Smart_Components_Aurus
/
SMART_COMPONENTS_Egts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
SMART_COMPONENTS_Egts/EgtsEbu.c

721 lines
26 KiB
C
Raw Permalink Blame History

//
// Created by cfif on 13.06.2024.
//
#include "EgtsEbu.h"
#include "string.h"
#include "lfs_file_utils.h"
#include "EgtsOutputCommands.h"
#include "ext_telematica.h"
#include "SystemDelayInterface.h"
#include "Rtc.h"
#include "FirmwareMetadataSection.h"
#include "ld_adr.h"
#define LOG_SIGN "EGTS_EBU"
#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 tFirmwareLoader FIRMWARE_TELE_LOADER;
extern tFirmwareLoader FIRMWARE_LOADER;
const tEgtsEbuName egtsEbuName[EBU_COUNT_TABLE_ITEMS] = {
{EBU_GNSS, "GNSS~UAZ", 0x0000, 0x0000, 0x0000, {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
{EBU_ABS, "ABS~UAZ1APG", TESTER_REQUEST_ABS_ESP, TESTER_RESPONSE_ABS_ESP, 0x4000, {0xF187, 0xF18A, 0xF18C, 0xF190, 0xF193, 0xF195, 0xF197, 0xF199, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
{EBU_ABS, "ABS~UAZ1TRINOVA", TESTER_REQUEST_ABS_ESP, TESTER_RESPONSE_ABS_ESP, 0x0200, {0xF112, 0xF180, 0xF183, 0xF187, 0xF189, 0xF18A, 0xF18B, 0xF18C, 0xF190, 0xF192, 0xF193, 0xF194, 0xF195, 0xF197, 0xF198, 0xF199, 0xF19D, 0x0000}},
{EBU_ECM, "ECM~UAZ1ITL", TESTER_REQUEST_ECM, TESTER_RESPONSE_ECM, 0x0090, {0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009A, 0x00A1, 0x00A2, 0x00A3, 0x0000, 0x0000, 0x0000, 0x0000}},
{EBU_ECM, "ECM~UAZ1DPLUS", TESTER_REQUEST_ECM, TESTER_RESPONSE_ECM, 0xF187, {0xF187, 0xF189, 0xF18A, 0xF18B, 0xF18C, 0xF190, 0xF192, 0xF193, 0xF194, 0xF195, 0xF197, 0xF198, 0xF199, 0xF19D, 0xF1F9, 0x0000, 0x0000, 0x0000}},
{EBU_HVAC, "HVAC~UAZ1", TESTER_REQUEST_HVAC, TESTER_RESPONSE_HVAC, 0xF112, {0xF112, 0xF122, 0xF132, 0xF150, 0xF151, 0xF153, 0xF18C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
{EBU_IMMO, "IMMO~UAZ1ITL", TESTER_REQUEST_ITELMA_IMMO_D, TESTER_RESPONSE_ITELMA_IMMO_D, 0x0000, {0x0007, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
{EBU_IMMO, "IMMO~UAZ1DPLUS", TESTER_REQUEST_IMMO_D, TESTER_RESPONSE_IMMO_D, 0x0000, {0xF190, 0xF193, 0xF195, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
{EBU_PTS, "PTS~UAZ1ABIX", TESTER_REQUEST_PTS, TESTER_RESPONSE_PTS, 0xF183, {0xF183, 0xF184, 0xF18E, 0xF190, 0xF191, 0xF199, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}}
};
const tEgtsEbuTestName egtsEbuTestName[EBU_COUNT_TEST_ITEMS] = {
{TEST_FIRMWARE, "FIRMWARE"},
{TEST_IGNITION, "IGNITION"},
{TEST_BAT_CONNECT, "BAT_CONNECT"},
{TEST_BAT_CHARGE, "BAT_CHARGE"},
{TEST_BAT_VOLTAGE, "BAT_VOLTAGE"},
{TEST_GNSS_ANT, "GNSS_ANT"},
{TEST_SPEAKER_CONNECT, "SPEAKER_CONNECT"},
{TEST_BIP_CONNECT, "BIP_CONNECT"},
{TEST_ACCEL, "ACCEL"},
{TEST_GSM, "GSM"},
{TEST_AUDIO_CODEC, "AUDIO_CODEC"},
{TEST_VIN, "VIN"},
{TEST_ACCEL_CALIB, "ACCEL_CALIB"},
{TEST_EOL, "EOL"},
{TEST_MODEM_SOFT_REV, "MODEM_SOFT_REV"},
{TEST_CERT_REV, "MODEM_CERT_REV"},
{TEST_AUDIO_FILE, "MODEM_AUDIO_FILE"},
{TEST_AMPLIFIER, "AMPLIFIER"},
{TEST_SIM_ERA, "SIM_ERA"},
{TEST_SIM_COMERS, "SIM_COMERS"}
};
bool addEbuTableItem(tEgtsProcessing *env, tEgtsEbuState *ebuState, tEgtsEbuItemState *ebuItemState) {
if (ebuState->count >= EBU_COUNT_FS_ITEMS)
return false;
ebuState->ebuItemState[ebuState->count].ebu = ebuItemState->ebu;
ebuState->ebuItemState[ebuState->count].timestamp = ebuItemState->timestamp;
++ebuState->count;
return true;
}
void setUpdateEbuAll(tEgtsProcessing *env, tEgtsEbuState *ebuState) {
if (osMutexAcquire(env->accessEbu, 2000) == osOK) {
for (uint16_t i = 0; i < ebuState->count; ++i) {
if (ebuState->ebuItemState[i].ebu == i) {
ebuState->ebuItemState[i].timestamp = 0;
}
}
dumpEbuTable(env);
osMutexRelease(env->accessEbu);
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа setUpdateEbu")
}
}
void setUpdateEbu(tEgtsProcessing *env, tEgtsEbuState *ebuState, eEgtsEbu egtsEbu, uint32_t state) {
if (osMutexAcquire(env->accessEbu, 2000) == osOK) {
for (uint16_t i = 0; i < ebuState->count; ++i) {
if (ebuState->ebuItemState[i].ebu == egtsEbu) {
ebuState->ebuItemState[i].timestamp = state;
LoggerInfoStatic(LOGGER, LOG_SIGN, "Состояние ЭБУ найдено")
dumpEbuTable(env);
break;
}
}
osMutexRelease(env->accessEbu);
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа setUpdateEbu")
}
}
void setUpdateEbuClearDTC(tEgtsProcessing *env, tEgtsEbuState *ebuState, eEgtsEbu egtsEbu, bool clearDTC) {
if (osMutexAcquire(env->accessEbu, 2000) == osOK) {
for (uint16_t i = 0; i < ebuState->count; ++i) {
if (ebuState->ebuItemState[i].ebu == egtsEbu) {
ebuState->ebuItemState[i].clearDTC = clearDTC;
LoggerInfoStatic(LOGGER, LOG_SIGN, "Состояние ЭБУ найдено")
break;
}
}
osMutexRelease(env->accessEbu);
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа setUpdateEbuClearDTC")
}
}
bool dumpEbuTable(tEgtsProcessing *env) {
bool isMain = true;
env->ebuState.version = VERSION_EBU;
uint32_t crc = lfs_crc(0, &env->ebuState, sizeof(env->ebuState) - sizeof(env->ebuState.crc));
env->ebuState.crc = crc;
int lfs_err = dumpEbuFile(&env->fs->lfs, "ebu.bin", &env->ebuState, sizeof(tEgtsEbuState));
if (lfs_err != LFS_ERR_OK) {
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Сохранение состояния ЭБУ - ошибка");
isMain = false;
}
if (!isMain)
return false;
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Сохранение состояния ЭБУ - успешно");
return true;
}
bool loadEbuTable(tEgtsProcessing *env) {
bool crc_main = false;
int lfs_err = loadEbuFile(&env->fs->lfs, "ebu.bin", &env->ebuState, sizeof(tEgtsEbuState));
if (lfs_err == LFS_ERR_OK) {
uint32_t crc = lfs_crc(0, &env->ebuState, sizeof(tEgtsEbuState) - sizeof(env->ebuState.crc));
if (crc == env->ebuState.crc) {
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Загрузка состояния ЭБУ - успешно");
crc_main = true;
} else {
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Загрузка состояния ЭБУ - ошибка контрольной суммы");
}
}
if ((!crc_main) || (env->ebuState.count == 0) || (env->ebuState.version != VERSION_EBU)) {
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Загрузка состояния ЭБУ - восстановление значений по умолчанию");
tEgtsEbuItemState egtsEbuItemState;
egtsEbuItemState.timestamp = 0;
for (uint16_t i = 0; i < EBU_COUNT_FS_ITEMS; ++i) {
egtsEbuItemState.ebu = i;
addEbuTableItem(env, &env->ebuState, &egtsEbuItemState);
}
dumpEbuTable(env);
}
return true;
}
bool setEgtsNameEbu(tEgtsProcessing *env, uint8_t ebu) {
if (ebu >= EBU_COUNT_TABLE_ITEMS)
return false;
env->egtsFirmwareDataArgs.module[0] = '\0';
strcat(env->egtsFirmwareDataArgs.module, egtsEbuName[ebu].ebuName);
return true;
/*
for (uint8_t i = 0; i < EBU_COUNT_TABLE_ITEMS; ++i) {
if (egtsEbuName[i].ebu == ebu) {
env->egtsFirmwareDataArgs.module[0] = '\0';
strcat(env->egtsFirmwareDataArgs.module, egtsEbuName[i].ebuName);
return true;
}
}
return false;
*/
}
void clearResultTest() {
for (uint16_t i = 0; i < EXT_ENV_TELE.testsTable->count; ++i) {
EXT_ENV_TELE.testsTable->items[i].resultFix = 0;
}
}
bool isCertTest() {
for (uint16_t i = 0; i < EXT_ENV_TELE.testsTable->count; ++i) {
if (memcmp(EXT_ENV_TELE.testsTable->items[i].name.str, "MODEM_CERT_REV",
EXT_ENV_TELE.testsTable->items[i].name.length) == 0) {
if (EXT_ENV_TELE.testsTable->items[i].resultFix == DEVICE_TESTING_CODE_PASSED) {
return true;
} else {
return false;
}
}
}
return false;
}
eEgtsTestEbu getResultTest(uint8_t indexTest, eDeviceTestingCode *deviceTestingCode) {
/**
* todo: Есть риск коллизии
* Потенциальная ситуация (пример)
* memcmp("ACCEL", "ACCEL_CALIB",5(длинна "ACCEL") ) вернет 0
*/
for (uint16_t i = 0; i < EBU_COUNT_TEST_ITEMS; ++i) {
if (memcmp(EXT_ENV_TELE.testsTable->items[indexTest].name.str, egtsEbuTestName[i].ebuTestName,
EXT_ENV_TELE.testsTable->items[indexTest].name.length) == 0) {
*deviceTestingCode = EXT_ENV_TELE.testsTable->items[indexTest].resultFix;
return egtsEbuTestName[i].ebu;
}
}
return 0xFF;
}
uint16_t SetEbuDTCerror(tEgtsProcessing *env, uint8_t *out, uint16_t offset, eUdsErrorDTC codeError) {
ADD_TO_DATA_BYTE(UDS_DTC_Error[codeError].DTCHighByte)
ADD_TO_DATA_BYTE(UDS_DTC_Error[codeError].DTCMiddleByte)
ADD_TO_DATA_BYTE(UDS_DTC_Error[codeError].DTCLowByte)
ADD_TO_DATA_BYTE(0x01)
return offset;
}
void getMetaDataUveos(tString32 *FW_NAME, tString32 *HW_NAME, tString32 *FW_INTERFACE) {
memset(FW_NAME, 0, sizeof(tString32));
memset(HW_NAME, 0, sizeof(tString32));
memset(FW_INTERFACE, 0, sizeof(tString32));
uint32_t offsetMeta = 0x08000000 + BOOT_AREA_LENGTH + FIRMWARE_MAIN_AREA_LENGTH - 256;
uint32_t pos = offsetMeta;
uint32_t offsetMetaCrc = (*(uint32_t *) pos);
pos += 4;
uint32_t offsetMetaSize = (*(uint32_t *) (pos));
pos += 4;
// FW
FW_NAME->length = (*(uint8_t *) (pos));
pos += 1;
if (FW_NAME->length > 32) {
FW_NAME->length = 0;
return;
}
memcpy(FW_NAME->data, (uint8_t *) (pos), FW_NAME->length);
pos += FW_NAME->length;
// HW
HW_NAME->length = (*(uint8_t *) (pos));
pos += 1;
if (HW_NAME->length > 32) {
HW_NAME->length = 0;
return;
}
memcpy(HW_NAME->data, (uint8_t *) (pos), HW_NAME->length);
pos += HW_NAME->length;
// FW_INTERFACE
FW_INTERFACE->length = (*(uint8_t *) (pos));
pos += 1;
if (FW_INTERFACE->length > 32) {
FW_INTERFACE->length = 0;
return;
}
memcpy(FW_INTERFACE->data, (uint8_t *) (pos), FW_INTERFACE->length);
pos += FW_INTERFACE->length;
}
void setBufEbu(tEgtsProcessing *env) {
uint16_t offset = 0;
uint8_t *out = env->egtsFirmwareDataArgs.bufEbu;
// начало------------------------------------------Ошибки-----------------------------------------------------------
ADD_TO_DATA_SHORT(0x1902)
ADD_TO_DATA_SHORT(0x0004)
ADD_TO_DATA_BYTE(0xFF)
ADD_TO_DATA_BYTE(0x00)
ADD_TO_DATA_BYTE(0x00)
ADD_TO_DATA_BYTE(0xE0)
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)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_BAT_CONNECT);
}
if (egtsTestEbu == TEST_BAT_CHARGE) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_BAT_CHARGE);
}
if (egtsTestEbu == TEST_BAT_VOLTAGE) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, 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))
offset = SetEbuDTCerror(env, out, offset, 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))
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_SPEAKER_CONNECT);
}
if (egtsTestEbu == TEST_BIP_CONNECT) {
if (deviceTestingCode == DEVICE_TESTING_CODE_NOT_CONNECTED)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_MICROPHONE_CONNECT);
}
if (egtsTestEbu == TEST_ACCEL) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_ACCEL);
}
if (egtsTestEbu == TEST_GSM) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_GSM);
}
if (egtsTestEbu == TEST_AUDIO_CODEC) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_GSM_AUDIO_CODEC);
}
if (egtsTestEbu == TEST_VIN) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_VIN);
}
if (egtsTestEbu == TEST_ACCEL_CALIB) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_ACCEL_CALIB);
}
if (egtsTestEbu == TEST_EOL) {
// DEVICE_TESTING_CODE_ERROR
// if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
// offset = SetEbuDTCerror(env, out, offset, UDS_TEST_EOL);
}
if (egtsTestEbu == TEST_MODEM_SOFT_REV) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_MODEM_SOFT_REV);
}
if (egtsTestEbu == TEST_CERT_REV) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_CERT_REV);
}
if (egtsTestEbu == TEST_AUDIO_FILE) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_AUDIO_FILE);
}
if (egtsTestEbu == TEST_AMPLIFIER) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_AMPLIFIER);
}
if (egtsTestEbu == TEST_SIM_ERA) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_SIM_ERA);
}
if (egtsTestEbu == TEST_SIM_COMERS) {
// DEVICE_TESTING_CODE_ERROR
if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
offset = SetEbuDTCerror(env, out, offset, UDS_TEST_SIM_COMERS);
}
}
if (offset > 8) {
uint16_t *len = (uint16_t *) &out[2];
uint8_t *err = (uint8_t *) &out[7];
*len = offset - 4;
*err = 0;
asm("nop");
}
// конец-------------------------------------------Ошибки-----------------------------------------------------------
// IMEI
uint8_t IMEI_len = EXT_ENV_TELE.store.device->cgsmid.length;
if (EXT_ENV_TELE.store.device->cgsmid.length >= 2) {
if ((EXT_ENV_TELE.store.device->cgsmid.data[IMEI_len - 1] == '\n') &&
(EXT_ENV_TELE.store.device->cgsmid.data[IMEI_len - 2] == '\r')) {
IMEI_len = EXT_ENV_TELE.store.device->cgsmid.length - 2;
}
}
uint8_t dataBuf[50];
memset(dataBuf, 0, sizeof(dataBuf));
memcpy(dataBuf, EXT_ENV_TELE.store.device->cgsmid.data, IMEI_len);
ADD_TO_DATA_SHORT(0x0411);
ADD_TO_DATA_CHAR_SHORT(15);
ADD_TO_DATA(dataBuf, 15)
memset(dataBuf, 0, sizeof(dataBuf));
memcpy(dataBuf, EXT_ENV_TELE.store.gost->VIN.data, EXT_ENV_TELE.store.gost->VIN.length);
ADD_TO_DATA_SHORT(0x0190);
ADD_TO_DATA_CHAR_SHORT(17);
ADD_TO_DATA(dataBuf, 17)
memset(dataBuf, 0, sizeof(dataBuf));
memcpy(dataBuf, EXT_ENV_TELE.store.device->ccidComers.data, EXT_ENV_TELE.store.device->ccidComers.length);
ADD_TO_DATA_SHORT(0x001E);
ADD_TO_DATA_CHAR_SHORT(20);
ADD_TO_DATA(dataBuf, 20)
memset(dataBuf, 0, sizeof(dataBuf));
memcpy(dataBuf, EXT_ENV_TELE.store.device->ccid.data, EXT_ENV_TELE.store.device->ccid.length);
ADD_TO_DATA_SHORT(0x001D);
ADD_TO_DATA_CHAR_SHORT(19);
ADD_TO_DATA(dataBuf, 19)
/*
tString32 FW_NAME;
FW_NAME.length = *FIRMWARE_LOADER.main.metadata.nameLength;
if (FW_NAME.length > 32) {
FW_NAME.length = 0;
} else {
memcpy(FW_NAME.data, FIRMWARE_LOADER.main.metadata.name, FW_NAME.length);
}
*/
tString32 FW_NAME;
tString32 HW_NAME;
tString32 FW_INTERFACE;
getMetaDataUveos(&FW_NAME, &HW_NAME, &FW_INTERFACE);
uint8_t posDel = findDelimiter(&FW_INTERFACE, ' ');
memset(dataBuf, 0, sizeof(dataBuf));
memcpy(dataBuf, FIRMWARE_TELE_LOADER.main.metadata.name, *FIRMWARE_TELE_LOADER.main.metadata.nameLength);
memcpy(&dataBuf[*FIRMWARE_TELE_LOADER.main.metadata.nameLength], &FW_INTERFACE.data[posDel], FW_INTERFACE.length - posDel);
ADD_TO_DATA_SHORT(0x0600);
ADD_TO_DATA_CHAR_SHORT(32);
ADD_TO_DATA(dataBuf, 32)
memset(dataBuf, 0, sizeof(dataBuf));
memcpy(dataBuf, &EXT_ENV_TELE.store.device->telematicaIsActive, 1);
ADD_TO_DATA_SHORT(0x0604);
ADD_TO_DATA_CHAR_SHORT(1);
ADD_TO_DATA(dataBuf, 1)
/*
// Serial Number
// ADD_TO_DATA_SHORT(0xF18C);
// ADD_TO_DATA_CHAR_SHORT(env->storage->nvm.device.serialNumber.value.length);
// ADD_TO_DATA(env->storage->nvm.device.serialNumber.value.data, env->storage->nvm.device.serialNumber.value.length)
// IMEI
uint8_t IMEI_len = EXT_ENV_TELE.store.device->cgsmid.length;
if (EXT_ENV_TELE.store.device->cgsmid.length >= 2) {
if ((EXT_ENV_TELE.store.device->cgsmid.data[IMEI_len - 1] == '\n') &&
(EXT_ENV_TELE.store.device->cgsmid.data[IMEI_len - 2] == '\r')) {
IMEI_len = EXT_ENV_TELE.store.device->cgsmid.length - 2;
}
}
ADD_TO_DATA_SHORT(0xF101);
ADD_TO_DATA_CHAR_SHORT(IMEI_len);
ADD_TO_DATA(EXT_ENV_TELE.store.device->cgsmid.data, IMEI_len)
// Phone Number
// Hardware Version
tString32 fw;
fw.length = META_FW_NAME_SIZE;
memcpy(&fw.data, (uint8_t *) META_FW_NAME, fw.length);
tString32 hw;
hw.length = META_HW_NAME_SIZE;
memcpy(&hw.data, (uint8_t *) META_HW_NAME, hw.length);
// Hardware Version
ADD_TO_DATA_SHORT(0xF193);
ADD_TO_DATA_CHAR_SHORT(hw.length);
ADD_TO_DATA(hw.data, hw.length)
// Vehicle VIN Number
ADD_TO_DATA_SHORT(0xF190);
ADD_TO_DATA_CHAR_SHORT(EXT_ENV_TELE.store.gost->VIN.length);
ADD_TO_DATA(EXT_ENV_TELE.store.gost->VIN.data, EXT_ENV_TELE.store.gost->VIN.length)
// Main Server
ADD_TO_DATA_SHORT(0xF104);
ADD_TO_DATA_CHAR_SHORT(env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length);
ADD_TO_DATA(env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data,
env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length)
// Second Server
ADD_TO_DATA_SHORT(0xF105);
ADD_TO_DATA_CHAR_SHORT(env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.length);
ADD_TO_DATA(env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.data,
env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.length)
*/
env->egtsFirmwareDataArgs.bufLen = offset;
}
void _Noreturn EgtsProcessing_TransmitterTaskEbu(tEgtsProcessing *env) {
time_t timestamp = 0;
uint8_t egtsEbuIndex = 0;
uint32_t timeTeleOff = 0;
bool isTimestamp = true;
bool oneOn = true;
bool oneOff = true;
for (;;) {
if (onOffTelematica(env, &oneOn, &oneOff, "Задача ЭБУ"))
continue;
//начало ---------------------------------Отправка прошивки ЭБУ-------------------------------------------------
//начало ---------------------------------Отправка прошивки ЭБУ-------------------------------------------------
//начало ---------------------------------Отправка прошивки ЭБУ-------------------------------------------------
if (!isAuth(env)) {
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание аутентификации на сервере")
SystemDelayMs(1000);
continue;
}
if (!env->isEnableTelematicaSendPoints) {
if (timeTeleOff < SystemGetMs()) {
timeTeleOff = SystemGetMs() + 10000;
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание разрешения телематики")
}
SystemDelayMs(1000);
continue;
}
RtcGet(env->gsm->Rtc, &timestamp);
if (timestamp < 1718359909) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание получения временной метки")
SystemDelayMs(1000);
continue;
} else {
if (isTimestamp) {
isTimestamp = false;
LoggerInfoStatic(LOGGER, LOG_SIGN, "Временная метка получена")
}
}
// Передача прошивки через ВРЕМЯ
if ((env->fl_firstStartTimeUpdateEBU) && (env->firstStartTimeUpdateEBU < SystemGetMs())) {
EXT_ENV_TELE.store.runtime->telematicaWaitConnect = true;
egtsEbuIndex = EBU_GNSS;
setEgtsNameEbu(env, egtsEbuIndex);
setBufEbu(env);
if (EgtsProcessing_SendFirmware(env) == false) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Передача данных ЭБУ (автоматическая) не удалась")
} else {
env->fl_firstStartTimeUpdateEBU = false;
LoggerInfoStatic(LOGGER, LOG_SIGN, "Передача данных ЭБУ (автоматическая) завершена успешно")
}
}
if (!env->ebuReady) {
if (env->ebuState.ebuItemState[EBU_GNSS].timestamp == 0) {
egtsEbuIndex = EBU_GNSS;
setEgtsNameEbu(env, egtsEbuIndex);
setBufEbu(env);
env->ebuReady = true;
} else {
if (env->CanMainAdditional.egtsEbuUdsReady.isUdsBufReady) {
egtsEbuIndex = env->CanMainAdditional.egtsEbuUdsReady.ebuIndex;
setEgtsNameEbu(env, egtsEbuIndex);
env->egtsFirmwareDataArgs.bufLen = env->CanMainAdditional.egtsEbuUdsReady.bufLen;
memcpy(env->egtsFirmwareDataArgs.bufEbu,
(uint8_t *) env->CanMainAdditional.egtsEbuUdsReady.buf,
env->CanMainAdditional.egtsEbuUdsReady.bufLen);
env->ebuReady = true;
}
}
}
if (env->ebuReady) {
env->ebuReady = false;
/*
setUpdateEbu(env, &env->ebuState, egtsEbuName[egtsEbuIndex].ebu, timestamp + 86400); // !!!!!!!!!
env->CanMainAdditional.egtsEbuUdsReady.ebuIndex = 0; // !!!!!!!!!
env->CanMainAdditional.egtsEbuUdsReady.isUdsBufReady = false; // !!!!!!!!!!!!
*/
// Передача прошивки
if (EgtsProcessing_SendFirmware(env) == false) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Передача данных ЭБУ не удалась")
} else {
setUpdateEbu(env, &env->ebuState, egtsEbuName[egtsEbuIndex].ebu, timestamp + 86400);
if (egtsEbuIndex != EBU_GNSS) {
env->CanMainAdditional.egtsEbuUdsReady.ebuIndex = 0;
env->CanMainAdditional.egtsEbuUdsReady.isUdsBufReady = false;
}
}
}
//конец ---------------------------------Отправка прошивки ЭБУ--------------------------------------------------
//конец ---------------------------------Отправка прошивки ЭБУ--------------------------------------------------
//конец ---------------------------------Отправка прошивки ЭБУ--------------------------------------------------
SystemDelayMs(1000);
}
}
Reference in New Issue View Git Blame Copy Permalink