Holarch

מדריך · ארכיטקטורה

ארכיטקטורה פונקציונלית, לוגית ופיזית ב-MBSE: מפונקציות לארכיטקטורת מערכת

האזנה למדריך הזה 32 דק׳

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

בדף זה
  1. שלוש תצוגות של מערכת אחת
    1. הערה על המינוח
  2. היכן הארכיטקטורה נמצאת במחזור החיים
  3. הארכיטקטורה הפונקציונלית
  4. הארכיטקטורה הלוגית
  5. הארכיטקטורה הפיזית
  6. הקצאה: ממה למי
    1. הכללים
    2. הצגת ההקצאה בדיאגרמה אחת
  7. ממשקים נובעים מההקצאה
  8. פשרות ארכיטקטורה
  9. דוגמה מעשית: פרוסות ההספק וטיפול הנתונים של EO-1
    1. הארכיטקטורה הפיזית
    2. שכבה לוגית לשתי הפרוסות
    3. ההקצאה, נבדקת במטריצה
    4. ממשקים שנובעים מההקצאה
    5. ניתוח חלופות פתוח בפרוסת ההספק
  10. איך LML ו-SysML מבטאות את שלוש התצוגות
  11. רשימת תיוג לסקירת ארכיטקטורה
  12. טעויות נפוצות
  13. לנסות ב-Holarch
  14. לאן ממשיכים

שלוש תצוגות של מערכת אחת

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

ארכיטקטורה פונקציונליתארכיטקטורה לוגיתארכיטקטורה פיזית
עונה עלמה המערכת חייבת לעשות?איך העבודה מקובצת לרכיבים, ללא תלות בטכנולוגיה?אילו רכיבים אמיתיים עושים את העבודה?
רכיביםפונקציות והפריטים שהן מחליפותרכיבים לוגיים (נקראים גם logical components או בלוקים פונקציונליים) והממשקים הלוגיים שלהםחומרה, תוכנה, אנשים ומתקנים, עם ממשקים פיזיים
נקרא בשם שלפועל ושם עצם: Regulate Bus Powerשם עצם לתפקיד: Power Conditioningשם עצם לדבר: Power Distribution Unit
משתנה כאשרהדרישות משתנותהקונספט משתנהספק, טכנולוגיה או מק״ט משתנים
מחוברים באמצעותקלטים ופלטיםממשקים לוגיים: מה חייב לעבור, לא איךכבלים, אפיקים, קישורי רדיו, צינורות, חיבורים מכניים
דיאגרמות אופייניותעץ פונקציות, FFBD, תרשים N2דיאגרמות בלוקים של רכיבים לוגיים, N2 של רכיביםדיאגרמות Asset או בלוקים, דיאגרמות בלוקים פנימיות, דיאגרמות ממשקים

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

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

הערה על המינוח

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

היכן הארכיטקטורה נמצאת במחזור החיים

ISO/IEC/IEEE 15288 ממקם את העבודה הזו בשני תהליכים טכניים. תהליך הגדרת הארכיטקטורה (סעיף 6.4.4) מפתח ארכיטקטורות מועמדות, מעריך אותן ובוחר אחת, שמבוטאת כמערכת של תצוגות עקביות. תהליך הגדרת התכן (סעיף 6.4.5) נותן אחר כך לכל רכיב פירוט מספיק כדי לבנות או לרכוש אותו. הגדרת דרישות המערכת מזינה את שניהם, וניתוח המערכת (6.4.6) מספק את המספרים שמכריעים בין המועמדות.

ה-NASA Systems Engineering Handbook ‏(NASA/SP-2016-6105 Rev 2) הולך באותו סדר בשמות אחרים: פירוק לוגי (סעיף 4.3) הופך דרישות למודלים פונקציונליים והתנהגותיים, והגדרת פתרון התכן (סעיף 4.4) הופכת אותם לתכנים פיזיים חלופיים ובוחרת אחד. ה-INCOSE Systems Engineering Handbook מתאר את הלולאות שקושרות ביניהם: עבודת הארכיטקטורה מחזירה את הצוות שוב ושוב לדרישות, ועבודת התכן מחזירה אותו לארכיטקטורה.

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

