תכנות מיקרו: רובוט ביט וג'ויסטיק: בקר סיביות עם מיקרופייתון: 11 שלבים

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

עבור רובוקאמפ 2019, מחנה הרובוטיקה הקיץ שלנו, צעירים בגילאי 10-13 הלחמים, מתכנתים ובונים רובוט "מבוסס כבד משקל" מבוסס BBC, כמו גם מתכנת מיקרו: ביט לשימוש כשלט רחוק.

אם אתה כרגע ב- Robocamp, דלג לשלב 3, כפי שעשינו את שני השלבים הראשונים כקבוצה

זהו מדריך שלב אחר שלב לקבלת רובוט מיקרו: ביט לתקשר עם בקר ג'ויסטיק: ביט.

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

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

ניתן למצוא קובצי עיצוב עבור הרובוט שלנו כאן:

מדריך זה נכתב למתחילים, אך אם מעולם לא השתמשת במיקרו: ביט עם MicroPython, אנו ממליצים שתנסה קודם כל תוכנית פשוטה יותר, כגון תג השם שלנו Instructable: https://www.instructables.com/id/Felt -מיקרוביט-נאם …

אספקה

2x מיקרו BBC: ביט

רובוט שעובד עם מיקרו: ביט של BBC (ראה הסבר למעלה)

ג'ויסטיק: בקר ביט (קיבלנו את שלנו מרכיבים מגניבים)

שלב 1: הגדרת רובוט

יש לך כמה אפשרויות לכתיבת קוד MicroPython עבור המיקרו: ביט:

• Mu, אותו תוכל להוריד ולהתקין מכאן:
• העורך המקוון, שתוכל למצוא כאן:

הוראות אלה מניחות שאתה משתמש ב- Mu

פתח את Mu וחבר את המיקרו: ביט למחשב שלך. מו צריך לזהות שאתה משתמש במיקרו: ביט ובחר 'מצב' של מיקרו: סיביות, אך אם לא, שנה אותו ידנית.

קבל מכאן עותק של קוד הבדיקה של מנוע הרובוט:

אם אתה לא רגיל ל- Github, זה יכול להיות לא אינטואיטיבי! שתי דרכים פשוטות להשיג את הקוד הזה הן:

1. שמור את הקובץ Raw במחשב שלך ולאחר מכן טען אותו ב- Mu:
2. העתק והדבק את כל הקוד הנתון לקובץ חדש ב- Mu.

כעת לחץ על כפתור 'פלאש' מסרגל הכלים של מו, כדי לשלוח את הקוד החדש שלך ל- micro: bit.

זה לא יעבוד אלא אם כן המיקרו: ביט מחובר לחשמל

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

הגדרת כיווני המנוע

תוכנית זו תפעיל את המנועים לכיוונים שונים כאשר תלחץ על כפתור 'A' במיקרו: ביט.

מה שאתה רוצה שיקרה הוא:

• כאשר מוצג 'A', מנוע שמאל קדימה
• כאשר מוצג 'B', השאירו את המנוע לאחור
• כאשר מוצג 'C', המנוע הימני קדימה
• כאשר מוצג 'D', מנוע ימני לאחור

זה כנראה לא יהיה המצב, כיוון שזה תלוי איך חיברת את הרובוט שלך!

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

אם אתה משתמש באחד הרובוטים שלנו (קבצים), החלף את שמות המשתנים כדי לגרום לרובוט לנוע בכיוונים הנכונים:

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

בדיקת הכונן

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

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

על ידי התקשרות לכונן (500, 500), למשל, אתה אומר לשני המנועים להדליק, בכיוון קדימה, בערך בחצי מהירות.

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

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

רמז: המנועים לא יכבו עד שתגידי להם! הם תמיד ימשיכו לבצע את ההוראה האחרונה שלהם.

אופציונלי: שיפור הנהיגה בקו ישר

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

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

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

כונן def (L, R):

# להלן התאמה לתיקון הפער במהירות המנוע L = int (L*1) R = int (R*1)

שתי שורות אלו לוקחות כיום את הערך L ו- R, מכפילות אותן ב -1 ואז מוודאות שהן עדיין מספרים שלמים (int).

