Moniteur ECG sans fil : Conception portable avec Arduino Nano et nRF24

Composants et fournitures

Dispositif uECG	×	1
Arduino Nano R3	×	1
Module nRF24 (générique)	×	1
Anneau NeoPixel Adafruit : WS2812 5050 RGB LED	×	1
Batterie LiPo	×	1

Outils et machines nécessaires

Fer à souder (générique)

À propos de ce projet

Ceci est une deuxième itération de mon projet de surveillance cardiaque. Le précédent montrait les battements cardiaques sur la poitrine et était connecté à l'uECG par fil. Cela avait l'air cool, mais n'était pas pratique du tout : on ne voit pas bien combien de LED sont allumées, c'est hors du champ de vision normal, et le fil le reliant au dispositif uECG crée beaucoup de problèmes pour le capteur lui-même, donc cela ne fonctionne basically pas quand on court.

Cette version résout tous ces problèmes : elle se porte au poignet, donc on peut la voir en gardant les yeux sur la route, et elle est sans fil, donc pas de distorsion des lectures. Elle fonctionne vraiment pour la course et permet de suivre la charge cardiaque.

1. Composants

Comme dans le projet précédent, tout le travail difficile est fait par l'uECG : il mesure les données et calcule les BPM (battements par minute) à bord. Mais aussi, quand il est basculé en mode liaison directe, il envoie toutes ces informations (avec les données ECG haute résolution, que nous n'utilisons pas ici) via un protocole radio compatible avec une puce nRF24 générique. Le deuxième composant critique est donc le module nRF24. Et l'Arduino Nano a juste la bonne taille pour s'insérer sous un petit anneau LED, donc je l'utilise comme contrôleur (mais vraiment n'importe quoi fonctionnerait tout aussi bien ici).

2. Schémas

Connecter le module nRF24 n'est pas simple : il faut connecter tous les fils SPI (MISO, MOSI, SCK, CS), aussi le fil d'activation de puce, et l'alimentation. Et si vous voulez une taille raisonnablement petite, tous les connecteurs à broches doivent être retirés, et les fils soudés directement aux pastilles. Donc connecter le nRF seul prend 7 fils, 14 points de soudure. La bonne nouvelle est que tout le reste est simple : l'anneau LED nécessite 1 fil de données et 2 fils d'alimentation, et 2 autres fils d'alimentation vont dans le connecteur de batterie.

Liste de connexions :

• nRF24 broche 1 (GND) → GND Arduino
• nRF24 broche 2 (Vcc) → 3,3 V Arduino
• nRF24 broche 3 (Chip Enable) → Arduino D9
• nRF24 broche 4 (SPI:CS) → Arduino D8
• nRF24 broche 5 (SPI:SCK) → Arduino D13
• nRF24 broche 6 (SPI:MOSI) → Arduino D11
• nRF24 broche 7 (SPI:MISO) → Arduino D12
• Anneau LED Alimentation → Arduino 5V
• Anneau LED GND → Arduino GND
• Anneau LED DI → Arduino D5
• Batterie positif (rouge) → Arduino 5V
• Batterie négatif (noir) → Arduino GND

Note importante : Vous ne pouvez pas connecter les fils MOSI, MISO, SCK à d'autres broches Arduino. Le matériel SPI se trouve sur D11, D12, D13 et ne fonctionnera pas s'il n'est pas connecté là. Toutes les autres broches peuvent être changées (si vous faites les modifications correspondantes dans le programme).

3. Programme

La seule chose compliquée dans le logiciel ici est la configuration du canal RF. J'ai passé un bon moment à essayer de le faire fonctionner avant de réaliser que l'uECG et le nRF24 utilisent un ordre de bits différent pour l'adresse du tuyau (pipe). Quand j'ai corrigé cela, tout a commencé à marcher immédiatement :) En gros, on lit juste les paquets entrants, on utilise leur 5e octet comme BPM, et on le filtre (le canal RF est bruité, donc de temps en temps on obtient une valeur aléatoire au lieu de la lecture correcte, et le CRC matériel est désactivé pour des raisons de compatibilité). Après cela, le BPM est converti en couleur et nombre de pixels actifs, et c'est tout.

4. Assemblage du bracelet

Quand tous les fils sont soudés, le programme est flashé, et vous avez confirmé que les données uECG sont reçues, il est temps de tout assembler.

J'ai choisi une méthode très simple pour tout maintenir ensemble : de la colle thermique. Comme les pièces elles-mêmes s'adaptent presque déjà (le Nano correspond à la taille de l'anneau externe, le module nRF24 à la taille de l'anneau interne, et la batterie, bien ne rentrant dans aucune pièce, ne gêne pas vraiment - je ne sais pas comment ça marche, mais je l'ai juste collé là et ça a vraiment bien marché :). Ensuite, je l'ai cousu à un bracelet aléatoire que j'avais sous la main (restes d'un pack de station de soudure, un bracelet utilisé pour la mise à la terre pendant le soudage), et c'est tout !

5. Test

