diff --git a/Robot_V2.csolution.yml b/Robot_V2.csolution.yml
index 5b0406c..54608ea 100644
--- a/Robot_V2.csolution.yml
+++ b/Robot_V2.csolution.yml
@@ -33,9 +33,8 @@ solution:
             - project-context: Robot_V2.Release
           debugger:
             name: ST-Link@pyOCD
-            port: 3333
-            protocol: swd
             clock: 10000000
+            protocol: swd
 
   # List of different build configurations.
   build-types:
diff --git a/Robot_V2/Algorithm/CRC.cpp b/Robot_V2/Algorithm/CRC.cpp
deleted file mode 100644
index e965895..0000000
--- a/Robot_V2/Algorithm/CRC.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "CRC.h"
-#include <cstring>
-#include <stdint.h>
-
-CRC_Calculator CRC_Calculator;
-// 静态成员初始化
-bool CRC_Calculator::table_initialized = false;
-u32 CRC_Calculator::crc_table[256];
-
-/**
- * @brief 初始化CRC表
- */
-void CRC_Calculator::init_crc_table() {
-    if (table_initialized) {
-        return;
-    }
-    
-    uint32_t polynomial = 0xEDB88320; // CRC-32 IEEE 802.3标准多项式
-    
-    for (int i = 0; i < 256; i++) {
-        uint32_t crc = i;
-        for (int j = 0; j < 8; j++) {
-            if (crc & 1) {
-                crc = (crc >> 1) ^ polynomial;
-            } else {
-                crc >>= 1;
-            }
-        }
-        crc_table[i] = crc;
-    }
-    
-    table_initialized = true;
-}
-
-/**
- * @brief 更新CRC值
- * @param crc 当前CRC值
- * @param data 要处理的数据
- * @return 更新后的CRC值
- */
-uint32_t CRC_Calculator::update_crc(uint32_t crc, uint8_t data) {
-    // 确保表已初始化
-    if (!table_initialized) {
-        init_crc_table();
-    }
-    
-    uint8_t table_index = (crc ^ data) & 0xFF;
-    return (crc >> 8) ^ crc_table[table_index];
-}
-
-/**
- * @brief 计算单个float值的CRC32
- * @param data float值
- * @return CRC32校验值
- */
-uint32_t CRC_Calculator::calculate(const float& data) {
-    // 强制初始化CRC表（如果尚未初始化）
-    if (!table_initialized) {
-        init_crc_table();
-    }
-    
-    uint32_t crc = 0xFFFFFFFF;
-    
-    // 将float值按字节处理
-    const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&data);
-    for (size_t i = 0; i < sizeof(float); i++) {
-        crc = update_crc(crc, bytes[i]);
-    }
-    
-    return crc ^ 0xFFFFFFFF;
-}
-
-/**
- * @brief 计算float数组的CRC32
- * @param data float数组指针
- * @param length 数组长度
- * @return CRC32校验值
- */
-uint32_t CRC_Calculator::calculate(const float* data, size_t length) {
-    // 强制初始化CRC表（如果尚未初始化）
-    if (!table_initialized) {
-        init_crc_table();
-    }
-    
-    uint32_t crc = 0xFFFFFFFF;
-    
-    // 处理每个float值
-    for (size_t i = 0; i < length; i++) {
-        const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&(data[i]));
-        for (size_t j = 0; j < sizeof(float); j++) {
-            crc = update_crc(crc, bytes[j]);
-        }
-    }
-    
-    return crc ^ 0xFFFFFFFF;
-}
-
-/**
- * @brief 验证单个float值的CRC32
- * @param data float值
- * @param expected_crc 期望的CRC值
- * @return true表示校验成功，false表示校验失败
- */
-bool CRC_Calculator::verify(const float& data, uint32_t expected_crc) {
-    return calculate(data) == expected_crc;
-}
-
-/**
- * @brief 验证float数组的CRC32
- * @param data float数组指针
- * @param length 数组长度
- * @param expected_crc 期望的CRC值
- * @return true表示校验成功，false表示校验失败
- */
-bool CRC_Calculator::verify(const float* data, size_t length, uint32_t expected_crc) {
-    return calculate(data, length) == expected_crc;
-}
-
-/**
- * @brief 获取CRC表初始化状态
- * @return true表示已初始化，false表示未初始化
- */
-bool CRC_Calculator::isInitialized() {
-    return table_initialized;
-}
-
-/**
- * @brief 强制重新初始化CRC表
- */
-void CRC_Calculator::reinitialize() {
-    table_initialized = false;
-    init_crc_table();
-}
\ No newline at end of file
diff --git a/Robot_V2/Algorithm/CRC.h b/Robot_V2/Algorithm/CRC.h
deleted file mode 100644
index 8ad7965..0000000
--- a/Robot_V2/Algorithm/CRC.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef __CRC_H
-#define __CRC_H
-
-#include <cstdint>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "gd32c10x.h"
-
-#ifdef __cplusplus
-}
-#endif
-
-#ifdef __cplusplus
-
-#include <cstddef>
-
-class CRC_Calculator {
-private:
-    static bool table_initialized;
-    static uint32_t crc_table[256];
-    
-    /**
-     * @brief 初始化CRC表
-     */
-    static void init_crc_table();
-    
-    /**
-     * @brief 更新CRC值
-     * @param crc 当前CRC值
-     * @param data 要处理的数据
-     * @return 更新后的CRC值
-     */
-    static uint32_t update_crc(uint32_t crc, uint8_t data);
-
-public:
-    /**
-     * @brief 计算单个float值的CRC32
-     * @param data float值
-     * @return CRC32校验值
-     */
-    static uint32_t calculate(const float& data);
-    
-    /**
-     * @brief 计算float数组的CRC32
-     * @param data float数组指针
-     * @param length 数组长度
-     * @return CRC32校验值
-     */
-    static uint32_t calculate(const float* data, size_t length);
-    
-    /**
-     * @brief 验证单个float值的CRC32
-     * @param data float值
-     * @param expected_crc 期望的CRC值
-     * @return true表示校验成功，false表示校验失败
-     */
-    static bool verify(const float& data, uint32_t expected_crc);
-    
-    /**
-     * @brief 验证float数组的CRC32
-     * @param data float数组指针
-     * @param length 数组长度
-     * @param expected_crc 期望的CRC值
-     * @return true表示校验成功，false表示校验失败
-     */
-    static bool verify(const float* data, size_t length, uint32_t expected_crc);
-    
-    /**
-     * @brief 获取CRC表初始化状态
-     * @return true表示已初始化，false表示未初始化
-     */
-    static bool isInitialized();
-    
-    /**
-     * @brief 强制重新初始化CRC表
-     */
-    static void reinitialize();
-};
-
-#endif // __cplusplus
-
-#endif // __CRC_H
\ No newline at end of file
diff --git a/Robot_V2/pid.h b/Robot_V2/Algorithm/pid.h
similarity index 100%
rename from Robot_V2/pid.h
rename to Robot_V2/Algorithm/pid.h
diff --git a/Robot_V2/RTE/_Release_GD32C103CB/RTE_Components.h b/Robot_V2/RTE/_Release_GD32C103CB/RTE_Components.h
index f92e443..8ac4eac 100644
--- a/Robot_V2/RTE/_Release_GD32C103CB/RTE_Components.h
+++ b/Robot_V2/RTE/_Release_GD32C103CB/RTE_Components.h
@@ -1,6 +1,6 @@
 /*
  * CSOLUTION generated file: DO NOT EDIT!
- * Generated by: csolution version 2.11.0
+ * Generated by: csolution version 2.12.0
  *
  * Project: 'Robot_V2.Release+GD32C103CB' 
  * Target:  'Release+GD32C103CB' 
@@ -17,8 +17,12 @@
 
 /* GigaDevice::Device:GD32C10x_StdPeripherals:ADC@1.0.0 */
 #define RTE_DEVICE_STDPERIPHERALS_ADC
