Arduino Data / Ora Plotting / Logging folosind Millis () și PfodApp: 11 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

Nu este necesară programarea Arduino sau Android. Modulele RTC și GPS sunt de asemenea acceptate. Corecția automată pentru fusurile orare, deriva RTC și GPS lipsește câteva secunde

Introducere

Acest tutorial vă arată cum să utilizați marcajele de timp Arduino millis () pentru a trasa date în funcție de dată și oră pe mobilul dvs. Android utilizând pfodApp.

Nu este necesară programarea Arduino sau Android. De asemenea, pfodApp înregistrează suficiente date, astfel încât să puteți reproduce ulterior graficele de dată / oră într-o foaie de calcul.

Niciun modul RTC sau GPS nu este necesar, totuși, dacă proiectul dvs. Arduino are un RTC (Ceas în timp real) sau un modul GPS, acestea pot fi, de asemenea, utilizate. În aceste cazuri, graficele pfodApp se vor corecta automat pentru fusul orar, deriva RTC și GPS lipsește de câteva secunde. Nu este necesar un cod Arduino special pentru aceste corecții. Ca întotdeauna cu pfodApp, datele primite sunt înregistrate exact așa cum sunt, necorectate, totuși fișierul jurnal conține, de asemenea, suficiente informații pentru a vă permite să aplicați aceste corecții dumneavoastră atunci când descărcați jurnalele pe computer. Vedeți mai jos exemple pentru această post-procesare.

Este acceptată o mare varietate de formatare pe axa X a orei și datei, toate fiind complet controlate de șiruri scurte de text în schița dvs. Arduino. Nu este necesară programarea Android.

pfodApp se va conecta prin WiFi, Bluetooth Classic, BLE și SMS. PfodDesigner gratuit generează schițe Arduino complete pentru graficarea / înregistrarea datei / orei pentru a vă conecta la o mare varietate de plăci. Nu este necesară programarea Arduino.

Acest instructable va utiliza un Adafruit Feather52 ca exemplu de placa Arduino, care se conectează prin BLE.

Această instrucțiune acoperă trei cazuri: - 1) Proiectul dvs. de microprocesor are numai marcaje de timp de milisecundă - milis () 2) Proiectul de microprocesor are un ceas în timp real (RTC) - pfodApp corectează automat pentru deriva. 3) Proiectul dvs. de microprocesor are un modul GPS - pfodApp corectează automat pentru câteva secunde în timp ce apar (în prezent, 18 secunde începând cu 2018).

Pasul 1: Utilizarea marcajelor temporale Arduino Millisecond, Millis ()

Există două părți în utilizarea milisecundelor pentru dată și oră. Unul este pentru trasarea datelor în funcție de timpul scurs sau de data / ora, iar cealaltă parte re-creează data și ora din ștampilele de timp înregistrate în milisecundă rawdata. pfodApp nu modifică datele brute primite de la pfodDevice (Arduino micro). Doar înregistrează exact octeții primiți.

Mai întâi utilizați pfodDesigner gratuit pentru a genera o schiță Arduino pentru micro care va trimite milisecundele și măsurătorile de date către pfodApp pentru reprezentare / înregistrare. Acest exemplu creează un meniu pentru placa Adafruit Feather 52 BLE care citește A0. Tutorialul despre Adafruit Feather nRF52 LE - Comenzi personalizate cu pfodApp parcurge pașii pfodDesigner pentru a crea un meniu pentru Feather nRF52 care include un buton Chart, deci verificați-l pentru mai multe detalii. În acest tutorial vom adăuga doar un buton grafic și vom folosi noile opțiuni de formatare axa X pentru a reprezenta citirile A0 în funcție de timpul scurs și data / ora.

Prima parte a acestui tutorial va trece prin utilizarea pfodDesigner gratuit pentru a crea un eșantion de diagramă dată / oră pe mobilul dvs. Android. Când sunteți mulțumit de afișaj, puteți genera schița Arduino care va reproduce acest lucru atunci când vă conectați cu pfodApp. Nu este necesară programarea Android și deoarece pfodDesigner generează schițe complete Arduino pentru o mare varietate de plăci Arduino, nu este necesară nici o programare Arduino.

Pasul 2: Adăugarea unui grafic la meniu

Descărcați aplicația pfodDesigner din Google Play, deschideți-o și faceți clic pe „Start new menu”

