Petsa ng Arduino / Oras na Plotting / Pag-log Gamit ang Millis () at PfodApp: 11 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:12

Walang kinakailangang programa ng Arduino o Android. Sinuportahan din ang mga module ng RTC at GPS. Awtomatikong pagwawasto para sa mga timezone, RTC naaanod at nawawalang leap segundo ng GPS

Panimula

Ipinapakita sa iyo ng tutorial na ito kung paano gamitin ang iyong mga timestamp ng Arduino millis () upang magbalangkas ng data laban sa petsa at oras sa iyong Android mobile gamit ang pfodApp.

Walang kinakailangang programa ng Arduino o Android. Nag-log din ang pfodApp ng sapat na data upang makaya mo muling kopyahin ang mga plot ng petsa / oras sa isang spreadsheet.

WALANG module ng RTC o GPS ang kinakailangan, subalit kung ang iyong proyekto sa Arduino ay mayroong RTC (Real Time Clock) o isang module ng GPS maaari mo rin itong magamit. Sa mga kasong iyon, ang mga plots ng pfodApp ay awtomatikong magtatama para sa timezone, RTC naaanod at nawawalang mga leap segundo ng GPS. Walang espesyal na Arduino code ang kinakailangan para sa mga pagwawasto. Tulad ng lagi sa pfodApp, ang natanggap na data ay naka-log eksakto tulad ng, hindi naitama, gayunpaman ang file ng log ay naglalaman din ng sapat na impormasyon upang payagan kang ilapat ang mga pagwawasto na ito mismo kapag na-download mo ang mga log sa iyong computer. Tingnan sa ibaba ang mga halimbawa ng post-processing na ito.

Ang isang malawak na pagkakaiba-iba ng oras at petsa ng pag-format ng X-axis ay suportado, na ang lahat ay ganap na kinokontrol ng maikling mga string ng teksto sa iyong Arduino sketch. Walang kinakailangang programa sa Android.

Ang pfodApp ay kumokonekta sa pamamagitan ng WiFi, Bluetooth Classic, BLE at SMS. Ang libreng pfodDesigner ay bumubuo ng kumpletong mga sketch ng Arduino para sa petsa / oras na paglalagay / pag-log upang kumonekta sa iba't ibang mga board. Walang kinakailangang programa sa Arduino.

Ang itinuturo na ito ay gagamit ng isang Adafruit Feather52 bilang halimbawa ng Arduino board, na kumokonekta sa pamamagitan ng BLE.

Ang itinuturo na ito ay sumasaklaw sa tatlong mga kaso: - 1) Ang iyong proyekto na microprocessor ay mayroon lamang mga millisecond timestamp - millis () 2) Ang iyong proyekto na microprocessor ay mayroong isang Real Time Clock (RTC) - awtomatikong naitatama ng pfodApp para sa naaanod. 3) Ang iyong proyekto sa microprocessor ay may isang module ng GPS - awtomatikong naitatama ng pfodApp para sa mga lumundag na segundo habang nangyayari ito (kasalukuyang 18 segundo hanggang 2018).

Hakbang 1: Paggamit ng Arduino Millisecond Timestamp, Millis ()

Mayroong dalawang bahagi sa paggamit ng milliseconds para sa petsa at oras. Ang isa ay para sa paglalagay ng data laban sa alinman sa lumipas na oras o petsa / oras at ang iba pang bahagi ay muling paglikha ng petsa at oras mula sa naka-log na rawdata millisecond timestamp. Hindi binabago ng pfodApp ang raw data na natanggap mula sa pfodDevice (ang Arduino micro). Ito ay nagta-log lamang eksakto ng mga byte na natanggap.

