dac_example.c

Go to the documentation of this file.

/*This file has been prepared for Doxygen automatic documentation generation.*/
/* Copyright (c) 2007, 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 "dac.h"
#include "settings.h"
#include "sinus.h"

typedef unsigned char avr32_piomap_t[][2];
static int pio_enable_module(avr32_piomap_t piomap, unsigned int size);

int main(void)
{
    int pi = 0;
    int retval = 0;
    int playing = 0;
    unsigned long debounce = 0;
    volatile avr32_pio_t *piob = &AVR32_PIOB;
    avr32_piomap_t abdac_piomap = {
        {AVR32_ABDAC_DATA_0_PIN, AVR32_ABDAC_DATA_0_FUNCTION},
        {AVR32_ABDAC_DATA_1_PIN, AVR32_ABDAC_DATA_1_FUNCTION},
        {AVR32_ABDAC_DATAN_0_PIN, AVR32_ABDAC_DATAN_0_FUNCTION},
        {AVR32_ABDAC_DATAN_1_PIN, AVR32_ABDAC_DATAN_1_FUNCTION},
    };

    /* Enable the GPIO pins for the ABDAC peripheral. */
    retval = pio_enable_module(abdac_piomap, 4);
    if (retval) {
        goto out;
    }

    /* Setup GPIO for LED and switch. */
    piob->per = 0x000001ff;
    piob->oer = 0x000000ff;
    piob->codr = 0x000000ff;

    abdac_set_dac_hz(&AVR32_ABDAC, BUSHZ, BUSHZ/256);

    for (;;) {
        /* Check if SW0 i pushed. */
        if (!(piob->pdsr & AVR32_PIO_P8_MASK) && !debounce) {
            if (playing) {
                playing = 0;
                piob->codr = AVR32_PIO_P0_MASK;
                debounce = GPIO_DEBOUNCE;
                abdac_disable(&AVR32_ABDAC);
            } else {
                playing = 1;
                piob->sodr = AVR32_PIO_P0_MASK;
                abdac_enable(&AVR32_ABDAC);
                debounce = GPIO_DEBOUNCE / 50;
            }
        }

        if (playing) {
            retval = abdac_sink(&AVR32_ABDAC,
                    sin_table(pi), sin_table(pi));
            if (retval) {
                goto out;
            }

            ++pi;
        }

        if (debounce) {
            --debounce;
        }
    }

out:
    return retval;
}

static 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 -EINVAL;
    }

    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 -EINVAL;
        }
        ++piomap;
    }

    return 0;
}

---