Holarch

SysML v2

מדריכי SysML v2

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

אופן השימוש ←

בדף זה
  1. איך להשתמש בה
    1. התחלת מדריך SysML v2
    2. הקלדת הטקסט של שלב
    3. טיפים
  2. צעדים ראשונים
  3. הגדרות ומאפיינים
  4. פתחות וממשקים
  5. פעולות וזרימות
  6. מצבים ומעברים
  7. דרישות
  8. אימות ועקיבות
  9. אילוצים וחישובים
  10. וריאנטים ותצורות
  11. פרויקטי מדריך
  12. קשור

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

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

מדריךזמןמה לומדים
צעדים ראשונים15 דקותכתיבת טקסט SysML v2, הצגתו כעץ וכתצוגה, שרטוט בתצוגה והוספת דרישה
הגדרות ומאפיינים20 דקותכתיבת מניות, טיפוסי ערכים והגדרות מופשטות, התמחות עם ערכים ויחידות, ושימוש בהשלמה, בהוספה ובשינוי שם
פתחות וממשקים20 דקותהגדרת יציאות וממשקים, היפוך יציאות, חיבור חלקים ושרטוט ממשק ב-Interconnection View
פעולות וזרימות20 דקותכתיבת הגדרות פעולה ומחזור נסיעה עם פיצול, זרימות ואיחוד, הוספת מסלולי שחייה ובניית שלבים ב-FFBD
מצבים ומעברים20 דקותכתיבת אותות ומכונת מצבים עם טריגרים, תנאי שמירה ופעולות מצב, ושרטוט מעבר מתוזמן
דרישות20 דקותכתיבת מגבלות, הגדרות ושימושים של דרישות, סיפוק שלהן והצגת דרישה שאינה מתקיימת
אימות ועקיבות15 דקותכתיבת מקרה אימות, עקיבה של שלב במטריצת העקיבות וגזירת דרישה
אילוצים וחישובים20 דקותכתיבת אילוצים וחישובים, קשירת ערכים בתצוגה פרמטרית, הרצת מקרה ניתוח וסימון ערכי TBD ו-TBR
וריאנטים ותצורות15 דקותכתיבת וריאציות וגרסאות מוצר, קו מוצרים עם כלל, תצורות ומילת מפתח משלך

איך להשתמש בה

התחלת מדריך SysML v2

  1. יש לפתוח את עזרה → מדריכים בסרגל הניווט, או ללחוץ על ⌘K / Ctrl+K ולהקליד tutorial. מחוץ לפרויקט, הדף מדריכים מציג קודם את המדריכים של LML ואחריהם את מדריכים לפרויקטים של SysML v2. בתוך פרויקט SysML v2 הוא מציג רק את המדריכים של SysML v2.
  2. יש ללחוץ על התחלה בכרטיס. Holarch יוצר את הפרויקט, למשל Tutorial: SysML v2 Ports and Interfaces (Hybrid Car), ופותח אותו עם חלונית השלבים משמאל.

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

הקלדת הטקסט של שלב

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

  • יש להקליד את השורות כפי שהן מוצגות. ההזחה לא משנה למודל; העורך שומר את ההזחה שלך.
  • קו תחתון אדום מסמן שגיאה: הצבעה עליו מציגה את ההודעה. טקסט עם שגיאת תחביר נשאר טיוטה ואינו מוחל עד שמתקנים אותו.
  • ⌘Z / Ctrl+Z מבטל את השינוי האחרון שהוחל.

טיפים

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

צעדים ראשונים

כתיבת מודל ראשון של תחנת מזג האוויר: פתיחת הטקסט, הוספת הגדרת חלק עם ערך ויחידה, שימוש בה בהגדרה אחרת, הצגת המודל בדפדפן וב-General View, שרטוט חלק בתצוגה וצפייה בו מופיע בטקסט, הוספת דרישה עם satisfy, וייצוא המודל כקובץ .sysml. השלבים מתוארים ב-תחילת העבודה עם פרויקטים של SysML v2.

הגדרות ומאפיינים

