[ZSC31014] Arduino로 EEPROM 및 센서 데이터 읽기/쓰기 (Reading/Writing EEPROM and Sensor Data with ZSC31014 and Arduino)

소개 (Introduction)

ZSC31014는 Renesas Electronics의 고정밀 센서 신호 컨디셔너로, 차동/하프 브리지 센서의 신호를 증폭하고 디지털로 변환합니다 (The ZSC31014 is a high-precision sensor signal conditioner from Renesas Electronics, amplifying and converting differential/half-bridge sensor signals to digital). 이 글에서는 Arduino를 사용하여 ZSC31014의 EEPROM 데이터를 읽고 쓰며, Normal Operation Mode에서 센서(브리지) 데이터와 온도 데이터를 I²C로 읽는 방법을 설명합니다 (This post explains how to read/write EEPROM data and read sensor (bridge) and temperature data in Normal Operation Mode using I²C with Arduino). 코드와 설정은 ZSC31014 데이터시트(REN_ZSC31014_DST_20160120_1.pdf)를 기반으로 합니다 (The code and configuration are based on the ZSC31014 datasheet, REN_ZSC31014_DST_20160120_1.pdf).

하드웨어 설정 (Hardware Setup)

필요 부품 (Required Components)

• Arduino 보드 (Uno, Nano 등, 3.3V 권장) (Arduino board, e.g., Uno, Nano, 3.3V recommended)
• ZSC31014 센서 모듈 (ZSC31014 sensor module)
• 차동/하프 브리지 센서 (예: 압력 센서) (Differential/half-bridge sensor, e.g., pressure sensor)
• 100nF~470nF 커패시터 (VDD-GND 간) (100nF~470nF capacitor between VDD and GND)
• 1kΩ~10kΩ 풀업 저항 (I²C 라인) (1kΩ~10kΩ pull-up resistors for I²C lines)

연결 (Connections)

• ZSC31014 VDD: Arduino 3.3V (또는 5V, 2.7V~5.5V 지원) (Arduino 3.3V or 5V, supports 2.7V~5.5V)
• VSS: GND
• SCL: Arduino A5
• SDA: Arduino A4
• VBP/VBN: 차동 센서 연결 (Connect to differential sensor)
• 커패시터: VDD-GND 간 100nF~470nF (100nF~470nF capacitor between VDD and GND)
• 풀업 저항: SCL/SDA에 1kΩ~10kΩ (1kΩ~10kΩ pull-up resistors on SCL/SDA)

참고 (Note): Arduino 5V 보드 사용 시 ZSC31014 VDD가 5.5V 이하인지 확인하세요 (Ensure ZSC31014 VDD is below 5.5V when using a 5V Arduino board). 데이터시트 페이지 6 참조 (Refer to datasheet page 6).

소프트웨어 설정 (Software Setup)

Arduino IDE 설정 (Arduino IDE Setup)

1. Arduino IDE를 설치합니다 (Install Arduino IDE).
2. 새 스케치를 만들고 아래 코드를 붙여넣습니다 (Create a new sketch and paste the code below).
3. 보드 선택: Arduino Uno/Nano 등 (Select board: Arduino Uno/Nano, etc.).
4. 시리얼 모니터: 9600 보드레이트 (Serial Monitor: 9600 baud rate).

라이브러리 (Library)

• Wire.h: I²C 통신용, Arduino에 기본 포함 (For I²C communication, included with Arduino).

Arduino 코드 (Arduino Code)

아래 코드는 ZSC31014의 EEPROM 읽기/쓰기와 센서/온도 데이터 읽기를 구현합니다 (The code below implements EEPROM read/write and sensor/temperature data reading for the ZSC31014). Wire 라이브러리를 사용하며, I²C 주소는 0x28로 설정됩니다 (Uses the Wire library with I²C address set to 0x28).

#include <Wire.h>

// ZSC31014 I2C 슬레이브 주소 (7비트 주소: 0x28, 데이터시트 페이지 20)
// ZSC31014 I2C slave address (7-bit address: 0x28, datasheet page 20)
#define ZSC31014_I2C_ADDR 0x28

