Diagram Controller

Controller

A Controller is a reusable control-behaviour type - the unit that defines the commands, states, transitions, interlocks and messages for one kind of device or function. It is instantiated many times as ControllerInstances in the tree and exposes its behaviour through a public interface, a per-instance interface and a private internal interface. A project controller usually extends a library base controller and adds only its specific behaviour.

class Controller extends NamedResource, AControllerDescription, AnnotableComment, DatatypeLibraryOwner, RootVariableLibrary, RootVariableName, AOoDomainRoot, ACallingBaseElement, AResourceWithType

ControllerInterface

A ControllerInterface is the shared public contract of a controller family: the commands, public data, hardware I/O and declared states that every implementing controller exposes and that a parent uses to interact with it. One interface can be reused by several sibling controllers.

class ControllerInterface extends NamedResource, AnnotableComment, DatatypeLibraryOwner

InterfaceLocal

An InterfaceLocal is the private internal container of a controller: its local variables, message definitions, function blocks, interlock definitions, simulation and helper methods - everything not visible from outside. It is the internal member of the controller's public / per-instance / local interface triad.

class InterfaceLocal extends Resource, AnnotableComment

InterfaceSpecific

An InterfaceSpecific holds a controller's per-instance public data and instance I/O - the values and pin mappings that differ from one ControllerInstance to another. It complements the ControllerInterface, which is the behavioural contract shared by all instances.

class InterfaceSpecific extends Resource, AnnotableComment, AInterfaceSpecific

Statemachine

A Statemachine defines the behaviour of a Controller as a finite state machine: its states, the transitions between them, and the initial entry point. A Controller has at most one statemachine.

class Statemachine extends AStatemachine, AStatemachineStart, RootVariableName, ASmDecorator, AJunctionProperty

AbstractMessageReactionFunctions

abstract class AbstractMessageReactionFunctions extends Resource

VariableLibrary

class VariableLibrary extends AVariableLibrary

ControllerInstance

A ControllerInstance is a Controller placed in the ControllerTree under a Level. It represents one concrete occurrence of a controller type, carrying its instance-specific attributes and the wiring to its child instances.

class ControllerInstance extends AnnotableComment, RangeChildFieldRef, BaseTreeElementInstance

ControllerLogbook

The controller logbook contains all elements of a controller to be logged.

class ControllerLogbook extends NamedResource, ANotAvailableOnS7Tia

AVariableLibrary

abstract class AVariableLibrary extends NamedResource, AnnotableComment, DatatypeLibraryOwner, AAutoPrefix, AOoDomainRoot

AStatemachine

abstract class AStatemachine extends Decorator, AnnotableComment

StatemachineExtension

A StatemachineExtension defines a controller's statemachine by building on an inherited base statemachine instead of from scratch. It reuses the base lifecycle and adds or overrides only the parts specific to this controller.

class StatemachineExtension extends AStatemachine, AJunctionProperty

StateOverride

A StateOverride re-declares a state group inherited from a base statemachine so a controller can extend it - adding sub-states, transitions or replacement lifecycle code - without redefining the whole machine.

class StateOverride extends AStateExtension, Statemachine

ControllerActions

ControllerActions is a controller's container for cyclic code that runs outside the statemachine: a one-time init hook and hooks that run before and after the states each cycle, plus not-exist behaviour. Controllers without a statemachine, such as I/O and driver controllers, do their whole job here.

class ControllerActions extends Resource

Function

abstract class Function extends Resource

UserObjectLink

A UserObjectLink is the type-level declaration on a Controller that names which shared UserObjectInterface the controller's code may access. The matching instance-level binding is a UserObjectLinkInstance.

class UserObjectLink extends NamedResource

ChildIterator

A ChildIterator is an indexed set of homogeneous children on a controller that all share one interface. It is used when a controller has a variable number of identical children, which it commands by index and can aggregate values across.

class ChildIterator extends Resource

ChildIteratorData

class ChildIteratorData extends Resource, ASubFieldSelector

AStateExtension

abstract class AStateExtension extends TargetState

StateExtension

The state that is extended basically remains as it is. It can simply be extended by function or transitions. It is also possible to overwrite single functions or transitions. Further additional states and junctions can be created.

class StateExtension extends AStateExtension, AJunctionProperty

StateBase

abstract class StateBase extends TargetState, AState

NotExistBehaviour

This class defines the behaviour of statemachine if controller exist flag is false. Without any definitions, native single answer implementation is active.

Use singleAnswerOverwrite definition to change single answer behaviour dependent of requested command.

Define a function to implemement another specific behaviour during single answer mode.

class NotExistBehaviour extends Resource

UserObjectLinkInstance

A UserObjectLinkInstance is the instance-level binding on a ControllerInstance that connects the controller's UserObjectLink to a placed UserObjectWrapper, wiring this instance to the tree-global blackboard.

class UserObjectLinkInstance extends Decorator

UserObjectInterface

A UserObjectInterface is a shared typed data structure that acts as a blackboard for cross-hierarchy data sharing - data exchanged outside the parent / child path. Each producing controller writes its own slot, and any controller with a link can read the whole structure.

class UserObjectInterface extends NamedResource, DatatypeLibraryOwner, AnnotableComment

AUserObject

abstract class AUserObject extends NamedResource, AnnotableComment

UserObject

class UserObject extends AUserObjectInterface, APlatformUserObject

UserObjectWrapper

A UserObjectWrapper is the single placed instance of a UserObjectInterface, parented to a Level so the shared blackboard is globally addressable in the tree. Controller instances bind to it to read and write the shared data.

class UserObjectWrapper extends AUserObjectInterface

GlobalVariable

class GlobalVariable extends BaseArrayVariable, InterfaceOptions