from usr.EventMesh import eventMesh
-from usr.telecom_dmp import telecomDmpCb
-from usr.china_mobile_dmp import chinamobileCb
+# from usr.telecom_dmp import telecomDmpCb
+# from usr.china_mobile_dmp import chinamobileCb
+
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+clog = log.getLogger("cat1")
def msg_cb(args):
index = args[1]
CAT1_SERVICE_HEAD = 'FE' #固定head
PROJECT_NAME = "Cat1SlipUDPService"
-PROJECT_VERSION = "PY_SRV_V16"
+PROJECT_VERSION = "PY_SRV_V17"
CONFIG_JSON="/usr/system_config.json"
CURRENT_APP_TYPE="pysrv"
-
-# 设置日志输出级别
-log.basicConfig(level=log.INFO)
-cat1service_log = log.getLogger("cat1service")
-
#设置通话音量
voiceCall.setVolume(10)
-print("voice call volume {}".format(voiceCall.getVolume()))
-# lpm_fd = pm.create_wakelock("system_lock", len("system_lock"))
-pm.autosleep(1)
-# pm.wakelock_lock(lpm_fd)
-cat1service_log.info("create_wakelock {}".format(pm.get_wakelock_num()))
+clog.info("voice call volume {}".format(voiceCall.getVolume()))
+lpm_fd = pm.create_wakelock("system_lock", len("system_lock"))
+# pm.autosleep(1)
+pm.wakelock_lock(lpm_fd)
+clog.info("create_wakelock {}".format(pm.get_wakelock_num()))
telecomTimerCount = 0
def get_versionkeyname_by_py(app_type):
return str("{}version".format(app_type))
ql_fs.touch(CONFIG_JSON,data)
def set_version_to_json_config(app_type,keyvalue):
- config_data = ql_fs.read_json(CONFIG_JSON)
- config_data.update( {str(get_versionkeyname_by_py(app_type)):keyvalue})
- ql_fs.touch(CONFIG_JSON, config_data)
- cat1service_log.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
- cat1service_log.info("{}".format(config_data))
+ try :
+ config_data = ql_fs.read_json(CONFIG_JSON)
+ config_data.update( {str(get_versionkeyname_by_py(app_type)):keyvalue})
+ ql_fs.touch(CONFIG_JSON, config_data)
+ clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+ clog.info("{}".format(config_data))
+ except Exception as e:
+ clog.error("set_version_to_json_config")
def get_version_from_json_config(app_type):
config_data = ql_fs.read_json(CONFIG_JSON)
keyvalue = config_data.get( get_versionkeyname_by_py(app_type),get_default_versionvalue_by_py(app_type))
- cat1service_log.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+ clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
return keyvalue
set_version_to_json_config(CURRENT_APP_TYPE,PROJECT_VERSION)
# level - 引脚电平，int类型，0 - 设置引脚为低电平, 1- 设置引脚为高电平。
# recvDataPin = Pin(Pin.GPIO22, Pin.IN, Pin.PULL_PU, 0)
def ExtIntfun(args):
- # cat1service_log.info('### interrupt {} ###'.format(args)) # args[0]:gpio号 args[1]:上升沿或下降沿
+ # clog.info('### interrupt {} ###'.format(args)) # args[0]:gpio号 args[1]:上升沿或下降沿
if args[1] == 0:
- cat1service_log.info("disable autosleep")
- pm.autosleep(0)
- # pm.wakelock_lock(lpm_fd)
+ clog.info("disable autosleep")
+ # pm.autosleep(0)
+ pm.wakelock_lock(lpm_fd)
elif args[1] == 1:
- cat1service_log.info("enable autosleep")
- # pm.wakelock_unlock(lpm_fd)
- pm.autosleep(1)
- # cat1service_log.info("recvDataPin={}".format(recvDataPin.read()))
+ clog.info("enable autosleep")
+ pm.wakelock_unlock(lpm_fd)
+ # pm.autosleep(1)
+ # clog.info("recvDataPin={}".format(recvDataPin.read()))
extint = ExtInt(ExtInt.GPIO22, ExtInt.IRQ_RISING_FALLING, ExtInt.PULL_DISABLE, ExtIntfun)
extint.enable()
UDP_MSG_REPLY = 'F' # 返回值
-
-def result(args):
- print('download status:',args[0],'download process:',args[1])
-def download_fota_img( srcurl ):
- fota_obj = fota() # 创建Fota对象
- cat1service_log.info("httpDownload... {} , {}".format("{}/dfota_1.bin".format(srcurl),"{}/dfota_2.bin".format(srcurl)))
- res = fota_obj.httpDownload(url1="{}/dfota_1.bin".format(srcurl),url2="{}/dfota_2.bin".format(srcurl),callback=result)
- #差分升级FTP方式
- #res = fota_obj.httpDownload(url1="ftp://user:password@ip:port/fota.bin",callback=result) #其中user,password,ip,port需要填写具体使用的FTP服务器信息
- if res != 0:
- cat1service_log.error("httpDownload error")
-
-def check_fota():
- modem_ver = modem.getDevFwVersion()
- imei = modem.getDevImei()
- url = "http://icfota.snicker.com.cn:8089/fd230ota.jsp?product=FD230&pkgver={0}&imei={1}".format(modem_ver,imei)
- response = request.get(url)
- cat1service_log.info(url)
- data = response.json()
- if(data['UptoDate'] == False):
- cat1service_log.info("Need update python application")
- srcurl = data['url']
- #差分升级方式
- # res = fota_obj.httpDownload(url1="http://www.example.com/fota.bin",callback=result)
- # mini fota方式
- return srcurl
- else:
- cat1service_log.info("No need update python application")
- return ""
-
class Cat1Service:
AP = 0 # SLIP_INNER
STA = 1 # SLIP_OUTER
# self.__value = None
self.__wait_resp = 0
self.__waiting_netstat = 0
- # slip.destroy()
- # print('slip uart={0}'.format (self.__uart))
-
- # ret = slip.construct(self.__uart, self.__mode, 0)
- # if ret != 0:
- # print('slip netif construct fail')
- # return None
- print('slip network card create success')
+ slip.destroy()
+ clog.info('slip uart={0}'.format (self.__uart))
+
+ ret = slip.construct(self.__uart, self.__mode, 0)
+ if ret != 0:
+ clog.error('slip netif construct fail')
+ return None
+ clog.info('slip network card create success')
# self.__queue = Queue(1)
self.__sock = self.__socket_init()
self.__threadid = _thread.start_new_thread(self.__Socket_Thread, ())
self.send_data_q = Queue(100)
self.ack_sem=0
_thread.start_new_thread(self.Socket_SEND_Thread,())
-
- # 发数据线程
-
-
-
+ # 发数据线程
return None
def __socket_init(self):
# 绑定IP
bind_addr = ('172.16.1.2', 5000)
sock.bind(bind_addr)
- sock.settimeout(10)
+ sock.settimeout(None)
return sock
def __socket_reinit(self):
# cell_data = hex(cmd_tmp)
# decimal_number = int(cell_data, 16)
# cmd = "%02x"%(decimal_number) # 使用两位表示，不足前面补0
- print(cmd) # 输出: 07
- print("btmcu_cmd_handler cmd {0} , args {1}".format(cmd,parm))
+ clog.info(cmd) # 输出: 07
+ clog.info("btmcu_cmd_handler cmd {0} , args {1}".format(cmd,parm))
if cmd == "00":
- print(cmd)
+ clog.info(cmd)
# UDP_CMD_GET_CAT1VER
modem_ver = modem.getDevFwVersion()
self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
ret = voiceCall.callStart(str(parm))
# if ret != 0:
# ret = voiceCall.callStart(str(parm))
- print("ret={} {} {}".format(ret,cmd,parm))
+ clog.info("ret={} {} {}".format(ret,cmd,parm))
if ret != 0:
self.reply_cmd('0F',"callcmd_fail")
else:
else:
self.reply_cmd('0F',"callcmd_fail")
elif cmd == "02":
- print(cmd)
+ clog.info(cmd)
# UDP_CMD_HUNGUP
ret = voiceCall.callEnd()
if ret != 0:
else:
self.reply_cmd('0F',"callend_success")
elif cmd == "03":
- print(cmd)
+ clog.info(cmd)
# UDP_CMD_ANSWER
ret = voiceCall.callAnswer()
if ret != 0:
else:
self.reply_cmd('0F',"callanswer_success")
elif cmd == "04":
- print(cmd)
- result = check_fota()
- if result == "":
- self.reply_cmd('04',"no need update!")
- else:
- self.reply_cmd('04',"start ota {} please wait...".format(result))
- download_fota_img(result)
+ clog.info(cmd)
elif cmd == "05":
- print(cmd)
+ clog.info(cmd)
# UDP_CMD_SEND_SMS
elif cmd == "06":
- print(cmd)
+ clog.info(cmd)
# UDP_CMD_GET_TIME
time=utime.localtime()
zone=utime.getTimeZone()
#(2024, 3, 2, 18, 31, 32, 5, 62),8
# 返回当前时间戳，参数为元组
# timestamp = utime.mktime(time)
- # cat1service_log.info(timestamp)
+ # clog.info(timestamp)
self.reply_cmd('06',"{0}@{1}".format(time,zone))
elif cmd == "07":
- print("cmd ==== 07!")
+ clog.info("cmd ==== 07!")
# UDP_CMD_GET_RECV_NETWORKSTAT
simstat = sim.getStatus()
imei = modem.getDevImei()
# ([voice_state, voice_lac, voice_cid, voice_rat, voice_reject_cause, voice_psc], [data_state, data_lac, data_cid, data_rat, data_reject_cause, data_psc])
operator = net.operatorName()
signal = net.csqQueryPoll()
- print("imei:{0},sim:{1},oper:{2},signal:{3},net:{4}".format(imei,simstat,operator,signal,netstat))
+ clog.info("imei:{0},sim:{1},oper:{2},signal:{3},net:{4}".format(imei,simstat,operator,signal,netstat))
self.reply_cmd('07',"imei:{0}@sim:{1}@oper:{2}@signal:{3}@net:{4}".format(imei,simstat,operator,signal,netstat))
elif cmd == "09":
- print("{},{}".format(cmd,parm))
+ clog.info("{},{}".format(cmd,parm))
# UDP_CMD_ATCMD
# net.setModemFun(0)
# net.setModemFun(1)
resp=bytearray(50)
ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10)
if ret == 0:
- print("reply:{},ret:{}".format(resp.decode(),ret))
+ clog.info("reply:{},ret:{}".format(resp.decode(),ret))
self.reply_cmd('09',"{}".format(resp.decode()))
else:
- print("cmd error ret:{}".format(ret))
+ clog.info("cmd error ret:{}".format(ret))
self.reply_cmd('09',"{}".format("at error"))
elif cmd == "10" or cmd == "12" or cmd == "14": #获取固件版本号或者获取BT保存的SIM卡的ICCID BLE那边是否开启电信入库功能
pass
elif cmd == "13":
on = int(parm)
- print("set_dmp_change_mode on:{}".format(on))
+ clog.info("set_dmp_change_mode on:{}".format(on))
eventMesh.publish("set_dmp_change_mode",on)
elif cmd == "16":
if cmd == "10":
self.software_version = str(parm)
eventMesh.publish("set_dev_version",self.software_version)
- print("software_version:{},{}".format(self.software_version,parm))
+ clog.info("software_version:{},{}".format(self.software_version,parm))
elif cmd == "12":
pass
elif cmd == "14":#
if cmd == "10":
self.software_version = str(parm)
eventMesh.publish("set_dev_version",self.software_version)
- print("software_version:{},{}".format(self.software_version,parm))
+ clog.info("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))
+ clog.info("parm:{}\r\n".format(parm))
pass
def get_factory_status(self,event,msg):
def delete_sms_cb(self,*argc):
eventMesh.publish_async("remove_all_sms_cb","",1*1024)
def remove_all_sms_cb(self, event, msg):
- print("remove_all_sms_cb\r\n")
+ clog.info("remove_all_sms_cb\r\n")
msg_nums = sms.getMsgNums() #短信数量
if msg_nums == -1:
msg_nums = 0
sms_data = sms.getSaveLoc()
- print("{}\r\n".format(sms_data))
+ clog.info("{}\r\n".format(sms_data))
if sms_data == -1:
return
sms_max = sms_data[0][2] #最大存储短信数量
if sms_data == -1:
return
sms_max = sms_data[0][2] #最大存储短信数量
- print("recv:{}".format(int(msg)))
+ clog.info("recv:{}".format(int(msg)))
message=self.sms_get_message_info(int(msg))
if message == -1: #说明没有这条短信
return
SMS_lis={}
SMS_lis_count = 0
sms_data = sms.getSaveLoc()
- print(sms_data)
+ clog.info(sms_data)
if sms_data == -1:
return
sms_max = sms_data[0][2]#最大存储短信数量
- print(sms_max)
+ clog.info(sms_max)
self.msg_nums = sms.getMsgNums()
if self.msg_nums_old != self.msg_nums:
self.send_data = []
count = len(self.send_data)
for i in range(count):
text = self.send_data[i]
- print("text:{} {} {}\r\n".format(text[0],text[1],text[2]))
+ clog.info("text:{} {} {}\r\n".format(text[0],text[1],text[2]))
msg_total = "@code:"+str(text[0])+"@totalcodenum:"+str(text[1])+"@currcodeid:"+str(text[2])+"@data:"+str(text[3])
self.reply_cmd('17',msg_total)
return 0
self.__waiting_netstat = 1
stage, state = checkNet.waitNetworkReady(30)
- # pm.wakelock_unlock(lpm_fd)
+ pm.wakelock_unlock(lpm_fd)
if stage == 3 and state == 1:
- print('Network connection successful.')
+ clog.info('Network connection successful.')
self.set_network_config()
self.__net_connected = 1
eventMesh.publish("set_network_state",self.__net_connected)
self.__waiting_netstat = 0
return 0
else:
- print('Network connection failed, stage={}, state={}'.format(stage, state))
+ clog.info('Network connection failed, stage={}, state={}'.format(stage, state))
self.reset_network_config()
self.__net_connected = 0
eventMesh.publish("set_network_state",self.__net_connected)
def reply_cmd(self,cmd,_timesync):
try :
- print('reply_cmd 1')
+ clog.info('reply_cmd 1')
self.clear_remain()
message = str(_timesync)
- print('reply_cmd 2')
+ clog.info('reply_cmd 2')
self.__Socket_UDP_noreply(cmd, message)
except:
- print('reply_cmd')
+ clog.info('reply_cmd')
return 0
def clear_remain(self):
def reset_network_config(self):
if (self.__net_connected == 0):
- print("skip reset_network_config")
+ clog.info("skip reset_network_config")
return 0
Info = dataCall.getInfo(1,0)
- print("Info{}".format(Info))
+ clog.info("Info{}".format(Info))
default_NIC_ip = Info[2][2] # 假设默认网卡ip地址为10.10.1.1，请根据实际情况更改
segment_ip = '172.16.4.0' # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255]，请根据实际情况更改
mask = '255.255.255.0' # 假设子网掩码为255.255.255.0，请根据实际情况更改
# 配置默认网卡，通过默认网卡进行网络转发
cat1service.set_default_NIC(default_NIC_ip)
- print("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
+ clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
#添加路由规则，只有该网段IP才进行转发
cat1service.router_add(segment_ip, mask)
if (self.__net_connected == 1) :
- print("skip set_network_config")
+ clog.info("skip set_network_config")
return 0
Info = dataCall.getInfo(1,0)
- print("Info{}".format(Info))
+ clog.info("Info{}".format(Info))
default_NIC_ip = Info[2][2] # 假设默认网卡ip地址为10.10.1.1，请根据实际情况更改
segment_ip = '172.16.1.0' # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255]，请根据实际情况更改
mask = '255.255.255.0' # 假设子网掩码为255.255.255.0，请根据实际情况更改
# 配置默认网卡，通过默认网卡进行网络转发
cat1service.set_default_NIC(default_NIC_ip)
- print("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
+ clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
#添加路由规则，只有该网段IP才进行转发
cat1service.router_add(segment_ip, mask)
if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#电信入库功能 不使用设置 0 防止两边不同步修改
if eventMesh.publish("get_dmp_change_mode") == 1:
eventMesh.publish("set_network_state",1)
- telecomDmpCb.telecom_dmp_power_on_init()
+ # telecomDmpCb.telecom_dmp_power_on_init()
if 1: #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()
+ # chinamobileCb.china_mobile_init()
def cat1_reply_iccid_to_ble(self,event,msg):
ICCID_DATA = str("ICCID:")+str(msg)
# self.head = head
# self.content = content
if len(content) == 0 or len(content) > 9999 or len(head) != 2:
- print('illegal pack tlv content')
+ clog.error('illegal pack tlv content')
return -1
len_str ='%04d' % len(content)
tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content
return tlv_pack
# 解码tlv数据包
def __unpack_tlv_format(self, msg):
- print('__unpack_tlv_format {}\r\n'.format(msg))
+ clog.info('__unpack_tlv_format {}\r\n'.format(msg))
self.msg = str(msg)[2:]#这是去除head FE
tag = self.msg[0:2]
length = self.msg[2:6]
value = self.msg[6:]
len_str ='%04d' % len(value)
if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != self.msg[2:6]:
- print('__unpack_tlv_format err')
+ clog.error('__unpack_tlv_format err')
return -1
- print('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
+ clog.info('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
unpack = (tag,length,value)
return unpack
# socket通信(UDP)模块
def Socket_SEND_Thread(self):
while True:
try:
- print("send====")
+ clog.info("send====")
data=self.send_data_q.get()
self.ack_sem=1
# # if data[2]:
self.__Socket_UDP_write( data[0], data[1])
- print("Socket_SEND_Thread data:{} {}".format(data[0],data[1]))
+ clog.info("Socket_SEND_Thread data:{} {}".format(data[0],data[1]))
count=20
while count & self.ack_sem :
# else :
self.__Socket_UDP_write( data[0], data[1])
- print("Socket_SEND_Thread while data:{} {}".format(data[0],data[1]))
+ clog.info("Socket_SEND_Thread while data:{} {}".format(data[0],data[1]))
if data:
- print("data ok!!")
+ clog.info("data ok!!")
else:
- print("data error!!")
+ clog.error("data error!!")
except Exception :
- print("sned Socket >>>")
+ clog.error("sned Socket >>>")
def __Socket_UDP_write(self, head, content):
try:
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
- print("__Socket_UDP send msg {}".format(msg))
+ clog.info("__Socket_UDP send msg {}".format(msg))
self.__err = 0
self.__sock.sendto(msg,server_addr)
- print("__Socket_UDP send 2")
+ clog.info("__Socket_UDP send 2")
self.__wait_resp = 1
# data = self.__queue.get()
self.__wait_resp = 0
# return data
return 1
except Exception as error:
- print(error)
+ clog.error(error)
return 0
def __Socket_UDP_noreply(self, head, content):
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
- print("__Socket_UDP_noreply send msg {}".format(msg))
+ clog.info("__Socket_UDP_noreply send msg {}".format(msg))
self.__err = 0
data_size = self.__sock.sendto(msg,server_addr)
- print("self.__sock data_size {}".format(data_size))
+ clog.info("self.__sock data_size {}".format(data_size))
self.__wait_resp = 0
return 0
def __Socket_Thread(self):
while True:
try:
- print("recv====")
+ clog.info("recv====")
data=self.__sock.recv(1024)
- print("data:{}".format(data))
+ clog.info("data:{}".format(data))
if data:
value = self.__unpack_tlv_format(data.decode())
if value != -1:
- print('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2]))
+ clog.info('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2]))
if value[1] == 'FF':
self.btmcu_cmd_handler(value[0],value[2])
else:
# self.__value = value
# self.__queue.put('1')
self.btmcu_cmd_handler(value[0],value[2])
- print("End else Thread")
+ clog.info("End else Thread")
else:
- print("data error!!")
+ clog.error("data error!!")
except Exception as recverr:
- print("recverr:{}\r\n".format(recverr))
+ clog.error("recverr:{}\r\n".format(recverr))
if "110" in str(recverr):
self.__err = 1
# if self.__wait_resp == 1:
- print("End Socket Thread")
+ clog.info("End Socket Thread")
# UDP_CMD_GET_TIME = '6', // 获取Cat1 时间 ，YYYYMMDD HHmmss zone
# UDP_CMD_GET_NETWORKSTAT = '7', //获取Cat1 信号信息，VOLTE信息，信号强度，SIM卡状态
# 下文进行系统配置
-print("Cat1Service start")
+clog.info("Cat1Service start")
cat1service = Cat1Service()
#voice call callback function
def voice_callback(args):
if args[0] == 10:
- print('voicecall incoming call, PhoneNO: ', args[6])
+ clog.info('voicecall incoming call, PhoneNO: ', args[6])
if eventMesh.publish("get_volte_switch") == 0: #关闭VOLTE功能
- print('voicecall auto end:')
+ clog.info('voicecall auto end:')
voiceCall.callEnd()
else:
# gpioWakeBT.write(1)
cat1service.notifyIncomingcall(args[6])
elif args[0] == 11:
if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
- print('voicecall connected, PhoneNO: ', args[6])
+ clog.info('voicecall connected, PhoneNO: \n'.format(args[6]))
cat1service.notifyConnecteCall(args[6])
elif args[0] == 12:
- print('voicecall disconnect')
+ clog.info('voicecall disconnect')
if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
- print('voicecall disconnected, PhoneNO: ', args[6])
+ clog.info('voicecall disconnected, PhoneNO: \n'.format(args[6]))
cat1service.notifyDisconnectCall(args[6])
elif args[0] == 13:
- print('voicecall is waiting, PhoneNO: ', args[6])
+ clog.info('voicecall is waiting, PhoneNO: \n'.format(args[6]))
elif args[0] == 14:
- print('voicecall dialing, PhoneNO: ', args[6])
+ clog.info('voicecall dialing, PhoneNO: \n'.format(args[6]))
elif args[0] == 15:
- print('voicecall alerting, PhoneNO: ', args[6])
+ clog.info('voicecall alerting, PhoneNO: \n'.format(args[6]))
elif args[0] == 16:
- print('voicecall holding, PhoneNO: ', args[6])
+ clog.info('voicecall holding, PhoneNO: \n'.format(args[6]))
else:
- print('voice_callback , args[0]: ', args[0])
+ clog.info('voice_callback , args[0]: \n'.format(args[6]))
#电话消息反馈
voiceCall.setCallback(voice_callback)
def checknet_cb(arg):
- print("start checktime!!")
- if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次
- if eventMesh.publish("get_dmp_change_mode") == 1:
- telecomDmpCb.telecom_dmp_power_on_count()
+ clog.info("start checktime!!")
+ # if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次
+ # if eventMesh.publish("get_dmp_change_mode") == 1:
+ # telecomDmpCb.telecom_dmp_power_on_count()
_thread.start_new_thread(cat1service.wait_network_ready, ())
# time=utime.localtime()
delaybootupmsg_timer.start(1000,0,bootupmsg_cb)
# def checkpin_cb(arg):
-# cat1service_log.info("recvDataPin={}".format(recvDataPin.read()))
+# clog.info("recvDataPin={}".format(recvDataPin.read()))
# timerCheckRevPin = osTimer()
# timerCheckRevPin.start(1000,1,checkpin_cb)
-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
-NEED_SAVE_CONFIG_FILE = 0 #是否需要保存上报次数 异常重试次数 时间戳到配置文件 0不保存 1保存
-#中国移动入库
-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
- self.regist_timeSec = 0
- self.iccid_data = ""
- self.software_version = ""
- self.mac_data =""
- self.address = "a.fxltsbl.com"
-
- self.new_address = "a.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()#心跳上报定时器
-
- 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)#订阅消息
-
- eventMesh.subscribe("set_dmp_cm_address",self.set_dmp_cm_address)#订阅消息
- eventMesh.subscribe("get_dmp_cm_address",self.get_dmp_cm_address)#订阅消息
-
- pass
-
- def set_dmp_cm_address(self,event,msg):#设置网络是否正常
- self.address = str(msg)
- self.new_address = str(msg)
-
- def get_dmp_cm_address(self,event,msg):#获取网络是否正常
- return self.address
-
- 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)))
- request_result = 0
- result_json = ""
- try:
- response = request.post(url, data=ujson.dumps(config_data),headers =headers_T)
- request_result = 1
- if response.status_code == 200:#服务器响应成功并返回数据
- content = response.content
- c = next(content)
- result_json = ujson.loads(c)
- print("response.json:{}".format(ujson.loads(c)))
- except Exception as e:
- print("response:{}".format(e))
- request_result = 0
-
-
- if request_result == 0: #请求出错了
- return ""
-
-
- 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)
- if result_json == "":
- return 0
- # {
- # "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
- new_address = self.address
- print("get_config_json old:{} {} {} {} {} {}\r\n".format(reportTime,heartBeatTime,reportNum,retryInterval,retryNum,new_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")
-
- 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 != new_address):
- #重新走注册流程 清空报错次数 记录当前时间戳
- print("new config not old config!!!\r\n")#拉取的配置文件和保存本地的不一致
- 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 new_address != self.address : #服务器下发和本地不一致需要用服务器下发的最新的IP 并把这个IP发送到BLE保存
- eventMesh.publish("send_dmp_cm_address_toBLE",str(self.address))
-
- 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 = "32MB"
- # 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 ="-1"
- # base64_wearingStatus = sha256_encode(key,wearingStatus)
-
- networkStatus ="1"#1:连接;0:未连接;-1:不支持
-
- routerMac = "***"
-
- wifiMac = "***"
- # base64_networkStatus = sha256_encode(key,networkStatus)
- encyr_data = [MAC,RAM,ROM,CPU,sysVersion,softwareVer,softwareName,volte,netType,resolution,screenSize,wearingStatus,networkStatus,routerMac,wifiMac]
- 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]),#网络状态
- "routerMac":"{}".format(encyr_new_data[13]), #路由mac地址 ***
- "mac":"{}".format(encyr_new_data[14]) #wifi mac
- }
- 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"}
- request_result = 0
- print("shangbao address:{}\r\n".format(url))
- try:
- response = request.post(url, data=ujson.dumps(send_autoregist),headers =headers_T)
- request_result = 1
- result_json = ""
- print("response success:response.status_code{}\r\n".format(response.status_code))
- 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"]
- print("response success:rspCode{} {}\r\n".format(rspMsg,rspCode))
- if rspCode == "0000" or rspMsg == "成功":
- dev_autoregist_result = 1
- else:
- dev_autoregist_result = 0
- else:
- dev_autoregist_result = 0
- print("response success:\r\n")
- return dev_autoregist_result
-
- except Exception as e:
- print("response:{}".format(e))
- request_result = 0
-
- if request_result == 0:#请求出错了
- 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 NEED_SAVE_CONFIG_FILE == 1:
- 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
- if NEED_SAVE_CONFIG_FILE == 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 reportTimerIntervalError(self):
- 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)标识旧的时间
- if NEED_SAVE_CONFIG_FILE == 1:
- 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()#重新查询
- 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.reportTimerIntervalError()
- # self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalError)#重新开始 需要清空数据
- else:
- get_result = self.first_get_config_json()#发起向服务端请求配置信息下发到设备端
- if get_result == 0:#获取失败或者没有网络 走异常重试机制
- self.report_Num_old+=1#请求错误请求失败都要保存上报次数
- if NEED_SAVE_CONFIG_FILE == 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.retryInterval,self.report_Num_old,self.reportNum))
- self.checkMaxReportNum()#检查上报最大次数
- self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb)
- pass
- else:#
-
- #第一步触发自注册
- if get_result == 2:#请求的配置文件和本地不一致重启
- self.retryNum_old = 0#保存本地 配置文件不同重启模组 清空异常重试的报错次数
- # self.report_Num_old+=1#请求错误请求失败都要保存上报次数
- # if NEED_SAVE_CONFIG_FILE == 1:
- # 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.china_mobile_init_param()#重新走流程读配置文件->判断上报总数->判断报错次数->获取配置文件
- self.search_report_num_step()
- return
-
- self.report_Num_old+=1#请求错误请求失败都要保存上报次数
- if NEED_SAVE_CONFIG_FILE == 1:
- self.config_data["report_Num_old"] = self.report_Num_old
- self.write_config_msg_file(self.config_data)
- print("error_retryNum_step self.report_Num_old:{}\r\n".format(self.report_Num_old))
- if self.checkMaxReportNum() == 1:#检查上报最大次数
- self.search_report_num_step()#重新查询
- return
- report_result = self.onself_regist_report_cb()#注册
-
- #第二步触发心跳上报次数
- if report_result == 1:#注册完成之后根据服务端下发的配置 间隔上报心跳
- self.heartreportTimer.stop()
- self.heartreportTimer.start(self.heartBeatTime*60*1000,1,self.heartreportTimerCb)
-
- def heartreportTimerCb(self,*argc):
- self.heart_report_cb()
-
- def retpoertTimerClear(self):
- 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+self.reportTime*60#记录当前时间+reportTime的时间用于下次错判断
- if NEED_SAVE_CONFIG_FILE == 1:
- 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 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:{} currentTime:{} self.reportTime*60:{}".format(reportTime, currentTime,self.reportTime*60))
- if currentTime >= reportTime:#当前时间是否大于上次记录的时间 currentTime >= reportTime 直接清空 不超过定时清空数据不再上报数据
- #在规定时间内上报次数大于8次就要等下一个10分钟 或者1440分了开个定时器
- print("currentTime >= reportTime:\r\n")
- self.retpoertTimerClear()
- else:#否则次数置零，记录一下（当前时间+reportTime）时间
- time_count = (reportTime - currentTime) #self.reportTime_Sec永远比time_tmp大
- print("time_count:{}".format(time_count))
- print("currentTime < reportTime:\r\n")
- self.retpoertTimerC.start(time_count*1000,0,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+self.reportTime*60#记录当前时间+reportTime的时间用于下次错判断
- if NEED_SAVE_CONFIG_FILE == 1:
- 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()#清空报错次数重新走判断报错次数
-
-
- 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)标识旧的时间
- if NEED_SAVE_CONFIG_FILE == 1:
- self.config_data["reportTime_Sec"] = self.reportTime_Sec
- self.write_config_msg_file(self.config_data)
- self.error_retryNum_step()#查询上报错误次数
-
- def search_report_num_step_init(self):#查询上报总数步骤
- print("search_report_num_step:self.retryInterval:{} self.retryNum:{} self.reportTime_Sec:{}\r\n".format(self.report_Num_old,self.reportNum,self.reportTime_Sec))
- 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)#获取时间戳
- if self.reportTime_Sec == 0:
- self.reportTime_Sec = time_tmp+self.reportTime*60 #(记录时间+reportTime)标识旧的时间
- if NEED_SAVE_CONFIG_FILE == 1:
- 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.search_report_num_step()#重新查询
-
- def onself_regist_report_cb(self):#自注册上报信息
- date_tmp = utime.localtime()
- time_tmp = utime.mktime(date_tmp)#获取时间戳
- 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))
- self.report_Num_old+=1 ##保存本地
- if NEED_SAVE_CONFIG_FILE == 1:
- self.config_data["report_Num_old"] = self.report_Num_old
- self.write_config_msg_file(self.config_data)
- #设备自注册上报信息
- 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:
- #触发异常重试进制
- self.checkMaxReportNum()#检查上报最大次数
- if self.checkMaxRetryNum() == 1:
- print("retryTimerCb timer22")#异常重试过多重新间隔reportTime注册流程 关闭所有的定时器
- self.search_report_num_step()#重新查询
- return 0
- self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb)
- return 0
- else:
- if self.checkMaxReportNum() == 1:
- self.search_report_num_step()#重新查询
- # self.retpoertTimerC.start(self.reportTime*60*1000,0,self.reportTimerIntervalCb)
- return 0
- else:
- return 1
- def checkMaxReportNum(self):#检查上报次数最大值
- print("checkMaxReportNum :self.reportNum :{} self.report_Num_old:{}\r\n".format(self.reportNum,self.report_Num_old))
- if self.report_Num_old >= self.reportNum and self.report_Num_old != 0:
- self.retryTimer.stop()#关定时器
- self.retpoertTimerC.stop()
- self.heartreportTimer.stop()
- return 1
- else:
- return 0
-
- def checkMaxRetryNum(self):#检查上报错误次数
- print("checkMaxRetryNum :self.retryNum:{} self.retryNum_old:{}\r\n".format(self.retryNum_old,self.retryNum))
- if self.retryNum_old >= self.retryNum and self.retryNum_old != 0:#异常重试过多重新间隔reportTime注册流程
- self.retryTimer.stop()#关定时器
- self.retpoertTimerC.stop()
- self.heartreportTimer.stop()#关闭心跳定时器
- return 1
- else:
- return 0
-
- def heart_report_cb(self):#心跳上报信息
-
- date_tmp = utime.localtime()
- time_tmp = utime.mktime(date_tmp)#获取时间戳
- self.report_Num_old+=1#保存本地
- if NEED_SAVE_CONFIG_FILE == 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:
- #触发异常重试进制
- self.checkMaxReportNum()
- if self.checkMaxRetryNum() == 1:#异常重试过多重新间隔reportTime注册流程
- self.search_report_num_step()#重新查询
- return
- self.retryTimer.start(self.retryInterval*60*1000,0,self.retryTimerCb)
- return
- if self.checkMaxReportNum() == 1:#上报次数大于8次
- self.search_report_num_step()#重新查询
- return
-
- def china_mobile_init_param(self):#初始化
-
- status = eventMesh.publish("get_factory_status")
- if status == None:
- status = 0
- print("get_factory_status:{}\r\n".format(status))
- 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#保存本地
- get_address = eventMesh.publish("get_dmp_cm_address")
- if get_address == None:#获取出来地址是空的使用适配地址
- self.address = "a.fxltsbl.com"#默认
- else: #恢复出厂使用BLE传送过来的地址
- self.address = str(eventMesh.publish("get_dmp_cm_address"))
-
- 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
- if NEED_SAVE_CONFIG_FILE == 1:
- self.config_data["reportTime_Sec"] = self.reportTime_Sec
- 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()
- def china_mobile_init(self):
- self.china_mobile_init_param()
- #查询上报总数流程
- self.search_report_num_step_init()
-
-
-
-
-chinamobileCb = chinamobile()
import example
+import log
+from machine import UART
+
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+# 设置输出到debug口
+uart = UART(UART.UART0, 115200, 8, 0, 1, 0)
+log.set_output(uart)
+clog = log.getLogger("cat1")
+
main_flag = 1
+
+
try:
- try:
- from usr.slipService import slipservice
- except Exception as e:
- main_flag = 0
- print("启动失败!!!!!\r\n".format(e),'slipservice')
-
- try:
- from usr.tcpService import TcpService
- except Exception as e:
- main_flag = 0
- print("启动失败!!!!!\r\n".format(e),'tcpService')
-
- try:
- import usr.checkota
- except Exception as e:
- main_flag = 0
- print("启动失败!!!!!\r\n".format(e),'checkota')
-
example.exec('/usr/main_init.py')
- print("启动成功!!!!!\r\n")
+ clog.info("启动main_init成功!!!!!\r\n")
except Exception as e:
main_flag = 0
- print("启动失败!!!!!\r\n".format(e))
-
-
+ clog.error("启动失败!!!!!\r\n".format(e))
+try:
+ example.exec('/usr/tcpService.py')
+ clog.info("启动tcpserver成功!!!!!\r\n")
+except Exception as e:
+ clog.error("启动失败!!!!!\r\n".format(e))
import uos
import slip
+
+log.basicConfig(level=log.INFO)
+clog = log.getLogger("cat1")
+
+
USR_FILE_PATH = "/usr" #
BAK_FILE_PATH = "{}/TmpPyFile".format(USR_FILE_PATH) #文件传输的临时文件夹目录路径
BAK_FILE_TMP = "_bak"
self.updateTimerFlag = 0
self.sock = None
self.bakFlag = "0"
+ self.conn= None
# slip.destroy()
# ret = slip.construct(self.__uart,self.__mode, 0)
# if ret != 0:
- # print('slip netif construct fail')
+ # clog.info('slip netif construct fail')
# return None
self.__sock_file = None
self.__sock_file = self.__socket_file_init()
self.__thread_file = _thread.start_new_thread(self.__Socket_File_Thread, ())
- print("ftp_Service :{}\r\n".format(self.__sock_file))
+ self.conn_thread=_thread.start_new_thread(self._client_conn_proc, ())
+ clog.info("ftp_Service :{}\r\n".format(self.__sock_file))
# 封装tlv数据包
def __pack_tlv_format(self, head, content):
head1 = head
content1 = content
if len(content1) == 0 or len(content1) > 9999 or len(head1) != 2:
- print('illegal pack tlv content file')
+ clog.info('illegal pack tlv content file')
return -1
len_str ='%04d' % len(content1)
tlv_pack = CAT1_SERVICE_HEAD+head1+len_str+content1
return tlv_pack
# 解码tlv数据包
def __unpack_tlv_format(self, msg):
- print('__unpack_tlv_format file {}\r\n'.format(msg))
+ clog.info('__unpack_tlv_format file {}\r\n'.format(msg))
msg_tmp = str(msg)[2:]#这是去除head FE
tag = msg_tmp[0:2]
length = msg_tmp[2:6]
value = msg_tmp[6:]
len_str ='%04d' % len(value)
if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != msg_tmp[2:6]:
- print('__unpack_tlv_format err file')
+ clog.info('__unpack_tlv_format err file')
return -1
- # print('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
+ # clog.info('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
unpack = (tag,length,value)
return unpack
def __socket_init(self):
return self.sock
def __socket_file_init(self): #文件传输Socket
- self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT)
+ # self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT)
+ self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM, usocket.IPPROTO_TCP_SER)
self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
# 绑定IP
bind_addr = ('172.16.1.2', 5001)
self.sock.bind(bind_addr)
- self.sock.settimeout(10)
+ # self.sock.settimeout(10)
+ self.sock.listen(10)
+
return self.sock
+
def __socket_file_reinit(self):
- print("self.__sock_file reinit:{}\r\n".format(self.__sock_file))
+ clog.info("self.__sock_file reinit:{}\r\n".format(self.__sock_file))
if self.__sock_file != None:
self.sock.close()
return self.__socket_file_init()
# 向服务端发送消息
server_addr = ('172.16.1.5',1001) #服务端口也需要更改
- print("__Socket_UDP_file_noreply send msg {}".format(msg))
+ clog.info("__Socket_TCP_file_noreply send msg {}".format(msg))
try:
data_size = self.__sock_file.sendto(msg,server_addr)
- print("self.__sock_file data_size {}".format(data_size))
+ clog.info("self.__sock_file data_size {}".format(data_size))
+ except Exception as e:
+ clog.info("self.__sock_file error {}".format(e))
+ return 0
+ def __Socket_TCP_file_noreply(self, head, content):
+ head1 = head
+ content1 = content
+ gpioWakeBT.write(1)
+ utime.sleep_ms(2)
+ gpioWakeBT.write(0)
+ utime.sleep_ms(20)
+ # 消息处理
+ msg = self.__pack_tlv_format(head1,content1)
+ if msg == -1: #无效数据
+ return 0
+ # 向服务端发送消息
+ # server_addr = ('172.16.1.5',1001) #服务端口也需要更改
+
+ clog.info("__Socket_TCP_file_noreply send msg {}".format(msg))
+ try:
+ data_size = self.conn.send(msg)
+ clog.info("self.__sock_file data_size {}".format(data_size))
except Exception as e:
- print("self.__sock_file error {}".format(e))
+ clog.info("self.__sock_file error {}".format(e))
+
return 0
# py文件传输
# //py文件传输
# // {"Code":5} BLE 主动发送OTA成功
# // {"Code":6} BLE 所有PY文件传输完成
# // {"Code":7} BLE 单个文件传输完成
- def __Socket_File_Thread(self):
+
+ def _client_conn_proc(self):
+ clog.error('[_client_conn_proc] _client_conn_proc')
+
while True:
+ if self.conn==None:
+ utime.sleep_ms(20)
+ continue
try:
- print(" __Socket_File_Thread recv====22222:\r\n")
- data=self.__sock_file.recv(1024*10)
+ # Receive data sent by the client
+
+ data = self.conn.recv(1024)
+ clog.info('[server] [client addr: %s] recv data:', data)
if not data:
- print("__Socket_File_Thread data null:\r\n")
+ clog.info("__Socket_File_Thread data null:\r\n")
else:
self.src_data(data.decode('uft-8'))
- # print("__Socket_File_Thread end:{}\r\n".format(data.decode()))
- except Exception as e:
- print("__Socket_File_Thread:e{}\r\n".format(e))
- self.__sock_file = self.__socket_file_reinit()
- # print("End __Socket_File_Thread Thread")
+ # Send data back to the client
+ # conn.send(data)
+ except:
+ # Exception occurred and connection closed
+ clog.error('[server] disconnected')
+ self.conn.close()
+ # self.__sock_file = self.__socket_file_reinit()
+ break
+
+
+ def __Socket_File_Thread(self):
+
+ # clog.info('[server] accept a client: %s, %s' % (cli_ip_addr, cli_port))
+
+ while True:
+ try :
+ clog.info('[serveice] start accept a client' )
+ cli_conn, cli_ip_addr, cli_port = self.__sock_file.accept()
+ self.conn=cli_conn
+ clog.info('[serveice] accept a client: %s, %s' % (cli_ip_addr, cli_port))
+ except :
+ clog.error('__Socket_File_Thread' )
+ utime.sleep_ms(20)
+ # Create a new thread for each client connection for concurrent processing
+
+ # clog.info("End __Socket_File_Thread Thread")
def cat1FileTimerCb(self,*argc):
- print("timer test\r\n")
+ clog.info("timer test\r\n")
if self.Cat1PyFileTimout > 0:
self.Cat1PyFileTimout-=1
if self.Cat1PyFileTimout == 0:
self.Cat1FileState = 0
self.deleteTmpFile()
self.deleteUsrTmpFile()
- self.__Socket_UDP_file_noreply(CAT1_OTA_TIMEOUT_BLE_NO_REPLAY,"ota error") #结束文件接收不完整的
+ self.__Socket_TCP_file_noreply(CAT1_OTA_TIMEOUT_BLE_NO_REPLAY,"ota error") #结束文件接收不完整的
self.Cat1FileTransTimer.stop() #//关闭定时器
pass
bytes_data = msg.encode('utf-8')
hex_data = binascii.hexlify(bytes_data)
hex_data = hex_data.decode()
- # print("hex_data:{}\r\n".format(hex_data))
+ # clog.info("hex_data:{}\r\n".format(hex_data))
data = hex_data
crcValue = 0
j = 0
i = 0
json_state = 0
crcbuf = 0
- # print("len(data) :{}\r\n".format(len(data)))
+ # clog.info("len(data) :{}\r\n".format(len(data)))
data_len = len(str(data))
try:
if data_len % 2 != 0:
return [json_state,crcbuf]
except Exception as e:
json_state = 0
- print("不合法的的十六进制数据!!\r\n")
+ clog.info("不合法的的十六进制数据!!\r\n")
for i in range(data_len):
if j >= data_len:
crcValue=crcValue+decimal_number
crcValue = crcValue&0xff
except Exception as e:
- print("不合法的的十六进制数据!!\r\n")
+ clog.info("不合法的的十六进制数据!!\r\n")
j+=2
crcbuf = crcValue%256
crcbuf = 256-crcbuf
crcbuf = crcbuf%256
- # print("crcbuf:{}\r\n".format(crcbuf))
+ # clog.info("crcbuf:{}\r\n".format(crcbuf))
return [json_state,"%02x"%(crcbuf)]
#删除临时创建的文件夹
def deleteTmpFile(self):
def src_data(self,data):
mk_dir_state = 0
- print("data!!!!!{}\r\n".format(len(data)))
+ clog.info("data!!!!!{}\r\n".format(len(data)))
if self.updateTimerFlag == 0:
self.updateTimerFlag = 1
self.updateTimer.stop()
pass
def file_data(self,msg):
- # print("msg type msg {} {}\r\n".format(msg,type(data)))
+ # clog.info("msg type msg {} {}\r\n".format(msg,type(data)))
if "Code" in msg:
Code = int(msg["Code"])
- print("Code {} self.Cat1FileState:{}\r\n".format(Code,self.Cat1FileState))
+ clog.info("Code {} self.Cat1FileState:{}\r\n".format(Code,self.Cat1FileState))
if Code == CAT1_TCP_STOP_OTA: #OTA失败
self.allPyRecvFlag = 0
self.Cat1FileState = 0
self.allPyRecvFlag = 0
self.fileNameList = []
self.fileSizeList = []
- print("CAT1_TCP_START_OTA {} \r\n".format(CAT1_TCP_START_OTA))
+ clog.info("CAT1_TCP_START_OTA {} \r\n".format(CAT1_TCP_START_OTA))
self.allPyRecvFlag = 0
self.Cat1FileState = 0
self.deleteUsrTmpFile()
try:
self.deleteTmpFile()
except Exception as e:
- print("移除失败!!!!\r\n")
+ clog.info("移除失败!!!!\r\n")
check_dir = ql_fs.path_exists(BAK_FILE_PATH)
if check_dir == False: #文件夹不存在 创建目录文件夹
try:
ql_fs.mkdirs(BAK_FILE_PATH)
mk_dir_state = 1
- print("创建临时文件 创建成功!!!!\r\n")
+ clog.info("创建临时文件 创建成功!!!!\r\n")
except Exception as e:
mk_dir_state = 0
- print("创建临时文件失败没有内存!!!!\r\n")
+ clog.info("创建临时文件失败没有内存!!!!\r\n")
else: #已经存在目录了
mk_dir_state = 1
- print("创建成功!!!!{}\r\n".format(mk_dir_state))
+ clog.info("创建成功!!!!{}\r\n".format(mk_dir_state))
if mk_dir_state == 0:
- self.__Socket_UDP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat dir error!")
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat dir error!")
else:
self.Cat1FileState = 1
self.fileNameList = []
self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间10s
self.Cat1FileTransTimer.stop()
self.Cat1FileTransTimer.start(1000,1,self.cat1FileTimerCb)
- self.__Socket_UDP_file_noreply(CAT1_CREAT_DIR_OK,"creat dir success!")
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_OK,"creat dir success!")
elif Code == CAT1_TCP_START_SEND_SINGLE_FILE_INFO and self.Cat1FileState == 1: #包含文件名 文件大小
- print("CAT1_TCP_START_SEND_SINGLE_FILE_INFO {} \r\n".format(CAT1_TCP_START_SEND_SINGLE_FILE_INFO))
+ clog.info("CAT1_TCP_START_SEND_SINGLE_FILE_INFO {} \r\n".format(CAT1_TCP_START_SEND_SINGLE_FILE_INFO))
self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间60s
# {"Code":1,"fileName":"testpy.py","fileSize":1040}
self.fileNameTmp = str(msg["fileName"])
self.fileNameList = msg["fileNameList"]
# self.fileSizeList.append({"fileName":self.fileNameTmp,"fileSize":int(self.fileSize)})
path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)
- print("self.fileNameTmp {} self.fileSize:{} self.fileNameList:{} self.fileSizeList:{}\r\n".format(self.fileNameTmp,self.fileSize,self.fileNameList,self.fileSizeList))
+ clog.info("self.fileNameTmp {} self.fileSize:{} self.fileNameList:{} self.fileSizeList:{}\r\n".format(self.fileNameTmp,self.fileSize,self.fileNameList,self.fileSizeList))
check_touch = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
if check_touch == True:
try:
uos.remove("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
except Exception as e:
- print("移除文件失败\r\n")
+ clog.info("移除文件失败\r\n")
try:
with open(path,"w+") as fd:
fd.write("")
fd.close() #关闭文件流
- self.__Socket_UDP_file_noreply(CAT1_CREAT_FILE_SUCC,"1creat file or dir success!")
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_SUCC,"1creat file or dir success!")
except Exception as e:
- print("创建文件失败\r\n")
- self.__Socket_UDP_file_noreply(CAT1_CREAT_FILE_ERROR,"1creat file or dir err!")
+ clog.info("创建文件失败\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"1creat file or dir err!")
else:
try:
- print("self.fileNameTmp 111111{}\r\n".format(self.fileNameTmp))
+ clog.info("self.fileNameTmp 111111{}\r\n".format(self.fileNameTmp))
with open(path,"w+") as fd:
fd.write("")
fd.close() #关闭文件流
self.crc_err = 0
- print("self.fileNameTmp {}\r\n".format(self.fileNameTmp))
- self.__Socket_UDP_file_noreply(CAT1_CREAT_FILE_SUCC,"2creat file or dir success!")
+ clog.info("self.fileNameTmp {}\r\n".format(self.fileNameTmp))
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_SUCC,"2creat file or dir success!")
except Exception as e:
- self.__Socket_UDP_file_noreply(CAT1_CREAT_FILE_ERROR,"2creat file or dir err!")
- print("创建文件失败\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"2creat file or dir err!")
+ clog.info("创建文件失败\r\n")
elif Code == CAT1_TCP_START_SEND_FILE_DATA and self.Cat1FileState == 1: #文件数据
self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间10s
- print("CAT1_TCP_START_SEND_FILE_DATA {} self.fileNameTmp:{}\r\n".format(CAT1_TCP_START_SEND_FILE_DATA,self.fileNameTmp))
+ clog.info("CAT1_TCP_START_SEND_FILE_DATA {} self.fileNameTmp:{}\r\n".format(CAT1_TCP_START_SEND_FILE_DATA,self.fileNameTmp))
# {"Code":2,"data":"89ggjdggsjgdj"}
if len(self.fileNameTmp) == 0: #文件名不能为空
return
data = msg["data"]
if len(data) == 0:
return
- print(" (data):{}\r\n".format(len(data)))
+ clog.info(" (data):{}\r\n".format(len(data)))
tmpdata = str(data)
head = tmpdata[0:2] #FE
if head != CAT1_FILE_DATA_HEAD or len(tmpdata) <= 8: #必须大于8 FF+012C+DATA+crc(一个字节89)
- print("head {}\r\n".format(head))
- self.__Socket_UDP_file_noreply(CAT1_SEND_HEAD_ERR,"head error!")
+ clog.info("head {}\r\n".format(head))
+ self.__Socket_TCP_file_noreply(CAT1_SEND_HEAD_ERR,"head error!")
return
datalen = str(tmpdata[2:6]) #012c
datalen = int("0x" + datalen, 16) #转换成十进制数
data_buf = tmpdata[6:] # 数据
data_buf = data_buf[:-2] #最后两个往前的数据
crc = tmpdata[-2:] # 最后两个字符是 crc 一个字节
- print("crc ===!111111:{} {} len:{} {}\r\n".format(crc,type(crc),datalen,len(str(data_buf))))
+ clog.info("crc ===!111111:{} {} len:{} {}\r\n".format(crc,type(crc),datalen,len(str(data_buf))))
if len(str(data_buf)) == 0 or len(str(data_buf)) != datalen: #数据为空
- self.__Socket_UDP_file_noreply(CAT1_WRITE_FILE_ERROR,"crc error or data null!")
+ self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"crc error or data null!")
return
# crclist=self.crc_cal(data_buf)
# newcrc = crclist[1]
# news = crclist[0]
# if len(str(crc)) == 0:
- # self.__Socket_UDP_file_noreply(CAT1_CRC_ERROR,"crc error!")
+ # self.__Socket_TCP_file_noreply(CAT1_CRC_ERROR,"crc error!")
# return
# decnumCrcCal = int("0x" + str(newcrc), 16) #转换成十进制数
# decnumCrc = int("0x" + str(crc), 16) #转换成十进制数
- # print("crc:{} newcrc:{}\r\n".format(crc,newcrc,decnumCrc,decnumCrcCal))
+ # clog.info("crc:{} newcrc:{}\r\n".format(crc,newcrc,decnumCrc,decnumCrcCal))
# if decnumCrcCal != decnumCrc and news == 0:
- # print("newcrc is not === crc crc校验出错不一致\r\n")
- # self.__Socket_UDP_file_noreply(CAT1_CRC_ERROR,"crc error!")
+ # clog.info("newcrc is not === crc crc校验出错不一致\r\n")
+ # self.__Socket_TCP_file_noreply(CAT1_CRC_ERROR,"crc error!")
# return
data = str(data_buf)
path = "{}/{}".format(BAK_FILE_PATH,str(self.fileNameTmp))
- print("py path:{} self.fileNameTmp:{}\r\n".format(path,self.fileNameTmp))
+ clog.info("py path:{} self.fileNameTmp:{}\r\n".format(path,self.fileNameTmp))
try:
with open(path,"a") as fd:
fd.write(data)
fd.close() #关闭文件流
- self.__Socket_UDP_file_noreply(CAT1_WRITE_FILE_SUCC,"write file success!")
- print("写文件成功!!!!!\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_SUCC,"write file success!")
+ clog.info("写文件成功!!!!!\r\n")
except Exception as e:
- self.__Socket_UDP_file_noreply(CAT1_WRITE_FILE_ERROR,"write file error!")
- print("写文件失败没有内存!!!!!{}:\r\n".format(e))
+ self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"write file error!")
+ clog.info("写文件失败没有内存!!!!!{}:\r\n".format(e))
elif Code == CAT1_TCP_START_OTA_FAILE and self.Cat1FileState == 1: #取消文件传输 OTA失败 移除目录文件
- print("CAT1_TCP_START_OTA_FAILE {} \r\n".format(CAT1_TCP_START_OTA_FAILE))
+ clog.info("CAT1_TCP_START_OTA_FAILE {} \r\n".format(CAT1_TCP_START_OTA_FAILE))
self.allPyRecvFlag = 0
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"OTA FAILE")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"OTA FAILE")
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
self.deleteTmpFile()
pass
elif Code == CAT1_TCP_START_SEND_ALLFILE_FINESH and self.Cat1FileState == 1: #全部文件传输完成
if self.bakFlag == "0":
- print("self.bakFlag auto:\r\n")
+ clog.info("self.bakFlag auto:\r\n")
if self.allPyRecvFlag == 1:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
else:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
- print("重启 auto:\r\n")
+ clog.info("重启 auto:\r\n")
self.Cat1OtaTimeOut.stop()
self.Cat1TimeCount = 0
self.ota_state = 1
self.allPyRecvFlag = 1 #所有的py文件接收完成
self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut)
return
- print("BAK_FILE_FUN!!!!!!\r\n")
+ clog.info("BAK_FILE_FUN!!!!!!\r\n")
tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
if tmp_dir == True:
filenamesList = uos.listdir(BAK_FILE_PATH)
list1 = sorted(filenamesList)
list2 = sorted(self.fileNameList)
- print("filenamesList:{} self.fileNameList:{} {}{}\r\n".format(filenamesList,self.fileNameList,type(filenamesList),type(self.fileNameList)))
+ clog.info("filenamesList:{} self.fileNameList:{} {}{}\r\n".format(filenamesList,self.fileNameList,type(filenamesList),type(self.fileNameList)))
if list1 != list2: #传输的文件列表和BLE不一致说明有文件没有传输完成不再重启CAT1
self.deleteTmpFile()
self.Cat1FileState = 0
- print("self.Cat1PyFile444!!!:{}\r\n".format(self.Cat1FileState))
+ clog.info("self.Cat1PyFile444!!!:{}\r\n".format(self.Cat1FileState))
self.Cat1FileTransTimer.stop()
self.deleteUsrTmpFile()
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
return
try:
copy_flag = 0
filenamesList = uos.listdir(BAK_FILE_PATH)
for tmp in filenamesList: #将传输的文件 copy到usr目录下
- print("filenamesList for :{}\r\n".format(filenamesList))
+ clog.info("filenamesList for :{}\r\n".format(filenamesList))
dst_path = "{}/{}".format(USR_FILE_PATH,tmp) #目标目录文件
# if ql_fs.path_exists(dst_path) == False:
# try:
# copy_flag = 1
# ql_fs.touch(dst_path,"")
# except Exception as e:
- # print("创建文件失败!!!!!\r\n")
+ # clog.info("创建文件失败!!!!!\r\n")
# if copy_flag == 0:
- # print("创建文件失败!!!!!copy_flag\r\n")
+ # clog.info("创建文件失败!!!!!copy_flag\r\n")
# copy_state = 0
# break
src_path = "{}/{}".format(BAK_FILE_PATH,tmp) #源目录文件
try:
ret = ql_fs.file_copy(dst_path,src_path)
- print("copy ret!!!!!:{}\r\n".format(ret))
+ clog.info("copy ret!!!!!:{}\r\n".format(ret))
if ret == True:
dstfile_size = ql_fs.path_getsize(dst_path)
srcfile_size = ql_fs.path_getsize(src_path)
- print("copy dstfile_size:{} srcfile_size:{}\r\n".format(dstfile_size,srcfile_size))
+ clog.info("copy dstfile_size:{} srcfile_size:{}\r\n".format(dstfile_size,srcfile_size))
if dstfile_size != srcfile_size:
compare_flag = 0
break
compare_flag = 1
uos.remove(src_path)
filenamesList = uos.listdir(BAK_FILE_PATH)
- print("remove filenamesList :{}\r\n".format(filenamesList))
+ clog.info("remove filenamesList :{}\r\n".format(filenamesList))
except Exception as e:
- print("copy file \r\n")
+ clog.info("copy file \r\n")
else:
compare_flag = 0
break
except Exception as e:
- print("copy file \r\n")
+ clog.info("copy file \r\n")
if copy_state == 0 or compare_flag == 0 : #比较失败 或者copy失败没有内存了
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22") #传输文件完之后最后提示是否成功失败
return
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
- print("重启 auto:\r\n")
+ clog.info("重启 auto:\r\n")
self.Cat1OtaTimeOut.stop()
self.Cat1TimeCount = 0
self.ota_state = 1
self.allPyRecvFlag = 1 #所有的py文件接收完成
self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut)
except Exception as e:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33") #传输文件完之后最后提示是否成功失败
self.deleteUsrTmpFile()
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
else:
if self.ota_state == 1:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
pass
else:
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
self.deleteUsrTmpFile()
- print("cat1 ota\r\n")
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+ clog.info("cat1 ota\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
elif Code == CAT1_TCP_START_OTA_SUCC and self.Cat1FileState == 1:
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
if self.allPyRecvFlag == 1: #所有的py文件接收完成
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
else:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") #传输文件完之后最后提示是否成功失败
return
if self.allPyRecvFlag == 0: #没有接收完成就发送OTA成功的标识
self.deleteTmpFile()
self.deleteUsrTmpFile()
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
return
tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
if tmp_dir == True:
filenamesList = uos.listdir(BAK_FILE_PATH)
list1 = sorted(filenamesList)
list2 = sorted(self.fileNameList)
- print("filenamesList:{} self.fileNameList:{} {}{}\r\n".format(filenamesList,self.fileNameList,type(filenamesList),type(self.fileNameList)))
+ clog.info("filenamesList:{} self.fileNameList:{} {}{}\r\n".format(filenamesList,self.fileNameList,type(filenamesList),type(self.fileNameList)))
if list1 != list2: #传输的文件列表和BLE不一致说明有文件没有传输完成不再重启CAT1
self.deleteTmpFile()
self.Cat1FileState = 0
- print("self.Cat1PyFile444!!!:{}\r\n".format(self.Cat1FileState))
+ clog.info("self.Cat1PyFile444!!!:{}\r\n".format(self.Cat1FileState))
self.Cat1FileTransTimer.stop()
self.deleteUsrTmpFile()
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
return
try:
copy_flag = 0
filenamesList = uos.listdir(BAK_FILE_PATH)
for tmp in filenamesList: #将传输的文件 copy到usr目录下
- print("filenamesList for :{}\r\n".format(filenamesList))
+ clog.info("filenamesList for :{}\r\n".format(filenamesList))
dst_path = "{}/{}".format(USR_FILE_PATH,tmp) #目标目录文件
# if ql_fs.path_exists(dst_path) == False: #usr下面没有就创建文件写空的数据
# try:
# ret = ql_fs.touch(dst_path,"")
- # print("创建文件成功!!!!!:ret {}\r\n".format(ret))
+ # clog.info("创建文件成功!!!!!:ret {}\r\n".format(ret))
# if ret == 0:
# copy_flag = 1
# except Exception as e:
- # print("创建文件失败!!!!!\r\n")
+ # clog.info("创建文件失败!!!!!\r\n")
# if copy_flag == 0:
- # print("创建文件失败!!!!!copy_flag\r\n")
+ # clog.info("创建文件失败!!!!!copy_flag\r\n")
# copy_state = 0
# break
src_path = "{}/{}".format(BAK_FILE_PATH,tmp) #源目录文件
try:
ret = ql_fs.file_copy(dst_path,src_path)
- print("copy ret!!!!!:{}\r\n".format(ret))
+ clog.info("copy ret!!!!!:{}\r\n".format(ret))
if ret == True:
dstfile_size = ql_fs.path_getsize(dst_path)
srcfile_size = ql_fs.path_getsize(src_path)
- print("copy dstfile_size:{} srcfile_size:{}\r\n".format(dstfile_size,srcfile_size))
+ clog.info("copy dstfile_size:{} srcfile_size:{}\r\n".format(dstfile_size,srcfile_size))
if dstfile_size != srcfile_size:
compare_flag = 0
break
compare_flag = 1
uos.remove(src_path)
filenamesList = uos.listdir(BAK_FILE_PATH)
- print("remove filenamesList :{}\r\n".format(filenamesList))
+ clog.info("remove filenamesList :{}\r\n".format(filenamesList))
except Exception as e:
- print("copy file \r\n")
+ clog.info("copy file \r\n")
else:
compare_flag = 0
break
except Exception as e:
- print("copy file \r\n")
+ clog.info("copy file \r\n")
if copy_state == 0 or compare_flag == 0 : #比较失败 或者copy失败没有内存了
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22") #传输文件完之后最后提示是否成功失败
return
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
- print("重启 auto:\r\n")
+ clog.info("重启 auto:\r\n")
self.Cat1OtaTimeOut.stop()
self.Cat1TimeCount = 0
self.ota_bstate = 1
+ self.conn.close()
self.Cat1OtaTimeOut.start(10000,0,self.otaTimeOut)
except Exception as e:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33") #传输文件完之后最后提示是否成功失败
self.deleteUsrTmpFile()
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
else:
if self.ota_bstate == 1:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
pass
else:
self.deleteTmpFile()
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
self.deleteUsrTmpFile()
- print("cat1 ota\r\n")
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+ clog.info("cat1 ota\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
elif Code == CAT1_TCP_SEND_SINGLE_FINESH and self.Cat1FileState == 1: #单个文件传输完成
- print("CAT1_TCP_SEND_SINGLE_FINESH {} self.fileNameTmp:{}\r\n".format(CAT1_TCP_SEND_SINGLE_FINESH,self.fileNameTmp))
+ clog.info("CAT1_TCP_SEND_SINGLE_FINESH {} self.fileNameTmp:{}\r\n".format(CAT1_TCP_SEND_SINGLE_FINESH,self.fileNameTmp))
self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间10s
tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
if tmp_dir == True:
tmp_file = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
if tmp_file == True: #文件存在
file_size = ql_fs.path_getsize("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
- print("file size :file_size:{} self.fileSize:{}\r\n".format(file_size,self.fileSize))
+ clog.info("file size :file_size:{} self.fileSize:{}\r\n".format(file_size,self.fileSize))
if self.fileSize != file_size: #文件大小不一致 传输出错
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") #结束文件接收不完整的
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") #结束文件接收不完整的
else: #传完一个文件copy到usr下面
if self.bakFlag == "0":
src_path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp) #源文件目录 /usr/TmpFile/
ret = False
try:
- print("touch single file!!!!!dtpath111:{}\r\n".format(dst_path,src_path))
+ clog.info("touch single file!!!!!dtpath111:{}\r\n".format(dst_path,src_path))
ret = ql_fs.file_copy(dst_path,src_path)
if ret == True:
dstfile_size = ql_fs.path_getsize(dst_path)
try:
uos.remove(src_path) #移除文件
except Exception as e:
- print("copy 文件异常出错 yichu!{}:\r\n".format(e))
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") #结束文件接收完整的
+ clog.info("copy 文件异常出错 yichu!{}:\r\n".format(e))
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") #结束文件接收完整的
return
else:
src_file = ql_fs.path_exists(src_path) #删除文件
try:
uos.remove(src_path) #移除文件
except Exception as e:
- print("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file size ok") #文件大小不一致
+ clog.info("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file size ok") #文件大小不一致
return
else:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") #copy失败
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") #copy失败
except Exception as e:
- print("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") #copy失败
+ clog.info("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") #copy失败
else:
- print("self.bakFlag 1:\r\n")
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file copy ok") #copy失败
+ clog.info("self.bakFlag 1:\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file copy ok") #copy失败
else:
- self.__Socket_UDP_file_noreply(CAT1_CREAT_FILE_ERROR,"creat file or dir err!")
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"creat file or dir err!")
pass
else:
- self.__Socket_UDP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat file or dir error!")
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat file or dir error!")
pass
if self.Cat1FileReplayBle == 1:
return
self.Cat1FileReplayBle = 1
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"reset start!") #结束文件接收不完整的
- print("错误信息!!!!!\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"reset start!") #结束文件接收不完整的
+ clog.info("错误信息!!!!!\r\n")
self.Cat1FileState == 0
self.Cat1FileTransTimer.stop() #//关闭定时器
self.Cat1PyFileTimout = 0
def otaTimeOut(self,*argc):
- print("重启成功！！！！！！！！\r\n")
- Power.powerRestart()
+
+
+ clog.info("重启成功！！！！！！！！\r\n")
+ # 上层直接重启即可
+ # Power.powerRestart()
TcpService = TcpServiceInit()
-import app_fota
-from misc import Power
-import modem
-import ujson
-import request
-import ql_fs
-import checkNet
-import sys
-import sim
-
-from queue import Queue
-import usys
-import _thread
-import fota
-import utime
import log
-import uos
-import osTimer
-import net
-import ql_fs
-from usr.EventMesh import eventMesh,CHINA_TELECOM_DM_FUN_ENABLE
+
# 设置日志输出级别
log.basicConfig(level=log.INFO)
fota_log = log.getLogger("telecom_dmp")
-import modem
-import base64
-import request
-import ujson
-REGIST_MAX_NUM=10 #自注册的最大次数 现在是默认是10次
-REGIST_INTERVAL_TIMER=60*60 #自注册失败的间隔时间 1小时
-REGIST_POWER_ON_TIME=5*60 #开机5分钟内就必须自注册触发
-MULTI_DAY_RESEND_T = 30*24*60*60-12*60*60#多日重发的机制的周期T 30天
-MULTI_DAY_RESEND_t = 12*60*60#多日重发的机制的周期t 0.5天
-def get_report_url_website(mode = None):#获取上报网址
- url = "http://zzhc.vnet.cn:9998/"#上报网址
- return url
-
-class telecomDmp:
- def __init__(self):
- self.config_data = {}
- self.check_timer = osTimer()#1小时定时器
- self.multiDayResend_timer = osTimer()#12小时定时器 多日重发的机制
- self.telecomTimer = osTimer()
- 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#注册成功
- eventMesh.subscribe("get_telecom_init_state",self.get_telecom_init_state)
- eventMesh.subscribe("set_telecom_init_state",self.set_telecom_init_state)
-
- eventMesh.subscribe("set_dmp_power_num",self.set_dmp_power_num)
- eventMesh.subscribe("get_dmp_power_num",self.get_dmp_power_num)
-
- eventMesh.subscribe("get_dmp_power_timer_count",self.get_dmp_power_timer_count)
-
- self.regist_queue = Queue()
- _thread.stack_size(10*1024)
- _thread.start_new_thread(self.regist_queue_thread, ())
- _thread.stack_size(8*1024)
-
- eventMesh.subscribe("publish_message_event_registinfor",self.publish_message_event_registinfor)
- self.__net_connected = 0
- eventMesh.subscribe("get_network_state",self.get_network_state)#订阅消息
- eventMesh.subscribe("set_network_state",self.set_network_state)#订阅消息
-
- eventMesh.subscribe("set_dev_version",self.set_dev_version)#订阅消息
- eventMesh.subscribe("get_dev_version",self.get_dev_version)#订阅消息
-
- eventMesh.subscribe("save_iccid_data",self.save_iccid_data)#订阅消息 保存ICCID
- eventMesh.subscribe("get_iccid_data",self.get_iccid_data)#订阅消息 保存ICCID
-
- eventMesh.subscribe("set_regist_time",self.set_regist_time)#订阅消息 保存ICCID
- eventMesh.subscribe("get_regist_time",self.get_regist_time)#订阅消息 保存ICCID
-
- self.regist_timeSec = 0
- self.iccid_data = ""
- self.software_version = ""
- self.mulit_day_timesec = 0#多日重发的开始的时间戳
- pass
- def regist_queue_thread(self):
- while True:
- data = self.regist_queue.get()
- #EventMesh.debug_log("regist_queue:data = {}".format(data))
- if data != None:
- try:
- data["func"](data["data"])
- except Exception as e:
- print("regist_queue:ERROR:{}".format(e))
- usys.print_exception(e)
- def publish_message_event_registinfor(self,event,msg):
- self.regist_queue.put(msg)
-
- def publish_regist_event_cb(self, *args, **kwargs):
- eventMesh.publish("publish_message_event_registinfor",{"func":self.timer_cb,"data":0})
-
- def set_network_state(self,event,msg):#设置网络是否正常
- self.__net_connected = int(msg)
-
- def get_network_state(self,event,msg):#获取网络是否正常
- return self.__net_connected
-
- def set_dev_version(self,event,msg):#获取固件版本号
- self.software_version = str(msg)
-
- def get_dev_version(self,event,msg):#获取固件版本号
- return self.software_version
-
- def save_iccid_data(self,event,msg):
- 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):
-
- 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):#
- 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
-
-
- def get_sim_state(self):#获取sim状态 不为1是sim异常
- return sim.getStatus()
-
- def get_sim_iccid(self):#获取sim的iccid
- return sim.getIccid()
-
- def get_sim_imsi(self):#获取sim的imsi
- return sim.getImsi()
- def get_dev_imei(self):#获取设备的imei号
- return modem.getDevImei()
-
- def telecom_regeist_infor(self):#自注册信息 可变更
- network_state = eventMesh.publish("get_network_state")
- print("telecom_regeist_infor :",network_state,self.isRegistOk,REGIST_INTERVAL_TIMER,MULTI_DAY_RESEND_T,MULTI_DAY_RESEND_t,REGIST_POWER_ON_TIME)
- if network_state == 0:# 第一次进入网络不正常就需要开启1小时定时器 等待下一个周期判断网络是否正常 需要判断网络是否正常 不正常就不去触发自注册了 就等待下一次 如果10次都不成功 就等一下次开机再去自注册
- self.timer_count+=1
- print("self.timer_count:{}".format(self.timer_count))
- if self.timer_count < REGIST_MAX_NUM:#总共是10次 10次结束还没有自注册成功就等下一次开机自注册
- self.check_timer.start(REGIST_INTERVAL_TIMER*1000,0,self.publish_regist_event_cb)#不需要循环定时器
- else:
- self.multiple_day_resend()
- return
- iccid = self.get_sim_iccid()
- read_iccid = eventMesh.publish("get_iccid_data")
- if read_iccid == None:
- read_iccid = ""
-
- print("iccid!!!!!!!!!!iccid {} read_iccid:{}".format(iccid,read_iccid))
- if read_iccid != "":
- if str(read_iccid) == str(iccid):#两者相同 并且本地有保存 不再自注册了 说明已经自注册过了
- print("already registed!!!!!!") #已自注册过
- self.isRegistOk = 1
-
- if self.isRegistOk == 1:
- print("multiple_day_resend!!!!!!\r\n")
- self.multiple_day_resend()
- return
- self.telecom_regist_infor_init()#自注册初始化函数
- if self.isRegistOk == 0:
- self.timer_count+=1
- print("self.timer_count:{}".format(self.timer_count))
- if self.timer_count < REGIST_MAX_NUM:#总共是10次 10次结束还没有自注册成功就等下一次开机自注册
- self.check_timer.start(REGIST_INTERVAL_TIMER*1000,0,self.publish_regist_event_cb)#不需要循环定时器
- else:
- self.multiple_day_resend()
-
- def telecom_regist_infor_init(self):#自注册的数据部分
- iccid = self.get_sim_iccid()
- read_iccid = eventMesh.publish("get_iccid_data")
- if read_iccid == None:
- read_iccid = ""
- url = get_report_url_website(None)#上报网址 根据需要更改上报网址
- if iccid == -1:
- iccid = str("FF")#为空就填写FF
-
- IMSI = self.get_sim_imsi()
- if IMSI == -1:#没有卡 则填FF
- IMSI = str("FF")
- imei = self.get_dev_imei()
- if imei == -1:
- imei = str("FF")
-
- data_tmp = net.getCellInfo() #会适当卡个3-5s
- i = 0
- cell_data = 0
- if(len(data_tmp) >= 1):
- for cell in data_tmp:
- if i == 2:#在list里面最多就三个元素 最后一个是LTE的数据
- if cell != []:
- for tup in cell:
- print("tup:{}".format(tup))
- if tup[0] == 0 and len(tup) > 0:#第0个代表当前服务的小区CELLID 7位16进制数
- cell_data = tup[1]#这个是十进制数需要自行转换成十六进制数
- print(cell_data)
- break
- i+=1
- # cell_data = 0
- cell_data = "%07x"%(cell_data)#7位16进制数不够前面补0
- print(cell_data)
- sendCellid = "{}".format(cell_data)
- REGVER = "12.0"#当前数据域协议版本号
- MODEL = "TXB-Watch Soar"#机型字段 -前面是厂商名 -后面是设备名
- get_dev_version = eventMesh.publish("get_dev_version")#订阅消息
- if get_dev_version == None:
- get_dev_version = ""
- SWVER = get_dev_version #软件版本号
- UETYPE = "12"#终端类型 12是智能手表 11是儿童手表
- SIM1ICCID = iccid
- SIM1LTEIMSI = IMSI
- MACID = ""#可用WALN的地址 终端布支持WLAN 就是不可上网
- OSVER = "RTOS"#操作系统版本号
- IMEI1 = imei#"876226002021717"#imei
- SIM1CELLID = sendCellid#下发的小区ID
- data = {
- "REGVER":REGVER,
- "MODEL":MODEL,
- "SWVER":SWVER,
- "UETYPE":UETYPE,
- "SIM1ICCID":SIM1ICCID,
- "SIM1LTEIMSI":IMSI,
- "MACID":MACID,
- "OSVER":OSVER,
- "IMEI1":IMEI1,
- "SIM1CELLID":SIM1CELLID,
- "NETWORKTYPE":4
- }
- data_infor=ujson.dumps(data)#将字典转换成json格式
- json_bytes = bytes(data_infor, 'utf-8')#转换成字节数
- data_encode = base64.b64encode(json_bytes)#再转换成base64的编码格式 密文
- print("data_infor:{} data:{}".format(data_encode,data))
- headers_T = {'Content-Type':'application/encrypted-json'} #请求头信息 按照实际要求填写
- request_result = 0
- try:
- response = request.post("http://zzhc.vnet.cn:9998/", data=data_encode,headers =headers_T)
- request_result = 1
- if response.status_code == 200 : #返回状态码 200服务器正常解析数据
- content = response.content#后台返回的结果
- c = next(content)
-
- jsload_data = ujson.loads(c)
- print("jsload_data:{}".format(ujson.loads(c))) #{"resultCode": "0","resultDesc": "Success"}
- if "resultCode" in jsload_data or "resultDesc" in jsload_data:#返回结果码值
- resultCode = jsload_data["resultCode"]#结果解析 "0" 成功 "1" 解码错误 "2" 校验错误
- resultDesc = jsload_data["resultDesc"]#Success 表示自注册成功
-
- if resultCode == "0" or resultDesc == "Success":#注册成功退出当前注册 保存当前的ICCID 不在进行自注册了
- iccid = self.get_sim_iccid()#获取当前SIM的ICCID
- if iccid != -1:#读到ICCID
- self.timer_count = 0
- self.check_timer.stop()
- self.isRegistOk = 1#已完成自注册的标识
- 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:!!!!!")
- return 1
- if resultCode == "1":
- print("Decode error")#解码错误 设备编码不正确
- return 0
-
- if resultCode == "2":#
- print("Check error")#校验错误 设备里面数据不正确 有些数据不应该为空
- return 0
-
- except Exception as e:
- print("response:{}".format(e))
- request_result = 0
- return 0
-
- def timer_cb(self,data):#定时器回调
- self.telecom_regeist_infor()#重新进行自注册
- pass
- # 多日重发功能要求：
- # 1) 多日重发是指：在重发周期 T 内，如果没有功能性触发数据域自注册（触发发送且发送成功），
- # 则终端应根据当前终端实时信息组织数据域自注册（不能直接拿上一周期的内容不变而重发）内容
- # 并发送的过程；
- # 2) 多日重发的时间间隔周期 T 设置为 30 天；
- # 3) 多日重发的过程应设置为：功能性（比如换卡等）触发数据域自注册后，立即启动定时器 t（t
- # 的初始值应设为 0.5 天）开始重发计时，以后每当 t 时间等于 T 的整数倍（t=N*T）时，终端就进
- # 行数据域自注册发送，发送后 t 不要清零不要初始化，只有当功能性触发数据域自注册后，t 才初
- # 始化，t 的初始化值为 0.5 天。
- # Multiple day resend
- def multiple_day_resend(self):#多日重发机制函数 没有发送数据域或者发送成功
-
- t = 12 #计时周期 按照0.5天 也就是12小时来计算
- T = 30*24 #周期为30天 计算30天的总共小时数
- # t = N*T#只有t为T的整数倍就需要重发数据域自注册
- date_tmp = utime.localtime()
- time_tmp = utime.mktime(date_tmp)#获取时间戳
- if self.multimer_init == 1:#已注册过或者开机5分钟之内没有注册 或者注册成功就开始出发多日重发机制
- self.mulit_day_timesec = time_tmp+MULTI_DAY_RESEND_t#初始值多加12小时 #初始化t = 0.5天
- 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
- 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)#一分钟计时
-
- def multiDayResendTimer_Cb(self,*argc):#多日重发机制定时器回调函数
- T = 30*24*60*60
- date_tmp = utime.localtime()
- time_tmp = utime.mktime(date_tmp)+MULTI_DAY_RESEND_t#获取时间戳
-
- if time_tmp < self.mulit_day_timesec:#如果当前时间戳小于保存的时间戳
- self.mulit_day_timesec = time_tmp
- print("time_tmp: self.mulit_day_timesec:\r\n",time_tmp,self.mulit_day_timesec)
-
- if time_tmp - self.mulit_day_timesec >= MULTI_DAY_RESEND_T:#一个周期的时间到了重发注册一次
- network_state = eventMesh.publish("get_network_state")
- print("get_network_state:\r\n",network_state)
- if network_state == 0:#网络不正常就不需要重发了等下一个周期
- return
- result = self.telecom_regist_infor_init()#要自注册数据域信息发送完才初始化t
- if result == 0: #上报出错了
- return
- self.mulit_day_timesec = time_tmp+MULTI_DAY_RESEND_t # 重发后 初始化t = 0.5天
- 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分钟内检查是否有联网 有一次联网就关闭检查
- self.telecom_init_state = msg
-
- def get_telecom_init_state(self,event,msg):
- return self.telecom_init_state
-
- def get_dmp_power_timer_count(self,event,msg):#开机后限定5分钟内完成自注册
- return REGIST_POWER_ON_TIME
-
- def get_dmp_power_num(self,event,msg):#开机限定次数最多十次 十次不成功就等下一次开机 或者多日重发机制
- print("get_dmp_power_num:{}".format(self.timerPowerNum))
- return self.timerPowerNum
-
- def set_dmp_power_num(self,event,msg):
- print("set_dmp_power_num:{}".format(msg))
- self.timerPowerNum = msg
- def 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)
-
- def fun_cb(self,*argc):
- self.telecom_regeist_infor()#开机初始一次自注册信息
- pass
- def telecom_dmp_power_on_count(self):#开机计时判断最多十次
- if eventMesh.publish("get_telecom_init_state") != 1:#在开机五分钟之内只要一次联网正常就不需要再检查是否网络正常去自注册了
- if eventMesh.publish("get_dmp_power_num") < (eventMesh.publish("get_dmp_power_timer_count")*1000)/30000:#10+1
- num = eventMesh.publish("get_dmp_power_num") #开机计时 如果开机5分钟内没有一次网络正常的话 当前开机自注册不生效 等待下一次开机自注册触发 或者触发多日重发机制
- num+=1
- eventMesh.publish("set_dmp_power_num",num)#次数累计加一
- else:
- if self.power_on_multiflag == 1:
- return
- self.power_on_multiflag = 1
- self.multiple_day_resend()
- pass
-
-telecomDmpCb = telecomDmp()
-
-
-
-
-
-
-
-
-
-
-
-
#include "ConfigModelC.h"
#include "cywee_hal.h"
+#include "cat1_tcpServer.h"
+
namespace OHOS
{
/**************************************************************************************************** */
debugOutputItemInfo[index++] = {index, "hrs_ble_swtich"};
debugOutputItemInfo[index++] = {index, "save_runtime_log"};
+ // CAT1升级
+ debugOutputItemInfo[index++] = {index, "CAT1_UPDATA"};
debugOutputItemInfo[index++] = {index, "cwm_runtime_log"};
+
usedLen = index;
/* -------------------------------- Add data -------------------------------- */
//重启
NotificationManager::GetInstance()->StopNotify();
shutdown_reboot_prejobs(REBOOT_TYPE);
- } else {
+ }
+ else {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"组件不存在");
}
return true; //进行UI刷新
}
-
+ else if (viewId == "CAT1_UPDATA")
+ {
+ Cat1_OTA(CAT1_TCP_START_OTA);
+ }
else if (viewId == NEXTORPREPAGELABELBUTTON)
{
// std::string str;
}
break;
case 20:
+ if(toggleButtonOffline)
+ {
+ if(toggleButtonOffline->IsVisible() == false)
+ {
+ toggleButtonOffline->SetState(false);
+ toggleButtonOffline->SetViewId("CAT1_UPDATA");
+ toggleButtonOffline->SetVisible(true);
+ }
+ }
+ break;
+ case 21:
str = "";
if(toggleButtonOffline)
{
// Set additional property
char fail_str[128]={0};
- sprintf_s(fail_str,128,"OTA upgrade failed, try upgrade again, or repair %s",updata_fail_str);
+ sprintf_s(fail_str,128,"ota升级失败，请尝试重启设备");
label_->SetText(fail_str);
label_->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
label_->SetStyle(STYLE_TEXT_FONT, 30);
// Set additional property
- char fail_str[128]={0};
- sprintf_s(fail_str,128,"Do not perform any operation during the upgrade to ensure sufficient power supply %c",' ');
+
- label_->SetText(fail_str);
+ label_->SetText("4G模块OTA升级中，请勿操作，升级成功后会自动重启");
label_->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
label_->SetTextColor(Color::GetColorFromRGBA(0xAA, 0xAA, 0xAA, 0xff));
label_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
UIViewGroup_transmitting->Add(label_);
- //Add ImageView to App
+ // Add ImageView to App
- // if (transmitting_img == nullptr)
- // {
- // transmitting_img = new UIImageView();
- // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SystemUpdateView::KUMILOGOImage new fail!");
- // }
- // transmitting_img->SetPosition(193, 150,80, 80);
- // const char *imagesPath = TRANSMITTING_FAIL_PATH;
- // transmitting_img->SetSrc(imagesPath);
- // UIViewGroup_transmitting->Add(transmitting_img);
+ if (transmitting_img == nullptr)
+ {
+ transmitting_img = new UIImageView();
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SystemUpdateView::KUMILOGOImage new fail!");
+ }
+ transmitting_img->SetPosition(193, 150,80, 80);
+ const char *imagesPath = TRANSMITTING_FAIL_PATH;
+ transmitting_img->SetSrc(imagesPath);
+ UIViewGroup_transmitting->Add(transmitting_img);
}
from usr.EventMesh import eventMesh
-from usr.telecom_dmp import telecomDmpCb
-from usr.china_mobile_dmp import chinamobileCb
+# from usr.telecom_dmp import telecomDmpCb
+# from usr.china_mobile_dmp import chinamobileCb
+
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+clog = log.getLogger("cat1")
def msg_cb(args):
index = args[1]
CAT1_SERVICE_HEAD = 'FE' #固定head
PROJECT_NAME = "Cat1SlipUDPService"
-PROJECT_VERSION = "PY_SRV_V16"
+PROJECT_VERSION = "PY_SRV_V18"
CONFIG_JSON="/usr/system_config.json"
CURRENT_APP_TYPE="pysrv"
-
-# 设置日志输出级别
-log.basicConfig(level=log.INFO)
-cat1service_log = log.getLogger("cat1service")
-
#设置通话音量
voiceCall.setVolume(10)
-print("voice call volume {}".format(voiceCall.getVolume()))
+#clog.info("voice call volume {}".format(voiceCall.getVolume()))
# lpm_fd = pm.create_wakelock("system_lock", len("system_lock"))
pm.autosleep(1)
# pm.wakelock_lock(lpm_fd)
-cat1service_log.info("create_wakelock {}".format(pm.get_wakelock_num()))
+#clog.info("create_wakelock {}".format(pm.get_wakelock_num()))
telecomTimerCount = 0
def get_versionkeyname_by_py(app_type):
return str("{}version".format(app_type))
config_data = ql_fs.read_json(CONFIG_JSON)
config_data.update( {str(get_versionkeyname_by_py(app_type)):keyvalue})
ql_fs.touch(CONFIG_JSON, config_data)
- cat1service_log.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
- cat1service_log.info("{}".format(config_data))
+ #clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+ #clog.info("{}".format(config_data))
def get_version_from_json_config(app_type):
config_data = ql_fs.read_json(CONFIG_JSON)
keyvalue = config_data.get( get_versionkeyname_by_py(app_type),get_default_versionvalue_by_py(app_type))
- cat1service_log.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+ #clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
return keyvalue
set_version_to_json_config(CURRENT_APP_TYPE,PROJECT_VERSION)
# level - 引脚电平，int类型，0 - 设置引脚为低电平, 1- 设置引脚为高电平。
# recvDataPin = Pin(Pin.GPIO22, Pin.IN, Pin.PULL_PU, 0)
def ExtIntfun(args):
- # cat1service_log.info('### interrupt {} ###'.format(args)) # args[0]:gpio号 args[1]:上升沿或下降沿
+ # #clog.info('### interrupt {} ###'.format(args)) # args[0]:gpio号 args[1]:上升沿或下降沿
if args[1] == 0:
- cat1service_log.info("disable autosleep")
+ #clog.info("disable autosleep")
pm.autosleep(0)
# pm.wakelock_lock(lpm_fd)
elif args[1] == 1:
- cat1service_log.info("enable autosleep")
+ #clog.info("enable autosleep")
# pm.wakelock_unlock(lpm_fd)
pm.autosleep(1)
- # cat1service_log.info("recvDataPin={}".format(recvDataPin.read()))
+ # #clog.info("recvDataPin={}".format(recvDataPin.read()))
extint = ExtInt(ExtInt.GPIO22, ExtInt.IRQ_RISING_FALLING, ExtInt.PULL_DISABLE, ExtIntfun)
extint.enable()
UDP_MSG_REPLY = 'F' # 返回值
-
-def result(args):
- print('download status:',args[0],'download process:',args[1])
-def download_fota_img( srcurl ):
- fota_obj = fota() # 创建Fota对象
- cat1service_log.info("httpDownload... {} , {}".format("{}/dfota_1.bin".format(srcurl),"{}/dfota_2.bin".format(srcurl)))
- res = fota_obj.httpDownload(url1="{}/dfota_1.bin".format(srcurl),url2="{}/dfota_2.bin".format(srcurl),callback=result)
- #差分升级FTP方式
- #res = fota_obj.httpDownload(url1="ftp://user:password@ip:port/fota.bin",callback=result) #其中user,password,ip,port需要填写具体使用的FTP服务器信息
- if res != 0:
- cat1service_log.error("httpDownload error")
-
-def check_fota():
- modem_ver = modem.getDevFwVersion()
- imei = modem.getDevImei()
- url = "http://icfota.snicker.com.cn:8089/fd230ota.jsp?product=FD230&pkgver={0}&imei={1}".format(modem_ver,imei)
- response = request.get(url)
- cat1service_log.info(url)
- data = response.json()
- if(data['UptoDate'] == False):
- cat1service_log.info("Need update python application")
- srcurl = data['url']
- #差分升级方式
- # res = fota_obj.httpDownload(url1="http://www.example.com/fota.bin",callback=result)
- # mini fota方式
- return srcurl
- else:
- cat1service_log.info("No need update python application")
- return ""
-
class Cat1Service:
AP = 0 # SLIP_INNER
STA = 1 # SLIP_OUTER
# self.__value = None
self.__wait_resp = 0
self.__waiting_netstat = 0
- # slip.destroy()
- # print('slip uart={0}'.format (self.__uart))
-
- # ret = slip.construct(self.__uart, self.__mode, 0)
- # if ret != 0:
- # print('slip netif construct fail')
- # return None
- print('slip network card create success')
+ slip.destroy()
+ #clog.info('slip uart={0}'.format (self.__uart))
+
+ ret = slip.construct(self.__uart, self.__mode, 0)
+ if ret != 0:
+ clog.error('slip netif construct fail')
+ return None
+ #clog.info('slip network card create success')
# self.__queue = Queue(1)
self.__sock = self.__socket_init()
self.__threadid = _thread.start_new_thread(self.__Socket_Thread, ())
self.send_data_q = Queue(100)
self.ack_sem=0
_thread.start_new_thread(self.Socket_SEND_Thread,())
-
- # 发数据线程
-
-
-
+ # 发数据线程
return None
def __socket_init(self):
# 绑定IP
bind_addr = ('172.16.1.2', 5000)
sock.bind(bind_addr)
- sock.settimeout(10)
+ sock.settimeout(None)
return sock
def __socket_reinit(self):
# cell_data = hex(cmd_tmp)
# decimal_number = int(cell_data, 16)
# cmd = "%02x"%(decimal_number) # 使用两位表示，不足前面补0
- print(cmd) # 输出: 07
- print("btmcu_cmd_handler cmd {0} , args {1}".format(cmd,parm))
+ #clog.info(cmd) # 输出: 07
+ #clog.info("btmcu_cmd_handler cmd {0} , args {1}".format(cmd,parm))
if cmd == "00":
- print(cmd)
+ #clog.info(cmd)
# UDP_CMD_GET_CAT1VER
modem_ver = modem.getDevFwVersion()
self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
ret = voiceCall.callStart(str(parm))
# if ret != 0:
# ret = voiceCall.callStart(str(parm))
- print("ret={} {} {}".format(ret,cmd,parm))
+ #clog.info("ret={} {} {}".format(ret,cmd,parm))
if ret != 0:
self.reply_cmd('0F',"callcmd_fail")
else:
else:
self.reply_cmd('0F',"callcmd_fail")
elif cmd == "02":
- print(cmd)
+ #clog.info(cmd)
# UDP_CMD_HUNGUP
ret = voiceCall.callEnd()
if ret != 0:
else:
self.reply_cmd('0F',"callend_success")
elif cmd == "03":
- print(cmd)
+ #clog.info(cmd)
# UDP_CMD_ANSWER
ret = voiceCall.callAnswer()
if ret != 0:
else:
self.reply_cmd('0F',"callanswer_success")
elif cmd == "04":
- print(cmd)
- result = check_fota()
- if result == "":
- self.reply_cmd('04',"no need update!")
- else:
- self.reply_cmd('04',"start ota {} please wait...".format(result))
- download_fota_img(result)
+ clog.info(cmd)
elif cmd == "05":
- print(cmd)
+ clog.info(cmd)
# UDP_CMD_SEND_SMS
elif cmd == "06":
- print(cmd)
+ #clog.info(cmd)
# UDP_CMD_GET_TIME
time=utime.localtime()
zone=utime.getTimeZone()
#(2024, 3, 2, 18, 31, 32, 5, 62),8
# 返回当前时间戳，参数为元组
# timestamp = utime.mktime(time)
- # cat1service_log.info(timestamp)
+ # #clog.info(timestamp)
self.reply_cmd('06',"{0}@{1}".format(time,zone))
elif cmd == "07":
- print("cmd ==== 07!")
+ #clog.info("cmd ==== 07!")
# UDP_CMD_GET_RECV_NETWORKSTAT
simstat = sim.getStatus()
imei = modem.getDevImei()
# ([voice_state, voice_lac, voice_cid, voice_rat, voice_reject_cause, voice_psc], [data_state, data_lac, data_cid, data_rat, data_reject_cause, data_psc])
operator = net.operatorName()
signal = net.csqQueryPoll()
- print("imei:{0},sim:{1},oper:{2},signal:{3},net:{4}".format(imei,simstat,operator,signal,netstat))
+ #clog.info("imei:{0},sim:{1},oper:{2},signal:{3},net:{4}".format(imei,simstat,operator,signal,netstat))
self.reply_cmd('07',"imei:{0}@sim:{1}@oper:{2}@signal:{3}@net:{4}".format(imei,simstat,operator,signal,netstat))
elif cmd == "09":
- print("{},{}".format(cmd,parm))
+ #clog.info("{},{}".format(cmd,parm))
# UDP_CMD_ATCMD
# net.setModemFun(0)
# net.setModemFun(1)
resp=bytearray(50)
ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10)
if ret == 0:
- print("reply:{},ret:{}".format(resp.decode(),ret))
+ #clog.info("reply:{},ret:{}".format(resp.decode(),ret))
self.reply_cmd('09',"{}".format(resp.decode()))
else:
- print("cmd error ret:{}".format(ret))
+ #clog.info("cmd error ret:{}".format(ret))
self.reply_cmd('09',"{}".format("at error"))
elif cmd == "10" or cmd == "12" or cmd == "14": #获取固件版本号或者获取BT保存的SIM卡的ICCID BLE那边是否开启电信入库功能
pass
elif cmd == "13":
on = int(parm)
- print("set_dmp_change_mode on:{}".format(on))
+ #clog.info("set_dmp_change_mode on:{}".format(on))
eventMesh.publish("set_dmp_change_mode",on)
elif cmd == "16":
if cmd == "10":
self.software_version = str(parm)
eventMesh.publish("set_dev_version",self.software_version)
- print("software_version:{},{}".format(self.software_version,parm))
+ #clog.info("software_version:{},{}".format(self.software_version,parm))
elif cmd == "12":
pass
elif cmd == "14":#
if cmd == "10":
self.software_version = str(parm)
eventMesh.publish("set_dev_version",self.software_version)
- print("software_version:{},{}".format(self.software_version,parm))
+ #clog.info("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))
+ #clog.info("parm:{}\r\n".format(parm))
pass
def get_factory_status(self,event,msg):
def delete_sms_cb(self,*argc):
eventMesh.publish_async("remove_all_sms_cb","",1*1024)
def remove_all_sms_cb(self, event, msg):
- print("remove_all_sms_cb\r\n")
+ #clog.info("remove_all_sms_cb\r\n")
msg_nums = sms.getMsgNums() #短信数量
if msg_nums == -1:
msg_nums = 0
sms_data = sms.getSaveLoc()
- print("{}\r\n".format(sms_data))
+ #clog.info("{}\r\n".format(sms_data))
if sms_data == -1:
return
sms_max = sms_data[0][2] #最大存储短信数量
if sms_data == -1:
return
sms_max = sms_data[0][2] #最大存储短信数量
- print("recv:{}".format(int(msg)))
+ #clog.info("recv:{}".format(int(msg)))
message=self.sms_get_message_info(int(msg))
if message == -1: #说明没有这条短信
return
SMS_lis={}
SMS_lis_count = 0
sms_data = sms.getSaveLoc()
- print(sms_data)
+ #clog.info(sms_data)
if sms_data == -1:
return
sms_max = sms_data[0][2]#最大存储短信数量
- print(sms_max)
+ #clog.info(sms_max)
self.msg_nums = sms.getMsgNums()
if self.msg_nums_old != self.msg_nums:
self.send_data = []
count = len(self.send_data)
for i in range(count):
text = self.send_data[i]
- print("text:{} {} {}\r\n".format(text[0],text[1],text[2]))
+ #clog.info("text:{} {} {}\r\n".format(text[0],text[1],text[2]))
msg_total = "@code:"+str(text[0])+"@totalcodenum:"+str(text[1])+"@currcodeid:"+str(text[2])+"@data:"+str(text[3])
self.reply_cmd('17',msg_total)
stage, state = checkNet.waitNetworkReady(30)
# pm.wakelock_unlock(lpm_fd)
if stage == 3 and state == 1:
- print('Network connection successful.')
+ #clog.info('Network connection successful.')
self.set_network_config()
self.__net_connected = 1
eventMesh.publish("set_network_state",self.__net_connected)
self.__waiting_netstat = 0
return 0
else:
- print('Network connection failed, stage={}, state={}'.format(stage, state))
+ #clog.info('Network connection failed, stage={}, state={}'.format(stage, state))
self.reset_network_config()
self.__net_connected = 0
eventMesh.publish("set_network_state",self.__net_connected)
def reply_cmd(self,cmd,_timesync):
try :
- print('reply_cmd 1')
+ #clog.info('reply_cmd 1')
self.clear_remain()
message = str(_timesync)
- print('reply_cmd 2')
+ #clog.info('reply_cmd 2')
self.__Socket_UDP_noreply(cmd, message)
except:
- print('reply_cmd')
+ clog.info('reply_cmd')
return 0
def clear_remain(self):
def reset_network_config(self):
if (self.__net_connected == 0):
- print("skip reset_network_config")
+ #clog.info("skip reset_network_config")
return 0
Info = dataCall.getInfo(1,0)
- print("Info{}".format(Info))
+ #clog.info("Info{}".format(Info))
default_NIC_ip = Info[2][2] # 假设默认网卡ip地址为10.10.1.1，请根据实际情况更改
segment_ip = '172.16.4.0' # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255]，请根据实际情况更改
mask = '255.255.255.0' # 假设子网掩码为255.255.255.0，请根据实际情况更改
# 配置默认网卡，通过默认网卡进行网络转发
cat1service.set_default_NIC(default_NIC_ip)
- print("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
+ #clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
#添加路由规则，只有该网段IP才进行转发
cat1service.router_add(segment_ip, mask)
if (self.__net_connected == 1) :
- print("skip set_network_config")
+ #clog.info("skip set_network_config")
return 0
Info = dataCall.getInfo(1,0)
- print("Info{}".format(Info))
+ #clog.info("Info{}".format(Info))
default_NIC_ip = Info[2][2] # 假设默认网卡ip地址为10.10.1.1，请根据实际情况更改
segment_ip = '172.16.1.0' # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255]，请根据实际情况更改
mask = '255.255.255.0' # 假设子网掩码为255.255.255.0，请根据实际情况更改
# 配置默认网卡，通过默认网卡进行网络转发
cat1service.set_default_NIC(default_NIC_ip)
- print("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
+ #clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
#添加路由规则，只有该网段IP才进行转发
cat1service.router_add(segment_ip, mask)
if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#电信入库功能 不使用设置 0 防止两边不同步修改
if eventMesh.publish("get_dmp_change_mode") == 1:
eventMesh.publish("set_network_state",1)
- telecomDmpCb.telecom_dmp_power_on_init()
+ # telecomDmpCb.telecom_dmp_power_on_init()
if 1: #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()
+ # chinamobileCb.china_mobile_init()
def cat1_reply_iccid_to_ble(self,event,msg):
ICCID_DATA = str("ICCID:")+str(msg)
# self.head = head
# self.content = content
if len(content) == 0 or len(content) > 9999 or len(head) != 2:
- print('illegal pack tlv content')
+ clog.error('illegal pack tlv content')
return -1
len_str ='%04d' % len(content)
tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content
return tlv_pack
# 解码tlv数据包
def __unpack_tlv_format(self, msg):
- print('__unpack_tlv_format {}\r\n'.format(msg))
+ #clog.info('__unpack_tlv_format {}\r\n'.format(msg))
self.msg = str(msg)[2:]#这是去除head FE
tag = self.msg[0:2]
length = self.msg[2:6]
value = self.msg[6:]
len_str ='%04d' % len(value)
if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != self.msg[2:6]:
- print('__unpack_tlv_format err')
+ clog.error('__unpack_tlv_format err')
return -1
- print('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
+ #clog.info('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
unpack = (tag,length,value)
return unpack
# socket通信(UDP)模块
def Socket_SEND_Thread(self):
while True:
try:
- print("send====")
+ #clog.info("send====")
data=self.send_data_q.get()
self.ack_sem=1
# # if data[2]:
self.__Socket_UDP_write( data[0], data[1])
- print("Socket_SEND_Thread data:{} {}".format(data[0],data[1]))
+ #clog.info("Socket_SEND_Thread data:{} {}".format(data[0],data[1]))
count=20
while count & self.ack_sem :
# else :
self.__Socket_UDP_write( data[0], data[1])
- print("Socket_SEND_Thread while data:{} {}".format(data[0],data[1]))
+ #clog.info("Socket_SEND_Thread while data:{} {}".format(data[0],data[1]))
if data:
- print("data ok!!")
+ clog.info("data ok!!")
else:
- print("data error!!")
+ clog.error("data error!!")
except Exception :
- print("sned Socket >>>")
+ clog.error("sned Socket >>>")
def __Socket_UDP_write(self, head, content):
try:
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
- print("__Socket_UDP send msg {}".format(msg))
+ #clog.info("__Socket_UDP send msg {}".format(msg))
self.__err = 0
self.__sock.sendto(msg,server_addr)
- print("__Socket_UDP send 2")
+ #clog.info("__Socket_UDP send 2")
self.__wait_resp = 1
# data = self.__queue.get()
self.__wait_resp = 0
# return data
return 1
except Exception as error:
- print(error)
+ clog.error(error)
return 0
def __Socket_UDP_noreply(self, head, content):
# 向服务端发送消息
server_addr = ('172.16.1.5',1000)
- print("__Socket_UDP_noreply send msg {}".format(msg))
+ #clog.info("__Socket_UDP_noreply send msg {}".format(msg))
self.__err = 0
data_size = self.__sock.sendto(msg,server_addr)
- print("self.__sock data_size {}".format(data_size))
+ #clog.info("self.__sock data_size {}".format(data_size))
self.__wait_resp = 0
return 0
def __Socket_Thread(self):
while True:
try:
- print("recv====")
+ #clog.info("recv====")
data=self.__sock.recv(1024)
- print("data:{}".format(data))
+ #clog.info("data:{}".format(data))
if data:
value = self.__unpack_tlv_format(data.decode())
if value != -1:
- print('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2]))
+ #clog.info('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2]))
if value[1] == 'FF':
self.btmcu_cmd_handler(value[0],value[2])
else:
# self.__value = value
# self.__queue.put('1')
self.btmcu_cmd_handler(value[0],value[2])
- print("End else Thread")
+ #clog.info("End else Thread")
else:
- print("data error!!")
+ clog.error("data error!!")
except Exception as recverr:
- print("recverr:{}\r\n".format(recverr))
+ clog.error("recverr:{}\r\n".format(recverr))
if "110" in str(recverr):
self.__err = 1
# if self.__wait_resp == 1:
- print("End Socket Thread")
+ #clog.info("End Socket Thread")
# UDP_CMD_GET_TIME = '6', // 获取Cat1 时间 ，YYYYMMDD HHmmss zone
# UDP_CMD_GET_NETWORKSTAT = '7', //获取Cat1 信号信息，VOLTE信息，信号强度，SIM卡状态
# 下文进行系统配置
-print("Cat1Service start")
+#clog.info("Cat1Service start")
cat1service = Cat1Service()
#voice call callback function
def voice_callback(args):
if args[0] == 10:
- print('voicecall incoming call, PhoneNO: ', args[6])
+ #clog.info('voicecall incoming call, PhoneNO: ', args[6])
if eventMesh.publish("get_volte_switch") == 0: #关闭VOLTE功能
- print('voicecall auto end:')
+ #clog.info('voicecall auto end:')
voiceCall.callEnd()
else:
# gpioWakeBT.write(1)
cat1service.notifyIncomingcall(args[6])
elif args[0] == 11:
if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
- print('voicecall connected, PhoneNO: ', args[6])
+ #clog.info('voicecall connected, PhoneNO: ', args[6])
cat1service.notifyConnecteCall(args[6])
elif args[0] == 12:
- print('voicecall disconnect')
+ #clog.info('voicecall disconnect')
if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
- print('voicecall disconnected, PhoneNO: ', args[6])
+ #clog.info('voicecall disconnected, PhoneNO: ', args[6])
cat1service.notifyDisconnectCall(args[6])
elif args[0] == 13:
- print('voicecall is waiting, PhoneNO: ', args[6])
+ clog.info('voicecall is waiting, PhoneNO: ', args[6])
elif args[0] == 14:
- print('voicecall dialing, PhoneNO: ', args[6])
+ clog.info('voicecall dialing, PhoneNO: ', args[6])
elif args[0] == 15:
- print('voicecall alerting, PhoneNO: ', args[6])
+ clog.info('voicecall alerting, PhoneNO: ', args[6])
elif args[0] == 16:
- print('voicecall holding, PhoneNO: ', args[6])
+ clog.info('voicecall holding, PhoneNO: ', args[6])
else:
- print('voice_callback , args[0]: ', args[0])
+ clog.info('voice_callback , args[0]: ', args[0])
#电话消息反馈
voiceCall.setCallback(voice_callback)
def checknet_cb(arg):
- print("start checktime!!")
- if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次
- if eventMesh.publish("get_dmp_change_mode") == 1:
- telecomDmpCb.telecom_dmp_power_on_count()
+ #clog.info("start checktime!!")
+ # if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次
+ # if eventMesh.publish("get_dmp_change_mode") == 1:
+ # telecomDmpCb.telecom_dmp_power_on_count()
_thread.start_new_thread(cat1service.wait_network_ready, ())
# time=utime.localtime()
delaybootupmsg_timer.start(1000,0,bootupmsg_cb)
# def checkpin_cb(arg):
-# cat1service_log.info("recvDataPin={}".format(recvDataPin.read()))
+# #clog.info("recvDataPin={}".format(recvDataPin.read()))
# timerCheckRevPin = osTimer()
# timerCheckRevPin.start(1000,1,checkpin_cb)
--- /dev/null
+# Copyright (c) Quectel Wireless Solution, Co., Ltd.All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+# net.getNetMode()
+# (0, '460', '11', 7)
+
+# net.getSignal(1)
+# ([99, 99, 255, 255], [-84, -117, -15, 255, -3])
+
+# net.nitzTime()
+# ('24/02/26 11:17:42 8 0', 1708946262, 0)
+
+
+import usocket
+import log
+import utime
+import slip
+import audio
+from machine import UART
+import _thread
+from queue import Queue
+from machine import Pin
+from machine import ExtInt
+import dataCall
+import voiceCall
+import net
+import uping
+import example
+import osTimer
+import sim
+import modem
+import utime
+import checkNet
+import atcmd
+import fota
+import request
+import ql_fs
+import pm
+import sms
+
+from usr.EventMesh import eventMesh
+
+# from usr.telecom_dmp import telecomDmpCb
+# from usr.china_mobile_dmp import chinamobileCb
+
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+clog = log.getLogger("cat1")
+
+def msg_cb(args):
+ index = args[1]
+ storage = args[2]
+ sms_data = sms.getSaveLoc()
+ if sms_data == -1:
+ return
+ sms_max = sms_data[0][2]
+ if index != -1:
+ eventMesh.publish("send_singal_data_toBle",index)
+
+ if index >= sms_max-1:#删除短信
+ eventMesh.publish("delete_sms_event")#删除短信
+
+sms.setCallback(msg_cb)#sms注册回调
+
+CAT1_SERVICE_HEAD = 'FE' #固定head
+
+PROJECT_NAME = "Cat1SlipUDPService"
+PROJECT_VERSION = "PY_SRV_V17"
+CONFIG_JSON="/usr/system_config.json"
+CURRENT_APP_TYPE="pysrv"
+
+
+
+
+
+
+#设置通话音量
+voiceCall.setVolume(10)
+clog.info("voice call volume {}".format(voiceCall.getVolume()))
+lpm_fd = pm.create_wakelock("system_lock", len("system_lock"))
+# pm.autosleep(1)
+pm.wakelock_lock(lpm_fd)
+clog.info("create_wakelock {}".format(pm.get_wakelock_num()))
+telecomTimerCount = 0
+def get_versionkeyname_by_py(app_type):
+ return str("{}version".format(app_type))
+
+def get_default_versionvalue_by_py(app_type):
+ if (app_type == "pymain"):
+ return "PY_MAIN_V2"
+ elif (app_type == "pyota"):
+ return "PY_OTA_V14"
+ elif (app_type == "pysrv"):
+ return "PY_SRV_V16"
+
+#如果没有configfile则创建它
+if not ql_fs.path_exists(CONFIG_JSON):
+ data = {str(get_versionkeyname_by_py(CURRENT_APP_TYPE)):get_default_versionvalue_by_py(CURRENT_APP_TYPE)}
+ ql_fs.touch(CONFIG_JSON,data)
+
+def set_version_to_json_config(app_type,keyvalue):
+ try :
+ config_data = ql_fs.read_json(CONFIG_JSON)
+ config_data.update( {str(get_versionkeyname_by_py(app_type)):keyvalue})
+ ql_fs.touch(CONFIG_JSON, config_data)
+ clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+ clog.info("{}".format(config_data))
+ except Exception as e:
+ clog.error("set_version_to_json_config")
+
+def get_version_from_json_config(app_type):
+ config_data = ql_fs.read_json(CONFIG_JSON)
+ keyvalue = config_data.get( get_versionkeyname_by_py(app_type),get_default_versionvalue_by_py(app_type))
+ clog.info("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+ return keyvalue
+
+set_version_to_json_config(CURRENT_APP_TYPE,PROJECT_VERSION)
+
+
+audio.set_qdai_cfg(1,0,0,1,0,0,1,1)
+
+# GPIO21 - 引脚 86 KP_MKOUT1 唤醒主控
+# GPIO22 - 引脚 87 KP_MKIN 被主控唤醒
+
+# GPIOn - GPIO号，int类型，点此查看GPIO引脚编号与物理引脚的映射关系。
+
+# direction - 输入输出模式，int类型，IN - 输入模式，OUT - 输出模式。
+
+# pullMode - 上下拉模式，int类型，说明如下：
+# PULL_DISABLE - 浮空模式
+# PULL_PU - 上拉模式
+# PULL_PD - 下拉模式
+
+# level - 引脚电平，int类型，0 - 设置引脚为低电平, 1- 设置引脚为高电平。
+# recvDataPin = Pin(Pin.GPIO22, Pin.IN, Pin.PULL_PU, 0)
+def ExtIntfun(args):
+ # clog.info('### interrupt {} ###'.format(args)) # args[0]:gpio号 args[1]:上升沿或下降沿
+ if args[1] == 0:
+ clog.info("disable autosleep")
+ # pm.autosleep(0)
+ pm.wakelock_lock(lpm_fd)
+ elif args[1] == 1:
+ clog.info("enable autosleep")
+ pm.wakelock_unlock(lpm_fd)
+ # pm.autosleep(1)
+ # clog.info("recvDataPin={}".format(recvDataPin.read()))
+extint = ExtInt(ExtInt.GPIO22, ExtInt.IRQ_RISING_FALLING, ExtInt.PULL_DISABLE, ExtIntfun)
+extint.enable()
+
+
+# 创建gpio对象
+gpioWakeBT = Pin(Pin.GPIO21, Pin.OUT, Pin.PULL_DISABLE, 1)
+# 设置输入输出模式
+gpioWakeBT.set_dir(Pin.OUT)
+
+# 设置引脚电平
+gpioWakeBT.write(0)
+
+UDP_CMD_GET_CAT1VER = '0' #获取 Cat1 版本号
+UDP_CMD_DIAL_NUMB = '1' #拨打电话
+UDP_CMD_HUNGUP = '2' #挂断电话
+UDP_CMD_ANSWER = '3' #接听电话
+UDP_CMD_CAT1_OTA_UPDATE = '4' #触发Cat1 OTA升级，mcu提供url
+UDP_CMD_SEND_SMS = '5' #发送SMS短信，mcu提供电话号及短信内容
+UDP_CMD_GET_TIME = '6' #获取Cat1 时间 ，YYYYMMDD HHmmss zone
+UDP_CMD_GET_RECV_NETWORKSTAT = '7' #获取Cat1 信号信息，VOLTE信息，信号强度，SIM卡状态 // 内容同UDP_CMD_GET_NETWORKSTAT，CAT主动发给MCU
+UDP_MSG_SMS = '8' # CAT1接收到的SMS信息给MCU，包含电话号及短信内容
+UDP_CMD_ATCMD = '9' # 执行AT指令
+UDP_MSG_CALL_CONNECTED = 'A' # CAT1 电话接听消息
+UDP_MSG_CALL_DISCONNECTED = 'B' # CAT1 电话挂断消息
+UDP_MSG_COMMING_CALL = 'C' # CAT1 来电消息，包含电话号
+UDP_MSG_REPLY = 'F' # 返回值
+
+
+class Cat1Service:
+ AP = 0 # SLIP_INNER
+ STA = 1 # SLIP_OUTER
+
+ def __init__(self, uart=UART.UART4, mode=AP):
+
+ self.__uart = uart
+ self.__mode = mode
+ self.__message = ''
+ self.__err = 0
+ self.__net_connected = 0
+ # self.__value = None
+ self.__wait_resp = 0
+ self.__waiting_netstat = 0
+ slip.destroy()
+ clog.info('slip uart={0}'.format (self.__uart))
+
+ ret = slip.construct(self.__uart, self.__mode, 0)
+ if ret != 0:
+ clog.error('slip netif construct fail')
+ return None
+ clog.info('slip network card create success')
+ # self.__queue = Queue(1)
+ self.__sock = self.__socket_init()
+ self.__threadid = _thread.start_new_thread(self.__Socket_Thread, ())
+ self.telecom_init_flag = 0
+ self.telecomTimer = osTimer()
+ 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 = ""
+ self.deletSmsTimer = osTimer()
+
+ self.volte_switch = 1 #默认是开启VOLTE通话功能
+ 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.subscribe("send_dmp_cm_address_toBLE",self.send_dmp_cm_address_toBLE)
+ eventMesh.subscribe("set_volte_switch",self.set_volte_switch)
+ eventMesh.subscribe("get_volte_switch",self.get_volte_switch)
+ eventMesh.publish("delete_sms_event")
+
+
+ self.telecom_dmp_switch = 0
+
+ self.send_data = []
+ self.code_old = 0
+ self.code_old_num = 1
+ self.tmp_data = []
+ self.total_num = 0
+ #
+ self.msg_nums = 0
+ self.msg_nums_old = 0
+ self.china_mobile_init = 0
+ self.factory_status = 0
+ self.send_data_q = Queue(100)
+ self.ack_sem=0
+ _thread.start_new_thread(self.Socket_SEND_Thread,())
+ # 发数据线程
+ return None
+
+ def __socket_init(self):
+ # 创建一个socket实例
+ sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT)
+ sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
+ # 绑定IP
+ bind_addr = ('172.16.1.2', 5000)
+ sock.bind(bind_addr)
+ sock.settimeout(None)
+ return sock
+
+ def __socket_reinit(self):
+ return self.__socket_init()
+
+ def bootup_msg_to_bt(self):
+ modem_ver = modem.getDevFwVersion()
+ self.reply_cmd('0F',"BOOTUP@pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
+ self.reply_cmd('0F',"VOLUME:{}".format(voiceCall.getVolume()))
+
+ def btmcu_cmd_handler(self,cmd,parm):
+
+ # cmd = ""
+ # cmd_tmp= int(cmd_data)#将十进制数转换成int 再转换成十六进制
+ # cell_data = hex(cmd_tmp)
+ # decimal_number = int(cell_data, 16)
+ # cmd = "%02x"%(decimal_number) # 使用两位表示，不足前面补0
+ clog.info(cmd) # 输出: 07
+ clog.info("btmcu_cmd_handler cmd {0} , args {1}".format(cmd,parm))
+ if cmd == "00":
+ clog.info(cmd)
+ # UDP_CMD_GET_CAT1VER
+ modem_ver = modem.getDevFwVersion()
+ self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
+ elif cmd == "01":
+ # UDP_CMD_DIAL_NUMB
+ if eventMesh.publish("get_volte_switch") == 1: #只有BLE开了VOLTE才允许打电话
+ ret = voiceCall.callStart(str(parm))
+ # if ret != 0:
+ # ret = voiceCall.callStart(str(parm))
+ clog.info("ret={} {} {}".format(ret,cmd,parm))
+ if ret != 0:
+ self.reply_cmd('0F',"callcmd_fail")
+ else:
+ self.reply_cmd('0F',"callcmd_success")
+ else:
+ self.reply_cmd('0F',"callcmd_fail")
+ elif cmd == "02":
+ clog.info(cmd)
+ # UDP_CMD_HUNGUP
+ ret = voiceCall.callEnd()
+ if ret != 0:
+ ret = voiceCall.callEnd()
+ if ret != 0:
+ self.reply_cmd('0F',"callend_fail")
+ else:
+ self.reply_cmd('0F',"callend_success")
+ elif cmd == "03":
+ clog.info(cmd)
+ # UDP_CMD_ANSWER
+ ret = voiceCall.callAnswer()
+ if ret != 0:
+ ret = voiceCall.callAnswer()
+ if ret != 0:
+ self.reply_cmd('0F',"callanswer_fail")
+ else:
+ self.reply_cmd('0F',"callanswer_success")
+ elif cmd == "04":
+ clog.info(cmd)
+ elif cmd == "05":
+ clog.info(cmd)
+ # UDP_CMD_SEND_SMS
+ elif cmd == "06":
+ clog.info(cmd)
+ # UDP_CMD_GET_TIME
+ time=utime.localtime()
+ zone=utime.getTimeZone()
+ #(2024, 3, 2, 18, 31, 32, 5, 62),8
+ # 返回当前时间戳，参数为元组
+ # timestamp = utime.mktime(time)
+ # clog.info(timestamp)
+ self.reply_cmd('06',"{0}@{1}".format(time,zone))
+ elif cmd == "07":
+ clog.info("cmd ==== 07!")
+ # UDP_CMD_GET_RECV_NETWORKSTAT
+ simstat = sim.getStatus()
+ imei = modem.getDevImei()
+ netstat = "0,10,0,10"
+ netstat_ = net.getState()
+ if netstat_ != -1 :
+ netstat = "{},{},{},{}".format(netstat_[0][0],netstat_[0][3],netstat_[1][0],netstat_[1][3])
+ # ([voice_state, voice_lac, voice_cid, voice_rat, voice_reject_cause, voice_psc], [data_state, data_lac, data_cid, data_rat, data_reject_cause, data_psc])
+ operator = net.operatorName()
+ signal = net.csqQueryPoll()
+ clog.info("imei:{0},sim:{1},oper:{2},signal:{3},net:{4}".format(imei,simstat,operator,signal,netstat))
+ self.reply_cmd('07',"imei:{0}@sim:{1}@oper:{2}@signal:{3}@net:{4}".format(imei,simstat,operator,signal,netstat))
+ elif cmd == "09":
+ clog.info("{},{}".format(cmd,parm))
+ # UDP_CMD_ATCMD
+ # net.setModemFun(0)
+ # net.setModemFun(1)
+ resp=bytearray(50)
+ ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10)
+ if ret == 0:
+ clog.info("reply:{},ret:{}".format(resp.decode(),ret))
+ self.reply_cmd('09',"{}".format(resp.decode()))
+ else:
+ clog.info("cmd error ret:{}".format(ret))
+ self.reply_cmd('09',"{}".format("at error"))
+
+ elif cmd == "10" or cmd == "12" or cmd == "14": #获取固件版本号或者获取BT保存的SIM卡的ICCID BLE那边是否开启电信入库功能
+ if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1 :
+ if eventMesh.publish("get_dmp_change_mode") == 1:
+ self.telecom_recv_cmd(cmd,parm)
+ else:
+ pass
+
+ if 1:#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":
+ on = int(parm)
+ clog.info("set_dmp_change_mode on:{}".format(on))
+ eventMesh.publish("set_dmp_change_mode",on)
+
+ elif cmd == "16":
+ if 1: #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))
+ elif cmd == "18":
+ eventMesh.publish("set_dmp_cm_address",str(parm))
+ elif cmd == "19": #DTMF功能
+ voiceCall.startDtmf(str(parm),100) #100ms 持续时间 100-1000
+ elif cmd == "1A":
+ eventMesh.publish("set_volte_switch",int(parm))
+ elif cmd == "AC":#
+ if self.ack_sem==1:
+ self.ack_sem=0
+
+ def telecom_recv_cmd(self,cmd,parm):
+ if cmd == "10":
+ self.software_version = str(parm)
+ eventMesh.publish("set_dev_version",self.software_version)
+ clog.info("software_version:{},{}".format(self.software_version,parm))
+ elif cmd == "12":
+ pass
+ elif cmd == "14":#
+ pass
+
+
+ pass
+
+ def set_volte_switch(self,event,msg): #设置VOLTE开关
+ self.volte_switch = int(msg)
+
+
+ def get_volte_switch(self,event,msg): #获取VOLTE开关
+
+ return self.volte_switch
+
+
+ def china_mobile_recv_cmd(self,cmd,parm): #移动入库相关指令
+ if cmd == "10":
+ self.software_version = str(parm)
+ eventMesh.publish("set_dev_version",self.software_version)
+ clog.info("software_version:{},{}".format(self.software_version,parm))
+ elif cmd == "16": #获取BLE mac地址
+ eventMesh.publish("set_dev_mac",str(parm))
+ clog.info("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 send_dmp_cm_address_toBLE(self,event,msg):
+ buf_tmp = "address:"+str(msg)
+ self.reply_cmd('18',"{}".format(buf_tmp))
+
+ 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_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)
+ def delete_sms_cb(self,*argc):
+ eventMesh.publish_async("remove_all_sms_cb","",1*1024)
+ def remove_all_sms_cb(self, event, msg):
+ clog.info("remove_all_sms_cb\r\n")
+ msg_nums = sms.getMsgNums() #短信数量
+ if msg_nums == -1:
+ msg_nums = 0
+ sms_data = sms.getSaveLoc()
+ clog.info("{}\r\n".format(sms_data))
+ if sms_data == -1:
+ return
+ sms_max = sms_data[0][2] #最大存储短信数量
+ if sms_max >= msg_nums and sms_max > 0:
+ sms.deleteMsg(1,4) #删除所有的sms信息
+
+ def send_singal_data_toBle(self,event,msg):
+ msg_nums = sms.getMsgNums() #短信数量
+ if msg_nums == -1:
+ msg_nums = 0
+ sms_data = sms.getSaveLoc()
+ if sms_data == -1:
+ return
+ sms_max = sms_data[0][2] #最大存储短信数量
+ clog.info("recv:{}".format(int(msg)))
+ message=self.sms_get_message_info(int(msg))
+ if message == -1: #说明没有这条短信
+ return
+ message_pdu = sms.decodePdu(message[5],20)
+
+ if message_pdu != -1: #解码出来的内容
+
+ message_ref = message[0] #编码
+ message_total_num = message[1] #总共条数
+ message_seq = message[2] #当前第几条
+ data = message[5] #内容
+ data_len = len(data) #内容长度
+ # ref ：短信参考标识，同一个标识表明为同一条短信
+ # total_num ：此条长短信总条数 大于1属于长短信
+ # seq ：此条短信在长短信中的序号
+ # print("message:{} {}\r\n".format(message,message_pdu))
+ msg_total = "ref:"+str(message_ref)+"@total_num:"+str(message_total_num)+"@seq:"+str(message_seq)+"@data:"+str(message[5])
+ self.reply_cmd('15',msg_total)
+
+ eventMesh.publish("delete_sms_single_data",int(msg))
+
+ def sms_deal_phone_number(self,args):
+ data=enumerate(args)
+ data_str1=""
+ data_str2=""
+ data_str3=""
+ for index,value in data:
+ if index % 2 == 0:
+ data_str1=data_str1+value
+ else:
+ data_str2=data_str2+value
+ for i in range(0,len(data_str1)):
+ data_str3=data_str3+data_str2[i]
+ data_str3=data_str3+data_str1[i]
+ return data_str3
+ def sms_get_message_info(self,index):
+ """
+ ：param index ：短信索引值
+ ：tyoe index ：整形
+
+ ：return ：元组类型
+ 元组内容：
+ （message_ref，message_total_num，message_seq，sub_message_data，pdu_tye，sub_message_len）
+
+ ：message_ref ：短信参考标识，同一个标识表明为同一条短信
+ ：message_total_num ：此条长短信总条数
+ ：message_seq ：此条短信在长短信中的序号
+ ：sub_message_data ：词条短信的内容
+ ：pdu_tye ：PDU类型，bit 6标记是否包含用户报文头，长短信需要
+ ：sub_message_len ：此条短信内容长度
+
+ """
+
+ message0=sms.searchPduMsg(index)
+ #print("sms_get_message_info:message0:{}".format(message0))
+ if message0 == -1:
+ return -1
+
+ sca_num = int(message0[0:2],16) - 1
+ data_len = 2
+ addr_type= message0[data_len:data_len+1*2]
+ data_len = data_len+1*2
+
+ sca = message0[data_len:data_len+sca_num*2]
+ # 电话号码高低位需要转换
+ sca = self.sms_deal_phone_number(sca)
+
+ # if sca_num % 2 == 1:
+ # print("Get SCA phone {}".format(sca[:-1]))
+ # else:
+ # print("Get SCA phone {}".format(sca))
+
+ data_len = data_len+sca_num*2
+
+ pdu_tye = int(message0[data_len:data_len+1*2],16)
+ data_len = data_len+1*2
+
+ oa_num = int(message0[data_len:data_len+1*2],16)
+ data_len = data_len+1*2
+ oa_addr_type = message0[data_len:data_len+1*2]
+ data_len = data_len+1*2
+
+ if oa_num % 2 == 1:
+ oa_num_t = int((oa_num + 1)/2)
+ else:
+ oa_num_t = int((oa_num )/2)
+
+ oa = message0[data_len:data_len+oa_num_t*2]
+ # 电话号码高低位需要转换
+ oa = self.sms_deal_phone_number(oa)
+
+ # if oa_num % 2 == 1:
+ # print("Get OA phone {}".format(oa[:-1]))
+ # else:
+ # print("get OA phone {}".format(oa))
+
+ data_len = data_len+oa_num_t*2
+ pid = message0[data_len:data_len+1*2]
+
+ data_len = data_len+1*2
+ dcs = message0[data_len:data_len+1*2]
+ data_len = data_len+1*2
+ scts = message0[data_len:data_len+7*2]
+ data_len = data_len+7*2
+ sub_message_len = int(message0[data_len:data_len+1*2],16)
+ data_len = data_len+1*2
+ sub_message_head = message0[data_len:data_len+6*2]
+ data_len = data_len+6*2
+
+ # 或短信用户数据
+ sub_message_data = message0[data_len:data_len+sub_message_len*2]
+
+ #长短信
+ if ((pdu_tye & 0x40 ) >> 6) == 1:
+ #长短信,处理长短信用户报文头
+ message_ref = int(sub_message_head[6:8],16)
+ message_total_num = int(sub_message_head[8:10],16)
+ message_seq = int(sub_message_head[10:12],16)
+ return [message_ref,message_total_num,message_seq,pdu_tye,sub_message_len,message0]
+ else:
+ # 短短信
+ return [0,1,1,pdu_tye,sub_message_len,message0]
+
+
+
+ def send_sms_max_to_Ble(self,event,msg):
+ msg_nums = sms.getMsgNums()#短信数量
+ if msg_nums == -1:
+ msg_nums = 0
+ sms_data = sms.getSaveLoc()
+ if sms_data != -1:
+ sms_max = sms_data[0][2]#最大存储短信数量
+ self.reply_cmd('15',"@sms_max:"+str(sms_max)+"@current_num:"+str(msg_nums))
+ pass
+
+ def get_all_sms_data(self,event,msg):
+ msg_total = ""
+ SMS_lis={}
+ SMS_lis_count = 0
+ sms_data = sms.getSaveLoc()
+ clog.info(sms_data)
+ if sms_data == -1:
+ return
+ sms_max = sms_data[0][2]#最大存储短信数量
+ clog.info(sms_max)
+ self.msg_nums = sms.getMsgNums()
+ if self.msg_nums_old != self.msg_nums:
+ self.send_data = []
+ self.msg_nums_old = self.msg_nums
+ if self.send_data == [] :
+ for i in range(self.msg_nums):
+ phonenum = ""
+ data =""
+ time = ""
+ data_len = 0
+ message=self.sms_get_message_info(self.msg_nums-i-1)
+ if message == -1:
+ break
+ data = message[5]
+ sms_data = []
+ code = message[0]#编码
+ num = message[1]#总共条数
+ curren_num = message[2]#当前第几条
+ data_len = message[4]
+ sms_data.append(code)#编码 编码相同是同一条短信的内容
+ sms_data.append(num)
+ sms_data.append(curren_num)
+ sms_data.append(data)
+ sms_data.append(data_len)
+ self.send_data.append(sms_data)
+ count = len(self.send_data)
+ for i in range(count):
+ text = self.send_data[i]
+ clog.info("text:{} {} {}\r\n".format(text[0],text[1],text[2]))
+
+ msg_total = "@code:"+str(text[0])+"@totalcodenum:"+str(text[1])+"@currcodeid:"+str(text[2])+"@data:"+str(text[3])
+ self.reply_cmd('17',msg_total)
+
+ # 来电提醒
+ def notifyIncomingcall(self, incomming_numb):
+ self.clear_remain()
+ __head = '0C'
+ __message = str(incomming_numb)
+ self.__Socket_UDP(__head, __message)
+ # if self.__err == 1 or self.__value[2] != 'OK':
+ # return -1
+ return 0
+
+ # 电话接听消息
+ def notifyConnecteCall(self, phone_numb):
+ self.clear_remain()
+ __head = '0A'
+ __message = str(phone_numb)
+ self.__Socket_UDP(__head, __message)
+ # if self.__err == 1 or self.__value[2] != 'OK':
+ # return -1
+ return 0
+
+ # 电话拒接消息
+ def notifyDisconnectCall(self, phone_numb):
+ self.clear_remain()
+ __head = '0B'
+ __message = str(phone_numb)
+ self.__Socket_UDP(__head, __message)
+ # if self.__err == 1 or self.__value[2] != 'OK':
+ # return -1
+ return 0
+
+ def wait_network_ready(self):
+ if(self.__waiting_netstat == 1):
+ return 0
+ self.__waiting_netstat = 1
+ stage, state = checkNet.waitNetworkReady(30)
+ pm.wakelock_unlock(lpm_fd)
+ if stage == 3 and state == 1:
+ clog.info('Network connection successful.')
+ self.set_network_config()
+ self.__net_connected = 1
+ eventMesh.publish("set_network_state",self.__net_connected)
+ self.__waiting_netstat = 0
+ return 0
+ else:
+ clog.info('Network connection failed, stage={}, state={}'.format(stage, state))
+ self.reset_network_config()
+ self.__net_connected = 0
+ eventMesh.publish("set_network_state",self.__net_connected)
+
+ self.__waiting_netstat = 0
+ return -1
+
+ # 查询网卡状态
+ def timesync(self,_timesync):
+ self.clear_remain()
+ message = str(_timesync)
+ self.__Socket_UDP('0D', message)
+ return 0
+
+ def reply_timesync(self,_timesync):
+ self.clear_remain()
+ message = str(_timesync)
+ self.__Socket_UDP_noreply('0D', message)
+ return 0
+
+ def reply_cmd(self,cmd,_timesync):
+ try :
+ clog.info('reply_cmd 1')
+ self.clear_remain()
+ message = str(_timesync)
+ clog.info('reply_cmd 2')
+ self.__Socket_UDP_noreply(cmd, message)
+ except:
+ clog.info('reply_cmd')
+ return 0
+
+ def clear_remain(self):
+ # if self.__queue.empty() == False:
+ # self.__queue.get()
+ self.__err = 0
+ # self.__value = None
+ #添加路由信息
+ def router_add(self, ip='192.168.4.1', mask='255.255.255.0'):
+ self.ip = ip
+ self.mask = mask
+
+ return slip.router_add(self.ip, self.mask)
+
+ # 获取slip的网络配置
+ def ipconfig(self):
+ return slip.ipconfig()
+
+ # 设置dns服务器
+ def set_dns(self, pri_dns='8.8.8.8', sec_dns='114.114.114.114'):
+ self.pri_dns = pri_dns
+ self.sec_dns = sec_dns
+ return slip.set_dns(self.pri_dns,self.sec_dns)
+
+ # 设置默认网卡
+ def set_default_NIC(self, ip_str):
+ self.ip_str = ip_str
+ return slip.set_default_netif(self.ip_str)
+
+ def reset_network_config(self):
+ if (self.__net_connected == 0):
+ clog.info("skip reset_network_config")
+ return 0
+ Info = dataCall.getInfo(1,0)
+ clog.info("Info{}".format(Info))
+ default_NIC_ip = Info[2][2] # 假设默认网卡ip地址为10.10.1.1，请根据实际情况更改
+ segment_ip = '172.16.4.0' # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255]，请根据实际情况更改
+ mask = '255.255.255.0' # 假设子网掩码为255.255.255.0，请根据实际情况更改
+ # 配置默认网卡，通过默认网卡进行网络转发
+ cat1service.set_default_NIC(default_NIC_ip)
+ clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
+ #添加路由规则，只有该网段IP才进行转发
+ cat1service.router_add(segment_ip, mask)
+
+ pri_dns = '8.8.8.8' # 假设DNS首选地址为8.8.8.8，请根据实际情况更改
+ sec_dns = '114.114.114.114' # 假设DNS备选地址为114.114.114.114，请根据实际情况更改
+ # 配置网卡DNS服务器
+ cat1service.set_dns(pri_dns, sec_dns)
+ # 网卡IP信息查询
+ cat1service.ipconfig()
+
+ def set_network_config(self):
+
+
+ if (self.__net_connected == 1) :
+ clog.info("skip set_network_config")
+ return 0
+ Info = dataCall.getInfo(1,0)
+ clog.info("Info{}".format(Info))
+ default_NIC_ip = Info[2][2] # 假设默认网卡ip地址为10.10.1.1，请根据实际情况更改
+ segment_ip = '172.16.1.0' # 假设ap模式网段范围是[192.168.4.0 ~ 192.168.4.255]，请根据实际情况更改
+ mask = '255.255.255.0' # 假设子网掩码为255.255.255.0，请根据实际情况更改
+ # 配置默认网卡，通过默认网卡进行网络转发
+ cat1service.set_default_NIC(default_NIC_ip)
+ clog.info("default_NIC_ip {0} segment_ip {1}".format(default_NIC_ip,segment_ip))
+ #添加路由规则，只有该网段IP才进行转发
+ cat1service.router_add(segment_ip, mask)
+
+ pri_dns = '8.8.8.8' # 假设DNS首选地址为8.8.8.8，请根据实际情况更改
+ sec_dns = '114.114.114.114' # 假设DNS备选地址为114.114.114.114，请根据实际情况更改
+ # 配置网卡DNS服务器
+ cat1service.set_dns(pri_dns, sec_dns)
+ # 网卡IP信息查询
+ cat1service.ipconfig()
+ if eventMesh.publish("get_dmp_change_mode") == 0:#入库功能关闭
+ return
+ if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#电信入库功能 不使用设置 0 防止两边不同步修改
+ if eventMesh.publish("get_dmp_change_mode") == 1:
+ eventMesh.publish("set_network_state",1)
+ # telecomDmpCb.telecom_dmp_power_on_init()
+ if 1: #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)
+ self.reply_cmd('11',"{}".format(ICCID_DATA))
+ pass
+ def cat1_reply_timesec_to_ble(self,event,msg):
+
+ self.reply_cmd('14',"REGIST_TIME:{}".format(msg))
+ pass
+ # 释放slip网卡
+ def stop(self):
+ slip.destroy()
+ return 0
+
+
+ # 封装tlv数据包
+ def __pack_tlv_format(self, head, content):
+ # self.head = head
+ # self.content = content
+ if len(content) == 0 or len(content) > 9999 or len(head) != 2:
+ clog.error('illegal pack tlv content')
+ return -1
+ len_str ='%04d' % len(content)
+ tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content
+ return tlv_pack
+ # 解码tlv数据包
+ def __unpack_tlv_format(self, msg):
+ clog.info('__unpack_tlv_format {}\r\n'.format(msg))
+ self.msg = str(msg)[2:]#这是去除head FE
+ tag = self.msg[0:2]
+ length = self.msg[2:6]
+ value = self.msg[6:]
+ len_str ='%04d' % len(value)
+ if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != self.msg[2:6]:
+ clog.error('__unpack_tlv_format err')
+ return -1
+ clog.info('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
+ unpack = (tag,length,value)
+ return unpack
+ # socket通信(UDP)模块
+ def __Socket_UDP(self, head, content):
+ # 0 则 __Socket_UDP_write
+ self.send_data_q.put([head,content])
+ def Socket_SEND_Thread(self):
+ while True:
+ try:
+ clog.info("send====")
+ data=self.send_data_q.get()
+ self.ack_sem=1
+ # # if data[2]:
+ # self.__Socket_UDP_noreply_write( data[0], data[1])
+ # else :
+ self.__Socket_UDP_write( data[0], data[1])
+
+
+ clog.info("Socket_SEND_Thread data:{} {}".format(data[0],data[1]))
+ count=20
+
+ while count & self.ack_sem :
+ utime.sleep_ms(1)
+ count=count-1
+ # if data[2]:
+ # self.__Socket_UDP_noreply_write( data[0], data[1])
+ # else :
+ self.__Socket_UDP_write( data[0], data[1])
+
+ clog.info("Socket_SEND_Thread while data:{} {}".format(data[0],data[1]))
+
+ if data:
+ clog.info("data ok!!")
+ else:
+ clog.error("data error!!")
+ except Exception :
+ clog.error("sned Socket >>>")
+
+ def __Socket_UDP_write(self, head, content):
+ try:
+ ##self.head = head
+ # self.content = content
+ gpioWakeBT.write(1)
+ utime.sleep_ms(2)
+ gpioWakeBT.write(0)
+ utime.sleep_ms(20)
+ # 消息处理
+ msg = self.__pack_tlv_format(head, content)
+
+ # 向服务端发送消息
+ server_addr = ('172.16.1.5',1000)
+ clog.info("__Socket_UDP send msg {}".format(msg))
+ self.__err = 0
+ self.__sock.sendto(msg,server_addr)
+ clog.info("__Socket_UDP send 2")
+ self.__wait_resp = 1
+ # data = self.__queue.get()
+ self.__wait_resp = 0
+ # return data
+ return 1
+ except Exception as error:
+ clog.error(error)
+ return 0
+
+ def __Socket_UDP_noreply(self, head, content):
+ # 1 则 __Socket_UDP_noreply_write
+ self.send_data_q.put([head,content])
+
+ def __Socket_UDP_noreply_write(self, head, content):
+ # self.head = head
+ # self.content = content
+ gpioWakeBT.write(1)
+ utime.sleep_ms(2)
+ gpioWakeBT.write(0)
+ utime.sleep_ms(20)
+ # 消息处理
+ msg = self.__pack_tlv_format(head, content)
+
+ # 向服务端发送消息
+ server_addr = ('172.16.1.5',1000)
+
+ clog.info("__Socket_UDP_noreply send msg {}".format(msg))
+ self.__err = 0
+ data_size = self.__sock.sendto(msg,server_addr)
+ clog.info("self.__sock data_size {}".format(data_size))
+ self.__wait_resp = 0
+ return 0
+
+ # socket通信(UDP)模块
+ def __Socket_Thread(self):
+ while True:
+ try:
+ clog.info("recv====")
+ data=self.__sock.recv(1024)
+ clog.info("data:{}".format(data))
+ if data:
+ value = self.__unpack_tlv_format(data.decode())
+ if value != -1:
+ clog.info('mode: {0}, recv {1} bytes, Data: {2}'.format (value[0],len(data), value[2]))
+ if value[1] == 'FF':
+ self.btmcu_cmd_handler(value[0],value[2])
+ else:
+ # self.__value = value
+ # self.__queue.put('1')
+ self.btmcu_cmd_handler(value[0],value[2])
+ clog.info("End else Thread")
+ else:
+ clog.error("data error!!")
+ except Exception as recverr:
+ clog.error("recverr:{}\r\n".format(recverr))
+ if "110" in str(recverr):
+ self.__err = 1
+ # if self.__wait_resp == 1:
+ # self.__queue.put('0')
+ else:
+ utime.sleep(1)
+ self.__sock = self.__socket_reinit()
+
+
+
+ clog.info("End Socket Thread")
+
+
+
+
+# UDP_CMD_GET_CAT1VER = '0', // 获取 Cat1 版本号
+# UDP_CMD_DIAL_NUMB = '1', // 拨打电话
+# UDP_CMD_HUNGUP = '2', // 挂断电话
+# UDP_CMD_ANSWER = '3', // 接听电话
+# UDP_CMD_CAT1_OTA_UPDATE = '4', // 触发Cat1 OTA升级，mcu提供url
+# UDP_CMD_SEND_SMS = '5', // 发送SMS短信，mcu提供电话号及短信内容
+# UDP_CMD_GET_TIME = '6', // 获取Cat1 时间 ，YYYYMMDD HHmmss zone
+# UDP_CMD_GET_NETWORKSTAT = '7', //获取Cat1 信号信息，VOLTE信息，信号强度，SIM卡状态
+# 下文进行系统配置
+clog.info("Cat1Service start")
+
+cat1service = Cat1Service()
+
+#send_data_q = Queue(100)
+
+#voice call callback function
+def voice_callback(args):
+ if args[0] == 10:
+ clog.info('voicecall incoming call, PhoneNO: ', args[6])
+ if eventMesh.publish("get_volte_switch") == 0: #关闭VOLTE功能
+ clog.info('voicecall auto end:')
+ voiceCall.callEnd()
+ else:
+ # gpioWakeBT.write(1)
+ cat1service.notifyIncomingcall(args[6])
+ elif args[0] == 11:
+ if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
+ clog.info('voicecall connected, PhoneNO: \n'.format(args[6]))
+ cat1service.notifyConnecteCall(args[6])
+ elif args[0] == 12:
+ clog.info('voicecall disconnect')
+ if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
+ clog.info('voicecall disconnected, PhoneNO: \n'.format(args[6]))
+ cat1service.notifyDisconnectCall(args[6])
+ elif args[0] == 13:
+ clog.info('voicecall is waiting, PhoneNO: \n'.format(args[6]))
+ elif args[0] == 14:
+ clog.info('voicecall dialing, PhoneNO: \n'.format(args[6]))
+ elif args[0] == 15:
+ clog.info('voicecall alerting, PhoneNO: \n'.format(args[6]))
+ elif args[0] == 16:
+ clog.info('voicecall holding, PhoneNO: \n'.format(args[6]))
+ else:
+ clog.info('voice_callback , args[0]: \n'.format(args[6]))
+
+#电话消息反馈
+voiceCall.setCallback(voice_callback)
+
+
+def checknet_cb(arg):
+ clog.info("start checktime!!")
+ # if 1: #CHINA_TELECOM_DM_FUN_ENABLE == 1:#这是手表每30s检查一次
+ # if eventMesh.publish("get_dmp_change_mode") == 1:
+ # telecomDmpCb.telecom_dmp_power_on_count()
+
+ _thread.start_new_thread(cat1service.wait_network_ready, ())
+ # time=utime.localtime()
+ # zone=utime.getTimeZone()
+ #(2024, 3, 2, 18, 31, 32, 5, 62),8
+ # cat1service.timesync("{0},{1}".format(time,zone))
+# _thread.start_new_thread(cat1service.wait_network_ready, ())
+timer = osTimer()
+# checknet_cb(())
+timer.start(30000,1,checknet_cb)
+
+def bootupmsg_cb(arg):
+ cat1service.bootup_msg_to_bt()
+
+
+delaybootupmsg_timer = osTimer()
+delaybootupmsg_timer.start(1000,0,bootupmsg_cb)
+
+# def checkpin_cb(arg):
+# clog.info("recvDataPin={}".format(recvDataPin.read()))
+
+# timerCheckRevPin = osTimer()
+# timerCheckRevPin.start(1000,1,checkpin_cb)
+
+
+
+
+
+
+# while True:
+# utime.sleep(5)
+
+
+# uping.ping("172.16.1.5")
+ # 获取网卡当前工作状态
+
+# gpioWakeBT.write(1)
+# utime.sleep(1)
+
+# timesync = net.nitzTime()
+# cat1service.timesync(timesync)
+
+
+#url = "http://zzhc.vnet.cn:9998/"
+
+
--- /dev/null
+import log
+
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+fota_log = log.getLogger("china_mobile")
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+import example
+import log
+from machine import UART
+
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+# 设置输出到debug口
+uart = UART(UART.UART0, 115200, 8, 0, 1, 0)
+log.set_output(uart)
+clog = log.getLogger("cat1")
+
+main_flag = 1
+
+
+try:
+ example.exec('/usr/main_init.py')
+ clog.info("启动main_init成功!!!!!\r\n")
+except Exception as e:
+ main_flag = 0
+ clog.error("启动失败!!!!!\r\n".format(e))
+
+try:
+ example.exec('/usr/tcpService.py')
+ clog.info("启动tcpserver成功!!!!!\r\n")
+except Exception as e:
+ clog.error("启动失败!!!!!\r\n".format(e))
+
--- /dev/null
+from misc import Power
+import usocket
+import log
+import utime
+import audio
+from machine import UART
+import _thread
+from queue import Queue
+from machine import Pin
+from machine import ExtInt
+import dataCall
+import voiceCall
+import net
+import uping
+import example
+import osTimer
+import sim
+import modem
+import utime
+import checkNet
+import atcmd
+import fota
+import request
+import ql_fs
+import pm
+import sms
+import binascii
+import ujson
+import uos
+import slip
+
+
+log.basicConfig(level=log.INFO)
+clog = log.getLogger("cat1")
+
+
+USR_FILE_PATH = "/usr" #
+BAK_FILE_PATH = "{}/TmpPyFile".format(USR_FILE_PATH) #文件传输的临时文件夹目录路径
+BAK_FILE_TMP = "_bak"
+
+CAT1_SERVICE_HEAD = "FE"
+CAT1_FILE_DATA_HEAD = "FF"
+
+
+CAT1_REPLAY_STATE="00"
+CAT1_CREAT_DIR_FAILE= "01"
+CAT1_CREAT_DIR_OK= "02"
+CAT1_NO_REPLAY_OTA_OK= "03"
+CAT1_WRITE_FILE_SUCC= "04"
+CAT1_WRITE_FILE_ERROR = "05"
+CAT1_CRC_ERROR = "06"
+CAT1_SEND_HEAD_ERR = "07"
+CAT1_OTA_TIMEOUT_BLE_NO_REPLAY = "08"
+CAT1_CREAT_FILE_ERROR = "09"
+CAT1_CREAT_FILE_SUCC = "0A"
+CAT1_ALLPY_FILE_TRANSFER_END = "0B"
+CAT1_REPLAY_OTA_SUCC = "0C"
+CAT1_REPLAY_OTA_FALIE = "0D"
+CAT1_REPLAY_FILE_SIZE_OK = "0E"
+CAT1_REPLAY_FILE_SIZE_ERR = "0F"
+CAT1_REPLAY_OTA_END_FAILE = "10" #升级完之后 CAT1回复升级失败
+
+CAT1_NEED_UPDATE_OTA = "11" #提示用户强制升级
+
+CAT1_TCP_STOP_OTA = 0 #结束OTA升级
+CAT1_TCP_START_OTA = 1 #ble 开始发送OTA标识 -》 CAT1
+CAT1_TCP_START_SEND_SINGLE_FILE_INFO= 2 #//ble 开始发送单个文件信息 -> CAT1 创建单个文件名
+CAT1_TCP_START_SEND_FILE_DATA= 3 #//BLE开始发送文件数据额 ----》CAT1 接收文件数据写文件
+CAT1_TCP_START_OTA_FAILE = 4 #BLE 发送OTA失败 取消文件传输
+CAT1_TCP_START_OTA_SUCC = 5 #//BLE 发送OTA成功标识
+CAT1_TCP_START_SEND_ALLFILE_FINESH = 6 #/所有PY文件传输完成
+CAT1_TCP_SEND_SINGLE_FINESH = 7 #//单个文件传输完成
+CAT1_TCP_START_ERROR_INFO = 255 #/发送错误信息结束进程
+
+# 创建gpio对象
+gpioWakeBT = Pin(Pin.GPIO21, Pin.OUT, Pin.PULL_DISABLE, 1)
+# 设置输入输出模式
+gpioWakeBT.set_dir(Pin.OUT)
+
+# 设置引脚电平
+gpioWakeBT.write(0)
+FILE_TRANSFER_TIMEOUT=60 #超时时间 60s没有收到BLE的发送数据就结束了
+class TcpServiceInit:
+ AP = 0 # SLIP_INNER
+ STA = 1 # SLIP_OUTER
+
+ def __init__(self, uart=UART.UART4, mode=AP):
+ self.__uart = uart
+ self.__mode = mode
+ self.Cat1FileState = 0
+ self.Cat1FileReplayBle = 0
+ self.Cat1TimeCount = 0
+ self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT
+ self.Cat1FileTransTimer = osTimer()
+ self.Cat1OtaTimeOut = osTimer()
+ self.crc_err = 0
+ self.allPyRecvFlag = 0
+ self.ota_state =0
+ self.ota_bstate =0
+ self.fileNameTmp = ""
+ self.fileNameList = []
+ self.fileSizeList = []
+ self.fileSize = 0
+ self.updateTimer = osTimer()
+ self.updateTimerCount = 0
+ self.updateTimerFlag = 0
+ self.sock = None
+ self.bakFlag = "0"
+ self.conn= None
+ # slip.destroy()
+ # ret = slip.construct(self.__uart,self.__mode, 0)
+ # if ret != 0:
+ # clog.info('slip netif construct fail')
+ # return None
+
+ self.__sock_file = None
+ self.__sock_file = self.__socket_file_init()
+ self.__thread_file = _thread.start_new_thread(self.__Socket_File_Thread, ())
+ self.conn_thread=_thread.start_new_thread(self._client_conn_proc, ())
+ clog.info("ftp_Service :{}\r\n".format(self.__sock_file))
+ # 封装tlv数据包
+ def __pack_tlv_format(self, head, content):
+ head1 = head
+ content1 = content
+ if len(content1) == 0 or len(content1) > 9999 or len(head1) != 2:
+ clog.info('illegal pack tlv content file')
+ return -1
+ len_str ='%04d' % len(content1)
+ tlv_pack = CAT1_SERVICE_HEAD+head1+len_str+content1
+ return tlv_pack
+ # 解码tlv数据包
+ def __unpack_tlv_format(self, msg):
+ clog.info('__unpack_tlv_format file {}\r\n'.format(msg))
+ msg_tmp = str(msg)[2:]#这是去除head FE
+ tag = msg_tmp[0:2]
+ length = msg_tmp[2:6]
+ value = msg_tmp[6:]
+ len_str ='%04d' % len(value)
+ if len(value) == 0 or len(value) > 9999 or len(tag) != 2 or len_str != msg_tmp[2:6]:
+ clog.info('__unpack_tlv_format err file')
+ return -1
+ # clog.info('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
+ unpack = (tag,length,value)
+ return unpack
+ def __socket_init(self):
+
+ # 创建一个socket实例
+ self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM)
+ self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
+ return self.sock
+
+ def __socket_file_init(self): #文件传输Socket
+ # self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT)
+ self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM, usocket.IPPROTO_TCP_SER)
+ self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
+ # 绑定IP
+ bind_addr = ('172.16.1.2', 5001)
+ self.sock.bind(bind_addr)
+ # self.sock.settimeout(10)
+ self.sock.listen(10)
+
+ return self.sock
+
+ def __socket_file_reinit(self):
+ clog.info("self.__sock_file reinit:{}\r\n".format(self.__sock_file))
+ if self.__sock_file != None:
+ self.sock.close()
+ return self.__socket_file_init()
+
+ def __Socket_UDP_file_noreply(self, head, content):
+ head1 = head
+ content1 = content
+ gpioWakeBT.write(1)
+ utime.sleep_ms(2)
+ gpioWakeBT.write(0)
+ utime.sleep_ms(20)
+ # 消息处理
+ msg = self.__pack_tlv_format(head1,content1)
+ if msg == -1: #无效数据
+ return 0
+ # 向服务端发送消息
+ server_addr = ('172.16.1.5',1001) #服务端口也需要更改
+
+ clog.info("__Socket_TCP_file_noreply send msg {}".format(msg))
+ try:
+ data_size = self.__sock_file.sendto(msg,server_addr)
+ clog.info("self.__sock_file data_size {}".format(data_size))
+ except Exception as e:
+ clog.info("self.__sock_file error {}".format(e))
+ return 0
+ def __Socket_TCP_file_noreply(self, head, content):
+ head1 = head
+ content1 = content
+ gpioWakeBT.write(1)
+ utime.sleep_ms(2)
+ gpioWakeBT.write(0)
+ utime.sleep_ms(20)
+ # 消息处理
+ msg = self.__pack_tlv_format(head1,content1)
+ if msg == -1: #无效数据
+ return 0
+ # 向服务端发送消息
+ # server_addr = ('172.16.1.5',1001) #服务端口也需要更改
+
+ clog.info("__Socket_TCP_file_noreply send msg {}".format(msg))
+ try:
+ data_size = self.conn.send(msg)
+ clog.info("self.__sock_file data_size {}".format(data_size))
+ except Exception as e:
+ clog.info("self.__sock_file error {}".format(e))
+
+ return 0
+ # py文件传输
+ # //py文件传输
+ # // {"Code":1} 开始OTA
+ # // {"Code":2,"fileName":"cat1Service.py","fileSize":123435} fileCode: 文件ID fileName:文件名称 fileSize:文件大小
+ # // {"Code":3,"head+datalen+data+CRC":"数据"} // Code: 2开始发送文件数据
+ # // {"Code":4} BLE 主动发送OTA失败
+ # // {"Code":5} BLE 主动发送OTA成功
+ # // {"Code":6} BLE 所有PY文件传输完成
+ # // {"Code":7} BLE 单个文件传输完成
+
+ def _client_conn_proc(self):
+ clog.error('[_client_conn_proc] _client_conn_proc')
+
+ while True:
+ if self.conn==None:
+ utime.sleep_ms(20)
+ continue
+ try:
+ # Receive data sent by the client
+
+ data = self.conn.recv(1024)
+ clog.info('[server] [client addr: %s] recv data:', data)
+ if not data:
+ clog.info("__Socket_File_Thread data null:\r\n")
+ else:
+ self.src_data(data.decode('uft-8'))
+
+ # Send data back to the client
+ # conn.send(data)
+ except:
+ # Exception occurred and connection closed
+ clog.error('[server] disconnected')
+ self.conn.close()
+ # self.__sock_file = self.__socket_file_reinit()
+ break
+
+
+ def __Socket_File_Thread(self):
+
+ # clog.info('[server] accept a client: %s, %s' % (cli_ip_addr, cli_port))
+
+ while True:
+ try :
+ clog.info('[serveice] start accept a client' )
+ cli_conn, cli_ip_addr, cli_port = self.__sock_file.accept()
+ self.conn=cli_conn
+ clog.info('[serveice] accept a client: %s, %s' % (cli_ip_addr, cli_port))
+ except :
+ clog.error('__Socket_File_Thread' )
+ utime.sleep_ms(20)
+ # Create a new thread for each client connection for concurrent processing
+
+ # clog.info("End __Socket_File_Thread Thread")
+
+ def cat1FileTimerCb(self,*argc):
+ clog.info("timer test\r\n")
+ if self.Cat1PyFileTimout > 0:
+ self.Cat1PyFileTimout-=1
+ if self.Cat1PyFileTimout == 0:
+ self.Cat1PyFileTimout = 0
+ self.Cat1FileState = 0
+ self.deleteTmpFile()
+ self.deleteUsrTmpFile()
+ self.__Socket_TCP_file_noreply(CAT1_OTA_TIMEOUT_BLE_NO_REPLAY,"ota error") #结束文件接收不完整的
+ self.Cat1FileTransTimer.stop() #//关闭定时器
+ pass
+
+ def crc_cal(self,msg):
+ bytes_data = msg.encode('utf-8')
+ hex_data = binascii.hexlify(bytes_data)
+ hex_data = hex_data.decode()
+ # clog.info("hex_data:{}\r\n".format(hex_data))
+ data = hex_data
+ crcValue = 0
+ j = 0
+ i = 0
+ json_state = 0
+ crcbuf = 0
+ # clog.info("len(data) :{}\r\n".format(len(data)))
+ data_len = len(str(data))
+ try:
+ if data_len % 2 != 0:
+ json_state = 0
+ return [json_state,crcbuf]
+ except Exception as e:
+ json_state = 0
+ clog.info("不合法的的十六进制数据!!\r\n")
+
+ for i in range(data_len):
+ if j >= data_len:
+ break
+ try:
+ decimal_number = int(str(data[j:j+2]), 16)
+
+ crcValue=crcValue+decimal_number
+ crcValue = crcValue&0xff
+ except Exception as e:
+ clog.info("不合法的的十六进制数据!!\r\n")
+ j+=2
+
+ crcbuf = crcValue%256
+ crcbuf = 256-crcbuf
+ crcbuf = crcbuf%256
+
+ # clog.info("crcbuf:{}\r\n".format(crcbuf))
+ return [json_state,"%02x"%(crcbuf)]
+ #删除临时创建的文件夹
+ def deleteTmpFile(self):
+ tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
+ if tmp_dir == True:
+ ql_fs.rmdirs(BAK_FILE_PATH)
+
+ #删除usr临时创建的文件夹
+ def deleteUsrTmpFile(self):
+ return
+ # tmp_dir = ql_fs.path_exists("/usr/UsrTmpPyFile")
+ # if tmp_dir == True:
+ # ql_fs.rmdirs("/usr/UsrTmpPyFile")
+
+ def src_data(self,data):
+ mk_dir_state = 0
+ clog.info("data!!!!!{}\r\n".format(len(data)))
+ if self.updateTimerFlag == 0:
+ self.updateTimerFlag = 1
+ self.updateTimer.stop()
+ msg = ""
+ json_state = 0
+ try:
+ msg = ujson.loads(data)
+ json_state = 1
+ except Exception as e:
+ json_state = 0
+ if json_state == 0: #不是json 字典的格式 {} 就是命令
+ value = self.__unpack_tlv_format(data) #解析数据 FE
+ self.cmd_data(value[0],value[2])
+ return
+ else:
+ self.file_data(msg)
+ pass
+ def cmd_data(self,cmd,parm): #(self,cmd,parm):
+ if cmd == "01":
+ self.bakFlag = str(parm)
+
+ pass
+ def file_data(self,msg):
+ # clog.info("msg type msg {} {}\r\n".format(msg,type(data)))
+ if "Code" in msg:
+
+ Code = int(msg["Code"])
+ clog.info("Code {} self.Cat1FileState:{}\r\n".format(Code,self.Cat1FileState))
+ if Code == CAT1_TCP_STOP_OTA: #OTA失败
+ self.allPyRecvFlag = 0
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ self.deleteTmpFile()
+ self.deleteUsrTmpFile()
+ pass
+ elif Code == CAT1_TCP_START_OTA: #BLE 开始OTA cat1创建临时文件夹记录传输的文件数据 文件名
+ self.ota_state =0
+ self.ota_bstate =0
+ self.allPyRecvFlag = 0
+ self.fileNameList = []
+ self.fileSizeList = []
+ clog.info("CAT1_TCP_START_OTA {} \r\n".format(CAT1_TCP_START_OTA))
+ self.allPyRecvFlag = 0
+ self.Cat1FileState = 0
+ self.deleteUsrTmpFile()
+ self.Cat1OtaTimeOut.stop()
+ check_dir = ql_fs.path_exists(BAK_FILE_PATH)
+ mk_dir_state = 0
+ if check_dir == True:
+ try:
+ self.deleteTmpFile()
+ except Exception as e:
+ clog.info("移除失败!!!!\r\n")
+ check_dir = ql_fs.path_exists(BAK_FILE_PATH)
+ if check_dir == False: #文件夹不存在 创建目录文件夹
+ try:
+ ql_fs.mkdirs(BAK_FILE_PATH)
+ mk_dir_state = 1
+ clog.info("创建临时文件 创建成功!!!!\r\n")
+ except Exception as e:
+ mk_dir_state = 0
+ clog.info("创建临时文件失败没有内存!!!!\r\n")
+ else: #已经存在目录了
+ mk_dir_state = 1
+ clog.info("创建成功!!!!{}\r\n".format(mk_dir_state))
+ if mk_dir_state == 0:
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat dir error!")
+ else:
+ self.Cat1FileState = 1
+ self.fileNameList = []
+ self.fileSizeList = []
+ self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间10s
+ self.Cat1FileTransTimer.stop()
+ self.Cat1FileTransTimer.start(1000,1,self.cat1FileTimerCb)
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_OK,"creat dir success!")
+
+
+ elif Code == CAT1_TCP_START_SEND_SINGLE_FILE_INFO and self.Cat1FileState == 1: #包含文件名 文件大小
+ clog.info("CAT1_TCP_START_SEND_SINGLE_FILE_INFO {} \r\n".format(CAT1_TCP_START_SEND_SINGLE_FILE_INFO))
+ self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间60s
+ # {"Code":1,"fileName":"testpy.py","fileSize":1040}
+ self.fileNameTmp = str(msg["fileName"])
+ self.fileSize = msg["fileSize"]
+ self.fileNameList = msg["fileNameList"]
+ # self.fileSizeList.append({"fileName":self.fileNameTmp,"fileSize":int(self.fileSize)})
+ path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)
+ clog.info("self.fileNameTmp {} self.fileSize:{} self.fileNameList:{} self.fileSizeList:{}\r\n".format(self.fileNameTmp,self.fileSize,self.fileNameList,self.fileSizeList))
+ check_touch = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
+ if check_touch == True:
+ try:
+ uos.remove("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
+ except Exception as e:
+ clog.info("移除文件失败\r\n")
+ try:
+ with open(path,"w+") as fd:
+ fd.write("")
+ fd.close() #关闭文件流
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_SUCC,"1creat file or dir success!")
+ except Exception as e:
+ clog.info("创建文件失败\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"1creat file or dir err!")
+ else:
+ try:
+ clog.info("self.fileNameTmp 111111{}\r\n".format(self.fileNameTmp))
+ with open(path,"w+") as fd:
+ fd.write("")
+ fd.close() #关闭文件流
+ self.crc_err = 0
+ clog.info("self.fileNameTmp {}\r\n".format(self.fileNameTmp))
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_SUCC,"2creat file or dir success!")
+ except Exception as e:
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"2creat file or dir err!")
+ clog.info("创建文件失败\r\n")
+
+ elif Code == CAT1_TCP_START_SEND_FILE_DATA and self.Cat1FileState == 1: #文件数据
+ self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间10s
+ clog.info("CAT1_TCP_START_SEND_FILE_DATA {} self.fileNameTmp:{}\r\n".format(CAT1_TCP_START_SEND_FILE_DATA,self.fileNameTmp))
+ # {"Code":2,"data":"89ggjdggsjgdj"}
+ if len(self.fileNameTmp) == 0: #文件名不能为空
+ return
+ data = msg["data"]
+ if len(data) == 0:
+ return
+ clog.info(" (data):{}\r\n".format(len(data)))
+ tmpdata = str(data)
+ head = tmpdata[0:2] #FE
+ if head != CAT1_FILE_DATA_HEAD or len(tmpdata) <= 8: #必须大于8 FF+012C+DATA+crc(一个字节89)
+ clog.info("head {}\r\n".format(head))
+ self.__Socket_TCP_file_noreply(CAT1_SEND_HEAD_ERR,"head error!")
+ return
+ datalen = str(tmpdata[2:6]) #012c
+ datalen = int("0x" + datalen, 16) #转换成十进制数
+ data_buf = tmpdata[6:] # 数据
+ data_buf = data_buf[:-2] #最后两个往前的数据
+ crc = tmpdata[-2:] # 最后两个字符是 crc 一个字节
+ clog.info("crc ===!111111:{} {} len:{} {}\r\n".format(crc,type(crc),datalen,len(str(data_buf))))
+ if len(str(data_buf)) == 0 or len(str(data_buf)) != datalen: #数据为空
+ self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"crc error or data null!")
+ return
+ # crclist=self.crc_cal(data_buf)
+ # newcrc = crclist[1]
+ # news = crclist[0]
+ # if len(str(crc)) == 0:
+ # self.__Socket_TCP_file_noreply(CAT1_CRC_ERROR,"crc error!")
+ # return
+ # decnumCrcCal = int("0x" + str(newcrc), 16) #转换成十进制数
+ # decnumCrc = int("0x" + str(crc), 16) #转换成十进制数
+ # clog.info("crc:{} newcrc:{}\r\n".format(crc,newcrc,decnumCrc,decnumCrcCal))
+ # if decnumCrcCal != decnumCrc and news == 0:
+ # clog.info("newcrc is not === crc crc校验出错不一致\r\n")
+ # self.__Socket_TCP_file_noreply(CAT1_CRC_ERROR,"crc error!")
+ # return
+ data = str(data_buf)
+ path = "{}/{}".format(BAK_FILE_PATH,str(self.fileNameTmp))
+ clog.info("py path:{} self.fileNameTmp:{}\r\n".format(path,self.fileNameTmp))
+ try:
+ with open(path,"a") as fd:
+ fd.write(data)
+ fd.close() #关闭文件流
+ self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_SUCC,"write file success!")
+ clog.info("写文件成功!!!!!\r\n")
+ except Exception as e:
+ self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"write file error!")
+ clog.info("写文件失败没有内存!!!!!{}:\r\n".format(e))
+
+ elif Code == CAT1_TCP_START_OTA_FAILE and self.Cat1FileState == 1: #取消文件传输 OTA失败 移除目录文件
+ clog.info("CAT1_TCP_START_OTA_FAILE {} \r\n".format(CAT1_TCP_START_OTA_FAILE))
+ self.allPyRecvFlag = 0
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"OTA FAILE")
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ self.deleteTmpFile()
+ self.deleteUsrTmpFile()
+ pass
+ elif Code == CAT1_TCP_START_SEND_ALLFILE_FINESH and self.Cat1FileState == 1: #全部文件传输完成
+ if self.bakFlag == "0":
+ clog.info("self.bakFlag auto:\r\n")
+ if self.allPyRecvFlag == 1:
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ else:
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ clog.info("重启 auto:\r\n")
+ self.Cat1OtaTimeOut.stop()
+ self.Cat1TimeCount = 0
+ self.ota_state = 1
+ self.allPyRecvFlag = 1 #所有的py文件接收完成
+ self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut)
+ return
+ clog.info("BAK_FILE_FUN!!!!!!\r\n")
+ tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
+ if tmp_dir == True:
+ filenamesList = uos.listdir(BAK_FILE_PATH)
+ list1 = sorted(filenamesList)
+ list2 = sorted(self.fileNameList)
+ clog.info("filenamesList:{} self.fileNameList:{} {}{}\r\n".format(filenamesList,self.fileNameList,type(filenamesList),type(self.fileNameList)))
+ if list1 != list2: #传输的文件列表和BLE不一致说明有文件没有传输完成不再重启CAT1
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ clog.info("self.Cat1PyFile444!!!:{}\r\n".format(self.Cat1FileState))
+ self.Cat1FileTransTimer.stop()
+ self.deleteUsrTmpFile()
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+ return
+
+ try:
+ copy_state = 1
+ compare_flag = 1
+ copy_flag = 0
+ filenamesList = uos.listdir(BAK_FILE_PATH)
+ for tmp in filenamesList: #将传输的文件 copy到usr目录下
+ clog.info("filenamesList for :{}\r\n".format(filenamesList))
+ dst_path = "{}/{}".format(USR_FILE_PATH,tmp) #目标目录文件
+ # if ql_fs.path_exists(dst_path) == False:
+ # try:
+ # copy_flag = 1
+ # ql_fs.touch(dst_path,"")
+ # except Exception as e:
+ # clog.info("创建文件失败!!!!!\r\n")
+
+ # if copy_flag == 0:
+ # clog.info("创建文件失败!!!!!copy_flag\r\n")
+ # copy_state = 0
+ # break
+ src_path = "{}/{}".format(BAK_FILE_PATH,tmp) #源目录文件
+ ret = False
+ file_size = 0
+
+ try:
+ ret = ql_fs.file_copy(dst_path,src_path)
+ clog.info("copy ret!!!!!:{}\r\n".format(ret))
+ if ret == True:
+ dstfile_size = ql_fs.path_getsize(dst_path)
+ srcfile_size = ql_fs.path_getsize(src_path)
+
+ clog.info("copy dstfile_size:{} srcfile_size:{}\r\n".format(dstfile_size,srcfile_size))
+ if dstfile_size != srcfile_size:
+ compare_flag = 0
+ break
+ else: #拷贝完之后比较大小一致移除文件
+ try:
+ compare_flag = 1
+ uos.remove(src_path)
+ filenamesList = uos.listdir(BAK_FILE_PATH)
+ clog.info("remove filenamesList :{}\r\n".format(filenamesList))
+ except Exception as e:
+ clog.info("copy file \r\n")
+ else:
+ compare_flag = 0
+ break
+
+ except Exception as e:
+ clog.info("copy file \r\n")
+
+
+ if copy_state == 0 or compare_flag == 0 : #比较失败 或者copy失败没有内存了
+ self.deleteUsrTmpFile()
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22") #传输文件完之后最后提示是否成功失败
+ return
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ clog.info("重启 auto:\r\n")
+ self.Cat1OtaTimeOut.stop()
+ self.Cat1TimeCount = 0
+ self.ota_state = 1
+ self.allPyRecvFlag = 1 #所有的py文件接收完成
+ self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut)
+ except Exception as e:
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33") #传输文件完之后最后提示是否成功失败
+ self.deleteUsrTmpFile()
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ else:
+ if self.ota_state == 1:
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ pass
+ else:
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ self.deleteUsrTmpFile()
+ clog.info("cat1 ota\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+
+
+ elif Code == CAT1_TCP_START_OTA_SUCC and self.Cat1FileState == 1:
+ if self.bakFlag == "0":
+ self.deleteUsrTmpFile()
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ if self.allPyRecvFlag == 1: #所有的py文件接收完成
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ else:
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!") #传输文件完之后最后提示是否成功失败
+ return
+
+
+ if self.allPyRecvFlag == 0: #没有接收完成就发送OTA成功的标识
+ self.deleteTmpFile()
+ self.deleteUsrTmpFile()
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+ return
+ tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
+ if tmp_dir == True:
+ filenamesList = uos.listdir(BAK_FILE_PATH)
+ list1 = sorted(filenamesList)
+ list2 = sorted(self.fileNameList)
+ clog.info("filenamesList:{} self.fileNameList:{} {}{}\r\n".format(filenamesList,self.fileNameList,type(filenamesList),type(self.fileNameList)))
+ if list1 != list2: #传输的文件列表和BLE不一致说明有文件没有传输完成不再重启CAT1
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ clog.info("self.Cat1PyFile444!!!:{}\r\n".format(self.Cat1FileState))
+ self.Cat1FileTransTimer.stop()
+ self.deleteUsrTmpFile()
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+ return
+
+ try:
+ copy_state = 1
+ compare_flag = 1
+ copy_flag = 0
+ filenamesList = uos.listdir(BAK_FILE_PATH)
+ for tmp in filenamesList: #将传输的文件 copy到usr目录下
+ clog.info("filenamesList for :{}\r\n".format(filenamesList))
+ dst_path = "{}/{}".format(USR_FILE_PATH,tmp) #目标目录文件
+ # if ql_fs.path_exists(dst_path) == False: #usr下面没有就创建文件写空的数据
+ # try:
+ # ret = ql_fs.touch(dst_path,"")
+ # clog.info("创建文件成功!!!!!:ret {}\r\n".format(ret))
+ # if ret == 0:
+ # copy_flag = 1
+ # except Exception as e:
+ # clog.info("创建文件失败!!!!!\r\n")
+
+ # if copy_flag == 0:
+ # clog.info("创建文件失败!!!!!copy_flag\r\n")
+ # copy_state = 0
+ # break
+ src_path = "{}/{}".format(BAK_FILE_PATH,tmp) #源目录文件
+ ret = False
+ file_size = 0
+
+ try:
+ ret = ql_fs.file_copy(dst_path,src_path)
+ clog.info("copy ret!!!!!:{}\r\n".format(ret))
+ if ret == True:
+ dstfile_size = ql_fs.path_getsize(dst_path)
+ srcfile_size = ql_fs.path_getsize(src_path)
+
+ clog.info("copy dstfile_size:{} srcfile_size:{}\r\n".format(dstfile_size,srcfile_size))
+ if dstfile_size != srcfile_size:
+ compare_flag = 0
+ break
+ else: #拷贝完之后比较大小一致移除文件
+ try:
+ compare_flag = 1
+ uos.remove(src_path)
+ filenamesList = uos.listdir(BAK_FILE_PATH)
+ clog.info("remove filenamesList :{}\r\n".format(filenamesList))
+ except Exception as e:
+ clog.info("copy file \r\n")
+ else:
+ compare_flag = 0
+ break
+
+ except Exception as e:
+ clog.info("copy file \r\n")
+
+
+ if copy_state == 0 or compare_flag == 0 : #比较失败 或者copy失败没有内存了
+ self.deleteUsrTmpFile()
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!22") #传输文件完之后最后提示是否成功失败
+ return
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ clog.info("重启 auto:\r\n")
+ self.Cat1OtaTimeOut.stop()
+ self.Cat1TimeCount = 0
+ self.ota_bstate = 1
+ self.conn.close()
+ self.Cat1OtaTimeOut.start(10000,0,self.otaTimeOut)
+ except Exception as e:
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota faile!33") #传输文件完之后最后提示是否成功失败
+ self.deleteUsrTmpFile()
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ else:
+ if self.ota_bstate == 1:
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ pass
+ else:
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ self.deleteUsrTmpFile()
+ clog.info("cat1 ota\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
+
+ elif Code == CAT1_TCP_SEND_SINGLE_FINESH and self.Cat1FileState == 1: #单个文件传输完成
+ clog.info("CAT1_TCP_SEND_SINGLE_FINESH {} self.fileNameTmp:{}\r\n".format(CAT1_TCP_SEND_SINGLE_FINESH,self.fileNameTmp))
+ self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间10s
+ tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
+ if tmp_dir == True:
+ tmp_file = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
+ if tmp_file == True: #文件存在
+ file_size = ql_fs.path_getsize("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
+ clog.info("file size :file_size:{} self.fileSize:{}\r\n".format(file_size,self.fileSize))
+ if self.fileSize != file_size: #文件大小不一致 传输出错
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") #结束文件接收不完整的
+
+ else: #传完一个文件copy到usr下面
+ if self.bakFlag == "0":
+
+ dst_path = "{}/{}".format(USR_FILE_PATH,self.fileNameTmp) #目标文件
+ src_path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp) #源文件目录 /usr/TmpFile/
+ ret = False
+ try:
+ clog.info("touch single file!!!!!dtpath111:{}\r\n".format(dst_path,src_path))
+ ret = ql_fs.file_copy(dst_path,src_path)
+ if ret == True:
+ dstfile_size = ql_fs.path_getsize(dst_path)
+ srcfile_size = ql_fs.path_getsize(src_path)
+ if dstfile_size != srcfile_size: #copy 之后比较文件大小一不一致
+
+ src_file = ql_fs.path_exists(src_path) #删除文件
+ if src_file == True:
+ try:
+ uos.remove(src_path) #移除文件
+ except Exception as e:
+ clog.info("copy 文件异常出错 yichu!{}:\r\n".format(e))
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") #结束文件接收完整的
+ return
+ else:
+ src_file = ql_fs.path_exists(src_path) #删除文件
+ if src_file == True:
+ try:
+ uos.remove(src_path) #移除文件
+ except Exception as e:
+ clog.info("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file size ok") #文件大小不一致
+ return
+ else:
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") #copy失败
+ except Exception as e:
+ clog.info("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err") #copy失败
+ else:
+ clog.info("self.bakFlag 1:\r\n")
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file copy ok") #copy失败
+ else:
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"creat file or dir err!")
+ pass
+ else:
+ self.__Socket_TCP_file_noreply(CAT1_CREAT_DIR_FAILE,"creat file or dir error!")
+ pass
+
+
+ else:
+ if self.Cat1FileState == 0:
+ if self.Cat1FileReplayBle == 1:
+ return
+ self.Cat1FileReplayBle = 1
+ self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_SUCC,"reset start!") #结束文件接收不完整的
+ clog.info("错误信息!!!!!\r\n")
+ self.Cat1FileState == 0
+ self.Cat1FileTransTimer.stop() #//关闭定时器
+ self.Cat1PyFileTimout = 0
+ self.fileNameList=[]
+ self.deleteTmpFile()
+ self.deleteUsrTmpFile()
+
+
+ def otaTimeOut(self,*argc):
+
+
+ clog.info("重启成功！！！！！！！！\r\n")
+ # 上层直接重启即可
+ # Power.powerRestart()
+
+TcpService = TcpServiceInit()
+
+
--- /dev/null
+import log
+
+# 设置日志输出级别
+log.basicConfig(level=log.INFO)
+fota_log = log.getLogger("telecom_dmp")
}
return 0;
}
+#include "cat1_tcpServer.h"
+
+static uint32_t Tcptest(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(strCommonCmd);
+ uint8_t argv[PPG_MAX_ARGC][PPG_MAX_ARGV_LEN] = { 0 };
+ uint32_t argc = 0;
+
+ int ret = ConvertCmdToParam(para, paraLen, argv, &argc);
+ if (ret != PPG_SUCCESS) {
+ printf("CAT1TEST ATCMD Convert Command Failed\n");
+ return ERRCODE_FAIL;
+ }
+
+ re_connect();
+ return 0;
+}
{ (char *)"AT^CALL_READ_ADRESSBOOK", read_ADDRESS, (char *)"1" },
{ (char *)"AT^CALLVOLUME", VoiceCallSetVolume, (char *)"1" },
{ (char *)"AT^CALLVOICE", VoiceCallcontrol, (char *)"1" },
+ { (char *)"AT^TCPTEST", Tcptest, (char *)"1" },
};
#include "custom_runtime.h"
#include "bleANCS.h"
#include "cat1_tcpServer.h"
+#include "custom_utils.h"
+#include "broadcast_feature.h"
+#include "cmsis_os2.h"
+extern osStatus_t osDelay(uint32_t ticks);
+#define cat1_msleep(ms) osDelay(ms) /* osDelay(1) : 1ms */
+
#ifdef __cplusplus
static uint8_t g_skip_cat1_service_udp_transfer = 0;
+uint8_t is_need_udp_updata=0;
+
+
#define PEER_IP "172.16.1.2"
#define PEER_PORT 5001
#define SERVER_IP "172.16.1.5"
#else
#define CAT1_PY_PATH "/system/cat1ota" //存放需要升级的py文件路径
#endif
+
+
+#ifdef SINGLE_USER_PARTITION
+#define CAT1_PY_UDP_PATH "/user/system/cat1otaudp" //存放需要升级的py文件路径
+#else
+#define CAT1_PY_UDP_PATH "/system/cat1otaudp" //存放需要升级的py文件路径
+#endif
+
+#ifdef SINGLE_USER_PARTITION
+#define CAT1_PY_IS_NEED_UDP_PATH "/user/system/cat1otaudp/is_need_updata.txt" //存放需要升级的py文件路径
+#else
+#define CAT1_PY_IS_NEED_UDP_PATH "/system/cat1otaudp/is_need_updata.txt" //存放需要升级的py文件路径
+#endif
+
#define CAT1_REPLYA_FILE_SIZE_FUN 1 //是否需要CAT1回复文件大小一致传输完单个文件是否与SIZE大小匹配比较
static osTimerId_t file_transfer_timer=NULL;
static uint8_t timerOut_count = 0;
{
int content_length = (int)strlen(content);
+ printf("content_length %d\r\n",content_length);
if(content_length > MAX_TCP_MSG_BUFFER_LEN || content == NULL)
{
printf("content data error: content_length %d %s\r\n",content_length,content);
int len = 0;
len = pack_tlv_format(tx_buffer,mode,cmd, content);
- // printf("msg_format_type %d \n",g_msg_format_type,len);
+ printf("msg_format_type %d %d\n",g_msg_format_type,len);
int err = 0;
if( len > 0 ) {
+
err = sendto(g_listen_sock, tx_buffer, len, 0, (struct sockaddr *)&filesourceAddr, sizeof(filesourceAddr));
+ // err=send(g_listen_sock,tx_buffer,len,0);
+ cat1_msleep(10);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"udp_send_response\n");
if (err < 0) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Error occured during sending: errno %d\n", errno);
}
} else {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Error occured unkown send data\n");
}
+
}
#include "uart_porting.h"
void ble_tcp_send_msg_toCat1(uint8_t mode,uint8_t cmd,char *content)
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Error cat1 poweroff skipp send data\n");
return ;
}
+ printf("ble_tcp_send_msg_toCat1 1\r\n");
+
uapi_cat1_wakeup_cat1(1);
// uart_port_register_irq(UART_BUS_0);
osal_irq_enable(UART_1_IRQN);
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP," g_skip_cat1_service_udp_transfer \n");
return ;
}
- char station_tx_buffer[MAX_TCP_MSG_BUFFER_LEN] = {0};
+ char *station_tx_buffer=(char*)malloc(MAX_TCP_MSG_BUFFER_LEN);
if( filesourceAddr.sin_port != 0 ) {
udp_send_response(station_tx_buffer,mode,cmd, content);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ble_tcp_send_msg_toCat1 2\n");
}
+ free(station_tx_buffer);
+
uapi_cat1_wakeup_cat1(0);
}
cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_START_SEND_FILE_DATA);
cJSON_AddStringToObject(dataJSON,"data",(char *)data); // FE 头 0012c 文件长度 + data+crc
json_format = cJSON_PrintUnformatted(dataJSON);
- // printf("start cat1_ota_send_data json_format:%s %d\r\n",data,strlen(data));
+ printf("start cat1_ota_send_data json_format:%s %d\r\n",data,strlen(data));
cJSON_Delete(dataJSON);
printf("cat1_ota_send_data two:\r\n");
ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
+ // if(json_format)
+ printf("free json_format \r\n");
cJSON_free(json_format);
break;
// case CAT1_TCP_START_OTA_FAILE: //OTA失败
fclose(fp);
fp = NULL;
}
+ uint8_t TRANSMIT_DATA=OTA_UPDATA_FAIL;
+
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
}
static void cat1_file_Timer_CallBack(int data_tmp)
if(file_count == 0){ //目录下没有文件
return;
}
+
+ send_dir_info();
+ noreplayCount = 0;
+ uint32_t tick;
+ osStatus_t retTimer;
+ if(file_transfer_timer == NULL){
+ file_transfer_timer = osTimerNew((osTimerFunc_t)cat1_file_Timer_CallBack, osTimerPeriodic, NULL, NULL);
+ tick = 1000;// osMs2Tick(1000);
+ retTimer = osTimerStart(file_transfer_timer, tick);
+ if (retTimer != osOK && file_transfer_timer != NULL) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"StartCallTimer osTimerStart failed, ret = %lx!!", retTimer);
+ osTimerDelete(file_transfer_timer);
+ file_transfer_timer = NULL;
+ }
+ }
+}
+
+void read_UDP_dir(void){
+
+ for (int i = 0; i < DEFAULT_MAX_FILE_COUNT; i++) { //释放内存
+ if(fileNameList[i] != NULL){
+ free(fileNameList[i]);
+ fileNameList[i] = NULL;
+ }
+ }
+
+ file_count = 0;
+
+ printf("fileNameList[file_count]\r\n");
+
+ for(int i=0;i<5;i++)
+ {
+ fileNameList[file_count] = (char *)malloc(DEFAULT_MAX_FILE_NAME_SIZE * sizeof(char));
+
+ if(i==0)
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","telecom_dmp.py");
+ else if (i==1)
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","china_mobile_dmp.py");
+ else if (i==2)
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","cat1Service.py");
+ else if (i==3)
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","main.py");
+ else
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","tcpService.py");
+
+ printf("fileNameList[file_count] %s\r\n",fileNameList[file_count]);
+ file_count+=1;
+ }
+
send_dir_info();
noreplayCount = 0;
uint32_t tick;
file_transfer_timer = NULL;
}
}
+
}
+
void send_curfile_info_data(void)
{
cat1_ota_flag = CAT1_TCP_START_SEND_SINGLE_FILE_INFO;
if(strlen(fileNameList[curfilecount]) != 0 && filesize != 0){
char file_path[DEFAULT_MAX_FILE_NAME_SIZE]={0};
memset(file_path,0,DEFAULT_MAX_FILE_NAME_SIZE);
+ if(is_need_udp_updata)
+ sprintf_s(file_path,DEFAULT_MAX_FILE_NAME_SIZE,"%s/%s",CAT1_PY_UDP_PATH,fileNameList[curfilecount]);
+ else
sprintf_s(file_path,DEFAULT_MAX_FILE_NAME_SIZE,"%s/%s",CAT1_PY_PATH,fileNameList[curfilecount]);
+
+
if(fp != NULL){
fclose(fp);
fp = NULL;
struct dirent *entry;
char file_path[DEFAULT_MAX_FILE_NAME_SIZE]={0};
memset(file_path,0,DEFAULT_MAX_FILE_NAME_SIZE);
+
+ if(is_need_udp_updata)
+ sprintf_s(file_path,DEFAULT_MAX_FILE_NAME_SIZE,"%s/%s",CAT1_PY_UDP_PATH,fileNameList[curfilecount]);
+ else
sprintf_s(file_path,DEFAULT_MAX_FILE_NAME_SIZE,"%s/%s",CAT1_PY_PATH,fileNameList[curfilecount]);
count+=1;
switch (mode)
{
case READ_DIR_INFO: //读文件目录信息
+ printf("READ_DIR_INFO\r\n");
+ if(is_need_udp_updata)
+ read_UDP_dir();
+ else
read_dir();
break;
case READ_FILE_DATA_INFO://收到CAT1回复开始发送文件信息
void start_cat1_ota(void){
stop_cat1_ota();
send_data_case(READ_DIR_INFO); //开始OTA 就开始升级py文件
+
+ uint8_t TRANSMIT_DATA=START_CAT1_OTA;
+
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
+ uapi_cat1_keep_wakeup(1);
}
void Cat1_OTA(uint8_t ota_state)
{
{
return 0;
}
+ uint8_t shutdowflag = 1;//重启
switch (cmd)
{
case CAT1_REPLAY_CREAT_DIR_FAILE: //cat1:创建临时文件夹失败
break;
case CAT1_REPLAY_OTA_SUCC: //ota 成功失败与否 收到CAT1的回复就停止计时器
stop_cat1_ota();
+ //成功直接重启
+ if(is_need_udp_updata)
+ {
+ remove(CAT1_PY_IS_NEED_UDP_PATH);
+ }
+ CustomEventPublish(TOPIC_EVENT_SHUTDOWN_ANIMATIOR, &shutdowflag, sizeof(shutdowflag));
//添加GUI
break;
case CAT1_REPLAY_OTA_FALIE:
+
stop_cat1_ota();
+
break;
case CAT1_REPLAY_FILE_SIZE_OK: //文件大小发送和接收的一致
read_file_info_data();
return listen_sock;
}
-#include "cmsis_os2.h"
-extern osStatus_t osDelay(uint32_t ticks);
-#define cat1_msleep(ms) osDelay(ms) /* osDelay(1) : 1ms */
+
+static int tcp_socket_file_init()
+{
+ int addr_family;
+ int ip_protocol;
+ int opt = 1;
+ struct sockaddr_in destAddr;
+ char addr_str[128];
+
+ // destAddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ destAddr.sin_addr.s_addr = inet_addr(SERVER_IP);
+ destAddr.sin_family = AF_INET;
+ destAddr.sin_port = htons(PORT);
+ addr_family = AF_INET;
+ ip_protocol = IPPROTO_IP;
+ inet_ntoa_r(destAddr.sin_addr, addr_str, sizeof(addr_str) - 1);
+
+ int listen_sock = socket(addr_family, SOCK_STREAM, ip_protocol);
+ if (listen_sock < 0) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Unable to create socket: errno %d\n", errno);
+ return -1;
+ }
+ // setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+ // setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+ filesourceAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+ filesourceAddr.sin_family = AF_INET;
+ filesourceAddr.sin_port = htons(PEER_PORT);
+
+ return listen_sock;
+}
+
+
+void re_connect(void)
+{
+ socklen_t addrLen = sizeof(filesourceAddr);
+ close(g_listen_sock);
+ // while (1)
+ {
+ int connret=connect(g_listen_sock, (struct sockaddr *)&filesourceAddr,addrLen);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Unable to connect: errno %d\n", errno);
+ if(connret=0)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"connect succ\n");
+ // break;
+ }
+ else
+ {
+ cat1_msleep(1000);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"connecting...\n");
+ }
+ }
+}
+
+uint8_t errno_count=0;
+
void cat1_server_file_task(void *pvParameters)
{
char rx_buffer[512];
int index;
socklen_t addrLen = sizeof(filesourceAddr);
while (1) {
- if( g_listen_sock > 0 ) close(g_listen_sock);
- g_listen_sock = udp_socket_file_init();
- if( g_listen_sock < 0 ) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"socket init fail and retry\n");
- // vTaskDelay(1000/portTICK_RATE_MS);
+ if(errno_count>3)
+ {
+ //如果失败太多次将退出循环，避免浪费系统资源
+ // return;
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"errno count %d\n",errno_count);
+ }
+ if( g_listen_sock > 0 )
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"close(g_listen_sock)\n");
+ close(g_listen_sock);
+ }
+
+ if(is_need_udp_updata==0)
+ {
+ g_listen_sock = tcp_socket_file_init();
+ if( g_listen_sock < 0 ) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"socket init fail and retry\n");
+ // vTaskDelay(1000/portTICK_RATE_MS);
+ errno_count++;
+ cat1_msleep(1000);
+ continue;
+ }
cat1_msleep(1000);
- continue;
+ int connret=connect(g_listen_sock, (struct sockaddr *)&filesourceAddr,addrLen);
+ if(connret>=0)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"connect succ\n");
+ }
+ else
+ {
+ cat1_msleep(1000);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Unable to connect: errno %d\n", errno);
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"connecting...\n");
+ errno_count++;
+ continue;
+ }
}
+ else
+ {
+ g_listen_sock = udp_socket_file_init();
+ if( g_listen_sock < 0 ) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"socket init fail and retry\n");
+ // vTaskDelay(1000/portTICK_RATE_MS);
+ cat1_msleep(1000);
+ errno_count++;
+ continue;
+ }
+ }
+
+ errno_count=0;
+
while (1) {
if (len < 0) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"recv failed: errno %d\n", errno);
break;
+ // continue;
} else if (len == 0) {
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Connection closed\n");
break;
+ // continue;
}
// Data received
rx_buffer[len] = '\0'; // Null-terminate whatever we received and treat like a string
taskcfg.attr.stack_size = CAT1_SERVICE_TASK_SIZE;
taskcfg.func = cat1_server_file_task;
taskcfg.use_mem = USE_EXTEND_MEM;
+ FILE* fp= fopen(CAT1_PY_IS_NEED_UDP_PATH,"rb");
+ if(fp)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"is_need_udp_updata !\r\n");
+ is_need_udp_updata=1;
+ fclose(fp);
+ fp=NULL;
+ }
+
errcode_t ret=uapi_create_osThread_custom(&taskcfg);
+
+
if(ret != ERRCODE_SUCC)
{
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"create cat1_service_file failed %d!\r\n",ret);
return ERRCODE_SUCC;
}
+char* xor_encrypt_decrypt(const char* message, const char* key) {
+ if (message == NULL || key == NULL) {
+ return NULL;
+ }
+
+ size_t message_len = strlen(message);
+ size_t key_len = strlen(key);
+
+ // 分配内存用于存储结果
+ char* result = (char*)malloc(message_len + 1);
+ if (result == NULL) {
+ return NULL; // 内存分配失败
+ }
+
+ // 执行 XOR 操作
+ for (size_t i = 0; i < message_len; ++i) {
+ result[i] = message[i] ^ key[i % key_len];
+ }
+ result[message_len] = '\0'; // 确保字符串以 null 结尾
+
+ return result;
+}
+
+
+
#ifdef __cplusplus
}
#define FILE_TRANSFER_CMD 0x01
#define UDP_SEND_CMD 0x02
+void re_connect(void);
+
+extern uint8_t is_need_udp_updata;
+
typedef enum Ble_send_file_mode { //BLE 发送文件模式
READ_DIR_INFO = 0,// BLE读目录文件 重新发送收到CAT1回复
READ_FILE_DATA_INFO = 1, //读文件信息 重新发送收到CAT1回复
projects / mirrors / FD230.git / commitdiff