test

detect MCU flash size to config diff usart
add tmp112a code
2025-08-21 17:12:04 +08:00 · 2025-08-21 00:39:30 +08:00 · 2025-08-18 00:18:21 +08:00 · 2025-08-17 18:01:01 +08:00 · 2025-08-17 03:10:50 +08:00 · 2025-08-17 03:06:46 +08:00
24 changed files with 443 additions and 2286 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -31,8 +31,8 @@ set(TARGET_SRC
    Src/command.c
    Src/i2c.c
    Src/ldc1612.c
-    # Src/tmp112.c
-    # Src/sensor_example.c
+    Src/tmp112.c
+    Src/board_config.c
 )

 # 设置输出目录
--- a/I2C_IMPROVEMENTS.md
+++ b/I2C_IMPROVEMENTS.md
@@ -1,139 +0,0 @@
-# I2C驱动改进总结
-
-## 🔧 主要改进内容
-
-### 1. **状态机重构**
- **原问题**: 状态机逻辑混乱，使用复杂的read_cycle变量
- **改进方案**: 
-  - 使用清晰的`i2c_state_t`枚举定义状态
-  - 分离写入和读取的状态流程
-  - 每个状态职责单一，逻辑清晰
-
-```c
-typedef enum {
-    I2C_STATE_IDLE = 0,         /* 空闲状态 */
-    I2C_STATE_START,            /* 生成起始条件 */
-    I2C_STATE_SEND_ADDRESS,     /* 发送从设备地址 */
-    I2C_STATE_CLEAR_ADDRESS,    /* 清除地址标志 */
-    I2C_STATE_TRANSMIT_REG,     /* 发送寄存器地址 */
-    I2C_STATE_TRANSMIT_DATA,    /* 发送数据 */
-    I2C_STATE_RESTART,          /* 生成重启条件 */
-    I2C_STATE_RECEIVE_DATA,     /* 接收数据 */
-    I2C_STATE_STOP,             /* 生成停止条件 */
-    I2C_STATE_ERROR             /* 错误状态 */
-} i2c_state_t;
-```
-
-### 2. **错误处理改进**
- **原问题**: 函数总是返回成功，无法区分错误类型
- **改进方案**: 
-  - 定义详细的状态码枚举
-  - 添加参数验证
-  - 实现重试机制
-
-```c
-typedef enum {
-    I2C_STATUS_SUCCESS = 0,     /* 操作成功 */
-    I2C_STATUS_TIMEOUT,         /* 超时 */
-    I2C_STATUS_NACK,            /* 无应答 */
-    I2C_STATUS_BUS_BUSY,        /* 总线忙 */
-    I2C_STATUS_ERROR,           /* 一般错误 */
-    I2C_STATUS_INVALID_PARAM    /* 无效参数 */
-} i2c_status_t;
-```
-
-### 3. **超时处理优化**
- **原问题**: 超时后无限循环重试
- **改进方案**: 
-  - 限制最大重试次数 (`I2C_MAX_RETRY = 3`)
-  - 超时后进入错误状态
-  - 重试前添加延时
-
-### 4. **总线重置完善**
- **原问题**: 总线重置不完整，可能无法恢复卡死状态
- **改进方案**: 
-  - 实现标准的9时钟脉冲恢复
-  - 生成正确的停止条件
-  - 重新配置GPIO和I2C外设
-
-```c
-/* 生成9个时钟脉冲释放卡死的从设备 */
-for (i = 0; i < I2C_RECOVERY_CLOCKS; i++) {
-    gpio_bit_reset(I2C_SCL_PORT, I2C_SCL_PIN);
-    delay_us(I2C_DELAY_US);
-    gpio_bit_set(I2C_SCL_PORT, I2C_SCL_PIN);
-    delay_us(I2C_DELAY_US);
-}
-```
-
-### 5. **配置问题修复**
- **原问题**: 硬编码从设备地址0xA0
- **改进方案**: 主机地址设为0x00，从设备地址作为参数传入
-
-### 6. **代码结构优化**
- **原问题**: 状态机中有大量重复代码
- **改进方案**: 
-  - 统一的超时检查模式
-  - 清晰的状态转换逻辑
-  - 一致的错误处理流程
-
-## 📋 新增功能
-
-### 1. **状态字符串函数**
-```c
-const char* i2c_get_status_string(i2c_status_t status);
-```
-用于调试时获取状态描述字符串。
-
-### 2. **参数验证**
-```c
-if (data == NULL || slave_addr > 0x7F) {
-    return I2C_STATUS_INVALID_PARAM;
-}
-```
-
-### 3. **调试信息**
-使用`DEBUG_VERBOSE`宏控制调试输出。
-
-## 🔍 状态机流程
-
-### 写入流程:
-```
-START → SEND_ADDRESS → CLEAR_ADDRESS → TRANSMIT_REG → 
-TRANSMIT_DATA → STOP → SUCCESS
-```
-
-### 读取流程:
-```
-写阶段: START → SEND_ADDRESS → CLEAR_ADDRESS → TRANSMIT_REG → RESTART
-读阶段: START → SEND_ADDRESS → CLEAR_ADDRESS → RECEIVE_DATA → STOP → SUCCESS
-```
-
-## 🚀 使用示例
-
-```c
-// 写入16位数据
-uint8_t write_data[2] = {0x12, 0x34};
-i2c_status_t status = i2c_write_16bits(0x48, 0x01, write_data);
-if (status != I2C_STATUS_SUCCESS) {
-    printf("Write failed: %s\r\n", i2c_get_status_string(status));
-}
-
-// 读取16位数据
-uint8_t read_data[2];
-status = i2c_read_16bits(0x48, 0x01, read_data);
-if (status == I2C_STATUS_SUCCESS) {
-    printf("Read data: 0x%02X%02X\r\n", read_data[0], read_data[1]);
-} else {
-    printf("Read failed: %s\r\n", i2c_get_status_string(status));
-}
-```
-
-## 📝 注意事项
-
-1. **编译选项**: 确保包含`<stdbool.h>`以支持bool类型
-2. **调试输出**: 定义`DEBUG_VERBOSE`宏启用调试信息
-3. **延时函数**: 确保`delay_us()`函数可用
-4. **兼容性**: 保留了原有的函数接口以保持向后兼容
-
-这些改进大大提高了I2C驱动的可靠性、可维护性和调试能力。
--- a/Inc/board_config.h
+++ b/Inc/board_config.h
@@ -1,6 +1,10 @@
 #ifndef BOARD_CONFIG_H
 #define BOARD_CONFIG_H

+#define GD32E23XF4          0x10
+#define GD32E23XF6          0x20
+#define GD32E23XF8          0x40
+
 /* >>>>>>>>>>>>>>>>>>>>[RS485 PHY DEFINE]<<<<<<<<<<<<<<<<<<<< */

 // #define RS485_MAX13487 // RS485 PHY : MAX13487 (AutoDir)
@@ -16,6 +20,28 @@
 // #define DEBUG_VERBOSE // Debug Assertions Status : Debug Verbose Information
 #undef  DEBUG_VERBOSE // Debug Assertions Status : No Debug Verbose Information

+/* >>>>>>>>>>>>>>>>>>>>[EDDY DRIVE CURRENT DETECTION]<<<<<<<<<<<<<<<<<<<< */
+
+// #define EDDY_DRIVE_CURRENT_DETECTION // Eddy Drive Current Detection : Enable
+#undef  EDDY_DRIVE_CURRENT_DETECTION // Eddy Drive Current Detection : Disable
+
+/******************************************************************************/
+
+/* Dynamic USART Configuration Structure */
+typedef struct {
+    uint32_t rcu_usart;
+    uint32_t usart_periph;
+    IRQn_Type irq_type;
+    void (*irq_handler)(void);  // 函数指针：指向中断处理函数
+} usart_config_t;
+
+extern usart_config_t g_usart_config;
+extern uint8_t g_mcu_flash_size;
+
+/* USART中断处理函数声明 */
+void usart0_irq_handler(void);
+void usart1_irq_handler(void);
+
 /******************************************************************************/

 #define RCU_GPIO_I2C         RCU_GPIOF
@@ -30,22 +56,25 @@

 /******************************************************************************/

+#define LED_RCU              RCU_GPIOA
 #define LED_PORT             GPIOA
 #define LED_PIN              GPIO_PIN_7
-#define LED_RCU              RCU_GPIOA

 /******************************************************************************/

-#define RS485_RCU            RCU_USART0
+#define RS485_RCU            (g_usart_config.rcu_usart)
+#define RS485_PHY            (g_usart_config.usart_periph)
+#define RS485_IRQ            (g_usart_config.irq_type)
 #define RS485_GPIO_RCU       RCU_GPIOA
 #define RS485_GPIO_PORT      GPIOA
+#define RS485_EN_PIN         GPIO_PIN_1
 #define RS485_TX_PIN         GPIO_PIN_2
 #define RS485_RX_PIN         GPIO_PIN_3
-#define RS485_PHY            USART0
 #define RS485_BAUDRATE       115200U
-#define RS485_EN_PIN         GPIO_PIN_1
-#define RS485_IRQ            USART0_IRQn

 /******************************************************************************/

+void mcu_detect_and_config(void);
+uint8_t get_flash_size(void);
+
 #endif //BOARD_CONFIG_H
--- a/Inc/command.h
+++ b/Inc/command.h
@@ -17,7 +17,8 @@
 */

 /** @brief 传感器周期上报使能标志 */
-extern volatile bool g_sensor_report_enabled;
+extern volatile bool g_eddy_current_sensor_report_enabled;
+extern volatile bool g_temperature_sensor_report_enabled;

 /**
 * @section Command_Protocol 协议格式
@@ -62,23 +63,42 @@ extern volatile bool g_sensor_report_enabled;
 */

 /**
- * @brief 获取传感器周期上报使能状态。
+ * @brief 获取电涡流传感器周期上报使能状态。
 * @return bool 上报状态。
 * @retval true  传感器周期上报已启用。
 * @retval false 传感器周期上报已禁用。
 * @ingroup Command
 */
-bool get_sensor_report_enabled(void);
+bool get_eddy_sensor_report_enabled(void);

 /**
- * @brief 设置传感器周期上报使能状态。
+ * @brief 设置电涡流传感器周期上报使能状态。
 * @param enabled 上报使能标志。
 * @arg true  启用传感器周期上报。
 * @arg false 禁用传感器周期上报。
 * @note 推荐通过此函数修改状态，便于后续功能扩展。
 * @ingroup Command
 */
-void set_sensor_report_status(bool enabled);
+void set_eddy_sensor_report_status(bool enabled);
+
+/**
+ * @brief 获取温度传感器周期上报使能状态。
+ * @return bool 上报状态。
+ * @retval true  传感器周期上报已启用。
+ * @retval false 传感器周期上报已禁用。
+ * @ingroup Command
+ */
+bool get_temp_sensor_report_enabled(void);
+
+/**
+ * @brief 设置温度传感器周期上报使能状态。
+ * @param enabled 上报使能标志。
+ * @arg true  启用传感器周期上报。
+ * @arg false 禁用传感器周期上报。
+ * @note 推荐通过此函数修改状态，便于后续功能扩展。
+ * @ingroup Command
+ */
+void set_temp_sensor_report_status(bool enabled);

 /**
 * @brief 处理串口环形缓冲区中的命令数据。
@@ -103,4 +123,6 @@ void handle_command(const uint8_t *cmd, uint8_t len);

 void eddy_current_report(void);

+void temperature_raw_value_report(void);
+
 #endif // COMMAND_H
--- a/Inc/ldc1612.h
+++ b/Inc/ldc1612.h
@@ -14,7 +14,6 @@
 #include <stdlib.h>
 #include <math.h>
 #include "board_config.h"
-#include "soft_i2c.h"
 #include "i2c.h"

 /***************************************************************************/
@@ -32,60 +31,153 @@

 /***************************************************************************/

-#define LDC1612_ADDR         0x2B
+#define LDC1612_ADDR         (0x2B)

-/*Register Rddr*/
-/***************************************************************************/
+/************************Register Addr***************************************/

 #define CONVERTION_RESULT_REG_START             0X00
 #define SET_CONVERSION_TIME_REG_START           0X08
 #define SET_CONVERSION_OFFSET_REG_START         0X0C
-#define SET_LC_STABILIZE_REG_START              0X10
+#define SET_SETTLECOUNT_REG_START               0X10
 #define SET_FREQ_REG_START                      0X14

 #define SENSOR_STATUS_REG                       0X18
 #define ERROR_CONFIG_REG                        0X19
 #define SENSOR_CONFIG_REG                       0X1A
-#define MUL_CONFIG_REG                          0X1B
+#define MUX_CONFIG_REG                          0X1B
 #define SENSOR_RESET_REG                        0X1C
 #define SET_DRIVER_CURRENT_REG                  0X1E

 #define READ_MANUFACTURER_ID                    0X7E
 #define READ_DEVICE_ID                          0X7F

-/******************************************************************************/
+/**********************Sensor Channel****************************************/

 #define CHANNEL_0  0
 #define CHANNEL_1  1

-/*************************MUX_CONFIG********************************************/
-#define LDC1612_MUX_CONFIG                 0x0200
+/*************************MUX_CONFIG********************************************
+ * 0x0209 AutoScanEN: 0 / RR_SEQ: 00 / RESERVED: 0 0010 0000 1 / Deglitch: 001(  1MHz)
+ * 0x020C AutoScanEN: 0 / RR_SEQ: 00 / RESERVED: 0 0010 0000 1 / Deglitch: 100(3.3MHz)
+ * 0x020D AutoScanEN: 0 / RR_SEQ: 00 / RESERVED: 0 0010 0000 1 / Deglitch: 100( 10MHz)
+ * 0x020F AutoScanEN: 0 / RR_SEQ: 00 / RESERVED: 0 0010 0000 1 / Deglitch: 100( 33MHz)
+*/
+#define LDC1612_MUX_CONFIG                 0x020C

-/***********************SENSOR_CONFIG********************************************/
+/***********************SENSOR_CONFIG********************************************
+ * 0x1601 Active CH0: 00 / SLEEP: 0 / OVERDRIVE: 1 / LowPowerMode: 0 / AutoAmpDis 1 / CLK(ext): 1 / RESERVED: 0 / INTB_Dis : 0 / HighCurrent: 0 / RESERVED: 00 0001
+ * 0x1201 Active CH0: 00 / SLEEP: 0 / OVERDRIVE: 1 / LowPowerMode: 0 / AutoAmpDis 0 / CLK(ext): 1 / RESERVED: 0 / INTB_Dis : 0 / HighCurrent: 0 / RESERVED: 00 0001
+ * 0x1641 Active CH0: 00 / SLEEP: 0 / OVERDRIVE: 1 / LowPowerMode: 0 / AutoAmpDis 1 / CLK(ext): 1 / RESERVED: 0 / INTB_Dis : 0 / HighCurrent: 1 / RESERVED: 00 0001
+ * 0x1241 Active CH0: 00 / SLEEP: 0 / OVERDRIVE: 1 / LowPowerMode: 0 / AutoAmpDis 0 / CLK(ext): 1 / RESERVED: 0 / INTB_Dis : 0 / HighCurrent: 1 / RESERVED: 00 0001
+*/ 

-#define LDC1612_SENSOR_CONFIG_CH0          0x1601 // 
+#ifdef EDDY_DRIVE_CURRENT_DETECTION
+    #define LDC1612_SENSOR_CONFIG_CH0      0x1241
+#else
+    #define LDC1612_SENSOR_CONFIG_CH0      0x1641
+#endif
+#define LDC1612_SLEEP_MODE                 0x2801

-/****************************CONVERSION_TIME************************************/
-#define LDC1612_CONVERSION_TIME_CH0        0x1000 // 0x1000=4096个时钟周期
-#define LC_STABILIZE_TIME_CH0              0x0020 // 0x0020=32个时钟周期
+/****************************CONVERSION_TIME************************************
+ * Freq_ref = 40MHz / CHx_FREF_DIVIDER
+ * ******RCOUNT_CHx*******
+ * Reference Count Conversion Interval Time
+ * 0x0005 ~ 0xFFFF
+ * default: 0x0080
+ * RCOUNT_CHx * 16 / Freq_ref = Conversion Interval Time
+ * 
+ * ******SETTLECOUNT_CHx*******
+ * Conversion Settling Time
+ * 0x0000 ~ 0xFFFF
+ * default: 0x0000
+ * SETTLECOUNT_CHx * 16 / Freq_ref = Conversion Settling Time
+ * 0x1000 4096*16个时钟周期
+ * 0x0100 256*16个时钟周期
+ * 0x0000/0x0001 32*16个时钟周期
+ * 
+ * ******RCOUNT_CHx*******
+*/
+#define LDC1612_RCOUNT_TIME_CH0            0x1000 // 0x1000=4096个时钟周期
+#define LDC1612_SETTLECOUNT_CH0            0x0100

