发新帖我要提问
12
返回列表
打印
[应用方案]

使用新唐NUC120 实现的一个 MODBUS的例程

[复制链接]
楼主: wangjiahao88
手机看帖
扫描二维码
随时随地手机跟帖
21楼
wangjiahao88|  楼主 | 2018-3-7 11:16 | 只看该作者 回帖奖励 |倒序浏览
/********************************************************************************************************//**
* @brief     The function is used to get  compute Baud Setting Value
* @param[in] clk        : Uart Source Clock
* @param[in] baudRate   : User seting BaudRate
* @param[in] UART_BAUD_T *baud  : Get User Settings
* @return    None
************************************************************************************************************/
static void BaudRateCalculator(uint32_t clk, uint32_t baudRate, UART_BAUD_T *baud)
{
    int32_t tmp;
    int32_t div;

    if(((clk / baudRate)%16)<3)       /* Source Clock mod 16 <3 => Using Divider X =16 (MODE#1) */
    {                                 
        PREG32WRITE(baud, DIVX_EN, 0);
        PREG32WRITE(baud, DIVX1, 0);
        tmp = clk / baudRate/16  -2;
    }
    else                              /* Source Clock mod 16 >3 => Up 5% Error BaudRate */
    {
        PREG32WRITE(baud, DIVX_EN, 1);            /* Try to Set Divider X = 1 (MODE#3)*/
        PREG32WRITE(baud, DIVX1, 1);
        tmp = clk / baudRate  -2;

        if(tmp > 0xFFFF)              /* If Divider > Range  */
        {
            PREG32WRITE(baud, DIVX_EN, 1);        /* Try to Set Divider X up 10 (MODE#2) */
            
            for(div = 8; div <16;div++)
            {
                if(((clk / baudRate)%(div+1))<3)
                {
                    PREG32WRITE(baud, DIVX1, div);
                    tmp = clk / baudRate / (div+1) -2;
                    break;
                }
            }
        }
    }

    PREG32WRITE(baud, DIV, tmp);


}


/********************************************************************************************************//**
* @brief     The function is used to get Uart clock
* @param[in] clk          : Uart Source Clock
* @param[in] baudRate     : User seting BaudRate
* @param[in] ART_BAUD_T *baud  : Get User Settings
* @return    Current Uart Clock
************************************************************************************************************/
static uint32_t GetUartCLk(void)
{
    uint32_t clk =0 , div;
                                                    /* Check UART Clock Source Setting */
    if(SYSCLK->CLKSEL1.UART_S == 0)         
    {
        clk = DrvSYS_GetEXTClock() * 1000;          /* Get External Clock From DrvSYS Setting */
    }
    else if(SYSCLK->CLKSEL1.UART_S == 1)
    {
        div = SYSCLK->CLKDIV.UART_N;                /* According PLL Clock and UART_Divider to get clock */
   
        clk = DrvSYS_GetPLLClock() * 1000 / (div+1);
    }
    else
        clk = 22000000;                             /* Clock 22Mhz  */

    return clk;
}



/********************************************************************************************************//**
* @brief     The function is used to set RTS information
* @param[in] Port  :  UART Channel:  UART_PORT0 / UART_PORT1
* @param[in] uint8_t    :   RTS Value
* @return    None
************************************************************************************************************/
void DrvUART_SetRTS(UART_PORT port,uint8_t u8Value)
{
   
    if(port == UART_PORT0)
        REG32WRITE(UART0->MCR, RTS_INV, u8Value);
    else if(port == UART_PORT1)
        REG32WRITE(UART1->MCR, RTS_INV, u8Value);
    else
        return;                                     /* UART2 is not supported RTS */
}   

使用特权

