FreertosHow-ToIntermediate · 4 min read

How to Implement Edge Computing with PLC: Simple Guide

To implement edge computing with a PLC, program the PLC to process data locally using its logic and memory, then communicate summarized results to higher-level systems via protocols like MQTT or OPC UA. This reduces latency and bandwidth by handling real-time decisions at the edge device itself.

📐

Syntax

Edge computing with PLC involves three main parts:

Local Data Processing: Use PLC logic blocks to analyze sensor inputs and control outputs.
Communication Setup: Configure protocols like MQTT or OPC UA to send data.
Cloud or Server Integration: Connect PLC to cloud or SCADA for further analysis.

Each part requires specific programming and configuration in the PLC environment.

structured_text

(* Example syntax for local data processing and MQTT publish in Structured Text *)
VAR
  sensorValue : INT;
  processedValue : INT;
END_VAR

sensorValue := AI_Input; (* Read analog input *)
processedValue := sensorValue / 10; (* Simple processing *)

(* Publish processedValue via MQTT *)
MQTT_Publish('edge/topic', INT_TO_STRING(processedValue));

💻

Example

This example shows a PLC program that reads a temperature sensor, processes the value, and sends the result to an MQTT broker for edge computing.

structured_text

VAR
  tempSensor : INT;
  tempCelsius : REAL;
  mqttMessage : STRING;
END_VAR

(* Read sensor input *)
tempSensor := AI_Temperature;

(* Convert raw sensor value to Celsius *)
tempCelsius := REAL(tempSensor) * 0.1;

(* Prepare MQTT message *)
mqttMessage := CONCAT('Temperature:', REAL_TO_STRING(tempCelsius));

(* Publish to MQTT broker *)
MQTT_Publish('factory/edge/temperature', mqttMessage);

Output

Temperature:23.5

⚠️

Common Pitfalls

Common mistakes when implementing edge computing with PLCs include:

Trying to send raw sensor data continuously without local processing, causing network overload.
Not configuring communication protocols correctly, leading to failed data transmission.
Ignoring PLC memory and CPU limits by adding too complex processing logic.

Always balance local processing and communication load.

structured_text

(* Wrong: Sending raw data without processing *)
VAR
  rawValue : INT;
END_VAR

rawValue := AI_Input;
MQTT_Publish('sensor/raw', INT_TO_STRING(rawValue));

(* Right: Process data before sending *)
VAR
  rawValue : INT;
  processedValue : INT;
END_VAR

rawValue := AI_Input;
processedValue := rawValue / 10;
MQTT_Publish('sensor/processed', INT_TO_STRING(processedValue));

📊

Quick Reference

Step	Description	Example
1	Read sensor data locally	tempSensor := AI_Temperature;
2	Process data in PLC	tempCelsius := REAL(tempSensor) * 0.1;
3	Format data for sending	mqttMessage := CONCAT('Temp:', REAL_TO_STRING(tempCelsius));
4	Send data via protocol	MQTT_Publish('topic', mqttMessage);
5	Monitor and adjust processing load	Avoid heavy calculations in PLC

✅

Key Takeaways

Process data locally on the PLC to reduce network traffic and latency.

Use standard communication protocols like MQTT or OPC UA for sending data.

Keep PLC processing simple to avoid overloading CPU and memory.

Test communication setup thoroughly to ensure reliable data transfer.

Balance edge processing and cloud integration for best performance.