UART(Universal Asynchronous Receiver/Transmitter)

最新推荐文章于 2024-03-12 17:28:25 发布
最新推荐文章于 2024-03-12 17:28:25 发布
阅读量1.5k 收藏 10
点赞数 5
分类专栏： uart 文章标签： c语言 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dkmknjk/article/details/122128219
版权

uart驱动实现

操作系统：裸机
IP版本：DW_apb_uart
语言：C语言
机器：32位

register

uart基地址

#define UART_BASE (0x????????)

uart中断号

#define UART_IRQ (0x??)

uart寄存器结构体

#define   __I     volatile const /*Defines 'read only' */
#define   __O     volatile /*Defines 'write only' */
#define   __IO    volatile/*Defines 'read / write' */

typedef unsigned int			u32_t;

typedef struct
{
    union UART_REG0{
        __I  u32_t UART_RBR;        //0x00
        __O  u32_t UART_THR;        //0x00
        __IO u32_t UART_DLL;        //0x00
    } uart_reg0;

    union UART_REG1{
        __IO u32_t UART_IER;        //0x04
        __IO u32_t UART_DLH;        //0x04
    } uart_reg1;

    union UART_REG2{
        __I  u32_t UART_IIR;        //0x08
        __O  u32_t UART_FCR;        //0x08
    } uart_reg2;

    __IO u32_t UART_LCR;            //0x0C
    __IO u32_t UART_MCR;            //0x10
    __I  u32_t UART_LSR;            //0x14
    __I  u32_t UART_MSR;            //0x18

    __IO u32_t UART_SCR;            //0x1C
    __IO u32_t UART_LPDLL;          //0x20
    __IO u32_t UART_LPDLH;          //0x24

    u32_t RSVD0[2];            //0x28~0x2C

    union UART_REG3{
        struct UART_SRBR {
            __I  u32_t UART_SRBR0;      //0x30
            __I  u32_t UART_SRBR1;      //0x34
            __I  u32_t UART_SRBR2;      //0x38
            __I  u32_t UART_SRBR3;      //0x3C
            __I  u32_t UART_SRBR4;      //0x40
            __I  u32_t UART_SRBR5;      //0x44
            __I  u32_t UART_SRBR6;      //0x48
            __I  u32_t UART_SRBR7;      //0x4C
            __I  u32_t UART_SRBR8;      //0x50
            __I  u32_t UART_SRBR9;      //0x54
            __I  u32_t UART_SRBR10;     //0x58
            __I  u32_t UART_SRBR11;     //0x5C
            __I  u32_t UART_SRBR12;     //0x60
            __I  u32_t UART_SRBR13;     //0x64
            __I  u32_t UART_SRBR14;     //0x68
            __I  u32_t UART_SRBR15;     //0x6C
        } uart_srbr;

        struct UART_STHR {
            __O  u32_t UART_STHR0;      //0x30
            __O  u32_t UART_STHR1;      //0x34
            __O  u32_t UART_STHR2;      //0x38
            __O  u32_t UART_STHR3;      //0x3C
            __O  u32_t UART_STHR4;      //0x40
            __O  u32_t UART_STHR5;      //0x44
            __O  u32_t UART_STHR6;      //0x48
            __O  u32_t UART_STHR7;      //0x4C
            __O  u32_t UART_STHR8;      //0x50
            __O  u32_t UART_STHR9;      //0x54
            __O  u32_t UART_STHR10;     //0x58
            __O  u32_t UART_STHR11;     //0x5C
            __O  u32_t UART_STHR12;     //0x60
            __O  u32_t UART_STHR13;     //0x64
            __O  u32_t UART_STHR14;     //0x68
            __O  u32_t UART_STHR15;     //0x6C
        } uart_sthr;
    } uart_reg3;

    __IO u32_t UART_FAR;         //0x70
    __I  u32_t UART_TFR;         //0x74
    __O  u32_t UART_RFW;         //0x78
    __I  u32_t UART_USR;         //0x7C

    __I  u32_t UART_TFL;         //0x80
    __I  u32_t UART_RFL;         //0x84
    __IO u32_t UART_SRR;         //0x88
    __IO u32_t UART_SRTS;        //0x8C

    __IO u32_t UART_SBCR;        //0x90
    __IO u32_t UART_SDMAM;       //0x94
    __IO u32_t UART_SFE;         //0x98
    __IO u32_t UART_SRT;         //0x9C

    __IO u32_t UART_STET;        //0xA0
    __IO u32_t UART_HTX;         //0xA4
    __IO u32_t UART_DMASA;       //0xA8
    __IO u32_t UART_TCR;         //0xAC

    __IO u32_t UART_DE_EN;       //0xB0
    __IO u32_t UART_RE_EN;       //0xB4
    __IO u32_t UART_DET;         //0xB8
    __IO u32_t UART_TAT;         //0xBC

    __IO u32_t UART_DLF;         //0xC0
    __IO u32_t UART_RAR;         //0xC4
    __IO u32_t UART_TAR;         //0xC8
    __IO u32_t UART_LCR_EXT;     //0xCC

    __IO u32_t UART_PROT_LEVEL;     //0xD0
    __IO u32_t UART_REG_TIMEOUT_RST;//0xD4

    u32_t RSVD1[7];         //0xD8~0xF0

    __I  u32_t UART_CPR;         //0xF4
    __I  u32_t UART_UCV;         //0xF8
    __I  u32_t UART_CTR;         //0xFC
}uart_typedef;