// 명령 코드 (데이터시트 페이지 37, Table 3.6)
// Command codes (datasheet page 37, Table 3.6)
#define CMD_START_CM  0xA0 // Command Mode 진입 (Enter Command Mode)
#define CMD_START_NOM 0x80 // Normal Operation Mode 복귀 (Return to Normal Operation Mode)
#define CMD_EEPROM_READ_BASE  0x00 // EEPROM 읽기 명령 기본값 (0x00 ~ 0x13) (EEPROM read base, 0x40 ~ 0x53)
#define CMD_EEPROM_WRITE_BASE 0x40 // EEPROM 쓰기 명령 기본값 (0x40 ~ 0x53) (EEPROM write base, 0x80 ~ 0x93)

// 함수 프로토타입 (Function prototypes)
bool zsc31014_start_cm();
bool zsc31014_start_nom();
bool zsc31014_read_sensor_data(uint16_t *bridge_data, uint16_t *temp_data, bool temp_res_11bit);
bool zsc31014_trigger_measurement();
bool zsc31014_read_eeprom(uint8_t word_addr, uint16_t *data);
bool zsc31014_write_eeprom(uint8_t word_addr, uint16_t data);
bool zsc31014_read_all_eeprom(uint16_t *data_array);
bool zsc31014_write_all_eeprom(uint16_t *data_array);


void setup() {
  // 시리얼 초기화 (디버깅용) (Initialize Serial for debugging)
  Serial.begin(9600);
  while (!Serial); // 시리얼 포트 연결 대기 (Wait for Serial port connection)
  Serial.println("ZSC31014 Arduino 테스트 시작 (ZSC31014 Arduino Test Started)");

  // I2C 초기화 (Initialize I2C)
  Wire.begin();
  Wire.setClock(100000); // 100kHz (데이터시트 페이지 20) (100kHz, datasheet page 20)

  // 테스트 실행 (Run test)
  zsc31014_example();
}

void loop() {
  // 주기적으로 센서 데이터 읽기 (예: 1초마다) (Read sensor data periodically, e.g., every 1 second)
  uint16_t bridge_data, temp_data;
  Serial.println("주기적 센서/온도 데이터 읽기 (Periodic Sensor/Temperature Data Reading)");
  if (zsc31014_trigger_measurement()) {
    if (zsc31014_read_sensor_data(&bridge_data, &temp_data, true)) {
      Serial.print("(Bridge Data: 0x");
      Serial.print(bridge_data, HEX);
      Serial.print(", Temperature Data: 0x");
      Serial.println(temp_data, HEX);
      Serial.println(")");
    } else {
      Serial.println("센서 데이터 읽기 실패 (Sensor Data Reading Failed)");
    }
  } else {
    Serial.println("Write_MR 실패 (Write_MR Failed)");
  }
  delay(1000); // 1초 대기 (1-second delay)
}

/**
 * @brief Command Mode 진입 (Enter Command Mode)
 * @return true 성공, false 실패 (true on success, false on failure)
 */
bool zsc31014_start_cm() {
  Wire.beginTransmission(ZSC31014_I2C_ADDR);
  Wire.write(CMD_START_CM);
  Wire.write(0x00); // 상위 바이트 (Upper byte)
  Wire.write(0x00); // 하위 바이트 (Lower byte)
  if (Wire.endTransmission() != 0) {
    Serial.println("Start_CM 실패 (Start_CM Failed)");
    return false;
  }

  // 명령 완료 대기 (데이터시트: 10us, 페이지 37) (Wait for command completion, 10us, datasheet page 37)
  delay(1);
  return true;
}

/**
 * @brief Normal Operation Mode 복귀 및 EEPROM 서명 업데이트 (Return to Normal Operation Mode and update EEPROM signature)
 * @return true 성공, false 실패 (true on success, false on failure)
 */
