delete unuse file

.vscode/tasks.json

@@ -11,7 +11,11 @@
                 "Build",
                 "Flash MCU"
             ],
-            "dependsOrder": "sequence"
+            "dependsOrder": "sequence",
+            "icon": {
+                "id": "insert",
+                "tooltip": "Build and Flash"
+            }
         },
         {
             "label": "Flash MCU",
@@ -31,6 +35,10 @@
             },
             "presentation": {
                 "clear": true
+            },
+            "icon": {
+                "id": "gather",
+                "tooltip": "Flash MCU"
             }
         },
         {
@@ -51,6 +59,10 @@
             },
             "presentation": {
                 "clear": true
+            },
+            "icon": {
+                "id": "discard",
+                "tooltip": "Reset MCU"
             }
         },
         {
@@ -71,6 +83,10 @@
             },
             "presentation": {
                 "clear": true
+            },
+            "icon": {
+                "id": "clear-all",
+                "tooltip": "Erase MCU"
             }
         },
         {
@@ -119,6 +135,10 @@
             },
             "presentation": {
                 "clear": true
+            },
+            "icon": {
+                "id": "code",
+                "tooltip": "Build"
             }
         }
     ]

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驱动的可靠性、可维护性和调试能力。

Inc/board_config.h

@@ -13,8 +13,8 @@
 
 /* >>>>>>>>>>>>>>>>>>>>[DEBUG ASSERTIONS DEFINE]<<<<<<<<<<<<<<<<<<<< */
 
-#define DEBUG_VERBOSE // Debug Assertions Status : Debug Verbose Information
-// #undef  DEBUG_VERBOSE // Debug Assertions Status : No Debug Verbose Information
+// #define DEBUG_VERBOSE // Debug Assertions Status : Debug Verbose Information
+#undef  DEBUG_VERBOSE // Debug Assertions Status : No Debug Verbose Information
 
 /******************************************************************************/
 

Inc/command.h

@@ -16,6 +16,9 @@
  * @{
  */
 
+/** @brief 传感器周期上报使能标志 */
+extern volatile bool g_sensor_report_enabled;
+
 /**
  * @section Command_Protocol 协议格式
  * 接收命令帧格式：

Inc/i2c.h

@@ -32,15 +32,18 @@
 
 /******************************************************************************/
 
-/* I2C status enumeration */
+/* I2C result enumeration */
 typedef enum {
-    I2C_STATUS_SUCCESS = 0,     /* Operation successful */
-    I2C_STATUS_TIMEOUT,         /* Timeout occurred */
-    I2C_STATUS_NACK,            /* No acknowledge received */
-    I2C_STATUS_BUS_BUSY,        /* Bus is busy */
-    I2C_STATUS_ERROR,           /* General error */
-    I2C_STATUS_INVALID_PARAM    /* Invalid parameter */
-} i2c_status_t;
+    I2C_RESULT_SUCCESS = 0,     /* Operation successful */
+    I2C_RESULT_TIMEOUT,         /* Timeout occurred */
+    I2C_RESULT_NACK,            /* No acknowledge received */
+    I2C_RESULT_BUS_BUSY,        /* Bus is busy */
+    I2C_RESULT_ERROR,           /* General error */
+    I2C_RESULT_INVALID_PARAM,   /* Invalid parameter */
+    I2C_RECOVERY_OK,
+    I2C_RECOVERY_SDA_STUCK_LOW,
+    I2C_RECOVERY_SCL_STUCK_LOW
+} i2c_result_t;
 
 /* I2C state machine enumeration */
 typedef enum {
@@ -53,45 +56,29 @@ typedef enum {
     I2C_STATE_RESTART,          /* Generate restart condition */
     I2C_STATE_RECEIVE_DATA,     /* Receive data */
     I2C_STATE_STOP,             /* Generate stop condition */
-    I2C_STATE_ERROR             /* Error state */
+    I2C_STATE_ERROR,            /* Error state */
+    I2C_STATE_END
 } i2c_state_t;
 
-/* Legacy enumeration for compatibility */
-typedef enum {
-    I2C_START = 0,
-    I2C_SEND_ADDRESS,
-    I2C_CLEAR_ADDRESS_FLAG,
-    I2C_TRANSMIT_DATA,
-    I2C_STOP
-} i2c_process_enum;
-
 /******************************************************************************/
 
+
 /* Function declarations */
-
-/*!
-    \brief      configure the GPIO ports for I2C
-    \param[in]  none
-    \param[out] none
-    \retval     none
-*/
-void i2c_gpio_config(void);
-
 /*!
     \brief      configure the I2C interface
     \param[in]  none
     \param[out] none
-    \retval     i2c_status_t
+    \retval     i2c_result_t
 */
-i2c_status_t i2c_config(void);
+i2c_result_t i2c_config(void);
 
 /*!
     \brief      reset I2C bus with proper recovery
     \param[in]  none
     \param[out] none
-    \retval     i2c_status_t
+    \retval     i2c_result_t
 */
-i2c_status_t i2c_bus_reset(void);
+i2c_result_t i2c_bus_reset(void);
 
 /*!
     \brief      scan I2C bus for devices
@@ -107,25 +94,34 @@ void i2c_scan(void);
     \param[in]  reg_addr: register address
     \param[in]  data: pointer to 2-byte data array
     \param[out] none
-    \retval     i2c_status_t
+    \retval     i2c_result_t
 */
-i2c_status_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, const uint8_t data[2]);
+i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[2]);
 
 /*!
     \brief      read 16-bit data from I2C device
     \param[in]  slave_addr: 7-bit slave address
     \param[in]  reg_addr: register address
     \param[out] data: pointer to 2-byte data buffer
-    \retval     i2c_status_t
+    \retval     i2c_result_t
 */
