Sistema sanitario indossabile che utilizza IOT: 8 passaggi

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

Nel presente lavoro, i sensori sono avvolti in

il cappotto indossabile e misura la temperatura dell'utente, l'ECG, la posizione, la pressione sanguigna e il BPM e lo invia tramite il server ThingSpeak. Visualizza una rappresentazione grafica dei dati misurati. La trasformazione dei dati viene eseguita dal controller principale principale di Arduino. Quando i sensori sono misurati, Arduino eseguirà il programma e anche la chiave API ThingSpeak viene inserita nel programma.

Passaggio 1: componenti richiesti

1. Arduino UNO

2. LM75 (sensore di temperatura)

3. AD8232 (sensore ECG)

4. HW01 (sensore di impulso)

5. ESP8266 (modulo Wi-Fi)

6. Fili binari

7. Cavo USB per il debug

8. Batteria agli ioni di litio da 4 (9v)

9. Cappotto antipioggia

10. Scatola di cotone (25X25 cm)

11. Pistola per colla con 2 stick.

Passaggio 2: collegamento di LM75 e Arduino

L'LM75 prevede il protocollo I2C con Arduino. Quindi, la temperatura è rilevata e verrà convertita in dati digitali utilizzando il convertitore analogico-digitale delta sigma a 9 bit integrato. Grazie alla precisione LM75 viene utilizzato per misurare la temperatura dell'utente. La risoluzione del sensore è di 9 bit e ha un indirizzo slave a 7 bit. quindi, il formato dei dati è complementare a due con l'indirizzo slave. La frequenza operativa del sensore LM75 è 400KHz. L'LM75 contiene un filtro passa basso per aumentare l'affidabilità della comunicazione in ambienti rumorosi.

Il pin Arduino A4 e A5 prevede una comunicazione con interfaccia a due fili, quindi sarà collegato al pin SDA e SCL di LM75.

LM75 ------ ARDUINO

SCL ---- A5 (INGRESSO analogico)

SDA ---- A4 (INGRESSO analogico)

VCC ---- 3.3V

GND ---- GND

Passaggio 3: connessione tra modulo a impulsi e Arduino

In questo lavoro viene utilizzato il sensore di pulsazioni. Il sensore di pulsazioni è un sensore Plug and Play ben progettato attraverso il quale l'utente può acquisire dati in tempo reale sulla frequenza cardiaca o sulla frequenza del polso e alimentarli dove vuole.

Collegare il sensore di impulsi alla scheda Arduino Uno come segue: + a +5V e - a GND S a A0. Collegare LCD alla scheda Arduino Uno come segue: VSS a +5V e VDD a GND e RS a 12 e RW a GND e E a D11 e D4 a D5 e D5 a D4 e D6 a D3 e D7 a D2 e A/VSS a +5V e K/VDD a GND. Collegare il potenziometro 10K all'LCD come segue: Dati su v0 e VCC su +5V. Collegare il LED ad Arduino come segue: LED1 (ROSSO, pin lampeggiante) a D13 e LED2 (VERDE, velocità di dissolvenza) a D8.

Sensore di IMPULSI ------ Arduino

VSS ------ +5V

GND ------ GND

S ----- LA0

Quando il sensore tocca la pelle, il LED sul sensore lampeggia.

Passaggio 4: connessione tra sensore ECG e Arduino

Il sensore ECG AD8232 è interfacciato con Arduino e gli elettrodi sono posizionati al braccio sinistro, al braccio destro e alla gamba destra. In questo l'azionamento della gamba destra funge da feedback al circuito. Ci sono tre ingressi dagli elettrodi che misura l'attività elettrica del cuore e sarà indicato dal LED. Per ridurre il rumore viene utilizzato l'amplificatore della strumentazione (BW: 2KHz) e vengono utilizzati due filtri passa alto per ridurre gli artefatti da movimento e il potenziale della semicella dell'elettrodo. AD8232 è configurato come configurazione a tre elettrodi.

CONNESSIONE: L'elettrodo del braccio sinistro è collegato al pin +IN di AD8232 e l'elettrodo del braccio destro è collegato al pin -IN di AD8232 e il feedback della gamba destra è collegato al pin RLDFB di AD8232. Il rilevamento delle derivazioni in questo sensore è CA o CC. Per questo AC è usato. Il pin LO- è connesso al pin Analog (11) di Arduino e il pin LO+ è connesso al pin Analog (10) di Arduino e l'output degli elettrodi è connesso al pin A1 di Arduino.

Sensore ECG ------ Arduino

