차이

문서의 선택한 두 판 사이의 차이를 보여줍니다.

--- products:mpino_16a8r8t [2026/09/03 14:21] – 바깥 편집 127.0.0.1
+++ products:mpino_16a8r8t [2026/09/15 17:45] (현재) – 바깥 편집 127.0.0.1
@@ 줄 5: / 줄 5: @@
 Arduino IDE(Arduino C/C++) 또는 MPINO STUDIO 2(Arduino C/C++ & 래더로직)로 프로그램할 수 있습니다.
-{{ :products:mpino-16a8r8t-connectors.svg?nolink |}}
+[[:products:mpino_series#mpino_series_사양표|MPINO Series 사양표]]에서 MPINO-16A8R8T의 보드 이름, 연결 방법과 첫 입출력 번호를 확인할 수 있습니다.
-===== 주요 사양 =====
+{{ :products:mpino-16a8r8t-connectors.svg?nolink |MPINO-16A8R8T 커넥터 안내}}
+===== 제품 사양서 =====
 ^  구분  ^  개수  ^  접점명  ^  사양  ^
@@ 줄 14: / 줄 19: @@
 |  릴레이 출력  |  8점 \\ (유접점·절연)  |  R(62)~R(69)  | 동작 연결 전압: DC 0~30V 또는 AC 0~250V \\ 최대 출력 허용 전류: 5A/1점 \\ 2점/1COM × 4그룹  |
 |  트랜지스터 출력  |  8점 \\ (무접점·비절연)  |  O(39)~O(46)  | SINK 출력 \\ 동작 출력 전압: DC 0~55V \\ 최대 출력 허용 전류: 3A/1점, 15A/COM  |
-|  아날로그 입력  |  4점 \\ (비절연)  |  A(0)~A(3)  | 기본 입력: DC 0~20mA \\ 점퍼 해제 시: DC 0~5V \\ 선택 사양: DC 0~10V \\ 10bit (0~1023)  |
+|  아날로그 입력  |  4점 \\ (비절연)  |  A(0)~A(3)  | 기본 입력: DC 0~20mA \\ 점퍼 해제 시: DC 0~5V \\ 선택 사양: DC 0~10V \\ 10bit (0~1023)  |
 |  아날로그 출력  |  2점 \\ (비절연)  |  AO(6), AO(7)  | DC 0~5V \\ 16bit (0~65535)  |
 |  온도센서 입력  |  2점 \\ (비절연)  |  T(4), T(5)  | NTC 10kΩ(25℃), 3950K \\ 10kΩ 풀업 저항 내장 \\ 10bit (0~1023)  |
@@ 줄 27: / 줄 32: @@
 | ::: | ::: |  SRAM  | 8KB  |
 | ::: | ::: |  EEPROM  | 4KB  |
+**Markdown 자료:** [[https://www.ilogics.net/docs/downloads:mpino:ko:mpino_16a8r8t?do=export_raw|MPINO-16A8R8T.md 다운로드]]
 ===== 디지털 입력 =====
-^ 그룹 ^ 단자 ^ Arduino 핀 ^ 입력 구성 ^
+[[:guide:wiring#디지털_입력_한_채널_확인|처음 결선할 때는 디지털 입력 한 채널 확인 순서를 함께 보십시오. →]]
-| COM0 | I(22)~I(29) | D22~D29 | 디지털 입력 8점, COM0 공유 |
+^ 그룹 ^ 단자 ^ Arduino 핀 ^ 입력 구성 ^ 단자대 및 결선 예시 ^
-| COM1 | I(30)~I(37) | D30~D37 | 디지털 입력 8점, COM1 공유 |
+| COM0 | I(22)~I(29) | D22~D29 | 디지털 입력 8점, COM0 공유 |  {{:products:mpino-16a8r8t-digital-input.svg?727|MPINO-16A8R8T 디지털 입력 단자대와 NPN·PNP 결선}}  |
+| COM1 | I(30)~I(37) | D30~D37 | 디지털 입력 8점, COM1 공유 | ::: |
 디지털 입력은 양방향 포토커플러로 절연되어 있으며 DC 5~24V의 NPN 또는 PNP 입력을 연결할 수 있습니다. 입력 방식은 COM0·COM1 결선 방향으로 선택합니다.
+==== 예제 프로그램 · 디지털 입력 ====
+digitalRead()로 D22~D37의 입력 상태를 200ms마다 표시합니다. HIGH는 1, LOW는 0입니다.
+<code cpp>
+void setup() {
+  Serial.begin(115200);
+}
+void loop() {
+  for (uint8_t pin = 22; pin <= 37; pin++) {
+    Serial.print(F("D"));
+    Serial.print(pin);
+    Serial.print(F(": "));
+    Serial.println(digitalRead(pin));
+  }
+  delay(200);
+}
+</code>
+**관련 내장 명령어**
+=== 함수 예제 · 연속 판독 필터: IdigitalRead() ===
+**함수 원형**
+<code cpp>
+bool IdigitalRead(uint8_t pin, uint8_t samples);
+</code>
+IdigitalRead(22, 5)는 D22을 5회 연속 판독합니다. 모두 HIGH 또는 모두 LOW일 때 상태를 갱신하고, 값이 섞이면 이전 상태를 유지합니다. 시간 기준의 채터링 필터와 달리 판독 사이에 지연을 넣지 않습니다.
+<code cpp>
+void setup() {
+  Serial.begin(115200);
+}
+void loop() {
+  const bool inputOn = IdigitalRead(22, 5);  // D22을 5회 연속 판독해 안정된 상태 반환
+  Serial.println(inputOn ? F("D22 ON") : F("D22 OFF"));
+  delay(200);
+}
+</code>
+=== 함수 예제 · 채터링 방지: Ibounce(), IbounceOn(), IbounceOff() ===
+**함수 원형**
+<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>
+D22 입력을 세 가지 필터로 비교합니다. 반환값은 필터 처리된 ON/OFF 상태입니다.
+  * ''Ibounce(22, 30)'': ON과 OFF 모두 30ms 이상 안정된 뒤 반영합니다.
+  * ''IbounceOn(22, 500)'': ON만 500ms 지연하고 OFF는 즉시 반영합니다.
+  * ''IbounceOff(22, 500)'': OFF만 500ms 지연하고 ON은 즉시 반영합니다.
+각 함수는 같은 핀에서도 독립적으로 동작합니다. 필터를 loop()마다 실행하고 결과만 200ms 간격으로 표시합니다.
+<code cpp>
+unsigned long lastPrint = 0;
+void setup() {
+  Serial.begin(115200);
+}
+void loop() {
+  const bool stable = Ibounce(22, 30);  // D22의 ON/OFF 채터링을 30ms로 필터링
+  const bool onDelayed = IbounceOn(22, 500);  // D22의 ON만 500ms 지연, OFF는 즉시 반영
+  const bool offDelayed = IbounceOff(22, 500);  // D22의 OFF만 500ms 지연, ON은 즉시 반영
+  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>
+=== 함수 예제 · 입력 토글: Ialt() ===
+**함수 원형**
+<code cpp>
+void Ialt(bool input, bool &state_var);
+</code>
+Ialt(input, state)는 입력이 OFF에서 ON으로 바뀔 때마다 state를 반전합니다. D22을 한 번 누르면 D39가 ON, 다시 누르면 OFF가 되며 누르고 있는 동안은 유지됩니다. 예제는 Ibounce(22, 30)로 채터링을 걸러 Ialt()에 전달합니다. outputOn은 호출 사이에 유지되는 전역 변수이며, Ialt()가 이 값을 직접 변경합니다.
+<code cpp>
+bool outputOn = false;
+void setup() {
+  Serial.begin(115200);
+  digitalWrite(39, LOW);
+}
+void loop() {
+  const bool previous = outputOn;
+  const bool inputOn = Ibounce(22, 30);  // D22의 ON/OFF 채터링을 30ms로 필터링
+  Ialt(inputOn, outputOn);  // 입력이 OFF→ON일 때 outputOn 반전
+  digitalWrite(39, outputOn ? HIGH : LOW);
+  if (outputOn != previous) {
+    Serial.println(outputOn ? F("D39 ON") : F("D39 OFF"));
+  }
+}
+</code>
 ===== 트랜지스터 출력 =====
-^ 단자 ^ Arduino 핀 ^ 출력 방식 ^ 정격 ^
+[[:guide:wiring#sink_트랜지스터_출력_한_채널_확인|처음 결선할 때는 SINK 트랜지스터 출력 한 채널 확인 순서를 함께 보십시오. →]]
-| O(39)~O(46) | D39~D46 | SINK \\ ON: GND 연결 \\ OFF: 개방 | DC 0~55V \\ 최대 3A/1점·15A/COM |
+^ 단자 ^ Arduino 핀 ^ 출력 방식 ^ 정격 ^ 단자대 및 결선 예시 ^
+| O(39)~O(46) | D39~D46 | SINK \\ ON: GND 연결 \\ OFF: 개방 | DC 0~55V \\ 최대 3A/1점·15A/COM |  {{:products:mpino-16a8r8t-transistor-output.svg?1000|MPINO-16A8R8T 트랜지스터 출력 단자대와 SINK 결선}}  |
 트랜지스터 출력 부하는 V+와 출력 단자 사이에 연결합니다.
+==== 예제 프로그램 · 트랜지스터 출력 ====
+D22~D29 입력을 D39~D46 출력에 순서대로 대응시킵니다. 입력이 HIGH이면 해당 출력이 ON됩니다.
+<code cpp>
+void setup() {
+  for (uint8_t pin = 39; pin <= 46; pin++) digitalWrite(pin, LOW);
+}
+void loop() {
+  for (uint8_t ch = 0; ch < 8; ch++) {
+    digitalWrite(39 + ch, digitalRead(22 + ch));
+  }
+}
+</code>
 ===== 릴레이 출력 =====
-^ 그룹 ^ 단자 ^ Arduino 핀 ^ 접점 정격 ^
+[[:guide:wiring#릴레이_출력_한_채널_확인|처음 결선할 때는 릴레이 출력 한 채널 확인 순서를 함께 보십시오. →]]
-| COM3 | R(62), R(63) | D62, D63 | AC 250V 또는 DC 30V, 최대 5A/1점 |
+^ 그룹 ^ 단자 ^ Arduino 핀 ^ 접점 정격 ^ 단자대 및 결선 예시 ^
-| COM4 | R(64), R(65) | D64, D65 | AC 250V 또는 DC 30V, 최대 5A/1점 |
+| COM3 | R(62), R(63) | D62, D63 | AC 250V 또는 DC 30V, 최대 5A/1점 |  {{:products:mpino-16a8r8t-relay-output.svg?558|MPINO-16A8R8T 릴레이 출력 단자대와 부하 결선}}  |
-| COM5 | R(66), R(67) | D66, D67 | AC 250V 또는 DC 30V, 최대 5A/1점 |
+| COM4 | R(64), R(65) | D64, D65 | AC 250V 또는 DC 30V, 최대 5A/1점 | ::: |
-| COM6 | R(68), R(69) | D68, D69 | AC 250V 또는 DC 30V, 최대 5A/1점 |
+| COM5 | R(66), R(67) | D66, D67 | AC 250V 또는 DC 30V, 최대 5A/1점 | ::: |
+| COM6 | R(68), R(69) | D68, D69 | AC 250V 또는 DC 30V, 최대 5A/1점 | ::: |
 릴레이 출력은 각 COM 단자와 출력 단자를 물리적으로 연결하는 무전압 접점입니다. 부하 전원은 별도로 연결합니다.
+==== 예제 프로그램 · 릴레이 출력 ====
+D22~D29 입력을 D62~D69 출력에 순서대로 대응시킵니다. 입력이 HIGH이면 해당 출력이 ON됩니다.
+<code cpp>
+void setup() {
+  for (uint8_t pin = 62; pin <= 69; pin++) digitalWrite(pin, LOW);
+}
+void loop() {
+  for (uint8_t ch = 0; ch < 8; ch++) {
+    digitalWrite(62 + ch, digitalRead(22 + ch));
+  }
+}
+</code>
 ===== 아날로그 입력ㆍ온도센서 입력 =====
-^ 기능 ^ 단자·Arduino 핀 ^ 입력 범위 ^ 분해능 ^
+^ 기능 ^ 단자·Arduino 핀 ^ 입력 범위 ^ 분해능 ^ 커넥터 핀 배열 ^
-| 아날로그 입력 | A(0)~A(3) \\ D54~D57 | DC 0~20mA(기본) \\ DC 0~5V(점퍼 해제) \\ DC 0~10V(선택 사양) | 10bit (0~1023) |
+| 아날로그 입력 | A(0)~A(3) \\ D54~D57 | DC 0~20mA(기본) \\ DC 0~5V(점퍼 해제) \\ DC 0~10V(선택 사양) | 10bit (0~1023) |  {{:products:mpino-16a8r8t-analog-input.svg?697|MPINO-16A8R8T 아날로그·온도 입력 커넥터 핀 배열}}  |
-| 온도센서 입력 | T(4), T(5) \\ D58, D59 | NTC 10kΩ(25℃), 3950K | 10bit (0~1023) |
+| 온도센서 입력 | T(4), T(5) \\ D58, D59 | NTC 10kΩ(25℃), 3950K | 10bit (0~1023) | ::: |
+==== 예제 프로그램 · 아날로그 입력 ====
+analogRead()로 A0~A3의 ADC 원시값(0~1023)을 표시합니다. 각 채널의 전압·전류 모드는 실제 제품 설정을 따릅니다.
+<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>
+**관련 내장 명령어**
+=== 함수 예제 · 입력 범위 환산: IanalogRead(), IanalogReadf() ===
+**함수 원형**
+<code cpp>
+int32_t IanalogRead(uint8_t ch, int32_t min, int32_t max);
+float IanalogReadf(uint8_t ch, float min, float max);
+</code>
+A0를 0~5V 입력으로, A2를 0(4)~20mA 입력으로 설정한 경우의 예제입니다. 두 함수는 ADC 입력을 지정한 min~max 범위로 환산합니다. IanalogRead()는 소수부를 버린 정수, IanalogReadf()는 실수를 반환합니다. A0의 0~5V 입력을 0~100%와 전압으로 각각 표시합니다. A2의 0~20mA 입력은 0~20 범위를 지정하여 실제 전류로 읽습니다.
+<code cpp>
+void setup() {
+  Serial.begin(115200);
+}
+void loop() {
+  const int32_t percent = IanalogRead(A0, 0, 100);  // A0 입력을 0~100% 정수로 환산
+  const float voltage = IanalogReadf(A0, 0.0f, 5.0f);  // A0 입력을 0~5V 실수로 환산
+  const float current = IanalogReadf(A2, 0.0f, 20.0f);  // A2 입력을 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>
+=== 함수 예제 · 4~20mA 범위 환산: IanalogRead2(), IanalogRead2f() ===
+**함수 원형**
+<code cpp>
+int32_t IanalogRead2(uint8_t ch, int32_t min, int32_t max);
+float IanalogRead2f(uint8_t ch, float min, float max);
+</code>
+A0를 0~5V 입력으로, A2를 0(4)~20mA 입력으로 설정한 경우의 예제입니다. A2에 연결한 4~20mA 센서 입력을 사용자 범위로 환산합니다. IanalogRead2(A2, 0, 100)는 4mA를 0%, 20mA를 100%로 변환한 정수를 반환합니다. IanalogRead2f(A2, 4.0f, 20.0f)는 전류를 실수로 반환합니다. 약 3.6mA 미만은 두 함수 모두 ANALOG_READ2_ERROR(65535), 약 3.6~4mA는 지정한 최솟값을 반환합니다.
+<code cpp>
+void setup() {
+  Serial.begin(115200);
+}
+void loop() {
+  const int32_t percent = IanalogRead2(A2, 0, 100);  // A2의 4~20mA를 0~100% 정수로 환산
+  const float current = IanalogRead2f(A2, 4.0f, 20.0f);  // A2의 4~20mA를 전류 실수값으로 환산
+  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>
+=== 함수 예제 · 이동 평균: analogReadAvg(), analogRead2Avg() ===
+**함수 원형**
+<code cpp>
+int32_t analogReadAvg(uint8_t ch, uint8_t samples);
+int32_t analogRead2Avg(uint8_t ch, uint8_t samples);
+</code>
+A0를 0~5V 입력으로, A2를 0(4)~20mA 입력으로 설정한 경우의 예제입니다. analogReadAvg(A0, 5)는 A0의 ADC 원시값(0~1023)을, analogRead2Avg(A2, 5)는 A2의 4~20mA 보정값(4mA=0, 20mA=32767)을 이동 평균으로 반환합니다. 최근 호출에서 읽은 정상값을 최대 5개까지 누적해 평균하며, 한 번에 5회 읽는 함수가 아닙니다. samples는 최대 20입니다. analogRead2Avg()는 약 3.6mA 미만 입력에서 ANALOG_READ2_AVG_ERROR(-1)를 반환합니다.
+<code cpp>
+void setup() {
+  Serial.begin(115200);
+}
+void loop() {
+  const int32_t voltageAvg = analogReadAvg(A0, 5);  // 최근 A0 ADC 값 최대 5개의 이동평균
+  const int32_t currentAvg = analogRead2Avg(A2, 5);  // 최근 A2의 4~20mA 보정값 최대 5개의 이동평균
+  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>
+==== 예제 프로그램 · 온도센서 입력 ====
+analogRead()로 A4, A5의 온도센서 ADC 원시값(0~1023)을 표시합니다. 섭씨 환산은 아래 내장 명령어에서 설명합니다.
+<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>
+**관련 내장 명령어**
+=== 함수 예제 · NTC 온도 읽기: ntcRead(), ntcReadf() ===
+**함수 원형**
+<code cpp>
+int ntcRead(uint8_t ch);
+float ntcReadf(uint8_t ch);
+</code>
+NTC 입력 A4에 연결한 NTC 10kΩ(25℃), B=3950K 센서의 온도를 읽습니다. ntcRead()는 섭씨 온도의 10배 정수(25.3℃ → 253), ntcReadf()는 섭씨 실수(25.3)를 반환합니다. 두 함수의 분해능은 동일하게 0.1℃입니다. 변환 범위 밖 값은 -40℃ 또는 120℃로 제한되므로 단선·단락 판정값으로 사용하지 않습니다.
+<code cpp>
+void setup() {
+  Serial.begin(115200);
+}
+void loop() {
+  const int temperature10 = ntcRead(A4);  // A4 온도를 섭씨×10 정수로 반환
+  const float temperature = ntcReadf(A4);  // A4 온도를 섭씨 실수로 반환
+  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>
-아날로그 입력과 온도센서 입력을 사용할 때는 ''setup()''에서 ''analogReference(EXTERNAL)''을 설정합니다.
 ===== 아날로그 출력 =====
-^ 단자 ^ Arduino 핀 ^ 출력 범위 ^ 분해능 ^
+^ 단자 ^ Arduino 핀 ^ 출력 범위 ^ 분해능 ^ 커넥터 핀 배열 ^
-| AO(6), AO(7) | D6, D7 | DC 0~5V | 16bit (0~65535) |
+| AO(6), AO(7) | D6, D7 | DC 0~5V | 16bit (0~65535) |  {{:products:mpino-16a8r8t-analog-output.svg?260|MPINO-16A8R8T 아날로그 출력 단자대 핀 배열}}  |
 아날로그 출력은 TIMER4를 사용합니다. TCNT4 고속카운터 입력도 TIMER4를 사용하므로 두 기능은 동시에 사용할 수 없습니다.
+==== 예제 프로그램 · 아날로그 출력 ====
+analogWrite()의 기본 8비트 값 128로 AO(6)·AO(7)에 약 2.5V를 출력합니다. 16비트 전압 환산은 아래 내장 명령어를 사용합니다. 외부 12~24V 전원이 필요하며 Timer4 고속카운터와 동시에 사용하지 않습니다.
+<code cpp>
+void setup() {
+  analogWrite(6, 128);
+  analogWrite(7, 128);
+}
+void loop() {
+}
+</code>
+**관련 내장 명령어**
+=== 함수 예제 · 출력 범위 환산: IanalogWrite(), IanalogWritef() ===
+**함수 원형**
+<code cpp>
+void analogWriteInit(uint8_t ch, uint16_t top = 65535, uint16_t prescaler = 1);
+void IanalogWrite(uint8_t ch, int32_t min, int32_t max, int32_t value);
+void IanalogWritef(uint8_t ch, float min, float max, float value);
+</code>
+AO(6)에는 0~5000mV 범위의 2500을, AO(7)에는 0~5V 범위의 2.5를 지정해 약 2.5V를 출력합니다. analogWriteInit(6)으로 두 채널이 공유하는 Timer4를 16비트 TOP=65535로 먼저 설정합니다. 두 채널은 Timer4를 공유하며 TCNT4와 동시에 사용하지 않습니다.
+<code cpp>
+void setup() {
+  analogWriteInit(6);  // AO(6)·AO(7)의 Timer4를 16비트로 설정
+  IanalogWrite(6, 0, 5000, 2500);  // AO(6)에 2500mV 상당의 16비트 출력
+  IanalogWritef(7, 0.0f, 5.0f, 2.5f);  // AO(7)에 2.5V 상당의 16비트 출력
+}
+void loop() {
+}
+</code>
 ===== 고속카운터ㆍ인터럽트ㆍ엔코더 =====
 ^ 기능 ^ 단자·Arduino 핀 ^ 채널 ^
 | 절연 고속카운터 | TCNT4(D74), TCNT5(D47), COM2 | 2점, 최대 5kHz |
 | 외부 인터럽트 | P(2)(D2), SCL(D21), SDA(D20) | 3점 |
@@ 줄 76: / 줄 445: @@
 SDA와 SCL을 엔코더 입력이나 외부 인터럽트로 사용하면 I²C 통신을 동시에 사용할 수 없습니다. P(2)는 펄스 출력과 외부 인터럽트 기능을 공유합니다.
+==== 예제 프로그램 · 펄스 카운트 ====
+TCNT4·TCNT5 절연 입력을 타이머 외부 클럭으로 계수합니다. MCU 타이머 입력의 상승 에지를 사용하며, 값은 0~65535 이후 0으로 순환합니다. 원자적으로 읽어 500ms마다 표시합니다. Timer4를 사용하므로 AO(6)·AO(7)과 동시에 실행하지 않습니다.
+<code cpp>
+#include <util/atomic.h>
+void setup() {
+  Serial.begin(115200);
+  TIMSK4 = 0;
+  TCCR4A = 0;
+  TCCR4B = 0x07;
+  TCNT4 = 0;
+  TIMSK5 = 0;
+  TCCR5A = 0;
+  TCCR5B = 0x07;
+  TCNT5 = 0;
+}
+void loop() {
+  uint16_t first, second;
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+    first = TCNT4;
+    second = TCNT5;
+  }
+  Serial.print(F("TCNT4: "));
+  Serial.print(first);
+  Serial.print(F(", TCNT5: "));
+  Serial.println(second);
+  delay(500);
+}
+</code>
+SDA(D20)의 FALLING 에지를 계수합니다. 입력은 4.7kΩ 풀업 (SDA/SCL)입니다. 32비트 값을 ATOMIC_BLOCK으로 읽어 500ms마다 표시하는 소프트웨어 인터럽트 예제입니다. 최대 입력 주파수에서 무손실을 보장하지 않습니다. SDA·SCL을 사용하므로 I²C 통신과 동시에 실행하지 않습니다.
+<code cpp>
+static_assert(digitalPinToInterrupt(SDA) != NOT_AN_INTERRUPT, "Invalid interrupt input");
+#include <util/atomic.h>
+volatile uint32_t pulseCount = 0;
+void countPulse() {
+  pulseCount++;
+}
+void setup() {
+  Serial.begin(115200);
+  // SDA는 풀업 상태이며, 외부 신호가 GND로 당길 때 계수
+  attachInterrupt(digitalPinToInterrupt(SDA), countPulse, FALLING);
+}
+void loop() {
+  uint32_t snapshot;
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+    snapshot = pulseCount;
+  }
+  Serial.print(F("SDA pulses: "));
+  Serial.println(snapshot);
+  delay(500);
+}
+</code>
+**관련 내장 명령어**
+=== 함수 예제 · 하드웨어 펄스 카운터 설정: TCNTSETUP() ===
+**함수 원형**
+<code cpp>
+void TCNTSETUP(uint8_t timerNumber, bool on32bit = false);
+</code>
+TCNTSETUP(timerNumber, false)로 Timer4·Timer5를 16비트 외부 클럭 카운터로 설정합니다. 누적값은 TCNT4·TCNT5 레지스터에서 읽습니다. TCNTOUT()은 누적 펄스값이 아니라 32비트 모드의 오버플로 횟수를 반환하므로 이 16비트 예제에서는 사용하지 않습니다. Timer4와 AO 출력은 동시 사용하지 않습니다.
+<code cpp>
+#include <util/atomic.h>
+void setup() {
+  Serial.begin(115200);
+  TCNTSETUP(4, false);  // Timer4를 16비트 외부 펄스 카운터로 설정
+  TCNTSETUP(5, false);  // Timer5를 16비트 외부 펄스 카운터로 설정
+}
+void loop() {
+  uint16_t first, second;
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+    first = TCNT4;
+    second = TCNT5;
+  }
+  Serial.print(F("TCNT4: "));
+  Serial.print(first);
+  Serial.print(F(", TCNT5: "));
+  Serial.println(second);
+  delay(500);
+}
+</code>
+==== 예제 프로그램 · 엔코더 입력 ====
+A상은 SDA(D20), B상은 SCL(D21)에 연결합니다. 4.7kΩ 풀업 (SDA/SCL)이며 FALLING 에지에서 B상이 LOW이면 증가하는 1배 계수 예제입니다. 실제 회전 방향은 A·B상 결선에 따라 달라집니다. SDA·SCL을 사용하므로 I²C 통신과 동시에 실행하지 않습니다.
+<code cpp>
+static_assert(digitalPinToInterrupt(SDA) != NOT_AN_INTERRUPT, "Invalid interrupt input");
+#include <util/atomic.h>
+#include <stdint.h>
+volatile int32_t position = 0;
+void readEncoder() {
+  // A상 하강 시 B상이 LOW이면 증가 (1배 카운트)
+  if (digitalRead(SCL) == LOW) {
+    if (position < INT32_MAX) position++;
+  } else {
+    if (position > INT32_MIN) position--;
+  }
+}
+void setup() {
+  Serial.begin(115200);
+  // 엔코더 A상 → SDA(D20), B상 → SCL(D21)
+  attachInterrupt(digitalPinToInterrupt(SDA), readEncoder, FALLING);
+}
+void loop() {
+  int32_t snapshot;
+  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+    snapshot = position;
+  }
+  Serial.print(F("Encoder: "));
+  Serial.println(snapshot);
+  delay(500);
+}
+</code>
 ===== 펄스 출력 =====
-^ 단자 ^ Arduino 핀 ^ 타이머 ^
+^ 단자 ^ Arduino 핀 ^ 타이머 ^ 커넥터 핀 배열 ^
-| P(11), P(12) | D11, D12 | TIMER1 |
+| P(11), P(12) | D11, D12 | TIMER1 |  {{:products:mpino-16a8r8t-pwm-output.svg?400|MPINO-16A8R8T 펄스 출력 커넥터 핀 배열}}  |
-| P(5), P(2) | D5, D2 | TIMER3 |
+| P(5), P(2) | D5, D2 | TIMER3 | ::: |
 펄스 출력은 기본 8bit 듀티를 사용하며 출력 전압은 DC 0~5V입니다. 타이머 레지스터를 설정하면 16bit 듀티를 사용할 수 있습니다.
+==== 예제 프로그램 · PWM 출력 ====
+analogWrite()의 0~255 듀티값 중 128을 D11, D12, D5, D2에 지정해 약 50% PWM을 출력합니다.
+<code cpp>
+void setup() {
+  analogWrite(11, 128);
+  analogWrite(12, 128);
+  analogWrite(5, 128);
+  analogWrite(2, 128);
+}
+void loop() {
+}
+</code>
+**관련 내장 명령어**
+=== 함수 예제 · 듀티값 지정: PWM() ===
+**함수 원형**
+<code cpp>
+void PWM(uint8_t pin, uint16_t val, bool onDutybit16 = false);
+</code>
+PWM(pin, val, onDutybit16)은 듀티값을 지정합니다. 8비트는 0~255, 세 번째 인수가 true인 16비트는 0~65535입니다. D11에 16비트 중간값 32768을 출력합니다. D11·D12는 Timer1, D5·D2는 Timer3를 공유하므로 같은 타이머는 같은 분해능으로 사용합니다. PWM_RESET() 후 시작합니다.
+<code cpp>
+void setup() {
+  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화
+  PWM(11, 32768, true);  // D11에 16비트 중간 듀티값 출력
+}
+void loop() {
+}
+</code>
+=== 함수 예제 · 주파수·듀티 설정: FDPWM() ===
+**함수 원형**
+<code cpp>
+void FDPWM(uint8_t pin, int32_t intHz, float Duty);
+</code>
+FDPWM(pin, intHz, Duty)는 주파수(Hz)와 듀티(%)를 지정합니다. D11에 1kHz, 50%를 출력합니다. D11·D12는 Timer1, D5·D2는 Timer3를 공유하므로 같은 타이머의 출력은 같은 주파수를 지정합니다. 별도 FPWM() 함수는 없으며 50% 출력은 FDPWM(pin, hz, 50.0f)로 설정합니다.
+<code cpp>
+void setup() {
+  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화
+  FDPWM(11, 1000, 50.0f);  // D11에 1kHz, 50% 듀티 출력
+}
+void loop() {
+}
+</code>
+=== 함수 예제 · 지정 개수 펄스 출력: NPWM_BEGIN(), NPWM() ===
+**함수 원형**
+<code cpp>
+void NPWM_BEGIN(uint8_t pin, uint32_t intHz, float Duty, uint32_t N);
+void NPWM(uint8_t pin);
+</code>
+NPWM_BEGIN()으로 D11의 1kHz·50% 펄스 100개를 준비하고 NPWM()을 loop()마다 실행해 출력 및 완료 처리를 합니다. delay()를 넣지 않습니다. D11·D12는 Timer1, D5·D2는 Timer3를 공유하며, 같은 타이머의 다른 출력과 혼합하지 않습니다.
+<code cpp>
+void setup() {
+  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화
+  NPWM_BEGIN(11, 1000, 50.0f, 100);  // D11에 1kHz, 50% 펄스 100개 준비
+}
+void loop() {
+  NPWM(11);  // 준비한 펄스 출력 진행 및 완료 처리
+}
+</code>
+=== 함수 예제 · 채널 출력 정지·재개: PWMOFF() ===
+**함수 원형**
+<code cpp>
+void PWMOFF(uint8_t pin, bool POff);
+</code>
+PWMOFF(pin, true)는 채널 정지 플래그를 설정하고 false는 해제합니다. 설정 직후 FDPWM()을 호출해 출력 연결에 반영합니다. D11을 2초 켜고 2초 끄며, 정지 후 digitalWrite()로 LOW를 유지합니다. NPWM()에는 이 정지 플래그가 적용되지 않습니다.
+<code cpp>
+void setup() {
+  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화
+}
+void loop() {
+  PWMOFF(11, false);  // D11 정지 상태 해제
+  FDPWM(11, 1000, 50.0f);  // 해제를 반영해 1kHz, 50% 출력 시작
+  delay(2000);
+  PWMOFF(11, true);  // D11 정지 상태 설정
+  FDPWM(11, 1000, 50.0f);  // 정지를 반영해 PWM 출력 연결 해제
+  digitalWrite(11, LOW);
+  delay(2000);
+}
+</code>
+=== 함수 예제 · PWM 타이머 정지·초기화: PWM_RESET() ===
+**함수 원형**
+<code cpp>
+void PWM_RESET();
+</code>
+PWM_RESET()은 Timer1·Timer3·Timer4·Timer5 제어 레지스터와 카운터를 초기화합니다. D11에 1kHz를 2초 출력한 후 전체 타이머를 정지합니다. 같은 타이머의 PWM·카운터·아날로그 출력에도 영향을 줍니다. PWMOFF()의 정지 플래그까지 해제하지는 않습니다.
+<code cpp>
+void setup() {
+  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화
+  FDPWM(11, 1000, 50.0f);  // D11에 1kHz, 50% 듀티 출력
+  delay(2000);
+  PWM_RESET();  // Timer1·Timer3·Timer4·Timer5의 모든 PWM 정지 및 초기화
+  digitalWrite(11, LOW);
+}
+void loop() {
+}
+</code>
 ===== 통신과 다운로드 =====
-^ 기능 ^ Arduino 핀 ^ 사용 객체 ^
+^ 기능 ^ Arduino 핀 ^ 사용 객체 ^ 상대 기기 결선 ^
-| USB 다운로드·모니터링 | D0(RX0), D1(TX0) | ''Serial'' |
+| USB 다운로드·모니터링 | D0(RX0), D1(TX0) | ''Serial'' |  {{:products:mpino-16a8r8t-communication.svg?780|MPINO-16A8R8T 통신 커넥터와 상대 기기 결선}}  |
-| RS-232 | D19(RX1), D18(TX1) | ''Serial1'' |
+| RS-232 | D19(RX1), D18(TX1) | ''Serial1'' | ::: |
-| RS-485 | D17(RX2), D16(TX2) | ''Serial2'' |
+| RS-485 | D17(RX2), D16(TX2) | ''Serial2'' | ::: |
-| UART | D15(RX3), D14(TX3) | ''Serial3'' |
+| UART | D15(RX3), D14(TX3) | ''Serial3'' | ::: |
-| I²C | D20(SDA), D21(SCL) | ''Wire'' |
+| I²C | D20(SDA), D21(SCL) | ''Wire'' | ::: |
 RS-485는 자동 방향제어 방식이므로 송수신 방향을 전환하는 별도의 제어 핀이 필요하지 않습니다.
-===== 기본 입출력 예제 =====
+==== 예제 프로그램 · 기본 통신 ====
-아래 예제는 I(22) 입력이 ON되면 R(62) 릴레이를 동작시킵니다.
+Serial(115200bps)과 RS-232 Serial1(9600bps, 8-N-1) 사이에 문자를 전달합니다. availableForWrite()로 송신 버퍼 여유를 확인합니다. Serial2는 RS-485, Serial3는 TTL UART이며 해당 단자 사용 시 예제의 Serial1을 해당 객체로 바꿉니다.
 <code cpp>
+// MP 다운로드 케이블의 Serial 모니터 ↔ RS-232 Serial1
 void setup() {
-  pinMode(62, OUTPUT);
+  Serial.begin(115200);
-  digitalWrite(62, LOW);
+  Serial1.begin(9600);  // 상대 기기도 9600 bps, 8-N-1 설정
 }
 void loop() {
-  digitalWrite(62, digitalRead(22));
+  if (Serial.available() && Serial1.availableForWrite()) {
+    Serial1.write(Serial.read());
+  }
+  if (Serial1.available() && Serial.availableForWrite()) {
+    Serial.write(Serial1.read());
+  }
+}
+</code>
+==== 예제 프로그램 · I²C 통신 ====
+Wire로 주소 0x08~0x77을 검색하고 응답한 주소를 3초마다 표시합니다. 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>
+==== 예제 프로그램 · Modbus RTU 통신 ====
+**관련 내장 명령어**
+=== 함수 예제 · Modbus RTU Slave: ImodbusRTUMem(), ImodbusRTUAdr(), ImodbusRTUInit(), ImodbusRTU() ===
+**함수 원형**
+<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>
+D22 상태를 M[0], A0 원시값(0~1023)을 D[0]에 넣어 상대 기기에서 읽습니다. RS-232(Serial1), 국번 1, 9600bps, 8N1로 설정하고, M[0]은 FC01·시작 주소 0·1비트, D[0]은 FC03·시작 주소 0·1워드로 읽습니다. 주소는 실제 전송 주소(0부터) 기준입니다. 통신 함수는 loop()마다 호출하며 출력은 제어하지 않습니다.
+M과 D는 코어가 제공하는 공유 전역 메모리입니다. 이 스케치는 단독 실행하며, 다른 프로토콜과 함께 사용할 때는 메모리를 중복 할당하지 않습니다. RS-485 단자에 연결할 때는 Serial1을 Serial2로 바꾸며, UART 단자는 Serial3를 사용합니다.
+<code cpp>
+unsigned long lastPrint = 0;
+bool memoryReady = false;
+void setup() {
+  Serial.begin(115200);
+  ImodbusRTUMem(8, 8);  // M 8비트와 D 8워드 메모리 할당
+  ImodbusRTUAdr(0, 0);  // M과 D의 통신 시작 주소를 0으로 설정
+  ImodbusRTUInit(Serial1, 1, 9600);  // RS-232를 국번 1, 9600bps로 시작
+  memoryReady = (M != nullptr && D != nullptr);
+  if (!memoryReady) Serial.println(F("Memory allocation failed"));
+}
+void loop() {
+  if (!memoryReady) return;
+  M[0] = digitalRead(22);
+  D[0] = analogRead(A0);
+  ImodbusRTU();  // 수신한 Modbus RTU 요청 처리
+  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>
+=== 함수 예제 · Modbus RTU Master: ImodbusRTUmasterInit(), ImodbusRTUmaster() ===
+**함수 원형**
+<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>
+RS-232(Serial1)로 상대 슬레이브의 홀딩 레지스터 1개를 1초마다 읽습니다. 상대 기기는 국번 1, 9600bps, 8N1, FC03·실제 시작 주소 0으로 준비합니다. 응답은 received[0]에 저장하며 성공한 경우에만 표시합니다. 오류 코드는 16진수로 표시합니다. 위 슬레이브 예제와는 별도 스케치이며, M/D 메모리 대신 수신 배열을 사용합니다. RS-485 단자에 연결할 때는 Serial1을 Serial2로 바꾸며, UART 단자는 Serial3를 사용합니다.
+<code cpp>
+unsigned long lastRequest = 0;
+uint16_t received[1];
+void setup() {
+  Serial.begin(115200);
+  ImodbusRTUmasterInit(Serial1, 9600, SERIAL_8N1);  // RS-232를 Modbus 마스터로 시작
+}
+void loop() {
+  if (millis() - lastRequest < 1000) return;
+  lastRequest = millis();
+  const uint8_t result = ImodbusRTUmaster(Serial1, 1, 3, 0, 1, received, 200);  // 국번 1의 주소 0에서 1워드 읽기, 제한 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>
+==== 예제 프로그램 · LS산전 Cnet 통신 ====
+**관련 내장 명령어**
+=== 함수 예제 · LS산전 Cnet SLave: ICnetMem(), ICnetAdr(), ICnetInit(), ICnet() ===
+**함수 원형**
+<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>
+D22 상태를 M[0], A0 원시값(0~1023)을 D[0]에 넣어 HMI에서 읽습니다. 상대 기기는 LS산전 Cnet, RS-232, 국번 1, 9600bps, 8N1로 설정합니다. 비트는 %MX00000(M[0]), 워드는 %DW0(D[0])을 읽습니다. 통신 함수는 loop()마다 호출하며 출력은 제어하지 않습니다.
+M·D·R은 코어가 제공하는 공유 전역 메모리이며, 이 예제는 R을 사용하지 않습니다. Modbus 예제와는 단독 실행하며, 다른 프로토콜과 함께 사용할 때는 메모리를 중복 할당하지 않습니다. RS-485 단자에 연결할 때는 Serial1을 Serial2로 바꾸며, UART 단자는 Serial3를 사용합니다.
+<code cpp>
+unsigned long lastPrint = 0;
+bool memoryReady = false;
+void setup() {
+  Serial.begin(115200);
+  ICnetMem(8, 8, 0);  // M 8비트와 D 8워드 할당, R은 사용하지 않음
+  ICnetAdr(0, 0, 0);  // M과 D의 통신 시작 주소를 0으로 설정
+  ICnetInit(Serial1, 1, 9600);  // RS-232를 국번 1, 9600bps로 시작
+  memoryReady = (M != nullptr && D != nullptr);
+  if (!memoryReady) Serial.println(F("Memory allocation failed"));
+}
+void loop() {
+  if (!memoryReady) return;
+  M[0] = digitalRead(22);
+  D[0] = analogRead(A0);
+  ICnet();  // 수신한 LS Cnet 요청 처리
+  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>