#define UART0    ((uart_typedef *)UART0_BASE)

include

数据位宽

#define UART_9BIT_DATA_EN 0

#ifdef UART_9BIT_DATA_EN
	#define UART_WIDTH_N 9
#else
	#define UART_WIDTH_N 8
#endif

用户自定义初始化结构体

typedef struct
{
    u32_t baudrate_fraction;
    u32_t baudrate_low;
    u32_t baudrate_high;

    /* 0x3:8bit    0x2:7bit    0x1:6bit    0x0:5bit*/
    u32_t data_length;

    /* 0x0:1 stop bit    0x1:1.5 stop bit when DLS(LCR[1:0]) is zero,else 2 stop bit */
    u32_t stop_bit_count;

    /* 0x0:odd     0x1:even */
    u32_t add_even;
}uart_inittypedef;

寄存器例化

typedef union uarts_rbr
{
    struct rbr {
        u32_t rbr:UART_WIDTH_N;
        u32_t rsvd:(32-UART_WIDTH_N);
    } rbr;
    u32_t value;
} uarts_rbr;

typedef union uarts_thr
{
    struct thr {
        u32_t thr:UART_WIDTH_N;
        u32_t rsvd:(32-UART_WIDTH_N);
    } thr;
    u32_t value;
} uarts_thr;

typedef union uarts_tcr
{
    struct tcr {
        u32_t rs485_en:1;
        u32_t re_pol:1;
        u32_t de_pol:1;
        u32_t xfer_mode:2;
        u32_t rsvd:27;
    } tcr;
    u32_t value;
} uarts_tcr;

typedef union uarts_mcr
{
    struct mcr {
        u32_t dtr:1;
        u32_t rts:1;
        u32_t out1:1;
        u32_t out2:1;
        u32_t loopback:1;
        u32_t afce:1;
        u32_t sire:1;
        u32_t rsvd:25;
    } mcr;
    u32_t value;
} uarts_mcr;

typedef union uarts_lcr
{
    struct lcr {
        u32_t dls:2;
        u32_t stop:1;
        u32_t pen:1;
        u32_t eps:1;
        u32_t sp:1;
        u32_t bc:1;
        u32_t dlab:1;
        u32_t rsvd:24;
    } lcr;
    u32_t value;
} uarts_lcr;

typedef union uarts_dlf
{
    struct dlf {
        u32_t dlf:UART_WIDTH_N;
        u32_t rsvd:(32-UART_WIDTH_N);
    } dlf;
    u32_t value;
} uarts_dlf;

typedef union uarts_dll
{
    struct dll {
        u32_t dll:8;
        u32_t rsvd:24;
    } dll;
    u32_t value;
} uarts_dll;

typedef union uarts_dlh
{
    struct dlh {
        u32_t dlh:8;
        u32_t rsvd:24;
    } dlh;
    u32_t value;
} uarts_dlh;

typedef union uarts_fcr
{
    struct fcr {
        u32_t fifoe:1;
        u32_t rfifor:1;
        u32_t xfifor:1;
        u32_t dmam:1;
        u32_t tet:2;
        u32_t rt:2;
        u32_t rsvd:24;
    } fcr;
    u32_t value;
} uarts_fcr;

