В последнее время разработчики электроники испытывают трудности с поставками электронных компонентов. Одним из решений данной проблемы является переход на "исконно китайскую" элементную базу. Это решение подкупает ценой и доступностью, но пугает плохой документацией и небольшим количеством информации на понятных нам языках. В данной публикации расскажу о любопытном микроконтроллере на ядре RISC-V и сделаю простое первое устройство - датчик концентрации углекислого газа в воздухе/мигалку OLED дисплеем и светодиодом (куда ж без мигалки светодиодом). В репозитории размещен проект для тех, кто захочет воспользоваться данными наработками.

Вступление

Достаточно часто я слышал про ядро RISC-V и его нарастающую популярность. Мне захотелось попробовать микроконтроллер на этом ядре. Микрон недавно выпустил достаточно мощный МК на ядре RISC-V, но его закупку я даже не рассматривал, так как частному лицу достаточно сложно получить отладочный комплект для российского микроконтроллера.

Так же мне попадались МК CH32 от китайской фирмы WCH. Она широко известна преобразователем USB-UART CH340. Я посмотрел документацию и решил заказать младший МК из семейства RISC-V. Меня ждал приятный сюрприз: на али за 1400 рублей предлагают две демонстрационные платы, программатор и по пять МК одним лотом!

CH32V003 позиционируется как замена восьмибитного МК STM8S003F3, совместим с ним по ногам, но обладает большим быстродействием. Стоимость CH32V003 порядка 25 рублей за штуку. Так же немаловажно, что данный МК поставляется российскими поставщиками электронных компонентов.

Мигаем светодиодом

Мигание светодиодом - канон первого действия при программировании МК. В аппаратной части для этого достаточно демонстрационной платы, программатора и нескольких проводов.

Первым шагом станет установка среды разработки. Производитель рекомендует MounRiver Studio. Основа данной среды - Eclipse. Я бы порекомендовал выбирать расположение среды так, чтобы путь к папке и имя пользователя в операционной системе не содержали кириллицы (с данной средой не проверял, но уже имел неприятный опыт работы с другими средами разработки на базе Eclipse, которые отказывались работать)

Вторым шагом необходимо скачать SDK с сайта производителя МК. Внизу станицы есть ссылка на скачивание ZIP архива со схемой демонстрационной платы и примерами ПО. Распаковываем архив в рабочую папку.

Копируем проект GPIO_Toggle в отдельную папку с сохранением уровня вложенности папок. Я переименовал проект в Habr_CO2.

Отрываем проект в среде разработки. Пример GPIO_Toggle управляет светодиодом, подключенным к порту PD_0. В моем устройстве светодиод подключен к порту PD_3.

В инициализации и в бесконечном цикле мигания меняем номер вывода порта:

void GPIO_Toggle_INIT(void)
{
    GPIO_InitTypeDef GPIO_InitStructure = {0};

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;//здесь был GPIO_Pin_0
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOD, &GPIO_InitStructure);
}
...
  while(1)
    {
        Delay_Ms(500);
        GPIO_WriteBit(GPIOD, GPIO_Pin_3, (i == 0) ? (i = Bit_SET) : (i = Bit_RESET));
    }
//и в строке выше был GPIO_Pin_0

Теперь можно скомпилировать проект. Нажимаем Project -> Build Project. После компиляции нажимаем Flash -> Download, дожидаемся окончания прошивки, судорожно нажимаем Reset или выключаем и включаем МК - ничего не работает! А все потому, что мы изменили имя проекта и имя файла hex тоже изменилось. А среда разработки прошивает старый файл hex. Нажимаем Flash -> Configuration, в поле Target File: выбираем Habr_CO2.hex. Теперь после прошивки светодиод будет мигать (у меня все работает).

Работаем с I2C

Как говорила преподавательница по матану в МАИ (первый факультет, кто был там, вспомнит): "Внимательный слушатель заме...етит", что в схеме нет подтягивающих резисторов шины I2C к "+" питания, но все работает, так как на платах датчика CO2 и дисплея данные резисторы есть. Начнем с OLED дисплея. Он сделан на контроллере ssd1306 и про него написаны гигабайты текста, множество библиотек, так что описывать подробно работу с дисплеем я не стану. Для работы с дисплеем нужен интерфейс I2C. Посмотрев примеры работы с I2C накатывает ностальгия по простым готовым решениям от фирмы ST. Но что делать - придется писать HAL и дорабатывать библиотеку работы с дисплеем.

