Arduino תאריך/שעה תכנון/רישום באמצעות Millis () ו- PfodApp: 11 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:14

אין צורך בתכנות Arduino או אנדרואיד. מודולי RTC ו- GPS נתמכים גם כן. תיקון אוטומטי לאזורי זמן, סחיפת RTC ושניות זינוק חסרות GPS

מבוא

מדריך זה מראה לך כיצד להשתמש בחותמות הזמן של Arduino millis () כדי לשרטט נתונים מול תאריך ושעה בנייד אנדרואיד שלך באמצעות pfodApp.

אין צורך בתכנות Arduino או אנדרואיד. pfodApp גם רושם מספיק נתונים בכדי שתוכל מאוחר יותר לשחזר את עלילות התאריך/שעה בגיליון אלקטרוני.

אין צורך במודול RTC או GPS, אולם אם לפרויקט Arduino שלך יש RTC (שעון בזמן אמת) או מודול GPS ניתן להשתמש בהם גם. במקרים אלה חלקות pfodApp יתקנו באופן אוטומטי עבור אזור זמן, סחף RTC ו- GPS חסרות שניות קפיצה. לא נדרש קוד Arduino מיוחד לתיקונים אלה. כמו תמיד עם pfodApp, הנתונים המתקבלים נרשמים בדיוק כפי שהם, ללא תיקון, אולם קובץ היומן מכיל גם מידע מספיק כדי לאפשר לך ליישם תיקונים אלה בעצמך בעת הורדת היומנים למחשב שלך. ראה להלן דוגמאות של עיבוד לאחר מכן.

מגוון רחב של עיצוב ותאריך ציר ה- X נתמך, כולם נשלטים לחלוטין על ידי מחרוזות טקסט קצרות במערכון הארדואינו שלך. אין צורך בתכנות אנדרואיד.

pfodApp יתחבר באמצעות WiFi, Bluetooth Classic, BLE ו- SMS. PfodDesigner החינמי יוצר סקיצות מלאות של Arduino לתזמון/כניסה של תאריך/שעה כדי להתחבר למגוון רחב של לוחות. אין צורך בתכנות Arduino.

מדריך זה ישתמש ב- Adafruit Feather52 כדוגמת לוח Arduino, המתחבר באמצעות BLE.

מדריך זה מכסה שלושה מקרים:- 1) לפרויקט המיקרו-מעבד שלך יש חותמות זמן של אלפיות השנייה בלבד- מיליס () 2) לפרויקט המיקרו-מעבד שלך יש שעון בזמן אמת (RTC)- pfodApp מתקן אוטומטית את הסחף. 3) לפרויקט המעבדים שלך יש מודול GPS - pfodApp מתקן אוטומטית לשניות קפיצה כשהן מתרחשות (כרגע 18 שניות נכון לשנת 2018).

שלב 1: שימוש בחותמות זמן Arduino Millisecond, Millis ()

ישנם שני חלקים לשימוש באלפיות השנייה לתאריך ושעה. האחד נועד לשרטט את הנתונים כנגד הזמן שחלף או תאריך/שעה והחלק השני יוצר מחדש את התאריך והשעה מתוך חותמות הזמן של הנתונים הנתונים הגולמיים שנרשמו. pfodApp אינו משנה את הנתונים הגולמיים שהתקבלו מה- pfodDevice (המיקרו Arduino). הוא פשוט רושם בדיוק את הבייטים שהתקבלו.

תחילה השתמש ב- pfodDesigner החינמי ליצירת שרטוט Arduino למיקרו שלך שישלח את האלפיות השנייה ומדידות הנתונים אל pfodApp לצורך תכנון/כניסה. דוגמה זו יוצרת תפריט ללוח Adafruit Feather 52 BLE שקורא A0. ההדרכה בנושא Adafruit Feather nRF52 LE - פקדים מותאמים אישית עם pfodApp עוברת את שלבי pfodDesigner ליצירת תפריט עבור ה- Feather nRF52 הכולל לחצן תרשים, אז בדוק אותו לפרטים נוספים. במדריך זה נוסיף רק כפתור תרשים ונשתמש באפשרויות הפורמט החדשות של ציר ה- X כדי להתוות את קריאות A0 מול הזמן והתאריך/השעה שחלפו.

