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
Branches Tags
hulk:main hulk:dev hulk:dev_feature_iic_more_byte hulk:dev_more_information
..
compare: hulk:dev_feature_iic_more_byte
Branches Tags
hulk:dev hulk:dev_feature_iic_more_byte hulk:dev_more_information hulk:main

2 Commits
dev ... dev_featur

Author SHA1 Message Date
yelvlab
dbb65695c9 add dlpc3421 driver from kimi 2025-08-25 10:26:43 +08:00
yelvlab
75ea93cd53 添加IIC多字节读写，以应对不同环境 2025-08-25 09:43:20 +08:00
21 changed files with 1464 additions and 1845 deletions
Expand all files Collapse all files

7
CMakeLists.txt
View File

@@ -6,10 +6,6 @@ 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)
@@ -51,7 +47,6 @@ 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
@@ -73,7 +68,7 @@ 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}_${BUILD_VARIANT}_${BUILD_DATE}")
set(OUTPUT_PREFIX "${PROJECT_NAME}_${VERSION}_${IIC_TYPE}_${BUILD_DATE}")
add_custom_command(TARGET ${PROJECT_NAME}
POST_BUILD

62
CommunicationProtocol.md
View File

@@ -1,62 +0,0 @@
# 电涡流传感器模块通信协议
## 电涡流传感器模块通信协议
| **序号** | **修改内容** | **版本** | **日期** | **修改人** |
|:------:|:--------:|:------:|:----------:|:-------:|
| 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. 单次读取并发送板载温度传感器数据
- M3 指令 单次读取并发送板载温度传感器数据
- `D5 03 02 4D 34 86`

18
Inc/board_config.h
View File

@@ -1,8 +1,6 @@
#ifndef BOARD_CONFIG_H
#define BOARD_CONFIG_H
#include "version.h"
#define GD32E23XF4 0x10
#define GD32E23XF6 0x20
#define GD32E23XF8 0x40
@@ -27,16 +25,6 @@
// #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 */
@@ -68,9 +56,9 @@ void usart1_irq_handler(void);
/******************************************************************************/
#define LED_RCU RCU_GPIOB
#define LED_PORT GPIOB
#define LED_PIN GPIO_PIN_1
#define LED_RCU RCU_GPIOA
#define LED_PORT GPIOA
#define LED_PIN GPIO_PIN_7
/******************************************************************************/

20
Inc/command.h
View File

@@ -18,6 +18,7 @@
/** @brief 传感器周期上报使能标志 */
extern volatile bool g_eddy_current_sensor_report_enabled;
extern volatile bool g_temperature_sensor_report_enabled;
/**
* @section Command_Protocol 协议格式
@@ -80,6 +81,25 @@ 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 基于状态机的非阻塞协议解析器，处理完整的命令帧并自动响应。

18
Inc/dlpc3421.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef __DLPC3421_H
#define __DLPC3421_H
#include <stdint.h>
#include <stdbool.h>
bool dlp_probe(void);
int dlp_init(void);
void dlp_on(void);
void dlp_off(void);
void dlp_set_current(uint8_t r, uint8_t g, uint8_t b);
void dlp_reset(void);
void dlp_dump_regs(void);
#ifdef DLP_PATTERN_TEST
void dlp_test_pattern(uint8_t pattern_id);
#endif
#endif

72
Inc/i2c.h
View File

@@ -107,76 +107,15 @@ i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data
*/
i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
/* 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)
\brief read 16-bit data from I2C device
\param[in] slave_addr: 7-bit slave address
\param[in] reg_addr: register address
\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
\param[out] data: pointer to 2-byte data buffer
\retval i2c_result_t
*/
i2c_result_t i2c_write(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data, uint8_t length);
i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
/*!
\brief read data from I2C device with configurable length
\param[in] slave_addr: slave device address (7-bit)
\param[in] reg_addr: register address
\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, uint8_t reg_addr, uint8_t *data, uint8_t length);
/* Convenience functions for common operations */
/*!
\brief write single byte to I2C device
\param[in] slave_addr: slave device address (7-bit)
\param[in] reg_addr: register address
\param[in] data: data byte to write
\retval i2c_result_t: operation result
*/
i2c_result_t i2c_write_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data);
/*!
\brief read single byte from I2C device
\param[in] slave_addr: slave device address (7-bit)
\param[in] reg_addr: register address
\param[out] data: pointer to data byte
\retval i2c_result_t: operation result
*/
i2c_result_t i2c_read_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
/*!
\brief write 32-bit data to I2C device
\param[in] slave_addr: slave device address (7-bit)
\param[in] reg_addr: register address
\param[in] data: pointer to 4-byte data array
\retval i2c_result_t: operation result
*/
i2c_result_t i2c_write_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[4]);
/*!
\brief read 32-bit data from I2C device
\param[in] slave_addr: slave device address (7-bit)
\param[in] reg_addr: register address
\param[out] data: pointer to 4-byte data buffer
\retval i2c_result_t: operation result
*/
i2c_result_t i2c_read_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
/*!
\brief read display panel parameters (multi-byte)
\param[in] slave_addr: slave device address (7-bit)
\param[in] reg_addr: register address
\param[out] data: pointer to data buffer
\param[in] length: number of bytes to read (1-13)
\retval i2c_result_t: operation result
*/
i2c_result_t i2c_read_display_params(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data, uint8_t length);
#ifdef DEBUG_VERBOSE
/*!
\brief get status string for debugging
\param[in] status: i2c_result_t value
@@ -184,6 +123,5 @@ i2c_result_t i2c_read_display_params(uint8_t slave_addr, uint8_t reg_addr, uint8
\retval const char* status string
*/
const char* i2c_get_status_string(i2c_result_t status);
#endif
#endif //I2C_H