На данный момент я сделал библиотеку работы с I2C в блокирующем режиме. Микроконтроллеры STM приучили меня, что блокирующие функции работы с интерфейсами (а по-хорошему и не с интерфейсами) должны быть защищены от зависания - например выполнять в теле функции проверку времени ее исполнения, и при превышении оного выходить из функции и возвращать ошибку TIMEOUT. Для отсчета времени используется SysTick таймер. Реализацию базовых функций системного таймера я вынес в отдельную библиотеку, которую необходимо подключить в проект.

Чтобы не таскать все библиотеки HAL в каждый проект, я положил их в папку на одном уровне с папкой проекта. Чтобы проект нормально собирался, надо указать компилятору путь к этой папке. Для этого открываем свойства проекта нажав Project -> Properties. В открывшемся окне в списке выбираем C/C++ General -> Path and symbols, в поле Languages переключаем на GNU C и в поле include directories добавляем строку "/${ProjName}/HAL". Эта строка позволит подключить внешнюю папку к проекту.

В дереве проекта щелкаем правой кнопкой мыши по имени проекта и добавляем папку командой Add -> External Linked Folder. Файлы внутри папки добавятся автоматически.

При создании библиотеки "i2c_hal.h" я опирался на пример I2C_EEPROM. Инициализацию интерфейса взял из примера. Подробно не буду разбирать функцию, так как стандартная инициализация покроет ~95% всех случаев работы с интерфейсом.

На картинке ниже вызывается ведомое устройство с адресом 0b1101000 для последующей передачи данных от ведущего к ведомому. На верхней схеме сигналов ведомое устройство ответило, что готово принимать данные, а на нижней ответа не поступило (например устройства с таким адресом на шине нет).

Передачу некоторого количества байт вынесем в функцию:

uint8_t HAL_I2C_Transmit (I2C_TypeDef *i2c_periph, 
                          uint8_t DevAddress, 
                          uint8_t *pData, 
                          uint16_t Size, 
                          uint32_t i2c_timeout)

Рассмотрим аргументы функции:

1. I2C_TypeDef *i2c_periph - указатель на структуру, содержащую сведения об интерфейсе. Так как I2C в данном МК один, то возможный вариант только один: I2C1;

2. uint8_t DevAddress - адрес ведомого устройства;

3. uint8_t *pData - указатель на массив байт, который требуется передать;

4. uint16_t Size - количество байт, которые требуется передать;

5. uint32_t i2c_timeout - максимальное время пребывания в функции в отсчетах системного таймера (миллисекундах).

При входе в любую функцию передачи или приема данных создаем переменную и записываем в нее текущее значение системного таймера. Это значение будет использовано для вычисления Timeout-а.

uint32_t tickstart = get_tick();

Перед тем, как генерировать сигнал старт, необходимо убедиться, что шина не занята. Проверяем флаг I2C_FLAG_BUSY и ждем, когда он сбросится, но не дольше установленного времени пребывания в функции. После сброса флага генерируем старт и ждем установки флага I2C_EVENT_MASTER_MODE_SELECT. Это значит, что наше устройство захватило управление шиной.

/* i2c master sends start signal only when the bus is idle */
while((I2C_GetFlagStatus( i2c_periph, I2C_FLAG_BUSY ) != RESET) && (get_tick() - tickstart < i2c_timeout)) ;

    if(get_tick() - tickstart < i2c_timeout) {
        } else {
                return I2C_BUSY;
                }
/* send the start signal */
I2C_GenerateSTART( i2c_periph, ENABLE );

while(!I2C_CheckEvent( I2C1, I2C_EVENT_MASTER_MODE_SELECT )  && (get_tick() - tickstart < i2c_timeout)) ;
      
    if(get_tick() - tickstart < i2c_timeout) {
        } else {
                return I2C_BUSY;
                }

