18. STM32 I2C 통신 - AM1008W-K-P 동작 구현

이 전 글에서 AM1008W-K-P 데이터시트와 I2C HAL 함수들을 소개했다. 이번 글은 위 정보들을 이용하여 아두이노와 똑같이 재현하도록 하겠다. 우선 프로젝트를 생성한다. 프로젝트 생성에 대한 내용은 생략하겠다.

1. I2C 설정

I2C 동작을 구현하기 위해 레지스터를 설정해주어야 하는데, CUBE IDE에서는 간단하게 GUI를 통해 생성할 수 있다.

I2C1와 USART1을 각각 활성화시킨다. (생략, 이 전글들 참고 바람)

USART1는 기본 115200을 사용할 것이므로 별도의 설정을 할 필요는 없지만 I2C1은 속도를 설정해주어야 한다.

AM1008W-K-P 센서는 30kbps 이하에서 동작하는 것이 스펙이다.

I2C1은 default 설정으로 standard 모드로 100kbps이다. 

100kbps는 오버 스피드이므로 통신 속도를 스펙대로 낮출 필요가 있다.

I2C Speed를 30,000Hz로 변경한다.

STM32F103은 마스터로 동작하기 때문에 Slave Features는 건드릴 필요가 없다.

GPIO 설정으로 들어가 I2C Maximum output 스피드가 기본 High로 되어 있는데 Medium이나 Low 로 떨춰주어야 한다.

해당 핀맵을 통해 내장 GPIO Pull-up이 없기에 외장 Pull-up 저항을 써야하는 것을 알 수 있다.

이렇게 되면 설정은 완료되었고 코드를 생성한다.

여기서 UART를 활성화한 이유는 UART to Serial 을 통해 컴퓨터에서 값을 확인하기 위해서이다.

2. AM1008W-P-K 라이브러리

우리는 아두이노 글에서 AM1008W-K-P를 테스트하였다.

운이 좋게도 github에 코드(아두이노 + C++)들이 올라와 있었고 우리는 이를 STM32 + C언어로 변경해주면 된다.

여기서 팁 하나.

https://github.com/neosarchizo/am1008w_k_i2c/tree/main/src

am1008w_k_i2c/src at main · neosarchizo/am1008w_k_i2c

이제 개발자들도 조금 개발하는 스타일을 조금 스마트하게 가져갈 필요가 있다.

그것은 바로 chatgpt 이용하는 방법이다.

우리는 C++로 설계된 라이브러리를 C언어로 변경해야 하는데 GPT에게 던지면 간단히 변경할 수 있다. (나는 GPT4를 사용하는데 3.5는 성능이 어느정도 인지는 잘모르겠다.) 

방법은 간단하다. 코드를 그대로 던져서 변경해달라고 하면 된다. 사소한 내용들은 debug하면 된다.

gpt가 c언어로 변경한 소스코드들이다. 

3. am1008w_k_i2c.h

/*
 * am1008w_k_i2c.h
 *
 *  Created on: Jul 17, 2024
 *      Author: Yoon
 */

#ifndef SRC_AM1008W_K_I2C_H_
#define SRC_AM1008W_K_I2C_H_

#include <stdint.h>
#include "main.h"

#define AM1008W_K_I2C_ADDRESS 0x28

#define AM1008W_K_I2C_FRAME_STX 0x16
#define AM1008W_K_I2C_LEN_READ_DATA_COMMAND 25

#define AM1008W_K_I2C_PSO_CLOSE 0x00
#define AM1008W_K_I2C_PSO_TIMING_MEASURING_MODE 0x05
#define AM1008W_K_I2C_PSO_DYNAMIC_MEASURING_MODE 0x06
#define AM1008W_K_I2C_PSO_CONTINOUS_MEASURING_MODE 0x0C
#define AM1008W_K_I2C_PSO_SINGLE_MEASURING_MODE 0x0D

#define AM1008W_K_I2C_CTRL_CLOSE_MEASUREMENT 0x01
#define AM1008W_K_I2C_CTRL_OPEN_MEASUREMENT 0x02
#define AM1008W_K_I2C_CTRL_CO2_CALIBRATION 0x03
#define AM1008W_K_I2C_CTRL_SET_UP_TIMING_MEASUREMENT 0x05
#define AM1008W_K_I2C_CTRL_SET_UP_DYNAMIC_MEASUREMENT 0x06
#define AM1008W_K_I2C_CTRL_SET_UP_PM_CALIBRATION_COEFFICIENT 0x07
#define AM1008W_K_I2C_CTRL_SET_UP_CONTINUOUSLY_MEASUREMENT 0x0C
#define AM1008W_K_I2C_CTRL_SET_UP_SINGLE_MEASUREMENT 0x0D

typedef union
{
    uint8_t value;
    struct
    {
        uint8_t fan_at_high_revolving_speed:1;
        uint8_t fan_at_low_revolving_speed:1;
        uint8_t working_temperature_is_high:1;
        uint8_t working_temperature_is_low:1;
    } bits;
} am1008w_k_i2c_status;

