Holarch

מדריך · SysML v2

מדריך SysML v2: מידול מערכת ההספק של CubeSat בסימון הטקסטואלי

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

מדריך SysML v2 זה בונה צעד אחר צעד מודל קטן ושלם: מערכת ההספק החשמלית של ה-CubeSat ‏EO-1, עם ה-parts שלה, גדלים ויחידות, ports וחיבורים, מחזור אור שמש וליקוי, דרישות שכלי יכול לבדוק, מקרה אימות ו-views. כל רשימת קוד בעמוד הזה היא טקסט SysML v2 שנבדק במנוע שפה, וכל שלב מרכזי מציג את הדיאגרמה שהטקסט מפיק.

בדף זה
  1. מה תבנו
  2. רעיון ראשון: הגדרות ו-usages
  3. שלב 1: package וה-imports שלו
  4. שלב 2: הגדרות parts ו-attributes עם יחידות
  5. שלב 3: ההרכבה, עם ערכים
  6. שלב 4: ports, ממשקים וחיבורים
  7. שלב 5: התנהגות עם actions ו-flows
  8. שלב 6: הקצאת התנהגות למבנה
  9. שלב 7: דרישות עם אילוצים
  10. שלב 8: מקרה אימות
  11. שלב 9: views ודיאגרמות
  12. המודל המלא
  13. איך הרשימות נבדקו
  14. לנסות ב-Holarch
  15. לאן ממשיכים

מה תבנו

EO-1 הוא CubeSat בגודל 6U לתצפית על כדור הארץ במסלול סינכרוני-שמש בגובה 500 km. זו הדוגמה המשותפת של המדריכים האלה; פרויקט הדוגמה ל-MBSE עוקב אחרי החללית כולה מהצרכים ועד האימות. המדריך הזה לוקח תת-מערכת אחת, מערכת ההספק החשמלית (EPS), וכותב אותה בטקסט SysML v2.

ל-EPS שלושה parts. שני מערכי סוללות שמש נפתחים הופכים אור שמש להספק. מארז סוללות ליתיום-יון אוגר אנרגיה לזמן הליקוי. יחידת חלוקת הספק (PDU) עוקבת אחרי נקודת ההספק המרבי של המערכים, טוענת את הסוללה ומווסתת את פס ה-12 V. שני צרכנים על הפס הזה נמצאים גם הם במודל: מצלמת המטען ומשדר ה-S-band.

המספרים לקוחים ממודל EO-1:

פריטערךהיכן הוא משמש
מערכי סוללות שמש: שטח תאים, נצילות תאים, הספק מרבי0.2 m², ‏0.295, ‏75.4 Wשלב 3
נצילות מסלול ההספק; החלק המואר של המסלול0.6; 0.62שלב 3
מארז סוללות: קיבולת; אנרגיה שנצרכת בליקוי של 36 דקות77 Wh; ‏18.5 Whשלב 3
מסה: מערכים, סוללה, PDU0.45 kg, ‏0.62 kg, ‏0.28 kgשלב 3
צריכת הספק ממוצעת למסלול: מצלמה, משדר S-band6.2 W, ‏3.4 Wשלב 3
דרישה 3.1 Orbit Average Powerלפחות 28 W בסוף החייםשלב 7
דרישה 3.2 Battery Capacityלפחות 77 Wh בתחילת החייםשלבים 7 ו-8
דרישה 3.3 Depth of Dischargeלכל היותר 30% בכל מסלולשלב 7
מקרה בדיקה TC-07 Battery Capacity Testפריקה ב-C/2 בתא בטמפרטורה של 20 °Cשלב 8

למודל שלושה packages:

חבילהמכילהשלבים
CubeSatEPSPorts, ‏parts, חישוב, ההרכבות עם הערכים שלהן, וההתנהגות1 עד 6
CubeSatEPSRequirementsהדרישות 3.1 עד 3.3 ומקרה האימות TC-077 ו-8
CubeSatEPSViewsViews שבוחרים חלקים מהמודל לדיאגרמות9

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

רעיון ראשון: הגדרות ו-usages

SysML v2 מפרידה בין הגדרה ל-usage. הגדרה אומרת מהו סוג של דבר: part def BatteryPack מתארת כל מארז סוללות בתכן הזה, עם ה-attributes וה-ports שלו. Usage הוא דבר כזה בהקשר מסוים: part battery : BatteryPack בתוך מערכת ההספק הוא הסוללה היחידה של ה-EPS של EO-1, המחוברת ל-PDU שלה.

אותו צימוד עובר בשפה כולה: attribute def ו-attribute, ‏port def ו-port, ‏action def ו-action, ‏requirement def ו-requirement. מילת מפתח ואחריה def מצהירה על סוג; אותה מילת מפתח בלי def משתמשת בסוג. ערכים ספציפיים שייכים בדרך כלל ל-usages, כי usage הוא המקום שבו מתקבלת החלטת תכן.

