usart -> RTOR = 0.00175 * baudRate + 1;

У меня она вызывает три ошибки, последняя из которых такая: make: *** Error 1. Если usart -> RTOR присваевается константа, компиляция проходит без ошибок. Недоумение даже не в этом. Подстилаю соломку и записываю её в так:

usart -> RTOR = (uint32_t)(0.00175 *(float) baudRate) + 1;

И это тоже вызывает ошибку. Случайно вместо uint32_t записываю int32_t и, о чудо, - компиляция проходит без ошибок. Для меня это совершенно не понятная ситуация, поскольку RTOR определён как uint32_t. Можно было бы порадоваться и успокоиться, но остаётся беспокойство: "Не ударила бы эта "хорошая" непонятка в дальнейшем.

Прошу помощи. с. Скину фотки, ошибки что поможет решить проблему.

Заранее благодарен

Занимаюсь реализацией TUI через UART на STM32F1xx с HAL. Описание функциональности:

- Неблокирующий ввод

- Завершение ввода при нажатии Enter

- При нажатии на Backspace предыдущий символ удаляется (при наличии)

- Видимые символы отображаются

Вывод также хочется реализовать через прерывания, если вызов функции был сделан не из обработчика другого прерывания (в таком случае реализуется блокирующий вывод).

При написании кода использую кольцевой буфер (ring/circular buffer) для хранения строк. Он представляет из себя отдельную библиотеку.

Вот код проекта:

static UART_HandleTypeDef *console_uart = NULL;
static char line_buffer;
static uint16_t line_len = 0;

// TX Buffer
static ring_buffer_t tx_buffer;
static volatile uint8_t tx_busy = 0;
static volatile uint8_t tx_byte;

// RX Buffer
static ring_buffer_t rx_buffer;
static volatile uint8_t rx_byte;
static volatile uint8_t rx_ready = 0;

static void console_rx_callback(UART_HandleTypeDef *);
static void console_tx_callback(UART_HandleTypeDef *);

uint8_t console_init(UART_HandleTypeDef *huart) {
    if (huart == NULL || console_uart != NULL) {
        return 1;
    }

    console_uart = huart;

    ring_buffer_init(&tx_buffer);
    tx_busy = 0;    

    ring_buffer_init(&rx_buffer);
    rx_ready = 0;

    HAL_UART_RegisterCallback(
        console_uart,
        HAL_UART_RX_COMPLETE_CB_ID,
        console_rx_callback
    );

    HAL_UART_RegisterCallback(
        console_uart,
        HAL_UART_TX_COMPLETE_CB_ID,
        console_tx_callback
    );

    HAL_UART_Receive_IT(console_uart, (uint8_t *) &rx_byte, 1);
    return 0;
}

void console_print(const char *str) {
    HAL_UART_Transmit(console_uart, (uint8_t *) str, strlen(str), 10);
    // ring_buffer_write(&tx_buffer, (uint8_t *) str, strlen(str));

    // if (tx_busy == 0) {
    //     tx_busy = 1;
    //     tx_byte = ring_buffer_pop(&tx_buffer);
    //     HAL_UART_Transmit_IT(console_uart, &tx_byte, 1);
    // }
}

void console_clear() {
    console_print("\033[2J\033[H");
}

// Берет на себя всю обработку символов: backspace, enter и echo
void console_poll() {
    while (ring_buffer_get_length(&rx_buffer) > 0 && rx_ready == 0) {
        uint8_t ch = ring_buffer_pop(&rx_buffer);
        if ((ch == '\b' || ch == 0x7F) && line_len > 0) {
            line_len--;
            console_print("\b \b");
        }
        else if (ch == '\r' || ch == '\n') {
            line_buffer = '\0';
            rx_ready = 1;
            console_print("\r\n");
            return;
        }
        else if (line_len < CONSOLE_MAX_RX_DATA_LENGTH - 1) {
            line_buffer = ch;
            char echo = {ch, 0};
            console_print(echo);
        }
    }
}

uint8_t console_ready() {
    return rx_ready;
}