בפרויקט ההתחלתי יש את החבילה Vehicles עם הגדרת חלק אחת, Car.

  1. פתיחת החבילה. יש ללחוץ על מודל → עורך. כל הצהרה היא מילת מפתח ושם, ואחריהם גוף בסוגריים מסולסלים או נקודה-פסיק.
  2. כתיבת מנייה. מעל part def Car {, יש להוסיף enum def DriveMode { enum economy; enum normal; enum sport; } (ערך אחד בכל שורה).
  3. הגדרת טיפוס ערך. מתחת לה, יש להוסיף attribute def TirePressure :> ScalarValue;. :> פירושו התמחות.
  4. כתיבת הגדרה מופשטת. יש להוסיף abstract part def Component עם הערת doc והתכונות mass : MassValue, partNumber : String ו-power : PowerValue. // מתחיל הערה שנשארת רק בטקסט.
  5. מתן אפשרות לבודק למצוא טעות. יש להוסיף part def Battery :> Component עם attribute redefines mass = 45 [kg]; ובכוונה גם attribute redefines power = 60 [kg];. הבודק מסמן בקו תחתון את היחידה: קילוגרמים אינם הספק.
  6. תיקון היחידה. יש לשנות אותה ל-60 [W].
  7. השלמת שם. בסוללה, יש להקליד attribute capacity : Ener, לקבל את EnergyValue מרשימת ההשלמה עם Enter ולסיים ב-;.
  8. חיפוש בספרייה הסטנדרטית. יש ללחוץ על הגדרות → ספרייה סטנדרטית בתחתית סרגל הניווט ולהקליד EnergyValue בתיבת החיפוש.
  9. הוספת הגדרה. בעורך, יש ללחוץ על ⌃⇧Space / Ctrl+Shift+Space (או על הוספה ▾) בשורה ריקה, לבחור הגדרת חלק ולהשלים part def Engine :> Component עם attribute redefines mass = 110 [kg]; ו-attribute cylinders : Integer;.
  10. שימוש בהגדרות. ב-Car, יש להוסיף attribute mode : DriveMode;, part battery : Battery; ו-part engine : Engine;.
  11. שינוי שם בכל מקום. יש למקם את הסמן על cylinders, ללחוץ על F2 ולשנות את השם ל-cylinderCount.

פתחות וממשקים

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

  1. הגדרת יציאה. מעל port def TorquePort, יש להוסיף port def FuelPort עם out attribute flowRate : Real; ו-attribute kind : FuelKind;. out פירושו שהערך יוצא מהחלק שהיציאה שייכת לו.
  2. מתן יציאות לחלקים. יש להוסיף port fuelOut : FuelPort; ל-FuelTank ו-port fuelIn : ~FuelPort; ל-Engine. ~ הופך את היציאה: כניסה ויציאה מתחלפות.
  3. הגדרת ממשק. יש להוסיף interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }.
  4. בניית מערכת ההנעה. בסוף החבילה, יש להוסיף part def Powertrain עם החלקים tank, engine, motor, battery ו-transmission, יציאה output : TorquePort ו-bind output = transmission.output;.
  5. חיבור שני חלקים. במערכת ההנעה, יש להוסיף interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn;.
  6. הוספת הצירים. יש להוסיף interface engineShaft : Shaft connect engine.output to transmission.engineIn; ו-interface motorShaft : Shaft connect motor.output to transmission.motorIn;.
  7. יצירת Interconnection View. יש ללחוץ על ארכיטקטורה → Interconnection Views, ואז על + דיאגרמה חדשה. יש לבחור Powertrain תחת מציג וללחוץ על יצירה.
  8. שרטוט ממשק. יש לגרור מהידית של היציאה powerOut של הסוללה אל היציאה powerIn של המנוע, ולשחרר על Interface : HighVoltageBus.
  9. מתן שם לממשק. יש לבחור את הקו החדש ולהזין hvBus כשם שלו בחלונית המאפיינים.
  10. הצגה בטקסט. יש ללחוץ על מודל → עורך: הממשק נמצא במערכת ההנעה, עם השם, הטיפוס והקצוות שלו.

פעולות וזרימות

