Industrial Anomaly Detection on Arduino® Opta® PLC
Last updated
Last updated
This tutorial demonstrates how to implement and integrate anomaly detection on an Arduino Opta PLC using Edge Impulse. Anomaly detection is a machine learning technique that identifies unusual patterns in data, making it ideal for monitoring industrial processes and equipment. By training a model to recognize normal behavior, you can detect deviations that may indicate faults or malfunctions.
To showcase how easy it is to integrate Edge Impulse with the Arduino Opta PLC, we'll walk through a practical example using the Arduino DIN Celsius board that comes with the kit, but also a Motor to demonstrate this setup can be used interchangeably. This example demonstrates how to set up a temperature-controlled system, collect data, train a machine learning model, and deploy it for anomaly detection.
In this tutorial, you will:
Collect temperature data from a sensor connected to the Opta PLC.
Train a machine learning model in Edge Impulse to detect anomalies in the data.
Deploy the model to the Opta PLC for real-time inference.
Optionally, integrate the model with Arduino Cloud for remote monitoring and visualization.
We ran a webinar on integrating Edge Impulse with Arduino Opta PLC and Blues Wireless for remote monitoring and anomaly detection. The webinar covered the following topics:
Arduino Opta PLC: Learn about the flexibility and ease of integration of the Arduino Opta micro PLC, designed for industrial environments.
Edge Impulse for Machine Learning: Understand how to train and implement ML models for anomaly detection on industrial data directly on your Opta PLC.
Blues for Wireless Connectivity: Explore how Blues' Wireless for PLC Expansion enables secure cellular connectivity, allowing your Opta PLC to communicate with cloud-based monitoring systems.
The webinar is now available on-demand here.
Arduino Opta PLC (Wi-Fi version recommended)
Arduino IDE 2 (Download here)
Edge Impulse account (Sign up here)
Edge Impulse CLI (Installation guide
About the DIN Celsius Board
The DIN Celsius is an all-in-one temperature laboratory offering two independent heaters and a temperature sensor. It allows you to simulate heating scenarios and monitor temperature changes, making it ideal for testing our anomaly detection use case, we can introduce an anomaly by turning off one of the heaters to cause a deviation from the normal condition.
Connecting the DIN Celsius to the Opta PLC
Safety First: Before making any connections, ensure that all power sources are disconnected to prevent electric shock or short circuits.
Connections Overview:
Power Connections:
Connect the +24V and GND terminals of the DIN Celsius to the corresponding power supply pins.
Heater Control:
Connect Relay 3 (pin 2) on the Opta PLC to Input Heat 1 on the DIN Celsius.
Connect Relay 4 (pin 3) on the Opta PLC to Input Heat 2 on the DIN Celsius.
These connections will control the two independent heaters on the DIN Celsius.
Temperature Sensor Input:
Connect the Output Voltage from the DIN Celsius to the I8 input (analog pin A7) on the Opta PLC.
This connection allows the PLC to read the temperature sensor data.
Pin Definitions:
HEAT_LEFT (Relay 3) connected to pin 2
HEAT_RIGHT (Relay 4) connected to pin 3
TEMP_SENS connected to analog pin A7
BTN (User Button) on the Opta PLC
Arduino IDE Configuration
Install Necessary Libraries:
Ensure you have the latest Arduino IDE 2 installed.
Install any required libraries via the Library Manager, such as Edge Impulse SDK and Arduino_HTS221 if using temperature/humidity sensors.
Define Pin Constants:
Testing the Connections
Heater Control Test Code:
Upload the Code: Use the Arduino IDE to upload the sketch to the Opta PLC.
Verify Operation: The LEDs on the DIN Celsius should blink, indicating the heaters are being activated.
Temperature Sensor Reading Test:
Open Serial Monitor: Set the baud rate to 9600.
Observe Readings: You should see numerical values corresponding to the temperature sensor output.
Log In: Access your Edge Impulse account.
New Project: Create a project named, for example, "Opta PLC Anomaly Detection."
Upload a sketch to the Opta PLC that reads the temperature sensor and sends data to Edge Impulse.
Steps:
Upload the Data Forwarder Sketch: Use the Arduino IDE to upload the sketch to the Opta PLC.
Run Data Forwarder: In your terminal, execute the data forwarding command.
Select Serial Port: Choose the serial port corresponding to the Opta PLC.
Label the Data: As you collect data, assign labels to your data (e.g., "normal," "anomalous") based on the system's behavior.
Note: If you are new to Edge Impulse, please refer to our CLI Data Forwarder documentation for detailed instructions.
Run Data Forwarder: In your terminal, execute:
Select Serial Port: Choose the serial port corresponding to the Opta PLC.
Label the Data: Assign labels to your data (e.g., "normal," "anomalous") as you collect it.
If you are new to Edge Impulse please see our CLI Data Forwarder documentation.
Add Blocks: 2. Add Blocks:
Processing Block: Select a Time Series or Spectral Analysis block based on your data characteristics.
Learning Block: Choose Anomaly Detection using the Gaussian Mixture Model (GMM).
Window Size: Set according to the data frequency (e.g., 1000 ms).
Window Increase: Set overlap (e.g., 500 ms).
Compute Features: Navigate to the Generate Features tab and run feature generation.
Training Parameters:
Epochs: Start with 100 and adjust as needed.
Learning Rate: Default of 0.005 is usually sufficient. Start Training: Monitor the accuracy and loss graphs.
Model Testing: Use a separate dataset to evaluate model performance.
Adjust if Necessary: Retrain or adjust parameters based on results.
Deployment Tab: In Edge Impulse, go to Deployment.
Select Arduino Library: Download the library tailored for your model.
Read on here
Add Library to IDE: Import the downloaded library into your Arduino IDE.
If you are new to Arduino inference code, see our Arduino inference code documentation here for more information.
Replace Your_Edge_Impulse_Inference_Library.h
with the actual header file name from your downloaded library.
Set ANOMALY_THRESHOLD
to an appropriate value based on your model's performance.
Compile and Upload: Use the Arduino IDE to program the Opta PLC with your new inference code.
Monitor Output: Open the Serial Monitor to observe inference results and system behavior.
This section demonstrates integrating Blues Wireless for remote connectivity and monitoring. By connecting your Opta PLC to the cloud, you can visualize data, receive alerts, and monitor system performance from anywhere.
See the full Arduino OPTA for Arduino Cloud guide here.
Explore how Blues' Wireless for PLC Expansion enables seamless, secure cellular connectivity, allowing your Opta PLC to communicate with your cloud-based monitoring systems, regardless of location and without the hassle of local Wi-Fi.
See the Blues Wireless here.
This section will be updated following the Blues Wireless Webinar on the 30th of October Sign up here
In this section, we will integrate the anomaly detection model deployed on the Arduino Opta PLC with a ladder logic program. This integration will allow the machine learning inferences to interact with the PLC's native ladder logic control system, providing intelligent control responses to anomalies in temperature or motor power.
The Arduino PLC IDE allows you to combine an Arduino sketch with ladder logic using Shared Variables. These shared variables act as a bridge between the Edge Impulse inference running on the PLC and the PLC's control logic written in Ladder Diagram (LD) or other IEC-61131-3 programming languages (such as Function Block Diagram or Structured Text). This enables real-time decision-making based on the machine learning model's output.
Create Shared Variables
In the Arduino PLC IDE, navigate to the Global_vars
section to create shared variables that will store the results from the Edge Impulse inference. Define a shared variable for the anomaly score or classification output of the model.
Example:
Shared variable for storing inference result (e.g., float anomaly_score
).
Modify Inference Sketch
Update the Edge Impulse inference sketch to store the inference result in the shared variable. This will allow the ladder logic to access the result.
Example:
Ladder Logic Program
In the PLC IDE, create a new ladder logic program that will read the anomaly_score
shared variable. The logic can then trigger actions based on the value, such as activating relays, generating alarms, or shutting down equipment in response to detected anomalies.
Example Ladder Logic:
Create a rung that monitors the anomaly_score
. If the score exceeds a certain threshold, the logic can trigger an alarm (e.g., turn on an LED or activate a relay).
Add Inputs and Outputs:
Define Inputs (e.g., sensor values, inference results from the Arduino sketch) and Outputs (e.g., control signals like turning on a relay).
Click Add in the "Shared Inputs" and "Shared Outputs" sections to create global variables. These variables will allow communication between your inference sketch and ladder logic.
Set up the Inputs/Outputs:
Inputs: Define variables that will receive values from the Arduino sketch (e.g., anomaly_score).
Outputs: Define variables that will control actuators (e.g., relay_control).
Step 2: Accessing the Ladder Logic Editor
Create a New Ladder Logic Program:
Go to the Project tab (top-left section).
Right-click on Programs and select New Program.
Name the program (e.g., AnomalyDetection_LD) and select Ladder Diagram (LD) as the language.
Opening the Ladder Logic Editor:
Once the program is created, double-click it to open the Ladder Diagram editor. You will see a canvas where you can start adding blocks.
Step 3: Designing the Ladder Logic
Drag and Drop Components:
On the right panel under the Library Tree, you can see various block types, such as Comparison, Logic, and Arithmetic.
Comparison blocks will allow you to compare the input (e.g., anomaly_score) to a threshold (e.g., >=).
Creating Logic:
Input Condition: Drag a Comparison block (e.g., >=) to compare the anomaly_score to a threshold (e.g., 0.8).
Output Control: Connect the result of the comparison to an Output coil that controls the relay (e.g., relay_control).
Steps for Adding Logic:
Input: Select anomaly_score as the input to the comparison block.
Condition: Set the threshold (e.g., >= 0.8).
Output: Set the output to control a relay (e.g., activate relay_control when the condition is met).
Assigning the Ladder Logic to a Task
In the PLC IDE, assign the Arduino sketch (which runs the inference) to a task such as Fast (runs every 10ms) or Background (runs every 500ms) based on your system’s real-time requirements. Attach the ladder logic program to the same or another appropriate task to ensure it reacts to the updated shared variables in a timely manner.
Steps:
Go to the Project tab and locate the Tasks section.
Assign the ladder logic program (e.g., AnomalyDetection_LD) to an appropriate task (e.g., Fast Task for real-time control).
Monitor and Debug
Use the Watch window in the PLC IDE to monitor the shared variables and ensure the system responds correctly to anomalies detected by the machine learning model.
Upload the Arduino Sketch:
Ensure your Arduino sketch is uploaded to the Opta PLC to provide the inference results.
Run the Ladder Logic:
Start the ladder logic program from the Arduino PLC IDE.
Monitor the shared variables using the Watch window to see how the ladder logic reacts to the inference results.
Real-time Control: By integrating anomaly detection with ladder logic, you can implement real-time, intelligent control systems that take action based on data-driven decisions from the Edge Impulse model.
Easy Troubleshooting: Using ladder logic alongside machine learning allows for clear, visual representation of control logic, making it easier to debug and monitor the system's responses to anomalies.
Seamless PLC Integration: The Arduino PLC IDE provides a smooth environment for combining traditional control logic with modern machine learning, ensuring compatibility and ease of use.
Later will will revisit this with C++ and Siemens PLCs, for now, you can explore the Arduino PLC IDE.
Congratulations! You have successfully implemented anomaly detection on an Arduino Opta PLC using Edge Impulse. This tutorial demonstrates the seamless integration of machine learning models with industrial automation systems, enabling real-time monitoring and fault detection.
Please share your experiences and feedback with us on the Edge Impulse forum.
For more information on Edge Impulse and Arduino Opta PLC, visit the official websites:
Arduino Cloud Issues: We are aware of issues with Arduino Cloud .properties file format vs IDE and are working with Arduino. If you have issues try moving the .properties file to the same folder as the .ino file and re-uploading the sketch.