MPINO-8A4R-S is a all-in-one industrial Arduino with 8 digital inputs and 4 relay with independent COM terminals outputs. A single PCB integrates voltage and current analog inputs, NTC temperature sensor inputs, PWM, high-speed inputs, and RS-232 communication.

Program the controller with Arduino IDE (Arduino C/C++) or MPINO STUDIO 2 (Arduino C/C++ & ladder logic).

Use the MPINO-8A4R-S Arduino IDE getting-started guide to select the board and port and check the first input and output.

Terminal	Arduino Pin	Input Configuration	Terminals and Wiring Example
P0~P3	D0~D3	4 digital inputs, sharing COM0
P4~P7	D4~D7	4 digital inputs, sharing COM1

The digital inputs are isolated by optocouplers. DC 0~40V in the specification is the input circuit's operating voltage range; the wiring below is an example using a DC 5~24V sensor supply. The input is recognized as HIGH when the voltage between the input terminal and COM is at least DC 5V. Select NPN or PNP operation by wiring COM accordingly.

Use digitalRead() to display the D0~D7 input states every 200ms. HIGH is 1 and LOW is 0.

void setup() {
  Serial.begin(115200);
}
 
void loop() {
  for (uint8_t pin = 0; pin <= 7; pin++) {
    Serial.print(F("D"));
    Serial.print(pin);
    Serial.print(F(": "));
    Serial.println(digitalRead(pin));
  }
  delay(200);
}

Related built-in functions

Function prototype

bool IdigitalRead(uint8_t pin, uint8_t samples);

IdigitalRead(0, 5) reads D0 5 times consecutively. It updates the state when all readings are HIGH or all are LOW; mixed readings retain the previous state. Unlike a time-based debounce filter, it inserts no delay between readings.

void setup() {
  Serial.begin(115200);
}
 
void loop() {
  const bool inputOn = IdigitalRead(0, 5);  // Read D0 five times consecutively and return the stable state
  Serial.println(inputOn ? F("D0 ON") : F("D0 OFF"));
  delay(200);
}

Function prototype

bool Ibounce(uint8_t pin, uint32_t debounceTime);
bool IbounceOn(uint8_t pin, uint32_t debounceTime);
bool IbounceOff(uint8_t pin, uint32_t debounceTime);

Compare three filters on the D0 input. Each returns the filtered ON/OFF state.

• Ibounce(0, 30): Apply either ON or OFF after it remains stable for at least 30ms.
• IbounceOn(0, 500): Delay ON by 500ms; apply OFF immediately.
• IbounceOff(0, 500): Delay OFF by 500ms; apply ON immediately.

Each function operates independently, even on the same pin. Run the filters on every loop() iteration and display only the results at 200ms intervals.

unsigned long lastPrint = 0;
 
void setup() {
  Serial.begin(115200);
}
 
void loop() {
  const bool stable = Ibounce(0, 30);  // Filter D0 ON/OFF chatter over 30ms
  const bool onDelayed = IbounceOn(0, 500);  // Delay only D0 ON by 500ms; apply OFF immediately
  const bool offDelayed = IbounceOff(0, 500);  // Delay only D0 OFF by 500ms; apply ON immediately
 
  if (millis() - lastPrint >= 200) {
    lastPrint = millis();
    Serial.print(F("Ibounce: "));
    Serial.print(stable);
    Serial.print(F(", IbounceOn: "));
    Serial.print(onDelayed);
    Serial.print(F(", IbounceOff: "));
    Serial.println(offDelayed);
  }
}

Function prototype

void Ialt(bool input, bool &state_var);

Ialt(input, state) inverts state whenever the input changes from OFF to ON. Pressing D0 once turns D32 ON; pressing again turns it OFF. Holding the input does not change the state again. This example debounces the input with Ibounce(0, 30) before passing it to Ialt(). outputOn is a global variable retained between calls, and Ialt() modifies it directly.

bool outputOn = false;
 
