The Sequencer Basic Block can be used to make new Sequencer blocks using the No-Code approach. This provides a quick way for adding custom reusable sequential steps with desired control behavior to your library.

The BasicBlockHelpers contains a set of preconfigured blocks with one or two states or States with pre-added transitions. It is also possible to build regular cyclic state machines with the CyclicStateMachine pre-configured in BasicBlockHelpers or conditional execution control branching (if-else branching for regular operators) with the IfElseBranching pre-configured in BasicBlockHelpers.

These pre-configured blocks can be used to jumpstart your own custom blocks.

To understand Sequencer base consepts, read also the Introduction page.

Basic Block Overview

This overview describes the Basic Block's main configuration elements that can be added from resources.

• Argument: Represents an argument visible on the block API, that is routable or writable by events. Use it to define input data for your sequencer block.
• ArgumentOut: A multi-source routable output argument shown on the block API, readable by output events or routable by other blocks. Use it to define output data from your sequencer block.
• InternalArgument: An internal argument not shown on the block API, that is writable by events. Use it for internal data handling within the block.
• Sequencer.InternalArgumentOut<T>: An internal multi-source routable output argument not shown on the block API, readable by events. Use it for internal data output.
• EventIn: Used to receive messages as events and trigger state machine processing by default. Essential for handling incoming data that must be listed in EventIn Data property.

  Note: Only Arguments listed in Data property will be updated from the data in the recieved message event!

• EventOut: Used to send messages and argument data. Useful for emitting results from all argument values in the block sent arguments must be listed in EventOut Data property

  Note: Only Arguments listed in EventOut Data property will be added to the message event that is sent!

• EventInOut: Receives and forwards messages as events, triggering state machine processing. Used when a Input event must always be forwarded as a Output event as it is.
• RunOperation: Refers to an Operation to run when entering a state. Use it to link operations to specific states.
• Operation: A container for operator logic with a Done event emitted after each operation run. Use it to define regular CDPOperator based logic or math operations ran by states when they are entered using RunOperation to connect.
• RunScript: Runs short ChaiScripts for calculations when entering the sate it is added to. Use it for using scripting to do logic within the block instead of CDPOperator based logic.
• State: Represents a state in the sequencer block. Use it to define different stages of your sequence.
• StateTransition: Defines transitions between states. Use it to control the flow of your sequence. StateTransition is connected to its target State.

Execution Control Chart (ECC)

The block's behavior is controlled by states making up the Execution Control Chart (ECC). Transitions between states may require input events and/or transition condition evaluating to true allowing transition to next Sequencer - State. The transition condition is held by transition Value property.

The Basic Block is by default processed when input event arrives. The Sequencer input events are consumed when they are required by a transition and can only trigger one such transition during the process run.

Transitions without conditions will be taken immediately. The exact transitioning behavior can be controlled by TransitionMode property. The total number of transitions that can be taken during the process run is also limited by TransitionLimit property. Each StateTransition is connected via Push routing to its target State where the transition will be taken.

When ECC transitions to new Sequencer - State it will process operations linked to that state. If those operations produce output events they are emitted and sent when connected to block output events.

The ECC state can at any time be overridden by setting OverrideState and OverrideStateMachine properties.

Examples

To better explain the Basic Block behavior in different ProcessOn modes some example blocks are provided.

Simple Block

The following example represents the default Basic Block setup where processing is only triggered by events and all possible transitions are taken each time processing occurs.

The block executes either BigOp or SmallOp operation depending on the value of DataIn, each time EventIn0 arrives and updates DataOut with the value from the executed block. Regardless of what operation is executed it always emits EventOut0.

The slowed-down diagram video clip shows Event-based processing. Note that the actual processing happens during the same message handling callback and for any external observer at the same time.

The processing of the block starts when input event EventIn0 arrives. At event arrival values for all data inputs are synchronized. Currently, the event itself does not contain any data to over-assign data inputs.

EventIn0 is connected to two possible transitions exiting the initial Null state. Both transitions also have a condition expression that gets evaluated. Because the value of DataIn is currently 7, DataIn <= 10 evaluates to true, causing the ToSmall transition to be taken and EventIn0 to be consumed.

On entering the WorkSmall state all operations linked to the state get executed. RunOp0 run operation runs the SmallOp operation.

The SmallOp is processed, its data synchronized to connected output arguments and then Done event is emitted. As the Done event is connected to EventOut0 output event, it also gets emitted.

After processing linked operation in WorkSmall state, its transition is evaluated and taken as it has no additional conditions set.

The Basic Block arrives back at Null state, there is no operation to execute and all transitions require {Sequencer - EventIn} {event} EventIn0 that was already consumed.

At this stage, the processing of the Basic Block stops and the next event is needed to trigger processing.

Simple Wait Block

The following example represents a Basic Block setup where processing is triggered both by events and parent cycles with all possible transitions taken each time processing occurs. This Basic Block requires C flag to also be set in ProcessOn property to periodically evaluate the Wait.Time > 3 in transition condition.

The block executes Operation three seconds after EventIn0 arrives when Enabled is also true at the time and emits EventOut0 when done. If the second EventIn0 arrives during the waiting period, it will be ignored.

The processing of the block starts when input event EventIn0 arrives while the Enabled is also true. When this occurs ToWait transition is taken.

In Wait state, the event processing stops as the ToWork transition is not possible to traverse due to the Wait.Time (<state_name>.Time property of Wait state) not being greater than 3 seconds yet.

At each parent cycle, the expression Wait.Time > 3 is evaluated and after 3 seconds it will become true, allowing the ToWork transition to be taken.

Finally, on entering the Work state the operations linked to the state are executed. Mul2 operation multiplies input data with 2 and provides output data. The operation also emits Done event that in turn emits EventOut0.

The ECC transitions back to the Null state and will remain there until the next EventIn0 is received.

Properties

Basic Function Block has properties to set up desired behavior and get information about its operation.