כיצד לבצע אוטומציה של רישום פרויקטים גדולים

מדוע דרישות הפחתת הפטנטים

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

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

האנטומיה של ה-Creditation

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

בפרויקטים גדולים, הגדרות רישום מגיעות מ:

דפי נתונים ומדריכי התייחסות (לעתים קרובות PDFs).
שכבת אבסטרקציה קשיחה (HAL) קבצים אחוריים המסופקים על ידי ספקי סיליקון.
קובץ תיאור מערכת-View (SVD), תקן ARM CMSIS לתיאור רישומים היקפיים ב- XML.
קובץ מקור עץ המכשיר (DTS) המשמש בלינוקס ו-Zphyr כדי לתאר את הטופולוגיה חומרה ואת כתובות הרישום.

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

אתגרים שגדלו עם פרויקט

טעות אנושית ושקיפות

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

חידושים ו Errata

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

בין משפחות מיקרובקר

העברת קושחה מאחד MCU לשני - אפילו בתוך המשפחה של אותו המוכר - לעתים קרובות דורש פריסות רישום שונות לחלוטין רצפים של הרישום.ללא אוטומציה, צוותים למעשה לשכתב את אותם פעמים לוגיקה מרובות.עם דור קוד אוטומטי, תצורה ברמה גבוהה (למשל, "UART ב 115200 baud, 8N1") נשאר זהה בעוד משימות ברמה נמוכה מבוסס על המכשיר.

ביקורת ו-Berden Burden

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

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

YAML או JSON Configuration Files + Code Generation

זוהי האסטרטגיה המאומצת ביותר.מהנדסים מגדירים הגדרות רישום בפורמט אנושי:

# uart_config.yaml
peripheral: UART0
baudrate: 115200
databits: 8
stopbits: 1
parity: none
flow_control: false

(בדרך כלל פייתון) קורא את ה-YAML, מסתכל על מפת הרשומות של המטרה (מקובץ SVD או מסד נתונים מותאם אישית), ומייצר קוד C שכותב את הערכים הנכונים לכתובות הנכונות.גישה זו דהוולטת (FLT:0) מה שעדכון 1 אתה רוצה מ-FLT:2howofLT:3 המטלות היא משתנה לעתים קרובות.

2.מינוף CMSIS-SVD עבור Gold-Standard Definitions

(הופנה מהדף ⁇ ) ⁇ (התיאור של מערכת הראייה) מספק תיאור מבוסס XML של כל הרשומות, bitfields, ערכים מוזנים, וכתובת לתבנית אופטימיזציה של מיקרובקר (מערכת תצוגה) באמצעות קידוד SVD, כלי אוטומציה יכולים ליצור כותרות וקוד ראשוניזציה אשר מובטחים להתאים את הספקים של כלי מסחר אלקטרוני (D2D)

3.מבנה מבוסס תבנית (Jinja2, Mako או דומה)

במקום ליצור קוד קו-בי-ליין, מנוע תבנית מפריד את ההיגיון של הרישום (בקובץ תבנית) מהנתונים התצורה (ב-YAML/JSON) זה חזק לפרויקטים גדולים, כי אתה יכול לייצר מספר פורמטים של פלט: C Headers, תסריטי קישור, פונקציות ראשוניות היקפיות היקפיות, ואפילו רתמות.

void {{ peripheral.name }}_init(void) {
 // Clock enable
 *((volatile uint32_t *){{ peripheral.clock_enable_addr }}) |= (1 << {{ peripheral.clock_enable_bit }});
 // Baud rate
 *((volatile uint32_t *){{ peripheral.brr_addr }}) = {{ peripheral.brr_value }};
 // Control register
 *((volatile uint32_t *){{ peripheral.cr1_addr }}) =
 {% if peripheral.enable_te %}(1 << 3) |{% endif %}
 {% if peripheral.enable_re %}(1 << 2) |{% endif %}
 0;
}

לאחר מכן, תסריט Python הופך את התבנית עבור כל מקרה UART המוגדר בקובץ YML.

4. בנה אינטגרציה ומיזוג מצב

עבור גמישות מקסימלית, לשלב את הדור הקוד נכנס למערכת הבנייה שלך (CMake, Make, SCons או עטופה אישית) זה מבטיח כי בכל פעם תצורה YAML או את הגדרות הרישום שינוי (למשל, לאחר עדכון קובץ SVD), קוד ההסטליזציה הוא regenerated לפני איסוף.You יכול גם להשתמש מאקרו מראש כדי לבחור בין לוחות שונים:

#if defined(BOARD_REV_A)
#include "init_rev_a.h"
#elif defined(BOARD_REV_B)
#include "init_rev_b.h"
#endif

תסריטים אוטומציה יכולים ליצור את ראשי תיבות ספציפיים של גרסאות אלה מתצורה אחת, ביטול שגיאות לחתוך-and-paste.

כלים מעשיים ומסגרות

Python + PyYAML + Jinja2

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

⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
תסריט פייתון (ראה תהילים 6) מתאחד עם כל הקבצים YML, ממזג אותם עם נתונים SVD, ופלט 7 C קבצים.
מערכת הבנייה (FLT:8) לפני הסגירה.

svd2rust / svd2go (עבור פרויקטים של רפה ו Go)

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

עץ התקן (עבור לינוקס ו-Zphyr)

במערכות משובצות מבוססות לינוקס, הגדרות רישום מובעות באמצעות לינוקס:0Device TreeFelo1 (DTS/DTSI) קבצים. Bootloaders ו- kernel parse עץ המכשיר כדי לזרז שעונים ראשוניים, GPIOs, pinmux ו- peripherals. בעוד עץ התקן אינו מסגרת התחדשות קוד ל-S, הוא משרת מטרה דומה: אתה מתאר טקסט, טקסט מחייב, וכתוב קובץ.

HALS ו-Concurators

ספקים כמו STMicroelectronics (STM32CubemX), NXP (MCUXpresso Config Tools), ו- Microchip (MCC) מספקים כלים גרפיים המייצרים קוד ראשוניזציה בעת נוח לפרויקטים קטנים, כלים אלה לעתים קרובות לייצר קוד מונוליטי שקשה לשלוט בגירסה-שליטה, ועשויים לא לעלות בקנה מידה רחב על פני קווי מוצר מרובים.

שיטות טובות לייצור - Ready Automation

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

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

קוד שנוצר באופן אוטומטי

לפחות, הפעל בדיקת איסוף (עם התראות מתאימות) עבור כל קובץ שנוצר.

(ב) [ה]: [ה] [ה]] [ה]] [ה]] [ה]], [ב], [ה]], [ה]], [ה]]], [ה'], [ה'], [ה'], [ה']'[ה']']'[ה']']'[ה']']'[ה']']']']''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
(FLT:0) simulation:FLT:1 השתמש במודל של MCU (QEMU, Renode, או סימולטור מוכר-מסופק) כדי לטעון את הה ראשונית שנוצרת ולוודא כי רישומים נקבעים לערכים הצפויים.
(FLT:0) המוזהה בלולאה (HIL): אנדרל 1 להגדרות קריטיות (למשל שעון PLL, ניהול חשמל), להפעיל בדיקות אוטומטיות על חומרה אמיתית הקוראת בחזרה ערכים ולהשוות עם התצורה הצפויה.

שליטה בכל

קבצי SVD xml, קבצי תבנית, ותסריט הקוד עצמו חייב להיות תחת שליטה בגירסה.קבצים C המיוצרים צריכים להיות מחויבים (או לפחות מאוחסנים כחפצים לבנות) כדי לאפשר לשחזר קושחה מסוימת לבנות בדיוק. השתמש בחוק FLT:9 אם אתה מתנגן מחדש בכל בניין, אבל תג של הגנרטור וקבצים קלט.

מסמך ה-Peline

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

הפרדה בין לוגיקה עסקית

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

משתנה עם Inheritance (למשל, YML Anchors)

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

base_uart: &base_uart
 baudrate: 115200
 databits: 8
 stopbits: 1

uart0:
 <<: *base_uart
 flow_control: false

uart1:
 <<: *base_uart
 baudrate: 9600 # override

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

שילוב עם CI /CD ו- Release Processes

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

מפתח מעדכן קובץ תצורה של YAML כדי להתאים את תיקון לוח חדש.
הם דוחפים את השינוי ל-Repository.The CI Server (Jenkins, GitLab CI, GitHub Actions) מעורר.
CI מפעילה את מחולל הקוד כדי לייצר קבצים חדשים של C.
CI מאגד את הקושחה לכל גרסאות היעד.
CI מפעילה ניתוח סטטי ובדיקות סימולציה (אם זמין).
אם כל המחאות עוברות, CI מייצרת קושחה בינארית ותגות אופציונליות שחרור.

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

שיקולים מתקדמים

Multi-Threaded and Multicore Safety

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

הנדסה הפוכה וחוק הדור

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

בדומה לכך, ניתן להשתמש בתצורה YAML לתיעוד אוטומטי ב- Öreek או reStructuredText (באמצעות תבנית ג'נג'ה2). תיעוד זה יכול לכלול שמות רשומים, תיאורים bitfield ואפקטים צפויים, כולם מובטח להיות עקבי עם הקושחה.

התייחסות חיצונית לקריאה נוספת

(FLT:0)ARM CMSIS-SVD SpecificationFLT 1:1 - ה-XML הרשמי של תיאור רשומות מיקרובקר; הבסיס של כלי אוטומציה רבים.
(FLT:0)DeviceTree.orgFLT:1, מפרט וכלים לתבנית עץ המכשיר המשמש בלינוקס, Zephyr ומערכות הפעלה אחרות.
(ב) ,0)svd2cFLT:1 - כלי קוד פתוח כדי ליצור C רושם ראשי תיבות קוד ראשוני של קבצים SVD.

מסקנה

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