Holarch

गाइड · SysML v2

SysML v2 ट्यूटोरियल: टेक्स्ट नोटेशन में CubeSat पावर सिस्टम मॉडल करें

यह गाइड सुनें 24 मिनट

यह SysML v2 ट्यूटोरियल चरण-दर-चरण एक छोटा, पूरा मॉडल बनाता है: EO-1 CubeSat का विद्युत पावर सिस्टम, उसके part, मात्राओं और इकाइयों, पोर्ट और कनेक्शन, धूप और ग्रहण के चक्र, ऐसी आवश्यकताओं जिन्हें टूल जांच सके, एक verification case और व्यू के साथ। इस पेज की हर लिस्टिंग एक भाषा इंजन से जांचा गया SysML v2 टेक्स्ट है, और हर मुख्य चरण वह आरेख दिखाता है जो टेक्स्ट बनाता है।

इस पृष्ठ पर
  1. आप क्या बनाएंगे
  2. पहला विचार: definition और usage
  3. चरण 1: एक पैकेज और उसके import
  4. चरण 2: part definition और इकाइयों वाले attribute
  5. चरण 3: असेंबली, मानों के साथ
  6. चरण 4: पोर्ट, इंटरफ़ेस और कनेक्शन
  7. चरण 5: action और flow के साथ व्यवहार
  8. चरण 6: व्यवहार को संरचना पर आवंटित करें
  9. चरण 7: constraint वाली आवश्यकताएं
  10. चरण 8: एक verification case
  11. चरण 9: व्यू और आरेख
  12. पूरा मॉडल
  13. लिस्टिंग कैसे जांची गईं
  14. Holarch में आज़माएं
  15. आगे कहाँ जाएं

आप क्या बनाएंगे

EO-1 एक 6U पृथ्वी-अवलोकन CubeSat है जो 500 km की sun-synchronous ऑर्बिट में है। यह इन गाइडों का साझा उदाहरण है; MBSE उदाहरण प्रोजेक्ट पूरे अंतरिक्ष यान को ज़रूरतों से सत्यापन तक ले जाता है। यह ट्यूटोरियल एक सबसिस्टम, विद्युत पावर सिस्टम (EPS), लेता है और उसे SysML v2 टेक्स्ट में लिखता है।