评论回复 赏
22楼
wangjiahao88|  楼主 | 2018-3-7 11:16 | 只看该作者
/********************************************************************************************************//**
* @brief     The function is used to initialize UART
* @param[in] Port : UART Channel:  UART_PORT0 / UART_PORT1 /UART_PORT2
* @param[in] sParam : the struct parameter to configure UART  
*                       include of                                                                     
*                           * u32BaudRate - Baud rate                                                                                      
*                           * u8cParity   - DRVUART_PARITY_NONE / DRVUART_PARITY_EVEN / DRVUART_PARITY_ODD
*                           * u8cDataBits - DRVUART_DATA_BITS_5 / DRVUART_DATA_BITS_6                     
*                                           DRVUART_DATA_BITS_7 / DRVUART_DATA_BITS_8                     
*                           * u8cStopBits - DRVUART_STOPBITS_1 / STOPBITS_1_5 / STOPBITS_2                 
*                           * u8cRxTriggerLevel   - LEVEL_1_BYTE to LEVEL_62_BYTES                        
* @return   
*               E_DRVUART_ERR_PORT_INVALID                                                               
*               E_DRVUART_ERR_PARITY_INVALID                                                              
*               E_DRVUART_ERR_DATA_BITS_INVALID                                                            
*               E_DRVUART_ERR_STOP_BITS_INVALID                                                           
*               E_DRVUART_ERR_TRIGGERLEVEL_INVALID                                                      
*               E_DRVUART_ERR_ALLOC_MEMORY_FAIL                                                           
*               E_SUCCESS                                                                                
************************************************************************************************************/
int32_t DrvUART_Open(UART_PORT port, STR_UART_T *sParam)
{
   
    /********************************************************************************************************//**
     * Check UART port                                                                                    
    ************************************************************************************************************/
    if ((port != UART_PORT0) &&
        (port != UART_PORT1) &&
        (port != UART_PORT2))
    {

        return E_DRVUART_ERR_PORT_INVALID;
    }


    /********************************************************************************************************//**
     * Check the supplied parity                                                                          
    ************************************************************************************************************/
    if ((sParam->u8cParity != DRVUART_PARITY_NONE) &&
        (sParam->u8cParity != DRVUART_PARITY_EVEN) &&
        (sParam->u8cParity != DRVUART_PARITY_ODD)  &&
        (sParam->u8cParity != DRVUART_PARITY_MARK) &&
        (sParam->u8cParity != DRVUART_PARITY_SPACE))
    {
        return E_DRVUART_ERR_PARITY_INVALID;        
    }
    /********************************************************************************************************//**
     * Check the supplied number of data bits                                                              
    ************************************************************************************************************/
    else if ((sParam->u8cDataBits != DRVUART_DATABITS_5) &&
             (sParam->u8cDataBits != DRVUART_DATABITS_6) &&
             (sParam->u8cDataBits != DRVUART_DATABITS_7) &&
             (sParam->u8cDataBits != DRVUART_DATABITS_8))
    {
        return E_DRVUART_ERR_DATA_BITS_INVALID;  
    }
    /********************************************************************************************************//**
     * Check the supplied number of stop bits                                                              
    ************************************************************************************************************/
    else if ((sParam->u8cStopBits != DRVUART_STOPBITS_1) &&
             (sParam->u8cStopBits != DRVUART_STOPBITS_2) &&
             (sParam->u8cStopBits != DRVUART_STOPBITS_1_5)
             )
    {
        return E_DRVUART_ERR_STOP_BITS_INVALID;  
    }


    /********************************************************************************************************//**
     * Check the supplied nember of trigger level bytes                                                   
    ************************************************************************************************************/
    else if ((sParam->u8cRxTriggerLevel != DRVUART_FIFO_1BYTES) &&
             (sParam->u8cRxTriggerLevel != DRVUART_FIFO_4BYTES) &&
             (sParam->u8cRxTriggerLevel != DRVUART_FIFO_8BYTES) &&
             (sParam->u8cRxTriggerLevel != DRVUART_FIFO_14BYTES)&&
             (sParam->u8cRxTriggerLevel != DRVUART_FIFO_30BYTES)&&
             (sParam->u8cRxTriggerLevel != DRVUART_FIFO_46BYTES)&&
             (sParam->u8cRxTriggerLevel != DRVUART_FIFO_62BYTES))
    {
        return E_DRVUART_ERR_TRIGGERLEVEL_INVALID;      
    }               

    if(port == UART_PORT0)
    {
        /* Reset IP */
        REG32WRITE(SYS->IPRSTC2, UART0_RST, 1);
        REG32WRITE(SYS->IPRSTC2, UART0_RST, 0);
        
        /* Enable UART clock */
        REG32WRITE(SYSCLK->APBCLK, UART0_EN, 1);
        
        /* Select UART clock source */
        REG32WRITE(SYSCLK->CLKSEL1, UART_S, 0);
        REG32WRITE(SYSCLK->PWRCON, XTL12M_EN, 1);
        
        /* Select UART clock source */
        REG32WRITE(SYSCLK->CLKSEL1, UART_S, 0);
        
    }
    else if(port == UART_PORT1)
    {
        /* Reset IP */
        REG32WRITE(SYS->IPRSTC2, UART1_RST, 1);
        REG32WRITE(SYS->IPRSTC2, UART1_RST, 0);
        
        /* Enable UART clock */
        REG32WRITE(SYSCLK->APBCLK, UART1_EN, 1);
        REG32WRITE(SYSCLK->PWRCON, XTL12M_EN, 1);
        /* Select UART clock source */
        REG32WRITE(SYSCLK->CLKSEL1, UART_S, 0);
        
    }
    else
    {
        /* Reset IP */
        REG32WRITE(SYS->IPRSTC2, UART2_RST, 1);
        REG32WRITE(SYS->IPRSTC2, UART2_RST, 0);
        
        /* Enable UART clock */
        REG32WRITE(SYSCLK->APBCLK, UART2_EN, 1);
        REG32WRITE(SYSCLK->PWRCON, XTL12M_EN, 1);

        /* Select UART clock source */
        REG32WRITE(SYSCLK->CLKSEL1, UART_S, 0);
   
    }
   
    /* Tx FIFO Reset & Rx FIFO Reset & FIFO Mode Enable */
    if(port == UART_PORT0)  
    {
        REG32WRITE(UART0->FCR, TFR, 1);
        REG32WRITE(UART0->FCR, RFR, 1);
    }
    else if(port == UART_PORT1)
    {
        REG32WRITE(UART1->FCR, TFR, 1);
        REG32WRITE(UART1->FCR, RFR, 1);
    }
    else
    {
        REG32WRITE(UART2->FCR, TFR, 1);
        REG32WRITE(UART2->FCR, RFR, 1);
    }

    if (port == UART_PORT0)
    {
        /* Set Rx Trigger Level */
        REG32WRITE(UART0->FCR, RFITL, sParam->u8cRxTriggerLevel);  
   
        /* Set Parity & Data bits & Stop bits */
        REG32WRITE(UART0->LCR, SPE, ((sParam->u8cParity)&0x4)?1:0);
        REG32WRITE(UART0->LCR, EPE, ((sParam->u8cParity)&0x2)?1:0);
        REG32WRITE(UART0->LCR, PBE, ((sParam->u8cParity)&0x1)?1:0);
        
        REG32WRITE(UART0->LCR, WLS, sParam->u8cDataBits);
        REG32WRITE(UART0->LCR, NSB, sParam->u8cStopBits);
        
        /* Set Time-Out */
        UART0->TOR      =sParam->u8TimeOut;

        /* Set BaudRate */
        BaudRateCalculator(GetUartCLk(), sParam->u32BaudRate, &UART0->BAUD);
    }
    else if(port == UART_PORT1)
    {
        /* Set Rx Trigger Level */
        REG32WRITE(UART1->FCR, RFITL, sParam->u8cRxTriggerLevel);  
   
        /* Set Parity & Data bits & Stop bits */
        REG32WRITE(UART1->LCR, SPE, ((sParam->u8cParity)&0x4)?1:0);
        REG32WRITE(UART1->LCR, EPE, ((sParam->u8cParity)&0x2)?1:0);
        REG32WRITE(UART1->LCR, PBE, ((sParam->u8cParity)&0x1)?1:0);
        
        REG32WRITE(UART1->LCR, WLS, sParam->u8cDataBits);
        REG32WRITE(UART1->LCR, NSB, sParam->u8cStopBits);
        
        /* Set Time-Out */
        UART1->TOR      =sParam->u8TimeOut;
        
        /* Set BaudRate */
        BaudRateCalculator(GetUartCLk(), sParam->u32BaudRate, &UART1->BAUD);
    }
    else
    {
        /* Set Rx Trigger Level */
        REG32WRITE(UART2->FCR, RFITL, sParam->u8cRxTriggerLevel);  
   
        /* Set Parity & Data bits & Stop bits */
        REG32WRITE(UART2->LCR, SPE, ((sParam->u8cParity)&0x4)?1:0);
        REG32WRITE(UART2->LCR, EPE, ((sParam->u8cParity)&0x2)?1:0);
        REG32WRITE(UART2->LCR, PBE, ((sParam->u8cParity)&0x1)?1:0);
        
        REG32WRITE(UART2->LCR, WLS, sParam->u8cDataBits);
        REG32WRITE(UART2->LCR, NSB, sParam->u8cStopBits);
        
        /* Set Time-Out */
        UART2->TOR      =sParam->u8TimeOut;
        
        /* Set BaudRate */
        BaudRateCalculator(GetUartCLk(), sParam->u32BaudRate, &UART2->BAUD);
    }
   
    return E_SUCCESS;
}