46
Inc/iic_new.h Normal file
View File

@@ -0,0 +1,46 @@
// ...existing code...
/* function declarations */
i2c_result_t i2c_config(void);
i2c_result_t i2c_bus_reset(void);
void i2c_scan(void);
/* generic read/write functions with configurable length */
i2c_result_t i2c_write(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data, uint8_t length);
i2c_result_t i2c_read(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data, uint8_t length);
/* compatibility functions for legacy code */
i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[2]);
i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
/* convenience functions for common operations */
i2c_result_t i2c_write_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data);
i2c_result_t i2c_read_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
i2c_result_t i2c_write_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[4]);
i2c_result_t i2c_read_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data);
#ifdef DEBUG_VERBOSE
const char* i2c_get_status_string(i2c_result_t status);
#endif
// ...existing code...
// 读取显示面板参数 (13字节)
uint8_t display_params[13];
i2c_result_t result = i2c_read_display_params(0x3C, 0x0F, display_params, 13);
// 或者使用通用函数
result = i2c_read(0x3C, 0x0F, display_params, 13);
// 读取单个参数
uint8_t startup_mode;
result = i2c_read_8bits(0x3C, 0x0F, &startup_mode);
// 读取2字节参数（如显示界面宽度）
uint8_t width_data[2];
result = i2c_read(0x3C, 0x10, width_data, 2);
// 写入多字节配置
uint8_t config_data[5] = {0x01, 0x02, 0x03, 0x04, 0x05};
result = i2c_write(0x3C, 0x20, config_data, 5);

499
Inc/ldc1612.h
View File

