lib_at91r40008.h

ARM入门的好帮手.包含了从简单到相对较复杂的程序.

//* \brief Disable a PIO pin IT
//*----------------------------------------------------------------------------
__inline void AT91F_PIO_DisableIt (
        AT91PS_PIO pPio,   // \arg  pointer to a PIO controller
        unsigned int pin)   // \arg IT to be disabled
{
        //* Write to the IDR register
        pPio->PIO_IDR = pin;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PIO_PioPinItStatus
//* \brief Return the PIO pin IT Enabled
//*----------------------------------------------------------------------------
__inline unsigned int AT91F_PIO_PioPinItStatus (
        AT91PS_PIO pPio)   // \arg  pointer to a PIO controller
{
        //* Read to the PIO_IMR
        return (pPio->PIO_IMR) ;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PIO_IsPioPinItPending
//* \brief Test if one or more PIO pin IT are pending
//*----------------------------------------------------------------------------
__inline unsigned int  AT91F_PIO_IsPioPinItPending (
        AT91PS_PIO pPio)   // \arg  pointer to a PIO controller
{
        return (pPio->PIO_ISR);
}
/* *****************************************************************************
                SOFTWARE API FOR USART
   ***************************************************************************** */
//* Standard Asynchronous Mode : 8 bits , 1 stop , no parity
#define AT91C_US_ASYNC_MODE ( AT91C_US_CHMODE_NORMAL + \
                        AT91C_US_NBSTOP_1_BIT + \
                        AT91C_US_PAR_NONE + \
                        AT91C_US_CHRL_8_BITS + \
                        AT91C_US_CLKS_CLOCK )

//* Standard External Asynchronous Mode : 8 bits , 1 stop , no parity
#define AT91C_US_ASYNC_SCK_MODE ( AT91C_US_CHMODE_NORMAL + \
                            AT91C_US_NBSTOP_1_BIT + \
                            AT91C_US_PAR_NONE + \
                            AT91C_US_CHRL_8_BITS + \
                            AT91C_US_CLKS_EXT )

//* Standard Synchronous Mode : 8 bits , 1 stop , no parity
#define AT91C_US_SYNC_MODE ( AT91C_US_SYNC + \
                       AT91C_US_CHMODE_NORMAL + \
                       AT91C_US_NBSTOP_1_BIT + \
                       AT91C_US_PAR_NONE + \
                       AT91C_US_CHRL_8_BITS + \
                       AT91C_US_CLKS_CLOCK )

