====== MPINO-8A8R-S ======

MPINO-8A8R-S is a compact all-in-one industrial Arduino with 8 digital inputs and 8 relay outputs. A single PCB integrates 4 analog inputs, 2 NTC temperature sensor inputs, 6 PWM outputs, 4 high-speed inputs, and RS-485·I²C communication.

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

See the [[:en-us_products:mpino_series#mpino_series_specifications|MPINO Series specifications]] for the board name, connection method, and first I/O numbers for MPINO-8A8R-S.





{{ :en-us_products:mpino-8a8r-s-connectors.svg?nolink |MPINO-8A8R-S connector guide }}

===== Product Specifications =====

^  Category  ^  Quantity  ^  Terminal / Item  ^  Specifications  ^
|  Power  |  -  |  Supply voltage  | DC 12~24V (0.5A or more when using DC 24V)  |
|  Digital inputs  |  8 points \\ (Solid-state, isolated)  |  P0~P7  | operating input voltage: DC 0~40V \\ HIGH detection voltage: DC 5V or higher \\ 8 points/1COM \\ NPN/PNP input support  |
|  Relay outputs  |  8 points \\ (Mechanical contacts, isolated)  |  R32~R39  | operating connection voltage: DC 0~30V or AC 0~250V \\ maximum allowable output current: 5A/1 point, 15A/1COM \\ 2 points/1COM × 4 groups  |
|  Analog inputs  |  4 points \\ (Non-isolated)  |  A0~A3  | Standard input: 0(4)~20mA, 10-bit \\ DC 0~5V: 10-bit, input resistance 200kΩ \\ DC 0~10V: 10-bit, input resistance 400kΩ; resistor-change option \\ current input resistance: 250Ω  |
|  Temperature sensor inputs  |  2 points \\ (Non-isolated)  |  A4, A5  | NTC 3950K, 10kΩ(25℃) \\ input temperature: -40~120℃ \\ Resolution: 0.1℃ (at 0~40℃)  |
|  High-speed input \\ Interrupts  |  4 points \\ (Non-isolated)  |  D18(SCL), D19(SDA) \\ D24(CLK), D25(DIO)  | input voltage: DC 0~5V \\ HIGH detection voltage: DC 3V or higher \\ maximum input frequency: 50kHz \\ D18/D19: 4.7kΩ pull-up; D24/D25: 4.7kΩ pull-down  |
|  PWM outputs  |  6 points \\ (Non-isolated)  |  D21~D23 \\ D26~D28  | output voltage: LOW(DC 0V), HIGH(DC 5V) \\ maximum output current: 30mA  |
|  Communication Channels  |  1 channel \\ (Non-isolated)  |  I²C  | I²C master/slave supported \\ Use D18(SCL), D19(SDA)  |
| ::: | ::: |  RS-485  | Use ''Serial1'' \\ Built-in Modbus RTU Master & Slave commands supported \\ Built-in LS Industrial Systems Cnet commands supported  |
|  Memory  |  -  |  Flash  | 128KB  |
| ::: | ::: |  SRAM  | 4KB  |
| ::: | ::: |  EEPROM  | 4KB  |

**Markdown file:** [[https://www.ilogics.net/docs/downloads:mpino:en:mpino_8a8r_s?do=export_raw|Download MPINO-8A8R-S.md]]


===== Digital inputs =====

[[:en-us_guide:wiring#digital_input_one_channel_check|See the one-channel digital-input check before wiring for the first time. →]]
^ Group ^ Terminal ^ Arduino Pin ^ Input Configuration ^ Terminals and Wiring Example ^
| COM0 | P0~P7 | D0~D7 | 8 digital inputs, sharing COM0 |  {{:en-us_products:mpino-8a8r-s-digital-input.svg?628|MPINO-8A8R-S digital input terminals and NPN/PNP wiring}}  |

The digital inputs are isolated by optocouplers and accept DC 5~24V NPN or PNP signals. Select the input type through the COM0 wiring polarity.

==== Example program · digital inputs ====

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

<code cpp>
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);
}
</code>

**Related built-in functions**

=== Function example · consecutive-read filter: IdigitalRead() ===

**Function prototype**

<code cpp>
bool IdigitalRead(uint8_t pin, uint8_t samples);
</code>

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.

<code cpp>
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);
}
</code>

=== Function example · debouncing: Ibounce(), IbounceOn(), IbounceOff() ===

**Function prototype**

<code cpp>
bool Ibounce(uint8_t pin, uint32_t debounceTime);
bool IbounceOn(uint8_t pin, uint32_t debounceTime);
bool IbounceOff(uint8_t pin, uint32_t debounceTime);
</code>

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.

<code cpp>
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);
  }
}
</code>

