- בחירת החלקים לרובוט לאיזון עצמי
- הדפסת תלת מימד והרכבת הרובוט המאזן העצמי שלנו
- תרשים מעגל
- קוד רובוט מאזן עצמי
- עבודה של רובוט איזון עצמי של Arduino
לאחר שקיבלתי השראה ממנועי RYNO וקטנועים אחרים עם איזון עצמי מסגווי, תמיד רציתי לבנות משהו של רובוט סגווי של ארדואינו. במחשבה לזמן מה החלטתי לבנות רובוט לאיזון עצמי באמצעות ארדואינו. בדרך זו אוכל להבין את הרעיון העומד מאחורי כל הקטנועים הללו וללמוד גם כיצד פועל אלגוריתם PID.
ברגע שהתחלתי לבנות, הבנתי שהבוט הזה הוא קצת אתגר לבנות. יש כל כך הרבה אפשרויות לבחירה ולכן הבלבולים מתחילים בצורה נכונה בבחירת המנועים ונותרים עד לכוונון ערכי PID. ויש לקחת כל כך הרבה דברים כמו סוג סוללה, מיקום סוללה, אחיזת גלגל, סוג נהג מנוע, שמירה על ה- CoG (מרכז הכובד) ועוד ועוד.
אבל תן לי לשבור לך את זה, ברגע שתבנה את זה תסכים שזה לא כל כך קשה כמו שזה נשמע. אז בואו נודה בזה, במדריך זה אתעד את ניסיוני בבניית הרובוט המאזן העצמי. יכול להיות שאתה מתחיל מוחלט שרק מתחיל או אולי נחת כאן אחרי תסכול ארוך מכך שלא הביא את הבוט שלך לעבודה. המקום הזה נועד להיות היעד הסופי שלך. אז בואו נתחיל……
בחירת החלקים לרובוט לאיזון עצמי
לפני שאגיד לכם את כל האפשרויות לבניית הבוט, הרשו לי לרשום את הפריטים בהם השתמשתי בפרויקט הרובוט האיזון העצמי הזה
- ארדואינו UNO
- מנועי DC ממונעים (בצבע צהוב) - 2Nos
- מודול נהג מנוע L298N
- MPU6050
- זוג גלגלים
- 7.4V סוללת ליתיום
- חוטי חיבור
- גוף מודפס בתלת מימד
אתה יכול לערבב ולבחור את כל אחד מהרכיבים הנ"ל על בסיס הזמינות להכין ערכת רובוטים מאוזנים בעצמך, רק וודא שהרכיבים תואמים לקריטריונים הבאים.
בקר: הבקר בו השתמשתי כאן הוא Arduino UNO, מדוע מכיוון שהוא פשוט קל לשימוש. אתה יכול גם להשתמש ב- Arduino Nano או Arduino mini, אבל אני ממליץ לך להישאר עם UNO מכיוון שנוכל לתכנת אותו ישירות ללא חומרה חיצונית.
מנועים: הבחירה הטובה ביותר של המנוע שתוכלו להשתמש בו לרובוט לאיזון עצמי, ללא ספק תהיה מנוע צעד. אבל כדי לשמור על דברים פשוטים השתמשתי במנוע הילוכים DC. כן אין חובה להחזיק צעד; הבוט עובד מצוין גם עם מנועי הילוך DC זולים בצבע צהוב נפוץ.
נהג מנוע: אם בחרתם במנועי הילוכים DC כמוני, תוכלו להשתמש במודול הנהג L298N כמוני, או אפילו L293D אמור לעבוד בסדר גמור. למידע נוסף על שליטה במנוע DC באמצעות L293D ו- Arduino.
גלגלים: אין להעריך בחורים האלה; היה לי קשה להבין שהבעיה בגלגלים שלי. אז וודאו שלגלגלים שלכם אחיזה טובה ברצפה בה אתם משתמשים. צפה מקרוב, האחיזה שלך לעולם לא תאפשר לגלגלים שלך להחליק על הרצפה.
מד תאוצה וג'ירוסקופ: הבחירה הטובה ביותר של תאוצה וג'ירוסקופ עבור הבוט שלך תהיה MPU6050. אז אל תנסו לבנות אחד עם תאוצה רגיל כמו ADXL345 או משהו כזה, זה פשוט לא יעבוד. תדע מדוע בסוף מאמר זה. אתה יכול גם לבדוק את המאמר הייעודי שלנו בנושא שימוש ב- MPU6050 עם Arduino.
סוללה: אנו זקוקים לסוללה קלה ככל האפשר ומתח ההפעלה צריך להיות יותר מ -5 וולט כדי שנוכל להניע את הארדואינו ישירות ללא מודול דחיפה. אז הבחירה האידיאלית תהיה סוללת ליתיום פולימר 7.4V. הנה, מכיוון שהיה לי סוללת ליתיום 7.4V זמינה, השתמשתי בה. אבל זכרו שליפו הוא יתרון מאשר ליון.
שלדה: מקום אחר שבו אתה לא צריך להתפשר הוא עם שלדת הבוטים שלך. אתה יכול להשתמש בקרטון, עץ, פלסטיק בכל דבר שאתה טוב איתו. אבל, רק וודאו שהשלדה יציבה ולא אמורה להתנועע כשהבוט מנסה לאזן. תכננתי על ידי שלדה משלימה על Solidworks והסקתי מהבוטים האחרים והדפסתי אותה בתלת ממד. אם יש לך מדפסת, תוכל גם להדפיס את העיצוב, קבצי העיצוב יצורפו בכותרת הקרובה.
הדפסת תלת מימד והרכבת הרובוט המאזן העצמי שלנו
אם החלטתם להדפיס תלת מימד את אותה שלדה בה אני משתמש לבניית הבוט שלי, ניתן להוריד את קבצי ה- STL מ- thingiverse. הוספתי גם את קבצי העיצוב יחד איתו, כך שתוכל גם לשנות אותו בהתאם להעדפות הצוות שלך.
לחלקים אין מבנים תלויים כך שתוכלו להדפיס אותם בקלות ללא תומכים ומילוי של 25% יעבוד בסדר. העיצובים די פשוטים וכל מדפסת בסיסית אמורה להיות מסוגלת להתמודד עם זה בקלות. השתמשתי בתוכנת הקורה כדי לחתוך את הדגם והדפסתי באמצעות טרנטולה Tevo שלי, ההגדרה מוצגת למטה.
יהיה עליכם להדפיס את חלקי הגוף כמו גם ארבעה חלקי הרכבה למנוע. ההרכבה די ישר קדימה; השתמש באומים ובברגים של 3 מ"מ כדי לאבטח את המנוע והלוחות במקומם. לאחר ההרכבה הוא אמור להיראות בערך כך המוצג בתמונה למטה.
התכנון בפועל תוכנן עם מודול הכונן L298N במעמד התחתון של הארדואינו והסוללה עליו כפי שמוצג לעיל. אם אתה מבצע את אותה ההזמנה אתה יכול לדפוק ישירות את הלוח באמצעות החורים המסופקים ולהשתמש בתווית חוט לסוללת Li-po. הסדר זה אמור לעבוד גם, למעט הגלגלים הסופר פשוטים שהייתי צריך לשנות אחר כך.
בבוט שלי החלפתי את עמדת הסוללה ולוח ה- UNO של ארדואינו על מנת להקל על התכנות ונאלצתי גם להציג לוח מושלם להשלמת החיבורים. אז הבוט שלי לא נראה כמו שתכננתי בשלב הראשוני. לאחר השלמת בדיקות תכנות החיווט והכל, הרובוט הדו-גלגלי שלי סוף סוף נראה ככה
תרשים מעגל
יצירת החיבורים לרובוט לאיזון עצמי מבוסס Arduino זה די פשוט. זהו רובוט מאזן עצמי המשתמש ב- Arduino ו- MPU6050 ולכן אנו רוצים לממשק את ה- MPU6050 עם Arduino ולחבר את המנועים באמצעות מודול מנהל התקן המנוע. כל המערך מופעל על ידי סוללת ליתיום 7.4V. תרשים המעגל עבור אותו מוצג להלן.
ה- Arduino ומודול הנהג המנוע L298N מופעל ישירות דרך סיכת Vin ומסוף 12V בהתאמה. הרגולטור על הלוח בלוח Arduino ימיר את הקלט 7.4V ל- 5V וה- ATmega IC ו- MPU6050 יופעלו על ידיו. מנועי DC יכולים לפעול ממתח 5V עד 12V. אבל אנו נחבר את החוט החיובי 7.4V מהסוללה למסוף קלט 12V של מודול נהג המנוע. זה יגרום למנועים לפעול עם 7.4 וולט. הטבלה הבאה תפרט כיצד מודול נהג המנוע MPU6050 ו- L298N מחובר לארדואינו.
|
סיכת רכיב |
פין ארדואינו |
|
MPU6050 |
|
|
Vcc |
+ 5 וולט |
|
קרקע, אדמה |
Gnd |
|
SCL |
A5 |
|
SDA |
A4 |
|
INT |
D2 |
|
L298N |
|
|
IN1 |
D6 |
|
IN2 |
D9 |
|
IN3 |
D10 |
|
IN4 |
D11 |
ה- MPU6050 מתקשר עם Arduino דרך ממשק I2C, לכן אנו משתמשים בסיכות SPI A4 ו- A5 של Arduino. מנועי DC מחוברים לסיכות PWM D6, D9 D10 ו- D11 בהתאמה. עלינו לחבר אותם לסיכות PWM מכיוון שנשלוט במהירות של מנוע DC על ידי שינוי מחזור החובה של אותות ה- PWM. אם אינך מכיר את שני המרכיבים הללו, מומלץ לקרוא את המדריך לממשקים MPU6050 ו- L298N.
קוד רובוט מאזן עצמי
עכשיו עלינו לתכנת את לוח ה- UNO של ארדואינו כדי לאזן את הרובוט. כאן קורה כל הקסם; הרעיון שמאחוריו פשוט. עלינו לבדוק אם הבוט נוטה לפנים או לאחור באמצעות MPU6050 ואז אם הוא נוטה לפנים עלינו לסובב את הגלגלים לכיוון קדימה ואם הוא נוטה לאחור עלינו לסובב את הגלגלים בכיוון ההפוך.
במקביל עלינו גם לשלוט במהירות בה הגלגלים מסתובבים, אם הבוט מעט מבולבל ממצב המרכז הגלגלים מסתובבים לאט והמהירות עולה ככל שהוא מתרחק יותר ממצב המרכז. כדי להשיג לוגיקה זו אנו משתמשים באלגוריתם PID, שמיקום המרכז הוא כנקודת נקודה ורמת הדיסאוריינטציה כפלט.
כדי לדעת את המיקום הנוכחי של הבוט אנו משתמשים ב- MPU6050, שהוא מד תאוצה וחיישן ג'ירוסקופ בשילוב. על מנת לקבל ערך מהימן של המיקום מהחיישן עלינו להשתמש בערך מד תאוצה וגם גירוסקופ, מכיוון שלערכים ממד התאוצה יש בעיות רעש והערכים מגירוסקופ נוטים להיסחף עם הזמן. אז עלינו לשלב את שניהם ולקבל את ערך גובה הלסת והגלגול של הרובוט שלנו, ממנו נשתמש רק בערך של הלסת.
נשמע קצת ראש מסתובב נכון? אך אל דאגה אל תודות לקהילת Arduino יש לנו ספריות זמינות שיכולות לבצע את חישוב ה- PID ולקבל גם את הערך של yaw מה- MPU6050. הספרייה פותחה על ידי br3ttb ו- jrowberg בהתאמה. לפני שתמשיך להוריד את הספריות שלהם צרו את הקישור הבא והוסיפו אותם לספריית ה- Arduino lib שלכם.
github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h
github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050
עכשיו, לאחר שהספריות נוספו ל- Arduino IDE שלנו. נתחיל לתכנת לרובוט המאזן העצמי שלנו. כמו תמיד הקוד השלם לרובוט האיזון MPU6050 ניתן בסוף עמוד זה, הנה אני רק מסביר את הקטעים החשובים ביותר בקוד. נאמר קודם שהקוד נבנה על גבי קוד הדוגמה MPU6050, אנחנו רק הולכים לייעל את הקוד למטרתנו ולהוסיף את טכניקת ה- PID והשליטה לרובוט המאזן העצמי שלנו.
ראשית אנו כוללים את הספריות הנדרשות כדי שתוכנית זו תפעל. הם כוללים את ספריית I2C המובנית, ספריית PID וספריית MPU6050 שהורדנו זה עתה.
# כלול "I2Cdev.h" #
כלול
לאחר מכן אנו מצהירים על המשתנים הנדרשים לקבלת הנתונים מחיישן MPU6050. אנו קוראים הן את וקטור הכבידה והן את ערכי הרבעון ואז מחשבים את ערך המגרש והגלגול של הבוט. Ypr מערך לצוף יקיים את התוצאה הסופית.
// בקרת MPU / סטטוס vars bool dmpReady = false; // להגדיר נכון אם DMP init הצליח uint8_t mpuIntStatus; // מחזיק בתים במצב הפרעה בפועל מ- MPU uint8_t devStatus; // להחזיר סטטוס לאחר כל פעולת מכשיר (0 = הצלחה ,! 0 = שגיאה) uint16_t packetSize; // גודל מנות DMP צפוי (ברירת המחדל היא 42 בתים) uint16_t fifoCount; // ספירת כל הבתים שנמצאים כעת ב- FIFO uint8_t fifoBuffer; // חיץ אחסון FIFO // כיוון / תנועה vars Quaternion q; // מיכל הקוואטרניון VectorFloat הכבידה; // וקטור כוח הכבידה לצוף ypr; // מיכל פיה / זפת / גליל וקטור כוח הכבידה
לאחר מכן מגיע הקטע החשוב מאוד של הקוד, וכאן תשקיע זמן רב בכוונון ערכת הערכים הנכונה. אם הרובוט שלך בנוי עם מרכז כובד טוב מאוד והרכיבים מסודרים בצורה סימטרית (מה שברוב המקרים לא), אז ערך נקודת ההגדרה שלך יהיה 180. אחרת חבר את הבוט שלך לצג סדרתי של Arduino והטה אותו עד אתה מוצא עמדת איזון טובה, קרא את הערך המוצג בצג הסדרתי וזה ערך הנקודה שלך. הערך של Kp, Kd ו- Ki צריך להיות מכוון בהתאם לבוט שלך. בשני בוטים זהים לא יהיו אותם ערכים של Kp, Kd ו- Ki ולכן אין מנוס ממנו. צפו בסרטון בסוף עמוד זה כדי לקבל מושג כיצד להתאים את הערכים הללו.
/ ********* כוון את 4 הערכים הללו עבור ה- BOT שלך ********* / setpoint כפול = 176; // הגדר את הערך כאשר הבוט מאונך לקרקע באמצעות צג סדרתי. // קרא את תיעוד הפרויקט באתר circuitdigest.com כדי ללמוד כיצד להגדיר ערכים אלה כפול Kp = 21; // הגדר Kd כפול ראשון זה = 0.8; // הגדר כפל שני זה Ki = 140; // סוף סוף הגדר / ****** הגדרת סוף הערכים ********* /
בשורה הבאה אנו מאותחלים את אלגוריתם ה- PID על ידי העברת משתני הקלט קלט, פלט, נקודת סט, Kp, Ki ו- Kd. מתוך אלה כבר הגדרנו את הערכים של נקודת ההגדרה Kp, Ki ו- Kd בקטע הקוד שלמעלה. ערך הקלט יהיה הערך הנוכחי של הלחץ הנקרא מחיישן MPU6050 וערך הפלט יהיה הערך המחושב על ידי אלגוריתם ה- PID. אז בעצם אלגוריתם ה- PID ייתן לנו ערך פלט שיש להשתמש בו כדי לתקן את ערך הקלט להיותו קרוב לנקודת ההגדרה.
PID pid (& קלט, & פלט, & setpoint, Kp, Ki, Kd, DIRECT);
בתוך פונקציית הגדרת החלל אנו מאתחלים את ה- MPU6050 על ידי הגדרת התצורה של ה- DMP (Digital Motion Processor). זה יעזור לנו בשילוב נתוני האקסלומטר עם נתוני הג'ירוסקופ ויספק ערך אמין של Yaw, Pitch and Roll. לא נעמיק רבות בזה מכיוון שזה יהיה הרבה מעבר לנושא. בכל מקרה קטע קוד שאתה צריך לחפש בפונקציית ההתקנה הוא ערכי קיזוז הג'ירו. לכל חיישן MPU6050 יש ערכים משלו של קיזוזים. באפשרותך להשתמש בסקישת Arduino זו כדי לחשב את ערך הקיזוז של החיישן שלך ולעדכן את השורות הבאות בהתאם בתוכנית שלך.
// ספק כאן קיזוזי ג'ירו משלך, מוגדלים לרגישות מינימלית mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);
עלינו לאתחל גם את סיכות ה- PWM הדיגיטליות בהן אנו משתמשים כדי לחבר את המנועים שלנו. במקרה שלנו מדובר ב- D6, D9, D10 ו- D11. אז אנו מאותטלים את הפינים האלה כסיכות פלט הופכות אותם ל LOW כברירת מחדל.
// אתחל את סיכות פלט המנוע pinMode (6, OUTPUT); pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); // כברירת מחדל כבה את שני המנועים אנלוגיים כתוב (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);
בתוך פונקציית הלולאה הראשית אנו בודקים אם הנתונים מה- MPU6050 מוכנים לקריאה . אם כן, אנו משתמשים בו כדי לחשב את ערך ה- PID ואז להציג את ערך הקלט והפלט של ה- PID בצג הסדרתי רק כדי לבדוק כיצד ה- PID מגיב. ואז על סמך ערך התפוקה אנו מחליטים אם הבוט צריך להתקדם או לאחור או לעמוד במקום.
מכיוון שאנו מניחים כי ה- MPU6050 יחזיר 180 כשהבוט זקוף. נקבל ערכי תיקון חיוביים כאשר הבוט נופל לכיוון חזית ונקבל ערכים בשלילה אם הבוט נופל לאחור. לכן אנו בודקים מצב זה וקוראים לפונקציות המתאימות להנעת הבוט קדימה או אחורה.
בעוד (! mpuInterrupt && fifoCount <packetSize) { // אין נתוני mpu - ביצוע חישובי PID ופלט למנועים pid.Compute (); // הדפיסו את הערך קלט ופלט על גבי צג סדרתי כדי לבדוק כיצד הוא פועל. Serial.print (קלט); Serial.print ("=>"); Serial.println (פלט); אם (קלט> 150 && קלט <200) {// אם הבוט נופל אם (פלט> 0) // נופל לכיוון קדמי קדימה (); // סובב את הגלגלים קדימה אחרת אם (פלט <0) // נופל לכיוון הגב לאחור (); // סובב את הגלגלים לאחור } אחר // אם הבוט לא נופל עצור (); // להחזיק את הגלגלים בשקט }
משתנה פלט ה- PID מחליט גם כמה מהר יש לסובב את המנוע. אם הבוט בדיוק עומד ליפול, אנו מבצעים תיקון קל על ידי סיבוב גלגל לאט. אם התיקון הקטן הזה לא עובד, ובכל זאת אם הבוט נופל למטה אנו מגבירים את מהירות המנוע. הערך כמה מהר הגלגלים מסתובבים יוחלט על ידי אלגוריתם ה- PI. שימו לב שעבור הפונקציה הפוכה הכפלנו את ערך הפלט ב- -1 כדי שנוכל להמיר את הערך השלילי לחיובי.
void Forward () // קוד לסיבוב הגלגל קדימה { analogWrite (6, פלט); analogWrite (9,0); analogWrite (10, פלט); analogWrite (11,0); Serial.print ("F"); // ניפוי מידע באגים } בטל הפוך () // קוד לסיבוב הגלגל לאחור { analogWrite (6,0); analogWrite (9, פלט * -1); analogWrite (10,0); analogWrite (11, פלט * -1); Serial.print ("R"); } בטל עצור () // קוד לעצירת שני הגלגלים { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }
עבודה של רובוט איזון עצמי של Arduino
ברגע שאתה מוכן עם החומרה, אתה יכול להעלות את הקוד ללוח Arduino שלך. וודא שהחיבורים תקינים מכיוון שאנו משתמשים בסוללת ליתיום יש צורך בזהירות רבה. אז בדוק אם קיימים מעגלים קצרים וודא שהמסופים לא יבואו במגע גם אם הבוט שלך חווה השפעות קטנות. הפעל את המודול שלך ופתח את המסך הטורי שלך, אם ה- Arduino שלך יכול לתקשר עם MPU6050 בהצלחה ואם הכל עובד כצפוי אתה אמור לראות את המסך הבא.
כאן אנו רואים את ערכי הקלט והפלט של אלגוריתם ה- PID בפורמט קלט => פלט . אם הבוט מאזן בצורה מושלמת ערך הפלט יהיה 0. ערך הקלט הוא הערך הנוכחי מחיישן MPU6050. האלף בית "F" מייצג כי הבוט נע קדימה ו- "R" מייצג את הבוט הפוך.
בשלבים הראשונים של PID אני ממליץ להשאיר את כבל הארדואינו מחובר לבוט כך שתוכל לפקח בקלות על ערכי הקלט והפלט וגם יהיה קל לתקן ולהעלות את התוכנית שלך לערכי Kp, Ki ו- Kd. הווידאו שלהלן מראה את העבודה המלאה של בוט וגם מראה איך לתקן ערכי PID שלך.
מקווה שזה יעזור לבנות רובוט מאזן עצמי משלך אם יש לך בעיה לגרום לו לעבוד, ואז השאיר את השאלות שלך בקטע ההערות למטה או השתמש בפורומים לשאלות טכניות נוספות. אם אתה רוצה יותר כיף אתה יכול גם להשתמש באותו היגיון כדי לבנות רובוט איזון כדורים.