Snicker Git - mirrors/FD230.git/blob

   1 import app_fota
   2 from misc import Power
   3 import modem
   4 import ujson
   5 import request
   6 import ql_fs
   7 import checkNet
   8 import sys
   9 import sim
  10
  11 from queue import Queue
  12 import usys
  13 import _thread
  14 import fota
  15 import utime
  16 import log
  17 import uos
  18 import osTimer
  19 import net
  20 import ql_fs
  21 from ucryptolib import aes
  22 import hashlib
  23 from usr.EventMesh import eventMesh
  24 # 设置日志输出级别
  25 log.basicConfig(level=log.INFO)
  26 fota_log = log.getLogger("china_mobile")
  27 import modem
  28 import base64
  29 import request
  30 import ujson
  31 import sim
  32
  33 BLOCK_SIZE = 16
  34 NEED_SAVE_CONFIG_FILE = 0  #是否需要保存上报次数 异常重试次数 时间戳到配置文件 0不保存 1保存
  35 #中国移动入库
  36 class chinamobile:
  37     def __init__(self):
  38         self.multiDayResend_timer = osTimer()#12小时定时器 多日重发的机制
  39
  40         self.multimer_count = 0#多日重发机制周期Count
  41         self.multimer_init = 0
  42         self.power_on_multiflag = 0
  43         self.timer_count = 0
  44         self.timerPowerNum = 0
  45         self.telecom_init_state = 0#初始化状态开机检查标识
  46         self.isRegistOk = 0#注册成功
  47         self.config_data = {}
  48
  49         self.__net_connected = 0
  50         self.regist_timeSec = 0
  51         self.iccid_data = ""
  52         self.software_version = ""
  53         self.mac_data =""
  54         self.address = "a.fxltsbl.com"
  55
  56         self.new_address = "a.fxltsbl.com"
  57
  58         self.retryInterval = 10
  59         self.retryNum = 1#异常重试最大次数
  60         self.heartBeatTime = 1440#心跳上报频率 单位分钟
  61         self.reportTime = 1440#最大上报频率 自注册+心跳上报的频率次数不能大于最大上报频率次数
  62         self.reportNum = 8 #最大上报次数
  63
  64
  65         self.reportTime_Sec = 0 #保存本地 保存时间戳下一次开机使用
  66         self.report_Num_old = 0#保存本地
  67         self.retryNum_old = 0#保存本地
  68         self.init_flag = 0#初始化状态指初始化一次
  69         self.retryTimer = osTimer()#异常重试定时器
  70         self.retpoertTimerC = osTimer()#上报次数大于下一个周期再触发
  71         self.heartreportTimer = osTimer()#心跳上报定时器
  72
  73         eventMesh.subscribe("get_network_state",self.get_network_state)#订阅消息
  74         eventMesh.subscribe("set_network_state",self.set_network_state)#订阅消息
  75
  76         eventMesh.subscribe("set_dev_version",self.set_dev_version)#订阅消息
  77         eventMesh.subscribe("get_dev_version",self.get_dev_version)#订阅消息
  78
  79         eventMesh.subscribe("set_dev_mac",self.set_dev_mac)#订阅消息
  80         eventMesh.subscribe("get_dev_mac",self.get_dev_mac)#订阅消息
  81
  82         eventMesh.subscribe("set_dmp_cm_address",self.set_dmp_cm_address)#订阅消息
  83         eventMesh.subscribe("get_dmp_cm_address",self.get_dmp_cm_address)#订阅消息
  84
  85         pass
  86
  87     def set_dmp_cm_address(self,event,msg):#设置网络是否正常
  88         self.address = str(msg)
  89         self.new_address = str(msg)
  90
  91     def get_dmp_cm_address(self,event,msg):#获取网络是否正常
  92         return self.address
  93
  94     def set_network_state(self,event,msg):#设置网络是否正常
  95         self.__net_connected = int(msg)
  96
  97     def get_network_state(self,event,msg):#获取网络是否正常
  98         return self.__net_connected
  99
 100     def set_dev_version(self,event,msg):#获取固件版本号
 101         self.software_version = str(msg)
 102
 103     def get_dev_version(self,event,msg):#获取固件版本号
 104         return self.software_version
 105
 106     def set_dev_mac(self,event,msg):#设置BLE MAC地址
 107         self.mac_data = str(msg)
 108
 109     def get_dev_mac(self,event,msg):#获取BLE MAC地址
 110         return self.mac_data
 111
 112     def sha256_encode(self,key,data):#对数据进行AES256加密
 113         h = hashlib.sha256()
 114         h.update(key)
 115         crypto_key = h.digest()
 116         #IV是偏移量 默认16个十六进制00
 117         IV = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 118
 119         crypto = aes(crypto_key, 2, IV)
 120
 121         #进行PKCS7Padding填充。
 122         block_num = len(data) // BLOCK_SIZE+1
 123         k = len(data) % BLOCK_SIZE
 124         j = len(data) // BLOCK_SIZE
 125         padding = BLOCK_SIZE - k
 126         i = 0
 127         szDataIn = bytearray(data)
 128         # print(szDataIn)
 129         szDataIn = szDataIn+bytearray(block_num * BLOCK_SIZE -len(data))
 130         # print(szDataIn)
 131
 132         for i in range(padding):
 133             szDataIn[j * BLOCK_SIZE + k + i] = padding
 134             # print("szDataIn:{} {} {}\r\n".format(szDataIn,j * BLOCK_SIZE + k + i,padding))
 135
 136         indata = bytes(szDataIn)
 137         enc = crypto.encrypt(indata)
 138         #最后将加密AES256的数据转换成base64的编码格式
 139         msg_tmp = base64.b64encode(enc)
 140         data_encode = msg_tmp.decode('ascii')#转换成字符串
 141         return data_encode
 142
 143     #写文件信息
 144     def write_config_msg_file(self,msg):
 145
 146         print("write_config_msg_file msg:{}\r\n".format(msg))
 147         with open("/usr/china_mobie_config.json",'w+',encoding="utf-8") as fd:
 148             ujson.dump(msg,fd)
 149     #读文件信息
 150     def read_config_msg_file(self):
 151         IFEXIST = ql_fs.path_exists("/usr/china_mobie_config.json")   #不存在
 152         if IFEXIST == True:
 153             with open("/usr/china_mobie_config.json","r",encoding='utf-8') as fd:
 154                 self.config_data = ujson.load(fd)
 155         print("read_config_msg_file self.config_data:{}\r\n".format(self.config_data))
 156
 157     def china_mobile_first_get_config(self,url):
 158         ##############第一步#######获取采集规则配置#######
 159         # brand = "KUMI"#品牌
 160         # model = "Watch Soar"#型号
 161         # NWO N9
 162         brand = "NWO"#品牌
 163         model = "NWO N9"#型号
 164
 165
 166         appKey = "M100001131"#不需要就填***appKey 厂商标识
 167         sdkVersion = "***"#非SDK传输
 168         apiVersion = "4.0.1"#接口定义 固定4.0.1
 169         apiType = "I"#非Android
 170         templateId = "TY000014"#根据产品分类在平台查询
 171         IMEI = modem.getDevImei()
 172         imei1 = IMEI#IMEI1或者CMEI
 173         imei2 = "***"
 174         configType = "autoRegist"#自注册填autoRegist 心跳配置传输 keepAlive
 175         preField1 = "***"#预留字段1
 176         preField2 = "***"#预留字段2
 177         preField3 = "***"#预留字段3
 178
 179
 180
 181         #配置拉取数据格式
 182         config_data = {"endpoint":"{}||{}||{}||{}||{}||{}||{}||{}||{}||{}||{}||{}".format(brand,model,appKey,sdkVersion,apiVersion,apiType,templateId,imei1,imei2,preField1,preField2,preField3),"configType":"{}".format(configType)}
 183
 184         #配置拉取数据上报地址
 185         url = "https://{}//dm-multi-accept/multi/getMultiTerminalConfig".format(self.address)
 186         headers_T ={"Content-Type":"application/json"}
 187         print("ujson.dumps(config_data):{}".format(ujson.dumps(config_data)))
 188         request_result = 0
 189         result_json = ""
 190         try:
 191             response = request.post(url, data=ujson.dumps(config_data),headers =headers_T)
 192             request_result = 1
 193             if response.status_code == 200:#服务器响应成功并返回数据
 194                 content = response.content
 195                 c = next(content)
 196                 result_json = ujson.loads(c)
 197                 print("response.json:{}".format(ujson.loads(c)))
 198         except Exception as e:
 199             print("response:{}".format(e))
 200             request_result = 0
 201
 202
 203         if request_result == 0: #请求出错了
 204             return ""
 205
 206
 207         return result_json
 208
 209
 210     def first_get_config_json(self):#开机上电获取配置信息
 211         getresult = 0
 212         print("first_get_config_json false",self.__net_connected)
 213         network_state = eventMesh.publish("get_network_state")
 214         if network_state != 1:#网络不正常
 215             print("网络不正常")
 216             return getresult
 217         url = "https://{}//dm-multi-accept/multi/getMultiTerminalConfig".format(self.address)
 218         result_json = self.china_mobile_first_get_config(url)
 219
 220         if result_json == "":
 221             print("result_json == NULL")
 222             return 0
 223         # {
 224         #     "reportTime":1440,
 225         #     "reportNum":8,
 226         #     "heartBeatTime":1440,
 227         #     "retryInterval":10,
 228         #     "retryNum":1
 229         # }#默认采集规则配置
 230         #默认参数
 231
 232         retryInterval = self.retryInterval
 233         heartBeatTime = self.heartBeatTime
 234         reportTime = self.reportTime
 235         reportNum = self.reportNum
 236         retryNum = self.retryNum
 237         new_address = self.address
 238         print("get_config_json old:{} {} {} {} {} {}\r\n".format(reportTime,heartBeatTime,reportNum,retryInterval,retryNum,new_address))
 239         if "rspCode" in result_json:#返回结课code 0000成功 其他参考文档
 240             rspCode = result_json["rspCode"]
 241             rspCode_zh = result_json["rspMsg"]
 242             if rspCode == "0000" or rspCode_zh == "成功":
 243                 getresult = 1
 244                 if "result" in result_json:
 245                     msg_data = result_json["result"] #采集规则配置信息
 246                     if "ruleConfig" in msg_data:#不存在就是空
 247                         msg_data = msg_data["ruleConfig"]
 248                         msg_data = ujson.loads(msg_data)#转换成json格式
 249                         if "reportTime" in msg_data:
 250                             self.reportTime = int(msg_data["reportTime"])
 251                         if "heartBeatTime" in msg_data:
 252                             self.heartBeatTime = int(msg_data["heartBeatTime"])
 253                         if "reportNum" in msg_data:
 254                             self.reportNum = int(msg_data["reportNum"])
 255                         if "retryInterval" in msg_data:
 256                             self.retryInterval = int(msg_data["retryInterval"])
 257                         if "retryNum" in msg_data:
 258                             self.retryNum = int(msg_data["retryNum"])
 259                         if "address" in msg_data:
 260                             self.address = str(msg_data["address"])
 261                         print("get_config_json new:{} {} {} {} {}\r\n".format(self.reportTime,self.heartBeatTime,self.reportNum,self.retryInterval,self.retryNum,self.address))
 262
 263                     print("true")
 264                 else:
 265                     print("false")
 266
 267         if getresult == 1:#请求配置文件成功
 268             if (self.retryInterval != retryInterval) or (self.retryNum != retryNum) or  (self.heartBeatTime != heartBeatTime) or\
 269              (self.reportTime != reportTime) or (self.reportNum != reportNum) or (self.address != new_address):
 270                 #重新走注册流程 清空报错次数 记录当前时间戳
 271                 print("new config not old config!!!\r\n")#拉取的配置文件和保存本地的不一致
 272                 self.config_data["reportTime"] = self.reportTime
 273                 self.config_data["heartBeatTime"] = self.heartBeatTime
 274                 self.config_data["reportNum"] = self.reportNum
 275                 self.config_data["retryNum"] = self.retryNum
 276                 self.config_data["retryInterval"] = self.retryInterval
 277                 # self.config_data["address"] = str(self.address)
 278                 if new_address != self.address : #服务器下发和本地不一致需要用服务器下发的最新的IP 并把这个IP发送到BLE保存
 279                     eventMesh.publish("send_dmp_cm_address_toBLE",str(self.address))
 280
 281                 self.write_config_msg_file(self.config_data) #保存新的配置文件
 282                 return 2
 283         return getresult #1 获取成功 0 获取失败
 284
 285
 286     def china_mobile_autoregist_infor(self,url,configType_data):
 287         #########################第二步############自注册上报###################
 288         #设备自注册上报
 289         dev_autoregist_result = 0 #默认是1成功 0是失败
 290         network_state = eventMesh.publish("get_network_state")
 291         if network_state != 1:#网络不正常
 292             return dev_autoregist_result
 293         #密钥
 294         key = "03816c12b6d24182981325e57670e478"
 295
 296         brand = "{}".format("NWO")#品牌
 297
 298         # model = "Watch Soar"#型号
 299         model = "NWO N9"#型号
 300
 301         # -*- coding: UTF-8 -*-
 302 #示例
 303
 304
 305         appKey = "M100001188"#不需要就填***appKey 厂商标识
 306         sdkVersion = "***"#非SDK传输
 307         apiVersion = "4.0.1"#接口定义 固定4.0.1
 308         apiType = "I"#非Android
 309         templateId = "TY000014"#根据产品分类在平台查询
 310         IMEI = modem.getDevImei()
 311         imei1 = IMEI#IMEI1或者CMEI
 312         imei2 = "***"
 313         configType = configType_data#自注册填autoRegist 心跳配置传输 keepAlive 暂时不用
 314         preField1 = "***"#预留字段1
 315         preField2 = "***"#预留字段2
 316         preField3 = "***"#预留字段3
 317
 318
 319         batteryCapacityCurr="***"
 320
 321
 322         #不需要加密 #||分隔符不能超过11个 否则平台会解析出错
 323         config_data = "{}||{}||{}||{}||{}||{}||{}||{}||{}||{}||{}||{}".format(brand,model,appKey,sdkVersion,apiVersion,apiType,templateId,imei1,imei2,configType,preField1,preField2)
 324
 325         #需要加密的数据明文
 326         mac_data="***"#eventMesh.publish("get_dev_mac")
 327
 328         if (len(mac_data) == 0):#获取失败了
 329             mac_data = "***"
 330
 331         imsi = sim.getImsi()
 332         print("Get IMSI : {}".format(imsi))
 333
 334         MAC = mac_data
 335         # base64_MAC = sha256_encode(key,MAC)
 336         RAM = "***"
 337         # base64_RAM = sha256_encode(key,RAM)
 338         ROM = "***"
 339         # base64_ROM = sha256_encode(key,ROM)
 340         CPU = "***"
 341         # base64_CPU = sha256_encode(key,CPU)
 342         GPU = "***"
 343
 344         imsi2="***"
 345
 346         sysVersion = "***"
 347
 348         board = "***"
 349
 350         # base64_sysVersion = sha256_encode(key,sysVersion)
 351         if (len(self.software_version) == 0):#获取失败了
 352             # self.software_version = "Watch Soar V1.0"
 353             self.software_version = "NWO N9 V1.0"
 354
 355         softwareVer = "NWO N9 V1.0"
 356         # base64_softwareVer = sha256_encode(key,softwareVer)
 357         # softwareName ="FD230"
 358         softwareName ="***"
 359
 360         sn="***"
 361
 362         batteryCapacity="***"
 363
 364         phoneNumber="***"
 365         # base64_softwareName = sha256_encode(key,softwareName)
 366         volte="***" #0:开;1:关;-1:不支持
 367         # base64_volte = sha256_encode(key,volte)
 368         netType="***"
 369         # base64_netType = sha256_encode(key,netType)
 370
 371         resolution="466*466"
 372         # base64_resolution = sha256_encode(key,resolution)
 373
 374         screenSize = "1.43"
 375         # base64_screenSize = sha256_encode(key,screenSize)
 376         wearingStatus ="未佩戴"
 377         # base64_wearingStatus = sha256_encode(key,wearingStatus)
 378
 379         networkStatus ="***"#1:连接;0:未连接;-1:不支持
 380
 381         routerMac = "***"
 382
 383         wifiMac = "***"
 384         # base64_networkStatus = sha256_encode(key,networkStatus)
 385         encyr_data = [MAC,RAM,ROM,CPU,sysVersion,softwareVer,softwareName,volte,netType,resolution,screenSize,wearingStatus,networkStatus,routerMac,wifiMac,imsi,GPU,imsi2,board,sn,batteryCapacity,phoneNumber,batteryCapacityCurr]
 386         print(len(encyr_data))
 387         encyr_new_data=[]
 388         for i in range(len(encyr_data)):
 389             tmp_data = self.sha256_encode(key,encyr_data[i])
 390             encyr_new_data.append(tmp_data)
 391
 392         # deviceInfo_tmp = {
 393         #     "bluetoothMac":"{}".format(base64_MAC),#mac地址可填可不填
 394         #     "ram":"{}".format(base64_RAM),#ram信息
 395         #     "rom":"{}".format(base64_ROM),#rom信息
 396         #     "cpu":"{}".format(base64_CPU),#cpu信息
 397         #     "sysVersion":"{}".format(base64_sysVersion),#操作系统版本号
 398         #     "softwareVer":"{}".format(base64_softwareVer),#固件版本号
 399         #     "softwareName":"{}".format(base64_softwareName),#固件名称
 400         #     "volte":"{}".format(base64_volte),#volte开关 默认是开
 401         #     "netType":"{}".format(base64_netType),#当前网络类型4G
 402         #     "resolution":"{}".format(base64_resolution),#屏幕分辨率466*466
 403         #     "screenSize":"{}".format(base64_screenSize),#屏幕尺寸默认1.43
 404         #     "wearingStatus":"{}".format(base64_wearingStatus),#佩戴状态不支持
 405         #     "networkStatus":"{}".format(base64_networkStatus)#网络状态
 406
 407         # }
 408         if configType_data=="keepAlive":
 409             print("keepAlive :")
 410             deviceInfo_tmp = {
 411                 "bluetoothMac":"{}".format(encyr_new_data[0]),#mac地址可填可不填
 412                 "ram":"{}".format(encyr_new_data[1]),#ram信息
 413                 "rom":"{}".format(encyr_new_data[2]),#rom信息
 414                 "cpu":"{}".format(encyr_new_data[3]),#cpu信息
 415                 "sysVersion":"{}".format(encyr_new_data[4]),#操作系统版本号
 416                 "softwareVer":"{}".format(encyr_new_data[5]),#固件版本号
 417                 "softwareName":"{}".format(encyr_new_data[6]),#固件名称
 418                 "volte":"{}".format(encyr_new_data[7]),#volte开关 默认是开
 419                 "netType":"{}".format(encyr_new_data[8]),#当前网络类型4G
 420                 "resolution":"{}".format(encyr_new_data[9]),#屏幕分辨率466*466
 421                 "screenSize":"{}".format(encyr_new_data[10]),#屏幕尺寸默认1.43
 422                 "wearingStatus":"{}".format(encyr_new_data[11]),#佩戴状态不支持
 423                 "networkStatus":"{}".format(encyr_new_data[12]),#网络状态
 424                 "routerMac":"{}".format(encyr_new_data[13]), #路由mac地址 ***
 425                 "mac":"{}".format(encyr_new_data[14]), #wifi mac
 426                 "imsi":"{}".format(encyr_new_data[15]), #imsi
 427                 "gpu":"{}".format(encyr_new_data[16]), #GPU
 428                 "imsi2":"{}".format(encyr_new_data[17]), #imsi2
 429                 "board":"{}".format(encyr_new_data[18]), #board
 430                 "sn":"{}".format(encyr_new_data[19]), #board
 431                 "batteryCapacity":"{}".format(encyr_new_data[20]), #board
 432                 "phoneNumber":"{}".format(encyr_new_data[21]), #board
 433                 "batteryCapacityCurr":"{}".format(encyr_new_data[22]), #board
 434             }
 435         else :
 436              deviceInfo_tmp = {
 437                 "bluetoothMac":"{}".format(encyr_new_data[0]),#mac地址可填可不填
 438                 "ram":"{}".format(encyr_new_data[1]),#ram信息
 439                 "rom":"{}".format(encyr_new_data[2]),#rom信息
 440                 "cpu":"{}".format(encyr_new_data[3]),#cpu信息
 441                 "sysVersion":"{}".format(encyr_new_data[4]),#操作系统版本号
 442                 "softwareVer":"{}".format(encyr_new_data[5]),#固件版本号
 443                 "softwareName":"{}".format(encyr_new_data[6]),#固件名称
 444                 "volte":"{}".format(encyr_new_data[7]),#volte开关 默认是开
 445                 "netType":"{}".format(encyr_new_data[8]),#当前网络类型4G
 446                 "resolution":"{}".format(encyr_new_data[9]),#屏幕分辨率466*466
 447                 "screenSize":"{}".format(encyr_new_data[10]),#屏幕尺寸默认1.43
 448                 "wearingStatus":"{}".format(encyr_new_data[11]),#佩戴状态不支持
 449                 "networkStatus":"{}".format(encyr_new_data[12]),#网络状态
 450                 "routerMac":"{}".format(encyr_new_data[13]), #路由mac地址 ***
 451                 "mac":"{}".format(encyr_new_data[14]), #wifi mac
 452                 "imsi":"{}".format(encyr_new_data[15]), #imsi
 453                 "gpu":"{}".format(encyr_new_data[16]), #GPU
 454                 "imsi2":"{}".format(encyr_new_data[17]), #imsi2
 455                 "board":"{}".format(encyr_new_data[18]), #board
 456                 "sn":"{}".format(encyr_new_data[19]), #board
 457                 "batteryCapacity":"{}".format(encyr_new_data[20]), #board
 458                 "phoneNumber":"{}".format(encyr_new_data[21]), #board
 459
 460             }
 461         json_data = ujson.dumps(deviceInfo_tmp)#需要转义的字符串
 462
 463
 464
 465
 466         send_autoregist = {
 467             "endpoint":config_data,
 468             "deviceInfo":"{}".format(json_data)
 469         }
 470
 471         test_data = ujson.dumps(send_autoregist)#需要转义的字符串
 472         print("test_data:{}".format(test_data))
 473         headers_T ={"Content-Type":"application/json"}
 474         request_result = 0
 475         print("shangbao address:{}\r\n".format(url))
 476         try:
 477             response = request.post(url, data=ujson.dumps(send_autoregist),headers =headers_T)
 478             request_result = 1
 479             result_json = ""
 480             print("response success:response.status_code{}\r\n".format(response.status_code))
 481             if response.status_code == 200:
 482                 dev_autoregist_result = 1
 483                 content = response.content
 484                 c = next(content)
 485                 result_json = ujson.loads(c)#解析成json格式
 486             else:
 487                 dev_autoregist_result = 0
 488
 489
 490             if "rspCode" in result_json:
 491                 rspCode = result_json["rspCode"]
 492                 rspMsg = result_json["rspMsg"]
 493                 print("response success:rspCode{} {}\r\n".format(rspMsg,rspCode))
 494                 if rspCode == "0000" or rspMsg == "成功":
 495                     dev_autoregist_result = 1
 496                 else:
 497                     dev_autoregist_result = 0
 498             else:
 499                 dev_autoregist_result = 0
 500             print("response success:\r\n")
 501             return dev_autoregist_result
 502
 503         except Exception as e:
 504             print("response:{}".format(e))
 505             request_result = 0
 506
 507         if request_result == 0:#请求出错了
 508             dev_autoregist_result = 0
 509             return dev_autoregist_result
 510
 511
 512     def read_config_file(self):#获取配置文件，一开机是没有配置文件的
 513
 514         self.read_config_msg_file()#读文件信息
 515         if self.config_data != {}:
 516             if "retryInterval" in self.config_data:
 517                 self.retryInterval = int(self.config_data["retryInterval"])
 518             if "retryNum" in self.config_data:
 519                 self.retryNum = int(self.config_data["retryNum"])
 520             if "heartBeatTime" in self.config_data:
 521                 self.heartBeatTime = int(self.config_data["heartBeatTime"])
 522             if "reportTime" in self.config_data:
 523                 self.reportTime = int(self.config_data["reportTime"])
 524             if "reportNum" in self.config_data:
 525                 self.reportNum = int(self.config_data["reportNum"])
 526             if "address" in self.config_data:
 527                 self.address = str(self.config_data["address"])
 528
 529             #终端本地需要保存本地的数据
 530             # self.reportTime_Sec = 0 #保存本地 保存时间戳下一次开机使用
 531             # self.report_Num_old = 0#保存本地
 532             # self.retryNum_old = 3#保存本地
 533             if NEED_SAVE_CONFIG_FILE == 1:
 534                 if "reportTime_Sec" in self.config_data:
 535                     self.reportTime_Sec = int(self.config_data["reportTime_Sec"])
 536                 if "report_Num_old" in self.config_data:
 537                     self.report_Num_old = int(self.config_data["report_Num_old"])
 538                 if "retryNum_old" in self.config_data:
 539                     self.retryNum_old = int(self.config_data["retryNum_old"])
 540
 541         print("read_config_file self.config_data:{} ".format(self.config_data))
 542     def retryTimerCb(self,*argc):#异常重试机制定时器回调
 543         #保存本地
 544         self.retryNum_old+=1 #1 self.reportNum = 1
 545         if NEED_SAVE_CONFIG_FILE == 1:
 546             self.config_data["retryNum_old"] = self.retryNum_old
 547             self.write_config_msg_file(self.config_data)
 548         print("retryTimerCb self.retryNum_old:{}\r\n".format(self.retryNum_old))
 549         self.search_report_num_step()
 550         pass
 551     def reportTimerIntervalError(self):
 552         self.retryNum_old = 0#保存
 553         self.report_Num_old = 0#保存 定时清空数据
 554         date_tmp = utime.localtime()
 555         time_tmp = utime.mktime(date_tmp)#获取时间戳
 556         self.reportTime_Sec = time_tmp+self.reportTime*60 #(记录时间+reportTime)标识旧的时间
 557         if NEED_SAVE_CONFIG_FILE == 1:
 558             self.config_data["reportTime_Sec"] = self.reportTime_Sec
 559             self.config_data["retryNum_old"] = self.retryNum_old
 560             self.config_data["report_Num_old"] = self.report_Num_old
 561             self.write_config_msg_file(self.config_data)
 562         self.search_report_num_step()#重新查询
 563         pass
 564     def error_retryNum_step(self):#判读报错次数是否大于self.retryNum 步骤
 565         print("error_retryNum_step:self.retryNum_oldd:{} self.retryNum:{} self.reportTime:{}\r\n".format(self.retryNum_old,self.retryNum,self.reportTime))
 566
 567         if self.retryNum_old >= self.retryNum and self.retryNum_old != 0:#self.retryNum_old > 10#结束HTPP下一个最大频率周期时间间隔流程
 568             print("error_retryNum_step:self.retryNum_old >= self.retryNum\r\n")
 569             self.reportTimerIntervalError()
 570             # self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalError)#重新开始 需要清空数据
 571         else:
 572             get_result = self.first_get_config_json()#发起向服务端请求配置信息下发到设备端
 573             if get_result == 0:#获取失败或者没有网络 走异常重试机制
 574                 self.report_Num_old+=1#请求错误请求失败都要保存上报次数
 575                 if NEED_SAVE_CONFIG_FILE == 1:
 576                     self.config_data["report_Num_old"] = self.report_Num_old
 577                     self.write_config_msg_file(self.config_data)
 578                 print("error_retryNum_step:self.retryTimer.start :{} {} {}\r\n".format(self.retryInterval,self.report_Num_old,self.reportNum))
 579                 self.checkMaxReportNum()#检查上报最大次数
 580                 self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb)
 581                 pass
 582             else:#
 583
 584                 #第一步触发自注册
 585                 if get_result == 2:#请求的配置文件和本地不一致重启
 586                     self.retryNum_old = 0#保存本地 配置文件不同重启模组 清空异常重试的报错次数
 587                     # self.report_Num_old+=1#请求错误请求失败都要保存上报次数
 588                     # if NEED_SAVE_CONFIG_FILE == 1:
 589                     #     self.config_data["report_Num_old"] = self.report_Num_old
 590                     #     self.config_data["retryNum_old"] = self.retryNum_old
 591                     #     self.write_config_msg_file(self.config_data)
 592
 593                     self.china_mobile_init_param()#重新走流程读配置文件->判断上报总数->判断报错次数->获取配置文件
 594                     self.search_report_num_step()
 595                     return
 596
 597                 self.report_Num_old+=1#请求错误请求失败都要保存上报次数
 598                 if NEED_SAVE_CONFIG_FILE == 1:
 599                     self.config_data["report_Num_old"] = self.report_Num_old
 600                     self.write_config_msg_file(self.config_data)
 601                 print("error_retryNum_step self.report_Num_old:{}\r\n".format(self.report_Num_old))
 602                 if self.checkMaxReportNum() == 1:#检查上报最大次数
 603                     self.search_report_num_step()#重新查询
 604                     return
 605                 report_result = self.onself_regist_report_cb()#注册
 606
 607                 #第二步触发心跳上报次数
 608                 if report_result == 1:#注册完成之后根据服务端下发的配置 间隔上报心跳
 609                     self.heartreportTimer.stop()
 610                     self.heartreportTimer.start(self.heartBeatTime*60*1000,1,self.heartreportTimerCb)
 611
 612     def heartreportTimerCb(self,*argc):
 613         self.heart_report_cb()
 614
 615     def retpoertTimerClear(self):
 616         date_tmp = utime.localtime()
 617         time_tmp = utime.mktime(date_tmp)#获取时间戳
 618         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))
 619         self.report_Num_old = 0#清空上报总次数 #保存本地
 620         self.retryNum_old = 0#清空上报错误次数 #保存本地
 621         self.reportTime_Sec = time_tmp+self.reportTime*60#记录当前时间+reportTime的时间用于下次错判断
 622         if NEED_SAVE_CONFIG_FILE == 1:
 623             self.config_data["reportTime_Sec"] = self.reportTime_Sec
 624             self.config_data["retryNum_old"] = self.retryNum_old
 625             self.config_data["report_Num_old"] = self.report_Num_old
 626             self.write_config_msg_file(self.config_data)
 627         self.retpoertTimerC.stop()#关闭定时器
 628         self.error_retryNum_step()#清空报错次数重新走判断报错次数
 629         pass
 630     def check_current_time(self):#检测当前时间是否超过self.reportTime 超过清空报错次数 清空上报总次数
 631         #
 632         date_tmp = utime.localtime()
 633         currentTime = utime.mktime(date_tmp)#获取时间戳
 634         reportTime = self.reportTime_Sec
 635         print("check_current_time:time_tmp - self.reportTime_Sec:{} currentTime:{} self.reportTime*60:{}".format(reportTime, currentTime,self.reportTime*60))
 636         if currentTime >= reportTime:#当前时间是否大于上次记录的时间 currentTime >= reportTime 直接清空 不超过定时清空数据不再上报数据
 637             #在规定时间内上报次数大于8次就要等下一个10分钟 或者1440分了开个定时器
 638             print("currentTime >= reportTime:\r\n")
 639             self.retpoertTimerClear()
 640         else:#否则次数置零，记录一下（当前时间+reportTime）时间
 641             time_count = (reportTime - currentTime)  #self.reportTime_Sec永远比time_tmp大
 642             print("time_count:{}".format(time_count))
 643             print("currentTime < reportTime:\r\n")
 644             self.retpoertTimerC.start(time_count*1000,0,self.retpoertTimerCB)
 645
 646
 647     # 第一次请求的时候，记录一下（当前时间+reportTime）时间与次数，如果次数小于最大次数，直接返回true。
 648     # 如果次数大于最大次数，则判断一下当前时间是否超过上次设置的时间，如果超过了，则表示超过最大次数；否则次数置零，记录一下（当前时间+reportTime）时间。
 649     def retpoertTimerCB(self,*argc):#按照剩余的时间做定时器
 650         date_tmp = utime.localtime()
 651         time_tmp = utime.mktime(date_tmp)#获取时间戳
 652         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))
 653         self.report_Num_old = 0#清空上报总次数 #保存本地
 654         self.retryNum_old = 0#清空上报错误次数 #保存本地
 655         self.reportTime_Sec = time_tmp+self.reportTime*60#记录当前时间+reportTime的时间用于下次错判断
 656         if NEED_SAVE_CONFIG_FILE == 1:
 657             self.config_data["reportTime_Sec"] = self.reportTime_Sec
 658             self.config_data["retryNum_old"] = self.retryNum_old
 659             self.config_data["report_Num_old"] = self.report_Num_old
 660             self.write_config_msg_file(self.config_data)
 661         self.error_retryNum_step()#清空报错次数重新走判断报错次数
 662
 663
 664     def search_report_num_step(self):#查询上报总数步骤
 665         print("search_report_num_step:self.retryInterval:{} self.retryNum:{}".format(self.report_Num_old,self.reportNum))
 666         if self.report_Num_old >= self.reportNum and self.report_Num_old != 0:#查询上报的总次数是否大于存储上报总次数
 667             self.check_current_time()#检测当前时间是否超过self.reportTime 超过清空报错次数 清空上报总次数
 668         else:#
 669             date_tmp = utime.localtime()
 670             time_tmp = utime.mktime(date_tmp)#获取时间戳
 671             self.reportTime_Sec = time_tmp+self.reportTime*60 #(记录时间+reportTime)标识旧的时间
 672             if NEED_SAVE_CONFIG_FILE == 1:
 673                 self.config_data["reportTime_Sec"] = self.reportTime_Sec
 674                 self.write_config_msg_file(self.config_data)
 675             self.error_retryNum_step()#查询上报错误次数
 676
 677     def search_report_num_step_init(self):#查询上报总数步骤
 678         print("search_report_num_step:self.retryInterval:{} self.retryNum:{} self.reportTime_Sec:{}\r\n".format(self.report_Num_old,self.reportNum,self.reportTime_Sec))
 679         if self.report_Num_old >= self.reportNum and self.report_Num_old != 0:#查询上报的总次数是否大于存储上报总次数
 680             self.check_current_time()#检测当前时间是否超过self.reportTime 超过清空报错次数 清空上报总次数
 681         else:#
 682             date_tmp = utime.localtime()
 683             time_tmp = utime.mktime(date_tmp)#获取时间戳
 684             if self.reportTime_Sec == 0:
 685                 self.reportTime_Sec = time_tmp+self.reportTime*60 #(记录时间+reportTime)标识旧的时间
 686                 if NEED_SAVE_CONFIG_FILE == 1:
 687                     self.config_data["reportTime_Sec"] = self.reportTime_Sec
 688                     self.write_config_msg_file(self.config_data)
 689             self.error_retryNum_step()#查询上报错误次数
 690
 691
 692     def reportTimerIntervalCb(self,*argc):#最大上报频率时间间隔定时器 要清空数据
 693         print("reportTimerIntervalCb\r\n")
 694         self.search_report_num_step()#重新查询
 695
 696     def onself_regist_report_cb(self):#自注册上报信息
 697         date_tmp = utime.localtime()
 698         time_tmp = utime.mktime(date_tmp)#获取时间戳
 699         print("onself_regist_report_cb:self.report_Num_old:{} self.reportNum:{} self.reportTime_Sec:{}\r\n".format(self.report_Num_old,self.reportNum,self.reportTime_Sec))
 700         self.report_Num_old+=1 ##保存本地
 701         if NEED_SAVE_CONFIG_FILE == 1:
 702             self.config_data["report_Num_old"] = self.report_Num_old
 703             self.write_config_msg_file(self.config_data)
 704         #设备自注册上报信息
 705         print("onself_regist_report_cb:self.china_mobile_autoregist_infor")
 706         url = "https://{}//dm-multi-accept/multi/acceptMultiTerminalRegInfo".format(self.address)#上报地址
 707         confing_type = "autoRegist"#上报传输配置
 708         result = self.china_mobile_autoregist_infor(url,confing_type)
 709
 710
 711         if result != 1:
 712             #触发异常重试进制
 713             self.checkMaxReportNum()#检查上报最大次数
 714             if self.checkMaxRetryNum() == 1:
 715                 print("retryTimerCb timer22")#异常重试过多重新间隔reportTime注册流程 关闭所有的定时器
 716                 self.search_report_num_step()#重新查询
 717                 return 0
 718             self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb)
 719             return 0
 720         else:
 721             if self.checkMaxReportNum() == 1:
 722                 self.search_report_num_step()#重新查询
 723                 # self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalCb)
 724                 return 0
 725             else:
 726                 return 1
 727     def checkMaxReportNum(self):#检查上报次数最大值
 728         print("checkMaxReportNum :self.reportNum :{} self.report_Num_old:{}\r\n".format(self.reportNum,self.report_Num_old))
 729         if self.report_Num_old >= self.reportNum and self.report_Num_old != 0:
 730             self.retryTimer.stop()#关定时器
 731             self.retpoertTimerC.stop()
 732             self.heartreportTimer.stop()
 733             return 1
 734         else:
 735             return 0
 736
 737     def checkMaxRetryNum(self):#检查上报错误次数
 738         print("checkMaxRetryNum :self.retryNum:{} self.retryNum_old:{}\r\n".format(self.retryNum_old,self.retryNum))
 739         if self.retryNum_old >= self.retryNum and self.retryNum_old != 0:#异常重试过多重新间隔reportTime注册流程
 740             self.retryTimer.stop()#关定时器
 741             self.retpoertTimerC.stop()
 742             self.heartreportTimer.stop()#关闭心跳定时器
 743             return 1
 744         else:
 745             return 0
 746
 747     def heart_report_cb(self):#心跳上报信息
 748
 749         date_tmp = utime.localtime()
 750         time_tmp = utime.mktime(date_tmp)#获取时间戳
 751         self.report_Num_old+=1#保存本地
 752         if NEED_SAVE_CONFIG_FILE == 1:
 753             self.config_data["report_Num_old"] = self.report_Num_old
 754             self.write_config_msg_file(self.config_data)
 755         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))
 756
 757         url = "https://{}//dm-multi-accept/multi/acceptMultiTerminalHeartbeatInfo".format(self.address)#上报地址
 758         confing_type = "keepAlive"#上报传输配置
 759         print("heart_report_cb:self.china_mobile_autoregist_infor")
 760         result = self.china_mobile_autoregist_infor(url,confing_type)
 761         if result != 1:
 762             #触发异常重试进制
 763             self.checkMaxReportNum()
 764             if self.checkMaxRetryNum() == 1:#异常重试过多重新间隔reportTime注册流程
 765                 self.search_report_num_step()#重新查询
 766                 return
 767             self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb)
 768             return
 769         if self.checkMaxReportNum() == 1:#上报次数大于8次
 770             self.search_report_num_step()#重新查询
 771             return
 772
 773     def china_mobile_init_param(self):#初始化
 774
 775         status = eventMesh.publish("get_factory_status")
 776         if status == None:
 777             status = 0
 778         print("get_factory_status:{}\r\n".format(status))
 779         if status == 0:#恢复出厂或者新的机器需要清空不必要的数据
 780             if self.init_flag == 0:#只初始化一次
 781                 IFEXIST = ql_fs.path_exists("/usr/telecom_config.json")   #不存在
 782                 if IFEXIST == True:
 783                     uos.remove("/usr/telecom_config.json")
 784                 isStorage = ql_fs.path_exists("/usr/china_mobie_config.json")#移动入库的配置文件移除
 785                 if isStorage == True:
 786                     uos.remove("/usr/china_mobie_config.json")
 787                 #先清空再写入默认参数
 788                 self.init_flag = 1
 789                 self.retryInterval = 10
 790                 self.retryNum = 1#异常重试最大次数
 791                 self.heartBeatTime = 1440#心跳上报频率 单位分钟
 792                 self.reportTime = 1440#最大上报频率 自注册+心跳上报的频率次数不能大于最大上报频率次数
 793                 self.reportNum = 8 #最大上报次数
 794
 795                 self.reportTime_Sec = 0 #保存本地 保存时间戳下一次开机使用
 796                 self.report_Num_old = 0#保存本地
 797                 self.retryNum_old = 0#保存本地
 798                 get_address = eventMesh.publish("get_dmp_cm_address")
 799                 if get_address == None:#获取出来地址是空的使用适配地址
 800                     self.address = "a.fxltsbl.com"#默认
 801                 else: #恢复出厂使用BLE传送过来的地址
 802                     self.address = str(eventMesh.publish("get_dmp_cm_address"))
 803
 804                 self.config_data["retryInterval"] = self.retryInterval
 805                 self.config_data["retryNum"] = self.retryNum
 806                 self.config_data["heartBeatTime"] = self.heartBeatTime
 807                 self.config_data["reportTime"] = self.reportTime
 808                 self.config_data["reportNum"] = self.reportNum
 809                 # self.config_data["address"] = self.address
 810                 if NEED_SAVE_CONFIG_FILE == 1:
 811                     self.config_data["reportTime_Sec"] = self.reportTime_Sec
 812                     self.config_data["report_Num_old"] = self.report_Num_old
 813                     self.config_data["retryNum_old"] = self.retryNum_old
 814
 815                 self.write_config_msg_file(self.config_data)
 816         #读配置文件
 817         self.read_config_file()#只读一下配置文件
 818
 819         self.retryTimer.stop()#关定时器
 820         self.retpoertTimerC.stop()
 821         self.heartreportTimer.stop()
 822     def china_mobile_init(self):
 823         self.china_mobile_init_param()
 824         #查询上报总数流程
 825         self.search_report_num_step_init()
 826
 827
 828
 829
 830 chinamobileCb = chinamobile()
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842