/**
* \brief Configure the Pushbuttons
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_buttons(void)
{
// [main_button1_configure]
/* Configure Pushbutton 1 */
pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, 10);
/* Interrupt on rising edge */
pio_handler_set(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_ID,
PIN_PUSHBUTTON_1_MASK, PIN_PUSHBUTTON_1_ATTR, Button1_Handler);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_1_ID);
pio_handler_set_priority(PIN_PUSHBUTTON_1_PIO,
(IRQn_Type) PIN_PUSHBUTTON_1_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK);
// [main_button1_configure]
#ifndef BOARD_NO_PUSHBUTTON_2
// [main_button2_configure]
/* Configure Pushbutton 2 */
pmc_enable_periph_clk(PIN_PUSHBUTTON_2_ID);
pio_set_debounce_filter(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK, 10);
/* Interrupt on falling edge */
pio_handler_set(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_ID,
PIN_PUSHBUTTON_2_MASK, PIN_PUSHBUTTON_2_ATTR, Button2_Handler);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_2_ID);
pio_handler_set_priority(PIN_PUSHBUTTON_2_PIO,
(IRQn_Type) PIN_PUSHBUTTON_2_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK);
// [main_button2_configure]
#endif
}
/**
* \brief Configure the push buttons.
*
* Configure the PIOs as inputs and generate corresponding interrupt when
* the push buttons are pressed or released.
*/
static void configure_buttons(void)
{
/* Enable the pmc clocks of the push buttons for all SAM3. */
pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
pmc_enable_periph_clk(PIN_PUSHBUTTON_2_ID);
/* Adjust PIO debouncing filter patameters, using 10 Hz filter. */
pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK,
10);
pio_set_debounce_filter(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK,
10);
/* Initialize PIOs interrupt handlers (see PIO definition in board.h). */
pio_handler_set(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_ID, PIN_PUSHBUTTON_1_MASK, PIN_PUSHBUTTON_1_ATTR, Int1Handler); /* Interrupt on rising edge. */
pio_handler_set(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_ID, PIN_PUSHBUTTON_2_MASK, PIN_PUSHBUTTON_2_ATTR, Int2Handler); /* Interrupt on falling edge. */
/* Enable PIO controller IRQs. */
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_1_ID);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_2_ID);
/* PIO configuration for Buttons. */
pio_handler_set_priority(PIN_PUSHBUTTON_1_PIO, (IRQn_Type) PIN_PUSHBUTTON_1_ID, 0);
pio_handler_set_priority(PIN_PUSHBUTTON_2_PIO, (IRQn_Type) PIN_PUSHBUTTON_2_ID, 0);
/* Enable PIO line interrupts. */
pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK);
pio_enable_interrupt(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK);
}
/**
* \brief Configure the Pushbuttons
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_buttons(void)
{
pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
pmc_enable_periph_clk(PIN_PUSHBUTTON_2_ID);
pio_set_input(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, PIO_PULLUP | PIO_DEBOUNCE);
pio_set_input(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK, PIO_PULLUP | PIO_DEBOUNCE);
pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, 10);
pio_set_debounce_filter(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK, 10);
pio_handler_set(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_ID, PIN_PUSHBUTTON_1_MASK, PIO_IT_FALL_EDGE | PIO_PULLUP, Button1_Handler);
pio_handler_set(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_ID, PIN_PUSHBUTTON_2_MASK, PIO_IT_FALL_EDGE | PIO_PULLUP, Button2_Handler);
pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO , PIN_PUSHBUTTON_1_MASK);
pio_enable_interrupt(PIN_PUSHBUTTON_2_PIO , PIN_PUSHBUTTON_2_MASK);
NVIC_SetPriority((IRQn_Type) PIN_PUSHBUTTON_1_ID, 0);
NVIC_SetPriority((IRQn_Type) PIN_PUSHBUTTON_2_ID, 0);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_1_ID);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_2_ID);
}
/**
* \brief Configure the Pushbuttons
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_buttons(void)
{
pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
pio_set_input(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, PIN_PUSHBUTTON_1_ATTR);
pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, 100);
pio_handler_set(PIN_PUSHBUTTON_1_PIO,PIN_PUSHBUTTON_1_ID, PIN_PUSHBUTTON_1_MASK,PIO_IT_FALL_EDGE, Button1_Handler);
pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK);
NVIC_SetPriority(PIN_PUSHBUTTON_1_ID,0);
NVIC_EnableIRQ(PIN_PUSHBUTTON_1_ID);
pmc_enable_periph_clk(PIN_PUSHBUTTON_2_ID);
pio_set_input(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK, PIN_PUSHBUTTON_2_ATTR);
pio_set_debounce_filter(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK, 100);
pio_handler_set(PIN_PUSHBUTTON_2_PIO,PIN_PUSHBUTTON_2_ID, PIN_PUSHBUTTON_2_MASK,PIO_IT_FALL_EDGE, Button2_Handler);
pio_enable_interrupt(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK);
NVIC_SetPriority(PIN_PUSHBUTTON_2_ID,1);
NVIC_EnableIRQ(PIN_PUSHBUTTON_2_ID);
}
/**
* \brief Configure the Pushbuttons
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_buttons(void)
{
pmc_enable_periph_clk(ID_BUT_2);
pmc_enable_periph_clk(ID_BUT_1);
pio_set_input(PORT_BUT_2, MASK_BUT_2, PIO_PULLUP | PIO_DEBOUNCE);
pio_set_input(PORT_BUT_1, MASK_BUT_1, PIO_PULLUP | PIO_DEBOUNCE);
pio_set_debounce_filter(PORT_BUT_2, MASK_BUT_2, 20);
pio_set_debounce_filter(PORT_BUT_1, MASK_BUT_1, 20);
pio_handler_set(PORT_BUT_2, ID_BUT_2, MASK_BUT_2, PIO_IT_FALL_EDGE , Button1_Handler );
pio_handler_set(PORT_BUT_1, ID_BUT_1, MASK_BUT_1, PIO_IT_FALL_EDGE , Button2_Handler );
pio_enable_interrupt(PORT_BUT_2, MASK_BUT_2);
pio_enable_interrupt(PORT_BUT_1, MASK_BUT_1);
NVIC_SetPriority((IRQn_Type) ID_PIOB, 2);
NVIC_SetPriority((IRQn_Type) ID_PIOC, 2);
NVIC_EnableIRQ(ID_BUT_2);
NVIC_EnableIRQ(ID_BUT_1);
}
void button_init(uint32_t ul_id, Pio *p_pio, const uint32_t ul_mask, IRQn_Type IRQn, void (*p_handler) (uint32_t, uint32_t))
{
pmc_enable_periph_clk(ul_id);
pio_set_input(p_pio, ul_mask, PIO_PULLUP | PIO_DEBOUNCE);
pio_set_debounce_filter(p_pio, ul_mask, DEBOUNCE_FREQ);
pio_handler_set(p_pio, ul_id, ul_mask, PIO_IT_FALL_EDGE, p_handler);
pio_enable_interrupt(p_pio, ul_mask);
NVIC_EnableIRQ(IRQn);
}
void configure_botao(void)
{
pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
pio_set_input(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, PIN_PUSHBUTTON_1_ATTR);
pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, 10);
pio_handler_set(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_ID,PIN_PUSHBUTTON_1_MASK, PIN_PUSHBUTTON_1_ATTR ,push_button_handle);
pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK);
NVIC_SetPriority((IRQn_Type) PIN_PUSHBUTTON_1_ID, 0);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_1_ID);
}
/**
* \brief Configure the Pushbuttons
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_buttons(void)
{
pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
pmc_enable_periph_clk(PIN_PUSHBUTTON_2_ID);
/**
* Configura entrada
*/
pio_set_input(PIN_PUSHBUTTON_1_PIO,PIN_PUSHBUTTON_1_MASK , PIO_PULLUP | PIO_DEBOUNCE);
pio_set_input(PIN_PUSHBUTTON_2_PIO,PIN_PUSHBUTTON_2_MASK , PIO_PULLUP | PIO_DEBOUNCE);
/*
* Configura divisor do clock para debounce
*/
pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO,PIN_PUSHBUTTON_1_MASK ,20);
pio_set_debounce_filter(PIN_PUSHBUTTON_2_PIO,PIN_PUSHBUTTON_2_MASK ,20);
/*
* Configura interrupção para acontecer em borda de descida.
*/
pio_handler_set(PIN_PUSHBUTTON_1_PIO,PIN_PUSHBUTTON_1_ID,PIN_PUSHBUTTON_1_MASK ,PIN_PUSHBUTTON_1_ATTR ,Button1_Handler);
pio_handler_set(PIN_PUSHBUTTON_2_PIO,PIN_PUSHBUTTON_2_ID,PIN_PUSHBUTTON_2_MASK ,PIN_PUSHBUTTON_2_ATTR ,Button2_Handler);
/*
* Ativa interrupção no periférico B porta do botão
*/
pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO,PIN_PUSHBUTTON_1_MASK);
pio_enable_interrupt(PIN_PUSHBUTTON_2_PIO,PIN_PUSHBUTTON_2_MASK);
/*
* Configura a prioridade da interrupção no pORTB
*/
NVIC_SetPriority(ID_PIOB,2);
NVIC_SetPriority(ID_PIOC,2);
/*
* Ativa interrupção no port B
*/
NVIC_EnableIRQ(ID_PIOB);
NVIC_EnableIRQ(ID_PIOC);
}
static void configure_buttons(void)
{
pmc_enable_periph_clk(ID_BUT_2);
pmc_enable_periph_clk(ID_BUT_3);
/**
* Configura entrada
*/
pio_set_input(PORT_BUT_2, MASK_BUT_2, PIO_PULLUP | PIO_DEBOUNCE);
pio_set_input(PORT_BUT_3, MASK_BUT_3, PIO_PULLUP | PIO_DEBOUNCE);
/*
* Configura divisor do clock para debounce
*/
pio_set_debounce_filter(PORT_BUT_2,MASK_BUT_2, 100);
pio_set_debounce_filter(PORT_BUT_3,MASK_BUT_3, 100);
/*
* Configura interrupção para acontecer em borda de descida.
*/
pio_handler_set(PORT_BUT_2,ID_BUT_2,MASK_BUT_2,PIO_IT_FALL_EDGE,Button2_Handler);
pio_handler_set(PORT_BUT_3,ID_BUT_3,MASK_BUT_3,PIO_IT_FALL_EDGE,Button3_Handler);
/*
* Ativa interrupção no periférico B porta do botão
*/
pio_enable_interrupt(PORT_BUT_2,MASK_BUT_2);
pio_enable_interrupt(PORT_BUT_3,MASK_BUT_3);
/*
* Configura a prioridade da interrupção no PORTB E PORTC
*/
NVIC_SetPriority(PIOB_IRQn, 10);
NVIC_SetPriority(PIOC_IRQn, 10);
/*
* Ativa interrupção no port B e C
*/
NVIC_EnableIRQ(PIOB_IRQn);
NVIC_EnableIRQ(PIOC_IRQn);
}
/**
* \brief Configure the Pushbuttons.
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_buttons(void)
{
/* Configure Pushbutton 1. */
pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, 10);
pio_handler_set(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_ID,
PIN_PUSHBUTTON_1_MASK, PIN_PUSHBUTTON_1_ATTR, Button1_Handler);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_1_ID);
pio_handler_set_priority(PIN_PUSHBUTTON_1_PIO, (IRQn_Type) PIN_PUSHBUTTON_1_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK);
/* Configure Pushbutton 2. */
pmc_enable_periph_clk(PIN_PUSHBUTTON_2_ID);
pio_set_debounce_filter(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK, 10);
pio_handler_set(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_ID,
PIN_PUSHBUTTON_2_MASK, PIN_PUSHBUTTON_2_ATTR, Button2_Handler);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_2_ID);
pio_handler_set_priority(PIN_PUSHBUTTON_2_PIO, (IRQn_Type) PIN_PUSHBUTTON_2_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK);
/* Configure Pushbutton 3. */
pmc_enable_periph_clk(PIN_PUSHBUTTON_3_ID);
pio_set_debounce_filter(PIN_PUSHBUTTON_3_PIO, PIN_PUSHBUTTON_3_MASK, 10);
pio_handler_set(PIN_PUSHBUTTON_3_PIO, PIN_PUSHBUTTON_3_ID,
PIN_PUSHBUTTON_3_MASK, PIN_PUSHBUTTON_3_ATTR, Button3_Handler);
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_3_ID);
pio_handler_set_priority(PIN_PUSHBUTTON_3_PIO, (IRQn_Type) PIN_PUSHBUTTON_3_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(PIN_PUSHBUTTON_3_PIO, PIN_PUSHBUTTON_3_MASK);
/* Configure SD card detection. */
pmc_enable_periph_clk(SD_MMC_0_CD_ID);
pio_set_debounce_filter(SD_MMC_0_CD_PIO, SD_MMC_0_CD_MASK, 10);
pio_handler_set(SD_MMC_0_CD_PIO, SD_MMC_0_CD_ID, SD_MMC_0_CD_MASK,
SD_MMC_0_CD_ATTR, SD_Detect_Handler);
NVIC_EnableIRQ((IRQn_Type) SD_MMC_0_CD_ID);
pio_handler_set_priority(SD_MMC_0_CD_PIO, (IRQn_Type) SD_MMC_0_CD_ID, IRQ_PRIOR_PIO);
pio_enable_interrupt(SD_MMC_0_CD_PIO, SD_MMC_0_CD_MASK);
}
/**
* \brief Configure the push button 1.
*
* \note Configure the PIO as input and generate corresponding interrupt
* when pressed or released.
*/
static void dsp_configure_button2(void)
{
/* Configure Pushbutton 1. */
pmc_enable_periph_clk(PIN_PUSHBUTTON_2_ID);
pio_set_debounce_filter(PIN_PUSHBUTTON_2_PIO,
PIN_PUSHBUTTON_2_MASK, 10);
pio_handler_set(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_ID,
PIN_PUSHBUTTON_2_MASK, PIN_PUSHBUTTON_2_ATTR,
dsp_event_button2);
/* Take care of NVIC_SetPriority. */
pio_handler_set_priority(PIN_PUSHBUTTON_2_PIO,
(IRQn_Type) PIN_PUSHBUTTON_2_ID,
INT_PRI_PUSHBUTTON);
pio_enable_interrupt(PIN_PUSHBUTTON_2_PIO, PIN_PUSHBUTTON_2_MASK);
}
/**
* \brief Configure the Pushbutton.
*/
static void configure_button(void)
{
/* Enable the peripheral clock for the push button on board. */
pmc_enable_periph_clk(PUSHBUTTON_ID);
/* Configure PIOs as input pins. */
pio_configure(PUSHBUTTON_PIO, PUSHBUTTON_TYPE, PUSHBUTTON_MASK,
PUSHBUTTON_ATTR);
/* Adjust PIO debounce filter parameters. */
pio_set_debounce_filter(PUSHBUTTON_PIO, PUSHBUTTON_MASK,
PUSHBUTTON_FILTER_GLITCH_VAULE);
/* Initialize PIO interrupt handler, interrupt on rising edge. */
pio_handler_set(PUSHBUTTON_PIO, PUSHBUTTON_ID, PUSHBUTTON_MASK,
PUSHBUTTON_ATTR, button_handler);
}
/**
* \brief Configure the push button.
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_button(void)
{
/* Adjust PIO debounce filter parameters, using 10 Hz filter. */
pio_set_debounce_filter(PIN_PUSHBUTTON_WAKEUP_PIO,
PIN_PUSHBUTTON_WAKEUP_MASK, 10);
/* Initialize PIO interrupt handlers, see PIO definition in board.h. */
pio_handler_set(PIN_PUSHBUTTON_WAKEUP_PIO, PIN_PUSHBUTTON_WAKEUP_ID,
PIN_PUSHBUTTON_WAKEUP_MASK, PIN_PUSHBUTTON_WAKEUP_ATTR,
button_handler);
/* Enable PIO controller IRQs. */
NVIC_EnableIRQ((IRQn_Type)PIN_PUSHBUTTON_WAKEUP_ID);
/* Enable PIO line interrupts. */
pio_enable_interrupt(PIN_PUSHBUTTON_WAKEUP_PIO,
PIN_PUSHBUTTON_WAKEUP_MASK);
}
/**
* \brief Configure the push button.
*
* Configure the PIOs as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_button(void)
{
/* Configure PIO clock. */
pmc_enable_periph_clk(PUSH_BUTTON_ID);
/* Adjust pio debounce filter parameters, uses 10 Hz filter. */
pio_set_debounce_filter(PUSH_BUTTON_PIO, PUSH_BUTTON_PIN_MSK, 10);
/* Initialize pios interrupt handlers, see PIO definition in board.h. */
pio_handler_set(PUSH_BUTTON_PIO, PUSH_BUTTON_ID, PUSH_BUTTON_PIN_MSK,
PUSH_BUTTON_ATTR, button_handler);
/* Enable PIO controller IRQs. */
NVIC_EnableIRQ((IRQn_Type)PUSH_BUTTON_ID);
/* Enable PIO line interrupts. */
pio_enable_interrupt(PUSH_BUTTON_PIO, PUSH_BUTTON_PIN_MSK);
}
/**
* \brief Configure the Pushbuttons
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void _configure_buttons(void)
{
int i = 0;
for (i = 0; i < ARRAY_SIZE(button_pins); ++i)
{
/* Configure pios as inputs. */
pio_configure(&button_pins[i], 1);
/* Adjust pio debounce filter parameters, uses 10 Hz filter. */
pio_set_debounce_filter(&button_pins[i], 10);
/* Initialize pios interrupt with its handlers */
pio_configure_it(&button_pins[i]);
pio_add_handler_to_group(button_pins[i].group,
button_pins[i].mask,
push_button_handler,
NULL);
pio_enable_it(button_pins);
}
}
/**
* \brief Configure the Push buttons
*
* Configure the PIO as inputs and generate corresponding interrupt when
* pressed or released.
*/
static void configure_buttons(void)
{
/* Enable the peripheral clock for PCK and push button */
pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
/* Adjust PIO debounce filter parameters, using 10 Hz filter. */
pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, 10);
/* Initialize PIOs interrupt handlers, see PIO definition in board.h. */
/* Interrupt on rising edge */
pio_handler_set(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_ID,
PIN_PUSHBUTTON_1_MASK, PIN_PUSHBUTTON_1_ATTR, button1_handler);
/* Enable PIO controller IRQs. */
NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_1_ID);
/* Enable PIO line interrupts. */
pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK);
}
/**
* \brief Configure the INTN interrupt.
*/
void configure_intn(void (*p_handler) (uint32_t, uint32_t))
{
/* Configure PIO clock. */
pmc_enable_periph_clk(INTN_ID);
/* Adjust PIO debounce filter parameters, uses 10 Hz filter. */
pio_set_debounce_filter(INTN_PIO, INTN_PIN_MSK, 10);
/* Initialize PIO interrupt handlers, see PIO definition in board.h. */
pio_handler_set(INTN_PIO, INTN_ID, INTN_PIN_MSK,
INTN_ATTR, p_handler);
/* Enable NVIC interrupts. */
NVIC_SetPriority(INTN_IRQn, INT_PRIORITY_PIO);
NVIC_EnableIRQ((IRQn_Type)INTN_ID);
/* Enable PIO interrupts. */
pio_enable_interrupt(INTN_PIO, INTN_PIN_MSK);
}
/**
* \brief getting-started Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
int tests = 0;
int test_fail = 0;
printf("<?xml version=\"1.0\" encoding=\"UTF-8\">\r\n\r\n");
printf("<testsuite>\r\n");
printf(" <testcase classname=\"pio.setup\" name=\"Setup\">\r\n");
printf(" <system-out>\r\n");
/* Output example information */
console_example_info("PIO Testing Example");
/* Configure PIO for input acquisition */
pio_configure(&pio_input, 1);
pio_set_debounce_filter(&pio_input, 100);
/* Initialize pios interrupt with its handlers, see
* PIO definition in board.h. */
pio_configure_it(&pio_input);
pio_add_handler_to_group(pio_input.group, pio_input.mask, pio_handler, NULL);
/* Configure PIO for output generation */
pio_configure(&pio_output, 1);
/* Reset event counts */
_pio_event = 0;
printf(" </system-out>\r\n");
printf(" </testcase>\r\n");
printf("<testsuite>\r\n");
printf(" <testcase classname=\"pio.level.low\" name='PIO: Set/Get PIO LOW LEVEL'>\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_clear(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (!(pio_get(&pio_input) == 0) || !(pio_get(&pio_output) == 0)) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
printf(" </testcase>\r\n");
printf(" <testcase classname=\"pio.level.high\" name=\"PIO: Get PIO HIGH LEVEL\">\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_set(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (!(pio_get(&pio_input) == 1) || !(pio_get(&pio_output) == 1)) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
printf(" </testcase>\r\n");
printf(" <testcase classname=\"pio.irq.edge.falling\" name=\"PIO: Get PIO IRQ FALLING EDGE\">\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_set(&pio_output);
pio_input.attribute |= PIO_IT_FALL_EDGE;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
pio_clear(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (_pio_event != 1) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_input.attribute &= ~PIO_IT_FALL_EDGE;
printf(" </test>\r\n");
printf(" <testcase classname=\"pio.irq.edge.rising\" name=\"PIO: Get PIO IRQ RISING EDGE\">\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_clear(&pio_output);
pio_input.attribute |= PIO_IT_RISE_EDGE;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
pio_set(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (_pio_event != 1) {
test_fail++;
printf(" <error error=\"error\">event(s): %d</error>\r\n", _pio_event);
}
tests++;
pio_input.attribute &= ~PIO_IT_RISE_EDGE;
printf(" </test>\r\n");
printf(" <testcase classname=\"pio.irq.edge.both\" name=\"PIO: Get PIO IRQ BOTH EDGE\">\r\n");
#ifdef PIO_IT_BOTH_EDGE
printf(" <system-out>\r\n");
_pio_event = 0;
pio_set(&pio_output);
pio_input.attribute |= PIO_IT_BOTH_EDGE;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
pio_clear(&pio_output);
timer_wait(10);
pio_set(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (_pio_event != 2) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_input.attribute &= ~PIO_IT_BOTH_EDGE;
#else
printf(" <skip />\r\n");
#endif
printf(" </testcase>\r\n");
printf(" <testcase classname=\"pio.irq.level.low\" name=\"PIO: Get PIO IRQ LEVEL LOW\">\r\n");
printf(" <system-out>\r\n");
pio_set(&pio_output);
pio_input.attribute |= PIO_IT_LOW_LEVEL;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
_pio_event = 0;
pio_clear(&pio_output);
timer_wait(10);
pio_set(&pio_output);
printf(" </system-out>\r\n");
if (_pio_event < 1) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_input.attribute &= ~PIO_IT_LOW_LEVEL;
printf(" </testcase>\r\n");
printf(" <testcase classname=\"pio.irq.level.high\" name=\"PIO: Get PIO IRQ LEVEL HIGH\">\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_clear(&pio_output);
pio_input.attribute |= PIO_IT_HIGH_LEVEL;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
pio_set(&pio_output);
timer_wait(10);
pio_clear(&pio_output);
printf(" </system-out>\r\n");
if (_pio_event < 1) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_input.attribute &= ~PIO_IT_HIGH_LEVEL;
printf(" </test>\r\n");
printf(" <testcase classname=\"pio.mode.pull.up\" name=\"PIO: Get PIO PULL UP\">\r\n");
printf(" <system-out>\r\n");
pio_clear(&pio_output);
pio_output.type = PIO_INPUT;
pio_output.attribute |= PIO_PULLUP;
pio_configure(&pio_output, 1);
pio_configure(&pio_input, 1);
printf(" </system-out>\r\n");
if (pio_get(&pio_input) != 1) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_output.attribute &= ~PIO_PULLUP;
pio_output.type = PIO_OUTPUT_0;
pio_configure(&pio_output, 1);
printf(" </testcase>\r\n");
printf(" <statistics>\r\n");
printf(" <failures>%d</failures>\r\n", test_fail);
printf(" <tests>%d</tests>\r\n", tests);
printf(" </statistics>\r\n");
printf("</testsuite>\r\n");
while (1);
}
extern "C" void pinModeDuet(Pin pin, enum PinMode ulMode, uint32_t debounceCutoff)
{
if (pin > MaxPinNumber)
{
return;
}
const PinDescription& pinDesc = g_APinDescription[pin];
if (pinDesc.ulPinType == PIO_NOT_A_PIN)
{
return;
}
switch (ulMode)
{
case INPUT:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pullup
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? 0 : PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
case INPUT_PULLUP:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? PIO_PULLUP : PIO_PULLUP | PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
#if SAM4E
case INPUT_PULLDOWN:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0);
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 1);
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? 0 : PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
#endif
case OUTPUT_LOW:
pio_configure(
pinDesc.pPort,
PIO_OUTPUT_0,
pinDesc.ulPin,
pinDesc.ulPinConfiguration);
/* if all pins are output, disable PIO Controller clocking, reduce power consumption */
if (pinDesc.pPort->PIO_OSR == 0xffffffff)
{
pmc_disable_periph_clk(pinDesc.ulPeripheralId);
}
break;
case OUTPUT_HIGH:
pio_configure(
pinDesc.pPort,
PIO_OUTPUT_1,
pinDesc.ulPin,
pinDesc.ulPinConfiguration);
/* if all pins are output, disable PIO Controller clocking, reduce power consumption */
if (pinDesc.pPort->PIO_OSR == 0xffffffff)
{
pmc_disable_periph_clk(pinDesc.ulPeripheralId);
}
break;
case OUTPUT_PWM_LOW:
if ((pinDesc.ulPinAttribute & (PIN_ATTR_PWM | PIN_ATTR_TIMER)) != 0)
{
AnalogOut(pin, 0.0, 0); // set it to zero frequency to force re-initialisation on next AnalogOut call
}
break;
case OUTPUT_PWM_HIGH:
if ((pinDesc.ulPinAttribute & (PIN_ATTR_PWM | PIN_ATTR_TIMER)) != 0)
{
AnalogOut(pin, 1.0, 0); // set it to zero frequency to force re-initialisation on next AnalogOut call
}
break;
case AIN:
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pullup
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
// Ideally we should record which pins are being used as analog inputs, then we can disable the clock
// on any PIO that is being used solely for outputs and ADC inputs. But for now we don't do that.
break;
case SPECIAL:
ConfigurePin(pinDesc);
break;
default:
break;
}
}
int main (void)
{
/**
* Inicializando o clock do uP
*/
sysclk_init();
/**
* Desabilitando o WathDog do uP
*/
WDT->WDT_MR = WDT_MR_WDDIS;
/**
* Ativa clock nos periféricos
*/
_pmc_enable_clock_periferico(ID_LED_BLUE);
_pmc_enable_clock_periferico(ID_LED_GREEN); // Redundante mas não tem problema !
_pmc_enable_clock_periferico(ID_LED_RED);
_pmc_enable_clock_periferico(ID_BUT_2);
/**
* Configura saída
*/
pio_set_output(PORT_LED_BLUE , MASK_LED_BLUE ,1,0,0);
pio_set_output(PORT_LED_GREEN , MASK_LED_GREEN ,1,0,0);
pio_set_output(PORT_LED_RED , MASK_LED_RED ,1,0,0);
/**
* Configura entrada
*/
pio_set_input(PORT_BUT_2, MASK_BUT_2, PIO_PULLUP | PIO_DEBOUNCE);
/*
* Configura divisor do clock para debounce
*/
pio_set_debounce_filter(PORT_BUT_2, MASK_BUT_2, 100);
/*
* Configura interrupção para acontecer em borda de descida.
*/
pio_handler_set(PIOB, ID_BUT_2, MASK_BUT_2, PIO_IT_FALL_EDGE, push_button_handle);
/*
* Ativa interrupção no periférico B porta do botão
*/
pio_enable_interrupt(PORT_BUT_2, MASK_BUT_2);
/*
* Configura a prioridade da interrupção no pORTB
*/
NVIC_SetPriority((IRQn_Type)PIOB_IRQn, 0);
/*
* Ativa interrupção no port B
*/
NVIC_EnableIRQ((IRQn_Type)PIOB_IRQn);
/**
* Loop infinito
*/
while(1){
/*
pio_set(PIOA, (1 << PIN_LED_BLUE));
delay_ms(500);
pio_clear(PIOA, (1 << PIN_LED_BLUE));
delay_ms(500);
*/
}
}