=== Function example · input toggle: Ialt() ===

**Function prototype**

<code cpp>
void Ialt(bool input, bool &state_var);
</code>

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.

<code cpp>
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"));
  }
}
</code>


===== STATUS LED =====

The MPINO-8A8R-S STATUS LED is an indicator mounted on the board. You can use it to show the operating state of your program.

The STATUS LED is connected to digital pin D20. In a sketch, use ''LED_BUILTIN'' in place of D20. Set ''pinMode(LED_BUILTIN, OUTPUT)'' before controlling it. ''digitalWrite(LED_BUILTIN, HIGH)'' turns the LED on; ''digitalWrite(LED_BUILTIN, LOW)'' turns it off.

**Note:** The STATUS LED is on the board and is separate from the external output terminals.

==== Example · Blink the STATUS LED ====

This example turns the STATUS LED on and off at 0.5-second intervals.

<code cpp>
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  // LED on
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);   // LED off
  delay(500);
}
</code>

===== Relay outputs =====

[[:en-us_guide:wiring#relay_output_one_channel_check|See the one-channel relay-output check before wiring for the first time. →]]
^ Group ^ Terminal ^ Arduino Pin ^ Contact ratings ^ Terminals and Wiring Example ^
| COM1 | R32, R33 | D32, D33 | AC 250V or DC 30V, Max. 5A/1 point·15A/COM |  {{:en-us_products:mpino-8a8r-s-relay-output.svg?492|MPINO-8A8R-S relay output terminals and load wiring}}  |
| COM2 | R34, R35 | D34, D35 | AC 250V or DC 30V, Max. 5A/1 point·15A/COM | ::: |
| COM3 | R36, R37 | D36, D37 | AC 250V or DC 30V, Max. 5A/1 point·15A/COM | ::: |
| COM4 | R38, R39 | D38, D39 | AC 250V or DC 30V, Max. 5A/1 point·15A/COM | ::: |

Relay outputs are dry contacts that physically connect each COM terminal to its output terminal. Connect a separate load power supply.

==== Example program · relay outputs ====

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

<code cpp>
void setup() {
  for (uint8_t pin = 32; pin <= 39; pin++) digitalWrite(pin, LOW);
}

void loop() {
  for (uint8_t ch = 0; ch < 8; ch++) {
    digitalWrite(32 + ch, digitalRead(0 + ch));
  }
}
</code>


===== Analog and Temperature Sensor Inputs =====

^ channel ^ Input Type ^ Input Range ^ Connector Pinout ^
| A0~A3 | Selectable analog inputs | 0(4)~20mA standard \\ DC 0~5V or DC 0~10V option |  {{:en-us_products:mpino-8a8r-s-analog-input.svg?690|MPINO-8A8R-S analog/temperature input connector pinout}}  |
| A4, A5 | NTC temperature sensor inputs | NTC 10kΩ, 3950K \\ -40~120℃ | ::: |

The input modes of A0~A3 are determined by the product's resistor configuration.

==== Example program · analog inputs ====

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

<code cpp>
const uint8_t analogPins[] = {A0, A1, A2, A3};

void setup() {
  Serial.begin(115200);
}

void loop() {
  for (uint8_t ch = 0; ch < 4; ch++) {
    Serial.print(F("A"));
    Serial.print(ch);
    Serial.print(F(" ADC: "));
    Serial.println(analogRead(analogPins[ch]));
  }
  delay(500);
}
</code>

**Related built-in functions**

=== Function example · input range scaling: IanalogRead(), IanalogReadf() ===

**Function prototype**

<code cpp>
int32_t IanalogRead(uint8_t ch, int32_t min, int32_t max);
float IanalogReadf(uint8_t ch, float min, float max);
</code>

This example assumes A0 is configured for 0~5V input and A2 for 0(4)~20mA input. 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.

<code cpp>
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);
}
</code>

