release:(1.0.2) 版本号提升至 V1.0.2

- openocd_daplink_gd32e23x.cfg：去掉 connect_assert_srst（该选项导致 DAPLink 下 Cortex-M23 识别失败）

.gitignore

@@ -4,3 +4,4 @@ Build/
 # 忽略 Toolchain 目录下所有内容，但保留目录本身
 Toolchain/*
 !Toolchain/.gitkeep
+.vscode/settings.json

.vscode/erase.jlink

@@ -0,0 +1,2 @@
+erase
+exit

.vscode/extensions.json

@@ -1,26 +1,8 @@
 {
-  "recommendations": [
+    "recommendations": [
-    "ms-vscode.cmake-tools",
+        "marus25.cortex-debug",
-    "ms-vscode.cpptools",
+        "ms-vscode.cmake-tools",
-    "ms-vscode.cpptools-extension-pack",
+        "twxs.cmake",
-    "ms-vscode.cpptools-themes",
+        "ms-vscode.cpptools"
-    "ms-vscode.vscode-embedded-tools",
+    ]
-    "ms-vscode.hexeditor",
+}
-    "ms-vscode.notepadplusplus-keybindings",
-    "twxs.cmake",
-    "xaver.clang-format",
-    "marus25.cortex-debug",
-    "cheshirekow.cmake-format",
-    "mcu-debug.debug-tracker-vscode",
-    "mcu-debug.memory-view",
-    "mcu-debug.peripheral-viewer",
-    "mcu-debug.rtos-views",
-    "trond-snekvik.gnu-mapfiles",
-    "zixuanwang.linkerscript",
-    "gurumukhi.selected-lines-count",
-    "gruntfuggly.todo-tree",
-    "vscode-icons-team.vscode-icons",
-    "jeff-hykin.better-cpp-syntax",
-    "dan-c-underwood.arm"
-  ]
-}

.vscode/flash.jlink

@@ -0,0 +1,4 @@
+loadfile Application.hex
+r
+go
+exit

.vscode/launch.json

@@ -9,20 +9,19 @@
             "type": "cortex-debug",
             "runToEntryPoint": "main",
             "showDevDebugOutput": "none",
-            "gdbPath": "${workspaceFolder}/Toolchain/xpack-arm-none-eabi-gcc-11.3.1-1.1/bin/arm-none-eabi-gdb.exe",
+            "gdbPath": "${env:GD32_GCC_BIN}/arm-none-eabi-gdb.exe",
             "servertype": "openocd",
-            "serverpath": "${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/bin/openocd.exe",
+            "serverpath": "${env:GD32_OPENOCD_BIN}/openocd.exe",
             "svdFile": "${workspaceFolder}/GD32E230.svd",
-            "liveWatch": {
-                "enabled": true,
-                "samplesPerSecond": 1
-            },
             "configFiles": [
-                "${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/scripts/target/openocd_gdlink_gd32e23x.cfg"
+                "${env:GD32_OPENOCD_SCRIPTS}/${config:gd32.openocd.targetConfig}"
             ],
             "serverArgs": [
-                "-s", "${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/scripts"
+                "-s", "${env:GD32_OPENOCD_SCRIPTS}"
             ],
+            "env": {
+                "OPENOCD_SCRIPTS": "${env:GD32_OPENOCD_SCRIPTS}"
+            },
             "searchDir": [
                 "${workspaceFolder}"
             ],
@@ -30,7 +29,30 @@
             "preRestartCommands": [
                 "load",
                 "continue"
-            ],
+            ]
         },
+        {
+            "cwd": "${workspaceFolder}",
+            "executable": "${workspaceFolder}/Build/Debug/Application/Application.elf",
+            "name": "Debug with J-Link",
+            "request": "launch",
+            "type": "cortex-debug",
+            "runToEntryPoint": "main",
+            "showDevDebugOutput": "none",
+            "gdbPath": "${env:GD32_GCC_BIN}/arm-none-eabi-gdb.exe",
+            "servertype": "jlink",
+            "device": "${config:gd32.jlink.device}",
+            "interface": "${config:gd32.jlink.interface}",
+            "svdFile": "${workspaceFolder}/GD32E230.svd",
+            "liveWatch": {
+                "enabled": true,
+                "samplesPerSecond": 1
+            },
+            "preLaunchTask": "Build",
+            "preRestartCommands": [
+                "load",
+                "continue"
+            ]
+        }
     ]
-}
+}

.vscode/openocd_daplink_gd32e23x.cfg

@@ -0,0 +1,23 @@
+# DAPLink-friendly GD32E23x flash/debug config
+# Difference vs target/openocd_gdlink_gd32e23x.cfg:
+#   - no connect_assert_srst (breaks target examination with the current DAPLink)
+adapter driver cmsis-dap
+transport select swd
+
+source [find target/swj-dp.tcl]
+source [find mem_helper.tcl]
+
+set _CHIPNAME gd32e23x
+swj_newdap $_CHIPNAME cpu -irlen 4 -ircapture 0x1 -irmask 0xf -expected-id 0x0BF11477
+dap create $_CHIPNAME.dap -chain-position $_CHIPNAME.cpu
+
+set _TARGETNAME $_CHIPNAME.cpu
+target create $_TARGETNAME cortex_m -dap $_CHIPNAME.dap
+$_TARGETNAME configure -work-area-phys 0x20000000 -work-area-size 0x1000 -work-area-backup 0
+
+flash bank $_CHIPNAME.flash gd32e23x 0x08000000 0 0 0 $_TARGETNAME
+
+adapter speed 1000
+reset_config srst_only srst_nogate
+
+cortex_m reset_config sysresetreq

.vscode/reset.jlink

@@ -0,0 +1,2 @@
+r
+exit

.vscode/settings.json

@@ -1,30 +1,15 @@
 {
-    "terminal.integrated.tabs.enabled": true,
-    "terminal.integrated.profiles.windows": {
-        "Git Bash": {
-            "path": "C:\\Program Files\\Git\\bin\\bash.exe",
-            "icon": "terminal-bash"
-        },
-        "Git-Bash": {
-            "path": "D:\\Git\\bin\\bash.exe",
-            "icon": "terminal-bash"
-        }
-    },
-    "terminal.integrated.defaultProfile.windows": "Git-Bash",
-    "clang-format.assumeFilename": ".clang-format",
-    "clang-format.executable": "clang-format",
-    "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
     "cmake.configureOnOpen": true,
-    "cmake.buildDirectory": "${workspaceFolder}/Build",
+    "cmake.useCMakePresets": "always",
-    "vcpkg.storageLocation": "C:\\Dev\\Tools\\vcpkg",
+    "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
+    "cortex-debug.variableUseNaturalFormat": true,
+    "gd32.openocd.targetConfig": "target/openocd_gdlink_gd32e23x.cfg",
+    "gd32.openocd.massEraseCommand": "gd32e23x mass_erase 0",
+    "gd32.jlink.device": "GD32E230F8",
+    "gd32.jlink.interface": "SWD",
+    "gd32.jlink.speed": "4000",
     "files.associations": {
         "*.h": "c",
-        "*.c": "c",
+        "*.c": "c"
-        "array": "c",
+    }
-        "string": "c",
+}
-        "string_view": "c",
-        "ranges": "c",
-        "span": "c"
-    },
-    "cortex-debug.variableUseNaturalFormat": true,
-}

.vscode/tasks.json

@@ -1,116 +1,6 @@
 {
     "version": "2.0.0",
     "tasks": [
-        {
-            "label": "Build and Flash",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "dependsOn": [
-                "Build",
-                "Flash MCU"
-            ],
-            "dependsOrder": "sequence",
-            "icon": {
-                "id": "insert",
-                "tooltip": "Build and Flash"
-            }
-        },
-        {
-            "label": "Flash MCU",
-            "type": "shell",
-            "command": "'${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/bin/openocd.exe' -s '${workspaceFolder}' -f '${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/scripts/target/openocd_gdlink_gd32e23x.cfg' -c 'init; reset halt; flash write_image erase ${command:cmake.launchTargetFilename}; reset; exit'",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "problemMatcher": [],
-            "options": {
-                "cwd": "${command:cmake.buildDirectory}/Application",
-                "environment": {
-                    "CLICOLOR_FORCE": "1",
-                    "OPENOCD_SCRIPTS": ""
-                }
-            },
-            "presentation": {
-                "clear": true
-            },
-            "icon": {
-                "id": "gather",
-                "tooltip": "Flash MCU"
-            }
-        },
-        {
-            "label": "Reset MCU",
-            "type": "shell",
-            "command": "'${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/bin/openocd.exe' -s '${workspaceFolder}' -f '${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/scripts/target/openocd_gdlink_gd32e23x.cfg' -c 'init; reset; exit'",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "problemMatcher": [],
-            "options": {
-                "cwd": "${command:cmake.buildDirectory}/Application",
-                "environment": {
-                    "CLICOLOR_FORCE": "1",
-                    "OPENOCD_SCRIPTS": ""
-                }
-            },
-            "presentation": {
-                "clear": true
-            },
-            "icon": {
-                "id": "discard",
-                "tooltip": "Reset MCU"
-            }
-        },
-        {
-            "label": "Mass Erase MCU",
-            "type": "shell",
-            "command": "'${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/bin/openocd.exe' -s '${workspaceFolder}' -f '${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/scripts/target/openocd_gdlink_gd32e23x.cfg' -c 'init; reset halt; gd32e23x mass_erase 0; exit'",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "problemMatcher": [],
-            "options": {
-                "cwd": "${command:cmake.buildDirectory}/Application",
-                "environment": {
-                    "CLICOLOR_FORCE": "1",
-                    "OPENOCD_SCRIPTS": ""
-                }
-            },
-            "presentation": {
-                "clear": true
-            },
-            "icon": {
-                "id": "clear-all",
-                "tooltip": "Erase MCU"
-            }
-        },
-        {
-            "label": "OpenOCD Server",
-            "type": "shell",
-            "command": [
-                "'${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/bin/openocd.exe' -s '${workspaceFolder}' -f '${workspaceFolder}/Toolchain/xpack-openocd-0.11.0-3/scripts/target/openocd_gdlink_gd32e23x.cfg'"
-            ],
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "problemMatcher": [],
-            "options": {
-                "cwd": "${command:cmake.buildDirectory}/Application",
-                "environment": {
-                    "CLICOLOR_FORCE": "1",
-                    "OPENOCD_SCRIPTS": ""
-                }
-            },
-            "presentation": {
-                "clear": true
-            }
-        },
         {
             "label": "Build",
             "type": "cmake",
@@ -130,7 +20,8 @@
             ],
             "options": {
                 "environment": {
-                    "CLICOLOR_FORCE": "1"
+                    "CLICOLOR_FORCE": "1",
+                    "OPENOCD_SCRIPTS": "${env:GD32_OPENOCD_SCRIPTS}"
                 }
             },
             "presentation": {
@@ -140,6 +31,224 @@
                 "id": "code",
                 "tooltip": "Build"
             }
+        },
+        {
+            "label": "Build and Flash",
+            "dependsOn": [
+                "Build",
+                "Flash MCU"
+            ],
+            "dependsOrder": "sequence",
+            "group": "build",
+            "icon": {
+                "id": "insert",
+                "tooltip": "Build and Flash"
+            }
+        },
+        {
+            "label": "Flash MCU",
+            "type": "process",
+            "command": "${env:GD32_OPENOCD_BIN}/openocd.exe",
+            "args": [
+                "-s", "${env:GD32_OPENOCD_SCRIPTS}",
+                "-f", "${env:GD32_OPENOCD_SCRIPTS}/${config:gd32.openocd.targetConfig}",
+                "-c", "init; reset halt; flash write_image erase ${command:cmake.launchTargetFilename}; reset; exit"
+            ],
+            "group": "build",
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${command:cmake.buildDirectory}/Application",
+                "environment": {
+                    "OPENOCD_SCRIPTS": "${env:GD32_OPENOCD_SCRIPTS}"
+                }
+            },
+            "presentation": {
+                "clear": true
+            },
+            "icon": {
+                "id": "gather",
+                "tooltip": "Flash MCU"
+            }
+        },
+        {
+            "label": "Flash MCU (DAPLink)",
+            "type": "process",
+            "command": "${env:GD32_OPENOCD_BIN}/openocd.exe",
+            "args": [
+                "-s", "${env:GD32_OPENOCD_SCRIPTS}",
+                "-f", "${workspaceFolder}/.vscode/openocd_daplink_gd32e23x.cfg",
+                "-c", "program Application.elf verify reset exit"
+            ],
+            "group": "build",
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${command:cmake.buildDirectory}/Application",
+                "environment": {
+                    "OPENOCD_SCRIPTS": "${env:GD32_OPENOCD_SCRIPTS}"
+                }
+            },
+            "presentation": {
+                "clear": true
+            },
+            "icon": {
+                "id": "zap",
+                "tooltip": "Flash MCU via DAPLink (no connect_assert_srst)"
+            }
+        },
+        {
+            "label": "Reset MCU",
+            "type": "process",
+            "command": "${env:GD32_OPENOCD_BIN}/openocd.exe",
+            "args": [
+                "-s", "${env:GD32_OPENOCD_SCRIPTS}",
+                "-f", "${env:GD32_OPENOCD_SCRIPTS}/${config:gd32.openocd.targetConfig}",
+                "-c", "init; reset; exit"
+            ],
+            "group": "build",
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${command:cmake.buildDirectory}/Application",
+                "environment": {
+                    "OPENOCD_SCRIPTS": "${env:GD32_OPENOCD_SCRIPTS}"
+                }
+            },
+            "presentation": {
+                "clear": true
+            },
+            "icon": {
+                "id": "discard",
+                "tooltip": "Reset MCU"
+            }
+        },
+        {
+            "label": "Mass Erase MCU",
+            "type": "process",
+            "command": "${env:GD32_OPENOCD_BIN}/openocd.exe",
+            "args": [
+                "-s", "${env:GD32_OPENOCD_SCRIPTS}",
+                "-f", "${env:GD32_OPENOCD_SCRIPTS}/${config:gd32.openocd.targetConfig}",
+                "-c", "init; reset halt; ${config:gd32.openocd.massEraseCommand}; exit"
+            ],
+            "group": "build",
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${command:cmake.buildDirectory}/Application",
+                "environment": {
+                    "OPENOCD_SCRIPTS": "${env:GD32_OPENOCD_SCRIPTS}"
+                }
+            },
+            "presentation": {
+                "clear": true
+            },
+            "icon": {
+                "id": "clear-all",
+                "tooltip": "Erase MCU"
+            }
+        },
+        {
+            "label": "OpenOCD Server",
+            "type": "process",
+            "command": "${env:GD32_OPENOCD_BIN}/openocd.exe",
+            "args": [
+                "-s", "${env:GD32_OPENOCD_SCRIPTS}",
+                "-f", "${env:GD32_OPENOCD_SCRIPTS}/${config:gd32.openocd.targetConfig}"
+            ],
+            "group": "build",
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${command:cmake.buildDirectory}/Application",
+                "environment": {
+                    "OPENOCD_SCRIPTS": "${env:GD32_OPENOCD_SCRIPTS}"
+                }
+            },
+            "presentation": {
+                "clear": true
+            }
+        },
+        {
+            "label": "Build and Flash (Jlink)",
+            "dependsOn": [
+                "Build",
+                "Flash MCU (Jlink)"
+            ],
+            "dependsOrder": "sequence",
+            "group": "build",
+            "icon": {
+                "id": "insert",
+                "tooltip": "Build and Flash (Jlink)"
+            }
+        },
+        {
+            "label": "Flash MCU (Jlink)",
+            "type": "process",
+            "command": "JLink.exe",
+            "args": [
+                "-device", "${config:gd32.jlink.device}",
+                "-if", "${config:gd32.jlink.interface}",
+                "-speed", "${config:gd32.jlink.speed}",
+                "-autoconnect", "1",
+                "-CommanderScript", "${workspaceFolder}/.vscode/flash.jlink"
+            ],
+            "group": "build",
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${command:cmake.buildDirectory}/Application"
+            },
+            "presentation": {
+                "clear": true
+            },
+            "icon": {
+                "id": "gather",
+                "tooltip": "Flash MCU (Jlink)"
+            }
+        },
+        {
+            "label": "Reset MCU (Jlink)",
+            "type": "process",
+            "command": "JLink.exe",
+            "args": [
+                "-device", "${config:gd32.jlink.device}",
+                "-if", "${config:gd32.jlink.interface}",
+                "-speed", "${config:gd32.jlink.speed}",
+                "-autoconnect", "1",
+                "-CommanderScript", "${workspaceFolder}/.vscode/reset.jlink"
+            ],
+            "group": "build",
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "presentation": {
+                "clear": true
+            },
+            "icon": {
+                "id": "discard",
+                "tooltip": "Reset MCU (Jlink)"
+            }
+        },
+        {
+            "label": "Mass Erase MCU (Jlink)",
+            "type": "process",
+            "command": "JLink.exe",
+            "args": [
+                "-device", "${config:gd32.jlink.device}",
+                "-if", "${config:gd32.jlink.interface}",
+                "-speed", "${config:gd32.jlink.speed}",
+                "-autoconnect", "1",
+                "-CommanderScript", "${workspaceFolder}/.vscode/erase.jlink"
+            ],
+            "group": "build",
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "presentation": {
+                "clear": true
+            },
+            "icon": {
+                "id": "clear-all",
+                "tooltip": "Erase MCU (Jlink)"
+            }
         }
     ]
-}
+}

AGENTS.md

@@ -0,0 +1,75 @@
+# AGENTS.md — ldc1612_cmake_vscode 项目约定与进度
+
+## 项目概述
+
+GD32E230 电涡流传感器节点固件：LDC1612（电涡流/电感数字转换器）+ TMP112（板载温度），
+通过 RS485 串口命令协议（`D5 03 LEN [cmd] CRC`）与上位机通信，支持温度补偿与标定。
+
+- 协议文档：`CommunicationProtocol.md`；寄存器速查：`LDC1612_REG_LIST.md`
+- 版本策略：`Inc/version.h`（BOARD_TYPE_CODE.主.次.修订，当前 23.1.0.1）
+
+## 工具链与构建
+
+- 语言/环境：C99，GD32E23x 标准库（`SDK/`）
+- 编译器：`arm-none-eabi-gcc`（D:\toolchain\xpack-arm-none-eabi-gcc-15.2.1-1.1）
+- 构建：CMake + Ninja，preset `Debug` / `Release`，输出 `Build/<preset>/Application/Application.elf`
+  - 命令行构建：`cmake --build Build\Debug`（需 arm-none-eabi-gcc/cmake/ninja 在 PATH）
+- 烧录/调试（.vscode/tasks.json、launch.json）：
+  - OpenOCD：`GD32_OPENOCD_BIN` 指向定制构建（含 gd32e23x flash 驱动，CMSIS-DAP HID 后端）
+  - `Flash MCU (DAPLink)` 任务 + `.vscode/openocd_daplink_gd32e23x.cfg`：
+    适配 DAPLink 探针（无 connect_assert_srst，当前共享 cfg 的 connect_assert_srst
+    会导致 Cortex-M23 识别失败）；烧录命令 `program Application.elf verify reset exit`
+  - J-Link 任务需 SEGGER 探针 + PATH 中 JLink.exe（当前接的是 DAPLink，不适用）
+- 调试器探针历史问题（2026-10-02 已解决）：DAPLink 的 CMSIS-DAP v1 接口曾被 Zadig
+  装上 libwdi WinUSB 驱动（oem244.inf），导致 OpenOCD 枚举不到探针；删除该驱动包后
+  恢复 HID。若复发：管理员运行 `pnputil /delete-driver <oemNN.inf> /uninstall`。
+- 串口验证：RS485 转 USB（FTDI，COM15），115200-8N1，**需同时置位 RTS+DTR**
+  （转换器方向控制），否则命令发不出去；DAPLink 虚拟串口为 COM8。
+
+## 硬件/板级约定（Inc/board_config.h）
+
+- MCU：GD32E230（自动探测 Flash 容量，64KB → USART1 作 RS485）
+- RS485：SP3487（无自动方向），USART1 PA2(TX)/PA3(RX)，DE=PA1（USART 硬件 DE，AF1）
+- I2C0：PF0(SDA)/PF1(SCL)，硬件 IIC 100kHz（`SOFTWARE_IIC` 可切换软模拟，默认关闭）
+- LED：PB1
+- 传感器：LDC1612 @0x2B（40MHz 外部时钟），TMP112 @0x49（ADD0=GND）
+- 调试宏（均默认关闭）：DEBUG_VERBOSE / COM_DEBUG / LDC_DEBUG / EDDY_DRIVE_CURRENT_DETECTION
+
+## 内存布局（当前调试阶段，2026-10-02 用户确认）
+
+- **APP 直接链接在 0x08000000，VECT_TAB_OFFSET=0x00（Src/system_gd32e23x.c），
+  不考虑 Bootloader**；正式发布时再切回 Bootloader 布局（0x08002000/54K + OTA 打包，
+  参见 hulk-mcu-firmware skill）
+- 修改布局需同时改 `LD/gd32e23x_flash.ld` 的 ORIGIN 与 VECT_TAB_OFFSET
+
+## 开发进度
+
+### 已完成
+
+- [x] LDC1612 驱动（初始化/单通道配置/原始值读取/状态检查）
+- [x] TMP112 驱动（初始化/温度读取/阈值/单次转换）
+- [x] RS485 命令体系：M1/M2（周期上报开关）、M3（涡流原始值）、M4（温度×10000）、
+      M5（温度补偿涡流值）、M6（标定数据：涡流+温度）、M999（版本）、M9999（复位）
+- [x] v1.0.1：涡流传感器温度标定方法与标定命令（M6）
+- [x] 2026-10-02：从模板 gd32e23x_template_cmake_vscode 导入 IIC 驱动改进：
+      错误路径改为 i2c_bus_reset() 总线恢复+重试、_i2c_wait_flag_timeout 系列带超时
+      辅助函数、i2c_scan 增加 AERR 处理、新增 i2c_read_raw（无子地址读取）、
+      i2c_write/i2c_read 改为 16 位寄存器地址（DLPC 风格，本项目传感器仍走
+      i2c_write_16bits/i2c_read_16bits 8 位寄存器路径）；移除未使用的
+      i2c_read/write_8bits、_32bits、i2c_read_display_params 显示面板便捷函数；
+      tmp112.c 读取改回 i2c_read_16bits
+- [x] 2026-10-02：硬件验证通过——全部命令实测：M3 涡流原始值 ~0x01ADBADC
+      （室温）/0x01B094BA（板子被手捂热后，随温度同步上移，无错误位）、
+      M4 温度 27.25→30.45→29.95°C（跟踪板温变化合理）、M5 补偿值（系数为 0 时≈M3）、
+      M1 周期上报（~10ms/帧）开启、M2 停止（"ok" 确认）、M6 组合数据、
+      M999 版本 v23.1.0.1、M9999 复位（复位后 M999 恢复应答）；
+      所有响应 CRC 抽查校验正确；Release 预设编译通过（text 11.4KB）
+- [x] 2026-10-02：解决 DAPLink 烧录器识别问题（Zadig WinUSB 驱动冲突）；
+      新增 DAPLink 专用烧录 cfg 与任务
+
+### 计划 / TODO
+
+- [ ] 正式发布前切回 Bootloader 布局（0x08002000/54K）并适配 OTA/Ymodem 打包流程
+- [ ] M5 温度补偿系数目前为 0（TEMP_COMP_COEFF_*），待标定后填入实际温漂系数
+- [ ] 模板侧（gd32e23x_template_cmake_vscode）的 SEGGER RTT / CFG_ENABLE 宏体系
+      尚未同步到本项目（board_config.h 仍是 define/undef 风格），如需对齐另起任务

CMakeLists.txt

@@ -6,6 +6,10 @@ include(${CMAKE_SOURCE_DIR}/cmake/project.cmake)
 
 project(${PROJECT_NAME} LANGUAGES C CXX ASM)
 
+# Generate version header from CMake version variables
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/generated)
+configure_file(${CMAKE_SOURCE_DIR}/cmake/version.h.in ${CMAKE_BINARY_DIR}/generated/version.h @ONLY)
+
 # 添加SDK库
 add_subdirectory(SDK/CMSIS)
 add_subdirectory(SDK/GD32E23x_standard_peripheral)
@@ -32,6 +36,7 @@ set(TARGET_SRC
     Src/i2c.c
     Src/ldc1612.c
     Src/tmp112.c
+    Src/board_config.c
 )
 
 # 设置输出目录
@@ -46,6 +51,7 @@ project_add_target_properties(${PROJECT_NAME})
 # 头文件路径
 target_include_directories(${PROJECT_NAME} PRIVATE
     ${CMAKE_SOURCE_DIR}/Inc
+    ${CMAKE_BINARY_DIR}/generated
 
     # Add new include directories here, e.g. ${CMAKE_SOURCE_DIR}/Application/User/Inc
     
@@ -67,12 +73,13 @@ target_link_libraries(${PROJECT_NAME} PRIVATE CMSIS)
 target_link_libraries(${PROJECT_NAME} PRIVATE GD32E23x_standard_peripheral)
 
 # 生成 bin/hex/list 文件名格式：[工程名_版本号_编译条件_编译日期]
-set(OUTPUT_PREFIX "${PROJECT_NAME}_${VERSION}_${IIC_TYPE}_${BUILD_DATE}")
+set(OUTPUT_PREFIX "${PROJECT_NAME}_${VERSION}_${BUILD_VARIANT}_${BUILD_DATE}")
 
 add_custom_command(TARGET ${PROJECT_NAME}
     POST_BUILD
     COMMAND echo -- Running Post Build Commands
     COMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${PROJECT_NAME}> ${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_PREFIX}.hex
+        COMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${PROJECT_NAME}> $<TARGET_FILE_DIR:${PROJECT_NAME}>/Application.hex
     COMMAND ${CMAKE_OBJCOPY} -O binary $<TARGET_FILE:${PROJECT_NAME}> ${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_PREFIX}.bin
     COMMAND ${CMAKE_SIZE} $<TARGET_FILE:${PROJECT_NAME}>
     COMMAND ${CMAKE_OBJDUMP} -h -S $<TARGET_FILE:${PROJECT_NAME}> > ${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_PREFIX}.list

CommunicationProtocol.md

@@ -0,0 +1,85 @@
+# 电涡流传感器模块通信协议
+
+## 电涡流传感器模块通信协议
+
+| **序号** | **修改内容** | **版本** | **日期**     | **修改人** |
+|:------:|:--------:|:------:|:----------:|:-------:|
+| 1      | 初版       | V1.0   | 2024-12-25 | Hulk    |
+| 2      |  修改指令含义  |    V1.1    |    20250822        |     Hulk    |
+|        |          |        |            |         |
+|        |          |        |            |         |
+
+### 发包格式
+
+| **包头** | **类型** | **数据长度**    | **数据** | **校验** |
+|:------:|:------:|:-----------:|:------:|:------:|
+| D5     | 0x03   | Data Length |  Data  | CRC    |
+
+- 数据长度只包含数据部分，不包含包头、类型、数据长度、校验
+- CRC求和校验，包含类型、数据长度、数据
+- 数据部分为ascii码
+
+### 回包格式
+
+| **包头** |  **状态码**   | **数据长度**    | **数据** | **校验** |
+|:------:|:----------:|:-----------:|:------:|:------:|
+|   B5   |  0xF0 正常包  | Data Length |  Data  | CRC    |
+|   B5   | 0xF1 CRC错误 | Data Length |  Data  | CRC    |
+|   B5   | 0xF2 包头错误  | Data Length |  Data  | CRC    |
+|   B5   | 0xF3 类型错误  | Data Length |  Data  | CRC    |
+|   B5   | 0xF4 包长度错误 | Data Length |  Data  | CRC    |
+
+- 数据长度仅包含数据部分，不包含包头状态码等
+- CRC求和校验，包含状态码数据长度和数据部分
+
+-------------------
+
+## 电涡流传感器模块功能
+
+### 1. 开启自动读取并发送电涡流传感器模块数据
+
+- M1指令 开启自动读取并发送涡流传感器数据，间隔10ms左右
+    - `D5 03 02 4D 31 83`
+- 电涡流传感器模块涡流回复数据
+    - `B5 F0 04 01 AE 1B E4 A2`, 有效数据为 `0x01AE1BE4`，转换为`28187620`
+    - `B5 F0 04 04 19 C1 FA CC`, 有效数据为 `0x0419C1FAD2`，转换为`17612012242`
+
+
+### 2. 关闭自动读取并发送电涡流传感器模块数据
+
+- M2 指令 关闭自动读取并发送涡流传感器数据
+    - `D5 03 02 4D 32 84`
+    > 注：因为485总线为半双工，M1命令开启后持续自动发送数据，M2指令发送停止命令可能无法一次成功，可持续发送几次
+
+### 3. 单次读取并发送电涡流传感器数据
+
+- M3 指令 单次读取并发送涡流传感器数据
+    - `D5 03 02 4D 33 85`
+
+### 4. 单次读取并发送板载温度传感器数据
+
+- M4 指令 单次读取并发送板载温度传感器数据（TMP112，返回温度值×10000，4 字节有符号大端）
+    - `D5 03 02 4D 34 86`
+    - 示例回复：`B5 F0 04 00 04 28 74 94`，有效数据 `0x00042874` = 272500，即 `27.25°C`
+
+### 5. 单次读取并发送温度补偿后的涡流传感器数据
+
+- M5 指令 单次读取并发送温度补偿后的涡流传感器数据（补偿系数默认为 0，与 M3 等价）
+    - `D5 03 02 4D 35 87`
+
+### 6. 单次读取并发送标定数据（涡流原始值 + 温度值）
+
+- M6 指令 单次读取涡流原始值和板载温度值，用于温度标定
+    - `D5 03 02 4D 36 88`
+    - 回复 9 字节：涡流原始值(4字节大端) + 0xFF + 温度值×10000(4字节大端)
+    - 示例回复：`B5 F0 09 01 AD BA DC FF 00 04 28 74 DC`
+
+### 7. 查询固件版本号
+
+- M999 指令 返回固件版本号字符串，如 `v23.1.0.1`（板卡类型.主版本.次版本.修订号）
+    - `D5 03 04 4D 39 39 39 FF`
+
+### 8. 复位 MCU
+
+- M9999 指令 立即复位 MCU（无回复）
+    - `D5 03 05 4D 39 39 39 39 39`

Inc/board_config.h

@@ -1,6 +1,12 @@
 #ifndef BOARD_CONFIG_H
 #define BOARD_CONFIG_H
 
+#include "version.h"
+
+#define GD32E23XF4          0x10
+#define GD32E23XF6          0x20
+#define GD32E23XF8          0x40
+
 /* >>>>>>>>>>>>>>>>>>>>[RS485 PHY DEFINE]<<<<<<<<<<<<<<<<<<<< */
 
 // #define RS485_MAX13487 // RS485 PHY : MAX13487 (AutoDir)
