コード例 #1
0
OSStatus MicoUartSend( mico_uart_t uart, const void* data, uint32_t size )
{
  /* Reset DMA transmission result. The result is assigned in interrupt handler */
  uart_interfaces[uart].tx_dma_result = kGeneralErr;
  
  MicoMcuPowerSaveConfig(false);  
  
  uart_mapping[uart].tx_dma_stream->CR  &= ~(uint32_t) DMA_SxCR_CIRC;
  uart_mapping[uart].tx_dma_stream->NDTR = size;
  uart_mapping[uart].tx_dma_stream->M0AR = (uint32_t)data;
  
  USART_DMACmd( uart_mapping[uart].usart, USART_DMAReq_Tx, ENABLE );
  USART_ClearFlag( uart_mapping[uart].usart, USART_FLAG_TC );
  DMA_Cmd( uart_mapping[uart].tx_dma_stream, ENABLE );
  
#ifndef NO_MICO_RTOS
  mico_rtos_get_semaphore( &uart_interfaces[ uart ].tx_complete, MICO_NEVER_TIMEOUT );
#else 
  while(uart_interfaces[ uart ].tx_complete == false);
  uart_interfaces[ uart ].tx_complete = false;
#endif
  
  while ( ( uart_mapping[ uart ].usart->SR & USART_SR_TC ) == 0 )
  {
  }
  
  DMA_Cmd( uart_mapping[uart].tx_dma_stream, DISABLE );
  USART_DMACmd( uart_mapping[uart].usart, USART_DMAReq_Tx, DISABLE );
  
  MicoMcuPowerSaveConfig(true);
  
  return uart_interfaces[uart].tx_dma_result;
  //#endif
}
コード例 #2
0
ファイル: usart.c プロジェクト: lennytraviano/quadrocopter
void DMA_Configuration(void)
{
    DMA_DeInit(DMA1_Channel6);

    /* Enable the USART Rx DMA request */
    USART_DMACmd(USART2, USART_DMAReq_Tx, ENABLE);

    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; // Receive //DMA_DIR_PeripheralDST
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)read_parameters_android;
    DMA_InitStructure.DMA_BufferSize = sizeof(read_parameters_android);
    DMA_InitStructure.DMA_PeripheralBaseAddr =(uint32_t) &(USART2->RDR);

    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;

    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel6, &DMA_InitStructure);
    USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE);
    DMA_ITConfig(DMA1_Channel6, DMA_IT_TC, ENABLE);
    DMA_ITConfig(DMA1_Channel6, DMA_IT_HT, ENABLE);
    DMA_Cmd(DMA1_Channel6, ENABLE);
}
コード例 #3
0
ファイル: stuff.c プロジェクト: vehar/CAN-viewer
void DMA_USART_ReInit()
{
    DMA_Cmd(DMA1_Stream6, DISABLE);
    USART_DMACmd(USART2,USART_DMAReq_Tx,DISABLE);
    DMA_Init(DMA1_Stream6, &DMA_InitStructure);
    USART_DMACmd(USART2,USART_DMAReq_Tx,ENABLE);
    DMA_Cmd(DMA1_Stream6, ENABLE);
}
コード例 #4
0
void pingpong_usart1_rx_dma_int(void)
{
	if(!dma1_ch5_mode_is_circular())
	{
		USART_DMACmd(USART1, USART_DMAReq_Rx, DISABLE);
		DMA_Cmd(DMA1_Channel5, DISABLE);
	}
	
#if DMA_Circular
	if(PINGPONG_BUF_NO0 == PingPongBuf_Free_No)
	{
		DMA1_Channel5->CMAR = (unsigned int)&pingpongbuf[0]; // DMA_MemoryBaseAddr;
		PingPongBuf_Free_No = PINGPONG_BUF_NO1;
		//usart1_dma_write(pingpongbuf[1], PINGPONG_BUFSIZE, usart1_dma_tx_done_callback);
	}
	else
	{
		DMA1_Channel5->CMAR = (unsigned int)pingpongbuf[1]; // DMA_MemoryBaseAddr;
		PingPongBuf_Free_No = PINGPONG_BUF_NO0;
		//usart1_dma_write(pingpongbuf[1], PINGPONG_BUFSIZE, usart1_dma_tx_done_callback);
	}
	PINGPONG_BUF_OK = TRUE;
#else // DMA Mode Normal
	if(PINGPONG_BUF_NO0 == PingPongBuf_Free_No)
	{
		PingPongBuf_Free_No = PINGPONG_BUF_NO1;
		//usart1_dma_write(pingpongbuf[1], PINGPONG_BUFSIZE, usart1_dma_tx_done_callback);
		#if 1
		DMA1_Channel5->CMAR = (unsigned int)pingpongbuf[0]; // DMA_MemoryBaseAddr;
		DMA1_Channel5->CNDTR = PINGPONG_BUFSIZE; // DMA_BufferSize;
		DMA_Cmd(DMA1_Channel5, ENABLE);
		USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
		#else
		dma1_ch5_peri2mem_start((unsigned char *)(&USART1->DR), pingpongbuf[0], PINGPONG_BUFSIZE);
		USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
		#endif
		
	}
	else
	{
		PingPongBuf_Free_No = PINGPONG_BUF_NO0;
		//usart1_dma_write(pingpongbuf[0], PINGPONG_BUFSIZE, usart1_dma_tx_done_callback);
		#if 1
		DMA1_Channel5->CMAR = (unsigned int)pingpongbuf[1]; // DMA_MemoryBaseAddr;
		DMA1_Channel5->CNDTR = PINGPONG_BUFSIZE; // DMA_BufferSize;
		DMA_Cmd(DMA1_Channel5, ENABLE);
		USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
		#else
		dma1_ch5_peri2mem_start((unsigned char *)(&USART1->DR), pingpongbuf[1], PINGPONG_BUFSIZE);
		USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
		#endif		
	}
	PINGPONG_BUF_OK = TRUE;
#endif
}
コード例 #5
0
ファイル: uart2_stm32.c プロジェクト: miaofng/ulp
static int uart_Init(const uart_cfg_t *cfg)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef uartinfo;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
#ifdef CONFIG_STM32F10X_CL
	/*configure PD5<uart2.tx>, PD6<uart2.rx>*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_AFIO, ENABLE);
	GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOD, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOD, &GPIO_InitStructure);
#else
	/*configure PA2<uart2.tx>, PA3<uart2.rx>*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
#endif

	/*init serial port*/
	USART_StructInit(&uartinfo);
	uartinfo.USART_BaudRate = cfg->baud;
	USART_Init(uart, &uartinfo);

