HVAC_M7
/
HVAC_M7_MONO
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
HVAC_M7_MONO/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.c

452 lines
21 KiB
C
Raw Blame History

//
// Created by cfif on 05.04.2024.
//
#include <SystemDelayInterface.h>
#include "CanSpamReceiver.h"
#include "CmsisRtosThreadUtils.h"
#include "CanPorts.h"
#include "string.h"
#include "HVAC_model.h"
#include "MainStack.h"
#define LOG_SIGN "CAN_RECEIVED"
#define LOGGER env->logger
// Структура для таблицы мониторов
typedef struct {
uint32_t can_id;
FrameMonitor_t *monitor;
uint8_t *error_flag;
uint32_t *time_flag;
} CAN_MonitorEntry_t;
// Таблица всех мониторов
static const CAN_MonitorEntry_t g_can_monitors[] = {
{ESC_04_CANID, &ccu_candb_rx.ESC_04.mon1, &ccu_candb_error_missing_rx.ESC_04, &ccu_candb_time_missing_rx.ESC_04},
{EMS_Veh_CANID, &ccu_candb_rx.EMS_Veh.mon1, &ccu_candb_error_missing_rx.EMS_Veh, &ccu_candb_time_missing_rx.EMS_Veh},
{BCM_Powertrain_CANID, &ccu_candb_rx.BCM_Powertrain.mon1, &ccu_candb_error_missing_rx.BCM_Powertrain, &ccu_candb_time_missing_rx.BCM_Powertrain},
{EMS_Veh_02_CANID, &ccu_candb_rx.EMS_Veh_02.mon1, &ccu_candb_error_missing_rx.EMS_Veh_02, &ccu_candb_time_missing_rx.EMS_Veh_02},
{BCM_EEM_CANID, &ccu_candb_rx.BCM_EEM.mon1, &ccu_candb_error_missing_rx.BCM_EEM, &ccu_candb_time_missing_rx.BCM_EEM},
{DMFR_Msg1_CANID, &ccu_candb_rx.DMFR_Msg1.mon1, &ccu_candb_error_missing_rx.DMFR_Msg1, &ccu_candb_time_missing_rx.DMFR_Msg1},
{DMFL_Msg1_CANID, &ccu_candb_rx.DMFL_Msg1.mon1, &ccu_candb_error_missing_rx.DMFL_Msg1, &ccu_candb_time_missing_rx.DMFL_Msg1},
{TM_Stat_CANID, &ccu_candb_rx.TM_Stat.mon1, &ccu_candb_error_missing_rx.TM_Stat, &ccu_candb_time_missing_rx.TM_Stat},
{TM_CP_CANID, &ccu_candb_rx.TM_CP.mon1, &ccu_candb_error_missing_rx.TM_CP, &ccu_candb_time_missing_rx.TM_CP},
{HVC_CCU_Status_Msg_CANID, &ccu_candb_rx.HVC_CCU_Status_Msg.mon1, &ccu_candb_error_missing_rx.HVC_CCU_Status_Msg, &ccu_candb_time_missing_rx.HVC_CCU_Status_Msg},
{BCM_VEH_STATE_CANID, &ccu_candb_rx.BCM_VEH_STATE.mon1, &ccu_candb_error_missing_rx.BCM_VEH_STATE, &ccu_candb_time_missing_rx.BCM_VEH_STATE},
{EMS_HVC_Req_Msg_CANID, &ccu_candb_rx.EMS_HVC_Req_Msg.mon1, &ccu_candb_error_missing_rx.EMS_HVC_Req_Msg, &ccu_candb_time_missing_rx.EMS_HVC_Req_Msg},
{HVC_Err_Status_Msg_CANID, &ccu_candb_rx.HVC_Err_Status_Msg.mon1, &ccu_candb_error_missing_rx.HVC_Err_Status_Msg, &ccu_candb_time_missing_rx.HVC_Err_Status_Msg},
{BCM_CLIMATIC_DATA_CANID, &ccu_candb_rx.BCM_CLIMATIC_DATA.mon1, &ccu_candb_error_missing_rx.BCM_CLIMATIC_DATA, &ccu_candb_time_missing_rx.BCM_CLIMATIC_DATA},
{VCU_CCU_Req_CANID, &ccu_candb_rx.VCU_CCU_Req.mon1, &ccu_candb_error_missing_rx.VCU_CCU_Req, &ccu_candb_time_missing_rx.VCU_CCU_Req},
{ESC_08_CANID, &ccu_candb_rx.ESC_08.mon1, &ccu_candb_error_missing_rx.ESC_08, &ccu_candb_time_missing_rx.ESC_08},
{SMFL_status_CANID, &ccu_candb_rx.SMFL_status.mon1, &ccu_candb_error_missing_rx.SMFL_status, &ccu_candb_time_missing_rx.SMFL_status},
{SMFR_status_CANID, &ccu_candb_rx.SMFR_status.mon1, &ccu_candb_error_missing_rx.SMFR_status, &ccu_candb_time_missing_rx.SMFR_status},
{SMRL_status_CANID, &ccu_candb_rx.SMRL_status.mon1, &ccu_candb_error_missing_rx.SMRL_status, &ccu_candb_time_missing_rx.SMRL_status},
{SMRR_status_CANID, &ccu_candb_rx.SMRR_status.mon1, &ccu_candb_error_missing_rx.SMRR_status, &ccu_candb_time_missing_rx.SMRR_status},
{SDM_Cmd_CANID, &ccu_candb_rx.SDM_Cmd.mon1, &ccu_candb_error_missing_rx.SDM_Cmd, &ccu_candb_time_missing_rx.SDM_Cmd},
{VEH_VIN_CANID, &ccu_candb_rx.VEH_VIN.mon1, &ccu_candb_error_missing_rx.VEH_VIN, &ccu_candb_time_missing_rx.VEH_VIN},
{OCUFL_MSG_CANID, &ccu_candb_rx.OCUFL_MSG.mon1, &ccu_candb_error_missing_rx.OCUFL_MSG, &ccu_candb_time_missing_rx.OCUFL_MSG},
{OCUFR_MSG_CANID, &ccu_candb_rx.OCUFR_MSG.mon1, &ccu_candb_error_missing_rx.OCUFR_MSG, &ccu_candb_time_missing_rx.OCUFR_MSG},
{OCURL_MSG_CANID, &ccu_candb_rx.OCURL_MSG.mon1, &ccu_candb_error_missing_rx.OCURL_MSG, &ccu_candb_time_missing_rx.OCURL_MSG},
{OCURR_MSG_CANID, &ccu_candb_rx.OCURR_MSG.mon1, &ccu_candb_error_missing_rx.OCURR_MSG, &ccu_candb_time_missing_rx.OCURR_MSG},
{DW_STATE_CANID, &ccu_candb_rx.DW_STATE.mon1, &ccu_candb_error_missing_rx.DW_STATE, &ccu_candb_time_missing_rx.DW_STATE},
{FIU_CCU1_CANID, &ccu_candb_rx.FIU_CCU1.mon1, &ccu_candb_error_missing_rx.FIU_CCU1, &ccu_candb_time_missing_rx.FIU_CCU1},
{FIU_CCU2_CANID, &ccu_candb_rx.FIU_CCU2.mon1, &ccu_candb_error_missing_rx.FIU_CCU2, &ccu_candb_time_missing_rx.FIU_CCU2},
{FIU_CCU3_CANID, &ccu_candb_rx.FIU_CCU3.mon1, &ccu_candb_error_missing_rx.FIU_CCU3, &ccu_candb_time_missing_rx.FIU_CCU3},
};
#define CAN_MONITOR_COUNT (sizeof(g_can_monitors) / sizeof(g_can_monitors[0]))
void CanSpamReceiver_Init(tCanSpamReceiver *env,
tSerialPortFrameIO *ioCanFrame,
tLoggerInterface *logger) {
env->ioCanFrame = ioCanFrame;
env->logger = logger;
env->access = osMutexNew(NULL);
for (uint32_t i = 0; i < CAN_MONITOR_COUNT; i++) {
FrameMonitor_t *mon = g_can_monitors[i].monitor;
mon->timeout_cycle = 3000;
}
// VIN
FrameMonitor_t *vin_mon = g_can_monitors[CAN_IDX_VEH_VIN].monitor;
vin_mon->timeout_cycle = 45000; // 45 секунд для VIN
/*
env->ccu_candb_rx_LOCAL_HVAC_VIN = osMessageQueueNew(1, 17, NULL);
env->ccu_candb_rx_LOCAL_HVAC_UDS_VIN = osMessageQueueNew(1, 17, NULL);
env->ccu_candb_rx_TM_CP = osMessageQueueNew(1, sizeof(ccu_candb_rx.TM_CP), NULL);
env->ccu_candb_rx_FIU_CCU1 = osMessageQueueNew(1, sizeof(ccu_candb_rx.FIU_CCU1), NULL);
env->ccu_candb_rx_FIU_CCU2 = osMessageQueueNew(1, sizeof(ccu_candb_rx.FIU_CCU2), NULL);
env->ccu_candb_rx_BCM_Powertrain = osMessageQueueNew(1, sizeof(ccu_candb_rx.BCM_Powertrain), NULL);
env->ccu_candb_rx_BCM_CLIMATIC_DATA = osMessageQueueNew(1, sizeof(ccu_candb_rx.BCM_CLIMATIC_DATA), NULL);
env->ccu_candb_rx_EMS_Veh = osMessageQueueNew(1, sizeof(ccu_candb_rx.EMS_Veh), NULL);
env->ccu_candb_rx_ESC_04 = osMessageQueueNew(1, sizeof(ccu_candb_rx.ESC_04), NULL);
env->ccu_candb_rx_BCM_VEH_STATE = osMessageQueueNew(1, sizeof(ccu_candb_rx.BCM_VEH_STATE), NULL);
env->ccu_candb_rx_EMS_HVC_Req_Msg = osMessageQueueNew(1, sizeof(ccu_candb_rx.EMS_HVC_Req_Msg), NULL);
env->ccu_candb_rx_HVC_Err_Status_Msg = osMessageQueueNew(1, sizeof(ccu_candb_rx.HVC_Err_Status_Msg), NULL);
*/
env->ccu_candb_error_missing_rx = osMessageQueueNew(1, sizeof(ccu_candb_error_missing_rx_t), NULL);
env->ccu_candb_time_missing_rx = osMessageQueueNew(1, sizeof(ccu_candb_time_missing_rx_t), NULL);
env->ccu_candb_rx_LOCAL_HVAC_VIN = osMessageQueueNew(1, 17, NULL);
env->ccu_candb_rx_LOCAL_HVAC_UDS_VIN = osMessageQueueNew(1, 17, NULL);
env->ccu_candb_rx_TM_CP = osMessageQueueNew(1, sizeof(rtDW.TM_CP_model), NULL);
env->ccu_candb_rx_FIU_CCU1 = osMessageQueueNew(1, sizeof(rtDW.FIU_CCU1_MODEL), NULL);
env->ccu_candb_rx_FIU_CCU2 = osMessageQueueNew(1, sizeof(rtDW.FIU_CCU2_MODEL), NULL);
env->ccu_candb_rx_BCM_Powertrain = osMessageQueueNew(1, sizeof(rtDW.CCUCAN_BCM_Powertrain_model), NULL);
env->ccu_candb_rx_BCM_CLIMATIC_DATA = osMessageQueueNew(1, sizeof(rtDW.CCUCAN_BCM_Climatic_model), NULL);
env->ccu_candb_rx_EMS_Veh = osMessageQueueNew(1, sizeof(rtDW.CCUCAN_EMS_Veh_model), NULL);
env->ccu_candb_rx_ESC_04 = osMessageQueueNew(1, sizeof(rtDW.CCUCAN_ESC_04_model), NULL);
env->ccu_candb_rx_BCM_VEH_STATE = osMessageQueueNew(1, sizeof(rtDW.CCUCAN_BCM_VEH_STATE_model), NULL);
env->ccu_candb_rx_EMS_HVC_Req_Msg = osMessageQueueNew(1, sizeof(rtDW.CCUCAN_EMS_HVC_REQ_MSG_MODEL), NULL);
env->ccu_candb_rx_HVC_Err_Status_Msg = osMessageQueueNew(1, sizeof(rtDW.HVC_ERR_STATUS_MSG_MODEL), NULL);
env->thread.stack = tCanSpamReceiver_stack;
InitThreadAtr(&env->thread.attr, "CanSpamRec", &env->thread.controlBlock, sizeof(env->thread.controlBlock),
env->thread.stack, tCanSpamReceiver_stack_size, osPriorityNormal);
env->thread.id = 0;
// InitThreadAtrStatic(&env->thread.attr, "CanSpamRec", env->thread.controlBlock, env->thread.stack,
// osPriorityNormal);
}
static void CheckAllCANMonitors(void) {
uint32_t current_time = SystemGetMs();
for (uint32_t i = 0; i < CAN_MONITOR_COUNT; i++) {
FrameMonitor_t *mon = g_can_monitors[i].monitor;
// Проверяем таймаут
uint32_t diff = current_time - mon->last_cycle;
uint8_t error = (diff > mon->timeout_cycle) ? 1 : 0;
// Сохраняем ошибку
*(g_can_monitors[i].error_flag) = error;
// Сохраняем время
*(g_can_monitors[i].time_flag) = mon->last_cycle;
}
}
static void set_CanSpamReceiver(tCanSpamReceiver *env, uint32_t recid) {
osStatus_t status = osOK;
// ВСЕГДА проверяем все мониторы на таймаут
CheckAllCANMonitors();
uint32_t countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_error_missing_rx);
if (countQueue_ccu_candb_rx) {
status = osMessageQueuePut(env->ccu_candb_error_missing_rx, &ccu_candb_error_missing_rx, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_time_missing_rx);
if (countQueue_ccu_candb_rx) {
status = osMessageQueuePut(env->ccu_candb_time_missing_rx, &ccu_candb_time_missing_rx, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_TM_CP);
if ((countQueue_ccu_candb_rx) && (recid == TM_CP_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_TM_CP, &ccu_candb_rx.TM_CP, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_FIU_CCU1);
if ((countQueue_ccu_candb_rx) && (recid == FIU_CCU1_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_FIU_CCU1, &ccu_candb_rx.FIU_CCU1, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_FIU_CCU2);
if ((countQueue_ccu_candb_rx) && (recid == FIU_CCU2_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_FIU_CCU2, &ccu_candb_rx.FIU_CCU2, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_Powertrain);
if ((countQueue_ccu_candb_rx) && (recid == BCM_Powertrain_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_BCM_Powertrain, &ccu_candb_rx.BCM_Powertrain, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_CLIMATIC_DATA);
if ((countQueue_ccu_candb_rx) && (recid == BCM_CLIMATIC_DATA_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_BCM_CLIMATIC_DATA, &ccu_candb_rx.BCM_CLIMATIC_DATA, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_EMS_Veh);
if ((countQueue_ccu_candb_rx) && (recid == EMS_Veh_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_EMS_Veh, &ccu_candb_rx.EMS_Veh, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_ESC_04);
if ((countQueue_ccu_candb_rx) && (recid == ESC_04_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_ESC_04, &ccu_candb_rx.ESC_04, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_VEH_STATE);
if ((countQueue_ccu_candb_rx) && (recid == BCM_VEH_STATE_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_BCM_VEH_STATE, &ccu_candb_rx.BCM_VEH_STATE, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_EMS_HVC_Req_Msg);
if ((countQueue_ccu_candb_rx) && (recid == EMS_HVC_Req_Msg_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_EMS_HVC_Req_Msg, &ccu_candb_rx.EMS_HVC_Req_Msg, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_HVC_Err_Status_Msg);
if ((countQueue_ccu_candb_rx) && (recid == HVC_Err_Status_Msg_CANID)) {
status = osMessageQueuePut(env->ccu_candb_rx_HVC_Err_Status_Msg, &ccu_candb_rx.HVC_Err_Status_Msg, 0, 0U);
return;
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_LOCAL_HVAC_VIN);
if ((countQueue_ccu_candb_rx) && (recid == VEH_VIN_CANID)) {
if (ccu_candb_rx.VEH_VIN.VIN_Addressing == 0) {
env->SET_HVAC_VIN[0] = ccu_candb_rx.VEH_VIN.VIN_Char1;
env->SET_HVAC_VIN[1] = ccu_candb_rx.VEH_VIN.VIN_Char2;
env->SET_HVAC_VIN[2] = ccu_candb_rx.VEH_VIN.VIN_Char3;
env->SET_HVAC_VIN[3] = ccu_candb_rx.VEH_VIN.VIN_Char4;
env->SET_HVAC_VIN[4] = ccu_candb_rx.VEH_VIN.VIN_Char5;
env->SET_HVAC_VIN[5] = ccu_candb_rx.VEH_VIN.VIN_Char6;
env->SET_HVAC_VIN[6] = ccu_candb_rx.VEH_VIN.VIN_Char7;
env->getVIN0 = true;
}
if (ccu_candb_rx.VEH_VIN.VIN_Addressing == 1) {
env->SET_HVAC_VIN[7] = ccu_candb_rx.VEH_VIN.VIN_Char8;
env->SET_HVAC_VIN[8] = ccu_candb_rx.VEH_VIN.VIN_Char9;
env->SET_HVAC_VIN[9] = ccu_candb_rx.VEH_VIN.VIN_Char10;
env->SET_HVAC_VIN[10] = ccu_candb_rx.VEH_VIN.VIN_Char11;
env->SET_HVAC_VIN[11] = ccu_candb_rx.VEH_VIN.VIN_Char12;
env->SET_HVAC_VIN[12] = ccu_candb_rx.VEH_VIN.VIN_Char13;
env->SET_HVAC_VIN[13] = ccu_candb_rx.VEH_VIN.VIN_Char14;
env->getVIN1 = true;
}
if (ccu_candb_rx.VEH_VIN.VIN_Addressing == 2) {
env->SET_HVAC_VIN[14] = ccu_candb_rx.VEH_VIN.VIN_Char15;
env->SET_HVAC_VIN[15] = ccu_candb_rx.VEH_VIN.VIN_Char16;
env->SET_HVAC_VIN[16] = ccu_candb_rx.VEH_VIN.VIN_Char17;
env->getVIN2 = true;
}
if ((env->getVIN0) && (env->getVIN1) && (env->getVIN2)) {
status = osMessageQueuePut(env->ccu_candb_rx_LOCAL_HVAC_VIN, env->SET_HVAC_VIN, 0, 0U);
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_LOCAL_HVAC_UDS_VIN);
if (countQueue_ccu_candb_rx) {
status = osMessageQueuePut(env->ccu_candb_rx_LOCAL_HVAC_UDS_VIN, env->SET_HVAC_VIN, 0, 0U);
}
env->getVIN0 = false;
env->getVIN1 = false;
env->getVIN2 = false;
}
return;
}
}
uint32_t getCanTimeReceived(tCanSpamReceiver *env) {
uint32_t time = 0;
if (osMutexAcquire(env->access, 5000) == osOK) {
time = env->canTimeReceived;
osMutexRelease(env->access);
} else {
LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error getCanTimeReceived");
}
return time;
}
static void ListenCanSpamReceiver(tCanSpamReceiver *env) {
uint16_t recv = env->ioCanFrame->receive(env->ioCanFrame->env, PROTOCOL_CAN_RAW, (uint8_t *) &env->canFrame, 1,
1000);
if (recv == 0) {
return;
}
if (osMutexAcquire(env->access, 5000) == osOK) {
env->canTimeReceived = SystemGetMs();
uint32_t id = env->canFrame.standard_id;
if (env->canFrame.id_type == FLEXCAN_ID_EXT) {
id = env->canFrame.extended_id;
}
env->logger->loggingCan(env->logger->env, 1, 0, env->canFrame.dlc, env->canFrame.standard_id,
env->canFrame.data, SystemGetMs());
uint32_t recid = ccu_candb_Receive(&ccu_candb_rx, env->canFrame.data, id, env->canFrame.dlc);
set_CanSpamReceiver(env, recid);
osMutexRelease(env->access);
} else {
LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error ListenCanSpamReceiver");
}
}
bool get_is_NoNull_CanSpam_BCM_PowerTrain_Receiver(tCanSpamReceiver *env) {
if (osMutexAcquire(env->access, 5000) == osOK) {
uint8_t *data = (uint8_t *) &ccu_candb_rx.BCM_Powertrain;
for (uint8_t i = 0; i < (uint8_t) sizeof(BCM_Powertrain_t); ++i) {
if (data[i] != 0) {
osMutexRelease(env->access);
return true;
}
}
osMutexRelease(env->access);
} else {
LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error get_CanSpamReceiver");
}
return false;
}
void get_CanSpamReceiver(tCanSpamReceiver *env, char *VIN, ccu_candb_error_missing_rx_t *CAN_ERROR_MISSLE, ccu_candb_time_missing_rx_t *CAN_TIME_MISSLE) {
osStatus_t status = osOK;
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
uint32_t countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_error_missing_rx);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_error_missing_rx, CAN_ERROR_MISSLE, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_time_missing_rx);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_time_missing_rx, CAN_TIME_MISSLE, 0, 0U);
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_TM_CP);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_TM_CP, &rtDW.TM_CP_model, 0, 0U);
}
memset(&rtDW.FIU_CCU1_MODEL, 0, sizeof(rtDW.FIU_CCU1_MODEL));
memset(&rtDW.FIU_CCU2_MODEL, 0, sizeof(rtDW.FIU_CCU2_MODEL));
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_FIU_CCU1);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_FIU_CCU1, &rtDW.FIU_CCU1_MODEL, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_FIU_CCU2);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_FIU_CCU2, &rtDW.FIU_CCU2_MODEL, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_Powertrain);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_BCM_Powertrain, &rtDW.CCUCAN_BCM_Powertrain_model, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_CLIMATIC_DATA);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_BCM_CLIMATIC_DATA, &rtDW.CCUCAN_BCM_Climatic_model, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_EMS_Veh);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_EMS_Veh, &rtDW.CCUCAN_EMS_Veh_model, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_ESC_04);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_ESC_04, &rtDW.CCUCAN_ESC_04_model, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_BCM_VEH_STATE);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_BCM_VEH_STATE, &rtDW.CCUCAN_BCM_VEH_STATE_model, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_EMS_HVC_Req_Msg);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_EMS_HVC_Req_Msg, &rtDW.CCUCAN_EMS_HVC_REQ_MSG_MODEL, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_HVC_Err_Status_Msg);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_HVC_Err_Status_Msg, &rtDW.HVC_ERR_STATUS_MSG_MODEL, 0, 0U);
}
countQueue_ccu_candb_rx = osMessageQueueGetSpace(env->ccu_candb_rx_LOCAL_HVAC_VIN);
if (countQueue_ccu_candb_rx == 0) {
status = osMessageQueueGet(env->ccu_candb_rx_LOCAL_HVAC_VIN, VIN, 0, 0U);
}
}
bool get_CanSpamReceiverUDS(tCanSpamReceiver *env, char *VIN, func_update_func update_func, void *update_func_env,
uint32_t timeout, uint32_t count) {
uint32_t u32Time = SystemGetMs() + timeout;
for (uint32_t i = 0; i < count; ++i) {
osStatus_t status = osMessageQueueGet(env->ccu_candb_rx_LOCAL_HVAC_UDS_VIN, VIN, 0, timeout);
if (update_func != NULL) {
if (SystemGetMs() > u32Time) {
update_func(update_func_env);
u32Time = SystemGetMs() + timeout;
}
}
if (status == osOK) {
return true;
}
}
return false;
}
static _Noreturn void CanSpamReceiver_Thread(tCanSpamReceiver *env) {
for (;;) {
ListenCanSpamReceiver(env);
}
}
void CanSpamReceiver_StartThread(tCanSpamReceiver *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (CanSpamReceiver_Thread), (void *) (env), &env->thread.attr);
}
}
Reference in New Issue View Git Blame Copy Permalink