pdc_example.c

Go to the documentation of this file.

/*This file has been prepared for Doxygen automatic documentation generation.*/
/* Copyright (c) 2006, Atmel Corporation All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. The name of ATMEL may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY ATMEL ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY AND
 * SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifdef __GNUC__
#include <avr32/io.h>
#elif __ICCAVR32__
#include <avr32/ioap7000.h>
#else
#error No known compiler used
#endif
#include "settings.h"
#include "usart.h"
#include "pdc.h"

#ifdef __GNUC__
#include "interrupt_gcc.h"
#elif __ICCAVR32__
#include "interrupt_iar.h"
#if __PART__ == __AP7000__
#define AVR32_USART0_CLK_0_PIN             10
#define AVR32_USART0_CLK_0_FUNCTION        1
#define AVR32_USART0_CTS_0_PIN             7
#define AVR32_USART0_CTS_0_FUNCTION        1
#define AVR32_USART0_RTS_0_PIN             6
#define AVR32_USART0_RTS_0_FUNCTION        1
#define AVR32_USART0_RXD_0_PIN             8
#define AVR32_USART0_RXD_0_FUNCTION        1
#define AVR32_USART0_TXD_0_PIN             9
#define AVR32_USART0_TXD_0_FUNCTION        1
#define AVR32_USART1_CLK_0_PIN             16
#define AVR32_USART1_CLK_0_FUNCTION        0
#define AVR32_USART1_CTS_0_PIN             20
#define AVR32_USART1_CTS_0_FUNCTION        0
#define AVR32_USART1_RTS_0_PIN             19
#define AVR32_USART1_RTS_0_FUNCTION        0
#define AVR32_USART1_RXD_0_PIN             17
#define AVR32_USART1_RXD_0_FUNCTION        0
#define AVR32_USART1_TXD_0_PIN             18
#define AVR32_USART1_TXD_0_FUNCTION        0
#define AVR32_USART2_CLK_0_PIN             60
#define AVR32_USART2_CLK_0_FUNCTION        1
#define AVR32_USART2_CTS_0_PIN             61
#define AVR32_USART2_CTS_0_FUNCTION        1
#define AVR32_USART2_RTS_0_PIN             62
#define AVR32_USART2_RTS_0_FUNCTION        1
#define AVR32_USART2_RXD_0_PIN             58
#define AVR32_USART2_RXD_0_FUNCTION        1
#define AVR32_USART2_TXD_0_PIN             59
#define AVR32_USART2_TXD_0_FUNCTION        1
#define AVR32_USART3_CLK_0_PIN             51
#define AVR32_USART3_CLK_0_FUNCTION        1
#define AVR32_USART3_CTS_0_PIN             47
#define AVR32_USART3_CTS_0_FUNCTION        1
#define AVR32_USART3_RTS_0_PIN             48
#define AVR32_USART3_RTS_0_FUNCTION        1
#define AVR32_USART3_RXD_0_PIN             50
#define AVR32_USART3_RXD_0_FUNCTION        1
#define AVR32_USART3_TXD_0_PIN             49
#define AVR32_USART3_TXD_0_FUNCTION        1
#else
#error No PIO definitions for the IAR compiler and the cpu chosen
#endif /* __AVR32_AP7000__ */
#endif /* __ICCAVR32__ */

#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

typedef unsigned char avr32_piomap_t[][2];

int pio_enable_module(avr32_piomap_t piomap, unsigned int size);