בפרויקט ההתחלתי יש את החבילה VehicleBehavior עם הפריטים Fuel ו-Torque, הפונקציות ProduceTorque (F.2) ו-DriveWheels (F.3), ושלוש הגדרות חלק.

  1. הגדרת פונקציה. יש להוסיף action def <'F.1'> SupplyFuel עם in attribute fuelDemand : Real; ו-out item fuel : Fuel;. השם הקצר בסוגריים הזוויתיים הוא מספר הפונקציה.
  2. כתיבת מחזור הנסיעה. יש להוסיף action def <'F'> DriveCycle עם first start then split;, fork split;, then supply;, then produce; והשלבים action supply : SupplyFuel ו-action produce : ProduceTorque, כל אחד עם duration.
  3. הוספת זרימה. במחזור הנסיעה, יש להוסיף flow of Fuel from supply.fuel to produce.fuel;.
  4. איחוד הענפים. יש להוסיף first supply then ready;, first produce then ready;, join ready;, then action drive : DriveWheels { … }, then done; ו-flow produce.torque to drive.torque;.
  5. יצירת תצוגת זרימת פעולות. יש ללחוץ על התנהגות → זרימות פעולה, ואז על + דיאגרמה חדשה, ולבחור DriveCycle תחת מציג.
  6. ציון מי מבצע כל שלב. יש להוסיף part def DrivenCar עם perform action trip : DriveCycle; והחלקים tank, engine ו-transmission, כל אחד עם perform trip.supply;, perform trip.produce; או perform trip.drive;. התצוגה מקבלת מסלול שחייה לכל חלק.
  7. פתיחת הניתוח הפונקציונלי. יש ללחוץ על התנהגות → ניתוח פונקציונלי, ללחוץ על בחירה… ולבחור DriveCycle.
  8. הצהרה על פעולה נוספת. יש להוסיף action def EmergencyShutdown;.
  9. בניית שלבים ב-FFBD. יש ללחוץ על התנהגות → FFBD, ואז על + דיאגרמה חדשה, ולבחור EmergencyShutdown. בחלונית הוספה, יש להקליד Open Contactors וללחוץ על Enter, ואז Cut Fuel.
  10. הצגת השלבים בטקסט. יש ללחוץ על מודל → עורך: ה-FFBD כתב את השלבים ואת הרצפים ביניהם.

מצבים ומעברים

בפרויקט ההתחלתי יש את החבילה PowertrainBehavior עם part def Car ריק.

  1. הגדרת האותות. יש להוסיף attribute def StartRequest;, ובאותו אופן StopRequest, PlugIn ו-Unplug.
  2. כתיבת הגדרת מצב. יש להוסיף state def PowertrainStates עם in attribute charge : Real;, entry; then off; והמצבים off, electric ו-hybrid.
  3. הוספת מעברים. אחרי state off;, יש להוסיף accept StartRequest if charge > 20 then electric; ו-accept StartRequest then hybrid;.
  4. מתן פעולות למצב. יש להחליף את state electric; בגוף שמכיל entry action spinUpMotor;, do action driveElectric; ו-exit action holdMotor;.
  5. יציאה מהמצב החשמלי. אחריו, יש להוסיף if charge < 15 then hybrid; ו-accept StopRequest then off;; יש להוסיף accept StopRequest then off; גם אחרי state hybrid;.
  6. הוספת מצב עם מעברים בעלי שם. יש להוסיף state charging { do action chargeBattery; }, transition plugIn first off accept PlugIn then charging; ו-transition unplugged first charging accept Unplug then off;.
  7. יצירת State Transition View. יש ללחוץ על התנהגות → מכונות מצבים, ואז על + דיאגרמה חדשה, ולבחור PowertrainStates תחת מציג.
  8. שרטוט מעבר מתוזמן. יש לגרור מהידית של charging אל off ולשחרר על Transition. בחלונית המעבר, יש להזין את השם charged ואת הטריגר after 30 [min].
  9. הצגה בטקסט. יש ללחוץ על מודל → עורך: המעבר כתוב כמעבר בעל שם.
  10. מתן אפשרות למכונית להציג את המצבים. ב-Car, יש להוסיף exhibit state powertrainStates : PowertrainStates;.