typedef union uarts_ier
{
    struct ier {
        u32_t erbfi:1;
        u32_t etbei:1;
        u32_t elsi:1;
        u32_t edssi:1;
        u32_t elcolr:1;
        u32_t rsvd0:2;
        u32_t ptime:1;
        u32_t rsvd1:24;
    } ier;
    u32_t value;
} uarts_ier;

typedef union uarts_iir
{
    struct iir {
        u32_t iid:4;
        u32_t rsvd0:2;
        u32_t fifoe:2;
        u32_t rsvd1:24;
    } iir;
    u32_t value;
} uarts_iir;

typedef union uarts_lsr
{
    struct lsr {
        u32_t dr:1;
        u32_t oe:1;
        u32_t pe:1;
        u32_t fe:1;
        u32_t bi:1;
        u32_t thre:1;
        u32_t temt:1;
        u32_t rfe:1;
        u32_t addr_rcvd:1;
        u32_t rsvd:23;
    } lsr;
    u32_t value;
} uarts_lsr;

source

void uart_set_rs485_mode(uart_typedef* uart)
{
    uarts_tcr *uart_tcr;

    uart_tcr = (uarts_tcr *) & (uart->UART_TCR);
    /* enabled the timer:bit0写1 */
    uart_tcr->tcr.rs485_en = 0b1;
}

void uart_stop(uart_typedef* uart)
{
    uarts_mcr *uart_mcr;

    uart_mcr = (uarts_mcr *) & (uart->UART_MCR);
    uart_mcr->mcr.sire = 0b0;
    uart_mcr->mcr.afce = 0b0;
    uart_mcr->mcr.loopback = 0b0;
    uart_mcr->mcr.out2 = 0b0;
    uart_mcr->mcr.out1 = 0b0;
    uart_mcr->mcr.rts = 0b0;
    uart_mcr->mcr.dtr = 0b0;
}

void uart_enable_baudrate(uart_typedef* uart)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.dlab = 0b1;
}

void uart_disable_baudrate(uart_typedef* uart)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.dlab = 0b0;
}


void uart_set_baudrate_fraction(uart_typedef* uart, u32_t fraction)
{
    uarts_dlf *uart_dlf;

    uart_dlf = (uarts_dlf *) & (uart->UART_DLF);
    uart_dlf->dlf.dlf = fraction;
}

void uart_set_baudrate_low(uart_typedef* uart, u32_t low)
{
    uarts_dll *uart_dll;

    uart_dll = (uarts_dll *) & (uart->uart_reg0.UART_DLL);
    uart_dll->dll.dll = low;
}

void uart_set_baudrate_high(uart_typedef* uart, u32_t high)
{
    uarts_dlh *uart_dlh;

    uart_dlh = (uarts_dlh *) & (uart->UART_DLF);
    uart_dlh->dlh.dlh = high;
}

void uart_select_data_length(uart_typedef* uart, u32_t length)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.dls = length;
}

void uart_select_stop_bit_count(uart_typedef* uart, u32_t stop_bit_count)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.stop = stop_bit_count;
}

void uart_enable_parity(uart_typedef* uart)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.pen = 0b1;
}

void uart_disable_parity(uart_typedef* uart)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.pen = 0b0;
}

void uart_select_parity_odd_even(uart_typedef* uart, u32_t odd_even)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.eps = odd_even;
}

void uart_enable_stick_parity(uart_typedef* uart)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.sp = 0b1;
}

void uart_disable_stick_parity(uart_typedef* uart)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.sp = 0b0;
}

void uart_enable_break_control(uart_typedef* uart)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.bc = 0b1;
}

void uart_disable_break_control(uart_typedef* uart)
{
    uarts_lcr *uart_lcr;

    uart_lcr = (uarts_lcr *) & (uart->UART_LCR);
    uart_lcr->lcr.bc = 0b0;
}

void uart_enable_fifo(uart_typedef* uart)
{
    uarts_fcr *uart_fcr;

    uart_fcr = (uarts_fcr *) & (uart->uart_reg2.UART_FCR);
    uart_fcr->fcr.fifoe = 0b1;
}

