Arduino dátum/idő ábrázolása/naplózása Millis () és PfodApp használatával: 11 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

Nincs szükség Arduino vagy Android programozásra. Az RTC és a GPS modulok is támogatottak. Az időzónák automatikus korrekciója, az RTC sodródás és a hiányzó szökő másodpercek

Bevezetés

Ez az oktatóanyag bemutatja, hogyan használhatja Arduino millis () időbélyegzőit az adatok ábrázolásához a dátum és idő függvényében Android -mobilján a pfodApp használatával.

Nincs szükség Arduino vagy Android programozásra. A pfodApp elegendő adatot naplóz, hogy később újra megjeleníthesse a dátum/idő diagramokat egy táblázatban.

Nincs szükség RTC vagy GPS modulra, de ha az Arduino projektje rendelkezik RTC (valós idejű óra) vagy GPS modullal, akkor is használhatók. Ezekben az esetekben a pfodApp grafikonok automatikusan korrigálják az időzónát, az RTC eltolódást és a hiányzó szökő másodperceket. Ezekhez a javításokhoz nincs szükség speciális Arduino kódra. Mint mindig a pfodApp esetében, a kapott adatok pontosan úgy kerülnek naplózásra, hogy azok nincsenek kijavítva, de a naplófájl elegendő információt is tartalmaz ahhoz, hogy ezeket a javításokat saját maga is alkalmazhassa, amikor letöltötte a naplókat a számítógépére. Lásd alább az utófeldolgozás példáit.

Az idő és dátum X-tengely formázásának széles választéka támogatott, mindezt teljesen vezérlik az Arduino-vázlat rövid szöveges karakterláncai. Nincs szükség Android programozásra.

A pfodApp WiFi, Bluetooth Classic, BLE és SMS -en keresztül csatlakozik. Az ingyenes pfodDesigner teljes Arduino vázlatokat generál a dátum/idő ábrázolásához/naplózásához, hogy csatlakozzon a táblák széles választékához. Nincs szükség Arduino programozásra.

Ez az utasítás Adafruit Feather52 -t fog használni példaként Arduino táblaként, amely a BLE -n keresztül csatlakozik.

Ez az utasítás három esetre vonatkozik:- 1) A mikroprocesszoros projekt csak ezredmásodperc időbélyegzővel rendelkezik- millis () 2) A mikroprocesszoros projekt valós idejű órával (RTC) rendelkezik- a pfodApp automatikusan korrigálja a sodródást. 3) A mikroprocesszoros projektje rendelkezik GPS -modullal - a pfodApp automatikusan korrigálja a szökő másodperceket, amikor előfordulnak (jelenleg 18 másodperc 2018 -ban).

1. lépés: Arduino ezredmásodperces időbélyegek használata, Millis ()

A dátum és az idő ezredmásodpercek használatának két része van. Az egyik az adatok ábrázolása az eltelt idő vagy a dátum/idő szerint, a másik rész pedig a dátum és az idő újbóli létrehozása a naplózott nyersadatok ezredmásodperces időbélyegeiből. A pfodApp nem módosítja a pfodDevice -től (az Arduino mikro) kapott nyers adatokat. Pontosan naplózza a kapott bájtokat.

Először az ingyenes pfodDesigner segítségével hozzon létre egy Arduino -vázlatot a mikro számára, amely elküldi az ezredmásodperceket és az adatméréseket a pfodApp -nak a rajzoláshoz/naplózáshoz. Ez a példa egy menüt hoz létre az Adafruit Feather 52 BLE táblához, amelyen A0 olvasható. Az Adafruit Feather nRF52 LE - Egyéni vezérlők a pfodApp alkalmazással kapcsolatos oktatóanyag a pfodDesigner lépésein keresztül menüt hoz létre a Feather nRF52 számára, amely tartalmaz egy Chart gombot, ezért nézze meg a további részleteket. Ebben az oktatóanyagban csak egy diagramgombot adunk hozzá, és az új X-tengely formátumbeállítások segítségével ábrázoljuk az A0 értékeket az eltelt idő és a dátum/idő alapján.

