如何使用stm32 cubeMX配置生成工程？

使用stm32 cubeMX配置生成工程

发送数据的时候可以发送第一包数据，进入的数据直接跳过了，过了，了，，，

仿真的时候没有任何问题，可以所有数据

上图





分析：
封装stxm2F4中文参考手册
使能这种模式（将DMA_SCR3寄存器中的EN位置1）时，数据流会立即启动传输，从源完全填充FIFO
如果DMA_SxNDTR寄存器获取零、外设请求传输终止（在使用设备外设请求传输终止）流控制器的情况下）或DMA_SxCR寄存器中的EN位由软件清零，传输即会停止。

结合代码：




//使能DMA数据流立即启动传输
#define __HAL_DMA_ENABLE(__HANDLE__)      ((__HANDLE__)->Instance->CR |=  DMA_SxCR_EN)
//传输终止
#define __HAL_DMA_DISABLE(__HANDLE__)     ((__HANDLE__)->Instance->CR &=  ~DMA_SxCR_EN)




HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  uint32_t *tmp;
  
  /* Check that a Tx process is not already ongoing */
  if(huart->gState == HAL_UART_STATE_READY)
  {
    if((pData == NULL ) || (Size == 0))
    {
      return HAL_ERROR;
    }


    /* Process Locked */
    __HAL_LOCK(huart);


    huart->pTxBuffPtr = pData;
    huart->TxXferSize = Size;
    huart->TxXferCount = Size;


    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->gState = HAL_UART_STATE_BUSY_TX;


    /* Set the UART DMA transfer complete callback */
    huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;


    /* Set the UART DMA Half transfer complete callback */
    huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;


    /* Set the DMA error callback */
    huart->hdmatx->XferErrorCallback = UART_DMAError;


    /* Set the DMA abort callback */
    huart->hdmatx->XferAbortCallback = NULL;


    /* Enable the UART transmit DMA Stream */
    tmp = (uint32_t*)&pData;
    HAL_DMA_Start_IT(huart->hdmatx, *(uint32_t*)tmp, (uint32_t)&huart->Instance->DR, Size);
   
    /* Clear the TC flag in the SR register by writing 0 to it */
    __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
   
    /* Process Unlocked */
    __HAL_UNLOCK(huart);
   
    /* Enable the DMA transfer for transmit request by setting the DMAT bit
       in the UART CR3 register */
    SET_BIT(huart->Instance->CR3, USART_CR3_DMAT);
   
    return HAL_OK;
  }
  else
  {
    return HAL_BUSY;
  }
}




HAL_StatusTypeDef HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)
{
  HAL_StatusTypeDef status = HAL_OK;


  /* calculate DMA base and stream number */
  DMA_Base_Registers *regs = (DMA_Base_Registers *)hdma->StreamBaseAddress;
  
  /* Check the parameters */
  assert_param(IS_DMA_BUFFER_SIZE(DataLength));

  /* Process locked */
  __HAL_LOCK(hdma);
  
  if(HAL_DMA_STATE_READY == hdma->State)
  {
    /* Change DMA peripheral state */
    hdma->State = HAL_DMA_STATE_BUSY;
   
    /* Initialize the error code */
    hdma->ErrorCode = HAL_DMA_ERROR_NONE;
   
    /* Configure the source, destination address and the data length */
    DMA_SetConfig(hdma, SrcAddress, DstAddress, DataLength);
   
    /* Clear all interrupt flags at correct offset within the register */
    regs->IFCR = 0x3FU << hdma->StreamIndex;
   
    /* Enable Common interrupts*/
    hdma->Instance->CR  |= DMA_IT_TC | DMA_IT_TE | DMA_IT_DME;
    hdma->Instance->FCR |= DMA_IT_FE;
   
    if(hdma->XferHalfCpltCallback != NULL)
    {
      hdma->Instance->CR  |= DMA_IT_HT;
    }
   
    /* Enable the Peripheral */
    __HAL_DMA_ENABLE(hdma);
  }
  else
  {
    /* Process unlocked */
    __HAL_UNLOCK(hdma);          
   
    /* Return error status */
    status = HAL_BUSY;
  }
  
  return status;
}


在DMA发送中断中加入DMA中断使能即可


        HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 1, 3);
        HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);


直接上代码吧
/* USART1 init function */
static void MX_USART1_UART_Init(uint32_t BaudRate)
{


  huart1.Instance = USART1;
  huart1.Init.BaudRate = 256000;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }
}


void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  if(huart->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspInit 0 */


  /* USER CODE END USART1_MspInit 0 */
    /* Peripheral clock enable */
    __HAL_RCC_USART1_CLK_ENABLE();
  
    /**USART1 GPIO Configuration   
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);


    /* USART1 DMA Init */
    /* USART1_RX Init */
    hdma_usart1_rx.Instance = DMA2_Stream2;
    hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_rx.Init.Mode = DMA_NORMAL;
    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
    hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
    {
      _Error_Handler(__FILE__, __LINE__);
    }


    __HAL_LINKDMA(huart,hdmarx,hdma_usart1_rx);


    /* USART1_TX Init */
    hdma_usart1_tx.Instance = DMA2_Stream7;
    hdma_usart1_tx.Init.Channel = DMA_CHANNEL_4;
    hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_tx.Init.Mode = DMA_NORMAL;
    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_HIGH;
    hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
    {
      _Error_Handler(__FILE__, __LINE__);
    }


    __HAL_LINKDMA(huart,hdmatx,hdma_usart1_tx);


    /* USART1 interrupt Init */
    HAL_NVIC_SetPriority(USART1_IRQn, 1, 3);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
        HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 1, 3);
        HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);
  /* USER CODE BEGIN USART1_MspInit 1 */


  /* USER CODE END USART1_MspInit 1 */
  }
}




//不使用DMA发送
int fputc(int ch,FILE *f)
{
          while((USART1->SR & 0x40) == 0);
        USART1->DR = (uint8_t)ch;
        return ch;
}
//使用DMA发送
void myprintf(UART_HandleTypeDef *huart, char *fmt,...){
        char buffer[CMD_BUF_LEN-1];
        uint8_t len=0;
        va_list arg_ptr;
        va_start(arg_ptr, fmt);
        len = vsnprintf(buffer, CMD_BUF_LEN+1, fmt, arg_ptr);
        //HAL_UART_Transmit(huart, (uint8_t*)buffer, len, 1*len);
        while(HAL_BUSY == HAL_UART_Transmit_DMA(huart,  (uint8_t*)buffer, len));
        va_end(arg_ptr);
}


//测试函数
//不使用DMA发送
printf( "system config completen");
printf( "system config complete2nnn");


//使用DMA发送
myprintf(&huart1, "hello stm32n");
myprintf(&huart1, "hello stm32 next1n");
myprintf(&huart1, "hello stm32 next2n");
myprintf(&huart1, "hello stm32 next3n");
myprintf(&huart1, "hello stm32 next4n");
myprintf(&huart1, "hello stm32 next5n");
myprintf(&huart1, "hello stm32 next6n");


测试结果：