当前位置： 首页 > article >正文

14、nRF52xx蓝牙学习（串口 UART 和 UARTE 外设应用）

article 2026/1/25 15:21:42
一、UART 功能描述
串口 UART 也称为通用异步收发器。是各种处理器中常用了通信接口，在 nRF52 芯片中， UART
具有以下特点：
● 全双工操作
● 自动流控
● 奇偶校验产生第 9 位数据
串口 UART 的数据发送与接收流程 :
◆硬件配置：
根据 PSELRXD、PSELCTS、PSELRTS 和 PSELTXD 寄存器的配置可以相应的将 RXD、CTS(发送清除、 低有效)、TXD、RTS（发送请求、低有效）映射到物理的引脚上。如果这些寄存器的任意一个设为 0xffffffff，相关的 UART 信号就不会连接到任务物理引脚上。这四个寄存器及其配置只能在 UART 使能时可用，可以在芯片为系统 ON 模式时保持。为了在系统处于 OFF 关闭模式时通过 UART 确保引 脚上的信号电平正确，必须按照 GPIO 外设中的说明在 GPIO 外设中配置引脚。如下表 7.1 所示：
◆UART 发送：
如图 7.1 所示，通过触发 STARTTX 任务启动 UART 传输序列。然后通过写入 TXD 寄存器来发
送字节。成功发送一个字节后，UART 将产生一个 TXDRDY 事件，之后可以将一个新字节写入 TXD 寄 存器。通过触发 STOPTX 任务立即停止 UART 传输序列。如果启用了流量控制，则在 CTS 取消激活时 将自动暂停传输，并在再次激活 CTS 时恢复。在 CTS 被停用时正在传输的字节将在传输暂停之前被 完全传输。
◆UART 接收：
通过触发 STARTRX 任务启动 UART 接收序列。UART 接收器连接了一个 FIFO，能够在数据被覆盖 之前存储六个传入的 RXD 字节。 通过读取 RXD 寄存器从该 FIFO 中提取字节。当从 FIFO 中提取一 个字节时，FIFO 中待处理的新字节将被移动到 RXD 寄存器。 每次将新字节移入 RXD 寄存器时，UART 都会产生 RXDRDY 事件。
当启用流量控制时，如果接收器 FIFO 中只有 4 个字节的空间时，UART 将禁用 RTS 信号。启用
流量控制状态下在重写数据之前，发送器能够在 RTS 信号激活之后发送多达四个字节。因此为防止 覆盖 FIFO 中的数据，对应的 UART 发送器必须确保在 RTS 线停用后在四个字节时间内停止发送数据。
当 FIFO 清空时，首先再次激活 RTS 信号；CPU 读取 FIFO 中的所有字节后，接收器通过 STOPRX 任务 停止时，RTS 信号也将被禁用；
为防止输入数据丢失，必须在每次 RXDRDY 事件后读取 RXD 寄存器一次。为了确保 CPU 可以通
过 RXDRDY 事件寄存器检测所有输入的 RXDRDY 事件，必须在读取 RXD 寄存器之前清零 RXDRDY 事件 寄存器。这样做的原因是允许 UART 将新字节写入 RXD 寄存器，在 CPU 读取（清空）RXD 寄存器后立 即生成新事件。
◆UART 挂起：
UART 串口可以通过触发 SUPSPEND 寄存器任务来挂起。SUPSPEND 将会影响 UART 发送器和 UART 接收器，设置后使发生器停止发送，接收器停止接收。在 UART 挂起后，通过相应的触发 STARTTX 和 STARTRX 就可以重新开启发送和接收。
当触发 SUPSPEND 任务时，UART 接收器和触发 STOPRX 任务一样的工作。
在触发 SUPSPEND 任务后，正在进行的 TXD 字节传输将在 UART 挂起前完成。
◆错误条件：
在一个错误帧出现的情况下，如果再此帧中没有检测到有效的停止位会产生一个 ERROR 事件。
另外，在中断时，如果 RXD 保持低电平超过一个数据帧长度时，也会产生一个 ERROR 事件。
◆流量控制：
nRF52 芯片的 UART 可以分为带流量控制和不带流量控制两种方式。不带流量控制时，不需要
连接 CTS 和 RTS 两个管脚，可以视为两个管脚一值有效。
带流量控制时， RTS 引脚作为输出，由 UART 硬件模块自动控制。与接收寄存器的多级硬件缓
冲 Buff 协调工作。比如在硬件缓冲已经接收满了 6 个字节的时， RTS 引脚就输出高电平的终止信号，
当缓冲中的数据都被读出后回复有效信号（低电平）。
CTS 作为输入由外部输入。当 CTS 有效时（低电平）模块可以发送，当为无效时，模块自动
暂停发送，并在 CTS 恢复有效时继续发送。
那么当 uart 模块的 rts 与 cts 交叉相接。 如果发送方发送太快，当接收方的接收硬件 buff 已经
存满了字节后，接收方自动无效 RTS 信号，表示不能接收了。因为接收方 RTS 与发送方 CTS 相接，
使得发送方的 CTS 也编程无效信号，于是发送方自动停止发送。这样就保证了接收方不会接收溢出。
流量控制也就是体现在这里。
二、UARTE 功能介绍
UARTE 就是带有 EasyDMA 的通用异步接收器 / 发送器 UART 。提供快速、全双工、异步的串
行通信，内置流量控制（ CTS ， RTS ）支持硬件，速率高达 1 Mbps 。这里列出的是 UARTE 的主要功能：
• 全双工操作
• 自动硬件流控制
• 生成 9 位数据带奇偶校验
• EasyDMA
• 波特率高达 1 Mbps
• 在支持的事务之间返回 IDLE （使用 HW 流控制时）
• 一个停止位
• 最低有效位（LSB ）优先
用于每个 UART 接口的 GPIO 可以从设备上的任何 GPIO 来选择并且独立地为可配置的。
这使得能够在器件的引脚和有效地利用电路板空间和信号路由很大的灵活性。 UARTE 的内部结构
图 如下所示：
对内部寄存器的说明如下表   所示：
UARTE 实现 EasyDMA 读取和写入，并存入 RAM。如果 TXD.PTR 和 RXD.PTR 没有指向
数据 RAM 区， EasyDMA 传递可能导致 HardFault 或 RAM 损坏。
.PTR 和 .MAXCNT 寄存器是双缓冲的。他们可以在收到 RXSTARTED / TXSTARTED 事件后 立即进行更新，并在接下来的 RX / TX 传送准备。所述 ENDRX / ENDTX 事件表示 EasyDMA 已
完成访问分别在 RAM 中的 RX / TX 缓冲器。
◆ UARTE 发送：
一个 UARTE 的发送的第一个步骤是存储的字节到发送缓冲器和配置 EasyDMA 。这个过程是
通过写起始地址到指针 TXD.PTR ，并在 RAM 缓冲器放置 TXD.MAXCNT 大小的字节数来实现的。
串口 UARTE 的发送是通过触发 STARTTX 任务开始，之后的每个字节在 TXD 线上发送时，会产
生一个 TXDRDY 事件。当在 TXD 缓冲器中的所有字节（在 TXD.MAXCNT 寄存器中指定数目）
已被传送时， UARTE 传输将自动结束，并且将产生一个 ENDTX 事件。
通过触发 STOPTX 任务来停止 UARTE 发送序列 ，当 UARTE 发射机已经停止，将产生一个
TXSTOPPED 事件。如果在 UARTE 发射机已经停下来但尚未产生 ENDTX 事件时， UARTE 将
明确产生一个 ENDTX 事件，即使在 TXD 缓冲区中的所有字节（ TXD.MAXCNT 寄存器中指定）
还没有被发送。
如果启用了流量控制，则在 CTS 取消激活时将自动暂停传输，并在再次激活 CTS 时恢复。在
CTS 被停用时正在传输的字节将在传输暂停之前被完全传输。
◆ UARTE 接收：
通过触发 STARTRX 任务启动 UARTE 接收器。 UARTE 接收器使用 EasyDMA 将输入数据存储
在 RAM 中的 RX 缓冲区中。 RX 缓冲区位于 RXD.PTR 寄存器中指定的地址。 RXD.PTR 寄存器是双 缓冲的，可以在生成 RXSTARTED 事件后立即更新并为下一个 STARTRX 任务做好准备。 RX 缓冲 区的大小在 RXD.MAXCNT 寄存器中指定， UARTE 在填充 RX 缓冲区时将生成 ENDRX 事件。
对于通过 RXD 线接收的每个字节，都将生成 RXDRDY 事件。在将相应的数据传输到数据 RAM
之前，可能会发生此事件。在 ENDRX 事件之后可以查询 RXD.AMOUNT 寄存器，以查看自上一次 ENDRX 事件以来有多少新字节已传输到 RAM 中的 RX 缓冲区。
通过触发 STOPRX 任务来停止 UARTE 接收器。 UARTE 停止时会生成 RXTO 事件。 UARTE
将确保在生成 RXTO 事件之前生成即将发生的 ENDRX 事件。 这意味着 UARTE 将保证在 RXTO
之后不会生成 ENDRX 事件，除非重新启动 UARTE 或在生成 RXTO 事件后发出 FLUSHRX 命令。
重要提示：如果在 UARTE 接收器停止时尚未生成 ENDRX 事件，这意味着 RX FIFO 中的所有
待处理内容都已移至 RX 缓冲区，则 UARTE 将显式生成 ENDRX 事件，即使 RX 缓冲区未满。 在 这种情况下，将在生成 RXTO 事件之前生成 ENDRX 事件。
为了能够知道实际接收到 RX 缓冲区的字节数， CPU 可以在 ENDRX 事件或 RXTO 事件之后读
取 RXD.AMOUNT 寄存器。只要在 RTS 信号被禁用后立即连续发送， UARTE 就可以在 STOPRX 任 务被触发后接收最多四个字节。这是可能的，因为在 RTS 取消激活后， UARTE 能够在一段延长的 时间内接收字节，该时间等于在配置的波特率上发送 4 个字节所需的时间。生成 RXTO 事件后，内 部 RX FIFO 可能仍包含数据，要将此数据移至 RAM ，必须触发 FLUSHRX 任务。
为确保此数据不会覆盖 RX 缓冲区中的数据，应在 FLUSHRX 任务被触发之前清空 RX 缓冲区
或更新 RXD.PTR 。为确保 RX FIFO 中的所有数据都移至 RX 缓冲区， RXD.MAXCNT 寄存器必须
设置为 RXD.MAXCNT> 4 ，通过 STOPRX 强制停止的 UARTE 接收。即使 RX FIFO 为空或 RX 缓 冲区未填满，UARTE 也会在完成 FLUSHRX 任务后生成 ENDRX 事件。 为了能够知道在这种情况 下实际接收到 RX 缓冲区的字节数， CPU 可以在 ENDRX 事件之后读取 RXD.AMOUNT 寄存器。
如果启用了 HW 流量控制，当接收器通过 STOPRX 任务停止或 UARTE 只能在其内部 RX FIFO
中接收 4 个字节时， RTS 信号将被禁用。禁用流量控制后， UARTE 将以与启用流量控制时相同的
方式运行，但不会使用 RTS 线路。这意味着当 UARTE 达到只能在其内部 RX FIFO 中接收四个字节 的点时，不会产生任何信号。内部 RX FIFO 填满时接收的数据将丢失。 UARTE 接收器将处于最低 活动水平，并在停止时消耗最少的能量，即在通过 STARTRX 启动之前或通过 STOPRX 停止并且已 生成 RXTO 事件之后。
实例1：串口 printf 输出
硬件连接方面，通过高质量芯片 CH340T 把串口信号转换成 usb 输出 , TXD-- 接端口 P0.09 端
RXD-- 接端口 P0.11 端 CTS-- 接端口 P0.08 端 RTS-- 接端口 P0.10 端，其中数据口 TXD 和 RXD 分别 接 1K 电阻上拉，提高驱动能力，如下图   所示
在代码文件中，实验建立了一个演示历程，我们还是采用分层思想，直接通过官方提供的组
件库进行编程。打开文件夹中的 uart 工程，添加 UART 的组件库工程如下图   所示：
红色框框内的文件是需要在建立串口工程时进行添加的库文件，对这几个添加的库
文件说明如下表   所示：
如上表   所示： nrf_drv_uart.c 文件和 app_uart_fifi.c 文件是官方编写好的驱动库文件。这两个
文件在后面编写带协议栈的 BLE 应用时，是可以直接用于其中配置串口功能的。因此理解这两个文 件提供的 API 函数是利用组件编写串口的必由之路。
在 app_uart.h 文 件 中 提 供 了 两 个 关 键 的 uart 的 初 始 化 函 数 APP_UART_FIFO_INIT 和
APP_UART_INIT ，一个是带 FIFO 缓冲的初始化串口函数，一个是不带 FIFO 缓冲的初始化函数， 一般情况下使用带软件缓冲的 FIF0 的函数，减小数据溢出错误的发生几率。
下面学习几个库函数：
（1） APP_UART_FIFO_INIT宏 
#define APP_UART_FIFO_INIT(P_COMM_PARAMS, RX_BUF_SIZE, TX_BUF_SIZE, EVT_HANDLER, IRQ_PRIO, ERR_CODE) \do                                                                                             \{                                                                                              \app_uart_buffers_t buffers;                                                                \static uint8_t     rx_buf[RX_BUF_SIZE];                                                    \static uint8_t     tx_buf[TX_BUF_SIZE];                                                    \\buffers.rx_buf      = rx_buf;                                                              \buffers.rx_buf_size = sizeof (rx_buf);                                                     \buffers.tx_buf      = tx_buf;                                                              \buffers.tx_buf_size = sizeof (tx_buf);                                                     \ERR_CODE = app_uart_init(P_COMM_PARAMS, &buffers, EVT_HANDLER, IRQ_PRIO);                  \} while (0)