void setup() {
  Serial.begin(115200);
  digitalWrite(32, LOW);
}
 
void loop() {
  const bool previous = outputOn;
  const bool inputOn = Ibounce(0, 30);  // Filter D0 ON/OFF chatter over 30ms
  Ialt(inputOn, outputOn);  // Invert outputOn on an OFF→ON input transition
  digitalWrite(32, outputOn ? HIGH : LOW);
 
  if (outputOn != previous) {
    Serial.println(outputOn ? F("D32 ON") : F("D32 OFF"));
  }
}

Terminal	Arduino Pin	Contact ratings	COM configuration	Terminals and Wiring Example
P32	D32	AC 250V or DC 30V, Max. 5A	Separate COM2
P33	D33	AC 250V or DC 30V, Max. 5A	Separate COM3
P34	D34	AC 250V or DC 30V, Max. 5A	Separate COM4
P35	D35	AC 250V or DC 30V, Max. 5A	Separate COM5

Each relay point has its own independent COM terminal. Relay contacts are dry contacts that do not supply power; connect a separate load power supply.

Map inputs D0~D3 to outputs D32~D35 in order. When an input is HIGH, its corresponding output turns ON.

void setup() {
  for (uint8_t pin = 32; pin <= 35; pin++) digitalWrite(pin, LOW);
}
 
void loop() {
  for (uint8_t ch = 0; ch < 4; ch++) {
    digitalWrite(32 + ch, digitalRead(0 + ch));
  }
}

Use analogRead() to display the ADC raw values (0~1023) of A0~A5. Each channel's voltage/current mode follows the actual product settings.

const uint8_t analogPins[] = {A0, A1, A2, A3, A4, A5};
 
void setup() {
  Serial.begin(115200);
}
 
void loop() {
  for (uint8_t ch = 0; ch < 6; ch++) {
    Serial.print(F("A"));
    Serial.print(ch);
    Serial.print(F(" ADC: "));
    Serial.println(analogRead(analogPins[ch]));
  }
  delay(500);
}

Related built-in functions

Function prototype

int32_t IanalogRead(uint8_t ch, int32_t min, int32_t max);
float IanalogReadf(uint8_t ch, float min, float max);

Both functions scale the ADC input to the specified min~max range. IanalogRead() returns an integer with the fractional part discarded; IanalogReadf() returns a floating-point value. This example displays the 0~5V input on A0 as both 0~100% and voltage. For the 0~20mA input on A2, specify a range of 0~20 to read the actual current.

void setup() {
  Serial.begin(115200);
}
 
void loop() {
  const int32_t percent = IanalogRead(A0, 0, 100);  // Scale A0 to an integer from 0~100%
  const float voltage = IanalogReadf(A0, 0.0f, 5.0f);  // Scale A0 to a floating-point voltage from 0~5V
  const float current = IanalogReadf(A2, 0.0f, 20.0f);  // Scale A2 to a floating-point current from 0~20mA
  Serial.print(F("A0: "));
  Serial.print(percent);
  Serial.print(F(" %, "));
  Serial.print(voltage, 2);
  Serial.print(F(" V, A2: "));
  Serial.print(current, 2);
  Serial.println(F(" mA"));
  delay(500);
}

Function prototype

int32_t IanalogRead2(uint8_t ch, int32_t min, int32_t max);
float IanalogRead2f(uint8_t ch, float min, float max);

Scale a 4~20mA sensor input connected to A2 to a user-defined range. IanalogRead2(A2, 0, 100) returns an integer with 4mA mapped to 0% and 20mA to 100%. IanalogRead2f(A2, 4.0f, 20.0f) returns the current as a floating-point value. Below approximately 3.6mA, both functions return ANALOG_READ2_ERROR(65535); from approximately 3.6~4mA, they return the specified minimum.

void setup() {
  Serial.begin(115200);
}
 