דרישות

בפרויקט ההתחלתי יש את החבילה VehicleRequirements עם עותק קטן של התכן: Battery, Car וה-sedan של הצי, עם מסה עצמית של 1580 ק״ג.

  1. מתן שמות למגבלות. יש להוסיף attribute maxCurbMass : MassValue = 1650 [kg]; ו-attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h];.
  2. כתיבת הגדרת דרישה. יש להוסיף requirement def <'VR-1'> CurbMass עם הצהרת doc, subject car : Car;, attribute limit : MassValue; ו-require constraint { car.curbMass <= limit }.
  3. הוספת דרישה. יש ללחוץ על ⌃⇧Space / Ctrl+Shift+Space בשורה ריקה, לבחור הגדרת דרישה ולכתוב VR-3 BatteryCapacity עם הנושא battery : Battery ו-require constraint { battery.capacity >= minBatteryCapacity }.
  4. קינון דרישות במפרט. יש להוסיף requirement carSpec עם subject car : Car; ו-requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; }.
  5. ציון מה מספק אותן. יש להוסיף satisfy carSpec by fleet.sedan; ו-satisfy requirement batterySpec : BatteryCapacity by fleet.sedan.battery;.
  6. הפרת דרישה. יש לשנות את המסה העצמית של הסדאן ל-1700 [kg]. העורך מסמן את ה-satisfy: הסדאן כבר אינו עומד ב-VR-1.1.
  7. עמידה בה שוב. יש ללחוץ על ⌘Z / Ctrl+Z, או לשנות אותה בחזרה ל-1580 [kg].
  8. הצגת טבלת הדרישות. יש ללחוץ על צרכים ודרישות → דרישות.
  9. יצירת תצוגת דרישות. בדף דיאגרמות, יש ללחוץ על + דיאגרמה חדשה, לבחור תצוגת דרישות ואת carSpec תחת מציג.
  10. בדיקת ההצהרות. יש ללחוץ על צרכים ודרישות → איכות וללחוץ על בדיקת איכות.

אימות ועקיבות

בפרויקט ההתחלתי יש את דרישת המסה העצמית ואת מפרט המכונית, מחזור נסיעה עם השלבים cruise ו-brake, את VR-6 batteryMassLimit ואת VR-7 stopFromCruise.

  1. כתיבת מקרה אימות. יש להוסיף verification def <'VC-1'> CurbMassTest עם subject car : Car;, objective massObjective { verify carSpec.sedanMass; } ו-return verdict : Boolean = car.curbMass <= maxCurbMass;.
  2. החלה על הסדאן. יש להוסיף verification <'VC-1.1'> sedanWeighing : CurbMassTest { subject car = fleet.sedan; }.
  3. פתיחת מקרי האימות. יש ללחוץ על אימות → מקרי אימות. שלבים, תוצאות ומצב הם נתוני Holarch שלצד המודל. בשורה של Sedan Weighing, יש ללחוץ על + שלבים, ואז על + הוספת צעד, להקליד Weigh the car תחת פעולה וללחוץ על החלה. לאחר מכן יש ללחוץ על עבר בלחצני המצב שלו.
  4. קריאת ה-RVTM. יש ללחוץ על אימות → RVTM.
  5. עקיבה משלב לדרישה. יש ללחוץ על אימות → מטריצת עקיבות, להציג דרישות כשורות ופעולות כעמודות, ללחוץ על התא של stopFromCruise ו-brake, ולבחור satisfied by.
  6. גזירת דרישה. יש להוסיף private import RequirementDerivation::*; ו-connection batteryMassDerivation : Derivation connect carSpec.sedanMass to batteryMassLimit;.
  7. הרצת בדיקות המודל. יש ללחוץ על אימות → בדיקות מודל.