使用特权

评论回复 赏
23楼
wangjiahao88|  楼主 | 2018-3-7 11:17 | 只看该作者
/********************************************************************************************************//**
* @brief     The function is used disable UART clock, disable ISR and close UART function.
* @param[in] Port  : UART Channel:  UART_PORT0 / UART_PORT1
* @return    None
************************************************************************************************************/

void DrvUART_Close(UART_PORT Port)
{
    if(Port == UART_PORT1)  
    {
        while(!UART1->FSR.TX_EMPTY);
        
        REG32WRITE(SYSCLK->APBCLK, UART1_EN, 0);
        REG32WRITE(SYSCLK->APBCLK, UART1_EN, 0);
        g_pfnUART1callback = NULL;
        NVIC_DisableIRQ (UART1_IRQn);
    }
    else if(Port == UART_PORT2)
    {
        while(!UART2->FSR.TX_EMPTY);
        
        REG32WRITE(SYSCLK->APBCLK, UART2_EN, 0);
        REG32WRITE(SYSCLK->APBCLK, UART2_EN, 0);
        g_pfnUART2callback = NULL;
        NVIC_DisableIRQ (UART0_IRQn);
    }
    else
    {
        while(!UART0->FSR.TX_EMPTY);
        REG32WRITE(SYSCLK->APBCLK, UART0_EN, 0);
        g_pfnUART0callback = NULL;
        NVIC_DisableIRQ(UART0_IRQn);      
    }
}