EPS के तीन part हैं। दो खुलने वाले सोलर ऐरे धूप को पावर में बदलते हैं। एक लिथियम-आयन बैटरी पैक ग्रहण के लिए ऊर्जा संग्रहीत करता है। एक पावर डिस्ट्रीब्यूशन यूनिट (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-band ट्रांसमीटर6.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 Test20 °C चैंबर में C/2 पर डिस्चार्जचरण 8

मॉडल में तीन पैकेज हैं:

पैकेजक्या रखता हैचरण
CubeSatEPSपोर्ट, part, एक calculation, मानों के साथ असेंबली, और व्यवहार1 से 6
CubeSatEPSRequirementsआवश्यकताएं 3.1 से 3.3 और verification case TC-077 और 8
CubeSatEPSViewsआरेखों के लिए मॉडल के हिस्से चुनने वाले व्यू9

साथ चलने के लिए किसी विशेष टूल की ज़रूरत नहीं: टेक्स्ट सादा SysML v2 है और टेक्स्ट नोटेशन पढ़ने वाले किसी भी टूल में लोड होता है। पूरा मॉडल पेज के अंत में और डाउनलोड के रूप में है, और अंतिम खंड दिखाता है कि इसे Holarch में कैसे लोड करें।

पहला विचार: definition और usage

SysML v2 definition को usage से अलग करता है। definition बताती है कि कोई प्रकार की चीज़ क्या है: part def BatteryPack इस डिज़ाइन के हर बैटरी पैक का वर्णन करता है, उसके attribute और पोर्ट के साथ। usage किसी संदर्भ में ऐसी एक चीज़ है: पावर सिस्टम के भीतर part battery : BatteryPack, EO-1 के EPS की एकमात्र बैटरी है, जो उसके PDU से जुड़ी है।

यही जोड़ी पूरी भाषा में चलती है: attribute def और attribute, port def और port, action def और action, requirement def और requirement। def के बाद आने वाला कीवर्ड एक प्रकार घोषित करता है; def के बिना वही कीवर्ड उसका उपयोग करता है। विशिष्ट मान आमतौर पर usage पर होते हैं, क्योंकि usage वह जगह है जहाँ डिज़ाइन निर्णय लिया जाता है।

SysML v1 जानने वाले पाठक definition की तुलना block से और usage की part property से कर सकते हैं। SysML v2 में यह विचार हर प्रकार के एलिमेंट पर लागू होता है, और usage किसी भी गहराई तक नेस्ट होते और एक-दूसरे को परिष्कृत करते हैं। SysML v1 बनाम SysML v2 दोनों भाषाओं की निर्माण-दर-निर्माण तुलना करता है।

चरण 1: एक पैकेज और उसके import

पैकेज एक namespace है: यह एलिमेंट को समूहित करता है और उन्हें CubeSatEPS::BatteryPack जैसे qualified name देता है। एक ख़ाली पैकेज और उसकी ज़रूरत के लाइब्रेरी import से शुरू करें।

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 /* … */ पैकेज से दस्तावेज़ीकरण जोड़ता है। // टिप्पणी के विपरीत, यह मॉडल का हिस्सा है, और टूल इसे एलिमेंट के साथ दिखाते हैं।
  • ScalarValues Real, Integer, Boolean और String जैसे मूल प्रकार देता है।
  • ISQ International System of Quantities से मात्रा प्रकार देता है, जैसे MassValue, PowerValue और EnergyValue।
  • SI kg, V, W और h जैसी SI इकाइयां देता है।
  • private import किए गए नामों को इसी पैकेज के भीतर रखता है, ताकि CubeSatEPS को import करने वाले पैकेज को वे इसके माध्यम से न मिलें।

import के बिना MassValue जैसा नाम हल नहीं हो सकता, और चेकर उसे अज्ञात रिपोर्ट करता है।

चरण 2: part definition और इकाइयों वाले attribute

हर कंपोनेंट को टाइप किए गए attribute वाली एक part definition मिलती है। attribute को Real के बजाय किसी मात्रा से टाइप करने से दर्ज होता है कि वह क्या मापता है: द्रव्यमान, पावर, ऊर्जा। फिर टूल हर मान और हर expression में आयामों की संगति जांच सकता है।

  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;
  }

ये पंक्तियां पैकेज के कोष्ठकों के भीतर जाती हैं। दोनों दक्षताएं सादा Real रहती हैं क्योंकि वे बिना इकाई के अनुपात हैं।

अभी कोई मान नहीं है। definition इस प्रकार के हर बैटरी पैक का वर्णन करती है; संख्याएं अगले चरण में EO-1 की अपनी बैटरी के साथ आती हैं।

चरण 3: असेंबली, मानों के साथ

पावर सिस्टम भी एक part definition है, जो part usage से बनी है: सोलर ऐरे, बैटरी और PDU। हर usage अपनी definition से विरासत में मिले attribute को मान देता है। एक पुन: उपयोग योग्य calculation ऐरे की शिखर पावर को उस ऑर्बिट-औसत पावर में बदलती है जिसके सामने आवश्यकता 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 battery नाम का एक usage घोषित करता है, जो definition 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 इनपुट और टाइप किए गए परिणाम वाली एक calculation है। OrbitAverage(…) इसे ऐरे के मानों के साथ बुलाता है, इसलिए सूत्र एक बार लिखा जाता है और उसका हर उपयोग परिवर्तन के साथ चलता है।
  • depthOfDischarge एक ऊर्जा को एक ऊर्जा से भाग देता है। इकाइयां कट जाती हैं, और परिणाम एक सादा अनुपात है।
  • Spacecraft पावर सिस्टम को उन दो लोड के साथ रखता है जिनका यह ट्यूटोरियल अनुसरण करता है। मॉडल को छोटा रखने के लिए EO-1 का बाकी हिस्सा (एटिट्यूड कंट्रोल, फ़्लाइट कंप्यूटर, संरचना) छोड़ दिया गया है।

मान केवल संग्रहीत नहीं होते; टूल उनका मूल्यांकन करता है। ऊपर की संख्याओं के साथ:

एट्रिब्यूटExpressionपरिणाम
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.295 दक्षता पर 0.2 m² सेल, 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 में संपादक पंक्ति को आयाम त्रुटि से चिह्नित करता है। किसी स्प्रेडशीट में यही चूक बिना पकड़े depth of discharge तक पहुँच जाती।

चरण 4: पोर्ट, इंटरफ़ेस और कनेक्शन

पोर्ट वे बिंदु हैं जहाँ कोई part अपने परिवेश से मिलता है। port definition सीमा पार करने वाली चीज़ें सूचीबद्ध करती है, हर फ़ीचर एक दिशा के साथ: स्वामी जो भेजता है उसके लिए 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 definition उपयोग करता है, ~ से conjugate करके। ~BusPowerPort, BusPowerPort का दर्पण रूप है: हर out, in बन जाता है। एक port definition किसी लिंक के दोनों सिरों का वर्णन करती है, इसलिए दोनों सिरे एक-दूसरे से अलग नहीं हो सकते।

interface definition टाइप किए गए सिरों वाले एक प्रकार के कनेक्शन का वर्णन करती है। BusLink 12 V बस को, जो पावर भेजती है, उसे प्राप्त करने वाले लोड से जोड़ता है। यह EO-1 के 12 V Power Interface (IFB-1) की भूमिका निभाता है।

अब part में पोर्ट जोड़ें और उन्हें कनेक्ट करें। टिप्पणी वाली पंक्तियां पिछले चरणों की पंक्तियों के स्थान पर हैं।

  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 एक सादा कनेक्शन है: ऐरे हार्नेस (EO-1 का इंटरफ़ेस IF-20)। battery.cellsOut से pdu.batteryIn बैटरी हार्नेस (IF-21) है।
  • bind bus = pdu.busOut बताता है कि पावर सिस्टम का अपना bus पोर्ट और PDU का आउटपुट एक ही चीज़ हैं। इसी तरह कोई part किसी भीतरी पोर्ट को अपनी सीमा पर उजागर करता है: लोड EPS से जुड़ते हैं, उसके भीतर से नहीं।
  • interface payloadPower : BusLink connect … to … दो पोर्ट को एक टाइप किए गए इंटरफ़ेस से जोड़ता है, इसलिए कनेक्शन BusLink का अर्थ वहन करता है। दोनों बस इंटरफ़ेस EO-1 की Payload Power Line (IF-01) और Radio Power Line (IF-04) हैं।

Interconnection View इस टेक्स्ट से पावर सिस्टम बनाता है: हर part किनारे पर अपने पोर्ट के साथ, conjugated पोर्ट ~ से चिह्नित, और फ़्रेम पर बंधा bus पोर्ट।

चरण 9 का व्यू epsConnections: EPS के part, उनके पोर्ट और कनेक्शन, टेक्स्ट से बनाए गए।

इंजीनियरिंग परिणाम: सबसिस्टम की इंटरफ़ेस सूची अब एक क्वेरी है, अलग तालिका नहीं। हर कनेक्शन दोनों सिरों का नाम लेता है और, टाइप होने पर, यह भी कि उसके पार क्या जाता है। यही इंटरफ़ेस कंट्रोल दस्तावेज़ का कच्चा माल है, और यह मॉडल बदलने पर बदलता है।

एक आम ग़लती दोनों सिरों को एक जैसा, बिना conjugate किया पोर्ट देना है। तब दोनों सिरे भेजते हैं और कोई प्राप्त नहीं करता:

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 भेजते हैं। प्राप्त करने वाले सिरे को conjugate करना, port powerIn : ~BusPowerPort;, इसे ठीक करता है।

चरण 5: action और flow के साथ व्यवहार

संरचना बताती है कि सिस्टम क्या है; व्यवहार बताता है कि वह क्या करता है। action definition इनपुट और आउटपुट पैरामीटर वाले व्यवहार का वर्णन करती है। item definition बहने वाली चीज़ों का वर्णन करती हैं, यहाँ धूप और उसके विभिन्न रूपों में विद्युत पावर।

  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 usage एक ऑर्बिट के चरण हैं: धूप में ऐरे पावर एकत्र करते हैं और PDU बैटरी चार्ज करती है; ग्रहण में बैटरी ऊर्जा वापस देती है और PDU उससे बस को पावर देती है।
  • flow collect.power to charge.power बताता है कि एक चरण का आउटपुट अगले का इनपुट है।
  • first collect then charge एक succession है: अगला चरण शुरू होने से पहले एक चरण पूरा होता है। flow बताते हैं कि क्या चलता है; succession बताते हैं कि किस क्रम में। start और done घेरने वाले action का आरंभ और अंत हैं।

