בינה מלאכותית ברובוטיקה ובקרת תנועה

רווחים:

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

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

קינמטיקה קדימה והפוכה

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

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

מושג

קלט

פלט

מספר פתרונות

קינמטיקה קדימה

זוויות מפרקים

מיקום/התמצאות קיצונית

רווק

קינמטיקה הפוכה

מיקום/התמצאות קיצונית

זוויות מפרקים

מרובה/אין/אינסופי

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

ייבוא ​​numpy כ-npdef inverse_kinematik_2r(x, y, L1, L2): """IK עבור זרוע מישורית בעלת 2 מפרקים. מחזיר זוויות ברדיאנים (פתרון מרפק למטה).""" r2 = x**2 + y**2 # בדיקת נגישות: האם הנקודה בסביבת העבודה? if np.sqrt(r2) > (L1 + L2) או np.sqrt(r2) < abs(L1 - L2): raise ValueError("הנקודה נמצאת מחוץ למרחב העבודה הנגיש") cos_t2 = (r2 - L1**2 - L2**2) / (2 * L1 * L2) cos_.t2, = 1s_0, clip 1.0) # numericalsecurity t2 = np.arccos(cos_t2) # elbow down t1 = np.arctan2(y, x) - np.arctan2(L2*np.sin(t2), L1 + L2*np.cos(t2)) retour np.degrees(np.degrees(np.degrees) L1=L2=1, יעד (1,1) -> צפוי t2=90 degreesprint(inverse_kinematik_2r(1.0, 1.0, 1.0, 1.0)) # ~ (0.0, 90.0)

השורות הקריטיות כאן הן המקום שבו ה-AI מדלג לעתים קרובות: בדיקת גישה (היא הנקודה בסביבת העבודה) ו-'np.clip' (מונע מקלט arccos לעבור מעבר ל-±1 עקב שגיאת עיגול). ללא שתי ההגנות הללו, הקוד יפיק NaN או יקרוס בנקודה לא חוקית.

טיפ: כשאתה מבקש רזולוציית IK, אמור בבירור ל-AI "להוסיף בקרת נגישות ולהגביל קלט arccos לקליפ". שני קווים אלו מונעים את השגיאות השקטות שגורמות להכי הרבה כאבי ראש בשטח.

מגבלות משותפות, ייחוד ופתרונות מרובים

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

לכן פתרון משאבי אנוש לבדו אינו מספיק; כל פתרון חייב לעבור מסנן קבילות:

def solution_gecerli_mi(acilar_deg, limits_deg): """כאבים: [t1,t2,...], גבולות: [(min,max),...]""" לכאב, (amin, amax) ב-zip(acilar_deg, limits_deg): אם לא (amine <= כאב <= amax): return deg False. f"} ({amine},{amax}) except" return True, "OK"limits = [(-170, 170), (-120, 120)]print(cozum_valid_mi([0.0, 90.0], limits)) # (True, 'OK')print(cozum_valid_mi limit([0.0,F limits], #Jointals limit([0.0,F limits), חרג...')

AI יכול לתת את הפתרון ה"מתמטי" של IK; אך מגבלות משותפות והימנעות מייחודיות הן ספציפיות למערכת שלך וחייבות להינתן כהקשר להנחיה.

תכנון מסלול

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

ייבוא numpy כ-npdef trapez_yorunge(q0, q1, v_max, a_max, dt=0.01): """פרופיל מהירות טרפז עבור מפרק יחיד. מערך המיקום מוחזר.""" distance = abs(q1 - q0) distance = np.sign(q1 - /speed_max.0) v_max_0. * a_max * t_speed**2 if 2 * distance_speed > distance: # פרופיל משולש (v_max לא ניתן להגיע) t_speed = np.sqrt(distance / a_max) t_constant = 0.0 v_peak = a_max * t_speed else: t_constant =peak = *v_max - T_max)2 = (distance v_max - max) 2 * t_accelerate + t_constant t = np.arange(0, T, dt) # ... חישוב מיקום עבור כל t (מבוסס על שלבי תאוצה/קבוע/האטה) החזר t, T, v_peak, duration, vz = trapezoidal_trajectory(0.0, v_max60, v_max. a_max=120.0)print(f"משך כולל: {duration:.3f} שניות, מהירות שיא: {vz:.1f} מעלות/שניות")

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

הנחיה חלשה / הנחיה חזקה

WEAK:"כתוב מסלול שלוקח את זרוע הרובוט מ-A ל-B."(אין אילוץ: הגבלת מהירות? תאוצה? מרווח מפרקים? פלט עיוור.)STRONG:"צור מסלול מנקודה לנקודה במרחב המפרק עבור רובוט 6 צירים. הגבלת המהירות עבור כל מפרק היא 90 מעלות/שניה, מגבלת התאוצה היא טווח של 180 מלכודת. פרופיל מהירות, אם המרחק קצר, נופל לפרופיל משולש. הפלט של כל מפרק הוא גם כתוב פונקציית אימות שבודקת שהוא אינו חורג ממגבלות המפרק: {{טבלה}}.

