From: SnickerSun Date: Tue, 4 Jun 2024 06:40:02 +0000 (+0800) Subject: 同步 xts_origin cat1 入库提交: X-Git-Tag: release_V1.2.70_20241020_135402~1049 X-Git-Url: http://git.snicker.com.cn/css/static/script.js?a=commitdiff_plain;h=24a88d8b5a79e52449ddad6b9f1770e1f6dde2a9;p=mirrors%2FFD230.git 同步 xts_origin cat1 入库提交: commit 38d4e128ac840ca950a158a7bf671d374e0df921 移动入库未完善,待完善优化;添加py压缩文件 commit 07a4673939b3f4a0c71fc2204ddb38c706ac94df 添加中国移动入库.py文件 china_mobile_dmp.py --- diff --git a/code/sdk/application/wearable/service/ble_service/blemoder/bletest.cpp b/code/sdk/application/wearable/service/ble_service/blemoder/bletest.cpp index 45f3b3d99..e3f6e743a 100644 --- a/code/sdk/application/wearable/service/ble_service/blemoder/bletest.cpp +++ b/code/sdk/application/wearable/service/ble_service/blemoder/bletest.cpp @@ -620,7 +620,18 @@ void set_brigthness(uint8_t data) //设置屏幕亮度 p_ConfigModel->SetBrightness(data); return; } +void Set_DmpChangeMode(int state) +{ + OHOS::ConfigModel *p_ConfigModel = OHOS::ConfigModel::GetInstance(); + p_ConfigModel->SetDmpChangeMode(state); +} + +int Get_DmpChangeMode(void) +{ + OHOS::ConfigModel *p_ConfigModel = OHOS::ConfigModel::GetInstance(); + return p_ConfigModel->GetDmpChangeMode(); +} int get_brigthness(void) //获取屏幕亮度 { OHOS::ConfigModel *p_ConfigModel = OHOS::ConfigModel::GetInstance(); diff --git a/code/sdk/application/wearable/service/ble_service/blemoder/bletest.h b/code/sdk/application/wearable/service/ble_service/blemoder/bletest.h index fed09c74c..b4395cb03 100644 --- a/code/sdk/application/wearable/service/ble_service/blemoder/bletest.h +++ b/code/sdk/application/wearable/service/ble_service/blemoder/bletest.h @@ -182,6 +182,10 @@ void ble_get_sleep_remind(msg_get_sleep_param_info_t *data); void ble_set_sleep_remind(msg_get_sleep_param_info_t data); char * ble_step_history(uint8_t day,uint16_t *len); + +void Set_DmpChangeMode(int state); +int Get_DmpChangeMode(void); + #ifdef __cplusplus #if __cplusplus } diff --git a/code/sdk/application/wearable/service/ble_service/bleservice/bleEvent.c b/code/sdk/application/wearable/service/ble_service/bleservice/bleEvent.c index d9deb4e92..e2bdbe679 100644 --- a/code/sdk/application/wearable/service/ble_service/bleservice/bleEvent.c +++ b/code/sdk/application/wearable/service/ble_service/bleservice/bleEvent.c @@ -4025,6 +4025,63 @@ len 就是data的长度 *totaldata:总的数据内容 包含包头和校验预览做接口是用 如果要计算totaldata的长度直接是len+17+1 就是加上包头和校验和 crcvalue;数据的校验和 不包含包头和校验和的计算结果 */ +// 73 01 31 01 00 00 00 01 00 00 00 01 00 00 00 00 00 2 FE +void SetDMPModeCmd(uint16_t cmd,uint8_t *data,uint16_t len,uint8_t *totalData,uint8_t crcvalue)//设置入库模式 0关闭 1电信 2-255移动 +{ + uint8_t value[19]; + memset(value,0,19); + uint32_t tmp = 1; + value[0] =0x72; + value[1] =0x01; + value[2] =0x31; + memcpy(value+3,&tmp,4); + memcpy(value+7,&tmp,4); + memcpy(value+11,&tmp,4); + memcpy(value+15,&tmp,2); + + if(Check_CRC(data,len,crcvalue)) + { + + int state = 0; + state = data[0]; + printf("data[0];%d state:%d\r\n",data[0],state); + Set_DmpChangeMode(state); + value[17] = 1; + value[18] = Calculate_CRC(value,18); + sendBleData(value,19); + }else{ + value[17] = 0; + value[18] = Calculate_CRC(value,18); + sendBleData(value,19); + } +} +// 73 01 FE 01 00 00 00 00 00 00 00 01 00 00 00 00 00 crc + +void GetDMPModeCmd(uint16_t cmd,uint8_t *data,uint16_t len,uint8_t *totalData,uint8_t crcvalue)//获取入库模式 0关闭 1电信 2-255移动 +{ + uint8_t value[19]; + memset(value,0,19); + uint32_t tmp = 1; + value[0] =0x72; + value[1] =0x01; + value[2] =0x32; + memcpy(value+3,&tmp,4); + memcpy(value+7,&tmp,4); + memcpy(value+11,&tmp,4); + memcpy(value+15,&tmp,2); + + if(Check_CRC(data,len,crcvalue)) + { + int state = Get_DmpChangeMode(); + value[17] = state; + value[18] = Calculate_CRC(value,18); + sendBleData(value,19); + }else{ + value[17] = 0; + value[18] = Calculate_CRC(value,18); + sendBleData(value,19); + } +} void type2AE3Data(ble_read_data *buffer_handle,uint8_t *cmd_buf ,uint8_t *data,uint16_t datalen,uint8_t *totaldata,uint8_t crcvalue) { uint16_t cmd = cmd_buf[1]*256+cmd_buf[2]; @@ -4163,7 +4220,13 @@ void type2AE3Data(ble_read_data *buffer_handle,uint8_t *cmd_buf ,uint8_t *data,u case ALARM_CMD://获取手表闹钟//同步闹钟 readDevDataBle(cmd,data,datalen,totaldata,crcvalue); break; - + + case SET_DMP_MODE_CMD://0X0131 + SetDMPModeCmd(cmd,data,datalen,totaldata,crcvalue); + break; + case GET_DMP_MODE_CMD://0X0132 + GetDMPModeCmd(cmd,data,datalen,totaldata,crcvalue); + break; default: break; } diff --git a/code/sdk/application/wearable/service/ble_service/bleservice/bleEvent.h b/code/sdk/application/wearable/service/ble_service/bleservice/bleEvent.h index ecacb8069..3ec0f3cc2 100644 --- a/code/sdk/application/wearable/service/ble_service/bleservice/bleEvent.h +++ b/code/sdk/application/wearable/service/ble_service/bleservice/bleEvent.h @@ -92,6 +92,9 @@ void cameram_send_data(void); #define SYN_BASIC_TRANIN_HISTORY_DATA_CMD 0x0149 //同步基础训练历史数据basic training #define SYN_SLEEP_HISTORY_DATA_CMD 0x014B //同步睡眠历史数据 +#define SET_DMP_MODE_CMD 0x0131 +#define GET_DMP_MODE_CMD 0x0132 + #define FIND_PHONE_CMD 0x0501 //同步睡眠历史数据 #define MSG_DIRECTION_RECV 0x73 diff --git a/code/sdk/build/config/target_config/brandy/config.py b/code/sdk/build/config/target_config/brandy/config.py index ae39c1f09..5d9e483a4 100755 --- a/code/sdk/build/config/target_config/brandy/config.py +++ b/code/sdk/build/config/target_config/brandy/config.py @@ -137,9 +137,10 @@ target = { 'SUPPORT_BLE_SERVICE', 'FD230', 'CYWEE_SPORT', - 'SUPPORT_BAIDU_MAP', + 'SUPPORT_TELECOM_DMP', + #'SUPPORT_CHINA_MOBILE_DMP', 'SUPPORT_HID_SERVICE', - 'SUPPORT_TELECOM_DMP', + 'SUPPORT_BAIDU_MAP' ], 'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite", "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation', diff --git a/code/sdk/drivers/peripheral/config/include/ConfigModel.h b/code/sdk/drivers/peripheral/config/include/ConfigModel.h index e88fdaad2..b21c53a74 100644 --- a/code/sdk/drivers/peripheral/config/include/ConfigModel.h +++ b/code/sdk/drivers/peripheral/config/include/ConfigModel.h @@ -98,6 +98,11 @@ namespace OHOS CONFIFMOFEL_ITEM_SIM_ICCID,//SIM卡的ICCID CONFIFMOFEL_ITEM_TELECOM_DMP_TIMESEC,//注册时间戳 + CONFIFMOFEL_ITEM_DMP_FACTORY_STATUS,//入库恢复出厂状态 0已恢复出厂过 1代表没有 1cat1发送 + + CONFIFMOFEL_ITEM_DMP_CHANGE_MODE,//入库切换模式 默认是1 电信入库 2-255其他是移动入库 0是关闭 + CONFIFMOFEL_ITEM_DMP_CHANGE_MODE_OLD,//入库切换模式旧模式 防止切换来回数据不清楚问题 默认是1 电信入库 2-255其他是移动入库 + CONFIGMODEL_ITEM_MAX, } ; @@ -183,6 +188,15 @@ namespace OHOS void SetCallVolume(int value); int GetCallVolume(void); + + void SetDmpFactoryStatus(int state); + int GetDmpFactoryStatus(void); + + void SetDmpChangeMode(int state);//设置入库模式 + int GetDmpChangeMode(void);//获取入库模式 + + void SetDmpChangeModeOld(int state);//设置旧入库模式 + int GetDmpChangeModeOld(void);//获取旧入库模式 void SetVibrationReminder(int state); int GetVibrationReminder(void); @@ -278,6 +292,9 @@ namespace OHOS {ConfigDataType::DATATYPE_STRING, "sedentary_reminderTime ", "10:00-22:00" }, // CONFIFMOFEL_ITEM_SEDENTARY_REMINDERTIME,//久坐提醒时间段 {ConfigDataType::DATATYPE_STRING, "sim_iccid", "" },//CONFIFMOFEL_ITEM_SIM_ICCID cat1的iccid {ConfigDataType::DATATYPE_STRING, "telecom_regist_timesec", "" },//CONFIFMOFEL_ITEM_TELECOM_DMP_TIMESEC + {ConfigDataType::DATATYPE_INT, "dmp_factory_status", "0" },//CONFIFMOFEL_ITEM_DMP_FACTORY_STATUS默认是0 + {ConfigDataType::DATATYPE_INT, "dmp_change_mode", "1" },//CONFIFMOFEL_ITEM_DMP_CHANGE_MODE 入库切换模式 默认值 1 + {ConfigDataType::DATATYPE_INT, "dmp_change_mode_old", "1" }//CONFIFMOFEL_ITEM_DMP_CHANGE_MODE_OLD 默认值 1 要和新默认值一致 }; ConfigModel(); // 私有构造函数,确保无法在外部实例化 ConfigModel(const ConfigModel &) = delete; // 禁止拷贝构造 diff --git a/code/sdk/drivers/peripheral/config/src/ConfigModel.cpp b/code/sdk/drivers/peripheral/config/src/ConfigModel.cpp index 4c7fd2cc0..c8032b769 100644 --- a/code/sdk/drivers/peripheral/config/src/ConfigModel.cpp +++ b/code/sdk/drivers/peripheral/config/src/ConfigModel.cpp @@ -672,6 +672,37 @@ namespace OHOS set_condigData_String(CONFIGMODEL_ITEM_CAT1_MODEMVER,str); } + void ConfigModel::SetDmpFactoryStatus(int state) + { + set_condigData_Int(CONFIFMOFEL_ITEM_DMP_FACTORY_STATUS,state); + } + + int ConfigModel::GetDmpFactoryStatus(void) + { + return get_configData_int(CONFIFMOFEL_ITEM_DMP_FACTORY_STATUS); + } + + void ConfigModel::SetDmpChangeMode(int state) + { + set_condigData_Int(CONFIFMOFEL_ITEM_DMP_CHANGE_MODE,state); + } + + + int ConfigModel::GetDmpChangeMode(void) + { + return get_configData_int(CONFIFMOFEL_ITEM_DMP_CHANGE_MODE); + } + + void ConfigModel::SetDmpChangeModeOld(int state) + { + set_condigData_Int(CONFIFMOFEL_ITEM_DMP_CHANGE_MODE_OLD,state); + } + + + int ConfigModel::GetDmpChangeModeOld(void) + { + return get_configData_int(CONFIFMOFEL_ITEM_DMP_CHANGE_MODE_OLD); + } /* * @brief 设置震动模式强度 * @param 马达 开关,3 强,2 中,1 å¼±,0 关 diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/cat1_server.cpp b/code/sdk/drivers/peripheral/slip/cat1Service/cat1_server.cpp index 834348116..4371d2bb3 100644 --- a/code/sdk/drivers/peripheral/slip/cat1Service/cat1_server.cpp +++ b/code/sdk/drivers/peripheral/slip/cat1Service/cat1_server.cpp @@ -83,6 +83,10 @@ enum UDP_COMMAND_HEAD { UDP_MSG_SET_TELECON_DMP_SWITCH = 0x13,//通知cat1是否开启电信入库功能 UDP_MSG_GET_TELECON_DMP_TIMESEC = 0x14,//获取本地保存的注册的时间戳 UDP_MSG_RECV_CAT1_SMS_CONTENT = 0x15,//接收信息内容数据 + + UDP_MSG_SEND_BLE_MAC_TO_CAT1 = 0x16,//发送BLE MAC地址->CAT1 + + UDP_MSG_RECV_DMP_FACTORY = 0x17,//用于入库配置flag 0已经恢复出厂过 1代表没有恢复出厂过 }; static uint8_t g_msg_format_type = 0;// 0: old format , 1: new format @@ -949,15 +953,7 @@ void get_sim_iccid_toCat1(void)//获取sim卡的ICCID到cat1 udp_send_msg_toCat1(UDP_MSG_GET_SIM_ICCID,iccid_buf); } } -void set_telecom_dmp_switch_toCat1(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_toBle(char *msg)//保存注册的时间戳 { if(strncmp(msg,"REGIST_TIME:",12) == 0)//字符串是否有ICCID:字符串 @@ -969,6 +965,28 @@ void save_regist_time_toBle(char *msg)//保存注册的时间戳 } return; } +void send_dmp_mode_toCat1(uint8_t on)//设置 +{ + printf("set_telecom_dmp_switch_toCat1 on:%d\r\n",on); + char buf[10] ={0}; + sprintf_s(buf,10,"%d",on); + udp_send_msg_toCat1(UDP_MSG_SET_TELECON_DMP_SWITCH,buf);//1开启 0关闭 +} +int get_dmp_change_mode_toCat1(void)//获取切换模式TO CAT1 +{ + int state = OHOS::ConfigModel::GetInstance()->GetDmpChangeMode(); + return state; +} +void set_dmp_change_mode_old(uint8_t mode)//获取切换模式TO CAT1 +{ + OHOS::ConfigModel::GetInstance()->SetDmpChangeModeOld(mode); + return; +} +int get_dmp_change_mode_old(void)//获取切换模式TO CAT1 +{ + int state = OHOS::ConfigModel::GetInstance()->GetDmpChangeModeOld(); + return state; +} void get_regist_time_toCat1(void)//设置电信入库功能开关->CAT1 { char time_buf[30] = {0}; @@ -985,6 +1003,35 @@ void get_regist_time_toCat1(void)//设置电信入库功能开关->CAT1 udp_send_msg_toCat1(UDP_MSG_GET_TELECON_DMP_TIMESEC,time_buf); } } +void send_ble_mac_toCat1(void)//发送BLE mac地址 to CAT1 +{ + errcode_t ret = 0; + uint8_t btaddr[6] = {0}; + char btaddr_str[64] = {0}; + uint32_t len = 6; + ret = uapi_get_nv_btaddr((uint8_t *)btaddr, &len); + sprintf_s((char *)btaddr_str,64,"%02X:%02X:%02X:%02X:%02X:%02X", btaddr[0], btaddr[1], btaddr[2], btaddr[3], btaddr[4], btaddr[5]); + udp_send_msg_toCat1(UDP_MSG_SEND_BLE_MAC_TO_CAT1,btaddr_str); +} +void send_dmp_factory_flag(void)//发送入库出厂标识 +{ + printf("send_dmp_factory_flag\r\n"); + char send_str[10] = {0}; + int state = OHOS::ConfigModel::GetInstance()->GetDmpFactoryStatus(); + sprintf_s((char *)send_str,10, "%d", state); + udp_send_msg_toCat1(UDP_MSG_RECV_DMP_FACTORY,send_str);//发送和接收同一个指令 +} +int get_dmp_factory_status(void) +{ + int state = OHOS::ConfigModel::GetInstance()->GetDmpFactoryStatus(); + return state; +} +void set_dmp_china_mobile_factory_flag(char *msg)//设置factory状态 +{ + printf("set_dmp_china_mobile_factory_flag:%s\r\n",msg); + int state = atoi(msg); + OHOS::ConfigModel::GetInstance()->SetDmpFactoryStatus(state); +} static int udp_packet_parse(char *rx_buffer, int len) { @@ -1052,12 +1099,28 @@ static int udp_packet_parse(char *rx_buffer, int len) restart_time_sync(); cat1_getsignal(); if(g_msg_format_type == 0) break; - #ifdef SUPPORT_TELECOM_DMP //是否开启电信入库功能 - set_telecom_dmp_switch_toCat1(1); - get_software_version_toCat1(); - get_sim_iccid_toCat1(); - get_regist_time_toCat1(); - #endif + int stateOld = get_dmp_change_mode_old(); + int stateNew = get_dmp_change_mode_toCat1();//0 stateOld = 0 0-1 + if (stateNew == 0){//关闭入库功能 把恢复出厂标识清0 + send_dmp_mode_toCat1(stateNew); + set_dmp_change_mode_old(stateNew); + set_dmp_china_mobile_factory_flag("0");//清数据不能保留原来的数据 + }else{ + set_dmp_change_mode_old(stateNew); + if (stateNew != stateOld ){//防止切换之后数据还是以前的 + set_dmp_china_mobile_factory_flag("0");//清数据不能保留原来的数据 + } + printf("stateNew %d stateOld:%d\r\n",stateNew,stateOld); + send_dmp_mode_toCat1(stateNew); + if (stateNew == 1){ //0 是不开启入库功能 1 电信 2-255其他移动 + get_software_version_toCat1(); + send_dmp_factory_flag(); + }else { + get_software_version_toCat1(); + send_ble_mac_toCat1(); + send_dmp_factory_flag(); + } + } if(sntp_enabled()==0) { sntp_init(); @@ -1067,10 +1130,8 @@ static int udp_packet_parse(char *rx_buffer, int len) } } break; - case UDP_MSG_GET_TELECON_DMP_TIMESEC: - #ifdef SUPPORT_TELECOM_DMP - save_regist_time_toBle(msg_buffer); - #endif + case UDP_MSG_GET_TELECON_DMP_TIMESEC://暂时不用 + break; case UDP_CMD_GET_CAT1VER: index = cat1_handle_version_msg(msg_buffer); @@ -1078,10 +1139,10 @@ static int udp_packet_parse(char *rx_buffer, int len) 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_toBle(msg_buffer); - #endif + case UDP_MSG_SAVE_SIM_ICCID://暂时不用 + break; + case UDP_MSG_RECV_DMP_FACTORY: + set_dmp_china_mobile_factory_flag(msg_buffer); break; case UDP_MSG_RECV_CAT1_SMS_CONTENT://接收单条短信内容 case UDP_MSG_SMS: diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/EventMesh.py b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/EventMesh.py index 6441113cd..df8d94021 100644 --- a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/EventMesh.py +++ b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/EventMesh.py @@ -1,7 +1,8 @@ import _thread import usys import ql_fs -CHINA_TELECOM_DM_FUN_ENABLE = 1 #是否开启电信入库的功能 +CHINA_TELECOM_DM_FUN_ENABLE = 0 #是否开启电信入库的功能 +CHINA_MOBILE_DM_FUN_ENABLE = 0 #开启移动入库功能 class EventStore(object): def __init__(self): self.map = dict() diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/cat1Service.py b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/cat1Service.py index bf7f36aeb..2d9268353 100644 --- a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/cat1Service.py +++ b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/cat1Service.py @@ -50,10 +50,10 @@ import request import ql_fs import pm import sms -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 +from usr.EventMesh import eventMesh,CHINA_TELECOM_DM_FUN_ENABLE,CHINA_MOBILE_DM_FUN_ENABLE + +from usr.telecom_dmp import telecomDmpCb +from usr.china_mobile_dmp import chinamobileCb def msg_cb(args): index = args[1] @@ -71,7 +71,7 @@ sms.setCallback(msg_cb)#sms注册回调 CAT1_SERVICE_HEAD = 'FE' #固定head PROJECT_NAME = "Cat1SlipUDPService" -PROJECT_VERSION = "PY_SRV_V7" +PROJECT_VERSION = "PY_SRV_V8" CONFIG_JSON="/usr/system_config.json" CURRENT_APP_TYPE="pysrv" @@ -228,24 +228,27 @@ class Cat1Service: 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) + 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.deletSmsTimer = osTimer() + + eventMesh.subscribe("set_dmp_change_mode",self.set_dmp_change_mode) + eventMesh.subscribe("get_dmp_change_mode",self.get_dmp_change_mode) eventMesh.subscribe("delete_sms_event",self.delete_sms_event) eventMesh.subscribe("remove_all_sms_cb", self.remove_all_sms_cb)# eventMesh.subscribe("send_sms_max_to_Ble",self.send_sms_max_to_Ble) eventMesh.subscribe("get_all_sms_data",self.get_all_sms_data)#获取所有的短信内容 eventMesh.subscribe("send_singal_data_toBle",self.send_singal_data_toBle) eventMesh.subscribe("delete_sms_single_data",self.delete_sms_single_data) + + eventMesh.subscribe("get_factory_status",self.get_factory_status) + eventMesh.subscribe("set_factory_status",self.set_factory_status) eventMesh.publish("delete_sms_event") - self.deletSmsTimer = osTimer() + self.telecom_dmp_switch = 0 self.send_data = [] @@ -256,6 +259,8 @@ class Cat1Service: # self.msg_nums = 0 self.msg_nums_old = 0 + self.china_mobile_init = 0 + self.factory_status = 0 sms_get = sms.getSaveLoc() if(sms_get != -1): sms_lacv = sms_get[0][0] @@ -356,13 +361,31 @@ class Cat1Service: 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: + if CHINA_TELECOM_DM_FUN_ENABLE == 1 : + if eventMesh.publish("get_dmp_change_mode") == 1: self.telecom_recv_cmd(cmd,parm) + else: + pass + + if CHINA_MOBILE_DM_FUN_ENABLE == 1: + if eventMesh.publish("get_dmp_change_mode") > 1: + self.china_mobile_recv_cmd(cmd,parm) + else: + pass pass elif cmd == "13": - if CHINA_TELECOM_DM_FUN_ENABLE == 1: - self.telecom_recv_cmd(cmd,parm) + on = int(parm) + print("set_dmp_change_mode on:{}".format(on)) + eventMesh.publish("set_dmp_change_mode",on) + + elif cmd == "16": + if CHINA_MOBILE_DM_FUN_ENABLE == 1: + if eventMesh.publish("get_dmp_change_mode") > 1: + self.china_mobile_recv_cmd(cmd,parm) + else: + pass + elif cmd == "17":#用于CAT1恢复出厂需要清空数据的标识通用 + eventMesh.publish("set_factory_status",int(parm)) def telecom_recv_cmd(self,cmd,parm):#电信入库 @@ -371,24 +394,35 @@ class Cat1Service: 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 + elif cmd == "14":# + pass pass - def set_telecom_dmp_switch(self,event,msg): + def china_mobile_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 == "16":#获取BLE mac地址 + eventMesh.publish("set_dev_mac",str(parm)) + print("parm:{}\r\n".format(parm)) + + pass + def get_factory_status(self,event,msg): + return self.factory_status + def set_factory_status(self,event,msg): + self.factory_status = int(msg) + if self.factory_status == 0:#只有为的时候才设置进去 1不再设置 + self.reply_cmd('17',"{}".format(1)) + + + def set_dmp_change_mode(self,event,msg): self.telecom_dmp_switch = msg def delete_sms_single_data(self,event,msg):#删除单条信息 sms.deleteMsg(int(msg)) - def get_telecom_dmp_switch(self,event,msg): + def get_dmp_change_mode(self,event,msg): return self.telecom_dmp_switch def delete_sms_event(self,event,msg): self.deletSmsTimer.start(2*1000,0,self.delete_sms_cb) @@ -626,18 +660,15 @@ class Cat1Service: 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) + 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) + eventMesh.publish("set_network_state",self.__net_connected) + self.__waiting_netstat = 0 return -1 @@ -732,9 +763,19 @@ class Cat1Service: cat1service.set_dns(pri_dns, sec_dns) # 网卡IP信息查询 cat1service.ipconfig() + if eventMesh.publish("get_dmp_change_mode") == 0:#入库功能关闭 + return if CHINA_TELECOM_DM_FUN_ENABLE == 1:#电信入库功能 不使用设置 0 防止两边不同步修改 - if eventMesh.publish("get_telecom_dmp_switch") == 1: + if eventMesh.publish("get_dmp_change_mode") == 1: + eventMesh.publish("set_network_state",1) telecomDmpCb.telecom_dmp_power_on_init() + if CHINA_MOBILE_DM_FUN_ENABLE == 1: + if eventMesh.publish("get_dmp_change_mode") > 1: + eventMesh.publish("set_network_state",1) + if self.china_mobile_init == 1: + return + self.china_mobile_init = 1 + chinamobileCb.china_mobile_init() def cat1_reply_iccid_to_ble(self,event,msg): ICCID_DATA = str("ICCID:")+str(msg) @@ -899,7 +940,7 @@ voiceCall.setCallback(voice_callback) def checknet_cb(arg): print("start checktime!!") if CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次 - if eventMesh.publish("get_telecom_dmp_switch") == 1: + if eventMesh.publish("get_dmp_change_mode") == 1: telecomDmpCb.telecom_dmp_power_on_count() _thread.start_new_thread(cat1service.wait_network_ready, ()) diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/checkota.py b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/checkota.py index e3abcdd48..216de226f 100644 --- a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/checkota.py +++ b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/checkota.py @@ -14,7 +14,7 @@ import utime import log import uos -PROJECT_VERSION="PY_OTA_V7" +PROJECT_VERSION="PY_OTA_V8" CONFIG_JSON="/usr/system_config.json" CURRENT_APP_TYPE="pyota" # 设置日志输出级别 diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/china_mobile_dmp.py b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/china_mobile_dmp.py new file mode 100644 index 000000000..ebb67740b --- /dev/null +++ b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/china_mobile_dmp.py @@ -0,0 +1,669 @@ +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 ucryptolib import aes +import hashlib +from usr.EventMesh import eventMesh +# 设置日志输出级别 +log.basicConfig(level=log.INFO) +fota_log = log.getLogger("china_mobile") +import modem +import base64 +import request +import ujson +BLOCK_SIZE = 16 +#中国移动入库 +class chinamobile: + def __init__(self): + self.multiDayResend_timer = osTimer()#12小时定时器 多日重发的机制 + + self.multimer_count = 0#多日重发机制周期Count + self.multimer_init = 0 + self.power_on_multiflag = 0 + self.timer_count = 0 + self.timerPowerNum = 0 + self.telecom_init_state = 0#初始化状态开机检查标识 + self.isRegistOk = 0#注册成功 + self.config_data = {} + + 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("set_dev_mac",self.set_dev_mac)#订阅消息 + eventMesh.subscribe("get_dev_mac",self.get_dev_mac)#订阅消息 + + self.regist_timeSec = 0 + self.iccid_data = "" + self.software_version = "" + self.mac_data ="" + self.address = "b.fxltsbl.com" + + self.retryInterval = 10 + self.retryNum = 1#异常重试最大次数 + self.heartBeatTime = 1440#心跳上报频率 单位分钟 + self.reportTime = 1440#最大上报频率 自注册+心跳上报的频率次数不能大于最大上报频率次数 + self.reportNum = 8 #最大上报次数 + + self.reportTime_Sec = 0 #保存本地 保存时间戳下一次开机使用 + self.report_Num_old = 0#保存本地 + self.retryNum_old = 0#保存本地 + self.init_flag = 0#初始化状态指初始化一次 + self.retryTimer = osTimer()#异常重试定时器 + self.retpoertTimerC = osTimer()#上报次数大于下一个周期再触发 + self.heartreportTimer = osTimer()#心跳上报定时器 + + pass + + + 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 set_dev_mac(self,event,msg):#设置BLE MAC地址 + self.mac_data = str(msg) + + def get_dev_mac(self,event,msg):#获取BLE MAC地址 + return self.mac_data + + def sha256_encode(self,key,data):#对数据进行AES256加密 + h = hashlib.sha256() + h.update(key) + crypto_key = h.digest() + #IV是偏移量 默认16个十六进制00 + IV = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + crypto = aes(crypto_key, 2, IV) + + #进行PKCS7Padding填充。 + block_num = len(data) // BLOCK_SIZE+1 + k = len(data) % BLOCK_SIZE + j = len(data) // BLOCK_SIZE + padding = BLOCK_SIZE - k + i = 0 + szDataIn = bytearray(data) + # print(szDataIn) + szDataIn = szDataIn+bytearray(block_num * BLOCK_SIZE -len(data)) + # print(szDataIn) + + for i in range(padding): + szDataIn[j * BLOCK_SIZE + k + i] = padding + # print("szDataIn:{} {} {}\r\n".format(szDataIn,j * BLOCK_SIZE + k + i,padding)) + + indata = bytes(szDataIn) + enc = crypto.encrypt(indata) + #最后将加密AES256的数据转换成base64的编码格式 + msg_tmp = base64.b64encode(enc) + data_encode = msg_tmp.decode('ascii')#转换成字符串 + return data_encode + + #写文件信息 + def write_config_msg_file(self,msg): + print("write_config_msg_file msg:{}\r\n".format(msg)) + with open("/usr/china_mobie_config.json",'w+',encoding="utf-8") as fd: + ujson.dump(msg,fd) + #读文件信息 + def read_config_msg_file(self): + + IFEXIST = ql_fs.path_exists("/usr/china_mobie_config.json") #不存在 + if IFEXIST == True: + with open("/usr/china_mobie_config.json","r",encoding='utf-8') as fd: + self.config_data = ujson.load(fd) + print("read_config_msg_file self.config_data:{}\r\n".format(self.config_data)) + + def china_mobile_first_get_config(self,url): + ##############第一步#######获取采集规则配置####### + brand = "KUMI"#品牌 + + model = "Watch Soar"#型号 + appKey = "M100001131"#不需要就填***appKey 厂商标识 + sdkVersion = "***"#非SDK传输 + apiVersion = "4.0.1"#接口定义 固定4.0.1 + apiType = "I"#非Android + templateId = "TY000014"#根据产品分类在平台查询 + IMEI = modem.getDevImei() + imei1 = IMEI#IMEI1或者CMEI + imei2 = "***" + configType = "autoRegist"#自注册填autoRegist 心跳配置传输 keepAlive + preField1 = "***"#预留字段1 + preField2 = "***"#预留字段2 + preField3 = "***"#预留字段3 + + + + #配置拉取数据格式 + config_data = {"endpoint":"{}||{}||{}||{}||{}||{}||{}||{}||{}||{}||{}||{}".format(brand,model,appKey,sdkVersion,apiVersion,apiType,templateId,imei1,imei2,preField1,preField2,preField3),"configType":"{}".format(configType)} + + #配置拉取数据上报地址 + url = "https://{}//dm-multi-accept/multi/getMultiTerminalConfig".format(self.address) + headers_T ={"Content-Type":"application/json"} + print("ujson.dumps(config_data):{}".format(ujson.dumps(config_data))) + response = request.post(url, data=ujson.dumps(config_data),headers =headers_T) + result_json = "" + if response.status_code == 200:#服务器响应成功并返回数据 + content = response.content + c = next(content) + result_json = ujson.loads(c) + print("response.json:{}".format(ujson.loads(c))) + return result_json + + + def first_get_config_json(self):#开机上电获取配置信息 + getresult = 0 + print("first_get_config_json false",self.__net_connected) + if self.__net_connected != 1:#网络不正常 + return getresult + url = "https://{}//dm-multi-accept/multi/getMultiTerminalConfig".format(self.address) + result_json = self.china_mobile_first_get_config(url) + # { + # "reportTime":1440, + # "reportNum":8, + # "heartBeatTime":1440, + # "retryInterval":10, + # "retryNum":1 + # }#默认采集规则配置 + #默认参数 + + retryInterval = self.retryInterval + heartBeatTime = self.heartBeatTime + reportTime = self.reportTime + reportNum = self.reportNum + retryNum = self.retryNum + address = self.address + print("get_config_json old:{} {} {} {} {} {}\r\n".format(reportTime,heartBeatTime,reportNum,retryInterval,retryNum,address)) + if "rspCode" in result_json:#返回结课code 0000成功 其他参考文档 + rspCode = result_json["rspCode"] + rspCode_zh = result_json["rspMsg"] + if rspCode == "0000" or rspCode_zh == "成功": + getresult = 1 + if "result" in result_json: + msg_data = result_json["result"] #采集规则配置信息 + if "ruleConfig" in msg_data:#不存在就是空 + msg_data = msg_data["ruleConfig"] + msg_data = ujson.loads(msg_data)#转换成json格式 + if "reportTime" in msg_data: + self.reportTime = int(msg_data["reportTime"]) + if "heartBeatTime" in msg_data: + self.heartBeatTime = int(msg_data["heartBeatTime"]) + if "reportNum" in msg_data: + self.reportNum = int(msg_data["reportNum"]) + if "retryInterval" in msg_data: + self.retryInterval = int(msg_data["retryInterval"]) + if "retryNum" in msg_data: + self.retryNum = int(msg_data["retryNum"]) + if "address" in msg_data: + self.address = str(msg_data["address"]) + print("get_config_json new:{} {} {} {} {}\r\n".format(self.reportTime,self.heartBeatTime,self.reportNum,self.retryInterval,self.retryNum,self.address)) + + print("true") + else: + print("false") + self.config_data["reportTime"] = self.reportTime + self.config_data["heartBeatTime"] = self.heartBeatTime + self.config_data["reportNum"] = self.reportNum + self.config_data["retryNum"] = self.retryNum + self.config_data["retryInterval"] = self.retryInterval + self.config_data["address"] = str(self.address) + + + if getresult == 1:#请求配置文件成功 + if (self.retryInterval != retryInterval) or (self.retryNum != retryNum) or (self.heartBeatTime != heartBeatTime) or\ + (self.reportTime != reportTime) or (self.reportNum != reportNum) or (self.address != address): + #重新走注册流程 清空报错次数 记录当前时间戳 + print("new config not old config!!!\r\n")#拉取的配置文件和保存本地的不一致 + self.write_config_msg_file(self.config_data) #保存新的配置文件 + return 2 + return getresult #1 获取成功 0 获取失败 + + + def china_mobile_autoregist_infor(self,url,configType_data): + #########################第二步############自注册上报################### + #设备自注册上报 + dev_autoregist_result = 0 #默认是1成功 0是失败 + if self.__net_connected != 1:#网络不正常 + return dev_autoregist_result + #密钥 + key = "f74c005251dc40c4b64a283827da3812" + + brand = "{}".format("KUMI")#品牌 + + model = "Watch Soar"#型号 + appKey = "M100001131"#不需要就填***appKey 厂商标识 + sdkVersion = "***"#非SDK传输 + apiVersion = "4.0.1"#接口定义 固定4.0.1 + apiType = "I"#非Android + templateId = "TY000014"#根据产品分类在平台查询 + IMEI = modem.getDevImei() + imei1 = IMEI#IMEI1或者CMEI + imei2 = "***" + configType = configType_data#自注册填autoRegist 心跳配置传输 keepAlive 暂时不用 + preField1 = "***"#预留字段1 + preField2 = "***"#预留字段2 + preField3 = "***"#预留字段3 + + #不需要加密 #||分隔符不能超过11个 否则平台会解析出错 + config_data = "{}||{}||{}||{}||{}||{}||{}||{}||{}||{}||{}||{}".format(brand,model,appKey,sdkVersion,apiVersion,apiType,templateId,imei1,imei2,configType,preField1,preField2) + + #需要加密的数据明文 + if (len(self.mac_data) == 0):#获取失败了 + self.mac_data = "***" + + MAC = self.mac_data + # base64_MAC = sha256_encode(key,MAC) + RAM = "35MB" + # base64_RAM = sha256_encode(key,RAM) + ROM = "144MB" + # base64_ROM = sha256_encode(key,ROM) + CPU = "YH601S" + # base64_CPU = sha256_encode(key,CPU) + sysVersion = "OpenHarmony 3.2" + # base64_sysVersion = sha256_encode(key,sysVersion) + if (len(self.software_version) == 0):#获取失败了 + self.software_version = "Watch Soar V1.0" + softwareVer = self.software_version + # base64_softwareVer = sha256_encode(key,softwareVer) + softwareName ="FD230" + # base64_softwareName = sha256_encode(key,softwareName) + volte="0" #0:开;1:关;-1:不支持 + # base64_volte = sha256_encode(key,volte) + netType="4G" + # base64_netType = sha256_encode(key,netType) + + resolution="466*466" + # base64_resolution = sha256_encode(key,resolution) + + screenSize = "1.43" + # base64_screenSize = sha256_encode(key,screenSize) + wearingStatus ="***" + # base64_wearingStatus = sha256_encode(key,wearingStatus) + + networkStatus ="1"#1:连接;0:未连接;-1:不支持 + # base64_networkStatus = sha256_encode(key,networkStatus) + encyr_data = [MAC,RAM,ROM,CPU,sysVersion,softwareVer,softwareName,volte,netType,resolution,screenSize,wearingStatus,networkStatus] + print(len(encyr_data)) + encyr_new_data=[] + for i in range(len(encyr_data)): + tmp_data = self.sha256_encode(key,encyr_data[i]) + encyr_new_data.append(tmp_data) + + # deviceInfo_tmp = { + # "bluetoothMac":"{}".format(base64_MAC),#mac地址可填可不填 + # "ram":"{}".format(base64_RAM),#ram信息 + # "rom":"{}".format(base64_ROM),#rom信息 + # "cpu":"{}".format(base64_CPU),#cpu信息 + # "sysVersion":"{}".format(base64_sysVersion),#操作系统版本号 + # "softwareVer":"{}".format(base64_softwareVer),#固件版本号 + # "softwareName":"{}".format(base64_softwareName),#固件名称 + # "volte":"{}".format(base64_volte),#volte开关 默认是开 + # "netType":"{}".format(base64_netType),#当前网络类型4G + # "resolution":"{}".format(base64_resolution),#屏幕分辨率466*466 + # "screenSize":"{}".format(base64_screenSize),#屏幕尺寸默认1.43 + # "wearingStatus":"{}".format(base64_wearingStatus),#佩戴状态不支持 + # "networkStatus":"{}".format(base64_networkStatus)#网络状态 + + # } + deviceInfo_tmp = { + "bluetoothMac":"{}".format(encyr_new_data[0]),#mac地址可填可不填 + "ram":"{}".format(encyr_new_data[1]),#ram信息 + "rom":"{}".format(encyr_new_data[2]),#rom信息 + "cpu":"{}".format(encyr_new_data[3]),#cpu信息 + "sysVersion":"{}".format(encyr_new_data[4]),#操作系统版本号 + "softwareVer":"{}".format(encyr_new_data[5]),#固件版本号 + "softwareName":"{}".format(encyr_new_data[6]),#固件名称 + "volte":"{}".format(encyr_new_data[7]),#volte开关 默认是开 + "netType":"{}".format(encyr_new_data[8]),#当前网络类型4G + "resolution":"{}".format(encyr_new_data[9]),#屏幕分辨率466*466 + "screenSize":"{}".format(encyr_new_data[10]),#屏幕尺寸默认1.43 + "wearingStatus":"{}".format(encyr_new_data[11]),#佩戴状态不支持 + "networkStatus":"{}".format(encyr_new_data[12])#网络状态 + } + json_data = ujson.dumps(deviceInfo_tmp)#需要转义的字符串 + + send_autoregist = { + "endpoint":config_data, + "deviceInfo":"{}".format(json_data) + } + + test_data = ujson.dumps(send_autoregist)#需要转义的字符串 + print("test_data:{}".format(test_data)) + headers_T ={"Content-Type":"application/json"} + response = request.post(url, data=ujson.dumps(send_autoregist),headers =headers_T) + result_json = "" + + if response.status_code == 200: + dev_autoregist_result = 1 + content = response.content + c = next(content) + result_json = ujson.loads(c)#解析成json格式 + else: + dev_autoregist_result = 0 + + + if "rspCode" in result_json: + rspCode = result_json["rspCode"] + rspMsg = result_json["rspMsg"] + if rspCode == "0000" or rspMsg == "成功": + dev_autoregist_result = 1 + else: + dev_autoregist_result = 0 + else: + dev_autoregist_result = 0 + + return dev_autoregist_result + + def read_config_file(self):#获取配置文件,一开机是没有配置文件的 + + self.read_config_msg_file()#读文件信息 + if self.config_data != {}: + if "retryInterval" in self.config_data: + self.retryInterval = int(self.config_data["retryInterval"]) + if "retryNum" in self.config_data: + self.retryNum = int(self.config_data["retryNum"]) + if "heartBeatTime" in self.config_data: + self.heartBeatTime = int(self.config_data["heartBeatTime"]) + if "reportTime" in self.config_data: + self.reportTime = int(self.config_data["reportTime"]) + if "reportNum" in self.config_data: + self.reportNum = int(self.config_data["reportNum"]) + if "address" in self.config_data: + self.address = str(self.config_data["address"]) + + #终端本地需要保存本地的数据 + # self.reportTime_Sec = 0 #保存本地 保存时间戳下一次开机使用 + # self.report_Num_old = 0#保存本地 + # self.retryNum_old = 3#保存本地 + + if "reportTime_Sec" in self.config_data: + self.reportTime_Sec = int(self.config_data["reportTime_Sec"]) + if "report_Num_old" in self.config_data: + self.report_Num_old = int(self.config_data["report_Num_old"]) + if "retryNum_old" in self.config_data: + self.retryNum_old = int(self.config_data["retryNum_old"]) + + print("read_config_file self.config_data:{} ".format(self.config_data)) + def retryTimerCb(self,*argc):#异常重试机制定时器回调 + #保存本地 + self.retryNum_old+=1 #1 self.reportNum = 1 + self.config_data["retryNum_old"] = self.retryNum_old + self.write_config_msg_file(self.config_data) + print("retryTimerCb self.retryNum_old:{}\r\n".format(self.retryNum_old)) + self.search_report_num_step() + pass + + def error_retryNum_step(self):#判读报错次数是否大于self.retryNum 步骤 + print("error_retryNum_step:self.retryNum_oldd:{} self.retryNum:{} self.reportTime:{}\r\n".format(self.retryNum_old,self.retryNum,self.reportTime)) + + if self.retryNum_old >= self.retryNum and self.retryNum_old != 0:#self.retryNum_old > 10#结束HTPP下一个最大频率周期时间间隔流程 + print("error_retryNum_step:self.retryNum_old >= self.retryNum\r\n") + self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalCb)#重新开始 需要清空数据 + else: + get_result = self.first_get_config_json()#发起向服务端请求配置信息下发到设备端 + if get_result == 0:#获取失败或者没有网络 走异常重试机制 + self.report_Num_old+=1#请求错误请求失败都要保存上报次数 + self.config_data["report_Num_old"] = self.report_Num_old + self.write_config_msg_file(self.config_data) + print("error_retryNum_step:self.retryTimer.start :{} {}\r\n".format(self.report_Num_old,self.reportNum)) + if self.report_Num_old >= self.reportNum and self.report_Num_old != 0: + self.retryTimer.stop()#关定时器 + self.retpoertTimerC.stop() + self.heartreportTimer.stop() + self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb) + pass + else:# + + #第一步触发自注册 + if get_result == 2:#请求的配置文件和本地不一致重启 + self.report_Num_old+=1#请求错误请求失败都要保存上报次数 + self.config_data["report_Num_old"] = self.report_Num_old + self.write_config_msg_file(self.config_data) + + self.retryNum_old = 0#保存本地 配置文件不同重启模组 清空异常重试的报错次数 + self.config_data["retryNum_old"] = self.retryNum_old + self.write_config_msg_file(self.config_data) + self.china_mobile_init()#重新走流程读配置文件->判断上报总数->判断报错次数->获取配置文件 + return + + report_result = self.self_regis_report_cb()#注册 + + #第二步触发心跳上报次数 + if report_result == 1:#注册完成之后根据服务端下发的配置 间隔上报心跳 + # self.heart_report_cb() + self.heartreportTimer.start(self.heartBeatTime*60*1000,1,self.heartreportTimerCb) + + def heartreportTimerCb(self,*argc): + self.heart_report_cb() + + def check_current_time(self):#检测当前时间是否超过self.reportTime 超过清空报错次数 清空上报总次数 + # + date_tmp = utime.localtime() + currentTime = utime.mktime(date_tmp)#获取时间戳 + reportTime = self.reportTime_Sec + print("check_current_time:time_tmp - self.reportTime_Sec:{} self.reportTime*60:{}".format(self.reportTime_Sec - currentTime ,self.reportTime*60)) + if currentTime > reportTime:#当前时间是否大于上次记录的时间 currentTime >= reportTime 直接清空 不超过定时清空数据不再上报数据 + date_tmp = utime.localtime() + time_tmp = utime.mktime(date_tmp)#获取时间戳 + self.report_Num_old = 0#清空上报总次数 #保存本地 + self.retryNum_old = 0#清空上报错误次数 #保存本地 + self.reportTime_Sec = time_tmp+reportTime#记录当前时间+reportTime的时间用于下次错判断 + self.config_data["reportTime_Sec"] = self.reportTime_Sec + self.config_data["retryNum_old"] = self.retryNum_old + self.config_data["report_Num_old"] = self.report_Num_old + self.write_config_msg_file(self.config_data) + self.error_retryNum_step() + else:#否则次数置零,记录一下(当前时间+reportTime)时间 + time_count = self.reportTime_Sec - currentTime#self.reportTime_Sec永远比time_tmp大 + self.retpoertTimerC.start(time_count*1000,1,self.retpoertTimerCB) + + + # 第一次请求的时候,记录一下(当前时间+reportTime)时间与次数,如果次数小于最大次数,直接返回true。 + # 如果次数大于最大次数,则判断一下当前时间是否超过上次设置的时间,如果超过了,则表示超过最大次数;否则次数置零,记录一下(当前时间+reportTime)时间。 + def retpoertTimerCB(self,*argc):#按照剩余的时间做定时器 + + date_tmp = utime.localtime() + time_tmp = utime.mktime(date_tmp)#获取时间戳 + print("retpoertTimerCB time_tmp -self.reportTime_Sec:{} time_tmp :{} self.reportTime_Sec:{}\r\n".format(self.reportTime_Sec-time_tmp,time_tmp,self.reportTime_Sec)) + self.report_Num_old = 0#清空上报总次数 #保存本地 + self.retryNum_old = 0#清空上报错误次数 #保存本地 + self.reportTime_Sec = time_tmp+reportTime#记录当前时间+reportTime的时间用于下次错判断 + self.config_data["reportTime_Sec"] = self.reportTime_Sec + self.config_data["retryNum_old"] = self.retryNum_old + self.config_data["report_Num_old"] = self.report_Num_old + self.write_config_msg_file(self.config_data) + self.retpoertTimerC.stop()#关闭定时器 + self.error_retryNum_step()#清空报错次数重新走判断报错次数 + pass + + def search_report_num_step(self):#查询上报总数步骤 + print("search_report_num_step:self.retryInterval:{} self.retryNum:{}".format(self.report_Num_old,self.reportNum)) + if self.report_Num_old >= self.reportNum and self.report_Num_old != 0:#查询上报的总次数是否大于存储上报总次数 + self.check_current_time()#检测当前时间是否超过self.reportTime 超过清空报错次数 清空上报总次数 + else:# + date_tmp = utime.localtime() + time_tmp = utime.mktime(date_tmp)#获取时间戳 + self.reportTime_Sec = time_tmp+self.reportTime*60 #(记录时间+reportTime)标识旧的时间 + self.config_data["reportTime_Sec"] = self.reportTime_Sec + self.write_config_msg_file(self.config_data) + self.error_retryNum_step()#查询上报错误次数 + + def reportTimerIntervalCb(self,*argc):#最大上报频率时间间隔定时器 要清空数据 + print("reportTimerIntervalCb\r\n") + self.retryNum_old = 0#保存 + self.report_Num_old = 0#保存 定时清空数据 + date_tmp = utime.localtime() + time_tmp = utime.mktime(date_tmp)#获取时间戳 + self.reportTime_Sec = time_tmp+self.reportTime*60 #(记录时间+reportTime)标识旧的时间 + self.config_data["reportTime_Sec"] = self.reportTime_Sec + self.config_data["retryNum_old"] = self.retryNum_old + self.config_data["report_Num_old"] = self.report_Num_old + self.write_config_msg_file(self.config_data) + self.search_report_num_step()#重新查询 + + def self_regis_report_cb(self):#自注册上报信息 + date_tmp = utime.localtime() + time_tmp = utime.mktime(date_tmp)#获取时间戳 + + self.report_Num_old+=1 ##保存本地 + self.config_data["report_Num_old"] = self.report_Num_old + self.write_config_msg_file(self.config_data) + print("self_regis_report_cb:self.report_Num_old:{} self.reportNum:{} self.reportTime_Sec:{}\r\n".format(self.report_Num_old,self.reportNum,self.reportTime_Sec)) + + #设备自注册上报信息 + url = "https://{}//dm-multi-accept/multi/acceptMultiTerminalRegInfo".format(self.address)#上报地址 + confing_type = "autoRegist"#上报传输配置 + result = self.china_mobile_autoregist_infor(url,confing_type) + + + if result != 1: + #触发异常重试进制 + if self.report_Num_old >= self.reportNum and self.report_Num_old != 0:#上报次数大于 + self.retryTimer.stop()#关定时器 + self.retpoertTimerC.stop() + self.heartreportTimer.stop() + if self.retryNum_old >= self.retryNum and self.retryNum_old != 0: + print("retryTimerCb timer22")#异常重试过多重新间隔reportTime注册流程 关闭所有的定时器 + self.retryTimer.stop()#关定时器 + self.retpoertTimerC.stop() + self.heartreportTimer.stop() + self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalCb)#重新开始 需要清空数据 + return + self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb) + return 0 + else: + if self.report_Num_old >= self.reportNum and self.report_Num_old != 0: + self.retryTimer.stop()#关定时器 + self.retpoertTimerC.stop() + self.heartreportTimer.stop() + self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalCb) + return 0 + else: + return 1 + + def heart_report_cb(self):#心跳上报信息 + #设备心跳上报信息 + + date_tmp = utime.localtime() + time_tmp = utime.mktime(date_tmp)#获取时间戳 + self.report_Num_old+=1#保存本地 + self.config_data["report_Num_old"] = self.report_Num_old + self.write_config_msg_file(self.config_data) + print("heart_report_cb:self.report_Num_old:{} self.reportNum:{} self.reportTime:{} self.reportTime_Sec:{}\r\n".format(self.report_Num_old,self.reportNum,self.reportTime,self.reportTime_Sec)) + + + url = "https://{}//dm-multi-accept/multi/acceptMultiTerminalHeartbeatInfo".format(self.address)#上报地址 + confing_type = "keepAlive"#上报传输配置 + result = self.china_mobile_autoregist_infor(url,confing_type) + if result != 1: + #触发异常重试进制 + if self.report_Num_old >= self.reportNum and self.report_Num_old != 0: + self.retryTimer.stop()#关定时器 + self.retpoertTimerC.stop() + self.heartreportTimer.stop() + if self.retryNum_old >= self.retryNum and self.retryNum_old != 0:#异常重试过多重新间隔reportTime注册流程 + print("retryTimerCb timer3333") + self.retryTimer.stop()#关定时器 + self.retpoertTimerC.stop() + self.heartreportTimer.stop() + self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalCb)#重新开始 需要清空数据 + return + self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb) + return + if self.report_Num_old >= self.reportNum and self.report_Num_old != 0: + self.retryTimer.stop()#关定时器 + self.retpoertTimerC.stop() + self.heartreportTimer.stop() + print("self.retpoertTimerC.start") + self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalCb) + return + + def china_mobile_init(self):#初始化 + + status = eventMesh.publish("get_factory_status") + if status == None: + status = 0 + if status == 0:#恢复出厂或者新的机器需要清空不必要的数据 + if self.init_flag == 0:#只初始化一次 + IFEXIST = ql_fs.path_exists("/usr/telecom_config.json") #不存在 + if IFEXIST == True: + uos.remove("/usr/telecom_config.json") + isStorage = ql_fs.path_exists("/usr/china_mobie_config.json")#移动入库的配置文件移除 + if isStorage == True: + uos.remove("/usr/china_mobie_config.json") + #先清空再写入 + self.init_flag = 1 + self.retryInterval = 10 + self.retryNum = 1#异常重试最大次数 + self.heartBeatTime = 1440#心跳上报频率 单位分钟 + self.reportTime = 1440#最大上报频率 自注册+心跳上报的频率次数不能大于最大上报频率次数 + self.reportNum = 8 #最大上报次数 + + self.reportTime_Sec = 0 #保存本地 保存时间戳下一次开机使用 + self.report_Num_old = 0#保存本地 + self.retryNum_old = 0#保存本地 + + self.address = "b.fxltsbl.com"#默认适配地址 + + self.config_data["retryInterval"] = self.retryInterval + self.config_data["retryNum"] = self.retryNum + self.config_data["heartBeatTime"] = self.heartBeatTime + self.config_data["reportTime"] = self.reportTime + self.config_data["reportNum"] = self.reportNum + self.config_data["address"] = self.address + + self.config_data["report_Num_old"] = self.report_Num_old + self.config_data["retryNum_old"] = self.retryNum_old + + self.write_config_msg_file(self.config_data) + #读配置文件 + self.read_config_file()#只读一下配置文件 + + self.retryTimer.stop()#关定时器 + self.retpoertTimerC.stop() + self.heartreportTimer.stop() + + #查询上报总数流程 + self.search_report_num_step() + + + + +chinamobileCb = chinamobile() + + + + + + + + + + + + diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/telecom_dmp.py b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/telecom_dmp.py index 075f8950b..de00742fd 100644 --- a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/telecom_dmp.py +++ b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/telecom_dmp.py @@ -37,6 +37,7 @@ def get_report_url_website(mode = None):#获取上报网址 class telecomDmp: def __init__(self): + self.config_data = {} self.check_timer = osTimer()#1小时定时器 self.multiDayResend_timer = osTimer()#12小时定时器 多日重发的机制 self.telecomTimer = osTimer() @@ -107,24 +108,48 @@ class telecomDmp: 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)) + def save_iccid_data(self,event,msg): + self.iccid_data = str(msg)[6:]#ICCID: + print("write_config_msg_file msg:{}\r\n".format(msg)) + self.config_data["ICCID"]=self.iccid_data + with open("/usr/telecom_config.json",'w+',encoding="utf-8") as fd: + ujson.dump(self.config_data,fd) + #读文件信息 + def get_iccid_data(self,event,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 + IFEXIST = ql_fs.path_exists("/usr/telecom_config.json") #不存在 + if IFEXIST == True: + with open("/usr/telecom_config.json","r",encoding='utf-8') as fd: + self.config_data = ujson.load(fd) + print("get_iccid_data self.config_data:{}\r\n".format(self.config_data)) + if self.config_data != {}: + if "ICCID" in self.config_data: + value = self.config_data["ICCID"] + self.iccid_data = str(value) + else: + self.iccid_data = "" + print("get_iccid_data self.config_data end:{}\r\n".format(self.config_data)) 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) + self.regist_timeSec = str(msg)[7:]#REGIST: + print("set_regist_time msg:{}\r\n".format(msg)) + self.config_data["REGIST"]=self.regist_timeSec + with open("/usr/telecom_config.json",'w+',encoding="utf-8") as fd: + ujson.dump(self.config_data,fd) def get_regist_time(self,event,msg):# + IFEXIST = ql_fs.path_exists("/usr/telecom_config.json") #不存在 + if IFEXIST == True: + with open("/usr/telecom_config.json","r",encoding='utf-8') as fd: + self.config_data = ujson.load(fd) + print("get_regist_time self.config_data:{}\r\n".format(self.config_data)) + if self.config_data != {}: + if "REGIST" in self.config_data: + value = self.config_data["REGIST"] + self.regist_timeSec = int(value) + else: + self.regist_timeSec = 0 return self.regist_timeSec @@ -256,7 +281,8 @@ class telecomDmp: self.timer_count = 0 self.check_timer.stop() self.isRegistOk = 1#已完成自注册的标识 - eventMesh.publish("save_iccid_data",[1,iccid]) + iccid_buf =str("ICCID:")+str(str(iccid)) + eventMesh.publish("save_iccid_data",iccid_buf) self.multiple_day_resend() #上报成功后 需要29.5或者30.5天后重发 初始值为0.5也就是12小时 30天后再重发一次也是一个月后重发数据自注册域 print("regist success:!!!!!") @@ -289,14 +315,16 @@ class telecomDmp: time_tmp = utime.mktime(date_tmp)#获取时间戳 if self.multimer_init == 1:#已注册过或者开机5分钟之内没有注册 或者注册成功就开始出发多日重发机制 self.mulit_day_timesec = time_tmp+MULTI_DAY_RESEND_t#初始值多加12小时 #初始化t = 0.5天 - eventMesh.publish("set_regist_time",[1,self.mulit_day_timesec]) + REGIST_buf = str("REGIST:")+str(self.mulit_day_timesec) + eventMesh.publish("set_regist_time",REGIST_buf) 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_RESEND_t #初始化t = 0.5天 - eventMesh.publish("set_regist_time",[1,self.mulit_day_timesec]) + self.mulit_day_timesec = time_tmp+MULTI_DAY_RESEND_t + REGIST_buf = str("REGIST:")+str(self.mulit_day_timesec) + eventMesh.publish("set_regist_time",REGIST_buf) else: self.mulit_day_timesec = get_timesec self.multiDayResend_timer.start(60*60*1000,1,self.multiDayResendTimer_Cb)#一分钟计时 @@ -317,7 +345,8 @@ class telecomDmp: return self.telecom_regist_infor_init()#要自注册数据域信息发送完才初始化t self.mulit_day_timesec = time_tmp+MULTI_DAY_RESEND_t # 重发后 初始化t = 0.5天 - eventMesh.publish("set_regist_time",[1,self.mulit_day_timesec]) + REGIST_buf = str("REGIST:")+str(self.mulit_day_timesec) + eventMesh.publish("set_regist_time",REGIST_buf) def set_telecom_init_state(self,event,msg):#开机5分钟内检查是否有联网 有一次联网就关闭检查 @@ -336,12 +365,27 @@ class telecomDmp: def set_dmp_power_num(self,event,msg): print("set_dmp_power_num:{}".format(msg)) self.timerPowerNum = msg + def clear_storage_data(self): + IFEXIST = ql_fs.path_exists("/usr/telecom_config.json") #不存在 + if IFEXIST == True: + uos.remove("/usr/telecom_config.json") + isStorage = ql_fs.path_exists("/usr/china_mobie_config.json")#移动入库的配置文件移除 + if isStorage == True: + uos.remove("/usr/china_mobie_config.json") + print("clear_storage_data;{} {}".format(IFEXIST,isStorage)) + 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:#开机初始化一次 + status = eventMesh.publish("get_factory_status") + if status == None: + status = 0 + if status == 0:#恢复出厂过需要清空存储数据 + self.clear_storage_data() + pass self.telecomTimer.start(1*1000,0,self.fun_cb) eventMesh.publish("set_telecom_init_state",1) diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/update.json b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/update.json index 4b55ac2d7..fc7a33d0a 100644 --- a/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/update.json +++ b/code/sdk/drivers/peripheral/slip/cat1Service/pyscript/update.json @@ -37,6 +37,13 @@ "OtaPackageName" : "checkota.py", "OtaPackageVersion" : "PY_OTA_V7", "md5sum" : "7d8b35e58ad8ca5eb0ef031c101e375e" + }, + { + "url" : "http://icfota.snicker.com.cn:8089/FD230/PY_OTA_V3/china_mobile_dmp.py", + "OtaPackageLength" : 1809362, + "OtaPackageName" : "china_mobile_dmp.py", + "OtaPackageVersion" : "PY_CHINA_MOBILE_V7", + "md5sum" : "7d8b35e58ad8ca5eb0ef031c101e375e" } ] }