void loop() {
  const int32_t percent = IanalogRead2(A2, 0, 100);  // Scale A2 4~20mA to an integer from 0~100%
  const float current = IanalogRead2f(A2, 4.0f, 20.0f);  // Convert A2 4~20mA to a floating-point current
  if (percent == ANALOG_READ2_ERROR ||
      current == (float)ANALOG_READ2_ERROR) {
    Serial.println(F("A2: 4-20mA input error"));
  } else {
    Serial.print(F("A2: "));
    Serial.print(percent);
    Serial.print(F(" %, "));
    Serial.print(current, 2);
    Serial.println(F(" mA"));
  }
  delay(500);
}

Function prototype

int32_t analogReadAvg(uint8_t ch, uint8_t samples);
int32_t analogRead2Avg(uint8_t ch, uint8_t samples);

analogReadAvg(A0, 5) returns a moving average of the raw A0 ADC readings (0~1023). analogRead2Avg(A2, 5) averages the corrected A2 4~20mA values (4mA=0, 20mA=32767). Each function accumulates up to 5 valid readings from recent calls; it does not take 5 readings in one call. The maximum samples value is 20. analogRead2Avg() returns ANALOG_READ2_AVG_ERROR(-1) for inputs below approximately 3.6mA.

void setup() {
  Serial.begin(115200);
}
 
void loop() {
  const int32_t voltageAvg = analogReadAvg(A0, 5);  // Moving average of up to 5 recent A0 ADC values
  const int32_t currentAvg = analogRead2Avg(A2, 5);  // Moving average of up to 5 recent corrected A2 4~20mA values
  Serial.print(F("A0 ADC average: "));
  Serial.print(voltageAvg);
  Serial.print(F(", A2 4-20mA average: "));
  if (currentAvg == ANALOG_READ2_AVG_ERROR) {
    Serial.println(F("input error"));
  } else {
    Serial.println(currentAvg);
  }
  delay(500);
}

Use analogRead() to display the temperature-sensor ADC raw values (0~1023) of A6, A7. Celsius conversion is explained in the built-in functions below.

void setup() {
  Serial.begin(115200);
}
 
void loop() {
  Serial.print(F("A6 ADC: "));
  Serial.println(analogRead(A6));
  Serial.print(F("A7 ADC: "));
  Serial.println(analogRead(A7));
  delay(500);
}

Related built-in functions

Function prototype

int ntcRead(uint8_t ch);
float ntcReadf(uint8_t ch);

Read the temperature of the NTC 10kΩ (25℃), B=3950K sensor connected to NTC input A6. ntcRead() returns an integer equal to 10 times the Celsius temperature (25.3℃ → 253); ntcReadf() returns the Celsius temperature as a floating-point value (25.3). Both have a resolution of 0.1℃. Values outside the conversion range are clamped to -40℃ or 120℃, so do not use these values to detect an open or short circuit.

void setup() {
  Serial.begin(115200);
}
 
void loop() {
  const int temperature10 = ntcRead(A6);  // Return A6 temperature as an integer in Celsius ×10
  const float temperature = ntcReadf(A6);  // Return A6 temperature as floating-point Celsius
  Serial.print(F("ntcRead: "));
  Serial.print(temperature10);
  Serial.print(F(" (0.1 C), ntcReadf: "));
  Serial.print(temperature, 1);
  Serial.println(F(" C"));
  delay(500);
}

Function	Arduino Pin	Points	Connector Pinout
PWM outputs	D21, D22, D23	3 points
High-Speed Inputs / Interrupts	D18, D19, D24, D25	4 points
Encoder Inputs	D24, D25	2 points

D18 and D19 share the I²C SCL and SDA functions. These pins cannot be used as high-speed inputs while I²C communication is active.

Set analogWrite() duty value 128 in the 0~255 range on D21, D22, D23 to output approximately 50% PWM.

void setup() {
  analogWrite(21, 128);
  analogWrite(22, 128);
  analogWrite(23, 128);
}
 
void loop() {
}

Related built-in functions

Function prototype

