From d0d4685518d6244d2eb8453963294c85e765da15 Mon Sep 17 00:00:00 2001 From: cfif Date: Wed, 4 Dec 2024 13:10:48 +0300 Subject: [PATCH] Init --- EgtsInputCommands.c | 164 +++++++ EgtsInputCommands.h | 49 ++ EgtsOutputCommands.c | 604 ++++++++++++++++++++++++ EgtsOutputCommands.h | 145 ++++++ EgtsProcessing.c | 1061 ++++++++++++++++++++++++++++++++++++++++++ EgtsProcessing.h | 450 ++++++++++++++++++ EgtsTeledataPoint.c | 796 +++++++++++++++++++++++++++++++ EgtsTeledataPoint.h | 16 + EgtsTelesataTypes.h | 99 ++++ PointEvent.h | 71 +++ modular.json | 18 + 11 files changed, 3473 insertions(+) create mode 100644 EgtsInputCommands.c create mode 100644 EgtsInputCommands.h create mode 100644 EgtsOutputCommands.c create mode 100644 EgtsOutputCommands.h create mode 100644 EgtsProcessing.c create mode 100644 EgtsProcessing.h create mode 100644 EgtsTeledataPoint.c create mode 100644 EgtsTeledataPoint.h create mode 100644 EgtsTelesataTypes.h create mode 100644 PointEvent.h create mode 100644 modular.json 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" + ] + } +} +