/********************************************************************************************************//**
* @brief     The function is used to enable UART Interrupt and Install the call back function
* @param[in] Port  : UART Channel:  UART_PORT0 / UART_PORT1
* @param[in] u32InterruptFlag: DRVUART_LININT/DRVUART_WAKEUPINT/DRVUART_BUFERRINT/DRVUART_RLSNT
*                         DRVUART_MOSINT/DRVUART_THREINT/DRVUART_RDAINT/DRVUART_TOUTINT
* @param[in] pfncallback   : A function pointer for callback function
* @return   
************************************************************************************************************/
int32_t DrvUART_EnableInt(UART_PORT port, uint32_t  u32InterruptFlag, PFN_DRVUART_CALLBACK pfncallback)
{
    if((port != UART_PORT0) && (port != UART_PORT1)&& (port != UART_PORT2))
    {
        return E_DRVUART_ARGUMENT;
    }

    if(port == UART_PORT0)                                              /* Set Specified Interrupt */
    {
        REG32WRITE(UART0->IER, RDA_IEN, (u32InterruptFlag & DRVUART_RDAINT)?1:0 );
        REG32WRITE(UART0->IER, THRE_IEN, (u32InterruptFlag & DRVUART_THREINT)?1:0);
        REG32WRITE(UART0->IER, RLS_IEN, (u32InterruptFlag & DRVUART_RLSNT)?1:0);
        REG32WRITE(UART0->IER, MS_IEN, (u32InterruptFlag & DRVUART_MOSINT)?1:0);
        
        REG32WRITE(UART0->IER, TOC_EN, (u32InterruptFlag & DRVUART_TOUTINT)?1:0);     /* Time-out count enable */
        REG32WRITE(UART0->IER, RTO_IEN, (u32InterruptFlag & DRVUART_TOUTINT)?1:0);     /* Time-out INT enable */

        REG32WRITE(UART0->IER, BUF_ERR_IEN, (u32InterruptFlag & DRVUART_BUFERRINT)?1:0);
        REG32WRITE(UART0->IER, WAKE_IEN, (u32InterruptFlag & DRVUART_WAKEUPINT)?1:0);
        REG32WRITE(UART0->IER, LIN_RX_BRK_IEN, (u32InterruptFlag & DRVUART_LININT)?1:0);

    }
    else if(port == UART_PORT1)
    {
        REG32WRITE(UART1->IER, RDA_IEN, (u32InterruptFlag & DRVUART_RDAINT)?1:0 );
        REG32WRITE(UART1->IER, THRE_IEN, (u32InterruptFlag & DRVUART_THREINT)?1:0);
        REG32WRITE(UART1->IER, RLS_IEN, (u32InterruptFlag & DRVUART_RLSNT)?1:0);
        REG32WRITE(UART1->IER, MS_IEN, (u32InterruptFlag & DRVUART_MOSINT)?1:0);
        
        REG32WRITE(UART1->IER, TOC_EN, (u32InterruptFlag & DRVUART_TOUTINT)?1:0);     /* Time-out count enable */
        REG32WRITE(UART1->IER, RTO_IEN, (u32InterruptFlag & DRVUART_TOUTINT)?1:0);     /* Time-out INT enable */

        REG32WRITE(UART1->IER, BUF_ERR_IEN, (u32InterruptFlag & DRVUART_BUFERRINT)?1:0);
        REG32WRITE(UART1->IER, WAKE_IEN, (u32InterruptFlag & DRVUART_WAKEUPINT)?1:0);
        REG32WRITE(UART1->IER, LIN_RX_BRK_IEN, (u32InterruptFlag & DRVUART_LININT)?1:0);
    }
    else
    {
        REG32WRITE(UART2->IER, RDA_IEN, (u32InterruptFlag & DRVUART_RDAINT)?1:0 );
        REG32WRITE(UART2->IER, THRE_IEN, (u32InterruptFlag & DRVUART_THREINT)?1:0);
        REG32WRITE(UART2->IER, RLS_IEN, (u32InterruptFlag & DRVUART_RLSNT)?1:0);
        REG32WRITE(UART2->IER, MS_IEN, (u32InterruptFlag & DRVUART_MOSINT)?1:0);
        
        REG32WRITE(UART2->IER, TOC_EN, (u32InterruptFlag & DRVUART_TOUTINT)?1:0);     /* Time-out count enable */
        REG32WRITE(UART2->IER, RTO_IEN, (u32InterruptFlag & DRVUART_TOUTINT)?1:0);     /* Time-out INT enable */

        REG32WRITE(UART2->IER, BUF_ERR_IEN, (u32InterruptFlag & DRVUART_BUFERRINT)?1:0);
        REG32WRITE(UART2->IER, WAKE_IEN, (u32InterruptFlag & DRVUART_WAKEUPINT)?1:0);
        REG32WRITE(UART2->IER, LIN_RX_BRK_IEN, (u32InterruptFlag & DRVUART_LININT)?1:0);
    }

    if(port == UART_PORT0)                                              /* Install Callback function */
    {
        g_pfnUART0callback = pfncallback;        
        NVIC_EnableIRQ(UART0_IRQn);
    }
    else if(port == UART_PORT1)                                         /* Install Callback function */
    {
        g_pfnUART1callback = pfncallback;
        NVIC_EnableIRQ(UART1_IRQn);
    }
    else                                                                /* Install Callback function */
    {
        g_pfnUART2callback = pfncallback;
        NVIC_EnableIRQ(UART0_IRQn);
    }


    return E_SUCCESS;

}

                                                                  
/********************************************************************************************************//**
* @brief     The function is used to get the interrupt enable status
* @param[in] Port  : UART Channel:  UART_PORT0 / UART_PORT1
* @param[in] u32InterruptFlag: DRVUART_LININT/DRVUART_WAKEUPINT/DRVUART_BUFERRINT/DRVUART_RLSNT
*                         DRVUART_MOSINT/DRVUART_THREINT/DRVUART_RDAINT/DRVUART_TOUTINT
* @return    Specified Interrupt Flag Set or clear
************************************************************************************************************/
uint32_t DrvUART_IsIntEnabled(UART_PORT u16Port,uint32_t u32InterruptFlag)
{
    if(u16Port == UART_PORT0)                   /* Read IER Register and check specified flag is enable */
        return ((inpw(&UART0->IER) &
         (u32InterruptFlag & (DRVUART_LININT | DRVUART_WAKEUPINT | DRVUART_BUFERRINT |
                DRVUART_TOUTINT | DRVUART_MOSINT | DRVUART_RLSNT | DRVUART_THREINT | DRVUART_RDAINT))))?1:0;
    else if(u16Port == UART_PORT1)
        return ((inpw(&UART1->IER) &
        (u32InterruptFlag & (DRVUART_LININT | DRVUART_WAKEUPINT | DRVUART_BUFERRINT |
                DRVUART_TOUTINT | DRVUART_MOSINT | DRVUART_RLSNT | DRVUART_THREINT | DRVUART_RDAINT))))?1:0;
    else
        return ((inpw(&UART2->IER) &
        (u32InterruptFlag & (DRVUART_LININT | DRVUART_WAKEUPINT | DRVUART_BUFERRINT |
                DRVUART_TOUTINT | DRVUART_MOSINT | DRVUART_RLSNT | DRVUART_THREINT | DRVUART_RDAINT))))?1:0;


}


