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

release dev branch

Browse Source
This commit is contained in:
yelvlab
2025-08-17 02:58:32 +08:00
parent f82ab23898
commit 5cdd7ca58c
34 changed files with 5220 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

846
Src/command.c Normal file
View File

@@ -0,0 +1,846 @@
/**
* @file command.c
* @brief 串口命令解析与处理模块实现
* @details 实现基于状态机的协议解析器，支持 D5 03 LEN [cmd] CRC 格式的命令处理，
* 包含命令帧解析、响应生成和传感器状态管理功能。
* @author Hulk
* @date 2025-08-13
* @version 1.0.0
* @ingroup Command
*/
#include "command.h"
#include "uart_ring_buffer.h"
#include "led.h"
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include "board_config.h"
#include "gd32e23x_usart.h"
#include "ldc1612.h"
/* ============================================================================
* 协议格式说明
* ============================================================================ */
/**
* @name 协议帧格式
* @{
* @details
* Host -> Device 命令帧格式：
* [0] HEADER = 0xD5 // 包头标识
* [1] BOARD_TYPE = 0x03 // 板卡类型标识
* [2] LEN = 数据区字节数 // 有效载荷长度
* [3..(3+LEN-1)] 数据 // 命令数据，如 "M1", "M2S123"
* [last] CRC = 校验码 // 从索引1到(last-1)的累加和低8位
*
* 最小协议包长度为 6 字节
* 数据示例（两字节命令）："M1" / "M2" / "M3"
*
* Device -> Host 响应帧格式：
* [0] 0xB5 // 响应包头
* [1] TYPE // 响应类型（0xF0=成功，0xF1..=错误类型）
* [2] LEN // 响应数据长度
* [3..(3+LEN-1)] 数据 // 响应数据，如 "ok", "err"
* [last] CRC // 校验码（同命令帧规则）
* @}
*/
/* ============================================================================
* 协议常量定义
* ============================================================================ */
/** @name 协议帧标识符
* @{ */
#define PROTOCOL_PACKAGE_HEADER 0xD5 /**< 命令帧包头标识 */
#define PROTOCOL_BOARD_TYPE 0x03 /**< 板卡类型标识 */
/** @} */
/** @name 命令长度限制
* @{ */
#define COMMAND_MIN_LEN 2 /**< 最小命令长度，如"M1" */
#define PROTOCOL_MIN_FRAME_LEN (3 + COMMAND_MIN_LEN + 1) /**< 最小完整帧长度：header+type+len+payload+crc = 6 */
#define PROTOCOL_MAX_FRAME_LEN 16 /**< 最大完整帧长度 */
/** @} */
/** @name 响应帧标识符
* @{ */
#define RESP_HEADER 0xB5 /**< 响应帧包头标识 */
#define RESP_TYPE_OK 0xF0 /**< 成功响应类型 */
#define RESP_TYPE_CRC_ERR 0xF1 /**< CRC校验错误 */
#define RESP_TYPE_HEADER_ERR 0xF2 /**< 包头错误 */
#define RESP_TYPE_TYPE_ERR 0xF3 /**< 类型错误 */
#define RESP_TYPE_LEN_ERR 0xF4 /**< 长度错误 */
/** @} */
/* ============================================================================
* 模块内部变量
* ============================================================================ */
/** @brief 传感器周期上报使能标志 */
volatile bool g_sensor_report_enabled = false;
/** @name 预设响应数据
* @{ */
static const uint8_t s_report_status_ok[] = { 'o', 'k' }; /**< 成功响应数据 */
static const uint8_t s_report_status_err[] = { 'e','r','r' }; /**< 错误响应数据 */
/** @} */
/* ============================================================================
* 公共接口函数
* ============================================================================ */
/**
* @brief 查询是否启用周期性传感器上报。
* @return true 表示启用；false 表示禁用。
* @ingroup Command
*/
bool get_sensor_report_enabled(void)
{
return g_sensor_report_enabled;
}
/**
* @brief 设置是否启用周期性传感器上报标志。
* @details 本模块内部保存的布尔状态，供其他逻辑决定是否进行周期性数据上报；
* 推荐通过本函数修改而非直接访问全局/静态变量，以便后续扩展（如加锁/回调）。
* @param status true 启用周期上报；false 禁用。
* @ingroup Command
*/
void set_sensor_report_status(bool status)
{
g_sensor_report_enabled = status;
}
/**
* @brief 计算协议包的 8 位累加校验值（Checksum）。
* @details 对输入缓冲区逐字节累加并取低 8 位，累加范围为 data[1] 至 data[len-2]，
* 即不包含包头 HEADER（索引 0）与尾部 CRC 字节（索引 len-1）。
* 当 len 小于最小协议帧长度（PACKAGE_MIN_LENGTH）时返回 0。
* @param data 指向待校验的完整协议包缓冲区。
* @param len 缓冲区总长度（字节），应满足 header + type + len + payload + crc 的最小格式。
* @return uint8_t 计算得到的 8 位校验值。
* @note 本函数实现为简单求和校验（Checksum），非多项式 CRC；与本协议“从索引 1 累加到 len-2”的规则一致。
* @ingroup Command
*/
static uint8_t command_sum_crc_calc(const uint8_t *data, uint8_t len)
{
uint16_t crc = 0;
// 仅在满足协议最小帧长时计算（header + type + len + payload + crc）
if (len < PROTOCOL_MIN_FRAME_LEN) return 0;
// 累加从索引 1 到 len-2 的字节（不含 header 和 crc 字节）
for (uint8_t i = 1; i < (len - 1); i++)
{
crc += data[i];
}
return (uint8_t)(crc & 0xFF);
}
/**
* @brief 发送协议响应帧（使用GD32E230标准库）。
* @details 构造并发送格式为 B5 TYPE LEN [payload] CRC 的响应帧，
* 自动计算CRC校验值并通过串口输出。
* @param type 响应类型码（如 RESP_TYPE_OK, RESP_TYPE_CRC_ERR 等）。
* @param payload 指向响应数据的缓冲区，当len为0时可为NULL。
* @param len 响应数据长度（字节），为0时不复制payload数据。
* @note 内部使用固定大小缓冲区，超长响应将被丢弃。
* @warning 使用GD32E230标准库函数发送，确保串口已正确初始化。
* @ingroup Command
*/
static void send_response(uint8_t type, const uint8_t *payload, uint8_t len)
{
uint8_t buf_len = (uint8_t)(3 + len + 1);
uint8_t buf[16]; // 简单场景足够，必要时可增大
if (buf_len > sizeof(buf)) return; // 防御
buf[0] = RESP_HEADER;
buf[1] = type;
buf[2] = len;
// 简化逻辑：只有当len > 0且payload非空时才复制数据
if (len > 0 && payload != NULL) {
for (uint8_t i = 0; i < len; i++) {
buf[3 + i] = payload[i];
}
}
buf[buf_len - 1] = command_sum_crc_calc(buf, buf_len);
// 使用GD32E230标准库函数逐字节发送（标准库实现）
for (uint8_t i = 0; i < buf_len; i++) {
// 等待发送缓冲区空
while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(RS485_PHY, buf[i]);
}
// 等待发送完成
while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
// // 使用printf发送（通过重定向到串口）
// for (uint8_t i = 0; i < buf_len; i++) {
// printf("%c", buf[i]);
// }
// // 刷新缓冲区
// fflush(stdout);
}
/**
* @brief 判断字符是否为十进制数字字符。
* @param c 待检查的字符（ASCII码值）。
* @return bool 判断结果。
* @retval true 字符为 '0' 到 '9' 之间的数字字符。
* @retval false 字符不是十进制数字字符。
* @ingroup Command
*/
static inline bool is_dec_digit(uint8_t c) { return (c >= '0' && c <= '9'); }
/**
* @brief 从缓冲区解析十进制无符号整数。
* @details 从指定位置开始连续读取十进制数字字符，累加构成32位无符号整数。
* 遇到非数字字符或到达长度限制时停止解析。
* @param s 指向待解析字符缓冲区的起始位置。
* @param n 允许解析的最大字符数。
* @param out 输出参数，存储解析结果，可为NULL。
* @return uint8_t 实际消耗的字符数。
* @retval 0 首字符不是数字，解析失败。
* @retval >0 成功解析的数字字符个数。
* @note 不处理符号、空白字符或进制前缀。
* @warning 不进行溢出检查，超出uint32_t范围时按无符号算术溢出处理。
* @ingroup Command
*/
static uint8_t parse_uint_dec(const uint8_t *s, uint8_t n, uint32_t *out)
{
uint8_t i = 0;
uint32_t v = 0;
while (i < n && is_dec_digit(s[i]))
{
v = v * 10u + (uint32_t)(s[i] - '0');
i++;
}
if (i == 0) return 0; // 未读到数字
if (out) *out = v; //
return i;
}
/* ============================================================================
* 命令处理函数
* ============================================================================ */
/**
* @brief 解析并处理完整的命令帧。
* @details 处理经过协议校验的完整命令帧，支持以下命令格式：
* - 无参数命令：M<数字>（如 M1、M2、M10、M201）
* - 带参数命令：M<数字>S<参数>（如 M100S123，参数为十进制）
*
* 支持的命令：
* - M1: 开启LED，启用传感器上报
* - M2: 关闭LED，禁用传感器上报
* - M100S<value>: 设置PWM值（示例）
*
* @param frame 指向完整命令帧的缓冲区（从包头0xD5开始）。
* @param len 命令帧总长度（字节）。
* @note 函数内部进行帧格式校验，格式错误时自动发送错误响应。
* @warning 假设输入帧已通过基本协议校验（包头、类型、CRC等）。
* @ingroup Command
*/
void handle_command(const uint8_t *frame, uint8_t len) {
// 帧格式：D5 03 LEN [cmd] CRC; cmd 支持变长，如 "M1"、"M10"、"M201"、"M123S400"，有最小长度限制和命令长度校验
uint8_t cmd_len = frame[2];
if (len < PROTOCOL_MIN_FRAME_LEN || (uint8_t)(3 + cmd_len + 1) != len) return; // 长度不匹配或者小于最小限制
const uint8_t *cmd = &frame[3]; // 提取命令部分
// 命令必须以 'M' 开头
if (cmd[0] != 'M'){
send_response(RESP_TYPE_TYPE_ERR, s_report_status_err, sizeof(s_report_status_err));
return;
}
// 从 'M' 后开始解析
uint8_t cmd_index = 1;
// 解析M后的十进制数，即命令本体
uint32_t base_cmd = 0;
uint8_t used_base_cmd = parse_uint_dec(&cmd[cmd_index], (cmd_len - cmd_index), &base_cmd);
if (used_base_cmd == 0)
{
// 'M' 后没有数字，格式错误
send_response(RESP_TYPE_LEN_ERR, s_report_status_err, sizeof(s_report_status_err));
return;
}
cmd_index = (uint8_t)(cmd_index + used_base_cmd); // 更新索引到命令后
// 情况A：无附加参数的基础命令
if (cmd_index == cmd_len) {
// 仅基础命令，如 M1, M2, M3
switch (base_cmd) {
case 1u: // M1: enable sensor report
set_sensor_report_status(true);
return;
case 2u: // M2: disable sensor report
set_sensor_report_status(false);
return;
// 示例：M3、M10、M201、M100 等（按需添加）
// case 3u: // M3命令 - 高电流驱动测试
// /**
// * M3命令：使用更高驱动电流测试线圈响应
// * 响应格式：6字节状态信息
// *
// * 响应数据解析：
// * [0-1]: 传感器状态寄存器（大端序）
// * bit[15-8]: 预留
// * bit[7]: DRDY_1 - 通道1数据就绪
// * bit[6]: DRDY_0 - 通道0数据就绪
// * bit[5]: UNREAD_CONV - 未读转换结果
// * bit[4]: ERR_ZC - 零计数错误
// * bit[3]: ERR_AE - 幅度错误（重点关注）
// * bit[2]: ERR_WD - 看门狗超时
// * bit[1]: ERR_OR - 过量程错误
// * bit[0]: ERR_UR - 欠量程错误
// * [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
// * [3]: 0xA0 - 高电流测试标记
// * [4]: 幅度错误专用标志 (0xAE=有幅度错误, 0x00=无)
// * [5]: 0x33 - M3命令标记
// *
// * 分析要点：
// * - 如果[0-1]从0x0008变为其他值，说明高电流有效果
// * - 如果[2]变为0x01，说明数据开始就绪
// * - 如果[4]变为0x00，说明幅度错误消失
// */
// // 重置传感器
// ldc1612_reset_sensor();
// delay_ms(50);
// // 使用更高的驱动电流重新配置
// // ldc1612_write_register(SET_DRIVER_CURRENT_REG, 0xA000);
// delay_ms(10);
// // 重新配置其他参数
// ldc1612_config_single_channel(CHANNEL_0);
// delay_ms(200); // 更长稳定时间
// // 检查结果
// uint16_t status_m3 = ldc1612_get_sensor_status();
// bool ready_m3 = ldc1612_is_data_ready(CHANNEL_0);
// uint8_t m3_info[6];
// m3_info[0] = (uint8_t)(status_m3 >> 8);
// m3_info[1] = (uint8_t)(status_m3 & 0xFF);
// m3_info[2] = ready_m3 ? 0x01 : 0x00;
// m3_info[3] = 0xA0; // 高电流标记
// m3_info[4] = (status_m3 & 0x0008) ? 0xAE : 0x00; // 幅度错误标志
// m3_info[5] = 0x33; // M3命令标记
// send_response(RESP_TYPE_OK, m3_info, sizeof(m3_info));
// return;
// case 4u: // M4命令 - 寄存器诊断
// /**
// * M4命令：读取关键寄存器进行配置诊断
// * 响应格式：8字节寄存器信息
// *
// * 响应数据解析：
// * [0-1]: 状态寄存器 (0x18) - 当前传感器状态
// * [2-3]: 传感器配置寄存器 (0x1A) - 传感器工作模式
// * 期望值: 0x1601 (活动模式，单通道)
// * [4-5]: 驱动电流寄存器 (0x1E) - 当前驱动电流设置
// * 常见值: 0x9000(默认), 0xA000(高), 0xF800(最高)
// * [6]: I2C读取状态 (0x4F='O'=成功, 0xEE=失败)
// * [7]: 0x44 - M4命令标记
// *
// * 分析要点：
// * - [2-3]应该是0x1601，如果不是说明配置异常
// * - [4-5]显示实际的驱动电流设置
// * - [6]必须是0x4F，否则I2C通信有问题
// */
// // 简化版本，只读取最关键的寄存器，避免I2C超时
// uint16_t status_reg = ldc1612_get_sensor_status(); // 0x18
// // 逐一安全读取关键寄存器
// uint8_t data_buf[2] = {0};
// uint16_t sensor_config = 0;
// uint16_t drive_current = 0;
// // 尝试读取传感器配置寄存器
// bool result1_ok = (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, data_buf) == I2C_RESULT_SUCCESS);
// if (result1_ok) {
// sensor_config = (data_buf[0] << 8) | data_buf[1];
// }
// // 尝试读取驱动电流寄存器
// bool result2_ok = (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, data_buf) == I2C_RESULT_SUCCESS);
// if (result2_ok) {
// drive_current = (data_buf[0] << 8) | data_buf[1];
// }
// // 构造8字节简化诊断信息
// uint8_t diag_info[8];
// diag_info[0] = (uint8_t)(status_reg >> 8); // 状态寄存器高位
// diag_info[1] = (uint8_t)(status_reg & 0xFF); // 状态寄存器低位
// diag_info[2] = (uint8_t)(sensor_config >> 8); // 传感器配置寄存器高位
// diag_info[3] = (uint8_t)(sensor_config & 0xFF); // 传感器配置寄存器低位
// diag_info[4] = (uint8_t)(drive_current >> 8); // 驱动电流寄存器高位
// diag_info[5] = (uint8_t)(drive_current & 0xFF); // 驱动电流寄存器低位
// diag_info[6] = (result1_ok && result2_ok) ? 0x4F : 0xEE; // I2C状态
// diag_info[7] = 0x44; // M4命令标记
// send_response(RESP_TYPE_OK, diag_info, sizeof(diag_info));
// return;
// case 5u: // M5命令 - 最高电流启动测试
// // 命令: D5 03 02 4D 35 87
// // 响应: B5 F0 08 [状态2字节][就绪标志][电流设置2字节][幅度错误标志][M5标记][最高电流标记] CRC
// // 响应格式:
// // [0-1]: 传感器状态寄存器（启动后状态）
// // [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
// // [3-4]: 实际驱动电流设置值（应该是0xF800）
// // [5]: 幅度错误专用标志 (0xAE=仍有错误, 0x00=错误消失)
// // [6]: 0x55 - M5命令标记
// // [7]: 0xF8 - 最高电流标记
// // 重置传感器
// ldc1612_reset_sensor();
// delay_ms(100);
// // 使用最高驱动电流并固定配置
// // ldc1612_write_register(SET_DRIVER_CURRENT_REG, 0xF800);
// delay_ms(10);
// // 手动配置其他必要寄存器，避免被覆盖
// // 配置频率分频器为较低频率 (更容易起振)
// uint8_t freq_data[2] = {0x10, 0x00}; // 较低分频
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_data);
// delay_ms(10);
// // 设置较长的LC稳定时间
// uint8_t lc_data[2] = {0x04, 0x00}; // 更长稳定时间
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_LC_STABILIZE_REG_START + CHANNEL_0, lc_data);
// delay_ms(10);
// // 配置MUX为单通道模式
// // ldc1612_configure_mux_register(0, CHANNEL_0, LDC1612_MUX_RR_SEQUENCE_1, LDC1612_MUX_FILTER_1MHz);
// delay_ms(10);
// // 启动传感器
// uint8_t sensor_cfg_data[2] = {0x16, 0x01}; // 活动模式，单通道
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sensor_cfg_data);
// delay_ms(200); // 更长稳定时间
// // 读取结果
// uint16_t status_m5 = ldc1612_get_sensor_status();
// bool ready_m5 = ldc1612_is_data_ready(CHANNEL_0);
// // 再次确认驱动电流设置
// uint8_t curr_data[2];
// LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, curr_data);
// uint16_t actual_current = (curr_data[0] << 8) | curr_data[1];
// uint8_t m5_info[8];
// m5_info[0] = (uint8_t)(status_m5 >> 8);
// m5_info[1] = (uint8_t)(status_m5 & 0xFF);
// m5_info[2] = ready_m5 ? 0x01 : 0x00;
// m5_info[3] = (uint8_t)(actual_current >> 8); // 实际电流设置高位
// m5_info[4] = (uint8_t)(actual_current & 0xFF); // 实际电流设置低位
// m5_info[5] = (status_m5 & 0x0008) ? 0xAE : 0x00; // 幅度错误标志
// m5_info[6] = 0x55; // M5命令标记
// m5_info[7] = 0xF8; // 最高电流标记
// send_response(RESP_TYPE_OK, m5_info, sizeof(m5_info));
// return;
// case 6u: // M6命令 - 芯片功能验证
// // 命令: D5 03 02 4D 36 88
// // 响应: B5 F0 0C [写入值2字节][读取值2字节][制造商ID2字节][设备ID2字节][状态2字节][ID读取状态][M6标记] CRC
// // 响应格式:
// // [0-1]: 写入测试值 (0x9000)
// // [2-3]: 读取回的值
// // [4-5]: 制造商ID (应该是0x5449="TI")
// // [6-7]: 设备ID (应该是0x3055)
// // [8-9]: 当前状态寄存器
// // [10]: ID读取状态 (0x4F=成功, 0xEE=失败)
// // [11]: 0x66 - M6命令标记
// // 测试1: 写入和读取特定值到驱动电流寄存器
// uint8_t test_current_data[2] = {0x90, 0x00}; // 写入0x9000
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, test_current_data);
// delay_ms(10);
// // 读取验证
// uint8_t read_current_data[2];
// LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, read_current_data);
// uint16_t read_current = (read_current_data[0] << 8) | read_current_data[1];
// // 测试2: 读取制造商ID和设备ID
// uint8_t manufacturer_data[2];
// uint8_t device_data[2];
// bool id_read_ok = true;
// if (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, 0x7E, manufacturer_data) != I2C_RESULT_SUCCESS) {
// id_read_ok = false;
// }
// if (LDC1612_IIC_READ_16BITS(LDC1612_ADDR, 0x7F, device_data) != I2C_RESULT_SUCCESS) {
// id_read_ok = false;
// }
// uint16_t manufacturer_id = id_read_ok ? ((manufacturer_data[0] << 8) | manufacturer_data[1]) : 0x0000;
// uint16_t device_id = id_read_ok ? ((device_data[0] << 8) | device_data[1]) : 0x0000;
// // 测试3: 检查当前状态
// uint16_t current_status = ldc1612_get_sensor_status();
// // 构造12字节测试结果
// uint8_t test_info[12];
// test_info[0] = 0x90; // 写入的值高位
// test_info[1] = 0x00; // 写入的值低位
// test_info[2] = (uint8_t)(read_current >> 8); // 读取的值高位
// test_info[3] = (uint8_t)(read_current & 0xFF); // 读取的值低位
// test_info[4] = (uint8_t)(manufacturer_id >> 8);
// test_info[5] = (uint8_t)(manufacturer_id & 0xFF);
// test_info[6] = (uint8_t)(device_id >> 8);
// test_info[7] = (uint8_t)(device_id & 0xFF);
// test_info[8] = (uint8_t)(current_status >> 8);
// test_info[9] = (uint8_t)(current_status & 0xFF);
// test_info[10] = id_read_ok ? 0x4F : 0xEE; // ID读取状态
// test_info[11] = 0x66; // M6命令标记
// send_response(RESP_TYPE_OK, test_info, sizeof(test_info));
// return;
// case 7u: // M7命令 - 保守参数测试
// // 命令: D5 03 02 4D 37 89
// // 响应: B5 F0 0A [状态2字节][就绪标志][频率设置2字节][幅度错误标志][欠量程错误标志][过量程错误标志][M7标记][低频标记] CRC
// // 响应格式:
// // [0-1]: 状态寄存器
// // [2]: 数据就绪标志
// // [3-4]: 实际频率分频器设置 (0x2000=较低频率)
// // [5]: 幅度错误标志 (0xAE=有错误, 0x00=无)
// // [6]: 欠量程错误标志 (0x01=有, 0x00=无)
// // [7]: 过量程错误标志 (0x02=有, 0x00=无)
// // [8]: 0x77 - M7命令标记
// // [9]: 0x20 - 低频标记
// // 重置传感器
// ldc1612_reset_sensor();
// delay_ms(100);
// // 使用保守的配置尝试启动线圈
// // 1. 设置最高驱动电流
// uint8_t drive_data[2] = {0xF8, 0x00}; // 最高电流
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, drive_data);
// delay_ms(10);
// // 2. 设置较低的频率分频器(适合更大电感值)
// uint8_t freq_low_data[2] = {0x20, 0x00}; // 更低频率
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_low_data);
// delay_ms(10);
// // 3. 设置更长的LC稳定时间
// uint8_t lc_stable_data[2] = {0x08, 0x00}; // 更长稳定时间
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_LC_STABILIZE_REG_START + CHANNEL_0, lc_stable_data);
// delay_ms(10);
// // 4. 设置更长的转换时间
// uint8_t conv_time_data[2] = {0x04, 0x00}; // 更长转换时间
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_CONVERSION_TIME_REG_START + CHANNEL_0, conv_time_data);
// delay_ms(10);
// // 5. 设置转换偏移
// uint8_t conv_offset_data[2] = {0x00, 0x00};
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_CONVERSION_OFFSET_REG_START + CHANNEL_0, conv_offset_data);
// delay_ms(10);
// // 6. 配置错误寄存器 - 降低错误敏感度
// uint8_t error_config_data[2] = {0x00, 0x00}; // 允许所有错误
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, ERROR_CONFIG_REG, error_config_data);
// delay_ms(10);
// // 7. 配置MUX寄存器
// // ldc1612_configure_mux_register(0, CHANNEL_0, LDC1612_MUX_RR_SEQUENCE_1, LDC1612_MUX_FILTER_1MHz);
// delay_ms(10);
// // 8. 启动传感器
// uint8_t sensor_start_data[2] = {0x16, 0x01}; // 活动模式
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sensor_start_data);
// delay_ms(500); // 给予充分时间稳定
// // 检查结果
// uint16_t status_m7 = ldc1612_get_sensor_status();
// bool ready_m7 = ldc1612_is_data_ready(CHANNEL_0);
// // 读取实际配置的频率分频器确认
// uint8_t freq_readback[2];
// LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, freq_readback);
// uint16_t freq_actual = (freq_readback[0] << 8) | freq_readback[1];
// uint8_t m7_info[10];
// m7_info[0] = (uint8_t)(status_m7 >> 8);
// m7_info[1] = (uint8_t)(status_m7 & 0xFF);
// m7_info[2] = ready_m7 ? 0x01 : 0x00;
// m7_info[3] = (uint8_t)(freq_actual >> 8); // 实际频率分频器
// m7_info[4] = (uint8_t)(freq_actual & 0xFF);
// m7_info[5] = (status_m7 & 0x0008) ? 0xAE : 0x00; // 幅度错误
// m7_info[6] = (status_m7 & 0x0001) ? 0x01 : 0x00; // 欠量程错误
// m7_info[7] = (status_m7 & 0x0002) ? 0x02 : 0x00; // 过量程错误
// m7_info[8] = 0x77; // M7命令标记
// m7_info[9] = 0x20; // 低频标记
// send_response(RESP_TYPE_OK, m7_info, sizeof(m7_info));
// return;
// case 8u: // M8命令 - 极端参数测试
// // 命令: D5 03 02 4D 38 8A
// // 响应: B5 F0 06 [状态2字节][就绪标志][幅度错误标志][M8标记][极端测试标记] CRC
// // 响应格式:
// // [0-1]: 传感器状态寄存器
// // [2]: 数据就绪标志 (0x01=就绪, 0x00=未就绪)
// // [3]: 幅度错误标志 (0xAE=仍有错误, 0x00=错误消失)
// // [4]: 0x88 - M8命令标记
// // [5]: 0xEE - 极端测试标记
// {
// // 重置传感器
// ldc1612_reset_sensor();
// delay_ms(100);
// // 极端配置1: 极低频率
// uint8_t extreme_freq[2] = {0x40, 0x00};
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, extreme_freq);
// delay_ms(10);
// // 极端配置2: 最大驱动电流
// uint8_t max_drive[2] = {0xFF, 0x00};
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, max_drive);
// delay_ms(10);
// // 极端配置3: 禁用错误检测
// uint8_t no_errors[2] = {0x00, 0x00};
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, ERROR_CONFIG_REG, no_errors);
// delay_ms(10);
// // 启动传感器
// uint8_t start_data[2] = {0x16, 0x01};
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_data);
// delay_ms(1000); // 等待1秒
// // 读取状态
// uint16_t status_8 = ldc1612_get_sensor_status();
// bool ready_8 = ldc1612_is_data_ready(CHANNEL_0);
// uint8_t m8_result[6];
// m8_result[0] = (uint8_t)(status_8 >> 8);
// m8_result[1] = (uint8_t)(status_8 & 0xFF);
// m8_result[2] = ready_8 ? 0x01 : 0x00;
// m8_result[3] = (status_8 & 0x0008) ? 0xAE : 0x00; // 幅度错误
// m8_result[4] = 0x88; // M8标记
// m8_result[5] = 0xEE; // 极端测试标记
// send_response(RESP_TYPE_OK, m8_result, sizeof(m8_result));
// return;
// }
// case 9u: // M9命令 - 多频率特性测试
// // 命令: D5 03 02 4D 39 8B
// // 响应: B5 F0 08 [高频状态2字节][高频就绪标志][低频状态2字节][低频就绪标志][M9标记][多频测试标记] CRC
// // 响应格式:
// // [0-1]: 高频测试状态
// // [2]: 高频就绪标志 (0x01=就绪, 0x00=未就绪)
// // [3-4]: 低频测试状态
// // [5]: 低频就绪标志 (0x01=就绪, 0x00=未就绪)
// // [6]: 0x99 - M9命令标记
// // [7]: 0xAA - 多频测试标记
// {
// // 测试1: 高频配置
// ldc1612_reset_sensor();
// delay_ms(50);
// uint8_t high_freq[2] = {0x04, 0x00}; // 高频
// uint8_t low_drive[2] = {0x80, 0x00}; // 低电流
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, high_freq);
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, low_drive);
// delay_ms(10);
// // 启动高频测试
// uint8_t start_hf[2] = {0x16, 0x01};
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_hf);
// delay_ms(200);
// uint16_t hf_status = ldc1612_get_sensor_status();
// bool hf_ready = ldc1612_is_data_ready(CHANNEL_0);
// // 测试2: 低频配置
// uint8_t sleep_mode[2] = {0x20, 0x01};
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, sleep_mode);
// delay_ms(50);
// uint8_t low_freq[2] = {0x20, 0x00}; // 低频
// uint8_t high_drive[2] = {0xC0, 0x00}; // 高电流
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_FREQ_REG_START + CHANNEL_0, low_freq);
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, high_drive);
// delay_ms(10);
// // 启动低频测试
// LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, start_hf);
// delay_ms(200);
// uint16_t lf_status = ldc1612_get_sensor_status();
// bool lf_ready = ldc1612_is_data_ready(CHANNEL_0);
// uint8_t m9_result[8];
// m9_result[0] = (uint8_t)(hf_status >> 8); // 高频状态
// m9_result[1] = (uint8_t)(hf_status & 0xFF);
// m9_result[2] = hf_ready ? 0x01 : 0x00; // 高频就绪
// m9_result[3] = (uint8_t)(lf_status >> 8); // 低频状态
// m9_result[4] = (uint8_t)(lf_status & 0xFF);
// m9_result[5] = lf_ready ? 0x01 : 0x00; // 低频就绪
// m9_result[6] = 0x99; // M9标记
// m9_result[7] = 0xAA; // 多频测试标记
// send_response(RESP_TYPE_OK, m9_result, sizeof(m9_result));
// return;
// }
// case 201u: // M201命令
// send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
// return;
default:
// 其它无参数命令在此扩展（示例：M100）处理逻辑该如何待定
// send_response(RESP_TYPE_OK, s_report_status_ok, sizeof(s_report_status_ok));
// return;
break;
}
// 未在处理列表的无参数基础命令，回复错误
send_response(RESP_TYPE_TYPE_ERR, s_report_status_err, sizeof(s_report_status_err));
return;
}
// 情况B：有附加参数的命令
if (cmd[cmd_index] == 'S') {
cmd_index++;
uint32_t param_value = 0;
const uint8_t used_param_cmd = parse_uint_dec(&cmd[cmd_index], (uint8_t)(cmd_len - cmd_index), &param_value);
if (used_param_cmd == 0) {
// 'S' 后没有数字，格式错误
send_response(RESP_TYPE_LEN_ERR, s_report_status_err, sizeof(s_report_status_err));
return;
}
switch (base_cmd)
{
// case 100u:
// // set_pwm(param_value);
// printf("Set PWM to %u\n", param_value);
// return;
default:
break;
}
send_response(RESP_TYPE_TYPE_ERR, s_report_status_err, sizeof(s_report_status_err));
}
}
/**
* @brief 处理串口环形缓冲区中的命令数据，解析完整的协议帧。
* @details 本函数实现一个基于状态机的协议解析器，用于处理格式为 D5 03 LEN [cmd] CRC 的命令帧：
* - 状态1：等待包头字节 PROTOCOL_PACKAGE_HEADER (0xD5)
* - 状态2：接收板卡类型字节 PROTOCOL_BOARD_TYPE (0x03)
* - 状态3：接收长度字段并计算期望的完整帧长度
* - 状态4：继续接收剩余数据直到完整帧
* - 状态5：对完整帧进行校验（包头、板卡类型、CRC）并处理
*
* 函数采用非阻塞方式处理，每次调用处理缓冲区中所有可用数据。
* 遇到格式错误、长度异常或校验失败时自动重置状态机。
*
* @note 本函数使用静态变量维护解析状态，因此不可重入。在中断环境中使用需注意并发安全。
* 协议帧最大长度受 PROTOCOL_MAX_FRAME_LEN 限制，超出范围的帧将被丢弃。
*
* @warning 函数依赖 uart_ring_buffer_available() 和 uart_ring_buffer_get()
* 正确实现，若这些函数有缺陷可能导致死循环或数据丢失。
*
* @see handle_command() 用于处理校验通过的完整命令帧
* @see command_sum_crc_calc() 用于计算和校验 CRC 值
* @see send_response() 用于发送错误响应
*
* @ingroup Command
*/
void command_process(void) {
static uint8_t cmd_buf[PROTOCOL_MAX_FRAME_LEN];
static uint8_t cmd_len = 0;
static uint8_t expected_cmd_len = 0; // 0 表示尚未确定总长度
while (uart_ring_buffer_available() > 0) {
int byte = uart_ring_buffer_get();
if (byte < 0) break;
if (cmd_len == 0) {
if ((uint8_t)byte == PROTOCOL_PACKAGE_HEADER) {
cmd_buf[cmd_len++] = (uint8_t)byte;
expected_cmd_len = 0; // 等待进一步字段以确定长度
} else {
// 丢弃非起始字节
}
continue;
}
if (cmd_len >= PROTOCOL_MAX_FRAME_LEN) {
// 防御：缓冲溢出，复位状态机
cmd_len = 0;
expected_cmd_len = 0;
}
// 缓存后续字节
cmd_buf[cmd_len++] = (uint8_t)byte;
// 当到达长度字段（索引 2）后，确定总长度：3 + LEN + 1
if (cmd_len == 3) {
uint8_t payload_len = cmd_buf[2];
expected_cmd_len = (uint8_t)(3 + payload_len + 1);
if (expected_cmd_len > PROTOCOL_MAX_FRAME_LEN) {
// 异常：长度超界，复位状态机
cmd_len = 0;
expected_cmd_len = 0;
}
continue;
}
if (expected_cmd_len > 0 && cmd_len == expected_cmd_len) {
// 到帧尾，进行各项校验
bool verification_status = true;
#ifdef DEBUG_VERBOSE
if (cmd_buf[0] != PROTOCOL_PACKAGE_HEADER) {
send_response(RESP_TYPE_HEADER_ERR, s_report_status_err, sizeof(s_report_status_err));
verification_status = false;
}
#endif
if (verification_status && cmd_buf[1] != PROTOCOL_BOARD_TYPE) {
send_response(RESP_TYPE_TYPE_ERR, s_report_status_err, sizeof(s_report_status_err));
verification_status = false;
}
if (verification_status) {
uint8_t crc_calc = command_sum_crc_calc(cmd_buf, expected_cmd_len);
uint8_t crc_recv = cmd_buf[expected_cmd_len - 1];
if (crc_calc != crc_recv) {
send_response(RESP_TYPE_CRC_ERR, s_report_status_err, sizeof(s_report_status_err));
verification_status = false;
}
}
if (verification_status) {
handle_command(cmd_buf, expected_cmd_len);
}
// 复位，等待下一帧
cmd_len = 0;
expected_cmd_len = 0;
}
}
}
void eddy_current_report(void) {
// if (!g_sensor_report_enabled) return;
uint32_t raw_result = ldc1612_get_raw_channel_result(CHANNEL_0);
uint8_t sensor_data[4];
sensor_data[0] = (uint8_t)(raw_result >> 24);
sensor_data[1] = (uint8_t)(raw_result >> 16);
sensor_data[2] = (uint8_t)(raw_result >> 8);
sensor_data[3] = (uint8_t)(raw_result & 0xFF);
send_response(RESP_TYPE_OK, sensor_data, sizeof(sensor_data));
}

