From 04cf0dba2f6e193e35a9a0c9640ad09dab728a0c Mon Sep 17 00:00:00 2001 From: cfif Date: Mon, 2 Jun 2025 13:26:40 +0300 Subject: [PATCH] Init --- GsmWithGnss.c | 464 ++++++++++++++++++++++++++++++++++++ GsmWithGnss.h | 184 ++++++++++++++ GsmWithGnss_AudioSettings.c | 20 ++ GsmWithGnss_Ecall.c | 227 ++++++++++++++++++ GsmWithGnss_GnssOps.c | 398 +++++++++++++++++++++++++++++++ GsmWithGnss_Private.h | 53 ++++ GsmWithGnss_Sms.c | 17 ++ modular.json | 37 +++ 8 files changed, 1400 insertions(+) create mode 100644 GsmWithGnss.c create mode 100644 GsmWithGnss.h create mode 100644 GsmWithGnss_AudioSettings.c create mode 100644 GsmWithGnss_Ecall.c create mode 100644 GsmWithGnss_GnssOps.c create mode 100644 GsmWithGnss_Private.h create mode 100644 GsmWithGnss_Sms.c create mode 100644 modular.json diff --git a/GsmWithGnss.c b/GsmWithGnss.c new file mode 100644 index 0000000..d1ce186 --- /dev/null +++ b/GsmWithGnss.c @@ -0,0 +1,464 @@ +#include +// +// 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 +#include +#include +#include +#include +#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 подсистемы") + } +} + + + + + + + diff --git a/GsmWithGnss.h b/GsmWithGnss.h new file mode 100644 index 0000000..8d391b5 --- /dev/null +++ b/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 +#include +#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 diff --git a/GsmWithGnss_AudioSettings.c b/GsmWithGnss_AudioSettings.c new file mode 100644 index 0000000..316a8f4 --- /dev/null +++ b/GsmWithGnss_AudioSettings.c @@ -0,0 +1,20 @@ +// +// Created by xemon on 21.10.22. +// + +#include +#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) { + +} \ No newline at end of file diff --git a/GsmWithGnss_Ecall.c b/GsmWithGnss_Ecall.c new file mode 100644 index 0000000..7fb3246 --- /dev/null +++ b/GsmWithGnss_Ecall.c @@ -0,0 +1,227 @@ +// +// Created by xemon on 28.11.22. +// + +#include "GsmWithGnss_Private.h" +#include + +#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; + +} + + + diff --git a/GsmWithGnss_GnssOps.c b/GsmWithGnss_GnssOps.c new file mode 100644 index 0000000..298087d --- /dev/null +++ b/GsmWithGnss_GnssOps.c @@ -0,0 +1,398 @@ +// +// Created by xemon on 02.09.22. +// + +//#include + +#include +#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, ×tampLocal); + + 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") + } +} \ No newline at end of file diff --git a/GsmWithGnss_Private.h b/GsmWithGnss_Private.h new file mode 100644 index 0000000..b3b5e47 --- /dev/null +++ b/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 diff --git a/GsmWithGnss_Sms.c b/GsmWithGnss_Sms.c new file mode 100644 index 0000000..a8aad00 --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..af68126 --- /dev/null +++ b/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" + ] + } +} \ No newline at end of file