שיטות תזמון Arduino עם מילי (): 4 שלבים

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

במאמר זה אנו מציגים את מיליס (); לתפקד ולהשתמש בו ליצירת דוגמאות תזמון שונות.

מילי? אין שום קשר לסינכרון שפתיים … בתקווה שזיהית את מילי כקידומת המספרים לאלפית; הכפלת יחידת מידה ב- 0.001 (או עשר בכוחו של השלילי 3).

מעניין שמערכות הארדואינו שלנו יספרו את מספר האלפיות השנייה (אלפי שנייה) מתחילת הרישום עד שהספירה תגיע למספר המרבי המסוגל לאחסן בסוג המשתנה ללא סימן ארוך (מספר שלם של 32 סיביות [ארבעה בתים] -זה נע בין אפס ל (2^32) -1. (2^32) -1, או 4294967295 אלפיות השנייה הופך לימים של 49.71027 אי זוגיות.

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

התחל = מילי ();

כאשר התחלה היא משתנה ארוך ללא סימן. להלן דוגמה פשוטה מאוד להראות לך מילי () בפעולה:

/ * מילי () הדגמה */

התחלה ארוכה ללא סימן, סיים, חלף;

הגדרת חלל ()

{Serial.begin (9600); }

לולאת חלל ()

{Serial.println ("התחל …"); התחל = מילי (); עיכוב (1000); סיים = מילי (); Serial.println ("סיים"); עברו = סיום-התחלה; Serial.print (חלף); Serial.println ("חלפו אלפיות השנייה"); Serial.println (); עיכוב (500); }

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

שלב 1:

במילים פשוטות, הפונקציה millis משתמשת במונה פנימי בתוך המיקרו -בקר ATmega בלב הארדואינו שלך. מונה זה מגדיל כל מחזור שעון - מה שקורה (בארדואינו סטנדרטי ותואם) במהירות שעון של 16 מגה -הרץ. מהירות זו נשלטת על ידי הקריסטל שעל לוח הארדואינו (הדבר הכסוף שעליו מוטבע T16.000).

שלב 2:

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

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

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

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

/* שעון עצר סופר בסיסי באמצעות מילי (); */

התחלה ארוכה ללא סימן, סיים, חלף;

הגדרת חלל ()

{Serial.begin (9600); pinMode (2, INPUT); // כפתור התחל pinMode (3, INPUT); // לחצן עצור Serial.println ("לחץ על 1 להתחלה/איפוס, 2 לזמן שחלף"); }

void displayResult ()

{לצוף h, m, s, ms; לא חתום מזמן; עברו = סיום-התחלה; h = int (חלף/3600000); מעל =%3600000 שחלף; m = int (מעל/60000); מעל = מעל%60000; s = int (מעל/1000); ms = מעל%1000; Serial.print ("זמן חלף גלם:"); Serial.println (חלף); Serial.print ("זמן שחלף:"); Serial.print (h, 0); Serial.print ("h"); Serial.print (m, 0); Serial.print ("m"); הדפסה סידורי (ים, 0); Serial.print ("s"); Serial.print (ms, 0); Serial.println ("ms"); Serial.println (); }

לולאת חלל ()

{if (digitalRead (2) == HIGH) {start = millis (); עיכוב (200); // עבור debounce Serial.println ("התחיל …"); } if (digitalRead (3) == HIGH) {הסתיים = מיליס (); עיכוב (200); // עבור debounce displayResult (); }}

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

שלב 3: מד מהירות …

אם היה לך חיישן בתחילת ובסוף מרחק קבוע, ניתן לחשב את המהירות: מהירות = מרחק ÷ זמן.

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

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

אחרים עשויים להשתמש בחיישן אפקט אולם-כל אחד לשלו). זכור משיעור מתמטיקה, לחישוב ההיקף - השתמש בנוסחה: היקף = 2πr כאשר r הוא רדיוס המעגל.

עכשיו שיש לך את היקף הגלגל, ערך זה יכול להיחשב כ'מרחק הקבוע 'שלנו, ולכן ניתן לחשב את המהירות על ידי מדידת הזמן שחלף בין סיבוב מלא.

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

לשם כך, יציאת החיישן בדוגמה שלנו מחוברת לפין דיגיטלי 2 - מכיוון שהיא תפעיל הפרעה לחישוב המהירות. הסקיצה אחרת תציג את המהירות במודול LCD רגיל בממשק I2C. מוצע ממשק I2C מכיוון שזה דורש רק 4 חוטים מלוח ה- Arduino אל ה- LCD - ככל שהחוטים פחות כן ייטב.

להלן הסקיצה לעיונך:

/*מד מהירות בסיסי באמצעות מילי (); */

#כלול "Wire.h" // עבור LCD אוטובוס I2C

#כלול "LiquidCrystal_I2C.h" // עבור מודול LCD אוטובוס I2C - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // הגדר את כתובת ה- LCD ל- 0x27 עבור תצוגה של 16 תווים ו -2 שורות

צף התחלה, סיים;

הציפה חלפה, הזמן; float circMetric = 1.2; // היקף גלגל ביחס למיקום החיישן (במטרים) צף מעגל; // שימוש בקילומטר אחד = 0.621371192 מייל צף speedk, speedm; // מחזיק ערכי מהירות מחושבים במטרי ובאימפריאלי

הגדרת חלל ()

{attachInterrupt (0, speedCalc, RISING); // הפסק נקרא כאשר חיישנים שולחים דיגיטל 2 גבוה (כל סיבוב גלגלים) התחלה = מיליס (); // הגדרת lcd.init LCD (); // לאתחל את lcd lcd.backlight (); // הפעל תאורה אחורית LCD lcd.clear (); lcd.println ("חבשו קסדה!"); עיכוב (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric*.62137; // המרת מדד לאימפריאלי לחישובי MPH}

מהירות חלל Calc ()

{elapped = millis ()-התחל; התחל = מילי (); speedk = (3600*circMetric)/שחלף; // קמ ש מהירות m = (3600*מעגל)/חלף; // מיילים לשעה }

לולאת חלל ()

{lcd.setCursor (0, 0); lcd.print (int (speedk)); lcd.print ("קמ"ש"); lcd.print (int (מהירות)); lcd.print ("MPH"); lcd.setCursor (0, 1); lcd.print (int (חלף)); lcd.print ("ms/rev"); עיכוב (1000); // התאמה להעדפה אישית כדי למזער הבהובים}

אין כל כך הרבה דברים - בכל פעם שהגלגל משלים מהפכה אחת האות מהחיישן יעבור מנמוך לגבוה - מה שמעורר הפרעה המכנה את הפונקציה speedCalc ().

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

float circMetric = 1.2;

והוא נמדד במטרים). לבסוף הוא מחשב את המהירות בקמ ש ו- MPH. בין ההפסקות הציור מציג את נתוני המהירות המעודכנים על ה- LCD וכן את ערך הזמן הגולמי לכל מהפכה למען הסקרנות. בחיים האמיתיים אני לא חושב שמישהו יעלה LCD על אופניים, אולי תצוגת LED תהיה רלוונטית יותר.

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

שלב 4:

זה בערך מסכם את השימוש ב- millis () לעת עתה. יש גם את המיקרו (); פונקציה הסופרת מיקרו שניות.

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

את הפוסט הזה הביאה לכם pmdway.com - הכל ליצרנים ולחובבי האלקטרוניקה, עם משלוח חינם לכל רחבי העולם.