#ifdef ENABLE_TX_DMA
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	uart_SetupTxDMA(uart_fifo_tx, 0);
	USART_DMACmd(uart, USART_DMAReq_Tx, ENABLE);
	uart_fifo_tn = 0;
	uart_fifo_tp = 0;
#endif

#ifdef ENABLE_RX_DMA
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	uart_SetupRxDMA(uart_fifo_rx, RX_FIFO_SZ);
	USART_DMACmd(uart, USART_DMAReq_Rx, ENABLE);
	uart_fifo_rn = 0;
#endif

	USART_Cmd(uart, ENABLE);
	return 0;
}
コード例 #6
0
void  USART_DMA_Config(void)
{
  
  /* USART configuration -----------------------------------------------------*/
  USART_Config(); 
    
    
   /******************************************************************
    DMA TX   
    
    *******************************************************************/
    /* Prepare the DMA to transfer the transaction command (2bytes) from the
         memory to the USART  */ 
    DMA_DeInit(USARTx_TX_DMA_STREAM);
    DMA_InitStructure.DMA_Channel = USARTx_TX_DMA_CHANNEL;
    DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;  
    DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)TxBuffer_dma;
    DMA_InitStructure.DMA_BufferSize = (uint16_t)24;
    DMA_Init(USARTx_TX_DMA_STREAM, &DMA_InitStructure); 
    
    DMA_ITConfig(USARTx_TX_DMA_STREAM, DMA_IT_TC , ENABLE);
    
    /* Enable the USART DMA requests */   
    USART_DMACmd(USARTx, USART_DMAReq_Tx, ENABLE);
      
    /* Clear the TC bit in the SR register by writing 0 to it */
    USART_ClearFlag(USARTx, USART_FLAG_TC);         
    
   
	
/******************************************************************
    DMA RX
    
*******************************************************************/       
#if 1
    DMA_DeInit(USARTx_RX_DMA_STREAM);
    DMA_InitStructure.DMA_Channel = USARTx_RX_DMA_CHANNEL;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
	DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;  
    DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)RxBuffer_dma;
    DMA_InitStructure.DMA_BufferSize = (uint16_t)24;
    DMA_Init(USARTx_RX_DMA_STREAM, &DMA_InitStructure);
    
    /******        DMA ÖжÏÅäÖà        ************************/
    DMA_ITConfig(USARTx_RX_DMA_STREAM, DMA_IT_TC , ENABLE);
    /* Enable the USART Rx DMA request  */
    USART_DMACmd(USARTx, USART_DMAReq_Rx, ENABLE);  
    /* Enable the DMA RX Stream*/ 
    DMA_Cmd(USARTx_RX_DMA_STREAM, ENABLE);   
    