Gamitin muna ang libreng pfodDesigner upang makabuo ng isang Arduino sketch para sa iyong micro na magpapadala ng mga millisecond at pagsukat ng data sa pfodApp para sa paglalagay / pag-log. Ang halimbawang ito ay lumilikha ng isang menu para sa Adafruit Feather 52 BLE board na nagbabasa ng A0. Ang tutorial sa Adafruit Feather nRF52 LE - Mga Custom na Kontrol sa pfodApp ay dumadaan sa mga hakbang na pfodDesigner upang lumikha ng isang menu para sa Feather nRF52 na may kasamang isang pindutan ng Tsart, kaya suriin ito para sa higit pang mga detalye. Sa tutorial na ito, magdagdag kami ng isang pindutan lamang ng tsart at gagamitin ang mga bagong pagpipilian ng format na axis-X upang magbalak ng mga pagbasa ng A0 laban sa lumipas na oras at petsa / oras.

Ang unang bahagi ng tutorial na ito ay dadaan sa pamamagitan ng paggamit ng libreng pfodDesigner upang lumikha ng isang sample na tsart ng petsa / oras sa iyong Android mobile. Kapag nasiyahan ka sa pagpapakita maaari kang makabuo ng Arduino sketch na magpaparami nito kapag kumonekta ka sa pfodApp. Walang kinakailangang Programming sa Android at dahil ang pfodDesigner ay bumubuo ng kumpletong mga sketch ng Arduino para sa isang iba't ibang mga Arduino board, walang kinakailangang programa sa Arduino alinman.

Hakbang 2: Pagdaragdag ng isang Tsart sa Menu

I-download ang pfodDesigner app mula sa Google Play, buksan ito at mag-click sa "Magsimula ng bagong Menu"

Mag-click sa "Target Serial" at pagkatapos ay sa pindutang "Bluetooth Mababang Enerhiya" upang ipakita ang listahan ng ilang 11 BLE board (mag-scroll pababa upang makita ang iba pang mga pagpipilian). Piliin sa Adafruit Bluefruit Feather52.

Bumalik sa menu ng Pag-edit at mag-click sa "I-edit ang Prompt" at magtakda ng angkop na prompt para sa menu na ito, hal. "Feather52" at text na naka-bold at laki +7. Ang kulay sa background ay naiwan bilang 'default' na Puti

Bumalik at mag-click sa "Magdagdag ng Item sa Menu", mag-scroll pababa at piliin ang "Tsart ng Tsart" na magbubukas sa screen ng pag-edit ng pindutan ng tsart. Maaari kang gumawa ng anumang pagbabago sa hitsura ng pindutan dito. Sa kasong ito ang teksto ng pindutan ay binago sa "Petsa / Oras ng balangkas ng A0" at ang iba pang mga default ay naiwan na tulad nito.

Binibigyan ka nito ng isang pindutan sa menu na magbubukas sa screen ng tsart.

Hakbang 3: Pag-edit sa Pinagmulan ng Plot at Mga Lable

Mag-click sa pindutan na "Petsa / Oras ng A0" upang buksan ang screen ng Pag-edit ng Mga Plots, kung saan maaari mong ma-access ang label na tsart, format na X-axis, agwat ng data ng plot at (sa pamamagitan ng pag-scroll pababa) mismo ng mga setting ng balangkas. I-edit ang Chart Label sa isang bagay na angkop, hal. "A0 Volts".

Mag-scroll pababa at para sa Plots 2 at 3 buksan ang I-edit ang Plot at i-click ang Itago ang Plot upang alisin ang mga ito mula sa display ng tsart.

Pagkatapos mag-click sa "I-edit ang Plot 1" at magtakda ng isang label na balangkas (hal. A0), yAxis unit (hal. Volts), ipakita ang max ng 3.6V at kumonekta sa I / O pin A0.

Mag-scroll back up at mag-click sa "Chart Preview" sa pinakabagong 0 sample na mga puntos ng data, sa mga agwat ng 1sec, na naka-plano laban sa lumipas na oras sa mga min: seg.

Para sa lahat ng lumipas na mga plots ng oras na humahantong sa zero na mga yunit ay hindi ipinapakita sa sa plot na ito lamang sa oras na iyon> 1min na may ipinakitang mga nangungunang minuto.

Hakbang 4: Pagpili ng Format ng Petsa / Oras

