CONFIFMOFEL_ITEM_SLEEP_GET_UP,//起床时间
CONFIFMOFEL_ITEM_SLEEP_REMIND,//提前20分钟提醒开关
++ CONFIFMOFEL_ITEM_SIM_ICCID,//SIM卡的ICCID
++ CONFIFMOFEL_ITEM_TELECOM_DMP_TIMESEC,//注册时间戳
++
CONFIGMODEL_ITEM_MAX,
} ;
std::string GetLanguageCode(void);
std::string Getimei();
++ std::string GetSimIccid();
std::string GetpyVer();
std::string GetmoderVer();
++ std::string GetRegistTime();
void Setimei(char *str);
void SetpyVer(char *str);
void SetmoderVer(char *str);
--
++ void SetSimIccid(char *str);
++ void SetRegistTime(char *time);
void SetCat1_4Gability(bool state);
bool GetCat1_4Gability();
{ConfigDataType::DATATYPE_INT, "sleep_bedtime", "0" }, //CONFIFMOFEL_ITEM_SLEEP_BEDTIME,//就寝时间
{ConfigDataType::DATATYPE_INT, "sleep_getup", "0" }, // CONFIFMOFEL_ITEM_SLEEP_GET_UP,//起床时间
{ConfigDataType::DATATYPE_INT, "sleep_remide", "0" }, // CONFIFMOFEL_ITEM_SLEEP_REMIND,//提前20分钟提醒开关
++ {ConfigDataType::DATATYPE_STRING, "sim_iccid", "" },//CONFIFMOFEL_ITEM_SIM_ICCID cat1的iccid
++ {ConfigDataType::DATATYPE_STRING, "telecom_regist_timesec","" },//CONFIFMOFEL_ITEM_TELECOM_DMP_TIMESEC
};
ConfigModel(); // 私有构造函数，确保无法在外部实例化
ConfigModel(const ConfigModel &) = delete; // 禁止拷贝构造
set_condigData_String(CONFIGMODEL_ITEM_CAT1_IMEI,str);
}
++
++ void ConfigModel::SetSimIccid(char *str)//保存SIM的ICCID
++ {
++ set_condigData_String(CONFIFMOFEL_ITEM_SIM_ICCID,str);
++ }
++
++ std::string ConfigModel::GetSimIccid()///获取本地保存的SIM卡的iccid
++ {
++ return get_configData_string(CONFIFMOFEL_ITEM_SIM_ICCID);
++ }
++
++ void ConfigModel::SetRegistTime(char *time)
++ {
++ set_condigData_String(CONFIFMOFEL_ITEM_TELECOM_DMP_TIMESEC,time);
++ }
++
++ std::string ConfigModel::GetRegistTime(void)
++ {
++ return get_configData_string(CONFIFMOFEL_ITEM_TELECOM_DMP_TIMESEC);
++ }
++
void ConfigModel::SetpyVer(char *str)
{
set_condigData_String(CONFIGMODEL_ITEM_CAT1_PYVER,str);
'SUPPORT_BLE_SERVICE',
'FD230',
'CYWEE_SPORT',
-- 'SUPPORT_HID_SERVICE'
++ 'SUPPORT_HID_SERVICE',
++ 'SUPPORT_TELECOM_DMP',
],
'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite",
"liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation',
#define PORT 1000
//"F"UDP_COMMAND_HEAD , len ,data
enum UDP_COMMAND_HEAD {
-- UDP_CMD_GET_CAT1VER = '0', // 获取 Cat1 版本号
-- UDP_CMD_DIAL_NUMB = '1', // 拨打电话
-- UDP_CMD_HUNGUP = '2', // 挂断电话
-- UDP_CMD_ANSWER = '3', // 接听电话
-- UDP_CMD_CAT1_OTA_UPDATE = '4', // 触发Cat1 OTA升级，mcu提供url
-- UDP_CMD_SEND_SMS = '5', // 发送SMS短信，mcu提供电话号及短信内容
-- UDP_CMD_GET_TIME = '6', // 获取Cat1 时间 ，YYYYMMDD HHmmss zone
-- UDP_CMD_GET_RECV_NETWORKSTAT = '7', //获取Cat1 信号信息，VOLTE信息，信号强度，SIM卡状态 // 内容同UDP_CMD_GET_NETWORKSTAT，CAT主动发给MCU
-- UDP_MSG_SMS = '8', // CAT1接收到的SMS信息给MCU，包含电话号及短信内容
-- UDP_CMD_MSG_ATCMD = '9', // AT 指令
-- UDP_MSG_CALL_CONNECTED = 'A', // CAT1 电话接听消息
-- UDP_MSG_CALL_DISCONNECTED = 'B', // CAT1 电话挂断消息
-- UDP_MSG_COMMING_CALL = 'C' , // CAT1 来电消息，包含电话号
-- // UDP_MSG_TIMESYNC = 'D' , // CAT1 来电消息，包含电话号
-- // UDP_MSG_VERSION = 'E',
-- UDP_MSG_REPLY = 'F' // 返回值
++ UDP_CMD_GET_CAT1VER = 0x00, // 获取 Cat1 版本号
++ UDP_CMD_DIAL_NUMB = 0x01, // 拨打电话
++ UDP_CMD_HUNGUP = 0x02, // 挂断电话
++ UDP_CMD_ANSWER = 0x03, // 接听电话
++ UDP_CMD_CAT1_OTA_UPDATE = 0x04, // 触发Cat1 OTA升级，mcu提供url
++ UDP_CMD_SEND_SMS = 0x05, // 发送SMS短信，mcu提供电话号及短信内容
++ UDP_CMD_GET_TIME = 0x06, // 获取Cat1 时间 ，YYYYMMDD HHmmss zone
++ UDP_CMD_GET_RECV_NETWORKSTAT = 0x07, //获取Cat1 信号信息，VOLTE信息，信号强度，SIM卡状态 // 内容同UDP_CMD_GET_NETWORKSTAT，CAT主动发给MCU
++ UDP_MSG_SMS = 0x08, // CAT1接收到的SMS信息给MCU，包含电话号及短信内容
++ UDP_CMD_MSG_ATCMD = 0x09, // AT 指令
++ UDP_MSG_CALL_CONNECTED = 0x0A, // CAT1 电话接听消息
++ UDP_MSG_CALL_DISCONNECTED = 0x0B, // CAT1 电话挂断消息
++ UDP_MSG_COMMING_CALL = 0x0C , // CAT1 来电消息，包含电话号
++ // UDP_MSG_TIMESYNC = 0x0D , // CAT1 来电消息，包含电话号
++ // UDP_MSG_VERSION = 0x0E,
++ UDP_MSG_REPLY = 0x0F, // 返回值
++
++ /* telecom fun电信入库需要用到以下几个指令*/
++ UDP_MSG_GET_SOFTWARE_VESION = 0x10,//获取固件版本号
++ UDP_MSG_SAVE_SIM_ICCID = 0x11,//保存SIM卡的ICCID
++ UDP_MSG_GET_SIM_ICCID = 0x12,//获取SIM卡的ICCID
++ UDP_MSG_SET_TELECON_DMP_SWITCH = 0x13,//通知cat1是否开启电信入库功能
++ UDP_MSG_GET_TELECON_DMP_TIMESEC = 0x14,//获取本地保存的注册的时间戳
++
};
++
++static uint8_t get_header_cmd_from_uint16_hexstr(uint16_t value)
++{
++
++ uint8_t *p_value = (uint8_t *)&value;
++ uint16_t intvalue = 0;
++ uint8_t * p_intvalue = (uint8_t *)&intvalue;
++ for (int i= 0 ; i<2;i++)
++ {
++ uint8_t tmp=0;
++ switch (p_value[i])
++ {
++ case '0':
++ tmp = 0;
++ break;
++ case '1':
++ tmp = 1;
++ break;
++ case '2':
++ tmp = 2;
++ break;
++ case '3':
++ tmp = 3;
++ break;
++ case '4':
++ tmp = 4;
++ break;
++ case '5':
++ tmp = 5;
++ break;
++ case '6':
++ tmp = 6;
++ break;
++ case '7':
++ tmp = 7;
++ break;
++ case '8':
++ tmp = 8;
++ break;
++ case '9':
++ tmp = 9;
++ break;
++ case 'A':
++ case 'a':
++ tmp = 0xA;
++ break;
++ case 'B':
++ case 'b':
++ tmp = 0xB;
++ break;
++ case 'C':
++ case 'c':
++ tmp = 0xC;
++ break;
++ case 'D':
++ case 'd':
++ tmp = 0xD;
++ break;
++ case 'E':
++ case 'e':
++ tmp = 0xE;
++ break;
++ case 'F':
++ case 'f':
++ tmp = 0xF;
++ break;
++ default:
++ tmp = 0x0;
++ break;
++ }
++ p_intvalue[i] = tmp;
++ }
++ uint8_t ret = (p_intvalue[1]&0x0F) | ((p_intvalue[0]&0x0F)<<4);
++ return ret;
++}
++
// static char *msg_wifi_resp[] =
// {
// "OK", // op success
// "6", // smart config mode
// };
#define RESP_STATUS_OFSET 2
--
++#define MAX_TCP_MSG_BUFFER_LEN (512+8)
#pragma pack(push)
#pragma pack(1)
struct tcp_msg_t {
-- char head[2];
++ uint16_t head;
++ uint16_t cmd;
int length;
char buffer[512];
};
temp[4] = '\0';
msg->length = atoi(temp);
-- if( length != msg->length+6 ) return NULL;
++ if( length != msg->length+8 ) return NULL;
return msg;
}
--static int pack_tlv_format(char *tx_buffer, char *head, char *content)
++static int pack_tlv_format(char *tx_buffer, uint8_t cmd, char *content)
{
int content_length = (int)strlen(content);
-- if( content == NULL || head == NULL || content_length > 9999 ) {
++ if( content == NULL || content_length > MAX_TCP_MSG_BUFFER_LEN ) {
return -1;
}
--
struct tcp_msg_t *msg = (struct tcp_msg_t *)tx_buffer;
-- strncpy(msg->head, head, 2);
-- sprintf((char *)(&msg->length), "%04d", (unsigned char)content_length);
-- sprintf(&tx_buffer[2], "%04d", content_length);
--
++ sprintf((char*)(&msg->head), "%02X", 0xFE);
++ sprintf((char*)(&msg->cmd), "%02X", cmd);
++ sprintf((char*)(&msg->length), "%04d", (unsigned char)content_length);
++ sprintf(&tx_buffer[4], "%04d", content_length);
strcpy(msg->buffer, content);
-- return strlen(content)+6;
++ return strlen(content)+8;
}
--static void udp_send_response(char *tx_buffer, char *head, char *content)
++static void udp_send_response(char *tx_buffer, uint8_t cmd, char *content)
{
// remain lock using
-- int len = pack_tlv_format(tx_buffer, head, content);
++ int len = pack_tlv_format(tx_buffer, cmd, content);
int err = 0;
if( len > 0 ) {
err = sendto(g_listen_sock, tx_buffer, len, 0, (struct sockaddr *)&sourceAddr, sizeof(sourceAddr));
}
}
#include "uart_porting.h"
--void udp_send_msg_toCat1(char cmd,char *content)
++void udp_send_msg_toCat1(uint8_t cmd,char *content)
{
if (!uapi_cat1_get_power_stat())
return ;
}
uapi_cat1_wakeup_cat1(1);
--
// uart_port_register_irq(UART_BUS_0);
osal_irq_enable(UART_1_IRQN);
-- char station_tx_buffer[256] = {0};
-- char station_head[2] = {0};
++ char station_tx_buffer[MAX_TCP_MSG_BUFFER_LEN] = {0};
if( sourceAddr.sin_port != 0 ) {
-- station_head[0] = 'F';
-- station_head[1] = cmd;
-- udp_send_response(station_tx_buffer, station_head, content);
++
++ udp_send_response(station_tx_buffer, cmd, content);
}
uapi_cat1_wakeup_cat1(0);
}
uapi_cat1_stop_volte_voice();
return 1;
}
++void get_software_version_to_cat1(void)//发送固件版本到cat1
++{
++ char version_buf[128] = {0};
++ uint32_t version_len = 128;
++ uapi_get_buildversion((uint8_t *)version_buf, version_len);
++ printf("version_buf %s\r\n",version_buf);
++ udp_send_msg_toCat1(UDP_MSG_GET_SOFTWARE_VESION,version_buf);
++ return;
++}
++void save_sim_iccid_to_ble(char *msg)//保存SIM卡的ICCID到蓝牙
++{
++ if(strncmp(msg,"ICCID:",6) == 0)//字符串是否有ICCID:字符串
++ {
++ char* ppbuf = NULL;
++ ppbuf = msg+6;
++ printf("ppbuf %s\r\n",ppbuf);
++ OHOS::ConfigModel::GetInstance()->SetSimIccid(ppbuf);
++ }
++
++ return;
++}
++
++void get_sim_iccid_to_cat1(void)//获取sim卡的ICCID到cat1
++{
++ char iccid_buf[30] = {0};
++ const char *imei_str = const_cast<char*>(OHOS::ConfigModel::GetInstance()->GetSimIccid().c_str());
++ int len = strlen(imei_str);
++ if(len == 0)
++ {
++ printf("iccid len====0\r\n");
++ udp_send_msg_toCat1(UDP_MSG_GET_SIM_ICCID,"0");
++ }else{
++ sprintf_s(iccid_buf,30,imei_str);
++ udp_send_msg_toCat1(UDP_MSG_GET_SIM_ICCID,iccid_buf);
++ }
++}
++void set_telecom_dmp_switch_to_cat1(uint8_t on)//设置电信入库功能开关->CAT1
++{
++ if(on){
++ udp_send_msg_toCat1(UDP_MSG_SET_TELECON_DMP_SWITCH,"1");//1开启 0关闭
++ }else{
++ udp_send_msg_toCat1(UDP_MSG_SET_TELECON_DMP_SWITCH,"0");
++ }
++
++}
++void save_regist_time_to_ble(char *msg)//保存注册的时间戳
++{
++ if(strncmp(msg,"REGIST_TIME:",12) == 0)//字符串是否有ICCID:字符串
++ {
++ char* ppbuf = NULL;
++ ppbuf = msg+12;
++ printf("time %s\r\n",ppbuf);
++ OHOS::ConfigModel::GetInstance()->SetRegistTime(ppbuf);
++ }
++ return;
++}
++void get_regist_time_toCat1(void)//设置电信入库功能开关->CAT1
++{
++ char time_buf[30] = {0};
++ const char *time_str = const_cast<char*>(OHOS::ConfigModel::GetInstance()->GetRegistTime().c_str());
++ int len = strlen(time_str);
++ if(len == 0)
++ {
++ printf("iccid len====0\r\n");
++ udp_send_msg_toCat1(UDP_MSG_GET_TELECON_DMP_TIMESEC,"0");
++ }
++ else
++ {
++ sprintf_s(time_buf,30,time_str);
++ udp_send_msg_toCat1(UDP_MSG_GET_TELECON_DMP_TIMESEC,time_buf);
++ }
++}
++
++
static int udp_packet_parse(char *rx_buffer, int len)
{
++
struct tcp_msg_t *msg = unpack_tlv_format(rx_buffer, len);
int index = 0;
// if( msg->head[1] != UDP_WIFI_STATUS ) { // ota only status check
// return 1;
// }
++ uint8_t cmd = get_header_cmd_from_uint16_hexstr(msg->cmd);
++
++ uint8_t *p_header = (uint8_t *)&msg->head;
++ if (( *p_header == 'F' || *p_header == 'f') && (*(p_header+1) == 'E' || *(p_header+1) == 'e'))
++ {
++
++ }else{
++ printf("msg format error!\n");
++ return -1;
++ }
++
if( msg != NULL ) {
-- switch (msg->head[1]) {
++ switch (cmd) {
case UDP_MSG_COMMING_CALL:
index = cat1_handle_call_incomming(msg);
break;
PRINT("CAT1_OTA_UPDATE reply %s\n",msg->buffer);
break;
case UDP_MSG_REPLY:
-- PRINT("UDP_MSG_REPLY reply %s\n",msg->buffer);
++ PRINT("UDP_MSG_REPLY reply %s!!!!!!!\n",msg->buffer);
//"BOOTUP,pyVer,PY_SRV_V4,modemVer,EG810MCNLAR06A01M08_VOLTE_OCPU_QPY_BETA0312"
++ // VER:xxxxx
++ // ICCID:xxxxxx
if(strstr(msg->buffer,"BOOTUP")!=NULL)
{
cat1_handle_version_msg(msg);
-- cat1_getsignal();
restart_time_sync();
++ cat1_getsignal();
++ #ifdef SUPPORT_TELECOM_DMP //是否开启电信入库功能
++ set_telecom_dmp_switch_to_cat1(1);
++ get_software_version_to_cat1();
++ get_sim_iccid_to_cat1();
++ get_regist_time_toCat1();
++
++ #endif
}
--
++ break;
++ case UDP_MSG_GET_TELECON_DMP_TIMESEC:
++ #ifdef SUPPORT_TELECOM_DMP
++ save_regist_time_to_ble(msg->buffer);
++ #endif
break;
case UDP_CMD_GET_CAT1VER:
index = cat1_handle_version_msg(msg);
break;
case UDP_CMD_MSG_ATCMD:
PRINT("ATCMD reply : %s\n", msg->buffer);
++ break;
++ case UDP_MSG_SAVE_SIM_ICCID:
++ #ifdef SUPPORT_TELECOM_DMP
++ save_sim_iccid_to_ble(msg->buffer);
++ #endif
break;
default:
PRINT("error message: %s\n", rx_buffer);
while (1) {
++ printf("recv ENTER\r\n");
memset(rx_buffer, 0, sizeof(rx_buffer));
int len = recvfrom(g_listen_sock, rx_buffer, sizeof(rx_buffer) - 1, 0, (struct sockaddr *)&sourceAddr, &addrLen);
// Error occured during receiving
++ printf("recv len:%d rx_buffer:%s\r\n",len,rx_buffer);
if (len < 0) {
PRINT("recv failed: errno %d\n", errno);
break;
void cat1_getver(void);
void restart_time_sync(void);
void cat1_at_cmd(char* cmd);
--
++void send_version_to_cat1(char *version);//发送固件版本到cat1
errcode_t cat1_server_init(void);
++void get_software_version_to_cat1(void);//获取软件版本号到cat1
++void save_sim_iccid_to_ble(char *msg);//保存SIM卡的ICCID到蓝牙
++void get_sim_iccid_to_cat1(void);//获取sim卡的ICCID到cat1
++void set_telecom_dmp_switch_to_cat1(uint8_t on);//设置电信入库功能开关->CAT1
++void save_regist_time_to_ble(char *msg);//保存注册的时间戳
++void get_regist_time_toCat1(void);
#ifdef __cplusplus
#if __cplusplus
--- /dev/null
- import versions
+import _thread
+import usys
-
+import ql_fs
- event_store = EventStore()
++CHINA_TELECOM_DM_FUN_ENABLE = 1 #是否开启电信入库的功能
+class EventStore(object):
+ def __init__(self):
+ self.map = dict()
+ self.log = None
+ self.__filters = []
+
+ def add_filter(self, flt):
+ self.__filters.append(flt)
+
+ def append(self, event, cb):
+ self.map[event] = cb
+
+ def fire_async(self, event, msg,thread_size):
+ if event in self.map:
+ #print("fire_async:thread_size:{}".format(thread_size))
+ if thread_size != None:
+ _thread.stack_size(thread_size)
+ #print("fire_async:thread_size:{}".format(thread_size))
+ _thread.start_new_thread(self.map[event], (event, msg))
+ if thread_size != None:
+ _thread.stack_size(8*1024)
+ if self.log:
+ self.log.info("ASYNC executed (event) -> {} (params) -> {} (result) -> {}".format(event, msg, None))
+
+ def fire_sync(self, event, msg):
+ res = None
+ try:
+ if event in self.map:
+ res = self.map[event](event, msg)
+ except Exception as e:
+ usys.print_exception(e)
+ if self.log:
+ self.log.info("ERROR executed (event) -> {} (params) -> {} (result) -> {}".format(event, msg, res))
+ if event not in self.__filters:
+ if self.log:
+ self.log.info("SYNC executed (event) -> {} (params) -> {} (result) -> {}".format(event, msg, res))
+ return res
+
++ def subscribe(self,event, cb):
++ """
++ subscribe event and cb
++ """
++ return self.append(event, cb)
++
+
- def subscribe(event, cb):
- """
- subscribe event and cb
- """
- return event_store.append(event, cb)
++ def publish(self,event, msg=None):
++ """
++ publish event and msg
++ """
++ return self.publish_sync(event, msg)
+
+
- def publish(event, msg=None):
- """
- publish event and msg
- """
- return publish_sync(event, msg)
++ def publish_async(self,event, msg=None,thread_size = None):
++ """
++ 异步发送
++ """
++ return self.fire_async(event, msg,thread_size)
+
+
- def publish_async(event, msg=None,thread_size = None):
- """
- 异步发送
- """
- return event_store.fire_async(event, msg,thread_size)
++ def publish_sync(self,event, msg=None):
++ """
++ 同步发送
++ """
++ return self.fire_sync(event, msg)
+
+
- def publish_sync(event, msg=None):
- """
- 同步发送
- """
- return event_store.fire_sync(event, msg)
++ def set_log(self,log_adapter):
++ self,log = log_adapter
+
+
- def set_log(log_adapter):
- event_store.log = log_adapter
++ def add_filter(self,flt):
++ self.add_filter(flt)
+
++eventMesh = EventStore()
+
- def add_filter(flt):
- event_store.add_filter(flt)
+
+
+
+
+
+
import request
import ql_fs
import pm
++from usr.EventMesh import eventMesh,CHINA_TELECOM_DM_FUN_ENABLE
++# CHINA_TELECOM_DM_FUN_ENABLE = 1 #是否开启电信入库功能 1开启 0关闭
++if CHINA_TELECOM_DM_FUN_ENABLE == 1:#防止两边不同步修改 用于包含头文件信息
++ from usr.telecom_dmp import telecomDmpCb
++
++CAT1_SERVICE_HEAD = 'FE' #固定head
++
PROJECT_NAME = "Cat1SlipUDPService"
PROJECT_VERSION = "PY_SRV_V6"
CONFIG_JSON="/usr/system_config.json"
pm.autosleep(1)
pm.wakelock_lock(lpm_fd)
cat1service_log.info("create_wakelock {}".format(pm.get_wakelock_num()))
--
++telecomTimerCount = 0
def get_versionkeyname_by_py(app_type):
return str("{}version".format(app_type))
self.__message = ''
self.__err = 0
self.__net_connected = 0
-- self.__value = None
++ # self.__value = None
self.__wait_resp = 0
self.__waiting_netstat = 0
slip.destroy()
print('slip netif construct fail')
return None
print('slip network card create success')
-- self.__queue = Queue(1)
++ # self.__queue = Queue(1)
self.__sock = self.__socket_init()
self.__threadid = _thread.start_new_thread(self.__Socket_Thread, ())
++ self.telecom_init_flag = 0
++ self.telecomTimer = osTimer()
++ if CHINA_TELECOM_DM_FUN_ENABLE == 1:
++ eventMesh.subscribe("cat1_reply_iccid_to_ble",self.cat1_reply_iccid_to_ble)
++ eventMesh.subscribe("cat1_reply_timesec_to_ble",self.cat1_reply_timesec_to_ble)
++
++ self.iccid_data = ""
++ self.software_version = ""
++
++ eventMesh.subscribe("set_telecom_dmp_switch",self.set_telecom_dmp_switch)
++ eventMesh.subscribe("get_telecom_dmp_switch",self.get_telecom_dmp_switch)
++ self.telecom_dmp_switch = 0
return None
def __socket_init(self):
def bootup_msg_to_bt(self):
modem_ver = modem.getDevFwVersion()
-- self.reply_cmd('FF',"BOOTUP@pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
++ self.reply_cmd('0F',"BOOTUP@pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
def btmcu_cmd_handler(self,cmd,parm):
++
++ # cmd = ""
++ # cmd_tmp= int(cmd_data)#将十进制数转换成int 再转换成十六进制
++ # cell_data = hex(cmd_tmp)
++ # decimal_number = int(cell_data, 16)
++ # cmd = "%02x"%(decimal_number) # 使用两位表示，不足前面补0
++ print(cmd) # 输出: 07
print("btmcu_cmd_handler cmd {0} , args {1}".format(cmd,parm))
-- if cmd == "F0":
++ if cmd == "00":
print(cmd)
# UDP_CMD_GET_CAT1VER
modem_ver = modem.getDevFwVersion()
-- self.reply_cmd('F0',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
-- elif cmd == "F1":
++ self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
++ elif cmd == "01":
print("{}{}".format(cmd,parm))
# UDP_CMD_DIAL_NUMB
voiceCall.callStart(parm)
-- elif cmd == "F2":
++ elif cmd == "02":
print(cmd)
# UDP_CMD_HUNGUP
voiceCall.callEnd()
-- elif cmd == "F3":
++ elif cmd == "03":
print(cmd)
# UDP_CMD_ANSWER
voiceCall.callAnswer()
-- elif cmd == "F4":
++ elif cmd == "04":
print(cmd)
result = check_fota()
if result == "":
-- self.reply_cmd('F4',"no need update!")
++ self.reply_cmd('04',"no need update!")
else:
-- self.reply_cmd('F4',"start ota {} please wait...".format(result))
++ self.reply_cmd('04',"start ota {} please wait...".format(result))
download_fota_img(result)
-- elif cmd == "F5":
++ elif cmd == "05":
print(cmd)
# UDP_CMD_SEND_SMS
-- elif cmd == "F6":
++ elif cmd == "06":
print(cmd)
# UDP_CMD_GET_TIME
time=utime.localtime()
# 返回当前时间戳，参数为元组
# timestamp = utime.mktime(time)
# cat1service_log.info(timestamp)
-- self.reply_cmd('F6',"{0}@{1}".format(time,zone))
-- elif cmd == "F7":
-- print(cmd)
++ self.reply_cmd('06',"{0}@{1}".format(time,zone))
++ elif cmd == "07":
++ print("cmd ==== 07!")
# UDP_CMD_GET_RECV_NETWORKSTAT
simstat = sim.getStatus()
imei = modem.getDevImei()
operator = net.operatorName()
signal = net.csqQueryPoll()
print("imei:{0},sim:{1},oper:{2},signal:{3},net:{4}".format(imei,simstat,operator,signal,netstat))
-- self.reply_cmd('F7',"imei:{0}@sim:{1}@oper:{2}@signal:{3}@net:{4}".format(imei,simstat,operator,signal,netstat))
-- elif cmd == "F9":
++ self.reply_cmd('07',"imei:{0}@sim:{1}@oper:{2}@signal:{3}@net:{4}".format(imei,simstat,operator,signal,netstat))
++ elif cmd == "09":
print("{},{}".format(cmd,parm))
# UDP_CMD_ATCMD
# net.setModemFun(0)
ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10)
if ret == 0:
print("reply:{},ret:{}".format(resp.decode(),ret))
-- self.reply_cmd('F9',"{}".format(resp.decode()))
++ self.reply_cmd('09',"{}".format(resp.decode()))
else:
print("cmd error ret:{}".format(ret))
-- self.reply_cmd('F9',"{}".format("at error"))
--
--
++ self.reply_cmd('09',"{}".format("at error"))
++
++ elif cmd == "10" or cmd == "12" or cmd == "14":#获取固件版本号或者获取BT保存的SIM卡的ICCID BLE那边是否开启电信入库功能
++ if CHINA_TELECOM_DM_FUN_ENABLE == 1:
++ if eventMesh.publish("get_telecom_dmp_switch") == 1:
++ self.telecom_recv_cmd(cmd,parm)
++ pass
++ elif cmd == "13":
++ if CHINA_TELECOM_DM_FUN_ENABLE == 1:
++ self.telecom_recv_cmd(cmd,parm)
++
++
++ def telecom_recv_cmd(self,cmd,parm):#电信入库
++ if cmd == "10":
++ self.software_version = str(parm)
++ eventMesh.publish("set_dev_version",self.software_version)
++ print("software_version:{},{}".format(self.software_version,parm))
++ elif cmd == "12":
++ if len(str(parm)) > 1:#为空的时候会传一个字符0
++ self.iccid_data = str(parm)
++ eventMesh.publish("save_iccid_data",[0,self.iccid_data])
++ print("iccid_data:{},{}".format(self.iccid_data,parm))
++ elif cmd == "13":#电信入库功能开关cmd
++ on=int(parm)
++ eventMesh.publish("set_telecom_dmp_switch",on)
++ elif cmd == "14":#电信入库功能开关cmd
++ time=int(parm)
++ eventMesh.publish("set_regist_time",[0,time])
++
++ pass
++ def set_telecom_dmp_switch(self,event,msg):
++ self.telecom_dmp_switch = msg
++ def get_telecom_dmp_switch(self,event,msg):
++ return self.telecom_dmp_switch
# 来电提醒
def notifyIncomingcall(self, incomming_numb):
self.clear_remain()
-- __head = 'FC'
++ __head = '0C'
self.__message = str(incomming_numb)
self.__Socket_UDP(__head, self.__message)
# if self.__err == 1 or self.__value[2] != 'OK':
# 电话接听消息
def notifyConnecteCall(self):
self.clear_remain()
-- __head = 'FA'
++ __head = '0A'
self.__message = '0'
self.__Socket_UDP(__head, self.__message)
# if self.__err == 1 or self.__value[2] != 'OK':
# 电话拒接消息
def notifyDisconnectCall(self):
self.clear_remain()
-- __head = 'FB'
++ __head = '0B'
self.__message = '0'
self.__Socket_UDP(__head, self.__message)
# if self.__err == 1 or self.__value[2] != 'OK':
print('Network connection successful.')
self.set_network_config()
self.__net_connected = 1
++ if CHINA_TELECOM_DM_FUN_ENABLE == 1:
++ if eventMesh.publish("get_telecom_dmp_switch") == 1:
++ eventMesh.publish("set_network_state",self.__net_connected)
self.__waiting_netstat = 0
return 0
else:
print('Network connection failed, stage={}, state={}'.format(stage, state))
self.reset_network_config()
self.__net_connected = 0
++ if CHINA_TELECOM_DM_FUN_ENABLE == 1:
++ if eventMesh.publish("get_telecom_dmp_switch") == 1:
++ eventMesh.publish("set_network_state",self.__net_connected)
self.__waiting_netstat = 0
return -1
def timesync(self,_timesync):
self.clear_remain()
self.__message = str(_timesync)
-- self.__Socket_UDP('FD', self.__message)
++ self.__Socket_UDP('0D', self.__message)
return 0
-- # 查询网卡版本信息
-- def version(self):
-- self.clear_remain()
-- self.__Socket_UDP('F5', '0')
-- if self.__err == 1:
-- return -1
-- return self.__value[2]
--
def reply_timesync(self,_timesync):
self.clear_remain()
self.__message = str(_timesync)
-- self.__Socket_UDP_noreply('FD', self.__message)
++ self.__Socket_UDP_noreply('0D', self.__message)
return 0
def reply_cmd(self,cmd,_timesync):
return 0
def clear_remain(self):
-- if self.__queue.empty() == False:
-- self.__queue.get()
++ # if self.__queue.empty() == False:
++ # self.__queue.get()
self.__err = 0
-- self.__value = None
++ # self.__value = None
#添加路由信息
def router_add(self, ip='192.168.4.1', mask='255.255.255.0'):
self.ip = ip
self.mask = mask
++
return slip.router_add(self.ip, self.mask)
# 获取slip的网络配置
cat1service.ipconfig()
def set_network_config(self):
++
++
if (self.__net_connected == 1) :
print("skip set_network_config")
return 0
cat1service.set_dns(pri_dns, sec_dns)
# 网卡IP信息查询
cat1service.ipconfig()
--
++ if CHINA_TELECOM_DM_FUN_ENABLE == 1:#电信入库功能 不使用设置 0 防止两边不同步修改
++ if eventMesh.publish("get_telecom_dmp_switch") == 1:
++ telecomDmpCb.telecom_dmp_power_on_init()
++
++ def cat1_reply_iccid_to_ble(self,event,msg):
++ ICCID_DATA = str("ICCID:")+str(msg)
++ self.reply_cmd('11',"{}".format(ICCID_DATA))
++ pass
++ def cat1_reply_timesec_to_ble(self,event,msg):
++
++ self.reply_cmd('14',"REGIST_TIME:{}".format(msg))
++ pass
# 释放slip网卡
def stop(self):
slip.destroy()
print('illegal pack tlv content')
return -1
len_str ='%04d' % len(self.content)
-- tlv_pack = self.head+len_str+self.content
++ tlv_pack = CAT1_SERVICE_HEAD+self.head+len_str+self.content
return tlv_pack
--
# 解码tlv数据包
def __unpack_tlv_format(self, msg):
-- self.msg = str(msg)
++ print('__unpack_tlv_format {}\r\n'.format(msg))
++ self.msg = str(msg)[2:]#这是去除head FE
tag = self.msg[0:2]
length = self.msg[2:6]
value = self.msg[6:]
len_str ='%04d' % len(value)
if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != self.msg[2:6]:
-- print('illegal unpack tlv content')
++ print('__unpack_tlv_format err')
return -1
++ print('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
unpack = (tag,length,value)
return unpack
--
# socket通信(UDP)模块
def __Socket_UDP(self, head, content):
try:
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
-- print("send msg {}".format(msg))
++ print("__Socket_UDP send msg {}".format(msg))
self.__err = 0
self.__sock.sendto(msg,server_addr)
self.__wait_resp = 1
utime.sleep_ms(20)
# 消息处理
msg = self.__pack_tlv_format(self.head, self.content)
++
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
-- print("send msg {}".format(msg))
++
++ print("__Socket_UDP_noreply send msg {}".format(msg))
self.__err = 0
self.__sock.sendto(msg,server_addr)
++
self.__wait_resp = 0
return 0
print(recverr)
if "110" in str(recverr):
self.__err = 1
-- if self.__wait_resp == 1:
-- self.__queue.put('0')
++ # if self.__wait_resp == 1:
++ # self.__queue.put('0')
else:
utime.sleep(1)
self.__sock = self.__socket_reinit()
else :
value = self.__unpack_tlv_format(data.decode())
-- print('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2]))
-- if value[0] == 'FF':
-- self.btmcu_cmd_handler(value[0],value[2])
++ if value != -1:
++ print('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2]))
++ if value[1] == 'FF':
++ self.btmcu_cmd_handler(value[0],value[2])
++ else:
++ # self.__value = value
++ # self.__queue.put('1')
++ self.btmcu_cmd_handler(value[0],value[2])
++ print("End else Thread")
else:
-- self.__value = value
-- self.__queue.put('1')
-- self.btmcu_cmd_handler(value[0],value[2])
-- print("End else Thread")
++ print("data error!!")
print("End Socket Thread")
def checknet_cb(arg):
print("start checktime!!")
++ if CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次
++ if eventMesh.publish("get_telecom_dmp_switch") == 1:
++ telecomDmpCb.telecom_dmp_power_on_count()
++
_thread.start_new_thread(cat1service.wait_network_ready, ())
# time=utime.localtime()
# zone=utime.getTimeZone()
#(2024, 3, 2, 18, 31, 32, 5, 62),8
# cat1service.timesync("{0},{1}".format(time,zone))
--
++# _thread.start_new_thread(cat1service.wait_network_ready, ())
timer = osTimer()
# checknet_cb(())
timer.start(30000,1,checknet_cb)
# timesync = net.nitzTime()
# cat1service.timesync(timesync)
++
++
++#url = "http://zzhc.vnet.cn:9998/"
++
++
--- /dev/null
--- /dev/null
++version https://git-lfs.github.com/spec/v1
++oid sha256:963f78be228ae892aa4ec7c09425c6b8f4212be353b0d050221bd52dd9ac6c26
++size 11776692
--- /dev/null
- #远程升级
+import app_fota
+from misc import Power
+import modem
+import ujson
+import request
+import ql_fs
+import checkNet
+import sys
+import sim
-
+
++from queue import Queue
++import usys
++import _thread
+import fota
+import utime
+import log
+import uos
-
-
++import osTimer
++import net
++import ql_fs
++from usr.EventMesh import eventMesh,CHINA_TELECOM_DM_FUN_ENABLE
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+fota_log = log.getLogger("telecom_dmp")
- def get_sim_state():#获取sim状态 不为1是sim异常
- return sim.getStatus()
-
- def dmp_test():
- if get_sim_state() != 1:
- return
- url = "http://zzhc.vnet.cn:9998/"
- data = {
- "REGVER":"v12.0",
- "MODEL":"TXB-Watch Soar",
- "SWVER":"1.0.0",
- "UETYPE":"12",
- "SIM1ICCID":"89860322157550846869",
- "SIM1LTEIMSI":"460115058064458",
- "MACID":"28:11:06:6A:57:58",
- "OSVER":"HarmonyOS Sans",
- "IMEI1":"876226002021717",
- "SIM1CELLID":"C3"
- }
- response = request.post(url, data=ujson.dumps(data))
- content = response.content
- c = next(content)
- # "api.xcloudtech.com"
- # d_server_port = 9000
- jsload_data = ujson.loads(c)
- print("jsload_data:{}".format(jsload_data))
- print("jsload_dataend:{}".format(jsload_data))
++import modem
++import base64
+import request
+import ujson
- if __name__ == '__main__':
- print("telecon_dmp init!!!!!")
- dmp_test()
++REGIST_MAX_NUM=10 #自注册的最大次数 现在是默认是10次
++REGIST_INTERVAL_TIMER=30 #自注册失败的间隔时间 1小时
++REGIST_POWER_ON_TIME=5*60 #开机5分钟内就必须自注册触发
++MULTI_DAY_RESEND_T = 30*24*60*60#多日重发的机制的周期T 30天
++MULTI_DAY_RESEND_t = 12*60*60#多日重发的机制的周期t 0.5天
++def get_report_url_website(mode = None):#获取上报网址
++ url = "http://zzhc.vnet.cn:9998/"#上报网址
++ return url
++
++class telecomDmp:
++ def __init__(self):
++ self.check_timer = osTimer()#1小时定时器
++ self.multiDayResend_timer = osTimer()#12小时定时器 多日重发的机制
++ self.telecomTimer = osTimer()
++ self.multimer_count = 0#多日重发机制周期Count
++ self.multimer_init = 0
++ self.timer_count = 0
++ self.timerPowerNum = 0
++ self.telecom_init_state = 0#初始化状态开机检查标识
++ self.isRegistOk = 0#注册成功
++ eventMesh.subscribe("get_telecom_init_state",self.get_telecom_init_state)
++ eventMesh.subscribe("set_telecom_init_state",self.set_telecom_init_state)
++
++ eventMesh.subscribe("set_dmp_power_num",self.set_dmp_power_num)
++ eventMesh.subscribe("get_dmp_power_num",self.get_dmp_power_num)
++
++ eventMesh.subscribe("get_dmp_power_timer_count",self.get_dmp_power_timer_count)
++
++ self.regist_queue = Queue()
++ _thread.stack_size(10*1024)
++ _thread.start_new_thread(self.regist_queue_thread, ())
++ _thread.stack_size(8*1024)
++
++ eventMesh.subscribe("publish_message_event_registinfor",self.publish_message_event_registinfor)
++ self.__net_connected = 0
++ eventMesh.subscribe("get_network_state",self.get_network_state)#订阅消息
++ eventMesh.subscribe("set_network_state",self.set_network_state)#订阅消息
++
++ eventMesh.subscribe("set_dev_version",self.set_dev_version)#订阅消息
++ eventMesh.subscribe("get_dev_version",self.get_dev_version)#订阅消息
++
++ eventMesh.subscribe("save_iccid_data",self.save_iccid_data)#订阅消息 保存ICCID
++ eventMesh.subscribe("get_iccid_data",self.get_iccid_data)#订阅消息 保存ICCID
++
++ eventMesh.subscribe("set_regist_time",self.set_regist_time)#订阅消息 保存ICCID
++ eventMesh.subscribe("get_regist_time",self.get_regist_time)#订阅消息 保存ICCID
++
++ self.regist_timeSec = 0
++ self.iccid_data = ""
++ self.software_version = ""
++ self.mulit_day_timesec = 0#多日重发的开始的时间戳
++ pass
++ def regist_queue_thread(self):
++ while True:
++ data = self.regist_queue.get()
++ #EventMesh.debug_log("regist_queue:data = {}".format(data))
++ if data != None:
++ try:
++ data["func"](data["data"])
++ except Exception as e:
++ print("regist_queue:ERROR:{}".format(e))
++ usys.print_exception(e)
++ def publish_message_event_registinfor(self,event,msg):
++ self.regist_queue.put(msg)
++
++ def publish_regist_event_cb(self, *args, **kwargs):
++ eventMesh.publish("publish_message_event_registinfor",{"func":self.timer_cb,"data":0})
++
++ def set_network_state(self,event,msg):#设置网络是否正常
++ self.__net_connected = int(msg)
++
++ def get_network_state(self,event,msg):#获取网络是否正常
++ return self.__net_connected
++
++ def set_dev_version(self,event,msg):#获取固件版本号
++ self.software_version = str(msg)
++
++ def get_dev_version(self,event,msg):#获取固件版本号
++ return self.software_version
++
++ def save_iccid_data(self,event,msg):#保存ICCID
++ print("save_iccid_data :{}".format(msg))
++
++ self.iccid_data = str(msg[1])#iccid:
++ if msg[0] == 1:#不需要回复BLE 否则需要回复BLE
++ eventMesh.publish("cat1_reply_iccid_to_ble",self.iccid_data)
++
++ def get_iccid_data(self,event,msg):#获取ICCID
++ return self.iccid_data
++
++ def set_regist_time(self,event,msg):#
++ print("regist_timeSec :{}".format(msg))
++
++ self.regist_timeSec = int(msg[1])#iccid:
++ if msg[0] == 1:#不需要回复BLE 否则需要回复BLE
++ eventMesh.publish("cat1_reply_timesec_to_ble",self.regist_timeSec)
++
++ def get_regist_time(self,event,msg):#
++ return self.regist_timeSec
+
+
++ def get_sim_state(self):#获取sim状态 不为1是sim异常
++ return sim.getStatus()
++
++ def get_sim_iccid(self):#获取sim的iccid
++ return sim.getIccid()
++
++ def get_sim_imsi(self):#获取sim的imsi
++ return sim.getImsi()
++ def get_dev_imei(self):#获取设备的imei号
++ return modem.getDevImei()
++
++ def telecom_regeist_infor(self):#自注册信息 可变更
++ network_state = eventMesh.publish("get_network_state")
++ print("get_network_state!!!!!!!!!! %d self.isRegistOk:%d",network_state,self.isRegistOk)
++ if network_state == 0:# 第一次进入网络不正常就需要开启1小时定时器 等待下一个周期判断网络是否正常 需要判断网络是否正常 不正常就不去触发自注册了 就等待下一次 如果10次都不成功 就等一下次开机再去自注册
++ self.timer_count+=1
++ print("self.timer_count:{}".format(self.timer_count))
++ if self.timer_count < REGIST_MAX_NUM:#总共是10次 10次结束还没有自注册成功就等下一次开机自注册
++ self.check_timer.start(REGIST_INTERVAL_TIMER*1000,0,self.publish_regist_event_cb)#不需要循环定时器
++ else:
++ self.multiple_day_resend()
++ return
++ iccid = self.get_sim_iccid()
++ read_iccid = eventMesh.publish("get_iccid_data")
++ if read_iccid == None:
++ read_iccid = ""
+
++ print("iccid!!!!!!!!!!iccid {} read_iccid:{}".format(iccid,read_iccid))
++ if read_iccid != "":
++ if str(read_iccid) == str(iccid):#两者相同 并且本地有保存 不再自注册了 说明已经自注册过了
++ print("already registed!!!!!!") #已自注册过
++ self.isRegistOk = 1
++
++ if self.isRegistOk == 1:
++ print("multiple_day_resend!!!!!!\r\n")
++ self.multiple_day_resend()
++ return
++ self.telecom_regist_infor_init()#自注册初始化函数
++ if self.isRegistOk == 0:
++ self.timer_count+=1
++ print("self.timer_count:{}".format(self.timer_count))
++ if self.timer_count < REGIST_MAX_NUM:#总共是10次 10次结束还没有自注册成功就等下一次开机自注册
++ self.check_timer.start(REGIST_INTERVAL_TIMER*1000,0,self.publish_regist_event_cb)#不需要循环定时器
++ else:
++ self.multiple_day_resend()
++
++ def telecom_regist_infor_init(self):#自注册的数据部分
++ iccid = self.get_sim_iccid()
++ read_iccid = eventMesh.publish("get_iccid_data")
++ if read_iccid == None:
++ read_iccid = ""
++ url = get_report_url_website(None)#上报网址 根据需要更改上报网址
++ if iccid == -1:
++ iccid = str("FF")#为空就填写FF
++
++ IMSI = self.get_sim_imsi()
++ if IMSI == -1:#没有卡 则填FF
++ IMSI = str("FF")
++ imei = self.get_dev_imei()
++ if imei == -1:
++ imei = str("FF")
++
++ data_tmp = net.getCellInfo() #会适当卡个3-5s
++ i = 0
++ cell_data = 0
++ if(len(data_tmp) >= 1):
++ for cell in data_tmp:
++ if i == 2:#在list里面最多就三个元素 最后一个是LTE的数据
++ if cell != []:
++ for tup in cell:
++ print("tup:{}".format(tup))
++ if tup[0] == 0 and len(tup) > 0:#第0个代表当前服务的小区CELLID 7位16进制数
++ cell_data = tup[1]#这个是十进制数需要自行转换成十六进制数
++ print(cell_data)
++ break
++ i+=1
++ # cell_data = 0
++ cell_data = "%07x"%(cell_data)#7位16进制数不够前面补0
++ print(cell_data)
++ sendCellid = "{}".format(cell_data)
++ REGVER = "12.0"#当前数据域协议版本号
++ MODEL = "TXB-Watch Soar"#机型字段 -前面是厂商名 -后面是设备名
++ get_dev_version = eventMesh.publish("get_dev_version")#订阅消息
++ if get_dev_version == None:
++ get_dev_version = ""
++ SWVER = get_dev_version #软件版本号
++ UETYPE = "12"#终端类型 12是智能手表 11是儿童手表
++ SIM1ICCID = iccid
++ SIM1LTEIMSI = IMSI
++ MACID = ""#可用WALN的地址 终端布支持WLAN 就是不可上网
++ OSVER = "RTOS"#操作系统版本号
++ IMEI1 = imei#"876226002021717"#imei
++ SIM1CELLID = sendCellid#下发的小区ID
++ data = {
++ "REGVER":REGVER,
++ "MODEL":MODEL,
++ "SWVER":SWVER,
++ "UETYPE":UETYPE,
++ "SIM1ICCID":SIM1ICCID,
++ "SIM1LTEIMSI":IMSI,
++ "MACID":MACID,
++ "OSVER":OSVER,
++ "IMEI1":IMEI1,
++ "SIM1CELLID":SIM1CELLID
++ }
++ data_infor=ujson.dumps(data)#将字典转换成json格式
++ json_bytes = bytes(data_infor, 'utf-8')#转换成字节数
++ data_encode = base64.b64encode(json_bytes)#再转换成base64的编码格式 密文
++ print("data_infor:{} data:{}".format(data_encode,data))
++ headers_T = {'Content-Type':'application/encrypted-json'} #请求头信息 按照实际要求填写
++ response = request.post("http://zzhc.vnet.cn:9998/", data=data_encode,headers =headers_T)
++ print("response.status_code:{}".format(response.status_code))
++ if response.status_code == 200: #返回状态码 200服务器正常解析数据
++ content = response.content#后台返回的结果
++ c = next(content)
++
++ jsload_data = ujson.loads(c)
++ print("jsload_data:{}".format(ujson.loads(c))) #{"resultCode": "0","resultDesc": "Success"}
++ if "resultCode" in jsload_data or "resultDesc" in jsload_data:#返回结果码值
++ resultCode = jsload_data["resultCode"]#结果解析 "0" 成功 "1" 解码错误 "2" 校验错误
++ resultDesc = jsload_data["resultDesc"]#Success 表示自注册成功
++
++ if resultCode == "0" or resultDesc == "Success":#注册成功退出当前注册 保存当前的ICCID 不在进行自注册了
++ iccid = self.get_sim_iccid()#获取当前SIM的ICCID
++ if iccid != -1:#没有读到ICCID
++ self.timer_count = 0
++ self.check_timer.stop()
++ self.isRegistOk = 1#已完成自注册的标识
++ eventMesh.publish("save_iccid_data",[1,iccid])
++ self.multiple_day_resend()
++ #上报成功后 需要29.5或者30.5天后重发 初始值为0.5也就是12小时 30天后再重发一次也是一个月后重发数据自注册域
++ print("regist success:!!!!!")
++ return
++ if resultCode == "1":
++ print("Decode error")#解码错误 设备编码不正确
++
++ if resultCode == "2":#
++ print("Check error")#校验错误 设备里面数据不正确 有些数据不应该为空
++
++ def timer_cb(self,data):#定时器回调
++ self.telecom_regeist_infor()#重新进行自注册
++ pass
++ # 多日重发功能要求：
++ # 1) 多日重发是指：在重发周期 T 内，如果没有功能性触发数据域自注册（触发发送且发送成功），
++ # 则终端应根据当前终端实时信息组织数据域自注册（不能直接拿上一周期的内容不变而重发）内容
++ # 并发送的过程；
++ # 2) 多日重发的时间间隔周期 T 设置为 30 天；
++ # 3) 多日重发的过程应设置为：功能性（比如换卡等）触发数据域自注册后，立即启动定时器 t（t
++ # 的初始值应设为 0.5 天）开始重发计时，以后每当 t 时间等于 T 的整数倍（t=N*T）时，终端就进
++ # 行数据域自注册发送，发送后 t 不要清零不要初始化，只有当功能性触发数据域自注册后，t 才初
++ # 始化，t 的初始化值为 0.5 天。
++ # Multiple day resend
++ def multiple_day_resend(self):#多日重发机制函数 没有发送数据域或者发送成功
++
++ t = 12 #计时周期 按照0.5天 也就是12小时来计算
++ T = 30*24 #周期为30天 计算30天的总共小时数
++ # t = N*T#只有t为T的整数倍就需要重发数据域自注册
++ date_tmp = utime.localtime()
++ time_tmp = utime.mktime(date_tmp)#获取时间戳
++ if self.multimer_init == 1:#已注册过或者开机5分钟之内没有注册 或者注册成功就开始出发多日重发机制
++ self.mulit_day_timesec = time_tmp+MULTI_DAY_INIT_TIME_t#初始值多加12小时 #初始化t = 0.5天
++ eventMesh.publish("set_regist_time",[1,self.mulit_day_timesec])
++ return
++ self.multimer_init = 1
++ #设置开始时间戳
++ get_timesec = eventMesh.publish("get_regist_time")#一开机初始化为0 没有保存过数据 如果保存过就用保存的时间
++ if get_timesec == 0:
++ self.mulit_day_timesec = time_tmp+MULTI_DAY_INIT_TIME_t #初始化t = 0.5天
++ eventMesh.publish("set_regist_time",[1,self.mulit_day_timesec])
++ else:
++ self.mulit_day_timesec = get_timesec
++ self.multiDayResend_timer.start(60*1000,1,self.multiDayResendTimer_Cb)#一分钟计时
+
++ def multiDayResendTimer_Cb(self,*argc):#多日重发机制定时器回调函数
++ T = 30*24*60*60
++ date_tmp = utime.localtime()
++ time_tmp = utime.mktime(date_tmp)+MULTI_DAY_INIT_TIME_t#获取时间戳
++
++ if time_tmp < self.mulit_day_timesec:#如果当前时间戳小于保存的时间戳
++ self.mulit_day_timesec = time_tmp
++ print("time_tmp: self.mulit_day_timesec:\r\n",time_tmp,self.mulit_day_timesec)
++
++ if time_tmp - self.mulit_day_timesec >= MULTI_DAY_RESEND_T:#一个周期的时间到了重发注册一次
++ network_state = eventMesh.publish("get_network_state")
++ print("get_network_state:%d\r\n",network_state)
++ if network_state == 0:#网络不正常就不需要重发了等下一个周期
++ return
++ self.telecom_regist_infor_init()#要自注册数据域信息发送完才初始化t
++ self.mulit_day_timesec = time_tmp+MULTI_DAY_INIT_TIME_t # 重发后 初始化t = 0.5天
++ eventMesh.publish("set_regist_time",[1,self.mulit_day_timesec])
++
++
++ def set_telecom_init_state(self,event,msg):#开机5分钟内检查是否有联网 有一次联网就关闭检查
++ self.telecom_init_state = msg
++
++ def get_telecom_init_state(self,event,msg):
++ return self.telecom_init_state
++
++ def get_dmp_power_timer_count(self,event,msg):#开机后限定5分钟内完成自注册
++ return REGIST_POWER_ON_TIME
++
++ def get_dmp_power_num(self,event,msg):#开机限定次数最多十次 十次不成功就等下一次开机 或者多日重发机制
++ print("get_dmp_power_num:{}".format(self.timerPowerNum))
++ return self.timerPowerNum
++
++ def set_dmp_power_num(self,event,msg):
++ print("set_dmp_power_num:{}".format(msg))
++ self.timerPowerNum = msg
++
++ def telecom_dmp_power_on_init(self):#开机初始化一次检测
++ if eventMesh.publish("get_telecom_init_state") == 1:#发送消息获取对应的值
++ return
++ if eventMesh.publish("get_dmp_power_num") < (eventMesh.publish("get_dmp_power_timer_count")*1000)/30000:#开机检查
++ if eventMesh.publish("get_telecom_init_state") == 0:#开机初始化一次
++ self.telecomTimer.start(1*1000,0,self.fun_cb)
++ eventMesh.publish("set_telecom_init_state",1)
++
++ def fun_cb(self,*argc):
++ self.telecom_regeist_infor()#开机初始一次自注册信息
++ pass
++ def telecom_dmp_power_on_count(self):#开机计时判断最多十次
++ if eventMesh.publish("get_telecom_init_state") != 1:#在开机五分钟之内只要一次联网正常就不需要再检查是否网络正常去自注册了
++ if eventMesh.publish("get_dmp_power_num") < (eventMesh.publish("get_dmp_power_timer_count")*1000)/30000+1:#10+1
++ num = eventMesh.publish("get_dmp_power_num") #开机计时 如果开机5分钟内没有一次网络正常的话 当前开机自注册不生效 等待下一次开机自注册触发 或者触发多日重发机制
++ num+=1
++ eventMesh.publish("set_dmp_power_num",num)#次数累计加一
++
++telecomDmpCb = telecomDmp()
++
++
++
++
++
+
+
+
+
+
+
+
projects / mirrors / FD230.git / commitdiff