Faceți clic pe „Target Serial” și apoi pe butonul „Bluetooth Low Energy” pentru a afișa lista celor 11 plăci BLE (derulați în jos pentru a vedea celelalte opțiuni). Selectați pe Adafruit Bluefruit Feather52.

Reveniți la meniul de editare și faceți clic pe „Editați promptul” și setați un prompt adecvat pentru acest meniu, de ex. „Feather52” și text aldin și mărime +7. Culoarea de fundal a fost lăsată ca alb „implicit”

Întoarceți-vă și faceți clic pe „Adăugare element de meniu”, derulați în jos și selectați „Butonul diagramei” care deschide ecranul de editare a butonului diagramei. Aici puteți face orice modificare a aspectului butonului. În acest caz, textul butonului a fost schimbat în „Diagrama Data / Ora lui A0”, iar celelalte valori implicite au fost lăsate ca atare.

Acest lucru vă oferă un buton din meniu care va deschide ecranul graficului.

Pasul 3: Editarea sursei graficului și a tablourilor

Faceți clic pe butonul „Data / Ora graficului lui A0” pentru a deschide ecranul Editare parcele, unde puteți accesa eticheta graficului, formatul axei X, intervalul de date al graficului și (derulând în jos) setările graficului în sine. Editați eticheta graficului cu ceva adecvat, de ex. „Volți A0”.

Derulați în jos și pentru Parcele 2 și 3 deschideți Editare parcela și faceți clic pe Ascundere parcela pentru a le elimina de pe afișajul graficului.

Apoi faceți clic pe „Editați parcela 1” și setați o etichetă de parcela (de ex. A0), unități yAxis (de ex. Volți), afișați maxim 3,6 V și conectați-vă la pinul I / O A0.

Derulați înapoi și faceți clic pe „Previzualizare diagramă” până la cele mai recente 0 eșantioane de date, la intervale de 1sec, reprezentate în funcție de timpul scurs în minute: secunde.

Pentru toate graficele de timp scurs, unitățile zero care conduc nu sunt afișate, așa că în acest grafic sunt afișate doar acele timp> 1min.

Pasul 4: Alegerea formatului de dată / oră

Pentru graficele de timp scurs, unitatea principală continuă să crească pe măsură ce trece timpul. Pentru a vedea un exemplu, reveniți la ecranul „Editare parcele” și măriți intervalul de date de parcela la 15 minute (partea de jos a acestui ecran)

Apoi faceți clic pe Previzualizare diagramă pentru a afișa aceleași eșantioane de date, dar acum cu intervale de 15 minute între eșantioane. După cum puteți vedea, minutele din mm: ss continuă să crească.

Acum reveniți și faceți clic pe butonul axei X pentru a afișa o mică selecție a tuturor formatelor posibile de date / oră ale axei X (derulați în jos pentru mai multe)

Mai sus este o selecție de previzualizări ale graficelor folosind diferite formate ale axei X.

Graficele de dată / oră afișate aici sunt în fusul orar „local”. Există, de asemenea, opțiuni de format pentru a trasa data / ora în UTC. Pentru un set complet de posibile opțiuni de formatare dată / oră, consultați pfodSpecification.pfd.

Pasul 5: Generați și testați schița Arduino

Odată ce sunteți mulțumit de formatul graficului și de intervalul de date, puteți accesa ecranul „Editare meniu_1” și derulați în jos și „Generați cod” pentru placa țintă aleasă. Iată o schiță eșantion pentru Adafruit Feather52 folosind intervale de date de 1sec și un format de timp scurs mm: ss, pfodFeather52_timeplot.ino

Deasupra este un complot de A0 din Feather52

Schimbarea formatului la Weekday hr: mins: sec (~ E HH: mm: ss) și re-generarea codului (pfodFeather52_dateplot.ino) oferă un grafic ca al doilea de mai sus.

Puteți edita formatul axei X direct în schița Arduino, așa cum este descris în continuare.

Pasul 6: Cum calculează PfodApp Data / Ora de la Millis ()?

Când pfodApp se conectează, își amintește ora „locală” și UTC și solicită marcajele de timp curente ale graficului pfodDevice (placa Arduino). Folosind aceste informații, pfodApp poate apoi să traseze semnele de timp de milisecundă, fie ca timp scurs, adică să convertească milisecunde în ore min sec, etc., fie să traseze data și ora reprezentate de semnele de timp de milisecundă în raport cu momentul în care s-a făcut conexiunea și s-a solicitat ora curentă a dispozitivului pfodDevice.