Ennek az oktatóanyagnak az első része az ingyenes pfodDesigner használatával megy keresztül, hogy minta dátum/idő diagramot hozzon létre Android -mobilján. Ha elégedett a kijelzővel, létrehozhatja az Arduino vázlatot, amely reprodukálja azt, amikor csatlakozik a pfodApp -hoz. Nincs szükség Android programozásra, és mivel a pfodDesigner teljes Arduino vázlatokat generál az Arduino táblák széles választékához, nincs szükség Arduino programozásra sem.

2. lépés: Diagram hozzáadása a menühez

Töltse le a pfodDesigner alkalmazást a Google Playről, nyissa meg, és kattintson az „Új menü indítása” gombra

Kattintson a „Target Serial”, majd a „Bluetooth Low Energy” gombra a 11 BLE tábla listájának megjelenítéséhez (görgessen lefelé a többi lehetőség megtekintéséhez). Válassza ki az Adafruit Bluefruit Feather52 -t.

Menjen vissza a Szerkesztés menübe, és kattintson a „Szerkesztési utasítás” gombra, és állítson be egy megfelelő parancsot ehhez a menühez, pl. „Feather52” és félkövér szöveg, +7 -es méret. A háttérszín alapértelmezett fehér maradt

Menjen vissza, és kattintson a „Menüelem hozzáadása” elemre, görgessen lefelé, és válassza a „Diagramgomb” lehetőséget, amely megnyitja a diagramgomb szerkesztési képernyőjét. Itt bármikor módosíthatja a gomb megjelenését. Ebben az esetben a gomb szövege „A0 dátum/idő görbe” -re változott, és a többi alapértelmezett érték maradt.

Ezzel egy gombot kap a menüben, amely megnyitja a diagram képernyőt.

3. lépés: A nyomtatási forrás és a címkék szerkesztése

Kattintson az „A0 dátum/idő diagramja” gombra a Szerkesztési parcellák képernyő megnyitásához, ahol elérheti a diagramcímkét, az X-tengely formátumát, a diagramadat-intervallumot és (lefelé görgetve) magát a diagrambeállításokat. Szerkessze a diagramcímkét valami megfelelőre, pl. "A0 volt".

Görgessen lefelé, és a 2. és 3. ábrák esetében nyissa meg a Plot szerkesztése lehetőséget, és kattintson a Telek elrejtése lehetőségre azok eltávolításához a diagramképernyőről.

Ezután kattintson a „Plot 1 szerkesztése” elemre, és állítson be egy diagramcímkét (pl. A0), yAxis egységeket (pl. Volt), max.

Görgessen felfelé, és kattintson a „Diagram előnézete” lehetőségre a legutóbbi 0 mintaadat -ponthoz, 1 másodperces időközönként, az eltelt idő és a perc: másodperc ábrázolásával.

Az összes eltelt idő esetén a nulla egység előtti ábrák nem jelennek meg, így ebben a diagramban csak azok az idő> 1 perc, amelyeknél az első percek jelennek meg.

4. lépés: A dátum/idő formátumának kiválasztása

Az eltelt idődiagramokhoz a vezető egység az idő előrehaladtával folyamatosan növekszik. Ha látni szeretne erre egy példát, menjen vissza a „Telek szerkesztése” képernyőre, és növelje a Plot Data intervallumot 15 percre (a képernyő alján).

Ezután kattintson a Diagram előnézetére, hogy ugyanazokat a mintaadatokat jelenítse meg, de most 15 perces intervallumokkal a minták között. Mint látható, az mm: ss percek része folyamatosan növekszik.

Most menjen vissza, és kattintson az X-tengely gombra az összes lehetséges X-tengely adat/időformátum kis választékának megjelenítéséhez (görgessen lejjebb további információkért)

A fenti diagramok előnézete a különböző X-tengely formátumokat használja.

Az itt látható dátum/idő görbék a "helyi" időzónában vannak. Vannak formátumbeállítások a dátum/idő UTC -ben való ábrázolására is. A lehetséges dátum/idő formázási lehetőségek teljes készletét lásd a pfodSpecification.pfd oldalon.

Lépés: Generálja és tesztelje az Arduino vázlatot

Ha elégedett a diagram formátumával és adatintervallumával, lépjen a „Szerkesztési menü_1” képernyőre, és görgessen lefelé, és válassza ki a „Kód létrehozása” lehetőséget a kiválasztott céltábla számára. Itt van egy minta vázlat az Adafruit Feather52 -hez 1 másodperces adatközök és mm: s eltelt idő formátum használatával, pfodFeather52_timeplot.ino

Fentebb az A0 parcellája a Feather52 -ből

Ha megváltoztatja a formátumot hétköznap hr: mins: sec (~ E HH: mm: ss), és újra generálja a kódot (pfodFeather52_dateplot.ino), akkor a fenti másodikhoz hasonló görbe jön létre.

Az X-tengely formátumát közvetlenül az Arduino vázlatában szerkesztheti, a következőkben leírtak szerint.

6. lépés: Hogyan ábrázolja a PfodApp a Millis () dátumot/időt?

Amikor a pfodApp csatlakozik, megjegyzi a „helyi” és az UTC -időt, és kéri a pfodDevice (az Arduino tábla) aktuális nyomtatási adat időbélyegzőit. Ezen információk felhasználásával a pfodApp ezredmásodperces időbélyegeket ábrázolhat az eltelt időként, azaz ezredmásodpercek óra / perc másodpercre konvertálásával stb., Vagy ábrázolhatja azt a dátumot és időt, amelyet az ezredmásodperces időbélyegek képviselnek a kapcsolat létrejöttéhez és a pfodDevice aktuális időpontjához viszonyítva.

Az Arduino által létrehozott vázlatban (pl. PfodFeather52_dateplot.ino) nézve három kis kódrészlet található, amelyek a plotok Arduino oldalát kezelik.

A ciklus () kódrész, amely a pfodApp {@} aktuális időkérését kezeli

// kezelje a {@} kérést} else if ('@' == cmd) {// pfodApp 'current' time plot_mSOffset = millis (); // az aktuális milliméterek rögzítése nyersadatok időbélyegeinek eltolásával parser.print (F ("{@` 0} ")); // a "0" értéket adja vissza "aktuális" nyers adat milliszekundumként

