631 lines
23 KiB
C
631 lines
23 KiB
C
//
|
||
// Created by cfif on 12.02.2026.
|
||
//
|
||
#include <SystemDelayInterface.h>
|
||
#include "LinSensorTasks.h"
|
||
#include "CmsisRtosThreadUtils.h"
|
||
#include "CanPorts.h"
|
||
#include "fc7xxx_driver_lin.h"
|
||
#include "Lins.h"
|
||
#include "LoggerInterface.h"
|
||
#include "memory.h"
|
||
|
||
#define LOG_SIGN4 "Ln4"
|
||
#define LOG_SIGN5 "Ln5"
|
||
#define LOGGER env->logger
|
||
|
||
const uint8_t LIN5_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};
|
||
|
||
const uint8_t LIN4_SENSON_ADR_Stat[LIN4_SENSOR_COUNT] = {AirQS_Stat,
|
||
Aroma_Stat,
|
||
Ionizer_Stat,
|
||
eTXV_fHVAC_Stat,
|
||
eTXV_rHVAC_Stat,
|
||
eTXV_batChiller_Stat,
|
||
eTXV_eeChiller_Stat};
|
||
|
||
const uint8_t LIN4_SENSON_LEN_Stat[LIN4_SENSOR_COUNT] = {sizeof(tAirQS_Stat),
|
||
sizeof(tAroma_Stat),
|
||
sizeof(tIonizer_Stat),
|
||
sizeof(teTXV_fHVAC_Stat),
|
||
sizeof(teTXV_rHVAC_Stat),
|
||
sizeof(teTXV_batChiller_Stat),
|
||
sizeof(teTXV_eeChiller_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, COM_ADR, 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_Sensor4_Stat(tLinIO *linIo, tLinData *linData, void *p_Stat, uint8_t p_Stat_Len, uint8_t ADR_stat) {
|
||
lin_event_id_t res;
|
||
|
||
void *pStat_ = (void *) linData->g_aRxBuffer;
|
||
|
||
uint8_t retry = 1;
|
||
|
||
while (retry) {
|
||
|
||
linData->direction = LIN_DIRECTION_GET;
|
||
|
||
linData->g_aTxBufferLen = 0;
|
||
linData->g_aRxBufferLen = p_Stat_Len;
|
||
|
||
res = SEND_SENSOR_COM_x(linIo, ADR_stat);
|
||
|
||
if (res == LIN_RX_COMPLETED) {
|
||
memcpy(p_Stat, pStat_, p_Stat_Len);
|
||
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_SENSOR == 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
|
||
|
||
for (uint8_t i = 0; i < LIN4_SENSOR_COUNT; ++i) {
|
||
|
||
ret = Get_Sensor4_Stat(env->linIo, env->linData, &env->Stat[i], LIN4_SENSON_LEN_Stat[i],
|
||
LIN4_SENSON_ADR_Stat[i]);
|
||
|
||
switch (i) {
|
||
|
||
case eeAirQS_Stat: {
|
||
tAirQS_Stat *pAirQS_Stat = (tAirQS_Stat *) &env->Stat[i];
|
||
|
||
#if (LOG_LIN4_SENSOR == 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",
|
||
pAirQS_Stat->AirQS_LinRespErr_Stat,
|
||
pAirQS_Stat->AirQS_Sens_Stat,
|
||
pAirQS_Stat->AirQS_Combined_Stat,
|
||
pAirQS_Stat->AirQS_Err_Stat,
|
||
pAirQS_Stat->AirQS_COLvl_Stat,
|
||
pAirQS_Stat->AirQS_NOxLvl_Stat,
|
||
pAirQS_Stat->AirQS_NH3Lvl_Stat)
|
||
} else {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4, "LIN4 ERROR (pAirQS_Stat) = %d", ret)
|
||
}
|
||
|
||
#endif
|
||
|
||
break;
|
||
}
|
||
case eeAroma_Stat: {
|
||
tAroma_Stat *pAroma_Stat = (tAroma_Stat *) &env->Stat[i];
|
||
|
||
if (ret == LIN_RX_COMPLETED) {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4,
|
||
"Aroma_LinRespErr_Stat = %d Aroma_CartridgeSw_Stat = %d Aroma_Err_Stat = %d Aroma_Intens_Stat = %d Aroma_CartridgeFlavor_Stat = %d Aroma_CartridgeCapacity_Stat = %d",
|
||
pAroma_Stat->Aroma_LinRespErr_Stat,
|
||
pAroma_Stat->Aroma_CartridgeSw_Stat,
|
||
pAroma_Stat->Aroma_Err_Stat,
|
||
pAroma_Stat->Aroma_Intens_Stat,
|
||
pAroma_Stat->Aroma_CartridgeFlavor_Stat,
|
||
pAroma_Stat->Aroma_CartridgeCapacity_Stat)
|
||
} else {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4, "LIN4 ERROR (pAroma_Stat) = %d", ret)
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case eeIonizer_Stat: {
|
||
tIonizer_Stat *pIonizer_Stat = (tIonizer_Stat *) &env->Stat[i];
|
||
|
||
if (ret == LIN_RX_COMPLETED) {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4,
|
||
"Ionizer_LinRespErr_Stat = %d Ionizer_Err_Stat = %d Ionizer_Ionization_Stat = %d",
|
||
pIonizer_Stat->Ionizer_LinRespErr_Stat,
|
||
pIonizer_Stat->Ionizer_Err_Stat,
|
||
pIonizer_Stat->Ionizer_Ionization_Stat)
|
||
} else {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4, "LIN4 ERROR (pIonizer_Stat) = %d", ret)
|
||
}
|
||
|
||
break;
|
||
}
|
||
case eeTXV_fHVAC_Stat: {
|
||
teTXV_fHVAC_Stat *p_teTXV_fHVAC_Stat = (teTXV_fHVAC_Stat *) &env->Stat[i];
|
||
|
||
if (ret == LIN_RX_COMPLETED) {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4,
|
||
"eTXV_fHVAC_Pos_Stat = %d eTXV_fHVAC_LinRespErr_Stat = %d eTXV_fHVAC_Err_Stat = %d eTXV_fHVAC_Pressure_Val = %d eTXV_fHVAC_Temp_Val = %d",
|
||
p_teTXV_fHVAC_Stat->eTXV_fHVAC_Pos_Stat,
|
||
p_teTXV_fHVAC_Stat->eTXV_fHVAC_LinRespErr_Stat,
|
||
p_teTXV_fHVAC_Stat->eTXV_fHVAC_Err_Stat,
|
||
p_teTXV_fHVAC_Stat->eTXV_fHVAC_Pressure_Val,
|
||
p_teTXV_fHVAC_Stat->eTXV_fHVAC_Temp_Val)
|
||
} else {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4, "LIN4 ERROR (p_teTXV_fHVAC_Stat) = %d", ret)
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case eeTXV_rHVAC_Stat: {
|
||
teTXV_rHVAC_Stat *p_teTXV_rHVAC_Stat = (teTXV_rHVAC_Stat *) &env->Stat[i];
|
||
|
||
if (ret == LIN_RX_COMPLETED) {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4,
|
||
"eTXV_rHVAC_Pos_Stat = %d eTXV_rHVAC_LinRespErr_Stat = %d eTXV_rHVAC_Err_Stat = %d eTXV_fHVAC_Pressure_Val = %d eTXV_rHVAC_Temp_Val = %d",
|
||
p_teTXV_rHVAC_Stat->eTXV_rHVAC_Pos_Stat,
|
||
p_teTXV_rHVAC_Stat->eTXV_rHVAC_LinRespErr_Stat,
|
||
p_teTXV_rHVAC_Stat->eTXV_rHVAC_Err_Stat,
|
||
p_teTXV_rHVAC_Stat->eTXV_rHVAC_Pressure_Val,
|
||
p_teTXV_rHVAC_Stat->eTXV_rHVAC_Temp_Val)
|
||
} else {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4, "LIN4 ERROR (p_teTXV_rHVAC_Stat) = %d", ret)
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case eeTXV_batChiller_Stat: {
|
||
teTXV_batChiller_Stat *p_teTXV_batChiller_Stat = (teTXV_batChiller_Stat *) &env->Stat[i];
|
||
|
||
if (ret == LIN_RX_COMPLETED) {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4,
|
||
"eTXV_batChiller_Pos_Stat = %d eTXV_batChiller_LinRespErr_Stat = %d eTXV_batChiller_Err_Stat = %d eTXV_batChiller_Pressure_Val = %d eTXV_batChiller_Temp_Val = %d",
|
||
p_teTXV_batChiller_Stat->eTXV_batChiller_Pos_Stat,
|
||
p_teTXV_batChiller_Stat->eTXV_batChiller_LinRespErr_Stat,
|
||
p_teTXV_batChiller_Stat->eTXV_batChiller_Err_Stat,
|
||
p_teTXV_batChiller_Stat->eTXV_batChiller_Pressure_Val,
|
||
p_teTXV_batChiller_Stat->eTXV_batChiller_Temp_Val)
|
||
} else {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4, "LIN4 ERROR (p_teTXV_batChiller_Stat) = %d", ret)
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case eeTXV_eeChiller_Stat: {
|
||
teTXV_eeChiller_Stat *p_teTXV_eeChiller_Stat = (teTXV_eeChiller_Stat *) &env->Stat[i];
|
||
|
||
if (ret == LIN_RX_COMPLETED) {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4,
|
||
"eTXV_eeChiller_Stat_ = %d eTXV_eeChiller_LinRespErr_Stat = %d eTXV_eeChiller_Err_Stat = %d eTXV_eeChiller_Pressure_Val = %d eTXV_eeChiller_Temp_Val = %d",
|
||
p_teTXV_eeChiller_Stat->eTXV_eeChiller_Stat_,
|
||
p_teTXV_eeChiller_Stat->eTXV_eeChiller_LinRespErr_Stat,
|
||
p_teTXV_eeChiller_Stat->eTXV_eeChiller_Err_Stat,
|
||
p_teTXV_eeChiller_Stat->eTXV_eeChiller_Pressure_Val,
|
||
p_teTXV_eeChiller_Stat->eTXV_eeChiller_Temp_Val)
|
||
} else {
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN4, "LIN4 ERROR (p_teTXV_eeChiller_Stat) = %d", ret)
|
||
}
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
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_DL_Stat(tLinIO *linIo, tLinData *linData, tDRS_DL_Stat *p_tDRS_DL_Stat) {
|
||
lin_event_id_t res;
|
||
|
||
tDRS_DL_Stat *tDRS_DL_Stat_ = (tDRS_DL_Stat *) linData->g_aRxBuffer;
|
||
|
||
uint8_t retry = 3;
|
||
|
||
while (retry) {
|
||
|
||
linData->direction = LIN_DIRECTION_GET;
|
||
|
||
linData->g_aTxBufferLen = 0;
|
||
linData->g_aRxBufferLen = sizeof(tDRS_DL_Stat);
|
||
|
||
res = SEND_SENSOR_COM_x(linIo, DRS_DL_Stat);
|
||
|
||
if (res == LIN_RX_COMPLETED) {
|
||
memcpy(p_tDRS_DL_Stat, tDRS_DL_Stat_, sizeof(tDRS_DL_Stat));
|
||
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;
|
||
}
|
||
}
|
||
|
||
void getSensorLin5(tLin5TaskSensor *env, void *dataLedSensor) {
|
||
osStatus_t status = osMessageQueueGet(env->queue_led_count, dataLedSensor, 0, 0);
|
||
}
|
||
|
||
|
||
static lin_event_id_t Lin5_Scheduler(tLin5TaskSensor *env) {
|
||
lin_event_id_t ret = LIN_NO_EVENT;
|
||
|
||
SystemDelayMs(40);
|
||
|
||
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(40);
|
||
|
||
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], LIN5_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
|
||
}
|
||
|
||
// }
|
||
|
||
}
|
||
|
||
uint32_t countQueue_led_count = osMessageQueueGetSpace(env->queue_led_count);
|
||
|
||
if (countQueue_led_count) {
|
||
osStatus_t status = osMessageQueuePut(env->queue_led_count, env->linStateSensor.LED_COUNT, 0, 0U);
|
||
}
|
||
|
||
return LIN_NO_EVENT;
|
||
}
|
||
|
||
void Lin_5_Init(tLin5TaskSensor *env,
|
||
tLinData *linData,
|
||
tLinIO *linIO,
|
||
tLoggerInterface *logger) {
|
||
|
||
env->linIo = linIO;
|
||
env->linData = linData;
|
||
env->logger = logger;
|
||
env->access = osMutexNew(NULL);
|
||
|
||
env->queue_led_count = osMessageQueueNew(1, sizeof(env->linStateSensor.LED_COUNT), 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 ----------------------------------------------------------------
|