+/* GigaDevice::Device:GD32C10x_StdPeripherals:BKP@1.0.0 */
+#define RTE_DEVICE_STDPERIPHERALS_BKP
 /* GigaDevice::Device:GD32C10x_StdPeripherals:CAN@1.0.0 */
 #define RTE_DEVICE_STDPERIPHERALS_CAN
+/* GigaDevice::Device:GD32C10x_StdPeripherals:CRC@1.0.0 */
+#define RTE_DEVICE_STDPERIPHERALS_CRC
 /* GigaDevice::Device:GD32C10x_StdPeripherals:DBG@1.0.0 */
 #define RTE_DEVICE_STDPERIPHERALS_DBG
 /* GigaDevice::Device:GD32C10x_StdPeripherals:DMA@1.0.0 */
@@ -37,6 +41,8 @@
 #define RTE_DEVICE_STDPERIPHERALS_PMU
 /* GigaDevice::Device:GD32C10x_StdPeripherals:RCU@1.0.0 */
 #define RTE_DEVICE_STDPERIPHERALS_RCU
+/* GigaDevice::Device:GD32C10x_StdPeripherals:RTC@1.0.0 */
+#define RTE_DEVICE_STDPERIPHERALS_RTC
 /* GigaDevice::Device:GD32C10x_StdPeripherals:SPI_I2S@1.0.0 */
 #define RTE_DEVICE_STDPERIPHERALS_SPI
 /* GigaDevice::Device:GD32C10x_StdPeripherals:TIMER@1.0.0 */
diff --git a/Robot_V2/Robot_V2.cproject.yml b/Robot_V2/Robot_V2.cproject.yml
index bd0c077..58e3019 100644
--- a/Robot_V2/Robot_V2.cproject.yml
+++ b/Robot_V2/Robot_V2.cproject.yml
@@ -34,9 +34,7 @@ project:
         - file: Algorithm/DengFOC.cpp
         - file: Algorithm/DengFOC.h
         - file: Algorithm/pid.cpp
-        - file: pid.h
-        - file: Algorithm/CRC.cpp
-        - file: Algorithm/CRC.h
+        - file: Algorithm/pid.h
   components:
     - component: ARM::CMSIS:CORE
     - component: Device:Startup
@@ -57,6 +55,9 @@ project:
     - component: Device:EVAL:GD32C10x
     - component: Device:GD32C10x_StdPeripherals:FWDGT
     - component: Device:GD32C10x_StdPeripherals:WWDGT
+    - component: Device:GD32C10x_StdPeripherals:BKP
+    - component: Device:GD32C10x_StdPeripherals:CRC
+    - component: Device:GD32C10x_StdPeripherals:RTC
   output:
     type:
       - elf
diff --git a/Robot_V2/device/Can.cpp b/Robot_V2/device/Can.cpp
index 6fe7994..9f94b77 100644
--- a/Robot_V2/device/Can.cpp
+++ b/Robot_V2/device/Can.cpp
@@ -3,11 +3,11 @@
 #include "Filter.h"
 #include "adc.h"
 #include "ang_sensor.h"
-#include "core_cmFunc.h"
 #include "flash.h"
 #include "gd32c10x.h"
 #include "gd32c10x_can.h"
 #include "gd32c10x_dma.h"
+#include "gd32c10x_gpio.h"
 #include "motor.h"
 #include "systick.h"
 #include <cstdio>
@@ -28,7 +28,8 @@ CAN_transmiter CAN0_transmiter; // CAN初始化
 extern FOC_Controlroller FOC;
 extern sampler sampler;
 extern angle_sensor KTH7823;
-extern EncoderVelocityKalman Vel_kalman;
+extern EncoderAngleKalman Angle_kalman;	 // 角度滤波
+extern EncoderVelocityKalman Vel_kalman; // 速度滤波
 extern FlashEEPROM flashEEP;
 
 // 添加DMA相关变量
@@ -566,8 +567,14 @@ u8 CAN_transmiter::CANFD_Send(u32 id, u8 length, u8 *data) {
 
 	// 检查是否成功获取mailbox
 	if (CAN_NOMAILBOX == transmit_mailbox) {
+		static u32 count = 0;
 		// 没有可用的mailbox，可能所有mailbox都在使用中
+		count++;
 		printf("No available mailbox for CANFD transmission\r\n");
+		if (count > 0xff and !is_sleep) {
+			init();
+			count = 0;
+		}
 		return 0;
 	}
 	return 1;
@@ -695,10 +702,27 @@ void CAN_transmiter::communication_check() {
 				unpack_bytes_to_float(receive_message.rx_data, 11).f;
 			FOC.target_velocity = target_velocity_union.f;
 		} else if (receive_message.rx_efid == 0x00010301) {
-			motor_reset();
-			flashEEP.save_angle(FOC.rt_angle, false);
-			flashEEP.save_system_config(false);
-			
+			u8 first_byte = receive_message.rx_data[0];
+			u8 eigth_byte = receive_message.rx_data[7];
+			if (first_byte & 0x01) {
+				motor_reset();
+			}
+			if (first_byte >> 1 & 0x01) {
+				flashEEP.save_angle(false);
+			}
+			if (first_byte >> 2 & 0x01) {
+				flashEEP.save_system_config(false);
+			}
+			if (first_byte >> 3 & 0x01) {
+				KTH7823.angle_set(0);
+				Angle_kalman.init(0); // 角度滤波
+				Vel_kalman.init(0); // 角度滤波
+			}
+			if (eigth_byte & 0x80 >> 7) {
+				prepare_deep_sleep(true);
+				// CAN_Sleep();
+			}
+
 		} else {
 			printf("Unknown CAN ID: %X\n", receive_message.rx_efid);
 		}
@@ -706,6 +730,30 @@ void CAN_transmiter::communication_check() {
 	}
 }
 