=== Function example · 4~20mA range scaling: IanalogRead2(), IanalogRead2f() ===

**Function prototype**

<code cpp>
int32_t IanalogRead2(uint8_t ch, int32_t min, int32_t max);
float IanalogRead2f(uint8_t ch, float min, float max);
</code>

This example assumes A0 is configured for 0~5V input and A2 for 0(4)~20mA input. 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.

<code cpp>
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);
}
</code>

=== Function example · moving average: analogReadAvg(), analogRead2Avg() ===

**Function prototype**

<code cpp>
int32_t analogReadAvg(uint8_t ch, uint8_t samples);
int32_t analogRead2Avg(uint8_t ch, uint8_t samples);
</code>

This example assumes A0 is configured for 0~5V input and A2 for 0(4)~20mA input. 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.

<code cpp>
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);
}
</code>


==== Example program · temperature sensor inputs ====

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

<code cpp>
void setup() {
  Serial.begin(115200);
}

void loop() {
  Serial.print(F("A4 ADC: "));
  Serial.println(analogRead(A4));
  Serial.print(F("A5 ADC: "));
  Serial.println(analogRead(A5));
  delay(500);
}
</code>

**Related built-in functions**

=== Function example · read NTC temperature: ntcRead(), ntcReadf() ===

**Function prototype**

<code cpp>
int ntcRead(uint8_t ch);
float ntcReadf(uint8_t ch);
</code>

Read the temperature of the NTC 10kΩ (25℃), B=3950K sensor connected to NTC input A4. 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.

<code cpp>
void setup() {
  Serial.begin(115200);
}

void loop() {
  const int temperature10 = ntcRead(A4);  // Return A4 temperature as an integer in Celsius ×10
  const float temperature = ntcReadf(A4);  // Return A4 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);
}
</code>


===== PWM / High-speed inputs =====

^ Function ^ Arduino Pin ^ Points ^ Connector Pinout ^
| PWM outputs | D21, D22, D23, D26, D27, D28 | 6 points |  {{:en-us_products:mpino-8a8r-s-pwm-output.svg?634|MPINO-8A8R-S PWM output connector pinout}}  |
| High-Speed Inputs / Interrupts | D18, D19, D24, D25 | 4 points | ::: |
| Encoder Inputs | D24(CLK), D25(DIO) | 2 points | ::: |

D18 and D19 share the I²C SCL·SDA functions; D24 and D25 share CLK·DIO on the FND/ENCO connector. Functions using the same pin cannot be used simultaneously. D21~D23 use TIMER3 resources, and D26~D28 use TIMER1 resources.

==== Example program · PWM outputs ====

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

<code cpp>
void setup() {
  analogWrite(21, 128);
  analogWrite(22, 128);
  analogWrite(23, 128);
  analogWrite(26, 128);
  analogWrite(27, 128);
  analogWrite(28, 128);
}

void loop() {
}
</code>

**Related built-in functions**

=== Function example · specify duty value: PWM() ===

**Function prototype**

<code cpp>
void PWM(uint8_t pin, uint16_t val, bool onDutybit16 = false);
</code>

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, and D26~D28 share Timer1; use the same resolution on the same timer. Start after calling PWM_RESET().

<code cpp>
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() {
}
</code>

=== Function example · set frequency/duty: FDPWM() ===

**Function prototype**

<code cpp>
void FDPWM(uint8_t pin, int32_t intHz, float Duty);
</code>

FDPWM(pin, intHz, Duty) specifies the frequency (Hz) and duty cycle (%). Output 1kHz at 50% duty on D21. D21~D23 share Timer3, and D26~D28 share Timer1; 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.

<code cpp>
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() {
}
</code>

=== Function example · output a specified pulse count: NPWM_BEGIN(), NPWM() ===

**Function prototype**

<code cpp>
void NPWM_BEGIN(uint8_t pin, uint32_t intHz, float Duty, uint32_t N);
void NPWM(uint8_t pin);
</code>

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, and D26~D28 share Timer1; do not combine this with other outputs on the same timer.