bool zsc31014_start_nom() {
  Wire.beginTransmission(ZSC31014_I2C_ADDR);
  Wire.write(CMD_START_NOM);
  Wire.write(0x00); // 상위 바이트 (Upper byte)
  Wire.write(0x00); // 하위 바이트 (Lower byte)
  if (Wire.endTransmission() != 0) {
    Serial.println("Start_NOM 실패 (Start_NOM Failed)");
    return false;
  }

  // 서명 업데이트 포함 최대 15ms 대기 (데이터시트 페이지 37) (Max 15ms wait for signature update, datasheet page 37)
  delay(15);
  return true;
}

/**
 * @brief 특정 EEPROM 워드 읽기 (Read specific EEPROM word)
 * @param word_addr 워드 주소 (0x00 ~ 0x13) (Word address, 0x00 ~ 0x13)
 * @param data 읽은 16비트 데이터 저장 포인터 (Pointer to store 16-bit data)
 * @return true 성공, false 실패 (true on success, false on failure)
 */
bool zsc31014_read_eeprom(uint8_t word_addr, uint16_t *data) {
   // Command Mode 진입 (Enter Command Mode)
  if (!zsc31014_start_cm()) {
    Serial.println("Command Mode 진입 실패 (Command Mode entry failed)");
    return false;
  }
  if (word_addr > 0x13) {
    Serial.print("(Invalid word address: 0x");
    Serial.print(word_addr, HEX);
    Serial.println(")");
    return false;
  }

  // 읽기 명령 전송 (Send read command)
  Wire.beginTransmission(ZSC31014_I2C_ADDR);
  Wire.write(CMD_EEPROM_READ_BASE + word_addr);
  Wire.write(0x00); // 상위 바이트 (Upper byte)
  Wire.write(0x00); // 하위 바이트 (Lower byte)
  if (Wire.endTransmission() != 0) {
    Serial.print("(EEPROM read command failed, word 0x");
    Serial.print(word_addr, HEX);
    Serial.println(")");
    return false;
  }

  // 데이터 수신 (5AHEX + 16비트 데이터) (Receive data: 0x5A + 16-bit data)
  Wire.requestFrom(ZSC31014_I2C_ADDR, 3);
  if (Wire.available() != 3) {
    Serial.print("(EEPROM data receive failed, word 0x");
    Serial.print(word_addr, HEX);
    Serial.println(")");
    return false;
  }

  uint8_t rx_data[3];
  rx_data[0] = Wire.read(); // 0x5A
  rx_data[1] = Wire.read(); // 데이터 상위 바이트 (Data upper byte)
  rx_data[2] = Wire.read(); // 데이터 하위 바이트 (Data lower byte)

  // 첫 바이트가 0x5A인지 확인 (Check if first byte is 0x5A)
  if (rx_data[0] != 0x5A) {
    Serial.print("(EEPROM read response error, word 0x");
    Serial.print(word_addr, HEX);
    Serial.print("): 0x");
    Serial.println(rx_data[0], HEX);
    Serial.println(")");
    return false;
  }

  // 16비트 데이터 조합 (Combine 16-bit data)
  *data = (rx_data[1] << 8) | rx_data[2];
  // Normal Operation Mode 복귀 (Return to Normal Operation Mode)
  if (!zsc31014_start_nom()) {
    Serial.println("Normal Operation Mode 복귀 실패 (Normal Operation Mode return failed)");
    return false;
  }
  return true;
}

/**
 * @brief 특정 EEPROM 워드 쓰기 (Write specific EEPROM word)
 * @param word_addr 워드 주소 (0x00 ~ 0x13) (Word address, 0x00 ~ 0x13)
 * @param data 쓸 16비트 데이터 (16-bit data to write)
 * @return true 성공, false 실패 (true on success, false on failure)
 */
