hulk/ldc1612_cmake_vscode
1
0
Fork 0
generated from hulk/gd32e23x_template_cmake_vscode
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: hulk:dev_more_information
Branches Tags
hulk:main hulk:dev_feature_iic_more_byte hulk:dev hulk:dev_more_information
..
compare: hulk:b60cfbee974e3c59657fddb6c3805c02d924fd65
Branches Tags
hulk:dev_feature_iic_more_byte hulk:dev hulk:dev_more_information hulk:main

2 Commits
dev_more_i ... b60cfbee97

Author SHA1 Message Date
yelvlab
b60cfbee97 Delete useless file 2025-08-17 03:10:50 +08:00
yelvlab
9b3cd46b09 clear repo 2025-08-17 03:06:46 +08:00
10 changed files with 1 additions and 2177 deletions
Expand all files Collapse all files

139
I2C_IMPROVEMENTS.md
View File

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

28
Inc/sensor_example.h
View File

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

281
LDC1612_COIL_TEST_GUIDE.md
View File

@@ -1,281 +0,0 @@
# LDC1612 线圈性能测试指南
## 概述
这份文档详细说明如何使用M1-M9命令来测试和分析LDC1612线圈的性能特性。
## 测试命令总览
| 命令 | 功能 | 响应字节数 | 主要用途 |
|------|------|-----------|----------|
| M1 | 强制读取传感器数据 | 4 | 获取原始传感器数据 |
| M2 | 通信测试 | 4 | 验证通信链路 |
| M3 | 高电流驱动测试 | 6 | 测试提高驱动电流的效果 |
| M4 | 寄存器诊断 | 8 | 检查配置寄存器状态 |
| M5 | 最高电流启动测试 | 8 | 极限参数启动尝试 |
| M6 | 芯片功能验证 | 12 | 验证LDC1612芯片正常工作 |
| M7 | 保守参数测试 | 10 | 使用保守配置测试 |
| M8 | 极端参数测试 | 6 | 使用极端配置强制启动 |
| M9 | 多频率特性测试 | 8 | 对比不同频率配置效果 |
---
## 详细命令分析
### M1 命令 - 强制读取传感器数据
**命令**: `D5 03 02 4D 31 83`
**响应**: `B5 F0 04 [4字节数据] CRC`
**响应数据解析**:
```
[0-3]: 32位原始传感器数据（大端序）
- 高4位：错误标志（通常忽略）
- 低28位：有效传感器数据
```
**使用场景**: 在您已经有工作配置的情况下，直接获取传感器数据
---
### M2 命令 - 通信测试
**命令**: `D5 03 02 4D 32 84`
**响应**: `B5 F0 04 DD CC BB AA [CRC]`
**分析要点**: 如果响应不是固定的`DD CC BB AA`，说明通信有问题
---
### M3 命令 - 高电流驱动测试
**命令**: `D5 03 02 4D 33 85`
**响应**: `B5 F0 06 [6字节数据] CRC`
**响应数据解析**:
```
[0-1]: 传感器状态寄存器（大端序）
bit[7]: DRDY_1 - 通道1数据就绪
bit[6]: DRDY_0 - 通道0数据就绪
bit[5]: UNREAD_CONV - 未读转换结果
bit[4]: ERR_ZC - 零计数错误
bit[3]: ERR_AE - 幅度错误（重点关注）
bit[2]: ERR_WD - 看门狗超时
bit[1]: ERR_OR - 过量程错误
bit[0]: ERR_UR - 欠量程错误
[2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
[3]: 0xA0 - 高电流测试标记
[4]: 幅度错误专用标志 (0xAE=有幅度错误, 0x00=无)
[5]: 0x33 - M3命令标记
```
**分析要点**:
- 如果[0-1]从0x0008变为其他值，说明高电流有效果
- 如果[2]变为0x01，说明数据开始就绪
- 如果[4]变为0x00，说明幅度错误消失
---
### M4 命令 - 寄存器诊断
**命令**: `D5 03 02 4D 34 86`
**响应**: `B5 F0 08 [8字节数据] CRC`
**响应数据解析**:
```
[0-1]: 状态寄存器 (0x18) - 当前传感器状态
[2-3]: 传感器配置寄存器 (0x1A) - 传感器工作模式
期望值: 0x1601 (活动模式，单通道)
[4-5]: 驱动电流寄存器 (0x1E) - 当前驱动电流设置
常见值: 0x9000(默认), 0xA000(高), 0xF800(最高)
[6]: I2C读取状态 (0x4F='O'=成功, 0xEE=失败)
[7]: 0x44 - M4命令标记
```
**分析要点**:
- [2-3]应该是0x1601，如果不是说明配置异常
- [4-5]显示实际的驱动电流设置
- [6]必须是0x4F，否则I2C通信有问题
---
### M5 命令 - 最高电流启动测试
**命令**: `D5 03 02 4D 35 87`
**响应**: `B5 F0 08 [8字节数据] CRC`
**响应数据解析**:
```
[0-1]: 传感器状态寄存器（启动后状态）
[2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
[3-4]: 实际驱动电流设置值（应该是0xF800）
[5]: 幅度错误专用标志 (0xAE=仍有错误, 0x00=错误消失)
[6]: 0x55 - M5命令标记
[7]: 0xF8 - 最高电流标记
```
**分析要点**:
- 这是最激进的启动尝试
- 如果[5]仍是0xAE，说明线圈物理特性不兼容
- [3-4]验证电流设置是否生效
---
### M6 命令 - 芯片功能验证
**命令**: `D5 03 02 4D 36 88`
**响应**: `B5 F0 0C [12字节数据] CRC`
**响应数据解析**:
```
[0-1]: 写入测试值 (0x9000)
[2-3]: 读取回的值
[4-5]: 制造商ID (应该是0x5449="TI")
[6-7]: 设备ID (应该是0x3055)
[8-9]: 当前状态寄存器
[10]: ID读取状态 (0x4F=成功, 0xEE=失败)
[11]: 0x66 - M6命令标记
```
**分析要点**:
- [4-5]必须是0x5449，确认是正品TI芯片
- [6-7]应该是0x3055，确认是LDC1612型号
- [10]必须是0x4F，确认芯片通信正常
---
### M7 命令 - 保守参数测试
**命令**: `D5 03 02 4D 37 89`
**响应**: `B5 F0 0A [10字节数据] CRC`
**响应数据解析**:
```
[0-1]: 状态寄存器
[2]: 数据就绪标志
[3-4]: 实际频率分频器设置 (0x2000=较低频率)
[5]: 幅度错误标志 (0xAE=有错误, 0x00=无)
[6]: 欠量程错误标志 (0x01=有, 0x00=无)
[7]: 过量程错误标志 (0x02=有, 0x00=无)
[8]: 0x77 - M7命令标记
[9]: 0x20 - 低频标记
```
**分析要点**:
- 使用保守配置（低频率、长稳定时间）
- [6][7]指示电感值范围问题
---
### M8 命令 - 极端参数测试
**命令**: `D5 03 02 4D 38 8A`
**响应**: `B5 F0 06 [6字节数据] CRC`
**响应数据解析**:
```
[0-1]: 传感器状态寄存器
[2]: 数据就绪标志
[3]: 幅度错误标志 (0xAE=仍有错误, 0x00=错误消失)
[4]: 0x88 - M8命令标记
[5]: 0xEE - 极端测试标记
```
**分析要点**:
- 使用极低频率(0x4000)和最大电流(0xFF00)
- 如果[3]仍是0xAE，说明线圈根本无法工作
---
### M9 命令 - 多频率特性测试
**命令**: `D5 03 02 4D 39 8B`
**响应**: `B5 F0 08 [8字节数据] CRC`
**响应数据解析**:
```
[0-1]: 高频测试状态
[2]: 高频就绪标志 (0x01=就绪, 0x00=未就绪)
[3-4]: 低频测试状态
[5]: 低频就绪标志 (0x01=就绪, 0x00=未就绪)
[6]: 0x99 - M9命令标记
[7]: 0xAA - 多频测试标记
```
**分析要点**:
- 对比高频低电流 vs 低频高电流的效果
- 如果某个配置工作，说明找到了合适的参数范围
---
## 线圈诊断流程
### 步骤1: 基础验证
1. 执行M2确认通信正常
2. 执行M6确认芯片功能正常
### 步骤2: 状态诊断
1. 执行M4查看当前配置状态
2. 如果状态寄存器是0x0008，说明有幅度错误
### 步骤3: 参数优化测试
1. 执行M3测试高电流是否有改善
2. 执行M5测试最高电流极限启动
3. 执行M7测试保守参数配置
4. 执行M8测试极端参数配置
### 步骤4: 特性分析
1. 执行M9进行多频率对比测试
2. 分析哪种配置最接近成功
### 步骤5: 数据读取
1. 如果找到工作配置，执行M1获取数据
2. 如果所有测试都失败，确认线圈不兼容
---
## 常见问题诊断
### 所有命令都显示幅度错误 (0x0008)
**可能原因**:
- 线圈电感值超出范围 (< 1μH 或 > 18mH)
- 线圈Q值过低 (< 5)
- 线圈物理损坏（开路或短路）
- 线圈周围有金属干扰
**解决方案**:
1. 用万用表测量线圈直流电阻
2. 用LCR表测量线圈电感值和Q值
3. 更换符合规格的线圈
### M6显示错误的设备ID
**可能原因**:
- 使用了非正品芯片
- I2C地址配置错误
- 芯片损坏
### 部分命令有效果但数据不稳定
**可能原因**:
- 线圈参数在边界范围
- 外部干扰
- 电源噪声
**解决方案**:
1. 优化PCB布局
2. 改善电源滤波
3. 调整线圈参数
---
## 推荐线圈规格
```
电感值: 10μH - 1mH
Q值: > 15 (在工作频率下)
线径: 0.1-0.5mm 漆包线
绕制: 单层紧密绕制，避免交叉
工作频率: 1-10MHz
直流电阻: 1-50欧姆
```
---
## 总结
通过这套完整的测试命令，您可以：
1. 快速诊断线圈兼容性问题
2. 找到最优的工作参数
3. 验证硬件和软件功能
4. 分析线圈的频率特性
如果M8和M9都显示幅度错误，强烈建议更换线圈或调整线圈参数。

