lcm_module.c

Go to the documentation of this file.

/********************************** (C) COPYRIGHT *******************************
 * File Name          : lcm_module.c
 * Description        : Ядро I2C-ведомого модуля освещения (LCM): регистр
 *                      ошибки, конфигурация NVM, диспетчер команд,
 *                      жизненный цикл модуля (Init/Poll).
 *
 * Архитектура:
 *   — lcm_relay.c   — GPIO-драйвер 8 реле (push-pull, активный высокий уровень).
 *   — lcm_i2c.c     — I2C1 slave: FSM приёма/передачи, ISR (ADDR/RXNE/STOPF).
 *   — lcm_module.c  — команды, ошибки, NVM (user_data), Init/Poll.
 *
 *   4 группы освещения: каждая группа — битовая маска из 8 реле.
 *   Запись во flash (NVM) и перезагрузка MCU — в LCM_Module_Poll() из main().
 *********************************************************************************/
 
#include "lcm_module.h"
#include "lcm_relay.h"
#include "lcm_i2c.h"
#include "lcm_led.h"
#include "user_data.h"
#include "event_log.h"
#include "ch32v00x_conf.h"
 
/* --- Состояние приложения --- */
static uint8_t s_i2c_addr;                  /* текущий 7-битный адрес slave */
static uint8_t s_relay_state;               /* битовая маска реле (LSB = реле 0) */
static uint8_t s_group_mask[LCM_GROUP_COUNT]; /* маски групп 0…3 */
 
/* Регистр, отдаваемый по LCM_GET_ERROR */
static volatile uint8_t s_error_code;
 
/* Флаги отложенных действий (обрабатываются в LCM_Module_Poll) */
static volatile uint8_t s_nvm_dirty;        /* 1: нужен UserData_Commit() */
static volatile uint8_t s_reset_requested;  /* 1: после commit — NVIC_SystemReset */
static volatile uint8_t s_factory_reset;    /* 1: LCM_RESET — сброс NVM к заводскому */
 
/*********************************************************************
 * @fn      LCM_SetSuccess
 *
 * @brief   Отметить успешное выполнение последней команды: код ошибки
 *          = LCM_ERR_NONE.
 */
static void LCM_SetSuccess(void)
{
    s_error_code = LCM_ERR_NONE;
}
 
/*********************************************************************
 * @fn      LCM_SetError
 *
 * @brief   Зафиксировать ошибку обработки команды.
 *
 * @param   err — код LCM_ERR_* для чтения через LCM_GET_ERROR.
 */
static void LCM_SetError(uint8_t err)
{
    s_error_code = err;
    if (err != LCM_ERR_NONE) {
        EventLog_PushLcmError(err);
        LCM_Led_ErrorOn();
    }
}
 
void LCM_Module_SetError(uint8_t err)
{
    LCM_SetError(err);
}
 
/*********************************************************************
 * @fn      LCM_UserDataErrorCode
 *
 * @brief   Преобразовать UserData_Status в код LCM_ERR_USER_DATA_*.
 */
static uint8_t LCM_UserDataErrorCode(UserData_Status st)
{
    switch (st) {
    case USER_DATA_ERR_PARAM:
        return LCM_ERR_USER_DATA_PARAM;
    case USER_DATA_ERR_RANGE:
        return LCM_ERR_USER_DATA_RANGE;
    case USER_DATA_ERR_FLASH:
        return LCM_ERR_USER_DATA_FLASH;
    case USER_DATA_ERR_BUSY:
        return LCM_ERR_USER_DATA_BUSY;
    default:
        return LCM_ERR_USER_DATA_PARAM;
    }
}
 
/*********************************************************************
 * @fn      LCM_SetUserDataError
 *
 * @brief   Зафиксировать ошибку API user_data (кроме UserData_Commit).
 */
static void LCM_SetUserDataError(UserData_Status st)
{
    if (st != USER_DATA_OK) {
        EventLog_PushNvm(1U, (uint8_t)st);
    }
    LCM_SetError(LCM_UserDataErrorCode(st));
}
 
/*********************************************************************
 * @fn      LCM_SetUserDataCommitError
 *
 * @brief   Зафиксировать ошибку UserData_Commit().
 */