החלק הראשון של הדרכה זו יעבור באמצעות pfodDesigner החינמי ליצירת תרשים תאריך/שעה לדוגמא בנייד אנדרואיד שלך. כאשר אתה מרוצה מהתצוגה תוכל ליצור את סקיצת ה- Arduino שתשחזר זאת כאשר אתה מתחבר עם pfodApp. אין צורך בתכנות אנדרואיד ומכיוון ש- pfodDesigner יוצר סקיצות מלאות של Arduino למגוון רחב של לוחות Arduino, גם אין צורך בתכנות Arduino.

שלב 2: הוספת תרשים לתפריט

הורד את אפליקציית pfodDesigner מ- Google Play, פתח אותה ולחץ על "התחל תפריט חדש"

לחץ על "Serial Target" ולאחר מכן על כפתור "Bluetooth Low Energy" כדי להציג את רשימת כ -11 לוחות BLE (גלול מטה כדי לראות את האפשרויות האחרות). בחר ב- Adafruit Bluefruit Feather52.

חזור לתפריט העריכה ולחץ על "עריכת בקשה" והגדר הודעה מתאימה לתפריט זה, למשל. "נוצה 52" והטקסט מודגש וגודל +7. צבע הרקע נשאר כ'ברירת המחדל 'הלבן

חזור ולחץ על "הוסף פריט תפריט", גלול מטה ובחר "כפתור תרשים" אשר פותח את מסך עריכת לחצני התרשים. אתה יכול לבצע כל שינוי במראה הכפתור כאן. במקרה זה הטקסט של הלחצן השתנה ל"עלילה תאריך/שעה של A0 "ושאר ברירות המחדל נותרו כפי שהן.

זה נותן לך כפתור בתפריט שיפתח את מסך התרשים.

שלב 3: עריכת מקור העלילה והתוויות

לחץ על כפתור "תאריך/שעה חלקה של A0" כדי לפתוח את מסך עריכת החלקות, שם תוכל לגשת לתווית התרשים, פורמט ציר ה- X, מרווח נתוני העלילה ו (על ידי גלילה למטה) הגדרות העלילה עצמן. ערוך את תווית התרשים למשהו מתאים, למשל. "A0 וולט".

גלול מטה ובשביל חלקות 2 ו -3 פתח את ערוך העלילה ולחץ על הסתר חלקה כדי להסיר אותן מתצוגת התרשים.

לאחר מכן לחץ על "ערוך מגרש 1" והגדר תווית עלילה (למשל A0), יחידות yAxis (למשל וולט), הצג מקסימום 3.6V והתחבר לפין קלט/פלט A0.

גלול חזרה ולחץ על "תצוגה מקדימה של תרשים" ל -0 נקודות הנתונים המדוגמות האחרונות, במרווחים של 1 שניות, המתואם כנגד הזמן שחלף בדקות: שניות.

עבור כל זמני הזמן שחלפו חלקות מובילות אפס אינן מוצגות ולכן בחלקה זו מוצגות רק דקות> דקה אחת.

שלב 4: בחירת תבנית התאריך/שעה

בחלקות הזמן שחלף היחידה המובילה רק ממשיכה לגדול ככל שהזמן עובר. כדי לראות דוגמה לכך חזור למסך "עריכת עלילות" והגדיל את מרווח נתוני העלילה ל -15 דקות (תחתית מסך זה)

לאחר מכן לחץ על תצוגה מקדימה של תרשים כדי להציג את אותם נתוני המדגם אך כעת עם מרווחי 15 דקות בין הדגימות. כפי שאתה יכול לראות את חלק הדקות של mm: ss רק ממשיך לגדול.

