Read relay ladder diagrams, match sensors and actuators, understand VFDs, program PLC logic with timers and counters, and troubleshoot, guard and maintain automated machines.

Industrial Controls & PLCs

## Why it matters

A **programmable logic controller (PLC)** is an industrial computer built to run machines reliably for years in heat, dust and electrical noise. It replaced walls of relays with software that can be changed in minutes. To troubleshoot or program one you need a clear picture of its hardware, its addressing and, most of all, the **scan cycle**, which explains behavior that otherwise looks strange.

## Hardware

- **Power supply**: usually 24 V DC for the CPU and I/O.
- **CPU (processor)**: stores and runs the program, holds data, and talks to other devices. It has modes such as **RUN**, **PROGRAM** (stopped, outputs off) and sometimes **REMOTE**.
- **Input modules**: take signals from field devices (push buttons, sensors, switches) and convert them to bits the CPU can read. Each input has a status LED.
- **Output modules**: switch field devices (contactors, solenoids, lamps) according to the program. Relay, transistor and triac types exist.
- **Analog modules**: read 4 to 20 mA or 0 to 10 V signals as numbers, and write analog outputs to drives and valves.
- **Communication**: Ethernet ports for programming software, HMIs and networks such as EtherNet/IP, PROFINET or Modbus TCP; remote I/O racks connect over the network.
- **Chassis or rack** (modular PLCs) or everything in one unit (compact PLCs).

