Registra ECG ad alta velocità o altri dati, continuamente per oltre un mese: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Questo progetto è stato sviluppato per supportare un team di ricerca medica universitaria, che aveva bisogno di un dispositivo indossabile in grado di registrare 2 segnali ECG a 1000 campioni/sec ciascuno (2K campioni/sec in totale) ininterrottamente per 30 giorni, al fine di rilevare le aritmie. Il progetto qui presentato include il controllo remoto e il monitoraggio della registrazione. Il controllo remoto avviene tramite menu presentati su un terminale seriale, sia su un computer che su un telefono cellulare. Questo progetto non copre la misurazione dell'ECG, l'imballaggio o la batteria necessari per l'indossabile finale.

Questa versione ad alta velocità/lunga durata utilizza Teensy 3.2, modulo breakout Adafruit Micro-SD, una scheda SD 16G SDHC classe 10 di qualità per registrare i dati e un modulo di comunicazione Bluetooth per il controllo e il monitoraggio. È disponibile anche una versione UNO/Mega2560 meno sviluppata e più lenta di questo progetto. Sebbene questo progetto utilizzi un modulo di comunicazione Bluetooth per il controllo e il monitoraggio della registrazione, puoi anche utilizzare moduli WiFi o BLE.

Questa versione, basata su Teensy 3.2, è capace di frequenze di campionamento molto più elevate rispetto alla versione UNO/Mega2560. Utilizzando questo codice, Teensy 3.2 può campionare e registrare due campioni ADC a > 30 Khz con una media hardware di oltre 4 campioni e soddisfa così facilmente il requisito di 1000 campioni/sec sopra. Il codice supporta il salvataggio di 100 file.bin di 128K ciascuno. A 30Khz che copre 29 ore e 30 minuti. A 1000 campioni/sec copre 37 giorni. Il codice può essere facilmente esteso per gestire più di 100 file, estendendo così la durata dell'esecuzione. Alla fine della corsa avrai >10Gig di dati,.bin, file e un file.met di metadati che descrivono la corsa e i risultati. Il SDtoCSV.jar fornito (codice sorgente SDtoCSV_src.zip) può essere utilizzato per convertire i file.bin in file.csv sul computer per un'ulteriore elaborazione. I dati risultanti sono >60Gig. La versione UNO/Mega2560 ha la conversione da.bin a.csv inclusa nello sketch Arduino, ma dato il volume di dati registrati dalla versione Teensy, questo non è un modo efficiente per eseguire la conversione.

Forniture

Teensy 3.2 di PJRC

Scheda breakout scheda Adafruit MicroSD+ o simile.

Scheda MicroSD 16G SDHC classe 10 di buona qualità, ad es. SanDisk.

Alimentazione USB 5V

Un led con una resistenza 470R in serie.

2 x 100R resistori (fornisce protezione da danni dovuti a errori di cablaggio Tx/Rx)

Bluetooth Mate Silver OPPURE uno dei moduli descritti su Arduino UNO/Mega Starter, controllato da Android/pfodApp

Passaggio 1: costruzione

Scarica e installa Arduino IDE V1.8.9+ da https://arduino.cc/en/Main/Software. Quella pagina web ha collegamenti per vari sistemi operativi e un collegamento a GettingStarted (https://arduino.cc/en/Guide/HomePage).

