/******************************************************************
** 函数名: 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();
}
}
