Monitoraggio ambientale con uChip

Articolo riservato agli utenti registrati

Oggigiorno, anche e soprattutto nel monitoraggio ambientale, ci si orienta verso soluzioni connesse e sempre più integrate nel concetto di IoT, ma non in tutte le applicazioni è possibile o conveniente disporre della necessaria connessione Internet. In casi del genere è possibile salvare i dati desunti dai sensori e le relative misure su un supporto non volatile come una scheda SD, per poi leggerle ed elaborarle su un Personal Computer.

Il progetto qui proposto risponde a tale esigenza applicativa, ma non è semplicemente un data logger di dati ambientali, bensì un completo sistema di monitoraggio locale dotato di uscite grafiche in grado di farci capire l’andamento delle variabili osservate, le quali, in questo caso, sono la temperatura, la pressione atmosferica e l’umidità relativa. La rappresentazione grafica è quella tipica dei monitor usati in ambiente medico, con scorrimento da destra a sinistra in modo da visualizzare sempre le ultime misure.

Per il nostro progetto utilizziamo una configurazione hardware descritta dallo schema a blocchi mostrato nella Fig. 1.

Fig. 1

Il cuore del sistema è uChip, un modulo poco più grande di un circuito integrato DIP a 16 pin, dotato di un microcontrollore a 32 bit. Il display TFT, il touch controller e la scheda SD sono collegati via bus SPI, mentre il sensore utilizza l’interfaccia I²C-Bus. Per future applicazioni è disponibile anche un’interfaccia seriale, due I/O digitali o tre ingressi analogici o un’uscita analogica. Questo sistema si presta, quindi, per sviluppare numerose altre applicazioni.
Sulla scheda SD incorporata nel display, vengono salvati i campionamenti delle tre variabili insieme al timestamp, o marca temporale, che permette di elaborare facilmente i dati sul calcolatore. L’hardware del sistema, con modeste modifiche del software, si presta anche al monitoraggio di segnali analogici.

Il sistema uChip

Questa minuscola scheda, visibile in Fig. 2, con dimensioni di soli 28,5×10,16 mm, compreso il connettore USB, è prodotta in Italia e commercializzata da Futura Elettronica (Vedi prodotti a destra).

Fig. 2

Essa è basata sulla MCU Cortex M0 SAMD21-E18A, a 32 bit con memoria Flash da 256 kB (248 kB utili, i restanti occupati dal bootloader integrato) e RAM statica da 32 kB ed è compatibile con Arduino Zero. Ha due connettori strip da 8 pin con passo identico a un chip DIL16. In Fig. 2 sono visibili entrambe le facce della scheda.
Uchip può essere alimentata da 3,3V a 5V sul pin 16 (VEXT) o a 5V dalla presa micro USB e ha un sistema di alimentazione molto sofisticato, come si vede nello schema funzionale di Fig. 3.

Fig. 3

Sono presenti uno switching Boost da 500 mA (Step-Up: converte i 3,3V da VEXT in 5V su USB) e un Buck converter da 1 A (Step-Down: da 5V USB a 3,3V su VEXT), inoltre ha anche un regolatore lineare LDO (Low Drop-Out: bassa caduta di tensione ingresso-uscita). Quest’ultimo regolatore, un NCP114 a 3,3V con tensione di dropout di 135 mV a 300 mA, alimenta la MCU e rende disponibili 3,3V 100 mA sul pin 15 mediante ponticello a saldare. La tensione VEXT non deve superare il valore di 5,5V, valore limite del regolatore LDO.

Si può alimentare la scheda dalla porta USB a 5V, usando un normale alimentatore da cellulare, oppure applicare una tensione da 3,3V a 5V sul pin 16 (VEXT). Nel primo caso, abilitando il regolatore Buck settando VEXT_SELECT (PA15), uChip alimenta altri dispositivi esterni a 3,3V fino a 1A dal pin 16 che diventa un’uscita di alimentazione. Nel secondo caso si può collegare un alimentatore da 3,3V a 5V su VEXT o una batteria al litio di opportuna capacità al pin 16 che ora diventa un ingresso.

Un diodo ideale, realizzato con un MOSFET P a bassa resistenza di conduzione, isola l’uscita del Buck. Nel caso si utilizzi la porta USB come host, essa è alimentata dal Boost, attivato automaticamente dal pin ID del connettore OTG. Il Boost è anche attivato o disattivato con il BOOST_ENABLE (PA14).

