Arduino Dato/Tid Plotting/Logging Bruke Millis () og PfodApp: 11 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

Ingen Arduino- eller Android -programmering nødvendig. RTC- og GPS -moduler støttes også. Automatisk korreksjon for tidssoner, RTC -drift og GPS mangler sprang sekunder

Introduksjon

Denne opplæringen viser deg hvordan du bruker Arduino millis () tidsstempler til å plotte data mot dato og klokkeslett på Android -mobilen din ved hjelp av pfodApp.

Ingen Arduino- eller Android -programmering nødvendig. pfodApp logger også tilstrekkelige data slik at du senere kan reprodusere dato/klokkeslett i et regneark.

Ingen RTC eller GPS -modul er nødvendig, men hvis Arduino -prosjektet ditt har en RTC (sanntidsklokke) eller en GPS -modul, kan de også brukes. I slike tilfeller vil pfodApp -tomtene automatisk korrigere for tidssone, RTC -drift og GPS som mangler sprang sekunder. Ingen spesiell Arduino -kode er nødvendig for disse korreksjonene. Som alltid med pfodApp logges dataene som mottas nøyaktig slik de er, ikke-korrigert, men loggfilen inneholder også tilstrekkelig informasjon til at du kan bruke disse korreksjonene selv når du laster ned loggene til datamaskinen din. Se eksempler på denne etterbehandlingen nedenfor.

Et stort utvalg av tid og dato X-akseformatering støttes, som alle er fullstendig kontrollert av korte tekststrenger i Arduino-skissen din. Ingen Android -programmering er nødvendig.

pfodApp vil koble til via WiFi, Bluetooth Classic, BLE og SMS. Den gratis pfodDesigner genererer komplette Arduino -skisser for dato-/klokkeslettplanlegging/logging for å koble til et bredt utvalg av brett. Ingen Arduino -programmering er nødvendig.

Denne instruksen vil bruke en Adafruit Feather52 som eksempel Arduino -bord, som kobles til via BLE.

Denne instruksen dekker tre tilfeller:- 1) Mikroprosessorprosjektet ditt har bare tidsstempler i millisekunder- millis () 2) Mikroprosessorprosjektet har en sanntidsklokke (RTC)- pfodApp korrigerer automatisk for drift. 3) Mikroprosessorprosjektet ditt har en GPS -modul - pfodApp korrigerer automatisk i løpet av sekunder når de oppstår (for tiden 18 sekunder per 2018).

Trinn 1: Bruke Arduino Millisecond Timestamps, Millis ()

Det er to deler for å bruke millisekunder for dato og klokkeslett. Den ene er for å plotte dataene mot enten forløpt tid eller dato/klokkeslett, og den andre delen gjenoppretter dato og klokkeslett fra de loggede rawdata-millisekundens tidsstempler. pfodApp endrer ikke rådata mottatt fra pfodDevice (Arduino -mikroen). Det logger bare nøyaktig byte mottatt.

Bruk først gratis pfodDesigner til å generere en Arduino -skisse for mikroen din som sender millisekunder og datamålinger til pfodApp for plotting/logging. Dette eksemplet oppretter en meny for Adafruit Feather 52 BLE -kortet som leser A0. Opplæringen om Adafruit Feather nRF52 LE - Egendefinerte kontroller med pfodApp går gjennom trinnene i pfodDesigner for å lage en meny for Feather nRF52 som inneholder en diagramknapp, så sjekk den for mer informasjon. I denne opplæringen vil vi bare legge til en diagramknapp og bruke de nye X-aksens formatalternativer for å plotte A0-avlesningene mot forløpt tid og dato/tid.

Den første delen av denne opplæringen vil gå igjennom bruk av gratis pfodDesigner for å lage et eksempel på dato/tid -diagram på din Android -mobil. Når du er fornøyd med skjermen, kan du generere Arduino -skissen som vil gjengi det når du kobler deg til pfodApp. Ingen Android -programmering er nødvendig, og siden pfodDesigner genererer komplette Arduino -skisser for et stort utvalg Arduino -tavler, er det heller ikke nødvendig med Arduino -programmering.

Trinn 2: Legge til et diagram i menyen

Last ned pfodDesigner -appen fra Google Play, åpne den og klikk på "Start ny meny"

