HVAC_M7
/
HVAC_M7_MONO
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Добавлены интерфейсы LIN MISSING

This commit is contained in:
cfif 2026-09-02 13:12:48 +03:00
parent 415b9b9d7b
commit 55fde50ae2
8 changed files with 180 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
MODULES/HVAC_M7_LIN_TASKS/LinActuatorTasks.c
View File

@ -1166,6 +1166,8 @@ void Lin_1_Init(tLinTaskActuator *env,
env->LIN_ISSR_ALL = LIN_ISSR_ALL; env->LIN_ISSR_ALL = LIN_ISSR_ALL;
env->access = osMutexNew(NULL); env->access = osMutexNew(NULL);
env->queue_error_missing = osMessageQueueNew(1, sizeof(env->error_missle), NULL);
memcpy(env->SIGN_LOG, "Ln1 ", sizeof("Ln1 ") - 1); memcpy(env->SIGN_LOG, "Ln1 ", sizeof("Ln1 ") - 1);
env->threadLin.stack = tLin1TaskActuator_stack; env->threadLin.stack = tLin1TaskActuator_stack;
@ -1254,6 +1256,8 @@ void Lin_2_Init(tLinTaskActuator *env,
env->LIN_ISSR_ALL = LIN_ISSR_ALL; env->LIN_ISSR_ALL = LIN_ISSR_ALL;
env->access = osMutexNew(NULL); env->access = osMutexNew(NULL);
env->queue_error_missing = osMessageQueueNew(1, sizeof(env->error_missle), NULL);
memcpy(env->SIGN_LOG, "Ln2 ", sizeof("Ln2 ") - 1); memcpy(env->SIGN_LOG, "Ln2 ", sizeof("Ln2 ") - 1);
env->threadLin.stack = tLin2TaskActuator_stack; env->threadLin.stack = tLin2TaskActuator_stack;
@ -1339,6 +1343,8 @@ void Lin_3_Init(tLinTaskActuator *env,
env->LIN_ISSR_ALL = LIN_ISSR_ALL; env->LIN_ISSR_ALL = LIN_ISSR_ALL;
env->access = osMutexNew(NULL); env->access = osMutexNew(NULL);
env->queue_error_missing = osMessageQueueNew(1, sizeof(env->error_missle), NULL);
memcpy(env->SIGN_LOG, "Ln3 ", sizeof("Ln3 ") - 1); memcpy(env->SIGN_LOG, "Ln3 ", sizeof("Ln3 ") - 1);
env->threadLin.stack = tLin3TaskActuator_stack; env->threadLin.stack = tLin3TaskActuator_stack;

8
MODULES/HVAC_M7_LIN_TASKS/LinActuatorTasks.h
View File

@ -399,6 +399,10 @@ typedef struct {
uint8_t error_connect; uint8_t error_connect;
uint32_t last_cycle;
uint8_t error_flag;
} tLinStateFullActuator; } tLinStateFullActuator;
// POS - Позиция // POS - Позиция
@ -471,6 +475,8 @@ typedef struct {
// Выходные данные (локальные) для модели // Выходные данные (локальные) для модели
ActuatorCmdBusInput actuator_Ch012_Input_Model_local; ActuatorCmdBusInput actuator_Ch012_Input_Model_local;
osMessageQueueId_t queue_error_missing;
uint8_t error_missle[9];
struct { struct {
osThreadId_t id; osThreadId_t id;
@ -520,4 +526,6 @@ void GetLin123CallbackHandler(tLinData *env, uint8_t u8LinIndex, void *state);
void Lin123_StopThread(tLinTaskActuator *env); void Lin123_StopThread(tLinTaskActuator *env);
void Lin123_Output_Get_From_Model(tLinTaskActuator *env, uint8_t *MISSING);
#endif //HVAC_LIN_TASKS_H #endif //HVAC_LIN_TASKS_H

59
MODULES/HVAC_M7_LIN_TASKS/LinActuatorWork.c
View File

@ -3,6 +3,7 @@
// //
#include "LinActuatorWork.h" #include "LinActuatorWork.h"
#include "string.h" #include "string.h"
#include "SystemDelayInterface.h"
//#define LOG_SIGN "Lin" //#define LOG_SIGN "Lin"
@ -56,6 +57,32 @@ static void showLogCommand(tLinTaskActuator *linTaskActuator, char *LOG_SIGN, ui
(numAct == 3 && LOG_LIN3_ACTUATOR == 1) ) (numAct == 3 && LOG_LIN3_ACTUATOR == 1) )
#endif #endif
// Это формирование выхода с модели с задачи Lin123
void Lin123_Output_Get_From_Model(tLinTaskActuator *env, uint8_t *MISSING) {
osStatus_t status = osOK;
uint32_t countQueue_space = osMessageQueueGetSpace(env->queue_error_missing);
if (countQueue_space == 0) {
status = osMessageQueueGet(env->queue_error_missing, MISSING, 0, 0);
}
}
static void Lin123_Output_Set_From_Model(tLinTaskActuator *env) {
osStatus_t status = osOK;
for (uint8_t i = 0; i < env->LIN_ISSR_ALL; ++i) {
env->error_missle[i] = env->linStateActuator[i].error_flag;
}
uint32_t countQueue_space = osMessageQueueGetSpace(env->queue_error_missing);
if (countQueue_space == 0) {
status = osMessageQueuePut(env->queue_error_missing, env->error_missle, 0, 0);
}
}
// actuator_Command_Model_local - Выход модели (команды для актуаторов) ЛОКАЛЬНО // actuator_Command_Model_local - Выход модели (команды для актуаторов) ЛОКАЛЬНО
// actuator_Command_Model_trigger_local - Выход модели (команды для актуаторов) ЗАХВАТ // actuator_Command_Model_trigger_local - Выход модели (команды для актуаторов) ЗАХВАТ
// actuator_Output_Model_local - Вход модели (состояния актуаторов) ЛОКАЛЬНЫЙ // actuator_Output_Model_local - Вход модели (состояния актуаторов) ЛОКАЛЬНЫЙ
@ -70,6 +97,8 @@ void LinActuatorWork(tLinTaskActuator *linTaskActuator, osMutexId_t modelTaskAcc
char *LOG_SIGN) { char *LOG_SIGN) {
uint32_t current_time = SystemGetMs();
for (uint8_t i = 0; i < linTaskActuator->LIN_ISSR_ALL; ++i) { for (uint8_t i = 0; i < linTaskActuator->LIN_ISSR_ALL; ++i) {
linTaskActuator->linCommandActuator[i].POS = actuator_Command_Model_local->POS[i]; linTaskActuator->linCommandActuator[i].POS = actuator_Command_Model_local->POS[i];
@ -102,15 +131,29 @@ void LinActuatorWork(tLinTaskActuator *linTaskActuator, osMutexId_t modelTaskAcc
linTaskActuator->linCommandActuator[i].Coils_Stop_SET = actuator_Command_Model_local->Coils_Stop_SET[i]; linTaskActuator->linCommandActuator[i].Coils_Stop_SET = actuator_Command_Model_local->Coils_Stop_SET[i];
// Заполнение данных ВХОДЫ МОДЕЛИ // Заполнение данных ВХОДЫ МОДЕЛИ
actuator_Output_Model_local->in_CPOS_ALL[i] = (int16_t) linTaskActuator->linStateActuator[i].CPOS_ALL; actuator_Output_Model_local->in_CPOS_ALL[i] = linTaskActuator->linStateActuator[i].CPOS_ALL;
actuator_Output_Model_local->in_Act_Emrf_Slave[i] = (int8_t) linTaskActuator->linStateActuator[i].Emrf_Slave; actuator_Output_Model_local->in_Act_Emrf_Slave[i] = linTaskActuator->linStateActuator[i].Emrf_Slave;
actuator_Output_Model_local->in_Mode_Slave[i] = (int8_t) linTaskActuator->linStateActuator[i].Mode_Slave; actuator_Output_Model_local->in_Mode_Slave[i] = linTaskActuator->linStateActuator[i].Mode_Slave;
actuator_Output_Model_local->in_Act_Err1_Supply[i] = (int8_t) linTaskActuator->linStateActuator[i].Error1_Supply_Slave; actuator_Output_Model_local->in_Act_Err1_Supply[i] = linTaskActuator->linStateActuator[i].Error1_Supply_Slave;
actuator_Output_Model_local->in_Act_Err2_Communication[i] = (int8_t) linTaskActuator->linStateActuator[i].Error2_Communication_Slave; actuator_Output_Model_local->in_Act_Err2_Communication[i] = linTaskActuator->linStateActuator[i].Error2_Communication_Slave;
actuator_Output_Model_local->in_Act_Err3_Temperature[i] = (int8_t) linTaskActuator->linStateActuator[i].Error3_Temperature_Slave; actuator_Output_Model_local->in_Act_Err3_Temperature[i] = linTaskActuator->linStateActuator[i].Error3_Temperature_Slave;
actuator_Output_Model_local->in_Act_Err4_Permanent_Electrical[i] = (int8_t) linTaskActuator->linStateActuator[i].Error4_Permanent_Electrical_Slave; actuator_Output_Model_local->in_Act_Err4_Permanent_Electrical[i] = linTaskActuator->linStateActuator[i].Error4_Permanent_Electrical_Slave;
actuator_Output_Model_local->in_Act_Stall_Slave[i] = linTaskActuator->linStateActuator[i].Stall_Slave; actuator_Output_Model_local->in_Act_Stall_Slave[i] = linTaskActuator->linStateActuator[i].Stall_Slave;
actuator_Output_Model_local->in_Act_Reset[i] = linTaskActuator->linStateActuator[i].Reset_Slave; actuator_Output_Model_local->in_Act_Reset[i] = linTaskActuator->linStateActuator[i].Reset_Slave;
if (linTaskActuator->linStateActuator[i].error_connect) {
// Проверяем таймаут
uint32_t diff = current_time - linTaskActuator->linStateActuator[i].last_cycle;
uint8_t error = (diff > 4000) ? 1 : 0;
// Сохраняем ошибку
linTaskActuator->linStateActuator[i].error_flag = error;
} else {
linTaskActuator->linStateActuator[i].error_flag = 0;
linTaskActuator->linStateActuator[i].last_cycle = SystemGetMs();
}
} }
// Заполнение данных ВХОДЫ МОДЕЛИ // Заполнение данных ВХОДЫ МОДЕЛИ
@ -118,7 +161,7 @@ void LinActuatorWork(tLinTaskActuator *linTaskActuator, osMutexId_t modelTaskAcc
// LoggerFormatTrace(LOGGER, LOG_SIGN, "Busy = %d Error_Connect = %d", actuator_Output_Model_local->Busy, actuator_Output_Model_local->Error_Connect) // LoggerFormatTrace(LOGGER, LOG_SIGN, "Busy = %d Error_Connect = %d", actuator_Output_Model_local->Busy, actuator_Output_Model_local->Error_Connect)
Lin123_Output_Set_From_Model(linTaskActuator);

105
MODULES/HVAC_M7_LIN_TASKS/LinSensorTasks.c
View File

@ -208,10 +208,16 @@ void Lin4_Output_Set_Model(tLin4TaskSensor *env) {
status = osMessageQueuePut(env->queue_input_Lin4_Stat, &env->sensorLin4CmdBusInput, 0, 0); status = osMessageQueuePut(env->queue_input_Lin4_Stat, &env->sensorLin4CmdBusInput, 0, 0);
} }
countQueue_space = osMessageQueueGetSpace(env->queue_error_missing);
if (countQueue_space) {
status = osMessageQueuePut(env->queue_error_missing, env->error_flag, 0, 0);
}
} }
// Это формирование выхода с модели с задачи Lin4 // Это формирование выхода с модели с задачи Lin4
void Lin4_Output_Get_From_Model(tLin4TaskSensor *env) { void Lin4_Output_Get_From_Model(tLin4TaskSensor *env, uint8_t *MISSING) {
osStatus_t status = osOK; osStatus_t status = osOK;
uint32_t countQueue_space = osMessageQueueGetSpace(env->queue_input_tAirQS); uint32_t countQueue_space = osMessageQueueGetSpace(env->queue_input_tAirQS);
@ -234,6 +240,11 @@ void Lin4_Output_Get_From_Model(tLin4TaskSensor *env) {
status = osMessageQueueGet(env->queue_input_tIonizer, &rtDW.LIN4_Ionizer_Stat_Model, 0, 0); status = osMessageQueueGet(env->queue_input_tIonizer, &rtDW.LIN4_Ionizer_Stat_Model, 0, 0);
} }
countQueue_space = osMessageQueueGetSpace(env->queue_error_missing);
if (countQueue_space == 0) {
status = osMessageQueueGet(env->queue_error_missing, MISSING, 0, 0);
}
} }
// Это формирование входа с модели на задачу Lin4 // Это формирование входа с модели на задачу Lin4
@ -484,6 +495,8 @@ void Lin_4_Init(tLin4TaskSensor *env,
env->queue_input_tCCU = osMessageQueueNew(1, sizeof(LIN4_CCU_Req_Bus), NULL); env->queue_input_tCCU = osMessageQueueNew(1, sizeof(LIN4_CCU_Req_Bus), NULL);
env->queue_error_missing = osMessageQueueNew(1, sizeof(env->error_flag), NULL);
env->queue_input_tAirQS = osMessageQueueNew(1, sizeof(LIN4_AirQS_Stat_Bus), NULL); env->queue_input_tAirQS = osMessageQueueNew(1, sizeof(LIN4_AirQS_Stat_Bus), NULL);
env->queue_input_tAroma = osMessageQueueNew(1, sizeof(LIN4_Aroma_Stat_Bus), NULL); env->queue_input_tAroma = osMessageQueueNew(1, sizeof(LIN4_Aroma_Stat_Bus), NULL);
env->queue_input_tIonizer = osMessageQueueNew(1, sizeof(LIN4_Ionizer_Stat_Bus), NULL); env->queue_input_tIonizer = osMessageQueueNew(1, sizeof(LIN4_Ionizer_Stat_Bus), NULL);
@ -495,7 +508,8 @@ void Lin_4_Init(tLin4TaskSensor *env,
env->threadLin.stack = tLin4TaskSensor_stack; env->threadLin.stack = tLin4TaskSensor_stack;
InitThreadAtr(&env->threadLin.attr,"Ln4",&env->threadLin.controlBlock,sizeof(env->threadLin.controlBlock),env->threadLin.stack,tLin4TaskSensor_stack_size,osPriorityNormal); InitThreadAtr(&env->threadLin.attr, "Ln4", &env->threadLin.controlBlock, sizeof(env->threadLin.controlBlock),
env->threadLin.stack, tLin4TaskSensor_stack_size, osPriorityNormal);
env->threadLin.id = 0; env->threadLin.id = 0;
// InitThreadAtrStatic(&env->threadLin.attr, "Ln4", env->threadLin.controlBlock, env->threadLin.stack, // InitThreadAtrStatic(&env->threadLin.attr, "Ln4", env->threadLin.controlBlock, env->threadLin.stack,
@ -512,24 +526,39 @@ static _Noreturn void Lin4_Thread(tLin4TaskSensor *env) {
lin_event_id_t res = Lin4_Scheduler(env); lin_event_id_t res = Lin4_Scheduler(env);
uint32_t current_time = SystemGetMs();
uint8_t isError = 0; uint8_t isError = 0;
for (uint8_t i = 0; i < LIN4_SENSOR_COUNT; ++i) { for (uint8_t i = 0; i < LIN4_SENSOR_COUNT; ++i) {
if (env->error_connect[i] == 1) if (env->error_connect[i] == 1) {
++isError; ++isError;
// Проверяем таймаут
uint32_t diff = current_time - env->last_cycle[i];
uint8_t error = (diff > 4000) ? 1 : 0;
// Сохраняем ошибку
env->error_flag[i] = error;
} else {
env->error_flag[i] = 0;
env->last_cycle[i] = SystemGetMs();
} }
}
if (isError == LIN4_SENSOR_COUNT) { if (isError == LIN4_SENSOR_COUNT) {
env->error_all_connect = 1; env->error_all_connect = 1;
} else { } else {
env->error_all_connect = 0; env->error_all_connect = 0;
} }
Lin4_Output_Set_Model(env); Lin4_Output_Set_Model(env);
osMutexRelease(env->access); osMutexRelease(env->access);
} }
} }
} }
void Lin4_StartThread(tLin4TaskSensor *env) { void Lin4_StartThread(tLin4TaskSensor *env) {
@ -739,8 +768,7 @@ static void Lin5_Input_Get_From_Model(tLin5TaskSensor *env) {
} }
void Lin5_Output_Get_From_Model(tLin5TaskSensor *env, uint8_t *LIN_ERROR_MISSLE) {
void Lin5_Output_Get_From_Model(tLin5TaskSensor *env) {
uint32_t countQueue_space = osMessageQueueGetSpace(env->queue_led_count); uint32_t countQueue_space = osMessageQueueGetSpace(env->queue_led_count);
@ -748,8 +776,37 @@ void Lin5_Output_Get_From_Model(tLin5TaskSensor *env) {
osStatus_t status = osMessageQueueGet(env->queue_led_count, &rtDW.LIN5_SENSON_ADR_Stat_model, 0, 0); osStatus_t status = osMessageQueueGet(env->queue_led_count, &rtDW.LIN5_SENSON_ADR_Stat_model, 0, 0);
} }
countQueue_space = osMessageQueueGetSpace(env->queue_led_error_missing);
if (countQueue_space == 0) {
osStatus_t status = osMessageQueueGet(env->queue_led_error_missing, LIN_ERROR_MISSLE, 0, 0);
}
} }
// Это с выхода Lin5
static void Lin5_Output_Set_Model(tLin5TaskSensor *env) {
uint32_t countQueue_led_count = osMessageQueueGetSpace(env->queue_led_count);
osStatus_t status = osOK;
if (countQueue_led_count) {
memcpy(env->sensorButtonCmdBusInput.in_COUNT, env->linStateSensor.LED_COUNT, LIN5_SENSOR_COUNT);
memcpy(env->sensorButtonCmdBusInput.in_error_connect, env->linStateSensor.error_connect, LIN5_SENSOR_COUNT);
memcpy(env->sensorButtonCmdBusInput.LinRespErr_Stat, env->linStateSensor.LinRespErr_Stat, LIN5_SENSOR_COUNT);
memcpy(env->sensorButtonCmdBusInput.Err_Stat, env->linStateSensor.Err_Stat, LIN5_SENSOR_COUNT);
env->sensorButtonCmdBusInput.Error_Connect = env->error_connect;
status = osMessageQueuePut(env->queue_led_count, &env->sensorButtonCmdBusInput, 0, 0U);
}
countQueue_led_count = osMessageQueueGetSpace(env->queue_led_error_missing);
if (countQueue_led_count) {
status = osMessageQueuePut(env->queue_led_error_missing, &env->linStateSensor.error_flag, 0, 0U);
}
}
static lin_event_id_t Lin5_Scheduler(tLin5TaskSensor *env) { static lin_event_id_t Lin5_Scheduler(tLin5TaskSensor *env) {
lin_event_id_t ret = LIN_NO_EVENT; lin_event_id_t ret = LIN_NO_EVENT;
@ -815,19 +872,7 @@ static lin_event_id_t Lin5_Scheduler(tLin5TaskSensor *env) {
} }
uint32_t countQueue_led_count = osMessageQueueGetSpace(env->queue_led_count); Lin5_Output_Set_Model(env);
osStatus_t status = osOK;
if (countQueue_led_count) {
memcpy(env->sensorButtonCmdBusInput.in_COUNT, env->linStateSensor.LED_COUNT, LIN5_SENSOR_COUNT);
memcpy(env->sensorButtonCmdBusInput.in_error_connect, env->linStateSensor.error_connect, LIN5_SENSOR_COUNT);
memcpy(env->sensorButtonCmdBusInput.LinRespErr_Stat, env->linStateSensor.LinRespErr_Stat, LIN5_SENSOR_COUNT);
memcpy(env->sensorButtonCmdBusInput.Err_Stat, env->linStateSensor.Err_Stat, LIN5_SENSOR_COUNT);
env->sensorButtonCmdBusInput.Error_Connect = env->error_connect;
status = osMessageQueuePut(env->queue_led_count, &env->sensorButtonCmdBusInput, 0, 0U);
}
Lin5_Input_Get_From_Model(env); Lin5_Input_Get_From_Model(env);
@ -879,8 +924,11 @@ void Lin_5_Init(tLin5TaskSensor *env,
env->queue_led_count = osMessageQueueNew(1, sizeof(LIN5_SENSON_ADR_Stat_Bus), NULL); env->queue_led_count = osMessageQueueNew(1, sizeof(LIN5_SENSON_ADR_Stat_Bus), NULL);
env->queue_led_input_model_count = osMessageQueueNew(1, sizeof(LinStateSensorModel), NULL); env->queue_led_input_model_count = osMessageQueueNew(1, sizeof(LinStateSensorModel), NULL);
env->queue_led_error_missing = osMessageQueueNew(1, sizeof(env->linStateSensor.error_flag), NULL);
env->threadLin.stack = tLin5TaskSensor_stack; env->threadLin.stack = tLin5TaskSensor_stack;
InitThreadAtr(&env->threadLin.attr,"Ln5",&env->threadLin.controlBlock,sizeof(env->threadLin.controlBlock),env->threadLin.stack,tLin5TaskSensor_stack_size,osPriorityNormal); InitThreadAtr(&env->threadLin.attr, "Ln5", &env->threadLin.controlBlock, sizeof(env->threadLin.controlBlock),
env->threadLin.stack, tLin5TaskSensor_stack_size, osPriorityNormal);
env->threadLin.id = 0; env->threadLin.id = 0;
// InitThreadAtrStatic(&env->threadLin.attr, "Ln5", env->threadLin.controlBlock, env->threadLin.stack, // InitThreadAtrStatic(&env->threadLin.attr, "Ln5", env->threadLin.controlBlock, env->threadLin.stack,
@ -895,10 +943,25 @@ static _Noreturn void Lin5_Thread(tLin5TaskSensor *env) {
lin_event_id_t res = Lin5_Scheduler(env); lin_event_id_t res = Lin5_Scheduler(env);
uint32_t current_time = SystemGetMs();
uint8_t isError = 0; uint8_t isError = 0;
for (uint8_t i = 0; i < LIN5_SENSOR_COUNT; ++i) { for (uint8_t i = 0; i < LIN5_SENSOR_COUNT; ++i) {
if (env->linStateSensor.error_connect[i] == 1)
if (env->linStateSensor.error_connect[i] == 1) {
++isError; ++isError;
// Проверяем таймаут
uint32_t diff = current_time - env->linStateSensor.last_cycle[i];
uint8_t error = (diff > 4000) ? 1 : 0;
// Сохраняем ошибку
env->linStateSensor.error_flag[i] = error;
} else {
env->linStateSensor.error_flag[i] = 0;
env->linStateSensor.last_cycle[i] = SystemGetMs();
}
} }
if (isError == LIN5_SENSOR_COUNT) { if (isError == LIN5_SENSOR_COUNT) {

17
MODULES/HVAC_M7_LIN_TASKS/LinSensorTasks.h
View File

@ -12,7 +12,7 @@
#include "HVAC_model.h" #include "HVAC_model.h"
#define LOG_LIN4_SENSOR 0 #define LOG_LIN4_SENSOR 0
#define LOG_LIN5_SENSOR 0 #define LOG_LIN5_SENSOR 1
#define LIN4_SENSOR_COUNT 7 #define LIN4_SENSOR_COUNT 7
@ -330,6 +330,8 @@ typedef struct {
osMessageQueueId_t queue_input_tCCU; osMessageQueueId_t queue_input_tCCU;
osMessageQueueId_t queue_error_missing;
osMessageQueueId_t queue_input_tAirQS; osMessageQueueId_t queue_input_tAirQS;
osMessageQueueId_t queue_input_tAroma; osMessageQueueId_t queue_input_tAroma;
osMessageQueueId_t queue_input_tIonizer; osMessageQueueId_t queue_input_tIonizer;
@ -342,6 +344,9 @@ typedef struct {
uint8_t error_connect[LIN4_SENSOR_COUNT]; uint8_t error_connect[LIN4_SENSOR_COUNT];
uint8_t error_all_connect; uint8_t error_all_connect;
uint32_t last_cycle[LIN4_SENSOR_COUNT];
uint8_t error_flag[LIN4_SENSOR_COUNT];
struct { struct {
osThreadId_t id; osThreadId_t id;
//uint32_t stack[384]; //uint32_t stack[384];
@ -383,6 +388,8 @@ typedef struct {
osMessageQueueId_t queue_led_count; osMessageQueueId_t queue_led_count;
osMessageQueueId_t queue_led_input_model_count; osMessageQueueId_t queue_led_input_model_count;
osMessageQueueId_t queue_led_error_missing;
struct { struct {
tDRS_Stat d_DRS_Stat[LIN5_SENSOR_COUNT]; tDRS_Stat d_DRS_Stat[LIN5_SENSOR_COUNT];
tDRS_Stat d_old_DRS_Stat[LIN5_SENSOR_COUNT]; tDRS_Stat d_old_DRS_Stat[LIN5_SENSOR_COUNT];
@ -396,6 +403,10 @@ typedef struct {
uint8_t LinRespErr_Stat[LIN5_SENSOR_COUNT]; uint8_t LinRespErr_Stat[LIN5_SENSOR_COUNT];
uint8_t Err_Stat[LIN5_SENSOR_COUNT]; uint8_t Err_Stat[LIN5_SENSOR_COUNT];
uint32_t last_cycle[LIN5_SENSOR_COUNT];
uint8_t error_flag[LIN5_SENSOR_COUNT];
} linStateSensor; } linStateSensor;
uint8_t error_connect; uint8_t error_connect;
@ -424,7 +435,7 @@ void Lin4_StartThread(tLin4TaskSensor *env);
void Lin4_StopThread(tLin4TaskSensor *env); void Lin4_StopThread(tLin4TaskSensor *env);
void Lin4_Input_Set_From_Model(tLin4TaskSensor *env); void Lin4_Input_Set_From_Model(tLin4TaskSensor *env);
void Lin4_Output_Get_From_Model(tLin4TaskSensor *env); void Lin4_Output_Get_From_Model(tLin4TaskSensor *env, uint8_t *MISSING);
void Lin_5_Init(tLin5TaskSensor *env, void Lin_5_Init(tLin5TaskSensor *env,
tLinData *linData, tLinData *linData,
@ -434,7 +445,7 @@ void Lin_5_Init(tLin5TaskSensor *env,
void Lin5_StartThread(tLin5TaskSensor *env); void Lin5_StartThread(tLin5TaskSensor *env);
void Lin5_StopThread(tLin5TaskSensor *env); void Lin5_StopThread(tLin5TaskSensor *env);
void Lin5_Output_Get_From_Model(tLin5TaskSensor *env); void Lin5_Output_Get_From_Model(tLin5TaskSensor *env, uint8_t *LIN_ERROR_MISSLE);
void Lin5_Input_Set_From_Model(tLin5TaskSensor *env); void Lin5_Input_Set_From_Model(tLin5TaskSensor *env);

7
MODULES/HVAC_M7_MODEL/Model_Task.c
View File

@ -702,8 +702,11 @@ static _Noreturn void ModelTask_Thread(tModelTask *env) {
//конец--------------------------------------------------ВХОД МОДЕЛИ SLEEP---------------------------------------------- //конец--------------------------------------------------ВХОД МОДЕЛИ SLEEP----------------------------------------------
//начало-------------------------------------------------ВХОД МОДЕЛИ LIN4 LIN5------------------------------------------ //начало-------------------------------------------------ВХОД МОДЕЛИ LIN4 LIN5------------------------------------------
Lin4_Output_Get_From_Model(env->lin4TaskSensor); Lin123_Output_Get_From_Model(env->linTaskActuator1, env->LIN1_ERROR_MISSLE);
Lin5_Output_Get_From_Model(env->lin5TaskSensor); Lin123_Output_Get_From_Model(env->linTaskActuator2, env->LIN2_ERROR_MISSLE);
Lin123_Output_Get_From_Model(env->linTaskActuator3, env->LIN3_ERROR_MISSLE);
Lin4_Output_Get_From_Model(env->lin4TaskSensor, env->LIN4_ERROR_MISSLE);
Lin5_Output_Get_From_Model(env->lin5TaskSensor, env->LIN5_ERROR_MISSLE);
//конец--------------------------------------------------ВХОД МОДЕЛИ LIN4 LIN5------------------------------------------ //конец--------------------------------------------------ВХОД МОДЕЛИ LIN4 LIN5------------------------------------------
//ШАГ МОДЕЛИ------------------------------------------------------------------------------------------------------------ //ШАГ МОДЕЛИ------------------------------------------------------------------------------------------------------------

7
MODULES/HVAC_M7_MODEL/Model_Task.h
View File

@ -44,6 +44,13 @@ typedef struct {
ccu_candb_time_missing_rx_t CAN_TIME_MISSLE; ccu_candb_time_missing_rx_t CAN_TIME_MISSLE;
uint8_t LIN1_ERROR_MISSLE[9];
uint8_t LIN2_ERROR_MISSLE[9];
uint8_t LIN3_ERROR_MISSLE[9];
uint8_t LIN4_ERROR_MISSLE[LIN4_SENSOR_COUNT];
uint8_t LIN5_ERROR_MISSLE[LIN5_SENSOR_COUNT];
uint8_t dtc_state_error[127]; uint8_t dtc_state_error[127];
tLoggerInterface *logger; tLoggerInterface *logger;

5
MODULES/HVAC_M7_StatusData/DiagnosticTask.c
View File

@ -427,6 +427,10 @@ static void setErrorDTC_CAN(tDiagnostic *env, uint8_t *dtc_state_error_model, cc
} }
} }
static void setErrorDTC_LIN() {
// Actuator_Ch0_Status_Model.
}
void set_Dtc_state(tDiagnostic *env, CCU_Errors_t *CCU_Errors, void set_Dtc_state(tDiagnostic *env, CCU_Errors_t *CCU_Errors,
uint8_t *dtc_state_error_model, char *VIN, uint8_t *dtc_state_error_model, char *VIN,
ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE, ccu_candb_time_missing_rx_t *CAN_TIME_MISSLE) { ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE, ccu_candb_time_missing_rx_t *CAN_TIME_MISSLE) {
@ -441,6 +445,7 @@ void set_Dtc_state(tDiagnostic *env, CCU_Errors_t *CCU_Errors,
} }
for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) { for (uint8_t i = 0; i < COUNT_DTC_CODE_ERROR; ++i) {
if (dtc_state_error_model[i]) { if (dtc_state_error_model[i]) {
dtc_state_error_model[i] = DTC_TEST_FAILED_CONFIRMED; dtc_state_error_model[i] = DTC_TEST_FAILED_CONFIRMED;