void uart_disable_fifo(uart_typedef* uart)
{
    uarts_fcr *uart_fcr;

    uart_fcr = (uarts_fcr *) & (uart->uart_reg2.UART_FCR);
    uart_fcr->fcr.fifoe = 0b0;
}

void uart_reset_receive_fifo(uart_typedef* uart)
{
    uarts_fcr *uart_fcr;

    uart_fcr = (uarts_fcr *) & (uart->uart_reg2.UART_FCR);
    uart_fcr->fcr.rfifor = 0b1;
}

void uart_reset_transmit_fifo(uart_typedef* uart)
{
    uarts_fcr *uart_fcr;

    uart_fcr = (uarts_fcr *) & (uart->uart_reg2.UART_FCR);
    uart_fcr->fcr.xfifor = 0b1;
}

void uart_select_dma_mode0(uart_typedef* uart)
{
    uarts_fcr *uart_fcr;

    uart_fcr = (uarts_fcr *) & (uart->uart_reg2.UART_FCR);
    uart_fcr->fcr.dmam = 0b0;
}

void uart_select_dma_mode1(uart_typedef* uart)
{
    uarts_fcr *uart_fcr;

    uart_fcr = (uarts_fcr *) & (uart->uart_reg2.UART_FCR);
    uart_fcr->fcr.dmam = 0b1;
}

void uart_fifo_empty(uart_typedef* uart)
{
    uarts_fcr *uart_fcr;

    uart_fcr = (uarts_fcr *) & (uart->uart_reg2.UART_FCR);
    uart_fcr->fcr.tet = 0b00;
}

void uart_fifo_trigger_level(uart_typedef* uart, u32_t trogger_level)
{
    uarts_fcr *uart_fcr;

    uart_fcr = (uarts_fcr *) & (uart->uart_reg2.UART_FCR);
    uart_fcr->fcr.rt = trogger_level;
}

void uart_enable_interrupt(uart_typedef* uart)
{
    uarts_ier *uart_ier;

    uart_ier = (uarts_ier *) & (uart->uart_reg1.UART_IER);
    uart_ier->ier.erbfi = 0b1;
    uart_ier->ier.etbei = 0b1;
    uart_ier->ier.elsi= 0b1;
    uart_ier->ier.edssi = 0b1;
    uart_ier->ier.elcolr = 0b1;
    uart_ier->ier.ptime = 0b1;
}

void uart_tx_data(uart_typedef* uart, u32_t data)
{
    uarts_thr *uart_thr;

    uart_thr = (uarts_thr *) & (uart->uart_reg0.UART_THR);
    uart_thr->thr.thr = data;
}

u32_t uart_rx_data(uart_typedef* uart)
{
    uarts_rbr *uart_rbr;

    uart_rbr = (uarts_rbr *) & (uart->uart_reg0.UART_RBR);
    return uart_rbr->rbr.rbr;
}

int uart_transmitter_status(uart_typedef* uart)
{
    uarts_lsr *uart_lsr;

    uart_lsr = (uarts_lsr *) & (uart->UART_LSR);
    return uart_lsr->lsr.thre;
}

int uart_receive_status(uart_typedef* uart)
{
    uarts_lsr *uart_lsr;

    uart_lsr = (uarts_lsr *) & (uart->UART_LSR);
    return uart_lsr->lsr.dr;
}

int uart_interrupt_status(uart_typedef* uart)
{
    uarts_iir *uart_iir;

    uart_iir = (uarts_iir *) & (uart->uart_reg2.UART_IIR);
    return uart_iir->value;
}

uart初始化

