---
title: Build a Low‑Power IoT Wearable Health Monitor with Arduino Nano 33 BLE Sense
siteUrl: https://logzly.com/circuitcreations
author: circuitcreations (Circuit Creations)
date: 2026-06-26T11:00:44.883309
tags: [health, iot, wearable]
url: https://logzly.com/circuitcreations/build-a-lowpower-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:

| Pin on MAX30102 | Arduino Nano 33 BLE Sense |
|-----------------|----------------------------|
| VIN             | 3.3 V (do NOT use 5 V)      |
| GND             | GND                        |
| SDA             | A4 (SDA)                   |
| SCL             | A5 (SCL)                   |

### 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.

```cpp
#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)

| Problem | Fix |
|---------|-----|
| No BLE connection | Make sure the Nano is advertising (`BLE.advertise()`) and your phone’s Bluetooth is on. |
| Sensor reads always 0 | Verify you’re powering the sensors with 3.3 V, not 5 V. |
| Battery drains fast | Check you didn’t leave the LED on the Nano (the little “L” next to the USB). Turn it off with `pinMode(LED_BUILTIN, INPUT);` |
| Steps count too high | The crude accelerometer threshold may pick up arm swings. Adjust the threshold value (`1500` in the code) or add a debounce timer. |

## 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.