Privind în schița generată de Arduino (de exemplu, pfodFeather52_dateplot.ino), există trei biți mici de cod care gestionează partea Arduino a graficelor.

Secțiunea de cod loop () care gestionează {@} cererea de timp curentă a pfodApp

// gestionați {@} request} else if ('@' == cmd) {// pfodApp a solicitat timpul 'curent' plot_mSOffset = millis (); // captează milisii curenți ca mărci de timp offset rawdata parser.print (F ("{@` 0} ")); // returnează „0 ca date brute„ curente”în milisecunde

Puteți returna valoarea curentă a milis (), dar milis () se întoarce la 0 la fiecare 49,7 zile, ceea ce ar face ca parcela să sară înapoi. Deci, în schimb, codul își amintește valoarea milis () curentă atunci când a fost făcută solicitarea {@} și returnează {@ `0}, adică un timestamp curent de milisecundă de zero. Apoi, când trimiteți punctele rawdata, schița le folosește

plot_1_var = analogRead (A0); // citire intrare în complot // complot_2_var complot Ascuns deci nu sunt atribuite date aici // complot_3_var complot Ascunse deci nu sunt atribuite date aici // trimite date în format CSV parser.print (milis () - plot_mSOffset); // timp în milisecunde ….

astfel încât marca de timp milisecundă trimisă împreună cu datele începe de la 0 și crește până la 49,7 zile. Dacă rămâneți conectat continuu timp de 49,7 zile, atunci veți vedea complotul sări înapoi cu ~ 50 zile. Deconectarea și reconectarea o dată la fiecare 49,7 zile evită acest lucru.

A treia parte a complotului de dată / oră este mesajul de complot.

} else if ('A' == cmd) {// apăsat de utilizator - 'Diagrama datei / orei A0' // în Meniul principal al Meniului_1 // returnează mesajul de reprezentare. parser.print (F ("{= A0 Volți ~ E HH: mm: ss | dată | A0 ~~~ Volți ||}"));

Când utilizatorul apasă butonul „Data / Ora graficului lui A0”, pfodApp trimite cmd-ul {A} către pfodDevice, iar pfodDevice răspunde cu mesajul graficului, {=… {= A0 Volts ~ E HH: mm: ss | date | A0 ~~~ Volți ||} care conține formatul axei X E HH: mm: ss

Formatele Java SimpleDateFormat sunt acceptabile aici. pfodApp Data Logging and Plotting și pfodSpecification.pdf au mai multe detalii despre mesajul graficului.

Pasul 7: Reproducerea graficelor de dată / oră pe computerul dvs

În mod implicit, pfodApp înregistrează toate datele brute primite într-un fișier jurnal de pe telefonul dvs. mobil, cu excepția cazului în care ați dezactivat această înregistrare în ecranul de editare a conexiunii, consultați pfodAppForAndroidGettingStarted.pdf

Când editați pfodApp, se afișează un mesaj scurt cu locația și numele fișierului jurnal, de ex. /pfodAppRawData/pfod_bluefruit52.txt Acest fișier este în format CSV, delimitat de virgule și după ce l-ați transferat pe computerul dvs. (consultați pfodAppForAndroidGettingStarted.pdf pentru opțiuni de transfer), îl puteți deschide într-o foaie de calcul pentru a grafica datele.

Iată câteva linii ale unui fișier jurnal.

// pfodApp V3.0.360, ora locală, UTC, mS pe zi, pfod bluefruit52 ora curentă (mS), pfod bluefruit52 ora curentă, // conectat la, 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,, Mai sus puteți vedea ora „locală” și UTC pe care pfodApp le-a conectat la Feather52 și ora curentă în mS pe care Feather52 a raportat-o prin răspunsul {@..}. Ultima coloană este goală, deoarece nu există RTC sau GPS și, prin urmare, Feather52 nu a raportat niciun moment curent în aaaa / LL / zg.

Pentru a calcula datele în funcție de timpul scurs, scădeți timpul curent (mS) din marca de timp milisecundă și apoi împărțiți cu valoarea mS pe zi. Iată foaia de calcul cu formula adăugată și rezultatul trasat. Foaia de calcul, de mai jos, (pfod_bluefruit52.xls) este o foaie de calcul OpenOffice salvată în format Excel.

În OpenOffice, graficul este un grafic scatter și axa x a graficului a fost formatată în HH: MM: SS Notă: formatele datei / orei foii de calcul NU sunt aceleași cu formatele de grafic utilizate de pfodApp. De exemplu, în pfodApp, MM este de luni și mm este de minute.

Pentru a face complot în funcție de dată și oră, trebuie doar să adăugați ora conexiunii la ora foii de calcul și să replotați. (pfod_bluefruit52_date.xls)

Notă: Ora locală și UTC au fost importate ca text în foaia mea de calcul, așa că a trebuit să șterg versiunea „înainte” înainte de a le utiliza într-o formulă.

Pasul 8: Cum să evitați limita de 49,7 zile Millis () și de ce nu ar trebui

Așa cum s-a menționat mai sus în Cum pfodApp trasează Data / Ora de la milis () ?, dacă rămâneți conectat continuu mai mult de 49,7 zile, marcajele de timp de milisecundă se vor încheia înapoi la zero. Câteva linii de cod pot evita acest lucru, dar nu este recomandat.

Mai întâi cum să evitați înfășurarea. Adăugați o altă variabilă int nesemnată pentru a ține evidența de câte ori se înfășoară marcajele de timp și tipăriți rezultatul combinat în HEX.

uint_t mSwrapCount = 0; uint32_t lastTimeStamp = 0;

… Plot_1_var = analogRead (A0); // citire intrare în complot // complot_2_var complot Ascuns deci nu sunt atribuite date aici // complot_3_var complot Ascunse deci nu sunt atribuite date aici // trimite date în format CSV uint32_t timeStamp = millis () - plot_mSOffset; if (timeStamp <lastTimeStamp) {// timeStamp înfășurat înapoi la 0 mSwrapCount ++; // adaugă unul pentru a număra} lastTimeStamp = timeStamp; parser.print ("0x"); parser.print (msWrapCount, HEX); parser.print (timeStamp, HEX); // timp în milisecunde în HEX….

La returnarea răspunsului {@.. ștergeți și mSwrapCount.

// gestionați {@} request} else if ('@' == cmd) {// pfodApp a solicitat timpul 'curent' plot_mSOffset = millis (); // captează milisul curent ca offset de date brute mSwrapCount = 0; // ștergeți numărul de împachetări. parser.print (F ("{@` 0} ")); // returnează „0 ca date brute„ curente”în milisecunde

