‭Aspect‬ ‭MANET (Mobile Ad Hoc‬ ‭WSN (Wireless Sensor Networks)‬

‭Networks)‬

‭Purpose‬ ‭General-purpose communication‬ ‭Application-specific sensing & reporting‬

‭Node Power‬ ‭High (laptops, PDAs)‬ ‭ ery limited (tiny battery-powered‬

V
‭devices)‬

‭Node Mobility‬ ‭ odes frequently move (e.g.,‬

N ‭ sually static; may track moving‬
U
‭soldiers, vehicles)‬ ‭phenomena or mobile sinks‬

‭Traffic Pattern‬ ‭Peer-to-peer (unicast, P2P)‬ ‭Many-to-one (sensor → sink)‬

‭Applications‬ ‭Voice, messaging, web access‬ E‭ nvironmental, health, industrial‬

‭monitoring‬

‭QoS Requirements‬ L‭ ow delay, jitter for voice,‬ ‭Event-driven reliability, energy-aware QoS‬
‭reliability‬

‭Deployment Scale‬ ‭Small to medium (10–100s nodes)‬ ‭Large (1000s+ nodes)‬

‭Node Importance‬ E‭ ach node is important and‬ S‭ ingle node failure is tolerable due to‬
‭powerful‬ ‭redundancy‬

‭Protocol Type‬ ‭Address-centric‬ ‭Data-centric‬

‭Traffic Behavior‬ ‭Continuous and predictable‬ L‭ ow traffic → sudden bursts (event‬

‭storms)‬

‭Energy Constraints‬ ‭Moderate, often rechargeable‬ ‭Severe; energy-saving is critical‬

‭Programmability‬ ‭Flexible, higher capability devices‬ ‭Constrained, simple logic only‬

‭Self-Configuring‬ ‭Required‬ ‭Required‬

‭Software Design‬ ‭Complex layers (e.g., TCP/IP stack)‬ ‭Lightweight, energy-optimized stack‬

‭Resource Needs‬ ‭Can support larger code/memory‬ ‭Must be highly optimized‬

‭📘‬‭Comparison: MANETs vs. WSNs‬

‭Aspect‬ ‭Fieldbus‬ ‭Wireless Sensor Network (WSN)‬

‭Medium‬ ‭Wired‬ ‭Wireless‬

‭Purpose‬ ‭Industrial control (real-time control loops)‬ ‭ onitoring and control (less strict‬
M
‭real-time)‬

‭Real-time Needs‬ ‭Very strict (millisecond precision)‬ L‭ ooser timing, tolerates some‬
‭delays‬

‭ etwork Layers‬
N ‭ nly layers 1 (physical), 2 (data link), and 7‬
O ‭ ses more layers, but simpler‬
U
‭Used‬ ‭(application)‬ ‭design‬

‭Error Handling‬ ‭Strong guarantees via wires‬ ‭Error-prone wireless links‬

‭Scalability‬ ‭Limited‬ ‭Highly scalable (1000s of nodes)‬

‭Energy Concern‬ ‭Not a concern (usually powered by mains)‬ E‭ xtremely important‬

‭(battery-powered)‬

‭Traffic Pattern‬ ‭Periodic polling, deterministic‬ ‭Event-driven, bursty traffic‬

‭Mobility‬ ‭None (fixed infrastructure)‬ S‭ upports static & mobile‬
‭scenarios‬

S‭ oftware‬ ‭Medium to high‬ ‭Lightweight and minimal‬

‭Complexity‬

‭Quick Points to Remember‬

‭●‬ ‭WSNs =‬‭Energy-aware‬‭,‬‭data-centric‬‭,‬‭scalable‬‭,‬‭adaptive‬‭,‬‭and‬‭cost-sensitive‬‭.‬

‭●‬ ‭MANETs =‬‭User-oriented‬‭,‬‭powerful devices‬‭,‬‭real-time‬‭communication‬‭,‬‭address-based‬‭.‬

‭●‬ ‭Fieldbus =‬‭Wired‬‭,‬‭real-time‬‭,‬‭industrial control‬‭,‬‭no energy limitation‬‭.‬

🌟
‭ Enabling Technologies for Wireless Sensor Networks (WSNs) –‬
‭Simple Notes‬
‭ ireless Sensor Networks became possible only because of‬‭many new technologies‬‭. Let’s understand‬
W
‭them one by one:‬

‭🔹 1. Miniaturization of Hardware‬

‭●‬ ‭Earlier, electronics were big and needed a lot of power.‬

‭●‬ ‭Now, chips (processors and memory) have become‬‭very‬‭small and cheap‬‭.‬
 ‭●‬ ‭Small size = less power = perfect for sensor nodes.‬

‭●‬ ‭Even the‬‭radios (used to send/receive data)‬‭now use‬‭very little energy.‬

‭👉 This helps to‬‭build tiny, cheap, and low-power‬‭sensor nodes‬‭.‬

‭🔹 2. Sensors‬

‭●‬ ‭Different WSNs need different types of sensors:‬

‭○‬ ‭Temperature, light, motion, sound, etc.‬

‭●‬ ‭It’s hard to say one type fits all — depends on the‬‭application‬‭.‬

‭👉 So, sensors are chosen based on what you want to measure.‬

‭🔹 3. Power Supply & Energy Harvesting‬

‭●‬ ‭Sensor nodes run on‬‭batteries‬‭.‬

‭●‬ ‭But batteries must:‬