Теперь можно отправить адрес ведомого устройства. Надо учитывать, что адрес должен быть сдвинут на один бит влево, так как младший бит будет обозначать направление передачи данных (с данным вопросом у меня часто возникает путаница, например в библиотеках МК фирмы Nordic не надо сдвигать адрес влево). Чтобы установить младший бит адреса в режим передачи данных в качестве второго аргумента функции I2C_Send7bitAddress укажем I2C_Direction_Transmitter. Прежде чем передавать данные, дождемся ответа от ведомого, если такой адрес есть на шине. Для этого будем проверять установку флага I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED. Если ведомого с указанным адресом не окажется на шине, от зависания нас спасет проверка времени нахождения в функции. Функция пошлет на шину I2C сигнал стоп и вернет значение I2C_ADDR_NACK.

I2C_Send7bitAddress( i2c_periph, DevAddress, I2C_Direction_Transmitter );

/* address flag set means i2c slave sends ACK */
while((!I2C_CheckEvent( i2c_periph, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED )) && (get_tick() - tickstart < i2c_timeout));

    if(get_tick() - tickstart < i2c_timeout) {
      } else {
              I2C_GenerateSTOP( i2c_periph, ENABLE );
              return I2C_ADDR_NACK;
              }

Передаем полезную информацию. В цикле передаем один байт функцией I2C_SendData( i2c_periph, *pData ) , инкрементируем указатель на буфер, чтобы на следующем проходе передать следующий байт и ждем, когда установится флаг окончания передачи I2C_EVENT_MASTER_BYTE_TRANSMITTED. После успешной передачи данных отправляем на шину сигнал СТОП и возвращаем I2C_OK.

for(count = 0; count < Size; count ++) {

  I2C_SendData( i2c_periph, *pData );
  /* increment pointer to the next byte to be written */
  pData++;
  /* wait until transmission complete */
  while((!I2C_CheckEvent( i2c_periph, I2C_EVENT_MASTER_BYTE_TRANSMITTED )) && (get_tick() - tickstart < i2c_timeout));
  
  if(get_tick() - tickstart < i2c_timeout) {
      } else {
              I2C_GenerateSTOP( i2c_periph, ENABLE );
              return I2C_TIMEOUT;
              }
}

  I2C_GenerateSTOP( i2c_periph, ENABLE );
return I2C_OK;

Теперь рассмотрим функцию приема массива байт:

uint8_t HAL_I2C_Receive (I2C_TypeDef *i2c_periph, 
                          uint8_t DevAddress, 
                          uint8_t *pData, 
                          uint16_t Size, 
                          uint32_t i2c_timeout)

Аргументы функции приема такие же, как и у функции передачи, с разницей лишь в том, что передается указатель на массив, в который будут помещены данные и количество байт, которые необходимо принять.

Запрос ведомого устройства на прием данных отличается незначительно от передачи ему данных. При отправке адреса ведомого устройства на шину, необходимо установить младший бит адреса в "1". Изменим второй аргумент функции I2C_Send7bitAddress( i2c_periph, DevAddress, I2C_Direction_Receiver ). Затем дождемся установки флага I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED и переведем МК в режим ACK вызвав функцию I2C_AcknowledgeConfig( i2c_periph, ENABLE ).

/* i2c master sends start signal only when the bus is idle */
while((I2C_GetFlagStatus( i2c_periph, I2C_FLAG_BUSY ) != RESET) && (get_tick() - tickstart < i2c_timeout)) ;

if(get_tick() - tickstart < i2c_timeout) {
    } else {
            return I2C_BUSY;
            }

/* send the start signal */
I2C_GenerateSTART( I2C1, ENABLE );
while(!I2C_CheckEvent( I2C1, I2C_EVENT_MASTER_MODE_SELECT )  && (get_tick() - tickstart < i2c_timeout)) ;

if(get_tick() - tickstart < i2c_timeout) {
    } else {
            I2C_GenerateSTOP( i2c_periph, ENABLE );
            return I2C_BUSY;
            }

I2C_Send7bitAddress( i2c_periph, DevAddress, I2C_Direction_Receiver );
/* address flag set means i2c slave sends ACK */
while((!I2C_CheckEvent( i2c_periph, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED )) && (get_tick() - tickstart < i2c_timeout));