קוראים שמכירים את SysML v1 יכולים להשוות הגדרה ל-block ו-usage ל-part property. ב-SysML v2 הרעיון חל על כל סוג של רכיב, ו-usages מקוננים זה בזה ומעדנים זה את זה לכל עומק. SysML v1 מול SysML v2 משווה בין שתי השפות מבנה אחר מבנה.

שלב 1: package וה-imports שלו

Package הוא מרחב שמות: הוא מקבץ רכיבים ונותן להם שמות מלאים כמו CubeSatEPS::BatteryPack. מתחילים עם package ריק וה-imports של הספרייה שהוא צריך.

package CubeSatEPS {
  doc /* The electrical power system (EPS) of the EO-1 CubeSat: solar arrays, a battery pack and a power distribution unit that feed the payload camera and the S-band transmitter. */

  private import ScalarValues::*;
  private import ISQ::*;
  private import SI::*;
}
  • doc /* … */ מצרף תיעוד ל-package. בניגוד להערת //, הוא חלק מהמודל, וכלים מציגים אותו עם הרכיב.
  • ScalarValues מספקת טיפוסים בסיסיים כמו Real, ‏Integer, ‏Boolean ו-String.
  • ISQ מספקת טיפוסי גדלים ממערכת הגדלים הבינלאומית, כמו MassValue, ‏PowerValue ו-EnergyValue.
  • SI מספקת יחידות SI כמו kg, ‏V, ‏W ו-h.
  • private שומר את השמות המיובאים בתוך ה-package הזה, כך ש-package שמייבא את CubeSatEPS אינו מקבל אותם דרכו.

בלי ה-imports, שם כמו MassValue אינו ניתן לפתרון, ובודק מדווח עליו כלא מוכר.

שלב 2: הגדרות parts ו-attributes עם יחידות

כל רכיב מקבל הגדרת part עם attributes מוקלדים. הקלדת attribute לפי גודל ולא לפי Real מתעדת מה הוא מודד: מסה, הספק, אנרגיה. כך כלי יכול לבדוק שכל ערך וכל ביטוי עקביים בממדים שלהם.

  part def SolarArray {
    attribute mass : MassValue;
    attribute cellArea : AreaValue;
    attribute cellEfficiency : Real;
    attribute peakPower : PowerValue;
    attribute pathEfficiency : Real;
  }

  part def BatteryPack {
    attribute mass : MassValue;
    attribute capacity : EnergyValue;
  }

  part def PowerDistributionUnit {
    attribute mass : MassValue;
    attribute busVoltage : ElectricPotentialValue;
  }

  part def PayloadCamera {
    attribute powerDraw : PowerValue;
  }

  part def SBandTransmitter {
    attribute powerDraw : PowerValue;
  }

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

עדיין אין ערכים. הגדרה מתארת כל מארז סוללות מהסוג הזה; המספרים מגיעים עם הסוללה של EO-1 עצמה בשלב הבא.

שלב 3: ההרכבה, עם ערכים

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

  calc def OrbitAverage {
    doc /* Orbit-average array output (EQ-1.3): peak power times the sunlit fraction times the power path efficiency. */
    in peakPower : PowerValue;
    in sunlitFraction : Real;
    in pathEfficiency : Real;
    return : PowerValue = peakPower * sunlitFraction * pathEfficiency;
  }

  part def ElectricalPowerSystem {
    part solarArrays : SolarArray {
      attribute redefines mass = 0.45 [kg];
      attribute redefines cellArea = 0.2 [m^2];
      attribute redefines cellEfficiency = 0.295;
      attribute redefines peakPower = 75.4 [W];
      attribute redefines pathEfficiency = 0.6;
    }
    part battery : BatteryPack {
      attribute redefines mass = 0.62 [kg];
      attribute redefines capacity = 77 [W*h];
    }
    part pdu : PowerDistributionUnit {
      attribute redefines mass = 0.28 [kg];
      attribute redefines busVoltage = 12 [V];
    }

    attribute sunlitFraction : Real = 0.62;
    attribute eclipseEnergy : EnergyValue = 18.5 [W*h];
    attribute orbitAveragePower : PowerValue = OrbitAverage(solarArrays.peakPower, sunlitFraction, solarArrays.pathEfficiency);
    attribute depthOfDischarge : Real = eclipseEnergy / battery.capacity;
    attribute totalMass : MassValue = solarArrays.mass + battery.mass + pdu.mass;
  }

  part def Spacecraft {
    part eps : ElectricalPowerSystem;
    part camera : PayloadCamera {
      attribute redefines powerDraw = 6.2 [W];
    }
    part transmitter : SBandTransmitter {
      attribute redefines powerDraw = 3.4 [W];
    }
  }
  • part battery : BatteryPack מצהיר על usage בשם battery, שמוקלד לפי ההגדרה BatteryPack.
  • attribute redefines capacity = 77 [W*h] נותן ערך ל-capacity שעבר בירושה. הצורה המקוצרת :>> capacity = 77 [W*h]; פירושה אותו דבר. בלי redefines, השורה הייתה מצהירה על attribute שני שרק חולק את השם, וה-capacity שעבר בירושה היה נשאר בלי ערך.
  • 77 [W*h] הוא גודל: מספר ויחידה. יחידות משתלבות עם *, ‏/ ו-^, כך שוואט-שעות הן W*h ומטרים רבועים הם m^2.
  • calc def OrbitAverage הוא חישוב עם קלטים ותוצאה מוקלדת. OrbitAverage(…) קורא לו עם ערכי המערכים, כך שהנוסחה נכתבת פעם אחת וכל שימוש בה מתעדכן כשהיא משתנה.
  • depthOfDischarge מחלק אנרגיה באנרגיה. היחידות מצטמצמות, והתוצאה היא יחס פשוט.
  • Spacecraft מציב את מערכת ההספק לצד שני הצרכנים שהמדריך עוקב אחריהם. שאר EO-1 (בקרת יציבה, מחשב הטיסה, המבנה) הושמט כדי לשמור על מודל קצר.

הערכים אינם רק נשמרים; כלי מחשב אותם. עם המספרים שלמעלה:

מאפייןביטויתוצאה
orbitAveragePower75.4 W × 0.62 × 0.628.05 W
depthOfDischarge18.5 Wh ÷ 77 Wh0.24
totalMass0.45 kg + 0.62 kg + 0.28 kg1.35 kg

גם להספק המרבי עצמו יש מקור שאפשר לבדוק: 0.2 m² של תאים בנצילות 0.295 תחת 1361 W/m² של אור שמש, בזווית פגיעה של 0.35 rad ‏(cos 0.35 = 0.939), נותנים 75.4 W. החלק המואר נובע מהמסלול: מסלול בגובה 500 km נמשך כ-94.6 דקות, 36 מהן בליקוי, ונשארים 0.62 מהמסלול באור שמש.

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

package UnitCheck {
  private import ISQ::*;
  private import SI::*;

  part def BatteryPack {
    attribute capacity : EnergyValue;
  }

  part battery : BatteryPack {
    attribute redefines capacity = 77 [W];
  }
}

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

שלב 4: ports, ממשקים וחיבורים

Ports הם הנקודות שבהן part פוגש את סביבתו. הגדרת port מפרטת מה חוצה את הגבול, כל feature עם כיוון: out למה שהבעלים שולח, in למה שהוא מקבל.

  port def DCPowerPort {
    out attribute voltage : ElectricPotentialValue;
    out attribute current : ElectricCurrentValue;
  }

  port def BusPowerPort {
    out attribute voltage : ElectricPotentialValue;
    out attribute powerLimit : PowerValue;
  }

  interface def BusLink {
    end source : BusPowerPort;
    end load : ~BusPowerPort;
  }

הצד המקבל משתמש באותה הגדרת port, מצומדת עם ~. ~BusPowerPort היא תמונת המראה של BusPowerPort: כל out הופך ל-in. הגדרת port אחת מתארת את שני הקצוות של קישור, כך ששני הקצוות אינם יכולים להתרחק זה מזה.

הגדרת interface מתארת סוג של חיבור עם קצוות מוקלדים. BusLink מחבר את פס ה-12 V, ששולח הספק, לצרכן שמקבל אותו. היא ממלאת את התפקיד של 12 V Power Interface ‏(IFB-1) של EO-1.

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

  part def SolarArray {
    // attributes as in step 2
    port arrayOut : DCPowerPort;
  }

  part def BatteryPack {
    // attributes as in step 2
    port cellsOut : DCPowerPort;
  }

  part def PowerDistributionUnit {
    // attributes as in step 2
    port arrayIn : ~DCPowerPort;
    port batteryIn : ~DCPowerPort;
    port busOut : BusPowerPort;
  }

  part def PayloadCamera {
    // attributes as in step 2
    port powerIn : ~BusPowerPort;
  }

  part def SBandTransmitter {
    // attributes as in step 2
    port powerIn : ~BusPowerPort;
  }

  part def ElectricalPowerSystem {
    // parts as in step 3
    port bus : BusPowerPort;

    connect solarArrays.arrayOut to pdu.arrayIn;
    connect battery.cellsOut to pdu.batteryIn;
    bind bus = pdu.busOut;

    // computed attributes as in step 3
  }

  part def Spacecraft {
    // parts as in step 3
    interface payloadPower : BusLink connect eps.bus to camera.powerIn;
    interface radioPower : BusLink connect eps.bus to transmitter.powerIn;
  }
  • connect solarArrays.arrayOut to pdu.arrayIn הוא חיבור פשוט: רתמת המערך (הממשק IF-20 של EO-1). battery.cellsOut אל pdu.batteryIn הוא רתמת הסוללה (IF-21).
  • bind bus = pdu.busOut קובע שה-port ‏bus של מערכת ההספק עצמה והיציאה של ה-PDU הם אותו דבר. כך part חושף port פנימי בגבול שלו: הצרכנים מתחברים ל-EPS, לא לחלק הפנימי שלה.
  • interface payloadPower : BusLink connect … to … מחבר שני ports דרך interface מוקלד, כך שהחיבור נושא את המשמעות של BusLink. שני ממשקי הפס הם Payload Power Line ‏(IF-01) ו-Radio Power Line ‏(IF-04) של EO-1.