-i2c_status_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
+i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
+
+/*!
+    \brief      read 16-bit data from I2C device
+    \param[in]  slave_addr: 7-bit slave address
+    \param[in]  reg_addr: register address
+    \param[out] data: pointer to 2-byte data buffer
+    \retval     i2c_result_t
+*/
+i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
 
 /*!
     \brief      get status string for debugging
-    \param[in]  status: i2c_status_t value
+    \param[in]  status: i2c_result_t value
     \param[out] none
     \retval     const char* status string
 */
-const char* i2c_get_status_string(i2c_status_t status);
+const char* i2c_get_status_string(i2c_result_t status);
 
 #endif //I2C_H

Inc/sensor_example.h

@@ -0,0 +1,28 @@
+//
+// 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

Src/command.c

@@ -77,7 +77,7 @@
  * ============================================================================ */
 
 /** @brief 传感器周期上报使能标志 */
-static volatile bool s_sensor_report_enabled = false;
+volatile bool g_sensor_report_enabled = false;
 
 /** @name 预设响应数据
  * @{ */
@@ -96,7 +96,7 @@ static const uint8_t s_report_status_err[] = { 'e','r','r' }; /**< 错误响应
  */
 bool get_sensor_report_enabled(void)
 {
-    return s_sensor_report_enabled;
+    return g_sensor_report_enabled;
 }
 
 /**
@@ -108,7 +108,7 @@ bool get_sensor_report_enabled(void)
  */
 void set_sensor_report_status(bool status)
 {
-    s_sensor_report_enabled = status;
+    g_sensor_report_enabled = status;
 }
 
 /**
@@ -234,8 +234,8 @@ static uint8_t parse_uint_dec(const uint8_t *s, uint8_t n, uint32_t *out)
  *          - 带参数命令：M<数字>S<参数>（如 M100S123，参数为十进制）
  *          
  *          支持的命令：
- *          - M1: 开启LED，启用传感器上报
- *          - M2: 关闭LED，禁用传感器上报  
+ *          - M1: 启用传感器上报
+ *          - M2: 禁用传感器上报  
  *          - M100S<value>: 设置PWM值（示例）
  *          
  * @param frame 指向完整命令帧的缓冲区（从包头0xD5开始）。
@@ -275,29 +275,425 @@ void handle_command(const uint8_t *frame, uint8_t len) {
     if (cmd_index == cmd_len) {
         // 仅基础命令，如 M1, M2, M3
         switch (base_cmd) {
-            case 1u: // M1命令
+            case 1u: // M1: enable sensor report
                 set_sensor_report_status(true);
-                // send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
-                uint8_t test_response1[] = { 0xAA, 0xBB, 0xCC, 0xDD };
-                send_response(RESP_TYPE_OK, test_response1, sizeof(test_response1));
+                send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
                 return;
-            case 2u: // M2命令
+            case 2u: // M2: disable sensor report
                 set_sensor_report_status(false);
-                // send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
-                uint8_t test_response2[] = { 0xDD, 0xCC, 0xBB, 0xAA };
-                send_response(RESP_TYPE_OK, test_response2, sizeof(test_response2));
+                send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
                 return;
 
             // 示例：M3、M10、M201、M100 等（按需添加）
-            case 3u: // M3命令
-                send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
-                return;
-            case 4u: // M4命令
-                send_response(RESP_TYPE_OK, s_report_status_err, sizeof(s_report_status_err));
-                return;
-            // case 10u: // M10命令
-            //     send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
+            // 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);
+                
+            //     // 使用更高的驱动电流重新配置
+            //     // 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 201u: // M201命令
             //     send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
             //     return;

Src/i2c.c

@@ -1,13 +1,9 @@
 //
 // Created by dell on 24-12-20.
-// Improved I2C driver with better state machine and error handling
 //
 
 #include "i2c.h"
 
-/* Private variables */
-static uint8_t i2c_retry_count = 0;
-
 /*!
     \brief      configure the GPIO ports
     \param[in]  none
@@ -33,81 +29,131 @@ void i2c_gpio_config(void) {
     \brief      configure the I2CX interface
     \param[in]  none
     \param[out] none
-    \retval     i2c_status_t
+    \retval     none
 */
-i2c_status_t i2c_config(void) {
+i2c_result_t i2c_config(void) {
     /* configure I2C GPIO */
     i2c_gpio_config();
-    
     /* enable I2C clock */
     rcu_periph_clock_enable(RCU_I2C);
-    
     /* configure I2C clock */
     i2c_clock_config(I2C0, I2C_SPEED, I2C_DTCY_2);
-    
-    /* configure I2C address - use 0x00 as master doesn't need specific address */
-    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C_MASTER_ADDRESS);
-    
+    /* configure I2C address */
+    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, 0xA0);
     /* enable I2CX */
     i2c_enable(I2C0);
-    
     /* enable acknowledge */
     i2c_ack_config(I2C0, I2C_ACK_ENABLE);
