IMX6LL|串口通信

相关寄存器

• UART1时钟源

  • CCM_CSCDR1

• 初始化 UART1

  • UART1_UCR1：使能uart1、自动波特率

  • UART1_UCR2：设置串口的发送帧格式

    • 奇偶校验位、软件复位

    • 数据长度

    • 发送完成标志、数据接受标志

    • 发送使能、接收使能

  • UART1_UCR3：bit2置1，官方要求设置

  • UART1_UFCR：时钟分频、发送与接收的 fifo大小

  • UART1_UBIR、UART1_UBMR：波特率

• 收发数据
  • UART1_UTXD ：发送一个字符
  • UART1_URXD ：接受一个字符

55.15 UART Memory Map/Register Definition

makefile修改

官方sdk的设置波特率函数使用了除法，需要提供gcc除法库

LIBPATH := -lgcc  -static -L/usr/lib/gcc/arm-none-eabi/6.3.1

• -lgcc 表示会链接“libgcc.a”库

• -static -L 表示静态库所在路径

代码：

#include "uart.h"



void uart_init(void)

{

    /*时钟初始化，设置 UART 根时钟，并设置为40MHz*/

    CCM->CSCDR1 &= ~(0x01 << 6); //设置UART选择 PLL3 / 6 = 80MHz

    CCM->CSCDR1 &= ~(0x3F);      //清零

    CCM->CSCDR1 |= (0x01 << 0);  //设置串口根时钟分频值为1，UART根时钟频率为：80M / (dev + 1) = 40MHz



    //禁用 UART1

    UART1->UCR1 &= ~UART_UCR1_UARTEN_MASK; 



    /*软件复位*/

    UART1->UCR2 &= ~UART_UCR2_SRST_MASK;

    while ((UART1->UCR2 & UART_UCR2_SRST_MASK) == 0)

    {

    }

  

    /*引脚初始化*/

    IOMUXC_SetPinMux(IOMUXC_UART1_RX_DATA_UART1_RX, 0);     

    IOMUXC_SetPinConfig(IOMUXC_UART1_RX_DATA_UART1_RX, 0x10b0);



    IOMUXC_SetPinMux(IOMUXC_UART1_TX_DATA_UART1_TX, 0);

    IOMUXC_SetPinConfig(IOMUXC_UART1_TX_DATA_UART1_TX, 0x10b0);



    /*******uart初始化******/

    /*设置控制寄存器到默认值*/

    UART1->UCR2 |= (1 << 5);  //8位数宽度

    UART1->UCR2 &= ~(1 << 6); //一位停止位

    UART1->UCR2 &= ~(1 << 8); //禁用奇偶校验位



    UART1->UCR2 |= (1 << 2);  //使能发送

    UART1->UCR2 |= (1 << 1);  //使能接收

    UART1->UCR2 |= (1 << 14); //忽略流控



    /* For imx family device, UARTs are used in  mode, so that this bit should always be set.*/

    UART1->UCR3 |= UART_UCR3_RXDMUXSEL_MASK;



    //UART1->UFCR = (UART1->UFCR & ~UART_UFCR_TXTL_MASK) | UART_UFCR_TXTL(1); //设置发送FIFO 阀值

    //UART1->UFCR = (UART1->UFCR & ~UART_UFCR_TXTL_MASK) | UART_UFCR_TXTL(1); //设置接收FIFO 阀值



    UART1->UCR1 &= ~UART_UCR1_ADBR_MASK; //禁用可变波特率





    /*波特率设置方式 1 。 使用官方SDK设置波特率函数*/

   UART_SetBaudRate(UART1, 115200, 40000000);  //第三个参数是串口的时钟频率

#if 0

    /*波特率设置方式 2 。 手动计算，填入寄存器*/

    /*设置串口波特率

    * Ref Freq时钟 40MHz

    * UFCR RFDIV   110  0x06 7分频    5.714MHz

    * BaudRate     115200bps

    * UBMR         31-1 = 0x09

    * UBIR         10-1 = 0x1E

    */

    UART1->UFCR &= ~(0x07 << 7); //清零分频值

    UART1->UFCR |= (0x06 << 7);  //设置分频值，40MHz /7 =  5.714MHz



    UART1->UBIR = 0x09;

    UART1->UBMR = 0x1E;

#endif

    /*开启串口*/

    UART1->UCR1 |= UART_UCR1_UARTEN_MASK;



}





/*!

 * 功能：官方SDK 串口字符串读取函数

 * @brief Reads the receiver register.

 *

 * This function is used to read data from receiver register.

 * The upper layer must ensure that the receiver register is full or that

 * the RX FIFO has data before calling this function.

 *

 * @param base UART peripheral base address.

 * @return Data read from data register.

 */

static inline uint8_t UART_ReadByte(UART_Type *base)

{

    return (uint8_t)((base->URXD & UART_URXD_RX_DATA_MASK) >> UART_URXD_RX_DATA_SHIFT);

}





/*函数功能：串口接收函数

 *参数： base,指定串口。data,保存接收到的数据。 length，要接收的数据长度

 *

*/

void UART_ReadBlocking(UART_Type *base, uint8_t *data, uint8_t length)

{

    while (length--)

    {

        /* 等待接收完成 */

        while (!(base->USR2 & UART_USR2_RDR_MASK))

        {

        }

        /*读取接收到的数据 */

        *(data++) = UART_ReadByte(base);

    }

}





