1808 lines
79 KiB
C
1808 lines
79 KiB
C
//
|
||
// Created by cfif on 21.05.23.
|
||
//
|
||
|
||
#include <egts.h>
|
||
#include <SystemDelayInterface.h>
|
||
#include <Nmea0183Parser.h>
|
||
#include <time.h>
|
||
#include <egtsWorker.h>
|
||
#include <AsciiStringAssmeblingUtils.h>
|
||
#include <Rtc.h>
|
||
#include "EgtsProcessing.h"
|
||
#include "stddef.h"
|
||
#include "AtGsm_GetTime.h"
|
||
#include "EgtsInputCommands.h"
|
||
#include "EgtsOutputCommands.h"
|
||
#include "CarPositionUpdate.h"
|
||
#include "egtsWorkerExt.h"
|
||
#include "LoggerToSerialPort.h"
|
||
#include "string.h"
|
||
#include "AtGsmSimComA7600_SSL_LOAD_CA.h"
|
||
#include "Certs.h"
|
||
#include "FirmwareLoader.h"
|
||
#include "EgtsTeledataPoint.h"
|
||
#include "GsmWithGnss_Info.h"
|
||
#include "EgtsEbu.h"
|
||
#include "Network.h"
|
||
#include "AtGsm_NetworkRegistrationStatus.h"
|
||
#include "egts.h"
|
||
#include "AtGsmOperatorSelection.h"
|
||
#include "ext_telematica.h"
|
||
#include "lfs_file_utils.h"
|
||
#include "ld_adr.h"
|
||
#include "SerialPortCanComInt.h"
|
||
#include "AtGsmSimcomSim7600.h"
|
||
|
||
|
||
#define LOG_SIGN "EGTS"
|
||
#define LOGGER &env->slog->logger
|
||
|
||
bool onOffTelematica(tEgtsProcessing *env, bool *oneOn, bool *oneOff, char *task) {
|
||
|
||
if (EXT_ENV_TELE.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->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;
|
||
}
|
||
|
||
eEgtsCertsStatus changeServer(tEgtsProcessing *env, uint8_t numberServer) {
|
||
tIsFind check;
|
||
memset(&check, 0, sizeof(check));
|
||
|
||
env->numberServer = numberServer;
|
||
|
||
|
||
if (osMutexAcquire(env->gsm->gsmAt->access, 30000) == osOK) {
|
||
|
||
if (numberServer == 0) {
|
||
|
||
env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data[env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length] = '\0';
|
||
uint8_t pos = findDelimiter(&env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS, ':');
|
||
String32Copy(&env->srvAddr,
|
||
env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data,
|
||
pos);
|
||
env->srvPort = atoi(&env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data[pos + 1]);
|
||
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Установка сервера: %s",
|
||
env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data);
|
||
|
||
|
||
env->clientType = eAtGsmSimComA7600_SslType_TCP;
|
||
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_SERVER_SSL_ENABLE) {
|
||
|
||
env->clientType = eAtGsmSimComA7600_SslType_TLS;
|
||
|
||
check = AtGsmSimComA7600_SSL_CHECK_CA(env->gsm->gsmAt,
|
||
file_ca, strlen(file_ca),
|
||
file_crt, strlen(file_crt),
|
||
file_key, strlen(file_key), 2000);
|
||
|
||
|
||
if ((!check.isFind1) || (!check.isFind2) || (!check.isFind3)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ключи аутентификации не загружены")
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_UNLOAD;
|
||
}
|
||
/*
|
||
if (isCertTest() == false) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ключи аутентификации не загружены")
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_UNLOAD;
|
||
}
|
||
*/
|
||
|
||
if (AtGsmSimComA7600_SSL_CfgContext(env->gsm->gsmAt, eAtGsmSimComA7600_SslCfgType_STR,
|
||
"cacert", sizeof("cacert") - 1, 2,
|
||
(char *) file_ca, strlen(file_ca)) != AT_OK) {
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_ERROR;
|
||
}
|
||
|
||
if (AtGsmSimComA7600_SSL_CfgContext(env->gsm->gsmAt, eAtGsmSimComA7600_SslCfgType_STR,
|
||
"clientcert", sizeof("clientcert") - 1, 2,
|
||
(char *) file_crt, strlen(file_crt)) != AT_OK) {
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_ERROR;
|
||
}
|
||
|
||
if (AtGsmSimComA7600_SSL_CfgContext(env->gsm->gsmAt, eAtGsmSimComA7600_SslCfgType_STR,
|
||
"clientkey", sizeof("clientkey") - 1, 2,
|
||
(char *) file_key, strlen(file_key)) != AT_OK) {
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_ERROR;
|
||
}
|
||
|
||
if (AtGsmSimComA7600_SSL_CfgContext(env->gsm->gsmAt, eAtGsmSimComA7600_SslCfgType_INT,
|
||
"ciphersuites", sizeof("ciphersuites") - 1, 2,
|
||
"0xFFFF", sizeof("0xFFFF") - 1) != AT_OK) {
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_ERROR;
|
||
}
|
||
|
||
if (AtGsmSimComA7600_SSL_CfgContext(env->gsm->gsmAt, eAtGsmSimComA7600_SslCfgType_INT,
|
||
"authmode", sizeof("authmode") - 1, 2,
|
||
"2", sizeof("2") - 1) != AT_OK) {
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_ERROR;
|
||
}
|
||
|
||
AtGsmSimComA7600_PdpActivate(env->gsm->gsmAt, 1);
|
||
|
||
|
||
AtGsmSimComA7600_DefinePdpAuthContext(env->gsm->gsmAt, 1, 1,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_PASS.data,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_PASS.length,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_USER.data,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_USER.length);
|
||
|
||
|
||
AtGsmSimComA7600_DefinePdpContext(env->gsm->gsmAt, 1, AtGsmSimComA7600_PdpType_IP,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.data,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.length);
|
||
|
||
AtGsmSimComA7600_PdpActivate(env->gsm->gsmAt, 1);
|
||
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_LOAD;
|
||
|
||
} else {
|
||
|
||
AtGsmSimComA7600_PdpActivate(env->gsm->gsmAt, 1);
|
||
AtGsmSimComA7600_DefinePdpContext(env->gsm->gsmAt, 1, AtGsmSimComA7600_PdpType_IP,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.data,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.length);
|
||
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_LOAD;
|
||
}
|
||
|
||
|
||
} else {
|
||
|
||
env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.data[env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.length] = '\0';
|
||
uint8_t pos = findDelimiter(&env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS, ':');
|
||
String32Copy(&env->srvAddr,
|
||
env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.data,
|
||
pos);
|
||
env->srvPort = atoi(&env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.data[pos + 1]);
|
||
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Установка сервера: %s",
|
||
env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.data);
|
||
|
||
|
||
env->clientType = eAtGsmSimComA7600_SslType_TCP;
|
||
|
||
AtGsmSimComA7600_PdpActivate(env->gsm->gsmAt, 1);
|
||
AtGsmSimComA7600_DefinePdpContext(env->gsm->gsmAt, 1, AtGsmSimComA7600_PdpType_IP,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.data,
|
||
env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.length);
|
||
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
return CERTS_STATUS_LOAD;
|
||
|
||
|
||
}
|
||
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (changeServer)")
|
||
|
||
return CERTS_STATUS_ERROR;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
bool checkEbuFile(tEgtsProcessing *env, char *filename, uint32_t size) {
|
||
int lfs_err;
|
||
lfs_file_t file;
|
||
|
||
if (size <= 4) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Ошибка размера файла, удаление файла: %s", filename)
|
||
lfs_err = lfs_remove(&env->fs->lfs, filename);
|
||
return false;
|
||
}
|
||
|
||
lfs_err = lfs_file_open(&env->fs->lfs, &file, filename, LFS_O_RDONLY);
|
||
lfs_err = lfs_file_rewind(&env->fs->lfs, &file);
|
||
int reading = lfs_file_read(&env->fs->lfs, &file, env->wb, size);
|
||
|
||
uint32_t crc = *(uint32_t *) &env->wb[size - 4];
|
||
|
||
uint32_t crcCalc = lfs_crc(0, env->wb, size - 4);
|
||
|
||
lfs_err = lfs_file_close(&env->fs->lfs, &file);
|
||
|
||
if (crc != crcCalc) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Ошибка CRC файла, удаление файла: %s", filename)
|
||
lfs_err = lfs_remove(&env->fs->lfs, filename);
|
||
return false;
|
||
}
|
||
|
||
uint32_t versionEbu = *(uint32_t *) env->wb;
|
||
if (VERSION_EBU != versionEbu) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Не совпала версия файла, удаление файла: %s", filename)
|
||
lfs_err = lfs_remove(&env->fs->lfs, filename);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void EgtsProcessing_Init(
|
||
tEgtsProcessing *env,
|
||
tGsmWithGnss *gsm,
|
||
tRtcIO *rtcIO,
|
||
tLittleFileFs *fs,
|
||
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->fs = fs;
|
||
env->ebuReady = false;
|
||
|
||
env->TelematicaServerNotActiveWaitTime = 0;
|
||
|
||
env->rtc = rtcIO;
|
||
|
||
env->isEnableTelematicaSendPoints = false;
|
||
env->rebootFirmware = false;
|
||
env->egtsPacketId = 0;
|
||
|
||
env->egtsCanEnv.isEbuData = false;
|
||
|
||
env->fl_firstStartTimeUpdateEBU = false;
|
||
|
||
env->deviceTeledataStorageData = (tDeviceTeledataStorageData *) EXT_ENV_TELE.store.dataTeledata;
|
||
|
||
env->isOneEBU = false;
|
||
|
||
env->SENSORS_AN_MinutesOfTravel_gl = 0;
|
||
|
||
CarEventResetPosition(env);
|
||
|
||
EgtsProcessing_Default_SendSensorsDig(env);
|
||
EgtsProcessing_Default_SendSensorsAn(env);
|
||
|
||
|
||
uint32_t SENSORS_AN_NumberTrip_loc = 0;
|
||
|
||
for (uint8_t i = 0; i < 24; ++i) {
|
||
uint32_t bit = EXT_ENV_TELE.vccIo->get(EXT_ENV_TELE.vccIo->env, 5) & 1;
|
||
SENSORS_AN_NumberTrip_loc |= (bit << i);
|
||
}
|
||
|
||
if (SENSORS_AN_NumberTrip_loc == 0) {
|
||
|
||
time_t timestamp;
|
||
RtcGet(rtcIO, ×tamp);
|
||
|
||
SENSORS_AN_NumberTrip_loc = (uint32_t) timestamp;
|
||
}
|
||
|
||
if (SENSORS_AN_NumberTrip_loc == 0) {
|
||
SENSORS_AN_NumberTrip_loc = 1;
|
||
}
|
||
|
||
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_NumberTrip].value = SENSORS_AN_NumberTrip_loc;
|
||
|
||
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);
|
||
|
||
memset(&env->egtsTeledataEdit.egtsExtPositionDataArgs, 0, sizeof(tEgtsExtPositionDataArgs));
|
||
env->egtsTeledataEdit.egtsExtPositionDataArgs.FLG.NSFE = 1;
|
||
env->egtsTeledataEdit.egtsExtPositionDataArgs.FLG.SFE = 1;
|
||
|
||
int lfs_err;
|
||
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Сканирование файловой системы:");
|
||
|
||
struct lfs_info info;
|
||
lfs_dir_t dir;
|
||
|
||
lfs_err = lfs_dir_open(&env->fs->lfs, &dir, "");
|
||
lfs_err = lfs_dir_rewind(&env->fs->lfs, &dir);
|
||
|
||
bool isEbuFileCheck = false;
|
||
|
||
while (lfs_dir_read(&env->fs->lfs, &dir, &info) > 0) {
|
||
if (info.name[0] == '.')
|
||
continue;
|
||
|
||
if (info.type == LFS_TYPE_DIR) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Директория: %s", info.name);
|
||
|
||
lfs_err = lfs_remove(&env->fs->lfs, info.name);
|
||
/*
|
||
struct lfs_info sub_dir_info;
|
||
lfs_dir_t sub_dir;
|
||
|
||
lfs_err = lfs_dir_open(&env->fs->lfs, &sub_dir, info.name);
|
||
lfs_err = lfs_dir_rewind(&env->fs->lfs, &sub_dir);
|
||
|
||
while (lfs_dir_read(&env->fs->lfs, &sub_dir, &sub_dir_info) > 0) {
|
||
if (sub_dir_info.name[0] == '.')
|
||
continue;
|
||
|
||
char filename[32];
|
||
|
||
filename[0] = '\0';
|
||
strcat(filename, info.name);
|
||
strcat(filename, "/");
|
||
strcat(filename, sub_dir_info.name);
|
||
|
||
if (checkFile(env, filename, sub_dir_info.size)) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, " Файл: %s - OK", sub_dir_info.name);
|
||
} else {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, " Файл: %s - ERROR", sub_dir_info.name);
|
||
}
|
||
}
|
||
|
||
lfs_err = lfs_dir_close(&env->fs->lfs, &sub_dir);
|
||
*/
|
||
} else {
|
||
|
||
if (memcmp(info.name, "points.bin", sizeof("points.bin") - 1) == 0) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Файл точек: %s - OK", info.name);
|
||
} else if (memcmp(info.name, "ebu.bin", sizeof("ebu.bin") - 1) == 0) {
|
||
|
||
if (checkEbuFile(env, info.name, info.size)) {
|
||
isEbuFileCheck = true;
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Файл настроек ЭБУ: %s - OK", info.name);
|
||
} else {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Файл настроек ЭБУ: %s - ОШИБКА (удален)", info.name);
|
||
}
|
||
|
||
} else {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Файл неизвестен: %s - УДАЛЕН", info.name);
|
||
lfs_err = lfs_remove(&env->fs->lfs, info.name);
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
if (!isEbuFileCheck) {
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Файл точек: points.bin - УДАЛЕН");
|
||
lfs_err = lfs_remove(&env->fs->lfs, "points.bin");
|
||
}
|
||
|
||
lfs_dir_close(&env->fs->lfs, &dir);
|
||
|
||
/*
|
||
int lfs_err = lfs_mkdir(&env->fs->lfs, "points");
|
||
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Сканирование файловой системы:");
|
||
|
||
struct lfs_info info;
|
||
lfs_dir_t dir;
|
||
|
||
lfs_err = lfs_dir_open(&env->fs->lfs, &dir, "");
|
||
lfs_err = lfs_dir_rewind(&env->fs->lfs, &dir);
|
||
|
||
while (lfs_dir_read(&env->fs->lfs, &dir, &info) > 0) {
|
||
if (info.name[0] == '.')
|
||
continue;
|
||
|
||
if (info.type == LFS_TYPE_DIR) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Директория: %s", info.name);
|
||
|
||
struct lfs_info sub_dir_info;
|
||
lfs_dir_t sub_dir;
|
||
|
||
lfs_err = lfs_dir_open(&env->fs->lfs, &sub_dir, info.name);
|
||
lfs_err = lfs_dir_rewind(&env->fs->lfs, &sub_dir);
|
||
|
||
while (lfs_dir_read(&env->fs->lfs, &sub_dir, &sub_dir_info) > 0) {
|
||
if (sub_dir_info.name[0] == '.')
|
||
continue;
|
||
|
||
char filename[32];
|
||
|
||
filename[0] = '\0';
|
||
strcat(filename, info.name);
|
||
strcat(filename, "/");
|
||
strcat(filename, sub_dir_info.name);
|
||
|
||
if (checkFile(env, filename, sub_dir_info.size)) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, " Файл: %s - OK", sub_dir_info.name);
|
||
} else {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, " Файл: %s - ERROR", sub_dir_info.name);
|
||
}
|
||
}
|
||
|
||
lfs_err = lfs_dir_close(&env->fs->lfs, &sub_dir);
|
||
|
||
} else {
|
||
if (checkFile(env, info.name, info.size)) {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Файл: %s - OK", info.name);
|
||
} else {
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Файл: %s - ERROR", info.name);
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
lfs_dir_close(&env->fs->lfs, &dir);
|
||
*/
|
||
|
||
SystemMutexCmsis_init(&env->accessEbu, NULL);
|
||
loadEbuTable(env);
|
||
|
||
// setBufEbu(env);
|
||
|
||
|
||
eCanBaudRate can1BaudRate = CAN_BAUD_RATE_500K;
|
||
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_UNIT_CAN1_BAUD_RATE == 125000)
|
||
can1BaudRate = CAN_BAUD_RATE_125K;
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_UNIT_CAN1_BAUD_RATE == 500000)
|
||
can1BaudRate = CAN_BAUD_RATE_500K;
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_UNIT_CAN1_BAUD_RATE == 250000)
|
||
can1BaudRate = CAN_BAUD_RATE_250K;
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_UNIT_CAN1_BAUD_RATE == 100000)
|
||
can1BaudRate = CAN_BAUD_RATE_1000K;
|
||
|
||
eCanBaudRate canBaudRate;
|
||
EXT_ENV_TELE.CanPort_GetSpeed(CAN1, &canBaudRate);
|
||
|
||
if (canBaudRate != can1BaudRate) {
|
||
EXT_ENV_TELE.CanPort_SetSpeed(CAN1, can1BaudRate);
|
||
}
|
||
|
||
eCanBaudRate can2BaudRate = CAN_BAUD_RATE_500K;
|
||
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_UNIT_CAN2_BAUD_RATE == 125000)
|
||
can2BaudRate = CAN_BAUD_RATE_125K;
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_UNIT_CAN2_BAUD_RATE == 500000)
|
||
can1BaudRate = CAN_BAUD_RATE_500K;
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_UNIT_CAN2_BAUD_RATE == 250000)
|
||
can2BaudRate = CAN_BAUD_RATE_250K;
|
||
if (env->deviceTeledataStorageData->telematica.EGTS_UNIT_CAN2_BAUD_RATE == 100000)
|
||
can2BaudRate = CAN_BAUD_RATE_1000K;
|
||
|
||
EXT_ENV_TELE.CanPort_GetSpeed(CAN2, &canBaudRate);
|
||
|
||
if (canBaudRate != can2BaudRate) {
|
||
EXT_ENV_TELE.CanPort_SetSpeed(CAN2, can2BaudRate);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
can_filter_init_type can_filter0_init_struct;
|
||
can_filter_init_type can_filter1_init_struct;
|
||
|
||
can_filter0_init_struct.filter_activate_enable = TRUE;
|
||
can_filter0_init_struct.filter_mode = CAN_FILTER_MODE_ID_MASK;
|
||
can_filter0_init_struct.filter_fifo = CAN_FILTER_FIFO0;
|
||
can_filter0_init_struct.filter_number = 0;
|
||
can_filter0_init_struct.filter_bit = CAN_FILTER_32BIT;
|
||
can_filter0_init_struct.filter_id_high = 0x380 << 5;
|
||
can_filter0_init_struct.filter_id_low = 0;
|
||
can_filter0_init_struct.filter_mask_high = 0x7FF << 5;
|
||
can_filter0_init_struct.filter_mask_low = 0;
|
||
|
||
can_filter1_init_struct.filter_activate_enable = TRUE;
|
||
can_filter1_init_struct.filter_mode = CAN_FILTER_MODE_ID_MASK;
|
||
can_filter1_init_struct.filter_fifo = CAN_FILTER_FIFO1;
|
||
can_filter1_init_struct.filter_number = 1;
|
||
can_filter1_init_struct.filter_bit = CAN_FILTER_32BIT;
|
||
can_filter1_init_struct.filter_id_high =0x3e8 << 5;
|
||
can_filter1_init_struct.filter_id_low = 0;
|
||
can_filter1_init_struct.filter_mask_high = 0x7FF << 5;
|
||
can_filter1_init_struct.filter_mask_low = 0;
|
||
|
||
EXT_ENV_TELE.CanPort_SetFilter(CAN2, &can_filter0_init_struct, &can_filter1_init_struct);
|
||
*/
|
||
|
||
can_filter_init_type can_filter0_init_struct;
|
||
can_filter_init_type can_filter1_init_struct;
|
||
/*
|
||
can_filter0_init_struct.filter_activate_enable = TRUE;
|
||
can_filter0_init_struct.filter_mode = CAN_FILTER_MODE_ID_MASK;
|
||
can_filter0_init_struct.filter_fifo = CAN_FILTER_FIFO0;
|
||
can_filter0_init_struct.filter_number = 0;
|
||
can_filter0_init_struct.filter_bit = CAN_FILTER_32BIT;
|
||
can_filter0_init_struct.filter_id_high = 0x7ca << 5;
|
||
can_filter0_init_struct.filter_id_low = 0;
|
||
can_filter0_init_struct.filter_mask_high = 0x7FF << 5;
|
||
can_filter0_init_struct.filter_mask_low = 0;
|
||
*/
|
||
can_filter0_init_struct.filter_activate_enable = TRUE;
|
||
can_filter0_init_struct.filter_mode = CAN_FILTER_MODE_ID_MASK;
|
||
can_filter0_init_struct.filter_fifo = CAN_FILTER_FIFO0;
|
||
can_filter0_init_struct.filter_number = 0;
|
||
can_filter0_init_struct.filter_bit = CAN_FILTER_32BIT;
|
||
can_filter0_init_struct.filter_id_high = 0x700 << 5;
|
||
can_filter0_init_struct.filter_id_low = 0;
|
||
can_filter0_init_struct.filter_mask_high = 0x700 << 5;
|
||
can_filter0_init_struct.filter_mask_low = 0;
|
||
|
||
can_filter1_init_struct.filter_activate_enable = TRUE;
|
||
can_filter1_init_struct.filter_mode = CAN_FILTER_MODE_ID_MASK;
|
||
can_filter1_init_struct.filter_fifo = CAN_FILTER_FIFO1;
|
||
can_filter1_init_struct.filter_number = 1;
|
||
can_filter1_init_struct.filter_bit = CAN_FILTER_32BIT;
|
||
can_filter1_init_struct.filter_id_high = 0;
|
||
can_filter1_init_struct.filter_id_low = 0;
|
||
can_filter1_init_struct.filter_mask_high = 0;
|
||
can_filter1_init_struct.filter_mask_low = 0;
|
||
|
||
EXT_ENV_TELE.CanPort_SetFilter(CAN2, &can_filter0_init_struct, &can_filter1_init_struct);
|
||
|
||
|
||
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);
|
||
|
||
SystemMutexCmsis_init(&env->txCanAccessQueue, NULL);
|
||
|
||
CanMain_Init(
|
||
&env->CanMain,
|
||
env->deviceTeledataStorageData,
|
||
EXT_ENV_TELE.Can2_IO,
|
||
env->txCanAccessQueue,
|
||
EXT_ENV_TELE.testsTable,
|
||
env->slog,
|
||
&env->rawAccel,
|
||
&env->egtsTeledataEdit
|
||
);
|
||
|
||
CanMainMute_Init(
|
||
&env->CanMainMute,
|
||
EXT_ENV_TELE.Can2_IO,
|
||
env->txCanAccessQueue,
|
||
env->gsm,
|
||
env->slog
|
||
);
|
||
|
||
vSerialPortCanComInit(&env->tSerialPortCanComInt,
|
||
EXT_ENV_TELE.Can2_IO,
|
||
256);
|
||
|
||
env->serialPortCanComIntIO = vSerialPortCanComIntGetIo(&env->tSerialPortCanComInt);
|
||
|
||
CanMainAdditional_Init(
|
||
&env->CanMainAdditional,
|
||
EXT_ENV_TELE.Can2_IO,
|
||
&env->tSerialPortCanComInt,
|
||
&env->CanMainMute,
|
||
env->txCanAccessQueue,
|
||
EXT_ENV_TELE.testsTable,
|
||
env->slog,
|
||
&env->rawAccel,
|
||
&env->egtsTeledataEdit,
|
||
&env->ebuState,
|
||
env->accessEbu,
|
||
&env->CanMain,
|
||
env,
|
||
&env->isEnableTelematicaSendPoints
|
||
);
|
||
|
||
|
||
CanMainTest_Init(
|
||
&env->CanMainTest,
|
||
EXT_ENV_TELE.Can1_IO,
|
||
env->slog
|
||
);
|
||
|
||
}
|
||
|
||
void EgtsProcessing_Start(tEgtsProcessing *env) {
|
||
|
||
ThreadBlock_Start(env->T_processing_Network, env, EgtsProcessing_InfoTask);
|
||
|
||
ThreadBlock_Start(env->T_processing_input_command, env, EgtsProcessing_TransmitterTaskInputCommand);
|
||
ThreadBlock_Start(env->T_processing_ebu, env, EgtsProcessing_TransmitterTaskEbu);
|
||
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);
|
||
|
||
}
|
||
|
||
void EgtsProcessingCloseConnection(tEgtsProcessing *env) {
|
||
SocketInterface_close(&env->gsm->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->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) {
|
||
|
||
AtGsmSimComA7600_PdpActivate(env->gsm->gsmAt, 1);
|
||
|
||
env->socketId = SocketInterface_open(
|
||
&env->gsm->socketIO,
|
||
eSocketType_TCP,
|
||
env->clientType,
|
||
env->srvAddr.data,
|
||
env->srvAddr.length,
|
||
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 (EXT_ENV_TELE.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 (EXT_ENV_TELE.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 (EXT_ENV_TELE.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;
|
||
}
|
||
|
||
void EventUpdateFirmwareFunc(void *envMma, bool result, bool isAbortOld) {
|
||
|
||
tEgtsProcessing *env = (tEgtsProcessing *) envMma;
|
||
|
||
if (result) {
|
||
|
||
if (isAbortOld) {
|
||
|
||
if (env->gsmFirmware.firmwareType == FIRMWARE_UVEOS) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Прошивка не загружена. Обновленная версия УВЭОС уже установлена")
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Прошивка не загружена. Обновленная версия ТЕЛЕМАТИКИ уже установлена")
|
||
}
|
||
|
||
/*
|
||
if (env->gsmFirmware.firmwareType == FIRMWARE_UVEOS) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Прошивка не загружена. Обновленная версия УВЭОС уже установлена")
|
||
|
||
InitGsmFirmware(&env->gsmFirmware,
|
||
env->gsm->gsmAt,
|
||
FIRMWARE_TELE,
|
||
env->firmware_buf,
|
||
&env->firmwareStats,
|
||
&env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN,
|
||
&env->deviceTeledataStorageData->telematica.UPDATE_SERVER_ADDRESS,
|
||
env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_ATTEMPTS,
|
||
env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_PERIOD,
|
||
EXT_ENV_TELE.store.accessDumper,
|
||
false,
|
||
EventUpdateFirmwareFunc,
|
||
env,
|
||
env->slog);
|
||
|
||
StartUpdateFirmware(&env->gsmFirmware);
|
||
} else {
|
||
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Прошивка не загружена. Обновленная версия ТЕЛЕМАТИКИ уже установлена")
|
||
}
|
||
*/
|
||
} else {
|
||
|
||
if (env->gsmFirmware.firmwareType == FIRMWARE_UVEOS) {
|
||
EXT_ENV_TELE.store.AdditionalSettings->REGION_SIZE_UPDATE = FIRMWARE_MAIN_AREA_LENGTH;
|
||
}
|
||
|
||
if (env->gsmFirmware.firmwareType == FIRMWARE_TELE) {
|
||
EXT_ENV_TELE.store.AdditionalSettings->REGION_SIZE_UPDATE = FIRMWARE_TELE_AREA_LENGTH;
|
||
}
|
||
|
||
env->deviceTeledataStorageData->telematica.UPDATE_UVEOS_UPDATE = false;
|
||
|
||
EraGlonassUveosDumper_ForceDump(EXT_ENV_TELE.store.uveosDumper);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Прошивка загружена. Для применения новой прошивки перезагрузите устройство")
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматическая перезагрузка, через 5 сек");
|
||
SystemDelayMs(5000);
|
||
NVIC_SystemReset();
|
||
}
|
||
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Прошивка не загружена")
|
||
|
||
env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_ATTEMPTS = env->gsmFirmware.attempts;
|
||
|
||
if (env->gsmFirmware.attempts == 0) {
|
||
env->deviceTeledataStorageData->telematica.UPDATE_UVEOS_UPDATE = false;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Попытки исчерпаны. Обновление будет завершено после получения команды на обновление");
|
||
}
|
||
|
||
EraGlonassUveosDumper_ForceDump(EXT_ENV_TELE.store.uveosDumper);
|
||
|
||
// LoggerStrFormatInfo(LOGGER, LOG_SIGN,
|
||
// "Обновление будет завершено позже. Осталось попыток %d из %d", env->gsmFirmware.attempts,
|
||
// env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_ATTEMPTS);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
void wait_CHECK_IN_PERIOD(tEgtsProcessing *env) {
|
||
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 (EXT_ENV_TELE.store.runtime->EGTS_FLEET_ON == false) {
|
||
break;
|
||
}
|
||
|
||
SystemDelayMs(1000);
|
||
}
|
||
}
|
||
|
||
void result_CHECK_SOCKET(tEgtsProcessing *env) {
|
||
if (env->gsm->codeResultOpen == 15) {
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN,
|
||
"Ошибка рукопожатия, переход на альтернативный сервер");
|
||
}
|
||
|
||
if (env->gsm->codeResultOpen == 10) {
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN,
|
||
"Ошибка открытия сеанса, переход на альтернативный сервер");
|
||
}
|
||
|
||
if (env->gsm->codeResultOpen == 19) {
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN,
|
||
"Ошибка сертификатов, переход на альтернативный сервер");
|
||
}
|
||
|
||
if (env->gsm->codeResultOpen == 20) {
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN,
|
||
"Ошибка выполнения команды (возможно отключены услуги связи), переход на альтернативный сервер");
|
||
}
|
||
}
|
||
|
||
_Noreturn void EgtsProcessing_TransmitterTaskMain(tEgtsProcessing *env) {
|
||
|
||
bool isFirstStart = true;
|
||
bool isRebootNav = false;
|
||
uint32_t timeTeleOff = 0;
|
||
uint8_t stepAuth = 3;
|
||
tGsmWithGnssTimeStamp gsmWithGnssTimeStamp;
|
||
gsmWithGnssTimeStamp.status = 'V';
|
||
|
||
//---начало-----------ОБНОВЛЕНИЕ УВЭОС------------------------------
|
||
InitGsmFirmware(&env->gsmFirmware,
|
||
env->gsm->gsmAt,
|
||
FIRMWARE_UVEOS,
|
||
env->firmware_buf,
|
||
&env->firmwareStats,
|
||
&env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN,
|
||
&env->deviceTeledataStorageData->telematica.UPDATE_SERVER_ADDRESS,
|
||
env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_ATTEMPTS,
|
||
env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_PERIOD,
|
||
EXT_ENV_TELE.store.accessDumper,
|
||
false,
|
||
EventUpdateFirmwareFunc,
|
||
env,
|
||
env->slog);
|
||
|
||
GsmFirmware_Start(&env->gsmFirmware);
|
||
|
||
//---конец-----------ОБНОВЛЕНИЕ УВЭОС------------------------------
|
||
|
||
while (EXT_ENV_TELE.store.device->factoryMode == true) {
|
||
if (egtsProcessing.timeFact < SystemGetMs()) {
|
||
egtsProcessing.timeFact = SystemGetMs() + 10000;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим производственного теста")
|
||
}
|
||
SystemDelayMs(1000);
|
||
}
|
||
|
||
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_ALT_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;
|
||
|
||
tIsFind check;
|
||
memset(&check, 0, sizeof(check));
|
||
|
||
eEgtsCertsStatus isLoad;
|
||
while (1) {
|
||
if (EXT_ENV_TELE.store.runtime->EGTS_FLEET_ON) {
|
||
|
||
isLoad = changeServer(env, 0);
|
||
|
||
if (isLoad != CERTS_STATUS_LOAD) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Внутренняя ошибка настройки модема. Повторная попытка 1")
|
||
isLoad = changeServer(env, 0);
|
||
}
|
||
|
||
if (isLoad != CERTS_STATUS_LOAD) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Внутренняя ошибка настройки модема. Повторная попытка 2")
|
||
isLoad = changeServer(env, 0);
|
||
}
|
||
|
||
if (isLoad != CERTS_STATUS_LOAD) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Внутренняя ошибка настройки модема")
|
||
break;
|
||
} else {
|
||
break;
|
||
}
|
||
} else {
|
||
SystemDelayMs(1000);
|
||
}
|
||
|
||
}
|
||
|
||
if (isLoad != CERTS_STATUS_LOAD)
|
||
changeServer(env, 1);
|
||
|
||
uint32_t timeOutCheckConnect = 0;
|
||
uint32_t timeIsNetworkRegistration = 0;
|
||
uint32_t timeOutCheckNav = AURUS_CHECK_NAV;
|
||
uint8_t stepCheckNav = 3;
|
||
|
||
bool isRegistration;
|
||
|
||
while (1) {
|
||
|
||
// LoggerInfoStatic(LOGGER, LOG_SIGN, "НОВАЯ ПРОШИВКА ТЕЛЕМАТИКИ")
|
||
|
||
//---начало-----------ОБНОВЛЕНИЕ УВЭОС------------------------------
|
||
// if (EXT_ENV_TELE.store.runtime->EGTS_UPDATE_UVEOS) {
|
||
// EXT_ENV_TELE.store.runtime->EGTS_FLEET_ON = false;
|
||
// }
|
||
//---конец-----------ОБНОВЛЕНИЕ УВЭОС-------------------------------
|
||
|
||
if (EXT_ENV_TELE.store.runtime->EGTS_FLEET_ON) {
|
||
|
||
|
||
///---начало------------------------------------Проверка навигации на сбой приемника------------------------------------
|
||
if (egtsProcessing.timeNavUpdate < SystemGetMs()) {
|
||
egtsProcessing.timeNavUpdate = SystemGetMs() + 10000;
|
||
|
||
if (osMutexAcquire(env->gsm->gnssRmcGga.rmcAccess, 2000) == osOK) {
|
||
|
||
if ((env->gsm->gnssRmcGga.isRMC_Active == false) || (env->gsm->gnssRmcGga.isGGA_Active == false)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнаружена остановка навигации")
|
||
isRebootNav = true;
|
||
}
|
||
|
||
if ((env->gsm->gnssRmcGga.gsmWithGnssTimeStamp.status == 'A') &&
|
||
(gsmWithGnssTimeStamp.status == 'A')) {
|
||
if (memcmp((void *) &env->gsm->gnssRmcGga.gsmWithGnssTimeStamp, (void *) &gsmWithGnssTimeStamp,
|
||
sizeof(tGsmWithGnssTimeStamp)) == 0) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнаружена остановка времени навигации")
|
||
isRebootNav = true;
|
||
}
|
||
}
|
||
|
||
memcpy(&gsmWithGnssTimeStamp, &env->gsm->gnssRmcGga.gsmWithGnssTimeStamp,
|
||
sizeof(tGsmWithGnssTimeStamp));
|
||
env->gsm->gnssRmcGga.isRMC_Active = false;
|
||
env->gsm->gnssRmcGga.isGGA_Active = false;
|
||
|
||
osMutexRelease(env->gsm->gnssRmcGga.rmcAccess);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата доступа timeNavUpdate")
|
||
}
|
||
|
||
if (isRebootNav) {
|
||
isRebootNav = false;
|
||
if (osMutexAcquire(env->gsm->gsmAt->access, 10000) == osOK) {
|
||
AtGsm_Gsnss_Simcom7600_StartReceiver(env->gsm->gsmAt, false);
|
||
AtGsm_Gsnss_Simcom7600_StartReceiver(env->gsm->gsmAt, true);
|
||
AtGsm_Gsnss_Simcom7600_SetConfigureStaticRMCThread(env->gsm->gsmAt);
|
||
osMutexRelease(env->gsm->gsmAt->access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата (RestartResiver)")
|
||
}
|
||
}
|
||
|
||
}
|
||
///---конец-------------------------------------Проверка навигации на сбой приемника------------------------------------
|
||
|
||
EXT_ENV_TELE.store.runtime->telematicaCloseConnect = false;
|
||
|
||
isFirstStart = true;
|
||
/*
|
||
|
||
char serverName[] = "http://firmware.ficom-it.info/intelcom/file.php";
|
||
|
||
EgtsProcessing_SendCommandConfirmation(env,
|
||
CT_COM, //
|
||
0,
|
||
0,
|
||
0,
|
||
|
||
0,
|
||
0,
|
||
2, // Установка значения
|
||
0x0204, // Адрес и порт сервера для связи с использованием TCP/IP протокола
|
||
|
||
(uint8_t *)serverName,
|
||
sizeof(serverName) - 1);
|
||
|
||
SystemDelayMs(5000);
|
||
|
||
*/
|
||
|
||
if (EXT_ENV_TELE.store.device->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;
|
||
|
||
EXT_ENV_TELE.store.runtime->telematicaCloseConnect = true;
|
||
|
||
if (timeTeleOff < SystemGetMs()) {
|
||
timeTeleOff = SystemGetMs() + 10000;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика отключена")
|
||
}
|
||
|
||
|
||
//---начало-----------ОБНОВЛЕНИЕ УВЭОС------------------------------
|
||
|
||
if (env->deviceTeledataStorageData->telematica.UPDATE_UVEOS_UPDATE) {
|
||
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Через 5 секунд начнется обновление прошивки УВЭОС")
|
||
|
||
SystemDelayMs(5000);
|
||
|
||
env->gsmFirmware.attempts = env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_ATTEMPTS;
|
||
env->gsmFirmware.attemptsAll = env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_ATTEMPTS;
|
||
env->gsmFirmware.attempts_period = env->deviceTeledataStorageData->telematica.UPDATE_SERVER_CHECK_IN_PERIOD;
|
||
|
||
StartUpdateFirmware(&env->gsmFirmware);
|
||
|
||
for (;;) {
|
||
if (env->deviceTeledataStorageData->telematica.UPDATE_UVEOS_UPDATE == false) {
|
||
env->gsmFirmware.startUpdateFirmware = false;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Через 5 секунд выход из режима обновления прошивки УВЭОС")
|
||
SystemDelayMs(5000);
|
||
break;
|
||
}
|
||
SystemDelayMs(1000);
|
||
}
|
||
|
||
}
|
||
|
||
//---конец-----------ОБНОВЛЕНИЕ УВЭОС------------------------------
|
||
|
||
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 (EXT_ENV_TELE.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 = 3;
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Соединение с сервером установлено, ИД: %d", socketId);
|
||
SystemDelayMs(1000);
|
||
socketStatus = SocketInterface_status(&env->gsm->socketIO, socketId);
|
||
if (socketStatus == eSocketStatus_Connected) {
|
||
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Аутентификация на сервере");
|
||
|
||
if (EgtsProcessing_SendAuth(env)) {
|
||
|
||
if (!env->isOneEBU) {
|
||
env->isOneEBU = true;
|
||
env->firstStartTimeUpdateEBU = SystemGetMs() + 60000;
|
||
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) ||
|
||
(env->gsm->codeResultOpen == 19) || (env->gsm->codeResultOpen == 20)) {
|
||
|
||
if (stepAuth == 0) {
|
||
|
||
stepAuth = 3;
|
||
|
||
result_CHECK_SOCKET(env);
|
||
|
||
if (env->numberServer == 1) {
|
||
wait_CHECK_IN_PERIOD(env);
|
||
}
|
||
|
||
changeServer(env, 1);
|
||
|
||
} else {
|
||
|
||
--stepAuth;
|
||
|
||
result_CHECK_SOCKET(env);
|
||
|
||
}
|
||
|
||
continue;
|
||
|
||
} else {
|
||
stepAuth = 3;
|
||
wait_CHECK_IN_PERIOD(env);
|
||
}
|
||
|
||
}
|
||
|
||
--retry;
|
||
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN,
|
||
"Повторная попытка установки соединения с сервером, осталось попыток: %d", retry);
|
||
}
|
||
|
||
if (retry == 0) {
|
||
wait_CHECK_IN_PERIOD(env);
|
||
}
|
||
|
||
}
|
||
//конец ---------------------------------Установка соединения с сервером---------------------------------------
|
||
//конец ---------------------------------Установка соединения с сервером---------------------------------------
|
||
//конец ---------------------------------Установка соединения с сервером---------------------------------------
|
||
|
||
if (EXT_ENV_TELE.store.runtime->EGTS_FLEET_ON == false) {
|
||
continue;
|
||
}
|
||
|
||
//начало --------------------------------Проверка таймера ожидания обновления-----------------------------------
|
||
//начало --------------------------------Проверка таймера ожидания обновления-----------------------------------
|
||
//начало --------------------------------Проверка таймера ожидания обновления-----------------------------------
|
||
if ((env->TelematicaServerNotActiveWaitTime > 0) && (env->TelematicaServerNotActiveWaitTime < SystemGetMs())) {
|
||
|
||
env->TelematicaServerNotActiveWaitTime = 0;
|
||
|
||
if (EXT_ENV_TELE.store.device->telematicaIsActive == false) {
|
||
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Телематика отключена (полностью). Обновление не найдено. Закрытие соединения")
|
||
EgtsProcessingCloseConnection(env);
|
||
|
||
EXT_ENV_TELE.store.runtime->telematicaServerIsActive = false;
|
||
EXT_ENV_TELE.store.runtime->telematicaWaitConnect = true;
|
||
|
||
SystemDelayMs(5000);
|
||
|
||
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->socketIO, socketId);
|
||
|
||
if (socketStatus == eSocketStatus_Disconnected) {
|
||
env->egtsIdentityAdditionalData.isReceivedResultCode = false;
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Соединение с сервером разорвано, ИД: %d", socketId);
|
||
EgtsProcessingCloseConnection(env);
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
//конец ---------------------------------Проверка соединения---------------------------------------------------
|
||
//конец ---------------------------------Проверка соединения---------------------------------------------------
|
||
//конец ---------------------------------Проверка соединения---------------------------------------------------
|
||
|
||
SystemDelayMs(1000);
|
||
}
|
||
|
||
}
|
||
|
||
//extern tFirmwareLoader FIRMWARE_LOADER;
|
||
|
||
void EgtsProcessing_Worker(tEgtsProcessing *env) {
|
||
bool oneOn = true;
|
||
bool oneOff = true;
|
||
uint8_t stepAuth = 3;
|
||
|
||
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 = 3;
|
||
|
||
LoggerStrInfoStatic(LOGGER, LOG_SIGN,
|
||
"Не корректный сертификат, переход на альтернативный сервер");
|
||
changeServer(env, 1);
|
||
} else {
|
||
--stepAuth;
|
||
LoggerFormatInfo(LOGGER, LOG_SIGN,
|
||
"Не корректный сертификат, переход на альтернативный сервер через %u попыток",
|
||
stepAuth);
|
||
}
|
||
|
||
} else {
|
||
stepAuth = 3;
|
||
}
|
||
|
||
|
||
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 > 512)
|
||
egtsCommand.dataSize = 512;
|
||
|
||
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;
|
||
|
||
env->TelematicaServerNotActiveWaitTime = 0;
|
||
|
||
receivedUpdateFirmware(env);
|
||
}
|
||
}
|
||
//конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
|
||
//конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
|
||
//конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
|
||
/*
|
||
|
||
//начало --------------------------------Сервис ПРОШИВКИ-----------------------------------------------
|
||
//начало --------------------------------Сервис ПРОШИВКИ-----------------------------------------------
|
||
//начало --------------------------------Сервис ПРОШИВКИ-----------------------------------------------
|
||
if (env->egtsEnv.recSourceService == EGTS_FIRMWARE_SERVICE) {
|
||
if (env->egtsEnv.subRecType == EGTS_SR_SERVICE_PART_DATA) {
|
||
unknownPacket = false;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Получен пакет прошивки");
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Прошивка в этой версии не поддерживается");
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Прошивка будет получена в загрузчике при следующей перезагрузке");
|
||
}
|
||
}
|
||
//конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
|
||
//конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
|
||
//конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
|
||
*/
|
||
}
|
||
//конец ---------------------------------Получены данные----------------------------------------------------
|
||
//конец ---------------------------------Получены данные----------------------------------------------------
|
||
//конец ---------------------------------Получены данные----------------------------------------------------
|
||
|
||
|
||
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);
|
||
}
|
||
}
|