PLC Programming Basics: Ladder Logic, Structured Text & FBD

If you find yourself standing in front of a Mitsubishi MELSEC FX or an Allen-Bradley CompactLogix wondering where do I begin, you just got past the hard part. plc programming basics are more approachable than you might think once you realize there are only five official Languages - and that most engineers know how to use only two of them on a daily basis. This series will work through ladder logic, Structured Text, Function Block Diagram, Sequential Function Chart, and Instruction List under the IEC 61131-3 standard with code samples, software comparisons, and a decision tree to help you select the right language for your needs.

3 things have changed since most beginner guides were written: the standards was updated to IEC 61131-3 Edition 4.0 in 2025, vendor IDEs moved on to Studio 5000 v38 and TIA Portal V20, and AI-enabled code generation has began making waves within the engineer interface. We're covering all of it.

Quick Specs: PLC Programming at a Glance

• Standard: IEC 61131-3 - Edition 4.0 (2025), prior 3rd edition (2013)
• Defined languages: 5 — LD, ST, FBD, SFC, IL
• Industry usage (estimation): ~85% ladder logic, ~12% Structured Text, ~3% Function Block Diagram and others
• Typical scan cycle: 10–100 ms
• Standard I/O voltage: 24 VDC discrete; 4-20 mA / 0-10 V analog
• Major IDEs: Studio 5000 v38 (Allen-Bradley) TIA Portal V20 (Siemens) GX Works3 (Mitsubishi) CODESYS V3.5 (multi-vendor)

What Is PLC Programming and How Does It Work?

A Programmable Logic Controller (PLC) is one of the industrial computers engineered to replace banks of electromechanical relays and switches with a single solid-state device running a stored control system program. plc programming is the activity of writing that program — code that reads inputs from sensors, makes decisions, and energizes outputs like motor starters, solenoids, and indicator lamps that activate machinery on the factory floor. If you need a quick rundown on how hardware works, both from a general perspective and a deeper dive into the PLC base elements, our what is a PLC? and the deeper PLC fundamentals and technical framework piece will help out.

Every basic PLC runs the same fundamental program cycle, called the scan cycle: read inputs run program top-down output outputs do housekeeping start again. A typical scan lasts 10-100 ms, fast enough that one can call it instantaneous but predictable enough that the engineer can understand the result. Discrete inputs and outputs run on 24 VDC; analog signals follow 4-20 mA or 0-10 V conventions documented in IEC 60204-1 and UL 508A.

A PLC has five basic components found in any working code:

1. CPU (processor) - carries out the user program one statement or rung at a time.
2. I/O modules - interface to field devices (sensors, switches, contactors, valves).
3. Power supply - normally 24 VDC for the controller logic, separate from the field power.
4. Communication port - Ethernet/IP, PROFINET, Modbus, or USB for the program development equipment and network peers.
5. Programming device - the PC running Studio 5000, TIA Portal, GX Works or CODESYS that deploys the code to the CPU.

Released by Bedford Associates in the late 1960s, MODICON was the first device to wear the PLC label. Its goal was the same one we still solve today: to leave the ladders of physical relays on the warehouse shelves and have updatable software eliminate them, so the specialists could modify a control procedure without re-wiring the box.

IEC 61131-3 Standard: The 5 PLC Programming Languages

IEC 61131-3 was first ratified by the International Electrotechnical Commission in December 1993 to create a common set of languages for programmers of controllers. This has been iterated with a 2 nd edition (2003) and an industry-blessed 3 rd edition from the IEC (2013). PLCopen, the industry consortium that promotes the standard, adopted Edition 4.0 in 2025 - most PLC guides written before 2025 still reflect the 3 rd edition and miss the update.

Five languages are defined by the standard, organized into two families:

• Graphical (visual)
  • LD - Ladder Diagram: rungs of contacts and coils, a carryover from electromechanical relay schematics.
  • FBD - Function Block Diagram: wired blocks, heavily used in process control and signal flow systems.
  • SFC - Sequential Function Chart: a state machine allows for sequential behaviors.
• Textual
  • ST - Structured Text: a high level language derived from Pascal which allows use of IF/THEN statements, FOR loops, and user defined functions.
  • IL - Instruction List: a low level mnemonic language similar to assembler, now being deprecated on the IEC 61131-3 camps.