static void LCM_SetUserDataCommitError(UserData_Status st)
{
    EventLog_PushNvm(2U, (uint8_t)st);
    if (st == USER_DATA_ERR_FLASH) {
        LCM_SetError(LCM_ERR_USER_DATA_COMMIT);
    } else {
        LCM_SetError(LCM_UserDataErrorCode(st));
    }
}
 
/*********************************************************************
 * @fn      LCM_ApplyFactoryDefaults
 *
 * @brief   Заводские значения конфигурации LCM в RAM.
 */
static void LCM_ApplyFactoryDefaults(void)
{
    uint8_t i;
 
    s_i2c_addr = (uint8_t)LCM_I2C_ADDR_FACTORY;
    for (i = 0U; i < LCM_GROUP_COUNT; i++) {
        s_group_mask[i] = 0U;
    }
}
 
/*********************************************************************
 * @fn      LCM_UpdateRelayGpio
 *
 * @brief   Применить маску реле к GPIO и зафиксировать ошибку при сбое.
 *
 * @return  1 — GPIO обновлён успешно; 0 — ошибка (код в s_error_code).
 */
static uint8_t LCM_UpdateRelayGpio(void)
{
    uint8_t err = LCM_Relay_Apply(s_relay_state);
 
    if (err != LCM_ERR_NONE) {
        LCM_SetError(err);
        return 0U;
    }
    return 1U;
}
 
/*********************************************************************
 * @fn      LCM_NvmWriteConfig
 *
 * @brief   Записать текущую конфигурацию в RAM-кэш user_data.
 *
 * @details Формирует блок LCM_NVM_SIZE байт (magic, адрес, 4 маски групп)
 *          и вызывает UserData_Write(). Устанавливает s_nvm_dirty — фактическая
 *          запись во flash произойдёт в LCM_Module_Poll() через UserData_Commit().
 *          Не вызывать Commit из прерывания I2C.
 */
static uint8_t LCM_NvmWriteConfig(void)
{
    uint8_t buf[LCM_NVM_SIZE];
    uint8_t i;
    UserData_Status st;
 
    buf[LCM_NVM_OFF_MAGIC] = LCM_NVM_MAGIC;
    buf[LCM_NVM_OFF_I2C_ADDR] = s_i2c_addr;
    for (i = 0U; i < LCM_GROUP_COUNT; i++) {
        buf[LCM_NVM_OFF_GROUP_BASE + i] = s_group_mask[i];
    }
    st = UserData_Write(0U, buf, LCM_NVM_SIZE);
    if (st == USER_DATA_OK) {
        s_nvm_dirty = 1U;
        return 1U;
    }
 
    LCM_SetUserDataError(st);
    return 0U;
}
 
/*********************************************************************
 * @fn      LCM_LoadConfig
 *
 * @brief   Загрузить конфигурацию LCM из NVM (RAM-кэш user_data).
 *
 * @details Если magic != LCM_NVM_MAGIC (первый запуск или повреждённые данные),
 *          используются заводские значения: адрес 0x7F, все группы = 0x00.
 *          Вызывается один раз при LCM_Module_Init() после UserData_Init().
 */
static void LCM_LoadConfig(void)
{
    uint8_t magic;
    uint8_t i;
    UserData_Status st;
 
    st = UserData_ReadByte(LCM_NVM_OFF_MAGIC, &magic);
    if (st != USER_DATA_OK) {
        LCM_ApplyFactoryDefaults();
        LCM_SetUserDataError(st);
        return;
    }
    if (magic != LCM_NVM_MAGIC) {
        LCM_ApplyFactoryDefaults();
        return;
    }
 
    st = UserData_ReadByte(LCM_NVM_OFF_I2C_ADDR, &s_i2c_addr);
    if (st != USER_DATA_OK) {
        LCM_ApplyFactoryDefaults();
        LCM_SetUserDataError(st);
        return;
    }
 
    for (i = 0U; i < LCM_GROUP_COUNT; i++) {
        st = UserData_ReadByte(LCM_NVM_OFF_GROUP_BASE + i, &s_group_mask[i]);
        if (st != USER_DATA_OK) {
            LCM_ApplyFactoryDefaults();
            LCM_SetUserDataError(st);
            return;
        }
    }
}
 
