שלח נתונים מספריים מארדואינו אחד למשנהו: 16 שלבים

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

מבוא

מאת דייויד פאלמר, CDIO טק. באוניברסיטת אסטון.

האם אי פעם היית צריך לשלוח כמה מספרים מארדואינו אחד למשנהו? מדריך זה מראה כיצד.

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

מה שזה עושה

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

צִיוּד

• 2 של ארדואינו
• 2 כבלים USB
• חוטי תיקון (כנדרש)
• מחשב/מחשב נייד אחד טעון Arduino IDE (זמין להורדה בחינם מאתר Arduino.cc)

שלב 1: הגדרה - הגדר תחילה את החומרה שלך

חבר את 2 הארדואינים ל -2 יציאות USB במחשב שלך.

טיפ, מומלץ לתייג אותם כ- M ו- S (אמן ועבד) כדי שלא תיכנסו לבלבול מאוחר יותר (כפי שמוצג בשתי התמונות כאן.)

שלב 2: הגדרה - הגדר את המסך שלך

הדבר הטוב ביותר הוא להגדיר את המסך כך שיהיה לך

• ה- IDE טעון בתוכנית המאסטר בצד שמאל ו-
• זאת עם העבד מימין.

שמור גם על המסכים הסידוריים של Maser ו- Slave בצד שמאל וימין כפי שמוצג בצילום המסך כאן.

שלב 3: הגדר את ה- Master End ואז התחבר יחד - חלק 1

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

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

השתמשתי בירוק וצהוב

• קח את הצהוב ראשון, זה חייב להתחבר ל- D6 בארדואינו אחד ו- D7 בשני
• ואז ההפך לחוט הירוק, D7 בראשון ו- D6 בארדואינו השני.

לחלופין, אם יש לך משהו זמין כמו זוג מודולי בלוטות ' - כמו HC -05 - אלה יעבדו גם כדי לתת לך את אותו האפקט בדיוק כמו החוטים למעלה.

שלב 4: הגדר את ה- Master End ואז התחבר יחד - חלק 2

אנו עושים שימוש בספריית Serial Software. מידע נוסף זמין בקישור זה

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

שלב 5: סקירת הסקיצות / התוכניות - מבנה התוכנית

פריסה כמו בכל מערכונים של Arduino ישנם 3 חלקים בסיסיים:

• ההצהרות
• ההתקנה
• הלולאה הראשית

כפי שקורה לעתים קרובות, השתמשנו כאן בקטע רביעי שהוא תוספת של 'פונקציות'. אם אינך מכיר את השימוש בפונקציות תוכל לגוגל עבור "פונקציות ארדואינו" ותמצא אתרי הסבר כמו הדוגמא בקישור זה: www.tutorialspoint.com/arduino/arduino_functions…..

כמו כן, השתמשנו בכרטיסיות כדי להפריד את התוכנית לבלוקים ניתנים לניהול.

ניתן לראות את שלושת הבלוקים בהם השתמשנו בראש כל איור של חלונות IDE למעלה:

• simpleRxTx0330Master
• מְשׁוּתָף
• הערות

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

יש סיבה טובה מאוד לכך שעשינו זאת.

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

אף אחת מהפונקציות אינן נקראות מההגדרה, כולן נקראות מלולאה, כך שיצרנו אותן לאחר ההתקנה אך לפני הלולאה.

שלב 6: עיצוב מלמעלה למטה

כדאי לעצב את הסקיצה שלך החל מהגדרה של מה שאתה רוצה לעשות.

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