‭○‬ ‭Last for a long time‬

‭○‬ ‭Provide small amounts of energy‬

‭○‬ ‭Be rechargeable (if possible)‬

‭●‬ ‭Sometimes, power comes from‬‭nature‬‭:‬

‭○‬ ‭Solar panels (sunlight)‬

‭○‬ ‭Vibration (from machines, wind, etc.)‬

‭👉 This is called‬‭energy scavenging‬‭— a way to‬‭get‬‭free power‬‭from the environment.‬

‭🔹 4. Software for WSNs‬

‭WSN nodes don’t just need hardware — they also need‬‭smart, light software‬‭to control how they work.‬

‭✅ a) Runtime Environment (Node Software)‬

‭●‬ ‭Needs to be:‬

‭○‬ ‭Simple and small‬

‭○‬ ‭Easy to update‬

‭○‬ ‭Flexible‬‭for new tasks‬

‭○‬ ‭Allow‬‭sharing of info‬‭between layers (cross-layer)‬

‭👉 Example:‬‭TinyOS‬‭– a special operating system for‬‭sensor nodes.‬

‭✅ b) Network Architecture‬

‭●‬ ‭Not just one node – the‬‭whole network‬‭must work well.‬

‭●‬ ‭Software should:‬

‭○‬ ‭Decide‬‭which node does what‬

‭○‬ ‭Help in‬‭data collection and processing‬

‭○‬ ‭Make it easy for developers to add features‬

‭✅ c) Communication Protocols‬

‭●‬ ‭Nodes must‬‭talk to each other‬‭using wireless communication.‬

‭●‬ ‭But we must:‬

 ‭○‬ ‭Save energy‬

‭○‬ ‭Avoid packet loss‬

‭○‬ ‭Work even if some nodes fail‬

‭👉 So, we need smart, energy-saving communication rules (called‬‭protocols‬‭).‬

‭📝 Simple Summary:‬
‭Technology‬ ‭Why it’s important‬

‭Mini Chips‬ ‭Small, cheap, low-power sensor hardware‬

‭Sensors‬ ‭Collect data from the real world‬

‭Batteries & Power‬ ‭Provide long-term energy‬

‭Energy Harvesting‬ ‭Get energy from sunlight or vibrations‬

‭Node Software‬ ‭Helps each sensor work and talk to others‬

‭Network Software‬ ‭Makes the whole network work together‬

‭Protocols‬ ‭Manage communication and save energy‬

‭📘 Chapter 2: Sensor Node Hardware – Simple Notes‬

‭🔶 2.1.1 Sensor Node Hardware Overview‬

‭Every‬‭sensor node‬‭in a Wireless Sensor Network (WSN)‬‭is like a mini computer. It has 5 main parts:‬

‭✅ 1. Controller‬

‭●‬ ‭This is the brain of the sensor node.‬

‭●‬ ‭It runs programs, processes data, makes decisions (like when to send data).‬

‭●‬ ‭Works like a tiny CPU.‬

‭✅ 2. Memory‬

‭●‬ ‭Stores sensor data temporarily (RAM) and stores programs (Flash or EEPROM).‬

‭●‬ ‭Flash memory is slow but saves energy.‬

‭✅ 3. Sensors & Actuators‬

‭●‬ ‭Sensors‬‭collect data from the environment (e.g., temperature,‬‭motion).‬

‭●‬ ‭Actuators‬‭control things (e.g., turn on light, sound‬‭alarm).‬

‭✅ 4. Communication Device‬

‭●‬ ‭Sends and receives data wirelessly.‬

‭●‬ ‭Connects the node to other nodes in the network.‬

‭✅ 5. Power Supply‬

‭●‬ ‭Usually a‬‭battery‬‭.‬

‭●‬ ‭Some nodes also use‬‭solar panels‬‭or‬‭vibration-based charging‬‭to get extra energy.‬
‭⚙️ Important Concepts‬

‭●‬ ‭Energy saving is critical‬‭– turn off parts (like the‬‭controller or radio) when not needed.‬

‭●‬ ‭Some sensors‬‭wake up the node‬‭only when an event occurs‬‭(e.g., motion detected).‬

‭●‬ ‭This helps‬‭save battery life‬‭.‬

‭🔶 2.1.2 Controller (Processor)‬

‭This is the part that controls everything in the sensor node.‬

‭Types of Controllers:‬

‭Type‬ ‭Use in WSN‬ ‭Pros‬ ‭Cons‬

‭Microcontroller‬ ‭Commonly used‬ L‭ ow power, flexible,‬ ‭ o memory‬

N
‭programmable‬ ‭protection‬

‭ SP (Digital Signal‬
D ‭Rarely used in WSNs‬ ‭ ood for heavy signal‬
G ‭ verkill, uses more‬
O
‭Processor)‬ ‭processing‬ ‭power‬
 ‭FPGA‬ ‭Used in specific cases‬ ‭Reconfigurable‬ S‭ lower to update,‬
‭more complex‬

‭ASIC‬ ‭ sed when tasks‬

U ‭Fast, energy efficient‬ ‭ ot flexible, costly to‬
N
‭don’t change‬ ‭design‬

‭Common Microcontrollers in WSNs:‬

‭1.‬ ‭Intel StrongARM‬

‭○‬ ‭High-end, powerful (used in PDAs)‬

‭○‬ ‭Not ideal for low-power WSNs‬

‭2.‬ ‭Texas Instruments MSP430‬