@@ -10,6 +10,7 @@
#include "systick.h"
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "board_config.h"
@@ -28,32 +29,25 @@
#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 CONVERSION_RESULT_REG_START 0X00
#define CONVERTION_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
@@ -62,398 +56,131 @@
#define CHANNEL_0 0
#define CHANNEL_1 1
/**************************DATA (0x00-0x03)*******************************************/
/*
* 作用: 存储28位的传感器转换结果。结果分为高字节(MSB)和低字节(LSB)两个寄存器。
*
* 结构说明:
* - DATA_CHx_MSB: 包含错误标志和数据的高12位 [27:16]。
* - DATA_CHx_LSB: 包含数据的低16位 [15:0]。
*
* MSB寄存器位域:
* [15] ERR_UR: 转换下溢错误标志 (1 = 发生错误)
* [14] ERR_OR: 转换上溢错误标志 (1 = 发生错误)
* [13] ERR_WD: 看门狗超时错误标志 (1 = 发生错误)
* [12] ERR_AE: 振幅错误标志 (高或低) (1 = 发生错误)
* [11:0] DATA[27:16]: 数据的高12位
*
* 注意:
* - 仅当ERROR_CONFIG寄存器中对应的ERR2OUT位置1时，这些错误标志才会在MSB寄存器中被设置。
* - 读取数据时，应先读取LSB，再读取MSB，以确保数据的一致性。
/*************************MUX_CONFIG********************************************
* 0x0209 AutoScanEN: 0 / RR_SEQ: 00 / RESERVED: 0 0010 0000 1 / Deglitch: 001( 1MHz)
* 0x020C AutoScanEN: 0 / RR_SEQ: 00 / RESERVED: 0 0010 0000 1 / Deglitch: 100(3.3MHz)
* 0x020D AutoScanEN: 0 / RR_SEQ: 00 / RESERVED: 0 0010 0000 1 / Deglitch: 100( 10MHz)
* 0x020F AutoScanEN: 0 / RR_SEQ: 00 / RESERVED: 0 0010 0000 1 / Deglitch: 100( 33MHz)
*/
#define LDC1612_MUX_CONFIG 0x020C
/* --- 数据寄存器错误标志位掩码 --- */
#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)
/***********************SENSOR_CONFIG********************************************
* 0x1601 Active CH0: 00 / SLEEP: 0 / OVERDRIVE: 1 / LowPowerMode: 0 / AutoAmpDis 1 / CLK(ext): 1 / RESERVED: 0 / INTB_Dis : 0 / HighCurrent: 0 / RESERVED: 00 0001
* 0x1201 Active CH0: 00 / SLEEP: 0 / OVERDRIVE: 1 / LowPowerMode: 0 / AutoAmpDis 0 / CLK(ext): 1 / RESERVED: 0 / INTB_Dis : 0 / HighCurrent: 0 / RESERVED: 00 0001
* 0x1641 Active CH0: 00 / SLEEP: 0 / OVERDRIVE: 1 / LowPowerMode: 0 / AutoAmpDis 1 / CLK(ext): 1 / RESERVED: 0 / INTB_Dis : 0 / HighCurrent: 1 / RESERVED: 00 0001
* 0x1241 Active CH0: 00 / SLEEP: 0 / OVERDRIVE: 1 / LowPowerMode: 0 / AutoAmpDis 0 / CLK(ext): 1 / RESERVED: 0 / INTB_Dis : 0 / HighCurrent: 1 / RESERVED: 00 0001
*/
/**************************RCOUNT (0x08, 0x09)****************************************/
/*
* 作用: 设置参考计数器值，决定了传感器的转换时间，从而影响测量分辨率。
*
* 位域说明:
* [15:0] RCOUNT: 参考计数值。
*
* 计算公式:
* t_CONVERSION = (RCOUNT * 16) / f_REF
*
* 注意:
* - RCOUNT值必须 ≥ 0x0004。
* - 该寄存器在复位后值为 0x0080。
*
* 配置建议:
* - 需要高采样率: 使用较小的RCOUNT值。
* - 需要高分辨率: 使用较大的RCOUNT值。
*/
#ifdef EDDY_DRIVE_CURRENT_DETECTION
#define LDC1612_SENSOR_CONFIG_CH0 0x1241
#else
#define LDC1612_SENSOR_CONFIG_CH0 0x1641
#endif
#define LDC1612_SLEEP_MODE 0x2801
/* --- 预设配置示例 --- */
// 高速采样配置 (分辨率较低)
#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
/**************************SETTLECOUNT (0x10, 0x11)***********************************/
/*
* 作用: 设置传感器振荡器在开始转换前所需的建立时间。
*
* 位域说明:
* [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) 是一个很好的起始值。
*/
/* --- 预设配置示例 --- */
// 适用于高Q值传感器 (建立时间短)
#define LDC1612_SETTLECOUNT_HIGH_Q (0x000A) // 约 4µs @ 40MHz/2
// 适用于中等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值。
/****************************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
*/
/* --- 驱动电流值生成宏 --- */
// 参数 idrive: 0-31之间的整数
#define LDC1612_DRIVE_CURRENT_GEN(idrive) ( (uint16_t)(idrive) << 11 )
#define LDC1612_ERROR_CONFIG 0x0000
#define LDC1612_DRIVE_CURRENT LDC1612_DRIVE_CURRENT_GEN(18) // 0x9000
/**************************STATUS****************************************
* [15]
* [14] Error Channel 0b00: CH0 / 0b01: CH1 / 0b10: CH2 / 0b11: CH3
* [13] Conversion Under-Range Error 0b0: No / 0b1: Yes
* [12] Conversion Over-Range Error 0b0: No / 0b1: Yes
* [11] Watchdog Timeout Error 0b0: No / 0b1: Yes
* [10] Amplitude High Error 0b0: No / 0b1: Yes
* [ 9] Amplitude Low Error 0b0: No / 0b1: Yes
* [ 8] Zero Count Error 0b0: No / 0b1: Yes
* [ 7] RESERVED
* [ 6] Ddata Ready Flag 0b0: No new results / 0b1: New results available
* [ 5] RESERVED
* [ 4] RESERVED
* [ 3] CH0 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH0)
* [ 2] CH1 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH1)
* [ 1] CH2 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH2)
* [ 0] CH3 Unread Conversion Result 0b0: No / 0b1: Yes(DATA_CH3)
*
* 0x0000 No ERR to OUT or INTB
*/
/**************************IDs (Read Only 0x7E 0x7F)***********************************/
/*****************CONVERSION_OFFSET_CONFIG****************************************/
#define SET_CONVERSION_OFFSET_CH0 0x0000
/***********************RESET DEVICE********************************************
0x8000 RESET_DEV: 1 / RESERVED: 000 0000 0000 0000
*/
#define LDC1612_RESET_DEV 0x8000 //[15:0] 0b1000 0000 0000 0000
/***********************IDs****************************************************/
#define LDC1612_MANUFACTURER_ID 0x5449
#define LDC1612_DEVICE_ID 0x3055
/******************************************************************************/
#define COIL_RP_KOM 7.2
#define COIL_L_UH 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,
@@ -483,6 +210,4 @@ 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

4
LD/gd32e23x_flash.ld
View File

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

635
LDC1612_REG_LIST.md
View File

