C++ (Cpp) __HAL_UART_CLEAR_FLAG Examples

Example #1

File: serial_api.c Project: antonio-salieri/mbed

void serial_clear(serial_t *obj) {
    UartHandle.Instance = (USART_TypeDef *)(obj->uart);
    __HAL_UART_CLEAR_FLAG(&UartHandle, UART_FLAG_TXE);
    __HAL_UART_CLEAR_FLAG(&UartHandle, UART_FLAG_RXNE);
}

Example #2

File: serial_api.c Project: AlessandroA/mbed

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
    if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
        __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
    }
}

Example #3

File: serial_api.c Project: Farewellly/mbed

void serial_clear(serial_t *obj)
{
    UART_HandleTypeDef *handle = &UartHandle[SERIAL_OBJ(index)];
    __HAL_UART_CLEAR_FLAG(handle, UART_FLAG_TXE);
    __HAL_UART_CLEAR_FLAG(handle, UART_FLAG_RXNE);
}

Example #4

File: serial_api.c Project: Farewellly/mbed

/** The asynchronous TX and RX handler.
 *
 * @param obj The serial object
 * @return Returns event flags if a TX/RX transfer termination condition was met or 0 otherwise
 */
int serial_irq_handler_asynch(serial_t *obj)
{
    volatile int return_event = 0;
    uint8_t *buf = (uint8_t*)obj->rx_buff.buffer;
    uint8_t i = 0;

  // Irq handler is common to Tx and Rx
    UART_HandleTypeDef *handle = &UartHandle[SERIAL_OBJ(index)];
#if DEVICE_SERIAL_ASYNCH_DMA
    if ((handle->Instance->CR3 & USART_CR3_DMAT) !=0) {
        // call dma tx interrupt
        HAL_DMA_IRQHandler(handle->hdmatx);
    }
    if ((handle->Instance->CR3 & USART_CR3_DMAR) !=0) {
        // call dma rx interrupt
        HAL_DMA_IRQHandler(handle->hdmarx);
    }
#endif
    HAL_UART_IRQHandler(handle);
  // TX PART:
    if (__HAL_UART_GET_FLAG(handle, UART_FLAG_TC) != RESET) {
        __HAL_UART_CLEAR_FLAG(handle, UART_FLAG_TC);
        // return event SERIAL_EVENT_TX_COMPLETE if requested
        if ((SERIAL_OBJ(events) & SERIAL_EVENT_TX_COMPLETE ) != 0){
            return_event |= SERIAL_EVENT_TX_COMPLETE & obj->serial.events;
        }
    }
    // handle error events:
    if (__HAL_UART_GET_FLAG(handle, HAL_UART_ERROR_PE)) {
        __HAL_UART_CLEAR_FLAG(handle, HAL_UART_ERROR_PE);
        return_event |= SERIAL_EVENT_RX_PARITY_ERROR & obj->serial.events;
    }
    if (__HAL_UART_GET_FLAG(handle, HAL_UART_ERROR_NE)||(handle->ErrorCode & HAL_UART_ERROR_NE)!=0) {
      __HAL_UART_CLEAR_FLAG(handle, HAL_UART_ERROR_NE);
      // not supported by mbed
    }
    if (__HAL_UART_GET_FLAG(handle, HAL_UART_ERROR_FE)||(handle->ErrorCode & HAL_UART_ERROR_FE)!=0) {
      __HAL_UART_CLEAR_FLAG(handle, HAL_UART_ERROR_FE);
        return_event |= SERIAL_EVENT_RX_FRAMING_ERROR & SERIAL_OBJ(events);
    }
    if (__HAL_UART_GET_FLAG(handle, HAL_UART_ERROR_ORE)||(handle->ErrorCode & HAL_UART_ERROR_ORE)!=0) {
      __HAL_UART_CLEAR_FLAG(handle, HAL_UART_ERROR_ORE);
        return_event |= SERIAL_EVENT_RX_OVERRUN_ERROR & SERIAL_OBJ(events);
    }

    //RX PART
    // increment rx_buff.pos
    if (handle->RxXferSize !=0) {
        obj->rx_buff.pos = handle->RxXferSize - handle->RxXferCount;
    }
    if ((handle->RxXferCount==0)&&(obj->rx_buff.pos >= (obj->rx_buff.length - 1))) {
        return_event |= SERIAL_EVENT_RX_COMPLETE & SERIAL_OBJ(events);
    }
    // Chek if Char_match is present
    if (SERIAL_OBJ(events) & SERIAL_EVENT_RX_CHARACTER_MATCH) {
      if (buf != NULL){
        while((buf[i] != obj->char_match)&&(i<handle->RxXferSize)){//for (i=0;i<UartHandle.RxXferSize;i++){
          i++;//if (buf[i] == obj->char_match{
          //}
        }
        if (i<handle->RxXferSize){
            obj->rx_buff.pos = i;
            return_event |= SERIAL_EVENT_RX_CHARACTER_MATCH & SERIAL_OBJ(events);
        }
      }
    }
    return return_event;  
}

Example #5

File: serial_api.c Project: AlessandroA/mbed-hal-st-stm32f4

void serial_clear(serial_t *obj)
{
    UART_HandleTypeDef *handle = &UartHandle[obj->serial.module];
    __HAL_UART_CLEAR_FLAG(handle, UART_FLAG_TXE);
    __HAL_UART_CLEAR_FLAG(handle, UART_FLAG_RXNE);
}

Example #6

File: stm32f4xx_it.c Project: BGCX261/zhonx3-git

/**
* @brief This function handles USART3 global interrupt.
*/
void USART3_IRQHandler(void)
{
  /* USER CODE BEGIN USART3_IRQn 0 */
  uint32_t      uart_status_flag;
  uint32_t      uart_it_flag;
  static char   *pBuffer = serial_buffer;
  unsigned char c;
  /* USER CODE END USART3_IRQn 0 */
  HAL_UART_IRQHandler(&huart3);
  /* USER CODE BEGIN USART3_IRQn 1 */

  // Get UART flags
  uart_status_flag = __HAL_UART_GET_FLAG(&huart3, UART_FLAG_RXNE);
  uart_it_flag = __HAL_UART_GET_IT_SOURCE(&huart3, UART_IT_RXNE);

  if ((uart_status_flag != RESET) && (uart_it_flag != RESET))
  {
      // Clear interrupt flag
      __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_RXNE);

      // Get the character received
      c = (uint16_t)(huart3.Instance->DR & (uint16_t)0x01FF);

      switch (c)
      {
          case CMDLINE_CR:
              // Carriage Return
              cmdline_ctxt.cmd_len = (pBuffer - serial_buffer) + 1;
              cmdline_ctxt.cmd_received = TRUE;
              *pBuffer = c;
              pBuffer = serial_buffer;
              return;

          case CMDLINE_LF:
              // Line Feed
              pBuffer = serial_buffer;
              break;

          case CMDLINE_BS:
              // Backspace
              if (pBuffer == serial_buffer)
              {
                  HAL_UART_Transmit(&huart3, (unsigned char *)"\x07", 1, 100);
              }
              else
              {
                  HAL_UART_Transmit(&huart3, (unsigned char *)"\x08\x7F", 2, 100);
                  pBuffer--;
              }
              break;

          default:
              /* Echo received character */
              HAL_UART_Transmit(&huart3, &c, 1, 100);
              *pBuffer = c;
              pBuffer++;
              break;
      }
  }

  /* USER CODE END USART3_IRQn 1 */
}