Seqchart user guide

Getting started: a first chart in two minutes

Not for controlling real machinery. Seqchart is for education and preliminary design. It is NOT for controlling real machinery: it simulates control logic on a virtual scan cycle and has no real-time guarantees, no safety function, no certification and no connection to hardware. Results must be checked by a qualified professional and are not a substitute for code-compliant design, a safety assessment or licensed engineering judgement.

1. Press Examples and choose Traffic light. The chart opens in the Chart tab.
2. Press Space (or Run). The green step lights up, the lamps in the I/O panel follow the chart, and the timing chart at the bottom draws every signal.
3. Click the Pedestrian button in the I/O panel (or press the digit key shown next to it). The request latches and the green phase ends once it has lasted 5 s.
4. Press . (full stop) to run exactly one scan, then read the Scan log: it lists the inputs applied, the transitions that fired and the actions that ran.
5. Select a step in the chart, press Enter, and change an action's qualifier. The change takes effect when you next run; the simulator reloads from the edited chart.
6. File > Save downloads a .seqchart.json file. Your work is also kept in this browser automatically.

Start from Blank project to build your own: add steps and transitions in the Chart tab, declare variables in the Structured Text tab, and map the variables you want on the panel in the I/O map tab.

The workspace

On a phone the panels become tabs along the bottom edge; everything is reachable by touch and nothing needs hover.

The scan cycle

Seqchart simulates a programmable controller's repeating scan on a virtual clock. Scan number k happens at the time t = k x scan period. There is no real-time behaviour: a run can go faster or slower than real time, and time stops when you pause.

Every scan does these six things in this fixed order:

1. Inputs. Scripted input events due at or before t, then panel changes, then forced values, are written to the variables.
2. Flags. The step flags are refreshed: Step.X (TRUE while the step is active) and Step.T (time since the step became active, as TIME).
3. Evolution. The chart evolves (see Charts). Every transition that can fire does so together, judged from the situation at the start of the scan. A token therefore moves at most one transition per scan.
4. Actions. Qualifiers decide which actions are on this scan. Boolean targets are written; action bodies run.
5. Program. The PROGRAM body runs: plant models, interlocks, timers, counters.
6. Outputs. Forces are applied again and the trace records every changed signal.

Because inputs are applied first and the program runs last, an output computed by the program is seen by the chart one scan later. The scan period (1 to 1000 ms) is a setting of the project.

Charts: steps, transitions and branching

Step. A named box that is either active or not. The double-bordered step is initial: it is active at the start (a chart may have several initial steps, one token each). A step name must be a valid name (letters, digits, underscore), unique, and different from the program's variables.

Transition. A bar between steps, with a Boolean Structured Text condition. It lists the steps before it (from) and after it (to).

Evolution rules. These are the rules Seqchart implements (written for this tool, see Sources):

1. At the start, exactly the initial steps are active.
2. A transition is enabled when every step in its from list is active.
3. An enabled transition fires when its condition is TRUE.
4. Firing deactivates all its from steps and activates all its to steps at the same moment.
5. All transitions that can fire in a scan fire together, judged from the situation at the start of that scan. A step that is deactivated and activated by the same evolution simply stays active and its Step.T keeps running.
6. If two TRUE enabled transitions share a source step, they conflict: the one earlier in the transition list (its priority) fires and the other does not. This is how alternative branches are resolved when more than one condition is TRUE.

Branching, all expressed by the lists of one transition or by several transitions:

The diagnostics list warns about steps that can never become active and about steps with no way out. If more than one token reaches a step, the Scan log reports that the chart is not safe (a step was already active).

Action qualifiers

Each step has a list of actions: a qualifier, a target, and for timed qualifiers a time. The target is either a BOOL variable (which the chart then drives) or the name of an action body from the Actions tab (which runs while the qualifier is on). Several actions on one target are combined with OR.

Definitions used by Seqchart (our own written definitions; other tools differ in details such as the exact meaning of the pulse qualifiers):

Elapsed time is measured in whole scans: a delay of 30 ms at a 10 ms scan period is satisfied in the third scan after entry (elapsed 30 ms), a delay that is not a multiple of the period is satisfied on the first scan at or after it.

Structured Text subset

A documented subset of PLC-style languages (sequential function charts and structured text), written from openly available general descriptions. It is not a conforming implementation of any standard, and no standard text is reproduced.

