static void irq_port0_line3(void) { // print_dbg("\r\n interrupt on port0_line3"); //SW_F0 if(gpio_get_pin_interrupt_flag(SW0_PIN)) { gpio_clear_pin_interrupt_flag(SW0_PIN); /// process_sw() will post an event, which calls cpu_irq_disable(). /// apparently, this also clears the GPIO interrupt flags /// so clear the flag first to avoid triggering an infinite series of interrupts. /// this might be problematic if we were expecting faster interrupts from switches, /// but hardware pre-filtering should preclude this. process_sw(0); } // SW_F1 if(gpio_get_pin_interrupt_flag(SW1_PIN)) { gpio_clear_pin_interrupt_flag(SW1_PIN); process_sw(1); } // SW_F2 if(gpio_get_pin_interrupt_flag(SW2_PIN)) { gpio_clear_pin_interrupt_flag(SW2_PIN); process_sw(2); } // SW_F3 if(gpio_get_pin_interrupt_flag(SW3_PIN)) { gpio_clear_pin_interrupt_flag(SW3_PIN); process_sw(3); } // SW_MODE if(gpio_get_pin_interrupt_flag(SW_MODE_PIN)) { gpio_clear_pin_interrupt_flag(SW_MODE_PIN); process_sw(4); } }
static void irq_port1_line1(void) { // print_dbg("\r\ninterrupt on PB08-PB15."); // clock norm // if(gpio_get_pin_interrupt_flag(B10)) { // static event_t e; // e.type = kEventTrNormal; // e.data = !gpio_get_pin_value(B10); // event_post(&e); // gpio_clear_pin_interrupt_flag(B10); // } // clock in if(gpio_get_pin_interrupt_flag(B08)) { static event_t e; e.type = kEventTr; e.data = gpio_get_pin_value(B08); event_post(&e); gpio_clear_pin_interrupt_flag(B08); } // tr in if(gpio_get_pin_interrupt_flag(B09)) { static event_t e; e.type = kEventTr; e.data = gpio_get_pin_value(B09) + 2; event_post(&e); gpio_clear_pin_interrupt_flag(B09); } }
static void irq_port1_line1(void) { // print_dbg("\r\ninterrupt on PB08-PB15."); // static event_t e; // e.type = kSwitchEvents[swIdx]; // e.data = gpio_get_pin_value(kSwitchPins[swIdx]); // event_post(&e); // clock norm if(gpio_get_pin_interrupt_flag(B09)) { static event_t e; e.type = kEventClockNormal; e.data = !gpio_get_pin_value(B09); event_post(&e); gpio_clear_pin_interrupt_flag(B09); } // clock in if(gpio_get_pin_interrupt_flag(B08)) { // CLOCK BOUNCY WITHOUT THESE PRINTS // print_dbg("\rclk: "); // print_dbg_ulong(gpio_get_pin_value(B08)); // (*clock_pulse)(gpio_get_pin_value(B08)); static event_t e; e.type = kEventClockExt; e.data = gpio_get_pin_value(B08); event_post(&e); gpio_clear_pin_interrupt_flag(B08); } }
static void irq_port1_line3(void) { // print_dbg("\r\n irq_port1_line3"); if(gpio_get_pin_interrupt_flag(FS0_PIN)) { gpio_clear_pin_interrupt_flag(FS0_PIN); process_sw(6); } if(gpio_get_pin_interrupt_flag(FS1_PIN)) { gpio_clear_pin_interrupt_flag(FS1_PIN); process_sw(7); } }
static void irq_port1_line1(void) { // print_dbg("\r\b\interrupt on PB08-PB15."); // ENC3_0 if(gpio_get_pin_interrupt_flag(ENC3_S0_PIN)) { process_enc(3); gpio_clear_pin_interrupt_flag(ENC3_S0_PIN); } // ENC3_1 if(gpio_get_pin_interrupt_flag(ENC3_S1_PIN)) { process_enc(3); gpio_clear_pin_interrupt_flag(ENC3_S1_PIN); } }
/*! \internal Sensor Board GPIO interrupt handler * * This is the default ISR for the Xplained Sensor board GPIO pins. If * an external interrupt interface is available, the corresponding * eic_pinX_handler will be used instead. * * \return Nothing. */ ISR(gpio_irq_handler, AVR32_GPIO_IRQ_GROUP, GPIO_INT_LVL) { if (gpio_get_pin_interrupt_flag(SENSOR_BOARD_PIN3)) { sensor_pin3_handler(sensor_pin3_arg); gpio_clear_pin_interrupt_flag(SENSOR_BOARD_PIN3); } else if (gpio_get_pin_interrupt_flag(SENSOR_BOARD_PIN4)) { sensor_pin4_handler(sensor_pin4_arg); gpio_clear_pin_interrupt_flag(SENSOR_BOARD_PIN4); } else if (gpio_get_pin_interrupt_flag(SENSOR_BOARD_PIN5)) { sensor_pin5_handler(sensor_pin5_arg); gpio_clear_pin_interrupt_flag(SENSOR_BOARD_PIN5); } }
__interrupt #endif static void dip204_example_Joy_int_handler(void) { if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_UP)) { dip204_set_cursor_position(19,1); dip204_write_data(0xDE); display = 1; /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_UP); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_DOWN)) { dip204_set_cursor_position(19,3); dip204_write_data(0xE0); display = 1; /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_DOWN); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_LEFT)) { dip204_set_cursor_position(18,2); dip204_write_data(0xE1); display = 1; /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_LEFT); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT)) { dip204_set_cursor_position(20,2); dip204_write_data(0xDF); display = 1; /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_PUSH)) { dip204_set_cursor_position(19,2); dip204_write_data(0xBB); dip204_set_cursor_position(1,4); dip204_write_string(" AT32UC3A Series "); display = 1; /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_PUSH); } }
static void irq_port1_line2(void) { // print_dbg("\r\n interrupt on pb16-pb23 : "); //SW_POWER if(gpio_get_pin_interrupt_flag(SW_POWER_PIN)) { gpio_clear_pin_interrupt_flag(SW_POWER_PIN); process_sw(5); } }
static void interrupt_J3(void) { if ((gpio_get_pin_interrupt_flag(TEST_A))){ gpio_clear_pin_interrupt_flag(TEST_A); A = true; } if ((gpio_get_pin_interrupt_flag(TEST_B))){ gpio_clear_pin_interrupt_flag(TEST_B); B = true; } if ((gpio_get_pin_interrupt_flag(TEST_C))){ gpio_clear_pin_interrupt_flag(TEST_C); C = true; } }
static void irq_port0_line1(void) { if(gpio_get_pin_interrupt_flag(NMI)) { gpio_clear_pin_interrupt_flag(NMI); // print_dbg("\r\n ### NMI ### "); static event_t e; e.type = kEventFront; e.data = gpio_get_pin_value(NMI); event_post(&e); } }
__interrupt #endif static void dip204_example_PB_int_handler(void) { unsigned short i; /* display all available chars */ if (gpio_get_pin_interrupt_flag(GPIO_CHARSET)) { /* go to first column of 4th line */ dip204_set_cursor_position(1,4); /* display 20 chars of charmap */ for (i = current_char; i < current_char + 0x10; i++) { dip204_write_data(i); } dip204_write_string(" "); /* mark position in charmap */ current_char = i; /* reset marker */ if (current_char >= 0xFF) { current_char = 0x10; } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_CHARSET); } /* increase backlight power */ if (gpio_get_pin_interrupt_flag(GPIO_BACKLIGHT_PLUS)) { dip204_set_backlight(backlight_power_increase); /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_BACKLIGHT_PLUS); } /* decrease backlight power */ if (gpio_get_pin_interrupt_flag(GPIO_BACKLIGHT_MINUS)) { dip204_set_backlight(backlight_power_decrease); /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_BACKLIGHT_MINUS); } }
static void interrupt_J3(void) { if (gpio_get_pin_interrupt_flag(TEST_A)){ A_FLAG = true; gpio_clear_pin_interrupt_flag(TEST_A); } else if(gpio_get_pin_interrupt_flag(TEST_B)){ B_FLAG = true; gpio_clear_pin_interrupt_flag(TEST_B); } else if(gpio_get_pin_interrupt_flag(TEST_C)){ C_FLAG = true; gpio_clear_pin_interrupt_flag(TEST_C); } }
__interrupt #endif void at42qt1060_detect_int_handler(void) { if(gpio_get_pin_interrupt_flag(AT42QT1060_DETECT_PIN)) { gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN); if(at42qt1060.touch_detect_callback) at42qt1060.touch_detect_callback(); } }
static portBASE_TYPE prvpushb_ISR_NonNakedBehaviour( void ) { if (gpio_get_pin_interrupt_flag(GPIO_PUSH_BUTTON_0)) { // set the flag bSendMail = pdTRUE; // allow new interrupt : clear the IFR flag gpio_clear_pin_interrupt_flag(GPIO_PUSH_BUTTON_0); } // no context switch required, task is polling the flag return( pdFALSE ); }
static void irq_port1_line0(void) { // print_dbg("\r\b\interrupt on PB00-PB07."); // ENC0_0 if(gpio_get_pin_interrupt_flag(ENC0_S0_PIN)) { process_enc(0); gpio_clear_pin_interrupt_flag(ENC0_S0_PIN); } // ENC0_1 if(gpio_get_pin_interrupt_flag(ENC0_S1_PIN)) { process_enc(0); gpio_clear_pin_interrupt_flag(ENC0_S1_PIN); } // ENC1_0 if(gpio_get_pin_interrupt_flag(ENC1_S0_PIN)) { process_enc(1); gpio_clear_pin_interrupt_flag(ENC1_S0_PIN); } // ENC1_1 if(gpio_get_pin_interrupt_flag(ENC1_S1_PIN)) { process_enc(1); gpio_clear_pin_interrupt_flag(ENC1_S1_PIN); } // ENC2_0 if(gpio_get_pin_interrupt_flag(ENC2_S0_PIN)) { process_enc(2); gpio_clear_pin_interrupt_flag(ENC2_S0_PIN); } // ENC2_1 if(gpio_get_pin_interrupt_flag(ENC2_S1_PIN)) { process_enc(2); gpio_clear_pin_interrupt_flag(ENC2_S1_PIN); } }
static inline void manage_button_isr(int pin, enum joystick_status_t status_pressed, enum joystick_status_t status_released) { if (gpio_get_pin_interrupt_flag(pin)) { // Clear current pin status joystick_status &= ~(status_pressed | status_released); if (gpio_get_pin_value(pin)) joystick_status |= status_pressed; else joystick_status |= status_released; gpio_clear_pin_interrupt_flag(pin); } }
__interrupt #endif #if(INT_MODE == INT_MODE_GPIO) void touch_button_isr(void){ // UP if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_0)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_0); gpio_tgl_gpio_pin(LED0_GPIO); } // DOWN if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_1)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_1); gpio_tgl_gpio_pin(LED1_GPIO); } // Right if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_2)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_2); gpio_tgl_gpio_pin(LED2_GPIO); } // Left if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_3)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_3); gpio_tgl_gpio_pin(LED3_GPIO); } // Push if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_4)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_4); gpio_tgl_gpio_pin(LED0_GPIO); } }
__interrupt #endif void push_button_interrupt_handler(void) { if (gpio_get_pin_interrupt_flag(GPIO_PUSH_BUTTON_1)) { // Switch to next state based on current state switch (state_indicator) { case STATE_1: state_indicator = STATE_2; break; case STATE_2: state_indicator = STATE_1; break; } // Set run_once variable to true run_once = TRUE; // Clear interrupt flag to allow new interrupts gpio_clear_pin_interrupt_flag(GPIO_PUSH_BUTTON_1); } }
void init_PWM(int velocidad, int direccion){ int auxiliar; switch(velocidad){ case 9: auxiliar = 2; break; case 8: auxiliar = 4; break; case 7: auxiliar = 6; break; case 6: auxiliar = 8; break; case 5: auxiliar = 10; break; case 4: auxiliar = 12; break; case 3: auxiliar = 14; break; case 2: auxiliar = 16; break; case 1: auxiliar = 18; break; }//SWITCH pwm_opt_t pwm_opt = { .diva = AVR32_PWM_DIVA_CLK_OFF, .divb = AVR32_PWM_DIVB_CLK_OFF, .prea = AVR32_PWM_PREA_MCK, .preb = AVR32_PWM_PREB_MCK }; avr32_pwm_channel_t pwm_channel = { .ccnt = 0 }; pwm_channel.cdty = auxiliar; /* Channel duty cycle, should be < CPRD. */ pwm_channel.cprd = 20; /* Channel period. */ pwm_channel.cupd = 0; /* Channel update is not used here. */ pwm_channel.CMR.calg = PWM_MODE_LEFT_ALIGNED; /* Channel mode. */ pwm_channel.CMR.cpol = PWM_POLARITY_LOW; /* Channel polarity. */ pwm_channel.CMR.cpd = PWM_UPDATE_DUTY; /* Not used the first time. */ pwm_channel.CMR.cpre = AVR32_PWM_CPRE_MCK_DIV_256; /* Channel prescaler. */ gpio_enable_module_pin(PWM_PIN_3, PWM_PIN_Function); gpio_enable_module_pin(PWM_PIN_1, PWM_PIN_Function); pwm_init(&pwm_opt); if(direccion == 1){//FORWARD pwm_channel_init(PWM_ID_3, &pwm_channel); pwm_start_channels(1 << PWM_ID_3); } if(direccion == 0){//REVERSE pwm_channel_init(PWM_ID_1, &pwm_channel); pwm_start_channels(1 << PWM_ID_1); } } void update_PWM(int velocidad, int direccion){ int auxiliar; switch(velocidad){ case 9: auxiliar = 2; break; case 8: auxiliar = 4; break; case 7: auxiliar = 6; break; case 6: auxiliar = 8; break; case 5: auxiliar = 10; break; case 4: auxiliar = 12; break; case 3: auxiliar = 14; break; case 2: auxiliar = 16; break; case 1: auxiliar = 18; break; }//SWITCH avr32_pwm_channel_t pwm_channel = { .ccnt = 0 }; pwm_channel.cdty = auxiliar; /* Channel duty cycle, should be < CPRD. */ pwm_channel.cprd = 20; /* Channel period. */ pwm_channel.cupd = 0; /* Channel update is not used here. */ pwm_channel.CMR.calg = PWM_MODE_LEFT_ALIGNED; /* Channel mode. */ pwm_channel.CMR.cpol = PWM_POLARITY_LOW; /* Channel polarity. */ pwm_channel.CMR.cpd = PWM_UPDATE_DUTY; /* Not used the first time. */ pwm_channel.CMR.cpre = AVR32_PWM_CPRE_MCK_DIV_256; /* Channel prescaler. */ if(direccion == 1){//FORWARD pwm_stop_channels(1<<PWM_ID_1); pwm_stop_channels(1<<PWM_ID_3); pwm_channel_init(PWM_ID_3, &pwm_channel); pwm_start_channels(1 << PWM_ID_3); } if(direccion == 0){//REVERSE pwm_stop_channels(1<<PWM_ID_1); pwm_stop_channels(1<<PWM_ID_3); pwm_channel_init(PWM_ID_1, &pwm_channel); pwm_start_channels(1 << PWM_ID_1); } bandera = 0; } static void handler_interrupt(void){ if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_UP)){ direccion = 1; gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_UP); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_DOWN)){ direccion = 0; gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_DOWN); } bandera = 1; } void init_INTC(void){ gpio_enable_pin_interrupt(GPIO_JOYSTICK_UP , GPIO_FALLING_EDGE); gpio_enable_pin_interrupt(GPIO_JOYSTICK_DOWN , GPIO_FALLING_EDGE); Disable_global_interrupt(); INTC_init_interrupts(); INTC_register_interrupt( &handler_interrupt, AVR32_GPIO_IRQ_0 + (GPIO_JOYSTICK_UP/8), AVR32_INTC_INT1); INTC_register_interrupt( &handler_interrupt, AVR32_GPIO_IRQ_0 + (GPIO_JOYSTICK_DOWN/8), AVR32_INTC_INT1); Enable_global_interrupt(); }
__attribute__ ((__interrupt__)) void tecla_lrc_isr(void){//handler teclas left, right o center if (gpio_get_pin_interrupt_flag (QT1081_TOUCH_SENSOR_LEFT)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_LEFT); //LastRectX=RectX; #if PRACTICA == 2 if (actividad==0) { while(gpio_get_pin_value(QT1081_TOUCH_SENSOR_LEFT)){ et024006_DrawFilledRect(RectX , RectY, 30, 30, BLACK);//borra la posicion pasada RectX+=2; et024006_DrawFilledRect(RectX , RectY, 30, 30, RED); delay_ms(10); } } #endif } if (gpio_get_pin_interrupt_flag (QT1081_TOUCH_SENSOR_RIGHT)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_RIGHT); //LastRectX=RectX; if (actividad != 1) { actividad = 1; //te lleva al reloj CLR_disp(); } #if PRACTICA == 2 if (actividad==0) { while(gpio_get_pin_value(QT1081_TOUCH_SENSOR_RIGHT)){ et024006_DrawFilledRect(RectX , RectY, 30, 30, BLACK);//borra la posicion pasada RectX-=2; et024006_DrawFilledRect(RectX , RectY, 30, 30, RED); delay_ms(10); } } #endif } if (gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_UP)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_UP); if (actividad==2)//cronometro { resetTimer=1; } if (actividad != 2) { actividad = 2; //te lleva al cronometro CLR_disp(); } #if PRACTICA == 2 //LastRectY=RectY; if (actividad==0) { while(gpio_get_pin_value(QT1081_TOUCH_SENSOR_UP)){ et024006_DrawFilledRect(RectX , RectY, 30, 30, BLACK);//borra la posicion pasada RectY+=2; et024006_DrawFilledRect(RectX , RectY, 30, 30, RED); delay_ms(10); } } #endif } if (gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_DOWN)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_DOWN); if (actividad !=0) { actividad = 0; //te lleva al pong CLR_disp(); } #if PRACTICA == 2 //LastRectY=RectY; if (actividad==0) { while(gpio_get_pin_value(QT1081_TOUCH_SENSOR_DOWN)){ et024006_DrawFilledRect(RectX , RectY, 30, 30, BLACK);//borra la posicion pasada RectY-=2; et024006_DrawFilledRect(RectX , RectY, 30, 30, RED); delay_ms(10); } } #endif } if (gpio_get_pin_interrupt_flag (QT1081_TOUCH_SENSOR_ENTER)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER); //LastRectX=RectX; #if PRACTICA == 2 enter=0; #endif if (actividad==2) { go^=(1<<0);//toggle al go del cronometro } if (actividad==1) { enter^=(1<<0); } } }
static portBASE_TYPE prvpushb_ISR_NonNakedBehaviour( void ) { xLogDef *pxLog; portBASE_TYPE xSwitchRequired = pdFALSE; /* depending on the push buttons */ if (gpio_get_pin_interrupt_flag(PB1_POSITION)) { /* input is pulled up, if 1 : input is not active */ if (gpio_get_pin_value(PB1_POSITION)) { b_pushb1 = PUSHB_EVENT_RELEASE; } else { b_pushb1 = PUSHB_EVENT_PRESS; if ( bAlarm1 == pdTRUE ) { // post alarm to SMTP task v_SMTP_PostFromISR("Push Button 1 Alarm", NULL); } } // Alloc and init a log. pxLog = pxdatalog_log_alloc_init_FromISR(); if( NULL != pxLog ) { // Init the id field of the log. pxLog->id = DATALOG_ID_PB1; /* set log event string */ pxLog->pcStringLog = (portCHAR *)acpc_pushb_events[b_pushb1]; /* set free function pointer */ pxLog->pfFreeStringLog = NULL; /* add the log entry */ xSwitchRequired = x_datalog_AddLogFromISR( pxLog ); } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(PB1_POSITION); } if (gpio_get_pin_interrupt_flag(PB2_POSITION)) { /* input is pulled up, if 1 : input is not active */ if (gpio_get_pin_value(PB2_POSITION)) { b_pushb2 = PUSHB_EVENT_RELEASE; } else { b_pushb2 = PUSHB_EVENT_PRESS; if ( bAlarm2 == pdTRUE ) { // post alarm to SMTP task v_SMTP_PostFromISR("Push Button 2 Alarm", NULL); } } // Alloc and init a log. pxLog = pxdatalog_log_alloc_init_FromISR(); if( NULL != pxLog ) { // Init the id field of the log. pxLog->id = DATALOG_ID_PB2; /* set log event string */ pxLog->pcStringLog = (portCHAR *)acpc_pushb_events[b_pushb2]; /* set free function pointer */ pxLog->pfFreeStringLog = NULL; /* add the log entry */ xSwitchRequired = x_datalog_AddLogFromISR( pxLog ); } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(PB2_POSITION); } if (gpio_get_pin_interrupt_flag(PB3_POSITION)) { /* input is pulled up, if 1 : input is not active */ if (gpio_get_pin_value(PB3_POSITION)) { b_pushb3 = PUSHB_EVENT_RELEASE; } else { b_pushb3 = PUSHB_EVENT_PRESS; if ( bAlarm3 == pdTRUE ) { // post alarm to SMTP task v_SMTP_PostFromISR("Push Button 3 Alarm", NULL); } } // Alloc and init a log. pxLog = pxdatalog_log_alloc_init_FromISR(); if( NULL != pxLog ) { // Init the id field of the log. pxLog->id = DATALOG_ID_PB3; /* set log event string */ pxLog->pcStringLog = (portCHAR *)acpc_pushb_events[b_pushb3]; /* set free function pointer */ pxLog->pfFreeStringLog = NULL; /* add the log entry */ xSwitchRequired = x_datalog_AddLogFromISR( pxLog ); } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(PB3_POSITION); } return( xSwitchRequired ); }
static void twi_init(U32 fpba_hz) { const gpio_map_t AT42QT1060_TWI_GPIO_MAP = { {AT42QT1060_TWI_SCL_PIN, AT42QT1060_TWI_SCL_FUNCTION}, {AT42QT1060_TWI_SDA_PIN, AT42QT1060_TWI_SDA_FUNCTION} }; const twi_options_t AT42QT1060_TWI_OPTIONS = { .pba_hz = 24000000, .speed = AT42QT1060_TWI_MASTER_SPEED, .chip = AT42QT1060_TWI_ADDRESS }; // Assign I/Os to SPI. gpio_enable_module(AT42QT1060_TWI_GPIO_MAP, sizeof(AT42QT1060_TWI_GPIO_MAP) / sizeof(AT42QT1060_TWI_GPIO_MAP[0])); // Initialize as master. twi_master_init(AT42QT1060_TWI, &AT42QT1060_TWI_OPTIONS); } /*! \brief Callback function for a detect event of the touch sensor device. */ void touch_detect_callback(void) { touch_detect = true; } struct at42qt1060_data touch_data; void controller_task(void) { // if a touch is detected we read the status if(touch_detect) { touch_data.detect_status = at42qt1060_read_reg(AT42QT1060_DETECTION_STATUS); // need to read input port status too to reset CHG line at42qt1060_read_reg(AT42QT1060_INPUT_PORT_STATUS); touch_detect = false; } } static void controller_detect_int_handler(void) { if(gpio_get_pin_interrupt_flag(AT42QT1060_DETECT_PIN)) { gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN); touch_detect_callback(); } } void controller_init(U32 fcpu_hz, U32 fhsb_hz, U32 fpbb_hz, U32 fpba_hz) { // Disable all interrupts Disable_global_interrupt(); twi_init(fpba_hz); // wait until the device settles its CHG line cpu_delay_ms(230, fcpu_hz); at42qt1060_init(fcpu_hz); BSP_INTC_IntReg(&controller_detect_int_handler, AVR32_GPIO_IRQ_0 + AT42QT1060_DETECT_PIN/8, AVR32_INTC_INT1); // For now we only react on falling edge // Actually this is a level interrupt (low active) gpio_enable_pin_interrupt(AT42QT1060_DETECT_PIN, GPIO_FALLING_EDGE); gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN); //static_fcpu_hz = fcpu_hz; cpu_set_timeout(cpu_ms_2_cy(JOYSTICK_KEY_DEBOUNCE_MS, static_fcpu_hz), &joystick_key_sensibility_timer); // Enable global interrupts Enable_global_interrupt(); }
static portBASE_TYPE prvjoystick_ISR_NonNakedBehaviour( void ) { xLogDef *pxLog; U32 u32CurrentCountValue = xTaskGetTickCount(); // Debouncing: ignore joystick events occuring in less than 250ms before the last // valid joystick event. if((( u32CurrentCountValue >= u32LastCountValue ) && ( u32CurrentCountValue - u32LastCountValue <= 250)) || (( u32CurrentCountValue < u32LastCountValue ) && ( u32CurrentCountValue + (0xFFFFFFFF - u32LastCountValue) <= 250))) { // Clear all interrupts flag (it's no use checking which event has bouncing). gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_PUSH); Clr_bits(x_joystick, JS_EVENT_PUSH); gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_LEFT); Clr_bits(x_joystick, JS_EVENT_LEFT); gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT); Clr_bits(x_joystick, JS_EVENT_RIGHT); gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_UP); Clr_bits(x_joystick, JS_EVENT_UP); gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_DOWN); Clr_bits(x_joystick, JS_EVENT_DOWN); return(pdFALSE); } else { // Update last valid joystick event timestamp. u32LastCountValue = u32CurrentCountValue; // Check all events. if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_UP)) { /* input is pulled up, if 1 : input is not active */ if (gpio_get_pin_value(GPIO_JOYSTICK_UP)) { /* clear bit UP */ Clr_bits(x_joystick, JS_EVENT_UP); } else { Set_bits(x_joystick, JS_EVENT_UP); } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_UP); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_DOWN)) { /* input is pulled up, if 1 : input is not active */ if (gpio_get_pin_value(GPIO_JOYSTICK_DOWN)) { Clr_bits(x_joystick, JS_EVENT_DOWN); } else { Set_bits(x_joystick, JS_EVENT_DOWN); } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_DOWN); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_LEFT)) { /* input is pulled up, if 1 : input is not active */ if (gpio_get_pin_value(GPIO_JOYSTICK_LEFT)) { Clr_bits(x_joystick, JS_EVENT_LEFT); } else { Set_bits(x_joystick, JS_EVENT_LEFT); #ifdef MMILCD_ENABLE vMMI_UserMenuDisplayPreviousItem(pdTRUE); #endif } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_LEFT); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT)) { /* input is pulled up, if 1 : input is not active */ if (gpio_get_pin_value(GPIO_JOYSTICK_RIGHT)) { Clr_bits(x_joystick, JS_EVENT_RIGHT); } else { Set_bits(x_joystick, JS_EVENT_RIGHT); #ifdef MMILCD_ENABLE vMMI_UserMenuDisplayNextItem(pdTRUE); #endif } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT); } if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_PUSH)) { /* input is pulled up, if 1 : input is not active */ if (gpio_get_pin_value(GPIO_JOYSTICK_PUSH)) { Clr_bits(x_joystick, JS_EVENT_PUSH); } else { Set_bits(x_joystick, JS_EVENT_PUSH); if ( bAlarm == pdTRUE ) { // post alarm to SMTP task v_SMTP_PostFromISR("Joystick Alarm", NULL); } #ifdef MMILCD_ENABLE vMMI_UserMenuValidateItem(pdTRUE); #endif } /* allow new interrupt : clear the IFR flag */ gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_PUSH); } } // Alloc and init a log. pxLog = pxdatalog_log_alloc_init_FromISR(); if( NULL == pxLog ) return( pdFALSE ); // Init the id field of the log. pxLog->id = DATALOG_ID_JS; /* set log event string */ pxLog->pcStringLog = (portCHAR *)acpc_js_events[x_joystick]; /* set free function pointer */ pxLog->pfFreeStringLog = NULL; /* add the log entry */ return( x_datalog_AddLogFromISR( pxLog ) ); }
__attribute__ ((__interrupt__)) void tecla_lrc_isr(void){//handler teclas left, right o center if (gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER); } if (gpio_get_pin_interrupt_flag (QT1081_TOUCH_SENSOR_LEFT)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_LEFT); pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP); while(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER)==0){ gpio_tgl_gpio_pin(LED3_GPIO); delay_s(50); } display(0); } if (gpio_get_pin_interrupt_flag (QT1081_TOUCH_SENSOR_RIGHT)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_RIGHT); pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP); while(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER)==0){ displayPrimo(); delay_s(50); } } if (gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_UP)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_UP); pm_switch_to_clock(&AVR32_PM,0); //cambia al RC pm_pll_disable(&AVR32_PM,0); // deshabilita el el PLL 0 pm_pll_setup(&AVR32_PM,0,2,1,0,16); // lockcount in main clock for the PLL wait lock //_______________________________________________________________________________ // Establece la frecuencia de salida del PLL pm_pll_set_option(&AVR32_PM,0,1,0,0);//1 Star-up faster, Start-up normal //_______________________________________________________________________________ //Habilita el PLL 0 pm_pll_enable(&AVR32_PM,0); //_______________________________________________________________________________ //Espera a que se establesca el PLL pm_wait_for_pll0_locked(&AVR32_PM) ; //_______________________________________________________________________________ // Set one wait-state (WS) for flash controller flashc_set_wait_state(1); //habilita la salida del PLL0 con 2 y el OSC0 con 1 pm_switch_to_clock(&AVR32_PM, 2); while (gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER)==0) { displayA1(); /*for (uint32_t j =0; j<18000; j++)//300ms 12Mhz { delay_ms(10); }*/ delay_s(50); } display(0); } if (gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_DOWN)) { gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_DOWN); pm_switch_to_clock(&AVR32_PM,0); //cambia al RC pm_pll_disable(&AVR32_PM,0); // deshabilita el el PLL 0 pm_pll_setup(&AVR32_PM,0,6,1,0,16); // lockcount in main clock for the PLL wait lock //_______________________________________________________________________________ // Establece la frecuencia de salida del PLL pm_pll_set_option(&AVR32_PM,0,1,0,0);//1 Star-up faster, Start-up normal //_______________________________________________________________________________ //Habilita el PLL 0 pm_pll_enable(&AVR32_PM,0); //_______________________________________________________________________________ //Espera a que se establesca el PLL pm_wait_for_pll0_locked(&AVR32_PM) ; //_______________________________________________________________________________ // Set one wait-state (WS) for flash controller flashc_set_wait_state(1); //habilita la salida del PLL0 con 2 y el OSC0 con 1 pm_switch_to_clock(&AVR32_PM, 2); while (gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER)==0) { displayOnOff(); } display(0); } }