Arduino Data/Time Plotting/Logging utilizzando Millis() e PfodApp: 11 passaggi

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

Nessuna programmazione Arduino o Android richiesta. Sono supportati anche i moduli RTC e GPS. Correzione automatica per fusi orari, deriva RTC e secondi intercalari mancanti GPS

introduzione

Questo tutorial ti mostra come utilizzare i tuoi timestamp Arduino millis() per tracciare i dati rispetto a data e ora sul tuo cellulare Android utilizzando pfodApp.

Nessuna programmazione Arduino o Android richiesta. pfodApp registra anche dati sufficienti in modo da poter successivamente riprodurre i grafici di data/ora in un foglio di calcolo.

NESSUN modulo RTC o GPS è necessario, tuttavia se il tuo progetto Arduino ha un RTC (Real Time Clock) o un modulo GPS possono essere utilizzati anche. In questi casi, i grafici pfodApp verranno automaticamente corretti per fuso orario, deriva RTC e secondi intercalari mancanti GPS. Non è richiesto alcun codice Arduino speciale per queste correzioni. Come sempre con pfodApp, i dati ricevuti vengono registrati esattamente così come sono, non corretti, tuttavia il file di registro contiene anche informazioni sufficienti per consentirti di applicare queste correzioni da solo quando scarichi i registri sul tuo computer. Vedi sotto per esempi di questa post-elaborazione.

È supportata un'ampia varietà di formattazione dell'asse X di ora e data, tutte completamente controllate da brevi stringhe di testo nello schizzo Arduino. Non è richiesta alcuna programmazione Android.

pfodApp si connetterà tramite WiFi, Bluetooth Classic, BLE e SMS. Il pfodDesigner gratuito genera schizzi Arduino completi per il tracciamento/registrazione di data/ora per connettersi a un'ampia varietà di schede. Non è richiesta alcuna programmazione Arduino.

Questo istruibile utilizzerà un Adafruit Feather52 come scheda Arduino di esempio, che si collega tramite BLE.

Questa istruzione copre tre casi:- 1) Il progetto del tuo microprocessore ha solo timestamp in millisecondi – millis()2) Il tuo progetto del microprocessore ha un orologio in tempo reale (RTC) – pfodApp corregge automaticamente la deriva. 3) Il tuo progetto a microprocessore ha un modulo GPS: pfodApp corregge automaticamente i secondi intercalari man mano che si verificano (attualmente 18 secondi al 2018).

Passaggio 1: utilizzo dei timestamp dei millisecondi di Arduino, Millis()

Ci sono due parti per usare i millisecondi per la data e l'ora. Uno è per tracciare i dati rispetto al tempo trascorso o alla data/ora e l'altra parte sta ricreando la data e l'ora dai timestamp dei millisecondi dei dati grezzi registrati. pfodApp non modifica i dati grezzi ricevuti dal pfodDevice (il micro Arduino). Registra esattamente i byte ricevuti.

Per prima cosa usa il pfodDesigner gratuito per generare uno schizzo Arduino per il tuo micro che invierà i millisecondi e le misurazioni dei dati a pfodApp per la stampa/registrazione. Questo esempio crea un menu per la scheda Adafruit Feather 52 BLE che legge A0. Il tutorial su Adafruit Feather nRF52 LE - Controlli personalizzati con pfodApp segue i passaggi di pfodDesigner per creare un menu per Feather nRF52 che includa un pulsante Grafico, quindi dai un'occhiata per maggiori dettagli. In questo tutorial aggiungeremo solo un pulsante grafico e utilizzeremo le nuove opzioni di formato dell'asse X per tracciare le letture A0 rispetto al tempo trascorso e alla data/ora.

La prima parte di questo tutorial verrà illustrata utilizzando il pfodDesigner gratuito per creare un grafico di data/ora di esempio sul tuo cellulare Android. Quando sei soddisfatto del display puoi generare lo sketch Arduino che lo riprodurrà quando ti connetterai con pfodApp. Non è richiesta alcuna programmazione Android e poiché pfodDesigner genera schizzi Arduino completi per un'ampia varietà di schede Arduino, non è necessaria nemmeno la programmazione Arduino.