זה עוקב אחר פילוסופיית העיצוב הטוב, הנלמדת באוניברסיטאות רבות, הנקראת CDIO (אם אינך מכיר את זה עדיין תוכל לחפש אותו בגוגל ולמצוא אתרים להסבר כמו: https://www.cdio.org/s.) זה בעצם אומר: אל תתחיל את העיצוב לפני שהקונספט ברור. אל תתחיל את היישום עד שתבין את העיצוב. אל תצפה שהוא יפעל לפני שתסביר את היישום. C תחילה, אחר כך D, I ו- O. בכל שלב אחר שאתה חוזר על עצמו (חזור אחורה בלולאות), אז ברגע שאתה מרוצה מהלולאה הראשונית של העיצוב ובדוק שהוא עדיין עומד בקונספט, ועדכן C אם אתה צריך. וכך הלאה, כך שגם כאשר הגעת לפעולה, חזור עד לפסגה ושוב ראה כיצד C נראה כעת, לאחר מכן D ו- I, ובצע ובדוק הכל משתנה לפי הצורך. עם סקיצות תכנות זה עובד בדיוק אותו הדבר אם אתה מעצב מלמעלה למטה.

שלב 7: קונספט ועיצוב - חלק 1

הרעיון כאן נראה כמו דרישות המתאר המופיעות בכרטיסייה 'הערות'. '

העיצוב יכול להיראות כמו גרסה מוקדמת של הלולאה, התואמת את כרטיסיית ההערות ויכולה להיראות כמו שאתה רואה באיור זה

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

זה למעשה מהדר אישור כפי שאתה יכול לראות בתחתית המסך באיור. זה מגיע משלב CDIO D עד I, וככל שאנו מפתחים את הקוד, כדאי להמשיך את הלולאה הזו של D-I.

עכשיו הגיע הזמן לרדת לשלב הבא, יש שם הערה שאומרת שאנחנו הולכים: // לקבל משהו מה- USB החומרה, ואז נעביר את זה לערוץ הטורי של התוכנה. אנו כותבים את הקוד הזה כדי לגרום לזה לקרות - שורות 133 עד 138 המוצגות כאן בסימון צהוב

שלב 8: קונספט ועיצוב - חלק 2

שתי הפונקציות הראשונות שאנו מציגים כאן הן (recv () ו- tran () לבצע את הקבלה מיציאת החומרה והשידור ליציאת התוכנה - ומכאן לקרוא להן עם הפרמטרים 'hw' או 'sw' המוצגים.

בנוסף להם, הוספנו בדיקה על משתנה גלובלי בשם newData. זהו דגל שנקבע בתוך הפונקציה "void recv ();". כאשר התקבלה הודעה משתנה זה מסומן משקר לאמת. אנו עושים זאת כך שנוכל להעביר הודעה רק אם התקבלה הודעה אחת (flag == true) בשורה 134. וברגע שהעברנו את המסר שלנו ש'עבודה בוצעה ', כך ננקה את הדגל בחזרה לשקר בשורה 137.

שוב נוכל לבדוק את הידור (D עד I), והפעם יש לנו הודעת שגיאה 'לא מוכרז' (מוצג). זה אומר לנו שלא הכרזנו על recv (); פוּנקצִיָה. אנו מתכננים לעשות זאת מאוחר יותר, אז רק לעת עתה על מנת לאפשר לנו לקבל הידור נקי אנו צריכים ליצור פונקצית דמה או מציין מקום, כפי שמוצג בהמשך.

שוב נוכל לבדוק את הידור (D עד I), והפעם יש לנו עוד הודעת שגיאה 'לא מוצהרת' עבור ה- tran (); פוּנקצִיָה. זה צריך יצירת בדל דומה. שוב נוכל לבדוק הידור (D עד I), והפעם נגלה שזה עובד בצורה מושלמת; בינתיים הכל טוב.

שלב 9: סיים את הלולאה הראשית: א) קבלה מ- USB, ב) קבלה מעבד Arduino

ישנו פיסה אחת אחרונה שהוספנו כדי לסיים את החלק הזה והיא להוסיף קצת קוד באגים.

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

כך ששורות הבאגים [136-139 המוצגות] מתווספות לאחר מכן בלולאה הראשית, והנה, תוכל לבדוק אותן בסוף המאסטר על ידי הפיכת משתנה הבאגים לאמיתי וחיבור (I), ואז אם אם אתה מחבר Arduino למעלה אתה יכול להעלות, לפתוח את המסך הסידורי ולראות אם מה שחוזר לתוך הצג הטורי הוא כפי שמוצג כאן (האם אתה רואה שנוספה הודעת "MOD DEBUG"?)

שלב 10: קבלת וטיפול בנתונים ב- Arduino Slave

