Program organization units (POU) in PLC Programming - Deep Dive

Overview - Program organization units (POU)

What is it?

Program Organization Units, or POUs, are the building blocks of a PLC program. They organize code into manageable parts like functions, function blocks, and programs. Each POU has a specific role, such as performing calculations, controlling devices, or managing the overall process. This structure helps keep complex automation tasks clear and easy to maintain.

Why it matters

Without POUs, PLC programs would be long, tangled, and hard to understand or fix. POUs let programmers break down big tasks into smaller, reusable pieces, making automation more reliable and easier to update. This means machines run smoothly, downtime is reduced, and changes can be made quickly when needed.

Where it fits

Before learning POUs, you should understand basic PLC concepts like inputs, outputs, and simple programming languages. After mastering POUs, you can learn advanced topics like structured text programming, task scheduling, and complex control strategies.

Mental Model

Core Idea

POUs are like chapters in a book that organize and separate different parts of a PLC program for clarity and reuse.

Think of it like...

Imagine writing a cookbook where each recipe is a POU. Each recipe (POU) explains how to make one dish, and together they form the whole meal plan (PLC program). You can reuse recipes in different meals or change one without rewriting the entire book.

┌───────────────┐
│   PLC Program │
├───────────────┤
│  ┌─────────┐  │
│  │ Program │  │
│  │  POU    │  │
│  └─────────┘  │
│  ┌─────────┐  │
│  │Function │  │
│  │  POU    │  │
│  └─────────┘  │
│  ┌─────────┐  │
│  │Function │  │
│  │ Block   │  │
│  │  POU    │  │
│  └─────────┘  │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What is a POU in PLC

Concept: Introduce the basic idea of a Program Organization Unit as a code block in PLC programming.

A POU is a named block of code in a PLC program. There are three main types: Programs, Functions, and Function Blocks. Programs control the main logic, Functions perform calculations and return values, and Function Blocks can hold data and logic together.

Result

You understand that POUs are the main parts that make up a PLC program.

Knowing that POUs separate code into types helps you organize and reuse logic effectively.

2

Foundation

Types of POUs and their roles

Concept: Explain the three POU types and what each is used for.

Programs run the main control tasks. Functions are like mini-calculators that take inputs and return outputs without keeping data. Function Blocks combine data and code, like a smart device that remembers its state between runs.

Result

You can identify and choose the right POU type for different tasks.

Understanding POU types prevents mixing logic and data in ways that cause errors or confusion.

3

Intermediate

How POUs interact in a PLC program

🤔Before reading on: do you think POUs run independently or can call each other? Commit to your answer.

Concept: Show how POUs can call or use other POUs to build complex logic.

Programs can call Functions and Function Blocks to perform tasks. Function Blocks can be instantiated multiple times with their own data. This lets you build modular and reusable code pieces that work together.

Result

You see how POUs connect and share work inside a PLC program.

Knowing POU interaction helps you design clear, maintainable automation systems.

4

Intermediate

POU interfaces: inputs, outputs, and variables

🤔Before reading on: do you think POUs can share data directly or only through defined inputs and outputs? Commit to your answer.

Concept: Explain how POUs communicate using inputs, outputs, and internal variables.

Each POU has defined inputs and outputs to exchange data. Programs use variables to store and manipulate data. Function Blocks keep internal variables to remember states between cycles. This clear interface keeps code organized and predictable.

Result

You understand how data flows between POUs and how state is managed.

Recognizing POU interfaces prevents bugs caused by unclear data sharing.

5

Intermediate

Reusing POUs for cleaner code

Concept: Teach how to reuse POUs to avoid repeating code and simplify maintenance.

You can write a Function or Function Block once and use it many times in different Programs. This saves time and reduces errors because you fix bugs in one place. Reuse also makes your program easier to read and update.

Result

You can create modular code that is easier to manage and scale.

Understanding reuse through POUs is key to professional PLC programming.

6

Advanced

POU lifecycle and memory management

🤔Before reading on: do you think all POUs keep their data between PLC cycles? Commit to your answer.

Concept: Explain how different POUs handle data storage and lifecycle during PLC operation.