אילוצים וחישובים

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

  1. כתיבת הגדרת אילוץ. יש להוסיף constraint def MassLimit עם in mass : MassValue;, in limit : MassValue; והביטוי mass <= limit.
  2. כתיבת חישוב. יש להוסיף calc def PowerToWeight עם הפרמטרים power ו-mass ו-return ratio = power / mass;.
  3. קשירת הערכים של הסדאן. יש להוסיף constraint sedanMassCheck : MassLimit { in mass = fleet.sedan.curbMass; in limit = maxCurbMass; }.
  4. יצירת תצוגה פרמטרית. בדף דיאגרמות, יש ללחוץ על + דיאגרמה חדשה, לבחור תצוגה פרמטרית ואת VehicleAnalysis תחת מציג. הבדיקה עוברת: 1580 ק״ג נמצא בתוך 1650 ק״ג.
  5. גרימה לכישלון הבדיקה. יש לשנות את המסה העצמית של הסדאן ל-1700 [kg]; התצוגה מראה שהבדיקה נכשלת.
  6. החזרת הבדיקה למעבר. יש לבטל את הפעולה, או לשנות את המסה בחזרה ל-1580 [kg]. פתרון הכול בודק שוב כל אילוץ.
  7. הרצת מקרה ניתוח. יש להוסיף analysis def PowerToWeightAnalysis עם מטרה שדורשת ratio >= minPowerToWeight, ו-analysis sedanPowerToWeight : PowerToWeightAnalysis { subject car = fleet.sedan; }.
  8. סימון ערכים פתוחים. יש להוסיף private import HolarchMetadata::*; ואת הדרישה VR-5 ChargeTime עם #TBR על מגבלת הזמן שלה ו-@TBD עם בעלים, תאריך יעד ונימוק על הספק המטען. TBD ו-TBR מגיעים מהספרייה HolarchMetadata של Holarch, לא מהספרייה הסטנדרטית של SysML v2; הם מתמחים במטא-נתונים הסטנדרטיים StatusInfo.
  9. פתיחת מרשם TBD/TBR. יש ללחוץ על צרכים ודרישות → TBD/TBR. זמן הטעינה מופיע עם הבעלים ותאריך היעד מהמטא-נתונים @TBD שלו. המרשם הוא לקריאה בלבד: את הבעלים או את התאריך משנים במטא-נתונים בעורך.
  10. סיכום המסה. יש ללחוץ על ארכיטקטורה → תקציבים ו-TPMs ולבחור את חלק השורש sedan.

וריאנטים ותצורות

בפרויקט ההתחלתי יש את Component, Battery, Controller, Car ו-Powertrain.

  1. ייבוא חבילת השונות. יש להוסיף private import HolarchVariability::*;.
  2. כתיבת וריאציה. בשורה ריקה, יש ללחוץ על ⌃⇧Space / Ctrl+Shift+Space (או על הוספה ▾), לבחור שונות ולהשלים variation part def BatteryPack :> Battery עם הגרסאות standardPack (1.4 קוט״ש) ו-largePack (12 קוט״ש, 120 ק״ג).
  3. כתיבת קו המוצרים. יש להוסיף part def CarLine :> Car עם part pack : BatteryPack;, variation part charger עם הגרסאות noCharger ו-wallbox, ו-assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack }.
  4. התחלת תצורה. יש לבחור הוספה ▾ → תצורה ולמלא part plugInHybrid : CarLine { @HolarchConfiguration; }. העורך מציין את נקודות השונות שעדיין פתוחות.
  5. בחירת הגרסאות. ב-plugInHybrid, יש לבחור הוספה ▾ → בחירת גרסה לכל נקודה ולמלא part :>> pack = BatteryPack::largePack; ו-part :>> charger = charger::wallbox;.
  6. הוספת תצורה שנייה. יש להוסיף את selfChargingHybrid באותו אופן, עם המארז הסטנדרטי וללא מטען.
  7. הגדרת מילת מפתח משלך. יש להוסיף metadata def <safetyCritical> SafetyCritical.
  8. שימוש במילת המפתח. ב-Powertrain, יש לכתוב #safetyCritical part controller : Controller;.
  9. הצגת קו המוצרים. יש ליצור General View של Vehicles: מארז הסוללה מסומן כ-variation.

פרויקטי מדריך

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

SysML® ו-OMG® הם סימנים מסחריים רשומים של Object Management Group, Inc. בארצות הברית ובמדינות אחרות.