+/**
+ * @brief  CAN睡眠
+ * @param  None
+ * @retval None
+ */
+u8 CAN_transmiter::CAN_Sleep() {
+	gpio_bit_set(GPIOB, GPIO_PIN_13);
+	is_sleep = true;
+	return 0;
+}
+
+/**
+ * @brief  CAN唤醒
+ * @param  None
+ * @retval None
+ */
+u8 CAN_transmiter::CAN_Wakeup() {
+	printf("can wake\r\n");
+	is_sleep = false;
+	canfd_config();
+
+	return 0;
+}
+
 /**
  * @brief  CAN0中断服务程序
  * @retval 无
diff --git a/Robot_V2/device/Can.h b/Robot_V2/device/Can.h
index 856dc80..1cd3384 100644
--- a/Robot_V2/device/Can.h
+++ b/Robot_V2/device/Can.h
@@ -53,11 +53,11 @@ static inline float_union_t unpack_bytes_to_float(u8 *buffer, u16 offset) {
 	return float_union;
 }
 
-u8 can_gpio_init(void);	// CAN引脚初始化
-void can_config(void);	// CAN初始化
-void canfd_config(void);// CANFD初始化
-void can_dma_init(void); // CAN DMA初始化
-void CAN0_RX0_IRQHandler(void);// CAN接收中断处理函数
+u8 can_gpio_init(void);				 // CAN引脚初始化
+void can_config(void);				 // CAN初始化
+void canfd_config(void);			 // CANFD初始化
+void can_dma_init(void);			 // CAN DMA初始化
+void CAN0_RX0_IRQHandler(void);		 // CAN接收中断处理函数
 void DMA0_Channel4_IRQHandler(void); // DMA通道4中断处理函数(CAN接收)
 void DMA0_Channel5_IRQHandler(void); // DMA通道5中断处理函数(CAN发送)
 
@@ -71,47 +71,51 @@ void can_loopback_test(void);
 class CAN_transmiter {
 
   private:
-	u8 controller_Mode = 0;					   		// 电机模式
-	float_union_t limit_velocity_union = {0};    // 限制速度
-	u16 limit_voltage = 0;					   		// 限制电压
-	short mcu_temp = 0;						   		// MCU温度
-	short motor_temp = 0;					   		// 电机温度
-	u16 Power_Voltage = 0;					   		// 电源电压
-	float_union_t rt_angle_union = {0};		    // 实时角度
-	float_union_t rt_velocity_union = {0};	    // 实时速度
-	bool MotorStatus = 0;						   	// 电机状态码
-	float_union_t target_angle_union = {0};	    // 目标角度
-	u8 Target_Control_Mode = 0;				   		// 目标控制模式
-	u8 EEPROMStatus = 0;							// EEPROM状态码
-	float_union_t target_velocity_union = {0}; 	// 目标速度
-	float_union_t u_current_union = {0};	   		// U相电流
-	float_union_t w_current_union = {0};	   		// W相电流
-	float_union_t v_current_union = {0};	   		// V相电流
+	bool is_sleep = false; // 是否休眠
+
+	u8 controller_Mode = 0;					   // 电机模式
+	float_union_t limit_velocity_union = {0};  // 限制速度
+	u16 limit_voltage = 0;					   // 限制电压
+	short mcu_temp = 0;						   // MCU温度
+	short motor_temp = 0;					   // 电机温度
+	u16 Power_Voltage = 0;					   // 电源电压
+	float_union_t rt_angle_union = {0};		   // 实时角度
+	float_union_t rt_velocity_union = {0};	   // 实时速度
+	bool MotorStatus = 0;					   // 电机状态码
+	float_union_t target_angle_union = {0};	   // 目标角度
+	u8 Target_Control_Mode = 0;				   // 目标控制模式
+	u8 EEPROMStatus = 0;					   // EEPROM状态码
+	float_union_t target_velocity_union = {0}; // 目标速度
+	float_union_t u_current_union = {0};	   // U相电流
+	float_union_t w_current_union = {0};	   // W相电流
+	float_union_t v_current_union = {0};	   // V相电流
 
 	can_trasnmit_message_struct transmit_message; // 发送消息结构体
 	u8 transmit_mailbox = CAN_NOMAILBOX;		  // 初始化为无mailbox状态
 	u8 transmit_data[64];						  // CANFD最大64字节
 
-	void update(); 								// 更新数据
+	void update();								// 更新数据
 	u8 CAN_Receive();							// CAN接收
 	u8 CANFD_Receive();							// CANFD接收
 	u8 CAN_Send(u32 ID, u8 length, u8 *data);	// CAN发送
-	u8 CANFD_Send(u32 ID, u8 length, u8 *data);	// CANFD发送
-	u8 CAN_all_Send();							// CAN发送	
+	u8 CANFD_Send(u32 ID, u8 length, u8 *data); // CANFD发送
+	u8 CAN_all_Send();							// CAN发送
 	u8 CANFD_all_Send();						// CANFD发送
 
   public:
 	// 添加构造函数声明
 	u8 init(void);
 
-	can_receive_message_struct receive_message; 	// 接收消息结构体
-	FlagStatus can0_receive_flag;					// CAN0接收标志
-	FlagStatus can0_send_flag;						// CAN0发送标志
-	float_union_t testfloat_union = {0};			// 测试用
+	can_receive_message_struct receive_message; // 接收消息结构体
+	FlagStatus can0_receive_flag;				// CAN0接收标志
+	FlagStatus can0_send_flag;					// CAN0发送标志
+	float_union_t testfloat_union = {0};		// 测试用
 
-	bool MagStatus = 0;						   		// 磁状态码
-	bool ThermalStatus = 0;						   	// 热能状态码
-	void communication_check();						// 通信检查
+	bool MagStatus = 0;			// 磁状态码
+	bool ThermalStatus = 0;		// 热能状态码
+	void communication_check(); // 通信检查
+	u8 CAN_Sleep();				// CAN进入睡眠
+	u8 CAN_Wakeup();			// CAN进入睡眠
 };
 
 #ifdef __cplusplus
diff --git a/Robot_V2/device/Timer.cpp b/Robot_V2/device/Timer.cpp
index 5d62455..c59074a 100644
--- a/Robot_V2/device/Timer.cpp
+++ b/Robot_V2/device/Timer.cpp
@@ -97,7 +97,6 @@ void User_timer_init(void) {
 	nvic_config();
 }
 
-
 /**
  * @brief   TIMER2中断处理函数
  * @return void
diff --git a/Robot_V2/device/ang_sensor.cpp b/Robot_V2/device/ang_sensor.cpp
index 06d2b1d..6b8467e 100644
--- a/Robot_V2/device/ang_sensor.cpp
+++ b/Robot_V2/device/ang_sensor.cpp
@@ -216,7 +216,8 @@ u8 angle_sensor::init(void) {
 * @return 0成功/1失败
  */
 u8 angle_sensor::angle_set(float angle){
-	m_cumulativeAngle = flashEEP.read_angle()*REDUCTION_RATIO; // 从Flash读取上次保存的角度
+	m_cumulativeAngle = angle*REDUCTION_RATIO; // 从Flash读取上次保存的角度
+	m_firstUpdate = true;
 	return 0;
 }
 
