Arduino თარიღი/დრო შეთქმულება/ჩაწერა Millis () და PfodApp გამოყენებით: 11 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:17

არ არის საჭირო Arduino ან Android პროგრამირება. ასევე მხარდაჭერილია RTC და GPS მოდულები. დროის სარტყლების ავტომატური კორექცია, RTC დრიფტი და GPS დაკარგული ნახტომი წამი

შესავალი

ეს სახელმძღვანელო გიჩვენებთ თუ როგორ გამოიყენოთ თქვენი Arduino millis () დროის ნიშნულები თქვენი Android მობილურის თარიღისა და დროის მონაცემების გამოსახვისთვის pfodApp– ის გამოყენებით.

არ არის საჭირო Arduino ან Android პროგრამირება. pfodApp ასევე აწერს საკმარის მონაცემებს, რათა მოგვიანებით შეძლოთ თარიღის/დროის ნაკვეთების გამრავლება ცხრილში.

არ არის საჭირო RTC ან GPS მოდული, თუმცა თუ თქვენს Arduino პროექტს აქვს RTC (რეალური დროის საათი) ან GPS მოდული, მათი გამოყენებაც შესაძლებელია. ამ შემთხვევებში pfodApp ნაკვეთები ავტომატურად გამოსწორდება დროის ზონაში, RTC დრიფტში და GPS დაკარგული ნახტომი წამებში. ამ შესწორებებისათვის სპეციალური Arduino კოდი არ არის საჭირო. როგორც ყოველთვის pfodApp– ით, მიღებული მონაცემები იწერება ზუსტად ისე, როგორც არის, არ არის შესწორებული, თუმცა ჟურნალის ფაილი ასევე შეიცავს საკმარის ინფორმაციას, რომელიც საშუალებას მოგცემთ თავად გამოიყენოთ ეს შესწორებები, როდესაც ჩამოტვირთავთ ჟურნალებს თქვენს კომპიუტერში. ქვემოთ იხილეთ ამ შემდგომი დამუშავების მაგალითები.

მხარს უჭერს დროისა და თარიღის X ღერძის ფორმატირებას, ყველა მათგანი სრულად კონტროლდება მოკლე ტექსტური სტრიქონებით თქვენს არდუინოს ესკიზში. Android პროგრამირება არ არის საჭირო.

pfodApp დაუკავშირდება WiFi, Bluetooth Classic, BLE და SMS საშუალებით. უფასო pfodDesigner ქმნის Arduino– ს სრულყოფილ ჩანახატებს თარიღის/დროის შეთქმულებისთვის/შესასვლელად, რათა დააკავშიროთ სხვადასხვა დაფები. არდუინოს პროგრამირება არ არის საჭირო.

ეს ინსტრუქცია გამოიყენებს Adafruit Feather52 როგორც Arduino დაფის მაგალითს, რომელიც აკავშირებს BLE საშუალებით.

ეს ინსტრუქცია მოიცავს სამ შემთხვევას:- 1) თქვენს მიკროპროცესორულ პროექტს აქვს მხოლოდ მილიწამიანი დროის ნიშნები- მილი (2) თქვენს მიკროპროცესორულ პროექტს აქვს რეალურ დროში საათი (RTC)- pfodApp ავტომატურად ასწორებს დრიფტს. 3) თქვენს მიკროპროცესორულ პროექტს აქვს GPS მოდული - pfodApp ავტომატურად ასწორებს ნახტომის წამებს, როდესაც ისინი ხდება (ამჟამად 18 წამი 2018 წლის მონაცემებით).

ნაბიჯი 1: Arduino Millisecond Timestamps, Millis ()

მილიწამების გამოყენების თარიღისა და დროის ორი ნაწილია. ერთი არის მონაცემების შედგენა გასული დროის ან თარიღის/დროის წინააღმდეგ და მეორე ნაწილი არის თარიღისა და დროის ხელახლა შექმნა რეგისტრირებული ნედლეულის მონაცემების მილიწამიანი დროის ნიშნებიდან. pfodApp არ ცვლის pfodDevice– დან მიღებულ ნედლეულ მონაცემებს (Arduino მიკრო). ის უბრალოდ აწერს ზუსტად მიღებულ ბაიტებს.

პირველ რიგში გამოიყენეთ უფასო pfodDesigner თქვენი Arduino სკეტჩის გენერირებისთვის, რომელიც გამოგიგზავნით მილიწამებსა და მონაცემთა გაზომვებს pfodApp– ში შეთქმულების/ჟურნალისთვის. ეს მაგალითი ქმნის მენიუს Adafruit Feather 52 BLE დაფისთვის, სადაც წერია A0. სამეურვეო პროგრამა Adafruit Feather nRF52 LE - პერსონალური კონტროლი pfodApp– ით გადის pfodDesigner– ის საფეხურზე, რათა შექმნას მენიუ ბუმბულისთვის nRF52, რომელიც მოიცავს Chart ღილაკს, ასე რომ შეამოწმეთ იგი დამატებითი დეტალებისთვის. ამ სამეურვეოში ჩვენ დავამატებთ მხოლოდ დიაგრამის ღილაკს და გამოვიყენებთ X- ღერძის ფორმატის ახალ ვარიანტებს, რათა დავხატოთ A0 კითხვები გასული დროის და თარიღის/დროის წინააღმდეგ.