#endif
  
}
コード例 #7
0
ファイル: kl_lib_f0.cpp プロジェクト: Kreyl/nute
void CmdUnit_t::IStartTx(void) {
    IDmaIsIdle = false;
    // Start DMA
    USART_DMACmd(USART1, USART_DMAReq_Tx, DISABLE);
    DMA_Cmd(UART_DMA_CHNL, DISABLE);
    UART_DMA_CHNL->CMAR = (uint32_t) PBuf;  // Set memory base address
    UART_DMA_CHNL->CNDTR = TxIndx;          // Set count to transmit
    DMA_Cmd(UART_DMA_CHNL, ENABLE);
    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
    // Switch to next buf
    PBuf = (PBuf == TXBuf1)? TXBuf2 : TXBuf1;
    TxIndx = 0;
}
コード例 #8
0
ファイル: platform_uart.c プロジェクト: ilittlerui/MICO
OSStatus platform_uart_transmit_bytes( platform_uart_driver_t* driver, const uint8_t* data_out, uint32_t size )
{
    OSStatus err = kNoErr;

    platform_mcu_powersave_disable();

#ifndef NO_MICO_RTOS
    mico_rtos_lock_mutex( &driver->tx_mutex );
#endif

    require_action_quiet( ( driver != NULL ) && ( data_out != NULL ) && ( size != 0 ), exit, err = kParamErr);

    /* Clear interrupt status before enabling DMA otherwise error occurs immediately */
    clear_dma_interrupts( driver->peripheral->tx_dma_config.stream, driver->peripheral->tx_dma_config.complete_flags | driver->peripheral->tx_dma_config.error_flags );

    /* Init DMA parameters and variables */
    driver->last_transmit_result                    = kGeneralErr;
    driver->tx_size                                 = size;
    driver->peripheral->tx_dma_config.stream->CR   &= ~(uint32_t) DMA_SxCR_CIRC;
    driver->peripheral->tx_dma_config.stream->NDTR  = size;
    driver->peripheral->tx_dma_config.stream->M0AR  = (uint32_t)data_out;

    USART_DMACmd( driver->peripheral->port, USART_DMAReq_Tx, ENABLE );
    USART_ClearFlag( driver->peripheral->port, USART_FLAG_TC );
    driver->peripheral->tx_dma_config.stream->CR   |= DMA_SxCR_EN;

    /* Wait for transmission complete */
#ifndef NO_MICO_RTOS
    mico_rtos_get_semaphore( &driver->tx_complete, MICO_NEVER_TIMEOUT );
#else
    while( driver->tx_complete == false );
    driver->tx_complete = false;
#endif

    while ( ( driver->peripheral->port->SR & USART_SR_TC ) == 0 )
    {
    }

    /* Disable DMA and clean up */
    USART_DMACmd( driver->peripheral->port, USART_DMAReq_Tx, DISABLE );
    driver->tx_size = 0;
    err = driver->last_transmit_result;

exit:
#ifndef NO_MICO_RTOS
    mico_rtos_unlock_mutex( &driver->tx_mutex );
#endif
    platform_mcu_powersave_enable();
    return err;
}
コード例 #9
0
ファイル: bsp.c プロジェクト: huang87975716/temp
//DMA配置:
void DMA_Configuration(void)
{
  DMA_InitTypeDef DMA_InitStructure;
  /* DMA clock enable */
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);//DMA1
  /* DMA1 Channel7 (triggered by USART2 Tx event) Config */
  DMA_DeInit(DMA1_Channel7);
  DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40004404;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)USART2_SEND_DATA;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  DMA_InitStructure.DMA_BufferSize = 512;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA1_Channel7, &DMA_InitStructure);
  DMA_ITConfig(DMA1_Channel7, DMA_IT_TC, ENABLE);
  DMA_ITConfig(DMA1_Channel7, DMA_IT_TE, ENABLE);
  /* Enable USART2 DMA TX request */
  USART_DMACmd(USART2, USART_DMAReq_Tx, ENABLE);
  DMA_Cmd(DMA1_Channel7, DISABLE);