עכשיו חזור ולחץ על כפתור ציר ה- X כדי להציג מבחר קטן של כל פורמטי הנתונים/הזמן האפשריים של ציר ה- X (גלול למטה לעוד)

למעלה מבחר תצוגות מקדימות של תרשים באמצעות פורמטים שונים של ציר X.

עלילות התאריך/שעה המוצגות כאן נמצאות באזור הזמן ה'מקומי '. ישנן גם אפשרויות פורמט לזימון תאריך/שעה ב- UTC. למערך מלא של אפשרויות פורמט תאריך/שעה עיין pfodSpecification.pfd.

שלב 5: צור ובדוק את סקיצת הארדואינו

ברגע שאתה מרוצה מהפורמט של התרשים ומרווח הזמן של הנתונים, תוכל לעבור למסך "תפריט עריכה_1" ולגלול למטה ול"צור קוד "עבור לוח היעד שבחרת. להלן סקיצה לדוגמה של Adafruit Feather52 תוך שימוש במרווחי נתונים של 1 שניות ופורמט הזמן mm: ss שחלף, pfodFeather52_timeplot.ino

למעלה חלקה של A0 מהנוצה 52

שינוי הפורמט לשעות השבוע: דקות: שניות (~ E HH: mm: ss) ויצירת הקוד מחדש (pfodFeather52_dateplot.ino) נותן עלילה כמו השנייה למעלה.

אתה יכול לערוך את פורמט ציר ה- X ישירות במערכון הארדואינו שלך, כפי שיתואר להלן.

שלב 6: כיצד מתכננת PfodApp תאריך/שעה ממיליס ()?

כאשר pfodApp מתחבר, הוא זוכר את הזמן ה'מקומי 'וה- UTC ומבקש את חותמות הזמן הנוכחיות של נתוני העלילה של pfodDevice (לוח לוח Arduino). שימוש במידע זה pfodApp יכול לאחר מכן לשרטט חותמות זמן של מילי שניות כזמן שחלף, כלומר המרת מילי שניות לשניות דקות שניות וכו ', או לתכנן את התאריך והשעה שחותמות הזמן של האלפיות השנייה מייצגות ביחס לביצוע החיבור ובקשת הזמן הנוכחי של pfodDevice.

במבט בסקיצה שנוצרה על ידי Arduino (למשל pfodFeather52_dateplot.ino), ישנם שלושה פיסות קוד קטנות המטפלות בצד Arduino של העלילות.

קטע קוד הלולאה () המטפל בבקשת השעה הנוכחית של pfodApp {@}

// לטפל ב {@} בקשה} אחרת אם ('@' == cmd) {// pfodApp ביקש 'הנוכחי' זמן plot_mSOffset = millis (); // ללכוד מיליליטר הנוכחי כקיזוז חותמות זמן נתוני גלם parser.print (F ("{@` 0} ")); // החזר '0 כנתוני גלם' עדכניים '

