צור רובוט מודרך לידאר עם הצ'גלבוט: 8 שלבים

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

במדריך זה אנו גורמים ל- GiggleBot להתמודד עם הקשיים של מבוך.

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

במקביל, ה- GiggleBot שולח נתונים אלה למיקרו ביט: BBC המרוחק המציג על מטריצת נוריות ה -5 על 5 שלו את מיקומו היחסי למכשולים.

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

זה נשמע כיף! בואו נרד, נכון?

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

אנחנו נצטרך:

1. בוג צחקק.
2. מארז סוללות ל- micro: bit של BBC. הוא מגיע יחד עם מיקרו: ביט של BBC בחבילה שלו.
3. סוללות x3 ל- GiggleBot.
4. כבל גרוב לחיבור חיישן המרחק ל- GiggleBot.
5. ערכת סרוו של חברת DexterIndustries.
6. x3 BBC מיקרו: ביטים. אחד עבור GiggleBot ואחד שנהג לשלוט ברובוט מרחוק.
7. חיישן מרחק של חברת DexterIndustries.

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

שלב 2: הרכבת הרובוט

כדי להפוך את ה- GiggleBot מוכן לתכנות, עלינו להרכיב אותו, אם כי אין הרבה מה לעשות.

הכנס את 3 סוללות ה- AA לתא שלה מתחת ל- GiggleBot.

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

בעת הרכבה של זרוע הסרוו על הסרוו, ודא שהסרוו כבר מכוון למיקום 80. תוכל לעשות זאת על ידי התקשרות ל- gigglebot.set_servo (gigglebot. RIGHT, 80). תוכל לקרוא עוד על כך כאן.

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

לבסוף, חבר את חיישן המרחק עם כבל Grove לכל אחת משתי יציאות I2C ומנוע הסרווו ליציאה הימנית היושבת ב- GiggleBot - היציאה הנכונה מוזכרת עליו.

שלב 3: צור מבוך משלך - אופציונלי

במקרה זה, השתמשתי בחבורה של קופסאות ליצירת מסלול לולאה סגורה, בדומה למסלול של NASCAR.

בשלב זה, אתה יכול להיות יצירתי באמת ולהפוך אותו לכמה שאתה מעוות או להפוך אותו לסופר ארוך כי זה באמת תלוי בך.

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

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

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

שלב 5: תכנות ה- GiggleBot - חלק א '

ראשית, בואו להגדיר את התסריט של GiggleBot. תסריט זה יגרום ל- GiggleBot לסובב את מנוע הסרוו שלו 160 מעלות (80 מעלות לכל כיוון) ובמקביל לקחת 10 קריאות מחיישן המרחק לכל סיבוב.

כשהוא מופעל, ה- GiggleBot יעמוד ליד עד שהוא יקבל פקודה מהשלט הרחוק. יכולות להיות רק 3 פקודות: קדימה, שמאלה או ימינה.

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

GiggleBot מבוסס LIDAR בשלט רחוק

מיבוא gigglebot*

מאת distance_sensor יבוא DistanceSensor

משינה של ייבוא מיקרוביט

מאת utime יבוא ticks_us, sleep_us

ייבוא מבנה

ייבוא רדיו

# עצור את הרובוט אם הוא כבר זז

תפסיק()

# אפשר רדיו

radio.on ()

אובייקט חיישן מרחק #

ds = DistanceSensor ()

ds.start_continuous ()

rotate_time = 0.7# נמדד בשניות

rotate_span = 160# נמדד במעלות

rotate_steps = 10

תקרה_תקורה = 1.05# המוגדרת באחוזים

time_per_step = 10 ** 6* rotate_time / (rotate_steps* overhead_compensation)

שעון אחרון = 0

מכ"ם = bytearray (rotate_steps)

servo_rotate_direction = 0# 0 לעלייה כלפי מעלה (0-> 160) ו- 1 אחרת

radar_index = 0

set_servo (RIGHT, 0)

whileTrue:

# קראו מהרדאר

אם ticks_us () - שעון_קריאה אחרון> זמן_פעם_צעד:

# נקרא מחיישן המרחק

מכ"ם [radar_index] = int (ds.read_range_continuous () /10)

אחרון_קרי_זמן = ticks_us ()

הדפס (radar_index)

# עשו את ההיגיון לסיבוב הסרוו משמאל לימין

אם radar_index == rotate_steps -1and servo_rotate_direction == 0:

set_servo (RIGHT, 0)

servo_rotate_direction = 1

elif radar_index == 0and servo_rotate_direction == 1:

set_servo (RIGHT, rotate_span)

servo_rotate_direction = 0

אַחֵר:

radar_index += 1if servo_rotate_direction == 0else-1

# ושלח את ערכי המכ"ם

radio.send_bytes (מכ"ם)

לְנַסוֹת:

# קרא פקודות רובוט

lmotor, rmotor = ustruct.unpack ('bb', radio.receive_bytes ())

# והפעל את המנועים אם יהיו פקודות שהתקבלו

set_speed (lmotor, rmotor)

נהיגה()

exceptTypeError:

לַעֲבוֹר

הצג rawgigglebot_lidar_robot.py המתארח אצל ❤ על ידי GitHub

שלב 6: תכנות השלט - חלק ב '

מה שנותר לעשות הוא לתכנת את ה- micro: bit השני של ה- BBC שפועל כשלט.

השלט משמש להצגת המסך מתוצרת 5 על 5 פיקסלים שלו על המרחק היחסי למכשולים. לכל היותר יהיו 10 פיקסלים מופעלים.

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

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

GiggleBot מבוסס LIDAR נשלט מרחוק - קוד מרחוק

מ- microbit יבוא שינה, תצוגה, button_a, button_b

ייבוא מבנה

ייבוא רדיו

מתמטיקה יבוא

radio.on ()

rotate_steps = 10

rotate_span = 160# במעלות

rotate_step = rotate_span / rotate_steps

מרחק מקסימלי = 50# בסנטימטרים

side_length_leds = 3 # נמדד במספר הפיקסלים

מכ"ם = bytearray (rotate_steps)

xar = bytearray (rotate_steps)

yar = bytearray (rotate_steps)

save_xar = bytearray (rotate_steps)

save_yar = bytearray (rotate_steps)

motor_speed = 50

whileTrue:

status = radio.receive_bytes_into (מכ"ם)

אם המצב אינו קיים:

# display.clear ()

עבור c, val אינספור (מכ"ם):

אם מכ"ם [c] <= max_distance:

# חשב קואורדינטות 2d של כל מרחק

זווית = rotate_steps / (rotate_steps -1) * rotate_step * c

זווית += (180- rotate_span) /2.0

x_c = math.cos (זווית * math.pi /180.0) * מכ"ם [c]

y_c = math.sin (זווית * math.pi /180.0) * מכ"ם [c]

# קנה מידה את המרחקים כך שיתאימו לתצוגת המיקרוביט בגודל 5x5

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# קואורדינטות מיקום מחדש

x_c += (צד_אורך_דורות -1)

y_c = (side_length_leds +1) - y_c

# קואורדינטות עגולות בדיוק היכן נמצאות הנורות

אם x_c - רצפת מתמטיקה (x_c) <0.5:

x_c = רצפה מתמטית (x_c)

אַחֵר:

x_c = math.ceil (x_c)

אם y_c - רצפת מתמטיקה (y_c) <0.5:

y_c = רצפת מתמטיקה (y_c)

אַחֵר:

y_c = math.ceil (y_c)

xar [c] = x_c

yar [c] = y_c

אַחֵר:

xar [c] = 0

yar [c] = 0

display.clear ()

עבור x, y inzip (xar, yar):

display.set_pixel (x, y, 9)

# הדפסה (רשימה (zip (xar, yar, radar)))

stateA = button_a.is_pressed ()

stateB = button_b.is_pressed ()

אם stateA ו- stateB:

radio.send_bytes (ustruct.pack ('bb', motor_speed, motor_speed))

הדפס ('קדימה')

אם stateA ולא מצב B:

radio.send_bytes (ustruct.pack ('bb', motor_speed, -motor_speed))

הדפס ('שמאל')

ifnot stateA ו- state B:

radio.send_bytes (ustruct.pack ('bb', -motor_speed, motor_speed))

הדפס ('מימין')

ifnot stateA ו- not state B:

radio.send_bytes (ustruct.pack ('bb', 0, 0))

הדפס ('עצור')

הצג rawgigglebot_lidar_remote.py המתארח אצל ❤ על ידי GitHub

שלב 7: פרשנות המסך המרוחק

"loading =" עצלן "לשלוט ב- GiggleBot, יש לך את האפשרויות הבאות:

1. לחץ על כפתור A ולחצן B כדי להזיז את ה- GiggleBot קדימה.
2. לחץ על כפתור A כדי לסובב את ה- GiggleBot שמאלה.
3. לחץ על כפתור B כדי לסובב את ה- GiggleBot ימינה.

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