void exti9_5_isr(void) { gpio_toggle(PLED, LEDGREEN0); exti_reset_request(EXTI5); exti_reset_request(EXTI6); exti_reset_request(EXTI7); exti_reset_request(EXTI8); exti_reset_request(EXTI9); }
void exti9_5_isr(void) { /* clear EXTI */ if (EXTI_PR & EXTI6) { exti_reset_request(EXTI6); imu_krooz.hmc_eoc = TRUE; } if (EXTI_PR & EXTI5) { exti_reset_request(EXTI5); imu_krooz.mpu_eoc = TRUE; } }
/* * Accel data ready */ void exti2_isr(void) { /* clear EXTI */ exti_reset_request(EXTI2); //adxl345_start_reading_data(); }
interrupt(PORT1_VECTOR) PORT1_ISR(void) { P1IFG &= ~BIT0; // Clear interrupt flag #else void exti2_isr(void) { exti_reset_request(EXTI2); // Clear interrupt flag #endif int s; // set ACK payload to next squence number ptx.data[0]++; s = nrf_write_ack_pl(&ptx, 0); if(s == NRF_ERR_TX_FULL) { cio_printf("Unable to send back ACK payload (TX_FULL)\n\r"); } // receive non-blocking since IRQ already indicates that payload arived s = nrf_receive(&prx); if(s == NRF_ERR_RX_FULL) { cio_printf("Unable to receive any more (RX_FULL)\n\r"); } else { cio_printf("Received payload: %c; sending back %u\n\r", prx.data[0], ptx.data[0]); } }
void exti0_isr(void) { //gpio_toggle(GPIOD, GPIO12); exti_reset_request(EXTI0); button=1; /* exti_reset_request(EXTI0); if (exti_direction == FALLING) { //gpio_toggle(GPIOD, GPIO13); exti_direction = RISING; exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING); V_hall_1_V1=0.0f; } else { //gpio_toggle(GPIOD, GPIO14); exti_direction = FALLING; exti_set_trigger(EXTI0, EXTI_TRIGGER_FALLING); V_hall_1_V1=3.0f; } */ }
void rtc_wkup_isr(void) { /* clear flag, not write protected */ RTC_ISR &= ~(RTC_ISR_WUTF); exti_reset_request(EXTI20); state.rtc_ticked = true; }
//Setup hardware TouchADS7843::TouchADS7843(void) { //Enable clocks rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_SPI1EN); //SPI rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN); //SPI rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN); //PEN_INT rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN); //AFIO (EXTI) //Setup GPIO gpio_set_mode(GPIOC, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BIT13); //PEN_INT gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BIT6); //MISO gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, BIT4); //CS gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, BIT5 | BIT7); //MOSI, SCK //Set up SPI as mater _cs(1); spi_enable_software_slave_management(SPI1); spi_set_nss_high(SPI1); spi_set_baudrate_prescaler(SPI1, 7); spi_set_clock_polarity_0(SPI1); spi_set_clock_phase_0(SPI1); spi_set_dff_8bit(SPI1); spi_set_master_mode(SPI1); spi_enable(SPI1); //Enable PEN_INT nvic_enable_irq(NVIC_EXTI15_10_IRQ); exti_select_source(EXTI13, GPIOC); exti_set_trigger(EXTI13, EXTI_TRIGGER_BOTH); exti_reset_request(EXTI13); exti_enable_request(EXTI13); }
void exti2_isr(void) { /* clear EXTI */ exti_reset_request(EXTI2); max1168_status = MAX1168_GOT_EOC; }
void exti9_5_isr(void) { if( R.STARTED == 1 ) { ULTRA_checkEchoOnExti(EXTI9_5); exti_reset_request(EXTI9_5); // reset flag } }
void exti4_isr(void) { exti_reset_request(EXTI4); /* Call interrupt handler */ if (hal_irq_callback) { (void)hal_irq_callback(); PRINTF("exti4_isr\r\n "); } }
/* *************** HAL API functions **************************************** */ void hal_init( void ) { int ret = 0; /* Reset variables used in file. */ hal_system_time = 0; // hal_reset_flags(); /* Enable GPIOA clock. Enable AFIO clock. */ rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPBEN | RCC_APB2ENR_IOPCEN | RCC_APB2ENR_SPI1EN | RCC_APB2ENR_AFIOEN ); /* The following pins are output pins. */ gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,RST); //reset gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,SLP_TR); //sleep gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,SEL); //cs gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, SCK | MOSI | MISO); //sck mosi miso spi_disable(RF_SPI); SPI2_I2SCFGR = 0; /* Setup SPI parameters. */ spi_init_master(RF_SPI, SPI_CR1_BAUDRATE_FPCLK_DIV_16, SPI_CR1_CPOL_CLK_TO_0_WHEN_IDLE, SPI_CR1_CPHA_CLK_TRANSITION_1, SPI_CR1_DFF_8BIT, SPI_CR1_MSBFIRST); spi_set_unidirectional_mode(RF_SPI); spi_set_full_duplex_mode(RF_SPI); /* Not receive-only */ spi_enable_software_slave_management(RF_SPI); spi_set_nss_high(RF_SPI); spi_enable_ss_output(RF_SPI); /* Required, see NSS, 25.3.1 section. */ /* Finally enable the SPI. */ spi_enable(RF_SPI); /* Set GPIO4 (in GPIO port C) to 'input float'. */ gpio_set_mode(RF_IRQ_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, RF_IRQ_PIN); gpio_clear(RF_IRQ_PORT, RF_IRQ_PIN); /* Configure the EXTI subsystem. */ exti_select_source(EXTI4, RF_IRQ_PORT); exti_set_trigger(EXTI4, EXTI_TRIGGER_RISING); exti_enable_request(EXTI4); exti_reset_request(EXTI4); PRINTF("Enabling interrupts\r\n"); /* Enable EXTI0 interrupt. */ nvic_enable_irq(NVIC_EXTI4_IRQ); nvic_set_priority(NVIC_EXTI4_IRQ,4); //@@@!? timer_init(); // ret = trx_init(); // if(ret!=0) // { // PRINTF("rf231:hal init failed\r\n"); // }else // { // PRINTF("rf231:hal init success\r\n"); // } }
/* * Gyro data ready */ void exti15_10_isr(void) { /* clear EXTI */ exti_reset_request(EXTI14); #ifdef ASPIRIN_USE_GYRO_INT imu_aspirin.gyro_eoc = TRUE; imu_aspirin.status = AspirinStatusReadingGyro; #endif }
void exti1_isr(void) { if (gpio_get(JACK_SENSE_PORT,JACK_SENSE_PIN) != 0) { speaker_shutdown(); } else { speaker_start(); } exti_reset_request(EXTI1); }
void exti0_isr() { exti_line_state = GPIOA_IDR; if ((exti_line_state & (1 << 0)) != 0) { gpio_clear(GPIOC, GPIO12); } else { gpio_set(GPIOC, GPIO12); } exti_reset_request(EXTI0); }
void exti9_5_isr(void) { rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN); rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_BKPEN); pwr_disable_backup_domain_write_protect(); BKP_DR2 = 0x4242; gpio_clear(LED3_PORT, LED3_PIN); exti_reset_request(EXTI9); }
void exti0_isr(void) { exti_line_state = GPIOA_IDR; /* The LED (PC12) is on, but turns off when the button is pressed. */ if ((exti_line_state & (1 << 0)) != 0) { gpio_clear(GPIOC, GPIO12); } else { gpio_set(GPIOC, GPIO12); } exti_reset_request(EXTI0); }
void exti0_isr() { exti_reset_request(EXTI0); if (exti_direction == FALLING) { gpio_set(GPIOC, GPIO12); exti_direction = RISING; exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING); } else { gpio_clear(GPIOC, GPIO12); exti_direction = FALLING; exti_set_trigger(EXTI0, EXTI_TRIGGER_FALLING); } }
void BUTTON_DISCO_USER_isr(void) { exti_reset_request(BUTTON_DISCO_USER_EXTI); state.pressed = true; if (state.falling) { state.falling = false; exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_RISING); state.hold_time = TIM_CNT(TIMER_BUTTON_PRESS); } else { state.falling = true; exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_FALLING); state.hold_time = TIM_CNT(TIMER_BUTTON_PRESS) = 0; } }
void exti1_isr(void) { uint8_t actExti = EXTI0; if( exti_get_flag_status(actExti) != 0) { //gpio_toggle(PLED,LEDBLUE3); if( R.STARTED == 1 ) { // the robot is already alive - button does not work! ROBOT_handleUltraEchoOnExti(EXTI1); // flag reseting is done in ULTRA_handleEcho(..) } exti_reset_request(actExti); // reset flag } }
void exti9_5_isr(void) { u16 t1 = 0; u16 t = 0; t1 = timer_get_counter(TIM1); // get the counter(TIM1) value exti_reset_request(_PWM_EXTI); // reset(clean) the IRQ t = (t1>=t0) ? (t1-t0) : (65536+t1-t0); // none-stop TIM1 counter, compute ppm-signal width (2MHz = 0.5uSecond) t0 = t1; if (!ppmSync) { // ppm-in status : not Sync /* (1) capture pmSync (for ppm-timing > MIN_PPMin_Sync : 3300uSecond) */ if (t>MIN_PPMin_Sync) { // ppm-input Sync-signal if (j<3) { // set 3-times for count total channels number, k[0], k[1], k[2] j++; // set for next count ppm-in total channels number k[j] = 0; // initial ppm-in total channels number =0 } else { // accumulate 3-times total channels number k[0], k[1], k[2] /* (2) count channels and set to "ppmin_num_channels" */ j = 0; // initial ppm-in Sync counter=0 (or missed signal) k[0] = 0; // set ppm-in signal beginning k[0]=0, ignore the first count total channels number if (k[1]>1 && k[1]==k[2]) { // compare total channels number k[1], k[2] ppmin_num_channels = k[1]; // save number of channels found ppmSync = 1; // in-sync i = 0; } } } else { // t<MIN_PPMin_Sync, ppm-input each Channel-signal k[j]++; // conut 3-times for total channels number, k[0], k[1], k[2]. // ignore the first count total channels number k[0] } } else { // ppm-in status : Sync, /* (3) get each channel value and set to "Channel[i]" , [0...ppmin_num_channels-1] for each Channel-signal */ int ch = (t - (Model.ppmin_centerpw * 2))*10000 / (Model.ppmin_deltapw * 2); //Convert input to channel value ppmChannels[i] = ch; i++; // set for next count ppm-signal width /* (4) continue count channels and compare "num_channels", if not equal => disconnect(no-Sync) and re-connect (re-Sync) */ if (t>MIN_PPMin_Sync) { // Got the ppm-input Sync-signal if ((i-1) != ppmin_num_channels) { // Trainer disconnect (coach-trainee disconnect or noise) ppmSync = 0; // set ppm-in status to "Not Sync" } i = 0; // initial counter for capture next period } } }
void BUTTON_DISCO_USER_isr(void) { exti_reset_request(BUTTON_DISCO_USER_EXTI); if (state.falling) { gpio_clear(LED_DISCO_BLUE_PORT, LED_DISCO_BLUE_PIN); state.falling = false; exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_RISING); unsigned int x = TIM_CNT(TIM7); printf("held: %u ms\n", x); } else { gpio_set(LED_DISCO_BLUE_PORT, LED_DISCO_BLUE_PIN); printf("Pushed down!\n"); TIM_CNT(TIM7) = 0; state.falling = true; exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_FALLING); } }
void RHT_isr(void) { exti_reset_request(RHT_EXTI); int cnt = TIM7_CNT; TIM7_CNT = 0; // Skip catching ourself pulsing the start line until the 150uS start. if (!state.seen_startbit) { if (cnt < RHT_LOW_HIGH_THRESHOLD) { return; } else { state.seen_startbit = true; } } if (state.bitcount > 0) { // but skip that start bit... stuff_bit(state.bitcount - 1, cnt, state.rht_bytes); } state.bitcount++; }
//____________________________________________________ // interrupts request handlers = interrupt handler functions void exti0_isr(void) { // btnStart was pressed or ultraL triggered uint8_t actExti = EXTI0; if( exti_get_flag_status(actExti) != 0) { // btn and ultra if( R.STARTED == 0 ) { R.STARTED = 1; } else { // the robot is already alive - button does not work! ROBOT_handleUltraEchoOnExti(actExti); } exti_reset_request(actExti); // reset flag } }
void exti0_isr(void) { exti_reset_request(EXTI0); button=1; /* if (exti_direction == FALLING) { //gpio_toggle(GPIOD, GPIO13); exti_direction = RISING; exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING); } else { //gpio_toggle(GPIOD, GPIO13); exti_direction = FALLING; exti_set_trigger(EXTI0, EXTI_TRIGGER_FALLING); //timer_generate_event(TIM1, TIM_EGR_COMG); //capture compare event //timer_generate_event(TIM1, TIM_EGR_UG); }*/ }
void exti15_10_isr(void) { exti_reset_request(EXTI13); }
void exti0_isr(void) { exti_reset_request(EXTI0); simrf_interrupt_handler(); }
void exti9_5_isr(void) { exti_reset_request(EXTI5); }
// CTS RISING ISR void exti15_10_isr(void){ exti_reset_request(EXTI13); (*cts_irq_handler)(); }
void BTN_BIND_ISR(void) { exti_reset_request(BTN_BIND_EXTI); if (button_pressed_bind != NULL) button_pressed_bind(); }
void exti3_isr(void) { int i, j; uint16_t endFillByte; gpio_set(GREEN_LED_PORT, GREEN_LED_PIN); // gpio_set(RED_LED_PORT, RED_LED_PIN); // iprintf("fill bytes\r\n"); exti_reset_request(EXTI3); iprintf("exti3_isr\r\n"); if(media_file.buffer_ready[media_file.active_buffer] == 0) { iprintf("Buffer %d was ready...\r\n", media_file.active_buffer); while(gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) { // iprintf("loop\r\n"); gpio_set(CODEC_PORT, CODEC_CS); if(!media_file.near_end) { for(i=0;i<32;i++) { spi_xfer(CODEC_SPI, media_file.buffer[media_file.active_buffer][current_track.byte_count++]); } if((current_track.byte_count % 512) == 0) { gpio_clear(CODEC_PORT, CODEC_CS); } if(current_track.byte_count == MEDIA_BUFFER_SIZE) { // iprintf("reading\r\n"); sdfat_read_media(); current_track.byte_count = 0; gpio_clear(CODEC_PORT, CODEC_CS); // iprintf("swapping...\r\n"); /* fetch the value of current decode position */ vs1053_SCI_write(SCI_WRAMADDR, PARAM_POSITION_LO); for(i=0;i<150;i++) {__asm__("nop\n\t");} current_track.pos = vs1053_SCI_read(SCI_WRAM); for(i=0;i<150;i++) {__asm__("nop\n\t");} vs1053_SCI_write(SCI_WRAMADDR, PARAM_POSITION_HI); for(i=0;i<150;i++) {__asm__("nop\n\t");} current_track.pos += vs1053_SCI_read(SCI_WRAM) << 16; // iprintf("swap\r\n"); gpio_set(CODEC_PORT, CODEC_CS); while(media_file.buffer_ready[media_file.active_buffer]) {__asm__("nop\n\t");} // iprintf("Breaking out\r\n"); // break; // } } } else { for(i=0;i<32;i++) { if(current_track.byte_count > media_file.file_end) { iprintf("ending\r\n"); // Ought to do this next bit by issuing a player_stop job so that the cleanup code // is all in one place and we can power down everything automatically for power saving /* now need to clean up the fifos and stop the player */ gpio_clear(CODEC_PORT, CODEC_CS); /* fetch the value of endFillByte */ vs1053_SCI_write(SCI_WRAMADDR, PARAM_END_FILL_BYTE); while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");} endFillByte = vs1053_SCI_read(SCI_WRAM) & 0xFF; iprintf("End Fill Byte %02X\r\n", endFillByte); gpio_set(CODEC_PORT, CODEC_CS); for(i=0;i<65;i++) { while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");} for(j=0;j<32;j++) { spi_xfer(CODEC_SPI, endFillByte); } } gpio_clear(CODEC_PORT, CODEC_CS); i = vs1053_SCI_read(SCI_MODE); i |= SM_CANCEL; vs1053_SCI_write(SCI_MODE, i); gpio_set(CODEC_PORT, CODEC_CS); j = 0; while(j < 2048) { while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");} for(i=0;i<32;i++) { spi_xfer(CODEC_SPI, endFillByte); } j += 32; if(!(vs1053_SCI_read(SCI_MODE) & SM_CANCEL)) { break; } } gpio_clear(CODEC_PORT, CODEC_CS); if(j >= 2048) { /* need to do a software reset */ vs1053_SCI_write(SCI_MODE, SM_RESET); } iprintf("End Fill Byte %02X\r\n", endFillByte); current_track_playing = 0; exti_reset_request(EXTI3); exti_disable_request(EXTI3); nvic_disable_irq(NVIC_EXTI3_IRQ); return; } else { spi_xfer(CODEC_SPI, media_file.buffer[media_file.active_buffer][current_track.byte_count++]); } } } } } gpio_clear(GREEN_LED_PORT, GREEN_LED_PIN); }