void PWM(uint8_t pin, uint16_t val, bool onDutybit16 = false);

PWM(pin, val, onDutybit16) sets the duty value. The 8-bit range is 0~255; with the third argument true, the 16-bit range is 0~65535. Output the 16-bit midpoint value 32768 on D21. D21~D23 share Timer3; use the same resolution on the same timer. Start after calling PWM_RESET().

void setup() {
  PWM_RESET();  // Stop PWM timers and reset their modes
  PWM(21, 32768, true);  // Output a midrange 16-bit duty value on D21
}
 
void loop() {
}

Function prototype

void FDPWM(uint8_t pin, int32_t intHz, float Duty);

FDPWM(pin, intHz, Duty) specifies the frequency (Hz) and duty cycle (%). Output 1kHz at 50% duty on D21. D21~D23 share Timer3; specify the same frequency for outputs on the same timer. There is no separate FPWM() function; use FDPWM(pin, hz, 50.0f) for 50% duty output.

void setup() {
  PWM_RESET();  // Stop PWM timers and reset their modes
  FDPWM(21, 1000, 50.0f);  // Output 1kHz at 50% duty on D21
}
 
void loop() {
}

Function prototype

void NPWM_BEGIN(uint8_t pin, uint32_t intHz, float Duty, uint32_t N);
void NPWM(uint8_t pin);

Use NPWM_BEGIN() to prepare 100 pulses at 1kHz and 50% duty on D21, then run NPWM() on every loop() iteration to handle output and completion. Do not insert delay(). D21~D23 share Timer3; do not combine this with other outputs on the same timer.

void setup() {
  PWM_RESET();  // Stop PWM timers and reset their modes
  NPWM_BEGIN(21, 1000, 50.0f, 100);  // Prepare 100 pulses at 1kHz, 50% duty on D21
}
 
void loop() {
  NPWM(21);  // Process the prepared pulse output and completion
}

Function prototype

void PWMOFF(uint8_t pin, bool POff);

PWMOFF(pin, true) sets the channel stop flag; false clears it. Call FDPWM() immediately after setting the flag to apply it to the output connection. Turn D21 on for 2 seconds and off for 2 seconds; after stopping, hold LOW with digitalWrite(). This stop flag does not apply to NPWM().

void setup() {
  PWM_RESET();  // Stop PWM timers and reset their modes
}
 
void loop() {
  PWMOFF(21, false);  // Clear the stop state of D21
  FDPWM(21, 1000, 50.0f);  // Apply the cleared flag and start 1kHz, 50% output
  delay(2000);
 
  PWMOFF(21, true);  // Set the stop state of D21
  FDPWM(21, 1000, 50.0f);  // Apply the stop flag and disconnect PWM output
  digitalWrite(21, LOW);
  delay(2000);
}

Function prototype

void PWM_RESET();

PWM_RESET() resets the Timer1·Timer3 control registers and counters. Output 1kHz on D21 for 2 seconds, then stop all timers. This also affects PWM and counters on the same timer. It does not also clear the PWMOFF() stop flag.

void setup() {
  PWM_RESET();  // Stop PWM timers and reset their modes
  FDPWM(21, 1000, 50.0f);  // Output 1kHz at 50% duty on D21
  delay(2000);
  PWM_RESET();  // Stop and reset all Timer1/Timer3 PWM outputs
  digitalWrite(21, LOW);
}
 
void loop() {
}

Count FALLING edges on CLK(D24). The input has a 10kΩ pull-up. This software interrupt example reads the 32-bit value with ATOMIC_BLOCK and displays it every 500ms. Lossless counting is not guaranteed at the maximum input frequency.

static_assert(digitalPinToInterrupt(CLK) != NOT_AN_INTERRUPT, "Invalid interrupt input");
 
#include <util/atomic.h>
 
volatile uint32_t pulseCount = 0;
 
void countPulse() {
  pulseCount++;
}
 