代码理解：

代码概述 此代码定义了一个名为 APP_UART_FIFO_INIT 的宏，其用途是初始化一个基于 FIFO（先进先出）机制的 UART（通用异步收发传输器）通信。借助这个宏，你能够轻松地设置 UART 通信所需的参数，包含接收缓冲区、发送缓冲区、事件处理函数以及中断优先级等。

宏定义参数

• P_COMM_PARAMS：指向 UART 通信参数结构体的指针，该结构体里包含了波特率、数据位、停止位等 UART 通信所需的基本参数。

结构体定义如下 ：

typedef struct
{uint32_t                rx_pin_no;    /**< RX pin number. */uint32_t                tx_pin_no;    /**< TX pin number. */uint32_t                rts_pin_no;   /**< RTS pin number, only used if flow control is enabled. */uint32_t                cts_pin_no;   /**< CTS pin number, only used if flow control is enabled. */app_uart_flow_control_t flow_control; /**< Flow control setting, if flow control is used, the system will use low power UART mode, based on CTS signal. */bool                    use_parity;   /**< Even parity if TRUE, no parity if FALSE. */uint32_t                baud_rate;    /**< Baud rate configuration. */
} app_uart_comm_params_t;

结构体解析：用于配置 UART（通用异步收发传输器）通信参数。下面解释结构体中每个成员的作用：