@@ -303,11 +304,3 @@ float angle_sensor::getRawAngle(void) const { return m_cumulativeAngle; }
 float angle_sensor::getcurrent_sensorangle(void) const {
 	return current_angle_deg;
 }
-
-/**
- * @brief 重置累积角度值
- */
-void angle_sensor::reset(void) {
-	m_cumulativeAngle = 0.0f;
-	m_firstUpdate = true;
-}
\ No newline at end of file
diff --git a/Robot_V2/main.cpp b/Robot_V2/main.cpp
index fdadb19..42b4855 100644
--- a/Robot_V2/main.cpp
+++ b/Robot_V2/main.cpp
@@ -11,43 +11,52 @@
 #include "health.h"
 #include "initial.h"
 #include "motor.h"
+#include "sys/initial.h"
 #include "systick.h"
 #include <cstdio>
 #include <stdint.h>
+extern CAN_transmiter CAN0_transmiter;		// CAN初始化
+extern sampler sampler;						// 采样器
+extern angle_sensor KTH7823;				// 角度传感器
+extern EncoderVelocityKalman Vel_kalman;	// 速度滤波
+extern EncoderAngleKalman Angle_kalman;		// 角度滤波
+extern ThermalController thermalController; // 热量控制器
+extern FOC_Controlroller FOC;				// FOC控制
+extern FlashEEPROM flashEEP;				// EEPROM类
 
 TaskScheduler scheduler = {0};
 volatile u32 system_runtime_us = 0;
 volatile u32 cnt_test = 0;
 int main(void) {
-	systick_config();  // 系统时钟初始化
-	unused_pin_init(); // 未使用引脚初始化
-	USART0_init();	   // 调试串口初始化
+	systick_config();		 // 系统时钟初始化
+	SystemCoreClockUpdate(); // 更新系统时钟变量
+	watchdog_init(50);		 // 看门狗初始化
+	unused_pin_init();		 // 未使用引脚初始化
+	USART0_init();			 // 调试串口初始化
+	motor_init();			 // 电机驱动初始化
+	if (get_reset_cause() ==
+		RCU_FLAG_FWDGTRST) { // 如果是看门狗复位，本次看门狗时间延长并休眠
+		printf("continue sleep\r\n");
+		watchdog_init(5000); // 看门狗初始化
+		delay_1ms(1);
+		prepare_deep_sleep(false);
+	}
 	User_timer_init(); // 任务Timer初始化
-	motor_init();	   // 电机驱动初始化
-
-	extern CAN_transmiter CAN0_transmiter;		// CAN初始化
-	extern sampler sampler;						// 采样器
-	extern angle_sensor KTH7823;				// 角度传感器
-	extern EncoderVelocityKalman Vel_kalman;	// 速度滤波
-	extern EncoderAngleKalman Angle_kalman;		// 角度滤波
-	extern ThermalController thermalController; // 热量控制器
-	extern FOC_Controlroller FOC;				// FOC控制
-	extern FlashEEPROM flashEEP;				// EEPROM类
-
 	u8 init_status = 0;
-	init_status += flashEEP.init();						  // EEPROM初始化
-	init_status += KTH7823.init();						  // 角度传感器初始化
-	init_status += sampler.init();						  // 采样器初始化
-	init_status += CAN0_transmiter.init();				  // CAN初始化
+	init_status += KTH7823.init(); // 角度传感器初始化
+	init_status += sampler.init(); // 采样器初始化
+	init_status +=
+		flashEEP.init(); // EEPROM初始化，必须放在角度卡尔曼之前，角度传感器之后
+
 	init_status += Angle_kalman.init(KTH7823.getAngle()); // 角度滤波初始化
 	init_status += Vel_kalman.init(0.0f);				  // 速度滤波初始化
-	while (init_status) {								  // 初始化检测
+	init_status += CAN0_transmiter.init();				  // CAN初始化
+
+	while (init_status) { // 初始化检测
 		std::printf("初始化失败\r\n");
 	}
 
-	watchdog_init(500);		 // 看门狗初始化
-	angsens_MG_check();		 // 角度传感器磁感应强度测试
-	SystemCoreClockUpdate(); // 更新系统时钟变量
+	angsens_MG_check(); // 角度传感器磁感应强度测试
 	while (1) {
 		__disable_irq();
 		u32 currentTasks =
@@ -55,69 +64,71 @@ int main(void) {
 		scheduler.taskFlags &= ~currentTasks; // 一次性清除所有已处理的任务标志
 		__enable_irq();
 
-		// 按照优先级和重要性处理任务
-		if (currentTasks & (1 << TASK_CURRENT_UPDATE)) { // 更新电流采样值
-			sampler.update_current();
-		}
-		if (currentTasks & (1 << TASK_ANGLE_UPDATE)) { // 更新角度传感器值
-			KTH7823.update();
-			FOC.rt_angle = Angle_kalman.update(KTH7823.getAngle());
-		}
-		if (currentTasks & (1 << TASK_VELOCITY_UPDATE)) { // 更新速度传感器值
-			FOC.rt_velocity = Vel_kalman.update(Angle_kalman.getVelocity());
-		}
-		if (currentTasks &
-			(1 << TASK_MOTOR_CONTROL)) { // 电机控制任务(最高优先级)
-			system_runtime_us++;
-			switch (FOC.control_mode) {
-			case 0: {
-				FOC.drv_hold(0.95); // 占空比置0
-				break;
-			}
-			case 1: {
-				FOC.angle_control(FOC.target_angle); // 角度闭环控制
-				// FOC.angle_control_with_velocity_limit(FOC.target_angle,
-				// FOC.limit_velocity); // 角度闭环控制，带速度限制
-				break;
-			}
-			case 2: {
-				FOC.velocity_control(FOC.target_velocity); // 速度闭环控制
-				break;
-			}
-			case 3: {
-				// FOC.angle_control_NPID(FOC.target_angle); // 角度闭环控制
-				FOC.current_control(FOC.limit_velocity); // 电流闭环控制
-				break;
-			}
-			case 4: {
-				FOC.velocity_open_loop(); // 速度开环控制
-				break;
-			}
-			}
-		}
-		if (currentTasks & (1 << TASK_MCU_TEMP_UPDATE)) { // 更新mcu温度传感器值
-			sampler.update_mcu_temp();
-		}
-		if (currentTasks &
-			(1 << TASK_DRV_TEMP_UPDATE)) { // 更新电机温度传感器值
-			sampler.update_drv_temp();
-		}
-		if (currentTasks & (1 << TASK_THERMAL_CONTROL)) { // 热量控制
-			thermalController.update();
-		}
-		if (currentTasks & (1 << TASK_MAGNETIC_CHECK)) { // 磁感应强度检测
-			angsens_MG_check();
-		}
-		if (currentTasks & (1 << TASK_VBUS_UPDATE)) { // 更新vbus电压值
-			power_manage();
-		}
-		if (currentTasks & (1 << TASK_CAN_TRANSMIT)) { // CAN通信
-			// CAN0_transmiter.testfloat_union.f = cnt_test; // 负载检测
-			cnt_test = 0;
-			CAN0_transmiter.can0_send_flag = SET;
-			CAN0_transmiter.communication_check();
-			fwdgt_counter_reload(); // 看门狗复位
-		}
+		do_task(currentTasks);
 	}
 	return 0;
 }
+
+void do_task(u32 currentTasks) {
+	// 按照优先级和重要性处理任务
+	if (currentTasks & (1 << TASK_CURRENT_UPDATE)) { // 更新电流采样值
+		sampler.update_current();
+	}
+	if (currentTasks & (1 << TASK_ANGLE_UPDATE)) { // 更新角度传感器值
+		KTH7823.update();
+		FOC.rt_angle = Angle_kalman.update(KTH7823.getAngle());
+	}
+	if (currentTasks & (1 << TASK_VELOCITY_UPDATE)) { // 更新速度传感器值
+		FOC.rt_velocity = Vel_kalman.update(Angle_kalman.getVelocity());
+	}
+	if (currentTasks & (1 << TASK_MOTOR_CONTROL)) { // 电机控制任务(最高优先级)
+		system_runtime_us++;
+		switch (FOC.control_mode) {
+		case 0: {
+			FOC.drv_hold(0.95); // 占空比置0
+			break;
+		}
+		case 1: {
+			FOC.angle_control(FOC.target_angle); // 角度闭环控制
+			// FOC.angle_control_with_velocity_limit(FOC.target_angle,
+			// FOC.limit_velocity); // 角度闭环控制，带速度限制
+			break;
+		}
+		case 2: {
+			FOC.velocity_control(FOC.target_velocity); // 速度闭环控制
+			break;
+		}
+		case 3: {
+			// FOC.angle_control_NPID(FOC.target_angle); // 角度闭环控制
+			FOC.current_control(FOC.limit_velocity); // 电流闭环控制
+			break;
+		}
+		case 4: {
+			FOC.velocity_open_loop(); // 速度开环控制
+			break;
+		}
+		}
+	}
+	if (currentTasks & (1 << TASK_MCU_TEMP_UPDATE)) { // 更新mcu温度传感器值
+		sampler.update_mcu_temp();
+	}
+	if (currentTasks & (1 << TASK_DRV_TEMP_UPDATE)) { // 更新电机温度传感器值
+		sampler.update_drv_temp();
+	}
+	if (currentTasks & (1 << TASK_THERMAL_CONTROL)) { // 热量控制
+		thermalController.update();
+	}
+	if (currentTasks & (1 << TASK_MAGNETIC_CHECK)) { // 磁感应强度检测
+		angsens_MG_check();
+	}
+	if (currentTasks & (1 << TASK_VBUS_UPDATE)) { // 更新vbus电压值
+		power_manage();
+	}
+	if (currentTasks & (1 << TASK_CAN_TRANSMIT)) { // CAN通信
+		// CAN0_transmiter.testfloat_union.f = cnt_test; // 负载检测
+		cnt_test = 0;
+		CAN0_transmiter.can0_send_flag = SET;
+		CAN0_transmiter.communication_check();
+		fwdgt_counter_reload(); // 看门狗复位
+	}
+}
\ No newline at end of file
diff --git a/Robot_V2/main.h b/Robot_V2/main.h
index 86aa1aa..a8426d5 100644
--- a/Robot_V2/main.h
+++ b/Robot_V2/main.h
@@ -34,6 +34,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef MAIN_H
 #define MAIN_H
+#include "stdint.h"
 
+void do_task(u32 currentTasks);
 
 #endif /* MAIN_H */
diff --git a/Robot_V2/sys/flash.cpp b/Robot_V2/sys/flash.cpp
index 29bddd6..b554a58 100644
--- a/Robot_V2/sys/flash.cpp
+++ b/Robot_V2/sys/flash.cpp
@@ -1,11 +1,11 @@
 #include "flash.h"
 #include "DengFOC.h"
 #include "ang_sensor.h"
-#include "core_cmFunc.h"
+#include "gd32c10x_crc.h"
 #include "gd32c10x_fmc.h"
 #include "math.h"
-#include <CRC.h>
 #include <Can.h>
+#include <Filter.h>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -15,7 +15,6 @@ FlashEEPROM flashEEP = FlashEEPROM();
 extern angle_sensor KTH7823;
 extern CAN_transmiter CAN0_transmiter;
 extern FOC_Controlroller FOC; // FOC控制
-extern CRC_Calculator CRC_Calculator;
 constexpr u8 SIZE_U32 = sizeof(uint32_t);
 constexpr u8 DEFAULT_VALUE = 0;
 constexpr u8 NUM_SAVED = 5;
@@ -31,12 +30,15 @@ FlashEEPROM::FlashEEPROM() {
  * @retval None
  */
 u8 FlashEEPROM::init() {
+	rcu_periph_clock_enable(RCU_CRC);
+	// 使用硬件CRC计算校验值
+	crc_deinit(); // 初始化CRC模块
+
 	// 读取保存的参数
 	u32 CRC_NUM = 0x0000;
-	FlashEepromStatus status_read[NUM_SAVED + 1] = {FLASH_EEPROM_OK};
+	FlashEepromStatus status_read[NUM_SAVED] = {FLASH_EEPROM_OK};
 	float angle = 0.0f;
-	float data[NUM_SAVED] = {FOC.target_angle, FOC.target_velocity,
-							 FOC.limit_voltage, (float)FOC.control_mode};
+	float data[NUM_SAVED - 1] = {0.0f, 0.0f, 0.0f, 0.0f};
 	FlashEepromStatus status = FLASH_EEPROM_OK;
 	if (readFloat(ADDR_ANGLE, &angle) != FLASH_EEPROM_OK) {
 		angle = DEFAULT_VALUE; // 默认值
@@ -49,7 +51,7 @@ u8 FlashEEPROM::init() {
 	status_read[4] = readFloat(ADDR_CONTROL_MODE, &data[3]);
 
 	// 读取失败则使用默认值
-	for (u8 i = 1; i < NUM_SAVED + 1; i++) {
+	for (u8 i = 1; i < NUM_SAVED; i++) {
 		if (status_read[i] ==
 			FLASH_EEPROM_DATA_NOT_FOUND) { // 首次读取，不保存报错
 			data[i - 1] = DEFAULT_VALUE;
@@ -62,8 +64,8 @@ u8 FlashEEPROM::init() {
 	if (status_read[0] == FLASH_EEPROM_OK) {
 		u32 next_address = EEPROM_END_ADDRESS;
 		// 遍历Flash页面寻找下一个可写入位置
-		for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
-			 address > EEPROM_START_ADDRESS; address -= SIZE_U32) {
+		for (u32 address = EEPROM_START_ADDRESS - SIZE_U32;
+			 address > FLASH_START_ADDRESS; address -= SIZE_U32) {
 
 			// 安全读取Flash数据
 			volatile u32 *flash_ptr = (volatile u32 *)address;
@@ -76,8 +78,13 @@ u8 FlashEEPROM::init() {
 			// 更新下一个可能的写入位置（如果需要格式化）
 			next_address = address - SIZE_U32;
 		}
-		CRC_NUM = CRC_Calculator::calculate(data, NUM_SAVED);
 
+		crc_data_register_reset(); // 确保CRC计算从初始状态开始
+		CRC_NUM = crc_block_data_calculate((uint32_t *)data, NUM_SAVED);
+		// for (float &p : data) {
+		// 	printf("%f\r\n", p);
+		// }
+		// printf("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 < NUM_SAVED; i++) {
 				data[i] = DEFAULT_VALUE;
@@ -91,7 +98,7 @@ u8 FlashEEPROM::init() {
 		EEPROMStatus = status_read[0];
 	}
 
-	KTH7823.angle_set(angle);
+	KTH7823.angle_set(angle - KTH7823.update());
 	FOC.target_angle = data[0];
 	FOC.target_velocity = data[1];
 	FOC.limit_voltage = data[2];
@@ -149,10 +156,12 @@ FlashEepromStatus FlashEEPROM::readFloat(u8 virtualAddr, float *data) const {
 			u8 addr = (u8)(data_word & 0xFF);
 			// 找到匹配的虚拟地址
 			if (addr == virtualAddr) {
+				u32 data_word_c = *((u32 *)address);
 				// 清除最低的8位地址信息，保留高24位数据
 				u32 float_data = data_word & 0xFFFFFF00;
 				// 使用内存拷贝将处理后的数据解释为float
 				memcpy(data, &float_data, sizeof(float));
+				// printf("check:0x%x=%f\r\n", address, *data);
 				return FLASH_EEPROM_OK;
 			}
 		}
@@ -255,8 +264,6 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
 
 	// 如果有足够空间，直接写入
 	if (next_address < EEPROM_END_ADDRESS) {
-		u32 float_bits;
-
 		u32 data_word;
 		// 将完整的float数据复制到32位变量中
 		memcpy(&data_word, &data, sizeof(float));
@@ -271,6 +278,11 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
 		fmc_state_enum fmc_status = fmc_word_program(next_address, data_word);
 
 		fmc_lock();
+
+		// u32 data_word_c = *((u32 *)next_address);
+		// float float_data = *((float *)&data_word_c);
+		// printf("check:0x%x=%f\r\n", next_address, float_data);
+
 		if (fmc_status != FMC_READY) {
 			return FLASH_EEPROM_WRITE_ERROR;
 		}
@@ -283,8 +295,6 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
 		}
 
 		// 格式化后在页面开头写入数据
-		u32 float_bits;
-
 		u32 data_word;
 		// 将完整的float数据复制到32位变量中
 		memcpy(&data_word, &data, sizeof(float));
@@ -345,13 +355,12 @@ FlashEepromStatus FlashEEPROM::format() {
 			}
 		}
 	}
-
+	fmc_unlock();
 	// 擦除整个页面
 	fmc_status = fmc_page_erase(EEPROM_START_ADDRESS);
 	if (fmc_status != FMC_READY) {
 		return FLASH_EEPROM_ERASE_ERROR;
 	}
-	fmc_unlock();
 	// 重新写入有效的数据项
 	for (u16 i = 0; i < valid_count; i++) {
 		fmc_status = fmc_word_program(EEPROM_START_ADDRESS + i * SIZE_U32,
@@ -371,10 +380,10 @@ FlashEepromStatus FlashEEPROM::format() {
  */
 FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
 	u32 CRC_NUM = 0x0000;
-	u32 next_address;
-	FlashEepromStatus status_save[NUM_SAVED] = {FLASH_EEPROM_OK};
-	float data[NUM_SAVED] = {FOC.target_angle, FOC.target_velocity,
-							 FOC.limit_voltage, (float)FOC.control_mode};
+	static u32 next_address;
+	FlashEepromStatus status_save[NUM_SAVED - 1] = {FLASH_EEPROM_OK};
+	float data[NUM_SAVED - 1] = {FOC.target_angle, FOC.target_velocity,
+								 FOC.limit_voltage, (float)FOC.control_mode};
 
 	// 读取保存的参数
 	if (!system_config_saved) {
@@ -390,11 +399,12 @@ FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
 			}
 		}
 
-		CRC_NUM = CRC_Calculator.calculate(data, NUM_SAVED);
-		// 遍历Flash页面寻找下一个可写入位置
-		for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
-			 address > EEPROM_START_ADDRESS; address -= SIZE_U32) {
+		crc_data_register_reset(); // 确保CRC计算从初始状态开始
+		CRC_NUM = crc_block_data_calculate((uint32_t *)data, NUM_SAVED);
 
+		// 遍历Flash页面寻找下一个可写入位置
+		for (u32 address = EEPROM_START_ADDRESS - SIZE_U32;
+			 address > FLASH_START_ADDRESS; address -= SIZE_U32) {
 			// 安全读取Flash数据
 			volatile u32 *flash_ptr = (volatile u32 *)address;
 			u32 data_word = *flash_ptr;
@@ -407,16 +417,20 @@ FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
 			next_address = address - SIZE_U32;
 		}
 		// 如果有足够空间，直接写入
-		if (next_address > EEPROM_START_ADDRESS) {
+		if (next_address > FLASH_START_ADDRESS) {
 			fmc_unlock();
 			fmc_flag_clear(FMC_FLAG_PGERR | FMC_FLAG_PGAERR | FMC_FLAG_WPERR);
 			fmc_state_enum fmc_status = fmc_word_program(next_address, CRC_NUM);
 			// printf("write address:0x%X,status:0x%x \r\n", next_address,
 			// 	   fmc_status);
+			fmc_lock();
+			// for (float &p : data) {
+			// 	printf("%f\r\n", p);
+			// }
 			// printf("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM, *((u32
 			// *)next_address));
-			fmc_lock();
 		} else {
+			printf("no enough space\r\n");
 			// 空间不足，需要格式化页面
 			FlashEepromStatus status = format();
 			if (status != FLASH_EEPROM_OK) {
@@ -452,8 +466,9 @@ FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
  * @param angle 角度数据
  * @return FlashEepromStatus: 操作状态
  */
-FlashEepromStatus FlashEEPROM::save_angle(float angle, bool saved) {
+FlashEepromStatus FlashEEPROM::save_angle(bool saved) {
 	float angle_read = DEFAULT_VALUE;
+	float angle = FOC.rt_angle;
 	FlashEepromStatus status = FLASH_EEPROM_OK;
 
 	// 读取保存的参数
diff --git a/Robot_V2/sys/flash.h b/Robot_V2/sys/flash.h
index 5891b6b..d501619 100644
--- a/Robot_V2/sys/flash.h
+++ b/Robot_V2/sys/flash.h
@@ -1,8 +1,6 @@
 #ifndef __FLASH_H
 #define __FLASH_H
 
-#include "gd32c10x.h"
-#include <cstdint>
 #include <stdint.h>
 // 修改后 - 强制4字节对齐
 #define ALIGN_4BYTE(addr) ((addr) & 0xFFFFFFFC) // 4字节对齐
@@ -24,9 +22,10 @@ class FlashEEPROM {
   public:
 	// EEPROM emulation constants
 	static constexpr u32 EEPROM_START_ADDRESS =
-		0x0801F800;										  // Flash最后一页(2KB)
-	static constexpr u32 EEPROM_END_ADDRESS = 0x08020000; // Flash结束地址
-	static constexpr u32 EEPROM_MAX_SIZE = 0x800; // EEPROM最大容量
+		0x0801F800;										   // Flash最后一页(2KB)
+	static constexpr u32 EEPROM_END_ADDRESS = 0x08020000;  // Flash结束地址
+	static constexpr u32 EEPROM_MAX_SIZE = 0x800;		   // EEPROM最大容量
+	static constexpr u32 FLASH_START_ADDRESS = 0x08010000; // Flash起始地址
 
 	// 定义用户自定义的虚拟地址
 	static constexpr u8 ADDR_CONTROL_MODE = 0x0;  // 控制模式
@@ -56,7 +55,7 @@ class FlashEEPROM {
 	// 格式化Flash EEPROM页面
 	FlashEepromStatus format();
 
-	FlashEepromStatus save_angle(float angle, bool saved);
+	FlashEepromStatus save_angle(bool saved);
 	FlashEepromStatus save_system_config(bool saved);
 	float read_angle();
 
diff --git a/Robot_V2/sys/health.cpp b/Robot_V2/sys/health.cpp
index a0e4de6..c78469d 100644
--- a/Robot_V2/sys/health.cpp
+++ b/Robot_V2/sys/health.cpp
@@ -96,7 +96,7 @@ void power_manage(void) {
 	float vbus = sampler.get_vbus_voltage();
 	if ((vbus < 22.0f) and (last_vbus > vbus) and vbus > 8.0f) {
 		FOC.shut_down();
-		flashEEP.save_angle(FOC.rt_angle, true);
+		flashEEP.save_angle(true);
 		flashEEP.save_system_config(true);
 	} else {
 		FOC.resume();
diff --git a/Robot_V2/sys/initial.cpp b/Robot_V2/sys/initial.cpp
index 7e41501..90bdb52 100644
--- a/Robot_V2/sys/initial.cpp
+++ b/Robot_V2/sys/initial.cpp
@@ -1,9 +1,10 @@
 #include "initial.h"
+#include "gd32c10x.h"
 #include "gd32c10x_gpio.h"
 #include "gd32c10x_rcu.h"
+#include <cstdio>
 #include <stdint.h>
-
-
+#include <stdio.h>
 
 /* retarget the C library printf function to the USART */
 u8 USART0_init() {
@@ -34,15 +35,59 @@ int fputc(int ch, FILE *f) throw() {
 	return ch;
 }
 
-
-void unused_pin_init() { 
+void unused_pin_init() {
 	rcu_periph_clock_enable(RCU_GPIOA); // 使能GPIOA时钟
 	rcu_periph_clock_enable(RCU_GPIOB); // 使能GPIOB时钟
 	rcu_periph_clock_enable(RCU_GPIOC); // 使能GPIOC时钟
-	gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ, GPIO_PIN_8|GPIO_PIN_11|GPIO_PIN_12);
-	gpio_init(GPIOB, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ, GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_15);
-	gpio_init(GPIOC, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15);
-	gpio_bit_reset(GPIOA, GPIO_PIN_8|GPIO_PIN_11|GPIO_PIN_12);
-	gpio_bit_reset(GPIOB, GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_15);
-	gpio_bit_reset(GPIOC, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15);
-}
\ No newline at end of file
+	gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
+			  GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12);
+	gpio_init(GPIOB, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
+			  GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_15);
+	gpio_init(GPIOC, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
+			  GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15);
+	gpio_bit_reset(GPIOA, GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12);
+	gpio_bit_reset(GPIOB, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_15);
+	gpio_bit_reset(GPIOC, GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15);
+}
+
+/*!
+	\brief      检测并打印复位源信息
+	\param[in]  none
+	\param[out] none
+	\retval     none
+*/
+u16 get_reset_cause(void) {
+	u16 cause = 0;
+	if (RESET != rcu_flag_get(RCU_FLAG_FWDGTRST)) {
+		// printf("Free Watchdog Timer Reset\r\n");
+		cause = RCU_FLAG_FWDGTRST;
+	}
+	if (RESET != rcu_flag_get(RCU_FLAG_EPRST)) {
+		// printf("External Pin Reset\r\n");
+		cause = RCU_FLAG_EPRST;
+	}
+
+	if (RESET != rcu_flag_get(RCU_FLAG_PORRST)) {
+		// printf("Power Reset\r\n");
+		cause = RCU_FLAG_PORRST;
+	}
+
+	if (RESET != rcu_flag_get(RCU_FLAG_WWDGTRST)) {
+		// printf("Window Watchdog Timer Reset\r\n");
+		cause = RCU_FLAG_WWDGTRST;
+	}
+
+	if (RESET != rcu_flag_get(RCU_FLAG_LPRST)) {
+		// printf("Low Power Reset\r\n");
+		cause = RCU_FLAG_LPRST;
+	}
+
+	if (RESET != rcu_flag_get(RCU_FLAG_SWRST)) {
+		// printf("Software Reset\r\n");
+		cause = RCU_FLAG_SWRST;
+	}
+	// 清除所有复位标志
+	rcu_all_reset_flag_clear();
+	// printf("cause:%d\r\n", cause);
+	return cause;
+}
diff --git a/Robot_V2/sys/initial.h b/Robot_V2/sys/initial.h
index 5a75963..4330a0e 100644
--- a/Robot_V2/sys/initial.h
+++ b/Robot_V2/sys/initial.h
@@ -4,6 +4,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 #include "gd32c10x_eval.h"
 #include "stdint.h"
 #include <stdio.h>
@@ -19,6 +20,7 @@ int fputc(int ch, FILE *f);						// 声明fputc函数以重载标准库实现
 
 u8 USART0_init(void);
 u8 watchdog_init(u32 time);
+u16 get_reset_cause(void);
 void unused_pin_init();
 // 任务标志定义
 typedef enum {
diff --git a/Robot_V2/sys/systick.cpp b/Robot_V2/sys/systick.cpp
index 2f584fc..88c8fc0 100644
--- a/Robot_V2/sys/systick.cpp
+++ b/Robot_V2/sys/systick.cpp
@@ -33,11 +33,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "systick.h"
+#include "Can.h"
+#include "flash.h"
 #include "gd32c10x.h"
 #include "gd32c10x_exti.h"
-#include "gd32c10x_gpio.h"
+#include "motor.h"
+#include <cstdio>
 
 volatile static uint32_t delay;
+extern CAN_transmiter CAN0_transmiter;
+extern FlashEEPROM flashEEP;
 
 /*!
 	\brief      configure systick
@@ -113,27 +118,64 @@ void system_soft_reset(void) {
 	}
 }
 
-// 1. 进入深度睡眠前的准备
-void prepare_deep_sleep(void) {
+/*!
+	\brief      prepare system to enter deep sleep mode
+	\param[in]  none
+	\param[out] none
+	\retval     none
+*/
+void prepare_deep_sleep(bool save_data) {
+	if (save_data) {
+		flashEEP.save_angle(true);
+		flashEEP.save_system_config(true);
+	}
 	// 将SIT1044设置为低功耗待机模式
-	gpio_bit_set(GPIOB, GPIO_PIN_8); // STB = 高电平
+	// CAN0_transmiter.CAN_Sleep();
+	motor_sleep();
 
-	// 配置EXTI中断（连接到SIT1044的RXD引脚）
-	exti_init(EXTI_1, EXTI_INTERRUPT, EXTI_TRIG_FALLING); // 下降沿触发
+	// 关闭不必要的外设时钟
+	rcu_periph_clock_disable(RCU_TIMER0); // 关闭定时器时钟
+	rcu_periph_clock_disable(RCU_TIMER1);
+	rcu_periph_clock_disable(RCU_SPI0); // 关闭SPI时钟
+	rcu_periph_clock_disable(RCU_I2C0); // 关闭I2C时钟
+	rcu_periph_clock_disable(RCU_ADC0); // 关闭ADC时钟
+	// 注意不要关闭GPIOB和AF的时钟，因为需要它们来处理唤醒中断
+
+	// 设置深睡眠模式下的电压以进一步降低功耗
+	rcu_deepsleep_voltage_set(RCU_DEEPSLEEP_V_0_8); // 设置最低电压
+
+	// 配置PB8为输入模式，用于外部中断
+	rcu_periph_clock_enable(RCU_GPIOB);
+	rcu_periph_clock_enable(RCU_AF);
+	gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_8);
+
+	// 配置EXTI中断（连接到PB8引脚）
+	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB,
+							GPIO_PIN_SOURCE_8); // 配置GPIOB的PIN8作为EXTI8的源
+	exti_init(EXTI_8, EXTI_INTERRUPT, EXTI_TRIG_RISING); // 边沿触发
+	exti_interrupt_enable(EXTI_8);
+	nvic_irq_enable(EXTI5_9_IRQn, 0, 0); //
+
+	// 确保中断标志已被清除
+	exti_interrupt_flag_clear(EXTI_8);
 
 	// 进入深度睡眠
 	pmu_to_deepsleepmode(PMU_LDO_LOWPOWER, WFI_CMD);
 }
 
-// 2. 唤醒中断处理
-void EXTI1_IRQHandler(void) {
-	if (exti_interrupt_flag_get(EXTI_1) != RESET) {
+/**
+ * @brief  EXTI5_9中断处理函数
+ * @param  无
+ * @retval 无
+ */
+void EXTI5_9_IRQHandler(void) {
+	if (exti_interrupt_flag_get(EXTI_8) != RESET) {
 		// 清除中断标志
-		exti_interrupt_flag_clear(EXTI_1);
-		// 禁用EXTI线1的中断
-		exti_interrupt_disable(EXTI_1);
+		exti_interrupt_flag_clear(EXTI_8);
+		// 禁用EXTI线8的中断，防止重复触发
+		exti_interrupt_disable(EXTI_8);
 
-		// 唤醒SIT1044到正常模式
-		gpio_bit_reset(GPIOB, GPIO_PIN_8); // STB = 低电平
+		printf("MCU wake up\r\n");
+		system_soft_reset();
 	}
 }
\ No newline at end of file
diff --git a/Robot_V2/sys/systick.h b/Robot_V2/sys/systick.h
index 7604179..5cf51e5 100644
--- a/Robot_V2/sys/systick.h
+++ b/Robot_V2/sys/systick.h
@@ -55,9 +55,9 @@ uint8_t get_cpu_usage(void);
 /* 系统软复位 */
 void system_soft_reset(void);
 /* 准备进入低功耗模式 */
-void prepare_deep_sleep(void);
+void prepare_deep_sleep(bool save_data);
 /* 中断唤醒 */
-void EXTI1_IRQHandler(void);
+void EXTI5_9_IRQHandler(void);
 
 #ifdef __cplusplus
 }