Inside AutomationView: Leveraging the Python SDK for Automated Regression Testing of SFC Logic

flowchart LR
    A["Git Commit"]:::bgBlue --> B["CI Pipeline"]:::bgGreen
    B --> C["AutomationView SDK"]:::bgBlue
    C --> D["SFC Execution"]:::bgRed
    D --> E["Test Report"]:::bgGreen

    classDef bgBlue fill:#2563eb,color:#ffffff,stroke-width:0px
    classDef bgGreen fill:#16a34a,color:#ffffff,stroke-width:0px
    classDef bgRed fill:#dc2626,color:#ffffff,stroke-width:0px

Automated regression testing is common in standard software engineering, but it remains notoriously difficult to implement in the industrial automation world. Engineers often test PLC code manually during the commissioning phase, discovering logic conflicts only when physical hardware is at risk. By leveraging the AutomationView Python SDK, control engineers can run automated regression testing on their Sequential Function Charts (SFC) long before deploying to the factory floor.

Key Takeaways

• Manual PLC testing scales poorly as sequence complexity increases.
• The AutomationView Python SDK allows headless execution of SFCs.
• Integrating PLC regression tests into a CI/CD pipeline prevents logic regressions during collaborative development.

The Paradox of PLC Regression Testing

In traditional development, testing a function block means providing inputs and verifying outputs. SFC logic, however, relies heavily on state and time. A sequence step might wait for a cylinder limit switch to actuate within a 5-second window. Testing this manually requires an engineer to sit at a desk, toggle bits in a watch table, and observe the transitions. This process is time-consuming and almost never repeatable across multiple iterations.

When multiple engineers work on a single sequence using Git integration, one logic change can easily break another branch’s functionality. Without an automated way to verify that existing states and transitions still operate correctly, teams face massive bottlenecks during factory acceptance testing.

Architecting Automated Tests with the Python SDK

AutomationView addresses this by exposing its core simulation engine through a Python API. Instead of manually clicking through the UI to trigger transitions, engineers write Python scripts that load the SFC model, simulate physical inputs, advance the clock, and assert expected outputs.

flowchart TD
    start_test["Start Python Script"]:::bgBlue --> load_model["Load SFC Model via SDK"]:::bgBlue
    load_model --> simulate_inputs["Inject Hardware Variables"]:::bgGreen
    simulate_inputs --> run_cycle["Execute PLC Cycle"]:::bgRed
    run_cycle --> assert_outputs["Assert Expected State"]:::bgGreen
    assert_outputs --> test_pass["Pass/Fail Report"]:::bgBlue

    classDef bgBlue fill:#2563eb,color:#ffffff,stroke-width:0px
    classDef bgGreen fill:#16a34a,color:#ffffff,stroke-width:0px
    classDef bgRed fill:#dc2626,color:#ffffff,stroke-width:0px

Simulating Hardware-in-the-Loop

True automated testing requires simulating the physical plant. The Python SDK allows you to create virtual models of valves, motors, and sensors. For example, when the SFC sets a valve command to true, the Python script catches this output, waits for a defined virtual time delay, and then sets the corresponding limit switch input to true. This closes the loop without requiring real hardware.

This method exposes timing-related bugs that standard Boolean logic checks would miss. If a transition is programmed to fail if the limit switch does not actuate within 3 seconds, the Python script can intentionally delay the sensor feedback to ensure the SFC correctly triggers the timeout alarm.

Comparing Testing Methods

The transition from manual testing to automated regression testing requires an upfront investment in scripting, but the long-term benefits are substantial.

Continuous Integration for PLC Code

Once you have a suite of Python tests verifying your SFC logic, the next logical step is integrating them into a Continuous Integration pipeline. Tools like GitLab CI or GitHub Actions can execute these Python scripts every time an engineer pushes a commit to the repository. If a recent change breaks an existing machine sequence, the pipeline fails, preventing the faulty logic from ever reaching the production environment.

This approach transforms PLC programming from a solitary, hardware-dependent task into a modern, collaborative software engineering discipline.

Common Challenges and FAQ

How do you handle real-time constraints in a simulated environment?

The AutomationView simulation engine can decouple its internal clock from real-world time. This allows the Python script to advance time in fixed increments, ensuring deterministic execution regardless of the host machine’s processing speed.

Can this replace physical factory acceptance testing?

No. Automated regression testing verifies the logical intent of the code. Physical testing is still required to account for unpredictable variables like sensor noise, mechanical friction, and wiring errors.

Start modernizing your sequence development today. Visit the AutomationView Store to explore licenses, templates, and training materials designed to accelerate your engineering workflow.