‭○‬ ‭16-bit processor, low power, good for embedded systems‬

‭3.‬ ‭Atmel ATmega 128L‬

‭○‬ ‭8-bit, very commonly used, easy to program, used in many WSN projects‬

‭🔶 2.1.3 Memory‬

‭Sensor nodes use‬‭different types of memory‬‭for storing‬‭programs and data.‬

‭Type‬ ‭Use‬ ‭Features‬

‭RAM‬ ‭Temporary data (sensor readings, messages)‬ F‭ ast, but loses data if power goes‬
‭off‬

‭Flash Memory‬ ‭Store program code and backup data‬ S‭ low, but retains data without‬
‭power‬
 ‭EEPROM‬ S‭ imilar to Flash, but slower and erased byte by‬ ‭Less used today‬
‭byte‬

‭✅ Important:‬

‭●‬ M
‭ emory must be‬‭just enough‬‭– not too much (wastes‬‭energy and cost), not too little (can’t run‬
‭properly).‬

‭●‬ ‭Memory needs change based on application.‬

‭🧠 Summary:‬
‭●‬ A
‭ ‬‭sensor node‬‭is made of 5 key parts: controller, memory, sensors/actuators, communication‬
‭device, and power.‬

‭●‬ ‭Microcontrollers‬‭are mostly used for WSNs due to low‬‭power and flexibility.‬

‭●‬ ‭Memory‬‭includes RAM for fast storage and Flash for‬‭long-term storage.‬

‭●‬ ‭The whole system must be‬‭designed for low energy use‬‭and‬‭reliability‬‭.‬

‭ bsolutely, Jaya! Let me now give you a better, clearer, and more structured explanation of‬
A
‭Communication Devices in Wireless Sensor Networks, especially focusing on transceiver operation,‬
‭states, advanced types, and examples, in a way that's easier to remember and ideal for writing‬
‭detailed answers in your exam.‬

‭📘 2.1.4 Communication Device – Better and Clearer‬

‭Explanation‬
‭🔶 What is a Communication Device?‬

‭●‬ ‭It’s the part of the sensor node responsible for sending and receiving data wirelessly.‬
 ‭●‬ ‭This is what turns individual nodes into a network so they can communicate.‬

‭●‬ ‭Most WSNs use wireless RF (Radio Frequency) communication because it:‬

‭○‬ ‭Works over long distances‬

‭○‬ ‭Doesn’t need line-of-sight‬

‭○‬ ‭Uses low power‬

‭🛰️ Transmission Media‬

‭WSNs can use different types of signals to transmit data:‬

‭Type‬ ‭Usefulness‬ ‭Comment‬

‭Radio Frequency (RF)‬ ‭✅ Most‬ ‭Works without needing direct‬

‭common‬ ‭line-of-sight‬

‭Optical (like IR or LED)‬ ‭❌ Not preferred‬ ‭Needs direct visibility, affected by‬
‭weather‬

‭Ultrasound‬ ‭⚠️ Sometimes‬ ‭Good in underwater environments‬

‭used‬

‭Magnetic Induction‬ ‭🧪 Very rare‬ ‭Used in specialized environments‬

‭📝 Conclusion: RF is best suited for most WSNs due to its reliability, range, and low energy use.‬
‭📻 Transceivers in WSNs‬
‭●‬ ‭A transceiver = Transmitter + Receiver‬

‭●‬ ‭Used to convert data (bits or bytes) into radio signals and vice versa.‬

‭●‬ ‭Usually half-duplex: cannot send and receive at the same time.‬

‭●‬ ‭A baseband processor handles the digital signals.‬

‭●‬ ‭The RF front end processes real-world analog signals (radio waves).‬

‭🔹 Key Features of a Good Transceiver‬

‭Feature‬ ‭Why it Matters in WSNs‬

‭Low Power Use‬ ‭Saves battery, increases node life‬

‭Fast Switching‬ ‭Quick transition between sleep/active states‬

‭Multiple Channels‬ ‭Reduces interference from other devices‬

‭Carrier Frequency‬ ‭Must be in allowed range (e.g. 2.4 GHz)‬

‭Modulation & Coding‬ ‭Affects data rate and reliability‬

‭RSSI Support‬ ‭Measures signal strength (used in routing or localization)‬

 ‭Receiver Sensitivity‬ ‭Helps pick up weak signals from far away‬

‭Transmission Power‬ ‭Lets the node adjust how strongly it sends signals to save‬
‭Control‬ ‭energy‬

‭⚙️ Transceiver Operating States‬

‭State‬ ‭What Happens‬ ‭Power‬

‭Use‬

‭Trans‬ ‭Sends data over the air‬ ‭High‬

‭mi‬
‭t‬

‭Receiv‬ ‭Listens for incoming data‬ ‭High‬

‭e‬

‭Idle‬ ‭Ready to receive, but not receiving‬ ‭Mediu‬

‭anything‬ ‭m‬

‭Sleep‬ ‭Most parts are turned off‬ ‭Very‬

‭low‬

‭📝 Smart WSN software switches between these states to balance energy and performance.‬

‭⚠️ Switching itself also uses power, so the transitions must be managed carefully.‬
‭🚀 Advanced Radio Concepts‬
‭✅ 1. Wake-Up Radio‬

‭●‬ ‭A small, always-on radio that only listens for wake-up signals.‬

‭●‬ ‭When a real packet comes, it activates the main transceiver.‬