Klikk på "Target Serial" og deretter på "Bluetooth Low Energy" -knappen for å vise listen over noen 11 BLE -tavler (rull ned for å se de andre valgene). Velg på Adafruit Bluefruit Feather52.

Gå tilbake til redigeringsmenyen, klikk på "Rediger spørsmål" og angi en passende melding for denne menyen, f.eks. “Feather52” og fet skrift og størrelse +7. Bakgrunnsfargen ble igjen som 'standard' hvit

Gå tilbake og klikk på "Legg til menyelement", rull ned og velg "Diagramknapp" som åpner skjermknappens redigeringsskjerm. Du kan gjøre en endring i knappens utseende her. I dette tilfellet ble knappens tekst endret til “Dato/klokkeslett for A0”, og de andre standardene ble etterlatt som de er.

Dette gir deg en knapp på menyen som åpner kartskjermen.

Trinn 3: Redigere plottkilden og etikettene

Klikk på "Dato/tid-plott av A0" -knappen for å åpne Editing Plots-skjermbildet, der du får tilgang til kartetiketten, X-aksens format, plottdataintervall og (ved å rulle ned) selve plottinnstillingene. Rediger kartetiketten til noe passende, f.eks. "A0 volt".

Rull ned og for Plots 2 og 3 åpne Edit Plot og klikk på Skjul plot for å fjerne dem fra kartvisningen.

Klikk deretter på "Rediger plott 1" og sett en plottikett (f.eks. A0), yAxis -enheter (f.eks. Volt), vis maks 3,6V og koble til I/O -pinne A0.

Rull opp igjen og klikk på "Chart Preview" til de siste 0 eksempeldatapunktene, med 1 sek intervaller, plottet mot forløpt tid i minutter: sekunder.

For alle tidene som er gått, vises ikke tomter som fører null enheter, så i dette plottet er det bare tid> 1min som har innledende minutter vist.

Trinn 4: Velge dato/klokkeslettformat

For tiden som har gått, fortsetter den ledende enheten å øke etter hvert som tiden går. For å se et eksempel på dette, gå tilbake til skjermbildet "Rediger plott" og øk plottdataintervallet til 15 minutter (nederst på dette skjermbildet)

Klikk deretter på Chart Preview for å vise de samme eksempeldataene, men nå med 15 minutters intervaller mellom prøvene. Som du kan se minutter delen av mm: ss bare fortsetter å øke.

Gå nå tilbake og klikk på X-akseknappen for å vise et lite utvalg av alle mulige X-aksedata/tidsformater (rull ned for mer)

Over er et utvalg av diagramforhåndsvisninger ved bruk av forskjellige X-akseformater.

Dato/tid -plottene som vises her er i den 'lokale' tidssonen. Det er også formatalternativer for å plotte dato/klokkeslett i UTC. For et komplett sett med mulige dato/klokkeslettformatalternativer, se pfodSpecification.pfd.

Trinn 5: Generer og test Arduino -skissen

Når du er fornøyd med diagrammets format og dataintervall, kan du gå til "Redigeringsmeny_1" -skjermen og bla ned og "Generer kode" for det valgte brettet. Her er et eksempel på en skisse for Adafruit Feather52 ved hjelp av 1sek dataintervaller og et mm: ss forløpt tidsformat, pfodFeather52_timeplot.ino

Over er en tomt på A0 fra fjæren52

Endring av formatet til ukedagstimer: minutter: sek (~ E HH: mm: ss) og generering av koden (pfodFeather52_dateplot.ino) gir et plott som det andre ovenfor.

Du kan redigere X-akseformatet direkte i Arduino-skissen din, som beskrevet nedenfor.

Trinn 6: Hvordan plotter PfodApp dato/klokkeslett fra Millis ()?

Når pfodApp kobler seg til, husker den sin 'lokale' og UTC -tid og ber pfodDevices (Arduino -styrets) nåværende plottdatatidsstempler. Ved å bruke denne informasjonen kan pfodApp deretter plotte millisekund tidsstempler som enten forløpt tid, dvs. konvertere millisekunder til timer minutter sekunder osv., Eller plotte dato og klokkeslett millisekund tidsstempler representerer i forhold til når tilkoblingen ble gjort og pfodDevices nåværende tid ble forespurt.

Ser du i den Arduino -genererte skissen (f.eks. PfodFeather52_dateplot.ino), er det tre små kodebiter som håndterer Arduino -siden av tomtene.