Interconnection View מצייר את מערכת ההספק מהטקסט הזה: כל part עם ה-ports שלו על השפה, ה-ports המצומדים מסומנים ב-~, וה-port הקשור bus על המסגרת.

ה-view ‏epsConnections משלב 9: ה-parts של ה-EPS, ה-ports והחיבורים שלהם, מצוירים מהטקסט.

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

טעות נפוצה היא לתת לשני הקצוות אותו port לא מצומד. אז שני הקצוות שולחים ואף אחד מהם אינו מקבל:

package PortCheck {
  private import ISQ::*;

  port def BusPowerPort {
    out attribute voltage : ElectricPotentialValue;
  }

  part def PowerDistributionUnit { port busOut : BusPowerPort; }
  part def PayloadCamera { port powerIn : BusPowerPort; }

  part def Spacecraft {
    part pdu : PowerDistributionUnit;
    part camera : PayloadCamera;
    connect pdu.busOut to camera.powerIn;
  }
}

הטקסט מנותח, אבל בודק שמשווה כיוונים מזהיר ששני הקצוות של החיבור שולחים voltage. צימוד הקצה המקבל, port powerIn : ~BusPowerPort;, מתקן זאת.

שלב 5: התנהגות עם actions ו-flows

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

  item def Sunlight;
  item def ArrayPower;
  item def ChargePower;
  item def DischargePower;
  item def BusPower;

  action def ConvertSunlight {
    in item sun : Sunlight;
    out item power : ArrayPower;
  }

  action def ChargeBattery {
    in item power : ArrayPower;
    out item charge : ChargePower;
  }

  action def StoreEnergy {
    in item charge : ChargePower;
    out item discharge : DischargePower;
  }

  action def SupplyBus {
    in item discharge : DischargePower;
    out item bus : BusPower;
  }

  action def RunPowerCycle {
    doc /* One orbit: about 59 minutes of sunlight, then a 36 minute eclipse. */

    action collect : ConvertSunlight;
    action charge : ChargeBattery;
    action store : StoreEnergy;
    action supply : SupplyBus;

    flow collect.power to charge.power;
    flow charge.charge to store.charge;
    flow store.discharge to supply.discharge;

    first start then collect;
    first collect then charge;
    first charge then store;
    first store then supply;
    first supply then done;
  }
  • פרמטרי in ו-out הם הקלטים והפלטים של action.
  • בתוך RunPowerCycle, ארבעה action usages הם השלבים של מסלול אחד: באור שמש המערכים אוספים הספק וה-PDU טוען את הסוללה; בליקוי הסוללה מחזירה את האנרגיה וה-PDU מזין ממנה את הפס.
  • flow collect.power to charge.power אומר שהפלט של שלב אחד הוא הקלט של השלב הבא.
  • first collect then charge הוא succession: שלב אחד מסתיים לפני שהבא מתחיל. Flows אומרים מה נע; successions אומרים באיזה סדר. start ו-done הם ההתחלה והסוף של ה-action העוטף.

השלבים תואמים לפונקציות ההספק של EO-1: ‏F3.1 Convert Sunlight to Power, ‏F3.2 Store Battery Energy ו-F3.3 Regulate Bus Power. גזירת פונקציות כאלה מדרישות וסידורן הם הנושא של ניתוח פונקציונלי; הגדרות ה-action הן המקום שבו העבודה הזו נוחתת ב-SysML v2.

ה-Action Flow View שלמטה מצויר מהטקסט הזה יחד עם ההקצאה שבשלב 6, שנותנת לכל שלב נתיב שחייה.

ה-view ‏powerCycleFlow: השלבים המוארים, ואחריהם שלבי הליקוי, עם ההספק שזורם ביניהם.

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

שלב 6: הקצאת התנהגות למבנה

עד עכשיו ההתנהגות אינה שייכת לאף רכיב. הצהרת perform אומרת איזה part מבצע איזה שלב:

  part eo1 : Spacecraft {
    part redefines eps {
      perform action powerCycle : RunPowerCycle;
      part redefines solarArrays { perform powerCycle.collect; }
      part redefines battery { perform powerCycle.store; }
      part redefines pdu {
        perform powerCycle.charge;
        perform powerCycle.supply;
      }
    }
  }

eo1 הוא usage של Spacecraft בראש ה-package: החללית של התכן הזה. מערכת ההספק שלה מבצעת את RunPowerCycle, וכל part של ה-EPS מבצע את השלבים שלו. part redefines eps מעדן את מערכת ההספק שעברה בירושה מ-Spacecraft במקום להוסיף מערכת שנייה. ה-PDU מבצע שני שלבים, טעינה באור שמש והזנת הפס בליקוי, כי יחידה אחת עושה את שתי העבודות.

