Arduino Data / Hora Traçat / Registre mitjançant Millis () i PfodApp: 11 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

No es requereix programació d'Arduino ni d'Android. També s'admeten mòduls RTC i GPS. Correcció automàtica de zones horàries, deriva RTC i falta de segons de traspàs GPS

Introducció

Aquest tutorial us mostra com utilitzar les vostres marques de temps Arduino millis () per representar dades i data i hora al vostre mòbil Android mitjançant pfodApp.

No cal programació Arduino ni Android. pfodApp també registra prou dades perquè pugueu reproduir els gràfics de data / hora en un full de càlcul.

NO cal cap mòdul RTC ni GPS, però si el vostre projecte Arduino té un RTC (Real Time Clock) o un mòdul GPS, també es poden utilitzar. En aquests casos, les parcel·les de pfodApp es corregiran automàticament per la zona horària, la deriva RTC i el GPS que falten segons de traspàs. No cal cap codi Arduino especial per a aquestes correccions. Com sempre amb pfodApp, les dades rebudes es registren exactament tal qual, sense corregir, però el fitxer de registre també conté informació suficient per permetre-vos aplicar aquestes correccions vosaltres mateixos quan baixeu els registres al vostre ordinador. Vegeu a continuació exemples d’aquest post-processament.

S'admet una gran varietat de format de l'eix X de data i hora, que estan completament controlats per cadenes de text breus al vostre esbós Arduino. No cal programar Android.

pfodApp es connectarà mitjançant WiFi, Bluetooth Classic, BLE i SMS. El pfodDesigner gratuït genera esbossos Arduino complets per a la representació de data / hora / registre per connectar-se a una gran varietat de taules. No cal programació Arduino.

Aquesta instrucció utilitzarà un Adafruit Feather52 com a exemple de placa Arduino, que es connecta mitjançant BLE.

Aquesta instrucció cobreix tres casos: - 1) El vostre projecte de microprocessador només té marques de temps de mil·lisegons - millis () 2) El vostre projecte de microprocessador té un rellotge en temps real (RTC) - pfodApp corregeix automàticament la deriva. 3) El vostre projecte de microprocessador té un mòdul GPS: pfodApp corregeix automàticament els segons de traspàs quan es produeixen (actualment 18 segons al 2018).

Pas 1: utilitzar les marques de temps Arduino Millisegons, Millis ()

L’ús de mil·lisegons per a data i hora té dues parts. Una consisteix a traçar les dades en funció de l'hora transcorreguda o de la data / hora i l'altra part torna a crear la data i l'hora a partir de les marques de temps registrades de mil·lisegons de rawdata. pfodApp no modifica les dades brutes rebudes del pfodDevice (el micro Arduino). Simplement registra exactament els bytes rebuts.

Primer, utilitzeu el pfodDesigner gratuït per generar un esbós Arduino per al vostre micro que enviarà els mil·lisegons i les mesures de dades a pfodApp per al traçat / registre. Aquest exemple crea un menú per al tauler BLE d'Adafruit Feather 52 que diu A0. El tutorial sobre Adafruit Feather nRF52 LE - Controls personalitzats amb pfodApp recorre els passos de pfodDesigner per crear un menú per al Feather nRF52 que inclogui un botó de gràfic, així que consulteu-lo per obtenir més detalls. En aquest tutorial afegirem només un botó gràfic i utilitzarem les noves opcions de format de l'eix X per representar les lectures A0 en funció de l'hora i la data / hora transcorregudes.

La primera part d’aquest tutorial s’utilitzarà amb el pfodDesigner gratuït per crear un gràfic de data / hora de mostra al vostre mòbil Android. Quan estigueu satisfet amb la pantalla, podeu generar l'esbós d'Arduino que el reproduirà quan us connecteu amb pfodApp. No es requereix programació d'Android i, ja que pfodDesigner genera esbossos Arduino complets per a una àmplia varietat de plaques Arduino, tampoc no es necessita programació Arduino.

Pas 2: afegir un gràfic al menú

Descarregueu l'aplicació pfodDesigner de Google Play, obriu-la i feu clic a "Inici nou menú"

Feu clic a "Target Serial" i després al botó "Bluetooth Low Energy" per mostrar la llista d'alguns 11 taulers BLE (desplaceu-vos cap avall per veure les altres opcions). Seleccioneu a Adafruit Bluefruit Feather52.