LO- ------ Pin analogico(11)

LO+ ------ Pin analogico(10)

Uscita ------ A1

Gli elettrodi posizionati sul corpo del paziente rilevano i piccoli cambiamenti del potenziale elettrico sulla pelle che derivano dalla depolarizzazione del muscolo cardiaco durante il battito cardiaco a portata di mano a differenza di un ECG triplo convenzionale in cui tendono gli elettrodi posizionati sugli arti e sul torace del paziente. Nella misurazione del segnale ECG, la fase dell'intervallo PR e dell'intervallo QR e la durata dell'ampiezza vengono variate in condizioni anormali. Le anomalie sono definite nella programmazione di Arduino.

Parametri ECG normali Parametri ECG anormali

Onda P 0,06-0,11 <0,25 ------------------------------------------- --------- Onde T piatte o invertite Ischemia coronarica

Complesso QRS <0,12 0,8-1,2 ------------------------------------------- ------- Blocco di branca QRS aumentato

Onda T 0,16 <0,5 ------------------------------- ------------------- Blocco PR AV aumentato

Intervallo QT 0,36-0,44 --------------------------------------------- --------------- Ipercalcemia a breve intervallo QT

Intervallo PR 0,12-0,20 --------------------------------------------- ------ PR lungo, QRS largo, QT corto Iperkaliemia

mostra le anomalie nel segnale ECG che sarà incluso nella codifica Arduino e quando si verificano le anomalie verrà inviato come messaggio di avviso ai particolari numeri di cellulare. Abbiamo un file di libreria separato che è incluso nel programma

Passaggio 5: interfacciamento modulo Wi-Fi e Arduino

Il modulo Wi-Fi ESP8266 è un ricetrasmettitore wireless autonomo a basso costo che può essere utilizzato per sviluppi IoT end-point. Il modulo Wi-Fi ESP8266 consente la connettività Internet alle applicazioni integrate. Utilizza il protocollo di comunicazione TCP/UDP per connettersi con server/client. Per comunicare con il modulo Wi-Fi ESP8266, il microcontrollore deve utilizzare un set di comandi AT. Il microcontrollore comunica con il modulo Wi-Fi ESP8266-01 utilizzando UART con baud rate specificato (predefinito 115200).

APPUNTI:

1. Il modulo Wi-Fi ESP8266 può essere programmato utilizzando l'IDE Arduino e per farlo è necessario apportare alcune modifiche all'IDE Arduino. Per prima cosa, vai su File -> Preferenze nell'IDE Arduino e nella sezione URL di Gestione schede aggiuntive. Ora vai su Strumenti -> Bacheca -> Gestione schede e cerca ESP8266 nel campo di ricerca. Seleziona ESP8266 di ESP8266 Community e fai clic su Installa.

2.. Il modulo ESP8266 funziona con un alimentatore da 3,3 V e qualcosa di più grande, come ad esempio 5 V, ucciderà il SoC. Quindi, il pin VCC e il pin CH_PD del modulo ESP8266 ESP-01 sono collegati a un'alimentazione da 3,3 V.

3. Il modulo Wi-Fi ha due modalità di funzionamento: modalità di programmazione e modalità normale. In modalità di programmazione, è possibile caricare il programma o il firmware sul modulo ESP8266 e in modalità normale, il programma o il firmware caricato verrà eseguito normalmente.

4. Per abilitare la modalità di programmazione, il pin GPIO0 deve essere collegato a GND. Nello schema del circuito, abbiamo collegato un interruttore SPDT al pin GPIO0. Commutando la leva di SPDT si commuterà l'ESP8266 tra la modalità di programmazione (GPIO0 è collegato a GND) e la modalità normale (GPIO0 funge da pin GPIO). Inoltre, l'RST (Reset) svolgerà un ruolo importante nell'abilitazione della modalità di programmazione. Il pin RST è un pin attivo LOW e quindi è collegato a GND tramite un pulsante. Quindi, ogni volta che si preme il pulsante, il modulo ESP8266 si ripristinerà.

Connessione:

I pin RX e TX del modulo ESP8266 sono collegati ai pin RX e TX sulla scheda Arduino. Poiché il SoC ESP8266 non può tollerare 5V, il Pin RX di Arduino è collegato tramite un convertitore di livello composto da un resistore da 1KΩ e da 2,2KΩ.

Modulo Wi-Fi ------ Arduino

VCC ---------------- 3.3V

GND ---------------- GND

CH_PD ---------------- 3.3V

RST ---------------- GND (normalmente aperto)

