כוונון עוקב קו GiggleBot - מתקדם: 7 שלבים

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

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

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

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

תזדקק לדברים הבאים:

1. רובוט GiggleBot למיקרו: ביט.
2. x3 סוללות AA
3. x2 BBC micro: bits - אחד ל- GiggleBot והשני משמש כשלט לכוונון פרמטרים.
4. סוללה למיקרו: ביט של BBC - כמו זו המגיעה בתוך חבילת המיקרו: ביט של BBC.

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

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

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

מכיוון שהדרכה זו קשורה מאוד להדרכה אחרת זו שכותרתה GiggleBot Line Follower, פשוט לך לשם ופעל לפי שלבים 2 ו -3 ואז חזור לכאן.

באשר ל- IDE, אתה יכול להשתמש בעורך Mu ובזמן הריצה אתה צריך להוריד את GiggleBot MicroPython Runtime. ניתן להוריד את זמן הריצה מתיעוד שלו כאן. עברו לפרק תחילת העבודה של התיעוד ופעלו לפי ההנחיות בנושא הגדרת הסביבה. נכון לרגע זה, נעשה שימוש בגרסה v0.4.0 של זמן הריצה.

שלב 3: הגדרת ה- GiggleBot

לפני שמבהבים את זמן הריצה ל- GiggleBot, וודא שבחרת את המהירות ואת קצב העדכון הרצוי עבור GiggleBot: כברירת מחדל, המהירות מוגדרת ל- 100 (משתנה base_speed) וקצב העדכון מוגדר ל- 70 (משתנה update_rate).

בהתחשב ביישום הנוכחי, קצב העדכון הגבוה ביותר שניתן להשיג הוא 70 ואם run_neopixels מוגדר ל- True, ניתן להשיג רק 50. אז במובן מסוים, אפשר לומר שקצב עדכון ברירת המחדל נמצא ממש בקצה מה שהמיקרו: ביט של BBC יכול לעשות.

ליתר דיוק, חיישן עוקבי הקווים יכול להחזיר עדכונים 100 פעמים בשנייה.

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

מקלט עוקב GIDGBOT PID Line (דורש שלט כדי לכוון אותו) - xjfls23

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

מיבוא gigglebot*

מאת utime יבוא sleep_ms, ticks_us

ייבוא רדיו

ייבוא מבנה

# לאתחל רדיו ו- neopixels GB

radio.on ()

ניאו = init ()

# תזמון

update_rate = 70

# ערכי רווח ברירת מחדל

Kp = 0.0

Ki = 0.0

Kd = 0.0

נקודת ערך = 0.5

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

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

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

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

סה"כ זמן = 0.0

סך כל_ספרים = 0

whileTrue:

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

אם button_a.is_pressed ():

לרוץ = נכון

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

אם button_b.is_pressed ():

הפעלה = שקר

אינטגרל = 0.0

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

display.scroll ('{} - {}'. פורמט (total_time, total_counts), עיכוב = 100, המתנה = שקר)

סה"כ זמן = 0.0

סך כל_ספרים = 0

pixels_off ()

תפסיק()

שנת_מס (500)

if run isTrue:

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

start_time = ticks_us ()

# בדוק אם עדכנו את רווחי ה- Kp/Kd באמצעות שלט

לְנַסוֹת:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack ('fffff', radio.receive_bytes ())

set_eyes ()

exceptTypeError:

לַעֲבוֹר

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

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

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

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

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

לְנַסוֹת:

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

למעט ZeroDivisionError:

מיקום = 0.5

אם מיקום == 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 - תיקון

# הדליק את הניאופיקסלים כדי להראות לאיזה כיוון GiggleBot צריך ללכת

אם 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] = (12, 44, 41)

אַחֵר:

neo [center_pixel - 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 (12* אחוז), int (44* אחוז), אינט (41* אחוז))

אַחֵר:

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

neo [center_pixel - i] = (int (12* אחוז), int (44* אחוז), אינט (41* אחוז))

לשבור

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

total_time += delay_diff

סה"כ מספרים = 1

if1.0/ update_rate - delay_diff> 0:

sleep (1.0/ update_rate - delay_diff)

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

שלב 4: הגדרת הטונר (מרחוק)

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

1. Kp = רווח יחסי לבקר ה- PID.
2. Ki = רווח אינטגרלי עבור בקר ה- PID.
3. Kd = רווח נגזר עבור בקר ה- PID.
4. trigger_point = הנקודה המתבטאת באחוזים בין המהירות המינימלית והמקסימלית של ה- GiggleBot שבה המהירות מתחילה לרדת באופן לינארי עד שהיא מגיעה למהירות המינימלית.
5. min_speed_percent = המהירות המינימלית המתבטאת באחוזים מהמהירות המרבית.

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

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

