The result of the modeling, specification and synthesis approach of the previous chapters is a controller in the form of an automaton. This controller is usually meant to be implemented in a computer, and in the very common special case that the controller is to control a manufacturing system, that computer is a programmable logic controller (PLC). Thus, implementation is often a matter of implementing an automaton in one of the PLC programming languages ladder diagram (LD) or sequential function charts (SFC).
Though the supervisory control theory (Ramadge (1987), Wonham (1987)) that the approach in the previous chapters build upon has for over a decade received substantial attention in academia, still very few industrial applications exist. Balemi (1992) and Brandin (1996) among a few others describe applications, but industry has by no means accepted formal methods in general, and the SCT in particular, on a larger scale.
As Balemi (1992) points out, the main reason for this seems to be a discrepancy between the abstract supervisor and its physical implementation. There are very few guidelines for how to implement the controller, once the abstract supervisor model has been calculated. The step to a physical implementation is not necessarily straightforward given a state-machine solution to the control problem. This is specifically noticeable when the implementation is supposed to be based on programmable logic controllers (PLCs), as is the case with many manufacturing systems. The asynchronous event-driven nature of the supervisor is not straightforwardly implemented in the synchronous signal-based PLC.
The problems can be dissected into the following main problem classes.
1. Signals and events. The SCT considers events that have symbolic values and occur asynchronously at discrete instances of time. The PLC-world handles (in our case) boolean valued signals, the values of which are updated synchronously. Merely regarding the rising and falling edges of the signals as the events does not resolve all problems. Furthermore, in the synchronous signal-based PLC-world several events can occur simultaneously. Since this violates a fundamental assumption of events, it obviously introduces complications.
2. Causality. The SCT assumes that the plant generates all events, and that the supervisor dynamically disables events that the plant might otherwise have generated. In this way, the supervisor controls the plant to stay within the specification. This abstraction considerably simplifies the theory. However, in practice, the signals in the plant change values as responses to signal-changes initiated by the PLC. Thus, the concept of causality cannot be avoided in the implementation; we have to answer the question “who generates what?”.
3. Choice. The supervisor is generally required to allow the plant the largest possible amount of freedom in its event generation; the supervisor is supposed to be minimally restrictive. This means that the supervisor includes alternative paths that the plant is supposed to choose between. However, when the supervisor generates some signal-changes, it may have to choose between several alternatives in a single state. Depending on the order of the implementation internally in the PLC, different choices will be made. In fact, for each state with alternatives the same choice will always be made. Therefore, those choices have to be made explicitly by the programmer. Deciding the choice to make is by no means trivial, and beyond the scope of this paper. The point we are making is that if we do not choose the sequential execution of the program within the PLC will make the choice for us.
4. Inexact synchronization. Originally, Ramadge (1987), the supervisor consisted of an automaton together with a state feedback map that disabled events according to the current supervisor state. However, Kumar (1991) showed that the supervisor plant interaction can be modeled by synchronization, a useful abstraction that significantly simplifies the SCT. In real life, though, and especially in the PLC-world, exact synchronization does not exist. Due to time delays and the periodic updating of the input signals, a supervisor implemented in a PLC cannot execute in exact synchrony with the plant.