pdc_example.c

Go to the documentation of this file.

/*This file has been prepared for Doxygen automatic documentation generation.*/
#include <avr32/io.h>
#include "settings.h"
#include "usart.h"
#include "pdc.h"

#ifdef __GNUC__
        #include "interrupt_gcc.h"
#elif __IAR__
        #include "interrupt_iar.h"
#endif

#define RGB_OFF         0
#define RGB_RED         1
#define RGB_GREEN       2
#define RGB_BLUE        3
#define RGB_ORANGE      4
#define RGB_WHITE       5

#define MODE_POLLED     0
#define MODE_PDC        1
#define MODE_INT        2


char * string;
int stringSize;
char * stringPDC;
int stringSizePDC;
volatile avr32_pio_t * pioa;
volatile avr32_pio_t * piob;
volatile avr32_usart_t * usart0;
unsigned char runningleds_status;

void delay()
{
        unsigned int timeout = TIMEOUT;

        do {
                --timeout;
        } while ( timeout > 0 );
}


void runningleds()
{
        runningleds_status <<= 1;
        runningleds_status ^= ( runningleds_status ^ 0x80 ) >> 7;
        piob->codr = 0x000000FF;
        piob->sodr = (long)runningleds_status;
}

void rgb_setColor( unsigned char color )
{
        piob->codr = 0x003F0000;

        switch( color ) {
                case RGB_OFF:
                        break;
                case RGB_RED:
                        piob->sodr = 0x00030000;
                        break;
                case RGB_GREEN:
                        piob->sodr = 0x000C0000;
                        break;
                case RGB_BLUE:
                        piob->sodr = 0x00300000;
                        break;
                case RGB_ORANGE:
                        piob->sodr = 0x000F0000;
                        break;
                case RGB_WHITE:
                        piob->sodr = 0x003F0000;
                        break;
                default:
                        break;
        }
}


int main( int argc, char * argv[] )
{
        struct usart_options_t usartOptions;

        /* Select PIO */
        pioa = (volatile avr32_pio_t *) AVR32_PIOA_ADDRESS;
        piob = (volatile avr32_pio_t *) AVR32_PIOB_ADDRESS;

        /* Select USART */
        usart0 = (volatile avr32_usart_t *) AVR32_USART0_ADDRESS;

        /* disable all interrupts on PIO */
        pioa->idr = 0xFFFFffff;
        piob->idr = 0xFFFFffff;

        /* Enable USART0, SPI and I2S on PIOA
         * USART0 is PA26 and PA27
         * USART0 is module A on PIOA
         */
        pioa->pdr = 0x0C000000;
        pioa->asr = 0x0C000000;

        /* Enable PIOB as debug output/input
         * Output: PB0, PB1, PB2, PB3, PB4, PB5, PB6 and PB7
         * Input: PB8, PB9, PB10, PB11, PB12, PB13, PB14 AND PB15
         */
        piob->per = 0x000000FF;
        piob->oer = 0x00FF00FF;
        piob->odr = 0x0000FF00;
        piob->ifer = 0x0000FF00;
        piob->codr = 0xFFFFffff;
        piob->ower = 0x00FF00FF;

        /* Set options for the USART */
        usartOptions.baudrate = USART_BAUD;
        usartOptions.charlength = USART_BITS;
        usartOptions.paritytype = USART_NO_PARITY;
        usartOptions.stopbits = USART_1_STOPBIT;
        usartOptions.channelmode = USART_NORMAL_CHMODE;

        /* Initialize USART in RS232 mode */
        usart_init2( usart0, &usartOptions, CPUHZ );

        string = "POL: AVR32 PDC application demo\r\n";
        stringPDC = "PDC: AVR32 PDC application demo\r\n";

        stringSize = 33;
        stringSizePDC = 33;

        pdc_flushCache( string, stringSize );
        pdc_flushCache( stringPDC, stringSizePDC );

        int mode = MODE_POLLED;
        rgb_setColor(RGB_RED);
        runningleds_status = 0;

        for( ;; ) {

                /* Actions
                 * SW7 change mode to POLL
                 * SW6 change mode to PDC
                 * SW5 change mode to PDC + Interrupt
                 */
                if( (piob->pdsr & (1<<AVR32_PIO_P15)) == 0 ) {
                        rgb_setColor(RGB_RED);
                        mode = MODE_POLLED;
                } else if( (piob->pdsr & (1<<AVR32_PIO_P14)) == 0 ) {
                        rgb_setColor(RGB_ORANGE);
                        mode = MODE_PDC;
                } else if( (piob->pdsr & (1<<AVR32_PIO_P13)) == 0 ) {
                        rgb_setColor(RGB_GREEN);
                        mode = MODE_INT;
                }


                if( mode == MODE_POLLED ) {
                        usart_writeLine( usart0, string );
                }
                else if( mode == MODE_PDC ) {
                        if( pdc_txBytesLeft( (void *) usart0 ) == 0 ) {
                                pdc_setTxBuf( (void *) usart0,
                                                pdc_translatePtr( stringPDC ),
                                                stringSizePDC,
                                                0,
                                                0 );
                        }
                }
                else if( mode == MODE_INT ) {
                        int interrupts_on = 1;

                        start_interrupts();

                        do {
                                /* SW7 and SW6 disables interrupts */
                                if( (piob->pdsr & (1<<AVR32_PIO_P15)) == 0 ) {
                                        rgb_setColor(RGB_RED);
                                        mode = MODE_POLLED;
                                        interrupts_on = 0;
                                } else if( (piob->pdsr & (1<<AVR32_PIO_P14)) == 0 ) {
                                        rgb_setColor(RGB_ORANGE);
                                        mode = MODE_PDC;
                                        interrupts_on = 0;
                                }

                                runningleds();
                                delay();
                        } while( interrupts_on == 1 );

                        stop_interrupts();
                }

                runningleds();
                delay();
        }
}

---