// 定义一个名为 app_uart_comm_params_t 的结构体，用于配置 UART 通信参数
typedef struct
{// RX 引脚编号，用于接收数据uint32_t                rx_pin_no;    /**< RX pin number. */// TX 引脚编号，用于发送数据uint32_t                tx_pin_no;    /**< TX pin number. */// RTS（请求发送）引脚编号，仅在启用流控制时使用uint32_t                rts_pin_no;   /**< RTS pin number, only used if flow control is enabled. */// CTS（清除发送）引脚编号，仅在启用流控制时使用uint32_t                cts_pin_no;   /**< CTS pin number, only used if flow control is enabled. */// 流控制设置，如果使用流控制，系统将基于 CTS 信号使用低功耗 UART 模式app_uart_flow_control_t flow_control; /**< Flow control setting, if flow control is used, the system will use low power UART mode, based on CTS signal. */// 是否使用奇偶校验，TRUE 表示使用偶校验，FALSE 表示不使用奇偶校验bool                    use_parity;   /**< Even parity if TRUE, no parity if FALSE. */// 波特率配置，用于设置数据传输的速率uint32_t                baud_rate;    /**< Baud rate configuration. */
} app_uart_comm_params_t;

其中：app_uart_flow_control_t（控制流）是一个枚举类型，其定义如下：

typedef enum
{
    APP_UART_FLOW_CONTROL_DISABLED, /**< UART Hw Flow Control is disabled. */
    APP_UART_FLOW_CONTROL_ENABLED,  /**< Standard UART Hw Flow Control is enabled. */
} app_uart_flow_control_t;

