//--------------------------------------------------------------------------------------------------
static void SendCellNetStateEvent
(
void
)
{
le_mrc_NetRegState_t state;
le_mrc_GetNetRegState(&state);
le_cellnet_State_t cellNetState = TranslateToCellNetState(state);
LE_PRINT_VALUE("%i", cellNetState);
// Send the event to interested applications
le_event_Report(CellNetStateEvent, &cellNetState, sizeof(cellNetState));
}
//-------------------------------------------------------------------------------------------------
static le_result_t GetRegState
(
void
)
{
le_result_t res;
le_mrc_NetRegState_t state;
res = le_mrc_GetNetRegState(&state);
if (res != LE_OK)
{
return res;
}
switch (state)
{
case LE_MRC_REG_NONE:
cm_cmn_FormatPrint("Status", "Not registered and not currently searching for new operator (LE_MRC_REG_NONE)");
break;
case LE_MRC_REG_HOME:
cm_cmn_FormatPrint("Status", "Registered, home network (LE_MRC_REG_HOME)");
break;
case LE_MRC_REG_SEARCHING:
cm_cmn_FormatPrint("Status", "Not registered but currently searching for a new operator (LE_MRC_REG_SEARCHING)");
break;
case LE_MRC_REG_DENIED:
cm_cmn_FormatPrint("Status", "Registration was denied, usually because of invalid access credentials (LE_MRC_REG_DENIED)");
break;
case LE_MRC_REG_ROAMING:
cm_cmn_FormatPrint("Status", "Registered to a roaming network (LE_MRC_REG_ROAMING)");
break;
default:
cm_cmn_FormatPrint("Status", "Unknown state (LE_MRC_REG_UNKNOWN)");
break;
}
return res;
}
//--------------------------------------------------------------------------------------------------
static void GetAndSendCellNetStateEvent
(
void
)
{
le_mrc_NetRegState_t state = LE_MRC_REG_UNKNOWN;
le_cellnet_State_t cellNetState = LE_CELLNET_REG_UNKNOWN;
// Retrieve network registration state
if (LE_OK == le_mrc_GetNetRegState(&state))
{
cellNetState = TranslateToCellNetState(state);
}
else
{
LE_ERROR("Impossible to retrieve network registration state!");
}
LE_DEBUG("MRC network state %d translated to Cellular network state %d (%s)",
state, cellNetState, cellNetStateStr[cellNetState]);
// Send the state event to applications
ReportCellNetStateEvent(cellNetState);
}
// -------------------------------------------------------------------------------------------------
static bool ProcessCommand
(
const char* textPtr, ///< [IN] Check this text to see if it's a valid command.
const char* requesterPtr ///< [IN] If not NULL, then any response text is SMSed to this target.
)
{
char buffer[10240];
// Start looking for a match...
if (strcmp(textPtr, "Crash") == 0)
{
// As the name implies, we are going to be crashing the application. So simply append to
// the output log and crash the app. This is done to allow demonstration of the supervisor
// policies.
int x = 10;
int y = 0;
LE_ERROR("Something wicked this way comes...");
LE_ERROR("Data result: %d", x / y);
}
else if (strcmp(textPtr, "Status") == 0)
{
// The status command allows the caller to query the current state of the modem. A friendly
// version of this status is constructed and returned to the caller.
le_onoff_t radioStatus;
const char * radioStatusPtr;
le_mrc_NetRegState_t netRegState;
uint32_t signalQuality;
if(le_mrc_GetRadioPower(&radioStatus) != LE_OK)
{
radioStatusPtr = "in an unknown state";
}
else
{
radioStatusPtr = (radioStatus == LE_OFF) ? "off" : "on";
}
if(le_mrc_GetNetRegState(&netRegState) != LE_OK)
{
netRegState = LE_MRC_REG_UNKNOWN;
}
if(le_mrc_GetSignalQual(&signalQuality) != LE_OK)
{
signalQuality = 0;
}
sprintf(buffer, "The radio is %s and is %s. The signal strength is %s.",
radioStatusPtr,
GetNetStateString(netRegState),
GetSignalString(signalQuality));
}
else if (strcmp(textPtr, "Sim") == 0)
{
// Like the status command, this command queries the underling hardware for information.
// This information is turned into a string that can then be returned to the caller.
le_sim_Id_t simId;
le_sim_States_t simState;
char iccid[100];
char imsi[100];
int pos = 0;
simId = le_sim_GetSelectedCard();
simState = le_sim_GetState(simId);
pos += snprintf(buffer + pos, sizeof(buffer) - pos,
"SIM %u is %s.",
simId,
GetSimStateString(simState));
if(le_sim_GetICCID(simId, iccid, sizeof(iccid)) == LE_OK)
{
pos += snprintf(buffer + pos, sizeof(buffer) - pos,
" ICCID=%s", iccid);
}
if(le_sim_GetIMSI(simId, imsi, sizeof(imsi)) == LE_OK)
{
pos += snprintf(buffer + pos, sizeof(buffer) - pos,
" IMSI=%s", imsi);
}
}
else if (strcmp(textPtr, "Online") == 0)
{
le_utf8_Copy(buffer, "Requesting data connection.", sizeof(buffer), NULL);
GoOnline();
}
else if (strcmp(textPtr, "Offline") == 0)
{
le_utf8_Copy(buffer, "Releasing data connection.", sizeof(buffer), NULL);
GoOffline(buffer);
}
else if (strcmp(textPtr, "TestDataConnectionV4") == 0)
{
TestDataConnectionV4(buffer);
}
else if (strcmp(textPtr, "TestDataConnectionV6") == 0)
{
TestDataConnectionV6(buffer);
}
else if (strcmp(textPtr, "Netinfo") == 0)
{
Netinfo(buffer);
}
else if (strcmp(textPtr, "DataInfo") == 0)
{
Datainfo(buffer);
}
else if (strcmp(textPtr, "DataReset") == 0)
{
DataReset(buffer);
}
else if (strcmp(textPtr, "Scan") == 0)
{
PerformScan(buffer, sizeof(buffer), requesterPtr);
}
else
{
return false;
}
// Check to see if any processing has occurred. If so, check to see if the request came from a
// local or remote requester.
// If the requester was local, (requesterPtr == NULL) then simply log our response to the SMS log.
// Otherwise, attempt to SMS the response string to the original caller.
if (requesterPtr != NULL)
{
SendMessage(requesterPtr, buffer);
}
else if (OutputFilePtr != NULL)
{
fprintf(OutputFilePtr, "## %s ##\n", buffer);
fflush(OutputFilePtr);
}
// Let the calling function know if we did any processing or not.
return true;
}