הארכיטקטורה הפונקציונלית

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

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

הארכיטקטורה הלוגית

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

למה להוסיף שכבה בין פונקציות לחלקים? משלוש סיבות:

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

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

הארכיטקטורה הפיזית

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

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

הקצאה: ממה למי

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

requirement  -> satisfied by -> function
function     -> allocated to -> logical element
logical      -> allocated to -> physical component

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

הכללים

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

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

הצגת ההקצאה בדיאגרמה אחת

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

האיור מצייר כך את 1 EO-1 Spacecraft. קוראים אותו משמאל לימין. השורה שמתחת לתת-מערכת מפרטת את הפונקציות שהיא מבצעת בעצמה; רשימת הרכיבים שלה מוסיפה את הפונקציות שניתנו לחלקים שלה. 1.3 EPS מבצעת את F3 Generate and Store Power, והרשימה שלה מציבה את F3.1 עד F3.3 על מערכי סוללות השמש, מארז הסוללות ויחידת חלוקת ההספק. 1.5 Communications אינה מבצעת דבר בעצמה: העבודה שלה יושבת על משדר-המקלט UHF ‏(F6) ועל משדר ה-S-band ‏(F9). תיבת המערכת נושאת את F5 Operate Imaging Orbits, שאף תת-מערכת אינה הבעלים שלה. מספרים כמו OPS.4 ו-SM.2 הם שלבים של תרחיש התפעול ושל פעילויות מצב הבטיחות, שמבוצעים על ידי אותן תת-מערכות.

שתי בדיקות לוקחות שניות בתצוגה הזו:

  • כל פונקציה מכוסה על ידי תת-מערכת אחת לפחות. עוברים על רשימת הפונקציות ומוצאים כל מספר בדיאגרמה. F1 עד F10 מופיעות כולן. F11 Process and Deliver Images אינה מופיעה, כי 2.2 Mission Operations Center בקרקע מבצע אותה. לפונקציה שאינה מופיעה באף דיאגרמה של המערכת או של שכנותיה אין מבצע.
  • פונקציה תחת כמה תת-מערכות מסמנת ממשק. כשמספר אחד מופיע תחת שתי תת-מערכות, הן חולקות את העבודה הזו, וכל מה שעובר ביניהן הוא ממשק, בין שצויר ובין שלא. יש לפרק את הפונקציה עד שלכל חלק יש מבצע אחד, ולתעד את הממשק. ב-EO-1 כל פונקציה מופיעה פעם אחת.

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

ממשקים נובעים מההקצאה

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

  1. לכל פריט שמוחלף בין פונקציות, מחפשים את המבצע של הפונקציה המייצרת ושל הפונקציה הצורכת.
  2. אם המבצע זהה, ההחלפה פנימית לאותו רכיב; היא עניין תכנוני של הצוות של הרכיב עצמו.
  3. אם המבצעים שונים, ההחלפה צריכה נתיב פיזי ביניהם: ממשק קיים שיכול לשאת אותה, או ממשק חדש.
  4. יש לבדוק את הקיבולת של כל נתיב מול כל מה שהוא נושא, ולתת לכל ממשק בעלים וסטטוס.

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

פשרות ארכיטקטורה

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

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

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

דוגמה מעשית: פרוסות ההספק וטיפול הנתונים של EO-1