bool zsc31014_write_eeprom(uint8_t word_addr, uint16_t data) {
   // Command Mode 진입 (Enter Command Mode)
  if (!zsc31014_start_cm()) {
    Serial.println("Command Mode 진입 실패 (Command Mode entry failed)");
    return false;
  }
  if (word_addr > 0x13) {
    Serial.print("(Invalid word address: 0x");
    Serial.print(word_addr, HEX);
    Serial.println(")");
    return false;
  }

  // T_Config(0x10), Osc_Trim(0x11)은 공장 설정 유지 경고 (Warning: Keep factory settings for T_Config 0x10, Osc_Trim 0x11)
  if (word_addr == 0x10 || word_addr == 0x11) {
    Serial.print("(Warning: Word 0x");
    Serial.print(word_addr, HEX);
    Serial.println(" should retain factory settings)");
  }

  Wire.beginTransmission(ZSC31014_I2C_ADDR);
  Wire.write(CMD_EEPROM_WRITE_BASE + word_addr);
  Wire.write((data >> 8) & 0xFF); // 상위 바이트 (Upper byte)
  Wire.write(data & 0xFF);        // 하위 바이트 (Lower byte)
  if (Wire.endTransmission() != 0) {
    Serial.print("(EEPROM write failed, word 0x");
    Serial.print(word_addr, HEX);
    Serial.println(")");
    return false;
  }

  // 쓰기 완료 대기 (데이터시트: 10ms, 페이지 37) (Wait for write completion, 10ms, datasheet page 37)
  delay(10);
   // Normal Operation Mode 복귀 (Return to Normal Operation Mode)
  if (!zsc31014_start_nom()) {
    Serial.println("Normal Operation Mode 복귀 실패 (Normal Operation Mode return failed)");
    return false;
  }
  return true;
}

/**
 * @brief 전체 EEPROM 읽기 (0x00 ~ 0x13) (Read all EEPROM, 0x00 ~ 0x13)
 * @param data_array 20개 워드(16비트)를 저장할 배열 (Array to store 20 words of 16-bit data)
 * @return true 성공, false 실패 (true on success, false on failure)
 */
bool zsc31014_read_all_eeprom(uint16_t *data_array) {
  // Command Mode 진입 (Enter Command Mode)
  if (!zsc31014_start_cm()) {
    Serial.println("Command Mode 진입 실패 (Command Mode entry failed)");
    return false;
  }

  // 워드 0x00 ~ 0x13 읽기 (Read words 0x00 ~ 0x13)
  for (uint8_t word_addr = 0x00; word_addr <= 0x13; word_addr++) {
    if (!zsc31014_read_eeprom(word_addr, &data_array[word_addr])) {
      Serial.print("(EEPROM read failed, word 0x");
      Serial.print(word_addr, HEX);
      Serial.println(")");
      return false;
    }
    Serial.print(" (Word 0x");
    Serial.print(word_addr, HEX);
    Serial.print(": 0x");
    Serial.print(data_array[word_addr], HEX);
    Serial.println(")");
  }

  // Normal Operation Mode 복귀 (Return to Normal Operation Mode)
  if (!zsc31014_start_nom()) {
    Serial.println("Normal Operation Mode 복귀 실패 (Normal Operation Mode return failed)");
    return false;
  }

  return true;
}

/**
 * @brief 전체 EEPROM 쓰기 (0x00 ~ 0x13) (Write all EEPROM, 0x00 ~ 0x13)
 * @param data_array 쓸 20개 워드(16비트) 데이터 배열 (Array of 20 words of 16-bit data to write)
 * @return true 성공, false 실패 (true on success, false on failure)
 */
bool zsc31014_write_all_eeprom(uint16_t *data_array) {
  // Command Mode 진입 (Enter Command Mode)
  if (!zsc31014_start_cm()) {
    Serial.println("Command Mode 진입 실패 (Command Mode entry failed)");
    return false;
  }

  // 워드 0x00 ~ 0x13 쓰기 (Write words 0x00 ~ 0x13)
  for (uint8_t word_addr = 0x00; word_addr <= 0x13; word_addr++) {
    if (!zsc31014_write_eeprom(word_addr, data_array[word_addr])) {
      Serial.print("(EEPROM write failed, word 0x");
      Serial.print(word_addr, HEX);
      Serial.println(")");
      return false;
    }
    Serial.print("(Wrote 0x");
    Serial.print(data_array[word_addr], HEX);
    Serial.print(" to word 0x");
    Serial.print(word_addr, HEX);
    Serial.println(")");
  }

  // Normal Operation Mode 복귀 및 서명 업데이트 (Return to Normal Operation Mode and update signature)
  if (!zsc31014_start_nom()) {
    Serial.println("Normal Operation Mode 복귀 실패 (Normal Operation Mode return failed)");
    return false;
  }

  return true;
}