Passaggio 2: aggiunta di un grafico al menu

Scarica l'app pfodDesigner da Google Play, aprila e fai clic su "Avvia nuovo menu"

Fare clic su "Target Serial" e quindi sul pulsante "Bluetooth Low Energy" per visualizzare l'elenco di circa 11 schede BLE (scorri verso il basso per vedere le altre scelte). Seleziona su Adafruit Bluefruit Feather52.

Torna al menu Modifica e fai clic su "Modifica prompt" e imposta un prompt adatto per questo menu, ad es. "Feather52" e testo in grassetto e dimensione +7. Il colore di sfondo è stato lasciato come "predefinito" Bianco

Torna indietro e fai clic su "Aggiungi voce di menu", scorri verso il basso e seleziona "Pulsante grafico" che apre la schermata di modifica del pulsante grafico. Puoi apportare qualsiasi modifica all'aspetto del pulsante qui. In questo caso il testo del pulsante è stato modificato in "Grafico data/ora di A0" e gli altri valori predefiniti sono stati lasciati così com'è.

Questo ti dà un pulsante nel menu che aprirà la schermata del grafico.

Passaggio 3: modifica del codice sorgente e delle etichette

Fare clic sul pulsante "Grafico data/ora di A0" per aprire la schermata Modifica grafici, dove è possibile accedere all'etichetta del grafico, al formato dell'asse X, all'intervallo dei dati del grafico e (scorrendo verso il basso) le impostazioni del grafico stesso. Modifica l'etichetta del grafico in qualcosa di adatto, ad es. “A0 Volt”.

Scorri verso il basso e per i grafici 2 e 3 apri Modifica grafico e fai clic su Nascondi grafico per rimuoverli dalla visualizzazione del grafico.

Quindi fare clic su "Edit Plot 1" e impostare un'etichetta di plot (ad es. A0), unità yAxis (ad es. Volt), visualizzare un massimo di 3,6 V e connettersi al pin I/O A0.

Scorri verso l'alto e fai clic su "Anteprima grafico" fino ai punti dati di esempio 0 più recenti, a intervalli di 1 secondo, tracciati rispetto al tempo trascorso in minuti: secondi.

Per tutti i grafici del tempo trascorso non vengono visualizzate le unità di zero iniziali, quindi in questo grafico solo i tempi > 1 min hanno i minuti iniziali.

Passaggio 4: scelta del formato data/ora

Per i grafici del tempo trascorso, l'unità principale continua ad aumentare con il passare del tempo. Per vedere un esempio di ciò, torna alla schermata "Modifica grafici" e aumenta l'intervallo dei dati del grafico a 15 minuti (in fondo a questa schermata)

Quindi fare clic su Anteprima grafico per mostrare gli stessi dati di esempio ma ora con intervalli di 15 minuti tra i campioni. Come puoi vedere la parte dei minuti di mm:ss continua ad aumentare.

Ora torna indietro e fai clic sul pulsante dell'asse X per mostrare una piccola selezione di tutti i possibili formati di dati/ora dell'asse X (scorri verso il basso per ulteriori informazioni)

Sopra c'è una selezione di anteprime dei grafici che utilizzano diversi formati dell'asse X.

I grafici di data/ora mostrati qui sono nel fuso orario "locale". Ci sono anche opzioni di formato per tracciare data/ora in UTC. Per un set completo di possibili opzioni di formato data/ora, vedere pfodSpecification.pfd.

Passaggio 5: generare e testare lo schizzo Arduino

Una volta che sei soddisfatto del formato del tuo grafico e dell'intervallo di dati, puoi accedere alla schermata "Menu di modifica_1" e scorrere verso il basso e "Genera codice" per la scheda di destinazione scelta. Ecco uno schizzo di esempio per Adafruit Feather52 utilizzando intervalli di dati di 1 secondo e un formato di tempo trascorso mm: ss, pfodFeather52_timeplot.ino

