עוקב קו GiggleBot באמצעות פייתון: 5 שלבים

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

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

יש לשייך את ה- GiggleBot למיקרו ביט: BBC כדי לשלוט בו כראוי.

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

שלב 1: רכיבים נדרשים

דרושים רכיבי החומרה הבאים:

1. סוללות x3 AA - במקרה שלי אני משתמש בסוללות נטענות בעלות מתח נמוך יותר.
2. רובוט GiggleBot של Dexter Industries למיקרו: ביט.
3. מיקרו של BBC: ביט.

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

קבל את GiggleBot למיקרו: ביט כאן

שלב 2: הגדר את הרצועות

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

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

• 12 אריחים מסוג 1.
• 5 אריחים מסוג 2.
• 3 תבניות מסוג אריח מס '5.
• 3 תבניות מסוג אריח מס '6 - כאן תקבל אריח נוסף אחד.

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

שלב 3: הגדרת הסביבה

על מנת שתוכל לתכנת את ה- micro: bit של ה- BBC ב- MicroPython, עליך להגדיר עורך עבורו (עורך מו) ולהגדיר את Runtime GiggleBot MicroPython כזמן הריצה שלו. לשם כך עליך לעקוב אחר ההוראות המופיעות בדף זה. נכון לרגע זה, נעשה שימוש בגרסה v0.4.0 של זמן הריצה.

שלב 4: תכנות ה- GiggleBot

לפני שמתחילים לעסוק בזה, זמן הריצה של GiggleBot MicroPython מכיל את זמן הריצה הקלאסי של ה- micro: bit של BBC וספריות אחרות לתמיכה ב- GiggleBot ובחיישני Dexter Industries אחרים.

לאחר הגדרתו, פתח את הסקריפט הבא בעורך Mu ולחץ על Flash. פעולה זו תבהב את זמן הריצה של GiggleBot MicroPython ואת התסריט שפתחת זה עתה למיקרו: bit של ה- BBC שלך. התסריט מוצג גם למטה.

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

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

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

עוקב קו PID של GiggleBot - מכוון עם NeoPixels

מיבוא מיקרוביט*

מיבוא gigglebot*

מאת utime יבוא sleep_ms, ticks_us

ייבוא מבנה

# לאתחל GB neopixels

ניאו = init ()

# תזמון

update_rate = 50

# רווחים/קבועים (בהנחה שמתח הסוללה הוא סביב 4.0 וולט)

Kp = 25.0

Ki = 0.5

Kd = 35.0

נקודה טריגר = 0.3

מהירות_מהירות = 0.3

מהירות בסיס = 70

נקודת ערך = 0.5

last_position = נקודת ערך

אינטגרל = 0.0

run_neopixels = נכון

center_pixel = 5# שבו הפיקסל המרכזי של החיוך נמצא ב- GB

# טורקיז = tuple (מפה (lambda x: int (x / 5), (64, 224, 208))) # צבע לשימוש כדי לצייר את השגיאה עם הניאופיקסלים

# טורקיז = (12, 44, 41) # שזה בדיוק הטורקיז הנ"ל הגיב מעל זה

error_width_per_pixel = 0.5/3# שגיאה מקסימלית חלקי מספר הפלחים בין כל neopixel

צמצום_בונד_ליניארי_מהירות_הפחתה (abs_error, trigger_point, upper_bound, small_motor_power, מיטב_כוח המנוע):

מהירות בסיס גלובלית

אם abs_error> = trigger_point:

# x0 = 0.0

# y0 = 0.0

# x1 = upper_bound - trigger_point

# y1 = 1.0

# x = abs_error - trigger_point

# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

# כמו

y = (abs_error - trigger_point) / (upper_bound - trigger_point)

motor_power = base_speed * (smallest_motor_power + (1- y) * (הגבוה ביותר_מנוע_כוח - הקטנה_מנוע_כוח))

להחזיר את כוח המנוע

אַחֵר:

החזר בסיס_מהירות * כוח_מנוע גבוה ביותר

הפעלה = שקר

שגיאה קודמת = 0

whileTrue:

# אם נלחץ על כפתור a התחל לעקוב

אם button_a.is_pressed ():

לרוץ = נכון

# אך אם נלחץ על כפתור ב עצור את עוקב השורה

אם button_b.is_pressed ():

הפעלה = שקר

אינטגרל = 0.0

שגיאה קודמת = 0.0

pixels_off ()

תפסיק()

שנת_מס (500)

if run isTrue:

# קרא את חיישני הקו

start_time = ticks_us ()

ימין, שמאל = read_sensor (LINE_SENSOR, BOTH)

קו # משמאל כאשר המיקום <0.5

קו # מימין כאשר המיקום> 0.5

קו # באמצע כאשר המיקום = 0.5

# זהו ממוצע אריתמטי משוקלל

לְנַסוֹת:

מיקום = ימין /צף (שמאל + ימין)

למעט ZeroDivisionError:

מיקום = 0.5

# הטווח חייב להיות (0, 1) ולא [0, 1]

אם מיקום == 0: מיקום = 0.001

אם מיקום == 1: מיקום = 0.999

# השתמש בבקר PD

שגיאה = מיקום - נקודת ערך

אינטגרל += שגיאה

תיקון = Kp * שגיאה + Ki * אינטגרל + Kd * (שגיאה - הקודם_טעות)

הקודם_טעות = שגיאה

# לחשב את מהירות המנוע

motor_speed = upper_bound_linear_speed_reducer (abs (error), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + תיקון

rightMotorSpeed = motor_speed - תיקון

# להאיר את neopixels בהתאם לשגיאה הנתונה

אם run_neopixels isTrueand total_counts %3 == 0:

עבור i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

ניאו = (0, 0, 0)

עבור i inb '\ x00 / x01 / x02 / x03':

ifabs (שגיאה)> error_width_per_pixel * i:

אם שגיאה <0:

# ניאו [מרכז_פיקסל + i] = טורקיז

ניאו [מרכז_פיקסל + i] = (12, 44, 41)

אַחֵר:

# ניאו [מרכז_פיקסל - i] = טורקיז

ניאו [מרכז_פיקסל + i] = (12, 44, 41)

אַחֵר:

אחוז = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# להדליק את הפיקסל הנוכחי

אם שגיאה <0:

# neo [center_pixel + i] = tuple (מפה (lambda x: int (x * אחוז), טורקיז))

neo [center_pixel + i] = (int (64* אחוז /5), int (224* אחוז /5), int (208* אחוז /5))

אַחֵר:

# neo [center_pixel - i] = tuple (מפה (lambda x: int (x * אחוז), טורקיז))

neo [center_pixel - i] = (int (64* אחוז /5), int (224* אחוז /5), int (208* אחוז /5))

לשבור

neo.show ()

לְנַסוֹת:

# קליפ את מהירויות המנוע

אם נשאר MotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

אם נכון MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - ימין MotorSpeed +100

אם נשאר MotorSpeed <-100:

leftMotorSpeed = -100

אם נכון MotorSpeed <-100:

rightMotorSpeed = -100

# הפעל את המנועים

set_speed (leftMotorSpeed, rightMotorSpeed)

נהיגה()

# הדפס ((שגיאה, מהירות מנוע))

מלבד:

# למקרה שנקלע לבעיה בלתי ניתנת לתיקון

לַעֲבוֹר

# ולשמור על תדר הלולאה

סוף_זמן = ticks_us ()

delay_diff = (end_time - start_time) /1000

if1000.0/ update_rate - delay_diff> 0:

sleep (1000.0/ update_rate - delay_diff)

הצג rawgigglebot_tuned_line_follower.py המתארח אצל ❤ מאת GitHub

שלב 5: לתת לזה לרוץ

ישנם 2 כפתורים במיקרו: ביט של כפתור A ולחצן ב ':

• לחיצה על כפתור A קובעת את ה- GiggleBot לעקוב אחר הקו (אם יש כזה).
• לחיצה על כפתור B עוצרת את ה- GiggleBot ומאפסת הכל כך שתוכל להשתמש בו שוב.

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