הדוגמה היא EO-1, ‏CubeSat בדיוני בגודל 6U לתצפית על כדור הארץ במסלול סינכרוני-שמש בגובה 500 km, אותה מערכת שהמדריכים האחרים עוקבים אחריה (פרויקט הדוגמה ל-MBSE עובר על המודל כולו). שתי פרוסות ממנה מראות את השרשרת המלאה מפונקציות לרכיבים: תת-מערכת ההספק החשמלי (EPS) ותת-מערכת הפיקוד וטיפול הנתונים (C&DH). כל מה שבהמשך לקוח מהמודל, כולל השכבה הלוגית שלו L1 עד L6, שהיא חלק ממודל הייחוס EO-1 ‏(v1.0) ומפרויקטי הדגמה שנוצרו ב-Holarch 2.2.1 ואילך.

הורדה: שרשרת ההקצאה של EO-1 ל-EPS ול-C&DH ‏(CSV): שורה אחת לכל פונקציה של EPS ושל C&DH עם הדרישות שלה, הרכיב הלוגי, הרכיב הפיזי, הפריטים שהיא מחליפה עם רכיבים אחרים והממשקים שנושאים אותם. אפשר להשתמש בה כתבנית לטבלת ההקצאה שלכם.

הארכיטקטורה הפיזית

הפירוק הפיזי של המודל מתחיל ב-0 EO-1 Mission, ומתחתיו החללית, מקטע הקרקע, משגר הלוויין וסביבת המסלול. לחללית שש תת-מערכות, ושלוש מהן מפורקות לחלקים:

  • 1.3 EPS מכילה את 1.3.1 Solar Arrays (שני פאנלים נפתחים בעלי שלושה צמתים), ‏1.3.2 Battery Pack (ליתיום-יון בן 8 תאים, 77 Wh) ו-1.3.3 Power Distribution Unit (מעקב אחר נקודת הספק מרבי, ויסות 12 V, יציאות צרכנים ממותגות).
  • 1.4 C&DH היא יחידה אחת: מחשב טיסה עם 64 GB של אחסון למטען.
  • ה-conduits הם ממשקים פיזיים עם מספרים, כמו IF-01 עד IF-04 לקווי ההספק מה-EPS ו-IF-09 Power Telemetry Link, קישור I2C בין יחידת חלוקת ההספק למחשב הטיסה.

שכבה לוגית לשתי הפרוסות

הפירוק הפיזי לבדו עובר ישירות מפונקציות לתת-מערכות ולחלקים. שכבה לוגית לשתי הפרוסות מראה מה שלב הביניים מוסיף. שישה רכיבים לוגיים, L1 עד L6 תחת L0 EO-1 Logical Architecture, מכסים את הפונקציות המעורבות:

רכיב לוגיאחריותפונקציות שמקובצות בוממומש על ידי
L1 Power Generationהפיכת מקור אנרגיה חיצוני להספק חשמליF3.1 Convert Sunlight to Power1.3.1 Solar Arrays
L2 Energy Storageהחזקת אנרגיה לליקוי ולעומסי שיאF3.2 Store Battery Energy1.3.2 Battery Pack
L3 Power Conditioning and Distributionויסות הפס, ניהול הטעינה, מיתוג צרכניםF3.3 Regulate Bus Power1.3.3 Power Distribution Unit
L4 Onboard Command Processingאימות תקינות, תזמון וביצוע של פקודותOPS.3 Load Command Schedule, ‏SM.1 Execute Command Schedule, ‏SM.3 Enable S-band Transmitter1.4 C&DH
L5 Payload Data Managementדחיסה, אחסון ושחרור של נתוני המטעןF8 Store Payload Data, ‏OPS.7 Encode and Store Image1.4 C&DH
L6 Fault Managementזיהוי תקלות והעברת החללית למצב בטוחF10 Enter Safe Mode1.4 C&DH