-    
-    /* reset retry counter */
-    i2c_retry_count = 0;
-    
-    return I2C_STATUS_SUCCESS;
+
+    return I2C_RESULT_SUCCESS;
+}
+
+/* wait for SCL to go high, return true if successful, false if timeout */
+static bool i2c_wait_scl_high(uint16_t max_wait_time) {
+    while (max_wait_time--) {
+        if (gpio_input_bit_get(I2C_SCL_PORT, I2C_SCL_PIN)) {
+            return true;
+        }
+        delay_10us(1);
+    }
+    return false;
+}
+
+/* generate one manual SCL pulse; return true if SCL observed high (no stuck/overstretch) */
+static bool i2c_generate_scl_pulse(void) {
+    GPIO_BC(I2C_SCL_PORT) = I2C_SCL_PIN;   /* drive SCL low */
+    delay_10us(1);
+    GPIO_BOP(I2C_SCL_PORT) = I2C_SCL_PIN;  /* release SCL (open-drain -> high via pull-up) */
+    return i2c_wait_scl_high(200);         /* wait up to ~2ms for clock stretching release */
 }
 
 /*!
-    \brief      reset I2C bus with proper 9-clock recovery
+    \brief      reset I2C bus
     \param[in]  none
     \param[out] none
-    \retval     i2c_status_t
+    \retval     none
 */