‭●‬ ‭Saves energy during long periods of inactivity.‬

‭●‬ ‭Still under research; not common in real WSNs yet.‬

‭✅ 2. Spread Spectrum Transceivers‬

‭●‬ ‭Spread data over a wider frequency band to reduce interference.‬

‭●‬ ‭More secure and robust.‬

‭●‬ ‭❌ More expensive and complex → Not common in WSNs yet.‬

‭✅ 3. Ultra-Wideband (UWB) Communication‬

‭●‬ ‭Sends very short pulses over a wide range of frequencies.‬

‭●‬ ‭Advantages:‬

‭○‬ ‭High data rate (great for video or rapid sensing)‬

‭○‬ ‭Can measure distance accurately‬

‭○‬ ‭Works through walls‬

‭●‬ ‭❌ Requires very precise timing, expensive receivers‬

 ‭Type‬ ‭Example‬ ‭Use‬

‭Optical‬ ‭LED, laser‬ ‭Works if line-of-sight is available. Very low power. Example:‬
‭corner cube reflectors.‬

‭Ultrasou‬ ‭Used‬ ‭Useful when RF fails (e.g., in water or solid media)‬

‭nd‬ ‭underw‬
‭ater‬

‭✅ 4. Non-Radio Communication‬

‭Transceiver‬ ‭Features‬

‭RFM TR1000‬ ‭916 MHz band, low power, used in Mica motes‬

‭Chipcon CC1000‬ ‭Works between 300–1000 MHz, uses FSK‬

‭Chipcon CC2420‬ ‭First to support IEEE 802.15.4 (ZigBee), works at 2.4 GHz, data rate =‬
‭250 kbps‬

‭Infineon TDA5250‬ ‭ASK/FSK, energy-efficient, good for dense networks‬

‭Ember EM2420‬ ‭IEEE 802.15.4 compliant, works at 868/915/2400 MHz‬

 ‭National‬ ‭Used in early WSNs, high data rate (up to 1 Mbps)‬
‭LMX3162‬

‭Conexant‬ ‭Uses DSSS for interference resistance‬

‭RDSSS9M‬

‭🧪 Real-Life Examples of Transceivers in WSNs‬

‭📝 Summary to Write in Exam‬

I‭ n Wireless Sensor Networks (WSNs), the communication device is responsible for‬
‭sending and receiving data. Most WSNs use RF-based transceivers due to their energy‬
‭efficiency, decent range, and no need for line-of-sight.‬

‭ transceiver can be in one of four states: transmit, receive, idle, or sleep, with sleep‬
A
‭being the most energy-efficient.‬

‭ ew technologies like wake-up radios help save power by only activating the transceiver‬
N
‭when needed. Other advanced options include UWB and spread-spectrum‬
‭communication, though they are not widely used yet due to cost.‬

‭ opular transceivers used in real WSN projects include TR1000, CC1000, CC2420, and‬
P
‭TDA5250, each optimized for different needs like range, power, and modulation.‬

‭📘 2.1.5 Sensors and Actuators – Simple Explanation‬

‭🔷 What Are Sensors?‬

‭Sensors are the‬‭"eyes and ears"‬‭of a WSN. They collect‬‭data from the environment, like:‬

‭●‬ ‭Temperature‬
‭●‬ ‭Light‬

‭●‬ ‭Sound‬

‭●‬ ‭Vibration‬

‭●‬ ‭Chemicals‬

‭●‬ ‭Motion, etc.‬

‭🔹 Types of Sensors‬

‭Type‬ ‭Description‬ ‭Examples‬

✅
‭ ‬‭Passive,‬ ‭ o‬‭not‬‭send signals; they just‬
D T‭ hermometer, mic, light‬
‭Omnidirectional‬ ‭sense‬‭. Work in all directions.‬ ‭sensor, vibration sensor‬

✅
‭ ‬‭Passive,‬ S‭ ense only in a‬‭specific‬ ‭Camera‬
‭Narrow-Beam‬ ‭direction‬‭.‬

✅
‭ ‬‭Active‬ ‭ ctively‬‭probe‬‭the‬
A ‭ adar, sonar, seismic‬
R
‭Sensors‬ ‭environment.‬ ‭sensors‬

📝
‭ Most WSNs use‬‭passive, omnidirectional‬‭sensors‬‭because they are simple and‬
‭energy-efficient.‬

‭🔹 Sensor Coverage Concept‬

‭●‬ ‭Each sensor covers an area around it — called its‬‭“coverage radius.”‬

‭●‬ ‭Within this radius, the sensor gives‬‭good enough‬‭data.‬

‭●‬ ‭For example: temperature changes slowly, so one sensor can cover several meters.‬
 ‭🔷 What Are Actuators?‬

‭●‬ ‭Actuators are‬‭output devices‬‭.‬

‭●‬ ‭They allow the node to‬‭perform an action‬‭in the real‬‭world — like:‬

‭○‬ ‭Turning on a light‬

‭○‬ ‭Activating an alarm‬

‭○‬ ‭Opening a valve‬

‭●‬ ‭In WSNs, an actuator usually‬‭sets or resets‬‭something‬‭(like a switch).‬

✅
‭ ‬‭Good Practice‬‭: Always use a‬‭sensor + actuator pair‬‭.‬‭Example: If temperature rises, the actuator‬
‭starts a fan.‬

‭📘 2.1.6 Power Supply – Simple Explanation‬

‭🔷 Why Power Supply Is Crucial in WSNs?‬

