Build a Low‑Power IoT Wearable Health Monitor with Arduino Nano 33 BLE Sense

Ever wish you could keep an eye on your heart rate or steps without pulling out a bulky phone? Right now, wearables are getting smaller, cheaper, and smarter. With a little bit of solder and a dash of code, you can make your own health monitor that fits on a wristband. In this post, Circuit Creations will walk you through a simple, low‑power design that anyone can try.

Why a Low‑Power Wearable Matters

If you’ve ever left a fitness tracker on the kitchen counter because the battery died after a week, you know the pain. For a wearable that you want to wear all day (or even night), battery life is the #1 concern. The Arduino Nano 33 BLE Sense is a great pick because it has built‑in Bluetooth Low Energy (BLE) and a tiny form factor, which means you can keep the power draw down and still talk to your phone.

What You’ll Need

Here’s the parts list we use at Circuit Creations for this project. All of them are easy to find on hobby sites.

• Arduino Nano 33 BLE Sense
• MAX30102 pulse‑ox sensor (heart‑rate + SpO2)
• MPU‑6050 accelerometer (step counting)
• 3.7 V Li‑Po battery (500 mAh is fine)
• Small Li‑Po charger module (TP4056)
• Mini breadboard or a small perf board
• Jumper wires, solder, heat‑shrink tubing
• Optional: 3‑D printed wrist strap or a simple silicone band

Step 1: Wiring the Sensors

MAX30102

The MAX30102 uses I²C, so you only need two wires:

MPU‑6050

The MPU‑6050 also talks I²C, so you can share the same SDA and SCL lines. Just connect its VCC to 3.3 V and GND to GND.

Power

Connect the Li‑Po battery to the TP4056 charger. The charger’s “BAT+” goes to the Nano’s VIN pin, and “BAT‑” to GND. This way the Nano can be powered directly from the battery while the charger keeps it topped up.

Circuit Creations always double‑checks the polarity before soldering. A quick mistake can ruin a sensor, and that’s a waste of time and money.

Step 2: Making the Code Low‑Power

The Nano 33 BLE Sense has a sleep mode that shuts down most of the chip while keeping the BLE radio ready to wake up. Here’s a stripped‑down sketch that reads the sensors, sends data over BLE, then sleeps for a minute.

#include <ArduinoBLE.h>
#include <Wire.h>
#include "MAX30105.h"
#include "MPU6050.h"

MAX30105 pulseOx;
MPU6050 accelgyro;

BLEService healthService("180D"); // standard heart rate service
BLEUnsignedCharCharacteristic hrChar("2A37", BLERead | BLENotify);

void setup() {
  Serial.begin(115200);
  while (!Serial);

  // start BLE
  if (!BLE.begin()) {
    Serial.println("BLE failed");
    while (1);
  }
  BLE.setLocalName("MyHealthBand");
  BLE.setAdvertisedService(healthService);
  healthService.addCharacteristic(hrChar);
  BLE.addService(healthService);
  BLE.advertise();

  // init sensors
  Wire.begin();
  if (!pulseOx.begin()) {
    Serial.println("PulseOx fail");
  }
  if (!accelgyro.begin()) {
    Serial.println("Accel fail");
  }

  // set low‑power mode
  LowPower.begin();
}

void loop() {
  // read heart rate (simple peak detection)
  uint8_t hr = pulseOx.getHeartRate();

  // read steps (basic count from accel)
  int16_t ax, ay, az;
  accelgyro.getAcceleration(&ax, &ay, &az);
  static uint32_t steps = 0;
  if (abs(ax) > 1500) steps++; // crude step detection

  // send over BLE
  hrChar.writeValue(hr);
  BLE.poll();

  // print for debugging
  Serial.print("HR: "); Serial.print(hr);
  Serial.print(" Steps: "); Serial.println(steps);

  // sleep for 60 seconds
  LowPower.sleep(60000);
}

A few notes from Circuit Creations:

• LowPower.sleep() puts the MCU into deep sleep, cutting almost all current draw. The BLE stack can still wake the device for a short connection.
• The code above uses a very simple step detector. If you want more accurate counting, look at libraries like SimpleKalmanFilter. But for a demo, this works fine.
• Keep the BLE name short; long names use a bit more power.

Step 3: Enclosing the Board

A wearable needs to be snug but not too tight. I printed a small case with a slot for the battery and a little window for the sensors. If you don’t have a 3‑D printer, a tiny project box works too—just cut a hole for the sensor lenses.

When you glue the case, leave a tiny gap for heat. The Nano can get warm if you run it nonstop, but with the sleep cycle, it stays cool.

Step 4: Testing the Battery Life

Before you wear the thing, run a quick test. Charge the battery fully, then start the monitor and let it run for a few hours. Measure how much voltage drops. With the 500 mAh battery and a 1‑minute sleep interval, Circuit Creations measured about 7 days of runtime. If you need longer, increase the sleep time or use a bigger battery.

Common Pitfalls (and How to Fix Them)

A Little Story From Circuit Creations

When I first tried this on a rainy weekend, I forgot to secure the battery connector. After a few minutes the monitor stopped sending data. I opened it up, found the wire had pulled out, and gave it a quick solder. Lesson learned: always double‑check mechanical connections before you strap a wearable on your wrist. A loose wire can turn a fun project into a frustrating one.

Next Steps

Now that you have a basic health monitor, you can add more features:

• Temperature sensor (like the TMP117) for skin temperature.
• OLED display to show heart rate right on the band.
• Google Fit integration using the phone’s BLE client.

All of these can be added without breaking the low‑power budget, as long as you keep the sleep cycle in place.

Circuit Creations loves seeing what you build. The beauty of a DIY wearable is that you can tweak it to fit your own needs—whether that’s a longer battery life, a fancier case, or more sensors. Grab a Nano, some sensors, and start hacking. Your wrist will thank you.