First, a little history. The electromechanical relay, discussed in the previous chapter, was originally invented to extend telegraph signals. The weakening DC signal from the previous station was applied to the coil of a relay in the receiving station, which would clatter its contacts with dots and dashes, sending the signal down line with new energy. A relay is called a relay because it “relayed” telegraph signals in this manner. About the same time use of the telegraph was becoming widespread, George Boole developed a mathematical system of logic based on the simple concept of true or false. It didn’t take long for the relay, which has two states – on or off – to be combined with the Boolean system of logic – true or false – to produce the first electromechanical computers based on the binary numbering system. It might take a few hundred relays to do a simple calculation and several thousand for a complex algorithm. One of the first such computers, the Mark 1, built at Harvard to assist the Manhattan Project, had 3500 relays among its 700,000 other electromechanical parts. Despite the complexity of these rudimentary computers, they were rapidly adopted by postwar manufacturers to automate machinery and processes on the production line.

But there were serious drawbacks to relay logic systems. First of all, they were power hungry. Those coils needed to be fed, and the signals moving between their contacts needed power too. And, like any mechanical device, they were prone to breakdowns. But the biggest problem was that their programming was hardwired. To make a simple change to a program meant dragging out the soldering iron or screwdriver and moving wires around. By the late 1960s, automakers, with their yearly model changes, were looking for a better way. In 1968, the Hydra-matic division of General Motors wrote the specification for a solid state version of a relay logic control system and Bedford Associates, a small company in Bedford, Massachusetts produced the winning proposal. Their device, the Modular Digital Controller (MODICON), became the first programmable controller. (In the 1980s the description was changed to programmable logic controller to avoid confusion with the burgeoning personal computing market.)

What Is a PLC?

A programmable logic controller is simply a device designed specifically for the control of machinery and processes. It is a specialized computer which has been hardened for the industrial environment to resist shock, vibration, humidity, and other vicissitudes found on the factory floor. It is a direct replacement for electromechanical relays, timers, and counters. In addition, PLCs are typically provided with onboard power supplies and terminal blocks to simplify installation.

Advantages of PLCs

As solid-state devices, PLCs are inherently more reliable than the electromechanical relays they replaced. The lifecycle for PLCs is five to ten years, and many have been in service far longer. PLCs are also significantly cheaper than relays; even a small PLC can provide the equivalent of hundreds of relays, timers, and counters in a single unit. Modern PLCs also provide features the relay systems simply could not touch, including motion control, PID loops, onboard communication and more. The list of features added to PLCs seems to grow daily. But the single, most important advantage of PLCs is that they are programmable – rather than hardwired.

Types and Sizes of PLCs

There are scores of manufacturers offering PLCs, and each manufacturer may have a dozen models from which to choose. But for simplicity, we can sort PLCs into a few broad categories. Originally, PLCs were divided into analog and digital, but that distinction has blurred over time. Analog PLCs were designed to handle continuously variable data like temperature and pressure and to output variable signals, typically 0–5 VDC, +/-10 VDC and 4–20 mA, to control valves, pumps, heater/chillers and the like. This sort of PLC has limited use in the entertainment industry, with notable exceptions like the Las Vegas shows “O” and “Ka,” which employ massive hydraulic systems. These days, analog modules are available for most digital PLCs.

Digital PLCs, which are designed to handle discrete data (ON or OFF), are measured by their I/O, or the number of INPUTS and OUTPUTS. The nano class has fewer than 32 I/O. (For example, a nano PLC may have as few as 6 inputs and 4 outputs for a total of 10 I/O.) The micro class includes PLCs with 32 to 128 I/O, small with 128 to 256 I/O and so on. Larger PLCs are generally designed around a central processing unit (CPU) attached to an open backplane to which I/O modules and specialty modules can be attached. Modular PLCs may have thousands of I/O along with a host of analog modules, high-speed counters, motion control modules and more. More about these specialty modules later.

Programming the Programmable Logic Controller

To assist the adoption of the new PLC technology, the original programming “language” of PLCs looked very similar to the relay ladder logic (RLL) factory technicians were used to seeing with the old relay systems. Relay ladder logic consists of vertical left and right power rails with “rungs” arrayed with relay contacts, each with an output next to the right rail. The following illustrations show pictorial versions of relay logic circuits and their schematic equivalents.

The image above shows a simple relay circuit. When Relay-1 turns on, power flows through the contact to the light and back to the power plug completing the circuit.

The image above shows a simple series relay circuit. In this case, if Relay-1 is on and Relay-2 is not on, power flows to the light and back to the power plug. Let’s see how this looks as ladder logic rung:

