// // Created by cfif on 21.05.23. // #include #include #include #include #include #include #include #include "EgtsProcessing.h" #include "stddef.h" #include "AtGsm_GetTime.h" #include "EgtsInputCommands.h" #include "EgtsOutputCommands.h" #include "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); } }