/*********************************************************************
 * @fn      LCM_ApplyGroupOn
 *
 * @brief   Включить реле, входящие в выбранные группы.
 *
 * @param   group_sel — битовая маска групп (бит g → группа g).
 *
 * @details Для каждой установленной бита group_sel объединяет (OR) маску
 *          s_group_mask[g] в общую маску реле, затем включает эти реле
 *          в s_relay_state. Реле вне выбранных групп не изменяются.
 */
static void LCM_ApplyGroupOn(uint8_t group_sel)
{
    uint8_t g;
    uint8_t mask = 0U;
 
    for (g = 0U; g < LCM_GROUP_COUNT; g++) {
        if (group_sel & (uint8_t)(1U << g)) {
            mask |= s_group_mask[g];
        }
    }
    s_relay_state |= mask;
    if (LCM_UpdateRelayGpio()) {
        LCM_SetSuccess();
    }
}
 
/*********************************************************************
 * @fn      LCM_ApplyGroupOff
 *
 * @brief   Выключить реле, входящие в выбранные группы.
 *
 * @param   group_sel — битовая маска групп.
 *
 * @details Аналогично LCM_ApplyGroupOn, но сбрасывает соответствующие биты
 *          в s_relay_state (AND с инверсией маски).
 */
static void LCM_ApplyGroupOff(uint8_t group_sel)
{
    uint8_t g;
    uint8_t mask = 0U;
 
    for (g = 0U; g < LCM_GROUP_COUNT; g++) {
        if (group_sel & (uint8_t)(1U << g)) {
            mask |= s_group_mask[g];
        }
    }
    s_relay_state &= (uint8_t)~mask;
    if (LCM_UpdateRelayGpio()) {
        LCM_SetSuccess();
    }
}
 
/*********************************************************************
 * @fn      LCM_Module_ExecuteSingleByte
 *
 * @brief   Выполнить однобайтовую команду и вооружить ответ (READ-фазу).
 *
 * @param   cmd — код команды 0x00…0x1D (либо неизвестный код).
 *
 * @details Вызывается из lcm_i2c.c при приёме первого байта транзакции.
 *          Диапазоны:
 *            0x00–0x07 — включить реле (номер = cmd);
 *            0x08–0x0F — выключить реле (номер = cmd − 0x08);
 *            0x10/0x11 — все вкл/выкл;
 *            0x12–0x19 — группы вкл/выкл;
 *            0x1A — сброс (флаги factory_reset + reset_requested);
 *            0x1C/0x1D — явное чтение регистра ошибки / ID.
 *          Неизвестные коды фиксируют ошибку `LCM_ERR_UNKNOWN_CMD`.
 *
 *          Протокол: КАЖДАЯ команда (в т.ч. неизвестная) вооружает READ-фазу
 *          кодом текущей ошибки (LCM_I2C_ArmRead(s_error_code)), поэтому
 *          мастер получает результат сразу же — RepSTART + Addr+R следом за
 *          записью команды, без отдельной команды GET_ERROR. Исключения:
 *          GET_ERROR/GET_ID вооружают READ-фазу своим собственным байтом
 *          (код ошибки / ID) и выходят из функции сразу после этого.
 */
