ILOGICS 제품 사용설명서

사용자 도구

사이트 도구

추적: • box_functions • mpino_studio2 • memory • mpaino • mpino_studio2
products:mpino_8a4t_s

차이

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

차이 보기로 링크

양쪽 이전 판이전 판
다음 판		이전 판
products:mpino_8a4t_s [2026/09/07 16:19] – 바깥 편집 127.0.0.1products:mpino_8a4t_s [2026/09/15 17:45] (현재) – 바깥 편집 127.0.0.1
줄 4: 줄 4:
  
 Arduino IDE(Arduino C/C++) 또는 MPINO STUDIO 2(Arduino C/C++ & 래더로직)로 프로그램할 수 있습니다. Arduino IDE(Arduino C/C++) 또는 MPINO STUDIO 2(Arduino C/C++ & 래더로직)로 프로그램할 수 있습니다.
 +
 +[[:products:mpino_series#mpino_series_사양표|MPINO Series 사양표]]에서 MPINO-8A4T-S의 보드 이름, 연결 방법과 첫 입출력 번호를 확인할 수 있습니다.
 +
 +
 +
 +
  
 {{ :products:mpino-8a4t-s-connectors.svg?nolink |MPINO-8A4T-S 커넥터 안내 }} {{ :products:mpino-8a4t-s-connectors.svg?nolink |MPINO-8A4T-S 커넥터 안내 }}
줄 24: 줄 30:
 | ::: | ::: |  SRAM  | 4KB  | | ::: | ::: |  SRAM  | 4KB  |
 | ::: | ::: |  EEPROM  | 4KB  | | ::: | ::: |  EEPROM  | 4KB  |
 +
 +**Markdown 자료:** [[https://www.ilogics.net/docs/downloads:mpino:ko:mpino_8a4t_s?do=export_raw|MPINO-8A4T-S.md 다운로드]]
 +
  
 ===== 디지털 입력 ===== ===== 디지털 입력 =====
  
 +[[:guide:wiring#디지털_입력_한_채널_확인|처음 결선할 때는 디지털 입력 한 채널 확인 순서를 함께 보십시오. →]]
 ^ 단자 ^ Arduino 핀 ^ 입력 구성 ^ 단자대 및 결선 예시 ^ ^ 단자 ^ Arduino 핀 ^ 입력 구성 ^ 단자대 및 결선 예시 ^
 | P0~P3 | D0~D3 | 디지털 입력 4점, COM0 공유 |  {{:products:mpino-8a4t-s-digital-input.svg?740|MPINO-8A4T-S 디지털 입력 단자대와 NPN·PNP 결선}}  | | P0~P3 | D0~D3 | 디지털 입력 4점, COM0 공유 |  {{:products:mpino-8a4t-s-digital-input.svg?740|MPINO-8A4T-S 디지털 입력 단자대와 NPN·PNP 결선}}  |
줄 35: 줄 45:
 ==== 예제 프로그램 · 디지털 입력 ==== ==== 예제 프로그램 · 디지털 입력 ====
  
-Arduino IDE에서 보드를 **MPINO-8A4R(T)-S**로 선택합니다. 아래 코드는 각각 별도 스케치로 실행합니다. +digitalRead()로 P0~P7의 입력 상태를 읽어 200ms마다 시리얼 모니터에 표시합니다. HIGH는 1, LOW는 0으로 표시됩니다.
- +
-**기본 예제** +
- +
-**P0~P7 입력 상태 읽기** +
- +
-IdigitalRead(pin, 5)로 입력을 5회 연속 판독하고 200ms마다 P0~P7 상태를 시리얼 모니터에 표시합니다. 5회 값이 모두 같으면 상태를 갱신하고, 섞여 있으면 이전 상태를 유지합니다. NPN·PNP에 맞는 COM0·COM1 결선은 위 그림을 따릅니다.+
  
 <code cpp> <code cpp>
줄 54: 줄 58:
     Serial.print(pin);     Serial.print(pin);
     Serial.print('=');     Serial.print('=');
-    Serial.print(IdigitalRead(pin, 5));  // 5회 판독이 일치하면 상태 갱신+    Serial.print(digitalRead(pin));
     Serial.print(' ');     Serial.print(' ');
   }   }
줄 62: 줄 66:
 </code> </code>
  
-**관련 내장함수 · 기본 함수**+**관련 내장 명령어**
  
-함수 이름을 누르면 설명과 독립 실행 예제가 펼쳐집니다.+=== 함수 예제 · 연속 판독 필터: IdigitalRead() ===
  
-=== 함수 예제 · IdigitalRead() ===+**함수 원형**
  
-ILOGICS 내장 함수: IdigitalRead(pin, samples)는 입력 핀을 지정 횟수만큼 연속 판독하여 bool 값을 반환합니다. 이 예제는 P0을 5회 읽으며, 모두 HIGH 또는 모두 LOW이면 상태를 갱신하고 섞여 있으면 이전 상태를 유지합니다. 판독 사이에 시간 지연을 넣는 방식은 아닙니다.+<code cpp> 
 +bool IdigitalRead(uint8_t pin, uint8_t samples); 
 +</code> 
 + 
 +IdigitalRead(0, 5)는 P0을 5회 연속 판독합니다. 모두 HIGH 또는 모두 LOW일 때 상태를 갱신하고, 값이 섞이면 이전 상태를 유지합니다. 시간 기준의 채터링 필터와 달리 판독 사이에 지연을 넣지 않습니다.
  
 <code cpp> <code cpp>
줄 76: 줄 84:
  
 void loop() { void loop() {
-  const bool inputOn = IdigitalRead(0, 5);+  const bool inputOn = IdigitalRead(0, 5);  // P0을 5회 연속 판독해 안정된 상태 반환
   Serial.println(inputOn ? F("P0 ON") : F("P0 OFF"));   Serial.println(inputOn ? F("P0 ON") : F("P0 OFF"));
   delay(200);   delay(200);
줄 82: 줄 90:
 </code> </code>
  
 +=== 함수 예제 · 채터링 방지: Ibounce(), IbounceOn(), IbounceOff() ===
  
-===== 트랜지스터 출력 =====+**함수 원형**
  
-^ 단자 ^ Arduino 핀 ^ 출력 방식 ^ 최대 정격 ^ 단자대 및 결선 예시 ^ +<code cpp> 
-| P32 | D32 | SINK 출력 | DC 100V, 1A/1점 |  {{:products:mpino-8a4t-s-transistor-output.svg?698|MPINO-8A4T-S 트랜지스터 출력 단자대와 SINK 결선}}  | +bool Ibounce(uint8_t pin, uint32_t debounceTime); 
-| P33 | D33 | SINK 출력 | DC 100V, 1A/1점 | ::: | +bool IbounceOn(uint8_t pin, uint32_t debounceTime); 
-| P34 | D34 | SINK 출력 | DC 100V, 1A/1점 | ::: | +bool IbounceOff(uint8_t pin, uint32_t debounceTime); 
-| P35 | D35 | SINK 출력 | DC 100V, 1A/1점 | ::: |+</code>
  
-트랜지스터 출력은 ON될 때 출력 단자가 V-와 연결되는 SINK 방식입니다. V+와 V- 단자에는 제어할 부하의 외부 DC 전원을 연결합니다.+P0 입력을 세 가지 필터로 비교합니다. 반환값은 필터 처리된 ON/OFF 상태입니다.
  
-==== 예제 프로그램 · 트랜지스터 출력 ====+  * ''Ibounce(0, 30)'': ON과 OFF 모두 30ms 이상 안정된 뒤 반영합니다. 
 +  * ''IbounceOn(0, 500)'': ON만 500ms 지연하고 OFF는 즉시 반영합니다. 
 +  * ''IbounceOff(0, 500)'': OFF만 500ms 지연하고 ON은 즉시 반영합니다.
  
-Arduino IDE에서 보드를 **MPINO-8A4R(T)-S**로 선택합니다. 아래 코드는 각각 별도 스케치로 실행합니다.+각 함수는 같은 핀에서도 독립적으로 동작합니다. 필터를 loop()마다 실행하고 결과만 200ms 간격으로 표시합니다.
  
-**기본 예제**+<code cpp> 
 +unsigned long lastPrint = 0; 
 + 
 +void setup() { 
 +  Serial.begin(115200); 
 +} 
 + 
 +void loop() { 
 +  const bool stable = Ibounce(0, 30);  // P0의 ON/OFF 채터링을 30ms로 필터링 
 +  const bool onDelayed = IbounceOn(0, 500);  // P0의 ON만 500ms 지연, OFF는 즉시 반영 
 +  const bool offDelayed = IbounceOff(0, 500);  // P0의 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>
  
-**P0~P3 입력으로 P32~P35 출력 제어**+=== 함수 예제 · 입력 토글: Ialt() ===
  
-IdigitalRead(channel, 5)로 읽은 입력을 P0→P32, P1→P33, P2→P34, P3→P35로 대응시킵니다. 5회 연속 판독이 일치하면 상태를 갱신합니다. HIGH일 때 출력이 V-와 연결됩니다. 부하의 다른 쪽은 V+에 연결하고, 부하 전원은 출력을 OFF한 상태에서 공급합니다.+**함수 원형**
  
 <code cpp> <code cpp>
-// MPINO-8A4T-S: P0~P3 입력으로 P32~P35 SINK 출력을 제어합니다.+void Ialt(bool input, bool &state_var); 
 +</code> 
 + 
 +Ialt(input, state)는 입력이 OFF에서 ON으로 바뀔 때마다 state를 반전합니다. P0을 한 번 누르면 P32가 ON, 다시 누르면 OFF가 되며 누르고 있는 동안은 유지됩니다. 예제는 Ibounce(0, 30)로 채터링을 걸러 Ialt()에 전달합니다. outputOn은 호출 사이에 유지되는 전역 변수이며, Ialt()가 이 값을 직접 변경합니다. 
 + 
 +<code cpp> 
 +bool outputOn = false; 
 void setup() { void setup() {
-  for (uint8_t channel = 0; channel < 4; channel++) { +  Serial.begin(115200); 
-    digitalWrite(32 + channel, LOW);  // 출력을 OFF로 시작 +  digitalWrite(32, LOW);
-  }+
 } }
  
 void loop() { void loop() {
-  for (uint8_t channel = 0; channel < 4; channel++) { +  const bool previous = outputOn; 
-    digitalWrite(32 + channel, IdigitalRead(channel, 5));+  const bool inputOn = Ibounce(0, 30);  // P0의 ON/OFF 채터링을 30ms로 필터링 
 +  Ialt(inputOn, outputOn);  // 입력이 OFF→ON일 때 outputOn 반전 
 +  digitalWrite(32, outputOn ? HIGH : LOW); 
 + 
 +  if (outputOn != previous) { 
 +    Serial.println(outputOn ? F("P32 ON") : F("P32 OFF"));
   }   }
 } }
 </code> </code>
  
-**관련 내장함수 · 기본 함수** 
  
-함수 이름을 누르면 설명과 독립 실행 예제가 펼쳐집니다.+===== 트랜지스터 출력 =====
  
-=== 함수 예제 · digitalWrite() ===+[[:guide:wiring#sink_트랜지스터_출력_한_채널_확인|처음 결선할 때는 SINK 트랜지스터 출력 한 채널 확인 순서를 함께 보십시오. →]] 
 +^ 단자 ^ Arduino 핀 ^ 출력 방식 ^ 최대 정격 ^ 단자대 및 결선 예시 ^ 
 +| P32 | D32 | SINK 출력 | DC 100V, 1A/1점 |  {{:products:mpino-8a4t-s-transistor-output.svg?698|MPINO-8A4T-S 트랜지스터 출력 단자대와 SINK 결선}}  | 
 +| P33 | D33 | SINK 출력 | DC 100V, 1A/1점 | ::: | 
 +| P34 | D34 | SINK 출력 | DC 100V, 1A/1점 | ::: | 
 +| P35 | D35 | SINK 출력 | DC 100V, 1A/1점 | ::: |
  
-Arduino 기본 함수: digitalWrite(pin, value)는 지정 출력 핀에 HIGH 또는 LOW를 쓰며 반환값이 없습니다. MPINO-8A4T-S의 P32~P35는 HIGH일 때 부하의 출력 단자를 V-에 연결합니다. 예제는 P0 입력으로 P32를 제어합니다. 부하의 다른 쪽은 V+에 연결하며, 부하 전원은 출력이 OFF인 상태에서 공급합니다.+트랜지스터 출력은 ON될 때 출력 단자가 V-와 연결되는 SINK 방식입니다. V+와 V- 단자에는 제어할 부하의 외부 DC 전원을 연결합니다. 
 + 
 +==== 예제 프로그램 · 트랜지스터 출력 ==== 
 + 
 +digitalRead()로 읽은 P0~P3 상태를 digitalWrite()로 P32~P35에 출력합니다. P0→P32, P1→P33, P2→P34, P3→P35 순서로 대응하며, 입력이 HIGH이면 해당 출력이 ON됩니다.
  
 <code cpp> <code cpp>
 +// MPINO-8A4T-S: P0~P3 입력으로 P32~P35 SINK 출력을 제어합니다.
 void setup() { void setup() {
-  digitalWrite(32, LOW);+  for (uint8_t channel = 0; channel < 4; channel++) { 
 +    digitalWrite(32 + channel, LOW);  // 출력을 OFF로 시작 
 +  }
 } }
  
 void loop() { void loop() {
-  const bool inputOn = IdigitalRead(0, 5); +  for (uint8_t channel = 0; channel < 4; channel++) { 
-  digitalWrite(32, inputOn ? HIGH : LOW); +    digitalWrite(32 + channel, digitalRead(channel)); 
-  delay(10);+  }
 } }
 </code> </code>
줄 147: 줄 202:
 | A6, A7 | NTC 온도센서 입력 | NTC 10kΩ, 3950K | ::: | | A6, A7 | NTC 온도센서 입력 | NTC 10kΩ, 3950K | ::: |
  
 +==== 예제 프로그램 · 아날로그 입력 ====
  
-==== 예제 프로그램 · 아날로그 입력ㆍ온도센서 입력 ==== +analogRead()로 A0~A5의 ADC 원시값(0~1023)을 읽어 시리얼 모니터에 표시합니다. 전압·전류 환산과 평균 처리는 아래 내장 명령어 예제에서 설명합니다.
- +
-Arduino IDE에서 보드를 **MPINO-8A4R(T)-S**로 선택합니다. 아래 코드는 각각 별도 스케치로 실행합니다. +
- +
-**기본 예제** +
- +
-**전압·전류와 NTC 온도 읽기** +
- +
-IanalogReadf()로 A0·A1은 V(0~5V), A2·A3은 mA(0~20mA), A4·A5는 V(0~10V)를 표시하고, ntcReadf()로 A6·A7의 섭씨 온도를 읽습니다. 4~20mA 입력도 실제 전류값을 읽으므로 환산 범위는 0~20mA를 사용합니다. NTC 10kΩ(25℃), B=3950K를 A6 또는 A7과 GND 사이에 연결합니다. ntcReadf()는 범위 밖 값을 -40~120℃의 끝값으로 제한하므로 센서 단선·단락을 별도로 판정하지 않습니다. 정밀 측정에는 외부 DC 전원을 사용합니다.+
  
 <code cpp> <code cpp>
줄 164: 줄 212:
  
 void loop() { void loop() {
-  const uint8_t pins[] = {A0, A1, A2, A3, A4, A5, A6, A7}; +  const uint8_t pins[] = {A0, A1, A2, A3, A4, A5}; 
-  for (uint8_t channel = 0; channel < 8; channel++) {+  for (uint8_t channel = 0; channel < 6; channel++) {
     Serial.print('A');     Serial.print('A');
     Serial.print(channel);     Serial.print(channel);
     Serial.print(F(": "));     Serial.print(F(": "));
-    if (channel < 2) { +    Serial.println(analogRead(pins[channel]));
-      Serial.print(IanalogReadf(pins[channel], 0.0f, 5.0f), 3); +
-      Serial.println(F(" V")); +
-    } else if (channel < 4) { +
-      Serial.print(IanalogReadf(pins[channel], 0.0f, 20.0f), 3); +
-      Serial.println(F(" mA")); +
-    } else if (channel < 6) { +
-      Serial.print(IanalogReadf(pins[channel], 0.0f, 10.0f), 3); +
-      Serial.println(F(" V")); +
-    } else { +
-      Serial.print(ntcReadf(pins[channel]), 1); +
-      Serial.println(F(" C")); +
-    }+
   }   }
   Serial.println();   Serial.println();
줄 188: 줄 224:
 </code> </code>
  
-**관련 내장함수 · 기본 함수**+**관련 내장 명령어**
  
-함수 이름을 누르면 설명과 독립 실행 예제가 펼쳐집니다.+=== 함수 예제 · 입력 범위 환산: IanalogRead(), IanalogReadf() ===
  
-=== 함수 예제 · 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>
  
-ILOGICS 내장 함수: IanalogReadf(ch, min, max)는 ADC 입력을 min~max 범위의 float 값으로 환산합니다. 이 제품의 A0·A1은 0~5V, A2·A3은 0~20mA, A4·A5는 0~10V에 해당합니다. 4~20mA 센서도 실제 전류를 읽을 때는 0~20으로 환산합니다. 예제는 A0 전압과 A2 전류를 표시합니다.+두 함수는 ADC 입력을 지정한 min~max 범위로 환산합니다. IanalogRead()는 소수부를 버린 정수, IanalogReadf()는 실수를 반환합니다. A0의 0~5V 입력을 0~100%와 전압으로 각각 표시합니다. A2의 0~20mA 입력은 0~20 범위를 지정하여 실제 전류로 읽습니다.
  
 <code cpp> <code cpp>
줄 202: 줄 243:
  
 void loop() { void loop() {
-  const float voltage = IanalogReadf(A0, 0.0f, 5.0f); +  const int32_t percent = IanalogRead(A0, 0, 100);  // A0 입력을 0~100% 정수로 환산 
-  const float current = IanalogReadf(A2, 0.0f, 20.0f);+  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(F("A0: "));
 +  Serial.print(percent);
 +  Serial.print(F(" %, "));
   Serial.print(voltage, 2);   Serial.print(voltage, 2);
   Serial.print(F(" V, A2: "));   Serial.print(F(" V, A2: "));
줄 213: 줄 257:
 </code> </code>
  
-=== 함수 예제 · ntcReadf() ===+=== 함수 예제 · 4~20mA 범위 환산: IanalogRead2(), IanalogRead2f() ===
  
-ILOGICS 내장 함수: ntcReadf(ch)는 NTC 입력의 섭씨 온도를 float 값으로 반환합니다. NTC 10kΩ(25℃), B=3950K 센서를 A6 또는 A7과 GND 사이에 연결합니다. 예제는 A6을 읽습니다. 범위 밖 값은 -40~120℃의 끝값으로 제한되므로 센서 단선·단락을 별도로 판정하지 않습니다.+**함수 원형** 
 + 
 +<code cpp> 
 +int32_t IanalogRead2(uint8_t ch, int32_t min, int32_t max); 
 +float IanalogRead2f(uint8_t ch, float min, float max); 
 +</code> 
 + 
 +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> <code cpp>
줄 223: 줄 274:
  
 void loop() { void loop() {
-  const float temperature = ntcReadf(A6); +  const int32_t percent = IanalogRead2(A2, 0, 100);  // A2의 4~20mA를 0~100% 정수로 환산 
-  Serial.print(F("NTC0: "));+  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> 
 + 
 +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()로 NTC0(A6)·NTC1(A7)의 ADC 원시값(0~1023)을 표시합니다. 섭씨 온도로 변환하려면 아래 ntcRead()·ntcReadf() 예제를 참고합니다. 
 + 
 +<code cpp> 
 +void setup() { 
 +  Serial.begin(115200); 
 +} 
 + 
 +void loop() { 
 +  Serial.print(F("NTC0 ADC: ")); 
 +  Serial.print(analogRead(A6)); 
 +  Serial.print(F(", NTC1 ADC: ")); 
 +  Serial.println(analogRead(A7)); 
 +  delay(1000); 
 +} 
 +</code> 
 + 
 +**관련 내장 명령어** 
 + 
 +=== 함수 예제 · NTC 온도 읽기: ntcRead(), ntcReadf() === 
 + 
 +**함수 원형** 
 + 
 +<code cpp> 
 +int ntcRead(uint8_t ch); 
 +float ntcReadf(uint8_t ch); 
 +</code> 
 + 
 +NTC0(A6)에 연결한 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(A6);  // NTC0 온도를 섭씨×10 정수로 반환 
 +  const float temperature = ntcReadf(A6);  // NTC0 온도를 섭씨 실수로 반환 
 +  Serial.print(F("ntcRead: ")); 
 +  Serial.print(temperature10); 
 +  Serial.print(F(" (0.1 C), ntcReadf: "));
   Serial.print(temperature, 1);   Serial.print(temperature, 1);
   Serial.println(F(" C"));   Serial.println(F(" C"));
줄 241: 줄 380:
 D18과 D19는 I²C의 SCL·SDA 기능을 공유합니다. I²C 통신을 사용하는 동안에는 해당 핀을 고속 입력으로 동시에 사용할 수 없습니다. D18과 D19는 I²C의 SCL·SDA 기능을 공유합니다. I²C 통신을 사용하는 동안에는 해당 핀을 고속 입력으로 동시에 사용할 수 없습니다.
  
-==== 예제 프로그램 · PWM·고속 입력 ==== +==== 예제 프로그램 · PWM 출력 ====
- +
-Arduino IDE에서 보드를 **MPINO-8A4R(T)-S**로 선택합니다. 아래 코드는 각각 별도 스케치로 실행합니다. +
- +
-**기본 예제** +
- +
-**PWM 3채널 출력**+
  
-FDPWM(핀, 주파수Hz, 듀티%)으로 PWM0·PWM1·PWM2에 1kHz, 약 25%·50%·75% 듀티를 출력합니다. 세 출력은 Timer3를 공유하므로 주파수를 동일하게 지정합니다. DC 5V 신호 입력 기기의 GND와 보드 GND를 연결합니다.+analogWrite()의 0~255 값으로 PWM 듀티를 지정합니다. PWM0(D21)·PWM1(D22)·PWM2(D23)에 각각 64·128·191을 써서 약 25%·50%·75% 듀티를 출력합니다. 주파수와 듀티를 직접 지정하는 방법은 아래 FDPWM() 예제에 있습니다.
  
 <code cpp> <code cpp>
 // MPINO-8A4T-S: PWM0(D21), PWM1(D22), PWM2(D23) // MPINO-8A4T-S: PWM0(D21), PWM1(D22), PWM2(D23)
 void setup() { void setup() {
-  FDPWM(21, 1000, 25.0f);  // PWM0: 1kHz, 25% 듀티 +  analogWrite(21, 64);   // PWM0: 약 25% 듀티 
-  FDPWM(22, 1000, 50.0f);  // PWM1: 1kHz, 50% 듀티 +  analogWrite(22, 128);  // PWM1: 약 50% 듀티 
-  FDPWM(23, 1000, 75.0f);  // PWM2: 1kHz, 75% 듀티+  analogWrite(23, 191);  // PWM2: 약 75% 듀티
 } }
  
줄 263: 줄 396:
 </code> </code>
  
-**CLK 펄스 카운트**+**관련 내장 명령어**
  
-CLK(D24)의 상승 에지를 누적합니다. 신호는 DC 0~5V이며 신호원의 GND를 보드 GND에 연결합니다. 다른 입력을 쓰려면 CLK를 DIO, SCL 또는 SDA로 바꿀 수 있습니다. SCL·SDA를 입력으로 쓰는 동안 Wire 통신은 사용하지 않습니다. 이 예제는 소프트웨어 인터럽트 방식이므로 제품의 최대 입력 주파수에서 무손실 계수를 보장하는 성능 예제가 아닙니다.+=== 함수 예제 · 듀티값 지정: PWM() === 
 + 
 +**함수 원형**
  
 <code cpp> <code cpp>
-#include <util/atomic.h>+void PWM(uint8_t pin, uint16_t val, bool onDutybit16 = false); 
 +</code>
  
-volatile uint32_t pulseCount = 0;+PWM(pin, val, onDutybit16)은 듀티값을 지정합니다. 기본 8비트는 0~255, 세 번째 인수를 true로 지정한 16비트는 0~65535입니다. 예제는 PWM0(D21)에 16비트 중간값 32768을 출력합니다. PWM0~2(D21~D23)는 Timer3를 공유하므로 같은 분해능으로 사용합니다. PWM_RESET()으로 타이머 모드를 정리한 뒤 시작합니다.
  
-void countPulse() { +<code cpp> 
-  pulseCount++;+void setup() { 
 +  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화 
 +  PWM(21, 32768, true);  // PWM0에 16비트 중간 듀티값 출력
 } }
  
 +void loop() {
 +}
 +</code>
 +
 +=== 함수 예제 · 주파수·듀티 설정: FDPWM() ===
 +
 +**함수 원형**
 +
 +<code cpp>
 +void FDPWM(uint8_t pin, int32_t intHz, float Duty);
 +</code>
 +
 +FDPWM(pin, intHz, Duty)는 주파수(Hz)와 듀티(%)를 지정합니다. 예제는 PWM0(D21)에 1kHz, 50%를 출력합니다. PWM0~2(D21~D23)는 Timer3를 공유하므로 함께 사용할 때 같은 주파수를 지정합니다. 이 Arduino 코어에는 별도 FPWM() 함수가 없으며, 주파수 지정 50% 출력은 FDPWM(pin, hz, 50.0f)으로 설정합니다.
 +
 +<code cpp>
 void setup() { void setup() {
-  Serial.begin(115200); +  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화 
-  // CLK = D24, 내장 풀업 사용 +  FDPWM(21, 1000, 50.0f);  // PWM0에 1kHz, 50% 듀티 출력
-  attachInterrupt(digitalPinToInterrupt(CLK), countPulse, RISING);+
 } }
  
 void loop() { void loop() {
-  uint32_t snapshot; 
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { 
-    snapshot = pulseCount; 
-  } 
-  Serial.print(F("CLK pulses: ")); 
-  Serial.println(snapshot); 
-  delay(500); 
 } }
 </code> </code>
  
-**CLK·DIO 엔코더 방향 판별**+=== 함수 예제 · 지정 개수 펄스 출력: NPWM_BEGIN(), NPWM() ===
  
-A상은 CLK(D24), B상은 DIO(D25)에 연결하며 1배 카운트합니다. 신호는 DC 0~5V이고 GND를 공통으로 연결합니다. 표시 방향이 반대라면 A·B 결선 또는 증감 방향을 바꿉니다. 32비트 값은 인터럽트를 잠시 막고 읽어 깨진 값이 출력되지 않도록 합니다.+**함수 원형**
  
 <code cpp> <code cpp>
-#include <util/atomic.h> +void NPWM_BEGIN(uint8_t pin, uint32_t intHz, float Duty, uint32_t N); 
-#include <stdint.h>+void NPWM(uint8_t pin); 
 +</code>
  
-volatile int32_t position = 0;+NPWM_BEGIN(pin, intHz, Duty, N)으로 주파수·듀티·펄스 개수를 준비하고 NPWM(pin)을 loop()에서 계속 호출합니다. 예제는 PWM0(D21)에 1kHz, 50% 펄스 100개를 한 번 출력합니다. NPWM()이 출력 진행과 완료 처리를 담당하므로 loop()에 delay()를 넣지 않습니다. 같은 Timer3의 다른 PWM 출력과 혼합하지 않습니다.
  
-void readEncoder() { +<code cpp> 
-  // A상 상승 시 B상에 따라 방향 판별 (1배 카운트) +void setup() { 
-  if (digitalRead(DIO) == HIGH) { +  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화 
-    if (position < INT32_MAX) position++; +  NPWM_BEGIN(21, 1000, 50.0f, 100);  // PWM0에 1kHz, 50% 펄스 100개 준비
-  } else { +
-    if (position > INT32_MIN) position--; +
-  }+
 } }
  
 +void loop() {
 +  NPWM(21);  // 준비한 펄스 출력 진행 및 완료 처리
 +}
 +</code>
 +
 +=== 함수 예제 · 채널 출력 정지·재개: PWMOFF() ===
 +
 +**함수 원형**
 +
 +<code cpp>
 +void PWMOFF(uint8_t pin, bool POff);
 +</code>
 +
 +PWMOFF(pin, true)는 해당 채널의 정지 상태를 설정하고 false는 해제합니다. 이 제품에서는 설정 직후 PWM() 또는 FDPWM()을 다시 호출해야 출력에 반영됩니다. 예제는 PWM0(D21)의 1kHz 출력을 2초 켜고 2초 끕니다. 정지 때 digitalWrite(21, LOW)로 핀을 LOW로 유지합니다. NPWM()은 이 정지 플래그를 사용하지 않습니다.
 +
 +<code cpp>
 void setup() { void setup() {
-  Serial.begin(115200); +  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화
-  // 엔코더 A상 → CLK(D24), B상 → DIO(D25) +
-  attachInterrupt(digitalPinToInterrupt(CLK), readEncoder, RISING);+
 } }
  
 void loop() { void loop() {
-  int32_t snapshot; +  PWMOFF(21, false);  // PWM0 정지 상태 해제 
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { +  FDPWM(21, 1000, 50.0f);  // 해제를 반영해 1kHz, 50% 출력 시작 
-    snapshot = position; +  delay(2000); 
-  } + 
-  Serial.print(F("Encoder: ")); +  PWMOFF(21, true);  // PWM0 정지 상태 설정 
-  Serial.println(snapshot); +  FDPWM(21, 1000, 50.0f);  // 정지를 반영해 PWM 출력 연결 해제 
-  delay(500);+  digitalWrite(21, LOW); 
 +  delay(2000);
 } }
 </code> </code>
  
-**관련 내장함수 · 기본 함수**+=== 함수 예제 · PWM 타이머 정지·초기화: PWM_RESET() ===
  
-함수 이름을 누르면 설명과 독립 실행 예제가 펼쳐집니다.+**함수 원형**
  
-=== 함수 예제 · FDPWM() ===+<code cpp> 
 +void PWM_RESET(); 
 +</code>
  
-ILOGICS 내장 함수: FDPWM(pin, frequencyHz, dutyPercent)는 PWM 주파수(Hz)와 듀티(%)를 설정하며 반환값이 없습니다. PWM0·PWM1·PWM2는 각각 D21·D22·D23입니다. 세 출력이 Timer3를 공유하므로 함께 사용할 때는 같은 주파수를 지정합니다. 예제는 PWM0에 1kHz, 50% 듀티를 출력합니다.+PWM_RESET()은 Timer1·Timer3의 제어 레지스터와 카운터를 초기화하여 해당 타이머 출력을 모두 정지합니다. 예제는 PWM0(D21)에 1kHz를 2초 출력한 후 정지합니다. PWM0~2 전체와 같은 타이머를 사용하는 기능에 영향을 주므로 채널 하나만 멈출 때는 PWMOFF()를 사용합니다. PWMOFF()로 설정한 정지 플래그까지 해제하는 함수는 아닙니다.
  
 <code cpp> <code cpp>
 void setup() { void setup() {
-  FDPWM(21, 1000, 50.0f);+  PWM_RESET();  // PWM 타이머를 정지하고 모드 초기화 
 +  FDPWM(21, 1000, 50.0f);  // PWM0에 1kHz, 50% 듀티 출력 
 +  delay(2000); 
 +  PWM_RESET();  // Timer1·Timer3의 모든 PWM 정지 및 초기화 
 +  digitalWrite(21, LOW);
 } }
  
줄 346: 줄 510:
 </code> </code>
  
-=== 함수 예제 · attachInterrupt() === 
  
-Arduino 기본 함수: attachInterrupt(digitalPinToInterrupt(pin), ISR, mode)는 입력 변화에 실행할 함수를 등록하며 반환값이 없습니다. 예제는 CLK(D24)의 상승 에지(RISING)를 누적하고 32비트 카운트를 원자적으로 읽습니다. 입력은 DC 0~5V이며 GND를 공통으로 연결합니다. 소프트웨어 인터럽트 예제로, 제품 최대 입력 주파수에서 무손실 계수를 보장하는 예제는 아닙니다.+==== 예제 프로그램 · 펄스 카운트 ==== 
 + 
 +CLK(D24)는 풀업되어 입력이 없으면 HIGH입니다. 외부 신호가 GND로 당기는 HIGH→LOW 순간을 FALLING으로 계수하고 500ms마다 표시합니다. 32비트 값은 ATOMIC_BLOCK으로 읽습니다. 소프트웨어 인터럽트 방식이며 최대 입력 주파수에서 무손실을 보장하는 예제는 아닙니다.
  
 <code cpp> <code cpp>
줄 355: 줄 520:
 volatile uint32_t pulseCount = 0; volatile uint32_t pulseCount = 0;
  
-void onPulse() {+void countPulse() {
   pulseCount++;   pulseCount++;
 } }
줄 361: 줄 526:
 void setup() { void setup() {
   Serial.begin(115200);   Serial.begin(115200);
-  attachInterrupt(digitalPinToInterrupt(CLK), onPulse, RISING);+  // CLK는 풀업 상태이며, 외부 신호가 GND로 당길 때 계수 
 +  attachInterrupt(digitalPinToInterrupt(CLK), countPulse, FALLING);
 } }
  
 void loop() { void loop() {
-  uint32_t count;+  uint32_t snapshot;
   ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {   ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
-    count = pulseCount;+    snapshot = pulseCount;
   }   }
-  Serial.println(count);+  Serial.print(F("CLK pulses: ")); 
 +  Serial.println(snapshot); 
 +  delay(500); 
 +} 
 +</code> 
 + 
 + 
 +==== 예제 프로그램 · 엔코더 입력 ==== 
 + 
 +풀업된 CLK(D24)에 A상, DIO(D25)에 B상을 연결합니다. CLK 하강 에지(FALLING)에서 DIO가 LOW이면 증가, HIGH이면 감소하는 1배 계수 예제입니다. 실제 회전 방향은 A·B상 연결에 따라 달라집니다. 
 + 
 +<code cpp> 
 +#include <util/atomic.h> 
 +#include <stdint.h> 
 + 
 +volatile int32_t position = 0; 
 + 
 +void readEncoder() { 
 +  // A상 하강 시 B상이 LOW이면 증가 (1배 카운트) 
 +  if (digitalRead(DIO) == LOW) { 
 +    if (position < INT32_MAX) position++; 
 +  } else { 
 +    if (position > INT32_MIN) position--; 
 +  } 
 +} 
 + 
 +void setup() { 
 +  Serial.begin(115200); 
 +  // 엔코더 A상 → CLK(D24), 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);   delay(500);
 } }
줄 382: 줄 586:
 | I²C | D18(SCL), D19(SDA) | ''Wire'' | ::: | | I²C | D18(SCL), D19(SDA) | ''Wire'' | ::: |
  
-==== 예제 프로그램 · 통신과 다운로드 ====+==== 예제 프로그램 · 기본 통신 ====
  
-Arduino IDE에서 보드를 **MPINO-8A4R(T)-S**로 선택합니다. 아래 코드는 각각 별도 스케치로 실행합니다. +Serial(115200bps)로 받은 문자를 Serial1(9600bps, 8-N-1)으로 보내고, Serial1 수신 문자를 Serial로 돌려보냅니다. availableForWrite()로 전송 버퍼 여유를 확인합니다. 상대 기기보다 빠른 연속 전송은 수신 버퍼를 넘칠 수 있습니다.
- +
-**기본 예제** +
- +
-**시리얼 모니터 ↔ RS-232 문자 전송** +
- +
-시리얼 모니터에 입력한 문자를 Serial1로 보내고, 상대 기기의 수신 문자를 모니터에 표시합니다. RS-232 상대 기기는 9600 bps, 8-N-1로 설정하고 TX↔RX 및 GND를 연결합니다. 간단한 문자 확인용이며 Modbus·Cnet 프로토콜 예제는 아닙니다. USB 쪽에서 상대 기기가 처리할 수 있는 속도보다 빠르게 연속 전송하면 수신 버퍼가 넘칠 수 있습니다.+
  
 <code cpp> <code cpp>
줄 409: 줄 607:
 </code> </code>
  
-**I²C 장치 주소 확인** 
  
-GND·SDA·SCL을 연결한 장치의 7비트 주소를 3초마다 검색합니다. 5V 단자는 5V를 지원하는 장치의 전원에만 연결합니다. I²C 사용 중에는 D18·D19에 고속 입력 인터럽트를 함께 설정하지 않습니다.+==== 예제 프로그램 · I²C 통신 ==== 
 + 
 +Wire로 0x08~0x77의 I²C 주소를 검색하고 응답한 주소를 3초마다 시리얼 모니터에 표시합니다. endTransmission()의 반환값이 0이면 해당 주소에서 응답한 것입니다.
  
 <code cpp> <code cpp>
줄 440: 줄 639:
 </code> </code>
  
-**관련 내장함수 · 기본 함수** 
  
-함수 이름을 누르면 설명과 독립 실행 예제가 펼쳐집니다.+==== 예제 프로그램 · Modbus RTU 통신 ====
  
-=== 함수 예제 · Serial.begin() · available() · read() · write() ===+**관련 내장 명령어**
  
-Arduino 기본 Serial 함수: begin(baud)는 통신 속도를 설정합니다. available()은 수신 대기 바이트 수, read()는 수신한 한 바이트(없으면 -1), write(data)는 전송 버퍼에 기록한 바이트 수를 반환합니다. availableForWrite()로 전송 버퍼 여유를 확인합니다. Serial은 다운로드 케이블의 시리얼 모니터(115200 bps), Serial1은 RS-232(9600 bps, 8-N-1)에 사용합니다. TX↔RX와 GND를 연결합니다. 아래는 문자 중계 예제이며 지속적인 대량 전송에서는 수신 버퍼가 넘칠 수 있습니다.+=== 함수 예제 · Modbus RTU Slave: ImodbusRTUMem(), ImodbusRTUAdr(), ImodbusRTUInit(), ImodbusRTU() === 
 + 
 +**함수 원형**
  
 <code cpp> <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>
 +
 +P0 상태를 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는 코어가 제공하는 공유 전역 메모리입니다. 이 스케치는 단독 실행하며, 다른 프로토콜과 함께 사용할 때는 메모리를 중복 할당하지 않습니다.
 +
 +<code cpp>
 +unsigned long lastPrint = 0;
 +bool memoryReady = false;
 +
 void setup() { void setup() {
   Serial.begin(115200);   Serial.begin(115200);
-  Serial1.begin(9600);+  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() { void loop() {
-  if (Serial.available() && Serial1.availableForWrite()) { +  if (!memoryReady) return; 
-    Serial1.write(Serial.read()); +  M[0] = digitalRead(0); 
-  } +  D[0] = analogRead(A0); 
-  if (Serial1.available() && Serial.availableForWrite()) { +  ImodbusRTU();  // 수신한 Modbus RTU 요청 처리 
-    Serial.write(Serial1.read());+ 
 +  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> </code>
  
-=== 함수 예제 · Wire.beginTransmission() · endTransmission() ===+=== 함수 예제 · Modbus RTU Master: ImodbusRTUmasterInit(), ImodbusRTUmaster() ===
  
-Arduino 기본 Wire 라이브러리: Wire.begin()으로 I²C를 시작합니다. beginTransmission(address)는 7비트 주소의 장치로 전송을 준비하고, endTransmission()은 전송을 실행한 뒤 결과를 반환합니다(0이면 성공). 아래는 0x08~0x77 주소의 응답을 확인합니다. GND·SDA·SCL을 연결하고 5V 전원은 5V 지원 장치에만 사용합니다. I²C 사용 중에는 D18·D19의 고속 입력 인터럽트를 함께 사용하지 않습니다.+**함수 원형**
  
 <code cpp> <code cpp>
-#include <Wire.h>+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 메모리 대신 수신 배열을 사용합니다. 
 + 
 +<code cpp> 
 +unsigned long lastRequest = 0; 
 +uint16_t received[1];
  
 void setup() { void setup() {
   Serial.begin(115200);   Serial.begin(115200);
-  Wire.begin(); +  ImodbusRTUmasterInit(Serial1, 9600, SERIAL_8N1);  // RS-232를 Modbus 마스터로 시작
-  Wire.setClock(100000);+
 } }
  
 void loop() { void loop() {
-  for (uint8_t address = 0x08; address <= 0x77; address++) { +  if (millis() - lastRequest < 1000) return; 
-    Wire.beginTransmission(address); +  lastRequest = millis(); 
-    const uint8_t result = Wire.endTransmission(); +  const uint8_t result = ImodbusRTUmaster(Serial1, 1, 3, 0, 1, received, 200);  // 국번 1의 주소 0에서 1워드 읽기, 제한 200ms 
-    if (result == 0) { + 
-      Serial.print(F("I2C: 0x")); +  if (result == IMODBUS_RTU_SUCCESS) { 
-      if (address < 16) Serial.print('0'); +    Serial.print(F("Register 0: ")); 
-      Serial.println(address, HEX); +    Serial.println(received[0]); 
-    }+  } else { 
 +    Serial.print(F("Modbus error: 0x")); 
 +    Serial.println(result, HEX);
   }   }
-  delay(3000); 
 } }
 </code> </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>
 +
 +P0 상태를 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 예제와는 단독 실행하며, 다른 프로토콜과 함께 사용할 때는 메모리를 중복 할당하지 않습니다.
 +
 +<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(0);
 +  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>
  
 [[products:mpino_series|← MPINO Series 비교표로 돌아가기]] [[products:mpino_series|← MPINO Series 비교표로 돌아가기]]
  
products/mpino_8a4t_s.1788765595.txt.gz · 마지막으로 수정됨: 저자 127.0.0.1
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki