CREEM Technical Deep Dive Manual

Common Runtime Engineering Exchange Model

The Common Behavioral Model Behind Workflow Canvas (WFC), an IT/OT Data Fusion and Execution Platform

Document basis: This manual presents an English technical version of the source standard draft “Smart Factory — Reconfigurable Modeling Rules for Production Systems” (GB/T XXXXX—2026, approval draft).
Positioning: In the WFC context, CREEM is the common runtime engineering exchange model for describing IT/OT assets, behaviors, workflows, execution logic, and engineering knowledge in one interoperable system.

Table of Contents

  1. Document Positioning
  2. Foreword and Context
  3. Introduction
  4. Scope
  5. Normative References
  6. Terms, Definitions, and Abbreviations
  7. Overall System Architecture
  8. Foundation Layer
  9. Core Layer
  10. Logic Fusion Layer
  11. Production System Knowledge Repository Layer
  12. Modeling Examples and Engineering Guidance
  13. Reference Architecture and Runtime View
  14. Appendix A — Modeling Examples
  15. Appendix B — Resource Description Namespace Examples
  16. Appendix C — Function Block Namespace Examples
  17. Appendix D — Type Mapping Tables
  18. Appendix E — Atomic Behavior Namespace Catalog
  19. Appendix F — Adaptation with Existing Standards
  20. Appendix G — File System Structure for Engineering and Agentic AI
  21. Appendix H — XML Schema Reference
  22. Appendix I — Instance Examples
  23. References

1. Document Positioning

CREEM is the generalized runtime modeling framework used to describe, bind, organize, and execute the active elements of a reconfigurable production system.

In Workflow Canvas (WFC), CREEM is the behavior-centric exchange model that:

In short:

Concept CREEM Role
Resource The active subject that can perform or participate in behavior
Function Block The executable behavior
Workflow The orchestration of behaviors
Resource Tree The aggregation structure of resources
Global Namespace The readable global identifier and classification mechanism
Global Data Table Cross-object data exchange and persistence mechanism
Industrial Behavior Tree The primary workflow logic and execution model

2. Foreword and Context

This document is derived from a Chinese national standard draft prepared in accordance with GB/T 1.1-2020, Directives for Standardization — Part 1: Rules for the Structure and Drafting of Standardizing Documents.

The draft notes that certain content may involve patents, and the issuing authority assumes no responsibility for identifying such patents.

Proposal and Standardization Context

Main Drafting Organizations

Principal Authors

Zhou ZhenHua (SIEMENS), Zhu XiaoXun (SIEMENS), Weng ChangWei (SIEMENS), Lu TieLin (ITEI), Ding Lu (ITEI), Liu Dan (ITEI).

3. Introduction

With the development of intelligent manufacturing, smart factories are evolving from rigid structures toward flexibility, networked coordination, and highly collaborative operation. In markets characterized by high product variety, small batch sizes, and rapid demand shifts, production systems must support fast structural and functional adjustment.

Existing modeling methods often lack a unified expression mechanism between:

CREEM addresses this gap by defining a common set of reconfigurable modeling rules for production systems. It standardizes how to describe:

It focuses on elements that possess active behavioral capability, and explicitly does not target passive elements that cannot actively perform behavior.

Related research note: The Dynamic Behavior Model (DBM) is a derivative research model built on top of CREEM. DBM reuses the CREEM meta-structure, namespace system, type tree, behavior tree, and FSM execution semantics, while focusing on agentic-AI–oriented dynamic behavior representation, scene–behavior holography, and runtime data planes. This manual presents that work under the CREEM name; readers familiar with DBM materials can treat CREEM as the underlying common model.

Key Design Intent

CREEM emphasizes:

  1. consistent modeling logic across abstraction levels;
  2. compatibility with existing information models;
  3. a foundation for: - industrial world models, - industrial agents, - smart factory engineering platforms, - heterogeneous system integration;
  4. lower system integration complexity;
  5. better coordination between the information layer and the operational layer;
  6. support for industrial system integration and operations.

4. Scope

This manual specifies the reconfigurable modeling rules for production systems in smart factories, including the requirements for:

It applies to:

of smart factory production systems.

5. Normative References

The following normative reference is indispensable to the application of the source rules:

Standard Title
GB/T 33863.4-2017 OPC Unified Architecture — Part 4: Services

6. Terms, Definitions, and Abbreviations

6.1 Terms and Definitions

Term Definition
Event An instantaneous event of critical importance to the execution of a planning algorithm. The execution of the algorithm uses variables associated with the event.
Behavior The observable effect of an operation or event, including its result.
Information Model A formal model of a bounded set of facts, concepts, or instructions satisfying specific requirements.
Behavior Model A formal model of an extensible collection of behaviors, dynamic characteristics, and their logic satisfying specific requirements.
Schema A formal description used to define data or information structures, including elements, attributes, and their relationships.
Instance A functional unit composed of independent, named entities with typed properties.
Metadata Data that defines and describes other data.
Parameter A language construct used for passing a data object or value between modules.
Resource Description (RD) An abstract or physical object used to describe a behavioral subject. Semantically it corresponds to a noun, subject, or physical node.
Function Block (FB) A configurable software component whose behavior is driven by events and data, and which interacts with other FBs through standardized interfaces. Semantically it corresponds to a verb, predicate, or logical node.
Workflow A sequence of activities with a clear start and end used to describe a task. In CREEM, it is an activity model composed of function blocks and may include branches, decision points, and events.
Repository A collection of domain knowledge required for problem solving, expressed as facts, rules, and structured patterns for acquisition, storage, and sharing.
Finite State Machine A computational model consisting of a finite number of states and transitions between them, possibly with accompanying actions.

6.2 Abbreviations

Abbreviation Meaning
AGV Automated Guided Vehicle
AI Artificial Intelligence
AMR Autonomous Mobile Robot
API Application Programming Interface
BPMN Business Process Modeling Notation
BT Behavior Tree
CNC Computer Numerical Control
COM Component Object Model
DCS Distributed Control System
DSL Domain Specific Language
ERP Enterprise Resource Planning
FBD Function Block Diagram
GUID Globally Unique Identifier
HMI Human-Machine Interface
HTML HyperText Markup Language
HTTP Hypertext Transfer Protocol
HTTPS Hypertext Transfer Protocol Secure
ID Identifier
IL Instruction List
IP Internet Protocol
IPC Industrial Personal Computer
IT Information Technology
JSON JavaScript Object Notation
LD Ladder Diagram
LLM Large Language Model
MES Manufacturing Execution System
MOM Manufacturing Operation Management
OMG Object Management Group
OPC UA OPC Unified Architecture
OS Operating System
OT Operational Technology
PLC Programmable Logic Controller
REST Representational State Transfer
RFID Radio-Frequency Identification
ROS Robot Operating System
RTOS Real-Time Operating System
SCADA Supervisory Control and Data Acquisition
SFC Sequential Function Chart
SOAP Simple Object Access Protocol
SOP Standard Operating Procedure
SQL Structured Query Language
SSH Secure Shell
SVG Scalable Vector Graphics
TCP Transmission Control Protocol
UDP User Datagram Protocol
UI User Interface
URI Uniform Resource Identifier
URL Uniform Resource Locator
USB Universal Serial Bus
UTC Coordinated Universal Time
UUID Universally Unique Identifier
WMS Warehouse Management System
XML Extensible Markup Language
XSD XML Schema Definition
3MF 3D Manufacturing Format

7. Overall System Architecture

The architecture is divided into four layers:

Layer Purpose
Foundation Layer Defines metadata types and meta-structure; provides the structural base for all other model elements
Core Layer Defines the main information-model constructs: basic objects, type inheritance tree, and global namespaces
Logic Fusion Layer Defines how core objects are logically organized and executed through FSMs, industrial behavior trees, and global data tables
Production System Knowledge Repository Layer Defines classification and organization rules for resource descriptions and function blocks

Architectural Interpretation in CREEM / WFC

In WFC, this four-layer architecture enables:

8. Foundation Layer

8.1 Metadata Types

The metadata types are defined as follows.

Type Name Base Type Description
metaAnySimpleType xsd:anySimpleType Root type from which any simple type may be defined
metaAnyURI xsd:anyURI Uniform resource identifier used to locate a resource
metaBase64Binary xsd:base64Binary Base64-encoded binary data
metaBoolean xsd:boolean Boolean value
metaByte xsd:byte 8-bit signed integer
metaDateTime - Composite date-time type; see structure below
metaDecimal xsd:decimal Arbitrary-precision decimal
metaDouble xsd:double 64-bit double-precision floating point
metaFloat xsd:float 32-bit single-precision floating point
metaHexBinary xsd:hexBinary Hex-encoded binary
metaInt xsd:int 32-bit signed integer
metaLong xsd:long 64-bit signed integer
metaReference - Composite reference type that can point to arbitrary properties and types
metaShort xsd:short 16-bit signed integer
metaString xsd:string String
metaUnsignedByte xsd:unsignedByte 8-bit unsigned integer
metaUnsignedInt xsd:unsignedInt 32-bit unsigned integer
metaUnsignedLong xsd:unsignedLong 64-bit unsigned integer
metaUnsignedShort xsd:unsignedShort 16-bit unsigned integer

metaDateTime Structure

Type Name Base Type Description
metaDateTime - Date/time; values are constrained using an XSD choice
DateTime xsd:dateTime UTC datetime YYYY-MM-DDThh:mm:ss
Date xsd:date UTC date YYYY-MM-DD
Time xsd:time UTC time hh:mm:ss
Duration xsd:duration Duration PnYnMnDTnHnMnS
LocalDateTime xsd:string Localized date-time string; may be empty

Note: In DateTime, the letter T is the separator between the date and time segments.

8.2 Meta-Structure

8.2.1 General

CREEM defines a universal segmented structure for all model instances. Every basic object follows the same four-part structure:

Segment Required Purpose
Metadata Required Describes and indexes the model instance itself
UI Information Optional Describes all user-interface-related presentation information
Data Required Describes all non-UI data of the model
Resource Optional Attaches or references static assets or dynamic assets

This segmentation cleanly separates:

Where classification is needed inside the UI Information, Data, or Resource segment, the content shall be further partitioned using Content.

The atomic element in the UI Information and Data segments is the Parameter. Parameters are the smallest indivisible elements and must comply with the type inheritance tree defined later in this manual.

Parameters across layers refer to the same logical object through the same ID / namespace identity.

8.2.2 Metadata Segment

The metadata segment is mandatory for every model instance and is used for indexing and marking reconfigurable models. Metadata may also be extracted into dedicated indexing systems.

Element Description Metadata Type Notes
Metadata Meta-structure: metadata metaReference -
Namespace Global namespace metaString See namespace rules
URI Uniform resource identifier metaAnyURI Local or network location of the model
Name Name metaString Standard name
Version Information model version metaString Major.Minor.Patch
EngineeringVersion Optional compatible version metaString >= Major.Minor.Patch
RuntimeVersion Optional compatible version metaString >= Major.Minor.Patch
Description Description metaString Standard description
UUID Global unique ID metaString Globally unique model ID
Organization Organization metaReference Owning enterprise or organization
Organization.Name Organization name metaString -
Organization.DigitalSignature Optional digital signature metaReference Signature of the organization
License License metaString Applicable license name
Authors Authors metaReference Collection of authors
Author Author metaReference Author information
Certification Optional certification metaReference Standard certification status
Certification.Name Certification body name metaString -
Certification.DigitalSignature Optional digital signature metaReference Signature of certification body
... Extension items - Arbitrary new fields may be extended

Metadata Extension Principles

Extended metadata fields should follow:

  1. Uniqueness principle: they must not duplicate or conflict with existing fields.
  2. Meta-property principle: they should describe, index, or validate the model itself, not the domain content inside the model.

8.2.3 UI Information Segment

The UI Information segment contains presentation-oriented information for engineering realization, such as:

Element Description Metadata Type Notes
UIInformation Meta-structure: UI information metaReference -
Content Segmented content set metaReference Used for localization partitions
lang Language code attribute metaString e.g. en-US
Name Localized name metaString -
Description Localized description metaString May map to Markdown
Style Optional UI style metaReference UI style definition
Parameter Set of parameters metaReference UI presentation info for parameters
Parameter.ID Parameter ID - Must match the Data segment parameter ID
Parameter.DisplayName Localized display name metaString -
... Extension items - Arbitrary extension fields allowed

Localization Rules

Different language localizations shall be segmented through Content and specified using lang.

Examples:

The UI Information segment should contain at least one localization, preferably English (en-US) by default.

If no localization is provided, the parameter display name defaults to the parameter Name in the Data segment.

Description Authoring Rules

The Description element (and any other long-form localized text such as Parameter.Description, Parameter.Tooltip, or extended help fields) MAY carry Markdown content rather than plain text. Two carrying mechanisms are defined, and they MAY coexist within the same model:

1. Inline Markdown via XML CDATA