/* DMA1 Channel6 (triggered by USART1 Rx event) Config */
  DMA_DeInit(DMA1_Channel6);
  DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40004404;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)USART2_RECEIVE_DATA;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_BufferSize = 512;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA1_Channel6, &DMA_InitStructure);
  DMA_ITConfig(DMA1_Channel6, DMA_IT_TC, ENABLE);
  DMA_ITConfig(DMA1_Channel6, DMA_IT_TE, ENABLE);
  /* Enable USART2 DMA RX request */
  USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE);
  DMA_Cmd(DMA1_Channel6, ENABLE);

}
コード例 #10
0
ファイル: usart.c プロジェクト: chenzhengxin/SmartScale
void UART_DMA_Rx_Enable(void)
{
    USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
	DMA_Cmd(DMA1_Channel5, DISABLE );
	DMA_SetCurrDataCounter(DMA1_Channel5,UART_RX_BUFFER_SIZE);
	DMA_Cmd(DMA1_Channel5, ENABLE); 
}
コード例 #11
0
ファイル: usart.cpp プロジェクト: 2cats/STM32
void Usart::enableDmaRead()
{
    DMA_InitTypeDef DMA_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

    DMA_DeInit(theConfig.DMA_Channel);

    DMA_InitStructure.DMA_PeripheralBaseAddr =  (uint32_t) & (USARTx->DR);
    DMA_InitStructure.DMA_MemoryBaseAddr =(u32)USART_defaultBuf;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = DMA_BUFSIZE;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;

    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize =DMA_MemoryDataSize_Byte;

    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(theConfig.DMA_Channel, &DMA_InitStructure);

    DMA_ITConfig(theConfig.DMA_Channel,DMA_IT_TC,ENABLE );
    USART_DMACmd(USARTx,USART_DMAReq_Rx,ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel = theConfig.DMA_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    DMA_Cmd(theConfig.DMA_Channel,ENABLE);

}
コード例 #12
0
ファイル: ZPH01.C プロジェクト: xz1996/Stm32_uCOSIII
//串口配置
void ZPH01_USART_Configuration(void)
{
    USART_InitTypeDef  USART_InitStructure;

	USART_InitStructure.USART_BaudRate=9600;				//波特率设置
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;//通信数据长度
	USART_InitStructure.USART_StopBits=USART_StopBits_1;		//停止位位数
	USART_InitStructure.USART_Parity=USART_Parity_No;			//无校验位
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;		//无硬件流控制
	USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;					//收发模式

	USART_Init(USART1,&USART_InitStructure);					//初始化配置
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);				//使能串口中断
	USART_Cmd(USART1,ENABLE);									//使能串口
	USART_ClearFlag(USART1,USART_FLAG_TC);						//清除发送完成标志
	
	USART_InitStructure.USART_BaudRate=9600;				//波特率设置
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;//通信数据长度
	USART_InitStructure.USART_StopBits=USART_StopBits_1;		//停止位位数
	USART_InitStructure.USART_Parity=USART_Parity_No;			//无校验位
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;		//无硬件流控制
	USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;					//收发模式

	USART_Init(USART2,&USART_InitStructure);					//初始化配置
	USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);				//使能串口接收中断
	//USART_ITConfig(USART2, USART_IT_IDLE,DISABLE);				//先失能串口空闲中断
	USART_Cmd(USART2,ENABLE);									//使能串口
	USART_ClearFlag(USART2,USART_FLAG_TC);						//清除发送完成标志
	
	/* Enable or Disable USART DMA RX request */
	USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE);

}
コード例 #13
0
ファイル: nfcTask.c プロジェクト: jongwonk/fun_thing1
void DMA_usart3_Configuration(void)
{
  DMA_InitTypeDef DMA_TX_InitStructure;

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);

  DMA_DeInit(DMA1_Stream3);
  DMA_TX_InitStructure.DMA_Channel = DMA_Channel_4;
  DMA_TX_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; // Transmit
  DMA_TX_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&(USART3->DR));
  DMA_TX_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_TX_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_TX_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_TX_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_TX_InitStructure.DMA_Mode = DMA_Mode_Normal;
  DMA_TX_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_TX_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
  DMA_TX_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
  DMA_TX_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  DMA_TX_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;

  DMA_Init(DMA1_Stream3, &DMA_TX_InitStructure);
  USART_DMACmd(USART3, USART_DMAReq_Tx, ENABLE);
  DMA_ITConfig(DMA1_Stream3, DMA_IT_TC, ENABLE);
  DMA_Cmd(DMA1_Stream3, ENABLE);
}
コード例 #14
0
ファイル: WBTDS01.c プロジェクト: joe3501/BlueRing
/**
* @brief  发数据给蓝牙模块
* @param[in] unsigned char *pData 要发送的数据
* @param[in] int length 要发送数据的长度
*/
static void send_data_to_WBTDS01(const unsigned char *pData, unsigned short length)
{
	//while(length--)
	//{
	//	USART_SendData(USART2, *pData++);
	//	while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET)
	//	{
	//	}
	//}
	//while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET){};

	/* disable DMA */
	DMA_Cmd(DMA1_Channel7, DISABLE);

	/* set buffer address */
	memcpy(wbtd_send_buff,pData,length);

	DMA1_Channel7->CMAR = (u32)&wbtd_send_buff[0];
	/* set size */
	DMA1_Channel7->CNDTR = length;

	USART_DMACmd(USART2, USART_DMAReq_Tx , ENABLE);
	/* enable DMA */
	DMA_Cmd(DMA1_Channel7, ENABLE);

	while(DMA1_Channel7->CNDTR);
	while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET){};
}
コード例 #15
0
 /**
  * @brief  USART1 GPIO 配置,工作模式配置。115200 8-N-1
  * @param  无
  * @retval 无
  */