Nel caso in cui si voglia ridurre il rumore generato dagli alimentatori switching, occorre disabilitare entrambi i convertitori Boost e Buck in questo caso, la MPU non è più alimentata dalla USB ma dal pin 16 (VEXT), tensione che non deve superare i +5,5V. Durante lo sviluppo del software, il Buck è abilitato dalla presenza della tensione USB. I due alimentatori switching sono controllati via software usando la specifica libreria o intervenendo sui pin di controllo. In Fig. 4 è visibile la pin-out della scheda.

Fig. 4

In Tabella 1 sono indicati i pin disponibili di uChip e quelli usati dal progetto.

Tab. 1

Il display TFT touch 320×240 pixel da 2,4 pollici

Il display è un TFT touch da 320×240 pixel da 2,4 pollici con 18-bit per 262k colori con codifica a 6 bit per colore. Il chip di controllo usato per questo schermo è un ILI9341 mentre il Touch Screen Controller è un XPT2046.

Fig. 5

Le immagini di Fig. 5 mostrano la scheda display usata; come si vede, da un lato ha un connettore da 14 pin per il display e per il touch controller, dal lato opposto uno da 4 pin per la SD-Card.

Fig. 6

In Fig. 6 è mostrato lo schema di questa scheda, mentre in Tabella 2 si vedono i collegamenti con uChip realizzati in questo progetto. I segnali della scheda sono TTL a 3,3V e questo non è un problema per uChip che lavora a questa tensione.

Tab. 2

Il display può essere comunque alimentato a 5V grazie ad un regolatore LDO che fornisce l’esatta tensione per alimentare il TFT e la SD. Per ridurre i pin di I/O e per ottimizzare l’interfaccia, sono stati uniti in un unico bus SPI il controller grafico del display, la SD e il touch controller. Per risparmiare pin, si è anche rinunciato al reset pilotato dalla MCU collegandolo a un RC (47kΩ e 100nF) sul pin 4 del TFT.

Come funziona il sensore BME280

Il BME280 è un sensore della Bosch combinato di temperatura, pressione barometrica e umidità relativa della  Bosch, incapsulato in un minuscolo case metallico di soli 2,5×2,5×0,93 mm. Inoltre consuma pochissimo, per cui è particolarmente indicato per telefoni cellulari, ricevitori GPS od orologi.

Ha un’accuratezza sulla pressione di ±0,12 hPa che è equivalente a circa ±1 m come differenza di altitudine, con una deriva termica di solo 12,6 cm/°C. Il sensore di temperatura ha una risoluzione di 0,01 °C e un’accuratezza di ±0,5 °C a 25 °C; quanto al sensore di umidità relativa, è dichiarata un’accuratezza di ±3 %RH a 25 °C.

Il sensore ha la stessa piedinatura del popolare BMP280, che è però privo del sensore di umidità ed è alimentabile con una tensione continua compresa fra 1,7 e 3,6V; nel nostro caso è alimentato a 3,3V dal regolatore LDO (low drop-out) interno al modulo (alla breakout board sulla quale si trova commercialmente disponibile il sensore). La Fig. 7 mostra lo schema funzionale del sensore. Tutti i dettagli sul sensore Bosch si trovano nel documento tecnico BME280 “Combined humidity and pressure sensor”.

Fig. 7

Il componente ha due distinti pin di alimentazione: Vdd, alimentazione principale dei circuiti analogici e digitali e Vddio, alimentazione dell’interfaccia digitale di I/O. Nella maggior parte dei casi esse sono collegate insieme, come nel caso della breakboard da noi utilizzata nel progetto, visibile in Fig. 8.

Fig. 8

In Fig. 9 è stato ricavato lo schema di questa scheda. Essa incorpora un regolatore LDO da 3,3V e un adattatore di livello, necessario per collegarlo a un Arduino Uno o altri microcontrollori alimentati a 5V, nel caso di uChip i segnali devono essere a 3,3V e questi componenti sono del tutto inutili. Questa scheda, avendo solo 4 pin, prevede solo l’interfaccia I²C (CSB=1).

Fig. 9

