MPINO Series
MPINO-16A8R
MPINO-16A8R Industrial Arduino Controller
MPINO-16A8R is an ATmega2560-based industrial Arduino-compatible PLC controller with 16 isolated digital inputs and 8 relay outputs. Onboard RS-232, RS-485, UART, I²C with Modbus RTU, programmable in the Arduino IDE. DIN-rail mountable for automation, testing, HMI integration and embedded control.
International shipping (EMS) — calculated at checkout by destination & weight
Shipping weight 300 g (per unit)
Ships the next business day (regardless of order time)
Large orders may take 1 extra day to dispatch
Cancel before dispatch · request a return/exchange after delivery
Key features
/ FEATURES- ATmega2560 core, programmable in the Arduino IDE and MPINO STUDIO2
- 16 opto-isolated digital inputs (NPN/PNP, up to 40 V tolerant)
- 8 relay outputs for AC/DC dry-contact switching
- 4 analog inputs (0–5 V / 4–20 mA / 0–10 V ranges)
- Industrial communication: RS-485, RS-232, UART, I²C · Modbus RTU
- DIN-rail 35 mm mountable, isolated field I/O for the factory floor
Specifications
/ SPEC| MCU | ATmega2560 |
|---|---|
| Power input | DC 9V – 12V |
| Digital inputs | 16 |
| Relay outputs | 8 |
| Analog inputs | 4 |
| RS-232 | 1ch |
| RS-485 | 1ch |
| UART | 1ch |
| I²C | 1ch |
| Modbus RTU | Yes |
| LS Cnet | Yes |
| Mitsubishi MC | Yes |
| Arduino IDE compatible | Yes |
Software
Arduino IDE / MPINO Studio 2
Arduino IDE compatible
Works with the Arduino toolchain you already use
MPINO STUDIO2 included
Arduino code and ladder logic in one tool
Arduino + ladder logic
Build control logic faster with familiar ladder rungs
Setting up the toolchain
Installing the ARDUINO SDK adds this product's board definition to the Arduino IDE and makes the functions that earn their keep in industrial work available as built-in commands. There is no library to add — the Arduino IDE offers them with autocompletion as you type.
Built-in commands the SDK unlocks
- PLC timers · callback timersIton · Itof · Itpl · Itmr · ItimerSet
- CountersIctu · Ictd · Ictud · IgetCount
- Scaling · PID controlIscale · Iscalef · IpidSet · IpidRun
- First-in and last-in buffersFIFO · FILO
- Input debounce · edge detectionIbounce · IdigitalRead · Iup · Idown · Ialt
- Debug · watchdogdebug · debugln · WDT_ENABLE · WDT
- Modbus RTU · LS Cnet · Mitsubishi MCImodbusRTU · ICnet · IMcProtocol
- Analog input · 4–20 mA correctionanalogRead2 · IanalogRead · IanalogFilter · ntcRead
Using the Arduino IDE requires the ARDUINO SDK (the ILOGICS board package) to be installed. MPINO STUDIO2 can be used without installing it.
This board can also be used without the ARDUINO SDK by selecting the MEGA2560 board in the Arduino IDE. In that case the ILOGICS built-in commands are not available.
Digital input
16 isolated digital input channels
Sixteen digital input channels read external switches and sensors reliably, straight from the terminal block.
D22–D37 inputs
Sixteen digital input points in total
COM0 / COM1 commons
Two independent input groups
Optocoupler isolation
Control circuit protected from field noise
NPN / PNP sensors
Works with either sensor wiring convention
Input channel layout
* Example wiring for external switches or sensors (NPN/PNP shared)
Optocoupler isolation
The digital inputs use a bidirectional optocoupler stage (anti-parallel LEDs), so either NPN or PNP signals are read reliably, with all 16 channels referenced to COM0 / COM1.
Example sketch — reading an input
void setup() {
// Input pins work as inputs with no pinMode() call (the pull-up / pull-down is on the board).
Serial.begin(9600);
}
void loop() {
if (digitalRead(22) == HIGH) {
Serial.println("I(22) ON");
}
delay(100);
}Relay output
8 relay output channels (1a1c)
8 relay output channels control external loads running on AC or DC, reliably.
D39–D46 outputs
8 relay contact output points
8 × 1a1c relays
Each output is an independent relay contact
4 outputs per COM
Each COM terminal is shared by 4 outputs
Electrical isolation
Control and output sides separated by the relay
Output channel layout
* Example wiring for external loads (relay contact output)
Relay output structure
Each relay output is a 1a1c relay that mechanically separates the control side from the output side, with 4 outputs sharing one COM terminal. Being a volt-free contact, it switches both AC and DC loads.
Example sketch — driving a relay output
void setup() {
pinMode(39, OUTPUT);
}
void loop() {
digitalWrite(39, HIGH);
delay(1000);
digitalWrite(39, LOW);
delay(1000);
}Analog inputAnalog Input
4 analog input channels, DC 0–5 V as shipped
A(0)–A(3) are poles of the bottom terminal row, next to AGND and just left of the power block. Every channel is 10-bit and ships as a DC 0–5 V voltage input; 0–10 V, 0(4)–20 mA and an NTC 10 kΩ thermistor are the other ranges the input circuit supports.
A(0)–A(3) · 4 channels
Four 10-bit (0–1023) analog input points
DC 0–5 V as shipped
100 MΩ input resistance in this range
Voltage · current · NTC
0–10 V, 0(4)–20 mA and NTC 10 kΩ also supported
External reference
AVCC 5 V is wired out to AREF
Analog input terminals
* Poles of the bottom terminal row, silkscreened ANALOG IN, in the order A(0) · A(1) · A(2) · A(3) · AGND. There is no range-select cap or jumper on this board — the range follows the input circuit's resistor configuration, and the board ships as DC 0–5 V.
Input ranges
| Input range | State | Input resistance |
|---|---|---|
| DC 0–5 V | As shipped | 100 MΩ |
| DC 0–10 V | Resistor configuration | 200 MΩ |
| 0(4)–20 mA | Resistor configuration | 250 Ω (1%) |
| NTC 10 kΩ @25 °C | Resistor configuration | 10 kΩ pull-up (1%) |
All four channels are 10-bit (0–1023). AVCC 5 V is wired out to AREF on this board. The board ships as DC 0–5 V; the other ranges follow the channel's input-resistor configuration.
Example sketch — reading an analog input
unsigned int ADC0;
void setup() {
Serial.begin(9600);
}
void loop() {
ADC0 = analogRead(A0); // 0-5V -> 0-1023
Serial.println(ADC0);
delay(500);
}External interruptInterrupt · Encoder
Count fast pulses and read a rotary encoder on the interrupt inputs
SDA and SCL are the board's two external interrupt inputs — SDA is INT1 and SCL is INT0 — with 4.7 kΩ pull-ups already fitted. Attach an ISR and every edge is counted without the sketch polling, or wire a two-phase encoder across both and read the direction from the phase relationship.
2 interrupt inputs
SDA (D20) · SCL (D21)
Fast pulse counting
Count edges in an ISR, no polling
Rotary encoder
Phase A = SDA, phase B = SCL
4.7 kΩ pull-ups
Fitted on both inputs
Interrupt pin mapping
| Pin | INT | Shared with |
|---|---|---|
| D20 | INT1 | I²C SDA · encoder phase A |
| D21 | INT0 | I²C SCL · encoder phase B |
The operating range is DC 0–5 V and encoder input works above 50 kHz. Both pins carry a 4.7 kΩ pull-up. These two are the only external interrupt pins brought out on this board. What frequency a sketch actually keeps up with depends on the length of the ISR and the load of the whole program, so no fixed figure is guaranteed.
What the interrupt inputs are for
* On the left the pulse source's output goes to SDA and its ground to a GND pole of the power terminal, and the ISR counts every edge. On the right the two encoder phases are 90° apart, so the level of SCL at an SDA edge is the direction of rotation.
Interrupt terminals
* The 2-pole terminal on the right edge, silkscreened I2C. SDA = D20 (INT1) and SCL = D21 (INT0), both with a 4.7 kΩ pull-up built in. The terminal carries the two signal poles only — take the sensor's ground from the power terminal. Because these are the I²C bus pins, I²C cannot be used if they serve as interrupts.
Before you use it
- The interrupt inputs take DC 0–5 V only. Anything above 5 V destroys the MCU — put a 24 V signal through the isolated digital inputs instead.
- SDA and SCL are the I²C bus. If they are used as interrupts or as an encoder, I²C communication cannot be used.
- Inside the ISR, do nothing but increment the count — no Serial, no delay(), no floating-point maths.
- This board counts in an attachInterrupt() ISR. It has no timer-clocked hardware counter.
Example sketch — external interrupt
void setup() {
Serial.begin(9600);
// a rising edge on SCL (D21) calls onRising()
attachInterrupt(digitalPinToInterrupt(SCL), onRising, RISING);
}
void loop() {
}
void onRising() {
Serial.println("ok");
}Example sketch — rotary encoder
volatile long encoderValue = 0;
void setup() {
Serial.begin(115200);
// SDA(20) = phase A, SCL(21) = phase B
attachInterrupt(digitalPinToInterrupt(SDA), updateEncoder, FALLING);
}
void loop() {
Serial.print("Encoder Value: ");
Serial.println(encoderValue);
delay(500);
}
void updateEncoder() {
if (digitalRead(SCL) == LOW) { encoderValue++; }
else { encoderValue--; }
}CommunicationRS-232 · RS-485 · UART · I²C
Four communication channels — RS-232, RS-485, a TTL UART and I²C
RS-232 is Serial1, RS-485 is Serial2 and the TTL UART is Serial3, each on its own terminal, and I²C is the Wire library with its pull-ups already fitted. Modbus RTU works as master or slave on every external port. RS-485 uses a MAX13487 transceiver that switches direction on its own, so no DE/RE control pin is needed.
RS-485 · 1 channel
Serial2 · 1:N multidrop · MAX13487 auto direction
RS-232 · 1 channel
Serial1 · point-to-point on the TX / RX / GND terminals
UART (TTL) · 1 channel
Serial3 · TXD, RXD, GND terminals, no level driver
I²C · 1 channel
Wire · 4.7 kΩ pull-ups built in · 1:N
Modbus RTU
Master or slave on every external port
RS-232 · UART · I²C · USB connectors
* Each connector is drawn as its silkscreen reads. The I²C connector carries the two SIGNAL pins only — power an I²C device from the +5V and GND poles of the power terminal. The program port is silkscreened UPLOAD.
RS-485 link
* RS-485 is a multidrop bus, so 485+ goes to every node's 485+ and 485− to every node's 485−. Direction is switched by the transceiver itself; no DE/RE control pin has to be driven from the sketch.
Communication ports
| Port | Pins | Use |
|---|---|---|
| Serial | D1 (TX0) · D0 (RX0) | Program upload and debug over the UPLOAD USB port |
| Serial1 | D18 (TX1) · D19 (RX1) | RS-232 on the TX / RX / GND terminals · point-to-point |
| Serial2 | D16 (TX2) · D17 (RX2) | RS-485 on the 485+ / 485− terminals · 1:N |
| Serial3 | D14 (TX3) · D15 (RX3) | TTL UART on the TXD, RXD, GND terminals |
| Wire (I²C) | SDA = D20 · SCL = D21 | 2-pin connector · 4.7 kΩ pull-ups built in |
All four external ports support Modbus RTU as master or slave. The UART channel is TTL level with no line driver, so it reaches a nearby module directly rather than a long cable run.
Before you wire it
- The I²C connector has signal pins only — take +5V and GND for the device from the power terminal (a supply output rated 100 mA).
- Using SDA and SCL as external interrupts or as an encoder input means I²C cannot be used at the same time.
- The UART channel is TTL level and is not isolated. Do not connect it to an RS-232 or RS-485 line directly.
- The USB-UART bridge is on the board, so an ordinary USB cable uploads. Install the CP210x driver before the first upload.
Example sketch — serial send and receive
void setup() {
Serial.begin(9600); // USB, for monitoring
Serial2.begin(9600); // RS-485
}
void loop() {
Serial2.println("Hello RS485");
while (Serial2.available()) {
char c = Serial2.read();
Serial.write(c);
}
delay(1000);
}7-segment (FND) connectionFND · TM1637
A four-digit 7-segment display on two signal wires — up to 2 of them
The display module carries a TM1637 driver, so a four-digit readout needs only a clock line and a data line. This board has no dedicated display connector: the two signals go on ordinary screw poles — CLK = A(2) · DIO = A(3) is the recommended pair — and +5V and GND come off the POWER terminal block, which makes the whole run four wires.
Two wires: CLK and DIO
A TM1637 four-digit module needs no more
Up to 2 displays
Each on its own pair of poles
Powered from the board
+5V · GND on the POWER terminal block · up to 100mA
Built-in commands
IsegDecimal and IsegHex print decimals and hex
Displays and their poles
| Display | Terminals | Pins |
|---|---|---|
| Display 1 | CLK = A(0) · DIO = A(1) | A0 · A1 |
| Display 2 | CLK = A(2) · DIO = A(3) | A2 · A3 |
| Supply | +5V · GND | Board output · up to 100mA |
The signal poles are analog input terminals doing double duty, so a pole driving a display is spent for as long as it does. The +5V pole is an output on this board, which is what lets the display run without a supply of its own. The display module itself is an accessory sold separately.
Recommended connection
* The poles are silkscreened A(2) · A(3) · +5V · GND; nothing on the board says CLK or DIO, so the role of each wire is printed where it lands. A(2) is A2 and A(3) is A3. The display comes in a decimal-point form and a time-displaying form, both sold separately.
Driving more than one
* Every display needs its own CLK and DIO pair; +5V and GND are shared by all of them. The pole names below are read left to right off the board, which is why the clock line is not always the left-hand one.
Before you wire it
- A pole used for a display cannot be used as analog input at the same time.
- The Iseg commands in the sketch below are built into the ARDUINO SDK — install the SDK and they are available, with no library to add and no #include to write.
- Used as an output, this board's +5V pole is limited to 100 mA. Check the total if anything else is drawn from the same pole.
- The 7-segment module is an accessory sold separately; it is not included with the board.
Example sketch — driving a 7-segment display
// 4-digit 7-segment (TM1637) on the A(2) and A(3) terminals - CLK, DIO, +5V, GND
// Iseg* are ARDUINO SDK built-in commands: nothing to install, no #include to add.
void setup()
{
IsegBegin(A2, A3);
IsegBrightness(7); // 0-7 - required, nothing lights without it
IsegClear();
}
void loop()
{
IsegDecimal((millis() / 1000UL) % 10000UL, true);
delay(200);
}Power · Data retentionPower · Backup
DC 9V ~ 12V in, 5 V out — and your data survives the blackout
The controller takes DC 9V ~ 12V and converts it to 5 V internally with a LM1117 regulator. Size the supply for at least 12V 1A.
DC 9V ~ 12V
Size the supply for 12V 1A or more
5 V internal
LM1117 DC-DC conversion
+5 V out 100mA
From the +5 V pole of the power terminal block
Supercapacitor hold-up
About ten seconds on the +5 V pole
Before wiring the supply
- EEPROM cells last about 100,000 writes. Keep fast-changing values in RAM and write them only when the mains drops — see the two methods below — not every loop.
- Running on USB alone makes the USB 5 V the analog reference, so readings can wander. Use the external supply for precise measurement.
Where the power goes
* Either source runs the board: the external supply through the regulator, or the download port's 5 V directly. The supercapacitor sits on the same 5 V node and keeps it alive when both go away.
Power and data retention
| Input voltage | DC 9V ~ 12V |
|---|---|
| Recommended supply | 12V 1A or more |
| Internal conversion | LM1117 DC-DC to 5 V |
| +5 V output | 100mA max, from the +5 V pole of the power terminal block |
| USB-powered operation | Runs on the PC's 5 V through the download port |
| Non-volatile memory | EEPROM 4 KB, about 100,000 writes |
| Hold-up on a power cut | Supercapacitor on the +5 V pole, about ten seconds |
| Blackouts retained | More than 100,000, writing only when the mains drops |
Size the supply for 12V 1A or more, plus whatever the +5 V pole is feeding (up to 100mA).
Two ways to keep data through a blackout
Which one you want depends on how often the value changes. They are meant to be combined.
EEPROM — values that change occasionally
The on-board EEPROM holds 4 KB with no power at all and is written a byte at a time, but the same cell survives only about 100,000 writes. That makes it right for setpoints, calibration data and machine configuration — and wrong for anything the loop updates.
Supercapacitor — values that change constantly
Fit a supercapacitor to the +5 V pole and the internal 5 V stays up for about ten seconds after the main supply is cut. Wire the main supply into a digital input, and the moment digitalRead() sees that input go off, write the value to EEPROM; when power comes back, setup() reads the stored value out of EEPROM and puts it into memory. Because the EEPROM is written only at the instant of a blackout, it survives more than 100,000 of them.
MPINO STUDIO2 — done for you
MPINO STUDIO2 offers supercapacitor-based retention as an option, so the sequence above can be set up in the tool instead of being coded by hand.
Mounting · DIN railDIN Rail
Clips onto a 35 mm DIN rail, or screws down through the PCB's own holes
Inside a control panel the board clips onto a 35 mm DIN rail; built into a machine it screws down through the mounting holes in the PCB. The board measures 116.80 × 100.00 mm without the rail clip, and stands 109.42~119.42 mm high once the clip is closed on the rail.
35 mm DIN rail
Clips onto the rail in a control panel
Direct PCB mounting
Screws through the mounting holes
116.80 × 100.00 mm
PCB outline with no rail clip fitted
109.42~119.42 mm engaged
114.68~124.68 mm with the clip open, 109.42~119.42 mm closed
Mounting and dimensions
| Mounting | 35 mm DIN rail, or direct to PCB |
|---|---|
| DIN rail | 35 mm |
| PCB alone (no clip) | 116.80 × 100.00 mm |
| Mounting holes | 100.00 × 90.00 mm apart |
| Clip open (before engaging) | approx. 114.68~124.68 mm |
| Clip closed (engaged) | approx. 109.42~119.42 mm |
Where no DIN rail is used, the board screws down through the mounting holes in the PCB; on a rail, the clip closes over a 35 mm profile and the assembly stands 109.42~119.42 mm high.
Mounting on a 35 mm DIN rail
* The clip hooks over a 35 mm DIN rail. Overall height is 114.68~124.68 mm with the clip open and 109.42~119.42 mm once it is closed and engaged. The drawing shows the mounting method rather than the clip's own shape.
Outline and mounting holes
* The outline and mounting holes with no rail clip fitted. All dimensions in millimetres.
Installation notes
- Indoor use only. Do not install where there is rain, dust, frost, direct sunlight or condensation.
- Do not install in an atmosphere containing flammable or explosive gas.
- Do not install where there is heavy vibration or shock.
- Where the equipment affects life or property (nuclear, medical, marine, vehicle, aviation and the like), a secondary safety device must be fitted.
FAQ
How many I/O points does the MPINO-16A8R have?▾
The MPINO-16A8R provides 16 isolated digital inputs and 8 relay outputs, with onboard RS-485, RS-232, UART, I²C communication. See the specification table for the full breakdown.
Does the MPINO-16A8R support Modbus RTU?▾
Yes. The MPINO-16A8R supports Modbus RTU — master and slave alike — over its serial interface.
Related controllers
/ RELATED
Related guides
/ DOCSRS-485 Networking for Industrial Arduino Controllers
Multi-drop wiring, termination, biasing, and automatic direction control for reliable RS-485 field buses.
Industrial Arduino vs Traditional PLC: How to Choose
Cost, openness, I/O density, ecosystem, and reliability compared — with guidance on when each is the right tool.