PLC vs Arduino: Building an Industrial Modbus Node with Arduino Opta

The verdict in the PLC vs Arduino debate comes down to environment and determinism. Use a traditional PLC (or an industrial-grade Arduino like the Opta) for 24VDC factory floors, life-safety interlocks, and deterministic scan times. Use a standard Arduino (Uno R4, Mega) for 5V/3.3V bench prototyping, non-critical data logging, and rapid UI iteration. Standard Arduinos lack the galvanic isolation, optocoupled inputs, and IEC 61131-3 compliance required to survive industrial electrical noise.

However, the line is blurring. In 2026, the Arduino Opta WiFi bridges this gap entirely. It is a micro-PLC that runs standard C++ via the Arduino IDE while offering 24VDC isolated I/O and native Modbus TCP/RTU support. Below, we build a complete industrial sensor node that reads a 4-20mA pressure transducer and serves it to a master SCADA system, proving you don't always need a $1,500 Siemens S7 to get reliable industrial I/O.

The Core Differences: PLC vs Arduino Hardware

Before wiring the panel, it is critical to understand why standard Arduinos fail in industrial cabinets. The table below contrasts a standard Arduino Uno R4 WiFi with the Arduino Opta WiFi (acting as a PLC).

Project Build: Arduino Opta Modbus Sensor Node

This build targets the Arduino Opta WiFi (Part Number: AFV040010). We will read a 4-20mA industrial pressure sensor, map it to engineering units (PSI), and expose it via Modbus TCP holding registers so a master PLC or SCADA system (like Ignition or Node-RED) can poll it.

Parts List

• Controller: Arduino Opta WiFi (AFV040010) with Ethernet and WiFi/BLE
• Power Supply: Mean Well DR-30-24 (30W 24VDC DIN Rail PSU)
• Sensor: 4-20mA Pressure Transducer (0-150 PSI, 1/4" NPT)
• Wiring: 18 AWG stranded for 24VDC power, 20 AWG shielded twisted pair for 4-20mA signal
• Network: Cat6 Ethernet patch cable
• Hardware: 35mm DIN rail, end stops, ferrule crimps

Pin Mapping Table

Wiring and Setup Steps

1. Mount the Hardware: Snap the Mean Well DR-30-24 and the Arduino Opta onto the 35mm DIN rail. Ensure the Opta's ventilation gaps (top and bottom) are clear by at least 20mm to prevent thermal derating of the internal relays.
2. Wire the 24VDC Power: Crimp ferrules onto your 18 AWG stranded wire. Connect the PSU V+ to the Opta PWR terminal and V- to the GND terminal. Do not apply mains power to the PSU yet.
3. Wire the 4-20mA Sensor: Connect the sensor's red wire to the PSU V+ (to power the loop). Connect the sensor's black wire (signal) to the Opta I1 terminal. Connect the Opta COM terminal to the PSU V- to complete the circuit.
4. Set the DIP Switch (If applicable): The Opta automatically detects 4-20mA vs 0-10V on its analog inputs via software configuration in the Arduino_MachineControl library, but ensure no physical jumpers on your specific sensor board are set to voltage mode.
5. Connect Network: Plug the Cat6 cable into the Opta Ethernet port and route it to your SCADA network switch.

Complete C++ Firmware for Arduino Opta

This code targets the Arduino Opta WiFi. It uses the official Arduino_MachineControl library to handle the isolated I/O and the ArduinoModbus library to serve the data. Upload this via the Arduino IDE (ensure "Arduino Opta" is selected as the board).

#include <Ethernet.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>
#include <Arduino_MachineControl.h>

// --- PIN & HARDWARE DEFINITIONS ---
// Opta uses abstracted channels via MachineControl library
const int SENSOR_CHANNEL = 0; // Analog Input I1
const int RELAY_CHANNEL = 0;  // Relay Output O1

// --- NETWORK DEFINITIONS ---
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 177);
IPAddress subnet(255, 255, 255, 0);
EthernetServer ethServer(502); // Standard Modbus TCP Port
ModbusTCPServer modbusTCPServer;

// --- PROCESS VARIABLES ---
float pressurePSI = 0.0;
const float MAX_PRESSURE = 150.0; // Sensor max range

void setup() {
  Serial.begin(115200);
  while (!Serial && millis() < 3000); // Wait for serial monitor or timeout

  // Initialize Opta Hardware
  if (!MachineControl.begin()) {
    Serial.println("FATAL: MachineControl.begin() failed. Check Opta hardware.");
    while (1); // Halt execution
  }

  // Configure Analog Input for 4-20mA mode
  MachineControl.AnalogIn.begin(SENSOR_CHANNEL);
  
  // Configure Relay Output
  MachineControl.DigitalOutputs.begin();
  MachineControl.DigitalOutputs.write(RELAY_CHANNEL, LOW);

  // Initialize Ethernet
  Ethernet.begin(mac, ip, subnet);
  
  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println("Ethernet PHY not found.");
    while (true) { delay(1000); }
  }
  
  if (Ethernet.linkStatus() == LinkOFF) {
    Serial.println("WARNING: Ethernet cable disconnected.");
  }

  // Start Modbus TCP Server
  ethServer.begin();
  if (!modbusTCPServer.begin()) {
    Serial.println("Modbus TCP Server failed to start. Error: -1");
    while (1); // Halt if Modbus fails to initialize
  }
  
  // Map Holding Registers: 
  // Reg 0: Pressure (x10 for 1 decimal place)
  // Reg 1: Control Command (1 = Relay ON, 0 = Relay OFF)
  modbusTCPServer.configureHoldingRegisters(0, 2);
  
  Serial.println("Opta Modbus Node Online. IP: 192.168.1.177");
}