אתה יכול פשוט להחזיר את הערך הנוכחי של מילי (), אך מילי () עוטף אחורה ל -0 כל 49.7 ימים, מה שיגרום לעלילה לקפוץ לאחור. אז במקום זאת הקוד זוכר את הערך הנוכחי של מילי () כאשר הוגשה הבקשה {@}, ומחזיר את {@`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 ימים ימנע זאת.

החלק השלישי של עלילת התאריך/שעה הוא הודעת העלילה.

} אחרת אם ('A' == cmd) {// משתמש נלחץ - 'נתח תאריך/שעה של A0' // בתפריט הראשי של תפריט_1 // החזר הודעת זמירה. parser.print (F ("{= A0 וולט ~ E HH: mm: ss | תאריך | A0 ~~~ וולט ||}"));

כאשר המשתמש לוחץ על כפתור "תאריך/שעה עלילה של A0", pfodApp שולח את ה- cmd {A} ל- pfodDevice וה- pfodDevice מגיב עם הודעת העלילה, {= … {= A0 וולט ~ E HH: mm: ss | תאריך | A0 ~~~ וולט ||} המכיל את תבנית ציר ה- X E HH: mm: ss

תבניות Java SimpleDateFormat מקובלות כאן. ל pfodApp Logging and Plotting ו- 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 הוא חודשים ו- 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) אתה משתמש בנוסחה זו כדי להמיר את מחרוזת ה- hex, ב- A2, ל- mS (כאשר A1 הוא תא ריק כלשהו) = HEX2DEC (REPLACE (A2; 1; 2; A1))

למה אתה לא רוצה לעשות את זה

כפי שמוצג לעיל, קל להאריך את חותמות הזמן של mS ליותר מ -50 יום. עם זאת אתה כנראה לא רוצה לעשות את זה כי הם הופכים מדויקים יותר ויותר. קריסטל טיפוסי של 16Mhz המשמש ליצירת התוצאות של מילי () במיקרו בעל דיוק של ~ 50ppm (חלקים למיליון). המשמעות היא שאחרי 49.7 ימים חותמת הזמן באלפיות השנייה יכולה להיעדר ב -3 וחצי דקות וזה מתעלם מהשפעת הטמפרטורה על דיוק הגביש.

לאורך תקופות חיבור קצרות, דיוק זה אינו מהווה בעיה מכיוון שתגובת {@.. מסנכרנת מחדש את חותמת הזמן של האלפיות השנייה לתאריך/שעה של הנייד בכל חיבור מחדש. עם זאת, אם אתה רוצה להישאר מחובר לפרקי זמן ארוכים (ימים) ולרשום את הנתונים באופן רציף, עליך להשתמש במשהו מדויק יותר מהמיליס המובנה (), כגון מודול RTC או GPS.

שלב 9: שימוש ב- RTC (שעון בזמן אמת)

ישנם מספר מודולי RTC זמינים, אחד המדויקים יותר הוא DS3231 למשל. מודול DS3231 של Adafruit. הדיוק המוצהר הוא +/- 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 = מיליס (); // ללכוד מילי הנוכחי כקיזוז חותמות זמן גולמיות של נתונים parser.print (F ("{@` 0 "}); // להחזיר '0 כנתונים גולמיים' עדכניים 'נתונים parser.print (' ~ '); // התחלת מחרוזת של date/time DateTime now = rtc.now () sendDateTime (& now); // שלח yyyy/M/d/H: m: s ל- parser.print, העבר כתובת & כפי שטוען parser.print ('}'); // סוף {@ תגובה למשל {@ `0 ~ 2019/4/19 3: 33: 5}….

// שלח את תאריך השעה למנתח 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-> שעה (), DEC); parser.print (':'); parser.print (dt-> minute (), DEC); parser.print (':'); parser.print (dt-> second (), DEC); }

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // הפעל מחדש טיימר נתוני עלילה, ללא סחף // הקצה ערכים למשתני עלילה ממשתני הלולאה שלך או קרא כניסות ADC plot_1_var = analogRead (A0); // קריאת קלט לעלילה // plot_2_var עלילה מוסתרת כך שאין נתונים מוקצים כאן // plot_3_var עלילה מוסתרים כך שאין נתונים מוקצים כאן // שלח נתוני עלילה בפורמט CSV DateTime עכשיו = rtc.now (); sendDateTime (& עכשיו); // שלח yyyy/M/d/H: m: s אל parser.print, העבר כתובת & כמו arg. 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 Office) כדי לקבל את השעה המקומית האמיתית.

עבור חלקות זמן שחלפו, צור עמודה חדשה המכילה את (חותמת הזמן תאריך/שעה-השעה הנוכחית של 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.

ספריית ה- GPS של Adafruit עבור ה- Adafruit Ultimate GPS, בניגוד ל- RTClib, אינה מוסיפה את קיזוז 2000 השנים לשנות ה- GPS, כך שצריך להוסיף אותה כשאתה שולח את חותמת הזמן של התאריך והשעה. למרות שספריית ה- GPS מספקת אלפיות השנייה שיש לה דיוק טוב לטווח הארוך, הם אינם מדויקים במיוחד. עדכוני זמן ה- GPS הם רק פעם אחת בכל 100 ms ואז יש עיכוב נוסף בקבלת הנתונים הטוריים בשידור איטי של 9600 ועוד עיכוב בניתוחו. כל אלה מוסיפים לדיוק האלפיות השנייה בעת חותמת זמן קריאת נתונים.

להלן מספר שינויים בקוד לדוגמה החלים על הסקיצה שנוצרה על ידי pfodDesigner לשימוש במודול GPS, בהנחה שאתה משתמש בספריית ה- GPS של Adafruit והוספת את הקוד כדי לקבל ולנתח את ההודעות לאובייקט GPS.

// לטפל ב {@} בקשה} אחרת אם ('@' == cmd) {// pfodApp ביקש 'הנוכחי' זמן plot_mSOffset = מיליס (); // ללכוד מילי הנוכחי כקיזוז חותמות זמן נתונים גולמיים parser.print (F ("{@` 0 "}); // להחזיר '0 כנתונים גולמיים' עדכניים 'parser.print (' ~ '); // התחלת מחרוזת של date/time sendDateTime (& GPS); // שלח yyyy/M/d/H: m: s אל parser.print, העבר כתובת & כמו arg. 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-> month, 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 מוסתר כך שאין נתונים מוקצים כאן // plot_3_var עלילה מוסתרים כך שאין נתונים מוקצים כאן // שלח נתוני עלילה בפורמט CSV sendDateTime (& GPS); // שלח yyyy/M/d/H: m: s אל parser.print, העבר כתובת & כמו arg. 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 הוא 18 שניות לפני ה- UTC. pfodApp מתקן זאת על ידי השוואת התאריך/השעה שהוחזר על ידי ה- GPS בחיבור, באמצעות התגובה {@, מול התאריך והשעה UTC של הנייד. יצירת עלילות בגיליון אלקטרוני מקובץ יומן pfodApp זהה למודולי RTC למעלה. הוספת השעה (זמן מקומי - זמני משרד טמפ ') לחותמות הזמן של GPS מתקנת את שניות הקפיצה.

חותמות הזמן millis () ממשיכות לפעול כמו בשימוש בחותמות זמן של אלפי שניות של Arduino, שלב 5 לעיל.

שלב 11: סיכום

שימוש ב- pfodApp בנייד אנדרואיד מאפשר לך לשרטט נתונים מול תאריך ושעה או זמן שחלף, תוך שימוש בפונקציה מילי () בלבד של Arduino. באמצעות קובץ יומן ה- pfodApp תוכל לייצר מחדש את חלקות התאריך/שעה בגיליון אלקטרוני. אם לפרויקט Arduino שלך יש מודול RTC, תוכל לרשום ולתוות את התאריך ואת חותמות הזמן של RTC, ולתקן אוטומטית את 'סחף' ה- RTC. אם לפרויקט Arduino שלך יש מודול GPS אתה יכול לרשום ולשרטט את חותמות הזמן המדויקות ביותר שלו ו- pfodApp יתקן אוטומטית את שניות הקפיצה החסרות של ה- GPS.

בכל המקרים הנתונים הגולמיים מפרויקט Arduino שלך נרשמים בדיוק כפי שהתקבלו, ללא תיקון. אולם קובץ יומן ה- pfodApp כולל נתונים נוספים שיאפשרו לך לייצר מחדש את התיקונים האלה בגיליון אלקטרוני מקובץ היומן שהורד.

אין צורך בקידוד אנדרואיד. תבניות העלילה כולן מצוינות על ידי מחרוזות טקסט קטנות במערכון הארדואינו שלך. PfodDesigner החינמי יוצר רישום נתונים מלא של Arduino ושרטוט סקיצות למגוון רחב של לוחות Arduino המתחברים באמצעות WiFi, Bluetooth קלאסי, BLE ו- SMS