commit d0d4685518d6244d2eb8453963294c85e765da15 Author: cfif Date: Wed Dec 4 13:10:48 2024 +0300 Init diff --git a/EgtsInputCommands.c b/EgtsInputCommands.c new file mode 100644 index 0000000..35535a0 --- /dev/null +++ b/EgtsInputCommands.c @@ -0,0 +1,164 @@ +// +// Created by cfif on 11.04.2024. +// +#include "EgtsInputCommands.h" +#include "EgtsOutputCommands.h" +#include "Rtc.h" +#include "string.h" +#include "SystemDelayInterface.h" + +#define LOG_SIGN "EGTS_COM" +#define LOGGER &env->slog->logger + +egtsAurusCommandResult egtsAurusGetReport(tEgtsProcessing *env) { + + uint16_t command = *((uint16_t *) (env->egtsCommandSent.data + 2)); + uint16_t block = *((uint16_t *) env->egtsCommandSent.data); + + bool isResponseCommand = false; + + if (command == 101) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда сброса ошибок, код команды: %u, код блока: %u", + command, block) + isResponseCommand = true; + + } + + if (command == 102) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда обновления отчета, код команды: %u, код блока: %u", + command, block) + isResponseCommand = true; + } + + if (!isResponseCommand) { + LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда, код команды: %u, код блока: %u", + command, block) + } + + return EGTS_AURUS_COMMAND_RESULT_OK; +} + +egtsAurusCommandResult egtsAurusSetRestart(tEgtsProcessing *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена команда перезагрузки устройства") + return EGTS_AURUS_COMMAND_RESULT_RESTART_OK; +} + +egtsAurusCommandResult egtsAurusAnalizCommands(tEgtsProcessing *env) { +/* + env->egtsCommandSent.commandConfirmationType = CC_OK; + + if (env->egtsCommandSent.cmd == EGTS_SET_TIME) { + return egtsAurusSetTimestamp(env); + } + + if (env->egtsCommandSent.cmd == EGTS_SET_PERMANENT_TELEMATICA) { + } + + if (env->egtsCommandSent.cmd == EGTS_GET_REPORT) { + return egtsAurusGetReport(env); + } + + if (env->egtsCommandSent.cmd == EGTS_SET_RESTART) { + return egtsAurusSetRestart(env); + } +*/ + env->egtsCommandSent.commandConfirmationType = CC_ILL; + + return EGTS_AURUS_COMMAND_RESULT_UNKNOWN; +} + +void addCommandQueue(tEgtsProcessing *env, tEgtsCommand *egtsCommand) { + + osStatus_t status = osMessageQueuePut(env->egtsCommandConfirmationAdditionalData.queue, egtsCommand, 0x0, 0U); + + if (status != osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь addCommandQueue") + } +} + +bool extractCommandQueue(tEgtsProcessing *env, tEgtsCommand *egtsCommandSent, uint32_t timeout) { + osStatus_t status = osMessageQueueGet(env->egtsCommandConfirmationAdditionalData.queue, egtsCommandSent, 0, + timeout); + + if ((status != osOK) && (status != osErrorTimeout)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка извлечения из очереди extractCommandQueue") + } + + if (status == osOK) { + return true; + } + + return false; +} + + +_Noreturn void EgtsProcessing_TransmitterTaskInputCommand(tEgtsProcessing *env) { + + bool oneOn = true; + bool oneOff = true; + + for (;;) { + if (onOffTelematica(env, &oneOn, &oneOff, "Задача обработки команд")) + continue; + + + //начало ---------------------------------Обработка команд------------------------------------------------------ + //начало ---------------------------------Обработка команд------------------------------------------------------ + //начало ---------------------------------Обработка команд------------------------------------------------------ + + if (!isAuth(env)) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание аутентификации на сервере") + SystemDelayMs(1000); + continue; + } + + if (extractCommandQueue(env, &env->egtsCommandSent, 1000)) { + + egtsAurusCommandResult resultCom = egtsAurusAnalizCommands(env); + + if (env->egtsCommandSent.commandConfirmationType == CC_ILL) { + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен неизвестный код команды: %d", + env->egtsCommandSent.cmd); + + } + + EgtsProcessing_SendCommandConfirmation(env, + CT_COMCONF, + env->egtsCommandSent.commandConfirmationType, + env->egtsCommandSent.cmdId, + 0, + + 0, + 0, + 0, + env->egtsCommandSent.cmd, + + env->egtsCommandSent.data, + env->egtsCommandSent.dataSize); + + +// if (resultCom == EGTS_AURUS_COMMAND_RESULT_ERROR) { +// env->egtsIdentityAdditionalData.isReceivedResultCode = false; +// LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Принудительный разрыв соединения с сервером, ИД: %d", +// env->socketId); +// EgtsProcessingCloseConnection(env); +// } + + if (resultCom == EGTS_AURUS_COMMAND_RESULT_RESTART_OK) { + SystemDelayMs(1000); +// nvic_system_reset(); + } + + + } + + + //конец ---------------------------------Обработка команд------------------------------------------------------- + //конец ---------------------------------Обработка команд------------------------------------------------------- + //конец ---------------------------------Обработка команд------------------------------------------------------- + + } +} + + diff --git a/EgtsInputCommands.h b/EgtsInputCommands.h new file mode 100644 index 0000000..eb14ef5 --- /dev/null +++ b/EgtsInputCommands.h @@ -0,0 +1,49 @@ +// +// Created by cfif on 11.04.2024. +// + +#ifndef SMART_COMPONENTS_EGTSINPUTCOMMANDS_H +#define SMART_COMPONENTS_EGTSINPUTCOMMANDS_H + +#include "EgtsProcessing.h" + +typedef enum { + EGTS_AURUS_COMMAND_RESULT_OK = 0x00, + EGTS_AURUS_COMMAND_RESULT_ERROR = 0x01, + + EGTS_AURUS_COMMAND_RESULT_TIMESTAMP_TELE_STOP_OK = 0xFC, + EGTS_AURUS_COMMAND_RESULT_TIMESTAMP_TELE_RUN_OK = 0xFD, + + EGTS_AURUS_COMMAND_RESULT_RESTART_OK = 0xFE, + EGTS_AURUS_COMMAND_RESULT_UNKNOWN = 0xFF, +} egtsAurusCommandResult; + +typedef enum { + EGTS_SET_RESTART = 0x0008, + EGTS_SET_TIME = 0xFAC4, + + EGTS_SET_PERMANENT_TELEMATICA = 0xFAD0, + + EGTS_GET_REPORT = 0xFAC2, + + EGTS_GPRS_APN = 0x0203, + EGTS_SERVER_ADDRESS = 0x0204, + EGTS_SIM_PIN = 0x0205, + + EGTS_GPRS_USER = 0x051A + + +} egtsAurusCommands; + + +egtsAurusCommandResult egtsAurusAnalizCommands(tEgtsProcessing *env); + +egtsAurusCommandResult egtsAurusSetTimestamp(tEgtsProcessing *env); + +void addCommandQueue(tEgtsProcessing *env, tEgtsCommand *egtsCommand); + +uint8_t VariablesTable_ExGetVarTypeLength(tVariableDescriptor *var); + +_Noreturn void EgtsProcessing_TransmitterTaskInputCommand(tEgtsProcessing *env); + +#endif //SMART_COMPONENTS_EGTSINPUTCOMMANDS_H diff --git a/EgtsOutputCommands.c b/EgtsOutputCommands.c new file mode 100644 index 0000000..18a6ac9 --- /dev/null +++ b/EgtsOutputCommands.c @@ -0,0 +1,604 @@ +// +// Created by cfif on 12.04.2024. +// +#include "EgtsOutputCommands.h" +#include "math.h" +#include "AsciiStringAssmeblingUtils.h" +#include "stdio.h" +#include "Rtc.h" +#include "egts_commonExt.h" +#include "EgtsTimestamp.h" +#include "string.h" +#include "FirmwareMetadataSection.h" +#include "stdlib.h" + +#define LOG_SIGN "EGTS" +#define LOGGER &env->slog->logger + +#define ADD_TO_RESULT(DATA, LEN) memcpy(out + offset, (uint8_t * ) & DATA, LEN); offset+=LEN; +#define ADD_TO_RESULT_P(DATA, LEN) memcpy(out + offset, DATA, LEN); offset+=LEN; + +//начало ---------------------------------Аутентификация--------------------------------------------------------------- +//начало ---------------------------------Аутентификация--------------------------------------------------------------- +//начало ---------------------------------Аутентификация--------------------------------------------------------------- + +uint16_t vEgtsPackAuth(uint8_t *out, tEgtsIdentityDataArgs *args, uint16_t step) { + uint16_t offset = 0; + + uint16_t TermIdentityBS = 256;//1400; + uint8_t TermIdentityFlags = 0b01000010; + + ADD_TO_RESULT(args->TerminalID, 4); + ADD_TO_RESULT(TermIdentityFlags, 1); + ADD_TO_RESULT((*args->IMEI), args->IMEI_len); + ADD_TO_RESULT(TermIdentityBS, 2); + + return offset; +} + +uint16_t vEgtsPackModuleData(uint8_t *out, tEgtsIdentityModuleDataArgs *args, uint16_t step) { + uint16_t offset = 0; + + tString32 fw; + fw.length = META_FW_NAME_SIZE; + memcpy(&fw.data, (uint8_t *) META_FW_NAME, fw.length); + + uint8_t pos = findDelimiter(&fw, '.') + 1; + uint8_t fw_h = atoi(FIRMWARE_VERSION); + uint8_t fw_l = atoi(&FIRMWARE_VERSION[pos]); + + tString32 hw; + hw.length = META_HW_NAME_SIZE; + memcpy(&hw.data, (uint8_t *) META_HW_NAME, hw.length); + + pos = findDelimiter(&hw, '.') + 1; + uint8_t hw_h = atoi(HARDWARE_REVISION); + uint8_t hw_l = atoi(&HARDWARE_REVISION[pos]); + + uint8_t MT = 1; // Module Туре + uint32_t VID = 1; // Vendor Identifier + uint16_t FWV = (hw_h << 8) | hw_l; // Firmware Version + uint16_t SWV = (fw_h << 8) | fw_l; // Software Version + uint8_t MD = 0; // Modification + uint8_t ST = 1; // State + + uint8_t Delimiter = 0; + + ADD_TO_RESULT(MT, 1); + ADD_TO_RESULT(VID, 4); + ADD_TO_RESULT(FWV, 2); + ADD_TO_RESULT(SWV, 2); + ADD_TO_RESULT(MD, 1); + ADD_TO_RESULT(ST, 1); + ADD_TO_RESULT(Delimiter, 1); + + return offset; +} + +//char auth[15] = "860384067388816"; + +bool EgtsProcessing_SendAuth(tEgtsProcessing *env) { + + uint8_t egtsRaw[256]; + memset(egtsRaw, 0, sizeof(egtsRaw)); + + uint16_t authPackLength; + + time_t timestamp; + RtcGet(env->gsm->Rtc, ×tamp); + + uint8_t IMEI_len = env->store->nvm.device.cgsmid.length; + if (env->store->nvm.device.cgsmid.length >= 2) { + if ((env->store->nvm.device.cgsmid.data[IMEI_len - 1] == '\n') && + (env->store->nvm.device.cgsmid.data[IMEI_len - 2] == '\r')) { + IMEI_len = env->store->nvm.device.cgsmid.length - 2; + } + } + + env->egtsIdentityDataArgs.IMEI = (uint8_t *) env->store->nvm.device.cgsmid.data; + env->egtsIdentityDataArgs.IMEI_len = IMEI_len; + env->egtsIdentityDataArgs.TerminalID = env->deviceTeledataStorageData->telematica.EGTS_UNIT_ID; + + ++env->egtsPacketId; + env->egtsIdentityAdditionalData.idPacked = env->egtsPacketId; + env->egtsIdentityAdditionalData.isReceivedResponse = false; + env->egtsIdentityAdditionalData.isReceivedResultCode = false; + + authPackLength = vEgtsPackTransportEx2( + 0, + env->egtsIdentityAdditionalData.idPacked, + &env->counter, + egtsRaw, + EGTS_SERVICE_FLAGS_AUTH, + EGTS_PT_APPDATA, + EGTS_AUTH_SERVICE, + EGTS_AUTH_SERVICE, + timestamp, + + 1, + EGTS_SR_TERM_IDENTITY, + (tEgtsServiceSubRecordGeneratorEx) vEgtsPackAuth, + &env->egtsIdentityDataArgs, + + 1, + EGTS_SR_MODULE_DATA, + (tEgtsServiceSubRecordGeneratorEx) vEgtsPackModuleData, + &env->egtsModuleDataArgs + ); + + LoggerFormatInfo(LOGGER, LOG_SIGN, "Отправка пакета (id: %u) аутентификации:", + env->egtsIdentityAdditionalData.idPacked) + sendLogHex(env, egtsRaw, authPackLength); + + bool result = EgtsProcessingSend(env, egtsRaw, authPackLength, EGTS_WAIT_2, + &env->egtsIdentityAdditionalData.isReceivedResponse, + &env->egtsIdentityAdditionalData.isReceivedResultCode); + + if (!result) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Истекло время ожидания (EgtsProcessing_SendAuth)"); + return false; + } + + return true; +} + +//конец ---------------------------------Аутентификация--------------------------------------------------------------- +//конец ---------------------------------Аутентификация--------------------------------------------------------------- +//конец ---------------------------------Аутентификация--------------------------------------------------------------- + + +//начало ---------------------------------Теледанные-------------------------------------------------------------------- +//начало ---------------------------------Теледанные-------------------------------------------------------------------- +//начало ---------------------------------Теледанные-------------------------------------------------------------------- + +void EgtsProcessing_Default_SendSensorsDig(tEgtsProcessing *env) { + + + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[0].number = 18; + +/* + for (int i = 0; i < 20; ++i) { + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[i].number = i; + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[i].state = 0; + } + + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[0].state = 0; // Vehicle Alarm System activate siren + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[1].state = 0; // Состояние охранной сигнализации + + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[2].state = 0; // Статус заряда АКБ + + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[3].state = 0; // Статус ПЛ двери + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[4].state = 0; // Статус ПП двери + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[5].state = 0; // Статус ЗЛ двери + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[6].state = 0; // Статус ЗП двери + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[7].state = 0; // Статус капота + + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[8].state = 0; // Уровень омывающей жидкости + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[9].state = 0; // Уровень охлаждающей жидкости + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[10].state = 0; // Окно ПЛ + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[11].state = 0; // Окно ПП + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[12].state = 0; // Окно ЗЛ + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[13].state = 0; // Окно ЗП + + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[14].state = 0; // Состояние батареи датчика давления шины ПЛ + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[15].state = 0; // Состояние батареи датчика давления шины ПП + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[16].state = 0; // Состояние батареи датчика давления шины ЗЛ + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[17].state = 0; // Состояние батареи датчика давления шины ЗП + + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[18].state = 0; // Статус шины BodyCan + env->egtsTeledataEdit.egtsSensorsDigArgs.sensorsDigState[19].state = 0; // Статус шины DiagCan +*/ +} + + +void EgtsProcessing_Default_SendSensorsAn(tEgtsProcessing *env) { + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[0].number = 99; +/* + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[0].number = 99; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[1].number = 104; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[2].number = 105; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[3].number = 106; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[4].number = 111; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[5].number = 112; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[6].number = 113; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[7].number = 131; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[8].number = 132; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[9].number = 133; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[10].number = 134; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[11].number = 3; + + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[12].number = 206; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[13].number = 207; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[14].number = 208; + + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[15].number = 142; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[16].number = 143; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[17].number = 144; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[18].number = 145; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[19].number = 146; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[20].number = 147; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[21].number = 148; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[22].number = 149; + + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[23].number = 150; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[24].number = 151; + */ + +/* + // 0 + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[0].number = 3; + + // 43 + for (int i = 1; i <= 43; ++i) { + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[i].number = 98 + i; + } + + // 3 + for (int i = 44; i <= 46; ++i) { + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[i].number = 162 + i; + } + + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[0].value = 12000; + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[1].value = 0; // Время работы прибора в минутах, после последней перезагрузки/включения + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[2].value = 80 + 40; // 20 Темп. внутри салона (передняя), С + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[3].value = 80 + 60; // 30 Температура внутри салона (задняя), С + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[4].value = 50; // SoH АКБ, % + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[5].value = 60; // SoC АКБ, % + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[6].value = 90; // 5 Внешняя температура, С + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[7].value = 80; // 40 л Уровень топлива, л + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[8].value = 3; // Статус автомобиля + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[9].value = 1; // Статус замков дверей + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[10].value = 3; // Статус багажника (задняя дверь) + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[11].value = 70; // 7 л Ср. расход топлива после БК + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[12].value = 60; // 6 л Ср. расход за поездку + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[13].value = 200; // 20 км Пробег поездки + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[14].value = 600; // 60 км/ч Средняя скорость + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[15].value = 20; // Минут поездки (сборная) + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[16].value = 3; // Положение рычага АКПП + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[17].value = 100000 + 50; // Дней до ТО + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[18].value = 100000 + 300; // Пробег до ТО + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[19].value = 80;// Уровень масла в двигателе + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[20].value = 0; // Индикатор уровня масла двигателя + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[21].value = 22;// 2 атм давление в шине ПЛ + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[22].value = 24;// 2 атм давление в шине ПП + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[23].value = 26;// 2 атм давление в шине ЗЛ + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[24].value = 20;// 2 атм давление в шине ЗП + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[25].value = 2;// Состояние шины ПЛ + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[26].value = 2;// Состояние шины ПП + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[27].value = 2;// Состояние шины ЗЛ + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[28].value = 2;// Состояние шины ЗП + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[29].value = 20;//26 = 20/10 + 16 Целевая темп. CCU водитель + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[30].value = 20;// Целевая темп. CCU П-П + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[31].value = 20;// Целевая темп. CCU ЗЛ-П + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[32].value = 20;// Целевая темп. CCU ЗП-П + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[33].value = 100;// Моточасы + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[34].value = 250;// Пробег авто после сброса БК + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[35].value = 700;// Средняя скорость после сброса БК + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[36].value = 20;// 20 мин Время после сброса БК + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[37].value = 700;// Пробег на остатке топлива + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[38].value = 50;// SoH HV АКБ, % + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[39].value = 60;// SoC HV АКБ, % + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[40].value = 1;// Занятость кресла водителя + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[41].value = 1;// Занятость кресла ПП + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[42].value = 1;// Занятость кресла ЗЛ + // Нет Напряжение АКБ 12В + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[43].value = 4;// Занятость кресла ЗП + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[44].value = 3;// Кол-во спутников + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[45].value = 30;// 53 = 113- 30*2 RSSI (GSM Network) + env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[46].value = 44;// Network type +*/ + +} + + +uint16_t vEgtsPackSensorsDigData(uint8_t *out, tEgtsSensorsDigDataArgs *args, uint16_t step) { + uint16_t offset = 0; + ADD_TO_RESULT(args->sensorsDigState[step], 2); + return offset; +} + +uint16_t vEgtsPackSensorsAnData(uint8_t *out, tEgtsSensorsAnDataArgs *args, uint16_t step) { + uint16_t offset = 0; + ADD_TO_RESULT(args->sensorsAnState[step], 4); + return offset; +} + +uint16_t vEgtsPackPositionData(uint8_t *out, tEgtsPositionDataArgs *args, uint16_t step) { + + uint16_t offset = 0; + + ADD_TO_RESULT(args->NTM, 4); + ADD_TO_RESULT(args->LAT, 4); + ADD_TO_RESULT(args->LONG, 4); + ADD_TO_RESULT(args->FLG, 1); + ADD_TO_RESULT(args->SPD, 2); + ADD_TO_RESULT(args->DIR, 1); + ADD_TO_RESULT(args->ODM, 3); + ADD_TO_RESULT(args->DIN, 1); + ADD_TO_RESULT(args->SRC, 1); + ADD_TO_RESULT(args->ALT, 3); + + return offset; + +} + +bool EgtsProcessing_SendSensors(tEgtsProcessing *env, bool isStorage) { + + uint8_t egtsRaw[512]; + memset(egtsRaw, 0, sizeof(egtsRaw)); + + time_t timestamp; + RtcGet(env->gsm->Rtc, ×tamp); + +// LoggerStrInfoStatic(LOGGER, LOG_SIGN, "НОВАЯ ТЕЛЕМАТИКА"); + + ++env->egtsPacketId; + env->egtsTeledataAdditionalData.idPacked = env->egtsPacketId; + env->egtsTeledataAdditionalData.isReceivedResponse = false; + + uint16_t PackLength; + + PackLength = vEgtsPackTransportEx3( + 0, + env->egtsTeledataAdditionalData.idPacked, + &env->counter, + egtsRaw, + EGTS_SERVICE_FLAGS_TELEDATA, + EGTS_PT_APPDATA, + EGTS_TELEDATA_SERVICE, + EGTS_TELEDATA_SERVICE, + timestamp, + + 1, + EGTS_SR_POS_DATA, + (tEgtsServiceSubRecordGeneratorEx) vEgtsPackPositionData, + &env->egtsTeledataSent.egtsPosDataArgs, + + //20, + 1, + EGTS_SR_ABS_DIG_SENS_DATA, + (tEgtsServiceSubRecordGeneratorEx) vEgtsPackSensorsDigData, + &env->egtsTeledataSent.egtsSensorsDigArgs, + + //47, + 25, + EGTS_SR_ABS_AN_SENS_DATA, + (tEgtsServiceSubRecordGeneratorEx) vEgtsPackSensorsAnData, + &env->egtsTeledataSent.egtsSensorsAnArgs + ); + + + LoggerFormatInfo(LOGGER, LOG_SIGN, "Отправка пакета (id: %u) теледанных (%u байт):", + env->egtsTeledataAdditionalData.idPacked, PackLength) +// sendLogHex(env, egtsRaw, PackLength); + + bool result = EgtsProcessingSend(env, egtsRaw, PackLength, EGTS_WAIT_1, + &env->egtsTeledataAdditionalData.isReceivedResponse, NULL); + + if (!result) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Истекло время ожидания (EgtsProcessing_SendSensors)"); + return false; + } + + return true; + +} + +//конец ---------------------------------Теледанные--------------------------------------------------------------------- +//конец ---------------------------------Теледанные--------------------------------------------------------------------- +//конец ---------------------------------Теледанные--------------------------------------------------------------------- + + +//начало ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ +//начало ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ +//начало ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ + +uint16_t vEgtsPackFirmware(uint8_t *out, tEgtsFirmwareDataArgs *args, uint16_t step) { + uint16_t offset = 0; + + ++args->partNumber; + + ADD_TO_RESULT(args->idFirmware, 2); + ADD_TO_RESULT(args->partNumber, 2); + ADD_TO_RESULT(args->countNumber, 2); + + if (args->partNumber == 1) { + + tOA OA; + OA.MT = 0; + OA.OT = 1; + OA.Reserve = 0; + ADD_TO_RESULT(OA, 1); + + uint8_t CMI = 0; + ADD_TO_RESULT(CMI, 1); + + uint16_t VER = 0x100; + ADD_TO_RESULT(VER, 2); + + uint16_t WOS = CRC16EGTS(args->bufEbu, args->bufLen); + ADD_TO_RESULT(WOS, 2); + + char FILENAME[100]; + sprintf(FILENAME, "DTC_%lu_%s", args->timestamp, args->module); + ADD_TO_RESULT(FILENAME, strlen(FILENAME) + 1); + } + + ADD_TO_RESULT(args->bufEbu, args->bufLen); + + return offset; +} + +bool EgtsProcessing_SendFirmware(tEgtsProcessing *env) { + uint8_t egtsRaw[1024]; + memset(egtsRaw, 0, sizeof(egtsRaw)); + + uint16_t firmwarePackLength; + + time_t timestamp; + RtcGet(env->gsm->Rtc, ×tamp); + + ++env->egtsFirmwareDataArgs.idFirmware; + env->egtsFirmwareDataArgs.countNumber = 1; + env->egtsFirmwareDataArgs.partNumber = 0; + env->egtsFirmwareDataArgs.timestamp = timestamp; + + ++env->egtsPacketId; + env->egtsIdentityAdditionalData.idPacked = env->egtsPacketId; + env->egtsIdentityAdditionalData.isReceivedResponse = false; + + firmwarePackLength = vEgtsPackTransportEx1( + 0, + env->egtsIdentityAdditionalData.idPacked, + &env->counter, + egtsRaw, + EGTS_SERVICE_FLAGS_FIRMWARE, + EGTS_PT_APPDATA, + EGTS_FIRMWARE_SERVICE, + EGTS_FIRMWARE_SERVICE, + timestamp, + 1, + EGTS_SR_SERVICE_PART_DATA, + (tEgtsServiceSubRecordGeneratorEx) vEgtsPackFirmware, + &env->egtsFirmwareDataArgs + ); + + LoggerFormatInfo(LOGGER, LOG_SIGN, "Отправка пакета (id: %u) прошивки:", env->egtsIdentityAdditionalData.idPacked) + sendLogHex(env, egtsRaw, firmwarePackLength); + + bool result = EgtsProcessingSend(env, egtsRaw, firmwarePackLength, EGTS_WAIT_1, + &env->egtsIdentityAdditionalData.isReceivedResponse, NULL); + + if (!result) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Истекло время ожидания (EgtsProcessing_SendFirmware)"); + return false; + } + + return true; +} + +//конец ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ +//конец ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ +//конец ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ + + +//начало ---------------------------------Команды------------------------------------------------------------------ +//начало ---------------------------------Команды------------------------------------------------------------------ +//начало ---------------------------------Команды------------------------------------------------------------------ +uint16_t vEgtsPackCommandConfirmation(uint8_t *out, tEgtsCommandConfirmationDataArgs *args, uint16_t step) { + uint16_t offset = 0; + + uint8_t flag = (args->CT << 0x4) | (args->CCT & 0xF); + ADD_TO_RESULT(flag, 1); + + ADD_TO_RESULT(args->CID, 4); + ADD_TO_RESULT(args->SID, 4); + + uint8_t hasFlags = (args->ACFE << 0x1) | (args->CHSFE & 0x1); + ADD_TO_RESULT(hasFlags, 1); + + if (args->CHSFE) { + ADD_TO_RESULT(args->CHS, 1); + } + if (args->ACFE) { + ADD_TO_RESULT(args->ACL, 1); + ADD_TO_RESULT(args->AC, 4); + } + + if ((args->CT == CT_COMCONF) && (args->CCT == CC_OK)) { + ADD_TO_RESULT(args->CmdData.ADR, 2); + uint8_t flagComData = (args->CmdData.SZ << 0x4) | (args->CmdData.ACT & 0xF); + ADD_TO_RESULT(flagComData, 1); + ADD_TO_RESULT(args->CmdData.CCD, 2); + } + + if (args->CmdData.DT_SIZE) { + ADD_TO_RESULT_P(args->CmdData.DT, args->CmdData.DT_SIZE); + } + + return offset; +} + +bool EgtsProcessing_SendCommandConfirmation(tEgtsProcessing *env, + uint8_t cmdType, + uint8_t cmdConfirmationType, + uint32_t cmdId, + uint32_t srcId, + + uint16_t address, + uint8_t size, + uint8_t act, + uint16_t cmd, + + uint8_t *DT, + uint16_t DT_SIZE) { + uint8_t egtsRaw[256]; + memset(egtsRaw, 0, sizeof(egtsRaw)); + + uint16_t commandConfirmationPackLength; + + time_t timestamp; + RtcGet(env->gsm->Rtc, ×tamp); + + bool authCodeExist = false; + bool charsetExist = false; + + env->egtsCommandConfirmationDataArgs.CT = cmdType; + env->egtsCommandConfirmationDataArgs.CCT = cmdConfirmationType; + env->egtsCommandConfirmationDataArgs.CID = cmdId; + env->egtsCommandConfirmationDataArgs.SID = srcId; + env->egtsCommandConfirmationDataArgs.ACFE = authCodeExist; + env->egtsCommandConfirmationDataArgs.CHSFE = charsetExist; + + env->egtsCommandConfirmationDataArgs.CmdData.ADR = address; + env->egtsCommandConfirmationDataArgs.CmdData.SZ = size; + env->egtsCommandConfirmationDataArgs.CmdData.ACT = act; + env->egtsCommandConfirmationDataArgs.CmdData.CCD = cmd; + + env->egtsCommandConfirmationDataArgs.CmdData.DT_SIZE = DT_SIZE; + if (DT_SIZE == 0) { + env->egtsCommandConfirmationDataArgs.CmdData.DT = NULL; + } else { + env->egtsCommandConfirmationDataArgs.CmdData.DT = DT; + } + + ++env->egtsPacketId; + env->egtsCommandConfirmationAdditionalData.idPacked = env->egtsPacketId; + env->egtsCommandConfirmationAdditionalData.isReceivedResponse = false; + + commandConfirmationPackLength = vEgtsPackTransportEx1( + 0, + env->egtsCommandConfirmationAdditionalData.idPacked, + &env->counter, + egtsRaw, + +// 0x44, + EGTS_SERVICE_FLAGS_COMMAND, + EGTS_PT_APPDATA, + EGTS_COMMANDS_SERVICE, + EGTS_COMMANDS_SERVICE, + timestamp, + 1, + EGTS_SR_COMMAND_DATA, + (tEgtsServiceSubRecordGeneratorEx) vEgtsPackCommandConfirmation, + &env->egtsCommandConfirmationDataArgs + ); + + LoggerFormatInfo(LOGGER, LOG_SIGN, "Отправка пакета (id: %u) ответа на команду:", + env->egtsCommandConfirmationAdditionalData.idPacked) + sendLogHex(env, egtsRaw, commandConfirmationPackLength); + + bool result = EgtsProcessingSend(env, egtsRaw, commandConfirmationPackLength, EGTS_WAIT_1, + &env->egtsCommandConfirmationAdditionalData.isReceivedResponse, NULL); + + if (!result) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Истекло время ожидания (EgtsProcessing_SendCommandConfirmation)"); + return false; + } + + return true; +} + +//конец ---------------------------------Команды------------------------------------------------------------------ +//конец ---------------------------------Команды------------------------------------------------------------------ +//конец ---------------------------------Команды------------------------------------------------------------------ \ No newline at end of file diff --git a/EgtsOutputCommands.h b/EgtsOutputCommands.h new file mode 100644 index 0000000..4ea02e7 --- /dev/null +++ b/EgtsOutputCommands.h @@ -0,0 +1,145 @@ +// +// Created by cfif on 12.04.2024. +// + +#ifndef SMART_COMPONENTS_EGTSOUTPUTCOMMANDS_H +#define SMART_COMPONENTS_EGTSOUTPUTCOMMANDS_H + +#include "EgtsProcessing.h" + +typedef enum { + SENSORS_DIG_BodyCanBusStatus = 0 // Статус шины BodyCan +} eSensorsDig; + +typedef enum { + SENSORS_AN_Uptime = 0, // Время работы прибора в минутах, после последней перезагрузки/включения + SENSORS_AN_ExternalTemperature = 1, // Внешняя температура, С + SENSORS_AN_FuelLevel = 2, // Уровень топлива, л + SENSORS_AN_VehicleStatus = 3, // Статус автомобиля + SENSORS_AN_TripMileage = 4,// Пробег поездки + SENSORS_AN_AverageSpeed = 5,// Средняя скорость + SENSORS_AN_MinutesOfTravel = 6,// Минут поездки (сборная) + SENSORS_AN_EngineHours = 7,// Моточасы + SENSORS_AN_CarMileageAfterBCReset = 8,// Пробег авто после сброса БК + SENSORS_AN_AverageSpeedAfterBCReset = 9,// Средняя скорость после сброса БК + SENSORS_AN_TimeAfterBCReset = 10,// Время после сброса БК + SENSORS_AN_Voltage12Volts = 11, // Напряжение АКБ 12В + SENSORS_AN_NumberOfSatellites = 12,// Кол-во спутников + SENSORS_AN_RSSI = 13,// RSSI (GSM Network) + SENSORS_AN_NetworkType = 14,// Network type + SENSORS_AN_NumberAccelerations = 15, // Количество ускорений за поездку + SENSORS_AN_NumberBraking = 16, // Количество торможений за поездку + SENSORS_AN_NumberAccelerationsAfterReset = 17, // Количество ускорений после сброса + SENSORS_AN_NumberBrakingAfterReset = 18, // Количество торможений после сброса + SENSORS_AN_NumberLateralAccelerations = 19, // Количество боковых ускорений за поездку + SENSORS_AN_NumberLateralAccelerationsAfterReset = 20, // Количество боковых ускорений после сброса + SENSORS_AN_NumberSpeedViolations = 21, // Количество нарушений скорости за поездку + SENSORS_AN_NumberSpeedViolationsAfterReset = 22, // Количество нарушений скорости после сброса + SENSORS_AN_EngineOXTemperature = 23, // Температура ОХ двигателя + SENSORS_AN_EngineOilTemperature = 24 // Температура масла двигателя +} eSensorsAn; + +/* +typedef enum { + SENSORS_DIG_VehicleAlarmSystemActivateSirenOnOff = 0, // Vehicle Alarm System activate siren + SENSORS_DIG_VehicleAlarmSystemActivateSirenGuarded = 1, // Состояние охранной сигнализации + + SENSORS_DIG_BatteryChargeStatus = 2, // Статус заряда АКБ + + SENSORS_DIG_PL_DoorStatus = 3, // Статус ПЛ двери + SENSORS_DIG_PP_DoorStatus = 4, // Статус ПП двери + SENSORS_DIG_ZL_DoorStatus = 5, // Статус ЗЛ двери + SENSORS_DIG_ZP_DoorStatus = 6, // Статус ЗП двери + SENSORS_DIG_HoodStatus = 7, // Статус капота + + SENSORS_DIG_WasherFluidLevel = 8, // Уровень омывающей жидкости + SENSORS_DIG_CoolantLevel = 9, // Уровень охлаждающей жидкости + SENSORS_DIG_PL_Window = 10, // Окно ПЛ + SENSORS_DIG_PP_Window = 11, // Окно ПП + SENSORS_DIG_ZL_Window = 12, // Окно ЗЛ + SENSORS_DIG_ZP_Window = 13, // Окно ЗП + + SENSORS_DIG_PL_TirePressureSensorBatteryStatus = 14, // Состояние батареи датчика давления шины ПЛ + SENSORS_DIG_PP_TirePressureSensorBatteryStatus = 15, // Состояние батареи датчика давления шины ПП + SENSORS_DIG_ZL_TirePressureSensorBatteryStatus = 16, // Состояние батареи датчика давления шины ЗЛ + SENSORS_DIG_ZP_TirePressureSensorBatteryStatus = 17, // Состояние батареи датчика давления шины ЗП + + SENSORS_DIG_BodyCanBusStatus = 18, // Статус шины BodyCan + SENSORS_DIG_DiagCanBusStatus = 19, // Статус шины DiagCan +} eSensorsDig; + +typedef enum { + SENSORS_AN_BatteryVoltage = 0, // Напряжение АКБ 12В + SENSORS_AN_Uptime = 1, // Время работы прибора в минутах, после последней перезагрузки/включения + SENSORS_AN_TemperatureInsideCabinFront = 2, // Температура внутри салона (передняя), С + SENSORS_AN_TemperatureInsideCabinBack = 3, // Температура внутри салона (задняя), С + SENSORS_AN_BatterySoH = 4, // SoH АКБ, % + SENSORS_AN_BatterySoC = 5, // SoC АКБ, % + SENSORS_AN_ExternalTemperature = 6, // Внешняя температура, С + SENSORS_AN_FuelLevel = 7, // Уровень топлива, л + SENSORS_AN_VehicleStatus = 8, // Статус автомобиля + SENSORS_AN_DoorLockStatus = 9, // Статус замков дверей + SENSORS_AN_TrunkStatus = 10, // Статус багажника (задняя дверь) + SENSORS_AN_WedFuelConsumptionAfterBK = 11,// Ср. расход топлива после БК + SENSORS_AN_WedRipExpense = 12,// Ср. расход за поездку + SENSORS_AN_TripMileage = 13,// Пробег поездки + SENSORS_AN_AverageSpeed = 14,// Средняя скорость + SENSORS_AN_MinutesOfTravel = 15,// Минут поездки (сборная) + SENSORS_AN_AutomaticTransmissionLeverPosition = 16, // Положение рычага АКПП + SENSORS_AN_DaysUntilMintenance = 17, // Дней до ТО + SENSORS_AN_MileageBeforeMaintenance = 18, // Пробег до ТО + SENSORS_AN_OilLevelInEngine = 19,// Уровень масла в двигателе + SENSORS_AN_EngineOilLevelIndicator = 20, // Индикатор уровня масла двигателя + SENSORS_AN_TirePressurePL = 21,// давление в шине ПЛ + SENSORS_AN_TirePressurePP = 22,// давление в шине ПП + SENSORS_AN_TirePressureZL = 23,// давление в шине ЗЛ + SENSORS_AN_TirePressureZP = 24,// давление в шине ЗП + SENSORS_AN_PLBusStatus = 25,// Состояние шины ПЛ + SENSORS_AN_TireConditionPP = 26,// Состояние шины ПП + SENSORS_AN_TireConditionZL = 27,// Состояние шины ЗЛ + SENSORS_AN_TireConditionZP = 28,// Состояние шины ЗП + SENSORS_AN_TargetTempCCUdriver = 29,// Целевая темп. CCU водитель + SENSORS_AN_TargetTempCCUPP = 30,// Целевая темп. CCU П-П + SENSORS_AN_TargetTempCCUZLPP = 31,// Целевая темп. CCU ЗЛ-П + SENSORS_AN_TargetTempCCUZPPP = 32,// Целевая темп. CCU ЗП-П + SENSORS_AN_EngineHours = 33,// Моточасы + SENSORS_AN_CarMileageAfterBCReset = 34,// Пробег авто после сброса БК + SENSORS_AN_AverageSpeedAfterBCReset = 35,// Средняя скорость после сброса БК + SENSORS_AN_TimeAfterBCReset = 36,// Время после сброса БК + SENSORS_AN_MileageOnRemainingFuel = 37,// Пробег на остатке топлива + SENSORS_AN_SoHHVBattery = 38,// SoH HV АКБ, % + SENSORS_AN_SoCHVBattery = 39,// SoC HV АКБ, % + SENSORS_AN_DriverSeatOccupancy = 40,// Занятость кресла водителя + SENSORS_AN_ChairOccupancyPP = 41,// Занятость кресла ПП + SENSORS_AN_ChairOccupancyZL = 42,// Занятость кресла ЗЛ + SENSORS_AN_ChairOccupancyZP = 43,// Занятость кресла ЗП + SENSORS_AN_NumberOfSatellites = 44,// Кол-во спутников + SENSORS_AN_RSSI = 45,// RSSI (GSM Network) + SENSORS_AN_NetworkType = 46,// Network type +} eSensorsAn; +*/ +bool EgtsProcessing_SendAuth(tEgtsProcessing *env); + +bool EgtsProcessing_SendSensors(tEgtsProcessing *env, bool isStorage); + +bool EgtsProcessing_SendFirmware(tEgtsProcessing *env); + +void EgtsProcessing_Default_SendSensorsDig(tEgtsProcessing *env); + +void EgtsProcessing_Default_SendSensorsAn(tEgtsProcessing *env); + +bool EgtsProcessing_SendCommandConfirmation(tEgtsProcessing *env, + uint8_t cmdType, + uint8_t cmdConfirmationType, + uint32_t cmdId, + uint32_t srcId, + + uint16_t address, + uint8_t size, + uint8_t act, + uint16_t cmd, + + uint8_t *DT, + uint16_t DT_SIZE); + +#endif //SMART_COMPONENTS_EGTSOUTPUTCOMMANDS_H diff --git a/EgtsProcessing.c b/EgtsProcessing.c new file mode 100644 index 0000000..60b2cdc --- /dev/null +++ b/EgtsProcessing.c @@ -0,0 +1,1061 @@ +// +// Created by cfif on 21.05.23. +// + +#include +#include +#include +#include +#include +#include +#include +#include "EgtsProcessing.h" +#include "stddef.h" +#include "AtGsm_GetTime.h" +#include "EgtsInputCommands.h" +#include "EgtsOutputCommands.h" +#include "egtsWorkerExt.h" +#include "LoggerToSerialPort.h" +#include "string.h" +#include "EgtsTeledataPoint.h" +//#include "GsmWithGnss_Info.h" +//#include "Network.h" +#include "AtGsm_NetworkRegistrationStatus.h" +#include "egts.h" +#include "AtGsmOperatorSelection.h" +#include "AtGsmTelitLe910_DefinePdpContext.h" + + +#define LOG_SIGN "EGTS" +#define LOGGER &env->slog->logger + +bool onOffTelematica(tEgtsProcessing *env, bool *oneOn, bool *oneOff, char *task) { + + if (env->store->runtime.EGTS_FLEET_ON == false) { + + if (*oneOff) { + *oneOn = true; + *oneOff = false; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "%s - отключена", task); + } + + SystemDelayMs(1000); + + return true; + + } else { + if (*oneOn) { + *oneOn = false; + *oneOff = true; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "%s - включена", task); + } + } + + return false; +} + +void EgtsProcessing_TransmitterTaskMain(tEgtsProcessing *env); + +void EgtsProcessing_ListenerTask(tEgtsProcessing *env); + +char *sendLogHex(tEgtsProcessing *env, uint8_t *data, size_t size) { + memset(env->hexString, 0, sizeof(env->hexString)); + size_t len = 0; + vAsciiStringAddBytesAsHex(env->hexString, &len, data, size); + + LoggerStrInfo(LOGGER, LOG_SIGN, env->hexString, strlen(env->hexString)); + + return env->hexString; +} + +size_t EgtsProcessing_WorkerRead(tEgtsProcessing *env, uint8_t *data, size_t size) { + if (env->socketId != SOCKET_WRONG_CONTEXT) { + return SocketInterface_read(&env->gsm->socketGsm.socketIO, env->socketId, data, size, 2000); + } + + return 0; +} + +uint8_t findDelimiter(tString32 *address, char ch) { + + for (uint8_t i = 0; i < address->length; ++i) { + if (address->data[i] == ch) + return i; + } + + return 0; +} + +_Noreturn void Processing_URC(tEgtsProcessing *env) { + bool oneOn = true; + bool oneOff = true; + + for (;;) { + + if (onOffTelematica(env, &oneOn, &oneOff, "Задача URC")) + continue; + + if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) { + + while (AtCmdReceiveNextLine(&env->gsm->gsmAt, 150) == AT_OK) { + AtCmdProcessUnresolvedLine(&env->gsm->gsmAt); + } + + osMutexRelease(env->gsm->gsmAt.access); + + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Processing_URC)") + } + SystemDelayMs(40); + } + +} + +void EgtsProcessing_Init( + tEgtsProcessing *env, + tDeviceStorage *deviceStorage, + tGpioPin *ignition, + tGsmWithGnss *gsm, + tRtcIO *rtcIO, + tLoggerToSerialPort *slog +) { + env->egtsEnv.readData = (void *) EgtsProcessing_WorkerRead; + env->egtsEnv.readDataEnv = env; + env->egtsEnv.workingBuffer = env->wb; + env->egtsEnv.workingBufferLimit = sizeof(env->wb); + env->egtsEnv.workingBufferLength = 0; + env->gsm = gsm; + env->slog = slog; + //env->ebuReady = false; + + env->ignition = ignition; + + env->rtc = rtcIO; + + env->isEnableTelematicaSendPoints = false; + env->rebootFirmware = false; + env->egtsPacketId = 0; + + env->egtsCanEnv.isEbuData = false; + + env->fl_firstStartTimeUpdateEBU = false; + + env->deviceTeledataStorageData = &deviceStorage->nvm.deviceTeledataStorageData; + env->store = deviceStorage; + + env->isOneEBU = false; + + EgtsProcessing_Default_SendSensorsDig(env); + EgtsProcessing_Default_SendSensorsAn(env); + + env->egtsTeledataAdditionalData.queue = osMessageQueueNew(TELEDATA_QUEUE_SIZE, sizeof(tEgtsTeledata), NULL); + env->egtsTeledataAdditionalData.queueEvent = osMessageQueueNew(TELEDATA_QUEUE_SIZE, 1, NULL); + env->egtsCommandConfirmationAdditionalData.queue = osMessageQueueNew(COMMAND_QUEUE_SIZE, sizeof(tEgtsCommand), + NULL); + + +// InitThreadBlock(env->T_processing_Network, "Network", osPriorityNormal); + InitThreadBlock(env->T_processing_input_command, "EgtsPrcInputCom", osPriorityNormal); +// InitThreadBlock(env->T_processing_ebu, "EgtsPrcEbu", osPriorityNormal); + InitThreadBlock(env->T_processing_event_teledata, "EgtsPrcEventTel", osPriorityNormal); + InitThreadBlock(env->T_processing_teledata, "EgtsPrcTeledata", osPriorityNormal); + InitThreadBlock(env->T_processing_main, "EgtsPrcMain", osPriorityNormal); + InitThreadBlock(env->T_listener, "EgtsListner", osPriorityNormal); + + + InitThreadBlock(env->T_processing_urc, "Urc", osPriorityNormal); +} + +void EgtsProcessing_Start(tEgtsProcessing *env) { + +// ThreadBlock_Start(env->T_processing_Network, env, EgtsProcessing_InfoTask); +// ThreadBlock_Start(env->T_processing_ebu, env, EgtsProcessing_TransmitterTaskEbu); + + + + +// ThreadBlock_Start(env->T_processing_input_command, env, EgtsProcessing_TransmitterTaskInputCommand); +// ThreadBlock_Start(env->T_processing_event_teledata, env, EgtsProcessing_EventTaskTeledata); + ThreadBlock_Start(env->T_processing_teledata, env, EgtsProcessing_TransmitterTaskTeledata); + ThreadBlock_Start(env->T_processing_main, env, EgtsProcessing_TransmitterTaskMain); + ThreadBlock_Start(env->T_listener, env, EgtsProcessing_ListenerTask); +// ThreadBlock_Start(env->T_processing_urc, env, Processing_URC); +} + +void EgtsProcessingCloseConnection(tEgtsProcessing *env) { + SocketInterface_close(&env->gsm->socketGsm.socketIO, env->socketId); + env->gsm->slots[0].addr.length = 0; +} + +bool EgtsProcessingSend(tEgtsProcessing *env, uint8_t *egtsRaw, uint16_t egtsRawLength, + eEgtsSendWait wait, volatile bool *wait1, volatile bool *wait2) { + + + uint32_t retry = env->deviceTeledataStorageData->telematica.EGTS_SERVER_PACKET_RETRANSMIT_ATTEMPTS; + + while (retry) { + + bool result = true; + + if (SocketInterface_send(&env->gsm->socketGsm.socketIO, env->socketId, egtsRaw, egtsRawLength, + defaultSocketTransmiteTimeout) != egtsRawLength) { + result = false; + } + + if (!result) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка отправки пакета (ошибка сокета)"); + return false; + } + + if (wait == EGTS_WAIT_0) + return result; + + uint32_t timeEnd = SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_SERVER_PACKET_TOUT * 1000; + + while (timeEnd > SystemGetMs()) { + + if (wait == EGTS_WAIT_1) { + if (*wait1) { + return true; + } + } + + if (wait == EGTS_WAIT_2) { + if ((*wait1) && (*wait2)) { + return true; + } + } + + SystemDelayMs(1); + } + + --retry; + + if (!isAuth(env)) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка отправки пакета (ошибка аутентификации)"); + return false; + } + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Повторная отправка, осталось попыток: %d", retry); + } + + return false; +} + + +bool EgtsProcessing_SendResponse(tEgtsProcessing *env, + eEgtsServiceId sourceServiceId, + eEgtsServiceId recipientServiceId, + uint8_t srvFlags, + uint8_t rst, + uint16_t crn) { + uint8_t egtsRaw[256]; + memset(egtsRaw, 0, sizeof(egtsRaw)); + + if (env->socketId == SOCKET_WRONG_CONTEXT) { + return false; + } + + time_t timestamp; + RtcGet(env->gsm->Rtc, ×tamp); + + tEgtsRecordResponseData args = { + .CRN = crn, + .RST = rst, + }; + + ++env->egtsPacketId; + uint16_t packetResponseLength = vEgtsPackTransport( + env->egtsEnv.header.packetId, + env->egtsPacketId, + egtsRaw, + srvFlags, + EGTS_PT_RESPONSE, + sourceServiceId, + recipientServiceId, + timestamp, + EGTS_SR_RECORD_RESPONSE, + vEgtsPackResponseGen, + &args + ); + + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Отправка пакета подтверждения:"); + sendLogHex(env, egtsRaw, packetResponseLength); + + EgtsProcessingSend(env, egtsRaw, packetResponseLength, EGTS_WAIT_0, NULL, NULL); + + return true; +} + +uint8_t EgtsProcessingOpenConnection(tEgtsProcessing *env) { +/* + env->socketId = SocketInterface_open( + &env->gsm->socketIO, + eSocketType_TCP, + env->clientType, + env->srvAddr.data, + env->srvAddr.length, + env->srvPort, + defaultSocketOpenTimeout + ); +*/ + env->socketId = SocketInterface_openStatic(&env->gsm->socketGsm.socketIO, eSocketType_TCP, env->srvAddr.data, + env->srvPort, defaultSocketOpenTimeout); + + if (env->socketId == SOCKET_WRONG_CONTEXT) { + return SOCKET_WRONG_CONTEXT; + } + + return env->socketId; +} + +bool isAuth(tEgtsProcessing *env) { + + if ((env->egtsIdentityAdditionalData.isReceivedResponse) && + (env->egtsIdentityAdditionalData.isReceivedResultCode)) { + if (env->egtsIdentityAdditionalData.resultCodeAuth == 0) { + return true; + } + } + + return false; +} + + +bool WaitNetworkRegistration(tEgtsProcessing *env, uint16_t timeReg) { + + uint32_t timeEnd = SystemGetMs() + timeReg; + + tAtGsm_NetworkRegistrationReportMode mode; + tAtGsm_NetworkRegistrationState state; + + while (timeEnd > SystemGetMs()) { + + AtCommandResult result = AT_TIMEOUT; + if (osMutexAcquire(env->gsm->gsmAt.access, 2000) == osOK) { + result = AtGsm_NetworkRegistrationStatus(&env->gsm->gsmAt, &mode, &state); + osMutexRelease(env->gsm->gsmAt.access); + } + + if (result) { + if (state == AT_NETWORK_REGISTRATION_STATE_REGISTERED_HOME || + state == AT_NETWORK_REGISTRATION_STATE_REGISTERED_ROAMING) { + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена регистрация") + + return true; + } + } + + if (env->store->runtime.EGTS_FLEET_ON == false) { + return AT_TIMEOUT; + } + + SystemDelayMs(100); + } + + return false; +} + +bool NetworkRequire(tEgtsProcessing *env) { + bool result = false; + + if (!WaitNetworkRegistration(env, 2000)) { + + if (env->store->runtime.EGTS_FLEET_ON == false) { + return false; + } + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение регистрации в сети"); + for (uint8_t i = 0; i < 3; ++i) { + + if (osMutexAcquire(env->gsm->gsmAt.access, 2000) == osOK) { + AtGsm_OperatorSelectionAutomatic(&env->gsm->gsmAt); + osMutexRelease(env->gsm->gsmAt.access); + } + + if (env->store->runtime.EGTS_FLEET_ON == false) { + return false; + } + + SystemDelayMs(100); + } + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ждем сеть..."); + if (WaitNetworkRegistration(env, 2000)) { + result = true; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети получена"); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети не получена"); + } + + } else { + result = true; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует"); + } + + + return result; +} + +bool Gsm_ActivatePdp(tEgtsProcessing *env) { + AtCommandResult res = AT_ERROR; + if (osMutexAcquire(env->gsm->gsmAt.access, 1000) == osOK) { + + res = AtGsmTelitLe910_PdpActivate(&env->gsm->gsmAt, 1); + + osMutexRelease(env->gsm->gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_ActivatePdp)") + } + return res == AT_OK; +} + +bool Gsm_ActivateApn(tEgtsProcessing *env) { + AtCommandResult res = AT_ERROR; + if (osMutexAcquire(env->gsm->gsmAt.access, 1000) == osOK) { + + res = AtGsmTelitLe910_DefinePdpContext(&env->gsm->gsmAt, 1, AtGsmTelitLe910_PdpType_IP, + env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.data, + env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.length); + + osMutexRelease(env->gsm->gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_ActivateApn)") + } + + return res == AT_OK; +} + + +_Noreturn void EgtsProcessing_TransmitterTaskMain(tEgtsProcessing *env) { + + bool isFirstStart = true; + uint32_t timeTeleOff = 0; + uint8_t stepAuth = 1; + + for (;;) { + if (env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length == 0) { + if (timeTeleOff < SystemGetMs()) { + timeTeleOff = SystemGetMs() + 10000; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Не установлен адрес сервера телематики") + } + SystemDelayMs(1000); + continue; + } + + if (env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.length == 0) { + if (timeTeleOff < SystemGetMs()) { + timeTeleOff = SystemGetMs() + 10000; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Не установлен APN") + } + SystemDelayMs(1000); + continue; + } + + break; + } + + uint8_t socketId = SOCKET_WRONG_CONTEXT; + eSocketStatus socketStatus = eSocketStatus_Disconnected; + + eEgtsCertsStatus isLoad; + + while (1) { + + if (env->store->runtime.EGTS_FLEET_ON) { + + Gsm_ActivatePdp(env); + Gsm_ActivateApn(env); + + break; + + } else { + SystemDelayMs(1000); + } + + } + + uint32_t timeOutCheckConnect = 0; + uint32_t timeIsNetworkRegistration = 0; + uint32_t timeOutCheckNav = AURUS_CHECK_NAV; + uint8_t stepCheckNav = 3; + + bool isRegistration; + + while (1) { + + + if (env->store->runtime.EGTS_FLEET_ON) { + + env->store->runtime.telematicaCloseConnect = false; + + isFirstStart = true; + + if (env->deviceTeledataStorageData->telematica.telematicaIsActive) { + env->isEnableTelematicaSendPoints = true; + } else { + env->isEnableTelematicaSendPoints = env->deviceTeledataStorageData->telematica.EGTS_SERVER_ENABLE_TELEMATICA; + } + + } else { + + if (isFirstStart) { + isFirstStart = false; + EgtsProcessingCloseConnection(env); + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Соединение с сервером разорвано, ИД: %d", socketId); + } + + env->egtsIdentityAdditionalData.isReceivedResultCode = false; + + env->egtsEnv.workingBufferLength = 0; + env->isEnableTelematicaSendPoints = false; + env->fl_firstStartTimeUpdateEBU = false; + + env->store->runtime.telematicaCloseConnect = true; + + if (timeTeleOff < SystemGetMs()) { + timeTeleOff = SystemGetMs() + 10000; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика отключена") + } + + SystemDelayMs(100); + continue; + } + + + //начало ---------------------------------Установка соединения с сервером--------------------------------------- + //начало ---------------------------------Установка соединения с сервером--------------------------------------- + //начало ---------------------------------Установка соединения с сервером--------------------------------------- + + + if ((socketStatus == eSocketStatus_Disconnected) || (socketId == SOCKET_WRONG_CONTEXT)) { + uint32_t retry = env->deviceTeledataStorageData->telematica.EGTS_SERVER_CHECK_IN_ATTEMPTS; + + while (retry) { + + if (env->store->runtime.EGTS_FLEET_ON == false) { + break; + } + + if (NetworkRequire(env)) { + isRegistration = true; + } else { + isRegistration = false; + } + + if (!isRegistration) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Нет регистрации в сети"); + continue; + } + + EgtsProcessingCloseConnection(env); + EgtsResetBuffer(&env->egtsEnv); + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Установка соединения с сервером"); + socketId = EgtsProcessingOpenConnection(env); + if (socketId != SOCKET_WRONG_CONTEXT) { + stepAuth = 1; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Соединение с сервером установлено, ИД: %d", socketId); + SystemDelayMs(500); + socketStatus = SocketInterface_status(&env->gsm->socketGsm.socketIO, socketId); + if (socketStatus == eSocketStatus_Connected) { + + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Аутентификация на сервере"); + + if (EgtsProcessing_SendAuth(env)) { + + if (!env->isOneEBU) { + env->isOneEBU = true; + env->firstStartTimeUpdateEBU = SystemGetMs() + 35000; + env->fl_firstStartTimeUpdateEBU = true; + } + + addTeledataQueueEvent(env, EVENT_TCP_CONNECTION_START); + + break; + } + } else { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, + "Аутентификация на сервере невозможна. Соединение разорвано"); + } + } else { + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Ошибка соединения с сервером, код %d", + env->gsm->codeResultOpen); + + + if ((env->gsm->codeResultOpen == 15) || (env->gsm->codeResultOpen == 10)) { + + if (stepAuth == 0) { + + stepAuth = 1; + + if (env->gsm->codeResultOpen == 15) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, + "Ошибка рукопожатия, переход на альтернативный сервер"); + } + + if (env->gsm->codeResultOpen == 10) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, + "Ошибка открытия сеанса, переход на альтернативный сервер"); + } + +// if (env->gsm->codeResultOpen == 20) { +// LoggerStrInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды, переход на альтернативный сервер"); +// } + +// changeServer(env, 1); + + } else { + + --stepAuth; + + if (env->gsm->codeResultOpen == 15) { + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Ошибка рукопожатия, переход на альтернативный сервер через %u попыток", + stepAuth); + } + + if (env->gsm->codeResultOpen == 10) { + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Ошибка открытия сеанса, переход на альтернативный сервер через %u попыток", + stepAuth); + } + +// if (env->gsm->codeResultOpen == 20) { +// LoggerFormatInfo(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды, переход на альтернативный сервер через %u попыток", +// stepAuth); +// } + + } + + continue; + + } else { + stepAuth = 1; + } + + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, + "Соединение с сервером не установлено, повторная попытка соединения, через %d сек", + env->deviceTeledataStorageData->telematica.EGTS_SERVER_CHECK_IN_PERIOD); + + for (uint32_t i = 0; + i < env->deviceTeledataStorageData->telematica.EGTS_SERVER_CHECK_IN_PERIOD; ++i) { + + if (env->store->runtime.EGTS_FLEET_ON == false) { + break; + } + + SystemDelayMs(1000); + } + + + } + + --retry; + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, + "Повторная попытка установки соединения с сервером, осталось попыток: %d", retry); + } + + if (retry == 0) { + + + } + + } + //конец ---------------------------------Установка соединения с сервером--------------------------------------- + //конец ---------------------------------Установка соединения с сервером--------------------------------------- + //конец ---------------------------------Установка соединения с сервером--------------------------------------- + + if (env->store->runtime.EGTS_FLEET_ON == false) { + continue; + } + + //начало ---------------------------------Проверка соединения--------------------------------------------------- + //начало ---------------------------------Проверка соединения--------------------------------------------------- + //начало ---------------------------------Проверка соединения--------------------------------------------------- + if ((timeOutCheckConnect < SystemGetMs()) || (env->gsm->isDisconnect)) { + + if (env->gsm->isDisconnect) { + env->gsm->isDisconnect = false; + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Обнаружен разрыв соединения") + } + + + timeOutCheckConnect = SystemGetMs() + AURUS_CHECK_CONNECT; + + if (socketId != SOCKET_WRONG_CONTEXT) { + + socketStatus = SocketInterface_status(&env->gsm->socketGsm.socketIO, socketId); + + if (socketStatus == eSocketStatus_Disconnected) { + env->egtsIdentityAdditionalData.isReceivedResultCode = false; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Соединение с сервером разорвано, ИД: %d", socketId); + EgtsProcessingCloseConnection(env); + } + + } + + } + //конец ---------------------------------Проверка соединения--------------------------------------------------- + //конец ---------------------------------Проверка соединения--------------------------------------------------- + //конец ---------------------------------Проверка соединения--------------------------------------------------- + + SystemDelayMs(1000); + } + +} + +void EgtsProcessing_Worker(tEgtsProcessing *env) { + bool oneOn = true; + bool oneOff = true; + uint8_t stepAuth = 1; + + for (;;) { + + if (onOffTelematica(env, &oneOn, &oneOff, "Задача драйвер протокола")) + continue; + + EgtsCompleteResult *result = EgtsCompleteTransportExt(&env->egtsEnv); + + if ((result->completeResult == EGTS_COMPLETE_ERR_VER) || + (result->completeResult == EGTS_COMPLETE_HEADER_ERR_CRC) || + (result->completeResult == EGTS_COMPLETE_BODY_ERR_CRC) || + (result->completeResult == EGTS_COMPLETE_ERR_OVERFLOW)) { + + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка в пакете ЕГТС"); + + + if (result->completeResult == EGTS_COMPLETE_ERR_OVERFLOW) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Переполнение приемного буфера"); + } + if (result->completeResult == EGTS_COMPLETE_ERR_VER) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка номера версии в пакете ЕГТС"); + } + + if (result->completeResult == EGTS_COMPLETE_HEADER_ERR_CRC) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка CRC заголовка в пакете ЕГТС"); + + LoggerFormatInfo(LOGGER, LOG_SIGN, "CRC CALC = 0x%02x, CRC RECEIVED = 0x%02x", result->calcHeaderCrc, + result->receivedHeaderCrc); + + char bufLogHexString[40]; + memset(bufLogHexString, 0, sizeof(bufLogHexString)); + size_t lenLog = 0; + vAsciiStringAddBytesAsHex(bufLogHexString, &lenLog, (uint8_t *) env->wb, 11); + LoggerFormatInfo(LOGGER, LOG_SIGN, "HEADER (%d): %s", 11, bufLogHexString); + + } + + if (result->completeResult == EGTS_COMPLETE_BODY_ERR_CRC) { + LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка CRC тела в пакете ЕГТС"); + + LoggerFormatInfo(LOGGER, LOG_SIGN, "CRC CALC = 0x%04x, CRC RECEIVED = 0x%04x", result->calcBodyCrc, + result->receivedBodyCrc); + +// char bufLogHexString[400]; +// memset(bufLogHexString, 0, sizeof(bufLogHexString)); +// size_t lenLog = 0; +// vAsciiStringAddBytesAsHex(bufLogHexString, &lenLog, (uint8_t *) env->wb, result->fullLength); +// LoggerFormatInfo(LOGGER, LOG_SIGN, "HEADER + BODY (%d): %s", result->fullLength, bufLogHexString); + + } + + + if (env->socketId != SOCKET_WRONG_CONTEXT) { + EgtsProcessingCloseConnection(env); + } + + } + + if (EgtsIsTransportCompleteExt(&env->egtsEnv) == EGTS_COMPLETE_OK) { + + EgtsParseHeaderExt(&env->egtsEnv); + EgtsParseFrameData(&env->egtsEnv); + uint16_t lengthData = EgtsParseSrvRecordExt(&env->egtsEnv, env->egtsEnv.record); + + bool unknownPacket = true; + +// LoggerFormatInfo(LOGGER, LOG_SIGN, "env->egtsEnv.header.type = %u", env->egtsEnv.header.type); +// LoggerFormatInfo(LOGGER, LOG_SIGN, "env->egtsEnv.recSourceService = %u", env->egtsEnv.recSourceService); +// LoggerFormatInfo(LOGGER, LOG_SIGN, "nv->egtsEnv.subRecType = %u", env->egtsEnv.subRecType); + + //начало ---------------------------------Получена квитанция------------------------------------------------ + //начало ---------------------------------Получена квитанция------------------------------------------------ + //начало ---------------------------------Получена квитанция------------------------------------------------ + + if (env->egtsEnv.header.type == EGTS_PT_RESPONSE) { + + //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ----------------------------------------- + //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ----------------------------------------- + //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ----------------------------------------- + + if (env->egtsEnv.recSourceService == EGTS_AUTH_SERVICE) { + + if (env->egtsEnv.subRecType == EGTS_SR_RECORD_RESPONSE) { + if (env->egtsEnv.ptResponse.responsePacketId == env->egtsIdentityAdditionalData.idPacked) { + + tEgtsRecordResponseData *egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData; + + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет (id: %u) подтверждения запроса аутентификации, status: %u RST: %u", + env->egtsEnv.ptResponse.responsePacketId, env->egtsEnv.ptResponse.status, + egtsRecordResponseData->RST); + + unknownPacket = false; + + if ((env->egtsEnv.ptResponse.status == 0) && (egtsRecordResponseData->RST == 0)) + env->egtsIdentityAdditionalData.isReceivedResponse = true; + } else { + unknownPacket = false; + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет подтверждения запроса аутентификации (не верный), id: %u id (ожидаемый): %u", + env->egtsEnv.ptResponse.responsePacketId, + env->egtsIdentityAdditionalData.idPacked); + } + } + + } + + + + //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------ + //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------ + //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------ + + //начало ---------------------------------Сервис ПРОШИВКИ----------------------------------------------- + //начало ---------------------------------Сервис ПРОШИВКИ----------------------------------------------- + //начало ---------------------------------Сервис ПРОШИВКИ----------------------------------------------- + if (env->egtsEnv.recSourceService == EGTS_FIRMWARE_SERVICE) { + if (env->egtsEnv.subRecType == EGTS_SR_RECORD_RESPONSE) { + + if (env->egtsEnv.ptResponse.responsePacketId == + env->egtsIdentityAdditionalData.idPacked) { + + tEgtsRecordResponseData *egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData; + + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет (id: %u) подтверждения запроса прошивки, status: %u RST: %u", + env->egtsEnv.ptResponse.responsePacketId, env->egtsEnv.ptResponse.status, + egtsRecordResponseData->RST); + + unknownPacket = false; + + if ((env->egtsEnv.ptResponse.status == 0) && (egtsRecordResponseData->RST == 0)) + env->egtsIdentityAdditionalData.isReceivedResponse = true; + } else { + unknownPacket = false; + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет подтверждения запроса прошивки (не верный), id: %u id (ожидаемый): %u", + env->egtsEnv.ptResponse.responsePacketId, + env->egtsIdentityAdditionalData.idPacked); + } + + + } + } + //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------ + //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------ + //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------ + + //начало ---------------------------------Сервис ТЕЛЕДАННЫХ--------------------------------------------- + //начало ---------------------------------Сервис ТЕЛЕДАННЫХ--------------------------------------------- + //начало ---------------------------------Сервис ТЕЛЕДАННЫХ--------------------------------------------- + if (env->egtsEnv.recSourceService == EGTS_TELEDATA_SERVICE) { + + if (env->egtsEnv.ptResponse.responsePacketId == env->egtsTeledataAdditionalData.idPacked) { + tEgtsRecordResponseData *egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData; + uint16_t POS_DATA_CRN = egtsRecordResponseData->CRN; + uint8_t POS_DATA_RST = egtsRecordResponseData->RST; + /* + lengthData += EgtsParseSrvRecordExt(&env->egtsEnv, env->egtsEnv.record + lengthData); + egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData; + uint16_t DIG_SENS_CRN = egtsRecordResponseData->CRN; + uint8_t DIG_SENS_RST = egtsRecordResponseData->RST; + + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет подтверждения отправки теледанных, status: %u POS_DATA_RST: %u DIG_SENS_RST: %u", + env->egtsEnv.ptResponse.status, POS_DATA_RST, DIG_SENS_RST); + */ + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет (id: %u) подтверждения отправки теледанных, status: %u POS_DATA_RST: %u", + env->egtsEnv.ptResponse.responsePacketId, env->egtsEnv.ptResponse.status, + POS_DATA_RST); + + unknownPacket = false; + + env->egtsTeledataAdditionalData.isReceivedResponse = true; + } else { + unknownPacket = false; + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет подтверждения отправки теледанных (не верный), id: %u id (ожидаемый): %u", + env->egtsEnv.ptResponse.responsePacketId, + env->egtsIdentityAdditionalData.idPacked); + } + } + //конец ---------------------------------Сервис ТЕЛЕДАННЫХ---------------------------------------------- + //конец ---------------------------------Сервис ТЕЛЕДАННЫХ---------------------------------------------- + //конец ---------------------------------Сервис ТЕЛЕДАННЫХ---------------------------------------------- + + //начало ---------------------------------Сервис КОМАНД------------------------------------------------- + //начало ---------------------------------Сервис КОМАНД------------------------------------------------- + //начало ---------------------------------Сервис КОМАНД------------------------------------------------- + if (env->egtsEnv.recSourceService == EGTS_COMMANDS_SERVICE) { + + if (env->egtsEnv.ptResponse.responsePacketId == + env->egtsCommandConfirmationAdditionalData.idPacked) { + tEgtsRecordResponseData *egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData; + uint16_t POS_DATA_CRN = egtsRecordResponseData->CRN; + uint8_t POS_DATA_RST = egtsRecordResponseData->RST; + + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет (id: %u) подтверждения отправки команды, status: %u POS_DATA_RST: %u", + env->egtsEnv.ptResponse.responsePacketId, env->egtsEnv.ptResponse.status, + POS_DATA_RST); + + unknownPacket = false; + + env->egtsCommandConfirmationAdditionalData.isReceivedResponse = true; + } else { + unknownPacket = false; + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет подтверждения отправки команды (не верный), id: %u id (ожидаемый): %u", + env->egtsEnv.ptResponse.responsePacketId, + env->egtsCommandConfirmationAdditionalData.idPacked); + } + } + //конец ---------------------------------Сервис КОМАНД------------------------------------------------- + //конец ---------------------------------Сервис КОМАНД------------------------------------------------- + //конец ---------------------------------Сервис КОМАНД------------------------------------------------- + + + } + //конец ---------------------------------Получена квитанция------------------------------------------------ + //конец ---------------------------------Получена квитанция------------------------------------------------ + //конец ---------------------------------Получена квитанция------------------------------------------------ + + + //начало ---------------------------------Получены данные--------------------------------------------------- + //начало ---------------------------------Получены данные--------------------------------------------------- + //начало ---------------------------------Получены данные--------------------------------------------------- + if (env->egtsEnv.header.type == EGTS_PT_APPDATA) { + + //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ----------------------------------------- + //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ----------------------------------------- + //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ----------------------------------------- + if (env->egtsEnv.recSourceService == EGTS_AUTH_SERVICE) { + if (env->egtsEnv.subRecType == EGTS_SR_RESULT_CODE) { + + env->egtsIdentityAdditionalData.resultCodeAuth = *((uint8_t *) (env->egtsEnv.subRecData)); + + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Получен пакет результата аутентификации, код: %d", + env->egtsIdentityAdditionalData.resultCodeAuth); + + EgtsProcessing_SendResponse(env, EGTS_AUTH_SERVICE, + EGTS_AUTH_SERVICE, + EGTS_SERVICE_FLAGS_AUTH, + 0, + env->egtsEnv.recordNumber); + + // Ошибка АУТЕНТИФИКАЦИИ + if (env->egtsIdentityAdditionalData.resultCodeAuth == 165) { + + if (stepAuth == 0) { + stepAuth = 1; + + LoggerStrInfoStatic(LOGGER, LOG_SIGN, + "Не корректный сертификат, переход на альтернативный сервер"); +// changeServer(env, 1); + } else { + --stepAuth; + LoggerFormatInfo(LOGGER, LOG_SIGN, + "Не корректный сертификат, переход на альтернативный сервер через %u попыток", + stepAuth); + } + + } else { + stepAuth = 1; + } + + + unknownPacket = false; + env->egtsIdentityAdditionalData.isReceivedResultCode = true; + } + } + //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------ + //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------ + //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------ + + //начало ---------------------------------Сервис КОМАНД------------------------------------------------- + //начало ---------------------------------Сервис КОМАНД------------------------------------------------- + //начало ---------------------------------Сервис КОМАНД------------------------------------------------- + if (env->egtsEnv.recSourceService == EGTS_COMMANDS_SERVICE) { + unknownPacket = false; + + tEgtsCommand egtsCommand; + egtsCommand.cmdType = env->egtsEnv.srCommand->cmdType; + egtsCommand.cmdId = env->egtsEnv.srCommand->cmdId; + egtsCommand.act = env->egtsEnv.srCommand->act; + egtsCommand.cmd = env->egtsEnv.srCommand->cmd; + egtsCommand.dataSize = env->egtsEnv.subRecLength - 15; + + if (egtsCommand.dataSize > 32) + egtsCommand.dataSize = 32; + + memcpy(egtsCommand.data, env->egtsEnv.srCommand->dataPointer, egtsCommand.dataSize); + + EgtsProcessing_SendResponse(env, EGTS_COMMANDS_SERVICE, + EGTS_COMMANDS_SERVICE, + EGTS_SERVICE_FLAGS_COMMAND, + 0, + env->egtsEnv.recordNumber); + + addCommandQueue(env, &egtsCommand); + + } + //конец ---------------------------------Сервис КОМАНД------------------------------------------------- + //конец ---------------------------------Сервис КОМАНД------------------------------------------------- + //конец ---------------------------------Сервис КОМАНД------------------------------------------------- + + //начало --------------------------------Сервис ПРОШИВКИ----------------------------------------------- + //начало --------------------------------Сервис ПРОШИВКИ----------------------------------------------- + //начало --------------------------------Сервис ПРОШИВКИ----------------------------------------------- + if (env->egtsEnv.recSourceService == EGTS_FIRMWARE_SERVICE) { + if (env->egtsEnv.subRecType == EGTS_SR_SERVICE_PART_DATA) { + unknownPacket = false; +// receivedUpdateFirmware(env); + } + } + //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------ + //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------ + //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------ + + } + //конец ---------------------------------Получены данные---------------------------------------------------- + //конец ---------------------------------Получены данные---------------------------------------------------- + //конец ---------------------------------Получены данные---------------------------------------------------- + + + if (unknownPacket) { + uint16_t len = + env->egtsEnv.headerLength + env->egtsEnv.frameDataLength + env->egtsEnv.frameDataSrcLength; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Получен неопознанный пакет:"); + sendLogHex(env, env->egtsEnv.workingBuffer, len); + + } + + EgtsResetBuffer(&env->egtsEnv); + } + + } +} + +_Noreturn void EgtsProcessing_ListenerTask(tEgtsProcessing *env) { + while (1) { + EgtsProcessing_Worker(env); + } +} diff --git a/EgtsProcessing.h b/EgtsProcessing.h new file mode 100644 index 0000000..1d408ef --- /dev/null +++ b/EgtsProcessing.h @@ -0,0 +1,450 @@ +// +// Created by cfif on 21.05.23. +// + +#ifndef SMART_COMPONENTS_EGTSPROCESSING_H +#define SMART_COMPONENTS_EGTSPROCESSING_H + +#include +#include "SocketInterface.h" +#include "stdint.h" +#include "stddef.h" +#include "stdbool.h" +#include "CmsisRtosThreadUtils.h" +#include "egtsWorker.h" +#include "AtCmdBase.h" +#include "GsmWithGnss.h" +#include "LoggerToSerialPort.h" +#include "DeviceStorage.h" +#include "Nmea0183Parser.h" +#include "PointEvent.h" +#include "EraGlonassUveos_Dumper.h" +#include "EgtsTelesataTypes.h" +#include "GpioPinInterface.h" + + +#define AURUS_CHECK_CONNECT 15000 +#define AURUS_CHECK_NAV 5000 +#define AURUS_CHECK_NETWORK_STATUS 30000 + +//начало ---------------------------------ЭБУ------------------------------------------------------------------------- +//начало ---------------------------------ЭБУ------------------------------------------------------------------------- +//начало ---------------------------------ЭБУ------------------------------------------------------------------------- + +#define EBU_STATE_UPDATE 0 +#define EBU_STATE_INIT 0xFFFFFFFF + +#define EBU_COUNT_ITEMS 38 +#define EBU_COUNT_TEST_ITEMS 20 + +typedef enum { + EBU_SDM = 0, + EBU_CGW = 1, + // Info-CAN + EBU_ERAG = 2, + EBU_SVU = 3, + EBU_IC = 4, + EBU_PACU = 5, + EBU_HUD = 6, + // Body-CAN + EBU_PTG = 7, + EBU_TMDTM = 8, + EBU_DMS = 9, + EBU_DMFL = 10, + EBU_DMRL = 11, + EBU_SMFL = 12, + EBU_SMRL = 13, + EBU_VAU = 14, + EBU_BCM = 15, + EBU_APU = 16, + EBU_CCU = 17, + EBU_DMFR = 18, + EBU_DMRR = 19, + EBU_SMFR = 20, + EBU_SMRR = 21, + // DA-CAN + EBU_CDA = 22, + EBU_FCU = 23, + //VMS-CAN + EBU_ACU = 24, + EBU_EPB = 25, + EBU_ESP = 26, + EBU_SCU = 27, + EBU_OCUFL = 28, + EBU_OCURL = 29, + EBU_OCUFR = 30, + EBU_OCURR = 31, + //PT-CAN + EBU_ATC = 32, + EBU_TCU = 33, + EBU_EMS = 34, + EBU_INC = 35, + EBU_DCDC_INC = 36, + EBU_BMS = 37 +} eEgtsEbu; + +typedef enum { + TS_STATUS_DEEP_SLEEP = 0, + TS_STATUS_SLEEP = 1, + TS_STATUS_STANDBY = 2, + TS_STATUS_IGNITION = 3, + TS_STATUS_DRIVE = 4, + TS_STATUS_REMOTE_START = 5, + TS_STATUS_SERVICE_MODE = 6, + TS_STATUS_PREHEATING = 8, + TS_STATUS_COMFORT = 9, + TS_STATUS_MULTIMEDIA = 10, + TS_STATUS_UNKNOWN = 15 +} eEgtsTsStatus; + +typedef struct { + eEgtsEbu ebu; + const char *ebuName; +} tEgtsEbuName; + +typedef enum { + CERTS_STATUS_LOAD = 0, + CERTS_STATUS_UNLOAD = 1, + CERTS_STATUS_ERROR = 2 +} eEgtsCertsStatus; + +typedef enum { + TEST_FIRMWARE = 0, + TEST_IGNITION = 1, + TEST_BAT_CONNECT = 2, + TEST_BAT_CHARGE = 3, + TEST_BAT_VOLTAGE = 4, + TEST_GNSS_ANT = 5, + TEST_SPEAKER_CONNECT = 6, + TEST_BIP_CONNECT = 7, + TEST_ACCEL = 8, + TEST_GSM = 9, + TEST_AUDIO_CODEC = 10, + TEST_VIN = 11, + TEST_ACCEL_CALIB = 12, + TEST_EOL = 13, + TEST_TELE = 14, + TEST_MODEM_SOFT_REV = 15, + TEST_CERT_REV = 16, + TEST_AUDIO_FILE = 17, + TEST_AMPLIFIER = 18, + TEST_SIM_ERA = 19, + TEST_SIM_COMERS = 20, + +} eEgtsTestEbu; + + +typedef struct { + eEgtsTestEbu ebu; + const char *ebuTestName; +} tEgtsEbuTestName; + +typedef struct { + eEgtsEbu ebu; + uint32_t timestamp; +} tEgtsEbuItemState; + +#define VERSION_EBU 3 + +typedef struct { + uint32_t version; + tEgtsEbuItemState ebuItemState[EBU_COUNT_ITEMS]; + uint16_t count; + uint32_t crc; +} tEgtsEbuState; + +//начало ---------------------------------ЭБУ------------------------------------------------------------------------- +//начало ---------------------------------ЭБУ------------------------------------------------------------------------- +//начало ---------------------------------ЭБУ------------------------------------------------------------------------- + +//начало ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ +//начало ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ +//начало ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ + +typedef struct { + uint16_t idPacked; + bool isReceivedResponse; +} tEgtsFirmwareAdditionalData; + +typedef struct { + uint32_t timestamp; + uint16_t idFirmware; + uint16_t partNumber; + uint16_t countNumber; + char module[10]; + + uint8_t bufEbu[1024]; + uint16_t bufLen; +} tEgtsFirmwareDataArgs; + +//конец ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ +//конец ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ +//конец ---------------------------------Прошивка ЭБУ------------------------------------------------------------------ + + +//начало ---------------------------------Аутентификация--------------------------------------------------------------- +//начало ---------------------------------Аутентификация--------------------------------------------------------------- +//начало ---------------------------------Аутентификация--------------------------------------------------------------- + +typedef struct { + uint8_t *IMEI; + uint8_t IMEI_len; + uint32_t TerminalID; +} tEgtsIdentityDataArgs; + +typedef struct { +} tEgtsIdentityModuleDataArgs; + +typedef struct { + uint16_t idPacked; + bool isReceivedResponse; + bool isReceivedResultCode; + uint16_t resultCodeAuth; +} tEgtsIdentityAdditionaData; + +//конец ---------------------------------Аутентификация--------------------------------------------------------------- +//конец ---------------------------------Аутентификация--------------------------------------------------------------- +//конец ---------------------------------Аутентификация--------------------------------------------------------------- + + +//начало ---------------------------------Команды----------------------------------------------------------------------- +//начало ---------------------------------Команды----------------------------------------------------------------------- +//начало ---------------------------------Команды----------------------------------------------------------------------- + +#define COMMAND_QUEUE_SIZE 10 + +typedef struct { + uint16_t ADR; + uint8_t SZ; + uint8_t ACT; + uint16_t CCD; + uint8_t *DT; + uint8_t DT_SIZE; +} tEgtsSrCmdConfirmationExComData; + +typedef struct { + uint8_t CT; + uint8_t CCT; + uint32_t CID; + uint32_t SID; + uint8_t ACFE; + uint8_t CHSFE; + uint8_t CHS; + uint8_t ACL; + uint16_t AC; + tEgtsSrCmdConfirmationExComData CmdData; +} tEgtsCommandConfirmationDataArgs; + +typedef struct { + osMessageQueueId_t queue; + uint16_t idPacked; + bool isReceivedResponse; +} tEgtsCommandConfirmationAdditionalData; + + +typedef struct { + uint8_t cmdType; + uint32_t cmdId; + uint8_t act; + uint16_t cmd; + uint8_t commandConfirmationType; + uint16_t dataSize; + uint8_t data[32]; +} tEgtsCommand; + +//конец ---------------------------------Команды------------------------------------------------------------------------ +//конец ---------------------------------Команды------------------------------------------------------------------------ +//конец ---------------------------------Команды------------------------------------------------------------------------ + +typedef struct { + bool isEbuData; + uint16_t speed; + uint32_t dist; +} tEgtsCanEnv; + +typedef enum { + EGTS_WAIT_0 = 0, + EGTS_WAIT_1 = 1, + EGTS_WAIT_2 = 2 +} eEgtsSendWait; + +typedef struct __attribute__ ((packed)) { + uint32_t SIZE_ROOT_CA; + uint32_t SIZE_CLIENT_KEY; + uint32_t SIZE_CLIENT_CRT; + uint32_t ENC; +} tEgtsCertInfo; + +typedef struct { + uint32_t timeOutCheckTeledata_IGN_TimeUpdate; + uint32_t timeOutCheckTeledata_EM_TimeUpdate; + + uint32_t timeOutCheckTeledata_TimeSpeedUpdate; + + bool isUpdatePoints; + + bool isOneNav; + + bool oneOn; + bool oneOff; + bool isBeginEndNav; + + bool isEVENT_NAVIGATION_START_STOP; + bool isEVENT_ROTATE_ANGLE_LIMIT; + bool isEVENT_DISTANCE; + bool isEVENT_TIMEOUT_ENGINE_OFF; + bool isEVENT_TIMEOUT_ENGINE_ON; + bool isEVENT_EMERGENCY_TRACKING_TIMEOUT; + bool isEVENT_VEH_STATE_CHANGED; + bool isEVENT_MOVEMENT_ON; + bool isEVENT_MOVEMENT_OFF; + + uint16_t beginAngle; + uint16_t beginDist; + +} tEgtsPointEnv; + +typedef struct { + + tSerialPortIO *log; + volatile uint16_t egtsPacketId; + uint16_t counter; + uint8_t socketId; + EgtsWorkerEnvironment egtsEnv; + tLoggerToSerialPort *slog; + + tGpioPin *ignition; + + tEgtsPointEnv egtsPointEnv; + + struct { + uint32_t stopPositionLimitTime; + eCarPosition carPosition; + + tNmeaRmc beginPosition; + tNmeaRmc movePosition; + + bool isTimerMoving; + uint32_t timerMoving; + + uint16_t dataSpeed[4]; + uint16_t dataSpeedStep; + + } carEventPosition; + +// tStaticThreadBlock(1024) T_processing_Network; + tStaticThreadBlock(512) T_processing_input_command; +// tStaticThreadBlock(1024) T_processing_ebu; + tStaticThreadBlock(512) T_processing_event_teledata; + tStaticThreadBlock(512) T_processing_teledata; + tStaticThreadBlock(512) T_processing_main; + tStaticThreadBlock(512) T_listener; + + tStaticThreadBlock(256) T_processing_urc; + +// uint8_t wb[1024 * 10]; + uint8_t wb[1024]; +// uint8_t wb[1024 * 10]; + + + char hexString[1024]; + + tLocationPointInDegDouble *bleLoc; + tGsmWithGnss *gsm; + tRtcIO *rtc; + + // Теледанные + volatile tEgtsTeledataAdditionalData egtsTeledataAdditionalData; + tEgtsTeledata egtsTeledataUveos; // Состояние по запросу от УВЭОС + tEgtsTeledata egtsTeledataSent; // Последнее отправленное состояние + tEgtsTeledata egtsTeledataEdit; // Формируемое состояние + tEgtsTeledata egtsTeledataFix; // Фиксируемое состояние + + // Прошивка модулей ЭБУ + volatile tEgtsFirmwareAdditionalData egtsFirmwareAdditionalData; + tEgtsFirmwareDataArgs egtsFirmwareDataArgs; + +// tEgtsEbuState ebuState; +// bool ebuReady; + + // Аутентификация + volatile tEgtsIdentityAdditionaData egtsIdentityAdditionalData; + tEgtsIdentityDataArgs egtsIdentityDataArgs; + tEgtsIdentityModuleDataArgs egtsModuleDataArgs; + + // Команды + volatile tEgtsCommandConfirmationAdditionalData egtsCommandConfirmationAdditionalData; + tEgtsCommandConfirmationDataArgs egtsCommandConfirmationDataArgs; + tEgtsCommand egtsCommandSent; // Последняя извлеченная команда + + tString32 srvAddr; + uint16_t srvPort; + + tEgtsCanEnv egtsCanEnv; + + uint16_t pPointsStorageSent; + + bool isEnableTelematicaSendPoints; + uint32_t firstStartTimeUpdateEBU; + bool fl_firstStartTimeUpdateEBU; +/* + uint16_t firmwareBufCrc; + uint32_t firmwareOffset; +*/ + tDeviceTeledataStorageData *deviceTeledataStorageData; + tDeviceStorage *store; + + bool rebootFirmware; + + bool isOneEBU; + +/* + int32_t x1; + int32_t y1; + int32_t z1; + int32_t x2; + int32_t y2; + int32_t z2; + uint8_t count_shot; + uint8_t count_free; + uint32_t timeAccelUpdate; +*/ + +} tEgtsProcessing; + +extern tEgtsProcessing egtsProcessing; + +void EgtsProcessing_Init( + tEgtsProcessing *env, + tDeviceStorage *deviceStorage, + tGpioPin *ignition, + tGsmWithGnss *gsm, + tRtcIO *rtcIO, + tLoggerToSerialPort *slog +); + +char *sendLogHex(tEgtsProcessing *env, uint8_t *data, size_t size); + +void EgtsProcessing_Start(tEgtsProcessing *env); + +bool EgtsProcessingSend(tEgtsProcessing *env, uint8_t *egtsRaw, uint16_t egtsRawLength, + eEgtsSendWait wait, volatile bool *wait1, volatile bool *wait2); + +void EgtsProcessingCloseConnection(tEgtsProcessing *env); + +bool isAuth(tEgtsProcessing *env); + +uint8_t findDelimiter(tString32 *address, char ch); + +bool EgtsProcessing_SendResponse(tEgtsProcessing *env, + eEgtsServiceId sourceServiceId, + eEgtsServiceId recipientServiceId, + uint8_t srvFlags, + uint8_t rst, + uint16_t crn); + +bool onOffTelematica(tEgtsProcessing *env, bool *oneOn, bool *oneOff, char *task); + +void receivedUpdateFirmware(tEgtsProcessing *env); + +#endif //SMART_COMPONENTS_EGTSPROCESSING_H diff --git a/EgtsTeledataPoint.c b/EgtsTeledataPoint.c new file mode 100644 index 0000000..ca683e5 --- /dev/null +++ b/EgtsTeledataPoint.c @@ -0,0 +1,796 @@ +// +// Created by cfif on 12.06.2024. +// +#include +#include "EgtsTeledataPoint.h" +#include "string.h" +#include "EgtsOutputCommands.h" +#include "EgtsTimestamp.h" +#include "math.h" +#include "Nmea0183Parser.h" +#include "Rtc.h" +#include "SystemDelayInterface.h" + + +#define LOG_SIGN "EGTS TELE" +#define LOGGER &env->slog->logger + +const tStringStatic textEgtsEventTetedata[] = { + + StringStaticInit("EVENT_TIMEOUT_ENGINE_ON (0) - Наступление таймера при включенном зажигании\0"), + StringStaticInit("EVENT_DISTANCE (1 (Превышение заданного расстояния\0"), + StringStaticInit("EVENT_ROTATE_ANGLE_LIMIT (2) - Превышение заданного курсового угла\0"), + StringStaticInit("EVENT_RESPONSE (3 (Событие по запросу\0"), + StringStaticInit("EVENT_INPUT_CHANGED (4) - Изменение по аналоговым/дискретным входам\0"), + StringStaticInit("EVENT_TIMEOUT_ENGINE_OFF (5) - Наступление таймера при выключенном зажигании\0"), + StringStaticInit("-\0"), + StringStaticInit("EVENT_HI_SPEED_LIMIT (7) - Превышение одного из заданных порогов скорости\0"), + StringStaticInit("EVENT_CPU_RESTART (8) - Событие при старте прибора после перезагрузки по запросу\0"), + StringStaticInit("-\0"), + StringStaticInit("EVENT_TAMPER (10) - Срабатывание датчика вскрытия корпуса\0"), + StringStaticInit("EVENT_EXT_POWER_LOST (11) - Пропадание внешнего питания\0"), + StringStaticInit("EVENT_INT_BATTERY_LOW (12) - Низкий заряд встроенного АКБ\0"), + StringStaticInit("EVENT_ALARM_BUTTON (13) - Нажата кнопка тревоги\0"), + StringStaticInit("EVENT_USER_CALL (14) - Совершен голосовой вызов с устройства\0"), + StringStaticInit("EVENT_EMERGENCY_CALL (15) - Экстренный вызов\0"), + StringStaticInit("EVENT_DATA_FROM_EXT_SERVICE (16) - Данные с внешнего сервиса (в SDM не используется)\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("EVENT_INT_BATTERY_FAIL (19) - Неисправность внутреннего источника питания\0"), + StringStaticInit("EVENT_RAPID_ACCELERATION (20) - Резкий разгон\0"), + StringStaticInit("EVENT_RAPID_DECELERATION (21) - Резкое торможение\0"), + StringStaticInit("EVENT_NAVIGATION_FAIL (22) - Неисправность навигационного модуля\0"), + StringStaticInit("EVENT_ACC_FAIL (23) - Неисправность акселерометра\0"), + StringStaticInit("EVENT_GSM_ANTENNA_FAIL (24) - Неисправность антенны сотовой связи\0"), + StringStaticInit("EVENT_NAV_ANTENNA_FAIL (25) - Неисправность антенны ГНСС\0"), + StringStaticInit("-\0"), + StringStaticInit("EVENT_LOW_SPEED_LIMIT (27) - Снижение ниже одного из заданных порогов скорости\0"), + StringStaticInit("EVENT_MOVEMENT_WITH_ENGINE_OFF (28) - Передвижение при выключенном зажигании\0"), + StringStaticInit("EVENT_EMERGENCY_TRACKING_TIMEOUT (29) - Таймер посылки точек при экстренном слежении\0"), + StringStaticInit("EVENT_NAVIGATION_START_STOP (30) - Событие при начале/окончании навигационного решения\0"), + StringStaticInit("EVENT_NAVIGATION_UNSTABLE (31) - Нестабильная навигация\0"), + StringStaticInit("EVENT_TCP_CONNECTION_START (32) - Событие при установлении соединения с сервером\0"), + StringStaticInit("EVENT_GSM_UNSTABLE (33) - Нестабильная сотовая связь\0"), + StringStaticInit("EVENT_TCP_UNSTABLE (34) - Нестабильное соединение с сервером\0"), + StringStaticInit("EVENT_STATE_CHANGED (35) - Изменение состояния устройства\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("-\0"), + StringStaticInit("EVENT_FIRMWARE_UPDATE (62) - Событие при старте устройства после обновления ПО\0"), + StringStaticInit("EVENT_CHANGE_POS (63) - Событие по изменению местоположения\0"), + StringStaticInit( + "VENT_START_SL_MODE_LOW_LVB (64) - Событие по переходу в режим глубокий сон по низкому напряжению АКБ\0"), + StringStaticInit( + "VENT_START_SL_MODE_ENGINE_OFF (65) - Событие по переходу в режим глубокий сон через заданное время после выключения двигателя\0"), + StringStaticInit( + "EVENT_START_SL_MODE_GSM_OFF (66) - Событие по переходу в глубокий сон при отсутствии связи\0"), + StringStaticInit( + "VENT_EXIT_FROM_SL_MODE_CAN_ON (67) - Событие при выходе из глубокого сна по появлению активности в CAN-шине\0"), + StringStaticInit( + "VENT_EXIT_FROM_SL_MODE_HIGH_POW (68) - Событие при выходе из глубокого сна по появлению высокого напряжения на внешнем АКБ\0"), + StringStaticInit( + "VENT_EXIT_FROM_SL_MODE_TIMEOUT (69) - Событие при выходе из глубокого сна по заданному таймеру\0"), + StringStaticInit("EVENT_GSM_CERTS_UPLOAD (70) - Событие по факту загрузки набора сертификатов\0"), + StringStaticInit("EVENT_EGTS_CONFIG_UPDATED (71) - Событие по факту загрузки файла конфигурации\0"), + StringStaticInit( + "VENT_EXIT_FROM_SL_MODE_ERS (72) - Событие при выходе из глубокого сна для запуска двигателя по расписанию\0"), + StringStaticInit("EVENT_WATCHDOG_RESTART (73) - Событие при старте прибора после перезагрузки по вотчдогу\0"), + StringStaticInit("EVENT_VEH_STATE_CHANGED (74) - Изменение статуса автомобиля\0"), + StringStaticInit("EVENT_DOORS_LOCK_STATE_CHANGED (75) - Изменение статуса замков дверей\0"), + StringStaticInit( + "VENT_VAS_ALARM_STATE_CHANGED (76) - Изменения статуса тревоги системы контроля доступа (сигнализация)\0"), + StringStaticInit("EVENT_LVB_STATE_CHANGED (77) - Изменения статуса внешнего АКБ\0"), + StringStaticInit("EVENT_DOORS_STATE_CHANGED (78) - Изменение статуса дверей и капота\0"), + StringStaticInit("EVENT_CCU_STATE_CHANGED (79) - Изменение статуса климат-контроля\0"), + StringStaticInit("EVENT_TCU_STATE_CHANGED (80) - Изменение статуса КПП\0"), + StringStaticInit("EVENT_REFUELING (81) - Событие заправки топливного бака\0"), + StringStaticInit("EVENT_SEATS_STATE_CHANGED (82) - Событие изменения статуса кресел\0"), + StringStaticInit("EVENT_EXT_POWER_ON (83) - Событие при старте прибора после появления внешнего питания\0"), + StringStaticInit("EVENT_CAN_RECIVE_ON (84) - Событие при появлении активности CAN-шины\0"), + StringStaticInit("EVENT_CAN_RECIVE_OFF (85) - Событие при пропадании активности CAN-шины\0"), + StringStaticInit("EVENT_MOVEMENT_ON (86) - Событие при начале движения\0"), + StringStaticInit("EVENT_MOVEMENT_OFF (87) - Событие при окончании движения\0") +}; + + +void addTeledataQueue(tEgtsProcessing *env, tEgtsTeledata *egtsTeledata) { + + if (!isAuth(env)) { + if ((egtsTeledata->egtsPosDataArgs.SRC != EVENT_EMERGENCY_CALL) && + (egtsTeledata->egtsPosDataArgs.SRC != EVENT_USER_CALL) && + (egtsTeledata->egtsPosDataArgs.SRC != EVENT_VEH_STATE_CHANGED) && + (egtsTeledata->egtsPosDataArgs.SRC != EVENT_ROTATE_ANGLE_LIMIT) && + (egtsTeledata->egtsPosDataArgs.SRC != EVENT_NAVIGATION_START_STOP)) { + + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Соединение с сервером не установлено. Точка не критичная. Сохранение в очередь отменено") + return; + } + } + + osStatus_t status = osMessageQueuePut(env->egtsTeledataAdditionalData.queue, egtsTeledata, 0x0, 0U); + + if (status != osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь addTeledataQueue (1)") + + tEgtsTeledata egtsTeledataStore; + + for (uint8_t i = 0; i < 100; ++i) { + if (extractTeledataQueue(env, &egtsTeledataStore, 1)) { + +// bool result = dumpPointStorage(env, &egtsTeledataStore, false); +// if (!result) + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка при сохранении данных телематики в хранилище (1)") + + } else { + break; + } + } + + status = osMessageQueuePut(env->egtsTeledataAdditionalData.queue, egtsTeledata, 0x0, 0U); + if (status != osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь addTeledataQueue (2)") + } + } + + +} + +void addTeledataQueueEvent(tEgtsProcessing *env, eEgtsEventTetedata egtsTeledataEvent) { + + osStatus_t status = osMessageQueuePut(env->egtsTeledataAdditionalData.queueEvent, &egtsTeledataEvent, 0x0, 0U); + + if (status != osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь addTeledataQueueEvent") + } else { + if (egtsTeledataEvent < 88) { + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[egtsTeledataEvent].data); + } else { + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло неизвестное событие: %u", egtsTeledataEvent); + } + } +} + +bool extractTeledataQueue(tEgtsProcessing *env, tEgtsTeledata *egtsTeledata, uint32_t timeout) { + osStatus_t status = osMessageQueueGet(env->egtsTeledataAdditionalData.queue, egtsTeledata, 0, timeout); + + if ((status != osOK) && (status != osErrorTimeout)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка извлечения из очереди extractTeledataQueue") + } + + if (status == osOK) { + return true; + } + + return false; +} + +bool extractTeledataQueueEvent(tEgtsProcessing *env, eEgtsEventTetedata *egtsTeledataEvent, uint32_t timeout) { + osStatus_t status = osMessageQueueGet(env->egtsTeledataAdditionalData.queueEvent, egtsTeledataEvent, 0, timeout); + + if ((status != osOK) && (status != osErrorTimeout)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка извлечения из очереди extractTeledataQueueEvent") + } + + if (status == osOK) { + return true; + } + + return false; +} + +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 addEventFromUveos(tEgtsProcessing *env, const eEgtsEventTetedata *event) { + time_t timestamp = 0; + + RtcGet(env->gsm->Rtc, ×tamp); + + tNmeaRmc nmeaRmc; + Gnss_GetFullNavData(env->gsm, &nmeaRmc); + + env->egtsTeledataUveos.egtsPosDataArgs.NTM = Egts_EpochTimestampToEgtsTime(timestamp); + + env->egtsTeledataAdditionalData.LAT = nmeaLocationToDeg(nmeaRmc.location.latitude); + env->egtsTeledataAdditionalData.LON = nmeaLocationToDeg(nmeaRmc.location.longitude); + + double lat = (fabs(env->egtsTeledataAdditionalData.LAT) / 90) * 0xFFFFFFFF; + env->egtsTeledataUveos.egtsPosDataArgs.LAT = (uint32_t) lat; + + double lon = (fabs(env->egtsTeledataAdditionalData.LON) / 180) * 0xFFFFFFFF; + env->egtsTeledataUveos.egtsPosDataArgs.LONG = (uint32_t) lon; + + env->egtsTeledataUveos.egtsPosDataArgs.FLG.VLD = (nmeaRmc.status == 'A') ? 1 + : 0; // Битовый флаг, признак «валидности» координатных данных + + env->egtsTeledataUveos.egtsPosDataArgs.FLG.FIX = 0; // битовое поле, тип определения координат + env->egtsTeledataUveos.egtsPosDataArgs.FLG.CS = 0; // битовое поле, тип используемой системы + env->egtsTeledataUveos.egtsPosDataArgs.FLG.BB = 0; // битовый флаг, признак отправки данных из памяти («черный ящик») + env->egtsTeledataUveos.egtsPosDataArgs.FLG.MV = env->carEventPosition.carPosition; // битовый флаг, признак движения + env->egtsTeledataUveos.egtsPosDataArgs.FLG.LAHS = (nmeaRmc.location.nsIndicator == 'S') ? 1 + : 0; // битовый флаг определяет полушарие широты + env->egtsTeledataUveos.egtsPosDataArgs.FLG.LOHS = (nmeaRmc.location.ewIndicator == 'W') ? 1 + : 0; // битовый флаг определяет полушарие долготы + env->egtsTeledataUveos.egtsPosDataArgs.FLG.ALTE = 1; // битовый флаг определяет наличие поля ALT в подзаписи + + uint16_t speed = (uint16_t) (nmeaRmc.knotVelocity * 1.82 * 10); + uint16_t dir = (uint16_t) nmeaRmc.headingAngle; + + env->egtsTeledataUveos.egtsPosDataArgs.SPD.SPD = speed & + 0b0011111111111111; // скорость в км/ч с дискретностью 0,1 км/ч (используется 14 младших бит) + + int32_t alt = GnssGgaGetAlt(env->gsm); + + if (alt >= 0) { + env->egtsTeledataUveos.egtsPosDataArgs.SPD.ALTS = 0; + } else { + env->egtsTeledataEdit.egtsPosDataArgs.SPD.ALTS = 1; + } + + env->egtsTeledataUveos.egtsPosDataArgs.SPD.DIRH = dir >> 8; // направление движения + + env->egtsTeledataUveos.egtsPosDataArgs.DIR = dir; // направление движения + env->egtsTeledataUveos.egtsPosDataArgs.ODM = 0; // пройденное расстояние (пробег) в км, с дискретностью 0,1 км + env->egtsTeledataUveos.egtsPosDataArgs.DIN = 0; // битовые флаги, определяют состояние основных дискретных входов + env->egtsTeledataEdit.egtsPosDataArgs.ALT = abs(alt); + + env->egtsTeledataUveos.egtsPosDataArgs.SRC = *event; // определяет источник (событие) + + // Обновление датчиков + env->egtsTeledataUveos.egtsSensorsAnArgs = env->egtsTeledataEdit.egtsSensorsAnArgs; + env->egtsTeledataUveos.egtsSensorsDigArgs = env->egtsTeledataEdit.egtsSensorsDigArgs; + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сохранение события от УВЭОС") + bool result = dumpPointStorage(env, &env->egtsTeledataUveos, true); + + SystemDelayMs(1500); +} + */ + +_Noreturn void EgtsProcessing_TransmitterTaskTeledata(tEgtsProcessing *env) { + bool oneOn = true; + bool oneOff = true; + + env->pPointsStorageSent = 0; + + for (;;) { + + if (onOffTelematica(env, &oneOn, &oneOff, "Задача отправки")) + continue; + + //начало ---------------------------------Отправка теледанных--------------------------------------------------- + //начало ---------------------------------Отправка теледанных--------------------------------------------------- + //начало ---------------------------------Отправка теледанных--------------------------------------------------- + + if (!isAuth(env)) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание аутентификации на сервере") + SystemDelayMs(1000); + continue; + } +/* + uint32_t countPoints = 1; + + while (countPoints) { + + getPointStorageCount(env, &countPoints); + + if (loadPointStorage(env, &env->egtsTeledataSent)) { + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "В хранилище найдены точки: %d", countPoints) + + if (env->egtsTeledataSent.egtsPosDataArgs.SRC < 88) { + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Событие в хранилище: %s", + textEgtsEventTetedata[env->egtsTeledataSent.egtsPosDataArgs.SRC].data); + } else { + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Неизвестное событие в хранилище: %d", + env->egtsTeledataSent.egtsPosDataArgs.SRC); + } + + // Передача теледанных + if (EgtsProcessing_SendSensors(env, true) == false) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Передача теледанных не удалась") + } else { + ++env->pPointsStorageSent; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Теледанные из хранилища отправлены"); + } + + } else { + env->pPointsStorageSent = 0; + } + + if (!isAuth(env) || (EXT_ENV_TELE.store.runtime->EGTS_FLEET_ON == false)) { + break; + } + + } +*/ + if (!isAuth(env) || (env->store->runtime.EGTS_FLEET_ON == false)) { + continue; + } + + + if (extractTeledataQueue(env, &env->egtsTeledataSent, 1)) { + +/* + // начало --- тест --- + for (int j = 0; j < 10000; ++j) { + + for (int i = 0; i < 7000; ++i) { + if (dumpPointStorage(env, &env->egtsTeledataSent, false) == false) { + asm("nop"); + break; + } + } + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Циклов: %d", j) + + deleteFilePointStorage(env); + asm("nop"); + } + // конец --- тест --- +*/ + + + if (env->egtsTeledataSent.egtsPosDataArgs.SRC < 88) { + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Отправка события: %s", + textEgtsEventTetedata[env->egtsTeledataSent.egtsPosDataArgs.SRC].data); + } else { + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Неизвестное событие: %u", + env->egtsTeledataSent.egtsPosDataArgs.SRC); + + continue; + } +/* + if (!isAuth(env)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Нет регистрации в сети или аутентификации на сервере") + bool result = dumpPointStorage(env, &env->egtsTeledataSent, false); + + if (!result) + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка при сохранении данных телематики в хранилище") + + continue; + } +*/ + // Передача теледанных + if (EgtsProcessing_SendSensors(env, false) == false) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Передача теледанных не удалась") + + +// bool result = dumpPointStorage(env, &env->egtsTeledataSent, false); +// if (!result) +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка при сохранении данных телематики в хранилище") + + } + } + + //конец ---------------------------------Отправка теледанных--------------------------------------------------- + //конец ---------------------------------Отправка теледанных--------------------------------------------------- + //конец ---------------------------------Отправка теледанных--------------------------------------------------- + } + +} + +uint16_t getTotalSpeed(tEgtsProcessing *env, tNmeaRmc *nmeaRmc) { + + uint16_t totalSpeed = 0; + + if (nmeaRmc->status == 'A') + totalSpeed = (uint16_t) (nmeaRmc->knotVelocity * 1.82); + + if (env->egtsCanEnv.isEbuData) { + totalSpeed = env->egtsCanEnv.speed; + } + + return totalSpeed; +} + +uint32_t getTotalDist(tEgtsProcessing *env) { + + return env->egtsCanEnv.dist; + +} + +_Noreturn void EgtsProcessing_EventTaskTeledata(tEgtsProcessing *env) { + + bool isTimestamp = true; + time_t timestamp = 0; + + uint32_t timeTeleOff = 0; + + env->egtsPointEnv.isUpdatePoints = true; + + env->egtsPointEnv.isOneNav = true; + + env->egtsPointEnv.oneOn = true; + env->egtsPointEnv.oneOff = true; + env->egtsPointEnv.isBeginEndNav = false; + + env->egtsPointEnv.beginAngle = 0; + env->egtsPointEnv.beginDist = 0; + + uint32_t timeTimestamp; + + eEgtsTsStatus egtsTsStatus = TS_STATUS_UNKNOWN; + + bool isOneFixMove = true; + + for (;;) { + + if (onOffTelematica(env, &env->egtsPointEnv.oneOn, &env->egtsPointEnv.oneOff, "Задача формирования точек")) { + + if (GpioPinGet(env->ignition)) { + env->egtsPointEnv.timeOutCheckTeledata_IGN_TimeUpdate = + SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_FLEET_IGN_ON_PERIOD * 1000; + } else { + env->egtsPointEnv.timeOutCheckTeledata_IGN_TimeUpdate = + SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_FLEET_IGN_OFF_PERIOD * 1000; + } + + continue; + } + + RtcGet(env->gsm->Rtc, ×tamp); + + if (timestamp < 1718359909) { + + if (timeTimestamp < SystemGetMs()) { + timeTimestamp = SystemGetMs() + 10000; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание получения временной метки") + } + + SystemDelayMs(1000); + continue; + } else { + if (isTimestamp) { + isTimestamp = false; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Временная метка получена") + } + } + + if (!env->isEnableTelematicaSendPoints) { + if (timeTeleOff < SystemGetMs()) { + timeTeleOff = SystemGetMs() + 10000; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание разрешения телематики") + } + SystemDelayMs(1000); + continue; + } + + env->egtsPointEnv.isEVENT_NAVIGATION_START_STOP = false; + env->egtsPointEnv.isEVENT_ROTATE_ANGLE_LIMIT = false; + env->egtsPointEnv.isEVENT_DISTANCE = false; + env->egtsPointEnv.isEVENT_TIMEOUT_ENGINE_OFF = false; + env->egtsPointEnv.isEVENT_TIMEOUT_ENGINE_ON = false; + env->egtsPointEnv.isEVENT_EMERGENCY_TRACKING_TIMEOUT = false; + env->egtsPointEnv.isEVENT_VEH_STATE_CHANGED = false; + + env->egtsPointEnv.isEVENT_MOVEMENT_ON = false; + env->egtsPointEnv.isEVENT_MOVEMENT_OFF = false; + + + eEgtsEventTetedata egtsEventTetedata = EVENT_INVALID_STATE; + + if (extractTeledataQueueEvent(env, &egtsEventTetedata, 1)) { + + } + + tNmeaRmc nmeaRmc; + Gnss_GetFullNavData(env->gsm, &nmeaRmc); + + + //начало-----------------------------Отслеживание угла поворота и начала и окончания навигации------------------ + //начало-----------------------------Отслеживание угла поворота и начала и окончания навигации------------------ + //начало-----------------------------Отслеживание угла поворота и начала и окончания навигации------------------ + + uint16_t totalSpeed = getTotalSpeed(env, &nmeaRmc); + + bool isBeginNav = false; + if ((env->egtsPointEnv.isBeginEndNav == false) && (nmeaRmc.status == 'A')) { + env->egtsPointEnv.isBeginEndNav = true; + isBeginNav = true; + } + + bool isEndNav = false; + if ((env->egtsPointEnv.isBeginEndNav == true) && (nmeaRmc.status != 'A')) { + env->egtsPointEnv.isBeginEndNav = false; + isEndNav = true; + } + + if ((isBeginNav) || (isEndNav)) { + env->egtsPointEnv.isEVENT_NAVIGATION_START_STOP = true; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_NAVIGATION_START_STOP].data); + } + + uint16_t moveAngle = (uint16_t) nmeaRmc.headingAngle; + uint16_t angle = abs(moveAngle - env->egtsPointEnv.beginAngle); + + if (angle > env->deviceTeledataStorageData->telematica.EGTS_FLEET_COURSE_THRESHOLD) { + + env->egtsPointEnv.beginAngle = moveAngle; + + if (totalSpeed > env->deviceTeledataStorageData->telematica.EGTS_GNSS_COURSE_SPEED) { + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Скорость транспортного средства: %d", totalSpeed); + + env->egtsPointEnv.isEVENT_ROTATE_ANGLE_LIMIT = true; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_ROTATE_ANGLE_LIMIT].data); + } + + } + + uint16_t moveDist = getTotalDist(env); + uint16_t dist = abs(moveDist - env->egtsPointEnv.beginDist); + + if (dist > env->deviceTeledataStorageData->telematica.EGTS_FLEET_DIST_THRESHOLD) { + env->egtsPointEnv.beginDist = moveDist; + + env->egtsPointEnv.isEVENT_DISTANCE = true; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_DISTANCE].data); + } + + //конец-----------------------------Отслеживание угла поворота и начала и окончания навигации------------------- + //конец-----------------------------Отслеживание угла поворота и начала и окончания навигации------------------- + //конец-----------------------------Отслеживание угла поворота и начала и окончания навигации------------------- + + // Отслеживание изменение состояния + if (egtsTsStatus != env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_VehicleStatus].value) { + egtsTsStatus = env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_VehicleStatus].value; + env->egtsPointEnv.isEVENT_VEH_STATE_CHANGED = true; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_VEH_STATE_CHANGED].data); + } + + + // Сброс события таймера, если было другое событие + if (((egtsEventTetedata != EVENT_INVALID_STATE) && (egtsEventTetedata != EVENT_EMERGENCY_TRACKING_TIMEOUT)) || + (env->egtsPointEnv.isEVENT_NAVIGATION_START_STOP) || + (env->egtsPointEnv.isEVENT_ROTATE_ANGLE_LIMIT) || + (env->egtsPointEnv.isEVENT_DISTANCE)) { + + if (GpioPinGet(env->ignition)) { + env->egtsPointEnv.timeOutCheckTeledata_IGN_TimeUpdate = + SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_FLEET_IGN_ON_PERIOD * 1000; + } else { + env->egtsPointEnv.timeOutCheckTeledata_IGN_TimeUpdate = + SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_FLEET_IGN_OFF_PERIOD * 1000; + } + } + + // Отслеживание таймеров зажигания + if (GpioPinGet(env->ignition)) { + if (env->egtsPointEnv.timeOutCheckTeledata_IGN_TimeUpdate < SystemGetMs()) { + env->egtsPointEnv.timeOutCheckTeledata_IGN_TimeUpdate = + SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_FLEET_IGN_ON_PERIOD * 1000; + env->egtsPointEnv.isEVENT_TIMEOUT_ENGINE_ON = true; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_TIMEOUT_ENGINE_ON].data); + + } + + } else { + if (env->egtsPointEnv.timeOutCheckTeledata_IGN_TimeUpdate < SystemGetMs()) { + env->egtsPointEnv.timeOutCheckTeledata_IGN_TimeUpdate = + SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_FLEET_IGN_OFF_PERIOD * 1000; + env->egtsPointEnv.isEVENT_TIMEOUT_ENGINE_OFF = true; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_TIMEOUT_ENGINE_OFF].data); + } + + } + + // Отслеживание движения + // CarEventPosition(env, &nmeaRmc, totalSpeed); + + env->egtsPointEnv.isUpdatePoints = false; + + // Если транспортное средство в движении + if (env->carEventPosition.carPosition == CAR_POSITION_MOVE) { + if (isOneFixMove) { + isOneFixMove = false; + env->egtsPointEnv.isEVENT_MOVEMENT_ON = true; + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_MOVEMENT_ON].data); + } + + env->egtsPointEnv.isUpdatePoints = true; + } + + // Отслеживание таймера экстренного слежения + if ((env->carEventPosition.carPosition == CAR_POSITION_MOVE) && + (env->deviceTeledataStorageData->telematica.EGTS_FLEET_EM_MON_PERIOD != 0) && + (env->egtsPointEnv.timeOutCheckTeledata_EM_TimeUpdate < SystemGetMs())) { + + env->egtsPointEnv.timeOutCheckTeledata_EM_TimeUpdate = + SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_FLEET_EM_MON_PERIOD * 1000; + env->egtsPointEnv.isEVENT_EMERGENCY_TRACKING_TIMEOUT = true; + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_EMERGENCY_TRACKING_TIMEOUT].data); + } + + + // Если транспортное средство не в движении + if (env->carEventPosition.carPosition == CAR_POSITION_FIX) { + isOneFixMove = true; + env->egtsPointEnv.isEVENT_MOVEMENT_OFF = true; + env->carEventPosition.carPosition = CAR_POSITION_UNDEFINED; + + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Возникло событие: %s", + textEgtsEventTetedata[EVENT_MOVEMENT_OFF].data); + } + + + if ((egtsEventTetedata != EVENT_INVALID_STATE) || + (env->egtsPointEnv.isEVENT_NAVIGATION_START_STOP) || + (env->egtsPointEnv.isEVENT_ROTATE_ANGLE_LIMIT) || + (env->egtsPointEnv.isEVENT_DISTANCE) || + (env->egtsPointEnv.isEVENT_TIMEOUT_ENGINE_OFF) || + (env->egtsPointEnv.isEVENT_TIMEOUT_ENGINE_ON) || + (env->egtsPointEnv.isEVENT_EMERGENCY_TRACKING_TIMEOUT) || + (env->egtsPointEnv.isEVENT_VEH_STATE_CHANGED) || + (env->egtsPointEnv.isEVENT_MOVEMENT_ON) || + (env->egtsPointEnv.isEVENT_MOVEMENT_OFF) + ) { + + // Первое получение навигации + if (env->egtsPointEnv.isEVENT_NAVIGATION_START_STOP) { + env->egtsPointEnv.isUpdatePoints = true; + } + + if (env->egtsPointEnv.isUpdatePoints) { + + env->egtsTeledataEdit.egtsPosDataArgs.NTM = Egts_EpochTimestampToEgtsTime(timestamp); + + env->egtsTeledataAdditionalData.LAT = nmeaLocationToDeg(nmeaRmc.location.latitude); + env->egtsTeledataAdditionalData.LON = nmeaLocationToDeg(nmeaRmc.location.longitude); + + double lat = (fabs(env->egtsTeledataAdditionalData.LAT) / 90) * 0xFFFFFFFF; + env->egtsTeledataEdit.egtsPosDataArgs.LAT = (uint32_t) lat; + + double lon = (fabs(env->egtsTeledataAdditionalData.LON) / 180) * 0xFFFFFFFF; + env->egtsTeledataEdit.egtsPosDataArgs.LONG = (uint32_t) lon; + + env->egtsTeledataEdit.egtsPosDataArgs.FLG.VLD = (nmeaRmc.status == 'A') ? 1 + : 0; // Битовый флаг, признак «валидности» координатных данных + + env->egtsTeledataEdit.egtsPosDataArgs.FLG.FIX = 0; // битовое поле, тип определения координат + env->egtsTeledataEdit.egtsPosDataArgs.FLG.CS = 0; // битовое поле, тип используемой системы + env->egtsTeledataEdit.egtsPosDataArgs.FLG.BB = 0; // битовый флаг, признак отправки данных из памяти («черный ящик») + env->egtsTeledataEdit.egtsPosDataArgs.FLG.MV = env->carEventPosition.carPosition; // битовый флаг, признак движения + env->egtsTeledataEdit.egtsPosDataArgs.FLG.LAHS = (nmeaRmc.location.nsIndicator == 'S') ? 1 + : 0; // битовый флаг определяет полушарие широты + env->egtsTeledataEdit.egtsPosDataArgs.FLG.LOHS = (nmeaRmc.location.ewIndicator == 'W') ? 1 + : 0; // битовый флаг определяет полушарие долготы + env->egtsTeledataEdit.egtsPosDataArgs.FLG.ALTE = 1; // битовый флаг определяет наличие поля ALT в подзаписи + + uint16_t speed = (uint16_t) (nmeaRmc.knotVelocity * 1.82 * 10); + uint16_t dir = (uint16_t) nmeaRmc.headingAngle; + + env->egtsTeledataEdit.egtsPosDataArgs.SPD.SPD = speed & + 0b0011111111111111; // скорость в км/ч с дискретностью 0,1 км/ч (используется 14 младших бит) + +// int32_t alt = GnssGgaGetAlt(env->gsm); + int32_t alt = 0; + + if (alt >= 0) { + env->egtsTeledataEdit.egtsPosDataArgs.SPD.ALTS = 0; + } else { + env->egtsTeledataEdit.egtsPosDataArgs.SPD.ALTS = 1; + } + + env->egtsTeledataEdit.egtsPosDataArgs.SPD.DIRH = dir >> 8; // направление движения + + env->egtsTeledataEdit.egtsPosDataArgs.DIR = dir; // направление движения + env->egtsTeledataEdit.egtsPosDataArgs.ODM = 0; // пройденное расстояние (пробег) в км, с дискретностью 0,1 км + env->egtsTeledataEdit.egtsPosDataArgs.DIN = 0; // битовые флаги, определяют состояние основных дискретных входов + + env->egtsTeledataEdit.egtsPosDataArgs.ALT = abs(alt); + + // Обновление фиксированное позиции + LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновление фиксированной позиции") + env->egtsTeledataFix = env->egtsTeledataEdit; + + } else { + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Фиксированные координаты. Движение не зафиксировано") + + env->egtsTeledataEdit.egtsPosDataArgs = env->egtsTeledataFix.egtsPosDataArgs; + env->egtsTeledataEdit.egtsPosDataArgs.NTM = Egts_EpochTimestampToEgtsTime(timestamp); + + } + + if (egtsEventTetedata != EVENT_INVALID_STATE) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = egtsEventTetedata; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + if (env->egtsPointEnv.isEVENT_NAVIGATION_START_STOP) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_NAVIGATION_START_STOP; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + if (env->egtsPointEnv.isEVENT_ROTATE_ANGLE_LIMIT) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_ROTATE_ANGLE_LIMIT; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + if (env->egtsPointEnv.isEVENT_DISTANCE) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_DISTANCE; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + if (env->egtsPointEnv.isEVENT_TIMEOUT_ENGINE_OFF) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_TIMEOUT_ENGINE_OFF; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + if (env->egtsPointEnv.isEVENT_TIMEOUT_ENGINE_ON) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_TIMEOUT_ENGINE_ON; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + if (env->egtsPointEnv.isEVENT_MOVEMENT_ON) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_MOVEMENT_ON; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + if (env->egtsPointEnv.isEVENT_EMERGENCY_TRACKING_TIMEOUT) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_EMERGENCY_TRACKING_TIMEOUT; // определяет источник (событие) + + if (nmeaRmc.status != 'A') { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Посылка точек при экстренном слежении не требуется, навигация не валидна") + } else { + addTeledataQueue(env, &env->egtsTeledataEdit); + } + } + + if (env->egtsPointEnv.isEVENT_MOVEMENT_OFF) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_MOVEMENT_OFF; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + if (env->egtsPointEnv.isEVENT_VEH_STATE_CHANGED) { + env->egtsTeledataEdit.egtsPosDataArgs.SRC = EVENT_VEH_STATE_CHANGED; // определяет источник (событие) + addTeledataQueue(env, &env->egtsTeledataEdit); + } + + } + + } +} \ No newline at end of file diff --git a/EgtsTeledataPoint.h b/EgtsTeledataPoint.h new file mode 100644 index 0000000..e6af114 --- /dev/null +++ b/EgtsTeledataPoint.h @@ -0,0 +1,16 @@ +// +// Created by cfif on 12.06.2024. +// + +#ifndef SMART_COMPONENTS_EGTSTELEDATAPOINT_H +#define SMART_COMPONENTS_EGTSTELEDATAPOINT_H +#include "EgtsProcessing.h" + +_Noreturn void EgtsProcessing_TransmitterTaskTeledata(tEgtsProcessing *env); +_Noreturn void EgtsProcessing_EventTaskTeledata(tEgtsProcessing *env); +void addTeledataQueue(tEgtsProcessing *env, tEgtsTeledata *egtsTeledata); +void addTeledataQueueEvent(tEgtsProcessing *env, eEgtsEventTetedata egtsTeledataEvent); +bool extractTeledataQueue(tEgtsProcessing *env, tEgtsTeledata *egtsTeledata, uint32_t timeout); +void addEventFromUveos(tEgtsProcessing *env, const eEgtsEventTetedata *event); + +#endif //SMART_COMPONENTS_EGTSTELEDATAPOINT_H diff --git a/EgtsTelesataTypes.h b/EgtsTelesataTypes.h new file mode 100644 index 0000000..6da4677 --- /dev/null +++ b/EgtsTelesataTypes.h @@ -0,0 +1,99 @@ +// +// Created by cfif on 03.09.2024. +// + +#ifndef SMART_COMPONENTS_TELEMATICA_V2_EGTSTELESATATYPES_H +#define SMART_COMPONENTS_TELEMATICA_V2_EGTSTELESATATYPES_H + +#include "stdint.h" +#include "CmsisRtosThreadUtils.h" +#include "stdbool.h" + +#define TELEDATA_QUEUE_SIZE 20 + +typedef enum { + CAR_POSITION_UNDEFINED = 0, + CAR_POSITION_FIX = 1, + CAR_POSITION_MOVE = 2 +} eCarPosition; + +typedef struct __attribute__ ((packed)) { + uint16_t SPD: 14; + uint8_t ALTS: 1; + uint8_t DIRH: 1; +} tSPD; + +typedef struct __attribute__ ((packed)) { + uint8_t VLD: 1; + uint8_t CS: 1; + uint8_t FIX: 1; + uint8_t BB: 1; + uint8_t MV: 1; + uint8_t LAHS: 1; + uint8_t LOHS: 1; + uint8_t ALTE: 1; +} tFLG; + +typedef struct __attribute__ ((packed)) { + uint8_t state: 4; + uint16_t number: 12; +} tEgtsSensorsDigState; + +typedef struct __attribute__ ((packed)) { + uint8_t number; + uint32_t value: 24; +} tEgtsSensorsAnState; + +typedef struct { + tEgtsSensorsDigState sensorsDigState[1]; +// tEgtsSensorsDigState sensorsDigState[20]; +} tEgtsSensorsDigDataArgs; + + +typedef struct { + tEgtsSensorsAnState sensorsAnState[1]; +// tEgtsSensorsAnState sensorsAnState[25]; +// tEgtsSensorsAnState sensorsAnState[47]; +} tEgtsSensorsAnDataArgs; + +typedef struct __attribute__ ((packed)) { + uint32_t NTM; + uint32_t LAT; + uint32_t LONG; + tFLG FLG; + tSPD SPD; + uint8_t DIR; + uint32_t ODM; + uint8_t DIN; + uint32_t ALT; + uint16_t SRC; +} tEgtsPositionDataArgs; + +typedef struct { + osMessageQueueId_t queue; + osMessageQueueId_t queueEvent; + uint16_t idPacked; + bool isReceivedResponse; + double LAT; + double LON; +} tEgtsTeledataAdditionalData; + +typedef struct { + tEgtsPositionDataArgs egtsPosDataArgs; + tEgtsSensorsDigDataArgs egtsSensorsDigArgs; + tEgtsSensorsAnDataArgs egtsSensorsAnArgs; + uint32_t isValid; + uint32_t crc; +} tEgtsStorageTeledata; + +typedef struct { + tEgtsPositionDataArgs egtsPosDataArgs; + tEgtsSensorsDigDataArgs egtsSensorsDigArgs; + tEgtsSensorsAnDataArgs egtsSensorsAnArgs; +} tEgtsTeledata; + +//конец ---------------------------------Теледанные--------------------------------------------------------------------- +//конец ---------------------------------Теледанные--------------------------------------------------------------------- +//конец ---------------------------------Теледанные--------------------------------------------------------------------- + +#endif //SMART_COMPONENTS_TELEMATICA_V2_EGTSTELESATATYPES_H diff --git a/PointEvent.h b/PointEvent.h new file mode 100644 index 0000000..5120b03 --- /dev/null +++ b/PointEvent.h @@ -0,0 +1,71 @@ +// +// Created by cfif on 03.08.2024. +// + +#ifndef SMART_COMPONENTS_TELEMATICA_POINTEVENT_H +#define SMART_COMPONENTS_TELEMATICA_POINTEVENT_H + +typedef enum { + EVENT_TIMEOUT_ENGINE_ON = 0, + EVENT_DISTANCE = 1, + EVENT_ROTATE_ANGLE_LIMIT = 2, + EVENT_RESPONSE = 3, + EVENT_INPUT_CHANGED = 4, + EVENT_TIMEOUT_ENGINE_OFF = 5, + EVENT_HI_SPEED_LIMIT = 7, + EVENT_CPU_RESTART = 8, + EVENT_TAMPER = 10, + EVENT_EXT_POWER_LOST = 11, + EVENT_INT_BATTERY_LOW = 12, + EVENT_ALARM_BUTTON = 13, + EVENT_USER_CALL = 14, + EVENT_EMERGENCY_CALL = 15, + EVENT_DATA_FROM_EXT_SERVICE = 16, + EVENT_INT_BATTERY_FAIL = 17, + EVENT_RAPID_ACCELERATION = 20, + EVENT_RAPID_DECELERATION = 21, + EVENT_NAVIGATION_FAIL = 22, + EVENT_ACC_FAIL = 23, + EVENT_GSM_ANTENNA_FAIL = 24, + EVENT_NAV_ANTENNA_FAIL = 25, + EVENT_LOW_SPEED_LIMIT = 26, + EVENT_MOVEMENT_WITH_ENGINE_OFF = 28, + EVENT_EMERGENCY_TRACKING_TIMEOUT = 29, + EVENT_NAVIGATION_START_STOP = 30, + EVENT_NAVIGATION_UNSTABLE = 31, + EVENT_TCP_CONNECTION_START = 32, + EVENT_GSM_UNSTABLE = 33, + EVENT_TCP_UNSTABLE = 34, + EVENT_STATE_CHANGED = 35, + EVENT_FIRMWARE_UPDATE = 62, + EVENT_CHANGE_POS = 63, + EVENT_START_SL_MODE_LOW_LVB = 64, + EVENT_START_SL_MODE_ENGINE_OFF = 65, + EVENT_START_SL_MODE_GSM_OFF = 66, + EVENT_EXIT_FROM_SL_MODE_CAN_ON = 67, + EVENT_EXIT_FROM_SL_MODE_HIGH_POW = 68, + EVENT_EXIT_FROM_SL_MODE_TIMEOUT = 69, + EVENT_GSM_CERTS_UPLOAD = 70, + EVENT_EGTS_CONFIG_UPDATED = 71, + EVENT_EXIT_FROM_SL_MODE_ERS = 72, + EVENT_WATCHDOG_RESTART = 73, + EVENT_VEH_STATE_CHANGED = 74, + EVENT_DOORS_LOCK_STATE_CHANGED = 75, + EVENT_VAS_ALARM_STATE_CHANGED = 76, + EVENT_LVB_STATE_CHANGED = 77, + EVENT_DOORS_STATE_CHANGED = 78, + EVENT_CCU_STATE_CHANGED = 79, + EVENT_TCU_STATE_CHANGED = 80, + EVENT_REFUELING = 81, + EVENT_SEATS_STATE_CHANGED = 82, + EVENT_EXT_POWER_ON = 83, + EVENT_CAN_RECIVE_ON = 84, + EVENT_CAN_RECIVE_OFF = 85, + EVENT_MOVEMENT_ON = 86, + EVENT_MOVEMENT_OFF = 87, + + EVENT_INVALID_STATE = 255 + +} eEgtsEventTetedata; + +#endif //SMART_COMPONENTS_TELEMATICA_POINTEVENT_H diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..68a98d4 --- /dev/null +++ b/modular.json @@ -0,0 +1,18 @@ +{ + "dep": [ + { + "type": "git", + "provider": "NAVIGATOR_UVEOS_NATION_TELIT", + "repo": "Legacy_EgtsEncoderDecoder" + } + ], + "cmake": { + "inc_dirs": [ + "./" + ], + "srcs": [ + "./**.c" + ] + } +} +