בקרת Pan Servo Multi Servo: 11 שלבים (עם תמונות)

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

במדריך זה נלמד כיצד לשלוט במספר סרוו באמצעות פייתון ב- Raspberry Pi. המטרה שלנו תהיה מנגנון PAN/TILT למיקום מצלמה (PiCam).

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

בדיקת לולאת בקרת סרוו שליטה:

שלב 1: BoM - שטר החומר

חלקים עיקריים:

1. Raspberry Pi V3 - 32.00 דולר ארה"ב
2. 5 מגה פיקסל חיישן 1080p OV5647 מודול וידאו מצלמה מיני - 13.00 $
3. TowerPro SG90 9G 180 מעלות מיקרו סרוו (2 X)- 4.00 $
4. מצלמת מיני פאן/ הטיה למצלמה נגד רטט עם 2 סרוו (*) - 8.00 דולר ארה"ב
5. התנגדות 1K אוהם (2X) - אופציונלי
6. שונות: חלקי מתכת, להקות וכו '(למקרה שתבנה את מנגנון הפאן/הטיה שלך)

(*) אתה יכול לקנות פלטפורמת Pan/Tilt שלמה עם סרוווס או לבנות משלך.

שלב 2: כיצד פועל PWM

ל- Raspberry Pi אין פלט אנלוגי, אך אנו יכולים לדמות זאת באמצעות גישת PWM (Pulse Width Modulation). מה שנעשה הוא לייצר אות דיגיטלי עם תדר קבוע, שבו נשנה את רוחב רכבת הדופק, מה שיתורגם כ"רמת מתח יציאה "ממוצעת כפי שמוצג להלן:

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

שים לב שמה שחשוב כאן הוא לא התדר עצמו, אלא "מחזור החובה", כלומר היחס בין הזמן שהפולסים "גבוהים" מחולקים בתקופת הגל. לדוגמה, נניח שנוצר תדר דופק של 50 הרץ באחד מ- RPberry Pi GPIO שלנו. התקופה (p) תהיה הפוך של תדר או 20ms (1/f). אם אנחנו רוצים שה- LED שלנו עם "חצי" בהיר, עלינו לקבל מחזור חובה של 50%, כלומר "דופק" שיהיה "גבוה" למשך 10ms.

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

סרוו

שלב 3: התקנת Hw

סרוווס יחוברו לאספק 5V חיצוני, כאשר סיכת הנתונים שלהם (במקרה שלי, החיווט הצהוב שלהם) יתחברו ל- Raspberry Pi GPIO כמפורט להלן:

• GPIO 17 ==> סרוו הטיה
• GPIO 27 ==> פאן סרוו

אל תשכח לחבר את ה- GND יחד ==> Raspberry Pi - סרוווס - ספק כוח חיצוני)

תוכל לקבל כאופציה, הנגד של 1K אוהם בין Raspberry Pi GPIO לבין פין קלט הנתונים של השרת. זה יגן על ה- RPi שלך במקרה של בעיית סרוו.

שלב 4: כיול סרוווס

הדבר הראשון שאתה צריך לעשות הוא לאשר את המאפיינים העיקריים של סרווס שלך. במקרה שלי, אני משתמש ב- Power Pro SG90.

מתוך גליון הנתונים שלו, אנו יכולים לשקול:

• טווח: 180o
• ספק כוח: 4.8V (5VDC חיצוני כספק כוח USB פועל מצוין)
• תדר עבודה: 50Hz (תקופה: 20 ms)
• רוחב הדופק: מ -1 ms עד 2 ms

בתיאוריה, הסרוו יהיה על שלו

• מיקום התחלתי (0 מעלות) כאשר דופק של 1 ms מופעל על מסוף הנתונים שלו
• מיקום ניטרלי (90 מעלות) כאשר דופק של 1.5 אלפיות השנייה מופעל על מסוף הנתונים שלו
• מיקום סופי (180 מעלות) כאשר דופק של 2 אלפיות השנייה מופעל על מסוף הנתונים שלו

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

• מיקום ראשוני ==> (0 מעלות) רוחב הדופק ==> 1ms ==> מחזור עבודה = 1ms/20ms ==> 2.0%
• מיקום ניטרלי (90 מעלות) רוחב דופק של 1.5 ms ==> מחזור עבודה = 1.5 ms/20 ms ==> 7.5%
• מיקום סופי (180 מעלות) רוחב הדופק של 2 ms ==> מחזור עבודה = 2ms/20ms ==> 10%