/**
 * @brief 센서(브리지) 데이터와 온도 데이터 읽기 (Read sensor (bridge) and temperature data)
 * @param bridge_data 브리지 데이터(14비트) 저장 포인터 (Pointer to store 14-bit bridge data)
 * @param temp_data 온도 데이터(8비트 또는 11비트) 저장 포인터 (Pointer to store 8-bit or 11-bit temperature data)
 * @param temp_res_11bit 온도 해상도 (false: 8비트, true: 11비트) (Temperature resolution, false: 8-bit, true: 11-bit)
 * @return true 성공, false 실패 (true on success, false on failure)
 */
bool zsc31014_read_sensor_data(uint16_t *bridge_data, uint16_t *temp_data, bool temp_res_11bit) {
  uint8_t byte_count = temp_res_11bit ? 4 : 3; // Read_DF4 (11비트) 또는 Read_DF3 (8비트) (Read_DF4 for 11-bit, Read_DF3 for 8-bit)
  Wire.requestFrom(ZSC31014_I2C_ADDR, byte_count);
  if (Wire.available() != byte_count) {
    Serial.println("센서 데이터 수신 실패 (Sensor data receive failed)");
    return false;
  }

  uint8_t rx_data[4];
  for (uint8_t i = 0; i < byte_count; i++) {
    rx_data[i] = Wire.read();
  }

  // 상태 비트 확인 (S[1:0], 데이터시트 페이지 24, Table 2.9) (Check status bits, S[1:0], datasheet page 24, Table 2.9)
  uint8_t status_bits = (rx_data[0] >> 6) & 0x03;
  if (status_bits == 0x03) {
    Serial.println("진단 오류: EEPROM 무결성 또는 센서 오류 (Diagnostic error: EEPROM integrity or sensor error)");
    return false;
  } else if (status_bits == 0x02) {
    Serial.println("경고: Stale 데이터 (Warning: Stale data)");
  }

  // 브리지 데이터 (14비트) 조합 (Combine 14-bit bridge data)
  *bridge_data = ((rx_data[0] & 0x3F) << 8) | rx_data[1];

  // 온도 데이터 조합 (Combine temperature data)
  if (byte_count >= 3) {
    if (temp_res_11bit) {
      // 11비트 온도 데이터 (11-bit temperature data)
      *temp_data = (rx_data[2] << 3) | ((rx_data[3] >> 5) & 0x07);
    } else {
      // 8비트 온도 데이터 (8-bit temperature data)
      *temp_data = rx_data[2];
    }
  } else {
    *temp_data = 0; // 온도 데이터 요청되지 않음 (No temperature data requested)
  }

  Serial.print(" (Bridge Data: 0x");
  Serial.print(*bridge_data, HEX);
  Serial.print(", Temperature Data: 0x");
  Serial.println(*temp_data, HEX);
  Serial.println(")");
  return true;
}

/**
 * @brief Sleep Mode에서 측정 요청 (Write_MR) (Trigger measurement in Sleep Mode, Write_MR)
 * @return true 성공, false 실패 (true on success, false on failure)
 */
bool zsc31014_trigger_measurement() {
  // Write_MR: 주소만 전송 (데이터시트 페이지 36, Figure 3.9) (Write_MR: Send address only, datasheet page 36, Figure 3.9)
  Wire.beginTransmission(ZSC31014_I2C_ADDR);
  if (Wire.endTransmission() != 0) {
    Serial.println("Write_MR 실패 (Write_MR Failed)");
    return false;
  }

  // 측정 완료 대기 (1MHz 클럭: 1.5ms, 데이터시트 페이지 31, Table 3.4) (Wait for measurement completion, 1.5ms for 1MHz clock, datasheet page 31, Table 3.4)
  delay(2);
  return true;
}

/**
 * @brief 테스트 함수 (Test function)
 */
