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); } }