void UART4_IRQHandler(void) { #ifdef RT_USING_UART4 extern struct rt_device uart4_device; extern void rt_hw_serial_isr(struct rt_device *device); u8 data=0; /* enter interrupt */ rt_interrupt_enter(); // rt_hw_serial_isr(&uart4_device); if (USART_GetITStatus(UART4, USART_IT_RXNE) != RESET) { data = USART_ReceiveData(UART4) & 0xFF; GSM_RxHandler(data); USART_ClearITPendingBit(UART4, USART_IT_RXNE); } /* leave interrupt */ rt_interrupt_leave(); #endif }
void UART2_IRQHandler(void) { struct mm32_uart *uart; uart = &uart2; /* enter interrupt */ rt_interrupt_enter(); if (UART_GetITStatus(uart->uart_device, UART_IT_RXIEN) != RESET) { UART_ClearITPendingBit(uart->uart_device, UART_IT_RXIEN); rt_hw_serial_isr(&serial2, RT_SERIAL_EVENT_RX_IND); } if (UART_GetITStatus(uart->uart, UART_IT_TXIEN) != RESET) { /* clear interrupt */ UART_ClearITPendingBit(uart->uart, UART_IT_TXIEN); } /* leave interrupt */ rt_interrupt_leave(); }
/******************************************************************************* * Function Name : TIM4_IRQHandler * Description : This function handles TIM3 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void TIM4_IRQHandler(void) { static uint8_t cnt1 = 0; // static uint8_t cnt2 = 0; /* enter interrupt */ rt_interrupt_enter(); TIM_ClearITPendingBit(BSP_TIM, TIM_IT_Update); if((cnt1++ % 5) == 0) { rt_sem_release(&sem_adio_task); // Bsp_can_send_cycle_event(); } Bsp_can_send_cycle_event(); /* leave interrupt */ rt_interrupt_leave(); }
void USART3_IRQHandler(void) { struct stm32_uart *uart; uart = &uart3; /* enter interrupt */ rt_interrupt_enter(); /* UART in mode Receiver ---------------------------------------------------*/ if ((__HAL_UART_GET_IT(&uart->UartHandle, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&uart->UartHandle, UART_IT_RXNE) != RESET)) { rt_hw_serial_isr(&serial3, RT_SERIAL_EVENT_RX_IND); /* Clear RXNE interrupt flag */ __HAL_UART_SEND_REQ(&uart->UartHandle, UART_RXDATA_FLUSH_REQUEST); } /* leave interrupt */ rt_interrupt_leave(); }
/** * @} */ void RTC_IRQHandler(void) { static int delay_cnt; struct rtgui_event_command ecmd; /* enter interrupt */ rt_interrupt_enter(); ++rtc_1s_int_cnt; #if 1 == LCD_TEST_MALOOEI rt_kprintf("rtc:%d\n", rtc_1s_int_cnt); #endif if (delay_cnt < 1) { ++delay_cnt; goto ret_entry; } if (NULL == wb_thread) goto ret_entry; if (RTC_GetITStatus(RTC_IT_SEC) != RESET) { RTGUI_EVENT_COMMAND_INIT(&ecmd); ecmd.command_id = UPDATE_SYS_TIME; if (RT_EOK != rtgui_thread_send(wb_thread, &ecmd.parent, sizeof(struct rtgui_event_command))) rt_kprintf("[RTC_IRQHandler]send enent cmd fail\n"); } #if 0 if(RTC_GetFlagStatus(RTC_FLAG_ALR) != RESET) { } else { } #endif ret_entry: RTC_ClearITPendingBit(RTC_IT_ALR | RTC_IT_SEC); /* leave interrupt */ rt_interrupt_leave(); return; }
void UART5_IRQHandler( void ) { uint8_t ch; rt_interrupt_enter( ); if( USART_GetITStatus( UART5, USART_IT_RXNE ) != RESET ) { ch = USART_ReceiveData( UART5 ); if( ( ch == 0x0a ) && ( last_ch == 0x0d ) ) /*遇到0d 0a 表明结束*/ { uart5_rxbuf.body[uart5_rxbuf.wr++] = ch; if( uart5_rxbuf.wr < 124 ) { //--------- fliter useful------ if((strncmp((char *)uart5_rxbuf.body + 3, "RMC,", 4) == 0) || (strncmp((char *)uart5_rxbuf.body + 3, "TXT,", 4) == 0) || \ (strncmp((char *)uart5_rxbuf.body + 3, "GGA,", 4) == 0)) //||(strncmp((char*)uart5_rxbuf.body+3,"GSA,",4)==0)) { rt_mq_send( &mq_gps, (void *)&uart5_rxbuf, uart5_rxbuf.wr + 2 ); } } uart5_rxbuf.wr = 0; } else { // 1. get head char if(ch == '$') uart5_rxbuf.wr = 0; // 2. judge head char if(uart5_rxbuf.body[0] != '$') // add later uart5_rxbuf.wr = 0; // 3. rx data uart5_rxbuf.body[uart5_rxbuf.wr++] = ch; if( uart5_rxbuf.wr == UART5_RX_SIZE ) { uart5_rxbuf.wr = 0; } uart5_rxbuf.body[uart5_rxbuf.wr] = 0; } last_ch = ch; USART_ClearITPendingBit( UART5, USART_IT_RXNE ); } rt_interrupt_leave( ); }
void DMA1_Stream0_IRQHandler(void) //I2C1 RX { rt_interrupt_enter(); if (DMA_GetITStatus(I2C1_DMA_CHANNEL_RX, DMA_IT_TCIF0)) { I2C_TRACE("RXTC\n"); /* clear DMA flag */ DMA_ClearFlag(I2C1_DMA_CHANNEL_RX, DMA_FLAG_TCIF0 ); DMA_ITConfig( I2C1_DMA_CHANNEL_RX, DMA_IT_TC, DISABLE); DMA_Cmd(I2C1_DMA_CHANNEL_RX, DISABLE); if( i2cStatus == S6 ) { i2cStatus = S_STOP; I2C1->CR1 |= CR1_STOP_Set; rt_event_send(&i2c_event, I2C_COMPLETE); } } if (DMA_GetITStatus(I2C1_DMA_CHANNEL_RX, DMA_IT_HTIF0)) { I2C_TRACE("RXHT\n"); DMA_ClearFlag(I2C1_DMA_CHANNEL_RX, DMA_FLAG_HTIF0 ); } if (DMA_GetITStatus(I2C1_DMA_CHANNEL_RX, DMA_IT_TEIF0)) { I2C_TRACE("RXTE\n"); DMA_ClearFlag(I2C1_DMA_CHANNEL_RX, DMA_FLAG_TEIF0 ); } if (DMA_GetITStatus(I2C1_DMA_CHANNEL_RX, DMA_IT_FEIF0)) { I2C_TRACE("RXFE\n"); DMA_ClearFlag(I2C1_DMA_CHANNEL_RX, DMA_FLAG_FEIF0 ); } if (DMA_GetITStatus(I2C1_DMA_CHANNEL_RX, DMA_IT_DMEIF0)) { I2C_TRACE("RXDME\n"); DMA_ClearFlag(I2C1_DMA_CHANNEL_RX, DMA_FLAG_DMEIF0 ); } rt_interrupt_leave(); }
void UART2_IRQHandler(void) { struct lpc_uart *uart; uint32_t intsrc, temp; uart = &uart2; /* enter interrupt */ rt_interrupt_enter(); /* Determine the interrupt source */ intsrc = uart->USART->IIR & UART_IIR_INTID_MASK; switch (intsrc) { case UART_IIR_INTID_RLS: /* Receive Line Status interrupt*/ /* read the line status */ intsrc = uart->USART->LSR; /* Receive an error data */ if (intsrc & UART_LSR_PE) { temp = LPC_USART0->RBR; } break; case UART_IIR_INTID_RDA: /* Receive data */ case UART_IIR_INTID_CTI: /* Receive data timeout */ /* read the data to buffer */ while (uart->USART->LSR & UART_LSR_RDR) { rt_hw_serial_isr(&serial0, RT_SERIAL_EVENT_RX_IND); } break; default: break; } /* leave interrupt */ rt_interrupt_leave(); }
/*********************************************************** * Function: * Description: uart4的中断服务函数 * Input: * Input: * Output: * Return: * Others: ***********************************************************/ void UART4_IRQHandler( void ) { rt_interrupt_enter( ); if( USART_GetITStatus( UART4, USART_IT_RXNE ) != RESET ) { rt_ringbuffer_putchar( &rb_uart4_rx, USART_ReceiveData( UART4 ) ); USART_ClearITPendingBit( UART4, USART_IT_RXNE ); //rt_sem_release( &sem_uart ); last_tick = rt_tick_get( ); } /* if (USART_GetITStatus(UART4, USART_IT_TC) != RESET) { USART_ClearITPendingBit(UART4, USART_IT_TC); } */ rt_interrupt_leave( ); }
/*********************************************************** * Function: * Description: uart4的中断服务函数 * Input: * Input: * Output: * Return: * Others: ***********************************************************/ void UART4_IRQHandler( void ) { rt_interrupt_enter( ); if( USART_GetITStatus( UART4, USART_IT_RXNE ) != RESET ) { uart4_rxbuf[uart4_rxbuf_wr++] = USART_ReceiveData( UART4 ); uart4_rxbuf_wr %= UART4_RX_SIZE; USART_ClearITPendingBit( UART4, USART_IT_RXNE ); last_tick = rt_tick_get( ); } /* if (USART_GetITStatus(UART4, USART_IT_TC) != RESET) { USART_ClearITPendingBit(UART4, USART_IT_TC); } */ rt_interrupt_leave( ); }
/******************************************************************************* * Function Name : EXTI4_IRQHandler * Description : This function handles External interrupt Line 4 request. * Input : None * Output : None * Return : None *******************************************************************************/ void EXTI4_IRQHandler(void) { #ifdef RT_USING_LWIP extern void rt_dm9000_isr(void); /* Clear the EXTI4 line pending bit */ EXTI_ClearITPendingBit(EXTI_Line4); /* enter interrupt */ rt_interrupt_enter(); while(GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_4)) { rt_dm9000_isr(); } /* leave interrupt */ rt_interrupt_leave(); #endif }
/******************************************************************************* * Function Name : USART1_IRQHandler * Description : This function handles USART1 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void USART1_IRQHandler(void) { rt_interrupt_enter(); //溢出错误 if (USART_GetFlagStatus(USART1, USART_FLAG_ORE) == SET) { prvvUARTRxISR(); } //接收中断 if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET) { USART_ClearITPendingBit(USART1, USART_IT_RXNE); prvvUARTRxISR(); } //发送中断 if (USART_GetITStatus(USART1, USART_IT_TXE) == SET) { prvvUARTTxReadyISR(); } rt_interrupt_leave(); }
/******************************************************************************* * Function Name : DMA2_Channel2_IRQHandler * Description : This function handles DMA2 Channel 2 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA2_Channel2_IRQHandler(void) { #if CODEC_USE_SPI3 extern void codec_dma_isr(void); /* enter interrupt */ rt_interrupt_enter(); if (DMA_GetITStatus(DMA2_IT_TC2)) { /* clear DMA flag */ DMA_ClearFlag(DMA2_FLAG_TC2 | DMA2_FLAG_TE2); /* transmission complete, invoke serial dma tx isr */ codec_dma_isr(); } /* leave interrupt */ rt_interrupt_leave(); #endif }
/******************************************************************************* * Function Name : DMA1_Channel2_IRQHandler * Description : This function handles DMA1 Channel 2 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel2_IRQHandler(void) { #ifdef RT_USING_UART3 extern struct rt_device uart3_device; /* enter interrupt */ rt_interrupt_enter(); if (DMA_GetITStatus(DMA1_IT_TC2)) { /* transmission complete, invoke serial dma tx isr */ rt_hw_serial_dma_tx_isr(&uart3_device); } /* clear DMA flag */ DMA_ClearFlag(DMA1_FLAG_TC2 | DMA1_FLAG_TE2); /* leave interrupt */ rt_interrupt_leave(); #endif }
void UART0_IRQHandler(void) { volatile uint32_t INTSTAT, tmp; /* enter interrupt */ rt_interrupt_enter(); INTSTAT = LPC_USART0->INTSTAT; INTSTAT &= 0x01; switch (INTSTAT) { case 0x01: rt_hw_serial_isr(&serial0, RT_SERIAL_EVENT_RX_IND); break; default : tmp = LPC_USART0->INTSTAT; break; } /* leave interrupt */ rt_interrupt_leave(); }
void USART3_IRQHandler(void) { struct stm32_uart *uart; uart = &uart3; /* enter interrupt */ rt_interrupt_enter(); if (USART_GetITStatus(uart->uart_device, USART_IT_RXNE) != RESET) { rt_hw_serial_isr(&serial3, RT_SERIAL_EVENT_RX_IND); } if (USART_GetITStatus(uart->uart_device, USART_IT_TC) != RESET) { /* clear interrupt */ USART_ClearITPendingBit(uart->uart_device, USART_IT_TC); } /* leave interrupt */ rt_interrupt_leave(); }
void UART1_IRQHandler(void) { rt_ubase_t level, iir; struct rt_uart_lpc* uart = &uart1_device; /* enter interrupt */ rt_interrupt_enter(); /* read IIR and clear it */ iir = uart->UART->IIR; if (iir == UART_IIR_INTID_RDA) /* Receive Data Available */ { /* Receive Data Available */ uart->rx_buffer[uart->save_index] = uart->UART->RBR; level = rt_hw_interrupt_disable(); uart->save_index ++; if (uart->save_index >= RT_UART_RX_BUFFER_SIZE) uart->save_index = 0; rt_hw_interrupt_enable(level); /* invoke callback */ if(uart->parent.rx_indicate != RT_NULL) { rt_size_t length; if (uart->read_index > uart->save_index) length = RT_UART_RX_BUFFER_SIZE - uart->read_index + uart->save_index; else length = uart->save_index - uart->read_index; uart->parent.rx_indicate(&uart->parent, length); } } /* leave interrupt */ rt_interrupt_leave(); return; }
/******************************************************************************* * Function Name : DMA1_Channel5_IRQHandler * Description : This function handles DMA1 Channel 5 interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void DMA1_Channel5_IRQHandler(void) { #if !CODEC_USE_SPI3 extern void codec_dma_isr(void); /* enter interrupt */ rt_interrupt_enter(); if (DMA_GetITStatus(DMA1_IT_TC5)) { /* clear DMA flag */ DMA_ClearFlag(DMA1_FLAG_TC5 | DMA1_FLAG_TE5); // rt_kprintf("DMA\n"); /* transmission complete, invoke serial dma tx isr */ codec_dma_isr(); } /* leave interrupt */ rt_interrupt_leave(); #endif }
void ENET_IRQHandler(void) { rt_uint32_t status; /* enter interrupt */ rt_interrupt_enter(); status = LPC_EMAC->IntStatus; if (status & INT_RX_DONE) { /* Disable EMAC RxDone interrupts. */ LPC_EMAC->IntEnable = INT_TX_DONE; /* a frame has been received */ eth_device_ready(&(lpc_emac_device.parent)); } else if (status & INT_TX_DONE) { /* set event */ rt_event_send(&tx_event, 0x01); } if (status & INT_RX_OVERRUN) { rt_kprintf("rx overrun\n"); } if (status & INT_TX_UNDERRUN) { rt_kprintf("tx underrun\n"); } /* Clear the interrupt. */ LPC_EMAC->IntClear = status; /* leave interrupt */ rt_interrupt_leave(); }
void UART0_IRQHandler(void) { struct lpc_uart *uart; uint32_t intsrc, tmp, tmp1; uart = &uart0; /* enter interrupt */ rt_interrupt_enter(); /* Determine the interrupt source */ intsrc = UART_GetIntId(uart->UART); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if (tmp == UART_IIR_INTID_RLS) { // Check line status tmp1 = UART_GetLineStatus(uart->UART); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE); // If any error exist if (tmp1) { // } } // Receive Data Available or Character time-out if ((tmp == UART_IIR_INTID_RDA) || (tmp == UART_IIR_INTID_CTI)) { rt_hw_serial_isr(&serial0); } /* leave interrupt */ rt_interrupt_leave(); }
/******************************************************************************* * Function Name : USART1_IRQHandler * Description : This function handles USART1 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void USART1_IRQHandler(void) { rt_interrupt_enter(); //接收中断 if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET) { USART_ClearITPendingBit(USART1, USART_IT_RXNE); if(master_slave != 0) prvvUARTRxISR(); else prvvUARTRxISR_Master(); } //发送中断 if (USART_GetITStatus(USART1, USART_IT_TXE) == SET) { // USART_ClearITPendingBit(USART1, USART_IT_TXE); if(master_slave != 0) prvvUARTTxReadyISR(); else prvvUARTTxReadyISR_Master(); } rt_interrupt_leave(); }
void EXTI4_IRQHandler(void) { rt_interrupt_enter(); GD32_GPIO_EXTI_IRQHandler(4); rt_interrupt_leave(); }
void TIM8_UP_TIM13_IRQHandler(void) { float I1 = 0, I2 = 0, power = 0; static float percent = 0, percent1 = 0 ; float error_pid = 0; static uint16_t interrupt_times = 0; // static uint8_t flag_modbus = 0; // rt_enter_critical();/*调度器上锁*/ rt_interrupt_enter(); logic_out(1,1); I1 = adc_get(0);//电流值 // I2 = adc_get(1); power = adc_get(2);//功率百分比 trig_adc(); if(interrupt_times < 500) { p_get[interrupt_times] = power; i_get[interrupt_times] = I1; } if(TIM_GetITStatus(TIM8, TIM_IT_Update) != RESET) { TIM_ClearITPendingBit(TIM8, TIM_IT_Update); if(pwm_struct[select_pwm].mode == 0) { // TIM_SetCompare1(TIM8, (uint16_t)(percent * pwm_period)); if(interrupt_times < pwm_struct[select_pwm]. positive_pulse) { pwm_struct[select_pwm].busy_flag = 1; pwm_ena(1); { error_pid = pwm_struct[select_pwm].p_array[interrupt_times] \ * program_data[select_pwm].current_max - I1; // logic_out(1,1); percent = pid3(error_pid); // logic_out(1,0); if(percent > 0.98f) percent = 0.98f; if(percent < 0.0f) percent = 0.0f; // percent = 0.3f; interrupt_times++; } } else { interrupt_times++; percent = 0; if( interrupt_times > pwm_struct[select_pwm].positive_pulse + pwm_struct[select_pwm].negative_pulse) { TIM_Cmd(TIM8, DISABLE); TIM_ClearITPendingBit(TIM8, TIM_IT_Update); pwm_ena(0); interrupt_times = 0; pwm_struct[select_pwm].busy_flag = 0; IntTerm_C3 = 0; PrevError_C3 = 0; } } } else { if(interrupt_times < pwm_struct[select_pwm]. positive_pulse) { pwm_struct[select_pwm].busy_flag = 1; pwm_ena(1); { // logic_out(1,1); error_pid = pwm_struct[select_pwm].p_array[interrupt_times] - power; percent1 = pid1(error_pid);//percent1为计算得出的电流值 if(percent1 > program_data[select_pwm].current_max) percent1 = program_data[select_pwm].current_max; if(percent1 < 0.0f) percent1 = 0.0f; error_pid = percent1 - I1; percent = pid3(error_pid); // logic_out(1,0); if(percent > 0.98f) percent = 0.98f; if(percent < 0.0f) percent = 0.0f; // percent = 0.3f; interrupt_times++; } } else { interrupt_times++; percent = 0; if( interrupt_times > pwm_struct[select_pwm].positive_pulse + pwm_struct[select_pwm].negative_pulse) { TIM_Cmd(TIM8, DISABLE); TIM_ClearITPendingBit(TIM8, TIM_IT_Update); pwm_ena(0); interrupt_times = 0; pwm_struct[select_pwm].busy_flag = 0; IntTerm_C3 = 0; PrevError_C3 = 0; IntTerm_C1 = 0; PrevError_C1 = 0; } } } TIM_SetCompare1(TIM8, (uint16_t)(pwm_period * percent)); if(interrupt_times < 500) { pid_out[interrupt_times] = percent; code[interrupt_times] = TIM8->CCR1; } } logic_out(1,0); rt_interrupt_leave(); // rt_exit_critical();/* 退出临界区*/ }
/* Only 1 byte READ using Interrupt or Polling otherwise using DMA */ void I2C1_EV_IRQHandler() { __IO uint16_t regSR1, regSR2; __IO uint32_t regSR; int i=10; rt_interrupt_enter(); //rt_hw_led_on(10); regSR1 = I2C1->SR1; regSR2 = I2C1->SR2; regSR = (regSR2 << 16) | regSR1; //rt_kprintf("EV=> SR1: 0x%x\tSR2: 0x%x\tSR: 0x%x status: %d\n", regSR1, regSR2, regSR, i2cStatus); if( (regSR & I2C_EVENT_MASTER_MODE_SELECT) == I2C_EVENT_MASTER_MODE_SELECT) //EV5 { if( i2cStatus == S1 ) //Send TX Command { I2C1->DR = DevAddr & 0xFE; i2cStatus = S2; } else if( i2cStatus == S4 ) //Send RX Command { I2C1->DR = DevAddr | 0x01; i2cStatus = S5; } regSR1 = 0; regSR2 = 0; } if( (regSR & I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)== I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED ) //EV6 { switch( i2cStatus ) { case S2: //Send 1st memory address phase { //I2C_DMACmd(I2C1, ENABLE); I2C1->DR = MemAddr[0]; if( memtype == I2C_MEM_1Byte ) i2cStatus = S2_2; else if( memtype == I2C_MEM_2Bytes ) i2cStatus = S2_1; } break; case S5: //Set RX buffer phase { if( i2cFlag == I2C_READ_DMA ) { I2C_DMAConfig(I2C1, i2c_buf, BufSize, I2C_DIRECTION_RX); I2C1->CR2 |= CR2_LAST_Set | CR2_DMAEN_Set; DMA_ITConfig( I2C1_DMA_CHANNEL_RX, DMA_IT_TC, ENABLE); } else if( i2cFlag == I2C_READ_INTERRUPT ) { I2C1->CR2 |= I2C_IT_BUF; I2C1->CR1 &= CR1_ACK_Reset; /* Program the STOP */ I2C1->CR1 |= CR1_STOP_Set; } i2cStatus = S6; } break; } regSR1 = 0; regSR2 = 0; //dump_i2c_register(I2C1); } if((regSR & I2C_EVENT_MASTER_BYTE_RECEIVED) == I2C_EVENT_MASTER_BYTE_RECEIVED) //EV7 { //Interrupt RX complete phase if( i2cStatus == S6 && i2cFlag == I2C_READ_INTERRUPT ) { *i2c_buf = I2C1->DR; i2cStatus = S_STOP; rt_event_send(&i2c_event, I2C_COMPLETE); } } if( (regSR & I2C_EVENT_MASTER_BYTE_TRANSMITTED) == I2C_EVENT_MASTER_BYTE_TRANSMITTED ) //EV8_2 { //Start TX/RX phase if(i2cStatus == S3) { DMA_ClearFlag(I2C1_DMA_CHANNEL_TX, DMA_FLAG_TCIF6 ); DMA_Cmd(I2C1_DMA_CHANNEL_TX, DISABLE); switch (i2cFlag) { case I2C_WRITE: i2cStatus = S_STOP; I2C1->CR1 |= CR1_STOP_Set; rt_event_send(&i2c_event, I2C_COMPLETE); break; case I2C_READ_DMA: i2cStatus = S4; I2C1->CR1 |= CR1_START_Set; break; case I2C_READ_POLLING: i2cStatus = S_STOP; rt_event_send(&i2c_event, I2C_COMPLETE); I2C1->CR2 &= ~(CR2_LAST_Set | I2C_IT_EVT | CR2_DMAEN_Set); I2C1->CR1 |= CR1_START_Set; break; case I2C_READ_INTERRUPT: i2cStatus = S4; I2C1->CR1 |= CR1_START_Set; break; } } if( i2cStatus == S2_1 ) //Send 2nd memory address { if( memtype == I2C_MEM_2Bytes ) //memory address has 2 bytes { I2C1->DR = MemAddr[1]; i2cStatus = S2_2; } if( i2cFlag == I2C_READ_POLLING || i2cFlag == I2C_READ_DMA || i2cFlag == I2C_READ_INTERRUPT) { i2cStatus = S3; } } if( i2cStatus == S2_2 ) //Set TX DAM phase { I2C_DMAConfig(I2C1, i2c_buf, BufSize, I2C_DIRECTION_TX); I2C1->CR2 |= CR2_DMAEN_Set; i2cStatus = S3; } } rt_interrupt_leave(); }
void _485_RxHandler(u8 data) { // Large LCD Data rt_interrupt_enter( ); _485_dev_rx[_485dev_wr++] = data; switch(_485_RXstatus._485_receiveflag) { case IDLE_485: if((0xAA != _485_dev_rx[0]) && (0x40 != _485_dev_rx[0])) { // 判断 第一个字节是否合法,否则直接清除 _485dev_wr = 0; break; } switch (_485dev_wr) { case 2 : if((0x55 != _485_dev_rx[1]) && (0x40 != _485_dev_rx[1])) _485dev_wr = 0; break; case 3: //---------- Check LCD -------------------------- if((0xAA == _485_dev_rx[0]) && (0x55 == _485_dev_rx[1])) { //AA 55 08 83 30 00 02 1E FF FF 00 08 是长度(包含1BYTE 指令2 BYTES 地址) _485_RXstatus._485_RxLen = _485_dev_rx[2]; _485_RXstatus._485_receiveflag = LARGE_LCD; } else if(0x40 != _485_dev_rx[0]) _485dev_wr = 0; break; case 8: // ------- Camera Data ----------- if((0x40 == _485_dev_rx[0]) && (0x40 == _485_dev_rx[1]) && (0x63 == _485_dev_rx[2])) { // 40 40 63 FF FF 00 02 00 02 是长度 (小端) _485_RXstatus._485_RxLen = ((u16)_485_dev_rx[6] << 8) + (u16)_485_dev_rx[5]; //---------------------------------- _485dev_wr = 0; //clear now , the bytes receiving later is pic data _485_RXstatus._485_receiveflag = CAMERA_Related; // return Idle } else _485dev_wr = 0; // clear break; } break; case LARGE_LCD: if(_485dev_wr >= (_485_RXstatus._485_RxLen + 3)) // AA 55 08 { // send msg_queue _485_MsgQue_sruct.info = _485_dev_rx; _485_MsgQue_sruct.len = _485dev_wr; _485dev_wr = 0; // clear _485_RXstatus._485_receiveflag = IDLE_485; } break; case CAMERA_Related: if(_485dev_wr >= _485_RXstatus._485_RxLen) { memset(_485_content, 0, sizeof(_485_content)); //-------------------------------------------------- memcpy(_485_content, _485_dev_rx, _485_RXstatus._485_RxLen); _485_content_wr = _485_RXstatus._485_RxLen; // Packet info len _485_CameraData_Enable = 1; // 图片数据过来了 //--------------------------------------------------- _485dev_wr = 0; // clear _485_RXstatus._485_receiveflag = IDLE_485; } break; default: _485dev_wr = 0; _485_RXstatus._485_receiveflag = IDLE_485; break ; } rt_interrupt_leave( ); }
void USART2_IRQHandler(void) { //用户程序.. UartType *P2data = &UartAppData2; /* enter interrupt */ rt_interrupt_enter(); if ( USART_GetITStatus(USART2, USART_IT_RXNE) != RESET ) { UCHAR ucChar; USART_ClearITPendingBit(USART2, USART_IT_RXNE); ucChar = USART_ReceiveData(USART2); if ( !P2data->Flags.Solo.RecFlame ) { P2data->RxTimeout = __25ms__; if ( P2data->RecCnt < (UART_BUFF_SIZE-1) ) { P2data->TxRxBuf[P2data->RecCnt] = ucChar; P2data->RecCnt++; if ( P2data->RecCnt == 8 ) { P2data->Flags.Solo.ShortFrame =1; } if ( P2data->RecCnt == UART_BUFF_SIZE-1 ) { P2data->Flags.Solo.RecFlame =1; } //if (P2data->RecCnt == UART_SHORT_LEN) //{ // P2data->Flags->Solo->ShortFrame =1; //} } } } else if ( USART_GetITStatus(USART2,USART_IT_TXE) ) { USART_ClearITPendingBit(USART2,USART_IT_TXE); USART_ClearFlag(USART2,USART_FLAG_TC); if ( P2data->SentCnt < P2data->ToSend ) { USART_SendData(USART2,P2data->TxRxBuf[P2data->SentCnt++]); } else { USART_ITConfig(USART2, USART_IT_TXE, DISABLE); USART_ITConfig(USART2, USART_IT_TC, ENABLE); } } else if ( USART_GetITStatus(USART2,USART_IT_TC) ) { P2data->Flags.Solo.TxStart = 0; Run_void(P2data->DisTxPin); USART_ITConfig(USART2, USART_IT_TC, DISABLE); } /* leave interrupt */ rt_interrupt_leave(); }
/******************************************************************************* * Function Name : TIM4_IRQHandler * Description : This function handles TIM2 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void TIM4_IRQHandler(void) { rt_interrupt_enter(); rt_interrupt_leave(); }
void EXTI4_IRQHandler(void) { rt_interrupt_enter(); HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_4); rt_interrupt_leave(); }