@@ -21,6 +27,33 @@
 // #define EDDY_DRIVE_CURRENT_DETECTION // Eddy Drive Current Detection : Enable
 #undef  EDDY_DRIVE_CURRENT_DETECTION // Eddy Drive Current Detection : Disable
 
+/* >>>>>>>>>>>>>>>>>>>>[COMMAND DEBUG]<<<<<<<<<<<<<<<<<<<< */
+
+// #define COM_DEBUG // Enable Command Debug Information
+#undef  COM_DEBUG // Disable Command Debug Information
+
+/* >>>>>>>>>>>>>>>>>>>>>[LDC1612 DEBUG]<<<<<<<<<<<<<<<<<<<< */
+
+// #define LDC_DEBUG // LDC1612 Driver Debug : Enable
+#undef  LDC_DEBUG // LDC1612 Driver Debug : 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
@@ -35,22 +68,25 @@
 
 /******************************************************************************/
 
-#define LED_PORT             GPIOA
+#define LED_RCU              RCU_GPIOB
-#define LED_PIN              GPIO_PIN_7
+#define LED_PORT             GPIOB
-#define LED_RCU              RCU_GPIOA
+#define LED_PIN              GPIO_PIN_1
 
 /******************************************************************************/
 
-#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

Inc/command.h

@@ -18,7 +18,6 @@
 
 /** @brief 传感器周期上报使能标志 */
 extern volatile bool g_eddy_current_sensor_report_enabled;
-extern volatile bool g_temperature_sensor_report_enabled;
 
 /**
  * @section Command_Protocol 协议格式
@@ -81,25 +80,6 @@ bool get_eddy_sensor_report_enabled(void);
  */
 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 处理串口环形缓冲区中的命令数据。
  * @details 基于状态机的非阻塞协议解析器，处理完整的命令帧并自动响应。
@@ -125,4 +105,8 @@ void eddy_current_report(void);
 
 void temperature_raw_value_report(void);
 
+void eddy_current_compensated_report(void);
+
+void calibration_data_report(void);
+
 #endif // COMMAND_H

Inc/i2c.h

@@ -89,9 +89,9 @@ i2c_result_t i2c_bus_reset(void);
 void i2c_scan(void);
 
 /*!
-    \brief      write 16-bit data to I2C device
+    \brief      write 16-bit data to I2C device (8-bit register address + 2 data bytes)
     \param[in]  slave_addr: 7-bit slave address
-    \param[in]  reg_addr: register address
+    \param[in]  reg_addr: register address (8-bit)
     \param[in]  data: pointer to 2-byte data array
     \param[out] none
     \retval     i2c_result_t
@@ -99,23 +99,47 @@ void i2c_scan(void);
 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
+    \brief      read 16-bit data from I2C device (8-bit register address + 2 data bytes)
     \param[in]  slave_addr: 7-bit slave address
-    \param[in]  reg_addr: register address
+    \param[in]  reg_addr: register address (8-bit)
     \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);
 
+/* Generic read/write functions with configurable length */
+/*!
+    \brief      write data to I2C device with configurable length
+    \param[in]  slave_addr: slave device address (7-bit)
+    \param[in]  reg_addr: register address (16-bit, high byte first)
+    \param[in]  data: pointer to data buffer
+    \param[in]  length: number of bytes to write (1-255)
+    \param[out] none
+    \retval     i2c_result_t: operation result
+*/
+i2c_result_t i2c_write(uint8_t slave_addr, uint16_t reg_addr, uint8_t *data, uint8_t length);
+
 /*!
-    \brief      read 16-bit data from I2C device
+    \brief      read data from I2C device with configurable length
-    \param[in]  slave_addr: 7-bit slave address
+    \param[in]  slave_addr: slave device address (7-bit)
-    \param[in]  reg_addr: register address
+    \param[in]  reg_addr: register address (16-bit, high byte first)
-    \param[out] data: pointer to 2-byte data buffer
+    \param[out] data: pointer to data buffer
-    \retval     i2c_result_t
+    \param[in]  length: number of bytes to read (1-255)
+    \retval     i2c_result_t: operation result
 */
-i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
+i2c_result_t i2c_read(uint8_t slave_addr, uint16_t reg_addr, uint8_t *data, uint8_t length);
 
+/* Pure read response without sub-address phase (for commands that already sent read request parameters) */
+/*!
+    \brief      read data from I2C device without register/sub-address phase
+    \param[in]  slave_addr: slave device address (7-bit)
+    \param[out] data: pointer to data buffer
+    \param[in]  length: number of bytes to read (1-255)
+    \retval     i2c_result_t: operation result
+*/
+i2c_result_t i2c_read_raw(uint8_t slave_addr, uint8_t *data, uint8_t length);
+
+#ifdef DEBUG_VERBOSE
 /*!
     \brief      get status string for debugging
     \param[in]  status: i2c_result_t value
@@ -123,5 +147,6 @@ i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
     \retval     const char* status string
 */
 const char* i2c_get_status_string(i2c_result_t status);
+#endif
 
 #endif //I2C_H

Inc/ldc1612.h

@@ -10,7 +10,6 @@
 #include "systick.h"
 #include <stdbool.h>
 #include <string.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include "board_config.h"
@@ -29,25 +28,32 @@
     #define LDC1612_IIC_TYPE_STR                         "Hardware IIC"
 #endif
 
+/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>[EXT CLK(MHz)]<<<<<<<<<<<<<<<<<<<< */
+
+#define LDC1612_EXT_CLK_MHZ  40
+
 /***************************************************************************/
 
 #define LDC1612_ADDR         (0x2B)
 
+/******************************************************************************/
+
+#define COIL_L_UH                40.9
+#define COIL_C_PF                180
+
 /************************Register Addr***************************************/
 
-#define CONVERTION_RESULT_REG_START             0X00
+#define CONVERSION_RESULT_REG_START             0X00
 #define SET_CONVERSION_TIME_REG_START           0X08
 #define SET_CONVERSION_OFFSET_REG_START         0X0C
 #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 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
 
@@ -56,131 +62,398 @@
 #define CHANNEL_0  0
 #define CHANNEL_1  1
 
-/*************************MUX_CONFIG********************************************
+/**************************DATA (0x00-0x03)*******************************************/
- * 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)
+ * 作用: 存储28位的传感器转换结果。结果分为高字节(MSB)和低字节(LSB)两个寄存器。
- * 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)
+ * 结构说明:
-*/
+ * - DATA_CHx_MSB: 包含错误标志和数据的高12位 [27:16]。
-#define LDC1612_MUX_CONFIG                 0x020C
+ * - DATA_CHx_LSB: 包含数据的低16位 [15:0]。
-
+ *
-/***********************SENSOR_CONFIG********************************************
+ * MSB寄存器位域:
- * 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
+ * [15] ERR_UR: 转换下溢错误标志 (1 = 发生错误)
- * 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
+ * [14] ERR_OR: 转换上溢错误标志 (1 = 发生错误)
- * 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
+ * [13] ERR_WD: 看门狗超时错误标志 (1 = 发生错误)
- * 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
+ * [12] ERR_AE: 振幅错误标志 (高或低) (1 = 发生错误)
-*/ 
+ * [11:0] DATA[27:16]: 数据的高12位
-
+ *
-#ifdef EDDY_DRIVE_CURRENT_DETECTION
+ * 注意:
-    #define LDC1612_SENSOR_CONFIG_CH0      0x1241
+ * - 仅当ERROR_CONFIG寄存器中对应的ERR2OUT位置1时，这些错误标志才会在MSB寄存器中被设置。
-#else
+ * - 读取数据时，应先读取LSB，再读取MSB，以确保数据的一致性。
-    #define LDC1612_SENSOR_CONFIG_CH0      0x1641
-#endif
-#define LDC1612_SLEEP_MODE                 0x2801
-
-/****************************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****************************************
- * 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***************************************/
-
-
-
-/**************************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
+/* --- 数据寄存器错误标志位掩码 --- */
+#define LDC1612_DATA_ERR_UR                 (1 << 15)
+#define LDC1612_DATA_ERR_OR                 (1 << 14)
+#define LDC1612_DATA_ERR_WD                 (1 << 13)
+#define LDC1612_DATA_ERR_AE                 (1 << 12)
+#define LDC1612_DATA_ERR_MASK               (0xF000)
+#define LDC1612_DATA_MSB_MASK               (0x0FFF)
 
-/**************************STATUS****************************************
+/**************************RCOUNT (0x08, 0x09)****************************************/
- * [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
+ * [15:0] RCOUNT: 参考计数值。
- * [10] Amplitude High Error 0b0: No / 0b1: Yes
+ *
- * [ 9] Amplitude Low Error 0b0: No / 0b1: Yes
+ * 计算公式:
- * [ 8] Zero Count Error 0b0: No / 0b1: Yes
+ * t_CONVERSION = (RCOUNT * 16) / f_REF
- * [ 7] RESERVED
+ *
- * [ 6] Ddata Ready Flag 0b0: No new results / 0b1: New results available
+ * 注意:
- * [ 5] RESERVED
+ * - RCOUNT值必须 ≥ 0x0004。
- * [ 4] RESERVED
+ * - 该寄存器在复位后值为 0x0080。
- * [ 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)
+ * - 需要高采样率: 使用较小的RCOUNT值。
- * [ 0] CH3 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH3)
+ * - 需要高分辨率: 使用较大的RCOUNT值。
- * 
- * 0x0000 No ERR to OUT or INTB
 */
 
-/*****************CONVERSION_OFFSET_CONFIG****************************************/
+/* --- 预设配置示例 --- */
+// 高速采样配置 (分辨率较低)
+#define LDC1612_RCOUNT_HIGH_SPEED           (0x04D6) // 1238, 约 1kSPS @ 40MHz/2
 