‭●‬ ‭Most sensor nodes run on‬‭batteries‬‭.‬

‭●‬ ‭In many cases, you‬‭cannot recharge or replace‬‭the‬‭battery after deployment.‬

‭●‬ ‭So, power has to be used‬‭very carefully‬‭.‬

‭🔹 1. Storing Energy: Batteries‬

‭ atter‬
B ‭Recharg‬ ‭Example‬
‭y Type‬ ‭eable?‬
 ‭ rimar‬
P ‭❌ No‬ ‭Zinc-air, Alkaline‬
‭y‬

S‭ econ‬ ‭✅ Yes‬ L‭ ithium-ion, NiMH,‬

‭dary‬ ‭NiCd‬

‭📊 Energy Density (per cm³)‬

‭Battery‬ E‭ nergy‬
‭(J/cm³)‬

‭Zinc-air‬ ‭3780‬

L‭ ithium‬ ‭2880‬
‭(primary)‬

‭Alkaline‬ ‭1200‬

L‭ ithium‬ ‭1080‬
‭(rechargeable)‬

‭⚠️ Batteries must:‬

‭●‬ ‭Handle‬‭different loads‬

‭●‬ ‭Have‬‭low self-discharge‬

‭●‬ ‭Be‬‭efficient at low current charging‬

 ‭🔹 2. DC–DC Conversion‬

‭●‬ ‭As battery voltage drops, the node might not get enough power.‬

‭●‬ ‭A‬‭DC–DC converter‬‭keeps the output voltage constant.‬

‭●‬ ‭⚠️ But it also‬‭uses energy‬‭, so there's a trade-off.‬

‭🔹 3. Energy Scavenging (Harvesting from the Environment)‬

‭Instead of only relying on batteries, WSNs can‬‭generate‬‭power from nature‬‭:‬

‭Method‬ ‭How It Works‬ ‭ ower‬

P
‭ enerated‬
G

‭☀️‬‭Solar‬ ‭ onverts light into‬

C ‭ .006 – 15‬
0
‭electricity‬ ‭mW/cm²‬

🌡️
‭ ‬‭Thermal (Seebeck‬ ‭ ses temperature‬
U ‭~80 µW/cm²‬
‭effect)‬ ‭difference‬

‭🌀‬‭Vibration‬ ‭ ses mechanical‬

U ‭ p to 200‬
U
‭movement‬ ‭µW/cm³‬

‭💨‬‭Air/Water Flow‬ ‭Like tiny wind turbines‬ S‭ till‬

‭experimental‬

‭👣‬‭Human Power‬ ‭Piezo in shoes‬ ‭~330 µW/cm²‬

 ‭☢️‬‭Nuclear‬ ‭Tiny radioactive cells‬ ‭ 0 mW/cm³‬
8
‭(very rare)‬

‭📝 These scavenging methods often need a‬‭battery to‬‭store the power‬‭they generate over time.‬

‭🔹 Summary Table: Sensor Node Power Options‬

‭Source‬ ‭Best For‬ ‭Challenges‬

‭Battery‬ ‭Easy to use‬ L‭ imited life, no‬

‭recharge‬

‭Solar‬ ‭Outdoor use‬ ‭Depends on light‬

‭Vibration‬ ‭ achines,‬
M ‭Depends on motion‬
‭buildings‬

T‭ hermoel‬ ‭ ot/cold‬
H ‭ eeds temperature‬
N
‭ectric‬ ‭areas‬ ‭difference‬

‭ uman-p‬
H ‭ earable‬
W ‭Small power only‬
‭owered‬ ‭WSNs‬

‭Nuclear‬ L‭ ong-term,‬ ‭Expensive, risky‬

‭remote‬
 ‭✏️ Sample Answer You Can Write in Exam‬
‭ wireless sensor network is powered by batteries or external energy sources. Most nodes‬
A
‭use primary or rechargeable batteries.‬

T‭ o increase lifetime,‬‭energy scavenging‬‭methods like‬‭solar power, vibration harvesting, or‬

‭thermal gradients are used. However, these sources may not always provide enough or‬
‭stable power, so a‬‭battery + energy harvester‬‭combo‬‭is often used.‬

‭ ‬‭DC–DC converter‬‭is used to maintain a stable voltage.‬‭Power-aware design and smart‬

A
‭sleep-wake strategies are essential to extend battery life in WSNs.‬

‭📘 Slide 1: Controlling Transceivers (Power Management)‬

‭🔹 Why Control the Transceiver?‬

‭●‬ ‭Transceivers use a lot of‬‭energy‬‭, especially during‬‭idle listening‬‭.‬

‭●‬ ‭So, like the controller, we need a‬‭low duty cycle‬‭– keep it‬‭off as much as possible‬‭to save power.‬

‭✅ Key Points‬

‭🔹 Transmit Mode:‬

‭●‬ ‭Easy to manage.‬

‭●‬ S‭ imilar to controller: You know‬‭when you want to send‬‭,‬‭so you can‬‭turn it on only when‬
‭needed‬‭.‬

‭🔹 Receive Mode:‬
 ‭●‬ ‭Harder to manage‬‭because:‬

‭○‬ ‭You‬‭don’t know‬‭when someone else will send data.‬

‭○‬ ‭You must depend on‬‭remote nodes‬‭and‬‭MAC protocols‬‭to decide‬‭when to wake up‬‭.‬