चरण EO-1 के पावर फ़ंक्शन से मेल खाते हैं: F3.1 Convert Sunlight to Power, F3.2 Store Battery Energy और F3.3 Regulate Bus Power। आवश्यकताओं से ऐसे फ़ंक्शन निकालना और उन्हें क्रम देना फ़ंक्शनल विश्लेषण का विषय है; action definition वह जगह है जहाँ वह काम SysML v2 में पहुँचता है।

नीचे का Action Flow View इस टेक्स्ट से चरण 6 के आवंटन के साथ बनाया गया है, जो हर चरण को एक स्विमलेन देता है।

व्यू 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 पैकेज के शीर्ष पर Spacecraft का एक usage है: इस डिज़ाइन का अंतरिक्ष यान। इसका पावर सिस्टम RunPowerCycle perform करता है, और EPS का हर part अपने चरण perform करता है। part redefines eps दूसरा जोड़ने के बजाय Spacecraft से विरासत में मिले पावर सिस्टम को परिष्कृत करता है। PDU दो चरण perform करती है, धूप में चार्ज करना और ग्रहण में बस को पावर देना, क्योंकि एक ही यूनिट दोनों काम करती है।

यह फ़ंक्शनल आवंटन का टेक्स्ट रूप है। इससे टूल हर कंपोनेंट द्वारा किए जाने वाले फ़ंक्शन सूचीबद्ध कर सकता है, या ऊपर के व्यू की तरह हर part के लिए एक लेन के साथ action flow बना सकता है।

चरण 7: constraint वाली आवश्यकताएं

आवश्यकताएं अपने पैकेज में जाती हैं, जो डिज़ाइन को import करता है। SysML v2 में आवश्यकता किसी subject पर एक constraint है: doc टेक्स्ट शब्दों में बताता है कि क्या चाहिए, और require constraint वही बात ऐसे रूप में कहता है जिसका टूल मूल्यांकन कर सके। तीनों आवश्यकताएं EO-1 की आवश्यकताएं 3.1, 3.2 और 3.3 हैं, अपनी id और शब्दों के साथ।

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'> एक short name है: वह पहचानकर्ता जिसे इंजीनियर समीक्षाओं में उद्धृत करते हैं। अन्य मॉडल एलिमेंट पूरे नाम, OrbitAveragePower, का संदर्भ देते हैं।
  • subject eps : ElectricalPowerSystem बताता है कि आवश्यकता किस बारे में है।
  • require constraint { eps.orbitAveragePower >= required } वह शर्त है जो सही होनी चाहिए। सीमा एक पैरामीटर है, इसलिए वही definition अलग पावर ज़रूरत वाले अंतरिक्ष यान के लिए भी काम आती है।
  • powerSpec EO-1 की आवश्यकताओं को एकत्र करता है और सीमाएं तय करता है: 28 W, 77 Wh और 0.3।
  • satisfy powerSpec by eo1.eps दावा करता है कि EO-1 का पावर सिस्टम विनिर्देश पूरा करता है।

doc टेक्स्ट और constraint को एक ही बात कहते हुए रखें। समीक्षक टेक्स्ट पढ़ते हैं; टूल constraint का मूल्यांकन करते हैं। आवश्यकता से डिज़ाइन और टेस्ट तक के लिंक ही वह आधार हैं जिस पर आवश्यकता ट्रेसेबिलिटी बनती है।

Requirement View विनिर्देश को एक ट्री के रूप में दिखाता है, satisfy करने वाले part और चरण 8 के verification case के साथ:

व्यू requirementTree: आवश्यकताएं 3.1 से 3.3, उन्हें क्या satisfy करता है और क्या सत्यापित करता है।