#ifdef __cplusplus
extern "C" {
#endif

void am1008w_k_i2c_begin(I2C_HandleTypeDef *hi2c);
uint8_t am1008w_k_i2c_pm_sensor_mode_close();
uint8_t am1008w_k_i2c_pm_sensor_mode_open();
uint8_t am1008w_k_i2c_pm_sensor_mode_single_measurement(uint16_t range);
uint8_t am1008w_k_i2c_pm_sensor_mode_continuously_measurement();
uint8_t am1008w_k_i2c_pm_sensor_mode_timing_measurement(uint16_t range);
uint8_t am1008w_k_i2c_pm_sensor_mode_dynamic_measurement();
uint8_t am1008w_k_i2c_set_pm_coefficient(uint8_t range);
uint8_t am1008w_k_i2c_calibrate_co2(uint16_t range);
uint8_t am1008w_k_i2c_read_data_command();
uint8_t am1008w_k_i2c_get_pm_operation_mode();
uint16_t am1008w_k_i2c_get_co2();
uint16_t am1008w_k_i2c_get_voc();
int am1008w_k_i2c_get_humidity();
int am1008w_k_i2c_get_temperature();
uint16_t am1008w_k_i2c_get_pm1p0();
uint16_t am1008w_k_i2c_get_pm2p5();
uint16_t am1008w_k_i2c_get_pm10();
uint16_t am1008w_k_i2c_get_voc_now_r_ref_r();
uint16_t am1008w_k_i2c_get_voc_ref_r();
uint16_t am1008w_k_i2c_get_voc_now_r();
am1008w_k_i2c_status am1008w_k_i2c_get_pm_sensor_status_alarm();

#ifdef __cplusplus
}
#endif

#endif /* SRC_AM1008W_K_I2C_H_ */

4. am1008w_k_i2c.c

/*
 * am1008w_k_i2c.c
 *
 *  Created on: Jul 17, 2024
 *      Author: Yoon
 */
#include "am1008w_k_i2c.h"

static I2C_HandleTypeDef *mhi2c;
static uint8_t _buffer[32];
static uint8_t _pm_operation_mode;
static uint16_t _co2;
static uint16_t _voc;
static int _humidity;
static int _temperature;
static uint16_t _pm1p0;
static uint16_t _pm2p5;
static uint16_t _pm10;
static uint16_t _voc_now_r_ref_r;
static uint16_t _voc_ref_r;
static uint16_t _voc_now_r;
static am1008w_k_i2c_status _pm_sensor_status_alarm;

void am1008w_k_i2c_begin(I2C_HandleTypeDef *hi2c) {
    mhi2c = hi2c;
}

uint8_t am1008w_k_i2c_send_command_data(uint8_t ctrl, uint16_t data) {
    uint8_t tx_data[7] = {0};
    tx_data[0] = AM1008W_K_I2C_FRAME_STX;
    tx_data[1] = 7; // FRAME LENGTH
    tx_data[2] = ctrl; // Control Command of the PM Sensor
    tx_data[3] = (data >> 8) & 0xff; // high byte of data
    tx_data[4] = data & 0xff; // low byte of data
    tx_data[5] = 0;

    uint8_t cs = tx_data[0];
    for (uint8_t i = 1; i < 6; i++) {
        cs ^= tx_data[i];
    }
    tx_data[6] = cs;

    HAL_I2C_Master_Transmit(mhi2c, AM1008W_K_I2C_ADDRESS << 1, tx_data, 7, HAL_MAX_DELAY);

    return 0;
}

uint8_t am1008w_k_i2c_pm_sensor_mode_close() {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_CLOSE_MEASUREMENT, 0);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_open() {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_OPEN_MEASUREMENT, 0);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_single_measurement(uint16_t range) {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_SINGLE_MEASUREMENT, range);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_continuously_measurement() {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_CONTINUOUSLY_MEASUREMENT, 0);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_timing_measurement(uint16_t range) {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_TIMING_MEASUREMENT, range);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_dynamic_measurement() {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_DYNAMIC_MEASUREMENT, 0);
}

uint8_t am1008w_k_i2c_set_pm_coefficient(uint8_t range) {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_PM_CALIBRATION_COEFFICIENT, range);
}

uint8_t am1008w_k_i2c_calibrate_co2(uint16_t range) {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_CO2_CALIBRATION, range);
}