Torneu al menú Edició i feu clic a "Edita la sol·licitud" i configureu una sol·licitud adequada per a aquest menú, per exemple. "Feather52" i text en negreta i mida +7. El color de fons es va deixar com a blanc "predeterminat"

Torneu enrere i feu clic a "Afegeix un element de menú", desplaceu-vos cap avall i seleccioneu "Botó de gràfic" que obre la pantalla d'edició del botó de gràfic. Podeu fer qualsevol canvi en l’aspecte del botó aquí. En aquest cas, el text del botó es va canviar a "Diagrama de data / hora d'A0" i els altres valors predeterminats es van deixar tal qual.

Això us dóna un botó al menú que obrirà la pantalla del gràfic.

Pas 3: Edició de la font i els gràfics de la trama

Feu clic al botó "Diagrama de data / hora d'A0" per obrir la pantalla Edició de gràfics, on podeu accedir a l'etiqueta del gràfic, al format de l'eix X, a l'interval de dades de la gràfica i (desplaçant-vos cap avall) a la configuració de la gràfica. Editeu l'etiqueta del gràfic perquè en convingui, per exemple. "Volts A0".

Desplaceu-vos cap avall i obriu Edita la gràfica per als gràfics 2 i 3 i feu clic a Amaga la gràfica per eliminar-los de la visualització del gràfic.

A continuació, feu clic a "Edita la trama 1" i configureu una etiqueta de trama (per exemple, A0), unitats yAxis (per exemple, volts), mostreu un màxim de 3,6 V i connecteu-vos al pin A0 d'E / S.

Desplaceu-vos cap enrere i feu clic a "Visualització prèvia del gràfic" fins als 0 punts de dades de mostra més recents, a intervals de 1 segon, representats en funció del temps transcorregut en minuts: segons.

Per a tots els plànols de temps transcorreguts, no es mostren les unitats zero, de manera que en aquest gràfic només es mostren els minuts inicials> 1min.

Pas 4: triar el format de data i hora