צד ה-EPS ממופה אחד לאחד: לכל רכיב לוגי יש חלק משלו. צד ה-C&DH אינו כזה: שלושה רכיבים לוגיים חולקים מחשב טיסה אחד. זו בחירת תכן לגיטימית ל-CubeSat, שבו מעבד שני עולה במסה, בהספק ובנפח, אבל השכבה הלוגית הופכת אותה לבחירה גלויה ולא למקרה. היא גם מראה את החלופות שניתוח חלופות יכול לשקול: L5 ביחידת זיכרון המונית נפרדת, או חלק מ-L6 כמנתק תת-מתח בחומרה ביחידת חלוקת ההספק, שישרת את דרישה 4.3 (מצב בטיחות בתוך 10 שניות מזיהוי תת-מתח) בלי תלות בתוכנת הטיסה.

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

המודל מתעד את המבצע של כל פונקציה בקישור performed by. מטריצת הקצאה עם עץ הפונקציות של F0 Perform EO-1 Mission בשורות ועץ ה-Assets של המשימה בעמודות מציגה את ההקצאה כולה בבת אחת (עמודות שאינן מבצעות דבר מוסתרות):

קוראים את המטריצה מול הכללים:

  • כל פונקציה מוקצית. לכל אחת מ-18 הפונקציות יש בדיוק סימון אחד. השורה הריקה היחידה היא F0, הפונקציה העליונה, שמכוסה דרך הצאצאים שלה.
  • אבות לתת-מערכות, צאצאים לחלקים. F3 Generate and Store Power מבוצעת על ידי ה-EPS, ושלוש תת-הפונקציות שלה על ידי שלושת החלקים של ה-EPS. ההקצאה עקבית בין הרמות: המבצע של כל צאצא הוא חלק מהמבצע של האב.
  • רבים לאחד ב-C&DH. לעמודת ה-C&DH יש שני סימונים בעץ הזה, F8 ו-F10. במודל כולו היא מבצעת שש פעולות, ומוסיפה את OPS.3 Load Command Schedule ו-OPS.7 Encode and Store Image מתרחיש התפעול ושתי פעילויות מצב ממכונת המצבים. זה הקיבוץ L4 עד L6 שלמעלה, בצורה מוחשית.
  • תת-מערכת שעושה עבודה של חלק. F4.2 Compute Control Torques מבוצעת על ידי 1.2 ADCS עצמה, בעוד האחיות שלה הולכות לחלקים (עוקב כוכבים, גלגלי תגובה, מגנטורקרים). ל-ADCS אין חלק בקר בפירוק, אף ששלושה קישורים ברמת החלקים (IF-16 עד IF-18) מסתיימים ב-ADCS. הוספת חלק כמו ADCS Controller והעברת F4.2 וקצות הקישורים האלה אליו תגרום לפירוק לומר את מה שהממשקים כבר מרמזים.
  • פונקציה על החללית כולה. F5 Operate Imaging Orbits מבוצעת על ידי 1 EO-1 Spacecraft. זה נכון לפונקציה שהיא בעצם לולאה חוזרת על פונקציות אחרות: אף תת-מערכת אינה הבעלים שלה, והדרישות שלה (זמן ביקור חוזר, משך חיי המשימה) הן ברמת המערכת.

המטריצה חושפת גם הקצאות שצריך לבחון שוב מול הדרישות. דרישה 4.4 Downlink Encryption, שנוספה אחרי קו הבסיס של הדרישות, מקוימת על ידי F8 Store Payload Data וה-C&DH. הצפנת מסגרות היא טרנספורמציה שונה מאחסונן; פונקציה כמו Encrypt Downlink Frames תחת L5 תישא אותה בדיוק רב יותר ותיתן לצוות הבדיקות מקום אחד לחפש בו.

ממשקים שנובעים מההקצאה

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

כל קו הוא החלפה פונקציונלית שההקצאה הפכה לפיזית:

פריטמפונקציה (מבצע)אל פונקציה (מבצע)נישא על ידי
Array Power OutputF3.1 ‏(Solar Arrays)F3.3 ‏(Power Distribution Unit)IF-20 Array Power
Battery Charge PowerF3.3 ‏(Power Distribution Unit)F3.2 ‏(Battery Pack)IF-21 Battery Power
Battery Discharge PowerF3.2 ‏(Battery Pack)F3.3 ‏(Power Distribution Unit)IF-21 Battery Power
Power TelemetryF3.3 ‏(Power Distribution Unit)F10 Enter Safe Mode ‏(C&DH)IF-09 Power Telemetry Link
Safe Mode CommandsF10 Enter Safe Mode ‏(C&DH)F3.3 ‏(Power Distribution Unit)IF-09 Power Telemetry Link
Solar Illuminationסביבת המסלול (מחוץ למערכת)F3.1 ‏(Solar Arrays)IF-23 Sunlight Path

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

שלוש נקודות בולטות:

  • לכל החלפה פונקציונלית יש נתיב. IF-20 ו-IF-21 קיימים כי F3.1, ‏F3.2 ו-F3.3 נמצאות על חלקים שונים. אילו בקרת הטעינה הייתה מובנית במארז הסוללות, Battery Charge Power הייתה החלפה בתוך המארז, ו-IF-21 היה נושא במקומה הספק פס לא מווסת: ההקצאה קובעת מה ממשק נושא.
  • הפרוסות נפגשות בממשק אחד. מלבד קו ההספק של ה-C&DH, ההחלפה היחידה בין פרוסות ה-EPS וה-C&DH היא לולאת הטלמטריה והפקודות של ניהול התקלות. מכיוון ש-L6 Fault Management יושב על מחשב הטיסה בעוד נתוני ההספק מגיעים מיחידת חלוקת ההספק, IF-09 נמצא על הנתיב הקריטי של דרישה 4.3. הוא נושא 0.01 Mbps של טלמטריה ו-0.001 Mbps של פקודות על קישור I2C של 0.4 Mbps, מרווח נרחב, אבל ההשהיה שלו וההתנהגות שלו כשמחשב הטיסה עמוס או מאותחל שייכות עכשיו ל-ICD.
  • הגבול מוקלד. IF-22 Regulated Bus מסתיים ב-port ‏12 V Bus של ה-EPS, שמוקלד לפי 12 V Power Interface. כל תת-מערכת שצורכת הספק מתחברת להגדרה האחת הזו, כך ששינוי במתח הפס או במגבלת הזרם נעשה במקום אחד.

ניתוח חלופות פתוח בפרוסת ההספק

ההקצאה מציבה גם את התקציבים במקום הנכון. דרישה 3.1 מחייבת את מערכי סוללות השמש לייצר לפחות 30 W הספק ממוצע למסלול בסוף החיים (היא עמדה על 28 W עד שהעומס הממוצע למסלול גדל ל-26 W אחרי סקירת התכן המקדמית). TC-06 מדד 75.1 W שיא; עם החלק המואר של 0.62 ונצילות מסלול ההספק של 0.6 שבמודל, מתקבל ממוצע למסלול של כ-27.9 W, פחות מ-30 W. הדרישה מוקצית דרך F3.1 למערכי סוללות השמש, ולכן שם נוחת החוסר, והאפשרויות הן ארכיטקטוניות:

  • יותר שטח מערך או תאים בנצילות גבוהה יותר ב-L1 (מסה, מורכבות פריסה, עלות);
  • מסלול הספק טוב יותר ב-L3, שמעלה את הנצילות של 0.6 (טופולוגיית וסת אחרת ביחידת חלוקת ההספק);
  • פחות עומס: שינוי תפעולי שמצלם פחות מטרות בכל מסלול, ומעביר את הבעיה לדרישות המשימה.

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

איך LML ו-SysML מבטאות את שלוש התצוגות