‭●‬ ‭So, receivers may need to stay on‬‭longer‬‭, increasing‬‭energy use.‬

‭⚠️‬‭MAC protocol choice strongly affects power use‬‭.‬

‭🔹 Advanced Techniques (Like DVS but for Communication)‬

‭In processors,‬‭Dynamic Voltage Scaling (DVS)‬‭reduces‬‭power. Here are‬‭similar ideas‬‭for transceivers:‬

‭Technique‬ ‭What It Does‬

‭ ynamic Modulation Scaling‬

D ‭ hange modulation (e.g., ASK, FSK) based on‬‭channel quality‬‭to‬
C
‭(DSM)‬ ‭save energy‬

‭Dynamic Coding Scaling‬ ‭ hange‬‭coding rate‬‭(more or less redundancy) based on signal‬

C
‭conditions‬

‭Combinations‬ ‭Use both DSM + Coding Scaling together‬

‭But –‬‭these are hard to apply‬‭, so they’re‬‭limited‬‭in practice‬‭.‬

‭📘 Slide 2: Computation vs Communication – Energy Cost‬

‭⚡ Trade-Off: Compute or Communicate?‬

‭●‬ ‭Sending/receiving data‬‭costs way more power‬‭than computing.‬

‭●‬ ‭But‬‭how much more‬‭? The ratio can vary:‬

 ‭Sending‬‭1 bit‬‭= Computing‬‭220 to 2900 instructions‬

‭🧠 Example:‬

‭Sending 1 KB = Energy of‬‭3 million CPU instructions‬

‭✅ So, What’s the Lesson?‬

‭👉‬‭Compute locally‬‭instead of sending data whenever‬‭possible.‬

‭This means:‬

‭●‬ ‭Process and filter data‬‭within the node‬‭.‬

‭●‬ ‭Only send‬‭important or compressed‬‭data.‬

‭🔑 Key Technique: In-Network Processing‬

‭●‬ ‭Don’t send raw data – process it‬‭inside the network‬‭.‬

‭●‬ ‭Use:‬

‭○‬ ‭Compression‬

‭○‬ ‭Smart coding‬

‭○‬ ‭Aggregation‬

‭○‬ ‭Event detection at node level‬

‭Saves energy and reduces traffic.‬

‭📝 Final Summary for Exam‬

 I‭n WSNs, transceivers must use‬‭low duty cycles‬‭to‬‭save energy. While transmitters can‬
‭easily switch off,‬‭receivers depend on MAC protocols‬‭and are harder to manage‬‭.‬

‭ dvanced techniques like‬‭Dynamic Modulation Scaling‬‭help adjust communication based‬

A
‭on signal quality but are rarely used in real systems.‬

‭ ommunication is far more power-hungry than computation. Hence, WSNs rely on‬
C
‭in-network processing‬‭to compute and compress data‬‭before sending‬‭, extending battery‬
‭life and reducing network load.‬

📘
‭ Operating System Challenges in Wireless Sensor Networks‬
‭(WSN)‬

‭🔷 What’s the Problem?‬

‭In normal computers, the operating system (OS) helps by:‬

‭●‬ ‭Hiding hardware details (virtualization)‬

‭●‬ ‭Protecting resources from being used incorrectly (like memory protection)‬

🧠
‭ But in‬‭WSNs‬‭, we usually use‬‭microcontrollers‬‭—‬‭small, cheap, and power-efficient chips — which‬
‭don’t support these advanced OS features‬‭.‬

‭✅ Standard OS Features (NOT available in microcontrollers):‬

‭Feature‬ ‭Why it’s useful‬ ‭Why it’s missing in WSNs‬

‭Protected CPU modes‬ ‭ revent apps from crashing‬

P ‭ icrocontrollers don’t support‬
M
‭system‬ ‭it‬
 ‭ emory Management Unit‬
M ‭ ive each process its own safe‬
G T‭ oo expensive &‬
‭(MMU)‬ ‭memory‬ ‭power-hungry‬

‭Separate address space‬ ‭Isolate processes‬ ‭Not possible on tiny hardware‬

‭🔺 Main Challenges in WSN OS:‬

‭●‬ ‭Can’t use‬‭standard OS mechanisms‬‭.‬

‭●‬ ‭Must be‬‭very lightweight‬‭(low memory, low energy).‬

‭●‬ ‭WSN nodes usually run‬‭only one application‬‭, so full‬‭OS features aren’t needed.‬

‭📌 What are the Solutions?‬

‭Option 1: Try to Build a Mini OS‬

‭●‬ ‭Make the system‬‭look like a real OS‬‭(support processes,‬‭give known APIs).‬

‭●‬ ‭But:‬

‭○‬ ‭No process protection.‬

‭○‬ ‭More overhead (slow & power-consuming).‬

‭○‬ ‭Example: TinyOS or Contiki tries to do this.‬

‭Option 2: No OS at All!‬

‭●‬ ‭Just use a‬‭runtime environment‬‭:‬

‭○‬ ‭One application only → no need for isolation‬

‭○‬ ‭Application directly controls the hardware‬

 ‭○‬ ‭Efficient & simple‬

‭✅ What’s Commonly Done?‬

‭Most WSNs use‬‭no OS‬‭– just a‬‭tiny runtime‬‭.‬

‭Why?‬

‭●‬ ‭Reduces cost, power, and complexity‬

‭●‬ ‭Still allows easy hardware control‬

‭●‬ ‭But: programming becomes‬‭non-standard‬‭(unusual model)‬

