1171 lines
52 KiB
C
1171 lines
52 KiB
C
//
|
||
// Created by cfif on 21.05.23.
|
||
//
|
||
|
||
#ifdef UVEOS_ADD_TELEMATICA
|
||
|
||
#include <egts.h>
|
||
#include <SystemDelayInterface.h>
|
||
#include <Nmea0183Parser.h>
|
||
#include <time.h>
|
||
#include <egtsWorker.h>
|
||
#include <AsciiStringAssmeblingUtils.h>
|
||
#include <Rtc.h>
|
||
#include <stdlib.h>
|
||
#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);
|
||
}
|
||
|
||
}
|
||
|
||
const char LOG_TASK_GSM_SOCKET[] = "GSM SOCKET";
|
||
|
||
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;
|
||
|
||
#ifdef UVEOS_ADD_TELEMATICA
|
||
env->deviceTeledataStorageData = &deviceStorage->nvm.deviceTeledataStorageData;
|
||
#endif
|
||
|
||
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);
|
||
|
||
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);
|
||
|
||
SocketSocketGsm_Init(&env->gsm->socketGsm, &env->gsm->gsmAt,
|
||
&env->srvAddr, env->srvPort,
|
||
env->gsm->gsmAt.access);
|
||
|
||
env->gsm->socketGsm.logger = &slog->logger;
|
||
env->gsm->socketGsm.loggerTaskName = (char *) LOG_TASK_GSM_SOCKET;
|
||
|
||
InitThreadBlock(env->T_processing_Network, "Network", osPriorityNormal);
|
||
// InitThreadBlock(env->T_processing_ebu, "EgtsPrcEbu", osPriorityNormal);
|
||
|
||
InitThreadBlock(env->T_processing_input_command, "EgtsPrcInputCom", 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);
|
||
}
|
||
|
||
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_SetRegistrationAutomatic(&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, 5000) == 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, 5000) == 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;
|
||
}
|
||
|
||
bool Gsm_SetProfileERA(tEgtsProcessing *env) {
|
||
AtCommandResult res = AT_ERROR;
|
||
if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {
|
||
|
||
#ifdef UVEOS_ADD_TELEMATICA
|
||
AtGsmTelitLe910_SimProfileSelect(&env->gsm->gsmAt,
|
||
&env->store->nvm.deviceTeledataStorageData.telematica.EGTS_PROFILE_SIM_ERA);
|
||
#endif
|
||
|
||
AtGsmTelitLe910_SIMCardNoDetect(&env->gsm->gsmAt);
|
||
AtGsmTelitLe910_SIMCardDetect(&env->gsm->gsmAt);
|
||
SystemDelayMs(1000);
|
||
|
||
osMutexRelease(env->gsm->gsmAt.access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_SetProfileERA)")
|
||
}
|
||
|
||
return res == AT_OK;
|
||
}
|
||
|
||
bool Gsm_SetProfileINTERNET(tEgtsProcessing *env) {
|
||
AtCommandResult res = AT_ERROR;
|
||
if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {
|
||
|
||
#ifdef UVEOS_ADD_TELEMATICA
|
||
AtGsmTelitLe910_SimProfileSelect(&env->gsm->gsmAt,
|
||
&env->store->nvm.deviceTeledataStorageData.telematica.EGTS_PROFILE_SIM_INTERNET);
|
||
#endif
|
||
|
||
AtGsmTelitLe910_SIMCardNoDetect(&env->gsm->gsmAt);
|
||
SystemDelayMs(500);
|
||
AtGsmTelitLe910_SIMCardDetect(&env->gsm->gsmAt);
|
||
SystemDelayMs(500);
|
||
|
||
osMutexRelease(env->gsm->gsmAt.access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_SetProfileINTERNET)")
|
||
}
|
||
|
||
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;
|
||
|
||
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;
|
||
|
||
if (!isFirstStart) {
|
||
isFirstStart = true;
|
||
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Настройка телематики")
|
||
|
||
Gsm_SetProfileINTERNET(env);
|
||
Gsm_ActivatePdp(env);
|
||
Gsm_ActivateApn(env);
|
||
}
|
||
|
||
// 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, "Установка соединения с сервером");
|
||
|
||
Gsm_ActivatePdp(env);
|
||
// Gsm_ActivateApn(env);
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
//++++CFIFначало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
|
||
//начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
|
||
//начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
|
||
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_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);
|
||
}
|
||
}
|
||
|
||
#endif |