Arduino as a PLC: Controllino MAXI Wiring and Scan-Cycle Code

Using a bare Arduino Uno as a Programmable Logic Controller (PLC) in an industrial or home-automation control panel is a fast track to fried optocouplers and erratic resets. Standard Arduinos operate at 5V logic, lack DIN-rail mounting, and have no isolation against the 24VDC signals and inductive kicks common in control environments. To successfully deploy an Arduino as a PLC, you need hardware that bridges the gap between the AVR microcontroller ecosystem and industrial I/O standards.

The direct answer: for a reliable, code-compatible deployment, use the Controllino MAXI (based on the ATmega2560) paired with a Mean Well DR-15-24 power supply. It natively supports the Arduino IDE, features built-in 24V opto-isolated inputs, and includes relay outputs capable of switching external contactors. Below is the complete decision framework, wiring procedure, and fail-safe C++ scan-cycle code to get it running.

The Verdict: Which Hardware Actually Works as a PLC?

Not all 'industrial Arduinos' are created equal. Here is the decision path to select the right hardware for your control panel. This matrix evaluates the three most common approaches to building an Arduino-based PLC.

Parts List & Pin Mapping for the Controllino MAXI

The Controllino MAXI (Hardware variant HW204) maps the ATmega2560 pins to industrial screw terminals. It features 24 digital inputs (opto-isolated, 24VDC), 12 analog inputs, and 22 relay outputs. Below is the exact bill of materials and the pin mapping for our motor-control build.

Bill of Materials

Pin Mapping Table

When programming the Controllino, you must use their specific library constants. Do not use raw Arduino pin numbers (like pin 2), as the internal routing differs from a standard Mega.

Wiring the 24V Industrial I/O

1. Mount the Hardware: Snap the Mean Well DR-15-24 and the Controllino MAXI onto a standard 35mm DIN rail. Ensure there is at least 20mm of clearance above and below the power supply for convection cooling.
2. Wire the 24VDC Supply: Connect your AC mains (L/N/G) to the Mean Well input. On the DC output side, wire the +V terminal to a red terminal block bus (24VDC) and the -V terminal to a blue terminal block bus (0VDC/Common).
3. Power the Controllino: Run 18 AWG wire from the 24VDC bus to the Controllino +24V terminal, and from the 0VDC bus to the GND terminal. The green 'PWR' LED should illuminate upon energizing the PSU.
4. Wire the Inputs (Sink Configuration): The Controllino inputs are opto-isolated. Wire the 24VDC bus to the common terminal of your Start (NO) and Stop (NC) pushbuttons. Wire the switched side of the Start button to IN0, the Stop button to IN1, and the Overload Relay auxiliary NC contact to IN2. When a button is pressed, 24V flows into the input pin, triggering the internal optocoupler.
5. Wire the Outputs: Connect the 24VDC bus to the COM (Common) terminal of Relay D0. Wire the NO (Normally Open) terminal of D0 to the A1 coil terminal of your external motor contactor. Wire the contactor's A2 terminal back to the 0VDC bus. Note: Always install an RC snubber across the contactor coil if switching large inductive loads to prevent relay contact welding.

The PLC Scan Cycle: Compilable C++ Code

Unlike standard Arduino sketches that meander through the loop() function, a PLC operates on a strict scan cycle: Read Inputs → Execute Logic → Write Outputs. The code below targets the Controllino MAXI, implements a classic motor start/stop seal-in circuit, and includes a hardware Watchdog Timer (WDT) to automatically reset the microcontroller if the code hangs.

#include <Controllino.h>
#include <avr/wdt.h>

// --- PIN DEFINITIONS ---
const int START_BUTTON = CONTROLLINO_IN0;   // 24V Opto Input (NO pushbutton)
const int STOP_BUTTON = CONTROLLINO_IN1;    // 24V Opto Input (NC pushbutton)
const int OVERLOAD_RELAY = CONTROLLINO_IN2; // 24V Opto Input (NC aux contact)
const int MOTOR_CONTACTOR = CONTROLLINO_D0; // Relay Output
const int RUN_INDICATOR = CONTROLLINO_D1;   // Relay Output

// State variable for the seal-in circuit
bool motor_state = false;

void setup() {
  // 1. Initialize Watchdog Timer (2-second timeout)
  // If the loop hangs for >2s, the AVR will hardware-reset
  wdt_enable(WDTO_2S);

  // 2. Configure Pin Modes
  pinMode(START_BUTTON, INPUT);
  pinMode(STOP_BUTTON, INPUT);
  pinMode(OVERLOAD_RELAY, INPUT);
  pinMode(MOTOR_CONTACTOR, OUTPUT);
  pinMode(RUN_INDICATOR, OUTPUT);

  // 3. Ensure safe state on boot
  digitalWrite(MOTOR_CONTACTOR, LOW);
  digitalWrite(RUN_INDICATOR, LOW);
}

