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

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

זווית הסיבוב של מנוע סרבו "אנלוגי" סטנדרטי נקבעת, כידוע, לפי אורך הפולס שהוא מקבל בקו הבקרה שלו – בדרך כלל בטווח שבין 0.5 ל-2.5 אלפיות השניה, בתוך מחזור של פלוס מינוס 20 אלפיות השניה. יצירה של פולס אחד כזה באמצעות טיימר היא עסק פשוט למדי, אבל מה עושים כשצריך לשלוט ביותר ממנוע יחיד? טיימר הוא משאב נדיר מאד, גם במיקרו-בקרים מודרניים ומשוכללים, כך שאין מצב להקדיש טיימר נפרד לכל מנוע. פתרון ראוי לשמו צריך להסתפק בטיימר אחד בלבד.

שיקול הרזולוציה

נניח שפולס של 0.5ms מסובב את הסרבו לקצה אחד של הטווח שלו, ופולס של 2.5ms מסובב אותו עד הקצה השני. לכמה תחנות ביניים אפשר, או צריך, לחלק את הטווח הזה? אפשר, למשל, לקבוע מדרגות של כ-11 מיליוניות השניה כל אחת, מה שייתן רזולוציה "טבעית" של מעלה אחת (בטווח שבין 0 ל-180). אם המנוע באיכות נמוכה, ייתכן שחוסר-הדיוק המובנה שלו יתקשה להתמודד אפילו עם זה. ביישומים מסוימים לא נזדקק בכלל לדיוק של מעלה יחידה. לעומת זאת, מנוע איכותי יוכל לתת בעת הצורך תוצאות מדויקות מאד, אם רק נחלק את הפולס ליותר מדרגות. ממידע לא-פורמלי שמצאתי ברשת, נראה שמנועי סרבו אנלוגיים מסוגלים להגיע עד רזולוציה של 4 מיליוניות השניה (כ-500 צעדים על פני טווח התנועה).

פתרון נאיבי ושגוי

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

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

הדרך של ארדואינו

ספריית הסרבו של ארדואינו מאפשרת – על פי התיעוד הרשמי – שליטה נוחה בעד 12 מנועים (בלוחות מבוססי ATmega328), ובפונקציות המתקדמות שלה (כגון writeMicroseconds) אפשר לקבוע תזמונים ברזולוציה של 4 מיליוניות השניה. תוך כדי קריאה של הקוד לצורך כתיבת הערכים בוויקי, הבנתי את השיטה הפשוטה והחכמה שהמתכנתים בחרו: במקום להתחיל את כל הפולסים באותו זמן, הם שירשרו אותם.

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

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

כל פולס בפני עצמו הוא בסדר, אבל משך המחזור הכולל התארך לכמעט 30 אלפיות השניה (12 מנועים כפול 2.5ms פולס מרבי). מנועי סרבו בדרך כלל לא מתעקשים על מחזור מדויק של 20ms, אבל 30 זה באמת מוגזם, ובמקרה הקיצוני הנ"ל לא אתפלא אם כל המנועים ישתגעו לגמרי.

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

פתרון אוניברסלי?

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

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

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