usart_if.c

Go to the documentation of this file.

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file    usart_if.c
 * @author  MCD Application Team
 * @brief   Configuration of UART driver interface for hyperterminal communication
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2026 STMicroelectronics.
 * All rights reserved.
 *
 * This software is licensed under terms that can be found in the LICENSE file
 * in the root directory of this software component.
 * If no LICENSE file comes with this software, it is provided AS-IS.
 *
 ******************************************************************************
 */
/* USER CODE END Header */
 
/* Includes ------------------------------------------------------------------*/
#include "usart_if.h"
 
/* USER CODE BEGIN Includes */
#include "stm32_seq.h"
/* USER CODE END Includes */
 
/* External variables ---------------------------------------------------------*/
/**
  * @brief DMA handle
  */
extern DMA_HandleTypeDef hdma_usart1_tx;
 
/**
  * @brief UART handle
  */
extern UART_HandleTypeDef huart1;
 
/**
  * @brief buffer to receive 1 character
  */
uint8_t charRx;
 
/* USER CODE BEGIN EV */
 
char uart_req_buf[100];
char *uart_req_w_ptr;
static UART_HandleTypeDef *_curUart = NULL;     // aktualny uart
 
/* USER CODE END EV */
 
/* Private typedef -----------------------------------------------------------*/
/**
  * @brief Trace driver callbacks handler
  */
const UTIL_ADV_TRACE_Driver_s UTIL_TraceDriver =
{
  vcom_Init,
  vcom_DeInit,
  vcom_ReceiveInit,
  vcom_Trace_DMA,
};
 
/* USER CODE BEGIN PTD */
 
/* USER CODE END PTD */
 
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
 
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
/**
  * @brief  TX complete callback
  * @return none
  */
static void (*TxCpltCallback)(void *);
/**
  * @brief  RX complete callback
  * @param  rxChar ptr of chars buffer sent by user
  * @param  size buffer size
  * @param  error errorcode
  * @return none
  */
static void (*RxCpltCallback)(uint8_t *rxChar, uint16_t size, uint8_t error);
 
/* USER CODE BEGIN PV */
 
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
 
/* USER CODE BEGIN PFP */
 
/* USER CODE END PFP */
 
/* Exported functions --------------------------------------------------------*/
 
UTIL_ADV_TRACE_Status_t vcom_Init(void (*cb)(void *))
{
  /* USER CODE BEGIN vcom_Init_1 */
 
  /* USER CODE END vcom_Init_1 */
  TxCpltCallback = cb;
  MX_DMA_Init();
  MX_USART1_UART_Init();
  LL_EXTI_EnableIT_0_31(LL_EXTI_LINE_26);
  return UTIL_ADV_TRACE_OK;
  /* USER CODE BEGIN vcom_Init_2 */
 
  /* USER CODE END vcom_Init_2 */
}
 
UTIL_ADV_TRACE_Status_t vcom_DeInit(void)
{
  /* USER CODE BEGIN vcom_DeInit_1 */
    if (huart1.Instance == NULL)
        return UTIL_ADV_TRACE_HW_ERROR; // MT 4.2.2026 - suppress UART
 
  /* USER CODE END vcom_DeInit_1 */
  /* ##-1- Reset peripherals ################################################## */
  __HAL_RCC_USART1_FORCE_RESET();
  __HAL_RCC_USART1_RELEASE_RESET();
 
  /* ##-2- MspDeInit ################################################## */
  HAL_UART_MspDeInit(&huart1);
 
  /* ##-3- Disable the NVIC for DMA ########################################### */
  /* USER CODE BEGIN 1 */
    HAL_NVIC_DisableIRQ(DMA1_Channel5_IRQn);
 
    return UTIL_ADV_TRACE_OK;
  /* USER CODE END 1 */
  /* USER CODE BEGIN vcom_DeInit_2 */
 
  /* USER CODE END vcom_DeInit_2 */
}
 
void vcom_Trace(uint8_t *p_data, uint16_t size)
{
  /* USER CODE BEGIN vcom_Trace_1 */
    if (huart1.Instance == NULL)
        return;
 
  /* USER CODE END vcom_Trace_1 */
  HAL_UART_Transmit(&huart1, p_data, size, 1000);
  /* USER CODE BEGIN vcom_Trace_2 */
 
  /* USER CODE END vcom_Trace_2 */
}
 
UTIL_ADV_TRACE_Status_t vcom_Trace_DMA(uint8_t *p_data, uint16_t size)
{
  /* USER CODE BEGIN vcom_Trace_DMA_1 */
    if (huart1.Instance == NULL)
        return UTIL_ADV_TRACE_HW_ERROR;
 
    HAL_UART_Transmit(&huart1, p_data, size, 10000);    // MT 13.1.2026 - no DMA
    HAL_UART_TxCpltCallback(&huart1);   // must be called
      return UTIL_ADV_TRACE_OK;
 
 
  /* USER CODE END vcom_Trace_DMA_1 */
  HAL_UART_Transmit_DMA(&huart1, p_data, size);
  return UTIL_ADV_TRACE_OK;
  /* USER CODE BEGIN vcom_Trace_DMA_2 */
 
  /* USER CODE END vcom_Trace_DMA_2 */
}
 
