Init

GsmWithGnss.c

@@ -0,0 +1,464 @@
+#include <sys/cdefs.h>
+//
+// Created by zemon on 05.04.23.
+//
+
+//
+// Created by xemon on 21.10.22.
+//
+
+#include "GsmWithGnss_Private.h"
+#include "AtGsm_GetTime.h"
+#include "Rtc.h"
+
+#include <AtCmdCommonProtected.h>
+#include <AudioPlayerSimComSim7600E.h>
+#include <AudioRecorderSimComSim7600E.h>
+#include <SystemDelayInterface.h>
+#include <memory.h>
+#include "ext_telematica.h"
+
+
+#define LOGGER env->logger
+#define LOG_SIGN "GSM&GNSS"
+
+EraGlonassUveosNavData location;
+
+void GsmWithGnss_resetInputCall(tGsmWithGnss *env) {
+    env->urc.inputCall = false;
+}
+
+void GsmWithGnss_ResetRing(tGsmWithGnss *env) {
+    env->urc.ring = false;
+}
+
+bool GsmWithGnss_IsRing(tGsmWithGnss *env) {
+    return env->urc.ring;
+}
+
+void GsmWithGnss_resetMsd(tGsmWithGnss *env) {
+    env->urc.msdSendResult = false;
+}
+
+void GsmWithGnss_Urc(tGsmWithGnss *env, tAtBuffer *buff) {
+
+//    LoggerInfo(LOGGER, LOG_SIGN, buff->data, buff->len)
+
+    if (AtBufferBeginWithStatic(buff, "+ECALL: SUCCEED_TO_TRANSMIT_MSD")) {
+        env->urc.msdSendResult = true;
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, MSD доставлен.")
+    }
+
+    if (AtBufferBeginWithStatic(buff, "+ECALL:UNMUTE MSD transfer complete")) {
+        env->urc.msdSendResult = true;
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, MSD доставлен..")
+    }
+
+    if (AtBufferBeginWithStatic(buff, "+ECALL: UNMUTE MSD transfer complete")) {
+        env->urc.msdSendResult = true;
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, MSD доставлен...")
+    }
+
+    if (AtBufferBeginWithStatic(buff, "+ECALL: FAILED_TO_TRANSMIT_MSD")) {
+        env->urc.msdSendResult = false;
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, ОШИБКА ДОСТАВКИ MSD.")
+    }
+
+    if (AtBufferBeginWithStatic(buff, " +ECALL: FAILED_TO_TRANSMIT_MSD")) {
+        env->urc.msdSendResult = false;
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, ОШИБКА ДОСТАВКИ MSD по каналу тональной связи.")
+    }
+
+    if (AtBufferBeginWithStatic(buff, "VOICE CALL: BEGIN")) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, начало вызова средствами тональной связи код 1")
+        env->urc.ring = true;
+    }
+
+    if (AtBufferBeginWithStatic(buff, "RING")) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, начало вызова средствами тональной связи код 2")
+        env->urc.ring = true;
+    }
+
+    if (AtBufferBeginWithStatic(buff, "VOICE CALL: END:")) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, сброс вызова тональной связи")
+        env->urc.ring = false;
+    }
+
+    if (AtBufferBeginWithStatic(buff, "+CREG: 0,1") || AtBufferBeginWithStatic(buff, "+CREG: 0,2")) {
+        env->urc.netReg = true;
+//        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена URC, получена регистрация в сети.")
+    }
+
+    if (AtBufferBeginWithStatic(buff, "$GPRMC,")) {
+        if (*env->enableGnssUpdate == true) {
+            AtGsm_Gsnss_NavData_Processing(env, buff);
+            AtGsm_Gsnss_GetLastActualNavData(env, &location, 1);
+        }
+    }
+
+    if (AtBufferBeginWithStatic(buff, "#ECALLEV:0")) {
+        env->urc.msdPull = true;
+    }
+
+    if (AtBufferBeginWithStatic(buff, "+CMTI: \"SM\"")) {
+        env->urc.message = true;
+    }
+
+    if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
+        EXT_ENV_ADR_TELE.tele_func(buff, TELE_MODULE_GSM_URC);
+
+}
+
+uint32_t GsmWithGnss_InvalidateGnssUserExternalAntenna(tGsmWithGnss *env, uint32_t currentState, uint32_t targetState) {
+    AtGsm_Gsnss_Simcom7600_SetExternalLnaSupport(
+            &env->gsmAt,
+            targetState ? SIMCOM_SIM7600_EXTERNAL_LNA_NOT_SUPPORT
+                        : SIMCOM_SIM7600_EXTERNAL_LNA_SUPPORT
+    );
+    return targetState;
+}
+
+bool GsmWithGnss_InvalidateNetworkEnable(tGsmWithGnss *env, uint32_t currentState, uint32_t targetState) {
+    if (targetState) {
+        if (!GsmWithGnss_WaitNetworkRegistration(env, 2000)) {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации_3...");
+            if (GsmWithGnss_NetworkSetStateInnaterups(env, 4, 10000) == AT_OK) {
+                LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
+            } else {
+                LoggerErrorStatic(LOGGER, LOG_SIGN, "нет сети");
+                return false;
+            }
+        } else {
+            LoggerErrorStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует");
+            return true;
+        }
+    } else {
+        if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключаем регистрацию в сети")
+            AtGsm_OperatorSelectionDeregister(&env->gsmAt);
+            osMutexRelease(env->gsmAt.access);
+            return false;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Подсистема контроля URC не смогла выполнить захват управления, повторная попытка захвата...")
+            return true;
+        }
+    }
+    return false;
+}
+
+AtCommandResult GsmWithGnss_NetworkReconnect(tAtCmd *env, uint8_t cuontReg) {
+    AtCommandResult res = AT_ERROR;
+    if (osMutexAcquire(env->access, 1000) == osOK) {
+        for (uint8_t i = 0; i < cuontReg; i++) {
+            res = AtGsm_OperatorSelectionAutomatic(env);
+            SystemDelayMs(500);
+        }
+        osMutexRelease(env->access);
+        return res;
+    }
+    return res;
+}
+
+AtCommandResult GsmWithGnss_NetworkSetStateInnaterups(tGsmWithGnss *env, uint8_t cuontReg, uint32_t timeOut) {
+    if (GsmWithGnss_NetworkReconnect(&env->gsmAt, cuontReg) == AT_OK) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание регистрации в сети");
+        if (GsmWithGnss_WaitNetworkRegistration(env, timeOut) == true) {
+            LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть найдена")
+            return AT_OK;
+        } else {
+            LoggerTraceStatic(LOGGER, LOG_SIGN, "Попытка регистрации в сети НЕ выполнена")
+            return AT_ERROR;
+        }
+    }
+    return AT_ERROR;
+}
+
+void GsmWithGnssInit(
+        tGsmWithGnss *env,
+        tString16 *smsCenter,
+        uint16_t *gnssDataRateHz,
+        tRtcIO *Rtc,
+        bool *enableGnssUpdate,
+        tAudioPlayer *audioPlayer,
+        tAudioRecorder *audioRecorder
+) {
+    env->isRegToGSM = false;
+    env->flBlockReg = false;
+    env->enableGnssUpdate = enableGnssUpdate;
+    env->smsCenter = smsCenter;
+    env->gnss.dataRateHz = gnssDataRateHz;
+    env->Rtc = Rtc;
+    env->navDataProvider.env = env;
+    env->navDataProvider.getNavData = (void *) GnssGetNavData;
+    env->navDataProvider.getTime = (void *) GnssTaskGetTime;
+    env->audioPlayer = audioPlayer;
+    env->audioRecorder = audioRecorder;
+
+    env->ecallProvider = (tEraGlonassEcallProvider) {
+            .env = env,
+            .settingNewMsd = (setNewMsd) GsmWithGnss_SetNewMSD,
+            .ecall =(sendEcallCall) GsmWithGnss_Ecall,
+            .isDialing =(eraGlonassEcallProviderCall) GsmWithGnss_isCallDialing,
+            .isMsdSent =(eraGlonassEcallProviderCall) GsmWithGnss_isMsdSent,
+            .isMsdReSent =(eraGlonassEcallProviderCall) GsmWithGnss_isMsdReSent,
+            .isActiveOut =(eraGlonassEcallProviderCall) GsmWithGnss_isOutCallActive,
+            .isActiveInp =(eraGlonassEcallProviderCall) GsmWithGnss_isInpCallActive,
+            .hangup =(eraGlonassEcallProviderCall) GsmWithGnss_HangUp,
+            .hangupEcl =(eraGlonassEcallProviderCall) GsmWithGnss_HangUpEcoll,
+            .prepHenUp =(eraGlonassEcallProviderCall) AtGsmPrepHangCall,
+//            .isNetworkState =(void*) GsmWithGnss_WaitNetworkRegistration,
+            .isNetReg =(eraGlonassEcallProviderCall) GsmWithGnss_GetUrcIsNetReg,
+            .resetUrcNetReg =(eraGlonassEcallProviderCall) GsmWithGnss_ResetUrcIsNetReg,
+            .isNetworkReg =(void *) GsmWithGnss_InvalidateNetworkEnable
+    };
+
+    env->smsProvider.env = env;
+    env->smsProvider.sendDataPdu = (void *) GsmWithGnss_SendDataPduSms;
+
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        GsmWithGnss_ResetRing(env);
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс URC RING выполнен 1");
+        osMutexRelease(env->gsmAt.access);
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления, сброс URC RING 1")
+    }
+
+    env->audioPlayerIO = AudioPlayerSimComSim7600E_GetInterface(env->audioPlayer);
+    env->audioRecorderIO = AudioRecordSimComSim7600E_GetInterface(env->audioRecorder);
+
+    ControllableSwitch_Init(&env->useInternalAntennaSwitch, env, GsmWithGnss_InvalidateGnssUserExternalAntenna);
+    ControllableSwitch_Init(&env->enableNetworkSwitch, env, GsmWithGnss_InvalidateNetworkEnable);
+
+    env->gnss.rmcAccess = osMutexNew(NULL);
+
+    AtCmdSetUrcProcessor(&env->gsmAt, env, GsmWithGnss_Urc);
+
+    InitThreadBlock(env->urcT, "gsm_urc", osPriorityNormal);
+    env->busyThread = false;
+}
+
+_Noreturn void GsmWithGnss_urcThread_body(tGsmWithGnss *env) {
+    for (;;) {
+        if (osMutexAcquire(env->gsmAt.access, 5000) == osOK) {
+//            LoggerInfoStatic(LOGGER, LOG_SIGN, "--URC processor мьютэкс RMC захвачен")
+            //AtCmdProcessUnresolvedLines(&env->gsmAt);
+            while (AtCmdReceiveNextLine(&env->gsmAt, 150) == AT_OK) {
+                AtCmdProcessUnresolvedLine(&env->gsmAt);
+            }
+
+            osMutexRelease(env->gsmAt.access);
+//            LoggerInfoStatic(LOGGER, LOG_SIGN, "--URC processor мьютэкс RMC освобождён")
+        } else {
+//                LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (GsmWithGnss_urcThread_body)")
+        }
+        SystemDelayMs(40);
+    }
+}
+
+bool GetMuxNavDataAcsess(tGsmWithGnss *env, tNmeaRmc *rmc) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) != osOK) {
+        return false;
+    }
+    *rmc = env->gnss.currentRmc;
+    osMutexRelease(env->gsmAt.access);
+    return true;
+}
+
+void GsmWithGnss_startUrcThread(tGsmWithGnss *env) {
+///    urcEnv = env;
+    ThreadBlock_Start(env->urcT, env, GsmWithGnss_urcThread_body);
+}
+
+
+void GsmWithGnss_UseInternalAntenna(tGsmWithGnss *env, bool value) {
+    ControllableSwitch_Set(&env->useInternalAntennaSwitch, value);
+}
+
+void GsmWithGnss_SetNetworkRegistration(tGsmWithGnss *env, bool value) {
+    ControllableSwitch_Set(&env->enableNetworkSwitch, value);
+}
+
+/*
+ *
+ */
+bool GsmWithGnss_WaitNetworkRegistration(tGsmWithGnss *env, uint32_t timeReg) {
+    uint32_t timeEnd = SystemGetMs() + timeReg;
+
+    tAtGsm_NetworkRegistrationReportMode mode;
+
+    while (timeEnd > SystemGetMs()) {
+        if (!env->flBlockReg) {
+            if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+                if (AtGsm_NetworkRegistrationStatus(&env->gsmAt, &mode, &env->regState)) {
+                    if (
+                            env->regState == AT_NETWORK_REGISTRATION_STATE_REGISTERED_HOME ||
+                            env->regState == AT_NETWORK_REGISTRATION_STATE_REGISTERED_ROAMING
+                       ) {
+                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена регистрация")
+                        osMutexRelease(env->gsmAt.access);
+                        env->isRegToGSM = true;
+                        return true;
+                    } else {
+                        env->regState = AT_NETWORK_REGISTRATION_STATE_REGISTRATION_DENIED;
+                        osMutexRelease(env->gsmAt.access);
+                        env->isRegToGSM = false;
+                        return false;
+                    }
+                }
+                osMutexRelease(env->gsmAt.access);
+            } else {
+                LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_WaitNetworkRegistration)")
+            }
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация запрещена настройками")
+            env->isRegToGSM = true;
+            return true;
+        }
+        SystemDelayMs(40);
+    }
+    env->isRegToGSM = false;
+    return false;
+}
+
+void GsmWithGnss_SetNetworkRegistrationHard(tGsmWithGnss *env, bool value) {
+    ControllableSwitch_SetHard(&env->enableNetworkSwitch, value);
+}
+
+bool GsmWaitFirstStartup(tGsmWithGnss *env) {
+    volatile AtCommandResult res = AT_ERROR;
+    uint32_t ttm = SystemGetMs() + 3000;
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        res = AtCmdWaitOk(&env->gsmAt, 1000, 10000);
+        osMutexRelease(env->gsmAt.access);
+        while (ttm > SystemGetMs()){
+            SystemDelayMs(50);
+        }
+        return  res;
+    }
+    while (ttm > SystemGetMs()){
+        SystemDelayMs(50);
+    }
+    return  res;
+}
+
+bool GsmWithGnss_IsGnssReady(tGsmWithGnss *env) {
+    return (env->gnss.currentRmc.status == 'A') &&
+           (env->gnss.currentRmc.location.longitude) &&
+           (env->gnss.currentRmc.location.latitude);
+}
+
+void Gsm_WaitGetTimeAsBaseStation(tGsmWithGnss *env) {
+    struct tm tm_time;
+    SystemDelayMs(500);
+    if (osMutexAcquire(env->gsmAt.access, 5000) == osOK) {
+        memset(&tm_time, '\0', sizeof(tm_time));
+        AtGsm_GetTime(&env->gsmAt, &tm_time);
+
+        time_t gsmTime = mktime(&tm_time);
+        gsmTime &= 0xFFFFFFFF;
+//        gsmTime -= 3600 * 3;
+
+        LoggerFormatInfo(LOGGER, LOG_SIGN, "Получено время с GSM, временная метка: %u", gsmTime)
+        if (gsmTime > 1734956049) {
+            RtcSet(env->Rtc, &gsmTime);
+        }
+
+        osMutexRelease(env->gsmAt.access);
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления WaitGetTime")
+    }
+}
+
+void Gsm_SetManualModemPower(
+        tGsmWithGnss *env,
+        bool *mode,
+        uint16_t *MODEM_POWER_FOR_LTE_MODE,
+        uint16_t *MODEM_POWER_FOR_WCDMA_MODE,
+        uint16_t *MODEM_POWER_FOR_GSM_MODE
+        ){
+        if(*mode == true){
+            GsmWithGnssSetModemManualPowerMode(env, mode);
+            GsmWithGnssSetModemLTEPowerMode(env, MODEM_POWER_FOR_LTE_MODE);
+            GsmWithGnssSetModemWCDMAPowerMode(env, MODEM_POWER_FOR_WCDMA_MODE);
+            GsmWithGnssSetModemGSMPowerMode(env, MODEM_POWER_FOR_GSM_MODE);
+        }
+}
+
+void Gsm_WaitGsmBoot(tGsmWithGnss *env) {
+    uint32_t time = SystemGetMs() + 20000;
+    while (time > SystemGetMs()) {
+        if (GsmWithGnssInitGnss(env) == AT_OK) {
+            break;
+        }
+        SystemDelayMs(100);
+    }
+}
+
+void RestartResiver(tGsmWithGnss *env, bool stat){
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        uint32_t tm = SystemGetMs() + 2000;
+        while (tm > SystemGetMs()){
+            SystemDelayMs(4);
+        }
+
+        AtCommandResult result = AT_ERROR;
+        tm = SystemGetMs() + 4000;
+        while (tm > SystemGetMs()){
+            result = AtGsm_Gsnss_Simcom7600_StartReceiver(&env->gsmAt, stat);
+            if (result == AT_OK){
+                if(stat == false) {
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Остановка GNSS подсистемы выполнена");
+                } else {
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск GNSS подсистемы выполнен");
+                }
+                osMutexRelease(env->gsmAt.access);
+                return;
+            }
+            SystemDelayMs(40);
+        }
+        osMutexRelease(env->gsmAt.access);
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка при выполнении запуска/остановки GNSS подсистемы");
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления, остановка GNSS подсистемы")
+    }
+}
+
+void StopResiver(tGsmWithGnss *env){
+    RestartResiver(env,false);
+}
+
+void StartResiver(tGsmWithGnss *env){
+    RestartResiver(env,true);
+}
+
+void HotStartGNSS(tGsmWithGnss *env){
+    if (osMutexAcquire(env->gsmAt.access, 2000) == osOK) {
+        uint32_t tm = SystemGetMs() + 500;
+        while (tm > SystemGetMs()){
+            SystemDelayMs(4);
+        }
+
+        AtCommandResult result = AT_ERROR;
+        tm = SystemGetMs() + 4000;
+        while (tm > SystemGetMs()){
+            result = AtGsm_Gsnss_Simcom7600_HotStartReceiver(&env->gsmAt);
+            if (result == AT_OK){
+                LoggerInfoStatic(LOGGER, LOG_SIGN, "Горячий перезапуск GNSS выполнен");
+                osMutexRelease(env->gsmAt.access);
+                return;
+            }
+            SystemDelayMs(40);
+        }
+        osMutexRelease(env->gsmAt.access);
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка при выполнении горячего перезапуска GNSS");
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления, горячий старт GNSS подсистемы")
+    }
+}
+
+
+
+
+
+
+

