feat(CAN): 实现多节点CAN总线通信与节点ID管理功能

- 添加CAN调试宏定义，支持条件编译调试信息输出
- 实现节点ID相关功能，包括构建CAN ID、消息过滤、获取/设置节点ID
- 支持Flash存储节点ID，提供加载和保存功能
- 实现节点ID设置和查询命令处理
- 更新CANFD发送函数使用节点ID构建发送ID
- 添加消息过滤逻辑，只处理目标节点的消息
- 重构DMA中断服务程序，优化数据传输处理
- 替换printf为调试宏，便于生产环境控制调试输出

Robot_V2/device/Can.cpp

@@ -18,6 +18,13 @@
 #include <cstring>
 #include <random>
 
+// CAN 调试宏定义
+#if CAN_DEBUG
+#define CAN_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define CAN_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
 constexpr u16 CANX = CAN0;
 extern FOC_Controller FOC;
 extern sampler sampler;
@@ -35,6 +42,124 @@ uint8_t can_tx_buffer[8]; // CAN发送缓冲区
 
 CAN_transmiter CAN0_transmiter; // CAN 初始化
 
+// ============================================================================
+// 节点 ID 相关函数实现 (多电机 CAN 总线隔离)
+// 使用高 16 位 (bits 31-16) 存储节点 ID，低 16 位 (bits 15-0) 存储基础 ID
+// 格式：[节点 ID(16 位)][基础 ID(16 位)]
+// 例如：node_id=1, base_id=0x0200 → 0x00010200
+// ============================================================================
+
+/*!
+	\brief 根据节点 ID 构建 CAN ID
+	\param[in]  base_id 基础 CAN ID(低 16 位)
+	\param[out] none
+	\retval     构建后的完整 CAN ID
+	\note       将节点 ID 放在高 16 位，基础 ID 放在低 16 位
+				格式：[节点 ID(16 位)][基础 ID(16 位)]
+				例如：node_id=1, base_id=0x0200 → 0x00010200
+*/
+u32 CAN_transmiter::build_can_id(u32 base_id) {
+	return ((u32)node_id << 16) | (base_id & 0xFFFF);
+}
+
+/*!
+	\brief 判断接收到的消息是否是发给本节点的
+	\param[in]  received_id 接收到的 CAN ID
+	\param[out] none
+	\retval     true: 消息是发给本节点的 (或广播消息)
+				false: 消息不是发给本节点的
+	\note       支持广播地址 (0xFFFF)，广播消息所有节点都会响应
+				提取高 16 位进行节点 ID 匹配
+*/
+bool CAN_transmiter::is_message_for_me(u32 received_id) {
+	u16 rx_node_id = (u16)((received_id >> 16) & 0xFFFF);
+	return (rx_node_id == BROADCAST_NODE_ID) || (rx_node_id == node_id);
+}
+
+/*!
+	\brief 获取当前节点 ID
+	\param[in]  none
+	\param[out] none
+	\retval     当前节点 ID 值 (0-65534)
+*/
+u16 CAN_transmiter::get_node_id() { return node_id; }
+
+/*!
+	\brief 设置节点 ID
+	\param[in]  new_id 新的节点 ID 值
+	\param[out] none
+	\retval     none
+	\note       节点 ID 范围：0-65534，0xFFFF 保留为广播地址
+*/
+void CAN_transmiter::set_node_id(u16 new_id) {
+	if (new_id <= MAX_NODE_ID) {
+		node_id = new_id;
+		CAN_DEBUG_PRINT("Node ID set to: %d\r\n", node_id);
+	}
+}
+
+/*!
+	\brief 从 Flash 加载节点 ID
+	\param[in]  none
+	\param[out] none
+	\retval     FLASH_EEPROM_OK: 加载成功
+				其他：加载失败，使用默认值
+	\note       Flash 擦除状态为 0xFFFF，需要特殊处理避免误判
+*/
+u8 CAN_transmiter::load_node_id_from_flash() {
+	u16 node_id_temp = 0xFFFF; // 初始化为 Flash 擦除值
+	FlashEepromStatus status =
+		flashEEP.read(FlashEEPROM::ADDR_NODE_ID, &node_id_temp);
+
+	// 检查 Flash 是否为擦除状态 (0xFFFF 或 0) 或读取失败
+	// 注意：Flash 未写入时读到的值是 0xFFFF，但有些情况可能读到 0
+	if (status != FLASH_EEPROM_OK || node_id_temp == 0xFFFF ||
+		node_id_temp == 0) {
+		node_id = DEFAULT_NODE_ID;
+		CAN_DEBUG_PRINT(
+			"Node ID not found in Flash (status=%d, val=0x%04X), using "
+			"default: %d\r\n",
+			status, node_id_temp, node_id);
+		return FLASH_EEPROM_DATA_NOT_FOUND;
+	}
+
+	// 检查节点 ID 是否有效
+	if (node_id_temp <= MAX_NODE_ID) {
+		node_id = node_id_temp;
+		CAN_DEBUG_PRINT("Node ID loaded from Flash: %d\r\n", node_id);
+		return FLASH_EEPROM_OK;
+	} else {
+		node_id = DEFAULT_NODE_ID;
+		CAN_DEBUG_PRINT("Invalid Node ID in Flash (%d), using default: %d\r\n",
+						node_id_temp, node_id);
+		return FLASH_EEPROM_DATA_NOT_FOUND;
+	}
+}
+
+/*!
+	\brief 保存节点 ID 到 Flash
+	\param[in]  new_id 要保存的节点 ID
+	\param[out] none
+	\retval     FLASH_EEPROM_OK: 保存成功
+				其他：保存失败
+*/
+u8 CAN_transmiter::save_node_id_to_flash(u16 new_id) {
+	if (new_id > MAX_NODE_ID) {
+		CAN_DEBUG_PRINT("Invalid Node ID: %d\r\n", new_id);
+		return FLASH_EEPROM_INVALID_ADDR;
+	}
+	FlashEepromStatus status =
+		flashEEP.write(FlashEEPROM::ADDR_NODE_ID, new_id);
+	if (status == FLASH_EEPROM_OK) {
+		node_id = new_id;
+		CAN_DEBUG_PRINT("Node ID saved to Flash: %d\r\n", node_id);
+		return FLASH_EEPROM_OK;
+	} else {
+		CAN_DEBUG_PRINT("Failed to save Node ID to Flash\r\n");
+		return (u8)status;
+	}
+}
+
 // CAN 接收缓冲区相关函数实现
 /*!
 	\brief      检查 CAN 接收缓冲区是否已满
@@ -42,8 +167,8 @@ CAN_transmiter CAN0_transmiter; // CAN初始化
 	\param[out] none
 	\retval     bool 返回 true 表示缓冲区已满，false 表示未满
 	\note       通过比较头指针的下一个位置和尾指针来判断缓冲区是否已满
-				使用循环缓冲区策略，当(rx_buffer_head + 1) %
-   CAN_RX_BUFFER_SIZE等于rx_buffer_tail时， 表示缓冲区已达到最大容量
+				使用循环缓冲区策略，当(rx_buffer_head + 1) % CAN_RX_BUFFER_SIZE
+   等于 rx_buffer_tail 时， 表示缓冲区已达到最大容量
 */
 bool CAN_transmiter::is_rx_buffer_full() {
 	return ((rx_buffer_head + 1) % CAN_RX_BUFFER_SIZE) == rx_buffer_tail;
@@ -180,7 +305,7 @@ void can_config(void) {
 	/* initialize CAN */
 	if (can_init(CAN0, &can_parameter) != SUCCESS) {
 		while (1)
-			printf("can init error \r\n");
+			CAN_DEBUG_PRINT("can init error \r\n");
 	}
 
 	/* initialize filter */
@@ -316,7 +441,7 @@ void can_loopback_init(void) {
 		u16 i = 200;
 		while (--i > 0) {
 			delay_1ms(10);
-			printf("can init error \r\n");
+			CAN_DEBUG_PRINT("can init error \r\n");
 		}
 		system_soft_reset();
 	}
@@ -368,7 +493,7 @@ void canfd_loopback_test(void) {
 	int i = 0;
 	while (i++ < transmit_message.tx_dlen) {
 		transmit_message.tx_data[i] = dis(gen);
-		std::printf("%x\n", transmit_message.tx_data[i]);
+		CAN_DEBUG_PRINT("%x\n", transmit_message.tx_data[i]);
 	}
 
 	/* transmit message */
@@ -392,10 +517,10 @@ void canfd_loopback_test(void) {
 		(transmit_message.tx_ff == receive_message.rx_ff) &&
 		(transmit_message.tx_dlen == receive_message.rx_dlen)) {
 		/* loopback test is success */
-		std::printf("CAN LO0PBACK SUCCESS\r\n");
+		CAN_DEBUG_PRINT("CAN LO0PBACK SUCCESS\r\n");
 	} else {
 		/* loopback test is failed */
-		std::printf("CAN LO0PBACK FAIL\r\n");
+		CAN_DEBUG_PRINT("CAN LO0PBACK FAIL\r\n");
 	}
 }
 
@@ -430,7 +555,8 @@ void can_loopback_test(void) {
 	/* waiting for transmit completed */
 	while ((CAN_TRANSMIT_OK != can_transmit_states(CANX, transmit_mailbox)) &&
 		   (0 != timeout)) {
-		printf("sending:%x...\n", can_transmit_states(CANX, transmit_mailbox));
+		CAN_DEBUG_PRINT("sending:%x...\n",
+						can_transmit_states(CANX, transmit_mailbox));
 		timeout--;
 	}
 	timeout = 0xFF;
@@ -447,19 +573,20 @@ void can_loopback_test(void) {
 		(transmit_message.tx_dlen == receive_message.rx_dlen)) {
 		i = transmit_message.tx_dlen;
 		while (i-- > 0) {
-			std::printf("rx %d:%x:%x\n", i, transmit_message.tx_data[i],
+			CAN_DEBUG_PRINT("rx %d:%x:%x\n", i, transmit_message.tx_data[i],
 							receive_message.rx_data[i]);
 		}
 		if (std::memcmp(receive_message.rx_data, transmit_message.tx_data,
 						transmit_message.tx_dlen) == 0) {
 			/* loopback test is success */
-			std::printf("loopback success\n");
+			CAN_DEBUG_PRINT("loopback success\n");
 		} else {
-			std::printf("loopback failed\n");
+			/* loopback test is failed */
+			CAN_DEBUG_PRINT("loopback failed\n");
 		}
 	} else {
 		/* loopback test is failed */
-		std::printf("loopback failed\n");
+		CAN_DEBUG_PRINT("loopback failed\n");
 	}
 }
 
@@ -480,6 +607,12 @@ u8 CAN_transmiter::init() {
 	// 初始化 DMA 缓冲区
 	memset(can_rx_buffer, 0, sizeof(can_rx_buffer));
 	memset(can_tx_buffer, 0, sizeof(can_tx_buffer));
+
+	// 初始化节点 ID 为默认值
+	node_id = DEFAULT_NODE_ID;
+
+	// 从 Flash 加载节点 ID (如果 Flash 中有有效值则覆盖默认值)
+	load_node_id_from_flash();
 	return 0;
 }
 
@@ -535,7 +668,9 @@ u8 CAN_transmiter::CANFD_all_Send() {
 	pack_float_to_bytes(transmit_data, 21, rt_current_union);
 	pack_float_to_bytes(transmit_data, 25, testfloat_union);
 	pack_u16_to_bytes(transmit_data, 29, test_u16);
-	success_flag += CANFD_AsyncSend(CANFD_STATUS_ID, 32, transmit_data);
+	// 使用节点 ID 构建发送 ID (高 16 位为节点 ID)
+	success_flag +=
+		CANFD_AsyncSend(build_can_id(CANFD_STATUS_ID), 32, transmit_data);
 
 	// 打包 config 数据 - 只清零实际使用的 24 字节
 	memset(transmit_data, 0, 24);
@@ -544,7 +679,9 @@ u8 CAN_transmiter::CANFD_all_Send() {
 	pack_float_to_bytes(transmit_data, 3, target_current_union);
 	pack_float_to_bytes(transmit_data, 7, target_velocity_union);
 	pack_float_to_bytes(transmit_data, 11, target_angle_union);
-	success_flag += CANFD_AsyncSend(CANFD_CONFIG_ID, 24, transmit_data);
+	// 使用节点 ID 构建发送 ID (高 16 位为节点 ID)
+	success_flag +=
+		CANFD_AsyncSend(build_can_id(CANFD_CONFIG_ID), 24, transmit_data);
 
 	return success_flag;
 }
@@ -557,7 +694,8 @@ u8 CAN_transmiter::CANFD_all_Send() {
 void CAN_transmiter::communication_check() {
 	// CAN0 发送数据标志
 	if (SET == can0_send_flag) {
-		// printf("\r\n can0 %X receive data:", receive_message.rx_efid);
+		// CAN_DEBUG_PRINT("\r\n can0 %X receive data:",
+		// receive_message.rx_efid);
 		update();
 		// CAN0_transmiter.CAN_all_Send();
 		CANFD_all_Send();
@@ -567,11 +705,19 @@ void CAN_transmiter::communication_check() {
 	// 处理所有接收到的 CAN 消息（从环形缓冲区中）
 	can_receive_message_struct current_message;
 	while (dequeue_rx_message(current_message)) {
-		// printf("\r\n can0 %X receive data:", current_message.rx_efid);
-		// for (i = 0; i < current_message.rx_dlen; i++) {
-		// 	printf(" %02x", current_message.rx_data[i]);
+		// CAN_DEBUG_PRINT("\r\n can0 %X receive data:",
+		// current_message.rx_efid); for (i = 0; i < current_message.rx_dlen;
+		// i++) { 	CAN_DEBUG_PRINT(" %02x", current_message.rx_data[i]);
 		// }
-		if (current_message.rx_efid == CANFD_CMD_ID) {
+		// 检查消息是否是发给本节点的 (检查高 16 位)
+		if (!is_message_for_me(current_message.rx_efid)) {
+			continue; // 不是发给本节点的消息，跳过
+		}
+
+		// 提取基础 ID (低 16 位，去除高 16 位节点 ID 部分)
+		u32 base_id = current_message.rx_efid & 0xFFFF;
+
+		if (base_id == CANFD_CMD_ID) {
 			// 控制模式
 			FOC.control_mode = current_message.rx_data[0];
 			// 目标电压限制
@@ -611,7 +757,7 @@ void CAN_transmiter::communication_check() {
 			FOC.ang_loop_p = DEFAULT_angle_loop_p * P_config / voltage;
 			FOC.ang_angloop_p = DEFAULT_angle_angloop_p * P_config / voltage;
 			FOC.ang_MIT_p = DEFAULT_angle_MIT_p * P_config / voltage;
-		} else if (current_message.rx_efid == CANFD_RESET_ID) {
+		} else if (base_id == CANFD_RESET_ID) {
 			u8 first_byte = current_message.rx_data[0];
 			u8 eigth_byte = current_message.rx_data[7];
 			// 电机重置
@@ -638,17 +784,17 @@ void CAN_transmiter::communication_check() {
 				app_prepare_deep_sleep(true);
 				// CAN_Sleep();
 			}
-		} else if (current_message.rx_efid == CANFD_VERSION_ID) {
+		} else if (base_id == CANFD_VERSION_ID) {
 			// 处理版本号请求，发送当前系统版本信息
 			Version.sendVersionInfoViaCan();
-		} else if (current_message.rx_efid == CANFD_BOOT_ID) {
+		} else if (base_id == CANFD_BOOT_ID) {
 			motor_sleep();
 			flashEEP.save_system_config(false);
 			fmc_unlock();
 			OTA_SET(n_APP_LATEST_EN_ADDR, OTA_NOT_AVAL); // 设置 APP 为不激活
 			fmc_lock();
 			jumpToBOOT();
-		} else if (current_message.rx_efid == 0x00000102) {
+		} else if (base_id == CANFD_OTA_ACK_ID) {
 			volatile u32 *flash_ptr = (volatile u32 *)n_APP_LATEST_EN_ADDR;
 			u32 app_enable = *flash_ptr;
 			flash_ptr = (volatile u32 *)n_APP_LATEST_CHECK_ADDR;
@@ -657,10 +803,86 @@ void CAN_transmiter::communication_check() {
 			transmit_data[1] = 0xAC;
 			delay_1ms(1);
 			if (app_enable == OTA_AVAL && app_check == OTA_AVAL) {
-				CANFD_AsyncSend(CANFD_OTA_ACK_ID, 2, transmit_data);
+				CANFD_AsyncSend(build_can_id(CANFD_OTA_ACK_ID), 2,
+								transmit_data);
+			}
+		}
+		// 设置节点 ID 命令 (基础 ID: 0x0400)
+		else if (base_id == CANFD_SET_NODE_ID) {
+			// 打印接收到的原始数据
+			CAN_DEBUG_PRINT(
+				"SET_NODE_ID: rx_dlen=%d, data[0]=%02X data[1]=%02X\r\n",
+				current_message.rx_dlen, current_message.rx_data[0],
+				current_message.rx_data[1]);
+			// 解析新节点 ID - 支持 1 字节或 2 字节格式
+			u16 new_node_id;
+			if (current_message.rx_dlen >= 2) {
+				new_node_id = unpack_bytes_to_u16(current_message.rx_data, 0);
+			} else {
+				new_node_id =
+					current_message.rx_data[0]; // 只发送 1 字节时直接使用
+			}
+			u16 old_node_id = node_id; // 保存旧节点 ID 用于构建响应 ID
+			CAN_DEBUG_PRINT(
+				"SET_NODE_ID: recv new_id=%d (0x%04X), old_id=%d\r\n",
+				new_node_id, new_node_id, old_node_id);
+
+			if (new_node_id <= MAX_NODE_ID) {
+				u8 save_status = save_node_id_to_flash(new_node_id);
+				CAN_DEBUG_PRINT(
+					"SET_NODE_ID: save_status=%d, current node_id=%d\r\n",
+					save_status, node_id);
+				if (save_status == FLASH_EEPROM_OK) {
+					// 发送确认响应 - 使用旧节点 ID 构建响应 ID
+					// 响应数据格式：[status:1byte][new_node_id:2byte] = 3 字节
+					transmit_data[0] = 0x01;					 // 成功
+					transmit_data[1] = (u8)(new_node_id & 0xFF); // 新 ID 低字节
+					transmit_data[2] =
+						(u8)((new_node_id >> 8) & 0xFF); // 新 ID 高字节
+					CAN_DEBUG_PRINT("SET_NODE_ID: SUCCESS, send response with "
+									"old_id=%d, new_id_bytes=%02X %02X\r\n",
+									old_node_id, transmit_data[1],
+									transmit_data[2]);
+					// 注意：这里不修改 node_id，因为 save_node_id_to_flash
+					// 已经更新了 但构建响应时需要用旧 ID，所以临时修改
+					node_id = old_node_id;
+					CANFD_AsyncSend(build_can_id(CANFD_SET_NODE_ID), 3,
+									transmit_data); // 发送 3 字节
+					node_id = new_node_id;			// 恢复新 ID
+					CAN_DEBUG_PRINT("SET_NODE_ID: node_id updated to %d\r\n",
+									node_id);
+				} else {
+					// Flash 写入失败，发送错误响应
+					CAN_DEBUG_PRINT(
+						"SET_NODE_ID: Flash write FAILED, status=%d\r\n",
+						save_status);
+					transmit_data[0] = 0x00; // 失败
+					transmit_data[1] = (u8)(new_node_id & 0xFF);
+					transmit_data[2] = (u8)((new_node_id >> 8) & 0xFF);
+					node_id = old_node_id;
+					CANFD_AsyncSend(build_can_id(CANFD_SET_NODE_ID), 3,
+									transmit_data);
 				}
 			} else {
-			printf("Unknown CAN ID: %X\n", current_message.rx_efid);
+				// 发送错误响应 - 使用旧节点 ID 构建响应 ID
+				CAN_DEBUG_PRINT("SET_NODE_ID: invalid new_id=%d (max=%d)\r\n",
+								new_node_id, MAX_NODE_ID);
+				transmit_data[0] = 0x00; // 失败
+				transmit_data[1] = (u8)(new_node_id & 0xFF);
+				transmit_data[2] = (u8)((new_node_id >> 8) & 0xFF);
+				node_id = old_node_id; // 临时恢复旧 ID 用于构建响应
+				CANFD_AsyncSend(build_can_id(CANFD_SET_NODE_ID), 3,
+								transmit_data);
+				// 保持原 ID 不变
+			}
+		}
+		// 查询节点 ID 命令 (基础 ID: 0x0402)
+		else if (base_id == CANFD_GET_NODE_ID) {
+			pack_u16_to_bytes(transmit_data, 0, get_node_id());
+			CANFD_AsyncSend(build_can_id(CANFD_GET_NODE_ID), 2, transmit_data);
+		} else {
+			CAN_DEBUG_PRINT("Unknown CAN ID: %X (node_id=%d)\n",
+							current_message.rx_efid, node_id);
 		}
 	}
 }
@@ -682,7 +904,7 @@ u8 CAN_transmiter::CAN_Sleep() {
  * @retval None
  */
 u8 CAN_transmiter::CAN_Wakeup() {
-	printf("can wake\r\n");
+	CAN_DEBUG_PRINT("can wake\r\n");
 	is_sleep = false;
 	canfd_config();
 
@@ -718,13 +940,13 @@ void CAN0_RX0_IRQHandler(void) {
 	if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFF0) != RESET) {
 		// FIFO0 满中断
 		can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFF0);
-		printf("CAN FIFO0 full\n");
+		CAN_DEBUG_PRINT("CAN FIFO0 full\n");
 	}
 
 	if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFO0) != RESET) {
 		// FIFO0 溢出中断
 		can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFO0);
-		printf("CAN FIFO0 overflow\n");
+		CAN_DEBUG_PRINT("CAN FIFO0 overflow\n");
 	}
 }
 
@@ -766,13 +988,13 @@ void DMA0_Channel5_IRQHandler(void) {
 u8 CAN_transmiter::CAN_AsyncSend(u32 id, u8 length, u8 *data) {
 	// 检查数据长度是否符合 CAN 规范
 	if (length > 8) {
-		printf("CAN data length exceeds maximum of 8 bytes\r\n");
+		CAN_DEBUG_PRINT("CAN data length exceeds maximum of 8 bytes\r\n");
 		return 0;
 	}
 
 	// 检查数据指针是否有效
 	if (data == nullptr) {
-		printf("Invalid data pointer\r\n");
+		CAN_DEBUG_PRINT("Invalid data pointer\r\n");
 		return 0;
 	}
 
@@ -793,7 +1015,8 @@ u8 CAN_transmiter::CAN_AsyncSend(u32 id, u8 length, u8 *data) {
 	// 检查是否成功获取 mailbox
 	if (transmit_mailbox == CAN_NOMAILBOX) {
 		// 没有可用的 mailbox，启用发送中断以便在邮箱可用时重试
-		printf("No available mailbox for CAN transmission, enabling TX "
+		CAN_DEBUG_PRINT(
+			"No available mailbox for CAN transmission, enabling TX "
 			"interrupt\r\n");
 		// 可以设置一个标志位，当邮箱可用时发送
 		// 在实际应用中，可以维护一个待发送队列
@@ -815,13 +1038,13 @@ u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
 	u8 valid_length = length;
 	// 检查 CANFD 模式是否启用
 	if (!(CAN_CTL(CAN0) & CAN_CTL_DFZ)) {
-		printf("CANFD mode not enabled\r\n");
+		CAN_DEBUG_PRINT("CANFD mode not enabled\r\n");
 		return 0;
 	}
 
 	// 检查数据指针是否有效
 	if (data == nullptr) {
-		printf("Invalid data pointer\r\n");
+		CAN_DEBUG_PRINT("Invalid data pointer\r\n");
 		return 0;
 	}
 
@@ -842,7 +1065,7 @@ u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
 		} else if (length > 48 and length < 65) {
 			valid_length = 64;
 		} else {
-			printf("CANFD data length error\r\n");
+			CAN_DEBUG_PRINT("CANFD data length error\r\n");
 			return 0;
 		}
 	}
@@ -872,7 +1095,8 @@ u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
 	// 检查是否成功获取 mailbox
 	if (transmit_mailbox == CAN_NOMAILBOX) {
 		// 没有可用的 mailbox，启用发送中断以便在邮箱可用时重试
-		printf("No available mailbox for CANFD transmission, enabling TX "
+		CAN_DEBUG_PRINT(
+			"No available mailbox for CANFD transmission, enabling TX "
 			"interrupt\r\n");
 		return 0;
 	}

Robot_V2/device/Can.h

@@ -8,6 +8,7 @@ extern "C" {
 
 #include <cstdint>
 #include "gd32c10x_can.h"
+#include "config.h"
 
 // 定义一个联合体类型用于 float 和 byte 数组之间的转换
 typedef union {
@@ -66,7 +67,7 @@ void can_loopback_test(void);
 
 /*!
 	\brief CAN 通信类
-	\note  封装CAN发送和接收功能
+	\note  封装 CAN 发送和接收功能，支持多电机节点 ID 隔离
 */
 class CAN_transmiter {
 
@@ -75,6 +76,7 @@ class CAN_transmiter {
 	
 	bool is_sleep = false; // 是否休眠
 
+	u16 node_id; // 本节点 ID(0-254)，使用 CAN ID 高 8 位存储 (在 init() 中初始化为 DEFAULT_NODE_ID)
 	u8 Target_Control_Mode = 0; // 目标控制模式
 	u8 controller_Mode = 0;		// 当前模式
 	short mcu_temp = 0;			// MCU 温度
@@ -114,6 +116,11 @@ class CAN_transmiter {
 	bool is_rx_buffer_empty();
 	bool dequeue_rx_message(can_receive_message_struct& message);
 	
+  public:
+	// 节点 ID 相关辅助函数 (使用高 16 位存储节点 ID)
+	u32 build_can_id(u32 base_id);			// 根据节点 ID 构建 CAN ID，格式：[节点 ID(16 位)][基础 ID(16 位)]
+	bool is_message_for_me(u32 received_id); // 判断消息是否发给本节点
+
   public:
 	// 添加构造函数声明
 	u8 init(void);
@@ -127,12 +134,18 @@ class CAN_transmiter {
 	bool ThermalStatus = 0;							 // 热能状态码
 	void communication_check();						 // 通信检查
 	u8 CAN_Sleep();									 // CAN 进入睡眠
-	u8 CAN_Wakeup();								 // CAN进入睡眠
+	u8 CAN_Wakeup();								 // CAN 唤醒
 	u8 CAN_AsyncSend(u32 ID, u8 length, u8 *data);	 // CAN 异步发送 (使用 DMA)
 	u8 CANFD_AsyncSend(u32 ID, u8 length, u8 *data); // CANFD 异步发送 (使用 DMA)
 	u8 CAN_all_Send();								 // CAN 发送
 	u8 CANFD_all_Send();							 // CANFD 发送
 	
+	// 节点 ID 管理接口
+	u16 get_node_id();						// 获取当前节点 ID
+	void set_node_id(u16 new_id);			// 设置节点 ID
+	u8 load_node_id_from_flash();			// 从 Flash 加载节点 ID
+	u8 save_node_id_to_flash(u16 new_id);	// 保存节点 ID 到 Flash
+	
 	// 中断处理函数需要访问的公共接口
 	void enqueue_rx_message_from_isr(const can_receive_message_struct& message) {
 		if (!is_rx_buffer_full()) {

Robot_V2/device/ang_sensor.cpp

@@ -11,6 +11,13 @@
 #include <cstring>
 #include <stdint.h>
 
+// ANG_SENS 调试宏定义
+#if ANG_SENS_DEBUG
+#define ANG_SENS_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define ANG_SENS_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
 #define ANG_SPI_CS_ENABLE() gpio_bit_reset(GPIOA, GPIO_PIN_15)
 #define ANG_SPI_CS_DISABLE() gpio_bit_set(GPIOA, GPIO_PIN_15)
 #define DRV_SPI_CS_ENABLE() gpio_bit_reset(GPIOB, GPIO_PIN_14)
@@ -113,7 +120,7 @@ int spi_rw_half_word_dma(uint32_t spi_periph, uint16_t tx_data,
 		// 禁用 DMA 通道
 		dma_channel_disable(DMA0, DMA_CH2);
 		dma_channel_disable(DMA0, DMA_CH1);
-		printf("SPI DMA transfer timeout\r\n");
+		ANG_SENS_DEBUG_PRINT("SPI DMA transfer timeout\r\n");
 		return -1;
 	}
 
@@ -174,7 +181,7 @@ void KTH7823_spi_init(void) {
 	spi_parameter_struct spi_init_str;
 	spi_struct_para_init(&spi_init_str);
 
-	/* SPI参数：16bit, 主机, 全双工, CPOL=1 CPHA=1, MSB first */
+	/* SPI 参数：16bit, 主机，全双工，CPOL=1 CPHA=1, MSB first */
 	spi_init_str.device_mode = SPI_MASTER;
 	spi_init_str.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
 	spi_init_str.frame_size = SPI_FRAMESIZE_16BIT;
@@ -232,8 +239,7 @@ inline float angle_sensor::read_sensorAngle(void) {
 
 	// 仅在调试模式下输出错误，避免发布版本中的 I/O 开销
 	if (result != 0) {
-		// 使用更高效的串口输出替代printf（如果可用）
-		printf("Error reading angle from sensor.\n");
+		ANG_SENS_DEBUG_PRINT("Error reading angle from sensor.\n");
 	}
 
 	return (float)FAULT_RECEIVE;

Robot_V2/device/test.cpp

@@ -1,6 +1,14 @@
 #include "adc.h"
+#include "config.h"
 #include <cstdio>
 
+// TEST 调试宏定义
+#if TEST_DEBUG
+#define TEST_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define TEST_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
 constexpr int status_print = 0;
 extern sampler sampler;
 void test_1111() {
@@ -9,17 +17,17 @@ void test_1111() {
 	// can_config();
 	if (status_print) {
 		/* value print */
-		printf(" the temperature data is %2.2f degrees Celsius\r\n",
+		TEST_DEBUG_PRINT(" the temperature data is %2.2f degrees Celsius\r\n",
 			   sampler.get_mcu_temp());
-		printf(" the drv_temperature data is %2.2f degrees Celsius\r\n",
+		TEST_DEBUG_PRINT(" the drv_temperature data is %2.2f degrees Celsius\r\n",
 			   sampler.get_drv_temp());
-		printf(" the U current data is %2.2f mA\r\n", sampler.get_current('U'));
-		printf(" the V current data is %2.2f mA\r\n", sampler.get_current('V'));
-		printf(" the W current data is %2.2f mA\r\n", sampler.get_current('W'));
-		printf(" the VBUS is %2.2f V\r\n", sampler.get_vbus_voltage());
-		// printf(" the angle is %2.2f\r\n", tle5012b_read());
+		TEST_DEBUG_PRINT(" the U current data is %2.2f mA\r\n", sampler.get_current('U'));
+		TEST_DEBUG_PRINT(" the V current data is %2.2f mA\r\n", sampler.get_current('V'));
+		TEST_DEBUG_PRINT(" the W current data is %2.2f mA\r\n", sampler.get_current('W'));
+		TEST_DEBUG_PRINT(" the VBUS is %2.2f V\r\n", sampler.get_vbus_voltage());
+		// TEST_DEBUG_PRINT(" the angle is %2.2f\r\n", tle5012b_read());
 
-		printf("\n----------------------------------------------------\n");
+		TEST_DEBUG_PRINT("\n----------------------------------------------------\n");
 	}
 	// can_loopback_test();
 }

Robot_V2/main.cpp

@@ -10,6 +10,13 @@
 #include "initial.h"
 #include "systick.h"
 
+// MAIN 调试宏定义
+#if MAIN_DEBUG
+#define MAIN_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define MAIN_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
 extern CAN_transmiter CAN0_transmiter;		// CAN 初始化
 extern sampler sampler;						// 采样器
 extern angle_sensor KTH7823;				// 角度传感器
@@ -41,9 +48,9 @@ int main(void) {
 	u8 init_status = hardware_init();
 
 	while (init_status) { // 初始化检测
-		std::printf("初始化失败\r\n");
+		MAIN_DEBUG_PRINT("初始化失败\r\n");
 	}
-	OTA_initial(); //  OTA初始化,A/B分区处理
+	OTA_initial(); //  OTA 初始化，A/B 分区处理
 
 	angsens_MG_check(); // 角度传感器磁感应强度测试
 	watchdog_init(50);	// 看门狗初始化
@@ -70,11 +77,16 @@ u8 hardware_init(void) {
 	u8 init_status = 0;
 	init_status += KTH7823.init(); // 角度传感器初始化
 	init_status += sampler.init(); // 采样器初始化
-	flashEEP.init(); // EEPROM初始化，必须放在角度卡尔曼之前，角度传感器之后
+
+	// 先初始化 CAN，确保节点 ID 被正确设置
+	// CAN 初始化会先设置默认节点 ID，然后从 Flash 加载
+	init_status += CAN0_transmiter.init(); // CAN 初始化
+
+	// EEPROM 初始化 (必须在 CAN 初始化之后，因为会读取节点 ID)
+	flashEEP.init(); // EEPROM 初始化
 
 	init_status += Angle_kalman.init(KTH7823.getAngle()); // 角度滤波初始化
 	init_status += Vel_kalman.init(0.0f);				  // 速度滤波初始化
-	init_status += CAN0_transmiter.init();				  // CAN初始化
 	init_status += FOC.init();							  // FOC 初始化
 	return init_status;
 }
@@ -142,7 +154,7 @@ void do_task(u32 currentTasks) {
 		power_manage();
 	}
 	if (currentTasks & (1 << TASK_CAN_TRANSMIT)) {				  // CAN 通信
-		CAN0_transmiter.test_u16 = cnt_test;	   // 负载检测
+		CAN0_transmiter.test_u16 = CAN0_transmiter.get_node_id(); // 负载检测
 		cnt_test = 0;
 		CAN0_transmiter.can0_send_flag = SET;
 		CAN0_transmiter.communication_check();

Robot_V2/sys/config.h

@@ -10,12 +10,15 @@
 #define OTA_DEBUG 1
 #define SLEEP_DEBUG 1
 #define ANG_SENS_DEBUG 1
+#define CAN_DEBUG 1
+#define MAIN_DEBUG 1
+#define TEST_DEBUG 1
 
 // 版本号定义 - 可根据实际项目进行调整
 constexpr u16 SOFTWARE_VERSION_MAJOR = 26;
 constexpr u16 SOFTWARE_VERSION_MINOR = 3;
-constexpr u16 SOFTWARE_VERSION_PATCH = 9;
-constexpr u16 SOFTWARE_VERSION_BUILD = 1;
+constexpr u16 SOFTWARE_VERSION_PATCH = 15;
+constexpr u16 SOFTWARE_VERSION_BUILD = 4;
 
 constexpr u16 HARDWARE_VERSION_MAJOR = 25;
 constexpr u16 HARDWARE_VERSION_MINOR = 12;
@@ -40,6 +43,14 @@ constexpr u32 FLASH_EMPTY = 0xFFFFFFFF;			  // 空数据
 constexpr u32 SLEEP_ENABLE = 0x11111111;		  // 睡眠使能
 constexpr u32 SLEEP_DISABLE = 0x00000000;		  // 睡眠禁止
 
+// 节点 ID 配置 (用于多电机 CAN 总线隔离)
+// 使用 CAN ID 高 16 位 (bits 31-16) 存储节点 ID，低 16 位 (bits 15-0) 存储基础 ID
+// 格式：[节点 ID(16 位)][基础 ID(16 位)]，例如：node_id=1, base_id=0x0200 → 0x00010200
+constexpr u32 NODE_ID_CONFIG_ADDR = 0x0801E800; // 节点 ID 存储地址
+constexpr u16 DEFAULT_NODE_ID = 1;				// 默认节点 ID
+constexpr u16 BROADCAST_NODE_ID = 0xFFFF;		// 广播 ID (所有节点响应)
+constexpr u16 MAX_NODE_ID = 0xFFFE;				// 最大有效节点 ID (0~0xFFFE)
+
 // BOOT 相关
 constexpr u32 OTA_CONFIG_NUM = 6;
 constexpr u32 n_APP_LATEST_AVAL_ADDR = 0x0801E000;	// 最新 APP 可用地址
@@ -102,7 +113,8 @@ constexpr float DEFAULT_vel_angloop_p = 0.4f / 100; // 速度 速度-角度P
 constexpr float vel_angloop_Ki = 5.0f;				// 速度 速度 - 角度 I
 constexpr float vel_angloop_Kd = 5e-05f;			// 速度 速度 - 角度 D
 
-constexpr float DEFAULT_angle_angloop_p = 150.0f / 100 * 12; // 角度 速度-角度P
+constexpr float DEFAULT_angle_angloop_p =
+	150.0f / 100 * 12;					 // 角度 速度 - 角度 P
 constexpr float ang_angloop_Ki = 0.00f;	 // 角度 速度 - 角度 I
 constexpr float ang_angloop_Kd = 8e-04f; // 角度 速度 - 角度 D
 
@@ -143,22 +155,29 @@ constexpr u16 LUT_MASK = (LUT_SIZE - 1);
 constexpr u16 LUT_SCALE = (LUT_SIZE / (2.0f * PI));
 
 // CAN 相关
+// 注意：以下为 CAN 基础 ID（只保留低 16 位），实际发送/接收时会自动叠加节点 ID
+// 到高 16 位 格式：[节点 ID(16 位)][基础 ID(16 位)] 例如：节点 ID=1，发送命令
+// ID = (1 << 16) | CANFD_CMD_ID = 0x00010200
 constexpr u16 DEV_CAN0_ID = 0x0000;
 constexpr u16 DEV_CAN0_MASK = 0x0000;
 constexpr u16 DEV_CAN_LOOPBACK_ID = 0x0000;
-// 反馈ID
-constexpr u32 CANFD_STATUS_ID = 0x00010100;
-constexpr u32 CANFD_CONFIG_ID = 0x00010101;
-constexpr u32 CANFD_VERSION_ID = 0x00010000;
-// 命令ID
-constexpr u32 CANFD_CMD_ID = 0x00010200;
-constexpr u32 CANFD_RESET_ID = 0x00010301;
-// OTA相关ID
-constexpr u32 CANFD_BOOT_ID = 0x00000000;
-constexpr u32 CANFD_OTA_REQ_ID = 0x00000100;
-constexpr u32 CANFD_OTA_DATA_ID = 0x00000101;
-constexpr u32 CANFD_OTA_ACK_ID = 0x00000102;
-constexpr u32 CANFD_OTA_WAIT_ID = 0x00000103;
+// 反馈基础 ID
+constexpr u16 CANFD_STATUS_ID = 0x0100;	 // 状态反馈基础 ID
+constexpr u16 CANFD_CONFIG_ID = 0x0101;	 // 配置信息基础 ID
+constexpr u16 CANFD_VERSION_ID = 0x00FF; // 版本信息基础 ID
+// 命令基础 ID
+constexpr u16 CANFD_CMD_ID = 0x0200;   // 控制命令基础 ID
+constexpr u16 CANFD_RESET_ID = 0x0301; // 重置命令基础 ID
+// 节点 ID 管理基础 ID
+constexpr u16 CANFD_SET_NODE_ID = 0x0400; // 设置节点 ID 基础 ID
+constexpr u16 CANFD_GET_NODE_ID = 0x0401; // 查询节点 ID 基础 ID
+
+// OTA 相关基础 ID 不受到node ID影响
+constexpr u16 CANFD_BOOT_ID = 0x0000; // BOOT 模式基础 ID (进入 BOOT 使用此 ID)
+constexpr u16 CANFD_OTA_REQ_ID = 0x0100;  // OTA 请求基础 ID
+constexpr u16 CANFD_OTA_DATA_ID = 0x0101; // OTA 数据基础 ID
+constexpr u16 CANFD_OTA_ACK_ID = 0x0102;  // OTA 确认基础 ID
+constexpr u16 CANFD_OTA_WAIT_ID = 0x0103; // OTA 等待基础 ID
 
 // ADC
 constexpr u8 ADC_FILTER_SIZE = 6;

Robot_V2/sys/flash.cpp

@@ -10,6 +10,20 @@
 #include <cstdio>
 #include <cstring>
 
+// EEP 调试宏定义
+#if EEP_DEBUG
+#define EEP_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define EEP_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
+// OTA 调试宏定义
+#if OTA_DEBUG
+#define OTA_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define OTA_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
 FlashEEPROM flashEEP = FlashEEPROM();
 extern angle_sensor KTH7823;
 extern CAN_transmiter CAN0_transmiter;
@@ -104,10 +118,8 @@ u8 FlashEEPROM::read_saved_system_config(void) {
 
 		crc_data_register_reset(); // 确保 CRC 计算从初始状态开始
 		CRC_NUM = crc_block_data_calculate((uint32_t *)data, CONFIG_SAVED_NUM);
-
-#if EEP_DEBUG
-		printf("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM, *((u32 *)next_address));
-#endif
+		EEP_DEBUG_PRINT("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM,
+						*((u32 *)next_address));
 		if (CRC_NUM != *((u32 *)next_address)) { // CRC 错误
 			for (u8 i = 0; i < CONFIG_SAVED_NUM; i++) {
 				data[i] = DEFAULT_VALUE;
@@ -189,9 +201,7 @@ FlashEepromStatus FlashEEPROM::readFloat(u8 virtualAddr, float *data) const {
 				u32 float_data = data_word & DATA_FLOAT_MASK;
 				// 使用内存拷贝将处理后的数据解释为 float
 				memcpy(data, &float_data, SIZE_FLOAT);
-#if EEP_DEBUG
-				printf("read:0x%x=%f\r\n", address, *data);
-#endif
+				EEP_DEBUG_PRINT("read:0x%x=%f\r\n", address, *data);
 				return FLASH_EEPROM_OK;
 			}
 		}
@@ -210,8 +220,8 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
 	// 查找下一个可写入的位置
 	u32 next_address = EEPROM_START_ADDRESS;
 	u32 data_read;
-	// 插入虚拟地址到低8位	格式: [data:16bit][reserved:8bit][addr:8bit]
-	data = (data & DATA_U16_MASK) | (u32)virtualAddr;
+	// 构建要写入的 32 位数据：格式 [data:16bit][reserved:8bit][addr:8bit]
+	u32 data_word_to_write = ((u32)data << 16) | (u32)virtualAddr;
 
 	for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
 		 address >= EEPROM_DATA_START_ADDRESS; address -= SIZE_U32) {
@@ -221,11 +231,12 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
 
 		if ((data_read & DATA_ADDR_MASK) == (u32)virtualAddr) { // 虚拟地址相同
 			if ((data_read & DATA_U16_MASK) ==
-				(data & DATA_U16_MASK)) { // 数据相同
+				(data_word_to_write & DATA_U16_MASK)) { // 数据相同
 #if EEP_DEBUG
 				data_read = data_read & DATA_U16_MASK;
 				u16 float_data_read = *((u16 *)&data_read);
-				printf("Found data in:0x%x=%u\r\n", address, data_read);
+				EEP_DEBUG_PRINT("Found data in:0x%x=%u\r\n", address,
+								data_read);
 #endif
 				return FLASH_EEPROM_OK;
 			} else {
@@ -251,18 +262,15 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
 
 	// 如果有足够空间，直接写入
 	if (next_address < EEPROM_END_ADDRESS) {
-		u32 data_word = ((u32)data << 16) | (u32)virtualAddr;
-
-		fmc_state_enum fmc_status = write_ADDRESS(next_address, data_word);
+		fmc_state_enum fmc_status =
+			write_ADDRESS(next_address, data_word_to_write);
 
 		if (fmc_status != FMC_READY) {
 			return FLASH_EEPROM_WRITE_ERROR;
 		}
 		return FLASH_EEPROM_OK;
 	} else { // 空间不足，需要格式化页面
-#if EEP_DEBUG
-		printf("no enough space\r\n");
-#endif
+		EEP_DEBUG_PRINT("no enough space\r\n");
 		FlashEepromStatus status = format();
 		if (status == FLASH_EEPROM_OK) {
 			status = save_system_config(false);
@@ -286,7 +294,7 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
 
 	// 将完整的 float 数据复制到 32 位变量中
 	memcpy(&data_word, &data, SIZE_FLOAT);
-	// 插入虚拟地址到低8位	格式: [data:24bit][addr:8bit]
+	// 插入虚拟地址到低 8 位	格式：[data:24bit][addr:8bit]
 	data_word = (data_word & DATA_FLOAT_MASK) | (u32)virtualAddr;
 
 	// 从 Flash 末尾开始向前搜索，找到最新的数据
@@ -303,7 +311,8 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
 #if EEP_DEBUG
 				data_word_read = data_word_read & DATA_FLOAT_MASK;
 				float float_data_read = *((float *)&data_word_read);
-				printf("Found data in:0x%x=%f\r\n", address, float_data_read);
+				EEP_DEBUG_PRINT("Found data in:0x%x=%f\r\n", address,
+								float_data_read);
 #endif
 				return FLASH_EEPROM_OK;
 			} else {
@@ -334,7 +343,7 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
 		u32 data_word_c = *((u32 *)next_address);
 		data_word_c = data_word_c & DATA_FLOAT_MASK;
 		float float_data = *((float *)&data_word_c);
-		printf("save:0x%x=%f\r\n", next_address, float_data);
+		EEP_DEBUG_PRINT("save:0x%x=%f\r\n", next_address, float_data);
 #endif
 		if (fmc_status != FMC_READY) {
 			return FLASH_EEPROM_WRITE_ERROR;
@@ -343,7 +352,7 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
 	} else {
 		// 空间不足，需要格式化页面
 #if EEP_DEBUG
-		printf("no enough space\r\n");
+		EEP_DEBUG_PRINT("no enough space\r\n");
 #endif
 		FlashEepromStatus status = format();
 		if (status == FLASH_EEPROM_OK) {
@@ -362,9 +371,7 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
  */
 FlashEepromStatus FlashEEPROM::format() {
 	fmc_state_enum fmc_status;
-#if EEP_DEBUG
-	printf("擦除页面\r\n");
-#endif
+	EEP_DEBUG_PRINT("擦除页面\r\n");
 
 	fmc_unlock();
 	fmc_status = fmc_page_erase(EEPROM_START_ADDRESS); // 擦除第一页
@@ -495,9 +502,8 @@ FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
 		// 如果有足够空间，直接写入 crc 值
 		if (next_address > EEPROM_START_ADDRESS) {
 			fmc_state_enum fmc_status = write_ADDRESS(next_address, CRC_NUM);
-#if EEP_DEBUG
-			printf("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM, *((u32 *)next_address));
-#endif
+			EEP_DEBUG_PRINT("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM,
+							*((u32 *)next_address));
 			// 检查写入是否成功
 			if (fmc_status != FMC_READY) {
 				EEPROMStatus = fmc_status;
@@ -505,9 +511,7 @@ FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
 			}
 		} else {
 			// 空间不足，需要格式化页面
-#if EEP_DEBUG
-			printf("no enough space\r\n");
-#endif
+			EEP_DEBUG_PRINT("no enough space\r\n");
 			FlashEepromStatus status = format();
 			if (status == FLASH_EEPROM_OK) {
 				status = save_system_config(false);
@@ -534,18 +538,18 @@ FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
  * @brief  设置 OTA 配置参数到 Flash
  *
  * 此函数用于更新存储在 Flash 中的 OTA 相关标志位（如 APP 可用、启用、校验等）。
- * GD32的Flash特性是：只能将1写为0，不能将0写为1。若要将0变为1，必须先擦除整个页面。
- * 因此，本函数通过读取同一页内的所有参数，擦除该页，然后重新写入有效的参数来实现“写1”操作。
+ * GD32 的 Flash 特性是：只能将 1 写为 0，不能将 0 写为 1。若要将 0 写为
+ * 1，必须先擦除整个页面。
+ * 因此，本函数通过读取同一页内的所有参数，擦除该页，然后重新写入有效的参数来实现"写
+ * 1"操作。
  *
  * @param  addr: 要设置的 Flash 地址
  * @param  data: 要写入的数据 (通常为 OTA_AVAL=0x00000000 或
  * OTA_NOT_AVAL=0xFFFFFFFF)
- * @retval FLASH_EEPROM_OK (0) 表示成功, 其他值表示失败
+ * @retval FLASH_EEPROM_OK (0) 表示成功，其他值表示失败
  */
 u8 OTA_SET(u32 addr, u32 data) {
-#if EEP_DEBUG
-	printf("OTA_prepare write%08x at %08x\r\n", data, addr);
-#endif
+	EEP_DEBUG_PRINT("OTA_prepare write%08x at %08x\r\n", data, addr);
 	fmc_state_enum fmc_status;
 	u32 temp_val[OTA_CONFIG_NUM]; // 临时数组，用于存储当前所有配置参数的值
 	volatile u32 *flash_ptr = (volatile u32 *)addr;
@@ -580,20 +584,17 @@ u8 OTA_SET(u32 addr, u32 data) {
 	flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
 	temp_val[5] = *flash_ptr;
 
-#if EEP_DEBUG
-	printf("OTA_prepare write%08x at %08x\r\n", data, addr);
+	EEP_DEBUG_PRINT("OTA_prepare write%08x at %08x\r\n", data, addr);
 	// 修复：完整输出所有 6 个配置项的值，便于调试
-	printf("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
+	EEP_DEBUG_PRINT("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
 					"BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n",
-		   temp_val[0], temp_val[1], temp_val[2], temp_val[3], temp_val[4],
-		   temp_val[5]);
-#endif
+					temp_val[0], temp_val[1], temp_val[2], temp_val[3],
+					temp_val[4], temp_val[5]);
 	// 4. 擦除包含所有配置参数的 Flash 页
 	fmc_status = fmc_page_erase(n_APP_LATEST_AVAL_ADDR);
 	if (fmc_status != FMC_READY) {
-#if EEP_DEBUG
-		printf("OTA_SET - Page erase failed! Status: %d\r\n", fmc_status);
-#endif
+		EEP_DEBUG_PRINT("OTA_SET - Page erase failed! Status: %d\r\n",
+						fmc_status);
 		return FLASH_EEPROM_ERASE_ERROR;
 	}
 
@@ -604,11 +605,9 @@ u8 OTA_SET(u32 addr, u32 data) {
 		if (current_addr != addr and temp_val[i] != OTA_NOT_AVAL) {
 			fmc_status = write_ADDRESS(current_addr, temp_val[i]);
 			if (fmc_status != FMC_READY) {
-#if EEP_DEBUG
-				printf("OTA_SET - Write backup value %08X failed at "
+				EEP_DEBUG_PRINT("OTA_SET - Write backup value %08X failed at "
 								"0x%08X!status:%d\r\n",
 								temp_val[i], current_addr, fmc_status);
-#endif
 				return FLASH_EEPROM_WRITE_ERROR;
 			}
 		}
@@ -629,10 +628,10 @@ u8 OTA_SET(u32 addr, u32 data) {
 	flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
 	temp_val[5] = *flash_ptr;
 	// 修复：完整输出所有 6 个配置项的值，便于调试
-	printf("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
+	EEP_DEBUG_PRINT("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
 					"BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n",
-		   temp_val[0], temp_val[1], temp_val[2], temp_val[3], temp_val[4],
-		   temp_val[5]);
+					temp_val[0], temp_val[1], temp_val[2], temp_val[3],
+					temp_val[4], temp_val[5]);
 #endif
 
 	return FLASH_EEPROM_OK;
@@ -677,7 +676,7 @@ void jumpToBOOT() {
 	app_entry();
 
 	// 如果程序执行到这里，说明跳转失败
-	printf("Jump to application failed!\r\n");
+	EEP_DEBUG_PRINT("Jump to application failed!\r\n");
 }
 
 /**
@@ -686,14 +685,12 @@ void jumpToBOOT() {
  * @retval fmc_state_enum: 操作状态
  */
 fmc_state_enum move_app_data() {
-	// 源地址: APPLATEST_START_ADDR (0x08011000)
-	// 目标地址: APPBACK_START_ADDR (0x08005000)
-	// 数据大小: APP_MAX_SIZE (0xC000 = 48KB)
+	// 源地址：APPLATEST_START_ADDR (0x08011000)
+	// 目标地址：APPBACK_START_ADDR (0x08005000)
+	// 数据大小：APP_MAX_SIZE (0xC000 = 48KB)
 
 	fmc_state_enum fmc_status = FMC_READY;
-#if OTA_DEBUG
-	printf("move_app_data\r\n");
-#endif
+	OTA_DEBUG_PRINT("move_app_data\r\n");
 	// 关闭全局中断以防止 Flash 操作期间的中断干扰
 	__disable_irq();
 	fmc_unlock();
@@ -710,7 +707,7 @@ fmc_state_enum move_app_data() {
 		if (fmc_status != FMC_READY) {
 			fmc_lock();
 #if OTA_DEBUG
-			printf("move_app_data erase error\r\n");
+			OTA_DEBUG_PRINT("move_app_data erase error\r\n");
 			delay_1ms(1000);
 #endif
 			__enable_irq(); // 重新开启中断
@@ -745,7 +742,7 @@ fmc_state_enum move_app_data() {
 			// 检查写入操作是否成功
 			if (fmc_status != FMC_READY) {
 #if OTA_DEBUG
-				printf(
+				OTA_DEBUG_PRINT(
 					"Flash write failed at offset 0x%08X with status: %d\r\n",
 					offset, fmc_status);
 				delay_1ms(1000);
@@ -776,15 +773,12 @@ fmc_state_enum move_app_data() {
 
 	// 比较 CRC 值，确保数据完整性
 	if (src_crc != dst_crc) {
-#if OTA_DEBUG
-		printf("APPbackup CRC mismatch: src_crc=0x%08X, dst_crc=0x%08X\r\n",
+		OTA_DEBUG_PRINT(
+			"APPbackup CRC mismatch: src_crc=0x%08X, dst_crc=0x%08X\r\n",
 			src_crc, dst_crc);
-#endif
 		return (fmc_state_enum)0xFF; // CRC 校验失败
 	}
-#if OTA_DEBUG
-	printf("APPbackup CRC OK\r\n");
-#endif
+	OTA_DEBUG_PRINT("APPbackup CRC OK\r\n");
 	// 设置备份应用可用标志
 	fmc_unlock();
 	OTA_SET(n_APP_BACKUP_AVAL_ADDR, OTA_AVAL);

Robot_V2/sys/flash.h

@@ -40,6 +40,7 @@ class FlashEEPROM {
 	static constexpr u8 ADDR_TARGET_VEL = 0x03;	  // 速度命令数据存储地址
 	static constexpr u8 ADDR_VOLTAGE_LIMIT = 0x4; // 电压限制
 	static constexpr u8 ADDR_VEL_LIMIT = 0x05;	  // 角度数据存储地址
+	static constexpr u8 ADDR_NODE_ID = 0x06;	  // 节点 ID 存储地址
 
 	bool angle_saved = false;
 	bool system_config_saved = false;

Robot_V2/sys/initial.cpp

@@ -11,6 +11,20 @@
 #include <cstdio>
 #include <cstring>
 
+// OTA 调试宏定义
+#if OTA_DEBUG
+#define OTA_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define OTA_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
+// EEP 调试宏定义
+#if EEP_DEBUG
+#define EEP_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define EEP_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
 extern CAN_transmiter CAN0_transmiter; // CAN 初始化
 VersionManager Version;
 
@@ -108,20 +122,23 @@ void VersionManager::sendVersionInfoViaCan() const {
 	versionData[22] = bootVersion.build & 0xFF;		   // 低字节
 	versionData[23] = (bootVersion.build >> 8) & 0xFF; // 高字节
 
-	// 使用CANFD发送函数发送版本信息
-	CAN0_transmiter.CANFD_AsyncSend(CANFD_VERSION_ID, 24, versionData);
+	// 使用 CANFD 发送函数发送版本信息，使用 build_can_id 构建带 node_id 的 CAN
+	// ID
+	CAN0_transmiter.CANFD_AsyncSend(
+		CAN0_transmiter.build_can_id(CANFD_VERSION_ID), 24, versionData);
 }
 
 void VersionManager::printVersions() const {
 	char versionStr[32];
 
-	printf(
+	OTA_DEBUG_PRINT(
 		"Software Version: %s\r\n",
 		versionToString(getSoftwareVersion(), versionStr, sizeof(versionStr)));
-	printf(
+	OTA_DEBUG_PRINT(
 		"Hardware Version: %s\r\n",
 		versionToString(getHardwareVersion(), versionStr, sizeof(versionStr)));
-	printf("BOOT Version: %s\r\n",
+	OTA_DEBUG_PRINT(
+		"BOOT Version: %s\r\n",
 		versionToString(getBootVersion(), versionStr, sizeof(versionStr)));
 }
 
@@ -177,36 +194,36 @@ void unused_pin_init() {
 u16 get_reset_cause(void) {
 	u16 cause = 0;
 	if (RESET != rcu_flag_get(RCU_FLAG_FWDGTRST)) {
-		// printf("Free Watchdog Timer Reset\r\n");
+		// OTA_DEBUG_PRINT("Free Watchdog Timer Reset\r\n");
 		cause = RCU_FLAG_FWDGTRST;
 	}
 	if (RESET != rcu_flag_get(RCU_FLAG_EPRST)) {
-		// printf("External Pin Reset\r\n");
+		// OTA_DEBUG_PRINT("External Pin Reset\r\n");
 		cause = RCU_FLAG_EPRST;
 	}
 
 	if (RESET != rcu_flag_get(RCU_FLAG_PORRST)) {
-		// printf("Power Reset\r\n");
+		// OTA_DEBUG_PRINT("Power Reset\r\n");
 		cause = RCU_FLAG_PORRST;
 	}
 
 	if (RESET != rcu_flag_get(RCU_FLAG_WWDGTRST)) {
-		// printf("Window Watchdog Timer Reset\r\n");
+		// OTA_DEBUG_PRINT("Window Watchdog Timer Reset\r\n");
 		cause = RCU_FLAG_WWDGTRST;
 	}
 
 	if (RESET != rcu_flag_get(RCU_FLAG_LPRST)) {
-		// printf("Low Power Reset\r\n");
+		// OTA_DEBUG_PRINT("Low Power Reset\r\n");
 		cause = RCU_FLAG_LPRST;
 	}
 
 	if (RESET != rcu_flag_get(RCU_FLAG_SWRST)) {
-		// printf("Software Reset\r\n");
+		// OTA_DEBUG_PRINT("Software Reset\r\n");
 		cause = RCU_FLAG_SWRST;
 	}
 	// 清除所有复位标志
 	rcu_all_reset_flag_clear();
-	// printf("cause:%d\r\n", cause);
+	// OTA_DEBUG_PRINT("cause:%d\r\n", cause);
 	return cause;
 }
 
@@ -227,7 +244,8 @@ void OTA_initial(void) {
 	flash_ptr1 = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
 	temp_val[5] = *flash_ptr1;
 	// 修复：完整输出所有 6 个配置项的值，便于调试
-	printf("APP:CHECK LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
+	OTA_DEBUG_PRINT(
+		"APP:CHECK LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
 		"BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n",
 		temp_val[0], temp_val[1], temp_val[2], temp_val[3], temp_val[4],
 		temp_val[5]);
@@ -237,9 +255,7 @@ void OTA_initial(void) {
 	volatile u32 *flash_ptr = (volatile u32 *)n_APP_LATEST_CHECK_ADDR;
 	u32 app_check = *flash_ptr;
 	if (app_check == OTA_NOT_AVAL) { // 新的 APP 刷入后第一次启动
-#if OTA_DEBUG
-		std::printf("APP enabled\r\n");
-#endif
+		OTA_DEBUG_PRINT("APP enabled\r\n");
 		move_app_data();
 	}
 
@@ -257,17 +273,13 @@ void OTA_initial(void) {
 	u32 back_check = *flash_ptr;
 
 	if (back_aval == OTA_NOT_AVAL) { // 如果 BACK 不可用
-#if OTA_DEBUG
-		std::printf("notaval\r\n");
-#endif
+		OTA_DEBUG_PRINT("notaval\r\n");
 		move_app_data();
 	} else if (back_aval == OTA_AVAL &&
 			   back_check == OTA_NOT_AVAL) { // BACK 已刷写，但未检查
-#if OTA_DEBUG
-		std::printf("aval\r\n");
-#endif
+		OTA_DEBUG_PRINT("aval\r\n");
 		move_app_data();
 	} else {
-		printf("check\r\n");
+		EEP_DEBUG_PRINT("check\r\n");
 	}
 }

Robot_V2/sys/systick.cpp

@@ -44,6 +44,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "motor.h"
 #include <cstdio>
 
+// SLEEP 调试宏定义
+#if SLEEP_DEBUG
+#define SLEEP_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
+#else
+#define SLEEP_DEBUG_PRINT(fmt, ...) ((void)0)
+#endif
+
 volatile static uint32_t delay;
 extern CAN_transmiter CAN0_transmiter;
 extern FlashEEPROM flashEEP;
@@ -149,9 +156,7 @@ void app_prepare_deep_sleep(bool save_data) {
 			address > SLEEP_CONFIG_START) { // 空数据且未到头跳过
 			continue;
 		} else { // 有数据的话读取
-#if SLEEP_DEBUG
-			printf("app sleep found %08x at %08x\r\n", sleep_enable, address);
-#endif
+			SLEEP_DEBUG_PRINT("app sleep found %08x at %08x\r\n", sleep_enable, address);
 			if (address == SLEEP_CONFIG_END - SIZE_U32) {
 				fmc_unlock();
 				fmc_state_enum fmc_status =
@@ -164,23 +169,19 @@ void app_prepare_deep_sleep(bool save_data) {
 				address = SLEEP_CONFIG_START - SIZE_U32; // 重新开始写入
 			}
 			address += SIZE_U32;
-#if SLEEP_DEBUG
-			printf("app sleep prepare write %08x at %08x\r\n", SLEEP_ENABLE,
+			SLEEP_DEBUG_PRINT("app sleep prepare write %08x at %08x\r\n", SLEEP_ENABLE,
 				   address);
-#endif
 			fmc_state_enum fmc_status =
 				write_ADDRESS(address, SLEEP_ENABLE); // 写入数据
 #if SLEEP_DEBUG
 			volatile u32 *flash_ptr = (volatile u32 *)address;
 			u32 sleep_check = *flash_ptr;
-			printf("app sleep wrote %08x at %08x\r\n", sleep_check, address);
+			SLEEP_DEBUG_PRINT("app sleep wrote %08x at %08x\r\n", sleep_check, address);
 #endif
 			if (fmc_status != FMC_READY) { // 写入失败报错
 				flashEEP.EEPROMStatus = FLASH_EEPROM_WRITE_ERROR;
-#if SLEEP_DEBUG
-				printf("app wrote %08x at %08x ERROR\r\n", SLEEP_ENABLE,
+				SLEEP_DEBUG_PRINT("app wrote %08x at %08x ERROR\r\n", SLEEP_ENABLE,
 					   address);
-#endif
 				return;
 			}
 			break;