-i2c_status_t i2c_bus_reset(void) {
-    uint8_t i;
-    
-    /* disable I2C peripheral */
+i2c_result_t i2c_bus_reset(void) {
+    /* 1. Disable & deinit peripheral so pins can be fully controlled */
     i2c_disable(I2C0);
     i2c_deinit(I2C0);
-    
-    /* configure SDA/SCL as GPIO output for manual control */
+
+#ifdef DEBUG_VERBOSE
+    printf("I2C bus reset\r\n");
+#endif
+
+    /* 2. Configure SCL/SDA as GPIO open-drain outputs with pull-up and release them */
     gpio_mode_set(I2C_SCL_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, I2C_SCL_PIN);
     gpio_mode_set(I2C_SDA_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, I2C_SDA_PIN);
     gpio_output_options_set(I2C_SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
     gpio_output_options_set(I2C_SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);
-    
-    /* ensure both lines are high initially */
-    gpio_bit_set(I2C_SCL_PORT, I2C_SCL_PIN);
-    gpio_bit_set(I2C_SDA_PORT, I2C_SDA_PIN);
-    delay_10us(I2C_DELAY_10US);
-    
-    /* generate 9 clock pulses to release any stuck slave */
-    for (i = 0; i < I2C_RECOVERY_CLOCKS; i++) {
-        gpio_bit_reset(I2C_SCL_PORT, I2C_SCL_PIN);
-        delay_10us(I2C_DELAY_10US);
-        gpio_bit_set(I2C_SCL_PORT, I2C_SCL_PIN);
-        delay_10us(I2C_DELAY_10US);
+    gpio_bit_set(I2C_SCL_PORT, I2C_SCL_PIN); /* release SCL */
+    gpio_bit_set(I2C_SDA_PORT, I2C_SDA_PIN); /* release SDA */
+
+#ifdef DEBUG_VERBOSE
+    printf("I2C bus reset: SCL = %d, SDA = %d\r\n", gpio_input_bit_get(I2C_SCL_PORT, I2C_SCL_PIN), gpio_input_bit_get(I2C_SDA_PORT, I2C_SDA_PIN));
+#endif
+
+    /* 3. Double sample to confirm bus state */
+    delay_10us(1);
+    bool scl_value1 = gpio_input_bit_get(I2C_SCL_PORT, I2C_SCL_PIN);
+    bool sda_value1 = gpio_input_bit_get(I2C_SDA_PORT, I2C_SDA_PIN);
+    delay_10us(1);
+    bool scl_value2 = gpio_input_bit_get(I2C_SCL_PORT, I2C_SCL_PIN);
+    bool sda_value2 = gpio_input_bit_get(I2C_SDA_PORT, I2C_SDA_PIN);
+
+    /* 4. If SCL low -> stuck (cannot proceed) */
+    if (!scl_value2) {
+#ifdef DEBUG_VERBOSE
+        printf("I2C bus reset: SCL stuck low\r\n");
+#endif
+        return I2C_RECOVERY_SCL_STUCK_LOW;
     }
-    
-    /* generate stop condition */
-    gpio_bit_reset(I2C_SDA_PORT, I2C_SDA_PIN);
-    delay_10us(I2C_DELAY_10US);
-    gpio_bit_set(I2C_SCL_PORT, I2C_SCL_PIN);
-    delay_10us(I2C_DELAY_10US);
-    gpio_bit_set(I2C_SDA_PORT, I2C_SDA_PIN);
-    delay_10us(I2C_DELAY_10US);
-    
-    /* reconfigure as I2C pins */
-    gpio_af_set(I2C_SCL_PORT, I2C_GPIO_AF, I2C_SCL_PIN);
-    gpio_af_set(I2C_SDA_PORT, I2C_GPIO_AF, I2C_SDA_PIN);
-    gpio_mode_set(I2C_SCL_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, I2C_SCL_PIN);
-    gpio_mode_set(I2C_SDA_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, I2C_SDA_PIN);
-    
-    /* reconfigure the I2CX interface */
-    return i2c_config();
+
+    /* 5. Fast path: bus idle */
+    if (scl_value1 && sda_value1 && scl_value2 && sda_value2) {
+        i2c_config();
+#ifdef DEBUG_VERBOSE
+        printf("I2C bus reset: bus idle\r\n");
+#endif
+        return I2C_RECOVERY_OK;
+    }
+
+    /* 6. SDA low: attempt to free by generating up to I2C_RECOVERY_CLOCKS pulses */
+    if (scl_value2 && !sda_value2) {
+        bool sda_released = false;
+#ifdef DEBUG_VERBOSE
+        printf("I2C bus reset: SCL will try to free SDA\r\n");
+#endif
+        for (uint8_t i = 0; i < I2C_RECOVERY_CLOCKS && !sda_released; i++) {
+            if (!i2c_generate_scl_pulse()) {
+                return I2C_RECOVERY_SCL_STUCK_LOW; /* SCL failed to go high */
+            }
+            if (gpio_input_bit_get(I2C_SDA_PORT, I2C_SDA_PIN)) {
+                sda_released = true;
+            }
+        }
+        if (!sda_released) {
+            return I2C_RECOVERY_SDA_STUCK_LOW;
+        }
+        /* 7. Generate a STOP condition to leave bus in idle state */
+#ifdef DEBUG_VERBOSE
+        printf("I2C bus reset: generating STOP condition\r\n");
+#endif
+        gpio_bit_reset(I2C_SDA_PORT, I2C_SDA_PIN); /* SDA low */
+        delay_10us(1);
+        gpio_bit_set(I2C_SCL_PORT, I2C_SCL_PIN);   /* ensure SCL high */
+        delay_10us(1);
+        gpio_bit_set(I2C_SDA_PORT, I2C_SDA_PIN);   /* SDA rising while SCL high -> STOP */
+        delay_10us(1);
+    }
+
+#ifdef DEBUG_VERBOSE
+        printf("I2C bus reset: bus recovered\r\n");
+#endif
+    /* 8. Reconfigure & enable peripheral */
+    i2c_config();
+    return I2C_RECOVERY_OK;
 }
 
 /**
@@ -182,7 +228,7 @@ void i2c_scan(void) {
 
         timeout = 0;
 
-        while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT))
+        while (i2c_flag_get(I2C0, I2C_FLAG_STPDET) && (timeout < I2C_TIME_OUT))
             timeout++;
     }
 
@@ -217,33 +263,22 @@ void i2c_scan(void) {
     }
 }
 
-/*!
-    \brief      write 16-bit data to I2C device with improved state machine
-    \param[in]  slave_addr: 7-bit slave address
-    \param[in]  reg_addr: register address
-    \param[in]  data: pointer to 2-byte data array
-    \param[out] none
-    \retval     i2c_status_t
-*/
-i2c_status_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, const uint8_t data[2]) {
+i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[2]) {
     i2c_state_t state = I2C_STATE_START;
     uint16_t timeout = 0;
-    uint8_t data_index = 0;
     uint8_t retry_count = 0;
 
-    /* Parameter validation */
+    /* parameter validation */
     if (data == NULL || slave_addr > 0x7F) {
-        return I2C_STATUS_INVALID_PARAM;
+        return I2C_RESULT_INVALID_PARAM;
     }
 
-    /* Enable acknowledge */
-    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
-
     while (retry_count < I2C_MAX_RETRY) {
         switch (state) {
             case I2C_STATE_START:
                 timeout = 0;
-                /* Wait for bus to be idle */
+
+                /* wait for bus to be idle */
                 while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -252,15 +287,14 @@ i2c_status_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, const uint8_
                     break;
                 }
 
-                /* Send start condition */
                 i2c_start_on_bus(I2C0);
-                state = I2C_STATE_SEND_ADDRESS;
                 timeout = 0;
+                state = I2C_STATE_SEND_ADDRESS;
                 break;
 
             case I2C_STATE_SEND_ADDRESS:
-                /* Wait for start condition to be sent */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
+                /* wait for start condition to be sent. SBSEND flag */
+                while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
                 if (timeout >= I2C_TIME_OUT) {
@@ -268,30 +302,37 @@ i2c_status_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, const uint8_
                     break;
                 }
 
-                /* Send slave address with write bit */
-                i2c_master_addressing(I2C0, (slave_addr << 1), I2C_TRANSMITTER);
-                state = I2C_STATE_CLEAR_ADDRESS;
+                /* send slave address */
+                i2c_master_addressing(I2C0, slave_addr << 1, I2C_TRANSMITTER);
                 timeout = 0;
+                state = I2C_STATE_CLEAR_ADDRESS;
                 break;
 
             case I2C_STATE_CLEAR_ADDRESS:
-                /* Wait for address to be acknowledged */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) {
+                /* wait for address to be acknowledged.ADDSEND set means i2c slave sends ACK */
+                while ((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (!i2c_flag_get(I2C0, I2C_FLAG_AERR)) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
                 if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
+                } else if (i2c_flag_get(I2C0, I2C_FLAG_ADDSEND))
+                {
+                    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+                    timeout =0;
+                    state = I2C_STATE_TRANSMIT_REG;
+                    break;
+                } else {
+                    i2c_flag_clear(I2C0, I2C_FLAG_AERR);
+                    timeout =0;
+#ifdef DEBUG_VERBOES
+                    printf("IIC write failed for Error Slave Address. \n");
+#endif
+                    return I2C_RESULT_NACK;
                 }
 
-                /* Clear address flag */
-                i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
-                state = I2C_STATE_TRANSMIT_REG;
-                timeout = 0;
-                break;
-
             case I2C_STATE_TRANSMIT_REG:
-                /* Wait for transmit buffer to be empty */
+                /* wait until the transmit data buffer is empty */
                 while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -300,16 +341,15 @@ i2c_status_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, const uint8_
                     break;
                 }
 
-                /* Send register address */
+                /* send register address */
                 i2c_data_transmit(I2C0, reg_addr);
-                state = I2C_STATE_TRANSMIT_DATA;
                 timeout = 0;
-                data_index = 0;
+                state = I2C_STATE_TRANSMIT_DATA;
                 break;
 
             case I2C_STATE_TRANSMIT_DATA:
-                /* Wait for byte transfer complete */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
+                /* wait until the transmit data buffer is empty */
+                while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
                 if (timeout >= I2C_TIME_OUT) {
@@ -317,24 +357,49 @@ i2c_status_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, const uint8_
                     break;
                 }
 
-                /* Send data bytes */
-                if (data_index < 2) {
-                    i2c_data_transmit(I2C0, data[data_index]);
-                    data_index++;
-                    timeout = 0;
-                    /* Stay in this state until all data is sent */
-                } else {
-                    /* All data sent, proceed to stop */
-                    state = I2C_STATE_STOP;
-                    timeout = 0;
+                /* send register MSB value */
+                i2c_data_transmit(I2C0, data[0]);
+                timeout = 0;
+                
+                /* wait until the transmit data buffer is empty */
+                while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
                 }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                if (i2c_flag_get(I2C0, I2C_FLAG_AERR)) {
+                    i2c_stop_on_bus(I2C0);
+                    return I2C_RESULT_NACK;
+                } else if (i2c_flag_get(I2C0, I2C_FLAG_BERR) || i2c_flag_get(I2C0, I2C_FLAG_LOSTARB)) {
+                    // 可按需清标志
+                    i2c_stop_on_bus(I2C0);
+                    return I2C_RESULT_ERROR;
+                }
+
+                /* send register LSB value */
+                i2c_data_transmit(I2C0, data[1]);
+                timeout = 0;
+                
+                /* wait until BTC bit is set */
+                while (!i2c_flag_get(I2C0, I2C_FLAG_BTC) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                state = I2C_STATE_STOP;
                 break;
 
             case I2C_STATE_STOP:
-                /* Send stop condition */
+                /* send a stop condition to I2C bus */
                 i2c_stop_on_bus(I2C0);
 
-                /* Wait for stop condition to complete */
+                timeout = 0;
                 while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -343,80 +408,71 @@ i2c_status_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, const uint8_
                     break;
                 }
 
-                /* Success */
-                return I2C_STATUS_SUCCESS;
+                /* i2c master sends STOP signal successfully */
+                /* success */
+                return I2C_RESULT_SUCCESS;
 
             case I2C_STATE_ERROR:
-                /* Send stop condition to release bus */
+                /* send a stop condition to I2C bus */
                 i2c_stop_on_bus(I2C0);
 
-                /* Increment retry counter */
-                retry_count++;
-                if (retry_count >= I2C_MAX_RETRY) {
-#ifdef DEBUG_VERBOSE
-                    // printf("I2C write failed after %d retries\r\n", I2C_MAX_RETRY);
-                    const char* msg5_prefix = "I2C write failed after ";
-                    for (uint8_t i = 0; msg5_prefix[i] != '\0'; i++) {
-                        while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
-                        usart_data_transmit(I2C_DEBUG_UART, msg5_prefix[i]);
-                    }
-                    while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
-                    usart_data_transmit(I2C_DEBUG_UART, '0' + I2C_MAX_RETRY);
-                    const char* msg5_suffix = " retries\r\n";
-                    for (uint8_t i = 0; msg5_suffix[i] != '\0'; i++) {
-                        while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
-                        usart_data_transmit(I2C_DEBUG_UART, msg5_suffix[i]);
-                    }
-                    while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TC) == RESET) {}
-#endif
-                    return I2C_STATUS_TIMEOUT;
+                timeout = 0;
+                while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if (timeout >= I2C_TIME_OUT) {
+                    return I2C_RESULT_ERROR;
                 }
 
-                /* Reset state machine for retry */
+                i2c_flag_clear(I2C0, I2C_FLAG_AERR);
+                i2c_flag_clear(I2C0, I2C_FLAG_BERR);
+                i2c_flag_clear(I2C0, I2C_FLAG_LOSTARB);
+
+                retry_count ++;
+                if (retry_count >= I2C_MAX_RETRY)
+                {
+#ifdef DEBUG_VERBOES
+                    printf("IIC write failed after %d retries\n", I2C_MAX_RETRY);
+#endif
+                    return I2C_RESULT_ERROR;
+                }
+
+                /* reset state machine for retry */
                 state = I2C_STATE_START;
                 timeout = 0;
-                data_index = 0;
 
-                /* Small delay before retry */
+                /* small delay before retry */
                 delay_10us(10);
                 break;
-
+                
             default:
-                state = I2C_STATE_ERROR;
+                state = I2C_STATE_START;
                 break;
         }
     }
-
-    return I2C_STATUS_TIMEOUT;
+    return I2C_RESULT_TIMEOUT;
 }
 