void loop() {
  // Handle incoming Modbus TCP connections
  EthernetClient client = ethServer.available();
  if (client) {
    modbusTCPServer.accept(client);
    modbusTCPServer.poll();
  }

  // 1. Read 4-20mA Sensor (Returns 0 to 65535 raw ADC value)
  uint16_t rawADC = MachineControl.AnalogIn.read(SENSOR_CHANNEL);
  
  // Map 4-20mA (approx 13107 to 65535 on 16-bit scale) to 0-150 PSI
  // Note: Opta library handles the 4mA zero-offset internally when configured correctly,
  // but we use a safe map for demonstration.
  float mappedVal = map(rawADC, 0, 65535, 0.0, MAX_PRESSURE * 10.0);
  uint16_t regPressure = (uint16_t)mappedVal;
  
  modbusTCPServer.holdingRegisterWrite(0, regPressure);

  // 2. Read Control Command from SCADA Master
  int controlCmd = modbusTCPServer.holdingRegisterRead(1);
  
  // 3. Execute Control Logic with Error Handling
  if (controlCmd == 1) {
    MachineControl.DigitalOutputs.write(RELAY_CHANNEL, HIGH);
  } else {
    MachineControl.DigitalOutputs.write(RELAY_CHANNEL, LOW);
  }

  // 4. Safety Interlock: Trip relay if pressure exceeds 130 PSI
  if (regPressure > 1300) { // 130.0 PSI * 10
    MachineControl.DigitalOutputs.write(RELAY_CHANNEL, LOW);
    Serial.println("SAFETY TRIP: High Pressure Interlock Activated.");
  }

  delay(50); // 50ms scan cycle
}

Debugging: "Modbus TCP Server failed to start. Error: -1"

When deploying industrial C++ on microcontrollers, network stack initialization is the most common point of failure. If your serial monitor outputs the exact string: Modbus TCP Server failed to start. Error: -1, the underlying Ethernet socket allocation has failed.

The First Three Things to Check

1. Verify 24VDC Supply Voltage: Measure the voltage directly at the Opta's PWR and GND screw terminals with a multimeter. It must read between 23.5V and 25.5V. If it reads below 18V, the internal DC-DC converters will brownout the STM32H747 MCU, causing the Ethernet PHY to fail initialization.
2. Check Physical Link Status: Look at the Ethernet port LEDs on the Opta. If the Link LED is off, the Ethernet.begin() function will still execute, but the socket binding will fail. Swap the Cat6 cable and verify the switch port is not administratively down.
3. Confirm IP Subnet Conflicts: Ensure 192.168.1.177 is not already claimed by another device on the VLAN. An IP conflict during the ARP resolution phase can cause the Modbus library to abort socket creation and throw Error: -1.

Ranked Causes for Modbus Polling Failures

If the server starts but the SCADA master cannot read the registers, check these in order:

• Cause 1: Firewall / Port Blocking. Modbus TCP uses port 502. Windows Defender or corporate IT firewalls frequently block unencrypted traffic on this port. Fix: Add an inbound/outbound rule for TCP 502 on the SCADA server.
• Cause 2: Endianness Mismatch. The Opta (ARM Cortex) is Little-Endian. Some older PLCs expect Big-Endian (Word Swap). If your 150 PSI reads as 38400, the bytes are swapped. Fix: Enable "Byte Swap" or "Word Swap" in your SCADA Modbus driver configuration.
• Cause 3: Scan Cycle Starvation. If your loop() contains heavy blocking delays (e.g., delay(1000)), the Opta cannot service the TCP stack, resulting in dropped packets. Fix: Use non-blocking millis() timers for logic delays.

How to Extend or Simplify This Build

To Simplify: If you do not have a master PLC or SCADA system and just want to view the data on your phone, drop the Modbus TCP library entirely. Use the Opta's native WiFi and the ArduinoMqttClient library to publish the pressure readings to a free broker like HiveMQ or Adafruit IO via MQTT. This removes the need for static IP routing and Ethernet cabling.

To Extend: If your facility mandates IEC 61131-3 compliance for insurance or auditing reasons, transition from the Arduino IDE to the Arduino PLC IDE. You can port this exact C++ logic into Structured Text (ST) or Ladder Logic (LD). The PLC IDE also enables deterministic task scheduling, ensuring your safety interlock (the 130 PSI trip) executes on a guaranteed 10ms high-priority thread, independent of network latency.

FAQ: PLC vs Arduino Long-Tail Questions