if(get_tick() - tickstart < i2c_timeout){
    } else {
            I2C_GenerateSTOP( i2c_periph, ENABLE );
            return I2C_ADDR_NACK;
            }

I2C_AcknowledgeConfig( i2c_periph, ENABLE );

Принимаем данные от ведомого. В цикле ждем установки флага I2C_FLAG_RXNE, то есть пока в буфере не окажется очередной байт данных. Затем помещаем принятый байт в массив *pData = I2C_ReceiveData( i2c_periph ) и инкрементируем указатель на этот массив pData++. После приема предпоследнего байта необходимо указать ведомому, что следующий байт последний. Когда счетчик count будет равен номеру предпоследнего байта, вызовем функцию I2C_AcknowledgeConfig( i2c_periph, DISABLE ). по окончанию приема данных проверяем, не превысило ли время TIMEOUT, если нет - то данные приняты успешно, можно послать сигнал СТОП.

 for(count = 0; count < Size; count ++)
  {
      /* wait until data received */
      while((I2C_GetFlagStatus( i2c_periph, I2C_FLAG_RXNE ) ==  RESET) && (get_tick() - tickstart < i2c_timeout));

      if( count == (Size-2) )
              {
               /*before receiving last byte and after receiving byte-1 disable ACK for last byte */
              I2C_AcknowledgeConfig( i2c_periph, DISABLE );
              }

      /* receive data and store in buffer */
      *pData = I2C_ReceiveData( i2c_periph );
      pData++;
  }

      /* check timeout while receiving data */
      if(get_tick() - tickstart > i2c_timeout)
          {
           I2C_GenerateSTOP( i2c_periph, ENABLE );
           return I2C_TIMEOUT;
          }

      I2C_GenerateSTOP( i2c_periph, ENABLE );

return I2C_OK;

Этого достаточно для работы с интерфейсом I2C (кого-то устраивают библиотеки на регистрах или программный I2C), но после общения с STM32 мне нравятся функции чтения и записи регистров/памяти ведомого устройства.

uint8_t HAL_I2C_Mem_Write (I2C_TypeDef *i2c_periph, 
                           uint8_t DevAddress, 
                           uint8_t MemAddress, 
                           uint8_t *pData, 
                           uint16_t Size, 
                           uint32_t i2c_timeout)

uint8_t HAL_I2C_Mem_Read (I2C_TypeDef *i2c_periph, 
                          uint8_t DevAddress, 
                          uint8_t MemAddress, 
                          uint8_t *pData, 
                          uint16_t Size, 
                          uint32_t i2c_timeout)

Функция HAL_I2C_Mem_Write представляет собой ту же самую функцию передачи данных ведомому с добавлением перед массивом байт одного байта внутреннего адреса памяти/регистра uint8_t MemAddres.

Функция HAL_I2C_Mem_Read совмещает в себе передачу одного байта адреса памяти/регистра ведомому и приема массива данных от ведомого.

Время помигать дисплеем

В качестве основы я использую данную библиотеку работы с SSD1306 достаточно давно на разнообразных МК. Скопируем папку с библиотекой дисплея и шрифтом в папку User в корне проекта. Добавим в дерево проекта папку ssd1306 командой Add -> Existing Folder пропишем в меню Path & Symbols /${ProjName}/User/ssd1306 по аналогии с библиотекой HAL.

Изменения коснулись функций SSD1306_writecommand и SSD1306_UpdateScreen. В них были заменены функции передачи данных по I2C на вышеописанные функции для CH32V003. В файле "SSD1306.h" подключаем новые библиотеки #include "i2c_hal.h" и #include "systick_hal.h". В main.c подключаем #include "SSD1306.h" и #include "systick_hal.h" и приступаем к работе с дисплеем.

Перед бесконечным циклом инициализируем SysTick, I2C, ssd1306 и управляем дисплеем в бесконечном цикле. Так же меняем все задержки с Delay_Ms(500) на delay_1ms(500), так как эта функция сделана для работы вместе с системным таймером.