void zsc31014_example() {
  uint16_t eeprom_data[20]; // 0x00 ~ 0x13 워드 저장 배열 (Array to store words 0x00 ~ 0x13)
  uint16_t bridge_data, temp_data;

  // 전체 EEPROM 읽기 (Read all EEPROM)
  Serial.println("EEPROM 전체 읽기 시작 (Starting full EEPROM read)");
  if (zsc31014_read_all_eeprom(eeprom_data)) {
    Serial.println("EEPROM 전체 읽기 완료 (Full EEPROM read completed)");
  } else {
    Serial.println("EEPROM 전체 읽기 실패 (Full EEPROM read failed)");
  }

  // 특정 워드 읽기 (예: 워드 0x01) (Read specific word, e.g., word 0x01)
  uint16_t single_data;
  Serial.println("워드 0x01 읽기 시작 (Starting read of word 0x01)");
  if (zsc31014_read_eeprom(0x01, &single_data)) {
    Serial.print(" (Word 0x01: 0x");
    Serial.print(single_data, HEX);
    Serial.println(")");
  } else {
    Serial.println("워드 0x01 읽기 실패 (Word 0x01 read failed)");
  }

  // 특정 워드 쓰기 (예: 워드 0x01에 0x0000 쓰기) (Write specific word, e.g., write 0x0000 to word 0x01)
  Serial.println("워드 0x01에 0x0000 쓰기 시작 (Starting write of 0x0000 to word 0x01)");
  if (zsc31014_write_eeprom(0x01, 0x0000)) {
    Serial.println("워드 0x01 쓰기 완료 (Word 0x01 write completed)");
  } else {
    Serial.println("워드 0x01 쓰기 실패 (Word 0x01 write failed)");
  }

  // 전체 EEPROM 쓰기 예시 (샘플 데이터) (Example: Write full EEPROM with sample data)
  uint16_t sample_data[20];
  memset(sample_data, 0, sizeof(sample_data)); // 0으로 초기화 (Initialize to 0)
  sample_data[0x01] = 0x0004; // I2C, 1MHz, 11비트 온도, Update_Rate=25ms (I2C, 1MHz, 11-bit temp, Update_Rate=25ms)
  sample_data[0x02] = 0x0280; // 슬레이브 주소 0x28 (Slave address 0x28)
  sample_data[0x0F] = 0x0A80; // PreAmp_Gain=6, A2D_Offset=-1/2 ~ 1/2
  Serial.println("EEPROM 전체 쓰기 시작 (Starting full EEPROM write)");
  if (zsc31014_write_all_eeprom(sample_data)) {
    Serial.println("EEPROM 전체 쓰기 완료 (Full EEPROM write completed)");
  } else {
    Serial.println("EEPROM 전체 쓰기 실패 (Full EEPROM write failed)");
  }

  // Sleep Mode에서 센서 데이터와 온도 데이터 읽기 (Read sensor and temperature data in Sleep Mode)
  Serial.println("Sleep Mode에서 센서/온도 데이터 읽기 시작 (Starting sensor/temperature data read in Sleep Mode)");
  if (zsc31014_trigger_measurement()) {
    if (zsc31014_read_sensor_data(&bridge_data, &temp_data, true)) {
      Serial.println("Sleep Mode 데이터 읽기 완료 (Sleep Mode data read completed)");
    } else {
      Serial.println("Sleep Mode 데이터 읽기 실패 (Sleep Mode data read failed)");
    }
  } else {
    Serial.println("Write_MR 실패 (Write_MR Failed)");
  }

  // Update Mode에서 센서 데이터와 온도 데이터 읽기 (Read sensor and temperature data in Update Mode)
  Serial.println("Update Mode에서 센서/온도 데이터 읽기 시작 (Starting sensor/temperature data read in Update Mode)");
  if (zsc31014_read_sensor_data(&bridge_data, &temp_data, true)) {
    Serial.println("Update Mode 데이터 읽기 완료 (Update Mode data read completed)");
  } else {
    Serial.println("Update Mode 데이터 읽기 실패 (Update Mode data read failed)");
  }
}

 

사용 방법 (Usage Instructions)