/********************************************************************************************************//**
* @brief     The function is used to disable UART Interrupt and uninstall the call back function
* @param[in] Port  :] UART Channel:  UART_PORT0 / UART_PORT1 /  UART_PORT2
* @param[in] u32InterruptFlag: DRVUART_LININT/DRVUART_WAKEUPINT/DRVUART_BUFERRINT/DRVUART_RLSNT
*                         DRVUART_MOSINT/DRVUART_THREINT/DRVUART_RDAINT/DRVUART_TOUTINT
* @return    None
************************************************************************************************************/
void DrvUART_DisableInt(UART_PORT u16Port,uint32_t u32InterruptFlag)
{
    if(u16Port == UART_PORT0)              
    {
        outpw(&UART0->IER + u16Port,inpw(&UART0->IER + u16Port) &~u32InterruptFlag);       /* Disable INT  */
    }
   
    if(u32InterruptFlag & DRVUART_TOUTINT)                                       /* Disable Counter Enable */
    {
        if(u16Port == DRVUART_PORT0)
            REG32WRITE(UART0->IER, RTO_IEN, 0);
        else
            REG32WRITE(UART1->IER, RTO_IEN, 0);
    }
   
    switch (u16Port)                                                 /* Disable Callback function and NVIC */
    {
        case UART_PORT0:
            g_pfnUART0callback = NULL;
            NVIC_DisableIRQ(UART0_IRQn);   
            break;

        case UART_PORT1:
            g_pfnUART1callback = NULL;
            NVIC_DisableIRQ(UART1_IRQn);   
            break;
        
        case UART_PORT2:
            g_pfnUART2callback = NULL;
            NVIC_DisableIRQ(UART0_IRQn);   
            break;

        default:
            break;
    }

}


/********************************************************************************************************//**
* @brief     The function is used to clear UART Interrupt
* @param[in]            u16Por             :  UART Channel:  UART_PORT0 / UART_PORT1  /UART_PORT2         
* @param[in]    u32InterruptFlag   :   DRVUART_MOSINT/DRVUART_RLSNT/DRVUART_THREINT                    
*                                            DRVUART_RDAINT/DRVUART_TOUTINT                                
* @return    None
************************************************************************************************************/
uint32_t DrvUART_ClearInt(UART_PORT u16Port,uint32_t u32InterruptFlag)
{
    if((u32InterruptFlag & DRVUART_RDAINT) == DRVUART_RDAINT)               /* clear Rx read Interrupt */      
        inpw(&UART0->DATA + u16Port);

    if((u32InterruptFlag & DRVUART_RLSNT) == DRVUART_RLSNT)                 /* clear Receive Line Status Interrupt */      
        outpw(&UART0->FSR + u16Port , inpw(&UART0->FSR + u16Port) | 0x70);
   
    if((u32InterruptFlag & DRVUART_MOSINT) == DRVUART_MOSINT)               /* clear Modem Interrupt */   
        outpw(&UART0->MSR + u16Port,inpw(&UART0->MSR + u16Port) | 0x1);   

    if((u32InterruptFlag & DRVUART_TOUTINT) == DRVUART_TOUTINT)             /* clear Time-out Interrupt */     
    {
        inpw(&UART0->DATA + u16Port);
    }

    return E_SUCCESS;


}   


