1801 lines
80 KiB
C
1801 lines
80 KiB
C
//
|
||
// 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);
|
||
}
|
||
|
||
|