From 51b10baa5ac102a2d3c797827365b99ee7aa5326 Mon Sep 17 00:00:00 2001 From: cfif Date: Wed, 26 Aug 2026 13:40:14 +0300 Subject: [PATCH] =?UTF-8?q?=D0=92=20UDS=20=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2?= =?UTF-8?q?=D0=BB=D0=B5=D0=BD=20VIN=20learn?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.c | 102 +++++++++++++++++- MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.h | 12 +++ MODULES/HVAC_M7_CAN_UDS/CanUds.c | 54 ++++++---- MODULES/HVAC_M7_CAN_UDS/CanUds.h | 8 ++ MODULES/HVAC_M7_CRC32/crc32_m7.c | 4 +- MODULES/HVAC_M7_CRC32/crc32_m7.h | 6 +- MODULES/HVAC_M7_CanPorts/CanPorts.c | 4 +- .../MainModesArbiter_InitStage.c | 1 + 8 files changed, 164 insertions(+), 27 deletions(-) diff --git a/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.c b/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.c index a77bb1d..f53d3e1 100644 --- a/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.c +++ b/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.c @@ -12,6 +12,8 @@ #define LOG_SIGN "CAN_RECEIVED" #define LOGGER env->logger +char GET_HVAC_VIN[17] = {'0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'}; + void CanSpamReceiver_Init(tCanSpamReceiver *env, tSerialPortFrameIO *ioCanFrame, tLoggerInterface *logger) { @@ -21,6 +23,8 @@ void CanSpamReceiver_Init(tCanSpamReceiver *env, env->access = osMutexNew(NULL); + env->ccu_candb_rx_LOCAL_HVAC_VIN = osMessageQueueNew(1, sizeof(GET_HVAC_VIN), NULL); + env->ccu_candb_rx_LOCAL_HVAC_UDS_VIN = osMessageQueueNew(1, sizeof(GET_HVAC_VIN), 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); @@ -34,7 +38,8 @@ void CanSpamReceiver_Init(tCanSpamReceiver *env, env->thread.stack = tCanSpamReceiver_stack; - InitThreadAtr(&env->thread.attr,"CanSpamRec",&env->thread.controlBlock,sizeof(env->thread.controlBlock),env->thread.stack,tCanSpamReceiver_stack_size,osPriorityNormal); + 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, @@ -47,51 +52,111 @@ static void set_CanSpamReceiver(tCanSpamReceiver *env, uint32_t recid) { uint32_t 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; } } @@ -133,7 +198,7 @@ bool get_is_NoNull_CanSpam_BCM_PowerTrain_Receiver(tCanSpamReceiver *env) { uint8_t *data = (uint8_t *) &ccu_candb_rx.BCM_Powertrain; - for (uint8_t i = 0; i < (uint8_t)sizeof(BCM_Powertrain_t); ++i) { + for (uint8_t i = 0; i < (uint8_t) sizeof(BCM_Powertrain_t); ++i) { if (data[i] != 0) { osMutexRelease(env->access); return true; @@ -205,6 +270,11 @@ void get_CanSpamReceiver(tCanSpamReceiver *env) { 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, GET_HVAC_VIN, 0, 0U); + } + /* if (osMutexAcquire(env->access, 5000) == osOK) { memcpy(&rtDW.TM_CP_model, &ccu_candb_rx.TM_CP, sizeof(rtDW.TM_CP_model)); @@ -235,6 +305,34 @@ void get_CanSpamReceiver(tCanSpamReceiver *env) { } +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; iccu_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); diff --git a/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.h b/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.h index e7fe9cc..af0a881 100644 --- a/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.h +++ b/MODULES/HVAC_M7_CAN_SPAM/CanSpamReceiver.h @@ -9,6 +9,7 @@ #include "CanSerialPortFrame.h" #include "ccu_candb-binutil.h" #include "LoggerInterface.h" +#include "crc32_m7.h" typedef struct { @@ -17,6 +18,14 @@ typedef struct { osMutexId_t access; can_rx_message_type canFrame; + char SET_HVAC_VIN[17]; + bool getVIN0; + bool getVIN1; + bool getVIN2; + + + osMessageQueueId_t ccu_candb_rx_LOCAL_HVAC_VIN; + osMessageQueueId_t ccu_candb_rx_LOCAL_HVAC_UDS_VIN; osMessageQueueId_t ccu_candb_rx_TM_CP; osMessageQueueId_t ccu_candb_rx_FIU_CCU1; osMessageQueueId_t ccu_candb_rx_FIU_CCU2; @@ -46,6 +55,9 @@ void CanSpamReceiver_StartThread(tCanSpamReceiver *env); void get_CanSpamReceiver(tCanSpamReceiver *env); +bool get_CanSpamReceiverUDS(tCanSpamReceiver *env, char *VIN, func_update_func update_func, void *update_func_env, + uint32_t timeout, uint32_t count); + bool get_is_NoNull_CanSpam_BCM_PowerTrain_Receiver(tCanSpamReceiver *env); #endif //HVAC_CAN_SPAM_RECEIVER_H diff --git a/MODULES/HVAC_M7_CAN_UDS/CanUds.c b/MODULES/HVAC_M7_CAN_UDS/CanUds.c index bda8f04..5f3d6a3 100644 --- a/MODULES/HVAC_M7_CAN_UDS/CanUds.c +++ b/MODULES/HVAC_M7_CAN_UDS/CanUds.c @@ -72,7 +72,6 @@ static uint16_t getActProc(uint16_t maxPos, uint16_t pos) { } - // Тут данные должны быть с модели &env->Status_Sensor_For_Model_input и т.д. void CanUdsInput_Set_Model(tCanUds *env) { osStatus_t status = osOK; @@ -82,11 +81,11 @@ void CanUdsInput_Set_Model(tCanUds *env) { memcpy(&env->Status_Sensort_model_IO_local, &rtY.Status_Sensort_model_IO, sizeof(Status_Sensor_Bus)); - uint16_t IGN_ANS_16 = (uint16_t)((rtDW.ADC_Data_Model.IGN_ANS * 27.75f / 4095.0f) * 10.0f); - uint16_t PBATT_CHECK_16 = (uint16_t)((rtDW.ADC_Data_Model.PBATT_CHECK * 33.4375f / 4095.0f) * 10.0f); + uint16_t IGN_ANS_16 = (uint16_t) ((rtDW.ADC_Data_Model.IGN_ANS * 27.75f / 4095.0f) * 10.0f); + uint16_t PBATT_CHECK_16 = (uint16_t) ((rtDW.ADC_Data_Model.PBATT_CHECK * 33.4375f / 4095.0f) * 10.0f); - uint8_t IGN_ANS = (IGN_ANS_16 > 255) ? 255 : (uint8_t)IGN_ANS_16; - uint8_t PBATT_CHECK = (PBATT_CHECK_16 > 255) ? 255 : (uint8_t)PBATT_CHECK_16; + uint8_t IGN_ANS = (IGN_ANS_16 > 255) ? 255 : (uint8_t) IGN_ANS_16; + uint8_t PBATT_CHECK = (PBATT_CHECK_16 > 255) ? 255 : (uint8_t) PBATT_CHECK_16; env->Status_Sensort_model_IO_local.Ignition = IGN_ANS; env->Status_Sensort_model_IO_local.Battery = PBATT_CHECK; @@ -660,7 +659,6 @@ static void setDefaultValue(tCanUds *env) { } - static char strPrintfDebug_UDS[80]; static void PrintfDebug(uint8_t *data, uint8_t dlc) { @@ -850,11 +848,13 @@ void setResponseErrorPending(tCanUds *env, eUdsServices service, eUdsResponseErr env->dataResponsePending[1] = service; env->dataResponsePending[2] = error; + env->currentSessionTesterPresentTimeout = SystemGetMs() + timeout_session_S3_Server; + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, env->dataResponsePending, 3, PROTOCOL_CAN_ADR_UDS, WAIT_FRAME_WRITE); } -void SendUpdatePendingCrc(void *env) { +void SendUpdatePendingRoutine(void *env) { setResponseErrorPending(env, UDS_RoutineControl, UDS_error_requestCorrectlyReceived_ResponsePending); } @@ -1153,7 +1153,8 @@ static uint16_t WriteDataByIdentifier_2E(tCanUds *env) { // начало --------------------------- Управление --------------------------------------------------------- static void GetUpdateQueueIO(tCanUds *env) { - setResponseErrorPending(env, UDS_InputOutputControlByIdentifier, UDS_error_requestCorrectlyReceived_ResponsePending); + setResponseErrorPending(env, UDS_InputOutputControlByIdentifier, + UDS_error_requestCorrectlyReceived_ResponsePending); for (uint8_t i = 0; i < 15; ++i) { CanUdsOutput_Set_Model(env); @@ -1222,7 +1223,7 @@ static uint16_t InputOutputControlByIdentifier_2F(tCanUds *env) { return setResponseError(env, UDS_InputOutputControlByIdentifier, UDS_error_requestOutOfRange); } - uint8_t *pSet = (uint8_t * ) & env->Status_Set_For_Model_output; + uint8_t *pSet = (uint8_t *) &env->Status_Set_For_Model_output; pSet[dataIdentifier_lo - 0x60] = 1; @@ -1376,7 +1377,7 @@ static uint16_t InputOutputControlByIdentifier_2F(tCanUds *env) { // Motor_Def...MotorSealingValve (percent) if ((dataIdentifier_lo >= 0x60) && (dataIdentifier_lo <= 0x78)) { - uint8_t *pSet = (uint8_t * ) & env->Status_Set_For_Model_output; + uint8_t *pSet = (uint8_t *) &env->Status_Set_For_Model_output; pSet[dataIdentifier_lo - 0x60] = 0; GetUpdateQueueIO(env); @@ -1705,7 +1706,21 @@ static uint16_t vUDS_routine_VIN_learn(tCanUds *env, eUdsRoutineControlType udsR return 0xFF00 | UDS_error_sub_functionNotSupported; } - env->dataResponse[4] = UDS_routine_RoutineStartStopSuccess; + bool isVIN = get_CanSpamReceiverUDS(env->canSpamReceiver, env->VIN, SendUpdatePendingRoutine, env, 200, 200); + + if (isVIN) { + + memcpy(statusData.ecu.Vehicle_Identification, env->VIN, 17); + + SendUpdatePendingRoutine(env); + SaveToStorageFromStatusData(env->deviceStorage, &statusData.ecu); + + env->dataResponse[4] = UDS_routine_RoutineStartStopSuccess; + } else { + + env->dataResponse[4] = UDS_routine_RoutineStartStopFailure; + } + return 4 + 1; } @@ -1724,7 +1739,7 @@ static uint16_t vUDS_routine_Compare_Checksum(tCanUds *env, eUdsRoutineControlTy setResponseErrorPending(env, UDS_RoutineControl, UDS_error_requestCorrectlyReceived_ResponsePending); uint32_t crc32_calc = UdsCrc32Update_Hardware(0xFFFFFFFF, (uint8_t *) env->CurrentBlockAdr, env->CurrentBlockSize, - SendUpdatePendingCrc, env, 200); + SendUpdatePendingRoutine, env, 200); uint32_t crc32_received = (env->data->data[4] << 24) | (env->data->data[5] << 16) | (env->data->data[6] << 8) | env->data->data[7]; @@ -1941,9 +1956,9 @@ vUDS_routine_Check_Programming_Dependancies(tCanUds *env, eUdsRoutineControlType setResponseErrorPending(env, UDS_RoutineControl, UDS_error_requestCorrectlyReceived_ResponsePending); uint32_t crc32_calc = UdsCrc32Update_Hardware(0xFFFFFFFF, (uint8_t *) ADR_HEX_Mapped_BlockMain, SIZE_HEX_BlockMain - 4, - SendUpdatePendingCrc, env, 200); + SendUpdatePendingRoutine, env, 200); - uint32_t crc32_file = (*(uint32_t * )(ADR_HEX_Mapped_BlockMain + SIZE_HEX_BlockMain - 4)); + uint32_t crc32_file = (*(uint32_t *) (ADR_HEX_Mapped_BlockMain + SIZE_HEX_BlockMain - 4)); if (crc32_calc != crc32_file) { env->dataResponse[4] = UDS_routine_RoutineStartStopFailure; @@ -1953,9 +1968,9 @@ vUDS_routine_Check_Programming_Dependancies(tCanUds *env, eUdsRoutineControlType setResponseErrorPending(env, UDS_RoutineControl, UDS_error_requestCorrectlyReceived_ResponsePending); crc32_calc = UdsCrc32Update_Hardware(0xFFFFFFFF, (uint8_t *) ADR_HEX_Mapped_BlockCalib, SIZE_HEX_BlockCalib - 4, - SendUpdatePendingCrc, env, 200); + SendUpdatePendingRoutine, env, 200); - crc32_file = (*(uint32_t * )(ADR_HEX_Mapped_BlockCalib + SIZE_HEX_BlockCalib - 4)); + crc32_file = (*(uint32_t *) (ADR_HEX_Mapped_BlockCalib + SIZE_HEX_BlockCalib - 4)); if (crc32_calc != crc32_file) { env->dataResponse[4] = UDS_routine_RoutineStartStopFailure; @@ -1981,7 +1996,7 @@ vUDS_routine_Check_Programming_Dependancies(tCanUds *env, eUdsRoutineControlType return 4 + 1; } - size_t size = D_sInternalFlashPage_Write(0x04000000, 0, (uint8_t * ) & NumberBank, 8); + size_t size = D_sInternalFlashPage_Write(0x04000000, 0, (uint8_t *) &NumberBank, 8); if (size != 8) { env->dataResponse[4] = UDS_routine_RoutineStartStopFailure; @@ -2838,6 +2853,7 @@ void CanUds_Init( tDiagnostic *Diagnostic, tSerialPortFrameIO *CanIO, tDeviceStorage *deviceStorage, + tCanSpamReceiver *canSpamReceiver, tCanSpamTransmitter *canSpamTransmitter, tCanSpamDebugTransmitter *canSpamDebugTransmitter, tAdc0Task *adcTask0, @@ -2848,6 +2864,7 @@ void CanUds_Init( env->logger = logger; env->CanIO = CanIO; env->deviceStorage = deviceStorage; + env->canSpamReceiver = canSpamReceiver; env->Diagnostic = Diagnostic; env->adcTask0 = adcTask0; env->filterIdCount = 2; @@ -2938,7 +2955,8 @@ void CanUds_Init( env->thread_Uds.stack = tCanUds_stack; - InitThreadAtr(&env->thread_Uds.attr,"UdsTester",&env->thread_Uds.controlBlock,sizeof(env->thread_Uds.controlBlock),env->thread_Uds.stack,tCanUds_stack_size,osPriorityNormal); + InitThreadAtr(&env->thread_Uds.attr, "UdsTester", &env->thread_Uds.controlBlock, + sizeof(env->thread_Uds.controlBlock), env->thread_Uds.stack, tCanUds_stack_size, osPriorityNormal); env->thread_Uds.id = 0; // InitThreadBlock(env->T_can_Uds, "UdsTester", osPriorityNormal); diff --git a/MODULES/HVAC_M7_CAN_UDS/CanUds.h b/MODULES/HVAC_M7_CAN_UDS/CanUds.h index d86ee74..f361a5d 100644 --- a/MODULES/HVAC_M7_CAN_UDS/CanUds.h +++ b/MODULES/HVAC_M7_CAN_UDS/CanUds.h @@ -12,6 +12,7 @@ #include "CanSpamDebugTransmitter.h" #include "AdcTasks.h" #include "StatusData.h" +#include "CanSpamReceiver.h" #define LOG_UDS 0 @@ -204,10 +205,13 @@ typedef struct { eUdsSession currentSession; uint32_t currentSessionTesterPresentTimeout; + tCanSpamReceiver *canSpamReceiver; + tCanSpamTransmitter *canSpamTransmitter; // tCanSpamSlowTransmitter *canSpamSlowTransmitter; tCanSpamDebugTransmitter *canSpamDebugTransmitter; + uint32_t randomSecuritySeed; struct { @@ -232,6 +236,8 @@ typedef struct { uint32_t CurrentBlockAdr; uint32_t CurrentBlockSize; + char VIN[17]; + bool isEcuReset; uint32_t timeoutPendingClear; @@ -289,6 +295,7 @@ typedef struct { Status_Sensor_Bus Status_Sensort_model_IO_local; + struct { osThreadId_t id; //uint32_t stack[384]; @@ -314,6 +321,7 @@ void CanUds_Init( tDiagnostic *Diagnostic, tSerialPortFrameIO *CanIO, tDeviceStorage *deviceStorage, + tCanSpamReceiver *canSpamReceiver, tCanSpamTransmitter *canSpamTransmitter, tCanSpamDebugTransmitter *canSpamDebugTransmitter, tAdc0Task *adcTask0, diff --git a/MODULES/HVAC_M7_CRC32/crc32_m7.c b/MODULES/HVAC_M7_CRC32/crc32_m7.c index 3d6a38e..cf243b9 100644 --- a/MODULES/HVAC_M7_CRC32/crc32_m7.c +++ b/MODULES/HVAC_M7_CRC32/crc32_m7.c @@ -54,7 +54,7 @@ static const uint32_t crc_table[256] = { uint32_t -UdsCrc32Update(uint32_t crc, const uint8_t *data, uint32_t len, crc32_update_func update_func, void *update_func_env, +UdsCrc32Update(uint32_t crc, const uint8_t *data, uint32_t len, func_update_func update_func, void *update_func_env, uint32_t timeout) { uint32_t time = SystemGetMs() + timeout; @@ -111,7 +111,7 @@ uint32_t UdsCrc32Finalize(uint32_t crc) { * @return uint32_t Updated CRC value */ uint32_t UdsCrc32Update_Hardware(uint32_t crc, const uint8_t *data, uint32_t len, - crc32_update_func update_func, void *update_func_env, + func_update_func update_func, void *update_func_env, uint32_t timeout) { CRC_InitType tInitCfg = {0}; diff --git a/MODULES/HVAC_M7_CRC32/crc32_m7.h b/MODULES/HVAC_M7_CRC32/crc32_m7.h index 9dd04d4..19a6d93 100644 --- a/MODULES/HVAC_M7_CRC32/crc32_m7.h +++ b/MODULES/HVAC_M7_CRC32/crc32_m7.h @@ -6,12 +6,12 @@ #define HVAC_M7_CRC32_UDS_H #include "stdint.h" -typedef void (crc32_update_func)(void *update_func_env); +typedef void (func_update_func)(void *update_func_env); -uint32_t UdsCrc32Update(uint32_t crc, const uint8_t *data, uint32_t len, crc32_update_func update_func, void *update_func_env, uint32_t timeout); +uint32_t UdsCrc32Update(uint32_t crc, const uint8_t *data, uint32_t len, func_update_func update_func, void *update_func_env, uint32_t timeout); uint32_t UdsCrc32Finalize(uint32_t crc); uint32_t UdsCrc32Update_Hardware(uint32_t crc, const uint8_t *data, uint32_t len, - crc32_update_func update_func, void *update_func_env, + func_update_func update_func, void *update_func_env, uint32_t timeout); #endif //HVAC_M7_CRC32_UDS_H diff --git a/MODULES/HVAC_M7_CanPorts/CanPorts.c b/MODULES/HVAC_M7_CanPorts/CanPorts.c index 0cd9fc1..300f90f 100644 --- a/MODULES/HVAC_M7_CanPorts/CanPorts.c +++ b/MODULES/HVAC_M7_CanPorts/CanPorts.c @@ -160,7 +160,7 @@ const FilterTo_FLEXCAN_RxMbFilterType IdCanHardSoftFilterCan0[countIdCanHardSoft */ -#define countIdCanHardSoftFilterCan0 13 +#define countIdCanHardSoftFilterCan0 14 const FilterTo_FLEXCAN_RxMbFilterType IdCanHardSoftFilterCan0[countIdCanHardSoftFilterCan0] = { {FLEXCAN_ID_STD, Diag_To_CCU_CANID, 0x7FF, PROTOCOL_CAN_UDS}, {FLEXCAN_ID_STD, Diag_Functional_CANID, 0x7FF, PROTOCOL_CAN_UDS}, @@ -184,7 +184,7 @@ const FilterTo_FLEXCAN_RxMbFilterType IdCanHardSoftFilterCan0[countIdCanHardSoft // {FLEXCAN_ID_STD, SMRL_status_CANID, 0x7FF, PROTOCOL_CAN_RAW}, // {FLEXCAN_ID_STD, SMRR_status_CANID, 0x7FF, PROTOCOL_CAN_RAW}, // {FLEXCAN_ID_STD, SDM_Cmd_CANID, 0x7FF, PROTOCOL_CAN_RAW}, -// {FLEXCAN_ID_STD, VEH_VIN_CANID, 0x7FF, PROTOCOL_CAN_RAW}, + {FLEXCAN_ID_STD, VEH_VIN_CANID, 0x7FF, PROTOCOL_CAN_RAW}, // {FLEXCAN_ID_STD, OCUFL_MSG_CANID, 0x7FF, PROTOCOL_CAN_RAW}, // {FLEXCAN_ID_STD, OCUFR_MSG_CANID, 0x7FF, PROTOCOL_CAN_RAW}, // {FLEXCAN_ID_STD, OCURL_MSG_CANID, 0x7FF, PROTOCOL_CAN_RAW}, diff --git a/MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c b/MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c index 6b466b5..ba8cd1a 100644 --- a/MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c +++ b/MODULES/HVAC_M7_DebugTesting/MainModesArbiter_InitStage.c @@ -265,6 +265,7 @@ static void Mma_InitSubSystems(tMma *env) { &env->Diagnostic, &env->canPorts->Can0_IO, &env->storage, + &env->canSpamReceiver, &env->canSpamTransmitter, &env->canSpamDebugTransmitter, &env->adcTask0,