void delay(int delay)
{
    unsigned int timeout = delay * TIMEOUT;

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


void rgb_setColor(volatile avr32_pio_t * pio, unsigned char color)
{
    pio->codr = 0x00003F00;

    switch(color) {
        case RGB_OFF:
            break;
        case RGB_RED:
            pio->sodr = 0x00000300;
            break;
        case RGB_GREEN:
            pio->sodr = 0x00000C00;
            break;
        case RGB_BLUE:
            pio->sodr = 0x00003000;
            break;
        case RGB_ORANGE:
            pio->sodr = 0x00000F00;
            break;
        case RGB_WHITE:
            pio->sodr = 0x00003F00;
            break;
        default:
            break;
    }
}


void do_interrupt_mode(volatile avr32_pio_t *piob,
        volatile avr32_pio_t *pioc,
        int *mode, unsigned char *leds)
{
    start_interrupts();

    for (;;) {
        /* SW7 and SW6 disables interrupts */
        if ((piob->pdsr & AVR32_PIO_P7_MASK) == 0) {
            rgb_setColor(pioc, RGB_RED);
            *mode = MODE_POLLED;
            goto stop_int;
        } else if ((piob->pdsr & AVR32_PIO_P6_MASK) == 0) {
            rgb_setColor(pioc, RGB_GREEN);
            *mode = MODE_PDC;
            goto stop_int;
        }

        *leds <<= 1;
        *leds ^= (*leds ^ 0x80) >> 7;
        pioc->codr = 0x000000FF;
        pioc->sodr = (long) *leds;
        delay(10);
    }

stop_int:
    stop_interrupts();
}


int main()
{
    /* Initialize interrupts */
    init_usart_interrupts();

    avr32_piomap_t usart_piomap = {
        {AVR32_USART1_RXD_0_PIN, AVR32_USART1_RXD_0_FUNCTION}, \
        {AVR32_USART1_TXD_0_PIN, AVR32_USART1_TXD_0_FUNCTION}, \
    };

    char * string;
    int stringSize;
#ifdef __GNUC__
    char * stringPDC __attribute__((aligned(32)));
#elif __ICCAVR32__
    char * stringPDC;
#else
#error Unknown compiler used, stringPDC must be alligned to work as intended
#endif
    int stringSizePDC;
    volatile avr32_pio_t * piob;
    volatile avr32_pio_t * pioc;
    volatile struct avr32_usart_t * usart;
    struct usart_options_t usartOptions;

    /* Select PIO */
    piob = &AVR32_PIOB;
    pioc = &AVR32_PIOC;

    /* Select USART */
    usart = &USART_MODULE;

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

    /* Enable USART on PIOA */
    pio_enable_module(usart_piomap, 2);

    /* Enable PIOB as debug output
     * Output: PC0 => PC15
     *
     * Enable PIOC as debug input
     * Input: PB0 => BP7
     */
    piob->per = 0x000000FF;
    piob->odr = 0x000000FF;
    piob->puer = 0x000000FF;

    pioc->per = 0x0000FFFF;
    pioc->oer = 0x0000FFFF;
    pioc->ower = 0x0000FFFF;
    pioc->odsr = 0x0000FFFF;

    /* 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_linit(usart, &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/4);
    pdc_flushCache(stringPDC, stringSizePDC/4);

    int mode = MODE_POLLED;
    rgb_setColor(pioc, RGB_RED);

    unsigned char leds = 0;

    for (;;) {
        leds <<= 1;
        leds ^= (leds ^ 0x80) >> 7;
        pioc->codr = 0x000000FF;
        pioc->sodr = (long) leds;

        /* Actions
         * SW7 change mode to POLL
         * SW6 change mode to PDC
         * SW5 change mode to PDC + Interrupt
         */
        if ((piob->pdsr & AVR32_PIO_P7_MASK) == 0) {
            rgb_setColor(pioc, RGB_RED);
            mode = MODE_POLLED;
        } else if ((piob->pdsr & AVR32_PIO_P6_MASK) == 0) {
            rgb_setColor(pioc, RGB_GREEN);
            mode = MODE_PDC;
        } else if ((piob->pdsr & AVR32_PIO_P5_MASK) == 0) {
            rgb_setColor(pioc, RGB_BLUE);
            mode = MODE_INT;
        }


        if (mode == MODE_POLLED) {
            usart_lwriteLine(usart, string);
        }
        else if (mode == MODE_PDC) {
            if (pdc_txBytesLeft((void *) usart) == 0) {
                pdc_setTxBuf((void *) usart,
                        pdc_translatePtr(stringPDC),
                        stringSizePDC,
                        pdc_translatePtr(stringPDC),
                        stringSizePDC);
            }
        }
        else if (mode == MODE_INT) {
            do_interrupt_mode(piob, pioc, &mode, &leds);
        }

        delay(10);
    }
}


int pio_enable_module(avr32_piomap_t piomap, unsigned int size)
{
    int i;
    volatile struct avr32_pio_t *pio;

    /* get the base address for the port */
    switch(**piomap/32) {

        case 0:
            pio = &AVR32_PIOA;
            break;
        case 1:
            pio = &AVR32_PIOB;
            break;
        case 2:
            pio = &AVR32_PIOC;
            break;
        case 3:
            pio = &AVR32_PIOD;
            break;
        case 4:
            pio = &AVR32_PIOE;
            break;
        default :
            return USART_ERROR_ARGUMENT;

    }

    for (i = 0; i < size; i++){

        pio->pdr |= (1<<((**piomap) % 32));
        pio->pudr |= (1<<((**piomap) % 32));

        switch(*(*piomap+1)){
            case 0:
                pio->asr |= (1<<((**piomap) % 32));
                break;
            case 1:
                pio->bsr |= (1<<((**piomap) % 32));
                break;
            default:
                return USART_ERROR_ARGUMENT;
        }

        ++piomap;

    }

    return USART_OK;
}

---