Para sa lumipas na mga plots ng oras ang nangungunang yunit ay patuloy na nadaragdagan habang tumatagal. Upang makita ang isang halimbawa nito bumalik sa screen na "Pag-edit ng Mga Plots" at dagdagan ang agwat ng Plot Data sa 15mins (ilalim ng screen na ito)

Pagkatapos mag-click sa Chart Preview upang maipakita ang parehong data ng sample ngunit ngayon na may 15min agwat sa pagitan ng mga sample. Tulad ng nakikita mo ang minuto na bahagi ng mm: patuloy lamang na nadaragdagan ang ss.

Bumalik ngayon at mag-click sa pindutan ng X-axis upang maipakita ang isang maliit na pagpipilian ng lahat ng posibleng mga format ng data / oras ng X-axis (mag-scroll pababa para sa higit pa)

Sa itaas ay isang pagpipilian ng mga preview ng tsart gamit ang iba't ibang mga format ng X-axis.

Ang mga plots ng petsa / oras na ipinapakita dito ay nasa 'lokal' na timezone. Mayroon ding mga pagpipilian sa format upang mag-plot ng petsa / oras sa UTC. Para sa isang kumpletong hanay ng mga posibleng pagpipilian ng format ng petsa / oras tingnan ang pfodSpecification.pfd.

Hakbang 5: Bumuo at Subukan ang Arduino Sketch

Kapag nasisiyahan ka sa format ng iyong tsart at agwat ng data, maaari kang sa screen na "Pag-edit ng Menu_1" at mag-scroll pababa at "Bumuo ng Code" para sa napili mong target board. Narito ang isang sample na sketch para sa Adafruit Feather52 gamit ang mga agwat ng data ng 1sec at isang mm: ss lumipas na format ng oras, pfodFeather52_timeplot.ino

Sa itaas ay isang lagay ng A0 mula sa Feather52

Ang pagbabago ng format sa Weekday hr: mins: sec (~ E HH: mm: ss) at muling pagbuo ng code (pfodFeather52_dateplot.ino) ay nagbibigay ng isang lagay ng lupa tulad ng pangalawa sa itaas.

Maaari mong i-edit ang format ng X-axis nang direkta sa iyong Arduino sketch, tulad ng susunod na inilarawan.

Hakbang 6: Paano Ang Petsa / Oras ng Plot ng PfodApp Mula sa Millis ()?

Kapag nag-uugnay ang pfodApp, naaalala nito ang 'lokal' at oras ng UTC at hinihiling ang kasalukuyang timestamp ng data ng data ng pfodDevice (ang Arduino board). Ang paggamit ng impormasyong ito pfodApp ay maaaring magbalangkas ng mga timestamp ng millisecond bilang alinman sa lumipas na oras ibig sabihin ay ang pag-convert ng mga millisecond sa oras na minuto atbp, o balangkas ang petsa at oras na kinakatawan ng mga timestamp ng millisecond na may kaugnayan sa kung kailan nagawa ang koneksyon at hiniling ang kasalukuyang oras ng pfodDevice.

Sa pagtingin sa nabuong sketch ng Arduino (hal. PfodFeather52_dateplot.ino), mayroong tatlong maliliit na piraso ng code na humahawak sa panig ng Arduino ng mga plots.

Ang seksyon ng loop () code na humahawak sa kasalukuyang kahilingan sa oras ng pfodApp {@}

// hawakan {@} hiling} pa kung ('@' == cmd) {// pfodApp humiling ng 'kasalukuyang' oras plot_mSOffset = millis (); // capture current millis as offset rawdata timestamp parser.print (F ("{@` 0} ")); // ibalik ang "0 bilang 'kasalukuyang' hilaw na milliseconds ng data