/********************************************************************************************************//**
* @brief     The function is used to get the interrupt  status
* @param[in]            u16Por             :  UART Channel:  UART_PORT0 / UART_PORT1         
* @param[in]    u32InterruptFlag   :   DRVUART_MOSINT/DRVUART_RLSNT/DRVUART_THREINT                    
*                                            DRVUART_RDAINT/DRVUART_TOUTINT
* @return   
*               0: None                                                                                 
*               1: Interrupt occurs                                                                        
************************************************************************************************************/
int8_t DrvUART_GetIntStatus(UART_PORT u16Port,uint32_t u32InterruptFlag)
{
   
    switch(u32InterruptFlag)
    {
        case DRVUART_MOSINT:                    /* MODEM Status Interrupt */
                return (inpw(&UART0->ISR + u16Port) & DRVUART_MOSINT)?TRUE:FALSE;
        
        case DRVUART_RLSNT:                     /* Receive Line Status Interrupt */
                return (inpw(&UART0->ISR + u16Port) & DRVUART_RLSNT)?TRUE:FALSE;

        case DRVUART_THREINT:                   /* Transmit Holding Register Empty Interrupt */
                return (inpw(&UART0->ISR + u16Port) & DRVUART_THREINT)?TRUE:FALSE;

        case DRVUART_RDAINT:                    /* Receive Data Available Interrupt */
                return (inpw(&UART0->ISR + u16Port) & DRVUART_RDAINT)?TRUE:FALSE;

        case DRVUART_TOUTINT:                   /* Time-out Interrupt */
                return (inpw(&UART0->ISR + u16Port) & DRVUART_TOUTINT)?TRUE:FALSE;

        default:
            return FALSE;
    }
   
}


/********************************************************************************************************//**
* @brief     The function is used to set Rx FIFO Trigger Level
* @param[in] u16Port    :   UART Channel:  UART_PORT0 / UART_PORT1 / UART_PORT2
* @param[in] 32TriggerLevel :   FIFO Trigger Level :LEVEL_1_BYTE to LEVEL_62_BYTES
* @return    None
************************************************************************************************************/
void DrvUART_SetFIFOTriggerLevel(UART_PORT  u16Port,uint16_t u32TriggerLevel)
{
    if(u16Port == UART_PORT0)
        REG32WRITE(UART0->FCR, RFITL, u32TriggerLevel);

    else if(u16Port == UART_PORT1)
        REG32WRITE(UART1->FCR, RFITL, u32TriggerLevel);
    else
        REG32WRITE(UART2->FCR, RFITL, u32TriggerLevel);
        
}



/********************************************************************************************************//**
* @brief     The function is used to get CTS value and change state
* @param[in] UART_PORT         :   UART Channel:  UART_PORT0 / UART_PORT1
* @param[in] pu8CTSValue           :   Buffer to store the CTS Value
* @param[in] pu8CTSChangeState  :   Buffer to store the CTS Change State
* @return    None
************************************************************************************************************/
void DrvUART_GetCTS(UART_PORT u16Port,uint8_t *pu8CTSValue, uint8_t *pu8CTSChangeState)
{
    if(u16Port == UART_PORT0)
    {
        *pu8CTSValue        = UART0->MSR.CTS;
        *pu8CTSChangeState  = UART0->MSR.DCTS;
    }
    else if(u16Port == UART_PORT1)
    {
        *pu8CTSValue        = UART1->MSR.CTS;
        *pu8CTSChangeState  = UART1->MSR.DCTS;  
    }
    else
        return;   /* CTS */
}   

/********************************************************************************************************//**
* @brief     The function is used to set Rx Time Out Value
* @param[in] u16Port        :   UART Channel:  UART_PORT0 / UART_PORT1  / UART_PORT2
* @param[in] u8TimeOut    :   Time out value
* @return    None
************************************************************************************************************/
void DrvUART_SetRxTimeOut(UART_PORT u16Port, uint8_t u8TimeOut)
{
    if(u16Port == UART_PORT0)
    {
        UART0->TOR = u8TimeOut;                         /* Set Time out value */
        REG32WRITE(UART0->IER, TOC_EN, 1);       /* Enable Time-out count  */
    }
    else if(u16Port == UART_PORT1)
    {
        UART1->TOR = u8TimeOut;
        REG32WRITE(UART1->IER, TOC_EN, 1);
    }
    else
    {
        UART2->TOR = u8TimeOut;
        REG32WRITE(UART2->IER, TOC_EN, 1);
    }
}   


/********************************************************************************************************//**
* @brief     The function is used to read Rx data from RX buffer
* @param[in] u16Port      :   UART Channel:  UART_PORT0 / UART_PORT1  / UART_PORT2
* @param[in] pu8RxBuf   :   Specify the buffer to receive the data of receive FIFO
* @param[in] u32ReadBytes          :  Specify the bytes number of data.
* @return    E_SUCCESS
************************************************************************************************************/
int32_t DrvUART_Read(UART_PORT  u16Port,uint8_t *pu8RxBuf, uint32_t u32ReadBytes)
{
    uint32_t  u32Count, u32delayno;
   
    if(u16Port == UART_PORT0)
    {
        for (u32Count=0; u32Count < u32ReadBytes; u32Count++)
        {
             u32delayno = 0;
             while (UART0->FSR.RX_EMPTY ==1)                      /* Check RX empty => failed */      
             {
                 u32delayno++;        
                 if ( u32delayno >= 0x40000000 )        
                    return E_DRVUART_ERR_TIMEOUT;               
                    
             }
             pu8RxBuf[u32Count] = UART0->DATA;                    /* Get Data from UART RX  */
        }
    }
    else if(u16Port == UART_PORT1)   
    {
        for (u32Count=0; u32Count < u32ReadBytes; u32Count++)
        {
             u32delayno = 0;
             while (UART1->FSR.RX_EMPTY ==1)
             {
                 u32delayno++;        
                 if ( u32delayno >= 0x40000000 )        
                    return E_DRVUART_ERR_TIMEOUT;               
                    
             }
             pu8RxBuf[u32Count] = UART1->DATA;
        }
   
    }
    else
    {
        for (u32Count=0; u32Count < u32ReadBytes; u32Count++)
        {
             u32delayno = 0;
             while (UART2->FSR.RX_EMPTY ==1)
             {
                 u32delayno++;        
                 if ( u32delayno >= 0x40000000 )        
                    return E_DRVUART_ERR_TIMEOUT;               
                    
             }
             pu8RxBuf[u32Count] = UART2->DATA;
        }
   
    }
    return E_SUCCESS;
   
}