void LCM_Module_ExecuteSingleByte(uint8_t cmd)
{
    if (cmd <= LCM_LAMP_7_ON) {
        s_relay_state |= (uint8_t)(1U << cmd);
        if (LCM_UpdateRelayGpio()) {
            LCM_SetSuccess();
        }
    } else if (cmd >= LCM_LAMP_0_OFF && cmd <= LCM_LAMP_7_OFF) {
        s_relay_state &= (uint8_t)~(uint8_t)(1U << (cmd - LCM_LAMP_0_OFF));
        if (LCM_UpdateRelayGpio()) {
            LCM_SetSuccess();
        }
    } else {
        switch (cmd) {
        case LCM_LAMP_ALL_ON:
            s_relay_state = 0xFFU;
            if (LCM_UpdateRelayGpio()) {
                LCM_SetSuccess();
            }
            break;
 
        case LCM_LAMP_ALL_OFF:
            s_relay_state = 0U;
            if (LCM_UpdateRelayGpio()) {
                LCM_SetSuccess();
            }
            break;
 
        case LCM_GROUP_0_ON:
        case LCM_GROUP_1_ON:
        case LCM_GROUP_2_ON:
        case LCM_GROUP_3_ON:
            LCM_ApplyGroupOn((uint8_t)(1U << (cmd - LCM_GROUP_0_ON)));
            break;
 
        case LCM_GROUP_0_OFF:
        case LCM_GROUP_1_OFF:
        case LCM_GROUP_2_OFF:
        case LCM_GROUP_3_OFF:
            LCM_ApplyGroupOff((uint8_t)(1U << (cmd - LCM_GROUP_0_OFF)));
            break;
 
        case LCM_RESET:
            /* Сброс NVM и reboot выполняются в Poll — здесь только флаги */
            s_factory_reset = 1U;
            s_reset_requested = 1U;
            LCM_SetSuccess();
            break;
 
        case LCM_GET_ERROR:
            LCM_I2C_ArmRead(s_error_code);
            /* Ошибка считана мастером — гасим красный индикатор */
            LCM_Led_ErrorOff();
            return;
 
        case LCM_GET_ID:
            LCM_I2C_ArmRead((uint8_t)LCM_ID);
            return;
 
        default:
            /* Нераспознанная команда — фиксируем ошибку, код вернётся ниже */
            LCM_SetError(LCM_ERR_UNKNOWN_CMD);
            break;
        }
    }
 
    /* Единая точка выхода: код ошибки сразу доступен по RepSTART + Addr+R.
       Явного GET_ERROR теперь может и не быть — красный гасим здесь же,
       чтобы он не оставался гореть навсегда (ErrorOff учитывает минимальное
       время показа LCM_LED_RED_MIN_MS, заданное в LCM_SetError/ErrorOn). */
    LCM_I2C_ArmRead(s_error_code);
    LCM_Led_ErrorOff();
}
 
/*********************************************************************
 * @fn      LCM_Module_ExecuteTwoByte
 *
 * @brief   Выполнить двухбайтовую команду и вооружить ответ (READ-фазу).
 *
 * @param   cmd   — 0x20…0x28.
 * @param   param — маска реле, маска групп, маска состава группы или I2C-адрес.
 *
 * @details Вызывается из lcm_i2c.c после приёма второго байта транзакции.
 *          Как и для однобайтовых команд, по завершении всегда вооружается
 *          READ-фаза кодом текущей ошибки — мастер читает результат сразу
 *          через RepSTART + Addr+R, без отдельной команды GET_ERROR.
 */
void LCM_Module_ExecuteTwoByte(uint8_t cmd, uint8_t param)
{
    switch (cmd) {
    case LCM_LAMP_ON:
        s_relay_state |= param;
        if (LCM_UpdateRelayGpio()) {
            LCM_SetSuccess();
        }
        break;
 
    case LCM_LAMP_OFF:
        s_relay_state &= (uint8_t)~param;
        if (LCM_UpdateRelayGpio()) {
            LCM_SetSuccess();
        }
        break;
 
    case LCM_GROUP_ON:
        LCM_ApplyGroupOn(param);
        break;
 
    case LCM_GROUP_OFF:
        LCM_ApplyGroupOff(param);
        break;
 
    case LCM_GROUP_0_SET:
    case LCM_GROUP_1_SET:
    case LCM_GROUP_2_SET:
    case LCM_GROUP_3_SET:
        s_group_mask[cmd - LCM_GROUP_0_SET] = param;
        if (LCM_NvmWriteConfig()) {
            LCM_SetSuccess();
        }
        break;
 
    case LCM_SET_ADDR:
        if (param > LCM_I2C_ADDR_FACTORY) {
            LCM_SetError(LCM_ERR_BAD_PARAM);
            break;
        }
        s_i2c_addr = param;
        if (LCM_NvmWriteConfig()) {
            s_reset_requested = 1U;   /* новый адрес I2C — после Commit */
            LCM_SetSuccess();
        }
        break;
 
    default:
        break;
    }
 
    /* Единая точка выхода: код ошибки сразу доступен по RepSTART + Addr+R.
       Красный гасим здесь же (см. пояснение в ExecuteSingleByte) — иначе
       без явного GET_ERROR индикатор ошибки остаётся гореть навсегда. */
    LCM_I2C_ArmRead(s_error_code);
    LCM_Led_ErrorOff();
}
 