// 定义 app_uart_flow_control_t 枚举类型，用于表示 UART 硬件流控制状态
typedef enum
{
    // UART 硬件流控制禁用
    APP_UART_FLOW_CONTROL_DISABLED, /**< UART Hw Flow Control is disabled. */
    // 标准 UART 硬件流控制启用
    APP_UART_FLOW_CONTROL_ENABLED,  /**< Standard UART Hw Flow Control is enabled. */
} app_uart_flow_control_t;

再回到开始的宏参数：

• RX_BUF_SIZE：接收缓冲区的大小，也就是用于存储从 UART 接收到的数据的缓冲区大小。 • TX_BUF_SIZE：发送缓冲区的大小，即用于存储要通过 UART 发送出去的数据的缓冲区大小。 • EVT_HANDLER：UART 事件处理函数的指针，当 UART 发生特定事件（像数据接收、发送完成等）时，会调用这个函数。

• IRQ_PRIO：UART 中断的优先级，用于设置 UART 中断在系统中的优先级。

• ERR_CODE：用于存储 UART 初始化的错误码，若初始化成功，该变量会被赋值为 0；若失败，则会被赋值为相应的错误码。  

代码详细解析

#define APP_UART_FIFO_INIT(P_COMM_PARAMS, RX_BUF_SIZE, TX_BUF_SIZE, EVT_HANDLER, IRQ_PRIO, ERR_CODE) \
    do                                                                                             \
    {                                                                                              \
        app_uart_buffers_t buffers;                                                                \
        static uint8_t     rx_buf[RX_BUF_SIZE];                                                    \
        static uint8_t     tx_buf[TX_BUF_SIZE];                                                    \
                                                                                                   \
        buffers.rx_buf      = rx_buf;                                                              \
        buffers.rx_buf_size = sizeof (rx_buf);                                                     \
        buffers.tx_buf      = tx_buf;                                                              \
        buffers.tx_buf_size = sizeof (tx_buf);                                                     \
        ERR_CODE = app_uart_init(P_COMM_PARAMS, &buffers, EVT_HANDLER, IRQ_PRIO);                  \
    } while (0)


     1.  定义缓冲区和变量：

app_uart_buffers_t buffers;：定义一个 app_uart_buffers_t 类型的结构体变量 buffers，该结构体用于存储接收和发送缓冲区的信息。

app_uart_buffers_t 类型的结构体定义如下 ：

typedef struct
{
    uint8_t * rx_buf;      /**< Pointer to the RX buffer. */
    uint32_t  rx_buf_size; /**< Size of the RX buffer. */
    uint8_t * tx_buf;      /**< Pointer to the TX buffer. */
    uint32_t  tx_buf_size; /**< Size of the TX buffer. */
} app_uart_buffers_t;

static uint8_t rx_buf[RX_BUF_SIZE];：定义一个静态的接收缓冲区数组 rx_buf，其大小由 RX_BUF_SIZE 决定。

static uint8_t tx_buf[TX_BUF_SIZE];：定义一个静态的发送缓冲区数组 tx_buf，其大小由 TX_BUF_SIZE 决定。  

2.  初始化缓冲区信息：

buffers.rx_buf = rx_buf;：把 rx_buf 数组的地址赋值给 buffers 结构体的 rx_buf 成员。

buffers.rx_buf_size = sizeof (rx_buf);：把 rx_buf 数组的大小赋值给 buffers 结构体的 rx_buf_size 成员。

buffers.tx_buf = tx_buf;：把 tx_buf 数组的地址赋值给 buffers 结构体的 tx_buf 成员。

buffers.tx_buf_size = sizeof (tx_buf);：把 tx_buf 数组的大小赋值给 buffers 结构体的 tx_buf_size 成员。  

3  调用 UART 初始化函数：

ERR_CODE = app_uart_init(P_COMM_PARAMS, &buffers, EVT_HANDLER, IRQ_PRIO);：调用 app_uart_init 函数来初始化 UART 通信，将初始化的错误码存储在 ERR_CODE 变量中。

   下面是一个简单的使用示例：

 #include <stdio.h>

// 假设的 UART 通信参数结构体
typedef struct {
    int baud_rate;
    // 其他参数...
} app_uart_comm_params_t;

// 假设的 UART 缓冲区结构体
typedef struct {
    uint8_t *rx_buf;
    size_t  rx_buf_size;
    uint8_t *tx_buf;
    size_t  tx_buf_size;
} app_uart_buffers_t;

// 假设的 UART 初始化函数
int app_uart_init(app_uart_comm_params_t *p_comm_params, app_uart_buffers_t *p_buffers, void (*evt_handler)(void), int irq_prio) {
    // 实际的初始化代码
    return 0; // 假设初始化成功
}

// 假设的 UART 事件处理函数
void uart_evt_handler(void) {
    // 处理 UART 事件
}

// 定义宏
#define APP_UART_FIFO_INIT(P_COMM_PARAMS, RX_BUF_SIZE, TX_BUF_SIZE, EVT_HANDLER, IRQ_PRIO, ERR_CODE) \
    do                                                                                             \
    {                                                                                              \
        app_uart_buffers_t buffers;                                                                \
        static uint8_t     rx_buf[RX_BUF_SIZE];                                                    \
        static uint8_t     tx_buf[TX_BUF_SIZE];                                                    \
                                                                                                   \
        buffers.rx_buf      = rx_buf;                                                              \
        buffers.rx_buf_size = sizeof (rx_buf);                                                     \
        buffers.tx_buf      = tx_buf;                                                              \
        buffers.tx_buf_size = sizeof (tx_buf);                                                     \
        ERR_CODE = app_uart_init(P_COMM_PARAMS, &buffers, EVT_HANDLER, IRQ_PRIO);                  \
    } while (0)

