Customer results and applications you can put to work.
Customer case study · Manufacturing
From seconds or minutes to under 300 ms.
A manufacturing control loop took seconds or minutes
to send PLC data through middleware and SQL Server and return commands
to the PLC. Those delays were a serious production-line bottleneck.
A C++ rewrite on DEVS brought the complete cycle below 300 ms,
removing the bottleneck and saving the customer millions while
retaining the existing PLC and database.
What changed in this installation
Measure
Before
After
Full cycle time
A few seconds to several minutes
Consistently under 300 ms, including under load
Production impact
A serious production-line bottleneck
Bottleneck removed; millions saved
Middleware
Java/Jython scripting platform
Native C++ on DEVS
Equipment and database
Siemens S7-400 and SQL Server
The same PLC and SQL Server
Unpredictable delays bottlenecked the production line.
The line depended on completing the PLC-to-SQL feedback loop.
When that loop stalled, it constrained production. Object allocation
and garbage-collection pauses, interpreted scripts,
and synchronous database work on shared threads contributed to
unpredictable cycle times in this installation. Heap and
garbage-collector tuning did not produce the required consistency.
The data flow stayed. The execution path changed.
The replacement runs the critical logic in compiled C and C++.
The PLC initiates each cycle with a raw TCP data push. DEVS processes
the data, interacts with SQL Server, and writes the result back to
the PLC. The JavaScript HMI operates outside this control path.
PLC eventS7-400 pushes raw data over TCP
DEVS C++Decodes the data and runs middleware logic
SQL ServerLogs data and applies database decision logic
DEVS C++Receives the result and writes it through Snap7
PLC commandThe result returns to the same controller
Separate HMI: the JavaScript interface
is kept out of the critical control path.
Technical implementation: TCP, byte order, ODBC, and Snap7
PLC-initiated input: raw TCP pushes trigger processing,
without continuous polling of the input data.
Explicit data conversion: native handling decodes the
packets and converts multi-byte PLC values from big-endian to
the host's little-endian representation.
Database access: POCO Data with ODBC connects to SQL
Server. Dynamic Poco::Data::RecordSet operations were
sufficient; bulk operations were not required for this result.
Return path: Snap7 writes the results back to the
Siemens PLC.
The change addressed the complete execution path: event handling,
data conversion, database interaction, and separation of the HMI.
The critical middleware no longer depended on the scripting runtime
or its garbage collector.
The result: under 300 ms and millions saved.
The replacement delivered consistent end-to-end cycles under 300 ms,
including under load. Removing the production bottleneck saved the
customer millions. The team retained the overall PLC-to-database
architecture, the Siemens S7-400 PLC, and SQL Server, replacing the
middleware responsible for the variable response.
The timing result is for this installation's complete
loop, including middleware processing, SQL Server interaction, and
the return write to the PLC.
Customer case study · Automation integration
From many layers to a common datapoint model.
Another customer's data passed through multiple
layers between automation and the manufacturing execution system
(MES). DEVS consolidated that data into datapoints, simplifying
access for performance and management.
Before
Automation → Multiple integration layers → MES
Data moved through a chain of intermediaries between the
equipment and the system that needed it.
With DEVS
Automation → DEVS datapoints → MES
The data was consolidated into a common model, simplifying
how it could be accessed and managed.
One application-facing interface: HTTP(S) and JSON.
A datapoint gives an application a named value to work with.
The DEVS datapoint API exposes those values through ordinary HTTP(S)
requests and JSON. Any HTTP client can use it; the consuming
application does not need the device's protocol library or a
DEVS-specific client.
That makes the boundary between equipment and applications easier
to work with: DEVS handles device communication, while the MES or
other consumer works with the datapoint model.
The Rolling Mill application uses DEVS to track
production through a steel rolling mill. The overview, schedule,
billet history, delays, and finished-product records are different
views of the same operation.
Reheat furnaceBillet identity and furnace state
Rolling standsPasses, speed, motor load, and temperature
FinishingCooling, cutting, or coiling
Finished productBundles and coils linked to production records
Watch the mill in operation.
See structural steel and rebar moving through the line alongside
work-order progress and live stand data. Then watch the AI assistant
answer questions about production and delays. All three walkthroughs
include narration and English captions. Use full screen to inspect the detail.
Structural steel: from billet to bundle
Follow steel from the reheat furnace through the rolling
stands and shear, onto the cooling and collecting beds, and through
cutting, stacking, and banding. Billet counts, tonnage, and finished
bundles update alongside stand speed, motor load, and current. Watch on YouTube.
Rebar: from billet to coil
Watch hot steel pass through the rolling stands and branch
into the rebar line for coiling, weighing, and tagging. The same
screen tracks the active work order, billets rolled, tonnage,
coil count, and changing stand values. Watch on YouTube.
AI assistant: work-order progress and delay analysis
In this 75-second recording, the assistant uses live
data and production records to report the active order's product,
grade, billets completed, tonnage, and remaining billets. A follow-up
question examines recorded delay causes, event counts, and lost
minutes. The assistant identifies the available delay and makes
clear that the history is limited. Watch on YouTube.
What the application brings together
Task
In the application
Follow a work order
See scheduled, active, and completed orders, with progress in billets and tons.
Trace a billet
Connect its heat and work order to its passage through the stands, with recorded speed, motor load, and temperature.
Investigate a delay
Review duration, area, category, and reason alongside the mill's event log.
Review output
Inspect finished coils and bundles, including weights, counts, and product sizes.
Ask about the operation in the application.
The RM assistant has tools for reading current datapoints and querying
the production database. Its context includes the mill,
the records it keeps, and how they relate.
Example questions include “Which areas accounted for the most delay
time?” and “What happened to this billet?” Live values describe
the mill now; stored records support questions about its history.
Application example · Pump station
Pressure, pumps, and control logic in one application.
The PumpStation application combines Modbus
devices, live datapoints, a Node-RED control flow, SQL-backed
setups, trend charts, and an application assistant.
The operator view shows pressure against its setpoint, pump state,
speed, and flow. Behind that view, the control flow adjusts pump
speed and stages pumps as demand changes. The application also
exposes its code, SQL, trends, and changes.
App Wizard lets you select these kinds of parts for a new
application and describe the interface and behavior you need.
The same platform components support both the operator's screen
and the engineer's tools.
Operate, inspect, and troubleshoot the pump station.
Follow valve changes through the operator view,
live datapoints, Node-RED debug output, and trend charts. The
walkthrough also shows application code, AI-assisted troubleshooting,
and change history. This 5-minute, 39-second walkthrough includes
narration and English captions. Use full screen to inspect the detail. Watch on YouTube.