commit 2b30609d4de144c8303fc163ebcc1ff6f61875f0 Author: cfif Date: Mon May 26 14:41:45 2025 +0300 Init diff --git a/ModemGonec.c b/ModemGonec.c new file mode 100644 index 0000000..38cfde6 --- /dev/null +++ b/ModemGonec.c @@ -0,0 +1,1185 @@ +// +// Created by cfif on 25.01.23. +// + +#include "ModemGonec.h" +#include +#include +#include "AtGsmCommon.h" +#include "AtGsmSim800f.h" +#include "string.h" + +// Запись прошивки крипто-платы +bool Modem_CryptoSend(tAtCmd *env, uint8_t *pBuf, uint32_t crc, uint32_t offset, uint32_t size) { + AtCommandResult result = AtModem_CryptoSend(env, pBuf, crc, offset, size); + + if (result != AT_OK) + return false; + + return true; +} + +// Останов ожидания маркерного сигнала +bool Modem_Stop(tAtCmd *env) { + AtCommandResult result = AtModem_Stop(env); + + if (result != AT_OK) + return false; + + return true; +} + +// Запуск ожидания маркерного сигнала +bool Modem_Start(tAtCmd *env) { + AtCommandResult result = AtModem_Start(env); + + if (result != AT_OK) + return false; + + return true; +} + + +// Останов задачи приема +bool Modem_StopRecvTask(tAtCmd *env) { + AtCommandResult result = AtModem_StopRecvTask(env); + + if (result != AT_OK) + return false; + + return true; +} + +// Запуск задачи приема +bool Modem_StartRecvTask(tAtCmd *env) { + AtCommandResult result = AtModem_StartRecvTask(env); + + if (result != AT_OK) + return false; + + return true; +} + + +// Останов задачи передачи +bool Modem_StopSendTask(tAtCmd *env) { + AtCommandResult result = AtModem_StopSendTask(env); + + if (result != AT_OK) + return false; + + return true; +} + +// Запуск задачи передачи +bool Modem_StartSendTask(tAtCmd *env) { + AtCommandResult result = AtModem_StartSendTask(env); + + if (result != AT_OK) + return false; + + return true; +} + +// +bool Modem_DelTasi(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_DelTasi(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_DelTasi(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Ввод сетевого адреса модема +bool Modem_NetAddress(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_NetAddress(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_NetAddress(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Ввод каналов ожидания маркерного сигнала +bool Modem_MarkerCh(tAtCmd *env, bool *isWriteMem, uint32_t mc1, uint32_t mc2) { + *isWriteMem = false; + + uint32_t oldMc1; + uint32_t oldMc2; + + AtCommandResult result = AtModem_Get_MarkerCh(env, &oldMc1, &oldMc2); + + if (result != AT_OK) + return false; + + if ((mc1 != oldMc1) || (mc2 != oldMc2)) { + result = AtModem_MarkerCh(env, mc1, mc2); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Ввод тип адреса 1 - почта; 2 - гонец +bool Modem_AddressType(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_AddressType(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_AddressType(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + + +// Периодичность запроса на съем, МС +bool Modem_PerDown(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_PerDown(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_PerDown(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Периодичность запроса на съем, МС +bool Modem_Get_PerDown(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_PerDown(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + + +bool Modem_LogEnable(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_LogEnable(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_LogEnable(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +bool Modem_Get_LogEnable(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_LogEnable(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + + +bool Modem_LogExtended(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_LogExtended(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_LogExtended(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +bool Modem_Get_LogExtended(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_LogExtended(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + + +// Коррекция передатчика PWR +bool Modem_TransmitterPWR(tAtCmd *env, bool *isWriteMem, uint32_t value1, uint32_t value2, uint32_t value3, uint32_t value4) { + *isWriteMem = false; + + uint32_t oldValue1; + uint32_t oldValue2; + uint32_t oldValue3; + uint32_t oldValue4; + AtCommandResult result = AtModem_Get_TransmitterPWR(env, &oldValue1, &oldValue2, &oldValue3, &oldValue4); + + if (result != AT_OK) + return false; + + if ((value1 != oldValue1) || (value2 != oldValue2) || (value3 != oldValue3) || (value4 != oldValue4)) { + result = AtModem_TransmitterPWR(env, value1, value2, value3, value4); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Коррекция передатчика +bool Modem_Get_TransmitterPWR(tAtCmd *env, bool *isWriteMem, uint32_t value1, uint32_t value2, uint32_t value3, uint32_t value4, + uint32_t *oldValue1, uint32_t *oldValue2, uint32_t *oldValue3, uint32_t *oldValue4) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_TransmitterPWR(env, oldValue1, oldValue2, oldValue3, oldValue4); + + if (result != AT_OK) + return false; + + if ((value1 != *oldValue1) || (value2 != *oldValue2) || (value3 != *oldValue3) || (value4 != *oldValue4)) + *isWriteMem = true; + + return true; +} + + +/* +// Коррекция передатчика PWR1 +bool Modem_TransmitterPWR1(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_TransmitterPWR1(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_TransmitterPWR1(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Коррекция передатчика PWR2 +bool Modem_TransmitterPWR2(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_TransmitterPWR2(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_TransmitterPWR2(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Коррекция передатчика PWR3 +bool Modem_TransmitterPWR3(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_TransmitterPWR3(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_TransmitterPWR3(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Коррекция передатчика PWR4 +bool Modem_TransmitterPWR4(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_TransmitterPWR4(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_TransmitterPWR4(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} +*/ + +// +bool +Modem_Region(tAtCmd *env, bool *isWriteMem, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4, uint32_t p5, + uint32_t p6, uint32_t p7, + uint32_t p8) { + *isWriteMem = false; + + uint32_t oldP1; + uint32_t oldP2; + uint32_t oldP3; + uint32_t oldP4; + uint32_t oldP5; + uint32_t oldP6; + uint32_t oldP7; + uint32_t oldP8; + + AtCommandResult result = AtModem_Get_Region(env, &oldP1, &oldP2, &oldP3, &oldP4, &oldP5, &oldP6, &oldP7, &oldP8); + + if (result != AT_OK) + return false; + + if ((p1 != oldP1) || (p2 != oldP2) || (p3 != oldP3) || (p4 != oldP4) || (p5 != oldP5) || (p6 != oldP6) || + (p7 != oldP7) || (p8 != oldP8)) { + result = AtModem_Region(env, p1, p2, p3, p4, p5, p6, p7, p8); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + + +// Установка скоростей +bool Modem_RxTxBitrate(tAtCmd *env, bool *isWriteMem, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4) { + *isWriteMem = false; + + uint32_t oldP1; + uint32_t oldP2; + uint32_t oldP3; + uint32_t oldP4; + + AtCommandResult result = AtModem_Get_RxTxBitrate(env, &oldP1, &oldP2, &oldP3, &oldP4); + + if (result != AT_OK) + return false; + + if ((p1 != oldP1) || (p2 != oldP2) || (p3 != oldP3) || (p4 != oldP4)) { + result = AtModem_RxTxBitrate(env, p1, p2, p3, p4); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; + +} + + + +// Установка приоритета +bool Modem_Priority(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_Priority(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_Priority(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// +bool Modem_RestrictSc(tAtCmd *env, bool *isWriteMem, char *value) { + *isWriteMem = false; + + char oldValue[255]; + memset(oldValue, 0, sizeof(oldValue)); + AtCommandResult result = AtModem_Get_RestrictSc(env, oldValue, sizeof(oldValue)); + + if (result != AT_OK) + return false; + + if (strcmp(value, oldValue) != 0) { + result = AtModem_RestrictSc(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +bool Modem_Reg(tAtCmd *env, bool *isWriteMem, char *value) { + *isWriteMem = false; + + char oldValue[255]; + memset(oldValue, 0, sizeof(oldValue)); + AtCommandResult result = AtModem_Get_Reg(env, oldValue, sizeof(oldValue)); + + if (result != AT_OK) + return false; + + if (strcmp(value, oldValue) != 0) { + result = AtModem_Reg(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +bool Modem_MaxDist(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_MaxDist(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_MaxDist(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Установка региона +bool Modem_RegRegion(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_RegRegion(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_RegRegion(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// Время жизни регистрации +bool Modem_RegTime(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_RegTime(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_RegTime(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + +// +bool Modem_DateTime(tAtCmd *env, time_t *timestamp) { + AtCommandResult result = AtModem_DateTime(env, timestamp); + + if (result != AT_OK) + return false; + + return true; +} + +bool Modem_WriteMem(tAtCmd *env) { + AtCommandResult result = AtModem_WriteMem(env); + + if (result != AT_OK) + return false; + + return true; +} + +// Загрузка ключей с проверкой +bool Modem_LoadKey(tAtCmd *env, uint32_t key_num, char *buf, size_t buf_len) { + + // Загрузка ключей + AtCommandResult result = AtModem_SetKey(env, key_num, buf, buf_len); + if (result != AT_OK) + return false; + + // Проверка ключа +// result = AtModem_CheckKey(env, key_num); + +// if (result != AT_OK) +// return false; + + // Запись текущих настроек и ключей +// result = AtModem_WriteMem(env); + +// if (result != AT_OK) +// return false; + + return true; +} + + + + + + + + + + + + + + + + + + + + +// +bool Modem_Get_DelTasi(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_DelTasi(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +// Ввод сетевого адреса модема +bool Modem_Get_NetAddress(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_NetAddress(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +// Ввод каналов ожидания маркерного сигнала +bool +Modem_Get_MarkerCh(tAtCmd *env, bool *isWriteMem, uint32_t mc1, uint32_t mc2, uint32_t *oldMc1, uint32_t *oldMc2) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_MarkerCh(env, oldMc1, oldMc2); + + if (result != AT_OK) + return false; + + if ((mc1 != *oldMc1) || (mc2 != *oldMc2)) + *isWriteMem = true; + + return true; +} + +// Ввод тип адреса 1 - почта; 2 - гонец +bool Modem_Get_AddressType(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_AddressType(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +/* +// Коррекция передатчика 1 +bool Modem_Get_TransmitterPWR1(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_TransmitterPWR1(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +// Коррекция передатчика 2 +bool Modem_Get_TransmitterPWR2(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_TransmitterPWR2(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +// Коррекция передатчика 3 +bool Modem_Get_TransmitterPWR3(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_TransmitterPWR3(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +// Коррекция передатчика 4 +bool Modem_Get_TransmitterPWR4(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_TransmitterPWR4(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} +*/ + +// Установка скоростей +bool Modem_Get_RxTxBitrate(tAtCmd *env, bool *isWriteMem, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4, + uint32_t *oldP1, uint32_t *oldP2, uint32_t *oldP3, uint32_t *oldP4) { + *isWriteMem = false; + + + AtCommandResult result = AtModem_Get_RxTxBitrate(env, oldP1, oldP2, oldP3, oldP4); + + if (result != AT_OK) + return false; + + if ((p1 != *oldP1) || (p2 != *oldP2) || (p3 != *oldP3) || (p4 != *oldP4)) + *isWriteMem = true; + + return true; +} + + + +// Установка приоритета +bool Modem_Get_Priority(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_Priority(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +// +bool Modem_Get_RestrictSc(tAtCmd *env, bool *isWriteMem, char *value, char oldValue[255]) { + *isWriteMem = false; + + memset(oldValue, 0, 255); + AtCommandResult result = AtModem_Get_RestrictSc(env, oldValue, 255); + + if (result != AT_OK) + return false; + + if (strcmp(value, oldValue) != 0) + *isWriteMem = true; + + return true; +} + +bool Modem_Get_Reg(tAtCmd *env, bool *isWriteMem, char *value, char oldValue[255]) { + *isWriteMem = false; + + memset(oldValue, 0, 255); + AtCommandResult result = AtModem_Get_Reg(env, oldValue, 255); + + if (result != AT_OK) + return false; + + if (strcmp(value, oldValue) != 0) + *isWriteMem = true; + + return true; +} + +// Максимальная дальность до КА +bool Modem_Get_MaxDist(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_MaxDist(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + + +// Установка региона +bool Modem_Get_RegRegion(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_RegRegion(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +// Время жизни регистрации +bool Modem_Get_RegTime(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_RegTime(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; +} + +bool Modem_Get_SelectPWR(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue) { + *isWriteMem = false; + + AtCommandResult result = AtModem_Get_SelectPWR(env, oldValue); + + if (result != AT_OK) + return false; + + if (value != *oldValue) + *isWriteMem = true; + + return true; + +} + +bool Modem_SelectPWR(tAtCmd *env, bool *isWriteMem, uint32_t value) { + *isWriteMem = false; + + uint32_t oldValue; + AtCommandResult result = AtModem_Get_SelectPWR(env, &oldValue); + + if (result != AT_OK) + return false; + + if (value != oldValue) { + result = AtModem_SelectPWR(env, value); + + if (result != AT_OK) + return false; + + *isWriteMem = true; + } + + return true; +} + + +// Запрос слотов +bool Modem_Get_Slot(tAtCmd *env, uint8_t id[], uint8_t status[], uint8_t count) { + + AtCommandResult result = AtModem_Get_Slot(env, id, status, count); + + if (result != AT_OK) + return false; + + return true; +} + +// Запись данных в слот +bool Modem_Write_Slot(tAtCmd *env, uint32_t id, uint32_t addressAT, uint32_t addressEND, uint32_t urgency, + uint32_t confirmation, uint32_t size, uint8_t *pBuf) { + + AtCommandResult result = AtModem_Write_Slot(env, id, addressAT, addressEND, urgency, confirmation, size, pBuf); + + if (result != AT_OK) + return false; + + return true; +} + + +// Чтение данных из слота +bool Modem_Read_Recv_Slot(tAtCmd *env, uint8_t id, uint32_t *size, uint8_t *pBuf) { + + AtCommandResult result = AtModem_Read_Recv_Slot(env, id, size, pBuf); + + if (result != AT_OK) + return false; + + return true; +} + +// Запрос слотов приема +bool Modem_Get_Recv_Slot(tAtCmd *env, uint8_t id[], uint8_t status[], uint8_t count) { + + AtCommandResult result = AtModem_Get_Recv_Slot(env, id, status, count); + + if (result != AT_OK) + return false; + + return true; +} + +// Очистка слота приема +bool Modem_Clear_Recv_Slot(tAtCmd *env, char *id) { + + AtCommandResult result = AtModem_Clear_Recv_Slot(env, id); + + if (result != AT_OK) + return false; + + return true; +} + +// Очистка слота +bool Modem_Clear_Slot(tAtCmd *env, char *id) { + + AtCommandResult result = AtModem_Clear_Slot(env, id); + + if (result != AT_OK) + return false; + + return true; +} + + +// Запуск получения альманаха +bool Modem_AlmaRun(tAtCmd *env) { + AtCommandResult result = AtModem_AlmaRun(env); + + if (result != AT_OK) + return false; + + return true; +} + +// Останов получения альманаха +bool Modem_AlmaStop(tAtCmd *env) { + AtCommandResult result = AtModem_AlmaStop(env); + + if (result != AT_OK) + return false; + + return true; +} + +// Чтения состояния получения альманаха +bool Modem_Get_AlmaRun(tAtCmd *env, uint8_t *run) { + AtCommandResult result = AtModem_Get_AlmaRun(env, run); + + if (result != AT_OK) + return false; + + return true; +} + +// Запрос состояния получения альманаха +bool Modem_AlmaStatus(tAtCmd *env, uint8_t *status) { + AtCommandResult result = AtModem_AlmaStatus(env, status); + + if (result != AT_OK) + return false; + + return true; +} + +// Запрос состояния регистрации +bool Modem_RegStatus(tAtCmd *env, uint8_t *status) { + AtCommandResult result = AtModem_RegStatus(env, status); + + if (result != AT_OK) + return false; + + return true; +} + + +// Чтение пакета альманаха +bool Modem_Read_Alma(tAtCmd *env, uint32_t *size, uint8_t *pBuf) { + + AtCommandResult result = AtModem_Read_Alma(env, size, pBuf); + + if (result != AT_OK) + return false; + + return true; +} + +// Очистка пакета альманаха +bool Modem_Clear_Alma(tAtCmd *env) { + AtCommandResult result = AtModem_Clear_Alma(env); + + if (result != AT_OK) + return false; + + return true; +} + +// Запуск регистрации +bool Modem_StartRegTask(tAtCmd *env) { + AtCommandResult result = AtModem_StartRegTask(env); + + if (result != AT_OK) + return false; + + return true; +} + +// Останов регистрации +bool Modem_StopRegTask(tAtCmd *env) { + AtCommandResult result = AtModem_StopRegTask(env); + + if (result != AT_OK) + return false; + + return true; +} + + +// Запуск прошивкиы +bool Modem_RunModemOrCrypto(tAtCmd *env) { + AtCommandResult result = AtModem_RunModemOrCrypto(env); + + if (result != AT_OK) + return false; + + return true; +} + + +// Координаты +bool Modem_Coord(tAtCmd *env, int latitude, int longitude) { + AtCommandResult result = AtModem_Coord(env, latitude, longitude); + + if (result != AT_OK) + return false; + + return true; +} + +// Получение логов +bool Modem_Get_Log(tAtCmd *env, int32_t *rssi, int32_t *temp, uint32_t *pwramp, uint32_t *state, uint32_t *wasreboot, uint32_t *size, uint8_t *pBuf) { + AtCommandResult result = AtModem_Get_Log(env, rssi, temp, pwramp, state, wasreboot, size, pBuf); + + if (result != AT_OK) + return false; + + return true; +} + + + + + + + + + + + + + + + +// Чтение версии +bool +Modem_Get_Version(tAtCmd *env, char *versionModem, uint8_t *sizeModem, char *versionCrypto, uint8_t *sizeCrypto) { + + AtCommandResult result = AtModem_Get_Version(env, versionModem, sizeModem, versionCrypto, sizeCrypto); + + if (result != AT_OK) + return false; + + return true; +} + + + +bool Modem_TestAFU(tAtCmd *env) { + + AtCommandResult result = AtModem_TestAFU(env); + + if (result != AT_OK) + return false; + + return true; +} + + +bool Modem_TestAPO(tAtCmd *env) { + + AtCommandResult result = AtModem_TestAPO(env); + + if (result != AT_OK) + return false; + + return true; +} diff --git a/ModemGonec.h b/ModemGonec.h new file mode 100644 index 0000000..93f7619 --- /dev/null +++ b/ModemGonec.h @@ -0,0 +1,204 @@ +// +// Created by cfif on 25.01.23. +// + +#ifndef MODEM_GONEC_H +#define MODEM_GONEC_H + +#include "SerialPortIO.h" +#include "LoggerInterface.h" +#include "BaseTypes.h" +#include "AtCmdCommonProtected.h" +#include "AtModemGonec.h" +#include "ModemMain.h" + +bool Modem_TestAFU(tAtCmd *env); + +bool Modem_TestAPO(tAtCmd *env); + + +// Периодичность запроса на съем, МС +bool Modem_PerDown(tAtCmd *env, bool *isWriteMem, uint32_t value); +// Периодичность запроса на съем, МС +bool Modem_Get_PerDown(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +bool Modem_Reg(tAtCmd *env, bool *isWriteMem, char *value); + +bool Modem_Get_SelectPWR(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +bool Modem_SelectPWR(tAtCmd *env, bool *isWriteMem, uint32_t value); + +// Коррекция передатчика PWR +bool +Modem_TransmitterPWR(tAtCmd *env, bool *isWriteMem, uint32_t value1, uint32_t value2, uint32_t value3, uint32_t value4); +// Коррекция передатчика +bool Modem_Get_TransmitterPWR(tAtCmd *env, bool *isWriteMem, uint32_t value1, uint32_t value2, uint32_t value3, + uint32_t value4, + uint32_t *oldValue1, uint32_t *oldValue2, uint32_t *oldValue3, uint32_t *oldValue4); + + +bool Modem_LogEnable(tAtCmd *env, bool *isWriteMem, uint32_t value); + +bool Modem_Get_LogEnable(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +bool Modem_LogExtended(tAtCmd *env, bool *isWriteMem, uint32_t value); + +bool Modem_Get_LogExtended(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + + +/* +// Коррекция передатчика 1 +bool Modem_Get_TransmitterPWR1(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); +// Коррекция передатчика 2 +bool Modem_Get_TransmitterPWR2(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); +// Коррекция передатчика 3 +bool Modem_Get_TransmitterPWR3(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); +// Коррекция передатчика 4 +bool Modem_Get_TransmitterPWR4(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +// Коррекция передатчика PWR1 +bool Modem_TransmitterPWR1(tAtCmd *env, bool *isWriteMem, uint32_t value); +// Коррекция передатчика PWR2 +bool Modem_TransmitterPWR2(tAtCmd *env, bool *isWriteMem, uint32_t value); +// Коррекция передатчика PWR3 +bool Modem_TransmitterPWR3(tAtCmd *env, bool *isWriteMem, uint32_t value); +// Коррекция передатчика PWR4 +bool Modem_TransmitterPWR4(tAtCmd *env, bool *isWriteMem, uint32_t value); +*/ + +// Запись прошивки крипто-платы +bool Modem_CryptoSend(tAtCmd *env, uint8_t *pBuf, uint32_t crc, uint32_t offset, uint32_t size); + +// Запуск прошивкиы +bool Modem_RunModemOrCrypto(tAtCmd *env); + +bool Modem_DelTasi(tAtCmd *env, bool *isWriteMem, uint32_t param); +// Останов ожидания маркерного сигнала +bool Modem_Stop(tAtCmd *env); +// Запуск ожидания маркерного сигнала +bool Modem_Start(tAtCmd *env); +// Ввод сетевого адреса модема +bool Modem_NetAddress(tAtCmd *env, bool *isWriteMem, uint32_t adr); +// Ввод каналов ожидания маркерного сигнала +bool Modem_MarkerCh(tAtCmd *env, bool *isWriteMem, uint32_t mc1, uint32_t mc2); +// Ввод тип адреса 1 - почта; 2 - гонец +bool Modem_AddressType(tAtCmd *env, bool *isWriteMem, uint32_t type); +// +bool Modem_Region(tAtCmd *env, bool *isWriteMem, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4, uint32_t p5, + uint32_t p6, uint32_t p7, uint32_t p8); +// Установка скоростей +bool Modem_RxTxBitrate(tAtCmd *env, bool *isWriteMem, uint32_t s1, uint32_t s2, uint32_t s3, uint32_t s4); +// Установка приоритета +bool Modem_Priority(tAtCmd *env, bool *isWriteMem, uint32_t prior); +// +bool Modem_RestrictSc(tAtCmd *env, bool *isWriteMem, char *banned); +// Установка региона +bool Modem_RegRegion(tAtCmd *env, bool *isWriteMem, uint32_t region); +// +bool Modem_RegTime(tAtCmd *env, bool *isWriteMem, uint32_t time); +// +bool Modem_DateTime(tAtCmd *env, time_t *timestamp); + +// Запись во флеш модема +bool Modem_WriteMem(tAtCmd *env); + +// Загрузка ключей с проверкой +bool Modem_LoadKey(tAtCmd *env, uint32_t key_num, char *buf, size_t buf_len); + +// Запрос состояния регистрации +bool Modem_RegStatus(tAtCmd *env, uint8_t *status); + +// Останов регистрации +bool Modem_StopRegTask(tAtCmd *env); + +// Останов задачи передачи +bool Modem_StopSendTask(tAtCmd *env); +// Запуск задачи передачи +bool Modem_StartSendTask(tAtCmd *env); + +// Запрос слотов +bool Modem_Get_Slot(tAtCmd *env, uint8_t id[], uint8_t status[], uint8_t count); +// Запись данных в слот +bool Modem_Write_Slot(tAtCmd *env, uint32_t id, uint32_t addressAT, uint32_t addressEND, uint32_t urgency, + uint32_t confirmation, uint32_t size, uint8_t *pBuf); + +// Чтение данных из слота +bool Modem_Read_Recv_Slot(tAtCmd *env, uint8_t id, uint32_t *size, uint8_t *pBuf); +// Запрос слотов приема +bool Modem_Get_Recv_Slot(tAtCmd *env, uint8_t id[], uint8_t status[], uint8_t count); +// Очистка слота приема +bool Modem_Clear_Recv_Slot(tAtCmd *env, char *id); + +// Останов задачи приема +bool Modem_StopRecvTask(tAtCmd *env); +// Запуск задачи приема +bool Modem_StartRecvTask(tAtCmd *env); + +// Очистка слота +bool Modem_Clear_Slot(tAtCmd *env, char *id); + +// Запуск регистрации +bool Modem_StartRegTask(tAtCmd *env); +// Координаты +bool Modem_Coord(tAtCmd *env, int latitude, int longitude); + +// Запуск получения альманаха +bool Modem_AlmaRun(tAtCmd *env); +// Останов получения альманаха +bool Modem_AlmaStop(tAtCmd *env); + +// Чтения состояния получения альманаха +bool Modem_Get_AlmaRun(tAtCmd *env, uint8_t *run); +// Запрос состояния получения альманаха +bool Modem_AlmaStatus(tAtCmd *env, uint8_t *status); +// Чтение пакета альманаха +bool Modem_Read_Alma(tAtCmd *env, uint32_t *size, uint8_t *pBuf); +// Очистка пакета альманаха +bool Modem_Clear_Alma(tAtCmd *env); +// Получение логов +bool Modem_Get_Log(tAtCmd *env, int32_t *rssi, int32_t *temp, uint32_t *pwramp, uint32_t *state, uint32_t *wasreboot, uint32_t *size, + uint8_t *pBuf); + + +// +bool Modem_Get_DelTasi(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +// Ввод сетевого адреса модема +bool Modem_Get_NetAddress(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); +// Ввод каналов ожидания маркерного сигнала +bool Modem_Get_MarkerCh(tAtCmd *env, bool *isWriteMem, uint32_t mc1, uint32_t mc2, uint32_t *oldMc1, uint32_t *oldMc2); + +// Ввод тип адреса 1 - почта; 2 - гонец +bool Modem_Get_AddressType(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +// Установка скоростей +bool Modem_Get_RxTxBitrate(tAtCmd *env, bool *isWriteMem, uint32_t p1, uint32_t p2, uint32_t p3, uint32_t p4, + uint32_t *oldP1, uint32_t *oldP2, uint32_t *oldP3, uint32_t *oldP4); + +// Установка приоритета +bool Modem_Get_Priority(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +// +bool Modem_Get_RestrictSc(tAtCmd *env, bool *isWriteMem, char *value, char oldValue[255]); + +bool Modem_Get_BanReg(tAtCmd *env, bool *isWriteMem, char *value, char oldValue[255]); + +// Установка региона +bool Modem_Get_RegRegion(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +// Время жизни регистрации +bool Modem_Get_RegTime(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + + +// Чтение версии +bool Modem_Get_Version(tAtCmd *env, char *versionModem, uint8_t *sizeModem, char *versionCrypto, uint8_t *sizeCrypto); + +bool Modem_Get_MaxDist(tAtCmd *env, bool *isWriteMem, uint32_t value, uint32_t *oldValue); + +bool Modem_Get_Reg(tAtCmd *env, bool *isWriteMem, char *value, char oldValue[255]); + +bool Modem_Ban(tAtCmd *env, bool *isWriteMem, char *value); + +bool Modem_MaxDist(tAtCmd *env, bool *isWriteMem, uint32_t value); + +#endif //MODEM_GONEC_H diff --git a/ModemGonecFunc.c b/ModemGonecFunc.c new file mode 100644 index 0000000..a6b150c --- /dev/null +++ b/ModemGonecFunc.c @@ -0,0 +1,1336 @@ +// +// Created by cfif on 20.03.23. +// +#include +#include +#include +#include +#include "SerialPort.h" +#include "stdlib.h" +#include "string.h" +#include "httpd_types.h" +#include "httpd_base_func.h" +#include "fs_base_func.h" +#include "math.h" +#include "fs_base_func.h" +#include "file_logger.h" +#include "ModemReceiveFunc.h" +#include "ModemSendFunc.h" +#include "ModemAlmanah.h" + +#define LOGGER env->logger +#define LOG_SIGN "GONEC" + + +bool isModemCheck(tModemMain *env) { + if (!env->isModemCheck) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Модем ГОНЕЦ не доступен"); + } + + return env->isModemCheck; +} + +// Загрузка ключей с проверкой +idPostResult_t ModemLoadKey(tModemMain *env, uint32_t key_num, char *buf, size_t buf_len) { + bool result = false; + if (!isModemCheck(env)) return Post_LOAD_KEY_ERR; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + + result = Modem_LoadKey(&env->modemAt, key_num, buf, buf_len); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи ключа в модем"); + } + + + osMutexRelease(env->accessMODEM); + } else { + return Post_MUTEX_ERR; + } + + if (!result) + return Post_LOAD_KEY_ERR; + + return Post_OK; +} + + +// Прошивка крипто-платы +idPostResult_t ModemCryptoWrite(tModemMain *env, uint8_t *pBuf, uint32_t crc, uint32_t offset, uint32_t size) { + bool result = false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Останов ожидания маркерного сигнала +// result = Modem_Stop(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// } + + result = Modem_CryptoSend(&env->modemAt, pBuf, crc, offset, size); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Запись прошивки модема или крипто-платы (WRITE)"); + } + + // Запуск ожидания маркерного сигнала +// result = Modem_Start(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// } + + osMutexRelease(env->accessMODEM); + } else { + return Post_MUTEX_ERR; + } + + if (!result) + return Post_SET_MODEM; + + return Post_OK; +} + +// Запуск получения альманаха +bool AlmaRun(tModemMain *env) { + + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + +#ifdef DEBUG_MODEM + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск задачи получения альманаха"); +#endif + result = Modem_AlmaRun(&env->modemAt); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Запуск получения альманаха (AT#STARTALMANACTASK)"); + } + + env->stateRequest.stateReqAlma = StateReqAlmaSendStatus; + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Останов получения альманаха +bool AlmaStop(tModemMain *env) { + + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + +#ifdef DEBUG_MODEM + LoggerInfoStatic(LOGGER, LOG_SIGN, "Останов задачи получения альманаха"); +#endif + result = Modem_AlmaStop(&env->modemAt); + if (!result) { +#ifdef DEBUG_MODEM + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Запуск получения альманаха (AT#STOPALMANACTASK)"); +#endif + + } + + +// env->stateRequest.stateReqAlma = StateReqAlmaNoSendStatus; + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +bool ModemDateTime(tModemMain *env, time_t *timestamp) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Останов ожидания маркерного сигнала +// result = Modem_Stop(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// } + // Очистка слота + result = Modem_DateTime(&env->modemAt, timestamp); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Установка даты и времени (AT#DATETIME)"); + } + + // Запуск ожидания маркерного сигнала +// result = Modem_Start(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Запрос чтения состояния получения альманаха +bool AlmaGetRun(tModemMain *env, uint8_t *status) { + bool result = false; + if (!isModemCheck(env)) return false; + +// if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Чтение состояния + result = Modem_Get_AlmaRun(&env->modemAt, status); + +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Запрос чтения состояния получения альманаха (AT#STATUSALMANACTASK)"); +// } + + if (result) { + if (*status == 1) + env->stateRequest.stateReqAlma = StateReqAlmaSendStatus; + + if (*status == 0) + env->stateRequest.stateReqAlma = StateReqAlmaNoSendStatus; + } + +// osMutexRelease(env->accessMODEM); +// } + + + + return result; +} + +// Запрос состояния получения альманаха +bool AlmaStatus(tModemMain *env, uint8_t *status) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Чтение состояния + result = Modem_AlmaStatus(&env->modemAt, status); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запрос состояния получения альманаха (AT#GETRESALMANACTASK)"); + } + + osMutexRelease(env->accessMODEM); + } + + + return result; +} + +// Чтение альманаха +bool AlmaRead(tModemMain *env) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Останов ожидания маркерного сигнала +// result = Modem_Stop(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// } + // Чтение данных из слота + result = Modem_Read_Alma(&env->modemAt, &env->bufReceivedPacketLen, env->bufReceivedPacket); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Чтение пакета альманаха (AT#ALMAREAD)"); + } + + // Запуск ожидания маркерного сигнала +// result = Modem_Start(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + + +// Очистка данных пакета альманаха +bool AlmaClear(tModemMain *env) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Останов ожидания маркерного сигнала +// result = Modem_Stop(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// } + // Очистка слота + result = Modem_Clear_Alma(&env->modemAt); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Очистка пакета альманаха (AT#ALMACLEAR)"); + } + + // Запуск ожидания маркерного сигнала +// result = Modem_Start(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +bool ModemGetSlot(tModemMain *env, uint8_t id[], uint8_t status[], uint8_t count) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Получение слотов + result = Modem_Get_Slot(&env->modemAt, id, status, count); + + osMutexRelease(env->accessMODEM); + } + + return result; + +} + +bool ModemGetLog(tModemMain *env, int32_t *rssi, int32_t *temp, uint32_t *pwramp, uint32_t *state, uint32_t *wasreboot, + uint32_t *size, uint8_t *pBuf) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + // Получение логов + result = Modem_Get_Log(&env->modemAt, rssi, temp, pwramp, state, wasreboot, size, pBuf); + osMutexRelease(env->accessMODEM); + } + + return result; +} + +bool ModemStopSend(tModemMain *env) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + +#ifdef DEBUG_MODEM + LoggerInfoStatic(LOGGER, LOG_SIGN, "Останов задачи передачи сообщений"); +#endif + + // Останов передачи + result = Modem_StopSendTask(&env->modemAt); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Останов задачи передачи сообщений (AT#STOPSENDTASK)"); + + } + osMutexRelease(env->accessMODEM); + } + + return result; +} + + +bool ModemStartSend(tModemMain *env) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + +#ifdef DEBUG_MODEM + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск задачи передачи сообщений"); +#endif + + // Останов передачи + result = Modem_StartSendTask(&env->modemAt); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запуск задачи передачи (AT#STARTSENDTASK)"); + + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Запись данных в пакет +bool SlotWrite(tModemMain *env, uint8_t id, uint32_t addressAT, uint32_t addressEND, uint32_t urgency, + uint32_t confirmation, uint32_t lenTransPaket) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Останов передачи +// result = Modem_StopSendTask(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Останов задачи передачи (AT#STOPSENDTASK)"); +// +// } + + // Запись данных в слот + result = Modem_Write_Slot(&env->modemAt, env->modemStatus.id[id], addressAT, addressEND, urgency, + confirmation, lenTransPaket, + env->bufSendPacket); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запись данных в пакет (AT#WRITEPKT)"); + } + + // Запуск передачи +// result = Modem_StartSendTask(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Запуск задачи передачи (AT#STARTSENDTASK)"); +// +// } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + + +// Чтение данных из пакета +bool SlotRecvRead(tModemMain *env, uint8_t id) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Чтение данных из слота + result = Modem_Read_Recv_Slot(&env->modemAt, id, &env->bufReceivedPacketLen, env->bufReceivedPacket); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Чтение данных из пакета (AT#READPKT)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Очистка данных из пакета приема +bool SlotRecvClear(tModemMain *env, char *id) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Останов приема +// result = Modem_StopRecvTask(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Останов задачи приема (AT#STOPRECVTASK)"); +// } + + // Очистка слота + result = Modem_Clear_Recv_Slot(&env->modemAt, id); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Очистка пакета (AT#DELRECVPKT)"); + } + + // Старт приема +// result = Modem_StartRecvTask(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Запуск задачи приема (AT#STARTRECVTASK)"); +// } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Получение состояния слотов приема +bool ModemGetRecvSlot(tModemMain *env, uint8_t id[], uint8_t status[], uint8_t count) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + result = Modem_Get_Recv_Slot(&env->modemAt, id, status, count); + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Очистка данных из пакета +bool SlotClearNoStartTask(tModemMain *env, char *id) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + env->modemWorkingState = MODEM_WORKING_NONE; + + // Останов передачи + result = Modem_StopSendTask(&env->modemAt); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Останов задачи передачи (AT#STOPSENDTASK)"); + } + + // Очистка слота + result = Modem_Clear_Slot(&env->modemAt, id); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Очистка пакета (AT#DELSENDPKT)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Очистка данных из пакета +bool SlotClearNoStopTask(tModemMain *env, char *id) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Очистка слота + result = Modem_Clear_Slot(&env->modemAt, id); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Очистка пакета (AT#DELSENDPKT)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Очистка данных из пакета +bool SlotClear(tModemMain *env, char *id) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Останов передачи + result = Modem_StopSendTask(&env->modemAt); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Останов задачи передачи (AT#STOPSENDTASK)"); + } + + // Очистка слота + result = Modem_Clear_Slot(&env->modemAt, id); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Очистка пакета (AT#DELSENDPKT)"); + } + + // Старт передачи + result = Modem_StartSendTask(&env->modemAt); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запуск задачи передачи (AT#STARTSENDTASK)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + + +idPostResult_t ModemGetInitAt(tModemMain *env, bool *isWriteMem, bool grp1, bool grp2, bool grp3, bool grp25) { + bool ret; + bool b1 = false, b2 = false, b3 = false, b4 = false, /*b5 = false,*/ b6 = false, b7 = false, b8 = false, b9 = false, b10 = false; + bool b11 = false, /*b12 = false,*/ b13 = false, b14 = false; + bool b15 = false; + bool b16 = false; + bool b17 = false; + + *isWriteMem = false; + + if (!isModemCheck(env)) return Post_SET_MODEM; + + uint32_t value1; + uint32_t value2; + uint32_t value3; + uint32_t value4; + char valueStr255[255]; + + bool isErrorAtModem = false; + + +// if ((grp1) || (grp2) || (grp3)) { + // Останов ожидания маркерного сигнала +// ret = Modem_Stop(&env->modemAt); +// if (!ret) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// return Post_SET_MODEM; +// } +// } + + if (grp1) { + // Ввод сетевого адреса модема - 1 + ret = Modem_Get_NetAddress(&env->modemAt, &b2, env->store->runtime.Settings_General.ATnum_v, &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды чтения из модема: Сетевой адрес AT (AT#NETADDRESS)"); + isErrorAtModem = true; + } + if (b2) + env->store->runtime.Settings_General.ATnum_v = value1; + + // Установка приоритета - 2 + ret = Modem_Get_Priority(&env->modemAt, &b7, env->store->runtime.Settings_General.ATpriority_v, &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Приоритет AT (AT#PRIORITY)"); + isErrorAtModem = true; + } + if (b7) + env->store->runtime.Settings_General.ATpriority_v = value1; + + + // Запрещенные КА - 10 + if (strlen(env->store->runtime.BannedSAT_ex) > 0) { + + } else { + ret = Modem_Get_RestrictSc(&env->modemAt, &b8, env->store->runtime.Settings_General.BannedSAT_v, + valueStr255); + } + + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Запрещенные КА (AT#RESTRICTSC)"); + isErrorAtModem = true; + } + + if (b8) { + memset(env->store->runtime.Settings_General.BannedSAT_v, 0, sizeof(valueStr255)); + strcpy(env->store->runtime.Settings_General.BannedSAT_v, valueStr255); + } + + } + + + if (grp2) { + // Ввод каналов ожидания маркерного сигнала 18, 19 + ret = Modem_Get_MarkerCh(&env->modemAt, &b3, env->store->runtime.Settings_Frequency_Speed.freqMC1_v, + env->store->runtime.Settings_Frequency_Speed.freqMC2_v, &value1, &value2); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды чтения из модема: Номер частоты МС1, MC2 (MARKERCH)"); + isErrorAtModem = true; + } + + if (b3) { + env->store->runtime.Settings_Frequency_Speed.freqMC1_v = value1; + env->store->runtime.Settings_Frequency_Speed.freqMC2_v = value2; + } + + + // Установка скоростей - 20 + ret = Modem_Get_RxTxBitrate(&env->modemAt, &b6, env->store->runtime.Settings_Frequency_Speed.SpeedPKsig_v, + env->store->runtime.Settings_Frequency_Speed.SpeedPKdata_v, + env->store->runtime.Settings_Frequency_Speed.SpeedOKsig_v, + env->store->runtime.Settings_Frequency_Speed.SpeedOKdata_v, + &value1, &value2, &value3, &value4); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Скорости ПК, ОК каналов данных (AT#RXTXBITRATE)"); + isErrorAtModem = true; + } + + if (b6) { + env->store->runtime.Settings_Frequency_Speed.SpeedPKsig_v = value1; + env->store->runtime.Settings_Frequency_Speed.SpeedPKdata_v = value2; + env->store->runtime.Settings_Frequency_Speed.SpeedOKsig_v = value3; + env->store->runtime.Settings_Frequency_Speed.SpeedOKdata_v = value4; + } + + + // 25 + ret = Modem_Get_DelTasi(&env->modemAt, &b1, env->store->runtime.Settings_Frequency_Speed.SItimeAdv_v, + &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Опережение СИ борта (AT#DELTASI)"); + isErrorAtModem = true; + } + + if (b1) + env->store->runtime.Settings_Frequency_Speed.SItimeAdv_v = value1; + + // Установка региона - 29 + ret = Modem_Get_RegRegion(&env->modemAt, &b9, env->store->runtime.Settings_Frequency_Speed.RegionRegistr_v, + &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Георегион регистрации (AT#REGREGION)"); + isErrorAtModem = true; + } + + if (b9) + env->store->runtime.Settings_Frequency_Speed.RegionRegistr_v = value1; + + // Время жизни регистрации - 28 + ret = Modem_Get_RegTime(&env->modemAt, &b10, env->store->runtime.Settings_Frequency_Speed.TimeLifeRegistr_v, + &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Время жизни регистрации (AT#REGTIME)"); + isErrorAtModem = true; + } + + if (b10) + env->store->runtime.Settings_Frequency_Speed.TimeLifeRegistr_v = value1; + + + + + // Максимальная дальность до КА + ret = Modem_Get_MaxDist(&env->modemAt, &b15, env->store->runtime.Settings_Frequency_Speed.MaxDistanceSAT_v, + &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Максимальная дальность до КА (AT#MAXDIST)"); + isErrorAtModem = true; + } + + if (b15) + env->store->runtime.Settings_Frequency_Speed.MaxDistanceSAT_v = value1; + + // Запрещенные георегионы +// if (strlen(env->store->runtime.Settings_Frequency_Speed.AllowedReg_v) > 0) { + ret = Modem_Get_Reg(&env->modemAt, &b16, env->store->runtime.Settings_Frequency_Speed.AllowedReg_v, + valueStr255); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Разрешенные георегионы (AT#REGION)"); + isErrorAtModem = true; +// } + } + + if (b16) { + memset(env->store->runtime.Settings_Frequency_Speed.AllowedReg_v, 0, sizeof(valueStr255)); + strcpy(env->store->runtime.Settings_Frequency_Speed.AllowedReg_v, valueStr255); + } + + + } + + if (grp3) { + + + // Периодичность запроса на съем, МС: + ret = Modem_Get_PerDown(&env->modemAt, &b17, env->store->runtime.Settings_Basic_Access.PerReqDown_v, + &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Периодичность запроса на съем, МС (AT#PERDOWN)"); + isErrorAtModem = true; + } + + if (b17) + env->store->runtime.Settings_Basic_Access.PerReqDown_v = value1; + + + // Ввод тип адреса 2 - косвенный; 1 - прямой + ret = Modem_Get_AddressType(&env->modemAt, &b4, + env->store->runtime.Settings_Basic_Access.TypeAddressing_v - 1, + &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Режим доступа (AT#ADDRESSTYPE)"); + isErrorAtModem = true; + } + + if (b4) + env->store->runtime.Settings_Basic_Access.TypeAddressing_v = value1 - 1; + } + + if (grp25) { + + ret = Modem_Get_TransmitterPWR(&env->modemAt, &b11, + env->store->runtime.Settings_Transmitter.CorPwr1, + env->store->runtime.Settings_Transmitter.CorPwr2, + env->store->runtime.Settings_Transmitter.CorPwr3, + env->store->runtime.Settings_Transmitter.CorPwr4, + &value1, + &value2, + &value3, + &value4); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Коррекция передатчика (AT#SETUPPWR)"); + isErrorAtModem = true; + } + + if (b11) { + env->store->runtime.Settings_Transmitter.CorPwr1 = value1; + env->store->runtime.Settings_Transmitter.CorPwr2 = value2; + env->store->runtime.Settings_Transmitter.CorPwr3 = value3; + env->store->runtime.Settings_Transmitter.CorPwr4 = value4; + } + + + ret = Modem_Get_SelectPWR(&env->modemAt, &b14, env->store->runtime.Settings_Transmitter.SelectCorPwr, &value1); + + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Выбор параметра мощности (AT#SELECTPWR)"); + isErrorAtModem = true; + } + + if (b14) { + env->store->runtime.Settings_Transmitter.SelectCorPwr = value1; + } + + + ret = Modem_Get_LogExtended(&env->modemAt, &b13, + env->store->runtime.Settings_Transmitter.LogExtendedEn, + &value1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды чтения из модема: Разрешение системных логов (AT#SYSLOGENABLE)"); + isErrorAtModem = true; + } + + if (b13) + env->store->runtime.Settings_Transmitter.LogExtendedEn = value1; + + + } + + // +// ret = Modem_Region(&env->modemAt, &b5, 1, 11, 25, 33, 49, 52, 51, 8); +// if (!ret) +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды REGION"); + + +// if ((grp1) || (grp2) || (grp3)) { + // Запуск ожидания маркерного сигнала +// ret = Modem_Start(&env->modemAt); +// if (!ret) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// return Post_SET_MODEM; +// } +// } + + // Если было изменение настроек, записать в настройки + if ((b1) || (b2) || (b3) || (b4) || /*(b5) ||*/ (b6) || (b7) || (b8) || (b9) || (b10) || (b11) || + /*(b12) ||*/ (b13) || (b14) || (b15) || (b16) || (b17)) { + *isWriteMem = true; + } + + if (isErrorAtModem) { + return Post_SET_MODEM; + } + + + return Post_OK; +} + +idPostResult_t ModemInitAt(tModemMain *env, bool grp1, bool grp2, bool grp3, bool grp25) { + bool ret; + bool b1 = false, b2 = false, b3 = false, b4 = false, /*b5 = false,*/ b6 = false, b7 = false, b8 = false, b9 = false, b10 = false; + bool b11 = false, /*b12 = false,*/ b13 = false; + bool b14 = false; + bool b15 = false; + bool b16 = false; + bool b17 = false; + + if (!isModemCheck(env)) return Post_SET_MODEM; + +// if ((grp1) || (grp2) || (grp3)) { + // Останов ожидания маркерного сигнала +// ret = Modem_Stop(&env->modemAt); +// if (!ret) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// return Post_SET_MODEM; +// } +// } + + bool isErrorAtModem = false; + + if (grp1) { + // Ввод сетевого адреса модема - 1 + ret = Modem_NetAddress(&env->modemAt, &b2, env->store->runtime.Settings_General.ATnum_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды записи в модем: Сетевой адрес AT (AT#NETADDRESS)"); + isErrorAtModem = true; + } + + // Установка приоритета - 2 + ret = Modem_Priority(&env->modemAt, &b7, env->store->runtime.Settings_General.ATpriority_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Приоритет AT (AT#PRIORITY)"); + isErrorAtModem = true; + } + // Запрещенные КА - 10 +// if (strlen(env->store->runtime.Settings_General.BannedSAT_v) > 0) { + ret = Modem_RestrictSc(&env->modemAt, &b8, env->store->runtime.Settings_General.BannedSAT_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Запрещенные КА (AT#RESTRICTSC)"); + isErrorAtModem = true; +// } + } + + } + + + if (grp2) { + // Ввод каналов ожидания маркерного сигнала 18, 19 + ret = Modem_MarkerCh(&env->modemAt, &b3, env->store->runtime.Settings_Frequency_Speed.freqMC1_v, + env->store->runtime.Settings_Frequency_Speed.freqMC2_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды записи в модем: Номер частоты МС1, MC2 (MARKERCH)"); + isErrorAtModem = true; + } + + // Установка скоростей - 20 + ret = Modem_RxTxBitrate(&env->modemAt, &b6, env->store->runtime.Settings_Frequency_Speed.SpeedPKsig_v, + env->store->runtime.Settings_Frequency_Speed.SpeedPKdata_v, + env->store->runtime.Settings_Frequency_Speed.SpeedOKsig_v, + env->store->runtime.Settings_Frequency_Speed.SpeedOKdata_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Скорости ПК, ОК каналов данных (AT#RXTXBITRATE)"); + isErrorAtModem = true; + } + + // 25 + ret = Modem_DelTasi(&env->modemAt, &b1, env->store->runtime.Settings_Frequency_Speed.SItimeAdv_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Опережение СИ борта (AT#DELTASI)"); + isErrorAtModem = true; + } + + // Установка региона - 29 + ret = Modem_RegRegion(&env->modemAt, &b9, env->store->runtime.Settings_Frequency_Speed.RegionRegistr_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Георегион регистрации (AT#REGREGION)"); + isErrorAtModem = true; + } + + // Время жизни регистрации - 28 + ret = Modem_RegTime(&env->modemAt, &b10, env->store->runtime.Settings_Frequency_Speed.TimeLifeRegistr_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Время жизни регистрации (AT#REGTIME)"); + isErrorAtModem = true; + } + + + // Максимальная дальность до КА + ret = Modem_MaxDist(&env->modemAt, &b15, env->store->runtime.Settings_Frequency_Speed.MaxDistanceSAT_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Максимальная дальность до КА (AT#MAXDIST)"); + isErrorAtModem = true; + } + + // Запрещенные георегионы + ret = Modem_Reg(&env->modemAt, &b16, env->store->runtime.Settings_Frequency_Speed.AllowedReg_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Разрешенные георегионы (AT#REGION)"); + isErrorAtModem = true; + } + + } + + if (grp3) { + + // Периодичность запроса на съем, МС: + ret = Modem_PerDown(&env->modemAt, &b17, env->store->runtime.Settings_Basic_Access.PerReqDown_v); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модема: Периодичность запроса на съем, МС (AT#PERDOWN)"); + isErrorAtModem = true; + } + + + // Ввод тип адреса 2 - косвенный; 1 - прямой + + ret = Modem_AddressType(&env->modemAt, &b4, env->store->runtime.Settings_Basic_Access.TypeAddressing_v + 1); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Режим доступа (AT#ADDRESSTYPE)"); + isErrorAtModem = true; + } + + } + + + if (grp25) { + + ret = Modem_TransmitterPWR(&env->modemAt, &b11, env->store->runtime.Settings_Transmitter.CorPwr1, + env->store->runtime.Settings_Transmitter.CorPwr2, + env->store->runtime.Settings_Transmitter.CorPwr3, + env->store->runtime.Settings_Transmitter.CorPwr4); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Коррекция передатчика (AT#SETUPPWR)"); + isErrorAtModem = true; + } + + ret = Modem_SelectPWR(&env->modemAt, &b14, env->store->runtime.Settings_Transmitter.SelectCorPwr); + + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Выбор параметра мощности (AT#SELECTPWR)"); + } + + +// ret = Modem_LogEnable(&env->modemAt, &b12, env->store->runtime.Settings_Transmitter.LogEn); +// if (!ret) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды записи в модем: Разрешение логов (AT#LOGENABLE)"); +// isErrorAtModem = true; +// } + + ret = Modem_LogExtended(&env->modemAt, &b13, env->store->runtime.Settings_Transmitter.LogExtendedEn); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Разрешение системных логов (AT#SYSLOGENABLE)"); + isErrorAtModem = true; + } + + } + + + // +// ret = Modem_Region(&env->modemAt, &b5, 1, 11, 25, 33, 49, 52, 51, 8); +// if (!ret) +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды REGION"); + + + // Если было изменение настроек, записать во флеш модема + if ((b1) || (b2) || (b3) || (b4) || /*(b5) ||*/ (b6) || (b7) || (b8) || (b9) || (b10) || (b11) || + /* (b12) ||*/ (b13) || (b14) || (b15) || (b16) || (b17)) { + // Запись во флеш модема + ret = Modem_WriteMem(&env->modemAt); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды: Запись текущих настроек в память (AT#WRITEMEM)"); + isErrorAtModem = true; + } + } + +// if ((grp1) || (grp2) || (grp3)) { + // Запуск ожидания маркерного сигнала +// ret = Modem_Start(&env->modemAt); +// if (!ret) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// return Post_SET_MODEM; +// } +// } + + if (isErrorAtModem) { + return Post_SET_MODEM; + } else { + return Post_OK; + } +} + +// Переход в основной режим работы +idPostResult_t ModemStartAt(tModemMain *env) { + bool ret; + + // Запуск ожидания маркерного сигнала + ret = Modem_Start(&env->modemAt); + if (!ret) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); + return Post_SET_MODEM; + } + + return Post_OK; +} + + + + +// Запрос версий +bool Modem_Get_Version_Modem(tModemMain *env, char *versionModem, uint8_t *sizeModem, char *versionCrypto, + uint8_t *sizeCrypto) { + bool result = false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + + result = Modem_Get_Version(&env->modemAt, versionModem, sizeModem, versionCrypto, sizeCrypto); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запрос версий (VERSION)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Запуск прошивки +bool RunModemOrCrypto(tModemMain *env) { + bool result = false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Запуск прошивки + result = Modem_RunModemOrCrypto(&env->modemAt); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запуск прошивки (RUN)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + + + +// Запуск регистрации +bool StartRegTask(tModemMain *env) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + +#ifdef DEBUG_MODEM + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск задачи регистрации"); +#endif + // Останов ожидания маркерного сигнала +// result = Modem_Stop(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// } + + result = Modem_StartRegTask(&env->modemAt); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запуск регистрации (AT#STARTREGTASK)"); + } + + // Запуск ожидания маркерного сигнала +// result = Modem_Start(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Останов регистрации +bool StopRegTask(tModemMain *env) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + +#ifdef DEBUG_MODEM + LoggerInfoStatic(LOGGER, LOG_SIGN, "Останов задачи регистрации"); +#endif + + // Останов ожидания маркерного сигнала +// result = Modem_Stop(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// } + + result = Modem_StopRegTask(&env->modemAt); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Останов регистрации (AT#STOPREGTASK)"); + } + + // Запуск ожидания маркерного сигнала +// result = Modem_Start(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +// Запрос статуса регистрации +bool ModemGetRegStatus(tModemMain *env, uint8_t *status) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Чтение состояния + result = Modem_RegStatus(&env->modemAt, status); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запрос состояния регистрации (AT#GETREGSTATUS)"); + } + + osMutexRelease(env->accessMODEM); + } + + + return result; +} + + +// Установка координат +bool ModemSet_Coord(tModemMain *env, int latitude, int longitude) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Останов ожидания маркерного сигнала +// result = Modem_Stop(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)"); +// } + + result = Modem_Coord(&env->modemAt, latitude, longitude); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Установка координат (AT#SETCOORD)"); + } + + // Запуск ожидания маркерного сигнала +// result = Modem_Start(&env->modemAt); +// if (!result) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)"); +// } + + osMutexRelease(env->accessMODEM); + } + + + return result; +} + + +bool TestAFU(tModemMain *env) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + // Чтение данных из слота + result = Modem_TestAFU(&env->modemAt); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запуск теста АФУ (AT#TESTAFU)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +bool TestAPO(tModemMain *env) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + result = Modem_TestAPO(&env->modemAt); + + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды модема: Запуск приемника в режиме измерения шума (AT#RSSIAPO)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + +bool SetRoutingRestrictSc(tModemMain *env, char *banned) { + bool result = false; + if (!isModemCheck(env)) return false; + + if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) { + + bool fl; + result = Modem_RestrictSc(&env->modemAt, &fl, banned); + if (!result) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Ошибка выполнения команды записи в модем: Запрещенные КА (AT#RESTRICTSC)"); + } + + osMutexRelease(env->accessMODEM); + } + + return result; +} + diff --git a/ModemGonecFunc.h b/ModemGonecFunc.h new file mode 100644 index 0000000..1f9562f --- /dev/null +++ b/ModemGonecFunc.h @@ -0,0 +1,96 @@ +// +// Created by cfif on 20.03.23. +// + +#ifndef GONEC_GSM_MODEMGONECFUNC_H +#define GONEC_GSM_MODEMGONECFUNC_H + +#include "SerialPortIO.h" +#include "LoggerInterface.h" +#include "BaseTypes.h" +#include "AtCmdCommonProtected.h" +#include "AtModemGonec.h" +#include "ModemMain.h" + +bool SlotClearNoStartTask(tModemMain *env, char *id); + +bool SlotClearNoStopTask(tModemMain *env, char *id); + + +bool SetRoutingRestrictSc(tModemMain *env, char *banned); + +// Загрузка ключей с проверкой +idPostResult_t ModemLoadKey(tModemMain *env, uint32_t key_num, char *buf, size_t buf_len); + +// Прошивка криптоплаты +idPostResult_t ModemCryptoWrite(tModemMain *env, uint8_t *pBuf, uint32_t crc, uint32_t offset, uint32_t size); + +idPostResult_t ModemGetInitAt(tModemMain *env, bool *isWriteMem, bool grp1, bool grp2, bool grp3, bool grp25); + +idPostResult_t ModemInitAt(tModemMain *env, bool grp1, bool grp2, bool grp3, bool grp25); + +// Переход в основной режим работы +idPostResult_t ModemStartAt(tModemMain *env); +// Запрос состояния получения альманаха +bool AlmaStatus(tModemMain *env, uint8_t *status); +// Чтение альманаха +bool AlmaRead(tModemMain *env); +// Очистка данных пакета альманаха +bool AlmaClear(tModemMain *env); + + +// Останов регистрации +bool StopRegTask(tModemMain *env); + +// Запуск прошивки +bool RunModemOrCrypto(tModemMain *env); + +bool ModemGetLog(tModemMain *env, int32_t *rssi, int32_t *temp, uint32_t *pwramp, uint32_t *state, uint32_t *wasreboot, uint32_t *size, + uint8_t *pBuf); + +bool ModemGetSlot(tModemMain *env, uint8_t id[], uint8_t status[], uint8_t count); + +bool ModemDateTime(tModemMain *env, time_t *timestamp); + +// Чтение данных из пакета +bool SlotRecvRead(tModemMain *env, uint8_t id); +// Очистка данных из пакета приема +bool SlotRecvClear(tModemMain *env, char *id); +// Получение состояния слотов приема +bool ModemGetRecvSlot(tModemMain *env, uint8_t id[], uint8_t status[], uint8_t count); + +// Запуск получения альманаха +bool AlmaRun(tModemMain *env); +// Останов получения альманаха +bool AlmaStop(tModemMain *env); +// Запрос чтения состояния получения альманаха +bool AlmaGetRun(tModemMain *env, uint8_t *status); + +// Запись данных в пакет +bool SlotWrite(tModemMain *env, uint8_t id, uint32_t addressAT, uint32_t addressEND, uint32_t urgency, + uint32_t confirmation, uint32_t lenTransPaket); +// Очистка данных из пакета +bool SlotClear(tModemMain *env, char *id); + +bool ModemStopSend(tModemMain *env); + +bool ModemStartSend(tModemMain *env); + +// Запрос версий +bool Modem_Get_Version_Modem(tModemMain *env, char *versionModem, uint8_t *sizeModem, char *versionCrypto, + uint8_t *sizeCrypto); + +// Запуск регистрации +bool StartRegTask(tModemMain *env); + +// Запрос статуса регистрации +bool ModemGetRegStatus(tModemMain *env, uint8_t *status); + +// Установка координат +bool ModemSet_Coord(tModemMain *env, int latitude, int longitude); + +bool TestAFU(tModemMain *env); + +bool TestAPO(tModemMain *env); + +#endif //GONEC_GSM_MODEMGONECFUNC_H diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..9b5e20d --- /dev/null +++ b/modular.json @@ -0,0 +1,22 @@ +{ + "dep": [ + { + "type": "git", + "provider": "GONEC_NEW", + "repo": "SystemDelayInterface" + }, + { + "type": "git", + "provider": "GONEC_NEW", + "repo": "AtModemGonec" + } + ], + "cmake": { + "inc_dirs": [ + "./" + ], + "srcs": [ + "*.c" + ] + } +} \ No newline at end of file