Il pin SDO permette di cambiare l’indirizzo (LSB) che per default è SDO=0 (ponticello a massa) per cui l’indirizzo è 1110110 (0x76). Se SDO =1, operazione che richiede il taglio del ponticello e il collegamento a Vdd, l’indirizzo diventa 0x77, operazione non necessaria in questo caso.
La libreria Adafruit BME280 con interfaccia I²C software richiede l’assegnazione dei pin usati per il bus con la funzione Wire.begin (SDA, SCL).

Lo schema elettrico del monitoraggio ambientale con BME280

Bene, ora che sono stati analizzati i singoli moduli componenti il sistema passiamo a vedere lo schema elettrico del complesso, ovvero della scheda da noi prevista per ospitare la scheda display, la breakout board sensore e la board uChip.È stata prevista anche una interfaccia seriale e un I/O analogico sul pin A6.

schema elettrico

Per spegnere il display è utilizzato un transistor PNP a bassa VCE di saturazione, la scheda ha già un resistore limitatore R6= 3,9Ω (vedere Fig. 6) per i quattro led di retroilluminazione e, per ridurre ulteriormente i consumi, si è aggiunto un altro resistore in serie. Quindi la retroilluminazione è comandata da un segnale di I/O (ON = LOW).
Si può abilitare l’alimentatore Buck usando la funzione della libreria uChipPowerManagement.h:
uChipSetVextValue(VEXT_3V3);

Per questo sistema si consiglia l’alimentazione da connettore micro USB, questo per ridurre il consumo: utilizzando lo switching Buck di uChip si ottiene un minore consumo, ulteriormente ridotto spegnendo la retro-illuminazione del display nel normale funzionamento per accenderla solo quando deve interagire con l’operatore.
Sul pin 4 del connettore J1 dell’interfaccia seriale è possibile alimentare il sistema anche con una tensione VEXT da 3,3V a 5V. Per tensioni maggiori di 3,3V il display apparirà più luminoso. Si può usare anche una batteria agli ioni di litio (3,7V tipici). I consumi aumentano sensibilmente in quanto non è usato il regolatore Buck e il display consuma di più, per cui sarebbe da aumentare la resistenza di R3. Alimentando da USB, i consumi medi del sistema sono molto bassi: circa 12 mA senza retro-illuminazione e 38 mA quando si accende, ossia quando si interviene sul touch diplay per immettere i parametri o leggere le misure. Il display è spento automaticamente a ogni campionamento e dopo 5 secondi di inattività.

Per future applicazioni sono presenti il connettore J1 per utilizzare la Serial1 per connettersi ad altri dispositivi, come un ricevitore GPS o altro; e anche il connettore J2, che2 permette di usare l’ingresso analogico A6 a 12 bit o l’uscita del DAC a 10 bit. Questi due connettori, con opportuna inizializzazione di I/O e conseguenti modifiche al programma, permettono anche di monitorare tre segnali analogici A6 (J2), A3 e A5 (J1).

Realizzazione pratica

Per realizzare il sistema abbiamo progettato un circuito stampato a doppia faccia (nel nostro prototipo completo di serigrafia). Scaricate i file gerber e utilizzare il servizio PCBPRODUCTION (qui a destra) per realizzare il PCB.

piano di montaggio

Una volta realizzato il PCB vi si possono montare i componenti del caso, tutti discreti, seguendo la disposizione proposta nel piano di montaggio visibile in queste pagine; l’ordine di montaggio è il solito, vale a dire prima quelli a più basso profilo come le resistenze e i condensatori, poi il transistor PNP T1, da orientare esattamente come indicato nel piano di montaggio. Infine si inseriscono e si saldano le file di pin-strip necessarie a comporre gli zoccoli per ospitare la scheda display, la breakout board sensore e la scheda uChip, tutte da orientare come mostrato nel piano di montaggio e comunque per ottenere il risultato visibile nella Fig. 10. Oltre ai due connettori J1 e J2, non necessari per questa ma per future applicazioni, occorre quindi saldare file di strip femmina da 14 + 4 pin per il display, da 4 pin per il sensore e da 8 + 8 pin per la uChip.

Fig. 10

L’orologio RTC del SAMD21

La MCU SAMD21 ha incorporato un valido RTC (Real Time Clock) e uChip usa un quarzo da 32.768 Hz (FK135EIHM0.032768) molto preciso con una tolleranza di ±20 ppm e una stabilità in frequenza di -0.04 ppm/∆°C. Unico inconveniente è che, togliendo l’alimentazione si perde l’ora impostata, ma questo si può superare con qualche artificio, come si vedrà più avanti.