В функцию HAL_I2C_Init передаем частоту работы интерфейса в герцах и собственный адрес МК на шине I2C как ведомого устройства (в данном примере не используется, но функция инициализации производителем написана так).

В бесконечном цикле буфер дисплея заполняем черным цветом, формируем строку символов "Blink OFF". Начиная с верхнего левого угла на дисплей выводится строка символов и буфер выводится на дисплей. Затем, после задержки в полсекунды, дисплей заполняется белым и выводится новая строка.

uint8_t buff[32];
    Systick_Init ();
    HAL_I2C_Init(400000, 0xEE);
    SSD1306_Init();


    while(1)
    {
        SSD1306_Fill(SSD1306_COLOR_BLACK);
        sprintf (buff,"Blink OFF");
        SSD1306_GotoXY(0, 0);
        SSD1306_Puts(buff, &Font_11x18, SSD1306_COLOR_WHITE);
        SSD1306_UpdateScreen();
        delay_1ms(500);

        SSD1306_Fill(SSD1306_COLOR_WHITE);
        sprintf (buff,"Blink ON");
        SSD1306_GotoXY(0, 0);
        SSD1306_Puts(buff, &Font_11x18, SSD1306_COLOR_BLACK);
        SSD1306_UpdateScreen();
        delay_1ms(500);

        GPIO_WriteBit(GPIOD, GPIO_Pin_3, (i == 0) ? (i = Bit_SET) : (i = Bit_RESET));
    }

Тяжелая гиф мигания дисплеем

Измеряем концентрацию CO2

Для некоторых опытов с медицинским аппаратом я заказал модуль датчика CO2 SCD41.

Датчик работает по фотоакустическому принципу измерения. При воздействии ИК света на молекулы CO2 они начинают колебаться, что регистрируется микрофоном и обрабатывается встроенным МК (в общих чертах, как я понял). Данный датчик снабжен системой автоматической калибровки. Он регистрирует минимальное значение CO2 в окружающей среде, и принимает его за 400 ppm (концентрация углекислого газа в атмосфере у земли). Это значит, что помещение, в котором расположен датчик, хоть изредка, но проветривается до атмосферного уровня CO2. Из этого следует, что датчик в режиме автокалибровки не стоит помещать в атмосферу чистого газа. Я поместил его в атмосферу кислорода (по нормам содержание CO2 менее 100 ppm) и датчик стал сильно завышать показания. В своих опытах я отключаю автоматическую калибровку, но для бытового применения этого не требуется.

Для работы с датчиком существуют библиотека Arduino, но она написана на C++ и все равно не для CH32V003, так что я сделал свою реализацию. Копируем папку с библиотекой scd4x в проект и добавляем путь к ней, как это уже делали с библиотекой для ssd1306.

Чтобы улучшить переносимость библиотеки датчика, над функциями передачи и приема данных сделаем абстракции:

uint8_t scd4x_transmit_data (uint8_t *pData, uint16_t Size)
{
    return HAL_I2C_Transmit(I2C_SCD4x, SCD4x_SLAVE_ADDR, pData, Size, I2C_Timeout);
}

uint8_t scd4x_receive_data (uint8_t *pData, uint16_t Size)
{
    return HAL_I2C_Receive(I2C_SCD4x, SCD4x_SLAVE_ADDR, pData, Size, I2C_Timeout);
}

Команды датчика состоят из двух байт (список команд и их значение можно посмотреть в описании на датчик). Отправку команд так же вынесем в отдельную функцию:

uint8_t scd4x_send_command (uint16_t command)
{
    uint8_t buff[2];
    buff [0] = (uint8_t)(command>>8);
    buff [1] = (uint8_t)command;
    return scd4x_transmit_data(buff, 2);
}

В данном проекте ограничусь тремя функциями работы с датчиком. Первую необходимо будет вызвать для запуска периодических измерений.

uint8_t scd4x_Init(void)
{
    uint8_t err_code;
    err_code = scd4x_send_command (SCD4x_START_PERIODIC_MEASUREMENT);
    return err_code;
}

С инициализацией вряд ли возникнут сложности. Функция чтения данных от датчика уже несколько сложнее:

uint8_t scd4x_read_measurement(uint16_t* co2_conc, int16_t* temp, uint16_t* humidity)
{
    uint8_t buff [10];
    uint8_t err_code = 0;
    scd4x_send_command (SCD4x_READ_MEASUREMENT);
    err_code = scd4x_receive_data (buff, 9);
    if (err_code != 0)
    {
        return err_code; //return i2c err code in case of i2c troubles
    }
    if (buff[2] != sensirion_common_generate_crc(buff,2)
       ||buff[5] != sensirion_common_generate_crc(&buff[3],2)
       ||buff[8] != sensirion_common_generate_crc(&buff[6],2))
    {
        return 0xFF;//crc error
    }
    *co2_conc = ((uint16_t)buff[0]<<8) + buff[1];
    *temp = (int32_t)(((uint16_t)buff[3]<<8) + buff[4])*175/65535 - 45;
    *humidity = (int32_t)(((uint16_t)buff[3]<<8) + buff[4])*1000/65535;
    return 0;
}

В качестве аргументов в данную функцию необходимо передать указатели на переменные, в которые будет помещено значение концентрации CO2 в ppm, температуры в градусах Цельсия и относительной влажности в процентах*10. В теле функции посылаем команду чтения значения SCD4x_READ_MEASUREMENT, принимаем 9 байт от датчика. Проверяем, не произошло ли каких-то проблем на шине I2C, и если они случились, то возвращаем код ошибки. Затем сравниваем контрольные суммы каждого значения с рассчитанной контрольной суммой. Функцию sensirion_common_generate_crc любезно предоставил производитель датчика. Если в одном из значений контрольная сумма не совпала - возвращаем crc_error. Затем приводим значения к реальным по формулам, указанным в описании, и возвращаем 0 как свидетельство того, что значения приняты успешно. В данном примере можно заметить, что при вычислении температуры сильно теряется точность, но датчик потребляет достаточно много энергии (средний ток 15 мА) и данный показатель показывает температуру датчика, но не окружающего воздуха. Данное измерение требуется для коррекции показаний внутри датчика.

В создании библиотеки работы с I2C мне очень помог логический анализатор. Я купил его не так давно и теперь не представляю своей жизни без него. Раньше интерфейсы отлаживал с использованием осцилографа, приходилось импульсы считать. А логический анализатор дает красивую и понятную картинку. В качестве примера рассмотрим функцию чтения scd4x_read_measurement в логическом анализаторе.

После сигнала СТАРТ (S) ведущий отправляет 0xC4 - это адрес ведомого 0x62<<1 с добавлением бита ЗАПИСЬ(W), получает от него ответ ACK(A), затем ведущий отправляет команду чтения данных от датчика 0xEC 0x05 (SCD4x_READ_MEASUREMENT). При передаче последнего байта ведомый ответил ACK, но ведущий уже закончил передачу и сгенерировал СТОП (P).

Для приема данных ведущий снова отправляет на шину СТАРТ (S), затем 0xC5 - это адрес ведомого 0x62<<1 с добавлением бита ЧТЕНИЕ(R), получает от ведомого ответ ACK(A) и начинает принимать данные. В конце каждого принятого байта ведущий отвечает ведомому ACK(A), и только при приеме последнего байта NACK(N), что видно на картинке ниже. Всего ведущий принимает 9 байт от ведомого, как и запланировано.

Так как период измерений составляет 5 секунд, а между измерениями датчик неохотно делится измеренными показаниями, нам необходимо проверять состояние готовности данных.

uint8_t scd4x_is_data_ready(void)
{
    uint8_t buff [3];
    uint16_t status = 0;
    uint8_t err_code = 0;
    scd4x_send_command (SCD4x_GET_DATA_READY_STATUS);
    err_code = scd4x_receive_data (buff, 3);
    if (err_code != 0)
    {
        return err_code; //return i2c err code in case of i2c troubles
    }
    status = ((uint16_t)buff[0]<<8) + buff[1];
    status = status & 0x07FF; //set first 5 bits to zero
    if (status)return 0; //return 0 if data is ready
    else return SCD4x_DATA_NOT_READY;
}

