NAVIGATOR_UVEOS_NATION_TELIT
/
AtGsmTelitLe910
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Init

This commit is contained in:
cfif 2024-12-04 13:10:49 +03:00
commit 2ebc49112a
10 changed files with 871 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Inc/AtGsmTelitLe910.h Normal file
View File

@ -0,0 +1,14 @@
//
// Created by xemon on 06.09.22.
//
#ifndef GSMPN6280_GSMPN6280_H
#define GSMPN6280_GSMPN6280_H
#include "AtGsmCommon.h"
#include "AtGsmTelitLe910_Gnss.h"
#include "AtGsmTelitLe910_DigitalVoicebandInterface.h"
#include "AtGsmTelitLe910_Ecall.h"
#include "AtGsmTelitLe910_AudioFileAndStream.h"
#endif //GSMPN6280_GSMPN6280_H

36
Inc/AtGsmTelitLe910_AudioFileAndStream.h Normal file
View File

@ -0,0 +1,36 @@
//
// Created by xemon on 14.11.22.
//
#ifndef UVEOS_ON_NATION_ATGSMTELITLE910_AUDIOFILEANDSTREAM_H
#define UVEOS_ON_NATION_ATGSMTELITLE910_AUDIOFILEANDSTREAM_H
#include "AtCmdCommon.h"
AtCommandResult AtGsmTelitLe910_DeleteAllAudioFiles(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_SendAudioFile(tAtCmd *env, char *name, size_t nameLen, uint8_t *data, size_t dataLen);
typedef enum {
TELIT_AUDIO_FILE_PLAY_TO_SPEAKER = '0',
TELIT_AUDIO_FILE_PLAY_TO_UPLINK = '1'
} eTelitPlayAudioFileDir;
AtCommandResult AtGsmTelitLe910_RecorderAudioFileStart(tAtCmd *env, char *name, size_t nameLen);
AtCommandResult AtGsmTelitLe910_RecorderAudioFileStop(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_DeleteAudioFile(tAtCmd *env, char *name, size_t nameLen) ;
AtCommandResult AtGsmTelitLe910_RecAudioWaitEnd(tAtCmd *env, uint32_t timeout);
AtCommandResult AtGsmTelitLe910_PlayAudioFileTo(tAtCmd *env, eTelitPlayAudioFileDir dir, char *name, size_t nameLen);
#define AtGsmTelitLe910_PlayAudioFileStatic(ENV, STR) AtGsmTelitLe910_PlayAudioFileTo(ENV,TELIT_AUDIO_FILE_PLAY_TO_SPEAKER,STR,sizeof(STR)-1)
AtCommandResult AtGsmTelitLe910_PlayAudioWaitEnd(tAtCmd *env, uint32_t timeout);
AtCommandResult AtGsmTelitLe910_PlayAudioStop(tAtCmd *env);
#endif //UVEOS_ON_NATION_ATGSMTELITLE910_AUDIOFILEANDSTREAM_H

41
Inc/AtGsmTelitLe910_DigitalVoicebandInterface.h Normal file
View File

@ -0,0 +1,41 @@
//
// Created by xemon on 20.10.22.
//
#ifndef UVEOS_ON_NATION_ATGSMTELITLE910_AUDIOINTERFACE_H
#define UVEOS_ON_NATION_ATGSMTELITLE910_AUDIOINTERFACE_H
#include "AtCmdCommon.h"
typedef enum {
AT_GSM_TELIT_910_DVI_CLOCK_0_KHz = 0,
AT_GSM_TELIT_910_DVI_CLOCK_128_KHz = 7,
AT_GSM_TELIT_910_DVI_CLOCK_256_KHz = 8,
AT_GSM_TELIT_910_DVI_CLOCK_512_KHz = 9,
AT_GSM_TELIT_910_DVI_CLOCK_1024_KHz = 10,
AT_GSM_TELIT_910_DVI_CLOCK_2048_KHz = 11,
AT_GSM_TELIT_910_DVI_CLOCK_4096_KHz = 12,
} eAtGsmTelitLe910DviClock;
typedef enum {
AT_GSM_TELIT_910_DVI_SAMPLE_RATE_8KHz = '0',
AT_GSM_TELIT_910_DVI_SAMPLE_RATE_16KHz = '1',
} eAtGsmTelitLe910DviSampleRate;
AtCommandResult AtGsmTelitLe910_SetSpeakerVolumeLevel(tAtCmd *env, uint16_t level);
AtCommandResult AtGsmTelitLe910_DviEnableMaster(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_DviToPcmMode(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_DviPcmClk(
tAtCmd *env,
eAtGsmTelitLe910DviClock clock,
eAtGsmTelitLe910DviSampleRate sampleRate
);
AtCommandResult AtGsmTelitLe910_DviToI2s16Khz(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_DviToI2s8Khz(tAtCmd *env);
#endif //UVEOS_ON_NATION_ATGSMTELITLE910_AUDIOINTERFACE_H

44
Inc/AtGsmTelitLe910_Ecall.h Normal file
View File

@ -0,0 +1,44 @@
//
// Created by xemon on 24.10.22.
//
#ifndef UVEOS_ON_NATION_ATGSMTELITLE910_ECALL_H
#define UVEOS_ON_NATION_ATGSMTELITLE910_ECALL_H
#include "AtCmdCommon.h"
typedef enum {
GSM_ECALLTYPE_TEST = 0,
GSM_ECALLTYPE_RECONFIGURATION = 1,
GSM_ECALLTYPE_MANUAL = 2,
GSM_ECALLTYPE_AUTOMATIC = 3,
} eGsmEcallType;
typedef enum {
GSM_TELIT_ECALL_URC_MODE_0 = '0',
GSM_TELIT_ECALL_URC_MODE_1 = '1',
GSM_TELIT_ECALL_URC_MODE_2 = '2'
} eGsmTelitEcallUrcLevel;
AtCommandResult AtGsmTelitLe910_EcallSetUrc(tAtCmd *env, eGsmTelitEcallUrcLevel mode);
AtCommandResult AtGsmTelitLe910_SendEcall(
tAtCmd *env,
uint8_t *msd,
size_t msdLength,
char *phoneNumber,
size_t phoneNumberLength,
eGsmEcallType ecallType
);
AtCommandResult AtGsmTelitLe910_ResetiingMsd(
tAtCmd *env,
uint8_t *msd,
size_t msdLength
);
#endif //UVEOS_ON_NATION_ATGSMTELITLE910_ECALL_H

51
Inc/AtGsmTelitLe910_Gnss.h Normal file
View File

@ -0,0 +1,51 @@
//
// Created by zemon on 21.10.22.
//
#ifndef UVEOS_ON_NATION_ATGSMTELITLE910_GNSS_H
#define UVEOS_ON_NATION_ATGSMTELITLE910_GNSS_H
#include "AtCmdCommon.h"
#include "BaseTypes/Strings.h"
typedef enum {
TELIT_LE910_EXTERNAL_LNA_NOT_SUPPORT = '0',
TELIT_LE910_EXTERNAL_LNA_SUPPORT = '1'
} eTelitLe910_ExternalLnaSupportMode;
AtCommandResult AtGsmTelitLe910_Gnss_ClearRxGnssBuf(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_GnssSwitchOnRestoreParam(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_GnssEcallOnlyMode(tAtCmd *env, bool mode);
AtCommandResult AtGsmTelitLe910_Gnss_ClearNvramGnssBuf(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_Gnss_ClearStaticBufFix(tAtCmd *env);
AtCommandResult xAtGsmTelitLe910_Gnss_xClearBuf(tAtCmd *env, char value, uint8_t paramLen);
AtCommandResult xAtGsmTelitLe910_Gnss_GetAcquiredPositionRMC(tAtCmd *env, char *acpString, size_t *acpStringLen, uint32_t timeout);
AtCommandResult xAtGsmTelitLe910_Gnss_GetAcquiredPositionNMEA(tAtCmd *env, char *acpString, size_t *acpStringLen, uint32_t timeout);
AtCommandResult AtGsmTelitLe910_Gnss_ReStartReceiver(tAtCmd *env, bool value);
AtCommandResult AtGsmTelitLe910_Gnss_GetExternalLnaSupport(tAtCmd *env, eTelitLe910_ExternalLnaSupportMode *value);
AtCommandResult AtGsmTelitLe910_Gnss_ActivateRMCPort(tAtCmd *env);
AtCommandResult AtGsmTelitLe910_Gsm_RSSI(tAtCmd *env, char *rsi, uint8_t *len);
AtCommandResult AtGsmTelitLe910_Gnss_AGPSup(tAtCmd *env, bool value);
AtCommandResult GsmWithGnss_setCodecConf(tAtCmd *env, tString32 codecConf);
//Set command is used to enable/disable GNSS External LNA(Low Noise Amplifier) Support
//1. If <mode> is 0, GNSS RF receiver is high gain mode. If <mode> is 1, GNSS RF receiver is low gain mode.
//2. If the GNSS external LNA isn’t supported on H/W, please never set <mode>=1 (Support GNSS External LNA).
//3. This setting is dependent on H/W Design.
//4. The current setting is stored in NVM.
AtCommandResult AtGsmTelitLe910_Gnss_ExternalLnaSupport(tAtCmd *env, eTelitLe910_ExternalLnaSupportMode value);
#endif //UVEOS_ON_NATION_ATGSMTELITLE910_GNSS_H

80
Src/AtGsmTelitLe910_AudioFileAndStream.c Normal file
View File

@ -0,0 +1,80 @@
//
// Created by xemon on 14.11.22.
//
#include "AtGsmTelitLe910_AudioFileAndStream.h"
#include <AtCmdCommonProtected.h>
#include <SystemDelayInterface.h>
AtCommandResult AtGsmTelitLe910_DeleteAllAudioFiles(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#ADELA\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_DeleteAudioFile(tAtCmd *env, char *name, size_t nameLen) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT#ADELF=");
AtCmdTxAddStatic(env, "\"");
AtCmdTxAdd(env, name, nameLen);
AtCmdTxAddStatic(env, "\"");
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_SendAudioFile(tAtCmd *env, char *name, size_t nameLen, uint8_t *data, size_t dataLen) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT#ASEND=\"");
AtCmdTxAdd(env, name, nameLen);
AtCmdTxAddStatic(env, "\",");
AtCmdTxAddDecimalIntWithLimit(env, nameLen, 8);
AtCmdTxSendLn(env);
SystemDelayMs(5);
AtCmdSend(env, data, dataLen);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_RecorderAudioFileStart(tAtCmd *env, char *name, size_t nameLen) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT#ARECD=1,");
AtCmdTxAddStatic(env, "\"");
AtCmdTxAdd(env, name, nameLen);
AtCmdTxAddStatic(env, "\"");
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_RecorderAudioFileStop(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#ARECD=0\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_PlayAudioFileTo(tAtCmd *env, eTelitPlayAudioFileDir dir, char *name, size_t nameLen) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT#APLAY=1,");
AtCmdTxAddChar(env, dir);
AtCmdTxAddStatic(env, ",\"");
AtCmdTxAdd(env, name, nameLen);
AtCmdTxAddStatic(env, "\"");
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_PlayAudioWaitEnd(tAtCmd *env, uint32_t timeout) {
return AtCmdWaitPrefixStatic(env, timeout, "#APLAYEV: 0");
}
AtCommandResult AtGsmTelitLe910_RecAudioWaitEnd(tAtCmd *env, uint32_t timeout) {
return AtCmdWaitPrefixStatic(env, timeout, "#ARECDEV: 0");
}
AtCommandResult AtGsmTelitLe910_PlayAudioStop(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#APLAY=0\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

59
Src/AtGsmTelitLe910_DigitalVoicebandInterface.c Normal file
View File

@ -0,0 +1,59 @@
//
// Created by xemon on 20.10.22.
//
#include "AtGsmTelitLe910_DigitalVoicebandInterface.h"
#include <AtCmdCommonProtected.h>
AtCommandResult AtGsmTelitLe910_SetSpeakerVolumeLevel(tAtCmd *env, uint16_t level) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT#PCMRXG=");
AtCmdTxAddDecimalIntWithLimit(env, level, 4);
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_DviEnableMaster(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#DVI=1,2,1\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_DviToPcmMode(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#DVIEXT=0\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_DviPcmClk(
tAtCmd *env,
eAtGsmTelitLe910DviClock clock,
eAtGsmTelitLe910DviSampleRate sampleRate
) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT#DVICLK=");
AtCmdTxAddDecimalIntWithLimit(env, (1 << clock), 4);
AtCmdTxAddStatic(env, ",");
AtCmdTxAdd(env, (char *) &sampleRate, 1);
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_DviToI2s16Khz(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#DVIEXT=1,1\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_DviToI2s8Khz(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#DVIEXT=1,0\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}

143
Src/AtGsmTelitLe910_Ecall.c Normal file
View File

@ -0,0 +1,143 @@
//
// Created by xemon on 24.10.22.
//
#include <AsciiStringAssmeblingUtils.h>
#include <AtCmdCommonProtected.h>
#include <string.h>
#include <SystemDelayInterface.h>
#include "AtGsmTelitLe910_Ecall.h"
AtCommandResult AtGsmTelitLe910_EcallSetUrc(tAtCmd *env, eGsmTelitEcallUrcLevel mode) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT#ECALLURC=");
AtCmdTxAddChar(env, mode);
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_EcallSetTestNumber(tAtCmd *env, char *phoneNumber, size_t phoneNumberLength) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT#TESTNUM=0,");
AtCmdTxAdd(env, phoneNumber, phoneNumberLength);
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_EcallSetModeBattle(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#ECALL=1\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_SIMCardDetect(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#SIMDET=1\r\n");
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_EcallWriteMsdToModem(tAtCmd *env, uint8_t *msd, size_t msdLength) {
//prepare msd data packet
char dataInModemFormat[281];
size_t dataInModemFormatLen = 0;
memset(dataInModemFormat, '0', 281);
vAsciiStringAddBytesAsHex(dataInModemFormat, &dataInModemFormatLen, msd, msdLength);
dataInModemFormat[280] = 0x1A;
//execute at
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#MSDSEND\r\n");
AtCmdWaitChar(env, 10000, '>');
AtCmdSend(env, (uint8_t *) dataInModemFormat, 281);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_EcallPushMsd(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdSendStatic(env, "AT#MSDPUSH\r\n");
return AtCmdOkErrAnswer(env, 2 * env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_EcallMake(tAtCmd *env, eGsmEcallType value) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT+CECALL=");
AtCmdTxAddDecimalInt(env, value, 1);
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, 25 * env->stdRxTimeout);
}
//GsmCommandResult AtGsmTelitLe910_EcallMsdRead(tGsmAt *env) {
// vGsmClearRx(env);
// vSendAtStatic(env, "AT#MSDREAD\r");
// xGsmWaitAnswerLine(env, "#MSDREAD:", 20000);
// return xGsmOkErrAnswer(env, 1000);
//}
AtCommandResult AtGsmTelitLe910_SendEcall(
tAtCmd *env,
uint8_t *msd,
size_t msdLength,
char *phoneNumber,
size_t phoneNumberLength,
eGsmEcallType ecallType
) {
if (ecallType == GSM_ECALLTYPE_TEST) {
AT_INOKR(AtGsmTelitLe910_EcallSetTestNumber(env, phoneNumber, phoneNumberLength))
SystemDelayMs(100);
}
AT_INOKR(AtGsmTelitLe910_EcallSetModeBattle(env))
SystemDelayMs(100);
AT_INOKR(AtGsmTelitLe910_EcallWriteMsdToModem(env, msd, msdLength))
SystemDelayMs(100);
AT_INOKR(AtGsmTelitLe910_EcallPushMsd(env))
SystemDelayMs(100);
AT_INOKR(AtGsmTelitLe910_EcallMake(env, ecallType))
return AT_OK;
}
AtCommandResult AtGsmTelitLe910_ResetiingMsd(
tAtCmd *env,
uint8_t *msd,
size_t msdLength
) {
AT_INOKR(AtGsmTelitLe910_EcallWriteMsdToModem(env, msd, msdLength))
SystemDelayMs(100);
AT_INOKR(AtGsmTelitLe910_EcallPushMsd(env))
return AT_OK;
}

381
Src/AtGsmTelitLe910_Gnss.c Normal file
View File

@ -0,0 +1,381 @@
//
// Created by xemon on 06.09.22.
//
#include "AtGsmTelitLe910.h"
#include "AtCmdCommonProtected.h"
#include "SystemDelayInterface.h"
#include <stdbool.h>
#include <string.h>
AtCommandResult AtGsmTelitLe910_Gnss_ClearRxGnssBuf(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT$GPSCLRX\r\n");
return AtCmdOkErrAnswer(env, 2000 * env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_GnssSwitchOnRestoreParam(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT$GPSRST\r\n");
return AtCmdOkErrAnswer(env, 2000 * env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_GnssEcallOnlyMode(tAtCmd *env, bool mode) {
AtCmdPrepare(env);
AtCmdTxClear(env);
if(mode){
AtCmdSendStatic(env, "AT#ECONLY=1\r\n");
} else{
AtCmdSendStatic(env, "AT#ECONLY=0\r\n");
}
return AtCmdOkErrAnswer(env, 2000 * env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_Gnss_ClearNvramGnssBuf(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT$GPSNVRAM=15,0\r\n");
return AtCmdOkErrAnswer(env, 2000 * env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_Gnss_ClearStaticBufFix(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT$GPSACP\r\n");
return AtCmdOkErrAnswer(env, 2000 * env->stdRxTimeout);
}
AtCommandResult xAtGsmTelitLe910_Gnss_xClearBuf(tAtCmd *env, char value, uint8_t paramLen) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT$GPSNVRAM=");
AtCmdTxAdd(env, &value, paramLen);
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, 5000 * env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_Gnss_ReStartReceiver(tAtCmd *env, bool value) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT$GPSP=");
AtCmdTxAddChar(env, value ? '1' : '0');
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, 5 * env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_Gnss_AGPSup(tAtCmd *env, bool value) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT$AGPSEN=0");
return AtCmdOkErrAnswer(env, 2000 * env->stdRxTimeout);
}
AtCommandResult AtGsmTelitLe910_Gnss_ExternalLnaSupport(tAtCmd *env, eTelitLe910_ExternalLnaSupportMode value) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT$GPSELNA=");
AtCmdTxAddChar(env, value);
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, 2 * env->stdRxTimeout);
}
AtCommandResult
xAtGsmTelitLe910_Gnss_GetAcquiredPositionRMC(tAtCmd *env, char *acpString, size_t *acpStringLen, uint32_t timeout) {
}
AtCommandResult
xAtGsmTelitLe910_Gnss_GetAcquiredPositionNMEA(tAtCmd *env, char *acpString, size_t *acpStringLen, uint32_t timeout) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT$GPSACP\r\n");
*acpStringLen = 0;
bool hasValue = false;
while (AtCmdReceiveNextLine(env, timeout) == AT_OK) {
if (AtCmdRxBeginWithStatic(env, "ERROR")) {
return AT_ERROR;
}
if (AtCmdRxBeginWithStatic(env, "OK")) {
return hasValue ? AT_OK : AT_ERROR;
}
if (AtCmdRxBeginWithStatic(env, "$GPSACP:")) {
*acpStringLen = env->rxBuffer.len;
memcpy(acpString, env->rxBuffer.data, *acpStringLen);
hasValue = true;
}
}
return AT_TIMEOUT;
}
AtCommandResult AtGsmTelitLe910_Gnss_GetExternalLnaSupport(tAtCmd *env, eTelitLe910_ExternalLnaSupportMode *value) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT$GPSELNA?\r\n");
static const uint32_t timeout = 1000;
uint32_t endTimeout = SystemGetMs() + timeout;
bool hasValue = false;
while (AtCmdReceiveNextLine(env, endTimeout - SystemGetMs()) == AT_OK) {
if (AtCmdRxBeginWithStatic(env, "ERROR")) {
return AT_ERROR;
}
if (AtCmdRxBeginWithStatic(env, "OK")) {
return hasValue ? AT_OK : AT_ERROR;
}
if (AtCmdRxBeginWithStatic(env, "$GPSELNA: ")) {
*value = env->rxBuffer.data[sizeof("$GPSELNA: ") - 1];
hasValue = true;
}
AtCmdProcessUnresolvedLine(env);
}
return AT_TIMEOUT;
}
//deprecated
//#define GsmWithGnss_ActivateRMCPort AtGsmTelitLe910_Gnss_ActivateRMCPort
AtCommandResult AtGsmTelitLe910_Gnss_ActivateRMCPort(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT&K0\r\n");
while (AtCmdReceiveNextLine(env, 500) == AT_OK) {
if (AtCmdWaitOk(env, 100, 500) == AT_OK) {
return AT_OK;
} else {
return AT_ERROR;
}
}
return AT_TIMEOUT;
}
AtCommandResult GsmWithGnss_ActivateRMCPort(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT&K0\r\n");
while (AtCmdReceiveNextLine(env, 500) == AT_OK) {
if (AtCmdWaitOk(env, 100, 500) == AT_OK) {
return AT_OK;
} else {
return AT_ERROR;
}
}
return AT_TIMEOUT;
}
AtCommandResult GsmWithGnss_SelectStandartNetwork(tAtCmd *env, uint8_t standatr) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdTxAddStatic(env, "AT+WS46=");
AtCmdTxAddDecimalIntWithLimit(env, standatr, 3);
AtCmdTxSendLn(env);
return AtCmdOkErrAnswer(env, env->stdRxTimeout);
}
AtCommandResult GsmWithGnss_StartRMCThread(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT$GPSNMUN=3,0,0,0,0,1,0\r\n");
static const uint32_t timeout = 1000;
uint32_t endTimeout = SystemGetMs() + timeout;
AtCommandResult res;
while (AtCmdReceiveNextLine(env, endTimeout - SystemGetMs()) == AT_OK) {
if (AtCmdRxBeginWithStatic(env, "CONNECT")) {
res = AT_OK;
}
}
if (res != AT_OK) {
res = AT_TIMEOUT;
}
return res;
}
AtCommandResult GsmWithGnss_StopRMCThread(tAtCmd *env) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "+++");
static const uint32_t timeout = 2000;
uint32_t endTimeout = SystemGetMs() + timeout;
AtCommandResult res;
while (AtCmdReceiveNextLine(env, endTimeout - SystemGetMs()) == AT_OK) {
if (AtCmdRxBeginWithStatic(env, "NO CARRIER")) {
res = AT_OK;
}
}
if (res != AT_OK) {
res = AT_TIMEOUT;
}
return res;
}
AtCommandResult GsmWithGnss_GetCGSN(tAtCmd *env, char *acpString, size_t *acpStringLen) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT#CGSN\r\n");
SystemDelayMs(2000);
while (AtCmdReceiveNextLine(env, 15000) == AT_OK) {
if (AtCmdRxBeginWithStatic(env, "#CGSN: ")) {
static const uint16_t prefixSize = sizeof("#CGSN: ") - 1;
*acpStringLen = env->rxBuffer.len - (prefixSize + 2);
memcpy(acpString, env->rxBuffer.data + prefixSize, *acpStringLen);
return AT_OK;
}
if (AtCmdRxBeginWithStatic(env, "ERROR")) {
return AT_ERROR;
}
}
return AT_TIMEOUT;
}
AtCommandResult GsmWithGnss_GetCCID(tAtCmd *env, char *acpStr, size_t *acpStrLen) {
// AtCmdPrepare(env);
// AtCmdRxClear(env);
// AtCmdSendStatic(env, "AT#CCID\r\n");
//
// uint32_t timeout = 4000;
// uint32_t endMs = SystemGetMs() + timeout;
// uint32_t leftMs = timeout;
//
// while ((AtCmdReceiveNextLine(env, leftMs) == AT_OK) && (SystemGetMs() < endMs)) {
// leftMs = endMs - SystemGetMs();
//
// if (AtCmdRxBeginWithStatic(env, "OK")) {
// AtCmdRxClear(env);
// continue;
//
// } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
// AtCmdRxClear(env);
// return AT_ERROR;
//
// } else if (AtCmdRxBeginWithStatic(env, "#CCID: ")) {
//
// static const uint16_t prefixSize = sizeof("#CCID: ") - 1;
// *acpStrLen = env->rxBuffer.len - (prefixSize + 2);
// memcpy(acpStr, env->rxBuffer.data+ prefixSize,*acpStrLen);
// AtCmdRxClear(env);
// return AT_OK;
//
// } else {
// AtCmdProcessUnresolvedLine(env);
// AtCmdRxClear(env);
// continue;
// }
// }
// return AT_TIMEOUT;
//
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT#CCID\r\n");
while (AtCmdReceiveNextLine(env, 1500) == AT_OK) {
if (AtCmdRxBeginWithStatic(env, "#CCID: ")) {
static const uint16_t prefixSize = sizeof("#CCID: ") - 1;
*acpStrLen = env->rxBuffer.len - (prefixSize + 2);
memcpy(acpStr, env->rxBuffer.data+ prefixSize,*acpStrLen);
return AT_OK;
}
if (AtCmdRxBeginWithStatic(env, "ERROR")) {
return AT_ERROR;
}
}
return AT_TIMEOUT;
}
AtCommandResult AtGsmTelitLe910_Gsm_RSSI(tAtCmd *env, char *rsi, uint8_t *len) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT+CSQ\r\n");
static const uint32_t timeout = 500;
uint32_t endTimeout = SystemGetMs() + timeout;
bool hasValue = false;
while (AtCmdReceiveNextLine(env, endTimeout - SystemGetMs()) == AT_OK) {
if (AtCmdRxBeginWithStatic(env, "ERROR")) {
return AT_ERROR;
}
if (AtCmdRxBeginWithStatic(env, "OK")) {
return hasValue ? AT_OK : AT_ERROR;
}
if (AtCmdRxBeginWithStatic(env, "+CSQ: ")) {
static const uint16_t prefixSize = sizeof("+CSQ: ") - 1;
*rsi = env->rxBuffer.data[sizeof("+CSQ: ") - 1];
*len = env->rxBuffer.len;
hasValue = true;
}
AtCmdProcessUnresolvedLine(env);
}
return AT_TIMEOUT;
}
AtCommandResult GsmWithGnss_setCodecConf(tAtCmd *env, tString32 codecConf) {
AtCmdPrepare(env);
AtCmdTxClear(env);
AtCmdSendStatic(env, "AT#I2CWR=2,3,20,2,15\r\n");
SystemDelayMs(500);
AtCmdSend(env, codecConf.data, codecConf.length);
SystemDelayMs(500);
AtCmdSendStatic(env, "\x1A");
return AT_OK;
// AtCmdPrepare(env);
//
// AtCmdTxClear(env);
// AtCmdSendStatic(env, "AT#I2CWR=2,3,20,2,15\r\n");
// SystemDelayMs(500);
// AtCmdSendStatic(env, "00109000040033060f20320000008a");
// SystemDelayMs(500);
// AtCmdSendStatic(env, "\x1A");
// return AT_OK;
}

22
modular.json Normal file
View File

@ -0,0 +1,22 @@
{
"dep": [
{
"type": "git",
"provider": "NAVIGATOR_UVEOS_NATION_TELIT",
"repo": "AsciiStringAssemblingUtils"
},
{
"type": "git",
"provider": "NAVIGATOR_UVEOS_NATION_TELIT",
"repo": "AtGsmCommon"
}
],
"cmake": {
"inc_dirs": [
"Inc"
],
"srcs": [
"Src/**.c"
]
}
}