From ef5950be031c28b6ba8151f961548b9e0dd866eb Mon Sep 17 00:00:00 2001 From: cfif Date: Mon, 18 May 2026 17:40:41 +0300 Subject: [PATCH] Init --- LinSensorTasks.c | 490 +++++++++++++++++++++++++++++++++++++++++++++++ LinSensorTasks.h | 322 +++++++++++++++++++++++++++++++ modular.json | 10 + 3 files changed, 822 insertions(+) create mode 100644 LinSensorTasks.c create mode 100644 LinSensorTasks.h create mode 100755 modular.json diff --git a/LinSensorTasks.c b/LinSensorTasks.c new file mode 100644 index 0000000..be4e0c5 --- /dev/null +++ b/LinSensorTasks.c @@ -0,0 +1,490 @@ +// +// Created by cfif on 12.02.2026. +// +#include +#include "LinSensorTasks.h" +#include "CmsisRtosThreadUtils.h" +#include "CanPorts.h" +#include "LoggerInterface.h" +#include "memory.h" + +#define LOG_SIGN4 "Ln4" +#define LOG_SIGN5 "Ln5" +#define LOGGER env->logger + +const uint8_t DRS_SENSON_ADR_Stat[LIN5_SENSOR_COUNT] = {DRS_DL_Stat, + DRS_DR_Stat, + DRS_FPL_Stat, + DRS_FPR_Stat, + DRS_RLB_Stat, + DRS_RRB_Stat, + DRS_FCL_Stat, + DRS_FCR_Stat}; + +static lin_event_id_t SEND_SENSOR_COM_x(tLinIO *linIo, uint8_t COM_ADR) { + lin_event_id_t res = linIo->runCommand(linIo->env, 30); +// SystemDelayMs(40); + return res; +} + +static lin_event_id_t Set_CCU_Req(tLinIO *linIo, tLinData *linData, tCCU_Req *p_CCU_Req) { + lin_event_id_t res; + + linData->direction = LIN_DIRECTION_SET; + + linData->g_aTxBufferLen = sizeof(tCCU_Req); + linData->g_aRxBufferLen = 0; + + memcpy(linData->g_aTxBuffer, p_CCU_Req, sizeof(tCCU_Req)); + + uint8_t retry = 1; + + while (retry) { + + res = SEND_SENSOR_COM_x(linIo, CCU_Req); + + if (res == LIN_TX_COMPLETED) { + break; + } + + --retry; + } + + return res; +} + +/* +static lin_event_id_t Get_AirQS_Stat(tLinIO *linIo, tLinData *linData, tAirQS_Stat *p_AirQS_Stat) { + lin_event_id_t res; + + tAirQS_Stat *tAirQS_Stat_ = (tAirQS_Stat *) linData->g_aRxBuffer; + + uint8_t retry = 1; + + while (retry) { + + linData->direction = LIN_DIRECTION_GET; + + linData->g_aTxBufferLen = 0; + linData->g_aRxBufferLen = sizeof(tAirQS_Stat); + + res = SEND_SENSOR_COM_x(linIo, AirQS_Stat); + + if (res == LIN_RX_COMPLETED) { + memcpy(p_AirQS_Stat, tAirQS_Stat_, sizeof(tAirQS_Stat)); + break; + } + + --retry; + } + + return res; +} + + + +//начало----------------------------------------- LIN 4 ---------------------------------------------------------------- +//начало----------------------------------------- LIN 4 ---------------------------------------------------------------- +//начало----------------------------------------- LIN 4 ---------------------------------------------------------------- +//начало----------------------------------------- LIN 4 --------------------------------------------------------------- + +static lin_event_id_t Lin4_Scheduler(tLin4TaskSensor *env) { + lin_event_id_t ret = LIN_NO_EVENT; + + env->d_CCU_Req.CCU_AirQS_Req = 1; + ret = Set_CCU_Req(env->linIo, env->linData, &env->d_CCU_Req); + +#if (LOG_LIN4_ACTUATOR == 1) + if (ret == LIN_TX_COMPLETED) { + LoggerFormatInfo(LOGGER, LOG_SIGN4, "OK Set_CCU_Req = %d", ret) + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN4, "ERROR Set_CCU_Req = %d", ret) + } +#endif + + + ret = Get_AirQS_Stat(env->linIo, env->linData, &env->d_AirQS_Stat); + +#if (LOG_LIN4_ACTUATOR == 1) + + if (ret == LIN_RX_COMPLETED) { + LoggerFormatInfo(LOGGER, LOG_SIGN4, + "AirQS_LinRespErr_Stat = %d AirQS_Sens_Stat = %d AirQS_Combined_Stat = %d AirQS_Err_Stat = %d AirQS_COLvl_Stat = %d AirQS_NOxLvl_Stat = %d AirQS_NH3Lvl_Stat = %d", + env->d_AirQS_Stat.AirQS_LinRespErr_Stat, + env->d_AirQS_Stat.AirQS_Sens_Stat, + env->d_AirQS_Stat.AirQS_Combined_Stat, + env->d_AirQS_Stat.AirQS_Err_Stat, + env->d_AirQS_Stat.AirQS_COLvl_Stat, + env->d_AirQS_Stat.AirQS_NOxLvl_Stat, + env->d_AirQS_Stat.AirQS_NH3Lvl_Stat) + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN4, "ERROR Get_AirQS_Stat = %d", ret) + } + +#endif + + return LIN_NO_EVENT; +} + +void Lin_4_Init(tLin4TaskSensor *env, + tLinData *linData, + tLinIO *linIO, + tLoggerInterface *logger) { + + env->linIo = linIO; + env->linData = linData; + env->logger = logger; + env->access = osMutexNew(NULL); + + InitThreadAtrStatic(&env->threadLin.attr, "Ln4", env->threadLin.controlBlock, env->threadLin.stack, + osPriorityNormal); +} + + +static _Noreturn void Lin4_Thread(tLin4TaskSensor *env) { + for (;;) { + + if (osMutexAcquire(env->access, 1000) == osOK) { + + lin_event_id_t res = Lin4_Scheduler(env); + + + osMutexRelease(env->access); + } + + SystemDelayMs(1000); + } +} + +void Lin4_StartThread(tLin4TaskSensor *env) { + if (!env->threadLin.id) { + env->threadLin.id = osThreadNew((osThreadFunc_t) (Lin4_Thread), (void *) (env), &env->threadLin.attr); + SystemDelayMs(10); + } +} + +//конец----------------------------------------- LIN 4 ---------------------------------------------------------------- +//конец----------------------------------------- LIN 4 ---------------------------------------------------------------- +//конец----------------------------------------- LIN 4 ---------------------------------------------------------------- +//конец----------------------------------------- LIN 4 ---------------------------------------------------------------- +*/ + +//начало----------------------------------------- LIN 5 ---------------------------------------------------------------- +//начало----------------------------------------- LIN 5 ---------------------------------------------------------------- +//начало----------------------------------------- LIN 5 ---------------------------------------------------------------- +//начало----------------------------------------- LIN 5 --------------------------------------------------------------- + +static lin_event_id_t Set_CCU_DRS_Req(tLinIO *linIo, tLinData *linData, tCCU_DRS_Req *p_CCU_DRS_Req) { + lin_event_id_t res; + + linData->direction = LIN_DIRECTION_SET; + + linData->g_aTxBufferLen = sizeof(tCCU_DRS_Req); + linData->g_aRxBufferLen = 0; + + memcpy(linData->g_aTxBuffer, p_CCU_DRS_Req, sizeof(tCCU_DRS_Req)); + + uint8_t retry = 1; + + while (retry) { + + res = SEND_SENSOR_COM_x(linIo, CCU_DRS_Req); + + if (res == LIN_TX_COMPLETED) { + break; + } + + --retry; + } + + return res; +} + + +static lin_event_id_t Get_DRS_Stat(tLinIO *linIo, tLinData *linData, tDRS_Stat *p_tDRS_Stat, uint8_t DRS_stat) { + lin_event_id_t res; + + tDRS_Stat *tDRS_Stat_ = (tDRS_Stat *) linData->g_aRxBuffer; + + uint8_t retry = 3; + + while (retry) { + + linData->direction = LIN_DIRECTION_GET; + + linData->g_aTxBufferLen = 0; + linData->g_aRxBufferLen = sizeof(tDRS_Stat); + + res = SEND_SENSOR_COM_x(linIo, DRS_stat); + + if (res == LIN_RX_COMPLETED) { + memcpy(p_tDRS_Stat, tDRS_Stat_, sizeof(tDRS_Stat)); + break; + } + + --retry; + } + + return res; +} + +// Вспомогательная функция: устанавливает три бита для группы led_group +// в соответствии со значением count (0, 1, 2, 3) +static void set_led_group(tCCU_DRS_Req *req, uint8_t led_group, uint8_t count) { + // Определяем, какой из трёх битов должен быть установлен + + uint8_t b1 = 0; + uint8_t b2 = 0; + uint8_t b3 = 0; + + if (count == 1) { + b1 = 0; + b2 = 0; + b3 = 1; + } + + if (count == 2) { + b1 = 0; + b2 = 1; + b3 = 1; + } + + if (count == 3) { + b1 = 1; + b2 = 1; + b3 = 1; + } + + switch (led_group) { + case 0: + req->CCU_DLLed1_Req = b1; + req->CCU_DLLed2_Req = b2; + req->CCU_DLLed3_Req = b3; + break; + case 1: + req->CCU_DRLed1_Req = b1; + req->CCU_DRLed2_Req = b2; + req->CCU_DRLed3_Req = b3; + break; + case 2: + req->CCU_FPLLed1_Req = b1; + req->CCU_FPLLed2_Req = b2; + req->CCU_FPLLed3_Req = b3; + break; + case 3: + req->CCU_FPRLed1_Req = b1; + req->CCU_FPRLed2_Req = b2; + req->CCU_FPRLed3_Req = b3; + break; + case 4: + req->CCU_RLBLed1_Req = b1; + req->CCU_RLBLed2_Req = b2; + req->CCU_RLBLed3_Req = b3; + break; + case 5: + req->CCU_RRBLed1_Req = b1; + req->CCU_RRBLed2_Req = b2; + req->CCU_RRBLed3_Req = b3; + break; + case 6: + req->CCU_FCLLed1_Req = b1; + req->CCU_FCLLed2_Req = b2; + req->CCU_FCLLed3_Req = b3; + break; + case 7: + req->CCU_FCRLed1_Req = b1; + req->CCU_FCRLed2_Req = b2; + req->CCU_FCRLed3_Req = b3; + break; + default: + // Недопустимый индекс – можно ничего не делать или добавить assert + break; + } +} + + +static lin_event_id_t Lin5_Scheduler(tLin5TaskSensor *env) { + + + lin_event_id_t ret = env->lin_Io.getCommand(env->lin_Io.env, 1000); + + asm("nop"); + +/* + lin_event_id_t ret = LIN_NO_EVENT; + + ret = Set_CCU_DRS_Req(env->linIo, env->linData, &env->d_CCU_DRS_Req); + + if (ret == LIN_TX_COMPLETED) { + + for (uint8_t i = 0; i < LIN5_SENSOR_COUNT; ++i) { + set_led_group(&env->d_CCU_DRS_Req, i, env->linStateSensor.LED_COUNT[i]); + } + env->d_CCU_DRS_Req.BCM_SwIndIntens_Stat = 0; + env->d_CCU_DRS_Req.BCM_IndFadingTime_Req = 0; + +#if (LOG_LIN5_SENSOR == 1) + + if (*((uint32_t *) &env->d_CCU_DRS_Req) != *((uint32_t *) &env->d_old_CCU_DRS_Req)) { + *((uint32_t *) &env->d_old_CCU_DRS_Req) = *((uint32_t *) &env->d_CCU_DRS_Req); + LoggerInfoStatic(LOGGER, LOG_SIGN5, "Sensor Set_CCU_DRS_Req - OK") + } +#endif + } else { +#if (LOG_LIN5_SENSOR == 1) + if (*((uint32_t *) &env->d_CCU_DRS_Req) != *((uint32_t *) &env->d_old_CCU_DRS_Req)) { + *((uint32_t *) &env->d_old_CCU_DRS_Req) = *((uint32_t *) &env->d_CCU_DRS_Req); + LoggerFormatInfo(LOGGER, LOG_SIGN5, "Sensor Set_CCU_DRS_Req (ERROR %d)", ret) + } +#endif + } + + SystemDelayMs(50); + + for (uint8_t i = 0; i < LIN5_SENSOR_COUNT; ++i) { + + if (env->linStateSensor.error_connect[i] == 0) { + + ret = Get_DRS_Stat(env->linIo, env->linData, &env->linStateSensor.d_DRS_Stat[i], DRS_SENSON_ADR_Stat[i]); + + uint8_t current_btn_state = env->linStateSensor.d_DRS_Stat[i].DRS_Btn_Stat; + + if ((current_btn_state) && (!env->linStateSensor.prev_btn_state[i])) { + + if (env->linStateSensor.LED_COUNT[i] == 0) { + env->linStateSensor.LED_COUNT[i] = 3; + } else { + --env->linStateSensor.LED_COUNT[i]; + } + + } + env->linStateSensor.prev_btn_state[i] = current_btn_state; + + env->linStateSensor.LinRespErr_Stat[i] = env->linStateSensor.d_DRS_Stat[i].DRS_LinRespErr_Stat; + env->linStateSensor.Err_Stat[i] = env->linStateSensor.d_DRS_Stat[i].DRS_Err_Stat; + + if (ret == LIN_RX_COMPLETED) { + env->linStateSensor.error_connect[i] = 0; +#if (LOG_LIN5_SENSOR == 1) + + if ((*((uint8_t *) &env->linStateSensor.d_DRS_Stat[i]) != + *((uint8_t *) &env->linStateSensor.d_old_DRS_Stat[i])) || + (env->linStateSensor.LED_COUNT[i] != env->linStateSensor.LED_OLD_COUNT[i])) { + + *((uint8_t *) &env->linStateSensor.d_old_DRS_Stat[i]) = *((uint8_t *) &env->linStateSensor.d_DRS_Stat[i]); + env->linStateSensor.LED_OLD_COUNT[i] = env->linStateSensor.LED_COUNT[i]; + + LoggerFormatInfo(LOGGER, LOG_SIGN5, + "Sensor number %d: COUNT = %d DRS_Btn_Stat = %d DRS_LinRespErr_Stat = %d DRS_Err_Stat = %d", + i, + env->linStateSensor.LED_COUNT[i], + env->linStateSensor.d_DRS_Stat[i].DRS_Btn_Stat, + env->linStateSensor.d_DRS_Stat[i].DRS_LinRespErr_Stat, + env->linStateSensor.d_DRS_Stat[i].DRS_Err_Stat + ) + } +#endif + } else { + env->linStateSensor.error_connect[i] = 1; +#if (LOG_LIN5_SENSOR == 1) + if (env->linStateSensor.error_connect[i] != env->linStateSensor.error_old_connect[i]) { + env->linStateSensor.error_old_connect[i] = env->linStateSensor.error_connect[i]; + LoggerFormatInfo(LOGGER, LOG_SIGN5, "Sensor number %d: ERROR Get_FPL_Stat = %d", i, ret) + } +#endif + } + + SystemDelayMs(50); + + } + + } + + return LIN_NO_EVENT; + */ +} + +void Lin_5_Init(tLin5TaskSensor *env, + tSerialPortIO *serialPortIO, + tLoggerInterface *logger) { + + LIN_Initial(&env->lin, serialPortIO, &env->linData); + env->lin_Io = vLinGetIo(&env->lin); + + env->logger = logger; + env->access = osMutexNew(NULL); + + for (uint8_t i = 0; i < LIN5_SENSOR_COUNT; ++i) { + env->linStateSensor.LED_COUNT[i] = 3; + } + + InitThreadAtrStatic(&env->threadLin.attr, "Ln5", env->threadLin.controlBlock, env->threadLin.stack, + osPriorityNormal); +} + + +static _Noreturn void Lin5_Thread(tLin5TaskSensor *env) { + for (;;) { + + if (osMutexAcquire(env->access, 1000) == osOK) { + + lin_event_id_t res = Lin5_Scheduler(env); + + uint8_t isError = 0; + for (uint8_t i = 0; i < LIN5_SENSOR_COUNT; ++i) { + if (env->linStateSensor.error_connect[i] == 1) + ++isError; + } + + if (isError == LIN5_SENSOR_COUNT) { + env->error_connect = 1; + } else { + env->error_connect = 0; + } + + + osMutexRelease(env->access); + } else { + LoggerErrorStatic(LOGGER, LOG_SIGN5, "Access error Lin5_Thread"); + } + + } +} + +void Lin5_StartThread(tLin5TaskSensor *env) { + if (!env->threadLin.id) { + env->threadLin.id = osThreadNew((osThreadFunc_t) (Lin5_Thread), (void *) (env), &env->threadLin.attr); + SystemDelayMs(10); + } +} + +//конец----------------------------------------- LIN 5 ---------------------------------------------------------------- +//конец----------------------------------------- LIN 5 ---------------------------------------------------------------- +//конец----------------------------------------- LIN 5 ---------------------------------------------------------------- +//конец----------------------------------------- LIN 5 ---------------------------------------------------------------- + + + + + +void Lin_Timeouts_Init(tLinTimeoutsTask *env, tLoggerInterface *logger) { + + env->logger = logger; + + InitThreadAtrStatic(&env->threadLin.attr, "LinTimeouts", env->threadLin.controlBlock, env->threadLin.stack, + osPriorityNormal); +} + + +static _Noreturn void LinTimeouts_Thread(tLinTimeoutsTask *env) { + for (;;) { + + } +} + +void LinTimeout_StartThread(tLinTimeoutsTask *env) { + if (!env->threadLin.id) { + env->threadLin.id = osThreadNew((osThreadFunc_t) (LinTimeouts_Thread), (void *) (env), &env->threadLin.attr); + SystemDelayMs(10); + } +} \ No newline at end of file diff --git a/LinSensorTasks.h b/LinSensorTasks.h new file mode 100644 index 0000000..cac9d95 --- /dev/null +++ b/LinSensorTasks.h @@ -0,0 +1,322 @@ +// +// Created by cfif on 12.02.2026. +// + +#ifndef HVAC_DEV_LINSENSORTASKS_H +#define HVAC_DEV_LINSENSORTASKS_H + +#include +#include "stdbool.h" +#include "LinIO.h" +#include "LoggerInterface.h" +#include "SerialPortIO.h" +#include "LinAt32.h" + +#define LOG_LIN4_SENSOR 1 +#define LOG_LIN5_SENSOR 1 + +#define LIN5_SENSOR_COUNT 8 + +#define AirQS_Stat 0x14 +#define Aroma_Stat 0x5 +#define CCU_Req 0x1 +#define Ionizer_Stat 0x1C +#define eTXV_fHVAC_Stat 0x1E +#define eTXV_rHVAC_Stat 0x20 +#define eTXV_batChiller_Stat 0x22 +#define eTXV_eeChiller_Stat 0x24 + +#define CCU_DRS_Req 0x1 +#define DRS_DL_Stat 0xD +#define DRS_DR_Stat 0x12 +#define DRS_FPL_Stat 0x17 +#define DRS_FPR_Stat 0x1C +#define DRS_RLB_Stat 0x21 +#define DRS_RRB_Stat 0x26 +#define DRS_FCL_Stat 0x2B +#define DRS_FCR_Stat 0x30 + + +typedef struct __attribute__ ((packed)) { + uint8_t AirQS_LinRespErr_Stat: 1; // 0 + uint8_t AirQS_Sens_Stat: 2; // 1 + uint8_t AirQS_Combined_Stat: 3; // 3 + uint8_t unused1: 2; // 6 + uint8_t AirQS_Err_Stat: 3; // 8 + uint8_t AirQS_COLvl_Stat: 4; // 11 + uint8_t unused2: 1; // 15 + uint8_t AirQS_NOxLvl_Stat: 4; // 16 + uint8_t AirQS_NH3Lvl_Stat: 4; // 20 +} tAirQS_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t Aroma_LinRespErr_Stat: 1; // 0 + uint8_t Aroma_CartridgeSw_Stat: 1; // 1 + uint8_t unused1: 2; // 2 + uint8_t Aroma_Err_Stat: 2; // 4 + uint8_t Aroma_Intens_Stat: 2; // 6 + uint8_t unused2: 2; // 8 + uint8_t Aroma_CartridgeFlavor_Stat: 4; // 10 + uint16_t unused3: 10; // биты 14–23 + uint8_t Aroma_CartridgeCapacity_Stat: 4; // 24 + uint8_t unused4: 4; // биты 28–31 + uint8_t unused5: 8; // биты 32–39 +} tAroma_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t CCU_Ionization_Req: 1; // 0 + uint8_t unused1: 2; // 1 + uint8_t CCU_AromaIntens_Req: 2; // 3 + uint8_t unused2: 3; // биты 5–7 + uint8_t unused3: 8; // биты 8–15 + uint8_t unused4: 8; // биты 16–23 + uint8_t CCU_AirQS_Req: 1; // 24 + uint8_t CCU_fHVAC_Pos_Val: 7; // 25 + uint8_t CCU_rHVAC_Pos_Val: 7; // 32 + uint8_t unused5: 1; // 39 + uint8_t CCU_batChiller_Pos_Val: 7; // 40 + uint8_t unused6: 1; // 47 + uint8_t CCU_eeChiller_Pos_Val: 7; // 48 + uint8_t unused7: 1; // 55 – явное заполнение +} tCCU_Req; + +typedef struct __attribute__ ((packed)) { + uint8_t Ionizer_LinRespErr_Stat: 1; // 0 + uint8_t Ionizer_Err_Stat: 2; // 1 + uint8_t unused1: 5; // 3 + uint8_t Ionizer_Ionization_Stat: 1; // 8 +} tIonizer_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t eTXV_fHVAC_Pos_Stat: 7; // 0 + uint8_t eTXV_fHVAC_LinRespErr_Stat: 1; // 7 + uint8_t eTXV_fHVAC_Err_Stat: 2; // 8 + uint8_t eTXV_fHVAC_Pressure_Val: 6; // 10 + uint8_t eTXV_fHVAC_Temp_Val: 7; // 16 +} teTXV_fHVAC_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t eTXV_rHVAC_Pos_Stat: 7; // 0 + uint8_t eTXV_rHVAC_LinRespErr_Stat: 1; // 7 + uint8_t eTXV_rHVAC_Err_Stat: 2; // 8 + uint8_t eTXV_rHVAC_Pressure_Val: 6; // 10 + uint8_t eTXV_rHVAC_Temp_Val: 7; // 16 +} teTXV_rHVAC_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t eTXV_batChiller_Pos_Stat: 7; // 0 + uint8_t eTXV_batChiller_LinRespErr_Stat: 1; // 7 + uint8_t eTXV_batChiller_Err_Stat: 2; // 8 + uint8_t eTXV_batChiller_Pressure_Val: 6; // 10 + uint8_t eTXV_batChiller_Temp_Val: 7; // 16 +} teTXV_batChiller_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t eTXV_eeChiller_Stat_: 7; // 0 + uint8_t eTXV_eeChiller_LinRespErr_Stat: 1; // 7 + uint8_t eTXV_eeChiller_Err_Stat: 2; // 8 + uint8_t eTXV_eeChiller_Pressure_Val: 6; // 10 + uint8_t eTXV_eeChiller_Temp_Val: 7; // 16 +} teTXV_eeChiller_Stat; + + +typedef struct __attribute__ ((packed)) { + uint8_t CCU_DLLed1_Req: 1; // 0 + uint8_t CCU_DLLed2_Req: 1; // 1 + uint8_t CCU_DLLed3_Req: 1; // 2 + + uint8_t CCU_DRLed1_Req: 1; // 3 + uint8_t CCU_DRLed2_Req: 1; // 4 + uint8_t CCU_DRLed3_Req: 1; // 5 + + uint8_t CCU_FPLLed1_Req: 1; // 6 + uint8_t CCU_FPLLed2_Req: 1; // 7 + uint8_t CCU_FPLLed3_Req: 1; // 8 + + uint8_t CCU_FPRLed1_Req: 1; // 9 + uint8_t CCU_FPRLed2_Req: 1; // 10 + uint8_t CCU_FPRLed3_Req: 1; // 11 + + uint8_t CCU_RLBLed1_Req: 1; // 12 + uint8_t CCU_RLBLed2_Req: 1; // 13 + uint8_t CCU_RLBLed3_Req: 1; // 14 + + uint8_t CCU_RRBLed1_Req: 1; // 15 + uint8_t CCU_RRBLed2_Req: 1; // 16 + uint8_t CCU_RRBLed3_Req: 1; // 17 + + uint8_t CCU_FCLLed1_Req: 1; // 18 + uint8_t CCU_FCLLed2_Req: 1; // 19 + uint8_t CCU_FCLLed3_Req: 1; // 20 + + uint8_t CCU_FCRLed1_Req: 1; // 21 + uint8_t CCU_FCRLed2_Req: 1; // 22 + uint8_t CCU_FCRLed3_Req: 1; // 23 + + uint8_t BCM_SwIndIntens_Stat: 1; // 24 + uint8_t BCM_IndFadingTime_Req: 5; // 25 +} tCCU_DRS_Req; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_Btn_Stat: 1; // 0 + uint8_t DRS_LinRespErr_Stat: 1; // 1 + uint8_t DRS_Err_Stat: 1; // 2 +} tDRS_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_DL_Btn_Stat: 1; // 0 + uint8_t DRS_DL_LinRespErr_Stat: 1; // 1 + uint8_t DRS_DL_Err_Stat: 1; // 2 +} tDRS_DL_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_DR_Btn_Stat: 1; // 0 + uint8_t DRS_DR_LinRespErr_Stat: 1; // 1 + uint8_t DRS_DR_Err_Stat: 1; // 2 +} tDRS_DR_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_FCL_Btn_Stat: 1; // 0 + uint8_t DRS_FCL_LinRespErr_Stat: 1; // 1 + uint8_t DRS_FCL_Err_Stat: 1; // 2 +} tDRS_FCL_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_FCR_Btn_Stat: 1; // 0 + uint8_t DRS_FCR_LinRespErr_Stat: 1; // 1 + uint8_t DRS_FCR_Err_Stat: 1; // 2 +} tDRS_FCR_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_FPL_Btn_Stat: 1; // 0 + uint8_t DRS_FPL_LinRespErr_Stat: 1; // 1 + uint8_t DRS_FPL_Err_Stat: 1; // 2 +} tDRS_FPL_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_FPR_Btn_Stat: 1; // 0 + uint8_t DRS_FPR_LinRespErr_Stat: 1; // 1 + uint8_t DRS_FPR_Err_Stat: 1; // 2 +} tDRS_FPR_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_RLB_Btn_Stat: 1; // 0 + uint8_t DRS_RLB_LinRespErr_Stat: 1; // 1 + uint8_t DRS_RLB_Err_Stat: 1; // 2 +} tDRS_RLB_Stat; + +typedef struct __attribute__ ((packed)) { + uint8_t DRS_RRB_Btn_Stat: 1; // 0 + uint8_t DRS_RRB_LinRespErr_Stat: 1; // 1 + uint8_t DRS_RRB_Err_Stat: 1; // 2 +} tDRS_RRB_Stat; + + +typedef struct { + + tLinIO *linIo; + osMutexId_t access; + + tLinData *linData; + + tLoggerInterface *logger; + + tCCU_Req d_CCU_Req; + tAirQS_Stat d_AirQS_Stat; + + struct { + osThreadId_t id; + uint32_t stack[384]; + StaticTask_t controlBlock; + osThreadAttr_t attr; + } threadLin; + + +} tLin4TaskSensor; + +/* +typedef struct { + uint8_t in_COUNT[8]; // Уровень (0,1,2,3) + uint8_t in_error_connect[8]; // Конкретное устройство не ответило + uint8_t LinRespErr_Stat[8]; // Внутренняя ошибка устройства (ошибка коммутации) + uint8_t Err_Stat[8]; // Внутренняя ошибка устройства + uint8_t Error_Connect; // Ошибка LIN шины (не одно устройство не отвечает) +} SensorButtonCmdBusInput; +*/ +typedef struct { + osMutexId_t access; + + tLinData linData; + + tLoggerInterface *logger; + + tLinAt32 lin; + tLinIO lin_Io; + + struct { + tDRS_Stat d_DRS_Stat[LIN5_SENSOR_COUNT]; + tDRS_Stat d_old_DRS_Stat[LIN5_SENSOR_COUNT]; + uint8_t LED_COUNT[LIN5_SENSOR_COUNT]; + uint8_t LED_OLD_COUNT[LIN5_SENSOR_COUNT]; + uint8_t error_connect[LIN5_SENSOR_COUNT]; + uint8_t error_old_connect[LIN5_SENSOR_COUNT]; + + uint8_t prev_btn_state[LIN5_SENSOR_COUNT]; + + uint8_t LinRespErr_Stat[LIN5_SENSOR_COUNT]; + uint8_t Err_Stat[LIN5_SENSOR_COUNT]; + } linStateSensor; + + uint8_t error_connect; + + tCCU_DRS_Req d_CCU_DRS_Req; + tCCU_DRS_Req d_old_CCU_DRS_Req; + + + struct { + osThreadId_t id; + uint32_t stack[384]; + StaticTask_t controlBlock; + osThreadAttr_t attr; + } threadLin; + + +} tLin5TaskSensor; + +/* +void Lin_4_Init(tLin4TaskSensor *env, + tLinData *linData, + tLinIO *linIO, + tLoggerInterface *logger); + +void Lin4_StartThread(tLin4TaskSensor *env); +*/ + +void Lin_5_Init(tLin5TaskSensor *env, + tSerialPortIO *serialPortIO, + tLoggerInterface *logger); + +void Lin5_StartThread(tLin5TaskSensor *env); + + + + + + + +typedef struct { + tLoggerInterface *logger; + + struct { + osThreadId_t id; + uint32_t stack[384]; + StaticTask_t controlBlock; + osThreadAttr_t attr; + } threadLin; + +} tLinTimeoutsTask; + +void Lin_Timeouts_Init(tLinTimeoutsTask *env, tLoggerInterface *logger); + +void LinTimeouts_StartThread(tLinTimeoutsTask *env); +#endif //HVAC_DEV_LINSENSORTASKS_H diff --git a/modular.json b/modular.json new file mode 100755 index 0000000..99df025 --- /dev/null +++ b/modular.json @@ -0,0 +1,10 @@ +{ + "cmake": { + "inc_dirs": [ + "./" + ], + "srcs": [ + "./**.c" + ] + } +}