GsmWithGnss.h

@@ -0,0 +1,184 @@
+//
+// Created by zemon on 20.02.24.
+//
+
+#ifndef HEAVY_TERMINAL_GSMWITHGNSS_H
+#define HEAVY_TERMINAL_GSMWITHGNSS_H
+
+#include "SerialPortIO.h"
+#include "AtGsmSimcomSim7600.h"
+#include "EraGlonassUveos.h"
+#include "LoggerInterface.h"
+#include "BaseTypes.h"
+#include <AudioPlayerInterface.h>
+#include <AudioRecorderInterface.h>
+#include "ControllableSwitch.h"
+#include "RtcIO.h"
+#include "Nmea0183Parser.h"
+#include "CmsisRtosThreadUtils.h"
+#include "SystemMutexCmsis.h"
+#include "AudioPlayerSimComSim7600E.h"
+#include "AudioRecorderSimComSim7600E.h"
+
+//typedef struct {
+//    tString32 softValue;
+//    tString32 ssidValue;
+//    tString32 cgsmValue;
+//    bool aufioFileIsValid;
+//} tModemVersionRevision;
+
+typedef enum {
+    GSM_INITIALIZING=0,
+    GSM_IDLE=1,
+    GSM_ERROR=2,
+    GSM_NOT_USET=2,
+} tGsmState;
+
+typedef struct {
+    bool *enableGnssUpdate;
+    tAtCmd gsmAt;
+    tAudioPlayer *audioPlayer;
+    tAudioRecorder *audioRecorder;
+    tNavDataProvider navDataProvider;
+    tEraGlonassEcallProvider ecallProvider;
+    tEraGlonassSmsProvider smsProvider;
+    tLoggerInterface *logger;
+    tString16 *smsCenter;
+    tRtcIO *Rtc;
+
+    tAudioPlayerInterface audioPlayerIO;
+    tAudioRecorderInterface audioRecorderIO;
+    tAtGsm_NetworkRegistrationState regState;
+    tControllableSwitch useInternalAntennaSwitch;
+    tControllableSwitch enableNetworkSwitch;
+    tGsmState gsmState;
+
+    struct {
+        volatile bool msdSendResult;
+        volatile bool msdPull;
+        volatile bool ring;
+        volatile bool netReg;
+        volatile bool inputCall;
+        volatile bool ringStatus;
+        volatile bool message;
+    } urc;
+
+    struct {
+        volatile uint32_t next;
+        volatile uint16_t *dataRateHz;
+
+        tNmeaRmc currentRmc;
+        tNmeaRmc prevRmc;
+
+        SystemMutexCmsis rmcAccess;
+    } gnss;
+
+
+    struct {
+        uint8_t gsmRx[512];
+        uint8_t gsmTx[512];
+    } mem;
+
+    bool busyThread;
+    bool flBlockReg;
+    bool isRegToGSM;
+
+    tStaticThreadBlock(512) urcT;
+} tGsmWithGnss;
+
+//Common
+void GsmWithGnssInit(
+        tGsmWithGnss *env,
+        tString16 *smsCenter,
+        uint16_t *gnssDataRateHz,
+        tRtcIO *Rtc,
+        bool *enableGnssUpdate,
+        tAudioPlayer *audioPlayer,
+        tAudioRecorder *audioRecorder
+);
+
+void GsmWithGnss_startUrcThread(tGsmWithGnss *env);
+
+AtCommandResult GsmWithGnssConfigureAudioProfile(tGsmWithGnss *env, tString32 *profileData);
+
+void GsmWithGnss_ResetPbDone(tGsmWithGnss *env);
+
+bool GsmWithGnss_IsPbDone(tGsmWithGnss *env);
+
+void Gsm_WaitGetTimeAsBaseStation(tGsmWithGnss *env);
+
+bool GsmWaitFirstStartup(tGsmWithGnss *env);
+
+bool GsmWithGnss_InvalidateNetworkEnable(tGsmWithGnss *env, uint32_t currentState, uint32_t targetState);
+
+void GsmWithGnss_SetNetworkRegistration(tGsmWithGnss *env, bool value);
+
+AtCommandResult GsmWithGnss_NetworkReconnect(tAtCmd *env, uint8_t cuontReg);
+
+bool GetMuxNavDataAcsess(tGsmWithGnss *env, tNmeaRmc *rmc);
+
+bool GsmWithGnss_WaitNetworkRegistration(tGsmWithGnss *env, uint32_t timeReg);
+
+void GsmWithGnss_UseInternalAntenna(tGsmWithGnss *env, bool value);
+
+bool GsmWithGnss_SetNewMSD(tGsmWithGnss *env,
+                           uint8_t *msd,
+                           size_t msdLength,
+                           eEcallActivationType activationType,
+                           eEcallTestMode testMode
+);
+
+//Gnss ops
+AtCommandResult GsmWithGnssInitGnss(tGsmWithGnss *env);
+
+AtCommandResult GsmWithGnssSimProfileSelect(tAtCmd *gsmAt, tStringLink profile);
+
+AtCommandResult GsmWithGnss_NetworkSetStateInnaterups(tGsmWithGnss *env, uint8_t cuontReg, uint32_t timeOut);
+
+bool GsmWithGnss_IsGnssReady(tGsmWithGnss *env);
+
+//Audio ops
+void GsmWithGnss_InitAudio(tGsmWithGnss *env);
+
+//Ring ops
+bool GsmWithGnss_IsRing(tGsmWithGnss *env);
+
+//Ring reset
+void GsmWithGnss_ResetRing(tGsmWithGnss *env);
+
+bool GsmWithGnss_isOutCallActive(tGsmWithGnss *env);
+
+bool GsmWithGnss_isInpCallActive(tGsmWithGnss *env);
+
+void Gsm_WaitGsmBoot(tGsmWithGnss *env);
+
+void Gsm_SetManualModemPower(
+        tGsmWithGnss *env,
+        bool *mode,
+        uint16_t *MODEM_POWER_FOR_LTE_MODE,
+        uint16_t *MODEM_POWER_FOR_WCDMA_MODE,
+        uint16_t *MODEM_POWER_FOR_GSM_MODE
+);
+
+void Gsm_CodecIsConfig(tGsmWithGnss *env);
+
+void AtGsm_Gsnss_NavData_Processing(tGsmWithGnss *env, tAtBuffer *buf);
+//void AtGsm_Gsnss_NavData_Processing(tGsmWithGnss *env);
+
+void GsmWithGnss_resetMsd(tGsmWithGnss *env);
+
+void GsmWithGnss_resetInputCall(tGsmWithGnss *env);
+
+void AtGsm_Gsnss_GetLastActualNavData(tGsmWithGnss *env, EraGlonassUveosNavData *location, bool locSourse);
+
+void HotStartGNSS(tGsmWithGnss *env);
+
+void StopResiver(tGsmWithGnss *env);
+
+void StartResiver(tGsmWithGnss *env);
+
+AtCommandResult GsmWithGnss_AudioFilesValidation(tGsmWithGnss *env);
+
+AtCommandResult Gsm_SturtupCodec(tGsmWithGnss *env);
+
+#endif //HEAVY_TERMINAL_GSMWITHGNSS_H