Programs and Function Blocks keep their data between cycles, so they remember states. Functions do not keep data; they run and return results immediately. This affects how you design control logic and manage memory in your PLC.

Result

You know which POUs keep state and which are stateless.

Knowing POU lifecycle prevents unexpected behavior and memory issues in automation.

7

Expert

Advanced POU usage and optimization

🤔Before reading on: do you think stacking many Function Blocks affects PLC performance? Commit to your answer.

Concept: Discuss best practices for using POUs efficiently and avoiding common pitfalls in large systems.

Using many instances of Function Blocks can increase memory and CPU load. Experts optimize by minimizing unnecessary instances and using efficient data types. Also, understanding task priorities and POU execution order improves system responsiveness.

Result

You can write high-performance PLC programs using POUs wisely.

Mastering POU optimization is crucial for reliable, scalable industrial automation.

Under the Hood

At runtime, the PLC executes Programs cyclically, calling Functions and Function Blocks as needed. Function Blocks maintain internal memory areas to store state between cycles, while Functions execute stateless calculations. The PLC runtime manages memory allocation for each POU instance and schedules execution based on task priorities.

Why designed this way?

POUs were designed to modularize complex control logic, making programs easier to build, test, and maintain. Separating stateless Functions from stateful Function Blocks allows efficient memory use and clear logic separation. This design balances flexibility with performance in industrial environments.

┌───────────────┐
│   PLC Runtime │
├───────────────┤
│  ┌─────────┐  │
│  │ Program │◄─────┐
│  └─────────┘      │
│       │           │
│       ▼           │
│  ┌─────────┐      │
│  │Function │      │
│  └─────────┘      │
│       │           │
│       ▼           │
│  ┌─────────────┐  │
│  │FunctionBlock│  │
│  │ (with state)│  │
│  └─────────────┘  │
└───────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do Functions in PLC keep their data between cycles? Commit to yes or no.

Common Belief: Functions keep their data between PLC cycles like Function Blocks do.

Reality: Functions are stateless and do not retain data between cycles; only Function Blocks and Programs keep state.

Why it matters: Assuming Functions keep state can cause logic errors and unexpected behavior in control systems.

Quick: Can you call a Program from another Program directly? Commit to yes or no.

Common Belief: Programs can call other Programs directly like Functions or Function Blocks.

Reality: Programs cannot be called like Functions; they are the main execution units and run according to the PLC task configuration.

Why it matters: Trying to call Programs like Functions leads to confusion and programming errors.

Quick: Is it okay to create many instances of Function Blocks without concern? Commit to yes or no.

Common Belief: Creating many Function Block instances has no impact on PLC performance or memory.

Reality: Each Function Block instance consumes memory and CPU time; excessive instances can degrade performance.

Why it matters: Ignoring resource use can cause slowdowns or crashes in industrial control systems.

Quick: Do all POUs share the same variable space by default? Commit to yes or no.

Common Belief: All POUs share variables globally unless explicitly separated.

Reality: Each POU has its own variable scope; variables are local unless declared global or passed explicitly.

Why it matters: Misunderstanding variable scope causes bugs and unpredictable program behavior.

Expert Zone

1

Function Blocks can be designed with initialization code that runs only once, which is critical for setting up hardware or communication parameters.

2

The execution order of POUs within a task can affect program behavior, especially when POUs share data or control outputs.

3

Some PLC platforms allow POUs to be parameterized with generic types, enabling highly reusable and type-safe code blocks.

When NOT to use

Avoid using Function Blocks when you only need simple, stateless calculations; use Functions instead for efficiency. For very simple logic, inline code in Programs may be sufficient. When real-time constraints are tight, minimize complex POU nesting to reduce execution time.

Production Patterns

In real-world systems, engineers use Function Blocks to model physical devices like motors or sensors, encapsulating their state and control logic. Programs orchestrate overall process flow by calling these blocks. Functions handle calculations like PID control or data conversions. Modular POU design enables easier troubleshooting and updates.

Connections

Modular Programming

POUs implement modular programming principles in PLC code.