Maaari mo lamang ibalik ang kasalukuyang halaga ng millis (), ngunit ang millis () ay balot pabalik sa 0 tuwing 49.7 araw, na maaaring tumalon paurong. Kaya sa halip ay naaalala ng code ang kasalukuyang halaga ng millis () nang nagawa ang {@} kahilingan, at ibabalik ang {@ `0} ibig sabihin ay isang kasalukuyang millisecond timestamp na zero. Pagkatapos kapag nagpapadala ng mga puntos ng rawdata na ginagamit ng sketch

plot_1_var = analogRead (A0); // read input to plot // plot_2_var plot Hidden kaya walang nakatalagang data dito // plot_3_var plot Nakatago kaya walang data na nakatalaga dito // magpadala ng data ng plot sa CSV format parser.print (millis () - plot_mSOffset); // oras sa milliseconds ….

upang ang millisecond timestamp na ipinadala kasama ang data ay nagsisimula sa 0 at tataas hanggang sa 49.7day. Kung mananatiling konektado ka ng tuloy-tuloy para sa 49.7day pagkatapos ay makikita mo ang balangkas na tumalon paatras ng ~ 50day. Ang pagdidiskonekta at muling pagkonekta nang isang beses bawat 49.7 araw ay iniiwasan ito.

Ang pangatlong bahagi ng date / time plot ay ang plot message.

} iba pa kung ('A' == cmd) {// user na pinindot - 'Petsa / Oras ng plot ng A0' // sa pangunahing Menu ng Menu_1 // return plotting msg. parser.print (F ("{= A0 Volts ~ E HH: mm: ss | date | A0 ~~~ Volts ||}"));

Kapag pinindot ng gumagamit ang button na "Petsa / Oras ng A0", ipinapadala ng pfodApp ang {A} cmd sa pfodDevice at ang pfodDevice ay tumutugon kasama ang isang mensahe ng balangkas, {= … {= A0 Volts ~ E HH: mm: ss | date | A0 ~~~ Volts ||} na naglalaman ng format na X-axis na E HH: mm: ss

Ang mga format ng Java SimpleDateFormat ay katanggap-tanggap dito. Ang pfodApp Data Logging and Plotting at ang pfodSpecification.pdf ay may higit pang mga detalye sa mensahe ng balangkas.

Hakbang 7: Ang muling paggawa ng Mga Plots ng Petsa / Oras sa Iyong Computer

Bilang default, na-log ng pfodApp ang lahat ng papasok na rawdata sa isang file ng log sa iyong mobile, maliban kung hindi mo pinagana ang pag-log in sa screen ng pag-edit ng koneksyon, tingnan ang pfodAppForAndroidGettingStarted.pdf

Kapag na-edit mo ang pfodApp, isang maikling mensahe ang ipinapakita kasama ang lokasyon at pangalan ng file ng log, hal. /pfodAppRawData/pfod_bluefruit52.txt Ang file na iyon ay nasa format na CSV, na-limit, at pagkatapos ilipat ito sa iyong computer (tingnan ang pfodAppForAndroidGettingStarted.pdf para sa mga pagpipilian sa paglipat), maaari mo itong buksan sa isang spreadsheet upang mabalangkas ang data.

Narito ang unang ilang mga linya ng isang file ng log.

// pfodApp V3.0.360, lokal na oras, UTC, mS bawat araw, pfod bluefruit52 kasalukuyang oras (mS), pfod bluefruit52 kasalukuyang oras, // na konektado sa, 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,,

Sa itaas maaari mong makita ang 'lokal' at oras ng UTC na ang pfodApp ay kumonekta sa Feather52 at ang kasalukuyang oras sa mS na iniulat ng Feather52 sa pamamagitan ng tugon na {@..}. Ang huling haligi ay blangko, dahil walang RTC o GPS at sa gayon walang kasalukuyang oras sa oras na yyyy / MM / dd ang naiulat ng Feather52.

Upang mailagay ang data laban sa lumipas na oras, ibawas ang kasalukuyang oras (mS) mula sa millisecond time stamp at pagkatapos ay hatiin ng mS bawat araw na halaga. Narito ang spreadsheet na may idinagdag na pormula at ang resulta ay nakabalangkas. Ang spreadsheet, sa ibaba, (pfod_bluefruit52.xls) ay isang OpenOffice spreadsheet na nai-save sa format na Excel.

Sa OpenOffice, ang balangkas ay isang nakakalat na balangkas at ang x-axis ng balangkas ay na-format sa HH: MM: SS Tandaan: ang mga format ng petsa / oras ng spreadsheet ay HINDI kapareho ng mga format ng plot na ginamit ng pfodApp. Halimbawa sa pfodApp, ang MM ay buwan at ang mm ay minuto.

Upang magplano laban sa petsa at oras, kailangan mo lamang idagdag ang oras ng koneksyon sa oras ng spreadsheet at muling gawin. (pfod_bluefruit52_date.xls)

Tandaan: Ang lokal na oras at UTC ay na-import bilang teksto sa aking spreadsheet kaya kailangan kong alisin ang nangungunang 'bago gamitin ang mga ito sa isang pormula.

Hakbang 8: Paano Maiiwasan ang 49.7day Millis () Limitahan at Bakit Hindi Dapat

Tulad ng nabanggit sa itaas sa Paano naglalagay ng pfodApp Petsa / Oras mula sa millis ()?, Kung mananatili kang patuloy na konektado nang higit pang 49.7 araw ang millisecond timestamp ay ibabalot pabalik sa zero. Ang ilang mga linya ng code ay maaaring maiwasan ito ngunit hindi ito inirerekumenda.

Una kung paano maiiwasan ang balot. Magdagdag ng isa pang hindi naka-sign na variable ng int upang subaybayan ang bilang ng beses na nakabalot ang mga timestamp at na-print ang pinagsamang resulta sa HEX.

uint_t mSwrapCount = 0; uint32_t lastTimeStamp = 0;

… Plot_1_var = analogRead (A0); // read input to plot // plot_2_var plot Hidden kaya walang itinalagang data dito // plot_3_var plot Nakatago kaya walang data na nakatalaga dito // magpadala ng data ng plot sa format ng CSV uint32_t timeStamp = millis () - plot_mSOffset; kung (timeStamp <lastTimeStamp) {// timeStamp na nakabalot pabalik sa 0 mSwrapCount ++; // add one to count} lastTimeStamp = timeStamp; parser.print ("0x"); parser.print (msWrapCount, HEX); parser.print (timeStamp, HEX); // oras sa milliseconds sa HEX ….

Kapag ibinabalik ang {@.. tugon limasin din ang mSwrapCount.

// hawakan {@} hiling} pa kung ('@' == cmd) {// pfodApp humiling ng 'kasalukuyang' oras plot_mSOffset = millis (); // capture current millis as offset rawdata timestamp mSwrapCount = 0; // malinaw na bilang ng pambalot. parser.print (F ("{@` 0} ")); // ibalik ang "0 bilang 'kasalukuyang' hilaw na milliseconds ng data