GsmWithGnss_AudioSettings.c

@@ -0,0 +1,20 @@
+//
+// Created by xemon on 21.10.22.
+//
+
+#include <memory.h>
+#include "GsmWithGnss_Private.h"
+
+void GsmWithGnss_InitAudio(tGsmWithGnss *env) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        AtGsmSetErrorLogLevel(&env->gsmAt, GSM_LOG_ERROR_VERBOSE);
+        osMutexRelease(env->gsmAt.access);
+    } else {
+        bool b;
+        b=true;
+    }
+}
+
+AtCommandResult GsmWithGnss_AudioFilesValidation(tGsmWithGnss *env) {
+
+}

GsmWithGnss_Ecall.c

@@ -0,0 +1,227 @@
+//
+// Created by xemon on 28.11.22.
+//
+
+#include "GsmWithGnss_Private.h"
+#include <SystemDelayInterface.h>
+
+#define LOG_SIGN "Главн. Вкл"
+#define LOGGER env->logger
+
+bool GsmWithGnss_GetCurrentCallGranted(tGsmWithGnss *env, tGsmCurrentCallsTable *callsTable) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        static const uint8_t tries_limit = 10;
+        uint8_t tries = tries_limit;
+        do {
+            bool gotGable = (AtGsmListOfCurrentCalls(&env->gsmAt, callsTable) == AT_OK);
+            if (gotGable) {
+                osMutexRelease(env->gsmAt.access);
+                return true;
+            } else {
+                SystemDelayMs(200);
+                --tries;
+            }
+        } while (tries);
+        osMutexRelease(env->gsmAt.access);
+        return false;
+
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_GetCurrentCallGranted")
+        return false;
+    }
+
+}
+
+bool GsmWithGnss_SetNewMSD(tGsmWithGnss *env,
+                           uint8_t *msd,
+                           size_t msdLength,
+                           eEcallActivationType activationType,
+                           eEcallTestMode testMode
+) {
+//    AtGsmSimComSim7600_EcallSetUrc(&env->gsmAt, GSM_SIMCOM_ECALL_URC_MODE_2);
+    return AtGsmSimComSim7600_ResetiingMsd(&env->gsmAt, msd, msdLength, activationType, testMode) == AT_OK;
+}
+
+bool GsmWithGnss_Ecall(tGsmWithGnss *env,
+                       uint8_t *msd,
+                       size_t msdLength,
+
+                       char *phoneNumber,
+                       size_t phoneNumberLength,
+
+                       eEcallActivationType activationType,
+                       eEcallTestMode testMode
+) {
+    LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверка наличия сети")
+
+//   if(env->flBlockReg == false) {
+//       if( ! GsmWithGnss_WaitNetworkRegistration(env, 4000) ) {
+//           LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации_4...");
+//           if (GsmWithGnss_NetworkSetStateInnaterups(env, 4,6000) == AT_OK) {
+//               LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
+//           } else {
+//               LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует")
+//           }
+//       } else {
+//           LoggerErrorStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует");
+//       }
+//    } else {
+//        LoggerErrorStatic(LOGGER, LOG_SIGN, "Регистрация сети запрещена настройками");
+//    }
+
+    env->urc.msdSendResult = false;
+    return AtGsmSimComSim7600_SendEcall(
+            &env->gsmAt,
+            activationType,
+            testMode,
+            msd,
+            msdLength,
+            phoneNumber,
+            phoneNumberLength
+    ) == AT_OK;
+
+}
+
+bool GsmWithGnss_isCallDialing(tGsmWithGnss *env) {
+    tGsmCurrentCallsTable callsTable;
+    GsmWithGnss_GetCurrentCallGranted(env, &callsTable);
+
+    if (callsTable.count) {
+        for (uint8_t call = 0; call < callsTable.count; ++call) {
+            if (callsTable.calls[call].direction == GSM_CURRENT_CALL_DIRECTION_MOBILE_ORIGINATED) {
+                if (callsTable.calls->state != GSM_CURRENT_CALL_STATE_ACTIVE) {
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+bool GsmWithGnss_isOutCallActive(tGsmWithGnss *env) {
+    tGsmCurrentCallsTable callsTable;
+    GsmWithGnss_GetCurrentCallGranted(env, &callsTable);
+
+    if (callsTable.count) {
+        for (uint8_t call = 0; call < callsTable.count; ++call) {
+            if (callsTable.calls[call].direction == GSM_CURRENT_CALL_DIRECTION_MOBILE_ORIGINATED) {
+                if (callsTable.calls->state == GSM_CURRENT_CALL_STATE_ACTIVE) {
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+bool GsmWithGnss_isInpCallActive(tGsmWithGnss *env) {
+    tGsmCurrentCallsTable callsTable;
+    GsmWithGnss_GetCurrentCallGranted(env, &callsTable);
+
+    if (callsTable.count) {
+        for (uint8_t call = 0; call < callsTable.count; ++call) {
+            if (callsTable.calls[call].direction == GSM_CURRENT_CALL_DIRECTION_MOBILE_TERMINATED) {
+                if (callsTable.calls->state == GSM_CURRENT_CALL_STATE_ACTIVE) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool GsmWithGnss_isMsdReSent(tGsmWithGnss *env) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        AtCmdProcessUnresolvedLines(&env->gsmAt);
+        if(env->urc.msdPull){
+            env->urc.msdPull = false;
+            osMutexRelease(env->gsmAt.access);
+            return true;
+        } else {
+            osMutexRelease(env->gsmAt.access);
+            return false;
+        }
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_isMsdReSent")
+        return false;
+    }
+}
+
+bool GsmWithGnss_isMsdSent(tGsmWithGnss *env) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        AtCmdProcessUnresolvedLines(&env->gsmAt);
+        osMutexRelease(env->gsmAt.access);
+        return env->urc.msdSendResult;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_isMsdSent")
+        return false;
+    }
+}
+
+bool GsmWithGnss_GetUrcIsNetReg(tGsmWithGnss *env) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        AtCmdProcessUnresolvedLines(&env->gsmAt);
+        osMutexRelease(env->gsmAt.access);
+        return env->urc.netReg;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_GetUrcIsNetReg")
+        return false;
+    }
+}
+
+void GsmWithGnss_ResetUrcIsNetReg(tGsmWithGnss *env) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        AtCmdProcessUnresolvedLines(&env->gsmAt);
+        env->urc.netReg = false;
+        osMutexRelease(env->gsmAt.access);
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_GetUrcIsNetReg")
+    }
+}
+
+bool AtGsmPrepHangCall(tGsmWithGnss *env) {
+    AtCommandResult res;
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        res = AtGsmPrepareHangCall(&env->gsmAt);
+        osMutexRelease(env->gsmAt.access);
+        return res;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления AtGsmPrepHangCall")
+    }
+    return AT_ERROR;
+}
+
+bool GsmWithGnss_HangUp(tGsmWithGnss *env) {
+    AtCommandResult res;
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        env->urc.msdSendResult = false;
+        env->urc.msdPull = false;
+        res = AtGsmHangUpCall(&env->gsmAt);
+        osMutexRelease(env->gsmAt.access);
+        return res;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_HangUp")
+    }
+    return AT_ERROR;
+}
+
+bool GsmWithGnss_HangUpEcoll(tGsmWithGnss *env) {
+    AtCommandResult res;
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        env->urc.msdSendResult = false;
+        env->urc.msdPull = false;
+        res = AtGsmHangUpEcoll(&env->gsmAt);
+        GsmWithGnss_resetInputCall(env);
+        osMutexRelease(env->gsmAt.access);
+        return res;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_HangUpEcoll")
+    }
+    return AT_ERROR;
+
+}
+
+
+

GsmWithGnss_GnssOps.c

@@ -0,0 +1,398 @@
+//
+// Created by xemon on 02.09.22.
+//
+
+//#include <Log.h>
+
+#include <memory.h>
+#include "SystemDelayInterface.h"
+#include "AsciiStringAssmeblingUtils.h"
+#include "GsmWithGnss.h"
+#include "AtCmdCommonProtected.h"
+#include "AtGsmSms_DeleteAll.h"
+#include "AtGsmSimcomSim7600.h"
+#include "Rtc.h"
+#include "GsmSimComAudioCodec.h"
+
+#define LOGGER env->logger
+#define LOG_SIGN "GSM&GNSS"
+tGsmWithGnss gnssEnv;
+bool fl_rtcIsUsed = false;
+#define GWG_IER(FUNC) {A}
+
+AtCommandResult GsmWithGnssSimProfileSelect(tAtCmd *gsmAt, tStringLink profileExt) {
+    if (osMutexAcquire(gsmAt->access, 1000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_SimProfileSelect(gsmAt, profileExt) != AT_OK) {
+            osMutexRelease(gsmAt->access);
+            return AT_ERROR;
+        } else {
+            osMutexRelease(gsmAt->access);
+            return AT_OK;
+        }
+    } else {
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssSetModemManualPowerMode(tGsmWithGnss *env, bool *mode) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        AtCommandResult result = AtGsm_Gsnss_Simcom7600_ManualPowerMode(&env->gsmAt, mode);
+        if (result == AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Мощность модема установлена у ручном режиме")
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Не удалось установить мощность модема")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата режима установки мощности модема")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssSetModemGSMPowerMode(tGsmWithGnss *env, uint16_t *value) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_SetModemGSMPowerMode(&env->gsmAt, value) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Мощность модема по каналу GSM установлена")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата режима установки мощности модема по каналу GSM")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssSetModemWCDMAPowerMode(tGsmWithGnss *env, uint16_t *value) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_SetModemWCDMAPowerMode(&env->gsmAt, value) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Мощность модема по каналу WCDMA установлена")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата режима установки мощности модема по каналу WCDMA")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssSetModemLTEPowerMode(tGsmWithGnss *env, uint16_t *value) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_SetModemLTEPowerMode(&env->gsmAt, value) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Мощность модема по каналу LTE установлена")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата режима установки мощности модема по каналу LTE")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssSetEchoMode(tGsmWithGnss *env) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_EchoMode(&env->gsmAt, 1) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Эхо режим установлен")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации эхо режима")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssSetADBConf(tGsmWithGnss *env) {
+    SystemDelayMs(40);
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_OpenADB(&env->gsmAt) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "ADB порт сконфигурирован")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации ADB порта")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssPDUClear(tGsmWithGnss *env) {
+    SystemDelayMs(40);
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        if (AtGsmSms_DeleteAll(&env->gsmAt) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "PDU пакеты очищены")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации очистки СМС")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssSetEcallOnlyMode(tGsmWithGnss *env) {
+    SystemDelayMs(40);
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_EcallOnlyMode(&env->gsmAt, 0) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим EcallOnlyMode сконфигурирован")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации EcallOnlyMode")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssDeleteGpsInfo(tGsmWithGnss *env) {
+    SystemDelayMs(40);
+    if (osMutexAcquire(env->gsmAt.access, 2000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_DeleteGpsInfo(&env->gsmAt) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            osMutexRelease(env->gsmAt.access);
+            return AT_OK;
+        }
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации очистки GNSS данных")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssConfigureAudioProfile(tGsmWithGnss *env, tString32 *profileData) {
+    if (osMutexAcquire(env->gsmAt.access, 3000) == osOK) {
+        AtCommandResult res = AtGsm_Gsnss_Simcom7600_SetConfigureAudioProfile(&env->gsmAt, profileData);
+        if (res!= AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выбора конфигурации аудио профиля в модеме, возможно профиль не загружен")
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Конфигурация аудио профиля выбрана")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации аудио профиля")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssConfigureRMCThread(tGsmWithGnss *env) {
+    SystemDelayMs(40);
+    if (osMutexAcquire(env->gsmAt.access, 2000) == osOK) {
+        if (AtGsm_Gsnss_Simcom7600_SetConfigureStaticRMCThread(&env->gsmAt) != AT_OK) {
+            osMutexRelease(env->gsmAt.access);
+            return AT_ERROR;
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Подсистема GNSS сконфигурирована")
+        }
+        osMutexRelease(env->gsmAt.access);
+        return AT_OK;
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации установки GNSS параметров")
+        return AT_TIMEOUT;
+    }
+}
+
+AtCommandResult GsmWithGnssInitGnss(tGsmWithGnss *env) {
+    AtCommandResult res;
+
+    res = AT_ERROR;
+
+    if(GsmWithGnssSetEchoMode(env) == AT_ERROR) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка установки эхо-режима")
+        res = AT_ERROR;
+    } else {
+        res = AT_OK;
+    }
+
+    if(GsmWithGnssSetADBConf(env) == AT_ERROR) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка конфигурации ADB порта")
+        if(res == AT_OK){
+            res = AT_ERROR;
+        }
+    } else {
+        res = AT_OK;
+    }
+
+    if(GsmWithGnssPDUClear(env) == AT_ERROR) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка очистки СМС сообщений")
+        if(res == AT_OK){
+            res = AT_ERROR;
+        }
+    } else {
+        res = AT_OK;
+    }
+
+    if(GsmWithGnssSetEcallOnlyMode(env) == AT_ERROR) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка конфигурации установки режима EcallOnly")
+        if(res == AT_OK){
+            res = AT_ERROR;
+        }
+    } else {
+        res = AT_OK;
+    }
+
+//    StopResiver(env);
+
+    if(GsmWithGnssDeleteGpsInfo(env) == AT_ERROR) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка очистки навигационного буфера")
+        if(res == AT_OK){
+            res = AT_ERROR;
+        }
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Навигационный буфер GNSS очищен")
+        res = AT_OK;
+    }
+
+    if(GsmWithGnssConfigureRMCThread(env) == AT_ERROR) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка конфигурации и запуска навигационного потока")
+        if(res == AT_OK){
+            res = AT_ERROR;
+        }
+    } else {
+        res = AT_OK;
+    }
+
+    StartResiver(env);
+    return res;
+}
+
+
+AtCommandResult Gsm_SturtupCodec(tGsmWithGnss *env) {
+    AtGsmSimCom_NAU_Codec_Full10w(&env->gsmAt);
+    return AT_OK;
+}
+
+void AtGsm_Gsnss_NavData_Incorrect(tGsmWithGnss *env) {
+    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
+        env->gnss.currentRmc.status = 'V';
+        osMutexRelease(env->gsmAt.access);
+    }
+}
+
+char convertDecToMilliArcSec(double dec, int32_t *mArcs, double *gradus) {
+    int deg = 0, min = 0;
+    double sec = 0.0;
+    double _dec = dec;
+
+    deg = (int) (_dec / 100);
+    min = (int) (_dec) - (deg * 100);
+
+    sec = (double) (_dec - min - 100 * deg) * 60.0;
+
+    if (gradus != NULL) *gradus = deg + min / 60.0 + sec / 3600.0;
+
+    if (mArcs != NULL) *mArcs = (int) (deg * 3600 + min * 60) * 1000 + (int) (sec * 1000);
+
+    return 0;
+}
+
+void NmeaRMCLocationToLocationRMC(tNmeaLocationRmc *nmea, EraGlonassUveosNavData *gnss) {
+    convertDecToMilliArcSec(nmea->latitude, &gnss->latitude, NULL);
+    convertDecToMilliArcSec(nmea->longitude, &gnss->longitude, NULL);
+}
+
+void GnssTaskGetTime(tGsmWithGnss *env, uint32_t *timestamp) {
+    if (osMutexAcquire(env->gnss.rmcAccess, 1000) == osOK) {
+        *timestamp = iNmea0183TimestampFromRmc(&env->gnss.currentRmc);
+        osMutexRelease(env->gnss.rmcAccess);
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (GnssTaskGetTime)")
+    }
+}
+
+void GnssSetRTC(tGsmWithGnss *env) {
+    if (env->gnss.currentRmc.time.second != 0) {
+        if (!fl_rtcIsUsed) {
+            time_t gnssTime;
+            GnssTaskGetTime(env, (uint32_t *) &gnssTime);
+            LoggerFormatInfo(LOGGER, LOG_SIGN, "Получено время с GNSS, временная метка: %u", gnssTime)
+
+            time_t timestampLocal = 0;
+            RtcGet(env->Rtc, &timestampLocal);
+
+            if (timestampLocal < 1718359909) {
+                LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка времени с GNSS")
+                RtcSet(env->Rtc, &gnssTime);
+            }
+
+            fl_rtcIsUsed = true;
+        }
+    }
+}
+
+void AtGsm_Gsnss_NavData_Processing(tGsmWithGnss *env, tAtBuffer *buf) {
+    if (osMutexAcquire(env->gnss.rmcAccess, 1000) == osOK) {
+        if (bNmea0183IsRmcString(buf->data, buf->len)) {
+            if (bNmea0183IsValidString(buf->data, buf->len)) {
+                bNmea0183ParseRMC(buf->data + 7, buf->len - 7, &env->gnss.currentRmc);
+                if (env->gnss.currentRmc.status == 'A') {
+                    env->gnss.prevRmc = env->gnss.currentRmc;
+                }
+            }
+        }
+        osMutexRelease(env->gnss.rmcAccess);
+        GnssSetRTC(env);
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа AtGsm_Gsnss_NavData_Processing")
+    }
+}
+
+void AtGsm_Gsnss_GetLastActualNavData(tGsmWithGnss *env, EraGlonassUveosNavData *location, bool locSourse) {
+    if (osMutexAcquire(env->gnss.rmcAccess, 1000) == osOK) {
+        if (env->gnss.currentRmc.status == 'A') {
+            env->gnss.prevRmc = env->gnss.currentRmc;
+            location->valid = 2;
+        } else {
+            if (env->gnss.prevRmc.status == 'A') {
+                env->gnss.currentRmc = env->gnss.prevRmc;
+                env->gnss.currentRmc.status = 'V';
+                location->valid = 1;
+            } else if (env->gnss.prevRmc.location.latitude < 1) {
+                env->gnss.currentRmc.status = 'V';
+                location->valid = 0;
+            }
+        }
+        osMutexRelease(env->gnss.rmcAccess);
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа AtGsm_Gsnss_GetLastActualNavData")
+    }
+}
+
+void GnssGetNavData(tGsmWithGnss *env, EraGlonassUveosNavData *location, bool locSourse) {
+    GnssSetRTC(env);
+    AtGsm_Gsnss_GetLastActualNavData(env, location, locSourse);
+
+    if (osMutexAcquire(env->gnss.rmcAccess, 1000) == osOK) {
+        NmeaRMCLocationToLocationRMC(&env->gnss.currentRmc.location, location);
+        location->direction = (uint16_t) env->gnss.currentRmc.headingAngle;
+        osMutexRelease(env->gnss.rmcAccess);
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GnssGetNavData")
+    }
+}