LML ‏(Lifecycle Modeling Language) שומרת על אוצר מילים קטן. פונקציות הן Actions, מפורקות ב-decomposed by, ומחליפות Input/Outputs דרך generates ו-receives. רכיבים הם Assets, מחוברים ב-Conduits שמבצעים transfer ל-Input/Outputs. ההקצאה היא הקשר performs (ובכיוון ההפוך, performed by) מ-Asset אל Action, ודרישות מוקצות ב-satisfies. ל-LML אין מחלקה נפרדת לרכיבים לוגיים; פרויקט שרוצה שכבה לוגית ממדל אותה כעץ Assets שני, שמסומן בתווית כמו Logical. ‏EO-1 עושה זאת: הסכמה שלו מוסיפה זוג קשרים, allocated to / allocated from, שמקבץ כל פונקציה לרכיב הלוגי שלה, כך ש-performed by ממשיך לציין את החלק שעושה את העבודה, וכל חלק הוא related to לרכיב הלוגי שהוא מממש.

ל-SysML יש מושג הקצאה ייעודי. ב-SysML v1, פונקציות הן activities או actions, רכיבים הם blocks ו-parts, והקצאה היא תלות «allocate», שמוצגת לעיתים קרובות כנתיבי שחייה (allocate activity partitions) בדיאגרמת activity או כתאי הקצאה על blocks. ארכיטקטורות לוגית ופיזית הן בדרך כלל שתי היררכיות blocks עם הקצאות ביניהן.

ב-SysML v2 אותם רעיונות נכתבים כטקסט. Actions הם action def ו-action, רכיבים הם part def ו-part, וההקצאה היא ההצהרה allocate … to …; (או perform, כש-part מבצע action). הרשימה שלמטה כותבת את שתי הפרוסות של EO-1 בצורה הזו: התצוגות הפונקציונלית, הלוגית והפיזית, שרשרת ההקצאה ביניהן, ולולאת הטלמטריה שהופכת ל-IF-09.

package EO1Architecture {
    // Items the functions exchange
    item def PowerTelemetry;
    item def SafeModeCommands;

    // Functional architecture: what the system does
    action def GenerateAndStorePower {
        action convertSunlight;
        action storeEnergy;
        action regulateBus {
            out telemetry : PowerTelemetry;
            in commands : SafeModeCommands;
        }
    }
    action def EnterSafeMode {
        in telemetry : PowerTelemetry;
        out commands : SafeModeCommands;
    }
    action def StorePayloadData;

    // Logical architecture: solution-independent elements
    part def PowerGeneration;
    part def EnergyStorage;
    part def PowerConditioning;
    part def FaultManagement;
    part def DataStorage;

    // Physical architecture: the real components
    part def SolarArray;
    part def BatteryPack;
    part def PowerDistributionUnit;
    part def FlightComputer;

    part def Spacecraft {
        action power : GenerateAndStorePower;
        action safeMode : EnterSafeMode;
        action storeData : StorePayloadData;

        part logical {
            part generation : PowerGeneration;
            part storage : EnergyStorage;
            part conditioning : PowerConditioning;
            part faults : FaultManagement;
            part data : DataStorage;
        }
        part eps {
            part solarArrays : SolarArray[2];
            part battery : BatteryPack;
            part pdu : PowerDistributionUnit;
        }
        part cdh : FlightComputer;

        // Functions to logical elements
        allocate power.convertSunlight to logical.generation;
        allocate power.storeEnergy to logical.storage;
        allocate power.regulateBus to logical.conditioning;
        allocate safeMode to logical.faults;
        allocate storeData to logical.data;

        // Logical elements to physical components
        allocate logical.generation to eps.solarArrays;
        allocate logical.storage to eps.battery;
        allocate logical.conditioning to eps.pdu;
        allocate logical.faults to cdh;
        allocate logical.data to cdh;

        // The functional exchange becomes an interface between components
        flow of PowerTelemetry from power.regulateBus.telemetry to safeMode.telemetry;
        flow of SafeModeCommands from safeMode.commands to power.regulateBus.commands;
    }
}