void setup() {
  Serial.begin(115200);
  // Count at the selected edge of the input signal
  attachInterrupt(digitalPinToInterrupt(CLK), countPulse, FALLING);
}
 
void loop() {
  uint32_t snapshot;
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    snapshot = pulseCount;
  }
  Serial.print(F("CLK pulses: "));
  Serial.println(snapshot);
  delay(500);
}

Connect phase A to CLK(D24) and phase B to DIO(D25). This x1 counting example uses a 10kΩ pull-up and increments when phase B is LOW at a FALLING edge. The actual rotation direction depends on the phase A/B wiring.

static_assert(digitalPinToInterrupt(CLK) != NOT_AN_INTERRUPT, "Invalid interrupt input");
 
#include <util/atomic.h>
#include <stdint.h>
 
volatile int32_t position = 0;
 
void readEncoder() {
  // Increment if phase B is LOW at the phase A falling edge (x1 decoding)
  if (digitalRead(DIO) == LOW) {
    if (position < INT32_MAX) position++;
  } else {
    if (position > INT32_MIN) position--;
  }
}
 
void setup() {
  Serial.begin(115200);
  // Encoder phase A → CLK(D24), phase B → DIO(D25)
  attachInterrupt(digitalPinToInterrupt(CLK), readEncoder, FALLING);
}
 
void loop() {
  int32_t snapshot;
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    snapshot = position;
  }
  Serial.print(F("Encoder: "));
  Serial.println(snapshot);
  delay(500);
}

Forward characters between Serial(115200bps) and RS-232 Serial1(9600bps, 8-N-1). Check the free space in the transmit buffer with availableForWrite().

// Serial Monitor via MP download cable ↔ RS-232 Serial1
void setup() {
  Serial.begin(115200);
  Serial1.begin(9600);  // Also configure the other device for 9600 bps, 8-N-1
}
 
void loop() {
  if (Serial.available() && Serial1.availableForWrite()) {
    Serial1.write(Serial.read());
  }
  if (Serial1.available() && Serial.availableForWrite()) {
    Serial.write(Serial1.read());
  }
}

Use Wire to scan addresses 0x08~0x77 and display responding addresses every 3 seconds. Do not run this simultaneously with encoder/interrupt examples that use SDA·SCL.

#include <Wire.h>
 
void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(100000);
}
 
void loop() {
  uint8_t found = 0;
  for (uint8_t address = 0x08; address <= 0x77; address++) {
    Wire.beginTransmission(address);
    const uint8_t result = Wire.endTransmission();
    if (result == 0) {
      Serial.print(F("I2C: 0x"));
      if (address < 16) Serial.print('0');
      Serial.println(address, HEX);
      found++;
    }
  }
  Serial.print(F("Devices: "));
  Serial.println(found);
  delay(3000);
}

Related built-in functions

Function prototype

void ImodbusRTUMem(uint16_t m_size, uint16_t d_size);
void ImodbusRTUAdr(uint16_t m_offset, uint16_t d_offset);
void ImodbusRTUInit(HardwareSerial& serialPort, uint8_t slaveId, long baudrate);
void ImodbusRTU();

Store the D0 state in M[0] and the raw A0 reading (0~1023) in D[0] for the other device to read. Configure RS-232(Serial1), station 1, 9600bps, 8N1. Read M[0] with FC01, start address 0, quantity 1 bit; read D[0] with FC03, start address 0, quantity 1 word. Addresses are zero-based on-wire addresses. Call the communication function on every loop() iteration. This example does not control outputs.

M and D are shared global memory provided by the core. Run this sketch on its own. When combining protocols, do not allocate the shared memory more than once.

unsigned long lastPrint = 0;
bool memoryReady = false;
 
void setup() {
  Serial.begin(115200);
  ImodbusRTUMem(8, 8);  // Allocate 8 M bits and 8 D words
  ImodbusRTUAdr(0, 0);  // Set the M and D communication start addresses to 0
  ImodbusRTUInit(Serial1, 1, 9600);  // Start RS-232 at station 1, 9600bps
  memoryReady = (M != nullptr && D != nullptr);
  if (!memoryReady) Serial.println(F("Memory allocation failed"));
}
 