14
Src/gd32e23x_it.c
View File

@@ -34,6 +34,9 @@ OF SUCH DAMAGE.
#include "gd32e23x_it.h"
#include "systick.h"
#include "uart.h"
#include "uart_ring_buffer.h"
#include "led.h"
/*!
\brief this function handles NMI exception
@@ -93,7 +96,14 @@ void PendSV_Handler(void)
\param[out] none
\retval none
*/
void SysTick_Handler(void)
{
void SysTick_Handler(void) {
led_heart_beat(); // LED心跳指示灯
delay_decrement();
}
void USART0_IRQHandler(void) {
if (RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_RBNE)) {
uint8_t data = usart_data_receive(USART0);
(void)uart_ring_buffer_put(data); // 缓冲满时丢弃，返回值可用于统计
}
}

677
Src/i2c.c Normal file
View File

@@ -0,0 +1,677 @@
//
// Created by dell on 24-12-20.
//
#include "i2c.h"
/*!
\brief configure the GPIO ports
\param[in] none
\param[out] none
\retval none
*/
void i2c_gpio_config(void) {
/* enable IIC GPIO clock */
rcu_periph_clock_enable(RCU_GPIO_I2C);
/* connect I2C_SCL_PIN to I2C_SCL */
gpio_af_set(I2C_SCL_PORT, I2C_GPIO_AF, I2C_SCL_PIN);
/* connect I2C_SDA_PIN to I2C_SDA */
gpio_af_set(I2C_SDA_PORT, I2C_GPIO_AF, I2C_SDA_PIN);
/* configure GPIO pins of I2C */
gpio_mode_set(I2C_SCL_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, I2C_SCL_PIN);
gpio_output_options_set(I2C_SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
gpio_mode_set(I2C_SDA_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, I2C_SDA_PIN);
gpio_output_options_set(I2C_SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);
}
/*!
\brief configure the I2CX interface
\param[in] none
\param[out] none
\retval none
*/
i2c_result_t i2c_config(void) {
/* configure I2C GPIO */
i2c_gpio_config();
/* enable I2C clock */
rcu_periph_clock_enable(RCU_I2C);
/* configure I2C clock */
i2c_clock_config(I2C0, I2C_SPEED, I2C_DTCY_2);
/* configure I2C address */
i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, 0xA0);
/* enable I2CX */
i2c_enable(I2C0);
/* enable acknowledge */
i2c_ack_config(I2C0, I2C_ACK_ENABLE);
return I2C_RESULT_SUCCESS;
}
/* wait for SCL to go high, return true if successful, false if timeout */
static bool i2c_wait_scl_high(uint16_t max_wait_time) {
while (max_wait_time--) {
if (gpio_input_bit_get(I2C_SCL_PORT, I2C_SCL_PIN)) {
return true;
}
delay_10us(1);
}
return false;
}
/* generate one manual SCL pulse; return true if SCL observed high (no stuck/overstretch) */
static bool i2c_generate_scl_pulse(void) {
GPIO_BC(I2C_SCL_PORT) = I2C_SCL_PIN; /* drive SCL low */
delay_10us(1);
GPIO_BOP(I2C_SCL_PORT) = I2C_SCL_PIN; /* release SCL (open-drain -> high via pull-up) */
return i2c_wait_scl_high(200); /* wait up to ~2ms for clock stretching release */
}
/*!
\brief reset I2C bus
\param[in] none
\param[out] none
\retval none
*/
i2c_result_t i2c_bus_reset(void) {
/* 1. Disable & deinit peripheral so pins can be fully controlled */
i2c_disable(I2C0);
i2c_deinit(I2C0);
#ifdef DEBUG_VERBOSE
printf("I2C bus reset\r\n");
#endif
/* 2. Configure SCL/SDA as GPIO open-drain outputs with pull-up and release them */
gpio_mode_set(I2C_SCL_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, I2C_SCL_PIN);
gpio_mode_set(I2C_SDA_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, I2C_SDA_PIN);
gpio_output_options_set(I2C_SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
gpio_output_options_set(I2C_SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);
gpio_bit_set(I2C_SCL_PORT, I2C_SCL_PIN); /* release SCL */
gpio_bit_set(I2C_SDA_PORT, I2C_SDA_PIN); /* release SDA */
#ifdef DEBUG_VERBOSE
printf("I2C bus reset: SCL = %d, SDA = %d\r\n", gpio_input_bit_get(I2C_SCL_PORT, I2C_SCL_PIN), gpio_input_bit_get(I2C_SDA_PORT, I2C_SDA_PIN));
#endif
/* 3. Double sample to confirm bus state */
delay_10us(1);
bool scl_value1 = gpio_input_bit_get(I2C_SCL_PORT, I2C_SCL_PIN);
bool sda_value1 = gpio_input_bit_get(I2C_SDA_PORT, I2C_SDA_PIN);
delay_10us(1);
bool scl_value2 = gpio_input_bit_get(I2C_SCL_PORT, I2C_SCL_PIN);
bool sda_value2 = gpio_input_bit_get(I2C_SDA_PORT, I2C_SDA_PIN);
/* 4. If SCL low -> stuck (cannot proceed) */
if (!scl_value2) {
#ifdef DEBUG_VERBOSE
printf("I2C bus reset: SCL stuck low\r\n");
#endif
return I2C_RECOVERY_SCL_STUCK_LOW;
}
/* 5. Fast path: bus idle */
if (scl_value1 && sda_value1 && scl_value2 && sda_value2) {
i2c_config();
#ifdef DEBUG_VERBOSE
printf("I2C bus reset: bus idle\r\n");
#endif
return I2C_RECOVERY_OK;
}
/* 6. SDA low: attempt to free by generating up to I2C_RECOVERY_CLOCKS pulses */
if (scl_value2 && !sda_value2) {
bool sda_released = false;
#ifdef DEBUG_VERBOSE
printf("I2C bus reset: SCL will try to free SDA\r\n");
#endif
for (uint8_t i = 0; i < I2C_RECOVERY_CLOCKS && !sda_released; i++) {
if (!i2c_generate_scl_pulse()) {
return I2C_RECOVERY_SCL_STUCK_LOW; /* SCL failed to go high */
}
if (gpio_input_bit_get(I2C_SDA_PORT, I2C_SDA_PIN)) {
sda_released = true;
}
}
if (!sda_released) {
return I2C_RECOVERY_SDA_STUCK_LOW;
}
/* 7. Generate a STOP condition to leave bus in idle state */
#ifdef DEBUG_VERBOSE
printf("I2C bus reset: generating STOP condition\r\n");
#endif
gpio_bit_reset(I2C_SDA_PORT, I2C_SDA_PIN); /* SDA low */
delay_10us(1);
gpio_bit_set(I2C_SCL_PORT, I2C_SCL_PIN); /* ensure SCL high */
delay_10us(1);
gpio_bit_set(I2C_SDA_PORT, I2C_SDA_PIN); /* SDA rising while SCL high -> STOP */
delay_10us(1);
}
#ifdef DEBUG_VERBOSE
printf("I2C bus reset: bus recovered\r\n");
#endif
/* 8. Reconfigure & enable peripheral */
i2c_config();
return I2C_RECOVERY_OK;
}
/**
* @brief 扫描I2C总线，查找连接的设备
*
* 该函数会扫描I2C总线上的所有地址（1到126），并尝试与每个地址进行通信。
* 如果在某个地址上发现了设备，则会打印出该设备的地址。
* 最后会打印出找到的设备总数。
*/
void i2c_scan(void) {
uint32_t timeout;
uint8_t address;
int found_devices = 0;
// printf("Scanning I2C bus...\r\n");
const char* msg1 = "Scanning I2C bus...\r\n";
for (uint8_t i = 0; msg1[i] != '\0'; i++) {
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, msg1[i]);
}
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TC) == RESET) {}
for (address = 1; address < 127; address++) {
timeout = 0;
// 生成起始条件
while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT))
timeout++;
if (timeout >= I2C_TIME_OUT) {
continue; // 超时，跳过该地址
}
i2c_start_on_bus(I2C0);
timeout = 0;
// 等待起始条件发送完成
while (!i2c_flag_get(I2C0, I2C_FLAG_SBSEND) && (timeout < I2C_TIME_OUT))
timeout++;
if (timeout >= I2C_TIME_OUT) {
continue; // 超时，跳过该地址
}
i2c_master_addressing(I2C0, (address << 1), I2C_TRANSMITTER);
timeout = 0;
// 等待地址发送完成
while (!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND) && (timeout < I2C_TIME_OUT))
timeout++;
if (timeout < I2C_TIME_OUT) {
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
// printf("Found device at 0x%02X\r\n", address);
const char* msg2_prefix = "Found device at 0x";
for (uint8_t i = 0; msg2_prefix[i] != '\0'; i++) {
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, msg2_prefix[i]);
}
// 发送地址的十六进制表示
uint8_t hex_chars[] = "0123456789ABCDEF";
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, hex_chars[(address >> 4) & 0x0F]);
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, hex_chars[address & 0x0F]);
const char* msg2_suffix = "\r\n";
for (uint8_t i = 0; msg2_suffix[i] != '\0'; i++) {
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, msg2_suffix[i]);
}
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TC) == RESET) {}
found_devices++;
}
// 生成停止条件
i2c_stop_on_bus(I2C0);
timeout = 0;
while (i2c_flag_get(I2C0, I2C_FLAG_STPDET) && (timeout < I2C_TIME_OUT))
timeout++;
}
if (found_devices == 0) {
// printf("No I2C devices found.\r\n");
const char* msg3 = "No I2C devices found.\r\n";
for (uint8_t i = 0; msg3[i] != '\0'; i++) {
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, msg3[i]);
}
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TC) == RESET) {}
} else {
// printf("Total %d I2C devices found.\r\n", found_devices);
const char* msg4_prefix = "Total ";
for (uint8_t i = 0; msg4_prefix[i] != '\0'; i++) {
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, msg4_prefix[i]);
}
// 发送设备数量
if (found_devices >= 10) {
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, '0' + (found_devices / 10));
}
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, '0' + (found_devices % 10));
const char* msg4_suffix = " I2C devices found.\r\n";
for (uint8_t i = 0; msg4_suffix[i] != '\0'; i++) {
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(I2C_DEBUG_UART, msg4_suffix[i]);
}
while (usart_flag_get(I2C_DEBUG_UART, USART_FLAG_TC) == RESET) {}
}
}
i2c_result_t i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[2]) {
i2c_state_t state = I2C_STATE_START;
uint16_t timeout = 0;
uint8_t retry_count = 0;
/* parameter validation */
if (data == NULL || slave_addr > 0x7F) {
return I2C_RESULT_INVALID_PARAM;
}
while (retry_count < I2C_MAX_RETRY) {
switch (state) {
case I2C_STATE_START:
timeout = 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_VERBOES
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 register MSB value */
i2c_data_transmit(I2C0, data[0]);
timeout = 0;
/* wait until the transmit data buffer is empty */
while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
if (i2c_flag_get(I2C0, I2C_FLAG_AERR)) {
i2c_stop_on_bus(I2C0);
return I2C_RESULT_NACK;
} else if (i2c_flag_get(I2C0, I2C_FLAG_BERR) || i2c_flag_get(I2C0, I2C_FLAG_LOSTARB)) {
// 可按需清标志
i2c_stop_on_bus(I2C0);
return I2C_RESULT_ERROR;
}
/* send register LSB value */
i2c_data_transmit(I2C0, data[1]);
timeout = 0;
/* wait until BTC bit is set */
while (!i2c_flag_get(I2C0, I2C_FLAG_BTC) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
state = I2C_STATE_STOP;
break;
case I2C_STATE_STOP:
/* send 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;
}
/* i2c master sends STOP signal successfully */
/* 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++;
}
if (timeout >= I2C_TIME_OUT) {
return I2C_RESULT_ERROR;
}
i2c_flag_clear(I2C0, I2C_FLAG_AERR);
i2c_flag_clear(I2C0, I2C_FLAG_BERR);
i2c_flag_clear(I2C0, I2C_FLAG_LOSTARB);
retry_count ++;
if (retry_count >= I2C_MAX_RETRY)
{
#ifdef DEBUG_VERBOES
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;
}
i2c_result_t i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data) {
i2c_state_t state = I2C_STATE_START;
uint16_t timeout = 0;
uint8_t retry_count = 0;
bool write_phase = true;
// 参数检查：防止空指针和非法地址
if (data == NULL || slave_addr > 0x7F) {
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;
// 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 for 2 bytes: set POS=NEXT and disable ACK BEFORE clearing ADDR */
i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
i2c_ack_config(I2C0, I2C_ACK_DISABLE);
/* now clear address flag to release SCL and enter data phase */
i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
state = I2C_STATE_RECEIVE_DATA;
}
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 BTC: Bit 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 (R/W bit is set by library) */
i2c_master_addressing(I2C0, (slave_addr << 1), I2C_RECEIVER);
/* switch to read phase */
write_phase = false;
state = I2C_STATE_CLEAR_ADDRESS;
timeout = 0;
break;
case I2C_STATE_RECEIVE_DATA:
/* Wait for BTC (both bytes received) */
while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* Send STOP before reading the last two bytes */
i2c_stop_on_bus(I2C0);
/* Read the two bytes back-to-back */
data[0] = i2c_data_receive(I2C0);
data[1] = i2c_data_receive(I2C0);
state = I2C_STATE_STOP;
break;
case I2C_STATE_STOP:
/* wait for stop condition to complete */
while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
timeout++;
}
if (timeout >= I2C_TIME_OUT) {
state = I2C_STATE_ERROR;
break;
}
/* i2c master sends STOP signal successfully */
/* success */
return I2C_RESULT_SUCCESS;
case I2C_STATE_ERROR:
/* send stop condition to release bus */
i2c_stop_on_bus(I2C0);
retry_count++;
if (retry_count >= I2C_MAX_RETRY) {
#ifdef DEBUG_VERBOES
printf("IIC read failed after %d retries\n", I2C_RETRY_MAX);
#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;
}
#ifdef DEBUG_VERBOSE
/*!
\brief get status string for debugging
\param[in] status: i2c_status_t value
\param[out] none
\retval const char* status string
*/
const char* i2c_get_status_string(i2c_result_t status) {
switch (status) {
case I2C_RESULT_SUCCESS:
return "SUCCESS";
case I2C_RESULT_TIMEOUT:
return "TIMEOUT";
case I2C_RESULT_NACK:
return "NACK";
case I2C_RESULT_BUS_BUSY:
return "BUS_BUSY";
case I2C_RESULT_ERROR:
return "ERROR";
case I2C_RESULT_INVALID_PARAM:
return "INVALID_PARAM";
default:
return "UNKNOWN";
}
}
#endif

236
Src/ldc1612.c Normal file
View File

@@ -0,0 +1,236 @@
//
// Created by dell on 24-12-3.
//
#include "ldc1612.h"
/*!
\brief 写入寄存器
\param[in] reg_addr: 寄存器地址
\param[in] value: 写入值
\param[out] none
\retval i2c_result_t
*/
static i2c_result_t ldc1612_write_register(uint8_t reg_addr, uint16_t value) {
uint8_t data[2];
data[0] = (value >> 8) & 0xFF;
data[1] = value & 0xFF;
return LDC1612_IIC_WRITE_16BITS(LDC1612_ADDR, reg_addr, data);
}
/*!
\brief 读取寄存器
\param[in] reg_addr: 寄存器地址
\param[out] value: 读取值指针
\retval i2c_status_t
*/
static i2c_result_t ldc1612_read_register(uint8_t reg_addr, uint16_t *value) {
uint8_t data[2];
i2c_result_t status;
if (value == NULL) {
return I2C_RESULT_INVALID_PARAM;
}
status = LDC1612_IIC_READ_16BITS(LDC1612_ADDR, reg_addr, data);
if (status == I2C_RESULT_SUCCESS) {
*value = ((uint16_t)data[0] << 8) | data[1];
}
return status;
}
/*!
\brief 计算并获取频率分频值
\param[in] channel: 通道号
\param[out] none
\retval 计算得到的频率分频值
*/
static uint16_t ldc1612_calculate_freq_divider(uint8_t channel) {
uint16_t value;
uint16_t fin_div, freq_div;
float sensor_freq;
sensor_freq = 1 / (2 * 3.14 * sqrt(COIL_L_UH * COIL_C_PF * pow(10, -18))) * pow(10, -6);
fin_div = (uint16_t) (sensor_freq / 8.75 + 1);
if (fin_div * 4 < 40) {
freq_div = 2;
} else {
freq_div = 4;
}
value = fin_div << 12;
value |= freq_div;
return value;
}
uint16_t ldc1612_get_manufacturer_id(void) {
uint8_t data[2] = {0};
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, READ_MANUFACTURER_ID, data);
return (data[0] << 8) | data[1];
}
uint16_t ldc1612_get_deveice_id(void) {
uint8_t data[2] = {0};
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, READ_DEVICE_ID, data);
return (data[0] << 8) | data[1];
}
/** @brief reset sensor.
* */
ldc1612_status_t ldc1612_reset_sensor(void) {
i2c_result_t state = ldc1612_write_register(SENSOR_RESET_REG, LDC1612_RESET_DEV);
return (state == I2C_RESULT_SUCCESS) ? LDC1612_STATUS_SUCCESS : LDC1612_STATUS_ERROR;
}
ldc1612_status_t ldc1612_init(void) {
i2c_result_t i2c_status;
uint16_t manufacturer_id, device_id;
/* reset LDC1612 sensor */
i2c_status = ldc1612_reset_sensor();
if (i2c_status != I2C_RESULT_SUCCESS) {
return LDC1612_STATUS_ERROR;
}
delay_ms(100);
manufacturer_id = ldc1612_get_manufacturer_id();
device_id = ldc1612_get_deveice_id();
if (manufacturer_id != 0x5449 || device_id != 0x3055) {
return LDC1612_STATUS_ERROR;
}
return LDC1612_STATUS_SUCCESS;
}
/*!
\brief 配置单通道模式
\param[in] channel: 通道号 (0或1)
\param[out] none
\retval ldc1612_status_t
*/
ldc1612_status_t ldc1612_config_single_channel(uint8_t channel) {
i2c_result_t status;
if (channel > 1) {
return LDC1612_STATUS_INVALID_PARAM;
}
/* 配置顺序严格按照TI官方文档要求 */
/* Step 1: 确保传感器处于睡眠模式 - 配置前必须 */
status = ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SLEEP_MODE);
if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
delay_ms(10);
/* Step 2: 配置频率分频 - 必须在其他配置之前 */
uint16_t freq_divider = ldc1612_calculate_freq_divider(channel);
ldc1612_write_register(SET_FREQ_REG_START + channel, freq_divider);
delay_ms(5);
/* Step 3: 配置LC稳定时间 - 影响测量精度 */
ldc1612_write_register(SET_LC_STABILIZE_REG_START + channel, LC_STABILIZE_TIME_CH0);
/* Step 4: 配置转换时间 - 影响测量速度和精度 */
ldc1612_write_register(SET_CONVERSION_TIME_REG_START + channel, LDC1612_CONVERSION_TIME_CH0);
/* Step 5: 配置转换偏移 */
ldc1612_write_register(SET_CONVERSION_OFFSET_REG_START + channel, SET_CONVERSION_OFFSET_CH0);
/* Step 6: 配置驱动电流 - 影响传感器灵敏度 */
ldc1612_write_register(SET_DRIVER_CURRENT_REG + channel, LDC1612_DRIVE_CURRENT);
/* Step 7: 配置多路复用器 - 设置通道选择和滤波 */
// ldc1612_configure_mux_register(LDC1612_MUX_AUTOSCAN_DISABLE, LDC1612_MUX_RR_SEQUENCE_0, LDC1612_MUX_FILTER_ALL_LOW, LDC1612_MUX_FILTER_NONE);
ldc1612_write_register(MUL_CONFIG_REG, LDC1612_MUX_CONFIG);
/* Step 8: 配置错误输出 */
ldc1612_write_register(ERROR_CONFIG_REG, LDC1612_ERROR_CONFIG);
/* Step 9: 最后启动传感器 - 必须最后一步 */
status = ldc1612_write_register(SENSOR_CONFIG_REG, LDC1612_SENSOR_CONFIG_CH0);
if (status != I2C_RESULT_SUCCESS) return LDC1612_STATUS_ERROR;
/* Step 10: 等待传感器稳定 */
delay_ms(50);
return LDC1612_STATUS_SUCCESS;
}
/** @brief read the raw channel result from register.
@param channel LDC1612 has total two channels.
@param result raw data
* */
uint32_t ldc1612_get_raw_channel_result(uint8_t channel) {
uint32_t raw_value = 0;
uint8_t value[2] = {0};
/* Read MSW */
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERTION_RESULT_REG_START + channel, value);
raw_value |= (uint32_t)(((uint16_t)value[0] << 8) | value[1]) << 16;
/* Read LSW */
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, CONVERTION_RESULT_REG_START + channel + 1, value);
raw_value |= (uint32_t)(((uint16_t)value[0] << 8) | value[1]);
uint32_t calibration_value = raw_value & 0x0FFFFFFF;
if (calibration_value == 0x0FFFFFFF) {
return 0xF0000000; /* No coil */
}
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 */
if (error_code & 0x20) return 0x20000000; /* Watchdog */
if (error_code & 0x10) return 0x10000000; /* Amplitude error */
return raw_value;
}
// void ldc1612_drvie_current_detect(uint8_t channel) {
// uint8_t data[2] = {0};
// uint16_t init_value = 0 , drive_current = 0;
// ldc1612_set_sensor_config(LDC1612_SLEEP_MODE);
// ldc1612_configure_frequency(channel);
// LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SENSOR_CONFIG_REG, data);
// ldc1612_set_sensor_config(LDC1612_SLEEP_MODE);
// ldc1612_set_sensor_config(LDC1612_SENSOR_CONFIG_CH0); //0x1A --0x1601
// delay_ms(10);
// LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SET_DRIVER_CURRENT_REG, data);
// init_value = (((data[0] << 8) | data[1]) >> 6) & 0x1F;
// drive_current = (init_value << 11) | 0x0000;
// printf("init value: 0x%x\tdrive current: 0x%x\n", init_value, drive_current);
// }
/** @brief Get sensor status register
@return Status register value
* */
uint16_t ldc1612_get_sensor_status(void) {
uint8_t data[2] = {0};
LDC1612_IIC_READ_16BITS(LDC1612_ADDR, SENSOR_STATUS_REG, data);
return (data[0] << 8) | data[1];
}
/** @brief Check if data is ready for specific channel
@param channel Channel to check (0 or 1)
@return true if data is ready, false otherwise
* */
bool ldc1612_is_data_ready(uint8_t channel) {
uint16_t status = ldc1612_get_sensor_status();
if (channel == 0) {
return (status & 0x0040) != 0; // DRDY_0 bit
} else if (channel == 1) {
return (status & 0x0080) != 0; // DRDY_1 bit
}
return false;
}

