Kabelloser EKG-Herzfrequenz-Monitor: Wearable-Design mit Arduino Nano & nRF24

Komponenten und Materialien

Benötigte Werkzeuge und Maschinen

• Lötkolben (Standard)

Projektbeschreibung

Dies ist die zweite Iteration meines Herzmonitoring-Projekts. Die erste Version zeigte Herzschläge auf der Brust, war aber per Kabel mit dem uECG verbunden – unpraktisch: Man sieht die LEDs schlecht, sie liegen außerhalb des Sichtfelds, und das Kabel stört den Sensor beim Laufen.

Diese Version löst alle Probleme: Handgelenk-getragen (im Blickfeld beim Laufen), kabellos (keine Signalverfälschung), funktioniert beim Joggen und zeigt die Herzlast zuverlässig an.

1. Komponenten

Wie beim Vorgänger übernimmt der uECG die schwere Arbeit: Messung und BPM-Berechnung on-board. Im „Direct Link Mode“ sendet er Daten (inkl. hochauflösendem EKG, hier ungenutzt) via nRF24-kompatiblem Protokoll. Zweite kritische Komponente: nRF24-Modul. Arduino Nano passt perfekt unter den LED-Ring und dient als Controller.

2. Schaltung

nRF24-Anschluss ist aufwendig: Alle SPI-Leitungen (MISO, MOSI, SCK, CS), Chip Enable, Versorgung. Für kompakte Bauweise: Pin-Header entfernen, Drähte direkt auf Pads löten – 7 Drähte, 14 Lötstellen. Der Rest ist einfach: LED-Ring (1 Data + 2 Power), Akku (2 Power).

Verbindungsliste:

• nRF24 Pin 1 (GND) → Arduino GND
• nRF24 Pin 2 (VCC) → Arduino 3,3 V
• nRF24 Pin 3 (CE) → Arduino D9
• nRF24 Pin 4 (CSN) → Arduino D8
• nRF24 Pin 5 (SCK) → Arduino D13
• nRF24 Pin 6 (MOSI) → Arduino D11
• nRF24 Pin 7 (MISO) → Arduino D12
• LED-Ring VCC → Arduino 5 V
• LED-Ring GND → Arduino GND
• LED-Ring DI → Arduino D5
• Akku + → Arduino 5 V
• Akku – → Arduino GND
• (Akku mit Stecker für Laden/Entnehmen)

Wichtig: MOSI, MISO, SCK müssen an D11, D12, D13 (Hardware-SPI). Andere Pins sind änderbar (mit Code-Anpassung).

3. Programm

Die einzige Software-Herausforderung: RF-Kanal-Konfiguration. uECG und nRF24 nutzen unterschiedliche Bit-Reihenfolge für die Pipe-Adresse. Nach Korrektur lief alles sofort. Ablauf: Pakete empfangen, 5. Byte = BPM, filtern (Kanal rauschend, CRC deaktiviert für Kompatibilität). BPM → Farbe & Anzahl aktiver Pixel.

#include 
#ifdef __AVR__
#include 
#endif
#include 
#include 
#include 
#include 

int rf_cen = 9; // CE
int rf_cs = 8;  // CSN
RF24 rf(rf_cen, rf_cs);

// Pipe-Adresse (hardcoded im uECG) – Bit-Reihenfolge vertauscht!
uint8_t pipe_rx[8] = {0x0E, 0xE6, 0x0D, 0xA7, 0, 0, 0, 0};

#define PIN 5
#define NUMPIXELS 16
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

// Bit-Reihenfolge umkehren (uECG vs nRF24)
uint8_t swapbits(uint8_t a) {
  uint8_t v = 0;
  if(a & 0x80) v |= 0x01;
  if(a & 0x40) v |= 0x02;
  if(a & 0x20) v |= 0x04;
  if(a & 0x10) v |= 0x08;
  if(a & 0x08) v |= 0x10;
  if(a & 0x04) v |= 0x20;
  if(a & 0x02) v |= 0x40;
  if(a & 0x01) v |= 0x80;
  return v;
}

