int main (void)
{
// Insert system clock initialization code here (sysclk_init()).
sysclk_init();
board_init();
// Insert application code here, after the board has been initialized.
pmc_enable_periph_clk(ID_PIOA);
pio_set_input(PIOA, PIO_PA16, PIO_DEFAULT);
pio_pull_down(PIOA, (PIO_PA16), ENABLE);
pio_handler_set(PIOA, ID_PIOA, PIO_PA16, PIO_IT_RISE_EDGE, pin_riseedge_handler);
pio_enable_interrupt(PIOA,PIO_PA16);
pio_set_input(PIOA, PIO_PA17, PIO_DEFAULT);
pio_pull_down(PIOA, (PIO_PA17), ENABLE);
pio_handler_set(PIOA, ID_PIOA, PIO_PA17, PIO_IT_RISE_EDGE, pin_riseedge_handler);
pio_enable_interrupt(PIOA,PIO_PA17);
NVIC_EnableIRQ(PIOA_IRQn);
gpio_set_pin_low(LED0_GPIO);
gpio_set_pin_high(LED1_GPIO);
while(1){
}
}
/**
* \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(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 config_hall_interrupt (void){
pmc_enable_periph_clk(ID_HALL);
pio_set_input(PIOA, GPIO_HALLB, PIO_DEFAULT);
pio_pull_down(PIOA, GPIO_HALLB, ENABLE);
pio_handler_set(PIOA, ID_HALL, GPIO_HALLB, PIO_IT_RISE_EDGE, pin_riseedge_handler);
pio_enable_interrupt(PIOA, GPIO_HALLB);
pio_set_input(PIOA, GPIO_HALLC, PIO_DEFAULT);
pio_pull_down(PIOA, GPIO_HALLC, ENABLE);
pio_handler_set(PIOA, ID_HALL, GPIO_HALLC, PIO_IT_FALL_EDGE, pin_riseedge_handler);
pio_enable_interrupt(PIOA, GPIO_HALLC);
NVIC_DisableIRQ(PIOA_IRQn);
NVIC_ClearPendingIRQ(PIOA_IRQn);
NVIC_SetPriority(PIOA_IRQn, PRIORITY_MEASURE);
NVIC_EnableIRQ(PIOA_IRQn);
}
/**************************************************************************
Configure the interrupt.
Digital Pin 12
**************************************************************************/
void configure_interrupt_pio_RightWheel(void)
{
pmc_enable_periph_clk(ID_PIOD); //Enable the module clock
pio_set_input(PIOD, PIO_PD8,PIO_PULLUP);
pio_handler_set(PIOD,ID_PIOD,PIO_PD8,PIO_IT_EDGE,pin_edge_handler);
pio_enable_interrupt(PIOD,PIO_PD8);
NVIC_EnableIRQ(PIOD_IRQn);
}
/**
* \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 Set an interrupt handler for the specified pin.
* The provided handler will be called with the triggering pin as its parameter
* as soon as an interrupt is detected.
*
* \param ul_pin Pin index to configure.
* \param ul_flag Pin flag.
* \param p_handler Interrupt handler function pointer.
*
* \return 0 if successful, 1 if the maximum number of sources has been defined.
*/
uint32_t pio_handler_set_pin(uint32_t ul_pin, uint32_t ul_flag,
void (*p_handler) (uint32_t, uint32_t))
{
Pio *p_pio = pio_get_pin_group(ul_pin);
uint32_t group_id = pio_get_pin_group_id(ul_pin);
uint32_t group_mask = pio_get_pin_group_mask(ul_pin);
return pio_handler_set(p_pio, group_id, group_mask, ul_flag, p_handler);
}
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);
}
static void irq_init(void) {
pio_configure_pin(DW_IRQ_IDX, DW_IRQ_FLAGS);
pio_pull_down(DW_IRQ_PIO, DW_IRQ_MASK, true);
pio_handler_set(DW_IRQ_PIO, DW_IRQ_PIO_ID, DW_IRQ_MASK, DW_IRQ_ATTR, irq_handler);
pio_enable_interrupt(DW_IRQ_PIO, DW_IRQ_MASK);
pio_handler_set_priority(DW_IRQ_PIO, DW_IRQ_IRQ, 0);
pmc_enable_periph_clk(DW_IRQ_PIO_ID);
}
/**
* \brief Intialize Vsync_Handler.
*/
static void init_vsync_interrupts(void)
{
/* Initialize PIO interrupt handlers, see PIO definition in conf_board.h
**/
pio_handler_set(OV7740_VSYNC_PIO, OV7740_VSYNC_ID, OV7740_VSYNC_MASK,
OV7740_VSYNC_TYPE, vsync_handler);
/* Enable PIO controller IRQs */
NVIC_EnableIRQ((IRQn_Type)OV7740_VSYNC_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);
}
void ui_init(void)
{
sleepmgr_lock_mode(SLEEPMGR_SLEEP_WFI);
/* Set handler for push button */
pio_handler_set(WAKEUP_PIO, WAKEUP_PIO_ID, WAKEUP_PIO_MASK,
WAKEUP_PIO_ATTR, ui_wakeup_handler);
/* Enable IRQ for button */
NVIC_EnableIRQ((IRQn_Type) WAKEUP_PIO_ID);
/* Initialize LED */
LED_Off(LED0);
}
void ui_init(void)
{
/* Set handler for push button */
pio_handler_set(WAKEUP_PIO, WAKEUP_PIO_ID, WAKEUP_PIO_MASK,
WAKEUP_PIO_ATTR, ui_wakeup_handler);
/* Enable IRQ for button (PIOA) */
NVIC_EnableIRQ((IRQn_Type) WAKEUP_PIO_ID);
/* Initialize LEDs */
LED_Off(LED0);
LED_Off(LED1);
}
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);
}
void ui_init(void)
{
// Enable PIO clock for button inputs
pmc_enable_periph_clk(ID_PIOA);
pmc_enable_periph_clk(ID_PIOB);
// Set handler for PA15
pio_handler_set(WAKEUP_PIO, WAKEUP_PIO_ID, WAKEUP_PIO_MASK, WAKEUP_PIO_ATTR, ui_wakeup_handler);
// Enable IRQ for button (PIOA)
NVIC_EnableIRQ((IRQn_Type) WAKEUP_PIO_ID);
// Initialize LEDs
LED_On(LED0_GPIO);
LED_Off(LED1_GPIO);
}
/**
* \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);
}
int initMPU60X0(void)
{
twi_options_t twi_options;
twi_options.master_clk = BOARD_MCK;
twi_options.speed = MPU60X0_SPEED;
twi_options.chip = MPU60X0_BASE_ADDRESS;
// Enable External Interrupt Controller Line.
// Enable interrupts with priority higher than USB.
pio_set_input(PIOA, MPU60X0_BODY_INT_PIN, MPU60X0_BODY_INT_FUNCTION);
pio_configure_interrupt(PIOA, MPU60X0_BODY_INT_PIN, MPU60X0_BODY_INT_FUNCTION);
pio_handler_set(PIOA, ID_PIOA, MPU60X0_BODY_INT_PIN, PIO_IT_RISE_EDGE, MPU60X0BodyInterrupt);
pio_set_input(PIOA, MPU60X0_HEAD_INT_PIN, MPU60X0_HEAD_INT_FUNCTION);
pio_configure_interrupt(PIOA, MPU60X0_HEAD_INT_PIN, MPU60X0_HEAD_INT_FUNCTION);
pio_handler_set(PIOA, ID_PIOA, MPU60X0_HEAD_INT_PIN, PIO_IT_RISE_EDGE, MPU60X0HeadInterrupt);
NVIC_EnableIRQ(PIOA_IRQn);
pio_enable_interrupt(PIOA, MPU60X0_BODY_INT_PIN);
pio_enable_interrupt(PIOA, MPU60X0_HEAD_INT_PIN);
// Initialize TWI driver with options.
if (TWI_SUCCESS != twi_master_init(TWI0, &twi_options))
{
// Disable the interrupts.
pio_disable_interrupt(PIOA, MPU60X0_BODY_INT_PIN);
pio_disable_interrupt(PIOA, MPU60X0_HEAD_INT_PIN);
return(-1);
}
// Enable both RX and TX
TWI0->TWI_IER = TWI_IER_TXRDY | TWI_IER_RXRDY;
return(0);
}
/**
* \name Main user interface functions
* @{
*/
void ui_init(void)
{
/* Enable PIO clock for button inputs */
pmc_enable_periph_clk(RESUME_PIO_ID);
pmc_enable_periph_clk(ID_PIOA);
/* Set handler for wakeup */
pio_handler_set(RESUME_PIO, RESUME_PIO_ID, RESUME_PIO_MASK,
RESUME_PIO_ATTR, ui_wakeup_handler);
/* Enable IRQ for button (PIOB) */
NVIC_EnableIRQ((IRQn_Type)RESUME_PIO_ID);
pio_configure_pin(RESUME_PIN, RESUME_PIO_ATTR);
/* Initialize LEDs */
LED_Off(LED0);
}
/**
* \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 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 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.
*/
void Mifi_ConfigInt(void)
{
/* Configure PIO clock. */
//pmc_enable_periph_clk(CC1101_INT_ID);
/* Adjust pio debounce filter parameters, uses 10 Hz filter. */
//pio_set_debounce_filter(CC1101_INT_PIO, CC1101_INT_PIN_MSK, 10);
/* Initialize pios interrupt handlers, see PIO definition in board.h. */
pio_handler_set(CC1101_GPIO0_PIO, CC1101_INT_ID, CC1101_GPIO0,
CC1101_INT_ATTR, button_handler);
/* Enable PIO controller IRQs. */
NVIC_EnableIRQ((IRQn_Type)CC1101_INT_ID);
/* Enable PIO line interrupts. */
pio_enable_interrupt(CC1101_GPIO0_PIO, CC1101_GPIO0);
}
/**
* \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 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);
}
/**
* \name Main user interface functions
* @{
*/
void ui_init(void)
{
/* Enable PIO clock for button inputs */
pmc_enable_periph_clk(ID_PIOB);
pmc_enable_periph_clk(ID_PIOE);
/* Set handler for wakeup */
pio_handler_set(RESUME_PIO, RESUME_PIO_ID, RESUME_PIO_MASK,
RESUME_PIO_ATTR, ui_wakeup_handler);
/* Enable IRQ for button (PIOB) */
NVIC_EnableIRQ((IRQn_Type)RESUME_PIO_ID);
/* Enable interrupt for button pin */
pio_get_interrupt_status(RESUME_PIO);
pio_configure_pin(RESUME_PIN, RESUME_PIO_ATTR);
pio_enable_pin_interrupt(RESUME_PIN);
/* Enable fastwakeup for button pin */
pmc_set_fast_startup_input(RESUME_PMC_FSTT);
/* Initialize LEDs */
LED_Off(LED0_GPIO);
LED_Off(LED1_GPIO);
LED_Off(LED2_GPIO);
LED_Off(LED3_GPIO);
}
int main (void)
{
/* Insert system clock initialization code here (sysclk_init()). */
sysclk_init();
board_init();
/* Insert application code here, after the board has been initialized. */
if (SysTick_Config(sysclk_get_cpu_hz() / 1000)) {
puts("-E- Systick configuration error\r");
while (1) {
/* Capture error */
gpio_set_pin_low(LED2_GPIO);
}
}
config_lcd();
pmc_enable_periph_clk(ID_ENC);
//Interrupt for A:
pio_set_input(PIOA, GPIO_A, PIO_DEFAULT);
pio_pull_down(PIOA, GPIO_A, ENABLE);
pio_handler_set(PIOA, ID_ENC, GPIO_A, PIO_IT_RISE_EDGE, pin_handler);
pio_enable_interrupt(PIOA, GPIO_A);
//Interrupt for B:
pio_set_input(PIOA, GPIO_B, PIO_DEFAULT);
pio_pull_down(PIOA, GPIO_B, ENABLE);
pio_handler_set(PIOA, ID_ENC, GPIO_B, PIO_IT_RISE_EDGE, pin_handler);
pio_enable_interrupt(PIOA, GPIO_B);
//Interrupt for C:
pio_set_input(PIOA, GPIO_C, PIO_DEFAULT);
pio_pull_down(PIOA, GPIO_C, ENABLE);
//pio_handler_set(PIOA, ID_ENC, GPIO_C, PIO_IT_RISE_EDGE, pin_handler);
pio_handler_set(PIOA, ID_ENC, GPIO_C, PIO_IT_FALL_EDGE, pin_handler);
pio_enable_interrupt(PIOA, GPIO_C);
//Enable Interrupt GPIO:
NVIC_DisableIRQ(PIOA_IRQn);
NVIC_ClearPendingIRQ(PIOA_IRQn);
NVIC_SetPriority(PIOA_IRQn, 0);
NVIC_EnableIRQ(PIOA_IRQn);
ili9225_set_foreground_color(COLOR_BLACK);
ili9225_draw_string(10,10, (uint8_t *)"Encoder Test");
while (1){
ili9225_set_foreground_color(COLOR_WHITE);
ili9225_draw_filled_rectangle(0,30,ILI9225_LCD_WIDTH,ILI9225_LCD_HEIGHT);
ili9225_set_foreground_color(COLOR_BLACK);
graus = ((float)round/ENC_RES)*VOLTA_COMP;
snprintf(buf, sizeof(buf), "Graus:%.3f", graus );
ili9225_draw_string(10,50, buf);
snprintf(buf, sizeof(buf), "Round:%d", round );
ili9225_draw_string(10,80, buf);
mdelay(500);
}
}
