935 lines
39 KiB
C
935 lines
39 KiB
C
/****************************************************************************
|
|
*
|
|
* Copy right: 2019-, Copyrigths of EigenComm Ltd.
|
|
* File name: plat_config.c
|
|
* Description: platform configuration source file
|
|
* History: Rev1.0 2019-01-18
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include "commonTypedef.h"
|
|
#include "lfs_port.h"
|
|
#include "dm_task.h"
|
|
#include "cucc_dm.h"
|
|
#include "osasys.h"
|
|
#include "ostask.h"
|
|
#include DEBUG_LOG_HEADER_FILE
|
|
#include "networkmgr.h"
|
|
#include "slpman.h"
|
|
#include "ps_lib_api.h"
|
|
#include "at_util.h"
|
|
#include "MQTTClient.h"
|
|
#include "ps_event_callback.h"
|
|
#include "ps_lib_api.h"
|
|
#include "mw_nvm_config.h"
|
|
#include "cucc_mqtt.h"
|
|
#include "osasys.h"
|
|
#include "ps_mm_if.h"
|
|
#include "appmgr.h"
|
|
|
|
QueueHandle_t dmMsgHandle = NULL;
|
|
UINT8 cuccDmSlpHandler = 0xff;
|
|
osThreadId_t cuccAutoRegisterTaskHandle = NULL;
|
|
osThreadId_t cuccDmAutoRegisterTaskHandle = NULL;
|
|
MQTTClient cuccMqttClient;
|
|
Network cuccMqttNetwork;
|
|
char *cuccMqttSendbuf = NULL;
|
|
char *cuccMqttReadbuf = NULL;
|
|
char *cuccIMEI = NULL;
|
|
char *cuccIMSI = NULL;
|
|
char *cuccCCID = NULL;
|
|
char *cuccSendPayload = NULL;
|
|
UINT32 cuccDmMsgI = 81192;
|
|
osTimerId_t cuccDmTimer = NULL;
|
|
|
|
extern time_t OsaSystemTimeReadSecs(void);
|
|
|
|
void cuccAutoRegTimerCallback(void)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccAutoRegTimerCallback, P_SIG, "cuccAutoRegTimerCallback....");
|
|
|
|
}
|
|
void cuccAutoRegCheckIfNeedExit(UINT32 needFlag)
|
|
{
|
|
UINT8 cfun = 0xff;
|
|
|
|
appGetCFUN(&cfun);
|
|
if((cfun == 0)||(needFlag == 1))
|
|
{
|
|
if(cuccIMEI != NULL)
|
|
{
|
|
freeEc(cuccIMEI);
|
|
cuccIMEI = NULL;
|
|
}
|
|
if(cuccIMSI != NULL)
|
|
{
|
|
freeEc(cuccIMSI);
|
|
cuccIMSI = NULL;
|
|
}
|
|
if(cuccCCID != NULL)
|
|
{
|
|
freeEc(cuccCCID);
|
|
cuccCCID = NULL;
|
|
}
|
|
if(cuccMqttSendbuf != NULL)
|
|
{
|
|
freeEc(cuccMqttSendbuf);
|
|
cuccMqttSendbuf = NULL;
|
|
}
|
|
if(cuccMqttReadbuf != NULL)
|
|
{
|
|
freeEc(cuccMqttReadbuf);
|
|
cuccMqttReadbuf = NULL;
|
|
}
|
|
if(cuccSendPayload != NULL)
|
|
{
|
|
freeEc(cuccSendPayload);
|
|
cuccSendPayload = NULL;
|
|
}
|
|
|
|
slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
|
|
slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
|
|
osThreadExit();
|
|
}
|
|
}
|
|
|
|
#define CUCC_DM_AUTOREG_TASK_START
|
|
void cuccAutoRegisterTask(void *argument)
|
|
{
|
|
INT32 ret = 0xff;
|
|
INT32 retryCount = 0xff;
|
|
INT32 len = 0;
|
|
MWNvmCfgDmCuccParam dmCuccParam = {0};
|
|
MQTTPacket_connectData connectData = MQTTPacket_connectData_initializer;
|
|
char cuccClientID[CUCC_DM_MQTT_CLIENTID_LEN] = {0};
|
|
char cuccUsername[CUCC_DM_MQTT_USERNAME_LEN] = {0};
|
|
char cuccPassword[CUCC_DM_MQTT_PASSWORD_LEN] = {0};
|
|
char dmTopic[CUCC_DM_TOPIC_LEN] = {0};
|
|
MQTTString topicName;
|
|
char recvPayload[CUCC_DM_MQTT_RECV_DEVICE_SECRET_LEN] = {0};
|
|
char *data_start_ptr = NULL;
|
|
char *data_end_ptr = NULL;
|
|
MQTTMessage message;
|
|
float rsrq = -10.2;
|
|
int rsrqTemp = 0;
|
|
int csq = 30;
|
|
int rsrp = -100;
|
|
int cellId = 8119;
|
|
int snr = 10;
|
|
//UINT32 epoch_time = 30;
|
|
int primSize;
|
|
dmMessage dmMsg;
|
|
int autoRegPeriod = 0;
|
|
int autoRegPeriodFlag = 0;
|
|
UeExtStatusInfo statusInfo;
|
|
UINT8 apn[CUCC_DM_APN_LEN] = {0};
|
|
utc_timer_value_t *utcTimePtr = NULL;
|
|
UINT8 utcTimeBuf[CUCC_DM_UTC_TIME_LEN] = {0};
|
|
UINT8 msgId[CUCC_DM_MSG_ID_LEN] = {0};
|
|
INT32 timeSyncFlag = 0xff;
|
|
INT32 timeSyncRetry = 0;
|
|
INT32 i=0;
|
|
|
|
memset(&dmMsg, 0, sizeof(dmMsg));
|
|
memset(&message, 0, sizeof(MQTTMessage));
|
|
memset(&dmCuccParam, 0, sizeof(dmCuccParam));
|
|
slpManPlatVoteDisableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //close sleep2 gate now, it can go to active or sleep1
|
|
|
|
mwNvmCfgGetDmCuccParam(&dmCuccParam);
|
|
if(dmCuccParam.mProductKey[0] == 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_err1, P_SIG, "mProductKey is null");
|
|
slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
|
|
slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
|
|
osThreadExit();
|
|
}
|
|
|
|
/* step1: init mqtt client */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_1, P_SIG, "step1: init mqtt client....");
|
|
NetworkInit(&cuccMqttNetwork);
|
|
cuccMqttSendbuf = mallocEc(CUCC_MQTT_SEND_BUFF_LEN);
|
|
cuccMqttReadbuf = mallocEc(CUCC_MQTT_RECV_BUFF_LEN);
|
|
memset(cuccMqttSendbuf, 0, CUCC_MQTT_SEND_BUFF_LEN);
|
|
memset(cuccMqttReadbuf, 0, CUCC_MQTT_RECV_BUFF_LEN);
|
|
MQTTClientInit(&cuccMqttClient, &cuccMqttNetwork, 5000, (unsigned char *)cuccMqttSendbuf, CUCC_MQTT_SEND_BUFF_LEN, (unsigned char *)cuccMqttReadbuf, CUCC_MQTT_RECV_BUFF_LEN);
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
|
|
/* step2: connect cucc mqtt server with product key/product secret/device key */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_2, P_SIG, "step2: connect cucc mqtt server....");
|
|
if(dmCuccParam.mCuccToken[0] == 0)
|
|
{
|
|
if(dmCuccParam.mProductSecret[0] == 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_err2, P_SIG, "mProductSecret is null");
|
|
freeEc(cuccMqttSendbuf);
|
|
cuccMqttSendbuf = NULL;
|
|
freeEc(cuccMqttReadbuf);
|
|
cuccMqttReadbuf = NULL;
|
|
slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
|
|
slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
|
|
osThreadExit();
|
|
}
|
|
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_2_1, P_SIG, "step2: connect cucc mqtt server with product key/product secret....");
|
|
mqttCuccDynNoPreRegIdentity((const char *)dmCuccParam.mProductKey, (const char *)cuccCCID, (const char *)cuccIMEI, (const char *)dmCuccParam.mProductSecret, (char *)&cuccClientID, (char *)&cuccUsername, (char *)&cuccPassword);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccClientID, P_SIG, "cuccClientID=%s",cuccClientID);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccUsername, P_SIG, "cuccUsername=%s",cuccUsername);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccPassword, P_SIG, "cuccPassword=%s",cuccPassword);
|
|
|
|
ret = MQTTCuccCreate(&cuccMqttClient, &cuccMqttNetwork, cuccClientID, cuccUsername, cuccPassword, CUCC_MQTT_SERVER_URL, CUCC_MQTT_SERVER_PORT, &connectData);
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
if(ret != 0)
|
|
{
|
|
for(retryCount=0; retryCount<3; retryCount++)
|
|
{
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccCreate, P_SIG, "MQTTCuccCreate...retryCount=%d....", retryCount);
|
|
ret = MQTTCuccCreate(&cuccMqttClient, &cuccMqttNetwork, cuccClientID, cuccUsername, cuccPassword, CUCC_MQTT_SERVER_URL, CUCC_MQTT_SERVER_PORT, &connectData);
|
|
if(ret == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(ret != 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_exit, P_SIG, "MQTTCuccCreate....fail..exit..task........");
|
|
freeEc(cuccMqttSendbuf);
|
|
cuccMqttSendbuf = NULL;
|
|
freeEc(cuccMqttReadbuf);
|
|
cuccMqttReadbuf = NULL;
|
|
slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
|
|
slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
|
|
osThreadExit();
|
|
}
|
|
/* step3: sub mqtt client topic, preRegist is $/sys/productKey/deviceKey/ext/regist, no preRegist is $/sys/productKey/deviceKey/ext/autoregist */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_3, P_SIG, "step3: sub mqtt client topic, $/sys/productKey/deviceKey/ext/autoregist....");
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccSubscribe, P_SIG, "MQTTCuccSubscribe....$sys/productKey/deviceKey/ext/autoregist........");
|
|
memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
|
|
snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/ext/autoregist", dmCuccParam.mProductKey, (const char *)cuccIMEI);
|
|
ret = MQTTCuccSubscribe(&cuccMqttClient, (const char* )dmTopic, QOS0, NULL);
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
if(ret != 0)
|
|
{
|
|
for(retryCount=0; retryCount<3; retryCount++)
|
|
{
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
ret = MQTTCuccSubscribe(&cuccMqttClient, (const char* )dmTopic, QOS0, NULL);
|
|
if(ret == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* step4: wait for cucc mqtt server send token */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_4, P_SIG, "step4: wait for cucc mqtt server sending token....");
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccWaitForRecv, P_SIG, "MQTTCuccWaitForRecv....$sys/productKey/deviceKey/ext/autoregist........");
|
|
ret = MQTTCuccWaitForRecv(&cuccMqttClient, PUBLISH, 100000, &topicName, recvPayload);
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
if(ret == 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_recvPayload, P_SIG, "recvPayload=%s",recvPayload);
|
|
|
|
data_start_ptr = strstr(recvPayload, "token");/*for no pre autoregist, server publish "token", for auroreist, server publish "deviceSecret"*/
|
|
if(data_start_ptr == NULL)
|
|
{
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_4_2, P_SIG, "step4: get token fail and exit task....");
|
|
freeEc(cuccMqttSendbuf);
|
|
cuccMqttSendbuf = NULL;
|
|
freeEc(cuccMqttReadbuf);
|
|
cuccMqttReadbuf = NULL;
|
|
slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
|
|
slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
|
|
osThreadExit();
|
|
}
|
|
else
|
|
{
|
|
data_start_ptr = data_start_ptr+8;
|
|
data_end_ptr = strstr(data_start_ptr, "\"");
|
|
len = data_end_ptr-data_start_ptr;
|
|
memset(cuccPassword, 0, CUCC_DM_MQTT_PASSWORD_LEN);
|
|
memcpy(cuccPassword, data_start_ptr, len); /*for no pre autoregist, the token is password and deviceSecret*/
|
|
memset(dmCuccParam.mCuccToken, 0, sizeof(dmCuccParam.mCuccToken));
|
|
memcpy(dmCuccParam.mCuccToken, cuccPassword, len);
|
|
mwNvmCfgSetAndSaveDmCuccParam(&dmCuccParam);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_4_1, P_SIG, "step4: get token ok and save token....");
|
|
}
|
|
}
|
|
|
|
/* step5: disconnect mqtt client */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_5, P_SIG, "step5: disconnect mqtt client....");
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccDisconnect, P_SIG, "MQTTCuccDisconnect............");
|
|
MQTTCuccDisconnect(&cuccMqttClient);
|
|
}
|
|
|
|
/* step6: connect cucc mqtt server with product key/token */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_6, P_SIG, "step6: connect cucc mqtt server with product key/token....");
|
|
memset(cuccClientID, 0, CUCC_DM_MQTT_CLIENTID_LEN);
|
|
memset(cuccUsername, 0, CUCC_DM_MQTT_USERNAME_LEN);
|
|
mqttCuccNoPreIdentity((const char *)dmCuccParam.mProductKey, (const char *)cuccCCID, (const char *)cuccIMEI, (char *)cuccClientID, (char *)cuccUsername);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_ClientID, P_SIG, "cuccClientID=%s",cuccClientID);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Username, P_SIG, "cuccUsername=%s",cuccUsername);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Password, P_SIG, "cuccPassword=%s",dmCuccParam.mCuccToken);
|
|
NetworkInit(&cuccMqttNetwork);
|
|
MQTTClientInit(&cuccMqttClient, &cuccMqttNetwork, 20000, (unsigned char *)cuccMqttSendbuf, CUCC_MQTT_SEND_BUFF_LEN, (unsigned char *)cuccMqttReadbuf, CUCC_MQTT_RECV_BUFF_LEN);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccConnect, P_SIG, "MQTTCuccConnect............");
|
|
ret = MQTTCuccCreate(&cuccMqttClient, &cuccMqttNetwork, cuccClientID, cuccUsername, (char *)dmCuccParam.mCuccToken, CUCC_MQTT_SERVER_URL, CUCC_MQTT_SERVER_PORT, &connectData);
|
|
//ret = MQTTCuccConnect(&cuccMqttClient, cuccClientID, cuccUsername, dmCuccParam.mCuccToken, &connectData);
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
if(ret != 0)
|
|
{
|
|
for(retryCount=0; retryCount<3; retryCount++)
|
|
{
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_ReMQTTCuccConnect, P_SIG, "MQTTCuccConnect...retryCount=%d....", retryCount);
|
|
ret = MQTTCuccCreate(&cuccMqttClient, &cuccMqttNetwork, cuccClientID, cuccUsername, (char *)dmCuccParam.mCuccToken, CUCC_MQTT_SERVER_URL, CUCC_MQTT_SERVER_PORT, &connectData);
|
|
if(ret == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(ret != 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_6_1, P_SIG, "MQTTCuccCreate....fail..exit..task........");
|
|
freeEc(cuccMqttSendbuf);
|
|
cuccMqttSendbuf = NULL;
|
|
freeEc(cuccMqttReadbuf);
|
|
cuccMqttReadbuf = NULL;
|
|
slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
|
|
slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
|
|
osThreadExit();
|
|
}
|
|
|
|
/* step7: subscribe cucc server topic property/batch_reply and deviceShadow/command */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_7, P_SIG, "step7: subscribe cucc server topic property/batch_reply and deviceShadow/command....");
|
|
memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
|
|
snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/property/batch_reply", dmCuccParam.mProductKey, (const char *)cuccIMEI);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_batch_reply, P_SIG, "MQTTCuccSubscribe......$sys/productKey/deviceKey/property/batch_reply......");
|
|
ret = MQTTCuccSubscribe(&cuccMqttClient, (const char* )dmTopic, QOS0, NULL);
|
|
|
|
memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
|
|
snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/deviceShadow/command", dmCuccParam.mProductKey, (const char *)cuccIMEI);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_deviceShadow, P_SIG, "MQTTCuccSubscribe......$sys/productKey/deviceKey/deviceShadow/command......");
|
|
ret = MQTTCuccSubscribe(&cuccMqttClient, (const char* )dmTopic, QOS0, NULL);
|
|
|
|
/* step8: send register param info to cucc server */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_8, P_SIG, "step7: send register param info to cucc server....");
|
|
cuccSendPayload = mallocEc(CUCC_MQTT_SEND_PAYLOAD_LEN);
|
|
memset(cuccSendPayload, 0, CUCC_MQTT_SEND_PAYLOAD_LEN);
|
|
|
|
memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
|
|
snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/property/batch", dmCuccParam.mProductKey, (const char *)cuccIMEI);
|
|
|
|
ret = appGetUeExtStatusInfoSync(UE_EXT_STATUS_PHY, &statusInfo);
|
|
if(ret == 0){
|
|
cellId = statusInfo.rrcStatus.cellId;
|
|
rsrp = statusInfo.phyStatus.sRsrp/100;
|
|
rsrq = ((float)statusInfo.phyStatus.sRsrq)/100;
|
|
snr = statusInfo.phyStatus.snr;
|
|
csq = mmGetCsqRssiFromCesq(rsrp, rsrq, statusInfo.phyStatus.rssiAllBW);
|
|
appGetAPNSettingSync(cellId, apn);
|
|
if(apn[0]==0)
|
|
{
|
|
memcpy(apn, "3gnet", strlen("3gnet"));
|
|
}
|
|
}
|
|
timeSyncFlag = appCheckSystemTimeSync();
|
|
if(timeSyncFlag != 0)
|
|
{
|
|
for(timeSyncRetry=0; timeSyncRetry<4; timeSyncRetry++)
|
|
{
|
|
AppMgrSntpStart("cn.ntp.org.cn", 0, BROADCAST_IND_HANDLER, 1, LWIP_PS_INVALID_CID);
|
|
for(i=0; i<10; i++)
|
|
{
|
|
timeSyncFlag = appCheckSystemTimeSync();
|
|
if(timeSyncFlag == 0)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
osDelay(300);
|
|
}
|
|
}
|
|
AppMgrSntpStop();
|
|
if(timeSyncFlag == 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Sntp2, P_SIG, "Sntp is ready....");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
utcTimePtr = OsaSystemTimeReadUtc();
|
|
int year =0;
|
|
int month =0;
|
|
int day =0;
|
|
int hour =0;
|
|
|
|
year = utcTimePtr->UTCtimer1>>16&0xffff;
|
|
month = (utcTimePtr->UTCtimer1>>8)&0xff;
|
|
day = utcTimePtr->UTCtimer1&0xff;
|
|
hour = (utcTimePtr->UTCtimer2>>24)&0xff;
|
|
if((hour+8) >= 24)
|
|
{
|
|
switch(month)
|
|
{
|
|
case 1:
|
|
case 3:
|
|
case 5:
|
|
case 7:
|
|
case 8:
|
|
case 10:
|
|
day = day+1;
|
|
if(day >31)
|
|
{
|
|
month = month+1;
|
|
day = 1;
|
|
hour = (hour+8) -24;
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
case 6:
|
|
case 9:
|
|
case 11:
|
|
day = day+1;
|
|
if(day >30)
|
|
{
|
|
month = month+1;
|
|
day = 1;
|
|
hour = (hour+8) -24;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
day = day+1;
|
|
if(((day >29)&&((year%4) == 0))||((day >28)&&((year%4) != 0)))
|
|
{
|
|
month = month+1;
|
|
day = 1;
|
|
hour = (hour+8) -24;
|
|
}
|
|
break;
|
|
|
|
case 12:
|
|
day = day+1;
|
|
if(day >31)
|
|
{
|
|
month = month+1;
|
|
if(month > 12)
|
|
{
|
|
month = 1;
|
|
year = year+1;
|
|
}
|
|
day = 1;
|
|
hour = (hour+8) -24;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hour = hour+8;
|
|
}
|
|
sprintf((char *)utcTimeBuf, "%04d/%02d/%02d %02d:%02d:%02d.%03d", year, month, day, hour, (utcTimePtr->UTCtimer2>>16)&0xff, (utcTimePtr->UTCtimer2>>8)&0xff, (utcTimePtr->UTCms));
|
|
atDataToDecString(msgId, CUCC_DM_MSG_ID_LEN, cuccDmMsgI);
|
|
cuccDmMsgI++;
|
|
|
|
if(rsrq <0.01)
|
|
{
|
|
rsrq = 0-rsrq;
|
|
rsrqTemp = (int)(rsrq*100);
|
|
sprintf( cuccSendPayload,
|
|
"{\"messageId\":\"%s\",\"params\":{\"data\":[{\"key\":\"manufacturer\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleType\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleIMEI\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"chipManufacturer\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"chipType\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleSoftwareVersion\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleHardwareVersion\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"connectionMode\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleIMSI\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleICCID\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":""\"csq\",\"value\":%d,\"ts\":\"\"},{\"key\":\"rsrp\",\"value\":%d,\"ts\":\"\"},{\"key\":\"rsrq\",\"value\":-%d.%d,\"ts\":\"\"},{\"key\":\"signalECL\",\"value\":%d,\"ts\":\"\"},{\"key\":\"sinr\",\"value\":%d,\"ts\":\"\"},{\"key\":\"cellID\",\"value\":\"%lu\",\"ts\":\"\"},{\"key\":\"APN\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"longitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"latitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"altitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"moduleTime\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"internetTime\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"autoRegperiod\",\"value\":%d,\"ts\":\"\"},{\"key\":\"powerSavingMode\",\"value\":%d,\"ts\":\"\"}]}}",
|
|
msgId,dmCuccParam.manufacture, dmCuccParam.moduleType, cuccIMEI, dmCuccParam.chipManufacturer, dmCuccParam.chipType, dmCuccParam.moduleSWVer, dmCuccParam.moduleHWVer, "CAT1", cuccIMSI, cuccIMEI, csq, rsrp, rsrqTemp/100, (rsrqTemp%100)/10, 0, snr, cellId, apn, 120, 30, 108, utcTimeBuf, utcTimeBuf, dmCuccParam.autoRegPeriod, 0);
|
|
}
|
|
else
|
|
{
|
|
sprintf( cuccSendPayload,
|
|
"{\"messageId\":\"%s\",\"params\":{\"data\":[{\"key\":\"manufacturer\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleType\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleIMEI\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"chipManufacturer\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"chipType\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleSoftwareVersion\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleHardwareVersion\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"connectionMode\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleIMSI\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"moduleICCID\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":""\"csq\",\"value\":%d,\"ts\":\"\"},{\"key\":\"rsrp\",\"value\":%d,\"ts\":\"\"},{\"key\":\"rsrq\",\"value\":%d.%d,\"ts\":\"\"},{\"key\":\"signalECL\",\"value\":%d,\"ts\":\"\"},{\"key\":\"sinr\",\"value\":%d,\"ts\":\"\"},{\"key\":\"cellID\",\"value\":\"%lu\",\"ts\":\"\"},{\"key\":\"APN\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"longitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"latitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"altitude\",\"value\":%d,\"ts\":\"\"},{\"key\":\"moduleTime\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"internetTime\",\"value\":\"%s\",\"ts\":\"\"},{\"key\":\"autoRegperiod\",\"value\":%d,\"ts\":\"\"},{\"key\":\"powerSavingMode\",\"value\":%d,\"ts\":\"\"}]}}",
|
|
msgId,dmCuccParam.manufacture, dmCuccParam.moduleType, cuccIMEI, dmCuccParam.chipManufacturer, dmCuccParam.chipType, dmCuccParam.moduleSWVer, dmCuccParam.moduleHWVer, "CAT1", cuccIMSI, cuccIMEI, csq, rsrp ,rsrqTemp/100, (rsrqTemp%100)/10, 0, snr, cellId, apn, 120, 30, 108, utcTimeBuf, utcTimeBuf, dmCuccParam.autoRegPeriod, 0);
|
|
}
|
|
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_MQTTCuccPublish, P_SIG, "MQTTCuccPublish......$sys/productKey/deviceKey/property/batch......");
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_cuccSendPayload, P_SIG, "cuccSendPayload:%s.",cuccSendPayload);
|
|
|
|
message.payload = cuccSendPayload;
|
|
message.payloadlen = strlen((char *)cuccSendPayload);
|
|
ret = MQTTCuccPublish(&cuccMqttClient, (const char* )dmTopic, &message);
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
|
|
/* step9: wait to recv publish ack */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9, P_SIG, "step9: recv for publish ack....");
|
|
ret = MQTTCuccWaitForRecv(&cuccMqttClient, PUBLISH, 100000, &topicName, recvPayload);
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
if(ret == 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_recv_Success, P_SIG, "recvPayload=%s",recvPayload);
|
|
data_start_ptr = strstr(recvPayload, "Success");/*for no pre autoregist, server publish "token", for auroreist, server publish "deviceSecret"*/
|
|
if(data_start_ptr == NULL)
|
|
{
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_2, P_SIG, "step9: recv publish ack....");
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_1, P_SIG, "step9: recv publish ack Success ok....");
|
|
}
|
|
data_start_ptr = strstr(recvPayload, "autoRegperiod");/*for no pre autoregist, server publish "token", for auroreist, server publish "deviceSecret"*/
|
|
if(data_start_ptr == NULL)
|
|
{
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_3, P_SIG, "step9: turn to recv autoRegperiod....");
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_4, P_SIG, "step9: recv autoRegperiod ok....");
|
|
data_start_ptr = data_start_ptr+15;
|
|
data_end_ptr = strstr(data_start_ptr, "}");
|
|
len = data_end_ptr-data_start_ptr;
|
|
cmsDecStrToInt((INT32 *)&autoRegPeriod, (UINT8 *)data_start_ptr, len);
|
|
dmCuccParam.autoRegPeriod = autoRegPeriod;
|
|
mwNvmCfgSetAndSaveDmCuccParam(&dmCuccParam);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_9_5, P_SIG, "step9: recv autoRegperiod=%d....",autoRegPeriod);
|
|
autoRegPeriodFlag = 1;
|
|
}
|
|
}
|
|
|
|
/* step10: wait to recv autoRegperiod */
|
|
if(autoRegPeriodFlag != 1)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10, P_SIG, "step10: wait to recv autoRegperiod....");
|
|
ret = MQTTCuccWaitForRecv(&cuccMqttClient, PUBLISH, 100000, &topicName, recvPayload);
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
if(ret == 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_recv_autoRegperiod, P_SIG, "recvPayload=%s",recvPayload);
|
|
data_start_ptr = strstr(recvPayload, "autoRegperiod");/*for no pre autoregist, server publish "token", for auroreist, server publish "deviceSecret"*/
|
|
if(data_start_ptr == NULL)
|
|
{
|
|
cuccAutoRegCheckIfNeedExit(0);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10_3, P_SIG, "step10: do not recv autoRegperiod....");
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10_1, P_SIG, "step10: recv autoRegperiod ok....");
|
|
|
|
data_start_ptr = data_start_ptr+15;
|
|
data_end_ptr = strstr(data_start_ptr, "}");
|
|
len = data_end_ptr-data_start_ptr;
|
|
cmsDecStrToInt((INT32 *)&autoRegPeriod, (UINT8 *)data_start_ptr, len);
|
|
dmCuccParam.autoRegPeriod = autoRegPeriod;
|
|
mwNvmCfgSetAndSaveDmCuccParam(&dmCuccParam);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10_2, P_SIG, "step10: recv autoRegperiod=%d....",autoRegPeriod);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_10_0, P_SIG, "step10: have recv autoRegperiod already....");
|
|
}
|
|
|
|
/* step11: publish autoRegperiod to server */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_11, P_SIG, "step11: publish autoRegperiod to server....");
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Publish, P_SIG, "MQTTCuccPublish......$sys/productKey/deviceKey/deviceShadow/pub......");
|
|
memset(dmTopic, 0, CUCC_DM_TOPIC_LEN);
|
|
snprintf(dmTopic, CUCC_DM_TOPIC_LEN, "$sys/%s/%s/deviceShadow/pub", dmCuccParam.mProductKey, (const char *)cuccIMEI);
|
|
memset(msgId, 0, CUCC_DM_MSG_ID_LEN);
|
|
atDataToDecString(msgId, CUCC_DM_MSG_ID_LEN, cuccDmMsgI);
|
|
cuccDmMsgI++;
|
|
|
|
|
|
memset(cuccSendPayload, 0, CUCC_MQTT_SEND_PAYLOAD_LEN);
|
|
sprintf( cuccSendPayload, "{\"messageId\":\"%s\",\"params\":{\"state\":{\"reported\":{\"autoRegperiod\":\"%d\"}}}}", msgId, dmCuccParam.autoRegPeriod);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_11_1, P_SIG, "cuccSendPayload=%s....",cuccSendPayload);
|
|
|
|
message.payload = cuccSendPayload;
|
|
message.payloadlen = strlen((char *)cuccSendPayload);
|
|
ret = MQTTCuccPublish(&cuccMqttClient, (const char* )dmTopic, &message);
|
|
|
|
/* step12: disconnect mqtt client */
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_12, P_SIG, "step12: disconnect mqtt client....");
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Disconnect, P_SIG, "MQTTDisconnect..............");
|
|
MQTTDisconnect(&cuccMqttClient);
|
|
|
|
/* step13: store cucc dm info to mw */
|
|
if(cuccIMEI != NULL)
|
|
{
|
|
freeEc(cuccIMEI);
|
|
cuccIMEI = NULL;
|
|
}
|
|
if(cuccIMSI != NULL)
|
|
{
|
|
freeEc(cuccIMSI);
|
|
cuccIMSI = NULL;
|
|
}
|
|
if(cuccCCID != NULL)
|
|
{
|
|
freeEc(cuccCCID);
|
|
cuccCCID = NULL;
|
|
}
|
|
if(cuccMqttSendbuf != NULL)
|
|
{
|
|
freeEc(cuccMqttSendbuf);
|
|
cuccMqttSendbuf = NULL;
|
|
}
|
|
if(cuccMqttReadbuf != NULL)
|
|
{
|
|
freeEc(cuccMqttReadbuf);
|
|
cuccMqttReadbuf = NULL;
|
|
}
|
|
if(cuccSendPayload != NULL)
|
|
{
|
|
freeEc(cuccSendPayload);
|
|
cuccSendPayload = NULL;
|
|
}
|
|
|
|
dmCuccParam.hasReg = CUCC_HAS_REGISTER;
|
|
dmMsg.ret = REG_OK;
|
|
primSize = sizeof(dmMsg);
|
|
applSendCmsInd(BROADCAST_IND_HANDLER, APPL_DM, APPL_DM_CUCC_OPEN_IND, primSize, (void *)&dmMsg);
|
|
mwNvmCfgSetAndSaveDmCuccParam(&dmCuccParam);
|
|
|
|
if(dmCuccParam.autoRegPeriod > 0)
|
|
{
|
|
//start a timer
|
|
if(cuccDmTimer != NULL)
|
|
{
|
|
if(osTimerIsRunning(cuccDmTimer) == 0)
|
|
{
|
|
osTimerDelete(cuccDmTimer);
|
|
cuccDmTimer = osTimerNew(cuccAutoRegisterInit, osTimerOnce, NULL, NULL);
|
|
osTimerStart(cuccDmTimer, (dmCuccParam.autoRegPeriod*2000));
|
|
}
|
|
else
|
|
{
|
|
osTimerStop(cuccDmTimer);
|
|
osTimerDelete(cuccDmTimer);
|
|
cuccDmTimer = osTimerNew(cuccAutoRegisterInit, osTimerOnce, NULL, NULL);
|
|
osTimerStart(cuccDmTimer, (dmCuccParam.autoRegPeriod*2000));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cuccDmTimer = osTimerNew(cuccAutoRegisterInit, osTimerOnce, NULL, NULL);
|
|
osTimerStart(cuccDmTimer, (dmCuccParam.autoRegPeriod*2000));
|
|
}
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_TimerStart, P_SIG, "autoReg cuccDmTimer start, tick=%d", (dmCuccParam.autoRegPeriod*2000));
|
|
}
|
|
else
|
|
{
|
|
slpManPlatVoteEnableSleep(cuccDmSlpHandler,SLP_SLP2_STATE); //open the sleep2 gate, it can go to sleep2 and hib state
|
|
slpManGivebackPlatVoteHandle(cuccDmSlpHandler);
|
|
}
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_exitAll, P_SIG, "autoReg will exit");
|
|
|
|
osThreadExit();
|
|
}
|
|
|
|
#define CUCC_DM_AUTOREG_TASK_END
|
|
|
|
void cuccDmAutoRegInitTask(void)
|
|
{
|
|
osThreadAttr_t task_attr;
|
|
memset(&task_attr, 0, sizeof(task_attr));
|
|
|
|
task_attr.name = "cuDmTask";
|
|
task_attr.stack_size = CUCC_AUTO_REG_TASK_STACK_SIZE;
|
|
task_attr.priority = osPriorityBelowNormal5;
|
|
#ifdef TYPE_EC718M
|
|
task_attr.reserved = osThreadDynamicStackAlloc;
|
|
#endif
|
|
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccDmAutoRegInitTask0, P_SIG, "autoReg..starting task ");
|
|
|
|
cuccDmAutoRegisterTaskHandle= osThreadNew(cuccAutoRegisterTask, NULL,&task_attr);
|
|
if(cuccDmAutoRegisterTaskHandle == NULL)
|
|
{
|
|
if(slpManGivebackPlatVoteHandle(cuccDmSlpHandler) != RET_TRUE)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccDmAutoRegInitTask1, P_ERROR, "CUCC_DM vote handle give back failed");
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccDmAutoRegInitTask2, P_VALUE, "CUCC_DM vote handle give back success");
|
|
}
|
|
}
|
|
}
|
|
|
|
INT32 cuccDmNetWorkStatusCallback(PsEventID eventID, void *param, UINT32 paramLen)
|
|
{
|
|
NmAtiNetInfoInd *netif = NULL;
|
|
dmInterMsg dmMsg;
|
|
CmiSimImsiStr *imsi = NULL;
|
|
|
|
memset(&dmMsg, 0, sizeof(dmInterMsg));
|
|
switch(eventID)
|
|
{
|
|
case PS_URC_ID_PS_NETINFO:
|
|
{
|
|
netif = (NmAtiNetInfoInd *)param;
|
|
if (netif->netifInfo.netStatus == NM_NETIF_ACTIVATED)
|
|
//if ((netif->netStatus == NM_NETIF_OOS)||(netif->netStatus == NM_NETIF_ACTIVATED))
|
|
{
|
|
dmMsg.cmdType = DM_MSG_NETWORK_READY;
|
|
if(dmMsgHandle != NULL)
|
|
{
|
|
xQueueSend(dmMsgHandle, &dmMsg, DM_MSG_TIMEOUT);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccDmNetWorkStatusCallback_1, P_INFO, "dm network is ready");
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccDmNetWorkStatusCallback_2, P_ERROR, "dm network dmMsgHandle is NULL");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case PS_URC_ID_SIM_READY:
|
|
{
|
|
imsi = (CmiSimImsiStr *)param;
|
|
memcpy(dmMsg.imsi, imsi->contents, imsi->length);
|
|
|
|
dmMsg.cmdType = DM_MSG_SIM_READY;
|
|
if(dmMsgHandle != NULL)
|
|
{
|
|
xQueueSend(dmMsgHandle, &dmMsg, DM_MSG_TIMEOUT);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccDmNetWorkStatusCallback_3, P_INFO, "dm sim is ready");
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccDmNetWorkStatusCallback_4, P_ERROR, "dm sim dmMsgHandle is NULL");
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void cuccAutoRegPreInitTask(void *argument)
|
|
{
|
|
UINT8 imsiReadyFlag = 0;
|
|
UINT8 networkReadyFlag = 0;
|
|
UINT8 cfun = 0xff;
|
|
INT32 msgWaitCount = 60;
|
|
UINT8 imei[IMEI_LEN+1] = {0};
|
|
UINT8 imsi[IMSI_LEN+1] = {0};
|
|
UINT8 flashCCID[CCID_LEN+1] = {0};
|
|
UINT8 simCCID[CCID_LEN+1] = {0};
|
|
dmInterMsg dmMsg;
|
|
MWNvmCfgDmCuccParam dmCuccParam;
|
|
INT32 len = 0;
|
|
INT32 timeSyncFlag = 0xff;
|
|
INT32 timeSyncRetry = 0;
|
|
INT32 i=0;
|
|
NmAtiNetifInfo netInfo;
|
|
|
|
memset(&dmCuccParam, 0, sizeof(dmCuccParam));
|
|
mwNvmCfgGetDmCuccParam(&dmCuccParam);
|
|
if(dmCuccParam.autoRegPeriod == CUCC_AUTO_REG_PERIOD_DISABLE)
|
|
{
|
|
osThreadExit();
|
|
}
|
|
if((dmCuccParam.autoRegPeriod == CUCC_AUTO_REG_PERIOD_TYPE1)&&(dmCuccParam.hasReg == CUCC_HAS_REGISTER))
|
|
{
|
|
osThreadExit();
|
|
}
|
|
|
|
memset(&dmMsg, 0, sizeof(dmInterMsg));
|
|
dmMsgHandle = xQueueCreate(DM_MSG_MAX_NUMB, sizeof(dmInterMsg));
|
|
registerPSEventCallback(PS_GROUP_ALL_MASK, cuccDmNetWorkStatusCallback);
|
|
NetMgrGetNetInfo(LWIP_PS_INVALID_CID,&netInfo);
|
|
if(netInfo.netStatus == NM_NETIF_ACTIVATED)
|
|
{
|
|
//turn to next
|
|
appGetImsiNumSync((CHAR *)imsi);
|
|
appGetIccidNumSync((CHAR *)simCCID);
|
|
appGetImeiNumSync((CHAR *)imei);
|
|
}
|
|
else
|
|
{
|
|
while(msgWaitCount)
|
|
{
|
|
xQueueReceive(dmMsgHandle, &dmMsg, DM_MSG_RECV_TIMEOUT);
|
|
|
|
switch(dmMsg.cmdType)
|
|
{
|
|
case DM_MSG_NETWORK_READY:
|
|
networkReadyFlag = 1;
|
|
appGetCFUN(&cfun);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterTask0, P_INFO, "dm network is ready %d %d", networkReadyFlag, cfun);
|
|
break;
|
|
|
|
case DM_MSG_SIM_READY:
|
|
imsiReadyFlag = 1;
|
|
memcpy(imsi, dmMsg.imsi, strlen((const char*)dmMsg.imsi));
|
|
appGetCFUN(&cfun); //for CTCC CUCC DM, it need wait for nerwork ready
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterTask1, P_INFO, "dm sim is ready %d %d", imsiReadyFlag, cfun);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
msgWaitCount--;
|
|
|
|
if((networkReadyFlag == 1)&&(imsiReadyFlag == 1))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if((networkReadyFlag != 1)||(imsiReadyFlag != 1))
|
|
{
|
|
appGetCFUN(&cfun);
|
|
if(cfun == 0) //at+cfun = 0
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
appGetCFUN(&cfun);
|
|
|
|
if((networkReadyFlag != 1)||(imsiReadyFlag != 1)||(cfun == 0))
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterTask2, P_INFO, "dm network or sim is not ready %d %d", networkReadyFlag, cfun);
|
|
if(dmMsgHandle != NULL)
|
|
{
|
|
deregisterPSEventCallback(cuccDmNetWorkStatusCallback);
|
|
vQueueDelete(dmMsgHandle);
|
|
dmMsgHandle = NULL;
|
|
}
|
|
osThreadExit();
|
|
}
|
|
}
|
|
|
|
|
|
//AppMgrResult AppMgrSntpStart(CHAR *server, UINT16 port, UINT16 reqHandler, BOOL autoSync, UINT8 cid)
|
|
for(timeSyncRetry=0; timeSyncRetry<4; timeSyncRetry++)
|
|
{
|
|
AppMgrSntpStart("cn.ntp.org.cn", 0, BROADCAST_IND_HANDLER, 1, LWIP_PS_INVALID_CID);
|
|
for(i=0; i<10; i++)
|
|
{
|
|
timeSyncFlag = appCheckSystemTimeSync();
|
|
if(timeSyncFlag == 0)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
osDelay(300);
|
|
}
|
|
}
|
|
AppMgrSntpStop();
|
|
if(timeSyncFlag == 0)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_Sntp, P_SIG, "Sntp is ready....");
|
|
break;
|
|
}
|
|
}
|
|
//if((imsi[0] == '4')&&(imsi[1] == '6')&&(imsi[2] == '0'))
|
|
if(1)
|
|
{
|
|
//if(((imsi[3] == '0')&&(imsi[4] == '1')) || ((imsi[3] == '0')&&(imsi[4] == '6')))
|
|
if(1)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk0, P_SIG, "autoReg this is CUCC SIM card");
|
|
|
|
/* if imei is not set, use default imei, but the api will return false */
|
|
OsaGetImeiNumSync((CHAR *)imei);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk1, P_SIG, "autoReg get imei ok, imei is %s", (UINT8 *)imei);
|
|
appGetIccidNumSync((CHAR *)simCCID);
|
|
//mwGetSimCcidValue(flashCCID, CCID_LEN);
|
|
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk2, P_SIG, "autoReg get imsi is %s", (UINT8 *)imsi);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk3, P_SIG, "autoReg get current iccid is %s", (UINT8 *)simCCID);
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk4, P_SIG, "autoReg get previous iccid is %s", (UINT8 *)flashCCID);
|
|
|
|
/* check ccid, and start auto register */
|
|
if((strcmp((CHAR *)dmCuccParam.ccid, (CHAR *)simCCID) != 0)
|
|
||(strcmp((CHAR *)dmCuccParam.imsi, (CHAR *)imsi) != 0)
|
|
||(strcmp((CHAR *)dmCuccParam.imei, (CHAR *)imei) != 0))
|
|
{
|
|
cuccIMEI = mallocEc(IMEI_LEN);
|
|
memset(cuccIMEI, 0, IMEI_LEN);
|
|
cuccIMSI = mallocEc(IMSI_LEN);
|
|
memset(cuccIMSI, 0, IMSI_LEN);
|
|
cuccCCID = mallocEc(CCID_LEN);
|
|
memset(cuccCCID, 0, CCID_LEN);
|
|
len = strlen((const char *)imei);
|
|
memcpy(cuccIMEI, imei, len);
|
|
len = strlen((const char *)imsi);
|
|
memcpy(cuccIMSI, imsi, len);
|
|
len = strlen((const char *)simCCID);
|
|
memcpy(cuccCCID, simCCID, len);
|
|
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk5, P_SIG, "autoReg find new sim iccid, start auto register");
|
|
cuccDmAutoRegInitTask();
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk6, P_SIG, "autoReg find same sim iccid");
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk7, P_SIG, "autoReg is enable, start register");
|
|
cuccDmAutoRegInitTask();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk8, P_SIG, "autoReg this MNC is not supported SIM card");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoReg_prechk9, P_SIG, "autoReg the SIM card is %s, it is not '460' SIM card, exit now", (UINT8 *)imsi);
|
|
}
|
|
|
|
if(dmMsgHandle != NULL)
|
|
{
|
|
deregisterPSEventCallback(cuccDmNetWorkStatusCallback);
|
|
vQueueDelete(dmMsgHandle);
|
|
dmMsgHandle = NULL;
|
|
}
|
|
osThreadExit();
|
|
}
|
|
|
|
void cuccAutoRegisterInit(void *argument)
|
|
{
|
|
osThreadAttr_t task_attr;
|
|
memset(&task_attr, 0, sizeof(task_attr));
|
|
|
|
slpManApplyPlatVoteHandle("cuccDm",&cuccDmSlpHandler);
|
|
|
|
task_attr.name = "cuccAutoReg";
|
|
task_attr.stack_size = CUCC_AUTO_REG_TASK_STACK_SIZE;
|
|
task_attr.priority = osPriorityBelowNormal5;
|
|
#ifdef TYPE_EC718M
|
|
task_attr.reserved = osThreadDynamicStackAlloc;
|
|
#endif
|
|
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterInit0, P_SIG, "autoReg..starting task ");
|
|
|
|
cuccAutoRegisterTaskHandle= osThreadNew(cuccAutoRegPreInitTask, NULL,&task_attr);
|
|
if(cuccAutoRegisterTaskHandle == NULL)
|
|
{
|
|
if(slpManGivebackPlatVoteHandle(cuccDmSlpHandler) != RET_TRUE)
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterInit1, P_ERROR, "CUCC_DM vote handle give back failed");
|
|
}
|
|
else
|
|
{
|
|
ECPLAT_PRINTF(UNILOG_DM, cuccAutoRegisterInit2, P_VALUE, "CUCC_DM vote handle give back success");
|
|
}
|
|
}
|
|
}
|
|
|
|
|