void loop() {
  // Pet the watchdog immediately at the start of the scan
  wdt_reset(); 

  // --- PHASE 1: READ INPUTS ---
  // Controllino 24V inputs read HIGH when 24V is applied
  bool start_sig = digitalRead(START_BUTTON);
  bool stop_sig = digitalRead(STOP_BUTTON);
  bool overload_ok = digitalRead(OVERLOAD_RELAY);

  // --- PHASE 2: EXECUTE LOGIC ---
  // Start/Stop Seal-in Logic with Overload Interlock
  // Note: Stop button is wired NC, so it reads HIGH when normal, LOW when pressed.
  // Overload is wired NC, so it reads HIGH when normal, LOW when tripped.
  
  if (start_sig && stop_sig && overload_ok) {
    motor_state = true; // Seal in
  } 
  else if (!stop_sig || !overload_ok) {
    motor_state = false; // Break seal on stop or overload
  }

  // --- PHASE 3: WRITE OUTPUTS ---
  digitalWrite(MOTOR_CONTACTOR, motor_state ? HIGH : LOW);
  digitalWrite(RUN_INDICATOR, motor_state ? HIGH : LOW);

  // --- PHASE 4: SCAN DELAY ---
  // A short delay stabilizes the scan rate and prevents contactor chatter
  delay(10); 
}

Debugging: First 3 Things to Check When It Fails

Industrial environments introduce electrical noise that bare Arduinos rarely see. If your Controllino fails to upload or behaves erratically, follow this ranked troubleshooting path.

1. Upload Fails with: avrdude: stk500v2_ReceiveMessage(): timeout

This exact error string means the PC cannot establish the serial bootloader handshake with the ATmega2560.

• Cause A (Most Likely): You are using a charge-only USB cable. Fix: Swap to a verified data-capable USB-A to USB-B cable.
• Cause B: RS485 or Serial1 interference. If you have external devices wired to the RS485/UART pins during upload, they can corrupt the bootloader sync. Fix: Disconnect external serial devices before uploading.
• Cause C: Auto-reset circuit failure. Fix: Press and hold the physical 'RESET' button on the Controllino, click 'Upload' in the IDE, and release the button the exact second the IDE says 'Uploading...'.

2. Inputs Read 'HIGH' When Nothing is Connected (Floating)

Unlike 5V logic Arduinos, the Controllino's opto-isolated inputs require a complete 24V circuit to trigger. However, if the 0VDC common is lost, the inputs can float and pick up capacitive coupling from nearby AC wires.

• Fix: Measure the voltage between the Controllino GND terminal and the negative terminal of your Mean Well power supply. It must read < 0.1V. If it reads higher, your 0VDC bus has a broken connection or a high-resistance fault.

3. Motor Contactor Chatters or Drops Out Randomly

This is almost always caused by inductive kickback or voltage sag, not a software bug.

• Fix: When a large contactor coil de-energizes, it sends a massive voltage spike back into the 24VDC bus, causing a brownout on the Controllino's internal DC-DC converter. Install an RC snubber (e.g., 100 ohm + 0.1µF) directly across the contactor coil terminals (A1 and A2) to absorb the spike.

Extending or Simplifying the Build

Once the base scan-cycle is proven, you will inevitably need to scale the system. Here is how to adjust the architecture based on your I/O requirements.

How to Simplify (Under 14 I/O Points)

If your project only requires a few limit switches and a single valve, the MAXI is overkill. Downgrade to the Controllino MINI (based on the ATmega328P). It costs roughly $90, fits in a much smaller panel footprint, and uses the exact same <Controllino.h> library. The code above will compile and run on the MINI with zero modifications, provided you map your physical wires to the MINI's IN0 and D0 terminals.

How to Extend (SCADA and HMI Integration)

To elevate this from a standalone relay-replacement to a true networked PLC, you need to expose the internal variables to a Human Machine Interface (HMI) or SCADA system. The Controllino MAXI features a built-in RS485 transceiver wired to Serial3.

1. Add the official ArduinoRS485 and ArduinoModbus libraries via the Library Manager.
2. Configure the Controllino as a Modbus RTU Slave (Node ID 1, Baud 19200).
3. Map your motor_state boolean and input statuses to Modbus Coils and Discrete Inputs.
4. Wire the RS485 A/B terminals to a Weintek or Advanced HMI touchscreen. This allows operators to monitor motor run-hours, force inputs for testing, and acknowledge overload faults remotely without opening the panel door.

By treating the Arduino ecosystem as a logic engine rather than a hobbyist toy, and wrapping it in purpose-built industrial hardware like the Controllino, you achieve the flexibility of C++ with the reliability demanded by 24/7 control environments.