שתי השורות allocate logical.… to cdh; הן ההקצאה של רבים לאחד של ה-C&DH במבט אחד. המדריך ל-SysML v2 בונה את מערכת ההספק של EO-1 צעד אחר צעד, כולל ההקצאה שלה עם perform.

רשימת תיוג לסקירת ארכיטקטורה

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

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

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

לנסות ב-Holarch

Holarch הוא כלי MBSE עם פרויקטים של LML ופרויקטים של SysML v2. בפרויקט LML, פונקציות הן Actions, רכיבים הם Assets וההקצאה היא performed by; בפרויקט SysML v2 הם action usages ו-part usages שמקושרים ב-perform וב-allocate (ראו פרויקטים של SysML v2). הדוגמה שלמעלה היא פרויקט ההדגמה CubeSat EO-1: יוצרים אותו דרך ניהול פרויקטים ← קובצי פרויקט ▾ ← פרויקט הדגמה חדש ← CubeSat (הנדסת מערכות מודרכת). כדי לסקור את הארכיטקטורה שלו:

  1. יש לפתוח את התנהגות ← ניתוח פונקציונלי לעץ הפונקציות, לזרימה ול-FFBD. יש לקשר כל פונקציה לרכיב שלה ב-performed by בסעיף עקיבות של חלונית המאפיינים, ולסמן תת-מערכת כדי להציג את המבצעים בטבלת ההקצאה.
  2. למטריצת ההקצאה, יש לפתוח את אימות ← מטריצת עקיבות. יש ללחוץ על השבב שורות ולבחור היררכיה תחת ישות שורש עם F0 Perform EO-1 Mission; ללחוץ על השבב עמודות ולבחור היררכיה תחת ישות שורש עם 0 EO-1 Mission; להגדיר את קשר ל-performed by ולסמן הסתרת עמודות ריקות. לחיצה על תא ריק מקצה, ו-שמירת התצוגה… שומרת את ההגדרה. ראו התיעוד של מטריצת העקיבות.
  3. לארכיטקטורה הפיזית, יש לפתוח את דיאגרמת Asset של 1 EO-1 Spacecraft מהעמוד דיאגרמות, ואז להעביר את בורר סוג הדיאגרמה ל-דיאגרמת I/O פיזית. הקווים שלה מגיעים מההחלפות המוקצות ומה-conduits; בדיקות הדיאגרמה (בדיקות בסרגל הכלים) מפרטות כל החלפה שאין conduit שיישא אותה. ראו בניית ארכיטקטורה פיזית ובדיקת הממשקים שלה.
  4. לחיצה כפולה על EPS בדיאגרמת ה-Asset הזו פותחת את הדיאגרמה שלה, ואז מעבירים את בורר הסוג ל-דיאגרמת I/O פיזית או ל-דיאגרמת בלוקים פנימית לשתי תצוגות ה-EPS שמוצגות למעלה.
  5. להיררכיה המוקצית, יש לפתוח שוב את דיאגרמת Asset של 1 EO-1 Spacecraft, להעביר את בורר הסוג ל-דיאגרמת היררכיה, ללחוץ על הגדרה בסרגל הכלים וללחוץ על התבנית היררכיית הקצאה תחת אפשרויות. ראו התבנית היררכיית הקצאה.
  6. יש לפתוח את ממשקים ← דיאגרמות N² להחלפות בין פונקציות, ואת ממשקים ← מרשם הממשקים לכל conduit עם הסטטוס שלו ובדיקת הקיבולת.
  7. יש להריץ את אימות ← בדיקות המודל: Action.11 מפרטת actions שאף asset אינו מבצע, Asset.11 מפרטת assets שאינם מבצעים אף action, ו-Asset.13 מפרטת assets שמחליפים פריט בלי conduit משותף.

מזרימה בדיאגרמת Action, ‏סידור ▾ ← יצירת דיאגרמת Asset בונה הקשר פיזי ראשון מהמבצעים ומהפריטים שהם מחליפים.

לאן ממשיכים