void uart_init(uart_typedef* uart,uart_inittypedef* uart_initstruct)
{
    /* stop uart */
    uart_stop(uart);

    /*  set baudrate*/
    uart_enable_baudrate(uart);
    uart_set_baudrate_fraction(uart, uart_initstruct->baudrate_fraction);
    uart_set_baudrate_low(uart, uart_initstruct->baudrate_low);
    uart_set_baudrate_high(uart, uart_initstruct->baudrate_high);
    uart_disable_baudrate(uart);

    /* select data length */
    uart_select_data_length(uart, uart_initstruct->data_length);

    /* select stop bit count */
    uart_select_stop_bit_count(uart, uart_initstruct->stop_bit_count);

    /* enable parity */
    uart_enable_parity(uart);
    /* select parity for add or even */
    uart_select_parity_odd_even(uart, uart_initstruct->add_even);
    /* enable stick parity */
    uart_enable_stick_parity(uart);

    /* release data transmission */
    uart_disable_break_control(uart);

    /* enable fifo */
    uart_enable_fifo(uart);
    /* reset receive fifo */
    uart_reset_receive_fifo(uart);
    /* reset transmit fifo */
    uart_reset_transmit_fifo(uart);
    /* select dma mode0 */
    uart_select_dma_mode0(uart);
    /* clear tx fifo to empty */
    uart_fifo_empty(uart);
    /* select the trogger level in rx fifo */
    uart_fifo_trigger_level(uart, 0x1);

    /* enable interrupt */
    uart_enable_interrupt(uart);
}

谢谢！！！