לכן מחזור החובה צריך להשתנות בטווח של 2 עד 10 %.

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

sudo python3

על מעטפת פייתון

>>

ייבא את המודול RPI. GPIO וקרא לו GPIO:

ייבא RPi. GPIO כ- GPIO

הגדר באילו תוכניות מספור סיכה אתה רוצה להשתמש (BCM או BOARD). עשיתי את הבדיקה הזו עם BOARD, כך שהסיכות בהן השתמשתי היו הסיכות הפיזיות (GPIO 17 = Pin 11 ו- GPIO 27 Pin 13). היה לי קל לזהות אותם ולא לטעות במהלך הבדיקה (בתוכנית הגמר אשתמש ב- BCM). בחר את ההעדפה שלך:

GPIO.setmode (GPIO. BOARD)

הגדר את סיכת הסרוו שבה אתה משתמש:

tiltPin = 11

אם במקום זאת, השתמשת בסכימת BCM, יש להחליף את 2 הפקודות האחרונות ב:

GPIO.setmode (GPIO. BCM)

tiltPin = 17

כעת, עלינו לציין כי סיכה זו תהיה "פלט"

GPIO.setup (tiltPin, GPIO. OUT)

ומה תהיה התדירות שנוצרה בסיכה זו, שעבור סרוונו יהיה 50 הרץ:

הטיה = GPIO. PWM (tiltPin, 50)

כעת, נתחיל לייצר אות PWM בסיכה עם מחזור עבודה ראשוני (נשמור אותו "0"):

הטיה = התחל (0)

כעת, תוכל להזין ערכי מחזור עבודה שונים, תוך התבוננות בתנועת הסרוו שלך. נתחיל עם 2% ונראה מה קורה (אנו רואים שהסרוו עובר ל"מיקום אפס "):

tilt. ChangeDutyCycle (2)

במקרה שלי, הסרוו עמד למצב אפס, אך כאשר שיניתי את מחזור העבודה ל -3% הבנתי שהסרוו נשאר באותה תנוחה, והתחיל לנוע עם מחזורי עבודה גדולים מ -3%. אז, 3% היא המיקום ההתחלתי שלי (o מעלות). אותו דבר קרה עם 10%, הסרוו שלי עלה על הערך הזה, ועמד על 13%שלו. אז עבור הסרוו הספציפי הזה, התוצאה הייתה:

• 0 תואר ==> מחזור עבודה של 3%
• 90 מעלות ==> מחזור עבודה של 8%
• 180 מעלות ==> מחזור עבודה של 13%

לאחר שתסיים את הבדיקות, עליך לעצור את ה- PWM ולנקות את ה- GPIO:

הטיה = עצירה ()

GPIO.cleanup ()

מסך ההדפסה של טרמינל לעיל מציג את התוצאה של שני סרווואים שלי (שיש להם תוצאות דומות). הטווח שלך יכול להיות שונה.

שלב 5: יצירת סקריפט פייתון

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

איך לעשות את זה? פשוט מאוד! אנו יודעים כי טווח מחזור העבודה נע בין 3% ל -13% וכי הדבר שווה לזוויות שינועו בין 0 ל -180 מעלות. כמו כן, אנו יודעים כי וריאציות אלה הן לינאריות, כך שנוכל לבנות סכמה פרופורציונלית כפי שמוצג למעלה. אז בהתחשב בזווית, נוכל לקבל מחזור תפקיד של כתב:

חובה = זווית/18 + 3

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

בואו ניצור סקריפט Python לביצוע הבדיקות. בעיקרון, נחזור על מה שעשינו בעבר ב- Python Shell:

מפעם לפעם ייבוא שינה

ייבא RPi. GPIO כ- GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) def setServoAngle (סרוו, זווית): pwm = GPIO. PWM (סרוו, 50) pwm.start (8) dutyCycle = זווית / 18. + 3. שינה pwm. ChangeDutyCycle (dutyCycle) (0.3) pwm.stop () אם _name_ == '_main_': יבוא sys servo = int (sys.argv [1]) GPIO.setup (servo, GPIO. OUT) setServoAngle (סרוו, int (sys.argv [2])) GPIO.cleanup ()

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

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

לדוגמה:

סודו python3 זווית ServoCtrl.py 17 45