Here the power plug has been replaced with power rails. Power flows down the left power rail, across the rung (assuming all the conditions have been met), through the light and back up the right power rail to complete the electrical circuit. We have eliminated the coils of the relays and just assume they are there. Of course, we are not limited to a light. It could be anything able to switch on and off. So to simplify this somewhat further, we can change the lamp to a general purpose output, which in the real world of the PLC is either a dry contact closure or a transistor acting as a switch.

One way to read the program above (and it really is a line of relay ladder logic programming) is: if the coil of Relay-1 is energized and its contact changes from open to closed, power will flow to the normally closed contact of Relay-2, which, if Relay-2’s coil is not energized and its contact remains closed, power will flow to the output causing the PLC’s output contact or transistor to switch on. Gak! It’s much simpler to read the rung thus: If Relay-1 is ON and Relay-2 is NOT/ON then the output will switch on. (Just imagine the slash through the normally closed contact is the international symbol for NOT.)

So far we have used two of the three main operands of ladder logic programming NOT/ON and ON. In Boolean logic, this would be the NOT and the AND. That leaves the OR operand. Let’s take a look at a simple parallel circuit in pictorial and schematic form:

Here is a simple parallel circuit. In this case, if Relay-1 or Relay-2 is on, the light will turn on.

Here is the schematic version of the same circuit.

If you put enough of these rungs together, it begins to resemble a ladder, hence the name.

Programming software for relay ladder logic allows one to draw these diagrams on a personal computer then download them to the PLC.

So now we have the three principal operands of relay ladder logic: the familiar Boolean AND, OR, NOT. Complex control of machines and processes can be done with just these few simple instructions.

Disclaimer

Relay Ladder Logic is not the only programming language available for PLCs. The IEC 61131–3:2013 currently recognizes four standard programming languages: Ladder Diagram, Function Block Diagram, Instruction List, and Structured Text. Many PLC manufacturers provide all these languages with their higher end models, and the languages can be mixed and matched as the programmer desires. But at the very least, especially for the lower-end of the PLC spectrum (nanos and micros), Ladder Diagram programming is ubiquitous among manufacturers.

It is beyond the scope of this book to tutor the reader in each of the available languages. If you are a visual person, ladder and function block diagrams may be easier to learn. But if you already have a background in a structured language, like Pascal, then the text-based options may be best. However, to continue our discussion of the PLCs and how they function, I will use ladder diagrams because they are uniquely suited to demonstrating what sets PLCs apart from other controller designs. (That, and it’s the first language I learned for PLC programming.)

Climbing the Ladder

So, a ladder diagram consists of a left power rail, one or more rungs with one or more contacts, outputs and the right power rail. And the contacts on the rung have only two possible states: ON or NOT/ON. The key is in the contacts.

Contacts may be:

Scanning

A feature unique to PLCs is how the program is read and interpreted, and the ladder diagram provides a good way to visualize the process. The PLC starts by looking at the status of the real world inputs – the switches and sensors connected to the input terminal block – and whether they are ON or NOT/ON. It then looks at the ladder, working top to bottom, left to right. After scanning the ladder, it updates (turns ON or OFF) the outputs based on the status of the contacts on the ladder. Usually at this point the PLC will do a quick self-test and then start the process over again, many times per second. A typical PLC scan takes only a few milliseconds. The scan and response time are completely predictable, or deterministic, which is a very desirable characteristic in a control system.

Each rung is a truth table. If all the conditions (contacts) on the rung are true, the output will turn on, along with whatever is connected to it. However, because the program is scanned top to bottom, left to right, rungs at the bottom will take precedence over rungs at the top. Say, for example, that the contacts on Rung-1 are true and the instructions turn OUTPUT-1 on, but further down the ladder another rung is also true which tells the PLC to set OUTPUT-1 to off. When the PLC sets the outputs at the end of the scan, Output-1 will be off. This is why many manufacturers recommend against, or wisely prohibit, the same output appearing on the ladder twice. This may sound like a problem, but it’s not, as we shall see.

So if the devices connected to the PLC’s inputs are simple ON/OFF switches (or sensors acting like ON/OFF switches), and the PLC’s outputs are simple ON/OFF switches, what’s the point? Why bother with the PLC? The answer is programmability. With these simple switches and a PLC we can build very sophisticated control systems. Let’s look at a typical theatrical scenario of a wagon moving to several positions on stage and see how an inexpensive nano or micro PLC might help.

Let’s assume our stage winch VFD is set up like the traveler winch described in Chapter 7. We will use a similar strategy of using two limit switches at each end of the track – one to shift into creep speed (to improve positioning) and one to tell the winch to stop. Modern VFDs provide this “creep” capability onboard. This two-position, onstage/offstage set up may be enough for many productions, but we will assume we need to provide a few more intermediate positions as well.

