lib_at91m55800a.h

AT91M5800a例子

{
    unsigned int value_for_cs;
    value_for_cs = (~(1 << cs_number)) & 0xF;  //Place a zero among a 4 ONEs number
    pSPI->SPI_TDR = (character & 0xFFFF) | (value_for_cs << 16);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_SPI_GetChar
//* \brief Receive a character,does not check if a character is available
//*----------------------------------------------------------------------------
__inline int AT91F_SPI_GetChar (
        const AT91PS_SPI pSPI)
{
    return((pSPI->SPI_RDR) & 0xFFFF);
}
/* *****************************************************************************
                SOFTWARE API FOR APMC
   ***************************************************************************** */
//*--------------------------------------------------------------------------
//* \fn    AT91F_APMC_EnablePeriphClock
//* \brief Enable peripheral clock
//*--------------------------------------------------------------------------
__inline void AT91F_APMC_EnablePeriphClock (
        AT91PS_APMC pAPMC, // \arg pointer to APMC controller
        unsigned int periphIds)  // \arg IDs of peripherals to enable
{
        pAPMC->APMC_PCER = periphIds;
}

//*--------------------------------------------------------------------------
//* \fn    AT91F_APMC_DisablePeriphClock
//* \brief Enable peripheral clock
//*--------------------------------------------------------------------------
__inline void AT91F_APMC_DisablePeriphClock (
        AT91PS_APMC pAPMC, // \arg pointer to APMC controller
        unsigned int periphIds)  // \arg IDs of peripherals to enable
{
        pAPMC->APMC_PCDR = periphIds;
}

//*--------------------------------------------------------------------------
//* \fn    AT91F_APMC_GetCgmrConfig
//* \brief Return the value of the Clock Mode Generator
//*--------------------------------------------------------------------------
__inline unsigned int AT91F_APMC_GetCgmrConfig (
        AT91PS_APMC pAPMC) // \arg pointer to APMC controller
{
        return ( pAPMC->APMC_CGMR ) ;
}

//*--------------------------------------------------------------------------
//* \fn    AT91F_APMC_IsPllLocked
//* \brief Return the state of the PLL. AT91C_APMC_LOCK if locked, 0 otherwise.
//*--------------------------------------------------------------------------
__inline unsigned int AT91F_APMC_IsPllLocked (
        AT91PS_APMC pAPMC ) // \arg pointer to APMC controller
{
        if ( ( pAPMC->APMC_SR & AT91C_APMC_LOCK ) == AT91C_APMC_LOCK )
                return AT91C_APMC_LOCK ;
        else return 0 ;
}

//*--------------------------------------------------------------------------
//* \fn    AT91F_APMC_EnablePll
//* \brief Enable the PLL and wait for the PLL is locked
//*--------------------------------------------------------------------------
__inline void AT91F_APMC_EnablePll (
        AT91PS_APMC pAPMC, // \arg pointer to APMC controller
        unsigned int pll_config)  // \arg Configuration of the PLL
{
        pAPMC->APMC_CGMR = (( AT91F_APMC_GetCgmrConfig(pAPMC) & ~(AT91C_APMC_MUL|AT91C_APMC_PLLCOUNT)) | pll_config );

        while ( AT91F_APMC_IsPllLocked (pAPMC) != AT91C_APMC_LOCK ) {} ;
}

//*--------------------------------------------------------------------------
//* \fn    AT91F_APMC_IsMoscLocked
//* \brief Return the state of the Main oscillator. AT91C_APMC_MOSCS if locked, 0 otherwise.
//*--------------------------------------------------------------------------
__inline unsigned int AT91F_APMC_IsMoscLocked (
        AT91PS_APMC pAPMC ) // \arg pointer to APMC controller
{
        if ( ( pAPMC->APMC_SR & AT91C_APMC_MOSCS ) == AT91C_APMC_MOSCS )
                return AT91C_APMC_MOSCS ;
        else return 0 ;
}

//*--------------------------------------------------------------------------
//* \fn    AT91F_APMC_EnableMainOsc
//* \brief Enable the Main Oscillator and wait for the Main Oscillator is locked
//*--------------------------------------------------------------------------
__inline void AT91F_APMC_EnableMainOsc (
        AT91PS_APMC pAPMC ) // \arg pointer to APMC controller
{
        pAPMC->APMC_CGMR = ( AT91F_APMC_GetCgmrConfig (pAPMC) | AT91C_APMC_MOSCEN | AT91C_APMC_OSCOUNT ) ;

        while ( AT91F_APMC_IsMoscLocked (pAPMC) != AT91C_APMC_MOSCS ) {} ;
}

//*--------------------------------------------------------------------------
//* \fn    AT91F_APMC_SwitchClock
//* \brief Switching between the different Clock sources
//*--------------------------------------------------------------------------
__inline void AT91F_APMC_SwitchClock (
        AT91PS_APMC pAPMC, // \arg pointer to APMC controller
        unsigned int source_clock)  // \arg Source clock to switch to
{

        pAPMC->APMC_CGMR = (~AT91C_APMC_CSS & AT91F_APMC_GetCgmrConfig (pAPMC)) | source_clock ;
}/* *****************************************************************************
                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
//*----------------------------------------------------------------------------