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

clear repo

Browse Source
This commit is contained in:
yelvlab
2025-08-17 03:06:46 +08:00
parent 5cdd7ca58c
commit 9b3cd46b09
7 changed files with 1 additions and 1383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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;