אימות: מסימולציה לרובוט

המסלול שנוצר על ידי ה-AI מאומת בסדר הזה לפני המעבר לרובוט:

1. מספרי: האם זווית המפרק, המהירות והתאוצה של כל צעד בגבולות?
2. התנגשות: האם לאורך המסלול הזרוע מתנגשת בעצמה או בסביבה (מדמה/מדמה אם אפשר)?
3. סינגולריות: האם המסלול עובר דרך אזור סינגולריות (האם הקובע היעקובי מתקרב לאפס)?
4. בדיקת חומרה איטית: הפעל את הרובוט במהירות נמוכה (למשל 10%) ולפקח עליו ויזואלית.
5. עליית מהירות הדרגתית: לאחר שהכל מאומת, המהירות עולה צעד אחר צעד עד לערך הנומינלי.

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

קייס מיני

מהנדס האוטומציה Ece מבקש מה-AI קוד מסלול במרחב משותף עבור יישום בחירה-ומקום. ה-AI מייצר פרופיל טרפז, אבל כאשר Ece בודקת מהלך למרחקים קצרים, היא רואה שהזמן שלילי: הקוד לא טיפל במקרה של הפרופיל המשולש שבו לא ניתן להגיע ל-v_max. Ece מתקן זאת על ידי כך שההנחיה "אם המרחק קצר, תיפול לתוך הפרופיל המשולש". לאחר מכן הוא מריץ את זוויות המפרק שניתנו על ידי ה-AI דרך פונקציית האימות שלו מול טבלת הגבול שלו ומגלה שמפרק 5 רצה +125° בנקודה אחת, בעוד שהגבול היה +120°. הוא מתכנן מחדש את המסלול ומנטר אותו, הפעם מפעיל את הרובוט במהירות של 10%. בסיבוב הראשון הוא רואה שהתפסן מתקרב מדי לשולחן ומתקן את היסט Z. ה-AI החזיר מתאר עבודה תוך דקות; אבל שלושה אימותים נפרדים (פרופיל משולש, גבול מפרק, בדיקה איטית) תפסו שלוש בעיות אמיתיות נפרדות.

טעויות נפוצות

• שימוש בפתרון IK ללא מגבלות משותפות ובקרת נגישות.
• לא חותך ערכי arccos/arcsin אלא יצירת NaN במקרה של שגיאת עיגול.
• בקשת המסלול ללא הגבלת מהירות/האצה ויצירת זעזוע מכני.
• התעלמות מאזורי ייחוד ונותנת למהירויות המפרקים להרקיע שחקים.
• דילוג על מעבר הפרופיל הטרפז-משולש במרחק קצר וחישוב הזמן הלא נכון.
• ביצוע מבחן המסלול הראשון במהירות מלאה וללא גישה לעצירה חשמלית.

לסיכום

• לקינמטיקה קדימה יש פתרון יחיד; קינמטיקה הפוכה יכולה לייצר פתרונות מרובים, לא קיימים או אינסופיים.
• פתרונות IK מסוננים בהכרח במונחים של מגבלות משותפות, נגישות וייחודיות.
• תכנון מסלול; הוא משתמש בפרופילים רכים התואמים לגבולות כגון טרפז או עקומת S.
• במרחק קצר הפרופיל משתנה מטרפז למשולש; זה צריך להיות מטופל בקוד.
• AI מזרז מתמטיקה; ההגבלות והקשר ההתקנה הפיזי צריכים להיכנס להודעה.
• המסלול החדש מופעל תמיד בפעם הראשונה עם יחס מהירות נמוך ועצירה חשמלית נגישה.

משימת יישום

בחר דגם זרוע דו או שלושה מפרקים (עם אורכי קישור אמיתיים או דמיוניים ומגבלות מפרקים). בקש מה-AI ליצור פונקציית קינמטיקה הפוכה ומתכנן מסלולים בהקשר זה. לאחר מכן: (1) אמת ידנית את פלט ה-IK עם מטרה ידועה (האם אתה מחזיר את הזוויות וחוזר לאותה נקודה כמו ה-FK), (2) בדוק שהקוד לוכד אותן על ידי מתן לפחות נקודה אחת בלתי נגישה ומגבלה משותפת אחת החורגת מהיעד, (3) בדוק שבמרחק קצר זמן המסלול מתברר כסביר. רשום כמה בעיות אימות מצאת בגרסה הראשונה של הקוד ואיזו שכבה תפסה כל אחת מהן.