void USART1_Config(uint32_t BaudRate)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	
	/* config USART1 clock */
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
	
	/* USART1 GPIO config */
	/* Configure USART1 Tx (PA.09) as alternate function push-pull */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);    
	
	/* Configure USART1 Rx (PA.10) as input floating */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	/* USART1 mode config */
	USART_InitStructure.USART_BaudRate = BaudRate;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No ;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_Init(USART1, &USART_InitStructure);
    /* 使能串口2接收中断 */
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);	
    USART_ClearFlag(USART1,USART_FLAG_TC);//先清除一下发送中断标志位,会解决第一个字节丢失的问题。
    USART_Cmd(USART1, ENABLE);
    USART1_NVIC_Configuration(ENABLE);
    USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);
}
コード例 #16
0
ファイル: main.cpp プロジェクト: bmaxfie/Cerulean-Hardware
void DMA_Configuration(void)
{
 
 
  DMA_InitStructure.DMA_Channel = DMA_Channel_4;
  DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; // Transmit
  DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)Buffer;
  DMA_InitStructure.DMA_BufferSize = (uint16_t)sizeof(Buffer);
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&UART4->DR;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  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_Full;
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
 
  DMA_Init(DMA1_Stream4, &DMA_InitStructure);
 
  /* Enable the USART Tx DMA request */
  USART_DMACmd(UART4, USART_DMAReq_Tx, ENABLE);
 
  /* Enable DMA Stream Transfer Complete interrupt */
  //DMA_ITConfig(DMA1_Stream4, DMA_IT_TC, ENABLE);
 
  /* Enable the DMA Tx Stream */
  DMA_Cmd(DMA1_Stream4, ENABLE);
}
コード例 #17
0
ファイル: main.c プロジェクト: MbedTinkerer/uart_dma
void stopRXDMA(){
  DMA_Cmd(USARTx_RX_DMA_STREAM, DISABLE);
  /* Clear USART Transfer Complete Flags */
  USART_ClearFlag(USARTx,USART_FLAG_TC);
  /* Enable USART DMA RX Requsts */
  USART_DMACmd(USARTx, USART_DMAReq_Rx, DISABLE);
}
コード例 #18
0
ファイル: platform_uart.c プロジェクト: yangk/Mico
static OSStatus receive_bytes( platform_uart_driver_t* driver, void* data, uint32_t size, uint32_t timeout )
{
  OSStatus err = kNoErr;

  if ( driver->rx_buffer != NULL )
  {
    driver->peripheral->rx_dma_config.stream->CR |= DMA_SxCR_CIRC;
    
    // Enabled individual byte interrupts so progress can be updated
    USART_ClearITPendingBit( driver->peripheral->port, USART_IT_RXNE );
    USART_ITConfig( driver->peripheral->port, USART_IT_RXNE, ENABLE );
  }
  else
  {
    driver->rx_size = size;
    driver->peripheral->rx_dma_config.stream->CR &= ~(uint32_t) DMA_SxCR_CIRC;
  }
  
  clear_dma_interrupts( driver->peripheral->rx_dma_config.stream, driver->peripheral->rx_dma_config.complete_flags | driver->peripheral->rx_dma_config.error_flags );

  driver->peripheral->rx_dma_config.stream->NDTR  = size;
  driver->peripheral->rx_dma_config.stream->M0AR  = (uint32_t)data;
  driver->peripheral->rx_dma_config.stream->CR   |= DMA_SxCR_EN;
  USART_DMACmd( driver->peripheral->port, USART_DMAReq_Rx, ENABLE );
  
  if ( timeout > 0 )
  {
    err = mico_rtos_get_semaphore( &driver->rx_complete, timeout );
  }
  return err;
}
コード例 #19
0
ファイル: hal_uart_dma.c プロジェクト: XHelaoshi/USER
void hal_uart_dma_receive_block(uint8_t *data, uint16_t size){
	/*
	 * USART1_RX is on DMA_CHANNEL5
	 */
	/* Reset DMA channel*/
	//DMA_Cmd(RX_DMA_CHANNEL,DISABLE);
	RST_CMD(0);
	DMA_DeInit(RX_DMA_CHANNEL);
	dma_init.DMA_Channel = USARTx_RX_DMA_CHANNEL;
	dma_init.DMA_PeripheralBaseAddr = (uint32_t)& BT_USART->DR;
	dma_init.DMA_Memory0BaseAddr = (uint32_t)data;
	dma_init.DMA_BufferSize = size;
	dma_init.DMA_DIR = DMA_DIR_PeripheralToMemory;
	dma_init.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
	dma_init.DMA_MemoryInc = DMA_MemoryInc_Enable;
	dma_init.DMA_PeripheralDataSize =
			DMA_PeripheralDataSize_Byte;
	dma_init.DMA_MemoryDataSize =
			DMA_MemoryDataSize_Byte;
	dma_init.DMA_Mode = DMA_Mode_Normal;
	dma_init.DMA_Priority = DMA_Priority_High;
	dma_init.DMA_FIFOMode = DMA_FIFOMode_Disable;
	dma_init.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
	dma_init.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
	dma_init.DMA_MemoryBurst = DMA_MemoryBurst_Single;
	//dma_init.DMA_M2M = DMA_M2M_Disable;
	DMA_Init(RX_DMA_CHANNEL, &dma_init);
	DMA_ITConfig(RX_DMA_CHANNEL,DMA_IT_TC,ENABLE);
	DMA_ClearITPendingBit(RX_DMA_CHANNEL,DMA_IT_TCIF1);
	USART_DMACmd(BT_USART,USART_DMAReq_Rx,ENABLE);
	DMA_Cmd(RX_DMA_CHANNEL,ENABLE);
	RST_CMD(1);
	//rt_kprintf("need %d\n",size);
}
コード例 #20
0
ファイル: hal_uart_dma.c プロジェクト: XHelaoshi/USER
void hal_uart_dma_send_block(const uint8_t *data, uint16_t size){

	// printf("hal_uart_dma_send_block size %u\n", size);
	/*
	 * USART1_TX Using DMA_CHANNEL4 
	 */
	//DMA_Cmd(TX_DMA_CHANNEL,DISABLE);
	/* Reset DMA channel*/
	DMA_DeInit(TX_DMA_CHANNEL);
	dma_init.DMA_Channel = USARTx_TX_DMA_CHANNEL;
	dma_init.DMA_PeripheralBaseAddr = (uint32_t)& BT_USART->DR;
	dma_init.DMA_Memory0BaseAddr = (uint32_t)data;
	dma_init.DMA_BufferSize = size;
	dma_init.DMA_DIR = DMA_DIR_MemoryToPeripheral;
	dma_init.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
	dma_init.DMA_MemoryInc = DMA_MemoryInc_Enable;
	dma_init.DMA_PeripheralDataSize =
			DMA_PeripheralDataSize_Byte;
	dma_init.DMA_MemoryDataSize =
			DMA_MemoryDataSize_Byte;
	dma_init.DMA_Mode = DMA_Mode_Normal;
	dma_init.DMA_Priority = DMA_Priority_VeryHigh;
	dma_init.DMA_FIFOMode = DMA_FIFOMode_Disable;
	//dma_init.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
	dma_init.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
	dma_init.DMA_MemoryBurst = DMA_MemoryBurst_Single;
//	dma_init.DMA_M2M = DMA_M2M_Disable;
	DMA_Init(TX_DMA_CHANNEL, &dma_init);
	DMA_ITConfig(TX_DMA_CHANNEL,DMA_IT_TC,ENABLE);
	DMA_ClearITPendingBit(TX_DMA_CHANNEL,DMA_IT_TCIF3);
	USART_DMACmd(BT_USART,USART_DMAReq_Tx,ENABLE);
	DMA_Cmd(TX_DMA_CHANNEL,ENABLE);
	//rt_kprintf("send %d\n",size);	
}
コード例 #21
0
/*Printf while waiting for it to finish, DMA based*/
int sync_printf(char * fmt, ...)
{
	if (DMA_GetCmdStatus(COM_TX_DMA_STREAM[USART_COM1]))
		return -1;
	int n;
	va_list ap;
	va_start(ap, fmt);
	n = vsprintf((char *) COM_TX_BUFFER[USART_COM1], fmt, ap);
	va_end(ap);

	COM_TX_DMA_STREAM[USART_COM1]->NDTR = (uint16_t) n;
	USART_DMACmd(COM_USART[USART_COM1], USART_DMAReq_Tx, ENABLE);
	/* Clear the TC bit in the SR register by writing 0 to it */
	USART_ClearFlag(COM_USART[USART_COM1], USART_FLAG_TC);
	/* Enable the DMA TX Stream, USART will start sending the command code (2bytes) */
	DMA_Cmd(COM_TX_DMA_STREAM[USART_COM1], ENABLE);



	/*wait for sigal to be reset*/
	while ((USART_GetFlagStatus(COM_USART[USART_COM1], USART_FLAG_TC) == RESET))
	{
	}
	COM1_TX_COMPLETE();

	return n;
}
コード例 #22
0
ファイル: xbee.cpp プロジェクト: slayerrensky/arm-projekt
/*
 * DMA konfigurieren mit Startadresse der Daten und länge des Strings
 * DMA sendet dann die Daten via Uart
 */