Source layout. Optional TYPE blocks (enumerations), then any number of FUNCTION_BLOCK and FUNCTION definitions (each may use only blocks and functions defined before it), then exactly one PROGRAM. Names are not case sensitive. Comments are (* ... *) (not nested) and // ... to the end of the line.

Variables. VAR, VAR_INPUT and VAR_OUTPUT blocks, optionally CONSTANT, with initial values: Count : INT := 3;, Table : ARRAY[0..9] OF INT := [1, 2, 3];.

Number literals: decimal (1_000), 2#1010, 8#17, 16#FF, real (1.5, 2.5e-3).

Operators, from tightest to loosest: **; unary - + NOT; * / MOD; + -; < > <= >=; = <>; AND &; XOR; OR. AND and OR stop evaluating as soon as the result is known (left to right). Integer division truncates toward zero. MOD has the sign of the dividend. ** always gives REAL. Mixing INT, DINT and REAL converts operands to the larger type before comparison or arithmetic. Selection functions convert their selected value too; every REAL assignment rounds to binary32. Powers associate right to left: 2 ** 3 ** 2 is 512; -2 ** 2 is -4; 2 ** -2 is 0.25. Narrowing needs a conversion function.

Statements: assignment; IF / ELSIF / ELSE; CASE with values, comma lists, ranges (1..5) and ELSE; FOR i := a TO b BY c DO (bounds evaluated once; after normal completion the counter holds the first value outside the range); WHILE; REPEAT ... UNTIL; EXIT (Seqchart requires an enclosing FOR, WHILE or REPEAT loop); RETURN; function block calls blk(IN := x, PT := T#2s);.

Functions. ABS, MIN, MAX, LIMIT(min, value, max), SEL(g, in0, in1), SQRT, TRUNC, REAL_TO_INT (rounds half away from zero), REAL_TO_DINT, INT_TO_REAL, DINT_TO_REAL, INT_TO_DINT, DINT_TO_INT, BOOL_TO_INT, INT_TO_BOOL, TIME_TO_DINT, DINT_TO_TIME, and your own FUNCTIONs (positional or named arguments; the function name is the result variable).

Predefined. SCAN_MS (DINT, the scan period) and, for every step, Step.X and Step.T.

Faults. Division by zero, an array index out of range, a numeric overflow of REAL, an out-of-range conversion and exceeding the step budget (200,000 operation units in one scan: each statement, function/block invocation, loop pass and copied array entry costs one unit) stop the simulation and are reported with the unit and line. Reset clears a fault.

Not in the subset: bit operations on integers, strings, structures, pointers, global variable lists, LREAL/LINT and other widths, dates, recursion, and the object-oriented extensions.

Standard blocks

Behaviour as implemented, written from our own definitions. Time comes from the scan clock, so a timer sees time advance by exactly one scan period per scan. Edges are detected between consecutive calls; before the first call the previous input value is FALSE.

Declare an instance, then call it every scan: Delay : TON; and Delay(IN := Start, PT := T#2s); Ready := Delay.Q;. Inputs you leave out keep their last value. Instance outputs are read-only; you can also set an input by assignment (Delay.PT := T#5s;) and call Delay();.

Because the timers are scan-quantised, the first scan with Q TRUE after an input rises in scan r is scan r + ceil(PT / dt) (see the timing identities on the Verify page).

The I/O panel, watch table and forcing

Mapping. In the I/O map tab each row names a variable of the program, whether it is an input (you drive it), an output (the program drives it), or a sensor (a value the program computes, shown read-only), and how it looks: switch, button (held while pressed), slider, lamp, valve, motor, gauge or indicator. A name that is not a variable is reported in the diagnostics.

Driving inputs. Click a switch to toggle it; hold a button; drag a slider. With the panel focused, the digit keys 1 to 9 toggle the first nine inputs. A panel change takes effect at the start of the next scan.

Scripted inputs. A project can carry a list of timed input events (time in ms, variable, value) so that a run is repeatable. The examples use them to press buttons at fixed times. Scripted events are applied before panel changes.

Watch table. Type a variable path and press Enter. Paths address variables (Count), block members (Delay.ET), array elements (Table[3]) and step flags (Fill.T). The Set box writes a value once; the Force box holds a value at the start and end of every scan until you clear it. Only writable variables can be set or forced. Forces are a debugging aid for the simulation; they are not saved in the file.

Timing chart and stepping

The timing chart records every change of the selected signals (by default the I/O points and the step flags). BOOL signals are drawn as digital lanes, numbers as scaled lanes with their minimum and maximum. Keys with the chart focused: Left/Right move the cursor by one scan, + and - zoom, 0 shows everything. The cursor reading lists every value at that time.

A trace is limited to 200,000 recorded changes and 64 signals. When it is full, the older half of the time span is dropped and the chart says so.

Stepping. Step (.) runs one scan and fills the Scan log with the inputs applied, the transitions fired, the steps activated and deactivated, and the actions run. Step x10 (Shift + .) runs ten. Run runs at the chosen speed (1x, 10x, 100x or as fast as the browser allows). Pause and Cancel stop the worker at the next slice; a run that does not stop can be ended with Stop worker.

Files, exports and formats

Every export carries the footer "Made with Seqchart · simulations4all.com" and the notice that the tool is not for controlling real machinery.

Formats not implemented. An XML exchange format for controller programs is published by an industry association. Its schema's licence could not be confirmed as open when this tool was written (checked 2026-10-17), so it is deferred rather than guessed; no proprietary or binary project formats are read or written.

Your work autosaves to this browser's local storage (small projects only). Nothing else leaves your browser except the domain-gate token exchange; there are no accounts and no analytics.

Keyboard shortcuts

Limitations, limits and budgets

The simulator runs in a background worker, never on the page's main thread, and keeps inside what a phone browser allows.

A larger project or run is refused with a message that names the limit. A run is cancellable at any time; the worker checks its slice time after every scan and honours Cancel when it yields. A running scan is synchronous and bounded by the operation budget; Stop worker ends the worker at once.

Compared with other tools

Seqchart is a teaching and prototyping environment for sequential function charts and Structured Text in the browser. Desktop programming environments for industrial controllers are far larger: they target real hardware, include ladder and function-block diagram editors, instruction-list, motion and safety libraries, online debugging, and certified toolchains. Seqchart does none of those things.

What you get in return: nothing to install, deterministic and repeatable runs (a virtual clock, scripted inputs, a step budget), a single-scan stepper with an event log, a full recorded timing chart, and a documented, tested language subset whose behaviour is checked in your own browser.

Gaps to know about: no ladder, function-block or instruction-list editors; no import or export of controller-vendor project formats; no real-time or hardware connection; a subset of the data types and library; one program per project.

Sources and openness

The language is a documented subset written from openly available general descriptions; no standard's text, tables or figures are reproduced, and the tool makes no claim of conformance or certification. The semantics of every construct are defined in this Guide and checked on the Verify page.

Consulted: a general public encyclopedia article on sequential function charts (https://en.wikipedia.org/wiki/Sequential_function_chart, consulted 2026-10-17) for the vocabulary of steps and transitions and for the rule that a firing transition deactivates all steps before it and activates all steps after it. Everything else, including the qualifier definitions, the scan order and the standard-block behaviour, is our own written definition. Where other tools differ (for example in the pulse qualifiers), this tool follows the definition above.

How we verify Seqchart

Every behaviour in this Guide is covered by a case in one data module, used both by the automated test suite and by the Verify page, so what you can run is exactly what is tested. Today there are 168 cases, grouped as:

• Structured Text semantics: operator precedence, wrap-around, integer division and MOD signs, loops, CASE, arrays, enumerations, functions and blocks, with hand-derived expected values.
• Rejections: programs that must be refused, each with the exact diagnostic.
• Standard blocks: hand-traced scan sequences for every timer, counter, edge and latch block.
• Timing identities: closed-form checks such as "the first scan with Q TRUE is r + ceil(PT/dt)", across many scan periods and delays.
• Chart evolution and qualifiers: the rules above on small documented charts, with the active steps and the target values at chosen scans.
• Python reference: a separate interpreter written in Python 3 for the integer, loop and array subset; its results are recorded as literals and compared with this tool's.
• Validation against published examples: none are recorded yet. The two placeholders on the Verify page are marked pending source and carry no numbers.

Press Run all checks on the Verify page to run them in your browser; the summary badge shows how many pass, and Print report produces a verification report. These checks verify that the tool does what this Guide says; they do not make a design safe or compliant.

Troubleshooting