GPIO0 ---------------- GND

TX ---------------- TX di Arduino

RX ------------------ RX di Arduino (convertitore di livello)

Dopo la connessione e la configurazione:

L'ESP8266 in modalità di programmazione (GPIO0 è collegato a GND), collega l'Arduino al sistema. Una volta acceso il modulo ESP8266, premere il pulsante RST e aprire l'IDE Arduino. Nelle opzioni della scheda (Strumenti -> Scheda), seleziona la scheda "Generic ESP8266". Selezionare il numero di porta appropriato nell'IDE. Ora apri il Blink Sketch e cambia il pin LED su 2. Qui, 2 significa pin GPIO2 del modulo ESP8266. Prima di eseguire il caricamento, assicurati che GPIO0 sia prima connesso a GND e quindi premi il pulsante RST. Premi il pulsante di caricamento e il codice impiegherà un po' di tempo per essere compilato e caricato. Puoi vedere i progressi nella parte inferiore dell'IDE. Una volta che il programma è stato caricato con successo, puoi rimuovere il GPIO0 da GND. Il LED collegato a GPIO2 lampeggerà.

Passaggio 6: programma

Il programma serve per interfacciare LM75, modulo Pulse, sensore ECG e modulo Wi-Fi ad Arduino

Passaggio 7: configurazione del server ThingSpeak

ThingSpeak è una piattaforma applicativa per. l'Internet delle cose. È una piattaforma aperta con analisi MATLAB. ThingSpeak ti consente di costruire un'applicazione attorno ai dati raccolti dai sensori. Le funzionalità di ThingSpeak includono: raccolta dati in tempo reale, elaborazione dati, visualizzazioni, app e plug-in

Al centro di ThingSpeak c'è un canale ThingSpeak. Un canale viene utilizzato per memorizzare i dati. Ogni canale include 8 campi per qualsiasi tipo di dati, 3 campi di posizione e 1 campo di stato. Una volta che hai un canale ThingSpeak, puoi pubblicare i dati sul canale, fare in modo che ThingSpeak elabori i dati e quindi fare in modo che la tua applicazione recuperi i dati.

PASSAGGI:

1. Crea un account in ThingSpeak.

2. Crea un nuovo canale e chiamalo.

3. E crea 3 file e specifica il suo nome per ogni file.

4. Prendere nota dell'ID canale di ThingSpeak.

5. Prendere nota della chiave API.

6. E menzionalo in Programma per passare i dati da ESP8266.

7. Ora visualizza i dati ottenuti.

Passaggio 8: configurazione finale (hardware)

La configurazione hardware del nostro progetto Contiene tutti i componenti hardware del progetto e verrà imballata e inserita in un cappotto indossabile per il comfort dei pazienti. Il cappotto con sensori è realizzato da noi e fornisce misurazioni senza errori agli utenti. I dati biologici dell'utente, le informazioni sono archiviate nel server ThingSpeak per analisi e monitoraggio a lungo termine. È quello che il progetto ha coinvolto nel sistema sanitario

IMPOSTARE:

1. Posizionare i circuiti all'interno della scatola di cotone.

2. L'uso della pistola per colla lo rende fissabile alla scatola.

3. Collegare la batteria al VIN di Arduino al terminale positivo della batteria e GND di Arduino al terminale negativo della batteria

4. Quindi fissa la scatola all'interno del cappotto usando la pistola per colla.

Una volta stabilita la codifica senza errori, il programma viene eseguito e uno sarà pronto per vedere l'output di Senor su una piattaforma come il display dell'output di Arduino e successivamente le informazioni verranno trasferite al ThingSpeak Cloud via web e saremo pronti per visualizzarlo sul mondo piattaforma. L'interfaccia web può essere sviluppata per implementare più funzionalità nella visualizzazione, gestione e analisi dei dati per fornire una migliore interfaccia ed esperienza all'utente. Utilizzando l'impostazione del lavoro proposto il Dottore può monitorare le condizioni del paziente 24 ore su 24 e 7 giorni su 7 e qualsiasi brusca variazione dello stato del paziente viene notificata al Dottore o al personale paramedico tramite un avviso di avviso. Inoltre, poiché le informazioni sono accessibili nel server Thingspeak, le condizioni del paziente possono essere controllate a distanza da qualsiasi parte del pianeta. Oltre a vedere semplicemente le informazioni precedenti di un paziente, possiamo utilizzare queste informazioni per una comprensione rapida e curare la salute del paziente da parte dei rispettivi esperti.