void loop() {
  if (!memoryReady) return;
  M[0] = digitalRead(0);
  D[0] = analogRead(A0);
  ImodbusRTU();  // Process incoming Modbus RTU requests
 
  if (millis() - lastPrint >= 1000) {
    lastPrint = millis();
    Serial.print(F("M[0]: "));
    Serial.print(M[0]);
    Serial.print(F(", D[0]: "));
    Serial.println(D[0]);
  }
}

Function prototype

void ImodbusRTUmasterInit(HardwareSerial& serialPort, long baudrate, uint8_t config);
uint8_t ImodbusRTUmaster(HardwareSerial& serialPort, uint8_t slaveId, uint8_t functionCode, uint16_t address, uint16_t quantity, uint16_t* data, uint16_t timeoutMs = 100);

Read one holding register from the remote slave over RS-232(Serial1) every 1 second. Configure the other device for station 1, 9600bps, 8N1, FC03, and on-wire start address 0. The response is stored in received[0] and displayed only on success. Error codes are displayed in hexadecimal. This is a separate sketch from the slave example above and uses a receive array instead of M/D memory.

unsigned long lastRequest = 0;
uint16_t received[1];
 
void setup() {
  Serial.begin(115200);
  ImodbusRTUmasterInit(Serial1, 9600, SERIAL_8N1);  // Start RS-232 as a Modbus master
}
 
void loop() {
  if (millis() - lastRequest < 1000) return;
  lastRequest = millis();
  const uint8_t result = ImodbusRTUmaster(Serial1, 1, 3, 0, 1, received, 200);  // Read 1 word at address 0 from station 1, timeout 200ms
 
  if (result == IMODBUS_RTU_SUCCESS) {
    Serial.print(F("Register 0: "));
    Serial.println(received[0]);
  } else {
    Serial.print(F("Modbus error: 0x"));
    Serial.println(result, HEX);
  }
}

Related built-in functions

Function prototype

void ICnetMem(uint16_t m_size, uint16_t d_size, uint16_t r_size = 100);
void ICnetAdr(uint16_t m_offset, uint16_t d_offset, uint16_t r_offset = 0);
void ICnetInit(HardwareSerial& serialPort, uint8_t slaveId, long baudrate);
void ICnet();

Store the D0 state in M[0] and the raw A0 reading (0~1023) in D[0] for an HMI to read. Configure the other device for LS Industrial Systems Cnet, RS-232, station 1, 9600bps, 8N1. Read the bit at %MX00000(M[0]) and the word at %DW0(D[0]). Call the communication function on every loop() iteration. This example does not control outputs.

M, D, and R are shared global memory provided by the core; this example does not use R. Run this separately from the Modbus example. When combining protocols, do not allocate the shared memory more than once.

unsigned long lastPrint = 0;
bool memoryReady = false;
 
void setup() {
  Serial.begin(115200);
  ICnetMem(8, 8, 0);  // Allocate 8 M bits and 8 D words; R is unused
  ICnetAdr(0, 0, 0);  // Set the M and D communication start addresses to 0
  ICnetInit(Serial1, 1, 9600);  // Start RS-232 at station 1, 9600bps
  memoryReady = (M != nullptr && D != nullptr);
  if (!memoryReady) Serial.println(F("Memory allocation failed"));
}
 
void loop() {
  if (!memoryReady) return;
  M[0] = digitalRead(0);
  D[0] = analogRead(A0);
  ICnet();  // Process incoming LS Cnet requests
 
  if (millis() - lastPrint >= 1000) {
    lastPrint = millis();
    Serial.print(F("M[0]: "));
    Serial.print(M[0]);
    Serial.print(F(", D[0]: "));
    Serial.println(D[0]);
  }
}

← MPINO Series comparison (Korean)