זו הצורה הטקסטואלית של הקצאה פונקציונלית. ממנה כלי יכול לפרט את הפונקציות שכל רכיב מבצע, או לצייר את ה-action flow עם נתיב אחד לכל part, כמו ב-view שלמעלה.

שלב 7: דרישות עם אילוצים

הדרישות נכנסות ל-package משלהן, שמייבא את התכן. ב-SysML v2 דרישה היא אילוץ על subject: טקסט ה-doc אומר במילים מה נדרש, ו-require constraint אומר את אותו הדבר בצורה שכלי יכול לחשב. שלוש הדרישות הן הדרישות 3.1, ‏3.2 ו-3.3 של EO-1, עם המזהים והניסוח שלהן.

package CubeSatEPSRequirements {
  doc /* Electrical power requirements of EO-1 (section 3) and how one of them is verified. */

  private import CubeSatEPS::*;
  private import ScalarValues::*;
  private import ISQ::*;
  private import SI::*;

  requirement def <'3.1'> OrbitAveragePower {
    doc /* The solar arrays shall generate at least 28 W orbit-average power at end of life. */
    subject eps : ElectricalPowerSystem;
    attribute required : PowerValue;
    require constraint { eps.orbitAveragePower >= required }
  }

  requirement def <'3.2'> BatteryCapacity {
    doc /* The battery shall store at least 77 Wh at beginning of life. */
    subject eps : ElectricalPowerSystem;
    attribute minimum : EnergyValue;
    require constraint { eps.battery.capacity >= minimum }
  }

  requirement def <'3.3'> DepthOfDischarge {
    doc /* The EPS shall limit battery depth of discharge to 30% per orbit. */
    subject eps : ElectricalPowerSystem;
    attribute limit : Real;
    require constraint { eps.depthOfDischarge <= limit }
  }

  requirement powerSpec {
    doc /* The electrical power requirements EO-1 is built to. */
    subject eps : ElectricalPowerSystem;
    requirement orbitAveragePower : OrbitAveragePower {
      attribute redefines required = 28 [W];
    }
    requirement batteryCapacity : BatteryCapacity {
      attribute redefines minimum = 77 [W*h];
    }
    requirement depthOfDischarge : DepthOfDischarge {
      attribute redefines limit = 0.3;
    }
  }

  satisfy powerSpec by eo1.eps;
}
  • <'3.1'> הוא שם מקוצר: המזהה שמהנדסים מצטטים בסקירות. רכיבי מודל אחרים מפנים לשם המלא, OrbitAveragePower.
  • subject eps : ElectricalPowerSystem נוקב במה שהדרישה עוסקת בו.
  • require constraint { eps.orbitAveragePower >= required } הוא התנאי שחייב להתקיים. המגבלה היא פרמטר, כך שאותה הגדרה משרתת חללית עם צורך הספק אחר.
  • powerSpec אוסף את הדרישות ל-EO-1 וקובע את המגבלות: 28 W, ‏77 Wh ו-0.3.
  • satisfy powerSpec by eo1.eps טוען שמערכת ההספק של EO-1 עומדת במפרט.

יש לשמור על כך שטקסט ה-doc והאילוץ אומרים אותו דבר. סוקרים קוראים את הטקסט; כלים מחשבים את האילוץ. הקישורים מהדרישה אל התכן ואל הבדיקה הם הבסיס של עקיבות דרישות.

Requirement View מציג את המפרט כעץ, עם ה-part שמקיים אותו ומקרה האימות משלב 8:

ה-view ‏requirementTree: הדרישות 3.1 עד 3.3, מה מקיים אותן ומה מאמת אותן.

מכיוון שאפשר לחשב את האילוצים, בודק עושה יותר מלצייר את קו ה-satisfy: הוא בודק את הטענה מול הערכים משלב 3. במודל כפי שנכתב, שלושתן מתקיימות: 28.05 W מול 28 W, ‏77 Wh מול 77 Wh, ועומק פריקה של 0.24 מול 0.3.

המרווח הראשון מבין אלה דק. אם מורידים את נצילות מסלול ההספק מ-0.6 ל-0.59, שינוי של פחות משני אחוזים, ההספק הממוצע למסלול יורד ל-27.58 W. אז הבודק מדווח שדרישה 3.1 כבר אינה מתקיימת, עם הערכים ששברו אותה:

בדיקת הדרישה אחרי שערך תכן אחד השתנה: האזהרה נוקבת בדרישה, ב-part, באילוץ ובערכים.

המשמעות ההנדסית: דרישה 3.1 כבר נושאת את מרווח המערכת (הרציונל שלה ב-EO-1 הוא עומס של 24 W במצב צילום ועוד 15%), אבל המערכים עומדים ב-3.1 עצמה עם עודף של 0.05 W בלבד. כל אובדן שלא נכלל בהערכה, כמו התדרדרות מהירה יותר של התאים, מחייב שטח מערך גדול יותר או עומס קטן יותר. מודל שבודק את הדרישה בכל שינוי מראה זאת כשהמספר זז, לא בסקירה הבאה. כדי לראות עד כמה סביר שהמרווח יחזיק כשהקלטים אינם קבועים אלא לא ודאיים, ראו ניתוח מונטה קרלו בהנדסת מערכות.

