title: STM32 only works properly the first time and then drops bytes
body: <p>I am having a strange problem. I have a board with 2 UART interfaces (STM32F217) and I am using DMA to receive the data on both UARTs (USART1 and USART2).</p>
  
  <p>USART2 works perfectly. I can send and receive data through it no problem, but I am having a problem with USART1. It only works properly the first transfer. If it just worked once and then stopped then I'd be ok, since it probably means that I just need to add the function for USART1 interruption and call its IRQHandler But my problem is that the next times it receives the data, but it drops the first few bytes (randomly ... sometimes drops 2 sometimes drops up to 6 bytes and it's not like it's a fast protocol, it has a 1s timeout). </p>
  
  <p>Here is my workflow:
  - Initialize UART;</p>
  
  <ul>
  <li><p>Call Receive_DMA;</p></li>
  <li><p>Protocol has variable size, it depends on the first bytes so I configured a fixed 256 circular receive transfer (maximum size for header + data) and check how many bytes have been received so far, if the amount matches the first byte then it's ok. </p></li>
  <li><p>After error (did not receive entire packet, wrong CRC or timeout) or success then call </p>
  
  <p>HAL_UART_DMAStop(&amp;huart1);</p></li>
  </ul>
  
  <p>and then </p>
  
  <pre><code>if(HAL_UART_Receive_DMA(&amp;huart1, rx232buffer, 256) != HAL_OK) {
      while(1);
  }
  </code></pre>
  
  <p>This is done for both UARTs and one works perfectly and the other works well the first time and then starts dropping bytes. </p>
  
  <p>Any idea of what could be the problem?</p>
  
  <p><strong>EDIT</strong></p>
  
  <p>Here's a version of my code. I wrote the functionality just now (inside main loop ... it's not exactly that but it works similar to that ... my code is kinda big and with many things not related to the communication so I just rewrote it like this ... as stated huart1 only works properly once and then drops bytes ... huart2 works fine .. huart1 is RS232 ... huart2 i RS485)</p>
  
  <pre><code>static void rxbuffer[256] = {0};
  static void rx232buffer[256] = {0};
  
  struct header {
      int startWord;
      int command;
      int size;
  };
  
  UART_HandleTypeDef huart1;
  UART_HandleTypeDef huart2;
  DMA_HandleTypeDef hdma_usart1_rx;
  DMA_HandleTypeDef hdma_usart1_tx;
  DMA_HandleTypeDef hdma_usart2_rx;
  DMA_HandleTypeDef hdma_usart2_tx;
  
  static void MX_DMA_Init(void)
  {
      /* DMA controller clock enable */
      __HAL_RCC_DMA2_CLK_ENABLE();
      __HAL_RCC_DMA1_CLK_ENABLE();
  
      /* DMA interrupt init */
      /* DMA1_Stream5_IRQn interrupt configuration */
      HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0);
      HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
      /* DMA1_Stream6_IRQn interrupt configuration */
      HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 5, 0);
      HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
      /* DMA2_Stream2_IRQn interrupt configuration */
      HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);
      HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
      /* DMA2_Stream7_IRQn interrupt configuration */
      HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 5, 0);
      HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);
  }
  
  static void MX_USART1_UART_Init(void)
  {
      huart1.Instance = USART1;
      huart1.Init.BaudRate = 57600;
      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(&amp;huart1) != HAL_OK)
      {
        _Error_Handler(__FILE__, __LINE__);
      }
  
  }
  
  static void MX_USART2_UART_Init(void)
  {
      huart2.Instance = USART2;
      huart2.Init.BaudRate = 57600;
      huart2.Init.WordLength = UART_WORDLENGTH_8B;
      huart2.Init.StopBits = UART_STOPBITS_1;
      huart2.Init.Parity = UART_PARITY_NONE;
      huart2.Init.Mode = UART_MODE_TX_RX;
      huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
      huart2.Init.OverSampling = UART_OVERSAMPLING_16;
      if (HAL_UART_Init(&amp;huart2) != HAL_OK)
       {
        _Error_Handler(__FILE__, __LINE__);
       }
  
  }
  
  int main(void)
  {
      int bytecount;
      int bytecount232;
  
      int rxlen485;
      int rxlen232;
      HAL_Init();
  
      SystemClock_Config();
  
      MX_GPIO_Init();
      MX_DMA_Init();
      MX_USART1_UART_Init();
      MX_USART2_UART_Init();
  
      if(HAL_UART_Receive_DMA(&amp;huart2, rxbuffer, 256) != HAL_OK) {
          while(1);
      }
  
      if(HAL_UART_Receive_DMA(&amp;huart1, rx232buffer, 256) != HAL_OK) {
          while(1);
      }
  
      while(1) {
          bytecount = __HAL_DMA_GET_COUNTER(&amp;hdma_usart2_rx);
          rxlen485 = 256 - bytecount;
          bytecount232 = __HAL_DMA_GET_COUNTER(&amp;hdma_usart1_rx);
          rxlen232 = 256 - bytecount232;
  
          if(rxlen485 &gt;= sizeof(struct header)) {
              //start timer
              struct header *pHeader = rxbuffer;
              if(pHeader-&gt;size == rxlen485 - sizeof(struct header)) {
                  //do something
                  HAL_UART_DMAStop(&amp;huart2);
                  if(HAL_UART_Receive_DMA(&amp;huart2, rxbuffer, 256) != HAL_OK) {
                      while(1);
              }
  
              if(timeout) { // purely demonstrative ... the timeout part
                  //do something
                  HAL_UART_DMAStop(&amp;huart2);
                  if(HAL_UART_Receive_DMA(&amp;huart2, rxbuffer, 256) != HAL_OK) {
                      while(1);
                  }
              }
          }
  
          if(rxlen232 &gt;= sizeof(struct header)) {
              struct header *pHeader = rxbuffer;
              if(pHeader-&gt;size == rxlen232 - sizeof(struct header)) {
                  //do something
                  HAL_UART_DMAStop(&amp;huart1);
                  if(HAL_UART_Receive_DMA(&amp;huart1, rx232buffer, 256) != HAL_OK) {
                      while(1);
                  }
  
                  if(timeout) { // purely demonstrative ... the timeout part
                      //do something
                      HAL_UART_DMAStop(&amp;huart1);
                      if(HAL_UART_Receive_DMA(&amp;huart1, rx232buffer, 256) != HAL_OK) {
                          while(1);
                      }
                  }
              }
          }
      }
  }
  
  void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
      __NOP();
  }
  
  void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
      __NOP();
  }
  
  void USART2_IRQHandler(void)
  {
    /* USER CODE BEGIN USART2_IRQn 0 */
  
    /* USER CODE END USART2_IRQn 0 */
    HAL_UART_IRQHandler(&amp;huart2);
    /* USER CODE BEGIN USART2_IRQn 1 */
  
    /* USER CODE END USART2_IRQn 1 */
  }
  
  void USART1_IRQHandler(void)
  {
    /* USER CODE BEGIN USART2_IRQn 0 */
  
    /* USER CODE END USART2_IRQn 0 */
    HAL_UART_IRQHandler(&amp;huart1);
    /* USER CODE BEGIN USART2_IRQn 1 */
  
    /* USER CODE END USART2_IRQn 1 */
  }
  
  
  
  
  
  
  //----- in another file--------
  void HAL_UART_MspInit(UART_HandleTypeDef* huart)
  {
  
    GPIO_InitTypeDef GPIO_InitStruct;
    if(huart-&gt;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     ------&gt; USART1_TX
      PA10     ------&gt; USART1_RX
      PA11     ------&gt; USART1_CTS
      PA12     ------&gt; USART1_RTS 
      */
      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, &amp;GPIO_InitStruct);
  
      GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12;
      GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
      GPIO_InitStruct.Pull = GPIO_NOPULL;
      GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
      GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
      HAL_GPIO_Init(GPIOA, &amp;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_CIRCULAR;
      hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
      hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
      if (HAL_DMA_Init(&amp;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_LOW;
      hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
      if (HAL_DMA_Init(&amp;hdma_usart1_tx) != HAL_OK)
      {
        _Error_Handler(__FILE__, __LINE__);
      }
  
      __HAL_LINKDMA(huart,hdmatx,hdma_usart1_tx);
  
    /* USER CODE BEGIN USART1_MspInit 1 */
  
    /* USER CODE END USART1_MspInit 1 */
    }
    else if(huart-&gt;Instance==USART2)
    {
    /* USER CODE BEGIN USART2_MspInit 0 */
  
    /* USER CODE END USART2_MspInit 0 */
      /* Peripheral clock enable */
      __HAL_RCC_USART2_CLK_ENABLE();
  
      /**USART2 GPIO Configuration    
      PD5     ------&gt; USART2_TX
      PD6     ------&gt; USART2_RX 
      */
      GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6;
      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_USART2;
      HAL_GPIO_Init(GPIOD, &amp;GPIO_InitStruct);
  
      /* USART2 DMA Init */
      /* USART2_RX Init */
      hdma_usart2_rx.Instance = DMA1_Stream5;
      hdma_usart2_rx.Init.Channel = DMA_CHANNEL_4;
      hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
      hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
      hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
      hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
      hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
      hdma_usart2_rx.Init.Mode = DMA_CIRCULAR;
      hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;
      hdma_usart2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
      if (HAL_DMA_Init(&amp;hdma_usart2_rx) != HAL_OK)
      {
        _Error_Handler(__FILE__, __LINE__);
      }
  
      __HAL_LINKDMA(huart,hdmarx,hdma_usart2_rx);
  
      /* USART2_TX Init */
      hdma_usart2_tx.Instance = DMA1_Stream6;
      hdma_usart2_tx.Init.Channel = DMA_CHANNEL_4;
      hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
      hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
      hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;
      hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
      hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
      hdma_usart2_tx.Init.Mode = DMA_NORMAL;
      hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;
      hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
      if (HAL_DMA_Init(&amp;hdma_usart2_tx) != HAL_OK)
      {
        _Error_Handler(__FILE__, __LINE__);
      }
  
      __HAL_LINKDMA(huart,hdmatx,hdma_usart2_tx);
  
      HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
      HAL_NVIC_EnableIRQ(USART2_IRQn);
    }
  
  }
  </code></pre>