Scarica e installa Teensyduino (Supporto Teensy per l'IDE Arduino). NOTARE attentamente le istruzioni per il primo utilizzo.

Seleziona Teensy 3.2 come scheda e verifica che il programma di esempio BLINK venga caricato ed eseguito.

Scarica e installa le seguenti librerie:- millisDelay e SdFat (un'istantanea locale della libreria SdFat utilizzata per questi test è qui.) e pfodParser.zip (per la classe pfodBufferedStream e pfodNonBlockingInput)

Scarica i file zip della libreria e quindi usa il menu Arduino IDE → Sketch → Includi libreria → Aggiungi libreria. ZIP per installare le librerie dai file zip.

Decomprimi il file Teensy32AnalogLogger.zip nella directory degli sketch di Arduino e programma la scheda Teensy 3.2 con Teensy32AnalogLogger.ino (Versione 0.01)

Collega il Teensy 3.2, il modulo Bluetooth e il modulo della scheda SD come mostrato sopra (versione pdf)

Passaggio 2: esecuzione del programma - test

Prima formatta la tua scheda SD usando

La scheda SD deve essere vuota per avviare la registrazione.

Per il test iniziale non è necessario collegare il modulo di comunicazione, è sufficiente collegare il modulo Teensy 3.2 + SD (con una scheda vuota installata) all'IDE di Arduino tramite il cavo seriale USB. Come previsto, lo sketch Teensy32AnalogLogger.ino utilizza la connessione USB per il controllo e il monitoraggio. Vedere il passaggio Registrazione dati reali di seguito per l'utilizzo di un dispositivo di comunicazione per il controllo e il monitoraggio.

Modifica la parte superiore dello schizzo Teensy32AnalogLogger.ino per impostare COM_SERIAL su Serial, per l'output sulla connessione USB di Teensy.

#define COM_SERIAL seriale

Quindi carica lo schizzo su Teensy 3.2

Apri il monitor seriale Arduino IDE a 115200 baud (con entrambi i set NL e CR). Dopo pochi secondi il Teensy 3.2 visualizzerà un menu di comandi

Ver:0.01 immettere uno dei seguenti comandi:? - stato attuale e metadatii - inizializza i filel - elenca i file>

Il ? cmd visualizza i dettagli delle impostazioni correnti. (Vedi la parte superiore di Teensy32AnalogLogger.ino per modificare queste impostazioni) I comandi devono essere terminati con NL o CR o entrambi.

0:00:00.000 di 720:00:00.000

Pin campione: 16 17 Ordine byte: Bit ADC Little-Endian: 10 Medie di campionamento ADC su: 4 Frequenza di campionamento: 1000.00 Intervallo di campionamento: 1000uS Campioni per blocco: 127 Tempo per riempire il blocco: 127000uS Tempo per riempire un file: 9:01: 52.000 Tempo per riempire TUTTI i file: 894:04:48.000 Latenza massima SD (include chiusura/apertura file): 0uS Latenza massima chiusura/apertura file: 0uS Numero di blocchi di buffer: 28 Tempo per riempire TUTTI i buffer di blocco: 3556000uS Numero massimo di buffer salvato nella chiamata a storeSampleBuffers(): 0 Timer persi totale: 0 Campioni mancanti totali finora: 0 Blocchi totali scritti: 0 Campioni totali scritti: 0 copertura: 0:00:00.000 File corrente:

In questo caso il tempo di esecuzione della registrazione corrente è 0 delle 720 ore richieste (30 giorni), campionando D16/A2 e D17/A3 (vedere di seguito per le restrizioni sulla scelta degli ingressi ADC di seguito) 1000 volte al secondo. Il tempo di esecuzione massimo può essere fino a 894 ore (37,25 giorni). Il ciclo principale() può essere occupato fino a 3,5 secondi (tempo per riempire TUTTI i buffer di blocco) prima che tutti i buffer disponibili vengano riempiti e i campioni inizino a essere persi. I buffer salvati ecc. vengono aggiornati man mano che l'esecuzione procede.

Inserisci una scheda SD vuota, usa il cmd 'i' per inizializzare i 99 file utilizzati per memorizzare i dati. La pre-inizializzazione qui riduce il ritardo nel passaggio da un file all'altro e consente un campionamento più rapido.

Inizializzazione di 99 file

Creazione nuovo file: log00.bin Tempo trascorso: 368 ms Creazione nuovo file: log01.bin Tempo trascorso: 520 ms… Creazione nuovo file: log98.bin Tempo trascorso: 15660mS Creazione nuovo file: log99.bin Tempo trascorso: 15812mS

È quindi possibile utilizzare il cmd r per avviare un'esecuzione di registrazione. L'esecuzione verrà eseguita per il tempo richiesto o fino a quando non verrà utilizzato il cmd s per interromperla. Puoi anche usare il ? cmd durante la registrazione per ottenere tempi e conteggi aggiornati. Ecco un breve periodo interrotto in anticipo utilizzando s cmd.

REGISTRAZIONE DATI …..

Ver:0.01 immettere uno dei seguenti comandi: ? - stato attuale e metadati - interruzione della registrazione dei dati

REGISTRAZIONE DATI… Verificare con ? comando

Tempo di esecuzione trascorso: 0:00:10.000 di 720:00:00.000 Tempo di esecuzione trascorso: 0:00:20.000 di 720:00:00.000…

Arresto della registrazione e rimozione dei file inutilizzati.

… Rimozione di file inutilizzati: log98.bin Rimozione di file inutilizzati: log99.bin

0:01:04.976 di 720:00:00.000

Pin campione: 16 17 Ordine byte: Bit ADC Little-Endian: 10 Medie di campionamento ADC su: 4 Frequenza di campionamento: 1000.00 Intervallo di campionamento: 1000uS Campioni per blocco: 127 Tempo per riempire il blocco: 127000uS Tempo per riempire un file: 9:01: 52.000 Tempo per riempire TUTTI i file: 894:04:48.000 Latenza SD massima (include chiusura/apertura file): 204uS Latenza massima chiusura/apertura file: 0uS Numero di blocchi di buffer: 28 Tempo per riempire TUTTI i buffer di blocco: 3556000uS Numero massimo di buffer salvato nella chiamata a storeSampleBuffers(): 1 Timer persi totale: 0 Campioni mancanti totali finora: 0 Blocchi totali scritti: 511 Campioni totali scritti: 64832 copertura: 0:01:04,832 File corrente: log00.bin

ls:

2000-01-01 01:00:00 261632 log00.bin 2000-01-01 01:00:00 240 log.met

REGISTRAZIONE DATI COMPLETATA!

Ver:0.01 immettere uno dei seguenti comandi: ? - stato attuale e metadati ** r - registrare i dati ADC ** non disponibile. I dati esistono già ** i - inizializza i file ** non disponibile. I dati esistono già l - elenca i file

I DATI SONO GIÀ STATI REGISTRATI, verificare con ?

Display a LED

Il LED collegato a D3 (con D2 che fornisce la connessione GND) si accenderà fisso se manca un campione e lampeggerà se c'è un errore. Lo schizzo tenta di continuare dopo gli errori, ma potrebbe non farlo correttamente.

Passaggio 3: registrazione dei dati reali

Quando si registrano dati reali per lunghi periodi, è più conveniente collegare un modulo di comunicazione ai pin D0/D1 e controllare e monitorare la registrazione in remoto. Qui è stato utilizzato un modulo Bluetooth Mate Silver con le impostazioni predefinite, 115200 baud, nessun handshake hardware (RTC, CTS), codice pin 1234.

Nota: quando viene applicata l'alimentazione al modulo Mate Silver, esso entra in modalità di configurazione, lampeggio veloce del led rosso, per 60 sec. Durante questo periodo è possibile inviare $$$ tramite la connessione seriale al modulo per configurarlo ma non è possibile connettere il modulo. Una volta che il led rosso lampeggia lentamente, il modulo bluetooth accetterà le connessioni.

Cambia la COM_SERIAL definita in Teensy32AnalogLogger.ino con la connessione seriale hardware (D0/D1), Serial1

#define COM_SERIAL Seriale1

Dopo l'associazione con il computer, è stata creata una nuova porta COM sul computer e CoolTerm può essere utilizzato per connettersi, controllare e monitorare la registrazione. È possibile utilizzare anche altri moduli di comunicazione collegati in serie, come WiFi o BLE, vedere Arduino UNO/Mega Starter, controllato da Android/pfodApp per i dettagli.

Puoi anche controllare e monitorare la registrazione dal tuo cellulare Android utilizzando un'app per terminale bluetooth come l'app Bluetooth Terminal o utilizzando un'app per terminale WiFi e TCP come TCP Telnet Terminal Pro o un mdoule da Uart a BLE e un'app per terminale BLE come nRF UART V2

Passaggio 4: restrizioni sulla scelta degli ingressi ADC

Il Teensy 3.2 ha due moduli hardware ADC separati, ADC_0 e ADC_1, nel suo microprocessore in modo che possa campionare due ingressi contemporaneamente. Ha anche una media hardware integrata che prende più campioni ADC e ne calcola la media prima di modificare il risultato.

Esistono restrizioni su quali ingressi possono essere collegati a ADC_0, ADC_1. L'immagine Teensy3_1_AnalogCard-p.webp

In sintesi:-Per le letture a terminazione singola, ad esempio +Volt riferiti a GND, ADC_0 può leggere da A0 a A9, A10, A11, A12, A14 ADC_1 può leggere da A2, A3, A10, A13, da A15 a A20 Se si seleziona un pin che l'ADC impossibile leggerlo restituirà 0 (sempre)

Questo progetto utilizza A2, A3 a cui è possibile accedere ciascuno da ADC_0 o ADC_1.

Passaggio 5: conversione dei file.bin in file.csv

Il Teensy32AnalogLogger.ino salva i campioni come binari nei file logxx.bin, ad esempio da log00.bin a log99.bin. Teensy32AnalogLogger.ino salva anche un file log.met di metadati sulla corsa.

Puoi utilizzare SDtoCSV.jar (codice sorgente SDtoCSV_src.zip) per convertire i file.bin in.csv per un'ulteriore elaborazione. Copia i file dalla scheda SD sul disco rigido del tuo computer con almeno 70Gig di spazio libero e copia il file SDtoCSV.jar nella stessa directory. Apri una finestra di comando in quella directory ed esegui

java -jar SDtoCSV.jar log

Se il tuo computer non ha Java installalo, installalo da www.java.com

SDtoCSV elaborerà il file log.met e quindi ciascuno dei file logxx.bin disponibili nella directory e produrrà un file.csv per ogni.bin. Il file.csv ha il numero di sequenza del campione seguito dalle due letture.

Qui viene mostrato un output di console di esempio per una lettura di 2 adc campionata 30303 volte/sec, output.txt. Illustra come vengono segnalati i campioni mancanti. (Il raddoppio del numero di buffer nello schizzo finale ha risolto questo problema con questi campioni mancanti)

Conversione da SD_Logging a CSV. Controllare SDtoCSV.log per i messaggi di avanzamento e di errore. Processing log00 Elaborato 256000 blocchi Elaborazione log01 Elaborato 256000 blocchi… Log di elaborazione25 256000 blocchi elaborati Log di elaborazione26 256000 blocchi elaborati Log di elaborazione27 256000 blocchi elaborati Campioni mancanti: 2715 Log di elaborazione28 256000 blocchi elaborati… Log di elaborazione29 Elaborato 256000 blocchi… Registro elaborazione47 Elaborato 256000 blocchi Registro elaborazione48 Elaborato 35935 blocchi --- Elaborazione terminata

Un file di registro più completo, SDtoCSV.log, viene aggiunto a ogni esecuzione di SDtoCSV. Include l'output dei metadati e gli eventuali messaggi di errore. Qui il conteggio:254 è il conteggio dei dati memorizzati in quel blocco, ovvero 127 campioni x 2 letture adc per blocco. MissSamples è il numero di coppie di letture mancate, ovvero righe nell'output.csv.

=== File di registro per la conversione da SD_Logging a CSV Sat Jul 13 13:19:51 AEST 2019 Per visualizzare i messaggi di avanzamento sulla console, utilizzare java -jar SDtoCSV.jar Nome del file di base 'log' Versione dei metadati: 0 (Little Endian) sampleInterval uS: 33 adcBits:10 adcAvgs:4 pinCount:2 Pin: 16, 17 samplePerBlock:127 noBufferBlocks:28 durata mS:51649820 runTime richiesto mS:106216704 maxBuffersUsed:32 Avviso: supera il numero di buffer disponibili (28). Alcuni campioni potrebbero mancare. maxLatency uS:221476 Avviso: supera il tempo fornito dai blocchi buffer (117348uS). Mancheranno alcuni campioni. maxFileOpenTime uS:20998 missTimers:0 missSamplesTotal:2715 totalBlocksWritten:12323935 totalSamplesWritten:1565139665 Elaborazione log00.bin Elaborato 256000 blocchi Elaborazione log01.bin Elaborato 256000 blocchi… Elaborazione log26.bin Elaborato 256000 blocchi Elaborazione log27.bin !!! Block:57696 count:254 missSamples:2339 !!! Blocco: 57697 conteggio: 254 campioni mancati: 376 Elaborato 256000 blocchi --- Campioni mancanti totali: 2715

Elaborazione log28.bin Elaborato 256000 blocchi

… Elaborazione log47.bin Elaborato 256000 blocchi Elaborazione log48.bin Elaborato 35935 blocchi --- Elaborazione terminata

Un esempio di file di output log00.csv è

SampleCounter (per 33uS), Pin 16, Pin 170, 248, 205 1, 273, 195 2, 228, 337 3, 360, 302 4, 355, 369 5, 220, 281…

Il contatore del campione aumenta da file a file in modo che possa essere utilizzato come timestamp. Se ci sono campioni mancanti, il contatore dei campioni viene incrementato del conteggio mancante prima di emettere la riga successiva in modo che il contatore/timbro orario rimanga preciso per i campioni registrati.

Passaggio 6: commenti sul codice e sulle estensioni

Il Teensy32AnalogLogger è una versione pesantemente modificata dell'esempio AnalogBinLogger di Bill Greiman nella sua libreria SdFat Arduino. Qui la libreria è stata riscritta per funzionare su Teensy 3.2.

Teensy32AnalogLogger utilizza timer0 per impostare l'intervallo di campionamento. Il gestore di interrupt per timer0 avvia le due conversioni ADC. Un gestore di interrupt per il secondo modulo ADC viene chiamato continuamente fino a quando entrambi non sono finiti, in genere il primo modulo ADC avviato ADC_0 termina prima del secondo, quindi il gestore di interrupt viene chiamato solo una volta. Il gestore di interrupt ADC_1 salva i campioni in un buffer di dati.

Nel loop() principale, storeSampleBuffer() salva tutti i buffer pieni sulla scheda SD e ricicla i buffer nella coda di buffer vuota. La grande quantità di RAM disponibile su Teensy 3.2 significa che è possibile allocare un gran numero di buffer e quindi storeSampleBuffer() non ha bisogno di essere chiamato spesso. Questo lascia tempo al loop() principale per fare altro lavoro, come elaborare i comandi e inviare l'output.

Estensioni

Sebbene questo progetto sia funzionale come un data logger ad alta velocità, per un completo indossabile deve ancora essere imballato e un sistema di batterie e sensori ECG forniti. Inoltre, ci sono alcune estensioni che dovrebbero essere considerate.

1. Aggiungi il controllo e il monitoraggio in tempo reale della forma d'onda campionata tramite pfodApp utilizzando la funzione di plottaggio di pfodApp per mostrare istantanee della forma d'onda
2. Estendere i numeri di file oltre 99 per cicli di campionamento più lunghi
3. Campiona più di 2 input. Poiché Teensy 3.2 ha due moduli ADC, è possibile modificare il codice per aggiungere ulteriori input in coppia per massimizzare la frequenza di campionamento.
4. Aggiungi il monitoraggio della batteria per monitorare la carica della batteria. Il Teensy 3.2 utilizza circa 1100 mAh in 24 ore, incluso il modulo bluetooth e SD, ma escludendo il modulo sensore
5. Aggiungere un circuito di alimentazione a doppia batteria per consentire la sostituzione della batteria senza interrompere la registrazione.