/****************************************************************** ** 函数名: TIMy_IRQHandler ** 输 入: none ** 描 述: 该定时器用作检测和LED控制计时使用 ** 全局变量: ** 调用模块: ** 作 者: zcs ** 日 期: 2015-04-21 ** 修 改: ** 日 期: ** 版 本: 1.0 *******************************************************************/ void USARTx_IRQHandler(void) { // if (USART_GetITStatus(USARTx,USART_IT_RXNE) != RESET) // { // EnQueue(&Queue,USART_ReceiveData(USARTx)); /* 把串口接收的数据放入环形缓冲区 */ // USART_ClearITPendingBit(USARTx,USART_IT_RXNE); // TIM_Cmd(TIMz,DISABLE); // TIM_SetCounter(TIMz,0); // TIM_Cmd(TIMz,ENABLE); // } if(USART_GetITStatus(USARTx, USART_IT_IDLE) != RESET) { USART_ClearITPendingBit(USARTx, USART_IT_IDLE);//空闲 USARTx->SR; USARTx->DR; cur_count = DMA_GetCurrDataCounter(DMA1_Channel6); Queue.front = ( Queue.front + pre_remain_count + CAPACITY - cur_count)%CAPACITY; pre_remain_count = DMA_GetCurrDataCounter(DMA1_Channel6); // USART_SendData(USARTx,Queue.front); // while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET); //等待字符发送完毕 get_whole_data = 1; } }
//returns byte from RX buffer. sets emtpy to true if no data to be received u8 Serial::getByte(bool &empty) { u16 dmaCounter; //circular buffer mode if (thisPort == RS485) { dmaCounter = 256 - DMA_GetCurrDataCounter(DMA2_Stream2); //counts downwards as data is received //if there is data if (rxBufPos != dmaCounter) { u8 ret = rxBuffer[rxBufPos]; rxBufPos++; if (rxBufPos >= RXBUFSIZE) rxBufPos = 0; return ret; } } //normal mode because of transfer complete (TC) interrupt needed else if (thisPort == DSC) { dmaCounter = rxPacketLen - DMA_GetCurrDataCounter(DMA1_Stream5); //counts downwards as data is received //if there is data if (rxBufPos < dmaCounter) { u8 ret = rxBuffer[rxBufPos]; rxBufPos++; return ret; } } empty=true; return RET_NODATA; }
void DMA1_Channel1_IRQHandler(void) { if(DMA_GetITStatus(DMA1_IT_HT1)) { CurrDataCounterEnd = DMA_GetCurrDataCounter(DMA1_Channel1); DMA_ClearITPendingBit(DMA1_IT_GL1); __TOGGLE_BIT(GPIOC->ODR, 8); } if(DMA_GetITStatus(DMA1_IT_TC1)) { CurrDataCounterEnd = DMA_GetCurrDataCounter(DMA1_Channel1); DMA_ClearITPendingBit(DMA1_IT_GL1); __TOGGLE_BIT(GPIOC->ODR, 9); } }
/** * ISR for USART6 RX DMA Stream Interrupt */ void DMA2_Stream2_IRQHandler() { // Stream2 transfer complete interrupt? if(DMA_GetITStatus(DMA2_Stream2,DMA_IT_TCIF2)) { // clear pending interrupt DMA_ClearFlag(DMA2_Stream2,DMA_IT_TCIF2); UART6_Str.Recv_Len = UART6_MAX_RECV_LEN -DMA_GetCurrDataCounter(DMA2_Stream2); if(UART6_Str.Recv_Len > 0) { UART6_Str.data = UART6_Recv_Buf[UART6_User_Buf_No]; UART6_Str.Recv_Flag = 1; UART6_User_Buf_No++; if(UART6_User_Buf_No >= UART6_MAX_ARR) UART6_User_Buf_No = 0; } DMA_ClearFlag(DMA2_Stream2,DMA_FLAG_DMEIF2 | DMA_FLAG_FEIF2 | DMA_FLAG_TCIF2 | DMA_FLAG_TEIF2 | DMA_FLAG_HTIF2);//清标志 DMA_SetCurrDataCounter(DMA2_Stream2,UART6_MAX_RECV_LEN);//重装填 //USART6_Rcv_Str.Free_Buf_No = DMA_GetCurrentMemoryTarget(DMA2_Stream2); UART6_DMA_RX.DMA_Memory0BaseAddr = (u32)&UART6_Recv_Buf[UART6_User_Buf_No]; DMA_Init(DMA2_Stream2, &UART6_DMA_RX); } DMA_ClearFlag(DMA2_Stream2,DMA_IT_TEIF2 | DMA_FLAG_HTIF2); }
uint8_t PARAMETERS_GetNbNewBytes(uint8_t* PARAMETERS_Buffer) { static uint16_t dma_cpt_prev=PARAMETERS_BUFFER_LENGTH; uint16_t dma_cpt, n=0; // Get current DMA counter dma_cpt = DMA_GetCurrDataCounter(DMA1_Stream1); // If DMA counter has changed, compute the number of received MIDI bytes if (dma_cpt != dma_cpt_prev) { if (dma_cpt < dma_cpt_prev) { n = dma_cpt_prev - dma_cpt; } else { n = dma_cpt_prev - (dma_cpt - PARAMETERS_BUFFER_LENGTH); } // Store the new DMA counter dma_cpt_prev = dma_cpt; } return(n); }
//----------------------------------------------------------------------------------- unsigned int uart3FindEscapedPack() { unsigned int i = u1Fifo.rxCurrent; while (i != (UARTRX_FIFO_SIZE - DMA_GetCurrDataCounter(USART3_RX_DMA))) { if (u1Fifo.rxBuf[i] == 0x55) { i++; i &= UARTRX_FIFO_SIZE_MASK; if (i == (USART3_RX_DMA->CMAR - (uint32_t) &u1Fifo.rxBuf[0])) return 0;//return (isStart & isEnd); if (u1Fifo.rxBuf[i] == 0x03) { return 1; } } i++; i &= UARTRX_FIFO_SIZE_MASK; } return 0; }
/******************************************************************************* * Function Name : uart_dma_irq_handler * Description : DMA interrupt handle function * Input : - Uart: Select the USART or the UART peripheral. * Output : None * Return : None *******************************************************************************/ void uart_dma_irq_handler(const _Uart_Descriptor *Uart) { // __hw_enter_interrupt(); // if (*Uart->Ctrl) { while ((DMA_GetCurrDataCounter(Uart->DMAy_Streamx) != (*Uart->Ctrl)->iDma) && ((*Uart->Ctrl)->RxCnt < (*Uart->Ctrl)->RxBufSize)) { (*Uart->Ctrl)->RxBufPtr[(*Uart->Ctrl)->RxiPut++] = (*Uart->Ctrl)->DmaBufPtr[(*Uart->Ctrl)->DmaBufSize - (*Uart->Ctrl)->iDma--]; if (!(*Uart->Ctrl)->iDma) (*Uart->Ctrl)->iDma = (*Uart->Ctrl)->DmaBufSize; //lepton if(!(*Uart->Ctrl)->RxCnt){ if(Uart->board_uart_info && Uart->board_uart_info->desc_r!=-1) __fire_io_int(ofile_lst[Uart->board_uart_info->desc_r].owner_pthread_ptr_read); } //lepton (*Uart->Ctrl)->RxCnt++; if ((*Uart->Ctrl)->RxiPut >= (*Uart->Ctrl)->RxBufSize) (*Uart->Ctrl)->RxiPut = 0; if (((*Uart->Ctrl)->HwCtrl & UART_HW_FLOW_CTRL_RX) && ((*Uart->Ctrl)->RxCnt > ((*Uart->Ctrl)->RxBufSize - (*Uart->Ctrl)->DmaBufSize))) uart_set_rx_hw_fc(Uart); } } #ifdef _UART_OS_SUPPORT isr_evt_set((*Uart->Ctrl)->Event, (*Uart->Ctrl)->Task); #endif // DMA_ClearITPendingBit(Uart->DMAy_Streamx, DMA_IT_ALL_1); // __hw_leave_interrupt(); // }
void uarts_sport_irq_handler_callback(void) { uint32_t temp = 0; uint16_t len = 0; uint8_t RxBuffer[S_PORT_RX_BUFF_LEN]; if(USART_GetITStatus(USART_S_PORT, USART_IT_IDLE) != RESET) { DMA_Cmd(USART_S_PORT_Rx_DMA_STREAM,DISABLE); temp = USART_S_PORT->SR; temp = USART_S_PORT->DR; //清USART_IT_IDLE标志 temp = temp; //接收字节数 len = S_PORT_RX_BUFF_LEN - DMA_GetCurrDataCounter(USART_S_PORT_Rx_DMA_STREAM); memcpy(RxBuffer, Sport_RxBuffer, len); //设置传输数据长度 DMA_SetCurrDataCounter(USART_S_PORT_Rx_DMA_STREAM,S_PORT_RX_BUFF_LEN); //打开DMA DMA_Cmd(USART_S_PORT_Rx_DMA_STREAM,ENABLE); uarts_sport_irq_handler_cb_hook(RxBuffer, len); } }
/** * * @param buffer * @param max_length * @return */ uint32_t USART1_Recv(uint8_t* buffer, uint32_t max_length) { uint32_t recv_length; uint32_t write_index; write_index = sizeof(USART1_RxBuffer) - DMA_GetCurrDataCounter(DMA1_Channel5); recv_length = 0; while( (write_index - USART1_ReadIndex) != 0 ) { buffer[recv_length] = USART1_RxBuffer[USART1_ReadIndex]; recv_length ++; USART1_ReadIndex ++; if( USART1_ReadIndex == sizeof(USART1_RxBuffer) ) { USART1_ReadIndex = 0; } if( recv_length == max_length ) { break; } } return recv_length; }
void USART2_IRQHandler(void) //����2 �жϷ������ { uint8_t tmp; task * uart2_task; struct uart_buffer *uart2_buf; uint16_t length = 0; if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET) { tmp = USART_ReceiveData(USART2); DMA_Cmd(DMA1_Channel6, DISABLE); // close DMA length = USART_RECEIVED_MAX_LEN - DMA_GetCurrDataCounter(DMA1_Channel6); //printf("uart2 dma2 length:%d\n", length); uart2_buf = (struct uart_buffer*)malloc(sizeof(struct uart_buffer)); uart2_buf->buf = (uint8_t*)malloc(length + 1); uart2_buf->length = length + 1; memcpy(uart2_buf->buf, g_usart2_received_buf, length); uart2_buf->buf[length] = 0; uart2_task = new_task(); uart2_task->handler = module_data_handler; uart2_task->pdata = uart2_buf; add_task(uart2_task); // set data length of transmission DMA_SetCurrDataCounter(DMA1_Channel6, USART_RECEIVED_MAX_LEN); // open DMA DMA_Cmd(DMA1_Channel6,ENABLE); } if(USART_GetITStatus(USART2, USART_IT_TXE) != RESET) //�����Ϊ�˱���STM32 USART ��һ���ֽڷ�����ȥ��BUG { USART_ITConfig(USART2, USART_IT_TXE, DISABLE); //��ֹ�����������жϣ� } }
/* * 函数名:u2_printf() * 输入:char* fmt,...要发送的数据,用printf的相同的格式输入 * 输出:void * 功能:通过UART1发送数据到外设 * PS:使用时要确保一次发送数据不超过USART1_MAX_SEND_LEN字节 */ void u2_printf(char* fmt,...) { va_list ap; va_start(ap,fmt); vsprintf((char*)USART2_TX_BUF,fmt,ap); va_end(ap); while(DMA_GetCurrDataCounter(DMA1_Channel7)!=0); //等待通道4传输完成 UART2_DMA_Enable(DMA1_Channel7,strlen((const char*)USART2_TX_BUF)); //通过dma发送出去 }
void setSync(void) { __disable_irq (); DMA_Cmd(DMA2_Stream0, DISABLE); sync.side = !status.side[0]; sync.correctFirstCount = SIZE_BUF - DMA_GetCurrDataCounter(DMA2_Stream0)/2; DMA_Cmd(DMA2_Stream0, ENABLE); __enable_irq (); return; }
uint8_t * OV7670_capture_image() { DCMI_InitTypeDef DCMI_InitStructure; DMA_InitTypeDef DMA_InitStructure; /* DMA2 Stream1 Configuration */ DMA_DeInit(DMA2_Stream1); DMA_InitStructure.DMA_Channel = DMA_Channel_1; DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&DCMI->DR); DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t) image_buffer; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory; DMA_InitStructure.DMA_BufferSize = (IMG_SIZE/sizeof(uint32_t)); DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; /* DMA2 IRQ channel Configuration */ DMA_Init(DMA2_Stream1, &DMA_InitStructure); DMA_Cmd(DMA2_Stream1, ENABLE); DCMI_Cmd(ENABLE); DCMI_CaptureCmd(ENABLE); int temp; // Wait until DCMI DMA Rx transfer is complete while (DMA_GetFlagStatus(DMA2_Stream1, DMA_FLAG_TCIF1) == RESET) { temp = DMA_GetCurrDataCounter(DMA2_Stream1); temp = DCMI->CR; temp = DCMI->RISR; } /* Clear all DMA Streams flags */ DMA_ClearFlag(DMA2_Stream1, DMA_FLAG_HTIF1 | DMA_FLAG_TCIF1); /* Disable the DMA Rx Stream */ DMA_Cmd(DMA2_Stream1, DISABLE); //Do not disable DCMI peripheral untill DMA disable command gets through while(DMA_GetCmdStatus(DMA2_Stream1) == ENABLE) {} DCMI_Cmd(DISABLE); return (uint8_t*) image_buffer; }
char fillRest() { if (status.side_f == status.side_h || (SIZE_BUF - DMA_GetCurrDataCounter(DMA2_Stream0)/2 - 2) < LEN_WINDOW) { status.isRestFill = 0; } else { memcpy(buf[0].rest, buf[0].buf, sizeof(buf[0].rest)); memcpy(buf[1].rest, buf[1].buf, sizeof(buf[1].rest)); status.isRestFill = 1; } return status.isRestFill; }
/*USARTx使用DMA方式发送数据*/ void sys_usartSendData(uint8_t *Data, uint32_t SendSize) { while(DMA_GetCurrDataCounter(DMA1_Channel4)); while(!DMA_GetFlagStatus(DMA1_FLAG_TC4)); DMA_ClearFlag(DMA1_FLAG_TC4); DMA1_Channel4->CCR &= 0xffffffe; DMA1_Channel4->CMAR = (uint32_t)Data; DMA1_Channel4->CNDTR = SendSize; DMA1_Channel4->CCR |= 0x00000001; }
//not working!!!!!!!!!!! void UART_PutChar(char data) { while (!IsUsartTransferComplete(serialPort3)) { } sprintf(serialPort3->txBuf, &data); u16 retCounter = DMA_GetCurrDataCounter(USARTx_TX_DMA_STREAM); DMA_Cmd(USARTx_TX_DMA_STREAM, DISABLE); DMA_SetCurrDataCounter(USARTx_TX_DMA_STREAM, retCounter + 1); DMA_Cmd(USARTx_TX_DMA_STREAM, ENABLE); }
/** * @brief Main program * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup file (startup_stm32f10x_xx.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f10x.c file */ /* System Clocks Configuration */ RCC_Configuration(); /* NVIC configuration */ NVIC_Configuration(); /* DMA1 channel6 configuration */ DMA_DeInit(DMA1_Channel6); DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SRC_Const_Buffer; DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)DST_Buffer; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = BufferSize; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_M2M = DMA_M2M_Enable; DMA_Init(DMA1_Channel6, &DMA_InitStructure); /* Enable DMA1 Channel6 Transfer Complete interrupt */ DMA_ITConfig(DMA1_Channel6, DMA_IT_TC, ENABLE); /* Get Current Data Counter value before transfer begins */ CurrDataCounterBegin = DMA_GetCurrDataCounter(DMA1_Channel6); /* Enable DMA1 Channel6 transfer */ DMA_Cmd(DMA1_Channel6, ENABLE); /* Wait the end of transmission */ while (CurrDataCounterEnd != 0) { } /* Check if the transmitted and received data are equal */ TransferStatus = Buffercmp(SRC_Const_Buffer, DST_Buffer, BufferSize); /* TransferStatus = PASSED, if the transmitted and received data are the same */ /* TransferStatus = FAILED, if the transmitted and received data are different */ while (1) { } }
int uart3GetChar(unsigned char *ch) { if (u1Fifo.rxCurrent != (UARTRX_FIFO_SIZE - DMA_GetCurrDataCounter(USART3_RX_DMA))) { *ch = u1Fifo.rxBuf[u1Fifo.rxCurrent]; u1Fifo.rxCurrent++; u1Fifo.rxCurrent &= UARTRX_FIFO_SIZE_MASK; return 1; } return 0; }
/** * @brief This function handles DMA1 Channel 6 interrupt request. * @param None * @retval None */ void DMA1_Channel6_IRQHandler(void) { /* Test on DMA1 Channel6 Transfer Complete interrupt */ if(DMA_GetITStatus(DMA1_IT_TC6)) { /* Get Current Data Counter value after complete transfer */ CurrDataCounterEnd = DMA_GetCurrDataCounter(DMA1_Channel6); /* Clear DMA1 Channel6 Half Transfer, Transfer Complete and Global interrupt pending bits */ DMA_ClearITPendingBit(DMA1_IT_GL6); } }
uint16_t uart1NumCharsAvailable(void) { int32_t number; number = rx1DMAPos - DMA_GetCurrDataCounter(DMA2_Stream5); if (number >= 0) return (uint16_t)number; else return (uint16_t)(UART1_BUFFER_SIZE + number); }
static int uart_IsNotEmpty(void) { int ret; #ifdef ENABLE_RX_DMA int rn = RX_FIFO_SZ - DMA_GetCurrDataCounter(dma_ch_rx); ret = rn - uart_fifo_rn; ret += (ret < 0) ? RX_FIFO_SZ : 0; #else ret = (int) USART_GetFlagStatus(uart, USART_FLAG_RXNE); #endif return ret; }
void DMA1_Channel3_IRQHandler(void) { /* Disable DMA1_Channel2 transfer*/ //DMA_Cmd(USART3_TX_DMA, DISABLE); /* Clear DMA1_Channel2 Transfer Complete Flag*/ DMA_ClearFlag(DMA1_FLAG_TC3); u1Fifo.rxCurrent+=0; int tempTest = DMA_GetCurrDataCounter(USART3_RX_DMA); tempTest +=0; //DMARxDataReceived(); //uart3TxTask(); }
auto dma_wrap_base<Impl>::bytes_left() { constexpr auto stream = Impl::get_stream_ptr(); auto items_left = DMA_GetCurrDataCounter(stream); auto reg = stream->CR & 0x6000; // Fetch data size // DMA_MemoryDataSize encodes data size in a specific way, so shift can be // applied and divider can be obtained. // However, this can be possibly changed in SPL. auto div = reg == DMA_MemoryDataSize_Byte ? 1 : reg >> 12; return items_left * div; }
unsigned short get_positionDMA(void) { unsigned short pos_S1 = 0, pos_S2 = 0, pos_S = 0; char side[2] = {0}; __disable_irq (); DMA_Cmd(DMA2_Stream0, DISABLE); DMA_Cmd(DMA1_Stream3, DISABLE); side[0] = status.side[0]; side[1] = status.side[1]; pos_S = DMA_GetCurrDataCounter(DMA2_Stream0); pos_S2 = DMA_GetCurrDataCounter(DMA1_Stream3); DMA_Cmd(DMA2_Stream0, ENABLE); DMA_Cmd(DMA1_Stream3, ENABLE); if(status.side_h != status.side_f) { __enable_irq (); return SIZE_BUF + LEN_WINDOW - 1; } __enable_irq (); if(status.side_h == side[0]) pos_S = pos_S1; else pos_S = pos_S2; return SIZE_BUF - (pos_S/2); }
static int uart_putchar(int data) { char c = (char) data; #ifdef ENABLE_TX_DMA int i, j, n; //wait ... no enough fifo space to use do { n = DMA_GetCurrDataCounter(dma_ch_tx); } while(TX_FIFO_SZ - n < 1); //copy DMA_Cmd(dma_ch_tx, DISABLE); n = DMA_GetCurrDataCounter(dma_ch_tx); uart_fifo_tp += uart_fifo_tn - n; if(uart_fifo_tp + n + 2 > TX_FIFO_SZ) { for(i = 0, j = uart_fifo_tp; i < n; i ++, j ++) { if(i != j) uart_fifo_tx[i] = uart_fifo_tx[j]; } uart_fifo_tp = 0; } else { i = uart_fifo_tp + n; } uart_fifo_tx[i ++] = c; n ++; uart_fifo_tn = n; uart_SetupTxDMA(uart_fifo_tx + uart_fifo_tp, n); #else USART_SendData(uart, c); while(USART_GetFlagStatus(uart, USART_FLAG_TXE) == RESET); #endif return 0; }
void USART6_IRQHandler(void) { u16 i; if(USART_GetITStatus(USART6, USART_IT_IDLE) != RESET)//如果为空闲总线中断 { #if UART6_DMA_RX_ENABLE DMA_Cmd(DMA2_Stream2, DISABLE);//关闭DMA,防止处理其间有数据 UART6_Str.Recv_Len = UART6_MAX_RECV_LEN - DMA_GetCurrDataCounter(DMA2_Stream2); if(UART6_Str.Recv_Len > 0) { UART6_Str.data = UART6_Recv_Buf[UART6_User_Buf_No]; UART6_Str.Recv_Flag = 1; UART6_User_Buf_No++; if(UART6_User_Buf_No >= UART6_MAX_ARR) UART6_User_Buf_No = 0; } DMA_ClearFlag(DMA2_Stream2,DMA_FLAG_DMEIF2 | DMA_FLAG_FEIF2 | DMA_FLAG_TCIF2 | DMA_FLAG_TEIF2 | DMA_FLAG_HTIF2);//清标志 DMA_SetCurrDataCounter(DMA2_Stream2,UART6_MAX_RECV_LEN);//重装填 UART6_DMA_RX.DMA_Memory0BaseAddr = (u32)&UART6_Recv_Buf[UART6_User_Buf_No]; DMA_Init(DMA2_Stream2, &UART6_DMA_RX); //DMA_SetCurrDataCounter(DMA2_Stream2,MAX_RCV_LEN);//重装填 DMA_Cmd(DMA2_Stream2, ENABLE);//处理完,重开DMA #else UART6_Str.data = UART6_Recv_Buf[UART6_Str.User_Buf_No]; UART6_Str.Recv_Flag = 1; UART6_Str.User_Buf_No++; if(UART6_Str.User_Buf_No >= UART_MAX_ARR) UART6_Str.User_Buf_No = 0; #endif //读SR后读DR清除Idle i = USART6->SR; i = USART6->DR; } if(USART_GetITStatus(USART6, USART_IT_RXNE) != RESET)//如果为接收中断 { UART6_Recv_Buf[UART6_User_Buf_No][UART6_Str.Recv_Len] = USART6->DR; UART6_Str.Recv_Len++; if(UART6_Str.Recv_Len > UART6_MAX_RECV_LEN) UART6_Str.Recv_Len = 0; } if(USART_GetITStatus(USART6, USART_IT_PE | USART_IT_FE | USART_IT_NE) != RESET)//出错 { USART_ClearITPendingBit(USART6, USART_IT_PE | USART_IT_FE | USART_IT_NE); } USART_ClearITPendingBit(USART6, USART_IT_IDLE); }
static void uartPauseDma() { if (DMA_GetCmdStatus(UART_DMA_STREAM) == ENABLE) { // Disable transfer complete interrupt DMA_ITConfig(UART_DMA_STREAM, DMA_IT_TC, DISABLE); // Disable stream to pause it DMA_Cmd(UART_DMA_STREAM, DISABLE); // Wait for it to be disabled while(DMA_GetCmdStatus(UART_DMA_STREAM) != DISABLE); // Disable transfer complete DMA_ClearITPendingBit(UART_DMA_STREAM, UART_DMA_FLAG_TCIF); // Read remaining data count remainingDMACount = DMA_GetCurrDataCounter(UART_DMA_STREAM); dmaIsPaused = true; } }
uint32_t USART1_DataAvailable(void) { uint32_t filled_length; uint32_t write_index; write_index = sizeof(USART1_RxBuffer) - DMA_GetCurrDataCounter(DMA1_Channel5); if( USART1_ReadIndex > write_index ) { filled_length = (sizeof(USART1_RxBuffer) - USART1_ReadIndex) + write_index; } else { filled_length = write_index - USART1_ReadIndex; } return filled_length; }
void Usart2_Handle(void) { u16 DATA_LEN; u16 i; if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET) { DMA_Cmd(DMA1_Channel6, DISABLE);//关闭DMA,防止处理其间有数据 //USART_RX_STA = USART1->SR;//先读SR,然后读DR才能清除 //USART_RX_STA = USART1->DR; DATA_LEN=BufferSize-DMA_GetCurrDataCounter(DMA1_Ch_Usart2_Rx); if(DATA_LEN > 0) { while(USART1_TX_Finish==0) { ; } //将数据送DMA存储地址 for(i=0;i<DATA_LEN;i++) { TxBuffer1[i]=RxBuffer2[i]; } //USART用DMA传输替代查询方式发送,克服被高优先级中断而产生丢帧现象。 DMA_Cmd(DMA1_Channel7, DISABLE); //改变datasize前先要禁止通道工作 DMA1_Channel7->CNDTR=DATA_LEN; //DMA1,传输数据量 DMA1_Channel7->CMAR = (uint32_t)TxBuffer1; USART1_TX_Finish=0;//DMA传输开始标志量 DMA_Cmd(DMA1_Channel7, ENABLE); } //DMA_Cmd(DMA1_Ch_Usart1_Rx, DISABLE);//关闭DMA,防止处理其间有数据 DMA_ClearFlag(DMA1_FLAG_GL6 | DMA1_FLAG_TC6 | DMA1_FLAG_TE6 | DMA1_FLAG_HT6);//清标志 DMA1_Ch_Usart2_Rx->CNDTR = BufferSize;//重装填 DMA_Cmd(DMA1_Ch_Usart2_Rx, ENABLE);//处理完,重开DMA //读SR后读DR清除Idle i = USART2->SR; i = USART2->DR; } if(USART_GetITStatus(USART2, USART_IT_PE | USART_IT_FE | USART_IT_NE) != RESET)//出错 { USART_ClearITPendingBit(USART2, USART_IT_PE | USART_IT_FE | USART_IT_NE); } USART_ClearITPendingBit(USART2, USART_IT_TC); USART_ClearITPendingBit(USART2, USART_IT_IDLE); }
void USART1_IRQHandler(void) { if(USART_GetITStatus(USART1,USART_IT_IDLE) == SET) { num = USART1->SR; num = USART1->DR; //清USART_IT_IDLE标志 关键的一点,就是要读取SR,DR,将USART_IT_IDLE标志给清掉 DMA_Cmd(DMA1_Channel5,DISABLE); //关闭DMA通道 DMA_ClearFlag(DMA1_FLAG_GL5); //清除DMA标志位 num = 128 - DMA_GetCurrDataCounter(DMA1_Channel5); //得到真正接收数据个数 DMA1_Channel5->CNDTR=128; //重新设置接收数据个数 DMA_Cmd(DMA1_Channel5,ENABLE); //开启DMA receive_flag = true; //接收数据标志位置1 LEDR2_INVERSE(); } }