例子
#ifndef __PROJ_CANBMS_H__
#define __PROJ_CANBMS_H__
#include <stdint.h>
#include "double_list.h"
#define BMS_CAN CANFD0 //CANFD1
#define BMS_DEVICE_MAX_BUM 100
#define CAN_RECV_BUFF_NUM 50
#define Device_Max_Num 300 //BMS最大设备数
//设置Location空闲超时时间
#define DEVICE_LOCATION_IDLE_TIMEOUT 50000 //设备定位空闲超时时间 *1ms
//设置Search空闲超时时间
#define DEVICE_SEARCH_IDLE_TIMEOUT 50000 //设备搜索空闲超时时间 *1ms
//Search升级设备搜索时间
#define DEVICE_UPGRADE_SEARCH_TIMEOUT 10000
//Location升级设备定位时间
#define DEVICE_UPGRADE_LOCATION_TIMEOUT 10000
//设置BMS-OTA超时时间
#define DEVICE_LOCATIONH_TIMEOUT 30000 //设备定位超时时间 *1ms
#define DEVICE_SEARCH_TIMEOUT 30000 //设备搜索超时时间 *1ms
#define DEVICE_REQUEST_TIMEOUT 30000 //设备下载申请超时时间 *1ms
#define DEVICE_ERASE_TIMEOUT 50000 //设备下载擦除超时时间 *1ms
#define DEVICE_WRITE_TIMEOUT 6000 //设备下载写入超时时间 *1ms
#define DEVICE_WRITE_END_TIMEOUT 2000 //设备下载写入完成超时时间 *1ms
//设备发送超时时间 < 与设备数有关 - 与缓冲区有关 - 与BMS设备超时时间有关 >
#define DEVICE_SEARCH_TIMEOUT_SEND 250//300 //设备搜索超时发送时间 *1ms
#define DEVICE_REQUEST_TIMEOUT_SEND 300 //设备下载申请超时发送时间 *1ms
#define DEVICE_ERASE_TIMEOUT_SEND 300 //设备下载擦除超时发送时间 *1ms
#define DEVICE_WRITE_END_TIMEOUT_SEND 300 //设备下载写入超时发送完成时间 *1ms
/* DeviceIndex
ALL 0XFF
BCU 1H
BSMU 2H
BAMU 3H
ITMU 4H
ITPU 5H
EMU 6H
PC FH
*/
//BMS设备信息
typedef struct{
int macAddr[4];
uint8_t arch_id[3]; //arch1_id arch2_id arch3_id
uint8_t routeLevel;
uint16_t tempID;
uint16_t setID;
uint32_t timeout;
//uint8_t info; //firmwareVersion + device_grade
uint8_t firmwareVersion;
uint8_t device_grade;
uint8_t device_type;
uint8_t isSelect;
uint8_t isReady;
uint8_t randomid; //随机码
}BMSDeviceInfo_t;
//Location Search Page
typedef struct{
uint8_t macAddr[4];
uint8_t arch_id[3];
}Location_Search_Pack_t;
//BMS设备链表
typedef struct{
BMSDeviceInfo_t BMSDeviceInfo_Member;
double_list_t list;
}BMSDeviceInfo_Member_List_t;
//BMS升级设备链表
typedef struct{
uint8_t arch_id[3];
uint8_t Select_Flag;
uint8_t ota_status;
double_list_t list;
}Device_Upgrade_List_t;
//BMS升级设备类型信息 -- 设备类型链表嵌套设备链表
typedef struct{
Device_Upgrade_List_t Device_Upgrade_List_Head;
uint8_t device_type;
uint8_t Select_Flag;
double_list_t list;
}Device_Type_List_t;
//定位包
typedef struct{
uint64_t Server_id;
uint8_t data_id[50];
uint8_t onoff;
uint8_t type;
uint8_t file_type;
uint16_t timeInterval; //主动上报发送间隔/ms 和 被动模式
}Location_Pack_t;
extern Location_Pack_t Location_Pack;
//搜索包
typedef struct{
uint64_t Server_id;
uint8_t data_id[50];
uint8_t onoff;
uint8_t type;
uint8_t info;
uint16_t layer_num; //MAX 100
int macAddr[100][4];
int arch_id[100][3]; //arch3_id arch2_id arch1_id
uint8_t file_type;
uint16_t timeInterval; //主动上报发送间隔/ms 和 被动模式
}Search_Pack_t;
extern Search_Pack_t Search_Pack;
//BMS升级包
typedef struct{
uint64_t Server_id;
uint8_t data_id[20];
uint8_t file_id[20];
uint8_t file_name[50];
uint32_t crc;
uint8_t type; //1:bin 2:s19
uint8_t file_path[50];
uint8_t version[10];
uint8_t deviceList[300][4];
uint32_t select_device_num;
}Updown_Pack_t;
extern Updown_Pack_t Updown_Pack;
//终端升级包
typedef struct{
uint64_t Server_id;
uint32_t crc;
uint8_t data_id[20];
uint8_t file_id[20];
uint8_t file_name[50];
uint8_t file_path[50];
uint8_t version[13];
}Ars_Updown_Pack_t;
extern Ars_Updown_Pack_t Ars_Updown_Pack;
//Boot流程
enum CANBootStep{
BOOT_IDLE = 0,
BOOT_DEVICE_LOCATION = 8,
BOOT_DEVICE_SEARCH = 1,
BOOT_BURNING_REQUEST = 2,
BOOT_MEM_ERASE = 3,
BOOT_MEM_WRITE = 4,
BOOT_MEM_WRITE_END = 5,
BOOT_MEM_READ = 6,
BOOT_APP_GO = 7,
};
//OTA流程
enum OtaStep{
OTA_IDLE = 0,
OTA_ARS = 1,
OTA_BMS = 2,
};
//BMS Position错误码
enum BMS_Position_Failed_Code{
POSITION_CAN_SEND_FAILED = 12900, //定位CAN发送失败
POSITION_JSON_PARSE_FAILED = 12901, //Position包json数据解析异常
POSITION_ARS_Upgrading_FAILED = 12902, //定位ARS正在升级，拒绝搜索
POSITION_BMS_Upgrading_FAILED = 12903, //定位BMS正在升级，拒绝搜索
};
//BMS Search错误码
enum BMS_Search_Failed_Code{
SEARCH_CAN_SEND_FAILED = 13000, //搜索CAN发送失败
SEARCH_JSON_PARSE_FAILED = 13001, //Search包json数据解析异常
SEARCH_ARS_Upgrading_FAILED = 13002, //搜索ARS正在升级，拒绝搜索
SEARCH_BMS_Upgrading_FAILED = 13003, //搜索BMS正在升级，拒绝搜索
};
//BMS OTA升级错误码
enum BMS_Ota_Step_Failed_Code{
BMS_ALL_TYPE_DEVICE_NOT_ALLOW_UPGRADE = 13211, //BMS全类型设备，不允许升级
BMS_UPGRAD_JSON_PARSE_FAILED = 13200, //BMS升级包json数据解析异常
BMS_DEVICE_HAPPEN_OFFLINE_FAILED = 13201, //BMS设备发生掉线，片选设备与在线设备不一致
BMS_REQUEST_SEND_FAILED = 13202, //BMS设备升级请求发送失败
BMS_REQUEST_TIMEOUT_FAILED = 13203, //BMS设备升级请求接收超时失败
BMS_MEM_ERASE_SEND_FAILED = 13204, //BMS设备升级擦除发送失败
BMS_MEM_ERASE_TIMEOUT_FAILED = 13205, //BMS设备升级擦除接收超时失败
BMS_MEM_WRITE_SEND_FAILED = 13206, //BMS设备升级数据传输发送失败
BMS_MEM_WRITE_TIMEOUT_FAILED = 13207, //BMS设备升级数据传输接收超时失败
BMS_DATA_CRC_FAILED = 13208, //BMS设备升级数据传输校验失败
BMS_FLASH_WRITE_READ_CRC_SEND_FAILED = 13209, //BMS设备升级数据存储校验发送失败
BMS_FLASH_WRITE_READ_CRC_TIMEOUT_FAILED = 13210, //BMS设备升级数据存储校验接收超时失败
BMS_DEVICE_POS_FAILED = 13212, //BMS设备列表位置错误
};
//ARS OTA升级错误码
enum ARS_Ota_Step_Failed_Code{
ARS_UPGRAD_JSON_PARSE_FAILED = 13400, //升级包json数据解析异常
ARS_VERSION_TOO_LOW_FAILED = 13401, //ARS设备升级版本太低升级失败
ARS_MEM_WRITE_FAILED = 13402, //ARS设备升级数据传输失败
ARS_DATA_CRC_FAILED = 13403, //ARS设备升级数据传输校验失败
ARS_FLASH_WRITE_READ_CRC_FAILED = 13404, //ARS设备升级数据存储校验失败
};
//FTP错误码
enum FTP_ERROR_CODE{
FTP_LOGIN_FAILED = 13600, //FTP登录失败
FTP_FILE_PATH_FAILED = 13601, //FTP文件路径失败
FTP_PASV_FAILED = 13602, //FTP被动模式失败
FTP_DATA_PORT_CONNECT_FAILED = 13603, //FTP服务器数据端口连接失败
FTP_FILE_SIZE_FAILED = 13604, //FTP文件大小格式失败
FTP_RETR_FAILED = 13605, //FTP指令下载失败
};
typedef struct{
uint32_t address;
uint16_t data_length;
uint8_t data[256];
}S19_Record;
//Ota队列数据
typedef struct{
/*
1:data
2:Crc_Data
*/
uint8_t type;
uint8_t data[8];
}Ota_Queue_Data_t;
/* Global variables */
extern BMSDeviceInfo_Member_List_t Device_list_Head;
extern BMSDeviceInfo_Member_List_t Device_Location_list_Head;
extern QueueHandle_t OTA_Data_QueueHandle;
extern QueueHandle_t Can_Recv_Data_QueueHandle;
extern SemaphoreHandle_t OTA_Topic_BinarySemHandle;
extern SemaphoreHandle_t OTA_Last_Data_BinarySemHandle;
extern SemaphoreHandle_t OTA_Crc_Data_BinarySemHandle;
extern SemaphoreHandle_t OTA_Data_Done_BinarySemHandle;
extern uint16_t DeviceIndex; //设备ID
extern volatile uint8_t CANBootStep; //升级流程
extern uint8_t CANBootStatus;
extern uint64_t Device_Upgrade_Search_Timeout_Num;
extern uint64_t Device_Upgrade_Location_Timeout_Num;
void Bms_Boot_Init(void);
void Bms_Upgrade_Send_Recv_Pro(void);
int8_t Boot_Device_Location(uint16_t deviceIndex);
int8_t Boot_Device_Search(uint16_t deviceIndex);
int8_t Boot_Device_Search_t(uint16_t deviceIndex);
int8_t Boot_Device_Request(void);
//int8_t Boot_Mem_Erase(void);
int8_t Boot_Mem_Erase(uint16_t deviceIndex);
int8_t Boot_Mem_Write_End(uint16_t deviceIndex);
int8_t Boot_Mem_Write_S19_Bin(uint16_t deviceIndex, uint8_t *au8Data, uint32_t data_len);
int8_t Parse_S19_Record(const char *line, S19_Record *record);
int8_t Parse_S19_AddressLen(char *line);
void CANBootStep_Set(uint8_t BootStep);
void Clean_Search_Device_List(void);
void Clean_Location_Device_List(void);
void Bms_Boot_List_Pro(void);
void Bms_Boot_Arr_Pro(void);
#endif
/**
* @Author: wangxy
* @Date: 2024-08-15
* @LastEditTime: 2024-08-15
* @LastEditors: wangxy
* @Description: proj_canbms
* @FilePath: proj_canbms.c
*/
#include "main.h"
#include "proj_canbms.h"
#include "proj_fifo.h"
#include "FTP_client.h"
#include "sal_netdb.h"
#include "net_sockets.h"
#include "mqttclient.h"
/* Global variables */
QueueHandle_t OTA_Data_QueueHandle;
QueueHandle_t Can_Recv_Data_QueueHandle;
SemaphoreHandle_t OTA_Topic_BinarySemHandle;
SemaphoreHandle_t OTA_Last_Data_BinarySemHandle;
SemaphoreHandle_t OTA_Crc_Data_BinarySemHandle;
SemaphoreHandle_t OTA_Data_Done_BinarySemHandle;
BMSDeviceInfo_Member_List_t Device_list_Head; //定义设备头节点
BMSDeviceInfo_Member_List_t Device_Location_list_Head; //定义设备定位头节点
Device_Type_List_t Device_Type_List_Head; //定义升级设备类型头节点 -- 设备类型链表再嵌套设备链表
double_list_t *ptr =NULL;
volatile uint8_t CANBootStep = BOOT_IDLE; //BOOT_DEVICE_SEARCH; //0;
fifo_t *Can_Recv_Buff;
uint16_t DeviceIndex = 0; //设备ID
uint8_t OTA_Data_Done_BinarySemHandle_Flag =0;
Search_Pack_t Search_Pack;
Location_Pack_t Location_Pack;
Updown_Pack_t Updown_Pack;
Ars_Updown_Pack_t Ars_Updown_Pack;
uint16_t BOOT_Send_Timeout_Num;
extern TaskHandle_t CAN_BMS_Upgrade_handle;
volatile uint8_t CAN_BMS_BOOT_Flag =0;
Location_Search_Pack_t Location_Search_Pack;
//Search升级设备搜索时间
uint64_t Device_Upgrade_Search_Timeout_Num =DEVICE_UPGRADE_SEARCH_TIMEOUT;
//Location升级设备定位时间
uint64_t Device_Upgrade_Location_Timeout_Num =DEVICE_UPGRADE_LOCATION_TIMEOUT;
/**
* @details: This function is Bms Boot Init
*/
void Bms_Boot_Init(void)
{
/* 初始化设备链表头 */
memset(&Device_list_Head,0,sizeof(Device_list_Head));
double_list_init(&Device_list_Head.list);
/* 初始化设备定位链表头 */
memset(&Device_Location_list_Head,0,sizeof(Device_Location_list_Head));
double_list_init(&Device_Location_list_Head.list);
/* 初始化设备类型链表头和升级设备链表头 */
memset(&Device_Type_List_Head,0,sizeof(Device_Type_List_Head));
double_list_init(&Device_Type_List_Head.list);
memset(&Device_Type_List_Head.Device_Upgrade_List_Head,0,sizeof(Device_Type_List_Head.Device_Upgrade_List_Head));
double_list_init(&Device_Type_List_Head.Device_Upgrade_List_Head.list);
/* 初始化CAN-Fifo缓冲区 */
Can_Recv_Buff =fifo_alloc(CAN_RECV_BUFF_NUM, sizeof(CANFD_FD_MSG_T));
if(Can_Recv_Buff==NULL){
RS_LOGE("Can_Recv_Buff fifo_alloc Failed\n");
}
/* 初始化CAN-Queue缓冲区 */
Can_Recv_Data_QueueHandle =xQueueCreate(CAN_RECV_BUFF_NUM, sizeof(CANFD_FD_MSG_T));
if(Can_Recv_Data_QueueHandle ==NULL){
RS_LOGE("Can_Recv_Data_QueueHandle xQueueCreate failed!");
}
/* 初始化OTA数据缓冲队列 */
OTA_Data_QueueHandle =xQueueCreate(1, sizeof(Ota_Queue_Data_t));
if(OTA_Data_QueueHandle ==NULL){
RS_LOGE("OTA_Data_QueueHandle xQueueCreate failed!");
}
/* CreateBinary OTA_Data_Done_BinarySemHandle */
OTA_Data_Done_BinarySemHandle =xSemaphoreCreateBinary();
//vSemaphoreCreateBinary(OTA_Data_Done_BinarySemHandle);
//OTA_Data_Done_BinarySemHandle = xSemaphoreCreateMutex();
if(OTA_Data_Done_BinarySemHandle ==NULL){
RS_LOGE("OTA_Data_Done_BinarySemHandle vSemaphoreCreateBinary failed!");
}
/* CreateBinary OTA_Crc_Data_BinarySemHandle */
OTA_Crc_Data_BinarySemHandle =xSemaphoreCreateBinary();
if(OTA_Crc_Data_BinarySemHandle ==NULL){
RS_LOGE("OTA_Crc_Data_BinarySemHandle vSemaphoreCreateBinary failed!");
}
/* CreateBinary OTA_Last_Data_BinarySemHandle */
OTA_Last_Data_BinarySemHandle =xSemaphoreCreateBinary();
if(OTA_Last_Data_BinarySemHandle ==NULL){
RS_LOGE("OTA_Last_Data_BinarySemHandle vSemaphoreCreateBinary failed!");
}
/* CreateBinary OTA_Topic_BinarySemHandle */
//OTA_Topic_BinarySemHandle =xSemaphoreCreateBinary();
vSemaphoreCreateBinary(OTA_Topic_BinarySemHandle);
if(OTA_Topic_BinarySemHandle ==NULL){
RS_LOGE("OTA_Topic_BinarySemHandle vSemaphoreCreateBinary failed!");
}
}
/**
* @details: This function is Bms Boot Deinit
*/
void Bms_Boot_Deinit(void)
{
//no use
}
/**链表形式
* @details: This function is Bms Boot List Pro
*/
void Bms_Boot_List_Pro(void)
{
int8_t device_type =-1;
/* 1.遍历设备类型 --> 选定设备类型 --> 开启路线定位 */
{
/* 1.逐一获取所有设备类型的节点 --> 获取当前类型的所有路线 */
if(double_list_isempty(&Device_Type_List_Head.list) ==0){
//登录FTP服务器
if(zFTP_Connect_Fun()<0){
RS_LOGW("zFTP_Connect_Fun Failed and Thread Exit");
vTaskDelete(NULL);
}
//逐一遍历设备类型
double_list_t *Device_Type_List_ptr =NULL;
double_list_for_each(Device_Type_List_ptr,&Device_Type_List_Head.list){
Device_Type_List_t *Device_Type_Member =double_list_entry(Device_Type_List_ptr, Device_Type_List_t, list);
device_type =Device_Type_Member->device_type;
//设置设备类型，开启BMS定位
DeviceIndex =device_type;
CANBootStep_Set(BOOT_DEVICE_LOCATION);
//等待设备路线索引完成，通过设备类型，定位所有路线
//... Wait delay() ...
uint16_t Loop_Timeout =1000;
do{
vTaskDelay(100);
//超时结束处理
if(!(Loop_Timeout--)){
RS_LOGW("Bms_Boot_List_Pro Location_Timeout Thread Exit");
CANBootStep_Set(BOOT_IDLE);
vTaskDelete(NULL);
}
}while(Device_Upgrade_Location_Timeout_Num !=0);
/* 2.逐一定位所有路线 --> 再搜索当前路线下的所有设备 */
{
//1.逐一选定路线索引所有设备
if(double_list_isempty(&Device_Location_list_Head.list) ==0){
double_list_t *Device_Location_list_Head_ptr =NULL;
//开始逐个遍历所有路线
double_list_for_each(Device_Location_list_Head_ptr,&Device_Location_list_Head.list){
//先通过遍历判断当前设备链表是否已全部升级成功且完成?
int8_t Device_Upgrade_Member_Flag= 0;
double_list_t *Device_Upgrade_List_Head_ptr =NULL;
double_list_for_each(Device_Upgrade_List_Head_ptr, &Device_Type_Member->Device_Upgrade_List_Head.list){
Device_Upgrade_List_t *Device_Upgrade_Member =double_list_entry(Device_Upgrade_List_Head_ptr, Device_Upgrade_List_t, list);
if(Device_Upgrade_Member->Select_Flag ==0){
//当前设备升级链表没有全部升级完成
Device_Upgrade_Member_Flag =1;
}
}
if(Device_Upgrade_Member_Flag){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(Device_Location_list_Head_ptr, BMSDeviceInfo_Member_List_t, list);
memset(&Location_Search_Pack, 0, sizeof(Location_Search_Pack));
Location_Search_Pack.macAddr[0] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0];
Location_Search_Pack.macAddr[1] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1];
Location_Search_Pack.macAddr[2] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2];
Location_Search_Pack.macAddr[3] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3];
Location_Search_Pack.arch_id[0] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[0];
Location_Search_Pack.arch_id[1] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[1];
Location_Search_Pack.arch_id[2] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[2];
//发送定位，开启BMS搜索
CANBootStep_Set(BOOT_DEVICE_SEARCH);
//等待当前路线下的设备搜索完成
//... Wait delay() ...
uint16_t Loop_Timeout =1000;
do{
vTaskDelay(100);
//超时结束处理
if(!(Loop_Timeout--)){
RS_LOGW("Bms_Boot_List_Pro Search_Timeout Thread Exit");
CANBootStep_Set(BOOT_IDLE);
vTaskDelete(NULL);
}
}while(Device_Upgrade_Search_Timeout_Num !=0);
/* 3.当前路线下设备与升级设备进行匹配和片选 */
uint8_t Route_Select_Flag =0;
double_list_t *Device_Upgrade_List_Head_ptr =NULL;
Device_Upgrade_List_t *Device_Upgrade_Member =NULL;
double_list_for_each(Device_Upgrade_List_Head_ptr, &Device_Type_Member->Device_Upgrade_List_Head.list){ //设备类型下--所有设备
Device_Upgrade_Member =double_list_entry(Device_Upgrade_List_Head_ptr, Device_Upgrade_List_t, list);
double_list_t *Device_list_Head_ptr =NULL;
double_list_for_each(Device_list_Head_ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(Device_list_Head_ptr, BMSDeviceInfo_Member_List_t, list);
//匹配片选
if(memcmp(Device_Upgrade_Member->arch_id, BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id, sizeof(BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id))==0){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect =1;
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_REQUEST_TIMEOUT;
Device_Upgrade_Member->Select_Flag =1;
Route_Select_Flag =1;
}
}
}
if(Route_Select_Flag){
#if 0
//匹配和片选成功，开始升级
int8_t download_rel =download_S19_Bin_file_fun(1);
//开始启动升级！
int8_t download_rel =download_S19_Bin_file_fun(&Bms_Ota_Info_Arr.bms_ota_info[i]);
//升级结束，成功则置位，片选标志清零。
double_list_for_each(Device_Upgrade_List_Head_ptr,&Device_Type_Member->Device_Upgrade_List_Head.list){
Device_Upgrade_Member =double_list_entry(Device_Upgrade_List_Head_ptr, Device_Upgrade_List_t, list);
if(Device_Upgrade_Member->Select_Flag ==1){
Device_Upgrade_Member->Select_Flag =0;
if(download_rel==0){
Device_Upgrade_Member->ota_status =1;
}
}
}
#endif
}
}
}
}
}
}
//关闭FTP服务器
zFTP_Close_Fun();
//全部升级完成，遍历是否全部升级成功
double_list_for_each(Device_Type_List_ptr,&Device_Type_List_Head.list){
Device_Type_List_t *Device_Type_Member =double_list_entry(Device_Type_List_ptr, Device_Type_List_t, list);
double_list_t *Device_Upgrade_List_Head_ptr =NULL;
double_list_for_each(Device_Upgrade_List_Head_ptr, &Device_Type_Member->Device_Upgrade_List_Head.list){
Device_Upgrade_List_t *Device_Upgrade_Member =double_list_entry(Device_Upgrade_List_Head_ptr, Device_Upgrade_List_t, list);
if(Device_Upgrade_Member->ota_status == 0){
//完全升级失败
/* deal result */
}
}
}
}else{
//链表为空，无升级需求！
}
}
vTaskDelete(NULL);
}
/**数组形式
* @details: This function is Bms Boot Arr Pro
*/
void Bms_Boot_Arr_Pro(void)
{
int8_t device_type =-1;
/* 1.遍历设备类型 --> 选定设备类型 --> 开启路线定位 */
{
/* 1.逐一获取所有设备类型的节点 --> 获取当前类型的所有路线 */
if(Bms_Ota_Info_Arr.bms_ota_info_num !=0){
#if 0
//登录FTP服务器
if(zFTP_Connect_Fun()<0){
RS_LOGW("zFTP_Connect_Fun Failed and Thread Exit");
zFTP_Close_Fun();
vTaskDelete(NULL);
}
#endif
/* 逐一遍历每个升级的设备类型 */
for(uint8_t i=0; i<Bms_Ota_Info_Arr.bms_ota_info_num; i++){
device_type =Bms_Ota_Info_Arr.bms_ota_info[i].device_type;
//设置设备类型，开启BMS定位
DeviceIndex =device_type;
CANBootStep_Set(BOOT_DEVICE_LOCATION);
//等待设备路线索引完成，通过设备类型，定位所有路线
//... Wait delay() ...
uint16_t Loop_Timeout =200;
do{
vTaskDelay(100);
//超时结束处理
if(!(Loop_Timeout--)){
RS_LOGW("Bms_Boot_Arr_Pro Location_Timeout Thread Exit");
CANBootStep_Set(BOOT_IDLE);
//zFTP_Close_Fun();
goto Bms_Boot_Arr_Pro_Exit;
}
}while(Device_Upgrade_Location_Timeout_Num !=0);
/* 2.逐一定位所有路线 --> 再搜索当前路线下的所有设备 */
{
//1.逐一选定路线索引所有设备
if(double_list_isempty(&Device_Location_list_Head.list) ==0){
double_list_t *Device_Location_list_Head_ptr =NULL;
#if 0
/***********打印出所有的链表节点***********/
double_list_t *Device_Location_list_Head_ptr_t =NULL;
double_list_for_each(Device_Location_list_Head_ptr_t,&Device_Location_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(Device_Location_list_Head_ptr_t, BMSDeviceInfo_Member_List_t, list);
RS_LOGI("macAddr[0]:%x macAddr[1]:%x macAddr[2]:%x macAddr[3]:%x\n\
arch_id[0]:%d arch_id[1]:%d arch_id[2]:%d \n",
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[0],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[1],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[2]);
}
#endif
//开始逐个遍历所有路线
double_list_for_each(Device_Location_list_Head_ptr,&Device_Location_list_Head.list){
//先通过遍历判断当前设备链表是否已全部升级成功且完成?
int8_t Device_Upgrade_Member_Flag =0;
for(uint8_t m=0; m<Bms_Ota_Info_Arr.bms_ota_info[i].positions_device_num; m++){
if(Bms_Ota_Info_Arr.bms_ota_info[i].devces_positions_info[m].Select_Flag==0){
//当前设备升级链表没有全部升级完成
Device_Upgrade_Member_Flag =1;
}
}
if(Device_Upgrade_Member_Flag){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(Device_Location_list_Head_ptr, BMSDeviceInfo_Member_List_t, list);
memset(&Location_Search_Pack, 0, sizeof(Location_Search_Pack));
Location_Search_Pack.macAddr[0] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0];
Location_Search_Pack.macAddr[1] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1];
Location_Search_Pack.macAddr[2] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2];
Location_Search_Pack.macAddr[3] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3];
//层级编号
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.routeLevel ==3){
Location_Search_Pack.arch_id[0] =0xFF;
}else{
Location_Search_Pack.arch_id[0] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[0];
}
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.routeLevel ==2){
Location_Search_Pack.arch_id[1] =0xFF;
}else{
Location_Search_Pack.arch_id[1] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[1];
}
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.routeLevel ==1){
Location_Search_Pack.arch_id[2] =0xFF;
}else{
Location_Search_Pack.arch_id[2] =BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[2];
}
//发送定位，开启BMS搜索
CANBootStep_Set(BOOT_DEVICE_SEARCH);
//等待当前路线下的设备搜索完成
//... Wait delay() ...
uint16_t Loop_Timeout =200;
do{
vTaskDelay(100);
//超时结束处理
if(!(Loop_Timeout--)){
RS_LOGW("Bms_Boot_Arr_Pro Search_Timeout Thread Exit");
CANBootStep_Set(BOOT_IDLE);
//zFTP_Close_Fun();
goto Bms_Boot_Arr_Pro_Exit;
}
}while(Device_Upgrade_Search_Timeout_Num !=0);
/* 3.当前路线下设备与升级设备进行匹配和片选 */
uint8_t Route_Select_Flag =0;
for(uint8_t m=0; m<Bms_Ota_Info_Arr.bms_ota_info[i].positions_device_num; m++){
double_list_t *Device_list_Head_ptr =NULL;
double_list_for_each(Device_list_Head_ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(Device_list_Head_ptr, BMSDeviceInfo_Member_List_t, list);
if(memcmp(Bms_Ota_Info_Arr.bms_ota_info[i].devces_positions_info[m].arch_id, BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id, sizeof(BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id))==0){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect =1;
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_REQUEST_TIMEOUT;
Bms_Ota_Info_Arr.bms_ota_info[i].devces_positions_info[m].Select_Flag=1;
Route_Select_Flag =1;
}
}
}
if(Route_Select_Flag){
//开始连接服务器，启动升级！
if(zFTP_Connect_Fun()<0){
RS_LOGW("zFTP_Connect_Fun Failed and Thread Exit");
zFTP_Close_Fun();
goto Bms_Boot_Arr_Pro_Exit;
}
//下载升级设备固件
int8_t download_rel =download_S19_Bin_file_fun(&Bms_Ota_Info_Arr.bms_ota_info[i]);
if(download_rel<0){
RS_LOGW("download_S19_Bin_file_fun Failed and Thread Exit");
zFTP_Close_Fun();
goto Bms_Boot_Arr_Pro_Exit;
}
//清除匹配片选标志和置位升级标志
for(uint8_t n=0; n<Bms_Ota_Info_Arr.bms_ota_info[i].positions_device_num; n++){
if(Bms_Ota_Info_Arr.bms_ota_info[i].devces_positions_info[n].Select_Flag ==1){
Bms_Ota_Info_Arr.bms_ota_info[i].devces_positions_info[n].Select_Flag =0;
Bms_Ota_Info_Arr.bms_ota_info[i].devces_positions_info[n].ota_status =1;
}
}
//关闭Ftp客户端
zFTP_Close_Fun();
}
}
}
}
}
}
#if 0
//关闭FTP客户端
zFTP_Close_Fun();
#endif
//检测是否设备全部升级成功
uint8_t ALL_Type_Device_Success_Flag =1;
for(uint8_t p=0; p<Bms_Ota_Info_Arr.bms_ota_info_num; p++){
for(uint8_t q=0; q<Bms_Ota_Info_Arr.bms_ota_info[p].positions_device_num; q++){
if(Bms_Ota_Info_Arr.bms_ota_info[p].devces_positions_info[q].ota_status == 0){
//所有设备完全升级失败
ALL_Type_Device_Success_Flag =0;
}
}
}
Bms_Ota_Info_Arr.bms_ota_info_num =0;
if(ALL_Type_Device_Success_Flag){
//上报服务器成功
BMS_Upgrade_Result_Report(1,0);
RS_LOGV("BMS OTA ALL Transmit Success!\n");
}else{
//失败
BMS_Upgrade_Result_Report(0,BMS_DEVICE_POS_FAILED);
RS_LOGV("BMS OTA ALL Transmit Failed : DEVICE_POS ERROR!\n");
}
}else{
//链表为空，无升级需求！
RS_LOGI("List NO Device Need Upgrade!\n");
}
}
Bms_Boot_Arr_Pro_Exit:
//关闭 Bms_Upgrade_Send_Recv_Pro 线程
if(CAN_BMS_BOOT_Flag){
CAN_BMS_BOOT_Flag =0;
vTaskDelete(CAN_BMS_Upgrade_handle);
}
//清空链表上所有的搜索设备
Clean_Search_Device_List();
//清空链表上所有的定位设备
Clean_Location_Device_List();
RS_LOGI("Bms_Boot_Arr_Pro Thread Exit");
//释放升级信号量
if(xSemaphoreGive(OTA_Topic_BinarySemHandle) != pdTRUE){
RS_LOGW("xSemaphoreGive OTA_Topic_BinarySemHandle Full\n");
}
CANBootStep_Set(BOOT_IDLE);
vTaskDelete(NULL);
}
/**
* @details: This function is Bms Send Recv Pro
*/
void Bms_Upgrade_Send_Recv_Pro(void)
{
RS_LOGV("Bms_Upgrade_Send_Recv_Pro Begin Run...");
for(;;){
/* Upgrade Recv Deal Data */
CANFD_FD_MSG_T RxMsgFrame;
memset(&RxMsgFrame, 0, sizeof(RxMsgFrame));
//if(fifo_unuse(Can_Recv_Buff)){
//if(fifo_get(Can_Recv_Buff, &RxMsgFrame, sizeof(RxMsgFrame)) >0){
if(xQueueReceive(Can_Recv_Data_QueueHandle, &RxMsgFrame, 0) == pdTRUE){
switch(CANBootStep){
case BOOT_DEVICE_LOCATION: //定位
{
if((RxMsgFrame.u32Id & 0xFFFFFF00) != 0x1F010000 + (DeviceIndex << 8))
break;
//重置设备搜索发送
//BOOT_Send_Timeout_Num =0;
uint8_t New_Device_Flag =1; //遍历新设备标志
uint16_t Device_Curr_Num =0; //当前在线设备数
//遍历当前设备链表
if(double_list_isempty(&Device_Location_list_Head.list) ==0){
double_list_for_each(ptr,&Device_Location_list_Head.list){
Device_Curr_Num++;
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
uint8_t macAddr_temp[4] ={0};
macAddr_temp[0] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0];
macAddr_temp[1] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1];
macAddr_temp[2] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2];
macAddr_temp[3] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3];
if(memcmp(&RxMsgFrame.au8Data[4],macAddr_temp,4)==0){
//当前设备已经存在设备链表
BMSDeviceInfo_Member->BMSDeviceInfo_Member.firmwareVersion =((RxMsgFrame.au8Data[0]>>4)&0x0f); //更新固件版本号
BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade =(RxMsgFrame.au8Data[0]&0x0f); //更新设备层级
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[0] =RxMsgFrame.au8Data[1]; //更新设备Arch3 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[1] =RxMsgFrame.au8Data[2]; //更新设备Arch2 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[2] =RxMsgFrame.au8Data[3]; //更新设备Arch1 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type =(((uint8_t)(RxMsgFrame.u32Id>>8))&0xff); //更新设备类型
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout = DEVICE_SEARCH_TIMEOUT; //更新重置超时时间
BMSDeviceInfo_Member->BMSDeviceInfo_Member.routeLevel = RxMsgFrame.au8Data[0] & 0x0f; //更新架构层级
New_Device_Flag =0;
}
}
}
//扫描新设备,且小于设备总数
if(New_Device_Flag && (Device_Curr_Num < Device_Max_Num)){
//从新设置升级定位时间
Device_Upgrade_Location_Timeout_Num =DEVICE_UPGRADE_LOCATION_TIMEOUT;
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member = pvPortMalloc(sizeof(BMSDeviceInfo_Member_List_t));
memset(BMSDeviceInfo_Member, 0, sizeof(*BMSDeviceInfo_Member));
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0] = RxMsgFrame.au8Data[4];
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1] = RxMsgFrame.au8Data[5];
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2] = RxMsgFrame.au8Data[6];
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3] = RxMsgFrame.au8Data[7];
BMSDeviceInfo_Member->BMSDeviceInfo_Member.firmwareVersion =((RxMsgFrame.au8Data[0]>>4)&0x0f); //获取固件版本号
BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade =(RxMsgFrame.au8Data[0]&0x0f); //获取设备层级
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[0] =RxMsgFrame.au8Data[1]; //获取设备Arch3 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[1] =RxMsgFrame.au8Data[2]; //获取设备Arch2 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[2] =RxMsgFrame.au8Data[3]; //获取设备Arch1 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type =(((uint8_t)(RxMsgFrame.u32Id>>8))&0xff); //获取设备类型
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout = DEVICE_LOCATIONH_TIMEOUT; //设置超时时间
BMSDeviceInfo_Member->BMSDeviceInfo_Member.routeLevel = (RxMsgFrame.au8Data[0]&0x0f); //获取架构层级
double_list_insert_after(&Device_Location_list_Head.list,&BMSDeviceInfo_Member->list); //添加到设备定位链表
#if 1 //for debug test
RS_LOGI("Location Add a new device MacAddr: %02x-%02x-%02x-%02x\n",
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3]
);
#endif
}
break;
}
case BOOT_DEVICE_SEARCH: //搜索 0x1F01YYFF
{
if((RxMsgFrame.u32Id & 0xFFFFFF00) != 0x1F020000 + (DeviceIndex << 8))
break;
//重置设备搜索发送
//BOOT_Send_Timeout_Num =0;
uint8_t New_Device_Flag =1; //遍历新设备标志
uint16_t Device_Curr_Num =0; //当前在线设备数
//遍历当前设备链表
if(double_list_isempty(&Device_list_Head.list) ==0){
double_list_for_each(ptr,&Device_list_Head.list){
Device_Curr_Num++;
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
uint8_t macAddr_temp[4] ={0};
macAddr_temp[0] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0];
macAddr_temp[1] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1];
macAddr_temp[2] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2];
macAddr_temp[3] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3];
//if(memcmp(&RxMsgFrame.au8Data[2],BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr,6)==0){
//if(memcmp(&RxMsgFrame.au8Data[4],macAddr_temp,4)==0){
if( (memcmp(&RxMsgFrame.au8Data[4],macAddr_temp,4)==0) && (BMSDeviceInfo_Member->BMSDeviceInfo_Member.randomid == (((uint8_t)(RxMsgFrame.u32Id))&0xff))){
//当前设备已经存在设备链表
BMSDeviceInfo_Member->BMSDeviceInfo_Member.firmwareVersion =((RxMsgFrame.au8Data[0]>>4)&0x0f); //更新固件版本号
BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade =(RxMsgFrame.au8Data[0]&0x0f); //更新设备层级
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[0] =RxMsgFrame.au8Data[1]; //更新设备Arch3 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[1] =RxMsgFrame.au8Data[2]; //更新设备Arch2 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[2] =RxMsgFrame.au8Data[3]; //更新设备Arch1 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type =(((uint8_t)(RxMsgFrame.u32Id>>8))&0xff); //更新设备类型
BMSDeviceInfo_Member->BMSDeviceInfo_Member.randomid =(((uint8_t)(RxMsgFrame.u32Id))&0xff); //更新随机码
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout = DEVICE_SEARCH_TIMEOUT; //更新重置超时时间
//预设ID
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade ==1){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID = RxMsgFrame.au8Data[3];
}else if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade ==2){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID = RxMsgFrame.au8Data[2];
}else if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade ==3){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID = RxMsgFrame.au8Data[1];
}
New_Device_Flag =0; //已存设备
}
}
}
//扫描新设备,且小于设备总数
if(New_Device_Flag && (Device_Curr_Num < Device_Max_Num)){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member = pvPortMalloc(sizeof(BMSDeviceInfo_Member_List_t));
if(BMSDeviceInfo_Member !=NULL){
//从新设置升级搜索时间
Device_Upgrade_Search_Timeout_Num =DEVICE_UPGRADE_SEARCH_TIMEOUT;
//memcpy(BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr,&RxMsgFrame.au8Data[2],6); //获取MAC地址
memset(BMSDeviceInfo_Member, 0, sizeof(*BMSDeviceInfo_Member));
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0] = RxMsgFrame.au8Data[4];
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1] = RxMsgFrame.au8Data[5];
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2] = RxMsgFrame.au8Data[6];
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3] = RxMsgFrame.au8Data[7];
BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type =(((uint8_t)(RxMsgFrame.u32Id>>8))&0xff); //获取设备类型
BMSDeviceInfo_Member->BMSDeviceInfo_Member.randomid =(((uint8_t)(RxMsgFrame.u32Id))&0xff); //获取随机码
BMSDeviceInfo_Member->BMSDeviceInfo_Member.firmwareVersion =((RxMsgFrame.au8Data[0]>>4)&0x0f); //获取固件版本号
BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade =(RxMsgFrame.au8Data[0]&0x0f); //获取设备层级
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[0] =RxMsgFrame.au8Data[1]; //获取设备Arch3 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[1] =RxMsgFrame.au8Data[2]; //获取设备Arch2 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.arch_id[2] =RxMsgFrame.au8Data[3]; //获取设备Arch1 ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout = DEVICE_SEARCH_TIMEOUT; //设置超时时间
double_list_insert_after(&Device_list_Head.list,&BMSDeviceInfo_Member->list); //添加到设备链表
//预设ID
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade ==1){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID = RxMsgFrame.au8Data[3];
}else if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade ==2){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID = RxMsgFrame.au8Data[2];
}else if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_grade ==3){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID = RxMsgFrame.au8Data[1];
}
#if 1 //for debug test
RS_LOGI("Search Add a new device MacAddr: %02x-%02x-%02x-%02x\n",
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3]
);
#endif
//Report_Search_Device_Info();
}else{
RS_LOGW("BOOT_DEVICE_SEARCH new device pvPortMalloc failed!");
}
}
//unsigned int num_list =double_list_len(&Device_list_Head.list);
//printf("Device_list num :%d\n",num_list);
break;
}
case BOOT_BURNING_REQUEST: //请求
{
//if(RxMsgFrame.u32Id != 0x1F0300FF + (DeviceIndex << 8))
if((RxMsgFrame.u32Id & 0xFFFFFF00) != 0x1F030000 + (DeviceIndex << 8))
break;
//重置设备申请发送
//BOOT_Send_Timeout_Num =0;
if(double_list_isempty(&Device_list_Head.list) ==0){
uint8_t All_Ready =1;
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
uint8_t macAddr_temp[4] ={0};
macAddr_temp[0] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0];
macAddr_temp[1] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1];
macAddr_temp[2] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2];
macAddr_temp[3] =(uint8_t)BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3];
//if(memcmp(&RxMsgFrame.au8Data[2],BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr,6)==0 && RxMsgFrame.au8Data[0]== BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID){
if(memcmp(&RxMsgFrame.au8Data[4],macAddr_temp,4)==0 && RxMsgFrame.au8Data[0]== BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady =1;
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_REQUEST_TIMEOUT; //设置更新超时时间
}
//BMS DEVICES ALL Ready？
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect){
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady ==0){
All_Ready =0;
}
}
}
if(All_Ready){
CANBootStep_Set(BOOT_MEM_ERASE);
}
}
break;
}
case BOOT_MEM_ERASE: //擦除
{
if((RxMsgFrame.u32Id & 0xFFFFFF00) != 0x1F040000 + (DeviceIndex << 8))
break;
//重置设备擦除发送
//BOOT_Send_Timeout_Num =0;
if(double_list_isempty(&Device_list_Head.list) ==0){
uint8_t All_Ready =1;
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
if((uint8_t)RxMsgFrame.u32Id == BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID && RxMsgFrame.au8Data[0]==2){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady =1;
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_ERASE_TIMEOUT; //设置更新超时时间
}
//BMS DEVICES ALL Ready？
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect){
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady ==0){
All_Ready =0;
}
}
}
if(All_Ready){
CANBootStep_Set(BOOT_MEM_WRITE);
RS_LOGV("Flash Erase Finish, and begin download bms firmware...\n");
//发送成功指令，接收到所有片选设备应答ACK，开始升级下一帧数据
if(xSemaphoreGive(OTA_Data_Done_BinarySemHandle) != pdTRUE){
RS_LOGE("xSemaphoreGive OTA_Data_Done_BinarySemHandle Error\n");
}
}
}
break;
}
case BOOT_MEM_WRITE: //写入
{
if((RxMsgFrame.u32Id & 0xFFFFFF00) != 0x1F050000 + (DeviceIndex << 8))
break;
if(double_list_isempty(&Device_list_Head.list) ==0){
uint8_t All_Ready =1;
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
if(((uint8_t)RxMsgFrame.u32Id == BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID) && RxMsgFrame.au8Data[0]==1){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady =1;
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_WRITE_TIMEOUT; //设置更新超时时间
}
//BMS DEVICES ALL Ready？
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect){
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady ==0){
All_Ready =0;
}
}
}
if(All_Ready){
if(xSemaphoreTake(OTA_Crc_Data_BinarySemHandle, 0)==pdPASS){
CANBootStep_Set(BOOT_MEM_WRITE_END);
break;
}
//再次清除链表所有节点isReady标志
if(double_list_isempty(&Device_list_Head.list) ==0){
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady =0;
}
}
//发送成功指令，接收到所有片选设备应答ACK，开始升级下一帧数据
if(xSemaphoreGive(OTA_Data_Done_BinarySemHandle) != pdTRUE){
RS_LOGE("xSemaphoreGive OTA_Data_Done_BinarySemHandle Error\n");
}
}
}
break;
}
case BOOT_MEM_WRITE_END: //写完
{
if((RxMsgFrame.u32Id & 0xFFFFFF00) != 0x1F060000 + (DeviceIndex << 8))
break;
//重置设备写结束发送
//BOOT_Send_Timeout_Num =0;
if(double_list_isempty(&Device_list_Head.list) ==0){
uint8_t All_Ready =1;
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
if((uint8_t)RxMsgFrame.u32Id == BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID && RxMsgFrame.au8Data[0]==0){
//if((uint8_t)RxMsgFrame.u32Id == BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID){
if(RxMsgFrame.au8Data[0]==0){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady =1;
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_WRITE_END_TIMEOUT; //设置更新超时时间
}else if(RxMsgFrame.au8Data[0]==1){
//BMS Flash FAILED
BMS_Upgrade_Result_Report(0, BMS_FLASH_WRITE_READ_CRC_TIMEOUT_FAILED);
CANBootStep_Set(BOOT_IDLE);
break;
}
}
//BMS DEVICES ALL Ready？
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect){
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady ==0){
All_Ready =0;
}
}
}
//升级成功，进入空闲模式
if(All_Ready){
//释放信号量，本次升级成功
if(xSemaphoreGive(OTA_Last_Data_BinarySemHandle) != pdTRUE){
RS_LOGE("xSemaphoreGive OTA_Last_Data_BinarySemHandle Error\n");
}
//上报服务器成功
//BMS_Upgrade_Result_Report(1,0);
//RS_LOGV("BMS OTA Transmit Success!\n");
//CANBootStep_Set(BOOT_IDLE);
}
}
break;
}
default: break;
}
}
//}
/* Boot Send Can Data */
switch(CANBootStep){
case BOOT_IDLE:
{
break;
}
case BOOT_DEVICE_LOCATION:
{
//设置Location空闲超时时间
if(Device_Upgrade_Location_Timeout_Num !=0){
Device_Upgrade_Location_Timeout_Num--;
}
//检测超时发送Location
if(BOOT_Send_Timeout_Num++ > DEVICE_SEARCH_TIMEOUT_SEND){
BOOT_Send_Timeout_Num =0;
if(Boot_Device_Location(DeviceIndex) != RS_OK){
//定位发送失败，进入idle, 结束升级
CANBootStep_Set(BOOT_IDLE);
RS_LOGE("Boot Device Location Send Failed\n");
}
}
break;
}
case BOOT_DEVICE_SEARCH:
{
//设置Search空闲超时时间
if(Device_Upgrade_Search_Timeout_Num !=0){
Device_Upgrade_Search_Timeout_Num--;
}
//检测超时发送Search
if(BOOT_Send_Timeout_Num++ > DEVICE_SEARCH_TIMEOUT_SEND){
BOOT_Send_Timeout_Num =0;
//if(Boot_Device_Search(DeviceIndex) != RS_OK){
if(Boot_Device_Search_t(DeviceIndex) != RS_OK){
//搜索发送失败，进入idle, 结束升级
CANBootStep_Set(BOOT_IDLE);
RS_LOGE("Boot Device Search Send Failed\n");
}
}
break;
}
case BOOT_BURNING_REQUEST:
{
if(BOOT_Send_Timeout_Num++ > DEVICE_REQUEST_TIMEOUT_SEND){
BOOT_Send_Timeout_Num =0;
if(Boot_Device_Request() != RS_OK){
//申请发送失败，进入idle, 结束升级
BMS_Upgrade_Result_Report(0, BMS_REQUEST_SEND_FAILED);
CANBootStep_Set(BOOT_IDLE);
RS_LOGE("Boot Device Request Send Failed\n");
}
}
break;
}
case BOOT_MEM_ERASE:
{
if(BOOT_Send_Timeout_Num++ > DEVICE_ERASE_TIMEOUT_SEND){
BOOT_Send_Timeout_Num =0;
if(Boot_Mem_Erase(DeviceIndex) != RS_OK){
//擦除发送失败，进入idle, 结束升级
BMS_Upgrade_Result_Report(0, BMS_MEM_ERASE_SEND_FAILED);
CANBootStep_Set(BOOT_IDLE);
RS_LOGE("Boot Device Erase Send Failed\n");
}
}
break;
}
case BOOT_MEM_WRITE:
{
break;
}
case BOOT_MEM_WRITE_END:
{
if(BOOT_Send_Timeout_Num++ > DEVICE_WRITE_END_TIMEOUT_SEND){
if(Boot_Mem_Write_End(DeviceIndex) != RS_OK){
//写完成发送失败，进入idle, 结束升级
BMS_Upgrade_Result_Report(0, BMS_FLASH_WRITE_READ_CRC_SEND_FAILED);
CANBootStep_Set(BOOT_IDLE);
RS_LOGE("Boot Device Write End Send Failed\n");
}
}
break;
}
default: break;
}
/* 设备超时处理 */
if(CANBootStep == BOOT_DEVICE_LOCATION){ //BOOT_DEVICE_LOCATION TIMEOUT DEAL
if(double_list_isempty(&Device_Location_list_Head.list) ==0){
double_list_for_each(ptr,&Device_Location_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
////////////////////////////////////////////////////////////////////
#if 0 //for debug test
RS_LOGI("------------------------------------------------------------------------------>");
RS_LOGI("BMSDeviceInfo_Member.macAddr: %x-%x-%x-%x-%x-%x\n",
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[4],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[5]
);
RS_LOGI("BMSDeviceInfo_Member.firmwareVersion: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.firmwareVersion);
RS_LOGI("BMSDeviceInfo_Member.routeLevel: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.routeLevel);
RS_LOGI("BMSDeviceInfo_Member.tempID: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID);
RS_LOGI("BMSDeviceInfo_Member.setID: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID);
RS_LOGI("BMSDeviceInfo_Member.timeout: %d\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout);
RS_LOGI("BMSDeviceInfo_Member.device_type: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type);
RS_LOGI("BMSDeviceInfo_Member.isSelect: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect);
RS_LOGI("BMSDeviceInfo_Member.isReady: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady);
#endif
////////////////////////////////////////////////////////////////////
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout--;//时间步长
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout==0){
//移除设备链表
#if 1 //for debug test
RS_LOGI("Location Device Timeout Remove a device MacAddr: %02x-%02x-%02x-%02x\n",
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3]
);
#endif
double_list_remove(ptr);
vPortFree(BMSDeviceInfo_Member);
}
}
}
}else if(CANBootStep == BOOT_DEVICE_SEARCH){ //SEARCH TIMEOUT DEAL
if(double_list_isempty(&Device_list_Head.list) ==0){
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
////////////////////////////////////////////////////////////////////
#if 0 //for debug test
RS_LOGI("------------------------------------------------------------------------------>");
RS_LOGI("BMSDeviceInfo_Member.macAddr: %x-%x-%x-%x-%x-%x\n",
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[4],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[5]
);
RS_LOGI("BMSDeviceInfo_Member.firmwareVersion: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.firmwareVersion);
RS_LOGI("BMSDeviceInfo_Member.routeLevel: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.routeLevel);
RS_LOGI("BMSDeviceInfo_Member.tempID: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID);
RS_LOGI("BMSDeviceInfo_Member.setID: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID);
RS_LOGI("BMSDeviceInfo_Member.timeout: %d\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout);
RS_LOGI("BMSDeviceInfo_Member.device_type: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type);
RS_LOGI("BMSDeviceInfo_Member.isSelect: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect);
RS_LOGI("BMSDeviceInfo_Member.isReady: %x\n",BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady);
#endif
////////////////////////////////////////////////////////////////////
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout--; //时间步长
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout==0){
//移除设备链表
#if 1 //for debug test
RS_LOGI("Search Device Timeout Remove a device MacAddr: %02x-%02x-%02x-%02x\n",
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2],
BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3]
);
#endif
double_list_remove(ptr);
vPortFree(BMSDeviceInfo_Member);
//Report_Search_Device_Info();
}
}
}
}else if((CANBootStep == BOOT_BURNING_REQUEST) || (CANBootStep == BOOT_MEM_ERASE) || (CANBootStep == BOOT_MEM_WRITE) || (CANBootStep == BOOT_MEM_WRITE_END)){ //TIMEOUT DEAL
if(double_list_isempty(&Device_list_Head.list) ==0){
uint8_t Request_Timeout =0;
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect){
BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout--; //时间步长
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout==0){
//设备超时标志
Request_Timeout =1;
}
}
}
//但凡一台设备超时，移除链表所有设备，本次升级失败，进入IDLE
if(Request_Timeout){
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
double_list_remove(ptr);
vPortFree(BMSDeviceInfo_Member);
}
//上报服务器任务失败
switch(CANBootStep){
case BOOT_BURNING_REQUEST:
{
BMS_Upgrade_Result_Report(0, BMS_REQUEST_TIMEOUT_FAILED);
RS_LOGV("BMS OTA REQUEST Timeout!\n");
break;
}
case BOOT_MEM_ERASE:
{
BMS_Upgrade_Result_Report(0, BMS_MEM_ERASE_TIMEOUT_FAILED);
RS_LOGV("BMS OTA ERASE Timeout!\n");
break;
}
case BOOT_MEM_WRITE:
{
BMS_Upgrade_Result_Report(0, BMS_MEM_WRITE_TIMEOUT_FAILED);
RS_LOGV("BMS OTA WRITE Timeout!\n");
break;
}
case BOOT_MEM_WRITE_END:
{
BMS_Upgrade_Result_Report(0, BMS_FLASH_WRITE_READ_CRC_TIMEOUT_FAILED);
RS_LOGV("BMS OTA WRITE END Timeout!\n");
break;
}
default:break;
}
RS_LOGV("BMS OTA Transmit Failed!\n");
//判断是否为BOOT_MEM_WRITE，结束升级线程
if(CANBootStep == BOOT_BURNING_REQUEST || CANBootStep == BOOT_MEM_WRITE || CANBootStep == BOOT_MEM_WRITE_END){
//重置OTA的数据消息队列
xQueueReset(OTA_Data_QueueHandle);
}
//超时失败，本次升级失败，进入空闲模式
CANBootStep_Set(BOOT_IDLE);
}
}
}
//vTaskDelay(300);
//vTaskDelay(5);
//vTaskDelay(2);
vTaskDelay(1);
}
}
/**
* @details: This function is Boot Location Devices
*/
int8_t Boot_Device_Location(uint16_t deviceIndex)
{
CANFD_FD_MSG_T TxMsgFrame;
memset(&TxMsgFrame, 0, sizeof(TxMsgFrame));
/* Set the ID Number */
TxMsgFrame.u32Id = 0x0F0100FF + (deviceIndex << 8);
/* Set the frame type */
TxMsgFrame.eIdType = eCANFD_XID;
/* CAN FD frame type */
TxMsgFrame.eFrmType = eCANFD_DATA_FRM;
/* Set FD frame format attribute */
TxMsgFrame.bFDFormat = 1;
/* Set the bitrate switch attribute */
TxMsgFrame.bBitRateSwitch = 1;
/*Set data length*/
TxMsgFrame.u32DLC = 0;
if(CANFD_TransmitDMsg(BMS_CAN, 0, &TxMsgFrame) != 1){
return RS_ERROR;
}
//xSemaphoreTake(CAN0_Transfer_Done_BinarySemHandle, portMAX_DELAY);
return RS_OK;
}
/**
* @details: This function is Boot Search Devices
*/
int8_t Boot_Device_Search(uint16_t deviceIndex)
{
for(int i=0;i<Search_Pack.layer_num; i++){
CANFD_FD_MSG_T TxMsgFrame;
memset(&TxMsgFrame, 0, sizeof(TxMsgFrame));
/* Set the ID Number */
TxMsgFrame.u32Id = 0x0F0200FF + (deviceIndex << 8);
/* Set the frame type */
TxMsgFrame.eIdType = eCANFD_XID;
/* CAN FD frame type */
TxMsgFrame.eFrmType = eCANFD_DATA_FRM;
/* Set FD frame format attribute */
TxMsgFrame.bFDFormat = 1;
/* Set the bitrate switch attribute */
TxMsgFrame.bBitRateSwitch = 1;
/*Set data length*/
TxMsgFrame.u32DLC = 8;
/*Set data */
//arch_id
TxMsgFrame.au8Data[1] = (uint8_t)Search_Pack.arch_id[i][0];
TxMsgFrame.au8Data[2] = (uint8_t)Search_Pack.arch_id[i][1];
TxMsgFrame.au8Data[3] = (uint8_t)Search_Pack.arch_id[i][2];
//mac
TxMsgFrame.au8Data[4] = (uint8_t)Search_Pack.macAddr[i][0];
TxMsgFrame.au8Data[5] = (uint8_t)Search_Pack.macAddr[i][1];
TxMsgFrame.au8Data[6] = (uint8_t)Search_Pack.macAddr[i][2];
TxMsgFrame.au8Data[7] = (uint8_t)Search_Pack.macAddr[i][3];
if(CANFD_TransmitDMsg(BMS_CAN, 0, &TxMsgFrame) != 1){
return RS_ERROR;
}
//xSemaphoreTake(CAN0_Transfer_Done_BinarySemHandle, portMAX_DELAY);
//delay_ms(50);
}
return RS_OK;
}
/**
* @details: This function is Boot_Device_Search_t
*/
int8_t Boot_Device_Search_t(uint16_t deviceIndex)
{
CANFD_FD_MSG_T TxMsgFrame;
memset(&TxMsgFrame, 0, sizeof(TxMsgFrame));
/* Set the ID Number */
TxMsgFrame.u32Id = 0x0F0200FF + (deviceIndex << 8);
/* Set the frame type */
TxMsgFrame.eIdType = eCANFD_XID;
/* CAN FD frame type */
TxMsgFrame.eFrmType = eCANFD_DATA_FRM;
/* Set FD frame format attribute */
TxMsgFrame.bFDFormat = 1;
/* Set the bitrate switch attribute */
TxMsgFrame.bBitRateSwitch = 1;
/*Set data length*/
TxMsgFrame.u32DLC = 8;
/*Set data */
//arch_id
TxMsgFrame.au8Data[1] = (uint8_t)Location_Search_Pack.arch_id[0];
TxMsgFrame.au8Data[2] = (uint8_t)Location_Search_Pack.arch_id[1];
TxMsgFrame.au8Data[3] = (uint8_t)Location_Search_Pack.arch_id[2];
//mac
TxMsgFrame.au8Data[4] = (uint8_t)Location_Search_Pack.macAddr[0];
TxMsgFrame.au8Data[5] = (uint8_t)Location_Search_Pack.macAddr[1];
TxMsgFrame.au8Data[6] = (uint8_t)Location_Search_Pack.macAddr[2];
TxMsgFrame.au8Data[7] = (uint8_t)Location_Search_Pack.macAddr[3];
if(CANFD_TransmitDMsg(BMS_CAN, 0, &TxMsgFrame) != 1){
return RS_ERROR;
}
return RS_OK;
}
/**
* @details: This function is Boot Request Devices
*/
int8_t Boot_Device_Request(void)
{
//给选中设备分配临时ID
if(double_list_isempty(&Device_list_Head.list) ==0){
uint16_t TempID_Count =0;
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect){
TempID_Count =TempID_Count+1;
//烧录请求时，给所有片选的设备，分配临时ID
BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID = TempID_Count;
//发送CAN数据帧
CANFD_FD_MSG_T TxMsgFrame;
memset(&TxMsgFrame, 0, sizeof(TxMsgFrame));
/*Set the ID Number*/
TxMsgFrame.u32Id = 0x0F0300FF + ((BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type)<< 8);
//TxMsgFrame.u32Id = 0x0F030000 + ((BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type)<< 8) + (BMSDeviceInfo_Member->BMSDeviceInfo_Member.randomid);
/*Set the frame type*/
TxMsgFrame.eIdType = eCANFD_XID;
/*CAN FD frame type */
TxMsgFrame.eFrmType = eCANFD_DATA_FRM;
/*Set FD frame format attribute */
TxMsgFrame.bFDFormat = 1;
/*Set the bitrate switch attribute*/
TxMsgFrame.bBitRateSwitch = 1;
/*Set data length*/
TxMsgFrame.u32DLC = 8;
/*Set data */
TxMsgFrame.au8Data[0] = (uint8_t)(BMSDeviceInfo_Member->BMSDeviceInfo_Member.tempID);
TxMsgFrame.au8Data[1] = (uint8_t)(BMSDeviceInfo_Member->BMSDeviceInfo_Member.setID);
TxMsgFrame.au8Data[4] = BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[0];
TxMsgFrame.au8Data[5] = BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[1];
TxMsgFrame.au8Data[6] = BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[2];
TxMsgFrame.au8Data[7] = BMSDeviceInfo_Member->BMSDeviceInfo_Member.macAddr[3];
if(CANFD_TransmitDMsg(BMS_CAN, 0, &TxMsgFrame) != 1){
return RS_ERROR;
}
//xSemaphoreTake(CAN0_Transfer_Done_BinarySemHandle, portMAX_DELAY);
delay_ms(50);
}
}
return RS_OK;
}
return RS_OK;
}
/**
* @details: This function is Boot Devices Mem Erase
*/
//int8_t Boot_Mem_Erase(void)
int8_t Boot_Mem_Erase(uint16_t deviceIndex)
{
#if 0
//给每个片选设备发送擦除指令
if(double_list_isempty(&Device_list_Head.list) ==0){
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.isSelect){
//发送CAN数据帧
CANFD_FD_MSG_T TxMsgFrame;
memset(&TxMsgFrame, 0, sizeof(TxMsgFrame));
/*Set the ID Number*/
TxMsgFrame.u32Id = 0x0F0400FF + ((BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type)<< 8);
/*Set the frame type*/
TxMsgFrame.eIdType = eCANFD_XID;
/*CAN FD frame type */
TxMsgFrame.eFrmType = eCANFD_DATA_FRM;
/*Set FD frame format attribute */
TxMsgFrame.bFDFormat = 1;
/*Set the bitrate switch attribute*/
TxMsgFrame.bBitRateSwitch = 1;
/*Set data length*/
TxMsgFrame.u32DLC = 0;
if(CANFD_TransmitDMsg(BMS_CAN, 0, &TxMsgFrame) != 1){
return RS_ERROR;
}
//xSemaphoreTake(CAN0_Transfer_Done_BinarySemHandle, portMAX_DELAY);
delay_ms(50);
}
}
}
#endif
#if 1
//广播发送CAN数据帧
CANFD_FD_MSG_T TxMsgFrame;
memset(&TxMsgFrame, 0, sizeof(TxMsgFrame));
/*Set the ID Number*/
TxMsgFrame.u32Id = 0x0F0400FF + (deviceIndex<< 8);
/*Set the frame type*/
TxMsgFrame.eIdType = eCANFD_XID;
/*CAN FD frame type */
TxMsgFrame.eFrmType = eCANFD_DATA_FRM;
/*Set FD frame format attribute */
TxMsgFrame.bFDFormat = 1;
/*Set the bitrate switch attribute*/
TxMsgFrame.bBitRateSwitch = 1;
/*Set data length*/
TxMsgFrame.u32DLC = 0;
if(CANFD_TransmitDMsg(BMS_CAN, 0, &TxMsgFrame) != 1){
return RS_ERROR;
}
//xSemaphoreTake(CAN0_Transfer_Done_BinarySemHandle, portMAX_DELAY);
delay_ms(50);
#endif
return RS_OK;
}
/**
* @details: This function is Boot Devices Write End
*/
int8_t Boot_Mem_Write_End(uint16_t deviceIndex)
{
//广播发送CAN数据帧
CANFD_FD_MSG_T TxMsgFrame;
memset(&TxMsgFrame, 0, sizeof(TxMsgFrame));
/* Set the ID Number */
TxMsgFrame.u32Id = 0x0F0600FF + (deviceIndex<< 8);
/* Set the frame type */
TxMsgFrame.eIdType = eCANFD_XID;
/* CAN FD frame type */
TxMsgFrame.eFrmType = eCANFD_DATA_FRM;
/* Set FD frame format attribute */
TxMsgFrame.bFDFormat = 1;
/* Set the bitrate switch attribute */
TxMsgFrame.bBitRateSwitch = 1;
/* Set data length */
TxMsgFrame.u32DLC = 0;
if(CANFD_TransmitDMsg(BMS_CAN, 0, &TxMsgFrame) != 1){
return RS_ERROR;
}
//xSemaphoreTake(CAN0_Transfer_Done_BinarySemHandle, portMAX_DELAY);
delay_ms(50);
return RS_OK;
}
/**
* @details: This function is Boot Devices Mem Write S19
*/
int8_t Boot_Mem_Write_S19_Bin(uint16_t deviceIndex, uint8_t *au8Data, uint32_t data_len)
{
if((au8Data == NULL) || data_len >8)
RS_LOGE("Boot_Mem_Write_S19 para error\n");
CANFD_FD_MSG_T TxMsgFrame;
memset(&TxMsgFrame, 0, sizeof(TxMsgFrame));
/* Set the ID Number */
TxMsgFrame.u32Id = 0x0F0500FF + (deviceIndex<< 8);
/* Set the frame type */
TxMsgFrame.eIdType = eCANFD_XID;
/* CAN FD frame type */
TxMsgFrame.eFrmType = eCANFD_DATA_FRM;
/* Set FD frame format attribute */
TxMsgFrame.bFDFormat = 1;
/* Set the bitrate switch attribute */
TxMsgFrame.bBitRateSwitch = 1;
/* Set data length */
TxMsgFrame.u32DLC = data_len;
/* Set data */
memcpy(TxMsgFrame.au8Data, au8Data, data_len);
if(CANFD_TransmitDMsg(BMS_CAN, 0, &TxMsgFrame) != 1){
return RS_ERROR;
}
//xSemaphoreTake(CAN0_Transfer_Done_BinarySemHandle, portMAX_DELAY);
//delay_ms(50);
return RS_OK;
}
/**
* @details: This function is Parse_S19 Record
*/
int8_t Parse_S19_Record(const char *line, S19_Record *record)
{
int i, checksum;
char type[3]={0};
int length;
int8_t Address_length;
uint8_t byte;
//获取类型和长度
if(sscanf(line, "%2c%2x", type, &length) != 2){
RS_LOGE("Error parsing type length");
return RS_ERROR;
}
//类型检查
if(type[0] != 'S'){
RS_LOGE("Error Invalid record type");
return RS_ERROR;
}
//类型 s0 s5 s7 s8 s9 不进行数据解析
if(type[1]=='0' || type[1]=='5' || type[1]=='7' || type[1]=='8' || type[1]=='9'){
return -3;
}
//通过类型解析地址长度
Address_length =Parse_S19_AddressLen(type);
if(Address_length == RS_ERROR){
RS_LOGE("Parse_S19_AddressLen");
return RS_ERROR;
}
//获取行地址
switch(Address_length){
case 4:
{
if(sscanf(line+4, "%4x", &record->address) != 1){
RS_LOGE("Error parsing address");
return RS_ERROR;
}
break;
}
case 6:
{
if(sscanf(line+4, "%6x", &record->address) != 1){
RS_LOGE("Error parsing address");
return RS_ERROR;
}
break;
}
case 8:
{
if(sscanf(line+4, "%8x", &record->address) != 1){
RS_LOGE("Error parsing address");
return RS_ERROR;
}
break;
}
default:break;
}
//length = address + data + checksum 字节数总和
if(length > 256){
RS_LOGE("Error Invalid data length");
return RS_ERROR;
}
//记录数据字节大小
record->data_length = (length*2 - Address_length - 2) / 2;
//解析数据
for(i = 0; i < (length*2 - Address_length - 2)/2; ++i){
if(sscanf((line+2+2+Address_length)+i*2, "%2hhx", &byte) != 1){
RS_LOGE("Error parsing data bytes");
return RS_ERROR;
}
record->data[i] = byte;
}
//获取行数据校验和
int checksum_line =0;
if(sscanf((line+length*2+2), "%2x", &checksum_line) != 1){
RS_LOGE("Error parsing checksum_line bytes");
return RS_ERROR;
}
//计算对比行校验和
checksum = 0;
int checksum_data =0;
for(i=0; i<length; i++){
if(sscanf((line+2+i*2), "%2x", &checksum_data) != 1){
RS_LOGE("Error parsing checksum bytes");
return RS_ERROR;
}
checksum +=checksum_data;
}
checksum = 0xFF -(checksum & 0xFF);
//比较计算值与原始值的一致性
if(checksum != checksum_line){
RS_LOGE("Error Invalid checksum");
return RS_ERROR;
}
return RS_OK;
}
/**
* @details: This function is Parse_S19 AddressLen
*/
int8_t Parse_S19_AddressLen(char *line)
{
int8_t AddressLen = 0;
if(line[0] != 'S' || line == NULL || strlen(line) != 2){
return RS_ERROR;
}
switch(line[1]){
case '0': AddressLen = 2 * 2;
break;
case '1': AddressLen = 2 * 2;
break;
case '2': AddressLen = 3 * 2;
break;
case '3': AddressLen = 4 * 2;
break;
case '7': AddressLen = 4 * 2;
break;
case '8': AddressLen = 3 * 2;
break;
case '9': AddressLen = 2 * 2;
break;
default:break;
}
return AddressLen;
}
/**
* @details: This function is CANBootStep_Set
*/
void CANBootStep_Set(uint8_t BootStep)
{
CANBootStep =BootStep;
//只要跳转，清除BMS的CAN当前发送超时计数
BOOT_Send_Timeout_Num =0;
/*
跳转 :
1.对接口进行统一管理操作
2.清除链表所有节点isReady标志
3.重置链表所有节点超时时间
*/
if(double_list_isempty(&Device_list_Head.list) ==0){
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
//遍历清除所有准备状态标志
BMSDeviceInfo_Member->BMSDeviceInfo_Member.isReady =0;
switch(BootStep){
case BOOT_IDLE:
break;
case BOOT_DEVICE_LOCATION: BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_LOCATIONH_TIMEOUT;
break;
case BOOT_DEVICE_SEARCH: BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_SEARCH_TIMEOUT;
break;
case BOOT_BURNING_REQUEST: BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_REQUEST_TIMEOUT;
break;
case BOOT_MEM_ERASE: BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_ERASE_TIMEOUT;
break;
case BOOT_MEM_WRITE: BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_WRITE_TIMEOUT;
break;
case BOOT_MEM_WRITE_END: BMSDeviceInfo_Member->BMSDeviceInfo_Member.timeout =DEVICE_WRITE_END_TIMEOUT;
break;
default:break;
}
}
}
/* CAN Boot Step Deal */
switch(BootStep){
case BOOT_IDLE:
{
//关闭 Search上报开关
Search_Pack.onoff =0;
//OTA最后一帧数据标志置位
xSemaphoreTake(OTA_Crc_Data_BinarySemHandle, 0);
#if 1
//关闭 Bms_Upgrade_Send_Recv_Pro 线程
if(CAN_BMS_BOOT_Flag){
CAN_BMS_BOOT_Flag =0;
vTaskDelete(CAN_BMS_Upgrade_handle);
}
#endif
break;
}
case BOOT_DEVICE_LOCATION:
{
//设置Location升级设备定位时间
Device_Upgrade_Location_Timeout_Num =DEVICE_UPGRADE_LOCATION_TIMEOUT;
//针对设备类型进行过滤
CANFD_SetXIDFltr_BMS_DeviceIndex(0x1F010000,0x1F010000,DeviceIndex);
//清空定位设备链表节点
Clean_Location_Device_List();
//关闭 Bms_Upgrade_Send_Recv_Pro 线程
if(CAN_BMS_BOOT_Flag){
CAN_BMS_BOOT_Flag =0;
vTaskDelete(CAN_BMS_Upgrade_handle);
}
//创建 Bms_Upgrade_Send_Recv_Pro 线程
if(CAN_BMS_BOOT_Flag == 0){
if(xTaskCreate((TaskFunction_t )Bms_Upgrade_Send_Recv_Pro,
(const char* )"Bms_Upgrade_Send_Recv_Pro",
(uint16_t )512*3,//15 *1024,//512*6, //512*2,
(void* )NULL,
(UBaseType_t )7, //8, //7,//6, //3,
(TaskHandle_t* )&CAN_BMS_Upgrade_handle) != pdPASS)
{
RS_LOGE("xTaskCreate Bms_Upgrade_Send_Recv_Pro Task Failed!\n");
}else{
CAN_BMS_BOOT_Flag =1;
}
}
break;
}
case BOOT_DEVICE_SEARCH:
{
//设置Search升级设备搜索时间
Device_Upgrade_Search_Timeout_Num =DEVICE_UPGRADE_SEARCH_TIMEOUT;
//针对设备类型进行过滤
CANFD_SetXIDFltr_BMS_DeviceIndex(0x1F020000,0x1F020000,DeviceIndex);
//清空搜索设备链表节点
Clean_Search_Device_List();
//剔除不同的设备类型节点，保留相同设备
if(double_list_isempty(&Device_list_Head.list) ==0){
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
if(BMSDeviceInfo_Member->BMSDeviceInfo_Member.device_type != DeviceIndex){
double_list_remove(ptr);
vPortFree(BMSDeviceInfo_Member);
}
}
}
//创建 Bms_Upgrade_Send_Recv_Pro 线程
if(CAN_BMS_BOOT_Flag == 0){
if(xTaskCreate((TaskFunction_t )Bms_Upgrade_Send_Recv_Pro,
(const char* )"Bms_Upgrade_Send_Recv_Pro",
(uint16_t )512*3,//15 *1024,//512*6, //512*2,
(void* )NULL,
(UBaseType_t )7, //8, //6, //3,
(TaskHandle_t* )&CAN_BMS_Upgrade_handle) != pdPASS)
{
RS_LOGE("xTaskCreate Bms_Upgrade_Send_Recv_Pro Task Failed!\n");
}else{
CAN_BMS_BOOT_Flag =1;
}
}
break;
}
case BOOT_BURNING_REQUEST:
{
//清空重置队列缓冲区
xQueueReset(Can_Recv_Data_QueueHandle);
//针对设备类型进行过滤
CANFD_SetXIDFltr_BMS_DeviceIndex(0x1F030000,0x1F030000,DeviceIndex);
break;
}
case BOOT_MEM_ERASE:
{
//清空重置队列缓冲区
xQueueReset(Can_Recv_Data_QueueHandle);
//针对设备类型进行过滤
CANFD_SetXIDFltr_BMS_DeviceIndex(0x1F040000,0x1F040000,DeviceIndex);
break;
}
case BOOT_MEM_WRITE:
{
//清空重置队列缓冲区
xQueueReset(Can_Recv_Data_QueueHandle);
//针对设备类型进行过滤
CANFD_SetXIDFltr_BMS_DeviceIndex(0x1F050000,0x1F050000,DeviceIndex);
break;
}
case BOOT_MEM_WRITE_END:
{
//清空重置队列缓冲区
xQueueReset(Can_Recv_Data_QueueHandle);
//针对设备类型进行过滤
CANFD_SetXIDFltr_BMS_DeviceIndex(0x1F060000,0x1F060000,DeviceIndex);
break;
}
default:break;
}
}
/**清空搜索设备链表节点
* @details: This function is Clean_Search_Device_List
*/
void Clean_Search_Device_List(void)
{
if(double_list_isempty(&Device_list_Head.list) ==0){
double_list_for_each(ptr,&Device_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
double_list_remove(ptr);
vPortFree(BMSDeviceInfo_Member);
}
}
}
/**清空定位设备链表节点
* @details: This function is Clean_Location_Device_List
*/
void Clean_Location_Device_List(void)
{
if(double_list_isempty(&Device_Location_list_Head.list) ==0){
double_list_for_each(ptr,&Device_Location_list_Head.list){
BMSDeviceInfo_Member_List_t *BMSDeviceInfo_Member =double_list_entry(ptr, BMSDeviceInfo_Member_List_t, list);
double_list_remove(ptr);
vPortFree(BMSDeviceInfo_Member);
}
}
}
Stay hungry, stay foolish
待续。。。
浙公网安备 33010602011771号