Major vendors include Rockwell Automation (Allen-Bradley), Siemens, Mitsubishi, Omron, Schneider Electric and AutomationDirect. OpenPLC is a free, open-source option for learning (https://autonomylogic.com/). Checked on 2026-10-23.

## Addressing

Every input and output has an address, and the format depends on the vendor:

- Siemens style: `I0.0` (input byte 0, bit 0), `Q0.1` (output byte 0, bit 1).
- Older Allen-Bradley style: `I:1/0` (input slot 1, bit 0), `O:2/3`.
- Modern Allen-Bradley (Logix) and many others use **tags**: named variables such as `Conveyor_Start_PB` mapped to physical I/O.

Electrical drawings show which wire goes to which terminal and address. Good tag names and comments make a program readable.

## The scan cycle

A PLC does not watch its inputs continuously while running logic. It repeats a fixed loop called the **scan**:

1. **Read inputs**: copy the state of every physical input into memory (the **input image table**).
2. **Execute the program**: solve the logic rung by rung, top to bottom, left to right, using the input image and internal memory. Results go into the **output image table**.
3. **Write outputs**: copy the output image to the physical outputs.
4. **Housekeeping**: communications, diagnostics, then start again.

A scan usually takes a few milliseconds up to a few tens of milliseconds, depending on program size and CPU. A **watchdog timer** faults the CPU if a scan takes too long.

## What the scan explains

- **Inputs are frozen during the scan.** If a button changes halfway through, the program sees the new value on the next scan.
- **Rung order matters.** A bit set on rung 10 is already set when rung 11 runs in the same scan, but rung 9 only sees it next scan.
- **The last write wins.** If two rungs both write the same output coil, the lower rung decides the output. This "double coil" problem is a classic bug.
- **Very short pulses can be missed.** A sensor pulse shorter than one scan may fall between input reads. Fast events need high-speed counter inputs or interrupt routines.

**Worked example.** A program has a 20 ms scan. A photo-eye on a fast line produces a pulse 5 ms long for each part. Some parts will be missed, because the pulse can start and end between two input reads. The fix is a high-speed counter input, a pulse stretcher or a sensor with an off-delay setting, not a faster guess.

## Programming languages

The IEC 61131-3 standard defines PLC languages:

- **Ladder Diagram (LD)**: relay-style rungs, most common in North America and easiest for electricians to troubleshoot.
- **Function Block Diagram (FBD)**: blocks wired together, common in process control.
- **Structured Text (ST)**: a text language similar to Pascal, good for math and data handling.
- **Sequential Function Chart (SFC)**: steps and transitions for sequences.
- **Instruction List (IL)**: an older assembly-like language, now deprecated in the standard.

## Online monitoring and forcing

Programming software can go **online** with a running PLC and show which contacts are true (often highlighted green). This is the main troubleshooting tool. Software can also **force** an input or output on or off regardless of the logic. Forcing can make a machine move unexpectedly, so sites restrict it to authorized people with the area cleared, and forces must be removed and logged.

## Common mistakes

- Writing the same output coil in two places.
- Expecting a mid-scan input change to be seen immediately.
- Leaving forces installed.
- Editing a running program without a backup or a management-of-change process.

## Safety

Control panels contain voltages that can kill, stored energy in drives and capacitors, and machines that can start unexpectedly. Everything in this course is practised on paper or in simulators. Working in real panels requires employer training, supervision by a qualified person, lockout/tagout and the arc-flash practices in NFPA 70E (https://www.nfpa.org/codes-and-standards/nfpa-70e-standard-development/70e), and for electricians a registered apprenticeship and state or local licence. Checked on 2026-10-23.

## Recap

- PLC = power supply, CPU, input and output modules, communications.
- Scan: read inputs, solve logic top to bottom, write outputs, housekeeping, repeat.
- Rung order matters; the last write to an output wins; short pulses can be missed.
- Online monitoring is the main tool; forcing is restricted and dangerous.

## Try it

Open the **Do** tab and take the quiz on PLC hardware and the scan cycle.


Explain the parts of a PLC, how inputs and outputs are addressed, and how the scan cycle reads, solves and writes.

PLC hardware and scan cycle

PLC Basics | Programmable Logic Controller

Programable Logic Controller Basics Explained - automation engineering

## Why it matters

In the relay lesson you read circuits made of wires and contacts. In a PLC, the same logic is software: contacts and coils are instructions that read and write bits in memory. Writing it yourself, and predicting what happens scan by scan, is the step from reading programs to changing them safely.

## The three basic instructions

- **XIC, examine if closed** (`-| |-`): true when the referenced bit is 1. On an input, that means the input has voltage.
- **XIO, examine if open** (`-|/|-`): true when the bit is 0.
- **OTE, output energize** (`-( )-`): writes 1 to its bit when the rung to its left is true, and 0 when it is false.

Siemens calls these NO contact, NC contact and coil; the idea is the same. Series instructions are **AND**, parallel branches are **OR**, and an XIO is **NOT**.

## The key mental shift: field contact vs instruction

In a relay circuit the STOP button is a normally closed contact. In a PLC, the NC stop button is wired to an **input**, so that input is **on (1) when the button is not pressed**. In the program you therefore use **XIC** on the stop input, not XIO.

```text
Field device           Input bit when at rest    Instruction to use for "OK to run"
NC STOP button         1                         XIC (examine if closed)
NC overload contact    1                         XIC
NO START button        0                         XIC (true while pressed)
```

This trips up beginners more than anything else: the instruction is about the **bit**, not the button.

## Seal-in in ladder logic

```text
      STOP_PB   START_PB   OL_OK          MOTOR
 1 ---] [----+---] [----+---] [--------------( )---
             |          |
             +---] [----+
                MOTOR
```

As Boolean logic:

```text
MOTOR = (START_PB OR MOTOR) AND STOP_PB AND OL_OK
```

The MOTOR bit in the branch is the PLC's version of the auxiliary seal-in contact. On the scan where START is pressed, MOTOR becomes 1. On the next scan, START is 0, but the MOTOR branch is true, so MOTOR stays 1. When STOP is pressed, STOP_PB becomes 0, the rung goes false and MOTOR is written 0.

## Adding an interlock

For forward and reverse, each rung gets an XIO of the opposite output:

```text
FWD = (FWD_PB OR FWD) AND STOP_PB AND OL_OK AND NOT REV
REV = (REV_PB OR REV) AND STOP_PB AND OL_OK AND NOT FWD
```

Because of the scan, FWD is solved first. If both buttons are pressed on the same scan from a stop, FWD becomes 1, and then the REV rung sees FWD already 1 and stays 0. Rung order decides the tie, which is one more reason to think in scans. Real reversing starters keep a hard-wired electrical and mechanical interlock as well, because software alone must not be trusted to prevent a phase-to-phase short.

## Worked example: tracing scans

Start with the motor stopped. The table shows inputs and outputs at the end of each scan.

```text
Scan  STOP_PB  FWD_PB  REV_PB  OL_OK  ->  FWD  REV
1     1        1       0       1          1    0     forward pressed
2     1        0       0       1          1    0     seal-in holds
3     1        0       1       1          1    0     interlock blocks reverse
4     0        0       0       1          0    0     stop pressed
5     1        0       1       1          0    1     reverse starts
```

## Latch and unlatch

Many PLCs also have **OTL/OTU** (set/reset) instructions that latch a bit on until another rung unlatches it. Latched bits survive a power cycle on some platforms, which can make a machine restart unexpectedly. For motor control, the seal-in rung is preferred because it drops out on power loss, just like a relay circuit.

## Practise in a simulator

Free tools let you practise without hardware: OpenPLC Editor includes a simulator (https://autonomylogic.com/), and many vendors offer free or trial software with simulation. The Do tab has a small in-browser simulation of the forward/reverse rungs. Checked on 2026-10-23.

## Common mistakes

- Using XIO for an NC stop button, so the motor runs only while STOP is pressed.
- Forgetting the seal-in branch, so the motor stops when START is released.
- Writing the same output in two rungs.
- Relying on a software interlock alone where a hard-wired one is required.

## Safety

Control panels contain voltages that can kill, stored energy in drives and capacitors, and machines that can start unexpectedly. Everything in this course is practised on paper or in simulators. Working in real panels requires employer training, supervision by a qualified person, lockout/tagout and the arc-flash practices in NFPA 70E (https://www.nfpa.org/codes-and-standards/nfpa-70e-standard-development/70e), and for electricians a registered apprenticeship and state or local licence. Checked on 2026-10-23.

## Recap

- XIC is true when the bit is 1, XIO when it is 0; OTE writes the rung result.
- An NC stop button gives a 1 at rest, so use XIC on it.
- Seal-in: OUTPUT = (START OR OUTPUT) AND STOP AND OL.
- Interlock: AND NOT the opposite output; keep hard-wired interlocks too.

## Try it

Open the **Do** tab and write the forward rung of a reversing starter.


Write PLC ladder logic for a seal-in with an interlock and simulate it scan by scan.

Ladder logic programming

Ladder Logic for Absolute Beginner

PLC Programming Tutorial - Ladder Logic #1: Binary & Boolean Operations

## Why it matters

Almost every machine needs to wait or count: run a horn for 3 seconds before a conveyor starts, hold a clamp for 2 seconds, count 12 parts into a box, stop after 500 cycles for a tool change. Timers and counters are the PLC instructions that do this, and their accumulated values are among the first things you check when a sequence stalls.

## Timer basics

A PLC timer has:

- a **preset (PRE)**: the target time, for example 3,000 ms;
- an **accumulator (ACC)**: the time counted so far;
- status bits: **EN** (enabled, the rung is true), **TT** (timer timing) and **DN** (done).

Timers count in the background, scan by scan: each scan the PLC adds the time since the last scan to ACC. That is why timer accuracy is limited by the scan time.

### TON: on-delay

While the rung is true, ACC counts up. When ACC reaches PRE, **DN turns on**. If the rung goes false at any time, ACC **resets to 0** and DN turns off.

```text
Rung true:   ____|‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾|____
TON DN:      __________________|‾‾‾‾‾‾‾|____
                  <--- PRE --->
```

Uses: a start-up warning horn, debouncing a sensor that flickers, an alarm only if low pressure lasts more than 5 seconds.

### TOF: off-delay

DN turns on as soon as the rung is true and stays on for PRE **after** the rung goes false. Uses: keep a cooling fan running for 2 minutes after a motor stops.

### RTO: retentive timer

Like TON, but ACC **holds its value** when the rung goes false. It needs a separate **reset (RES)** instruction. Uses: total run hours on a pump before a PM is due.

## Counter basics

A counter has a preset, an accumulator and a done bit too, but it counts **events**, not time.

- **CTU (count up)**: adds 1 each time its rung goes from false to true (a **rising edge**). Holding the input on does not keep counting.
- **CTD (count down)**: subtracts 1 on each rising edge.
- **RES**: resets the accumulator to 0.

DN turns on when ACC is at or above PRE. Counters usually keep counting past the preset, so the logic must decide what happens next.

## Worked example 1: warning horn

When START is pressed, a horn sounds for 3 seconds, then the conveyor runs.

```text
1  START_REQ seal-in (from START, STOP)               -> START_REQ
2  START_REQ ---------------------------------------- TON T1 PRE 3000
3  START_REQ AND NOT T1.DN -------------------------- -> HORN
4  START_REQ AND T1.DN ------------------------------ -> CONVEYOR
```

Pressing STOP drops START_REQ, which resets T1 and stops everything.

## Worked example 2: counting into a case

A photo-eye produces one pulse per bottle. After 6 bottles the conveyor stops so the operator can swap the case; 2 seconds later the counter resets and the conveyor restarts.

```text
1  PHOTO_EYE ---------------------------------------- CTU C1 PRE 6
   T2.DN ---------------------------------------------- RES C1
2  C1.DN ---------------------------------------------- TON T2 PRE 2000
3  NOT C1.DN ------------------------------------------ -> CONVEYOR
```

Trace it: each bottle adds 1 to C1.ACC. On the 6th, C1.DN turns on, rung 3 stops the conveyor and rung 2 starts T2. When T2.DN turns on, C1 resets; C1.DN goes off, which disables T2 (resetting it) and restarts the conveyor. This is the station you will simulate in the Do tab.

## Timing and the scan

In the simulation, each scan adds a fixed time step, which is how a real PLC behaves: if the scan is 10 ms, ACC goes up in roughly 10 ms steps. A 2,000 ms timer in a 10 ms scan finishes on the 200th scan after it is enabled. If a scan happened to take 25 ms near the end, ACC would still stop at the preset rather than overshoot, because the timer **clamps** ACC at PRE.

## Troubleshooting with timers and counters

When a sequence stops, go online and look at the timer and counter values:

- A TON with ACC stuck at 0 means its rung is false: find the missing condition.
- A TON that keeps resetting near the end means a flickering input: consider a debounce timer.
- A counter that counts double may be seeing a bouncing sensor, or two rungs may be counting the same event.
- A counter that never reaches preset may be missing fast pulses (see the scan cycle lesson).

## Common mistakes

- Expecting a TON to remember its time when the rung goes false (that is an RTO).
- Forgetting to reset a counter or retentive timer.
- Using a TON where a TOF is needed, or the reverse.
- Units: some platforms use milliseconds, others a time base of 0.01 s or 1 s. Check before typing 3000.

## Safety

Timers must never be the only protection on a safety function such as a guard door: those use safety-rated devices, covered later in this course. Control panels contain voltages that can kill, stored energy in drives and capacitors, and machines that can start unexpectedly. Everything in this course is practised on paper or in simulators. Working in real panels requires employer training, supervision by a qualified person, lockout/tagout and the arc-flash practices in NFPA 70E (https://www.nfpa.org/codes-and-standards/nfpa-70e-standard-development/70e), and for electricians a registered apprenticeship and state or local licence. Checked on 2026-10-23.

## Recap

- TON: DN on after PRE of continuous true; resets when false. TOF: delay after false. RTO: keeps ACC until RES.
- CTU counts rising edges; DN at ACC ≥ PRE; RES clears it.
- ACC goes up in scan-time steps and clamps at PRE.

## Try it

Open the **Do** tab and finish the TON instruction that drives the case-packing station.


Use on-delay timers (TON) and up-counters (CTU) in PLC logic, and simulate a counting station with a timed delay.

Timers and counters

PLC Timer Programming for Beginners

PLC Counter Programming for Beginners

PLC hardware, I/O and the scan cycle, then ladder logic programming with seal-ins, interlocks, timers and counters in browser simulations.