@@ -1,635 +0,0 @@
#
```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通信测试。

95
Src/command.c
View File

@@ -80,14 +80,7 @@
/** @brief 传感器周期上报使能标志 */
volatile bool g_eddy_current_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
volatile bool g_temperature_sensor_report_enabled = false;
/** @name 预设响应数据
* @{ */
@@ -121,6 +114,28 @@ 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]，
@@ -205,36 +220,6 @@ 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位无符号整数。
@@ -321,50 +306,20 @@ 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:
eddy_current_report();
set_temp_sensor_report_status(true);
return;
case 4u:
temperature_raw_value_report();
set_temp_sensor_report_status(false);
return;
// case 201u: // M201命令
// send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
// return;
/* ==========================================
* 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));

187
Src/dlpc3421.c Normal file
View File

@@ -0,0 +1,187 @@
/***************************************************************************
* DLPC3421 全功能驱动模板（GD32E230）
* 作者：xxx
* 版本：v1.0
* 说明：
* 1. 覆盖上电→初始化→正常投影→关机→异常复位全部状态
* 2. 提供精简 API：dlp_on / dlp_off / dlp_set_current / dlp_set_pattern
* 3. 所有 I²C 操作带超时重试、CRC 打印、断言保护
* 4. 支持在线调试：dlp_dump_regs()
***************************************************************************/
#include "gd32e23x.h"
#include "dlpc3421.h"
#include <string.h>
#include <stdbool.h>
/* -------------------- 用户可调宏 -------------------- */
#define DLPC_I2C_ADDR 0x1B /* 7-bit 地址 */
#define I2C_TIMEOUT_MS 100
#define DLPC_BOOT_DELAY_MS 200
#define MAX_RETRY 3
/* -------------------- 内部宏 ------------------------ */
#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
/* -------------------- I²C 底层封装 ------------------ */
static int i2c_write(uint8_t dev, const uint8_t *tx, uint16_t len)
{
/* 你的 i2c 发送实现，这里用伪代码占位 */
/* 返回 0 成功，-1 失败 */
return 0;
}
static int i2c_read(uint8_t dev, uint8_t *rx, uint16_t len)
{
/* 你的 i2c 接收实现，这里用伪代码占位 */
return 0;
}
/* -------------------- 寄存器 / 指令表 --------------- */
typedef enum {
CMD_WRITE_ENABLE = 0x50, /* 1B bit0=1 打开手动电流 / CAIC */
CMD_LED_ENABLE = 0x52, /* 1B bit0=R,bit1=G,bit2=B */
CMD_LED_CURRENT_MANUAL = 0x54, /* 3B R/G/B mA */
CMD_MAX_CURRENT_LIMIT = 0x5C, /* 3B R/G/B max */
CMD_PATTERN_CONTROL = 0x60, /* 2B 模式/触发 */
CMD_STATUS = 0xD0, /* 1B bit0=Busy */
CMD_CHIP_ID = 0xD2, /* 2B 返回 0x34 0x21 */
CMD_SOFTWARE_RESET = 0xF0 /* 1B 0x01 软复位 */
} dlp_cmd_t;
/* -------------------- 内部工具函数 ------------------ */
static bool dlp_wait_not_busy(uint32_t timeout_ms)
{
uint8_t cmd = CMD_STATUS;
uint8_t sts = 0x01;
while (timeout_ms--) {
if (i2c_write(DLPC_I2C_ADDR, &cmd, 1) == 0 &&
i2c_read (DLPC_I2C_ADDR, &sts, 1) == 0) {
if (!(sts & 0x01))
return true;
}
delay_1ms(1);
}
return false;
}
static int dlp_send_cmd(uint8_t cmd, const uint8_t *data, uint8_t len)
{
uint8_t buf[32];
buf[0] = cmd;
if (len) memcpy(&buf[1], data, len);
for (int i = 0; i < MAX_RETRY; ++i) {
if (i2c_write(DLPC_I2C_ADDR, buf, len+1) == 0 &&
dlp_wait_not_busy(I2C_TIMEOUT_MS))
return 0;
}
return -1;
}
/* -------------------- 对外 API ---------------------- */
/* 1. 芯片识别 */
bool dlp_probe(void)
{
uint8_t cmd = CMD_CHIP_ID;
uint8_t id[2] = {0};
if (i2c_write(DLPC_I2C_ADDR, &cmd, 1) == 0 &&
i2c_read(DLPC_I2C_ADDR, id, 2) == 0) {
return (id[0] == 0x34 && id[1] == 0x21);
}
return false;
}
/* 2. 上电初始化流程（参考 TI 手册 Figure 3-1） */
int dlp_init(void)
{
/* Step-1: 上电等待 tPU */
delay_1ms(DLPC_BOOT_DELAY_MS);
if (!dlp_probe()) return -1;
/* Step-2: 设置最大电流限制（可选，按 LED 规格） */
uint8_t max_i[3] = {255, 255, 255};
if (dlp_send_cmd(CMD_MAX_CURRENT_LIMIT, max_i, 3)) return -2;
/* Step-3: 打开手动电流控制 */
uint8_t manual_on = 0x01;
if (dlp_send_cmd(CMD_WRITE_ENABLE, &manual_on, 1)) return -3;
return 0; /* OK */
}
/* 3. 开关光机（含 Busy 轮询） */
void dlp_on(void)
{
uint8_t leds = 0x07; /* RGB ON */
dlp_send_cmd(CMD_LED_ENABLE, &leds, 1);
}
void dlp_off(void)
{
uint8_t leds = 0x00; /* RGB OFF */
dlp_send_cmd(CMD_LED_ENABLE, &leds, 1);
}
/* 4. 手动设置电流 */
void dlp_set_current(uint8_t r, uint8_t g, uint8_t b)
{
uint8_t rgb[3] = {r, g, b};
dlp_send_cmd(CMD_LED_CURRENT_MANUAL, rgb, 3);
}
/* 5. 软件复位（异常恢复用） */
void dlp_reset(void)
{
uint8_t rst = 0x01;
dlp_send_cmd(CMD_SOFTWARE_RESET, &rst, 1);
delay_1ms(DLPC_BOOT_DELAY_MS);
dlp_init(); /* 重新初始化 */
}
/* 6. 打印常用寄存器（调试） */
void dlp_dump_regs(void)
{
uint8_t regs[] = {CMD_STATUS, CMD_CHIP_ID};
uint8_t buf[2];
for (size_t i = 0; i < ARRAY_SIZE(regs); ++i) {
if (i2c_write(DLPC_I2C_ADDR, &regs[i], 1) == 0 &&
i2c_read(DLPC_I2C_ADDR, buf, 1+(regs[i]==CMD_CHIP_ID)) == 0) {
printf("Reg 0x%02X : ", regs[i]);
for (size_t j = 0; j < (regs[i]==CMD_CHIP_ID?2:1); ++j)
printf("%02X ", buf[j]);
printf("\r\n");
}
}
}
/* 7. 可选：测试图案模式 */
#ifdef DLP_PATTERN_TEST
void dlp_test_pattern(uint8_t pattern_id)
{
uint8_t data[2] = {pattern_id, 0x01}; /* 打开内部测试图 */
dlp_send_cmd(CMD_PATTERN_CONTROL, data, 2);
}
#endif
/* -------------------- 使用示例 ---------------------- */
#if 0
int main(void)
{
i2c_init(); /* 你的 GD32 I²C 初始化 */
if (dlp_init() != 0) {
printf("DLPC3421 init fail\r\n");
while (1);
}
dlp_on();
dlp_set_current(80, 80, 80); /* 白光 80 mA */
delay_1ms(5000);
dlp_off();
while (1);
}
#endif
把 dlpc3421.c 和 dlpc3421.h 放到你的 GD32 工程 Src / Inc 目录。
把 i2c_write / i2c_read / delay_1ms 替换为你自己的 HAL/裸机实现。
dlp_probe() 可用于启动自检；dlp_dump_regs() 用于串口调试。
至此，DLPC3421 的全部已知流程都已覆盖，可直接编译、调试、裁剪。

481
Src/i2c.c
View File

@@ -649,487 +649,6 @@ 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
\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, uint8_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) {
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 {
i2c_flag_clear(I2C0, I2C_FLAG_AERR);
timeout = 0;
#ifdef DEBUG_VERBOSE
printf("IIC 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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
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)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
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;
}
/* check if all data has been sent */
if (data_index >= length) {
/* wait until BTC bit is set for last byte */
timeout = 0;
while (!i2c_flag_get(I2C0, I2C_FLAG_BTC) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
state = I2C_STATE_STOP;
}
timeout = 0;
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:
/* 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++;
}
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_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
\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, uint8_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);
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 */
while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* 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)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
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;
}
if (write_phase) {
/* clear address flag (write phase) */
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
state = I2C_STATE_TRANSMIT_DATA;
} else {
/* read phase setup based on length */
if (length == 1) {
/* single byte read: disable ACK before clearing ADDR */
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
/* send STOP immediately after clearing ADDR for single byte */
i2c_stop_on_bus(I2C0);
} else if (length == 2) {
/* two bytes read: set POS=NEXT and disable ACK before clearing ADDR */
i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
} else {
/* multi-byte read: clear ADDR with ACK enabled */
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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* 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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
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;
while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* send slave address with read bit */
i2c_master_addressing(I2C0, (slave_addr << 1), I2C_RECEIVER);
/* switch to read phase */
write_phase = false;
state = I2C_STATE_CLEAR_ADDRESS;
timeout = 0;
break;
case I2C_STATE_RECEIVE_DATA:
if (length == 1) {
/* single byte read */
while ((!i2c_flag_get(I2C0, I2C_FLAG_RBNE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
data[0] = i2c_data_receive(I2C0);
state = I2C_STATE_STOP;
} else if (length == 2) {
/* two bytes read */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* send STOP before reading the last two bytes */
i2c_stop_on_bus(I2C0);
/* read the two bytes back-to-back */
data[0] = i2c_data_receive(I2C0);
data[1] = i2c_data_receive(I2C0);
state = I2C_STATE_STOP;
} else {
/* multi-byte read (length > 2) */
while (data_index < length) {
/* wait for RBNE (receive buffer not empty) */
while ((!i2c_flag_get(I2C0, I2C_FLAG_RBNE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* special handling for last 3 bytes */
if (data_index == length - 3) {
/* wait for BTF (byte transfer finished) before reading N-2 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* disable ACK for last 2 bytes */
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
}
/* read data byte */
data[data_index] = i2c_data_receive(I2C0);
data_index++;
/* send STOP after reading N-1 byte */
if (data_index == length - 1) {
i2c_stop_on_bus(I2C0);
}
timeout = 0;
}
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:
/* send stop condition to release bus */
i2c_stop_on_bus(I2C0);
/* 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
printf("I2C read failed after %d retries\n", I2C_MAX_RETRY);
#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;
}
}
return I2C_RESULT_TIMEOUT;
}
/* convenience functions for common operations */
i2c_result_t i2c_write_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data) {
return i2c_write(slave_addr, reg_addr, &data, 1);
}
i2c_result_t i2c_read_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
return i2c_read(slave_addr, reg_addr, data, 1);
}
i2c_result_t i2c_write_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[4]) {
return i2c_write(slave_addr, reg_addr, data, 4);
}
i2c_result_t i2c_read_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
return i2c_read(slave_addr, reg_addr, data, 4);
}
/* 显示面板专用函数 - 支持读取显示界面参数 */
i2c_result_t i2c_read_display_params(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data, uint8_t length) {
/* 针对显示面板的多字节读取，支持13字节的完整参数读取 */
if (length > 13) {
return I2C_RESULT_INVALID_PARAM;
}
return i2c_read(slave_addr, reg_addr, data, length);
}
#ifdef DEBUG_VERBOSE
/*!
\brief get status string for debugging

975
Src/iic_new.c Normal file
View File

@@ -0,0 +1,975 @@
// ...existing code...
/*!
\brief write data to I2C device with configurable length
\param[in] slave_addr: slave device address (7-bit)
\param[in] reg_addr: register address
\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, uint8_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) {
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 {
i2c_flag_clear(I2C0, I2C_FLAG_AERR);
timeout = 0;
#ifdef DEBUG_VERBOSE
printf("IIC 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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
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)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
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;
}
/* check if all data has been sent */
if (data_index >= length) {
/* wait until BTC bit is set for last byte */
timeout = 0;
while (!i2c_flag_get(I2C0, I2C_FLAG_BTC) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
state = I2C_STATE_STOP;
}
timeout = 0;
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:
/* 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++;
}
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_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
\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, uint8_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);
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 */
while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* 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)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
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;
}
if (write_phase) {
/* clear address flag (write phase) */
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
state = I2C_STATE_TRANSMIT_DATA;
} else {
/* read phase setup based on length */
if (length == 1) {
/* single byte read: disable ACK before clearing ADDR */
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
/* send STOP immediately after clearing ADDR for single byte */
i2c_stop_on_bus(I2C0);
} else if (length == 2) {
/* two bytes read: set POS=NEXT and disable ACK before clearing ADDR */
i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
} else {
/* multi-byte read: clear ADDR with ACK enabled */
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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* 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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
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;
while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* send slave address with read bit */
i2c_master_addressing(I2C0, (slave_addr << 1), I2C_RECEIVER);
/* switch to read phase */
write_phase = false;
state = I2C_STATE_CLEAR_ADDRESS;
timeout = 0;
break;
case I2C_STATE_RECEIVE_DATA:
if (length == 1) {
/* single byte read */
while ((!i2c_flag_get(I2C0, I2C_FLAG_RBNE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
data[0] = i2c_data_receive(I2C0);
state = I2C_STATE_STOP;
} else if (length == 2) {
/* two bytes read */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* send STOP before reading the last two bytes */
i2c_stop_on_bus(I2C0);
/* read the two bytes back-to-back */
data[0] = i2c_data_receive(I2C0);
data[1] = i2c_data_receive(I2C0);
state = I2C_STATE_STOP;
} else {
/* multi-byte read (length > 2) */
while (data_index < length) {
/* wait for RBNE (receive buffer not empty) */
while ((!i2c_flag_get(I2C0, I2C_FLAG_RBNE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* special handling for last 3 bytes */
if (data_index == length - 3) {
/* wait for BTF (byte transfer finished) before reading N-2 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* disable ACK for last 2 bytes */
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
}
/* read data byte */
data[data_index] = i2c_data_receive(I2C0);
data_index++;
/* send STOP after reading N-1 byte */
if (data_index == length - 1) {
i2c_stop_on_bus(I2C0);
}
timeout = 0;
}
state = I2C_STATE_STOP;
}
break;
case I2C_STATE_STOP:
/* wait for stop condition to complete (only if not already sent) */
if (length > 2) {
/* for multi-byte reads, STOP was already sent */
/* just wait for the STOP bit to clear */
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:
/* send stop condition to release bus */
i2c_stop_on_bus(I2C0);
/* 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
printf("I2C read failed after %d retries\n", I2C_MAX_RETRY);
#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;
}
}
return I2C_RESULT_TIMEOUT;
}
/* compatibility functions for legacy code */
i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[2]) {
return i2c_write(slave_addr, reg_addr, data, 2);
}
i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
return i2c_read(slave_addr, reg_addr, data, 2);
}
/* convenience functions for common operations */
i2c_result_t i2c_write_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data) {
return i2c_write(slave_addr, reg_addr, &data, 1);
}
i2c_result_t i2c_read_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
return i2c_read(slave_addr, reg_addr, data, 1);
}
i2c_result_t i2c_write_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[4]) {
return i2c_write(slave_addr, reg_addr, data, 4);
}
i2c_result_t i2c_read_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
return i2c_read(slave_addr, reg_addr, data, 4);
}
// ...existing code...
// ...existing code...
/*!
\brief write data to I2C device with configurable length
\param[in] slave_addr: slave device address (7-bit)
\param[in] reg_addr: register address
\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, uint8_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) {
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 {
i2c_flag_clear(I2C0, I2C_FLAG_AERR);
timeout = 0;
#ifdef DEBUG_VERBOSE
printf("IIC 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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
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)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
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;
}
/* check if all data has been sent */
if (data_index >= length) {
/* wait until BTC bit is set for last byte */
timeout = 0;
while (!i2c_flag_get(I2C0, I2C_FLAG_BTC) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
state = I2C_STATE_STOP;
}
timeout = 0;
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:
/* 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++;
}
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_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
\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, uint8_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);
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 */
while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* 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)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
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;
}
if (write_phase) {
/* clear address flag (write phase) */
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
state = I2C_STATE_TRANSMIT_DATA;
} else {
/* read phase setup based on length */
if (length == 1) {
/* single byte read: disable ACK before clearing ADDR */
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
/* send STOP immediately after clearing ADDR for single byte */
i2c_stop_on_bus(I2C0);
} else if (length == 2) {
/* two bytes read: set POS=NEXT and disable ACK before clearing ADDR */
i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
} else {
/* multi-byte read: clear ADDR with ACK enabled */
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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* 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 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
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;
while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* send slave address with read bit */
i2c_master_addressing(I2C0, (slave_addr << 1), I2C_RECEIVER);
/* switch to read phase */
write_phase = false;
state = I2C_STATE_CLEAR_ADDRESS;
timeout = 0;
break;
case I2C_STATE_RECEIVE_DATA:
if (length == 1) {
/* single byte read */
while ((!i2c_flag_get(I2C0, I2C_FLAG_RBNE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
data[0] = i2c_data_receive(I2C0);
state = I2C_STATE_STOP;
} else if (length == 2) {
/* two bytes read */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* send STOP before reading the last two bytes */
i2c_stop_on_bus(I2C0);
/* read the two bytes back-to-back */
data[0] = i2c_data_receive(I2C0);
data[1] = i2c_data_receive(I2C0);
state = I2C_STATE_STOP;
} else {
/* multi-byte read (length > 2) */
while (data_index < length) {
/* wait for RBNE (receive buffer not empty) */
while ((!i2c_flag_get(I2C0, I2C_FLAG_RBNE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* special handling for last 3 bytes */
if (data_index == length - 3) {
/* wait for BTF (byte transfer finished) before reading N-2 */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* disable ACK for last 2 bytes */
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
}
/* read data byte */
data[data_index] = i2c_data_receive(I2C0);
data_index++;
/* send STOP after reading N-1 byte */
if (data_index == length - 1) {
i2c_stop_on_bus(I2C0);
}
timeout = 0;
}
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:
/* send stop condition to release bus */
i2c_stop_on_bus(I2C0);
/* 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
printf("I2C read failed after %d retries\n", I2C_MAX_RETRY);
#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;
}
}
return I2C_RESULT_TIMEOUT;
}
/* convenience functions for common operations */
i2c_result_t i2c_write_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data) {
return i2c_write(slave_addr, reg_addr, &data, 1);
}
i2c_result_t i2c_read_8bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
return i2c_read(slave_addr, reg_addr, data, 1);
}
i2c_result_t i2c_write_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[4]) {
return i2c_write(slave_addr, reg_addr, data, 4);
}
i2c_result_t i2c_read_32bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
return i2c_read(slave_addr, reg_addr, data, 4);
}
/* 显示面板专用函数 - 支持读取显示界面参数 */
i2c_result_t i2c_read_display_params(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data, uint8_t length) {
/* 针对显示面板的多字节读取，支持13字节的完整参数读取 */
if (length > 13) {
return I2C_RESULT_INVALID_PARAM;
}
return i2c_read(slave_addr, reg_addr, data, length);
}
// ...existing code...

113
Src/ldc1612.c
View File

@@ -4,13 +4,6 @@
#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: 寄存器地址
@@ -60,38 +53,16 @@ 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);
if (sensor_freq <= 8.75) {
fin_div = LDC1612_FIN_DIV_1;
} else if (sensor_freq <= 17.5) {
fin_div = LDC1612_FIN_DIV_2;
} else if (sensor_freq <= 35.0) {
fin_div = LDC1612_FIN_DIV_4;
fin_div = (uint16_t) (sensor_freq / 8.75 + 1);
if (fin_div * 4 < 40) {
freq_div = 2;
} else {
LDC1612_DEBUG("Error: Sensor frequency (%.2f MHz) exceeds maximum limit!", sensor_freq);
return 0;
freq_div = 4;
}
/*
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);
value = fin_div << 12;
value |= freq_div;
return value;
}
@@ -182,7 +153,7 @@ ldc1612_status_t ldc1612_config_single_channel(uint8_t channel) {
ldc1612_write_register(MUX_CONFIG_REG, LDC1612_MUX_CONFIG);
/* Step 8: 配置错误输出 */
ldc1612_write_register(ERROR_CONFIG_REG, LDC1612_ERROR_CONFIG_DEFAULT);
ldc1612_write_register(ERROR_CONFIG_REG, LDC1612_ERROR_CONFIG);
/* Step 9: 最后启动传感器 - 必须最后一步 */
status = ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SENSOR_CONFIG_CH0);
@@ -203,11 +174,11 @@ uint32_t ldc1612_get_raw_channel_result(uint8_t channel) {
uint8_t value[2] = {0};
/* Read MSW */
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERSION_RESULT_REG_START + (channel * 2), value);
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERTION_RESULT_REG_START + (channel * 2), value);
raw_value |= (uint32_t)(((uint16_t)value[0] << 8) | value[1]) << 16;
/* Read LSW */
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERSION_RESULT_REG_START + 1 + (channel * 2), value);
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERTION_RESULT_REG_START + 1 + (channel * 2), value);
raw_value |= (uint32_t)(((uint16_t)value[0] << 8) | value[1]);
@@ -215,7 +186,7 @@ uint32_t ldc1612_get_raw_channel_result(uint8_t channel) {
if (calibration_value == 0x0FFFFFFF) {
return 0xF0000000; /* No coil */
}
if (LDC1612_ERROR_CONFIG_DEFAULT & 0xF800) {
if (LDC1612_ERROR_CONFIG & 0xF800) {
uint8_t error_code = (uint8_t)(raw_value >> 24);
if (error_code & 0x80) return 0x80000000; /* Under range */
if (error_code & 0x40) return 0x40000000; /* Over range */
@@ -248,7 +219,7 @@ void ldc1612_drvie_current_detect(uint8_t channel) {
init_value = (((data[0] << 8) | data[1]) >> 6) & 0x1F;
drive_current = (init_value << 11) | 0x0000;
LDC1612_DEBUG("init value: 0x%x\tdrive current: 0x%x\n", init_value, drive_current);
printf("init value: 0x%x\tdrive current: 0x%x\n", init_value, drive_current);
}
/** @brief Get sensor status register
@@ -272,64 +243,4 @@ 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;
}

12
Src/main.c
View File

@@ -51,8 +51,6 @@ OF SUCH DAMAGE.
*/
int main(void)
{
// nvic_vector_table_set(NVIC_VECTTAB_FLASH, 0x2000);
led_init();
mcu_detect_and_config();
@@ -62,7 +60,7 @@ int main(void)
// led_init();
// printf("Flash size: %d Kbytes\n", get_flash_size());
printf("Flash size: %d Kbytes\n", get_flash_size());
#ifdef DEBUG_VERBOSE
char hello_world[] = {"Hello World!\r\n"};
@@ -97,8 +95,14 @@ int main(void)
#ifndef EDDY_DRIVE_CURRENT_DETECTION
command_process();
delay_ms(10);
// if (g_eddy_current_sensor_report_enabled)
if (g_eddy_current_sensor_report_enabled)
eddy_current_report();
if (g_temperature_sensor_report_enabled)
temperature_raw_value_report();
#else
ldc1612_drvie_current_detect(CHANNEL_0);

3
Src/tmp112.c
View File

@@ -86,8 +86,7 @@ tmp112a_status_t tmp112a_read_temperature(tmp112a_result_t *result) {
}
void tmp112a_get_raw_temperature_value(uint8_t *value) {
// i2c_read_16bits(TMP112A_ADDR, TMP112A_TEMP_REG, value);
i2c_read(TMP112A_ADDR, TMP112A_TEMP_REG, value, 2);
i2c_read_16bits(TMP112A_ADDR, TMP112A_TEMP_REG, value);
return;
}

9
cmake/project_config.cmake
View File

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

7
cmake/version.h.in
View File

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

43
iic_new.md Normal file
View File

@@ -0,0 +1,43 @@
主要改进特性：
通用读写函数：
i2c_write()：支持任意长度的写操作
i2c_read()：支持任意长度的读操作
兼容性函数：保留原有的16位读写函数以保持向后兼容
便利函数：提供常用的8位、16位、32位读写函数
智能长度处理：
单字节读取：正确处理NACK和STOP时序
双字节读取：使用POS=NEXT模式
多字节读取：正确处理最后几个字节的ACK/NACK时序
错误处理：保持原有的重试机制和错误处理逻辑
使用示例：
```
uint8_t data[4];
i2c_result_t result;
// 读取1字节
result = i2c_read_8bits(0x48, 0x00, &data[0]);
// 读取2字节
result = i2c_read(0x48, 0x01, data, 2);
// 读取4字节
result = i2c_read_32bits(0x48, 0x02, data);
// 写入3字节
uint8_t write_data[3] = {0x11, 0x22, 0x33};
result = i2c_write(0x48,
```
主要功能特性
支持任意长度读写：从1字节到255字节
正确的ACK/NACK处理：根据读取长度智能处理
保持兼容性：原有的16位读写函数仍然可用
专用显示函数：为显示面板参数读取提供专门的函数
完整的错误处理：保持原有的重试和错误恢复机制
这样就可以支持您文档中提到的多字节显示面板参数读写操作了

3
start-vscode-no-openocd-env.bat Normal file
View File

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