-/*!
-    \brief      read 16-bit data from I2C device with improved state machine
-    \param[in]  slave_addr: 7-bit slave address
-    \param[in]  reg_addr: register address
-    \param[out] data: pointer to 2-byte data buffer
-    \retval     i2c_status_t
-*/
-i2c_status_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
+i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
     i2c_state_t state = I2C_STATE_START;
     uint16_t timeout = 0;
-    uint8_t data_index = 0;
     uint8_t retry_count = 0;
-    bool write_phase = true;  /* First phase: write register address */
+    bool write_phase = true;
 
-    /* Parameter validation */
+    // 参数检查：防止空指针和非法地址
     if (data == NULL || slave_addr > 0x7F) {
-        return I2C_STATUS_INVALID_PARAM;
+        return I2C_RESULT_INVALID_PARAM;
     }
 
-    /* Enable acknowledge */
+    /* enable acknowledge */
     i2c_ack_config(I2C0, I2C_ACK_ENABLE);
 
-    while (retry_count < I2C_MAX_RETRY) {
+    while (retry_count < (uint8_t)I2C_MAX_RETRY) {
         switch (state) {
             case I2C_STATE_START:
                 timeout = 0;
-                /* Wait for bus to be idle */
+
+                // wait for bus to be idle
                 while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -425,19 +481,14 @@ i2c_status_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                     break;
                 }
 
-                /* Configure ACK position for 2-byte read */
-                if (!write_phase) {
-                    i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
-                }
-
-                /* Send start condition */
+                // send start condition
                 i2c_start_on_bus(I2C0);
                 state = I2C_STATE_SEND_ADDRESS;
                 timeout = 0;
                 break;
 
             case I2C_STATE_SEND_ADDRESS:
-                /* Wait for start condition to be sent */
+                /* wait for start condition to be sent  */
                 while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -446,22 +497,21 @@ i2c_status_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                     break;
                 }
 
-                /* Send slave address */
+                // send slave address
                 if (write_phase) {
-                    /* Write phase: send address with write bit */
+                    /* write phase: send address with write bit */
                     i2c_master_addressing(I2C0, (slave_addr << 1), I2C_TRANSMITTER);
                 } else {
-                    /* Read phase: send address with read bit */
+                    /* read phase: send address with read bit */
                     i2c_master_addressing(I2C0, (slave_addr << 1) | 0x01, I2C_RECEIVER);
-                    /* Disable ACK for last byte */
-                    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
                 }
+
                 state = I2C_STATE_CLEAR_ADDRESS;
                 timeout = 0;
                 break;
 
             case I2C_STATE_CLEAR_ADDRESS:
-                /* Wait for address to be acknowledged */
+                /* wait for address to be acknowledged */
                 while ((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -470,24 +520,26 @@ i2c_status_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                     break;
                 }
 
-                /* Clear address flag */
-                i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
-
                 if (write_phase) {
-                    state = I2C_STATE_TRANSMIT_REG;
+                    /* clear address flag (write phase) */
+                    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+                    state = I2C_STATE_TRANSMIT_DATA;
                 } else {
-                    /* For single byte read, send stop after clearing address */
-                    if (data_index == 1) {
-                        i2c_stop_on_bus(I2C0);
-                    }
+                    /* READ phase for 2 bytes: set POS=NEXT and disable ACK BEFORE clearing ADDR */
+                    i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
+                    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+
+                    /* now clear address flag to release SCL and enter data phase */
+                    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+
                     state = I2C_STATE_RECEIVE_DATA;
-                    data_index = 0;
                 }
+
                 timeout = 0;
                 break;
 
-            case I2C_STATE_TRANSMIT_REG:
-                /* Wait for transmit buffer to be empty */
+            case I2C_STATE_TRANSMIT_DATA:
+                /* wait for transmit buffer to be empty */
                 while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -496,14 +548,14 @@ i2c_status_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                     break;
                 }
 
-                /* Send register address */
+                /* send register address */
                 i2c_data_transmit(I2C0, reg_addr);
                 state = I2C_STATE_RESTART;
                 timeout = 0;
                 break;
 
             case I2C_STATE_RESTART:
-                /* Wait for byte transfer complete */
+                /* wait for byte transfer complete  BTC: Bit Transfer Complete */
                 while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -512,51 +564,50 @@ i2c_status_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                     break;
                 }
 