क्योंकि constraint का मूल्यांकन हो सकता है, चेकर satisfy रेखा बनाने से अधिक करता है: वह दावे को चरण 3 के मानों के सामने टेस्ट करता है। मॉडल जैसा लिखा है, उसमें तीनों सही हैं: 28 W के सामने 28.05 W, 77 Wh के सामने 77 Wh, और 0.3 के सामने 0.24 का depth of discharge।

इनमें से पहला मार्जिन पतला है। पावर पथ दक्षता को 0.6 से 0.59 करें, दो प्रतिशत से कम का परिवर्तन, और ऑर्बिट-औसत पावर 27.58 W रह जाती है। तब चेकर रिपोर्ट करता है कि आवश्यकता 3.1 अब पूरी नहीं होती, उसे तोड़ने वाले मानों के साथ:

एक डिज़ाइन मान बदलने के बाद आवश्यकता जांच: चेतावनी आवश्यकता, part, constraint और मानों का नाम लेती है।

इंजीनियरिंग परिणाम: आवश्यकता 3.1 पहले से सिस्टम मार्जिन रखती है (उसका EO-1 औचित्य 24 W इमेजिंग-मोड लोड और 15% है), लेकिन ऐरे स्वयं 3.1 को केवल 0.05 W की बचत के साथ पूरा करते हैं। अनुमान में न शामिल कोई भी हानि, जैसे सेल का तेज़ क्षरण, या तो अधिक ऐरे क्षेत्रफल या छोटा लोड मांगती है। हर परिवर्तन पर आवश्यकता जांचने वाला मॉडल यह संख्या बदलते ही दिखाता है, अगली समीक्षा में नहीं। इनपुट निश्चित न होकर अनिश्चित हों तो मार्जिन के बने रहने की कितनी संभावना है, यह देखने के लिए देखें सिस्टम इंजीनियरिंग में Monte Carlo विश्लेषण।

चरण 8: एक verification case

satisfy संबंध एक दावा है, और चरण 7 की जांच उसे केवल मॉडल की अपनी संख्याओं के सामने टेस्ट करती है। verification case बताता है कि असली हार्डवेयर पर दावे की जांच कैसे होती है, टेस्ट, निरीक्षण, विश्लेषण या प्रदर्शन से। 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; } उस आवश्यकता का नाम लेता है जिसे यह case सत्यापित करता है। इन्हीं लिंक से सत्यापन मैट्रिक्स बनता है: हर आवश्यकता उसे सत्यापित करने वाले case के सामने।
  • return verdict परिणाम है: यहाँ, क्या मापी गई क्षमता आवश्यकता 3.2 के 77 Wh तक पहुँचती है।
  • batteryTest EO-1 के पावर सिस्टम के लिए case का एक usage है: नियोजित टेस्ट, जिसका subject eo1.eps से बंधा है।

संतुष्टि और सत्यापन जानबूझकर अलग रखे जाते हैं। संतुष्टि बताती है कि कौन सा डिज़ाइन एलिमेंट किसी आवश्यकता का उत्तर देता है; सत्यापन बताता है कि आप कैसे जानते हैं कि वह देता है। EO-1 प्रोजेक्ट में, TC-07 78.3 Wh मापकर पास हुआ है। आवश्यकताओं 3.1 और 3.3 को अब भी अपने case चाहिए, और आवश्यकता सत्यापन मैट्रिक्स वह जगह है जहाँ वह कमी दिखती है।

चरण 9: व्यू और आरेख

SysML v2 में आरेख कोई अलग चित्र नहीं है। व्यू मॉडल का एक एलिमेंट है जो बताता है कि क्या दिखाना है (expose) और किस प्रकार के एलिमेंट शामिल करने हैं (filter)। टूल व्यू को रेंडर करता है और उसका लेआउट रखता है; सामग्री हमेशा मॉडल से आती है। ऊपर के तीन स्क्रीनशॉट यही तीन व्यू हैं।

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::**;
  }
}

मानक लाइब्रेरी आम व्यू प्रकार परिभाषित करती है:

व्यूदिखाता हैइस मॉडल में
General Viewकोई भी एलिमेंट और उनके संबंध, बॉक्स और रेखाओं के रूप मेंrequirementTree
Interconnection Viewएक असेंबली के part उनके पोर्ट और कनेक्शन के साथepsConnections
Action Flow Viewकिसी व्यवहार के चरण, उनका क्रम और उनके बीच क्या बहता हैpowerCycleFlow
स्टेट ट्रांज़िशन व्यूState और उनके बीच के ट्रांज़िशनकोई नहीं
Sequence Viewसमय के साथ part के बीच संदेशकोई नहीं
Grid Viewतालिका या मैट्रिक्स के रूप में एलिमेंट या संबंधकोई नहीं

requirementTree एक General View है जिसका फ़िल्टर केवल आवश्यकताएं और satisfy संबंध रखता है; SysML v1 आरेख प्रकार जानने वाले टूल, Holarch सहित, ऐसे व्यू को requirement diagram के रूप में दिखाते हैं। क्योंकि व्यू मॉडल का हिस्सा है, बैटरी का नाम बदलने से उसे दिखाने वाला हर आरेख बदल जाता है, और समीक्षक टेक्स्ट में ठीक-ठीक पढ़ सकता है कि किसी आरेख में क्या शामिल है।

पूरा मॉडल

तीनों पैकेज एक साथ। 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 से पार्स और जांचा गया, जो Holarch के SysML v2 संपादक के पीछे का इंजन है, SysML v2 मानक लाइब्रेरी लोड करके। जांच हर नाम को हल करती हैं, इकाइयों और आयामों की तुलना करती हैं, कनेक्शन के पार पोर्ट दिशाओं की तुलना करती हैं, और requirement constraint का उन्हें satisfy करने वाले मानों के सामने मूल्यांकन करती हैं।

  • पूरा मॉडल और अलग लिस्टिंग कोई त्रुटि या चेतावनी नहीं देते।
  • हर अंश पूरे मॉडल में पंक्ति-दर-पंक्ति, क्रम में दिखता है।
  • ग़लतियां दिखाने वाली दो लिस्टिंग ठीक वही त्रुटि और चेतावनी देती हैं जो उनके पास बताई गई है।
  • 0.59 की पावर पथ दक्षता वाला पूरा मॉडल ठीक एक चेतावनी देता है: आवश्यकता 3.1 पूरी नहीं हुई।

इंजन कौन से SysML v2 निर्माण समर्थित करता है और उसकी ज्ञात कमियों के लिए, देखें SysML v2 भाषा कवरेज। इन्हीं बिंदुओं पर टूल की तुलना के लिए, देखें SysML v2 टूल में क्या जांचें; यह मॉडल टेस्ट फ़ाइल के रूप में काम आने लायक छोटा है।

Holarch में आज़माएं

  1. cubesat-eps.sysml डाउनलोड करें, या पूरे मॉडल को उस नाम से सहेजें।
  2. मॉडल → आयात और निर्यात खोलें, नए SysML v2 प्रोजेक्ट में चुनें और फ़ाइल छोड़ें। देखें फ़ाइलें नए प्रोजेक्ट में आयात करें।
  3. टेक्स्ट पढ़ने और बदलने के लिए मॉडल → संपादक खोलें। हर पैकेज एक दस्तावेज़ है। देखें संपादक।
  4. आरेख सूची खोलें और epsConnections, powerCycleFlow या requirementTree पर क्लिक करें। देखें व्यू खोलें।
  5. CubeSatEPS में pathEfficiency = 0.6 को 0.59 में बदलें और रुकें। संपादक CubeSatEPSRequirements में satisfy पंक्ति पर चेतावनी दिखाता है। ⌘Z / Ctrl+Z से पूर्ववत करें।

इसके बजाय मॉडल टाइप करने के लिए, एक SysML v2 प्रोजेक्ट बनाएं, संपादक में + नया पैकेज पर क्लिक करें, और चरण क्रम से लिखें; पार्स होने वाला टेक्स्ट थोड़े ठहराव के बाद लागू होता है। देखें SysML v2 प्रोजेक्ट के साथ शुरुआत। पूरा EO-1 अंतरिक्ष यान, उसके दस्तावेज़, टेस्ट और बजट के साथ, CubeSat डेमो है: प्रोजेक्ट फ़ाइलें ▾ → नया डेमो प्रोजेक्ट।

आगे कहाँ जाएं