Abstract

The Supervisory Control Theory of Discrete Event Systems (DES) provides procedures to design supervisors to control plants
modeled as DES. The computed supervisor issues control commands to ensure design specifications, such as safety constraints, are met. In the supervisor design process, the plant and design specification models are used to obtain the supervisor in the form of a DES. In this approach, the control commands are
effectively pre-calculated before implementation; thus the approach is known as Offline Supervisor Design. The challenge associated with this method is that it requires large onboard memory for supervisor (due to typically large DES models involved). Such large memory is not available on embedded systems.
In order to make the implementation of supervisory control feasible for embedded systems, an approach is proposed in the literature where at any given time, supervisory commands are computed on-the-fly based on models for plant and specifications covering a small window into the future (i.e., lookahead window). This method needs a significantly smaller onboard memory. As a result, however, frequent control command computation is needed. This could pose a implementation challenge since control commands must be computed after every new event in the plant. Sometimes two (or more) consecutive events could occur in rapid succession in the plant and there may not be enough time to compute control commands. To mitigate this problem, an approach has been proposed called Lookahead Supervision with Buffering in which commands are computed and buffered in
advance for a window.
This thesis makes contributions to the underlying theory of lookahead policy with buffering. Specifically it proposes a method to use the timed model of the plant to compute the timing information of event sequences. This timing information is used in choosing the buffer size and was previously obtained experimentally. The thesis also develops a method for computing plant and specification models over the loakahead window that is suited for computer coding.
The thesis also implements the lookahead supervision with command buffering. To study the feasibility of implementation and the complexity of proposed controller in detail, a two-degree-of-freedom solar tracker equipped is used as plant. The goal is to generate supervisory commands for maneuvering the solar tracker to find a bright light source for charging battery. For implementation, all supervisory control algorithms are written in C language for faster computation time. Look-ahead policy with command buffering is designed and implemented. In several tests, the supervisor successfully calculates on-line the control commands in a timely fashion and maneuvers the solar tracker to the bright source while respecting design specifications. The experimental results show that the timing information calculated with the proposed method based on timed model match the actual plant behavior. Furthermore, the experiments demonstrate that the length of command buffer (as design parameter) can be used to achieve a compromise between onboard memory requirement and computational power.