uint8_t am1008w_k_i2c_read_data_command() {

    HAL_I2C_Master_Receive(mhi2c, (AM1008W_K_I2C_ADDRESS << 1) | 1, _buffer, 25, HAL_MAX_DELAY);

    uint8_t idx = 0;

    if (_buffer[0] != AM1008W_K_I2C_FRAME_STX) {
        return 2; // Frame header different
    }

    if (_buffer[1] != AM1008W_K_I2C_LEN_READ_DATA_COMMAND) {
        return 3; // Frame length different
    }

    uint8_t check_code = _buffer[0];
    for (uint8_t i = 1; i < AM1008W_K_I2C_LEN_READ_DATA_COMMAND - 1; i++) {
        check_code ^= _buffer[i];
    }

    if (_buffer[AM1008W_K_I2C_LEN_READ_DATA_COMMAND - 1] != check_code) {
        return 4; // Checksum wrong
    }

    _pm_operation_mode = _buffer[2];
    _co2 = (_buffer[3] << 8) + _buffer[4];
    _voc = (_buffer[5] << 8) + _buffer[6];
    _humidity = ((_buffer[7] << 8) + _buffer[8]);
    _temperature = ((_buffer[9] << 8) + _buffer[10] - 500);
    _pm1p0 = (_buffer[11] << 8) + _buffer[12];
    _pm2p5 = (_buffer[13] << 8) + _buffer[14];
    _pm10 = (_buffer[15] << 8) + _buffer[16];
    _voc_now_r_ref_r = (_buffer[17] << 8) + _buffer[18];
    _voc_ref_r = (_buffer[19] << 8) + _buffer[20];
    _voc_now_r = (_buffer[21] << 8) + _buffer[22];
    _pm_sensor_status_alarm.value = _buffer[23];

    return 0;
}

uint8_t am1008w_k_i2c_get_pm_operation_mode() {
    return _pm_operation_mode;
}

uint16_t am1008w_k_i2c_get_co2() {
    return _co2;
}

uint16_t am1008w_k_i2c_get_voc() {
    return _voc;
}

int am1008w_k_i2c_get_humidity() {
    return _humidity;
}

int am1008w_k_i2c_get_temperature() {
    return _temperature;
}

uint16_t am1008w_k_i2c_get_pm1p0() {
    return _pm1p0;
}

uint16_t am1008w_k_i2c_get_pm2p5() {
    return _pm2p5;
}

uint16_t am1008w_k_i2c_get_pm10() {
    return _pm10;
}

uint16_t am1008w_k_i2c_get_voc_now_r_ref_r() {
    return _voc_now_r_ref_r;
}

uint16_t am1008w_k_i2c_get_voc_ref_r() {
    return _voc_ref_r;
}

uint16_t am1008w_k_i2c_get_voc_now_r() {
    return _voc_now_r;
}

am1008w_k_i2c_status am1008w_k_i2c_get_pm_sensor_status_alarm() {
    return _pm_sensor_status_alarm;
}

5. main.c

#include "main.h"
#include am1008w_k_i2c.h

/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

...

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_I2C1_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  am1008w_k_i2c_begin(&hi2c1);

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  char buffer[100];

  while (1)
  {

	  am1008w_k_i2c_read_data_command();

	  int humidity = am1008w_k_i2c_get_humidity();
	  int temperature = am1008w_k_i2c_get_temperature();

	  uint16_t voc = am1008w_k_i2c_get_voc();
	  uint16_t co2 = am1008w_k_i2c_get_co2();
	  uint16_t pm1p0 = am1008w_k_i2c_get_pm1p0();
	  uint16_t pm2p5 = am1008w_k_i2c_get_pm2p5();
	  uint16_t pm10  = am1008w_k_i2c_get_pm10();

	  sprintf(buffer, "Humidity: %d.%02d %%, Temperature: %d.%02d C\r\n",
			  humidity / 10, humidity % 10, temperature / 10, temperature % 10);

	  HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), 1000);

	  sprintf(buffer, "CO2: %d ppm, VOC: %d ppb, PM1.0: %d, PM2.5: %d, PM10: %d\r\n",
	                  co2, voc, pm1p0, pm2p5, pm10);

	  HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), 1000);
	  HAL_Delay(1000);


    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */
}

아예 GPT가 생성해준 코드를 그대로 갖다쓴건 아니고, 내가 어느 정도 디버깅을 한 코드들이다.

6. 회로 구성

이 회로와 똑같이 구성을 해주었다. 다만 10K옴을 4.7K옴으로 대체하였다. (외부 풀업 저항을 사용해야 함.)

7. 동작 확인

정상적으로 동작하는 것을 확인하였으며 모니터를 통해 데이터가 제대로 출력되는 것을 확인한다.

https://youtube.com/shorts/TRYy-_zhIGg?si=BBddmJtvnHsqUXOM

다음 글로는 FTDI 를 블루투스로 대체하고, 현재 String으로 데이터를 표출하는데 패킷을 절약할 수 있게끔 코드를 변경할 예정이다.

또한 블루투스는 무선 통신이니 그 패킷에 가능하다면 Checksum 로직을 추가하여 데이터의 신뢰성을 높여볼 것이다.

내가 생성한 라이브러리는 첨부파일로 추가해놓으니 참고하면 좋을 것 같다.

am1008w_k_i2c.zip

0.00MB