# self.__value = None
self.__wait_resp = 0
self.__waiting_netstat = 0
- slip.destroy()
- print('slip uart={0}'.format (self.__uart))
+ # 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
+ # ret = slip.construct(self.__uart, self.__mode, 0)
+ # if ret != 0:
+ # print('slip netif construct fail')
+ # return None
print('slip network card create success')
# self.__queue = Queue(1)
self.__sock = self.__socket_init()
#如果没有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)
+ try:
+ ql_fs.touch(CONFIG_JSON,data)
+ except Exception as e:
+ print("checkota 创建出错 {}".format(e))
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)
- print("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
- print("{}".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)
+ print("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+ print("{}".format(config_data))
+ except Exception as e:
+ print("checkota 创建出错 {}".format(e))
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))
- print("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
- return keyvalue
+ try:
+ 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))
+ print("{}={}".format(get_versionkeyname_by_py(app_type),keyvalue))
+ return keyvalue
+ except Exception as e:
+ print("get_version_from_json_config出错 {}".format(e))
+ return ""
def result(args):
printf('download status:',args[0],'download process:',args[1])
targetfile_path = "/usr/{}".format(targetpyname)
print("download {0} to {1}".format(srcurl,targetfile_path))
if ql_fs.path_exists(tmpfile_path):
- uos.remove(tmpfile_path)
+ try:
+ uos.remove(tmpfile_path)
+ except Exception as e:
+ print("update remove出错 {}".format(e))
ret = fota.download(srcurl,targetpyname)
if ret == 0 :
- ql_fs.file_copy(targetfile_path, tmpfile_path)
- set_version_to_json_config(app_type,version)
- print("ota success")
+ try:
+ ql_fs.file_copy(targetfile_path, tmpfile_path)
+ set_version_to_json_config(app_type,version)
+ print("ota success")
+ except Exception as e:
+ print("ota failed!")
else:
print("ota failed")
# 升级后重启
import example
main_flag = 1
try:
+ from usr.slipService import slipservice
from usr.tcpService import TcpService
+ import usr.checkota
example.exec('/usr/main_init.py')
print("启动成功!!!!!\r\n")
except Exception as e:
main_flag = 0
- print("启动失败!!!!!\r\n")
+ print("启动失败!!!!!\r\n".format(e))
from usr.EventMesh import eventMesh
from usr.telecom_dmp import telecomDmpCb
from usr.china_mobile_dmp import chinamobileCb
- import usr.checkota
from usr.cat1Service import cat1service
ota_flag = 1
print("检测文件成功!!!!!!!\r\n")
if tmp_dir == True:
try:
ql_fs.rmdirs("/usr/TmpPyFile")
- print("移除 TmpPyFile 成功!!!!!!!{}\r\n".format(e))
+ print("移除 TmpPyFile 成功!!!!!!!\r\n")
except Exception as e:
print("移除 TmpPyFile 失败!!!!!!!{}\r\n".format(e))
--- /dev/null
+
+import log
+import slip
+from machine import UART
+class slipServiceInit:
+ AP = 0 # SLIP_INNER
+ STA = 1 # SLIP_OUTER
+ def __init__(self, uart=UART.UART4, mode=AP):
+ self.__uart = uart
+ self.__mode = mode
+ 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')
+ else:
+ print('slip netif construct success')
+
+slipservice = slipServiceInit()
\ No newline at end of file
import uos
import slip
-CAT1_SERVICE_HEAD = "FE"
+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_NEED_UPDATE_OTA = "11" #提示用户强制升级
-BLE_STOP_OTA = 0 #结束OTA升级
-BLE_START_OTA = 1 #ble 开始发送OTA标识 -》 CAT1
-BLE_START_SEND_SINGLE_FILE_INFO= 2 #//ble 开始发送单个文件信息 -> CAT1 创建单个文件名
-BLE_START_SEND_FILE_DATA= 3 #//BLE开始发送文件数据额 ----》CAT1 接收文件数据写文件
-BLE_START_OTA_FAILE = 4 #BLE 发送OTA失败 取消文件传输
-BLE_START_OTA_SUCC = 5 #//BLE 发送OTA成功标识
-BLE_START_SEND_ALLFILE_FINESH = 6 #/所有PY文件传输完成
-BLE_START_SEND_SINGLE_FINESH = 7 #//单个文件传输完成
-BLE_START_ERROR_INFO = 255 #/发送错误信息结束进程
+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)
self.updateTimerCount = 0
self.updateTimerFlag = 0
self.sock = None
-
- slip.destroy()
- ret = slip.construct(self.__uart,self.__mode, 0)
- if ret != 0:
- print('slip netif construct fail')
- return None
+ self.bakFlag = "0"
+ # slip.destroy()
+ # ret = slip.construct(self.__uart,self.__mode, 0)
+ # if ret != 0:
+ # print('slip netif construct fail')
+ # return None
self.__sock_file = None
self.__sock_file = self.__socket_file_init()
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')
return -1
- print('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
+ # print('__unpack_tlv_format: {} {} {}\r\n'.format(tag,length,value))
unpack = (tag,length,value)
return unpack
def __socket_init(self):
def __Socket_File_Thread(self):
while True:
try:
- print(" __Socket_File_Thread recv====22222")
+ print(" __Socket_File_Thread recv====22222:\r\n")
data=self.__sock_file.recv(1024*10)
if not data:
print("__Socket_File_Thread data null:\r\n")
else:
- self.file_data(data.decode('uft-8'))
+ self.src_data(data.decode('uft-8'))
# print("__Socket_File_Thread end:{}\r\n".format(data.decode()))
except Exception as e:
i = 0
json_state = 0
crcbuf = 0
- print("len(data) :{}\r\n".format(len(data)))
+ # print("len(data) :{}\r\n".format(len(data)))
data_len = len(str(data))
try:
if data_len % 2 != 0:
crcbuf = 256-crcbuf
crcbuf = crcbuf%256
- print("crcbuf:{}\r\n".format(crcbuf))
+ # print("crcbuf:{}\r\n".format(crcbuf))
return [json_state,"%02x"%(crcbuf)]
#删除临时创建的文件夹
def deleteTmpFile(self):
- tmp_dir = ql_fs.path_exists("/usr/TmpPyFile")
+ tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
if tmp_dir == True:
- ql_fs.rmdirs("/usr/TmpPyFile")
+ 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")
+ # tmp_dir = ql_fs.path_exists("/usr/UsrTmpPyFile")
+ # if tmp_dir == True:
+ # ql_fs.rmdirs("/usr/UsrTmpPyFile")
- def file_data(self,data):
+ def src_data(self,data):
mk_dir_state = 0
print("data!!!!!{}\r\n".format(len(data)))
if self.updateTimerFlag == 0:
self.updateTimerFlag = 1
self.updateTimer.stop()
- msg = {}
+ 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):
# print("msg type msg {} {}\r\n".format(msg,type(data)))
- if "Code" in msg and json_state == 1 :
+ if "Code" in msg:
Code = int(msg["Code"])
print("Code {} self.Cat1FileState:{}\r\n".format(Code,self.Cat1FileState))
- if Code == BLE_STOP_OTA: #OTA失败
+ if Code == CAT1_TCP_STOP_OTA: #OTA失败
self.allPyRecvFlag = 0
self.Cat1FileState = 0
self.Cat1FileTransTimer.stop()
self.deleteTmpFile()
self.deleteUsrTmpFile()
pass
- elif Code == BLE_START_OTA: #BLE 开始OTA cat1创建临时文件夹记录传输的文件数据 文件名
+ elif Code == CAT1_TCP_START_OTA: #BLE 开始OTA cat1创建临时文件夹记录传输的文件数据 文件名
self.ota_state =0
self.ota_bstate =0
self.allPyRecvFlag = 0
self.fileNameList = []
self.fileSizeList = []
- print("BLE_START_OTA {} \r\n".format(BLE_START_OTA))
+ print("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("/usr/TmpPyFile")
+ check_dir = ql_fs.path_exists(BAK_FILE_PATH)
mk_dir_state = 0
if check_dir == True:
try:
self.deleteTmpFile()
except Exception as e:
print("移除失败!!!!\r\n")
- check_dir = ql_fs.path_exists("/usr/TmpPyFile")
+ check_dir = ql_fs.path_exists(BAK_FILE_PATH)
if check_dir == False: #文件夹不存在 创建目录文件夹
try:
- ql_fs.mkdirs("/usr/TmpPyFile")
+ ql_fs.mkdirs(BAK_FILE_PATH)
mk_dir_state = 1
print("创建临时文件 创建成功!!!!\r\n")
except Exception as e:
self.__Socket_UDP_file_noreply(CAT1_CREAT_DIR_OK,"creat dir success!")
- elif Code == BLE_START_SEND_SINGLE_FILE_INFO and self.Cat1FileState == 1: #包含文件名 文件大小
- print("BLE_START_SEND_SINGLE_FILE_INFO {} \r\n".format(BLE_START_SEND_SINGLE_FILE_INFO))
+ 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))
self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间60s
# {"Code":1,"fileName":"testpy.py","fileSize":1040}
- # print("msg {}\r\n".format(msg))
self.fileNameTmp = str(msg["fileName"])
self.fileSize = msg["fileSize"]
self.fileNameList = msg["fileNameList"]
# self.fileSizeList.append({"fileName":self.fileNameTmp,"fileSize":int(self.fileSize)})
- path = "/usr/TmpPyFile/{}".format(self.fileNameTmp)
+ 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))
- check_touch = ql_fs.path_exists("/usr/TmpPyFile/{}".format(self.fileNameTmp))
+ check_touch = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
if check_touch == True:
try:
- uos.remove("/usr/TmpPyFile/{}".format(self.fileNameTmp))
+ uos.remove("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
except Exception as e:
print("移除文件失败\r\n")
try:
self.__Socket_UDP_file_noreply(CAT1_CREAT_FILE_ERROR,"2creat file or dir err!")
print("创建文件失败\r\n")
- elif Code == BLE_START_SEND_FILE_DATA and self.Cat1FileState == 1: #文件数据
+ elif Code == CAT1_TCP_START_SEND_FILE_DATA and self.Cat1FileState == 1: #文件数据
self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间10s
- print("BLE_START_SEND_FILE_DATA {} self.fileNameTmp:{}\r\n".format(BLE_START_SEND_FILE_DATA,self.fileNameTmp))
+ print("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
print(" (data):{}\r\n".format(len(data)))
tmpdata = str(data)
head = tmpdata[0:2] #FE
- if head != "FE" and len(tmpdata) <= 8: #必须大于8 FE+012C+DATA+crc(一个字节89)
+ if head != CAT1_FILE_DATA_HEAD and 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!")
return
self.__Socket_UDP_file_noreply(CAT1_CRC_ERROR,"crc error!")
return
data = str(data_buf)
- path = "/usr/TmpPyFile/{}".format(str(self.fileNameTmp))
+ path = "{}/{}".format(BAK_FILE_PATH,str(self.fileNameTmp))
print("py path:{} self.fileNameTmp:{}\r\n".format(path,self.fileNameTmp))
try:
with open(path,"a") as fd:
print("写文件成功!!!!!\r\n")
except Exception as e:
self.__Socket_UDP_file_noreply(CAT1_WRITE_FILE_ERROR,"write file error!")
- print("写文件失败没有内存!!!!!\r\n")
- elif Code == BLE_START_OTA_FAILE and self.Cat1FileState == 1: #取消文件传输 OTA失败 移除目录文件
- print("BLE_START_OTA_FAILE {} \r\n".format(BLE_START_OTA_FAILE))
+ print("写文件失败没有内存!!!!!{}:\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))
self.allPyRecvFlag = 0
self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"OTA FAILE")
self.Cat1FileState = 0
self.deleteTmpFile()
self.deleteUsrTmpFile()
pass
- elif Code == BLE_START_SEND_ALLFILE_FINESH and self.Cat1FileState == 1: #全部文件传输完成
-
- tmp_dir = ql_fs.path_exists("/usr/TmpPyFile")
+ elif Code == CAT1_TCP_START_SEND_ALLFILE_FINESH and self.Cat1FileState == 1: #全部文件传输完成
+ if self.bakFlag == "0":
+ print("self.bakFlag auto:\r\n")
+ if self.allPyRecvFlag == 1:
+ self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ else:
+ self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ self.deleteTmpFile()
+ self.Cat1FileState = 0
+ self.Cat1FileTransTimer.stop()
+ print("重启 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")
+ tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
if tmp_dir == True:
- filenamesList = uos.listdir("/usr/TmpPyFile")
+ 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)))
copy_state = 1
compare_flag = 1
copy_flag = 0
- filenamesList = uos.listdir("/usr/TmpPyFile")
+ filenamesList = uos.listdir(BAK_FILE_PATH)
for tmp in filenamesList: #将传输的文件 copy到usr目录下
print("filenamesList for :{}\r\n".format(filenamesList))
- dst_path = "/usr/{}".format(tmp) #目标目录文件
- if ql_fs.path_exists(dst_path) == True:
- try:
- copy_flag = 1
- uos.remove(dst_path)
- except Exception as e:
- print("移除文件失败!!!!!\r\n")
- try:
- copy_flag = 1
- ql_fs.touch(dst_path,"")
- except Exception as e:
- print("创建文件失败!!!!!\r\n")
+ 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")
- if copy_flag == 0:
- print("创建文件失败!!!!!copy_flag\r\n")
- copy_state = 0
- break
- src_path = "/usr/TmpPyFile/{}".format(tmp) #源目录文件
+ # if copy_flag == 0:
+ # print("创建文件失败!!!!!copy_flag\r\n")
+ # copy_state = 0
+ # break
+ src_path = "{}/{}".format(BAK_FILE_PATH,tmp) #源目录文件
ret = False
file_size = 0
try:
compare_flag = 1
uos.remove(src_path)
- filenamesList = uos.listdir("/usr/TmpPyFile")
+ filenamesList = uos.listdir(BAK_FILE_PATH)
print("remove filenamesList :{}\r\n".format(filenamesList))
except Exception as e:
print("copy file \r\n")
self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
- elif Code == BLE_START_OTA_SUCC and self.Cat1FileState == 1:
+ 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_UDP_file_noreply(CAT1_REPLAY_OTA_SUCC,"ota success!") #传输文件完之后最后提示是否成功失败
+ else:
+ self.__Socket_UDP_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!")
return
- tmp_dir = ql_fs.path_exists("/usr/TmpPyFile")
+ tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
if tmp_dir == True:
- filenamesList = uos.listdir("/usr/TmpPyFile")
+ 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)))
copy_state = 1
compare_flag = 1
copy_flag = 0
- filenamesList = uos.listdir("/usr/TmpPyFile")
+ filenamesList = uos.listdir(BAK_FILE_PATH)
for tmp in filenamesList: #将传输的文件 copy到usr目录下
print("filenamesList for :{}\r\n".format(filenamesList))
- dst_path = "/usr/{}".format(tmp) #目标目录文件
- if ql_fs.path_exists(dst_path) == True:
- try:
- copy_flag = 1
- uos.remove(dst_path)
- except Exception as e:
- print("移除文件失败!!!!!\r\n")
- try:
- copy_flag = 1
- ql_fs.touch(dst_path,"")
- except Exception as e:
- print("创建文件失败!!!!!\r\n")
+ 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))
+ # if ret == 0:
+ # copy_flag = 1
+ # except Exception as e:
+ # print("创建文件失败!!!!!\r\n")
- if copy_flag == 0:
- print("创建文件失败!!!!!copy_flag\r\n")
- copy_state = 0
- break
- src_path = "/usr/TmpPyFile/{}".format(tmp) #源目录文件
+ # if copy_flag == 0:
+ # print("创建文件失败!!!!!copy_flag\r\n")
+ # copy_state = 0
+ # break
+ src_path = "{}/{}".format(BAK_FILE_PATH,tmp) #源目录文件
ret = False
file_size = 0
try:
compare_flag = 1
uos.remove(src_path)
- filenamesList = uos.listdir("/usr/TmpPyFile")
+ filenamesList = uos.listdir(BAK_FILE_PATH)
print("remove filenamesList :{}\r\n".format(filenamesList))
except Exception as e:
print("copy file \r\n")
print("cat1 ota\r\n")
self.__Socket_UDP_file_noreply(CAT1_REPLAY_OTA_FALIE,"ota end faile!")
- elif Code == BLE_START_SEND_SINGLE_FINESH and self.Cat1FileState == 1: #单个文件传输完成
- print("BLE_START_SEND_SINGLE_FINESH {} self.fileNameTmp:{}\r\n".format(BLE_START_SEND_SINGLE_FINESH,self.fileNameTmp))
+ 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))
self.Cat1PyFileTimout = FILE_TRANSFER_TIMEOUT #超时时间10s
- tmp_dir = ql_fs.path_exists("/usr/TmpPyFile")
+ tmp_dir = ql_fs.path_exists(BAK_FILE_PATH)
if tmp_dir == True:
- tmp_file = ql_fs.path_exists("/usr/TmpPyFile/{}".format(self.fileNameTmp))
+ tmp_file = ql_fs.path_exists("{}/{}".format(BAK_FILE_PATH,self.fileNameTmp))
if tmp_file == True: #文件存在
- file_size = ql_fs.path_getsize("/usr/TmpPyFile/{}".format(self.fileNameTmp))
+ 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))
if self.fileSize != file_size: #文件大小不一致 传输出错
self.__Socket_UDP_file_noreply(CAT1_REPLAY_FILE_SIZE_ERR,"file size err") #结束文件接收不完整的
- pass
- else:
- self.__Socket_UDP_file_noreply(CAT1_REPLAY_FILE_SIZE_OK,"file size ok") #结束文件接收完整的
- pass
+
+ 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:
+ print("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:
+ print("copy 文件异常出错 yichu!{}:\r\n".format(e))
+ self.__Socket_UDP_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:
+ print("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
+ self.__Socket_UDP_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失败
+ except Exception as e:
+ print("copy 文件异常出错!!!!!!!!!!{}:\r\n".format(e))
+ self.__Socket_UDP_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失败
else:
self.__Socket_UDP_file_noreply(CAT1_CREAT_FILE_ERROR,"creat file or dir err!")
pass
#define SERVER_IP "172.16.1.5"
#define PORT 1001
-
/** 0: old format 1字节cmd, 1: new format 2字节cmd */
static uint8_t g_msg_format_type = 0;
-static char ble_buffer[20] = {0};
-
#define CAT1_PY_PATH "/system/cat1ota" //存放需要升级的py文件路径
#define CAT1_REPLYA_FILE_SIZE_FUN 1 //是否需要CAT1回复文件大小一致传输完单个文件是否与SIZE大小匹配比较
static osTimerId_t file_transfer_timer=NULL;
#define DEFAULT_TIMEOUT_COUNT (60/DEFAULT_TIMEOUT_TIME) //10s倒计时 计时6次总共是1分钟
#define READ_FILE_DATA_MAX_SIZE 400 // 一次读文件数据最大的size 数据长度不包含头 长度 CRC位
-#define CAT1_FILE_DATA_HEAD "FE" //数据头'FE'
-#define CAT1_FILE_DATA_LEN_CHA "0000" //数据LEN'FE'
-#define CAT1_FILE_DATA_CRC_CHA "00" //数据CRC'FE'
+#define CAT1_FILE_DATA_HEAD "FF" //数据头'FF'
+#define CAT1_FILE_DATA_LEN_CHA "0000" //数据LEN
+#define CAT1_FILE_DATA_CRC_CHA "00" //数据CRC'
#define DATA_HEAD_SIZE 2 //头的字符大小
#define DATA_ACTUAL_LEN_BIT 4 //实际数据的长度
static int g_listen_sock = 0;
struct sockaddr_in filesourceAddr = {0};
-static osTimerId_t g_timer_time_sync = NULL;
-#ifdef USE_CAT1_SLEEP_TIMER
-static osTimerId_t g_timer_cat1_sleep = NULL;
-#endif
-static uint8_t g_time_synced = 0;
-#define MAX_TIME_SYNC_RETRY_TIME 5
-static uint8_t g_time_sync_retry_time = 0;
-
-
-#define PY_SRV_VER_4 "PY_SRV_V4"
-#define PY_SRV_VER_5 "PY_SRV_V5"
-#define PY_SRV_VER_6 "PY_SRV_V6"
-
-static uint8_t g_py_ver = 4;
-
-
static struct tcp_msg_old_t *unpack_tlv_format_old(char *rx_buffer, int length)
{
char temp[8]={0};
return msg;
}
-static int pack_tlv_format_old(char *tx_buffer, uint8_t cmd, char *content)
+static int pack_tlv_format_old(char *tx_buffer,uint8_t mode, uint8_t cmd, char *content)
{
int content_length = (int)strlen(content);
if( content == NULL || content_length > MAX_CMD_MSG_BUFFER_LEN) {
return -1;
}
- sprintf(tx_buffer,"%s",content);
- return 0;
+ if(mode == FILE_TRANSFER_CMD){ //文件传输是json格式
+ sprintf(tx_buffer,"%s",content);
+ }else if(mode == UDP_SEND_CMD){ //普通的命令
+ sprintf(tx_buffer,"%1X", 0xF);
+ sprintf(tx_buffer+1,"%1X", cmd&0xF);
+ sprintf(tx_buffer+2,"%04d", content_length);
+ sprintf(tx_buffer+6,"%s",content);
+ }
+ return content_length+6;
}
static struct tcp_msg_t *unpack_tlv_format(char *rx_buffer, int length)
return msg;
}
-static int pack_tlv_format(char *tx_buffer, uint8_t cmd, char *content)
+static int pack_tlv_format(char *tx_buffer,uint8_t mode,uint8_t cmd, char *content)
{
int content_length = (int)strlen(content);
printf("content data error: content_length %d %s\r\n",content_length,content);
return -1;
}
- sprintf(tx_buffer,"%s",content);
+ if(mode == FILE_TRANSFER_CMD){ //文件传输是json格式
+ sprintf(tx_buffer,"%s",content);
+ }else if(mode == UDP_SEND_CMD){ //普通的命令
+ sprintf(tx_buffer,"%02X", 0xFE);
+ sprintf(tx_buffer+2,"%02X", cmd);
+ sprintf(tx_buffer+4,"%04d", content_length);
+ sprintf(tx_buffer+8,"%s",content);
+ }
+
return content_length+8;
}
-static void udp_send_response(char *tx_buffer, uint8_t cmd, char *content)
+static void udp_send_response(char *tx_buffer,uint8_t mode, uint8_t cmd, char *content)
{
// remain lock using
int len = 0;
- len = pack_tlv_format(tx_buffer, cmd, content);
+ len = pack_tlv_format(tx_buffer,mode,cmd, content);
+
// printf("msg_format_type %d \n",g_msg_format_type,len);
int err = 0;
if( len > 0 ) {
}
}
#include "uart_porting.h"
-void ble_tcp_send_msg_toCat1(uint8_t cmd,char *content)
+void ble_tcp_send_msg_toCat1(uint8_t mode,uint8_t cmd,char *content)
{
if (!uapi_cat1_get_power_stat())
{
char station_tx_buffer[MAX_TCP_MSG_BUFFER_LEN] = {0};
if( filesourceAddr.sin_port != 0 ) {
- udp_send_response(station_tx_buffer, cmd, content);
+ udp_send_response(station_tx_buffer,mode,cmd, content);
}
uapi_cat1_wakeup_cat1(0);
}
static uint32_t read_size=0; //实际读的文件数据大小
static char data_arr[DATA_TOTAL_LEN] = {0}; //数据arr
static uint8_t file_count = 0;//需要升级的文件个数
-static long size; //实际文件大小
+static long filesize; //实际文件大小
static uint8_t cat1_ota_flag = 0x00; //BLE传输文件状态
-static uint8_t allfiletransEnd = 0; //所有文件传输完成
static uint8_t otaCount = 0;//ota发送标识计时 10次默认是失败传输文件失败
static uint8_t noreplayCount = 0;//CAT1没有回复计数累加 10次
-static char fileNameList[DEFAULT_MAX_FILE_COUNT][DEFAULT_MAX_FILE_NAME_SIZE]; //文件列表
+static char *fileNameList[DEFAULT_MAX_FILE_COUNT]; //文件列表 最大暂存的个数20可更改
+// static char fileNameList[DEFAULT_MAX_FILE_COUNT][DEFAULT_MAX_FILE_NAME_SIZE]; //文件列表
static FILE *fp = NULL;
static uint8_t creat_file_err = 0; //CAT1创建文件失败次数
static uint8_t file_size_err = 0;//两边文件大小不一致错误count
static uint8_t data_crc_err = 0;//CRC两边不一致
static uint8_t write_data_err = 0;//CAT1写文件失败
-static uint8_t ota_flag = 0;//OTA标识
-static uint8_t transferFlag = 0;//是否在传输文件
static uint8_t count = 0;//文件累加
static uint8_t curfilecount = 0;//当前第几个文件用于重复发送当前文件信息
uint8_t i = 0;
switch (Code)
{
- case BLE_STOP_OTA: // 停止OTA
- cJSON_AddNumberToObject(dataJSON,"Code",BLE_STOP_OTA);
+ case CAT1_TCP_STOP_OTA: // 停止OTA
+ cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_STOP_OTA);
json_format = cJSON_PrintUnformatted(dataJSON);
printf("cat1_ota_send_data zero %s\r\n",json_format);
cJSON_Delete(dataJSON);
- ble_tcp_send_msg_toCat1(BLE_STOP_OTA,json_format);
+ ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
cJSON_free(json_format);
break;
- case BLE_START_OTA: // BLE 开始OTA cat1需要创建临时的目录存放传输的文件内容
- cJSON_AddNumberToObject(dataJSON,"Code",BLE_START_OTA);
+ case CAT1_TCP_START_OTA: // BLE 开始OTA cat1需要创建临时的目录存放传输的文件内容
+ cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_START_OTA);
json_format = cJSON_PrintUnformatted(dataJSON);
printf("cat1_ota_send_data first %s\r\n",json_format);
cJSON_Delete(dataJSON);
- ble_tcp_send_msg_toCat1(BLE_START_OTA,json_format);
+ ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
cJSON_free(json_format);
break;
- case BLE_START_SEND_SINGLE_FILE_INFO:
+ case CAT1_TCP_START_SEND_SINGLE_FILE_INFO:
for(i = 0;i < file_count;i++)
{
printf("cat1_ota_send_data fileNameList[i]:%s\r\n",fileNameList[i]);
- if(strlen(fileNameList[i]) != 0){
- cJSON_AddStringToObject(arrayJSON,"fileNameList",fileNameList[i]);
+ // if(strlen(fileNameList[i]) != 0){
+ // cJSON_AddStringToObject(arrayJSON,"fileNameList",fileNameList[i]);
+ // }
+ if(fileNameList[i] != NULL){
+ if(strlen(fileNameList[i])){
+ cJSON_AddStringToObject(arrayJSON,"fileNameList",fileNameList[i]);
+ }
+
}
}
cJSON_AddItemToObject(dataJSON,"fileNameList",arrayJSON); //文件列表 所有需要传输的文件名集合
- cJSON_AddNumberToObject(dataJSON,"Code",BLE_START_SEND_SINGLE_FILE_INFO);
+ cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_START_SEND_SINGLE_FILE_INFO);
cJSON_AddStringToObject(dataJSON,"fileName",fileName); //文件名
cJSON_AddNumberToObject(dataJSON,"fileSize",fileSize); //文件大小
json_format = cJSON_PrintUnformatted(dataJSON);
printf("cat1_ota_send_data one:%s\r\n",json_format);
cJSON_Delete(dataJSON);
- ble_tcp_send_msg_toCat1(BLE_START_SEND_SINGLE_FILE_INFO,json_format);
+ ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
cJSON_free(json_format);
break;
- case BLE_START_SEND_FILE_DATA: //start file transfer
- cJSON_AddNumberToObject(dataJSON,"Code",BLE_START_SEND_FILE_DATA);
+ case CAT1_TCP_START_SEND_FILE_DATA: //start file transfer
+ 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));
cJSON_Delete(dataJSON);
printf("cat1_ota_send_data two:\r\n");
- ble_tcp_send_msg_toCat1(BLE_START_SEND_FILE_DATA,json_format);
+ ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
cJSON_free(json_format);
break;
- // case BLE_START_OTA_FAILE: //OTA失败
+ // case CAT1_TCP_START_OTA_FAILE: //OTA失败
- // cJSON_AddNumberToObject(dataJSON,"Code",BLE_START_OTA_FAILE);
+ // cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_START_OTA_FAILE);
// json_format = cJSON_PrintUnformatted(dataJSON);
// printf("cat1_ota_send_data three:%s\r\n",json_format);
// cJSON_Delete(dataJSON);
- // ble_tcp_send_msg_toCat1(BLE_START_OTA_FAILE,json_format);
+ // ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
// cJSON_free(json_format);
// break;
- // case BLE_START_OTA_SUCC: // OTA成功
- // cJSON_AddNumberToObject(dataJSON,"Code",BLE_START_OTA_SUCC);
+ // case CAT1_TCP_START_OTA_SUCC: // OTA成功
+ // cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_START_OTA_SUCC);
// json_format = cJSON_PrintUnformatted(dataJSON);
// printf("cat1_ota_send_data four:%s\r\n",json_format);
// cJSON_Delete(dataJSON);
- // ble_tcp_send_msg_toCat1(BLE_START_OTA_SUCC,json_format);
+ // ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
// cJSON_free(json_format);
// break;
- case BLE_START_SEND_ALLFILE_FINESH: //all file transfer end
- cJSON_AddNumberToObject(dataJSON,"Code",BLE_START_SEND_ALLFILE_FINESH);
+ case CAT1_TCP_START_SEND_ALLFILE_FINESH: //all file transfer end
+ cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_START_SEND_ALLFILE_FINESH);
json_format = cJSON_PrintUnformatted(dataJSON);
printf("cat1_ota_send_data five:%s\r\n",json_format);
cJSON_Delete(dataJSON);
- ble_tcp_send_msg_toCat1(BLE_START_SEND_ALLFILE_FINESH,json_format);
+ ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
cJSON_free(json_format);
break;
- case BLE_START_SEND_SINGLE_FINESH:
- cJSON_AddNumberToObject(dataJSON,"Code",BLE_START_SEND_SINGLE_FINESH);
+ case CAT1_TCP_SEND_SINGLE_FINESH:
+ cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_SEND_SINGLE_FINESH);
json_format = cJSON_PrintUnformatted(dataJSON);
printf("cat1_ota_send_data single:%s\r\n",json_format);
cJSON_Delete(dataJSON);
- ble_tcp_send_msg_toCat1(BLE_START_SEND_SINGLE_FINESH,json_format);
+ ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
cJSON_free(json_format);
break;
- case BLE_START_ERROR_INFO: //连续发送十次都没有回复 当前传输py文件
- cJSON_AddNumberToObject(dataJSON,"Code",BLE_START_ERROR_INFO);
+ case CAT1_TCP_START_ERROR_INFO: //连续发送十次都没有回复 当前传输py文件
+ cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_START_ERROR_INFO);
json_format = cJSON_PrintUnformatted(dataJSON);
printf("cat1_ota_send_data five:%s\r\n",json_format);
cJSON_Delete(dataJSON);
- ble_tcp_send_msg_toCat1(BLE_START_ERROR_INFO,json_format);
+ ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
cJSON_free(json_format);
break;
file_transfer_timer = NULL;
}
otaCount = 0;
- allfiletransEnd = 0;
timerOut_count = 0;
noreplayCount = 0;
- ota_flag = 0;
- transferFlag = 0;
write_data_err = 0;
data_crc_err = 0;
creat_file_err = 0;
curfilecount = 0;
memset(data_arr,'\0',DATA_TOTAL_LEN);
file_count = 0;
- size=0;
- cat1_ota_flag = BLE_STOP_OTA;
- for(uint8_t i=0;i<DEFAULT_MAX_FILE_COUNT;i++){
- strcpy(fileNameList[i],"");
+ filesize=0;
+ cat1_ota_flag = CAT1_TCP_STOP_OTA;
+ for (int i = 0; i < DEFAULT_MAX_FILE_COUNT; i++) { //释放内存
+ if(fileNameList[i] != NULL){
+ free(fileNameList[i]);
+ fileNameList[i] = NULL;
+ }
}
+ // for(uint8_t i=0;i<DEFAULT_MAX_FILE_COUNT;i++){
+ // strcpy(fileNameList[i],"");
+ // }
if(fp != NULL){ //防止打开文件没有关闭
printf("file is not close!\r\n");
static void cat1_file_Timer_CallBack(int data_tmp)
{
- if(cat1_ota_flag == BLE_STOP_OTA){
+ if(cat1_ota_flag == CAT1_TCP_STOP_OTA){
stop_cat1_ota();
return;
}
}
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"timerOut_count = !!%d cat1_ota_flag:%d\r\n",timerOut_count,cat1_ota_flag);
if(timerOut_count==0){
- if(cat1_ota_flag == BLE_START_OTA || cat1_ota_flag == BLE_START_SEND_ALLFILE_FINESH
- || cat1_ota_flag == BLE_START_SEND_FILE_DATA || cat1_ota_flag == BLE_START_SEND_SINGLE_FILE_INFO
- ||cat1_ota_flag == BLE_START_SEND_SINGLE_FINESH){ //如果发送创建文件没有回复 累加十次结束发送
+ if(cat1_ota_flag == CAT1_TCP_START_OTA || cat1_ota_flag == CAT1_TCP_START_SEND_ALLFILE_FINESH
+ || cat1_ota_flag == CAT1_TCP_START_SEND_FILE_DATA || cat1_ota_flag == CAT1_TCP_START_SEND_SINGLE_FILE_INFO
+ ||cat1_ota_flag == CAT1_TCP_SEND_SINGLE_FINESH){ //如果发送创建文件没有回复 累加十次结束发送
noreplayCount+=1;
if(noreplayCount >= DEFAULT_TIMEOUT_COUNT){
noreplayCount = 0;
stop_cat1_ota();
return;
}else{ //
- if(cat1_ota_flag == BLE_START_OTA){
+ if(cat1_ota_flag == CAT1_TCP_START_OTA){
send_dir_info(); //再次发送目录文件信息
- }else if(cat1_ota_flag == BLE_START_SEND_SINGLE_FILE_INFO){
+ }else if(cat1_ota_flag == CAT1_TCP_START_SEND_SINGLE_FILE_INFO){
send_curfile_info_data();
- }else if(cat1_ota_flag == BLE_START_SEND_FILE_DATA){ //发送一包超过10s CAT1没有回复继续上一包的数据
+ }else if(cat1_ota_flag == CAT1_TCP_START_SEND_FILE_DATA){ //发送一包超过10s CAT1没有回复继续上一包的数据
send_cur_pack_data();
- }else if(cat1_ota_flag == BLE_START_SEND_SINGLE_FINESH){ //单个文件传输完成
+ }else if(cat1_ota_flag == CAT1_TCP_SEND_SINGLE_FINESH){ //单个文件传输完成
send_singlefile_end_cmd();
- }else if(cat1_ota_flag == BLE_START_SEND_ALLFILE_FINESH){ //所有文件传输完成
+ }else if(cat1_ota_flag == CAT1_TCP_START_SEND_ALLFILE_FINESH){ //所有文件传输完成
send_allfile_finesh_cmd();
}
return;
}
- cat1_ota_flag = BLE_START_OTA;
+ cat1_ota_flag = CAT1_TCP_START_OTA;
timerOut_count = DEFAULT_TIMEOUT_TIME;
- cat1_ota_send_data(BLE_START_OTA,NULL,0,NULL);
+ cat1_ota_send_data(CAT1_TCP_START_OTA,NULL,0,NULL);
}
void read_dir(void){
struct dirent *entry;
-
- for (int i = 0; i < DEFAULT_MAX_FILE_COUNT; i++) {
- strcpy(fileNameList[i],"");
+ for (int i = 0; i < DEFAULT_MAX_FILE_COUNT; i++) { //释放内存
+ if(fileNameList[i] != NULL){
+ free(fileNameList[i]);
+ fileNameList[i] = NULL;
+ }
}
+ // for (int i = 0; i < DEFAULT_MAX_FILE_COUNT; i++) {
+ // strcpy(fileNameList[i],"");
+ // }
DIR *dir = opendir(CAT1_PY_PATH); // 打开文件夹
if (dir == NULL) {
printf("opendir");
if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
printf("%s\n", entry->d_name); // 输出文件名
//0 1 2
+ fileNameList[file_count] = (char *)malloc(DEFAULT_MAX_FILE_NAME_SIZE * sizeof(char));
+ if (fileNameList[file_count] == NULL) {
+ printf("内存分配失败\n");
+ continue;
+ }
if(file_count >= DEFAULT_MAX_FILE_COUNT){
break;
}
snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s",entry->d_name);
- // memcpy_s(fileNameList+file_count,DEFAULT_MAX_FILE_NAME_SIZE,entry->d_name,strlen(entry->d_name));
printf("fileNameList[file_count] %s\r\n",fileNameList[file_count]);
file_count+=1;
}
if(file_count == 0){ //目录下没有文件
return;
}
- allfiletransEnd = 1;
- transferFlag = 1; //文件传输标识 1正在OTA py 2OTA失败
- ota_flag = 1;
send_dir_info();
noreplayCount = 0;
uint32_t tick;
void send_curfile_info_data(void)
{
- cat1_ota_flag = BLE_START_SEND_SINGLE_FILE_INFO;
+ cat1_ota_flag = CAT1_TCP_START_SEND_SINGLE_FILE_INFO;
timerOut_count = DEFAULT_TIMEOUT_TIME;
- if(strlen(fileNameList[curfilecount]) && size != 0){
- cat1_ota_send_data(BLE_START_SEND_SINGLE_FILE_INFO,fileNameList[curfilecount],size,NULL);
+ if(fileNameList[curfilecount] != NULL)
+ {
+ if(strlen(fileNameList[curfilecount]) != 0 && filesize != 0){
+ cat1_ota_send_data(CAT1_TCP_START_SEND_SINGLE_FILE_INFO,fileNameList[curfilecount],filesize,NULL);
+ }
}
-
}
void send_allfile_finesh_cmd(void)
{
- cat1_ota_flag = BLE_START_SEND_ALLFILE_FINESH;
+ cat1_ota_flag = CAT1_TCP_START_SEND_ALLFILE_FINESH;
timerOut_count = DEFAULT_TIMEOUT_TIME;
- cat1_ota_send_data(BLE_START_SEND_ALLFILE_FINESH,NULL,0,NULL);
+ cat1_ota_send_data(CAT1_TCP_START_SEND_ALLFILE_FINESH,NULL,0,NULL);
}
void read_file_info_data(void){
while (1)
{
if(count < file_count){
- size = 0;
+ filesize = 0;
if(count >= file_count){
- cat1_ota_flag = BLE_START_SEND_ALLFILE_FINESH;
+ cat1_ota_flag = CAT1_TCP_START_SEND_ALLFILE_FINESH;
timerOut_count = DEFAULT_TIMEOUT_TIME;
- cat1_ota_send_data(BLE_START_SEND_ALLFILE_FINESH,NULL,0,NULL);
+ cat1_ota_send_data(CAT1_TCP_START_SEND_ALLFILE_FINESH,NULL,0,NULL);
break;
}
if(strlen(fileNameList[count])==0){ //空的文件 2 count = 0 count = 1
fp = fopen(file_path, "rb");
if(fp != NULL){
fseek(fp, 0, SEEK_END);
- size = ftell(fp);
+ filesize = ftell(fp);
fseek(fp, 0, SEEK_SET);
noreplayCount = 0;
send_curfile_info_data();
break;
}
}else{
- cat1_ota_flag = BLE_START_SEND_ALLFILE_FINESH;
+ cat1_ota_flag = CAT1_TCP_START_SEND_ALLFILE_FINESH;
timerOut_count = DEFAULT_TIMEOUT_TIME;
- cat1_ota_send_data(BLE_START_SEND_ALLFILE_FINESH,NULL,0,NULL);
+ cat1_ota_send_data(CAT1_TCP_START_SEND_ALLFILE_FINESH,NULL,0,NULL);
break;
}
}
void send_cur_pack_data(void){
int data_len = 0;
uint8_t crcvalue = 0x00;
- cat1_ota_flag = BLE_START_SEND_FILE_DATA;
+ cat1_ota_flag = CAT1_TCP_START_SEND_FILE_DATA;
timerOut_count=DEFAULT_TIMEOUT_TIME;
char head_data[10]={0};
memset(head_data, '\0', sizeof(head_data));
- if(strlen(data_arr+6) != 0 && read_size != 0 ){ //FE 012C
- if(head_data[0] != 'F' && head_data[1] != 'E'){
- data_len+=snprintf(head_data+data_len,sizeof(head_data)-data_len,"%s","FE");
+ if(strlen(data_arr+6) != 0 && read_size != 0 ){ //FF 012C
+ if(head_data[0] != 'F' && head_data[1] != 'F'){
+ data_len+=snprintf(head_data+data_len,sizeof(head_data)-data_len,"%s","FF");
}else{
data_len+=snprintf(head_data+data_len,sizeof(head_data)-data_len,"%s",CAT1_FILE_DATA_HEAD);
}
data_len+=read_size;
data_len+=snprintf(data_arr+data_len,sizeof(data_arr)-data_len,"%02x",crcvalue);
- cat1_ota_send_data(BLE_START_SEND_FILE_DATA,NULL,0,data_arr);
+ cat1_ota_send_data(CAT1_TCP_START_SEND_FILE_DATA,NULL,0,data_arr);
}
}
void send_singlefile_end_cmd(void)
{
- cat1_ota_flag = BLE_START_SEND_SINGLE_FINESH;
+ cat1_ota_flag = CAT1_TCP_SEND_SINGLE_FINESH;
timerOut_count=DEFAULT_TIMEOUT_TIME;
- cat1_ota_send_data(BLE_START_SEND_SINGLE_FINESH,NULL,0,NULL);
+ cat1_ota_send_data(CAT1_TCP_SEND_SINGLE_FINESH,NULL,0,NULL);
}
void send_file_pack_data(void)
{
{
switch (ota_state)
{
- case BLE_START_OTA:
+ case CAT1_TCP_START_OTA:
start_cat1_ota();
break;
- case BLE_STOP_OTA:
+ case CAT1_TCP_STOP_OTA:
stop_cat1_ota();
- cat1_ota_send_data(BLE_STOP_OTA,NULL,0,NULL);
+ cat1_ota_send_data(CAT1_TCP_STOP_OTA,NULL,0,NULL);
break;
default:
break;
{
return cat1_ota_flag;
}
-#define BOOTMSG_HEADER_STR "BOOTUP"
-#define BOOTMSG_HEADER_STR_LEN strlen(BOOTMSG_HEADER_STR)
-#define NETSTAT_HEADER_STR "imei:"
-#define NETSTAT_HEADER_STR_LEN strlen(NETSTAT_HEADER_STR)
-#define VERMSG_HEADER_STR "pyVer"
-#define VERMSG_HEADER_STR_LEN strlen(VERMSG_HEADER_STR)
-#define MSG_SPLIT_CHAR ","
-#define MSG_SPLIT_CHAR2 "@"
-
-
+void send_bak_mode_toCat1(void)//发送bak fun cmd
+{
+ ble_tcp_send_msg_toCat1(UDP_SEND_CMD,CAT1_FILE_UDP_CMD_BAK_FUN,"1");
+}
static uint8_t get_int8_from_ascii_char( uint8_t ascii)
{
}
printf("cmd! %d",cmd);
noreplayCount = 0;
- if(cat1_ota_flag == BLE_STOP_OTA) //只有在传输文件才生效
+ if(cat1_ota_flag == CAT1_TCP_STOP_OTA) //只有在传输文件才生效
{
return 0;
}
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
+
+#define FILE_TRANSFER_CMD 0x01
+#define UDP_SEND_CMD 0x02
+
typedef enum Ble_send_file_mode { //BLE 发送文件模式
READ_DIR_INFO = 0,// BLE读目录文件 重新发送收到CAT1回复
READ_FILE_DATA_INFO = 1, //读文件信息 重新发送收到CAT1回复
} Ble_send_file_mode;
typedef enum Ble_send_state { //BLE 发送文件传输状态
- BLE_STOP_OTA = 0,//结束OTA升级
- BLE_START_OTA = 1, //ble 开始发送OTA标识 -》 CAT1
- BLE_START_SEND_SINGLE_FILE_INFO= 2, //ble 开始发送单个文件信息 -> CAT1 创建单个文件名
- BLE_START_SEND_FILE_DATA= 3, //BLE开始发送文件数据额 ----》CAT1 接收文件数据写文件
- BLE_START_OTA_FAILE = 4, //CAT 发送OTA失败 取消文件传输 //预留
- BLE_START_OTA_SUCC = 5, //BLE 发送OTA成功标识 //预留
- BLE_START_SEND_ALLFILE_FINESH = 6, //所有PY文件传输完成
- BLE_START_SEND_SINGLE_FINESH = 7, //单个文件传输完成
- BLE_START_ERROR_INFO = 255, //发送错误信息结束进程
+ 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, //CAT 发送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, //发送错误信息结束进程
} Ble_send_state;
typedef enum cat1_replay_state { //手表CAT1回复的状态
CAT1_REPLAY_STATE=0x00,
CAT1_NEED_UPDATE_OTA = 0x11, //CAT1回复需要强制升级 因为py运行出错了
} cat1_replay_state;
+typedef enum cat1_file_udp_cmd {
+ CAT1_FILE_UDP_CMD_BAK_FUN = 0x01, // bak function
+
+}cat1_file_udp_cmd;
+
errcode_t cat1_tcp_server_init(void);
-void ble_tcp_send_msg_toCat1(uint8_t cmd,char *content);
+void send_bak_mode_toCat1(void);//发送bak fun cmd
+void ble_tcp_send_msg_toCat1(uint8_t mode,uint8_t cmd,char *content);
void cat1_ota_send_data(uint8_t Code,char *fileName,uint32_t fileSize,char *data);
//ota_state:
-//BLE_START_OTA 开始OTA
-//BLE_STOP_OTA 停止OTA
+//CAT1_TCP_START_OTA 开始OTA
+//CAT1_TCP_STOP_OTA 停止OTA
void Cat1_OTA(uint8_t ota_state);
-//获取CAT1 OTA升级状态 返回 BLE_STOP_OTA 不在升级状态 其他在升级状态中
+//获取CAT1 OTA升级状态 返回 CAT1_TCP_STOP_OTA 不在升级状态 其他在升级状态中
uint8_t Get_Cat1_OTA_Flag(void);
#ifdef __cplusplus
#if __cplusplus
}
static uint32_t custom_cat1_start_ota_pyupdate(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
{
- Cat1_OTA(BLE_START_OTA);
+ Cat1_OTA(CAT1_TCP_START_OTA);
return ERRCODE_SUCC;
}
static uint32_t custom_cat1_stop_ota_pyupdate(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
{
- Cat1_OTA(BLE_STOP_OTA);
+ Cat1_OTA(CAT1_TCP_STOP_OTA);
return ERRCODE_SUCC;
}
+static uint32_t custom_cat1_send_bak_mode(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ send_bak_mode_toCat1();
+ return ERRCODE_SUCC;
+}
+
#ifdef SUPPORT_A5133_SERVICE
{(char *)"AT^CAT1STARTOTAPY", custom_cat1_start_ota_pyupdate, (char *)" "},
{(char *)"AT^CAT1STOPOTAPY", custom_cat1_stop_ota_pyupdate, (char *)" "},
+ {(char *)"AT^CAT1SENDBAKMODE", custom_cat1_send_bak_mode, (char *)" "},
{(char *)"AT^VIBTEST", custom_vibrator_test, (char *)" "},
#ifdef SUPPORT_A5133_SERVICE
{(char *)"AT^A5133SENDDATA", custom_a5133_send_msg, (char *)" "},
projects / mirrors / FD230.git / commitdiff