Program organization units (POU) in PLC Programming - Step-by-Step Execution

Concept Flow - Program organization units (POU)

Start PLC Project

↓

Create POU: Program

↓

Create POU: Function

↓

Create POU: Function Block

↓

Use POUs in Main Program

↓

Compile and Run PLC

↓

POUs Execute in Order

This flow shows how a PLC project is organized by creating different POUs (Program, Function, Function Block) and then using them in the main program to run the control logic.

Execution Sample

PLC Programming

PROGRAM MainProgram
VAR
  counter: INT := 0;
END_VAR
counter := counter + 1;
END_PROGRAM

This simple POU program increments a counter variable by 1 each scan cycle.

Execution Table

Step	Action	Variable	Value Before	Value After	Notes
1	Start scan cycle	counter	0	0	Initial value at start
2	Execute MainProgram	counter	0	1	counter incremented by 1
3	End scan cycle	counter	1	1	Value retained for next cycle
4	Start next scan cycle	counter	1	1	Value carried over
5	Execute MainProgram	counter	1	2	counter incremented again

💡 Execution continues each scan cycle, incrementing counter by 1 each time.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
counter	0	1	1	2	2

Key Moments - 3 Insights

Why does the counter keep its value between scan cycles?

Because the variable 'counter' is declared in the VAR section of the POU, it retains its value between executions as shown in execution_table rows 3 and 4.

What is the difference between a Program and a Function Block POU?

A Program POU runs cyclically and can hold persistent variables, while a Function Block POU can be instantiated multiple times with its own data, allowing reuse and encapsulation.

Why do we need different POUs in a PLC project?

Different POUs help organize code logically: Programs for main logic, Functions for reusable calculations without memory, and Function Blocks for reusable components with memory.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'counter' after Step 2?

A 0

B 2

C 1

D Undefined

💡 Hint

Check the 'Value After' column for Step 2 in the execution_table.

At which step does the scan cycle end?

A Step 3

B Step 1

C Step 5

D Step 4

💡 Hint

Look for the row with 'End scan cycle' in the Action column.

If we reset 'counter' to 0 at the start of each scan, how would the value after Step 5 change?

A It would be 0

B It would be 1

C It would be 2

D It would be undefined

💡 Hint

If counter resets to 0 each cycle, incrementing once makes it 1 after Step 5.

Concept Snapshot

Program Organization Units (POU) in PLC:
- POUs are building blocks: Program, Function, Function Block
- Programs run cyclically and hold persistent variables
- Functions perform calculations without memory
- Function Blocks are reusable with their own data
- POUs organize and structure PLC code clearly

Full Transcript

Program Organization Units (POUs) are the main building blocks in PLC programming. A typical PLC project starts by creating POUs such as Programs, Functions, and Function Blocks. Programs run cyclically and can hold variables that keep their values between scan cycles. Functions are used for calculations and do not keep memory. Function Blocks are reusable components with their own data and can be instantiated multiple times. In the example, a Program POU named MainProgram has a variable 'counter' initialized to 0. Each scan cycle, the program increments 'counter' by 1. The execution table shows the value of 'counter' before and after each step, demonstrating how it retains its value between cycles. Understanding POUs helps organize PLC code logically and makes it easier to maintain and reuse.

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