lcm_i2c.c

Go to the documentation of this file.

/********************************** (C) COPYRIGHT *******************************
 * File Name          : lcm_i2c.c
 * Description        : I2C1 slave: приём/передача протокола LCM (FSM + ISR).
 *
 * Обработчики прерываний:
 *   I2C1_EV_IRQHandler — события шины (ADDR, RXNE, STOP, передача ответа).
 *   I2C1_ER_IRQHandler — ошибки (AF, BERR, OVR, ARLO).
 *
 * Разбор и выполнение команд делегируется в lcm_module.c через
 * LCM_Module_ExecuteSingleByte() / LCM_Module_ExecuteTwoByte().
 *********************************************************************************/
 
#include "lcm_i2c.h"
#include "lcm_module.h"
#include "lcm_led.h"
#include "event_log.h"
#include "ch32v00x_conf.h"
 
/*
 * ---------------------------------------------------------------------------
 * Состояния конечного автомата приёма I2C (только фаза WRITE от мастера)
 * ---------------------------------------------------------------------------
 * WAIT_CMD   — ожидаем первый байт транзакции (код команды).
 * WAIT_PARAM — принята двухбайтовая команда (0x20…0x28), ждём параметр.
 * ARMED_READ — принята команда чтения (0x1C, 0x1D); ответ будет отправлен
 *              при следующем ADDR в режиме slave-transmitter (RepSTART+R).
 * ---------------------------------------------------------------------------
 */
typedef enum {
    LCM_I2C_WAIT_CMD = 0,
    LCM_I2C_WAIT_PARAM,
    LCM_I2C_ARMED_READ
} LCM_I2C_RxState;
 
/* --- Переменные FSM I2C (volatile: изменяются в ISR) --- */
static volatile LCM_I2C_RxState s_i2c_rx_state = LCM_I2C_WAIT_CMD;
static volatile uint8_t s_i2c_cmd;          /* код команды текущей транзакции */
static volatile uint8_t s_i2c_tx_byte;      /* байт для передачи мастеру (READ) */
static volatile uint8_t s_i2c_tx_pending;   /* 1: есть данные для фазы READ */
 
/*********************************************************************
 * @fn      LCM_IsTwoByteCmd
 *
 * @brief   Проверка: команда требует второго байта (параметра).
 *
 * @param   cmd — код команды из первого байта WRITE-транзакции.
 *
 * @return  1 — диапазон 0x20…0x28; 0 — однобайтовая команда.
 */
static uint8_t LCM_IsTwoByteCmd(uint8_t cmd)
{
    return (cmd >= LCM_LAMP_ON && cmd <= LCM_SET_ADDR) ? 1U : 0U;
}
 
/*********************************************************************
 * @fn      LCM_IsReadCmd
 *
 * @brief   Проверка: команда явного чтения регистра (для выбора текста лога).
 *
 * @param   cmd — код команды.
 *
 * @return  1 для LCM_GET_ERROR / LCM_GET_ID, иначе 0.
 *
 * @details Влияет только на формулировку в журнале событий (EventLog).
 *          На выполнение не влияет: READ-фаза вооружается для ЛЮБОЙ
 *          команды (см. LCM_Module_ExecuteSingleByte/ExecuteTwoByte) —
 *          мастер может прочитать код ошибки после любой команды.
 */
static uint8_t LCM_IsReadCmd(uint8_t cmd)
{
    return (cmd == LCM_GET_ERROR || cmd == LCM_GET_ID) ? 1U : 0U;
}
 
/*********************************************************************
 * @fn      LCM_I2C_ResetRx
 *
 * @brief   Сброс машины состояний приёма I2C в начальное состояние.
 *
 * @details Вызывается при STOP и при новой WRITE-транзакции (ADDR+W).
 *          После ExecuteSingleByte()/ExecuteTwoByte() состояние специально
 *          не сбрасывается сразу — см. LCM_I2C_OnRxData().
 */
static void LCM_I2C_ResetRx(void)
{
    s_i2c_rx_state = LCM_I2C_WAIT_CMD;
    s_i2c_cmd = 0U;
    s_i2c_tx_pending = 0U;
}
 