קבלת העבד ארדואינו

הוסף את הקוד הדרוש לערוץ השני ללולאה הראשית, המקלט הטורי של התוכנה כפי שמוצג - שורות 149 עד 155.

האם אתה יכול לראות שהמבנה מבוסס באופן רופף על מה שכתבנו לעיל עבור תיק המאסטר?

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

טיפול בנתונים ב- Arduino Slave

הוסף את קוד הלולאה הראשי הנדרש עבור Arduino אם הוא מוגדר כמכשיר Slave כפי שמוצג - שורות 163 עד 174. האם אתה יכול לראות שהמבנה שלו דומה מאוד לזה של הערוץ הראשון?

וכדאי שתמצא שהפעם הוא מתאסף בסדר גמור.

שלב 11: כתוב את פונקציית הקבלה

פונקציית הקבלה - void recv (char from) {} - כוללת שתי עבודות עיקריות.

1 לקבלת מחרוזת תווים מערוץ ה- USB, ו-

2 לקבל אחד מהערוץ Arduino to Arduino.

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

כשאנחנו מתחילים להוסיף קוד לפונקציה - כדי ליצור פונקציה שעושה משהו, במקום רק בדק - עלינו לזכור להסיר או להעיר את הבד שהוא מחליף. אחרת נקבל שגיאת הידור: הגדרה מחדש של 'void lrec (char)'.

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

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

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

כעת נסתכל על הקוד שכתבנו עבור הפונקציה recv ().

הוא די נקי, אתה יכול לראות את השימוש במצב 'אם' כדי לייצר את שני חלקי הפונקציה שאליה התייחסנו לעיל.

הקוד בתוך החלק 'sw' וחלק 'hw' הוא מאותה צורה, ואני אתאר אותו כאן.

הראשון מבין צמד השורות בכל מקרה הוא התחלה של לולאת זמן. אם אינך מכיר את זמני הזמן תוכל לחפש אותו באתר Arduino.cc/Reference לקבלת ההסבר והדוגמאות. כאן אנו ממתינים 'בזמן שהפונקציה' סידורי 'המובנית לא קיבלה תווים כלשהם ומכיוון שהמשתנה newData נכבה (כלומר המצב newData == false נכון). ברגע שיתקבל תו - או יותר מתו אחד - הזמן יעבור לשורה השנייה בצמד זה. לאחר מכן זה יקרא ל- recAstringChar (char); פונקציה לטיפול בדמות הנוכחית. צמד השורות יחלפו לאחר מכן בעוד (או כל עוד) יש תווים שעדיין דורשים להתקבל. ברגע שכולם מסיימים מדינת ה- while מסתיימת, מה שמאפשר לרמה הבאה אם או אחרת להסתיים, ובתורו מאפשר את rec (char); הפונקציה להסתיים. כך התקבלה כעת הודעה מלאה.

שלב 12: כתוב את פונקציית המשנה קבל - חלק 1

כעת עלינו לכתוב את הפונקציה הנקראת recAstringChar (char);. אתה רואה מההערה לשורה 50 כאן בחלק העליון שלה, שתפקידה לעדכן שני מאגרים עם עותקים של ההודעה הסדרתית הנכנסת. [התברר בזמן שניסיתי לגרום לכל זה לפעול שדבר אחד שלמדתי הוא שאני צריך שני מאגרים שונים - או לפחות זו הדרך הקלה ביותר לעקוף כמה בעיות, ומכאן שזה די התפתח להזדקק לשני מאגרים, אז פשוט הכנתי אותם.] התקשרתי למאגר אחד: receivedData, והשני: receivedChars.

המאגרים הם משתנים גלובליים, ולכן הם מוכרזים ברמת המודול, ראה שורות 9 ו -10 בכרטיסייה הנפוצה. ישנם משתנים אחרים המוצהרים בתוך פונקציה זו ולכן יש להם היקף מקומי- המוצג בשורות 51-54 כאן. זה לא המקום להסביר את ההבדלים בין גלובאל למקומיים, אבל יש מידע נוסף על כך ב https://www.arduino.cc/glossary/en/ תחת Local and Global.