ამ გაკვეთილის პირველი ნაწილი გაივლის უფასო pfodDesigner– ს, რათა შექმნათ თარიღის/დროის გრაფიკის ნიმუში თქვენს Android მობილურზე. როდესაც კმაყოფილი ხართ ჩვენებით, შეგიძლიათ შექმნათ Arduino ესკიზი, რომელიც გაიმეორებს მას, როდესაც დაუკავშირდებით pfodApp– ს. არ არის Android პროგრამირება საჭირო და ვინაიდან pfodDesigner ქმნის Arduino სკეტჩებს Arduino დაფების ფართო სპექტრისთვის, არც Arduino პროგრამირებაა საჭირო.

ნაბიჯი 2: დიაგრამის დამატება მენიუში

ჩამოტვირთეთ pfodDesigner აპი Google Play– დან, გახსენით იგი და დააწკაპუნეთ „ახალი მენიუს დაწყება“

დააწკაპუნეთ „სამიზნე სერიალზე“და შემდეგ „Bluetooth დაბალი ენერგიის“ღილაკზე, რომ ნახოთ 11 BLE დაფის სია (გადაახვიეთ ქვემოთ სხვა არჩევანის სანახავად). აირჩიეთ Adafruit Bluefruit Feather52.

დაუბრუნდით რედაქტირების მენიუს და დააწკაპუნეთ „რედაქტირების მოთხოვნაზე“და დააყენეთ შესაბამისი მოთხოვნა ამ მენიუსთვის, მაგ. "ბუმბული 52" და ტექსტი თამამი და ზომა +7. ფონის ფერი დარჩა როგორც "ნაგულისხმევი" თეთრი

დაბრუნდით და დააწკაპუნეთ „მენიუს ერთეულის დამატებაზე“, გადაახვიეთ ქვემოთ და აირჩიეთ „დიაგრამის ღილაკი“, რომელიც ხსნის დიაგრამის ღილაკის რედაქტირების ეკრანს. თქვენ შეგიძლიათ ნებისმიერი ცვლილება შეიტანოთ ღილაკის გარეგნობაში აქ. ამ შემთხვევაში ღილაკის ტექსტი შეიცვალა "თარიღი/დრო ნაკვეთი A0" და სხვა ნაგულისხმევი დარჩა როგორც არის.

ეს გაძლევთ მენიუს ღილაკს, რომელიც გახსნის დიაგრამის ეკრანს.

ნაბიჯი 3: ნაკვეთის წყაროს და ველების რედაქტირება

დააწკაპუნეთ ღილაკზე „თარიღი/დრო ნაკვეთი A0“, რომ გახსნათ ნაკვეთების რედაქტირება, სადაც შეგიძლიათ გქონდეთ წვდომა დიაგრამის ეტიკეტზე, X ღერძის ფორმატზე, ნაკვეთის მონაცემთა ინტერვალზე და (ქვემოთ გადაადგილებით) თავად ნაკვეთის პარამეტრებზე. შეცვალეთ დიაგრამის ეტიკეტი რაიმე შესაფერისი, მაგ. "A0 ვოლტი".

გადაახვიეთ ქვემოთ და ნაკვეთების 2 და 3 გახსენით ნაკვეთის რედაქტირება და დააწკაპუნეთ ნაკვეთის დამალვას, რომ ამოიღოთ ისინი დიაგრამის ჩვენებიდან.

შემდეგ დააწკაპუნეთ „ნაკვეთის 1 -ის რედაქტირებაზე“და დააყენეთ ნაკვეთის ეტიკეტი (მაგ. A0), yAxis ერთეულები (მაგ. ვოლტი), აჩვენეთ მაქსიმუმი 3.6 ვ და დაუკავშირდით I/O პინ A0- ს.

გადაახვიეთ უკან და დააწკაპუნეთ „დიაგრამის გადახედვაზე“უახლესი 0 მონაცემის ნიმუშის წერტილამდე, 1 წამიანი ინტერვალებით, რომელიც გამოითვლება წუთებში გასული დროის მიხედვით: წმ.

ყველა გასული დროისათვის ნაკვეთები წამყვანი ნულოვანი ერთეულები არ არის ნაჩვენები ასე რომ ამ ნაკვეთში მხოლოდ იმ დროს> 1 წთ არის ნაჩვენები წამყვანი წუთები.

ნაბიჯი 4: თარიღის/დროის ფორმატის არჩევა