void console_read(char *buffer) {
    if (buffer == NULL || rx_ready == 0) {
        return;
    }
    
    strcpy(buffer, line_buffer);
    rx_ready = 0;
    line_len = 0;
    line_buffer = '\0';
}

static void console_tx_callback(UART_HandleTypeDef *console) {
    if (ring_buffer_get_length(&tx_buffer) == 0) {
        tx_busy = 0;
    }
    else {
        tx_byte = ring_buffer_pop(&tx_buffer);
        HAL_UART_Transmit_IT(console_uart, &tx_byte, 1);
    }
}

static void console_rx_callback(UART_HandleTypeDef *console) {
    ring_buffer_push(&rx_buffer, rx_byte);
    HAL_UART_Receive_IT(console_uart, &rx_byte, 1);
}

while(1) {
    console_poll();
    if (console_ready()) {
        console_read(consoleBuffer);
        // Действия с console buffer
    }
}

При подключении через утилиту screen на скорости 115200 выводит следующее (вводил просто '?'):

Rebooeot system
?. menu
cm>>
Unknoan
oy en
symenu
cm

То есть вывод максимально ломаный.

Знающие люди, подскажите, пожалуйста, что не так с этим кодом и в чем именно проблема. Нейронки не помогают, а в DMA сейчас не планирую лезть - хочу сперва разобраться с прерываниями.

Благодарю за любую помощь, спасибо!

TIM1_DeInit();
TIM1_TimeBaseInit(TIM1_PRESCALER, TIM1_COUNTERMODE_UP, TIM1_PERIOD, 0);
TIM1_OC1Init(TIM1_OCMODE_TOGGLE, TIM1_OUTPUTSTATE_ENABLE, TIM1_OUTPUTNSTATE_DISABLE,
           0, TIM1_OCPOLARITY_HIGH, TIM1_OCNPOLARITY_HIGH, TIM1_OCIDLESTATE_SET,
           TIM1_OCNIDLESTATE_RESET);
TIM1_OC2Init(TIM1_OCMODE_TOGGLE, TIM1_OUTPUTSTATE_ENABLE, TIM1_OUTPUTNSTATE_DISABLE,
           GradazSdvig, TIM1_OCPOLARITY_HIGH, TIM1_OCNPOLARITY_HIGH, TIM1_OCIDLESTATE_SET,
           TIM1_OCNIDLESTATE_RESET);
CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER1, ENABLE);
TIM1_CCxCmd(TIM1_CHANNEL_1, ENABLE); 
TIM1_Cmd(ENABLE);

#include "stm8s.h"
#include "math.h"
#include "stm8s_clk.h"
#include "stm8s_tim1.h"
uint16_t Counter = 0;
uint16_t Count_Otl = 0;
 
main()
{ 
CLK_DeInit();  
CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1 | CLK_PRESCALER_CPUDIV1);  // 16 мГц
  //TIM1_InternalClockConfig();
  //TIM1_TimeBaseInit(25 - 1, TIM1_COUNTERMODE_UP, 8 - 1, 0);
  TIM1_TimeBaseInit(25 - 1, TIM1_COUNTERMODE_UP, 65536 - 1, 0);
  //TIM1_SetCounter(0);
  CLK->SWCR = CLK_SWCR_SWEN;    // Включаем тактирование
  TIM1_Cmd(ENABLE);
 
while (1)
  {
    Counter = TIM1_GetCounter();
    Count_Otl++;   
  }
}

/* USER CODE BEGIN Header */