/*********************************************************************
 * @fn      LCM_Module_ReportUserDataStatus
 *
 * @brief   Публичная фиксация ошибки user_data (для main и др.).
 */
void LCM_Module_ReportUserDataStatus(UserData_Status st)
{
    if (st != USER_DATA_OK) {
        LCM_SetUserDataError(st);
    }
}
 
uint8_t LCM_Module_GetI2cAddr(void)
{
    return s_i2c_addr;
}
 
uint8_t LCM_Module_GetRelayState(void)
{
    return s_relay_state;
}
 
const uint8_t *LCM_Module_GetGroupMasks(void)
{
    return s_group_mask;
}
 
/*********************************************************************
 * @fn      LCM_Module_Init
 *
 * @brief   Точка входа инициализации LCM (вызывается из main).
 *
 * @details Порядок: сброс переменных → загрузка NVM → GPIO (все реле выкл) →
 *          I2C slave. К моменту появления мастера на шине выводы реле
 *          уже в безопасном состоянии (логический 0).
 */
void LCM_Module_Init(void)
{
    uint8_t err;
 
    s_relay_state = 0U;
    s_error_code = LCM_ERR_NONE;
    s_nvm_dirty = 0U;
    s_reset_requested = 0U;
    s_factory_reset = 0U;
 
    LCM_Led_Init();
    LCM_LoadConfig();
 
    err = LCM_Relay_Init();
    if (err != LCM_ERR_NONE) {
        LCM_SetError(err);
    }
    err = LCM_Relay_Apply(s_relay_state);
    if (err != LCM_ERR_NONE) {
        LCM_SetError(err);
    }
    LCM_I2C_Init(s_i2c_addr);
}
 
/*********************************************************************
 * @fn      LCM_Module_Poll
 *
 * @brief   Фоновая обработка: NVM commit, заводской сброс, перезагрузка.
 *
 * @details Вызывается в каждой итерации while(1) в main. Не блокирует ISR
 *          надолго, кроме периода UserData_Commit() (стирание/программирование
 *          option bytes, несколько миллисекунд).
 *
 *          Порядок обработки:
 *            1) factory_reset — записать заводские значения в кэш NVM;
 *            2) nvm_dirty — UserData_Commit(); при ошибке — LCM_ERR_USER_DATA_*;
 *            3) reset_requested — NVIC_SystemReset() (новый I2C-адрес и т.д.).
 */
void LCM_Module_Poll(void)
{
    UserData_Status st;
    uint8_t buf[LCM_NVM_SIZE];
    uint8_t i;
 
    EventLog_Process();
    LCM_Led_Poll();
 
    if (s_factory_reset) {
        buf[LCM_NVM_OFF_MAGIC] = LCM_NVM_MAGIC;
        buf[LCM_NVM_OFF_I2C_ADDR] = (uint8_t)LCM_I2C_ADDR_FACTORY;
        for (i = 0U; i < LCM_GROUP_COUNT; i++) {
            buf[LCM_NVM_OFF_GROUP_BASE + i] = 0U;
            s_group_mask[i] = 0U;
        }
        s_i2c_addr = (uint8_t)LCM_I2C_ADDR_FACTORY;
        st = UserData_Write(0U, buf, LCM_NVM_SIZE);
        if (st == USER_DATA_OK) {
            s_nvm_dirty = 1U;
        } else {
            EventLog_PushNvm(3U, (uint8_t)st);
            LCM_SetUserDataError(st);
            s_nvm_dirty = 0U;
        }
        s_factory_reset = 0U;
    }
 
    if (s_nvm_dirty) {
        st = UserData_Commit();
        if (st != USER_DATA_OK) {
            LCM_SetUserDataCommitError(st);
            s_nvm_dirty = 0U;
            return;
        }
        EventLog_PushNvm(2U, USER_DATA_OK);
        s_nvm_dirty = 0U;
    }
 
    if (s_reset_requested) {
        s_reset_requested = 0U;
        EventLog_PushSystem(1U);
        EventLog_Process();
        NVIC_SystemReset();
    }
}