Alimentazione del sistema

Per alimentare il tutto ci si può rivolgere a una batteria o ad un alimentatore da rete; il metodo più semplice e capace di fornire autonomia operativa al sistema è l’utilizzo di una batteria al piombo da 12V con un carica cellulare da auto che contiene uno switching step-down da 12/24V a 5V con connettore micro USB per uChip.
L’uso di un alimentatore switching, che ha un alto rendimento, permette di ridurre ulteriormente il già basso consumo e aumentare notevolmente l’autonomia.
In alternativa, si potrebbe usare una batteria agli ioni di litio (3,7V) sul pin VEXT, accessibile sui connettori J1 e J2. In questo caso, come si è già detto, i consumi aumentano.
Dove invece è disponibile la tensione di rete, si può ricorrere a un normale alimentatore da 5V per cellulari con connettore micro USB; ciò comporta però l’inconveniente di perdere l’orologio in caso di black-out anche brevi. Il sistema può essere perfezionato usando due semplici pile da 1,5V collegate con un diodo in serie sulla VEXT. Nel caso di interruzione della rete luce le pile mantengono una tensione di circa 2,4V, bassa per il display ma sufficiente per far funzionare la MCU.
Un sistema più complesso di alimentazione potrebbe essere quello di tenere in tampone la batteria al piombo, con un alimentatore stabilizzato da 13,5V. La batteria potrebbe essere anche di modesta capacità (1,2 Ah) garantendo la continuità di funzionamento anche per qualche giorno di black-out.

Le librerie usate

Spostiamoci ora sugli aspetti firmware, partendo dalla descrizione delle librerie impiegate e, nello specifico, da quella per il display, il cui controller è un ILI9341; per esso sono disponibili diverse librerie Arduino e noi abbiamo usato la Adafruit_GFX, insieme alla Adafruit_ILI9341 scritte dalla bravissima Limor Fried (Lady Ada). La prima contiene tutte le primitive grafiche e la seconda le specifiche del controller usato dal display. Molto utile anche il manuale della GFX.
Per il touch controller XPT2046 abbiamo utilizzato la libreria XPT2046_Touchscreen di Paul Stoffregen che sfrutta il bus SPI hardware.

Anche per il sensore BME280 sono state utilizzate le librerie Adafruit: Adafruit_Sensor.h e Adafruit_BME280.h.
Quanto alla uChip, va scaricata la libreria del produttore della scheda, per caricare sulla IDE di Arduino la libreria basta seguire le indicazioni (in inglese) del manuale. Per Windows 10 non occorre scaricare il relativo driver, necessario per le versioni precedenti.
Per le modalità di installazione vedere la guida “uChip quick start manual”.

Il funzionamento del sistema

Vediamo ora il funzionamento complessivo del sistema di monitoraggio ambientale, con il quale andremo a registrare temperatura, pressione e umidità relativa sulla scheda SD. L’orologio RTC è molto importante non solo per indicare a ogni misura il tempo esatto, ma anche per scandire il periodo di campionamento.

L’indicazione del tempo: il timestamp

Per avere una corretta collocazione temporale occorre accompagnare gli eventi con una marca che prende il nome di timestamp. Noi umani siamo abituati a indicare il tempo come data e ora, espressi in modo non decimale e anche diversamente espresso in molte zone del mondo. Questa marcatura del tempo risulta di difficile gestione se dobbiamo valutare differenze di tempo tra un evento e l’altro o creare grafici di serie temporali di campioni.

Nei sistemi operativi Unix e Unix-like il tempo viene rappresentato come secondi trascorsi dalle ore zero del primo gennaio 1970 e prende il nome di epoca.
L’epoca Unix è un numero di 32 bit con segno, e il 19 gennaio 2038 si raggiungerà l’overflow del contatore con problemi di tantissimi computer che usano un contatore a 32 bit.
La libreria RTClib ha la funzione getEpoch() che restituisce l’epoca come unsigned long, il cui overflow è invece il 07 Feb 2106 06:28:15.
Anche per una più facile leggibilità, in questo progetto si è preferito indicare il timestamp con due numeri interi (long) di massimo cinque cifre. Il primo numero rappresenta i giorni trascorsi dal 1° gennaio 1900, naturalmente esso tiene conto degli anni bisestili, il secondo numero indica i secondi a partire dalla mezzanotte. In questo modo è facile plottare la serie temporale delle misure ambientali.

