+++ /dev/null
-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 osTimer
-import sim
-import modem
-import utime
-import checkNet
-import atcmd
-import ql_fs
-import pm
-import sms
-
-from usr.EventMesh import eventMesh
-
-log.basicConfig(level=log.INFO)
-clog = log.getLogger("cat1")
-
-CAT1_SERVICE_HEAD = 'FE'
-PROJECT_NAME = "Cat1SlipUDPService"
-PROJECT_VERSION = "PY_SRV_V17"
-CONFIG_JSON="/usr/system_config.json"
-CURRENT_APP_TYPE="pysrv"
-
-voiceCall.setVolume(10)
-lpm_fd = pm.create_wakelock("system_lock", len("system_lock"))
-pm.wakelock_lock(lpm_fd)
-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"
-
-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)
- 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))
- return keyvalue
-
-set_version_to_json_config(CURRENT_APP_TYPE,PROJECT_VERSION)
-
-
-audio.set_qdai_cfg(1,0,0,1,0,0,1,1)
-def ExtIntfun(args):
- if args[1] == 0:
- pm.wakelock_lock(lpm_fd)
- elif args[1] == 1:
- pm.wakelock_unlock(lpm_fd)
-extint = ExtInt(ExtInt.GPIO22, ExtInt.IRQ_RISING_FALLING, ExtInt.PULL_DISABLE, ExtIntfun)
-extint.enable()
-
-gpioWakeBT = Pin(Pin.GPIO21, Pin.OUT, Pin.PULL_DISABLE, 1)
-gpioWakeBT.set_dir(Pin.OUT)
-gpioWakeBT.write(0)
-
-UDP_CMD_GET_CAT1VER = '0'
-UDP_CMD_DIAL_NUMB = '1'
-UDP_CMD_HUNGUP = '2'
-UDP_CMD_ANSWER = '3'
-UDP_CMD_CAT1_OTA_UPDATE = '4'
-UDP_CMD_SEND_SMS = '5'
-UDP_CMD_GET_TIME = '6'
-UDP_CMD_GET_RECV_NETWORKSTAT = '7'
-UDP_MSG_SMS = '8'
-UDP_CMD_ATCMD = '9'
-UDP_MSG_CALL_CONNECTED = 'A'
-UDP_MSG_CALL_DISCONNECTED = 'B'
-UDP_MSG_COMMING_CALL = 'C'
-UDP_MSG_REPLY = 'F'
-
-class Cat1Service:
- AP = 0
- STA = 1
- def __init__(self, uart=UART.UART4, mode=AP):
- self.__uart = uart
- self.__mode = mode
- self.__message = ''
- self.__err = 0
- self.__net_connected = 0
- self.__wait_resp = 0
- self.__waiting_netstat = 0
- slip.destroy()
- ret = slip.construct(self.__uart, self.__mode, 0)
- if ret != 0:
- return None
- 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
- 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):
- sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.TCP_CUSTOMIZE_PORT)
- sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
- 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):
- if cmd == "00":
- modem_ver = modem.getDevFwVersion()
- self.reply_cmd('00',"pyVer:{}@modemVer:{}".format(PROJECT_VERSION,modem_ver))
- elif cmd == "01":
- if eventMesh.publish("get_volte_switch") == 1:
- ret = voiceCall.callStart(str(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":
- 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":
- 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 == "06":
- time=utime.localtime()
- zone=utime.getTimeZone()
- self.reply_cmd('06',"{0}@{1}".format(time,zone))
- elif cmd == "07":
- 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])
- operator = net.operatorName()
- signal = net.csqQueryPoll()
- self.reply_cmd('07',"imei:{0}@sim:{1}@oper:{2}@signal:{3}@net:{4}".format(imei,simstat,operator,signal,netstat))
- elif cmd == "09":
- resp=bytearray(50)
- ret=atcmd.sendSync("{}\r\n".format(parm),resp,'',10)
- if ret == 0:
- self.reply_cmd('09',"{}".format(resp.decode()))
- else:
- self.reply_cmd('09',"{}".format("at error"))
-
- elif cmd == "10" or cmd == "12" or cmd == "14":
- if 1:
- if eventMesh.publish("get_dmp_change_mode") == 1:
- self.telecom_recv_cmd(cmd,parm)
- else:
- pass
-
- if 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)
- eventMesh.publish("set_dmp_change_mode",on)
- elif cmd == "16":
- if 1:
- if eventMesh.publish("get_dmp_change_mode") > 1:
- self.china_mobile_recv_cmd(cmd,parm)
- else:
- pass
- elif cmd == "17":
- eventMesh.publish("set_factory_status",int(parm))
- elif cmd == "18":
- eventMesh.publish("set_dmp_cm_address",str(parm))
- elif cmd == "19":
- voiceCall.startDtmf(str(parm),100)
- 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)
- elif cmd == "12":
- pass
- elif cmd == "14":#
- pass
- pass
-
- def set_volte_switch(self,event,msg):
- self.volte_switch = int(msg)
-
- def get_volte_switch(self,event,msg):
- 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)
- elif cmd == "16":
- eventMesh.publish("set_dev_mac",str(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):
- 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]
- if sms_max >= msg_nums and sms_max > 0:
- sms.deleteMsg(1,4)
-
- 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]
- 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)
- 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):
- message0=sms.searchPduMsg(index)
- 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)
- 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)
- 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()
- if sms_data == -1:
- return
- sms_max = sms_data[0][2]
- 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]
- 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)
- return 0
-
- def notifyConnecteCall(self, phone_numb):
- self.clear_remain()
- __head = '0A'
- __message = str(phone_numb)
- self.__Socket_UDP(__head, __message)
- return 0
-
- def notifyDisconnectCall(self, phone_numb):
- self.clear_remain()
- __head = '0B'
- __message = str(phone_numb)
- self.__Socket_UDP(__head, __message)
- 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:
- self.set_network_config()
- self.__net_connected = 1
- eventMesh.publish("set_network_state",self.__net_connected)
- self.__waiting_netstat = 0
- return 0
- else:
- 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 :
- self.clear_remain()
- message = str(_timesync)
- self.__Socket_UDP_noreply(cmd, message)
- except:
- clog.info('reply_cmd')
- return 0
-
- def clear_remain(self):
- self.__err = 0
- 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)
-
- def ipconfig(self):
- return slip.ipconfig()
-
- 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):
- return 0
- Info = dataCall.getInfo(1,0)
- default_NIC_ip = Info[2][2]
- segment_ip = '172.16.4.0'
- mask = '255.255.255.0'
- cat1service.set_default_NIC(default_NIC_ip)
- cat1service.router_add(segment_ip, mask)
-
- pri_dns = '8.8.8.8'
- sec_dns = '114.114.114.114'
- cat1service.set_dns(pri_dns, sec_dns)
- cat1service.ipconfig()
-
- def set_network_config(self):
- if (self.__net_connected == 1) :
- return 0
- Info = dataCall.getInfo(1,0)
- default_NIC_ip = Info[2][2]
- segment_ip = '172.16.1.0'
- mask = '255.255.255.0'
- cat1service.set_default_NIC(default_NIC_ip)
- cat1service.router_add(segment_ip, mask)
-
- pri_dns = '8.8.8.8'
- sec_dns = '114.114.114.114'
- cat1service.set_dns(pri_dns, sec_dns)
- cat1service.ipconfig()
- if eventMesh.publish("get_dmp_change_mode") == 0:
- return
- if 1:
- if eventMesh.publish("get_dmp_change_mode") == 1:
- eventMesh.publish("set_network_state",1)
- if 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
-
- 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
-
- def stop(self):
- slip.destroy()
- return 0
-
- def __pack_tlv_format(self, head, content):
- if len(content) == 0 or len(content) > 9999 or len(head) != 2:
- return -1
- len_str ='%04d' % len(content)
- tlv_pack = CAT1_SERVICE_HEAD+head+len_str+content
- return tlv_pack
-
- def __unpack_tlv_format(self, msg):
- self.msg = str(msg)[2:]
- 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]:
- return -1
- unpack = (tag,length,value)
- return unpack
- def __Socket_UDP(self, head, content):
- self.send_data_q.put([head,content])
- def Socket_SEND_Thread(self):
- while True:
- try:
- data=self.send_data_q.get()
- self.ack_sem=1
- self.__Socket_UDP_write( data[0], data[1])
- count=20
-
- while count & self.ack_sem :
- utime.sleep_ms(1)
- count=count-1
- self.__Socket_UDP_write( data[0], data[1])
- except Exception :
- clog.error("sned Socket >>>")
-
- def __Socket_UDP_write(self, head, content):
- try:
- 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)
- self.__err = 0
- self.__sock.sendto(msg,server_addr)
- self.__wait_resp = 1
- self.__wait_resp = 0
- return 1
- except Exception as error:
- clog.error(error)
- return 0
-
- def __Socket_UDP_noreply(self, head, content):
- self.send_data_q.put([head,content])
-
- def __Socket_Thread(self):
- while True:
- try:
- data=self.__sock.recv(1024)
- if data:
- value = self.__unpack_tlv_format(data.decode())
- if value != -1:
- if value[1] == 'FF':
- self.btmcu_cmd_handler(value[0],value[2])
- else:
- self.btmcu_cmd_handler(value[0],value[2])
- else:
- clog.error("data error!!")
- except Exception as recverr:
- if "110" in str(recverr):
- self.__err = 1
- else:
- utime.sleep(1)
- self.__sock = self.__socket_reinit()
-cat1service = Cat1Service()
-
-def voice_callback(args):
- if args[0] == 10:
- if eventMesh.publish("get_volte_switch") == 0: #关闭VOLTE功能
- voiceCall.callEnd()
- else:
- cat1service.notifyIncomingcall(args[6])
- elif args[0] == 11:
- if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
- cat1service.notifyConnecteCall(args[6])
- elif args[0] == 12:
- if eventMesh.publish("get_volte_switch") == 1: #开启VOLTE功能
- cat1service.notifyDisconnectCall(args[6])
-voiceCall.setCallback(voice_callback)
-def checknet_cb(arg):
- _thread.start_new_thread(cat1service.wait_network_ready, ())
-timer = osTimer()
-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)
-
-
-
+++ /dev/null
-from misc import Power
-import usocket
-import log
-import utime
-from machine import UART
-import _thread
-from queue import Queue
-from machine import Pin
-from machine import ExtInt
-import osTimer
-import utime
-import ql_fs
-import binascii
-import ujson
-import uos
-
-
-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_NEED_UPDATE_OTA = "11"
-CAT1_TCP_STOP_OTA = 0
-CAT1_TCP_START_OTA = 1
-CAT1_TCP_START_SEND_SINGLE_FILE_INFO= 2
-CAT1_TCP_START_SEND_FILE_DATA= 3
-CAT1_TCP_START_OTA_FAILE = 4
-CAT1_TCP_START_OTA_SUCC = 5
-CAT1_TCP_START_SEND_ALLFILE_FINESH = 6
-CAT1_TCP_SEND_SINGLE_FINESH = 7
-CAT1_TCP_START_ERROR_INFO = 255
-
-gpioWakeBT = Pin(Pin.GPIO21, Pin.OUT, Pin.PULL_DISABLE, 1)
-gpioWakeBT.set_dir(Pin.OUT)
-gpioWakeBT.write(0)
-FILE_TRANSFER_TIMEOUT=60
-class TcpServiceInit:
- AP = 0
- STA = 1
-
- 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
- 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, ())
-
- def __pack_tlv_format(self, head, content):
- head1 = head
- content1 = content
- if len(content1) == 0 or len(content1) > 9999 or len(head1) != 2:
- return -1
- len_str ='%04d' % len(content1)
- tlv_pack = CAT1_SERVICE_HEAD+head1+len_str+content1
- return tlv_pack
-
- def __unpack_tlv_format(self, msg):
- msg_tmp = str(msg)[2:]
- 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]:
- return -1
- unpack = (tag,length,value)
- return unpack
-
- def __socket_file_init(self):
- self.sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM, usocket.IPPROTO_TCP_SER)
- self.sock.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
- bind_addr = ('172.16.1.2', 5001)
- self.sock.bind(bind_addr)
- self.sock.listen(10)
- return self.sock
-
- 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
- try:
- self.conn.send(msg)
- except Exception as e:
- clog.info("self.__sock_file error {}".format(e))
- return 0
-
- def _client_conn_proc(self):
- while True:
- if self.conn==None:
- utime.sleep_ms(20)
- continue
- try:
- data = self.conn.recv(1024)
- if not data:
- clog.info("__Socket_File_Thread data null:\r\n")
- else:
- self.src_data(data.decode('uft-8'))
- except:
- self.conn.close()
- break
-
- def __Socket_File_Thread(self):
- while True:
- try :
- 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 :
- utime.sleep_ms(20)
-
- 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()
- data = hex_data
- crcValue = 0
- j = 0
- i = 0
- json_state = 0
- crcbuf = 0
- 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
- 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("crc_cal")
- j+=2
- crcbuf = crcValue%256
- crcbuf = 256-crcbuf
- crcbuf = crcbuf%256
- 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)
-
- def deleteUsrTmpFile(self):
- return
-
- def src_data(self,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:
- value = self.__unpack_tlv_format(data)
- self.cmd_data(value[0],value[2])
- return
- else:
- self.file_data(msg)
- pass
- def cmd_data(self,cmd,parm):
- if cmd == "01":
- self.bakFlag = str(parm)
- pass
- def file_data(self,msg):
- if "Code" in msg:
- Code = int(msg["Code"])
- if Code == CAT1_TCP_STOP_OTA:
- self.allPyRecvFlag = 0
- self.Cat1FileState = 0
- self.Cat1FileTransTimer.stop()
- self.deleteTmpFile()
- self.deleteUsrTmpFile()
- pass
- elif Code == CAT1_TCP_START_OTA:
- self.ota_state =0
- self.ota_bstate =0
- self.allPyRecvFlag = 0
- self.fileNameList = []
- self.fileSizeList = []
- 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
- except Exception as e:
- mk_dir_state = 0
- else:
- mk_dir_state = 1
- 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
- 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:
- self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT
- self.fileNameTmp = str(msg["fileName"])
- self.fileSize = msg["fileSize"]
- self.fileNameList = msg["fileNameList"]
- path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)
- 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:
- self.__Socket_TCP_file_noreply(CAT1_CREAT_FILE_ERROR,"1creat file or dir err!")
- else:
- try:
- with open(path,"w+") as fd:
- fd.write("")
- fd.close()
- self.crc_err = 0
-
- 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!")
-
-
- elif Code == CAT1_TCP_START_SEND_FILE_DATA and self.Cat1FileState == 1:
- self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT
- if len(self.fileNameTmp) == 0:
- return
- data = msg["data"]
- if len(data) == 0:
- return
- tmpdata = str(data)
- head = tmpdata[0:2]
- if head != CAT1_FILE_DATA_HEAD or len(tmpdata) <= 8:
- clog.info("head {}\r\n".format(head))
- self.__Socket_TCP_file_noreply(CAT1_SEND_HEAD_ERR,"head error!")
- return
- datalen = str(tmpdata[2:6])
- datalen = int("0x" + datalen, 16)
- data_buf = tmpdata[6:]
- data_buf = data_buf[:-2]
- crc = tmpdata[-2:]
- 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
- data = str(data_buf)
- path = "{}/{}".format(BAK_FILE_PATH,str(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!")
-
- except Exception as e:
- self.__Socket_TCP_file_noreply(CAT1_WRITE_FILE_ERROR,"write file error!")
-
- elif Code == CAT1_TCP_START_OTA_FAILE and self.Cat1FileState == 1:
- 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":
- 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()
- self.Cat1OtaTimeOut.stop()
- self.Cat1TimeCount = 0
- self.ota_state = 1
- self.allPyRecvFlag = 1
- self.Cat1OtaTimeOut.start(5000,0,self.otaTimeOut)
- 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)
- if list1 != list2:
- self.deleteTmpFile()
- self.Cat1FileState = 0
- 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:
- dst_path = "{}/{}".format(USR_FILE_PATH,tmp)
- src_path = "{}/{}".format(BAK_FILE_PATH,tmp)
- ret = False
- file_size = 0
- try:
- 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:
- compare_flag = 0
- break
- else:
- try:
- compare_flag = 1
- uos.remove(src_path)
- filenamesList = uos.listdir(BAK_FILE_PATH)
- 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 :
- 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()
- self.Cat1OtaTimeOut.stop()
- self.Cat1TimeCount = 0
- self.ota_state = 1
- self.allPyRecvFlag = 1
- 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()
- 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:
- 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:
- 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)
- if list1 != list2:
- self.deleteTmpFile()
- self.Cat1FileState = 0
- 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
- filenamesList = uos.listdir(BAK_FILE_PATH)
- for tmp in filenamesList:
- dst_path = "{}/{}".format(USR_FILE_PATH,tmp)
- src_path = "{}/{}".format(BAK_FILE_PATH,tmp)
- ret = False
- file_size = 0
- try:
- 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:
- compare_flag = 0
- break
- else:
- try:
- compare_flag = 1
- uos.remove(src_path)
- filenamesList = uos.listdir(BAK_FILE_PATH)
- except Exception as e:
- clog.info("file\r\n")
- else:
- compare_flag = 0
- break
-
- except Exception as e:
- clog.info("file\r\n")
- if copy_state == 0 or compare_flag == 0 :
- 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()
- 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()
- self.__Socket_TCP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
-
- elif Code == CAT1_TCP_SEND_SINGLE_FINESH and self.Cat1FileState == 1:
- self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT
- 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))
- if self.fileSize != file_size:
- self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err")
- else:
- if self.bakFlag == "0":
- dst_path = "{}/{}".format(USR_FILE_PATH,self.fileNameTmp)
- src_path = "{}/{}".format(BAK_FILE_PATH,self.fileNameTmp)
- ret = False
- try:
- 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:
- 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")
- except Exception as e:
- self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file copy err")
- else:
- self.__Socket_TCP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file copy ok")
- 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!")
- self.Cat1FileState == 0
- self.Cat1FileTransTimer.stop()
- self.Cat1PyFileTimout = 0
- self.fileNameList=[]
- self.deleteTmpFile()
- self.deleteUsrTmpFile()
-
- def otaTimeOut(self,*argc):
- clog.info("重启成功！！！！！！！！\r\n")
-
-TcpService = TcpServiceInit()
-
-
projects / mirrors / FD230.git / commitdiff