/*********************************************************************
 * @fn      LCM_I2C_OnRxData
 *
 * @brief   Обработка принятого байта данных (slave-receiver).
 *
 * @details Вызывается из RXNE и перед STOP, если в DR остался байт.
 *
 *          Важно: после ExecuteSingleByte()/ExecuteTwoByte() состояние FSM
 *          уже переведено в ARMED_READ (см. LCM_I2C_ArmRead в lcm_module.c —
 *          вооружает ответ кодом ошибки для ЛЮБОЙ команды). Здесь это
 *          состояние специально не сбрасывается: если мастер продолжит
 *          транзакцию RepSTART + Addr+R, придёт код ошибки; если сразу
 *          STOP — состояние сбросит сам обработчик STOPF ниже.
 */
static void LCM_I2C_OnRxData(uint8_t byte)
{
    if (s_i2c_rx_state == LCM_I2C_WAIT_CMD) {
        s_i2c_cmd = byte;
        if (LCM_IsTwoByteCmd(byte)) {
            s_i2c_rx_state = LCM_I2C_WAIT_PARAM;
            return;
        }
 
        LCM_Led_ActivityPulse();
        if (LCM_IsReadCmd(byte)) {
            EventLog_PushI2cReadArm(byte);
        } else {
            /* Включая коды вне известных диапазонов (0x1E/0x1F, 0x29…0xFF) —
               диспетчер сам зафиксирует LCM_ERR_UNKNOWN_CMD. */
            EventLog_PushI2cCmd(byte, 0U, 0U);
        }
        LCM_Module_ExecuteSingleByte(byte);
    } else if (s_i2c_rx_state == LCM_I2C_WAIT_PARAM) {
        LCM_Led_ActivityPulse();
        EventLog_PushI2cCmd(s_i2c_cmd, byte, 1U);
        LCM_Module_ExecuteTwoByte(s_i2c_cmd, byte);
    }
}
 
void LCM_I2C_ArmRead(uint8_t byte)
{
    s_i2c_tx_byte = byte;
    s_i2c_tx_pending = 1U;
    s_i2c_rx_state = LCM_I2C_ARMED_READ;
}
 
void LCM_I2C_Init(uint8_t addr)
{
    GPIO_InitTypeDef gpio = {0};
    I2C_InitTypeDef i2c = {0};
    NVIC_InitTypeDef nvic = {0};
 
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
 
    gpio.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
    gpio.GPIO_Mode = GPIO_Mode_AF_OD;
    gpio.GPIO_Speed = GPIO_Speed_30MHz;
    GPIO_Init(GPIOC, &gpio);
 
    I2C_DeInit(I2C1);
 
    i2c.I2C_ClockSpeed = LCM_I2C_SPEED_HZ;
    i2c.I2C_Mode = I2C_Mode_I2C;
    i2c.I2C_DutyCycle = I2C_DutyCycle_2;
    /* OADDR1: 7-битный адрес сдвинут влево; бит R/W дополняет аппаратура */
    i2c.I2C_OwnAddress1 = (uint16_t)((uint16_t)addr << 1);
    i2c.I2C_Ack = I2C_Ack_Enable;
    i2c.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    I2C_Init(I2C1, &i2c);
 
    I2C_AcknowledgeConfig(I2C1, ENABLE);
 
    nvic.NVIC_IRQChannel = I2C1_EV_IRQn;
    nvic.NVIC_IRQChannelPreemptionPriority = 1;
    nvic.NVIC_IRQChannelSubPriority = 0;
    nvic.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&nvic);
 
    nvic.NVIC_IRQChannel = I2C1_ER_IRQn;
    nvic.NVIC_IRQChannelPreemptionPriority = 1;
    nvic.NVIC_IRQChannelSubPriority = 1;
    nvic.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&nvic);
 
    I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR, ENABLE);
    I2C_Cmd(I2C1, ENABLE);
 
    LCM_I2C_ResetRx();
}
 