1. 하드웨어 연결 (Hardware Connection):
   •   ZSC31014를 Arduino에 연결합니다 (Connect ZSC31014 to Arduino).
   •   VDD: Arduino 3.3V (권장) 또는 5V (VDD: Arduino 3.3V recommended or 5V).
   •   VSS: GND.
   •   SCL: A5, SDA: A4.
   •   VDD-GND 간 100nF~470nF 커패시터 (100nF~470nF capacitor between VDD-GND).
   •   I²C 라인에 1kΩ~10kΩ 풀업 저항 (1kΩ~10kΩ pull-up resistors on I²C lines).
   •   VBP/VBN에 차동 센서 연결 (Connect differential sensor to VBP/VBN).
2. 코드 업로드 (Upload Code):
   •   Arduino IDE에서 코드를 복사하여 새 스케치에 붙여넣습니다 (Copy the code to a new sketch in Arduino IDE).
   •   보드를 연결하고 업로드합니다 (Connect the board and upload).
   •   시리얼 모니터를 열어 결과를 확인합니다 (9600 보드레이트) (Open Serial Monitor to view results, 9600 baud rate).
3. 동작 확인 (Verify Operation):
   •   setup()에서 zsc31014_example()이 EEPROM 읽기/쓰기와 센서/온도 데이터 읽기를 실행합니다 (In setup(),       zsc31014_example() runs EEPROM read/write and sensor/temperature data reading).
   •   loop()에서 1초마다 Sleep Mode로 센서 데이터를 읽습니다 (In loop(), sensor data is read every 1 second in Sleep  Mode).
   •   시리얼 모니터에서 출력 확인 (Check output in Serial Monitor):
     •   EEPROM 워드 값 (EEPROM word values).
     •   브리지 데이터 (14비트)와 온도 데이터 (11비트) (Bridge data, 14-bit, and temperature data, 11-bit).

주의사항 (Notes)

•   전원 (Power): Arduino 5V 사용 시 ZSC31014 VDD가 5.5V 이하인지 확인하세요 (Ensure ZSC31014 VDD is below 5.5V with a 5V Arduino). 3.3V 보드 권장 (3.3V board recommended, datasheet page 6).
•   POR 후 6ms: Start_CM은 전원 켜짐 후 6ms 이내 실행해야 합니다 (Execute Start_CM within 6ms after power-on, datasheet page 37).
•   공장 설정: 워드 0x10 (T_Config), 0x11 (Osc_Trim)은 공장 설정 유지 권장 (Retain factory settings for words 0x10, T_Config, and 0x11, Osc_Trim, datasheet page 41).
•   EEPROM 서명: 쓰기 후 Start_NOM 필수, 그렇지 않으면 진단 오류 발생 (S[1:0] = 0x03, 페이지 24) (Run Start_NOM after EEPROM write to avoid diagnostic errors, S[1:0] = 0x03, datasheet page 24).
•   Sleep Mode 첫 데이터: 첫 번째 Write_MR은 부정확할 수 있으므로 두 번째 요청 확인 (First Write_MR in Sleep Mode may be inaccurate; check second request, datasheet page 31).
•   I²C 주소: 워드 02HEX 비트 [12:10] = 011이면 주소 고정 (If word 0x02 bits [12:10] = 011, I²C address is locked, datasheet page 40).
•   디버깅: 시리얼 모니터로 상태 비트와 통신 오류 확인 (Check status bits and communication errors in Serial Monitor).

추가 참고 (Additional Resources)

•   캘리브레이션 (Calibration): 센서 데이터가 부정확하면 워드 03HEX~09HEX (Gain_B, Offset_B 등)를 재설정하세요 (If sensor data is inaccurate, recalibrate words 0x03 ~ 0x09, e.g., Gain_B, Offset_B, datasheet pages 44~48).
•   IDT 소프트웨어 (IDT Software): 캘리브레이션 계수 계산에 사용 (Use for calibration coefficient calculation, datasheet page 45).
•   문서 (Documentation): ZSC31014 Technical Note-Detailed Equations for Calibration Math 요청 (Request ZSC31014 Technical Note-Detailed Equations for Calibration Math, datasheet page 56).