Pour tester, je suis allé courir, et cela a très bien fonctionné sauf pour une surprise. J'avais utilisé des réglages tels qu'à 192 BPM toutes les LED étaient allumées, car selon toutes les recommandations, un tel rythme cardiaque est trop élevé pour mes paramètres. La surprise a été que je l'ai dépassé en quelques minutes de course, sans même m'en rendre compte. J'ai même pensé que cela pouvait être une erreur du capteur, mais non - quand je me suis arrêté, il n'est pas redescendu immédiatement, au lieu de cela il y a eu une relaxation lente (le capteur est 100 % fiable quand il n'y a pas beaucoup de mouvement). Il s'avère donc que pendant un moment, je m'entraîne bien au-dessus de mon seuil sain (du moins ce qui est censé être sain pour un adulte standard de mon âge/poids). C'est intéressant : je fais du sport (amateur) depuis l'enfance, mais j'ai eu des problèmes cardiaques dans mon adolescence et ils semblaient s'être résorbés avec le temps. Mais je sais par expérience que toute charge supérieure à une marche rapide était vraiment dure pour moi, pourtant j'ai continué à m'entraîner - et cela a augmenté ma limite au fil du temps, au point que maintenant je me considère comme assez bien en forme. Et maintenant j'ai une question : mon BPM est-il juste plus élevé que la normale à cause de ces problèmes cardiaques à l'adolescence, ou est-ce que je pousse vraiment trop fort sans m'en rendre compte ? De toute façon, je devrai faire quelque chose - soit augmenter le BPM max sur le moniteur, soit m'entraîner moins intensivement. :)

P.S. Surprenant, l'uECG a très bien performé comme capteur EMG - vous pouvez en lire plus dans mon projet de contrôle de main robotique.

Code

bpm_watch.ino (Arduino)

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

int rf_cen = 9; // nRF24 chip enable pin
int rf_cs = 8;  // nRF24 CS pin
RF24 rf(rf_cen, rf_cs);

// Adresse du tuyau - codée en dur côté uECG
uint8_t pipe_rx[8] = {0x0E, 0xE6, 0x0D, 0xA7, 0, 0, 0, 0};

#define PIN 5        // Broche Arduino connectée aux NeoPixels
#define NUMPIXELS 16 // Nombre de NeoPixels attachés
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

uint8_t swapbits(uint8_t a) { // uECG utilise un ordre de bits inversé pour l'adresse du tuyau
  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 < NUMPIXELS; i++) {
    pixels.setPixelColor(i, pixels.Color(1, 1, 1));
  }
  pixels.show();

  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));

  for (int x = 0; x < 8; x++) // nRF24 et uECG ont un ordre de bits différent
    pipe_rx[x] = swapbits(pipe_rx[x]);

  // Configuration des paramètres radio
  rf.begin();
  rf.setDataRate(RF24_1MBPS);
  rf.setAddressWidth(4);
  rf.setChannel(22);
  rf.setRetries(0, 0);
  rf.setAutoAck(0);
  rf.disableDynamicPayloads();
  rf.setPayloadSize(32);
  rf.openReadingPipe(0, pipe_rx);
  rf.setCRCLength(RF24_CRC_DISABLED);
  rf.disableCRC();
  rf.startListening(); // Écoute les données uECG

  // Note : uECG doit être basculé en mode données brutes (via appui long sur le bouton)
  // pour envoyer des paquets compatibles, par défaut il envoie en mode BLE
  // qui ne peut pas être reçu par nRF24
}

long last_pix_upd = 0;
byte in_pack[32];
int rf_bpm = 0;
int bpm_hist[5]; // CRC désactivé, faut filtrer les données entrantes

void loop() {
  if (rf.available()) {
    rf.read(in_pack, 32);
    int bb = in_pack[5]; // BPM situé au 5e octet du paquet

    // Filtrage : on compare les 5 dernières valeurs BPM reçues
    for (int n = 0; n < 5 - 1; n++)
      bpm_hist[n] = bpm_hist[n + 1];
    bpm_hist[4] = bb;
    for (int n = 0; n < 5; n++)
      if (bpm_hist[n] != bb) bb = -1;
    if (bb > 0)
      rf_bpm = bb;
  }

  long ms = millis();
  if (ms - last_pix_upd > 10) { // Ne pas mettre à jour les pixels trop souvent
    int r, g, b;
    last_pix_upd = ms;
    int bpm = rf_bpm;
    int max_bright = 160; // Luminosité max, max 255
    float dd = 25; // Changement de BPM entre les tons de couleur (bleu→vert→jaune→rose→rouge)
    float t1 = 90, t2, t3, t4; // t1 = BPM « base », en dessous = bleu
    t2 = t1 + dd;
    t3 = t2 + dd;
    t4 = t3 + dd;

    // Changement de couleur selon la plage de BPM
    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; // Ne montre rien en dessous de 80 BPM (pour la course)
    for (int i = 0; i < NUMPIXELS; i++) {
      if (i < on_pixels)
        pixels.setPixelColor(NUMPIXELS - i - 1, pixels.Color(r, g, b));
      else
        pixels.setPixelColor(NUMPIXELS - i - 1, pixels.Color(0, 0, 0));
    }
    pixels.show();
  }
}

Schémas

Fichier : nrf24_led_ring_o2Gij5oigT.fzz