-                /* Switch to read phase */
+                /* generate repeated start condition */
+                i2c_start_on_bus(I2C0);
+                
+                /* wait for repeated start condition to be sent */
+                timeout = 0;
+                while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* send slave address with read bit (R/W bit is set by library) */
+                i2c_master_addressing(I2C0, (slave_addr << 1), I2C_RECEIVER);
+
+                /* switch to read phase */
                 write_phase = false;
-                state = I2C_STATE_START;
+                state = I2C_STATE_CLEAR_ADDRESS;
                 timeout = 0;
                 break;
 
             case I2C_STATE_RECEIVE_DATA:
-                if (data_index < 2) {
-                    if (data_index == 1) {
-                        /* Wait for BTC before sending stop for last byte */
-                        while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
-                            timeout++;
-                        }
-                        if (timeout >= I2C_TIME_OUT) {
-                            state = I2C_STATE_ERROR;
-                            break;
-                        }
-                        /* Send stop condition before reading last byte */
-                        i2c_stop_on_bus(I2C0);
-                    }
-
-                    /* Wait for receive buffer not empty */
-                    while ((!i2c_flag_get(I2C0, I2C_FLAG_RBNE)) && (timeout < I2C_TIME_OUT)) {
-                        timeout++;
-                    }
-                    if (timeout >= I2C_TIME_OUT) {
-                        state = I2C_STATE_ERROR;
-                        break;
-                    }
-
-                    /* Read data byte */
-                    data[data_index] = i2c_data_receive(I2C0);
-                    data_index++;
-                    timeout = 0;
-
-                    if (data_index >= 2) {
-                        state = I2C_STATE_STOP;
-                    }
-                } else {
-                    state = I2C_STATE_STOP;
+                /* Wait for BTC (both bytes received) */
+                while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
                 }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* Send STOP before reading the last two bytes */
