Distributed control system
A supervisory-level DCS built into the Lacerta platform
Core ideas
The foundational ideas behind the Lacerta DCS
DCS foundation
- Fault-tolerant cluster and cluster services
- Efficient interconnect
- Unified data model and object structure
- Reactive architecture, subscription mechanics
- Built-in scenarios and computation style
DCS functions
- Running complex decentralized logic
- Remote control of devices
- Functional-group control
- Higher level of automation
- Reduced operator involvement
What a supervisory-level DCS can do
Coordinating hosts. A supervisory-level DCS handles supervisory distributed-control tasks — above all the coordination of hosts, that is, the cluster clients.
Not a replacement for a regulator. It does not perform classic automatic-control tasks such as regulators, but it can control secondary processes where an acceptable delay is tolerable.
PLC compatibility. It works seamlessly with remote I/O modules and can coordinate the device nodes of cluster clients, such as PLCs, provided the required interfaces and APIs are available.
Supervisory-level DCS topology
The supervisory-level DCS cluster nodes (R) interface the hosts (C) through the client-side (relative to the cluster) interconnect.
DCS component interfacing diagram
How it is built physically
How the Lacerta DCS interfaces PLCs and remote I/O devices
DCS layers
Two-level DCS
The hosts (clients) of a supervisory-level DCS can themselves be a classic DCS.
Supervisory-level DCS (upper level)
- Coordinating lower-level DCS devices
- Coordinating interfaced subsystems
- Complex logic on servers
- Tolerates significant delay
Lower-level DCS (lower level)
- Device control
- Coordinating interfaced PLCs
- Moderate logic on DCS nodes
- Guaranteed low latency
Unified end-to-end DCS
- Coordinating all devices
- Single namespace
- Single programming language
- End-to-end diagnostics
End-to-end logic of a two-level DCS
The algorithm is distributed across all nodes of the end-to-end DCS, with parallelization provided where needed.
Algorithm flow across nodes
Distributed algorithm
-------------------------------------------- @node C01
src = {AI01_0, AI01_1, AI03_2, AI03_3} -- LIO ×2, LIO C02 ×2
dst = {AO01_0, AO01_1} -- LIO
x = read(src) -- OP01 R
y = {f01(x), f02(x)} -- OP02 C
write(dst, y) -- OP03 W
-------------------------------------------- @node C02
src = {AI03_0, AI03_1, AI01_2, AI01_3} -- LIO ×2, LIO C01 ×2
dst = {AO03_0, AO03_1} -- LIO
x = read(src) -- OP04 R
y = {f03(x), f04(x)} -- OP05 C
write(dst, y) -- OP06 W
-------------------------------------------- @node R01
src = {AI02_0, AI02_1, AI04_2, AI04_3} -- RIO ×2, RIO R02 ×2
dst = {AO02_0, AO02_1, AO04_2, AO04_3} -- RIO
x = read(src) -- OP07 R
y = {f05(x), f06(x), f07(x), f08(x)} -- OP08 C
write(dst, y) -- OP09 W
-------------------------------------------- @node R02
src = {AI04_0, AI04_1, AI02_2, AI02_3} -- RIO ×2, RIO R01 ×2
dst = {AO04_0, AO04_1, AO02_2, AO02_3} -- RIO
x = read(src) -- OP10 R
y = {f09(x), f10(x), f11(x), f12(x)} -- OP11 C
write(dst, y) -- OP12 W
-------------------------------------------- @node C01
src = {AI01_2, AI01_3} -- LIO ×2
dst = {AO01_2, AO01_3} -- LIO
x = read(src) -- OP13 R
z = {R02.ai04_0, R02.ai04_1} -- OP13 R cache R02
y = {f13(x, z), f14(x, z)} -- OP14 C
write(dst, y) -- OP15 W
-------------------------------------------- @node C02
src = {AI03_2, AI03_3} -- LIO ×2
dst = {AO03_2, AO03_3} -- LIO
x = read(src) -- OP16 R
z = {R01.ai02_0, R01.ai02_1} -- OP16 R cache R01
y = {f15(x, z), f16(x, z)} -- OP17 C
write(dst, y) -- OP18 W
Timing control
If the control logic allows parallel algorithms without locks, this is entirely feasible.
Timing per node
What a two-level DCS can do
Multi-level algorithm
- The algorithm is defined by a single description
- Its parts run on different nodes
- The algorithm is split across clusters
- Distribution of logic of different levels
- End-to-end diagnostics
I/O at any depth
- Access to I/O at any level
- Remote I/O support
- Unified access and processing style
- Multiple read access
- Output protection and locking
Two runtimes, one language
- Lacerta DCS on servers
- Multicontrol DCS on controllers
- End-to-end development environment, single language
- One language, universal syntax
- Moving logic between nodes
The Lacerta supervisory-level DCS has end-to-end interfacing with the Multicontrol lower-level DCS. Russian Software Registry entry No. 33304.