47
Src/led.c
View File

@@ -1,20 +1,57 @@
#include "led.h"
/**
* @brief LED心跳指示灯功能
* @details 实现类似心跳的LED闪烁模式：快闪两次然后暂停
* 适合在SysTick中断中调用，通过计数器控制闪烁节拍
* @note 假设SysTick中断频率为1ms，心跳周期约为2秒
* 心跳模式：亮200ms->灭200ms->亮200ms->灭1400ms（循环）
*/
void led_heart_beat(void)
{
static uint16_t heart_beat_counter = 0;
// 心跳周期：2000ms (假设SysTick为1ms中断)
// 模式：亮200ms -> 灭200ms -> 亮200ms -> 灭1400ms
heart_beat_counter++;
if (heart_beat_counter <= 200) {
// 第一次亮：0-200ms
led_on();
}
else if (heart_beat_counter <= 400) {
// 第一次灭：200-400ms
led_off();
}
else if (heart_beat_counter <= 600) {
// 第二次亮：400-600ms
led_on();
}
else if (heart_beat_counter <= 2000) {
// 长时间灭：600-2000ms
led_off();
}
else {
// 重置计数器，开始新的心跳周期
heart_beat_counter = 0;
}
}
void led_init(void) {
rcu_periph_clock_enable(LED_RCU);
gpio_mode_set(LED_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LED_PIN);
gpio_output_options_set(LED_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, LED_PIN);
gpio_bit_reset(LED_PORT, LED_PIN);
}
void led_on(void) {
gpio_bit_set(LED_PORT, LED_PIN);
}
void led_off(void) {
void led_on(void) {
gpio_bit_reset(LED_PORT, LED_PIN);
}
void led_off(void) {
gpio_bit_set(LED_PORT, LED_PIN);
}
void led_toggle(void) {
gpio_bit_toggle(LED_PORT, LED_PIN);
}

46
Src/main.c
View File

@@ -36,7 +36,11 @@ OF SUCH DAMAGE.
#include "systick.h"
#include "uart.h"
#include "led.h"
#include "command.h"
#include <stdio.h>
#include "i2c.h"
#include "board_config.h"
#include "ldc1612.h"
/*!
\brief main function
@@ -46,17 +50,43 @@ OF SUCH DAMAGE.
*/
int main(void)
{
systick_config();
uart0_init(115200);
// uart1_init(115200); // 如需使用USART1请初始化
// printf("Hello USART0!\r\n");
// uart_set_printf_port(UART_PRINTF_USART1); // 切换printf到USART1
// uart_set_printf_port(UART_PRINTF_BOTH); // 同时输出到USART0和USART1
setbuf(stdout, NULL);
systick_config();
rs485_init();
led_init();
#ifdef DEBUG_VERBOSE
char hello_world[] = {"Hello World!\r\n"};
for (uint8_t i = 0; i < sizeof(hello_world); i++)
{
while (usart_flag_get(RS485_PHY, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(RS485_PHY, hello_world[i]);
}
while (usart_flag_get(RS485_PHY, USART_FLAG_TC) == RESET) {}
#endif
i2c_config();
#ifdef DEBUG_VERBOSE
i2c_scan();
i2c_bus_reset();
#endif
ldc1612_init();
ldc1612_config_single_channel(CHANNEL_0);
while(1){
led_toggle();
delay_ms(200);
command_process();
delay_ms(10);
if (g_sensor_report_enabled) {
eddy_current_report();
}
}
}

224
Src/sensor_example.c Normal file
View File

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

234
Src/soft_i2c.c Normal file
View File

@@ -0,0 +1,234 @@
//
// Created by dell on 24-12-28.
//
#include "soft_i2c.h"
/*!
\brief delay
\param[in] none
\param[out] none
\retval none
*/
void soft_i2c_delay(void) {
delay_10us(2); // Adjust delay as needed
/* delay to freq
* 15KHz: delay_us(20);
* 65KHz: delay_us(1);
*/
}
/*!
\brief configure the software IIC GPIO
\param[in] none
\param[out] none
\retval none
*/
void soft_i2c_config(void) {
rcu_periph_clock_enable(RCU_GPIO_I2C);
gpio_mode_set(I2C_SCL_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, I2C_SCL_PIN);
gpio_output_options_set(I2C_SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
gpio_mode_set(I2C_SDA_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, I2C_SDA_PIN);
gpio_output_options_set(I2C_SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);
I2C_SCL_HIGH();
I2C_SDA_HIGH();
}
/*!
\brief generate I2C start signal
\param[in] none
\param[out] none
\retval none
*/
void soft_i2c_start(void) {
I2C_SDA_HIGH();
I2C_SCL_HIGH();
soft_i2c_delay();
I2C_SDA_LOW();
soft_i2c_delay();
I2C_SCL_LOW();
}
/*!
\brief generate I2C stop signal
\param[in] none
\param[out] none
\retval none
*/
void soft_i2c_stop(void) {
I2C_SCL_LOW(); // 确保时钟为低
I2C_SDA_LOW(); // 拉低数据线
soft_i2c_delay();
I2C_SCL_HIGH(); // 拉高时钟
soft_i2c_delay();
I2C_SDA_HIGH(); // 在时钟高电平时拉高数据线产生停止条件
soft_i2c_delay(); // 添加缺失的延时
}
/*!
\brief send I2C ACK signal
\param[in] none
\param[out] none
\retval none
*/
void soft_i2c_send_ack(void) {
// sda_out();
I2C_SDA_LOW();
soft_i2c_delay();
I2C_SCL_HIGH();
soft_i2c_delay();
I2C_SCL_LOW();
soft_i2c_delay();
I2C_SDA_HIGH();
}
/*!
\brief send I2C NACK signal
\param[in] none
\param[out] none
\retval none
*/
void soft_i2c_send_nack(void) {
I2C_SDA_HIGH();
soft_i2c_delay();
I2C_SCL_HIGH();
soft_i2c_delay();
I2C_SCL_LOW();
soft_i2c_delay();
I2C_SDA_HIGH();
}
/*!
\brief wait I2C ACK signal
\param[in] none
\param[out] none
\retval 0: ACK received, 1: ACK not received
*/
uint8_t soft_i2c_wait_ack(void) {
I2C_SDA_HIGH(); // 释放SDA线，让从设备控制
soft_i2c_delay();
I2C_SCL_HIGH(); // 拉高时钟
soft_i2c_delay();
uint8_t ack = !I2C_SDA_READ(); // 读取ACK信号（低电平为ACK）
I2C_SCL_LOW(); // 拉低时钟
soft_i2c_delay(); // 添加缺失的延时
return ack;
}
/*!
\brief send a byte via I2C
\param[in] byte: byte to be sent
\param[out] none
\retval none
*/
void soft_i2c_send_byte(uint8_t byte) {
// sda_out();
for (int i = 0; i < 8; i++) {
if (byte & 0x80) {
I2C_SDA_HIGH();
} else {
I2C_SDA_LOW();
}
byte <<= 1;
soft_i2c_delay();
I2C_SCL_HIGH();
soft_i2c_delay();
I2C_SCL_LOW();
soft_i2c_delay();
}
}
/*!
\brief receive a byte via I2C
\param[in] ack: 1: send ACK, 0: send NACK
\param[out] none
\retval received byte
*/
uint8_t soft_i2c_receive_byte(uint8_t ack) {
uint8_t byte = 0;
I2C_SDA_HIGH();
for (int i = 0; i < 8; i++) {
byte <<= 1;
I2C_SCL_HIGH();
soft_i2c_delay();
if (I2C_SDA_READ()) {
byte |= 0x01;
}
I2C_SCL_LOW();
soft_i2c_delay();
}
if (ack) {
soft_i2c_send_ack();
} else {
soft_i2c_send_nack();
}
return byte;
}
uint8_t soft_i2c_write_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t data[2]) {
/* 参数验证 */
if (data == NULL || slave_addr > 0x7F) {
return SOFT_I2C_FAIL;
}
soft_i2c_start();
soft_i2c_send_byte(slave_addr << 1); // 修复：左移1位，添加写位
if (!soft_i2c_wait_ack()) {
soft_i2c_stop();
return SOFT_I2C_FAIL;
}
soft_i2c_send_byte(reg_addr);
if (!soft_i2c_wait_ack()) {
soft_i2c_stop();
return SOFT_I2C_FAIL;
}
soft_i2c_send_byte(data[0]);
if (!soft_i2c_wait_ack()) {
soft_i2c_stop();
return SOFT_I2C_FAIL;
}
soft_i2c_send_byte(data[1]);
if (!soft_i2c_wait_ack()) { // 修复：添加错误处理
soft_i2c_stop();
return SOFT_I2C_FAIL;
}
soft_i2c_stop();
return SOFT_I2C_OK;
}
uint8_t soft_i2c_read_16bits(uint8_t slave_addr, uint8_t reg_addr, uint8_t *data)
{
/* 参数验证 */
if (data == NULL || slave_addr > 0x7F) {
return SOFT_I2C_FAIL;
}
/* 写阶段：发送寄存器地址 */
soft_i2c_start();
soft_i2c_send_byte(slave_addr << 1); // 修复：左移1位，写操作
if (!soft_i2c_wait_ack()) {
soft_i2c_stop();
return SOFT_I2C_FAIL;
}
soft_i2c_send_byte(reg_addr);
if (!soft_i2c_wait_ack()) {
soft_i2c_stop();
return SOFT_I2C_FAIL;
}
/* 读阶段：重新开始并读取数据 */
soft_i2c_start(); // 重新开始
soft_i2c_send_byte((slave_addr << 1) | 0x01); // 修复：正确的读地址
if (!soft_i2c_wait_ack()) {
soft_i2c_stop();
return SOFT_I2C_FAIL;
}
soft_i2c_delay();
data[0] = soft_i2c_receive_byte(1); // 第一个字节发送ACK
data[1] = soft_i2c_receive_byte(0); // 最后一个字节发送NACK
soft_i2c_stop();
return SOFT_I2C_OK;
}

167
Src/systick.c
View File

@@ -1,83 +1,118 @@
/*!
\file systick.c
\brief the systick configuration file
\version 2025-02-10, V2.4.0, demo for GD32E23x
*/
/*
Copyright (c) 2025, GigaDevice Semiconductor Inc.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/
/**
* ************************************************************************
*
* @file systick.c
* @author GD32
* @brief 通过 SysTick 定时器进行微秒级别和毫秒级别的延时函数
*
* ************************************************************************
* @copyright Copyright (c) 2024 GD32
* ************************************************************************
*/
#include "gd32e23x.h"
#include "systick.h"
volatile static uint32_t delay;
volatile static uint32_t delay_count = 0;
/*!
\brief configure systick
\param[in] none
\param[out] none
\retval none
*/
/**
* ************************************************************************
* @brief 配置 SysTick 定时器
*
*
* ************************************************************************
*/
void systick_config(void)
{
/* setup systick timer for 1000Hz interrupts */
if (SysTick_Config(SystemCoreClock / 1000U)){
/* capture error */
while (1){
}
}
/* configure the systick handler priority */
//设置了 SysTick 定时器的时钟源为 HCLK
systick_clksource_set(SYSTICK_CLKSOURCE_HCLK);
// 配置SysTick为1ms周期中断
// 注意：SysTick_Config会自动设置时钟源为HCLK，所以需要使用SystemCoreClock/1000
SysTick_Config(SystemCoreClock / 1000U); // 1ms中断
NVIC_SetPriority(SysTick_IRQn, 0x00U);
}
/*!
\brief delay a time in milliseconds
\param[in] count: count in milliseconds
\param[out] none
\retval none
*/
/**
* ************************************************************************
* @brief delay_ms 毫秒延时函数
*
* @param[in] count 毫秒值
*
* ************************************************************************
*/
void delay_10us(uint32_t count)
{
// 基于系统时钟的简单循环延时
// 这是一个粗略的估计，实际延时可能有偏差 实测10.2us
uint32_t loops_per_10us = SystemCoreClock / 1700000; // 粗略估计，每10微秒的循环次数
for(uint32_t i = 0; i < count; i++) {
for(volatile uint32_t j = 0; j < loops_per_10us; j++);
}
}
/**
* ************************************************************************
* @brief delay_ms 毫秒延时函数
*
* @param[in] count 毫秒值
*
* ************************************************************************
*/
void delay_ms(uint32_t count)
{
delay = count;
while(0U != delay){
}
delay_count = count; // 设置延时计数
while (delay_count != 0U);
}
/*!
\brief delay decrement
\param[in] none
\param[out] none
\retval none
*/
/**
* ************************************************************************
* @brief 每个 SysTick 中断调用时，减少延时计数
*
* @param[in] void
*
* ************************************************************************
*/
void delay_decrement(void)
{
if (0U != delay){
delay--;
if (delay_count != 0U)
{
delay_count--;
}
}
// /**
// * ************************************************************************
// * @brief delay_ms_safe 毫秒延时函数（不干扰SysTick中断）
// * @details 使用简单循环实现延时，不会重新配置SysTick
// * @param[in] count 毫秒值
// * ************************************************************************
// */
// void delay_ms_safe(uint32_t count)
// {
// // 基于系统时钟的简单循环延时
// // 这是一个粗略的估计，实际延时可能有偏差
// uint32_t loops_per_ms = SystemCoreClock / 14000; // 粗略估计
// for(uint32_t i = 0; i < count; i++) {
// for(volatile uint32_t j = 0; j < loops_per_ms; j++);
// }
// }
// /**
// * ************************************************************************
// * @brief delay_us_safe 微秒延时函数（不干扰SysTick中断）
// * @details 使用简单循环实现延时，不会重新配置SysTick
// * @param[in] count 微秒值
// * ************************************************************************
// */
// void delay_us_safe(uint32_t count)
// {
// // 基于系统时钟的简单循环延时
// // 这是一个粗略的估计，实际延时可能有偏差
// uint32_t loops_per_us = SystemCoreClock / 22000000; // 粗略估计，每微秒的循环次数
// for(uint32_t i = 0; i < count; i++) {
// for(volatile uint32_t j = 0; j < loops_per_us; j++);
// }
// }

323
Src/tmp112.c Normal file
View File

@@ -0,0 +1,323 @@
//
// Created by dell on 24-12-20.
// TMP112A Temperature Sensor Driver Implementation
//
#include "tmp112.h"
/* Private function prototypes */
static i2c_status_t tmp112a_write_register(uint8_t reg_addr, uint16_t value);
static i2c_status_t tmp112a_read_register(uint8_t reg_addr, uint16_t *value);
static float tmp112a_raw_to_celsius(uint16_t raw_data);
static uint16_t tmp112a_celsius_to_raw(float temperature);
/*!
\brief 初始化TMP112A传感器
\param[in] none
\param[out] none
\retval tmp112a_status_t
*/
tmp112a_status_t tmp112a_init(void) {
i2c_status_t i2c_status;
/* 配置传感器为默认设置 */
i2c_status = tmp112a_config(TMP112A_CONFIG_DEFAULT);
if (i2c_status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
/* 等待配置生效 */
delay_ms(1);
return TMP112A_STATUS_SUCCESS;
}
/*!
\brief 配置TMP112A传感器
\param[in] config: 配置值
\param[out] none
\retval tmp112a_status_t
*/
tmp112a_status_t tmp112a_config(uint16_t config) {
i2c_status_t status = tmp112a_write_register(TMP112A_CONFIG_REG, config);
return (status == I2C_STATUS_SUCCESS) ? TMP112A_STATUS_SUCCESS : TMP112A_STATUS_ERROR;
}
/*!
\brief 读取温度
\param[in] none
\param[out] result: 结果结构体指针
\retval tmp112a_status_t
*/
tmp112a_status_t tmp112a_read_temperature(tmp112a_result_t *result) {
uint16_t raw_data;
i2c_status_t status;
if (result == NULL) {
return TMP112A_STATUS_INVALID_PARAM;
}
/* 读取温度寄存器 */
status = tmp112a_read_register(TMP112A_TEMP_REG, &raw_data);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
/* 解析温度数据 */
result->raw_data = raw_data;
result->temperature_c = tmp112a_raw_to_celsius(raw_data);
result->temperature_f = result->temperature_c * 9.0f / 5.0f + 32.0f;
/* 检查温度范围 */
if (result->temperature_c < TMP112A_TEMP_MIN || result->temperature_c > TMP112A_TEMP_MAX) {
return TMP112A_STATUS_OUT_OF_RANGE;
}
/* 检查报警标志 */
uint16_t config_reg;
status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
if (status == I2C_STATUS_SUCCESS) {
result->alert_flag = (config_reg & TMP112A_CONFIG_AL) ? true : false;
} else {
result->alert_flag = false;
}
return TMP112A_STATUS_SUCCESS;
}
/*!
\brief 设置温度阈值
\param[in] low_temp: 低温阈值 (°C)
\param[in] high_temp: 高温阈值 (°C)
\param[out] none
\retval tmp112a_status_t
*/
tmp112a_status_t tmp112a_set_thresholds(float low_temp, float high_temp) {
uint16_t low_raw, high_raw;
i2c_status_t status;
/* 参数验证 */
if (low_temp < TMP112A_TEMP_MIN || low_temp > TMP112A_TEMP_MAX ||
high_temp < TMP112A_TEMP_MIN || high_temp > TMP112A_TEMP_MAX ||
low_temp >= high_temp) {
return TMP112A_STATUS_INVALID_PARAM;
}
/* 转换温度为原始值 */
low_raw = tmp112a_celsius_to_raw(low_temp);
high_raw = tmp112a_celsius_to_raw(high_temp);
/* 写入低温阈值 */
status = tmp112a_write_register(TMP112A_TLOW_REG, low_raw);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
/* 写入高温阈值 */
status = tmp112a_write_register(TMP112A_THIGH_REG, high_raw);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
return TMP112A_STATUS_SUCCESS;
}
/*!
\brief 进入关机模式
\param[in] none
\param[out] none
\retval tmp112a_status_t
*/
tmp112a_status_t tmp112a_shutdown(void) {
uint16_t config_reg;
i2c_status_t status;
/* 读取当前配置 */
status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
/* 设置关机位 */
config_reg |= TMP112A_CONFIG_SD;
/* 写回配置 */
status = tmp112a_write_register(TMP112A_CONFIG_REG, config_reg);
return (status == I2C_STATUS_SUCCESS) ? TMP112A_STATUS_SUCCESS : TMP112A_STATUS_ERROR;
}
/*!
\brief 退出关机模式
\param[in] none
\param[out] none
\retval tmp112a_status_t
*/
tmp112a_status_t tmp112a_wakeup(void) {
uint16_t config_reg;
i2c_status_t status;
/* 读取当前配置 */
status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
/* 清除关机位 */
config_reg &= ~TMP112A_CONFIG_SD;
/* 写回配置 */
status = tmp112a_write_register(TMP112A_CONFIG_REG, config_reg);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
/* 等待传感器启动 */
delay_ms(1);
return TMP112A_STATUS_SUCCESS;
}
/*!
\brief 单次转换
\param[in] none
\param[out] result: 结果结构体指针
\retval tmp112a_status_t
*/
tmp112a_status_t tmp112a_one_shot(tmp112a_result_t *result) {
uint16_t config_reg;
i2c_status_t status;
uint8_t timeout = 100; // 100ms超时
if (result == NULL) {
return TMP112A_STATUS_INVALID_PARAM;
}
/* 读取当前配置 */
status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
/* 启动单次转换 */
config_reg |= TMP112A_CONFIG_OS;
status = tmp112a_write_register(TMP112A_CONFIG_REG, config_reg);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
/* 等待转换完成 */
do {
delay_ms(1);
status = tmp112a_read_register(TMP112A_CONFIG_REG, &config_reg);
if (status != I2C_STATUS_SUCCESS) {
return TMP112A_STATUS_ERROR;
}
timeout--;
} while ((config_reg & TMP112A_CONFIG_OS) && timeout > 0);
if (timeout == 0) {
return TMP112A_STATUS_TIMEOUT;
}
/* 读取转换结果 */
return tmp112a_read_temperature(result);
}
/*!
\brief 获取状态字符串
\param[in] status: 状态码
\param[out] none
\retval const char* 状态字符串
*/
const char* tmp112a_get_status_string(tmp112a_status_t status) {
switch (status) {
case TMP112A_STATUS_SUCCESS:
return "SUCCESS";
case TMP112A_STATUS_ERROR:
return "ERROR";
case TMP112A_STATUS_TIMEOUT:
return "TIMEOUT";
case TMP112A_STATUS_INVALID_PARAM:
return "INVALID_PARAM";
case TMP112A_STATUS_OUT_OF_RANGE:
return "OUT_OF_RANGE";
default:
return "UNKNOWN";
}
}
/* Private Functions Implementation */
/*!
\brief 写入寄存器
\param[in] reg_addr: 寄存器地址
\param[in] value: 写入值
\param[out] none
\retval i2c_status_t
*/
static i2c_status_t tmp112a_write_register(uint8_t reg_addr, uint16_t value) {
uint8_t data[2];
data[0] = (value >> 8) & 0xFF;
data[1] = value & 0xFF;
return i2c_write_16bits(TMP112A_ADDR, reg_addr, data);
}
/*!
\brief 读取寄存器
\param[in] reg_addr: 寄存器地址
\param[out] value: 读取值指针
\retval i2c_status_t
*/
static i2c_status_t tmp112a_read_register(uint8_t reg_addr, uint16_t *value) {
uint8_t data[2];
i2c_status_t status;
if (value == NULL) {
return I2C_STATUS_INVALID_PARAM;
}
status = i2c_read_16bits(TMP112A_ADDR, reg_addr, data);
if (status == I2C_STATUS_SUCCESS) {
*value = ((uint16_t)data[0] << 8) | data[1];
}
return status;
}
/*!
\brief 将原始数据转换为摄氏度
\param[in] raw_data: 原始数据
\param[out] none
\retval float 温度值(°C)
*/
static float tmp112a_raw_to_celsius(uint16_t raw_data) {
int16_t temp_raw;
/* TMP112A使用12位分辨率，数据在高12位 */
temp_raw = (int16_t)(raw_data >> 4);
/* 处理负数 */
if (temp_raw & 0x800) {
temp_raw |= 0xF000; // 符号扩展
}
/* 转换为摄氏度 */
return (float)temp_raw * TMP112A_TEMP_RESOLUTION;
}
/*!
\brief 将摄氏度转换为原始数据
\param[in] temperature: 温度值(°C)
\param[out] none
\retval uint16_t 原始数据
*/
static uint16_t tmp112a_celsius_to_raw(float temperature) {
int16_t temp_raw;
/* 转换为原始值 */
temp_raw = (int16_t)(temperature / TMP112A_TEMP_RESOLUTION);
/* 移位到高12位 */
return (uint16_t)(temp_raw << 4);
}

108
Src/uart.c
View File

@@ -2,65 +2,71 @@
#include "gd32e23x_usart.h"
#include "gd32e23x_rcu.h"
#include "gd32e23x_gpio.h"
#include "board_config.h"
void uart0_init(uint32_t baudrate) {
void rs485_init(void) {
#ifndef RS485_MAX13487
/* 使能 GPIOA 和 USART0 时钟 */
rcu_periph_clock_enable(RCU_GPIOA);
rcu_periph_clock_enable(RCU_USART0);
rcu_periph_clock_enable(RS485_GPIO_RCU);
rcu_periph_clock_enable(RS485_RCU);
/* 配置 PA9 为 USART0_TX，PA10 为 USART0_RX */
gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_9 | GPIO_PIN_10);
gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_9 | GPIO_PIN_10);
gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9 | GPIO_PIN_10);
/* 配置 PA2 为 USART0_TX，PA3 为 USART0_RX */
gpio_af_set(RS485_GPIO_PORT, GPIO_AF_1, RS485_TX_PIN | RS485_RX_PIN | RS485_EN_PIN);
gpio_mode_set(RS485_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, RS485_TX_PIN | RS485_RX_PIN);
gpio_output_options_set(RS485_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, RS485_TX_PIN | RS485_RX_PIN);
gpio_mode_set(RS485_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, RS485_EN_PIN);
gpio_output_options_set(RS485_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, RS485_EN_PIN);
/* 配置波特率、数据位、停止位等 */
usart_deinit(USART0);
usart_baudrate_set(USART0, baudrate);
usart_receive_config(USART0, USART_RECEIVE_ENABLE);
usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
usart_enable(USART0);
}
usart_deinit(RS485_PHY);
usart_word_length_set(RS485_PHY, USART_WL_8BIT);
usart_stop_bit_set(RS485_PHY, USART_STB_1BIT);
usart_parity_config(RS485_PHY, USART_PM_NONE);
usart_baudrate_set(RS485_PHY, RS485_BAUDRATE);
usart_receive_config(RS485_PHY, USART_RECEIVE_ENABLE);
usart_transmit_config(RS485_PHY, USART_TRANSMIT_ENABLE);
void uart1_init(uint32_t baudrate) {
rcu_periph_clock_enable(RCU_GPIOA);
rcu_periph_clock_enable(RCU_USART1);
// USART1 默认引脚为 PA2 (TX), PA3 (RX)
gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_2 | GPIO_PIN_3);
gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_2 | GPIO_PIN_3);
gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_2 | GPIO_PIN_3);
usart_deinit(USART1);
usart_baudrate_set(USART1, baudrate);
usart_receive_config(USART1, USART_RECEIVE_ENABLE);
usart_transmit_config(USART1, USART_TRANSMIT_ENABLE);
usart_enable(USART1);
}
usart_driver_assertime_config(RS485_PHY, 0x01);
usart_driver_deassertime_config(RS485_PHY, 0x10);
static uart_printf_port_t g_printf_port = UART_PRINTF_USART0;
usart_rs485_driver_enable(RS485_PHY);
void uart_set_printf_port(uart_printf_port_t port) {
g_printf_port = port;
}
usart_enable(RS485_PHY);
// printf 重定向，支持多串口
int __io_putchar(int ch) {
switch (g_printf_port) {
case UART_PRINTF_USART0:
while (usart_flag_get(USART0, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(USART0, (uint8_t)ch);
break;
case UART_PRINTF_USART1:
while (usart_flag_get(USART1, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(USART1, (uint8_t)ch);
break;
case UART_PRINTF_BOTH:
while (usart_flag_get(USART0, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(USART0, (uint8_t)ch);
while (usart_flag_get(USART1, USART_FLAG_TBE) == RESET) {}
usart_data_transmit(USART1, (uint8_t)ch);
break;
default:
break;
nvic_irq_enable(USART0_IRQn, 0);
usart_interrupt_enable(RS485_PHY, USART_INT_RBNE);
// usart_interrupt_enable(RS485_PHY, USART_INT_IDLE);
#else
rcu_periph_clock_enable(RS485_GPIO_RCU);
rcu_periph_clock_enable(RS485_RCU);
gpio_af_set(RS485_GPIO_PORT, GPIO_AF_1, GPIO_PIN_2 | GPIO_PIN_3);
/* configure USART Tx&Rx as alternate function push-pull */
gpio_mode_set(RS485_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, RS485_TX_PIN | RS485_RX_PIN);
gpio_output_options_set(RS485_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, RS485_TX_PIN | RS485_RX_PIN);
/* configure RS485 EN Pin */
gpio_mode_set(RS485_GPIO_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, RS485_EN_PIN);
gpio_output_options_set(RS485_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, RS485_EN_PIN);
gpio_bit_write(RS485_GPIO_PORT, RS485_EN_PIN, SET);
/* USART configure */
usart_deinit(RS485_PHY);
usart_baudrate_set(RS485_PHY, RS485_BAUDRATE);
usart_receive_config(RS485_PHY, USART_RECEIVE_ENABLE);
usart_transmit_config(RS485_PHY, USART_TRANSMIT_ENABLE);
usart_enable(RS485_PHY);
nvic_irq_enable(USART0_IRQn, 0);
usart_interrupt_enable(RS485_PHY, USART_INT_RBNE);
usart_interrupt_enable(RS485_PHY, USART_INT_IDLE);
#endif // RS485_MAX13487
}
return ch;
}

104
Src/uart_ring_buffer.c Normal file
View File

@@ -0,0 +1,104 @@
/**
* @file uart_ring_buffer.c
* @brief 字节环形接收缓冲区的实现。
* @details 适用于中断接收（写）与主循环解析（读）的典型串口场景；
* 采用“预留一格”区分空/满，最大可用容量为 UART_RX_BUFFER_SIZE-1。
* @ingroup RingBuffer
*/
#include "uart_ring_buffer.h"
static volatile uint8_t uart_rx_buffer[UART_RX_BUFFER_SIZE];
static volatile uint8_t write_index = 0;
static volatile uint8_t read_index = 0;
static volatile uint32_t dropped_bytes = 0;
/**
* @brief 重置环形缓冲区状态。
* @details 将读指针、写指针与丢弃计数清零，不清空数据区内容。
* @note 内部工具函数；对外请优先使用 uart_ring_buffer_init()/uart_ring_buffer_clear()。
* @ingroup RingBuffer
*/
static void uart_ring_buffer_reset_state(void) {
write_index = 0;
read_index = 0;
dropped_bytes = 0;
}
/**
* @brief 初始化环形缓冲区。
* @details 调用内部重置逻辑，复位读写索引与丢弃计数，准备接收数据。
* @note 若在中断环境使用，初始化前建议关闭相关接收中断以避免并发竞争。
* @ingroup RingBuffer
*/
void uart_ring_buffer_init(void) {
uart_ring_buffer_reset_state();
}
/**
* @brief 获取当前可读的字节数。
* @details 通过读/写指针的快照计算可读长度，范围为 [0, UART_RX_BUFFER_SIZE-1]。
* @return uint8_t 可读字节数。
* @note 预留一个空槽区分“空/满”，因此满时返回 UART_RX_BUFFER_SIZE-1。
* @ingroup RingBuffer
*/
uint8_t uart_ring_buffer_available(void) {
/* 使用快照减少并发不一致窗口 */
uint8_t w = write_index;
uint8_t r = read_index;
return (uint8_t)((w + UART_RX_BUFFER_SIZE - r) % UART_RX_BUFFER_SIZE);
}
/**
* @brief 从环形缓冲区读取一个字节。
* @details 若缓冲区非空，返回队头字节并推进读指针；若为空，返回 -1。
* @return int 读取到的字节（0..255），或 -1 表示缓冲区为空。
* @ingroup RingBuffer
*/
int uart_ring_buffer_get(void) {
if (read_index == write_index) return -1; // 空
uint8_t data = uart_rx_buffer[read_index];
read_index = (read_index + 1) % UART_RX_BUFFER_SIZE;
return data;
}
/**
* @brief 向环形缓冲区写入一个字节。
* @details 尝试写入一个新字节；若缓冲区已满则丢弃并计数。
* @param data 待写入的字节。
* @return bool 是否写入成功。
* @retval true 写入成功。
* @retval false 写入失败（缓冲区已满，数据被丢弃并计数）。
* @note 如需“覆盖写入”策略，可在满时先推进读指针再写入。
* @ingroup RingBuffer
*/
bool uart_ring_buffer_put(uint8_t data) {
uint8_t next = (write_index + 1) % UART_RX_BUFFER_SIZE;
if (next != read_index) { // 缓冲区未满
uart_rx_buffer[write_index] = data;
write_index = next;
return true;
} else {
/* 缓冲区已满，丢弃新字节并计数 */
dropped_bytes++;
return false;
}
}
/**
* @brief 清空环形缓冲区。
* @details 复位读写索引与丢弃计数，相当于逻辑上丢弃所有已接收数据，不擦除数据区内容。
* @ingroup RingBuffer
*/
void uart_ring_buffer_clear(void) {
uart_ring_buffer_reset_state();
}
/**
* @brief 获取因满而被丢弃的字节累计数量。
* @details 写入时缓冲区满会丢弃新字节并累加计数；该计数在 init/clear 时清零。
* @return uint32_t 丢弃的累计字节数。
* @ingroup RingBuffer
*/
uint32_t uart_ring_buffer_drop_count(void) {
return dropped_bytes;
}