‭📝 Sample Exam Answer:‬

T‭ raditional operating system features like protected modes, memory management, and‬
‭multitasking are not supported in WSN microcontrollers because they add cost and energy‬
‭usage.‬

T‭ herefore, WSNs either use a‬‭lightweight runtime‬‭or‬‭a‬‭minimal OS-like environment‬‭. Most‬

‭applications don’t need full OS features since a single app runs per node.‬

‭ opular solutions include skipping the OS and using a simple runtime system, or using‬
P
‭specialized lightweight OSes like TinyOS.‬
‭📘 1. What is Concurrency in WSN?‬
‭ oncurrency‬‭= Ability to‬‭handle multiple tasks at the same time.‬
C
‭For example, a WSN node might:‬

‭●‬ ‭Sense data‬

‭●‬ ‭Receive radio messages‬

‭●‬ ‭Process application logic‬

‭●‬ ‭Transmit packets‬

‭❌ Simple Option: Sequential Execution (No Concurrency)‬

‭1. Poll sensor‬

‭2. Process sensor data‬

‭3. Poll transceiver‬

‭4. Process received packet‬

‭(Repeat)‬

‭🧠‬‭Problem:‬

‭●‬ ‭What if a‬‭radio packet arrives‬‭while the node is‬‭processing‬‭sensor data‬‭?‬

‭●‬ ‭That packet could be‬‭lost‬‭because the radio was not‬‭checked in time!‬

‭✅‬‭Conclusion‬‭: We need‬‭concurrent execution‬‭to avoid‬‭missing important events.‬

‭📘 2. Traditional Concurrency Model: Processes/Threads‬

‭In regular operating systems (like Windows or Linux):‬
 ‭●‬ ‭Processes/Threads‬‭are used for concurrency.‬

‭●‬ ‭The OS uses:‬

‭○‬ ‭Interrupts‬

‭○‬ ‭Context Switching‬

‭○‬ ‭Separate memory (via MMU)‬

‭But in WSNs, we face a‬‭Concurrency Mismatch‬‭:‬

‭Issue‬ ‭Why it's a Problem in WSN‬

‭Context switching‬ ‭Too costly for small tasks‬

‭Process protection‬ ‭Not needed (only 1 app runs)‬

‭Memory usage‬ ‭Too high for microcontrollers‬

‭🔴 Visual: Process Switching (Too Much Overhead)‬

‭Sensor task ———————————‬

‭↳ Context switch‬

‭Packet task ———————————‬

‭↳ Context switch‬

‭Sensor task ———————————‬

‭📌‬‭So traditional processes/threads are NOT a good‬‭fit for WSNs.‬

‭📘 3. Better Model: Event-Based Concurrency‬

‭Instead of switching between processes…‬

‭👉 React to events when they happen using‬‭event handlers‬‭.‬

‭🔹 What is an Event?‬

‭●‬ ‭External or internal‬‭triggers‬‭(like a sensor value, timer, or packet received).‬

‭🔹 Two Execution Modes:‬

‭1.‬ ‭Idle / Regular execution‬‭– when nothing important‬‭is happening‬

‭2.‬ ‭Interrupt / Event handler‬‭– when something happens‬‭(e.g., sensor/radio interrupt)‬

‭✅ Run-to-Completion Principle‬

‭●‬ ‭When an event handler starts → it‬‭runs to the end‬‭without interruption.‬

‭●‬ ‭This avoids complexity and‬‭ensures reliability‬‭.‬

📌
‭ ‬‭Don’t do heavy processing inside the event handler.‬
‭Just:‬

‭●‬ ‭Save data‬

‭●‬ ‭Signal the main program‬

‭●‬ ‭Exit quickly‬

‭🔵 Visual: Event Handling Flow‬

‭Sensor event ───▶ Sensor handler ───▶ Save data ▶ Exit‬

‭Radio event ───▶ Radio handler ───▶ Store packet ▶ Exit‬

‭📘 4. Components Instead of Processes (TinyOS Style)‬
‭TinyOS does not use threads or full processes. Instead, it uses‬‭components‬‭.‬

‭🔸 What is a Component?‬

‭●‬ ‭A‬‭small module‬‭that performs‬‭one specific task‬

‭●‬ ‭Example: One for ADC, one for radio, one for timer, etc.‬

‭🔹 Key Differences from Processes‬

‭Processes‬ ‭Components‬

‭Have their own memory‬ ‭Share same memory‬

‭Context switch needed‬ ‭Event-based‬

‭Expensive‬ ‭Lightweight‬

‭General-purpose‬ ‭Task-specific‬

‭🧠 Components‬‭don’t “run”‬‭— they are just‬‭event handlers‬‭or‬‭functions‬‭.‬

‭📘 5. API for Event-Based Protocol Stack‬

‭❌ Traditional API: Sockets‬

‭●‬ ‭In regular OS,‬‭sockets‬‭are used for networking:‬

‭○‬ ‭App‬‭waits (blocks)‬‭until data arrives.‬

‭●‬ ‭Problem:‬‭Blocking is wasteful in WSNs (wastes energy‬‭and time)‬

‭✅ Better: Event-Based API‬

‭●‬ ‭WSN uses‬‭non-blocking communication‬‭.‬

‭●‬ ‭When data arrives, the system‬‭posts an event‬‭to the‬‭right component.‬

‭🔹 Example:‬

‭"If a radio packet is received, wake up the radio handler component."‬