Understanding POUs as modules helps grasp how breaking code into parts improves clarity and reuse, a principle common in all programming.

Object-Oriented Programming (OOP)

Function Blocks in POUs resemble objects with data and methods.

Seeing Function Blocks as objects clarifies how PLCs manage state and behavior together, bridging PLC and software engineering concepts.

Manufacturing Process Control

POUs map directly to physical devices and control steps in manufacturing.

Knowing how POUs represent real machines and processes helps design automation that matches physical reality, improving reliability.

Common Pitfalls

#1 Mixing stateful and stateless logic in Functions causing unexpected results.

Wrong approach:

FUNCTION CalculateSpeed : REAL
VAR_INPUT
Distance : REAL;
Time : REAL;
END_VAR
VAR
LastSpeed : REAL; // Trying to keep state here
END_VAR
CalculateSpeed := Distance / Time + LastSpeed;
LastSpeed := CalculateSpeed;
END_FUNCTION

Correct approach:

FUNCTION CalculateSpeed : REAL
VAR_INPUT
Distance : REAL;
Time : REAL;
END_VAR
CalculateSpeed := Distance / Time;
END_FUNCTION

Root cause:

Functions do not retain variable values between calls; trying to keep state inside a Function breaks this rule.

#2 Calling a Program like a Function inside another Program.

Wrong approach:

PROGRAM MainProgram
CALL SubProgram(); // Incorrect call
END_PROGRAM

Correct approach:

PROGRAM MainProgram
// SubProgram runs as separate task or called via task configuration
END_PROGRAM

Root cause:

Programs are top-level execution units and cannot be called like Functions.

#3 Creating too many Function Block instances without considering resource limits.

Wrong approach:

VAR
Motor1 : MotorBlock;
Motor2 : MotorBlock;
Motor3 : MotorBlock;
Motor4 : MotorBlock;
Motor5 : MotorBlock;
Motor6 : MotorBlock;
Motor7 : MotorBlock;
Motor8 : MotorBlock;
Motor9 : MotorBlock;
Motor10 : MotorBlock;
END_VAR

Correct approach:

VAR
Motors : ARRAY[1..10] OF MotorBlock;
END_VAR
// Use array to manage instances efficiently

Root cause:

Not managing instances efficiently can waste memory and CPU, reducing system performance.

Key Takeaways

Program Organization Units (POUs) are essential building blocks that organize PLC programs into manageable, reusable parts.

There are three main POU types: Programs for main logic, Functions for stateless calculations, and Function Blocks for stateful logic with memory.

POUs communicate through defined inputs, outputs, and variables, which keeps data flow clear and predictable.

Understanding POU lifecycle and memory use is critical to avoid bugs and optimize PLC performance.

Expert use of POUs involves modular design, efficient resource management, and aligning code structure with physical automation processes.

Practice

1. Which of the following is NOT a type of Program Organization Unit (POU) in PLC programming?

easy

A. MODULE

B. PROGRAM

C. FUNCTION

D. FUNCTION_BLOCK

Solution

1. Step 1: Recall POU types

   The three main POUs are PROGRAM, FUNCTION_BLOCK, and FUNCTION.

2. Step 2: Identify the incorrect option

   MODULE is not a standard POU type in PLC programming.

3. Final Answer:

   MODULE -> Option A

4. Quick Check:

   POUs = PROGRAM, FUNCTION_BLOCK, FUNCTION [OK]

Hint: Remember only three POUs: PROGRAM, FUNCTION_BLOCK, FUNCTION [OK]

Common Mistakes:

• Confusing MODULE with FUNCTION_BLOCK
• Thinking FUNCTION_BLOCK is not a POU
• Mixing hardware modules with POUs

2. Which syntax correctly declares a FUNCTION_BLOCK named MotorControl in IEC 61131-3 standard?

easy

A. PROGRAM MotorControl
END_PROGRAM

B. FUNCTION MotorControl
END_FUNCTION

C. FUNCTION_BLOCK MotorControl
END_FUNCTION_BLOCK

D. FUNCTION_BLOCK MotorControl() END_FUNCTION_BLOCK

Solution