לדוגמה, אם המנוע השמאלי שלך מהיר יותר, שנה את *1 בקו שלו ל *0.9, ובדוק אם זה משפר את המצב.

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

הגדרת הרדיו

כעת הגדר את הרדיו על ידי הוספת השורות הבאות לראש הקוד שלך:

ייבוא רדיו

radio.config (ערוץ = 7, קבוצה = 0, תור = 1) radio.on ()

זה יאפשר לרובוט שלך לקבל הוראות ממיקרו -ביט אחר, אך כרגע הוא יקבל הוראות מכל מיקרו -ביט אחר.

הסיבה לכך היא שערוץ 7 וקבוצה 0 הם ערוצי ברירת המחדל.

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

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

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

נסה את הקוד הבא כבדיקה (הוא לא יעשה דבר עד שתגדיר את הג'ויסטיק בשלב 2):

בעוד שזה נכון:

message = radio.receive () אם הודעה == 'קדימה': כונן (500, 500)

שלב 2: הגדרת ג'ויסטיק

נתק את המיקרו: ביט של הרובוט, וחבר במקום זאת את המיקרו: ביט של הג'ויסטיק

קבל מכאן עותק של קוד הגדרת הג'ויסטיק:

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

בסיום התוכנית, התחל את הלולאה הראשית שלך:

בעוד שזה נכון:

אם button_a.was_pressed (): radio.send ('קדימה')

קוד זה עדיין אינו משתמש בג'ויסטיק: ביט. הוא משתמש בכפתור A במיקרו: ביט לשליחת הודעה.

ודא שלרובוט שלך ולמיקרו: ביטים של הבקר שלך יש כוח, ולאחר מכן לחץ על הלחצן כדי לשלוח את ההודעה שלך.

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

טיפים לפתרון בעיות

אם אתה מקבל הודעת שגיאה במיקרו הבקר שלך: … באג את קוד הבקר שלך

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

אם לא יקרה כלום בכלל

• הקפד להבהב את הקוד הנכון לכל מיקרו: ביט - קל להבהב בטעות את הקוד הלא נכון!
• ודא שמספרי הערוץ והקבוצה שלך תואמים בכל מיקרו: ביט

שלב 3: בדיקת ערכי הג'ויסטיק

השלבים הבאים משתמשים כולם בקוד הבקר

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

החלף את הלולאה הראשית שלך בקוד הבא:

בעוד שזה נכון:

ג'ויסטיק = joystick_push () הדפסה (ג'ויסטיק) שינה (500)

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

זה לא יעבוד אלא אם כן המיקרו: ביט מחובר לחשמל

כאשר REPL פתוח, לחץ על כפתור האיפוס בגב המיקרו: ביט.

אתה אמור לראות כמה ערכים מביאים 'מודפסים' למסך שלך:

דחוף את מקש הג'ויסטיק וראה מה קורה למספרים.

רשום את הערכים שניתנו כאשר הג'ויסטיק נמצא במיקום המרכזי - במקרה שלי (518, 523).

לחץ שוב על כפתור REPL בסרגל הכלים של מו כדי לסגור אותו - לא תוכל להבהב קוד חדש למיקרו: ביט כשהוא פתוח.

שלב 4: התאמת משתני X ו- Y

ברצונך לשנות את הערכים הניתנים על ידי פונקציית הג'ויסטיק, כך ש:

• במרכז זה אפס
• למעלה הוא חיובי
• למטה הוא שלילי.

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

תסתכל על המספרים שקיבלת בשלב האחרון. המספר הראשון הוא x, והמספר השני הוא y.

ערוך את ההגדרה joystick_push () שכבר נמצאת בתוכנית, למינוס הערכים שלך מהמקור:

def joystick_push ():

x = pin0.read_analog () - 518 y = pin1.read_analog () - 523 החזרה x, y

השתמש במספרים שלך, הם עשויים להיות שונים משלי

מהבהב את הקוד החדש שלך, פתח את REPL, לחץ על כפתור האיפוס של micro: bit ובדוק את הערכים שלך.

האם אתה מקבל (0, 0)?

