/* * @Description: * @Version: 2.0 * @Author: Seven * @Date: 2022-08-22 17:13:45 * @LastEditors: Seven * @LastEditTime: 2022-12-19 14:00:16 */ #include "ota.h" #include "includes.h" #include "gw_ctrl.h" #include "lora.h" #include "radio.h" uint8_t updata_state = 0; ota_state_t ota_state; ota_pkg_info_t ota_slave; ota_pkg_info_t ota_master; master_rcv_info_t master_rcv_info; slave_upload_info_t slave_upload_info; //比较接收设备的类型和sn int device_type_and_id_cmp(u32 device_type, u32 device_sn) { int ret = 0; if(device_type == 0x0201/*device_info.device_type*/) { if(device_sn == device_info.device_sn || device_sn == 0xFFFFFFFF) { ret = 1; } } else if(device_type == 0xffff && device_sn == 0xffffffff) { ret = 1; } return ret; } //存储升级状态 void updata_state_save(uint8_t state) { uint16_t updata_state_temp; updata_state = state; updata_state_temp = set_updata_state(updata_state); BKP_WriteBackupRegister(BKP_DR3, updata_state_temp); } //向备份寄存器存储转义数据 void BKP_WriteBackupRegister_code(uint16_t BKP_DR, uint8_t Data) { uint16_t temp; temp = set_updata_state(Data); BKP_WriteBackupRegister(BKP_DR, temp); } //采集器主动发送 void coll_msg_send(collect_gateway_msg_format_t *p_msg, uint8_t msg_type, uint16_t len) { static uint32_t msg_no = 0; char *msg = NULL; uint16_t *p_crc; p_msg->frame_header = 0xfefe; p_msg->proto_Ver = PROTOCOL_VERSION; p_msg->msg_id = msg_no++; p_msg->first_type = msg_type; p_msg->second_type = 0x00; p_msg->msg_len = len+2;//后面加两字节的CRC p_crc = (uint16_t*)&p_msg->info[len]; *p_crc = CRC16_get((uint8_t *)p_msg,p_msg->msg_len+FRAME_HEADER_LEN-2); msg = (char *)lora_queue_mem_calloc_must(SYS_LORA_TX); if(msg) { memcpy(msg, (char *)p_msg, FRAME_HEADER_LEN + len+2); lora_queue_insert(SYS_LORA_TX,(char *)msg, FRAME_HEADER_LEN + len+2); } else { lora_queue_mem_free(SYS_LORA_TX,msg); } } //升级重传函数 void ota_retransmit_req(uint16_t repeat_sub_pkg_id) { collect_gateway_msg_format_t msg; ota_retransmit_req_t *p_ota = (ota_retransmit_req_t *)msg.info; p_ota->repeat_devict_type = ota_slave.rcv_device_type; p_ota->repeat_device_sn = device_info.device_sn; p_ota->repeat_sub_pkg_id = repeat_sub_pkg_id; coll_msg_send(&msg, net_msg_type_update_retransmit_req, OTA_RETRNSMIT_INFO_LEN); } //存储设备升级信息 int lora_node_ota_info_Init(ota_pkg_info_t *ota_info,ota_start_info_t *p_ota) { // memset(ota_info, 0, sizeof(ota_pkg_info_t)); ota_info->rcv_device_type = p_ota->rcv_device_type; ota_info->rcv_device_sn = p_ota->rcv_device_sn; ota_info->des_device_type = p_ota->des_device_type; ota_info->des_device_sn = p_ota->des_device_sn; ota_info->update_version = p_ota->update_version; ota_info->total_bytes = p_ota->total_bytes; ota_info->total_pkgs = p_ota->total_bytes/OTA_UPDATE_PAYLAOA_LEN; ota_info->lossPkgIndex = 0; ota_info->lastRightPkgNum = 1; if(p_ota->total_bytes%OTA_UPDATE_PAYLAOA_LEN) { ota_info->total_pkgs += 1; } ota_info->lossPkgCounter = 0; ota_info->sub_pkg_id = 1; ota_info->Send_interval = p_ota->Send_interval; return 0; } //从设备设置旁观者定时器 void ota_timer_onlooker_slave_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { //升级指示灯 ota_start_led_init(); Led_Single_State_Set(UPDATA_ONLOOKER_LED,LED_ON); Data_last4bit_led(0xff,1); ota_state.update_mode = OTA_WORK_STATE_ONLOOKER; timeout_setValue(&ota_slave.tt_ota_onlooker,timeout,1); timeout_stop(&ota_slave.tt_ota_continuous);//关闭连续定时 timeout_stop(&ota_slave.tt_ota_retransmit);//关闭重传定时 } else if(state == CLOSE) { timeout_stop(&ota_slave.tt_ota_onlooker); } } //从设备旁观者超时处理 void ota_timeout_onlooker_slave(void) { if(timeout_isOut(&ota_slave.tt_ota_onlooker)) { memset(&ota_state,0,sizeof(ota_state)); ota_timer_continuous_slave_set(CLOSE,0);//关闭连续发包定时器 ota_timer_retransmit_slave_set(CLOSE,0);//关闭重传阶段定时器 ota_timer_total_slave_set(CLOSE,0);//关闭总定时器 if(updata_state)//上报升级状态 { device_fixed_info.slave_uploade_start = 1; } else { if(device_info.alrd == DEVICE_ALRD)//已初始化 { device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; } else { device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT; } //升级指示灯 led_run_set(LED_ALL,LED_OFF); } printf("onlooker timeout \n"); } } //从设备设置重传定时器 void ota_timer_retransmit_slave_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { ota_state.update_state_slave = OTA_WORK_STATE_RETRANSMIT; timeout_setValue(&ota_slave.tt_ota_retransmit, timeout, 1); } else if(state == CLOSE) { timeout_stop(&ota_slave.tt_ota_retransmit); } } //从设备重传超时 void ota_timeout_retransmit_slave(void) { if(timeout_isOut(&ota_slave.tt_ota_retransmit)) { ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 updata_state_save(RETRANSMIT_TIMEOUT);//存储升级状态 printf("retransmit timeout \n"); } } //从设备设置连续接收定时器 void ota_timer_continuous_slave_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { ota_state.update_state_slave = OTA_WORK_STATE_CONTINUOUS; timeout_setValue(&ota_slave.tt_ota_continuous,timeout,1); } else if(state == CLOSE) { timeout_stop(&ota_slave.tt_ota_continuous); } } //从设备连续接收超时 void ota_timeout_continuous_slave(void) { uint16_t i; if(timeout_isOut(&ota_slave.tt_ota_continuous)) { //更新收包相关状态 for(i = ota_slave.lastRightPkgNum;i < ota_slave.total_pkgs+1;i++) { ota_slave.lossPkgCounter++; ota_slave.lossPkgId[ota_slave.lossPkgIndex++] = i;//+1因为子包编号从0开始， //丢包太多了，超过了MAX_LOSS_PKG_COUNT，结束本次升级。 if(ota_slave.lossPkgCounter == MAX_LOSS_PKG_COUNT) {//降为旁观者, 放弃本次升级 ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 updata_state_save(PACKET_LOSS_MORE);//存储升级状态 return; } } if(ota_slave.lossPkgCounter == 0) //没有丢包 { ota_state.update_state_slave = OTA_WORK_STATE_RCV_END; printf("check begin\n"); ota_continuous_end_handle(); } else //有丢包 { ota_timer_retransmit_require_slave_set(OPEN,RETRANSMIT_DELAY_TIMEOUT_MIN);//打开重传延时定时器 ota_timer_retransmit_slave_set(OPEN,RETRANSMIT_TIMEOUT_TIME); //打开重传定时器 printf("retransmit begin\n"); } } } //从设备总定时器设置 void ota_timer_total_slave_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { timeout_setValue(&ota_slave.tt_ota_total,timeout,1); } else if(state == CLOSE) { timeout_stop(&ota_slave.tt_ota_total); } } //从设备总定时超时 void ota_timeout_total_slave(void) { if(timeout_isOut(&ota_slave.tt_ota_total)) { if(updata_state)//上报升级状态 { device_fixed_info.slave_uploade_start = 1; } else { if(device_info.alrd == DEVICE_ALRD)//已初始化 { device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; } else { device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT; } } ota_timer_onlooker_slave_set(CLOSE,0);//关闭旁观者定时器 ota_timer_continuous_slave_set(CLOSE,0);//关闭连续发包定时器 ota_timer_retransmit_slave_set(CLOSE,0);//关闭重传阶段定时器 memset(&ota_state,0,sizeof(ota_state)); updata_state_save(UPDATA_TOTAL_TIMEOUT);//存储升级状态 printf("total timeout \n"); } } //从设备重传请求间隔定时设置 void ota_timer_retransmit_require_slave_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { timeout_setValue(&ota_slave.tt_ota_retransmit_delay,timeout,1); } else if(state == CLOSE) { timeout_stop(&ota_slave.tt_ota_retransmit_delay); } } //从设备重传请求超时处理 void ota_timeout_retransmit_require_slave(void) { if(timeout_isOut(&ota_slave.tt_ota_retransmit_delay)) { ota_continuous_end_handle(); } } //从设备主动上报升级状态总定时设置 void ota_timer_upload_total_slave_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { ota_state.update_mode = OTA_WORK_STATE_UPLOAD; timeout_setValue(&slave_upload_info.upload_total_time,timeout,1); } else if(state == CLOSE) { timeout_stop(&slave_upload_info.upload_total_time); } } //从设备主动上报升级状态总定时超时处理 void ota_timeout_upload_total_slave(void) { if(timeout_isOut(&slave_upload_info.upload_total_time)) { slave_upload_end(); } } //从设备主动上报升级状态发送间隔定时设置 void ota_timer_upload_cad_slave_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { timeout_setValue(&slave_upload_info.upload_cad_time,timeout,1); } else if(state == CLOSE) { timeout_stop(&slave_upload_info.upload_cad_time); } } //从设备主动上报升级状态发送间隔超时处理 void ota_timeout_upload_cad_slave(void) { if(timeout_isOut(&slave_upload_info.upload_cad_time)) { lora_slave_ota_updatestate_resp(updata_state); } } uint32_t OTA_Continuous_Timeout = 0; //网关下发的升级命令分析 void gateway_lora_ota_proc(collect_gateway_msg_format_t *p_msg) { uint8_t flash_flag=0; uint32_t i; uint32_t remain_pkg = 0; ota_start_info_t *p_start = NULL; ota_continues_info_t *p_cont = NULL; gateway_coll_offline_upgrade_t *p_off = NULL; if(device_fixed_info.Work_State != DEV_WORK_STATE_UPDATING) { device_fixed_info.Work_State = DEV_WORK_STATE_UPDATING; updata_state = 0; srand(device_info.device_sn);//随机数种子 memset(&ota_state,0,sizeof(ota_state)); } if(ota_state.update_mode == OTA_WORK_STATE_ONLOOKER)//旁观者 { printf("p_msg->type:%x\n",p_msg->first_type); ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME); } else//非旁观者 { switch(p_msg->first_type) { case net_msg_type_update_start://开始升级指令 p_start = (ota_start_info_t *)p_msg->info; printf("p_msg->type:%x\n",p_msg->first_type); /* 校验当前设备是否为接收对象 */ if(device_type_and_id_cmp(p_start->rcv_device_type, p_start->rcv_device_sn) && p_start->des_device_type == ((p_start->update_version&0xffff0000)>>16)) { ota_state.update_mode = OTA_WORK_STATE_SLAVE; if(p_start->total_bytes > OTA_UPDATE_APP3_FLASH_SIZE)//升级包总长度大于存储区域大小 { updata_state_save(UPDATA_PACKAGE_LENGTH_ERROR);//存储升级状态 ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 printf("总长度太大\n"); return; } // if((p_start->rcv_device_type == 0xffff) && ((p_start->update_version&0xf0000000) != 0x10000000))//显示屏升级 // { // //软件版本错误 // updata_state_save(DEVICE_TYPE_ERROR);//存储升级状态 // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // printf("软件版本错误\n"); // return; // } // if((p_start->update_version&0xfffff000) != (SOFTWARE_VERSION_APP&0xfffff000))//软件版本号错误 // { // updata_state_save(DEVICE_TYPE_ERROR);//存储升级状态 // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // printf("软件版本错误\n"); // return; // } if(!ota_state.flash_erase)//第一次接收到指令擦除flash { ota_state.flash_erase = 1; device_irq_set(DISABLE); flash_flag = Flash_RangeErase(OTA_UPDATE_APP3_FLASH_START_ADDR, OTA_UPDATE_APP3_FLASH_SIZE); //擦除app3 printf("flash flag=%d\n",flash_flag); memset(&ota_slave, 0, sizeof(ota_pkg_info_t)); //打开升级总定时器 ota_timer_total_slave_set(OPEN,OTA_TOTAL_TIMEOUT_TIME_TICK); //存储升级状态 updata_state_save(START_UPDATA); //清除显示屏升级标志 BKP_WriteBackupRegister_code(BKP_DR4,0); //升级指示灯 ota_start_led_init(); Led_Single_State_Set(UPDATA_SLAVE_LED,LED_ON); } ota_state.update_state_slave = OTA_WORK_STATE_START; //存储升级信息 lora_node_ota_info_Init(&ota_slave,p_start); OTA_Continuous_Timeout = (ota_slave.total_pkgs * ota_slave.Send_interval) + CONTINUOUS_TIMEOUT_DELAY_TIME;//连续接收定时时间 if(OTA_Continuous_Timeout > CONTINUOUS_TIMEOUT_TIME_MUX)//发送时间太长 { printf("continuous time to long\n"); printf("ota continuous time:%u\n",OTA_Continuous_Timeout/1000); ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 return; } ota_timer_continuous_slave_set(OPEN,OTA_Continuous_Timeout);//打开连续接收定时器 printf("ota_totle_byte:%d, ota_totle_pkg:%d\n",ota_slave.total_bytes,ota_slave.total_pkgs); printf("send interval:%d, continuous time:%d\n",ota_slave.Send_interval,OTA_Continuous_Timeout/1000); } else { ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 } break; case net_msg_type_update_continues://连续发包阶段 p_cont = (ota_continues_info_t *)p_msg->info; if(device_type_and_id_cmp(p_cont->rcv_device_type, p_cont->rcv_device_sn)) //是当前设备 { if(ota_state.update_state_slave == OTA_WORK_STATE_CONTINUOUS)//收到了升级开始指令 { ota_state.update_mode = OTA_WORK_STATE_SLAVE; if(p_cont->sub_pkg_len > OTA_UPDATE_PAYLAOA_LEN)//收到的包长度大于128，收到的数据错误 return; if(p_cont->sub_pkg_id < ota_slave.lastRightPkgNum) return; if(p_cont->total_pkgs == ota_slave.total_pkgs) { printf("update continues: type = 0x%x, id = 0x%x, {%d/%d/%d}\r\n", p_cont->rcv_device_type, p_cont->rcv_device_sn, p_cont->total_pkgs, p_cont->sub_pkg_id,ota_slave.lossPkgCounter); //接收本包并写入flash的对应位置 Flash_BufferWrite(OTA_UPDATE_APP3_FLASH_START_ADDR + (p_cont->sub_pkg_id - 1)*OTA_UPDATE_PAYLAOA_LEN, (uint32_t *)(p_cont->pkg_content), p_cont->sub_pkg_len); //更新收包相关状态 for(i = ota_slave.lastRightPkgNum;i < p_cont->sub_pkg_id;i++) { ota_slave.lossPkgCounter++; ota_slave.lossPkgId[ota_slave.lossPkgIndex++] = i;//+1因为子包编号从0开始， //丢包太多了，超过了MAX_LOSS_PKG_COUNT，结束本次升级。 if(ota_slave.lossPkgCounter == MAX_LOSS_PKG_COUNT) {//降为旁观者, 放弃本次升级 ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 updata_state_save(PACKET_LOSS_MORE);//存储升级状态 return; } } ota_slave.lastRightPkgNum = p_cont->sub_pkg_id + 1; if(p_cont->sub_pkg_id == ota_slave.total_pkgs)//当前是最后一包 { if(ota_slave.lossPkgCounter == 0) //没有丢包 { ota_state.update_state_slave = OTA_WORK_STATE_RCV_END; printf("check begin\n"); ota_continuous_end_handle(); } else //有丢包 { ota_timer_retransmit_require_slave_set(OPEN,RETRANSMIT_DELAY_TIMEOUT_MIN);//打开重传延时定时器 ota_timer_retransmit_slave_set(OPEN,RETRANSMIT_TIMEOUT_TIME); //打开重传定时器 ota_timer_continuous_slave_set(CLOSE,0);//关闭连续定时器 printf("retransmit begin\n"); } } else { //连续接收定时时间 OTA_Continuous_Timeout = ((ota_slave.total_pkgs-p_cont->sub_pkg_id) * ota_slave.Send_interval)+ CONTINUOUS_TIMEOUT_DELAY_TIME; ota_timer_continuous_slave_set(OPEN,OTA_Continuous_Timeout);//打开连续接收定时器 printf("send interval:%d, continuous time:%d\n",ota_slave.Send_interval,OTA_Continuous_Timeout/1000); } //指示灯显示 remain_pkg = ota_slave.total_pkgs-p_cont->sub_pkg_id; Data_last4bit_led(remain_pkg,1); } } else//未收到升级开始指令 { updata_state_save(START_UPDATA_NONE);//存储升级状态 ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 ota_timer_continuous_slave_set(CLOSE,OTA_Continuous_Timeout);//关闭连续接收定时器 } } else { ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 ota_timer_continuous_slave_set(CLOSE,OTA_Continuous_Timeout);//关闭连续接收定时器 } break; case net_msg_type_update_retransmit_rsp://重传发包指令 p_cont = (ota_continues_info_t *)p_msg->info; if(device_type_and_id_cmp(p_cont->rcv_device_type, p_cont->rcv_device_sn)) { if(ota_state.update_state_slave == OTA_WORK_STATE_RETRANSMIT)//收到升级开始指令 { ota_state.update_mode = OTA_WORK_STATE_SLAVE; if(p_cont->sub_pkg_len > OTA_UPDATE_PAYLAOA_LEN)//收到的包长度大于128，收到的数据错误 return; if(p_cont->total_pkgs == ota_slave.total_pkgs) { //判定该包是否为本设备丢的那些包之中的子包 for(i = 0;i < ota_slave.lossPkgIndex;i++) { if(ota_slave.lossPkgId[i] == p_cont->sub_pkg_id) { ota_slave.lossPkgCounter--; ota_slave.lossPkgId[i] = 0; //接受本包并写入flash的对应位置 Flash_BufferWrite(OTA_UPDATE_APP3_FLASH_START_ADDR + (p_cont->sub_pkg_id - 1)*OTA_UPDATE_PAYLAOA_LEN, (uint32_t *)(p_cont->pkg_content), p_cont->sub_pkg_len); printf("rcv retransmit pkgid:%d\n",p_cont->sub_pkg_id); break; } } printf("ota_info.lossPkgCounter = %d, lossPkgId:%d\r\n", ota_slave.lossPkgCounter,p_cont->sub_pkg_id); if(ota_slave.lossPkgCounter == 0) //丢包已收完 { ota_state.update_state_slave = OTA_WORK_STATE_RCV_END; ota_continuous_end_handle(); return; } //指示灯显示 remain_pkg = ota_slave.lossPkgCounter; Data_last4bit_led(remain_pkg,1); } ota_timer_retransmit_slave_set(OPEN,RETRANSMIT_TIMEOUT_TIME);//打开重传定时器 } else//未收到升级开始指令 { // updata_state_save(START_UPDATA_NONE);//存储升级状态 ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 } } else { ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 } break; case net_msg_type_update_offline://网关下发开始离线升级 if(ota_state.update_mode == 0) { p_off = (gateway_coll_offline_upgrade_t *)p_msg->info; if(p_off->master_device_type==0x0201 && p_off->master_device_sn==device_info.device_sn) { ota_state.update_mode = OTA_WORK_STATE_MASTER; lora_master_ota_gateway_info_init(p_off); device_fixed_info.master_updata_start = 1; ota_state.offline_mode = GATEWAY_TRIGGER; printf("网关下发开始离线升级\n"); printf("slave sn:%010u, des sn:%010u\n",p_off->slave_device_sn,p_off->des_device_sn); } else { if(device_info.alrd == DEVICE_ALRD) { device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; } else { device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT; } } } break; default: if(ota_state.update_mode == 0) { if(device_info.alrd == DEVICE_ALRD) { device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; } else { device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT; } } break; } } } //升级包校验判断 uint8_t ota_update_pkg_check(uint16_t type, uint8_t state) { // uint8_t flashbuf[64]; uint8_t ret = 0; uint32_t crcVl,fixChar,fileVer,filelen/*,fileaddr*/; uint32_t getcrc; // uint32_t xspl_addr,xspl_len,xspa_len; //判断升级设备类型 crcVl = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+ota_slave.total_bytes-4); //CRC校验 fixChar = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+ota_slave.total_bytes-8); // 固定字符 WBJW fileVer = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+ota_slave.total_bytes-12); // 固件版本信息 // fileaddr = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+ota_slave.total_bytes-16); // 存储地址 filelen = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+ota_slave.total_bytes-20); // 文件总长度 if(type == 0x0201) { printf("read_fixchar:%08x, fixchar:%08x\n",fixChar,0x57424A57); if(fixChar != 0x57424A57) //固定字符错误 { ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 updata_state_save(FIXED_CHARACTER_ERROR);//存储升级状态 printf("fixChar error\r\n");// 升级文件固定字符校验错误 return ret; } printf("read_filever:%08x, update_ver:%08x\n",fileVer,ota_slave.update_version); if((fileVer) != ota_slave.update_version) //固件信息错误 { ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 updata_state_save(DEVICE_TYPE_ERROR);//存储升级状态 printf("fileVer error\r\n");// 升级文件固件信息校验错误 return ret; } printf("read_filelen:%08x, total_bytes:%08x\n",filelen,(ota_slave.total_bytes-20)); if(ota_slave.total_bytes != (filelen+20))//长度错误 { ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 updata_state_save(UPDATA_PACKAGE_LENGTH_ERROR);//存储升级状态 printf("filelen error\r\n");// 升级文件长度校验错误 return ret; } RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,ENABLE); CRC_ResetDR(); CRC_CalcBlockCRC((uint32_t*)OTA_UPDATE_APP3_FLASH_START_ADDR, (ota_slave.total_bytes -4)/4); getcrc = CRC_GetCRC(); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,DISABLE); printf("read_crc:%x, get_crc:%x\n",crcVl,getcrc); if(getcrc!=crcVl) { //校验错误 ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 updata_state_save(UPDATA_CRC_ERROR);//存储升级状态 printf("update file crc error\r\n");// 升级文件crc校验错误 return ret; } printf("收包正确\n"); updata_state_save(UPDATA_DATA_SUCCESS);//存储升级状态 ret = 1; // return ret; } else if(type == XSP_0904) { RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,ENABLE); CRC_ResetDR(); CRC_CalcBlockCRC((uint32_t*)OTA_UPDATE_APP3_FLASH_START_ADDR, (ota_slave.total_bytes -4)/4); getcrc = CRC_GetCRC(); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,DISABLE); printf("read_crc:%x, get_crc:%x\n",crcVl,getcrc); if(getcrc!=crcVl) { //校验错误 ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 updata_state_save(UPDATA_CRC_ERROR);//存储升级状态 printf("update file crc error\r\n");// 升级文件crc校验错误 return ret; } printf("收包正确\n"); updata_state_save(UPDATA_DATA_SUCCESS);//存储升级状态 ret = 1; // return ret; // if(fixChar != XSPL_CHAR) //固定字符错误 // { // if(state) // { // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // updata_state_save(FIXED_CHARACTER_ERROR);//存储升级状态 // } // printf("fixChar error\r\n");// 升级文件固定字符校验错误 // return ret; // } //// printf("read_filever:%08x, update_ver:%08x\n",fileVer,ota_slave.update_version); //// if((fileVer) != ota_slave.update_version) //固件版本信息错误 //// { //// ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 //// updata_state_save(DEVICE_TYPE_ERROR);//存储升级状态 //// printf("fileVer error\r\n");// 升级文件固件信息校验错误 //// return ret; //// } // XSPL_len = filelen; // XSPL_addr = fileaddr; // if(XSPL_addr != OTA_UPDATE_APP3_FLASH_START_ADDR+ota_slave.total_bytes-filelen-20) // { // //路由表的起始地址和长度错误 // if(state) // { // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // updata_state_save(UPDATA_PACKAGE_LENGTH_ERROR);//存储升级状态 // } // printf("xspl startaddr and length err\n"); // return ret; // } // // printf("xspl_addr:%08x,len:%d\n",XSPL_addr,(XSPL_len+16)); //// if((XSPL_len+16) <= 64) //// { //// Flash_BufferRead(XSPL_addr,(uint8_t *)flashbuf,XSPL_len+16); //// data_dump("flash",flashbuf,XSPL_len+16); //// } // RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,ENABLE); // CRC_ResetDR(); // CRC_CalcBlockCRC((uint32_t*)XSPL_addr, (XSPL_len+16)/4); // getcrc = CRC_GetCRC(); // RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,DISABLE); // printf("read_crc:%x, get_crc:%x\n",crcVl,getcrc); // if(getcrc!=crcVl) { //校验错误 // if(state) // { // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // updata_state_save(UPDATA_CRC_ERROR);//存储升级状态 // } // printf("update file crc error\r\n");// 升级文件crc校验错误 // return ret; // } // //显示屏路由表校验正确，校验显示屏升级包 // crcVl = *(uint32_t*)(XSPL_addr-4); //CRC校验 // fixChar = *(uint32_t*)(XSPL_addr-8); // 固定字符 XSPA // fileVer = *(uint32_t*)(XSPL_addr-12); // 固件信息 // filelen = *(uint32_t*)(XSPL_addr-20); // 文件总长度 // XSPA_len = XSPL_addr-OTA_UPDATE_APP3_FLASH_START_ADDR-20; // // XSP_OTA_VER = fileVer;//显示屏版本号 // // if(fixChar != XSPA_CHAR) //固定字符错误 // { // if(state) // { // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // updata_state_save(FIXED_CHARACTER_ERROR);//存储升级状态 // } // printf("fixChar error\r\n");// 升级文件固定字符校验错误 // return ret; // } // if(state) // { // printf("read_filever:%08x, update_ver:%08x\n",fileVer,ota_slave.update_version); // if((fileVer) != ota_slave.update_version) //固件信息错误 // { // XSP_OTA_VER = 0; // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // updata_state_save(DEVICE_TYPE_ERROR);//存储升级状态 // printf("fileVer error\r\n");// 升级文件固件信息校验错误 // return ret; // } // } // printf("read_filelen:%08x, total_bytes:%08x\n",filelen,(XSPA_len)); // if(XSPA_len != (filelen))//长度错误 // { // if(state) // { // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // updata_state_save(UPDATA_PACKAGE_LENGTH_ERROR);//存储升级状态 // } // printf("filelen error\r\n");// 升级文件长度校验错误 // return ret; // } // RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,ENABLE); // CRC_ResetDR(); // CRC_CalcBlockCRC((uint32_t*)OTA_UPDATE_APP3_FLASH_START_ADDR, (XSPA_len+16)/4); // getcrc = CRC_GetCRC(); // RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,DISABLE); // printf("read_crc:%x, get_crc:%x\n",crcVl,getcrc); // if(getcrc!=crcVl) { //校验错误 // if(state) // { // ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME);//打开旁观者定时器 // updata_state_save(UPDATA_CRC_ERROR);//存储升级状态 // } // printf("update file crc error\r\n");// 升级文件crc校验错误 // return ret; // } // printf("收包正确\n"); // updata_state_save(UPDATA_DATA_SUCCESS);//存储升级状态 // // //计算升级包信息 // XSPH_APP_Len = *(uint16_t*)(XSPL_addr-20-2); // XSPH_APP_Addr = *(uint16_t*)(XSPL_addr-20-4); // XSPL_APP_Len = *(uint16_t*)(XSPL_addr-20-6); // XSPL_APP_Addr = *(uint16_t*)(XSPL_addr-20-8); // XSPL_APP_Crc = xsp_update_crc(OTA_UPDATE_APP3_FLASH_START_ADDR+XSPL_APP_Addr,XSPL_APP_Len); // XSPH_APP_Crc = xsp_update_crc(OTA_UPDATE_APP3_FLASH_START_ADDR+XSPH_APP_Addr,XSPH_APP_Len); // ota_xsp_pack_info.update_ver = fileVer; // printf("xspl addr=0x%04x, xspl len=%d, xspl crc=0x%04x\n",XSPL_APP_Addr,XSPL_APP_Len,XSPL_APP_Crc); // printf("xsph addr=0x%04x, xsph len=%d, xsph crc=0x%04x\n",XSPH_APP_Addr,XSPH_APP_Len,XSPH_APP_Crc); // // ret = 1; // return ret; } return ret; } //连续接收完成任务处理函数 void ota_continuous_end_handle(void) { // uint32_t crcVl,fixChar,fileVer,filelen; // uint32_t getcrc; uint16_t i; uint8_t ret; switch(ota_state.update_state_slave) { case OTA_WORK_STATE_RCV_END: ota_timer_continuous_slave_set(CLOSE,0);//关闭连续定时器 ota_timer_retransmit_slave_set(CLOSE,0);//关闭重传定时器 ota_timer_retransmit_require_slave_set(CLOSE,0);//关闭重传请求定时器 if(ota_slave.des_device_type == 0x0201)//采集器升级 { ret = ota_update_pkg_check(0x0201,0); if(ret)//校验正确 { if(ota_slave.des_device_type == (SOFTWARE_VERSION_APP&0xffff0000)>>16)//自身升级 { //置升级标志 updata_state_info.updata_flag = set_updata_state(UPDATA_FLAG); BKP_WriteBackupRegister(BKP_DR2, updata_state_info.updata_flag); //存储APP3版本 device_version_info.APP3_ver = ota_slave.update_version; eeprom_write_data(EECFG_APP3_VER0,(uint8_t *)&device_version_info.APP3_ver,4); NVIC_SystemReset(); } } } else if(ota_slave.des_device_type == XSP_0904)//显示屏升级 { ret = ota_update_pkg_check(XSP_0904,0); if(ret)//校验正确 { //存储APP3版本 device_version_info.APP3_ver = ota_slave.update_version; eeprom_write_data(EECFG_APP3_VER0,(uint8_t *)&device_version_info.APP3_ver,4); ota_timer_onlooker_slave_set(CLOSE,0);//关闭旁观者定时器 ota_timer_continuous_slave_set(CLOSE,0);//关闭连续发包定时器 ota_timer_retransmit_slave_set(CLOSE,0);//关闭重传阶段定时器 ota_timer_total_slave_set(CLOSE,0);//关闭总定时器 memset(&ota_state,0,sizeof(ota_state)); if(device_info.alrd == DEVICE_ALRD)//已初始化 { device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; } else { device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT; } device_fixed_info.xsp_update_start = 1;//升级显示屏标志 printf("收包完成，开始升级显示屏 \n"); } } // else if((ota_slave.des_device_type&0xf000) == 0x1000)//显示屏升级 // { // ret = ota_update_pkg_check(DISPLAY,1); // if(ret)//校验正确 // { // get_xsp_ota_info(XSPL_addr,XSPL_len); // if(check_route_xsp_ota()) // { // ota_timer_onlooker_slave_set(CLOSE,0);//关闭旁观者定时器 // // //显示屏升级标志存储 // BKP_WriteBackupRegister_code(BKP_DR4,XSP_UPDATE); // //显示屏升级次数存储 // BKP_WriteBackupRegister_code(BKP_DR5,0); // // xsp_ota_start(); //// memset(&ota_xsp_info,0,sizeof(ota_xsp_info_t)); // ota_xsp_init(); // } // // } // //// device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; //// ota_timer_onlooker_slave_set(CLOSE,0); //// ota_timer_total_slave_set(CLOSE,0);//关闭总定时器 // } break; case OTA_WORK_STATE_RETRANSMIT://重传 if(sys_lora_tx.lora_q.MsgQ.NbrEntries==0)//当前队列中的消息数。 { for(i = 0;i < ota_slave.lossPkgIndex;i++) { if(ota_slave.lossPkgId[i]) { ota_retransmit_req(ota_slave.lossPkgId[i]); printf("send retransmit pkgid:%d\n",ota_slave.lossPkgId[i]); break; } } } // ota_timer_retransmit_require_slave_set(OPEN,RETRANSMIT_DELAY_TIMEOUT_MIN);//打开重传延时定时器 break; } } //从设备升级状态返回 void lora_slave_ota_updatestate_resp(uint8_t updatestate) { collect_gateway_msg_format_t msg; ota_state_upload_t *p_ota = (ota_state_upload_t *)msg.info; p_ota->rcv_device_type = device_info.device_type; p_ota->rcv_device_sn = device_info.device_sn; p_ota->des_device_type = device_info.device_type; p_ota->des_device_sn = device_info.device_sn; p_ota->des_bt_ver = device_fixed_info.Soft_ver_boot; p_ota->des_app_ver = device_fixed_info.Soft_ver_app; p_ota->update_state = updatestate; p_ota->reserve = 0; coll_msg_send(&msg, net_msg_type_update_status_upload, OTA_STATE_UPLOAD_LEN); // slave_upload_info.num++;//上报次数 // printf("slave send %d ",slave_upload_info.num); // data_dump("times",(uint8_t *)&msg,FRAME_HEADER_LEN + OTA_STATE_UPLOAD_LEN+2); } //从设备主动上报结束 void slave_upload_end(void) { ota_timer_upload_cad_slave_set(CLOSE,0);//关闭上报间隔定时 ota_timer_upload_total_slave_set(CLOSE,0);//关闭上报总定时 if(device_info.alrd == DEVICE_ALRD)//已初始化 { device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; } else { device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT; } memset(&slave_upload_info,0,sizeof(slave_upload_info_t)); memset(&ota_state,0,sizeof(ota_state_t)); close_all_led(); } //从设备升级定时器处理 void ota_slave_time_handle(void) { ota_timeout_onlooker_slave(); //旁观者定时器超时处理 ota_timeout_continuous_slave(); //连续阶段定时器超时处理 ota_timeout_retransmit_slave(); //重传阶段定时器超时处理 ota_timeout_total_slave(); //总定时器超时处理 ota_timeout_retransmit_require_slave(); //重传请求超时处理 ota_timeout_upload_cad_slave(); //主动上报升级状态间隔超时处理 ota_timeout_upload_total_slave(); //主动上报升级状态总定时超时处理 } //////////////////////////////////////////////////////////////////////////////////// ////离线升级 //主设备总定时器设置 void ota_timer_total_master_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { timeout_setValue(&ota_master.tt_ota_total,timeout,1); } else if(state == CLOSE) { timeout_stop(&ota_master.tt_ota_total); } } //主设备总定时超时 void ota_timeout_total_master(void) { if(timeout_isOut(&ota_master.tt_ota_total)) { if(ota_state.update_mode != OTA_WORK_STATE_XSP) master_rcv_total_proc();//离线升级时打印 if(device_info.alrd == DEVICE_ALRD)//已初始化 { device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; } else { device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT; } memset(&ota_state,0,sizeof(ota_state_t)); ota_timer_retransmit_master_set(CLOSE,0);//关闭重传定时器 close_all_led(); printf("master total timeout \n"); } } //主设备重传定时器设置 void ota_timer_retransmit_master_set(uint8_t state, uint32_t timeout) { if(state == OPEN) { timeout_setValue(&ota_master.tt_ota_retransmit,timeout,1); } else if(state == CLOSE) { timeout_stop(&ota_master.tt_ota_retransmit); } } //主设备重传定时超时 void ota_timeout_retransmit_master(void) { if(timeout_isOut(&ota_master.tt_ota_retransmit)) { if(ota_state.update_mode != OTA_WORK_STATE_XSP) master_rcv_total_proc();//离线升级时打印 memset(&ota_state,0,sizeof(ota_state_t)); ota_timer_total_master_set(CLOSE,0);//关闭总定时器 close_all_led(); if(device_info.alrd == DEVICE_ALRD)//已初始化 { device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL; } else { device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT; } printf("master update over\n"); } } //读取app程序包的大小并校验 uint32_t Read_APP_datalen_check(uint32_t addr, uint32_t len) { uint32_t datalen = 0; uint32_t crcVl,fixChar,fileVer,filelen,getcrc,t_addr; uint32_t bin_data[6] = {0}; uint8_t flag = 0; uint8_t check_flag = 0; printf("addr=%08x\n",addr); datalen = Flash_DatalenRead(addr,len); filelen = *(uint32_t*)(addr+datalen-20); // 文件总长度 printf("datalen=%08x,%u; filelen=%08x,%u\n",datalen,datalen,filelen,filelen); if(datalen > (128*1024)) { printf("升级包长度超过128K: %d\n",datalen); datalen = 0; } else { printf("addr=%08x\n",addr); crcVl = *(uint32_t*)(addr + datalen-4); //CRC校验 fixChar = *(uint32_t*)(addr + datalen-8); // 固定字符 WBJW fileVer = *(uint32_t*)(addr + datalen-12); // 固件信息 filelen = *(uint32_t*)(addr + datalen-20); // 文件总长度 t_addr = *(uint32_t*)(addr + datalen-16); // 文件写入的地址 printf("crcVl=%08x,fixChar=%08x,fileVer=%08x,filelen=%08x,t_addr=%08x\n",crcVl,fixChar,fileVer,filelen,t_addr); //判断后20字节是否正确 if((fixChar == WBJW_CHAR) && (t_addr == 0x08020000))//升级包中包含了后20字节 { printf("升级包包含了后20字节\n"); if(datalen != (filelen+20)) { printf("升级包长度校验错误\n"); check_flag = 1; } else if(fileVer != device_fixed_info.Soft_ver_app) { printf("固件信息错误\n"); printf("filever=%08x,app=%08x\n",fileVer,device_fixed_info.Soft_ver_app); check_flag = 1; } else { RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,ENABLE); CRC_ResetDR(); CRC_CalcBlockCRC((uint32_t*)addr, (datalen -4)/4); getcrc = CRC_GetCRC(); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,DISABLE); printf("read_crc:%08x, get_crc:%08x\n",crcVl,getcrc); if(crcVl != getcrc) { printf("crc 错误\n"); check_flag = 1; } } } else { check_flag = 1; } if(check_flag)//需要计算后20个字节 { bin_data[0] = datalen; //原始bin文件字节长度 bin_data[1] = 0x08020000; //存储地址 bin_data[2] = device_fixed_info.Soft_ver_app; //固件版本 bin_data[3] = WBJW_CHAR; //固定标记，"WBJW" flag = Flash_BufferWrite(addr+datalen,bin_data,16); printf("first flag = %d\n",flag); datalen += 20; RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,ENABLE); CRC_ResetDR(); CRC_CalcBlockCRC((uint32_t*)addr, (datalen -4)/4); getcrc = CRC_GetCRC(); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,DISABLE); bin_data[0] = getcrc; printf("crc=%08x\n",bin_data[0]); flag = Flash_BufferWrite(addr+datalen-4,bin_data,4); //crc校验 printf("second flag = %d\n",flag); } } return datalen; } //升级开始指令 void lora_master_ota_start(void) { uint32_t timer = 0; collect_gateway_msg_format_t msg; ota_start_info_t *p_ota = (ota_start_info_t *)msg.info; p_ota->des_device_type = ota_master.des_device_type; // device_info.device_type; p_ota->des_device_sn = ota_master.des_device_sn; //0xffffffff; p_ota->rcv_device_type = ota_master.rcv_device_type; //device_info.device_type; p_ota->rcv_device_sn = ota_master.rcv_device_sn; //0xffffffff; p_ota->update_version = ota_master.update_version; //device_fixed_info.Soft_ver_app; p_ota->total_bytes = ota_master.total_bytes; timer = RadioTimeOnAir2(MODEM_LORA,140); timer = (timer>UPDATE_EACH_TIME) ? timer : UPDATE_EACH_TIME; p_ota->Send_interval = timer; printf("total_bytes = %d, send interval = %d\n",p_ota->total_bytes, timer); coll_msg_send(&msg, net_msg_type_update_start, OTA_START_INFO_LEN); } //网关下发离线升级时初始化 int lora_master_ota_gateway_info_init(gateway_coll_offline_upgrade_t *p_off) { memset(&ota_master, 0, sizeof(ota_pkg_info_t)); ota_master.des_device_type = p_off->des_device_type; ota_master.des_device_sn = p_off->des_device_sn; ota_master.rcv_device_type = p_off->slave_device_type; ota_master.rcv_device_sn = p_off->slave_device_sn; ota_master.update_version = device_fixed_info.Soft_ver_app; ota_master.total_bytes = 0; ota_master.total_crc = 0; ota_master.total_pkgs = 0; ota_master.lastRightPkgNum = 1; ota_master.sub_pkg_id = 1; return 0; } //按键触发离线升级时初始化 int lora_master_ota_key_info_Init(uint32_t total_len, uint32_t total_crc) { memset(&ota_master, 0, sizeof(ota_pkg_info_t)); ota_master.des_device_type = device_info.device_type; ota_master.des_device_sn = 0xffffffff; ota_master.rcv_device_sn = 0xffffffff; ota_master.rcv_device_type = device_info.device_type; ota_master.update_version = device_fixed_info.Soft_ver_app; ota_master.total_bytes = total_len; ota_master.total_crc = total_crc; ota_master.total_pkgs = total_len/OTA_UPDATE_PAYLAOA_LEN; ota_master.lastRightPkgNum = 1; if(total_len%OTA_UPDATE_PAYLAOA_LEN) { ota_master.total_pkgs += 1; } ota_master.sub_pkg_id = 1; return 0; } //连续发送阶段 void lora_master_ota_continues(void) { collect_gateway_msg_format_t msg; ota_continues_info_t *p_ota = (ota_continues_info_t *)msg.info; OS_ERR err; uint32_t timer = 0; char buff[128] = {0}; // uint16_t i=0; printf("lora_gw_ota_continues\r\n"); p_ota->total_pkgs = ota_master.total_pkgs; p_ota->sub_pkg_len = OTA_UPDATE_PAYLAOA_LEN; p_ota->des_device_type = ota_master.des_device_type; p_ota->des_device_sn = ota_master.des_device_sn; p_ota->rcv_device_sn = ota_master.rcv_device_sn; p_ota->rcv_device_type = ota_master.rcv_device_type; timer = RadioTimeOnAir2(MODEM_LORA,140); timer = (timer>UPDATE_EACH_TIME) ? timer : UPDATE_EACH_TIME; printf("timer = %d\r\n", timer); printf("lora_update total_pkgs = %d\r\n",ota_master.total_pkgs); while(ota_master.sub_pkg_id <= ota_master.total_pkgs) { printf("lora_gw_ota_continues {%d/%d}\r\n", ota_master.total_pkgs,ota_master.sub_pkg_id); p_ota->sub_pkg_id = ota_master.sub_pkg_id++; Flash_BufferRead(OTA_UPDATE_APP1_FLASH_START_ADDR + (p_ota->sub_pkg_id - 1)*OTA_UPDATE_PAYLAOA_LEN, (uint8_t *)buff, OTA_UPDATE_PAYLAOA_LEN); memcpy(p_ota->pkg_content,buff,128); coll_msg_send(&msg, net_msg_type_update_continues, OTA_CONTINUES_INFO_LEN + OTA_UPDATE_PAYLAOA_LEN); //指示灯显示(显示剩余包数后四位) Data_last4bit_led(ota_master.total_pkgs-ota_master.sub_pkg_id,1); OSTimeDlyHMSM(0, 0, 0, timer, OS_OPT_TIME_DLY, &err); } } //发送重传包 void lora_master_ota_retransmit_resp(ota_retransmit_req_t *p_req) { collect_gateway_msg_format_t msg; ota_continues_info_t *p_ota = (ota_continues_info_t *)msg.info; char buff[128] = {0}; p_ota->total_pkgs = ota_master.total_pkgs; p_ota->sub_pkg_id = p_req->repeat_sub_pkg_id; p_ota->sub_pkg_len = OTA_UPDATE_PAYLAOA_LEN; p_ota->des_device_type = ota_master.des_device_type; p_ota->des_device_sn = ota_master.des_device_sn; p_ota->rcv_device_sn = ota_master.rcv_device_sn; p_ota->rcv_device_type = ota_master.rcv_device_type; Flash_BufferRead(OTA_UPDATE_APP1_FLASH_START_ADDR + (p_req->repeat_sub_pkg_id - 1)*OTA_UPDATE_PAYLAOA_LEN, (uint8_t *)buff, OTA_UPDATE_PAYLAOA_LEN); memcpy(p_ota->pkg_content,buff,128); coll_msg_send(&msg, net_msg_type_update_retransmit_rsp, OTA_CONTINUES_INFO_LEN + OTA_UPDATE_PAYLAOA_LEN); } //主设备收到状态上报指令处理 void master_upload_proc(collect_gateway_msg_format_t *p_msg) { int i; ota_state_upload_t *p_ota = (ota_state_upload_t *)p_msg->info; master_rcv_info.rcv_print_num++; printf("第%03d条：des_type:%04x,des_sn:%08x,des_bt:%08x,des_app:%08x,update_state:%02x\n",master_rcv_info.rcv_print_num, p_ota->des_device_type,\ p_ota->des_device_sn,p_ota->des_bt_ver,p_ota->des_app_ver,p_ota->update_state); if(master_rcv_info.rcv_total_num < 64) { if(master_rcv_info.rcv_total_num) { for(i = 0; i < master_rcv_info.rcv_total_num; i++) { if(master_rcv_info.master_rcv_update[i].des_sn == p_ota->des_device_sn) { master_rcv_info.master_rcv_update[i].des_type = p_ota->des_device_type; master_rcv_info.master_rcv_update[i].des_sn = p_ota->des_device_sn; master_rcv_info.master_rcv_update[i].des_bt = p_ota->des_bt_ver; master_rcv_info.master_rcv_update[i].des_app = p_ota->des_app_ver; master_rcv_info.master_rcv_update[i].state = p_ota->update_state; return; } } } master_rcv_info.master_rcv_update[master_rcv_info.rcv_total_num].des_type = p_ota->des_device_type; master_rcv_info.master_rcv_update[master_rcv_info.rcv_total_num].des_sn = p_ota->des_device_sn; master_rcv_info.master_rcv_update[master_rcv_info.rcv_total_num].des_bt = p_ota->des_bt_ver; master_rcv_info.master_rcv_update[master_rcv_info.rcv_total_num].des_app = p_ota->des_app_ver; master_rcv_info.master_rcv_update[master_rcv_info.rcv_total_num].state = p_ota->update_state; master_rcv_info.rcv_total_num++; } } int cmp(const void *a, const void *b) { // return (*(uint32_t *)a - *(uint32_t *)b); return ((*(uint32_t *)a>*(uint32_t *)b)?1:-1); //从小到大排序 } //主设备统计状态 void master_rcv_total_proc(void) { uint32_t des_sn[64] = {0}; int i; for(i = 0; i < master_rcv_info.rcv_total_num; i++) { if(master_rcv_info.master_rcv_update[i].state == UPDATA_SUCCESS) { des_sn[master_rcv_info.rcv_success_num] = master_rcv_info.master_rcv_update[i].des_sn; master_rcv_info.rcv_success_num++; } } printf("升级成功%d个：\n",master_rcv_info.rcv_success_num); //快排（从小到大排序） qsort(des_sn,master_rcv_info.rcv_success_num,sizeof(des_sn[0]),cmp); for(i = 0; i < master_rcv_info.rcv_success_num; i++) { if((i%4 == 0)&&i) { if((i%8 == 0)&&i) { printf("\r\n"); } else { printf(" "); } } printf("%010u ",des_sn[i]); } printf("\n"); } //收到重传请求后下发命令 void lora_master_ota_proc(collect_gateway_msg_format_t *p_msg) { ota_retransmit_req_t *p_req = NULL; if(ota_state.update_mode == OTA_WORK_STATE_ONLOOKER) { ota_timer_onlooker_slave_set(OPEN,ONLOOKER_TIMEOUT_TIME); return; } switch(p_msg->first_type) { case net_msg_type_update_retransmit_req://从设备的重传请求 p_req = (ota_retransmit_req_t *)p_msg->info; lora_master_ota_retransmit_resp(p_req); ota_timer_retransmit_master_set(OPEN,OTA_MASTER_WAIT_TIME_TICK);//主设备等待定时器 break; case net_msg_type_update_status: break; case net_msg_type_update_status_upload://从设备的状态返回 ota_timer_retransmit_master_set(OPEN,OTA_MASTER_WAIT_TIME_TICK);//主设备等待定时器 master_upload_proc(p_msg); break; default: break; } } //离线升级时的主设备 void Offline_upgrade_master(void) { OS_ERR err; uint32_t total_bytes = 0; uint32_t i = 0; //清空接收信息 memset(&master_rcv_info,0,sizeof(master_rcv_info_t)); //打开总定时器 ota_timer_total_master_set(OPEN,OTA_TOTAL_TIMEOUT_TIME_TICK); //升级指示灯 ota_start_led_init(); Led_Single_State_Set(UPDATA_MASTER_LED,LED_ON); total_bytes = Read_APP_datalen_check(OTA_UPDATE_APP1_FLASH_START_ADDR,OTA_UPDATE_APP1_FLASH_SIZE); if(total_bytes==0) //升级包长度错误,升级结束，总定时设置为1ms { ota_timer_total_master_set(OPEN,1); return; } printf("send total_bytes=%d\n",total_bytes); if(ota_state.offline_mode == KEY_TRIGGER) { lora_master_ota_key_info_Init(total_bytes,0); printf("按键触发\n"); } else if(ota_state.offline_mode == GATEWAY_TRIGGER) { printf("命令触发\n"); ota_master.total_bytes = total_bytes; ota_master.total_pkgs = total_bytes/OTA_UPDATE_PAYLAOA_LEN; if(total_bytes%OTA_UPDATE_PAYLAOA_LEN) { ota_master.total_pkgs++; } } for(i = 0; i < 5; i++) { lora_master_ota_start(); OSTimeDlyHMSM(0, 0, 2, 0, OS_OPT_TIME_DLY, &err); } lora_master_ota_continues(); //连续发送完成，打开等待定时器，如果一定时间内没收到重传请求或状态上报则认为升级结束 ota_timer_retransmit_master_set(OPEN,OTA_MASTER_WAIT_TIME_TICK); } //离线升级主设备定时处理 void ota_master_time_handle(void) { ota_timeout_retransmit_master();//重传定时超时 ota_timeout_total_master();//总定时超时 } //显示屏升级重启后升级 uint32_t xsp_update_reboot(void) { uint8_t ret; uint32_t datalen = 0; uint32_t filelen,fixChar;//fileVer,crcVl,getcrc,t_addr; datalen = Flash_DatalenRead(OTA_UPDATE_APP3_FLASH_START_ADDR,OTA_UPDATE_APP3_FLASH_SIZE); filelen = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+datalen-20); // 文件总长度 fixChar = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+datalen-8); // 固定字符 WBJW printf("datalen=%08x,%u; filelen=%08x,%u\n",datalen,datalen,filelen,filelen); if(datalen > (128*1024) || datalen == 0 || filelen > (datalen) || filelen == 0) { printf("升级包长度错误: %d\n",datalen); //清除显示屏升级标志 BKP_WriteBackupRegister_code(BKP_DR4,0); //显示屏升级次数存储 BKP_WriteBackupRegister_code(BKP_DR5,0); return datalen; } memset(&ota_slave,0,sizeof(ota_pkg_info_t)); ota_slave.total_bytes = datalen; XSPL_addr = OTA_UPDATE_APP3_FLASH_START_ADDR+datalen-filelen-20; XSPL_len = filelen; printf("addr=%08x\n",XSPL_addr); // crcVl = *(uint32_t*)(XSPL_addr + datalen-4); //CRC校验 // fixChar = *(uint32_t*)(XSPL_addr + datalen-8); // 固定字符 WBJW // fileVer = *(uint32_t*)(XSPL_addr + datalen-12); // 固件信息 // filelen = *(uint32_t*)(XSPL_addr + datalen-20); // 文件总长度 // t_addr = *(uint32_t*)(XSPL_addr + datalen-16); // 文件写入的地址 if(fixChar != XSPL_CHAR)//显示屏 { //清除显示屏升级标志 BKP_WriteBackupRegister_code(BKP_DR4,0); //显示屏升级次数存储 BKP_WriteBackupRegister_code(BKP_DR5,0); return datalen; } ret = ota_update_pkg_check(0x0401,0); if(ret)//校验正确 { get_xsp_ota_info(XSPL_addr,XSPL_len); if(check_route_xsp_ota()) { printf("xsp ota\n"); // device_fixed_info.Work_State = DEV_WORK_STATE_XSP_UPDATING; // ota_xsp_info.xsp_ota_begin = 1; xsp_ota_start(); // memset(&ota_xsp_info,0,sizeof(ota_xsp_info_t)); ota_xsp_init(); } } else { //清除显示屏升级标志 BKP_WriteBackupRegister_code(BKP_DR4,0); //显示屏升级次数存储 BKP_WriteBackupRegister_code(BKP_DR5,0); } return datalen; } //测试。下发开始离线升级命令 void lora_offline_update(uint32_t master_sn, uint32_t slave_sn, uint32_t des_sn) { collect_gateway_msg_format_t msg; gateway_coll_offline_upgrade_t *p_off = (gateway_coll_offline_upgrade_t *)msg.info; p_off->master_device_type = 0x0201; p_off->master_device_sn = master_sn; p_off->slave_device_type = 0x0201; p_off->slave_device_sn = slave_sn; p_off->des_device_type = 0x0201; p_off->des_device_sn = des_sn; p_off->reserve = 0; coll_msg_send(&msg, net_msg_type_update_offline, OTA_OFFLINE_LEN); // data_dump("offline",(uint8_t *)&msg,FRAME_HEADER_LEN+OTA_OFFLINE_LEN+2); }