/*********************************************************************
 * @fn      I2C1_EV_IRQHandler
 *
 * @brief   Обработчик событий I2C1 (режим slave).
 *
 * @details Протокол: КАЖДАЯ команда сразу вооружает READ-фазу кодом
 *          текущей ошибки (0x00 — нет ошибки), поэтому мастер может либо
 *          завершить транзакцию STOP-ом (результат не читается), либо
 *          продолжить RepSTART + Addr+R и получить код ошибки одной
 *          транзакцией — без отдельной команды GET_ERROR.
 *
 *          Типичные сценарии:
 *
 *          WRITE + READ (однобайтовая команда):
 *            START → Addr+W → cmd → RepSTART → Addr+R → [код ошибки] → STOP
 *
 *          WRITE + READ (двухбайтовая):
 *            START → Addr+W → cmd → param → RepSTART → Addr+R → [код ошибки] → STOP
 *
 *          WRITE + READ (явное чтение ошибки/ID):
 *            START → Addr+W → 0x1C/0x1D → RepSTART → Addr+R → [байт] → STOP
 *
 *          Если мастеру не нужен результат — RepSTART можно не делать,
 *          сразу STOP; вооружённая READ-фаза просто отбрасывается.
 *
 *          Обработка идёт в цикле, пока подняты флаги ADDR/RXNE/STOPF —
 *          это гарантирует, что байт, принятый непосредственно перед STOP,
 *          не будет потерян (RXNE может остаться необработанным к моменту STOPF).
 *
 *          При ADDR+W (приём) FSM всегда сбрасывается — новая WRITE-фаза
 *          начинается с чистого состояния.
 *
 * @return  none
 */
void I2C1_EV_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void I2C1_EV_IRQHandler(void)
{
    uint8_t work;
 
    do {
        work = 0U;
 
        if (I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR) != RESET) {
            work = 1U;
            if (I2C_GetFlagStatus(I2C1, I2C_FLAG_TRA) != RESET) {
                /* Slave-transmitter: мастер читает (фаза READ после RepSTART) */
                (void)I2C1->STAR2;
                if (s_i2c_tx_pending) {
                    I2C_SendData(I2C1, s_i2c_tx_byte);
                    s_i2c_tx_pending = 0U;
                }
            } else {
                /* Slave-receiver: новая WRITE-фаза — всегда сброс FSM */
                (void)I2C1->STAR2;
                LCM_I2C_ResetRx();
            }
        }
 
        if (I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE) != RESET) {
            work = 1U;
            LCM_I2C_OnRxData((uint8_t)I2C_ReceiveData(I2C1));
        }
 
        if (I2C_GetFlagStatus(I2C1, I2C_FLAG_STOPF) != RESET) {
            work = 1U;
            if (I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE) != RESET) {
                LCM_I2C_OnRxData((uint8_t)I2C_ReceiveData(I2C1));
            }
            /* STOP: очистка STOPF — чтение STAR1 + повторное включение PE */
            (void)I2C1->STAR1;
            I2C_Cmd(I2C1, ENABLE);
            LCM_I2C_ResetRx();
        }
    } while (work != 0U);
}
 
/*********************************************************************
 * @fn      I2C1_ER_IRQHandler
 *
 * @brief   Обработчик ошибок I2C1.
 *
 * @details В режиме slave типичны:
 *          — AF: NACK от мастера (например, конец чтения одного байта);
 *          — BERR: нарушение протокола;
 *          — OVR: не успели прочитать DATAR до следующего байта;
 *          — ARLO: потеря арбитража (для slave редко).
 *          Без сброса флагов периферия I2C может перестать отвечать на шине.
 *
 * @return  none
 */
void I2C1_ER_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void I2C1_ER_IRQHandler(void)
{
    /* AF (NACK) часто случается штатно при завершении чтения 1 байта мастером,
       поэтому не перезаписываем последнюю ошибку на AF. */
    if (I2C_GetFlagStatus(I2C1, I2C_FLAG_AF) != RESET) {
        I2C_ClearFlag(I2C1, I2C_FLAG_AF);
    }
 
    /* Если одновременно подняты несколько флагов, считаем приоритет:
       BERR > OVR > ARLO. */
    if (I2C_GetFlagStatus(I2C1, I2C_FLAG_BERR) != RESET) {
        (void)I2C1->STAR1;
        I2C_ClearFlag(I2C1, I2C_FLAG_BERR);
        LCM_Module_SetError(LCM_ERR_I2C_BERR);
        LCM_I2C_ResetRx();
        return;
    }
 
    if (I2C_GetFlagStatus(I2C1, I2C_FLAG_OVR) != RESET) {
        (void)I2C1->STAR1;
        I2C_ClearFlag(I2C1, I2C_FLAG_OVR);
        LCM_Module_SetError(LCM_ERR_I2C_OVR);
        LCM_I2C_ResetRx();
        return;
    }
 
    if (I2C_GetFlagStatus(I2C1, I2C_FLAG_ARLO) != RESET) {
        (void)I2C1->STAR1;
        I2C_ClearFlag(I2C1, I2C_FLAG_ARLO);
        LCM_Module_SetError(LCM_ERR_I2C_ARLO);
        LCM_I2C_ResetRx();
        return;
    }
}