Per als gràfics de temps transcorregut, la unitat principal continua augmentant a mesura que passa el temps. Per veure un exemple d'això, torneu a la pantalla "Edició de gràfics" i augmenteu l'interval de dades de gràfics a 15 minuts (part inferior d'aquesta pantalla)

A continuació, feu clic a Visualització prèvia del gràfic per mostrar les mateixes dades de mostra, però ara amb intervals de 15 minuts entre les mostres. Com podeu veure, la part de minuts de mm: ss continua augmentant.

Ara torneu enrere i feu clic al botó de l'eix X per mostrar una petita selecció de tots els formats possibles de dades / hora de l'eix X (desplaceu-vos cap avall per obtenir més informació)

A la part superior es mostra una selecció de visualitzacions prèvies de gràfics amb diferents formats de l'eix X.

Les parcel·les de data / hora que es mostren aquí es troben a la zona horària 'local'. També hi ha opcions de format per representar la data / hora a UTC. Per obtenir un conjunt complet de possibles opcions de format de data / hora, consulteu pfodSpecification.pfd.

Pas 5: Genereu i proveu l'Arduino Sketch

Quan estigueu satisfet amb el format i l'interval de dades del gràfic, podeu accedir a la pantalla "Edició del menú_1" i desplaçar-vos cap avall i "Generar codi" per al tauler objectiu que hàgiu triat. Aquí teniu un esbós de mostra per a Adafruit Feather52 amb intervals de dades de 1 segon i un format de temps transcorregut mm: ss, pfodFeather52_timeplot.ino

A la part superior hi ha una trama d’A0 del Feather52

Si canvieu el format a Weekday hr: mins: sec (~ E HH: mm: ss) i torneu a generar el codi (pfodFeather52_dateplot.ino) es dóna un diagrama com el segon anterior.

Podeu editar el format de l’eix X directament a l’esbós d’Arduino, tal com es descriu a continuació.

Pas 6: Com fa PfodApp la trama de la data / hora de Millis ()?

Quan pfodApp es connecta, recorda la seva hora 'local' i UTC i sol·licita les marques de temps actuals de les dades de la trama del pfodDevice (la placa Arduino). Mitjançant aquesta informació, pfodApp pot representar les marques de temps de mil·lisegons com a temps transcorregut, és a dir, convertir mil·lisegons a hores mins, etc., o representar la data i l'hora que representen les marques de temps de mil·lisegons en relació amb quan es va fer la connexió i es va sol·licitar l'hora actual del dispositiu pfodDevice.

Si es busca l'esbós generat per Arduino (per exemple, pfodFeather52_dateplot.ino), hi ha tres petits bits de codi que gestionen el costat Arduino de les trames.

La secció de codi loop () que gestiona la {@} sol·licitud d'hora actual de pfodApp

// gestiona {@} request} else if ('@' == cmd) {// pfodApp ha sol·licitat el temps 'actual' plot_mSOffset = millis (); // captura els millis actuals com a marca de temps offset de rawdata parser.print (F ("{@` 0} ")); // retorna "0 com a dades brutes" actuals "en mil·lisegons

Només podríeu retornar el valor actual de millis (), però millis () torna a 0 cada 49,7 dies, cosa que faria saltar la trama cap enrere. Per tant, el codi recorda el valor actual de mil·lis () quan es va fer la sol·licitud {@} i retorna {@ `0}, és a dir, una marca de temps actual de mil·lisegons de zero. Aleshores, quan s'envien els punts de dades brutes, s'utilitza l'esbós

plot_1_var = analogRead (A0); // llegir l'entrada al diagrama // plot_2_var plot Oculta de manera que no hi ha dades assignades // plot_3_var plot Oculta perquè no hi hagi dades assignades // enviar dades del diagrama en format CSV parser.print (millis () - plot_mSOffset); // temps en mil·lisegons ….

de manera que la marca de temps de mil·lisegons enviada amb les dades comença a 0 i augmenta fins a 49,7 dies. Si us manteniu connectat contínuament durant 49,7 dies, veureu que la trama salta cap enrere uns 50 dies. Desconnectar i tornar a connectar un cop cada 49,7 dies ho evita.

La tercera part de la trama de data / hora és el missatge de la trama.

} else if ('A' == cmd) {// premut per l'usuari - 'Diagrama de data / hora d'A0' // al menú principal de Menú_1 // retorna la representació del missatge. parser.print (F ("{= A0 volts ~ E HH: mm: ss | data | A0 ~~~ volts ||}"));

Quan l'usuari prem el botó "Diagrama de data / hora d'A0", pfodApp envia el cmd {A} al dispositiu pfodDevice i el dispositiu pfodDevice respon amb el missatge de gràfic, {= … {= A0 Volts ~ E HH: mm: ss | data | A0 ~~~ Volts ||} que conté el format de l'eix X E HH: mm: ss

Els formats Java SimpleDateFormat són acceptables aquí. pfodApp Data Logging and Plotting i pfodSpecification.pdf tenen més detalls sobre el missatge de la trama.

Pas 7: Reproducció de les parcel·les de data i hora a l'ordinador

Per defecte, pfodApp registra totes les dades brutes entrants en un fitxer de registre al mòbil, tret que hàgiu desactivat aquest registre a la pantalla d'edició de la connexió, consulteu la pàgina pfodAppForAndroidGettingStarted.pdf

Quan editeu pfodApp, apareixerà un missatge breu amb la ubicació i el nom del fitxer de registre, per exemple. /pfodAppRawData/pfod_bluefruit52.txt Aquest fitxer té un format CSV, està delimitat per comes i, després de transferir-lo al vostre ordinador (consulteu pfodAppForAndroidGettingStarted.pdf per obtenir opcions de transferència), podeu obrir-lo en un full de càlcul per representar les dades.

Aquí hi ha les primeres línies d'un fitxer de registre.

// pfodApp V3.0.360, hora local, UTC, mS per dia, pfod bluefruit52 hora actual (mS), pfod bluefruit52 hora actual, // connectat 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,, A sobre podeu veure l'hora "local" i UTC que pfodApp es va connectar a Feather52 i l'hora actual en mS que Feather52 va informar mitjançant la resposta {@..}. L'última columna està en blanc, perquè no hi ha RTC ni GPS i, per tant, Feather52 no va informar de cap hora actual en aaaa / MM / dd.

Per representar les dades en funció del temps transcorregut, resteu el temps actual (mS) del segell de temps mil·lisegon i, a continuació, dividiu-lo pel valor mS per dia. Aquí teniu el full de càlcul amb la fórmula afegida i el resultat representat. A continuació, el full de càlcul (pfod_bluefruit52.xls) és un full de càlcul OpenOffice desat en format Excel.

A OpenOffice, la trama és una gràfica de dispersió i l'eix x de la trama s'ha formatat en HH: MM: SS Nota: els formats de data / hora del full de càlcul NO són els mateixos que els formats de trama que utilitza pfodApp. Per exemple, a pfodApp, MM és de mesos i mm és de minuts.

Per representar la data i l’hora, només heu d’afegir l’hora de connexió a l’hora del full de càlcul i replantejar-la. (pfod_bluefruit52_date.xls)

Nota: l’hora local i l’UTC s’han importat com a text al full de càlcul, de manera que he d’eliminar el missatge principal abans d’utilitzar-los en una fórmula.

Pas 8: Com evitar el límit de 49,7 dies Millis () i per què no ho hauríeu de fer

Com es va esmentar anteriorment a Com pfodApp dibuixa la data / hora des de mil·lis () ?, si roman connectat contínuament durant més de 49,7 dies, les marques de temps de mil·lisegons es tornaran a zero. Unes poques línies de codi poden evitar-ho, però no es recomana.

Primer com evitar l’embolcall. Afegiu una altra variable int sense signar per fer un seguiment del nombre de vegades que les marques de temps s’ajusten i imprimiu el resultat combinat a HEX.

uint_t mSwrapCount = 0; uint32_t lastTimeStamp = 0;

… plot_1_var = analogRead (A0); // llegir l'entrada a la trama // plot_2_var plot Oculta de manera que no hi ha dades assignades // plot_3_var trama Oculta, així que no hi ha dades assignades aquí // envia dades de trama en format CSV uint32_t timeStamp = millis () - plot_mSOffset; if (timeStamp <lastTimeStamp) {// timeStamp tornat a 0 mSwrapCount ++; // n’afegeix un per comptar} lastTimeStamp = timeStamp; parser.print ("0x"); parser.print (msWrapCount, HEX); parser.print (timeStamp, HEX); // temps en mil·lisegons a HEX …

En retornar la resposta {@.. també esborreu el mSwrapCount.

// gestiona {@} request} else if ('@' == cmd) {// pfodApp ha sol·licitat el temps 'actual' plot_mSOffset = millis (); // captura millis actuals com a marca de temps de dades brutes compensades mSwrapCount = 0; // esborra el recompte d’embolcall. parser.print (F ("{@` 0} ")); // retorna "0 com a mil·lisegons de dades brutes" actuals"

Ara les marques de temps donaran el valor "correcte" per als propers 40,7 dies * 65536 ~ = 7308 anys.

pfodApp convertirà automàticament les marques de temps hexadecimals per representar-les i les registrarà exactament tal com es va rebre, és a dir, en hexadecimal. Al full de càlcul (OpenOffice) utilitzeu aquesta fórmula per convertir la cadena hexadecimal, en A2, a mS (on A1 és qualsevol cel·la buida) = HEX2DEC (REPLACE (A2; 1; 2; A1))

Per què no voleu fer això?

Com es mostra més amunt, és fàcil ampliar les marques de temps mS a més de 50 dies. Tanmateix, probablement no vulgueu fer-ho perquè són cada cop més inexactes. Un cristall típic de 16 MHz utilitzat per crear els millis () dóna com a resultat que el micro tingui una precisió de ~ 50 ppm (parts per milió). Això vol dir que al cap de 49,7 dies la marca de temps de mil·lisegons pot estar fora de 3 ½ minuts i això ignora l'efecte de la temperatura sobre la precisió del cristall.

Durant períodes de connexió curts, aquesta precisió no és un problema, ja que la resposta {@.. torna a sincronitzar la marca de temps de mil·lisegons amb la data / hora del mòbil en cada reconnexió. Tanmateix, si voleu mantenir-vos connectats durant llargs períodes de temps (dies) i registrar contínuament les dades, hauríeu d’utilitzar alguna cosa més precisa que els millis incorporats (), com ara un mòdul RTC o GPS.

Pas 9: utilitzar un RTC (rellotge en temps real)

Hi ha diversos mòduls RTC disponibles, un dels més precisos és DS3231, per exemple. Mòdul DS3231 d’Adafruit. La precisió indicada és de +/- 2 ppm per sobre de 0 a 40 ° C. és a dir, ~ +/- 5 segons / mes.

Si voleu representar dades que tinguin marques de data / hora, p. Ex. 2019-04-19 a les 20: 04: 34, haureu de modificar la resposta {@ per tornar la data / hora actual, p. Ex. {@ `0 ~ 2019/19/19 3:33: 5}. A continuació, es mostren alguns canvis de codi de mostra que s’han d’aplicar a l’esbós generat per pfodDesigner per utilitzar un mòdul RTC, suposant que utilitzeu la biblioteca RTClib i que heu afegit el codi inicialitzant el mòdul RTC.

// gestiona {@} request} else if ('@' == cmd) {// pfodApp ha sol·licitat el temps 'actual' plot_mSOffset = millis (); // captura els mil·lis actuals com a offset de marques de temps rawdata parser.print (F ("{@` 0 "}); // retorna` 0 com a dades brutes 'actuals' en mil·lisegons de parser.print ('~'); // inicia la cadena de data / hora DateTime now = rtc.now () sendDateTime (& now); // enviar aaaa / M / d / H: m: s a parser.print, adreça de pas & com a arg. parser.print ('}'); // final de la {@ resposta, per exemple, {@ `0 ~ 2019/4/19 3: 33: 5} …

// envia la data a l'analitzador printvoid sendDateTime (DateTime * dt) {parser.print (dt-> year (), DEC); parser.print ('/'); parser.print (dt-> month (), 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 (); // reinicieu el temporitzador de dades de traçat, sense derivar // assigneu valors a les variables de traçat de les vostres variables de bucle o llegiu les entrades ADC plot_1_var = analogRead (A0); // llegir l'entrada a la trama // plot_2_var plot Oculta de manera que no hi ha dades assignades // plot_3_var trama Oculta de manera que no hi ha dades assignades // envieu dades de trama en format CSV DataTime ara = rtc.now (); sendDateTime (& ara); // envia aaaa / M / d / H: m: s a parser.print, passa l'adreça i com a arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // La trama 2 està oculta. No s'han enviat dades. parser.print (','); // La trama 3 està oculta. No s'ha enviat cap dada. analitzador.println (); // final del registre de dades CSV}}

La part del ~ 2019/4/03: 33: 5 de la resposta {@ permet a pfodApp saber quina opció pensa el pfodDevice com la data i l'hora actuals. El vostre esbós pot enviar dades amb les marques de temps de yMd Hms i pfodApp les representarà com a temps transcorregut des de l’hora de connexió O com a data i hora, segons el format de l’eix X que especifiqueu.

Quan es traça la data i l’hora, la rutina de traçat de pfodApp corregeix qualsevol “deriva” del RTC comparant l’hora actual del pfodDevice amb l’hora actual del mòbil. Aquesta correcció també gestiona la configuració del RTC en una zona horària diferent de la zona horària local del mòbil. Les marques de temps millis () segueixen funcionant com a l'ús de marques de temps de mil·lisegons d'Arduino, pas 5 anterior.

Aquí teniu un exemple de full de càlcul de temperatures ambientals durant un període de vuit dies, Office_Temp.xls Quan es va importar el fitxer de registre, la primera columna es va marcar com a YMD per convertir el text a una data / hora. Encara haureu d’eliminar les entrades d’hora actual, hora local i UTC de l’origen local del formulari principal perquè el full de càlcul les interpreti com a dates i hores.

Per obtenir el mateix gràfic que mostra pfodApp, heu de calcular la "Data / hora corregida". En aquest cas, l'hora RTC és 2 segons per darrere de l'hora local del mòbil, de manera que a cada marca de temps RTC s'afegeix (hora local - hora actual Office Office) per obtenir l'hora local real.

Per als gràfics de temps transcorreguts, creeu una nova columna que contingui la (marca de temps de data / hora: l'hora actual de l'Oficina) i utilitzeu-la com a eix X del gràfic (Office_TempElapsed.xls). En aquest cas, pfodApp produeix gràfics de temps transcorreguts més agradables. en dies h: min: seg.

Pas 10: utilitzar un mòdul GPS

L’ús d’un mòdul GPS és similar a l’ús d’un mòdul RTC, excepte que els mòduls GPS tenen mil·lisegons disponibles, els anys comencen al 2000 i falten els segons de traspàs UTC (vegeu https://tycho.usno.navy.mil/leapsec.html) La data i l’hora del GPS s’avancen actualment 18 segons respecte a l’UTC, al gener de 2018.

La biblioteca GPS Adafruit per al GPS Adafruit Ultimate, a diferència del RTClib, no afegeix la compensació de 2.000 anys als anys GPS, de manera que cal afegir-la quan envieu la data i l’hora. També, tot i que la biblioteca GPS proporciona mil·lisegons que tenen una precisió a llarg termini molt bona, no són molt precisos. Les actualitzacions de temps del GPS només es fan una vegada cada 100 mS i hi ha un retard addicional en rebre les dades de sèrie a 9600 baud lents i un altre retard en analitzar-les. Tot això s’afegeix a la precisió del mil·lisegon en marcar les dades de marca de temps.

A continuació, es mostren alguns canvis de codi de mostra que s’han d’aplicar a l’esbós generat per pfodDesigner per utilitzar un mòdul GPS, suposant que utilitzeu la biblioteca GPS d’Adafruit i que heu afegit el codi per rebre i analitzar els missatges en un objecte GPS.

// gestiona {@} request} else if ('@' == cmd) {// pfodApp ha sol·licitat el temps 'actual' plot_mSOffset = millis (); // captura els mil·lis actuals com a offset de marques de temps rawdata parser.print (F ("{@` 0 "}); // retorna` 0 com a dades brutes 'actuals' en mil·lisegons de parser.print ('~'); // inicia la cadena de data / hora sendDateTime (& GPS); // envia aaaa / M / d / H: m: s a parser.print, passa l'adreça i com a arg. parser.print ('}'); // final de la resposta de @ {@ `0 ~ 2019/19/04 03: 33: 5} ….

// envia la data a l’analitzador printvoid sendDateTime (Adafruit_GPS * gps) {parser.print (F ("20"); // 20.. any parser.print (gps-> any, DEC); parser.print ('/ '); parser.print (gps-> mes, DEC); parser.print (' / '); parser.print (gps-> day, DEC); parser.print (' '); parser.print (gps- > hora, DEC); parser.print (':'); parser.print (gps-> minut, DEC); parser.print (':'); parser.print (gps-> segon, DEC); // parser.print ('.'); si envieu mil·lisegons // si voleu enviar mS, heu de tapar el valor gps-> mil·lisegons amb zeros inicials // és a dir, cal omplir 3 fins a 003}

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // reinicieu el temporitzador de dades de traçat, sense derivar // assigneu valors a les variables de traçat de les vostres variables de bucle o llegiu les entrades ADC plot_1_var = analogRead (A0); // llegir l'entrada a la trama // trama_2_var gràfica oculta, de manera que no hi ha dades assignades // trama_3_var trama oculta, de manera que no hi ha dades assignades // envia dades de trama en format CSV sendDateTime (& GPS); // envia aaaa / M / d / H: m: s a parser.print, passa l'adreça i com a arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // La trama 2 està oculta. No s'ha enviat cap dada. parser.print (','); // La trama 3 està oculta. No s'ha enviat cap dada. analitzador.println (); // final del registre de dades CSV}}

Quan es trama amb data i hora, la pfodApp es corregeix automàticament per segons de traspàs. Al gener de 2018, el temps del GPS s’avança 18 segons respecte a l’UTC. pfodApp corregeix això comparant la data / hora retornada pel GPS en la connexió, mitjançant la resposta {@, amb la data i hora UTC del mòbil. Crear gràfics en un full de càlcul a partir del fitxer de registre de pfodApp és el mateix que per als mòduls RTC, anterior. Si afegiu la (hora local - hora actual d’Office Temp) a les marques de temps del GPS, es corregeixen els segons de traspàs.

Les marques de temps millis () segueixen funcionant com a l'ús de marques de temps de mil·lisegons d'Arduino, pas 5 anterior.

Pas 11: Conclusió

L’ús de pfodApp al mòbil Android us permet representar les dades en funció de la data i l’hora o el temps transcorregut, utilitzant només la funció millis () d’Arduino. Mitjançant el fitxer de registre de pfodApp podeu tornar a produir aquests gràfics de data / hora en un full de càlcul. Si el vostre projecte Arduino té un mòdul RTC, podeu registrar i traçar la data i les marques de temps de RTC, corregint automàticament la "deriva" de l'RTC. Si el vostre projecte Arduino té un mòdul GPS, podeu registrar i traçar les seves marques de temps molt precises i pfodApp corregirà automàticament els segons de salt que falten del GPS.

En tots els casos, les dades brutes del vostre projecte Arduino es registren exactament tal com es van rebre, sense corregir. Tanmateix, el fitxer de registre de pfodApp inclou dades addicionals que us permeten tornar a produir aquestes correccions en un full de càlcul a partir del fitxer de registre descarregat.

No cal cap codificació d'Android. Els formats de la trama s’especifiquen amb petites cadenes de text al vostre esbós d’Arduino. El pfodDesigner gratuït genera esbossos de registre i traçat complet de dades Arduino per a una gran varietat de plaques Arduino que es connecten mitjançant WiFi, Bluetooth clàssic, BLE i SMS