int main() {
    app_uart_comm_params_t comm_params = {115200}; // 波特率设置为 115200
    int err_code;

    APP_UART_FIFO_INIT(&comm_params, 256, 256, uart_evt_handler, 1, err_code);

    if (err_code == 0) {
        printf("UART initialization successful.\n");
    } else {
        printf("UART initialization failed with error code: %d\n", err_code);
    }

    return 0;
}


    在这个示例中，我们定义了一个简单的 UART 通信系统，并且使用 APP_UART_FIFO_INIT 宏来初始化 UART 通信。若初始化成功，会输出相应的提示信息；若失败，则会输出错误码。

（2）app_uart_init函数学习

uint32_t app_uart_init(const app_uart_comm_params_t * p_comm_params,app_uart_buffers_t *     p_buffers,app_uart_event_handler_t event_handler,app_irq_priority_t       irq_priority)
{uint32_t err_code;m_event_handler = event_handler;if (p_buffers == NULL){return NRF_ERROR_INVALID_PARAM;}// Configure buffer RX buffer.err_code = app_fifo_init(&m_rx_fifo, p_buffers->rx_buf, p_buffers->rx_buf_size);VERIFY_SUCCESS(err_code);// Configure buffer TX buffer.err_code = app_fifo_init(&m_tx_fifo, p_buffers->tx_buf, p_buffers->tx_buf_size);VERIFY_SUCCESS(err_code);nrf_drv_uart_config_t config = NRF_DRV_UART_DEFAULT_CONFIG;config.baudrate = (nrf_uart_baudrate_t)p_comm_params->baud_rate;config.hwfc = (p_comm_params->flow_control == APP_UART_FLOW_CONTROL_DISABLED) ?NRF_UART_HWFC_DISABLED : NRF_UART_HWFC_ENABLED;config.interrupt_priority = irq_priority;config.parity = p_comm_params->use_parity ? NRF_UART_PARITY_INCLUDED : NRF_UART_PARITY_EXCLUDED;config.pselcts = p_comm_params->cts_pin_no;config.pselrts = p_comm_params->rts_pin_no;config.pselrxd = p_comm_params->rx_pin_no;config.pseltxd = p_comm_params->tx_pin_no;err_code = nrf_drv_uart_init(&app_uart_inst, &config, uart_event_handler);VERIFY_SUCCESS(err_code);m_rx_ovf = false;// Turn on receiver if RX pin is connectedif (p_comm_params->rx_pin_no != UART_PIN_DISCONNECTED){return nrf_drv_uart_rx(&app_uart_inst, rx_buffer,1);}else{return NRF_SUCCESS;}
}