שלב 5: המרת X ו- Y לערכים עבור המנוע השמאלי והימני

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

אם היית נותן לרובוט את המספרים האלה, הוא היה מפעיל את המנוע הימני אך לא את השמאלי, וזה לא מה שאתה רוצה שיקרה!

תרשים זה מראה מה קורה לערכי x ו- y כאשר אתה מזיז את הג'ויסטיק, ומה אנו רוצים שהרובוט יעשה בעת הזזת הג'ויסטיק.

אתה צריך להשתמש במתמטיקה כדי לערבב את ערכי x ו- y, כדי לתת לך משהו שימושי יותר.

נ

המתמטיקות

נתחיל בלדחוף את הג'ויסטיק כל הדרך קדימה.

דוגמה לערכים שאתה עשוי לקבל היא:

x = 0

y = 500

כדי להיות שימושי עבור הרובוט, אתה רוצה לקבל ערכים כמו אלה:

שמאל = 500

נכון = 500

ננסה להוסיף x ו- y בדרכים שונות כדי לראות אילו מספרים נקבל:

x + y = 0 + 500 = 500

x - y = 0 - 500 = -500 y + x = 500 + 0 = 500 y - x = 500 - 0 = 500

עכשיו נראה מה יקרה אם נדחוף את הג'ויסטיק עד ימינה.

דוגמה לערכים שאתה עשוי לקבל היא:

x = 500

y = 0

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

שמאל = 500

מימין = -500

בואו ננסה שוב את הנוסחה שלנו:

x + y = 500 + 0 = 500

x - y = 500 - 0 = 500 y + x = 0 + 500 = 500 y - x = 0 - 500 = -500

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

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

נ

הרחבת פונקציית הג'ויסטיק

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

def joystick_push ():

x = pin0.read_analog () - 518 y = pin1.read_analog () - 523 שמאל = ימין = חזור שמאלה, ימין

מהבהב את הקוד החדש שלך, פתח את REPL, לחץ על כפתור האיפוס של micro: bit ובדוק את הערכים שלך.

האם אתה מקבל את הערכים שאתה מצפה להם?

אם אתה זקוק לעזרה נוספת, עיין בקוד הדוגמה שלנו כאן:

שלב 6: שליחת הערכים כהודעות רדיו

עכשיו יש לך כמה ערכים מוכנים לשלוח לרובוט שלך.

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

בעוד שזה נכון:

ג'ויסטיק = joystick_push () הודעה = str (ג'ויסטיק [0]) + "" + str (ג'ויסטיק [1])

זה עדיין לא ישלח את ההודעה!

מה קורה בשורת הקוד החדשה הזו?

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

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

דוגמא:

150 + 100 = 250

str (150) + str (100) = 150100

כך ששרשור ידביק את הערכים השמאליים והימניים שלך יחד.

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

לבסוף, האריך את הקוד שלך כדי לשלוח הודעה חדשה זו באמצעות הרדיו:

radio.send (הודעה)

לישון (10)

השינה מאטה את שליחת ההודעות כך שהמיקרו: ביט המקבל לא יעמיס יתר על המידה!

מהבהב קוד זה למיקרו הבקר שלך: ביט ונטר באגים כלשהם לפני שתמשיך לשלב הבא

שלב 7: קבלת ההודעות על הרובוט שלך

חזור לקוד הרובוט שלך מההתחלה - זכור לנתק את מיקרו: ביט הבקר שלך כדי שלא תבהב אליו בטעות את קוד הרובוט

גלול מטה ללולאה הראשית שלך - הסר את קוד הבדיקה והוסף זאת במקום זאת:

בעוד שזה נכון:

הודעה = radio.receive () הדפסה (הודעה) שינה (100)

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

הבזק את הקוד החדש שלך, המחובר ל- REPL, ולאחר מכן לחץ על הג'ויסטיק.

אתה אמור לקבל משהו כזה:

טיפים לפתרון בעיות

אם אתה מקבל הודעת שגיאה במיקרו הבקר שלך: … באג את קוד הבקר שלך

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

אם לא יקרה כלום בכלל

• הקפד להבהב את הקוד הנכון לכל מיקרו: ביט - קל להבהב בטעות את הקוד הלא נכון!
• ודא שמספרי הערוץ והקבוצה שלך תואמים בכל מיקרו: ביט

שלב 8: שימוש בהודעות הנכנסות לשליטה במנועי הרובוט

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

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

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

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

בעוד שזה נכון:

message = radio.receive () אם ההודעה אינה None: message = message.split () כונן (int (הודעה [0]), int (הודעה [1]))

מה קורה כאן?

• הקוד החדש יפעל אם ההודעה היא משהו אחר מאשר 'ללא'.
• message.split () בודק רווח בהודעה (שהוספנו בשלב האחרון), ומשתמש בזה כדי לפצל את ההודעה לשניים.
• int (הודעה [0]), int (הודעה [1]) עושה את ההפך ממה שעשינו בשלב הקודם - מקבל כל פיסת מידע בנפרד וממיר אותה למספר שלם (מספר שלם).
• int (הודעה [0]) משמש כערך המנוע השמאלי בפונקציית הכונן, ו- int (הודעה [1]) משמש כערך המנוע הימני.

בדוק שזה עובד - האם המנועים מסתובבים כשאתה לוחץ על הג'ויסטיק?

אם לא - הגיע הזמן לניקוי באגים!

אם כן, פנטסטי! יש לך רובוט שלט רחוק שעובד!

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

השלבים הבאים יראו לך כיצד להשתמש בכפתורים בג'ויסטיק כדי להוסיף פונקציונליות נוספת לרובוט שלך

אם אתה רוצה לראות את הגרסה שלנו של הקוד הזה עד כה:

• רובוט:
• בקר:

שלב 9: שימוש בכפתורים - קבלת הודעות נוספות

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

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

הרחב את הקוד שלך כך:

אם ההודעה אינה None:

if message == 'שלום': display.show (Image. HAPPY) elif message == 'ברווז': display.show (Image. DUCK) אחר: message = message.split () drive (int (message [0]), int (הודעה [1]))

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

אם ההודעה אינה שלום, היא תבדוק אם ההודעה היא 'ברווז'.

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

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

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

קישור לקוד עבודה:

שלב 10: שליחת הודעות נוספות באמצעות לחצני הבקר

נתק את המיקרו: ביט של הרובוט, וחבר במקום זאת את המיקרו: ביט של הג'ויסטיק

חזור לקוד הבקר שלך כדי לערוך.

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

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

בעוד שזה נכון:

ג'ויסטיק = joystick_push () כפתור = button_press ()

button_press () מחזיר ערך A, B, C, D, E או F בהתאם ללחצן שנלחץ כרגע (אם לא לוחצים על כלום, הוא מחזיר None).

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

if כפתור == 'A':

radio.send ('שלום') sleep (500) elif button == 'B': radio.send ('ברווז') sleep (500) else: message = str (ג'ויסטיק [0]) + "" + str (ג'ויסטיק [1]) radio.send (הודעה) שינה (10)

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

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

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

האם זה עובד?

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

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

קישור לקוד עבודה:

שלב 11: השלבים הבאים

כעת יש לך את הידע הדרוש לך לעבודה עם מנועי הרובוט שלך, ועם בקר הג'ויסטיק: ביט

השתמש בידע זה כדי לשפר את שתי התוכניות ולהפוך אותן לשלך. כמה רעיונות למטה!

יש לך שישה כפתורים בבקר שלך! מה אתה רוצה שהם יעשו?

• מה דעתך לתכנת שגרת ריקודים שהרובוט שלך יעשה בפקודה? כתוב אלגוריתם של פקודות drive (), מופרדות באמצעות פקודות שינה ()!
• האם ברצונך לשנות את כיוון הרובוט לנוע, כך שיוכל לנהוג הפוך בקלות? חשוב על ערכי x ו- y של הג'ויסטיק שלך. מה הם מייצגים וכיצד אתה יכול לתפעל אותם?
• האם יש לרובוט שלך (או שאתה יכול להוסיף!) תכונות נוספות כגון נוריות LED, רמקול או חיישנים?

רעיונות לשיפור הקוד

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