שלב 8: מקרה אימות

קשר satisfy הוא טענה, והבדיקה בשלב 7 בוחנת אותה רק מול המספרים של המודל עצמו. מקרה אימות אומר איך הטענה נבדקת על החומרה האמיתית: בבדיקה, בבחינה, בניתוח או בהדגמה. EO-1 מאמת את קיבולת הסוללה שלו במקרה הבדיקה TC-07.

  verification def <'TC-07'> BatteryCapacityTest {
    doc /* Discharge the pack at C/2 from full charge in a thermal chamber at 20 degrees C and measure the energy delivered. */
    subject eps : ElectricalPowerSystem;
    objective {
      verify powerSpec.batteryCapacity;
    }
    return verdict : Boolean = eps.battery.capacity >= powerSpec.batteryCapacity.minimum;
  }

  verification batteryTest : BatteryCapacityTest {
    subject eps = eo1.eps;
  }
  • objective { verify powerSpec.batteryCapacity; } נוקב בדרישה שהמקרה הזה מאמת. מהקישורים האלה נבנית מטריצת אימות: כל דרישה מול המקרים שמאמתים אותה.
  • return verdict היא התוצאה: כאן, האם הקיבולת שנמדדה מגיעה ל-77 Wh של דרישה 3.2.
  • batteryTest הוא usage של המקרה עבור מערכת ההספק של EO-1: הבדיקה המתוכננת, כשה-subject שלה קשור ל-eo1.eps.

קיום ואימות מופרדים בכוונה. קיום אומר איזה רכיב תכן עונה לדרישה; אימות אומר איך יודעים שהוא אכן עונה. בפרויקט EO-1, ‏TC-07 עבר עם מדידה של 78.3 Wh. הדרישות 3.1 ו-3.3 עדיין צריכות מקרים משלהן, ומטריצת אימות דרישות היא המקום שבו הפער הזה נראה.

שלב 9: views ודיאגרמות

ב-SysML v2 דיאגרמה אינה שרטוט נפרד. View הוא רכיב של המודל שקובע מה להציג (expose) ואילו סוגי רכיבים לכלול (filter). כלי מציג את ה-view ושומר את הפריסה שלו; התוכן מגיע תמיד מהמודל. שלושת צילומי המסך שלמעלה הם שלושת ה-views האלה.

package CubeSatEPSViews {
  doc /* Views of the EO-1 power system. Each view selects part of the model; the layout belongs to the tool. */

  private import CubeSatEPS::*;
  private import CubeSatEPSRequirements::*;
  private import StandardViewDefinitions::*;

  // The EPS parts, their ports and connections.
  view epsConnections : InterconnectionView {
    expose CubeSatEPS::ElectricalPowerSystem;
  }

  // One orbit: the sunlit steps, the eclipse steps and the power that flows between them.
  view powerCycleFlow : ActionFlowView {
    expose CubeSatEPS::RunPowerCycle;
  }

  // The requirements with what satisfies and verifies them.
  view requirementTree : GeneralView {
    filter @SysML::RequirementDefinition or @SysML::RequirementUsage or @SysML::SatisfyRequirementUsage;
    expose CubeSatEPSRequirements::**;
  }
}

הספרייה הסטנדרטית מגדירה את סוגי ה-views הנפוצים:

Viewמציגבמודל הזה
General Viewרכיבים כלשהם והקשרים ביניהם, כתיבות וקוויםrequirementTree
Interconnection Viewה-parts של הרכבה אחת עם ה-ports והחיבורים שלהםepsConnections
Action Flow Viewהשלבים של התנהגות, הסדר שלהם ומה זורם ביניהםpowerCycleFlow
State Transition Viewמצבים והמעברים ביניהםאין
Sequence Viewהודעות בין parts לאורך זמןאין
Grid Viewרכיבים או קשרים כטבלה או כמטריצהאין

requirementTree הוא General View שהמסנן שלו משאיר רק דרישות וקשרי satisfy; כלים שמכירים את סוגי הדיאגרמות של SysML v1, ובהם Holarch, מציגים view כזה כדיאגרמת דרישות. מכיוון שה-view הוא חלק מהמודל, שינוי השם של הסוללה משנה כל דיאגרמה שמציגה אותה, וסוקר יכול לקרוא בטקסט בדיוק מה דיאגרמה כוללת.

המודל המלא

שלושת ה-packages יחד. הורדת מודל מערכת ההספק של EO-1 ‏(cubesat-eps.sysml), או העתקת הטקסט שלמטה; השניים זהים.

package CubeSatEPS {
  doc /* The electrical power system (EPS) of the EO-1 CubeSat: solar arrays, a battery pack and a power distribution unit that feed the payload camera and the S-band transmitter. */

  private import ScalarValues::*;
  private import ISQ::*;
  private import SI::*;

  // ---- Ports and interfaces ----
  port def DCPowerPort {
    out attribute voltage : ElectricPotentialValue;
    out attribute current : ElectricCurrentValue;
  }

  port def BusPowerPort {
    out attribute voltage : ElectricPotentialValue;
    out attribute powerLimit : PowerValue;
  }

  interface def BusLink {
    end source : BusPowerPort;
    end load : ~BusPowerPort;
  }

  // ---- Components ----
  part def SolarArray {
    attribute mass : MassValue;
    attribute cellArea : AreaValue;
    attribute cellEfficiency : Real;
    attribute peakPower : PowerValue;
    attribute pathEfficiency : Real;
    port arrayOut : DCPowerPort;
  }

  part def BatteryPack {
    attribute mass : MassValue;
    attribute capacity : EnergyValue;
    port cellsOut : DCPowerPort;
  }

  part def PowerDistributionUnit {
    attribute mass : MassValue;
    attribute busVoltage : ElectricPotentialValue;
    port arrayIn : ~DCPowerPort;
    port batteryIn : ~DCPowerPort;
    port busOut : BusPowerPort;
  }

  part def PayloadCamera {
    attribute powerDraw : PowerValue;
    port powerIn : ~BusPowerPort;
  }

  part def SBandTransmitter {
    attribute powerDraw : PowerValue;
    port powerIn : ~BusPowerPort;
  }

  // ---- Calculations ----
  calc def OrbitAverage {
    doc /* Orbit-average array output (EQ-1.3): peak power times the sunlit fraction times the power path efficiency. */
    in peakPower : PowerValue;
    in sunlitFraction : Real;
    in pathEfficiency : Real;
    return : PowerValue = peakPower * sunlitFraction * pathEfficiency;
  }

  // ---- The assembly ----
  part def ElectricalPowerSystem {
    part solarArrays : SolarArray {
      attribute redefines mass = 0.45 [kg];
      attribute redefines cellArea = 0.2 [m^2];
      attribute redefines cellEfficiency = 0.295;
      attribute redefines peakPower = 75.4 [W];
      attribute redefines pathEfficiency = 0.6;
    }
    part battery : BatteryPack {
      attribute redefines mass = 0.62 [kg];
      attribute redefines capacity = 77 [W*h];
    }
    part pdu : PowerDistributionUnit {
      attribute redefines mass = 0.28 [kg];
      attribute redefines busVoltage = 12 [V];
    }
    port bus : BusPowerPort;

    connect solarArrays.arrayOut to pdu.arrayIn;
    connect battery.cellsOut to pdu.batteryIn;
    bind bus = pdu.busOut;

    attribute sunlitFraction : Real = 0.62;
    attribute eclipseEnergy : EnergyValue = 18.5 [W*h];
    attribute orbitAveragePower : PowerValue = OrbitAverage(solarArrays.peakPower, sunlitFraction, solarArrays.pathEfficiency);
    attribute depthOfDischarge : Real = eclipseEnergy / battery.capacity;
    attribute totalMass : MassValue = solarArrays.mass + battery.mass + pdu.mass;
  }

  part def Spacecraft {
    part eps : ElectricalPowerSystem;
    part camera : PayloadCamera {
      attribute redefines powerDraw = 6.2 [W];
    }
    part transmitter : SBandTransmitter {
      attribute redefines powerDraw = 3.4 [W];
    }

    interface payloadPower : BusLink connect eps.bus to camera.powerIn;
    interface radioPower : BusLink connect eps.bus to transmitter.powerIn;
  }

  // ---- Behavior ----
  item def Sunlight;
  item def ArrayPower;
  item def ChargePower;
  item def DischargePower;
  item def BusPower;

  action def ConvertSunlight {
    in item sun : Sunlight;
    out item power : ArrayPower;
  }

  action def ChargeBattery {
    in item power : ArrayPower;
    out item charge : ChargePower;
  }

  action def StoreEnergy {
    in item charge : ChargePower;
    out item discharge : DischargePower;
  }

  action def SupplyBus {
    in item discharge : DischargePower;
    out item bus : BusPower;
  }

  action def RunPowerCycle {
    doc /* One orbit: about 59 minutes of sunlight, then a 36 minute eclipse. */

    action collect : ConvertSunlight;
    action charge : ChargeBattery;
    action store : StoreEnergy;
    action supply : SupplyBus;

    flow collect.power to charge.power;
    flow charge.charge to store.charge;
    flow store.discharge to supply.discharge;

    first start then collect;
    first collect then charge;
    first charge then store;
    first store then supply;
    first supply then done;
  }

  part eo1 : Spacecraft {
    part redefines eps {
      perform action powerCycle : RunPowerCycle;
      part redefines solarArrays { perform powerCycle.collect; }
      part redefines battery { perform powerCycle.store; }
      part redefines pdu {
        perform powerCycle.charge;
        perform powerCycle.supply;
      }
    }
  }
}

package CubeSatEPSRequirements {
  doc /* Electrical power requirements of EO-1 (section 3) and how one of them is verified. */

  private import CubeSatEPS::*;
  private import ScalarValues::*;
  private import ISQ::*;
  private import SI::*;

  requirement def <'3.1'> OrbitAveragePower {
    doc /* The solar arrays shall generate at least 28 W orbit-average power at end of life. */
    subject eps : ElectricalPowerSystem;
    attribute required : PowerValue;
    require constraint { eps.orbitAveragePower >= required }
  }

  requirement def <'3.2'> BatteryCapacity {
    doc /* The battery shall store at least 77 Wh at beginning of life. */
    subject eps : ElectricalPowerSystem;
    attribute minimum : EnergyValue;
    require constraint { eps.battery.capacity >= minimum }
  }

  requirement def <'3.3'> DepthOfDischarge {
    doc /* The EPS shall limit battery depth of discharge to 30% per orbit. */
    subject eps : ElectricalPowerSystem;
    attribute limit : Real;
    require constraint { eps.depthOfDischarge <= limit }
  }

  requirement powerSpec {
    doc /* The electrical power requirements EO-1 is built to. */
    subject eps : ElectricalPowerSystem;
    requirement orbitAveragePower : OrbitAveragePower {
      attribute redefines required = 28 [W];
    }
    requirement batteryCapacity : BatteryCapacity {
      attribute redefines minimum = 77 [W*h];
    }
    requirement depthOfDischarge : DepthOfDischarge {
      attribute redefines limit = 0.3;
    }
  }

  satisfy powerSpec by eo1.eps;

  verification def <'TC-07'> BatteryCapacityTest {
    doc /* Discharge the pack at C/2 from full charge in a thermal chamber at 20 degrees C and measure the energy delivered. */
    subject eps : ElectricalPowerSystem;
    objective {
      verify powerSpec.batteryCapacity;
    }
    return verdict : Boolean = eps.battery.capacity >= powerSpec.batteryCapacity.minimum;
  }

  verification batteryTest : BatteryCapacityTest {
    subject eps = eo1.eps;
  }
}

package CubeSatEPSViews {
  doc /* Views of the EO-1 power system. Each view selects part of the model; the layout belongs to the tool. */

  private import CubeSatEPS::*;
  private import CubeSatEPSRequirements::*;
  private import StandardViewDefinitions::*;

  // The EPS parts, their ports and connections.
  view epsConnections : InterconnectionView {
    expose CubeSatEPS::ElectricalPowerSystem;
  }

  // One orbit: the sunlit steps, the eclipse steps and the power that flows between them.
  view powerCycleFlow : ActionFlowView {
    expose CubeSatEPS::RunPowerCycle;
  }

  // The requirements with what satisfies and verifies them.
  view requirementTree : GeneralView {
    filter @SysML::RequirementDefinition or @SysML::RequirementUsage or @SysML::SatisfyRequirementUsage;
    expose CubeSatEPSRequirements::**;
  }
}

איך הרשימות נבדקו

כל רשימת קוד בעמוד הזה נותחה ונבדקה ב-Holarch Language Engine, המנוע שמאחורי עורך SysML v2 של Holarch, כשהספרייה הסטנדרטית של SysML v2 טעונה. הבדיקות פותרות כל שם, משוות יחידות וממדים, משוות כיווני ports לאורך חיבורים, ומחשבות את אילוצי הדרישות מול הערכים שמקיימים אותן.

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

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

לנסות ב-Holarch

  1. יש להוריד את cubesat-eps.sysml, או לשמור את המודל המלא בשם הזה.
  2. יש לפתוח את מודל ← ייבוא וייצוא, לבחור לפרויקט SysML v2 חדש ולשחרר את הקובץ. ראו ייבוא קבצים לפרויקט חדש.
  3. יש לפתוח את מודל ← עורך כדי לקרוא ולשנות את הטקסט. כל package הוא מסמך. ראו העורך.
  4. יש לפתוח את הרשימה דיאגרמות וללחוץ על epsConnections, ‏powerCycleFlow או requirementTree. ראו פתיחת view.
  5. ב-CubeSatEPS, יש לשנות את pathEfficiency = 0.6 ל-0.59 ולהמתין רגע. העורך מציג את האזהרה על שורת ה-satisfy ב-CubeSatEPSRequirements. ביטול הפעולה ב-⌘Z / Ctrl+Z.

כדי להקליד את המודל במקום זאת, יש ליצור פרויקט SysML v2, ללחוץ על + חבילה חדשה בעורך, ולכתוב את השלבים לפי הסדר; טקסט שמנותח בהצלחה מוחל אחרי השהיה קצרה. ראו תחילת העבודה עם פרויקטים של SysML v2. החללית EO-1 כולה, עם המסמכים, הבדיקות והתקציבים שלה, היא הדגמת ה-CubeSat: קובצי פרויקט ▾ ← פרויקט הדגמה חדש.

לאן ממשיכים