222
LDC1612_CONFIG_SEQUENCE.md
View File

@@ -1,222 +0,0 @@
# LDC1612 正确配置顺序说明
## 📋 **配置顺序重要性**
LDC1612的配置顺序**非常关键**，错误的顺序可能导致：
- 传感器无法正常工作
- 数据不准确
- 功耗异常
- 系统不稳定
## 🔄 **完整初始化配置流程**
### **阶段一：硬件复位和验证**
```c
ldc1612_status_t ldc1612_complete_init(void) {
/* 1. 硬件复位 - 必须第一步 */
ldc1612_reset_sensor();
delay_ms(100); // 重要：等待复位完成
/* 2. 验证设备身份 */
uint16_t manufacturer_id = ldc1612_get_manufacturer_id();
uint16_t device_id = ldc1612_get_deveice_id();
if (manufacturer_id != 0x5449 || device_id != 0x3055) {
return LDC1612_STATUS_ERROR;
}
/* 3. 进入配置阶段 */
return ldc1612_config_single_channel(CHANNEL_0);
}
```
### **阶段二：通道配置（严格顺序）**
#### **Step 1: 进入睡眠模式**
```c
// 配置前必须让传感器进入睡眠模式
ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SLEEP_MODE);
delay_ms(10);
```
**原因**：确保传感器停止工作，避免配置冲突
#### **Step 2: 频率分频配置**
```c
ldc1612_set_freq_divide(channel);
delay_ms(5);
```
**原因**：
- 这是最基础的配置，影响所有后续参数
- 必须根据LC谐振频率正确计算
- 公式：`f_sensor = 1/(2π√(LC))`
#### **Step 3: LC稳定时间**
```c
ldc1612_set_LC_stabilize_time(channel, LC_STABILIZE_TIME_CH0);
```
**原因**：
- 影响测量精度
- 时间太短可能导致不稳定
- 时间太长影响响应速度
#### **Step 4: 转换时间**
```c
ldc1612_set_conversion_time(channel, LDC1612_CONVERSION_TIME_CH0);
```
**原因**：
- 影响测量精度和速度的平衡
- 值越大精度越高但速度越慢
#### **Step 5: 转换偏移**
```c
ldc1612_set_conversion_offset(channel, 0x0000);
```
**原因**：
- 通常设为0，除非有特殊校准需求
#### **Step 6: 驱动电流**
```c
ldc1612_set_drive_current(channel, LDC1612_DRIVE_CURRENT);
```
**原因**：
- 影响传感器灵敏度和功耗
- 电流越大灵敏度越高但功耗也越大
#### **Step 7: 多路复用器配置**
```c
ldc1612_set_mux_config(LDC1612_MUX_CONFIG);
```
**原因**：
- 设置通道选择和滤波器带宽
- 影响噪声抑制和响应速度
#### **Step 8: 错误配置**
```c
ldc1612_set_error_config(LDC1612_ERROR_CONFIG);
```
**原因**：
- 配置错误输出行为
- 通常设为0（所有错误输出启用）
#### **Step 9: 启动传感器**
```c
ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SENSOR_CONFIG);
delay_ms(50);
```
**原因**：
- **必须最后一步**
- 启动传感器开始正常工作
- 需要等待稳定时间
## ⚠️ **常见配置错误**
### **1. 配置顺序错误**
```c
// ❌ 错误：先启动传感器再配置
ldc1612_set_sensor_config(LDC1612_SENSOR_CONFIG);
ldc1612_set_freq_divide(CHANNEL_0); // 太晚了！
// ✅ 正确：先配置后启动
ldc1612_set_freq_divide(CHANNEL_0);
ldc1612_set_sensor_config(LDC1612_SENSOR_CONFIG);
```
### **2. 缺少延时**
```c
// ❌ 错误：没有等待复位完成
ldc1612_reset_sensor();
ldc1612_get_manufacturer_id(); // 可能读取失败
// ✅ 正确：适当延时
ldc1612_reset_sensor();
delay_ms(100);
ldc1612_get_manufacturer_id();
```
### **3. 频率分频计算错误**
```c
// ❌ 错误：使用固定值
#define FREQ_DIV_VALUE 0x1002
// ✅ 正确：根据LC参数计算
sensor_freq = 1 / (2 * PI * sqrt(L * C));
fin_div = (uint16_t)(sensor_freq / 8.75 + 1);
```
## 📊 **配置参数说明**
| 参数 | 地址 | 当前值 | 说明 |
|------|------|--------|------|
| 频率分频 | 0x14 | 0x1002 | 根据LC计算得出 |
| LC稳定时间 | 0x10 | 0x001E | 30个时钟周期 |
| 转换时间 | 0x08 | 0x0546 | 1350个参考时钟 |
| 驱动电流 | 0x1E | 0x9000 | 高驱动电流 |
| 多路复用 | 0x1B | 0x020C | 单通道，3.3MHz带宽 |
| 传感器配置 | 0x1A | 0x1601 | 启用传感器，连续模式 |
## 🔍 **验证配置是否正确**
```c
void verify_ldc1612_config(void) {
uint16_t status = ldc1612_get_sensor_status();
printf("Status: 0x%04X\n", status);
// 检查数据就绪
if (ldc1612_is_data_ready(CHANNEL_0)) {
printf("✓ Channel 0 data ready\n");
}
// 检查错误
if (status & 0xFF00) {
printf("✗ Error detected: 0x%04X\n", status);
} else {
printf("✓ No errors detected\n");
}
}
```
## 📚 **TI官方建议的最佳实践**
1. **总是先复位**：每次配置前都要复位传感器
2. **验证设备ID**：确保通信正常
3. **睡眠模式配置**：配置期间保持睡眠状态
4. **频率优先**：频率分频必须最先配置
5. **启动最后**：传感器配置必须最后设置
6. **适当延时**：每个关键步骤后都要延时
7. **状态检查**：配置完成后检查状态寄存器
## 🎯 **推荐使用方式**
```c
// 推荐的初始化流程
int main(void) {
// 系统初始化
system_init();
// IIC初始化
#ifdef SOFTWARE_IIC
soft_i2c_config();
#else
i2c_config();
#endif
// LDC1612完整初始化
if (ldc1612_complete_init() != LDC1612_STATUS_SUCCESS) {
printf("LDC1612 initialization failed!\n");
while(1);
}
printf("LDC1612 initialization success!\n");
// 主循环
while (1) {
if (ldc1612_is_data_ready(CHANNEL_0)) {
uint32_t data = ldc1612_get_raw_channel_result(CHANNEL_0);
// 处理数据
}
delay_ms(100);
}
}
```