/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* 5 разных сообщений */
static const struct {
uint32_t id;
uint8_t data;
} can_messages[] = {
{0x001, {0x18, 0x00, 0x01, 0x24, 0x3A, 0x33, 0x0D, 0x00}},
{0x002, {0x80, 0x00, 0x13, 0xFE, 0x03, 0xFE, 0x0F, 0xFE}},
{0x003, {0x00, 0x00, 0x30, 0x08, 0x92, 0x80, 0x96, 0x4A}},
{0x004, {0x44, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00}},
{0x005, {0x02, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}
};

#define NUM_MESSAGES 5
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
CAN_HandleTypeDef hcan2;

/* USER CODE BEGIN PV */
CAN_TxHeaderTypeDef txHeader;
uint32_t txMailbox;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN2_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
* brief The application entry point.
* retval int
*/
int main(void)
{

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

HAL_Init();

SystemClock_Config();

MX_GPIO_Init();
MX_CAN2_Init();

/* USER CODE BEGIN 2 */

if (HAL_CAN_Start(&hcan2) != HAL_OK)
{
Error_Handler();
}

CAN_FilterTypeDef filter = {0};
filter.FilterBank = 14;
filter.SlaveStartFilterBank = 14;
filter.FilterMode = CAN_FILTERMODE_IDMASK;
filter.FilterScale = CAN_FILTERSCALE_32BIT;
filter.FilterIdHigh = 0x0000;
filter.FilterIdLow = 0x0000;
filter.FilterMaskIdHigh = 0x0000;
filter.FilterMaskIdLow = 0x0000;
filter.FilterFIFOAssignment = CAN_RX_FIFO0;
filter.FilterActivation = ENABLE;

if (HAL_CAN_ConfigFilter(&hcan2, &filter) != HAL_OK)
{
Error_Handler();
}

txHeader.RTR = CAN_RTR_DATA;
txHeader.IDE = CAN_ID_STD;
txHeader.DLC = 8;
txHeader.TransmitGlobalTime = DISABLE;

/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
uint8_t msg_index = 0;
uint32_t currentTime = 0;
uint32_t lastSendTime = 0;

while (1)
{
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */

currentTime = HAL_GetTick(); // Get current time in milliseconds

/* send every 250ms */
if ((currentTime — lastSendTime) >= 250) {
lastSendTime = currentTime;

txHeader.StdId = can_messages.id;

/* Abort всех mailbox'ов — очищаем от зависших (без ACK) */
HAL_CAN_AbortTxRequest(&hcan2, CAN_TX_MAILBOX0 | CAN_TX_MAILBOX1 | CAN_TX_MAILBOX2);

if (HAL_CAN_AddTxMessage(&hcan2, &txHeader, (uint8_t*)can_messages.data, &txMailbox) != HAL_OK)
{
Error_Handler();
}

/* Переходим к следующему сообщению */
msg_index = (msg_index + 1) % NUM_MESSAGES;

/* Если есть IWDG, можно добавить: */
/* HAL_IWDG_Refresh(&hiwdg); */
}

}
/* USER CODE END 3 */
}

/**
* brief System Clock Configuration
* retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.Prediv1Source = RCC_PREDIV1_SOURCE_HSE;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL4;
RCC_OscInitStruct.PLL2.PLL2State = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
{
Error_Handler();
}

__HAL_RCC_PLLI2S_ENABLE();
}

/**
* brief CAN2 Initialization Function
* param None
* retval None
*/
static void MX_CAN2_Init(void)
{

hcan2.Instance = CAN2;
hcan2.Init.Prescaler = 4;
hcan2.Init.Mode = CAN_MODE_NORMAL;
hcan2.Init.SyncJumpWidth = CAN_SJW_1TQ;
hcan2.Init.TimeSeg1 = CAN_BS1_13TQ;
hcan2.Init.TimeSeg2 = CAN_BS2_2TQ;
hcan2.Init.TimeTriggeredMode = DISABLE;
hcan2.Init.AutoBusOff = DISABLE;
hcan2.Init.AutoWakeUp = ENABLE;
hcan2.Init.AutoRetransmission = DISABLE; /* Одна попытка — ключ к работе без полного ACK */
hcan2.Init.ReceiveFifoLocked = DISABLE;
hcan2.Init.TransmitFifoPriority = ENABLE;
if (HAL_CAN_Init(&hcan2) != HAL_OK)
{
Error_Handler();
}
}

/**
* brief GPIO Initialization Function
* param None
* retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};

__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();

GPIO_InitStruct.Pin = GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

GPIO_InitStruct.Pin = GPIO_PIN_12;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
* brief This function is executed in case of error occurrence.
* retval None
*/
void Error_Handler(void)
{
__disable_irq();
while (1)
{
}
}

#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif /* USE_FULL_ASSERT */