void setup() {
  pixels.begin();
  for(int i=0;i 0) rf_bpm = bb;
  }

  long ms = millis();
  if(ms - last_pix_upd > 10) { // Pixel nicht zu oft updaten
    int r, g, b;
    last_pix_upd = ms;
    int bpm = rf_bpm;
    int max_bright = 160; // max 255, aber blendfrei
    float dd = 25; // BPM-Schritt pro Farbton
    float t1 = 90, t2, t3, t4; // t1 = Basis-BPM (darunter = blau)
    t2 = t1 + dd; t3 = t2 + dd; t4 = t3 + dd;

    // Farbverlauf: blau → grün → gelb → pink → rot
    if(bpm < t1) { r=0; g=0; b=max_bright; }
    else if(bpm < t2) { r=0; g=max_bright*(bpm-t1)/dd; b=max_bright-g; }
    else if(bpm < t3) { r=max_bright*(bpm-t2)/dd; g=max_bright-r; b=r/4; }
    else if(bpm < t4) { r=max_bright; g=0; b=max_bright/2 - max_bright*(bpm-t3)/(2*dd); }
    else { r=max_bright; g=0; b=0; }

    int on_pixels = (bpm-80)/8; // Anzeige ab 80 BPM (für Sport)
    for(int i=0;i

4. Armband-Montage

Nach dem Löten, Flashen und Test (uECG-Daten empfangen?) alles zusammenbauen.

Einfache Methode: Heißkleber. Teile passen fast perfekt (Nano in äußeren Ring, nRF24 in inneren Ring, Akku irgendwie dazwischen – funktioniert erstaunlich gut). Auf ein altes Handgelenkband (von Lötstation, ESD-Band) genäht – fertig!

5. Praxistest

Beim Joggen getestet – funktionierte tadellos. Eine Überraschung: Ich hatte 192 BPM als Maximum eingestellt (alle LEDs an), was laut Empfehlungen zu hoch für meine Parameter ist. Ich überschritt es nach wenigen Minuten, ohne es zu merken. Kein Sensorfehler – beim Stoppen sank der Wert langsam (Sensor zuverlässig bei wenig Bewegung).

Frage: Ist mein Maximalpuls durch Jugend-Herzbeschwerden verschoben, oder trainiere ich unwissentlich zu hart? Lösung: Max-BPM im Monitor erhöhen oder Training reduzieren.

P.S. uECG funktioniert überraschend gut als EMG-Sensor – siehe mein „Robotic Hand Control“-Projekt.

Code

bpm_watch.ino (Arduino)

#include 
#ifdef __AVR__
#include 
#endif
#include 
#include 
#include 
#include 

int rf_cen = 9;
int rf_cs = 8;
RF24 rf(rf_cen, rf_cs);
uint8_t pipe_rx[8] = {0x0E, 0xE6, 0x0D, 0xA7, 0, 0, 0, 0};
#define PIN 5
#define NUMPIXELS 16
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

uint8_t swapbits(uint8_t a) {
  uint8_t v = 0;
  if(a & 0x80) v |= 0x01;
  if(a & 0x40) v |= 0x02;
  if(a & 0x20) v |= 0x04;
  if(a & 0x10) v |= 0x08;
  if(a & 0x08) v |= 0x10;
  if(a & 0x04) v |= 0x20;
  if(a & 0x02) v |= 0x40;
  if(a & 0x01) v |= 0x80;
  return v;
}

void setup() {
  pixels.begin();
  for(int i=0;i 0) rf_bpm = bb;
  }
  long ms = millis();
  if(ms - last_pix_upd > 10) {
    int r, g, b;
    last_pix_upd = ms;
    int bpm = rf_bpm;
    int max_bright = 160;
    float dd = 25;
    float t1 = 90, t2 = t1+dd, t3 = t2+dd, t4 = t3+dd;
    if(bpm < t1) { r=0; g=0; b=max_bright; }
    else if(bpm < t2) { r=0; g=max_bright*(bpm-t1)/dd; b=max_bright-g; }
    else if(bpm < t3) { r=max_bright*(bpm-t2)/dd; g=max_bright-r; b=r/4; }
    else if(bpm < t4) { r=max_bright; g=0; b=max_bright/2 - max_bright*(bpm-t3)/(2*dd); }
    else { r=max_bright; g=0; b=0; }
    int on_pixels = (bpm-80)/8;
    for(int i=0;i

Schaltpläne

Kein separates Dokument.

nrf24_led_ring_o2Gij5oigT.fzz (Fritzing-Datei)

Live-Daten-Plot auf Arduino Mega: TFT-LCD-Historie mit DHT11-Sensor IoT-Smart-Straßenbeleuchtung: Intelligentes, energieeffizientes LED-System