UTIL_ADV_TRACE_Status_t vcom_ReceiveInit(void (*RxCb)(uint8_t *rxChar, uint16_t size, uint8_t error))
{
  /* USER CODE BEGIN vcom_ReceiveInit_1 */
 
    if (huart1.Instance == NULL)
        return UTIL_ADV_TRACE_HW_ERROR;
 
 
  /* USER CODE END vcom_ReceiveInit_1 */
  UART_WakeUpTypeDef WakeUpSelection;
 
  /*record call back*/
  RxCpltCallback = RxCb;
 
  /*Set wakeUp event on start bit*/
  WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
 
  HAL_UARTEx_StopModeWakeUpSourceConfig(&huart1, WakeUpSelection);
 
  /* Make sure that no UART transfer is on-going */
  while (__HAL_UART_GET_FLAG(&huart1, USART_ISR_BUSY) == SET);
 
  /* Make sure that UART is ready to receive)   */
  while (__HAL_UART_GET_FLAG(&huart1, USART_ISR_REACK) == RESET);
 
  /* Enable USART interrupt */
  __HAL_UART_ENABLE_IT(&huart1, UART_IT_WUF);
 
  /*Enable wakeup from stop mode*/
  HAL_UARTEx_EnableStopMode(&huart1);
 
  /*Start LPUART receive on IT*/
  HAL_UART_Receive_IT(&huart1, &charRx, 1);
 
  return UTIL_ADV_TRACE_OK;
  /* USER CODE BEGIN vcom_ReceiveInit_2 */
 
  /* USER CODE END vcom_ReceiveInit_2 */
}
 
void vcom_Resume(void)
{
  /* USER CODE BEGIN vcom_Resume_1 */
    if (huart1.Instance == NULL)
        return;
 
  /* USER CODE END vcom_Resume_1 */
  /*to re-enable lost UART settings*/
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
 
  /*to re-enable lost DMA settings*/
  if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN vcom_Resume_2 */
 
  /* USER CODE END vcom_Resume_2 */
}
 
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
  /* USER CODE BEGIN HAL_UART_TxCpltCallback_1 */
 
  /* USER CODE END HAL_UART_TxCpltCallback_1 */
  /* buffer transmission complete*/
  if (huart->Instance == USART1)
  {
    TxCpltCallback(NULL);
  }
  /* USER CODE BEGIN HAL_UART_TxCpltCallback_2 */
 
  /* USER CODE END HAL_UART_TxCpltCallback_2 */
}
 
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  /* USER CODE BEGIN HAL_UART_RxCpltCallback_1 */
 
  /* USER CODE END HAL_UART_RxCpltCallback_1 */
  if (huart->Instance == USART1)
  {
    if ((NULL != RxCpltCallback) && (HAL_UART_ERROR_NONE == huart->ErrorCode))
    {
      RxCpltCallback(&charRx, 1, 0);
    }
    HAL_UART_Receive_IT(huart, &charRx, 1);
  }
  /* USER CODE BEGIN HAL_UART_RxCpltCallback_2 */
    HAL_UART_RxCharMT(huart, charRx);
  /* USER CODE END HAL_UART_RxCpltCallback_2 */
}
 
/* USER CODE BEGIN EF */
 
/**
 * @brief called if char is ready from UART
 * @retval -1 - other UART, 0 - char is accepted, next receiving must start, 1 - data ready
 */
int HAL_UART_RxCharMT(UART_HandleTypeDef *huart, uint8_t charRx)
{
    int ret = -1;
    if (_curUart != NULL && huart->Instance == _curUart->Instance) //
    {
        *uart_req_w_ptr = charRx;
        if (*uart_req_w_ptr == '\n' || *uart_req_w_ptr == '\r' || uart_req_w_ptr == uart_req_buf + sizeof(uart_req_buf) - 2) //
        {
            ret = 1;
            UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_Uart_RX), CFG_SEQ_Prio_0);  // start of tasksensors_Work
        }
        else
        {
            uart_req_w_ptr++;
            ret = 0;
        }
    }
    return ret;
}
 
UTIL_ADV_TRACE_Status_t Uart_Info(const char *strInfo)
{
    UTIL_ADV_TRACE_Status_t status =  UTIL_ADV_TRACE_OK;//vcom_Trace_DMA((uint8_t*) strInfo, strlen(strInfo));
    vcom_Trace((uint8_t*) strInfo, strlen(strInfo));
    return status;
}
 
UTIL_ADV_TRACE_Status_t Uart_NextReceving()
{
    uart_req_w_ptr = uart_req_buf;
    memset(uart_req_buf, 0, sizeof(uart_req_buf));
    return UTIL_ADV_TRACE_OK;
}
 
UTIL_ADV_TRACE_Status_t Uart_StartReceving(UART_HandleTypeDef *uart) //
{
    _curUart = uart;
    Uart_NextReceving();
    return vcom_ReceiveInit(NULL);
}
 
/* USER CODE END EF */
 
/* Private Functions Definition -----------------------------------------------*/
 
/* USER CODE BEGIN PrFD */
 
/* USER CODE END PrFD */