Loop () -kodeseksjonen som håndterer pfodApps {@} nåværende tidsforespørsel

// håndter {@} forespørsel} annet hvis ('@' == cmd) {// pfodApp ba om 'nåværende' tid plot_mSOffset = millis (); // fange nåværende millis som offset rawdata tidsstempler parser.print (F ("{@` 0} ")); // returner '0 som' nåværende 'rådata millisekunder

Du kan bare returnere gjeldende verdi på millis (), men millis () vikler seg tilbake til 0 hver 49,7 dag, noe som vil få plottet til å hoppe bakover. Så i stedet husker koden gjeldende millis () -verdi da {@} forespørselen ble sendt, og returnerer {@`0} dvs. et nåværende tidsstempel på null på millisekund. Når du sender rådatapunktene, bruker skissen deretter

plot_1_var = analogRead (A0); // lese input til plot // plot_2_var plot Skjult så ingen data er tilordnet her // plot_3_var plot Skjult så ingen data tilordnet her // send plottdata i CSV-format parser.print (millis ()-plot_mSOffset); // tid i millisekunder ….

slik at tidsstempelet som sendes med dataene på millisekunder starter på 0 og øker opp til 49,7 dager. Hvis du holder kontakten kontinuerlig i 49,7 dager, vil du se plottet hoppe bakover med ~ 50 dager. Ved å koble fra og koble til igjen hver 49,7 dag unngår du dette.

Den tredje delen av dato/tid -plottet er plottmeldingen.

} annet hvis ('A' == cmd) {// bruker trykket - 'Dato/klokkeslett for A0' // i hovedmenyen i Meny_1 // retur plottingsmelding. parser.print (F ("{= A0 Volt ~ E HH: mm: ss | date | A0 ~~~ Volt ||}"));

Når brukeren trykker på knappen “Dato/klokkeslett for A0”, sender pfodApp {A} cmd til pfodDevice og pfodDevice svarer med plottmeldingen, {=… {= A0 Volt ~ E HH: mm: ss | date | A0 ~~~ Volt ||} som inneholder X-akseformatet E HH: mm: ss

Java SimpleDateFormat -formater er akseptable her. pfodApp Data Logging and Plotting og pfodSpecification.pdf har flere detaljer om plottmeldingen.

Trinn 7: Gjengi dato/klokkeslett på datamaskinen

Som standard logger pfodApp alle innkommende rådata til en loggfil på mobilen din, med mindre du har deaktivert denne loggingen i tilkoblingsredigeringsskjermen, se pfodAppForAndroidGettingStarted.pdf

Når du redigerer pfodApp, vises en kort melding med plassering og navn på loggfilen, f.eks. /pfodAppRawData/pfod_bluefruit52.txt Den filen er i CSV -format, kommaseparert, og etter å ha overført den til datamaskinen din (se pfodAppForAndroidGettingStarted.pdf for overføringsalternativer), kan du åpne den i et regneark for å plotte dataene.

Her er de første linjene i en loggfil.

// pfodApp V3.0.360, lokal tid, UTC, mS per dag, pfod bluefruit52 nåværende tid (mS), pfod bluefruit52 nåværende tid, // koblet til, 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,, Over kan du se den lokale og UTC -tiden som pfodApp koblet til Feather52 og gjeldende tid i mS som Feather52 rapporterte via {@..} svaret. Den siste kolonnen er tom, fordi det ikke er noen RTC eller GPS, og derfor ble det ikke rapportert om nåværende tid i åååå/MM/dd -tid av Feather52.

For å plotte dataene mot forløpt tid, trekker du gjeldende tid (mS) fra tidsstempelet millisekund og deler deretter med verdien mS per dag. Her er regnearket med formelen lagt til og resultatet plottet. Regnearket nedenfor (pfod_bluefruit52.xls) er et OpenOffice -regneark lagret i Excel -format.

I OpenOffice er plottet et spredningsdiagram og x-aksen til plottet ble formatert i HH: MM: SS Merk: Dato/klokkeslettformatene for regnearket er IKKE det samme som plottformatene som brukes av pfodApp. For eksempel i pfodApp er MM måneder og mm er minutter.

For å plotte mot dato og klokkeslett, trenger du bare å legge til tilkoblingstiden til regnearketiden og kopiere på nytt. (pfod_bluefruit52_date.xls)

Merk: Lokal tid og UTC ble importert som tekst i regnearket mitt, så jeg måtte fjerne innledningen før jeg brukte dem i en formel.

Trinn 8: Hvordan unngå grensen på 49,7 dager Millis () og hvorfor du ikke bør

Som nevnt ovenfor i Hvordan plotter pfodApp dato/tid fra millis () ?, hvis du forblir tilkoblet kontinuerlig i mer enn 49,7 dager, vil tidsstemplene i millisekunder vikle seg tilbake til null. Noen få kodelinjer kan unngå dette, men det anbefales ikke.

Først hvordan du unngår viklingen rundt. Legg til en annen usignert int -variabel for å holde oversikt over antall ganger tidsstemplene vikles rundt og skrive ut det kombinerte resultatet i HEX.

uint_t mSwrapCount = 0; uint32_t lastTimeStamp = 0;

… plot_1_var = analogRead (A0); // lese input til plot // plot_2_var plot Skjult så ingen data er tilordnet her // plot_3_var plot Skjult så ingen data tilordnet her // send plot data i CSV-format uint32_t timeStamp = millis ()-plot_mSOffset; if (timeStamp <lastTimeStamp) {// timeStamp pakket tilbake til 0 mSwrapCount ++; // legg til en for å telle} lastTimeStamp = timeStamp; parser.print ("0x"); parser.print (msWrapCount, HEX); parser.print (timeStamp, HEX); // tid i millisekunder i HEX….

Når du returnerer {@.. -svaret, må du også fjerne mSwrapCount.

// håndter {@} forespørsel} annet hvis ('@' == cmd) {// pfodApp ba om 'nåværende' tid plot_mSOffset = millis (); // fange nåværende millis som offset rawdata tidsstempler mSwrapCount = 0; // klar vikling. parser.print (F ("{@` 0} ")); // returner '0 som' nåværende 'rådata millisekunder