<code cpp>
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
}
</code>

=== Function example · stop/resume channel output: PWMOFF() ===

**Function prototype**

<code cpp>
void PWMOFF(uint8_t pin, bool POff);
</code>

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().

<code cpp>
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);
}
</code>

=== Function example · stop/reset PWM timers: PWM_RESET() ===

**Function prototype**

<code cpp>
void PWM_RESET();
</code>

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.

<code cpp>
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() {
}
</code>


==== Example program · pulse counting ====

Count RISING edges on CLK(D24). The input has a 4.7kΩ pull-down. 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.

<code cpp>
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, RISING);
}

void loop() {
  uint32_t snapshot;
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    snapshot = pulseCount;
  }
  Serial.print(F("CLK pulses: "));
  Serial.println(snapshot);
  delay(500);
}
</code>


==== Example program · encoder inputs ====

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

<code cpp>
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 when phase B is HIGH at phase A rising edge (×1 counting)
  if (digitalRead(DIO) == HIGH) {
    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, RISING);
}

void loop() {
  int32_t snapshot;
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    snapshot = position;
  }
  Serial.print(F("Encoder: "));
  Serial.println(snapshot);
  delay(500);
}
</code>


===== Communication and Upload =====

^ Function ^ Arduino Pin ^ Object ^ Device Wiring ^
| Program upload and monitoring | D16(RX0), D17(TX0) | ''Serial'' |  {{:en-us_products:mpino-8a8r-s-communication.svg?780|MPINO-8A8R-S communication connectors and device wiring}}  |
| RS-485 | D30(RX1), D31(TX1) | ''Serial1'' | ::: |
| I²C | D18(SCL), D19(SDA) | ''Wire'' | ::: |

Use the MP download cable to upload programs. RS-485 supports 1:N communication.

==== Example program · basic communication ====

Forward characters between Serial(115200bps) and RS-485 Serial1(9600bps, 8-N-1). Check the free space in the transmit buffer with availableForWrite(). RS-485 uses automatic direction control; no separate direction pin is configured.

<code cpp>
// 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());
  }
}
</code>


==== Example program · I²C communication ====

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.

<code cpp>
#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);
}
</code>


==== Example program · Modbus RTU communication ====

**Related built-in functions**

=== Function example · Modbus RTU Slave: ImodbusRTUMem(), ImodbusRTUAdr(), ImodbusRTUInit(), ImodbusRTU() ===

**Function prototype**

<code cpp>
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();
</code>

Store the D0 state in M[0] and the A0 raw value (0~1023) in D[0] for the other device to read. Configure RS-485(Serial1), station 1, 9600bps, 8N1. Read M[0] with FC01, start address 0, 1 bit; read D[0] with FC03, start address 0, 1 word. Addresses are actual transmitted addresses, starting from 0. 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.

<code cpp>
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-485 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]);
  }
}
</code>

=== Function example · Modbus RTU Master: ImodbusRTUmasterInit(), ImodbusRTUmaster() ===

**Function prototype**

<code cpp>
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);
</code>

Read 1 holding register from the slave every 1 second over RS-485(Serial1). 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.

<code cpp>
unsigned long lastRequest = 0;
uint16_t received[1];

void setup() {
  Serial.begin(115200);
  ImodbusRTUmasterInit(Serial1, 9600, SERIAL_8N1);  // Start RS-485 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);
  }
}
</code>


==== Example program · LS Industrial Systems Cnet communication ====

**Related built-in functions**

=== Function example · LS Industrial Systems Cnet Slave: ICnetMem(), ICnetAdr(), ICnetInit(), ICnet() ===

**Function prototype**

<code cpp>
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();
</code>

Store the D0 state in M[0] and the A0 raw value (0~1023) in D[0] for the HMI to read. Configure the other device for LS Industrial Systems Cnet, RS-485, station 1, 9600bps, 8N1. Read %MX00000(M[0]) for the bit and %DW0(D[0]) for the word. 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.

<code cpp>
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-485 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]);
  }
}
</code>

[[https://www.ilogics.net/en-us/products/mpino-8a8r-s|View MPINO-8A8R-S price and purchase options]]

[[:en-us_products:mpino_series|← MPINO Series comparison (Korean)]]