GsmWithGnss_Private.h

@@ -0,0 +1,53 @@
+//
+// Created by zemon on 05.04.23.
+//
+
+#ifndef UVEOS_ON_NATION_GSMWITHGNSS_PRIVATE_H
+#define UVEOS_ON_NATION_GSMWITHGNSS_PRIVATE_H
+
+#include "GsmWithGnss.h"
+
+void GnssGetNavData(tGsmWithGnss *env, EraGlonassUveosNavData *location, bool locSourse);
+
+void GnssTaskGetTime(tGsmWithGnss *env, uint32_t *timestamp);
+
+bool GsmWithGnss_Ecall(tGsmWithGnss *env,
+                       uint8_t *msd,
+                       size_t msdLength,
+
+                       char *phoneNumber,
+                       size_t phoneNumberLength,
+
+                       eEcallActivationType activationType,
+                       eEcallTestMode testMode
+);
+
+bool GsmWithGnss_isCallDialing(tGsmWithGnss *env);
+
+bool GsmWithGnss_isMsdSent(tGsmWithGnss *env);
+
+bool GsmWithGnss_GetUrcIsNetReg(tGsmWithGnss *env);
+
+void GsmWithGnss_ResetUrcIsNetReg(tGsmWithGnss *env);
+
+bool GsmWithGnss_HangUp(tGsmWithGnss *env);
+
+bool GsmWithGnss_HangUpEcoll(tGsmWithGnss *env);
+
+bool AtGsmPrepHangCall(tGsmWithGnss *env);
+
+bool GsmWithGnss_isMsdReSent(tGsmWithGnss *env);
+
+AtCommandResult GsmWithGnssSetModemManualPowerMode(tGsmWithGnss *env, bool *mode);
+AtCommandResult GsmWithGnssSetModemLTEPowerMode(tGsmWithGnss *env, uint16_t *value);
+AtCommandResult GsmWithGnssSetModemWCDMAPowerMode(tGsmWithGnss *env, uint16_t *value);
+AtCommandResult GsmWithGnssSetModemGSMPowerMode(tGsmWithGnss *env, uint16_t *value);
+
+
+//sms
+
+
+bool GsmWithGnss_SendDataPduSms(tGsmWithGnss *env, char *phone, uint8_t phoneSize, uint8_t *data, uint16_t dataSize);
+
+//ring
+#endif //UVEOS_ON_NATION_GSMWITHGNSS_PRIVATE_H