+                i2c_stop_on_bus(I2C0);
+
+                /* Read the two bytes back-to-back */
+                data[0] = i2c_data_receive(I2C0);
+                data[1] = i2c_data_receive(I2C0);
+
+                state = I2C_STATE_STOP;
                 break;
 
             case I2C_STATE_STOP:
-                /* Wait for stop condition to complete */
+                /* wait for stop condition to complete */
                 while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
                     timeout++;
                 }
@@ -565,75 +616,62 @@ i2c_status_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                     break;
                 }
 
-                /* Success */
-                return I2C_STATUS_SUCCESS;
+                /* i2c master sends STOP signal successfully */
+                /* success */
+                return I2C_RESULT_SUCCESS;
 
             case I2C_STATE_ERROR:
-                /* Send stop condition to release bus */
+                /* send stop condition to release bus */
                 i2c_stop_on_bus(I2C0);
 
-                /* Increment retry counter */
                 retry_count++;
                 if (retry_count >= I2C_MAX_RETRY) {
-#ifdef DEBUG_VERBOSE
-                    // printf("I2C read failed after %d retries\r\n", I2C_MAX_RETRY);
-                    const char* msg6_prefix = "I2C read failed after ";
-                    for (uint8_t i = 0; msg6_prefix[i] != '\0'; i++) {
-                        while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
-                        usart_data_transmit(I2C_DEBUG_UART, msg6_prefix[i]);
-                    }
-                    while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
-                    usart_data_transmit(I2C_DEBUG_UART, '0' + I2C_MAX_RETRY);
-                    const char* msg6_suffix = " retries\r\n";
-                    for (uint8_t i = 0; msg6_suffix[i] != '\0'; i++) {
-                        while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
-                        usart_data_transmit(I2C_DEBUG_UART, msg6_suffix[i]);
-                    }
-                    while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TC) == RESET) {}
+#ifdef DEBUG_VERBOES
+                    printf("IIC read failed after %d retries\n", I2C_RETRY_MAX);
 #endif
-                    return I2C_STATUS_TIMEOUT;
+                    return I2C_RESULT_ERROR;
                 }
 
-                /* Reset state machine for retry */
+                /* reset state machine for retry */
                 state = I2C_STATE_START;
                 write_phase = true;
                 timeout = 0;
-                data_index = 0;
 
-                /* Small delay before retry */
+                /* small delay before retry */
                 delay_10us(10);
                 break;
 
             default:
-                state = I2C_STATE_ERROR;
+                state = I2C_STATE_START;
                 break;
         }
     }
-
-    return I2C_STATUS_TIMEOUT;
+    return I2C_RESULT_TIMEOUT;
 }
 
+#ifdef DEBUG_VERBOSE
 /*!
     \brief      get status string for debugging
     \param[in]  status: i2c_status_t value
     \param[out] none
     \retval     const char* status string
 */
