SysML-AT: Automation Modeling

• SysML-AT is a domain-specific extension of SysML, introducing novel stereotypes to model both software and hardware aspects of manufacturing automation.
• It supports a complete model-driven engineering workflow, mapping requirements to system architecture and automating IEC 61131-3 code generation.
• Tool integration and live debugging in environments like CODESYS enhance system validation and industrial adoption through improved maintainability and accuracy.

SysML-AT (SysML for Automation) denotes a specialized extension of the Systems Modeling Language (SysML) targeted at manufacturing automation software projects. It encompasses novel stereotypes for both software and hardware abstractions, integrated requirements modeling (including non-functional constraints), and automated code generation for IEC 61131-3 compliant programmable logic controllers (PLCs) within a model-driven engineering (MDE) process. SysML-AT serves as a unified modeling approach enabling engineers to specify, analyze, and deploy automation solutions while maintaining consistency and traceability across the system lifecycle (Vogel-Heuser et al., 2022).

1. Language Profile and Modeling Extensions

SysML-AT is realized as a custom SysML profile that introduces domain-specific stereotypes and notation elements for the automation domain. Core extensions include:

• Automation Function (AF): Abstracts manufacturing functions (e.g., transport, detection). AFs encapsulate logical, reusable fragments of system behavior aligned with automation requirements.
• Software Application (SA): Represents software components/units that realize specific AFs. SAs are detailed with ports (InPort, OutPort) connected to internal logic and mapped to hardware resources.
• Hardware Elements: Stereotypes such as «node», «sensor», «actuator» extend standard blocks to capture proprietary hardware, associated properties (e.g., communication interfaces, AMSNetId), and deployment topology.

This modeling enhancement supports the definition of both the logical view (AF decomposition) and the concrete mapping to execution resources (deployment of SAs onto nodes with sensor/actuator interfaces).

2. Model-Driven Engineering Workflow

SysML-AT underpins a complete MDE process structured as follows:

1. Requirements Modeling: Both functional and non-functional requirements are specified in SysML notation, hierarchically refined, and traced to their realization within AFs and SAs. Non-functional requirements are modeled as type-value pairs (e.g., end-to-end response time: 10ms), driving hardware selection and software architecture.
2. Software Architecture Modeling: SAs are decomposed according to functional requirements and associated with explicit ports/interfaces.
3. Hardware Architecture Modeling: Physical controllers and devices (nodes, sensors, actuators) are incorporated, capturing vendor-specific parameters.
4. Deployment Mapping: SAs are allocated onto hardware nodes, establishing connections between software interfaces and physical I/O.
5. Automated Code Generation: The final SysML-AT model is transformed to PLC code in IEC 61131-3 (Structured Text), following a cyclic execution pattern enforced by modeled invocation order.

The process implements the Object Management Group’s (OMG) Model-Driven Architecture (MDA) pattern, with SysML-AT models as platform-independent models (PIM) transformed to platform-specific models (PSM) for IEC 61131-3 execution.

3. Software–Hardware Integration and Parametric Modeling

SysML-AT achieves tight software–hardware integration by:

• Modeling SAs with explicit port representations, directly mapping to PLC variable declarations.
• Annotating hardware blocks (e.g., Beckhoff CX nodes) with deployment-specific information, ensuring a rigorous match between modeled and realized interfaces.
• Using parametric diagrams to formally express local behavior and computation as sequences of function block (FB) or function (FC) calls (ordered via the “orderNumber” attribute).
• Supporting hierarchical decomposition, enabling encapsulation of complex automation functions and clear association to physical control modules.

This dual abstraction fosters consistent system specification, automated interface generation, and seamless traversal from system logic down to programmable real-time execution.

4. Automation of IEC 61131-3 Code Generation

SysML-AT supports direct model-to-text (M2T) transformation for IEC 61131-3 through:

• Template-driven extraction (using MOFM2T) of both declaration and implementation segments for each modeled SA, including variable, port, and invocation definitions.
• Application of Object Constraint Language (OCL) expressions to ensure order, uniqueness, and syntactic correctness (e.g., templates generate calls for each OrderedInstance in orderNumber sequence).
• Automatic alignment of implemented code with the full SysML-AT model, enabling iterative code regeneration when the model is updated—minimizing manual recoding and reducing errors.

Indented model elements and their relationships are faithfully mapped, with properties and invocation orders from the parametric diagrams deterministically reflected in the generated PLC code.

5. Tool Support and Debugging Capabilities

A SysML-AT-aware editor has been implemented as a plugin within the CODESYS V3 development environment. Key features include:

• Integrated Model Editor: Engineers develop parametric diagrams and model system behavior directly within the same environment used for code deployment.
• Live Debugging: The environment supports visualization of real-time variable states, breakpoints, and variable overrides, leveraging the coupling of model and soft-PLC runtime.
• Pre-compilation Review: Engineers can inspect automatically generated IEC 61131-3 code prior to compilation, ensuring fidelity against the high-level model.

This feedback loop enables rapid issue isolation and correction during design and validation phases.

6. Evaluation, Usability, and Industrial Implications

Multiple forms of evaluation were conducted:

• Case Studies: Application to laboratory and industrial-scale manufacturing systems confirmed the approach’s viability for both centralized and decentralized control architectures.
• Usability Experiments: Quantitative scoring with undergraduate engineering students demonstrated that SysML-AT enables more complete and correct modeling, particularly in architectural integrity and connection representations.
• Industrial Expert Validation: Interviews with automation vendors and manufacturers found SysML-AT beneficial for maintaining system consistency, though transition challenges exist for legacy system integration.

Long-term adoption is supported by improved traceability, reduced error propagation, enhanced maintainability, and model-driven clarity across both software and hardware system components.

7. Significance and Challenges

SysML-AT constitutes a domain-specific evolution of SysML for industrial automation, where explicit software–hardware abstraction and automated artifact synthesis are mandated by system complexity and high assurance requirements. Its value lies in:

• Enforcing end-to-end consistency from requirements to code.
• Reducing manual coding efforts and associated errors.
• Enabling efficient debugging and system validation.
• Bridging traditional engineering and modern automation software development processes.

However, increased upfront modeling effort and potential tool learning curves are recognized. The approach’s benefit grows with system scale and design evolution, justifying initial investments through improved maintainability and clarity (Vogel-Heuser et al., 2022).