void Xbee::SendViaDma(char *startBuf, int sizeofBytes)
{
	if (XbeeInstance->SendFirst)
	{
		XbeeInstance->SendFirst = 0;
	}
	else
	{
		int a = DMA_GetFlagStatus(DMA1_Stream6, DMA_FLAG_TCIF6) == RESET;
		while (a)
		{
			a = DMA_GetFlagStatus(DMA1_Stream6, DMA_FLAG_TCIF6) == RESET;
		}
		memcpy(XbeeInstance->dmaBuffer, startBuf, sizeofBytes);
	}

	DMA_DeInit(DMA1_Stream6);
	USART_ClearFlag(USART2, USART_FLAG_TC);

	DMA_InitStruct.DMA_Memory0BaseAddr = (uint32_t)XbeeInstance->dmaBuffer;
	DMA_InitStruct.DMA_BufferSize = sizeofBytes;

	DMA_Init(DMA1_Stream6, &DMA_InitStruct);

	USART_DMACmd(USART2,USART_DMAReq_Tx,ENABLE);

	DMA_Cmd(DMA1_Stream6, ENABLE);

}
コード例 #23
0
ファイル: usart.c プロジェクト: hsjia/DIY
void usart1_init(void){
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);	//ENABLE RCC_GPIOA AND RCC_AFIO
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;			//PA10 RX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;			//PA9 TX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	//ENABLE RCC_USART1
	USART_DeInit(USART1);			//DEINIT USART1
	USART_InitStructure.USART_BaudRate = 38400;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_Init(USART1, &USART_InitStructure);			//INIT USART1
	
	USART_SendData(USART1, (uint8_t) 0x00);				//FOR CLEAR TXE
	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
	
	USART_Cmd(USART1, ENABLE);							//ENABLE USART1
	USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
	USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);
	
	printf("USART1 INIT OK\r\n");
}
コード例 #24
0
ファイル: usart.c プロジェクト: glocklueng/MCU_WIFI
/**
  * @brief  Configures the DMA2 Channel4 for SDIO Rx request.
  * @param  BufferDST: pointer to the destination buffer
  * @param  BufferSize: buffer size
  * @retval None
  */