Sopra c'è una trama di A0 dal Feather52

Modificando il formato in Weekday hr:mins:sec (~E HH:mm:ss) e rigenerando il codice (pfodFeather52_dateplot.ino) si ottiene un grafico come il secondo sopra.

Puoi modificare il formato dell'asse X direttamente nel tuo schizzo Arduino, come descritto di seguito.

Passaggio 6: in che modo PfodApp traccia data/ora da Millis()?

Quando pfodApp si connette, ricorda la sua ora "locale" e UTC e richiede i timestamp dei dati del grafico corrente di pfodDevice (la scheda Arduino). Utilizzando queste informazioni pfodApp può quindi tracciare timestamp in millisecondi come tempo trascorso, ad esempio convertendo millisecondi in ore mins sec ecc., oppure tracciare la data e l'ora che i timestamp in millisecondi rappresentano rispetto a quando è stata effettuata la connessione e l'ora corrente di pfodDevice è stata richiesta.

Guardando nello schizzo generato da Arduino (ad esempio pfodFeather52_dateplot.ino), ci sono tre piccoli bit di codice che gestiscono il lato Arduino dei grafici.

La sezione del codice loop() che gestisce la richiesta dell'ora corrente {@} di pfodApp

// gestisce la richiesta {@} } else if('@'==cmd) { // pfodApp ha richiesto l'ora 'corrente' plot_mSOffset = millis(); // cattura i millisecondi correnti come data e ora di offset dei dati grezzi parser.print(F("{@`0}")); // restituisce `0 come millisecondi di dati grezzi 'correnti'

