Echtzeit-EKG-Darstellung auf OLED mit Arduino UNO

Komponenten und Materialien

Projektbeschreibung

Der Autor hatte zuvor Projekte mit dem uECG-Gerät veröffentlicht, aber der Code war unübersichtlich. Nun stellt er eine Arduino-Bibliothek (uECG_library) bereit, die die Kommunikation stark vereinfacht. Benötigt werden zusätzlich: RF24 (Library Manager) und Adafruit_SSD1306 für das OLED.

1. Schaltung

• nRF24 an SPI: D13 (SCK), D12 (MISO), D11 (MOSI), D10 (CS), D9 (CE).
• Wichtig: nRF24 an 3,3 V anschließen (nicht 5 V!). 1–10 µF Kondensator zwischen 3,3 V und GND empfohlen (stabile Spannung).
• OLED an I²C: SDA → A4, SCL → A5, VCC an 5 V. Meist sind Pull-Up-Widerstände (4,7 kΩ) auf dem Modul bereits vorhanden.

2. Code (Beispiel aus der Library)

#include <uECG.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

int rf_cen = 9; // nRF24 CE
int rf_cs = 10; // nRF24 CS

void setup() {
  Serial.begin(115200);
  while(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
  }
  display.display(); delay(100);
  uECG.begin(rf_cs, rf_cen);
  delay(100);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.cp437(true);
  display.display(); delay(100);
  Serial.println("after display");
}

uint32_t prev_data_count = 0, prev_displ = 0;
uint8_t ecg_screen[128];
int ecg_screen_len = 128;
float ecg_avg = 0, ecg_max = 1, ecg_min = -1;
int ecg_size = 40;
int displ_phase = 0;

void loop() {
  uECG.run(); // muss so oft wie möglich aufgerufen werden!
  uint32_t data_count = uECG.getDataCount();
  int new_data = data_count - prev_data_count;
  prev_data_count = data_count;

  if(new_data > 0) {
    uint32_t ms = millis();
    int16_t ecg_data[8];
    uECG.getECG(ecg_data, new_data);
    for(int x = 0; x < new_data; x++) Serial.println(ecg_data[x]);

    // Ringbuffer für Display verschieben
    for(int x = new_data; x < ecg_screen_len; x++)
      ecg_screen[x - new_data] = ecg_screen[x];
    for(int x = 0; x < new_data; x++) {
      ecg_avg *= 0.99; ecg_avg += 0.01 * ecg_data[x];
      ecg_max = ecg_max * 0.995 + ecg_avg * 0.005;
      ecg_min = ecg_min * 0.995 + ecg_avg * 0.005;
      if(ecg_data[x] > ecg_max) ecg_max = ecg_data[x];
      if(ecg_data[x] < ecg_min) ecg_min = ecg_data[x];
      int ecg_y = 63 - ecg_size * (ecg_data[x] - ecg_min) / (ecg_max - ecg_min + 1);
      ecg_screen[ecg_screen_len - 1 - new_data + x] = ecg_y;
    }

    // Display-Update alle 30 ms in 4 Phasen (Text, halber Graph, anderer halber Graph, display())
    if(ms - prev_displ > 30) {
      prev_displ = ms;
      if(displ_phase == 0) {
        display.clearDisplay();
        display.setCursor(0,0);
        display.print("BPM: "); display.println(uECG.getBPM());
        display.print(" RR: "); display.println(uECG.getLastRR());
        display.print("steps: "); display.print(uECG.getSteps());
        int batt_mv = uECG.getBattery();
        int batt_perc = (batt_mv - 3300) / 8;
        batt_perc = constrain(batt_perc, 0, 100);
        // Batterie-Balken zeichnen (110,0 bis 127,10)
        display.drawLine(110,0,127,0,WHITE);
        display.drawLine(110,10,127,10,WHITE);
        display.drawLine(110,0,110,10,WHITE);
        display.drawLine(127,0,127,10,WHITE);
        int bat_len = batt_perc / 6;
        for(int x=1; x<10; x++) display.drawLine(110,x,110+bat_len,x,WHITE);
      }
      if(displ_phase == 1) {
        for(int x=1; x