static void DMA_RxConfiguration(uint32_t *BufferDST, uint32_t BufferSize)
{

	DMA_InitTypeDef DMA_InitStructure;

	DMA_ITConfig(DMA2_Stream5, DMA_IT_TC | DMA_IT_TE | DMA_IT_HT,DISABLE);
	DMA_ClearFlag(DMA2_Stream5, DMA_FLAG_TCIF5 | DMA_FLAG_TEIF5 | DMA_FLAG_HTIF5 | DMA_FLAG_DMEIF5 | DMA_FLAG_HTIF5);
   
	/* DMA2 Channel4 disable */
	DMA_Cmd(DMA2_Stream5, DISABLE);

	DMA_StructInit(&DMA_InitStructure);
	/* DMA2 Channel4 Config */
	DMA_InitStructure.DMA_Channel = DMA_Channel_4;
	DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&(USART1->DR);
	DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)BufferDST;
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
	DMA_InitStructure.DMA_BufferSize = BufferSize;
	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
	DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
	DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;   //循环模式
	DMA_InitStructure.DMA_Priority = DMA_Priority_High;
	DMA_Init(DMA2_Stream5, &DMA_InitStructure);
	u1_recv.pos = 0;   //当前读取位置清零
	/* DMA2 Channel4 enable */
	DMA_ITConfig(DMA2_Stream5, DMA_IT_TE,ENABLE); //使能出错中断
	DMA_Cmd(DMA2_Stream5, ENABLE);
	USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);
	NVIC_EnableIRQ(DMA2_Stream5_IRQn);
}
コード例 #25
0
ファイル: main.c プロジェクト: AkeelAli/microprocessorsystems
/*******************************************************************************
* Function Name  : USART_Configuration
* Description    : Configures the USART1.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void USART_Configuration(void)
{
  USART_InitTypeDef  USART_InitStructure;

/* USART1 configuration ------------------------------------------------------*/
  /* USART1 configured as follow:
        - BaudRate = 9600 baud  
        - Word Length = 8 Bits
        - One Stop Bit
        - No parity
        - Hardware flow control disabled (RTS and CTS signals)
        - Receive and transmit enabled
  */
  USART_InitStructure.USART_BaudRate = 9600;
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

  USART_Init(USART1, &USART_InitStructure);
  
  USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
  
  /* Enable the USART1 */  
  USART_Cmd(USART1, ENABLE);
}
コード例 #26
0
ファイル: TUart.c プロジェクト: KHIEM2812/mySTMlib
void TUartDMA() {
    sprintf(serialPort3->txBuf, "hello\r\n");
    int length = strlen(serialPort3->txBuf);
    DMA_SetCurrDataCounter(USARTx_TX_DMA_STREAM, length);
    DMA_Cmd(USARTx_TX_DMA_STREAM, ENABLE);
    USART_DMACmd(USARTx, USART_DMAReq_Tx, ENABLE);
}
コード例 #27
0
ファイル: usart1.c プロジェクト: DharmaPatil/asp
static u8 usart1_dma_send(u8* buff, u32 buff_len)	
{
	u8 BoxErr = 0;
	s32 timeout = tx_timeout_ticks;
	if(buff_len > MAX_TX_BUFF_SIZE) return 0;
	if(buff_len == 0) return 0;
	
	while( (dmx_send_complete == 0) && timeout > 0)
	{
			SysTimeDly(1);
			--timeout;
	}
	memcpy(tx_buff,buff,buff_len);
  DMA2_Stream7->NDTR = buff_len;					   						//发送字节数量
	dmx_send_complete = 0;
	USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE); 	//开启
	DMA_Cmd(DMA2_Stream7, ENABLE);									//始能DMA通道
	
	SysMboxPend(tx_event,tx_timeout_ticks,&BoxErr);
	
	if(BoxErr != 0)
	{
		return 0;
	}
	if(dmx_send_complete != 1)
	{
		
	}
	return buff_len;	

}
コード例 #28
0
ファイル: stuff.c プロジェクト: vehar/CAN-viewer
void DMA_USART_Init(uint32_t MemAddr)
{
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);

    DMA_DeInit(DMA1_Stream6);
    DMA_InitStructure.DMA_Channel = DMA_Channel_4;
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART2->DR;
    DMA_InitStructure.DMA_Memory0BaseAddr = MemAddr;
    DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
    DMA_InitStructure.DMA_BufferSize = 1;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
    DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull;
    DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    DMA_Init(DMA1_Stream6, &DMA_InitStructure);
    //USART2->CR3 |= USART_CR3_DMAT;
    USART_DMACmd(USART2,USART_DMAReq_Tx,ENABLE);
    DMA_Cmd(DMA1_Stream6, ENABLE);
}
コード例 #29
0
ファイル: uart.c プロジェクト: edgardo87/lepton
/*******************************************************************************
* Function Name  : uart_close
* Description    : Close the USART port communication
* Input          : - Uart: Select the USART or the UART peripheral.
* Output         : None
* Return         : 0
*******************************************************************************/
int uart_close(const _Uart_Descriptor *Uart)
{
  /* Disable IT */
  NVIC_DisableIRQ(Uart->IRQn);

  /* Free control variables and buffers */
  if (*Uart->Ctrl)
  {
    if ((*Uart->Ctrl)->DmaBufSize)
    {
      USART_DMACmd(Uart->UARTx, USART_DMAReq_Rx, DISABLE);
      NVIC_DisableIRQ(Uart->DMAx_IRQn);
      DMA_DeInit(Uart->DMAy_Streamx);
    }
    if (((*Uart->Ctrl)->HwCtrl & UART_HW_FLOW_CTRL_RX) || ((*Uart->Ctrl)->HwCtrl & UART_HALF_DUPLEX)) gpio_init((*Uart->Ctrl)->Gpio);
    _sys_free(*Uart->Ctrl);
    *Uart->Ctrl = 0;
  }

  /* Deactivate UART peripheral */
  USART_DeInit(Uart->UARTx);

  /* Disable peripheral clock */
  (*Uart->RCC_APBxPeriphClockCmd)(Uart->RCC_APBxPeriph, DISABLE);

  /* Configure GPIO to default state */
  gpio_init(Uart->TxGpio);
  gpio_init(Uart->RxGpio);

  return(0);
}
コード例 #30
0
ファイル: usart.c プロジェクト: glocklueng/MCU_WIFI
void DMA2_Stream7_IRQHandler()  //发送中断
{	
	uint32_t irq_flag;
	enter_interrupt();

	DMA_Cmd(DMA2_Stream7, DISABLE);
	NVIC_DisableIRQ(DMA2_Stream7_IRQn);
	irq_flag = local_irq_save(); 

	if(DMA_GetFlagStatus(DMA2_Stream7, DMA_FLAG_TEIF7))
	{
		
		p_err("uart dma err");
	}

	DMA_ITConfig(DMA2_Stream7, DMA_IT_TC | DMA_IT_TE | DMA_IT_HT,DISABLE);
	DMA_ClearFlag(DMA2_Stream7, DMA_FLAG_TCIF7 | DMA_FLAG_TEIF7 | DMA_FLAG_HTIF7 | DMA_FLAG_DMEIF7 | DMA_FLAG_HTIF7);
   
	u1_send.cnt = DMA2_Stream7->NDTR;   //取剩余字数,应该为0
	local_irq_restore(irq_flag);
	USART_DMACmd(USART1, USART_DMAReq_Tx, DISABLE);
	p_dbg("u_send irq\n");
	wake_up(u1_send.wait);   //唤醒等待线程
	
	exit_interrupt(1);
}