Questo metodo è usato anche dai fogli elettronici come Excel, che ha come riferimento iniziale il 1° gennaio 1900 e non il 1970 mentre Matlab ha il 1° gennaio dell’anno zero, per passare da un sistema all’altro basta sommare i giorni di differenza.
Con la libreria RTClib il giorno seriale si calcola facilmente dall’epoca, dividendola per i secondi nel giorno (86400) e prendendo la parte intera. Per avere come riferimento il 1° gennaio 1900 occorre sommare i giorni corrispondenti agli anni dal 1900 al 1970:

days1900= long(epoch/86400)+ 25569; //days elapsed since 1/1/1900

Per quanto riguarda i secondi del giorno, basta trasformare ore, minuti e secondi in secondi che rappresentano la frazione del giorno:

secondspd= ho*3600 + mi*60 + se; //seconds elapsed in the day

Il programma trasferisce questi due numeri interi (long) sulla SD insieme alla temperatura in [°C], la pressione barometrica in hectopascal [1 hP = 1 millibar] e all’umidità relativa in [%].
Questi cinque numeri sono separati da virgole. Il file ha nome fisso e le misure sono via via appese in coda.
Ecco come si presenta il file ASCII:
44115,34800,27.0,933.0,43
44115,35100,24.6,933.0,49
44115,35400,23.3,932.9,52
……

Nel programma di elaborazione su PC si sono espressi i secondi in frazione di giorno = secondi/86400 sommandoli poi ai giorni.
Si sono elaborati i dati in Matlab, ma si possono elaborare anche con un foglio elettronico. In Excel la funzione DATA.VALORE(“11/09/2020”) restituisce il numero seriale 44085, la data è passata come stringa. Dato il numero seriale, la funzione inversa GIORNO(44085) restituisce il numero 11, MESE(44085) il numero 9 e ANNO(44085) il numero 2020. Se si inserisce anche la frazione di giorno, si possono ricavare anche l’ora, i minuti e i secondi. La Tabella 3 ne è un esempio:
Basta importarli come file testo con la virgola come separatore, quindi calcolare il numero seriale e da questo ricavare giorno, mese, anno, ora, minuti e secondi con le funzioni Exel che hanno lo stesso nome.

Tab. 3

Generazione del nome dei file

Si è utilizzata l’epoca per generare i nomi dei file dati con la risoluzione di soli 10 secondi. Partendo da un riferimento molto vicino, ossia il primo di novembre 2020, con quattro cifre si posso indicare i giorni per altri 27 anni e con altre quattro cifre si possono identificare i 10 secondi del giorno (8640/giorno), supponendo di non creare un file per tempi inferiori ai dieci secondi.
Per cui è generato il nome del file lungo 8 caratteri. Esso viene generato ad ogni inizio acquisizione e stampato sulla finestra “MISURE”.
Qui di seguito, il programma di generazione:

// days since 01 Nov 2020 00:00:00
ng= int((epoch-1604188800)/86400);
// seconds/10 from midnight
nm= int(secondspd/10);
// file name
String fn=Conv4digits(ng)+Conv4digits(nm)+ “.TXT”;
// String to char array conversion
fn.toCharArray(filename,13);

String Conv4digits(int n) {
if (n < 10) return “000” + String(n);
else if (n < 100) return “00” + String(n);
else if (n < 1000) return “0” + String(n);
else return String(n);
}

Il nome dei file generati da Arduino non deve superare gli otto caratteri, come nel vecchio DOS, per cui il programma controlla che il numero di giorni non superi i quattro caratteri, ossia che sia compreso tra 0000 e 9999, con queste istruzioni:

// check the lower limit of days
if (ng < 0) ng = 0;
// days must be 4 characters long
if (ng > 9999) ng= 9999;

Rappresentazione grafica dei dati ambientali

Per rappresentare i diagrammi storici delle tre grandezze misurate con il sensore BME280 occorre memorizzare le misure in un buffer di opportune dimensioni.
Il display TFT ha una definizione di 320×240 pixel, che si può organizzare come 240 punti sull’asse X e 320 sull’asse Y.
Volendo usare tutti i 240 pixel per rappresentare le misure nelle ventiquattro ore si deve campionare ogni 1440/240 = 6 minuti (= 360 s), il che va più che bene per misure ambientali.
Con la MCU SAMD21 di uChip non ci sono i problemi di memoria che ci sarebbero con un Arduino Uno e una matrice di 3×240 interi (1440 byte) non è critica. Si potrebbe usare anche una matrice di float (2880 byte), ma è meglio non perdere troppo tempo nelle conversioni durante la grafica mentre si dispone di tempi elevati tra una misura e l’altra.
Si è scelto di avere un unico buffer GBuff organizzato come array di tre righe per 240 colonne di elementi interi:

int GBuff [3][240]; // data buffer for graphics

Le tre righe rappresentano la temperatura, la pressione barometrica e l’umidità relativa. Le misure sono in float e, tenendo presente l’accuratezza del sensore e il miglior dettaglio dei grafici, si trasferiscono nel buffer gli interi che rappresentano la temperatura in decimi di grado, la pressione in decimi di hP e l’umidità in per mille trasformate nel vettore GVal[3].
A ogni campionamento si calcolano il massimo e il minimo di ogni variabile GVal[j]:

for (int j=0; j <= 2; j++){
if (GVal[j] > ValMax[j]) ValMax[j] = GVal[j];
if (GVal[j] < ValMin[j]) ValMin[j] = GVal[j];
}

Questi valori servono per creare i grafici in auto scala, tracciando le curve tra questi valori si ottiene una rappresentazione più dettagliata. Il massimo e il minimo sono calcolati dall’avvio del sistema. Il trasferimento dei dati nel buffer ha due modi di funzionamento.
All’inizio (first_buffer = true) il registro si riempie a partire da sinistra, dall’indice di colonna BuffInd =0 fino a BuffInd =239, ultimo punto a destra:

if (first_buffer){
for (int j=0; j <= 2; j++){
GBuff[j][BuffInd]= GVal[j];
}
BuffInd++;
if (BuffInd == 240) first_buffer = false;

Una volta riempito il buffer, cambia il modo di riempimento, tutti gli elementi meno l’ultimo, scorrono di una posizione verso sinistra:

for (int j=0; j <= 2; j++){
for (int i=0; i <= 238; i++){
// shift left previous values
GBuff[j][i]= GBuff [j][i+1]; }
}

Quindi le misure dell’ultimo campionamento sono trasferite nell’ultima posizione (BuffInd = 239):

for (int j=0; j <= 2; j++){
// update buffer with last values
GBuff[j][239]= GVal[j];
}

La funzione PlotMeasures(int k) graficherà tutte e tre le misure in tre distinti grafici da 240×100.
Lo shift dei dati verso sinistra crea uno scorrimento della traccia con un effetto simile a quello dei vecchi registratori a carta e si ottiene un trend storico delle misure nelle ultime 24 ore, assai utile per le previsioni meteo.

Il menu delle opzioni

Premendo il display touch, in qualsiasi momento, appare un menu con quattro possibili opzioni, corrispondenti a quattro pulsanti, come si vede in Fig. 11.

Fig. 11

La prima volta è necessario premere l’ultimo tasto, “SETTAGGI” di colore azzurro, per impostare il periodo di campionamento in secondi, quindi anno (le ultime due cifre), mese, giorno, ora, minuti e secondi. Per impostare questi sette parametri numerici si utilizza la funzione GetNum(String prompt) che attiva la tastiera virtuale numerica, come si vede in Fig. 12.

Fig. 12

Dopo aver digitato il parametro richiesto, occorre confermare con ”ok” o cancellare l’immissione con il tasto “C”. Il settaggio termina dopo aver inserito i secondi. Da programma non è possibile l’opzione settaggi se l’acquisizione è in corso, ossia se dal display viene mostrata la scritta “Acquisizione…”
Il secondo tasto, “MISURE”, mostra la data e l’ora relativi all’ultimo campionamento, i valori delle misure, il numero dei campioni salvati su SD, i minimi e i massimi delle misure e il nome del file, come si vede in Fig. 13.

Fig. 13

In questo caso sono stati acquisiti su SD Nc=269 campionamenti. Le ultime righe indicano i valori minimi e massimi, che sono anche gli estremi dei grafici.
Nell’ultima versione del programma, nel caso in cui sia stata avviata l’acquisizione, è indicato anche il nome del file su cui si trasferiscono le misure.
Il tasto giallo “GRAFICI” mostrerà i diagrammi temporali delle tre variabili, visibili in Fig. 14.

Fig. 14

Questo campionamento, come si vede dalla Fig. 13, è stato fatto con periodo di 60 secondi, quindi le variabili fisiche sono variate di poco e l’autoscala crea i tipici gradini.
Il tasto rosa, se non è inserita la scheda SD, rimane senza scritta ed è inutilizzato. Se la SD è presente e non abbiamo ancora avviato l’acquisizione compare la scritta “Acq. Start/Stop”. Premendo il tasto avviamo l’acquisizione e il tasto diventa temporaneamente rosso con la scritta “Inizio Acquisizione” per poi tornare rosa con la scritta “Acquisizione…”. Quando vogliamo terminare l’acquisizione premiamo questo tasto che diventerà brevemente verde con la scritta “Fine Acquisizione”, dopo questo è possibile togliere la SD.
Elaborando le misure con Matlab, si ottengono le seguenti uscite:

Elaborazioni misure ambientali di uChip
Nome file elaborato = 00583660.TXT
Data inizio registrazione = 29-Dec-2020 10:11:04
Data fine registrazione = 29-Dec-2020 11:33:04
Numero campioni acquisiti = 83
Durata registrazione = 82.00 [minuti]

Il grafico corrispondente è mostrato quello in Fig. 15.

Fig. 15

Confrontando i grafici di Fig. 14 con quelli della Fig. 15 si può notare che sono molto simili, tenendo presente che Matlab unisce i punti con curve interpolate e che le scale orizzontali sono molto diverse.
Il programma scritto in Matlab per elaborare i file è quello nel Listato 1.

Listato 1

% program TPHread.m legge i dati scritti dal sistema UChip
% di misure ambientali con data in giuliano e ora in secondi
% Giovanni Carrera 29 ott 2020
clear
clc
files= dir(‘*.TXT’);
nfile=size(files,1);% numero file trovati

for indf=1:nfile,
fprintf(‘%d) %s\n’,indf,files(indf).name);
end
while true
nf = input(‘numero di file da leggere = ‘);
if (nf>=1) && (nf<=nfile), break, end
end
nomefile = files(nf).name;
fid = fopen(nomefile);
if fid==-1
error([nomefile ‘: il file non esiste’]);
end
DELIMITER = ‘,’;
HEADERLINES = 0;
% Import the file
Data = importdata(nomefile, DELIMITER, HEADERLINES);
Gd = Data(:,1);% vettore giorno in giuliano
t = Data(:,2);% vettore tempo in secondi
julian = Gd+t/86400+693960;% aggiunge la frazione giorno e adatta l’anno
T = Data(:,3);% temperatura in [°C]
P = Data(:,4);% pressione in [hP]
RH = Data(:,5);% umidità relativa in [%]
Ns = size(Data,1);
clear Data;
disp(‘Elaborazioni misure ambientali di uChip’)
fprintf(‘Nome file elaborato = %s\n’,nomefile);
fprintf(‘Data inizio registrazione = %s\n’, datestr(julian(1)));
fprintf(‘Data fine registrazione = %s\n’, datestr(julian(end)));
fprintf(‘Numero campioni acquisiti = %d \n’, Ns);
Rt = julian(end)-julian(1);
fprintf(‘Durata registrazione = %6.2f [minuti]\n’, Rt*1440);
tz =julian-julian(1);
figure(1);
subplot(3,1,1), plot(tz,T,’r’,’LineWidth’,2),grid,ylabel(‘T [C]’),title([‘File: ‘ nomefile])
subplot(3,1,2), plot(tz,P,’g’,’LineWidth’,2),grid,ylabel(‘P [hP]’)
subplot(3,1,3), plot(tz,RH,’b’,’LineWidth’,2),grid,ylabel(‘H [%]’),xlabel(‘days’)

Chi non ha Matlab, può scaricare gratuitamente il programma GNU Octave che ora ha anche una buona interfaccia grafica utente. Questo programma funziona anche con Octave senza modifiche.
Il firmware della uChip è troppo voluminoso per entrare in questo articolo, ma lo trovate nella sezione downlod del nostro sito insieme agli altri file del progetto.

Conclusioni

Il progetto qui proposto è la base per realizzare sistemi di rilevamento di vari parametri, anche non necessariamente ambientali: è sufficiente scegliere i sensori adatti e modificare il firmware.

Download del progetto

Gerber per la realizzazione del PCB

Il firmware per il monitoraggio ambientale

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Menu