Introduction
When a process requires sequential control, the sequential function chart (SFC) is a useful tool, but complexity can grow quickly. The following methods help you create clearer, more maintainable SFC programs and applications.
What SFC Is
The graphical programming language known as sequential function chart (SFC) is standardized by IEC 61131-3. The chart is read top to bottom, with blocks representing steps, transitions, and actions. This programming style is similar to function block diagram (FBD) programming and shares some of the same limitations that can increase complexity and reduce programming efficiency.
Figure 1. Example SFC layout. Image provided by Schneider Electric.
Get the Basics Right
As with any programming language, investing time in groundwork, layout, and modular design saves time later. SFC is well suited to applications that operate as sequences. It is a versatile solution for automated assembly lines or systems that depend on actuator position, servo position, or boolean sensors to advance to the next step. First review the whole process, then break it into smaller sequences. For example, a pick-and-place station that receives parts from an escapement mechanism might have one sequence for the pick-and-place cycle and another for the escapement mechanism.
Decomposing the process naturally dictates the SFC layout. Use SFC to trigger other processes or outputs, but avoid doing calculations or heavy processing inside the SFC itself. Instead, use handshakes or function blocks to start and coordinate other processes.
Step Example
Figure 2. Example of steps in an SFC.
Appearance Matters
Use the same layout discipline you apply to FBD programming: keep blocks and transitions well spaced and add comments where necessary. SFC supports parallel branches, but add them cautiously. Too many branches can make the chart hard to read.
Best practice is to keep the chart tidy. If wires or lines clutter the view, use reference arrows. Ensure step actions do not overlap transitions or other steps.
Figure 3. Incorrect text spacing and layout (exaggerated).
Forward and Backward Steps
Sequences must be able to advance when required and hold when needed. They must also handle stepping back when necessary. For example, if a long cylinder takes a long time to extend, the sequence must wait for the cylinder to reach the extended sensor before proceeding. Most SFC programs include an input on the transition that tells the controller when it may enter the next step.
That transition input can be implemented in several ways:
- Each transition can have its own set of conditions that allow the sequence to move to the next step. This approach requires custom conditions adjusted for each step, but it makes the reason for each transition clear and allows different conditions per step.
- Create ladder logic outside the SFC that sets a single bit used for each transition. I often prefer an overall "all sensors OK" bit or a monitored fault word. If any faults are pending, the sequence should wait. Using one bit per step reduces SFC complexity and moves processing into separate subroutines.
Handshakes: Interfacing with Subroutines
As with FBD, using handshakes to interact with other subroutines or processes reduces SFC complexity. Avoid placing long conditional expressions directly in SFC steps or outputs. Implement handshake signals and drive conditions in separate subroutines. I like to use UDTs for devices such as cameras and robots and include handshake fields like "start" and "done" in those UDTs. This keeps all communication and control device requirements consolidated in one set of tags.
Application Areas
Returning to the pick-and-place example, create one SFC for the three cylinders and another SFC for the escapement mechanism. If sensors are not in the expected states, each cylinder action, fixture up/down, shuttle extend/retract, and fixture open/close should generate faults.
Monitor a fault word and block forward steps in the SFC if any faults are pending. To handle step delays, some IDEs provide timers built into SFC steps. In Rockwell Automation Studio 5000, for example, each step has configurable parameters including a step timer. Start the pick-and-place SFC when a part is present and the escapement is in the pick position.
Each SFC step sets the expected states for the cylinders; those expected bits act as handshakes. When an expected state changes, a fault remains pending until the cylinder reaches its target, after which the sequence advances.
Practical Benefits
Writing sequences this way lets programmers spend less time implementing low-level sequencing and more time on communication code and machine integration. When reviewing a sequence, it becomes easier to understand what should happen next and what has already occurred.