Csak visszaadhatja a millis () aktuális értékét, de a millis () 49,7 naponként visszaáll a 0 -ra, ami visszafelé ugrik. Ehelyett a kód megjegyzi a jelenlegi millis () értéket a {@} kérelem benyújtásakor, és visszaadja a {@`0} értéket, azaz a nulla ezredmásodperces időbélyeget. Ezután a rawdata pontok küldésekor a vázlat használja

plot_1_var = analógRead (A0); // bemenet beolvasása cselekményre // plot_2_var plot Rejtett, így nincs adat hozzárendelve // plot_3_var plot Rejtett, így nincs adat hozzárendelve // telekadatok küldése CSV formátumban parser.print (millis ()-plot_mSOffset); // idő ezredmásodpercben ….

így az adatokkal együtt küldött ezredmásodperces időbélyeg 0 -tól kezdődik és 49,7 napig nő. Ha 49,7 napig folyamatosan kapcsolatban marad, akkor a cselekmény visszafelé ugrik ~ 50 nappal. A 49,7 naponként történő bontás és újracsatlakozás ezt elkerülheti.

A dátum/idő diagram harmadik része a cselekményüzenet.

} else if ('A' == cmd) {// a felhasználó megnyomása - 'A0 dátum/idő görbéje' // // a Menu_1 főmenüjében // // a grafikon visszaadása. parser.print (F ("{= A0 volt ~ E HH: mm: ss | dátum | A0 ~~~ volt ||}"));

Amikor a felhasználó megnyomja az „A0 dátum/idő görbe” gombot, a pfodApp elküldi a {A} cmd -t a pfodDevice -nek, a pfodDevice pedig a cselekményüzenettel válaszol, {=… {= A0 volt ~ H H: mm: ss | date | A0 ~~~ Volt ||}, amely tartalmazza az X-tengely formátumát E HH: mm: ss

A Java SimpleDateFormat formátumok itt elfogadhatók. A pfodApp adatnaplózás és -ábrázolás és a pfodSpecification.pdf további részleteket tartalmaz a diagramüzenetről.

7. lépés: A dátum/idő grafikonok reprodukálása a számítógépen

Alapértelmezés szerint a pfodApp az összes bejövő nyersadatot naplófájlba naplózza a mobilján, hacsak nem tiltotta le ezt a naplózást a kapcsolatszerkesztő képernyőn, lásd: pfodAppForAndroidGettingStarted.pdf

A pfodApp szerkesztésekor megjelenik egy rövid üzenet a naplófájl helyével és nevével, pl. /pfodAppRawData/pfod_bluefruit52.txt Ez a fájl CSV formátumban van, vesszővel elválasztva, és miután átmásolta a számítógépére (az átviteli lehetőségekről lásd a pfodAppForAndroidGettingStarted.pdf fájlt), megnyithatja egy táblázatban az adatok ábrázolásához.

Itt található a naplófájl első néhány sora.

// pfodApp V3.0.360, helyi idő, UTC, mS naponta, pfod bluefruit52 aktuális idő (mS), pfod bluefruit52 aktuális idő, // csatlakozott, 2019.04.04. 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,, Fent látható a „helyi” és UTC -idő, amelyet a pfodApp a Feather52 -hez csatlakoztatott, és az aktuális idő mS -ben, amelyet a Feather52 jelentett a {@..} válaszon keresztül. Az utolsó oszlop üres, mivel nincs RTC vagy GPS, és így a Feather52 nem jelentett aktuális időt éééé/HH/nd időben.

Az adatok ábrázolásához az eltelt időhöz vonja le az aktuális időt (mS) a ezredmásodperces időbélyegzőből, majd ossza el az mS napi értékkel. Itt a táblázat, a képlet hozzáadásával és az eredmény ábrázolása. Az alábbi táblázat (pfod_bluefruit52.xls) egy Excel formátumban mentett OpenOffice táblázat.

Az OpenOffice-ban a diagram egy szórásdiagram, és a diagram x-tengelye ÓÓ: HH: SS formátumban lett formázva. Például a pfodApp -ban az MM hónap, és mm perc.

A dátum és az idő függvényében történő ábrázoláshoz csak hozzá kell adnia a csatlakozási időt a táblázathoz és az újratervezéshez. (pfod_bluefruit52_date.xls)

Megjegyzés: A helyi időt és az UTC -t szövegként importálták a táblázatba, ezért el kellett távolítanom a kezdőbetűt, mielőtt képletben használnám őket.

8. lépés: Hogyan kerülhető el a 49,7 napos Millis () korlát és miért nem szabad

Amint fentebb említettük, hogyan ábrázolja a pfodApp a dátumot/időt milliszámból () ?, ha 49,7 napnál hosszabb ideig folyamatosan kapcsolatban marad, az ezredmásodperces időbélyegek visszaállnak a nullára. Néhány kódsor elkerülheti ezt, de nem ajánlott.

Először is, hogyan kerülje el a körbetekerést. Adjon hozzá egy másik alá nem írt int változót, hogy nyomon kövesse az időbélyegek körbefutásának számát, és a kombinált eredményt HEX formátumban nyomtassa ki.

uint_t mSwrapCount = 0; uint32_t lastTimeStamp = 0;

… Plot_1_var = analogRead (A0); // bemenet beolvasása cselekményre // plot_2_var plot Rejtett, így itt nincs adat hozzárendelve // plot_3_var plot Rejtett, így nincs hozzárendelve itt // telekadatok küldése CSV formátumban uint32_t timeStamp = millis ()-plot_mSOffset; if (timeStamp <lastTimeStamp) {// timeStamp visszacsomagolva 0 mSwrapCount ++; // adjon hozzá egyet a számláláshoz} lastTimeStamp = timeStamp; parser.print ("0x"); parser.print (msWrapCount, HEX); parser.print (timeStamp, HEX); // az idő ezredmásodpercben a HEX -ben….

Amikor visszaadja a {@.. választ, törölje az mSwrapCount -ot is.

// kezelje a {@} kérést} else if ('@' == cmd) {// pfodApp 'current' time plot_mSOffset = millis (); // az aktuális milliméterek rögzítése eltolt nyersadatok időbélyegeként mSwrapCount = 0; // tiszta csomagolás. parser.print (F ("{@` 0} ")); // 0 -t ad vissza "aktuális" nyers adat milliszekundumként

