Traditional industrial PLCs are powerful, reliable, and built to run for decades without intervention. They’re also expensive, locked into vendor-specific programming environments, and genuinely difficult to integrate with cloud platforms and modern data infrastructure. For small and mid-sized manufacturers, building factories, and retrofitting older equipment with IIoT monitoring, that combination creates real problems.

Arduino Opta is a micro-PLC that sits in a different part of the market. It runs standard Arduino code and MicroPython, speaks Modbus RTU and TCP, and connects to cloud platforms like AWS IoT Core, Azure IoT Hub, and Arduino Cloud via standard MQTT. If you’re a firmware developer who knows Arduino, you can program an Opta with familiar tools. That’s not something you can say about most industrial controllers.

What the Opta Is

The Arduino Opta is a DIN-rail mounted micro-PLC certified for industrial environments (IEC 61010-2-201, UL Listed). The hardware specifications are designed around real industrial requirements:

  • STM32H747XI dual-core Cortex-M7 + M4 processor at up to 480MHz
  • 8 analogue/digital inputs (0—10V analogue, digital high/low with galvanic isolation)
  • 4 relay outputs rated at 250VAC / 10A (resistive load)
  • RS-485 port for Modbus RTU communications
  • Ethernet (100Mbps, RJ45) for Modbus TCP and cloud connectivity
  • USB-C for programming and power
  • Industrial power input: 12—24V DC

The unit is available in three variants: Opta Basic (no wireless), Opta WiFi (adds 2.4GHz WiFi and Bluetooth), and Opta RS485 (focuses on serial industrial bus connectivity). For IIoT applications where you want both local fieldbus communication and cloud connectivity, the WiFi variant is the most common choice.

The physical form factor fits standard 35mm DIN rail in control cabinets, which is where industrial electronics live. It’s not a development board you put on a desk — it’s designed to be installed alongside breakers, contactors, and terminals in an enclosure.

Programming Model

The Opta uses the Arduino IDE with the Arduino Mbed OS Opta board package. Programming uses C++ with the standard Arduino API — setup(), loop(), interrupt handlers, and the full Arduino library ecosystem. If you’ve written code for Arduino Uno or Mega, the structure is identical.

MicroPython support via the Arduino Lab for MicroPython environment is available for teams that prefer Python syntax or need to iterate quickly on logic without recompiling.

A simple example reading an analogue sensor and controlling a relay:

#include <Arduino.h>

const int SENSOR_PIN = A0;
const int RELAY_PIN = D0;
const float THRESHOLD_VOLTAGE = 5.5;

void setup() {
  Serial.begin(9600);
  pinMode(RELAY_PIN, OUTPUT);
  analogReadResolution(16);  // 16-bit ADC on STM32H7
}

void loop() {
  int rawValue = analogRead(SENSOR_PIN);
  float voltage = rawValue * (10.0 / 65535.0);  // 0-10V scaling
  
  Serial.print("Voltage: ");
  Serial.println(voltage);
  
  if (voltage > THRESHOLD_VOLTAGE) {
    digitalWrite(RELAY_PIN, HIGH);  // Activate relay
  } else {
    digitalWrite(RELAY_PIN, LOW);
  }
  
  delay(100);
}

This is readable and maintainable code. The equivalent in traditional PLC ladder logic or Structured Text would require familiarity with vendor-specific IEC 61131-3 tools and considerably more setup.

Modbus Integration

Modbus is the common language of industrial equipment. Most sensors, VFDs (variable frequency drives), HMIs, and legacy PLCs speak either Modbus RTU (serial, over RS-485) or Modbus TCP (Ethernet). The Opta supports both.

Reading from a Modbus RTU slave device on the RS-485 port:

#include <ArduinoModbus.h>

void setup() {
  RS485.begin(9600);
  ModbusRTUClient.begin(RS485, 9600);
}

void loop() {
  // Read holding registers from device address 1, starting at register 40001
  if (!ModbusRTUClient.requestFrom(1, HOLDING_REGISTERS, 0, 2)) {
    Serial.print("Failed to read: ");
    Serial.println(ModbusRTUClient.lastError());
    return;
  }
  
  int16_t reg1 = ModbusRTUClient.read();
  int16_t reg2 = ModbusRTUClient.read();
  
  float temperature = reg1 / 10.0;  // Convert raw to temperature
  Serial.print("Temperature: ");
  Serial.println(temperature);
}

This lets an Opta act as a Modbus master, polling data from existing field devices. You can also configure the Opta as a Modbus slave, where a SCADA system or HMI polls the Opta for data it has collected.

Cloud and MQTT Connectivity

The Opta WiFi connects to cloud platforms via MQTT over the WiFi interface. Arduino Cloud provides a managed MQTT broker and device registry with a dashboard for monitoring, OTA firmware updates, and webhook integrations to external systems.

For enterprise use with AWS IoT Core:

#include <ArduinoMqttClient.h>
#include <WiFi.h>

WiFiSSLClient wifiClient;
MqttClient mqttClient(wifiClient);

void setup() {
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  mqttClient.setUsernamePassword("", awsIotAuthToken);
  mqttClient.connect(AWS_IOT_ENDPOINT, 8883);
  
  mqttClient.subscribe("factory/opta/commands");
}

void loop() {
  mqttClient.poll();
  
  // Publish sensor data
  mqttClient.beginMessage("factory/opta/sensors");
  mqttClient.print("{\"temperature\":");
  mqttClient.print(readTemperature());
  mqttClient.print("}");
  mqttClient.endMessage();
  
  delay(5000);
}

This pattern — local Modbus polling from field devices, data published to a cloud broker — is the standard IIoT gateway architecture. The Opta is doing both jobs: local industrial interface and cloud connectivity in a single unit.

Where Opta Fits (and Doesn’t)

The Opta excels for:

IIoT gateway applications: reading from existing Modbus devices and publishing data to cloud platforms. If you’re retrofitting a factory floor with cloud monitoring, the Opta reads from existing sensors and PLCs and forwards data upward.

Small-scale automation in new installations: for applications that need 4—8 inputs/outputs, relay control, and cloud connectivity, the Opta is a cost-effective and developer-friendly alternative to traditional PLCs. Small machinery, environmental monitoring, building automation — all good fits.

Proof-of-concept and rapid prototyping: the Arduino development environment and MicroPython support makes it genuinely fast to prototype industrial automation concepts. Moving from concept to running hardware takes days rather than weeks.

Where traditional PLCs still win:

High-channel-count applications: large manufacturing lines with hundreds of I/O points need traditional PLCs (Siemens S7, Allen Bradley ControlLogix) with appropriate I/O expansion. The Opta’s 8 inputs and 4 relay outputs are a constraint for complex automation.

Deterministic real-time control: safety-critical applications with hard real-time requirements (sub-millisecond timing, safety-rated redundancy) need safety-certified PLCs with safety PLCs and SIL ratings. The Opta is industrial-grade but not safety-system rated.

Existing PLC programming expertise: if your engineering team knows Siemens Step 7 or Rockwell Studio 5000, the learning curve to Arduino/Python may not be worth it unless you’re specifically building hybrid IT/OT capabilities.

For teams with software backgrounds entering industrial automation, or organisations looking to add IIoT monitoring to existing equipment without replacing established control systems, the Opta offers a genuinely lower-friction path than traditional industrial automation toolchains.