（a)app_uart_init(const app_uart_comm_params_t * p_comm_params,
                                                   app_uart_buffers_t *     p_buffers,
                                        app_uart_event_handler_t event_handler,
                                                       app_irq_priority_t       irq_priority)
{


 * 此函数用于初始化 UART 通信，配置通信参数、缓冲区、事件处理函数和中断优先级。
 *
 * @param p_comm_params 指向 app_uart_comm_params_t 结构体的指针，包含 UART 通信参数，如引脚编号、流控制设置、奇偶校验和波特率等。
 * @param p_buffers 指向 app_uart_buffers_t 结构体的指针，该结构体应包含用于 UART 数据收发的缓冲区。
 * @param event_handler 指向 UART 事件处理函数的指针，当 UART 发生特定事件（如接收数据、发送完成等）时会调用此函数。
 * @param irq_priority UART 中断的优先级，用于确定 UART 中断在系统中的处理顺序。
 *
 * @return 函数返回值类型未给出，一般可能返回一个状态码，用于表示初始化是否成功。
 */

由于不清楚 app_uart_buffers_t、app_uart_event_handler_t 和 app_irq_priority_t 的具体定义，下面给出一个简单的模拟实现：

 #include <stdio.h>
#include <stdint.h>

// 假设 app_uart_flow_control_t 定义如下
typedef enum
{
    APP_UART_FLOW_CONTROL_DISABLED, /**< UART Hw Flow Control is disabled. */
    APP_UART_FLOW_CONTROL_ENABLED,  /**< Standard UART Hw Flow Control is enabled. */
} app_uart_flow_control_t;

// 假设 app_uart_comm_params_t 定义如下
typedef struct
{
    uint32_t                rx_pin_no;    /**< RX pin number. */
    uint32_t                tx_pin_no;    /**< TX pin number. */
    uint32_t                rts_pin_no;   /**< RTS pin number, only used if flow control is enabled. */
    uint32_t                cts_pin_no;   /**< CTS pin number, only used if flow control is enabled. */
    app_uart_flow_control_t flow_control; /**< Flow control setting, if flow control is used, the system will use low power UART mode, based on CTS signal. */
    bool                    use_parity;   /**< Even parity if TRUE, no parity if FALSE. */
    uint32_t                baud_rate;    /**< Baud rate configuration. */
} app_uart_comm_params_t;

// 假设 app_uart_buffers_t 定义如下
typedef struct
{
    uint8_t *rx_buffer;
    uint8_t *tx_buffer;
    size_t rx_buffer_size;
    size_t tx_buffer_size;
} app_uart_buffers_t;

// 假设 app_uart_event_handler_t 是一个函数指针类型
typedef void (*app_uart_event_handler_t)(void);

// 假设 app_irq_priority_t 是一个枚举类型
typedef enum
{
    APP_IRQ_PRIORITY_LOW,
    APP_IRQ_PRIORITY_MEDIUM,
    APP_IRQ_PRIORITY_HIGH
} app_irq_priority_t;

// 模拟实现 app_uart_init 函数
int app_uart_init(const app_uart_comm_params_t * p_comm_params,
                  app_uart_buffers_t *     p_buffers,
                  app_uart_event_handler_t event_handler,
                  app_irq_priority_t       irq_priority)
{
    if (p_comm_params == NULL || p_buffers == NULL || event_handler == NULL)
    {
        return -1; // 输入参数无效
    }

    // 模拟配置 UART 通信参数
    printf("Initializing UART with the following parameters:\n");
    printf("RX Pin: %u\n", p_comm_params->rx_pin_no);
    printf("TX Pin: %u\n", p_comm_params->tx_pin_no);
    printf("Flow Control: %s\n", p_comm_params->flow_control == APP_UART_FLOW_CONTROL_ENABLED ? "Enabled" : "Disabled");
    printf("Parity: %s\n", p_comm_params->use_parity ? "Even" : "None");
    printf("Baud Rate: %u\n", p_comm_params->baud_rate);

    // 模拟配置缓冲区
    printf("RX Buffer Size: %zu\n", p_buffers->rx_buffer_size);
    printf("TX Buffer Size: %zu\n", p_buffers->tx_buffer_size);

    // 模拟设置事件处理函数
    // 这里可以保存 event_handler 指针，在 UART 事件发生时调用
    printf("Event handler set.\n");

    // 模拟设置中断优先级
    printf("Interrupt priority set to ");
    switch (irq_priority)
    {
        case APP_IRQ_PRIORITY_LOW:
            printf("LOW\n");
            break;
        case APP_IRQ_PRIORITY_MEDIUM:
            printf("MEDIUM\n");
            break;
        case APP_IRQ_PRIORITY_HIGH:
            printf("HIGH\n");
            break;
        default:
            printf("UNKNOWN\n");
            break;
    }

    return 0; // 初始化成功
}

使用示例

  int main()
{
    app_uart_comm_params_t comm_params = {
        .rx_pin_no = 1,
        .tx_pin_no = 2,
        .rts_pin_no = 3,
        .cts_pin_no = 4,
        .flow_control = APP_UART_FLOW_CONTROL_ENABLED,
        .use_parity = false,
        .baud_rate = 115200
    };

    uint8_t rx_buffer[100];
    uint8_t tx_buffer[100];
    app_uart_buffers_t buffers = {
        .rx_buffer = rx_buffer,
        .tx_buffer = tx_buffer,
        .rx_buffer_size = sizeof(rx_buffer),
        .tx_buffer_size = sizeof(tx_buffer)
    };

    void dummy_event_handler()
    {
        // 处理 UART 事件的代码
    }

    app_irq_priority_t irq_priority = APP_IRQ_PRIORITY_MEDIUM;

    int result = app_uart_init(&comm_params, &buffers, dummy_event_handler, irq_priority);
    if (result == 0)
    {
        printf("UART initialization successful.\n");
    }
    else
    {
        printf("UART initialization failed.\n");
    }

    return 0;
}

上述代码中，首先为 app_uart_init 函数声明添加了详细注释，然后模拟实现了该函数，最后给出了一个使用示例，展示了如何调用 app_uart_init 函数进行 UART 初始化。

(b)

相关文章：

14、nRF52xx蓝牙学习（串口 UART 和 UARTE 外设应用）

一、UART 功能描述 串口 UART 也称为通用异步收发器。是各种处理器中常用了通信接口&#xff0c;在 nRF52 芯片中&#xff0c; UART 具有以下特点&#xff1a; ● 全双工操作 ● 自动流控 ● 奇偶校验产生第 9 位数据 串口 UART 的数据发送与接收流程 : ◆硬件配置…...

编程日记 2026/1/21 12:00:44

FlinkSQL的常用语言

FlinkSQL 常用语言指南 FlinkSQL 是 Apache Flink 提供的 SQL 接口&#xff0c;允许用户使用标准 SQL 或扩展的 SQL 语法来处理流式和批式数据。以下是 FlinkSQL 的常用语言元素和操作&#xff1a; 基本查询 -- 选择查询 SELECT * FROM table_name;-- 带条件的查询 SELECT c…...

编程日记 2026/1/19 9:20:08

DeepSeek轻松入门教程——从入门到精通

大家好&#xff0c;我是吾鳴。 今天吾鳴要给大家分享一份DeepSeek小白轻松入门指导手册——《DeepSeek 15天指导手册&#xff0c;从入门到精通》。指导手册分为基础入门对话篇、效率飞跃篇、场景实战篇、高手进化篇等&#xff0c;按照指导手册操作&#xff0c;DeepSeek从入门到…...

编程日记 2026/1/21 10:19:01

Vue2 老项目升级 Vue3 深度解析教程

Vue2 老项目升级 Vue3 深度解析教程 摘要 Vue3 带来了诸多改进和新特性&#xff0c;如性能提升、组合式 API、更好的 TypeScript 支持等&#xff0c;将 Vue2 老项目升级到 Vue3 可以让项目获得这些优势。本文将深入解析升级过程&#xff0c;涵盖升级前的准备工作、具体升级步骤…...

编程日记 2026/1/21 12:54:02

vue事假机制都有哪些

Vue 的事件机制主要包含以下几种类型和方式&#xff0c;可以分为组件内部事件、父子组件通信事件、原生 DOM 事件封装、修饰符增强等&#xff0c;下面详细分类介绍&#xff1a; 一、DOM 事件绑定&#xff08;最基础的事件&#xff09; 使用 v-on&#xff08;或简写 &#xff0…...

编程日记 2026/1/19 8:33:04

WXJ196微机小电流接地选线装置使用简单方便无需维护

WXJ196微机小电流接地选线装置&#xff0c;能在系统发生单相接地时&#xff0c;准确、迅速地选出接地线路母 线。使用简单方便&#xff0c;无需维护&#xff0c;可根据用户需要将相关信息通过通信接口传给上级监控系统&#xff0c; 适用于无人值守变电站。 2 功能及特点 全新的…...

编程日记 2026/1/25 9:01:57

Java第四节：idea在debug模式夏改变变量的值

作者往期文章 Java第一节&#xff1a;debug如何调试程序&#xff08;附带源代码&#xff09;-CSDN博客 Java第二节&#xff1a;debug如何调试栈帧链&#xff08;附带源代码&#xff09;-CSDN博客 Java第三节&#xff1a;新手如何用idea创建java项目-CSDN博客 步骤一 在需要修改…...

编程日记 2026/1/25 9:04:12

instructor 实现 reranker 功能

目录 代码代码解释1. 导入和初始化2. Label 类定义3. RerankedResults 类4. 重排序函数 示例类似例子例子中的jinjia模板语法变量2. 控制结构条件语句循环语句 代码 import instructor from openai import OpenAI from pydantic import BaseModel, Field, field_validator, Va…...

编程日记 2026/1/8 6:28:39

门极驱动器DRV8353M设计（二）

目录 13.3.4.4 MOSFET VDS 感测 (SPI Only) 13.3.5 Gate Driver保护回路 13.3.5.1 VM 电源和 VDRAIN 欠压锁定 (UVLO) 13.3.5.2 VCP 电荷泵和 VGLS 稳压器欠压锁定 (GDUV) 13.3.5.3 MOSFET VDS过流保护 (VDS_OCP) 13.3.5.3.1 VDS Latched Shutdown (OCP_MODE 00b) 13.…...

编程日记 2026/1/22 20:35:44

学点概率论，打破认识误区

概率论是统计分析和机器学习的核心。掌握概率论对于理解和开发稳健的模型至关重要&#xff0c;因为数据科学家需要掌握概率论。本博客将带您了解概率论中的关键概念&#xff0c;从集合论的基础知识到高级贝叶斯推理&#xff0c;并提供详细的解释和实际示例。 目录 简介 基本集合…...

编程日记 2026/1/22 17:03:19

NVIDIA AI Aerial

NVIDIA AI Aerial 适用于无线研发的 NVIDIA AI Aerial 基础模组Aerial CUDA 加速 RANAerial Omniverse 数字孪生Aerial AI 无线电框架 用例构建商业 5G 网络加速 5G生成式 AI 和 5G 数据中心 加速 6G 研究基于云的工具 优势100% 软件定义通过部署在数字孪生中进行测试6G 标准化…...

编程日记 2026/1/22 20:03:43

OpenCV 关键点定位

一、Opencv关键点定位介绍 关键点定位在计算机视觉领域占据着核心地位&#xff0c;它能够精准识别图像里物体的关键特征点。OpenCV 作为功能强大的计算机视觉库&#xff0c;提供了多种实用的关键点定位方法。本文将详细阐述关键点定位的基本原理&#xff0c;深入探讨 OpenCV 中…...

编程日记 2026/1/25 9:04:00

C++ 重构muduo网络库

本项目参考的陈硕老师的思想 1. 基础概念 进程里有 Reactor、Acceptor、Handler 这三个对象 Reactor 对象的作用是监听和分发事件&#xff1b;Acceptor 对象的作用是获取连接&#xff1b;Handler 对象的作用是处理业务&#xff1b; 先说说 阻塞I/O&#xff0c;非阻塞I/O&…...

编程日记 2026/1/14 16:23:01

SDHC接口协议底层传输数据是安全的

SDHC&#xff08;Secure Digital High Capacity&#xff09;接口协议在底层数据传输过程中确实包含校验机制&#xff0c;以确保数据的完整性和可靠性。以下是关键点的详细说明&#xff1a; 物理层与数据链路层的校验机制 物理层&#xff08;Electrical Layer&#xff09;&…...

编程日记 2026/1/19 6:44:52

arm_math.h、arm_const_structs.h 和 arm_common_tables.h

在 ​​FOC&#xff08;Field-Oriented Control&#xff0c;磁场定向控制&#xff09;​​ 中&#xff0c;arm_math.h、arm_const_structs.h 和 arm_common_tables.h 是 CMSIS-DSP 库的核心组件&#xff0c;用于实现高效的数学运算、预定义结构和查表操作。以下是它们在 FOC 控…...

编程日记 2026/1/25 9:03:57

buuctf sql注入类练习

BUU SQL COURSE 1 1 实例无法访问 / Instance cant be reached at that time | BUUCTF但是这个地方很迷惑就是这个 一个 # 我们不抓包就不知道这个是sql注入类的判断是 get 类型的sql注入直接使用sqlmap我们放入到1.txt中 目的是 优先检测 ?id1>python3 sqlmap.py -r 1.t…...

编程日记 2026/1/25 9:04:20

具身导航中的视觉语言注意力蒸馏！Vi-LAD：实现动态环境中的社会意识机器人导航

作者&#xff1a;Mohamed Elnoor 1 ^{1} 1, Kasun Weerakoon 1 ^{1} 1, Gershom Seneviratne 1 ^{1} 1, Jing Liang 2 ^{2} 2, Vignesh Rajagopal 3 ^{3} 3, and Dinesh Manocha 1 , 2 ^{1,2} 1,2单位&#xff1a; 1 ^{1} 1马里兰大学帕克分校电气与计算机工程系&#xff0c; 2…...

编程日记 2026/1/19 4:16:07

全局前置守卫与购物车页面鉴权

在很多应用里&#xff0c;并非所有页面都能随意访问。例如购物车页面&#xff0c;用户需先登录才能查看。这时可以利用全局前置守卫来实现这一鉴权功能。 全局前置守卫的书写位置在 router/index.js 文件中&#xff0c;在创建 router 对象之后&#xff0c;暴露 router 对象之前…...

编程日记 2026/1/22 21:53:05

vue3 ts 自定义指令 app.directive

在 Vue 3 中&#xff0c;app.directive 是一个全局 API&#xff0c;用于注册或获取全局自定义指令。以下是关于 app.directive 的详细说明和使用方法 app.directive 用于定义全局指令&#xff0c;这些指令可以用于直接操作 DOM 元素。自定义指令在 Vue 3 中非常强大&#xff0…...

编程日记 2025/12/20 22:28:10

layui 弹窗-调整窗口的缩放拖拽几次就看不到标题、被遮挡了怎么解决

拖拽几次&#xff0c;调整窗口的缩放&#xff0c;就出现了弹出的页面&#xff0c;右上角叉号调不出来了&#xff0c;窗口关不掉 废话不多说直入主题: 在使用layer.alert layer.confirm layer.msg 等等弹窗时&#xff0c;发现看不到弹窗&#xff0c;然后通过控制台检查代码发现…...

编程日记 2026/1/25 9:06:10

网络空间安全（57）K8s安全加固

一、升级K8s版本和组件 原因&#xff1a;K8s新版本通常会引入一系列安全功能&#xff0c;提供关键的安全补丁&#xff0c;能够补救已知的安全风险&#xff0c;减少攻击面。 操作&#xff1a;将K8s部署更新到最新稳定版本&#xff0c;并使用到达stable状态的API。 二、启用RBAC&…...

编程日记 2026/1/25 9:04:31

2025蓝桥杯C++A组省赛 题解

昨天打完蓝桥杯本来想写个 p y t h o n python python A A A 组的题解&#xff0c;结果被队友截胡了。今天上课把 C A CA CA 组的题看了&#xff0c;感觉挺简单的&#xff0c;所以来水一篇题解。 这场 B B B 是一个爆搜&#xff0c; C C C 利用取余的性质比较好写&#…...

编程日记 2026/1/25 9:04:03

论文学习：《通过基于元学习的图变换探索冷启动场景下的药物-靶标相互作用预测》

原文标题&#xff1a;Exploring drug-target interaction prediction on cold-start scenarios via meta-learning-based graph transformer 原文链接&#xff1a;https://www.sciencedirect.com/science/article/pii/S1046202324002470 药物-靶点相互作用&#xff08;DTI&…...

编程日记 2026/1/22 16:18:50

【题解-洛谷】P1824 进击的奶牛

题目：P1824 进击的奶牛 题目描述 Farmer John 建造了一个有 N N N（ 2 ≤ N ≤...

编程日记 2025/12/30 4:36:34

机械革命 无界15X 自带的 有线网卡 YT6801 debian12下 的驱动方法

这网卡是国货啊。。。 而且人家发了驱动程序 Motorcomm Microelectronics. YT6801 Gigabit Ethernet Controller [1f0a:6801] 网卡YT6801在Linux环境中的安装方法 下载网址 yt6801-linux-driver-1.0.29.zip 我不知道别的系统是否按照说明安装就行了 但是debian12不行&…...

编程日记 2026/1/21 13:50:07

十八、TCP多线程、多进程并发服务器

1、TCP多线程并发服务器 服务端&#xff1a; #include<stdio.h> #include <arpa/inet.h> #include<stdlib.h> #include<string.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> #include <pthread.h>…...

编程日记 2026/1/25 7:00:05

JAVA中正则表达式的入门与使用

JAVA中正则表达式的入门与使用 一&#xff0c;基础概念 正则表达式&#xff08;Regex&#xff09; 用于匹配字符串中的特定模式&#xff0c;Java 中通过 java.util.regex 包实现&#xff0c;核心类为&#xff1a; Pattern&#xff1a;编译后的正则表达式对象。 Matcher&#…...

编程日记 2026/1/24 21:21:51

AIGC-文生图与图生图

在之前的文章中&#xff0c;我们知道了如何通过Web UI和Confy UI两种SD工具来进行图片生成&#xff0c;今天进一步地讲解其中的参数用处及如何调节。 文生图 参数详解 所谓文生图&#xff0c;就是通过文字描述我们想要图片包含的内容。初学的话&#xff0c;还是以Web UI为例…...

编程日记 2026/1/22 20:19:22

量化交易 - 聚宽joinquant - 多因子入门研究 - 源码开源

先看一下我们的收益&#xff1a; JoinQuant直达这里看看 下面讲解原理和代码。 目录 一、是否为st 二、是否停牌 三、市值小、roe大 四、编写回测代码 今天来研究一下多因子回测模型&#xff0c;这里以‘市值’、‘roe’作为例子。 几个标准&#xff1a;沪深300里选股&am…...

编程日记 2026/1/25 9:04:35

本地缓存方案Guava Cache

Guava Cache 是 Google 的 Guava 库提供的一个高效内存缓存解决方案&#xff0c;适用于需要快速访问且不频繁变更的数据。 // 普通缓存 Cache<Key, Value> cache CacheBuilder.newBuilder().maximumSize(1000) // 最大条目数.expireAfterWrite(10, TimeUnit.MINUTES) /…...

编程日记 2025/11/27 9:08:51