-const char* i2c_get_status_string(i2c_status_t status) {
+const char* i2c_get_status_string(i2c_result_t status) {
     switch (status) {
-        case I2C_STATUS_SUCCESS:
+        case I2C_RESULT_SUCCESS:
             return "SUCCESS";
-        case I2C_STATUS_TIMEOUT:
+        case I2C_RESULT_TIMEOUT:
             return "TIMEOUT";
-        case I2C_STATUS_NACK:
+        case I2C_RESULT_NACK:
             return "NACK";
-        case I2C_STATUS_BUS_BUSY:
+        case I2C_RESULT_BUS_BUSY:
             return "BUS_BUSY";
-        case I2C_STATUS_ERROR:
+        case I2C_RESULT_ERROR:
             return "ERROR";
-        case I2C_STATUS_INVALID_PARAM:
+        case I2C_RESULT_INVALID_PARAM:
             return "INVALID_PARAM";
         default:
             return "UNKNOWN";
     }
 }
+#endif

Src/main.c

@@ -41,8 +41,6 @@ OF SUCH DAMAGE.
 #include "i2c.h"
 #include "board_config.h"
 
-bool g_status_switch = false;
-
 /*!
     \brief      main function
     \param[in]  none
@@ -59,7 +57,7 @@ int main(void)
     led_init();
 
 #ifdef DEBUG_VERBOSE
-    char hello_world[] = {"Hello World!"};
+    char hello_world[] = {"Hello World!\r\n"};
 
     for (uint8_t i = 0; i < sizeof(hello_world); i++)
     {
@@ -68,21 +66,21 @@ int main(void)
     }
     
     while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
-#endif
 
     
+#endif
 
     i2c_config();
 
-    // i2c_bus_reset();
-
 #ifdef DEBUG_VERBOSE
     i2c_scan();
+
+    i2c_bus_reset();
 #endif
-    
+
 
     while(1){
         command_process();
-        delay_ms(100);
+        delay_ms(10);
     }
 }

Src/soft_i2c.c

@@ -59,13 +59,13 @@ void soft_i2c_start(void) {
     \retval     none
 */
 void soft_i2c_stop(void) {
-    // sda_out();
-    I2C_SCL_LOW();
-    I2C_SDA_LOW();
+    I2C_SCL_LOW();   // 确保时钟为低
+    I2C_SDA_LOW();   // 拉低数据线
     soft_i2c_delay();
-    I2C_SCL_HIGH();
+    I2C_SCL_HIGH();  // 拉高时钟
     soft_i2c_delay();
-    I2C_SDA_HIGH();
+    I2C_SDA_HIGH();  // 在时钟高电平时拉高数据线产生停止条件
+    soft_i2c_delay(); // 添加缺失的延时
 }
 
 /*!
@@ -108,12 +108,13 @@ void soft_i2c_send_nack(void) {
     \retval     0: ACK received, 1: ACK not received
 */
 uint8_t soft_i2c_wait_ack(void) {
-    I2C_SDA_HIGH();
+    I2C_SDA_HIGH();  // 释放SDA线，让从设备控制
     soft_i2c_delay();
-    I2C_SCL_HIGH();
+    I2C_SCL_HIGH();  // 拉高时钟
     soft_i2c_delay();
-    uint8_t ack = !I2C_SDA_READ();
-    I2C_SCL_LOW();
+    uint8_t ack = !I2C_SDA_READ();  // 读取ACK信号（低电平为ACK）
+    I2C_SCL_LOW();   // 拉低时钟
+    soft_i2c_delay(); // 添加缺失的延时
     return ack;
 }
 
@@ -168,8 +169,13 @@ uint8_t soft_i2c_receive_byte(uint8_t ack) {
 }
 
 uint8_t soft_i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[2]) {
+    /* 参数验证 */
+    if (data == NULL || slave_addr > 0x7F) {
+        return SOFT_I2C_FAIL;
+    }
+
     soft_i2c_start();
-    soft_i2c_send_byte(slave_addr);
+    soft_i2c_send_byte(slave_addr << 1);  // 修复：左移1位，添加写位
     if (!soft_i2c_wait_ack()) {
         soft_i2c_stop();
         return SOFT_I2C_FAIL;
@@ -185,15 +191,24 @@ uint8_t soft_i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data
         return SOFT_I2C_FAIL;
     }
     soft_i2c_send_byte(data[1]);
-    if (soft_i2c_wait_ack()){}
+    if (!soft_i2c_wait_ack()) {  // 修复：添加错误处理
+        soft_i2c_stop();
+        return SOFT_I2C_FAIL;
+    }
     soft_i2c_stop();
     return SOFT_I2C_OK;
 }
 
 uint8_t soft_i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data)
 {
+    /* 参数验证 */
+    if (data == NULL || slave_addr > 0x7F) {
+        return SOFT_I2C_FAIL;
+    }
+
+    /* 写阶段：发送寄存器地址 */
     soft_i2c_start();
-    soft_i2c_send_byte(slave_addr);
+    soft_i2c_send_byte(slave_addr << 1);  // 修复：左移1位，写操作
     if (!soft_i2c_wait_ack()) {
         soft_i2c_stop();
         return SOFT_I2C_FAIL;
@@ -203,15 +218,17 @@ uint8_t soft_i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
         soft_i2c_stop();
         return SOFT_I2C_FAIL;
     }
-    soft_i2c_start();
-    soft_i2c_send_byte(slave_addr | 0x01);
+
+    /* 读阶段：重新开始并读取数据 */
+    soft_i2c_start();  // 重新开始
+    soft_i2c_send_byte((slave_addr << 1) | 0x01);  // 修复：正确的读地址
     if (!soft_i2c_wait_ack()) {
         soft_i2c_stop();
         return SOFT_I2C_FAIL;
     }
     soft_i2c_delay();
-    data[0] = soft_i2c_receive_byte(1);
-    data[1] = soft_i2c_receive_byte(0);
+    data[0] = soft_i2c_receive_byte(1);  // 第一个字节发送ACK
+    data[1] = soft_i2c_receive_byte(0);  // 最后一个字节发送NACK
     soft_i2c_stop();
     return SOFT_I2C_OK;
 }

cmake/project_config.cmake

@@ -7,8 +7,8 @@ set(VERSION "V${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
 string(TIMESTAMP BUILD_DATE "%Y-%m-%d")
 
 # 编译条件（如IIC类型等）
-set(IIC_TYPE "AutoDetectDriveCurrent")
-# set(IIC_TYPE "HW-IIC")
+# set(IIC_TYPE "AutoDetectDriveCurrent")
+set(IIC_TYPE "HW-IIC")
 
 # 其它自定义宏
 add_definitions(-DIIC_TYPE=${IIC_TYPE})