GsmWithGnss_Sms.c

@@ -0,0 +1,17 @@
+//
+// Created by xemon on 28.11.22.
+//
+
+#include "GsmWithGnss_Private.h"
+#include "AtGsmSms_Utils.h"
+
+
+
+bool GsmWithGnss_SendDataPduSms(tGsmWithGnss *env, char *phone, uint8_t phoneSize, uint8_t *data, uint16_t dataSize) {
+    return AtGsmSms_UtilsSendPduData(
+            &env->gsmAt,
+            env->smsCenter->data, env->smsCenter->length,
+            phone, phoneSize,
+            data, dataSize
+    ) == AT_OK;
+}

modular.json

@@ -0,0 +1,37 @@
+{
+  "dep": [
+    {
+      "type": "git",
+      "provider": "Smart_Components_Aurus",
+      "repo": "EraGlonassUveos"
+    },
+    {
+      "type": "git",
+      "provider": "Smart_Components_Aurus",
+      "repo": "SystemDelayInterface"
+    },
+    {
+      "type": "git",
+      "provider": "Smart_Components_Aurus",
+      "repo": "AtGsmSim7600"
+    },
+    {
+      "type": "git",
+      "provider": "Smart_Components_Aurus",
+      "repo": "AtGsmSms_Utils"
+    },
+    {
+      "type": "git",
+      "provider": "Smart_Components_Aurus",
+      "repo": "ControllableSwitch"
+    }
+  ],
+  "cmake": {
+    "inc_dirs": [
+      "./"
+    ],
+    "srcs": [
+      "*.c"
+    ]
+  }
+}