/********************************************************************************************************//**
* @brief     The function is to write data to TX buffer to transmit data by uart
* @param[in] u16Port      :   UART Channel:  UART_PORT0 / UART_PORT1  / UART_PORT2
* @param[in] pu8RxBuf   :   Specify the buffer to send the data of receive FIFO
* @param[in] u32ReadBytes          :  Specify the bytes number of data.
* @return    E_SUCCESS
************************************************************************************************************/
int32_t DrvUART_Write(UART_PORT u16Port,uint8_t *pu8TxBuf,  uint32_t u32WriteBytes)
{
    uint32_t  u32Count, u32delayno;
   
    if(u16Port == UART_PORT0)
    {
        for (u32Count=0; u32Count<u32WriteBytes; u32Count++)
        {
           u32delayno = 0;
           while (UART0->FSR.TX_EMPTY !=1)                          /* Wait Tx empty and Time-out manner */
           {
                u32delayno++;
                if ( u32delayno >= 0x40000000 )            
                   return E_DRVUART_ERR_TIMEOUT;               
                  
           }
           UART0->DATA = pu8TxBuf[u32Count];                        /* Send UART Data from buffer */
        }
    }
    else if(u16Port == UART_PORT1)
    {
        for (u32Count=0; u32Count<u32WriteBytes; u32Count++)
        {
           u32delayno = 0;
        
           while (UART1->FSR.TX_EMPTY !=1)
           {
                u32delayno++;
                if ( u32delayno >= 0x40000000 )            
                   return E_DRVUART_ERR_TIMEOUT;               
           }
           
           UART1->DATA = pu8TxBuf[u32Count];                        /* Send UART Data from buffer */
        }
   
    }
    else
    {
        for (u32Count=0; u32Count<u32WriteBytes; u32Count++)
        {
           u32delayno = 0;
        
           while (UART2->FSR.TX_EMPTY !=1)
           {
                u32delayno++;
                if ( u32delayno >= 0x40000000 )            
                   return E_DRVUART_ERR_TIMEOUT;               
           }
           
           UART2->DATA = pu8TxBuf[u32Count];                        /* Send UART Data from buffer */
        }
   
    }
    return E_SUCCESS;
   
  
}


/********************************************************************************************************//**
* @brief     he function is to Set IRCR Control Register
* @param[in] u16Port    :   UART Channel:  UART_PORT0 / UART_PORT1 /UART_PORT2
* @param[in] STR_IRCR_T   :  Ther stucture of IRCR                                       
*                              It includes of                                               
*                              u8cTXSelect: Tx select TRUE or FALSE                     
*                              u8cRXSelect: Rx select TRUE or FALSE                     
*                              u8cInvTX: Inverse TX signal                              
*                              u8cInvRX: Inverse RX signal                              
* @return    E_SUCCESS
************************************************************************************************************/
void DrvUART_OpenIRCR(UART_PORT u16Port,STR_IRCR_T str_IRCR )
{
    if(u16Port == UART_PORT0)
    {
        REG32WRITE(UART0->FUNSEL, LIN_EN, 0);
        REG32WRITE(UART0->FUNSEL, IrDA_EN, 1);  
        REG32WRITE(UART0->IRCR, RX_EN, str_IRCR.u8cRXSelect);
        REG32WRITE(UART0->IRCR, TX_EN, str_IRCR.u8cTXSelect);
        REG32WRITE(UART0->IRCR, TX_INV_EN, str_IRCR.u8cInvTX);
        REG32WRITE(UART0->IRCR, RX_INV_EN, str_IRCR.u8cInvRX);
        
    }
    else if(u16Port == UART_PORT1)
    {
        REG32WRITE(UART1->FUNSEL, LIN_EN, 0);
        REG32WRITE(UART1->FUNSEL, IrDA_EN, 1);  
        REG32WRITE(UART1->IRCR, RX_EN, str_IRCR.u8cRXSelect);
        REG32WRITE(UART1->IRCR, TX_EN, str_IRCR.u8cTXSelect);
        REG32WRITE(UART1->IRCR, TX_INV_EN, str_IRCR.u8cInvTX);
        REG32WRITE(UART1->IRCR, RX_INV_EN, str_IRCR.u8cInvRX);      
    }

    else
    {
        REG32WRITE(UART2->FUNSEL, LIN_EN,0);
        REG32WRITE(UART2->FUNSEL, IrDA_EN , 1);  
        REG32WRITE(UART2->IRCR, RX_EN, str_IRCR.u8cRXSelect);
        REG32WRITE(UART2->IRCR, TX_EN, str_IRCR.u8cTXSelect);
        REG32WRITE(UART2->IRCR, TX_INV_EN, str_IRCR.u8cInvTX);
        REG32WRITE(UART2->IRCR, RX_INV_EN, str_IRCR.u8cInvRX);      
    }
}


/********************************************************************************************************//**
* @brief     The function is used to set LIN relative setting
* @param[in] u16Port    :  UART Channel:  UART_PORT0 / UART_PORT1  /UART_PORT2
* @param[in] DIRECTION   :  MODE_TX or MODE_RX
* @param[in] BCNT     :  Break Count
* @return    E_SUCCESS
************************************************************************************************************/
void DrvUART_OpenLIN(UART_PORT u16Port,uint16_t DIRECTION,uint16_t BCNT)
{

    if(u16Port == UART_PORT0)
    {
        REG32WRITE(UART0->FUNSEL, LIN_EN, 1);
        REG32WRITE(UART0->FUNSEL, IrDA_EN, 0);  
        if(DIRECTION ==MODE_TX )
        {
            REG32WRITE(UART0->LINCON, LINTX_EN, 1);
            REG32WRITE(UART0->LINCON, LINRX_EN, 0);
        }else
        {
            REG32WRITE(UART0->LINCON, LINTX_EN, 0);
            REG32WRITE(UART0->LINCON, LINRX_EN, 1);      
        }
        REG32WRITE(UART0->LINCON, LINBCNT, BCNT);
    }
    else if(u16Port == UART_PORT1)
    {
        REG32WRITE(UART1->FUNSEL, LIN_EN, 1);
        REG32WRITE(UART1->FUNSEL, IrDA_EN, 0);  
        if(DIRECTION ==MODE_TX )
        {
            REG32WRITE(UART1->LINCON, LINTX_EN, 1);
            REG32WRITE(UART1->LINCON, LINRX_EN, 0);
        }else
        {
            REG32WRITE(UART1->LINCON, LINTX_EN, 0);
            REG32WRITE(UART1->LINCON, LINRX_EN, 1);      
        }
        REG32WRITE(UART1->LINCON, LINBCNT, BCNT);
    }
    else if(u16Port == UART_PORT2)
    {
        REG32WRITE(UART2->FUNSEL, LIN_EN, 1);
        REG32WRITE(UART2->FUNSEL, IrDA_EN, 0);  
        if(DIRECTION ==MODE_TX )
        {
            REG32WRITE(UART2->LINCON, LINTX_EN, 1);
            REG32WRITE(UART2->LINCON, LINRX_EN, 0);
        }else
        {
            REG32WRITE(UART2->LINCON, LINTX_EN, 0);
            REG32WRITE(UART2->LINCON, LINRX_EN, 1);      
        }
    }



}

/********************************************************************************************************//**
* @brief     This function returns TRUE  when UART get any character.Default use UART0
* @param[in] None
* @return    None
************************************************************************************************************/
int32_t DrvUART_kbhit(void)
{
   
    if(UART0->ISR.RDA_IF ==1)
    {
        return TRUE;
    }

    return FALSE;
}


/********************************************************************************************************//**
* @brief     The function is to Enable/Disable PDMA Channel
* @param[in] u16Port     :  UART Channel:  UART_PORT0 / UART_PORT0
* @param[in] IsEnable  :     Enable TX/RX PDMA TRUE or FASLE
* @return     E_SUCCESS
************************************************************************************************************/
void DrvUART_SetPDMA(UART_PORT u16Port,uint16_t IsEnable)
{
   
    if(u16Port == UART_PORT0)
    {
        REG32WRITE(UART0->IER, DMA_TX_EN, IsEnable ?1:0);
        REG32WRITE(UART0->IER ,DMA_RX_EN, IsEnable ?1:0);   
    }
    else if(u16Port == UART_PORT1)
    {
        REG32WRITE(UART1->IER, DMA_TX_EN, IsEnable ?1:0);
        REG32WRITE(UART1->IER, DMA_RX_EN, IsEnable ?1:0);
    }
    else
        return;                 /* UART2 can not support PDMA mode */
}

/********************************************************************************************************//**
* @brief     The function is used to get  DrvUART Version Number
* @param[in] None
* @return    Version Number
************************************************************************************************************/
int32_t DrvUART_GetVersion(void)
{
    return DRVUART_VERSION_NUM;
   
}

使用特权

评论回复 赏
24楼
wangjiahao88|  楼主 | 2018-3-7 11:17 | 只看该作者
不管怎么说 之前的 A B C 版本 或多或少 存在一些bug或者 不太方便的地方。。。

到后来 新唐的库更新了 使用起来 也越来越方便了！

使用特权

评论回复 赏
25楼
dongnanxibei| | 2018-3-8 16:00 | 只看该作者
这个协议还没用过呢

使用特权

评论回复 赏
26楼
wangjiahao88|  楼主 | 2018-3-12 13:25 | 只看该作者
MODBUS 调试利器啊！

使用特权

评论回复 赏
12
返回列表
发新帖 我要提问
高级模式
B Color Image Link Quote Code 收费 Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则