გასული დროის ნაკვეთებისთვის წამყვანი ერთეული მხოლოდ იზრდება დროთა განმავლობაში. ამის მაგალითის სანახავად დაბრუნდით "ნაკვეთების რედაქტირების" ეკრანზე და გაზარდეთ ნაკვეთის მონაცემების ინტერვალი 15 წუთამდე (ამ ეკრანის ბოლოში)

შემდეგ დააწკაპუნეთ დიაგრამის გადახედვაზე, რომ აჩვენოთ იგივე ნიმუშის მონაცემები, მაგრამ ახლა ნიმუშებს შორის 15 წუთის ინტერვალით. როგორც ხედავთ წუთების ნაწილი mm: ss სულ უფრო იზრდება.

ახლა დაბრუნდით და დააწკაპუნეთ X ღერძის ღილაკზე, რათა ნახოთ X- ღერძის ყველა შესაძლო მონაცემის/დროის ფორმატის მცირე არჩევანი (გადადით ქვემოთ ქვემოთ)

ზემოთ მოცემულია დიაგრამის წინასწარი გადახედვის შერჩევა X- ღერძის სხვადასხვა ფორმატის გამოყენებით.

აქ ნაჩვენები თარიღის/დროის ნაკვეთები არის "ადგილობრივ" დროის ზონაში. ასევე არსებობს ფორმატის ვარიანტები UTC– ში თარიღის/დროის გამოსახვისთვის. თარიღის/დროის ფორმატის შესაძლო ვარიანტების სრული ნაკრებისთვის იხილეთ pfodSpecification.pfd.

ნაბიჯი 5: შექმენით და გამოსცადეთ Arduino Sketch

მას შემდეგ რაც კმაყოფილი იქნებით თქვენი დიაგრამის ფორმატით და მონაცემების ინტერვალით, შეგიძლიათ გადადით "Editing Menu_1" ეკრანზე და გადაახვიეთ ქვემოთ და "გენერირება კოდი" თქვენთვის არჩეული სამიზნე დაფისათვის. აქ არის ნიმუშის ესკიზი Adafruit Feather52– ისთვის, 1sec მონაცემთა ინტერვალით და მმ: ss გასული დროის ფორმატით, pfodFeather52_timeplot.ino

ზემოთ არის ნაკვეთი A02 ბუმბულიდან 52

შეცვალეთ ფორმატი კვირის დღეებში სთ: წთ: წმ (~ E HH: მმ: სს) და კოდის ხელახლა გენერირება (pfodFeather52_dateplot.ino) იძლევა ნაკვეთს, როგორც მეორე ზემოთ.

თქვენ შეგიძლიათ შეცვალოთ X ღერძის ფორმატი პირდაპირ თქვენს არდუინოს ესკიზში, როგორც ეს აღწერილია შემდეგში.

ნაბიჯი 6: როგორ აფორმებს PfodApp თარიღი/დრო მილიისიდან ()?

როდესაც pfodApp უკავშირდება, მას ახსოვს თავისი „ადგილობრივი“და UTC დრო და ითხოვს pfodDevice– ის (Arduino დაფის) მიმდინარე ნაკვეთის მონაცემების დროის ნიშნულს. ამ ინფორმაციის გამოყენებით pfodApp- ს შეუძლია ჩაწეროს მილიწამიანი დროის ნიშნები, როგორც გასული დრო, ანუ მილიწამების გარდაქმნა საათებად წთ და წთ და ა. შ.

Arduino– ს გენერირებულ ესკიზში (მაგ. PfodFeather52_dateplot.ino), არის კოდის სამი პატარა ბიტი, რომელიც ამუშავებს Arduino– ს ნაკვეთებს.

მარყუჟის () კოდის განყოფილება, რომელიც ამუშავებს pfodApp- ის {@} მიმდინარე დროის მოთხოვნას

// გაუმკლავდეს {@} მოთხოვნას} სხვაგვარად თუ ('@' == cmd) {// pfodApp მოითხოვა 'მიმდინარე' დრო plot_mSOffset = millis (); // ჩაწერეთ მიმდინარე მილი, როგორც ოფსეტური rawdata დროის ნიშნები parser.print (F ("{@` 0} ")); // დააბრუნე `0 'როგორც' მიმდინარე 'ნედლეული მონაცემები მილიწამებში