A - IEC 61131-3 applicable controller must accept programs in any of these five languages, and projects are allowed to use more than one at a time - an SFC is able to command the transition between two Ladder routines, a Function Block can be written in ST but called from a rung, etc.. IEC 61131-3 compliant compilation tools for controllers are supported by the ITA standards council, and projects can can XML data from them to other programs.

Ladder Logic (LD): The Most Common PLC Programming Language

ladder logic is the easy-on-the-eye visual language for plc basics, where your program appears as an electrical diagram turned 90 degrees — a direct descendant of the relay logic schematics that ladder diagrams replaced in the 1970s. Parallel "rails" serve as the virtual power magnitude (+) and (-); horizontal "rungs" connect them through input contacts and output coils. When a route of closed contacts crosses from left to right through the bottom rail circuit, the output in that rung completes the circuit and turns ON. Each cycle, the CPU reads inputs, executes every rung top-down left-to-right, and energizes the output coils that activate machinery.

Industry estimates from plcprogramming.io's 2026 analysis put ladder logic at 85-90% of the installed controller base, and a case study from the University of British Columbia notes that ladder logic is the only IEC 61131-3 language ranked among the top 100 programming languages in current use - none of the other four cracks the list. That position is the reason every junior controls engineer learns ladder first, and the entire installed base of legacy hardware contactors and relays is still running ladder programs decades old.

Q: What is the difference between Normally Open and Normally Closed contacts?

A Normally Open (NO) contact is one of the two basic input notations in plc programming basics, shown by two vertical short lines with a middle space. It blocks rung continuity until the input it represents is energized, at which point it "closes" and allows virtual power to flow. Use NO contacts when an action should happen because a sensor is active.

A Normally Closed (NC) contact is drawn the same but with a slash through it. When it is unenergized it provides rung continuity - "closing" and completing the circuit. When input is energized it "opens" and breaks the circuit. NC contacts are how you wire emergency stops, interlocks, and anything that should stop if a sensor signals bad news. Fail-safe rule of thumb: real Stop pushbuttons in the cabinet are wired Normally Closed and read with a Normally Open instruction in the program, so a broken wire causes a shutdown rather than a runaway.

In actual practice ladder logic's best feature on the shop floor is the ability to troubleshoot while the system is running. When a startup sequence is supposed to go, you connect the IDE to the running PLC and watch the rungs as they go - the unenergized contact populates the failed condition instantaneously. As one programmer on r/PLC has said: "Ladder is fantastic for live debugging. If a startup sequence isn't going, you can visualize exactly which rung is preventing startup." That immediate feedback is hard to mirror in textual languages.

Electrical Engineer's Note: Always wire physical Stop and E-Stop pushbuttons as Normally Closed contacts in the field and then test them with Normally Open commands in the program. A loose wire or frayed cable should safely open the safe state - motor off - not close the run state. This rule is the only thing that will turn factory-grade ladder code into tutorial.

Structured Text (ST): When You Need Math, Loops, or Modern Code

Structured Text is the high-level text language specified by IEC 61131-3, with constructs borrowed from Pascal. If you've written C, Java, or Python, you'll find ST familiar - assignments terminate with semicolons, IF/ELSE conditions branch appropriately, FOR and WHILE loops repeat, and function block calls act like functions. A single ST line often replaces half a dozen ladder rungs when logic involves intense math.

Here is a trivial ST example that scales a 4-20 mA analog input (raw 0-32767) into engineering units (0-100 C) and sound an high-temperature alarm:

// Scale raw input to engineering units
TempC := (REAL_TO_INT(AnalogIn) - 6553) * 100 / 26214;

