commit a99781335c3d62d869e6240e923eda405336bc85 Author: cfif Date: Mon Jun 2 14:32:56 2025 +0300 Init diff --git a/CanMain.c b/CanMain.c new file mode 100644 index 0000000..39d2eb8 --- /dev/null +++ b/CanMain.c @@ -0,0 +1,1800 @@ +// +// Created by cfif on 05.08.2024. +// +#include "CanMain.h" +#include "CanPortFrame.h" +#include "SystemDelayInterface.h" +#include "LoggerToSerialPort.h" +#include "DiagnosticSessionControl_10.h" +#include "TesterPresent_3e.h" +#include "ReadDataByIdentifier_22i.h" +#include "string.h" +#include "EgtsInputCommands.h" +#include "EgtsEbu.h" +#include "RoutineControl_31.h" +#include "EgtsOutputCommands.h" +#include "math.h" + +#define LOG_SIGN "UDS" +#define LOGGER &env->slog->logger + +const uint8_t canTestData[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}; + +extern tFirmwareLoader FIRMWARE_TELE_LOADER; + +uint8_t reverseBits(uint8_t number) { + number = (number & 0x55) << 1 | (number & 0xAA) >> 1; + number = (number & 0x33) << 2 | (number & 0xCC) >> 2; + number = (number & 0x0F) << 4 | (number & 0xF0) >> 4; + + return number; +} + +bool ReceivedCan_func(void *arg, can_rx_message_type *canFrame) { + tCanMain *env = arg; + + + if ((canFrame->standard_id == TESTER_REQUEST_GNSS) || + (canFrame->standard_id == TESTER_REQUEST_FUNC) || + (canFrame->standard_id == TESTER_REQUEST_ABS_ESP) || + (canFrame->standard_id == TESTER_REQUEST_ACU) || + (canFrame->standard_id == TESTER_REQUEST_ECM) || + (canFrame->standard_id == TESTER_REQUEST_HVAC) || + (canFrame->standard_id == TESTER_REQUEST_IMMO_D) || + (canFrame->standard_id == TESTER_REQUEST_ITELMA_IMMO_D) || + (canFrame->standard_id == TESTER_REQUEST_PTS) || + (canFrame->standard_id == TESTER_REQUEST_SAS)) { + + env->isTimeTESTER_REQUEST = SystemGetMs(); + } + + + /* + tCanMain *env = arg; + + if (env->timeCan < SystemGetMs()) { + env->timeCan = SystemGetMs() + 1000; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "MAIN CAN = [%02x:%02x] %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", + (canFrame->standard_id >> 8) & 0xff, canFrame->standard_id & 0xff, + canFrame->data[0], canFrame->data[1], canFrame->data[2], canFrame->data[3], + canFrame->data[4], canFrame->data[5], canFrame->data[6], canFrame->data[7]) + } + + + // IPC_General + if (canFrame->standard_id == 0x3E8) { + + // внешняя температура + // Factor = 1.0 Offset = -40 Factor = 0.5 Offset = -40 + uint8_t CanRaw_ExternalTemperature = canFrame->data[1]; + if (CanRaw_ExternalTemperature != 0xFF) { + double ExternalTemperature = CanRaw_ExternalTemperature * 1.0 - 40; + +// if (env->time3E8_1 < SystemGetMs()) { +// env->time3E8_1 = SystemGetMs() + 1000; +// LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Внешняя температура = %d", (uint8_t) ExternalTemperature) +// } + + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ExternalTemperature].value = (uint8_t) ( + (ExternalTemperature + 40) / 0.5); + } + // уровень топлива + // Factor = 0.5 Offset = 0 Factor = 0.5 Offset = 0 + uint8_t CanRaw_FuelLevel = canFrame->data[3]; + if (CanRaw_FuelLevel != 0xFF) { + double FuelLevel = CanRaw_FuelLevel * 0.5; + +// if (env->time3E8_2 < SystemGetMs()) { +// env->time3E8_2 = SystemGetMs() + 1000; +// LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Уровень топлива = %d", (uint8_t)FuelLevel) +// } + + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_FuelLevel].value = (uint8_t) (FuelLevel / + 0.5); + } + } + + // ECM_Dashboard + if (canFrame->standard_id == 0x380) { + + // температура двигателя + // Factor = 0.75 Offset = -48 Factor = 0.5 Offset = -40 + uint8_t CanRaw_EngineOXTemperature = canFrame->data[0]; + double EngineOXTemperature = + canFrame->data[0] * 0.75 - 48; + + if (EngineOXTemperature < -39.5) { + + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_EngineOXTemperature].value = 0; + } else { + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_EngineOXTemperature].value = (uint8_t) ( + (EngineOXTemperature + 40) / 0.5); + } + +// if (env->time380_1 < SystemGetMs()) { +// env->time380_1 = SystemGetMs() + 1000; +// LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Температура двигателя = %d", (uint8_t) EngineOXTemperature) +// } + + // обороты двигателя + env->EngineSpeed = canFrame->data[1] * 40; + +// if (env->time380_2 < SystemGetMs()) { +// env->time380_2 = SystemGetMs() + 1000; +// LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Обороты двигателя = %d", env->EngineSpeed) +// } + + } +*/ + if ((env->isTimeTESTER_REQUEST + 5000) > SystemGetMs()) { + return true; + } + + return false; +} + +char *sendLogCanHex(tCanSerialPortFrameTp *env, uint8_t *data, size_t size); + +void ReceivedTP_func(void *arg, tCanTP_data *data) { + tCanMain *env = arg; + +// LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Приняты данные: "); +// sendLogCanHex(&env->canSerialPortFrameTp, data->data, data->len); + + if (data->adrCan == TESTER_REQUEST_GNSS) { + + if (data->data[0] == UDS_TesterPresent) { + + tTesterPresent testerPresent; + testerPresent.ServiceId = data->data[0] | 0b1000000; + testerPresent.zeroSubFunction = data->data[1] & 0b1111111; + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, (uint8_t *) &testerPresent, + sizeof(tTesterPresent), TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + + return; + } + + osStatus_t status = osMessageQueuePut(env->queueMain, data, 0, 0U); + + if (status != osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь addCommandQueue 1") + } + } else { + osStatus_t status = osMessageQueuePut(env->queueAdditional, data, 0, 0U); + + if (status != osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь addCommandQueue 2") + } + } + +} + +void CanMain_Init( + tCanMain *env, + tDeviceTeledataStorageData *deviceTeledataStorageData, + tSerialPortFrameIO *CanIO, + SystemMutexCmsis txAccessQueue, + tDeviceTestsTable *testsTable, + tLoggerToSerialPort *slog, + volatile tRawAccel *rawAccel, + tEgtsTeledata *egtsTeledata +) { + env->CanIO = CanIO; + env->deviceTeledataStorageData = deviceTeledataStorageData; + env->txAccessQueue = txAccessQueue; + env->slog = slog; + env->rawAccel = rawAccel; + env->testsTable = testsTable; + env->egtsTeledata = egtsTeledata; + env->queueMain = osMessageQueueNew(CAN_US_QUEUE_SIZE, sizeof(tCanTP_data), NULL); + env->queueAdditional = osMessageQueueNew(CAN_US_QUEUE_SIZE, sizeof(tCanTP_data), NULL); + + env->invalidKey = true; + env->invalidKeyAttempts = 3; + env->invalidKeyIsDelay = 0; + + env->isTimeTESTER_REQUEST = 0; + + env->filterIdCount = 7; + + env->filterReqId[0] = TESTER_RESPONSE_ABS_ESP; + env->filterReqId[1] = TESTER_RESPONSE_ECM; + env->filterReqId[2] = TESTER_RESPONSE_HVAC; + env->filterReqId[3] = TESTER_RESPONSE_IMMO_D; + env->filterReqId[4] = TESTER_RESPONSE_PTS; + env->filterReqId[5] = TESTER_REQUEST_GNSS; + env->filterReqId[6] = TESTER_RESPONSE_ITELMA_IMMO_D; + + env->filterRespId[0] = TESTER_REQUEST_ABS_ESP; + env->filterRespId[1] = TESTER_REQUEST_ECM; + env->filterRespId[2] = TESTER_REQUEST_HVAC; + env->filterRespId[3] = TESTER_REQUEST_IMMO_D; + env->filterRespId[4] = TESTER_REQUEST_PTS; + env->filterRespId[5] = TESTER_RESPONSE_GNSS; + env->filterRespId[6] = TESTER_REQUEST_ITELMA_IMMO_D; + + + env->filterDirReq[0] = 0; + env->filterDirReq[1] = 0; + env->filterDirReq[2] = 0; + env->filterDirReq[3] = 0; + env->filterDirReq[4] = 0; + env->filterDirReq[5] = 1; + env->filterDirReq[6] = 0; + + + CanSerialPortFrameTpInit( + &env->canSerialPortFrameTp, + + 0, + + env->txAccessQueue, + + ReceivedCan_func, + env, + + ReceivedTP_func, + env, + + env->CanIO, + (tCanTP_data *) &env->canTP_Ext_data, + sizeof(env->canTP_Ext_data.data), + slog, + + env->filterIdCount, + env->filterReqId, + env->filterRespId, + env->filterDirReq + + ); + + bool result; + + // Тип вызова 112 + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ECALL_TEST_MODE", + UDS_ECALLToTest, + 1); + + // Категория транспортного средства + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "VEHICLE_TYPE", + UDS_VehicleType, + 1); + // Тип энергоносителя + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, + "VEHICLE_PROPULSION_STORAGE_TYPE", UDS_vehicleFuelType, 1); + // Количество пассажиров + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "VEHICLE_PASSENGERS_NUMBER", + UDS_passengersNumber, 1); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "TEST_MODE_END_DISTANCE", + UDS_TestModeEndDistance, 2); + + // SIM Идентификатор + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "GSM_CCID", + UDS_SimIdentifier, + 19); + + // SIM Идентификатор COMM + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "GSM_CCID_COMERS", + UDS_CommSimIdentifier, + 20); + + // (МИН) Промежуток времени после завершения экстренного вызова, в течение которого УСВ автоматически отвечает на входящие звонки + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "CALL_AUTO_ANSWER_TIME", + UDS_CallAutoAnswerTime, 2); + + // Номер для тестового вызова + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ECALL_TEST_NUMBER", + UDS_ECALLTestNumber, 20); + + // (МИН) Время, после которого коммуникационный модуль GSM и UMTS прекращает регистрацию в сети + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "NAD_DEREGISTRATION_TIME", + UDS_NadDeregistrationTimer, 2); + + // Номер SMS цента + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "SMS_CENTER", + UDS_SMSCenterNumber, 20); + + // Номер, по которому УСВ посылает SMS с МНД при ошибке передачи МНД посредством in-band модема и по запросу от оператора системы. Определяется оператором национальной системы реагирования на аварии + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ECALL_SMS_FALLBACK_NUMBER", + UDS_SMSFallbackNumber, 20); + + // Период регистрации ТЕСТ + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "TEST_REGISTRATION_PERIOD", + UDS_TestRegistrationPeriod, 2); + + // Число попыток дозвона при экстренном вызове, инициированном вручную. Значение не может устанавливаться в «0» + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ECALL_MANUAL_DIAL_ATTEMPTS", + UDS_EcallManualDialAttempts, 2); + + // Интервал времени между повторными попытками отправки мнд из памяти + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "INT_MEM_TRANSMIT_INTERVAL", + UDS_IntMemTransmitInterval, 2); + + // Количество попыток отправки мнд из памяти + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "INT_MEM_TRANSMIT_ATTEMPTS", + UDS_IntMemTransmitAttempts, 2); + + // Только транспортные средства категорий М1 и N1 — число попыток дозвона при автоматически инициированном экстренном вызове. Не может быть установлено в «0» + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ECALL_AUTO_DIAL_ATTEMPTS", + UDS_EcallAutoDialAttempts, 2); + + // (МИН) Общая продолжительность дозвона при инициации экстренного вызова + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ECALL_DIAL_DURATION", + UDS_EcallDialDuration, 2); + + // APN + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "EGTS_GPRS_APN", + UDS_Apn, 50); + + // Промежуток времени, в течение которого УСВ остается зарегистрированной в сети после передачи результатов тестирования оператору системы + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, + "POST_TEST_REGISTRATION_TIME", + UDS_PostTestRegistrationTime, 2); + + // IMEI + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "GSM_CGSN", UDS_IMEI, 15); + + // VIN + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "VIN", + UDS_vehicleIdentificationNumber, 17); + + // SW_Version + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "SOFTWARE_VERS", + UDS_SW_Version, 27); + + + + // UDS_ECUSerialNumber + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ECU_SERIAL_NUMBER", + UDS_ECUSerialNumber, 20); + + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ACCEL_CALLIBRATION_X", + UDS_AccelCalibrationX, 2); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ACCEL_CALLIBRATION_Y", + UDS_AccelCalibrationY, 2); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ACCEL_CALLIBRATION_Z", + UDS_AccelCalibrationZ, 2); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ROLLOVER_ANGLE", + UDS_RolloverAngle, 1); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "ROLLOVER_TIME", + UDS_RolloverTime, 1); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "DIRECTION_ANGLE", + UDS_DirectionAngle, 1); +/* + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "EGTS_SERVER_ADDRESS", + UDS_ServerAddress, 32); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "EGTS_SERVER_SSL_ENABLE", + UDS_ServerSslEnable, 1); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "EGTS_ALT_SERVER_ADDRESS", + UDS_AltServerAddress, 32); +*/ + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "TELEMATICA_IS_ACTIVE", + UDS_TelematicsEnabledDisabled, 1); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "GNSS_GENERAL_TO_CAN", + UDS_TelematicsEnabledCanGnss, 1); + + result = VariablesTable_SetIdUDS_ByNameStatic(EXT_ENV_TELE.store.publicVariablesTable, "NAV_DATA_TO_CAN", + UDS_TelematicsEnabledCanNav, 1); + + InitThreadBlock(env->T_can_Main, "CanMain", osPriorityNormal); +} + +void SetUdsDTCerror(tCanMain *env, uint16_t *sizeResponse, eUdsErrorDTC codeError) { + env->canUDS_DataSendingBuf[*sizeResponse + 3] = UDS_DTC_Error[codeError].DTCHighByte; + env->canUDS_DataSendingBuf[*sizeResponse + 4] = UDS_DTC_Error[codeError].DTCMiddleByte; + env->canUDS_DataSendingBuf[*sizeResponse + 5] = UDS_DTC_Error[codeError].DTCLowByte; + env->canUDS_DataSendingBuf[*sizeResponse + 6] = 0x1; + + *sizeResponse += 4; +} + +static unsigned long SeedToKeyUAZ_ERA_NAMI(unsigned char rnd, unsigned long dwSeedInfo) { +#define Mask 0x52F387A6UL + unsigned char i; + unsigned long key = dwSeedInfo; + + rnd += 35; + if (rnd < 35) rnd = 255; + + for (i = 0; i < rnd; i++) { + if (key & 0x80000000UL) + key = (key << 1) ^ Mask; + else + key <<= 1; + } + + return key; +} + +void CanMainTask(tCanMain *env) { + tCanTP_data data; + + uint32_t timeoutClearSettings = 0; + + eUdsStartStopRoutineResult udsStartStopRoutineResult; + eUdsRequestRoutineResult udsRequestRoutineResult; + + + for (;;) { + osStatus_t status = osMessageQueueGet(env->queueMain, &data, 0, 1000); + + if (status == osOK) { + + + // начало --------------------------- SecurityAccess --------------------------------------------------------------- + // начало --------------------------- SecurityAccess -------------------------------------------------------------- + // начало --------------------------- SecurityAccess -------------------------------------------------------------- + + if (data.data[0] == UDS_SecurityAccess) { + bool isResponse = false; + + uint16_t sizeResponse = 0; + + uint32_t timeSystemGetMs = SystemGetMs(); + + if (data.data[1] == 0x01) { + isResponse = true; + + if (env->invalidKeyIsDelay < timeSystemGetMs) { + + env->RND = data.data[2]; + + sizeResponse = 6; + + uint32_t securitySeed = 0x11223344; + + env->canUDS_DataSendingBuf[2] = securitySeed >> 24; + env->canUDS_DataSendingBuf[3] = securitySeed >> 16; + env->canUDS_DataSendingBuf[4] = securitySeed >> 8; + env->canUDS_DataSendingBuf[5] = securitySeed; + } + + } + + if (data.data[1] == 0x02) { + isResponse = true; + + if (env->invalidKeyIsDelay < timeSystemGetMs) { + + sizeResponse = 3; + + uint32_t securitySeed = + (data.data[2] << 24) | + (data.data[3] << 16) | + (data.data[4] << 8) | + data.data[5]; + + env->canUDS_DataSendingBuf[2] = 2; + + uint32_t securitySeedMy = SeedToKeyUAZ_ERA_NAMI(env->RND, 0x11223344); + + if (securitySeedMy != securitySeed) { + env->invalidKey = true; + if (env->invalidKeyAttempts > 0) { + --env->invalidKeyAttempts; + } else { + env->invalidKeyAttempts = 3; + env->invalidKeyIsDelay = timeSystemGetMs + 10000; + } + } else { + env->invalidKey = false; + env->invalidKeyAttempts = 3; + } + +//------------------------Всегда разрешено !!!!!!!!!!!!!!!!!! +// env->invalidKey = false; + + } + + } + + if (isResponse) { + + if (env->invalidKeyIsDelay > timeSystemGetMs) { + sizeResponse = 3; + + env->canUDS_DataSendingBuf[0] = 0x7F; + env->canUDS_DataSendingBuf[1] = data.data[0]; + env->canUDS_DataSendingBuf[2] = 0x36; + + } else if ((env->invalidKey) && (data.data[1] == 0x02)) { + sizeResponse = 3; + + env->canUDS_DataSendingBuf[0] = 0x7F; + env->canUDS_DataSendingBuf[1] = data.data[0]; + env->canUDS_DataSendingBuf[2] = 0x35; + + } else { + + env->canUDS_DataSendingBuf[0] = data.data[0] | 0b1000000; + env->canUDS_DataSendingBuf[1] = data.data[1]; + + } + + } else { + sizeResponse = 3; + + env->canUDS_DataSendingBuf[0] = 0x7F; + env->canUDS_DataSendingBuf[1] = data.data[0]; + env->canUDS_DataSendingBuf[2] = 0x12; + } + + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, env->canUDS_DataSendingBuf, + sizeResponse, TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + + } + + + // конец ---------------------------- SecurityAccess --------------------------------------------------------------- + // конец ---------------------------- SecurityAccess -------------------------------------------------------------- + // конец ---------------------------- SecurityAccess -------------------------------------------------------------- + + + // начало --------------------------- Сброс --------------------------------------------------------------- + // начало --------------------------- Сброс -------------------------------------------------------------- + // начало --------------------------- Сброс -------------------------------------------------------------- + + if (data.data[0] == UDS_ECUResetService) { + bool isResponse = false; + uint16_t sizeResponse = 0; + + if (data.data[1] == 0x60) { + isResponse = true; + } + + if (isResponse) { + sizeResponse = 2; + + env->canUDS_DataSendingBuf[0] = data.data[0] | 0b1000000; + env->canUDS_DataSendingBuf[1] = data.data[1]; + + } else { + sizeResponse = 3; + + env->canUDS_DataSendingBuf[0] = 0x7F; + env->canUDS_DataSendingBuf[1] = data.data[0]; + env->canUDS_DataSendingBuf[2] = 0x12; + } + + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, env->canUDS_DataSendingBuf, + sizeResponse, TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + + + if (isResponse) { + SystemDelayMs(5000); + EXT_ENV_TELE.osFreeRTOS.nvic_system_reset(); + } + + } + + + // конец ---------------------------- Сброс --------------------------------------------------------------- + // конец ---------------------------- Сброс -------------------------------------------------------------- + // конец ---------------------------- Сброс -------------------------------------------------------------- + + + // начало --------------------------- Вызов функции УВЭОС -------------------------------------------------- + // начало --------------------------- Вызов функции УВЭОС ------------------------------------------------- + // начало --------------------------- Вызов функции УВЭОС ------------------------------------------------- + + if (data.data[0] == UDS_RoutineControl) { + bool isResponse = false; + uint16_t sizeResponse = 0; + + eUdsRoutineControlType udsRoutineControlType = data.data[1]; + uint16_t routineIdentifier = (data.data[2] << 8) | data.data[3]; + eUdsRoutineModes udsRoutineModes = data.data[4]; + + if (routineIdentifier == UDS_Self_Test) { + if ((udsRoutineControlType == UDS_StartRoutine) || + (udsRoutineControlType == UDS_StopRoutine) || + (udsRoutineControlType == UDS_RequestRoutineResults)) { + + if ((udsRoutineModes == UDS_MicrophoneDynamic) || + (udsRoutineModes == UDS_SosTestCall) || + (udsRoutineModes == UDS_SosTestCallNoMTS) || + (udsRoutineModes == UDS_LEDs)) { + + EXT_ENV_TELE.Routine_Can_UDS(EXT_ENV_TELE.Routine_Can_UDS_env, + routineIdentifier, + udsRoutineModes, + udsRoutineControlType, + &udsStartStopRoutineResult, + &udsRequestRoutineResult + ); + + + isResponse = true; + } + + } + } + + if (routineIdentifier == UDS_ModuleRegistration) { + + udsRoutineModes = UDS_NotDefined; + + EXT_ENV_TELE.Routine_Can_UDS(EXT_ENV_TELE.Routine_Can_UDS_env, + routineIdentifier, + udsRoutineModes, + udsRoutineControlType, + &udsStartStopRoutineResult, + &udsRequestRoutineResult + ); + + + isResponse = true; + + } + + + if ((env->invalidKey == false) || + (memcmp(EXT_ENV_TELE.store.gost->VIN.data, "00000000000000000", 17) == 0)) { + + + if (routineIdentifier == UDS_BoardVoltageCalibration) { + + udsRoutineModes = UDS_NotDefined; + + EXT_ENV_TELE.Routine_Can_UDS(EXT_ENV_TELE.Routine_Can_UDS_env, + routineIdentifier, + udsRoutineModes, + udsRoutineControlType, + &udsStartStopRoutineResult, + &udsRequestRoutineResult + ); + + + isResponse = true; + + } + + if (routineIdentifier == Clear_EEPROM) { + + udsRoutineModes = UDS_NotDefined; + + EXT_ENV_TELE.Routine_Can_UDS(EXT_ENV_TELE.Routine_Can_UDS_env, + routineIdentifier, + udsRoutineModes, + udsRoutineControlType, + &udsStartStopRoutineResult, + &udsRequestRoutineResult + ); + +/* + if (udsRoutineControlType == UDS_StartRoutine) { +// String32CopyStatic(&EXT_ENV_TELE.store.gost->VIN, "00000000000000000"); +// EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + udsStartStopRoutineResult = RoutineStartStopSuccess; + timeoutClearSettings = SystemGetMs() + 5000; + } + + if (udsRoutineControlType == UDS_RequestRoutineResults) { + + + if (timeoutClearSettings > SystemGetMs()) { + udsRequestRoutineResult = UDS_RoutineRun; + } else { + udsRequestRoutineResult = UDS_RoutineFinishSuccess; + } + + } +*/ + isResponse = true; + + } + } + + if (isResponse) { + + sizeResponse = 5; + + env->canUDS_DataSendingBuf[0] = data.data[0] | 0b1000000; + env->canUDS_DataSendingBuf[1] = data.data[1]; + env->canUDS_DataSendingBuf[2] = data.data[2]; + env->canUDS_DataSendingBuf[3] = data.data[3]; + + if ((udsRoutineControlType == UDS_StartRoutine) || (udsRoutineControlType == UDS_StopRoutine)) { + env->canUDS_DataSendingBuf[4] = udsStartStopRoutineResult; + } + + if (udsRoutineControlType == UDS_RequestRoutineResults) { + env->canUDS_DataSendingBuf[4] = udsRequestRoutineResult; + } + + + } else { + sizeResponse = 3; + + env->canUDS_DataSendingBuf[0] = 0x7F; + env->canUDS_DataSendingBuf[1] = data.data[0]; + env->canUDS_DataSendingBuf[2] = 0x12; + + if (env->invalidKey) { + env->canUDS_DataSendingBuf[2] = 0x33; + } + + } + + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, env->canUDS_DataSendingBuf, + sizeResponse, TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + + } + + + // конец --------------------------- Вызов функции УВЭОС -------------------------------------------------- + // конец --------------------------- Вызов функции УВЭОС -------------------------------------------------- + // конец --------------------------- Вызов функции УВЭОС -------------------------------------------------- + + + // начало ----------------------------- Сессия ------------------------------------------------------------- + // начало ----------------------------- Сессия ------------------------------------------------------------- + // начало ----------------------------- Сессия ------------------------------------------------------------- + + if (data.data[0] == UDS_DiagnosticSessionControl) { + tDiagnosticSessionsType diagnosticSessionsType; + diagnosticSessionsType.ServiceId = data.data[0] | 0b1000000; + diagnosticSessionsType.diagnosticSessionType = data.data[1] & 0b1111111; + + diagnosticSessionsType.sessionParameterRecord[0] = 0; + diagnosticSessionsType.sessionParameterRecord[1] = 0x32; + diagnosticSessionsType.sessionParameterRecord[2] = 0x01; + diagnosticSessionsType.sessionParameterRecord[3] = 0xF4; + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, (uint8_t *) &diagnosticSessionsType, + sizeof(tDiagnosticSessionsType), TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + + } + + // конец ----------------------------- Сессия ------------------------------------------------------------- + // конец ----------------------------- Сессия ------------------------------------------------------------- + // конец ----------------------------- Сессия ------------------------------------------------------------- + + + // начало --------------------------- Ошибки -------------------------------------------------------------- + // начало --------------------------- Ошибки -------------------------------------------------------------- + // начало --------------------------- Ошибки -------------------------------------------------------------- + + if (data.data[0] == UDS_ReadDTCInformation) { + uint16_t sizeResponse = 0; + + env->canUDS_DataSendingBuf[0] = data.data[0] | 0b1000000; + env->canUDS_DataSendingBuf[1] = data.data[1]; + env->canUDS_DataSendingBuf[2] = data.data[2]; + + for (uint16_t i = 0; i < EXT_ENV_TELE.testsTable->count; ++i) { + + eDeviceTestingCode deviceTestingCode; + eEgtsTestEbu egtsTestEbu = getResultTest(i, &deviceTestingCode); + + if (egtsTestEbu == TEST_FIRMWARE) { + // DEVICE_TESTING_CODE_ERROR + } + + if (egtsTestEbu == TEST_IGNITION) { + // DEVICE_TESTING_CODE_ERROR + } + + if (egtsTestEbu == TEST_BAT_CONNECT) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_BAT_CONNECT); + } + + if (egtsTestEbu == TEST_BAT_CHARGE) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_BAT_CHARGE); + } + + if (egtsTestEbu == TEST_BAT_VOLTAGE) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_BAT_VOLTAGE); + } + + if (egtsTestEbu == TEST_GNSS_ANT) { + // DEVICE_TESTING_CODE_ERROR + // DEVICE_TESTING_CODE_NOT_CONNECTED + // DEVICE_TESTING_CODE_SHORT_CIRCUIT + if ((deviceTestingCode == DEVICE_TESTING_CODE_ERROR) || + (deviceTestingCode == DEVICE_TESTING_CODE_NOT_CONNECTED) || + (deviceTestingCode == DEVICE_TESTING_CODE_SHORT_CIRCUIT)) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_GNSS_ANT); + } + + if (egtsTestEbu == TEST_SPEAKER_CONNECT) { + // DEVICE_TESTING_CODE_ERROR + // DEVICE_TESTING_CODE_NOT_CONNECTED + if ((deviceTestingCode == DEVICE_TESTING_CODE_ERROR) || + (deviceTestingCode == DEVICE_TESTING_CODE_NOT_CONNECTED)) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_SPEAKER_CONNECT); + + } + + if (egtsTestEbu == TEST_BIP_CONNECT) { + if (deviceTestingCode == DEVICE_TESTING_CODE_NOT_CONNECTED) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_MICROPHONE_CONNECT); + } + + + if (egtsTestEbu == TEST_ACCEL) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_ACCEL); + } + + if (egtsTestEbu == TEST_GSM) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_GSM); + } + + + if (egtsTestEbu == TEST_AUDIO_CODEC) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_GSM_AUDIO_CODEC); + } + + if (egtsTestEbu == TEST_VIN) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_VIN); + } + + if (egtsTestEbu == TEST_ACCEL_CALIB) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_ACCEL_CALIB); + } + + if (egtsTestEbu == TEST_EOL) { + // DEVICE_TESTING_CODE_ERROR +// if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) +// SetUdsDTCerror(env, &sizeResponse, UDS_TEST_EOL); + } + + if (egtsTestEbu == TEST_MODEM_SOFT_REV) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_MODEM_SOFT_REV); + } + + if (egtsTestEbu == TEST_CERT_REV) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_CERT_REV); + } + + if (egtsTestEbu == TEST_AUDIO_FILE) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_AUDIO_FILE); + } + + + if (egtsTestEbu == TEST_AMPLIFIER) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_AMPLIFIER); + } + + + if (egtsTestEbu == TEST_SIM_ERA) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_SIM_ERA); + } + + if (egtsTestEbu == TEST_SIM_COMERS) { + // DEVICE_TESTING_CODE_ERROR + if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR) + SetUdsDTCerror(env, &sizeResponse, UDS_TEST_SIM_COMERS); + } + + } + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, env->canUDS_DataSendingBuf, + sizeResponse + 3, TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + } + + if (data.data[0] == UDS_ClearDiagnosticInformation) { + uint16_t sizeResponse = 0; + + env->canUDS_DataSendingBuf[0] = data.data[0] | 0b1000000; + + clearResultTest(); + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, env->canUDS_DataSendingBuf, + sizeResponse + 1, TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + } + + // конец --------------------------- Ошибки --------------------------------------------------------- + // конец --------------------------- Ошибки --------------------------------------------------------- + // конец --------------------------- Ошибки --------------------------------------------------------- + + + // начало --------------------------- Чтение --------------------------------------------------------- + // начало --------------------------- Чтение --------------------------------------------------------- + // начало --------------------------- Чтение --------------------------------------------------------- + + if (data.data[0] == UDS_ReadDataByIdentifier) { + uint16_t dataIdentifier; + bool isResponse = false; + uint16_t sizeResponse = 0; + + dataIdentifier = (data.data[1] << 8) | data.data[2]; + + memset(env->canUDS_DataSendingBuf, 0, sizeof(env->canUDS_DataSendingBuf)); + + tVariableDescriptor *desc = VariablesTable_GetByIdUDS(EXT_ENV_TELE.store.publicVariablesTable, + dataIdentifier); + + if (desc != NULL) { + if (desc->typeId == VARIABLE_TYPE_STRING) { + memcpy(&env->canUDS_DataSendingBuf[3], desc->addr, *(uint8_t *) (desc->len)); +/* + if (!EXT_ENV_TELE.store.device->factoryMode) { + if (dataIdentifier == UDS_ECUSerialNumber) { + uint8_t lenECUSerialNumber = *(uint8_t *) (desc->len); + uint8_t *pointerECUSerialNumber = (uint8_t *) desc->addr; + + memcpy(&env->canUDS_DataSendingBuf[3], &pointerECUSerialNumber[4], + lenECUSerialNumber - 4); + memcpy(&env->canUDS_DataSendingBuf[3 + lenECUSerialNumber - 4], + &pointerECUSerialNumber[0], 4); + } + } +*/ + sizeResponse = desc->lenUds; + } else { +// uint8_t len = VariablesTable_ExGetVarTypeLength(desc); + + if (desc->lenUds == 1) { + env->canUDS_DataSendingBuf[3] = *(uint8_t *) desc->addr; + + if (dataIdentifier == UDS_vehicleFuelType) { + env->canUDS_DataSendingBuf[3] = reverseBits(env->canUDS_DataSendingBuf[3]); + } + + } + + if (desc->lenUds == 2) { + env->canUDS_DataSendingBuf[3] = *(uint8_t *) (desc->addr + 1); + env->canUDS_DataSendingBuf[4] = *(uint8_t *) desc->addr; + + if ((dataIdentifier == UDS_AccelCalibrationX) || + (dataIdentifier == UDS_AccelCalibrationY) || + (dataIdentifier == UDS_AccelCalibrationZ)) { + + env->canUDS_DataSendingBuf[3] = *(uint8_t *) (desc->addr); + env->canUDS_DataSendingBuf[4] = *(uint8_t *) (desc->addr + 1); + } + + + } + + if (desc->lenUds == 4) { + env->canUDS_DataSendingBuf[3] = *(uint8_t *) (desc->addr + 3); + env->canUDS_DataSendingBuf[4] = *(uint8_t *) (desc->addr + 2); + env->canUDS_DataSendingBuf[5] = *(uint8_t *) (desc->addr + 1); + env->canUDS_DataSendingBuf[6] = *(uint8_t *) desc->addr; + } + + + sizeResponse = desc->lenUds; + } + + isResponse = true; + } + + + if (dataIdentifier == UDS_InputStatesRecord) { + sizeResponse = sizeof(tInputStatesRecord_0001); + memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.InputStatesRecord_0001, sizeResponse); + isResponse = true; + } + + if (dataIdentifier == UDS_outputStatesRecord) { + sizeResponse = sizeof(tOutputStatesRecord_0002); + memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.OutputStatesRecord_0002, sizeResponse); + isResponse = true; + } + + if (dataIdentifier == UDS_SystemState) { + sizeResponse = sizeof(tSystemStateID_0006); + + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + // EXT_ENV_TELE.SystemStateID_0006->TCM_State = 0; + + memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.SystemStateID_0006, sizeResponse); + isResponse = true; + } + + if (dataIdentifier == UDS_AccelerometerRawData) { + sizeResponse = 8; + + //начало---------------------------------Рассчет для UDS сканера---------------------------------------------------- + + + vector3 gravity = (vector3) {0.f, 0.f, 1.f}; + vector3 currentValue = (vector3) {(float) egtsProcessing.x1 / 1000, + (float) egtsProcessing.y1 / 1000, + (float) egtsProcessing.z1 / 1000}; + + egtsProcessing.rawAccel.x = (int16_t) (currentValue.x * 1333); + egtsProcessing.rawAccel.y = (int16_t) (currentValue.y * 1333); + egtsProcessing.rawAccel.z = (int16_t) (currentValue.z * 1333); + + float angleCos = vector3AngleCos(gravity, currentValue); + float angle = acosf(angleCos); + egtsProcessing.rawAccel.angle = (uint16_t) (180.0 / 3.141592 * angle); + + //конец---------------------------------Рассчет для UDS сканера----------------------------------------------------- + + memcpy(&env->canUDS_DataSendingBuf[3], env->rawAccel, sizeResponse); + + isResponse = true; + } + + if (dataIdentifier == UDS_ECALLManualCanCancel) { + sizeResponse = 1; + + if (EXT_ENV_TELE.store.gost->ECALL_MANUAL_CAN_CANCEL) { + env->canUDS_DataSendingBuf[3] = 0xC7; + } else { + env->canUDS_DataSendingBuf[3] = 0x7C; + } + + isResponse = true; + } + + if (dataIdentifier == UDS_boardVoltage) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.BoardVoltage; + isResponse = true; + } + + if (dataIdentifier == UDS_reserveBatteryCharge) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.ReserveBatteryCharge; + isResponse = true; + } + +// if (dataIdentifier == UDS_reserveBatteryTemperature) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.ReserveBatteryTemperature; +// isResponse = true; +// } + + if (dataIdentifier == UDS_vehicleCoordinates) { + sizeResponse = 8; + + uint8_t dataVehicleCoordinates[8]; + + dataVehicleCoordinates[0] = EXT_ENV_TELE.VehicleCoordinates->vehicleLatitude >> 24; + dataVehicleCoordinates[1] = EXT_ENV_TELE.VehicleCoordinates->vehicleLatitude >> 16; + dataVehicleCoordinates[2] = EXT_ENV_TELE.VehicleCoordinates->vehicleLatitude >> 8; + dataVehicleCoordinates[3] = EXT_ENV_TELE.VehicleCoordinates->vehicleLatitude; + + dataVehicleCoordinates[4] = EXT_ENV_TELE.VehicleCoordinates->vehicleLongitude >> 24; + dataVehicleCoordinates[5] = EXT_ENV_TELE.VehicleCoordinates->vehicleLongitude >> 16; + dataVehicleCoordinates[6] = EXT_ENV_TELE.VehicleCoordinates->vehicleLongitude >> 8; + dataVehicleCoordinates[7] = EXT_ENV_TELE.VehicleCoordinates->vehicleLongitude; + + + memcpy(&env->canUDS_DataSendingBuf[3], dataVehicleCoordinates, sizeResponse); + isResponse = true; + } + + if (dataIdentifier == UDS_vehicleCoordinatesReliability) { + sizeResponse = 1; + + //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + //*EXT_ENV_TELE.VehicleCoordinatesReliability = 1; + + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.VehicleCoordinatesReliability; + isResponse = true; + } + + if (dataIdentifier == UDS_MDS_FormatVersion) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.MDS_FormatVersion; + isResponse = true; + } + + if (dataIdentifier == UDS_TCM_working_mode) { + sizeResponse = 1; + + //env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.TCM_working_mode; + + sizeResponse = 1; + + if (EXT_ENV_TELE.store.device->factoryMode) { + env->canUDS_DataSendingBuf[3] = 0xA5; + } else { + env->canUDS_DataSendingBuf[3] = 0x5A; + } + + isResponse = true; + } + +// if (dataIdentifier == UDS_TCM_activation_source) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.TCM_activation_source; +// isResponse = true; +// } + + if (dataIdentifier == UDS_TCM_time_calculation) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.TCM_time_calculation; + isResponse = true; + } + +// if (dataIdentifier == UDS_GLONASS_and_GLONASS_GPS_groups) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.GLONASS_and_GLONASS_GPS_groups; +// isResponse = true; +// } + + if (dataIdentifier == UDS_GsmRegistrationState) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.GsmRegistrationState; + isResponse = true; + } + + if (dataIdentifier == UDS_timeStamp) { + sizeResponse = 4; + + uint8_t dataTimeStamp[4]; + dataTimeStamp[0] = *EXT_ENV_TELE.TimeStamp >> 24; + dataTimeStamp[1] = *EXT_ENV_TELE.TimeStamp >> 16; + dataTimeStamp[2] = *EXT_ENV_TELE.TimeStamp >> 8; + dataTimeStamp[3] = *EXT_ENV_TELE.TimeStamp; + + memcpy(&env->canUDS_DataSendingBuf[3], dataTimeStamp, sizeResponse); + isResponse = true; + } + + if (dataIdentifier == UDS_GsmInnerError) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.GsmInnerError; + isResponse = true; + } + + if (dataIdentifier == UDS_VehicleCoordinatesReliabilityMem) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.VehicleCoordinatesReliabilityMem; + isResponse = true; + } + + if (dataIdentifier == UDS_GsmRegistartionStateMem) { + sizeResponse = 1; + + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +// *EXT_ENV_TELE.GsmRegistartionStateMem = 1; + + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.GsmRegistartionStateMem; + isResponse = true; + } + + if (dataIdentifier == UDS_GsmRegistrationError) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.GsmRegistrationError; + isResponse = true; + } + + if (dataIdentifier == UDS_EcallOn) { + sizeResponse = 1; + //env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.EcallOn; + + if (EXT_ENV_TELE.store.gost->CRASH_SIGNAL_INTERNAL) { + env->canUDS_DataSendingBuf[3] = 0x3B; + } else { + env->canUDS_DataSendingBuf[3] = 0xB3; + } + + isResponse = true; + } + +// if (dataIdentifier == UDS_CrashSignalExternal) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.CrashSignalExternal; +// isResponse = true; +// } + +// if (dataIdentifier == UDS_GnssPowerOffTime) { +// sizeResponse = 2; +// +// uint8_t dataGnssPoweOffTime[2]; +// dataGnssPoweOffTime[0] = *EXT_ENV_TELE.GnssPowerOffTime >> 8; +// dataGnssPoweOffTime[1] = *EXT_ENV_TELE.GnssPowerOffTime; +// +// memcpy(&env->canUDS_DataSendingBuf[3], dataGnssPoweOffTime, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_AutomaticActivationProhibition) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.AutomaticActivationProhibition; +// isResponse = true; +// } + +// if (dataIdentifier == UDS_NadRegistrationAtStartup) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.NadRegistrationAtStartup; +// isResponse = true; +// } + + if (dataIdentifier == UDS_GSMSoftwareVersionNumber) { + sizeResponse = 32; + memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.GSMSoftwareVersionNumber, sizeResponse); + isResponse = true; + } + + if (dataIdentifier == UDS_SmsFallbackTestNumber) { + sizeResponse = 20; + memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.SmsFallbackTestNumber, sizeResponse); + isResponse = true; + } + + if (dataIdentifier == UDS_SimProfileAmount) { + sizeResponse = 1; + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.SimProfileAmount; + isResponse = true; + } + +// if (dataIdentifier == UDS_SimProfile) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.SimProfile; +// isResponse = true; +// } + +// if (dataIdentifier == UDS_AudioProfile) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.AudioProfile; +// isResponse = true; +// } + + if (dataIdentifier == UDS_EcallNoAutomaticTriggering) { + sizeResponse = 1; + + env->canUDS_DataSendingBuf[3] = EXT_ENV_TELE.store.gost->ECALL_NO_AUTOMATIC_TRIGGERING; + + //env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.EcallNoAutomaticTriggering; + isResponse = true; + } + +// if (dataIdentifier == UDS_MiddletState) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.MiddletState; +// isResponse = true; +// } + +// if (dataIdentifier == UDS_Vehicle_SW_Version) { +// sizeResponse = 3; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.Vehicle_SW_Version, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_Midlet_SW_Version) { +// sizeResponse = 3; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.Midlet_SW_Version, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_Boot_SW_Version) { +// sizeResponse = 27; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.Boot_SW_Version, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_SertState) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.SertState; +// isResponse = true; +// } + +// if (dataIdentifier == UDS_ApplicationCheckSum) { +// sizeResponse = 2; +// +// uint8_t dataApplicationCheckSum[2]; +// dataApplicationCheckSum[0] = *EXT_ENV_TELE.ApplicationCheckSum >> 8; +// dataApplicationCheckSum[1] = *EXT_ENV_TELE.ApplicationCheckSum; +// +// memcpy(&env->canUDS_DataSendingBuf[3], dataApplicationCheckSum, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_Audio_HW_Settings) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.Audio_HW_Settings; +// isResponse = true; +// } + +// if (dataIdentifier == UDS_ECALL_EmergencyCallCounter) { +// sizeResponse = 3; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.ECALL_EmergencyCallCounter, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_Avaialble_Networks_List) { +// sizeResponse = 128; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.Avaialble_Networks_List, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_SavedMSDAmount) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.SavedMSDAmount; +// isResponse = true; +// } + +// if (dataIdentifier == UDS_SentMSDAmount) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.SentMSDAmount; +// isResponse = true; +// } + +// if (dataIdentifier == UDS_vehicleManufacturerSparePartNumber) { +// sizeResponse = 10; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.VehicleManufacturerSparePartNumber, +// sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_ConfigurationFileReferenceLink) { +// sizeResponse = 10; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.ConfigurationFileReferenceLink, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_systemSupplierIdentifier) { +// sizeResponse = 3; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.SystemSupplierIdentifier, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_ECUSerialNumber) { +// sizeResponse = 20; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.ECUSerialNumber, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_vehicleManufacturerECUHardwareNumber) { +// sizeResponse = 10; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.VehicleManufacturerECUHardwareNumber, +// sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_systemSupplierECUSoftwareNumber) { +// sizeResponse = 2; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.SystemSupplierECUSoftwareNumber, sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_systemSupplierECUSoftwareVersionNumber) { +// sizeResponse = 2; +// memcpy(&env->canUDS_DataSendingBuf[3], EXT_ENV_TELE.SystemSupplierECUSoftwareVersionNumber, +// sizeResponse); +// isResponse = true; +// } + +// if (dataIdentifier == UDS_VDIAG) { +// sizeResponse = 1; +// env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.VDIAG; +// isResponse = true; +// } + + if (dataIdentifier == UDS_TelematicsSoftwareVersion) { + sizeResponse = 32; + memcpy(&env->canUDS_DataSendingBuf[3], FIRMWARE_TELE_LOADER.main.metadata.name, + *FIRMWARE_TELE_LOADER.main.metadata.nameLength); + isResponse = true; + } + + if (dataIdentifier == UDS_Asi15) { + + sizeResponse = 4; + + uint32_t dataAsi15 = (uint32_t) ((double) EXT_ENV_TELE.store.gost->ASI15_TRESHOLD * 1000); + + env->canUDS_DataSendingBuf[6] = dataAsi15 & 0xFF; + env->canUDS_DataSendingBuf[5] = (dataAsi15 >> 8) & 0xFF; + env->canUDS_DataSendingBuf[4] = (dataAsi15 >> 16) & 0xFF; + env->canUDS_DataSendingBuf[3] = (dataAsi15 >> 24) & 0xFF; + + isResponse = true; + } + + if (dataIdentifier == UDS_LastEventDevice) { + sizeResponse = 1; + + env->canUDS_DataSendingBuf[3] = *EXT_ENV_TELE.LastEventDevice; + + isResponse = true; + } + + + if (dataIdentifier == UDS_ServerAddress) { + sizeResponse = 32; + + memcpy(&env->canUDS_DataSendingBuf[3], + env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data, + env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length); + + isResponse = true; + } + + if (dataIdentifier == UDS_ServerSslEnable) { + sizeResponse = 1; + + env->canUDS_DataSendingBuf[3] = env->deviceTeledataStorageData->telematica.EGTS_SERVER_SSL_ENABLE; + + isResponse = true; + } + + if (dataIdentifier == UDS_AltServerAddress) { + sizeResponse = 32; + + memcpy(&env->canUDS_DataSendingBuf[3], + env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.data, + env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.length); + + isResponse = true; + } + + if (isResponse) { + env->canUDS_DataSendingBuf[0] = data.data[0] | 0b1000000; + env->canUDS_DataSendingBuf[1] = data.data[1]; + env->canUDS_DataSendingBuf[2] = data.data[2]; + + } else { + env->canUDS_DataSendingBuf[0] = 0x7F; + env->canUDS_DataSendingBuf[1] = data.data[0]; + env->canUDS_DataSendingBuf[2] = 0x12; + } + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, env->canUDS_DataSendingBuf, + sizeResponse + 3, TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + + + } + + // конец --------------------------- Чтение --------------------------------------------------------- + // конец --------------------------- Чтение --------------------------------------------------------- + // конец --------------------------- Чтение --------------------------------------------------------- + + + // начало --------------------------- Запись --------------------------------------------------------- + // начало --------------------------- Запись --------------------------------------------------------- + // начало --------------------------- Запись --------------------------------------------------------- + if (data.data[0] == UDS_WriteDataByIdentifier) { + uint16_t dataIdentifier; + bool isResponse = false; + uint16_t sizeResponse = 0; + + + if ((env->invalidKey == false) || + (memcmp(EXT_ENV_TELE.store.gost->VIN.data, "00000000000000000", 17) == 0)) { + + dataIdentifier = (data.data[1] << 8) | data.data[2]; + + memset(env->canUDS_DataSendingBuf, 0, sizeof(env->canUDS_DataSendingBuf)); + + tVariableDescriptor *desc = VariablesTable_GetByIdUDS(EXT_ENV_TELE.store.publicVariablesTable, + dataIdentifier); + + if (desc != NULL) { + + if (VariablesTable_IsVariableChangeAllowed(desc)) { + + if (desc->typeId == VARIABLE_TYPE_STRING) { + + uint8_t lenStr = desc->lenUds; + + if ((data.len - 3) < desc->lenUds) { + lenStr = 0; + for (uint16_t i = 3; i < data.len; ++i) { + if (data.data[i] == 0) { + break; + } else { + ++lenStr; + } + } + } + + memcpy(desc->addr, &data.data[3], lenStr); + *(uint8_t *) (desc->addr - 1) = lenStr; + + } else { +// uint8_t len = VariablesTable_ExGetVarTypeLength(desc); + + if (desc->lenUds == 1) { + *(uint8_t *) desc->addr = data.data[3]; + + if (dataIdentifier == UDS_vehicleFuelType) { + uint8_t pere = data.data[3]; + pere = reverseBits(pere); + *(uint8_t *) desc->addr = (pere); + } + } + + if (desc->lenUds == 2) { + *(uint8_t *) desc->addr = data.data[4]; // Младшая 4 - младшая + *(uint8_t *) (desc->addr + 1) = data.data[3]; // Старшая 3 - старшая + + if ((dataIdentifier == UDS_AccelCalibrationX) || + (dataIdentifier == UDS_AccelCalibrationY) || + (dataIdentifier == UDS_AccelCalibrationZ)) { + +// *(uint8_t *) (desc->addr + 1) = data.data[4]; // +// *(uint8_t *) desc->addr = data.data[3]; + + } + + } + + if (desc->lenUds == 4) { + *(uint8_t *) desc->addr = data.data[6]; + *(uint8_t *) (desc->addr + 1) = data.data[5]; + *(uint8_t *) (desc->addr + 2) = data.data[4]; + *(uint8_t *) (desc->addr + 3) = data.data[3]; + } + + } + + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + } else { + + if (dataIdentifier == UDS_ECALLManualCanCancel) { + + if (data.data[3] == 0xC7) { + EXT_ENV_TELE.store.gost->ECALL_MANUAL_CAN_CANCEL = true; + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + + if (data.data[3] == 0x7C) { + EXT_ENV_TELE.store.gost->ECALL_MANUAL_CAN_CANCEL = false; + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + } + + if (dataIdentifier == UDS_EcallOn) { + + if (data.data[3] == 0x3B) { + EXT_ENV_TELE.store.gost->CRASH_SIGNAL_INTERNAL = true; + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + + if (data.data[3] == 0xB3) { + EXT_ENV_TELE.store.gost->CRASH_SIGNAL_INTERNAL = false; + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + } + + if (dataIdentifier == UDS_TCM_working_mode) { + + if (data.data[3] == 0x5A) { + EXT_ENV_TELE.store.device->factoryMode = false; + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + + if (data.data[3] == 0xA5) { + EXT_ENV_TELE.store.device->factoryMode = true; + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + } + + if (dataIdentifier == UDS_VehicleCoordinatesReliabilityMem) { + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + + if (dataIdentifier == UDS_GsmRegistartionStateMem) { + *EXT_ENV_TELE.GsmRegistartionStateMem = 0; + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + + if (dataIdentifier == UDS_Asi15) { + + uint32_t dataAsi15; + + dataAsi15 = (uint32_t) data.data[6]; + dataAsi15 |= (uint32_t) ((uint32_t) data.data[5] << 8); + dataAsi15 |= (uint32_t) ((uint32_t) data.data[4] << 16); + dataAsi15 |= (uint32_t) ((uint32_t) data.data[3] << 24); + + EXT_ENV_TELE.store.gost->ASI15_TRESHOLD = (float) ((double) dataAsi15 / 1000); + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + + if (dataIdentifier == UDS_SetDeviceFactoryMode) { + EXT_ENV_TELE.SetDeviceFactoryMode(EXT_ENV_TELE.SetDeviceFactoryMode_env); + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + + if (EXT_ENV_TELE.Function_Can_UDS != NULL) { + + if (dataIdentifier == UDS_TASK_INDICATION_START_STOP_CAN_UDS) { + + uint8_t dataFunctionCanUds = (data.data[3] == 0) ? TASK_INDICATION_STOP_CAN_UDS + : TASK_INDICATION_START_CAN_UDS; + + EXT_ENV_TELE.Function_Can_UDS(EXT_ENV_TELE.Function_Can_UDS_env, + TASK_INDICATION_STOP_START_CAN_UDS, + &dataFunctionCanUds + ); + + isResponse = true; + } + + if (dataIdentifier == UDS_GPIO_ECALL_OUT_CAN_UDS) { + + uint8_t dataFunctionCanUds = (data.data[3] == 0) ? GPIO_FALSE_ECALL_OUT_CAN_UDS + : GPIO_TRUE_ECALL_OUT_CAN_UDS; + + EXT_ENV_TELE.Function_Can_UDS(EXT_ENV_TELE.Function_Can_UDS_env, + GPIO_WRITE_CAN_UDS, + &dataFunctionCanUds + ); + + isResponse = true; + } + + if (dataIdentifier == UDS_GPIO_GARAGE_CAN_UDS) { + + uint8_t dataFunctionCanUds = (data.data[3] == 0) ? GPIO_FALSE_GARAGE_CAN_UDS + : GPIO_TRUE_GARAGE_CAN_UDS; + + EXT_ENV_TELE.Function_Can_UDS(EXT_ENV_TELE.Function_Can_UDS_env, + GPIO_WRITE_CAN_UDS, + &dataFunctionCanUds + ); + + isResponse = true; + } + + if (dataIdentifier == UDS_GPIO_MUTE_P_CAN_UDS) { + + uint8_t dataFunctionCanUds = (data.data[3] == 0) ? GPIO_FALSE_MUTE_P_CAN_UDS + : GPIO_TRUE_MUTE_P_CAN_UDS; + + EXT_ENV_TELE.Function_Can_UDS(EXT_ENV_TELE.Function_Can_UDS_env, + GPIO_WRITE_CAN_UDS, + &dataFunctionCanUds + ); + + isResponse = true; + } + + + if (dataIdentifier == UDS_GPIO_MUTE_N_CAN_UDS) { + + uint8_t dataFunctionCanUds = (data.data[3] == 0) ? GPIO_FALSE_MUTE_N_CAN_UDS + : GPIO_TRUE_MUTE_N_CAN_UDS; + + EXT_ENV_TELE.Function_Can_UDS(EXT_ENV_TELE.Function_Can_UDS_env, + GPIO_WRITE_CAN_UDS, + &dataFunctionCanUds + ); + + isResponse = true; + } + + if (dataIdentifier == UDS_GPIO_LED_RED_CAN_UDS) { + + uint8_t dataFunctionCanUds = (data.data[3] == 0) ? GPIO_FALSE_LED_RED_CAN_UDS + : GPIO_TRUE_LED_RED_CAN_UDS; + + EXT_ENV_TELE.Function_Can_UDS(EXT_ENV_TELE.Function_Can_UDS_env, + GPIO_WRITE_CAN_UDS, + &dataFunctionCanUds + ); + + isResponse = true; + } + + if (dataIdentifier == UDS_GPIO_LED_GREEN_CAN_UDS) { + + uint8_t dataFunctionCanUds = (data.data[3] == 0) ? GPIO_FALSE_LED_GREEN_CAN_UDS + : GPIO_TRUE_LED_GREEN_CAN_UDS; + + EXT_ENV_TELE.Function_Can_UDS(EXT_ENV_TELE.Function_Can_UDS_env, + GPIO_WRITE_CAN_UDS, + &dataFunctionCanUds + ); + + isResponse = true; + } + + if (dataIdentifier == UDS_AUDIO_PLAY_TEST_CAN_UDS) { + + uint8_t dataFunctionCanUds = data.data[3]; + + EXT_ENV_TELE.Function_Can_UDS(EXT_ENV_TELE.Function_Can_UDS_env, + AUDIO_TEST_PLAY_CAN_UDS, + &dataFunctionCanUds + ); + + isResponse = true; + } + + } + + } + + if (dataIdentifier == UDS_EcallNoAutomaticTriggering) { + EXT_ENV_TELE.store.gost->ECALL_NO_AUTOMATIC_TRIGGERING = env->canUDS_DataSendingBuf[3]; + isResponse = true; + EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + } + } + + + if (isResponse) { +// EraGlonassUveosDumper_ForceDump(EXT_ENV_TELE.store.uveosDumper); +// EXT_ENV_TELE.store.publicVariablesTable->changes = 1; + + env->canUDS_DataSendingBuf[0] = data.data[0] | 0b1000000; + env->canUDS_DataSendingBuf[1] = data.data[1]; + env->canUDS_DataSendingBuf[2] = data.data[2]; + + } else { + env->canUDS_DataSendingBuf[0] = 0x7F; + env->canUDS_DataSendingBuf[1] = data.data[0]; + env->canUDS_DataSendingBuf[2] = 0x12; + + if (env->invalidKey) { + env->canUDS_DataSendingBuf[2] = 0x33; + } + + } + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, env->canUDS_DataSendingBuf, + sizeResponse + 3, TESTER_RESPONSE_GNSS, WAIT_FRAME_WRITE); + + } + // конец --------------------------- Запись --------------------------------------------------------- + // конец --------------------------- Запись --------------------------------------------------------- + // конец --------------------------- Запись --------------------------------------------------------- + + } + } +} + + +void CanMain_Start(tCanMain *env) { + CanSerialPortFrameTp_Start(&env->canSerialPortFrameTp, 0); + ThreadBlock_Start(env->T_can_Main, env, CanMainTask); +} + + diff --git a/CanMain.h b/CanMain.h new file mode 100644 index 0000000..a999a6f --- /dev/null +++ b/CanMain.h @@ -0,0 +1,413 @@ +// +// Created by cfif on 05.08.2024. +// + +#ifndef SMART_COMPONENTS_UPDATE_CANMAIN_H +#define SMART_COMPONENTS_UPDATE_CANMAIN_H + +#include "CanSerialPortFrame.h" +#include "CmsisRtosThreadUtils.h" +#include "CanSerialPortFrameTP.h" +#include "DeviceStorage.h" +#include "DeviceTestsTable.h" +#include "ReadDTCInformation_19.h" +#include "RoutineControl_31.h" +#include "EgtsTelesataTypes.h" +#include "SystemMutexCmsis.h" +#include "SerialPortCanComInt.h" +#include "GsmWithGnss.h" +#include "DataStorage.h" + +extern const uint8_t canTestData[8]; + + +//#define CAN_ADR_REQUEST 0x7ca +//#define CAN_ADR_RESPONSE 0x7da + +#define CAN_US_QUEUE_SIZE 3 + +typedef enum { + UDS_DiagnosticSessionControl = 0x10, + UDS_ReadDTCInformation = 0x19, + UDS_ClearDiagnosticInformation = 0x14, + UDS_TesterPresent = 0x3E, + UDS_ReadDataByIdentifier = 0x22, + UDS_WriteDataByIdentifier = 0x2E, + UDS_RoutineControl = 0x31, + UDS_ECUResetService = 0x11, + UDS_SecurityAccess = 0x27 +} eUdsServices; + +typedef enum { + UDS_InputStatesRecord = 0x0001, + UDS_outputStatesRecord = 0x0002, + UDS_boardVoltage = 0x0003, + UDS_reserveBatteryCharge = 0x0004, + UDS_reserveBatteryTemperature = 0x0005, + UDS_SystemState = 0x0006, + UDS_vehicleCoordinates = 0x0007, + UDS_vehicleCoordinatesReliability = 0x0008, + UDS_MDS_FormatVersion = 0x0009, + UDS_vehicleFuelType = 0x000A, + UDS_timeStamp = 0x000B, + UDS_passengersNumber = 0x000C, + UDS_TCM_working_mode = 0x000D, + UDS_TCM_activation_source = 0x000E, + UDS_TCM_time_calculation = 0x000F, + UDS_ECALLManualCanCancel = 0x0010, + UDS_GLONASS_and_GLONASS_GPS_groups = 0x0011, + UDS_GsmRegistrationState = 0x0012, + UDS_GsmInnerError = 0x0013, + UDS_VehicleCoordinatesReliabilityMem = 0x0014, + UDS_GsmRegistartionStateMem = 0x0015, + UDS_GsmRegistrationError = 0x0016, // ! + UDS_EcallOn = 0x0017, + UDS_CrashSignalExternal = 0x0018, + UDS_TestModeEndDistance = 0x0019, + UDS_GnssPowerOffTime = 0x001A, + UDS_AutomaticActivationProhibition = 0x001B, + UDS_VehicleType = 0x001C, + UDS_SimIdentifier = 0x001D, + UDS_CommSimIdentifier = 0x001E, + UDS_CallAutoAnswerTime = 0x0301, + UDS_ECALLTestNumber = 0x0302, + UDS_ECALLToTest = 0x0303, + UDS_NadDeregistrationTimer = 0x0304, + UDS_NadRegistrationAtStartup = 0x0305, + UDS_SMSCenterNumber = 0x0306, + UDS_SMSFallbackNumber = 0x0307, + UDS_TestRegistrationPeriod = 0x030E, + UDS_EcallManualDialAttempts = 0x030F, + UDS_IntMemTransmitInterval = 0x0310, + UDS_IntMemTransmitAttempts = 0x0311, + UDS_GSMSoftwareVersionNumber = 0x0312, // ! + UDS_SmsFallbackTestNumber = 0x0316, + UDS_EcallAutoDialAttempts = 0x0319, + UDS_EcallDialDuration = 0x031A, + UDS_PostTestRegistrationTime = 0x031B, + UDS_SimProfileAmount = 0x031C, + UDS_SimProfile = 0x031D, + UDS_Apn = 0x031E, + UDS_AudioProfile = 0x0323, + UDS_AccelerometerRawData = 0x0401, + UDS_RolloverAngle = 0x0402, + UDS_RolloverTime = 0x0403, + UDS_EcallNoAutomaticTriggering = 0x0407, + UDS_MiddletState = 0x0408, + UDS_SW_Version = 0x0409, + UDS_Vehicle_SW_Version = 0x040A, + UDS_Midlet_SW_Version = 0x040B, + UDS_Boot_SW_Version = 0x040D, + UDS_SertState = 0x040E, + UDS_DirectionAngle = 0x040F, + UDS_IMEI = 0x0411, + UDS_ApplicationCheckSum = 0x0412, + UDS_Audio_HW_Settings = 0x0420, + UDS_ECALL_EmergencyCallCounter = 0x0422, + UDS_Avaialble_Networks_List = 0x0430, + UDS_SavedMSDAmount = 0x01FF, + UDS_SentMSDAmount = 0x02FF, + UDS_vehicleManufacturerSparePartNumber = 0xF187, + UDS_ConfigurationFileReferenceLink = 0xF188, + UDS_systemSupplierIdentifier = 0xF18A, + UDS_ECUSerialNumber = 0xF18C, + UDS_vehicleIdentificationNumber = 0xF190, + UDS_vehicleManufacturerECUHardwareNumber = 0xF191, + UDS_systemSupplierECUSoftwareNumber = 0xF194, + UDS_systemSupplierECUSoftwareVersionNumber = 0xF195, + UDS_VDIAG = 0xF1A0, + UDS_AccelCalibrationX = 0x0404, + UDS_AccelCalibrationY = 0x0405, + UDS_AccelCalibrationZ = 0x0406, + UDS_TelematicsSoftwareVersion = 0x0600, + UDS_ServerAddress = 0x0601, + UDS_ServerSslEnable = 0x0602, + UDS_AltServerAddress = 0x0603, + UDS_TelematicsEnabledDisabled = 0x604, + UDS_Asi15 = 0x605, + UDS_LastEventDevice = 0x606, + UDS_SetDeviceFactoryMode = 0x607, + UDS_TelematicsEnabledCanGnss = 0x608, + UDS_TelematicsEnabledCanNav = 0x609, + + UDS_TASK_INDICATION_START_STOP_CAN_UDS = 0x700, + UDS_GPIO_ECALL_OUT_CAN_UDS = 0x701, + UDS_GPIO_GARAGE_CAN_UDS = 0x702, + UDS_GPIO_MUTE_P_CAN_UDS = 0x703, + UDS_GPIO_MUTE_N_CAN_UDS = 0x704, + UDS_GPIO_LED_RED_CAN_UDS = 0x705, + UDS_GPIO_LED_GREEN_CAN_UDS = 0x706, + + UDS_AUDIO_PLAY_TEST_CAN_UDS = 0x710, + +} eUdsReadDataByIdentifier; + +typedef struct { + int16_t x; + int16_t y; + int16_t z; + uint16_t angle; +} tRawAccel; + +typedef struct { + tCanSerialPortFrameTp canSerialPortFrameTp; + tCanTP_Ext_data canTP_Ext_data; + osMessageQueueId_t queueMain; + osMessageQueueId_t queueAdditional; + SystemMutexCmsis txAccessQueue; + tEgtsTeledata *egtsTeledata; + + tDeviceTeledataStorageData *deviceTeledataStorageData; + + uint8_t canUDS_DataSendingBuf[256]; + + tSerialPortFrameIO *CanIO; + tLoggerToSerialPort *slog; + tDeviceTestsTable *testsTable; + tRawAccel *rawAccel; + + uint8_t filterIdCount; + uint32_t filterReqId[16]; + uint32_t filterRespId[16]; + uint8_t filterDirReq[16]; + + // Запрос типа функции на устройстве + eUdsRoutineModes udsRoutineModes; + // Запрос состояние функции на устройстве + eUdsRoutineControlType udsRoutineControlType; + + uint32_t timeID; + uint32_t time380_1; + uint32_t time380_2; + uint32_t time3E8_1; + uint32_t time3E8_2; + uint32_t timeCan; + + uint8_t RND; + bool invalidKey; + uint8_t invalidKeyAttempts; + uint32_t invalidKeyIsDelay; + + uint32_t isTimeTESTER_REQUEST; + + tStaticThreadBlock(1024) T_can_Main; +} tCanMain; + + +typedef struct { + SystemMutexCmsis txAccessQueue; + tSerialPortFrameIO *CanIO; + tLoggerToSerialPort *slog; + + tGsmWithGnss *gsm; + + bool isPassedTestCan; + + uint8_t GNSS_NMEA1[8]; + uint8_t GNSS_NMEA2[8]; + uint8_t GNSS_NMEA3[8]; + uint8_t GNSS_NMEA4[8]; + uint8_t GNSS_NMEA5[8]; + uint8_t GNSS_NMEA6[8]; + + tStaticThreadBlock(512) T_can_MainMute; + tStaticThreadBlock(512) T_can_MainNav; +} tCanMainMute; + +#define NUM_ACC_COUNT_MAX (5) + +typedef struct { + tCanSerialPortFrameTp canSerialPortFrameTp; + tCanTP_data canTP_data; +// osMessageQueueId_t queue; + SystemMutexCmsis txAccessQueue; + tEgtsTeledata *egtsTeledata; + + tDeviceTeledataStorageData *deviceTeledataStorageData; + + tSerialPortFrameIO *CanIO; + tLoggerToSerialPort *slog; + tDeviceTestsTable *testsTable; + volatile tRawAccel *rawAccel; + + uint8_t filterIdCount; + uint32_t filterReqId[16]; + uint32_t filterRespId[16]; + uint8_t filterDirReq[16]; + + // Запрос типа функции на устройстве + eUdsRoutineModes udsRoutineModes; + // Запрос состояние функции на устройстве + eUdsRoutineControlType udsRoutineControlType; + + uint32_t EngineSpeed; + + uint32_t timeID; + uint32_t time380_1; + uint32_t time380_2; + uint32_t time3E8_1; + uint32_t time3E8_2; + uint32_t timeCan; + + uint8_t RND; + bool invalidKey; + uint8_t invalidKeyAttempts; + uint32_t invalidKeyIsDelay; + + tCanMainMute *canMainMute; + + tCanMain *canMain; + + uint32_t timeAbsSpeedOnSecond; + uint32_t timeAbsSpeed; + uint32_t Counter_SENSORS_AN_TripMileage_MM; + uint32_t Counter_SENSORS_AN_TripMileage_MICRO_L; + + struct { + float acc_last[NUM_ACC_COUNT_MAX]; + uint8_t index; + float old_speed; + bool data_erase; + } calc_scoring; + + struct { + uint32_t skip_fuel_frames; + uint32_t pre_filtered_fuel; + long long int mem_fuel_diff; + bool ign_on; + } calc_fuel_lvl; + + uint32_t fuel_lvlFiltered; + uint16_t ABS_VehicleSpeed; + + + struct { + uint32_t acc_calc_time; + uint32_t gnss_course_speed; + uint32_t reference_speed; + uint32_t diff_speed_up; + uint32_t diff_speed_down; + } gnss_config; + + struct { + uint32_t trip_braking; + uint32_t trip_acceleration; + } state_get; + + struct { + uint32_t total_acceleration; + uint32_t acceleration; + uint32_t total_braking; + uint32_t braking; + } bc_get; + + + uint32_t isTimeSENSORS_DIG_BodyCanBusStatus; + + tSerialPortCanComInt *serialPortCanComInt; + + tEgtsEbuState *ebuState; + SystemMutexCmsis accessEbu; + void *envEgtsProcessing; + volatile tEgtsEbuUdsReady egtsEbuUdsReady; + + bool *isEnableTelematicaSendPoints; + + tStaticThreadBlock(1024) T_can_MainAdditional; + +} tCanMainAdditional; + +typedef struct { + tSerialPortFrameIO *CanIO; + tLoggerToSerialPort *slog; + tStaticThreadBlock(512) T_can_MainTest; +} tCanMainTest; + +void CanMain_Init( + tCanMain *env, + tDeviceTeledataStorageData *deviceTeledataStorageData, + tSerialPortFrameIO *CanIO, + SystemMutexCmsis txAccessQueue, + tDeviceTestsTable *testsTable, + tLoggerToSerialPort *slog, + volatile tRawAccel *rawAccel, + tEgtsTeledata *egtsTeledata +); + +void CanMain_Start(tCanMain *env); + +void CanMainAdditional_Init( + tCanMainAdditional *env, + tSerialPortFrameIO *CanIO, + tSerialPortCanComInt *serialPortCanComInt, + tCanMainMute *canMainMute, + SystemMutexCmsis txAccessQueue, + tDeviceTestsTable *testsTable, + tLoggerToSerialPort *slog, + volatile tRawAccel *rawAccel, + tEgtsTeledata *egtsTeledata, + tEgtsEbuState *ebuState, + SystemMutexCmsis accessEbu, + tCanMain *canMain, + void *envEgtsProcessing, + bool *isEnableTelematicaSendPoints +); + +void CanMainAdditional_Start(tCanMainAdditional *env); + +typedef struct __attribute__ ((packed)) { + uint8_t VLD: 1; + uint8_t LAHS: 1; + uint8_t LOHS: 1; + uint8_t ALTH: 1; + uint8_t SATH: 1; + uint8_t RESERVED_1: 1; + uint8_t RESERVED_2: 1; + uint8_t RESERVED_3: 1; +} tFLG_GNSS_NMEA2; + +typedef struct __attribute__ ((packed)) { + uint16_t SPD: 14; + uint8_t ALTS: 1; + uint8_t DIRH: 1; +} tSPD_GNSS_NMEA2; + +typedef struct __attribute__ ((packed)) { + uint32_t NTM; + uint32_t LAT; +} tGNSS_NMEA1; + +typedef struct __attribute__ ((packed)) { + uint32_t LONG; + tFLG_GNSS_NMEA2 FLG; + tSPD_GNSS_NMEA2 SPD; + uint8_t DIR; +} tGNSS_NMEA2; + +typedef struct __attribute__ ((packed)) { + uint16_t ALT; + uint8_t SAT; + uint8_t RESERVED[5]; +} tGNSS_NMEA3; + +void CanMainMute_Init( + tCanMainMute *env, + tSerialPortFrameIO *CanIO, + SystemMutexCmsis txAccessQueue, + tGsmWithGnss *gsm, + tLoggerToSerialPort *slog +); + +void CanMainMute_Start(tCanMainMute *env); + +void CanMainTest_Init( + tCanMainTest *env, + tSerialPortFrameIO *CanIO, + + tLoggerToSerialPort *slog +); + +void CanMainTest_Start(tCanMainTest *env); + + +#endif //SMART_COMPONENTS_UPDATE_CANMAIN_H diff --git a/CanMainAdditional.c b/CanMainAdditional.c new file mode 100644 index 0000000..9712d12 --- /dev/null +++ b/CanMainAdditional.c @@ -0,0 +1,1175 @@ +// +// Created by cfif on 15.10.2024. +// + +#include "CanMain.h" +#include "EgtsOutputCommands.h" +#include "SystemDelayInterface.h" +#include "math.h" +#include "Rtc.h" +#include "DiagnosticSessionControl_10.h" +#include "EgtsEbu.h" +#include "ReadDataByIdentifier_22i.h" +#include "ClearDiagnosticInformation_14.h" + +#define LOG_SIGN "UDS_ADD" +#define LOGGER &env->slog->logger + +#define ADD_TO_DATA_CHAR_SHORT(DATA) *(uint8_t *) (out + offset) = DATA; *(uint8_t *) (out + offset + 1) = 0; offset+=2; +#define ADD_TO_DATA_SHORT(DATA) *(uint8_t *) (out + offset) = (uint8_t)DATA; *(uint8_t *) (out + offset + 1) = (uint8_t)(DATA >> 8); offset+=2; +#define ADD_TO_DATA_BYTE(DATA) *(uint8_t *) (out + offset) = (uint8_t)DATA; offset+=1; +#define ADD_TO_DATA(DATA, LEN) memcpy(out + offset, (uint8_t * ) & DATA, LEN); offset+=LEN; + +extern const tEgtsEbuName egtsEbuName[EBU_COUNT_TABLE_ITEMS]; + +void calc_driver_scoring(tCanMainAdditional *env, float new_speed) { + + if (!env->gnss_config.acc_calc_time) + return; + + if ((env->EngineSpeed > 100) && (new_speed >= (float) env->gnss_config.gnss_course_speed) && + (env->calc_scoring.old_speed >= (float) env->gnss_config.gnss_course_speed)) { + float acc_sum = 0; + float coef_acc = 1.0f; + + if (env->gnss_config.reference_speed && new_speed > ((float) env->gnss_config.reference_speed)) + coef_acc = (float) sqrt((double) new_speed / ((double) env->gnss_config.reference_speed)); + + env->calc_scoring.acc_last[env->calc_scoring.index] = ((new_speed - env->calc_scoring.old_speed) * coef_acc); + + for (uint32_t i = 0; i < env->gnss_config.acc_calc_time; i++) { + acc_sum += env->calc_scoring.acc_last[i]; + } + + if ((float) env->gnss_config.diff_speed_up > 0.0f && acc_sum >= (float) env->gnss_config.diff_speed_up) { + env->state_get.trip_acceleration++; + env->bc_get.total_acceleration++; + env->bc_get.acceleration++; + for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) { + env->calc_scoring.acc_last[i] = 0.0f; + } + } else if ((float) env->gnss_config.diff_speed_down > 0.0f && + acc_sum <= ((-1.0f) * (float) env->gnss_config.diff_speed_down)) { + env->state_get.trip_braking++; + env->bc_get.total_braking++; + env->bc_get.braking++; + for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) { + env->calc_scoring.acc_last[i] = 0.0f; + } + } + + if ((++env->calc_scoring.index) > (env->gnss_config.acc_calc_time - 1)) + env->calc_scoring.index = 0; + + env->calc_scoring.data_erase = false; + } else if (!env->calc_scoring.data_erase) { + for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) { + env->calc_scoring.acc_last[i] = 0.0f; + } + env->calc_scoring.index = 0; + env->calc_scoring.data_erase = true; + } + env->calc_scoring.old_speed = new_speed; +} + +// fuel_lvl - current fuel level in 0.5L +// raw_fuel - fuel level from CAN in 0.5L +// ignition_on - ignition on or off (true/false) +// esp_speed - speed from ABS/ESP in 0.01km/h +// msg_cycle_time - message cycle time im milliseconds (for UAZ = 100) +// fuel_tank_capacity - fuel tank capacity in milliliters (for UAZ = 60000) + +#define INIT_CALC_PERIOD (2000u) //fuel calculation period in ms + +uint32_t +fuel_lvl_filtered(tCanMainAdditional *env, uint32_t fuel_lvl, uint32_t raw_fuel, bool ignition_on, uint32_t esp_speed, + uint32_t msg_cycle_time, uint32_t fuel_tank_capacity) { + uint32_t fuel_calc_period = 100; //fuel calculation period in ms + + if (!ignition_on) { + env->calc_fuel_lvl.ign_on = false; + env->calc_fuel_lvl.skip_fuel_frames = 0; + env->calc_fuel_lvl.pre_filtered_fuel = 0; + env->calc_fuel_lvl.mem_fuel_diff = 0; + return fuel_lvl; + } + + env->calc_fuel_lvl.pre_filtered_fuel += raw_fuel; + + if (!env->calc_fuel_lvl.ign_on && (++env->calc_fuel_lvl.skip_fuel_frames >= (INIT_CALC_PERIOD / msg_cycle_time))) { + fuel_lvl = env->calc_fuel_lvl.pre_filtered_fuel / env->calc_fuel_lvl.skip_fuel_frames; + env->calc_fuel_lvl.skip_fuel_frames = 0; + env->calc_fuel_lvl.pre_filtered_fuel = 0; + env->calc_fuel_lvl.mem_fuel_diff = 0; + env->calc_fuel_lvl.ign_on = ignition_on; + return fuel_lvl; + } + + if (msg_cycle_time > fuel_calc_period) { + fuel_calc_period = msg_cycle_time; + } + + if (env->calc_fuel_lvl.ign_on && (++env->calc_fuel_lvl.skip_fuel_frames >= (fuel_calc_period / msg_cycle_time))) { + uint32_t calc_lvl; + + calc_lvl = env->calc_fuel_lvl.pre_filtered_fuel / env->calc_fuel_lvl.skip_fuel_frames; + env->calc_fuel_lvl.skip_fuel_frames = 0; + env->calc_fuel_lvl.pre_filtered_fuel = 0; + + if (fuel_lvl == 0) { + fuel_lvl = calc_lvl; + env->calc_fuel_lvl.mem_fuel_diff = 0; + return fuel_lvl; + } + + if (esp_speed == 0) { + if ((calc_lvl + 9 * 2) <= fuel_lvl) + { +// env->calc_fuel_lvl.mem_fuel_diff -= ((fuel_calc_period * fuel_tank_capacity) +// / 6u); //Diff >= 9L E->F RunTime: 6s + + env->calc_fuel_lvl.mem_fuel_diff -= ((fuel_calc_period * fuel_tank_capacity) / + (10u * 60u)); //Diff >= 9L E->F RunTime: 10min + + } else if (calc_lvl < fuel_lvl) { + env->calc_fuel_lvl.mem_fuel_diff -= ((fuel_calc_period * fuel_tank_capacity) / + (240u * 60u)); //E->F RunTime: 240min + } else if (calc_lvl >= fuel_lvl + 9 * 2) { +// env->calc_fuel_lvl.mem_fuel_diff += ((fuel_calc_period * fuel_tank_capacity) / +// 6u); //Diff >= 9L E->F RunTime: 6s + env->calc_fuel_lvl.mem_fuel_diff += ((fuel_calc_period * fuel_tank_capacity) / + (2u * 60u)); //Diff >= 9L E->F RunTime: 2min + } else if (calc_lvl > fuel_lvl) { + env->calc_fuel_lvl.mem_fuel_diff += ((fuel_calc_period * fuel_tank_capacity) / + (240u * 60u)); // E->F RunTime: 240min + } else { + env->calc_fuel_lvl.mem_fuel_diff = 0; + } + } else { + if (calc_lvl < fuel_lvl) { + if (esp_speed <= (80u * 100u)) // Diff < 0, speed < 80km/h: E->F RunTime: 90min + { + env->calc_fuel_lvl.mem_fuel_diff -= ((fuel_calc_period * fuel_tank_capacity) / (90u * 60u)); + } else if (esp_speed < (240u * 100u)) // Diff < 0, 80km/h < speed < 240km/h: E->F RunTime: 432000s/speed + { + env->calc_fuel_lvl.mem_fuel_diff -= ((fuel_calc_period * fuel_tank_capacity) / + ((432000u * 100u) / esp_speed)); + } else { + env->calc_fuel_lvl.mem_fuel_diff -= ((fuel_calc_period * fuel_tank_capacity) / (30u * 60u)); + } + } else if (calc_lvl > (fuel_lvl + 3 * 2)) // 3L < Diff E->F RunTime: 300min + { + env->calc_fuel_lvl.mem_fuel_diff += ((fuel_calc_period * fuel_tank_capacity) / (300u * 60u)); + } else if (calc_lvl > (fuel_lvl + 1 * 2)) // 1L < Diff <= 3L E->F RunTime: 300min + { + env->calc_fuel_lvl.mem_fuel_diff += ((fuel_calc_period * fuel_tank_capacity) / (600u * 60u)); + } else if (calc_lvl > fuel_lvl) // 0L < Diff <= 1L E->F RunTime: 300min + { + env->calc_fuel_lvl.mem_fuel_diff += ((fuel_calc_period * fuel_tank_capacity) / (900u * 60u)); + } else { + env->calc_fuel_lvl.mem_fuel_diff = 0; + } + } + + if (env->calc_fuel_lvl.mem_fuel_diff >= 1000000) { + fuel_lvl += 2; + env->calc_fuel_lvl.mem_fuel_diff = 0; + } else if (env->calc_fuel_lvl.mem_fuel_diff >= 500000) { + fuel_lvl += 1; + env->calc_fuel_lvl.mem_fuel_diff = 0; + } else if (env->calc_fuel_lvl.mem_fuel_diff <= -1000000 && fuel_lvl > 1) { + fuel_lvl -= 2; + env->calc_fuel_lvl.mem_fuel_diff = 0; + } else if (env->calc_fuel_lvl.mem_fuel_diff <= -500000) { + fuel_lvl -= 1; + env->calc_fuel_lvl.mem_fuel_diff = 0; + } + } + + return fuel_lvl; +} + +bool ReceivedCan_Additional_func(void *arg, can_rx_message_type *canFrame) { + + tCanMainAdditional *env = arg; + + if (EXT_ENV_TELE.store.device->factoryMode) { + if (canFrame->standard_id == 0x88) { + if ((canFrame->dlc == 8) && memcmp(canFrame->data, canTestData, 8) == 0) { + env->canMainMute->isPassedTestCan = true; + } + } + } + + + if (canFrame->standard_id == 0x66) { + + for (uint8_t i = 0; i < canFrame->dlc; ++i) { + + osStatus_t status = osMessageQueuePut(env->serialPortCanComInt->queue, &canFrame->data[i], 0x0, 0U); + + if (status != osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь serialPortCanComInt") + } + } + + } + + env->isTimeSENSORS_DIG_BodyCanBusStatus = SystemGetMs(); + + +// if (env->timeCan < SystemGetMs()) { +// env->timeCan = SystemGetMs() + 1000; +// LoggerStrFormatInfo(LOGGER, LOG_SIGN, "CAN > [%02x:%02x] %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", +// (canFrame->standard_id >> 8) & 0xff, canFrame->standard_id & 0xff, +// canFrame->data[0], canFrame->data[1], canFrame->data[2], canFrame->data[3], + // canFrame->data[4], canFrame->data[5], canFrame->data[6], canFrame->data[7]) +// } + + // Поднят пин зажигания + bool isIgnition = GpioPinGet(EXT_ENV_TELE.ignition); + + // IPC_General + if (canFrame->standard_id == 0x3E8) { + + // внешняя температура + // Factor = 1.0 Offset = -40 Factor = 0.5 Offset = -40 + + if (isIgnition) { + + uint8_t CanRaw_ExternalTemperature = canFrame->data[1]; + if (CanRaw_ExternalTemperature != 0xFF) { + double ExternalTemperature = CanRaw_ExternalTemperature * 1.0 - 40; +/* + if (env->time3E8_1 < SystemGetMs()) { + env->time3E8_1 = SystemGetMs() + 1000; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Внешняя температура = %d", (uint8_t) ExternalTemperature) + } +*/ + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ExternalTemperature].value = (uint16_t) ( + (ExternalTemperature + 40) / 0.5); + + } + + } + + // уровень топлива + // Factor = 0.5 Offset = 0 Factor = 0.5 Offset = 0 + uint8_t CanRaw_FuelLevel = canFrame->data[3]; + if ((CanRaw_FuelLevel != 0) && (CanRaw_FuelLevel != 0xFF)) { + double FuelLevel = CanRaw_FuelLevel * 0.5; +/* + if (env->time3E8_2 < SystemGetMs()) { + env->time3E8_2 = SystemGetMs() + 1000; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Уровень топлива = %d", (uint8_t)FuelLevel) + } +*/ +// env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_FuelLevel].value = (uint8_t) (FuelLevel / +// 0.5); + + env->fuel_lvlFiltered = fuel_lvl_filtered(env, env->fuel_lvlFiltered, CanRaw_FuelLevel, isIgnition, env->ABS_VehicleSpeed, 100, 60000); + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_FuelLevel].value = env->fuel_lvlFiltered; + + + } + } + + // ECM_Status + if ((isIgnition) && (canFrame->standard_id == 0x560)) { + uint32_t mil = canFrame->data[4] & 3; + env->egtsTeledata->egtsSensorsDigArgs.sensorsDigState[SENSORS_DIG_ANS3].state = mil; + } + + // ECM_Dashboard + if ((isIgnition) && (canFrame->standard_id == 0x380)) { + + uint32_t mil = (canFrame->data[2] >> 3) & 1; + env->egtsTeledata->egtsSensorsDigArgs.sensorsDigState[SENSORS_DIG_ANS2].state = mil; + + + // температура двигателя + // Factor = 0.75 Offset = -48 Factor = 0.5 Offset = -40 + uint8_t CanRaw_EngineOXTemperature = canFrame->data[0]; + + double EngineOXTemperature = + CanRaw_EngineOXTemperature * 0.75 - 48; + + if (EngineOXTemperature < -39.5) { + + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_EngineOXTemperature].value = 0; + } else { + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_EngineOXTemperature].value = (uint16_t) ( + (EngineOXTemperature + 40) / 0.5); + } + + + uint16_t ECM_VolumetricFuelFlow = (canFrame->data[3] << 8) | canFrame->data[4]; + //там данные идут в литрах в час, что бы получить литры в час по их матрице надо помножить на 0,002146, нам нужны микролитры в 100 миллисекунд, для этого мы ECM_VolumetricFuelFlow*0.002146 умножаем на 1000000(перевод литры в микролитры) и делим на 36000 (перевод часа в сотки миллисекунд) + env->Counter_SENSORS_AN_TripMileage_MICRO_L += (uint32_t) (((float) ECM_VolumetricFuelFlow * 0.05961f) + 0.5f); + + // топливо делим на 100, + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_TripSpentFuel].value = + env->Counter_SENSORS_AN_TripMileage_MICRO_L / 100; + +/* + if (env->time380_1 < SystemGetMs()) { + env->time380_1 = SystemGetMs() + 1000; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Температура двигателя = %d", (uint8_t) EngineOXTemperature) + } +*/ + + // обороты двигателя + env->EngineSpeed = canFrame->data[1] * 40; +/* + if (env->time380_2 < SystemGetMs()) { + env->time380_2 = SystemGetMs() + 1000; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Обороты двигателя = %d", env->EngineSpeed) + } +*/ + } + + // ABS_Speed + if ((isIgnition) && (canFrame->standard_id == 0x27D)) { + + env->egtsTeledata->egtsSensorsDigArgs.sensorsDigState[SENSORS_DIG_ANS1].state = 1; + + env->ABS_VehicleSpeed = (canFrame->data[4] << 8) | canFrame->data[5]; + + if ((env->timeAbsSpeed) && (env->ABS_VehicleSpeed >= 10) && (SystemGetMs() > env->timeAbsSpeed) && + ((SystemGetMs() - env->timeAbsSpeed) < 1000)) { + env->Counter_SENSORS_AN_TripMileage_MM += (uint32_t) ( + (((float) env->ABS_VehicleSpeed * 10.0f * (float) (SystemGetMs() - env->timeAbsSpeed)) / + (3600.0f)) + + 0.5f); + } + + env->timeAbsSpeed = SystemGetMs(); + + // в итоге, пробег в миллиметрах мы приводим к стометровкам, т.е. делим на 100000 + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_TripMileage].value = + env->Counter_SENSORS_AN_TripMileage_MM / 100000; + + + if (env->timeAbsSpeedOnSecond < SystemGetMs()) { + env->timeAbsSpeedOnSecond = SystemGetMs() + 1000; + float realSpeed = (float) env->ABS_VehicleSpeed * 0.01f; + + calc_driver_scoring(env, realSpeed); + + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ANS5].value = (uint32_t) realSpeed; + + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_NumberAccelerations].value = env->state_get.trip_acceleration; + env->egtsTeledata->egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_NumberBraking].value = env->state_get.trip_braking; + + } + } + + return false; +} + +char *sendLogCanHex(tCanSerialPortFrameTp *env, uint8_t *data, size_t size); + +void ReceivedTP_Additional_func(void *arg, tCanTP_data *data) { +// tCanMainAdditional *env = arg; + +// LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Приняты данные: "); +// sendLogCanHex(&env->canSerialPortFrameTp, data->data, data->len); + +// osStatus_t status = osMessageQueuePut(env->queue, data, 0, 0U); + +// if (status != osOK) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь addCommandQueue") +// } +} + + +void CanMainAdditional_Init( + tCanMainAdditional *env, + tSerialPortFrameIO *CanIO, + tSerialPortCanComInt *serialPortCanComInt, + tCanMainMute *canMainMute, + SystemMutexCmsis txAccessQueue, + tDeviceTestsTable *testsTable, + tLoggerToSerialPort *slog, + volatile tRawAccel *rawAccel, + tEgtsTeledata *egtsTeledata, + tEgtsEbuState *ebuState, + SystemMutexCmsis accessEbu, + tCanMain *canMain, + void *envEgtsProcessing, + bool *isEnableTelematicaSendPoints +) { + env->CanIO = CanIO; + env->serialPortCanComInt = serialPortCanComInt; + env->txAccessQueue = txAccessQueue; + env->slog = slog; + env->rawAccel = rawAccel; + env->testsTable = testsTable; + env->egtsTeledata = egtsTeledata; + env->canMainMute = canMainMute; + env->canMain = canMain; + env->ebuState = ebuState; + env->accessEbu = accessEbu; + env->envEgtsProcessing = envEgtsProcessing; + env->isEnableTelematicaSendPoints = isEnableTelematicaSendPoints; + +// env->queue = osMessageQueueNew(CAN_US_QUEUE_SIZE, sizeof(tCanTP_data), NULL); + + env->egtsEbuUdsReady.step = STATUS_STEP_NONE; + env->egtsEbuUdsReady.isUdsBufReady = false; + env->egtsEbuUdsReady.ebuIndex = 0; + + + env->EngineSpeed = 0; + env->timeAbsSpeed = 0; + env->timeAbsSpeedOnSecond = 0; + env->Counter_SENSORS_AN_TripMileage_MM = 0; + env->Counter_SENSORS_AN_TripMileage_MICRO_L = 0; // расход топлива + + env->calc_scoring.index = 0; + env->calc_scoring.old_speed = 0; + env->calc_scoring.data_erase = true; + + env->calc_fuel_lvl.skip_fuel_frames = 0; + env->calc_fuel_lvl.pre_filtered_fuel = 0; + env->calc_fuel_lvl.mem_fuel_diff = 0; + env->calc_fuel_lvl.ign_on = false; + + env->fuel_lvlFiltered = 0; + env->ABS_VehicleSpeed = 0; + + env->gnss_config.acc_calc_time = egtsProcessing.deviceTeledataStorageData->telematica.EGTS_DRV_SCORE_ACC_CALC_TIME; + env->gnss_config.gnss_course_speed = egtsProcessing.deviceTeledataStorageData->telematica.EGTS_GNSS_COURSE_SPEED; + env->gnss_config.reference_speed = egtsProcessing.deviceTeledataStorageData->telematica.EGTS_DRV_SCORE_RFR_SPEED; + if (env->gnss_config.reference_speed == 0) + env->gnss_config.reference_speed = 50; + env->gnss_config.diff_speed_up = egtsProcessing.deviceTeledataStorageData->telematica.EGTS_DRV_SCORE_DIFF_SPD_UP; + env->gnss_config.diff_speed_down = egtsProcessing.deviceTeledataStorageData->telematica.EGTS_DRV_SCORE_DIFF_SPD_DOWN; + + memset(&env->state_get, 0, sizeof(env->state_get)); + memset(&env->bc_get, 0, sizeof(env->bc_get)); + + env->invalidKey = true; + env->invalidKeyAttempts = 3; + env->invalidKeyIsDelay = 0; + + env->isTimeSENSORS_DIG_BodyCanBusStatus = 0; + + env->filterIdCount = 0; + + CanSerialPortFrameTpInit( + &env->canSerialPortFrameTp, + + 1, + + env->txAccessQueue, + + ReceivedCan_Additional_func, + env, + + ReceivedTP_Additional_func, + env, + + env->CanIO, + (tCanTP_data *) &env->canTP_data, + sizeof(env->canTP_data.data), + slog, + + env->filterIdCount, + env->filterReqId, + env->filterRespId, + env->filterDirReq + + + ); + + InitThreadBlock(env->T_can_MainAdditional, "CanMainAdditional", osPriorityNormal); +} + +eEgtsEbu getEbuStateClearDTC(tCanMainAdditional *env) { + + if (osMutexAcquire(env->accessEbu, 2000) == osOK) { + + for (uint16_t i = 1; i < env->ebuState->count; ++i) { + + if (env->ebuState->ebuItemState[i].clearDTC == true) { + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Зафиксирован запрос очистки ошибок блоков") + + osMutexRelease(env->accessEbu); + return env->ebuState->ebuItemState[i].ebu; + + } + } + + osMutexRelease(env->accessEbu); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа getEbuStateClearDTC") + } + + return EBU_UNKNOWN; +} + +eEgtsEbu getEbuState(tCanMainAdditional *env, uint32_t timestamp) { + + if (osMutexAcquire(env->accessEbu, 2000) == osOK) { + + for (uint16_t i = 1; i < env->ebuState->count; ++i) { + + uint32_t deltaTime; + if (env->ebuState->ebuItemState[i].timestamp > timestamp) { + deltaTime = env->ebuState->ebuItemState[i].timestamp - timestamp; + } else { + deltaTime = timestamp - env->ebuState->ebuItemState[i].timestamp; + } + + if ((env->ebuState->ebuItemState[i].timestamp == 0) || + (env->ebuState->ebuItemState[i].timestamp < timestamp) || + (deltaTime > (86400 + 86400))) { + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Зафиксирован запрос данных блоков") + + osMutexRelease(env->accessEbu); + return env->ebuState->ebuItemState[i].ebu; + + } + } + + osMutexRelease(env->accessEbu); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа getEbuState") + } + + return EBU_UNKNOWN; +} + +uint8_t getEgtsNameEbuIndex(tCanMainAdditional *env, eEgtsEbu ebu, uint8_t indexStart) { + + for (uint8_t i = indexStart; i < EBU_COUNT_TABLE_ITEMS; ++i) { + if (egtsEbuName[i].ebu == ebu) { + return i; + } + } + + return 0; +} + + +void clearQueueAdditional(tCanMainAdditional *env) { + uint32_t count = osMessageQueueGetCount(env->canMain->queueAdditional); + if (count > 0) { + osMessageQueueReset(env->canMain->queueAdditional); + } +} + +//#define DEBUG_LOG_CAN_ADDITIONAL 1 + +void CanMainTaskAdditional(tCanMainAdditional *env) { + tCanTP_data data; + time_t timestamp = 0; + + uint32_t timeTeleOff = 0; + uint32_t timeDiagnostTwo = 0; + + bool isTimestamp = true; + + bool oneOn = true; + bool oneOff = true; + + uint8_t *out = (uint8_t *) env->egtsEbuUdsReady.buf; + uint16_t offset = 0; + + for (;;) { + + if (onOffTelematica(env->envEgtsProcessing, &oneOn, &oneOff, "Задача CAN (опрос блоков)")) + continue; + + + if (*env->isEnableTelematicaSendPoints == false) { + if (timeTeleOff < SystemGetMs()) { + timeTeleOff = SystemGetMs() + 10000; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание разрешения телематики") + } + SystemDelayMs(1000); + continue; + } + + RtcGet(env->canMainMute->gsm->Rtc, ×tamp); + + if (timestamp < 1718359909) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание получения временной метки") + + clearQueueAdditional(env); + + SystemDelayMs(40); + continue; + } else { + if (isTimestamp) { + isTimestamp = false; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Временная метка получена") + + clearQueueAdditional(env); + + } + } + + + if ((env->canMain->isTimeTESTER_REQUEST + 5000) > SystemGetMs()) { + + if (env->egtsEbuUdsReady.isUdsBufReady == false) { + env->egtsEbuUdsReady.ebuIndex = 0; + } + + env->egtsEbuUdsReady.step = STATUS_STEP_NONE; + + clearQueueAdditional(env); + + if (timeDiagnostTwo < SystemGetMs()) { + timeDiagnostTwo = SystemGetMs() + 10000; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Зафиксирован второй диагност") + } + + SystemDelayMs(40); + continue; + } + + // Если UDS опросов нет и готовых данных для отправки нет + if ((env->egtsEbuUdsReady.step == STATUS_STEP_NONE) && (env->egtsEbuUdsReady.isUdsBufReady == false)) { + + eEgtsEbu ebu = getEbuStateClearDTC(env); + + if (ebu != EBU_UNKNOWN) { + + uint8_t ebuIndex = 0; + + ebuIndex = getEgtsNameEbuIndex(env, ebu, 1); + + if (ebuIndex == 0) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s не найден тип блока", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + setUpdateEbuClearDTC(&egtsProcessing, env->ebuState, ebu, false); + env->egtsEbuUdsReady.ebuIndex = 0; + } else { + offset = 0; + + env->egtsEbuUdsReady.step = STATUS_STEP_DTC_CLEAR; + env->egtsEbuUdsReady.attempts = 2; + env->egtsEbuUdsReady.counterDID = 0; + env->egtsEbuUdsReady.ebuIndex = ebuIndex; + env->egtsEbuUdsReady.isUdsBufReady = false; + env->egtsEbuUdsReady.bufLen = 0; + } + + + } else { + + ebu = getEbuState(env, timestamp); + + if (ebu != EBU_UNKNOWN) { + + uint8_t ebuIndex = 0; + + if ((env->egtsEbuUdsReady.ebuIndex + 1) < EBU_COUNT_TABLE_ITEMS) { + ebuIndex = getEgtsNameEbuIndex(env, ebu, env->egtsEbuUdsReady.ebuIndex + 1); + } + + if (ebuIndex == 0) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s не найден тип блока", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + setUpdateEbu(&egtsProcessing, env->ebuState, ebu, timestamp + 86400); + env->egtsEbuUdsReady.ebuIndex = 0; + } else { + offset = 0; + + env->egtsEbuUdsReady.step = STATUS_STEP_DIAGNOSTIC; + env->egtsEbuUdsReady.attempts = 2; + env->egtsEbuUdsReady.counterDID = 0; + env->egtsEbuUdsReady.ebuIndex = ebuIndex; + env->egtsEbuUdsReady.isUdsBufReady = false; + env->egtsEbuUdsReady.bufLen = 0; + } + } else { + SystemDelayMs(1000); + continue; + } + + } + + } + + //начало ------------------------------------Отправка UDS_ClearDiagnosticInformation------------------------------ + if (env->egtsEbuUdsReady.step == STATUS_STEP_DTC_CLEAR) { + + if (env->egtsEbuUdsReady.attempts > 0) { + --env->egtsEbuUdsReady.attempts; + + tClearDiagnosticInformationRequest clearDiagnosticInformationRequest; + + clearDiagnosticInformationRequest.ServiceId = UDS_ClearDiagnosticInformation; + clearDiagnosticInformationRequest.groupOfDTCHighByte = 0xFF; + clearDiagnosticInformationRequest.groupOfDTCMiddleByte = 0xFF; + clearDiagnosticInformationRequest.groupOfDTCLowByte = 0xFF; + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, + (uint8_t *) &clearDiagnosticInformationRequest, + sizeof(tClearDiagnosticInformationRequest), + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ecu_req, + WAIT_FRAME_WRITE); + } else { + + if (env->egtsEbuUdsReady.attempts == 0) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s не найден", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + env->egtsEbuUdsReady.step = STATUS_STEP_NONE; + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s найден", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + env->egtsEbuUdsReady.step = STATUS_STEP_NONE; + } + + setUpdateEbuClearDTC(&egtsProcessing, env->ebuState, egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebu, + false); + env->egtsEbuUdsReady.ebuIndex = 0; + + continue; + + } + + } + //конец ------------------------------------Отправка UDS_ClearDiagnosticInformation------------------------------ + + //начало ------------------------------------Отправка UDS_DiagnosticSessionControl------------------------------ + if (env->egtsEbuUdsReady.step == STATUS_STEP_DIAGNOSTIC) { + + if (env->egtsEbuUdsReady.attempts > 0) { + --env->egtsEbuUdsReady.attempts; + + tDiagnosticSessionControlRequest diagnosticSessionControlRequest; + + diagnosticSessionControlRequest.ServiceId = UDS_DiagnosticSessionControl; + diagnosticSessionControlRequest.diagnosticSessionType = 1; // Default session + +#ifdef DEBUG_LOG_CAN_ADDITIONAL + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Отправка запроса открытия сессии", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) +#endif + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, + (uint8_t *) &diagnosticSessionControlRequest, + sizeof(tDiagnosticSessionControlRequest), + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ecu_req, + WAIT_FRAME_WRITE); + } else { + + if (env->egtsEbuUdsReady.attempts == 0) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s не найден", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + + env->egtsEbuUdsReady.step = STATUS_STEP_NONE; + continue; + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s найден", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + env->egtsEbuUdsReady.attempts = 2; + env->egtsEbuUdsReady.step = STATUS_STEP_READ_TEST_IDENTIFIER; + } + + + } + + } + //конец ------------------------------------Отправка UDS_DiagnosticSessionControl------------------------------ + + //начало ------------------------------------Отправка UDS_ReadDataByIdentifier TEST-------------------------- + if (env->egtsEbuUdsReady.step == STATUS_STEP_READ_TEST_IDENTIFIER) { + + if (egtsEbuName[env->egtsEbuUdsReady.ebuIndex].test_did == 0) { + env->egtsEbuUdsReady.step = STATUS_STEP_READ_DTC; + } else { + + if (env->egtsEbuUdsReady.attempts > 0) { + + --env->egtsEbuUdsReady.attempts; + + tReadDataByIdentifierRequest readDataByIdentifierRequest; + + readDataByIdentifierRequest.ServiceId = UDS_ReadDataByIdentifier; + readDataByIdentifierRequest.dataIdentifierByte1 = + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].test_did >> 8; + readDataByIdentifierRequest.dataIdentifierByte2 = egtsEbuName[env->egtsEbuUdsReady.ebuIndex].test_did; + +#ifdef DEBUG_LOG_CAN_ADDITIONAL + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Блок: %s Отправка запроса чтения ТЕСТОВОГО идентификатора: 0x%x", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName, + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].test_did) +#endif + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, + (uint8_t *) &readDataByIdentifierRequest, + sizeof(tReadDataByIdentifierRequest), + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ecu_req, + WAIT_FRAME_WRITE); + + } else { + + if (env->egtsEbuUdsReady.attempts == 0) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Тестовый идентификатор: 0x%x не получен", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName, + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].test_did) + + env->egtsEbuUdsReady.step = STATUS_STEP_NONE; + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Тестовый идентификатор получен", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + + env->egtsEbuUdsReady.attempts = 2; + env->egtsEbuUdsReady.step = STATUS_STEP_READ_DTC; + } + + } + + } + + } + //конец ------------------------------------Отправка UDS_ReadDataByIdentifier TEST----------------------------- + + //начало ------------------------------------Отправка UDS_ReadDTCInformation---------------------------------- + if (env->egtsEbuUdsReady.step == STATUS_STEP_READ_DTC) { + + if (env->egtsEbuUdsReady.attempts > 0) { + --env->egtsEbuUdsReady.attempts; + + tReadDTCInformationRequest readDTCInformationRequest; + + readDTCInformationRequest.ServiceId = UDS_ReadDTCInformation; + readDTCInformationRequest.reportDTCByStatusMask = 2; + readDTCInformationRequest.DTCStatusMask = 0x0D; + +#ifdef DEBUG_LOG_CAN_ADDITIONAL + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Отправка запроса состояния ошибок", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) +#endif + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, + (uint8_t *) &readDTCInformationRequest, + sizeof(tReadDTCInformationRequest), + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ecu_req, + WAIT_FRAME_WRITE); + + } else { + + if (env->egtsEbuUdsReady.attempts == 0) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Информация о состоянии ошибок не получена", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Получена информация о состоянии ошибок", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + } + + env->egtsEbuUdsReady.attempts = 2; + env->egtsEbuUdsReady.step = STATUS_STEP_READ_IDENTIFIER; + + } + + } + //конец ------------------------------------Отправка UDS_ReadDTCInformation---------------------------------- + + //начало ------------------------------------Отправка UDS_ReadDataByIdentifier---------------------------------- + if (env->egtsEbuUdsReady.step == STATUS_STEP_READ_IDENTIFIER) { + + if (env->egtsEbuUdsReady.attempts > 0) { + + if ((env->egtsEbuUdsReady.counterDID >= EBU_COUNT_DID_LIST_ITEMS) || + (egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID] == 0)) { + + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Все запросы идентификаторов отправлены", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + + env->egtsEbuUdsReady.step = STATUS_STEP_NONE; + env->egtsEbuUdsReady.bufLen = offset; + env->egtsEbuUdsReady.isUdsBufReady = true; + + } else { + --env->egtsEbuUdsReady.attempts; + + tReadDataByIdentifierRequest readDataByIdentifierRequest; + + readDataByIdentifierRequest.ServiceId = UDS_ReadDataByIdentifier; + readDataByIdentifierRequest.dataIdentifierByte1 = + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID] + >> 8; + readDataByIdentifierRequest.dataIdentifierByte2 = egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID]; + +#ifdef DEBUG_LOG_CAN_ADDITIONAL + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Отправка запроса чтения идентификатора: 0x%x", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName, + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID]) +#endif + + + CanSerialPortFrameTpTransmit(&env->canSerialPortFrameTp, + (uint8_t *) &readDataByIdentifierRequest, + sizeof(tReadDataByIdentifierRequest), + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ecu_req, + WAIT_FRAME_WRITE); + } + + + } else { + + if (env->egtsEbuUdsReady.attempts == 0) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Идентификатор: 0x%x не получен", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName, + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID]) + + + ADD_TO_DATA_SHORT( + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID]); + ADD_TO_DATA_CHAR_SHORT(0x0000); + + } else { +#ifdef DEBUG_LOG_CAN_ADDITIONAL + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Идентификатор: 0x%x получен", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName, + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID]) +#endif + } + + if ((env->egtsEbuUdsReady.counterDID >= EBU_COUNT_DID_LIST_ITEMS) || + (egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID] == 0)) { + + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Все запросы идентификаторов отправлены", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName) + + env->egtsEbuUdsReady.step = STATUS_STEP_NONE; + env->egtsEbuUdsReady.bufLen = offset; + env->egtsEbuUdsReady.isUdsBufReady = true; + } else { + env->egtsEbuUdsReady.attempts = 2; + ++env->egtsEbuUdsReady.counterDID; + continue; + } + + } + + } + //конец ------------------------------------Отправка UDS_ReadDataByIdentifier---------------------------------- +#ifdef DEBUG_LOG_CAN_ADDITIONAL + if (env->egtsEbuUdsReady.step != STATUS_STEP_NONE) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Этап: 0x%x, Попыток осталось: 0x%x", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName, + env->egtsEbuUdsReady.step, + env->egtsEbuUdsReady.attempts) + } +#endif + + +// SystemDelayMs(1000); + + for (uint8_t i = 0; i < 2; ++i) { + + osStatus_t status = osMessageQueueGet(env->canMain->queueAdditional, &data, 0, 1200); + + if (status == osOK) { + + if (env->egtsEbuUdsReady.step == STATUS_STEP_NONE) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Неверный номер этапа: 0x%x Нет запроса !!!!", + env->egtsEbuUdsReady.step) + break; + } + + if (data.adrCan == egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ecu_resp) { + + // начало --------------------------- Ошибка ---------------------------------------------------------- + // начало --------------------------- Ошибка ---------------------------------------------------------- + // начало --------------------------- Ошибка ---------------------------------------------------------- + + // Отрицательный ответ + if (data.data[0] == 0x7F) { + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен негативный ответ от сервиса: 0x%x ,код ошибки: 0x%x", + data.data[1], data.data[2]) + break; + } + + + + // конец ---------------------------- Ошибка ---------------------------------------------- + // конец ---------------------------- Ошибка ---------------------------------------------- + // конец ---------------------------- Ошибка ---------------------------------------------- + + + // начало --------------------------- Запрос очистки ошибок ---------------------------------------------- + // начало --------------------------- Запрос очистки ошибок --------------------------------------------- + // начало --------------------------- Запрос очистки ошибок --------------------------------------------- + + // Положительный ответ + if (data.data[0] == (UDS_ClearDiagnosticInformation | 0b1000000)) { + + if (env->egtsEbuUdsReady.step == STATUS_STEP_DTC_CLEAR) { + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен положительный ответ от сервиса: 0x%x", + data.data[0] & (~(0b1000000))) + + env->egtsEbuUdsReady.attempts = -1; + break; + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Неверный номер этапа, текущий: 0x%x получен: 0x%x", + env->egtsEbuUdsReady.step, STATUS_STEP_DTC_CLEAR) + } + } + + + // конец ---------------------------- Запрос очистки ошибок ---------------------------------------------- + // конец ---------------------------- Запрос очистки ошибок --------------------------------------------- + // конец ---------------------------- Запрос очистки ошибок --------------------------------------------- + + // начало --------------------------- Запрос открытия сессии ---------------------------------------------- + // начало --------------------------- Запрос открытия сессии --------------------------------------------- + // начало --------------------------- Запрос открытия сессии --------------------------------------------- + + // Положительный ответ + if (data.data[0] == (UDS_DiagnosticSessionControl | 0b1000000)) { + + if (env->egtsEbuUdsReady.step == STATUS_STEP_DIAGNOSTIC) { + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен положительный ответ от сервиса: 0x%x ,код сессии: 0x%x", + data.data[0] & (~(0b1000000)), data.data[1]) + + env->egtsEbuUdsReady.attempts = -1; + break; + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Неверный номер этапа, текущий: 0x%x получен: 0x%x", + env->egtsEbuUdsReady.step, STATUS_STEP_DIAGNOSTIC) + } + } + + + // конец ---------------------------- Запрос открытия сессии ---------------------------------------------- + // конец ---------------------------- Запрос открытия сессии --------------------------------------------- + // конец ---------------------------- Запрос открытия сессии --------------------------------------------- + + // начало --------------------------- Запрос состояния ошибок ---------------------------------------------- + // начало --------------------------- Запрос состояния ошибок --------------------------------------------- + // начало --------------------------- Запрос состояния ошибок --------------------------------------------- + + // Положительный ответ + if (data.data[0] == (UDS_ReadDTCInformation | 0b1000000)) { + + if (env->egtsEbuUdsReady.step == STATUS_STEP_READ_DTC) { + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен положительный ответ от сервиса: 0x%x ,код маски: 0x%x, код доступной маски: 0x%x", + data.data[0] & (~(0b1000000)), data.data[1], data.data[2]) + + ADD_TO_DATA_SHORT(0x1902) // ReadDTCInformation + reportDTCByStatusMask + ADD_TO_DATA_SHORT(0x0004) // Размер общих данных вместе с ошибками + ADD_TO_DATA_BYTE(0x00) // DTCStatusAvailabilityMask + ADD_TO_DATA_BYTE(0x00) // Всегда 0 + ADD_TO_DATA_BYTE(0x00) // Всегда 0 + ADD_TO_DATA_BYTE(0xE0) // E0 — нет ошибок. 00 - ошибки + + if (data.len > 3) { + //ADD_TO_DATA(data.data[3], data.len - 3) + ADD_TO_DATA(env->canMain->canTP_Ext_data.data[3], data.len - 3) + } + + uint8_t *DTCStatusAvailabilityMask = (uint8_t *) &out[4]; + *DTCStatusAvailabilityMask = data.data[2]; + + // Если есть ошибки + if (offset > 8) { + uint16_t *len = (uint16_t *) &out[2]; + uint8_t *err = (uint8_t *) &out[7]; + *len = offset - 4; + *err = 0; + asm("nop"); + } + + env->egtsEbuUdsReady.attempts = -1; + break; + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Неверный номер этапа, текущий: 0x%x получен: 0x%x", + env->egtsEbuUdsReady.step, STATUS_STEP_DIAGNOSTIC) + } + } + + + // конец ---------------------------- Запрос состояния ошибок ---------------------------------------------- + // конец ---------------------------- Запрос состояния ошибок --------------------------------------------- + // конец ---------------------------- Запрос состояния ошибок --------------------------------------------- + + // начало --------------------------- Запрос идентификаторов ---------------------------------------------- + // начало --------------------------- Запрос идентификаторов --------------------------------------------- + // начало --------------------------- Запрос идентификаторов --------------------------------------------- + + // Положительный ответ + if (data.data[0] == (UDS_ReadDataByIdentifier | 0b1000000)) { + +#ifdef DEBUG_LOG_CAN_ADDITIONAL + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен положительный ответ от сервиса: 0x%x ,код идентификатора: 0x%x", + data.data[0] & (~(0b1000000)), (data.data[1] << 8) | data.data[2]) +#endif + + + if (env->egtsEbuUdsReady.step == STATUS_STEP_READ_TEST_IDENTIFIER) { + + env->egtsEbuUdsReady.attempts = -1; + break; + } else { + + if (env->egtsEbuUdsReady.step == STATUS_STEP_READ_IDENTIFIER) { + + if (data.len > 3) { + ADD_TO_DATA_SHORT( + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].did_list[env->egtsEbuUdsReady.counterDID]); + ADD_TO_DATA_CHAR_SHORT(data.len - 3); + ADD_TO_DATA(data.data[3], data.len - 3) + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Не верная длина данных: 0x%x", data.len) + } + + env->egtsEbuUdsReady.attempts = -1; + break; + } else { + + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Неверный номер этапа, текущий: 0x%x получен: 0x%x или 0x%x", + env->egtsEbuUdsReady.step, STATUS_STEP_DIAGNOSTIC, + STATUS_STEP_READ_IDENTIFIER) + } + + } + + } + + + // конец ---------------------------- Запрос идентификаторов ---------------------------------------------- + // конец ---------------------------- Запрос идентификаторов --------------------------------------------- + // конец ---------------------------- Запрос идентификаторов --------------------------------------------- + + + } else { + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Ответ не от того устройства. Адрес ожидаемый: 0x%x ,адрес принятый: 0x%x", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ecu_resp, data.adrCan) + break; + } + + } else { + if (env->egtsEbuUdsReady.step != STATUS_STEP_NONE) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Блок: %s Таймаут получения ответа на шаге: 0x%x", + egtsEbuName[env->egtsEbuUdsReady.ebuIndex].ebuName, env->egtsEbuUdsReady.step) + + break; + } + } + + } // for + } +} + + +void CanMainAdditional_Start(tCanMainAdditional *env) { + CanSerialPortFrameTp_Start(&env->canSerialPortFrameTp, 1); + ThreadBlock_Start(env->T_can_MainAdditional, env, CanMainTaskAdditional); +} diff --git a/CanMute.c b/CanMute.c new file mode 100644 index 0000000..2b49720 --- /dev/null +++ b/CanMute.c @@ -0,0 +1,224 @@ +// +// Created by cfif on 15.10.2024. +// +#include +#include "CanMain.h" +#include "SystemDelayInterface.h" +#include "ext_telematica.h" +#include "string.h" +#include "Rtc.h" +#include "EgtsTimestamp.h" +#include "math.h" + +#define LOG_SIGN "UDS_MUTE" +#define LOGGER &env->slog->logger + +extern eDeviceTestingCode deviceTestingCodeCan; + +void CanMainMute_Init( + tCanMainMute *env, + tSerialPortFrameIO *CanIO, + SystemMutexCmsis txAccessQueue, + tGsmWithGnss *gsm, + tLoggerToSerialPort *slog +) { + env->CanIO = CanIO; + env->txAccessQueue = txAccessQueue; + env->gsm = gsm; + env->slog = slog; + + memset(env->GNSS_NMEA1, 0, sizeof(env->GNSS_NMEA1)); + memset(env->GNSS_NMEA2, 0, sizeof(env->GNSS_NMEA2)); + memset(env->GNSS_NMEA3, 0, sizeof(env->GNSS_NMEA3)); + memset(env->GNSS_NMEA4, 0, sizeof(env->GNSS_NMEA4)); + memset(env->GNSS_NMEA5, 0, sizeof(env->GNSS_NMEA5)); + memset(env->GNSS_NMEA6, 0, sizeof(env->GNSS_NMEA6)); + + InitThreadBlock(env->T_can_MainMute, "CanMainMute", osPriorityNormal); + InitThreadBlock(env->T_can_MainNav, "CanMainNav", osPriorityNormal); +} + +static double nmeaLocationToDeg(double dec) { + double _dec = dec; + int deg = (int) (_dec / 100); + int min = (int) (_dec) - (deg * 100); + + double sec = (double) (_dec - min - 100 * deg) * 60.0; + + return deg + min / 60.0 + sec / 3600.0; +} + +void CanMainTaskNav(tCanMainMute *env) { + uint16_t sent = 0; + uint8_t countCycle = 0; + uint8_t lcCounter = 0; + + for (;;) { + + if (!EXT_ENV_TELE.store.device->factoryMode) { + if ((EXT_ENV_TELE.DataToCan != NULL) && (EXT_ENV_TELE.DataToCan->nav_data_ToCan == true)) { + + deviceTestingCodeCan = DEVICE_TESTING_CODE_NOT_ACTIVE; + + //начало-----------------------------------НАВИГАЦИЯ---------------------------------------------------- + tGNSS_NMEA1 *GNSS_NMEA1 = (tGNSS_NMEA1 *) env->GNSS_NMEA1; + tGNSS_NMEA2 *GNSS_NMEA2 = (tGNSS_NMEA2 *) env->GNSS_NMEA2; + tGNSS_NMEA3 *GNSS_NMEA3 = (tGNSS_NMEA3 *) env->GNSS_NMEA3; + + time_t timestamp = 0; + RtcGet(env->gsm->Rtc, ×tamp); + tNmeaRmc nmeaRmc; + Gnss_GetFullNavData(env->gsm, &nmeaRmc); + int32_t alt = GnssGgaGetAlt(env->gsm); + uint8_t countSats = GnssGgaGetSat(env->gsm); + + GNSS_NMEA1->NTM = Egts_EpochTimestampToEgtsTime(timestamp); + double lat = (fabs(nmeaLocationToDeg(nmeaRmc.location.latitude)) / 90) * 0xFFFFFFFF; + GNSS_NMEA1->LAT = (uint32_t) lat; + + double lon = (fabs(nmeaLocationToDeg(nmeaRmc.location.longitude)) / 90) * 0xFFFFFFFF; + GNSS_NMEA2->LONG = (uint32_t) lon; + GNSS_NMEA2->FLG.VLD = (nmeaRmc.status == 'A') ? 1 : 0; + GNSS_NMEA2->FLG.LAHS = (nmeaRmc.location.nsIndicator == 'S') ? 1 : 0; + GNSS_NMEA2->FLG.LOHS = (nmeaRmc.location.ewIndicator == 'W') ? 1 : 0; + GNSS_NMEA2->FLG.ALTH = 1; + GNSS_NMEA2->FLG.SATH = 1; + + uint16_t speed = (uint16_t) (nmeaRmc.knotVelocity * 1.82 * 10); + GNSS_NMEA2->SPD.SPD = speed & 0b0011111111111111; + + if (alt >= 0) { + GNSS_NMEA2->SPD.ALTS = 0; + } else { + GNSS_NMEA2->SPD.ALTS = 1; + } + + uint16_t dir = (uint16_t) nmeaRmc.headingAngle; + GNSS_NMEA2->SPD.DIRH = dir >> 8; + + GNSS_NMEA2->DIR = dir; + + GNSS_NMEA3->ALT = abs(alt); + GNSS_NMEA3->SAT = countSats; + + + if (osMutexAcquire(env->txAccessQueue, 3000) == osOK) { + + CanSerialPortFrameSetId(env->CanIO->env, 0x5A4); + sent = env->CanIO->transmit(env->CanIO->env, env->GNSS_NMEA1, sizeof(env->GNSS_NMEA1), + WAIT_FRAME_WRITE); + + CanSerialPortFrameSetId(env->CanIO->env, 0x5A6); + sent = env->CanIO->transmit(env->CanIO->env, env->GNSS_NMEA2, sizeof(env->GNSS_NMEA2), + WAIT_FRAME_WRITE); + + CanSerialPortFrameSetId(env->CanIO->env, 0x5A8); + sent = env->CanIO->transmit(env->CanIO->env, env->GNSS_NMEA3, sizeof(env->GNSS_NMEA3), + WAIT_FRAME_WRITE); + + CanSerialPortFrameSetId(env->CanIO->env, 0x5AA); + sent = env->CanIO->transmit(env->CanIO->env, env->GNSS_NMEA4, sizeof(env->GNSS_NMEA4), + WAIT_FRAME_WRITE); + + CanSerialPortFrameSetId(env->CanIO->env, 0x5AC); + sent = env->CanIO->transmit(env->CanIO->env, env->GNSS_NMEA5, sizeof(env->GNSS_NMEA5), + WAIT_FRAME_WRITE); + + CanSerialPortFrameSetId(env->CanIO->env, 0x5AE); + sent = env->CanIO->transmit(env->CanIO->env, env->GNSS_NMEA6, sizeof(env->GNSS_NMEA6), + WAIT_FRAME_WRITE); + + osMutexRelease(env->txAccessQueue); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа CanMainTaskNav (1)") + } + + //конец------------------------------------НАВИГАЦИЯ---------------------------------------------------- + + SystemDelayMs(50); + ++countCycle; + } + } + + } + +} + +void CanMainTaskMute(tCanMainMute *env) { + uint16_t sent = 0; + uint8_t countCycle = 0; + uint8_t lcCounter = 0; + for (;;) { + if (!EXT_ENV_TELE.store.device->factoryMode) { +// if( (EXT_ENV_TELE.DataToCan != NULL) && (EXT_ENV_TELE.DataToCan->gnss_general_ToCan == true) ) { + //начало-----------------------------------ТИШИНА------------------------------------------------------- + if (osMutexAcquire(env->txAccessQueue, 3000) == osOK) { + + CanSerialPortFrameSetId(env->CanIO->env, 0x640); + + if (lcCounter >= 15) { + lcCounter = 0; + } else { + ++lcCounter; + } + EXT_ENV_TELE.GNSS_General->GNSS_LC = lcCounter; + + tGNSS_General GNSS_General; + memcpy(&GNSS_General, EXT_ENV_TELE.GNSS_General, sizeof(tGNSS_General)); + + if (EXT_ENV_TELE.GNSS_General->GNSS_Call_Auto == CAN_GNSS_ROLLOVER_DETECT) { + GNSS_General.GNSS_Call_By_button = CAN_GNSS_CALL; + } + +// if (EXT_ENV_TELE.GNSS_General->GNSS_Call_Test == CAN_GNSS_CALL_TEST_ACTIVE) { +// GNSS_General.GNSS_Call_By_button = CAN_GNSS_CALL; +// } + +// GNSS_General.GNSS_Call_Test = 0; + GNSS_General.GNSS_Call_Auto = 0; + GNSS_General.Reserved1 = 0; + GNSS_General.Reserved2 = 0; + + sent = env->CanIO->transmit(env->CanIO->env, (uint8_t *) &GNSS_General, 2, + WAIT_FRAME_WRITE); + + osMutexRelease(env->txAccessQueue); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа CanMainTaskMute (1)") + } + //конец-----------------------------------ТИШИНА------------------------------------------------------- + + SystemDelayMs(100); + ++countCycle; +// } + } else { + env->isPassedTestCan = false; + + if (osMutexAcquire(env->txAccessQueue, 1000) == osOK) { + + CanSerialPortFrameSetId(env->CanIO->env, 0x88); + sent = env->CanIO->transmit(env->CanIO->env, (uint8_t *) canTestData, 8, + WAIT_FRAME_WRITE); + + osMutexRelease(env->txAccessQueue); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа CanMainTaskMute (2)") + } + + SystemDelayMs(100); + + if (env->isPassedTestCan) { + deviceTestingCodeCan = DEVICE_TESTING_CODE_PASSED; + } else { + deviceTestingCodeCan = DEVICE_TESTING_CODE_ERROR; + } + + } + } +} + + +void CanMainMute_Start(tCanMainMute *env) { + ThreadBlock_Start(env->T_can_MainMute, env, CanMainTaskMute); + ThreadBlock_Start(env->T_can_MainNav, env, CanMainTaskNav); +} \ No newline at end of file diff --git a/CanTestCallBack.c b/CanTestCallBack.c new file mode 100644 index 0000000..e3e1c01 --- /dev/null +++ b/CanTestCallBack.c @@ -0,0 +1,49 @@ +// +// Created by cfif on 18.10.2024. +// +#include "CanMain.h" +#include "SystemDelayInterface.h" +#include "ext_telematica.h" +#include "string.h" + +#define LOG_SIGN "UDS_TEST" +#define LOGGER &env->slog->logger + +void CanMainTest_Init( + tCanMainTest *env, + tSerialPortFrameIO *CanIO, + + tLoggerToSerialPort *slog +) { + env->CanIO = CanIO; + env->slog = slog; + + InitThreadBlock(env->T_can_MainTest, "CanMainTest", osPriorityNormal); +} + + +void CanMainTaskTest(tCanMainTest *env) { + can_rx_message_type canFrame; + uint16_t sent; + + for (;;) { + uint16_t recv = env->CanIO->receive0(env->CanIO->env, (uint8_t *) &canFrame, 1, 1000); + + if (recv > 0) { + if (canFrame.standard_id == 0x88) { + if ((canFrame.dlc == 8) && memcmp(canFrame.data, canTestData, 8) == 0) { + CanSerialPortFrameSetId(env->CanIO->env, 0x88); + sent = env->CanIO->transmit(env->CanIO->env, (uint8_t *) canTestData, 8, WAIT_FRAME_WRITE); + } + } + } + + } + +} + + +void CanMainTest_Start(tCanMainTest *env) { + ThreadBlock_Start(env->T_can_MainTest, env, CanMainTaskTest); +} + diff --git a/ClearDiagnosticInformation_14.h b/ClearDiagnosticInformation_14.h new file mode 100644 index 0000000..78f11d1 --- /dev/null +++ b/ClearDiagnosticInformation_14.h @@ -0,0 +1,18 @@ +// +// Created by cfif on 11.02.2025. +// + +#ifndef SMART_COMPONENTS_TELEMATICA_V2_CLEARDIAGNOSTICINFORMATION_14_H +#define SMART_COMPONENTS_TELEMATICA_V2_CLEARDIAGNOSTICINFORMATION_14_H + +#include "stdint.h" + +// Для сброса ошибок DTC +typedef struct __attribute__ ((packed)) { + uint8_t ServiceId; + uint8_t groupOfDTCHighByte; + uint8_t groupOfDTCMiddleByte; + uint8_t groupOfDTCLowByte; +} tClearDiagnosticInformationRequest; + +#endif //SMART_COMPONENTS_TELEMATICA_V2_CLEARDIAGNOSTICINFORMATION_14_H diff --git a/DiagnosticSessionControl_10.h b/DiagnosticSessionControl_10.h new file mode 100644 index 0000000..c1cd637 --- /dev/null +++ b/DiagnosticSessionControl_10.h @@ -0,0 +1,25 @@ +// +// Created by cfif on 06.08.2024. +// + +#ifndef SMART_COMPONENTS_UPDATE_DIAGNOSTICSESSIONCONTROL_10_H +#define SMART_COMPONENTS_UPDATE_DIAGNOSTICSESSIONCONTROL_10_H + +#include "stdint.h" + +// Для готовности загрузки модема +typedef struct __attribute__ ((packed)) { + uint8_t ServiceId; + uint8_t diagnosticSessionType; + uint8_t sessionParameterRecord[4]; + +} tDiagnosticSessionsType; + + +// Для запроса сессии +typedef struct __attribute__ ((packed)) { + uint8_t ServiceId; + uint8_t diagnosticSessionType; +} tDiagnosticSessionControlRequest; + +#endif //SMART_COMPONENTS_UPDATE_DIAGNOSTICSESSIONCONTROL_10_H diff --git a/ReadDTCInformation_19.c b/ReadDTCInformation_19.c new file mode 100644 index 0000000..f1828df --- /dev/null +++ b/ReadDTCInformation_19.c @@ -0,0 +1,104 @@ +// +// Created by cfif on 08.08.2024. +// +#include "ReadDTCInformation_19.h" + + +const tUDS_DTC_Error UDS_DTC_Error[] = { + // Board voltage error + // 16 - Circuit voltage below threshold (low voltage); + {0x90, 0x11, 0x16}, + // 17 - Circuit voltage above threshold (high voltage); + {0x90, 0x11, 0x17}, + // 13 - Circuit open. + {0x90, 0x11, 0x13}, + + // GSM/GPRS and UMTS module error + // UDS_TEST_AUDIO_FILE 46 -Audiofiles error (missing or invalide). + {0x90, 0x21, 0x46}, + // UDS_TEST_GSM_AUDIO_CODEC 47 - Audiocodec error. + {0x90, 0x21, 0x47}, + // UDS_TEST_MODEM_SOFT_REV 48 - Invalid software version of GSM module. + {0x90, 0x21, 0x48}, + // 81 - Invalid serial data received (wrong frame format or data); + {0x90, 0x21, 0x81}, + // UDS_TEST_GSM 87 - Missing message (no signals from module). + {0x90, 0x21, 0x87}, + // UDS_TEST_CERT_REV 57 - Certificates error (missing or invalidate) + {0x90, 0x21, 0x57}, + + // GPS/GLONASS module error + // 81 - Invalid serial data received (wrong frame format or data); + {0x90, 0x31, 0x81}, + // 87 - Missing message (no signals from module). + {0x90, 0x31, 0x87}, + + // Antenna error + // UDS_TEST_GNSS_ANT 01 - Antenna not connected + {0x90, 0x32, 0x01}, + + // Internal Battery error + // UDS_TEST_BAT_VOLTAGE 91 - Parametric (battery charge too low); + {0x90, 0x12, 0x91}, + // UDS_TEST_BAT_CONNECT 92 - Performance or incorrect operation (battery is old); + {0x90, 0x12, 0x92}, + // UDS_TEST_BAT_CHARGE 97 - Component obstructed or blocked (battery unchargeable) + {0x90, 0x12, 0x97}, + // 98 - Component over temperature (battery temperature too high); + {0x90, 0x12, 0x98}, + + // Voltage Supplier error + // 01 - General Electrical Failure (supplier is defective). + {0x90, 0x13, 0x01}, + + // Microphone error + // 09 - Component Failures. + {0x90, 0x41, 0x09}, + // UDS_TEST_MICROPHONE_CONNECT 13 - Break + {0x90, 0x41, 0x13}, + + // Load Speaker error + // 09 - Component Failures. + {0x90, 0x42, 0x09}, + // UDS_TEST_SPEAKER_CONNECT 13 - Break + {0x90, 0x42, 0x13}, + + // Vehicle Identification Number error + // UDS_TEST_VIN 02 - General Signal Failures. + {0x90, 0x62, 0x02}, + + // Error activation + // UDS_TEST_EOL 04 - EOL error + {0x90, 0x63, 0x04}, + + // SOS button error + // 23 - Signal stuck low (SOS button is stuck) + {0x90, 0x51, 0x23}, + // 13 - Break + {0x90, 0x51, 0x13}, + + // Accelerometer error + // UDS_TEST_ACCEL 02 - no signal from module + {0x90, 0x53, 0x02}, + // 09 - initialization error + {0x90, 0x53, 0x09}, + // UDS_TEST_ACCEL_CALIB 15 - calibration error + {0x90, 0x53, 0x15}, + + // SIM-chip error + // UDS_TEST_SIM_ERA 4A - No response from SIM chip + {0x90, 0x71, 0x4A}, + + // UDS_TEST_SIM_COMERS Commercial SIM-chip error + // 4A - No response from commercial SIM chip + {0x90, 0x72, 0x4A}, + + // Flash error + // 01 - Incorrect CRC for flash application + {0x90, 0x16, 0x01}, + + // Amplifier error + // UDS_TEST_AMPLIFIER 05 - Error amplifier. + {0x90, 0x22, 0x05} + +}; \ No newline at end of file diff --git a/ReadDTCInformation_19.h b/ReadDTCInformation_19.h new file mode 100644 index 0000000..428e534 --- /dev/null +++ b/ReadDTCInformation_19.h @@ -0,0 +1,47 @@ +// +// Created by cfif on 07.08.2024. +// + +#ifndef SMART_COMPONENTS_TELEMATICA_READDTCINFORMATION_19_H +#define SMART_COMPONENTS_TELEMATICA_READDTCINFORMATION_19_H + +#include "stdint.h" + +typedef enum { + UDS_TEST_AUDIO_FILE = 3, + UDS_TEST_GSM_AUDIO_CODEC = 4, + UDS_TEST_MODEM_SOFT_REV = 5, + UDS_TEST_GSM = 7, + UDS_TEST_CERT_REV = 8, + UDS_TEST_GNSS_ANT = 11, + UDS_TEST_BAT_VOLTAGE = 12, + UDS_TEST_BAT_CONNECT = 13, + UDS_TEST_BAT_CHARGE = 14, + UDS_TEST_MICROPHONE_CONNECT = 18, + UDS_TEST_SPEAKER_CONNECT = 20, + UDS_TEST_VIN = 21, + UDS_TEST_EOL = 22, + UDS_TEST_ACCEL = 25, + UDS_TEST_ACCEL_CALIB = 27, + UDS_TEST_SIM_ERA = 28, + UDS_TEST_SIM_COMERS = 29, + UDS_TEST_AMPLIFIER = 31 +} eUdsErrorDTC; + +typedef struct __attribute__ ((packed)) { + uint8_t DTCHighByte; + uint8_t DTCMiddleByte; + uint8_t DTCLowByte; +} tUDS_DTC_Error; + +// Для запроса кодов ошибок +typedef struct __attribute__ ((packed)) { + uint8_t ServiceId; + uint8_t reportDTCByStatusMask; + uint8_t DTCStatusMask; +} tReadDTCInformationRequest; + + +extern const tUDS_DTC_Error UDS_DTC_Error[]; + +#endif //SMART_COMPONENTS_TELEMATICA_READDTCINFORMATION_19_H diff --git a/ReadDataByIdentifier_22i.h b/ReadDataByIdentifier_22i.h new file mode 100644 index 0000000..3e20f5d --- /dev/null +++ b/ReadDataByIdentifier_22i.h @@ -0,0 +1,17 @@ +// +// Created by cfif on 31.01.2025. +// + +#ifndef SMART_COMPONENTS_TELEMATICA_V2_READDATABYIDENTIFIER_22I_H +#define SMART_COMPONENTS_TELEMATICA_V2_READDATABYIDENTIFIER_22I_H + +#include "stdint.h" + +// Для запроса чтения идентификаторов +typedef struct __attribute__ ((packed)) { + uint8_t ServiceId; + uint8_t dataIdentifierByte1; + uint8_t dataIdentifierByte2; +} tReadDataByIdentifierRequest; + +#endif //SMART_COMPONENTS_TELEMATICA_V2_READDATABYIDENTIFIER_22I_H diff --git a/SerialPortCanComInt.c b/SerialPortCanComInt.c new file mode 100644 index 0000000..b111546 --- /dev/null +++ b/SerialPortCanComInt.c @@ -0,0 +1,71 @@ +// +// Created by cfif on 12.11.2024. +// + +#include "SerialPortCanComInt.h" +#include "SystemDelayInterface.h" +#include "CanSerialPortFrame.h" + +void vSerialPortCanComInit( + tSerialPortCanComInt *env, + tSerialPortFrameIO *CanIO, + uint32_t rxBufferLength +) { + env->CanIO = CanIO; + env->queue = osMessageQueueNew(rxBufferLength, 1, NULL); +} + +static uint16_t vSerialPortReceiveQueue(tSerialPortCanComInt *env, uint8_t *data, uint16_t size, uint32_t timeout, + osMessageQueueId_t queueId) { + uint16_t received = 0; + + + if (timeout) { + uint32_t endMs = SystemGetMs() + timeout; + uint32_t leftMs; + + while (size && ((timeout == SystemWaitForever) || (endMs > SystemGetMs()))) { + leftMs = endMs - SystemGetMs(); + if (osMessageQueueGet(queueId, data, NULL, leftMs) == osOK) { + --size; + ++received; + ++data; + } + } + + } else { + while (size) { + if (osMessageQueueGet(queueId, data, NULL, 0) == osOK) { + --size; + ++received; + ++data; + } else { + return received; + } + } + } + + return received; + +} + +static uint16_t vSerialPortReceive(tSerialPortCanComInt *env, uint8_t *data, uint16_t size, uint32_t timeout) { + return vSerialPortReceiveQueue(env, data, size, timeout, env->queue); +} + +static uint16_t vSerialPortTransmit(tSerialPortCanComInt *env, uint8_t *data, uint16_t size, uint32_t timeout) { + + CanSerialPortFrameSetId1(env->CanIO->env, 0x77); + uint16_t sent = env->CanIO->transmit1(env->CanIO->env, data, size, timeout); + + return sent; +} + +tSerialPortIO vSerialPortCanComIntGetIo(tSerialPortCanComInt *env) { + tSerialPortIO io = { + .env = env, + .receive = (SerialPortIOTransaction) vSerialPortReceive, + .transmit = (SerialPortIOTransaction) vSerialPortTransmit + }; + return io; +} \ No newline at end of file diff --git a/SerialPortCanComInt.h b/SerialPortCanComInt.h new file mode 100644 index 0000000..25b7160 --- /dev/null +++ b/SerialPortCanComInt.h @@ -0,0 +1,25 @@ +// +// Created by cfif on 12.11.2024. +// + +#ifndef SMART_COMPONENTS_TELEMATICA_V2_SERIALPORTCANCOMINT_H +#define SMART_COMPONENTS_TELEMATICA_V2_SERIALPORTCANCOMINT_H + +#include "cmsis_os2.h" +#include "SerialPortIO.h" +#include "SerialPortFrameIO.h" + +typedef struct { + tSerialPortFrameIO *CanIO; + osMessageQueueId_t queue; +} tSerialPortCanComInt; + +void vSerialPortCanComInit( + tSerialPortCanComInt *env, + tSerialPortFrameIO *CanIO, + uint32_t rxBufferLength +); + +tSerialPortIO vSerialPortCanComIntGetIo(tSerialPortCanComInt *env); + +#endif //SMART_COMPONENTS_TELEMATICA_V2_SERIALPORTCANCOMINT_H diff --git a/TesterPresent_3e.h b/TesterPresent_3e.h new file mode 100644 index 0000000..d800f32 --- /dev/null +++ b/TesterPresent_3e.h @@ -0,0 +1,17 @@ +// +// Created by cfif on 06.08.2024. +// + +#ifndef SMART_COMPONENTS_UPDATE_TESTERPRESENT_3E_H +#define SMART_COMPONENTS_UPDATE_TESTERPRESENT_3E_H + +#include "stdint.h" + +// Для готовности загрузки модема +typedef struct __attribute__ ((packed)) { + uint8_t ServiceId; + uint8_t zeroSubFunction; + +} tTesterPresent; + +#endif //SMART_COMPONENTS_UPDATE_TESTERPRESENT_3E_H diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..0dd1901 --- /dev/null +++ b/modular.json @@ -0,0 +1,10 @@ +{ + "cmake": { + "inc_dirs": [ + "./" + ], + "srcs": [ + "./**.c" + ] + } +} \ No newline at end of file