თქვენ შეგიძლიათ უბრალოდ დააბრუნოთ მილიესის () ამჟამინდელი მნიშვნელობა, მაგრამ მილილი () ბრუნდება 0 – ით ყოველ 49.7 დღეში, რაც ნაკვეთს უკან გადახტომას გახდის. ამის ნაცვლად, კოდს ახსოვს ამჟამინდელი millis () მნიშვნელობა, როდესაც {@} მოთხოვნა გაკეთდა და აბრუნებს {@`0}, ანუ მიმდინარე მილიწამიანი დროის ნიშნულს ნულს. შემდეგ ნედლეულის მონაცემების გაგზავნისას ესკიზი იყენებს

plot_1_var = analogRead (A0); // წაიკითხეთ შეყვანა ნაკვეთზე // plot_2_var ნაკვეთი დამალულია ისე, რომ აქ მონაცემები არ არის მინიჭებული // plot_3_var ნაკვეთი დამალულია ისე რომ მონაცემები არ არის მინიჭებული // გაგზავნეთ ნაკვეთის მონაცემები CSV ფორმატში parser.print (millis ()-plot_mSOffset); // დრო მილიწამებში …

ისე, რომ მონაცემებთან გაგზავნილი მილიწამიანი დროის ნიშნული იწყება 0 -დან და იზრდება 49,7 დღემდე. თუ 49.7 დღის განმავლობაში მუდმივად იქნებით დაკავშირებული, მაშინ ნახავთ, რომ ნაკვეთი უკან იხტება 50 ფუნტით. გათიშვა და ხელახლა დაკავშირება ყოველ 49.7 დღეში ერთხელ თავს არიდებს ამას.

თარიღის/დროის ნაკვეთის მესამე ნაწილი არის ნაკვეთის შეტყობინება.

} else if ('A' == cmd) {// მომხმარებელი დაჭერილი - 'თარიღი/დრო ნაკვეთი A0' // მენიუს მთავარ მენიუში // // დაბრუნების შედგენის შეტყობინება. parser.print (F ("{= A0 ვოლტი ~ E HH: მმ: წწ | თარიღი | A0 ~~~ ვოლტი ||}"));

როდესაც მომხმარებელი დააჭერს ღილაკს „თარიღი/დრო ნაკვეთი A0“, pfodApp აგზავნის {A} cmd– ს pfodDevice– ზე და pfodDevice პასუხობს ნაკვეთის შეტყობინებას, {=… {= A0 ვოლტი ~ E HH: მმ: სს | თარიღი | A0 ~~~ ვოლტი ||} რომელიც შეიცავს X ღერძის ფორმატს E HH: მმ: წმ

Java SimpleDateFormat ფორმატები აქ მისაღებია. pfodApp მონაცემთა აღრიცხვა და შედგენა და pfodSpecification.pdf უფრო დეტალურია ნაკვეთის შეტყობინებაზე.

ნაბიჯი 7: თარიღის/დროის ნაკვეთების გამრავლება თქვენს კომპიუტერში

ნაგულისხმევად, pfodApp აფიქსირებს ყველა შემომავალ ნედლეულს თქვენს მობილურში შესულ ფაილში, თუ თქვენ არ გამორთეთ კავშირის რედაქტირების ეკრანზე, იხილეთ pfodAppForAndroidGettingStarted.pdf

PfodApp- ის რედაქტირებისას გამოჩნდება მოკლე შეტყობინება ჟურნალის ფაილის ადგილმდებარეობისა და სახელის შესახებ, მაგ. /pfodAppRawData/pfod_bluefruit52.txt ეს ფაილი არის CSV ფორმატში, გამოყოფილია მძიმით და თქვენს კომპიუტერში გადატანის შემდეგ (იხილეთ pfodAppForAndroidGettingStarted.pdf გადაცემის ვარიანტებისთვის), შეგიძლიათ გახსნათ იგი ცხრილში მონაცემების შედგენისთვის.

აქ არის ჟურნალის ფაილის პირველი რამდენიმე სტრიქონი.

// pfodApp V3.0.360, ადგილობრივი დრო, UTC, mS დღეში, pfod bluefruit52 მიმდინარე დრო (mS), pfod bluefruit52 მიმდინარე დრო, // დაკავშირებულია, 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,, ზემოთ თქვენ შეგიძლიათ ნახოთ „ადგილობრივი“და UTC დრო, რომელიც pfodApp– მა დაუკავშირა Feather52– ს და mS– ში მიმდინარე დრო, რომელიც Feather52– მა მოახსენა {@..} პასუხის საშუალებით. ბოლო სვეტი ცარიელია, რადგან არ არსებობს RTC ან GPS და შესაბამისად არცერთი დრო yyyy/MM/dd დროს არ იყო მოხსენებული Feather52.

მონაცემების გასასვლელად, გამოაკელით მიმდინარე დროს (mS) მილიწამიანი დროის შტამპიდან და შემდეგ გაყავით mS- ზე დღეში. აქ არის ცხრილი, რომელსაც აქვს დამატებული ფორმულა და შედეგი ნაჩვენებია. ქვემოთ მოცემული ცხრილი (pfod_bluefruit52.xls) არის OpenOffice ცხრილი, შენახული Excel ფორმატში.

OpenOffice– ში ნაკვეთი არის გაფანტული ნაკვეთი და ნაკვეთის x ღერძი დაფორმატებულია HH– ში: MM: SS შენიშვნა: ცხრილების თარიღის/დროის ფორმატები არ არის იგივე, რაც pfodApp– ის მიერ გამოყენებული ნაკვეთის ფორმატები. მაგალითად pfodApp– ში, MM არის თვეები და მმ არის წუთები.

თარიღისა და დროის საწინააღმდეგოდ შეთქმულების მიზნით, თქვენ უბრალოდ უნდა დაამატოთ კავშირის დრო ცხრილის დროს და გაიმეოროთ. (pfod_bluefruit52_date.xls)

შენიშვნა: ადგილობრივი დრო და UTC იმპორტირებული იქნა როგორც ტექსტი ჩემს ცხრილში, ასე რომ მე მჭირდებოდა წამლის ამოღება ფორმულაში გამოყენებამდე.

ნაბიჯი 8: როგორ ავიცილოთ თავიდან 49.7 დღიანი მილი () ლიმიტი და რატომ არ უნდა

როგორც ზემოთ აღვნიშნეთ, როგორ ასახავს pfodApp თარიღს/დროს მილიდან () ?, თუ 49,7 დღეზე მეტხანს განუწყვეტლივ დაკავშირებულები დარჩებით, მილიწამიანი დროის ნიშნულები ნულის ტოლფასი გახდება. რამოდენიმე ხაზის კოდს შეუძლია ამის თავიდან აცილება, მაგრამ არ არის რეკომენდებული.

პირველი როგორ ავიცილოთ თავიდან შემოხვევა. დაამატეთ კიდევ ერთი ხელმოუწერელი შიდა ცვლადი, რათა თვალყური ადევნოთ რამდენჯერ შეასრულოს დროის ნიშნულები და დაბეჭდოთ კომბინირებული შედეგი HEX– ში.

uint_t mSwrapCount = 0; uint32_t lastTimeStamp = 0;

… Plot_1_var = analogRead (A0); // წაიკითხეთ შეყვანა ნაკვეთზე // plot_2_var ნაკვეთი დამალულია ისე, რომ აქ მონაცემები არ არის მინიჭებული // plot_3_var ნაკვეთი დამალულია, ასე რომ მონაცემები არ არის მინიჭებული // გაგზავნეთ ნაკვეთის მონაცემები CSV ფორმატში uint32_t timeStamp = millis ()-plot_mSOffset; if (timeStamp <lastTimeStamp) {// timeStamp გახვეული უკან 0 mSwrapCount ++; // დაამატეთ ერთი დათვლა} lastTimeStamp = timeStamp; parser.print ("0x"); parser.print (msWrapCount, HEX); parser.print (timeStamp, HEX); // დრო მილიწამებში HEX– ში….

{@.. პასუხის დაბრუნებისას გაასუფთავეთ mSwrapCount ასევე.

// გაუმკლავდეს {@} მოთხოვნას} სხვაგვარად თუ ('@' == cmd) {// pfodApp მოითხოვა 'მიმდინარე' დრო plot_mSOffset = millis (); // ჩაწერეთ მიმდინარე მილი, როგორც ოფსეტური ნედლეულის დროის ნიშნები mSwrapCount = 0; // შეფუთვის რაოდენობის გასუფთავება. parser.print (F ("{@` 0} ")); // დააბრუნე `0 'როგორც' მიმდინარე 'ნედლეული მონაცემები მილიწამებში