Marcajele de timp vor da acum valoarea „corectă” pentru următoarele 40,7 zile * 65536 ~ = 7308 ani.

pfodApp va converti automat marcajele de timp hexagonale pentru graficare și le va înregistra exact așa cum a fost primit, adică în hex. În foaia de calcul (OpenOffice) utilizați această formulă pentru a converti șirul hexagonal, în A2, în mS (unde A1 este orice celulă goală) = HEX2DEC (REPLACE (A2; 1; 2; A1))

De ce nu vrei să faci asta

Așa cum se arată mai sus, este ușor să extindeți marcajele temporale mS la mai mult de 50 de zile. Cu toate acestea, probabil că nu doriți să faceți acest lucru, deoarece acestea devin din ce în ce mai inexacte. Un cristal tipic de 16Mhz folosit pentru a crea milis () are ca rezultat micro are o precizie de ~ 50ppm (părți pe milion). Aceasta înseamnă că, după 49,7 zile, marca de timp milisecundă poate fi eliminată cu 3 ½ minute și asta ignoră efectul temperaturii asupra preciziei cristalului.

Pe perioade scurte de conectare, această precizie nu este o problemă, deoarece răspunsul {@.. sincronizează din nou marca de timp milisecundă cu data / ora telefonului mobil la fiecare reconectare. Cu toate acestea, dacă doriți să rămâneți conectat pentru perioade lungi de timp (zile) și să înregistrați continuu datele, atunci ar trebui să utilizați ceva mai precis decât milis-ul încorporat (), cum ar fi un modul RTC sau GPS.

Pasul 9: Utilizarea unui RTC (ceas în timp real)

Există un număr de module RTC disponibile, unul dintre cele mai exacte este DS3231 de ex. Modulul DS3231 Adafruit. Precizia indicată este de +/- 2ppm peste 0 până la 40C. adică ~ +/- 5 sec / lună.

Dacă doriți să trasați date care au date și ora, de ex. 2019/04/19 20: 4: 34, atunci trebuie să modificați răspunsul {@ pentru a returna data / ora curentă, de ex. {@ `0 ~ 2019/4/19 3: 33: 5}. Iată câteva exemple de modificări ale codului de aplicat schiței generate de pfodDesigner pentru utilizarea unui modul RTC, presupunând că utilizați biblioteca RTClib și ați adăugat codul inițializează modulul RTC.

// gestionați {@} request} else if ('@' == cmd) {// pfodApp a solicitat timpul 'curent' plot_mSOffset = millis (); // captează milisul curent ca offset de date brute parser.print (F ("{@` 0 "}); // returnează` 0 ca date brute 'curente' milisecunde parser.print ('~'); // începe șirul de data / ora DateTime acum = rtc.now () sendDateTime (& now); // trimite aaaa / M / d / H: m: s la parser.print, adresa de trecere & ca arg. parser.print ('}'); // sfârșitul {@ răspunsului de ex. {@ `0 ~ 2019/4/19 3: 33: 5}….

// trimite data oră la parser 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 (); // reporniți temporizatorul de date de plotare, fără drift // atribuiți valori pentru a variabilele de plotare din variabilele de buclă sau citiți intrările ADC plot_1_var = analogRead (A0); // citire intrare în complot // complot_2_var complot Ascuns deci nu există date atribuite aici // complot_3_var complot Ascuns deci nu există date atribuite aici // trimiteți date în complot în format CSV DateTime acum = rtc.now (); sendDateTime (& acum); // trimite aaaa / M / z / H: m: s la parser.print, treci adresa & ca arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // Parcela 2 este ascunsă. Nu au fost trimise date. parser.print (','); // Parcela 3 este ascunsă. Nu au fost trimise date. parser.println (); // sfârșitul înregistrării de date CSV}}

Partea ~ 2019/4/19 3: 33: 5 a răspunsului {@ permite pfodApp să știe ce crede pfodDevice este data și ora curente. Schița dvs. poate trimite apoi date cu marcaje de timp yMd Hms și pfodApp le va reprezenta fie ca timp scurs de la ora conexiunii SAU ca dată și oră, în funcție de formatul axei X pe care îl specificați.

Când faceți complot în funcție de dată și oră, rutina de complot pfodApp corectează orice „deriva” din RTC comparând ora curentă raportată de pfodDevice cu ora curentă a telefonului mobil. Această corecție gestionează, de asemenea, setarea RTC la un fus orar diferit de fusul orar local al telefonului mobil. marcajele de timp millis () continuă să funcționeze ca în Utilizarea marcajelor de timp milisecunde Arduino, pasul 5 de mai sus.

Iată un exemplu de foaie de calcul a temperaturii camerei pe o perioadă de 8 zile, Office_Temp.xls Când fișierul jurnal a fost importat, prima coloană a fost marcată ca YMD pentru a converti textul la o dată / oră. În continuare, trebuie să eliminați formularul principal de la ora locală, UTC și Office Temp intrările de timp curent pentru ca foaia de calcul să le interpreteze ca date și ore.

Pentru a obține același grafic pe care îl arată pfodApp, trebuie să calculați „Data / Ora corectată”. În acest caz, ora RTC este cu 2 secunde în urmă față de ora locală a telefonului, astfel încât fiecărei etichete de timp RTC i se adaugă (ora locală - ora curentă Office Temp) pentru a obține ora locală adevărată.

Pentru graficele de timp scurs, creați o nouă coloană care conține (data / ora timstamp - ora curentă Office Time) și utilizați-o ca axa X în diagramă (Office_TempElapsed.xls) De fapt, în acest caz, pfodApp produce diagrame de timp scurs mai frumoase în zile h: min: sec.

Pasul 10: Utilizarea unui modul GPS

Folosirea unui modul GPS este similară cu utilizarea unui modul RTC, cu excepția faptului că modulele GPS au milisecunde disponibile, anii încep de la 2000 și timpul lipsește secundelor de salt UTC (consultați https://tycho.usno.navy.mil/leapsec.html) Data și ora GPS sunt în prezent cu 18 secunde înainte de UTC, începând cu ianuarie 2018.

Biblioteca GPS Adafruit pentru GPS Adafruit Ultimate, spre deosebire de RTClib, nu adaugă decalajul de 2000 de ani la GPS, deci trebuie adăugat atunci când trimiteți data și ora. De asemenea, deși biblioteca GPS furnizează milisecunde care au o precizie foarte bună pe termen lung, ele nu sunt foarte precise. Actualizările de timp GPS sunt doar o dată la fiecare 100mS și apoi există o întârziere suplimentară la primirea datelor seriale la 9600 baud lent și o altă întârziere la analizarea acestora. Toate acestea se adaugă preciziei de milisecundă la citirea datelor de marcare a timpului.

Iată câteva exemple de modificări ale codului de aplicat schiței generate de pfodDesigner pentru utilizarea unui modul GPS, presupunând că utilizați biblioteca GPS Adafruit și ați adăugat codul pentru a primi și analiza mesajele într-un obiect GPS.

// gestionați {@} request} else if ('@' == cmd) {// pfodApp a solicitat timpul 'curent' plot_mSOffset = millis (); // captează milisul curent ca offset de date brute parser.print (F ("{@` 0 "}); // returnează` 0 ca date brute 'curente' milisecunde parser.print ('~'); // începe șirul de data / ora sendDateTime (& GPS); // trimite aaaa / L / z / H: m: s la parser.print, treci adresa & ca arg. parser.print ('}'); // sfârșitul răspunsului {@ de ex. {@ `0 ~ 2019/19/04 3: 33: 5}….

// trimite data și ora către parser printvoid sendDateTime (Adafruit_GPS * gps) {parser.print (F ("20"); // 20.. year parser.print (gps-> year, DEC); parser.print ('/ '); parser.print (gps-> lună, DEC); parser.print (' / '); parser.print (gps-> day, DEC); parser.print (' '); parser.print (gps- > oră, DEC); parser.print (':'); parser.print (gps-> minute, DEC); parser.print (':'); parser.print (gps-> second, DEC); // parser.print ('.'); dacă trimiteți milisecunde // dacă doriți să trimiteți mS, trebuie să blocați valoarea gps-> milisecunde cu zero-uri principale // adică 3 trebuie să fie umplut la 003}

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // reporniți temporizatorul de date de plotare, fără drift // atribuiți valori pentru a variabilele de plotare din variabilele de buclă sau citiți intrările ADC plot_1_var = analogRead (A0); // citire intrare în complot // complot_2_var complot Ascuns deci nu există date atribuite aici // complot_3_var complot Ascuns deci nu sunt atribuite date aici // trimite date în format CSV sendDateTime (& GPS); // trimite aaaa / M / z / H: m: s la parser.print, treci adresa & ca arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // Parcela 2 este ascunsă. Nu au fost trimise date. parser.print (','); // Parcela 3 este ascunsă. Nu au fost trimise date. parser.println (); // sfârșitul înregistrării de date CSV}}

Când faceți complot în funcție de dată și oră, pfodApp se corectează automat pentru câteva secunde. În ianuarie 2018, ora GPS este cu 18 sec înaintea UTC. pfodApp corectează acest lucru comparând data / ora returnată de GPS la conexiune, prin răspunsul {@, cu data și ora UTC ale telefonului mobil. Crearea graficelor într-o foaie de calcul din fișierul jurnal pfodApp este aceeași ca și pentru modulele RTC de mai sus. Adăugarea (ora locală - ora curentă Office Temp) la marcajele de timp GPS se corectează pentru secundele de salt.

marcajele de timp millis () continuă să funcționeze ca în Utilizarea marcajelor de timp milisecunde Arduino, pasul 5 de mai sus.

Pasul 11: Concluzie

Utilizarea pfodApp pe mobilul dvs. Android vă permite să stabiliți date în funcție de dată și oră sau de timpul scurs, utilizând doar funcția Arduino's millis (). Folosind fișierul jurnal pfodApp, puteți reproduce din nou aceste grafice de dată / oră într-o foaie de calcul. Dacă proiectul dvs. Arduino are un modul RTC, puteți înregistra și trage data și marcajele de timp RTC, corectând automat „deriva” RTC. Dacă proiectul dvs. Arduino are un modul GPS, puteți să vă conectați și să trageți marcajele sale de timp extrem de precise, iar pfodApp va corecta automat secundele de salt lipsite de GPS.

În toate cazurile, datele brute din proiectul dvs. Arduino sunt înregistrate exact așa cum au fost primite, necorectate. Cu toate acestea, fișierul jurnal pfodApp include date suplimentare pentru a vă permite să reproduceți din nou aceste corecții într-o foaie de calcul din fișierul jurnal descărcat.

Nu este necesară codificarea Android. Formatele de complot sunt toate specificate prin șiruri de text mici în schița dvs. Arduino. PfodDesigner gratuit generează schițe complete de înregistrare a datelor Arduino și schițe pentru o mare varietate de plăci Arduino conectate prin WiFi, Bluetooth clasic, BLE și SMS