The operator’s control pendant will consist of the following: a 22 mm, green, flush-style GO button; a 22 mm, red, projecting-style STOP button; a mushroom-head Emergency Stop button; the speed pot; a ten-position binary switch; and the amber power LED, green running LED and the two red limit LEDs. Now we can figure out how many I/O points we need before purchasing the PLC. The green GO button will be connected to INPUT-1, the red STOP button to INPUT-2, and the E-STOP mushroom to INPUT-3. We will wire the “creep” limits to INPUT-4 and INPUT-5 and the two end-of-track limit switches to INPUT-6 and INPUT-7 respectively. The binary switch will connect to INPUT-8 through INPUT-11. In actual wiring practice, one side of each switch is connected to the PLC’s input common and the other side of each switch is connected as described above.

Another thing to note: STOP switches, limit switches and E-stop switches are generally wired normally closed so that activation opens the circuit. In this way, a broken wire or disconnected plug will stop the system. So in our program, when a limit switch is activated (Boolean TRUE) it is NOT/ON.

OUTPUT-1 is assigned to the motor forward terminals in the VFD and OUTPUT-2 is assigned to the motor reverse terminals. OUTPUT-3 is assigned to the VFD preprogrammed (creep) speed terminal, and OUTPUTS 4, 5, and 6 to the indicator lights. The speed pot is wired directly to the VFD and will not appear in our ladder diagram, nor will the amber power light.

So, we need 11 inputs and 6 outputs. A quick glance at the Automation Direct website shows we can get a CLICK Brand PLC CPU module with 8 DC inputs and 6 relay outputs for less than $80 (at time of writing). We need a few more inputs, so we will need an additional input module, which comes with 8 additional inputs for another $30. The PLC will need a power supply for another $40. So, for about $150, plus the cost of the switches on the pendant and the limit switches, we are ready to build a viable, if a bit rudimentary, automated control system. (Note: Automation Direct and CLICK Brand PLCs are only one of scores of brands and suppliers. I just happen to have this PLC sitting on my desk.)

Let’s begin by setting the system up to run back and forth between the two limit switches. We will set up the intermediate positions later. To begin, we will assume the wagon is offstage and sitting on the offstage limit switch.

Here is an image of the programming screen for the CLICK Brand of PLCs by Koyo. Other brands have similar screens.

We have already programmed the first two ladder rungs in this image. If we read the first rung, as the PLC will, it says, “If the GO Button is ON and the OFFSTAGE Limit is NOT/ON and the STOP Button, E-STOP Button and ONSTAGE Limit are all ON, then OUTPUT-1 will turn on and the motor will start forward. Remember, the STOP, E-STOP and Limits are all wired so that activation turns them OFF. Because the Emergency Stop safety is critical, the PLC must not the only device monitoring this signal nor can it be solely responsible for its function. Also note that the moment that OUTPUT-1 turns on, the OR branch of the rung is true and the motor latches on. The operator can take his finger off the GO button and the motor will continue to run until one or more of the other conditions on the rung changes. Assuming the operator doesn’t activate either the STOP or the E-STOP button, the motor will run until it hits the ONSTAGE limit, in which case that contact will no longer be true, power ceases to flow across the rung and OUTPUT-1 will turn off. Pretty simple.

Rung 2 in the image above sets the VFD to creep once the ONSTAGE creep limit is activated. The OR branch latches creep mode on until the ONSTAGE Limit is activated. The MOTOR FWD contact assures that this rung is only true when the motor is moving forward, since we will want to exclude this rung when we reverse the process. Let’s do that now.

Here we have mirrored the first two rungs in order to move the wagon offstage. Note that the wagon must be on one or the other end-of-track limit switches in order for motion to start. This could be a problem if either the STOP or the E-STOP switches are activated before the limits are reached. With the wagon mid-position, none of the conditions required to start is met. The operator could simply activate one of the limits manually to restart motion, but that’s awkward, so we will want to incorporate a manual override as we expand our program. Also, the astute reader may have noted that I used the same output twice in the ladder program, which I said was not a good idea. In fact, the software returned this message:

So let’s fix that with some “internal coils” before moving on. These have no connections to the real world but are useful for creating logic within the program. Manufacturers include hundreds of these, even in their budget PLCs. This is how we can use them to fix the “don’t use the same output twice” problem:

The outputs on rungs 2 and 4 have been changed to internal coils C11 (Creep1) and C12 (Creep2), which are two different outputs. At the bottom of the ladder, these coils are gathered in rung 5 as an OR branch, so either C11 or C12 will activate OUTPUT-3 and initiate creep mode in the VFD. As long as you don’t use the same internal coil as an output, you can build logic this way up to the maximum number of internal coils available. (I could have started at internal coil C1, but I’m going to use C1 through C10 in a minute.)

The program above is a viable automation program for a wagon or traveler or roll drop (or whatever) that needs only on and offstage positions. For many shows, this is all that is needed – well, except for that problem of manual control. Presumably, you could draw another rung that, for example, will run the motor to one end of the track when – and only when – the GO button and the STOP button are pressed at the same time. But I will leave that as a puzzle for the reader to figure out.

Let’s look at how the binary switch on inputs 8 through 11 can help us out. Binary switches come in several configurations, including DIP, rotary and thumbwheel. The Binary Coded Decimal switch in thumbwheel configuration is easy to find from electronic suppliers like Mouser, Digi-Key, and others. This kind of switch converts the decimal numbers 0 through 9 on the face of the switch to 4-bit binary information we can use with the PLC. This is a table of how it works:

Selecting a decimal digit on the BCD switch rearranges the ON/OFF conditions at the inputs to our PLC. We can use that with internal coils to select different rungs in our program, like this:

I’ve already labeled each output in anticipation of its eventual use. By selecting zero on our binary switch, for example, internal coil C10 becomes true and we can use that in our program to isolate a specific rung. In fact, let’s use zero on the binary switch to create a homing cue for the motor driving the wagon, so that if the wagon is stopped short of one of the limit switches we have a way to get it going again, even if it’s only to get it offstage. This is what it looks like:

In rung 10, none of the inputs is on – which is true when zero is selected on the binary switch – so internal coil C10 (HOME) turns on. Rung 11 now reads: if zero is selected on the binary switch and the STOP Button, E-STOP and OFFSTAGE Limit switches are not activated, then hitting the GO button will start the wagon moving offstage until it hits the OFFSTAGE Limit. Rung 12 is the same creep instruction we had before, and rung 13 allows us to add more CREEP instructions while using OUTPUT Y003 just once.

This demonstrates how using the internal coils C1 through C10 we can select ten specific rungs within the program, or, in theatre-speak, ten different cues for our wagon.

Counters and Timers

Whether counting widgets going by on a conveyor belt or timing the filling of a bottle, counters and timers are an essential part of most industrial processes and even the micro PLCs come with hundreds of them. (Larger PLCs may have thousands.) The counters come in several different flavors: some count up, some count down, some reset to zero automatically, some hold their count until cleared by the program. There are also “High Speed” counters, which buffer counts that occur faster than the PLC’s scan time. Timers are similar, but they count pulses of an internal clock rather than external events. And like the counters, they can time up, time down, zero automatically, or hold their time until cleared by the program.

Let’s look at how we might use a counter in our program to add some intermediate positions for our wagon. First we need something to count. Often a stage winch will employ a chain stage between the motor and drum. It’s fairly simple to count the teeth going by on a sprocket with an inexpensive proximity switch. We still have a few inputs left on our micro PLC, so let’s add a proximity switch to INPUT-12 and point it at the teeth of the smaller motor sprocket. The switch will turn on and off each time a tooth goes by. If our winch employs #40 roller chain to drive the winch drum, then each passing tooth on the drum sprocket represents about ½ in of travel to our wagon, depending on the diameter of the drum. By pointing the proximity switch at the (usually) smaller motor sprocket, we can increase the position resolution by the ratio of the two sprockets. If, for example, the sprocket ratio is 2:1, then each tooth going by represents ¼ in of travel to our wagon.

Here is the cue to stop the wagon when it gets 10 feet onstage:

There is now an up counter, CT1, at rung 14. (All the other rungs above are the same as before; I’m only showing the relevant rungs for simplicity.) The counter has two connections to the left power rail: the first connection is what is being counted and the second is the condition that will reset the counter to zero. The proximity switch is connected to INPUT-12, so as each tooth goes by, the counter will increment by one. That information is stored in a data register called CTD1. When the counter reaches the set point of 480 (480 x .25 in = 120 in or 10 ft), CT1 will turn on.

Here’s how the program reads: When C1 (CUE1) is selected on the binary switch, the STOP Button, E-STOP button and the ONSTAGE Limit are not activated, then pressing the GO Button will start the motor onstage, which latches on through the OR portion of rung 13. As long as CT1 is not on, then the motor will run. When the motor begins running, the proximity switch starts sending pulses to the counter. Once the counter reaches its set point of 480, CT1 turns on, making the OR portion of rung 13 false and the motor stops. I added a simple compare statement in rung 15 which says that when the contents of CTD1 is greater than or equal to 468 activate internal coil C11, which, as you recall, tells the VFD to decelerate to creep speed. 480 − 468 = 12 counts or 3 in before the motor stops.