Az időbélyegek mostantól a „helyes” értéket adják a következő 40,7 napra * 65536 ~ = 7308 évre.

A pfodApp automatikusan átalakítja a hexadecimális időbélyegeket a rajzoláshoz, és pontosan naplózza azokat a kapott módon, azaz hexadecimálisan. Az (OpenOffice) táblázatban ezt a képletet használva alakíthatja át a hexadecimális karakterláncot A2 -ben mS -re (ahol A1 bármely üres cella) = HEX2DEC (REPLACE (A2; 1; 2; A1))

Miért nem akarja ezt csinálni

Amint fentebb látható, az mS időbélyegzőit 50 napnál hosszabbra is meg lehet hosszabbítani. Ezt azonban valószínűleg nem szeretné megtenni, mert egyre pontatlanabbá válnak. Egy tipikus 16 MHz -es kristály, amelyet a millis () eredmények létrehozásához használnak, a mikro pontossága ~ 50 ppm (milliomodrész). Ez azt jelenti, hogy 49,7 nap elteltével az ezredmásodperces időbélyeg 3½ perccel eltűnik, és figyelmen kívül hagyja a hőmérséklet kristály pontosságra gyakorolt hatását.

Rövid csatlakozási időszakok alatt ez a pontatlanság nem jelent problémát, mivel a {@.. válasz minden újracsatlakozáskor újra szinkronizálja az ezredmásodperces időbélyeget a mobil dátumával/idejével. Ha azonban hosszú ideig (napok) szeretne kapcsolatban maradni és folyamatosan naplózni az adatokat, akkor a beépített millimétereknél () pontosabbat kell használnia, például egy RTC vagy GPS modult.

9. lépés: RTC (valós idejű óra) használata

Számos RTC modul áll rendelkezésre, az egyik pontosabb a DS3231 pl. Az Adafruit DS3231 modulja. A megadott pontosság +/- 2 ppm 0 és 40 ° C között. azaz ~ +/- 5 mp/hó.

Ha dátum/idő időbélyeggel rendelkező adatokat szeretne ábrázolni, pl. 2019/04/19 20: 4: 34, akkor módosítania kell a {@ választ, hogy az aktuális dátumot/időt adja vissza, pl. {@`0 ~ 2019/4/19 3: 33: 5}. Íme néhány mintakód -módosítás, amelyet alkalmazni kell a pfodDesigner által létrehozott vázlatra az RTC modul használatához, feltéve, hogy az RTClib könyvtárat használja, és hozzáadta a kódot az RTC modul inicializálásához.

// kezelje a {@} kérést} else if ('@' == cmd) {// pfodApp 'current' time plot_mSOffset = millis (); // rögzítse az aktuális millimétereket nyersadatok időbélyegzőinek eltolásával parser.print (F ("{@` 0 "}); // return 0, mint" aktuális "nyers adat milliszekundum parser.print ('~'); // date/time DateTime now = rtc.now () sendDateTime (& now); // send yyyy/H/d/H: m: s to parser.print, pass address & as argument. parser.print ('}'); // a {@ válasz vége, pl. {@ `0 ~ 2019/4/19 3: 33: 5}….

// dátum küldése az elemzőnek printvoid sendDateTime (DateTime* dt) {parser.print (dt-> year (), DEC); parser.print ('/'); parser.print (dt-> hónap (), DEC); parser.print ('/'); parser.print (dt-> nap (), DEC); parser.print (''); parser.print (dt-> óra (), DEC); parser.print (':'); parser.print (dt-> perc (), DEC); parser.print (':'); parser.print (dt-> second (), DEC); }

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // a plot adat időzítő újraindítása, eltolás nélkül // értékek hozzárendelése a plot változókhoz a ciklus változóiból, vagy az ADC bemenetek olvasása plot_1_var = analogRead (A0); // bemenet beolvasása cselekménybe // plot_2_var plot Rejtett, így itt nincs adat hozzárendelve // plot_3_var plot Rejtett, így nincs hozzárendelve itt // telekadatok küldése CSV formátumban DateTime now = rtc.now (); sendDateTime (& most); // yyyy/M/d/H: m: s elküldése a parser.print -nek, cím átadása & as arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // A 2. ábra rejtett. Nincs adat elküldve. parser.print (','); // A 3. terv rejtett. Nincs adat elküldve. parser.println (); // a CSV -adatrekord vége}}

A ~ 2019/4/19 3: 33: 5 rész a {@ válaszból tájékoztatja a pfodApp -ot, hogy a pfodDevice szerint mi az aktuális dátum és idő. A vázlata ezután adatokat küldhet yMd Hms időbélyegzővel, és a pfodApp a megadott X-tengely formátumtól függően vagy a kapcsolódási idő elteltével, vagy dátumként és időként ábrázolja azokat.

A dátum és az idő függvényében történő ábrázoláskor a pfodApp plot rutinja korrigálja az RTC esetleges „sodródását”, összehasonlítva a pfodDevice jelentett aktuális idejét a mobil aktuális idejével. Ez a korrekció azt is kezeli, hogy az RTC más időzónára legyen beállítva, mint a mobilja helyi időzónája. A millis () időbélyegek továbbra is működnek, mint az Arduino ezredmásodperces időbélyegzők használata, fenti 5. lépésben.

Íme egy példa táblázat a szobahőmérsékletről egy 8 napos időszak alatt, Office_Temp.xls A naplófájl importálásakor az első oszlop YMD -ként lett megjelölve, hogy a szöveget dátumra/időre konvertálja. Még mindig el kell távolítania a vezető időt a helyi idő, az UTC és az Office Temp aktuális időbejegyzései közül, hogy a táblázat dátumként és időként értelmezze őket.

Ahhoz, hogy ugyanazt a diagramot kapja, amit a pfodApp mutat, ki kell számítania a „Javított dátum/idő” értéket. Ebben az esetben az RTC idő 2 másodperccel elmarad a mobil helyi idejétől, ezért minden RTC időbélyegzőt hozzá kell adni (helyi idő - Office Temp aktuális idő), hogy megkapjuk a valódi helyi időt.

Az eltelt idődiagramokhoz hozzon létre egy új oszlopot, amely tartalmazza a (dátum/idő időbélyegzőjét-az Office Time aktuális idejét), és használja ezt a diagram X-tengelyeként (Office_TempElapsed.xls) Valójában ebben az esetben a pfodApp szebb eltelt idő diagramokat készít napokban óra: perc: másodperc

10. lépés: GPS -modul használata

A GPS -modul használata hasonló az RTC -modulhoz, azzal a különbséggel, hogy a GPS -modulok ezredmásodpercekben állnak rendelkezésre, az évek 2000 -től kezdődnek, és az időből hiányoznak az UTC szökő másodpercek (lásd: https://tycho.usno.navy.mil/leapsec.html) A GPS dátuma és ideje jelenleg 18 másodperccel az UTC előtt van, 2018 januárjában.

Az Adafruit GPS könyvtár az Adafruit Ultimate GPS -hez, az RTClib -től eltérően, nem adja hozzá a 2000 éves eltolást a GPS -évekhez, ezért ezt hozzá kell adni a dátum és az időbélyegző elküldésekor. Továbbá, bár a GPS könyvtár ezredmásodperceket biztosít, amelyek nagyon jó hosszú távú pontossággal rendelkeznek, nem túl pontosak. A GPS időfrissítései 100 mS -enként csak egyszer, majd további késleltetés következik be a soros adatok lassú 9600 baudos fogadásakor, és újabb késleltetés az elemzés során. Mindezek ezredmásodperc pontossággal növelik az adatok leolvasásának időbélyegzését.

Íme néhány mintakód -módosítás, amelyet alkalmazni kell a pfodDesigner generált vázlatára a GPS -modul használatához, feltéve, hogy az Adafruit GPS -könyvtárát használja, és hozzáadta a kódot az üzenetek fogadásához és elemzéséhez egy GPS -objektumban.

// kezelje a {@} kérést} else if ('@' == cmd) {// pfodApp 'current' time plot_mSOffset = millis (); // rögzítse az aktuális millimétereket nyersadatok időbélyegzőinek eltolásával parser.print (F ("{@` 0 "}); // return 0, mint" aktuális "nyers adat milliszekundum parser.print ('~'); // date/time sendDateTime (& GPS); // yyyy/H/d/H: m: s küldése a parser.print -nek, a cím átadása & as argument. parser.print ('}'); // a {@ válasz pl. {@`0 ~ 2019/4/19 3: 33: 5}….

// dátum küldése az elemzőnek printvoid sendDateTime (Adafruit_GPS* gps) {parser.print (F ("20"); // 20.. year parser.print (gps-> year, DEC); parser.print ('/ '); parser.print (gps-> hónap, DEC); parser.print ('/'); parser.print (gps-> nap, DEC); parser.print (' '); parser.print (gps- > óra, DEC); parser.print (':'); parser.print (gps-> perc, DEC); parser.print (':'); parser.print (gps-> másodperc, DEC); // parser.print ('.'); ezredmásodperc küldése esetén // ha mS-t szeretne küldeni, akkor a gps-> ezredmásodperc értéket a kezdő nullákkal kell kitölteni // azaz a 3-at 003-ra kell kitölteni}

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // a plot adat időzítő újraindítása, eltolás nélkül // értékek hozzárendelése a plot változókhoz a ciklus változóiból, vagy az ADC bemenetek olvasása plot_1_var = analogRead (A0); // bemenet beolvasása cselekményre // plot_2_var plot Rejtett, így nincs adat hozzárendelve // plot_3_var plot Rejtett, így nincs hozzárendelve itt // telekadatok küldése CSV formátumban sendDateTime (& GPS); // yyyy/M/d/H: m: s elküldése a parser.print -nek, cím átadása & as arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // A 2. ábra rejtett. Nincs adat elküldve. parser.print (','); // A 3. terv rejtett. Nincs adat elküldve. parser.println (); // a CSV -adatrekord vége}}

Amikor dátum és idő szerint ábrázol, a pfodApp automatikusan korrigálja a szökő másodperceket. 2018 januárjában a GPS idő 18 másodperccel megelőzi az UTC -t. A pfodApp ezt úgy korrigálja, hogy összehasonlítja a GPS által a csatlakozáskor visszaadott dátumot/időt a {@ válaszon keresztül a mobil UTC dátumával és idejével. A táblázatok létrehozása táblázatban a pfodApp naplófájlból ugyanaz, mint a fenti RTC modulok esetében. A (helyi idő - Office Temp aktuális idő) hozzáadása a GPS időbélyegekhez korrigálja a szökő másodperceket.

A millis () időbélyegek továbbra is működnek, mint az Arduino ezredmásodperces időbélyegzők használata, fenti 5. lépésben.

11. lépés: Következtetés

A pfodApp használata az Ön Android mobilján lehetővé teszi az adatok ábrázolását a dátum és az idő vagy az eltelt idő függvényében, csak az Arduino millis () függvényével. A pfodApp naplófájl segítségével újra előállíthatja ezeket a dátum/idő diagramokat egy táblázatban. Ha az Arduino projektje rendelkezik RTC modullal, akkor naplózhatja és ábrázolhatja a dátumot és az RTC időbélyegeket, automatikusan korrigálva az RTC „sodródását”. Ha az Arduino projekt rendelkezik GPS modullal, akkor naplózhatja és ábrázolhatja annak rendkívül pontos időbélyegzőit, és a pfodApp automatikusan kijavítja a GPS hiányzó szökő másodperceit.

Minden esetben az Arduino -projekt nyers adatai pontosan a beérkezett, javítatlan naplóba kerülnek. A pfodApp naplófájl azonban további adatokat tartalmaz, amelyek lehetővé teszik, hogy ezeket a javításokat táblázatban készítse el újra a letöltött naplófájlból.

Nincs szükség Android -kódolásra. A nyomtatási formátumokat az Arduino -vázlat kis szöveges karakterláncai határozzák meg. Az ingyenes pfodDesigner teljes Arduino adatnaplózási és -rajzolási vázlatokat generál a Wrd -n, klasszikus Bluetooth -on, BLE -n és SMS -en keresztül csatlakozó Arduino -táblák széles választékához