MPINO Series
MPINO-16A8R8T
MPINO-16A8R8T Industrial Arduino Controller
MPINO-16A8R8T is an ATmega2560-based industrial Arduino-compatible PLC controller with 16 isolated digital inputs and 16 relay + transistor 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 350 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
- 8 transistor (sink) outputs for fast DC switching
- 4 analog inputs (0–5 V / 4–20 mA / 0–10 V ranges)
- 2 analog outputs
- 2 NTC temperature inputs (−40 to +120 °C)
- 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 12V – 24V |
| Digital inputs | 16 |
| Relay outputs | 8 |
| Transistor outputs | 8 |
| Analog inputs | 4 |
| Analog outputs | 2 |
| Temperature sensor inputs | 2 |
| High-speed pulse inputs | 2 |
| High-speed pulse outputs | 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
- Analog outputIanalogWrite · IanalogWrite2 · analogWriteFreq
- PWM · pulse · high-speed counterPWM · FDPWM · NPWM · TCNTSETUP · TCNTOUT
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.
Download CableMP DOWNLOAD CABLE
Programming this board needs the dedicated download cable
The upload port on this board is a mini 5P USB socket, but the USB-to-serial conversion lives in the CABLE, not on the board. Plug in an off-the-shelf mini 5P USB cable and the PC never enumerates a port, so nothing uploads. The MP download cable is one we build ourselves — buy one and keep using it.
USB-TTL converter inside
The conversion IC sits in the connector housing
Generic mini 5P cannot be used
An ordinary cable enumerates no port and cannot upload
USB-A to mini 5P
Connects the PC's USB port to the board's upload port.
Made by ILOGICS
A dedicated cable for use with ILOGICS products.
What the cable is
* Having the conversion IC inside the housing is what sets this apart from an ordinary cable. Board end is mini 5P, PC end is USB-A, and the cable is 1 m long.
Sold separately — order it with the board under Add-on products.
Cable specification
| Item | Detail |
|---|---|
| PC end | USB-A plug |
| Conversion | USB-TTL converter inside the cable |
| Board end | USB mini 5P plug |
| Length | 1 m |
| Driver | FTDI |
Installing the driver
- Connect the MP download cable between the PC's USB port and the board's upload port.
- Open Device Manager and check whether USB Serial Port (COMx) appears under Ports (COM & LPT).
- If it does not appear, install the FTDI driver from the resources section and reconnect the cable.
- In your development tool, select the same COM number Device Manager shows, then upload.
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.
Relay output
8 relay output channels (1a1c)
8 relay output channels control external loads running on AC or DC, reliably.
D62–D69 outputs
8 relay contact output points
8 × 1a1c relays
Each output is an independent relay contact
2 outputs per COM
Each COM terminal is shared by 2 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 2 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(62, OUTPUT); // R(62) as an output
}
void loop() {
if (digitalRead(22) == HIGH) digitalWrite(62, HIGH); // I(22) ON -> R(62) ON
else digitalWrite(62, LOW);
}Transistor output
8 sinking transistor output channels (N-MOSFET)
8 sinking transistor output channels switch and control external loads reliably.
D39–D46 outputs
8 sinking transistor output points
DO_V+ common supply
Loads wire between DO_V+ and the output terminal
N-MOSFET sink
IRFRU024N · 3A/point · 15A/COM
DC 0–55V loads
ON connects to GND (sink); OFF floats
Output channel layout
* Example wiring for external loads (sinking transistor output)
N-MOSFET sink output
The transistor outputs are sinking outputs built on the IRFRU024N N-MOSFET. When the MCU GPIO drives the gate, the output terminal is pulled to GND (ON); the load wires between DO_V+ and the output terminal. Each point sinks up to 3A (15A per COM) for DC 0–55V loads.
Example sketch — driving a transistor output
void setup() {
pinMode(39, OUTPUT); // O(39) as an output
}
void loop() {
// O(39) is a SINK output: writing HIGH ties it to GND (load ON)
digitalWrite(39, digitalRead(22));
}Analog inputAnalog Input
4 analog input channels, current or voltage selected per channel
A(0)–A(3) come out on a 5-pole strip on the board's left edge, reading AGND, A(3), A(2), A(1), A(0) from the top. Every channel ships as a 0–20 mA / 4–20 mA current input with its cap fitted on the SELECT header; pull that channel's cap and it becomes a DC 0–5 V voltage input. DC 0–10 V is an order option.
A(0)–A(3) · 4 channels
Four 10-bit (0–1023) analog input points
0–20 mA by default
Cap fitted at the factory · about 250 Ω
Cap off → DC 0–5 V
Selected independently per channel · 2 kΩ
External reference
REF3025 2.5 V ±0.2 % fed to AREF
Analog input terminals
* A 5-pole strip on the board's left edge legended ADC, in the order AGND · A(3) · A(2) · A(1) · A(0) from the TOP. The range is set on the SELECT 0-20mA header, whose four positions are silkscreened 0 to 3 — one per channel, all four capped as shipped.
Input range options
| Input range | How it is set | Input resistance |
|---|---|---|
| 0–20 mA / 4–20 mA | Cap fitted (factory default) | approx. 250 Ω |
| DC 0–5 V | Cap removed | 2 kΩ |
| DC 0–10 V | Order option (divider changed) | — |
All four channels are 10-bit (0–1023) and reference REF3025 2.5 V ±0.2 % fed to AREF. The 250 Ω shunt of current mode loads a voltage source heavily — remove the cap before feeding a 0–5 V signal in.
Example sketch — reading an analog input
unsigned int ADC0;
void setup() {
Serial.begin(9600);
}
void loop() {
ADC0 = analogRead(0); // read A(0)
Serial.println(ADC0);
delay(200);
}NTC temperature inputNTC Temperature
2 dedicated NTC channels on their own terminals
T(4) and T(5) are temperature inputs of their own, on a 3-pole strip at the board's left edge legended TEMP. A 10 kΩ pull-up is already fitted, so an NTC thermistor wires straight between its T terminal and the shared AGND — no external divider.
T(4) · T(5) · 2 channels
Dedicated temperature terminals, separate from A(0)–A(3)
NTC 10 kΩ @25 °C
β = 3950 thermistor, as used in the worked example
Pull-up built in
10 kΩ on the board — no external divider needed
Shared AGND
One common ground pole for both channels
NTC temperature terminals
* A 3-pole strip on the board's left edge legended TEMP, in the order T(4) · T(5) · AGND. Each thermistor goes between its own T terminal and AGND; NTC has no polarity, so the two leads can be swapped.
Temperature input specs
| Sensor | NTC 10 kΩ @25 °C · β = 3950 |
|---|---|
| Channels | T(4) = A4 (D58) · T(5) = A5 (D59) |
| Pull-up | 10 kΩ built in |
| Resolution | 10-bit (0–1023) |
| Terminals | 3-pole strip · T(4) · T(5) · shared AGND |
| Return value | ntcRead() returns tenths of a degree (251 → 25.1 °C) |
T(4) and T(5) use the same ADC — and therefore the same reference — as the analog inputs. Where more accuracy is needed, use the interpolated temperature function from the integrated library rather than the Steinhart calculation in the example.
Example sketch — reading the NTC temperature
unsigned int Temp; // tenths of a degree (251 = 25.1C)
void setup() {
Serial.begin(9600);
}
void loop() {
Temp = ntcRead(analogRead(4)); // T(4)
Serial.println(Temp);
delay(500);
}
int ntcRead(unsigned int RawADC) {
float v;
v = (1023.0F / (float)RawADC) - 1.0F;
v = 10000.0F / v;
float steinhart;
steinhart = v / 10000.0F;
steinhart = log(steinhart);
steinhart /= 3950.0F;
steinhart += 1.0F / (25.0F + 273.15F);
steinhart = 1.0F / steinhart;
steinhart -= 273.15F;
return (unsigned int)(steinhart * 10);
}Analog outputAnalog Output
2 analog output channels, DC 0–5 V at 16-bit resolution
AO(6) and AO(7) come out on a 2-pole terminal on the board's left edge and drive DC 0–5 V. There is no DAC peripheral behind them: TIMER4 produces a PWM waveform, a low-pass filter smooths it, and an op-amp buffers the result — which is why the timer is spent and why the board needs its external supply for this to work at all.
AO(6) · AO(7) · 2 channels
DC 0–5 V analog output
16-bit resolution
0–65535 after analogWriteInit()
PWM → filter → buffer
Not a DAC — a smoothed and buffered PWM
External supply required
USB power alone leaves the output at 0 V
How the output is made
* A 2-pole terminal on the board's left edge, legended DAC, reading AO(6) then AO(7). The buffer takes its supply from the board's external DC input, so the output only works with that supply connected.
Analog output specs
| Channels | AO(6) = D6 (OC4A) · AO(7) = D7 (OC4B) |
|---|---|
| Output voltage | DC 0–5 V |
| Resolution | 16-bit (0–65535) |
| Timer resource | TIMER4 — shared by both channels |
| Signal path | TIMER4 PWM → low-pass filter → op-amp buffer |
| Terminal | 2-pole terminal, legended DAC (no ground pole) |
Call analogWriteInit(6, 65535, 1) to put the timer into 16-bit mode, then write the value with analogWrite(6, …) / analogWrite(7, …). Both channels sit on TIMER4, so the TOP and prescaler set on one also apply to the other; their levels stay independent. analogWriteMax(6) reports the maximum currently in effect.
Before you wire it
- The output reads 0 V on USB power alone. The buffer is fed from the board's external DC supply — connect it.
- TIMER4 drives these outputs, so the TCNT4 high-speed counter cannot be used at the same time.
- This connector carries the two signal poles only — it has no ground pole. Take the reference potential from the board's own ground terminals (AGND on the analog and temperature strips, GND on the pulse-output and power strips).
- The output is not isolated.
Example sketch — driving an analog output
void setup() {
// TIMER4 in 16-bit mode (duty range 0~65535)
TCCR4A = 0xAA;
TCCR4B = 0x19;
ICR4 = 65535;
}
void loop() {
analogWrite(6, analogWriteScale(2.5F)); // AO(6) = 2.5V
analogWrite(7, analogWriteScale(3.0F)); // AO(7) = 3.0V
}
unsigned int analogWriteScale(float outVolt) {
return (unsigned int)((outVolt / 5.0F) * 65535);
}High-speed pulse outputPWM Output
4 PWM points on screw terminals, 8-bit or 16-bit duty
P(11) · P(12) · P(5) · P(2) come out on screw terminals as 4 PWM points. Each swings 0 V to 5 V at up to 30 mA behind a 150 Ω series resistor, and the duty is 8-bit by default or 16-bit once the timer registers are set. Points that share a timer share a frequency; their duty stays independent.
4 PWM points
Screw terminals · P(11) · P(12) · P(5) · P(2)
Timer1 / Timer3
Points on one timer share a frequency
8-bit or 16-bit duty
0–255 by default, 0–65535 with the registers set
0 V / 5 V · 30 mA
150 Ω series protection on every point
Pulse output specs
| Item | Value | Note |
|---|---|---|
| Points | 4 | PWM output on screw terminals |
| Output level | LOW DC 0 V / HIGH DC 5 V | Max 30 mA per point |
| Series protection | 150 Ω | Short-circuit protection |
| Duty resolution | 8-bit (0–255) | Up to 16-bit (0–65535) |
| Timer1 | P(11) · P(12) (D11 · D12) | Shared frequency |
| Timer3 | P(5) · P(2) (D5 · D2) | Shared frequency |
analogWrite(pin, duty) drives a point. Two points on the same timer cannot run at different frequencies — only their duty is independent.
PWM terminals and duty
* The silkscreen is what you wire against; the smaller line under each pole is the resource behind it. GND is the return for every point.
Before you wire it
- These outputs are not isolated and are rated 30 mA. Drive a relay, a solenoid or any inductive load through an external driver, never directly.
- Setting a timer's registers for 16-bit duty changes every point on that timer, not just the one you are writing to.
Example sketch — PWM output
void setup() {
// nothing to set up — 8-bit PWM by default
}
void loop() {
if (digitalRead(22) == HIGH) analogWrite(5, 127); // P(5) duty 50%
else analogWrite(5, 0);
}Interrupt · high-speed counterInterrupt · Counter
3 interrupt inputs and 2 isolated counter inputs
P(2) · SDA · SCL take attachInterrupt(), and separately TCNT4 · TCNT5 · COM2 is a photocoupler-isolated counter input that a timer counts in external-clock mode — up to 5 kHz, and DC 0–80 V at the terminal rather than the 5 V an interrupt pin can take.
3 interrupt inputs
P(2) · SDA · SCL
2 isolated counter inputs
TCNT4 · TCNT5 · COM2 · up to 5 kHz
Rotary encoder
SDA / SCL as phases A and B, above 50 kHz
4.7 kΩ pull-ups
On SDA and SCL, shared with I²C
Interrupt and counter specs
| Item | Value | Note |
|---|---|---|
| Interrupt inputs | 3 points | P(2) · SDA · SCL |
| Interrupt level | DC 0–5 V | HIGH from 3 V · MCU I/O, no isolation |
| Counter inputs | 2 points | TCNT4 · TCNT5 · COM2 · LTV-214 isolated |
| Counter level | DC 0–80 V | HIGH from 5V |
| Counter speed | up to 5 kHz | Timer external-clock mode |
| Counter resource | TIMER4 / TIMER5 | 16-bit, 32-bit with the overflow ISR |
The counter terminals are read from the timer's count register — digitalRead() does not work on them. The interrupt pins are ordinary MCU I/O and are not isolated.
Counting an input
* Left: pulses into the counter terminal, counted in hardware. Right: the encoder's two phases are 90° apart, so the level of one at the other's edge gives the direction.
Interrupt and counter terminals
* The larger line is the silkscreen; the smaller one is the Arduino pin and its INT number. The counter poles share one common; the interrupt pins are MCU I/O and take 5 V at most.
Before you wire it
- The interrupt inputs connect straight to MCU I/O. More than DC 5 V will damage the MCU — the isolated counter input is the one that takes field voltages.
- Using SDA and SCL as interrupts or as an encoder input means I²C cannot be used at the same time.
- A timer used for counting cannot also generate PWM, and the reverse.
- The TCNT4 counter and the analog outputs AO(6) / AO(7) both need TIMER4 and cannot be used at the same time.
Example sketch — interrupt
void setup() {
Serial.begin(9600);
// a rising edge on P(2) calls _INT2()
attachInterrupt(digitalPinToInterrupt(2), _INT2, RISING);
}
void loop() {
}
void _INT2() {
Serial.println("ok");
}Example sketch — rotary encoder
volatile long encoderValue = 0;
void setup() {
Serial.begin(115200);
// SDA(20) = phase A, SCL(21) = phase B. I2C cannot be used at the same time.
attachInterrupt(digitalPinToInterrupt(SDA), updateEncoder, FALLING);
}
void loop() {
Serial.print("Encoder: ");
Serial.println(encoderValue);
delay(500);
}
void updateEncoder() {
if (digitalRead(SCL) == LOW) encoderValue++;
else encoderValue--;
}Example sketch — hardware counter
unsigned int HCNT4, HCNT5;
void setup(void) {
// TIMER4 external clock mode (T4 pin)
TIMSK4 = 0x00; TCCR4A = 0x00; TCCR4B = 0x07; TCNT4 = 0x00;
// TIMER5 external clock mode (T5 pin)
TIMSK5 = 0x00; TCCR5A = 0x00; TCCR5B = 0x07; TCNT5 = 0x00;
}
void loop(void) {
HCNT4 = TCNT4; // pulses counted on the TCNT4 terminal
HCNT5 = TCNT5; // pulses counted on the TCNT5 terminal
}
void hcntReset() {
TCNT4 = 0; TCNT5 = 0;
}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 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 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 1 A or less).
- 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.
- Uploading requires the MP download cable, which has the USB-TTL converter built in. An off-the-shelf USB cable cannot upload.
Example sketch — serial send and receive
void setup() {
Serial.begin(9600); // USB download (debug)
Serial1.begin(9600); // RS232
Serial2.begin(9600); // RS485 (automatic direction control)
Serial3.begin(9600); // UART
}
void loop() {
if (Serial1.available()) Serial.write(Serial1.read());
if (Serial2.available()) Serial.write(Serial2.read());
if (Serial3.available()) Serial.write(Serial3.read());
}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 = P(5) · DIO = P(2) is the recommended pair — and +5V and GND come off the bottom power 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 bottom power block · up to 1A
Built-in commands
IsegDecimal and IsegHex print decimals and hex
Displays and their poles
| Display | Terminals | Pins |
|---|---|---|
| Display 1 | CLK = P(5) · DIO = P(2) | D5 · D2 |
| Display 2 | CLK = P(11) · DIO = P(12) | D11 · D12 |
| Supply | +5V · GND | Board output · up to 1A |
The signal poles are PWM pulse output 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 P(2) · P(5) · +5V · GND; nothing on the board says CLK or DIO, so the role of each wire is printed where it lands. P(5) is D5 and P(2) is D2. 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 PWM pulse output 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.
- P(2) and P(5) sit on TIMER3, P(11) and P(12) on TIMER1. A pole driving a display cannot output PWM at the same time.
- P(2) doubles as the external interrupt input INT4. Driving a display from it rules out the interrupt.
- 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 P(5) and P(2) terminals - CLK, DIO, +5V, GND
// Iseg* are ARDUINO SDK built-in commands: nothing to install, no #include to add.
void setup()
{
IsegBegin(5, 2);
IsegBrightness(7); // 0-7 - required, nothing lights without it
IsegClear();
}
void loop()
{
IsegDecimal((millis() / 1000UL) % 10000UL, true);
delay(200);
}Power · Data retentionPower · Backup
DC 12V ~ 24V in, 5 V out — and your data survives the blackout
The controller takes DC 12V ~ 24V and converts it to 5 V internally with a LM2576 regulator. Size the supply for at least 24V 0.5A.
DC 12V ~ 24V
Size the supply for 24V 0.5A or more
5 V internal
LM2576 DC-DC conversion
+5 V out 1A
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.
- The analog output does not work on USB power alone — its buffer needs the 24 V rail, so apply the external supply.
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 12V ~ 24V |
|---|---|
| Recommended supply | 24V 0.5A or more |
| Internal conversion | LM2576 DC-DC to 5 V |
| +5 V output | 1A 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 24V 0.5A or more, plus whatever the +5 V pole is feeding (up to 1A).
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 Ø3.5 mounting holes in the PCB. The board measures 160.0 × 100.0 mm without the rail clip, and stands 114.2 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 Ø3.5 mounting holes
160.0 × 100.0 mm
PCB outline with no rail clip fitted
114.2 mm engaged
119.4 mm with the clip open, 114.2 mm closed
Mounting and dimensions
| Mounting | 35 mm DIN rail, or direct to PCB (Ø3.5 holes) |
|---|---|
| DIN rail | 35 mm |
| PCB alone (no clip) | 160.0 × 100.0 mm |
| Mounting holes | Ø3.5 mm · 143.2 × 90.0 mm apart |
| Clip open (before engaging) | approx. 119.4 mm |
| Clip closed (engaged) | approx. 114.2 mm |
Where no DIN rail is used, the board screws down through the Ø3.5 mounting holes in the PCB; on a rail, the clip closes over a 35 mm profile and the assembly stands 114.2 mm high.
Mounting on a 35 mm DIN rail
* The clip hooks over a 35 mm DIN rail. Overall height is 119.4 mm with the clip open and 114.2 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-16A8R8T have?▾
The MPINO-16A8R8T provides 16 isolated digital inputs and 16 relay outputs, with onboard RS-485, RS-232, UART, I²C communication. See the specification table for the full breakdown.
Does the MPINO-16A8R8T support Modbus RTU?▾
Yes. The MPINO-16A8R8T supports Modbus RTU — master and slave alike — over its serial interface.
Related controllers
/ RELATED
Related guides
/ DOCSModbus RTU on Industrial Arduino: A Practical Guide
Wire RS-485, run a Modbus RTU master and slave on MPINO controllers with the SDK's built-in command set, and integrate with HMIs and SCADA.
RS-485 Networking for Industrial Arduino Controllers
Multi-drop wiring, termination, biasing, and automatic direction control for reliable RS-485 field buses.
How to Connect an HMI to an Industrial Arduino
Expose live I/O and process values to a touchscreen HMI over Modbus RTU or I²C, with register mapping examples.