This blog post is about a specialized composite pattern. It allows us to work with a hierarchy of objects (like an n-tree structure) in a uniform way. By designing a tree node that can execute operation modes and manage any number of child nodes, we can traverse all tree elements in one call.
The machines we program all have a hierarchical structure (see Figure 1).
A tiresome topic with the machines are the operating modes, therefore these will now serve as an example. The example is very simplified and incomplete because it is only meant to explain a principle, and a complete example would go beyond the scope of the blog post.
The machine has three stations: one infeed, one outfeed and one press station.
Since a picture is worth a thousand words, take a look at Figure 2. I have only drawn the structure of the inlet to outline the tree structure. The other stations have been left out.
We build a tree node that can execute an operation mode and can have any number of children. Furthermore, the node should call the corresponding operation mode for all children nodes, so that we get a traverse call over all tree elements. The calls of the corresponding operation mode should be done via an interface that a client can call (operation mode handler and parent node).
When calling the constructor (FB_init), the parent node should be passed, the child node calls the addChildNode method with itself. This way we save attachment methods, and the declaration structure also reflects the tree structure (ease of use and good readability). The class structure is shown in Figure 3, and the idea of communication is indicated in Figure 4.
In the introduction, I talked about how this is a specialized form of the composite pattern. The classic composite pattern distinguishes between nodes and leaves, i.e. like a folder structure there is the folder (root node) which contains files (leaves) and subfolders (nodes). A folder cannot be a file at the same time. In our example, however, each node can be a leaf and can also contain nodes and leaves.
For the implementation of the example, our cinnamon framework libraries are needed. You can find them in our Style Guide.
The example uses CNM_AbstractObject, CNM_RetrunTypes,
CNM_Collections, CNM_State-Machine-Lib,
CNM_CollectionInterfaces, and CNM_CycleManagerInterface.
As always, we start with the interfaces. We need the three interfaces INodeApi, INode and INodeBehavior. The structure of the interfaces can be seen in Figure 5.
INodeApi
INode
INodeBehavior
First, we implement the three delegates for Automatic, Homing and Manual, because these are needed for our AbstractNode. The structure of the delegates can be seen in Figure 6.
AutomaticBehavior
HomingBehavior
ManualBehavior
Now the abstract node can finally be implemented, and with it the core of our concept. There are actually three methods that are important to understand.
The constructor (FB_init), because here our tree structure is built.
The protected method handleMode, because it manages the execution and return values of the own node and the child nodes.
The property stopRequest, because it shares a stop request with all the children.
Now if I want to create a class for the machine, a station, a function group or a device, that class just needs to inherit from AbstractNode. Then I can just add the class to our hierarchy. For functionality of the node, the methods runAutomatic, runHoming, runManual are overridden, if needed. Figure 7 summarizes the structure of AbstractNode again.
Now we need a client that tells the tree what to do. This is our operation mode handler. In our example, we assume that the opmode is an unsigned short integer that comes by magic from the HMI. As said before, the example is incomplete. The operation mode handler should get a node and make the node do what needs to be done.
For readability, we build an enumeration which represents the different operation modes.
OpMode enumeration
Class OperationMode
In summary, you can find our client in Figure 8.
Don’t worry, I’m not going to implement a machine here, I’m just going to show you what it might look like.
Infeed
Machine
Main
The example shows very well how easy it is to build and use hierarchical compositions, if they provide the same methods/operations. The calls do not take longer than if you put each call in the main, just so it reads nicely because it reflects the structure of our machine.
