← Back to Recording

Summary

Overview

This course session provides a comprehensive, hands-on guide to model-based systems engineering (MBSE) using Cameo, with a strong emphasis on leveraging AI (ChatGPT) to accelerate and streamline the creation of system models. The session transitions from conceptual modeling (requirements and use cases) into logical architecture, teaching a domain-driven, pain-free approach to SysML modeling. Key topics include recursive subsystem decomposition, interface block definition, signal and flow property management, internal block diagrams (IBDs), state machines, and simulation. The instructor advocates for efficient modeling practices that avoid common pitfalls like item flow violations and excessive functional decomposition, promoting a streamlined workflow that reduces modeling time and complexity. The session concludes with a demonstration of how AI-generated system descriptions can be directly translated into structured SysML models.

Topic (Timeline)

1. Requirements Modeling in Cameo [00:00:09 - 00:12:40]

  • Demonstrated creation and population of a requirements table within a Cameo package, showing bidirectional sync between diagram and table views.
  • Explained requirements numbering: how prefixes and separators are scoped per package, and how gaps arise from adding/deleting requirements.
  • Revealed the hidden “Renumber Recursively” feature via the “Details” button to auto-correct numbering gaps.
  • Showed containment relationships: using containment to nest requirements (e.g., “real-time display” under “user interface”), which auto-renumbers child requirements (e.g., 3.1).
  • Demonstrated dynamic column customization in requirements tables (e.g., adding “satisfied by”) and the behavior of the columns tab when the window is shrunk horizontally (replaced by “>>” toggle).
  • Introduced AI-assisted requirements generation: using ChatGPT to generate requirements in CSV format, then importing into Cameo, with emphasis on matching column structure.

2. Use Case Modeling with AI and SysML [00:12:42 - 00:40:02]

  • Differentiated business use cases from software/system use cases: emphasized that use case names must be verb phrases (e.g., “acquire image”), not nouns.
  • Discussed AI-generated use case narratives: showed how ChatGPT defaults to verbose “fully dressed” templates (Alastair Coberne) with pre/post-conditions, but recommended a concise, scenario-based style focused on main success and exception flows.
  • Highlighted that AI often omits internal implementation details (e.g., “software communicates focus settings”) and frequently misses exception behavior, requiring manual review.
  • Introduced the concept of scenario decomposition (user-centric) vs. functional decomposition (system-centric), warning that skipping scenario analysis leads to “Swiss cheese” requirements.
  • Demonstrated use of activity diagrams to detail alternate/exception flows (not for functional decomposition), and sequence diagrams to map behavior to operations.
  • Presented a reusable use case template format with step numbering, alternate flows, and rejoin points, and showed how to train AI to follow this format.
  • Showed AI-generated UI wireframes (HTML/CSS) for use case validation and UI design.
  • Created a SysML use case diagram in Cameo for an electron microscope: defined actors, use cases, and relationships (include, extend).
  • Demonstrated “extend” relationships for exception handling: created extension points (e.g., “storage full”, “connection lost”) and linked them to exception use cases.
  • Showed the “Use Case Scenario Sketch” feature in Cameo 2024 to auto-generate activity diagrams from narrative steps, but warned it is buggy and may crash the tool; recommended manual diagramming instead.

3. Logical Architecture: Domain-Driven Design [00:40:08 - 01:20:30]

  • Shifted from functional decomposition to domain-driven logical architecture: started with a problem domain model (from yesterday) as the foundation.
  • Introduced recursive subsystem decomposition: identify top-level subsystems, then decompose each into its parts until reaching component level (clear stopping rule).
  • Created a Block Definition Diagram (BDD) of subsystems for an electron microscope using AI-generated list (e.g., “electron gun”, “image processing”, “power supply”).
  • Defined interface blocks (e.g., “iPower”, “iEBeam”) with flow properties (in/out) and typed them with signals (e.g., “power distribution”).
  • Created a separate package for signals and defined all signals to type flow properties, avoiding item flow violations later.
  • Constructed an Internal Block Diagram (IBD) showing power flow: used proxy ports typed to interface blocks, applied port conjugation to fix direction mismatches, and used item flow manager to connect typed flow properties to connectors.
  • Emphasized the critical sequence: define interface blocks → define flow properties → define signals → create IBDs. This avoids 80% of item flow errors.
  • Noted that Cameo’s item flow manager and requirement numbering are the two most painful UIs in SysML, and the above sequence minimizes their use.

