650 lines
19 KiB
C
650 lines
19 KiB
C
#include <stdlib.h>
|
|
#include <stdbool.h>
|
|
|
|
#include "main.h"
|
|
#include "usart.h"
|
|
#include "gpio.h"
|
|
|
|
#include "eg91.h"
|
|
#include "lte_comms.h"
|
|
|
|
#define LTE_CONTEXT_1 1
|
|
|
|
EG91Object_t Eg91Obj;
|
|
static uint16_t rnglocalport = 0;
|
|
|
|
int Network_Init(void)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
LTE_Registatus_t reg_status = LTE_REGISTATUS_UNKNOWN;
|
|
int32_t quality_level = 0;
|
|
int8_t quality_level_db = 0;
|
|
int try_counter = 0;
|
|
|
|
char moduleInfo[MAX(MAX(MAX(MAX(LTE_FW_REV_SIZE, LTE_MAN_SIZE), LTE_PROD_ID_SIZE), LTE_IMEI_SIZE), LTE_ICCID_SIZE) + 1];
|
|
LTE_HardwarePowerUp();
|
|
|
|
while (ret != LTE_RET_OK)
|
|
{
|
|
if (try_counter >= 3)
|
|
{
|
|
ret = LTE_RET_ERROR;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
try_counter++;
|
|
HAL_Delay(50);
|
|
|
|
reg_status = LTE_Init(120);
|
|
|
|
LTE_GetModuleName(moduleInfo);
|
|
APP_LOG_MSG("Module Name: %s\r\n", moduleInfo);
|
|
memset(moduleInfo, 0, sizeof(moduleInfo));
|
|
|
|
LTE_GetModuleID(moduleInfo);
|
|
APP_LOG_MSG("Product ID: %s\r\n", moduleInfo);
|
|
memset(moduleInfo, 0, sizeof(moduleInfo));
|
|
|
|
LTE_GetModuleFirmwareRevision(moduleInfo);
|
|
APP_LOG_MSG("FW Version: %s\r\n", moduleInfo);
|
|
memset(moduleInfo, 0, sizeof(moduleInfo));
|
|
|
|
LTE_GetIMEI(moduleInfo);
|
|
APP_LOG_MSG("IMEI: %s\r\n", moduleInfo);
|
|
memset(moduleInfo, 0, sizeof(moduleInfo));
|
|
|
|
LTE_GetSimId(moduleInfo);
|
|
APP_LOG_MSG("ICCID: %s\r\n", moduleInfo);
|
|
memset(moduleInfo, 0, sizeof(moduleInfo));
|
|
|
|
|
|
if ((reg_status != LTE_REGISTATUS_ERROR) && (reg_status != LTE_REGISTATUS_SIM_NOT_INSERTED) && (reg_status == LTE_REGISTATUS_NOT_REGISTERED))
|
|
{
|
|
APP_LOG_MSG("Successful Initialization of the Module\r\n\r\n");
|
|
memset(moduleInfo, 0, sizeof(moduleInfo));
|
|
|
|
|
|
/* Retrieve the Quality Level of the Connection */
|
|
LTE_GetSignalQualityStatus(&quality_level);
|
|
if (quality_level != 99)
|
|
{
|
|
quality_level_db = (int8_t)(-113 + 2 * quality_level);
|
|
APP_LOG_MSG("Signal Quality Level %d dBm (GSM Format: %ld)\r\n", quality_level_db, quality_level);
|
|
}
|
|
else
|
|
{
|
|
APP_LOG_MSG("Signal Quality Level not detectable\r\n");
|
|
}
|
|
APP_LOG_MSG("\r\n");
|
|
}
|
|
|
|
|
|
switch (reg_status)
|
|
{
|
|
case LTE_REGISTATUS_HOME_NETWORK:
|
|
case LTE_REGISTATUS_ROAMING:
|
|
case LTE_REGISTATUS_UNKNOWN:
|
|
{
|
|
HAL_Delay(1000);
|
|
ret = LTE_RET_OK;
|
|
APP_LOG_MSG("\r\n >>> Module Registration Successful\r\n\r\n");
|
|
break;
|
|
}
|
|
|
|
case LTE_REGISTATUS_TRYING:
|
|
{
|
|
APP_LOG_MSG("\r\n >>> Module Registration Trying\r\n\r\n");
|
|
break;
|
|
}
|
|
|
|
case LTE_REGISTATUS_REG_DENIED:
|
|
{
|
|
APP_LOG_MSG("\r\n >>> Module Registration Denied\r\n\r\n");
|
|
break;
|
|
}
|
|
|
|
case LTE_REGISTATUS_NOT_REGISTERED:
|
|
{
|
|
APP_LOG_MSG("\r\n >>> Module Registration Failed\r\n\r\n");
|
|
break;
|
|
}
|
|
|
|
case LTE_REGISTATUS_ERROR:
|
|
{
|
|
APP_LOG_MSG("\r\n >>> Module AT Communication Error with the Device\r\n");
|
|
APP_LOG_MSG(" >>> Device might be disconnected or wrongly connected\r\n\r\n");
|
|
break;
|
|
}
|
|
|
|
case LTE_REGISTATUS_SIM_NOT_INSERTED:
|
|
{
|
|
APP_LOG_MSG("\r\n >>> SIM is not INSERTED\r\n\r\n");
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
APP_LOG_MSG("\r\n >>> Module SIM Error: %d\r\n", reg_status);
|
|
APP_LOG_MSG(" >>> Please check if the SIM is inserted and valid, if credentials are ok, etc.\r\n\r\n");
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
static char operatorStr[LTE_OPERATORS_LIST + 1];
|
|
static uint8_t sim = -1;
|
|
char apnString[30];
|
|
APP_LOG_MSG("Cellular Operator: ");
|
|
if (LTE_GetCurrentOperator(operatorStr, sizeof(operatorStr)) == LTE_RET_OK)
|
|
{
|
|
APP_LOG_MSG("%s\r\n", operatorStr);
|
|
if ((strstr(operatorStr, "SMART") != NULL) || (strstr(operatorStr, "51503") != NULL))
|
|
{
|
|
sim = SIM_OPERATOR_SMART;
|
|
sprintf(apnString, "internet");
|
|
}
|
|
else if ((strstr(operatorStr, "GLOBE") != NULL) || (strstr(operatorStr, "51502") != NULL))
|
|
{
|
|
sim = SIM_OPERATOR_GLOBE;
|
|
sprintf(apnString, "internet.globe.com.ph");
|
|
}
|
|
else if ((strstr(operatorStr, "DITO") != NULL) || (strstr(operatorStr, "51566") != NULL))
|
|
{
|
|
sim = SIM_OPERATOR_DITO;
|
|
sprintf(apnString, "internet.dito.ph");
|
|
}
|
|
else
|
|
{
|
|
sim = SIM_OPERATOR_UNKNOWN;
|
|
ret = LTE_RET_NOT_SUPPORTED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
APP_LOG_MSG("\rFailed to get the current cellular operator name\r\n\r\n");
|
|
}
|
|
|
|
if(LTE_Connect(apnString) == LTE_RET_OK)
|
|
{
|
|
LTE_GetActiveIpAddress();
|
|
|
|
if (LTE_isConnected() == LTE_AP_ACTIVATED)
|
|
{
|
|
// LTE_SendATCommand_Test("AT+QPING=1,\"www.google.com.ph\"\r\n");
|
|
LTE_Ping();
|
|
HAL_Delay(5000);
|
|
// LTE_Ping("www.google.com.ph", 10, 3);
|
|
}
|
|
else
|
|
{
|
|
APP_LOG_MSG("Ping Will Not\r\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (ret == LTE_RET_OK) ? 0 : -1;
|
|
}
|
|
|
|
|
|
|
|
void LTE_ConvertIpAddrToString(const uint8_t * ipArray, char *returnStr)
|
|
{
|
|
snprintf((char*) returnStr, 16, "%d.%d.%d.%d", ipArray[0], ipArray[1], ipArray[2], ipArray[3]);
|
|
}
|
|
|
|
LTE_Registatus_t LTE_Init(uint16_t registration_timeout_sec)
|
|
{
|
|
EG91_InitRet_t init_status;
|
|
EG91_SIMState_t sim_tmp;
|
|
LTE_Registatus_t ret = LTE_REGISTATUS_ERROR;
|
|
|
|
bool signalMsg = false;
|
|
|
|
/* Channel Signal Quality */
|
|
int32_t quality_level = 0;
|
|
int8_t quality_level_db = 0;
|
|
|
|
/* Counter for PS Attachement */
|
|
int8_t attRetry = 0;
|
|
|
|
/* Init for timeout management */
|
|
uint32_t tickstart;
|
|
uint32_t tickcurrent;
|
|
uint32_t registration_timeout_msec = registration_timeout_sec * 1000;
|
|
|
|
tickstart = HAL_GetTick();
|
|
|
|
EG91_RegisterTickCb(&Eg91Obj, HAL_GetTick);
|
|
|
|
if (EG91_RegisterBusIO(&Eg91Obj, (IO_Init_Func)MX_USART1_UART_Init,
|
|
(IO_DeInit_Func)HAL_UART_DeInit, (IO_Baudrate_Func)LTE_UART_SetBaudrate,
|
|
(IO_Send_Func)LTE_UART_SendData, (IO_ReceiveOne_Func)LTE_UART_ReceiveSingleData,
|
|
(IO_Flush_Func)LTE_UART_FlushBuffer) == EG91_RETURN_OK)
|
|
{
|
|
init_status = EG91_Init(&Eg91Obj);
|
|
if (init_status == EG91_INIT_RET_OK)
|
|
{
|
|
tickcurrent = HAL_GetTick() - tickstart;
|
|
while ((tickcurrent < registration_timeout_msec) || (registration_timeout_sec == LTE_COMMS_MAX_DELAY))
|
|
{
|
|
/* Check Signal Quality*/
|
|
if (EG91_GetSignalQualityStatus(&Eg91Obj, &quality_level) == EG91_RETURN_OK)
|
|
{
|
|
if (quality_level == 99)
|
|
{
|
|
if (signalMsg == false)
|
|
{
|
|
APP_LOG_MSG("Signal is not known or not detectable yet... ");
|
|
signalMsg = true;
|
|
}
|
|
else
|
|
{
|
|
APP_LOG_MSG(".");
|
|
}
|
|
HAL_Delay(1000);
|
|
}
|
|
else
|
|
{
|
|
quality_level_db = (int8_t)(-113 + 2 * quality_level);
|
|
APP_LOG_MSG("\r\nSignal Level: %d dBm\r\n", quality_level_db);
|
|
HAL_Delay(1000);
|
|
break;
|
|
}
|
|
}
|
|
tickcurrent = HAL_GetTick() - tickstart;
|
|
}
|
|
|
|
EG91_ConfigurePDPContext(&Eg91Obj, LTE_CONTEXT_1, "internet");
|
|
|
|
tickcurrent = HAL_GetTick() - tickstart;
|
|
while( (tickcurrent < registration_timeout_msec) || (registration_timeout_sec == LTE_COMMS_MAX_DELAY) )
|
|
{
|
|
if((EG91_GetPsNetworkRegistrationStatus(&Eg91Obj) == EG91_NRS_HOME_NETWORK) &&
|
|
(EG91_GetCsNetworkRegistrationStatus(&Eg91Obj) == EG91_NRS_HOME_NETWORK))
|
|
{
|
|
/* Attach the MT to the backet domain service */
|
|
if (EG91_PSAttach(&Eg91Obj) == EG91_RETURN_OK)
|
|
{
|
|
APP_DEBUG_MSG("Packet Switched attachement succeeded\r\n");
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
/* Start an Automatic PLMN selection */
|
|
attRetry++;
|
|
if (attRetry == 1)
|
|
{
|
|
APP_DEBUG_MSG("Trying an automatic registration. It may take until 3 minutes, please wait ...\r\n");
|
|
if (EG91_RETURN_OK != EG91_AutomaticPlmnSelection(&Eg91Obj))
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (attRetry > 4)
|
|
{
|
|
APP_DEBUG_MSG("Unrecoverable Error, PS attachement failed\r\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
HAL_Delay(1000);
|
|
}
|
|
}
|
|
tickcurrent = HAL_GetTick() - tickstart;
|
|
}
|
|
/* Check Packet Switched Registration */
|
|
ret = (LTE_Registatus_t) EG91_GetPsNetworkRegistrationStatus(&Eg91Obj);
|
|
APP_DEBUG_MSG("Packet Switch Registration: %d\r\n", ret);
|
|
if ( (ret == LTE_REGISTATUS_HOME_NETWORK) || (ret == LTE_REGISTATUS_ROAMING) )
|
|
{
|
|
tickcurrent = HAL_GetTick() - tickstart;
|
|
APP_DEBUG_MSG("Registation done in %lu ms\r\n", tickcurrent);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (init_status == EG91_INIT_RET_SIM_ERR)
|
|
{
|
|
sim_tmp = Eg91Obj.SimInfo.SimStatus;
|
|
if (sim_tmp == EG91_OPERATION_NOT_ALLOW)
|
|
{
|
|
ret = LTE_REGISTATUS_OP_NOT_ALLOWED;
|
|
}
|
|
else
|
|
{
|
|
ret = (LTE_Registatus_t) Eg91Obj.SimInfo.SimStatus;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = LTE_REGISTATUS_ERROR; /* Generic e.g. module does not respond to AT command */
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetSignalQualityStatus(int32_t *qValue)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_GetSignalQualityStatus(&Eg91Obj, qValue) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_ListOperators(char *operator)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_ListOperators(&Eg91Obj, operator) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetCurrentOperator (char *operator, int32_t bufSize)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_GetCurrentOperator(&Eg91Obj, operator, bufSize) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_ForceOperator(int32_t code)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_ForceOperator(&Eg91Obj, code) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_ConfigureAP(uint8_t contextType, const char *apn, const char *username,
|
|
const char *password, uint8_t authenticationMode)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
EG91_APConfig_t apConfig;
|
|
|
|
apConfig.ContextID = LTE_CONTEXT_1;
|
|
strncpy((char *)apConfig.ApnString, (char *)apn, EG91_MAX_APN_NAME_SIZE);
|
|
strncpy((char *)apConfig.Username, (char *)username, EG91_MAX_USER_NAME_SIZE);
|
|
strncpy((char *)apConfig.Password, (char *)password, EG91_MAX_PSW_NAME_SIZE);
|
|
apConfig.Authentication = (EG91_Authent_t)authenticationMode;
|
|
|
|
if (EG91_ConfigureAP(&Eg91Obj, &apConfig) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_Connect(const char* apn)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
|
|
if (EG91_Activate(&Eg91Obj, LTE_CONTEXT_1, apn) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_Disconnect(void)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_Deactivate(&Eg91Obj, LTE_CONTEXT_1) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_APState_t LTE_isConnected(void)
|
|
{
|
|
return (LTE_APState_t) EG91_IsActivated(&Eg91Obj, LTE_CONTEXT_1);
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetActiveIpAddress(void)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_GetActiveIpAddresses(&Eg91Obj) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_Ping(void)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_Ping(&Eg91Obj) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetHostAddress(const char *address, uint8_t *ipaddr)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_DNS_LookUp(&Eg91Obj, LTE_CONTEXT_1, address, ipaddr) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_StartClientConnection(uint32_t socket, LTE_Protocol_t type, const char *url,
|
|
uint8_t *ipaddr, uint16_t port, uint16_t local_port)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
char converted_ipaddr[16] = { 0 };
|
|
EG91_Conn_t conn;
|
|
int random_number = 0;
|
|
|
|
conn.ConnectID = socket;
|
|
conn.RemotePort = port;
|
|
|
|
#ifdef ACCESS_MODE_DIRECT_PUSH
|
|
conn.AccessMode = EG91_DIRECT_PUSH;
|
|
#else
|
|
conn.AccessMode = EG91_BUFFER_MODE;
|
|
#endif
|
|
|
|
if (local_port != 0)
|
|
{
|
|
conn.LocalPort = local_port;
|
|
}
|
|
else
|
|
{
|
|
if(rnglocalport == 0)
|
|
{
|
|
random_number = rand();
|
|
rnglocalport = ((uint16_t)(random_number & 0xFFFF) >> 2) + 49152;
|
|
}
|
|
else
|
|
{
|
|
rnglocalport += 1;
|
|
}
|
|
|
|
if (rnglocalport < 49152) /* Wrap around */
|
|
{
|
|
rnglocalport = 49152;
|
|
}
|
|
conn.LocalPort = rnglocalport;
|
|
}
|
|
|
|
switch (type)
|
|
{
|
|
case LTE_TCP_PROTOCOL:
|
|
conn.Type = EG91_TCP_CONNECTION;
|
|
break;
|
|
|
|
case LTE_UDP_PROTOCOL:
|
|
conn.Type = EG91_UDP_CONNECTION;
|
|
break;
|
|
|
|
default:
|
|
conn.Type = LTE_RET_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
|
|
if (ret != LTE_RET_NOT_SUPPORTED)
|
|
{
|
|
if (url == NULL)
|
|
{
|
|
LTE_ConvertIpAddrToString(ipaddr, converted_ipaddr);
|
|
conn.Url = converted_ipaddr;
|
|
}
|
|
else
|
|
{
|
|
conn.Url = (char*)url;
|
|
}
|
|
|
|
if (EG91_OpenClientConnection(&Eg91Obj, LTE_CONTEXT_1, &conn) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_StopClientConnection(uint32_t socket)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
EG91_Conn_t conn;
|
|
|
|
conn.ConnectID = socket;
|
|
if (EG91_CloseClientConnection(&Eg91Obj, &conn) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_StartServerConnection(uint32_t socket, LTE_Protocol_t type, uint16_t port, uint16_t local_port)
|
|
{
|
|
return LTE_RET_NOT_SUPPORTED;
|
|
}
|
|
|
|
LTE_Ret_t LTE_StopServerConnection(uint32_t socket)
|
|
{
|
|
return LTE_RET_NOT_SUPPORTED;
|
|
}
|
|
|
|
LTE_SendStatus_t LTE_SendData(uint32_t socket, uint8_t *pdata, uint16_t reqLen, uint16_t *sentDataLen, uint32_t timeout)
|
|
{
|
|
LTE_SendStatus_t ret = LTE_SEND_ERROR;
|
|
EG91_SendRet_t status;
|
|
|
|
status = EG91_SendData(&Eg91Obj, socket, pdata, reqLen, sentDataLen, timeout);
|
|
if (status == EG91_SEND_RET_SENT)
|
|
{
|
|
ret = LTE_SEND_OK;
|
|
} else if (status == EG91_SEND_RET_BUF_FULL)
|
|
{
|
|
ret = LTE_SEND_BUF_FULL;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_ReceiveData(uint32_t socket, uint8_t *pdata, uint16_t reqLen, uint16_t *rcvDataLen, uint32_t timeout)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
EG91_ReceiveRet_t result;
|
|
|
|
result = EG91_ReceiveData(&Eg91Obj, socket, pdata, reqLen, rcvDataLen, timeout);
|
|
if ((result == EG91_RECEIVE_RET_OK) || (result == EG91_RECEIVE_RET_INCOMPLETE))
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_RetrieveLastErrorDetails(char *errorStr)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
char errStr[EG91_ERROR_STRING_SIZE];
|
|
|
|
memset(errStr, 0, EG91_ERROR_STRING_SIZE);
|
|
if (EG91_RetrieveLastErrorDetails(&Eg91Obj, errStr) == EG91_RETURN_OK)
|
|
{
|
|
strncpy(errorStr, errStr, MIN(LTE_ERROR_STRING, EG91_ERROR_STRING_SIZE));
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_PowerOff(void)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (EG91_PowerDown(&Eg91Obj) == EG91_RETURN_OK)
|
|
{
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetModuleFirmwareRevision(char *rev)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (Eg91Obj.FW_Rev != NULL)
|
|
{
|
|
strncpy(rev, (char*)Eg91Obj.FW_Rev, MIN(LTE_FW_REV_SIZE, EG91_FW_REV_SIZE));
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetModuleID(char *productId)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (Eg91Obj.ProductID != NULL)
|
|
{
|
|
strncpy(productId, (char*)Eg91Obj.ProductID, MIN(LTE_PROD_ID_SIZE, EG91_PROD_ID_SIZE));
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetModuleName(char *moduleName)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (Eg91Obj.Manufacturer != NULL)
|
|
{
|
|
strncpy(moduleName, (char*)Eg91Obj.Manufacturer, MIN(LTE_MAN_SIZE, EG91_MFC_SIZE));
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetSimId(char *simId)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (Eg91Obj.SimInfo.ICCID != NULL)
|
|
{
|
|
strncpy(simId, (char*)Eg91Obj.SimInfo.ICCID, MIN(LTE_ICCID_SIZE, EG91_ICCID_SIZE));
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LTE_Ret_t LTE_GetIMEI(char *imei)
|
|
{
|
|
LTE_Ret_t ret = LTE_RET_ERROR;
|
|
if (Eg91Obj.Imei != NULL)
|
|
{
|
|
strncpy(imei, (char*)Eg91Obj.Imei, MIN(LTE_IMEI_SIZE, EG91_IMEI_SIZE));
|
|
ret = LTE_RET_OK;
|
|
}
|
|
return ret;
|
|
}
|