‭So the‬‭event-driven model‬‭is used throughout:‬

‭●‬ ‭No blocking‬

‭●‬ ‭Low energy‬

‭●‬ ‭Responsive‬

‭📝 Final Summary for Exams‬

‭ ireless sensor nodes must handle multiple functions like sensing, receiving radio data,‬
W
‭and processing application logic — this requires‬‭concurrency‬‭.‬

T‭ raditional OS methods (processes, threads) are too heavy for WSNs due to memory and‬
‭power constraints. Instead, WSNs use an‬‭event-driven‬‭model‬‭, where the system reacts to‬
‭events‬‭like sensor readings or radio inputs using‬‭handlers‬‭.‬

T‭ hese handlers run to completion without interruption. Instead of full processes, TinyOS‬
‭uses‬‭lightweight components‬‭, which respond to events.‬

T‭ o match this model, WSNs use‬‭event-based APIs‬‭rather‬‭than blocking sockets, improving‬

‭energy efficiency and real-time responsiveness.‬

‭✅ Key Terms Recap:‬

 ‭Term‬ ‭Meaning‬

‭Concurrency‬ ‭Doing multiple tasks at once‬

‭Run-to-completion‬ ‭Event handler runs fully before ending‬

‭Component‬ ‭TinyOS unit of functionality (not a full process)‬

‭Event handler‬ ‭Reacts to sensor/radio input‬

‭Event-based API‬ ‭No blocking, actions triggered by events‬

‭📘 Dynamic Power Management (DPM)‬

‭ ynamic Power Management means‬‭intelligently controlling‬‭how and when a node uses power‬‭,‬
D
‭especially switching between different‬‭operation modes‬‭(active, idle, sleep) to‬‭maximize energy‬
‭efficiency‬‭while still meeting performance goals.‬

‭🔹 Why Use DPM?‬

‭●‬ ‭Sensor nodes run on‬‭limited battery‬‭.‬

‭●‬ ‭If we‬‭keep everything on‬‭, the battery dies quickly.‬

‭●‬ ‭If we‬‭turn off too often‬‭, we may‬‭miss important events‬‭.‬

‭✅ So, we‬‭dynamically adjust‬‭power usage‬‭based on need‬‭.‬

‭⚡ Key Ideas in DPM‬

‭🔷 1. Exploiting Multiple Operating Modes‬

‭Modern microcontrollers and radios support‬‭different‬‭energy states‬‭, such as:‬

‭●‬ ‭Active mode‬‭(fully on, high power)‬

‭●‬ ‭Idle mode‬‭(CPU off, memory on)‬

‭●‬ ‭Sleep mode‬‭(almost everything off)‬

‭🧠 Idea: Stay in‬‭low-power mode‬‭as much as possible‬‭and‬‭wake up only when needed‬‭.‬

‭❓ Question: When to go to sleep?‬

‭✅ The Challenge:‬

‭●‬ ‭Every‬‭wake-up‬‭takes‬‭time and energy‬‭.‬

‭●‬ ‭If you sleep too often ("greedy sleeping"), you may‬‭waste more energy‬‭by waking up repeatedly.‬

‭🔧 Solution: Smart Scheduling‬

‭●‬ ‭Use algorithms to‬‭decide sleep/wake times‬‭.‬

‭●‬ ‭Schedule tasks in a way that‬‭minimizes unnecessary‬‭wake-ups‬‭.‬

‭🔷 2. Dynamic Voltage Scaling (DVS)‬

‭DVS = Adjusting‬‭voltage and clock speed‬‭dynamically‬

‭●‬ ‭Lower speed → Lower power → Longer task time‬

 ‭●‬ ‭Higher speed → More power → Finish task faster‬

‭🧠 Use‬‭DVS‬‭to‬‭meet deadlines‬‭while saving energy.‬

‭❓ When to change voltage/speed?‬

‭●‬ ‭If the task has a‬‭loose deadline‬‭, run it‬‭slower‬‭to‬‭save energy.‬

‭●‬ ‭If a‬‭deadline is near‬‭, increase speed.‬

‭⚠️ Increasing voltage/speed is easy, but it‬‭consumes‬‭more energy‬‭.‬

‭🔷 3. Fidelity vs. Energy Trade-Off‬

‭Some applications (e.g., sensing, math processing) don’t always need‬‭high accuracy‬‭.‬

‭👉 Use‬‭less accurate but faster‬‭computations when‬‭battery is low.‬

‭🔬 Example: Polynomial Approximation‬

‭●‬ ‭For evaluating a mathematical function:‬

‭○‬ ‭Use fewer polynomial terms = faster = less accurate = less energy‬

‭○‬ ‭Use more terms = slower = more accurate = more energy‬

✅
‭ When more energy is available → use higher accuracy‬
❌
‭ Low energy → accept lower precision‬

‭📝 Final Summary for Exams:‬

‭ ynamic Power Management in WSNs involves using‬‭low-power‬‭states‬‭,‬‭dynamic voltage‬
D
‭scaling‬‭, and‬‭fidelity trade-offs‬‭to conserve energy.‬

S‭ cheduling‬‭is used to decide‬‭when to sleep‬‭without missing data.‬

‭DVS‬‭allows running tasks slower or faster depending on energy and deadline constraints.‬
 I‭n some cases,‬‭application accuracy‬‭can be traded for energy, such as using a lower-order‬
‭polynomial for faster calculations when energy is low.‬