//* SCK used Label
#define AT91C_US_SCK_USED (AT91C_US_CKLO | AT91C_US_CLKS_EXT)

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_Baudrate
//* \brief Caluculate baud_value according to the main clock and the baud rate
//*----------------------------------------------------------------------------
__inline unsigned int AT91F_US_Baudrate (
        const unsigned int main_clock, // \arg Master Clock
        const unsigned int baud_rate)  // \arg Desired UART baudrate
{
        unsigned int baud_value = ((main_clock*10)/(baud_rate * 16));
        if ((baud_value % 10) >= 5)
                baud_value = (baud_value / 10) + 1;
        else
                baud_value /= 10;
        return baud_value;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_SetBaudrate
//* \brief Set the baudrate according to the CPU clock
//*----------------------------------------------------------------------------
__inline void AT91F_US_SetBaudrate (
        AT91PS_USART pUSART,    // \arg pointer to a USART controller
        unsigned int mainClock, // \arg Master Clock
        unsigned int speed)     // \arg UART baudrate to be programmed
{
        //* Define the baud rate divisor register
        pUSART->US_BRGR = AT91F_US_Baudrate(mainClock, speed);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_SetTimeguard
//* \brief Set USART timeguard
//*----------------------------------------------------------------------------
__inline void AT91F_US_SetTimeguard (
        AT91PS_USART pUSART,    // \arg pointer to a USART controller
        unsigned int timeguard) // \arg timeguard value
{
        //* Write the Timeguard Register
        pUSART->US_TTGR = timeguard ;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_EnableIt
//* \brief Enable USART IT
//*----------------------------------------------------------------------------
__inline void AT91F_US_EnableIt (
        AT91PS_USART pUSART, // \arg pointer to a USART controller
        unsigned int flag)   // \arg IT to be enabled
{
        //* Write to the IER register
        pUSART->US_IER = flag;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_DisableIt
//* \brief Disable USART IT
//*----------------------------------------------------------------------------
__inline void AT91F_US_DisableIt (
        AT91PS_USART pUSART, // \arg pointer to a USART controller
        unsigned int flag)   // \arg IT to be disabled
{
        //* Write to the IER register
        pUSART->US_IDR = flag;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_Configure
//* \brief Configure USART
//*----------------------------------------------------------------------------
__inline void AT91F_US_Configure (
        AT91PS_USART pUSART,     // \arg pointer to a USART controller
        unsigned int mainClock,  // \arg peripheral clock
        unsigned int mode ,      // \arg mode Register to be programmed
        unsigned int baudRate ,  // \arg baudrate to be programmed
        unsigned int timeguard ) // \arg timeguard to be programmed
{
    //* Disable interrupts
    pUSART->US_IDR = (unsigned int) -1;

    //* Reset receiver and transmitter
    pUSART->US_CR = AT91C_US_RSTRX | AT91C_US_RSTTX | AT91C_US_RXDIS | AT91C_US_TXDIS ;

        //* Define the baud rate divisor register
        AT91F_US_SetBaudrate(pUSART, mainClock, baudRate);

        //* Write the Timeguard Register
        AT91F_US_SetTimeguard(pUSART, timeguard);

        //* Define the USART mode
        pUSART->US_MR = mode  ;

}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_SetControlRegister
//* \brief Save and Set USART's Control Register
//*----------------------------------------------------------------------------
__inline void AT91F_US_SetControlRegister (
        AT91PS_USART pUSART,     // \arg pointer to a USART controller
        unsigned int control_mode )      // \arg control Register to be programmed
{
        //* Define the USART's Control Mode
        pUSART->US_CR |= control_mode ;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_GetChannelStatus
//* \brief Return the Status of a USART Channel
//*----------------------------------------------------------------------------
__inline unsigned int AT91F_US_GetChannelStatus (
        AT91PS_USART pUSART )     // \arg pointer to a USART controller
{
    return (pUSART->US_CSR);
}


//*----------------------------------------------------------------------------
//* \fn    AT91F_US_EnableRx
//* \brief Enable receiving characters
//*----------------------------------------------------------------------------
__inline void AT91F_US_EnableRx (
        AT91PS_USART pUSART)     // \arg pointer to a USART controller
{
    //* Enable receiver
    pUSART->US_CR = AT91C_US_RXEN;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_EnableTx
//* \brief Enable sending characters
//*----------------------------------------------------------------------------
__inline void AT91F_US_EnableTx (
        AT91PS_USART pUSART)     // \arg pointer to a USART controller
{
    //* Enable  transmitter
    pUSART->US_CR = AT91C_US_TXEN;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_ResetRx
//* \brief Reset Receiver and re-enable it
//*----------------------------------------------------------------------------
__inline void AT91F_US_ResetRx (
        AT91PS_USART pUSART)     // \arg pointer to a USART controller
{
        //* Reset receiver
        pUSART->US_CR = AT91C_US_RSTRX;
    //* Re-Enable receiver
    pUSART->US_CR = AT91C_US_RXEN;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_ResetTx
//* \brief Reset Transmitter and re-enable it
//*----------------------------------------------------------------------------
__inline void AT91F_US_ResetTx (
        AT91PS_USART pUSART)     // \arg pointer to a USART controller
{
        //* Reset transmitter
        pUSART->US_CR = AT91C_US_RSTTX;
    //* Enable transmitter
    pUSART->US_CR = AT91C_US_TXEN;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_DisableRx
//* \brief Disable Receiver
//*----------------------------------------------------------------------------
__inline void AT91F_US_DisableRx (
        AT91PS_USART pUSART)     // \arg pointer to a USART controller
{
    //* Disable receiver
    pUSART->US_CR = AT91C_US_RXDIS;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_DisableTx
//* \brief Disable Transmitter
//*----------------------------------------------------------------------------
__inline void AT91F_US_DisableTx (
        AT91PS_USART pUSART)     // \arg pointer to a USART controller
{
    //* Disable transmitter
    pUSART->US_CR = AT91C_US_TXDIS;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_Close
//* \brief Close USART: disable IT disable receiver and transmitter, close PDC
//*----------------------------------------------------------------------------
__inline void AT91F_US_Close (
        AT91PS_USART pUSART)     // \arg pointer to a USART controller
{
    //* Reset the baud rate divisor register
    pUSART->US_BRGR = 0 ;

    //* Reset the USART mode
    pUSART->US_MR = 0  ;

    //* Reset the Timeguard Register
    pUSART->US_TTGR = 0;

    //* Disable all interrupts
    pUSART->US_IDR = 0xFFFFFFFF ;

    //* Disable receiver and transmitter and stop any activity immediately
    pUSART->US_CR = AT91C_US_TXDIS | AT91C_US_RXDIS | AT91C_US_RSTTX | AT91C_US_RSTRX ;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_TxReady
//* \brief Return 1 if a character can be written in US_THR
//*----------------------------------------------------------------------------
__inline unsigned int AT91F_US_TxReady (
        AT91PS_USART pUSART )     // \arg pointer to a USART controller
{
    return (pUSART->US_CSR & AT91C_US_TXRDY);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_RxReady
//* \brief Return 1 if a character can be read in US_RHR
//*----------------------------------------------------------------------------
__inline unsigned int AT91F_US_RxReady (
        AT91PS_USART pUSART )     // \arg pointer to a USART controller
{
    return (pUSART->US_CSR & AT91C_US_RXRDY);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_Error
//* \brief Return the error flag
//*----------------------------------------------------------------------------
__inline unsigned int AT91F_US_Error (
        AT91PS_USART pUSART )     // \arg pointer to a USART controller
{
    return (pUSART->US_CSR &
        (AT91C_US_OVRE |  // Overrun error
         AT91C_US_FRAME | // Framing error
         AT91C_US_PARE));  // Parity error
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_PutChar
//* \brief Send a character,does not check if ready to send
//*----------------------------------------------------------------------------
__inline void AT91F_US_PutChar (
        AT91PS_USART pUSART,
        int character )
{
    pUSART->US_THR = (character & 0x1FF);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_US_GetChar
//* \brief Receive a character,does not check if a character is available
//*----------------------------------------------------------------------------
__inline int AT91F_US_GetChar (
        const AT91PS_USART pUSART)
{
    return((pUSART->US_RHR) & 0x1FF);
}