დროის ნიშნულები მომდევნო 40,7 დღის * 65536 ~ = 7308 წლის განმავლობაში მისცემს "სწორ" მნიშვნელობას.

pfodApp ავტომატურად გადააქცევს hex დროის ნიშნებს შედგენისთვის და შეაფასებს მათ ზუსტად ისე, როგორც მიღებულია, ანუ ექვსკუთხედში. ცხრილში (OpenOffice) თქვენ იყენებთ ამ ფორმულას ჰექსაციური სტრიქონის გადასაყვანად, A2– ში, mS– ში (სადაც A1 არის ნებისმიერი ცარიელი უჯრედი) = HEX2DEC (შეცვლა (A2; 1; 2; A1))

რატომ არ გინდა ამის გაკეთება

როგორც ზემოთ იყო ნაჩვენები, ადვილია mS დროის ნიშნულის გახანგრძლივება 50 დღეზე მეტ ხანს. თქვენ ალბათ არ გსურთ ამის გაკეთება, რადგან ისინი სულ უფრო ზუსტი ხდებიან. ტიპიური 16 MHz ბროლი, რომელიც გამოიყენება millis () შედეგების შესაქმნელად მიკროში, აქვს სიზუსტე pp 50ppm (ნაწილები მილიონზე). ეს ნიშნავს, რომ 49.7 დღის შემდეგ მილიწამიანი დროის ნიშნული შეიძლება ამოიწუროს 3 წთ -ით და ეს იგნორირებას უკეთებს ტემპერატურის გავლენას კრისტალების სიზუსტეზე.

