#include "extendboards.h" #include "delay.h" #include "crc16.h" #include "filetrans.h" //------------------------------------------------------------------------------- //------------------------------------------------------------------------------- #if (MAX_SUPPORT_CORE > 0) CoreControl g_extendCtrlList[MAX_SUPPORT_CORE]; #define EXID_CORE_STA1 MAKE_EXID(BN_PROTOCOL_MVCTRL, BN_ID_CORE_1, 0, BN_CMD_REGVAL) // 第一块的状态变化 ID #define EXID_CORE_STA2 MAKE_EXID(BN_PROTOCOL_MVCTRL, BN_ID_CORE_2, 0, BN_CMD_REGVAL) // 第二块的状态变化 ID #define EXID_CORE_STA3 MAKE_EXID(BN_PROTOCOL_MVCTRL, BN_ID_CORE_3, 0, BN_CMD_REGVAL) // 第三块的状态变化 ID #define CUR_BOARD_INSTA_EXID MAKE_EXID(BN_PROTOCOL_MVCTRL, CUR_COREBOARD_ID, 0, BN_CMD_REGVAL) #define EXID_CORE_CTRL1 MAKE_EXID(BN_PROTOCOL_MVCTRL, BN_ID_CORE_1, 0, BN_CMD_WTREG) // 第一块的控制数据 ID #define EXID_CORE_CTRL2 MAKE_EXID(BN_PROTOCOL_MVCTRL, BN_ID_CORE_2, 0, BN_CMD_WTREG) // 第二块的控制数据 ID #define EXID_CORE_CTRL3 MAKE_EXID(BN_PROTOCOL_MVCTRL, BN_ID_CORE_3, 0, BN_CMD_WTREG) // 第三块的控制数据 ID #define CUR_BOARD_OUTCTRL_EXID MAKE_EXID(BN_PROTOCOL_MVCTRL, CUR_COREBOARD_ID, 0, BN_CMD_WTREG) const u32 g_coreInExid[MAX_SUPPORT_CORE] = { EXID_CORE_STA1, #if (MAX_SUPPORT_CORE > 1) EXID_CORE_STA2, #endif #if (MAX_SUPPORT_CORE > 2) EXID_CORE_STA3, #endif }; const u32 g_coreOutExid[MAX_SUPPORT_CORE] = { EXID_CORE_CTRL1, #if (MAX_SUPPORT_CORE > 1) EXID_CORE_CTRL2, #endif #if (MAX_SUPPORT_CORE > 2) EXID_CORE_CTRL3, #endif }; #endif //------------------------------------------------------------------------- int g_curBoardIdx = -1; // 当前板卡在列表中的下角标 int g_curBoardID = -1; // 当前板卡的节点ID int g_curBoardInstaExid = -1; int g_curBoardOutCtrlExid = -1; int g_wrcmdtoogle = 0; int g_rdcmdtoogle = 0; u32 g_rdcmdbitmap = 0; int g_wrstatoogle = 0; int g_rdstatoogle = 0; u32 g_rdstabitmap = 0; #if (RD_HEAD_PARA_NUM > 0) u8 g_exbNvPara[RD_HEAD_PARA_NUM][BOARD_PARA_SIZE]; // 外围板非易失性参数 u8 g_receiveEn[RD_HEAD_PARA_NUM] = {0}; // 接收允许 u8 g_receivenum[RD_HEAD_PARA_NUM] = {0}; // 接收计数 u8 g_framenum[RD_HEAD_PARA_NUM] = {0}; // 数据包帧数 u16 g_datacrc[RD_HEAD_PARA_NUM] = {0}; // 数据crc校验值 #endif s32 headparaval = 0; #define TOOGLE_ADD 0x00010000 #define PORT_ADDR_MOD 0x0000FFFF #define PORT_TOOG_MOD 0xFFFF0000 #define CMDSTA_BMP_FULL 0x000000FF //------------------------------------------------------------------------- static const u32 IDX_TO_BIT[32] = { 0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020, 0x00000040, 0x00000080, 0x00000100, 0x00000200, 0x00000400, 0x00000800, 0x00001000, 0x00002000, 0x00004000, 0x00008000, 0x00010000, 0x00020000, 0x00040000, 0x00080000, 0x00100000, 0x00200000, 0x00400000, 0x00800000, 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, }; #if (MAX_SUPPORT_HEAD > 0) HeadControl g_headList[MAX_SUPPORT_HEAD+1]; #endif #if (MAX_SUPPORT_COLOR > 0) ColorControl g_colorList[MAX_SUPPORT_COLOR+1]; #endif #if (MAX_SUPPORT_EXTIO > 0) ExtIOControl g_extioList[MAX_SUPPORT_EXTIO+1]; #endif #if (MAX_SUPPORT_SEWHD > 0) SewHeadControl g_sewHeadList[MAX_SUPPORT_SEWHD+1]; #endif //------------------------------------------------------------------------- void InitBoardsList(void) { int i; int id; // 核心主板 g_curBoardIdx = CUR_CORE_IDX; g_curBoardID = -1; g_curBoardInstaExid = -1; g_curBoardOutCtrlExid = -1; #if (MAX_SUPPORT_CORE > 0) for (i = 0; i < MAX_SUPPORT_CORE; i++) { InitCoreControl(&(g_extendCtrlList[i])); id = i+1; g_extendCtrlList[i].staexid = MAKE_EXID(BN_PROTOCOL_MVCTRL, id, 0, BN_CMD_REGVAL); g_extendCtrlList[i].cmdexid = MAKE_EXID(BN_PROTOCOL_MVCTRL, id, 0, BN_CMD_WTREG); if (g_curBoardIdx == i) { g_curBoardID = id; g_curBoardInstaExid = g_extendCtrlList[i].staexid; g_curBoardOutCtrlExid = g_extendCtrlList[i].cmdexid; } } #endif if (g_curBoardIdx >= 0) { printf("cur board idx = %d\r\n", g_curBoardIdx); } else { printf("init extendCtrlList error\r\n"); } //------------------------------------------------------------------------- // 机头板 #if (MAX_SUPPORT_HEAD > 0) for (i = 0; i < MAX_SUPPORT_HEAD+1; i++) // 0为广播命令 故MAX_SUPPORT_HEAD+1 { InitHeadControl(&(g_headList[i])); if (i == 0) { g_headList[i].nodeId = BN_ID_BROADCAST; } else { id = i + HEAD_NODEID_BASE - 1; g_headList[i].nodeId = id; } } #endif // (MAX_SUPPORT_HEAD > 0) //------------------------------------------------------------------------- // 换色板 #if (MAX_SUPPORT_COLOR > 0) for (i = 0; i < MAX_SUPPORT_COLOR+1; i++) { InitColorControl(&(g_colorList[i])); if (i == 0) { g_colorList[i].nodeId = BN_ID_BROADCAST; } else { id = i + COLOR_NODEID_BASE - 1; g_colorList[i].nodeId = id; } } #endif //------------------------------------------------------------------------- // IO扩展板 #if (MAX_SUPPORT_EXTIO > 0) for (i = 0; i < MAX_SUPPORT_EXTIO+1; i++) { InitExtIOControl(&(g_extioList[i])); if (i == 0) { g_extioList[i].nodeId = BN_ID_BROADCAST; } else { id = i + EXTIO_NODEID_BASE - 1; g_extioList[i].nodeId = id; } } #endif //------------------------------------------------------------------------- // 缝纫机头板 #if (MAX_SUPPORT_SEWHD > 0) for (i = 0; i < MAX_SUPPORT_SEWHD+1; i++) { InitSewHeadControl(&(g_sewHeadList[i])); if (i == 0) { g_sewHeadList[i].nodeId = BN_ID_BROADCAST; } else { id = i + SEWHD_NODEID_BASE - 1; g_sewHeadList[i].nodeId = id; } } #endif } //--------------------------------------------------- // 设置过滤器 void CoreCanFilter(u8 fifo) { int filteridx = 0; CAN_FilterTypeDef hFilterConfig; if (1) {// 防止报警 filteridx = filteridx; hFilterConfig.FilterBank = 1; hFilterConfig.FilterBank = hFilterConfig.FilterBank; } #if (MAX_SUPPORT_CORE > 1) // 请求本节点输入变化的远程帧和控制本节点输出的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDLIST; // 过滤器组为标识符列表模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器组位宽为32位 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(g_curBoardInstaExid, CAN_RTR_REMOTE)); // 设定第一个过滤器高16位 hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(g_curBoardInstaExid, CAN_RTR_REMOTE)); // 设定第一个过滤器低16位 hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(g_curBoardOutCtrlExid, CAN_RTR_DATA)); // 设定第二个过滤器高16位 hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(g_curBoardOutCtrlExid, CAN_RTR_DATA)); // 设定第二个过滤器低16位 hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对本类设备的所有ID的广播的远程帧和数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_MVCTRL, BN_ID_BROADCAST, 0, 0), 0)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_MVCTRL, BN_ID_BROADCAST, 0, 0), 0)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_TID, 0)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_TID, 0)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对其他N1的寄存器变化数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_MVCTRL, 0, 0, BN_CMD_WTREG), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_MVCTRL, 0, 0, BN_CMD_WTREG), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_REMOTE)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_REMOTE)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); filteridx++; // 针对其他N1的寄存器变化数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_MVCTRL, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_MVCTRL, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_REMOTE)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_REMOTE)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; #endif #if (MAX_SUPPORT_HEAD > 0) // 针对机头板的状态变化数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_HEAD, 0, 0, BN_CMD_EXSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_HEAD, 0, 0, BN_CMD_EXSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对机头板的总线状态命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_HEAD, 0, 0, BN_CMD_BUSSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_HEAD, 0, 0, BN_CMD_BUSSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对机头板的读取寄存器命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_HEAD, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_HEAD, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对机头板的读写参数命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_HEAD, 0, 0, BN_CMD_NVPARA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_HEAD, 0, 0, BN_CMD_NVPARA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; #endif #if (MAX_SUPPORT_COLOR > 0) // 针对换色板的状态变化数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_COLOR, 0, 0, BN_CMD_EXSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_COLOR, 0, 0, BN_CMD_EXSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对换色板的读取寄存器命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_COLOR, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_COLOR, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对换色板的读写参数命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_COLOR, 0, 0, BN_CMD_NVPARA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_COLOR, 0, 0, BN_CMD_NVPARA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; #endif #if (MAX_SUPPORT_EXTIO > 0) // 针对IO扩展板的状态变化数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_EXTIO, 0, 0, BN_CMD_EXSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_EXTIO, 0, 0, BN_CMD_EXSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对IO扩展板的读取寄存器命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_EXTIO, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_EXTIO, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; #endif #if (MAX_SUPPORT_SEWHD > 0) // 针对缝纫机头板的状态变化数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_SEWHD, 0, 0, BN_CMD_EXSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_SEWHD, 0, 0, BN_CMD_EXSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对缝纫机头板的总线状态命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_SEWHD, 0, 0, BN_CMD_BUSSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_SEWHD, 0, 0, BN_CMD_BUSSTA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对缝纫机头板的读取寄存器命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_SEWHD, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_SEWHD, 0, 0, BN_CMD_REGVAL), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; // 针对缝纫机头板的读写参数命令的数据帧 hFilterConfig.FilterBank = filteridx; // 设置过滤器组，范围为0~13 hFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // 过滤器组为标识符屏蔽位模式 hFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // 过滤器位宽为1个32位过滤器 hFilterConfig.FilterIdHigh = HIWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_SEWHD, 0, 0, BN_CMD_NVPARA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterIdLow = LOWORD(MAKE_FILTER(MAKE_EXID(BN_PROTOCOL_SEWHD, 0, 0, BN_CMD_NVPARA), CAN_RTR_DATA)); // 设定过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个） hFilterConfig.FilterMaskIdHigh = HIWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其高段位，16位位宽时为第一个） hFilterConfig.FilterMaskIdLow = LOWORD(MAKE_FILTER(BNMASK_PRT|BNMASK_CMD, CAN_RTR_DATA)); // 设定过滤器屏蔽标识符或者过滤器标识符（32位位宽时为其低段位，16位位宽时为第二个) hFilterConfig.FilterFIFOAssignment = fifo; // 关联到接收FIFO0 hFilterConfig.SlaveStartFilterBank = 14; hFilterConfig.FilterActivation = ENABLE; // 使能过滤器 HAL_CAN_ConfigFilter(&HCAN, &hFilterConfig); // 写入设置 filteridx++; #endif } void InitExtendBoards() { InitBoardsList(); RegistFilter(CoreCanFilter); InitCanCtrl(); } //------------------------------------------------------------------------- //------------------------------------------------------------------------- void InputsTask() { int rslt; CanRxMsg rxMsg; u32 tid, sid, cmd, dev, toogle; int i, count, idx; CtrlBusPacket pkt; count = 0; // CAN输入 do { rslt = GetACanDataPacket(&rxMsg); if (rslt == 0) { dev = GET_PRT_FROM_EXID(rxMsg.canRxhead.ExtId); tid = GET_TID_FROM_EXID(rxMsg.canRxhead.ExtId); sid = GET_SID_FROM_EXID(rxMsg.canRxhead.ExtId); cmd = GET_CMD_FROM_EXID(rxMsg.canRxhead.ExtId); sid = sid; if (rxMsg.canRxhead.RTR == CAN_RTR_REMOTE) // 远程帧 { if ((dev == BN_PROTOCOL_ALL || dev == BN_PROTOCOL_MVCTRL) && // 全部设备或N1 (tid == BN_ID_BROADCAST || tid == g_curBoardID) ) // 全部ID或本板 { if (cmd == BN_CMD_REGVAL) // 请求本节点发送寄存器 { // printf("receive sta request packet\r\n"); if (g_curBoardIdx >= 0) { g_extendCtrlList[g_curBoardIdx].refreshflag = 1; // 设置本板状态刷新标志，重新发送 } else { printf("error: g_curBoardIdx not init\r\n"); } } else { printf("other Remote cmd, cmd=0x%x\r\n", cmd); } } else { printf("other Remote packet, exid=0x%x\r\n", rxMsg.canRxhead.ExtId); } } else if (rxMsg.canRxhead.RTR == CAN_RTR_DATA && rxMsg.canRxhead.DLC == CAN_DATA_LEN) // 数据帧，数据长度为8 { #if (MAX_SUPPORT_CORE > 0) if (dev == BN_PROTOCOL_MVCTRL) { if (tid == BN_ID_BROADCAST || tid == g_curBoardID) // 全部ID或本板 { if (cmd == BN_CMD_WTREG) // 写入命令或数据 { // 写入命令到本节点 if (g_curBoardIdx >= 0) { memcpy(pkt.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); toogle = pkt.cancomm.data.wrport.portaddr & PORT_TOOG_MOD; idx = pkt.cancomm.data.wrport.portaddr & PORT_ADDR_MOD; // printf("refresh this cmd, toogle=0x%x, idx=%d, cmd=0x%x\r\n", toogle, idx, pkt.cancomm.data.wrport.wrdata); if (toogle != g_rdcmdtoogle) // 新命令 { // 清空状态buff g_rdcmdtoogle = toogle; g_rdcmdbitmap = 0; g_extendCtrlList[g_curBoardIdx].newcmdflag = 0; memset(g_extendCtrlList[g_curBoardIdx].cmdbuff, 0, sizeof(CORE_CHG_BUF_LEN)); // printf("get new cmd begin\r\n"); } if (idx < CORE_CHG_BUF_LEN) { g_extendCtrlList[g_curBoardIdx].cmdbuff[idx] = pkt.cancomm.data.wrport.wrdata; g_rdcmdbitmap |= IDX_TO_BIT[idx]; if (g_rdcmdbitmap == CMDSTA_BMP_FULL) { g_extendCtrlList[g_curBoardIdx].newcmdflag = 1; // 设置收到新命令状态 // printf("get new cmd end\r\n"); } } // printf("refresh this cmd, toogle=0x%x, idx=%d, cmd=0x%x\r\n", toogle, idx, pkt.cancomm.data.wrport.wrdata); } else { printf("error: g_curBoardIdx not init\r\n"); } } else { //printf("get other core data for this, cmd=%d, sid=%d\r\n", cmd, sid); } } else // 其他节点ID { if (cmd == BN_CMD_REGVAL) // 寄存器变化命令 { for (i = 0; i < MAX_SUPPORT_CORE ; i++) { if (g_extendCtrlList[i].staexid == rxMsg.canRxhead.ExtId) // 找到其他节点ID相符的缓冲区 { // 刷新状态到缓冲区 memcpy(pkt.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); toogle = pkt.cancomm.data.wrport.portaddr & PORT_TOOG_MOD; idx = pkt.cancomm.data.wrport.portaddr & PORT_ADDR_MOD; if (toogle != g_rdstatoogle) // 新状态 { // 清空状态buff memset(g_extendCtrlList[i].stabuff, 0, sizeof(CORE_CHG_BUF_LEN)); g_rdstatoogle = toogle; g_rdstabitmap = 0; g_extendCtrlList[i].stachangeflag = 0; // printf("get new status begin, toogle=0x%x, idx=%d\r\n", toogle, idx); } if (idx < CORE_CHG_BUF_LEN) { g_extendCtrlList[i].stabuff[idx] = pkt.cancomm.data.wrport.wrdata; g_rdstabitmap |= IDX_TO_BIT[idx]; if (g_rdstabitmap == CMDSTA_BMP_FULL) { g_extendCtrlList[i].stachangeflag = 1; // 设置收到新命令状态 // printf("get new status ok\r\n"); } } // printf("refresh core %d status, toogle=0x%x, idx=%d, val=0x%x\r\n", i+1, toogle, idx, pkt.cancomm.data.wrport.wrdata); break; } } } else { //printf("get other core data, exid=0x%x\r\n", rxMsg.canRxhead.ExtId); } } } #endif #if (MAX_SUPPORT_HEAD > 0) else if (dev == BN_PROTOCOL_HEAD) // 机头板 { if (cmd == BN_CMD_EXSTA) { //printf("get head sta packet, sid=%d\r\n", sid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_HEAD+1; i++) { if (sid == g_headList[i].nodeId) { g_headList[i].exbSta.cancomm.exId.id = rxMsg.canRxhead.ExtId; memcpy(g_headList[i].exbSta.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); g_headList[i].staFlag = 1; break; } } } } else if (cmd == BN_CMD_BUSSTA) // 总线状态命令 { printf("get head bus sta packet, sid=%d\r\n", sid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_HEAD+1; i++) { if (sid == g_headList[i].nodeId) { g_headList[i].busSta.cancomm.exId.id = rxMsg.canRxhead.ExtId; memcpy(g_headList[i].busSta.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); g_headList[i].busFlag = 1; break; } } } } else if (cmd == BN_CMD_REGVAL) // 读取寄存器命令 { //printf("get head reg val packet, sid=%d, tid=%d\r\n", sid, tid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_HEAD+1; i++) { if (sid == g_headList[i].nodeId) { memcpy(pkt.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); u32 highaddr, lowaddr; highaddr = pkt.cancomm.data.rdport.portaddr & PORT_ADDR_HIGH; lowaddr = pkt.cancomm.data.rdport.portaddr & PORT_ADDR_LOW; if (highaddr == BOARD_VERSION) { if (g_headList[i].regVal.rdnewbverflag == 1) // 新程序版本 { g_headList[i].regVal.rdbverbitmap = 0; g_headList[i].regVal.rdnewbverflag = 0; // 清空 g_headList[i].verFlag = 0; memset(g_headList[i].regVal.exbVer, 0, BOARD_VER_LEN*sizeof(u32)); } if (lowaddr < BOARD_VER_LEN) { g_headList[i].regVal.exbVer[lowaddr] = pkt.cancomm.data.rdport.status; g_headList[i].regVal.rdbverbitmap |= IDX_TO_BIT[lowaddr]; if (g_headList[i].regVal.rdbverbitmap == CMDSTA_BMP_FULL) { g_headList[i].verFlag = 1; } } } else if (highaddr == GET_NV_PARA) // 读取参数 { g_headList[i].headParaFlag = 1; headparaval = pkt.cancomm.data.rdport.status; } break; } } } } #if (RD_HEAD_PARA_NUM > 0) else if (cmd == BN_CMD_NVPARA) // 读取非易失性参数 { if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_HEAD+1; i++) { if (sid == g_headList[i].nodeId) { int id = 0; if (g_headList[i].nodeTye == FLAT_EMB_HEAD) { id = 1; } else if (g_headList[i].nodeTye == CHENILLE_HEAD) { id = 2; } else if (g_headList[i].nodeTye == COIL_HEAD) { id = 3; } int rslt = ReceiveBoardNvParaProc(rxMsg, id, g_headList[i].nodeTye); if (rslt == 0) { g_headList[i].nvParaFlag = 1; } break; } } } } #endif else { printf("get other head data packet, exid=0x%x\r\n", rxMsg.canRxhead.ExtId); } } #endif #if (MAX_SUPPORT_COLOR > 0) else if (dev == BN_PROTOCOL_COLOR) { if (cmd == BN_CMD_EXSTA) { //printf("get color sta packet, sid=0x%x, tid=0x%x\r\n", sid, tid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_COLOR+1; i++) { if (sid == g_colorList[i].nodeId) { g_colorList[i].exbSta.cancomm.exId.id = rxMsg.canRxhead.ExtId; memcpy(g_colorList[i].exbSta.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); g_colorList[i].staFlag = 1; break; } } } } else if (cmd == BN_CMD_REGVAL) // 读取寄存器命令 { //printf("get color reg val packet, sid=%d, tid=%d\r\n", sid, tid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_COLOR+1; i++) { if (sid == g_colorList[i].nodeId) { memcpy(pkt.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); u32 highaddr, lowaddr; highaddr = pkt.cancomm.data.rdport.portaddr & PORT_ADDR_HIGH; lowaddr = pkt.cancomm.data.rdport.portaddr & PORT_ADDR_LOW; if (highaddr == BOARD_VERSION) { if (g_colorList[i].regVal.rdnewbverflag == 1) // 新程序版本 { g_colorList[i].regVal.rdbverbitmap = 0; g_colorList[i].regVal.rdnewbverflag = 0; // 清空 g_colorList[i].verFlag = 0; memset(g_colorList[i].regVal.exbVer, 0, BOARD_VER_LEN*sizeof(u32)); } if (lowaddr < BOARD_VER_LEN) { g_colorList[i].regVal.exbVer[lowaddr] = pkt.cancomm.data.rdport.status; g_colorList[i].regVal.rdbverbitmap |= IDX_TO_BIT[lowaddr]; if (g_colorList[i].regVal.rdbverbitmap == CMDSTA_BMP_FULL) { g_colorList[i].verFlag = 1; } } } break; } } } } #if (RD_HEAD_PARA_NUM > 0) else if (cmd == BN_CMD_NVPARA) // 读取非易失性参数 { if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_COLOR+1; i++) { if (sid == g_colorList[i].nodeId) { int id = 0; if (i == 2) // 毛巾换色板 { id = 4; } int rslt = ReceiveBoardNvParaProc(rxMsg, id, 0); if (rslt == 0) { g_colorList[i].nvParaFlag = 1; } break; } } } } #endif else { printf("get other color data packet, exid=0x%x\r\n", rxMsg.canRxhead.ExtId); } } #endif // (MAX_SUPPORT_COLOR > 0) #if (MAX_SUPPORT_EXTIO > 0) else if (dev == BN_PROTOCOL_EXTIO) { if (cmd == BN_CMD_EXSTA) { //printf("get extio sta packet, sid=0x%x, tid=0x%x\r\n", sid, tid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_EXTIO+1; i++) { if (sid == g_extioList[i].nodeId) { g_extioList[i].exbSta.cancomm.exId.id = rxMsg.canRxhead.ExtId; memcpy(g_extioList[i].exbSta.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); g_extioList[i].staFlag = 1; break; } } } } else if (cmd == BN_CMD_REGVAL) // 读取寄存器命令 { //printf("get extio reg val packet, sid=%d, tid=%d\r\n", sid, tid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_EXTIO+1; i++) { if (sid == g_extioList[i].nodeId) { memcpy(pkt.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); u32 highaddr, lowaddr; highaddr = pkt.cancomm.data.rdport.portaddr & PORT_ADDR_HIGH; lowaddr = pkt.cancomm.data.rdport.portaddr & PORT_ADDR_LOW; if (highaddr == BOARD_VERSION) { if (g_extioList[i].regVal.rdnewbverflag == 1) // 新程序版本 { g_extioList[i].regVal.rdbverbitmap = 0; g_extioList[i].regVal.rdnewbverflag = 0; // 清空 g_extioList[i].verFlag = 0; memset(g_extioList[i].regVal.exbVer, 0, BOARD_VER_LEN*sizeof(u32)); } if (lowaddr < BOARD_VER_LEN) { g_extioList[i].regVal.exbVer[lowaddr] = pkt.cancomm.data.rdport.status; g_extioList[i].regVal.rdbverbitmap |= IDX_TO_BIT[lowaddr]; if (g_extioList[i].regVal.rdbverbitmap == CMDSTA_BMP_FULL) { g_extioList[i].verFlag = 1; } } } break; } } } } else { printf("get other extio data packet, exid=0x%x\r\n", rxMsg.canRxhead.ExtId); } } #endif // (MAX_SUPPORT_EXTIO > 0) #if (MAX_SUPPORT_SEWHD > 0) else if (dev == BN_PROTOCOL_SEWHD) { if (cmd == BN_CMD_EXSTA) { //printf("get color sta packet, sid=0x%x, tid=0x%x\r\n", sid, tid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_SEWHD+1; i++) { if (sid == g_sewHeadList[i].nodeId) { g_sewHeadList[i].exbSta.cancomm.exId.id = rxMsg.canRxhead.ExtId; memcpy(g_sewHeadList[i].exbSta.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); g_sewHeadList[i].staFlag = 1; break; } } } } else if (cmd == BN_CMD_REGVAL) // 读取寄存器命令 { //printf("get color reg val packet, sid=%d, tid=%d\r\n", sid, tid); if (tid == g_curBoardID) { for (i = 0; i < MAX_SUPPORT_SEWHD+1; i++) { if (sid == g_sewHeadList[i].nodeId) { memcpy(pkt.cancomm.data.buff, rxMsg.data, CAN_DATA_LEN); u32 highaddr, lowaddr; highaddr = pkt.cancomm.data.rdport.portaddr & PORT_ADDR_HIGH; lowaddr = pkt.cancomm.data.rdport.portaddr & PORT_ADDR_LOW; if (highaddr == BOARD_VERSION) { if (g_sewHeadList[i].regVal.rdnewbverflag == 1) // 新程序版本 { g_sewHeadList[i].regVal.rdbverbitmap = 0; g_sewHeadList[i].regVal.rdnewbverflag = 0; // 清空 g_sewHeadList[i].verFlag = 0; memset(g_sewHeadList[i].regVal.exbVer, 0, BOARD_VER_LEN*sizeof(u32)); } if (lowaddr < BOARD_VER_LEN) { g_sewHeadList[i].regVal.exbVer[lowaddr] = pkt.cancomm.data.rdport.status; g_sewHeadList[i].regVal.rdbverbitmap |= IDX_TO_BIT[lowaddr]; if (g_sewHeadList[i].regVal.rdbverbitmap == CMDSTA_BMP_FULL) { g_sewHeadList[i].verFlag = 1; } } } break; } } } } else { printf("get other sew head data packet, exid=0x%x\r\n", rxMsg.canRxhead.ExtId); } } #endif // (MAX_SUPPORT_SEWHD > 0) else { printf("get other data packet, exid=0x%x\r\n", rxMsg.canRxhead.ExtId); } } else { printf("other packet,RTR=%d,ID=%x,DLC=%d\r\n", rxMsg.canRxhead.RTR, rxMsg.canRxhead.ExtId, rxMsg.canRxhead.DLC); } } else { // printf("no data"); break; } count++; if (count > 10) { break; } }while(1); } void OutputsTask() { CanTxMsg txMsg; int i, j; CtrlBusPacket pkt; //------------------------------------------------------------------------- #if (MAX_SUPPORT_CORE > 0) // 发给其他核心主板的控制命令和本节点的状态命令 for (i = 0; i < MAX_SUPPORT_CORE; i++) { if (g_curBoardIdx == i) // 本节点的状态发送 { if (g_extendCtrlList[i].refreshflag != 0) { if (g_extendCtrlList[i].ReSendStatus != NULL) { g_extendCtrlList[i].ReSendStatus(1); } g_extendCtrlList[i].refreshflag = 0; g_extendCtrlList[i].stachangeflag = 1; } if (g_extendCtrlList[i].stachangeflag != 0) { txMsg.canTxhead.ExtId = g_extendCtrlList[i].staexid; txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 for (j = 0; j < CORE_CHG_BUF_LEN; j++) { pkt.cancomm.data.wrport.portaddr = j | g_wrstatoogle; // 地址 pkt.cancomm.data.wrport.wrdata = g_extendCtrlList[i].stabuff[j]; // 数据 memcpy(txMsg.data, pkt.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // printf("send sta change, toogle=0x%x, idx=%d, sta=0x%x\r\n", g_wrstatoogle, j, pkt.cancomm.data.wrport.wrdata); } g_extendCtrlList[i].stachangeflag = 0; g_wrstatoogle += TOOGLE_ADD; } } else // 其他节点的命令发送 { if (g_extendCtrlList[i].newcmdflag != 0) { txMsg.canTxhead.ExtId = g_extendCtrlList[i].cmdexid; txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 for (j = 0; j < CORE_CHG_BUF_LEN; j++) { pkt.cancomm.data.wrport.portaddr = j | g_wrcmdtoogle; // 地址 pkt.cancomm.data.wrport.wrdata = g_extendCtrlList[i].cmdbuff[j]; // 数据 memcpy(txMsg.data, pkt.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // printf("send cmd, toogle=0x%x, idx=%d, sta=0x%x\r\n", g_wrcmdtoogle, j, pkt.cancomm.data.wrport.wrdata); } g_extendCtrlList[i].newcmdflag = 0; g_wrcmdtoogle += TOOGLE_ADD; } } } #endif #if (MAX_SUPPORT_HEAD > 0) for (i = 0; i < MAX_SUPPORT_HEAD+1; i++) { if (g_headList[i].cmdFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_HEAD, g_headList[i].nodeId, g_curBoardID, BN_CMD_EXCTRL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_headList[i].ctrlCmd.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); g_headList[i].cmdFlag = 0; } if (g_headList[i].refSta != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_HEAD, g_headList[i].nodeId, g_curBoardID, BN_CMD_EXSTA); txMsg.canTxhead.RTR = CAN_RTR_REMOTE; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = 0; // 数据场长度 memset(txMsg.data, 0, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_headList[i].refSta = 0; } if (g_headList[i].refVer != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_HEAD, g_headList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memset(&g_headList[i].rdReg.cancomm.data.buff, 0, CAN_DATA_LEN); g_headList[i].rdReg.cancomm.data.rdport.portaddr = BOARD_VERSION; memcpy(txMsg.data, g_headList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送 g_headList[i].refVer = 0; } if (g_headList[i].traFlag != 0) // 遍历命令 { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_HEAD, g_headList[i].nodeId, g_curBoardID, BN_CMD_TRAVERSE); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_headList[i].traCmd.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); g_headList[i].traFlag = 0; } if (g_headList[i].transFlag != 0) // 数据传输命令 { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_HEAD, g_headList[i].nodeId, g_curBoardID, BN_CMD_TRANS_DATA); ExboardDataTrans(txMsg.canTxhead.ExtId); g_headList[i].transFlag = 0; } if (g_headList[i].exbupdateFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_HEAD, g_headList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_headList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_headList[i].exbupdateFlag = 0; } if (g_headList[i].refNvPara != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_HEAD, g_headList[i].nodeId, g_curBoardID, BN_CMD_NVPARA); txMsg.canTxhead.RTR = CAN_RTR_REMOTE; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = 0; // 数据场长度 memset(txMsg.data, 0, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_headList[i].refNvPara = 0; } if (g_headList[i].refHeadPara != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_HEAD, g_headList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_headList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_headList[i].refHeadPara = 0; } } #endif #if (MAX_SUPPORT_COLOR > 0) for (i = 0; i < MAX_SUPPORT_COLOR+1; i++) { if (g_colorList[i].cmdFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_COLOR, g_colorList[i].nodeId, g_curBoardID, BN_CMD_EXCTRL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_colorList[i].ctrlCmd.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); g_colorList[i].cmdFlag = 0; } if (g_colorList[i].refSta != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_COLOR, g_colorList[i].nodeId, g_curBoardID, BN_CMD_EXSTA); txMsg.canTxhead.RTR = CAN_RTR_REMOTE; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = 0; // 数据场长度 memset(txMsg.data, 0, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_colorList[i].refSta = 0; } if (g_colorList[i].refVer != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_COLOR, g_colorList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memset(&g_colorList[i].rdReg.cancomm.data.buff, 0, CAN_DATA_LEN); g_colorList[i].rdReg.cancomm.data.rdport.portaddr = BOARD_VERSION; memcpy(txMsg.data, g_colorList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送 g_colorList[i].refVer = 0; } if (g_colorList[i].transFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_COLOR, g_colorList[i].nodeId, g_curBoardID, BN_CMD_TRANS_DATA); ExboardDataTrans(txMsg.canTxhead.ExtId); g_colorList[i].transFlag = 0; } if (g_colorList[i].exbupdateFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_COLOR, g_colorList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_colorList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_colorList[i].exbupdateFlag = 0; } if (g_colorList[i].refNvPara != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_COLOR, g_colorList[i].nodeId, g_curBoardID, BN_CMD_NVPARA); txMsg.canTxhead.RTR = CAN_RTR_REMOTE; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = 0; // 数据场长度 memset(txMsg.data, 0, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_colorList[i].refNvPara = 0; } } #endif #if (MAX_SUPPORT_EXTIO > 0) for (i = 0; i < MAX_SUPPORT_EXTIO+1; i++) { if (g_extioList[i].cmdFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_EXTIO, g_extioList[i].nodeId, g_curBoardID, BN_CMD_EXCTRL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_extioList[i].ctrlCmd.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); g_extioList[i].cmdFlag = 0; } if (g_extioList[i].refSta != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_EXTIO, g_extioList[i].nodeId, g_curBoardID, BN_CMD_EXSTA); txMsg.canTxhead.RTR = CAN_RTR_REMOTE; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = 0; // 数据场长度 memset(txMsg.data, 0, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_extioList[i].refSta = 0; } if (g_extioList[i].refVer != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_EXTIO, g_extioList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memset(&g_extioList[i].rdReg.cancomm.data.buff, 0, CAN_DATA_LEN); g_extioList[i].rdReg.cancomm.data.rdport.portaddr = BOARD_VERSION; memcpy(txMsg.data, g_extioList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送 g_extioList[i].refVer = 0; } if (g_extioList[i].transFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_EXTIO, g_extioList[i].nodeId, g_curBoardID, BN_CMD_TRANS_DATA); ExboardDataTrans(txMsg.canTxhead.ExtId); g_extioList[i].transFlag = 0; } if (g_extioList[i].exbupdateFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_EXTIO, g_extioList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_extioList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_extioList[i].exbupdateFlag = 0; } } #endif #if (MAX_SUPPORT_SEWHD > 0) for (i = 0; i < MAX_SUPPORT_SEWHD+1; i++) { if (g_sewHeadList[i].cmdFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_SEWHD, g_sewHeadList[i].nodeId, g_curBoardID, BN_CMD_EXCTRL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_sewHeadList[i].ctrlCmd.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); g_sewHeadList[i].cmdFlag = 0; } if (g_sewHeadList[i].refSta != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_SEWHD, g_sewHeadList[i].nodeId, g_curBoardID, BN_CMD_EXSTA); txMsg.canTxhead.RTR = CAN_RTR_REMOTE; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = 0; // 数据场长度 memset(txMsg.data, 0, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_sewHeadList[i].refSta = 0; } if (g_sewHeadList[i].refVer != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_SEWHD, g_sewHeadList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memset(&g_sewHeadList[i].rdReg.cancomm.data.buff, 0, CAN_DATA_LEN); g_sewHeadList[i].rdReg.cancomm.data.rdport.portaddr = BOARD_VERSION; memcpy(txMsg.data, g_sewHeadList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送 g_sewHeadList[i].refVer = 0; } if (g_sewHeadList[i].transFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_SEWHD, g_sewHeadList[i].nodeId, g_curBoardID, BN_CMD_TRANS_DATA); ExboardDataTrans(txMsg.canTxhead.ExtId); g_sewHeadList[i].transFlag = 0; } if (g_sewHeadList[i].exbupdateFlag != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_SEWHD, g_sewHeadList[i].nodeId, g_curBoardID, BN_CMD_REGVAL); txMsg.canTxhead.RTR = CAN_RTR_DATA; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 memcpy(txMsg.data, g_sewHeadList[i].rdReg.cancomm.data.buff, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_sewHeadList[i].exbupdateFlag = 0; } if (g_sewHeadList[i].refNvPara != 0) { txMsg.canTxhead.ExtId = MAKE_EXID(BN_PROTOCOL_SEWHD, g_sewHeadList[i].nodeId, g_curBoardID, BN_CMD_NVPARA); txMsg.canTxhead.RTR = CAN_RTR_REMOTE; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = 0; // 数据场长度 memset(txMsg.data, 0, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 g_sewHeadList[i].refNvPara = 0; } } #endif } void ExtendBoardTask(void) { InputsTask(); OutputsTask(); } //------------------------------------------------------------------------- CoreControl * GetCoreFromList(u8 id) { #if (MAX_SUPPORT_CORE > 0) if (id > 0 && id <= MAX_SUPPORT_CORE) { return &(g_extendCtrlList[id-1]); } else #endif { return NULL; } } HeadControl * GetHeadFromList(u8 id) { #if (MAX_SUPPORT_HEAD > 0) if (id > 0 && id <= MAX_SUPPORT_HEAD+1) { return &(g_headList[id-1]); } else #endif { return NULL; } } ColorControl * GetColorFromList(u8 id) { #if (MAX_SUPPORT_COLOR > 0) if (id > 0 && id <= MAX_SUPPORT_COLOR+1) { return &(g_colorList[id-1]); } else #endif { return NULL; } } ExtIOControl * GetExtIOFromList(u8 id) { #if (MAX_SUPPORT_EXTIO > 0) if (id > 0 && id <= MAX_SUPPORT_EXTIO+1) { return &(g_extioList[id-1]); } else #endif { return NULL; } } int GetCurBoardID(void) { return g_curBoardID; } //------------------------------------------------------------------------ #if (MAX_SUPPORT_CORE > 0) int IsNewControlCommand(void) { if (g_extendCtrlList[g_curBoardIdx].newcmdflag != 0) { printf("can data inter\r\n"); return TRUE; } return FALSE; } // 请求其他板子发送状态 void RequestExStatus(void) { CanTxMsg txMsg; int i; for (i = 0; i < MAX_SUPPORT_CORE; i++) { if (g_curBoardIdx != i) // 其他点的状态请求 { txMsg.canTxhead.ExtId = g_extendCtrlList[i].staexid; txMsg.canTxhead.RTR = CAN_RTR_REMOTE; // 远程帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = 0; // 数据场长度 memset(txMsg.data, 0, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); // 发送远程帧 } } } #endif //------------------------------------------------------------------------- // 机头板协议,上位机不需要知道对应的节点ID,只需告知节点类型和机头号即可 // 换色板协议 需告知第几块板卡 // IO扩展板协议 需告知第几块板卡 void StartBoardUpdate(u8 protocol, u8 nodetype, u8 nodeid) { #if (MAX_SUPPORT_HEAD > 0) if (protocol == BN_PROTOCOL_HEAD) { HeadControl * head = GetHeadFromList(1); // 默认广播发送 HeadControl * temp = NULL; // 临时存储 if (nodeid != 0) { for(int i = 1; i < MAX_SUPPORT_HEAD+1; i++) { temp = GetHeadFromList(i+1); if (temp->nodeTye == nodetype) { if (nodeid <= 1) { head = temp; break; } else { nodeid--; } } } } head->rdReg.cancomm.data.rdport.portaddr = EXBOARD_UPDATE; head->rdReg.cancomm.data.rdport.status = nodetype; head->exbupdateFlag = 1; } else #endif #if (MAX_SUPPORT_COLOR > 0) if (protocol == BN_PROTOCOL_COLOR) { ColorControl * color = GetColorFromList(nodeid+1); color->exbupdateFlag = 1; } else #endif #if (MAX_SUPPORT_EXTIO > 0) if (protocol == BN_PROTOCOL_EXTIO) { ExtIOControl * extio = GetExtIOFromList(nodeid+1); extio->exbupdateFlag = 1; } else #endif { } } // 设置外围板非易失性参数 void SetBoardNvPara(int protocolType, int nodetype, int nodeId, u8 parablockID, u8 paraID, s32 paraVal) { #if (MAX_SUPPORT_HEAD > 0) if (protocolType == BN_PROTOCOL_HEAD) { SetHeadNvParaCmd(nodetype, nodeId, parablockID, paraID, paraVal); } else #endif #if (MAX_SUPPORT_COLOR > 0) if (protocolType == BN_PROTOCOL_COLOR) { if (nodeId != 0) // 20220628 不支持广播设置,因为界面存在乱发命令的情况 { SetColorNvParaCmd(nodeId, parablockID, paraID, paraVal); } } else #endif { } } //------------------------------------------------------------------------- #if (MAX_SUPPORT_HEAD > 0) // 进入遍历状态 void EnterTraverse(void) { memset(&g_headList[0].traCmd.cancomm.data, 0, CAN_DATA_LEN); g_headList[0].traCmd.cancomm.data.traverse.tracmd = TRA_CMD_ENTER_TRA; g_headList[0].traFlag = 1; OutputsTask(); } /* function:总线遍历 * return: 0: * -1: 参数错误 */ int TraverseSingleNode(u8 traNodeType, u8 traNodeId) { printf("traverse nodeid=%d, nodetype=%d\r\n", traNodeId, traNodeType); memset(&g_headList[0].traCmd.cancomm.data, 0, CAN_DATA_LEN); g_headList[0].traCmd.cancomm.data.traverse.tracmd = TRA_CMD_NODE_TRA_BEG; g_headList[0].traCmd.cancomm.data.traverse.nodetype = traNodeType; g_headList[0].traCmd.cancomm.data.traverse.nodeid = traNodeId; g_headList[0].traFlag = 1; OutputsTask(); return 0; } /* function:当前节点已遍历,返回确认数据包 * return: 0: */ int CurNodeTraverseAlready(u32 nodeid) { printf("nodeid %d already set\r\n", nodeid); for(int i = 1; i < MAX_SUPPORT_HEAD+1; i++) { if(g_headList[i].nodeId == nodeid) { memset(&g_headList[i].traCmd.cancomm.data, 0, CAN_DATA_LEN); g_headList[i].traCmd.cancomm.data.traverse.tracmd = TRA_CMD_NODE_TRA_END; g_headList[i].traCmd.cancomm.data.traverse.nodeid = nodeid; g_headList[i].traFlag = 1; break; } } OutputsTask(); return 0; } void ExitTravers() // 退出遍历 { memset(&g_headList[0].traCmd.cancomm.data, 0, CAN_DATA_LEN); g_headList[0].traCmd.cancomm.data.traverse.tracmd = TRA_CMD_EXIT_TRA; g_headList[0].traFlag = 1; OutputsTask(); printf("exit traverse\r\n"); } //--------------------------------------------------- // 请求总线状态 void InquireBusSta(int idx) { memset(&g_headList[idx].traCmd.cancomm.data, 0, CAN_DATA_LEN); g_headList[idx].traCmd.cancomm.data.traverse.tracmd = TRA_CMD_ASK_TRA_STA; g_headList[idx].traFlag = 1; OutputsTask(); printf("inquire bus sta, idx=%d\r\n", idx); } u32 GetHeadStatus(int idx) { u32 sta; HeadCommand * pSta; if (idx > 0 && idx <= MAX_SUPPORT_HEAD) { pSta = (HeadCommand *)( &(g_headList[idx].exbSta.cancomm.data.buff)); sta = pSta->headSta.staBits; } else { sta = 0; } return sta; } void CleanHeadStatus(int idx) { HeadCommand * pSta; if (idx > 0 && idx <= MAX_SUPPORT_HEAD) { pSta = (HeadCommand *)( &(g_headList[idx].exbSta.cancomm.data.buff)); pSta->headSta.staBits = 0; } } void RequestHeadsStatus(void) { RequestHeadStatus(&(g_headList[0])); // 发送广播命令 OutputsTask(); } void RequestHeadsVersion(void) { RequestHeadVersion(&(g_headList[0])); // 广播询问 for(int i = 1; i < MAX_SUPPORT_HEAD+1; i++) { g_headList[i].regVal.rdnewbverflag = 1; } } void RequestAHeadNvPara(int idx) { if (idx <= 0) { return; } RequestHeadNvPara(&(g_headList[idx])); } // 设置主轴角度 void SendHeadAngCmd(int idx, u8 para1, u16 para2, u8 para3) { HeadCommand ncmd; memset(&ncmd, 0, sizeof(HeadCommand)); ncmd.setmsang.cmd = CTRL_CMD_HEAD_MSANG; ncmd.setmsang.validFlag = para1; ncmd.setmsang.msang = para2; ncmd.setmsang.nodetype = para3; SendHeadCommand(&g_headList[idx], &ncmd); // 节点命令 OutputsTask(); // 刷新输入输出 } // 设置机头板非易失性参数 void SetHeadNvParaCmd(int nodetype, int idx, u8 parablockid, u8 paraid, s32 paraval) { if (idx < 0 || idx > MAX_SUPPORT_HEAD) { return; } HeadCommand ncmd; memset(&ncmd, 0, sizeof(HeadCommand)); if (nodetype == FLAT_EMB_HEAD) { ncmd.headNvPara.cmd = CTRL_CMD_HEAD_NVPARA; } else if (nodetype == CHENILLE_HEAD) { ncmd.headNvPara.cmd = CTRL_CMD_CHENILLE_NVPARA; } else if (nodetype == COIL_HEAD) { ncmd.headNvPara.cmd = CTRL_CMD_COIL_NVPARA; } ncmd.headNvPara.parablockID = parablockid; ncmd.headNvPara.paraID = paraid; ncmd.headNvPara.paraval = paraval; SendHeadCommand(&g_headList[idx], &ncmd); // 节点命令 OutputsTask(); // 刷新输入输出 } u16 GetHeadPotValue(int idx) { u32 sta; HeadCommand * pSta; if (idx > 0 && idx <= MAX_SUPPORT_HEAD) { pSta = (HeadCommand *)( &(g_headList[idx].exbSta.cancomm.data.buff)); sta = pSta->headSta.potValue; } else { sta = 0; } return sta; } int GetHeadCurrentNeele(int idx) { u32 sta; HeadCommand * pSta; if (idx > 0 && idx <= MAX_SUPPORT_HEAD) { pSta = (HeadCommand *)( &(g_headList[idx].exbSta.cancomm.data.buff)); sta = pSta->headSta.setedNP; } else { sta = 0; } return sta; } #endif //------------------------------------------------------------------------- #if (MAX_SUPPORT_COLOR > 0) void RequestColorsVersion(void) { RequestColorVersion(&(g_colorList[0])); for(int i = 1; i < MAX_SUPPORT_COLOR+1; i++) { g_colorList[i].regVal.rdnewbverflag = 1; } } void RequestAColorNvPara(int idx) { if (idx <= 0) { return; } RequestColorNvPara(&(g_colorList[idx])); } void SendColorCtrlCmd(int idx, u8 subcmd, u8 para1, u8 para2) { ColorCommand ncmd; memset(&ncmd, 0, sizeof(ColorCommand)); ncmd.colorCtrl.cmd = CTRL_CMD_COLOR_CTRL; ncmd.colorCtrl.subcmd = subcmd; ncmd.colorCtrl.para[0] = para1; ncmd.colorCtrl.para[1] = para2; SendColorCommand(&g_colorList[idx], &ncmd); // 节点命令 OutputsTask(); // 刷新输入输出 } // 设置换色板非易失性参数 void SetColorNvParaCmd(int idx, u8 parablockid, u8 paraid, s32 paraval) { if (idx < 0 || idx > MAX_SUPPORT_COLOR) { return; } ColorCommand ncmd; memset(&ncmd, 0, sizeof(ColorCommand)); ncmd.colorNvPara.cmd = CTRL_CMD_COLOR_NVPARA; ncmd.colorNvPara.parablockID = parablockid; ncmd.colorNvPara.paraID = paraid; ncmd.colorNvPara.paraval = paraval; SendColorCommand(&g_colorList[idx], &ncmd); // 节点命令 OutputsTask(); // 刷新输入输出 } void SendColorParaCmd(int idx, u8 para1) { ColorCommand ncmd; memset(&ncmd, 0, sizeof(ColorCommand)); ncmd.colorPara.cmd = CTRL_CMD_COLOR_PARA; ncmd.colorPara.needleNums = para1; SendColorCommand(&g_colorList[idx], &ncmd); // 节点命令 OutputsTask(); // 刷新输入输出 } void CleanColorSta(int idx) { memset(&(g_colorList[idx].exbSta.cancomm.data.buff), 0, CAN_DATA_LEN); } u16 GetColorStatus(int idx) { u16 sta; ColorCommand * pSta; pSta = (ColorCommand *)( &(g_colorList[idx].exbSta.cancomm.data.buff)); sta = pSta->colorSta.staBits; return sta; } u16 GetColorPotValue(int idx) { u16 sta; ColorCommand * pSta; pSta = (ColorCommand *)( &(g_colorList[idx].exbSta.cancomm.data.buff)); sta = pSta->colorSta.potValue; return sta; } int GetColorCurrentNeele(int idx) { int sta; ColorCommand * pSta; pSta = (ColorCommand *)( &(g_colorList[idx].exbSta.cancomm.data.buff)); sta = (int)pSta->colorSta.curNeedle; return sta; } void RequestColorsStatus(void) { RequestColorStatus(&(g_colorList[0])); // 发送广播命令 OutputsTask(); } #endif #if (MAX_SUPPORT_EXTIO > 0) u16 GetExtIOStatus(int idx) { u16 sta; ExtIOCommand * pSta; if (idx > 0 && idx <= MAX_SUPPORT_EXTIO) { pSta = (ExtIOCommand *)( &(g_extioList[idx].exbSta.cancomm.data.buff)); sta = pSta->extIOSta.inputSta; } else { sta = 0; } return sta; } void CleanExtIOStatus(int idx) { ExtIOCommand * pSta; if (idx > 0 && idx <= MAX_SUPPORT_EXTIO) { pSta = (ExtIOCommand *)( &(g_extioList[idx].exbSta.cancomm.data.buff)); pSta->extIOSta.inputSta = 0; } } void RequestExtIOsStatus(void) { RequestExtIOStatus(&(g_extioList[0])); // 发送广播命令 OutputsTask(); } void RequestExtIOsVersion(void) { RequestExtIOVersion(&(g_extioList[0])); // 广播询问 for(int i = 1; i < MAX_SUPPORT_EXTIO+1; i++) { g_extioList[i].regVal.rdnewbverflag = 1; } } void SetExtOutputOn(int idx, u16 bit) { ExtIOCommand ncmd; memset(&ncmd, 0, sizeof(ExtIOCommand)); ncmd.extIOCtrl.cmd = CTRL_CMD_EXTIO_CTRL; ncmd.extIOCtrl.subcmd = CTRL_SUBCMD_OUT_ON; ncmd.extIOCtrl.outctrl = bit; SendExtIOCommand(&g_extioList[idx], &ncmd); OutputsTask(); // 刷新输入输出 } void SetExtOutputOff(int idx, u16 bit) { ExtIOCommand ncmd; memset(&ncmd, 0, sizeof(ExtIOCommand)); ncmd.extIOCtrl.cmd = CTRL_CMD_EXTIO_CTRL; ncmd.extIOCtrl.subcmd = CTRL_SUBCMD_OUT_OFF; ncmd.extIOCtrl.outctrl = bit; SendExtIOCommand(&g_extioList[idx], &ncmd); OutputsTask(); // 刷新输入输出 } #endif #if (MAX_SUPPORT_SEWHD > 0) void RequestSewHeadsStatus(void) { RequestSewHeadStatus(&(g_sewHeadList[0])); // 发送广播命令 OutputsTask(); } void RequestSewHeadsVersion(void) { RequestSewHeadVersion(&(g_sewHeadList[0])); for(int i = 1; i < MAX_SUPPORT_SEWHD+1; i++) { g_sewHeadList[i].regVal.rdnewbverflag = 1; } } void CleanSewHeadSta(int idx) { memset(&(g_sewHeadList[idx].exbSta.cancomm.data.buff), 0, CAN_DATA_LEN); } u16 GetSewHeadStatus(int idx) { u16 sta; SewHeadCommand * pSta; pSta = (SewHeadCommand *)( &(g_sewHeadList[idx].exbSta.cancomm.data.buff)); sta = pSta->headSta.staBits; return sta; } void SendSewHeadCtrlCmd(int idx, u8 subcmd, u8 para1, u8 para2) { SewHeadCommand ncmd; memset(&ncmd, 0, sizeof(SewHeadCommand)); ncmd.headCtrl.cmd = CTRL_CMD_SEW_HEAD_CTRL; ncmd.headCtrl.subcmd = subcmd; ncmd.headCtrl.para[0] = para1; ncmd.headCtrl.para[1] = para2; SendSewHeadCommand(&g_sewHeadList[idx], &ncmd); // 节点命令 OutputsTask(); // 刷新输入输出 } #endif #if (RD_HEAD_PARA_NUM > 0) /* * 0:接收完成且正确 * -1:接收未完成 * -2:CRC校验错误 * -3:参数错误 */ int ReceiveBoardNvParaProc(CanRxMsg rxMsg, int id, u8 nodetype) { if (id < 1 || id > RD_HEAD_PARA_NUM) { return -3; } BoardFileCanCtrl * rxbuf = (BoardFileCanCtrl*)(&rxMsg.data); int rslt = -1; if ( rxbuf->head.sync[0] == CDP_SYNC[0] && rxbuf->head.sync[1] == CDP_SYNC[1] && rxbuf->head.sync[2] == CDP_SYNC[2] && 1 ) // 判断是否为数据包头 { if ((nodetype == FLAT_EMB_HEAD && rxbuf->head.pktId == 0) || // 平绣机头板参数 (nodetype == CHENILLE_HEAD && rxbuf->head.pktId == 1) || // 毛巾机头板参数 (nodetype == COIL_HEAD && rxbuf->head.pktId == 2) || // 缠绕机头板参数 (nodetype == 0 && rxbuf->head.pktId == 3) || // 毛巾换色板参数 0) { g_receiveEn[id-1] = 0x5A; g_receivenum[id-1] = 0; g_framenum[id-1] = rxbuf->head.fnum; g_datacrc[id-1] = rxbuf->head.crc; memset(&g_exbNvPara[id-1][0], 0, BOARD_PARA_SIZE); } } else { if (g_receiveEn[id-1] == 0x5A) { // 拷贝数据内容 memcpy(&g_exbNvPara[id-1][g_receivenum[id-1]*8], &rxbuf->data, CAN_DATA_LEN); g_receivenum[id-1]++; if (g_receivenum[id-1] == g_framenum[id-1]) // 接收完成 { g_receiveEn[id-1] = 0; u16 crc = CalcCrc16((u8*)(&g_exbNvPara[id-1][0]), BOARD_PARA_SIZE); if (crc != g_datacrc[id-1]) { rslt = -2; } else { rslt = 0; } } } } return rslt; } u8* GetBoardNvPara(int id) { if (id < 1) { return NULL; } return (u8*)(&g_exbNvPara[id-1][0]); } #endif void ParaDataFromOperToCan(u8 protocol, OperPacket * pPkt, BoardFilePacketCtrl * pBoard) { u32 exid = 0; #if (MAX_SUPPORT_HEAD > 0 || MAX_SUPPORT_COLOR > 0) int i = 0; u8 nodeId = 0; // 0为广播 #endif memset(pBoard, 0, sizeof(BoardFilePacketCtrl)); #if (MAX_SUPPORT_HEAD > 0) if (protocol == BN_PROTOCOL_HEAD) { // 机头板协议,只需告知节点类型和相应的机头号即可,不需关心具体的节点ID if (pPkt->boardPara.nodeId != 0) { int hdnm = pPkt->boardPara.nodeId; // 对应机头号 for (i = 1; i < MAX_SUPPORT_HEAD+1; i++) { if (g_headList[i].nodeTye == pPkt->boardPara.nodeType) { if (hdnm <= 1) { nodeId = g_headList[i].nodeId; break; } else { hdnm--; } } } } if (pPkt->boardPara.nodeType == FLAT_EMB_HEAD) { pBoard->pktHead.head.pktId = 0; // 平绣机头板参数 } else if (pPkt->boardPara.nodeType == CHENILLE_HEAD) { pBoard->pktHead.head.pktId = 1; // 毛巾机头板参数 } else if (pPkt->boardPara.nodeType == COIL_HEAD) { pBoard->pktHead.head.pktId = 2; // 缠绕机头板参数 } else { printf("set head para, nodeType unknown\r\n"); // 20230807新增,防止界面节点类型发送错误 return; } } else #endif #if (MAX_SUPPORT_COLOR > 0) if (protocol == BN_PROTOCOL_COLOR) { u8 boardnum = pPkt->boardPara.nodeId; if (boardnum == 0 || boardnum > MAX_SUPPORT_COLOR) { return; // 20220628 不再支持广播设置,防止界面乱发命令 } nodeId = g_colorList[boardnum].nodeId; if (boardnum == 2) { pBoard->pktHead.head.pktId = 3; // 毛巾换色板参数 } } else #endif { printf("not support protocol\r\n"); return; } memcpy(pBoard->pktHead.head.sync, CDP_SYNC, CDPSYNC_LEN); pBoard->pktHead.head.fnum = BOARD_PARA_SIZE/CAN_DATA_LEN; for (int j = 0; j < pBoard->pktHead.head.fnum; j++) { memcpy(&pBoard->pktData[j].data, &pPkt->boardPara.exData[j*CAN_DATA_LEN], CAN_DATA_LEN); } pBoard->pktHead.head.crc = CalcCrc16((u8*)pBoard->pktData, BOARD_PARA_SIZE); #if (MAX_SUPPORT_HEAD > 0) if (protocol == BN_PROTOCOL_HEAD) { if (i <= MAX_SUPPORT_HEAD) // 找到对应的节点或广播 { exid = MAKE_EXID(BN_PROTOCOL_HEAD, nodeId, g_curBoardID, BN_CMD_NVPARA); } } else #endif #if (MAX_SUPPORT_COLOR > 0) if (protocol == BN_PROTOCOL_COLOR) { exid = MAKE_EXID(BN_PROTOCOL_COLOR, nodeId, g_curBoardID, BN_CMD_NVPARA); } else #endif { } if (exid != 0) { SendPacketDataWithCanFrame(exid, pBoard); } } // 用CAN数据帧的格式发送数据包 void SendPacketDataWithCanFrame(u32 exid, BoardFilePacketCtrl * pBoard) { CanTxMsg txMsg; txMsg.canTxhead.ExtId = exid; txMsg.canTxhead.RTR = CAN_RTR_DATA; // 数据帧 txMsg.canTxhead.IDE = CAN_ID_EXT; // 扩展帧 txMsg.canTxhead.DLC = CAN_DATA_LEN; // 数据场长度 for (int idx = 0; idx < pBoard->pktHead.head.fnum+1; idx++) { memcpy(&txMsg.data, ((u8*)&pBoard->pktHead)+idx*CAN_DATA_LEN, CAN_DATA_LEN); // 填充数据场 SendACANDataPacket(&txMsg); DelayMs(1); } } s32 GetHeadPara(void) { return headparaval; } //------------------------------------------------------------------------- //------------------------------------------------------------------------- //------------------------------------------------------------------------- //-------------------------------------------------------------------------