Whether you are familiar with control system theory or not, the basic concept can be understood by considering the following: A simple control system looks kind like Figure 1.  This picture shows a simple closed-loop control system with its constituent parts.


|                                                                            |
|                   _                           +----------+                 |
|                 /   \  Error   +-------+      | Actuator |-->              |
|  Command------>| Dif |-------->| Plant |----->|    OR    |--> E F F E C T  |
|                 \ _ /          +-------+      |  Output  |-->      |       |
|                   ^                           +----------+         |       |
|                   |                                                |       |
|                   |                 <--Feedback                    |       |
|                   +------------------------------------------------+       |
|                                                                            |
Figure 1 - Simple, Closed-Loop Control System

It consists of a command input into a "difference summer" whose output feeds through an amplifier ("plant") to an actuating element.  A feedback signal comes from the "effect" or output and also feeds into the summer.  The difference between the command and feedback inputs generates an error signal which drives the "plant" such that this difference is minimized.  At equilibrium, the feedback equals the command and the plant drives the output/actuator to a stable level.  This type of system is considered a simple, non-adaptive, first-order, linear control system.  So how does this apply to robots?

Suppose one thinks of a robot as a collection of control systems: a group of complex, adaptive, self-governing control systems.  In a larger robot, there are probably multiple control systems subordinate to a top-level primary control system.  These might be implemented in a multiprocessor-based or multitasking-based architecture.  Regardless, subprocessors or processes would probably handle things like the motor drive system, sensor manipulation and data acquisition, voice input and output, arms, actuators, or other manipulators, navigation, etc., thus freeing the top-level controller for primary goal functions.  The top-level controller generates only high level commands in an open loop fashion to the subsystems, and may expect only acknowledgment that they are being carried out without concern for their respective details.  The closed-loop controls of the subsystems might follow the scheme illustrated in Figure 1 but the top level runs pretty much open loop, or does it?

The command input is still there but is generated by software as a result of the robot's primary goal(s).  Systems that affect the robot's environment such as its manipulators, or change the robot's situation in its environment such the motors, are like the "plant" and actuator output.  The sensors and related subprocesses or processors comprise a complex feedback signal (system).  The processing in between these elements comprises the "difference summer" or error computer.  Therefore the control system (robot's programming) responds to its environment (sensors), drives itself (moves, manipulates, whatever) to some stable, minimum error" state.  This would make a control system that does not accept a direct external command input, but applies "codified knowledge" about how to interact with the world to generate its own commands based on its sensory inputs and programmed goals.  Equilibrium is achieved whenever the robot is doing what its sensors say it should be doing.  Error or non-compliance would occur as the robot gets to this equilibrium state, or as new sensory input occurs, causing it to execute other maneuvers intended to achieve its primary goal (finding a target) or possibly sub-goals (like getting out of a boxed-in corner).  In the case of sumo, the robot might drive toward certain sensory input (such as forward contact with an opponent) and then drive hard straight ahead (to push this contact out of the game ring).  Figure 2 is an attempt to illustrate of this type of system.  Note that the elements look a little different and the decision-making components are hidden inside the microcontroller.


|                                                                            |
|       .........................................................<           |
|       :                                                                    |
|     Sensor-------\                                                         |
|                    \        Software--->Command             Motor          |
|     Sensor-----------\                     |                  |            |
|                        \    +--------------V--+         +-----------+      |
|     Sensor----------------->| Microcontroller |-------->| Motor I/F |      |
|                        /    +-----------------+         +-----------+      |
|     Sensor-----------/                                        |            |
|                    /                                        Motor          |
|     Sensor-------/                                                         |
|       :.........................................................<          |
|                                                                            |
|                                                                            |
Figure 2 - An adaptive, self-governing control system (i.e. Robot)

One might even extrapolate analogies to P-I-D (Proportional-Integral-Derivative) control, though this might be stretching things a bit so bear with me.  Please remember that I am not dictating how things must be, but only an idea I have about how a robot's behavior could be viewed or analyzed.  This discussion is intended primarily to provide food for thought.


The "Proportional" term or gain might imply how intensively the robot attempts to minimize the "error" in the output drive loop.  The system gain might cause moderate behavior until the sensors detect a situation that is one of the robot's goals such as finding the opponent.  This in turn initiates a heightened (or higher gain) behavior.  For example, initially the robot might amble about slowly until a target is spotted at which time it moves more quickly toward it.  Or once contact with an opponent is detected, high power drive might be initiated.


The "Integral" term or cumulative error suggests a continuous summing of the existing error into the drive to the actuators in an attempt to minimize the steady-state error.  Also, the integral term causes some output even though the robot sensors may not be calling for a specific behavior.  For example, if the robot's primary goal is sumo behavior, it might do something to try to find its opponent, rather than simply sitting and waiting for something to come along.  This stationary behavior used to be legal in competition, but the rules have changed to required periodic movement during a round.  As a result, the robots must move some, perhaps actively seeking out the opponent.


The "Derivative" term implies a sensitivity to rate-of-change in the error.  In other words, the robot might keep track of how quickly it is (or is not) achieving its goal(s).  This might modify the behavior over time by say increasing power to the motors once the opponent is detected or to help speed up searching if nothing is found after say 90 seconds.  Or the ranging system might expand its envelope over time if no close targets are acquired.

These illustrations aren't intended to be definitive or the final word on this subject, just speculative suggestions.  The main point is that the principles of a closed-loop control system can be applied to robotics in one form or another.  Since a simple robot program probably consists of a looping structure that reads the sensors (or waits for an interrupt from them), decides on a behavior, and executes that behavior, how different is this from a control system?  In fact fuzzy logic (past Encoder article), with its rule-based control scheme, fits even better.  But that is a subject for another article.  In an event-driven environment, this situation might be a lot different, but most simple controllers (BB1, BB2, BS1, BS2, etc.) run linear programs that follow this basic format.

Back to main article