-/**************************DRIVE_CURRENT****************************************/
-#define LDC1612_DRIVE_CURRENT              0x9000  //A000
+/**************************DRIVE_CURRENT****************************************
+ * 0xA000 CH_IDRIVE: 1010 0 / CH_INIT_IDRIVE: 000 00 / RESERVED: 00 0000
+ * 0x9000 CH_IDRIVE: 1001 0 / CH_INIT_IDRIVE: 000 00 / RESERVED: 00 0000
+ * CH_INIT_IDRIVE will update when every conversion systick ==>AutoAmpDis is 0
+ * CH_INIT_IDRIVE will store init drive current calculated ==> AutoAmpDis is 1
+*/  
+#define LDC1612_DRIVE_CURRENT              0x9000

 /**************************SENSOR_CONFIG***************************************/
-#define LDC1612_SLEEP_MODE                 0x2801
-/**************************OTHER_CONFIG*****************************************/
+
+
+
+/**************************ERROR_CONFIG****************************************
+ * [15] Under-Range ERR to OUT (DATA_CHx.CHx_ERR_UR)
+ * [14] Over-Range ERR to OUT (DATA_CHx.CHx_ERR_OR)
+ * [13] Watchdog-Timeout ERR to OUT (DATA_CHx.CHx_ERR_WD)
+ * [12] Amplitude-High-Error ERR to OUT (DATA_CHx.CHx_ERR_AE)
+ * [11] Amplitude-Low-Error ERR to OUT (DATA_CHx.CHx_ERR_AE)
+ * [10] RESERVED
+ * [ 9] RESERVED
+ * [ 8] RESERVED
+ * [ 7] Under-Range ERR to INTB (STATUS.ERR_UR)
+ * [ 6] Over-Range ERR to INTB (STATUS.ERR_OR)
+ * [ 5] Watchdog-Timeout ERR to INTB (STATUS.ERR_WD)
+ * [ 4] Amplitude-High-Error ERR to INTB (STATUS.ERR_AHE)
+ * [ 3] Amplitude-Low-Error ERR to INTB (STATUS.ERR_ALE)
+ * [ 2] Zero_Count_Error ERR to INTB (STATUS.ERR_ZC)
+ * [ 1] RESERVED
+ * [ 0] Data_Ready_Flag to INTB (STATUS.DRDY)
+ * 
+ * 0x0000 No ERR to OUT or INTB
+*/
+
 #define LDC1612_ERROR_CONFIG               0x0000
+
+/**************************STATUS****************************************
+ * [15] 
+ * [14] Error Channel 0b00: CH0 / 0b01: CH1 / 0b10: CH2 / 0b11: CH3
+ * [13] Conversion Under-Range Error 0b0: No / 0b1: Yes
+ * [12] Conversion Over-Range Error 0b0: No / 0b1: Yes
+ * [11] Watchdog Timeout Error 0b0: No / 0b1: Yes
+ * [10] Amplitude High Error 0b0: No / 0b1: Yes
+ * [ 9] Amplitude Low Error 0b0: No / 0b1: Yes
+ * [ 8] Zero Count Error 0b0: No / 0b1: Yes
+ * [ 7] RESERVED
+ * [ 6] Ddata Ready Flag 0b0: No new results / 0b1: New results available
+ * [ 5] RESERVED
+ * [ 4] RESERVED
+ * [ 3] CH0 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH0)
+ * [ 2] CH1 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH1)
+ * [ 1] CH2 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH2)
+ * [ 0] CH3 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH3)
+ * 
+ * 0x0000 No ERR to OUT or INTB
+*/
+
+/*****************CONVERSION_OFFSET_CONFIG****************************************/
+
 #define SET_CONVERSION_OFFSET_CH0          0x0000 
+
+/***********************RESET DEVICE********************************************
+0x8000 RESET_DEV: 1 / RESERVED: 000 0000 0000 0000
+*/ 
+
 #define LDC1612_RESET_DEV                  0x8000 //[15:0] 0b1000 0000 0000 0000

+/***********************IDs****************************************************/
+
+#define LDC1612_MANUFACTURER_ID            0x5449
+#define LDC1612_DEVICE_ID                  0x3055
+
 /******************************************************************************/

 #define COIL_RP_KOM              7.2
-#define COIL_L_UH                33
+#define COIL_L_UH                11.22
 #define COIL_C_PF                150
-#define COIL_Q_FACTOR            35.97
-#define COIL_FREQ_HZ             2262000
+#define COIL_Q_FACTOR            31.09
+#define COIL_FREQ_HZ             5323770

 /******************************************************************************/

@@ -112,7 +204,7 @@ uint16_t ldc1612_get_deveice_id(void);

 uint32_t ldc1612_get_raw_channel_result(uint8_t channel);

-uint32_t ldc1612_parse_raw_result(uint32_t raw_result);
+void ldc1612_drvie_current_detect(uint8_t channel);

 uint16_t ldc1612_get_sensor_status(void);

--- a/Inc/sensor_example.h
+++ b/Inc/sensor_example.h
@@ -1,28 +0,0 @@
-//
-// Sensor Usage Example Header
-// 传感器使用示例头文件
-//
-
-#ifndef SENSOR_EXAMPLE_H
-#define SENSOR_EXAMPLE_H
-
-#include "gd32e23x.h"
-#include "board_config.h"
-
-/*!
-    \brief      传感器初始化示例
-    \param[in]  none
-    \param[out] none
-    \retval     none
-*/
-void sensors_init_example(void);
-
-/*!
-    \brief      传感器读取示例
-    \param[in]  none
-    \param[out] none
-    \retval     none
-*/
-void sensors_read_example(void);
-
-#endif // SENSOR_EXAMPLE_H
--- a/Inc/tmp112.h
+++ b/Inc/tmp112.h
@@ -19,7 +19,7 @@

 /******************************************************************************/
 /* TMP112A I2C Address */
-#define TMP112A_ADDR                            (0x48)  // 7-bit address (ADD0=GND)
+#define TMP112A_ADDR                            (0x49)  // 7-bit address (ADD0=GND)

 /* Register Addresses */
 /******************************************************************************/
@@ -59,7 +59,7 @@

 /* Default Configuration */
 /******************************************************************************/
-#define TMP112A_CONFIG_DEFAULT                  (TMP112A_RESOLUTION_12BIT | TMP112A_RATE_4HZ)
+#define TMP112A_CONFIG_DEFAULT                  (TMP112A_RESOLUTION_12BIT | TMP112A_RATE_8HZ)

 /* Temperature Conversion Constants */
 /******************************************************************************/
@@ -111,6 +111,8 @@ tmp112a_status_t tmp112a_config(uint16_t config);
 */
 tmp112a_status_t tmp112a_read_temperature(tmp112a_result_t *result);