Potresti semplicemente restituire il valore corrente di millis(), ma millis() torna a 0 ogni 49,7 giorni, il che farebbe tornare indietro la trama. Quindi, invece, il codice ricorda il valore millis() corrente quando è stata effettuata la richiesta {@} e restituisce {@`0} cioè un timestamp di millisecondo corrente pari a zero. Quindi, quando si inviano i punti dati grezzi, lo schizzo utilizza

plot_1_var = analogRead(A0); // leggi l'input per tracciare // plot_2_var plot Nascosto, quindi nessun dato assegnato qui // plot_3_var plot Nascosto, quindi nessun dato assegnato qui // invia i dati del grafico in formato CSV parser.print(millis()-plot_mSOffset); // tempo in millisecondi ….

in modo che il timestamp in millisecondi inviato con i dati inizi da 0 e aumenti fino a 49,7 giorni. Se rimani connesso continuamente per 49,7 giorni, vedrai la trama tornare indietro di ~ 50 giorni. La disconnessione e la riconnessione una volta ogni 49,7 giorni lo evitano.

La terza parte del grafico data/ora è il messaggio del grafico.

} else if('A'==cmd) { // utente premuto -- 'Date/Time plot of A0' // nel menu principale di Menu_1 // return plotting msg. parser.print(F("{=A0 Volt~E HH:mm:ss|data|A0~~~Volt||}"));

Quando l'utente preme il pulsante "Date/Time plot of A0", pfodApp invia il cmd {A} al pfodDevice e il pfodDevice risponde con il messaggio plot, {=…{=A0 Volts~E HH:mm:ss|date |A0~~~Volt||}che contiene il formato dell'asse X E HH:mm:ss

I formati Java SimpleDateFormat sono accettabili qui. pfodApp Data Logging and Plotting e pfodSpecification.pdf hanno maggiori dettagli sul messaggio di plot.

Passaggio 7: riproduzione dei grafici di data/ora sul computer

Per impostazione predefinita, pfodApp registra tutti i dati grezzi in entrata in un file di registro sul tuo cellulare, a meno che tu non abbia disabilitato questa registrazione nella schermata di modifica della connessione, vedi pfodAppForAndroidGettingStarted.pdf

Quando modifichi pfodApp, viene visualizzato un breve messaggio con la posizione e il nome del file di registro, ad es. /pfodAppRawData/pfod_bluefruit52.txt Quel file è in formato CSV, delimitato da virgole, e dopo averlo trasferito sul tuo computer (vedi pfodAppForAndroidGettingStarted.pdf per le opzioni di trasferimento), puoi aprirlo in un foglio di calcolo per tracciare i dati.

Ecco le prime righe di un file di registro.

// pfodApp V3.0.360, ora locale, UTC, mS al giorno, ora corrente pfod bluefruit52 (mS), ora corrente pfod bluefruit52, // connesso a, 2019/04/20 11:32:50.238, 2019/04/20 01:32:50.238, 86400000, 0, 366, 0,25,, 1366, 0,29,, 2366, 0,31,, 3366, 0,33,, 4366, 0,33,, Sopra puoi vedere l'ora "locale" e UTC che pfodApp si è connessa a Feather52 e l'ora corrente in mS che Feather52 ha riportato tramite la risposta {@..}. L'ultima colonna è vuota, perché non c'è RTC o GPS e quindi Feather52 non ha riportato l'ora corrente in aaaa/MM/gg.

Per tracciare i dati rispetto al tempo trascorso, sottrarre l'ora corrente (mS) dal timestamp in millisecondi e quindi dividere per il valore mS al giorno. Ecco il foglio di calcolo con la formula aggiunta e il risultato tracciato. Il foglio di calcolo, di seguito, (pfod_bluefruit52.xls) è un foglio di calcolo di OpenOffice salvato in formato Excel.

In OpenOffice, il grafico è un grafico a dispersione e l'asse x del grafico è stato formattato in HH:MM:SS Nota: i formati di data/ora del foglio di calcolo NON sono gli stessi dei formati di grafico utilizzati da pfodApp. Ad esempio in pfodApp, MM è mesi e mm sono minuti.

Per tracciare la data e l'ora, devi solo aggiungere il tempo di connessione all'ora del foglio di calcolo e ripetere il plot. (pfod_bluefruit52_date.xls)

Nota: l'ora locale e l'UTC sono state importate come testo nel mio foglio di calcolo, quindi ho dovuto rimuovere l'iniziale ' prima di utilizzarle in una formula.

Passaggio 8: come evitare il limite di 49,7 giorni Millis() e perché non dovresti

Come menzionato sopra in Come pfodApp traccia la data/ora da millis()?, se rimani connesso continuamente per più di 49,7 giorni, i timestamp in millisecondi torneranno a zero. Alcune righe di codice possono evitarlo, ma non è raccomandato.

Innanzitutto come evitare l'avvolgimento. Aggiungi un'altra variabile int senza segno per tenere traccia del numero di volte in cui i timestamp si avvolgono e stampa il risultato combinato in HEX.

uint_t mSwrapCount = 0;uint32_t lastTimeStamp = 0;

… plot_1_var = analogRead(A0); // leggi l'input per tracciare // plot_2_var plot Nascosto, quindi nessun dato assegnato qui // plot_3_var plot Nascosto, quindi nessun dato assegnato qui // invia i dati del grafico in formato CSV uint32_t timeStamp = millis()-plot_mSOffset; if (timeStamp < lastTimeStamp) { // timeStamp riportato a 0 mSwrapCount++; // aggiungi uno per contare } lastTimeStamp = timeStamp; parser.print("0x"); parser.print(msWrapCount, HEX); parser.print(timeStamp, HEX);// tempo in millisecondi in HEX ….

Quando si restituisce la risposta {@.., cancellare anche mSwrapCount.

// gestisce la richiesta {@} } else if('@'==cmd) { // pfodApp ha richiesto l'ora 'corrente' plot_mSOffset = millis(); // cattura i millisecondi correnti come offset di data e ora di dati grezzi mSwrapCount = 0; // cancella il conteggio degli avvolgimenti. parser.print(F("{@`0}")); // restituisce `0 come millisecondi di dati grezzi 'correnti'