There are a couple of things to notice here: the onstage limit switch is included in the motor rung to be safe, should our proximity switch fail, and the proximity switch uses a special type of contact called a “one shot.” The PLC will only acknowledge this input when it cycles on – so for the input to be counted again, it has to cycle off. If this was not the case and the sprocket was turning slowly, the proximity switch might be on for several PLC scans, which would increment the counter by one every scan. Also note that the counter resets itself through the second connection to the left power rail when it turns on.

And there is one more thing: rung order makes a difference! Remember, the PLC looks at the inputs, scans the program then updates the outputs. If the counter is ahead of the motor rung, it will reset to zero before the motor rung and the motor will keep on running.

So, by isolating specific segments of our PLC program with the binary switch, we can create up to nine different cues (relative movements) for our wagon. But because we are now using outputs Y001 (MOTOR ONSTAGE) and Y002 (MOTOR OFFSTAGE) multiple times, we will need to use internal coils as the outputs for each motor move and gather them together in an OR statement near the end of the program, much as we did for the CREEP instructions. The trick is to use a labeling system that makes sense to the programmer. For example, MOFF1, MOFF2, or MON1 and MON2 could indicate the direction the motor will move and which cue it is moving in, as shown below.

For additional wagon positions, we simply duplicate rungs 13 through 15 above and use different numbers. The drawback to this system is that the “cues” must be run in sequence. The programmer must know where the wagon is at the end of each move in order to provide the counts and direction for the next. This is usually not a problem once a show is up and running, but it can be very tedious during tech rehearsals. Also, it may take a bit of adjusting of counts to get the wagon exactly where it is supposed to be, and that means downloading a new version of the edited program to the PLC each time the wagon position is adjusted. If the PLC is being used to run multiple axes, the tedium can be extreme. But there are ways to make the changes easier.

Human/Machine Interface (HMI)

Most PLC manufacturers offer a means of directly accessing variable data, like counter/timer constants or current counter/timer values in their PLCs. The interface is typically a touchscreen, which can be configured through software to show and manipulate the data stored in the PLC’s memory addresses. Instead of rewriting the counter values in the ladder logic and then reloading the new program, the user can call up the desired counter on the screen and directly enter new values, making changes to the wagon’s various positions much simpler and faster. Of course, a touchscreen adds cost and complexity to the system, but the time saved is usually well worth the expense. Small, monochrome touchscreens can be had for around $200.

Finishing the Program

You may have noticed that we have not programmed the indicator lights, which are attached to OUTPUTS 4 (RUNNING), 5 (ONSTAGE LIMIT) and 6 (OFFSTAGE LIMIT). With a PLC and ladder logic it’s pretty simple to add:

So, for less than $500 (including the HMI) we have put together a viable, if rudimentary, stage automation system. Of course, besides wagons, this system could run motorized battens, turntables, stage lifts, etc. And PLCs are particularly adept at sequencing events, like making sure the motor brake has lifted before starting the motor or checking that the trap door is open before allowing a lift to move – that sort of thing.

Specialty Modules

The system above is based on a low-end, inexpensive micro-PLC. More sophisticated PLCs offer a host of specialty modules that can be plugged into an open backplane attached to the PLC’s central processing unit. These modules can include:

A Note about Safety

In our system above, we included an E-stop switch to allow the operator to immediately halt the motion of the wagon in an emergency. The connection of the E-stop to the PLC and its inclusion in the program is only to inform the PLC that the E-stop switch has been activated and to stop trying to move the wagon. In actual practice, the E-stop will have removed power from the motor or initialized an orderly shutdown of the system, depending on the system’s design. The PLC should not be depended on for this purpose.

Final Thoughts about PLCs

In the early 1980s, the distinction between relay systems, PLCs, and the developing PC-based controls was pretty clear. These days, control systems range from programmable relays to programmable logic controllers to programmable automation controllers to personal computer controllers, and the lines between them continue to blur. Which device you choose will depend on the needs of your system and your dedication to its development. Dozens of stage automation vendors world-wide have invested thousands of man hours to build viable systems to move things on stage in a safe and controlled manner. I am not suggesting you shouldn’t attempt to design and build a stage automation system from scratch, but the task is daunting. However, there are scores of stage automation tasks the PLC can handle outside of a full-blown system and they are worth investigating. Not to mention they’re fun.