1. Step 1: Identify correct POU declaration syntax

   FUNCTION_BLOCK declaration starts with 'FUNCTION_BLOCK Name' and ends with 'END_FUNCTION_BLOCK'.

2. Step 2: Check each option

   FUNCTION_BLOCK MotorControl END_FUNCTION_BLOCK matches correct syntax; PROGRAM and FUNCTION declare different POUs; the version with parentheses is invalid.

3. Final Answer:

   FUNCTION_BLOCK MotorControl\nEND_FUNCTION_BLOCK -> Option C

4. Quick Check:

   FUNCTION_BLOCK syntax = FUNCTION_BLOCK MotorControl END_FUNCTION_BLOCK [OK]

Hint: FUNCTION_BLOCK has no parentheses in declaration [OK]

Common Mistakes:

• Adding parentheses to FUNCTION_BLOCK
• Confusing FUNCTION and FUNCTION_BLOCK syntax
• Using PROGRAM keyword for function blocks

3. Given the following FUNCTION in a PLC program:

FUNCTION AddTwo : INT
VAR_INPUT
  a : INT;
  b : INT;
END_VAR
AddTwo := a + b;
END_FUNCTION

What is the output of calling AddTwo(3, 5)?

medium

A. 8

B. 35

C. Error: FUNCTION cannot be called like this

D. 0

Solution

1. Step 1: Understand FUNCTION behavior

   The FUNCTION AddTwo takes two INT inputs and returns their sum.

2. Step 2: Calculate the output for inputs 3 and 5

   3 + 5 = 8, so the function returns 8.

3. Final Answer:

   8 -> Option A

4. Quick Check:

   3 + 5 = 8 [OK]

Hint: Functions return values; sum inputs to get output [OK]

Common Mistakes:

• Concatenating inputs as strings
• Thinking FUNCTION_BLOCKs return values
• Assuming syntax error on call

4. Identify the error in this FUNCTION_BLOCK declaration:

FUNCTION_BLOCK Timer
VAR
  StartTime : TIME;
END_VAR
METHOD Start()
  StartTime := TIME();
END_METHOD
END_FUNCTION_BLOCK

medium

A. METHOD keyword is not allowed inside FUNCTION_BLOCK

B. TIME() is not a valid way to get current time

C. StartTime variable must be VAR_INPUT

D. FUNCTION_BLOCK must not have variables

Solution

1. Step 1: Check METHOD usage in FUNCTION_BLOCK

   METHODs are allowed inside FUNCTION_BLOCKs to define actions.

2. Step 2: Verify TIME() usage

   TIME() is not a standard function to get current time in PLC; this causes an error.

3. Final Answer:

   TIME() is not a valid way to get current time -> Option B

4. Quick Check:

   Invalid TIME() call = TIME() is not a valid way to get current time [OK]

Hint: Check if functions used are standard PLC functions [OK]

Common Mistakes:

• Assuming METHODs are disallowed
• Thinking all variables must be inputs
• Believing FUNCTION_BLOCKs can't have variables

5. You want to create reusable code that holds internal state and can be called multiple times with different inputs. Which POU type should you choose and why?

hard

A. FUNCTION, because it can be called multiple times with different inputs

B. PROGRAM, because it organizes the entire PLC project

C. FUNCTION, because it returns a value and holds state internally

D. FUNCTION_BLOCK, because it can hold data and be reused with different instances

Solution

1. Step 1: Understand POU types and their features

   FUNCTION_BLOCKs can hold internal data/state and be instantiated multiple times.

2. Step 2: Compare with other POUs

   FUNCTIONs return values but do not hold state; PROGRAMs organize code but are not reusable units with state.

3. Final Answer:

   FUNCTION_BLOCK, because it can hold data and be reused with different instances -> Option D

4. Quick Check:

   Reusable with state = FUNCTION_BLOCK [OK]

Hint: Use FUNCTION_BLOCK for reusable code with internal state [OK]

Common Mistakes:

• Choosing FUNCTION for holding state
• Confusing PROGRAM with reusable unit
• Ignoring difference between FUNCTION and FUNCTION_BLOCK