I timestamp ora forniranno il valore "corretto" per i prossimi 40,7 giorni * 65536 ~= 7308 anni.

pfodApp convertirà automaticamente i timestamp esadecimali per la stampa e li registrerà esattamente come ricevuti, ovvero in formato esadecimale. Nel foglio di calcolo (OpenOffice) usi questa formula per convertire la stringa esadecimale, in A2, in mS (dove A1 è una cella vuota) =HEX2DEC(REPLACE(A2;1;2;A1))

Perché non vuoi farlo?

Come mostrato sopra, è facile estendere i timestamp mS a più di 50 giorni. Tuttavia, probabilmente non vorrai farlo perché diventano sempre più imprecisi. Un tipico cristallo da 16 Mhz utilizzato per creare i risultati millis() nel micro ha una precisione di ~ 50 ppm (parti per milione). Ciò significa che dopo 49,7 giorni il timestamp del millisecondo può essere scaduto di 3 minuti e mezzo e questo ignora l'effetto della temperatura sulla precisione del cristallo.

Su brevi periodi di connessione, questa imprecisione non è un problema poiché la risposta {@.. risincronizza il timestamp in millisecondi con la data/ora del cellulare a ogni riconnessione. Tuttavia, se vuoi rimanere connesso per lunghi periodi di tempo (giorni) e registrare continuamente i dati, allora dovresti usare qualcosa di più accurato del millis() integrato, come un modulo RTC o GPS.

Passaggio 9: utilizzo di un RTC (orologio in tempo reale)

Sono disponibili numerosi moduli RTC, uno dei più precisi è DS3231, ad es. Il modulo DS3231 di Adafruit. La precisione dichiarata è di +/-2ppm tra 0 e 40C. cioè ~+/-5 sec/mese.

Se desideri tracciare dati con data/ora, ad es. 2019/04/19 20:4:34, quindi è necessario modificare la risposta {@ per restituire la data/ora corrente, ad es. {@`0~2019/4/19 3:33:5}. Ecco alcune modifiche al codice di esempio da applicare allo schizzo generato da pfodDesigner per l'utilizzo di un modulo RTC, supponendo che tu stia utilizzando la libreria RTClib e abbia aggiunto il codice per inizializzare il modulo RTC.

// gestisce la richiesta {@} } else if('@'==cmd) { // pfodApp ha richiesto l'ora 'corrente' plot_mSOffset = millis(); // cattura i millisecondi correnti come offset dei dati grezzi dei dati grezzi parser.print(F("{@`0"}); // restituisce `0 come millisecondi dei dati grezzi 'correnti' parser.print('~'); // inizia la stringa di data/ora DateTime now = rtc.now() sendDateTime(&now); // invia yyyy/M/d/ H:m:s a parser.print, passa indirizzo & come argomento parser.print('}'); // fine della {@ risposta ad es. {@`0~2019/4/19 3:33:5}….

// invia la data e l'ora al parser printvoid sendDateTime(DateTime* dt) { parser.print(dt->year(), DEC); parser.print('/'); parser.print(dt->mese(), DEC); parser.print('/'); parser.print(dt->day(), DEC); parser.print(' '); parser.print(dt->hour(), DEC); parser.print(':'); parser.print(dt->minute(), DEC); parser.print(':'); parser.print(dt->second(), DEC); }

void sendData() { if (plotDataTimer.isFinished()) { plotDataTimer.repeat(); // riavvia il timer dei dati del grafico, senza deriva // assegna i valori alle variabili del grafico dalle variabili del loop o leggi gli ingressi ADC plot_1_var = analogRead(A0); // leggi l'input per tracciare // plot_2_var plot Nascosto, quindi nessun dato assegnato qui // plot_3_var plot Nascosto, quindi nessun dato assegnato qui // invia i dati del grafico in formato CSV DateTime now = rtc.now(); sendDateTime(&now); // invia aaaa/M/g/ H:m:s a parser.print, passa l'indirizzo e come arg. parser.print(', '); parser.print(((float)(plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print(', '); // Il diagramma 2 è nascosto. Nessun dato inviato. parser.print(', '); // Il diagramma 3 è nascosto. Nessun dato inviato. parser.println(); // fine del record di dati CSV } }

La parte ~2019/4/19 3:33:5 della risposta {@ consente a pfodApp di sapere quale secondo pfodDevice è la data e l'ora correnti. Il tuo schizzo può quindi inviare dati con timestamp yMd Hms e pfodApp li riporterà come tempo trascorso dal tempo di connessione OPPURE come data e ora, a seconda del formato dell'asse X specificato.

Quando si traccia la data e l'ora, la routine di stampa pfodApp corregge qualsiasi "deriva" nell'RTC confrontando l'ora corrente riportata da pfodDevice con l'ora corrente del cellulare. Questa correzione gestisce anche l'impostazione dell'RTC su un fuso orario diverso dal fuso orario locale del tuo cellulare. i timestamp millis() continuano a funzionare come in Utilizzo dei timestamp millisecondi di Arduino, passaggio 5 sopra.

Ecco un esempio di foglio di calcolo delle temperature ambiente in un periodo di 8 giorni, Office_Temp.xls Quando il file di registro è stato importato, la prima colonna è stata contrassegnata come YMD per convertire il testo in una data/ora. È ancora necessario rimuovere l'iniziale ' dalle voci dell'ora locale, UTC e Office Temp per fare in modo che il foglio di calcolo le interpreti come date e ore.

Per ottenere lo stesso grafico mostrato da pfodApp, è necessario calcolare la "Data/Ora corretta". In questo caso l'ora dell'RTC è 2 secondi indietro rispetto all'ora locale del cellulare, quindi a ogni data e ora dell'RTC viene aggiunto (ora locale – ora attuale di Office Temp) per ottenere l'ora locale reale.

Per i grafici del tempo trascorso, crea una nuova colonna contenente (data/ora timstamp - l'ora corrente dell'ufficio) e usalo come asse X nel grafico (Office_TempElapsed.xls) In realtà in questo caso, pfodApp produce grafici del tempo trascorso più belli in giorni ore:min:sec.

Passaggio 10: utilizzo di un modulo GPS

L'utilizzo di un modulo GPS è simile all'utilizzo di un modulo RTC, tranne per il fatto che i moduli GPS hanno millisecondi disponibili, gli anni iniziano a 2000 e l'ora non contiene i secondi intercalari UTC (vedi https://tycho.usno.navy.mil/leapsec.html) La data e l'ora del GPS sono attualmente 18 secondi avanti rispetto all'UTC, a gennaio 2018.

La libreria Adafruit GPS per Adafruit Ultimate GPS, a differenza di RTClib, non aggiunge l'offset di 2000 anni agli anni GPS, quindi è necessario aggiungerlo quando si invia la data e l'ora. Anche se la libreria GPS fornisce millisecondi che hanno un'ottima precisione a lungo termine, non sono molto precisi. Gli aggiornamenti dell'ora GPS sono solo una volta ogni 100 ms e quindi c'è un ulteriore ritardo nella ricezione dei dati seriali a una velocità lenta di 9600 baud e un altro ritardo nell'analisi. Tutto ciò si aggiunge alla precisione del millisecondo quando si esegue il timestamp delle letture dei dati.

Ecco alcune modifiche al codice di esempio da applicare allo schizzo generato da pfodDesigner per l'utilizzo di un modulo GPS, supponendo che tu stia utilizzando la libreria GPS di Adafruit e abbia aggiunto il codice per ricevere e analizzare i messaggi in un oggetto GPS.

// gestisce la richiesta {@} } else if('@'==cmd) { // pfodApp ha richiesto l'ora 'corrente' plot_mSOffset = millis(); // cattura i millisecondi correnti come offset dei dati grezzi dei dati grezzi parser.print(F("{@`0"}); // restituisce `0 come millisecondi dei dati grezzi 'correnti' parser.print('~'); // inizia la stringa di data/ora sendDateTime(&GPS); // invia yyyy/M/d/ H:m:s a parser.print, passa indirizzo & come arg. parser.print('}'); // fine di {@ risposta ad es. {@`0~2019/4/19 3:33:5}….

// invia la data e l'ora al parser printvoid sendDateTime(Adafruit_GPS* gps) { parser.print(F("20"); // 20.. anno parser.print(gps->year, DEC); parser.print('/ '); parser.print(gps->mese, DEC); parser.print('/'); parser.print(gps->giorno, DEC); parser.print(' '); parser.print(gps- >ora, DEC); parser.print(':'); parser.print(gps->minuto, DEC); parser.print(':'); parser.print(gps->secondo, DEC); // parser.print('.'); se invii millisecondi // se vuoi inviare mS devi riempire il valore gps->millisecondi con zeri iniziali // cioè 3 deve essere riempito a 003 }

void sendData() { if (plotDataTimer.isFinished()) { plotDataTimer.repeat(); // riavvia il timer dei dati del grafico, senza deriva // assegna i valori alle variabili del grafico dalle variabili del loop o leggi gli ingressi ADC plot_1_var = analogRead(A0); // leggi l'input per tracciare // plot_2_var plot Nascosto, quindi nessun dato assegnato qui // plot_3_var plot Nascosto, quindi nessun dato assegnato qui // invia i dati del grafico in formato CSV sendDateTime(&GPS); // invia aaaa/M/g/ H:m:s a parser.print, passa l'indirizzo e come arg. parser.print(', '); parser.print(((float)(plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print(', '); // Il diagramma 2 è nascosto. Nessun dato inviato. parser.print(', '); // Il diagramma 3 è nascosto. Nessun dato inviato. parser.println(); // fine del record di dati CSV } }

Quando si traccia la data e l'ora, pfodApp corregge automaticamente i secondi intercalari. A gennaio 2018, l'ora GPS è 18 secondi avanti rispetto all'UTC. pfodApp corregge questo problema confrontando la data/ora restituita dal GPS al momento della connessione, tramite la risposta {@, con la data e l'ora UTC del cellulare. La creazione di grafici in un foglio di calcolo dal file di registro pfodApp è la stessa dei moduli RTC, sopra. L'aggiunta di (ora locale – ora attuale di Office Temp) ai timestamp GPS corregge i secondi intercalari.

i timestamp millis() continuano a funzionare come in Utilizzo dei timestamp millisecondi di Arduino, passaggio 5 sopra.

Passaggio 11: conclusione

L'utilizzo di pfodApp sul tuo cellulare Android ti consente di tracciare i dati rispetto a data e ora o tempo trascorso, utilizzando solo la funzione millis() di Arduino. Utilizzando il file di registro pfodApp è possibile riprodurre questi grafici di data/ora in un foglio di calcolo. Se il tuo progetto Arduino ha un modulo RTC, puoi registrare e tracciare la data e i timestamp RTC, correggendo automaticamente per la "deriva" RTC. Se il tuo progetto Arduino ha un modulo GPS, puoi registrare e tracciare i suoi timestamp altamente precisi e pfodApp correggerà automaticamente i secondi intercalari mancanti del GPS.

In tutti i casi i dati grezzi del tuo progetto Arduino vengono registrati esattamente come ricevuti, non corretti. Tuttavia, il file di registro pfodApp include dati aggiuntivi per consentire di riprodurre queste correzioni in un foglio di calcolo dal file di registro scaricato.

Non è richiesta alcuna codifica Android. I formati di stampa sono tutti specificati da piccole stringhe di testo nel tuo schizzo Arduino. Il pfodDesigner gratuito genera la registrazione completa dei dati Arduino e gli schizzi di plottaggio per un'ampia varietà di schede Arduino che si collegano tramite WiFi, Bluetooth classico, BLE e SMS