From Zero to Conveyor Belt: Simulating Industrial Control Systems Without a Real Factory

The world of Industrial Control Systems (ICS) — the digital minds behind factories, power grids, and water treatment plants — is fascinating, yet often feels inaccessible to the eager learner. Whether you're a student, a career-switcher, or a cybersecurity professional looking to understand the core of Operational Technology (OT), the fundamental challenge is always the same: how do you start learning when you can't get your hands on a real, multi-million dollar factory?

You can read countless articles and textbooks on Programmable Logic Controllers (PLCs), SCADA systems, and industrial networking protocols, but true understanding only clicks when theory meets practice. You need a safe, fast, and, most importantly, free environment to break things without consequence.

This is where the power of simulation changes everything. Using a modern suite of open-source and proprietary tools allows us to build a complete, functional virtual factory that mimics a real-world scenario. This approach is not only the safest and cheapest way to learn — it's arguably the best. In this article, I'll walk you through setting up a simple scenario of conveyor belt using Factory I/O, OpenPLC, and Fuxa, proving that going from zero knowledge to controlling a fully simulated industrial process is easier than you think.

Scenario

To demonstrate the full power of our virtual factory, we'll tackle a classic, fundamental piece of automation: The Controlled Conveyor Belt.

Here is the simple — yet critical — logic we need to implement using OpenPLC:

1. A single box travels down the main conveyor belt.
2. At the end of the line, a sensor (our virtual input) detects the presence of the box.
3. Crucially: Once the box is detected, the PLC must automatically shut down the conveyor belt. Automation achieved!

But what if a technician needs to manually adjust the line or bypass the safety stop?

• We will include an Emergency Override Button.
• When this button is pressed, it must bypass the sensor's automatic stop, keeping the conveyor belt running — even if the box has reached or passed the detection point.

This straightforward scenario forces us to use both basic control logic (Start/Stop) and safety/override logic (Manual Bypass), giving us the perfect practical training ground for real-world ICS programming!

Tech Stacks

We will used these components:

• Factory I/O = The Physical Plant (The actual machinery, sensors, and actuators — in this case, virtualized).
• OpenPLC Runtime= The Programmable Logic Controller (PLC) (The program that decides when to turn the conveyor belt on and off based on the sensors).
• OpenPLC Editor= The coding of PLC done here
• FUXA= The SCADA/HMI (The graphical dashboard for the human operator to monitor the system status and issue start/stop commands).

Factory IO

Follow these quick steps to get our physical simulation running:

1. Acquire Factory I/O: Start by downloading Factory I/O from here. They usually offer a generous 30-day trial, giving you plenty of time to master this project.
2. Load the Scenario: Open the existing scene titled "Simple A to B". This scene already contains our key components: the conveyor belt and the necessary sensors.
3. Activate Modbus TCP Server: Navigate to the Drivers menu within the scene. Here, we need to configure Factory I/O as a Modbus TCP Server (running on the default Port 502). Once configured, start the server to make the virtual sensors and actuators accessible to OpenPLC.

Once this is complete, our virtual hardware is powered up and ready to receive commands from the PLC!

OpenPLC Editor

We move into the brain of our operation: the PLC programming itself.

• Create a new project in the OpenPLC Editor, making the explicit choice to use the powerful Structured Text (ST) language.
• Insert code as picture below

• Save and export the code for openplc (.st file)

OpenPLC Runtime

With our logic ready, it's time to load it onto the virtual PLC and connect it to our simulated factory floor:

• Access the Console: Open your web browser and navigate to the OpenPLC Runtime's web console (typically accessible on Port 8080). Log in to gain control.
• Upload the Program: Use the console's interface to upload the compiled .st program you exported from the OpenPLC Editor in the previous step.
• Connect to Factory I/O: Crucially, you must now add Factory I/O as a Slave Device within the Runtime configuration. This uses the Modbus connection we set up earlier.

• Initiate Control: Hit the Start PLC button. Your virtual controller is now online, executing the logic, and actively communicating with the conveyor belt simulation!

FUXA

Finally, we need a graphical interface (HMI) so a human operator can monitor the system and send commands. FUXA makes this incredibly easy:

• Launch the Dashboard Project: Start Fuxa and immediately create a new project.
• Establish Data Link: The first priority is connectivity. Set up a new Modbus connection pointed directly at our running OpenPLC Runtime (using the designated Port 501). This links your SCADA interface to the live PLC data.
• Map the I/O Tags: Inside your project, create the necessary components (tags) that correspond to the conveyor's status, the sensor, and the override button. Ensure these tags are configured to read data (e.g., status) and write data (e.g., override command) to the corresponding registers in the OpenPLC. In my experience, this is the hardest part! I have to try many things to get the addressing correct.

• Design the User Interface: Using the visual Editor, quickly drag-and-drop elements to create a functional and attractive UI — buttons, indicators, and a visual representation of the conveyor status.
• Go Live! Save your work, navigate to the Home view, and open the HMI dashboard. It's time to test your fully functional Industrial Control System!

Congratulations! If all connections were made correctly, your virtual factory is now alive and responding precisely as intended (just like in the video). You've closed the loop: the Fuxa dashboard is now your command center, allowing you to monitor and send commands that are executed by OpenPLC and instantly reflected in the physical simulation within Factory I/O. This is the tangible proof that theoretical knowledge translates into real control.

Next Steps and Resources

I encourage you to tweak the logic, introduce new sensors, or even try simulating failures to push your knowledge further!

I used very specific code for the Structured Text program to make this project work seamlessly. If there is significant interest in this article, I will clean up the final OpenPLC project file and the Fuxa configuration and upload them all to a dedicated GitHub repository.

Did this tutorial help you build your first virtual factory? Let me know in the comments if you'd like me to share the full project code on GitHub!