Low-Power Sensor Node

Learning Goals 5 min

Combine sleep modes (L04-37) and battery selection (L04-38) into the classic IoT field-device pattern: wake, sample, transmit, sleep. The complete blueprint for any battery-powered sensor that needs to last months or years. By the end of this lesson you will:

1. Implement the wake / sample / transmit / sleep cycle on a Pro Mini + sensor + radio.
2. Power down all peripherals between cycles (sensor + radio + chip) for true µA average draw.
3. Estimate runtime from measured current samples and pick the right wake interval for your use case.

Warm-Up 10 min

Hardware: Pro Mini 3.3 V (or any low-power AVR), DHT22 (or similar), nRF24 / RFM69 / LoRa radio, battery + monitor.

The pattern

while forever:
  wake from sleep
  power on the sensor (MOSFET switch)
  read sensor (~20 ms)
  power off sensor
  power on the radio
  publish (~50 ms)
  power off radio
  sleep for the configured interval

Each cycle takes ~100 ms of active time. Sleep takes 15 min – 1 hour depending on application. Active time is 0.005–0.01% of the cycle. Average current drops from ~30 mA to ~50 µA.

New Concept · The wake/sample/transmit cycle 25 min

Switching peripherals via MOSFET

Many sensors draw 1–5 mA even when idle. Cutting their power in sleep saves a lot. Use a P-channel MOSFET on the high side: GPIO HIGH = peripheral off; LOW = on.

Wiring:

• Battery + → P-MOSFET source.
• MOSFET drain → sensor V_CC.
• MOSFET gate → 10 kΩ pull-up to battery + + Arduino GPIO.

The structured loop

#include <LowPower.h>

const int SENSOR_POWER = 5;       // MOSFET gate (LOW = on)
const int RADIO_POWER  = 6;

const int WAKES_PER_SAMPLE = 7;   // 7 × 8 s ≈ 56 s; or 450 × 8 s ≈ 1 hour

int batteryThreshold = 3300;       // mV

void sleepInterval() {
  for (int i = 0; i < WAKES_PER_SAMPLE; i++) {
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
  }
}

void wakeAndDoWork() {
  // 1. Sensor on
  digitalWrite(SENSOR_POWER, LOW);
  delay(50);                       // sensor wake-up time
  // 2. Sample
  float temp = readTemperatureSensor();
  // 3. Sensor off
  digitalWrite(SENSOR_POWER, HIGH);

  // 4. Battery check
  int vbat = readBatteryVoltage_mV();
  if (vbat < batteryThreshold) {
    // refuse to transmit if battery is low
    return;
  }

  // 5. Radio on
  digitalWrite(RADIO_POWER, LOW);
  delay(20);                       // radio warm-up
  radio.begin();
  radio.send(makePacket(temp, vbat));
  radio.end();
  digitalWrite(RADIO_POWER, HIGH);
}

void setup() {
  pinMode(SENSOR_POWER, OUTPUT);
  pinMode(RADIO_POWER,  OUTPUT);
  digitalWrite(SENSOR_POWER, HIGH);
  digitalWrite(RADIO_POWER,  HIGH);
}

void loop() {
  wakeAndDoWork();
  sleepInterval();
}

Pre-wake checks

Sometimes you want to do nothing if conditions aren't right. Common pre-wake gates:

• V_BAT too low → skip transmit, only beep low-batt warning.
• Sensor reading hasn't changed significantly → skip transmit (saves more battery, fewer packets to the gateway).
• Time of day (e.g. 9 PM – 7 AM "sleep mode" — only one reading per hour).

Reducing transmit cost

The radio is usually the biggest energy sink. Strategies:

• Higher SF on LoRa = longer per-packet time but longer range. Pick based on coverage.
• Compress payloads. Send a 4-byte struct, not a 30-byte JSON.
• Send only on change. Cache last sent value; transmit when delta exceeds threshold.
• Aggregate. Sample 12 times an hour, send hourly with 12 values.

Worked Example · Build a 2-year temperature logger 25 min

Bill of materials

• Pro Mini 3.3 V (~3 mA active, ~3 µA deep sleep).
• DHT22 (~1 mA active, draws ~0 µA off).
• RFM69CW LoRa-like radio (~30 mA tx peak, ~0.1 µA off).
• P-MOSFET (SI2333DDS or similar).
• 3 × AA NiMH (3.6 V, 2500 mAh).

Math

• Active per cycle: 100 ms × ~30 mA ≈ 0.8 µAh.
• Sleep per cycle: ~3 µA × 15 minutes = 0.75 µAh.
• Per cycle total: 1.5 µAh.
• Cycles per year: 365 × 24 × 4 = 35040.
• Per year: 35040 × 1.5 µAh = 53 mAh.

2500 mAh / 53 mAh per year = 47 years. Battery shelf life will limit you to ~10 years long before capacity is consumed.

Real-world results

Reality is messier: leak currents, parasitic loads, charge inefficiency on the boost regulator. Field deployments of this pattern typically last 2–5 years on AA cells. That's still phenomenal — battery becomes the device's effective lifetime.

Verify in practice

1. Measure µA in sleep.
2. Measure mA during active cycle + duration.
3. Compute weighted average.
4. Divide battery mAh by average → years of life.

Basic 5 min

Challenge 1 5 min

Challenge 2 5 min

Challenge 3 · Estimate one of your project's runtime 10 min

1. Pick a battery project.
2. Measure active mA + duration per cycle.
3. Measure sleep mA + duration per cycle.
4. Compute weighted average.
5. Divide battery mAh by average → years.
6. Compare to the naive "always running" estimate.

Recap 5 min

Low-power sensor node = wake-sample-transmit-sleep with peripherals MOSFET-switched. Average current in µA, runtime in years. The pattern of every commercial battery-powered IoT device. Tomorrow we add solar and the device runs forever.

Wake/sample/transmit/sleep cycle

The four phases of a low-power node. Active 0.01–1% of the time; sleep the rest.

Peripheral power gating

Using a MOSFET to cut power to sensors / radios when not in use.

P-channel MOSFET (high-side switch)

Switches V_CC to a peripheral. Gate held HIGH = off; LOW = on. Cheap, low loss.

Sensor wake-up time

How long after power-on before a sensor gives valid readings. DHT22 ~50 ms; BMP280 ~10 ms.

Send-on-change

Transmit only when the value differs significantly from the last sent value. Reduces radio time.

Field-device pattern

The industry-standard low-power node template. Sleep most of the time; do work briefly; sleep again.

Extra Mission 5 min

Part 1 — Design a sensor node for a place nobody visits

Some sensors live where nobody checks them for months. On paper, design a node for one such place. It might be a school garden bed, a bird box or a shed.

Your design must include:

• What it measures, and how often.
• How the data leaves the node, and how often it sends.
• Which parts are switched off between readings, and how.
• The battery, and your estimate of how many months or years it lasts.

Part 2 — Make it

Build the core wake–measure–sleep cycle. Power your sensor through a MOSFET so it is fully off while the chip sleeps. Wake, switch the sensor on, read it, print the value, switch it off, sleep. Measure the current in both states and work out the battery life.

Bring back next class: your uploaded sketch, a photo of the circuit and your current readings with the battery-life calculation.