კავშირის ხანმოკლე პერიოდის განმავლობაში, ეს სიზუსტე არ წარმოადგენს პრობლემას, რადგან {@.. პასუხი ხელახლა სინქრონიზებს მილიწამიანი დროის ნიშნულს მობილურის თარიღთან/დროზე ყოველ ხელახალ კავშირზე. თუმცა, თუ გსურთ დარჩეთ დაკავშირებული დიდი ხნის განმავლობაში (დღეები) და მონაცემების უწყვეტი შესვლა, მაშინ უნდა გამოიყენოთ რაღაც უფრო ზუსტი ვიდრე ჩაშენებული მილი (), როგორიცაა RTC ან GPS მოდული.

ნაბიჯი 9: RTC- ის გამოყენება (რეალურ დროში საათი)

არსებობს რამოდენიმე RTC მოდული, ერთ -ერთი უფრო ზუსტი არის DS3231 მაგ. ადაფრუტის DS3231 მოდული. გამოცხადებული სიზუსტე არის +/- 2ppm 0-დან 40C- მდე. ანუ ~ +/- 5 წმ/თვეში.

თუ გსურთ მონაცემების შედგენა, რომელსაც აქვს თარიღი/დრო დროის ნიშნულები, მაგ. 2019/04/19 20: 4: 34, მაშინ თქვენ უნდა შეცვალოთ {@ პასუხი მიმდინარე თარიღის/დროის დასაბრუნებლად, მაგ. {@`0 ~ 2019/4/19 3: 33: 5}. აქ არის რამოდენიმე კოდის ცვლილების მაგალითი, რომელიც გამოიყენება pfodDesigner- ის გენერირებულ ესკიზზე RTC მოდულის გამოსაყენებლად, თუ თქვენ იყენებთ RTClib ბიბლიოთეკას და დაამატეთ RTC მოდულის ინიციალიზაციის კოდი.

// გაუმკლავდეს {@} მოთხოვნას} სხვაგვარად თუ ('@' == cmd) {// pfodApp მოითხოვა 'მიმდინარე' დრო plot_mSOffset = millis (); // ჩაწერეთ მიმდინარე მილი, როგორც ოფსეტური rawdata დროის ნიშნები parser.print (F ("{@` 0 "}); // დააბრუნეთ" 0 "როგორც" მიმდინარე "ნედლეული მონაცემები მილიწამებში parser.print (" ~ "); // სტრიქონის დაწყება თარიღი/დრო DateTime ახლა = rtc.now () sendDateTime (& ახლა); // გააგზავნეთ yyyy/M/d/H: m: s parser.print, გაიარეთ მისამართი და როგორც არგ. parser.print ('}'); // {@ პასუხის ბოლოს, მაგალითად {@ `0 ~ 2019/4/19 3: 33: 5}….

// გაგზავნის თარიღის დროს parser printvoid sendDateTime (DateTime* dt) {parser.print (dt-> წელი (), DEC); parser.print ('/'); parser.print (dt-> თვე (), DEC); parser.print ('/'); parser.print (dt-> day (), DEC); parser.print (''); parser.print (dt-> საათი (), DEC); parser.print (':'); parser.print (dt-> წუთი (), DEC); parser.print (':'); parser.print (dt-> მეორე (), DEC); }

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // გადატვირთეთ ნაკვეთის მონაცემების ქრონომეტრი, დრიფტის გარეშე // მიანიჭეთ მნიშვნელობები შეადგინეთ ცვლადები თქვენი მარყუჟის ცვლადებიდან ან წაიკითხეთ ADC შეყვანა plot_1_var = analogRead (A0); // წაიკითხეთ შეყვანა ნაკვეთზე // plot_2_var ნაკვეთი დამალულია ისე, რომ აქ მონაცემები არ არის მინიჭებული // plot_3_var ნაკვეთი დამალულია, ასე რომ მონაცემები არ არის მინიჭებული // გაგზავნეთ ნაკვეთის მონაცემები CSV ფორმატში DateTime now = rtc.now (); sendDateTime (და ახლა); // გააგზავნე წწწ/მ/დ/სთ: მ: ს parser.print– ზე, გაიარე მისამართი და როგორც არგ. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // ნაკვეთი 2 იმალება. მონაცემები არ არის გაგზავნილი. parser.print (','); // ნაკვეთი 3 იმალება. მონაცემები არ არის გაგზავნილი. parser.println (); // CSV მონაცემების ჩანაწერის დასასრული}}

@ 2019/4/19 3: 33: 5 ნაწილი {@ საპასუხოდ საშუალებას აძლევს pfodApp- ს იცოდეს რას ფიქრობს pfodDevice მიმდინარე თარიღი და დრო. თქვენს ესკიზს შეუძლია მონაცემების გაგზავნა yMd Hms დროის ნიშნულებით და pfodApp ასახავს მათ როგორც კავშირის დროდან გასულ დროს, ასევე თარიღსა და დროს, თქვენს მიერ მითითებული X ღერძის ფორმატის მიხედვით.

თარიღისა და დროის საწინააღმდეგოდ შეთქმულებისას, pfodApp ნაკვეთის რუტინა ასწორებს RTC– ში არსებულ ნებისმიერ „დრიფტს“, pfodDevice– ის მოხსენებული მიმდინარე დროის შედარებისას მობილურის მიმდინარე დროს. ეს შესწორება ასევე ამუშავებს RTC- ს თქვენს მობილურის ადგილობრივი დროის ზონისგან განსხვავებულ დროის ზონაში. millis () დროის ნიშნულები განაგრძობენ მუშაობას Arduino– ს მილიწამიანი დროის ნიშნების გამოყენებით, ნაბიჯი 5 ზემოთ.

აქ მოცემულია ოთახის ტემპერატურის მაგალითი 8 დღის განმავლობაში, Office_Temp.xls როდესაც ჟურნალის ფაილი იმპორტირებული იქნა, პირველი სვეტი აღინიშნა YMD ტექსტის თარიღად/დროზე გადასაყვანად. თქვენ კვლავ უნდა წაშალოთ წამყვანი 'ადგილობრივი დროით, UTC და Office Temp მიმდინარე დროის ჩანაწერები, რათა ცხრილმა განიხილოს ისინი როგორც თარიღები და დრო.

იმავე ნაკვეთის მისაღებად, რასაც აჩვენებს pfodApp, თქვენ უნდა გამოთვალოთ "შესწორებული თარიღი/დრო". ამ შემთხვევაში RTC დრო არის 2 წამი ჩამორჩება მობილური ტელეფონის ადგილობრივ დროს, ამიტომ თითოეულ RTC დროის ნიშნულს ემატება (ადგილობრივი დრო - Office Temp მიმდინარე დრო) რეალური ადგილობრივი დროის მისაღებად.

გასული დროის ნაკვეთებისთვის შექმენით ახალი სვეტი, რომელიც შეიცავს (თარიღის/დროის დროის ნიშნულს-Office Time მიმდინარე დროს) და გამოიყენეთ ეს როგორც X ღერძი დიაგრამაში (Office_TempElapsed.xls) სინამდვილეში ამ შემთხვევაში, pfodApp აწარმოებს დროის გასვლის უფრო ლამაზ გრაფიკებს დღეებში სთ: წთ: წმ.

ნაბიჯი 10: GPS მოდულის გამოყენება

GPS მოდულის გამოყენება მსგავსია RTC მოდულის გამოყენებისას, გარდა იმისა, რომ GPS მოდულებს აქვთ მილიწამები, წლები იწყება 2000 წლიდან და დრო აკლია UTC ნახტომი წამს (იხ. Https://tycho.usno.navy.mil/leapsec.html) GPS თარიღი და დრო ამჟამად 18 წამი უსწრებს UTC– ს, 2018 წლის იანვრის მდგომარეობით.

Adafruit GPS ბიბლიოთეკა Adafruit Ultimate GPS– ისთვის, RTClib– ისგან განსხვავებით, არ ამატებს 2000 წლის ანაზღაურებას GPS წლებს, ასე რომ, ის უნდა დაემატოს თარიღისა და დროის გაგზავნისას. ასევე მიუხედავად იმისა, რომ GPS ბიბლიოთეკა აწვდის მილიწამებს, რომლებსაც აქვთ ძალიან კარგი გრძელვადიანი სიზუსტე, ისინი არ არიან ძალიან ზუსტი. GPS დროის განახლება ხდება მხოლოდ 100mS ყოველ ჯერზე და შემდეგ ხდება დამატებითი შეფერხება სერიული მონაცემების მიღებით ნელი 9600 baud და კიდევ ერთი შეფერხება მისი ანალიზისას. ყოველივე ამას ემატება მილიწამში სიზუსტე მონაცემთა წაკითხვის დროის დაბეჭდვისას.

აქ მოცემულია რამოდენიმე კოდის ცვლილება, რომელიც გამოიყენება pfodDesigner– ის მიერ შექმნილ ესკიზზე GPS მოდულის გამოსაყენებლად, თუ თქვენ იყენებთ ადაფრუტის GPS ბიბლიოთეკას და დაამატეთ კოდი შეტყობინებების მისაღებად და გასაანალიზებლად GPS ობიექტში.

// გაუმკლავდეს {@} მოთხოვნას} სხვაგვარად თუ ('@' == cmd) {// pfodApp მოითხოვა 'მიმდინარე' დრო plot_mSOffset = millis (); // ჩაწერეთ მიმდინარე მილი, როგორც ოფსეტური rawdata დროის ნიშნები parser.print (F ("{@` 0 "}); // დააბრუნეთ" 0 "როგორც" მიმდინარე "ნედლეული მონაცემები მილიწამებში parser.print (" ~ "); // სტრიქონის დაწყება თარიღი/დრო გაგზავნის თარიღი {@`0 ~ 2019/4/19 3: 33: 5}….

// გაგზავნის თარიღი დრო parser printvoid sendDateTime (Adafruit_GPS* gps) {parser.print (F ("20"); // 20.. year parser.print (gps-> year, DEC); parser.print ('/ '); parser.print (gps-> თვე, DEC); parser.print ('/'); parser.print (gps-> day, DEC); parser.print (' '); parser.print (gps- > საათი, DEC); parser.print (':'); parser.print (gps-> წუთი, DEC); parser.print (':'); parser.print (gps-> მეორე, DEC); // parser.print ('.'); თუ გაგზავნით მილიწამებს // თუ გსურთ გაგზავნოთ mS თქვენ უნდა შეავსოთ gps-> მილიწამიანი მნიშვნელობა წამყვან ნულებთან // ანუ 3 უნდა იყოს ჩასმული 003}-ზე

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // გადატვირთეთ ნაკვეთის მონაცემების ქრონომეტრი, დრიფტის გარეშე // მიანიჭეთ მნიშვნელობები შეადგინეთ ცვლადები თქვენი მარყუჟის ცვლადებიდან ან წაიკითხეთ ADC შეყვანა plot_1_var = analogRead (A0); // წაიკითხეთ შეყვანა ნაკვეთზე // plot_2_var ნაკვეთი დამალულია ისე, რომ აქ მონაცემები არ არის მინიჭებული // plot_3_var ნაკვეთი დამალულია ისე, რომ აქ მონაცემები არ არის მინიჭებული // გაგზავნეთ ნაკვეთის მონაცემები CSV ფორმატში sendDateTime (& GPS); // გააგზავნე წწწ/მ/დ/სთ: მ: ს parser.print– ზე, გაიარე მისამართი და როგორც არგ. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // ნაკვეთი 2 იმალება. მონაცემები არ არის გაგზავნილი. parser.print (','); // ნაკვეთი 3 იმალება. მონაცემები არ არის გაგზავნილი. parser.println (); // CSV მონაცემების ჩანაწერის დასასრული}}

თარიღისა და დროის წინააღმდეგ შეთქმულებისას, pfodApp ავტომატურად ასწორებს ნახტომი წამებით. 2018 წლის იანვრის მონაცემებით, GPS დრო UTC– ს წინ 18 წამია. pfodApp ამას გამოასწორებს GPS– ით დაბრუნებული თარიღის/დროის შედარებისას, {@ პასუხის საშუალებით, მობილურით UTC თარიღთან და დროსთან. ნაკვეთების შექმნა ცხრილში pfodApp ლოგის ფაილიდან იგივეა, რაც RTC მოდულებისთვის, ზემოთ. GPS დროის ნიშნულებზე (ადგილობრივი დრო - Office Temp მიმდინარე დრო) დამატება ნახტომი წამების გასწორებას უწყობს ხელს.

millis () დროის ნიშნულები განაგრძობენ მუშაობას Arduino– ს მილიწამიანი დროის ნიშნების გამოყენებით, ნაბიჯი 5 ზემოთ.

ნაბიჯი 11: დასკვნა

Android მობილურზე pfodApp- ის გამოყენება საშუალებას მოგცემთ შეადგინოთ მონაცემები თარიღისა და დროის ან გასული დროის მიხედვით, მხოლოდ Arduino- ს millis () ფუნქციის გამოყენებით. PfodApp ჟურნალის ფაილის გამოყენებით შეგიძლიათ ხელახლა შექმნათ ეს თარიღი/დრო ნაკვეთები ცხრილში. თუ თქვენს Arduino პროექტს აქვს RTC მოდული, შეგიძლიათ შეხვიდეთ და ჩაწეროთ თარიღი და RTC დროის ვადები, ავტომატურად შეასწოროთ RTC 'დრიფტი'. თუ თქვენ Arduino– ს პროექტს აქვს GPS მოდული, შეგიძლიათ შეხვიდეთ და დაადგინოთ მისი უაღრესად ზუსტი დროის ნიშნები და pfodApp ავტომატურად შეასწორებს GPS– ის დაკარგული ნახტომი წამს.

ყველა შემთხვევაში თქვენი Arduino პროექტის ნედლეული მონაცემები არის ზუსტად ისე, როგორც მიღებულია, არ არის შესწორებული. თუმცა pfodApp ჟურნალის ფაილი შეიცავს დამატებით მონაცემებს, რაც საშუალებას მოგცემთ ხელახლა წარმოადგინოთ ეს შესწორებები ცხრილში გადმოწერილი ჟურნალის ფაილიდან.

Android კოდირება არ არის საჭირო. ნაკვეთის ფორმატები ყველა მითითებულია მცირე ზომის ტექსტური სტრიქონებით თქვენს არდუინოს ესკიზში. უფასო pfodDesigner აწარმოებს Arduino– ს მონაცემების სრულ ჩანაწერებს და ასახავს ესკიზებს Arduino დაფების ფართო სპექტრისთვის, რომლებიც დაკავშირებულია WiFi– ით, კლასიკური Bluetooth– ით, BLE– ით და SMS– ით