/*!

 * 功能：官方SDK 串口发送函数

 * 参数：base，指定串口。data，指定要发送的字节

 * This function is used to write data to transmitter register.

 * The upper layer must ensure that the TX register is empty or that

 * the TX FIFO has room before calling this function.

 */

static inline void UART_WriteByte(UART_Type *base, uint8_t data)

{

    base->UTXD = data & UART_UTXD_TX_DATA_MASK;

}



/*

 *功能：官方SDK 串口字符串发送函数

 *参数说明：

*/

void UART_WriteBlocking(UART_Type *base, const uint8_t *data, uint8_t length)

{



    while (length--)

    {

        /* Wait for TX fifo valid.

         * This API can only ensure that the data is written into the data buffer but can't

         * ensure all data in the data buffer are sent into the transmit shift buffer.

         */

        while (!(base->USR2 & UART_USR2_TXDC_MASK))

        {

        }

        UART_WriteByte(base, *(data++));

    }

}



/* 官方SDK 波特率设置函数，

 * 修改内容：修改了函数的返回值，波特率设置成功，返回1 。波特率设置失败返回 0

 *This UART instantiation uses a slightly different baud rate calculation.

 * Baud Rate = Ref Freq / (16 * (UBMR + 1)/(UBIR+1)).

 * To get a baud rate, three register need to be writen, UFCR,UBMR and UBIR

 * At first, find the approximately maximum divisor of src_Clock and baudRate_Bps.

 * If the numerator and denominator are larger then register maximum value(0xFFFF),

 * both of numerator and denominator will be divided by the same value, which

 * will ensure numerator and denominator range from 0~maximum value(0xFFFF).

 * Then calculate UFCR and UBIR value from numerator, and get UBMR value from denominator.

 */

int32_t UART_SetBaudRate(UART_Type *base, uint32_t baudRate_Bps, uint32_t srcClock_Hz)

{

    uint32_t numerator = 0u;

    uint32_t denominator = 0U;

    uint32_t divisor = 0U;

    uint32_t refFreqDiv = 0U;

    uint32_t divider = 1U;

    uint64_t baudDiff = 0U;

    uint64_t tempNumerator = 0U;

    uint32_t tempDenominator = 0u;



    /* get the approximately maximum divisor */

    numerator = srcClock_Hz;

    denominator = baudRate_Bps << 4;

    divisor = 1;



    while (denominator != 0)

    {

        divisor = denominator;

        denominator = numerator % denominator;

        numerator = divisor;

    }



    numerator = srcClock_Hz / divisor;

    denominator = (baudRate_Bps << 4) / divisor;



    /* numerator ranges from 1 ~ 7 * 64k */

    /* denominator ranges from 1 ~ 64k */

    if ((numerator > (UART_UBIR_INC_MASK * 7)) || (denominator > UART_UBIR_INC_MASK))

    {

        uint32_t m = (numerator - 1) / (UART_UBIR_INC_MASK * 7) + 1;

        uint32_t n = (denominator - 1) / UART_UBIR_INC_MASK + 1;

        uint32_t max = m > n ? m : n;

        numerator /= max;

        denominator /= max;

        if (0 == numerator)

        {

            numerator = 1;

        }

        if (0 == denominator)

        {

            denominator = 1;

        }

    }

    divider = (numerator - 1) / UART_UBIR_INC_MASK + 1;



    switch (divider)

    {

        case 1:

            refFreqDiv = 0x05;

            break;

        case 2:

            refFreqDiv = 0x04;

            break;

        case 3:

            refFreqDiv = 0x03;

            break;

        case 4:

            refFreqDiv = 0x02;

            break;

        case 5:

            refFreqDiv = 0x01;

            break;

        case 6:

            refFreqDiv = 0x00;

            break;

        case 7:

            refFreqDiv = 0x06;

            break;

        default:

            refFreqDiv = 0x05;

            break;

    }

    /* Compare the difference between baudRate_Bps and calculated baud rate.

     * Baud Rate = Ref Freq / (16 * (UBMR + 1)/(UBIR+1)).

     * baudDiff = (srcClock_Hz/divider)/( 16 * ((numerator / divider)/ denominator).

     */

    tempNumerator = srcClock_Hz;

    tempDenominator = (numerator << 4);

    divisor = 1;

    /* get the approximately maximum divisor */

    while (tempDenominator != 0)

    {

        divisor = tempDenominator;

        tempDenominator = tempNumerator % tempDenominator;

        tempNumerator = divisor;

    }

    tempNumerator = srcClock_Hz / divisor;

    tempDenominator = (numerator << 4) / divisor;

    baudDiff = (tempNumerator * denominator) / tempDenominator;

    baudDiff = (baudDiff >= baudRate_Bps) ? (baudDiff - baudRate_Bps) : (baudRate_Bps - baudDiff);



    if (baudDiff < (baudRate_Bps / 100) * 3)

    {

        base->UFCR &= ~UART_UFCR_RFDIV_MASK;

        base->UFCR |= UART_UFCR_RFDIV(refFreqDiv);

        base->UBIR = UART_UBIR_INC(denominator - 1);

        base->UBMR = UART_UBMR_MOD(numerator / divider - 1);

        base->ONEMS = UART_ONEMS_ONEMS(srcClock_Hz / (1000 * divider));



        return 1;

    }

    else

    {

        return 0;

    }

}