149
LDC1612_Configuration_Reference.md
View File

@@ -1,149 +0,0 @@
# LDC1612 Configuration Reference Guide
## 概述
本文档为德州仪器 LDC1612 电感数字转换器提供全面的配置指导。LDC1612 是一款高分辨率、多通道的电感式传感应用芯片。
---
## 总测量周期配置
### 寄存器信息
| 参数 | 通道0地址 | 通道1地址 | 数据位宽 | 寄存器名称 |
|------|-----------|-----------|----------|------------|
| 转换时间 | 0x08 | 0x09 | 16位 | CONVERSION_TIME_CHx |
| LC稳定时间 | 0x10 | 0x11 | 16位 | LC_STABILIZE_TIME_CHx |
### 功能说明
- **转换时间**: 决定ADC转换精度和数据更新率
- **LC稳定时间**: LC振荡器稳定所需时间，影响测量精度
- **约束条件**: LC稳定时间 < 转换时间
### 取值范围
**转换时间寄存器**:
- 最小值: 0x0100 (256个时钟周期)
- 最大值: 0x1FFF (8191个时钟周期)
- 推荐范围: 0x0200 - 0x1800
**LC稳定时间寄存器**:
- 最小值: 0x0004 (4个时钟周期)
- 最大值: 0xFFFF (65535个时钟周期)
- 推荐范围: 0x0010 - 0x0100
### 计算公式
```
转换时间 = 转换设置值 × (1 / f_REF_CLK)
LC稳定时间 = 稳定设置值 × (1 / f_REF_CLK)
总测量时间 = LC稳定时间 + 转换时间
数据更新率 = f_REF_CLK / (稳定设置值 + 转换设置值)
其中: f_REF_CLK = 40MHz (LDC1612内部参考时钟)
```
### 常用配置档位
| 档位 | 转换时间设置 | LC稳定时间设置 | 总测量时间 | 数据更新率 | 适用场景 |
|------|--------------|----------------|------------|------------|----------|
| 超高速 | 0x0200 (512周期) | 0x0010 (16周期) | 13.2μs | ~75.8kSPS | 振动检测 |
| 高速 | 0x0400 (1024周期) | 0x0010 (16周期) | 26.0μs | ~38.5kSPS | 快速响应 |
| 平衡 | 0x0800 (2048周期) | 0x0020 (32周期) | 52.0μs | ~19.2kSPS | 一般应用 |
| 高精度 | 0x1000 (4096周期) | 0x0020 (32周期) | 103.2μs | ~9.7kSPS | 精密测量 |
| 超高精度 | 0x1800 (6144周期) | 0x0040 (64周期) | 155.2μs | ~6.5kSPS | 实验室级 |
### 典型应用场景配置
#### 1. 振动监测/快速运动跟踪
- **转换时间**: 0x0200 (512周期)
- **LC稳定时间**: 0x0010 (16周期)
- **性能**: ~75.8kSPS，适中精度
#### 2. 一般工业传感/位置检测
- **转换时间**: 0x0800 (2048周期)
- **LC稳定时间**: 0x0020 (32周期)
- **性能**: ~19.2kSPS，平衡性能
#### 3. 精密位移测量/材料检测
- **转换时间**: 0x1000 (4096周期)
- **LC稳定时间**: 0x0020 (32周期)
- **性能**: ~9.7kSPS，高精度
#### 4. 实验室级测量/恶劣环境
- **转换时间**: 0x1800 (6144周期)
- **LC稳定时间**: 0x0040 (64周期)
- **性能**: ~6.5kSPS，最高稳定性
### 选择策略
1. **确定应用需求**: 响应速度、精度要求、环境条件
2. **线圈特性考虑**: Q因子越高需要更长LC稳定时间
3. **环境因素**: 温度变化大或电磁干扰强需增加时间参数
4. **调试优化**: 从保守设置开始，逐步优化提高响应速度
---
## 驱动电流配置
### 寄存器信息
- **寄存器地址**: 0x1E (通道0), 0x1F (通道1)
- **数据位宽**: 16位
- **功能**: 控制LC振荡器的驱动电流强度
### 取值范围
- **最小值**: 0x0000 (最小驱动电流)
- **最大值**: 0xFFFF (最大驱动电流)
- **常用范围**: 0x8000 - 0xC000
- **推荐起始值**: 0x9000
### 驱动电流档位
| 设置值 | 相对强度 | 适用场景 | 特点 |
|--------|----------|----------|------|
| 0x8000 | 低 | 小线圈、近距离检测 | 低功耗，灵敏度适中 |
| 0x9000 | 中等 | 一般应用 | 平衡性能，通用设置 |
| 0xA000 | 较高 | 大线圈、远距离检测 | 高灵敏度，功耗较高 |
| 0xC000 | 高 | 极端环境、最大灵敏度 | 最高性能，最大功耗 |
---
## 传感器配置寄存器
### 寄存器信息
- **寄存器地址**: 0x1A
- **数据位宽**: 16位
- **当前设置**: 0x1A23
### 关键位域功能
| 位域 | 功能 | 当前值 | 说明 |
|------|------|--------|------|
| 位15-14 | 活动通道选择 | 00 | 通道0活动 |
| 位13 | 睡眠模式控制 | 1 | 正常工作模式 |
| 位11 | 激活序列选择 | 1 | 完整激活序列 |
| 位10 | 自动幅度调整 | 0 | 启用自动幅度调整 |
| 位9 | 时钟源选择 | 1 | 外部时钟源 |
| 位1-0 | 去毛刺滤波 | 11 | 10MHz滤波(高EMI环境) |
### 常用配置组合
| 配置值 | 应用场景 | 特点 |
|--------|----------|------|
| 0x1601 | 手动模式+内部时钟 | 精确控制，稳定环境 |
| 0x1821 | 自动模式+内部时钟 | 智能调整，一般环境 |
| 0x1A21 | 自动模式+外部时钟 | 高性能，低噪声 |
| 0x1A23 | 自动模式+外部时钟+增强滤波 | 高EMI环境 |
---
## 注意事项
- 本文档将扩展更多LDC1612寄存器配置内容
- 所有时序计算基于40MHz内部参考时钟
- 实际性能可能因线圈特性和环境条件而异
- 请务必根据具体应用需求验证设置
---
## 文档历史
- **版本1.0** (2025-08-17): 初始转换时间配置文档
- **版本1.1** (2025-08-17): 添加LC稳定时间配置和时序参数协调说明
- **版本1.2** (2025-08-17): 添加驱动电流配置和传感器配置寄存器说明
- **未来更新**: 将添加频率分频器、错误配置等更多寄存器配置说明

