tia-forge

Posted on Oct 17 Originally published at hubwiz.com

Siemens PLC Ladder Logic Examples: 60 Exercises You Can Import Into TIA Portal

#plc #automation #programming #tutorial

The hard part of learning ladder logic isn't memorizing contact symbols — it's getting from a one-line requirement to a program that actually runs in TIA Portal. Learn-LAD breaks that step into 60 worked examples. Each one gets its own page: the ladder diagram, a network-by-network walkthrough (purpose / condition → action / why / watch out / logic expression), a signal table and a variable table, common questions, and variants. Install TiaLink and you can also pre-check the example's objects and then import them into the TIA Portal project you have open — same-named objects are not overwritten by default, and the project is not saved automatically after the import.

It's not a "watch the video, still can't write it" tutorial, and it's not an archive of files you download and forget. It's closer to a problem set with answers and explanations: the tasks mirror real machine behavior, and the answers can be read, modified, or imported into a project to check against.

1. Where learning ladder logic actually gets stuck (it's rarely syntax)

Contacts, coils, normally open / normally closed — an afternoon is enough to memorize all of it. The real sticking points show up later:

You can read it, but you can't write it. You can explain any single network. But give yourself one sentence — "after the start button is pressed, run the motor for 10 seconds, wait 10 seconds, then stop" — and you don't know what belongs in the first rung.
You can copy it, but you can't modify it. Someone else's program runs fine in your project. Change a timer value, add an interlock, add a mode — and you don't dare touch it.
You've practiced, but not correctly. The snippets you find online are scattered: no variable table, no addresses, no explanation of why it's written that way. You finish practicing and still don't know whether you got it right.

None of these three is a syntax problem. They're all the same missing thing: complete, verifiable, usable examples.

Five criteria for judging a PLC example library

Criterion	Why it matters	How Learn-LAD does
Real ladder diagrams	Not pseudocode or a spoken description — you can trace the contacts	One ladder screenshot per network
Network-by-network explanation	Explains why it's written this way, not just the answer	Purpose / condition → action / why / watch out / logic expression
Signal table and variable table	Real addresses and data types, ready to land in a project	Signal table + variable table + instance DB
Common questions and variants	Tells you in advance where people go wrong and how to extend it	Two fixed sections on every page
Can go into your own project	Otherwise you never leave "reading other people's code"	One-click import into TIA Portal via TiaLink

Those five criteria are also the order of this article: what it is, what's on one page, and how to turn it into your own practice.

2. What Learn-LAD is: one screen

Item	Detail
Entry	tia.hubwiz.com/learn-lad
Size	60 examples: beginner 23, intermediate 33, advanced 4 (verified 2026-10-17)
CPU tags	S7-1200: 57, S7-1500: 2, S7-300: 1
Multi-block projects	4 examples are tagged "multi-block", made of a main program + function blocks / functions + data blocks, and may include SCL
Page structure	Overview → signal table → workflow → network-by-network walkthrough → variables and data blocks → common questions → variants and extensions → related examples → next step
How to get it	Read directly on the page; program objects are imported through TiaLink — there is no file download
Import requirement	A Windows machine with a licensed TIA Portal install (TiaLink is currently built on V19 and Openness)

One thing to make clear up front: it is not a simulator, and it doesn't hand you a project file that opens with a double click. Every example can be read on the page; to get it into a project you go through TiaLink. That's both the limitation and the main difference from a "material pack": there's a pre-check before anything enters your project, and you save explicitly after.

3. What the 60 examples cover

Grouped by learning goal, they form roughly this ramp:

Learning goal	Representative examples	What you practice
Logic fundamentals	Circuit diagram → ladder, Basic digital logic (AND/OR), Technician logic drills	Series/parallel, normally closed contacts, the mapping between Boolean expressions and ladder
Buttons and state retention	Toggle output with one button, button-controlled solenoid valve, switch logic, oil pump control	Self-latching, set/reset, edge detection, "press once on, press again off"
Timers and counters	Coffee grinder timer, flashing indicator, automatic coffee machine, traffic light control	TON / TOF / TP differences, cascaded timers, counter-based phase switching
Interlocks and sequence control	Level pump start/stop, assembly line control, conveyor sorting, bottle filling and capping	Condition confirmation, interlocks, anti-short-cycling, multi-step sequences
Multi-block and SCL	SCL training: storage function block, SCL intro: FB calls, Factory IO connection, Sorting boxes (Factory IO)	LAD + SCL mixed, FB/FC/DB, main-program scheduling and layered business FBs

The size distribution shows the ramp too: beginner examples are mostly 1 block / 2–4 networks; intermediate ones reach 7–8 networks; the traffic light in the advanced row is 8 visible networks + 7 imported objects, and the Factory IO sorting box is 2 blocks / 19 networks, covering start/stop, infeed, left/right sorting, counting and outfeed.

4. Inside one page: the traffic light example

An example page doesn't just paste a ladder diagram and stop. The traffic light page, for instance, contains:

Overview: three phases (east → west → north), 20 seconds each (15 s green + 5 s yellow), implemented with SR start/stop + a counter for phase switching + three TP timers + comparison instructions.
Signal table: type (I / Q / M / TP / CTU), meaning and role of every point.
Workflow: the full sequence from START setting STARTED, through the three phases running, to the counter returning to 0.
Network-by-network walkthrough: every network follows the same template.

For example, network 2 (the phase counter) reads:

Purpose: increment the counter at the end of each phase; use CV to select the next phase.
Condition → action: falling edges of STEP1.Q, STEP2.Q, STEP3.Q (NContact) in parallel into the CU input of a CTU; PV = 3, and CV wraps to 0 after 3.
Why: one counter instead of three interlocked state bits keeps the phase logic much simpler; STEP*_FINISHED are the edge-memory bits for the three NContacts.
Watch out: NContact detects the falling edge — the instant the timer pulse ends — not the moment the timer starts.
Logic: COUNTER_STEP = CTU(CU = FALLING(STEP1.Q) OR FALLING(STEP2.Q) OR FALLING(STEP3.Q), PV = 3)

That short passage tells you three things: what the network is for, why it uses a counter instead of state bits, and the point people most often misread (the falling edge). That is far more productive than copying the diagram once.

Further down the page:

Variables and data blocks: the variable table (with %M addresses) plus the four timer / counter instance DBs TIA generates automatically.
Common questions: where to look first if phases don't switch, what to do when comments and phases don't line up, how to wire the lamp outputs from %M, which values to change together when you change a phase duration.
Variants and extensions: four phases / with left turn, night-time flashing yellow, pedestrian lights — each with a direction for the change.
Related examples and next steps: the "what to practice next" list, already ordered.

Two details worth noticing

First, the examples flag their own flaws. The traffic light page says in its common questions that the comment numbering on Networks 3/4 is off in the original project and to read it via CV and the actual network logic; the trash compactor cycle notes "the output uses a %I address, likely a typo"; the delayed lamp page notes "the lamp output in the point list is never driven in the block." Marking defects instead of hiding them is good for learners — real projects contain programs like this, and learning to spot them is more useful than pretending they don't exist.

Second, the page gives you a checkable logic expression. Besides the ladder diagram, every network has a line like STARTED = SR(SET = START, RESET = STOP). Its job isn't to replace the diagram — it's to let you cross-check between diagram and semantics: if the diagram doesn't make sense, read the expression; if the expression doesn't, go back to the diagram.

5. How to use it: three routes

Route A: read only (teaching, prepping, quick reference)

Nothing to install — just open the pages. Good for:

Self-study, working up the difficulty curve, and asking after each page "what happens if I remove XX?";
Training / classroom use, with a page as the worked example, the signal table as the board notes, and the common questions as discussion material;
On the job, when you need a small piece of logic (flashing, off-delay, level interlock) — come here and compare how it's written.

Route B: import into your own project (the recommended path)

This is the biggest difference between Learn-LAD and an ordinary example site. It's four steps:

Install and run TiaLink on Windows (default service address http://localhost:8080), and open the target TIA Portal project you want to import into at the same time.
On the example page click "TiaLink settings", confirm the address and test the connection. (If you started TiaLink with --api-token, enter the same value there; it's stored only in your browser's localStorage, never uploaded.)
Click "Import into my TIA project": pre-check first, then import.
Back in TIA Portal, save explicitly.

Three safe defaults to remember: there's a pre-check before import; same-named objects are not overwritten by default; nothing is saved automatically after import — so if you don't like the result, you can just abandon it.

After importing, take one more step: run it in S7-PLCSIM, force a few inputs, and see whether the output changes match the "workflow" section of the page. Read → import → verify in simulation — only after that loop is an example actually learned.

Route C: turn it into your own version

Every example page ends with "Variants and extensions". For the traffic light: add a phase, add night-time flashing yellow, add pedestrian lights. In each case you change a parameter or add a mode bit first, then extend the output mapping. Verify in simulation again — that's the transition from "reading someone's program" to "defining your own requirement and verifying it yourself", which is the jump the library is ultimately there to help you make.

Route	Who it's for	What you need	What you get
A Read only	Self-study, teaching, quick reference	A browser	Understanding + a logic explanation you can check against
B Import	Engineers / students with a TIA Portal setup	Windows + TIA Portal + TiaLink	Real project objects you can compile and simulate
C Modify	People who want to practice independent design	Everything in B + a bit of patience	Your own variant and a verification habit

6. A 4-week practice plan (copy it as-is)

Week	Suggested examples	Weekly acceptance test
Week 1	Circuit → ladder, basic digital logic, technician logic drills, toggle output	Without looking anything up, draw `Y=(A OR B) AND (NOT C OR D)` as ladder and explain the role of every NC contact
Week 2	Coffee grinder timer, flashing indicator, automatic door with delay, switch + timed output	Explain what TON / TOF / TP each do in that example; change a time parameter and predict the output change
Week 3	Level pump control, assembly line control, traffic light, multi-stage conveyor	Point out each example's interlocks; say what happens if a sensor chatters, and which part of the example exists for exactly that
Week 4	SCL training: storage FB, Factory IO connection, Sorting boxes (Factory IO)	Explain the division of labor between main program and FBs; import an example, compile it, and run the basic flow in simulation

7. Boundaries and caveats (read before you practice)

These are teaching examples, not safety programs you can put into production. Emergency stop, safety circuits and hard interlocks are hardware and functional-safety scope; no example replaces safety design and acceptance.
Many outputs use %M intermediate bits; map them to %Q for your own hardware before connecting real devices.
Import has environment prerequisites: TiaLink runs on the same machine as TIA Portal and is currently built on TIA Portal V19; MCP / clients can connect from another machine over the LAN.
Import does not equal trustworthy: pre-check, compile, simulation and human review are still all required. Automation saves you repeated copying and address mistakes; engineering responsibility stays with the engineer.
No file downloads — examples only enter a project via TiaLink, though everything is readable on the page.
The library keeps changing: the counts, categories and CPU tags in this article are as of the site on 2026-10-17; check the site for the current state.

8. FAQ

Q1: Does the library cost anything?
The example pages are free to read. Importing depends on TiaLink — see the TiaLink product page for current availability and licensing.

Q2: Can I use it without TIA Portal installed?
Yes, for reading and learning. But importing requires a licensed TIA Portal on the same machine, because TiaLink wraps TIA Portal's Openness capabilities and has to live next to it.

Q3: Can I download the program files from the site?
No. It's designed that way: no files land on disk, everything goes through TiaLink, so there's a pre-check before import and no automatic save after.

Q4: Will importing overwrite blocks with the same name in my project?
By default, no — same-named objects are not overwritten, and there's a pre-check first. Even after the import completes, the project isn't saved automatically, so you can inspect before deciding to keep it.

Q5: Can I use these examples directly on my machines?
Not recommended as-is. The point of a teaching example is to make the logic clear; before real hardware you still need I/O mapping, a safety assessment, commissioning and acceptance.

Q6: Is it suitable for teachers?
Yes. Every page has a signal table, workflow, network-by-network explanation and common questions, usable as worked examples, homework and discussion material; the import feature lets students bring the answers into their own project and verify.

9. Summary

What's missing when people learn ladder logic usually isn't "more knowledge" — it's enough complete, self-checkable practice. Learn-LAD puts 60 exercises into one consistent format: clear requirement, legible diagram, an explanation for every rung, address tables, and the usual pitfalls. Add TiaLink's "pre-check → import → explicit save" and the gap between "I understand it" and "it runs" is no longer a manual retyping exercise.

Where to start? Begin with toggle output — only 4 networks and 2 imported objects, but it already uses self-latching, edges and state evaluation. Then take on traffic light control.

Verification notes

The example library, page structure and counts come from the official Learn-LAD site tia.hubwiz.com/learn-lad, verified 2026-10-17; the import mechanism and version dependencies come from the TiaLink product page.
Example counts, categories and CPU tags are public site data; the current site version is authoritative.

DEV Community