The SFC Editor (Sequential Function Chart) provides a graphical view of the step-and-transition sequence within a process, following the IEC 61131-3 GRAFCET standard. It visualizes how steps connect through conditions, making complex process flows easy to understand and edit.
Access: Open a module → Module Ribbon → Conditions panel → SFC button.
🔎 Overview
The SFC Editor renders the entire process as a directed graph where:
-
Steps (phases) are shown as rectangular nodes
-
Transitions (conditions) are shown as labeled edges connecting steps
-
The graph supports parallel fork, parallel merge, and jump patterns for complex branching logic
The editor is built on the GraphX library and uses orthogonal edge routing for clean, readable layouts.
🧩 Graph Elements
📦 Step Nodes (Vertices)
Each node in the graph represents one of four vertex kinds:
|
Vertex Kind |
Visual |
Description |
|---|---|---|
|
Step (process phase) |
Rectangle with step name and index |
A process step. The primary building block of the SFC. Displays the step name and its index in the process. |
|
Parallel Fork (simultaneous branches) |
Diamond / junction node |
Represents a single condition that branches to multiple target steps. Used when one condition has several success or failure outcomes — all branches activate simultaneously. |
|
Parallel Merge (synchronization point) |
Diamond / merge node |
Represents multiple conditions converging into the same target step. AseptSoft auto-detects when several edges from different source steps share the same target and merges them visually. The target step activates only when all incoming conditions are satisfied. |
|
Jump (teleport to another step) |
Teleport pair (entry + exit) |
A visual shortcut that connects distant parts of the graph without drawing long edges. Created in pairs — one entry node near the source, one exit node near the target. |
Info: Only Step (process phase) vertices can be edge targets when dragging new connections. Fork and merge vertices are managed automatically by the system.
🔀 Edges (Transitions)
Edges represent transitions between steps. Each edge carries a condition text describing when the transition fires. There are 10 edge visual kinds that determine how the edge is displayed and what actions are available:
Simple Transitions
|
Edge Kind |
Description |
|---|---|
|
ConditionSingle |
A direct Step → Step connection. Shows the condition label and provides a full editor with actions for editing, duplicating, forking, and deleting. |
Parallel Fork Edges
|
Edge Kind |
Description |
|---|---|
|
ConditionMultiHead |
Step → Parallel Fork vertex. Shows the condition label with editor and supports duplicate/fork/edit actions. This is the "head" edge leading into the fork. |
|
ConditionMultiChild |
Parallel Fork → Step. No label is shown (the condition text is on the head edge). Only a delete button is available. These are the "child" branches of the fork. |
Parallel Merge Edges
|
Edge Kind |
Description |
|---|---|
|
AntiForkIncomingUnified |
Incoming edges when all merging conditions share the same text. A single shared label is displayed. |
|
AntiForkIncomingMixed |
Incoming edges when conditions have different texts. Individual labels are shown per edge. |
|
AntiForkOutgoingUnified |
The outgoing edge from the merge point when all incoming conditions share text. Shows the common label. |
|
AntiForkOutgoingMixed |
The outgoing edge from the merge point when conditions differ. Only a delete button is available. |
Jump Edges
|
Edge Kind |
Description |
|---|---|
|
TeleportEntryLabeled |
Non-teleport source → first jump node. Shows the condition label with full editor and actions. |
|
TeleportEntryPlain |
Non-teleport source → first jump node. No label; only delete and fork actions available. |
|
TeleportExitPlain |
Second jump node → non-teleport target. No label; delete and fork actions available. Can be rebound to a different target step by dragging. |
🎯 Condition Types
Each condition in the algorithm has a type based on the IEC 61131-3 standard. The SFC Editor displays these using distinct visual tokens and colors (configurable via Algorithm Colours in the Module Ribbon):
|
Type |
Description |
|---|---|
|
Transition condition |
Determines when to move to the next step — fires when the boolean expression becomes true |
|
Continuous action |
Runs continuously while the step is active — the action executes every scan cycle for the duration of the step |
|
Conditional continuous action |
Runs while both the step is active AND the condition is true — a guarded version of the continuous action |
|
Execute on activation |
Fires once when the step becomes active (rising edge) — used for one-shot initialization tasks |
|
Execute on deactivation |
Fires once when the step becomes inactive (falling edge) — used for cleanup or finalization tasks |
|
Execute on event |
Fires when a specific event occurs during the step — event-driven behavior within an active step |
|
Custom action |
User-defined behavior — for specialized logic that doesn't fit the standard IEC 61131-3 categories |
Tip: You can customize the colors for each condition type using the Algorithm Colours button in the Conditions panel of the Module Ribbon.
🏭 Pharma Example: CIP Sequence as a GRAFCET
This example shows a complete Clean-In-Place (CIP) sequence modeled as a Sequential Function Chart. CIP is one of the most common automated processes in pharmaceutical manufacturing.
📋 Steps (Process Phases)
|
Step |
Name |
Description |
|---|---|---|
|
0 |
Idle |
System at rest, all valves closed, pumps off |
|
1 |
Pre-Rinse |
Flush the circuit with purified water to remove product residues |
|
2 |
Caustic Wash |
Circulate NaOH solution (typically 0.5-1.0 M) at elevated temperature |
|
3 |
Intermediate Rinse |
Flush with purified water to remove caustic residues |
|
4 |
Acid Wash |
Circulate phosphoric or nitric acid solution for mineral deposit removal |
|
5 |
Final Rinse |
Final purified water flush to meet conductivity specifications |
|
6 |
Drain |
Drain all remaining fluid from the circuit |
|
7 |
Return to Idle |
Reset all valves and confirm system is ready for production |
🔀 Transitions (Step-to-Step Conditions)
|
From |
To |
Transition Condition |
Type |
|---|---|---|---|
|
Idle |
Pre-Rinse |
Operator starts CIP cycle (start command received) |
Transition condition |
|
Pre-Rinse |
Caustic Wash |
Pre-rinse timer complete (e.g., 5 minutes elapsed) |
Transition condition |
|
Caustic Wash |
Intermediate Rinse |
Caustic temperature held for required duration (e.g., 75 degrees C for 20 minutes) |
Transition condition |
|
Intermediate Rinse |
Acid Wash |
Rinse water conductivity below threshold (e.g., < 50 uS/cm) |
Transition condition |
|
Acid Wash |
Final Rinse |
Acid wash timer complete AND temperature target maintained |
Transition condition |
|
Final Rinse |
Drain |
Final rinse conductivity below specification (e.g., < 10 uS/cm) |
Transition condition |
|
Drain |
Idle |
Drain complete (flow sensor reads zero for 30 seconds) |
Transition condition |
▶️ Continuous Actions (Run While Step Is Active)
|
Step |
Continuous Action |
Description |
|---|---|---|
|
Pre-Rinse |
Open inlet valve V-101 and return valve V-103; start CIP pump P-101 |
Maintains water circulation throughout the pre-rinse |
|
Caustic Wash |
Open chemical dosing valve V-104; maintain pump speed; regulate heater |
Keeps caustic solution circulating at target temperature |
|
All rinse steps |
Monitor temperature sensor TT-101 and conductivity sensor CT-101 |
Continuous monitoring provides data for transition decisions |
⚡ Actions on Activation (Execute Once When Step Starts)
|
Step |
Stored Action |
Description |
|---|---|---|
|
Pre-Rinse |
Record batch start time and CIP cycle ID |
Logged for batch records and regulatory traceability |
|
Caustic Wash |
Log chemical dosing start; record initial conductivity reading |
Captured for quality documentation |
|
Final Rinse |
Reset rinse counter; record final rinse start |
Ensures fresh counting for the final validation rinse |
🔄 Conditional Continuous Actions
|
Step |
Condition |
Action |
Description |
|---|---|---|---|
|
Caustic Wash |
Temperature < 75 degrees C |
Increase heater power to maximum |
Only activates the heater boost when temperature drops below setpoint |
|
Final Rinse |
Conductivity > 5 uS/cm |
Continue recirculation (do not advance to drain) |
Keeps rinsing until water quality is acceptable |
Note: This CIP example demonstrates all the major GRAFCET condition types working together. The sequence is linear (no parallel forks), but in practice you might add parallel branches for simultaneous tank draining and line blowing.
⚙️ Graph Building Pipeline
When you open the SFC Editor or switch processes, the graph is built through these stages:
-
Load Domain Data — The adapter queries all steps, conditions, and transitions from the active process
-
Create Step Vertices — One vertex per step, positioned using saved coordinates (or auto-layout if new)
-
Create Transition Edges — Each condition's success/failure targets become directed edges
-
Detect Parallel Forks — When a single condition has multiple target steps, a Parallel Fork vertex is inserted
-
Detect Parallel Merges — When multiple conditions from different sources share the same target, a Parallel Merge vertex is created. The system checks whether all incoming condition texts match (unified vs. mixed)
-
Create Jump Pairs — For conditions marked with teleport endpoints, entry/exit node pairs are created with matching display IDs
-
Route Edges — The orthogonal edge routing algorithm computes clean right-angle paths for all connections
-
Place Labels — Edge labels are positioned on vertical segments using a reservation system to avoid overlaps
🔱 Parallel Fork Branching
A parallel fork occurs when a single condition leads to multiple target steps that activate simultaneously. For example, a condition might transition to Step 3 on success and Step 5 on failure, while also having additional fork targets.
How it works:
-
The condition becomes a Parallel Fork diamond vertex
-
The original edge (Step → diamond) carries the condition label
-
Each target step gets a child edge (diamond → Step) without labels
-
You can add more fork targets by using the Fork action on any edge
Edge creation modes:
-
New Success Transition — Create a brand new transition to a target step
-
Duplicate Transition — Clone an existing transition's condition text to a new target
-
Fork Transition — Add a new branch from an existing parallel fork condition
🔗 Parallel Merge
A parallel merge occurs when multiple transitions from different source steps converge on the same target step. The SFC Editor automatically detects this pattern.
Detection logic:
-
The system groups all incoming edges by their target step
-
If a target step has incoming edges from 2+ different source steps, a Parallel Merge vertex is created
-
If all incoming conditions share the same text → Unified display (single shared label)
-
If conditions differ → Mixed display (individual labels per incoming edge)
🚀 Jump Nodes
Jumps are visual shortcuts for connecting distant parts of the graph without cluttering the layout with long edges.
Structure:
-
Each jump consists of a pair of vertices
-
The entry node is placed near the source step
-
The exit node is placed near the target step
-
Both nodes share a pair key and display a matching ID for visual identification
When to use jumps:
-
When the source and target steps are far apart in the graph
-
To reduce visual clutter from long crossing edges
-
To keep the graph readable when many transitions span large distances
📐 Edge Routing
The SFC Editor uses an orthogonal edge routing algorithm that produces clean, right-angle paths:
🔧 Routing Strategy
-
Naive Route Computation — Each edge gets an initial orthogonal path based on source/target positions
-
Connection Points — Routes connect to specific anchor points on vertices (top, bottom, or indexed connection points for forks)
-
Special Routing for Forks — Parallel Fork vertices use left/right fanning for child edges; Parallel Merge vertices use controlled approach angles
-
Label Placement — Labels are placed on vertical segments of the route, with a reservation system that prevents overlaps. The algorithm tries three strategies in order:
-
Place on the first vertical segment below the source (if single outgoing)
-
Place on the last vertical segment above the target (if single incoming)
-
Fall back to an intermediate vertical segment
-
-
Hidden Loops — When the desired label distance doesn't match the natural route midpoint, small forward/backward loops are inserted at the start or end of the route to shift the label position
📏 Layout Constants
|
Setting |
Value |
Purpose |
|---|---|---|
|
Edge first-turn padding |
45 px |
Minimum distance before the first orthogonal turn |
|
Label offset from vertex |
55 px |
Distance from vertex center to label position |
|
Label turn clearance |
5 px |
Minimum gap between label and route corner |
|
Label minimum separation |
3 px |
Minimum gap between adjacent labels |
⚠️ Dangling Conditions
Some conditions may not have any transition targets assigned yet. These are called dangling conditions and are displayed as a list on their parent step vertex. This helps you identify incomplete step configurations that still need transitions.
📤 Exporting to Visio
The SFC graph can be exported to Microsoft Visio format for external documentation. See Export Dialogs to Visio for details on the GRAFCET Visio export, which maps each graph element to Visio shapes with metadata cells.
Exported elements include:
-
Steps (initial and regular) with index, name, and description
-
Conditions with their types and texts
-
Fork and merge junctions
-
Jump nodes with display IDs
-
Edge labels with transition details
-
Nested action elements (timed actions, conditional actions, etc.)
📋 How To: Build an SFC for a CIP Process
Follow this step-by-step workflow to create a Sequential Function Chart for a CIP (Clean-In-Place) process in AseptSoft.
Step 1 — Open the SFC Editor
Navigate to the Module Ribbon → Conditions panel → SFC button.
Step 2 — Ensure the process and steps exist
Before building the SFC, make sure the Process has been created with all required steps (e.g., Idle, Pre-Rinse, Caustic Wash, Intermediate Rinse, Acid Wash, Final Rinse, Drain). Steps are created in the Process Design area.
Step 3 — Arrange the step nodes
When the SFC Editor opens, all steps appear as rectangular nodes. Drag them into a logical top-to-bottom flow representing the CIP sequence. Place Idle at the top and Drain at the bottom.
Step 4 — Create transition conditions
Drag from one step node to the next to create a transition. In the condition editor that appears, enter the transition logic:
-
Idle → Pre-Rinse: "CIP start command received"
-
Pre-Rinse → Caustic Wash: "Pre-rinse timer elapsed (5 min)"
-
Caustic Wash → Intermediate Rinse: "Caustic hold time complete at target temperature"
-
And so on for each step transition.
Step 5 — Add continuous actions
For each step that needs ongoing behavior (e.g., keeping pumps running, monitoring sensors), add Continuous action conditions. These run every scan cycle while the step is active.
Step 6 — Add activation/deactivation actions
For one-shot tasks like logging the CIP start time or recording a batch ID, add Execute on activation conditions to the relevant steps. For cleanup tasks, add Execute on deactivation conditions.
Step 7 — Configure conditional continuous actions
For actions that only run under certain conditions within a step (e.g., boost heater when temperature drops), add Conditional continuous action entries with the appropriate guard condition.
Step 8 — Add the return-to-idle loop
Create a transition from the Drain step back to Idle, forming a complete cycle. If the graph becomes cluttered, use a Jump to connect the bottom of the chart back to the top cleanly.
Step 9 — Validate the chart
Check for dangling conditions (conditions without targets) shown on step nodes. Ensure every step has at least one outgoing transition. Review the complete flow matches your CIP recipe specification.
Step 10 — Test with the algorithm
Use the Algorithm Design tools to verify the SFC executes correctly — step through each phase and confirm transitions fire at the right conditions.
Tip: Use the CIP example above as a template. Most CIP processes follow a linear sequence; add parallel forks only when truly needed (e.g., simultaneous tank drain and line blowing).
🖱️ Keyboard and Mouse Interactions
|
Action |
How |
|---|---|
|
Pan |
Click and drag on empty canvas area |
|
Zoom |
Mouse wheel |
|
Select step |
Click on a step vertex |
|
Edit condition |
Click the label on a ConditionSingle or ConditionMultiHead edge |
|
Create transition |
Drag from a step vertex to a target step |
|
Delete transition |
Use the delete button on the edge label |
|
Fork a transition |
Use the fork action on any edge to add a branch |
|
Rebind jump exit |
Drag the jump exit edge endpoint to a different step |
|
Move vertex |
Drag any vertex to reposition it (positions are saved) |
Note: Vertex positions are saved per-process and restored when you reopen the editor.
📚 Related Pages
-
Module Ribbon — Access the SFC Editor from the Conditions panel
-
Algorithm Design — Conditions and algorithm editing
-
Process Design — Process and step management
-
Algorithm Attributes — Attribute configuration for conditions
-
Export Dialogs to Visio — GRAFCET Visio export details
-
Valve Phase Matrix — Complementary matrix view of valve states across phases
-
Symbol Editor — Symbol definition editor
-
Engineering Item — Engineering item data model
-
State — State definitions and custom values