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

מה זה TDD ב- Robotics?

פיתוח Test-Driven הוא מחזור פיתוח קצר, מחזור פיתוח מהיר, אשר לעתים קרובות מסכמת כמו FPLT:0 Red-Green-RefactorFLT:1 בהקשר של הנדסה רובוטית, מחזור פועל כדלקמן:

  1. [01:0] אדום: ⁇ 1 [=] כתוב מבחן המגדיר ציפייה למרכיב - מטפל חיישן, ממריץ המדינה או חוק בקרה.המבחן נכשל בתחילה משום שהקוד עדיין לא קיים.
  2. (ב) ירוק: ⁇ 1 (בלטינית:0) כתוב את כמות הקוד המינימלי הדרוש כדי לבצע את המעבר במבחן.
  3. (ב) ,0) ,מספק: ⁇ 1 (ה) ישפר את מבנה הקוד, להסיר את השכפול, ולהבטיח כי הוא נקי בעת ביצוע כל הבדיקות.

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

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

  • כיצד בקר PID מגיב להודעה
  • כיצד odometry estimator ממזג את גלגל קודר ונתונים IMU
  • כיצד מתכנן נתיב מטפל מכשולים של צורות וגדלים שונים
  • כיצד מכונה ממשלתית עוברת תחת קוראי חיישן שונים

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

מדוע חשוב לבקר את אלגורית

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

יעילות מוגברת

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

שיפור המודולריות

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

◄ מינוף

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

מהיר יותר להתווכח

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

יישום TDD בפרויקטים רובוטיים

אימוץ אלגוריתמים של שליטה דורש גישה שיטתית.למטה הוא מדריך צעד אחר צעד המותאם למגבלות הייחודיות של פיתוח הרובוטיקה.

שלב 1: דרישות ברורות

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

  • בקר PID ישיג אפס שגיאות מצב קבוע עבור קלט צעד בתוך 2 שניות.
  • ה- estimator המהיר יפיק עדכון ב 100 הרץ עם מהירויות מקסימליות של 5 מ'.
  • אלגוריתם מניעת ההתנגשות לעולם לא יפיק פקודה שמניעה את הרובוט קרוב יותר למכשול מ-0.5 מטרים.

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

שלב 2: כתוב את הבדיקות הראשונות

באמצעות מסגרת בדיקה, כתוב מבחן המאמת את אחת הדרישות.לדוגמה, באמצעות Google Test עם כיתת בקר PID, ייתכן שתכתוב:

TEST(PidControllerTest, StepResponseReachesSetpoint) {
 PidController pid(1.0, 0.1, 0.05); // kp, ki, kd
 double setpoint = 1.0;
 double output = 0.0;
 double dt = 0.01;
 for (int i = 0; i < 200; ++i) {
 output = pid.compute(setpoint, output, dt);
 }
 EXPECT_NEAR(output, setpoint, 0.01);
}

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

שלב 3: פיתוח קוד מינימלי

לכתוב מספיק קוד כדי לבצע את המבחן לעבור. Resist הדחף over-engineer - להוסיף רק את ההיגיון הנדרש על ידי הבדיקה. עבור מבחן PID, אתה יכול ליישם בקר פרופורציונלי בסיסי ראשון, ולאחר מכן להוסיף תנאים אינטגרליים ונגזר רק כאשר הבדיקה הבאה דורשת אותם. גישה מצטברת זו שומרת על בסיס קוד רזה וממוקד.

שלב 4: מקררים והתרחבות

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

כלים ומסגרות ל- TDD ב- Robotics

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

המונחים: Testing Framework

מערכת ההפעלה הרובוטית 2 (ROS 2) מספקת:2 ו- C ;0 כלי בדיקות ענישה בדיקת כליות FLT:1 המשלב עם FLT 3 ו- FLT:4 אתה יכול לכתוב פייתון או C ++ אשר ספיןאו את צומת ROS, לפרסם הודעות מבחן, ולקבוע על אלגוריתמים של שליטה, זה שימושי במיוחד עבור אינטגרציה כי אתה יכול לבדוק את האינטראקציה בין לא כמו בקר, ולא אלגוריתם.

Google Test ו-Google Mock

(FLT:0) Google TestveFLT:1 (GTest) הוא תקן דה פקטו עבור C++ יחידה בדיקות רובוטיקה. בשילוב עם Google Mock, זה מאפשר לך ליצור אובייקטים ללעג עבור ממשקי חומרה - לדוגמה, נהג מנוע לעג כי הוא לוגש את המהירות.זה מקלקל את האלגוריתם שלך מחומרה פיזית, המאפשר בדיקות מהירות, חוזר על הרבה רובוטים, כולל, כולל 2, זה נסמכת מאוד על ידי GTest.

Gazebo Simulator

