Realtime ECG op OLED-scherm krijgen

Over dit project

Enige tijd geleden heb ik een aantal projecten gepost die demonstreerden hoe je gegevens van een uECG-apparaat kunt krijgen - maar ze hadden nogal wat rommelige code en gebruikten er nog steeds alleen basisgegevens van. Dus uiteindelijk heb ik een Arduino-bibliotheek geschreven die deze manier eenvoudiger en veel betrouwbaarder maakt, hier is het:https://github.com/ultimaterobotics/uECG_library (houd er rekening mee dat u ook de RF24-bibliotheek moet installeren vanuit Bibliotheekbeheer, en als u gegevens op OLED willen tonen zoals in dit project - ook Adafruit's SSD1306-bibliotheek).

1. Schema's

Schema's zijn hetzelfde als voor elk ander project met behulp van nRF24-module en OLED:nRF24 is verbonden met Arduino's SPI-bus (D13, D12, D11) en twee willekeurige pinnen voor module CS- en CE-lijnen - ik heb voor het gemak D10 en D9 gekozen. Het enige belangrijke punt :nRF24-module moet worden aangesloten op 3,3V lijn, niet naar 5V! Het helpt ook veel om 1uF of 10uF condensator toe te voegen tussen 3,3V en GND - die nRF24-modules hebben een stabiele spanning nodig die Arduino niet altijd kan leveren op zijn 3,3V-lijn, condensatoren helpen daarbij.

OLED is aangesloten via I2C - SDA op A4, SCL op A5 en wordt gevoed via een 5V-lijn. In mijn geval had de OLED-module ingebouwde weerstanden voor het I2C-protocol. Als je module ze niet heeft, moet je 4,7k-weerstanden toevoegen van SDA tot 3,3V en van SCL tot 3,3V, hoewel de meeste modules die ik onlangs heb gezien ze al hebben.

U kunt hieronder de bijgevoegde schema's zien, en hier is een foto van het geassembleerde project:

2. Code

uECG-bibliotheek heeft nogal wat regels code nodig voor een goede werking, namelijk:

in setup(), moet je uECG.begin(pin_cs, pin_ce) aanroepen - je moet het vertellen welke pinnummers worden gebruikt voor nRF24 CS- en CE-lijnen, het zal de module inschakelen en intern in de juiste modus zetten.

In loop(), moet u uECG.run() zo vaak mogelijk aanroepen:uECG-apparaat verzendt veel gegevens - één pakket om de paar milliseconden - en als u uECG.run() niet aanroept tegen de tijd dat de volgende pakket arriveert, gaan de gegevens ervan verloren. Dat betekent dat de functie delay() nooit binnen de lus moet worden aangeroepen en millis() moet worden gebruikt voor taken die timing vereisen (ik heb daar een voorbeeld van toegevoegd in bibliotheekvoorbeelden).

Deze projectcode is beschikbaar als voorbeeld in de bibliotheek en is ook hieronder bijgevoegd (als het er te ingewikkeld uitziet - houd er rekening mee dat hier 95% van de code is gewijd aan geoptimaliseerde weergavetekening, voor het eenvoudig afdrukken van waarden in seriële monitor u heb maar een paar regels nodig):

#include 
#include 
#include 

#define SCREEN_WIDTH 128 // OLED schermbreedte, in pixels
#define SCREEN_HEIGHT 64 // OLED-schermhoogte, in pixels

// Verklaring voor een SSD1306-scherm aangesloten op I2C (SDA, SCL-pinnen)
# definieer OLED_RESET -1 // Reset pin # (of -1 als Arduino reset pin gedeeld wordt)
Adafruit_SSD1306 display (SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

int rf_cen =9; //nRF24-chip inschakelen pin
int rf_cs =10; //nRF24 CS-pin

void setup() {
 Serial.begin(115200); //seriële uitvoer - erg handig voor foutopsporing
 while(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Adres 0x3D voor 128x64
 Serial.println(F ("SSD1306-toewijzing mislukt")); 
 }
 display.display();
 vertraging(100);
 uECG.begin(rf_cs, rf_cen);
 vertraging(100);
 
 // Wis de buffer
 display.clearDisplay();
 display.setTextSize(1); // Normale 1:1 pixelschaal
 display.setTextColor(WHITE); // Teken witte tekst
 display.cp437(true); // Gebruik het volledige 256 char 'Code Page 437'-lettertype
 display.display();
 delay(100);
 Serial.println("after display");
} 

uint32_t prev_data_count =0;
uint32_t prev_displ =0;

uint8_t ecg_screen[128];
int ecg_screen_len =128;
float ecg_avg =0;
float ecg_max =1;
float ecg_min =-1;
int ecg_size =40;

int displ_phase =0;

void loop() 
{
 uECG.run();
 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  Serial.println(ecg_data[x]);
 
 for(int x =new_data; x  ecg_screen[x-new_data] =ecg_screen[x];
 for(int x =0; 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]  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;
 }

 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;
 if(batt_perc <0) batt_perc =0;
 if(batt_perc> 100) batt_perc =100;
 display.drawLine(110, 0, 127, 0, WIT);
 display.drawLine(110, 10, 127, 10, WIT);
 display.drawLine( 110, 0, 110, 10, WIT);
 display.drawLine(127, 0, 127, 10, WIT);
 int bat_len =batt_perc / 6;
 for(int x =1; x <10; x++)
 display.drawLine(110, x, 110+bat_len, x, WIT);
 }
 if(displ_phase ==1) 
 {
 for( int x =1; x  display.drawLine(x-1, ecg_screen[x-1], x, ecg_screen[x], WIT);
 } 
 if(displ_phase ==2) 
 {
 for(int x =ecg_screen_len/2; x  display.drawLine(x-1, ecg_screen[x- 1], x, ecg_screen[x], WIT);
 }
 if(displ_phase ==3) 
 display.display();
 displ_phase++;
 if (displ_phase> 3) displ_phase =0;
 }
 }
} 

3. Gegevens verwerken

Er wordt veel aan boord verwerkt en u kunt verschillende statistieken door het apparaat laten berekenen:BPM, GSR, laatste RR-interval, HRV-parameter en 16 HRV-bins (eerste bin vertegenwoordigt het aantal slagen met variatie <1%, tweede bin - variatie tussen 1 en 2% enz.), aantal gelopen stappen, versnellingsmetermetingen (hoewel de verversingssnelheid laag is, dus het is alleen goed voor het schatten van de pose).

Maar u kunt ook onbewerkte ECG-metingen krijgen - de gegevensstroom is niet perfect, zo nu en dan gaan er wat pakketten verloren, maar u kunt nog steeds iets bruikbaars krijgen:

Nou, dat was het - als je dit apparaat in een hoek had staan ​​stofzuigen, werkt het nu echt zonder al te veel moeite :)

Schema's