Tidsstemplene vil nå gi den "riktige" verdien for de neste 40,7 dagene * 65536 ~ = 7308 årene.

pfodApp vil automatisk konvertere hex -tidsstemplene for plotting og logge dem nøyaktig som mottatt, dvs. i hex. I regnearket (OpenOffice) bruker du denne formelen til å konvertere hex -strengen, i A2, til mS (hvor A1 er en hvilken som helst tom celle) = HEX2DEC (REPLACE (A2; 1; 2; A1))

Hvorfor vil du ikke gjøre dette

Som vist ovenfor er det enkelt å forlenge mS -tidsstemplene til mer enn 50 dager. Imidlertid vil du sannsynligvis ikke gjøre det fordi de blir stadig mer ukorrekte. En typisk 16Mhz krystall som brukes til å lage millis () -resultatene i mikroen har en nøyaktighet på ~ 50ppm (deler per million). Dette betyr at etter 49,7 dager kan tidsstempelet på millisekunder være ute med 3 ½ minutt, og det ignorerer effekten av temperaturen på krystallnøyaktigheten.

Over korte tilkoblingsperioder er ikke denne unøyaktigheten et problem ettersom {@.. -svaret synkroniserer tidsstempelet på millisekunder til datoen/klokkeslettet på mobilen på hver ny tilkobling. Men hvis du vil være tilkoblet i lange perioder (dager) og kontinuerlig logge dataene, bør du bruke noe mer nøyaktig enn den innebygde millis (), for eksempel en RTC- eller GPS-modul.

Trinn 9: Bruke en RTC (sanntidsklokke)

Det finnes en rekke RTC -moduler, en av de mer nøyaktige er DS3231 f.eks. Adafruit's DS3231 -modul. Oppgitt nøyaktighet er +/- 2ppm over 0 til 40C. dvs. ~ +/- 5 sek/måned.

Hvis du vil plotte data som har dato/klokkeslett tidsstempler, f.eks. 2019/04/19 20: 4: 34, så må du endre {@ -svaret for å returnere gjeldende dato/klokkeslett, f.eks. {@`0 ~ 2019/4/19 3: 33: 5}. Her er noen eksempler på kodeendringer som skal gjelde for pfodDesigner -genererte skissen for bruk av en RTC -modul, forutsatt at du bruker RTClib -biblioteket og har lagt til koden for å initialisere RTC -modulen.

// håndter {@} forespørsel} annet hvis ('@' == cmd) {// pfodApp ba om 'nåværende' tid plot_mSOffset = millis (); // fange nåværende millis som offset rawdata tidsstempler parser.print (F ("{@` 0 "}); // returnere` 0 som 'nåværende' rådata millisekunder parser.print ('~'); // startstreng av dato/tid DateTime nå = rtc.now () sendDateTime (& nå); // send åååå/M/d/H: m: s til parser.print, passadresse & som arg. parser.print ('}'); // slutten av {@ svar f.eks. {@ `0 ~ 2019/4/19 3: 33: 5}….

// send datotidspunkt til 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-> time (), DEC); parser.print (':'); parser.print (dt-> minutt (), DEC); parser.print (':'); parser.print (dt-> second (), DEC); }

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // start plottdatatimeren på nytt, uten drift // tilordne verdier til plottvariabler fra løkkevariablene eller les ADC -innganger plot_1_var = analogRead (A0); // lese input til plot // plot_2_var plot Skjult så ingen data er tilordnet her // plot_3_var plot Skjult så ingen data tilordnet her // send plottdata i CSV -format DateTime nå = rtc.now (); sendDateTime (& nå); // send åååå/M/d/H: m: s til parser.print, passadresse og som arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // Plot 2 er skjult. Ingen data sendt. parser.print (','); // Plot 3 er skjult. Ingen data sendt. parser.println (); // slutten av CSV -datapost}}

~ 2019/4/19 3: 33: 5 -delen av {@ -svaret lar pfodApp vite hva pfodDevice mener er gjeldende dato og klokkeslett. Skissen din kan deretter sende data med yMd Hms tidsstempler og pfodApp vil plotte dem enten som forløpt tid fra tilkoblingstiden ELLER som dato og klokkeslett, avhengig av X-aksens format du angir.

Når du plotter mot dato og klokkeslett, korrigerer pfodApp -plottrutinen for eventuelle "drift" i RTC ved å sammenligne pfodDevices rapporterte nåværende tid med mobilens nåværende tid. Denne korreksjonen håndterer også at RTC blir satt til en annen tidssone enn mobilens lokale tidssone. millis () tidsstempler fortsetter å fungere som i Bruke Arduino millisekunder tidsstempler, trinn 5 ovenfor.

Her er et eksempel på regneark over romtemperaturer over en 8 -dagers periode, Office_Temp.xls Da loggfilen ble importert, ble den første kolonnen merket som YMD for å konvertere teksten til en dato/klokkeslett. Du må fortsatt fjerne den ledende formen fra lokal tid, UTC og Office Temp nåværende tidsposter for å få regnearket til å tolke dem som datoer og klokkeslett.

For å få det samme plottet som pfodApp viser, må du beregne “Korrigert dato/klokkeslett”. I dette tilfellet er RTC -tiden 2 sekunder bak mobilens lokale tid, så til hvert RTC -tidsstempel legges det til (lokal tid - Office Temp nåværende tid) for å få den sanne lokale tiden.

For forløpne tidsplaner, opprett en ny kolonne som inneholder (dato/klokkeslett-tidspunktet for kontortidspunktet) og bruk den som X-aksen i diagrammet (Office_TempElapsed.xls) Faktisk i dette tilfellet produserer pfodApp bedre forløpte tidsdiagrammer i dager timer: minutter: sek.

Trinn 10: Bruke en GPS -modul

Å bruke en GPS -modul ligner på å bruke en RTC -modul, bortsett fra at GPS -moduler har millisekunder tilgjengelig, år starter ved 2000 og tiden mangler UTC -sprangsekunder (se https://tycho.usno.navy.mil/leapsec.html) Datoen og klokkeslettet for GPS er for tiden 18 sekunder foran UTC, per januar 2018.

Adafruit GPS -bibliotek for Adafruit Ultimate GPS, i motsetning til RTClib, legger ikke 2000 års forskyvning til GPS -årene, så det må legges til når du sender dato og klokkeslett. Selv om GPS -biblioteket leverer millisekunder som har veldig god langsiktig nøyaktighet, er de ikke veldig presise. GPS -tidsoppdateringene er bare én gang hver 100 ms, og det er en ekstra forsinkelse når serielle data mottas med en sakte 9600 baud og en annen forsinkelse i analysering av dem. Alt dette øker presisjonen på millisekunder ved tidsstempling av dataavlesninger.

Her er noen eksempler på kodeendringer for pfodDesigner -genererte skisser for bruk av en GPS -modul, forutsatt at du bruker Adafruit GPS -bibliotek og har lagt til koden for å motta og analysere meldingene i et GPS -objekt.

// håndter {@} forespørsel} annet hvis ('@' == cmd) {// pfodApp ba om 'nåværende' tid plot_mSOffset = millis (); // fange nåværende millis som offset rawdata tidsstempler parser.print (F ("{@` 0 "}); // returnere` 0 som 'nåværende' rådata millisekunder parser.print ('~'); // startstreng av date/time sendDateTime (& GPS); // send åååå/M/d/H: m: s til parser.print, passadresse & as arg. parser.print ('}'); // slutten av {@ svar f.eks. {@`0 ~ 2019/4/19 3: 33: 5}….

// send dato klokkeslett til parser printvoid sendDateTime (Adafruit_GPS* gps) {parser.print (F ("20"); // 20.. year parser.print (gps-> year, DEC); parser.print ('/ '); parser.print (gps-> måned, DEC); parser.print ('/'); parser.print (gps-> dag, DEC); parser.print (' '); parser.print (gps- > time, DEC); parser.print (':'); parser.print (gps-> minutt, DEC); parser.print (':'); parser.print (gps-> second, DEC); // parser.print ('.'); hvis du sender millisekunder // hvis du vil sende mS, må du putte gps-> millisekunder-verdien med ledende nuller // dvs. 3 må polstres til 003}

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // start plottdatatimeren på nytt, uten drift // tilordne verdier til plottvariabler fra løkkevariablene eller les ADC -innganger plot_1_var = analogRead (A0); // lese input til plot // plot_2_var plot Skjult så ingen data tilordnes her // plot_3_var plot Skjult så ingen data tilordnet her // send plot data i CSV -format sendDateTime (& GPS); // send åååå/M/d/H: m: s til parser.print, passadresse og som arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // Plot 2 er skjult. Ingen data sendt. parser.print (','); // Plot 3 er skjult. Ingen data sendt. parser.println (); // slutten av CSV -datapost}}

Når du plotter mot dato og klokkeslett, korrigerer pfodApp automatisk i løpet av et skuddsekund. Per januar 2018 er GPS -tiden 18 sekunder foran UTC. pfodApp korrigerer dette ved å sammenligne datoen/klokkeslettet som GPS -en returnerte ved tilkobling, via {@ -svaret, mot mobilens UTC -dato og -tid. Å lage tomter i et regneark fra pfodApp -loggfilen er det samme som for RTC -moduler ovenfor. Når du legger til (lokal tid - Kontorstemp gjeldende tid) i GPS -tidsstempene, korrigeres det for sprangsekundene.

millis () tidsstempler fortsetter å fungere som i Bruke Arduino millisekunder tidsstempler, trinn 5 ovenfor.

Trinn 11: Konklusjon

Ved å bruke pfodApp på din Android -mobil kan du plotte data mot dato og klokkeslett eller forløpt tid, bare ved å bruke Arduinos millis () -funksjon. Ved å bruke pfodApp-loggfilen kan du produsere disse dato-/klokkeslettene på nytt i et regneark. Hvis Arduino -prosjektet ditt har en RTC -modul, kan du logge og plotte dato og RTC -tidsstempler, automatisk korrigere for RTC 'drift'. Hvis ditt Arduino -prosjekt har en GPS -modul, kan du logge og plotte de meget nøyaktige tidsstemplene, og pfodApp vil automatisk korrigere GPSens manglende sprang sekunder.

I alle tilfeller logges rådataene fra Arduino -prosjektet nøyaktig som mottatt, ukorrekt. Imidlertid inneholder pfodApp-loggfilen ekstra data slik at du kan reprodusere disse korreksjonene i et regneark fra den nedlastede loggfilen.

Ingen Android -koding er nødvendig. Plottformatene er alle spesifisert med små tekststrenger i din Arduino -skisse. Den gratis pfodDesigner genererer komplette Arduino -datalogginger og plotter skisser for et bredt utvalg av Arduino -kort som kobles til via WiFi, Classic Bluetooth, BLE og SMS