daikaimiao
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
UART (Universal Asynchronous Receiver/Transmitter) 通用异步收发器
ivbapplication的专栏
11-02 3641
UART是用于控制计算机与串行设备的芯片。有一点要注意的是，它提供了RS-232C数据终端设备接口，这样计算机就可以和调制解调器或其它使用RS-232C接口的串行设备通信了。作为接口的一部分，UART还提供以下功能：     将由计算机内部传送过来的并行数据转换为输出的串行数据流。    将计算机外部来的串行数据转换为字节，供计算机内部使用并行数据的器件使用。    在输出的串行数据流中加
ESP32 学习笔记（三）UART - Universal Asynchronous Receiver/Transmitter
InfiniteYuan
08-11 8199
UART 概述 嵌入式应用通常要求一个简单的并且占用系统资源少的方法来传输数据。通用异步收发传输器(UART) 即可以满足这些要求，它能够灵活地与外部设备进行全双工数据交换。ESP32 芯片中有3 个UART 控制器可供使用，并且兼容不同的UART 设备。另外，UART 还可以用作红外数据交换(IrDA) 或RS-485 调制解调器。 3 个UART 控制器有一组功能相同的寄存器。本文以UA...
dw-apb-uart
04-24
dw_apb_uart c驱动代码
DW_apb_uart(1)
dfvcx2580的博客
04-22 6191
文章目录第一章 总体概述1.1 IP产品说明1.2 DW_apb_uart功能描述1.2.1 发送和接收数据FIFO1.2.2 DMA控制器接口1.2.3 异步时钟支持1.2.4 自动流量控制1.2.5 可编程发送保持寄存器空（THRE）中断1.2.6 串口红外支持1.2.7 增加内置诊断功能1.2.8 1级和2级调试支持1.3 DW_apb_uart整体框架1.4 DW_apb_uart特征 第一章 总体概述 1.1 IP产品说明 DW_apb_uart是一种可编程通用异步收发器（uart），该组件是符合
DW_apb_uart (2)
dfvcx2580的博客
04-25 4096
DW_apb_uart（1） 文章目录3.功能描述3.1 UART串行协议3.2 IrDA 1.0 SIR协议3.3 FIFO模式3.4 时钟模式3.5 中断模式3.6 自动流量控制3.7 可编程THRE中断 3.功能描述 3.1 UART串行协议 因为DW_apb_uart和所选设备之间的串行通信是异步的，所以在串行数据中添加了额外的位（开始和停止）来指示开始和结束。利用这些位可以同步两个设备。这种带有起始和停止位的串行数据结构称为一个字符。其结构如下图所示： 可以向串行字符中添加额外的奇偶校验位，该位
第二章 DW_apb_uart介绍
原海青木的博客
03-11 1802
波特率可软件配置，支持小数部分设置。计算公式如下：其中分频系数divisor由DLH和DLL寄存器控制。/** = (Serial Clock Operating Frequency >> 4) / Baud Rate (unsigned short类型保存数据时自动取整);* 当前 DLF_SIZE = 6，精度是6bit ，可以等分成为64份*/
新思公司的dw-apb-uart串口代码
weixin_44402611的博客
08-20 3016
rk uart使用dw - apb -uart，新思公司的uart代码，在8250文件夹下面。
UART 协议 Universal Asynchronous Receiver/Transmitter 协议
11-04
UART（通用异步收发传输器）是一种广泛用于设备间串行通信的接口标准，尤其在微控制器和计算机系统之间。UART协议允许两个设备通过共享的传输线进行数据交换，通常包括TX（发送）和RX（接收）两条线。下面我们将深入...
Universal Asynchronous Receiver Transmitter (UART) 通用异步接收发射机
08-02
UART（通用异步接收发射机）是计算机硬件通信接口的一种，广泛用于串行通信中，尤其是在嵌入式系统和微控制器中。它允许设备通过单个数据线进行双向通信，通常用于连接各种外设，如键盘、鼠标或串口调试器。UART在...
uart.rar_uart_uart transmitter _universal
09-22
UART，全称Universal Asynchronous Receiver and Transmitter，是通用异步收发传输器，是微处理器与外部设备间常用的一种串行通信接口。在数字电路和嵌入式系统设计中，UART扮演着至关重要的角色，它能以较低的硬件...
uart_DW_apb_uart_dw_apb_APBuart_APB_UART_dwuart
08-12
本文档具有较全面的dw_apb_uartd的接口代码，具有详细的注释，很方便供用户学习。
DW_apb_i2c 驱动
05-08
dw i2c master control driver！
apb_UART.zip
09-01
这个是接着UART完整的APB的demo，里面有上文提到的整个工程，然后这还有个完成的带ARM核的demo，比较麻烦没有上传，如有需要，可以私聊，共同进步学习。
UART.rar_uart transmitter
09-19
UART（通用异步收发传输器，Universal Asynchronous Receiver/Transmitter）是计算机硬件中一个重要的接口，用于设备之间的串行通信。它在各种嵌入式系统、微控制器以及计算机主板上广泛使用，允许不同设备间的数据...
UART.zip_uart_uart transmitter _zip
09-22
UART，即通用异步收发传输器（Universal Asynchronous Receiver/Transmitter），是微处理器与外部设备进行串行通信的一种接口。UART接口广泛应用于各种电子设备中，如嵌入式系统、单片机、计算机等，它允许这些设备...
第三章 DW_apb_uart初始化和使用
最新发布
原海青木的博客
03-12 1242
*定义联合体用于访问 RBR/DLL/THR 寄存器 *//* 定义联合体用于访问 DLH/IER 寄存器 *//* 定义联合体用于访问 FCR/IIR 寄存器 */上面这几个寄存器很特殊，使用的相同的偏移地址，读写的时候分别表示不同的含义，所以用联合体来定义。（吐槽一下，这个设计有点坑爹 =_=）接下来是定义所有的寄存器。该结构体包含UART初始化相关参数，用于配置UART的寄存器。/*!< 配置 uart 时钟源 *//*!< 配置 uart 波特率 *//*!
UART简介
青春易逝，愿不负昭华，期待梦与远方
10-19 459
因为DW_apb_uart和所选设备之间的串行通信是异步的，所以在串行数据中添加了额外的位（开始和停止）来指示开始和结束。利用这些位可以同步两个设备。这种带有起始和停止位的串行数据结构称为一个字符
apb uart IP使用说明
9+ years SOC/CPU Designer
05-17 545
通用异步收发传输器(Universal Asynchronous Receiver/Transmitter)，通常称作UART，是一种异步收发传输器，是电脑硬件的一部分。它将要传输的资料在串行通信与并行通信之间加以转换。作为把并行输入信号转成串行输出信号的芯片，UART通常被集成于其他通讯接口的连结上。在SOC设计中，UART被用于调试、打印、接收AT命令等。
USART UART
11-22
USART和UART是两种串行通信协议，它们在异步通信时没有太大区别，但在同步通信时有一些明显的区别。 USART是Universal Synchronous/Asynchronous Receiver/Transmitter的缩写，意为通用同步/异步收发器。它在UART的基础上增加了同步功能，可以提供主动时钟来触发数据传输。这使得USART在同步通信中更加灵活，可以支持一些特殊的应用，比如ISO7816的智能卡接口。 UART是Universal Asynchronous Receiver/Transmitter的缩写，意为通用异步收发器。它是一种简单的串行通信协议，常用于异步通信。UART通过发送和接收数据的引脚来实现数据传输，不需要时钟信号来同步数据。 总结来说，USART是UART的增强型，它在异步通信时与UART没有太大区别，但在同步通信时可以提供主动时钟来触发数据传输。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值