When the Markdown body is short or tightly coupled to the model instance, it SHOULD be embedded directly inside the Description element using an XML CDATA section so that Markdown punctuation (#, *, _, `, <, &, |, …) does not need to be XML-escaped.

<UIInformation>
  <Content lang="en-US">
    <Name>Pick And Place</Name>
    <Description><![CDATA[
# Pick And Place

Performs a **vision-guided** pick-and-place cycle.

- Input: target frame from `Camera.1`
- Output: status code (see *StatusCode* table)

> Requires the gripper to be homed before the first tick.
    ]]></Description>
  </Content>
  <Content lang="zh-CN">
    <Name>抓取与放置</Name>
    <Description><![CDATA[
# 抓取与放置

执行一次**视觉引导**的抓取放置循环。

- 输入：来自 `Camera.1` 的目标位姿
- 输出：状态码（参见 *StatusCode* 表）

> 第一次 tick 之前夹爪必须已完成回零。
    ]]></Description>
  </Content>
</UIInformation>

For JSON or YAML serializations, the equivalent convention is to place the raw Markdown string in the Description field (escaped per the host format) and tag the field as Markdown via a sibling descriptionFormat: "Markdown" attribute when disambiguation is required.

2. External Markdown via Resource reference

When the Markdown body is long, shared, version-controlled, or authored outside the model (e.g. by tech-writers), the Description SHOULD reference a Markdown asset declared in the Resource segment instead of inlining the text. The same id pattern from §8.2.5 applies, and one Resource entry per language SHOULD be provided so that the localization rule above is still honored.

<UIInformation>
  <Content lang="en-US">
    <Name>Pick And Place</Name>
    <Description ref="@Resource.Doc.Description.en-US"/>
  </Content>
  <Content lang="zh-CN">
    <Name>抓取与放置</Name>
    <Description ref="@Resource.Doc.Description.zh-CN"/>
  </Content>
</UIInformation>

<Resource>
  <Content id="Resource.Doc.Description.en-US"
           type="Document" format="Markdown"
           href="docs/pick-and-place.en-US.md"/>
  <Content id="Resource.Doc.Description.zh-CN"
           type="Document" format="Markdown"
           href="docs/pick-and-place.zh-CN.md"/>
  <Content id="Resource.Doc.Description.de-DE"
           type="Document" format="Markdown"><![CDATA[
# Aufnehmen und Platzieren

Führt einen **bildgeführten** Pick-and-Place-Zyklus aus.
  ]]></Content>
</Resource>

Either carrying mechanism — CDATA-inlined or Resource-referenced — yields the same logical result: a per-language Markdown document associated with the model instance. The third entry above also illustrates that a Resource entry of type="Document" format="Markdown" MAY itself carry an inline CDATA body when no external file is desired, providing a uniform addressing model regardless of where the text physically lives.

Authoring guidance

Rule Guidance
Format declaration format="Markdown" (CommonMark + GFM tables/fenced-code SHOULD be the baseline dialect). Engineering tools MAY accept format="Markdown+Mermaid", format="Markdown+KaTeX", etc. to advertise extra extensions.
Language coverage Each localized Content lang="…" SHOULD provide its own Description (inline or referenced). Missing locales fall back to en-US, then to the Data segment Name.
Cross-references Markdown bodies MAY use CREEM namespace references (e.g. @FB.AtomicBehavior.Robot.MoveLinear) which engineering tools SHOULD render as clickable links into the model.
Asset linking Images, diagrams, and sub-documents referenced from the Markdown SHOULD themselves be declared in the Resource segment so that the model remains self-contained when distributed.
Safety Renderers SHOULD sanitize embedded HTML, disable arbitrary script execution, and treat external hrefs as untrusted by default.

Description as AI Prompt

Every CREEM element — RD, FB, WF, Parameter, DT, Repository, Project — carries a Description in its UIInformation segment. In CREEM, this Description is dual-purpose: it is both human documentation and a machine-readable prompt consumed by agentic AI, code-generation tools, retrieval pipelines, and LLM-based planners.

Authors SHOULD therefore write each Description so that it is simultaneously:

Recommended writing style

Aspect Guidance
Voice Imperative or descriptive third person; avoid first person and marketing language.
Scope One paragraph stating what the element is and what it does/represents, followed by an explicit inputs / outputs / preconditions / postconditions / side-effects block where applicable.
Identity Reference other CREEM elements by their full namespace (e.g. @RD.Robot.Cobot.*, @FB.AtomicBehavior.Robot.MoveLinear) so that agents can resolve them.
Units State engineering units explicitly (m, m/s, rad, N·m, °C, …).
Determinism State whether the behavior is idempotent, reentrant, blocking, real-time, or safety-relevant.
Failure modes Enumerate the expected StatusCode outcomes and what each means.
Examples Provide at least one short usage example for non-trivial behaviors.

Extended prompt fields in UIInformation

In addition to the standard Description, the UIInformation/Content element MAY be extended with AI-oriented fields. These are optional but RECOMMENDED for any element that an industrial agent is expected to invoke, compose, or reason about.

Element Description Metadata Type Notes
Description Localized description; dual-purpose (human + AI) metaString / Markdown Same field defined earlier; AI agents read this by default.
Summary One-sentence purpose statement metaString Used as the "tool description" in MCP / function-calling manifests.
Prompt Long-form prompt or system message for LLMs metaString / Markdown MAY reference @Resource.AI.PromptTemplate.* for templated prompts.
Prompt.Role Intended role Enum: system, developer, tool, assistant Defaults to tool for FB / WF, system for Project.
UsageExamples Few-shot examples (NL ↔ CREEM invocation) metaReference Each example pairs a natural-language request with a concrete @… invocation.
Capabilities Tags consumable by capability-based planners metaString[] e.g. "motion.linear", "vision.detect", "gripping".
Constraints Hard preconditions / safety constraints metaString / Markdown What the agent MUST verify before calling.
Embedding Optional precomputed semantic embedding metaReference Points to @Resource.AI.Embedding.* for retrieval indexing.
... Extension items - Additional AI-oriented fields allowed.

The same per-language Content lang="…" partitioning applies: AI prompts SHOULD be authored in each supported locale so that retrieval and generation work consistently regardless of the agent's working language. When the body grows large, the same two carrying mechanisms apply — inline CDATA Markdown or a Resource reference (type="Prompt" format="Markdown" or type="Prompt" format="Jinja2").

Example — Cobot Resource Description (RD.Robot.Cobot.*)

<UIInformation>
  <Content lang="en-US">
    <Name>Collaborative Robot</Name>
    <Summary>A 6-DoF collaborative robot arm safe for shared workspaces with humans.</Summary>
    <Description><![CDATA[
A **collaborative robot (cobot)** is a 6-axis articulated robot arm designed to
operate safely alongside humans without traditional safety fencing. It exposes
joint-space and Cartesian-space motion, supports tool changes through a
standardized flange, and reports per-joint torque so that contact with a person
or workpiece can be detected and the motion halted.

- Workspace: spherical, typical reach 0.8–1.3 m
- Payload: typically 3–16 kg
- Repeatability: ±0.03 mm (typical)
- Native control: vendor controller exposing `MoveJoint` / `MoveLinear` and I/O
- Bound behaviors: `@FB.AtomicBehavior.Robot.MoveLinear`,
  `@FB.AtomicBehavior.Robot.MoveJoint`,
  `@FB.Behavior.Robot.PickAndPlace`
    ]]></Description>
    <Prompt role="tool"><![CDATA[
You are controlling a collaborative robot arm exposed as the CREEM resource
`@RD.Robot.Cobot.*`. When the user asks for a motion, prefer
`@FB.AtomicBehavior.Robot.MoveLinear` for short, straight-line moves in
Cartesian space, and `@FB.AtomicBehavior.Robot.MoveJoint` for reconfiguration
moves where path shape does not matter. Always verify that
`Parameters.SafetyEnabled = true` before commanding motion, and never exceed
`Parameters.MaxCartesianSpeed` (units: m/s).
    ]]></Prompt>
    <Capabilities>motion.joint, motion.linear, gripping, force.sensing</Capabilities>
  </Content>
  <Content lang="zh-CN">
    <Name>协作机器人</Name>
    <Summary>可与人共享工作空间的 6 自由度协作机械臂。</Summary>
    <Description><![CDATA[
**协作机器人（Cobot）** 是一种 6 轴关节式机械臂，设计上可在无传统安全围栏的
条件下与人共同作业。它同时支持关节空间和笛卡尔空间运动，通过标准法兰支持
快换工具，并通过关节力矩感知检测与人或工件的接触以触发安全停机。
    ]]></Description>
  </Content>
</UIInformation>

Example — FB.AtomicBehavior.Robot.MoveLinear

<UIInformation>
  <Content lang="en-US">
    <Name>Move Linear</Name>
    <Summary>Move the tool center point in a straight Cartesian line to a target pose.</Summary>
    <Description><![CDATA[
Commands the bound robot resource (`@RD.Robot.*`) to move its tool center point
(TCP) along a **straight line in Cartesian space** from the current pose to the
target pose, blending optionally with the next motion.

**Inputs**
- `Robot` — `ResourceRef` to a robot RD (e.g. `@RD.Robot.Cobot.1`)
- `Target` — `PositionOrientation` (x,y,z in m; rx,ry,rz in rad)
- `Speed` — linear TCP speed (m/s), bounded by the robot's `MaxCartesianSpeed`
- `Acceleration` — linear TCP acceleration (m/s²)
- `Blending` — blend radius (m), `0` = exact stop at target

**Outputs**
- `Status` — `StatusCode`: `OK` on completion, `FAIL` on singularity,
  workspace violation, collision, or safety stop.

**Preconditions**
- Robot is initialized, safety enabled, and the target pose is reachable.

**Side effects**
- Robot is in motion until `OK` or `FAIL` is returned.
    ]]></Description>
    <Prompt role="tool"><![CDATA[
Use `MoveLinear` when the *path shape* matters (e.g. dispensing, welding,
inserting). For free-air repositioning where only the final pose matters,
prefer `MoveJoint` because it is faster and avoids singularities. Always pass
`Speed` in meters per second and `Target` as a `PositionOrientation` struct.
    ]]></Prompt>
    <UsageExamples><![CDATA[
- User: "Move the cobot 100 mm straight down from its current pose."
  Call: `@FB.AtomicBehavior.Robot.MoveLinear(
            Robot=@RD.Robot.Cobot.1,
            Target=current + (0,0,-0.1,0,0,0),
            Speed=0.05)`
- User: "Approach the pick point slowly along the tool Z axis."
  Call: `@FB.AtomicBehavior.Robot.MoveLinear(
            Robot=@RD.Robot.Cobot.1,
            Target=@DT.Pick.ApproachPose,
            Speed=0.02, Blending=0)`
    ]]></UsageExamples>
    <Capabilities>motion.linear, cartesian</Capabilities>
    <Constraints>Requires SafetyEnabled = true; Speed ≤ Robot.MaxCartesianSpeed.</Constraints>
  </Content>
</UIInformation>

Example — FB.Behavior.Robot.PickAndPlace

<UIInformation>
  <Content lang="en-US">
    <Name>Pick And Place</Name>
    <Summary>Pick an object from a source pose and place it at a target pose using a robot, gripper, and optional vision.</Summary>
    <Description><![CDATA[
Composite behavior that performs a full pick-and-place cycle:

1. (Optional) Use `@RD.Detection.Camera.*` to localize the object and refine
   the source pose.
2. Approach the source pose along the tool Z axis using `MoveLinear`.
3. Close the gripper via `@FB.AtomicBehavior.Robot.CloseGripper`.
4. Retract, transit to the place location with `MoveJoint`, and place using
   `MoveLinear` + `OpenGripper`.

**Bound resources**
- `Robot`   — `@RD.Robot.IndustrialRobot.*` or `@RD.Robot.Cobot.*`
- `Gripper` — `@RD.Robot.EndEffector.Gripper.*`
- `Camera`  — `@RD.Detection.Camera.Industrial.*` (optional)
    ]]></Description>
    <Prompt role="tool"><![CDATA[
Call `PickAndPlace` whenever the user describes moving a discrete object from
one location to another with a robot. If the source pose is not known
precisely, bind a `Camera` so that vision-based refinement is enabled. Return
`StatusCode = FAIL` if the gripper reports no part after closing.
    ]]></Prompt>
    <UsageExamples><![CDATA[
- User: "Pick the screw from the feeder and place it into the fixture."
  Call: `@FB.Behavior.Robot.PickAndPlace(
            Robot=@RD.Robot.Cobot.1,
            Gripper=@RD.Robot.EndEffector.Gripper.1,
            Camera=@RD.Detection.Camera.Industrial.1,
            Source=@DT.Feeder.PickPose,
            Target=@DT.Fixture.InsertPose)`
    ]]></UsageExamples>
    <Capabilities>manipulation, pick, place, vision.optional</Capabilities>
  </Content>
</UIInformation>

Authoring guidance for AI consumption

  1. One source of truth. Do not maintain a separate "docs" copy of the description; the UIInformation/Description (plus optional Prompt) IS the documentation.
  2. Stable identifiers. Always refer to other elements by their CREEM namespace, not by display name, so prompts remain valid across translations and renames.
  3. Bounded length. Keep Summary ≤ 200 characters (suitable for MCP / function-calling description fields); keep Description focused on a single element.
  4. Few-shot examples. Provide 1–3 UsageExamples per non-trivial FB; they materially improve LLM tool-selection accuracy.
  5. Locale parity. Translate Summary, Description, Prompt, and examples together — an agent operating in zh-CN should not silently fall back to English mid-conversation.
  6. Retrievability. When a project has many elements, precompute embeddings into @Resource.AI.Embedding.* so that an agent can semantically search the repository at runtime.

8.2.4 Data Segment

The Data segment contains the engineering data corresponding to the reconfigurable model itself.

Element Description Metadata Type Notes
Data Meta-structure: data metaReference -
Content Segmented data set metaReference One or more content partitions
... Extension items - Arbitrary extension allowed

The concrete structure of the Data segment depends on the specific basic object.

8.2.5 Resource Segment

The Resource segment contains resources referenced by the model.

Element Description Metadata Type Notes
Resource Meta-structure: resource metaReference -
Content Resource content partitions metaReference Resource elements
id Namespace attribute Namespace Resource element index
type Type attribute metaString Resource element type
format Format attribute metaString Resource format
... Extension items - Arbitrary extension allowed

Resources may be:

To control model size, static resources should preferably be textual:

Large binaries or streaming assets should not be embedded directly. They should be referenced by URL/URI from:

Examples

The following examples show how the three attributes (id / type / format) combine to describe both embedded textual assets and externally referenced binaries. Engineering tools should treat type as the semantic role of the resource and format as the concrete encoding, so that the same type (e.g. Code) can be carried by many formats (Python, TypeScript, IEC61131-ST, …).

Source code (JIT / interpreted)

Source code (AOT / compiled)

OT control DSLs (IEC 61131-3 / robot / CNC)

IT / data DSLs and query languages

Markup, configuration, and structured data

Icons and presentation assets

3D geometry, CAD, BIM (typically external references for binary formats)

Compiled / packaged executables (always external)

AI artifacts

Documents and references

Datasets and time series

Cross-format conventions

8.2.6 Extensibility

Every model instance and every segment of a model instance supports extensibility at the schema-definition level.

This means that any model may extend new fields or attributes anywhere, without modifying the existing structure, while still allowing schema validation through XSD, JSON Schema, or equivalent mechanisms.

Example patterns from the source rules:

9. Core Layer

The Core Layer includes:

These constitute the modeling foundation for the Logic Fusion Layer and the Knowledge Repository Layer.

9.1 Global Namespace

9.1.1 Definition

The global namespace is the globally unique, human-readable identifier for all major model objects. It provides:

It is the precondition for:

9.1.2 Construction Rules

The same construction format is used for both type namespaces and instance namespaces.

Rules

  1. The namespace shall be globally unique, with uniqueness ideally determined through a unified network namespace query service.
  2. Segments shall be separated by the ASCII period ..
  3. Each segment shall consist only of letters and digits; no dots or other characters are allowed inside a segment.
  4. Each segment shall begin with an uppercase letter and should follow PascalCase.
  5. Each segment should be meaningful and understandable; random strings such as UUIDs should not be used as semantic segments.
  6. If a type and an instance share the same prefix and segments, they refer to the same element type.

Namespace Forms

Kind Pattern
Type Namespace Prefix.Segment1.Segment2...SegmentN
Instance Namespace Prefix.Segment1.Segment2...SegmentN.InstanceIndex

9.1.3 Namespace Prefixes

Prefix Full Name Description
RD Resource Description Resource Description
RT Resource Tree Resource Tree
RT.Typology Resource Typology Resource topology
RT.Layout Resource Layout Resource layout
FB Function Block Function block
FB.BT Behavior Tree Industrial behavior tree function blocks
FB.System System Function Block System-level function blocks
FB.AtomicBehavior Atomic Behavior Atomic behavior
FB.Behavior Composite Behavior Composite/nestable behavior
WF Workflow Workflow
RDR RD Repository Resource description repository
FBR FB Repository Function block repository
PRJ Project Project
DT Data Table Global data table
... Extensions Further prefixes may be extended
Object Type Recommended Limit
Function Block namespace granularity No more than 8 levels including prefix, excluding instance index
Resource Description granularity No more than 10 levels including prefix, excluding instance index
Other types Generally no more than 10 levels

For FBs, the decomposition should reach the smallest actively behaving level.
For RDs, the minimum granularity should generally reach the specific equipment model that can act as a behavioral subject. Manufacturer, series, and sub-series are acceptable; batch numbers, serial numbers, and aliases usually are not.

Notes

9.1.4 Wildcards

Namespaces may use the wildcard * to represent any segment, but to avoid ambiguity it shall be used only as the last segment.

Examples:

9.2 Basic Objects

9.2.1 Overview

The basic objects are:

Their logical relationship is:

Object Role
Parameter Atomic data unit
RD Behavioral subject
RT Aggregation of RDs
FB Behavior
WF Aggregation of FBs
Repository Collection and organization of RD or FB definitions
Project Aggregation of RT and WF instances

RDs and FBs both contain zero or more parameters. Parameters are the atomic units. RDs represent subjects; FBs represent behaviors. Their many-to-many mapping enables subject-behavior binding.

9.2.2 Parameter

Parameters represent data items of an industrial behavior or behavioral subject.

Element / Attribute Description
id Parameter ID
type Parameter type; must comply with the type inheritance tree
defaultValue Default value
unit Engineering unit
minValue Lower bound, applicable to numeric types
maxValue Upper bound, applicable to numeric types
maxLength Maximum length, applicable to string types
regex Regular expression, applicable to string types
isVisible Whether visible in UI
isReadOnly Whether read-only in UI / engineering tools
displayName Localized display name; defined only in UIInformation
Value Actual parameter value in an instance; defaults to defaultValue if unset

If displayName is not defined, the UI display name defaults to the parameter id.

Parameters are required as:

They may be type-mapped to attributes and parameters in other information models for interoperability.

9.2.3 Resource Description (RD)

An RD represents an industrial behavioral subject, either abstract or physical.

Part Description
id Namespace
Metadata Metadata segment
UIInformation UI segment
Data Data segment
Methods Optional method references describing resource-specific methods
Method Optional hook to a special function block
Parameters Parameter collection
Resource Resource segment
Icon SVG icon
File File references describing or configuring the resource
Extensions Arbitrary extension fields

Interpretation

A resource may be:

3D Mapping

An RD instance may be mapped through its id to an instance in a 3D simulation, CAD, BIM, or digital-twin information model. Supported and recommended target formats include:

Real-time / runtime 3D scene formats

Manufacturing / additive manufacturing formats

CAD / engineering formats

BIM / plant / facility formats

Point cloud / scan formats

Robotics / simulation description formats

Mapping principle

The CREEM RD id (namespace) acts as the canonical key that joins these heterogeneous representations:

This enables consistent linkage between CREEM RD instances and engineering CAD, BIM, real-time 3D scenes, additive manufacturing, scanned reality data, and robotics simulation platforms.

9.2.4 Resource Tree (RT)

A Resource Tree is a hierarchical tree structure used to organize resources and their relationships.

Part Description
id Namespace
Metadata Metadata segment
UIInformation UI segment
Data Data segment
ResourceTree Tree body
RDInstance Set of resource description instances
Resource Resource segment
Extensions Arbitrary extension fields

Semantics

The root node usually represents the root control unit of a system; multiple roots are allowed. Child nodes represent RD instances aggregated by hierarchical, compositional, or connection-like relationships.

Important: the RT relation is a weak relationship:

It may represent:

Extended Sub-Objects

RT may be extended with:

Sub-object Purpose
Resource Layout (RT.Layout) Describes 2D layout relationships, dimensions, containment; may map into 3D space
Resource Typology (RT.Typology) Describes network topology relationships, e.g. service communication graphs and QoS

9.2.5 Function Block (FB)

A Function Block represents an industrial atomic behavior and is the most basic executable behavior unit.

Part Description
id Namespace
Metadata Metadata segment
UIInformation UI segment
Widget Plugin reference
Data Data segment
Executor Execution definition; compiled package reference and language designation
Category FB category; if _Resource is empty, acts as default header
Input Input port set
Output Output port set
Exception Optional exception set
Resource Resource segment
Icon SVG icon
Code Precompiled source code with language designation
File File reference used to describe or execute the FB
Extensions Arbitrary extension fields

Granularity of Atomic Behavior

An atomic behavior is “atomic” from the user-facing modeling perspective, not necessarily from a low-level machine perspective.

Examples:

9.2.6 Workflow (WF)

A Workflow is a systematic way to describe, execute, and monitor a behavior process.

Part Description
id Namespace
Metadata Metadata segment
UIInformation UI segment
Data Data segment
WorkflowTree Workflow tree represented as Industrial Behavior Tree
FBInstance Set of function block instances
Resource Resource segment
Extensions Arbitrary extension fields

Key Rules

9.2.7 Repository

Two repository types are defined:

  1. RD Repository
  2. FB Repository

Repositories are indexed collections used to collect, store, organize, retrieve, and share knowledge. They may exist on:

RD Repository

Part Description
id Namespace
Metadata Metadata segment
UIInformation UI segment
Data Data segment
RepositoryTree Classification/index tree
ResourceDescription Set of RD definitions
Resource Resource segment
Extensions Arbitrary extension fields

FB Repository

Part Description
id Namespace
Metadata Metadata segment
UIInformation UI segment
Data Data segment
RepositoryTree Classification/index tree
FunctionBlock Set of FB definitions
Resource Resource segment
Extensions Arbitrary extension fields

Repositories form ecosystems through aggregation of elements from different namespaces.

9.2.8 Project

A Project represents an end-user industrial project based on the reconfigurable model.

Part Description
id Namespace
Metadata Metadata segment
UIInformation UI segment
Data Data segment
RTInstance Set of resource tree instances
WorkflowInstance Set of workflow instances
Resource Resource segment
Extensions Arbitrary extension fields

A project is the engineering software platform’s project construction model. In addition to the modeling objects themselves, it may include resources such as target project source code, enabling a full textual project description.

9.2.9 Semantic Mapping and Binding Between FBs and RDs

Semantic Mapping

Examples:

Natural Expression CREEM Mapping
Industrial robot moves linearly RD = Industrial robot, FB = MoveLinear
Worker carries / sorts RD = Worker, FB = Carrying / Sorting
Robot + gripper + camera perform pick-and-place Multiple RDs jointly bound to one FB

This semantic rule converts natural-language SOP descriptions into machine-readable workflows. The same structure can also be used as input for LLM training and generation.

Binding

FBs and RDs are bound through parameters of type ResourceRef defined on the FB.

Binding cardinalities supported:

Example:

For a composite FB such as FB.Behavior.Robot.PickAndPlace, bound RDs may include:

9.3 Type Inheritance Tree

9.3.1 Overview

The type inheritance tree defines the data types for Parameters. It supports type mapping to:

The tree contains:

A parent type accepts data from any descendant type in the child-to-parent direction without explicit coercion. Reverse assignment is invalid unless an explicit conversion FB is used.

Example:

9.3.2 Root Types

Root Type Category Description
Any Generic Root generic type of all types
Bool Basic Boolean type
String Basic Weak type family for string-related types
Numerial Basic Weak type family for number-related types
Enum Basic Enumeration type
Array Composite Members may be any type including itself, but member type must remain consistent
Struct Composite Members may be any types and need not be consistent
File Reference Reference type for file index addresses
Ref Reference Reference type pointing to any non-reference type

The source uses Numerial rather than Numerical; this manual preserves the source naming for compatibility.

9.3.3 Mapping to Typical Information Models

CREEM Type OMG IDL OPC UA PLC (IEC 61131-3) PROFINET ROS 2 / DDS JSON Schema Protobuf Avro
Any any Variant ANY - dynamic (any) google.protobuf.Any union
Bool boolean Boolean BOOL Boolean bool boolean bool boolean
Numerial.Integer.Int8 int8 SByte SINT Integer8 int8 integer (i8) int32 int
Numerial.UInteger.UInt8 uint8 Byte USINT Unsigned8 uint8 / byte integer (u8) uint32 int
Numerial.Integer.Int16 int16 Int16 INT Integer16 int16 integer (i16) int32 int
Numerial.UInteger.UInt16 uint16 UInt16 UINT Unsigned16 uint16 integer (u16) uint32 int
Numerial.Integer.Int32 int32 Int32 DINT Integer32 int32 integer (i32) int32 / sint32 int
Numerial.UInteger.UInt32 uint32 UInt32 UDINT Unsigned32 uint32 integer (u32) uint32 / fixed32 long
Numerial.Integer.Int64 int64 Int64 LINT Integer64 int64 integer (i64) int64 / sint64 long
Numerial.UInteger.UInt64 uint64 UInt64 ULINT Unsigned64 uint64 integer (u64) uint64 / fixed64 long
Numerial.Integer.Int128 - - - - - string (bigint) bytes(16) bytes(16)
Numerial.UInteger.UInt128 - - - - - string (bigint) bytes(16) bytes(16)
Numerial.Float16 - - - - - number - float (lossy)
Numerial.Float float Float REAL Float32 float32 number float float
Numerial.Double double Double LREAL Double float64 number double double
Numerial.Decimal - - - - - string (decimal) string decimal (logical)
Numerial.StatusCode uint32 StatusCode DWORD Unsigned32 uint32 integer uint32 int
String string String STRING STRING(VisibleString) string string string string
String.WString wstring LocalizedText WSTRING OctetString wstring string string string
String.UUID octet uuid[16] Guid - UUID octet[16] string (uuid) bytes(16) string (uuid logical)
String.URI - XmlElement(URI) - - string string (uri) string string
String.LanguageTag - LocaleId - - string string string string
Enum enum Enumeration - - enum string (enum) enum enum
Array sequence Array of T ARRAY[..] OF T Array sequence array repeated T array
Struct struct Structure STRUCT Record message / struct object message record
File - FileType (NodeClass) - - - string (URI) bytes bytes
Ref object reference NodeId / Reference POINTER - string (topic/srv) string ($ref) string string
Struct.DateTime.TimeStamp Time_t DateTime / UtcTime DATE_AND_TIME TimeStamp builtin_interfaces/Time string (date-time) google.protobuf.Timestamp timestamp-millis
Struct.DateTime.TimeSpan duration Duration TIME DifferenceShort builtin_interfaces/Duration string (duration) google.protobuf.Duration duration logical
Struct.DateTime.Date - Date DATE - - string (date) google.type.Date date logical
Struct.DateTime.TimeOfDay - TimeOfDay TIME_OF_DAY - - string (time) google.type.TimeOfDay time-millis

Full type names may be shortened in actual definition. For example, UInt8 may be used directly instead of Numerial.UInteger.UInt8.

When a target system lacks a native representation (cells marked -), implementations SHOULD fall back to the nearest wider numeric type, an opaque byte/string carrier (such as bytes(16) for 128-bit integers), or a registered logical/semantic annotation (such as Avro logical types or JSON Schema format).

For PLC mappings, vendor extensions of IEC 61131-3 (e.g. Siemens S5TIME, Beckhoff T_MaxString) MAY be used when an exact 1:1 mapping is required; such mappings SHOULD be declared in the implementation profile.

9.3.4 Numeric Type Subtree

Type Alias Description
Numerial Number Weak family of number-related types
Integer Int* Signed integer family
Int8 SByte / Char(signed) 8-bit signed integer, range −128…127
Int16 Short / SInt16 16-bit signed integer, range −2^15…2^15−1
Int32 Int / DInt 32-bit signed integer, range ±2.15e9
Int64 Long / LInt 64-bit signed integer, range ±9.22e18
Int128 LLong 128-bit signed integer, range ±1.7e38
IntVar BigInt / Integer.Arbitrary Arbitrary-precision signed integer (variable length encoding)
UInteger UInt* Unsigned integer family
UInt8 Byte / Octet / UChar 8-bit unsigned integer, range 0…255
UInt16 Word / UShort 16-bit unsigned integer, range 0…65535
UInt32 DWord / UDInt 32-bit unsigned integer, range 0…2^32−1
UInt64 QWord / ULInt 64-bit unsigned integer, range 0…2^64−1
UInt128 OWord 128-bit unsigned integer
UIntVar BigUInt Arbitrary-precision unsigned integer
StatusCode - 32-bit status code (inherits UInt32, see §9.3.4 StatusCode Rule)
BitString Bits / BITSTRING Fixed-length packed bit sequence (length declared via length attribute)
VarBitString - Variable-length packed bit sequence
Float Real / FP32 / Single 32-bit IEEE 754 binary float (binary32)
Double LReal / FP64 64-bit IEEE 754 binary float (binary64)
Float16 Half / FP16 16-bit IEEE 754 binary float (binary16), AI/ML payloads
BFloat16 Brain Float 16-bit Google brain floating-point, 8-bit exponent, AI accelerators
Float128 Quad / FP128 128-bit IEEE 754 binary float (binary128), high-precision metrology
Decimal32 - IEEE 754 decimal32, base-10, 7 significant digits
Decimal64 - IEEE 754 decimal64, base-10, 16 significant digits
Decimal128 Decimal IEEE 754 decimal128, base-10, 34 significant digits — preferred for currency and SI engineering values
Fixed Q-format Fixed-point number with declared integer and fraction bit widths (e.g. Q15.16); common on DSP / motion controllers
Rational Fraction Pair of integers (numerator, denominator), exact ratio representation
Complex - Complex number (real, imaginary) pair; impedance / FFT bin / phasor representations
Phasor - Magnitude + phase representation (alternative form of Complex)
Percentage Percent Convenience subtype of Float/Decimal with implicit unit=% and range [0,100]
PerMille ‰ Convenience subtype with implicit unit=‰
Ratio - Dimensionless ratio, typically Float in [0,1]
NaN - Not-a-Number marker value (IEEE 754 floats)
Infinity Inf Positive / negative infinity marker (IEEE 754 floats)
... - Extensions allowed

Numeric parameters may have a unit attribute using international unit symbols (SI base/derived units, ISO 80000), an optional scale/offset for engineering conversion (physical = raw × scale + offset), and min/max/step/resolution for value-domain constraints. Integer subtypes MAY additionally declare endianness (big/little/native) at the binary-encoding boundary.

StatusCode Rule

StatusCode inherits from UInt32 and should comply with GB/T 33863.4-2017 for Status Codes, while supporting extension.

Recommended encoding convention:

Prefix Meaning
0x00000000... Success
0x40000000... Uncertain
0x80000000... Failure

9.3.5 String Type Subtree

Type Description
String String
StatusString Status string
Namespace Namespace
URI Uniform Resource Identifier
URL Uniform Resource Locator
URN Uniform Resource Name
FilePath Local or POSIX file path
WindowsPath Windows file path
UUID UUID
GUID GUID
Markup Unescaped or serialized markup string
JSON JSON
XML XML
YAML YAML
TOML TOML
Base64 Base64-encoded binary
Hex Hex-encoded binary
Expression Generic expression
Regex Regular expression
ExcelExpression Excel expression
CodeSnippet Unescaped or serialized source code
PlaintextSnippet Plain text transformed from code
QualifiedName Qualified name
LocalizedText Localized text
LanguageTag BCP47 language tag (e.g. en-US, zh-CN)
CountryCode ISO 3166-1 alpha-2 country code
CurrencyCode ISO 4217 currency code
TimeZone IANA time-zone identifier (e.g. Asia/Shanghai)
Hostname RFC 1123 host name
FQDN Fully Qualified Domain Name
IPv4 IPv4 address plus optional port
IPv6 IPv6 address
CIDRv4 IPv4 CIDR block
CIDRv6 IPv6 CIDR block
MacAddress MAC address (EUI-48)
EUI64 EUI-64 identifier
Port TCP/UDP port (0–65535)
Email Email address (RFC 5322 simplified)
PhoneE164 Phone number in E.164 format
Version Major.Minor.Patch
SemVer Semantic Version (SemVer 2.0)
Icon Serialized SVG icon
Color.Hex #RRGGBB or #RRGGBBAA hex color
IMEI 15-digit device identifier string
IMSI 15-digit IMSI
ICCID 19/20-digit SIM card identifier
MEID Mobile Equipment Identifier
VIN Vehicle Identification Number
LicensePlate Vehicle license plate (locale-dependent)
ContainerNumber ISO 6346 shipping container number
GTIN8 GTIN-8
GTIN12 UPC-A / GTIN-12
GTIN13 EAN-13 / GTIN-13
GTIN14 ITF-14 / GTIN-14
SSCC Serial Shipping Container Code (18 digits)
GS1ElementString GS1 element string with AIs (incl. FNC1)
ISBN10 ISBN-10
ISBN13 ISBN-13
RFIDEPC RFID EPC (96-bit hex)
BarcodeData Generic 1D/2D barcode payload
QRPayload QR Code payload
DataMatrixPayload Data Matrix payload
MIMEType IETF media type (e.g. application/json)
ContentEncoding HTTP Content-Encoding token
ETag HTTP entity tag
JWT JSON Web Token (compact serialization)
JWK JSON Web Key
JWS JSON Web Signature (compact)
PEMBlock PEM-encoded block (cert / key)
X509Subject X.509 distinguished name
OID ISO/IEC object identifier dot-notation
OPCUANodeId OPC UA NodeId string form
OPCUABrowsePath OPC UA BrowsePath string
ModbusAddress Modbus address (e.g. 40001, HR:100)
ProfinetDeviceName PROFINET station/device name
EtherCATSlaveAddress EtherCAT slave address
CANId CAN identifier (11/29-bit, hex)
ISO15765Id ISO-TP / OBD-II identifier
OBD2PID OBD-II PID code
BACnetObjectId BACnet object identifier
DNP3Address DNP3 address
IEC61850Reference IEC 61850 functional reference (LD/LN.DO.DA)
IEC60870ASDU IEC 60870-5 ASDU address
MQTTTopic MQTT topic filter
AMQPRoutingKey AMQP routing key
KafkaTopic Kafka topic name
TagName Generic SCADA/historian tag name
PLCAddress Vendor-agnostic PLC address (%IX0.0, DB10.DBW2, M100.0)
ISA88Path ISA-88 physical hierarchy path
ISA95EquipmentRef ISA-95 equipment hierarchy reference
KKSCode KKS power-plant identification code
AKSCode AKS (DIN 40719-2) identification code
MaterialNumber ERP material number (e.g. SAP)
BatchId Batch / lot identifier
SerialNumber Serial number
WorkOrderId Production work-order id
RecipeId Recipe identifier
AssetTag Asset/equipment tag
HSCode Harmonized System tariff code
LEI Legal Entity Identifier (ISO 17442)
CRSCode EPSG / OGC CRS code (e.g. EPSG:4326)
Latitude Decimal latitude (-90..90)
Longitude Decimal longitude (-180..180)
WKT OGC Well-Known Text geometry
GeoJSON RFC 7946 GeoJSON object
What3Words what3words address
PlusCode Open Location Code
Cron Cron schedule expression
Duration.ISO8601 ISO 8601 duration PnYnMnDTnHnMnS
Interval.ISO8601 ISO 8601 time interval
DateTime.ISO8601 ISO 8601 / RFC 3339 date-time
Date.ISO8601 ISO 8601 calendar date
Time.ISO8601 ISO 8601 wall-clock time
HTTPMethodName HTTP method token
StatusCodeString Symbolic status-code name
... Extensions allowed

String subtypes should preferably be constrained by regular expressions defined in the schema.

Type Regex (PCRE syntax, anchored)
UUID / GUID ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$
IPv4 ^(25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)(\.(25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)){3}$
IPv6 ^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\|([0-9a-fA-F]{1,4}:){1,7}:\|::([0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4})$
CIDRv4 ^(?:(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)/(?:3[0-2]\|[12]?[0-9])$
CIDRv6 ^[0-9a-fA-F:]+/(?:12[0-8]\|1[01][0-9]\|[1-9]?[0-9])$
MacAddress ^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$
EUI64 ^([0-9A-Fa-f]{2}[:-]){7}([0-9A-Fa-f]{2})$
Port ^(6553[0-5]\|655[0-2][0-9]\|65[0-4][0-9]{2}\|6[0-4][0-9]{3}\|[1-5]?[0-9]{1,4})$
Hostname ^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)(\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$
FQDN ^(?=.{1,253}\.?$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[A-Za-z]{2,63}\.?$
Email ^[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}$
PhoneE164 ^\+[1-9][0-9]{1,14}$
URL ^(https?\|ftp\|file)://[^\s/$.?#].[^\s]*$
URI ^[A-Za-z][A-Za-z0-9+\-.]*:[^\s]*$
URN ^urn:[a-z0-9][a-z0-9-]{0,31}:[^\s]+$
MIMEType ^[a-zA-Z0-9!#$&^_.+-]+/[a-zA-Z0-9!#$&^_.+-]+$
Base64 ^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==\|[A-Za-z0-9+/]{3}=)?$
Hex ^(?:[0-9A-Fa-f]{2})+$
Color.Hex ^#(?:[0-9A-Fa-f]{6}\|[0-9A-Fa-f]{8})$
Version ^[0-9]+\.[0-9]+\.[0-9]+$
SemVer ^(0\|[1-9][0-9]*)\.(0\|[1-9][0-9]*)\.(0\|[1-9][0-9]*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$
LanguageTag ^[a-zA-Z]{2,3}(-[A-Z][a-z]{3})?(-([A-Z]{2}\|[0-9]{3}))?(-[A-Za-z0-9]{5,8})*$
CountryCode ^[A-Z]{2}$
CurrencyCode ^[A-Z]{3}$
TimeZone ^[A-Za-z]+(?:/[A-Za-z_\-]+){1,2}$
OID ^[0-2](\.(0\|[1-9][0-9]*))+$
IMEI ^[0-9]{15}$
IMSI ^[0-9]{15}$
ICCID ^[0-9]{19,20}$
VIN ^[A-HJ-NPR-Z0-9]{17}$
ContainerNumber ^[A-Z]{4}[0-9]{7}$
GTIN8 ^[0-9]{8}$
GTIN12 ^[0-9]{12}$
GTIN13 ^[0-9]{13}$
GTIN14 ^[0-9]{14}$
SSCC ^[0-9]{18}$
ISBN10 ^(?:[0-9]{9}[0-9Xx])$
ISBN13 ^97[89][0-9]{10}$
RFIDEPC ^[0-9A-Fa-f]{24}$
QRPayload ^.{1,2953}$
ETag ^(W/)?"[!#-~]+"$
JWT ^[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+$
PEMBlock ^-----BEGIN [A-Z ]+-----[\s\S]+-----END [A-Z ]+-----\s*$
OPCUANodeId ^(ns=[0-9]+;)?(i=[0-9]+\|s=.+\|g=[0-9a-fA-F-]{36}\|b=[A-Za-z0-9+/=]+)$
ModbusAddress ^(?:[0-9]{1,5}\|(HR\|IR\|CO\|DI):[0-9]{1,5})$
ProfinetDeviceName ^[a-z][a-z0-9\-]{0,239}$
CANId ^0x[0-9A-Fa-f]{3}$\|^0x[0-9A-Fa-f]{1,8}$
BACnetObjectId ^(analog-input\|analog-output\|analog-value\|binary-input\|binary-output\|binary-value\|device\|multi-state-input\|multi-state-output\|multi-state-value):[0-9]+$
IEC61850Reference ^[A-Za-z0-9_]+/[A-Za-z0-9_]+\.[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$
MQTTTopic ^([^+#/]+\|\+)(/([^+#/]+\|\+))*(/#)?$
KafkaTopic ^[A-Za-z0-9._\-]{1,249}$
PLCAddress ^(?:%[IQM][XBWDL]?[0-9]+(?:\.[0-7])?\|DB[0-9]+\.DB[XBWDL][0-9]+(?:\.[0-7])?\|[IQM][0-9]+(?:\.[0-7])?)$
Latitude ^[-+]?([1-8]?[0-9](\.[0-9]+)?\|90(\.0+)?)$
Longitude ^[-+]?(1[0-7][0-9]\|[1-9]?[0-9])(\.[0-9]+)?$\|^[-+]?180(\.0+)?$
PlusCode ^[23456789CFGHJMPQRVWX]{2,8}\+[23456789CFGHJMPQRVWX]{2,3}$
What3Words ^[a-z]{3,}\.[a-z]{3,}\.[a-z]{3,}$
Cron ^(\*\|[0-5]?[0-9])(/[0-9]+)?( (\*\|[01]?[0-9]\|2[0-3])(/[0-9]+)?){4}$
Duration.ISO8601 ^P(?!$)(?:[0-9]+Y)?(?:[0-9]+M)?(?:[0-9]+D)?(?:T(?:[0-9]+H)?(?:[0-9]+M)?(?:[0-9]+(?:\.[0-9]+)?S)?)?$
DateTime.ISO8601 ^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:Z\|[+\-][0-9]{2}:[0-9]{2})$
Date.ISO8601 ^[0-9]{4}-[0-9]{2}-[0-9]{2}$
Time.ISO8601 ^[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?$
HTTPMethodName ^(GET\|POST\|PUT\|PATCH\|DELETE\|HEAD\|OPTIONS\|TRACE\|CONNECT)$
LEI ^[A-Z0-9]{18}[0-9]{2}$
HSCode ^[0-9]{6,10}$
CRSCode ^(EPSG\|ESRI\|IAU):[0-9]+$

Note: Regexes above are intended for format validation, not full semantic validation (e.g. checksum digits in GTIN*, SSCC, IMEI, VIN, ISBN*, LEI must be verified separately). Engineering tools SHOULD also accept locale-specific variants and provide schema-level overrides.

Examples (legacy short form, kept for compatibility):

9.3.6 Enum Type Subtree

Type Example Values
Enum -
Flag Bitwise enumeration for markers and switches
LoggingLevel Trace, Debug, Info, Warning, Error, Critical
HTTPMethod GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
UserRole Admin, User, Guest, Developer, Maintainer
Gender Male, Female, Others
SystemColor -
Permission Read, Write, Execute
Priority High, Medium, Low
Direction North, South, East, West
Direction6 PositiveX, NegativeX, PositiveY, NegativeY, PositiveZ, NegativeZ
Axis X, Y, Z, A, B, C, U, V, W
RotationAxis Roll, Pitch, Yaw
CoordinateFrame World, Base, Tool, TCP, Workpiece, User, Joint, Camera, Flange
AngleUnit Degree, Radian
LengthUnit Millimeter, Centimeter, Meter, Inch, Foot
TemperatureUnit Celsius, Fahrenheit, Kelvin
PressureUnit Pa, kPa, MPa, Bar, PSI, mmHg, mbar
FlowUnit LPM, GPM, m3h, kgh, NLPM, SCFM
TorqueUnit Nm, kNm, ozin, ftlb
ForceUnit N, kN, lbf, kgf
SpeedUnit mps, mmps, mmin, rpm, degs, rads
ElectricUnit V, mV, kV, A, mA, kA, W, kW, MW, Wh, kWh, MWh, Hz
TimeUnit Nanosecond, Microsecond, Millisecond, Second, Minute, Hour, Day
DataSizeUnit Bit, Byte, KB, MB, GB, TB, KiB, MiB, GiB, TiB
DataRateUnit bps, Kbps, Mbps, Gbps, MBps
FrequencyUnit Hz, kHz, MHz, GHz
VoltageLevel ELV, LV, MV, HV, EHV, UHV
SignalType Digital, Analog, Pulse, Frequency, PWM, Encoder, Serial, FieldbusFrame
SignalEdge Rising, Falling, Both, High, Low
IOType DigitalInput, DigitalOutput, AnalogInput, AnalogOutput, Counter, PWM
IORange 0_5V, 0_10V, MinusPlus10V, 0_20mA, 4_20mA, 1_5V, MinusPlus5V
PLCMemoryArea I, Q, M, DB, V, T, C, S, AI, AQ
PLCDataType BOOL, BYTE, WORD, DWORD, LWORD, SINT, USINT, INT, UINT, DINT, UDINT, LINT, ULINT, REAL, LREAL, TIME, DATE, TOD, DT, STRING, WSTRING
PLCLanguage LD, FBD, ST, SFC, IL, CFC
PLCRunMode Run, Stop, Hold, Program, RemoteRun, RemoteStop, Test
ControllerVendor Siemens, Rockwell, Mitsubishi, Omron, Schneider, ABB, BeckhoffTwinCAT, Codesys, Inovance, Delta, Keyence, Yokogawa, Honeywell, Emerson, GE
RobotVendor ABB, KUKA, Fanuc, Yaskawa, Kawasaki, Staubli, UniversalRobots, Doosan, Techman, Jaka, Aubo, Elite, Estun, Efort, Siasun, Han, RokaeRobot, DobotRobot, Franka, Rethink, Mitsubishi, Comau, Adept, Epson, Denso, Nachi
RobotKinematics Articulated6Axis, Articulated7Axis, SCARA, Delta, Cartesian, Cylindrical, Spherical, Parallel, DualArm
RobotMotionType PTP, LIN, CIRC, SPLINE, JOG, Servo, Force, Impedance
RobotMotionBlending None, Radius, Time, Velocity, Spline
RobotProgramLanguage RAPID, KRL, INFORM, KAREL, URScript, JBI, AS, V, ROS, ROS2, MoveIt
RobotSafetyMode Normal, ReducedSpeed, SafetyStop, EmergencyStop, ProtectiveStop, RecoveryMode, HandGuiding
EndEffectorType ParallelGripper, AngularGripper, ThreeFingerGripper, FiveFingerGripper, VacuumGripper, MagneticGripper, SoftGripper, WeldingTorch, SprayGun, ScrewDriver, Dispenser, Riveter, NeedleGripper, AdhesiveGripper
GripperState Open, Opening, Closed, Closing, Holding, NoPart, PartLost, Fault
CNCMode Auto, MDI, JOG, Handle, EDIT, RemoteDNC, Reference, Teach
CNCAxisState Disabled, Enabled, Homing, Homed, Moving, InPosition, Following, Fault
ToolCondition New, InUse, NearLifeEnd, Expired, Broken, Inspect
SpindleState Stopped, Accelerating, RunningCW, RunningCCW, Decelerating, Oriented, Fault
MachineState PoweredOff, PoweredOn, Initializing, Ready, Running, Holding, Held, Suspended, Aborting, Aborted, Stopping, Stopped, Clearing, Resetting, Completing, Complete
OEEReason PlannedDowntime, Changeover, Breakdown, Setup, Adjustment, MinorStop, ReducedSpeed, Startup, MaterialShortage, OperatorShortage, QualityLoss, ReworkLoss, ScrapLoss
DowntimeCategory Planned, Unplanned, Idle, Blocked, Starved, External, MaintenancePM, MaintenanceCM, Quality, Safety
MaintenanceType Preventive, Predictive, Corrective, Condition, Reactive, Inspection, Calibration, Overhaul
ConditionLevel Healthy, Warning, Critical, Failure, Unknown
AlarmSeverity Diagnostic, Information, Notice, Warning, Minor, Major, Critical, Fatal
AlarmState Inactive, ActiveUnacknowledged, ActiveAcknowledged, InactiveUnacknowledged, Shelved, Suppressed, OutOfService
EventCategory Process, Equipment, Safety, Security, Quality, Maintenance, Operator, System, Audit
SafetyState Safe, SafeOperatingStop, SafeStop1, SafeStop2, SafelyLimitedSpeed, SafelyLimitedPosition, EmergencyStop, GuardOpen, LightCurtainBroken, TwoHandRequired
SafetyCategory Cat1, Cat2, Cat3, Cat4, PLa, PLb, PLc, PLd, PLe, SIL1, SIL2, SIL3, SIL4
EStopState Released, Pressed, Latched, RequiresReset
HazardClass Mechanical, Electrical, Thermal, Chemical, Biological, Radiation, Noise, Vibration, Ergonomic
LOTOState Operational, Isolated, LockedOut, TaggedOut, TestVerified, Restored
ConveyorState Stopped, Starting, Running, Stopping, Jammed, Empty, Full, Fault
AGVState Idle, Charging, MovingToPick, Picking, MovingToDrop, Dropping, Returning, Manual, Fault, Estop, AwaitingTask
AMRMode Auto, Manual, RemoteControl, Mapping, Localization, Charging, Maintenance
NavigationStatus Localized, Lost, Replanning, Blocked, Arrived, Aborted
WarehouseLocationType Receiving, Storage, Picking, Packing, Shipping, BufferIn, BufferOut, Quarantine, Return, Scrap
MaterialState Raw, WIP, FinishedGood, Scrap, Rework, OnHold, Quarantine, Released, Consumed
InventoryStatus OnHand, Allocated, Reserved, InTransit, OnOrder, BackOrdered, Quarantined, Blocked
BatchStatus Created, Released, InProcess, Held, Completed, Closed, Rejected, Reprocessed
OrderStatus Created, Released, Scheduled, InProgress, Paused, Completed, Closed, Cancelled
QualityResult Pass, Fail, ConditionalPass, Pending, Rework, Scrap
InspectionType Incoming, InProcess, Final, Audit, FirstArticle, SPC
DefectSeverity Cosmetic, Minor, Major, Critical
MeasurementResult InTolerance, OutOfToleranceHigh, OutOfToleranceLow, Unstable, Invalid
ToleranceClass IT01, IT0, IT1, IT2, IT3, IT4, IT5, IT6, IT7, IT8, IT9, IT10, IT11, IT12, IT13, IT14, IT15, IT16, IT17, IT18
WeldingType MIG, MAG, TIG, MMA, FCAW, SAW, LaserWelding, ResistanceSpot, ResistanceSeam, FrictionStir, UltrasonicWeld, PlasmaArc
AdditiveProcess FDM, SLA, SLS, SLM, DMLS, EBM, MJF, Polyjet, BinderJet, DED
MachiningProcess Turning, Milling, Drilling, Boring, Reaming, Tapping, Grinding, Honing, EDM, Broaching, Sawing
ProcessPhase Idle, Loading, Heating, Soaking, Processing, Cooling, Unloading, Cleaning
ProtocolFamily EthernetIP, ProfinetIO, EtherCAT, Profibus, Modbus, CANopen, DeviceNet, CCLink, Powerlink, OPCUA, OPCDA, MQTT, AMQP, Kafka, HTTP, gRPC, BACnet, DNP3, IEC61850, IEC60870, MTConnect, SECS, GEM
FieldbusMedium TwistedPair, Coaxial, Fiber, Wireless, Optical, PowerLine
NetworkRole Master, Slave, Client, Server, Publisher, Subscriber, Producer, Consumer, Bridge, Gateway, Coordinator, Router, EndDevice
ConnectionState Disconnected, Connecting, Connected, Reconnecting, Authenticating, Error, Timeout
OPCUASecurityMode None, Sign, SignAndEncrypt
OPCUASecurityPolicy None, Basic128Rsa15, Basic256, Basic256Sha256, Aes128Sha256RsaOaep, Aes256Sha256RsaPss
MQTTQoS AtMostOnce, AtLeastOnce, ExactlyOnce
TimeSyncProtocol NTP, PTPv1, PTPv2, gPTP, IRIG_B, GNSS, WhiteRabbit
TSNProfile IEEE802_1AS, IEEE802_1Qbv, IEEE802_1Qbu, IEEE802_1CB, IEEE802_1Qcc
DataLayer Physical, DataLink, Network, Transport, Session, Presentation, Application
ISA95Level Level0Process, Level1Sensing, Level2Control, Level3MES, Level4ERP
ISA88Level Enterprise, Site, Area, ProcessCell, Unit, EquipmentModule, ControlModule
RAMI40Layer Asset, Integration, Communication, Information, Functional, Business
RAMI40LifeCycle TypeDevelopment, TypeMaintenance, InstanceProduction, InstanceUsage
EnergyState Off, Standby, Idle, Warmup, Productive, NonProductive, Maintenance
EnergyCarrier Electricity, NaturalGas, Steam, CompressedAir, Water, ChilledWater, HotWater, Nitrogen, Oxygen, Hydrogen, Fuel
Sustainability Scope1, Scope2, Scope3, ProductCarbonFootprint, OrganizationCarbonFootprint
EnvironmentZone Cleanroom, ESDZone, ATEXZone0, ATEXZone1, ATEXZone2, ATEXZone20, ATEXZone21, ATEXZone22, Hazardous, NonHazardous
IngressProtection IP20, IP30, IP40, IP54, IP55, IP65, IP66, IP67, IP68, IP69K
HazardousZone Class1Div1, Class1Div2, Class2Div1, Class2Div2, Zone0, Zone1, Zone2, Zone20, Zone21, Zone22
DigitalTwinStage AsDesigned, AsPlanned, AsBuilt, AsMaintained, AsOperated
AssetLifecycle Conceived, Designed, Manufactured, Installed, Commissioned, Operated, Maintained, Decommissioned, Disposed
AssetClass Production, Utility, Auxiliary, Safety, Logistics, Quality, IT, OT, Network
AAS_ModelKind Template, Instance
AAS_AssetKind Type, Instance, NotApplicable
LoggingLevel Trace, Debug, Info, Warning, Error, Critical
ErrorClass Communication, Configuration, Hardware, Software, Process, Safety, Security, User, Timeout, Resource
DeviceStatus Offline, Running, Idle, Stopped, Alarm
ProductType RawMaterial, IntermediateProduct, FinishedProduct
ProcessStatus Setup, Process, Maintenance, Adjustment
FaultType Mechanical, Electrical, Software, Operator
RecipeState Draft, Approved, Released, Active, Held, Aborted, Completed, Obsolete
ShiftType Day, Evening, Night, Weekend, Holiday, NonProductive
OperatorSkillLevel Trainee, Operator, SeniorOperator, Specialist, Supervisor, Engineer, Master
AgentRole Planner, Scheduler, Executor, Monitor, Diagnoser, Optimizer, Advisor, HumanInLoop
... Extensions allowed

Enum.Flag is a special subtype that supports hexadecimal logical operations.

9.3.7 Struct Type Subtree

Struct Type Members Description
Struct - General struct
DateTime TimeStamp, TimeSpan, DateTime, Date, Time Date-time composite
TimeStamp seconds: UInt64, nanos: UInt32 Timestamp since a fixed epoch (e.g. Unix or PTP epoch)
TimeSpan seconds: Int64, nanos: Int32 Signed duration
TimeRange start: TimeStamp, end: TimeStamp Closed time interval
TimeWindow start: TimeStamp, duration: TimeSpan Sliding/rolling time window
Schedule cron: String, timezone: String, enabled: Bool Cron-style schedule
Shift id: String, start: Time, end: Time, crew: String Production shift
Calendar workingDays: Array<Date>, holidays: Array<Date>, exceptions: Array<TimeRange> Plant calendar
Vector2 x, y 2D vector
Vector3 x, y, z 3D vector
Vector4 x, y, z, w 4D vector / homogeneous coordinate
Quaternion w, x, y, z Unit quaternion (rotation)
EulerAngles roll, pitch, yaw, order: Enum Euler angles (rad) with rotation order
AxisAngle axis: Vector3, angle Axis–angle rotation (rad)
RotationMatrix m: Float[9] 3×3 row-major rotation matrix
TransformMatrix m: Float[16] 4×4 row-major homogeneous transform
PositionOrientation x, y, z, rx, ry, rz Pose; position + orientation (legacy 6-tuple form)
Pose position: Vector3, orientation: Quaternion, frame: Namespace Pose with explicit reference frame
PoseStamped pose: Pose, timestamp: TimeStamp, frame: Namespace Time-stamped pose
Twist linear: Vector3, angular: Vector3 Velocity (m/s, rad/s)
Acceleration linear: Vector3, angular: Vector3 Linear + angular acceleration
Wrench force: Vector3, torque: Vector3 Cartesian force/torque (N, N·m)
JointState position: Array<Float>, velocity: Array<Float>, effort: Array<Float> n-axis joint state
JointTarget position: Array<Float>, speed: Array<Float>, acceleration: Array<Float> Joint motion target
CartesianTarget pose: Pose, speed, acceleration, blending, frame: Namespace Cartesian motion target
MotionConstraints maxSpeed, maxAcceleration, maxJerk, maxForce, maxTorque Motion limits
Trajectory points: Array<JointTarget>, times: Array<TimeSpan> Time-parameterized joint trajectory
Path waypoints: Array<Pose>, frame: Namespace Cartesian path
Waypoint pose: Pose, blendingRadius, dwellTime: TimeSpan Single waypoint
ToolFrame name: String, pose: Pose, mass, cog: Vector3, inertia: Float[6] Tool / TCP definition
WorkObjectFrame name: String, pose: Pose, userFrame: Namespace Work object / user frame
Workspace min: Vector3, max: Vector3, frame: Namespace Axis-aligned workspace box
BoundingBox min: Vector3, max: Vector3 AABB
OrientedBoundingBox center: Vector3, halfExtents: Vector3, orientation: Quaternion OBB
Polygon vertices: Array<Vector2> 2D polygon
Polyline vertices: Array<Vector3> 3D polyline
Mesh vertices: Array<Vector3>, indices: Array<UInt32>, normals: Array<Vector3> Triangle mesh
GeoLocation latitude, longitude, altitude, crs: String WGS-84 / ECEF location
Map2D origin: Vector3, resolution, width, height, data: Array<UInt8> Occupancy grid
Color r, g, b, a RGBA color (0..1)
ColorTemperature kelvin, tint Color temperature
HSV h, s, v Hue-Saturation-Value
Resolution width: UInt32, height: UInt32 Pixel resolution
Image width, height, pixelFormat: Enum, data: Bytes, timestamp: TimeStamp Raw image frame
Region2D x, y, width, height Image ROI
Detection class: String, score: Float, box: Region2D, pose: Pose? Vision detection result
PointCloud points: Array<Vector3>, colors: Array<Color>?, timestamp: TimeStamp Point cloud frame
LaserScan ranges: Array<Float>, intensities: Array<Float>, angleMin, angleMax, angleIncrement, rangeMin, rangeMax, timestamp: TimeStamp 2D laser scan
IMUSample orientation: Quaternion, angularVelocity: Vector3, linearAcceleration: Vector3, timestamp: TimeStamp Inertial sample
GNSSFix location: GeoLocation, quality: Enum, hdop, numSatellites, timestamp: TimeStamp GNSS position fix
Measurement value: Float, unit: String, uncertainty, quality: Enum, timestamp: TimeStamp Generic measured value with quality
EngineeringValue value, unit, min, max, nominal, tolerance Value with engineering range
Tolerance nominal, upper, lower, class: Enum Symmetric/asymmetric tolerance
Range min, max, unit Min/max range
Setpoint value, ramp, unit, mode: Enum Controller setpoint
PIDParameters kp, ki, kd, dFilter, outputMin, outputMax PID tuning
AnalogSignal value: Float, unit: String, rangeMin, rangeMax, raw: Int32, quality: Enum, timestamp: TimeStamp Analog I/O sample
DigitalSignal value: Bool, quality: Enum, timestamp: TimeStamp Digital I/O sample
Pulse count: UInt64, frequency: Float, dutyCycle: Float, timestamp: TimeStamp Pulse / encoder reading
PWMSignal frequency, dutyCycle, phase PWM output
EncoderReading position: Int64, velocity: Float, direction: Enum, revolutions: Int32, timestamp: TimeStamp Incremental/absolute encoder
IOPoint address: String, type: IOType, value, quality: Enum, timestamp: TimeStamp Generic I/O point
OPCUAValue value, dataType: String, statusCode: StatusCode, sourceTimestamp: TimeStamp, serverTimestamp: TimeStamp OPC UA DataValue
TagValue tag: String, value, quality: Enum, timestamp: TimeStamp SCADA tag value
ModbusFrame unitId: UInt8, functionCode: UInt8, startAddress: UInt16, quantity: UInt16, data: Bytes Modbus PDU
ProfinetFrame frameId: UInt16, cycleCounter: UInt16, dataStatus: UInt8, transferStatus: UInt8, data: Bytes PROFINET RT frame
EtherCATTelegram slaveAddress: UInt16, command: UInt8, index: UInt8, data: Bytes, workingCounter: UInt16 EtherCAT datagram
CANFrame id: UInt32, extended: Bool, rtr: Bool, dlc: UInt8, data: Bytes, timestamp: TimeStamp CAN/CAN-FD frame
MQTTMessage topic: String, payload: Bytes, qos: MQTTQoS, retain: Bool, timestamp: TimeStamp MQTT message
KafkaRecord topic: String, partition: Int32, offset: Int64, key: Bytes, value: Bytes, headers: Map<String,Bytes>, timestamp: TimeStamp Kafka record
NetworkEndpoint host: String, port: UInt16, protocol: String, tls: Bool Network endpoint
Credentials type: Enum, username: String, secretRef: Namespace Credential reference (never inline secrets)
Certificate subject: String, issuer: String, notBefore: DateTime, notAfter: DateTime, fingerprint: String X.509 certificate descriptor
DigitalSignature algorithm: String, value: Bytes, signer: String, timestamp: TimeStamp Signature record
AuditRecord actor: String, action: String, target: Namespace, timestamp: TimeStamp, outcome: Enum, details: Map<String,String> Audit trail entry
Event id: UUID, source: Namespace, type: String, severity: AlarmSeverity, timestamp: TimeStamp, payload: Struct CloudEvents-style event
Alarm id: UUID, source: Namespace, class: String, severity: AlarmSeverity, state: AlarmState, message: LocalizedText, activeTime: TimeStamp, ackTime: TimeStamp?, clearTime: TimeStamp?, acknowledger: String? ISA-18.2 alarm record
Notification recipient: String, channel: Enum, subject: String, body: String, priority: Priority, timestamp: TimeStamp Operator notification
LogEntry level: LoggingLevel, message: String, source: Namespace, timestamp: TimeStamp, context: Map<String,String> Structured log entry
ErrorInfo code: StatusCode, category: ErrorClass, message: LocalizedText, source: Namespace, cause: ErrorInfo?, stackTrace: String? Hierarchical error info
HealthStatus state: ConditionLevel, score: Float, indicators: Map<String,Float>, lastUpdate: TimeStamp Asset health
OEEMetrics availability: Float, performance: Float, quality: Float, oee: Float, window: TimeWindow Computed OEE
CycleRecord cycleId: UUID, start: TimeStamp, end: TimeStamp, duration: TimeSpan, result: QualityResult Single machine cycle
MaterialLot lotId: String, materialNo: String, quantity: Float, unit: String, status: MaterialState, supplier: String?, expiry: DateTime? Material lot
SerialItem serial: String, materialNo: String, parentSerial: String?, genealogy: Array<String>, status: MaterialState Serial-tracked item
BatchRecord batchId: String, recipe: Namespace, state: BatchStatus, start: TimeStamp, end: TimeStamp?, actuals: Map<String,Float> ISA-88 batch record
Recipe id: Namespace, version: Version, state: RecipeState, parameters: Map<String,EngineeringValue>, steps: Array<Struct> Process recipe
WorkOrder orderId: String, productNo: String, quantity: Float, dueDate: DateTime, priority: Priority, status: OrderStatus, routing: Array<Namespace> Production order
JobInstruction jobId: String, workOrder: String, operation: String, resource: Namespace, assignedTo: String?, status: OrderStatus Single job/operation
RoutingStep step: UInt16, operation: String, resource: Namespace, setupTime: TimeSpan, runTime: TimeSpan Routing step
BOMEntry parentMaterial: String, childMaterial: String, quantity: Float, unit: String, scrapPct: Float Bill-of-materials entry
Inventory materialNo: String, location: Namespace, onHand: Float, allocated: Float, reserved: Float, unit: String Inventory record
StorageLocation id: String, type: WarehouseLocationType, aisle, rack, level, position, capacity: Float Warehouse slot
TransportJob jobId: String, from: Namespace, to: Namespace, payload: String, priority: Priority, status: AGVState AMR/AGV transport job
Inspection inspectionId: UUID, type: InspectionType, target: Namespace, criteria: Array<Struct>, result: QualityResult, inspector: String, timestamp: TimeStamp Quality inspection
Defect defectId: UUID, code: String, severity: DefectSeverity, location: Vector3?, image: Resource?, description: LocalizedText Defect record
SPCSample chart: String, value: Float, subgroupSize: UInt16, mean: Float, stdDev: Float, ucl: Float, lcl: Float, timestamp: TimeStamp SPC measurement
CalibrationRecord device: Namespace, date: DateTime, nextDue: DateTime, result: QualityResult, certificate: Resource? Calibration entry
MaintenanceWorkOrder woId: String, asset: Namespace, type: MaintenanceType, priority: Priority, status: OrderStatus, due: DateTime, technician: String? CMMS work order
Reliability mtbf: TimeSpan, mttr: TimeSpan, availability: Float, failureRate: Float Reliability metrics
EnergyReading carrier: EnergyCarrier, power: Float, energy: Float, unit: String, timestamp: TimeStamp Energy meter reading
EmissionRecord scope: Sustainability, co2eq: Float, unit: String, source: Namespace, window: TimeWindow CO2-equivalent emissions
ProcessSample temperature: Float, pressure: Float, flow: Float, level: Float, ph: Float, conductivity: Float, timestamp: TimeStamp Generic process sample
EnvironmentSample temperature: Float, humidity: Float, pressure: Float, co2: Float, pm25: Float, pm10: Float, tvoc: Float, timestamp: TimeStamp Ambient environment sample
SafetyEvent type: HazardClass, source: Namespace, severity: AlarmSeverity, state: SafetyState, timestamp: TimeStamp Safety event
LOTORecord asset: Namespace, state: LOTOState, lockOwner: String, tagId: String, timestamp: TimeStamp Lockout/Tagout record
Operator id: String, name: String, role: UserRole, skill: OperatorSkillLevel, certs: Array<String> Operator profile
Assignment operator: String, resource: Namespace, shift: Shift, task: String Operator assignment
AASIdentifier idType: Enum, id: String, idShort: String AAS identifier
AASReference keys: Array<Struct> Asset Administration Shell reference
Property idShort: String, valueType: String, value, semanticId: String?, unit: String? AAS-style property
Capability name: String, domain: String, inputs: Array<Property>, outputs: Array<Property> Declared capability
KPI name: String, formula: Expression, target: Float, actual: Float, unit: String, window: TimeWindow KPI definition + value
TimeSeriesPoint timestamp: TimeStamp, value, quality: Enum Single TS sample
TimeSeries tag: Namespace, unit: String, points: Array<TimeSeriesPoint> Time series segment
Histogram buckets: Array<Float>, counts: Array<UInt64>, sum: Float, count: UInt64 Histogram
Statistics count: UInt64, min: Float, max: Float, mean: Float, stdDev: Float, p50: Float, p95: Float, p99: Float Aggregated statistics
... Extensions allowed

Default interpretation for PositionOrientation and Pose:

Member Unit
x, y, z meter (m)
rx, ry, rz radian (rad)
Quaternion w, x, y, z unit quaternion (dimensionless)
Twist linear / angular m/s / rad/s
Wrench force / torque N / N·m

All struct types SHOULD declare engineering units on numeric fields via the unit attribute when units are not implied by the type. Nested struct types are supported, but cyclic nesting is not allowed.

9.3.8 Reference Type Subtree

Reference types use the format @Namespace to reference other data.

Type Description
Ref Generic reference
ResourceRef Reference to a Resource Description bound to a parameter
ParameterRef Reference to a parameter from RD, FB port, or DT
... Extensions allowed

ResourceRef

Used mainly on FB input ports to specify which resources are bound.

Example definition:

Example instance values:

ParameterRef

Any type in the type tree may be converted to a parameter reference value.

Examples:

10. Logic Fusion Layer

The Logic Fusion Layer defines how workflows are executed by combining:

10.1 Composition of the Logic Fusion Layer

To organize FB-described behaviors into executable workflows, the logic layer must support:

The primary logical implementation method is the Industrial Behavior Tree.

Guidance from the source rules:

10.2 Finite State Machine and Execution Mechanism

The preferred FSM uses four states:

State Category Description
IDLE Basic Node has not yet been executed
RUN Basic Node is currently running
OK Basic Node finished and returned success
FAIL Basic Node finished and returned failure

Typical factory behaviors such as:

all pass through such states.

Tick Mechanism

A key feature of behavior trees is the tick mechanism.

FB Tick

When an FB receives a tick, the execution engine should execute a small non-blocking code fragment that:

Workflow Tick

When a workflow receives a tick, the engine traverses the tree starting from the root node (typically the Start node’s child), ticks each FB, captures return states, and uses them to determine traversal direction.

Once traversal returns to the root, the current cycle ends. Traversal repeats until workflow termination.

Concurrency and Execution Rules

Rule Requirement
Scheduler threading The tree execution engine is single-threaded
Tick execution All tick methods are executed sequentially
Blocking If any tick blocks, the whole flow is blocked
Unreached nodes State remains IDLE
Long-running FB Must immediately return RUN after starting
Async execution May delegate long-running work to another thread or process
Completion On next tick after completion, returns OK or FAIL

Reliability-Oriented FB Methods

Each FB should implement:

Method Purpose
halt() Safely stop execution immediately from an intermediate position
exception() Handle exception or error and attempt recovery; if unrecoverable, return FAIL and output error status code

For highly reliable industrial scenarios, more complex multi-state logic may be used, but CREEM does not constrain that extension.

10.3 Industrial Behavior Tree

The Industrial Behavior Tree is an industrial extension of the general AI behavior tree paradigm.

It is a tree structure composed of function block nodes connected to describe behaviors and decisions. Execution proceeds along node relationships and priorities until the target state is reached.

10.3.1 Categories of Special BT Nodes

The source standard defines three groups of special BT nodes:

  1. Flow Control Nodes
  2. System Nodes
  3. Logic Nodes

All categories are extensible.

10.3.2 Workflow Control FB Nodes

Node Namespace
Start FB.BT.FlowControl.Start
End FB.BT.FlowControl.End
KeyPoint FB.BT.FlowControl.KeyPoint
Goto FB.BT.FlowControl.Goto
Stop FB.BT.FlowControl.Stop
Abort FB.BT.FlowControl.Abort
... FB.BT.FlowControl.*

Semantics

10.3.3 System FB Nodes

Node Namespace
Empty FB.BT.System.Empty
Manual FB.BT.System.Manual
Delay FB.BT.System.Delay
CallWorkflow FB.BT.System.CallWorkflow
Group FB.BT.System.Group
Parameter FB.BT.System.Parameter
Dynamic FB.BT.System.Dynamic
... FB.BT.System.*

Semantics

10.3.4 Logic FB Nodes

Industrial behavior trees are logically complete and can represent all propositional logic formulas through combinations of the following logic nodes.

Composite Nodes

Node Namespace
Sequence FB.BT.Logic.Composite.Sequence
Parallel FB.BT.Logic.Composite.Parallel
Fallback FB.BT.Logic.Composite.Fallback
ReactiveSequence FB.BT.Logic.Composite.ReactiveSequence
ReactiveFallback FB.BT.Logic.Composite.ReactiveFallback
SequenceWithMemory FB.BT.Logic.Composite.SequenceWithMemory
... FB.BT.Logic.Composite.*

Decorator Nodes

Node Namespace
Condition FB.BT.Logic.Decorator.Condition
Repeat FB.BT.Logic.Decorator.Repeat
Retry FB.BT.Logic.Decorator.Retry
Inverter FB.BT.Logic.Decorator.Inverter
Timeout FB.BT.Logic.Decorator.Timeout
OneShot FB.BT.Logic.Decorator.OneShot
... FB.BT.Logic.Decorator.*

Idiom Nodes

Node Namespace
IfThenElse FB.BT.Logic.Idiom.IfThenElse
Switch FB.BT.Logic.Idiom.Switch
Foreach FB.BT.Logic.Idiom.Foreach
RuleEngine FB.BT.Logic.Idiom.RuleEngine
... FB.BT.Logic.Idiom.*

Behavioral Definitions

All composite and decorator nodes MUST honour the BT lifecycle contract:

RuleEngine Guidance

If complex logic is defined using a DSL or graphical language (decision table, rule set, BPMN fragment, statechart, etc.):

  1. The rule engine implementation SHOULD remain inside the RuleEngine node and MUST NOT be lifted into the parent BT tick.
  2. Every triggered execution path SHOULD be exposed and connected to at least one child node so that the BT remains the single source of orchestration truth (see §10.5).
  3. The rule set MUST be versioned together with the enclosing workflow; hot-reload of rules requires explicit engine support (see §10.6 Hot-reload and partial deployment).
  4. Inputs and outputs MUST be bound to the blackboard / DT via the FB's port contract; the engine MUST NOT read or write DT entries outside its declared interface.
  5. The engine MUST report deterministic results: for the same inputs, the same rule set version, and the same tick context, the resolved branch MUST be reproducible. Non-deterministic conflict-resolution strategies (e.g. salience, recency, randomization) MUST be declared in metadata.
  6. The engine SHOULD emit structured telemetry per evaluation: matched rules, fired branch, evaluation latency, and any inputs that triggered side-effects — enabling audit and replay.
  7. Unmatched-input handling MUST be explicit (default_branch, fail, pass-through); silent fall-through is prohibited.
  8. Recursive or fixed-point rule sets MUST declare a termination bound (max iterations, max wall-clock) and SHOULD raise an alarm when the bound is hit.
  9. Rule sets that participate in safety-relevant decisions MUST be reviewed and signed off via the certified change process (see §10.6 Safety integration).
  10. The engine SHOULD support offline simulation against historical inputs for regression testing of rule-set changes.

10.4 Global Data Table (DT)

The Global Data Table is the mechanism for describing and exchanging data among basic objects.

Part Description
id Namespace
Metadata Metadata segment
UIInformation UI segment
Data Data segment
Parameter Parameter collection
Resource Resource segment

Characteristics

Storage Semantics

DT parameters are stored in memory by default.

When persistence is needed, parameters may map to:

The namespace should use the prefix DT.*.

FB Port ↔ DT Binding

Function Block ports and DT entries form a uniform parameter space: any FB input/output port MAY be aggregated into a DT entry by reference, and any FB parameter MAY resolve its value by referencing a DT entry using the @DT.* reference syntax. This makes the DT both a shared blackboard between FBs and a projection surface for external systems (HMI, historian, MES, twin, agent).

OT-Domain DT Examples

The following examples illustrate canonical DT layouts for common OT scenarios. Each example shows the namespaced parameter path, type (see §9.3), unit, and a short description. They are non-normative templates intended to anchor engineering practice; concrete projects MAY extend, rename, or sub-namespace these entries.

Example 1 — Discrete-Manufacturing Cell (Robot + Conveyor + Vision)

Path Type Unit Description
DT.Cell01.Meta.Site String - ISA-95 site code
DT.Cell01.Meta.Area String - ISA-95 area code
DT.Cell01.Meta.WorkCenter String - ISA-95 work-center identifier
DT.Cell01.State.Machine Enum.MachineState - PackML 17-state (Stopped, Idle, Execute, …)
DT.Cell01.State.Mode Enum.PackMLMode - Production / Maintenance / Manual
DT.Cell01.OEE.Availability Float % Rolling 1-min availability
DT.Cell01.OEE.Performance Float % Rolling 1-min performance
DT.Cell01.OEE.Quality Float % Rolling 1-min first-pass yield
DT.Cell01.OEE.OEE Float % Composite OEE
DT.Cell01.Robot.JointState Struct.JointState rad 6-DoF joint positions, velocities, efforts
DT.Cell01.Robot.TcpPose Struct.PoseStamped m, rad TCP pose in base_link frame
DT.Cell01.Robot.Wrench Struct.Wrench N, N·m FT-sensor reading at TCP
DT.Cell01.Robot.SafetyMode Enum.RobotSafetyMode - Normal / Reduced / Protective / Recovery
DT.Cell01.Conveyor.Speed Float m/s Belt linear speed
DT.Cell01.Conveyor.Direction Enum.Direction6 - Forward / Reverse / Stop
DT.Cell01.Vision.LastDetection Struct.Detection - Latest detected part bbox + class + score
DT.Cell01.Vision.InspectionResult Enum.QualityResult - Pass / Fail / Rework
DT.Cell01.WorkOrder.Active Struct.WorkOrder - Currently executing work order
DT.Cell01.Material.LotInProcess Struct.MaterialLot - Material lot at the cell
DT.Cell01.Alarm.Active Array - ISA-18.2 active alarm list

Example 2 — Continuous Process (Tank + Pump + PID Control Loop)

Path Type Unit Description
DT.Unit_T101.Meta.Tag String - KKS / AKS tag, e.g. 10LAB10AA001
DT.Unit_T101.Process.Level.PV Float m Process value (measured level)
DT.Unit_T101.Process.Level.SP Float m Setpoint
DT.Unit_T101.Process.Level.MV Float % Manipulated variable (valve opening)
DT.Unit_T101.Process.Temperature.PV Float °C Tank temperature
DT.Unit_T101.Process.Pressure.PV Float bar Head-space pressure
DT.Unit_T101.Process.Flow.Inlet Float m³/h Inlet mass flow
DT.Unit_T101.Process.Flow.Outlet Float m³/h Outlet mass flow
DT.Unit_T101.Control.Mode Enum - Manual / Auto / Cascade / Remote
DT.Unit_T101.Control.PID Struct.PIDParameters - Kp, Ki, Kd, anti-windup, output clamp
DT.Unit_T101.Control.Output Struct.AnalogSignal mA 4-20 mA loop output
DT.Unit_T101.Limits.LL / .L / .H / .HH Float m Alarm thresholds (LoLo, Lo, Hi, HiHi)
DT.Unit_T101.Alarm.State Enum.AlarmState - ISA-18.2 normal / unack / shelved / suppressed
DT.Unit_T101.Interlock.Engaged Bool - Safety interlock asserted
DT.Unit_T101.Recipe.Active Struct.Recipe - Currently executing recipe (ISA-88)
DT.Unit_T101.Batch.Record Struct.BatchRecord - Live batch record

Example 3 — AGV / AMR Fleet

Path Type Unit Description
DT.Fleet.AMR07.Meta.Serial String.SerialNumber - Vehicle serial
DT.Fleet.AMR07.State Enum.AMRMode - Idle / Picking / Transit / Charging / Fault
DT.Fleet.AMR07.Pose Struct.PoseStamped m, rad Pose in map frame
DT.Fleet.AMR07.Twist Struct.Twist m/s, rad/s Current linear + angular velocity
DT.Fleet.AMR07.Battery.SoC Float % State of charge
DT.Fleet.AMR07.Battery.SoH Float % State of health
DT.Fleet.AMR07.NavStatus Enum.NavigationStatus - Planning / Following / Blocked / Reached
DT.Fleet.AMR07.Path Struct.Path m Active path in map frame
DT.Fleet.AMR07.Job Struct.TransportJob - Active transport job
DT.Fleet.AMR07.LastScan Struct.LaserScan m Latest 2D LiDAR scan
DT.Fleet.AMR07.Safety.EStop Enum.EStopState - Released / Engaged / Recovering

Example 4 — Energy & Sustainability Monitoring

Path Type Unit Description
DT.Site.Energy.Electric.PowerActive Float kW Active power
DT.Site.Energy.Electric.PowerReactive Float kvar Reactive power
DT.Site.Energy.Electric.EnergyTotal Float kWh Cumulative consumption
DT.Site.Energy.Electric.PowerFactor Float - cosφ
DT.Site.Energy.Gas.Flow Float Nm³/h Natural-gas flow
DT.Site.Energy.Steam.Flow Float t/h Steam flow
DT.Site.Energy.Water.Flow Float m³/h Process-water flow
DT.Site.Energy.CompressedAir.Pressure Float bar Header pressure
DT.Site.Emissions.CO2e.Hourly Float kgCO2e Hourly CO₂-equivalent emissions
DT.Site.Emissions.Scope1 / .Scope2 / .Scope3 Float tCO2e GHG-protocol scope totals
DT.Site.Environment.AmbientTemp Float °C Outdoor temperature
DT.Site.Environment.RelHumidity Float % Outdoor relative humidity

Example 5 — Predictive Maintenance (Rotating Equipment)

Path Type Unit Description
DT.Asset.Pump_P201.Vibration.RMS_X Float mm/s Velocity RMS, X-axis
DT.Asset.Pump_P201.Vibration.RMS_Y Float mm/s Velocity RMS, Y-axis
DT.Asset.Pump_P201.Vibration.RMS_Z Float mm/s Velocity RMS, Z-axis
DT.Asset.Pump_P201.Vibration.Spectrum Struct.TimeSeries Hz, mm/s Latest FFT spectrum
DT.Asset.Pump_P201.BearingTemp Float °C Bearing temperature
DT.Asset.Pump_P201.MotorCurrent Float A Motor current
DT.Asset.Pump_P201.RunHours Float h Cumulative runtime
DT.Asset.Pump_P201.Health.Index Float - 0–1 composite health score
DT.Asset.Pump_P201.Health.RUL Struct.TimeSpan s Estimated remaining useful life
DT.Asset.Pump_P201.Maintenance.NextDue Struct.DateTime.TimeStamp - Next planned maintenance
DT.Asset.Pump_P201.Maintenance.LastWO Struct.MaintenanceWorkOrder - Last completed work order

Example 6 — Quality & SPC (Inline Inspection Station)

Path Type Unit Description
DT.QC.Station03.Measurement.Length Struct.Measurement mm Latest measured length with tolerance
DT.QC.Station03.Measurement.Diameter Struct.Measurement mm Latest measured diameter
DT.QC.Station03.SPC.Xbar Float mm Subgroup mean
DT.QC.Station03.SPC.R Float mm Subgroup range
DT.QC.Station03.SPC.Cp / .Cpk Float - Process capability indices
DT.QC.Station03.Defect.Count UInt32 - Defect count in current shift
DT.QC.Station03.Defect.Pareto Array - Pareto-ranked defect categories
DT.QC.Station03.Calibration.LastDate Struct.DateTime.TimeStamp - Last calibration timestamp
DT.QC.Station03.Calibration.NextDue Struct.DateTime.TimeStamp - Next calibration due date
DT.QC.Station03.Inspection.LastResult Enum.QualityResult - Pass / Fail / Rework / Hold

These templates demonstrate that DT entries can span discrete, continuous, mobile, energy, asset-health, and quality domains using the same DT.<Scope>.<Subsystem>.<Signal> convention. Engineering tools SHOULD provide importers for AAS submodels, OPC UA Companion Specifications (PackML, RoboticsCS, MachineTool, Weihenstephan, etc.), and ISA-95 / ISA-88 hierarchy templates to bootstrap these structures automatically.

10.5 Engineering Guidance Principles

The standard does not restrict the implementation of industrial engineering software, but recommends that engineering tools preferably use:

  1. Domain-Specific Languages (DSLs) compliant with the modeling rules:
    • textual DSLs for RD/FB authoring (e.g. YAML/JSON/TOML schemas, IEC 61131-3 ST, structured Python/Lua/Rust subsets),
    • configuration DSLs for project topology, parameter binding, and deployment manifests,
    • constraint / rule DSLs for safety interlocks, alarm logic, and quality predicates,
    • query DSLs for the Knowledge Repository (namespace selection, semantic search, model validation),
    • asset description DSLs aligned with AAS, OPC UA NodeSet, and SysML/SysMLv2.

  2. Graphical Languages: the Industrial Behavior Tree (IBT) is the default and canonical graphical format for orchestration, supervisory logic, error recovery, and cross-domain composition. All other graphical formalisms are integrated by encapsulating them as Function Blocks (FBs) that appear as leaf (or sub-tree) nodes in the IBT — they are never executed as independent top-level graphs:

    • function block diagrams (FBD) and continuous function charts (CFC) — control loops and signal flow, packaged as an FB whose tick invokes one solver step,
    • sequential function charts (SFC / Grafcet) and state machines (UML/Harel statecharts, ISA-88 procedures) — packaged as a stateful FB; the BT advances the SFC/SM by one transition per tick or runs it to a stable state,
    • flowcharts / activity diagrams — compiled into an FB or expanded into an equivalent BT sub-tree at import time,
    • ladder diagrams (LD) and instruction lists (IL) — wrapped as a scan-cycle FB for backward compatibility with legacy controllers,
    • piping & instrumentation diagrams (P&ID), process flow diagrams (PFD), and layout diagrams — used as plant-context views; their tags bind to FB I/O but do not execute,
    • dataflow / pipeline graphs for AI and analytics — packaged as a pipeline FB invoked from the BT,
    • timing diagrams and Gantt views for batch, recipe, and shift scheduling — rendered as scheduler FBs that emit BT events.

    The encapsulating FB MUST expose a uniform BT contract (tick/status with SUCCESS/FAILURE/RUNNING, optional halt/reset), declare its determinism class, reentrancy, and WCET, and surface its internal state through the blackboard so that the IBT remains the single source of orchestration truth.

  3. Bidirectional textual ↔ graphical round-tripping: every graphical model SHOULD have a canonical, version-controllable textual serialization, and edits in either view MUST be preserved without loss.

  4. Project / model lifecycle support:
    • versioning (semantic versioning, Git-based history, model diff/merge),
    • validation (schema, type, unit, namespace, and constraint checking before deployment),
    • simulation and dry-run (offline execution against virtual devices or digital twins),
    • debugging (breakpoints, watch variables, BT tick tracing, FB step-into),
    • hot-reload and partial deployment where the target engine permits.
  5. Reusability and packaging: RDs, FBs, sub-trees, and graphical fragments SHOULD be packageable as libraries with explicit interfaces, dependencies, and compatibility metadata.
  6. Internationalization and accessibility: labels, units, alarm texts, and tooltips SHOULD support multi-language resources (see §8.2.3 BCP 47) and screen-reader-friendly representations.
  7. Collaboration: source-code-friendly storage (text-based, line-stable serialization), code review workflows, role-based access control, and audit logging on all engineering operations.

This recommendation follows WFC's visual and executable modeling approach: any model expressible in a graphical language MUST also have a lossless textual DSL representation, and vice versa. The same artifact can then be authored, reviewed, version-controlled, and executed across different toolchains.

10.6 Execution Engine Guidance Principles

An execution engine is a program or service that parses CREEM-compliant workflows and executes IT/OT function blocks through an industrial behavior tree scheduler.

Recommended implementation principles:

Principle Guidance
Scheduler isolation The behavior tree scheduler SHOULD be isolated from FB execution threads/processes (separate thread pool, process, or container) to prevent FB faults from blocking tick propagation
Non-hard-real-time scheduler Prefer interpreter-based scheduler (e.g. tree walker, bytecode VM) for fast iteration, hot-reload, and dynamic graph editing
Non-hard-real-time FB execution Prefer process-isolated interpreted or compiled execution (per-FB sandbox, language-agnostic, gRPC/IPC/MQTT bridge)
Mixed real-time needs Strong-real-time partial functions MAY run in separate compiled processes (RT kernel, Xenomai, PREEMPT_RT, dedicated MCU) communicating with the scheduler over shared memory, DDS, or TSN
Hard-real-time scheduler Prefer compiler-based scheduler (AOT compiled BT to C/Rust/IEC 61131-3 ST) with deterministic tick budget and bounded memory
Hard-real-time FB execution Prefer conversion into a unified compiled language and merged execution within the same task; avoid dynamic dispatch, GC, and unbounded allocations
Platform separation Execution engine SHOULD be separated from the engineering software platform; the engineering tool produces a deployable artefact (model + manifest + signed checksum) consumed by the engine
Determinism & timing Provide configurable tick rates, jitter budgets, watchdogs, and worst-case execution time (WCET) reporting per BT node and per FB
Concurrency model Document the threading and reentrancy contract (single-threaded tick, parallel branches, async FBs); FB authors MUST declare reentrancy and idempotency
State management Persist and restore BT state, blackboard variables, and DT parameters across restarts; support checkpoint/restore for long-running workflows
Hot-reload and partial deployment Allow individual FBs, sub-trees, or DT bindings to be replaced without restarting the engine, with version negotiation and rollback on validation failure
Observability Emit structured telemetry: tick traces, FB span events, blackboard diffs, alarm events; expose OpenTelemetry, OPC UA A&C, and ISA-18.2 alarm interfaces
Logging & audit Append-only audit log of model loads, deployments, parameter overrides, manual interventions, and safety acknowledgements
Security Mutual authentication (X.509, OPC UA UserToken, OAuth2), authorization (RBAC/ABAC), signed model artefacts, encrypted transport (TLS 1.3, OPC UA SecurityPolicy), least-privilege FB sandboxing
Safety integration Integrate with safety controllers via certified channels (PROFIsafe, openSAFETY, CIP Safety, FSoE); never route safety logic through non-certified BT branches
Fault tolerance & recovery Retry, fallback, circuit-breaker, and supervisor BT patterns; clean separation of recoverable errors, fatal errors, and operator-acknowledgeable alarms
High availability Optional active/standby or active/active redundancy with state replication and bumpless transfer for continuous processes
Resource governance Per-FB CPU/memory/bandwidth quotas, back-pressure on message buses, and graceful degradation under overload
Portability Engine binaries SHOULD run on common industrial OSes (Linux, RT-Linux, Windows, QNX, VxWorks) and edge form factors (PLC, IPC, edge gateway, container, cloud VM)
Interoperability Expose standard north-bound interfaces (OPC UA, MQTT, REST, gRPC, DDS) and south-bound drivers (Modbus, PROFINET, EtherCAT, EtherNet/IP, BACnet, CAN) without recompiling the engine
Time synchronization Synchronize to a disciplined clock source (PTP/IEEE 1588, NTP, TSN) and timestamp all events with monotonic and wall-clock pairs
Conformance & certification Pass the CREEM conformance test suite (model parsing, BT semantics, type system, namespace resolution) and document deviations explicitly
Diagnostics & maintainability Provide a diagnostic console (live BT view, FB inspector, blackboard browser), crash dumps with model context, and remote support hooks
Lifecycle management Versioned model deployment, signed updates, staged rollout, and rollback; engine itself follows semantic versioning and publishes compatibility matrices

11. Production System Knowledge Repository Layer

This layer defines the domain ecosystem for RDs and FBs through namespace-based classification.

It provides the knowledge structure for describing:

It also supports:

11.1 RD Classification

RDs are classified into four major categories:

  1. General
  2. OT Hardware
  3. IT and OT Software
  4. AI Capability Components

11.1.1 General RD Category

English Name Namespace
General RD.General
Group RD.System.Group
Placeholder RD.Placeholder
Material RD.Material
Dynamic RD.Dynamic
Custom RD.Custom
... Extensions

Interpretation:

11.1.2 OT Hardware RD Category

English Name Namespace
ProductionLine RD.ProductionLine.*
Workstation RD.Workstation.*
MachineTool RD.MachineTool.*
Robot RD.Robot.*
Logistics RD.Logistics.*
Detection RD.Detection.*
Controller RD.Controller.*
Sensor RD.Sensor.*
Actuator RD.Actuator.*
Device RD.Device.*
Human RD.Human.*
... Extensions

Interpretation includes:

11.1.3 IT and OT Software RD Category

English Name Namespace
Program RD.Program.*
Database RD.Database.*
Protocol RD.Protocol.*
File RD.File.*
Service RD.Service.*
Software RD.Software.*
Software Solution RD.Software.Solution.*
Operation System RD.OS.*
... Extensions

This includes:

11.1.4 AI Capability Component RD Category

English Name Namespace
AI Model RD.AI.Model.*
AI Inference Service RD.AI.Inference.*
Industrial Agent RD.AI.Agent.*
... RD.AI.*

Interpretation:

11.2 FB Classification

FBs are classified into three groups:

  1. General
  2. Multi-Programming-Language Adaptation
  3. Behavior Packaging

11.2.1 General FB Category

English Name Namespace
General FB.General
System FB.System.*
Behavior Tree Logic FB.BT.*
General Logic FB.Logic.*
Document FB.Document.*
Exception FB.Exception.*
Custom FB.Custom.*
... Extensions

Interpretation:

11.2.2 Multi-Programming-Language Adaptation

English Name Namespace
JIT Programming Language FB.PL.JIT.*
AOT Programming Language FB.PL.AOT.*
Dynamic Library FB.Library.Dynamic.*
Static Library FB.Library.Static.*
IT DSL FB.DSL.IT.*
OT DSL FB.DSL.OT.*
Markup FB.Markup.*
Graphical Language FB.Graphical.*
... Extensions

This allows behaviors to be implemented in arbitrary languages.

Interpretation

11.2.3 Behavior Packaging

English Name Namespace
AtomicBehavior FB.AtomicBehavior.*
CompositeBehavior FB.CompositeBehavior.*
CompositeBehavior (shorthand) FB.Behavior.*

Interpretation:

Examples:

Level Example
Atomic MoveLinear, MoveJoint
Composite PickAndPlace
Nested Composite LoadingAndUnloading, Palletizing

12. Modeling Examples and Engineering Guidance

12.1 Physical-to-Abstract Mapping

CREEM maps physical IT/OT elements to model abstractions:

Physical / Operational Concept CREEM Abstraction
Behavioral subject Resource Description
Atomic behavior Function Block
Behavior aggregation Workflow
Data/property Parameter
Behavior implementation Code / library / executable reference

This gives a clean bridge between real equipment/software and executable engineering models.

12.2 Multi-Level Workflow Modeling

A workstation can be decomposed into:

Composite behaviors may call workflows or sub-workflows through CallWorkflow.

This enables hierarchical engineering without losing runtime executability.

12.3 Full Lifecycle Alignment

The source standard recommends that the following all align with the reconfigurable model:

CREEM is therefore a lifecycle model as well as a runtime graph.

12.4 Example: Flexible Digital Production Line

A real digital flexible production line may be hierarchically divided into:

These form a Resource Tree, then receive RD namespace descriptions, and finally get behavior descriptions through FBs.

13. Reference Architecture and Runtime View

This chapter provides a non-normative reference architecture and runtime view of CREEM. It complements the formal layered model in chapters 7–11 by describing CREEM's place in an Industrial Data Mesh, the customer requirements behind it, its mapping to 3D scene standards, and a possible runtime built around a shared data plane and workflow execution engine.

Much of the material in this chapter originates from agentic-AI and runtime research (the DBM derivative work) and has been reworded so that all model concepts use the unified CREEM vocabulary.

13.1 Architectural View — The Mission

CREEM sits within the broader software and architecture stack of an Industrial Data Mesh. It is the shared modeling and exchange layer for an Agentic Interoperability Data Plane above conventional IT/OT integration.

Stack Layer Role
IT/OT Building Blocks / Environments Physical and virtual assets, controllers, edge/cloud infrastructure
Industrial Data Mesh (Data Integration) Cross-system data integration and governance
Runtime Control Plane Workflow execution, scheduling, orchestration
Agentic Interoperability Data Plane CREEM-based semantic interoperability for agents and tools
Knowledge Representation / Design Intelligence Engineering knowledge, design AI

Inside this stack, CREEM provides:

13.2 Boundary — Solution View

In a typical implementation, CREEM is the common model referenced by the engineering tool, the runtime engine, and the digital-twin/3D visualization platform.

Reference role split:

Component Responsibility
Workflow Canvas Engineering Authoring of CREEM instances (RD, FB, WF, Project)
Workflow Canvas Runtime Execution of CREEM workflows on physical / virtual targets
CREEM Repositories RD/FB libraries shared across projects
Information Connector / IIH Connectivity to controllers, devices, IT systems
Anchor Model / OPC UA Ontology Asset semantic mapping
Vertical Project Models Domain-specific assemblies for energy, building, data center, FMCG, etc.
3D Scene Platforms (e.g. SiteScope MultiModal, etc.) Holographic / digital-twin visualization mapped through CREEM RDs

CREEM instances can be mapped against heterogeneous standards and information models, including:

CREEM is a compatibility surface. Software and device manufacturers can keep their existing standards; CREEM provides a common meta-structure, namespace, data type, status code, unit, and execution-logic layer.

13.3 Why — Industry Requirements

The following requirements are sourced from real customer and factory practice in industries including consumer goods, machinery, pharmaceuticals, automotive, and electronics:

Requirement Description
Scalability / Flexibility Nothing should be hard-coded in a software app or PLC program; end users should be able to change logic at runtime.
Unified Workflow / Orchestration The user should be able to implement a process across multiple IT and OT elements: read an order from ERP, update scheduling and recipe, get PLC I/O signals, use a camera to recognize an object, notify an AGV to pick, use a Python algorithm to calculate OEE, notify operators to update reports, scan an RFID, send G-Code to a CNC, update a database via SQL, …
Ecosystem All mainstream communicable devices should be supported regardless of protocol/interface. Devices can be uniformly addressed, support traceability in a unified data space, and allow reverse control.
No / Low Development Effort Less dependency on system integrators or development teams.
Fast to Add New Devices Users can add new device types — multiple domains and non-standard devices — quickly.
Extensibility / Customized Logic Exchange data across IT/OT programming languages and DSLs through a general type system.
Intuitive Semantic Programming Easy to understand and learn for both humans and agentic AI.
Virtual–Physical Mapping The same workflow drives both 3D simulation and real shop-floor control.
Fast to Implement An implemented standard and software stack can be deployed in 3–6 months.

13.4 What — Definition

A CREEM (Common Runtime Engineering Exchange Model) instance describes how AI/IT/OT assets perform actions and change state over time under runtime conditions through parameterized inputs, execution logic, and state transitions. The model is designed to be consumed both by agentic AI and by platform developers.

Notes:

13.5 How — Key Features and Mechanisms

Key Feature Implementation Mechanism
Meta definition Unified meta-models for Asset, Behavior, Parameter, and Execution semantics via a hierarchical type inheritance tree
Static asset repository Standardized asset descriptions using structured Resource Descriptions (RD) and RD namespaces
Dynamic behavior repository Atomic and composite behaviors maintained as reusable, device-independent behavior models
Asset & behavior binding Behaviors bound to assets via capability abstraction and parameter interface mapping
Physical & virtual mapping Bidirectional mapping between physical equipment and virtual models (OpenUSD, 3MF, IFC, glTF…) via identifiers and runtime context
General namespace (index) Global uniqueness and semantic indexing via hierarchical namespace addressing
General data type system Interoperable data types based on primitive types extended into engineering and behavior types
General data unit system Engineering units aligned with international unit specifications and associated with parameters
General executable logic Industrial Behavior Tree + FSM-based execution semantics
General status code Unified status codes derived from the OPC UA status model
AI-understandable models Structured, machine-interpretable semantic models; every element has natural-language descriptions
Globalization Internationally aligned standards and language-neutral identifiers and namespaces
Extensibility Domain extension through inheritance-based type expansion and namespace scalability

13.6 Multi-Level Scene Model (Static) and Behavior Model (Dynamic)

CREEM uses a multi-level Scene Model to organize Assets statically, and a Behavior Model to describe their dynamic capabilities.

Typical scene hierarchy:

Scene Level Examples
Factory (Floor Plan) Whole site layout
Production Line Line composition
Workstation Cell / station composition
Machine Machine internal composition
Logistics Material flow scenes
Humanoid / Humans Worker / humanoid robot scenes

Typical assets at workstation/machine level:

A static Scene Model and a dynamic Behavior Model together form a holographic mapping of the production system.

13.7 Scene Model Mapping to 3D Standards

CREEM Scene Models map cleanly onto major 3D scene standards.

CREEM Concept CREEM Definition OpenUSD Mapping 3MF Mapping Other (glTF, IFC, JT) Mapping
Resource (Industrial Asset) Namespace-addressable industrial entity USD Prim (Xform) 3MF Object glTF Node, IFC Element, JT Node
Namespace Global semantic identifier USD Stage Path (/Plant/Line/...) Object ID / Component Path IFC GlobalId, glTF Scene Graph
Static Asset Model Reference in RD UsdGeomMesh Mesh Resource STEP AP242 Geometry, glTF Mesh
Topology Structure Resource Typology USD Scene Graph Build Item Hierarchy IFC Spatial Structure
Parameter Atomic base object USD Attributes Metadata Property IFC PropertySet, glTF Extras
Unit System UN/ECE USD Metadata 3MF Unit Definition ISO 80000 Units
Capability What an asset can perform USD Relationship / Schema Custom Metadata IFC Capability Property
Atomic Behavior Smallest executable action Custom USD Schema External metadata reference N/A
Composite Behavior Workflow behavior composition USD Composition / Layer Assembly Definition Process extension required
Behavior Tree Execution logic structure USD Relationship Graph N/A External simulation model
Execution State Runtime lifecycle state VariantSet / Attribute Metadata State Flag Simulation runtime extension
StatusCode Execution result semantics (IEC 62541) Custom Attribute Metadata External control model
Physical–Virtual Mapping Unified model Live Transform Update N/A IFC Digital Twin linkage
3D Runtime Unified runtime & execution engine USD Runtime Extension N/A External execution engine
Digital Twin Instance Unified runtime asset instance USD Instancing Component Instance IFC Twin Instance
Workflow Context Unified workflow execution context USD Layer Composition N/A BPMN / ISA-95 linkage
AI-understandable Semantic Model Machine-readable behavior semantics USD Semantic Schema Extension Metadata only N/A

13.8 Asset Model and Scene Graph Architecture

A reference asset and scene management service organizes CREEM-described assets as follows.

Asset Model (per asset)

Scene Model (Scene Graph, hierarchical tree)

Node Purpose
Scene Metadata Unique ID, namespace, URI
Asset Node <reference> Reference to CREEM RD asset model instances
Annotation Node Semantic tags, alert labels, maintenance comments
Data Node Hooks to real-time and historical data sources for asset parameters
Actuator Node Hooks to CREEM behaviors (FBs / Workflows)

Scene models can be referenced by other scene models, and multiple scene models can be stitched together. Each scene model can be exported with mapping to OpenUSD, 3MF, glTF, IFC, JT, and similar standards.

13.9 Data Continuum and Runtime Data Plane

A reference CREEM runtime is organized around a data continuum that unifies static engineering data and dynamic runtime data.

Layer Contents
Static Data Programmable Asset Models, Non-Programmable Asset Models, 3D Asset Libraries, Workflow definitions, Scene Models, Synthetic Data
Dynamic Data Behavior and observation data surrogates (robot, AGV, PLC, virtual sensor/camera) and runtime parameter values
Time-sequenced Data Pipeline Timeseries database, continuous storage, replay
Workflow / Orchestration Workflow Canvas + workflow engine consuming CREEM workflows
IT/OT Integration Connectors to physical or virtual equipment

Reference internal services:

13.10 The Matrix — Temporal MIMO Data & Event Stream Engine

The Matrix is a reference runtime mechanism for streaming CREEM data and events under back-pressure with strict causality.

Key structural elements:

Element Purpose
Multi-Inputs / Multi-Outputs Multiple producers and consumers connect to a single queue
Temporal MIMO Queue Time-ordered events with causality and back-pressure handling
Dataflow Tick Scheduler Periodic ticking aligned with behavior tree execution
Behavior Filter Filters and routes behavior events
Active Behavior Abstraction Layer Outbound: behavior commands and active updates
Passive Event Abstraction Layer Inbound: sensor / event-driven inputs
Memory Mapper / State Engine Maps live data into memory space and state objects
Virtual Process Image (VPI) Temporal slice of the industrial world state
Timeseries Database Continuous historical storage with replay support

13.11 Holographic Virtual Process Image (VPI)

A Virtual Process Image captures a temporal slice of the industrial world state. Multiple temporal slices form a holographic VPI that supports:

The VPI can be projected back into the data plane (Active Behavior Abstraction Layer, Passive Event Abstraction Layer) and into virtualized devices (Robot Emulator, PLC Emulator, AGV Emulator, Virtual Sensors, Virtual Camera, Physical Engine) so that the same workflow drives both real and virtual targets.

13.12 Industrial Behavior Tree — Worked Sample

A representative composite workflow “Screw Fastening” illustrates how heterogeneous IT/OT assets coordinate inside a single CREEM workflow:

Workflow port summary (selected):

Port Bound Parameter
Home moveToHome.Target
Speed moveToHome.Speed
Mode moveToHome.Mode
Feeder moveToFeeder.Target
Target moveToTarget.Target
IPAdd fastenScrew.IPAdd
Result fastenScrew.Result

This illustrates how CREEM combines motion, vision, fastening, retry/exception logic, prioritized recycling branches, and operator escalation in a single executable behavior tree.

13.13 Behavior Library and Function Block Authoring

A reference CREEM authoring tool organizes FBs into libraries (system libraries, vendor libraries, user libraries). A typical FB definition includes:

Example — RoboticLibrary.MoveJoints definition:

Aspect Value
Name MoveJoints
Display Name Move Joints #
Category LogicalNode
Library Robotic Library
Author © SIEMENS™
Certification e6bb0119-2a2c-49ef-a31d-f7c45113f647
Input: Activate BOOL, default YES
Input: Robotic REF
Input: Velocity NUMBER, default 250
Input: Acceleration NUMBER, default 1200
Input: Trajectory JSON
Input: Duration NUMBER, default 0
Input: Blending NUMBER, default 0
Output: Status ENUM

Typical libraries supplied by such a tool include:

13.14 CREEM Markup Schema — Meta Structure

The CREEM serialization schema is built on a base object that follows a uniform meta-structure:

Segment Purpose
Metadata UUID, Schema Namespace, Instance URI, Certificate, Display Name, Data Tag Name, Data Attribute…
UI Information UI Graph Data and related presentation hints
Data Tree (default inner data structure) and/or Directed Graph
Resource Icons, Data Files, Codes

The schema layers are:

  1. CREEM Base — Markup Schema: base meta information model (meta of meta, schema namespace, base/meta data types).
  2. CREEM Structure — Markup Schema: common information model built on top of the base; defines the canonical meta-structure (Metadata / UI Information / Data / Resource).
  3. CREEM Ecosystem: concrete markup instances and DSL instances written against the structure.

This three-layer schema design is what enables CREEM to be extended at any segment while keeping schema validation tractable.

13.15 Adaptation with Existing Standards

The information model describes devices and objects; CREEM standardizes or retrofits existing equipment and systems for description and interconnection within a standardized scope. The behavior model describes dynamic interactions and execution; CREEM maps to existing information models without requiring uniformity.

The complete interoperability matrix, with one row per standard, is maintained in Appendix F.

13.16 Engineering File System Structure

The complete CREEM project layout for engineering tools and agentic AI is maintained in Appendix G. That appendix combines the asset, behavior, project, runtime, and device structure with the corresponding namespace links.

14. Appendix A — Modeling Examples

A.1 Example Mapping from Physical Elements to Reconfigurable Model Elements

Behavioral subjects in production systems typically include both IT and OT elements. When these are integrated into one system and begin interacting, dynamic interoperable behavior emerges.

CREEM models this as follows:

This also enables mapping to other information models at the data layer.

A.2 Example of Multi-Level Workflow Behavior in a Workstation

A single workstation may be divided into multiple equipment elements and equipment-based behaviors. These include both atomic and composite behaviors.

Composite behaviors may be realized through CallWorkflow, invoking workflows or sub-workflows.

Typical layering:

Level Example
Workstation workflow Machining -> Packaging -> Logistics
Equipment workflow PLC signal -> Robot pick/place -> Machining
Process/step workflow Move -> Grasp -> Move

A.3 Example of Full Lifecycle Relationship

The source standard recommends that a reconfigurable production system cover the full lifecycle through a consistent model:

Other standardized information models from physical equipment may also map into the CREEM model for interoperability.

A.4 Example Namespaces for a Flexible Digital Workshop

In a digital flexible production line, resources may include:

These are represented first as a resource tree, then as namespace-classified RDs, and then as FBs for behaviors such as:

A.5 Example of Namespace Ecosystem Across IT/OT Elements

The source standard shows an integrated example where:

This illustrates the namespace as a full-stack modeling backbone.

15. Appendix B — Resource Description Namespace Examples

15.1 Hardware Device Resources

Category Namespace
PC Controller RD.Controller.PC.*
IPC RD.Controller.PC.IPC.*
Server RD.Controller.PC.Server.*
Workstation RD.Controller.PC.Workstation.*
EdgeBox RD.Controller.PC.EdgeBox.*
Panel PC RD.Controller.PC.PanelPC.*
Rugged Laptop RD.Controller.PC.RuggedLaptop.*
Embedded Controller RD.Controller.Embedded.*
SBC RD.Controller.Embedded.SBC.*
SoM / SoC Module RD.Controller.Embedded.SoM.*
FPGA Board RD.Controller.Embedded.FPGA.*
SC / MCU RD.Controller.Embedded.SC.*
GPU Accelerator RD.Controller.Accelerator.GPU.*
NPU / AI Accelerator RD.Controller.Accelerator.NPU.*
TPU RD.Controller.Accelerator.TPU.*
Network Device RD.Device.NetworkDevice.*
Router RD.Device.NetworkDevice.Router.*
Switch RD.Device.NetworkDevice.Switch.*
Industrial Switch RD.Device.NetworkDevice.Switch.Industrial.*
TSN Switch RD.Device.NetworkDevice.Switch.TSN.*
Firewall RD.Device.NetworkDevice.Firewall.*
Gateway RD.Device.NetworkDevice.Gateway.*
Protocol Gateway RD.Device.NetworkDevice.Gateway.Protocol.*
Edge Gateway RD.Device.NetworkDevice.Gateway.Edge.*
WirelessAP RD.Device.NetworkDevice.WirelessAP.*
5G Device RD.Device.NetworkDevice.5G.*
5G CPE RD.Device.NetworkDevice.5G.CPE.*
LoRa Gateway RD.Device.NetworkDevice.LoRaGateway.*
PLC RD.Controller.PLC.*
Compact PLC RD.Controller.PLC.Compact.*
Modular PLC RD.Controller.PLC.Modular.*
Safety PLC RD.Controller.PLC.Safety.*
SoftPLC RD.Controller.PLC.SoftPLC.*
PAC RD.Controller.PAC.*
DCS RD.Controller.DCS.*
RTU RD.Controller.RTU.*
MotionController RD.Controller.Motion.*
CNC Controller RD.Controller.CNC.*
Robot Controller RD.Controller.Robot.*
Drive / Servo RD.Controller.Drive.Servo.*
VFD RD.Controller.Drive.VFD.*
Stepper Drive RD.Controller.Drive.Stepper.*
HMI (hardware) RD.Device.HMI.*
Industrial Monitor RD.Device.HMI.Monitor.*
Touch Panel RD.Device.HMI.TouchPanel.*
Push Button Box RD.Device.HMI.ButtonBox.*
Andon RD.Device.HMI.Andon.*
Signal Tower RD.Device.HMI.SignalTower.*
IO RD.Device.IO.*
Digital IO RD.Device.IO.Digital.*
Analog IO RD.Device.IO.Analog.*
Remote IO RD.Device.IO.Remote.*
IO-Link Master RD.Device.IO.IOLinkMaster.*
Robot RD.Robot.*
Industrial Robot RD.Robot.IndustrialRobot.*
SCARA RD.Robot.IndustrialRobot.SCARA.*
Delta Robot RD.Robot.IndustrialRobot.Delta.*
Cartesian Robot RD.Robot.IndustrialRobot.Cartesian.*
Palletizing Robot RD.Robot.IndustrialRobot.Palletizing.*
Painting Robot RD.Robot.IndustrialRobot.Painting.*
Welding Robot RD.Robot.IndustrialRobot.Welding.*
Cobot RD.Robot.Cobot.*
Mobile Manipulator RD.Robot.MobileManipulator.*
Humanoid RD.Robot.Humanoid.*
Quadruped RD.Robot.Quadruped.*
Exoskeleton RD.Robot.Exoskeleton.*
End Effector RD.Robot.EndEffector.*
Gripper RD.Robot.EndEffector.Gripper.*
Parallel Gripper RD.Robot.EndEffector.Gripper.Parallel.*
Vacuum Gripper RD.Robot.EndEffector.Gripper.Vacuum.*
Magnetic Gripper RD.Robot.EndEffector.Gripper.Magnetic.*
Soft Gripper RD.Robot.EndEffector.Gripper.Soft.*
Dexterous Hand RD.Robot.EndEffector.Gripper.Dexterous.*
ToolChanger RD.Robot.EndEffector.ToolChanger.*
TorqueWrench RD.Robot.EndEffector.TorqueWrench.*
Welding Torch RD.Robot.EndEffector.WeldingTorch.*
Dispensing Head RD.Robot.EndEffector.Dispenser.*
Screw Driver RD.Robot.EndEffector.ScrewDriver.*
Riveter RD.Robot.EndEffector.Riveter.*
Spray Gun RD.Robot.EndEffector.SprayGun.*
Industrial Camera RD.Detection.Camera.Industrial.*
Camera RD.Detection.Camera.*
Smart Camera RD.Detection.Camera.Smart.*
Area-Scan Camera RD.Detection.Camera.AreaScan.*
Line-Scan Camera RD.Detection.Camera.LineScan.*
3D Camera RD.Detection.Camera.3D.*
Stereo Camera RD.Detection.Camera.3D.Stereo.*
Structured-Light Camera RD.Detection.Camera.3D.StructuredLight.*
ToF Camera RD.Detection.Camera.3D.ToF.*
Thermal Camera RD.Detection.Camera.Thermal.*
Hyperspectral Camera RD.Detection.Camera.Hyperspectral.*
X-Ray Imager RD.Detection.Camera.XRay.*
Lidar RD.Detection.Lidar.*
Radar RD.Detection.Radar.*
AGV RD.Logistics.AGV.*
AMR RD.Logistics.AMR.*
Forklift RD.Logistics.Forklift.*
AGV Forklift RD.Logistics.Forklift.AGV.*
Conveyor RD.Logistics.Conveyor.*
Belt Conveyor RD.Logistics.Conveyor.Belt.*
Roller Conveyor RD.Logistics.Conveyor.Roller.*
Chain Conveyor RD.Logistics.Conveyor.Chain.*
Sorter RD.Logistics.Sorter.*
Stacker Crane RD.Logistics.StackerCrane.*
ASRS RD.Logistics.ASRS.*
Vertical Lift Module RD.Logistics.VLM.*
Shuttle RD.Logistics.Shuttle.*
Hoist RD.Logistics.Hoist.*
Discharge Port RD.Logistics.DischargePort.*
Pick Station RD.Logistics.PickStation.*
CNC RD.MachineTool.CNC.*
Lathe RD.MachineTool.Lathe.*
Milling Machine RD.MachineTool.Milling.*
Machining Center RD.MachineTool.MachiningCenter.*
Grinder RD.MachineTool.Grinder.*
EDM RD.MachineTool.EDM.*
Laser Cutter RD.MachineTool.Laser.Cutter.*
Laser Welder RD.MachineTool.Laser.Welder.*
Laser Marker RD.MachineTool.Laser.Marker.*
Press RD.MachineTool.Press.*
Injection Molding RD.MachineTool.InjectionMolding.*
Die Casting RD.MachineTool.DieCasting.*
Stamping RD.MachineTool.Stamping.*
Bending Machine RD.MachineTool.Bending.*
Welding Machine RD.MachineTool.Welding.*
Reactor RD.MachineTool.Process.Reactor.*
Mixer RD.MachineTool.Process.Mixer.*
Filler RD.MachineTool.Process.Filler.*
Capper RD.MachineTool.Process.Capper.*
Labeler RD.MachineTool.Process.Labeler.*
Wrapper RD.MachineTool.Process.Wrapper.*
Cartoner RD.MachineTool.Process.Cartoner.*
Palletizer RD.MachineTool.Process.Palletizer.*
Scanner RD.Detection.Scanner
QRCode Scanner RD.Detection.Scanner.QRCode.*
Barcode Scanner RD.Detection.Scanner.Barcode.*
RFID RD.Detection.Scanner.RFID.*
PDA RD.Detection.Scanner.PDA.*
OCR Reader RD.Detection.Scanner.OCR.*
3D Scanner RD.Detection.Scanner.3D.*
Weighing Scale RD.Detection.Scale.*
CMM RD.Detection.Metrology.CMM.*
Vision Measurement RD.Detection.Metrology.Vision.*
Leak Tester RD.Detection.Tester.Leak.*
Hi-Pot Tester RD.Detection.Tester.HiPot.*
Function Tester RD.Detection.Tester.Function.*
ConsumerElectronics RD.Device.ConsumerElectronics.*
SmartPhone RD.Device.ConsumerElectronics.SmartPhone.*
Tablet RD.Device.ConsumerElectronics.Tablet.*
SmartWearable RD.Device.ConsumerElectronics.SmartWearable.*
Smart Glasses RD.Device.ConsumerElectronics.SmartGlasses.*
AR/VR Headset RD.Device.ConsumerElectronics.XRHeadset.*
Smart Watch RD.Device.ConsumerElectronics.SmartWatch.*
3D Printer RD.MachineTool.3DPrinter.*
FDM Printer RD.MachineTool.3DPrinter.FDM.*
SLA Printer RD.MachineTool.3DPrinter.SLA.*
SLS Printer RD.MachineTool.3DPrinter.SLS.*
Metal 3D Printer RD.MachineTool.3DPrinter.Metal.*
Drone RD.Device.Drone.*
AUV RD.Device.AUV.*
USV RD.Device.USV.*
Sensor RD.Sensor.*
Temperature Sensor RD.Sensor.Temperature.*
Humidity Sensor RD.Sensor.Humidity.*
Pressure Sensor RD.Sensor.Pressure.*
Flow Sensor RD.Sensor.Flow.*
Level Sensor RD.Sensor.Level.*
Proximity Sensor RD.Sensor.Proximity.*
Photoelectric Sensor RD.Sensor.Photoelectric.*
Ultrasonic Sensor RD.Sensor.Ultrasonic.*
Vibration Sensor RD.Sensor.Vibration.*
Acoustic Sensor RD.Sensor.Acoustic.*
Force/Torque Sensor RD.Sensor.ForceTorque.*
Load Cell RD.Sensor.LoadCell.*
Encoder RD.Sensor.Encoder.*
Gas Sensor RD.Sensor.Gas.*
Particulate Sensor RD.Sensor.Particulate.*
Current/Voltage Sensor RD.Sensor.Electrical.*
IMU RD.Sensor.IMU.*
GPS Receiver RD.Sensor.GPS.*
UWB Anchor RD.Sensor.UWB.*
Actuator RD.Actuator.*
Pneumatic Cylinder RD.Actuator.Pneumatic.Cylinder.*
Hydraulic Cylinder RD.Actuator.Hydraulic.Cylinder.*
Solenoid Valve RD.Actuator.Valve.Solenoid.*
Proportional Valve RD.Actuator.Valve.Proportional.*
Servo Motor RD.Actuator.Motor.Servo.*
Stepper Motor RD.Actuator.Motor.Stepper.*
Linear Motor RD.Actuator.Motor.Linear.*
Pump RD.Actuator.Pump.*
Heater RD.Actuator.Heater.*
Chiller RD.Actuator.Chiller.*
Workstation RD.Workstation.*
Assembly Workstation RD.Workstation.Assembly.*
Inspection Workstation RD.Workstation.Inspection.*
Packaging Workstation RD.Workstation.Packaging.*
Manual Workstation RD.Workstation.Manual.*
Cleanroom Workstation RD.Workstation.Cleanroom.*
Power Supply RD.Device.Power.Supply.*
UPS RD.Device.Power.UPS.*
Battery Pack RD.Device.Power.Battery.*
Charging Station RD.Device.Power.ChargingStation.*
HVAC RD.Device.HVAC.*
Air Compressor RD.Device.Utility.AirCompressor.*
Vacuum Pump RD.Device.Utility.VacuumPump.*
Dust Collector RD.Device.Utility.DustCollector.*
Water Treatment RD.Device.Utility.WaterTreatment.*
IoT Cloud Device RD.Controller.IoT.Cloud.*
IoT Edge Device RD.Controller.IoT.Edge.*
IoT End Node RD.Controller.IoT.EndNode.*
Wearable Scanner RD.Device.Wearable.Scanner.*
Smart Wristband RD.Device.Wearable.Wristband.*
NonStandardDevice RD.Device.NonStandard.*

15.2 Database Resources

Database Namespace
PostgreSQL RD.Database.Rational.PostgreSQL
Oracle RD.Database.Rational.Oracle
SQL Server RD.Database.Rational.SQLServer
MySQL RD.Database.Rational.MySQL
MariaDB RD.Database.Rational.MariaDB
DB2 RD.Database.Rational.DB2
SQLite RD.Database.Rational.SQLite
Hive RD.Database.Rational.Hive
Access RD.Database.Rational.Access
Amazon Aurora RD.Database.Rational.AWS.Aurora
Google Cloud SQL RD.Database.Rational.GCP.CloudSQL
Google AlloyDB RD.Database.Rational.GCP.AlloyDB
Azure SQL Database RD.Database.Rational.Azure.SQLDatabase
Azure Database for PostgreSQL RD.Database.Rational.Azure.PostgreSQL
Supabase RD.Database.Rational.Supabase
Neon RD.Database.Rational.Neon
Xata RD.Database.Rational.Xata
PlanetScale RD.Database.Rational.PlanetScale
Vitess RD.Database.Rational.Vitess
TiDB RD.Database.NewSQL.TiDB
CockroachDB RD.Database.NewSQL.CockroachDB
YugabyteDB RD.Database.NewSQL.YugabyteDB
Google Spanner RD.Database.NewSQL.GCP.Spanner
OceanBase RD.Database.NewSQL.OceanBase
TDSQL RD.Database.NewSQL.Tencent.TDSQL
PolarDB RD.Database.NewSQL.Alibaba.PolarDB
GaussDB RD.Database.NewSQL.Huawei.GaussDB
MongoDB RD.Database.Document.MongoDB
MongoDB Atlas RD.Database.Document.MongoDB.Atlas
DynamoDB RD.Database.Document.AWS.DynamoDB
Cosmos DB RD.Database.Document.Azure.CosmosDB
Google Firestore RD.Database.Document.GCP.Firestore
Cloudflare D1 RD.Database.Document.Cloudflare.D1
Couchbase RD.Database.Document.Couchbase
CouchDB RD.Database.Document.CouchDB
Firebase Realtime RD.Database.Document.FirebaseRealtime
RavenDB RD.Database.Document.RavenDB
FerretDB RD.Database.Document.FerretDB
EdgeDB / Gel RD.Database.Document.EdgeDB
SurrealDB RD.Database.MultiModel.SurrealDB
ArangoDB RD.Database.MultiModel.ArangoDB
OrientDB RD.Database.MultiModel.OrientDB
MarkLogic RD.Database.MultiModel.MarkLogic
Redis RD.Database.KVPair.Redis
Valkey RD.Database.KVPair.Valkey
KeyDB RD.Database.KVPair.KeyDB
Dragonfly RD.Database.KVPair.Dragonfly
Memcached RD.Database.KVPair.Memcached
Hazelcast RD.Database.KVPair.Hazelcast
Aerospike RD.Database.KVPair.Aerospike
etcd RD.Database.KVPair.etcd
Consul KV RD.Database.KVPair.ConsulKV
FoundationDB RD.Database.KVPair.FoundationDB
TiKV RD.Database.KVPair.TiKV
RocksDB RD.Database.KVPair.RocksDB
LevelDB RD.Database.KVPair.LevelDB
LMDB RD.Database.KVPair.LMDB
Amazon ElastiCache RD.Database.KVPair.AWS.ElastiCache
Azure Cache for Redis RD.Database.KVPair.Azure.CacheForRedis
Upstash Redis RD.Database.KVPair.Upstash.Redis
InfluxDB RD.Database.TSDB.InfluxDB
InfluxDB 3 (IOx) RD.Database.TSDB.InfluxDB3
IoTDB RD.Database.TSDB.IoTDB
TDengine RD.Database.TSDB.TDengine
ClickHouse RD.Database.TSDB.ClickHouse
ClickHouse Cloud RD.Database.TSDB.ClickHouse.Cloud
TimescaleDB RD.Database.TSDB.TimescaleDB
QuestDB RD.Database.TSDB.QuestDB
GreptimeDB RD.Database.TSDB.GreptimeDB
VictoriaMetrics RD.Database.TSDB.VictoriaMetrics
OpenTSDB RD.Database.TSDB.OpenTSDB
Prometheus RD.Database.TSDB.Prometheus
Mimir RD.Database.TSDB.Grafana.Mimir
Thanos RD.Database.TSDB.Thanos
M3DB RD.Database.TSDB.M3DB
Graphite RD.Database.TSDB.Graphite
KairosDB RD.Database.TSDB.KairosDB
Amazon Timestream RD.Database.TSDB.AWS.Timestream
Azure Data Explorer RD.Database.TSDB.Azure.DataExplorer
Snowflake RD.Database.DataWarehouse.Snowflake
Databricks SQL RD.Database.DataWarehouse.Databricks.SQL
Google BigQuery RD.Database.DataWarehouse.GCP.BigQuery
Amazon Redshift RD.Database.DataWarehouse.AWS.Redshift
Azure Synapse RD.Database.DataWarehouse.Azure.Synapse
Apache Doris RD.Database.DataWarehouse.Doris
StarRocks RD.Database.DataWarehouse.StarRocks
Apache Pinot RD.Database.OLAP.Pinot
Apache Druid RD.Database.OLAP.Druid
DuckDB RD.Database.OLAP.DuckDB
MotherDuck RD.Database.OLAP.MotherDuck
Apache Iceberg RD.Database.Lakehouse.Iceberg
Apache Hudi RD.Database.Lakehouse.Hudi
Delta Lake RD.Database.Lakehouse.DeltaLake
Apache Paimon RD.Database.Lakehouse.Paimon
Unity Catalog RD.Database.Lakehouse.UnityCatalog
Polaris Catalog RD.Database.Lakehouse.Polaris
Apache Hive Metastore RD.Database.Lakehouse.HiveMetastore
Trino RD.Database.QueryEngine.Trino
Presto RD.Database.QueryEngine.Presto
Apache Spark SQL RD.Database.QueryEngine.Spark.SQL
Apache Flink SQL RD.Database.QueryEngine.Flink.SQL
Dremio RD.Database.QueryEngine.Dremio
JanusGraph RD.Database.Graph.JanusGraph
Neo4j RD.Database.Graph.Neo4j
Neo4j Aura RD.Database.Graph.Neo4j.Aura
DGraph RD.Database.Graph.DGraph
Amazon Neptune RD.Database.Graph.AWS.Neptune
Apache TinkerPop RD.Database.Graph.TinkerPop
NebulaGraph RD.Database.Graph.NebulaGraph
TigerGraph RD.Database.Graph.TigerGraph
Memgraph RD.Database.Graph.Memgraph
KuzuDB RD.Database.Graph.KuzuDB
Apache AGE RD.Database.Graph.ApacheAGE
Stardog RD.Database.Graph.Stardog
GraphDB (Ontotext) RD.Database.Graph.GraphDB
Virtuoso RD.Database.Graph.Virtuoso
Apache Jena TDB RD.Database.Graph.JenaTDB
Blazegraph RD.Database.Graph.Blazegraph
Pinecone RD.Database.Vector.Pinecone
Weaviate RD.Database.Vector.Weaviate
Milvus RD.Database.Vector.Milvus
Zilliz Cloud RD.Database.Vector.Zilliz.Cloud
Qdrant RD.Database.Vector.Qdrant
Chroma RD.Database.Vector.Chroma
LanceDB RD.Database.Vector.LanceDB
Vespa RD.Database.Vector.Vespa
Vald RD.Database.Vector.Vald
Marqo RD.Database.Vector.Marqo
Turbopuffer RD.Database.Vector.Turbopuffer
pgvector (PostgreSQL) RD.Database.Vector.pgvector
pgvectorscale RD.Database.Vector.pgvectorscale
Redis VSS RD.Database.Vector.RedisVSS
Elasticsearch kNN RD.Database.Vector.Elasticsearch.kNN
OpenSearch kNN RD.Database.Vector.OpenSearch.kNN
Azure AI Search RD.Database.Vector.Azure.AISearch
Amazon OpenSearch RD.Database.Vector.AWS.OpenSearch
Elasticsearch RD.Database.Search.Elasticsearch
OpenSearch RD.Database.Search.OpenSearch
Apache Solr RD.Database.Search.Solr
Meilisearch RD.Database.Search.Meilisearch
Typesense RD.Database.Search.Typesense
Manticore Search RD.Database.Search.Manticore
Algolia RD.Database.Search.Algolia
Quickwit RD.Database.Search.Quickwit
Apache Cassandra RD.Database.WideColumn.Cassandra
ScyllaDB RD.Database.WideColumn.ScyllaDB
HBase RD.Database.WideColumn.HBase
Google Bigtable RD.Database.WideColumn.GCP.Bigtable
Amazon Keyspaces RD.Database.WideColumn.AWS.Keyspaces
Apache Kudu RD.Database.WideColumn.Kudu
EventStoreDB RD.Database.EventStore.EventStoreDB
Axon Server RD.Database.EventStore.AxonServer
Materialize RD.Database.Streaming.Materialize
RisingWave RD.Database.Streaming.RisingWave
KsqlDB RD.Database.Streaming.KsqlDB
Estuary Flow RD.Database.Streaming.EstuaryFlow
Apache Drill RD.Database.QueryEngine.Drill
Apache Impala RD.Database.QueryEngine.Impala
Apache Pinot Realtime RD.Database.OLAP.Pinot.Realtime
Firebolt RD.Database.DataWarehouse.Firebolt
ClickHouse Keeper RD.Database.Coordination.ClickHouse.Keeper
Apache ZooKeeper RD.Database.Coordination.ZooKeeper
IndexedDB RD.Database.LocalStorage.IndexedDB
LocalForage RD.Database.LocalStorage.LocalForage
PouchDB RD.Database.LocalStorage.PouchDB
RxDB RD.Database.LocalStorage.RxDB
Dexie.js RD.Database.LocalStorage.DexieJS
LokiJS RD.Database.LocalStorage.LokiJS
Lovefield RD.Database.LocalStorage.Lovefield
ZangoDB RD.Database.LocalStorage.ZangoDB
WatermelonDB RD.Database.LocalStorage.WatermelonDB
ObjectBox RD.Database.Embedded.ObjectBox
Realm RD.Database.Embedded.Realm
DuckDB (Embedded) RD.Database.Embedded.DuckDB
SQLite WASM RD.Database.Embedded.SQLiteWASM
Turso (libSQL) RD.Database.Edge.Turso
Cloudflare Durable Objects RD.Database.Edge.Cloudflare.DurableObjects
Fauna RD.Database.Serverless.Fauna

Note: The above catalog covers the major database ecosystems — relational, NewSQL/distributed SQL, document, key-value/cache, time-series, data warehouse, lakehouse / open table formats (Iceberg / Hudi / Delta / Paimon), query engines (Trino / DuckDB), graph (property-graph + RDF), vector / embedding stores (Pinecone, Milvus, Qdrant, LanceDB, pgvector, …) driven by the LLM / RAG boom, search, wide-column, event-store, streaming-materialized-view, edge/serverless, and embedded / on-device. Cloud-managed services follow the RD.Database.<Category>.<Cloud>.<Product> pattern (e.g. AWS, Azure, GCP, Alibaba, Tencent, Huawei, Cloudflare).

15.3 Protocols, Message Buses, Industrial Ethernet, Fieldbus, Wireless, MCU Protocols

IT Communication Protocols and Message Buses

Protocol Namespace
General TCP/UDP RD.Protocol.General.General
HTTP/HTTPS RD.Protocol.General.HTTP
REST RD.Protocol.General.HTTP.REST
OpenAPI RD.Protocol.General.HTTP.REST.OpenAPI
OData RD.Protocol.General.HTTP.REST.OData
MCP RD.Protocol.General.HTTP.REST.MCP
RPC RD.Protocol.General.RPC
JSON-RPC RD.Protocol.General.RPC.JSON-RPC
XML-RPC RD.Protocol.General.RPC.XML-RPC
gRPC RD.Protocol.General.RPC.gRPC
GraphQL RD.Protocol.General.GraphQL
Socket RD.Protocol.General.Socket
WebSocket RD.Protocol.General.WebSocket
SOAP RD.Protocol.General.SOAP
CoAP RD.Protocol.General.CoAP
WebHook RD.Protocol.General.WebHook
MQTT RD.Protocol.MessageBroker.MQTT
AMQP RD.Protocol.MessageBroker.AMQP
DDS RD.Protocol.MessageBroker.DDS
STOMP RD.Protocol.MessageBroker.STOMP
Kafka RD.Protocol.MessageBroker.Kafka
RabbitMQ RD.Protocol.MessageBroker.RabbitMQ
ZeroMQ RD.Protocol.MessageBroker.ZeroMQ
JMS RD.Protocol.MessageBroker.JMS
Redis Pub/Sub RD.Protocol.MessageBroker.RedisPubSub

Industrial Ethernet

Protocol Namespace
OPC UA RD.Protocol.IndustrialEthernet.OPCUA
EtherNet/IP RD.Protocol.IndustrialEthernet.EthernetIP
Modbus TCP/IP RD.Protocol.IndustrialEthernet.ModbusTCPIP
ProfiNET RD.Protocol.IndustrialEthernet.ProfiNET
Ethernet POWERLINK RD.Protocol.IndustrialEthernet.Powerlink
SERCOS III RD.Protocol.IndustrialEthernet.SercosIII
CC-Link IE RD.Protocol.IndustrialEthernet.CC-LinkIE
EtherCAT RD.Protocol.IndustrialEthernet.EtherCAT
IO-Link RD.Protocol.IndustrialEthernet.IO-Link
OPC DA RD.Protocol.IndustrialEthernet.OPCDA
VARAN RD.Protocol.IndustrialEthernet.VARAN
HART-IP RD.Protocol.IndustrialEthernet.HART-IP
BACnet RD.Protocol.IndustrialEthernet.BACNet
ControlNet RD.Protocol.IndustrialEthernet.ControlNet
DeviceNet RD.Protocol.IndustrialEthernet.DeviceNet

Fieldbus

Protocol Namespace
General Serial (RS-232/485/422) RD.Protocol.FieldBus.GeneralSerial
ProfiBUS RD.Protocol.FieldBus.ProfiBUS
Modbus RTU RD.Protocol.FieldBus.Modbus
DeviceNet RD.Protocol.FieldBus.DeviceNet
HART RD.Protocol.FieldBus.HART
CANopen RD.Protocol.FieldBus.CANopen
AS-i RD.Protocol.FieldBus.AS-i
Foundation Fieldbus RD.Protocol.FieldBus.FoundationFieldbus
Interbus-S RD.Protocol.FieldBus.Interbus-S
CC-Link RD.Protocol.FieldBus.CC-Link
Sercos RD.Protocol.FieldBus.Sercos
BACNet RD.Protocol.FieldBus.BACNet
LoRaWAN RD.Protocol.FieldBus.LoRaWAN
KNX RD.Protocol.FieldBus.KNX

Industrial Wireless

Protocol Namespace
Wi-Fi RD.Protocol.Wireless.WiFi
Bluetooth RD.Protocol.Wireless.Bluetooth
ZigBee RD.Protocol.Wireless.ZigBee
Z-Wave RD.Protocol.Wireless.Z-Wave
EnOcean RD.Protocol.Wireless.EnOcean
Sigfox RD.Protocol.Wireless.Sigfox
LoRaWAN RD.Protocol.Wireless.LoRaWAN
NB-IoT RD.Protocol.Wireless.NB-IoT
LTE-M RD.Protocol.Wireless.LTE-M
WirelessHART RD.Protocol.Wireless.WirelessHART
ISA100.11a RD.Protocol.Wireless.ISA100-11a
IEEE 802.11 RD.Protocol.Wireless.IEEE802-11
Thread RD.Protocol.Wireless.Thread
DSRC RD.Protocol.Wireless.DSRC
NFC RD.Protocol.Wireless.NFC
ANT RD.Protocol.Wireless.ANT
RFID RD.Protocol.Wireless.RFID

Single-Chip / MCU Protocols

Protocol Namespace
UART RD.Protocol.SingleChip.UART
I2C RD.Protocol.SingleChip.I2C
SPI RD.Protocol.SingleChip.SPI
USB RD.Protocol.SingleChip.USB

15.4 File Formats

IT Parseable Files

File Type Namespace
PlainText RD.File.IT.PlainText
CSV RD.File.IT.CSV
XLSX RD.File.IT.XLSX
DOCX RD.File.IT.DOCX
PDF RD.File.IT.PDF
HTML RD.File.IT.HTML

OT File Formats

File Type Namespace
ODB++ RD.File.OT.PCB.ODBPlusPlus
IPC-2581 RD.File.OT.PCB.IPC2581
Gerber RD.File.OT.PCB.Gerber
GDSII RD.File.OT.Semiconductor.GDSII
DXF RD.File.OT.CAD.DXF
STEP RD.File.OT.CAD.STEP
IGES RD.File.OT.CAD.IGES
3MF RD.File.OT.CAD.3MF
STL RD.File.OT.Printer3D.STL
AMF RD.File.OT.Printer3D.AMF
X3D RD.File.OT.Printer3D.X3D
NIfTI RD.File.OT.MedicalDevice.NIfTI
DICOM RD.File.OT.MedicalDevice.DICOM

15.5 Standard Services

Service Namespace
Shared Folder RD.Service.Information.SharedFolder
File System RD.Service.Information.FS
Network File System RD.Service.Information.NFS.*
FTP RD.Service.Information.FTP
SSH RD.Service.Information.SSH
Push Message RD.Service.Information.PushMessage

15.6 Software Solutions

Solution Namespace
ERP RD.Software.Solution.ERP
CRM RD.Software.Solution.CRM
SRM RD.Software.Solution.SRM
SCM RD.Software.Solution.SCM
PLM RD.Software.Solution.PLM
MES RD.Software.Solution.MES
MOM RD.Software.Solution.MOM
WMS RD.Software.Solution.WMS
TMS RD.Software.Solution.TMS
EAM RD.Software.Solution.EAM
APS RD.Software.Solution.APS
OMS RD.Software.Solution.OMS
LMS RD.Software.Solution.LMS
EMS RD.Software.Solution.EMS

15.7 Operating Systems

OS Namespace
Windows RD.OS.Windows
Unix RD.OS.Unix
Linux RD.OS.Linux.*
Ubuntu RD.OS.Linux.Ubuntu
MacOS RD.OS.MacOS
Android RD.OS.Mobile.Android
iOS RD.OS.Mobile.iOS
HarmonyOS RD.OS.Mobile.Harmony
RTOS RD.OS.RTOS.*
VxWorks RD.OS.RTOS.VxWorks
FreeRTOS RD.OS.RTOS.FreeRTOS
ThreadX RD.OS.RTOS.ThreadX
Zephyr RD.OS.RTOS.Zephyr

Domain Operating Systems

OS Namespace
ROS RD.OS.Domain.ROS
RIOT OS RD.OS.Domain.RIOT
Contiki RD.OS.Domain.Contiki
TinyOS RD.OS.Domain.TinyOS

16. Appendix C — Function Block Namespace Examples

16.1 Programming Languages

JIT Languages

Language Dependency Namespace
Python - FB.PL.JIT.Python
JavaScript NodeJS FB.PL.JIT.JavaScript
TypeScript NodeJS FB.PL.JIT.TypeScript
Shell - FB.PL.JIT.Shell
Bat - FB.PL.JIT.Bat
PowerShell - FB.PL.JIT.PowerShell
Perl - FB.PL.JIT.Perl
Lua LuaJIT FB.PL.JIT.Lua
Ruby - FB.PL.JIT.Ruby
PHP - FB.PL.JIT.PHP
Scala - FB.PL.JIT.Scala
Groovy - FB.PL.JIT.Groovy
Clojure - FB.PL.JIT.Clojure
Julia - FB.PL.JIT.Julia

AOT Languages

Language Dependency Namespace
WebAssembly - FB.PL.AOT.WebAssembly
Assembly - FB.PL.AOT.Assembly
MIPS - FB.PL.AOT.MIPS
C - FB.PL.AOT.C
C++ - FB.PL.AOT.CPP
C# .NET FB.PL.AOT.CSharp
VB.NET .NET FB.PL.AOT.VBNET
Java JVM FB.PL.AOT.Java
Kotlin - FB.PL.AOT.Kotlin
Go - FB.PL.AOT.Go
Rust - FB.PL.AOT.Rust
Dart - FB.PL.AOT.Dart

16.2 Library Packaging

Library Type Description Namespace
JAR Java Archive FB.PL.Library.Dynamic.JAR
SO Unix/Linux shared object FB.PL.Library.Dynamic.SO
DLL Managed dynamic library FB.PL.Library.Dynamic.DLL
DLL.Unmanaged Unmanaged dynamic library FB.PL.Library.Dynamic.DLL.Unmanaged
DyLib MacOS dynamic library FB.PL.Library.Dynamic.DyLib
Bundle MacOS bundle dynamic library FB.PL.Library.Dynamic.Bundle

16.3 IT DSLs and Markup Languages

DSL / Language Category Namespace
SQL Database query language FB.DSL.IT.SQL
GraphQL Query language FB.DSL.IT.GraphQL
SPARQL RDF query language FB.DSL.IT.SPARQL
Markdown Lightweight document formatting FB.DSL.IT.Markdown
Latex Document formatting FB.DSL.IT.Latex
Regex Regular expression FB.DSL.IT.Regex
HTML Web layout description FB.DSL.IT.HTML
CSS Web style description FB.DSL.IT.CSS
LESS Web style preprocessor FB.DSL.IT.LESS
SCSS Web style preprocessor FB.DSL.IT.SCSS
Gherkin Test description language FB.DSL.IT.Gherkin
Website-spec Web test description FB.DSL.IT.WebsiteSpec
BPEL Business process modeling FB.DSL.IT.BPEL
ANTLR Syntax tree parser language FB.DSL.IT.ANTLR
DOT Graph description language FB.DSL.IT.DOT
OCL Constraint language FB.DSL.IT.OCL
XPath XML indexing language FB.DSL.IT.XPath
XML Markup FB.Markup.XML
JSON Markup FB.Markup.JSON
YAML Markup FB.Markup.YAML
TOML Markup FB.Markup.TOML
INI Markup FB.Markup.INI
Sed Text transformation script FB.DSL.IT.Sed
Gawk Text processing script FB.DSL.IT.Gawk
Apache Thrift RPC interface description FB.DSL.IT.Thrift
Protobuf RPC interface description FB.DSL.IT.Protobuf
Webpack Build language FB.DSL.IT.Webpack
Make Build language FB.DSL.IT.Make
Dockerfile CI/CD FB.DSL.IT.Dockerfile
Jenkinsfile CI/CD FB.DSL.IT.Jenkinsfile
GLSL 3D modeling / shader language FB.DSL.IT.GLSL
SCORM LMS course packaging FB.DSL.IT.SCORM

16.4 OT DSLs

DSL Namespace
Structured Text FB.DSL.OT.PLC.IEC61131.ST
Verilog HDL FB.DSL.OT.EDA.VerilogHDL
VHDL FB.DSL.OT.EDA.VHDL
SystemVerilog FB.DSL.OT.EDA.SystemVerilog
G-Code FB.DSL.OT.CAD.GCode

16.5 Graphical Languages

Graphical Language Namespace
Flow Chart FB.Graphical.FlowChart
BPMN FB.Graphical.BPMN
UML FB.Graphical.UML
SysML FB.Graphical.SysML
IEC61131-3 SFC FB.Graphical.IEC61131.SFC
IEC61131-3 LD FB.Graphical.IEC61131.LD
IEC61131-3 FBD FB.Graphical.IEC61131.FBD
Data Flow FB.Graphical.DataFlow
Behavior Tree FB.Graphical.BehaviorTree
Blockly FB.Graphical.Blockly

These graphical languages may work with FBs through widget plugins and port mappings. Textual representation and escaping should be completed before integration.

16.6 Atomic Robot Behavior Examples

Robot Instruction Namespace
MoveLinear FB.AtomicBehavior.Robot.MoveLinear
MoveJoint FB.AtomicBehavior.Robot.MoveJoint
MoveCircular FB.AtomicBehavior.Robot.MoveCircular
MoveToHome FB.AtomicBehavior.Robot.MoveToHome
Jog FB.AtomicBehavior.Robot.Jog
GetTCPPosition FB.AtomicBehavior.Robot.GetTCPPosition
GetJointPosition FB.AtomicBehavior.Robot.GetJointPosition
GetRobotState FB.AtomicBehavior.Robot.GetRobotState
GetErrorCode FB.AtomicBehavior.Robot.GetErrorCode
SetSpeed FB.AtomicBehavior.Robot.SetSpeed
SetAcceleration FB.AtomicBehavior.Robot.SetAcceleration
SetPayload FB.AtomicBehavior.Robot.SetPayload
SetCoordinateSystem FB.AtomicBehavior.Robot.SetCoordinateSystem
SetTool FB.AtomicBehavior.Robot.SetTool
Pause FB.AtomicBehavior.Robot.Pause
Resume FB.AtomicBehavior.Robot.Resume
Stop FB.AtomicBehavior.Robot.Stop
EmergencyStop FB.AtomicBehavior.Robot.EmergencyStop
Reset FB.AtomicBehavior.Robot.Reset

17. Appendix D — Type Mapping Tables

This appendix consolidates type-mapping examples between the CREEM Inherited Type Tree and major external type systems. These tables are non-normative and serve as engineering reference for connectors and runtime adapters.

17.1 CREEM Inherited Type Tree — Overview

The full inherited type tree is rooted at Any and contains the major branches shown below (selected, illustrative):

Any
├── String
│   ├── URI, Namespace, Markup, StatusString, Expression
│   ├── XML, JSON, XSD, …
│   └── File
├── Numeral
│   ├── Integer (UInt8, UInt16, UInt32, UInt64, StatusCode, …)
│   └── Float, Double
├── Boolean
├── Enum
├── Struct
│   ├── DateTime (Timestamp, …)
│   ├── Matrix
│   ├── Position, Orientation, Vector2, …
│   └── …
├── Array
└── Reference (Ref → ResourceRef, ParameterRef, …)

Selected standards followed by elementary types:

Element Type Definition Standard Followed Scope Description
Unit (unit attribute) Engineering Unit UN/ECE Recommendation No. 20 Rev. 17 Measurement units Parameter engineering units shall use internationally standardized unit symbols
StatusCode UInt32 derived type OPC UA / IEC 62541 Industrial status coding Unified industrial execution status representation
StatusString String subtype OPC UA Information Model Human-readable state Textual status description
Language Code Language code ISO 639 / ISO 3166 Language code e.g. en-GB, en-US, de-DE, de-AT, de-CH
Encoding Encoding WHATWG Encoding Standard Text encoding —
URI String subtype WHATWG URL Standard Resource addressing Uniform resource identification
UUID / GUID Identifier RFC 4122 Global identification Unique object identification
Expression / Regex Expression type W3C Regex Validation rule Parameter constraint definition

17.2 OPC UA → CREEM

OPC UA Category OPC UA Type Semantic Meaning Target CREEM Type Target CREEM Root Mapping Rule Notes
Built-in DataType Boolean Logical true/false Boolean Any → Boolean Direct No unit allowed
Built-in DataType SByte / Byte 8-bit signed/unsigned Int8 / UInt8 Numerical Bit-width preserved Respect signedness
Built-in DataType Int16 / UInt16 16-bit integer Int16 / UInt16 Numerical Direct —
Built-in DataType Int32 / UInt32 32-bit integer Int32 / UInt32 Numerical Direct —
Built-in DataType Int64 / UInt64 64-bit integer Int64 / UInt64 Numerical Direct —
Built-in DataType Float 32-bit float Float32 Numerical Direct IEEE 754
Built-in DataType Double 64-bit float Float64 Numerical Direct IEEE 754
Built-in DataType Decimal High-precision decimal Decimal Numerical Direct Financial / precise calc
Built-in DataType String UTF-8 string String String Direct Apply maxLength if defined
Built-in DataType ByteString Binary blob Binary String Encapsulated as Base64 If structured → Structure
Built-in DataType DateTime UTC timestamp DateTime Numerical Normalize to ISO 8601 See metaDateTime
Built-in DataType Guid Globally unique id UUID String Direct Canonical string form
Built-in DataType XmlElement XML content Structure Structure Parse to structured object Not raw string
Built-in DataType NodeId Address of node Reference Reference Convert to namespace-based reference Semantic link
Built-in DataType ExpandedNodeId Global NodeId Reference Reference Map to global namespace ref —
Built-in DataType QualifiedName (namespace, name) String or StructuredName Structure Decompose fields —
Built-in DataType LocalizedText Text + locale LocalizedString Structure Map to UIInformation segment Decoupled from Data
Enumeration Custom Enum Named integer constants EnumType Enum Preserve symbolic name Numeric base retained
Structured DataType Structure Composite fields StructType Structure Field-by-field recursive Nested allowed
Structured DataType Union One-of structure UnionType Structure Tagged union Explicit discriminator
Structured DataType OptionSet Bitmask flags EnumSet / BitMask Enum Map to flag-based enum —
VariableType BaseVariableType Typed variable Parameter Depends on DataType Map DataType first —
ObjectType BaseObjectType Structured object Resource Description (RD) Structure Map properties to Parameters Behavior separated
Method UA Method Callable function Function Block (FB) Behavior Inputs/Outputs → Parameters Behavior abstraction
ReferenceType HasComponent Structural reference Reference Reference Map to Resource Tree weak relation —
ReferenceType HasProperty Attribute binding Parameter Binding Reference Parameter association —
ReferenceType Organizes Folder grouping Resource Tree hierarchy Reference Weak hierarchical mapping —
DataType Dictionary Custom DataType User-defined types Custom Subtype Corresponding subtree Register in Type Tree Extendable

17.3 IEC 61131-3 → CREEM

IEC 61131-3 Type Semantic Meaning Target CREEM Type Target CREEM Root Mapping Rule Notes
BOOL Boolean Boolean Any → Boolean Direct No unit allowed
SINT 8-bit signed Int8 Numerical Preserve bit width Respect signedness
USINT 8-bit unsigned UInt8 Numerical Preserve bit width —
INT 16-bit signed Int16 Numerical Direct —
UINT 16-bit unsigned UInt16 Numerical Direct —
DINT 32-bit signed Int32 Numerical Direct IEEE 754
UDINT 32-bit unsigned UInt32 Numerical Direct IEEE 754
LINT 64-bit signed Int64 Numerical Direct Financial / precise calc
ULINT 64-bit unsigned UInt64 Numerical Direct Apply maxLength if defined
REAL 32-bit float Float32 Numerical IEEE 754 If structured → Structure
LREAL 64-bit float Float64 Numerical IEEE 754 See metaDateTime
BYTE 8-bit bitstring BitString8 Numerical Bit-level subtype Canonical string format
WORD 16-bit bitstring BitString16 Numerical — Not raw string
DWORD 32-bit bitstring BitString32 Numerical — Semantic link
LWORD 64-bit bitstring BitString64 Numerical — —
CHAR Single character Char String UTF normalized —
STRING Variable-length string String String Preserve max length Decoupled from Data
WSTRING Wide string String String Unicode normalized Numeric base retained

17.4 C → CREEM

C Type Semantic Meaning Target CREEM Type Target CREEM Root Mapping Rule Notes
_Bool / bool Boolean Boolean Any → Boolean Direct stdbool.h
char 8-bit integer / char Int8 or Char Numerical / String Context-sensitive Signedness implementation-defined
signed char 8-bit signed Int8 Numerical Preserve signedness —
unsigned char 8-bit unsigned UInt8 Numerical Direct —
short ≥16-bit signed Int16 Numerical Normalize to 16-bit Platform normalization required
unsigned short ≥16-bit unsigned UInt16 Numerical — —
int ≥16-bit signed Int32 Numerical Normalize to 32-bit Implementation-defined size
unsigned int ≥16-bit unsigned UInt32 Numerical — —
long ≥32-bit signed Int32 / Int64 Numerical Platform-dependent LP64 vs LLP64
unsigned long ≥32-bit unsigned UInt32 / UInt64 Numerical — —
long long ≥64-bit signed Int64 Numerical Direct —
unsigned long long ≥64-bit unsigned UInt64 Numerical — —
float 32-bit IEEE Float32 Numerical Direct —
double 64-bit IEEE Float64 Numerical Direct —
long double Extended precision Float128 / ExtendedFloat Numerical Preserve precision Platform-specific
void No value VoidType Any — —
NULL Null pointer NullRef Reference — —
Pointer T* Memory reference Reference Reference Typed reference mapping —
Array T[n] Fixed-size array List (bounded) Structure Preserve dimension —
Flexible array Variable-length List Structure Dynamic size —
struct Composite record StructType Structure Field recursion —
union Variant record UnionType Structure Tagged union required —
enum Integer enumeration EnumType Enum Preserve constants —
typedef Type alias TypeRef Reference Direct alias mapping —
Function pointer Callable reference FBRef Reference Bind to FB —

17.5 Python → CREEM

Python Construct Semantic Meaning Target CREEM Type Target CREEM Root Mapping Rule Notes
bool Boolean Boolean Any → Boolean Direct Subclass of int in Python
int Arbitrary precision integer Int64 / BigInt Numerical If ≤64 bit → Int64, else BigInt Python unbounded
float 64-bit IEEE float Float64 Numerical Direct CPython double precision
complex Complex number ComplexType Numerical Represent as struct (real, imag) No native primitive
str Unicode string String String Direct UTF-8 normalized
bytes Immutable byte sequence Binary String Base64 representation —
bytearray Mutable bytes Binary String Mutable flag —
None Null object NullType Any Nullable modifier Singleton
list Ordered mutable sequence List Structure Homogeneous inference Dynamic typing requires analysis
tuple Immutable sequence Struct (ordered) Structure Index-preserving Fixed-length tuple
set Unordered unique collection Set Structure Unique constraint Hash-based
frozenset Immutable set Immutable Set Structure Add immutable flag —
dict Key–value mapping Map<K,V> Structure Key & value type inference JSON-compatible
range Integer sequence RangeType Numerical Represent as (start, stop, step) Lazy sequence
enum.Enum Enumeration class EnumType Enum Preserve symbolic names Must resolve values
dataclass Structured record RD Structure Field mapping Behavior separated
module Namespace unit Repository Reference Flatten to namespace Organizational only
import Reference binding Reference Reference Namespace resolution —
typing.Optional[T] Nullable type T + nullable flag Any Modifier mapping —
typing.Union[A, B] Union type UnionType Structure Tagged union Explicit discriminator
typing.List[T] Typed list List Structure Generic instantiation first —
typing.Dict[K, V] Typed map Map<K,V> Structure — —
typing.Tuple[...] Typed tuple Struct Structure Field order preserved —
typing.Any Dynamic type AnyType Any Requires runtime typing Not recommended in strict mode
typing.Protocol Structural contract InterfaceType Structure Expand structural fields Compile-time only
property decorator Getter / setter binding Parameter + FB Structure + Behavior Separate accessors —
__init__ Constructor FB (Initialization) Behavior Bound to RD lifecycle —
__call__ Callable object FB Behavior Map to execution method —
__iter__ / __next__ Iterator protocol FB Behavior Streaming interface —
Global variable Module-level state RD node Structure Namespace-bound —
Mutable object reference Object identity Reference<T> Reference ID-based reference No raw memory address

18. Appendix E — Atomic Behavior Namespace Catalog

This appendix lists representative atomic and composite behaviors organized by domain. All entries are non-normative reference examples; each Function Block follows the CREEM FB structure defined in chapter 9 and uses the FB.AtomicBehavior.* or FB.CompositeBehavior.* namespace prefixes from chapter 11.

18.1 Devices ID Namespace (Sample)

Category Namespace
PC Controller RD.Controller.PC.*
IPC RD.Controller.PC.IPC.*
Server RD.Controller.PC.Server.*
Workstation RD.Controller.PC.Workstation.*
Embedded Controller RD.Controller.Embedded.*
SBC RD.Controller.Embedded.SBC.*
Single Chip RD.Controller.Embedded.SC.*
Network Device RD.Device.NetworkDevice.*
Router RD.Device.NetworkDevice.Router.*
Switch RD.Device.NetworkDevice.Switch.*
Firewall RD.Device.NetworkDevice.Firewall.*
5G RD.Device.NetworkDevice.5G.*
PLC RD.Controller.PLC.*
SoftPLC RD.Controller.PLC.SoftPLC.*
DCS RD.Controller.DCS.*
HMI RD.Device.HMI.*
IO RD.Device.IO.*
Robot RD.Robot.*
Industrial Robot RD.Robot.IndustrialRobot.*
Cobot RD.Robot.Cobot.*
End Effector RD.Robot.EndEffector.*
Gripper RD.Robot.EndEffector.Gripper.*
ToolChanger RD.Robot.EndEffector.ToolChanger.*
TorqueWrench RD.Robot.EndEffector.TorqueWrench.*
Industrial Camera RD.Detection.Camera.Industrial.*
Camera RD.Detection.Camera.*
AGV RD.Logistics.AGV.*
Forklift RD.Logistics.Forklift.*
CNC RD.MachineTool.CNC.*
3D Printer RD.MachineTool.3DPrinter.*
Scanner RD.Detection.Scanner.*
QRCode RD.Detection.Scanner.QRCode.*
RFID RD.Detection.Scanner.RFID.*
PDA RD.Detection.Scanner.PDA.*
SmartPhone RD.Device.ConsumerElectronics.SmartPhone.*
Tablet RD.Device.ConsumerElectronics.Tablet.*
Smart Wearable RD.Device.ConsumerElectronics.SmartWearable.*
Drone RD.Device.Drone.*
Sensor RD.Sensor.*
Workstation RD.Workstation.*
IoT Cloud Device RD.Controller.IoT.Cloud.*
Non-Standard RD.Device.NonStandard.*

Only device types with active behavioral capabilities are included.

18.2 IT Communication Protocols (Selection)

Protocol Description Namespace
HTTP Hypertext Transfer Protocol RD.Protocol.General.HTTP
HTTPS Secure HTTP RD.Protocol.General.HTTPS
REST REST API style RD.Protocol.General.HTTP.REST
OpenAPI REST API description RD.Protocol.General.HTTP.REST.OpenAPI
OData REST data service RD.Protocol.General.HTTP.REST.OData
GraphQL Query language for APIs RD.Protocol.General.HTTP.GraphQL
SSE Server-Sent Events RD.Protocol.General.HTTP.SSE
HTTP/2 Binary HTTP RD.Protocol.General.HTTP2
HTTP/3 QUIC-based HTTP RD.Protocol.General.HTTP3
MQTT Messaging RD.Protocol.General.MQTT
AMQP Messaging RD.Protocol.General.AMQP
Kafka Messaging RD.Protocol.General.Kafka
WebSocket Full-duplex RD.Protocol.General.WebSocket
gRPC RPC RD.Protocol.General.RPC.gRPC
JSON-RPC RPC RD.Protocol.General.RPC.JSONRPC
XML-RPC RPC RD.Protocol.General.RPC.XMLRPC
SOAP Messaging / middleware RD.Protocol.General.SOAP
DDS Messaging / middleware RD.Protocol.General.DDS
ZeroMQ Messaging / middleware RD.Protocol.General.ZeroMQ
Redis Pub/Sub Messaging / middleware RD.Protocol.General.Redis
NATS Messaging / middleware RD.Protocol.General.NATS
CoAP IoT RD.Protocol.General.CoAP
WebRTC DataChannel Real-time communication RD.Protocol.General.WebRTC
FTP File transfer RD.Protocol.General.FTP
SFTP File transfer RD.Protocol.General.SFTP
SMB File transfer RD.Protocol.General.SMB
WebDAV File transfer RD.Protocol.General.WebDAV
SNMP Network management RD.Protocol.General.SNMP
LDAP Directory service RD.Protocol.General.LDAP
OAuth2 Security RD.Protocol.General.Security.OAuth2
OIDC Security RD.Protocol.General.Security.OIDC
TLS Transport security RD.Protocol.General.Security.TLS
QUIC Transport RD.Protocol.General.QUIC
MCP Model Context Protocol RD.Protocol.General.AI.MCP
AI Agent RPC Agent-to-agent RD.Protocol.General.AI.AgentRPC

18.3 OT Industrial Ethernet / Field Bus (Selection)

Protocol Description Namespace
PROFINET Automation RD.Protocol.OT.Profinet
PROFIBUS Automation RD.Protocol.OT.Profibus
EtherNet/IP CIP family RD.Protocol.OT.EtherNetIP
DeviceNet CIP family RD.Protocol.OT.DeviceNet
ControlNet CIP family RD.Protocol.OT.ControlNet
EtherCAT Real-time Ethernet RD.Protocol.OT.EtherCAT
POWERLINK Real-time Ethernet RD.Protocol.OT.Powerlink
SERCOS Real-time Ethernet RD.Protocol.OT.SERCOS
MECHATROLINK Real-time Ethernet RD.Protocol.OT.Mechatrolink
VARAN Real-time Ethernet RD.Protocol.OT.VARAN
FL-net Real-time Ethernet RD.Protocol.OT.FLnet
CANopen Controller-level RD.Protocol.OT.CANopen
CC-Link Controller-level RD.Protocol.OT.CCLink
CC-Link IE Controller-level RD.Protocol.OT.CCLinkIE
Modbus RTU Industrial communication RD.Protocol.OT.ModbusRTU
Modbus TCP Industrial communication RD.Protocol.OT.ModbusTCP
INTERBUS Field-level RD.Protocol.OT.INTERBUS
AS-i Field-level RD.Protocol.OT.ASI
HART Field-level RD.Protocol.OT.HART
FOUNDATION Fieldbus Field-level RD.Protocol.OT.FoundationFieldbus
IO-Link Field-level RD.Protocol.OT.IOLink
OPC UA Service-oriented RD.Protocol.OT.OPCUA
OPC UA PubSub Service-oriented RD.Protocol.OT.OPCUA.PubSub
DDS Service-oriented RD.Protocol.OT.DDS
TSN Service-oriented RD.Protocol.OT.TSN
SECS Semiconductor RD.Protocol.OT.SECS
GEM Semiconductor RD.Protocol.OT.GEM

18.4 GPL (General Programming Languages)

Category Namespace
AOT — WebAssembly FB.GPL.AOT.WebAssembly
AOT — Assembly FB.GPL.AOT.Assembly
AOT — MIPS FB.GPL.AOT.MIPS
AOT — C FB.GPL.AOT.C
AOT — C++ FB.GPL.AOT.CPP
AOT — C# FB.GPL.AOT.CSharp
AOT — VB.NET FB.GPL.AOT.VBNET
AOT — Java FB.GPL.AOT.Java
AOT — Kotlin FB.GPL.AOT.Kotlin
AOT — Go FB.GPL.AOT.Go
AOT — Rust FB.GPL.AOT.Rust
AOT — Dart FB.GPL.AOT.Dart
JIT — Python FB.GPL.JIT.Python
JIT — JavaScript FB.GPL.JIT.JavaScript
JIT — TypeScript FB.GPL.JIT.TypeScript
JIT — Shell FB.GPL.JIT.Shell
JIT — Bat FB.GPL.JIT.Bat
JIT — PowerShell FB.GPL.JIT.PowerShell
JIT — Perl FB.GPL.JIT.Perl
JIT — Lua FB.GPL.JIT.Lua
JIT — Ruby FB.GPL.JIT.Ruby
JIT — PHP FB.GPL.JIT.PHP
JIT — Scala FB.GPL.JIT.Scala
JIT — Groovy FB.GPL.JIT.Groovy
JIT — Clojure FB.GPL.JIT.Clojure
Library — JAR FB.GPL.Library.Dynamic.JAR
Library — SO FB.GPL.Library.Dynamic.SO
Library — DLL FB.GPL.Library.Dynamic.DLL
Library — DLL (unmanaged) FB.GPL.Library.Dynamic.DLL.Unmanaged
Library — DyLib FB.GPL.Library.Dynamic.DyLib
Library — Bundle FB.GPL.Library.Dynamic.Bundle
Graphical — BPMN2 FB.GPL.Graphical.BPMN2
Graphical — Google Blockly FB.GPL.Graphical.Blockly
Graphical — Behavior Tree FB.GPL.Graphical.BehaviorTree

18.5 DSL Namespaces (Selection)

OT DSLs

DSL Namespace
Structured Text FB.DSL.OT.PLC.IEC61131.ST
Verilog HDL FB.DSL.OT.EDA.VerilogHDL
VHDL FB.DSL.OT.EDA.VHDL
SystemVerilog FB.DSL.OT.EDA.SystemVerilog
G-Code (ISO 6983) FB.DSL.OT.CNC.GCode
STEP-NC (ISO 14649) FB.DSL.OT.CNC.StepNC
CAEX FB.DSL.OT.Engineering.CAEX
PLCopen XML FB.DSL.OT.Engineering.PLCopen
EDDL FB.DSL.OT.Device.EDDL
FDT-DTM FB.DSL.OT.Device.FDT
IO-Link IODD FB.DSL.OT.Device.IOLink
ISA-88 Recipe FB.DSL.OT.Process.Recipe
Batch DSL FB.DSL.OT.Process.Batch
EtherCAT ENI FB.DSL.OT.Fieldbus.EtherCAT.ENI
PROFINET GSDML FB.DSL.OT.Fieldbus.Profinet.GSDXML
WinCC Script FB.DSL.OT.SCADA.WinCCScript
URScript FB.DSL.OT.RobotScript.URScript
KRL FB.DSL.OT.RobotScript.KRL
RAPID FB.DSL.OT.RobotScript.RAPID
INFORM FB.DSL.OT.RobotScript.INFORM
AS FB.DSL.OT.RobotScript.AS
Karel FB.DSL.OT.RobotScript.Karel
PDL2 FB.DSL.OT.RobotScript.PDL2
VAL3 FB.DSL.OT.RobotScript.VAL3

IT DSLs

DSL Namespace
SQL FB.DSL.IT.SQL
GraphQL FB.DSL.IT.GraphQL
SPARQL FB.DSL.IT.SPARQL
Markdown FB.DSL.IT.Markdown
Latex FB.DSL.IT.Latex
Regex FB.DSL.IT.Regex
HTML FB.DSL.IT.HTML
Dockerfile FB.DSL.IT.Dockerfile
ANTLR FB.DSL.IT.ANTLR
Gherkin FB.DSL.IT.Gherkin
Website-spec FB.DSL.IT.WebsiteSpec
BPEL FB.DSL.IT.BPEL
BPMN FB.DSL.IT.Workflow.BPMN
DMN FB.DSL.IT.Workflow.DMN
HCL (Terraform) FB.DSL.IT.Infrastructure.HCL
Kubernetes YAML FB.DSL.IT.Infrastructure.K8s
Helm FB.DSL.IT.Infrastructure.Helm
OPA Rego FB.DSL.IT.Security.Policy
Access Control DSL FB.DSL.IT.Security.Access
CloudEvents FB.DSL.IT.Event.CloudEvents
Stream Processing FB.DSL.IT.Stream
AI Prompt DSL FB.DSL.IT.AI.Prompt
AI Tool Schema FB.DSL.IT.AI.Tool
Agent Workflow DSL FB.DSL.IT.AI.AgentWorkflow
SCORM FB.DSL.IT.SCORM

18.6 IT — GitHub Atomic Behaviors (Sample)

Namespace: FB.AtomicBehavior.GitHub

# Atomic Behavior Description
1 AuthenticateUser Authenticate user via credential or token
2 CreateRepository Create a new repository
3 DeleteRepository Delete repository
4 ForkRepository Fork repository to another namespace
5 CloneRepository Clone repository locally
6 PullRepository Pull latest remote changes
7 PushRepository Push local commits to remote
8 CreateBranch Create new branch
9 DeleteBranch Delete branch
10 SwitchBranch Checkout or switch branch
11 MergeBranch Merge branch into target branch
12 RebaseBranch Rebase branch history
13 CommitChanges Commit staged file changes
14 StageFile Stage file for commit
15 UnstageFile Remove file from staging
16 ViewDiff View file or commit differences
17 CreatePullRequest Create pull request
18 ReviewPullRequest Review pull request
19 ApprovePullRequest Approve pull request
20 RejectPullRequest Request changes on pull request
21 MergePullRequest Merge approved pull request
22 ClosePullRequest Close pull request without merge
23 CreateIssue Create issue ticket
24 UpdateIssue Update issue content or status
25 CloseIssue Close issue
26 AssignIssue Assign issue to contributor
27 Comment Add comment to issue or PR
28 ManageAccess Grant or revoke repository access
29 CreateRelease Create software release
30 TagVersion Create version tag
31 TriggerWorkflow Trigger GitHub Actions workflow
32 ExecuteWorkflow Execute CI/CD workflow
33 CancelWorkflow Cancel running workflow
34 UploadArtifact Upload workflow artifact
35 DownloadArtifact Download artifact
36 ConfigureWebhook Configure webhook integration
37 ReceiveWebhookEvent Receive external webhook event
38 AuditLogQuery Query audit or activity log
39 RepositoryStatus Retrieve repository status

18.7 IT — Spreadsheet Atomic Behaviors (Sample)

Namespace: FB.AtomicBehavior.Spreadsheet

# Atomic Behavior Description
1 CreateWorkbook Create new spreadsheet workbook
2 OpenWorkbook Open existing workbook
3 SaveWorkbook Save workbook state
4 CloseWorkbook Close workbook
5 CreateSheet Create worksheet
6 DeleteSheet Delete worksheet
7 RenameSheet Rename worksheet
8 CopySheet Duplicate worksheet
9 SelectSheet Activate worksheet
10 ReadCell Read cell value
11 WriteCell Write value to cell
12 ClearCell Clear cell content
13 ReadRange Read cell range
14 WriteRange Write values to cell range
15 InsertRow / DeleteRow Insert / delete row
17 InsertColumn / DeleteColumn Insert / delete column
19 SortRange / FilterRange Sort / filter data range
21 ApplyFormula / EvaluateFormula / RecalculateWorkbook Formula operations
24 FormatCell / MergeCells / UnmergeCells Cell formatting
27 CreateTable / UpdateTable Structured-table operations
29 CreateChart / UpdateChart / DeleteChart Chart operations
32 ImportData / ExportData / RefreshDataConnection Data exchange
35 ProtectSheet / UnprotectSheet / ShareWorkbook / TrackChange Sharing & protection
39 UndoOperation / RedoOperation / QueryWorkbookStatus Misc.

18.8 OT — PLC Atomic Behaviors (IEC 61131-3 / 61131-2 / 61508)

Namespace prefix: FB.AtomicBehavior.PLC.<Domain>.<Action>

# Atomic Behavior Functional Domain
1–3 PowerOn / PowerOff / RestartController PowerSystem
4–7 EnterRunMode / EnterStopMode / EnterProgramMode / ResetController OperationMode
8 ExecuteScanCycle Runtime
9–13 ReadDigitalInput / ReadAnalogInput / WriteDigitalOutput / WriteAnalogOutput / UpdateIOImage IOAccess
14–18 ReadFieldbusData / WriteFieldbusData / EstablishConnection / CloseConnection / SynchronizeTime Communication
19–24 ExecuteFunctionBlock / ExecuteFunction / EvaluateLogic / UpdateVariable / ReadVariable / WriteVariable ProgramExecution
25–30 StartTask / StopTask / PauseTask / ResumeTask / ScheduleCyclicTask / ScheduleEventTask TaskManagement
31–35 DetectFault / ResetFault / SelfCheck / MonitorWatchdog / LogEvent Diagnostics
36–40 BackupProgram / RestoreProgram / DownloadProgram / UploadProgram / UpdateFirmware Maintenance
41–46 EnableSafetyMode / DisableSafetyMode / ExecuteSafetyLogic / SafeOutputOff / EmergencyStopHandling / MonitorSafetyInput Safety
47–50 PublishData / SubscribeData / BufferData / ClearDataBuffer DataExchange

18.9 OT — CNC Atomic Behaviors

Namespace: FB.AtomicBehavior.CNC

# Atomic Behavior Description
1–5 PowerOn / PowerOff / Initialize / Reset / EmergencyStop System control
6–11 StartProgram / PauseProgram / ResumeProgram / StopProgram / LoadProgram / SelectProgram Program control
12–16 HomeAxis / JogAxis / MoveRapid / MoveLinear / MoveCircular Axis motion
17–18 SetFeedRate / OverrideFeedRate Feed control
19–22 SetSpindleSpeed / SpindleOn / SpindleOff / SpindleOrient Spindle control
23–26 ChangeTool / SelectTool / MeasureToolLength / ToolWearCompensation Tool management
27–29 SetWorkOffset / ClampWorkpiece / UnclampWorkpiece Workpiece setup
30–31 CoolantOn / CoolantOff Coolant
32–36 ProbeMeasurement / Dwell / ExecuteMDI / AlarmAcknowledge / StatusReport Misc.

18.10 OT — AGV/AMR Atomic Behaviors (ISO 3691-4 / ISO 8373 / IEC 61508 / IEEE 1872)

Namespace prefix: FB.AtomicBehavior.AGV.<Domain>.<Action>

# Atomic Behavior Functional Domain
1–10 SetWheelVelocity / SetWheelTorque / StopWheel / EnableDrive / DisableDrive / SetSteeringAngle / LockBrake / ReleaseBrake / SetAcceleration / SetDeceleration DriveControl
11–20 MoveLinear / RotateInPlace / FollowPathSegment / StopMotion / HoldPosition / ResumeMotion / DockToStation / UndockFromStation / AdjustHeading / LocalizePose Navigation
21–30 ReadWheelEncoder / ReadIMU / ReadLidar / ReadUltrasonic / ReadCamera / DetectObstacle / DetectHuman / DetectZoneIntrusion / MeasureDistance / UpdateMapSegment Sensing
31–38 LiftLoad / LowerLoad / ExtendFork / RetractFork / ClampLoad / ReleaseLoad / MeasureLoadWeight / VerifyLoadPresence LoadHandling
39–46 EmergencyStop / SafeTorqueOff / EnterSafeState / ExitSafeState / ReduceSpeedZone / MonitorSafetyScanner / FaultReset / SelfCheck Safety
47–54 PowerOn / PowerOff / EnterStandby / ExitStandby / ChargeBattery / StopCharging / ReportBatteryStatus / MonitorSystemHealth PowerSystem
55–60 SendStatus / ReceiveCommand / AcknowledgeCommand / ReportPosition / ReportError / SyncFleetTime Communication
61–65 StartTask / StopTask / PauseTask / ResumeTask / LogEvent TaskExecution

18.11 OT — Torque Wrench Atomic Behaviors (ISO 6789 / ISO 5393 / IEC 62841)

Namespace prefix: FB.AtomicBehavior.TorqueWrench.<Domain>.<Action>

# Atomic Behavior Functional Domain
1–4 SetTargetTorque / SetTargetAngle / SetTorqueLimit / SetSpeed TorqueControl
5–9 EnableTool / DisableTool / StartRotation / StopRotation / ReverseRotation ToolControl
10–12 ApplyTorque / HoldTorque / ReleaseTorque TorqueExecution
13–17 MonitorTorque / MonitorAngle / MonitorSpeed / DetectTorqueReached / DetectAngleReached Sensing
18–22 DetectOverTorque / DetectStall / EmergencyStop / EnterSafeState / ExitSafeState Safety
23–24 CalibrateTorqueSensor / ZeroAngleSensor Calibration
25–26 SelfCheck / FaultReset Diagnostics
27–28 LogTighteningResult / StoreTighteningCurve DataHandling
29–32 ReportResult / ReceiveParameterSet / AcknowledgeCommand / SynchronizeTime Communication
33–39 PowerOn / PowerOff / EnterStandby / ExitStandby / MonitorBatteryStatus / ChargeBattery / StopCharging PowerSystem
40 UpdateFirmware Maintenance

18.12 OT — Industrial Camera Atomic Behaviors (EMVA 1288 / IEC 62676 / ISO 10360)

Namespace prefix: FB.AtomicBehavior.IndustrialCamera.<Domain>.<Action>

# Atomic Behavior Functional Domain
1–5 PowerOn / PowerOff / EnterStandby / ExitStandby / ResetDevice PowerSystem
6–14 SetExposureTime / SetGain / SetFrameRate / SetResolution / SetPixelFormat / EnableAutoExposure / DisableAutoExposure / EnableAutoWhiteBalance / DisableAutoWhiteBalance AcquisitionControl
15–18 SetTriggerMode / EnableTrigger / DisableTrigger / SendSoftwareTrigger TriggerControl
19–24 CaptureImage / CaptureBurst / StartContinuousAcquisition / StopContinuousAcquisition / ReadImageBuffer / ClearImageBuffer ImageAcquisition
25–32 SetRegionOfInterest / ApplyImageFilter / ConvertPixelFormat / AdjustBrightness / AdjustContrast / DetectEdge / DetectBlob / DetectPattern ImageProcessing
33–35 MeasureDistance / MeasureDimension / MeasureAngle Metrology
36–39 CalibrateIntrinsic / CalibrateExtrinsic / LoadCalibrationProfile / SaveCalibrationProfile Calibration
40–44 MonitorTemperature / MonitorSensorHealth / SelfCheck / FaultReset / LogEvent Diagnostics
45–49 SendImage / SendMeasurementResult / ReceiveParameterSet / AcknowledgeCommand / SynchronizeTime Communication
50 UpdateFirmware Maintenance

18.13 OT — Humanoid Atomic Behaviors (ISO 8373 / ISO 10218-1 / ISO 13482 / IEEE 1872)

Namespace prefix: FB.AtomicBehavior.Humanoid.<Domain>.<Action>

# Atomic Behavior Functional Domain
1–9 SetJointPosition / SetJointVelocity / SetJointTorque / StopJointMotion / EnableJoint / DisableJoint / CalibrateJoint / LockJoint / UnlockJoint JointControl
10–19 MoveLinear / MoveJointSpace / MoveToPose / SetEndEffectorVelocity / StopMotion / HoldPose / CompliantMove / ForceControlledMove / AdmittanceControl / ImpedanceControl CartesianMotion
20–30 ShiftCenterOfMass / StabilizePosture / StepForward / StepBackward / StepLeft / StepRight / TurnLeft / TurnRight / AdjustFootPlacement / RecoverBalance / FreezeMotion Locomotion
31–40 OpenGripper / CloseGripper / SetGripForce / ReleaseObject / PreShapeHand / AlignToObject / ApplyForce / RemoveForce / ContactDetect / MaintainContact Manipulation
41–45 RotateHead / TiltHead / SetGazeTarget / TrackTarget / StopTracking GazeControl
46–55 CaptureImage / CaptureDepthFrame / ReadForceSensor / ReadTorqueSensor / ReadIMU / ReadJointState / ReadMicrophone / DetectContact / DetectProximity / DetectHumanPresence Sensing
56–63 SpeakText / StopSpeaking / PlayAudio / StopAudio / DisplayText / DisplayImage / EmitSignal / ReceiveSignal Communication
64–70 EmergencyStop / SafeTorqueOff / EnterSafeState / ExitSafeState / SelfCheck / FaultReset / MonitorSafetyZone Safety
71–79 PowerOn / PowerOff / RestartSystem / EnterStandby / ExitStandby / ChargeBattery / StopCharging / ReportBatteryStatus / MonitorSystemHealth PowerSystem
80–85 StartRecognition / StopRecognition / LoadModel / UnloadModel / ResetBehavior / LogEvent CognitiveTrigger

18.14 OT — Industrial / Collaborative Robot Atomic Behaviors (ISO 10218-1 / ISO/TS 15066 / ISO 8373 / IEC 61508)

Namespace prefix: FB.AtomicBehavior.IndustrialRobot.<Domain>.<Action>

# Atomic Behavior Functional Domain
1–9 SetJointPosition / SetJointVelocity / SetJointTorque / StopJointMotion / EnableJoint / DisableJoint / CalibrateJoint / ResetJointFault / SetJointLimits JointControl
10–18 MoveLinear / MoveJoint / MoveCircular / MoveToPose / StopMotion / HoldPose / BlendMotion / SetToolFrame / SetWorkObjectFrame CartesianMotion
19–23 ForceControlledMove / ImpedanceControl / AdmittanceControl / SetForceLimit / MonitorContactForce ForceControl
24–30 OpenGripper / CloseGripper / SetGripForce / ReleaseObject / ActivateTool / DeactivateTool / ChangeTool EndEffector
31–36 ReadJointState / ReadForceTorqueSensor / ReadEncoder / ReadSafetyScanner / DetectCollision / DetectHumanPresence Sensing
37–45 EmergencyStop / SafeTorqueOff / EnterSafeState / ExitSafeState / ActivateProtectiveStop / ResetProtectiveStop / SetSpeedLimit / SetWorkspaceLimit / MonitorSafetyZone Safety
46–50 PowerOn / PowerOff / RestartController / EnterStandby / ExitStandby PowerSystem
51–53 SelfCheck / FaultReset / LogEvent Diagnostics
54–57 ReportStatus / ReceiveCommand / AcknowledgeCommand / SynchronizeTime Communication
58–62 StartProgram / StopProgram / PauseProgram / ResumeProgram / ResetProgram TaskExecution

18.15 OT — Industrial / Collaborative Robot Composite Behaviors

Namespace: FB.CompositeBehavior.Robot

# Composite Behavior Description
1 PickAndPlace Pick object and place at target position
2 Palletizing Stack products onto pallet
3 Depalletizing Remove products from pallet
4 BinPicking Random object picking from bin
5 MachineTending Load/unload CNC or machine tool
6 AssemblyOperation Perform component assembly
7 ScrewDriving Automated screw fastening
8 NutRunning Nut tightening operation
9 TorqueTightening Controlled torque fastening
10 Welding Generic welding operation
11 SpotWelding Spot welding process
12 ArcWelding Arc welding trajectory execution
13 LaserWelding Laser welding operation
14 GlueDispensing Adhesive dispensing
15 SealantApplying Sealant or sealing operation
16 Painting Spray painting process
17 SprayCoating Surface coating application
18 Polishing Surface polishing
19 Grinding Grinding operation
20 Deburring Remove burrs from workpiece
21 Cutting Robotic cutting operation
22 LaserCutting Laser-based cutting
23 Inspection Automated inspection
24 VisionGuidedPicking Vision-guided manipulation
25 MeasurementOperation Dimensional measurement
26 Sorting Object classification and sorting
27 Packaging Product packaging operation
28 CasePacking Place products into cases
29 TrayLoading Load items into tray
30 ConveyorTracking Moving conveyor tracking
31 CollaborativeHandling Human-robot collaborative handling
32 HandOverToHuman Robot-to-human object handover
33 ToolChanging Automatic tool exchange
34 Calibration Robot calibration procedure
35 WorkpieceAlignment Align workpiece pose
36 SurfaceScanning Scan surface geometry
37 FlexibleMaterialHandling Handle deformable objects
38 InsertOperation Peg-in-hole insertion
39 PressFitting Force-controlled insertion
40 DispenseAndAssemble Combined dispensing and assembly
41 QualityCheck Execute quality verification
42 ReworkOperation Perform corrective operation

18.16 AI — Machine Learning Atomic Behaviors

Namespace: FB.AtomicBehavior.ML

# Atomic Behavior Description
1 LoadDataset Load training or inference dataset
2 SplitDataset Split dataset into train/validation/test
3 NormalizeData Normalize or standardize features
4 EncodeFeature Encode categorical features
5 SelectFeature Perform feature selection
6 ExtractFeature Generate engineered features
7 InitializeModel Initialize model structure
8 ConfigureHyperparameter Configure model hyperparameters
9 TrainModel Execute model training
10 UpdateModelWeight Update model parameters
11 EvaluateModel Evaluate model performance
12 ValidateModel Run validation dataset evaluation
13 Predict Perform inference prediction
14 BatchPredict Perform batch inference
15 CalculateLoss Compute loss function
16 OptimizeModel Execute optimization step
17 CrossValidation Perform cross-validation
18 SaveModel Persist trained model
19 LoadModel Load trained model
20 ExportModel Export model artifact
21 ImportModel Import external model
22 MonitorTraining Monitor training metrics
23 DetectOverfitting Detect overfitting condition
24 ModelInferenceStatus Report inference status
25 DeployModel Deploy model to runtime

18.17 AI — Deep Learning Atomic Behaviors

Namespace: FB.AtomicBehavior.DL

# Atomic Behavior Description
1 InitializeNetwork Initialize neural network architecture
2 ForwardPropagation Execute forward pass
3 BackPropagation Execute gradient backpropagation
4 ComputeGradient Compute parameter gradients
5 UpdateWeight Update neural network weights
6 InitializeLayer Initialize neural network layer
7 ActivateNeuron Apply activation function
8 ApplyDropout Apply dropout regularization
9 BatchNormalization Execute batch normalization
10 AttentionComputation Execute attention mechanism
11 EmbeddingGeneration Generate vector embeddings
12 SequenceEncoding Encode sequential input
13 GradientClipping Apply gradient clipping
14 LearningRateUpdate Adjust learning rate
15 DistributedTraining Execute distributed training
16 GPUAcceleration Execute GPU-based computation
17 ModelCheckpoint Save intermediate training state
18 FineTuneModel Perform transfer learning fine-tuning
19 InferRealtime Perform real-time inference
20 QuantizeModel Quantize neural network
21 PruneModel Perform model pruning

18.18 AI — ML / DL Algorithm Atomic Behaviors

Namespace: FB.AtomicBehavior.ML.Algorithm / FB.AtomicBehavior.DL.Algorithm

# ML Algorithm # DL Algorithm
1 LinearRegression 1 MultilayerPerceptron
2 LogisticRegression 2 ConvolutionalNeuralNetwork (CNN)
3 DecisionTree 3 RecurrentNeuralNetwork (RNN)
4 RandomForest 4 LongShortTermMemory
5 GradientBoosting 5 GatedRecurrentUnit
6 XGBoost 6 AutoEncoder
7 SupportVectorMachine 7 VariationalAutoEncoder
8 KNearestNeighbor 8 GenerativeAdversarialNetwork
9 NaiveBayes 9 Transformer
10 KMeansClustering 10 VisionTransformer
11 DBSCANClustering 11 GraphNeuralNetwork
12 PCA 12 DeepQNetwork
13 IsolationForest 13 PolicyGradientNetwork
14 GaussianMixtureModel 14 DiffusionModel

18.19 AI — AI Agent Atomic Behaviors

Namespace: FB.AtomicBehavior.AIAgent

# Atomic Behavior Description
1 InitializeAgent Initialize agent instance and runtime context
2 LoadInstruction Load system prompt or task instruction
3 ReceiveInput Receive user or system input
4 InterpretIntent Interpret task intent from input
5 DecomposeTask Decompose goal into executable subtasks
6 PlanAction Generate execution plan
7 SelectTool Select appropriate external tool
8 InvokeTool Invoke external tool or API
9 ObserveResult Observe tool execution result
10 UpdateContext Update working memory/context
11 RetrieveKnowledge Retrieve knowledge from memory/RAG
12 ReasonStep Execute reasoning step
13 Reflect Perform self-reflection or evaluation
14 ValidateOutput Validate generated result
15 GenerateResponse Generate natural language or structured output
16 RequestClarification Request additional information
17 MaintainSession Maintain conversational/session state
18 StoreMemory Persist long-term memory
19 LoadMemory Load stored memory
20 TerminateTask End task execution
21 ReportStatus Report agent execution status

18.20 AI — MCP (Model Context Protocol) Atomic Behaviors

Namespace: FB.AtomicBehavior.MCP

# Atomic Behavior Description
1 DiscoverServer Discover MCP server capability
2 RegisterClient Register agent as MCP client
3 ListTools Query available tools
4 ListResources Query accessible resources
5 ListPrompts Retrieve predefined prompts
6 AccessResource Access external resource
7 SubscribeResource Subscribe to resource updates
8 InvokeMCPTool Execute MCP tool call
9 ExchangeContext Exchange structured context
10 SynchronizeState Synchronize agent–tool state
11 StreamResult Stream execution result
12 AuthenticateSession Authenticate MCP session
13 AuthorizeAccess Authorize capability access
14 DisconnectSession Close MCP connection

18.21 Logic — Industrial Behavior Tree Node Catalog

Category Node Description Node Type Namespace
Flow Control Start Entry node of workflow execution Flow Control FB.BT.FlowControl.Start
Flow Control End Normal workflow termination Flow Control FB.BT.FlowControl.End
Flow Control KeyPoint Workflow checkpoint or milestone Flow Control FB.BT.FlowControl.KeyPoint
Flow Control Goto Conditional jump to target node Flow Control FB.BT.FlowControl.Goto
Flow Control Stop Stop workflow execution Flow Control FB.BT.FlowControl.Stop
Flow Control Abort Abort execution immediately Flow Control FB.BT.FlowControl.Abort
Composite Logic Sequence Execute children sequentially until failure Composite FB.BT.Logic.Composite.Sequence
Composite Logic Parallel Execute child nodes concurrently Composite FB.BT.Logic.Composite.Parallel
Composite Logic Fallback Execute next child when previous fails Composite FB.BT.Logic.Composite.Fallback
Composite Logic ReactiveSequence Reactive sequential execution Composite FB.BT.Logic.Composite.ReactiveSequence
Composite Logic ReactiveFallback Reactive fallback execution Composite FB.BT.Logic.Composite.ReactiveFallback
Composite Logic SequenceWithMemory Resume execution from last state Composite FB.BT.Logic.Composite.SequenceWithMemory
Decorator Logic Condition Conditional execution wrapper Decorator FB.BT.Logic.Decorator.Condition
Decorator Logic Repeat Repeat execution Decorator FB.BT.Logic.Decorator.Repeat
Decorator Logic Retry Retry on failure Decorator FB.BT.Logic.Decorator.Retry
Decorator Logic Inverter Invert execution result Decorator FB.BT.Logic.Decorator.Inverter
Decorator Logic Timeout Limit execution duration Decorator FB.BT.Logic.Decorator.Timeout
Decorator Logic OneShot Execute only once Decorator FB.BT.Logic.Decorator.OneShot
Idiom Logic IfThenElse Binary conditional branching Idiom FB.BT.Logic.Idiom.IfThenElse
Idiom Logic Switch Multi-branch selection Idiom FB.BT.Logic.Idiom.Switch
Idiom Logic Foreach Iterative traversal execution Idiom FB.BT.Logic.Idiom.Foreach
Idiom Logic RuleEngine Rule-based decision execution Idiom FB.BT.Logic.Idiom.RuleEngine

18.22 Logic — IEC 61499 / PackML ↔ Industrial Behavior Tree ↔ FSM Mapping

Execution Semantic IEC 61499 (ECC State) PackML State Industrial Behavior Tree State Generic FSM State Description
Not Initialized START Idle IDLE Idle System created but not executing
Initializing INIT Starting INITIALIZING Transition Resource initialization
Ready STOPPED Idle / Complete READY Stable Waiting for execution trigger
Execution Requested REQ Starting TRIGGERED Event Received Execution requested
Running RUN Execute RUN Active Behavior actively executing
Holding Execution — Holding PAUSED Suspended Temporary suspension
Suspended — Suspended SUSPENDED Suspended Execution halted but recoverable
Completing — Completing COMPLETING Transition Finalizing execution
Execution Success CNF Complete OK Success Behavior finished successfully
Execution Failure ERROR Aborted FAIL Failure Execution failure
Stopping STOP Stopping STOPPING Transition Controlled stop
Stopped STOPPED Stopped STOPPED Idle Execution terminated safely
Aborting — Aborting ABORTING Emergency Transition Immediate termination
Aborted — Aborted ABORTED Failure Terminal emergency stop reached
Resetting RESET Resetting RESETTING Recovery Return to idle state

19. Appendix F — Adaptation with Existing Standards

The canonical interoperability matrix between CREEM and major information / behavior modeling standards. This appendix contains one row per standard and expands §13.15.

Standard IEC / ISO GB/T Interoperability Method with CREEM
OMG IDL — — Parameter & type mapping; same approach for Anchor Model
IEC 61499 IEC 61499 GB/T 19796 Consistent event-driven logical orchestration control; convertible Function Block (FB) encapsulation
IEC 61131 IEC 61131 GB/T 15969 Parameter & type mapping
OPC UA IEC 62541 GB/T 33863 Behavior & object binding; parameter & type mapping; unified unit (UN/ECE) and status code
AAS IEC 63278 — Resource mapping and interoperability via eCl@ss
MTP NE 148 — Behavior & object binding, AML mapping; parameter & type mapping
ProfiNET IEC 61158-5-10 GB/T 25105 Parameter & type mapping
IEC 61850 IEC 61850 — Logical node mapping; parameter & type mapping
BPMN 2.0 ISO/IEC 19510 — Business workflow converter; parameter & type mapping
UML ISO/IEC 19501 GB/T 28174 Object & resource mapping; parameter & type mapping
DEXPI (P&ID) ISO 15926 / DIN SPEC 91486 — Process-plant P&ID equipment, piping and instrumentation imported as RDs; DEXPI Proteus XML mapped to RD type tree (see §19.1)
ISA-88 — — BatchML mapping
ISA-95 — — B2MML mapping
PackML — — PackML state mapping (see §18.22)
DMTF RedFish — — Resource and operation mapping

Principle:

19.1 DEXPI / P&ID Interoperability Detail

DEXPI (Data Exchange in the Process Industry) is the de-facto open standard for vendor-neutral P&ID (Piping & Instrumentation Diagram) exchange in the process industries (chemical, pharmaceutical, oil & gas, etc.). It is built on ISO 15926 semantics, the DEXPI Information Model, the DEXPI Reference Data Library (RDL), and serialized as Proteus XML (with an emerging RDF/OWL variant). CREEM treats DEXPI as a first-class P&ID-side information model that complements its discrete-manufacturing-oriented RD/FB tree.

Why it matters for CREEM

Process plants are typically engineered around P&ID artefacts long before runtime execution exists. By interoperating with DEXPI, CREEM can:

Mapping table (DEXPI ↔ CREEM)

DEXPI Concept DEXPI Carrier (Proteus XML) CREEM Mapping
PlantModel Root <PlantModel> element CREEM Project (PRJ.*) + root Resource Tree (RT.*)
PlantArea Hierarchical container RT node; namespace segment RT.Plant.Area.*
PlantSection Hierarchical container RT node; namespace segment RT.Plant.Area.Section.*
Unit Hierarchical container RT node; namespace segment RT.Plant.Area.Section.Unit.*
Equipment (Tank, Vessel, Pump, HeatExchanger, Reactor, Column, Compressor, …) <Equipment ComponentClass="…"> RD instance under RD.Process.Equipment.<Class>.*
Nozzle Child <Nozzle> of Equipment RD sub-instance RD.Process.Equipment.*.Nozzle.*; mapped as a connection point
PipingNetworkSystem <PipingNetworkSystem> RT.Typology edges between Equipment RDs
PipingNetworkSegment <PipingNetworkSystem> Line numbers stored as RD parameters
PipingComponent (Valve, Fitting, Reducer, …) <PipingComponent> RD under RD.Process.Piping.*
ActuatingSystem <ActuatingSystem> Composite RD binding an actuator RD to the controlled PipingComponent
ActuatingElectricalSystem <ActuatingSystem> Composite RD binding an electrical actuator RD to the controlled PipingComponent
ProcessInstrumentationFunction (PIF) <ProcessInstrumentationFunction> CREEM FB (FB.Process.Control.*) bound to the relevant RD via ResourceRef
ProcessSignalGeneratingFunction <ProcessSignalGeneratingFunction> CREEM FB (FB.Process.Control.*) bound to the relevant RD via ResourceRef
ProcessControlFunction <ProcessControlFunction> CREEM FB (FB.Process.Control.*) bound to the relevant RD via ResourceRef
InstrumentationLoopFunction Control loop CREEM Workflow (WF.Process.Loop.*) referencing PIF-derived FBs
SignalConveyingFunction Instrument signal Parameter wiring on FB ports (ParameterRef)
SignalLine Instrument signal line DT entry or FB-port wiring (DT.*, ParameterRef)
Label <Label><Text> RD/FB Metadata.Name (TAG number)
TagInformation <GenericAttribute Name="TagName"> Written into Namespace as …<TagName>.<InstanceIndex>
Identifier DEXPI identifier Preserved in the CREEM namespace and metadata
RDL class reference (ComponentClass, Discipline) Pointer to DEXPI RDL URI RD/FB type field; preserved as a CIM mapping reference inside the Resource segment
GenericAttribute (Name, Value, Units, Format, UnitsURI) <GenericAttribute> RD/FB Parameter with unit populated from UN/ECE (Rec 20) via the DEXPI unit URI
PressureRelief… Safety-class equipment RD flagged with safety-relevant metadata; SIF logic implemented as Workflows
SafetyValve Safety-class equipment RD flagged with safety-relevant metadata; SIF logic implemented as Workflows
GraphicalRepresentation (Presentation, Extent, Position, drawing references) 2D P&ID geometry Stored in RT.Layout and/or as UIInformation.Style; original Proteus XML kept under the Resource segment for round-tripping
Connection Graph connectivity RT.Typology edge with typed connection metadata
Node Graph connectivity RT.Typology node with typed connection metadata
ConnectionPoints Graph connectivity RT.Typology endpoint with line spec, fluid service, and P&T class metadata
Reference data ID (RDL URI) DEXPI Reference Data Library Stored in cim:cimType / cim:cimReference attributes for traceability to the RDL

Identity and round-tripping rules

  1. Namespace anchoring. A DEXPI element's ID (and its TAG number where present) shall be carried into the CREEM instance namespace, e.g. an equipment with TAG V-101 becomes RD.Process.Equipment.Vessel.V101.1; the original DEXPI ID is preserved as a metadata attribute (Metadata.Extensions.dexpi:ID) for round-trip integrity.
  2. Class mapping. Each DEXPI ComponentClass (e.g. HorizontalDrum, CentrifugalPump, ControlValve) is mapped to a corresponding CREEM RD type under the RD.Process.* subtree; where no exact match exists, the DEXPI RDL URI is kept verbatim so consumers can resolve the original class.
  3. Units. DEXPI GenericAttribute units (URI-referenced) are normalized to UN/ECE Recommendation 20 in CREEM Parameters (the same unit catalog used by CREEM.Base.UNECE.xml).
  4. Graphical fidelity. The original Proteus XML (or DEXPI 1.x/2.x package) is retained as a Resource (type="PnID", format="DEXPI-Proteus-XML") so that round-trip back to a P&ID authoring tool stays loss-less even when CREEM enriches the model with runtime data.
  5. Behavior overlay. Static P&ID semantics (objects, connections, tags) are populated from DEXPI; runtime semantics (sequences, interlocks, alarms, batch recipes) are authored as CREEM FBs/Workflows that reference those RDs by namespace, keeping the design-time DEXPI master non-destructive.

Tooling pattern

A typical DEXPI ↔ CREEM bridge has three components:

Where a process plant also maintains a module-based view (NAMUR MTP for Process Equipment Assemblies), the DEXPI and MTP mappings can be used together: DEXPI provides plant-wide P&ID context, MTP provides modular execution interfaces, and CREEM provides the runtime behavior layer that connects them.

20. Appendix G — File System Structure for Engineering and Agentic AI

The canonical file and folder structure for engineering tools and agentic-AI access to CREEM instances. This appendix contains the detailed layout and expands §13.16.

<Project>/
├── repository/                       # Repository (Instance)
│   └── digital_asset_library/        # Digital Asset Model Library (reference)
├── assets/                           # CREEM Asset (Resource)
│   └── <RD.Namespace>/
│       ├── definition/               # Definition instance (XML, inner Markdown)
│       ├── ui/                       # UI code (HTML, CSS, JS/TS)
│       ├── references/               # Documents, icons, inner DSL
│       ├── 3d/                       # 3D model
│       ├── scene_mapping/            # 3MF, IFC, OpenUSD, glTF mappings
│       ├── kinematics/               # Animation / kinematics scripts
│       └── cim_mapping/              # MTP, DPP, AAS mappings
├── behaviors/                        # CREEM Behavior (FB)
│   └── <FB.Namespace>/
│       ├── definition/               # Definition instance (XML, inner Markdown)
│       ├── runtime/                  # Runtime code (Python, TS, WASM…)
│       ├── ui/                       # UI code
│       ├── references/               # Documents, icons, inner DSL
│       └── animation/                # Animation / kinematics scripts
├── workflows/                        # Workflow (CREEM Instance, DSL)
│   └── <WF.Namespace>/definition/
├── project/                          # Project (CREEM Instance)
│   ├── rt_instances/                 # Resource Tree instances
│   ├── wf_instances/                 # Workflow instances
│   └── semantic_ontology/            # Semantic ontology mapping
├── runtime/                          # Runtime (Orchestrator)
│   ├── tsdb/                         # Realtime data monitoring (TSDB)
│   └── logs/                         # Execution logs
└── devices/                          # Physical / virtual device endpoints

Linking semantics

Engineering tools and agentic-AI consumers can browse CREEM projects in this structure without an additional translation step.

21. Appendix H — XML Schema Reference

This appendix defines the normative XSD-based serialization of the CREEM meta-model. The XSD/XML files in this documentation are reference material only. Two XSD modules are defined:

Module Target Namespace Purpose
CREEM.Base.xsd http://creem.siemens.com/schemas/base Base parameter types, type-inheritance system (TI System), CIM base types, attribute types.
CREEM.Specification.xsd http://creem.siemens.com/schemas/creem The CIMI root, top-level CREEM elements (Project, FunctionBlock, FBLibrary, Workflow, DeviceDescription, Communication, DeviceLibrary, SystemConfiguration, Visualization3D, WorkcellMicroservice), and LCP workflow / FSM types.

Two additional reference catalogs are shipped as XML data files (not XSDs), because their content is large enumerations rather than structure:

Catalog Role
CREEM.Base.StatusCode.xml Numeric status-code catalog used as the value space of the StatusCode element in the TI System (≈ 1,200+ codes).
CREEM.Base.UNECE.xml UN/ECE Recommendation 20 unit-of-measure catalog used as the value space of the UNECE element in the TI System (≈ 9,300 entries).

Schema design pattern: CREEM XSDs use the Venetian Blind / Hybrid pattern — named complex/simple types are defined globally, and only a small set of root elements (CIMI, Project, Workflow, …) are exposed as global element declarations. This keeps the schemas reusable across many serializations.

Namespace prefixes used in instances: - xs → XML Schema - xsi → XML Schema instance - bs → http://creem.siemens.com/schemas/base - cim → http://creem.siemens.com/schemas/cim - cm → http://creem.siemens.com/schemas/creem (default for CREEM content)

21.1 CREEM.Base — Base parameter types

CREEM.Base defines the cross-cutting type vocabulary used by every CREEM document. It is split into four groups: (a) Metadata-of-Metadata schema attributes; (b) the CREEM Type-Inheritance (TI) System; (c) the extended cim* element wrappers; (d) attribute types.

21.1.1 Metadata-of-Metadata (MoM) attributes

Three global attributes are attached to any CREEM schema/document to describe the schema itself:

Attribute Type Enumeration / Pattern Meaning
bs:schemaDesignPattern SchemaDesignPattern_Type RussianDoll, SalamiSlice, VenetianBlind, GardenofEden, Hybrid Declares which XSD design pattern the schema follows.
bs:schemaState SchemaState_Type Initial, SnapShot, Released, Archived, Obsolete Lifecycle state of the schema definition.
bs:schemaVersion SchemaVersion_Type [0-9]+\.[0-9]+\.[0-9]+ Schema-internal semantic version major.minor.update.

ProjectState_Type is similar but applies to project lifecycle rather than the schema itself: Prototype, PreAlpha, Alpha, Beta, ReleaseCandidate, GeneralAvailability, SnapShot, Eval, OEM, Retire.

21.1.2 CREEM Type-Inheritance (TI) System

The TI System unifies weak (dynamic) and strong (static) typing under a single tree, so the same value tree can serve both a low-code authoring UI and a strongly-typed runtime / code generator.

Weak (top-level) types — CREEM_Weak_Type:

Weak Type Meaning
Any Generic reference; can hold any structured value.
Bool Boolean.
String Text; refined by CREEM_StringGroup.
Number Numeric; refined by CREEM_NumberGroup.
Array Ordered list.
Matrix 2D (or N-D) numeric matrix.
Enum Enumerated value.
DateTime Time-related value; refined by cimDateTime.
Struct Composite reference (cimReference).
Ref Reference to another node in the model (cimReference).

String refinements — CREEM_StringGroup:

Element Pattern / Note
QualifiedName Namespace-qualified identifier.
LocalizedText Localized string.
Namespace Dotted namespace, e.g. Robotic.Cobot.UniversalRobots.UR5.
URI URI/URL.
Version [0-9]+\.[0-9]+(\.[0-9]+)?
UUID Standard 8-4-4-4-12 hex UUID (with or without braces).
Email RFC-style mail address.

Number refinements — CREEM_NumberGroup:

Element Concrete sub-elements
Integer SByte, Int16, Int32, Int64 (CREEM_IntegerGroup)
UInteger Byte, UInt16, UInt32, StatusCode, UInt64 (CREEM_UIntegerGroup)
Float, Double IEEE-754 floats.
UNECE Numeric value carrying a UN/ECE Rec.20 unit code (see CREEM.Base.UNECE.xml).

DateTime refinements — cimDateTime:

Element XSD base
LocalDateTime xs:string (locale-bound)
Interval xs:duration
Date xs:date
Time xs:time
DateTime xs:dateTime (UTC)

21.1.3 cim* extended base types

Every CREEM-visible primitive is wrapped in a cim… complex type that adds xs:anyAttribute namespace="##any" processContents="lax" — this is what lets every value also carry metadata like unit, quality, timestamp, ref, etc., without breaking the schema. The full set:

cimAnySimpleType, cimString, cimDecimal, cimAnyURI, cimReference, cimDateTime, cimUnsignedByte, cimByte, cimUnsignedShort, cimShort, cimUnsignedInt, cimInt, cimUnsignedLong, cimLong, cimBoolean, cimFloat, cimDouble, cimBase64Binary, cimHexBinary.

21.1.4 Attribute types

Type Allowed values
Language_AttributeType en-US, zh-CN, … (ISO 639 + ISO 3166, extensible).

21.1.5 Full source of CREEM.Base.xsd

<?xml version="1.0" encoding="utf-8"?>
<!--
Common Information Model (CIM) of AIOT (AI/IT/OT) Integration
Common Runtime-Engineering Exchange Model (CREEM)
Type: Specification
Namespace: CREEM.Base
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns:bs="http://creem.siemens.com/schemas/base"
           targetNamespace="http://creem.siemens.com/schemas/base"
           elementFormDefault="qualified" attributeFormDefault="qualified" version="0.0.1">

    <xs:annotation>
        <xs:appinfo>CREEM.Base</xs:appinfo>
        <xs:documentation xml:lang="en">CREEM.Base : Define base parameter types of CREEM schemas.</xs:documentation>
    </xs:annotation>

    <!-- CIM : MoM (Metadata of Metadata) -->
    <xs:attribute name="schemaDesignPattern" type="bs:SchemaDesignPattern_Type"/>
    <xs:attribute name="schemaState" type="bs:SchemaState_Type"/>
    <xs:attribute name="schemaVersion" type="bs:SchemaVersion_Type"/>

    <xs:simpleType name="SchemaDesignPattern_Type">
        <xs:restriction base="xs:string">
            <xs:enumeration value="RussianDoll"/>
            <xs:enumeration value="SalamiSlice"/>
            <xs:enumeration value="VenetianBlind"/>
            <xs:enumeration value="GardenofEden"/>
            <xs:enumeration value="Hybrid"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="SchemaState_Type">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Initial"/>
            <xs:enumeration value="SnapShot"/>
            <xs:enumeration value="Released"/>
            <xs:enumeration value="Archived"/>
            <xs:enumeration value="Obsolete"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="SchemaVersion_Type">
        <xs:restriction base="xs:string">
            <xs:pattern value="[0-9]+\.[0-9]+\.[0-9]+"/>
        </xs:restriction>
    </xs:simpleType>

    <!-- CIM: General Schema Types -->
    <xs:simpleType name="ProjectState_Type">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Prototype"/>
            <xs:enumeration value="PreAlpha"/>
            <xs:enumeration value="Alpha"/>
            <xs:enumeration value="Beta"/>
            <xs:enumeration value="ReleaseCandidate"/>
            <xs:enumeration value="GeneralAvailability"/>
            <xs:enumeration value="SnapShot"/>
            <xs:enumeration value="Eval"/>
            <xs:enumeration value="OEM"/>
            <xs:enumeration value="Retire"/>
        </xs:restriction>
    </xs:simpleType>

    <!-- CREEM Type Inheritance System : Version 1.0 -->
    <xs:simpleType name="ProgrammingLanguage_Type">
        <xs:restriction base="xs:string">
            <xs:enumeration value="PlainText"/><xs:enumeration value="Markdown"/>
            <xs:enumeration value="Python"/><xs:enumeration value="C"/>
            <xs:enumeration value="C++"/><xs:enumeration value="Lua"/>
            <xs:enumeration value="JavaScript"/><xs:enumeration value="TypeScript"/>
            <xs:enumeration value="C#"/><xs:enumeration value="Java"/>
            <xs:enumeration value="Perl"/><xs:enumeration value="Go"/>
            <xs:enumeration value="HTML"/><xs:enumeration value="CSS"/>
            <xs:enumeration value="XML"/><xs:enumeration value="JSON"/>
            <xs:enumeration value="YAML"/><xs:enumeration value="SCL"/>
            <xs:enumeration value="WebAssembly"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name="CREEM_Weak_Type">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Any"/><xs:enumeration value="Bool"/>
            <xs:enumeration value="String"/><xs:enumeration value="Number"/>
            <xs:enumeration value="Array"/><xs:enumeration value="Matrix"/>
            <xs:enumeration value="Enum"/><xs:enumeration value="DateTime"/>
            <xs:enumeration value="Struct"/><xs:enumeration value="Ref"/>
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="CREEM_All_Type">
        <xs:choice>
            <xs:element name="Any" type="bs:cimReference"/>
            <xs:element name="Bool" type="xs:string"/>
            <xs:element name="String" type="xs:string"/>
            <xs:group ref="bs:CREEM_StringGroup"/>
            <xs:element name="Number" type="xs:string"/>
            <xs:group ref="bs:CREEM_NumberGroup"/>
            <xs:element name="Array" type="xs:string"/>
            <xs:element name="Matrix" type="xs:string" minOccurs="0"/>
            <xs:element name="Enum" type="xs:string"/>
            <xs:element name="DateTime" type="bs:cimDateTime"/>
            <xs:element name="Struct" type="bs:cimReference"/>
            <xs:element name="Ref" type="bs:cimReference"/>
        </xs:choice>
        <xs:anyAttribute namespace="##any" processContents="lax"/>
    </xs:complexType>

    <xs:group name="CREEM_NumberGroup">
        <xs:choice>
            <xs:element name="Integer" type="xs:string"/>
            <xs:group ref="bs:CREEM_IntegerGroup"/>
            <xs:element name="UInteger" type="xs:string"/>
            <xs:group ref="bs:CREEM_UIntegerGroup"/>
            <xs:element name="Float" type="xs:string"/>
            <xs:element name="Double" type="xs:string"/>
            <xs:element name="UNECE" type="xs:string"/>  <!-- UNECE.xml -->
        </xs:choice>
    </xs:group>
    <xs:group name="CREEM_IntegerGroup">
        <xs:choice>
            <xs:element name="SByte" type="xs:string"/>
            <xs:element name="Int16" type="xs:string"/>
            <xs:element name="Int32" type="xs:string"/>
            <xs:element name="Int64" type="xs:string"/>
        </xs:choice>
    </xs:group>
    <xs:group name="CREEM_UIntegerGroup">
        <xs:choice>
            <xs:element name="Byte" type="xs:string"/>
            <xs:element name="UInt16" type="xs:string"/>
            <xs:element name="UInt32" type="xs:string"/>
            <xs:element name="StatusCode" type="xs:string"/> <!-- StatusCode.xml -->
            <xs:element name="UInt64" type="xs:string"/>
        </xs:choice>
    </xs:group>
    <xs:group name="CREEM_StringGroup">
        <xs:choice>
            <xs:element name="QualifiedName" type="xs:string"/>
            <xs:element name="LocalizedText" type="xs:string"/>
            <xs:element name="Namespace" type="xs:string"/>
            <xs:element name="URI" type="xs:string"/>
            <xs:element name="Version" type="bs:Version_Type"/>
            <xs:element name="UUID" type="bs:UUID_Type"/>
            <xs:element name="Email" type="bs:Email_Type"/>
        </xs:choice>
    </xs:group>

    <xs:simpleType name="Version_Type">
        <xs:restriction base="xs:string">
            <xs:pattern value="[0-9]+\.[0-9]+(\.[0-9]+)?"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="UUID_Type">
        <xs:restriction base="xs:string">
            <xs:pattern value="([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})|(\{[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\})"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="Email_Type">
        <xs:restriction base="xs:string">
            <xs:pattern value="([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})"/>
        </xs:restriction>
    </xs:simpleType>

    <!-- Extended "CIM Base Types" (cim prefix) for element definitions in CIM schema. -->
    <xs:complexType name="cimString">
        <xs:simpleContent>
            <xs:extension base="xs:string">
                <xs:anyAttribute namespace="##any" processContents="lax"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <!-- Identical wrapper pattern is repeated for:
         cimAnySimpleType, cimDecimal, cimAnyURI, cimUnsignedByte, cimByte,
         cimUnsignedShort, cimShort, cimUnsignedInt, cimInt, cimUnsignedLong,
         cimLong, cimBoolean, cimFloat, cimDouble, cimBase64Binary, cimHexBinary.
         Each wraps the matching xs:* base type and adds <xs:anyAttribute .../>. -->

    <xs:complexType name="cimReference">
        <xs:sequence>
            <xs:any namespace="##other" processContents="lax" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:anyAttribute namespace="##any" processContents="lax"/>
    </xs:complexType>

    <xs:complexType name="cimDateTime">
        <xs:choice>
            <xs:element name="LocalDateTime" type="xs:string" nillable="true"/>
            <xs:element name="Interval" type="xs:duration"/>
            <xs:element name="Date" type="xs:date"/>
            <xs:element name="Time" type="xs:time"/>
            <xs:element name="DateTime" type="xs:dateTime"/>
        </xs:choice>
        <xs:anyAttribute namespace="##any" processContents="lax"/>
    </xs:complexType>

    <!-- Attribute Types -->
    <xs:simpleType name="Language_AttributeType">
        <xs:restriction base="xs:string">
            <xs:enumeration value="en-US"/>
            <xs:enumeration value="zh-CN"/>
        </xs:restriction>
    </xs:simpleType>
</xs:schema>

The block above is condensed for readability (the repetitive cim* wrappers are summarized as a comment). The on-disk schemas/CREEM.Base.xsd is the byte-exact normative source.

21.2 CREEM.Specification — CIMI root and CREEM elements

CREEM.Specification imports CREEM.Base and defines the CIMI (Common Information Model Instance) root plus all top-level CREEM artifacts.

21.2.1 The CIMI root

<xs:element name="CIMI" type="cm:CREEM_CIMI_Type"/>
<xs:complexType name="CREEM_CIMI_Type">
    <xs:choice maxOccurs="unbounded">
        <xs:element ref="Project"              minOccurs="0"/>
        <xs:element ref="FunctionBlock"        minOccurs="0"/>
        <xs:element ref="FBLibrary"            minOccurs="0"/>
        <xs:element ref="Workflow"             minOccurs="0"/>
        <xs:element ref="DeviceDescription"    minOccurs="0"/>
        <xs:element ref="Communication"        minOccurs="0"/>
        <xs:element ref="DeviceLibrary"        minOccurs="0"/>
        <xs:element ref="SystemConfiguration"  minOccurs="0"/>
        <xs:element ref="Visualization3D"      minOccurs="0"/>
        <xs:element ref="WorkcellMicroservice" minOccurs="0"/>
    </xs:choice>
    <xs:attribute ref="bs:schemaDesignPattern"/>
    <xs:attribute name="state"   type="bs:SchemaState_Type"/>
    <xs:attribute name="version" type="bs:SchemaVersion_Type"/>
    <xs:attribute name="lang"    type="xs:language"/>
    <xs:anyAttribute namespace="##any" processContents="lax"/>
</xs:complexType>

CIMI attributes

Attribute Type Meaning
bs:schemaDesignPattern enum Optional declaration of the XSD design pattern.
state SchemaState_Type Lifecycle of the instance: Initial / SnapShot / Released / Archived / Obsolete.
version SchemaVersion_Type Semantic version of the instance content.
lang xs:language Primary language tag of the document, e.g. en-US.

A single CIMI document may carry any combination of the top-level artifacts; this is the unit of import/export and signing.

21.2.2 Top-level CREEM elements

All but Project share the same CIM_Type skeleton:

Element Role in CREEM
Project A deployable project: references one SystemConfiguration and one or more Workflows.
FunctionBlock A single FB definition (CIM_Type).
FBLibrary A library of FBs (CIM_Type).
Workflow A workflow (LCP behavior tree) (CIM_Type).
DeviceDescription A device description (CIM_Type).
Communication A communication channel description (CIM_Type).
DeviceLibrary A library of device descriptions (CIM_Type).
SystemConfiguration The runtime topology / device tree (CIM_Type).
Visualization3D 3D visualization assets (CIM_Type).
WorkcellMicroservice Workcell-scoped microservice contract (CIM_Type).

21.2.3 Project_Type

<xs:complexType name="Project_Type">
    <xs:sequence>
        <xs:element ref="SystemConfiguration" minOccurs="0" maxOccurs="1"/>
        <xs:element ref="Workflow"            minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:string"/>
    <xs:anyAttribute namespace="##any" processContents="lax"/>
</xs:complexType>

A Project is a thin composition: an optional SystemConfiguration (the device tree) plus any number of Workflows.

21.2.4 The universal CIM_Type skeleton

Every non-Project CREEM artifact is shaped as four sibling sections — Metadata → UIInformation → Data → Resource — which the manual refers to throughout as the "CIM four-section pattern":

<xs:complexType name="CIM_Type">
    <xs:sequence>
        <xs:element name="Metadata"      type="cm:Metadata_Type"/>
        <xs:element name="UIInformation" type="cm:UIInformation_Type" nillable="true" minOccurs="0"/>
        <xs:element name="Data"          type="cm:Data_Type"          nillable="true"/>
        <xs:element name="Resource"      type="cm:Resource_Type"      nillable="true" minOccurs="0"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:string"/>
    <xs:anyAttribute namespace="##any" processContents="lax"/>
</xs:complexType>
Section Mandatory? Purpose
Metadata yes Identity (Namespace/Name/Version/UUID), authoring info, signature.
UIInformation optional Everything needed only by UI (display names, diagrams, icons, dialogs). Must be isolated from real data.
Data yes (nillable) The actual model payload (a Tree/List/DirectGraph/Semantic structure).
Resource optional Embedded binary/source/icon resources.

21.2.5 Metadata_Type

<xs:complexType name="Metadata_Type" block="#all">
    <xs:sequence>
        <xs:element name="Namespace"     type="bs:cimString"/>
        <xs:element name="Name"          type="bs:cimString"/>
        <xs:element name="Version"       type="bs:SchemaVersion_Type" default="1.0.0"/>
        <xs:element name="Description"   type="bs:cimString" nillable="true"/>
        <xs:element name="UUID"          type="bs:UUID_Type" nillable="true"/>
        <xs:element name="InstanceURI"   type="bs:cimAnyURI"
                    default="http://creem.siemens.com/instances" nillable="true" minOccurs="0"/>
        <xs:element name="Structure"     type="cm:Metadata_StructureSchema_Type" minOccurs="0"/>
        <xs:element name="Organization"  type="cm:Metadata_Organization_Type"    minOccurs="0"/>
        <xs:element name="Certification" type="cm:DigitalSignatureX509_Type"     minOccurs="0"/>
    </xs:sequence>
    <xs:attribute name="state"    type="bs:ProjectState_Type" default="PreAlpha"/>
    <xs:attribute name="revision" type="xs:int"               default="0"/>
    <xs:anyAttribute namespace="##any" processContents="lax"/>
</xs:complexType>
Field Type Notes
Namespace string Dotted namespace identity (matches the Namespace System in §9).
Name string Short human name.
Version SchemaVersion_Type major.minor.update, default 1.0.0.
Description string Free text.
UUID UUID Globally unique identifier.
InstanceURI URI Canonical resolvable URI for the instance.
Structure Metadata_StructureSchema_Type Carries StructureNamespace (default CIM) and StructureSchemaURI.
Organization Metadata_Organization_Type OrganizationName, choice of DigitalSignature / DigitalSignatureX509, list of Authors (Name, Email).
Certification DigitalSignatureX509_Type Signer / SignedUtcTime / X509Certificate. Any post-signing edit invalidates the signature.
@state ProjectState_Type Lifecycle (default PreAlpha).
@revision int Editorial revision (default 0).

21.2.6 UIInformation_Type

<xs:complexType name="UIInformation_Type" block="#all">
    <xs:sequence>
        <xs:element name="Identification" type="bs:cimReference" minOccurs="0"/>
        <xs:element name="Content"        type="bs:cimReference"/>
    </xs:sequence>
    <xs:attribute name="type"        type="cm:UIInformation_Type_AttributeType_Type" default="Default"/>
    <xs:attribute name="revision"    type="xs:int"           default="0"/>
    <xs:attribute name="version"     type="bs:Version_Type"  default="1.0.0"/>
    <xs:attribute name="description" type="xs:string"        default="0"/>
    <xs:anyAttribute namespace="##any" processContents="lax"/>
</xs:complexType>
Attribute Allowed values
type Default, Package

Content is a cimReference that typically carries one Content_UIInformation_Type per language:

<xs:complexType name="Content_UIInformation_Type">
    <xs:complexContent>
        <xs:extension base="cm:Content_Type">
            <xs:sequence>
                <xs:element name="DisplayName" type="bs:cimString"/>
                <xs:element name="Description" type="bs:cimString" minOccurs="0"/>
                <xs:element name="Icon"        type="bs:cimString" minOccurs="0"/>
                <xs:element name="Diagram"     type="bs:cimString" minOccurs="0"/>
                <xs:element name="Dialog"      type="bs:cimString" minOccurs="0"/>
            </xs:sequence>
        </xs:extension>
    </xs:complexContent>
</xs:complexType>

21.2.7 Data_Type

<xs:complexType name="Data_Type" block="#all">
    <xs:sequence>
        <xs:element name="Identification" type="bs:cimReference" minOccurs="0"/>
        <xs:element name="Content"        type="bs:cimReference"/>
    </xs:sequence>
    <xs:attribute name="type"        type="cm:Data_Type_AttributeType" use="required" fixed="Tree"/>
    <xs:attribute name="revision"    type="xs:int"          default="0"/>
    <xs:attribute name="version"     type="bs:Version_Type" default="1.0"/>
    <xs:attribute name="description" type="xs:string"       default="0"/>
    <xs:anyAttribute namespace="##any" processContents="lax"/>
</xs:complexType>
Attribute Allowed values Default / Constraint
type Unknown, List, Tree, DirectGraph, Semantic Currently fixed to Tree.

21.2.8 Resource_Type

<xs:complexType name="Resource_Type" block="#all">
    <xs:sequence>
        <xs:element name="Content" type="bs:cimReference"/>
    </xs:sequence>
    <xs:attribute name="revision" type="xs:int" default="0"/>
    <xs:anyAttribute namespace="##any" processContents="lax"/>
</xs:complexType>

The Resource_Type_AttributeType enumeration tags individual Content items: General, SourceCode, Icon, Binary.

21.2.9 Content_Type

<xs:complexType name="Content_Type" block="#all">
    <xs:sequence>
        <xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="lang" type="bs:Language_AttributeType" default="en-US"/>
    <xs:anyAttribute namespace="##any" processContents="lax"/>
</xs:complexType>

Content is intentionally open (xs:any namespace="##other") so each artifact can carry its domain-specific payload (device tree, FB library, workflow body, …) without further XSD changes.

21.2.10 DigitalSignatureX509_Type

Field Type Notes
Signer string Optional. Certificate signer name.
SignedUtcTime string Required. UTC timestamp of the signature.
X509Certificate string Required. Public part of the X.509 certificate.

21.2.11 LCP Workflow types

LCP_Workflow_Type defines the body of an LCP (Low-Code Paradigm) workflow as a sequence of behavior-tree-like nodes:

<xs:complexType name="LCP_Workflow_Type">
    <xs:sequence>
        <xs:element name="Start" type="xs:string" minOccurs="0"/>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:group ref="LCP_General_Group"/>
            <xs:element name="Condition" type="xs:string"/>
            <xs:group ref="LCP_Compositor_Group"/>
            <xs:group ref="LCP_Decorator_Group"/>
            <xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
        </xs:choice>
        <xs:element name="End" type="xs:string" minOccurs="0"/>
    </xs:sequence>
</xs:complexType>
Group Members
LCP_General_Group FBInstance, Idle, Manual, Delay, Goto, Stop, Abort, ErrorManager
LCP_Compositor_Group Sequence, Parallel, Priority, If, Switch
LCP_Decorator_Group Repeat, While, Timeout, Retry, IQC, Guard, OneShot

21.2.12 LCP Finite State Machine

<xs:complexType name="LCP_FiniteStateMachine_Type">
    <xs:sequence>
        <xs:element name="State"     type="cm:BehaviorForest_FSM_Enum"/>
        <xs:element name="LastState" type="cm:BehaviorForest_FSM_Enum" minOccurs="0"/>
        <xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
</xs:complexType>

<xs:simpleType name="BehaviorForest_FSM_Enum">
    <xs:restriction base="xs:string">
        <xs:enumeration value="IDLE"/>
        <xs:enumeration value="RUNNING"/>
        <xs:enumeration value="OK"/>
        <xs:enumeration value="FAILED"/>
        <xs:enumeration value="PAUSE"/>
        <xs:enumeration value="RESUME"/>
    </xs:restriction>
</xs:simpleType>

The FSM enumeration is the unified runtime status surface used by every node in a Behavior Forest, by every FB instance, and by every workflow/sub-workflow.

21.2.13 Global document attributes

Attribute Type Purpose
documentLanguage Language_AttributeType Primary document language.
documentEncoding string Character encoding of the document.

21.3 Reference catalogs

21.3.1 CREEM.Base.StatusCode.xml

A flat enumeration of numeric status codes used as the value space of <StatusCode> (TI System → UInteger). Each entry has a numeric code plus a short symbolic name and description. Because of its size (≈ 1,200 codes) the catalog is shipped as a separate XML and is not inlined here.

Authoring rule: a runtime that reports a status that is not in this catalog must allocate a code in the OEM-reserved range and contribute it back, so the catalog stays canonical.

21.3.2 CREEM.Base.UNECE.xml

The UN/ECE Recommendation 20 catalog of units of measure used as the value space of <UNECE> (TI System → Number). Every numeric quantity in a CREEM document that carries a physical unit must reference a UNECE code (e.g. MTR = metre, SEC = second, KGM = kilogram). This guarantees that any IT/OT consumer can convert units losslessly.

22. Appendix I — Instance Examples

This appendix collects representative on-disk instances that show how the schemas above are actually used. The samples are reproduced from the instance/ folder; license headers, embedded base64 icons and trivial empty wrappers are elided for readability. The on-disk files remain the byte-exact reference.

22.1 Project instance — CREEM.Project.xml

A Project is a thin composition: one SystemConfiguration reference plus N Workflow references.

<cm:CIMI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:bs="http://creem.siemens.com/schemas/base"
         xmlns:cim="http://creem.siemens.com/schemas/cim"
         xmlns:cm="http://creem.siemens.com/schemas/creem"
         xmlns="http://creem.siemens.com/schemas/creem"
         state="Alpha" version="0.0.1" lang="en-US">

    <cm:Project id="ProjectSample">
        <cm:Metadata/>

        <cm:UIInformation>
            <cm:Content lang="en-US">
                <cm:DisplayName>Project Sample</cm:DisplayName>
                <cm:Description>Sample project</cm:Description>
            </cm:Content>
        </cm:UIInformation>

        <cm:Data>
            <cm:Content>
                <cm:SystemConfiguration ref="CREEM.SystemConfiguration" />
                <cm:Workflow ref="CREEM.Workflow.1" />
                <cm:Workflow ref="CREEM.Workflow.2" />
                <cm:Workflow ref="CREEM.Workflow.3" />
            </cm:Content>
        </cm:Data>

        <cm:Resource/>
    </cm:Project>
</cm:CIMI>

Notes

22.2 System Configuration instance — CREEM.SystemConfiguration.Sample.xml

A SystemConfiguration carries the DeviceTree — the runtime topology that binds device instances to communication links and IO ports. The sample shows a controller IPC with an Ethernet sub-tree (camera + UR5 cobot + Schunk gripper on IO) and a USB sub-tree (barcode scanner), plus a second controller PLC with IO-attached buttons and an LED.

<cm:CIMI xmlns:cm="http://creem.siemens.com/schemas/creem"
         xmlns="http://creem.siemens.com/schemas/creem"
         state="Alpha" version="0.0.1" lang="en-US">

  <cm:SystemConfiguration>
    <cm:Metadata>
      <cm:Namespace>SystemConfiguration.Sample.1</cm:Namespace>
      <cm:Name>SystemConfiguration.Sample</cm:Name>
      <cm:Version>1.0.0</cm:Version>
    </cm:Metadata>

    <cm:Data>
      <cm:Content>
        <cm:DeviceTree>
          <cm:DDInstance id="Controller.IPC.Unknown.1">
            <cm:Parent>
              <cm:Communication id="Ethernet">
                <cm:Parameter id="ipAddress"  value="127.0.0.1"/>
                <cm:Parameter id="portNumber" value="10000"/>
              </cm:Communication>
            </cm:Parent>
            <cm:Children>
              <cm:Communication id="Ethernet">
                <cm:DDInstance id="Camera.2D.Unknown.1">
                  <cm:Parent>
                    <cm:Communication id="Ethernet">
                      <cm:Parameter id="ipAddress"  value="192.168.0.1"/>
                      <cm:Parameter id="portNumber" value="20000"/>
                    </cm:Communication>
                  </cm:Parent>
                </cm:DDInstance>
                <cm:DDInstance id="Robotic.Cobot.UniversalRobots.UR5.1">
                  <cm:Parent>
                    <cm:Communication id="Ethernet">
                      <cm:Parameter id="ipAddress"  value="192.168.0.2"/>
                      <cm:Parameter id="portNumber" value="20000"/>
                    </cm:Communication>
                  </cm:Parent>
                  <cm:Children>
                    <cm:Communication id="IO">
                      <cm:DDInstance id="Gripper.Schunk.85.1">
                        <cm:Parent>
                          <cm:Communication id="IO">
                            <cm:Parameter id="ioType"   value="DO"/>
                            <cm:Parameter id="portName" value="I6,I7"/>
                          </cm:Communication>
                        </cm:Parent>
                      </cm:DDInstance>
                    </cm:Communication>
                  </cm:Children>
                </cm:DDInstance>
              </cm:Communication>
              <cm:Communication id="USB">
                <cm:DDInstance id="BarcodeScanner.Keyence.S2000.1"/>
              </cm:Communication>
            </cm:Children>
          </cm:DDInstance>

          <cm:DDInstance id="Controller.PLC.Unknown.1">
            <cm:Children>
              <cm:Communication id="IO">
                <cm:DDInstance id="Button.PushButton.Unknown.1">
                  <cm:Parent>
                    <cm:Communication id="IO">
                      <cm:Parameter id="ioType"   value="DI"/>
                      <cm:Parameter id="portName" value="I9.1"/>
                    </cm:Communication>
                  </cm:Parent>
                </cm:DDInstance>
                <cm:DDInstance id="LED.Unknown.1">
                  <cm:Parent>
                    <cm:Communication id="IO">
                      <cm:Parameter id="ioType"   value="DO"/>
                      <cm:Parameter id="portName" value="Q3.2"/>
                    </cm:Communication>
                  </cm:Parent>
                </cm:DDInstance>
              </cm:Communication>
            </cm:Children>
          </cm:DDInstance>
        </cm:DeviceTree>
      </cm:Content>
    </cm:Data>
  </cm:SystemConfiguration>
</cm:CIMI>

Modeling rules illustrated

22.3 Workflow instance — CREEM.Workflow.Sample.xml

The Workflow sample shows how MainWorkflow, compositors (Sequence, Parallel, If, Switch), decorators (Repeat, While, Retry, Timeout, IQC), Condition, sub-workflow references, and FBInstance definitions with Input / Output / Port / Parameter payloads fit together.

22.3.1 Main workflow body (compositor / decorator catalogue)

<cm:MainWorkflow id="Workflow.Main">
  <cm:Sequence>
    <cm:FBInstance ref="Siemens.RoboticInstruction.Robotic.MoveLinear.1"/>

    <cm:Parallel id="Parallel.1" endLogic="AND">
      <cm:Sequence>
        <cm:FBInstance ref="System.Delay.1"/>
        <cm:FBInstance ref="Siemens.RoboticInstruction.Gripper.GripperGrasp.1"/>
      </cm:Sequence>
      <cm:Sequence>
        <cm:FBInstance ref="Siemens.RoboticInstruction.Robotic.ReadDI.1"/>
        <cm:SubWorkflowInstance ref="SubWorkflow.Sample.1"/>
      </cm:Sequence>
    </cm:Parallel>

    <cm:SubWorkflowInstance ref="SubWorkflow.Sample.2"/>

    <!-- Condition -->
    <cm:Condition id="System.Condition.1"
                  expression="Siemens.RoboticInstruction.ReadDI.1.Output.Value == 1">
      <cm:Sequence>
        <cm:FBInstance ref="UserSkill.ScanBarcode.1"/>
        <cm:FBInstance ref="UserSkill.CheckICT.1"/>
      </cm:Sequence>
    </cm:Condition>

    <!-- Decorator.Repeat -->
    <cm:Repeat id="System.Decorator.Repeat.1" expression="15">
      <cm:Sequence>
        <cm:FBInstance ref="UserSkill.ScanBarcode.1"/>
        <cm:FBInstance ref="UserSkill.CheckICT.1"/>
      </cm:Sequence>
    </cm:Repeat>

    <!-- Decorator.While -->
    <cm:While id="System.Decorator.While.1"
              expression="UserSkill.ScanBarcode.1.Output.status == failed">
      <cm:Sequence>
        <cm:FBInstance ref="UserSkill.ScanBarcode.1"/>
      </cm:Sequence>
    </cm:While>

    <!-- Decorator.Retry -->
    <cm:Retry id="System.Decorator.Retry.1" expression="3">
      <cm:Sequence>
        <cm:FBInstance ref="UserSkill.ScanBarcode.1"/>
      </cm:Sequence>
    </cm:Retry>

    <!-- Decorator.Timeout -->
    <cm:Timeout id="System.Decorator.Timeout.1" value="30" unit="s">
      <cm:Sequence>
        <cm:FBInstance ref="UserSkill.ScanBarcode.1"/>
      </cm:Sequence>
    </cm:Timeout>

    <!-- Decorator.IQC -->
    <cm:IQC id="System.Decorator.IQC.1"
            expression="ScanBarcode.1.Output.status == true">
      <cm:Sequence>  <cm:FBInstance ref="System.Idle.1"/>  </cm:Sequence>
      <cm:Otherwise>
        <cm:Sequence><cm:FBInstance ref="System.Idle.2"/></cm:Sequence>
      </cm:Otherwise>
    </cm:IQC>

    <!-- Compositor.If -->
    <cm:If expression="Siemens.RoboticInstruction.ReadDI.1.Output.Value == 1">
      <cm:Then><cm:Sequence><cm:FBInstance ref="System.Idle.1"/></cm:Sequence></cm:Then>
      <cm:Else><cm:Sequence><cm:FBInstance ref="System.Idle.1"/></cm:Sequence></cm:Else>
    </cm:If>

    <!-- Compositor.Switch -->
    <cm:Switch parameter="Siemens.RoboticInstruction.MoveLinear.1.trajectory.point.1.velocity">
      <cm:Case value="100">
        <cm:Sequence>
          <cm:FBInstance ref="UserSkill.ScanBarcode.1"/>
          <cm:FBInstance ref="UserSkill.CheckICT.1"/>
        </cm:Sequence>
      </cm:Case>
      <cm:Case value="200"><cm:Sequence><cm:FBInstance ref="System.Idle.1"/></cm:Sequence></cm:Case>
      <cm:Default>
        <cm:Sequence>
          <cm:FBInstance ref="Siemens.RoboticInstruction.AGV.AGVMove.1"/>
        </cm:Sequence>
      </cm:Default>
    </cm:Switch>
  </cm:Sequence>
</cm:MainWorkflow>

Notes

22.3.2 FB instances with typed I/O

<cm:FBInstances>
  <cm:FBInstance id="Siemens.RoboticInstruction.Robotic.MoveLinear.1">
    <cm:PhysicalNode>DD.Robotic.UniversalRobots.UR5.1</cm:PhysicalNode>
    <cm:Input>
      <cm:Port id="trajectory">
        <Parameter id="point.1">
          <Parameter id="x">23.12</Parameter>
          <Parameter id="y">33.23</Parameter>
          <Parameter id="z">38.11</Parameter>
          <Parameter id="rx">180.00</Parameter>
          <Parameter id="ry">30.00</Parameter>
          <Parameter id="rz">90.00</Parameter>
          <Parameter id="acceleration">1200</Parameter>
          <Parameter id="velocity">250</Parameter>
          <Parameter id="duration">25</Parameter>
          <Parameter id="blending">36</Parameter>
          <Parameter id="space">Base</Parameter>
          <Parameter id="tool">Tool0</Parameter>
          <Parameter id="selected">true</Parameter>
        </Parameter>
        <!-- point.2, point.3, … : identical shape -->
      </cm:Port>
      <cm:Port id="reference"/>
    </cm:Input>
    <cm:Output>
      <cm:Port id="status"/>
    </cm:Output>
  </cm:FBInstance>

  <cm:FBInstance id="Siemens.RoboticInstruction.Gripper.GripperGrasp.1">
    <cm:PhysicalNode>DD.Gripper.Robotiq.S85.1</cm:PhysicalNode>
    <cm:Input>
      <cm:Port id="position" unit="mm">10.0</cm:Port>
      <cm:Port id="speed"    unit="mm/s">50</cm:Port>
      <cm:Port id="force"    unit="N">50</cm:Port>
    </cm:Input>
  </cm:FBInstance>

  <cm:FBInstance id="UserSkill.CheckICT.1">
    <cm:Input>
      <cm:Port id="port1" type="Any">$runURScript.OutputPort.status</cm:Port>
      <cm:Port id="port2" type="Any">$readDI.OutputPort.value</cm:Port>
      <cm:Port id="port3" type="Struct">
        <cm:Parameter name="count"     type="Number">100</cm:Parameter>
        <cm:Parameter name="workPiece" type="String">PCB</cm:Parameter>
      </cm:Port>
    </cm:Input>
    <cm:Output>
      <cm:Port id="port4" type="Any"/>
    </cm:Output>
  </cm:FBInstance>

  <cm:FBInstance id="System.Delay.1">
    <Input><Parameter id="delay" unit="ms">500</Parameter></Input>
  </cm:FBInstance>
</cm:FBInstances>

Modeling rules illustrated

22.4 FB Library instance — CREEM.FBLibrary.Default.xml

FBLibrary is a catalog artifact. Its UIInformation carries per-language section/FB display names and icons; its Data carries the technical wiring (FB id, type, XML tag, file location).

<cm:FBLibrary>

  <cm:Metadata>
    <cm:Namespace>CREEM.xmlLibrary.Instance</cm:Namespace>
    <cm:Name>FBLibrary</cm:Name>
    <cm:Version>1.0.2</cm:Version>
    <cm:Description>A collection of FBs</cm:Description>
    <cm:UUID>248F7A6E-C3d0-8b3E-b1C3-B4efEB0bbf8F</cm:UUID>
  </cm:Metadata>

  <cm:UIInformation>
    <cm:Content lang="en-US">
      <cm:Library id="defaultFBLibrary" displayName="FB Library" icon="Resource.defaultFBLibraryIcon">
        <cm:Section id="general" displayName="General">
          <cm:FunctionBlock id="System.Start" displayName="Start"/>
          <cm:FunctionBlock id="System.End"   displayName="End"/>
          <cm:FunctionBlock id="System.Stop"  displayName="Stop"/>
          <cm:FunctionBlock id="System.Abort" displayName="Abort"/>
        </cm:Section>
        <cm:Section id="logic" displayName="Logic">
          <cm:FunctionBlock id="System.Compositor.Parallel"
                            displayName="Parallel" displayNameEnd="End Parallel"/>
          <cm:FunctionBlock id="System.Condition"          displayName="Condition"/>
          <cm:FunctionBlock id="System.Decorator.Repeat"   displayName="Repeat"/>
          <cm:FunctionBlock id="System.Decorator.While"    displayName="While"/>
          <cm:FunctionBlock id="System.Decorator.Retry"    displayName="Retry"/>
          <cm:FunctionBlock id="System.Decorator.Timeout"  displayName="Timeout"/>
          <cm:FunctionBlock id="System.Compositor.IQC"
                            displayName="IQC" displayNameElse="Else"/>
          <cm:FunctionBlock id="System.Compositor.If"
                            displayName="If" displayNameEnd="End If"/>
          <cm:FunctionBlock id="System.Compositor.Switch"
                            displayName="Switch" displayNameEnd="End Switch"/>
        </cm:Section>
        <cm:Section id="dataLayer"          displayName="Data Layer"/>
        <cm:Section id="roboticInstruction" displayName="Robotic Instruction"/>
        <cm:Section id="endEffector"        displayName="End Effector"/>
        <cm:Section id="agvInstruction"     displayName="AGV Instruction"/>
        <cm:Section id="plcInstruction"     displayName="PLC Instruction"/>
        <cm:Section id="userSkill"          displayName="User Skill"/>
      </cm:Library>
    </cm:Content>
    <!-- A parallel <cm:Content lang="zh-CN"> block carries Chinese display names. -->
  </cm:UIInformation>

  <cm:Data>
    <cm:Content>
      <cm:Library id="defaultFBLibrary">
        <cm:Section id="general" isMandatory="true">
          <cm:FunctionBlock id="System.Start" type="Process"   xmlTag="Start"
                            emptyDefinition="true" visible="false"/>
          <cm:FunctionBlock id="System.End"   type="Process"   xmlTag="Start"
                            emptyDefinition="true" visible="false"/>
          <cm:FunctionBlock ref="System.Idle"  location="System.Idle.xml"/>
          <cm:FunctionBlock ref="System.Delay" location="System.Delay.xml"/>
          <cm:FunctionBlock id="System.Stop"   type="Process"  xmlTag="Stop"  emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Abort"  type="Process"  xmlTag="Abort" emptyDefinition="true"/>
        </cm:Section>

        <cm:Section id="logic" isMandatory="true">
          <cm:FunctionBlock id="System.Compositor.Sequence" type="Compositor"
                            xmlTag="Sequence" emptyDefinition="true" visible="false"/>
          <cm:FunctionBlock id="System.Compositor.Parallel" type="Compositor"
                            xmlTag="Parallel" emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Condition"           type="Decorator"
                            xmlTag="Condition" emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Decorator.Repeat"    type="Decorator"
                            xmlTag="Repeat"  expression="1"     emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Decorator.While"     type="Decorator"
                            xmlTag="While"   expression="false" emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Decorator.Retry"     type="Decorator"
                            xmlTag="Retry"   expression="1"     emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Decorator.Timeout"   type="Decorator"
                            xmlTag="Timeout" value="1" unit="s" emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Compositor.IQC"      type="Decorator"
                            xmlTag="IQC"     emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Compositor.If"       type="Compositor"
                            xmlTag="If"      emptyDefinition="true"/>
          <cm:FunctionBlock id="System.Compositor.Switch"   type="Compositor"
                            xmlTag="Switch"  emptyDefinition="true"/>
        </cm:Section>

        <cm:Section id="roboticInstruction">
          <cm:FunctionBlock ref="Siemens.RoboticInstruction.Robotic.MoveLinear"
                            isVest="true" location="Siemens.RoboticInstruction.Robotic.MoveLinear.xml"/>
          <cm:FunctionBlock ref="Siemens.RoboticInstruction.Robotic.MoveJoints"
                            isVest="true" location="Siemens.RoboticInstruction.Robotic.MoveJoints.xml"/>
          <cm:FunctionBlock ref="Siemens.RoboticInstruction.Robotic.ReadDI"
                            isVest="true" location="Siemens.RoboticInstruction.Robotic.ReadDI.xml"/>
          <!-- … further entries elided … -->
        </cm:Section>

        <cm:Section id="endEffector">
          <cm:FunctionBlock ref="Siemens.RoboticInstruction.Gripper.GripperGrasp"
                            isVest="true" location="Siemens.RoboticInstruction.Gripper.GripperGrasp.xml"/>
        </cm:Section>

        <cm:Section id="agvInstruction">
          <cm:FunctionBlock ref="Siemens.AGVInstruction.AGV.AGVMove"
                            isVest="true" location="Siemens.AGVInstruction.AGV.AGVMove.xml"/>
        </cm:Section>
      </cm:Library>
    </cm:Content>
  </cm:Data>

  <cm:Resource>
    <cm:Content id="defaultFBLibraryIcon" type="Icon" format="SVG">
      <!-- base64-encoded SVG icon (elided) -->
    </cm:Content>
  </cm:Resource>
</cm:FBLibrary>

Modeling rules illustrated

22.5 Device Library instance — CREEM.DeviceLibrary.Default.xml

DeviceLibrary is the device-side counterpart of FBLibrary. Its UIInformation is a hierarchical browser tree (Section / Section / DeviceDescription); its Data declares each entry's reference to a base DeviceDescription type plus the file that carries its full definition.

<cm:DeviceLibrary>
  <cm:Metadata>
    <cm:Namespace>CREEM.DeviceLibrary.Instance</cm:Namespace>
    <cm:Name>DeviceLibrary</cm:Name>
    <cm:Version>1.0.0</cm:Version>
  </cm:Metadata>

  <cm:Data>
    <cm:Content>
      <cm:Library type="DeviceLibrary" id="defaultDeviceLibrary">
        <cm:Section type="Category" id="PC">
          <cm:Section type="Category" id="SBC">
            <cm:DeviceDescription ref="Controller.SBC.Unknown"
                                  location="Siemens.DeviceDescriptions.Unknown.xml"/>
            <cm:Section type="Manufacturer" id="SBC.RaspberryPi">
              <cm:DeviceDescription id="Controller.SBC.RaspberryPi.400"
                                    ref="Controller.SBC.Unknown"
                                    location="Siemens.DeviceDescriptions.Unknown.xml"/>
              <cm:DeviceDescription id="Controller.SBC.RaspberryPi.300"
                                    ref="Controller.SBC.Unknown"
                                    location="Siemens.DeviceDescriptions.Unknown.xml"/>
            </cm:Section>
          </cm:Section>
          <cm:Section type="Category" id="IPC">
            <cm:DeviceDescription ref="Controller.IPC.Unknown"
                                  location="Siemens.DeviceDescriptions.Unknown.xml"/>
            <cm:Section type="Manufacturer" id="IPC.Siemens">
              <cm:Section type="Series" id="BoxPC">
                <cm:DeviceDescription id="Controller.IPC.Siemens.BoxPC.347G"
                                      ref="Controller.IPC.Unknown"
                                      location="Siemens.DeviceDescriptions.Unknown.xml"/>
                <!-- 547G / 647E / 647D / 847E / 847D / 1047 follow the same shape -->
              </cm:Section>
            </cm:Section>
          </cm:Section>
        </cm:Section>

        <cm:Section type="Category" id="Robot">
          <cm:Section type="Category" id="Cobot">
            <cm:DeviceDescription ref="Robotic.Cobot.Unknown"
                                  location="Siemens.DeviceDescriptions.Unknown.xml"/>
            <cm:Section type="Manufacturer" id="Cobot.UniversalRobots">
              <cm:DeviceDescription id="Robotic.Cobot.UniversalRobots.UR5"
                                    ref="Robotic.Cobot.Unknown"
                                    location="Siemens.DeviceDescriptions.Unknown.xml"/>
              <cm:DeviceDescription id="Robotic.Cobot.UniversalRobots.UR5E"
                                    ref="Robotic.Cobot.Unknown"
                                    location="Siemens.DeviceDescriptions.Unknown.xml"/>
            </cm:Section>
          </cm:Section>
        </cm:Section>

        <cm:Section type="Category" id="Gripper">
          <cm:DeviceDescription ref="Gripper.Unknown"
                                location="Siemens.DeviceDescriptions.Unknown.xml"/>
          <cm:Section type="Manufacturer" id="Gripper.Schunk">
            <cm:DeviceDescription id="Gripper.Schunk.32-068" ref="Gripper.Unknown"
                                  location="Siemens.DeviceDescriptions.Unknown.xml"/>
          </cm:Section>
          <cm:Section type="Manufacturer" id="Gripper.Robotiq">
            <cm:DeviceDescription id="Gripper.Robotiq.85"    ref="Gripper.Unknown"
                                  location="Siemens.DeviceDescriptions.Unknown.xml"/>
          </cm:Section>
        </cm:Section>

        <!-- Camera / AGV / BarcodeScanner / TorqueWrench follow the same pattern -->
        <cm:Section type="Category" id="UserDevices"/>
      </cm:Library>
    </cm:Content>
  </cm:Data>
</cm:DeviceLibrary>

Modeling rules illustrated

22.6 Device Description instance — CREEM.DeviceDescriptions.Unknown.xml

A DeviceDescription declares one device archetype (IPC, SBC, PLC, PushButton, LED, Cobot, Gripper, Camera, AGV, BarcodeScanner, TorqueWrench, …). The minimal "Unknown" template below shows the canonical four-section shape plus the upstream/downstream Communication capability declaration.

<cm:DeviceDescription id="Controller.IPC.Unknown">
  <cm:Metadata>
    <cm:Namespace>Controller.IPC.Unknown</cm:Namespace>
    <cm:Name>IPC.Unknown</cm:Name>
    <cm:Version>1.0.0</cm:Version>
  </cm:Metadata>

  <cm:UIInformation>
    <cm:Content lang="en-US">
      <cm:DisplayName>IPC Unknown</cm:DisplayName>
      <cm:Description>Unknown industrial PC</cm:Description>
      <cm:Icon ref="Resource.defaultIcon"/>
    </cm:Content>
    <cm:Content lang="zh-CN">
      <cm:DisplayName>未知工控机</cm:DisplayName>
      <cm:Description>未知工控机</cm:Description>
      <cm:DeviceType id="IPC" displayName="工控机"/>
    </cm:Content>
  </cm:UIInformation>

  <cm:Data>
    <cm:Content>
      <cm:DeviceType id="IPC"/>
      <cm:Parent>
        <cm:Communication ref="Ethernet"/>
      </cm:Parent>
      <cm:Children>
        <cm:Communication ref="Ethernet"/>
        <cm:Communication ref="USB"/>
        <cm:Communication ref="SerialPort"/>
        <cm:Communication ref="IO"/>
      </cm:Children>
    </cm:Content>
  </cm:Data>

  <cm:Resource>
    <cm:Content id="defaultIcon" type="Icon" format="SVG"><![CDATA[ … ]]></cm:Content>
  </cm:Resource>
</cm:DeviceDescription>

Modeling rules illustrated

22.7 Project deployment package — CREEM.Project.Deployment.json

For runtime download, a project is shipped as a JSON envelope that bundles each XML/source file as a base64 payload:

{
  "creemDeployment": {
    "@version": "0.0.1",
    "@lang":    "en-US",

    "project": {
      "systemConfiguration": {
        "fileName": "CREEM.SystemConfiguration.xml",
        "base64":   "…(base64 of the SystemConfiguration XML)…"
      },
      "workflows": [
        { "fileName": "CREEM.Workflow.1.xml", "base64": "…" },
        { "fileName": "CREEM.Workflow.2.xml", "base64": "…" }
      ],
      "functionBlocks": [
        { "id": "Atlas.TorqueWrenchSkill.ScrewFastening",
          "fileName": "Atlas.TorqueWrenchSkill.ScrewFastening.py", "base64": "…" },
        { "id": "Keyence.BarcodeSkill.ScanBarcode",
          "fileName": "Keyence.BarcodeSkill.ScanBarcode.py",        "base64": "…" }
      ]
    }
  }
}

This envelope is the on-the-wire form of a deployable project: an authoring tool produces the XML files described in §22.1 – §22.6 and the FB source files, then base64-packs them into a single JSON for the runtime to unpack and validate against the schemas in Appendix H.

Two source XML files in instance/ — CREEM.DeviceDescriptions.Unknown.xml (~600 lines of repeated four-section archetypes) and the full CREEM.FBLibrary.Default.xml icon (an embedded base64 SVG) — are not reproduced here in full; only one representative archetype and one elided icon are shown.

23. References

Ref. Standard
[1] GB/T 5271.1-2000 Information Technology — Vocabulary — Part 1: Basic Terms
[2] GB/T 11457-2006 Information Technology — Software Engineering Terminology
[3] GB/T 15969.3-2017 Programmable Controllers — Part 3: Programming Languages
[4] GB/T 16656.1-2008 Industrial Automation Systems and Integration — Product Data Representation and Exchange — Part 1: Overview and Fundamental Principles
[5] GB/T 18391.1-2026 Information Technology — Metadata Registry System (MDR) — Part 1: Framework
[6] GB/T 18793-2002 Information Technology — Extensible Markup Language (XML) 1.0
[7] GB/T 19769.1-2022 Function Blocks — Part 1: Structure
[8] GB/T 23703.2-2010 Knowledge Management — Part 2: Terminology
[9] GB/T 25105.3-2025 Industrial Communication Networks — Fieldbus Specifications — Type 10: PROFINET IO Specification — Part 3: PROFINET IO Communication Profile
[10] GB/T 26243.1-2026 Information Technology — Relay Multicast Control Protocol (RMCP) — Part 1: Framework
[11] GB/T 32854.3-2020 Automation Systems and Integration — Advanced Control and Optimization Software Integration for Manufacturing Systems — Part 3: Activity Models and Workflows
[12] GB/T 33863.3-2017 OPC Unified Architecture — Part 3: Address Space Model

Note: This is a full English technical-manual-style Markdown version of the source standard, reframed as CREEM, the common behavioral model behind Workflow Canvas (WFC), while preserving the source structure, definitions, tables, classifications, namespaces, and execution rules, and expanding them into a more implementation-oriented handbook.

Document Version: 2.1.0

Revision: 10-08-2026

Author: Zhen Hua, Zhou (SIEMENS)