(FLT:0GazeboFLT:1) הוא לא מסגרת בדיקה ל-S, אבל זה חיוני עבור TDD כאשר שילוב עם פיזיקה נדרש.You יכול לשגר סימולציה גזיבו בתיקון מבחן, הזרקת נתונים באמצעות תוספים, ולוודא כי התנהגות הרובוט תואם ציפיות.על ידי שילוב של גזיבו עם בדיקות ההשקה של ROS 2, אתה יכול להפעיל בדיקות קבלה אוטומטית עבור שליטה אלגוריתמית על הסביבה ריאלית ללא סיכון אמיתי.

לתפוס 2 ו- pytest (Alternative Frameworks)

עבור צוותים המעדיפים מסגרת C++ בלבד, FLT:0 (Catch2Feloph 1:10) מציעה אלטרנטיבה קלה ל- GTest.עבור מחסניות הרובוטיות מבוססות פייתון (למשל, באמצעות שימוש ב-FLT:5), FLT:6 עם ה-FLT 7 מספק התאמה טבעית של התאמות מבחן תמיכה, בדיקות פרמטריות, ושילוב עם אינטגרציה רציפה.

אתגרים ועיסוקים טובים

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

סודיות

אלגוריתמים רבים של שליטה מתאחדים הדוקים לחיישנים ספציפיים או למבצעים.בדיקה על חומרה אמיתית בצנרת CI היא בלתי מעשית ולעתים מסוכנת.הפתרון הוא ל-FLT:0mock חומרה ממשקי חומרה סגסוגת 1:1 ברמה הנמוכה ביותר האפשרית.לדוגמה, ליצור מחלקה מופשטת של FLT:8 עם יישום של רשומות עבור טיעון מאוחר יותר, הדמיה על ידי קריאה על ידי האכלה מראש נתונים ללא בדיקה גופנית או אלגוריתם.

זמן אמת-זמן Constraints

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

בדיקות מורכבות אינטראקציה

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

Best Practices summary

  • (ב) ⁇ (ב"א) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) סימולציה:0 (Useסימולציה: FLT:1) הפעל TDD בדיקות בתוך גזיבו או סימולטור דומה לתפוס באגים הקשורים לפיזיקה לפני פריסת חומרה.
  • (ב)הסבר:0)הכול: 1FLT:1 אינטגר את כל הבדיקות לתוך צינור אינטגרציה מתמשך.כל מבצע צריך לגרום ליחידה, אינטגרציה, ו (היכן שניתן) בדיקות סימולציה.
  • (FLT:0)Write בוחן באותה שפה כמו יישום: אנדרל 1) Prefer C++ עבור C++ קוד בסיסים ו- Python עבור Python - זה נמנע משגיאות אי התאמה ולהפחית את פני השטח.
  • (FLT:0) בדיקות טוראט כקוד ראשון: ההרחבה:cioFLT:1 , לשמור אותם קריאים, להסיר אדמוניות.A חבילת מבחן מאויש היטב הוא בעל ערך כמו קוד הייצור.

דוגמה אמיתית לעולם: TDD for a PID

כדי להמחיש את התהליך, שקול ליישם בקר PID מאפס באמצעות TDD. הדרישות הן:

  • הבקר יסמן פלט המבוסס על הטעות בין נקודת מפנה לבין המדינה הנוכחית.
  • הרווח היחסי יהיה ניתן להגדרה.
  • הפלט יושפע למגבלה מסוימת.

(ב) ,0) ,1 , כתיב מבחן לדרגה.

TEST(PidControllerTest, ProportionalOutput) {
 PidController pid(2.0, 0.0, 0.0); // only P term
 double output = pid.compute(10.0, 5.0, 0.0, 0.1);
 EXPECT_DOUBLE_EQ(output, 10.0); // 2.0 * (10 - 5) = 10.0
}

[01:2] ,2:2, כתוב קוד מינימלי כדי לעבור.

class PidController {
public:
 PidController(double kp, double ki, double kd) : kp_(kp), ki_(ki), kd_(kd) {}
 double compute(double setpoint, double current, double prev_error, double dt) {
 double error = setpoint - current;
 return kp_ * error;
 }
private:
 double kp_, ki_, kd_;
};

(ב) 3 (ב) 3) הוסף מבחן לפעולה בלתי-נפרדת.

TEST(PidControllerTest, IntegralAccumulation) {
 PidController pid(1.0, 0.5, 0.0);
 double output = pid.compute(10.0, 5.0, 0.0, 0.1);
 // First call: error=5, integral=5*0.1=0.5, output=1*5 + 0.5*0.5 = 5.25
 EXPECT_NEAR(output, 5.25, 1e-6);
}

(FLT:0) ,Step Refactor Code כדי לצבור חלק בלתי נפרד.IRLT:1) המשך מחזור זה עד כל הדרישות - כולל הדגימה והסננות נגזרת - מיושמות כל מבחן חדש מניע שינוי קטן, חד-משמעי, וכתוצאה מכך הוא נבדק ביסודיות, בקר קורא ייצור.

מסקנה

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