Step-by-step guide to designing your first Arduino wearable sensor

Ever wondered why your smartwatch can tell you how many steps you took, but you can’t make one yourself? The answer is simple – most people never try. In today’s maker‑friendly world, the tools are cheap, the tutorials are everywhere, and the bragging rights are priceless. Let’s turn that curiosity into a working wrist‑band that measures temperature, motion, or anything you like.

Why a wearable sensor?

Wearables are more than a fashion statement. They let you collect real‑world data right on your body – perfect for fitness tracking, health experiments, or even a secret “door‑open” alarm for your garage. Building one yourself means you pick the sensor, the power source, and the look. No hidden fees, no forced updates, just pure DIY satisfaction.

What you need

You can find most of these on a single online store, but I like to split the purchase between a local electronics shop (for the battery and wires) and a hobby site for the Arduino board. Keeps shipping costs low and supports the community.

Choosing the right sensor

The Arduino Nano 33 BLE Sense already packs a lot of sensors: temperature, humidity, pressure, light, and a 9‑axis IMU. If you only need one, you can ignore the rest and save power by disabling them in code. For a first project, I recommend starting with the IMU because it’s easy to see motion data on your computer and it works well for step counting or gesture detection.

If you need something more specific – say a heart‑rate pulse sensor – you can add a tiny MAX30102 module. It plugs into the board’s I2C pins (SDA, SCL) and talks the same way as the built‑in sensors, so you won’t have to learn a new protocol.

Wiring it up without a breadboard

Breadboards are great for testing, but they add bulk to a wearable. Here’s a quick way to go straight to a permanent layout:

1. Plan the trace path – Sketch a simple diagram on paper. Keep power lines short and group all sensor wires together.
2. Solder the Arduino – Use a fine‑tip iron and a little flux. The Nano’s pins are tiny, so a steady hand helps.
3. Attach the sensor – If you’re using the built‑in IMU, you’re done. For an external sensor, solder the SDA line to A4, SCL to A5, VCC to 3.3 V, and GND to ground.
4. Add the battery connector – A JST‑PH plug works well. Solder the positive lead to the board’s VIN pin (or the 3.3 V pin if you’re using a low‑voltage battery) and the negative lead to GND.
5. Secure with conductive thread – For a truly flexible circuit, stitch the connections through a piece of fabric using silver‑coated thread. It’s slower than solder, but the result bends like a normal shirt cuff.

Power management tricks

Wearables run on tiny batteries, so every milliamp counts. Here are three habits that saved me hours of debugging:

• Sleep mode – The Nano can enter a low‑power state when idle. Call LowPower.sleep() in your loop and wake up on an interrupt from the IMU.
• Turn off unused peripherals – If you’re not using the built‑in temperature sensor, disable it with sensor.disableTemperature().
• Use a voltage regulator with low quiescent current – A tiny MCP1700 drops the Li‑Po voltage to 3.3 V without draining the cell when the board is asleep.

Writing the code

Below is a minimal sketch that reads the IMU’s accelerometer and sends the data over Bluetooth Low Energy (BLE). You can view the numbers on any phone with a BLE scanner app.

#include <ArduinoBLE.h>
#include <Arduino_LSM9DS1.h>   // Built‑in IMU library

BLEService sensorService("180D"); // Custom service UUID
BLECharacteristic accelChar("2A37", BLERead | BLENotify, 6);

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

  if (!BLE.begin()) {
    Serial.println("BLE init failed!");
    while (1);
  }

  if (!IMU.begin()) {
    Serial.println("IMU init failed!");
    while (1);
  }

  BLE.setLocalName("MyWristSensor");
  BLE.setAdvertisedService(sensorService);
  sensorService.addCharacteristic(accelChar);
  BLE.addService(sensorService);
  BLE.advertise();

  Serial.println("Ready to stream data");
}

void loop() {
  // Put the board to sleep for 100 ms to save power
  LowPower.sleep(100);

  float x, y, z;
  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(x, y, z);
    int16_t data[3] = {
      (int16_t)(x * 1000),
      (int16_t)(y * 1000),
      (int16_t)(z * 1000)
    };
    accelChar.writeValue((uint8_t*)data, sizeof(data));
  }
}

A few notes for newcomers:

• BLE – Short for Bluetooth Low Energy. It’s the same tech that powers fitness bands. The code above creates a tiny “service” that other devices can read.
• IMU – Inertial Measurement Unit. It combines a tiny accelerometer, gyroscope, and magnetometer to sense motion.
• LowPower.sleep() – Pauses the CPU while keeping the BLE radio ready to wake on an event.

Compile and upload using the Arduino IDE, then open the Serial Monitor. You should see “Ready to stream data” and a steady flow of numbers when you move the board.

Building the wrist band

I printed a simple two‑piece band on a PLA printer. The inner piece holds the board and battery, the outer piece snaps on like a clasp. If you don’t have a printer, a silicone wrist band from a sports store works just as well – just cut a small pocket for the electronics.

When you stitch the band, leave a tiny opening for the battery to be swapped. I use a small Velcro tab; it’s cheap and lets me charge the board without unscrewing anything.

Testing in the real world

Before you wear your new gadget to a marathon, give it a quick “real‑world” test:

1. Battery life – Run the sensor for 12 hours and note the voltage drop. If it falls below 3.0 V, you need a bigger cell.
2. Signal reliability – Walk around a house with a phone nearby. If the BLE connection drops often, try moving the antenna (the tiny chip on the Nano) away from metal parts.
3. Comfort – Wear the band for a few hours while doing normal chores. If it feels too tight or the wires poke, adjust the strap or add a thin foam layer.

I once forgot to secure a loose wire and ended up with a “wiggle‑dance” every time I lifted my arm. Lesson learned: double‑check all connections before you strap it on.

Next steps

Now that you have a working sensor, the sky’s the limit:

• Add a small OLED screen – Show live data right on your wrist.
• Log data to an SD card – Perfect for long‑term experiments.
• Combine multiple sensors – Temperature + motion can create a “weather‑aware” fitness tracker.

Each addition teaches a new skill, and TechCraft Insights loves seeing what the community builds. Keep experimenting, keep sharing, and remember: the best projects start with a single solder joint and a lot of curiosity.