Ibibigay na ngayon ng mga timestamp ang 'tamang' halaga para sa susunod na 40.7day * 65536 ~ = 7308 taon.

Awtomatikong i-convert ng pfodApp ang hex timestamp para sa paglalagay at i-log ang mga ito nang eksakto tulad ng natanggap, ibig sabihin sa hex. Sa spreadsheet (OpenOffice) ginagamit mo ang formula na ito upang mai-convert ang hex string, sa A2, sa mS (kung saan ang A1 ay walang laman na cell) = HEX2DEC (REPLACE (A2; 1; 2; A1))

Bakit ayaw mong gawin ito

Tulad ng ipinakita sa itaas, madaling pahabain ang mga timstamp ng mS sa mas mahaba sa 50 araw. Subalit malamang na hindi mo nais na gawin iyon dahil sila ay nagiging lalong wasto. Ang isang karaniwang 16Mhz na kristal na ginamit upang likhain ang millis () na mga resulta sa micro ay may kawastuhan na ~ 50ppm (mga bahagi bawat milyon). Nangangahulugan ito na pagkatapos ng 49.7 araw ang millisecond timestamp ay maaaring lumabas ng 3 ½ mins at hindi pinapansin ang epekto ng temperatura sa kawastuhan ng kristal.

Sa mga maikling panahon ng koneksyon, ang kawastuhan na ito ay hindi isang problema dahil ang tugon ng {@.. muling pagsasabay ng millisecond timestamp sa petsa / oras ng mobile sa bawat muling koneksyon. Gayunpaman kung nais mong manatiling konektado sa mahabang panahon (araw) at patuloy na pag-log ng data, dapat mong gamitin ang isang bagay na mas tumpak kaysa sa built-in na millis (), tulad ng isang RTC o GPS module.

Hakbang 9: Paggamit ng isang RTC (Real Time Clock)

Mayroong isang bilang ng mga module ng RTC na magagamit, ang isa sa mga mas tumpak ay ang DS3231 hal. Module ng DSaf31 ng Adafruit. Ang nakasaad na kawastuhan ay +/- 2ppm higit sa 0 hanggang 40C. ibig sabihin ~ +/- 5 sec / buwan.

Kung nais mong magbalangkas ng data na may mga timestamp ng petsa / oras, hal. 2019/04/19 20: 4: 34, kung gayon kailangan mong baguhin ang {@ tugon upang maibalik ang kasalukuyang petsa / oras, hal. {@ `0 ~ 2019/4/19 3: 33: 5}. Narito ang ilang mga pagbabago sa sample ng code upang mailapat sa pfodDesigner na nabuong sketch para sa paggamit ng isang module ng RTC, sa pag-aakalang gumagamit ka ng RTClib library at naidagdag ang code na pinasimulan ang module ng RTC.

// hawakan {@} hiling} pa kung ('@' == cmd) {// pfodApp humiling ng 'kasalukuyang' oras plot_mSOffset = millis (); // capture current millis as offset rawdata timestamp parser.print (F ("{@` 0 "}); // return` 0 as 'current' raw data milliseconds parser.print ('~'); // start string of date / time DateTime now = rtc.now () sendDateTime (& now); // send yyyy / M / d / H: m: s to parser.print, pass address & as arg. parser.print ('}'); // pagtatapos ng {@ tugon hal {@ `0 ~ 2019/4/19 3: 33: 5}….

// send time date to parser printvoid sendDateTime (DateTime * dt) {parser.print (dt-> year (), DEC); parser.print ('/'); parser.print (dt-> buwan (), DEC); parser.print ('/'); parser.print (dt-> day (), DEC); parser.print ("); parser.print (dt-> hour (), DEC); parser.print (':'); parser.print (dt-> minuto (), DEC); parser.print (':'); parser.print (dt-> pangalawa (), DEC); }

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // restart plot data timer, nang walang drift // magtalaga ng mga halaga sa mga variable ng plot mula sa iyong mga variable ng loop o basahin ang mga input ng ADC na plot_1_var = analogRead (A0); // read input to plot // plot_2_var plot Hidden kaya walang data na nakatalaga dito // plot_3_var plot Nakatago kaya walang data na nakatalaga dito // magpadala ng data ng plot sa format ng CSV DateTime ngayon = rtc.now (); sendDateTime (& ngayon); // send yyyy / M / d / H: m: s sa parser.print, ipasa ang address at bilang arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // Ang Plot 2 ay nakatago. Walang naipadala na data. parser.print (','); // Ang Plot 3 ay nakatago. Walang naipadala na data. parser.println (); // pagtatapos ng tala ng data ng CSV}}

Ang ~ 2019/4/19 3: 33: 5 na bahagi ng {@ tugon ay nagpapapaalam sa pfodApp kung ano ang palagay ng pfodDevice ay ang kasalukuyang petsa at oras. Ang iyong sketch ay maaaring magpadala ng data gamit ang mga timestamp ng yMd Hms at pfodApp ay ilalagay ang mga ito alinman sa lumipas na oras mula sa oras ng koneksyon O bilang petsa at oras, depende sa format ng X-axis na tinukoy mo.

Kapag nagpaplano laban sa petsa at oras, ang gawain ng pfodApp plot ay naitama para sa anumang 'drift' sa RTC sa pamamagitan ng paghahambing ng naiulat na kasalukuyang oras ng pfodDevice laban sa kasalukuyang oras ng mobile. Hinahawakan din ng pagwawasto na ito ang RTC na itinakda sa isang iba't ibang timezone mula sa lokal na timezone ng iyong mobile. millis () timestamp ay patuloy na gumagana tulad ng sa Paggamit ng Arduino millisecond timestamp, Hakbang 5 sa itaas.

Narito ang isang halimbawa ng spreadsheet ng temperatura ng kuwarto sa loob ng 8 araw na panahon, Office_Temp.xls Nang na-import ang file ng log ang unang haligi ay minarkahan bilang YMD upang mai-convert ang teksto sa isang petsa / oras. Kailangan mo pa ring alisin ang nangungunang 'form sa lokal na oras, mga kasalukuyang entry ng oras ng UTC at Office Temp upang bigyang kahulugan ng spreadsheet ang mga ito bilang mga petsa at oras.

Upang makuha ang parehong balangkas na ipinapakita ng pfodApp, kailangan mong kalkulahin ang "Naitama na Petsa / Oras". Sa kasong ito ang oras ng RTC ay 2 seg sa likod ng lokal na oras ng mobile, kaya sa bawat RTC timestamp ay idinagdag (lokal na oras - Opisina Temp kasalukuyang oras) upang makuha ang totoong lokal na oras.

Para sa mga lumipas na plots ng oras, lumikha ng isang bagong haligi na naglalaman ng (petsa / oras na timstamp - ang oras ng kasalukuyang Oras ng Opisina) at gamitin iyon bilang X-axis sa tsart (Office_TempElapsed.xls) Sa totoo lang sa kasong ito, gumagawa ang pfodApp ng mas magagandang lumipas na mga tsart ng oras sa mga araw na oras: min: seg.

Hakbang 10: Paggamit ng isang Modyul ng GPS

Ang paggamit ng isang module ng GPS ay katulad ng paggamit ng isang module ng RTC, maliban na ang mga module ng GPS ay may magagamit na milliseconds, taon na nagsisimula sa 2000 at ang oras ay nawawala ang mga leap ng UTC segundo (tingnan ang https://tycho.usno.navy.mil/leapsec.html) Ang petsa at oras ng GPS ay kasalukuyang 18 secs nang mas maaga sa UTC, tulad ng sa Enero 2018.

Ang Adafruit GPS library para sa Adafruit Ultimate GPS, hindi katulad ng RTClib, ay hindi idaragdag ang 2000 taong offset sa mga taon ng GPS, kaya't kailangang maidagdag kapag ipinadala mo ang petsa at timestamp ng oras. Kahit na ang GPS library ay nagbibigay ng mga millisecond na may napakahusay na katumpakan ng pangmatagalang, hindi masyadong tumpak ang mga ito. Ang mga pag-update ng oras ng GPS ay isang beses lamang sa bawat 100mS at pagkatapos ay mayroong isang labis na pagkaantala sa pagtanggap ng serial data sa isang mabagal na 9600 baud at isa pang pagkaantala sa pag-parse nito. Ang lahat ng ito ay idaragdag sa millisecond na hindi tumpak kapag binabasa ang oras ng pagbabasa ng data.

Narito ang ilang mga pagbabago sa sample ng code upang mailapat sa pfodDesigner na nabuong sketch para sa paggamit ng isang module ng GPS, sa pag-aakalang gumagamit ka ng library ng Adafruit na GPS at naidagdag ang code upang matanggap at ma-parse ang mga mensahe sa isang bagay na GPS.

// hawakan {@} hiling} pa kung ('@' == cmd) {// pfodApp humiling ng 'kasalukuyang' oras plot_mSOffset = millis (); // capture current millis as offset rawdata timestamp parser.print (F ("{@` 0 "}); // return` 0 as 'current' raw data milliseconds parser.print ('~'); // start string of date / time sendDateTime (& GPS); // send yyyy / M / d / H: m: s to parser.print, pass address & as arg. parser.print ('}'); // end of {@ response eg {@ `0 ~ 2019/4/19 3: 33: 5}….

// send time date to parser printvoid sendDateTime (Adafruit_GPS * gps) {parser.print (F ("20"); // 20.. year parser.print (gps-> year, DEC); parser.print ('/ '); parser.print (gps-> month, DEC); parser.print (' / '); parser.print (gps-> day, DEC); parser.print (' '); parser.print (gps- > oras, DEC); parser.print (':'); parser.print (gps-> minuto, DEC); parser.print (':'); parser.print (gps-> pangalawa, DEC); // parser.print ('.'); kung nagpapadala ng millisecond // kung nais mong magpadala ng mS kailangan mong i-pad ang halagang gps-> milliseconds na may nangungunang mga zero // ie 3 ay kailangang ma-padded sa 003}

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // restart plot data timer, nang walang drift // magtalaga ng mga halaga sa mga variable ng plot mula sa iyong mga variable ng loop o basahin ang mga input ng ADC na plot_1_var = analogRead (A0); // read input to plot // plot_2_var plot Hidden kaya walang data na nakatalaga dito // plot_3_var plot Nakatago kaya walang data na nakatalaga dito // magpadala ng data ng plot sa format na CSV sendDateTime (& GPS); // send yyyy / M / d / H: m: s sa parser.print, ipasa ang address at bilang arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // Ang Plot 2 ay nakatago. Walang naipadala na data. parser.print (','); // Ang Plot 3 ay nakatago. Walang naipadala na data. parser.println (); // pagtatapos ng tala ng data ng CSV}}

Kapag nagpaplano laban sa petsa at oras, awtomatikong nagwawasto ang pfodApp para sa mga lumundag na segundo. Tulad ng sa Jan 2018, ang oras ng GPS ay 18 sec maaga sa UTC. Inaayos ito ng pfodApp sa pamamagitan ng paghahambing ng petsa / oras na ibinalik ng GPS sa koneksyon, sa pamamagitan ng {@ tugon, laban sa petsa at oras ng UTC ng mobile. Ang paglikha ng mga plots sa isang spreadsheet mula sa pfodApp log file ay kapareho ng para sa mga module ng RTC, sa itaas. Ang pagdaragdag ng (lokal na oras - Office Temp kasalukuyang oras) sa mga timestamp ng GPS ay naitama para sa mga lumundag na segundo.

millis () timestamp ay patuloy na gumagana tulad ng sa Paggamit ng Arduino millisecond timestamp, Hakbang 5 sa itaas.

Hakbang 11: Konklusyon

Ang paggamit ng pfodApp sa iyo ng Android mobile ay nagbibigay-daan sa iyong magbalangkas ng data laban sa petsa at oras o lumipas na oras, gamit lamang ang millis () function ng Arduino. Gamit ang file ng log ng pfodApp maaari mong muling gawin ang mga plot ng petsa / oras na ito sa isang spreadsheet. Kung ang iyong proyekto ng Arduino ay may module ng RTC, maaari kang mag-log at mag-plot ng petsa at ang timestamp ng oras ng RTC, awtomatikong pagwawasto para sa 'drift' ng RTC. Kung ikaw ang proyekto ng Arduino ay may isang module ng GPS maaari kang mag-log at balangkas ng lubos na tumpak na mga timestamp at awtomatikong itatama ng pfodApp ang nawawalang mga segundo ng paglukso ng GPS.

Sa lahat ng kaso ang hilaw na data mula sa iyong proyekto ng Arduino ay naka-log eksakto tulad ng natanggap, hindi naitama. Gayunpaman ang file ng log ng pfodApp ay may kasamang labis na data upang payagan kang muling gumawa ng mga pagwawasto na ito sa isang spreadsheet mula sa na-download na file ng log.

Walang kinakailangang pag-coding sa Android. Ang mga format ng balangkas ay tinukoy ng lahat ng maliliit na mga string ng teksto sa iyong Arduino sketch. Ang libreng pfodDesigner ay bumubuo ng kumpletong Arduino data logging at plotting sketches para sa isang iba't ibang mga Arduino board na kumokonekta sa pamamagitan ng WiFi, Classic Bluetooth, BLE at SMS