+// 平衡配置 (常用)
+#define LDC1612_RCOUNT_BALANCED             (0x1000) // 4096, 约 380SPS @ 40MHz/2
+
+// 高分辨率配置 (采样率较低)
+#define LDC1612_RCOUNT_HIGH_RESOLUTION      (0xFFFF) // 65535, 约 24SPS @ 40MHz/2
+
+// 默认配置
+#define LDC1612_RCOUNT_TIME_CH0     LDC1612_RCOUNT_BALANCED // 0x1000=4096个时钟周期
+
+/**************************OFFSET (0x0C, 0x0D)****************************************/
+/*
+ * 作用: 设置一个16位的数字偏移量，该值会从原始转换结果中减去。
+ *
+ * 位域说明:
+ * [15:0] OFFSET: 数据偏移值。
+ *
+ * 计算公式:
+ * 最终数据 = 原始转换数据 - OFFSET
+ *
+ * 注意:
+ * - 如果减法结果为负，将触发下溢错误 (ERR_UR)。
+ * - 该寄存器在复位后值为 0x0000。
+ *
+ * 应用场景:
+ * - 消除传感器或环境的固有基线偏移。
+ * - 实现“去皮”(Tare)功能，将当前读数设为新的零点。
+*/
+
+// 默认配置: 不设置偏移
 #define SET_CONVERSION_OFFSET_CH0          0x0000 
 
-/***********************RESET DEVICE********************************************
+/**************************SETTLECOUNT (0x10, 0x11)***********************************/
-0x8000 RESET_DEV: 1 / RESERVED: 000 0000 0000 0000
+/*
-*/ 
+ * 作用: 设置传感器振荡器在开始转换前所需的建立时间。
+ *
+ * 位域说明:
+ * [15:0] SETTLECOUNT: 建立时间计数值。
+ *
+ * 计算公式:
+ * t_SETTLE 的计算方式取决于SETTLECOUNT的值：
+ * - 当 SETTLECOUNT = 0x0000 或 0x0001 时, t_SETTLE = 32 / f_REF
+ * - 当 SETTLECOUNT ≥ 0x0002 时, t_SETTLE = (SETTLECOUNT * 16) / f_REF
+ *
+ * 配置建议:
+ * - 传感器的Q值越高，所需的建立时间越短 (SETTLECOUNT值可以越小)。
+ * - 值过小可能导致传感器未充分稳定，数据不准确。
+ * - 值过大则会不必要地增加总转换时间，降低采样率。
+ * - 对于大多数应用，0x0100 (256) 是一个很好的起始值。
+*/
 
-#define LDC1612_RESET_DEV                  0x8000 //[15:0] 0b1000 0000 0000 0000
+/* --- 预设配置示例 --- */
+// 适用于高Q值传感器 (建立时间短)
+#define LDC1612_SETTLECOUNT_HIGH_Q          (0x000A) // 约 4µs @ 40MHz/2
 
-/***********************IDs****************************************************/
+// 适用于中等Q值传感器 (通用)
+#define LDC1612_SETTLECOUNT_MEDIUM_Q        (0x0100) // 约 102µs @ 40MHz/2
+
+// 适用于低Q值传感器 (建立时间长)
+#define LDC1612_SETTLECOUNT_LOW_Q           (0x0400) // 约 410µs @ 40MHz/2
+
+// 默认配置
+#define LDC1612_SETTLECOUNT_CH0    LDC1612_SETTLECOUNT_MEDIUM_Q
+
+/**************************CLOCK_DIVIDER (0x14, 0x15)***********************************/
+/*
+ * 作用: 配置传感器输入频率(f_sensor)和参考时钟(f_ref)的分频器。
+ *
+ * 位域说明:
+ * [15:12] FIN_DIVIDER:  传感器输入分频器。
+ * [11:10] RESERVED:     必须为00。
+ * [9:0]   FREF_DIVIDER: 参考时钟分频器。
+ *
+ * 配置逻辑:
+ * 1. FIN_DIVIDER: 根据传感器的谐振频率 f_sensor 选择。
+ *    - 目标是使 f_sensor / FIN_DIVIDER <= 8.75MHz。
+ *    - 例如: 如果 f_sensor = 15MHz, 则 FIN_DIVIDER 必须 >= 2。
+ *
+ * 2. FREF_DIVIDER: 根据外部时钟 f_clk 和工作模式选择。
+ *    - 目标是使 f_ref = f_clk / FREF_DIVIDER。
+ *    - 单通道模式且 f_clk <= 35MHz: FREF_DIVIDER = 1。
+ *    - 双通道模式或 f_clk > 35MHz: FREF_DIVIDER = 2。
+ *
+ * 最终寄存器值 = (FIN_DIVIDER << 12) | FREF_DIVIDER;
+*/
+
+/* --- 位域选项宏 --- */
+// [15:12] Sensor Input Divider (FIN_DIVIDER)
+#define LDC1612_FIN_DIV_1                   (0x1 << 12) // for f_sensor <= 8.75MHz
+#define LDC1612_FIN_DIV_2                   (0x2 << 12) // for 8.75MHz < f_sensor <= 17.5MHz
+#define LDC1612_FIN_DIV_4                   (0x3 << 12) // for 17.5MHz < f_sensor <= 35MHz
+
+// [9:0] Reference Clock Divider (FREF_DIVIDER)
+#define LDC1612_FREF_DIV_1                  (0x001)
+#define LDC1612_FREF_DIV_2                  (0x002)
+
+/* --- 组合宏 --- */
+#define LDC1612_CLOCK_DIVIDER_GEN(fin_div, fref_div) ((fin_div) | (fref_div))
+
+/* --- 预设配置示例 (基于40MHz外部时钟) --- */
+// 适用于 f_sensor <= 8.75MHz
+#define LDC1612_CLOCK_DIVIDER_DEFAULT       LDC1612_CLOCK_DIVIDER_GEN(LDC1612_FIN_DIV_1, LDC1612_FREF_DIV_2) // 0x1002
+
+
+/**************************STATUS (0x18) MACROS****************************************
+ *
+ * 作用: 定义STATUS寄存器的位掩码，用于解析设备状态。
+ *
+*/
+#define LDC1612_STATUS_DRDY              (1 << 6)  // 数据就绪
+#define LDC1612_STATUS_UNREAD_CH0        (1 << 3)  // 通道0有未读数据
+#define LDC1612_STATUS_UNREAD_CH1        (1 << 2)  // 通道1有未读数据
+
+#define LDC1612_STATUS_ERR_ZC            (1 << 8)  // 零计数错误
+#define LDC1612_STATUS_ERR_ALE           (1 << 9)  // 振幅过低
+#define LDC1612_STATUS_ERR_AHE           (1 << 10) // 振幅过高
+#define LDC1612_STATUS_ERR_WD            (1 << 11) // 看门狗超时
+#define LDC1612_STATUS_ERR_OR            (1 << 12) // 转换上溢
+#define LDC1612_STATUS_ERR_UR            (1 << 13) // 转换下溢
+#define LDC1612_STATUS_ERR_CHAN_MASK     (3 << 14) // 错误通道掩码
+
+/**************************ERROR_CONFIG (0x19)****************************************/
+/*
+ * 作用: 配置状态或错误输出或者触发INTB引脚中断。
+ *
+ * 位域说明:
+ * [15] UR_ERR2OUT:         1 = 转换下溢错误输出到DATA_CHx寄存器
+ * [14] OR_ERR2OUT:         1 = 转换上溢错误输出到DATA_CHx寄存器
+ * [13] WD_ERR2OUT:         1 = 看门狗超时错误输出到DATA_CHx寄存器
+ * [12] AH_ERR2OUT:         1 = 振幅过高错误输出到DATA_CHx寄存器
+ * [11] AL_ERR2OUT:         1 = 振幅过低错误输出到DATA_CHx寄存器
+ * [10:8] RESERVED
+ * [7]  UR_ERR2INT:         1 = 转换下溢错误触发INTB
+ * [6]  OR_ERR2INT:         1 = 转换上溢错误触发INTB
+ * [5]  WD_ERR2INT:         1 = 看门狗超时错误触发INTB
+ * [4]  AH_ERR2INT:         1 = 振幅过高错误触发INTB
+ * [3]  AL_ERR2INT:         1 = 振幅过低错误触发INTB
+ * [2]  ZC_ERR2INT:         1 = 零计数错误触发INTB
+ * [1]  RESERVED
+ * [0]  DRDY_2INT:          1 = 数据就绪标志触发INTB
+*/
+
+/* --- 位域选项宏 --- */
+
+// --- 中断触发 (ERR2INT) ---
+#define LDC1612_ERR_CFG_DRDY_INT_EN         (1 << 0)  // 数据就绪中断使能
+#define LDC1612_ERR_CFG_ZC_INT_EN           (1 << 2)  // 零计数错误中断使能
+#define LDC1612_ERR_CFG_AL_INT_EN           (1 << 3)  // 振幅过低错误中断使能
+#define LDC1612_ERR_CFG_AH_INT_EN           (1 << 4)  // 振幅过高错误中断使能
+#define LDC1612_ERR_CFG_WD_INT_EN           (1 << 5)  // 看门狗超时中断使能
+#define LDC1612_ERR_CFG_OR_INT_EN           (1 << 6)  // 转换上溢中断使能
+#define LDC1612_ERR_CFG_UR_INT_EN           (1 << 7)  // 转换下溢中断使能
+
+// --- 错误报告至数据寄存器 (ERR2OUT) ---
+#define LDC1612_ERR_CFG_AL_OUT_EN           (1 << 11) // 振幅过低错误报告使能
+#define LDC1612_ERR_CFG_AH_OUT_EN           (1 << 12) // 振幅过高错误报告使能
+#define LDC1612_ERR_CFG_WD_OUT_EN           (1 << 13) // 看门狗超时错误报告使能
+#define LDC1612_ERR_CFG_OR_OUT_EN           (1 << 14) // 转换上溢错误报告使能
+#define LDC1612_ERR_CFG_UR_OUT_EN           (1 << 15) // 转换下溢错误报告使能
+
+// 常用配置: 仅使能 "数据就绪" 中断
+#define LDC1612_ERROR_CONFIG_DRDY_ONLY      (LDC1612_ERR_CFG_DRDY_INT_EN) // 结果: 0x0001
+
+// 常用配置: 使能所有错误报告
+#define LDC1612_ERROR_CONFIG_OUT_ONLY       (LDC1612_ERR_CFG_AL_OUT_EN   | \
+                                             LDC1612_ERR_CFG_AH_OUT_EN   | \
+                                             LDC1612_ERR_CFG_WD_OUT_EN   | \
+                                             LDC1612_ERR_CFG_OR_OUT_EN   | \
+                                             LDC1612_ERR_CFG_UR_OUT_EN) // 结果: 0xF800
+
+// 调试配置: 使能所有错误中断和错误报告
+#define LDC1612_ERROR_CONFIG_DEBUG_ALL      (LDC1612_ERR_CFG_DRDY_INT_EN | \
+                                             LDC1612_ERR_CFG_ZC_INT_EN   | \
+                                             LDC1612_ERR_CFG_AL_INT_EN   | \
+                                             LDC1612_ERR_CFG_AH_INT_EN   | \
+                                             LDC1612_ERR_CFG_WD_INT_EN   | \
+                                             LDC1612_ERR_CFG_OR_INT_EN   | \
+                                             LDC1612_ERR_CFG_UR_INT_EN   | \
+                                             LDC1612_ERR_CFG_AL_OUT_EN   | \
+                                             LDC1612_ERR_CFG_AH_OUT_EN   | \
+                                             LDC1612_ERR_CFG_WD_OUT_EN   | \
+                                             LDC1612_ERR_CFG_OR_OUT_EN   | \
+                                             LDC1612_ERR_CFG_UR_OUT_EN) // 结果: 0xF8FD
+
+// 默认配置: 所有功能都禁用
+#define LDC1612_ERROR_CONFIG_DEFAULT        (0x0000)
+
+/**************************SENSOR_CONFIG (0x1A) MACROS***************************************/
+/*
+ * CONFIG寄存器位域宏定义，用于灵活组合生成配置值。
+ * 使用方法: LDC1612_CONFIG_GEN(ACTIVE_CHAN, SLEEP_MODE, RP_OVERRIDE, AUTO_AMP, CLK_SRC, INTB, CURRENT_DRV)
+ *
+ * 位域说明 (根据 LDC1612_REG_LIST.md):
+ * [15:14] ACTIVE_CHAN:      激活通道选择 (仅在 AUTOSCAN_EN=0 时有效)
+ * [13]    SLEEP_MODE_EN:    1 = 睡眠模式使能
+ * [12]    RP_OVERRIDE_EN:   1 = 禁用自动校准 (使用手动的IDRIVE设置)
+ * [11]    SENSOR_ACTIVATE_SEL: 传感器激活电流选择 (0:低电流, 1:高电流)
+ * [10]    AUTO_AMP_DIS:     1 = 禁用自动幅度校正
+ * [9]     REF_CLK_SRC:      1 = 使用外部CLKIN时钟
+ * [8]     RESERVED:         必须为0
+ * [7]     INTB_DIS:         1 = 禁用INTB中断引脚
+ * [6]     HIGH_CURRENT_DRV: 1 = 通道0高电流驱动模式
+ * [5:0]   RESERVED:         必须写入 0x01
+*/
+
+/* --- 位域选项宏 --- */
+// [15:14] Active Channel Selection
+#define LDC1612_CONFIG_ACTIVE_CHAN_CH0      (0x00 << 14)
+#define LDC1612_CONFIG_ACTIVE_CHAN_CH1      (0x01 << 14)
+
+// [13] Sleep Mode Enable
+#define LDC1612_CONFIG_SLEEP_MODE_DISABLE   (0x00 << 13)
+#define LDC1612_CONFIG_SLEEP_MODE_ENABLE    (0x01 << 13)
+
+// [12] RP Override Enable (Auto-Calibration Disable)
+#define LDC1612_CONFIG_RP_OVERRIDE_DISABLE  (0x00 << 12) // 启用自动校准
+#define LDC1612_CONFIG_RP_OVERRIDE_ENABLE   (0x01 << 12) // 禁用自动校准
+
+// [11] Sensor Activation Current Selection
+#define LDC1612_CONFIG_SENSOR_ACT_LOW_I     (0x00 << 11) // 低电流激活
+#define LDC1612_CONFIG_SENSOR_ACT_HIGH_I    (0x01 << 11) // 高电流激活
+
+// [10] Auto Amplitude Correction Disable
+#define LDC1612_CONFIG_AUTO_AMP_ENABLE      (0x00 << 10) // 启用自动幅度校正
+#define LDC1612_CONFIG_AUTO_AMP_DISABLE     (0x01 << 10) // 禁用自动幅度校正
+
+// [9] Reference Clock Source
+#define LDC1612_CONFIG_CLK_SRC_INTERNAL     (0x00 << 9)
+#define LDC1612_CONFIG_CLK_SRC_EXTERNAL     (0x01 << 9)
+
+// [7] INTB Pin Disable
+#define LDC1612_CONFIG_INTB_ENABLE          (0x00 << 7)
+#define LDC1612_CONFIG_INTB_DISABLE         (0x01 << 7)
+
+// [6] High Current Drive (Channel 0)
+#define LDC1612_CONFIG_HIGH_CURRENT_DISABLE (0x00 << 6)
+#define LDC1612_CONFIG_HIGH_CURRENT_ENABLE  (0x01 << 6)
+
+/* --- 组合宏 --- */
+// 将所有位域组合成一个16位值。注意，保留位0x01被固定添加。
+#define LDC1612_CONFIG_GEN(active_chan, sleep, rp_override, sensor_act, auto_amp, clk_src, intb, high_current) \
+    ( (active_chan) | (sleep) | (rp_override) | (sensor_act) | (auto_amp) | (clk_src) | (intb) | (high_current) | 0x0001 )
+
+/* --- 预设配置示例 --- */
+// CH0连续转换, 外部时钟, 高驱动电流, 禁用自动幅度修正(适用于电流检测)
+#define LDC1612_SENSOR_CONFIG_CH0       LDC1612_CONFIG_GEN( \
+                                            LDC1612_CONFIG_ACTIVE_CHAN_CH0, \
+                                            LDC1612_CONFIG_SLEEP_MODE_DISABLE, \
+                                            LDC1612_CONFIG_RP_OVERRIDE_ENABLE, /* Rp覆盖开启 */ \
+                                            LDC1612_CONFIG_SENSOR_ACT_LOW_I, /* 低功耗启动 */ \
+                                            LDC1612_CONFIG_AUTO_AMP_DISABLE, /* 禁用自动幅度校正 */ \
+                                            LDC1612_CONFIG_CLK_SRC_EXTERNAL, /* 外部时钟 */ \
+                                            LDC1612_CONFIG_INTB_ENABLE, /* 启用INTB引脚 */ \
+                                            LDC1612_CONFIG_HIGH_CURRENT_ENABLE /* 大电流模式 */ ) // 结果: 0x1641
+                                            // TODO 对比1601的不同(大电流与标准电流)
+
+// 睡眠模式, 外部时钟
+#define LDC1612_SLEEP_MODE              LDC1612_CONFIG_GEN( \
+                                            LDC1612_CONFIG_ACTIVE_CHAN_CH0, \
+                                            LDC1612_CONFIG_SLEEP_MODE_ENABLE, \
+                                            LDC1612_CONFIG_RP_OVERRIDE_DISABLE, \
+                                            LDC1612_CONFIG_SENSOR_ACT_HIGH_I, \
+                                            LDC1612_CONFIG_AUTO_AMP_ENABLE, \
+                                            LDC1612_CONFIG_CLK_SRC_INTERNAL, \
+                                            LDC1612_CONFIG_INTB_ENABLE, \
+                                            LDC1612_CONFIG_HIGH_CURRENT_DISABLE ) // 结果: 0x2801
+
+/*************************MUX_CONFIG (0x1B) MACROS***************************************/
+/*
+ * MUX_CONFIG寄存器位域宏定义，用于灵活组合生成配置值。
+ *
+ * 位域说明:
+ * [15]    AUTOSCAN_EN: 1 = 自动顺序扫描模式使能
+ * [14:13] RR_SEQUENCE: 扫描序列 (00: CH0, CH1)
+ * [12:3]  RESERVED:    必须写入 0x041
+ * [2:0]   DEGLITCH:    输入消抖滤波器带宽
+*/
+/* --- 位域选项宏 --- */
+// [15] Auto Scan Mode
+#define LDC1612_MUX_AUTOSCAN_DISABLE        (0x00 << 15) // 单通道连续模式
+#define LDC1612_MUX_AUTOSCAN_ENABLE         (0x01 << 15) // 自动扫描模式
+
+// [14:13] Round Robin Sequence
+#define LDC1612_MUX_RR_SEQ_CH0_CH1          (0x00 << 13) // 扫描 CH0, CH1
+
+// [2:0] Deglitch Filter Bandwidth
+#define LDC1612_MUX_DEGLITCH_1MHZ           (0x01)
+#define LDC1612_MUX_DEGLITCH_3_3MHZ         (0x04)
+#define LDC1612_MUX_DEGLITCH_10MHZ          (0x05)
+#define LDC1612_MUX_DEGLITCH_33MHZ          (0x07)
+
+/* --- 组合宏 --- */
+// 将所有位域组合成一个16位值。注意，保留位0x0208 (0x041 << 3)被固定添加。
+#define LDC1612_MUX_CONFIG_GEN(autoscan, sequence, deglitch) \
+    ( (autoscan) | (sequence) | (deglitch) | 0x0208 )
+
+/* --- 预设配置示例 --- */
+// 单通道模式, 3.3MHz 滤波
+#define LDC1612_MUX_CONFIG                  LDC1612_MUX_CONFIG_GEN( \
+                                                LDC1612_MUX_AUTOSCAN_DISABLE, \
+                                                LDC1612_MUX_RR_SEQ_CH0_CH1, /* 此模式下无效，但保持定义 */ \
+                                                LDC1612_MUX_DEGLITCH_3_3MHZ ) // 0x020C
+
+/***********************RESET DEVICE (0x1C)***********************************/
+/*
+ * 向RESET_DEV寄存器写入 LDC1612_RESET_CMD 会触发软件复位。
+ * 复位后，所有寄存器将恢复为默认值，设备进入睡眠模式。
+ * 需要大约10ms的稳定时间后才能重新配置。
+*/
+#define LDC1612_RESET_DEV                  0x8000
+
+/**************************DRIVE_CURRENT (0x1E, 0x1F)****************************************/
+/*
+ * 作用: 设置传感器的驱动电流，以确保振荡幅度(Vosc)在1.2V到1.8V之间。
+ *
+ * 位域说明:
+ * [15:11] IDRIVE:      当前驱动电流设置值 (0-31)。
+ * [10:6]  INIT_IDRIVE: 初始驱动电流设置值 (0-31)。
+ * [5:0]   RESERVED:    必须为0。
+ *
+ * 配置建议:
+ * 1. 初始阶段可启用自动校准 (CONFIG.RP_OVERRIDE_EN = 0)，让芯片自动寻找合适的IDRIVE值。
+ * 2. 读取DRIVE_CURRENT寄存器，获得自动校准后的IDRIVE值。
+ * 3. 在最终代码中，禁用自动校准 (CONFIG.RP_OVERRIDE_EN = 1)，并手动写入这个调试好的IDRIVE值。
+ * 
+ * CH_INIT_IDRIVE will update when every conversion systick ==>AutoAmpDis is 0
+ * CH_INIT_IDRIVE will store init drive current calculated ==> AutoAmpDis is 1
+*/
+
+/* --- 驱动电流值生成宏 --- */
+// 参数 idrive: 0-31之间的整数
+#define LDC1612_DRIVE_CURRENT_GEN(idrive)   ( (uint16_t)(idrive) << 11 )
+
+#define LDC1612_DRIVE_CURRENT              LDC1612_DRIVE_CURRENT_GEN(18) // 0x9000
+
+/**************************IDs (Read Only 0x7E 0x7F)***********************************/
 
 #define LDC1612_MANUFACTURER_ID            0x5449
 #define LDC1612_DEVICE_ID                  0x3055
 
 /******************************************************************************/
 