4. Top-Level State Machine and Simulation [01:20:32 - 01:52:28]

  • Used ChatGPT to generate a top-level state machine for the electron microscope: states included “initialization”, “idle”, “stage control”, “imaging”, “image processing”, “analyze images”, “generate report”.
  • Created a SysML state machine diagram in Cameo, mapping AI-generated states and transitions.
  • Introduced state machine syntax: initial/final states, pseudo-states, transitions triggered by signals, and nested substates.
  • Generated missing signals (e.g., “position stage”, “initialization complete”) by typing them directly on transitions.
  • Demonstrated the Cameo simulator: used VCR-style controls to step through state transitions by triggering signals (e.g., “position stage” moves from “ready” to “stage control”).
  • Simulated the state machine to validate behavior: confirmed transitions follow signal triggers and substates resolve correctly.
  • Noted that state names are typically verbs or past participles (e.g., “moving”, “analyzed”) representing system conditions, not nouns.

5. Recursive Subsystem Decomposition and Component-Level Modeling [01:52:30 - 02:47:46]

  • Performed recursive decomposition on the “sample stage” subsystem: created a child BDD within the subsystem block.
  • Used AI-generated list to rapidly create components: X-Motor, Y-Motor, X-Position Sensor, X-Limits, Y-Limits, Move Algorithm.
  • Replaced the “Move Algorithm” block with an Activity to better represent behavior.
  • Added operations (methods) directly to component blocks (e.g., “move()”, “setSpeed()”) instead of creating nested activity diagrams.
  • Emphasized that this approach uncovers all necessary functions without the overhead of deep functional decomposition trees.
  • Highlighted efficiency: operations on blocks are faster to define and maintain than complex activity diagram hierarchies.
  • Noted that object flows, pins, and activity parameters on IBDs are avoided to prevent “Chinese fire drills” of propagation errors.
  • Concluded that defining behavior via operations on blocks, combined with state machines and interface blocks, provides a complete, maintainable, and scalable architecture model.

Appendix

Key Principles

  • Domain-Driven Architecture: Start with the problem domain (e.g., sample stage, electron beam) to define stable abstractions, not mutable requirements or functions.
  • Recursive Subsystem Decomposition: Decompose by subsystems, not functions. Stop when components are reached. This provides a clear, scalable structure.
  • Pain-Free SysML: Avoid object flows, item flow violations, and deep activity diagram nesting. Use control flows and define operations on blocks instead.
  • AI as a Co-Pilot: Use ChatGPT to generate subsystems, interfaces, signals, use cases, and state machines. Always validate and refine output.
  • Sequence Matters: Define interface blocks → flow properties → signals → IBDs. This prevents 80% of modeling errors.

Tools Used

  • Cameo Systems Modeler (2024)
  • ChatGPT (for generating requirements, use cases, subsystems, signals, state machines, UI wireframes)
  • SysML BDD, IBD, State Machine, Use Case Diagrams
  • Cameo Simulator

Common Pitfalls & Mitigations

Pitfall Mitigation
Item flow violations on IBDs Define interface blocks and signals before creating IBDs. Use proxy ports and conjugation.
Requirement numbering gaps Use “Renumber Recursively” feature. Avoid manual deletion/insertion.
Overly verbose use cases Use concise, scenario-based templates focused on main success and exception flows.
Functional decomposition trees Use recursive subsystem decomposition instead. Stop at component level.
Object flows on activity diagrams Use control flows only. Define input/output parameters on block operations, not activity pins.
AI hallucinations Always validate AI output. Cross-check with domain knowledge.

Practice Suggestions

  • Train ChatGPT to use your preferred use case and state machine template by providing examples.
  • Create a “Pain-Free MBSE” checklist: 1) Domain model first, 2) Subsystems, 3) Interfaces, 4) Signals, 5) IBDs, 6) State machines, 7) Operations on blocks.
  • For new projects, use AI to generate the initial subsystem and interface list, then build the model manually to ensure understanding.
  • Simulate state machines early to validate system behavior before coding.
  • Avoid using Cameo’s “Use Case Scenario Sketch” feature due to instability; manually draw activity diagrams from narrative.