// Trigger alarm if above setpoint with 2 second debounce
IF TempC > SetpointHigh THEN
    AlarmTimer(IN := TRUE, PT := T#2s);
    IF AlarmTimer.Q THEN
        HighTempAlarm := TRUE;
    END_IF;
ELSE
    AlarmTimer(IN := FALSE);
    HighTempAlarm := FALSE;
END_IF;

Doing the same thing with Ladder would require analog scaling blocks, a TON timer, countless intermediate tags, and about 8 rungs. ST compresses it into ten concise lines.

Q: What's the difference between Ladder Logic and Structured Text?

Ladder Logic is visual, and works best for discrete I/O - motor starters, sequences, interlocks - where human eyes can see the shot window to follow operation. Structured Text is written and wins at continuous values, string manipulation, loops, and advanced calculations where Ladder Logic gets damn scary that an engineer can memorize more than about six contacts per rung. ST's programs are all more concise, more portable, and more keepable if version-controlled as text. Debugging is the trade-off: when ST breaks, you read variable values rather than watch power flow visually. In the real world, adoption is split ladder logic is monitored in DataForSEO 2025 monthly search data, which shows "structured text plc" queries boosting 24% from April through September 2025, while "ladder logic" queries slacken off. New engineers entering the trade are learning both.

An r/PLC discussion revealed a consistent working consensus: 'Structured text is the language of choice when programming. Ladder/FBD is the language of choice when troubleshooting.' Many engineers now write libraries of complex algorithms in ST and call them from a thin Ladder layer that maintenance techs can visually step through troubleshooting. This pattern is well supported in Mitsubishi GX Works3 and Allen-Bradley Studio 5000- If you create a Function Block in ST and call it in a Ladder rung, it shows up as a named block.

Function Block Diagram (FBD), Sequential Function Chart (SFC), and Instruction List (IL)

The other three IEC 61131-3 languages live in more narrow spaces but also show up in production code, especially in process factories.

Function Block Diagram (FBD) models logic as named blocks with outputs on the left and inputs on the right wired with virtual signal lines. FBD is magical anywhere signals are not switching on and off – closed-loop control, PID tuning, analog flow conditioning, and motor drive integration. FBD looks more like an instrumentation diagram with a PID block than a relay schematic diagram, which is why instrument control engineers like it. These Siemens controllers, like the SIMATIC S7-1500, host FBD natively and ships with large libraries of function blocks.

Sequential Function Chart (SFC) visualizes states. Boxes are steps; conditions on horizontal bars are transitions between steps. SFC is perfect for batch operation, machine startup, and any logic that proceeds in discrete phases - fill tank heat to target mix for 5 minutes drain. Ladder code can do the same thing but becomes a squarish maze of latching coils; SFC visually clarifies the state machine.

Instruction List (IL) is the lowest level textual language, similar in spirit to assembler. It was common in early plcs projects in Europe but has been abandoned in modern controllers - edition 4.0 of IEC 61131-3 continues the downward path and leading vendors now leave IL editors out of their newer development environments. beginners sometimes get drawn to IL because the syntax looks simple but that path quickly hits a dead end. If you see IL code in older projects, it's probably being converted away from.

In a typical controls engineer career, plan to be conversant in ladder logic, know your way around Structured Text and be able to follow FBD when asked to do process control work. SFC and IL have their uses but are rarely in the first-tool-nowhand.

How to Choose: The 85/12/3 Reality of PLC Programming Languages

beginner guides often describe all five IEC 61131-3 languages as just as important as the next. They are not. Incorporating industry usage estimates from plcprogramming.io's 2026 analysis, the UBC world-class reputation which has only ladder logic in the top 100 worldwide, and the growing-though-still-minority Structured Text signal found in 2025 search data, a working ratio looks like this:

• ~85% ladder logic - discrete I/O, motor control, interlocks, and everything else on the factory floor.
• ~12% Structured Text – number crunching, complex algorithms, libraries called from Ladder. Growing proportion of new code.
• ~3% Function Block Diagram- process control, PID, flow conditioning.
• SFC and IL- niche or legacy; not part of the everyday work.

Call this the 85/12/3 Reality. It's not a recipe - it's an empiric field-guide. Use it to inform how much time you spend learning each language and how much time you spend helping other engineers review their code. Below, the comparison walks each language through the trade-offs that matter when it's time to choose the right tool for the job.

One rule to rule them all: write ladder logic for maintenance technicians to troubleshoot at 2 AM, and reach for Structured Text only when math really demands it.

PLC Programming Software: Studio 5000, TIA Portal, GX Works, and CODESYS

Software is where plc programming gets unique. Which IDE you'll use depends on the PLC's CPU model, and search interest reflects how many engineers are evaluating these tools - DataForSEO shows query volume for "plc programming software" spiked 238% from April through September 2025, matching up with a series of important version updates landing during that time. PLC software is on track to expand by $924 million between 2024 and 2029 at a 5.6% CAGR according to a market survey by Technavio.

Four IDEs dominate the 2026 landscape:

• Studio 5000 Logix Designer (Allen-Bradley / Rockwell) - v38.00.00 released September 2025, according to Rockwell's own compatibility portal. Supports ControlLogix and CompactLogix families. Successor to RSLogix 5000. Commercial license, with a trial edition that is limited in scope. Strong Ladder + ST support; also FBD and SFC.
• TIA Portal (Siemens) - V20 is officially the 2026 product release; the previous V19 release was officially discontinued January 17, 2025. TIA Portal replaces—and uncouples—the old STEP 7 (plc programming), WinCC (HMI), Drive/startdrive (motor controllers), and Safety. Supports all five of the IEC 61131-3 languages. Requires a commercial license; the S7-1200 Basic edition license supports only that platform.
• GX Works3 (Mitsubishi) - the IDE for MELSEC iQ-R, iQ-F, and Q-series gamma-giants, with a completely backwards-compatible GX Works2 for FX-series circuits. Ladder, ST, FBD, and SFC.
• CODESYS V3.5 (multi-vendor) - vendor-neutral implementors include Beckhoff, WAGO, and Schneider (M-series). Freecontrollers time simulator as a platform for IDEs; controller licenses are sold per device. Common first IDE for a beginner or an academic engineer.

Schneider Electric's EcoStruxure platform, including Machine Expert and Control Expert—a fifth familiar to anyone in the Modicon GPS world. For a larger vendor overview, see our in-depth guide to leading PLC brands.

If you're ordering replacement parts for a business' old machine lines, keep the IDE version you write in mind: For example, openers written in Studio 5000 v32 may not open cleanly in newer v38 without conversion. Browse refurbished and new controllers in our PLC inventory when you need a known-good spare for a specific firmware target.

Your First PLC Program: Motor Start/Stop in Ladder Logic

The plc programming start/stop circuit is about as complex as that Hello, World! program you wrote in boilerplate Python: it covers three core patterns—injection of momentary input processing, the preservation of the state in a latching seal-in rung, and the fail-safe Stop wiring—in one small program that fits on a single screen.

Hardware: one NO Start pushbutton, one NC Stop pushbutton, and a contactor M1 motor. Start pushbutton wires to PLC input X1; stop pushbutton wires to PLC input X2; contactor coil wires to PLC output Y1. All field power runs through proper fusing and a master disconnect that the PLC not directly control.

Just one rung makes up the program:

+----[ X1 ]----+----[/ X2 ]----( Y1 )----+
|              |
+----[ Y1 ]----+

Read from left to right: power flows through the parallel branch (X1 OR Y1) through the NC instruction X2 energizes coil Y1. When the operator hits Start, X1 closes, Y1 energizes, and the parallel Y1 contact "seals in" the rung - Y1 stays energized after the operator releases the Start button. When the operator hit Stop, X2 (wired NC in the field, read as a NC instruction in the program) opens the rung; Y1 drops out and the motor stops.

The fail-safe trick lives in the Stop wiring. The physical Stop button is NC, so the X2 input is energized continually while the system is good. If the wire to the Stop button is cut or the button itself fails open, X2 de-energizes - same as hitting the button - and the motor shuts off. Wire it the opposite way (NO Stop button + NO instruction in the program) and a broken wire leaves you with no way to stop the motor.

Translated into Structured Text, the same logic is four lines:

IF (Start_PB OR Motor_Run) AND Stop_PB_NC THEN
    Motor_Run := TRUE;
ELSE
    Motor_Run := FALSE;
END_IF;

Same behavior, denser code. New engineers should write the Ladder version first because it makes the seal-in pattern visible; reach for ST only after the pattern is ingrained.

How to Learn PLC Programming: A 90-Day Beginner's Roadmap

Yes, you can teach yourself plc programming. Plan on 5-8 hours a week for a working professional, and 90 days will get you from zero to a working first project. The order matters - fundamentals first, Ladder before ST, hardware before software, simulator before live PLC.

An r/PLC veteran summed it best: "As much as I like my structured text, I would concede that a plc programming role would benefit more heavily from a focus on ladder logic." Start there.

• Weeks 1-2 - fundamentals. Read what a PLC is, the scan cycle, the 5 basic components, and how 24 VDC discrete I/O wiring works. Browse the PLCopen IEC 61131-3 introduction for the standard's structure.
• Weeks 3-6 - ladder logic. Practice NO/NC contacts, output coils, parallel and series rungs, timers (TON, TOF, TP), counters, and the seal-in pattern. Use a free simulator to simulate logic in real time - CODESYS V3.5 has a free Windows runtime that handles all five languages, and online plc training tutorials walk you through each one.
• Weeks 7-9 - Structured Text. Learn variable types (BOOL, INT, REAL, TIME), IF/ELSE, FOR loops, function block calls, and analog scaling. Convert three of your Week 3-6 Ladder programs to ST to gauge the trade-off.
• Weeks 10-12 - First real project. Pick a small problem (light sequencer, parking gate, conveyor counter), write the spec, draw the I/O list, code it in Ladder + ST, and run it on a simulator with realistic timing.

Formal credentials are useful for hiring but not required to learn. Programs like the Williston State College PLC Technician Certificate document a curriculum that maps cleanly to a self-study schedule, and several vendors host free plc training resources that complement paid courses. Vendor training is also a strong pathway — Allen-Bradley's Studio 5000 courses and Siemens' TIA Portal training cost more than a year of self-study but provide certification employers recognize.

PLC Programming in 2026: 3 Trends Changing How Engineers Code

The plumbing underneath plc programming is changing faster in 2025-6 than it has in over 20 years. Three signals are worth keeping an eye on as you choose where to focus your learning efforts.

1. AI-assisted programming is now present inside vendor IDEs. Siemens has released the Engineering Copilot for TIA Portal: a generative-AI co-pilot integrated into the engineering workspace that auto-creates suggests for tags, auto-creates function block families, and auto-translates freely-typed specification into IEC 61131-3 code. Sepcifically third-party tools - including PLCAutoPilot for Modicon M221, and PLCcopilot.com - arrived ahead of time. An industrial automation analysis warns that deployment still requires the same rigorous testing and review standards as human-generated code, but the productivity gain is undeniable. If starting from square one now, it make sense to use these tools, and validate their and the output it creates - in the same manner which you would a junior engineer's first commit.

2. The IEC 61131-3 standard has been refreshed. The fourth edition of IEC 61131-3 was released in 2025, superseding the third edition from 2013 which most beginner material still references. The standards either side of this - 3a, 4 - tighten Object Oriented programming within Function Blocks, refine namespace management, and continue the transition away from Instruction List. If your target controllers compliance label still says "Edition 3" you're A-OK - but for any new work, both training and design slides should reference 4.

3. Software demand is exploding, which is leading to consolidation. "plc programming software" searches increased 238% between April and September 2025, according to DataForSEO monthly searches report, and general PLC software market has an estimated CAGR of 5.6% from 2024 to 2029, adding up to a US$924 million increase per Technavio's market analysis. Industry analysts at JR Automation tie this to digital twin adoption and virtual commissioning workflows that compress physical PLC bench time. If you're checking off a capex project in 2026, bear in mind to schedule simulation-first programming - working on a digital twin before the cabinet is built is no longer a concept.

What this all adds up to is that: the legacy ladder logic the factory runs on won't disappear from the factory in the 2020s. But both the tools, and the tools to handle them are. Know the model, and use the associate assistant, simulator, and twin.

Frequently Asked Questions

Q: What are the basics of PLC programming?

The five IEC 61131-3 languages, the scan cycle (pull inputs, run program, push outputs, repeat 10-100ms), and the baseline logic (Normal Open/Normal Closed contacts, output-lamp coils, prevent-override latch for electric motors, fail-safe Stop circuits wiring in the field).

Q: Can I teach myself PLC programming?

Yes. 90 days self-study ( fundamentals, ladder logic, Structure Text, small first project) is achievable on a 5-8 hr. per week basis. Free CODESYS simulators allow one to write and run code without purchasing a PLC. Official certification like Williston State College PLC Technician Certificate can be useful for hiring but isn't compulsory in achieving competency.

Q: What are the 4 types of PLCs?

In physical form factor, plcs are four families: Compact (fixed I/O, small footprint, exemplified by Mitsubishi FX1S or Allen-Bradley MicroLogix 1400); Modular (interchange able I/O cards on a backplane exemplified by Mitsubishi Q-series or Allen-Bradley CompactLogix); Rack-mounted (large modular systems rolling out plant-scale automation exemplified by Allen-Bradley ControlLogix or Siemens S7-1500); Distributed / Remote I/O (CPU centralized, I/O distributed via Ethernet/IP or PROFINET).

Q: What is the most common PLC programming language?

By far the dominant language of ladder logic - field estimates have it at about 85% of the installed base of PLC code and a UBC academic ranking shows it is the only IEC 61131-3 language to make the global top 100 programming languages - and by a wide margin. Industry stats also put Structured Text as the emerging minority, especially in new projects with a lot of mathematical or string processing, and Function Block Diagram has already carved out about 3% of the mix. beginners should learn Ladder Logic first.

Q: How long does it take to learn PLC programming?

The usual number for working competence (comfortable in ladder logic, comfortable in Structured Text, able to design and debug a small standalone program) is a 90-day commute averaging 5-8 hours per week, which equals somewhere just under 60-95 total hours. The usual number for senior competence (able to architect line-scale automation with HMI, drive integration, and safety circuits) is 3-5 years experience on-the-job pieced together afterwards.

Q: Do I need a real PLC to learn programming?

No, not for the first 60 days. CODESYS V3.5 is released with a free Windows runtime that emulates all five IEC 61131-3 languages on a laptop, and most PLC vendors include time-limited trial versions of their IDEs (Studio 5000, TIA Portal Basic). Use the simulator for fundamentals, Ladder, ST and your first small project. Once you survive the basics, a low-cost used or reconditioned compact PLC is the logical next step for trying out real I/O wiring and online debugging.

About This Guide

This guide is based on Standard IEC 61131-3 (Edition 4.0, 2025), supplier guidebooks from the big PLC brands carried by itrustbot - Mitsubishi, Schneider, Siemens, Allen-Bradley and Omron, and a recent 6 month search-volume summary from DataForSEO showing plc programming software demand skyrocketing 238% from April-September 2025. We sell refurbished and new automation parts to maintenance teams every week, therefore our perspective stays grounded in what engineers need to be able to read legacy and current code.

Explore PLC inventory at itrustbot →

Related Articles

• Programmable Logic Controller: Fundamentals and Technical Framework — the hardware companion to this programming guide.
• Hints and tips to when programs misbehave on running equipment, is Introduction to PLC Troubleshooting.
• The consulting reference for selecting PLC brands such as Mitsubishi, Allen-Bradley, Siemens, and others, is Leading PLC Brands: Vendor Selection Guide.
• HMI, PLC, and SCADA: A Touchscreen Panel Guide — how PLC programming fits into a full control architecture.
• Refurbished Automation Parts — sourcing context for legacy controllers running ladder code.
• Understanding 24VDC Power Supply Sizing — the electrical foundation underneath every PLC installation.

References & Sources

1. IEC 61131-3 Edition 4.0 (2025) — PLCopen, the international consortium that promotes the IEC 61131-3 standard
2. IEC 61131-3:2013 — International Electrotechnical Commission, prior 3rd edition reference
3. IEC 61131-3 — Wikipedia — encyclopedic overview of the standard's history
4. A Case Study from Programmable Logic Controllers — University of British Columbia academic paper ranking ladder logic among the global top 100 programming languages
5. Formalizing Ladder Logic Programs and Timing Charts for Fault Detection — Michigan Technological University, Department of Computer Science
6. A Survey on PLC Programming Languages and Their Applications in Modern Industrial Automation — peer-reviewed survey paper, ResearchGate
7. PLC Technician Certificate Program — Curriculum Materials — Williston State College
8. IEC 61131-3: Acceptance Rate of This Control Programming Standard — Control Engineering magazine
9. PLC AI Programming: Rockwell and Siemens Copilot Options Explained — Industrial Monitor Direct knowledge base
10. 2026 Key Trends in Automation Shaping the Future of Manufacturing — JR Automation
11. PLC Software Market Growth Analysis 2025–2029 — Technavio market research report