-#define COIL_RP_KOM              7.2
-#define COIL_L_UH                11.22
-#define COIL_C_PF                150
-#define COIL_Q_FACTOR            31.09
-#define COIL_FREQ_HZ             5323770
-
-/******************************************************************************/
-
 typedef enum {
     LDC1612_STATUS_SUCCESS = 0,
     LDC1612_STATUS_ERROR,
@@ -210,4 +483,6 @@ uint16_t ldc1612_get_sensor_status(void);
 
 bool ldc1612_is_data_ready(uint8_t channel);
 
+uint16_t ldc1612_check_status_and_log_errors(void);
+
 #endif //LDC1612_H

LD/gd32e23x_flash.ld

@@ -12,8 +12,8 @@ _Min_Stack_Size = 0x400; /* required amount of stack */
 /* Memories definition */
 MEMORY
 {
-    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 16K
+    FLASH (rx)  : ORIGIN = 0x08002000, LENGTH = 54K
-    RAM (xrw)   : ORIGIN = 0x20000000, LENGTH = 4K
+    RAM (xrw)   : ORIGIN = 0x20000000, LENGTH = 8K
 }
 
 /* Sections */

LDC1612_REG_LIST.md

@@ -0,0 +1,635 @@
+#
+
+```c
+#define DATA_MSB_CH0            0X00
+#define DATA_LSB_CH0            0X01
+#define DATA_MSB_CH1            0X02
+#define DATA_LSB_CH1            0X03
+#define DATA_MSB_CH2            0X04  /* LDC1614 Only */
+#define DATA_LSB_CH2            0X05  /* LDC1614 Only */
+#define DATA_MSB_CH3            0X06  /* LDC1614 Only */
+#define DATA_LSB_CH3            0X07  /* LDC1614 Only */
+#define RCOUNT_CH0              0X08
+#define RCOUNT_CH1              0X09
+#define RCOUNT_CH2              0X0A  /* LDC1614 Only */
+#define RCOUNT_CH3              0X0B  /* LDC1614 Only */
+#define OFFSET_CH0              0X0C
+#define OFFSET_CH1              0X0D
+#define OFFSET_CH2              0X0E  /* LDC1614 Only */
+#define OFFSET_CH3              0X0F  /* LDC1614 Only */
+#define SETTLECOUNT_CH0         0X10
+#define SETTLECOUNT_CH1         0X11
+#define SETTLECOUNT_CH2         0X12  /* LDC1614 Only */
+#define SETTLECOUNT_CH3         0X13  /* LDC1614 Only */
+#define CLOCK_DIVIDER_CH0       0X14
+#define CLOCK_DIVIDER_CH1       0X15
+#define CLOCK_DIVIDER_CH2       0X16  /* LDC1614 Only */
+#define CLOCK_DIVIDER_CH3       0X17  /* LDC1614 Only */
+#define STATUS                  0X18
+#define ERROR_CONFIG            0X19
+#define CONFIG                  0X1A
+#define MUX_CONFIG              0X1B
+#define RESET_DEVICE            0X1C
+#define DRIVE_CURRENT_CH0       0x1E
+#define DRIVE_CURRENT_CH1       0x1F
+#define DRIVE_CURRENT_CH2       0x20  /* LDC1614 Only */
+#define DRIVE_CURRENT_CH3       0x21  /* LDC1614 Only */
+#define MANUFACTURER_ID         0x7E
+#define DEVICE_ID               0x7F
+```
+
+## 数据寄存器（只读）
+### DATA_CH0_MSB 0x00
+通道0数据高16位
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├────┬────┬────┬────┬─────────────────────────────────────┤
+│ 15 │ 14 │ 13 │ 12 │           11:0                      │
+├────┼────┼────┼────┼─────────────────────────────────────┤
+│ERR │ERR │ERR │ERR │     DATA0[27:16]                    │
+│_UR │_OR │_WD │_AE │     (数据高12位)                     │
+└────┴────┴────┴────┴─────────────────────────────────────┘
+
+位域说明：
+┌──────────┬────────┬────────────────────────────────────────┐
+│   位     │  名称  │              说明                       │
+├──────────┼────────┼────────────────────────────────────────┤
+│   15     │ ERR_UR │ 转换下溢错误标志                        │
+│          │        │ 0: 无下溢错误                           │
+│          │        │ 1: 通道0发生下溢错误                     │
+├──────────┼────────┼────────────────────────────────────────┤
+│   14     │ ERR_OR │ 转换上溢错误标志                        │
+│          │        │ 0: 无上溢错误                           │
+│          │        │ 1: 通道0发生上溢错误                     │
+├──────────┼────────┼────────────────────────────────────────┤
+│   13     │ ERR_WD │ 看门狗超时错误标志                      │
+│          │        │ 0: 无看门狗错误                         │
+│          │        │ 1: 通道0发生看门狗超时                   │
+├──────────┼────────┼────────────────────────────────────────┤
+│   12     │ ERR_AE │ 振幅错误标志                            │
+│          │        │ 0: 无振幅错误                           │
+│          │        │ 1: 通道0发生振幅错误(高或低)             │
+├──────────┼────────┼────────────────────────────────────────┤
+│  11:0    │ DATA0  │ 28位数据的高12位                        │
+│          │[27:16] │                                         │
+└──────────┴────────┴────────────────────────────────────────┘
+### DATA_CH0_LSB 0x01
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├─────────────────────────────────────────────────────────┤
+│                    15:0                                 │
+├─────────────────────────────────────────────────────────┤
+│                  DATA0[15:0]                            │
+│                   (数据低16位)                           │
+└─────────────────────────────────────────────────────────┘
+### DATA_CH1_MSB 0x02
+> 同DATA_CH0_MSB
+### DATA_CH1_LSB 0x03
+> 同DATA_CH0_LSB
+### DATA_CH2_MSB 0x04
+> LDC1614专用
+### DATA_CH2_LSB 0x05
+> LDC1614专用
+### DATA_CH3_MSB 0x06
+> LDC1614专用
+### DATA_CH3_LSB 0x07
+
+## 转换时间寄存器（RCOUNT）
+### RCOUNT_CH0 0x08
+通道0转换时间计数
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├─────────────────────────────────────────────────────────┤
+│                    15:0                                 │
+├─────────────────────────────────────────────────────────┤
+│                  RCOUNT0[15:0]                          │
+└─────────────────────────────────────────────────────────┘
+
+复位值：0x0080
+取值范围：3 ~ 65535 (0x0003 ~ 0xFFFF)
+
+设置通道0的转换时间，决定测量分辨率
+转换时间计算公式 t_CONVERSION = (RCOUNT × 16) / f_REF
+
+其中：
+- t_CONVERSION：单次转换时间（秒）
+- RCOUNT：寄存器值
+- f_REF：参考时钟频率（Hz）
+
+常用配置参考:
+| RCOUNT值        | 40MHz时钟转换时间 | 典型采样率   |
+| -------------- | ----------- | ------- |
+| 0x04D6 (1238)  | 495µs       | ~1kSPS  |
+| 0x0800 (2048)  | 819µs       | ~600SPS |
+| 0xFFFF (65535) | 26.2ms      | ~38SPS  |
+
+配置建议：
+需要高采样率：使用较小的RCOUNT值
+需要高分辨率：使用较大的RCOUNT值
+最小值必须≥3
+
+### RCOUNT_CH1 0x09
+> 同RCOUNT_CH0
+### RCOUNT_CH2 0x0A
+> LDC1614专用
+### RCOUNT_CH3 0x0B
+> LDC1614专用
+
+## 偏移寄存器（OFFSET）
+### OFFSET_CH0 0x0C
+通道0数据偏移
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├─────────────────────────────────────────────────────────┤
+│                    15:0                                 │
+├─────────────────────────────────────────────────────────┤
+│                  OFFSET0[15:0]                          │
+└─────────────────────────────────────────────────────────┘
+
+复位值：0x0000
+
+作用：设置通道0的偏移值，用于从测量结果中减去固定偏移。
+
+计算公式：实际输出 = 原始测量值 - OFFSET
+
+> 如果结果为负，则报告下溢错误(ERR_UR)
+
+应用场景：
+消除传感器固有偏移
+校准零点
+调整测量范围
+
+### OFFSET_CH1 0x0D
+> 同OFFSET_CH0
+### OFFSET_CH2 0x0E
+> LDC1614专用
+### OFFSET_CH3 0x0F
+> LDC1614专用
+
+## 建立时间寄存器（SETTLECOUNT）
+### SETTLECOUNT_CH0 0x10
+通道0建立时间计数
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├─────────────────────────────────────────────────────────┤
+│                    15:0                                 │
+├─────────────────────────────────────────────────────────┤
+│                SETTLECOUNT0[15:0]                       │
+└─────────────────────────────────────────────────────────┘
+
+复位值：0x0000
+取值范围：0 ~ 65535(0x0000 ~ 0xFFFF)
+
+作用：设置通道0传感器振荡器建立稳定振荡所需的时间。
+
+建立时间计算公式：t_SETTLE = (SETTLECOUNT × 16) / f_REF
+
+其中：
+- t_SETTLE：建立时间（秒）
+- SETTLECOUNT：寄存器值
+- f_REF：参考时钟频率（Hz）
+
+常用配置值：
+| SETTLECOUNT值  | 40MHz时钟建立时间 | 典型应用    |
+| ------------- | ----------- | ------- |
+| 0x000A (10)   | 4µs         | 高Q值传感器  |
+| 0x0040 (64)   | 25.6µs      | 中等Q值传感器 |
+| 0x0400 (1024) | 409.6µs     | 低Q值传感器  |
+配置建议：
+- 值过小：传感器未充分稳定，数据不准确
+- 值过大：增加转换周期，降低采样率
+- 需根据实际Q值计算
+
+### SETTLECOUNT_CH1 0x11
+> 同SETTLECOUNT_CH0
+### SETTLECOUNT_CH2 0x12
+> LDC1614专用
+### SETTLECOUNT_CH3 0x13
+> LDC1614专用
+
+## 时钟分频器寄存器（CLOCK_DIVIDERS）
+### CLOCK_DIVIDERS0 0x14
+通道0时钟分频器
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├────────┬────────┬───────────────────────────────────────┤
+│  15:12 │  11:10 │                9:0                    │
+├────────┼────────┼───────────────────────────────────────┤
+│FIN_DIV │RESERVED│           FREF_DIVIDER                │
+│   0    │        │                                       │
+└────────┴────────┴───────────────────────────────────────┘
+
+复位值：0x0000
+
+位域说明：
+| 位     | 名称             | 说明        |
+| ----- | -------------- | --------- |
+| 15:12 | FIN_DIVIDER0  | 通道0输入分频器  |
+| 11:10 | RESERVED      | 保留，必须设为00 |
+| 9:0   | FREF_DIVIDER0 | 通道0参考分频器  |
+
+FIN_DIVIDER设置：
+| FIN_DIVIDER值 | 分频比    | 传感器频率范围                       |
+| ------------- | ------ | ----------------------------- |
+| 0x0 (0000)    | 保留，不使用 | -                             |
+| 0x1 (0001)    | 1      | f_SENSOR ≤ 8.75MHz           |
+| 0x2 (0010)    | 2      | 8.75MHz < f_SENSOR ≤ 17.5MHz |
+| 0x3 (0011)    | 4      | 17.5MHz < f_SENSOR ≤ 35MHz   |
+| 0x4~0xF       | 保留    | -                            |
+
+FREF_DIVIDER设置：
+- 值≥1有效
+- 典型值：1或2
+- 计算公式：f_REF_effective = f_CLKIN / FREF_DIVIDER
+
+常用配置：
+| 配置值    | FIN_DIV | FREF_DIV | 说明                          |
+| ------ | -------- | --------- | --------------------------- |
+| 0x1001 | 1        | 1         | FIN=1, FREF=1               |
+| 0x1002 | 1        | 2         | FIN=1, FREF=2（推荐用于40MHz双通道） |
+| 0x2001 | 2        | 1         | FIN=2, FREF=1               |
+
+配置建议：
+- 单通道模式，f_CLKIN≤35MHz：FREF_DIV=1
+- 双通道模式，f_CLKIN≤40MHz：FREF_DIV=2
+- 单通道模式，35MHz<f_CLKIN≤40MHz：FREF_DIV=2
+
+### CLOCK_DIVIDERS1 0x15
+> 同CLOCK_DIVIDERS0
+### CLOCK_DIVIDERS2 0x16
+> LDC1614专用
+### CLOCK_DIVIDERS3 0x17
+> LDC1614专用
+
+## 状态寄存器（STATUS）
+### STATUS 0x18
+设备状态寄存器
+┌──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┐
+│    15    │    14    │    13    │    12    │    11    │    10    │     9    │     8    │     7    │     6    │    5:4   │     3    │     2    │     1:0  │
+├──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┤
+│ ERR_CHAN │ ERR_CHAN │  ERR_UR  │  ERR_OR  │  ERR_WD  │ ERR_AHE  │ ERR_ALE  │  ERR_ZC  │ RESERVED │   DRDY   │ RESERVED │UNREAD_CH0│UNREAD_CH1│ RESERVED │
+└──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┘
+
+位域说明：
+┌──────────┬─────────────┬────────────────────────────────────────┐
+│   位     │    名称     │              说明                       │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│ 15:14    │ ERR_CHAN    │ 错误通道指示                            │
+│          │             │ 00: 通道0发生错误                       │
+│          │             │ 01: 通道1发生错误                       │
+│          │             │ 10/11: LDC1614专用                      │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│   13     │ ERR_UR      │ 转换下溢错误                            │
+│          │             │ 0: 无下溢错误                           │
+│          │             │ 1: 有通道发生下溢错误                   │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│   12     │ ERR_OR      │ 转换上溢错误                            │
+│          │             │ 0: 无上溢错误                           │
+│          │             │ 1: 有通道发生上溢错误                   │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│   11     │ ERR_WD      │ 看门狗超时错误                          │
+│          │             │ 0: 无看门狗错误                         │
+│          │             │ 1: 有通道发生看门狗超时                 │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│   10     │ ERR_AHE     │ 振幅过高错误                            │
+│          │             │ 0: 无振幅过高错误                       │
+│          │             │ 1: 有通道振幅>1.8V                      │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│    9     │ ERR_ALE     │ 振幅过低警告                            │
+│          │             │ 0: 无振幅过低警告                       │
+│          │             │ 1: 有通道振幅<1.2V                      │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│    8     │ ERR_ZC      │ 零计数错误                              │
+│          │             │ 0: 无零计数错误                         │
+│          │             │ 1: 有通道发生零计数错误                 │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│    7     │ RESERVED    │ 保留                                    │
+│          │             │ 0: 读为0                                │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│    6     │ DRDY        │ 数据就绪标志                            │
+│          │             │ 0: 无新转换结果                         │
+│          │             │ 1: 新转换结果已就绪                     │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│   5:4    │ RESERVED    │ 保留                                    │
+│          │             │ 00: 读为00                              │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│    3     │ UNREADCONV0 │ 通道0未读转换标志                       │
+│          │             │ 0: 通道0无未读数据                      │
+│          │             │ 1: 通道0有未读数据                      │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│    2     │ UNREADCONV1 │ 通道1未读转换标志                       │
+│          │             │ 0: 通道1无未读数据                      │
+│          │             │ 1: 通道1有未读数据                      │
+├──────────┼─────────────┼────────────────────────────────────────┤
+│   1:0    │ RESERVED    │ 保留 (LDC1614中用于CH2/CH3)             │
+└──────────┴─────────────┴────────────────────────────────────────┘
+作用：提供设备运行状态的完整信息，包括错误状态、数据就绪状态等。
+
+读取特性：
+- 读取STATUS寄存器会清除错误标志
+- 读取STATUS会解除INTB引脚的断言
+- 错误标志在被读取前保持锁存状态
+
+## 错误配置寄存器（ERROR_CONFIG）
+### ERROR_CONFIG 0x19
+错误报告配置
+┌──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┐
+│    15    │    14    │    13    │    12    │    11    │   10:8   │    7     │    6     │    5     │    4     │    3     │    2     │    1     │    0     │
+├──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┼──────────┤
+│UR_ERR2OUT│OR_ERR2OUT│WD_ERR2OUT│AH_ERR2OUT│AL_ERR2OUT│ RESERVED │UR_ERR2INT│OR_ERR2INT│WD_ERR2INT│AH_ERR2INT│AL_ERR2INT│ZC_ERR2INT│ RESERVED │DRDY_2INT │
+└──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┘
+
+
+位域说明（输出寄存器报告）：
+┌────────┬─────────────┬────────────────────────────────────────┐
+│   位   │    名称     │              说明                       │
+├────────┼─────────────┼────────────────────────────────────────┤
+│   15   │ UR_ERR2OUT  │ 下溢错误报告到数据寄存器                │
+│        │             │ 0: 不在DATAx_MSB中报告                  │
+│        │             │ 1: 在DATAx_MSB中报告下溢错误            │
+├────────┼─────────────┼────────────────────────────────────────┤
+│   14   │ OR_ERR2OUT  │ 上溢错误报告到数据寄存器                │
+│        │             │ 0: 不在DATAx_MSB中报告                  │
+│        │             │ 1: 在DATAx_MSB中报告上溢错误            │
+├────────┼─────────────┼────────────────────────────────────────┤
+│   13   │ WD_ERR2OUT  │ 看门狗错误报告到数据寄存器              │
+│        │             │ 0: 不在DATAx_MSB中报告                  │
+│        │             │ 1: 在DATAx_MSB中报告看门狗错误          │
+├────────┼─────────────┼────────────────────────────────────────┤
+│   12   │ AH_ERR2OUT  │ 振幅过高错误报告到数据寄存器            │
+│        │             │ 0: 不在DATAx_MSB中报告                  │
+│        │             │ 1: 在DATAx_MSB中报告振幅过高错误        │
+├────────┼─────────────┼────────────────────────────────────────┤
+│   11   │ AL_ERR2OUT  │ 振幅过低警告报告到数据寄存器            │
+│        │             │ 0: 不在DATAx_MSB中报告                  │
+│        │             │ 1: 在DATAx_MSB中报告振幅过低警告        │
+└────────┴─────────────┴────────────────────────────────────────┘
+
+位域说明（INTB中断报告）：
+┌────────┬─────────────┬────────────────────────────────────────┐
+│   位   │    名称     │              说明                       │
+├────────┼─────────────┼────────────────────────────────────────┤
+│    7   │ UR_ERR2INT  │ 下溢错误触发INTB中断                    │
+│        │             │ 0: 不触发INTB                           │
+│        │             │ 1: 触发INTB中断                         │
+├────────┼─────────────┼────────────────────────────────────────┤
+│    6   │ OR_ERR2INT  │ 上溢错误触发INTB中断                    │
+│        │             │ 0: 不触发INTB                           │
+│        │             │ 1: 触发INTB中断                         │
+├────────┼─────────────┼────────────────────────────────────────┤
+│    5   │ WD_ERR2INT  │ 看门狗错误触发INTB中断                  │
+│        │             │ 0: 不触发INTB                           │
+│        │             │ 1: 触发INTB中断                         │
+├────────┼─────────────┼────────────────────────────────────────┤
+│    4   │ AH_ERR2INT  │ 振幅过高错误触发INTB中断                │
+│        │             │ 0: 不触发INTB                           │
+│        │             │ 1: 触发INTB中断                         │
+├────────┼─────────────┼────────────────────────────────────────┤
+│    3   │ AL_ERR2INT  │ 振幅过低警告触发INTB中断                │
+│        │             │ 0: 不触发INTB                           │
+│        │             │ 1: 触发INTB中断                         │
+├────────┼─────────────┼────────────────────────────────────────┤
+│    2   │ ZC_ERR2INT  │ 零计数错误触发INTB中断                  │
+│        │             │ 0: 不触发INTB                           │
+│        │             │ 1: 触发INTB中断                         │
+├────────┼─────────────┼────────────────────────────────────────┤
+│    1   │ RESERVED    │ 保留，设为0                             │
+├────────┼─────────────┼────────────────────────────────────────┤
+│    0   │ DRDY_2INT   │ 数据就绪触发INTB中断                    │
+│        │             │ 0: 不触发INTB                           │
+│        │             │ 1: 新数据就绪时触发INTB中断             │
+└────────┴─────────────┴────────────────────────────────────────┘
+
+作用：配置各种错误和状态条件的报告方式。
+
+常用配置值：
+- `0x0000`：禁用所有错误报告（默认）
+- `0x00FF`：所有错误都触发INTB中断
+- `0x0001`：仅数据就绪触发INTB
+- `0x00FD`：启用大部分错误中断（实际应用常用）
+
+## 主配置寄存器（CONFIG）
+### CONFIG 0x1A
+转换配置寄存器
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├───────┬────┬────┬────┬────┬────┬────┬────┬────────────────┤
+│ 15:14 │ 14 │ 13 │ 12 │ 11 │ 10 │  9 │  8 │      7:0       │
+├───────┼────┼────┼────┼────┼────┼────┼────┼────────────────┤
+│ACTIVE │SLEE│RP_O│SENS│AUTO│REF_│INTB│HIGH│    RESERVED    │
+│       │P_  │VER_│OR_ │_AMP│CLK_│_DIS│_CUR│                │
+│CHAN   │MODE│RIDE│ACTI│_DIS│SRC │    │RENT│                │
+│       │_EN │_EN │VATE│    │    │    │_DRV│                │
+│       │    │    │_SEL│    │    │    │    │                │
+└───────┴────┴────┴────┴────┴────┴────┴────┴────────────────┘
+
+复位值：0x2801
+
+位域说明：
+┌────────┬──────────────────┬────────────────────────────────────────┐
+│   位   │      名称        │              说明                       │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│   15:14│ ACTIVE_CHAN      │ 激活通道选择                            │
+│        │                  │ 0: 通道0激活                            │
+│        │                  │ 1: 通道1激活                            │
+│        │                  │ (仅在单通道模式AUTOSCAN_EN=0时有效)     │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│   13   │ SLEEP_MODE_EN    │ 睡眠模式使能                            │
+│        │                  │ 0: 正常工作模式                         │
+│        │                  │ 1: 进入睡眠模式（低功耗配置模式）        │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│   12   │ RP_OVERRIDE_EN   │ 自动校准禁用                            │
+│        │                  │ 0: 启用自动校准（推荐用于未知传感器）    │
+│        │                  │ 1: 禁用自动校准（使用手动IDRIVE设置）    │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│   11   │ SENSOR_ACTIVATE_ │ 传感器激活电流选择                      │
+│        │ SEL              │ 0: 低电流激活模式                       │
+│        │                  │ 1: 高电流激活模式                       │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│   10   │ AUTO_AMP_DIS     │ 自动幅度校正禁用                        │
+│        │                  │ 0: 启用自动幅度校正                     │
+│        │                  │ 1: 禁用自动幅度校正                     │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│    9   │ REF_CLK_SRC      │ 参考时钟源选择                          │
+│        │                  │ 0: 使用内部参考时钟（约35MHz）          │
+│        │                  │ 1: 使用外部CLKIN时钟                    │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│    8   │ IRESERVED        │ 保留，必须设为0x00                       │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│    7   │ INTB_DIS         │ INTB中断禁用                            │
+│        │                  │ 0: 启用INTB中断功能                     │
+│        │                  │ 1: 禁用INTB（引脚保持高电平）           │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│    6   │ HIGH_CURRENT_DRV │ 高电流驱动模式                          │
+│        │                  │ 0: 正常电流驱动                         │
+│        │                  │ 1: 通道0高电流驱动模式（特殊应用）       │
+├────────┼──────────────────┼────────────────────────────────────────┤
+│   5:0  │ RESERVED         │ 保留，必须设为0x01                      │
+└────────┴──────────────────┴────────────────────────────────────────┘
+
+作用：LDC1612的主配置寄存器，控制工作模式、时钟源、通道选择等核心功能。
+⚠️ 重要提示：CONFIG寄存器必须在所有其他配置完成后最后写入，写入后设备开始转换。
+常用配置值：
+| 配置值    | 说明               |
+| ------ | ---------------- |
+| 0x1601 | 外部时钟，连续转换，禁用自动校准 |
+| 0x1481 | 内部时钟，连续转换        |
+| 0x8000 | 软件复位             |
+| 0x2801 | 进入睡眠模式           |
+
+## 多路复用器配置寄存器（MUX_CONFIG）
+### MUX_CONFIG 0x1B
+通道多路复用配置
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├────┬───────┬─────────────────┬─────────────────────────┤
+│ 15 │ 14:13 │     12:3        │         2:0             │
+├────┼───────┼─────────────────┼─────────────────────────┤
+│AUTO│RR_    │   RESERVED      │      DEGLITCH           │
+│SCAN│SEQUENCE│  (必须设为      │    (消抖滤波器带宽)      │
+│_EN │       │  00 0100 0001)  │                         │
+└────┴───────┴─────────────────┴─────────────────────────┘
+
+复位值：0x020F
+
+位域说明：
+┌────────┬─────────────┬────────────────────────────────────────┐
+│   位   │    名称     │              说明                       │
+├────────┼─────────────┼────────────────────────────────────────┤
+│   15   │ AUTOSCAN_EN │ 自动扫描模式使能                        │
+│        │             │ 0: 单通道连续模式（由ACTIVE_CHAN选择）  │
+│        │             │ 1: 顺序扫描模式（由RR_SEQUENCE选择）    │
+├────────┼─────────────┼────────────────────────────────────────┤
+│  14:13 │ RR_SEQUENCE │ 扫描序列配置                            │
+│        │             │ 00: CH0, CH1                            │
+│        │             │ 01: CH0, CH1, CH2 (LDC1614)             │
+│        │             │ 10: CH0, CH1, CH2, CH3 (LDC1614)        │
+│        │             │ 11: CH0, CH1                            │
+├────────┼─────────────┼────────────────────────────────────────┤
+│  12:3  │ RESERVED    │ 保留，必须设为00 0100 0001 (0x041)      │
+├────────┼─────────────┼────────────────────────────────────────┤
+│   2:0  │ DEGLITCH    │ 输入消抖滤波器带宽                      │
+│        │             │ 001: 1.0 MHz                            │
+│        │             │ 100: 3.3 MHz                            │
+│        │             │ 101: 10 MHz                             │
+│        │             │ 111: 33 MHz                             │
+└────────┴─────────────┴────────────────────────────────────────┘
+作用：配置通道扫描模式和输入消抖滤波器。
+
+DEGLITCH选择建议：
+- 选择大于传感器频率的最低设置
+- 例如：f_SENSOR=7.8MHz，选择10MHz (101)
+
+常用配置值：
+| 配置值    | 说明               |
+| ------ | ---------------- |
+| 0x020C | 单通道模式，3.3MHz滤波   |
+| 0x820C | 双通道顺序模式，3.3MHz滤波 |
+| 0x820D | 双通道顺序模式，10MHz滤波  |
+
+## 复位寄存器（RESET_DEV）
+### RESET_DEV 0x1C
+设备复位
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├─────────────────────────────────────────────────────────┤
+│                    15:0                                 │
+├─────────────────────────────────────────────────────────┤
+│                  RESET_DEV[15:0]                        │
+└─────────────────────────────────────────────────────────┘
+作用：软件复位设备。
+
+复位操作：
+- 写入0x8000：触发软件复位
+- 复位后所有寄存器恢复默认值
+- 复位完成后设备进入睡眠模式
+
+复位完成后，delay 10ms，然后重新配置全部寄存器
+
+## 驱动电流寄存器（DRIVE_CURRENT）
+### DRIVE_CURRENT0 0x1E
+通道0驱动电流
+
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├────────────────┬──────────────────┬─────────────────────┤
+│     15:11      │      10:6        │         5:0         │
+├────────────────┼──────────────────┼─────────────────────┤
+│    IDRIVE0     │  INIT_IDRIVE0    │      RESERVED       │
+│ (当前驱动电流)   │ (初始驱动电流)     │     (设为0x00)      │
+└────────────────┴──────────────────┴─────────────────────┘
+复位值：0x0000
+
+作用：设置通道0的传感器驱动电流。INIT_IDRIVE0可以用来自动幅度校正关闭时，自动确定合适的驱动电流。
+
+IDRIVE值与Rp关系：
+| Rp (kΩ) | 推荐IDRIVE | DRIVE_CURRENT值 | Nominal Current (µA) |
+| ------- | -------- | --------------- | ------------------ |
+| 0.90    | 31       | 0xF800          | 1563              |
+| 1.05    | 30       | 0xF000          | 1355              |
+| 1.21    | 29       | 0xE800          | 1173              |
+| 1.40    | 28       | 0xE000          | 1017              |
+| 1.63    | 27       | 0xD800          | 880               |
+| 1.89    | 26       | 0xD000          | 763               |
+| 2.20    | 25       | 0xC800          | 635               |
+| 2.55    | 24       | 0xC000          | 551               |
+| 2.95    | 23       | 0xB800          | 489               |
+| 3.43    | 22       | 0xB000          | 424               |
+| 3.98    | 21       | 0xA800          | 392               |
+| 4.61    | 20       | 0xA000          | 297               |
+| 5.35    | 19       | 0x9800          | 244               |
+| 6.21    | 18       | 0x9000          | 212               |
+| 7.20    | 17       | 0x8800          | 195               |
+| 8.36    | 16       | 0x8000          | 169               |
+| 9.69    | 15       | 0x7800          | 146               |
+| 11.2    | 14       | 0x7000          | 127               |
+| 13.0    | 13       | 0x6800          | 110               |
+| 15.1    | 12       | 0x6000          | 95                |
+| 17.6    | 11       | 0x5800          | 82                |
+| 20.4    | 10       | 0x5000          | 72                |
+| 23.6    | 9        | 0x4800          | 59                |
+| 27.4    | 8        | 0x4000          | 52                |
+| 31.8    | 7        | 0x3800          | 46                |
+| 36.9    | 6        | 0x3000          | 40                |
+| 42.8    | 5        | 0x2800          | 32                |
+| 49.7    | 4        | 0x2000          | 28                |
+| 57.6    | 3        | 0x1800          | 23                |
+| 66.9    | 2        | 0x1000          | 20                |
+| 77.6    | 1        | 0x0800          | 18                |
+| 90.0    | 0        | 0x0000          | 16                |
+
+配置建议：
+- 先用自动校准模式确定合适的IDRIVE
+- 再用示波器确认Vosc在1.2V~1.8V之间
+- 固定IDRIVE后设置RP_OVERRIDE_EN=1
+
+### DRIVE_CURRENT1 0x1F
+> 同DRIVE_CURRENT0
+### DRIVE_CURRENT2 0x20
+> 同DRIVE_CURRENT0
+### DRIVE_CURRENT3 0x21
+> 同DRIVE_CURRENT0
+
+## 自动幅度校正寄存器（AUTO_AMPGAIN）
+### AUTO_AMPGAIN 0x22
+┌─────────────────────────────────────────────────────────┐
+│  位域分布 (16位)                                         │
+├─────────────────────────────────────────────────────────┤
+│                    15:0                                 │
+├─────────────────────────────────────────────────────────┤
+
+## ID寄存器（只读）
+### MANUFACTURER_ID 0x7E
+制造商ID
+┌─────────────────────────────────────────────────────────┐
+│  值：0x5449 ("TI"的ASCII码)                              │
+└─────────────────────────────────────────────────────────┘
+作用：验证设备制造商。
+
+### DEVICE_ID 0x7F
+设备ID
+┌─────────────────────────────────────────────────────────┐
+│  LDC1612值：0x3054                                        │
+│  LDC1614值：0x3056                                        │
+└─────────────────────────────────────────────────────────┘
+作用：验证设备型号，可用于I2C通信测试。

README.md

@@ -1,11 +1,36 @@
-# GD32E23x 工程模板
+# LDC1612 传感器固件
 
-本仓库为兆易创新 GD32E23x 系列 MCU 的 CMake + VSCode 工程模板，适合嵌入式开发快速上手和团队协作。
+本仓库基于 GD32E23x CMake + VSCode 工程模板（`gd32e23x_template_cmake_vscode`），包含 LDC1612 电感采样、TMP112 温度采集及补偿、RS485 命令处理。当前版本为 V1.0.1。固件采用 Bootloader + APP 布局：APP 链接在 `0x08002000`（54KB Flash / 8KB RAM），启动时自设向量表偏移；开发进度与审查资料见 `doc/` 目录。
+
+## 本地编译
+
+需要 CMake 3.20 或更新版本、Ninja 和 ARM GCC。CMake、Ninja 应在 `PATH` 中；ARM GCC 通过 `GD32_GCC_BIN` 指定，也可在配置时传入 `-DTOOLCHAIN_DIRECTORY="D:/toolchain/arm-gcc/bin"`，该参数优先于环境变量。工具链路径支持包根目录或 `bin` 目录。
+
+在工程根目录运行 PowerShell（工具链路径请替换为本机安装位置）：
+
+```powershell
+$env:GD32_GCC_BIN = 'D:\toolchain\xpack-arm-none-eabi-gcc-15.2.1-1.1\bin'
+cmake --preset Debug
+cmake --build --preset Debug
+cmake --preset Release
+cmake --build --preset Release
+```
+
+输出位于 `Build/Debug` 或 `Build/Release`：`Application/Application.elf` 用于调试，`LDC1612_V1.0.1_APP_<日期>.bin` / `.hex` 为应用固件；`Application/Application.hex` 供 J-Link 烧录任务使用。应用固件不含 Bootloader：单独烧录需写到 `0x08002000`；整片烧录（Bootloader + APP + 标志页）用配套的固件合并工具（`gd32e230f8_firmware_merge_tool` 仓库）处理。详见[固件布局与 Bootloader](#固件布局与-bootloader)。
+
+如果切换 ARM GCC 版本，请使用新的构建目录，或通过 CMake Tools 的 “Delete Cache and Reconfigure” 重新配置。需要独立验证目录时可运行：
+
+```powershell
+cmake --preset Debug -B Build/local-check/Debug
+cmake --build Build/local-check/Debug
+```
 
 ---
 
 ## 目录
 
+- [本地编译](#本地编译)
+- [固件布局与 Bootloader](#固件布局与-bootloader)
 - [适用范围](#适用范围)
 - [默认配置](#默认配置)
 - [工具链准备](#工具链准备)
@@ -16,6 +41,26 @@
 
 ---
 
+## 固件布局与 Bootloader
+
+GD32E230F8（64KB Flash）按 Bootloader + APP 方式分区：
+
+| 区域 | 地址范围 | 说明 |
+|---|---|---|
+| Bootloader | `0x08000000` - `0x08001FFF`（8KB） | 随板提供，独立固件（`gd32e230f8_bootloader_hulk.bin`），负责 RS485 Ymodem OTA 与跳转 |
+| APP（本仓库） | `0x08002000` - `0x0800F7FF`（54KB） | 链接区 `FLASH ORIGIN=0x08002000, LENGTH=54K` |
+| 温度标定页（预留） | `0x0800F800` - `0x0800FBFF` | 预留存放标定数据；当前 APP 不访问，仅靠 54KB 链接上限保证不越界覆盖 |
+| 有效标志 | `0x0800FFFC` | Bootloader OTA 完成后自写 `0x0000EEEE`，跳转前校验 |
+
+工程侧的两个适配点（缺一不可）：
+
+- `LD/gd32e23x_flash.ld`：FLASH `ORIGIN = 0x08002000, LENGTH = 54K`；
+- `Src/system_gd32e23x.c`：`VECT_TAB_OFFSET = 0x2000`——Bootloader 不写 VTOR，APP 必须自己把向量表指到 `0x08002000`，否则中断会落回 Bootloader 向量表（现象：收到第一个 RS485 字节即死机）。
+
+⚠️ 与旧版布局（APP 链接在 `0x08000000` 的独立镜像）不兼容：从旧版升级需整片烧录一次。RS485 协议、命令集（M1-M6/M999/M9999）与回包格式无任何变化。布局依据与 Bootloader 反汇编分析见 `doc/LDC1612_工程审查与实验方案_2026-09-26.md`。
+
+---
+
 ## 适用范围
 
 - 适用于兆易创新 GD32E23x 系列 Cortex-M23 内核单片机
@@ -34,37 +79,49 @@
 
 ### 1. xPack GNU Arm Embedded GCC Toolchain
 
-- **版本**：xpack-arm-none-eabi-gcc-11.3.1-1.1  
+- **原模板版本**：xpack-arm-none-eabi-gcc-11.3.1-1.1；本机编译验证使用 15.2.1-1.1。
-- **建议解压路径**：Tools/xpack-arm-none-eabi-gcc-11.3.1-1.1  
+- **安装位置**：由本机统一管理，不提交到仓库。
 - **官方下载地址**：https://github.com/xpack-dev-tools/arm-none-eabi-gcc-xpack/releases  
 - **路径自定义说明**：  
-  如需自定义工具链路径，请同步修改以下文件：  
+  编译器与 GDB 均通过 `GD32_GCC_BIN` 环境变量定位（或配置时传 `-DTOOLCHAIN_DIRECTORY`），CMake 文件与 `.vscode` 均无需修改路径。
-  - `Projects/<BoardName>/<ProjectName>/cmake/arm-none-eabi-gcc.cmake`（第2行）  
-  - `Projects/<BoardName>/<ProjectName>/.vscode/launch.json`（第12行）
 
-### 2. OpenOCD
+### 2. OpenOCD（GD-Link 支持）
 
 - **版本**：xpack-openocd-0.11.0-3  
-- **建议解压路径**：Tools/xpack-openocd-0.11.0-3  
 - **获取地址**：https://github.com/burakenez/gd32-tools-xpack-openocd/tree/v0.11.0-3  
 - **说明**：  
   - 本版本提取自 Embedded Builder V1.4.1.23782。  
   - ⚠️ 请勿随意更换版本，因 GD32 MCU 支持有限，推荐严格使用此版本。  
 - **路径自定义说明**：  
-  如需自定义 OpenOCD 路径，请同步修改以下文件：  
+  通过两个环境变量定位，安装位置任意：  
-  - `Projects/<BoardName>/<ProjectName>/.vscode/launch.json`（第14、17行）  
+  - `GD32_OPENOCD_BIN`：`openocd.exe` 所在 `bin` 目录；  
-  - `Projects/<BoardName>/<ProjectName>/.vscode/task.json` 中所有相关路径
+  - `GD32_OPENOCD_SCRIPTS`：OpenOCD `scripts` 目录。  
+  `.vscode` 的调试配置与烧录任务全部读取这两个变量，无需修改任何文件。
 
 ---
 
 ## 使用说明
 
-1. **准备工具链**  
+1. **配置环境变量**（用户级，按本机安装位置设置一次即可）
-   - 按上述说明下载并解压 ARM GCC 和 OpenOCD 到 Tools 目录。
-   - Toolchain 目录内容不会被 git 跟踪，需自行维护。
 
-2. **烧录固件**  
+   | 环境变量 | 指向 | 用途 |
-   - 可直接使用 VSCode 任务栏的 Flash MCU 任务，或命令行运行 OpenOCD。
+   |---|---|---|
+   | `GD32_GCC_BIN` | ARM GCC 的 `bin` 目录 | 编译、GDB 调试 |
+   | `GD32_OPENOCD_BIN` | OpenOCD 的 `bin` 目录 | 烧录、调试 |
+   | `GD32_OPENOCD_SCRIPTS` | OpenOCD 的 `scripts` 目录 | 烧录、调试 |
+
+   设置后重开终端 / VSCode 生效。`cmd` 示例：`setx GD32_GCC_BIN "D:\toolchain\xpack-arm-none-eabi-gcc-15.2.1-1.1\bin"`。
+
+2. **编译**  
+   命令行见上文[本地编译](#本地编译)，或直接用 VSCode 的 CMake Tools 选择 Debug / Release preset 构建。
+
+3. **烧录固件**  
+   - **OpenOCD（GD-Link）**：VSCode 任务 `Flash MCU`（连带编译用 `Build and Flash`）；另有 `Reset MCU`、`Mass Erase MCU`、`OpenOCD Server` 任务。  
+   - **J-Link**：任务 `Flash MCU (Jlink)` 等，依赖构建生成的 `Build/<preset>/Application/Application.hex`。  
+   - 器件与接口在 `.vscode/settings.json` 的 `gd32.jlink.*` / `gd32.openocd.*` 中配置，当前为 GD32E230F8 / SWD。
+
+4. **调试**  
+   VSCode 调试配置有两个：`Debug with OpenOCD` 与 `Debug with J-Link`（均使用 cortex-debug，SVD 文件 `GD32E230.svd`，支持外设寄存器查看）。烧录调试器以 GD-Link 为例；J-Link 直接选用对应配置即可。
 
 ---
 
@@ -129,7 +186,6 @@
 
 - **快速上手示例**：如 main.c 的最小点灯/串口输出代码片段。
 - **常见问题与解答**：如构建失败、烧录失败的排查建议。
-- **调试说明**：如何用 VSCode 调试、断点、查看寄存器等。
 - **多板卡适配说明**：如有多种硬件，如何切换 BoardName。
 - **贡献指南**：如何提交 PR、代码风格约定等。
 - **License 说明**：开源协议和版权声明。

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;
+}

Src/command.c

@@ -74,13 +74,29 @@
 #define RESP_TYPE_LEN_ERR         0xF4  /**< 长度错误 */
 /** @} */
 
+/* 温度补偿参数定义
+ * TEMP_COMP_REF_TEMP_X10000: 参考温度，单位 0.0001°C
+ * TEMP_COMP_COEFF_NUMERATOR / TEMP_COMP_COEFF_DENOMINATOR: 温漂系数，默认表示 counts/°C
+ * 补偿公式: compensated = raw - (temp - ref) * coeff
+ */
+#define TEMP_COMP_REF_TEMP_X10000      (250000L)
+#define TEMP_COMP_COEFF_NUMERATOR      (0L)
+#define TEMP_COMP_COEFF_DENOMINATOR    (10000L)
+
 /* ============================================================================
  * 模块内部变量
  * ============================================================================ */
 
 /** @brief 传感器周期上报使能标志 */
 volatile bool g_eddy_current_sensor_report_enabled = false;
-volatile bool g_temperature_sensor_report_enabled = false;
+
+/* Debug output control */
+#ifdef COM_DEBUG
+    #include <stdio.h>
+    #define COMMAND_DEBUG(fmt, ...) printf("[COMMAND] " fmt "\n", ##__VA_ARGS__)
+#else
+    #define COMMAND_DEBUG(fmt, ...)
+#endif
 
 /** @name 预设响应数据
  * @{ */
@@ -88,6 +104,9 @@ static const uint8_t s_report_status_ok[]  = { 'o', 'k' };   /**< 成功响应
 static const uint8_t s_report_status_err[] = { 'e','r','r' }; /**< 错误响应数据 */
 /** @} */
 
+static int32_t tmp112_get_temperature_x10000(void);
+static int64_t calculate_temperature_compensation_offset(int32_t temperature_x10000);
+
 /* ============================================================================
  * 公共接口函数
  * ============================================================================ */
@@ -114,28 +133,6 @@ void set_eddy_sensor_report_status(bool 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;
-}
-
 /**
  * @brief 计算协议包的 8 位累加校验值（Checksum）。
  * @details 对输入缓冲区逐字节累加并取低 8 位，累加范围为 data[1] 至 data[len-2]，
@@ -220,6 +217,36 @@ static void send_response(uint8_t type, const uint8_t *payload, uint8_t len)
  */
 static inline bool is_dec_digit(uint8_t c) { return (c >= '0' && c <= '9'); }
 
+/**
+ * @brief 将一个无符号整数转换为字符串并追加到缓冲区。
+ * @param value 要转换的数字。
+ * @param buffer 指向目标缓冲区的指针，转换后的字符串将写入此处。
+ * @return uint8_t 写入的字符数。
+ */
+static uint8_t uint_to_str(uint32_t value, char *buffer) {
+    char temp[10]; // 32位无符号整数最多10位
+    int i = 0;
+
+    if (value == 0) {
+        buffer[0] = '0';
+        return 1;
+    }
+
+    // 将数字逆序转换为字符存入临时数组
+    while (value > 0) {
+        temp[i++] = (char)((value % 10) + '0');
+        value /= 10;
+    }
+
+    // 将逆序的字符串反转并存入目标缓冲区
+    uint8_t len = (uint8_t)i;
+    for (int j = 0; j < len; j++) {
+        buffer[j] = temp[--i];
+    }
+    
+    return len;
+}
+
 /**
  * @brief 从缓冲区解析十进制无符号整数。
  * @details 从指定位置开始连续读取十进制数字字符，累加构成32位无符号整数。
@@ -306,20 +333,58 @@ void handle_command(const uint8_t *frame, uint8_t len) {
 
             case 2u: // M2: disable sensor report
                 set_eddy_sensor_report_status(false);
+                send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
                 return;
 
             case 3u:
-                set_temp_sensor_report_status(true);
+                eddy_current_report();
                 return;
                 
             case 4u:
-                set_temp_sensor_report_status(false);
+                temperature_raw_value_report();
+                return;
+
+            case 5u:
+                eddy_current_compensated_report();
+                return;
+
+            case 6u:
+                calibration_data_report();
                 return;
 
             // case 201u: // M201命令
             //     send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
             //     return;
 
+        /* ==========================================
+         * M999 输出固件版本号命令
+         * ========================================== */
+        case 999u: //M999: 输出固件版本号
+            {
+                char version_str[16];
+                char *p = version_str;
+
+                *p++ = 'v';
+                p += uint_to_str(BOARD_TYPE_CODE, p);
+                *p++ = '.';
+                p += uint_to_str(FW_VERSION_MAJOR, p);
+                *p++ = '.';
+                p += uint_to_str(FW_VERSION_MINOR, p);
+                *p++ = '.';
+                p += uint_to_str(FW_VERSION_PATCH, p);
+                *p = '\0'; // null-terminate for printf safety
+
+                uint8_t n = (uint8_t)(p - version_str);
+                send_response(RESP_TYPE_OK, (uint8_t *)version_str, n);
+                COMMAND_DEBUG("Firmware Version: %s", version_str);
+            }
+            return;
+
+            case 9999u:
+                __disable_irq();
+                NVIC_SystemReset();
+                return;
+
             default:
                 // 其它无参数命令在此扩展（示例：M100）处理逻辑该如何待定
                 // send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
@@ -468,20 +533,82 @@ void eddy_current_report(void) {
     send_response(RESP_TYPE_OK, sensor_data, sizeof(sensor_data));
 }
 
-void temperature_raw_value_report(void) {
+static int32_t tmp112_get_temperature_x10000(void)
-    // if (!g_temperature_sensor_report_enabled) return;
+{
-    uint8_t raw_result[4];
     uint8_t value[2] = {0};
-    uint32_t raw_value = 0;
+    int16_t temp_raw;
 
-    // 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);
+    temp_raw = (int16_t)(((uint16_t)value[0] << 8) | value[1]);
-    raw_result[1] = (uint8_t)(raw_value >> 16);
+    temp_raw >>= 4;
-    raw_result[2] = (uint8_t)(raw_value >> 8);
+
-    raw_result[3] = (uint8_t)(raw_value & 0xFF);
+    return (int32_t)temp_raw * 625;
+}
+
+static int64_t calculate_temperature_compensation_offset(int32_t temperature_x10000)
+{
+    int32_t delta_temp_x10000 = temperature_x10000 - TEMP_COMP_REF_TEMP_X10000;
+
+    return ((int64_t)delta_temp_x10000 * TEMP_COMP_COEFF_NUMERATOR) /
+           TEMP_COMP_COEFF_DENOMINATOR;
+}
+
+void temperature_raw_value_report(void) {
+    uint8_t raw_result[4];
+    int32_t raw_value = tmp112_get_temperature_x10000();
+
+    raw_result[0] = (uint8_t)((uint32_t)raw_value >> 24);
+    raw_result[1] = (uint8_t)((uint32_t)raw_value >> 16);
+    raw_result[2] = (uint8_t)((uint32_t)raw_value >> 8);
+    raw_result[3] = (uint8_t)((uint32_t)raw_value & 0xFF);
 
     send_response(RESP_TYPE_OK, raw_result, sizeof(raw_result));
 }
+
+void eddy_current_compensated_report(void)
+{
+    uint8_t sensor_data[4];
+    uint32_t raw_result = ldc1612_get_raw_channel_result(CHANNEL_0);
+
+    if ((raw_result & 0xF0000000u) == 0u) {
+        int32_t temperature_x10000 = tmp112_get_temperature_x10000();
+        int64_t compensated_value = (int64_t)raw_result -
+                                    calculate_temperature_compensation_offset(temperature_x10000);
+
+        if (compensated_value < 0) {
+            raw_result = 0;
+        } else if (compensated_value > 0x0FFFFFFFLL) {
+            raw_result = 0x0FFFFFFFu;
+        } else {
+            raw_result = (uint32_t)compensated_value;
+        }
+    }
+
+    sensor_data[0] = (uint8_t)(raw_result >> 24);
+    sensor_data[1] = (uint8_t)(raw_result >> 16);
+    sensor_data[2] = (uint8_t)(raw_result >> 8);
+    sensor_data[3] = (uint8_t)(raw_result & 0xFF);
+
+    send_response(RESP_TYPE_OK, sensor_data, sizeof(sensor_data));
+}
+
+void calibration_data_report(void)
+{
+    uint8_t payload[9];
+    uint32_t eddy_raw_value = ldc1612_get_raw_channel_result(CHANNEL_0);
+    int32_t temperature_raw_value = tmp112_get_temperature_x10000();
+
+    payload[0] = (uint8_t)(eddy_raw_value >> 24);
+    payload[1] = (uint8_t)(eddy_raw_value >> 16);
+    payload[2] = (uint8_t)(eddy_raw_value >> 8);
+    payload[3] = (uint8_t)(eddy_raw_value & 0xFF);
+    payload[4] = 0xFF;
+    payload[5] = (uint8_t)((uint32_t)temperature_raw_value >> 24);
+    payload[6] = (uint8_t)((uint32_t)temperature_raw_value >> 16);
+    payload[7] = (uint8_t)((uint32_t)temperature_raw_value >> 8);
+    payload[8] = (uint8_t)((uint32_t)temperature_raw_value & 0xFF);
+
+    send_response(RESP_TYPE_OK, payload, sizeof(payload));
+}
     

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)) {
+    // 检查当前配置是否使用USART0，并且函数指针不为空
-        uint8_t data = usart_data_receive(USART0);
+    if(g_usart_config.usart_periph == USART0 && g_usart_config.irq_handler != 0) {
-        (void)uart_ring_buffer_put(data); // 缓冲满时丢弃，返回值可用于统计
+        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();  // 通过函数指针调用对应的处理函数
+    }
+}

Src/i2c.c

@@ -34,6 +34,7 @@ void i2c_gpio_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 */
@@ -149,7 +150,7 @@ i2c_result_t i2c_bus_reset(void) {
     }
 
 #ifdef DEBUG_VERBOSE
-        printf("I2C bus reset: bus recovered\r\n");
+    printf("I2C bus reset: bus recovered\r\n");
 #endif
     /* 8. Reconfigure & enable peripheral */
     i2c_config();
@@ -197,10 +198,12 @@ void i2c_scan(void) {
         i2c_master_addressing(I2C0, (address << 1), I2C_TRANSMITTER);
         timeout = 0;
 
-        // 等待地址发送完成
+        // 等待地址发送完成或错误
-        while (!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND) && (timeout < I2C_TIME_OUT))
+        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) {
+
+        if (timeout < I2C_TIME_OUT && i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) {
+            // 设备响应 - 清除地址标志
             i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
             // printf("Found device at 0x%02X\r\n", address);
             const char* msg2_prefix = "Found device at 0x";
@@ -221,6 +224,9 @@ void i2c_scan(void) {
             }
             while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TC) == RESET) {}
             found_devices++;
+        } else if (i2c_flag_get(I2C0, I2C_FLAG_AERR)) {
+            // 设备无响应 - 清除错误标志
+            i2c_flag_clear(I2C0, I2C_FLAG_AERR);
         }
 
         // 生成停止条件
@@ -263,6 +269,53 @@ void i2c_scan(void) {
     }
 }
 
+/**
+ * @brief 内部辅助函数：等待指定的I2C标志位被设置，带有超时。
+ * @param[in]  flag: 要等待的I2C事件标志。
+ * @retval     i2c_result_t: I2C_RESULT_SUCCESS 或 I2C_RESULT_TIMEOUT。
+ */
+static i2c_result_t _i2c_wait_flag_timeout(uint32_t flag)
+{
+    uint16_t timeout = 0;
+    while(!i2c_flag_get(I2C0, flag)){
+        if(timeout++ > I2C_TIME_OUT){
+#ifdef DEBUG_VERBOSE
+            const char* fname = "UNKNOWN";
+            switch (flag) {
+                case I2C_FLAG_SBSEND: fname = "SBSEND"; break;
+                case I2C_FLAG_ADDSEND: fname = "ADDSEND"; break;
+                case I2C_FLAG_TBE: fname = "TBE"; break;
+                case I2C_FLAG_RBNE: fname = "RBNE"; break;
+                case I2C_FLAG_BTC: fname = "BTC"; break;
+                case I2C_FLAG_AERR: fname = "AERR"; break;
+                case I2C_FLAG_BERR: fname = "BERR"; break;
+                case I2C_FLAG_LOSTARB: fname = "LOSTARB"; break;
+                case I2C_FLAG_I2CBSY: fname = "I2CBSY"; break;
+            }
+            printf("I2C wait flag timeout: flag=0x%08X (%s)\r\n", (unsigned int)flag, fname);
+#endif
+            return I2C_RESULT_TIMEOUT;
+        }
+    }
+    return I2C_RESULT_SUCCESS;
+}
+
+/**
+ * @brief 内部辅助函数：等待指定的I2C标志位被清除，带有超时。
+ * @param[in]  flag: 要等待的I2C事件标志。
+ * @retval     i2c_result_t: I2C_RESULT_SUCCESS 或 I2C_RESULT_TIMEOUT。
+ */
+static i2c_result_t _i2c_wait_flag_clear_timeout(uint32_t flag)
+{
+    uint16_t timeout = 0;
+    while(i2c_flag_get(I2C0, flag)){
+        if(timeout++ > I2C_TIME_OUT){
+            return I2C_RESULT_TIMEOUT;
+        }
+    }
+    return I2C_RESULT_SUCCESS;
+}
+
 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;
@@ -325,7 +378,7 @@ i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data
                 } else {
                     i2c_flag_clear(I2C0, I2C_FLAG_AERR);
                     timeout =0;
-#ifdef DEBUG_VERBOES
+#ifdef DEBUG_VERBOSE
                     printf("IIC write failed for Error Slave Address. \n");
 #endif
                     return I2C_RESULT_NACK;
@@ -333,39 +386,28 @@ i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data
 
             case I2C_STATE_TRANSMIT_REG:
                 /* wait until the transmit data buffer is empty */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
 
                 /* send register address */
                 i2c_data_transmit(I2C0, reg_addr);
-                timeout = 0;
                 state = I2C_STATE_TRANSMIT_DATA;
                 break;
 
             case I2C_STATE_TRANSMIT_DATA:
                 /* wait until the transmit data buffer is empty */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
 
                 /* 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)) {
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
@@ -381,13 +423,9 @@ i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data
 
                 /* 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)) {
+                if(_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
@@ -413,25 +451,13 @@ i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data
                 return I2C_RESULT_SUCCESS;
 
             case I2C_STATE_ERROR:
-                /* send a stop condition to I2C bus */
+                /* I2C bus error, try to reset the bus and retry */
-                i2c_stop_on_bus(I2C0);
+                i2c_bus_reset();
-
-                timeout = 0;
-                while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
-                    return I2C_RESULT_ERROR;
-                }
-
-                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
+#ifdef DEBUG_VERBOSE
                     printf("IIC write failed after %d retries\n", I2C_MAX_RETRY);
 #endif
                     return I2C_RESULT_ERROR;
@@ -444,7 +470,7 @@ i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data
                 /* small delay before retry */
                 delay_10us(10);
                 break;
-                
+
             default:
                 state = I2C_STATE_START;
                 break;
@@ -472,11 +498,8 @@ i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
             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)) {
+                if(_i2c_wait_flag_clear_timeout(I2C_FLAG_I2CBSY) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
@@ -484,15 +507,11 @@ i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                 // 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  */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
+                if(_i2c_wait_flag_timeout(I2C_FLAG_SBSEND) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
@@ -540,10 +559,7 @@ i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
 
             case I2C_STATE_TRANSMIT_DATA:
                 /* wait for transmit buffer to be empty */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
@@ -551,28 +567,20 @@ i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                 /* 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  BTC: Bit Transfer Complete */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
+                if(_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
 
                 /* generate repeated start condition */
                 i2c_start_on_bus(I2C0);
-                
+
                 /* wait for repeated start condition to be sent */
-                timeout = 0;
+                if(_i2c_wait_flag_timeout(I2C_FLAG_SBSEND) != I2C_RESULT_SUCCESS) {
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
@@ -588,10 +596,7 @@ i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
 
             case I2C_STATE_RECEIVE_DATA:
                 /* Wait for BTC (both bytes received) */
-                while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
+                if(_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
-                    timeout++;
-                }
-                if (timeout >= I2C_TIME_OUT) {
                     state = I2C_STATE_ERROR;
                     break;
                 }
@@ -621,13 +626,13 @@ i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
                 return I2C_RESULT_SUCCESS;
 
             case I2C_STATE_ERROR:
-                /* send stop condition to release bus */
+                /* I2C bus error, try to reset the bus and retry */
-                i2c_stop_on_bus(I2C0);
+                i2c_bus_reset();
 
                 retry_count++;
                 if (retry_count >= I2C_MAX_RETRY) {
-#ifdef DEBUG_VERBOES
+#ifdef DEBUG_VERBOSE
-                    printf("IIC read failed after %d retries\n", I2C_RETRY_MAX);
+                    printf("IIC read failed after %d retries\n", I2C_MAX_RETRY);
 #endif
                     return I2C_RESULT_ERROR;
                 }
@@ -649,10 +654,659 @@ i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data
     return I2C_RESULT_TIMEOUT;
 }
 
+/*!
+    \brief      write data to I2C device with configurable length
+    \param[in]  slave_addr: slave device address (7-bit)
+    \param[in]  reg_addr: register address (16-bit, high byte first)
+    \param[in]  data: pointer to data buffer
+    \param[in]  length: number of bytes to write (1-255)
+    \param[out] none
+    \retval     i2c_result_t: operation result
+*/
+i2c_result_t i2c_write(uint8_t slave_addr, uint16_t reg_addr, uint8_t *data, uint8_t length) {
+    i2c_state_t state = I2C_STATE_START;
+    uint16_t timeout = 0;
+    uint8_t retry_count = 0;
+    uint8_t data_index = 0;
+
+    /* parameter validation */
+    if (data == NULL || slave_addr > 0x7F || length == 0) {
+#ifdef DEBUG_VERBOSE
+        printf("I2C write invalid param: slave=0x%02X, len=%u, data=%p\r\n", slave_addr, length, data);
+#endif
+        return I2C_RESULT_INVALID_PARAM;
+    }
+
+    while (retry_count < I2C_MAX_RETRY) {
+        switch (state) {
+            case I2C_STATE_START:
+                timeout = 0;
+                data_index = 0;
+
+                /* wait for bus to be idle */
+                while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                i2c_start_on_bus(I2C0);
+                timeout = 0;
+                state = I2C_STATE_SEND_ADDRESS;
+                break;
+
+            case I2C_STATE_SEND_ADDRESS:
+                /* 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) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* 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.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 {
+                    /* NACK received - address not acknowledged */
+                    i2c_flag_clear(I2C0, I2C_FLAG_AERR);
+                    i2c_stop_on_bus(I2C0);
+                    timeout = 0;
+#ifdef DEBUG_VERBOSE
+                    printf("I2C write failed for Error Slave Address. \n");
+#endif
+                    return I2C_RESULT_NACK;
+                }
+
+            case I2C_STATE_TRANSMIT_REG:
+                /* wait until the transmit data buffer is empty */
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* send register address, high byte first */
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+                i2c_data_transmit(I2C0, (uint8_t)(reg_addr >> 8));
+
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+                i2c_data_transmit(I2C0, (uint8_t)(reg_addr & 0xFF));
+                state = I2C_STATE_TRANSMIT_DATA;
+                break;
+
+            case I2C_STATE_TRANSMIT_DATA:
+                /* wait until the transmit data buffer is empty */
+                while (data_index < length) {
+                    if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
+                        state = I2C_STATE_ERROR;
+                        break;
+                    }
+
+                    /* send data byte */
+                    i2c_data_transmit(I2C0, data[data_index]);
+                    data_index++;
+
+                    /* check for errors */
+                    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;
+                    }
+                }
+                if(state == I2C_STATE_ERROR) break;
+
+
+                /* check if all data has been sent */
+                if (data_index >= length) {
+                    /* wait until BTC bit is set for last byte */
+                    if(_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
+                        state = I2C_STATE_ERROR;
+                        break;
+                    }
+                    state = I2C_STATE_STOP;
+                }
+                break;
+
+            case I2C_STATE_STOP:
+                /* send a stop condition to I2C bus */
+                i2c_stop_on_bus(I2C0);
+
+                timeout = 0;
+                while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* success */
+                return I2C_RESULT_SUCCESS;
+
+            case I2C_STATE_ERROR:
+                /* I2C bus error, try to reset the bus and retry */
+                i2c_bus_reset();
+
+                retry_count++;
+                if (retry_count >= I2C_MAX_RETRY) {
+#ifdef DEBUG_VERBOSE
+                    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;
+
+                /* small delay before retry */
+                delay_10us(10);
+                break;
+
+            default:
+                state = I2C_STATE_START;
+                break;
+        }
+    }
+    return I2C_RESULT_TIMEOUT;
+}
+
+/*!
+    \brief      read data from I2C device with configurable length
+    \param[in]  slave_addr: slave device address (7-bit)
+    \param[in]  reg_addr: register address (16-bit, high byte first)
+    \param[out] data: pointer to data buffer
+    \param[in]  length: number of bytes to read (1-255)
+    \retval     i2c_result_t: operation result
+*/
+i2c_result_t i2c_read(uint8_t slave_addr, uint16_t reg_addr, uint8_t *data, uint8_t length) {
+    i2c_state_t state = I2C_STATE_START;
+    uint16_t timeout = 0;
+    uint8_t retry_count = 0;
+    bool write_phase = true;
+    uint8_t data_index = 0;
+
+    /* parameter validation */
+    if (data == NULL || slave_addr > 0x7F || length == 0) {
+        return I2C_RESULT_INVALID_PARAM;
+    }
+
+    /* enable acknowledge */
+    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+
+#ifdef DEBUG_VERBOSE
+    printf("I2C read start: slave=0x%02X reg=0x%02X len=%u\r\n", slave_addr, reg_addr, length);
+#endif
+
+    while (retry_count < (uint8_t)I2C_MAX_RETRY) {
+        switch (state) {
+            case I2C_STATE_START:
+                timeout = 0;
+                data_index = 0;
+
+                /* wait for bus to be idle */
+                if(_i2c_wait_flag_clear_timeout(I2C_FLAG_I2CBSY) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* send start condition */
+                i2c_start_on_bus(I2C0);
+                state = I2C_STATE_SEND_ADDRESS;
+                break;
+
+            case I2C_STATE_SEND_ADDRESS:
+                /* wait for start condition to be sent */
+                if(_i2c_wait_flag_timeout(I2C_FLAG_SBSEND) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* send slave address */
+                if (write_phase) {
+                    /* write phase: send address with write bit */
+                    i2c_master_addressing(I2C0, (slave_addr << 1), I2C_TRANSMITTER);
+                } else {
+                    /* read phase: send address with read bit */
+                    i2c_master_addressing(I2C0, (slave_addr << 1) | 0x01, I2C_RECEIVER);
+                }
+
+                state = I2C_STATE_CLEAR_ADDRESS;
+                timeout = 0;
+                break;
+
+            case I2C_STATE_CLEAR_ADDRESS:
+                /* wait for address to be acknowledged */
+                while ((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* debug: show address ack and error flags */
+#ifdef DEBUG_VERBOSE
+                printf("I2C CLEAR_ADDRESS: write_phase=%d ADDSEND=%d AERR=%d\r\n",
+                       (int)write_phase,
+                       (int)i2c_flag_get(I2C0, I2C_FLAG_ADDSEND),
+                       (int)i2c_flag_get(I2C0, I2C_FLAG_AERR));
+#endif
+
+                if (write_phase) {
+                    /* clear address flag (write phase) */
+                    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+                    state = I2C_STATE_TRANSMIT_DATA;
+                } else {
+                    /* READ phase: handle ACK/ACKPOS based on requested length
+                       - length == 1: disable ACK before clearing ADDR
+                       - length == 2: set ACKPOS_NEXT and disable ACK before clearing ADDR
+                       - length > 2: keep ACK enabled and clear ADDR; we'll handle N-2/BTF sequence later */
+                    if (length == 1) {
+                        i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+#ifdef DEBUG_VERBOSE
+                        printf("I2C READ phase: length=1, disabling ACK before clearing ADDSEND\r\n");
+#endif
+                    } else if (length == 2) {
+                        i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
+                        i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+#ifdef DEBUG_VERBOSE
+                        printf("I2C READ phase: length=2, set ACKPOS_NEXT and disabling ACK before clearing ADDSEND\r\n");
+#endif
+                    } else {
+                        /* length > 2: keep ACK enabled so slave will clock out data */
+                        i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+#ifdef DEBUG_VERBOSE
+                        printf("I2C READ phase: length=%u (>2), keeping ACK enabled\r\n", length);
+#endif
+                    }
+
+                    /* now clear address flag to release SCL and enter data phase */
+                    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+
+                    state = I2C_STATE_RECEIVE_DATA;
+                }
+
+                timeout = 0;
+                break;
+
+            case I2C_STATE_TRANSMIT_DATA:
+                /* wait for transmit buffer to be empty */
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* send register address, high byte first */
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+                i2c_data_transmit(I2C0, (uint8_t)(reg_addr >> 8));
+
+                if(_i2c_wait_flag_timeout(I2C_FLAG_TBE) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+                i2c_data_transmit(I2C0, (uint8_t)(reg_addr & 0xFF));
+                state = I2C_STATE_RESTART;
+                break;
+
+            case I2C_STATE_RESTART:
+                /* wait for byte transfer complete */
+                if(_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+#ifdef DEBUG_VERBOSE
+                printf("I2C RESTART: after BTC, delay 5ms and issuing repeated START\r\n");
+#endif
+                /* small delay to allow slave device to prepare multi-byte data before repeated start */
+                /* increased to 5ms to improve reliability for DLPC multi-byte reads */
+                delay_ms(5);
+
+                /* generate repeated start condition */
+                i2c_start_on_bus(I2C0);
+
+                /* wait for repeated start condition to be sent */
+                if(_i2c_wait_flag_timeout(I2C_FLAG_SBSEND) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* send slave address with read bit */
+                i2c_master_addressing(I2C0, (slave_addr << 1), I2C_RECEIVER);
+
+                /* switch to read phase */
+                write_phase = false;
+                state = I2C_STATE_CLEAR_ADDRESS;
+                timeout = 0;
+#ifdef DEBUG_VERBOSE
+                printf("I2C addressing sent for read (slave=0x%02X)\r\n", slave_addr);
+#endif
+                break;
+
+            case I2C_STATE_RECEIVE_DATA:
+#ifdef DEBUG_VERBOSE
+                printf("I2C RECEIVE_DATA: expecting %u bytes\r\n", length);
+#endif
+                if (length == 1) {
+                    /* single byte read */
+                    if(_i2c_wait_flag_timeout(I2C_FLAG_RBNE) != I2C_RESULT_SUCCESS) {
+                        state = I2C_STATE_ERROR;
+                        break;
+                    }
+                    data[0] = i2c_data_receive(I2C0);
+                    state = I2C_STATE_STOP;
+                } else if (length == 2) {
+                    /* two bytes read */
+                    if(_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
+                        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;
+                } else {
+                    /* multi-byte read (length > 2) */
+                    while (data_index < length) {
+                        if (data_index < length - 2) {
+                            /* normal bytes: wait for RBNE and read with ACK */
+                            if(_i2c_wait_flag_timeout(I2C_FLAG_RBNE) != I2C_RESULT_SUCCESS) {
+                                state = I2C_STATE_ERROR;
+                                break;
+                            }
+                            data[data_index] = i2c_data_receive(I2C0);
+                            data_index++;
+                        } else if (data_index == length - 2) {
+                            /* second to last byte: wait for BTF, then disable ACK and read */
+                            if(_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
+                                state = I2C_STATE_ERROR;
+                                break;
+                            }
+                            /* disable ACK before reading N-1 byte */
+                            i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+                            /* send STOP before reading N-1 byte */
+                            i2c_stop_on_bus(I2C0);
+                            /* read N-1 byte */
+                            data[data_index] = i2c_data_receive(I2C0);
+                            data_index++;
+                        } else {
+                            /* last byte: wait for RBNE and read */
+                            if(_i2c_wait_flag_timeout(I2C_FLAG_RBNE) != I2C_RESULT_SUCCESS) {
+                                state = I2C_STATE_ERROR;
+                                break;
+                            }
+                            /* read last byte */
+                            data[data_index] = i2c_data_receive(I2C0);
+                            data_index++;
+                        }
+                    }
+                    if(state == I2C_STATE_ERROR) break;
+                    state = I2C_STATE_STOP;
+                }
+                break;
+
+            case I2C_STATE_STOP:
+                /* wait for stop condition to complete */
+                while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                /* reset ACK configuration for next operation */
+                i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+                i2c_ackpos_config(I2C0, I2C_ACKPOS_CURRENT);
+
+                /* success */
+                return I2C_RESULT_SUCCESS;
+
+            case I2C_STATE_ERROR:
+                /* I2C bus error, try to reset the bus and retry */
+#ifdef DEBUG_VERBOSE
+                printf("I2C_STATE_ERROR: resetting bus and retrying (retry_count=%u)\r\n", retry_count);
+#endif
+                i2c_bus_reset();
+
+                /* reset ACK configuration */
+                i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+                i2c_ackpos_config(I2C0, I2C_ACKPOS_CURRENT);
+
+                retry_count++;
+                if (retry_count >= I2C_MAX_RETRY) {
+#ifdef DEBUG_VERBOSE
+                    /* Print diagnostic flags to help root-cause analysis */
+                    printf("I2C read final failure after %d retries, last_state=%d\r\n", I2C_MAX_RETRY, state);
+                    printf("  FLAGS: AERR=%d BERR=%d LOSTARB=%d I2CBSY=%d\r\n",
+                           (int)i2c_flag_get(I2C0, I2C_FLAG_AERR),
+                           (int)i2c_flag_get(I2C0, I2C_FLAG_BERR),
+                           (int)i2c_flag_get(I2C0, I2C_FLAG_LOSTARB),
+                           (int)i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
+#endif
+                    return I2C_RESULT_ERROR;
+                }
+
+                /* reset state machine for retry */
+                state = I2C_STATE_START;
+                write_phase = true;
+                timeout = 0;
+
+                /* small delay before retry */
+                delay_10us(10);
+                break;
+
+            default:
+                state = I2C_STATE_START;
+                break;
+        }
+    }
+    /* timeout path: provide debug info */
+#ifdef DEBUG_VERBOSE
+    printf("I2C read timeout (end state). slave=0x%02X, len=%u\r\n", slave_addr, length);
+    printf("  FLAGS: AERR=%d BERR=%d LOSTARB=%d I2CBSY=%d\r\n",
+           (int)i2c_flag_get(I2C0, I2C_FLAG_AERR),
+           (int)i2c_flag_get(I2C0, I2C_FLAG_BERR),
+           (int)i2c_flag_get(I2C0, I2C_FLAG_LOSTARB),
+           (int)i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
+#endif
+    return I2C_RESULT_TIMEOUT;
+}
+
+/*!
+    \brief      read data from I2C device without register/sub-address phase
+    \param[in]  slave_addr: slave device address (7-bit)
+    \param[out] data: pointer to data buffer
+    \param[in]  length: number of bytes to read (1-255)
+    \retval     i2c_result_t: operation result
+*/
+i2c_result_t i2c_read_raw(uint8_t slave_addr, uint8_t *data, uint8_t length)
+{
+    i2c_state_t state = I2C_STATE_START;
+    uint16_t timeout = 0;
+    uint8_t retry_count = 0;
+    uint8_t data_index = 0;
+
+    if (data == NULL || slave_addr > 0x7F || length == 0) {
+        return I2C_RESULT_INVALID_PARAM;
+    }
+
+    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+
+    while (retry_count < (uint8_t)I2C_MAX_RETRY) {
+        switch (state) {
+            case I2C_STATE_START:
+                timeout = 0;
+                data_index = 0;
+
+                if (_i2c_wait_flag_clear_timeout(I2C_FLAG_I2CBSY) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                i2c_start_on_bus(I2C0);
+                state = I2C_STATE_SEND_ADDRESS;
+                break;
+
+            case I2C_STATE_SEND_ADDRESS:
+                if (_i2c_wait_flag_timeout(I2C_FLAG_SBSEND) != I2C_RESULT_SUCCESS) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                i2c_master_addressing(I2C0, (slave_addr << 1), I2C_RECEIVER);
+                state = I2C_STATE_CLEAR_ADDRESS;
+                timeout = 0;
+                break;
+
+            case I2C_STATE_CLEAR_ADDRESS:
+                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;
+                }
+                if (i2c_flag_get(I2C0, I2C_FLAG_AERR)) {
+                    i2c_flag_clear(I2C0, I2C_FLAG_AERR);
+                    i2c_stop_on_bus(I2C0);
+                    return I2C_RESULT_NACK;
+                }
+
+                if (length == 1) {
+                    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+                } else if (length == 2) {
+                    i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
+                    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+                } else {
+                    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+                }
+
+                i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
+                state = I2C_STATE_RECEIVE_DATA;
+                timeout = 0;
+                break;
+
+            case I2C_STATE_RECEIVE_DATA:
+                if (length == 1) {
+                    if (_i2c_wait_flag_timeout(I2C_FLAG_RBNE) != I2C_RESULT_SUCCESS) {
+                        state = I2C_STATE_ERROR;
+                        break;
+                    }
+                    data[0] = i2c_data_receive(I2C0);
+                    state = I2C_STATE_STOP;
+                } else if (length == 2) {
+                    if (_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
+                        state = I2C_STATE_ERROR;
+                        break;
+                    }
+                    i2c_stop_on_bus(I2C0);
+                    data[0] = i2c_data_receive(I2C0);
+                    data[1] = i2c_data_receive(I2C0);
+                    state = I2C_STATE_STOP;
+                } else {
+                    while (data_index < length) {
+                        if (data_index < length - 2) {
+                            if (_i2c_wait_flag_timeout(I2C_FLAG_RBNE) != I2C_RESULT_SUCCESS) {
+                                state = I2C_STATE_ERROR;
+                                break;
+                            }
+                            data[data_index++] = i2c_data_receive(I2C0);
+                        } else if (data_index == length - 2) {
+                            if (_i2c_wait_flag_timeout(I2C_FLAG_BTC) != I2C_RESULT_SUCCESS) {
+                                state = I2C_STATE_ERROR;
+                                break;
+                            }
+                            i2c_ack_config(I2C0, I2C_ACK_DISABLE);
+                            i2c_stop_on_bus(I2C0);
+                            data[data_index++] = i2c_data_receive(I2C0);
+                        } else {
+                            if (_i2c_wait_flag_timeout(I2C_FLAG_RBNE) != I2C_RESULT_SUCCESS) {
+                                state = I2C_STATE_ERROR;
+                                break;
+                            }
+                            data[data_index++] = i2c_data_receive(I2C0);
+                        }
+                    }
+                    if (state == I2C_STATE_ERROR) break;
+                    state = I2C_STATE_STOP;
+                }
+                break;
+
+            case I2C_STATE_STOP:
+                while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
+                    timeout++;
+                }
+                if (timeout >= I2C_TIME_OUT) {
+                    state = I2C_STATE_ERROR;
+                    break;
+                }
+
+                i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+                i2c_ackpos_config(I2C0, I2C_ACKPOS_CURRENT);
+                return I2C_RESULT_SUCCESS;
+
+            case I2C_STATE_ERROR:
+                i2c_bus_reset();
+                i2c_ack_config(I2C0, I2C_ACK_ENABLE);
+                i2c_ackpos_config(I2C0, I2C_ACKPOS_CURRENT);
+
+                retry_count++;
+                if (retry_count >= I2C_MAX_RETRY) {
+                    return I2C_RESULT_ERROR;
+                }
+
+                state = I2C_STATE_START;
+                timeout = 0;
+                delay_10us(10);
+                break;
+
+            default:
+                state = I2C_STATE_START;
+                break;
+        }
+    }
+
+    return I2C_RESULT_TIMEOUT;
+}
+
 #ifdef DEBUG_VERBOSE
 /*!
     \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
 */

Src/ldc1612.c

@@ -4,6 +4,13 @@
 
 #include "ldc1612.h"
 
+#ifdef LDC_DEBUG
+    #include <stdio.h>
+    #define LDC1612_DEBUG(fmt, ...) printf("[LDC1612] " fmt "\n", ##__VA_ARGS__)
+#else
+    #define LDC1612_DEBUG(fmt, ...)
+#endif
+
 /*!
     \brief      写入寄存器
     \param[in]  reg_addr: 寄存器地址
@@ -53,16 +60,38 @@ static uint16_t ldc1612_calculate_freq_divider(uint8_t channel) {
     float sensor_freq;
 
     sensor_freq = 1 / (2 * 3.14 * sqrt(COIL_L_UH * COIL_C_PF * pow(10, -18))) * pow(10, -6);
-    fin_div = (uint16_t) (sensor_freq / 8.75 + 1);
+    if (sensor_freq <= 8.75) {
-
+        fin_div = LDC1612_FIN_DIV_1;
-    if (fin_div * 4 < 40) {
+    } else if (sensor_freq <= 17.5) {
-        freq_div = 2;
+        fin_div = LDC1612_FIN_DIV_2;
+    } else if (sensor_freq <= 35.0) {
+        fin_div = LDC1612_FIN_DIV_4;
     } else {
-        freq_div = 4;
+        LDC1612_DEBUG("Error: Sensor frequency (%.2f MHz) exceeds maximum limit!", sensor_freq);
+        return 0;
+        
     }
 
-    value = fin_div << 12;
+/* 
-    value |= freq_div;
+    Fref为参考时钟频率，单位MHz，必须小于35MHz，如果输入时钟为外部时钟40MHz，则需要分频
+    LDC1612_EXT_CLK_MHZ为外部时钟频率，单位MHz
+    Fin为传感器谐振频率，单位MHz。
+    必须满足：Fin < Fref / 4
+    通常高精度应用，采用外部40MHz，2分频，Fin不应超5MHz。
+*/
+    if (LDC1612_EXT_CLK_MHZ >= 35)
+    {
+        freq_div = LDC1612_FREF_DIV_2;
+    } else {
+        freq_div = LDC1612_FREF_DIV_1;
+    }
+
+    if (sensor_freq >= (LDC1612_EXT_CLK_MHZ / freq_div) / 4)
+    {
+        LDC1612_DEBUG("Warning: Sensor frequency (%.2f MHz) is too high for the given reference clock (%.2f MHz)!\n", sensor_freq, (float)(LDC1612_EXT_CLK_MHZ / freq_div));
+    }
+
+    value = LDC1612_CLOCK_DIVIDER_GEN(fin_div, freq_div);
     
     return value;
 }
@@ -119,11 +148,17 @@ ldc1612_status_t ldc1612_init(void) {
 */
 ldc1612_status_t ldc1612_config_single_channel(uint8_t channel) {
     i2c_result_t status;
+    uint16_t freq_divider;
 
     if (channel > 1) {
         return LDC1612_STATUS_INVALID_PARAM;
     }
 
+    freq_divider = ldc1612_calculate_freq_divider(channel);
+    if (freq_divider == 0) {
+        return LDC1612_STATUS_INVALID_PARAM;
+    }
+
     /* 配置顺序严格按照TI官方文档要求 */
     
     /* Step 1: 确保传感器处于睡眠模式 - 配置前必须 */
@@ -132,28 +167,34 @@ ldc1612_status_t ldc1612_config_single_channel(uint8_t channel) {
     delay_ms(10);
 
     /* Step 2: 配置频率分频 - 必须在其他配置之前 */
-    uint16_t freq_divider = ldc1612_calculate_freq_divider(channel);
+    status = ldc1612_write_register(SET_FREQ_REG_START + channel, freq_divider);
-    ldc1612_write_register(SET_FREQ_REG_START + channel, freq_divider);
+    if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
     delay_ms(5);
 
     /* Step 3: 配置LC稳定时间 - 影响测量精度 */
-    ldc1612_write_register(SET_SETTLECOUNT_REG_START + channel, LDC1612_SETTLECOUNT_CH0);
+    status = ldc1612_write_register(SET_SETTLECOUNT_REG_START + channel, LDC1612_SETTLECOUNT_CH0);
+    if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
 
     /* Step 4: 配置转换时间 - 影响测量速度和精度 */
-    ldc1612_write_register(SET_CONVERSION_TIME_REG_START + channel, LDC1612_RCOUNT_TIME_CH0);
+    status = ldc1612_write_register(SET_CONVERSION_TIME_REG_START + channel, LDC1612_RCOUNT_TIME_CH0);
+    if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
 
     /* Step 5: 配置转换偏移 */
-    ldc1612_write_register(SET_CONVERSION_OFFSET_REG_START + channel, SET_CONVERSION_OFFSET_CH0);
+    status = ldc1612_write_register(SET_CONVERSION_OFFSET_REG_START + channel, SET_CONVERSION_OFFSET_CH0);
+    if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
 
     /* Step 6: 配置驱动电流 - 影响传感器灵敏度 */
-    ldc1612_write_register(SET_DRIVER_CURRENT_REG + channel, LDC1612_DRIVE_CURRENT);
+    status = ldc1612_write_register(SET_DRIVER_CURRENT_REG + channel, LDC1612_DRIVE_CURRENT);
+    if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
 
     /* 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(MUX_CONFIG_REG, LDC1612_MUX_CONFIG);
+    status = ldc1612_write_register(MUX_CONFIG_REG, LDC1612_MUX_CONFIG);
+    if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
 
     /* Step 8: 配置错误输出 */
-    ldc1612_write_register(ERROR_CONFIG_REG, LDC1612_ERROR_CONFIG);
+    status = ldc1612_write_register(ERROR_CONFIG_REG, LDC1612_ERROR_CONFIG_DEFAULT);
+    if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
 
     /* Step 9: 最后启动传感器 - 必须最后一步 */
     status = ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SENSOR_CONFIG_CH0);
@@ -174,11 +215,11 @@ 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 * 2), value);
+    LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERSION_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 + 1 + (channel * 2), value);
+    LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERSION_RESULT_REG_START + 1 + (channel * 2), value);
     raw_value |= (uint32_t)(((uint16_t)value[0] << 8) | value[1]);
 
     
@@ -186,7 +227,7 @@ uint32_t ldc1612_get_raw_channel_result(uint8_t channel) {
     if (calibration_value == 0x0FFFFFFF) {
         return 0xF0000000; /* No coil */
     }
-    if (LDC1612_ERROR_CONFIG & 0xF800) {
+    if (LDC1612_ERROR_CONFIG_DEFAULT & 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 */
@@ -219,7 +260,7 @@ void ldc1612_drvie_current_detect(uint8_t channel) {
 
     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_DEBUG("init value: 0x%x\tdrive current: 0x%x\n", init_value, drive_current);
 }
 
 /** @brief Get sensor status register
@@ -243,4 +284,64 @@ bool ldc1612_is_data_ready(uint8_t channel) {
         return (status & 0x0080) != 0; // DRDY_1 bit
     }
     return false;
-}
+}
+
+/*!
+    \brief      检查并记录LDC1612的状态和错误
+    \param[in]  none
+    \param[out] none
+    \retval     读取到的原始状态寄存器值
+*/
+uint16_t ldc1612_check_status_and_log_errors(void) {
+    uint16_t status;
+    i2c_result_t i2c_status = ldc1612_read_register(SENSOR_STATUS_REG, &status);
+
+    if (i2c_status != I2C_RESULT_SUCCESS) {
+        LDC1612_DEBUG("Failed to read STATUS register!");
+        return 0;
+    }
+
+    LDC1612_DEBUG("--- LDC1612 Status Check (Value: 0x%04X) ---", status);
+
+    // 检查数据就绪状态
+    if (status & LDC1612_STATUS_DRDY) {
+        LDC1612_DEBUG("  [OK] Data is ready.");
+    }
+    if (status & LDC1612_STATUS_UNREAD_CH0) {
+        LDC1612_DEBUG("  [INFO] Channel 0 has unread data.");
+    }
+    if (status & LDC1612_STATUS_UNREAD_CH1) {
+        LDC1612_DEBUG("  [INFO] Channel 1 has unread data.");
+    }
+
+    // 检查是否有任何错误标志
+    if ((status & 0x3F00) == 0) { // 检查所有错误位的掩码
+        LDC1612_DEBUG("  [OK] No errors detected.");
+    } else {
+        uint8_t err_chan = (status & LDC1612_STATUS_ERR_CHAN_MASK) >> 14;
+        LDC1612_DEBUG("  [ERROR] An error occurred on Channel %d.", err_chan);
+
+        if (status & LDC1612_STATUS_ERR_UR) {
+            LDC1612_DEBUG("    - Underflow Error: Conversion result is less than OFFSET.");
+        }
+        if (status & LDC1612_STATUS_ERR_OR) {
+            LDC1612_DEBUG("    - Overflow Error: Conversion result is at maximum.");
+        }
+        if (status & LDC1612_STATUS_ERR_WD) {
+            LDC1612_DEBUG("    - Watchdog Timeout: Sensor failed to complete conversion in time.");
+        }
+        if (status & LDC1612_STATUS_ERR_AHE) {
+            LDC1612_DEBUG("    - Amplitude High Error: Sensor oscillation amplitude > 1.8V.");
+        }
+        if (status & LDC1612_STATUS_ERR_ALE) {
+            LDC1612_DEBUG("    - Amplitude Low Error: Sensor oscillation amplitude < 1.2V.");
+        }
+        if (status & LDC1612_STATUS_ERR_ZC) {
+            LDC1612_DEBUG("    - Zero-Count Error: Reference count is zero, check clock.");
+        }
+    }
+    LDC1612_DEBUG("-------------------------------------------------");
+
+    // 读取STATUS寄存器会自动清除错误标志，但不会清除DRDY和UNREADCONV标志
+    return status;
+}

Src/main.c

@@ -51,12 +51,18 @@ OF SUCH DAMAGE.
 */
 int main(void)
 {
+    // nvic_vector_table_set(NVIC_VECTTAB_FLASH, 0x2000);
+
+    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"};
@@ -93,12 +99,6 @@ int main(void)
         delay_ms(10);
         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);

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) {}
+    while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
-    usart_data_transmit(USART0, (uint8_t)ch);
+    usart_data_transmit(RS485_PHY, (uint8_t)ch);
     return ch;
 }

Src/system_gd32e23x.c

@@ -41,7 +41,7 @@
 #define __HXTAL           (HXTAL_VALUE)            /* high speed crystal oscillator frequency */
 #define __SYS_OSC_CLK     (__IRC8M)                /* main oscillator frequency */
 
-#define VECT_TAB_OFFSET  (uint32_t)0x00            /* vector table base offset */
+#define VECT_TAB_OFFSET  (uint32_t)0x2000            /* vector table base offset */
 
 /* select a system clock by uncommenting the following line */
 //#define __SYSTEM_CLOCK_8M_HXTAL              (__HXTAL)

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);
+        // 在这里添加空闲中断处理逻辑
+    }
+}

cmake/arm-none-eabi-gcc.cmake

@@ -1,5 +1,61 @@
-# You can change TOOLCHAIN_DIRECTORY if you want to use different toolchain.
+# The project never stores a compiler package. Each machine supplies a path.
-set(TOOLCHAIN_DIRECTORY "${CMAKE_SOURCE_DIR}/Toolchain/xpack-arm-none-eabi-gcc-11.3.1-1.1/bin")
+# TOOLCHAIN_DIRECTORY (CMake cache) has priority over the environment variable.
+# GD32_GCC_ENV_VAR lets a workstation use a different variable name if needed.
+set(TOOLCHAIN_DIRECTORY "" CACHE PATH "Path to arm-none-eabi toolchain bin directory")
+set(GD32_GCC_ENV_VAR "GD32_GCC_BIN" CACHE STRING "Environment variable containing the ARM GCC path")
+set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES TOOLCHAIN_DIRECTORY GD32_GCC_ENV_VAR)
+
+if(GD32_GCC_ENV_VAR AND NOT GD32_GCC_ENV_VAR MATCHES "^GD32_[A-Za-z0-9_]+$")
+    message(FATAL_ERROR "GD32_GCC_ENV_VAR must use the GD32_ prefix: ${GD32_GCC_ENV_VAR}")
+endif()
+
+if(NOT TOOLCHAIN_DIRECTORY AND GD32_GCC_ENV_VAR)
+    if(DEFINED ENV{${GD32_GCC_ENV_VAR}} AND NOT "$ENV{${GD32_GCC_ENV_VAR}}" STREQUAL "")
+        file(TO_CMAKE_PATH "$ENV{${GD32_GCC_ENV_VAR}}" TOOLCHAIN_DIRECTORY)
+    endif()
+endif()
+
+if(NOT TOOLCHAIN_DIRECTORY)
+    message(FATAL_ERROR
+        "Cannot find ARM GCC toolchain. Set ${GD32_GCC_ENV_VAR} in the machine environment "
+        "or pass -DTOOLCHAIN_DIRECTORY=<toolchain-bin>.")
+endif()
+
+file(TO_CMAKE_PATH "${TOOLCHAIN_DIRECTORY}" TOOLCHAIN_DIRECTORY)
+get_filename_component(TOOLCHAIN_DIRECTORY "${TOOLCHAIN_DIRECTORY}" ABSOLUTE)
+
+if(WIN32)
+    set(TOOLCHAIN_SUFFIX ".exe")
+else()
+    set(TOOLCHAIN_SUFFIX "")
+endif()
+
+# Accept either the package root or its bin directory.
+if(NOT EXISTS "${TOOLCHAIN_DIRECTORY}/arm-none-eabi-gcc${TOOLCHAIN_SUFFIX}" AND
+   EXISTS "${TOOLCHAIN_DIRECTORY}/bin/arm-none-eabi-gcc${TOOLCHAIN_SUFFIX}")
+    set(TOOLCHAIN_DIRECTORY "${TOOLCHAIN_DIRECTORY}/bin")
+endif()
+
+set(_ARM_GCC_EXECUTABLE "${TOOLCHAIN_DIRECTORY}/arm-none-eabi-gcc${TOOLCHAIN_SUFFIX}")
+
+set(_TOOLCHAIN_BINARIES
+    arm-none-eabi-gcc
+    arm-none-eabi-g++
+    arm-none-eabi-gdb
+    arm-none-eabi-ar
+    arm-none-eabi-ranlib
+    arm-none-eabi-as
+    arm-none-eabi-ld
+    arm-none-eabi-objcopy
+    arm-none-eabi-objdump
+    arm-none-eabi-size
+)
+foreach(_binary IN LISTS _TOOLCHAIN_BINARIES)
+    if(NOT EXISTS "${TOOLCHAIN_DIRECTORY}/${_binary}${TOOLCHAIN_SUFFIX}")
+        message(FATAL_ERROR
+            "ARM GCC toolchain is incomplete; missing ${_binary}${TOOLCHAIN_SUFFIX} in ${TOOLCHAIN_DIRECTORY}")
+    endif()
+endforeach()
 
 set(CMAKE_C_FLAGS_DEBUG "")
 set(CMAKE_CXX_FLAGS_DEBUG "")
@@ -12,10 +68,6 @@ set(CMAKE_COLOR_DIAGNOSTICS ON)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE INTERNAL "")
 
-if(WIN32)
-    set(TOOLCHAIN_SUFFIX ".exe")
-endif()
-
 set(CMAKE_SYSTEM_NAME               Generic)
 set(CMAKE_SYSTEM_PROCESSOR          arm)
 
@@ -28,21 +80,48 @@ set(FLAGS                           "-mcpu=cortex-m23 -std=gnu11 -fstack-usage -
 set(ASM_FLAGS                       "-x assembler-with-cpp")
 set(CPP_FLAGS                       "-fno-rtti -fno-exceptions -fno-threadsafe-statics")
 
-set(CMAKE_C_COMPILER                ${TOOLCHAIN_PREFIX}gcc${TOOLCHAIN_SUFFIX})
+set(_REQUESTED_C_COMPILER "${TOOLCHAIN_PREFIX}gcc${TOOLCHAIN_SUFFIX}")
-set(CMAKE_CXX_COMPILER              ${TOOLCHAIN_PREFIX}g++${TOOLCHAIN_SUFFIX})
+if(DEFINED CMAKE_C_COMPILER AND CMAKE_C_COMPILER AND
-set(CMAKE_ASM_COMPILER              ${TOOLCHAIN_PREFIX}gcc${TOOLCHAIN_SUFFIX})
+   IS_ABSOLUTE "${CMAKE_C_COMPILER}" AND
+   NOT CMAKE_C_COMPILER STREQUAL "${_REQUESTED_C_COMPILER}")
+    message(FATAL_ERROR
+        "The build directory is already configured for a different ARM GCC compiler:\n"
+        "  cached:  ${CMAKE_C_COMPILER}\n"
+        "  selected: ${_REQUESTED_C_COMPILER}\n"
+        "Delete the build directory or run CMake Tools 'Delete Cache and Reconfigure'.")
+endif()
+
+set(CMAKE_C_COMPILER                "${_REQUESTED_C_COMPILER}")
+set(CMAKE_CXX_COMPILER              "${TOOLCHAIN_PREFIX}g++${TOOLCHAIN_SUFFIX}")
+set(CMAKE_ASM_COMPILER              "${TOOLCHAIN_PREFIX}gcc${TOOLCHAIN_SUFFIX}")
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAGS} ${CPP_FLAGS}")
 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${FLAGS} ${ASM_FLAGS}")
-set(CMAKE_OBJCOPY                   ${TOOLCHAIN_PREFIX}objcopy${TOOLCHAIN_SUFFIX})
+set(CMAKE_AR                        "${TOOLCHAIN_PREFIX}ar${TOOLCHAIN_SUFFIX}")
-set(CMAKE_SIZE                      ${TOOLCHAIN_PREFIX}size${TOOLCHAIN_SUFFIX})
+set(CMAKE_RANLIB                    "${TOOLCHAIN_PREFIX}ranlib${TOOLCHAIN_SUFFIX}")
-set(CMAKE_OBJDUMP                   ${TOOLCHAIN_PREFIX}objdump${TOOLCHAIN_SUFFIX})
+set(CMAKE_OBJCOPY                   "${TOOLCHAIN_PREFIX}objcopy${TOOLCHAIN_SUFFIX}")
-set(CMAKE_AS                        ${TOOLCHAIN_PREFIX}as${TOOLCHAIN_SUFFIX})
+set(CMAKE_SIZE                      "${TOOLCHAIN_PREFIX}size${TOOLCHAIN_SUFFIX}")
-set(CMAKE_LD                        ${TOOLCHAIN_PREFIX}ld${TOOLCHAIN_SUFFIX})
+set(CMAKE_OBJDUMP                   "${TOOLCHAIN_PREFIX}objdump${TOOLCHAIN_SUFFIX}")
+set(CMAKE_AS                        "${TOOLCHAIN_PREFIX}as${TOOLCHAIN_SUFFIX}")
+set(CMAKE_LD                        "${TOOLCHAIN_PREFIX}ld${TOOLCHAIN_SUFFIX}")
+set(CMAKE_LINKER                   "${TOOLCHAIN_PREFIX}ld${TOOLCHAIN_SUFFIX}")
+
+execute_process(
+    COMMAND "${_ARM_GCC_EXECUTABLE}" --version
+    OUTPUT_VARIABLE _ARM_GCC_VERSION_OUTPUT
+    ERROR_VARIABLE _ARM_GCC_VERSION_ERROR
+    RESULT_VARIABLE _ARM_GCC_VERSION_RESULT
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+if(NOT _ARM_GCC_VERSION_RESULT EQUAL 0)
+    message(FATAL_ERROR "Unable to execute ${_ARM_GCC_EXECUTABLE}: ${_ARM_GCC_VERSION_ERROR}")
+endif()
+string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" _ARM_GCC_VERSION "${_ARM_GCC_VERSION_OUTPUT}")
+message(STATUS "Using ARM GCC ${_ARM_GCC_VERSION} from ${TOOLCHAIN_DIRECTORY}")
 
 set(CMAKE_EXECUTABLE_SUFFIX_ASM     ".elf")
 set(CMAKE_EXECUTABLE_SUFFIX_C       ".elf")
 set(CMAKE_EXECUTABLE_SUFFIX_CXX     ".elf")
 
-set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

cmake/project_config.cmake

@@ -1,16 +1,19 @@
 # Project basic info
 set(PROJECT_NAME "LDC1612")
+set(BOARD_TYPE_CODE 23)
 set(VERSION_MAJOR 1)
 set(VERSION_MINOR 0)
-set(VERSION_PATCH 0)
+set(VERSION_PATCH 2)
 set(VERSION "V${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
 string(TIMESTAMP BUILD_DATE "%Y-%m-%d")
 
 # 编译条件（如IIC类型等）
-# set(IIC_TYPE "AutoDetectDriveCurrent")
+# Example: HW-IIC_APP / HW-IIC_Bootloader
-set(IIC_TYPE "HW-IIC")
+# set(BUILD_VARIANT "AutoDetectDriveCurrent")
+# set(BUILD_VARIANT "HW-IIC")
+set(BUILD_VARIANT "APP")
 
 # 其它自定义宏
-add_definitions(-DIIC_TYPE=${IIC_TYPE})
+add_definitions(-DBUILD_VARIANT=${BUILD_VARIANT})
 add_definitions(-DPROJECT_VERSION="${VERSION}")
 add_definitions(-DBUILD_DATE="${BUILD_DATE}")

cmake/version.h.in

@@ -0,0 +1,7 @@
+#pragma once
+
+/* Auto-generated from CMake VERSION_* variables. Do not edit directly. */
+#define BOARD_TYPE_CODE @BOARD_TYPE_CODE@
+#define FW_VERSION_MAJOR @VERSION_MAJOR@
+#define FW_VERSION_MINOR @VERSION_MINOR@
+#define FW_VERSION_PATCH @VERSION_PATCH@

start-vscode-no-openocd-env.bat

@@ -1,3 +0,0 @@
-@echo off
-set OPENOCD_SCRIPTS=
-start "" "D:\Microsoft VS Code\Code.exe"