Функция похожа на чтение данных. Датчик возвращает значение uint16_t. Когда все младшие 11 бит равны нулю - данные измерения готовы для чтения. Поэтому положим принятые два байта в переменную status и обнулим старшие 5 бит. Если переменная окажется после этого равна 0 - данные готовы и функция вернет 0. Если же не готовы - возвращаем SCD4x_DATA_NOT_READY.

Добавим инициализацию датчика и вывод на дисплей названия устройства "Dushnometr" (написал бы на русском, но шрифт не поддерживает, а кириллицу мне добавлять очень лениво). Объявим переменные, в которых будут храниться данные и состояние датчика. Добавим переменные, хранящие время, для вычисления времени между измерениями значений и массив для формирования строк, выводимых на дисплей.

scd4x_Init();

SSD1306_Fill(SSD1306_COLOR_BLACK);
      sprintf (buff,"Dushnometr");
      SSD1306_GotoXY(0, 0);
      SSD1306_Puts(buff, &Font_11x18, SSD1306_COLOR_WHITE);
      SSD1306_UpdateScreen();
      delay_1ms(1500);

uint16_t co2_conc = 0, rh = 0;
int16_t temp = 0;
uint32_t time = 0, prev_time = 0;
uint8_t sensor_disconnect = 0;
uint8_t err_code;
uint8_t data[32];

Осталось в бесконечном цикле проверять готовность данных, и при готовности читать данные от датчика. Если произойдет разрыв связи с датчиком, после восстановления необходимо будет вызвать функцию инициализации, чтобы запустить измерение.

После выводим на дисплей показания концентрации углекислого газа, температуры, влажности и времени между измерениями. В каждом цикле добавим включение светодиода на 1 миллисекунду для индикации работы программы.

while(1)
    {
        err_code = scd4x_is_data_ready();
        if (err_code == 0) //data ready
            {
                 scd4x_read_measurement(&co2_conc, &temp, &rh);
                 time = (get_tick() - prev_time)/100;
                 prev_time = get_tick();

            }
        else if (err_code != SCD4x_DATA_NOT_READY) //i2c bus error
            {
                 sensor_disconnect = 1;
            }

        if (sensor_disconnect)//sensor reinit
            {
                if (scd4x_Init() == 0){
                    sensor_disconnect = 0;
                    }
            }
        
        SSD1306_Fill(SSD1306_COLOR_BLACK);

        sprintf (data, "CO2:%dppm", co2_conc);
        SSD1306_GotoXY(0, 0);
        SSD1306_Puts(data, &Font_11x18, SSD1306_COLOR_WHITE);

        sprintf (data, "RH:%d.%d  T:%d'C",rh/10, rh%10, temp);
        SSD1306_GotoXY(0, 25);
        SSD1306_Puts(data, &Font_7x10, SSD1306_COLOR_WHITE);

        sprintf (data, "time:%d.%d d/c:%d",time/10, time%10, sensor_disconnect);
        SSD1306_GotoXY(0, 40);
        SSD1306_Puts(data, &Font_7x10, SSD1306_COLOR_WHITE);

        SSD1306_UpdateScreen();
        delay_1ms(10);
        GPIO_WriteBit(GPIOD, GPIO_Pin_3,Bit_RESET);
        delay_1ms(1);
        GPIO_WriteBit(GPIOD, GPIO_Pin_3,Bit_SET);
    }

Для отображения состояния сенсора выведем значение переменной sensor_disconnect на экран. Если вытащить датчик из разъема, то значение этой переменной станет "1", после подключения датчика значение станет снова "0" и показания обновятся по готовности.

Заключение

Работать с МК CH32V003 мне понравилось. Хоть он не обладает библиотеками и конфигуратором, как STM32, но все же несложный и понятный. Данная статья не является инструкцией по изготовлению "Душнометра", а показывает мой способ работы с интерфейсом I2C данного микроконтроллера.

Если вам понравилась данная публикация, то подписывайтесь на мой телегра... Oh, SHI~. У меня же его нет и всем надоела реклама этих ваших каналов!

Надеюсь, что принесу некоторую пользу своей интерпретацией I2C для CH32V003. В репозитории есть заготовка работы с SPI и описанная выше I2C. Буду шаг за шагом приоткрывать завесу китайской тайны.