178
LDC1612_USAGE_EXAMPLE.md
View File

@@ -1,178 +0,0 @@
# LDC1612 驱动使用指南
## 📌 概述
LDC1612是TI公司的涡流传感器芯片，本驱动支持单通道(Channel 0)和双通道工作模式，并提供了硬件IIC和软件IIC的灵活切换。
## 🔧 硬件IIC与软件IIC切换
### 方法一：通过 board_config.h 配置（推荐）
在 `Inc/board_config.h` 文件中修改以下配置：
```c
/* 使用软件IIC */
#define SOFTWARE_IIC // 启用软件IIC
// #undef SOFTWARE_IIC // 注释掉这行
/* 使用硬件IIC */
// #define SOFTWARE_IIC // 注释掉这行
#undef SOFTWARE_IIC // 使用硬件IIC
```
### 方法二：通过编译时定义
在CMakeLists.txt中添加：
```cmake
# 使用软件IIC
target_compile_definitions(${PROJECT_NAME} PRIVATE SOFTWARE_IIC)
# 使用硬件IIC（移除上面的定义即可）
```
## 📋 LDC1612 初始化序列
### 推荐的初始化步骤
```c
// 2. 检查传感器ID
uint16_t manufacturer_id = ldc1612_get_manufacturer_id();
uint16_t device_id = ldc1612_get_deveice_id();
printf("Manufacturer ID: 0x%04X (Expected: 0x5449)\n", manufacturer_id);
printf("Device ID: 0x%04X (Expected: 0x3055)\n", device_id);
if (manufacturer_id != 0x5449 || device_id != 0x3055) {
printf("ERROR: LDC1612 not detected!\n");
return;
}
// 3. 复位传感器
ldc1612_reset_sensor();
delay_ms(100);
// 4. 配置单通道模式
ldc1612_single_ch0_config();
// 5. 显示当前IIC类型
printf("Current IIC Type: %s\n", ldc1612_get_iic_type());
printf("LDC1612 initialization completed\n");
}
```
## 📊 数据读取示例
```c
void ldc1612_read_example(void) {
uint32_t raw_data;
uint16_t status;
// 检查数据是否准备好
if (ldc1612_is_data_ready(CHANNEL_0)) {
// 读取原始数据
raw_data = ldc1612_get_raw_channel_result(CHANNEL_0);
// 检查错误状态
if (raw_data & 0xF0000000) {
printf("Sensor Error: 0x%08X\n", raw_data);
return;
}
// 获取有效数据 (28位)
uint32_t sensor_data = raw_data & 0x0FFFFFFF;
printf("Channel 0 Data: %u\n", sensor_data);
// 转换为频率值 (可选)
float frequency = (float)sensor_data * COIL_FREQ_HZ / 0x10000000;
printf("Frequency: %.2f Hz\n", frequency);
}
// 读取状态寄存器
status = ldc1612_get_sensor_status();
printf("Status: 0x%04X\n", status);
}
```
## ⚠️ 常见错误代码
| 错误代码 | 说明 |
|---------|------|
| 0xF0000000 | ERR_NC - 未检测到线圈 |
| 0x80000000 | ERR_UR - 欠量程错误 |
| 0x40000000 | ERR_OR - 超量程错误 |
| 0x20000000 | ERR_WD - 看门狗超时 |
| 0x10000000 | ERR_AE - 振幅错误 |
## 🔍 寄存器配置说明
### 当前配置值解析
```c
#define LDC1612_CONVERSION_TIME_CH0 0x0546 // 转换时间
#define LDC1612_DRIVE_CURRENT 0x9000 // 驱动电流
#define LDC1612_MUX_CONFIG 0x020C // 多路复用配置
#define LDC1612_SENSOR_CONFIG_CH0 0x1601 // 传感器配置
#define LC_STABILIZE_TIME_CH0 0x001E // LC稳定时间
```
- **转换时间**: 0x0546 = 1350个参考时钟周期
- **驱动电流**: 0x9000 = 高驱动电流设置
- **MUX配置**: 0x020C = 无自动扫描，3.3MHz滤波带宽
- **传感器配置**: 0x1601 = 启用传感器，连续转换模式
## 🛠️ 调试技巧
### 1. 检查IIC通信
```c
void debug_iic_communication(void) {
printf("=== IIC Communication Test ===\n");
printf("IIC Type: %s\n", ldc1612_get_iic_type());
uint16_t manufacturer_id = ldc1612_get_manufacturer_id();
uint16_t device_id = ldc1612_get_deveice_id();
printf("Manufacturer ID: 0x%04X\n", manufacturer_id);
printf("Device ID: 0x%04X\n", device_id);
if (manufacturer_id == 0xFFFF || device_id == 0xFFFF) {
printf("ERROR: IIC communication failed!\n");
} else if (manufacturer_id == 0x5449 && device_id == 0x3055) {
printf("SUCCESS: LDC1612 detected and communicating\n");
} else {
printf("WARNING: Unexpected device detected\n");
}
}
```
### 2. 自动检测驱动电流
```c
void auto_detect_drive_current(void) {
printf("=== Auto Drive Current Detection ===\n");
ldc1612_drvie_current_detect(CHANNEL_0);
}
```
## 📈 性能优化建议
1. **硬件IIC vs 软件IIC**:
- 硬件IIC: 更快速，CPU占用率低
- 软件IIC: 更灵活，便于调试
2. **频率设置优化**:
- 根据实际线圈参数调整 `COIL_L_UH` 和 `COIL_C_PF`
- 确保传感器频率在1-10MHz范围内
3. **电源管理**:
- 不使用时可调用 `ldc1612_set_sensor_config(LDC1612_SLEEP_MODE)`
## 📚 参考资料
- TI LDC1612 数据手册
- GD32E230 参考手册
- 本项目IIC驱动实现: `i2c.c` 和 `soft_i2c.c`

410
Src/command.c
View File

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

5
Src/main.c
View File

@@ -67,8 +67,6 @@ int main(void)
}
while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
#endif
i2c_config();
@@ -85,8 +83,7 @@ int main(void)
while(1){
command_process();
delay_ms(10);
if (g_sensor_report_enabled) {
if (g_sensor_report_enabled)
eddy_current_report();
}
}
}

224
Src/sensor_example.c
View File

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

542
i2c_wait.c
View File

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