הפקודה לעיל תמקם את סרוו המחובר ל- GPIO 17 עם 45 מעלות ב"גובה ". פקודה דומה יכולה לשמש לבקרת פאן סרוו (מיקום עד 45 מעלות ב"אזימוט "):

sudo python זווית servoCtrl.py 27 45

ניתן להוריד את הקובץ angleServoCtrl.py מה- GitHub שלי

שלב 6: מנגנון פאן הטיה

סרוו ה"פאן "יזיז" אופקית "את המצלמה שלנו (" זווית אזימוט ") וסרוו" הטיה "יזיז אותה" אנכית "(זווית הגבהה).

התמונה למטה מראה כיצד פועל מנגנון הפאן/הטיה:

במהלך הפיתוח שלנו לא נלך ל"קיצוניות "ונשתמש במנגנון ה- Pan/Tilt שלנו מ -30 עד 150 מעלות בלבד. טווח זה יספיק לשימוש עם מצלמה.

שלב 7: מנגנון הפאן -הטיה - בנייה מכנית

בואו עכשיו להרכיב את 2 סרוו שלנו כמנגנון פאן/הטיה. אתה יכול לעשות 2 דברים כאן. קנה מנגנון פלטפורמת Pan-Tilt כפי שמוצג בשלב האחרון או בנה משלך בהתאם לצרכים שלך.

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

שלב 8: מכלול מחבת/הטייה חשמלית

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

1. כבה את ה- Pi שלך.
2. בצע את כל החיבורים החשמליים.
3. בדוק את זה פעמיים.
4. הדלק קודם את ה- Pi שלך.
5. אם הכל תקין, הפעל את סרווייך.

לא נלמד במדריך זה כיצד להגדיר את המצלמה, זה יוסבר במדריך הבא.

שלב 9: סקריפט Python

בואו ניצור סקריפט פייתון לשליטה בשני הסרבים בו זמנית:

מפעם לפעם ייבוא שינה

ייבא RPi. GPIO כ- GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (pan, GPIO. OUT) # אפור ==> PAN def setServoAngle (סרוו, זווית): קבע זווית> = 30 וזווית 90 (נקודת אמצע) ==> 150 setServoAngle (הטיה, int (sys.argv [2])) # 30 ==> 90 (נקודת אמצע) ==> 150 GPIO.cleanup ()

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

sudo python3 servoCtrl.py 45 120

הפקודה לעיל תמקם את מנגנון הפאן/הטיה עם 45 מעלות ב"אזימוט "(זווית פאן) ו -120 מעלות של" גובה "(זווית הטיה). שים לב שאם לא הוזנו פרמטרים, ברירת המחדל תהיה הן, זוויות ההטה וההטייה המוגדרות עד 90 מעלות.

להלן תוכל לראות כמה בדיקות:

ניתן להוריד את קובץ servoCtrl.py מה- GitHub שלי.

שלב 10: בדיקת לולאות של שרתים

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

מפעם לפעם ייבוא שינה

ייבא RPi. GPIO כ- GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (pan, GPIO. OUT) # אפור ==> PAN def setServoAngle (סרוו, זווית): זווית טענה> = 30 וזווית <= 150 pwm = GPIO. PWM (סרוו, 50) pwm.start (8) dutyCycle = זווית / 18. + 3. שינה pwm. ChangeDutyCycle (dutyCycle) (0.3) pwm.stop () אם _name_ == '_main_': עבור i בטווח (30, 160, 15): setServoAngle (pan, i) setServoAngle (הטיה, i) עבור i in טווח (150, 30, -15): setServoAngle (pan, i) setServoAngle (הטיה, i) setServoAngle (פאן, 100) setServoAngle (הטיה, 90) GPIO.cleanup ()

התוכנית תבצע אוטומטית לולאה מ -30 עד 150 מעלות בשתי הזוויות.

מתחת לתוצאה:

חיברתי אוסצילוסקופ רק כדי להמחיש את תיאוריית ה- PWM כפי שהוסבר קודם.

ניתן להוריד את הקוד לעיל, servoTest.py מה- GitHub שלי.

שלב 11: סיכום

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

לפרטים וקוד סופי, בקר במאגר GitHub שלי: RPi-Pan-Tilt-Servo-Control

לפרויקטים נוספים, בקר בבלוג שלי: MJRoBot.org

להלן הצצה להדרכה הבאה שלי:

כל הכבוד מדרום העולם!

נתראה במדריך הבא שלי!

תודה, מרסלו