+void tmp112a_get_raw_temperature_value(uint8_t *value);
+
 /*!
    \brief      设置温度阈值
    \param[in]  low_temp: 低温阈值 (°C)
--- a/LDC1612_COIL_TEST_GUIDE.md
+++ b/LDC1612_COIL_TEST_GUIDE.md
@@ -1,281 +0,0 @@
-# LDC1612 线圈性能测试指南
-
-## 概述
-这份文档详细说明如何使用M1-M9命令来测试和分析LDC1612线圈的性能特性。
-
-## 测试命令总览
-
-| 命令 | 功能 | 响应字节数 | 主要用途 |
-|------|------|-----------|----------|
-| M1 | 强制读取传感器数据 | 4 | 获取原始传感器数据 |
-| M2 | 通信测试 | 4 | 验证通信链路 |
-| M3 | 高电流驱动测试 | 6 | 测试提高驱动电流的效果 |
-| M4 | 寄存器诊断 | 8 | 检查配置寄存器状态 |
-| M5 | 最高电流启动测试 | 8 | 极限参数启动尝试 |
-| M6 | 芯片功能验证 | 12 | 验证LDC1612芯片正常工作 |
-| M7 | 保守参数测试 | 10 | 使用保守配置测试 |
-| M8 | 极端参数测试 | 6 | 使用极端配置强制启动 |
-| M9 | 多频率特性测试 | 8 | 对比不同频率配置效果 |
-
---
-
-## 详细命令分析
-
-### M1 命令 - 强制读取传感器数据
-**命令**: `D5 03 02 4D 31 83`  
-**响应**: `B5 F0 04 [4字节数据] CRC`
-
-**响应数据解析**:
-```
-[0-3]: 32位原始传感器数据（大端序）
-       - 高4位：错误标志（通常忽略）
-       - 低28位：有效传感器数据
-```
-
-**使用场景**: 在您已经有工作配置的情况下，直接获取传感器数据
-
---
-
-### M2 命令 - 通信测试
-**命令**: `D5 03 02 4D 32 84`  
-**响应**: `B5 F0 04 DD CC BB AA [CRC]`
-
-**分析要点**: 如果响应不是固定的`DD CC BB AA`，说明通信有问题
-
---
-
-### M3 命令 - 高电流驱动测试
-**命令**: `D5 03 02 4D 33 85`  
-**响应**: `B5 F0 06 [6字节数据] CRC`
-
-**响应数据解析**:
-```
-[0-1]: 传感器状态寄存器（大端序）
-       bit[7]: DRDY_1 - 通道1数据就绪
-       bit[6]: DRDY_0 - 通道0数据就绪  
-       bit[5]: UNREAD_CONV - 未读转换结果
-       bit[4]: ERR_ZC - 零计数错误
-       bit[3]: ERR_AE - 幅度错误（重点关注）
-       bit[2]: ERR_WD - 看门狗超时
-       bit[1]: ERR_OR - 过量程错误
-       bit[0]: ERR_UR - 欠量程错误
-[2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
-[3]: 0xA0 - 高电流测试标记
-[4]: 幅度错误专用标志 (0xAE=有幅度错误, 0x00=无)
-[5]: 0x33 - M3命令标记
-```
-
-**分析要点**:
- 如果[0-1]从0x0008变为其他值，说明高电流有效果
- 如果[2]变为0x01，说明数据开始就绪
- 如果[4]变为0x00，说明幅度错误消失
-
---
-
-### M4 命令 - 寄存器诊断
-**命令**: `D5 03 02 4D 34 86`  
-**响应**: `B5 F0 08 [8字节数据] CRC`
-
-**响应数据解析**:
-```
-[0-1]: 状态寄存器 (0x18) - 当前传感器状态
-[2-3]: 传感器配置寄存器 (0x1A) - 传感器工作模式
-       期望值: 0x1601 (活动模式，单通道)
-[4-5]: 驱动电流寄存器 (0x1E) - 当前驱动电流设置  
-       常见值: 0x9000(默认), 0xA000(高), 0xF800(最高)
-[6]: I2C读取状态 (0x4F='O'=成功, 0xEE=失败)
-[7]: 0x44 - M4命令标记
-```
-
-**分析要点**:
- [2-3]应该是0x1601，如果不是说明配置异常
- [4-5]显示实际的驱动电流设置
- [6]必须是0x4F，否则I2C通信有问题
-
---
-
-### M5 命令 - 最高电流启动测试
-**命令**: `D5 03 02 4D 35 87`  
-**响应**: `B5 F0 08 [8字节数据] CRC`
-
-**响应数据解析**:
-```
-[0-1]: 传感器状态寄存器（启动后状态）
-[2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
-[3-4]: 实际驱动电流设置值（应该是0xF800）
-[5]: 幅度错误专用标志 (0xAE=仍有错误, 0x00=错误消失)
-[6]: 0x55 - M5命令标记
-[7]: 0xF8 - 最高电流标记
-```
-
-**分析要点**:
- 这是最激进的启动尝试
- 如果[5]仍是0xAE，说明线圈物理特性不兼容
- [3-4]验证电流设置是否生效
-
---
-
-### M6 命令 - 芯片功能验证
-**命令**: `D5 03 02 4D 36 88`  
-**响应**: `B5 F0 0C [12字节数据] CRC`
-
-**响应数据解析**:
-```
-[0-1]: 写入测试值 (0x9000)
-[2-3]: 读取回的值
-[4-5]: 制造商ID (应该是0x5449="TI")
-[6-7]: 设备ID (应该是0x3055)
-[8-9]: 当前状态寄存器
-[10]: ID读取状态 (0x4F=成功, 0xEE=失败)
-[11]: 0x66 - M6命令标记
-```
-
-**分析要点**:
- [4-5]必须是0x5449，确认是正品TI芯片
- [6-7]应该是0x3055，确认是LDC1612型号
- [10]必须是0x4F，确认芯片通信正常
-
---
-
-### M7 命令 - 保守参数测试
-**命令**: `D5 03 02 4D 37 89`  
-**响应**: `B5 F0 0A [10字节数据] CRC`
-
-**响应数据解析**:
-```
-[0-1]: 状态寄存器
-[2]: 数据就绪标志
-[3-4]: 实际频率分频器设置 (0x2000=较低频率)
-[5]: 幅度错误标志 (0xAE=有错误, 0x00=无)
-[6]: 欠量程错误标志 (0x01=有, 0x00=无)
-[7]: 过量程错误标志 (0x02=有, 0x00=无)
-[8]: 0x77 - M7命令标记
-[9]: 0x20 - 低频标记
-```
-
-**分析要点**:
- 使用保守配置（低频率、长稳定时间）
- [6][7]指示电感值范围问题
-
---
-
-### M8 命令 - 极端参数测试
-**命令**: `D5 03 02 4D 38 8A`  
-**响应**: `B5 F0 06 [6字节数据] CRC`
-
-**响应数据解析**:
-```
-[0-1]: 传感器状态寄存器
-[2]: 数据就绪标志
-[3]: 幅度错误标志 (0xAE=仍有错误, 0x00=错误消失)
-[4]: 0x88 - M8命令标记
-[5]: 0xEE - 极端测试标记
-```
-
-**分析要点**:
- 使用极低频率(0x4000)和最大电流(0xFF00)
- 如果[3]仍是0xAE，说明线圈根本无法工作
-
---
-
-### M9 命令 - 多频率特性测试
-**命令**: `D5 03 02 4D 39 8B`  
-**响应**: `B5 F0 08 [8字节数据] CRC`
-
-**响应数据解析**:
-```
-[0-1]: 高频测试状态
-[2]: 高频就绪标志 (0x01=就绪, 0x00=未就绪)
-[3-4]: 低频测试状态
-[5]: 低频就绪标志 (0x01=就绪, 0x00=未就绪)
-[6]: 0x99 - M9命令标记
-[7]: 0xAA - 多频测试标记
-```
-
-**分析要点**:
- 对比高频低电流 vs 低频高电流的效果
- 如果某个配置工作，说明找到了合适的参数范围
-
---
-
-## 线圈诊断流程
-
-### 步骤1: 基础验证
-1. 执行M2确认通信正常
-2. 执行M6确认芯片功能正常
-
-### 步骤2: 状态诊断  
-1. 执行M4查看当前配置状态
-2. 如果状态寄存器是0x0008，说明有幅度错误
-
-### 步骤3: 参数优化测试
-1. 执行M3测试高电流是否有改善
-2. 执行M5测试最高电流极限启动
-3. 执行M7测试保守参数配置
-4. 执行M8测试极端参数配置
-
-### 步骤4: 特性分析
-1. 执行M9进行多频率对比测试
-2. 分析哪种配置最接近成功
-
-### 步骤5: 数据读取
-1. 如果找到工作配置，执行M1获取数据
-2. 如果所有测试都失败，确认线圈不兼容
-
---
-
-## 常见问题诊断
-
-### 所有命令都显示幅度错误 (0x0008)
-**可能原因**:
- 线圈电感值超出范围 (< 1μH 或 > 18mH)
- 线圈Q值过低 (< 5)
- 线圈物理损坏（开路或短路）
- 线圈周围有金属干扰
-
-**解决方案**:
-1. 用万用表测量线圈直流电阻
-2. 用LCR表测量线圈电感值和Q值
-3. 更换符合规格的线圈
-
-### M6显示错误的设备ID
-**可能原因**:
- 使用了非正品芯片
- I2C地址配置错误
- 芯片损坏
-
-### 部分命令有效果但数据不稳定
-**可能原因**:
- 线圈参数在边界范围
- 外部干扰
- 电源噪声
-
-**解决方案**:
-1. 优化PCB布局
-2. 改善电源滤波
-3. 调整线圈参数
-
---
-
-## 推荐线圈规格
-
-```
-电感值: 10μH - 1mH
-Q值: > 15 (在工作频率下)
-线径: 0.1-0.5mm 漆包线
-绕制: 单层紧密绕制，避免交叉
-工作频率: 1-10MHz
-直流电阻: 1-50欧姆
-```
-
---
-
-## 总结
-
-通过这套完整的测试命令，您可以：
-1. 快速诊断线圈兼容性问题
-2. 找到最优的工作参数
-3. 验证硬件和软件功能
-4. 分析线圈的频率特性
-
-如果M8和M9都显示幅度错误，强烈建议更换线圈或调整线圈参数。
--- a/LDC1612_CONFIG_SEQUENCE.md
+++ b/LDC1612_CONFIG_SEQUENCE.md
@@ -1,222 +0,0 @@
-# LDC1612 正确配置顺序说明
-
-## 📋 **配置顺序重要性**
-
-LDC1612的配置顺序**非常关键**，错误的顺序可能导致：
- 传感器无法正常工作
- 数据不准确
- 功耗异常
- 系统不稳定
-
-## 🔄 **完整初始化配置流程**
-
-### **阶段一：硬件复位和验证**
-
-```c
-ldc1612_status_t ldc1612_complete_init(void) {
-    /* 1. 硬件复位 - 必须第一步 */
-    ldc1612_reset_sensor();
-    delay_ms(100);  // 重要：等待复位完成
-    
-    /* 2. 验证设备身份 */
-    uint16_t manufacturer_id = ldc1612_get_manufacturer_id();
-    uint16_t device_id = ldc1612_get_deveice_id();
-    
-    if (manufacturer_id != 0x5449 || device_id != 0x3055) {
-        return LDC1612_STATUS_ERROR;
-    }
-    
-    /* 3. 进入配置阶段 */
-    return ldc1612_config_single_channel(CHANNEL_0);
-}
-```
-
-### **阶段二：通道配置（严格顺序）**
-
-#### **Step 1: 进入睡眠模式**
-```c
-// 配置前必须让传感器进入睡眠模式
-ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SLEEP_MODE);
-delay_ms(10);
-```
-**原因**：确保传感器停止工作，避免配置冲突
-
-#### **Step 2: 频率分频配置**
-```c
-ldc1612_set_freq_divide(channel);
-delay_ms(5);
-```
-**原因**：
- 这是最基础的配置，影响所有后续参数
- 必须根据LC谐振频率正确计算
- 公式：`f_sensor = 1/(2π√(LC))`
-
-#### **Step 3: LC稳定时间**
-```c
-ldc1612_set_LC_stabilize_time(channel, LC_STABILIZE_TIME_CH0);
-```
-**原因**：
- 影响测量精度
- 时间太短可能导致不稳定
- 时间太长影响响应速度
-
-#### **Step 4: 转换时间**
-```c
-ldc1612_set_conversion_time(channel, LDC1612_CONVERSION_TIME_CH0);
-```
-**原因**：
- 影响测量精度和速度的平衡
- 值越大精度越高但速度越慢
-
-#### **Step 5: 转换偏移**
-```c
-ldc1612_set_conversion_offset(channel, 0x0000);
-```
-**原因**：
- 通常设为0，除非有特殊校准需求
-
-#### **Step 6: 驱动电流**
-```c
-ldc1612_set_drive_current(channel, LDC1612_DRIVE_CURRENT);
-```
-**原因**：
- 影响传感器灵敏度和功耗
- 电流越大灵敏度越高但功耗也越大
-
-#### **Step 7: 多路复用器配置**
-```c
-ldc1612_set_mux_config(LDC1612_MUX_CONFIG);
-```
-**原因**：
- 设置通道选择和滤波器带宽
- 影响噪声抑制和响应速度
-
-#### **Step 8: 错误配置**
-```c
-ldc1612_set_error_config(LDC1612_ERROR_CONFIG);
-```
-**原因**：
- 配置错误输出行为
- 通常设为0（所有错误输出启用）
-
-#### **Step 9: 启动传感器**
-```c
-ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SENSOR_CONFIG);
-delay_ms(50);
-```
-**原因**：
- **必须最后一步**
- 启动传感器开始正常工作
- 需要等待稳定时间
-
-## ⚠️ **常见配置错误**
-
-### **1. 配置顺序错误**
-```c
-// ❌ 错误：先启动传感器再配置
-ldc1612_set_sensor_config(LDC1612_SENSOR_CONFIG);
-ldc1612_set_freq_divide(CHANNEL_0);  // 太晚了！
-
-// ✅ 正确：先配置后启动
-ldc1612_set_freq_divide(CHANNEL_0);
-ldc1612_set_sensor_config(LDC1612_SENSOR_CONFIG);
-```
-
-### **2. 缺少延时**
-```c
-// ❌ 错误：没有等待复位完成
-ldc1612_reset_sensor();
-ldc1612_get_manufacturer_id();  // 可能读取失败
-
-// ✅ 正确：适当延时
-ldc1612_reset_sensor();
-delay_ms(100);
-ldc1612_get_manufacturer_id();
-```
-
-### **3. 频率分频计算错误**
-```c
-// ❌ 错误：使用固定值
-#define FREQ_DIV_VALUE  0x1002
-
-// ✅ 正确：根据LC参数计算
-sensor_freq = 1 / (2 * PI * sqrt(L * C));
-fin_div = (uint16_t)(sensor_freq / 8.75 + 1);
-```
-
-## 📊 **配置参数说明**
-
-| 参数 | 地址 | 当前值 | 说明 |
-|------|------|--------|------|
-| 频率分频 | 0x14 | 0x1002 | 根据LC计算得出 |
-| LC稳定时间 | 0x10 | 0x001E | 30个时钟周期 |
-| 转换时间 | 0x08 | 0x0546 | 1350个参考时钟 |
-| 驱动电流 | 0x1E | 0x9000 | 高驱动电流 |
-| 多路复用 | 0x1B | 0x020C | 单通道，3.3MHz带宽 |
-| 传感器配置 | 0x1A | 0x1601 | 启用传感器，连续模式 |
-
-## 🔍 **验证配置是否正确**
-
-```c
-void verify_ldc1612_config(void) {
-    uint16_t status = ldc1612_get_sensor_status();
-    
-    printf("Status: 0x%04X\n", status);
-    
-    // 检查数据就绪
-    if (ldc1612_is_data_ready(CHANNEL_0)) {
-        printf("✓ Channel 0 data ready\n");
-    }
-    
-    // 检查错误
-    if (status & 0xFF00) {
-        printf("✗ Error detected: 0x%04X\n", status);
-    } else {
-        printf("✓ No errors detected\n");
-    }
-}
-```
-
-## 📚 **TI官方建议的最佳实践**
-
-1. **总是先复位**：每次配置前都要复位传感器
-2. **验证设备ID**：确保通信正常
-3. **睡眠模式配置**：配置期间保持睡眠状态
-4. **频率优先**：频率分频必须最先配置
-5. **启动最后**：传感器配置必须最后设置
-6. **适当延时**：每个关键步骤后都要延时
-7. **状态检查**：配置完成后检查状态寄存器
-
-## 🎯 **推荐使用方式**
-
-```c
-// 推荐的初始化流程
-int main(void) {
-    // 系统初始化
-    system_init();
-    
-    // IIC初始化
-    #ifdef SOFTWARE_IIC
-        soft_i2c_config();
-    #else
-        i2c_config();
-    #endif
-    
-    // LDC1612完整初始化
-    if (ldc1612_complete_init() != LDC1612_STATUS_SUCCESS) {
-        printf("LDC1612 initialization failed!\n");
-        while(1);
-    }
-    
-    printf("LDC1612 initialization success!\n");
-    
-    // 主循环
-    while (1) {
-        if (ldc1612_is_data_ready(CHANNEL_0)) {
-            uint32_t data = ldc1612_get_raw_channel_result(CHANNEL_0);
-            // 处理数据
-        }
-        delay_ms(100);
-    }
-}
-```
--- a/LDC1612_Configuration_Reference.md
+++ b/LDC1612_Configuration_Reference.md
@@ -1,149 +0,0 @@
-# LDC1612 Configuration Reference Guide
-
-## 概述
-本文档为德州仪器 LDC1612 电感数字转换器提供全面的配置指导。LDC1612 是一款高分辨率、多通道的电感式传感应用芯片。
-
---
-
-## 总测量周期配置
-
-### 寄存器信息
-| 参数 | 通道0地址 | 通道1地址 | 数据位宽 | 寄存器名称 |
-|------|-----------|-----------|----------|------------|
-| 转换时间 | 0x08 | 0x09 | 16位 | CONVERSION_TIME_CHx |
-| LC稳定时间 | 0x10 | 0x11 | 16位 | LC_STABILIZE_TIME_CHx |
-
-### 功能说明
- **转换时间**: 决定ADC转换精度和数据更新率
- **LC稳定时间**: LC振荡器稳定所需时间，影响测量精度
- **约束条件**: LC稳定时间 < 转换时间
-
-### 取值范围
-**转换时间寄存器**:
- 最小值: 0x0100 (256个时钟周期)
- 最大值: 0x1FFF (8191个时钟周期)
- 推荐范围: 0x0200 - 0x1800
-
-**LC稳定时间寄存器**:
- 最小值: 0x0004 (4个时钟周期)
- 最大值: 0xFFFF (65535个时钟周期)
- 推荐范围: 0x0010 - 0x0100
-
-### 计算公式
-```
-转换时间 = 转换设置值 × (1 / f_REF_CLK)
-LC稳定时间 = 稳定设置值 × (1 / f_REF_CLK) 
-总测量时间 = LC稳定时间 + 转换时间
-数据更新率 = f_REF_CLK / (稳定设置值 + 转换设置值)
-
-其中: f_REF_CLK = 40MHz (LDC1612内部参考时钟)
-```
-
-### 常用配置档位
-
-| 档位 | 转换时间设置 | LC稳定时间设置 | 总测量时间 | 数据更新率 | 适用场景 |
-|------|--------------|----------------|------------|------------|----------|
-| 超高速 | 0x0200 (512周期) | 0x0010 (16周期) | 13.2μs | ~75.8kSPS | 振动检测 |
-| 高速 | 0x0400 (1024周期) | 0x0010 (16周期) | 26.0μs | ~38.5kSPS | 快速响应 |
-| 平衡 | 0x0800 (2048周期) | 0x0020 (32周期) | 52.0μs | ~19.2kSPS | 一般应用 |
-| 高精度 | 0x1000 (4096周期) | 0x0020 (32周期) | 103.2μs | ~9.7kSPS | 精密测量 |
-| 超高精度 | 0x1800 (6144周期) | 0x0040 (64周期) | 155.2μs | ~6.5kSPS | 实验室级 |
-
-### 典型应用场景配置
-
-#### 1. 振动监测/快速运动跟踪
- **转换时间**: 0x0200 (512周期)
- **LC稳定时间**: 0x0010 (16周期)
- **性能**: ~75.8kSPS，适中精度
-
-#### 2. 一般工业传感/位置检测  
- **转换时间**: 0x0800 (2048周期)
- **LC稳定时间**: 0x0020 (32周期)
- **性能**: ~19.2kSPS，平衡性能
-
-#### 3. 精密位移测量/材料检测
- **转换时间**: 0x1000 (4096周期)  
- **LC稳定时间**: 0x0020 (32周期)
- **性能**: ~9.7kSPS，高精度
-
-#### 4. 实验室级测量/恶劣环境
- **转换时间**: 0x1800 (6144周期)
- **LC稳定时间**: 0x0040 (64周期)  
- **性能**: ~6.5kSPS，最高稳定性
-
-### 选择策略
-1. **确定应用需求**: 响应速度、精度要求、环境条件
-2. **线圈特性考虑**: Q因子越高需要更长LC稳定时间
-3. **环境因素**: 温度变化大或电磁干扰强需增加时间参数
-4. **调试优化**: 从保守设置开始，逐步优化提高响应速度
-
---
-
-## 驱动电流配置
-
-### 寄存器信息
- **寄存器地址**: 0x1E (通道0), 0x1F (通道1)
- **数据位宽**: 16位
- **功能**: 控制LC振荡器的驱动电流强度
-
-### 取值范围
- **最小值**: 0x0000 (最小驱动电流)
- **最大值**: 0xFFFF (最大驱动电流)  
- **常用范围**: 0x8000 - 0xC000
- **推荐起始值**: 0x9000
-
-### 驱动电流档位
-
-| 设置值 | 相对强度 | 适用场景 | 特点 |
-|--------|----------|----------|------|
-| 0x8000 | 低 | 小线圈、近距离检测 | 低功耗，灵敏度适中 |
-| 0x9000 | 中等 | 一般应用 | 平衡性能，通用设置 |
-| 0xA000 | 较高 | 大线圈、远距离检测 | 高灵敏度，功耗较高 |
-| 0xC000 | 高 | 极端环境、最大灵敏度 | 最高性能，最大功耗 |
-
---
-
-## 传感器配置寄存器
-
-### 寄存器信息
- **寄存器地址**: 0x1A
- **数据位宽**: 16位
- **当前设置**: 0x1A23
-
-### 关键位域功能
-
-| 位域 | 功能 | 当前值 | 说明 |
-|------|------|--------|------|
-| 位15-14 | 活动通道选择 | 00 | 通道0活动 |
-| 位13 | 睡眠模式控制 | 1 | 正常工作模式 |
-| 位11 | 激活序列选择 | 1 | 完整激活序列 |
-| 位10 | 自动幅度调整 | 0 | 启用自动幅度调整 |
-| 位9 | 时钟源选择 | 1 | 外部时钟源 |
-| 位1-0 | 去毛刺滤波 | 11 | 10MHz滤波(高EMI环境) |
-
-### 常用配置组合
-
-| 配置值 | 应用场景 | 特点 |
-|--------|----------|------|
-| 0x1601 | 手动模式+内部时钟 | 精确控制，稳定环境 |
-| 0x1821 | 自动模式+内部时钟 | 智能调整，一般环境 |
-| 0x1A21 | 自动模式+外部时钟 | 高性能，低噪声 |
-| 0x1A23 | 自动模式+外部时钟+增强滤波 | 高EMI环境 |
-
---
-
-## 注意事项
-
- 本文档将扩展更多LDC1612寄存器配置内容
- 所有时序计算基于40MHz内部参考时钟
- 实际性能可能因线圈特性和环境条件而异
- 请务必根据具体应用需求验证设置
-
---
-
-## 文档历史
-
- **版本1.0** (2025-08-17): 初始转换时间配置文档
- **版本1.1** (2025-08-17): 添加LC稳定时间配置和时序参数协调说明
- **版本1.2** (2025-08-17): 添加驱动电流配置和传感器配置寄存器说明
- **未来更新**: 将添加频率分频器、错误配置等更多寄存器配置说明
--- a/LDC1612_USAGE_EXAMPLE.md
+++ b/LDC1612_USAGE_EXAMPLE.md
@@ -1,178 +0,0 @@
-# LDC1612 驱动使用指南
-
-## 📌 概述
-
-LDC1612是TI公司的涡流传感器芯片，本驱动支持单通道(Channel 0)和双通道工作模式，并提供了硬件IIC和软件IIC的灵活切换。
-
-## 🔧 硬件IIC与软件IIC切换
-
-### 方法一：通过 board_config.h 配置（推荐）
-
-在 `Inc/board_config.h` 文件中修改以下配置：
-
-```c
-/* 使用软件IIC */
-#define SOFTWARE_IIC       // 启用软件IIC
-// #undef  SOFTWARE_IIC   // 注释掉这行
-
-/* 使用硬件IIC */
-// #define SOFTWARE_IIC    // 注释掉这行  
-#undef  SOFTWARE_IIC      // 使用硬件IIC
-```
-
-### 方法二：通过编译时定义
-
-在CMakeLists.txt中添加：
-
-```cmake
-# 使用软件IIC
-target_compile_definitions(${PROJECT_NAME} PRIVATE SOFTWARE_IIC)
-
-# 使用硬件IIC（移除上面的定义即可）
-```
-
-## 📋 LDC1612 初始化序列
-
-### 推荐的初始化步骤
-
-```c
-
-    
-    // 2. 检查传感器ID
-    uint16_t manufacturer_id = ldc1612_get_manufacturer_id();
-    uint16_t device_id = ldc1612_get_deveice_id();
-    
-    printf("Manufacturer ID: 0x%04X (Expected: 0x5449)\n", manufacturer_id);
-    printf("Device ID: 0x%04X (Expected: 0x3055)\n", device_id);
-    
-    if (manufacturer_id != 0x5449 || device_id != 0x3055) {
-        printf("ERROR: LDC1612 not detected!\n");
-        return;
-    }
-    
-    // 3. 复位传感器
-    ldc1612_reset_sensor();
-    delay_ms(100);
-    
-    // 4. 配置单通道模式
-    ldc1612_single_ch0_config();
-    
-    // 5. 显示当前IIC类型
-    printf("Current IIC Type: %s\n", ldc1612_get_iic_type());
-    
-    printf("LDC1612 initialization completed\n");
-}
-```
-
-## 📊 数据读取示例
-
-```c
-void ldc1612_read_example(void) {
-    uint32_t raw_data;
-    uint16_t status;
-    
-    // 检查数据是否准备好
-    if (ldc1612_is_data_ready(CHANNEL_0)) {
-        // 读取原始数据
-        raw_data = ldc1612_get_raw_channel_result(CHANNEL_0);
-        
-        // 检查错误状态
-        if (raw_data & 0xF0000000) {
-            printf("Sensor Error: 0x%08X\n", raw_data);
-            return;
-        }
-        
-        // 获取有效数据 (28位)
-        uint32_t sensor_data = raw_data & 0x0FFFFFFF;
-        printf("Channel 0 Data: %u\n", sensor_data);
-        
-        // 转换为频率值 (可选)
-        float frequency = (float)sensor_data * COIL_FREQ_HZ / 0x10000000;
-        printf("Frequency: %.2f Hz\n", frequency);
-    }
-    
-    // 读取状态寄存器
-    status = ldc1612_get_sensor_status();
-    printf("Status: 0x%04X\n", status);
-}
-```
-
-## ⚠️ 常见错误代码
-
-| 错误代码 | 说明 |
-|---------|------|
-| 0xF0000000 | ERR_NC - 未检测到线圈 |
-| 0x80000000 | ERR_UR - 欠量程错误 |
-| 0x40000000 | ERR_OR - 超量程错误 |
-| 0x20000000 | ERR_WD - 看门狗超时 |
-| 0x10000000 | ERR_AE - 振幅错误 |
-
-## 🔍 寄存器配置说明
-
-### 当前配置值解析
-
-```c
-#define LDC1612_CONVERSION_TIME_CH0    0x0546  // 转换时间
-#define LDC1612_DRIVE_CURRENT          0x9000  // 驱动电流
-#define LDC1612_MUX_CONFIG             0x020C  // 多路复用配置
-#define LDC1612_SENSOR_CONFIG_CH0      0x1601  // 传感器配置
-#define LC_STABILIZE_TIME_CH0          0x001E  // LC稳定时间
-```
-
- **转换时间**: 0x0546 = 1350个参考时钟周期
- **驱动电流**: 0x9000 = 高驱动电流设置
- **MUX配置**: 0x020C = 无自动扫描，3.3MHz滤波带宽
- **传感器配置**: 0x1601 = 启用传感器，连续转换模式
-
-## 🛠️ 调试技巧
-
-### 1. 检查IIC通信
-
-```c
-void debug_iic_communication(void) {
-    printf("=== IIC Communication Test ===\n");
-    printf("IIC Type: %s\n", ldc1612_get_iic_type());
-    
-    uint16_t manufacturer_id = ldc1612_get_manufacturer_id();
-    uint16_t device_id = ldc1612_get_deveice_id();
-    
-    printf("Manufacturer ID: 0x%04X\n", manufacturer_id);
-    printf("Device ID: 0x%04X\n", device_id);
-    
-    if (manufacturer_id == 0xFFFF || device_id == 0xFFFF) {
-        printf("ERROR: IIC communication failed!\n");
-    } else if (manufacturer_id == 0x5449 && device_id == 0x3055) {
-        printf("SUCCESS: LDC1612 detected and communicating\n");
-    } else {
-        printf("WARNING: Unexpected device detected\n");
-    }
-}
-```
-
-### 2. 自动检测驱动电流
-
-```c
-void auto_detect_drive_current(void) {
-    printf("=== Auto Drive Current Detection ===\n");
-    ldc1612_drvie_current_detect(CHANNEL_0);
-}
-```
-
-## 📈 性能优化建议
-
-1. **硬件IIC vs 软件IIC**:
-   - 硬件IIC: 更快速，CPU占用率低
-   - 软件IIC: 更灵活，便于调试
-
-2. **频率设置优化**:
-   - 根据实际线圈参数调整 `COIL_L_UH` 和 `COIL_C_PF`
-   - 确保传感器频率在1-10MHz范围内
-
-3. **电源管理**:
-   - 不使用时可调用 `ldc1612_set_sensor_config(LDC1612_SLEEP_MODE)`
-
-## 📚 参考资料
-
- TI LDC1612 数据手册
- GD32E230 参考手册
- 本项目IIC驱动实现: `i2c.c` 和 `soft_i2c.c`
--- a/Src/board_config.c
+++ b/Src/board_config.c
@@ -0,0 +1,52 @@
+#include "gd32e23x.h"
+#include "board_config.h"
+#include "systick.h"
+
+/******************************************************************************/
+
+#define FLASH_SIZE_ADDR      (*(const uint8_t *)0x1FFFF7E0) // Flash base address
+
+/******************************************************************************/
+
+/* 前向声明中断处理函数 */
+void usart0_irq_handler(void);
+void usart1_irq_handler(void);
+
+usart_config_t g_usart_config = {
+    .rcu_usart = RCU_USART1,
+    .usart_periph = USART1,
+    .irq_type = USART1_IRQn,
+    .irq_handler = usart1_irq_handler  // 初始化函数指针
+};
+
+uint8_t g_mcu_flash_size = 0;
+
+void mcu_detect_and_config(void) {
+    g_mcu_flash_size = FLASH_SIZE_ADDR;
+
+    switch (g_mcu_flash_size) {
+        case GD32E23XF4:
+            g_usart_config.rcu_usart = RCU_USART0;
+            g_usart_config.usart_periph = USART0;
+            g_usart_config.irq_type = USART0_IRQn;
+            g_usart_config.irq_handler = usart0_irq_handler;  // 指向USART0处理函数
+            break;
+        case GD32E23XF6:
+            g_usart_config.rcu_usart = RCU_USART1;
+            g_usart_config.usart_periph = USART1;
+            g_usart_config.irq_type = USART1_IRQn;
+            g_usart_config.irq_handler = usart1_irq_handler;  // 指向USART1处理函数
+            break;
+        default: // Default to GD32E23XF8
+            g_usart_config.rcu_usart = RCU_USART1;
+            g_usart_config.usart_periph = USART1;
+            g_usart_config.irq_type = USART1_IRQn;
+            g_usart_config.irq_handler = usart1_irq_handler;  // 指向USART1处理函数
+            break;
+    }
+
+}
+
+uint8_t get_flash_size(void) {
+    return g_mcu_flash_size;
+}
--- a/Src/command.c
+++ b/Src/command.c
@@ -18,6 +18,7 @@
 #include "board_config.h"
 #include "gd32e23x_usart.h"
 #include "ldc1612.h"
+#include "tmp112.h"

 /* ============================================================================
 * 协议格式说明
@@ -78,7 +79,8 @@
 * ============================================================================ */

 /** @brief 传感器周期上报使能标志 */
-volatile bool g_sensor_report_enabled = false;
+volatile bool g_eddy_current_sensor_report_enabled = false;
+volatile bool g_temperature_sensor_report_enabled = false;

 /** @name 预设响应数据
 * @{ */
@@ -91,25 +93,47 @@ static const uint8_t s_report_status_err[] = { 'e','r','r' }; /**< 错误响应
 * ============================================================================ */

 /**
- * @brief 查询是否启用周期性传感器上报。
+ * @brief 查询电涡流传感器是否启用周期性传感器上报。
 * @return true 表示启用；false 表示禁用。
 * @ingroup Command
 */
-bool get_sensor_report_enabled(void)
+bool get_eddy_sensor_report_enabled(void)
 {
-    return g_sensor_report_enabled;
+    return g_eddy_current_sensor_report_enabled;
 }

 /**
- * @brief 设置是否启用周期性传感器上报标志。
+ * @brief 设置电涡流传感器是否启用周期性传感器上报标志。
 * @details 本模块内部保存的布尔状态，供其他逻辑决定是否进行周期性数据上报；
 *          推荐通过本函数修改而非直接访问全局/静态变量，以便后续扩展（如加锁/回调）。
 * @param status true 启用周期上报；false 禁用。
 * @ingroup Command
 */
-void set_sensor_report_status(bool status)
+void set_eddy_sensor_report_status(bool status)
 {
-    g_sensor_report_enabled = status;
+    g_eddy_current_sensor_report_enabled = status;
+}
+
+/**
+ * @brief 查询温度传感器是否启用周期性传感器上报。
+ * @return true 表示启用；false 表示禁用。
+ * @ingroup Command
+ */
+bool get_temp_sensor_report_enabled(void)
+{
+    return g_temperature_sensor_report_enabled;
+}
+
+/**
+ * @brief 设置温度传感器是否启用周期性传感器上报标志。
+ * @details 本模块内部保存的布尔状态，供其他逻辑决定是否进行周期性数据上报；
+ *          推荐通过本函数修改而非直接访问全局/静态变量，以便后续扩展（如加锁/回调）。
+ * @param status true 启用周期上报；false 禁用。
+ * @ingroup Command
+ */
+void set_temp_sensor_report_status(bool status)
+{
+    g_temperature_sensor_report_enabled = status;
 }

 /**
@@ -277,422 +301,21 @@ void handle_command(const uint8_t *frame, uint8_t len) {
        // 仅基础命令，如 M1, M2, M3
        switch (base_cmd) {
            case 1u: // M1: enable sensor report
-                set_sensor_report_status(true);
-                return;
-            case 2u: // M2: disable sensor report
-                set_sensor_report_status(false);
+                set_eddy_sensor_report_status(true);
                return;

-            // 示例：M3、M10、M201、M100 等（按需添加）
-            // case 3u: // M3命令 - 高电流驱动测试
-            //     /**
-            //      * M3命令：使用更高驱动电流测试线圈响应
-            //      * 响应格式：6字节状态信息
-            //      * 
-            //      * 响应数据解析：
-            //      * [0-1]: 传感器状态寄存器（大端序）
-            //      *        bit[15-8]: 预留
-            //      *        bit[7]: DRDY_1 - 通道1数据就绪
-            //      *        bit[6]: DRDY_0 - 通道0数据就绪  
-            //      *        bit[5]: UNREAD_CONV - 未读转换结果
-            //      *        bit[4]: ERR_ZC - 零计数错误
-            //      *        bit[3]: ERR_AE - 幅度错误（重点关注）
-            //      *        bit[2]: ERR_WD - 看门狗超时
-            //      *        bit[1]: ERR_OR - 过量程错误
-            //      *        bit[0]: ERR_UR - 欠量程错误
-            //      * [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
-            //      * [3]: 0xA0 - 高电流测试标记
-            //      * [4]: 幅度错误专用标志 (0xAE=有幅度错误, 0x00=无)
-            //      * [5]: 0x33 - M3命令标记
-            //      * 
-            //      * 分析要点：
-            //      * - 如果[0-1]从0x0008变为其他值，说明高电流有效果
-            //      * - 如果[2]变为0x01，说明数据开始就绪
-            //      * - 如果[4]变为0x00，说明幅度错误消失
-            //      */
-            //     // 重置传感器
-            //     ldc1612_reset_sensor();
-            //     delay_ms(50);
+            case 2u: // M2: disable sensor report
+                set_eddy_sensor_report_status(false);
+                return;
+
+            case 3u:
+                set_temp_sensor_report_status(true);
+                return;
                
-            //     // 使用更高的驱动电流重新配置
-            //     // ldc1612_write_register(SET_DRIVER_CURRENT_REG, 0xA000);
-            //     delay_ms(10);
-                
-            //     // 重新配置其他参数
-            //     ldc1612_config_single_channel(CHANNEL_0);
-            //     delay_ms(200);  // 更长稳定时间
-                
-            //     // 检查结果
-            //     uint16_t status_m3 = ldc1612_get_sensor_status();
-            //     bool ready_m3 = ldc1612_is_data_ready(CHANNEL_0);
-                
-            //     uint8_t m3_info[6];
-            //     m3_info[0] = (uint8_t)(status_m3 >> 8);
-            //     m3_info[1] = (uint8_t)(status_m3 & 0xFF);
-            //     m3_info[2] = ready_m3 ? 0x01 : 0x00;
-            //     m3_info[3] = 0xA0;  // 高电流标记
-            //     m3_info[4] = (status_m3 & 0x0008) ? 0xAE : 0x00; // 幅度错误标志
-            //     m3_info[5] = 0x33;  // M3命令标记
-                
-            //     send_response(RESP_TYPE_OK, m3_info, sizeof(m3_info));
-            //     return;
-            // case 4u: // M4命令 - 寄存器诊断
-            //     /**
-            //      * M4命令：读取关键寄存器进行配置诊断
-            //      * 响应格式：8字节寄存器信息
-            //      * 
-            //      * 响应数据解析：
-            //      * [0-1]: 状态寄存器 (0x18) - 当前传感器状态
-            //      * [2-3]: 传感器配置寄存器 (0x1A) - 传感器工作模式
-            //      *        期望值: 0x1601 (活动模式，单通道)
-            //      * [4-5]: 驱动电流寄存器 (0x1E) - 当前驱动电流设置  
-            //      *        常见值: 0x9000(默认), 0xA000(高), 0xF800(最高)
-            //      * [6]: I2C读取状态 (0x4F='O'=成功, 0xEE=失败)
-            //      * [7]: 0x44 - M4命令标记
-            //      * 
-            //      * 分析要点：
-            //      * - [2-3]应该是0x1601，如果不是说明配置异常
-            //      * - [4-5]显示实际的驱动电流设置
-            //      * - [6]必须是0x4F，否则I2C通信有问题
-            //      */
-            //     // 简化版本，只读取最关键的寄存器，避免I2C超时
-            //     uint16_t status_reg = ldc1612_get_sensor_status();           // 0x18
-                
-            //     // 逐一安全读取关键寄存器
-            //     uint8_t data_buf[2] = {0};
-            //     uint16_t sensor_config = 0;
-            //     uint16_t drive_current = 0;
-                
-            //     // 尝试读取传感器配置寄存器
-            //     bool result1_ok = (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, data_buf) == I2C_RESULT_SUCCESS);
-            //     if (result1_ok) {
-            //         sensor_config = (data_buf[0] << 8) | data_buf[1];
-            //     }
-                
-            //     // 尝试读取驱动电流寄存器
-            //     bool result2_ok = (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, data_buf) == I2C_RESULT_SUCCESS);
-            //     if (result2_ok) {
-            //         drive_current = (data_buf[0] << 8) | data_buf[1];
-            //     }
-                
-            //     // 构造8字节简化诊断信息
-            //     uint8_t diag_info[8];
-            //     diag_info[0] = (uint8_t)(status_reg >> 8);      // 状态寄存器高位
-            //     diag_info[1] = (uint8_t)(status_reg & 0xFF);    // 状态寄存器低位
-            //     diag_info[2] = (uint8_t)(sensor_config >> 8);   // 传感器配置寄存器高位
-            //     diag_info[3] = (uint8_t)(sensor_config & 0xFF); // 传感器配置寄存器低位
-            //     diag_info[4] = (uint8_t)(drive_current >> 8);   // 驱动电流寄存器高位
-            //     diag_info[5] = (uint8_t)(drive_current & 0xFF); // 驱动电流寄存器低位
-            //     diag_info[6] = (result1_ok && result2_ok) ? 0x4F : 0xEE; // I2C状态
-            //     diag_info[7] = 0x44;  // M4命令标记
-                
-            //     send_response(RESP_TYPE_OK, diag_info, sizeof(diag_info));
-            //     return;
-            // case 5u: // M5命令 - 最高电流启动测试
-            //     // 命令: D5 03 02 4D 35 87
-            //     // 响应: B5 F0 08 [状态2字节][就绪标志][电流设置2字节][幅度错误标志][M5标记][最高电流标记] CRC
-            //     // 响应格式:
-            //     // [0-1]: 传感器状态寄存器（启动后状态）
-            //     // [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
-            //     // [3-4]: 实际驱动电流设置值（应该是0xF800）
-            //     // [5]: 幅度错误专用标志 (0xAE=仍有错误, 0x00=错误消失)
-            //     // [6]: 0x55 - M5命令标记
-            //     // [7]: 0xF8 - 最高电流标记
-            //     // 重置传感器
-            //     ldc1612_reset_sensor();
-            //     delay_ms(100);
-                
-            //     // 使用最高驱动电流并固定配置
-            //     // ldc1612_write_register(SET_DRIVER_CURRENT_REG, 0xF800);
-            //     delay_ms(10);
-                
-            //     // 手动配置其他必要寄存器，避免被覆盖
-            //     // 配置频率分频器为较低频率 (更容易起振)
-            //     uint8_t freq_data[2] = {0x10, 0x00}; // 较低分频
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_data);
-            //     delay_ms(10);
-                
-            //     // 设置较长的LC稳定时间
-            //     uint8_t lc_data[2] = {0x04, 0x00}; // 更长稳定时间
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_LC_STABILIZE_REG_START + CHANNEL_0, lc_data);
-            //     delay_ms(10);
-                
-            //     // 配置MUX为单通道模式
-            //     // ldc1612_configure_mux_register(0, CHANNEL_0, LDC1612_MUX_RR_SEQUENCE_1, LDC1612_MUX_FILTER_1MHz);
-            //     delay_ms(10);
-                
-            //     // 启动传感器
-            //     uint8_t sensor_cfg_data[2] = {0x16, 0x01}; // 活动模式，单通道
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sensor_cfg_data);
-            //     delay_ms(200); // 更长稳定时间
-                
-            //     // 读取结果
-            //     uint16_t status_m5 = ldc1612_get_sensor_status();
-            //     bool ready_m5 = ldc1612_is_data_ready(CHANNEL_0);
-                
-            //     // 再次确认驱动电流设置
-            //     uint8_t curr_data[2];
-            //     LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, curr_data);
-            //     uint16_t actual_current = (curr_data[0] << 8) | curr_data[1];
-                
-            //     uint8_t m5_info[8];
-            //     m5_info[0] = (uint8_t)(status_m5 >> 8);
-            //     m5_info[1] = (uint8_t)(status_m5 & 0xFF);
-            //     m5_info[2] = ready_m5 ? 0x01 : 0x00;
-            //     m5_info[3] = (uint8_t)(actual_current >> 8);    // 实际电流设置高位
-            //     m5_info[4] = (uint8_t)(actual_current & 0xFF);  // 实际电流设置低位
-            //     m5_info[5] = (status_m5 & 0x0008) ? 0xAE : 0x00; // 幅度错误标志
-            //     m5_info[6] = 0x55;  // M5命令标记
-            //     m5_info[7] = 0xF8;  // 最高电流标记
-                
-            //     send_response(RESP_TYPE_OK, m5_info, sizeof(m5_info));
-            //     return;
-            // case 6u: // M6命令 - 芯片功能验证
-            //     // 命令: D5 03 02 4D 36 88
-            //     // 响应: B5 F0 0C [写入值2字节][读取值2字节][制造商ID2字节][设备ID2字节][状态2字节][ID读取状态][M6标记] CRC
-            //     // 响应格式:
-            //     // [0-1]: 写入测试值 (0x9000)
-            //     // [2-3]: 读取回的值
-            //     // [4-5]: 制造商ID (应该是0x5449="TI")
-            //     // [6-7]: 设备ID (应该是0x3055)
-            //     // [8-9]: 当前状态寄存器
-            //     // [10]: ID读取状态 (0x4F=成功, 0xEE=失败)
-            //     // [11]: 0x66 - M6命令标记
-            //     // 测试1: 写入和读取特定值到驱动电流寄存器
-            //     uint8_t test_current_data[2] = {0x90, 0x00}; // 写入0x9000
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, test_current_data);
-            //     delay_ms(10);
-                
-            //     // 读取验证
-            //     uint8_t read_current_data[2];
-            //     LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, read_current_data);
-            //     uint16_t read_current = (read_current_data[0] << 8) | read_current_data[1];
-                
-            //     // 测试2: 读取制造商ID和设备ID
-            //     uint8_t manufacturer_data[2];
-            //     uint8_t device_data[2];
-            //     bool id_read_ok = true;
-                
-            //     if (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, 0x7E, manufacturer_data) != I2C_RESULT_SUCCESS) {
-            //         id_read_ok = false;
-            //     }
-            //     if (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, 0x7F, device_data) != I2C_RESULT_SUCCESS) {
-            //         id_read_ok = false;
-            //     }
-                
-            //     uint16_t manufacturer_id = id_read_ok ? ((manufacturer_data[0] << 8) | manufacturer_data[1]) : 0x0000;
-            //     uint16_t device_id = id_read_ok ? ((device_data[0] << 8) | device_data[1]) : 0x0000;
-                
-            //     // 测试3: 检查当前状态
-            //     uint16_t current_status = ldc1612_get_sensor_status();
-                
-            //     // 构造12字节测试结果
-            //     uint8_t test_info[12];
-            //     test_info[0] = 0x90;  // 写入的值高位
-            //     test_info[1] = 0x00;  // 写入的值低位
-            //     test_info[2] = (uint8_t)(read_current >> 8);    // 读取的值高位
-            //     test_info[3] = (uint8_t)(read_current & 0xFF);  // 读取的值低位
-            //     test_info[4] = (uint8_t)(manufacturer_id >> 8);
-            //     test_info[5] = (uint8_t)(manufacturer_id & 0xFF);
-            //     test_info[6] = (uint8_t)(device_id >> 8);
-            //     test_info[7] = (uint8_t)(device_id & 0xFF);
-            //     test_info[8] = (uint8_t)(current_status >> 8);
-            //     test_info[9] = (uint8_t)(current_status & 0xFF);
-            //     test_info[10] = id_read_ok ? 0x4F : 0xEE;  // ID读取状态
-            //     test_info[11] = 0x66;  // M6命令标记
-                
-            //     send_response(RESP_TYPE_OK, test_info, sizeof(test_info));
-            //     return;
-            // case 7u: // M7命令 - 保守参数测试
-            //     // 命令: D5 03 02 4D 37 89
-            //     // 响应: B5 F0 0A [状态2字节][就绪标志][频率设置2字节][幅度错误标志][欠量程错误标志][过量程错误标志][M7标记][低频标记] CRC
-            //     // 响应格式:
-            //     // [0-1]: 状态寄存器
-            //     // [2]: 数据就绪标志
-            //     // [3-4]: 实际频率分频器设置 (0x2000=较低频率)
-            //     // [5]: 幅度错误标志 (0xAE=有错误, 0x00=无)
-            //     // [6]: 欠量程错误标志 (0x01=有, 0x00=无)
-            //     // [7]: 过量程错误标志 (0x02=有, 0x00=无)
-            //     // [8]: 0x77 - M7命令标记
-            //     // [9]: 0x20 - 低频标记
-            //     // 重置传感器
-            //     ldc1612_reset_sensor();
-            //     delay_ms(100);
-                
-            //     // 使用保守的配置尝试启动线圈
-            //     // 1. 设置最高驱动电流
-            //     uint8_t drive_data[2] = {0xF8, 0x00};  // 最高电流
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, drive_data);
-            //     delay_ms(10);
-                
-            //     // 2. 设置较低的频率分频器(适合更大电感值)
-            //     uint8_t freq_low_data[2] = {0x20, 0x00};  // 更低频率
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_low_data);
-            //     delay_ms(10);
-                
-            //     // 3. 设置更长的LC稳定时间
-            //     uint8_t lc_stable_data[2] = {0x08, 0x00};  // 更长稳定时间
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_LC_STABILIZE_REG_START + CHANNEL_0, lc_stable_data);
-            //     delay_ms(10);
-                
-            //     // 4. 设置更长的转换时间
-            //     uint8_t conv_time_data[2] = {0x04, 0x00};  // 更长转换时间
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_CONVERSION_TIME_REG_START + CHANNEL_0, conv_time_data);
-            //     delay_ms(10);
-                
-            //     // 5. 设置转换偏移
-            //     uint8_t conv_offset_data[2] = {0x00, 0x00};
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_CONVERSION_OFFSET_REG_START + CHANNEL_0, conv_offset_data);
-            //     delay_ms(10);
-                
-            //     // 6. 配置错误寄存器 - 降低错误敏感度
-            //     uint8_t error_config_data[2] = {0x00, 0x00};  // 允许所有错误
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, ERROR_CONFIG_REG, error_config_data);
-            //     delay_ms(10);
-                
-            //     // 7. 配置MUX寄存器
-            //     // ldc1612_configure_mux_register(0, CHANNEL_0, LDC1612_MUX_RR_SEQUENCE_1, LDC1612_MUX_FILTER_1MHz);
-            //     delay_ms(10);
-                
-            //     // 8. 启动传感器
-            //     uint8_t sensor_start_data[2] = {0x16, 0x01};  // 活动模式
-            //     LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sensor_start_data);
-            //     delay_ms(500);  // 给予充分时间稳定
-                
-            //     // 检查结果
-            //     uint16_t status_m7 = ldc1612_get_sensor_status();
-            //     bool ready_m7 = ldc1612_is_data_ready(CHANNEL_0);
-                
-            //     // 读取实际配置的频率分频器确认
-            //     uint8_t freq_readback[2];
-            //     LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_readback);
-            //     uint16_t freq_actual = (freq_readback[0] << 8) | freq_readback[1];
-                
-            //     uint8_t m7_info[10];
-            //     m7_info[0] = (uint8_t)(status_m7 >> 8);
-            //     m7_info[1] = (uint8_t)(status_m7 & 0xFF);
-            //     m7_info[2] = ready_m7 ? 0x01 : 0x00;
-            //     m7_info[3] = (uint8_t)(freq_actual >> 8);    // 实际频率分频器
-            //     m7_info[4] = (uint8_t)(freq_actual & 0xFF);
-            //     m7_info[5] = (status_m7 & 0x0008) ? 0xAE : 0x00; // 幅度错误
-            //     m7_info[6] = (status_m7 & 0x0001) ? 0x01 : 0x00; // 欠量程错误
-            //     m7_info[7] = (status_m7 & 0x0002) ? 0x02 : 0x00; // 过量程错误
-            //     m7_info[8] = 0x77;  // M7命令标记
-            //     m7_info[9] = 0x20;  // 低频标记
-                
-            //     send_response(RESP_TYPE_OK, m7_info, sizeof(m7_info));
-            //     return;
-            // case 8u: // M8命令 - 极端参数测试
-            //     // 命令: D5 03 02 4D 38 8A
-            //     // 响应: B5 F0 06 [状态2字节][就绪标志][幅度错误标志][M8标记][极端测试标记] CRC
-            //     // 响应格式:
-            //     // [0-1]: 传感器状态寄存器
-            //     // [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
-            //     // [3]: 幅度错误标志 (0xAE=仍有错误, 0x00=错误消失)
-            //     // [4]: 0x88 - M8命令标记
-            //     // [5]: 0xEE - 极端测试标记
-            //     {
-            //         // 重置传感器
-            //         ldc1612_reset_sensor();
-            //         delay_ms(100);
-                    
-            //         // 极端配置1: 极低频率
-            //         uint8_t extreme_freq[2] = {0x40, 0x00};
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, extreme_freq);
-            //         delay_ms(10);
-                    
-            //         // 极端配置2: 最大驱动电流
-            //         uint8_t max_drive[2] = {0xFF, 0x00};
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, max_drive);
-            //         delay_ms(10);
-                    
-            //         // 极端配置3: 禁用错误检测
-            //         uint8_t no_errors[2] = {0x00, 0x00};
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, ERROR_CONFIG_REG, no_errors);
-            //         delay_ms(10);
-                    
-            //         // 启动传感器
-            //         uint8_t start_data[2] = {0x16, 0x01};
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_data);
-            //         delay_ms(1000);  // 等待1秒
-                    
-            //         // 读取状态
-            //         uint16_t status_8 = ldc1612_get_sensor_status();
-            //         bool ready_8 = ldc1612_is_data_ready(CHANNEL_0);
-                    
-            //         uint8_t m8_result[6];
-            //         m8_result[0] = (uint8_t)(status_8 >> 8);
-            //         m8_result[1] = (uint8_t)(status_8 & 0xFF);
-            //         m8_result[2] = ready_8 ? 0x01 : 0x00;
-            //         m8_result[3] = (status_8 & 0x0008) ? 0xAE : 0x00; // 幅度错误
-            //         m8_result[4] = 0x88;  // M8标记
-            //         m8_result[5] = 0xEE;  // 极端测试标记
-                    
-            //         send_response(RESP_TYPE_OK, m8_result, sizeof(m8_result));
-            //         return;
-            //     }
-            // case 9u: // M9命令 - 多频率特性测试
-            //     // 命令: D5 03 02 4D 39 8B
-            //     // 响应: B5 F0 08 [高频状态2字节][高频就绪标志][低频状态2字节][低频就绪标志][M9标记][多频测试标记] CRC
-            //     // 响应格式:
-            //     // [0-1]: 高频测试状态
-            //     // [2]: 高频就绪标志 (0x01=就绪, 0x00=未就绪)
-            //     // [3-4]: 低频测试状态
-            //     // [5]: 低频就绪标志 (0x01=就绪, 0x00=未就绪)
-            //     // [6]: 0x99 - M9命令标记
-            //     // [7]: 0xAA - 多频测试标记
-            //     {
-            //         // 测试1: 高频配置
-            //         ldc1612_reset_sensor();
-            //         delay_ms(50);
-                    
-            //         uint8_t high_freq[2] = {0x04, 0x00};  // 高频
-            //         uint8_t low_drive[2] = {0x80, 0x00};  // 低电流
-                    
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, high_freq);
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, low_drive);
-            //         delay_ms(10);
-                    
-            //         // 启动高频测试
-            //         uint8_t start_hf[2] = {0x16, 0x01};
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_hf);
-            //         delay_ms(200);
-                    
-            //         uint16_t hf_status = ldc1612_get_sensor_status();
-            //         bool hf_ready = ldc1612_is_data_ready(CHANNEL_0);
-                    
-            //         // 测试2: 低频配置
-            //         uint8_t sleep_mode[2] = {0x20, 0x01};
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sleep_mode);
-            //         delay_ms(50);
-                    
-            //         uint8_t low_freq[2] = {0x20, 0x00};   // 低频
-            //         uint8_t high_drive[2] = {0xC0, 0x00}; // 高电流
-                    
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, low_freq);
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, high_drive);
-            //         delay_ms(10);
-                    
-            //         // 启动低频测试
-            //         LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_hf);
-            //         delay_ms(200);
-                    
-            //         uint16_t lf_status = ldc1612_get_sensor_status();
-            //         bool lf_ready = ldc1612_is_data_ready(CHANNEL_0);
-                    
-            //         uint8_t m9_result[8];
-            //         m9_result[0] = (uint8_t)(hf_status >> 8);     // 高频状态
-            //         m9_result[1] = (uint8_t)(hf_status & 0xFF);
-            //         m9_result[2] = hf_ready ? 0x01 : 0x00;        // 高频就绪
-            //         m9_result[3] = (uint8_t)(lf_status >> 8);     // 低频状态
-            //         m9_result[4] = (uint8_t)(lf_status & 0xFF);
-            //         m9_result[5] = lf_ready ? 0x01 : 0x00;        // 低频就绪
-            //         m9_result[6] = 0x99;  // M9标记
-            //         m9_result[7] = 0xAA;  // 多频测试标记
-                    
-            //         send_response(RESP_TYPE_OK, m9_result, sizeof(m9_result));
-            //         return;
-            //     }
+            case 4u:
+                set_temp_sensor_report_status(false);
+                return;
+
            // case 201u: // M201命令
            //     send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
            //     return;
@@ -833,7 +456,7 @@ void command_process(void) {
 }

 void eddy_current_report(void) {
-    // if (!g_sensor_report_enabled) return;
+    // if (!g_eddy_current_sensor_report_enabled) return;
    uint32_t raw_result = ldc1612_get_raw_channel_result(CHANNEL_0);

    uint8_t sensor_data[4];
@@ -843,4 +466,22 @@ void eddy_current_report(void) {
    sensor_data[3] = (uint8_t)(raw_result & 0xFF);
    
    send_response(RESP_TYPE_OK, sensor_data, sizeof(sensor_data));
-}
+}
+
+void temperature_raw_value_report(void) {
+    // if (!g_temperature_sensor_report_enabled) return;
+    uint8_t raw_result[4];
+    uint8_t value[2] = {0};
+    uint32_t raw_value = 0;
+
+    // i2c_read_16bits(TMP112A_ADDR, TMP112A_TEMP_REG, value);
+    tmp112a_get_raw_temperature_value(value);
+    raw_value = (uint32_t)((uint16_t) (value[0] << 4) | (value[1]>>4)) * 625;
+    raw_result[0] = (uint8_t)(raw_value >> 24);
+    raw_result[1] = (uint8_t)(raw_value >> 16);
+    raw_result[2] = (uint8_t)(raw_value >> 8);
+    raw_result[3] = (uint8_t)(raw_value & 0xFF);
+
+    send_response(RESP_TYPE_OK, raw_result, sizeof(raw_result));
+}
+    
--- a/Src/gd32e23x_it.c
+++ b/Src/gd32e23x_it.c
@@ -37,6 +37,7 @@ OF SUCH DAMAGE.
 #include "uart.h"
 #include "uart_ring_buffer.h"
 #include "led.h"
+#include "board_config.h"

 /*!
    \brief      this function handles NMI exception
@@ -102,8 +103,15 @@ void SysTick_Handler(void) {
 }

 void USART0_IRQHandler(void) {
-    if (RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) {
-        uint8_t data = usart_data_receive(USART0);
-        (void)uart_ring_buffer_put(data); // 缓冲满时丢弃，返回值可用于统计
+    // 检查当前配置是否使用USART0，并且函数指针不为空
+    if(g_usart_config.usart_periph == USART0 && g_usart_config.irq_handler != 0) {
+        g_usart_config.irq_handler();  // 通过函数指针调用对应的处理函数
    }
-}
+}
+
+void USART1_IRQHandler(void) {
+    // 检查当前配置是否使用USART1，并且函数指针不为空
+    if(g_usart_config.usart_periph == USART1 && g_usart_config.irq_handler != 0) {
+        g_usart_config.irq_handler();  // 通过函数指针调用对应的处理函数
+    }
+}
--- a/Src/ldc1612.c
+++ b/Src/ldc1612.c
@@ -137,10 +137,10 @@ ldc1612_status_t ldc1612_config_single_channel(uint8_t channel) {
    delay_ms(5);

    /* Step 3: 配置LC稳定时间 - 影响测量精度 */
-    ldc1612_write_register(SET_LC_STABILIZE_REG_START + channel, LC_STABILIZE_TIME_CH0);
+    ldc1612_write_register(SET_SETTLECOUNT_REG_START + channel, LDC1612_SETTLECOUNT_CH0);

    /* Step 4: 配置转换时间 - 影响测量速度和精度 */
-    ldc1612_write_register(SET_CONVERSION_TIME_REG_START + channel, LDC1612_CONVERSION_TIME_CH0);
+    ldc1612_write_register(SET_CONVERSION_TIME_REG_START + channel, LDC1612_RCOUNT_TIME_CH0);

    /* Step 5: 配置转换偏移 */
    ldc1612_write_register(SET_CONVERSION_OFFSET_REG_START + channel, SET_CONVERSION_OFFSET_CH0);
@@ -150,7 +150,7 @@ ldc1612_status_t ldc1612_config_single_channel(uint8_t channel) {

    /* Step 7: 配置多路复用器 - 设置通道选择和滤波 */
    // ldc1612_configure_mux_register(LDC1612_MUX_AUTOSCAN_DISABLE, LDC1612_MUX_RR_SEQUENCE_0, LDC1612_MUX_FILTER_ALL_LOW, LDC1612_MUX_FILTER_NONE);
-    ldc1612_write_register(MUL_CONFIG_REG, LDC1612_MUX_CONFIG);
+    ldc1612_write_register(MUX_CONFIG_REG, LDC1612_MUX_CONFIG);

    /* Step 8: 配置错误输出 */
    ldc1612_write_register(ERROR_CONFIG_REG, LDC1612_ERROR_CONFIG);
@@ -174,43 +174,53 @@ uint32_t ldc1612_get_raw_channel_result(uint8_t channel) {
    uint8_t value[2] = {0};

    /* Read MSW */
-    LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERTION_RESULT_REG_START + channel, value);
+    LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERTION_RESULT_REG_START + (channel * 2), value);
    raw_value |= (uint32_t)(((uint16_t)value[0] << 8) | value[1]) << 16;

    /* Read LSW */
-    LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERTION_RESULT_REG_START + channel + 1, value);
+    LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERTION_RESULT_REG_START + 1 + (channel * 2), value);
    raw_value |= (uint32_t)(((uint16_t)value[0] << 8) | value[1]);

+    
    uint32_t calibration_value = raw_value & 0x0FFFFFFF;
    if (calibration_value == 0x0FFFFFFF) {
        return 0xF0000000; /* No coil */
    }
-    uint8_t error_code = (uint8_t)(raw_value >> 24);
-    if (error_code & 0x80) return 0x80000000; /* Under range */
-    if (error_code & 0x40) return 0x40000000; /* Over range */
-    if (error_code & 0x20) return 0x20000000; /* Watchdog */
-    if (error_code & 0x10) return 0x10000000; /* Amplitude error */
+    if (LDC1612_ERROR_CONFIG & 0xF800) {
+        uint8_t error_code = (uint8_t)(raw_value >> 24);
+        if (error_code & 0x80) return 0x80000000; /* Under range */
+        if (error_code & 0x40) return 0x40000000; /* Over range */
+        if (error_code & 0x20) return 0x20000000; /* Watchdog */
+        if (error_code & 0x10) return 0x10000000; /* Amplitude error */
+    }
    
    return raw_value;
 }


-// void ldc1612_drvie_current_detect(uint8_t channel) {
-//     uint8_t data[2] = {0};
-//     uint16_t init_value = 0 , drive_current = 0;
+void ldc1612_drvie_current_detect(uint8_t channel) {
+    uint8_t data[2] = {0};
+    uint16_t init_value = 0 , drive_current = 0;

-//     ldc1612_set_sensor_config(LDC1612_SLEEP_MODE);
-//     ldc1612_configure_frequency(channel);
-//     LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, data);
-//     ldc1612_set_sensor_config(LDC1612_SLEEP_MODE);
-//     ldc1612_set_sensor_config(LDC1612_SENSOR_CONFIG_CH0); //0x1A --0x1601
-//     delay_ms(10);
-//     LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, data);
+    ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SLEEP_MODE);
+    delay_ms(10);
+    
+    uint16_t freq_divider = ldc1612_calculate_freq_divider(channel);
+    ldc1612_write_register(SET_FREQ_REG_START + channel, freq_divider);
+    delay_ms(5);

-//     init_value = (((data[0] << 8) | data[1]) >> 6) & 0x1F;
-//     drive_current = (init_value << 11) | 0x0000;
-//     printf("init value: 0x%x\tdrive current: 0x%x\n", init_value, drive_current);
-// }
+    LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, data);
+    // ldc1612_set_sensor_config(LDC1612_SLEEP_MODE);
+    ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SLEEP_MODE);
+    delay_ms(10);
+    ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SENSOR_CONFIG_CH0);
+    delay_ms(10);
+    LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, data);
+
+    init_value = (((data[0] << 8) | data[1]) >> 6) & 0x1F;
+    drive_current = (init_value << 11) | 0x0000;
+    printf("init value: 0x%x\tdrive current: 0x%x\n", init_value, drive_current);
+}

 /** @brief Get sensor status register
    @return Status register value
--- a/Src/main.c
+++ b/Src/main.c
@@ -41,6 +41,7 @@ OF SUCH DAMAGE.
 #include "i2c.h"
 #include "board_config.h"
 #include "ldc1612.h"
+#include "tmp112.h"

 /*!
    \brief      main function
@@ -50,12 +51,16 @@ OF SUCH DAMAGE.
 */
 int main(void)
 {
+    led_init();
+    mcu_detect_and_config();

    setbuf(stdout, NULL);
    systick_config();
    rs485_init();

-    led_init();
+    // led_init();
+
+    printf("Flash size: %d Kbytes\n", get_flash_size());

 #ifdef DEBUG_VERBOSE
    char hello_world[] = {"Hello World!\r\n"};
@@ -67,8 +72,6 @@ int main(void)
    }
    
    while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-
-    
 #endif

    i2c_config();
@@ -82,11 +85,31 @@ int main(void)
    ldc1612_init();
    ldc1612_config_single_channel(CHANNEL_0);

+    tmp112a_init();
+
+#ifdef EDDY_DRIVE_CURRENT_DETECTION
+    ldc1612_drvie_current_detect(CHANNEL_0);
+#endif
+
    while(1){
+#ifndef EDDY_DRIVE_CURRENT_DETECTION
        command_process();
        delay_ms(10);
-        if (g_sensor_report_enabled) {
+        if (g_eddy_current_sensor_report_enabled) 
        eddy_current_report();
-        }
+        if (g_temperature_sensor_report_enabled) 
+        temperature_raw_value_report();
+
+
+
+
+
+#else
+        ldc1612_drvie_current_detect(CHANNEL_0);
+        delay_ms(1000);
+#endif
+        
+        
+        
    }
 }
--- a/Src/sensor_example.c
+++ b/Src/sensor_example.c
@@ -1,224 +0,0 @@
-//
-// Sensor Usage Example
-// 传感器使用示例代码
-//
-
-#include "ldc1612.h"
-// #include "tmp112.h"
-#include "i2c.h"
-
-/*!
-    \brief      传感器初始化示例
-    \param[in]  none
-    \param[out] none
-    \retval     none
-*/
-void sensors_init_example(void) {
-    ldc1612_status_t ldc_status;
-    // tmp112a_status_t tmp_status;
-    
-    /* 初始化I2C总线 */
-    i2c_status_t i2c_status = i2c_config();
-    if (i2c_status != I2C_STATUS_SUCCESS) {
-        // 使用串口发送错误信息
-        const char* error_msg = "I2C init failed\r\n";
-        for (uint8_t i = 0; error_msg[i] != '\0'; i++) {
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-            usart_data_transmit(RS485_PHY, error_msg[i]);
-        }
-        while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-        return;
-    }
-    
-    /* 扫描I2C总线 */
-    // i2c_scan();
-    
-    /* 初始化LDC1612 */
-    ldc_status = ldc1612_init();
-    if (ldc_status == LDC1612_STATUS_SUCCESS) {
-        const char* msg = "LDC1612 init success\r\n";
-        for (uint8_t i = 0; msg[i] != '\0'; i++) {
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-            usart_data_transmit(RS485_PHY, msg[i]);
-        }
-        while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-        
-        /* 配置通道0 */
-        ldc_status = ldc1612_config_single_channel(LDC1612_CHANNEL_0);
-        if (ldc_status != LDC1612_STATUS_SUCCESS) {
-            const char* error = "LDC1612 config failed\r\n";
-            for (uint8_t i = 0; error[i] != '\0'; i++) {
-                while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-                usart_data_transmit(RS485_PHY, error[i]);
-            }
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-        }
-    } else {
-        const char* error = "LDC1612 init failed: ";
-        for (uint8_t i = 0; error[i] != '\0'; i++) {
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-            usart_data_transmit(RS485_PHY, error[i]);
-        }
-        const char* status_str = ldc1612_get_status_string(ldc_status);
-        for (uint8_t i = 0; status_str[i] != '\0'; i++) {
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-            usart_data_transmit(RS485_PHY, status_str[i]);
-        }
-        const char* newline = "\r\n";
-        for (uint8_t i = 0; newline[i] != '\0'; i++) {
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-            usart_data_transmit(RS485_PHY, newline[i]);
-        }
-        while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-    }
-    
-    /* 初始化TMP112A */
-    // tmp_status = tmp112a_init();
-    // if (tmp_status == TMP112A_STATUS_SUCCESS) {
-    //     const char* msg = "TMP112A init success\r\n";
-    //     for (uint8_t i = 0; msg[i] != '\0'; i++) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, msg[i]);
-    //     }
-    //     while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-        
-    //     /* 设置温度阈值 */
-    //     tmp_status = tmp112a_set_thresholds(-10.0f, 50.0f);
-    //     if (tmp_status != TMP112A_STATUS_SUCCESS) {
-    //         const char* error = "TMP112A threshold config failed\r\n";
-    //         for (uint8_t i = 0; error[i] != '\0'; i++) {
-    //             while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //             usart_data_transmit(RS485_PHY, error[i]);
-    //         }
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-    //     }
-    // } else {
-    //     const char* error = "TMP112A init failed: ";
-    //     for (uint8_t i = 0; error[i] != '\0'; i++) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, error[i]);
-    //     }
-    //     const char* status_str = tmp112a_get_status_string(tmp_status);
-    //     for (uint8_t i = 0; status_str[i] != '\0'; i++) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, status_str[i]);
-    //     }
-    //     const char* newline = "\r\n";
-    //     for (uint8_t i = 0; newline[i] != '\0'; i++) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, newline[i]);
-    //     }
-    //     while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-    // }
-}
-
-/*!
-    \brief      传感器读取示例
-    \param[in]  none
-    \param[out] none
-    \retval     none
-*/
-void sensors_read_example(void) {
-    ldc1612_result_t ldc_result;
-    // tmp112a_result_t tmp_result;
-    ldc1612_status_t ldc_status;
-    // tmp112a_status_t tmp_status;
-    
-    /* 读取LDC1612数据 */
-    ldc_status = ldc1612_read_channel(LDC1612_CHANNEL_0, &ldc_result);
-    if (ldc_status == LDC1612_STATUS_SUCCESS) {
-        if (!ldc_result.error_flag) {
-            const char* msg = "LDC1612 Data: 0x";
-            for (uint8_t i = 0; msg[i] != '\0'; i++) {
-                while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-                usart_data_transmit(RS485_PHY, msg[i]);
-            }
-            
-            /* 发送32位十六进制数据 */
-            uint8_t hex_chars[] = "0123456789ABCDEF";
-            for (int8_t i = 7; i >= 0; i--) {
-                uint8_t nibble = (ldc_result.frequency >> (i * 4)) & 0x0F;
-                while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-                usart_data_transmit(RS485_PHY, hex_chars[nibble]);
-            }
-            
-            const char* newline = "\r\n";
-            for (uint8_t i = 0; newline[i] != '\0'; i++) {
-                while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-                usart_data_transmit(RS485_PHY, newline[i]);
-            }
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-        } else {
-            const char* error = "LDC1612 Error Code: 0x";
-            for (uint8_t i = 0; error[i] != '\0'; i++) {
-                while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-                usart_data_transmit(RS485_PHY, error[i]);
-            }
-            
-            uint8_t hex_chars[] = "0123456789ABCDEF";
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-            usart_data_transmit(RS485_PHY, hex_chars[(ldc_result.error_code >> 4) & 0x0F]);
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-            usart_data_transmit(RS485_PHY, hex_chars[ldc_result.error_code & 0x0F]);
-            
-            const char* newline = "\r\n";
-            for (uint8_t i = 0; newline[i] != '\0'; i++) {
-                while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-                usart_data_transmit(RS485_PHY, newline[i]);
-            }
-            while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-        }
-    }
-    
-    /* 读取TMP112A数据 */
-    // tmp_status = tmp112a_read_temperature(&tmp_result);
-    // if (tmp_status == TMP112A_STATUS_SUCCESS) {
-    //     const char* msg = "Temperature: ";
-    //     for (uint8_t i = 0; msg[i] != '\0'; i++) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, msg[i]);
-    //     }
-        
-    //     /* 简单的温度显示（整数部分） */
-    //     int16_t temp_int = (int16_t)tmp_result.temperature_c;
-    //     if (temp_int < 0) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, '-');
-    //         temp_int = -temp_int;
-    //     }
-        
-    //     if (temp_int >= 100) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, '0' + (temp_int / 100));
-    //         temp_int %= 100;
-    //     }
-    //     if (temp_int >= 10) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, '0' + (temp_int / 10));
-    //         temp_int %= 10;
-    //     }
-    //     while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //     usart_data_transmit(RS485_PHY, '0' + temp_int);
-        
-    //     const char* unit = " C";
-    //     for (uint8_t i = 0; unit[i] != '\0'; i++) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, unit[i]);
-    //     }
-        
-    //     if (tmp_result.alert_flag) {
-    //         const char* alert = " [ALERT]";
-    //         for (uint8_t i = 0; alert[i] != '\0'; i++) {
-    //             while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //             usart_data_transmit(RS485_PHY, alert[i]);
-    //         }
-    //     }
-        
-    //     const char* newline = "\r\n";
-    //     for (uint8_t i = 0; newline[i] != '\0'; i++) {
-    //         while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    //         usart_data_transmit(RS485_PHY, newline[i]);
-    //     }
-    //     while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-    // }
-}
--- a/Src/syscalls.c
+++ b/Src/syscalls.c
@@ -16,6 +16,7 @@
 #include <unistd.h>
 #include <sys/wait.h>
 #include "gd32e23x_usart.h"
+#include "board_config.h"

 #undef errno
 extern int errno;
@@ -164,7 +165,7 @@ int _execve(char *name, char **argv, char **env)
 // USART0 printf重定向实现
 int __io_putchar(int ch) {
    // 等待发送缓冲区空
-    while (usart_flag_get(USART0, USART_FLAG_TBE) == RESET) {}
-    usart_data_transmit(USART0, (uint8_t)ch);
+    while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
+    usart_data_transmit(RS485_PHY, (uint8_t)ch);
    return ch;
 }
--- a/Src/tmp112.c
+++ b/Src/tmp112.c
@@ -6,8 +6,8 @@
 #include "tmp112.h"

 /* Private function prototypes */
-static i2c_status_t tmp112a_write_register(uint8_t reg_addr, uint16_t value);
-static i2c_status_t tmp112a_read_register(uint8_t reg_addr, uint16_t *value);
+static i2c_result_t tmp112a_write_register(uint8_t reg_addr, uint16_t value);
+static i2c_result_t tmp112a_read_register(uint8_t reg_addr, uint16_t *value);
 static float tmp112a_raw_to_celsius(uint16_t raw_data);
 static uint16_t tmp112a_celsius_to_raw(float temperature);

@@ -18,11 +18,11 @@ static uint16_t tmp112a_celsius_to_raw(float temperature);
    \retval     tmp112a_status_t
 */
 tmp112a_status_t tmp112a_init(void) {
-    i2c_status_t i2c_status;
+    i2c_result_t i2c_status;
    
    /* 配置传感器为默认设置 */
    i2c_status = tmp112a_config(TMP112A_CONFIG_DEFAULT);
-    if (i2c_status != I2C_STATUS_SUCCESS) {
+    if (i2c_status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
@@ -39,8 +39,8 @@ tmp112a_status_t tmp112a_init(void) {
    \retval     tmp112a_status_t
 */
 tmp112a_status_t tmp112a_config(uint16_t config) {
-    i2c_status_t status = tmp112a_write_register(TMP112A_CONFIG_REG, config);
-    return (status == I2C_STATUS_SUCCESS) ? TMP112A_STATUS_SUCCESS : TMP112A_STATUS_ERROR;
+    i2c_result_t status = tmp112a_write_register(TMP112A_CONFIG_REG, config);
+    return (status == I2C_RESULT_SUCCESS) ? TMP112A_STATUS_SUCCESS : TMP112A_STATUS_ERROR;
 }

 /*!
@@ -51,7 +51,7 @@ tmp112a_status_t tmp112a_config(uint16_t config) {
 */
 tmp112a_status_t tmp112a_read_temperature(tmp112a_result_t *result) {
    uint16_t raw_data;
-    i2c_status_t status;
+    i2c_result_t status;
    
    if (result == NULL) {
        return TMP112A_STATUS_INVALID_PARAM;
@@ -59,7 +59,7 @@ tmp112a_status_t tmp112a_read_temperature(tmp112a_result_t *result) {
    
    /* 读取温度寄存器 */
    status = tmp112a_read_register(TMP112A_TEMP_REG, &raw_data);
-    if (status != I2C_STATUS_SUCCESS) {
+    if (status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
@@ -76,7 +76,7 @@ tmp112a_status_t tmp112a_read_temperature(tmp112a_result_t *result) {
    /* 检查报警标志 */
    uint16_t config_reg;
    status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
-    if (status == I2C_STATUS_SUCCESS) {
+    if (status == I2C_RESULT_SUCCESS) {
        result->alert_flag = (config_reg & TMP112A_CONFIG_AL) ? true : false;
    } else {
        result->alert_flag = false;
@@ -85,6 +85,11 @@ tmp112a_status_t tmp112a_read_temperature(tmp112a_result_t *result) {
    return TMP112A_STATUS_SUCCESS;
 }

+void tmp112a_get_raw_temperature_value(uint8_t *value) {
+    i2c_read_16bits(TMP112A_ADDR, TMP112A_TEMP_REG, value);
+    return;
+}
+
 /*!
    \brief      设置温度阈值
    \param[in]  low_temp: 低温阈值 (°C)
@@ -94,7 +99,7 @@ tmp112a_status_t tmp112a_read_temperature(tmp112a_result_t *result) {
 */
 tmp112a_status_t tmp112a_set_thresholds(float low_temp, float high_temp) {
    uint16_t low_raw, high_raw;
-    i2c_status_t status;
+    i2c_result_t status;
    
    /* 参数验证 */
    if (low_temp < TMP112A_TEMP_MIN || low_temp > TMP112A_TEMP_MAX ||
@@ -109,13 +114,13 @@ tmp112a_status_t tmp112a_set_thresholds(float low_temp, float high_temp) {
    
    /* 写入低温阈值 */
    status = tmp112a_write_register(TMP112A_TLOW_REG, low_raw);
-    if (status != I2C_STATUS_SUCCESS) {
+    if (status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
    /* 写入高温阈值 */
    status = tmp112a_write_register(TMP112A_THIGH_REG, high_raw);
-    if (status != I2C_STATUS_SUCCESS) {
+    if (status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
@@ -130,11 +135,11 @@ tmp112a_status_t tmp112a_set_thresholds(float low_temp, float high_temp) {
 */
 tmp112a_status_t tmp112a_shutdown(void) {
    uint16_t config_reg;
-    i2c_status_t status;
+    i2c_result_t status;
    
    /* 读取当前配置 */
    status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
-    if (status != I2C_STATUS_SUCCESS) {
+    if (status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
@@ -143,7 +148,7 @@ tmp112a_status_t tmp112a_shutdown(void) {
    
    /* 写回配置 */
    status = tmp112a_write_register(TMP112A_CONFIG_REG, config_reg);
-    return (status == I2C_STATUS_SUCCESS) ? TMP112A_STATUS_SUCCESS : TMP112A_STATUS_ERROR;
+    return (status == I2C_RESULT_SUCCESS) ? TMP112A_STATUS_SUCCESS : TMP112A_STATUS_ERROR;
 }

 /*!
@@ -154,11 +159,11 @@ tmp112a_status_t tmp112a_shutdown(void) {
 */
 tmp112a_status_t tmp112a_wakeup(void) {
    uint16_t config_reg;
-    i2c_status_t status;
+    i2c_result_t status;
    
    /* 读取当前配置 */
    status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
-    if (status != I2C_STATUS_SUCCESS) {
+    if (status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
@@ -167,7 +172,7 @@ tmp112a_status_t tmp112a_wakeup(void) {
    
    /* 写回配置 */
    status = tmp112a_write_register(TMP112A_CONFIG_REG, config_reg);
-    if (status != I2C_STATUS_SUCCESS) {
+    if (status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
@@ -185,7 +190,7 @@ tmp112a_status_t tmp112a_wakeup(void) {
 */
 tmp112a_status_t tmp112a_one_shot(tmp112a_result_t *result) {
    uint16_t config_reg;
-    i2c_status_t status;
+    i2c_result_t status;
    uint8_t timeout = 100; // 100ms超时
    
    if (result == NULL) {
@@ -194,14 +199,14 @@ tmp112a_status_t tmp112a_one_shot(tmp112a_result_t *result) {
    
    /* 读取当前配置 */
    status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
-    if (status != I2C_STATUS_SUCCESS) {
+    if (status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
    /* 启动单次转换 */
    config_reg |= TMP112A_CONFIG_OS;
    status = tmp112a_write_register(TMP112A_CONFIG_REG, config_reg);
-    if (status != I2C_STATUS_SUCCESS) {
+    if (status != I2C_RESULT_SUCCESS) {
        return TMP112A_STATUS_ERROR;
    }
    
@@ -209,7 +214,7 @@ tmp112a_status_t tmp112a_one_shot(tmp112a_result_t *result) {
    do {
        delay_ms(1);
        status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
-        if (status != I2C_STATUS_SUCCESS) {
+        if (status != I2C_RESULT_SUCCESS) {
            return TMP112A_STATUS_ERROR;
        }
        timeout--;
@@ -253,9 +258,9 @@ const char* tmp112a_get_status_string(tmp112a_status_t status) {
    \param[in]  reg_addr: 寄存器地址
    \param[in]  value: 写入值
    \param[out] none
-    \retval     i2c_status_t
+    \retval     i2c_result_t
 */
-static i2c_status_t tmp112a_write_register(uint8_t reg_addr, uint16_t value) {
+static i2c_result_t tmp112a_write_register(uint8_t reg_addr, uint16_t value) {
    uint8_t data[2];
    data[0] = (value >> 8) & 0xFF;
    data[1] = value & 0xFF;
@@ -267,18 +272,18 @@ static i2c_status_t tmp112a_write_register(uint8_t reg_addr, uint16_t value) {
    \brief      读取寄存器
    \param[in]  reg_addr: 寄存器地址
    \param[out] value: 读取值指针
-    \retval     i2c_status_t
+    \retval     i2c_result_t
 */
-static i2c_status_t tmp112a_read_register(uint8_t reg_addr, uint16_t *value) {
+static i2c_result_t tmp112a_read_register(uint8_t reg_addr, uint16_t *value) {
    uint8_t data[2];
-    i2c_status_t status;
+    i2c_result_t status;

    if (value == NULL) {
-        return I2C_STATUS_INVALID_PARAM;
+        return I2C_RESULT_INVALID_PARAM;
    }

    status = i2c_read_16bits(TMP112A_ADDR, reg_addr, data);
-    if (status == I2C_STATUS_SUCCESS) {
+    if (status == I2C_RESULT_SUCCESS) {
        *value = ((uint16_t)data[0] << 8) | data[1];
    }

--- a/Src/uart.c
+++ b/Src/uart.c
@@ -3,6 +3,7 @@
 #include "gd32e23x_rcu.h"
 #include "gd32e23x_gpio.h"
 #include "board_config.h"
+#include "uart_ring_buffer.h"


 void rs485_init(void) {
@@ -37,7 +38,7 @@ void rs485_init(void) {

    usart_enable(RS485_PHY);

-    nvic_irq_enable(USART0_IRQn, 0);
+    nvic_irq_enable(RS485_IRQ, 0);
    usart_interrupt_enable(RS485_PHY, USART_INT_RBNE);
    // usart_interrupt_enable(RS485_PHY, USART_INT_IDLE);

@@ -70,3 +71,37 @@ void rs485_init(void) {

    #endif // RS485_MAX13487
    }
+
+/******************************************************************************/
+/* 具体的中断处理函数实现 */
+/******************************************************************************/
+
+void usart0_irq_handler(void) {
+    // 处理USART0的接收中断
+    if(usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) {
+        uint8_t data = usart_data_receive(USART0);
+        // 使用原有的环形缓冲区处理逻辑
+        (void)uart_ring_buffer_put(data); // 缓冲满时丢弃，返回值可用于统计
+    }
+    
+    // 处理USART0的空闲中断
+    if(usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE)) {
+        usart_interrupt_flag_clear(USART0, USART_INT_FLAG_IDLE);
+        // 在这里添加空闲中断处理逻辑
+    }
+}
+
+void usart1_irq_handler(void) {
+    // 处理USART1的接收中断
+    if(usart_interrupt_flag_get(USART1, USART_INT_FLAG_RBNE)) {
+        uint8_t data = usart_data_receive(USART1);
+        // 使用原有的环形缓冲区处理逻辑
+        (void)uart_ring_buffer_put(data); // 缓冲满时丢弃，返回值可用于统计
+    }
+    
+    // 处理USART1的空闲中断
+    if(usart_interrupt_flag_get(USART1, USART_INT_FLAG_IDLE)) {
+        usart_interrupt_flag_clear(USART1, USART_INT_FLAG_IDLE);
+        // 在这里添加空闲中断处理逻辑
+    }
+}
--- a/DriveConfiguration.pdf
+++ b/DriveConfiguration.pdf
--- a/doc/Texas_Instruments-LDC1612QDNTTQ1-datasheet.pdf
+++ b/doc/Texas_Instruments-LDC1612QDNTTQ1-datasheet.pdf
--- a/doc/采用
+++ b/doc/采用
--- a/i2c_wait.c
+++ b/i2c_wait.c
@@ -1,542 +0,0 @@
-
-
-/* Private function prototypes */
-static i2c_status_t ldc1612_write_register(uint8_t reg_addr, uint16_t value);
-static i2c_status_t ldc1612_read_register(uint8_t reg_addr, uint16_t *value);
-static uint16_t ldc1612_calculate_clock_dividers(uint8_t channel);
-static uint32_t ldc1612_parse_raw_result(uint32_t raw_result);
-
-/*!
-    \brief      初始化LDC1612传感器
-    \param[in]  none
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_init(void) {
-    i2c_status_t i2c_status;
-    uint16_t device_id, manufacturer_id;
-    
-    /* 复位传感器 */
-    i2c_status = ldc1612_reset();
-    if (i2c_status != I2C_STATUS_SUCCESS) {
-        return LDC1612_STATUS_ERROR;
-    }
-    
-    /* 等待复位完成 */
-    delay_ms(10);
-    
-    /* 验证设备ID */
-    device_id = ldc1612_get_device_id();
-    manufacturer_id = ldc1612_get_manufacturer_id();
-    
-    if (device_id != 0x3055 || manufacturer_id != 0x5449) {
-        return LDC1612_STATUS_ERROR;
-    }
-    
-    return LDC1612_STATUS_SUCCESS;
-}
-
-/*!
-    \brief      复位LDC1612传感器
-    \param[in]  none
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_reset(void) {
-    i2c_status_t status = ldc1612_write_register(LDC1612_RESET_DEV, LDC1612_RESET_VALUE);
-    return (status == I2C_STATUS_SUCCESS) ? LDC1612_STATUS_SUCCESS : LDC1612_STATUS_ERROR;
-}
-
-/*!
-    \brief      配置单通道模式
-    \param[in]  channel: 通道号 (0或1)
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_config_single_channel(uint8_t channel) {
-    i2c_status_t status;
-    uint16_t clock_dividers;
-    
-    if (channel > 1) {
-        return LDC1612_STATUS_INVALID_PARAM;
-    }
-    
-    /* 进入休眠模式进行配置 */
-    status = ldc1612_write_register(LDC1612_CONFIG, LDC1612_SENSOR_CONFIG_SLEEP);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 计算并设置时钟分频 */
-    clock_dividers = ldc1612_calculate_clock_dividers(channel);
-    status = ldc1612_write_register(LDC1612_CLOCK_DIVIDERS_CH0 + channel, clock_dividers);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 设置稳定时间 */
-    status = ldc1612_write_register(LDC1612_SETTLECOUNT_CH0 + channel, LDC1612_SETTLECOUNT_CH0_DEFAULT);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 设置转换时间 */
-    status = ldc1612_write_register(LDC1612_RCOUNT_CH0 + channel, LDC1612_CONVERSION_TIME_CH0);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 设置错误配置 */
-    status = ldc1612_write_register(LDC1612_ERROR_CONFIG, LDC1612_ERROR_CONFIG_DEFAULT);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 设置驱动电流 */
-    status = ldc1612_write_register(LDC1612_DRIVE_CURRENT_CH0 + channel, LDC1612_DRIVE_CURRENT_DEFAULT);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 设置MUX配置 */
-    status = ldc1612_write_register(LDC1612_MUX_CONFIG, LDC1612_MUX_CONFIG_DEFAULT);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 退出休眠模式，开始转换 */
-    status = ldc1612_write_register(LDC1612_CONFIG, LDC1612_SENSOR_CONFIG_ACTIVE);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    return LDC1612_STATUS_SUCCESS;
-}
-
-/*!
-    \brief      读取制造商ID
-    \param[in]  none
-    \param[out] none
-    \retval     uint16_t 制造商ID
-*/
-uint16_t ldc1612_get_manufacturer_id(void) {
-    uint16_t id = 0;
-    ldc1612_read_register(LDC1612_MANUFACTURER_ID, &id);
-    return id;
-}
-
-/*!
-    \brief      读取设备ID
-    \param[in]  none
-    \param[out] none
-    \retval     uint16_t 设备ID
-*/
-uint16_t ldc1612_get_device_id(void) {
-    uint16_t id = 0;
-    ldc1612_read_register(LDC1612_DEVICE_ID, &id);
-    return id;
-}
-
-/*!
-    \brief      读取通道原始数据
-    \param[in]  channel: 通道号
-    \param[out] result: 结果结构体指针
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_read_channel(uint8_t channel, ldc1612_result_t *result) {
-    uint16_t msb, lsb;
-    uint32_t raw_data;
-    i2c_status_t status;
-    
-    if (channel > 1 || result == NULL) {
-        return LDC1612_STATUS_INVALID_PARAM;
-    }
-    
-    /* 读取MSB */
-    status = ldc1612_read_register(LDC1612_DATA_CH0_MSB + (channel * 2), &msb);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 读取LSB */
-    status = ldc1612_read_register(LDC1612_DATA_CH0_LSB + (channel * 2), &lsb);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 组合32位数据 */
-    raw_data = ((uint32_t)msb << 16) | lsb;
-    
-    /* 解析结果 */
-    result->raw_data = raw_data;
-    result->frequency = ldc1612_parse_raw_result(raw_data);
-    
-    /* 检查错误 */
-    if (result->frequency >= 0x10000000) {
-        result->error_flag = true;
-        result->error_code = (result->frequency >> 24) & 0xFF;
-        return LDC1612_STATUS_ERROR;
-    } else {
-        result->error_flag = false;
-        result->error_code = 0;
-    }
-    
-    return LDC1612_STATUS_SUCCESS;
-}
-
-/*!
-    \brief      设置驱动电流
-    \param[in]  channel: 通道号
-    \param[in]  current: 电流值
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_set_drive_current(uint8_t channel, uint16_t current) {
-    if (channel > 1) {
-        return LDC1612_STATUS_INVALID_PARAM;
-    }
-    
-    i2c_status_t status = ldc1612_write_register(LDC1612_DRIVE_CURRENT_CH0 + channel, current);
-    return (status == I2C_STATUS_SUCCESS) ? LDC1612_STATUS_SUCCESS : LDC1612_STATUS_ERROR;
-}
-
-/*!
-    \brief      自动检测驱动电流
-    \param[in]  channel: 通道号
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_auto_detect_drive_current(uint8_t channel) {
-    uint16_t config_value, drive_current_reg;
-    uint16_t init_value, drive_current;
-    i2c_status_t status;
-    
-    if (channel > 1) {
-        return LDC1612_STATUS_INVALID_PARAM;
-    }
-    
-    /* 进入休眠模式 */
-    status = ldc1612_write_register(LDC1612_CONFIG, LDC1612_SENSOR_CONFIG_SLEEP);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 设置时钟分频 */
-    uint16_t clock_dividers = ldc1612_calculate_clock_dividers(channel);
-    status = ldc1612_write_register(LDC1612_CLOCK_DIVIDERS_CH0 + channel, clock_dividers);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 读取当前配置并禁用Rp覆盖 */
-    status = ldc1612_read_register(LDC1612_CONFIG, &config_value);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    config_value &= ~(1 << 12); // 禁用RP_OVERRIDE_EN
-    status = ldc1612_write_register(LDC1612_CONFIG, config_value);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 启动测量 */
-    status = ldc1612_write_register(LDC1612_CONFIG, LDC1612_SENSOR_CONFIG_ACTIVE);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    /* 等待至少一次转换完成 */
-    delay_ms(10);
-    
-    /* 读取初始驱动电流值 */
-    status = ldc1612_read_register(LDC1612_DRIVE_CURRENT_CH0 + channel, &drive_current_reg);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    init_value = (drive_current_reg >> 6) & 0x1F;
-    drive_current = (init_value << 11) | 0x0000;
-    
-    /* 写入检测到的驱动电流 */
-    status = ldc1612_write_register(LDC1612_DRIVE_CURRENT_CH0 + channel, drive_current);
-    if (status != I2C_STATUS_SUCCESS) return LDC1612_STATUS_ERROR;
-    
-    return LDC1612_STATUS_SUCCESS;
-}
-
-/*!
-    \brief      获取状态字符串
-    \param[in]  status: 状态码
-    \param[out] none
-    \retval     const char* 状态字符串
-*/
-const char* ldc1612_get_status_string(ldc1612_status_t status) {
-    switch (status) {
-        case LDC1612_STATUS_SUCCESS:
-            return "SUCCESS";
-        case LDC1612_STATUS_ERROR:
-            return "ERROR";
-        case LDC1612_STATUS_TIMEOUT:
-            return "TIMEOUT";
-        case LDC1612_STATUS_INVALID_PARAM:
-            return "INVALID_PARAM";
-        case LDC1612_STATUS_NO_COIL:
-            return "NO_COIL";
-        case LDC1612_STATUS_UNDER_RANGE:
-            return "UNDER_RANGE";
-        case LDC1612_STATUS_OVER_RANGE:
-            return "OVER_RANGE";
-        default:
-            return "UNKNOWN";
-    }
-}
-
-/* Private Functions Implementation */
-
-/*!
-    \brief      写入寄存器
-    \param[in]  reg_addr: 寄存器地址
-    \param[in]  value: 写入值
-    \param[out] none
-    \retval     i2c_status_t
-*/
-static i2c_status_t ldc1612_write_register(uint8_t reg_addr, uint16_t value) {
-    uint8_t data[2];
-    data[0] = (value >> 8) & 0xFF;
-    data[1] = value & 0xFF;
-
-    return i2c_write_16bits(LDC1612_ADDR, reg_addr, data);
-}
-
-/*!
-    \brief      读取寄存器
-    \param[in]  reg_addr: 寄存器地址
-    \param[out] value: 读取值指针
-    \retval     i2c_status_t
-*/
-static i2c_status_t ldc1612_read_register(uint8_t reg_addr, uint16_t *value) {
-    uint8_t data[2];
-    i2c_status_t status;
-
-    if (value == NULL) {
-        return I2C_STATUS_INVALID_PARAM;
-    }
-
-    status = i2c_read_16bits(LDC1612_ADDR, reg_addr, data);
-    if (status == I2C_STATUS_SUCCESS) {
-        *value = ((uint16_t)data[0] << 8) | data[1];
-    }
-
-    return status;
-}
-
-/*!
-    \brief      计算时钟分频值
-    \param[in]  channel: 通道号
-    \param[out] none
-    \retval     uint16_t 分频值
-*/
-static uint16_t ldc1612_calculate_clock_dividers(uint8_t channel) {
-    uint16_t fin_div, fref_div;
-    float sensor_freq;
-
-    /* 计算传感器频率 (MHz) */
-    sensor_freq = 1.0f / (2.0f * 3.14159f * sqrtf(LDC1612_COIL_L_UH * LDC1612_COIL_C_PF * 1e-18f)) * 1e-6f;
-
-    /* 计算FIN分频 */
-    fin_div = (uint16_t)(sensor_freq / 8.75f + 1);
-
-    /* 计算FREF分频 */
-    if (fin_div * 4 < 40) {
-        fref_div = 2;
-    } else {
-        fref_div = 4;
-    }
-
-    return (fin_div << 12) | fref_div;
-}
-
-/*!
-    \brief      解析原始结果
-    \param[in]  raw_result: 原始数据
-    \param[out] none
-    \retval     uint32_t 解析后的数据
-*/
-static uint32_t ldc1612_parse_raw_result(uint32_t raw_result) {
-    uint32_t calibration_value;
-    uint8_t error_code;
-
-    calibration_value = raw_result & 0x0FFFFFFF;
-
-    /* 检查无线圈错误 */
-    if (calibration_value == 0x0FFFFFFF) {
-        return LDC1612_ERROR_NO_COIL;
-    }
-
-    error_code = (raw_result >> 24) & 0xFF;
-
-    /* 检查各种错误 */
-    if (error_code & 0x80) {
-        return LDC1612_ERROR_UNDER_RANGE;
-    }
-    if (error_code & 0x40) {
-        return LDC1612_ERROR_OVER_RANGE;
-    }
-    if (error_code & 0x20) {
-        return LDC1612_ERROR_WATCHDOG;
-    }
-    if (error_code & 0x10) {
-        return LDC1612_ERROR_AMPLITUDE;
-    }
-
-    return calibration_value;
-}
-
-
-// ldc1612.h
-//
-// Created by dell on 24-12-3.
-// LDC1612 Inductive Sensor Driver Header
-//
-
-#ifndef LDC1612_H
-#define LDC1612_H
-
-#include "gd32e23x_it.h"
-#include "gd32e23x.h"
-#include "systick.h"
-#include <stdbool.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include "board_config.h"
-#include "i2c.h"
-
-/******************************************************************************/
-/* LDC1612 I2C Address */
-#define LDC1612_ADDR         (0x2B)  // 7-bit address
-
-/* Register Addresses */
-/******************************************************************************/
-#define LDC1612_DATA_CH0_MSB                    0x00
-#define LDC1612_DATA_CH0_LSB                    0x01
-#define LDC1612_DATA_CH1_MSB                    0x02
-#define LDC1612_DATA_CH1_LSB                    0x03
-#define LDC1612_RCOUNT_CH0                      0x08
-#define LDC1612_RCOUNT_CH1                      0x09
-#define LDC1612_OFFSET_CH0                      0x0C
-#define LDC1612_OFFSET_CH1                      0x0D
-#define LDC1612_SETTLECOUNT_CH0                 0x10
-#define LDC1612_SETTLECOUNT_CH1                 0x11
-#define LDC1612_CLOCK_DIVIDERS_CH0              0x14
-#define LDC1612_CLOCK_DIVIDERS_CH1              0x15
-#define LDC1612_STATUS                          0x18
-#define LDC1612_ERROR_CONFIG                    0x19
-#define LDC1612_CONFIG                          0x1A
-#define LDC1612_MUX_CONFIG                      0x1B
-#define LDC1612_RESET_DEV                       0x1C
-#define LDC1612_DRIVE_CURRENT_CH0               0x1E
-#define LDC1612_DRIVE_CURRENT_CH1               0x1F
-#define LDC1612_MANUFACTURER_ID                 0x7E
-#define LDC1612_DEVICE_ID                       0x7F
-
-/* Channel Definitions */
-/******************************************************************************/
-#define LDC1612_CHANNEL_0                       0
-#define LDC1612_CHANNEL_1                       1
-
-/* Configuration Values */
-/******************************************************************************/
-#define LDC1612_CONVERSION_TIME_CH0             0x0546  // 转换时间
-#define LDC1612_DRIVE_CURRENT_DEFAULT           0x9000  // 驱动电流
-#define LDC1612_MUX_CONFIG_DEFAULT              0x020C  // 无自动扫描，滤波器带宽3.3MHz
-#define LDC1612_SENSOR_CONFIG_ACTIVE            0x1601  // 激活配置
-#define LDC1612_SENSOR_CONFIG_SLEEP             0x2801  // 休眠配置
-#define LDC1612_ERROR_CONFIG_DEFAULT            0x0000  // 错误配置
-#define LDC1612_SETTLECOUNT_CH0_DEFAULT         0x001E  // 稳定时间
-#define LDC1612_RESET_VALUE                     0x8000  // 复位值
-
-/* Coil Parameters */
-/******************************************************************************/
-#define LDC1612_COIL_RP_KOHM                    7.2f    // 并联电阻 (kΩ)
-#define LDC1612_COIL_L_UH                       33.0f   // 电感值 (μH)
-#define LDC1612_COIL_C_PF                       150.0f  // 电容值 (pF)
-#define LDC1612_COIL_Q_FACTOR                   35.97f  // 品质因数
-#define LDC1612_COIL_FREQ_HZ                    2262000 // 谐振频率 (Hz)
-
-/* Error Codes */
-/******************************************************************************/
-#define LDC1612_ERROR_NONE                      0x00000000
-#define LDC1612_ERROR_NO_COIL                   0xF0000000
-#define LDC1612_ERROR_UNDER_RANGE               0x80000000
-#define LDC1612_ERROR_OVER_RANGE                0x40000000
-#define LDC1612_ERROR_WATCHDOG                  0x20000000
-#define LDC1612_ERROR_AMPLITUDE                 0x10000000
-
-/* Status Definitions */
-/******************************************************************************/
-typedef enum {
-    LDC1612_STATUS_SUCCESS = 0,
-    LDC1612_STATUS_ERROR,
-    LDC1612_STATUS_TIMEOUT,
-    LDC1612_STATUS_INVALID_PARAM,
-    LDC1612_STATUS_NO_COIL,
-    LDC1612_STATUS_UNDER_RANGE,
-    LDC1612_STATUS_OVER_RANGE
-} ldc1612_status_t;
-
-typedef struct {
-    uint32_t raw_data;
-    uint32_t frequency;
-    float distance_mm;
-    bool error_flag;
-    uint8_t error_code;
-} ldc1612_result_t;
-
-/******************************************************************************/
-/* Function Declarations */
-
-/*!
-    \brief      初始化LDC1612传感器
-    \param[in]  none
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_init(void);
-
-/*!
-    \brief      复位LDC1612传感器
-    \param[in]  none
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_reset(void);
-
-/*!
-    \brief      配置单通道模式
-    \param[in]  channel: 通道号 (0或1)
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_config_single_channel(uint8_t channel);
-
-/*!
-    \brief      读取制造商ID
-    \param[in]  none
-    \param[out] none
-    \retval     uint16_t 制造商ID
-*/
-uint16_t ldc1612_get_manufacturer_id(void);
-
-/*!
-    \brief      读取设备ID
-    \param[in]  none
-    \param[out] none
-    \retval     uint16_t 设备ID
-*/
-uint16_t ldc1612_get_device_id(void);
-
-/*!
-    \brief      读取通道原始数据
-    \param[in]  channel: 通道号
-    \param[out] result: 结果结构体指针
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_read_channel(uint8_t channel, ldc1612_result_t *result);
-
-/*!
-    \brief      设置驱动电流
-    \param[in]  channel: 通道号
-    \param[in]  current: 电流值
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_set_drive_current(uint8_t channel, uint16_t current);
-
-/*!
-    \brief      自动检测驱动电流
-    \param[in]  channel: 通道号
-    \param[out] none
-    \retval     ldc1612_status_t
-*/
-ldc1612_status_t ldc1612_auto_detect_drive_current(uint8_t channel);
-
-/*!
-    \brief      获取状态字符串
-    \param[in]  status: 状态码
-    \param[out] none
-    \retval     const char* 状态字符串
-*/
-const char* ldc1612_get_status_string(ldc1612_status_t status);
-
-#endif //LDC1612_H
Author	SHA1	Message	Date
yelvlab	233576fd9a	test	2025-08-21 17:12:04 +08:00
yelvlab	b78c1e416a	detect MCU flash size to config diff usart	2025-08-21 00:39:30 +08:00
yelvlab	b6485c5c39	add tmp112a code	2025-08-18 00:18:21 +08:00
yelvlab	443e9bf8f2	fix H-file	2025-08-17 18:01:01 +08:00
yelvlab	b60cfbee97	Delete useless file	2025-08-17 03:10:50 +08:00
yelvlab	9b3cd46b09	clear repo	2025-08-17 03:06:46 +08:00