תוכל גם לברר הכל אודות סוגי הנתונים ומשתני הסוגים: סטטי, בוליאני, בייט, const, char ב https://www.arduino.cc/reference/en/#variables, המוצג כאן.

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

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

ב) [שורות 56 עד 73] המקבל את כל התווים האחרים באשר הם, אך הם מתמודדים עם תווים רק לאחר שהתחלה תקפה התקיימה ('>' התקבל כמו א) לעיל.)

בשורות אלה (מ -74 עד 78) הכנסנו את זה שהתקבל <לאחד המאגרים (receivedData [0]) אך לא בשני. אנו מתאימים את מצביע החיץ (משתנה: char ndx) כדי להצביע על עמדת החיץ החופשית הבאה (empfangData [1]) באמצעות הפקודה שלאחר התוספת (++) בשורה ndx ++;, והגדרנו את הדגל המתקיים נכון.

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

א) [משורה 65 ואילך] עם סיום ההודעה שהתקבלה. זה קורה כאשר ה- endMarker נצפה - מוגדר כ>, ולכן בכל פעם שאנו בודקים את הסקיצה שלנו אנו תמיד מסיימים את המחרוזת שלנו עם הדמות הזו. אחד הדברים שקורים עם קבלת תו הסיום הוא שהדגל הגלובלי (משתנה טכנית) newData מוגדר נכון בדיוק כשהפונקציה מסתיימת, כך שהפונקציה שקראה לפונקציית המשנה שלנו (הפונקציה הקוראת: recv (char);) יכול 'לדעת' כי התקבלו נתונים חדשים תקפים שהושלמו.

ב) [שורות 57 עד 64] המקבל את כל הדמויות האחרות, תהיינה אשר יהיו. זה פשוט מחנה אותם בצורה מסודרת בשורות בשני המאגרים.

שלב 13: כתוב את פונקציית המשנה קבל - חלק 2

זה עשוי לעזור לתת דוגמה איך 2 המאגרים נראים כשהם מאוכלסים. אם היינו מזינים enter, במאגרים היו התווים המוצגים בהם:

אז עכשיו אתה יכול לראות שיש לנו מאגר אחד שהוא בדיוק כל אותם תווים כפי שהקלדנו לראשונה, ומאגר אחד שיש לו רק את שני הערכים ופסיק מפריד. כעת יש לנו קוד כלשהו שיכול לקבל את התווים שאנו מקלידים במקלדת צג סידורי, אנו יכולים לעבור משלב CDIO ל- O, להקליד כמה מחרוזות ולראות מה קורה. העלה את הקוד ל- Master Arduino, פתח את הצג הסידורי ונסה להקליד משהו תקף, כמו enter. האם אתה מקבל הד במסך הצג הסידורי כמו זה שמוצג כאן?

שלב 14: כתוב את פונקציות השידור והניתוח

ראשית לשידור

אז עכשיו קיבלנו מחרוזת, נוכל לכתוב את פונקציית השידור: tran (char); להחליף את הבד שלו. זה יאפשר לנו לשלוח מחרוזת מהמאסטר לעבד ארדואינו, לכן וודא ששני המכשירים מחוברים ומחוברים זה לזה כדי לבדוק את הפונקציונליות החדשה הזו.

הזן פונקציה זו כפי שמוצג כאן בשורות 117 עד 133. כפי שתזהה, יש לה שני חלקים, אחד לשדר לערוץ ה- USB (חומרה UART) ואחד לשדר ל- Arduino השני (תוכנת UART). -חינמי, ותוכל להעלות מיד את הסקיצה ולראות מה קורה. הפעם אני אשלח. האם אתה מקבל את התוצאה המוצגת?

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

שלב 15: כתוב את פונקציות השידור והניתוח

ואז לפרס

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

החלף את תקע הניתוח בקוד המוצג בשורות 98 - 113. העלה אותו, ונראה אם הבעיה שהייתה לנו עם 2 ערכי המספר השלם תוקנה כעת. בוא ננסה.

כן, זה עובד, כפי שמוצג, המספרים השלמים שנמצאו הם 49 ו -98.

שלב 16: סיום

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