מקלט עוקב מקוון PID GiggleBot מרחוק (דורש את החלק השני) - xjfls23

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

מאת utime יבוא sleep_ms

ייבוא רדיו

ייבוא מבנה

האלמנט הראשון הוא רווח ה- Kp

האלמנט השני הוא רווח ה- Ki

האלמנט השלישי הוא רווח ה- Kd

האלמנט הרביעי # הוא נקודת ההדק של מנועים להורדת המהירות (0 -> 1)

האלמנט החמישי הוא מהירות המינימום של מנועים כפי שהיא מתבטאת באחוזים (0 -> 1)

רווחים = [0.0, 0.0, 0.0, 1.0, 0.0]

stepSize = 0.1

מס '0 ו -1 לאלמנט הראשון

מס '2 ו -3 לאלמנט השני

currentSetting = 0

defshowMenu ():

display.scroll ('{} - {}'. פורמט (currentSetting, רווחים [int (currentSetting /2)]), עיכוב = 100, המתנה = שקר)

radio.on ()

הראה תפריט()

whileTrue:

מעודכן = שקר

אם button_a.is_pressed ():

currentSetting = (currentSetting +1) % (2*5)

מעודכן = נכון

אם button_b.is_pressed ():

אם currentSetting %2 == 0:

# הגדלת הרווח כאשר הנוכחי הגדרה הוא 0 או 2 או..

ifint (currentSetting /2) ב- [0, 2]:

רווחים [int (currentSetting /2)] += 10* stepSize

אַחֵר:

רווחים [int (currentSetting /2)] += stepSize

אַחֵר:

# הגדלת הרווח כאשר הנוכחי הגדרה הוא 1 או 3 או..

ifint (currentSetting /2) ב- [0, 2]:

רווחים [int (currentSetting /2)] -= 10* stepSize

אַחֵר:

gain [int (currentSetting /2)] -= stepSize

radio.send_bytes (ustruct.pack ('fffff', *רווחים))

מעודכן = נכון

אם מעודכן:

הראה תפריט()

שנת_מס (200)

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

שלב 5: כוונון ה- GiggleBot

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

כדי להפעיל את ה- GiggleBot, לחץ על כפתור A על ה- micro: bit של ה- GiggleBot כדי לעצור אותו ובכך לאפס את מצבו לחץ על כפתור B.

במיקרו: bit המרוחק של BBC, לחיצה על כפתור A תעביר אותך בכל אפשרות בתפריט שלו ולחצן B מגביר/מקטין את הערך המתאים. זה כמו להציב את השעון בלוח המחוונים של מכונית ישנה. האפשרויות הן כך:

1. 0-1 אפשרויות מיועדות לרווח Kp.
2. 2-3 אפשרויות הן לרווח Ki.
3. 4-5 אפשרויות הן לרווח Kd.
4. 6-7 אפשרויות הן לקביעת נקודת ההתחלה לרגע שבו המנועים מתחילים להאט.
5. 8-9 אפשרויות מיועדות להגדרת המהירות המינימלית.

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

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

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

סט ראשון של כוונון הפרמטרים (עם נוריות NeoPixel כבויות)

1. Kp = 32.0
2. Ki = 0.5
3. Kd = 80.0
4. trigger_setpoint = 0.3 (שהם 30%)
5. min_speed_percent = 0.2 (שזה 20%)
6. מהירות בסיס = 100 (גם מהירות מרבית)
7. update_rate = 70 (פועל @70Hz)

סט שני של כוונון הפרמטרים (כאשר נוריות ה- NeoPixel דולקות)

1. Kp = 25.0
2. Ki = 0.5
3. Kd = 35.0
4. trigger_setpoint = 0.3 (שהם 30%)
5. min_speed_percent = 0.3 (שהם 30%)
6. מהירות בסיס = 70 (מהירות מקסימלית)
7. update_rate = 50 (פועל @50Hz)
8. כמו כן, משתנה run_neopixels חייב להיות מוגדר ל- True בתסריט שנטען ב- micro: bit של ה- GiggleBot ב- BBC. זה יגרום לנורות ה- NeoPixel להבהב באופן שיצביעו לאיזה כיוון השגיאה מצטברת.

שלב 6: ריצה של GiggleBot כשה NeoPixels כבויים

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

שלב 7: ריצת GiggleBot כשהופעלו ה- Neopixels

זוהי דוגמה להפעלת ה- GiggleBot עם הסט השני של פרמטרי הכוונון שנמצאו בשלב 5. בדוגמה זו מופעלות נוריות ה- NeoPixel.

שימו לב כיצד בדוגמה זו, ל- GiggleBot קשה יותר לעקוב אחר הקו - זאת מכיוון שנוריות ה- Neopixel "אוכלות" את זמן המעבד של ה- micro: bit של ה- BBC. לכן נאלצנו להפחית את קצב העדכונים מ -70 עד 50.