在固定间隔后通过STM32（Bluepill）接收到固定间隔后的角色

Question

我试图通过UART1从Atmega 328p不断地发送一个“ Hello”字符串到Bluepill板。我正在通过中断进行接收。 问题是几次后，它开始在我的串行显示器上给“ Ello”“ Hello”，我无法弄清楚什么问题。 波特率-9600 奇偶校验 - 无 stop bit-1

main.c：

usart_irq在此处称为“ USART代码在此处开始”下：

#include "main.h"
#include "uart.h"
UART_HandleTypeDef huart1;
char *readBuffer;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);

int main(void)
{
 HAL_Init();
 SystemClock_Config();
 MX_GPIO_Init();
  MX_USART1_UART_Init();

 /* USER CODE BEGIN 2 */
  __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);
    HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* USER CODE END 2 */

接收到的字符串使用ReadString存储在“ dechBuffer”中，并使用使用该串行监视器打印到序列显示我创建了一个单独的UART库。

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

      readBuffer=serialReadString1();
      writeString1(readBuffer);
      HAL_Delay(500);

    /* USER CODE BEGIN 3 */
  }

usart1_irqhandler

我启用了全局中断，并在那里称为接收函数，并使用了返回，因为我不想使用hal_irq：

void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
 receivestring1();
 return;
  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

uart.c

写字符串：

#include"main.h"
#include "uart.h"
#define RX_BUFFER_SIZE1 144

char rxBuffer1[RX_BUFFER_SIZE1];
uint16_t rx1ReadPos;


void sendChar1( uint8_t ch)
{
  while(!(USART1->SR & USART_SR_TXE));
  USART1->DR = ch;
}


void writeString1(const char c[])
{
    uint16_t i = 0;
        for (i = 0; i<= strlen(c); i++)
        {
            sendChar1(c[i]);
        }
        memset(rxBuffer1,0,RX_BUFFER_SIZE1);
        rx1ReadPos = 0;
}

用于阅读 ：细绳：

 unsigned char receivedChar1(void)
    {
       while(!(USART1->SR & USART_SR_RXNE));//check whether any tx is going on
       return USART1->DR;
    }
    
    void receivestring1()
    {
        while(!(USART1->SR & USART_SR_RXNE));//check whether any tx is going on
        rxBuffer1[rx1ReadPos] = USART1->DR;
    
                if (rxBuffer1[rx1ReadPos] != '\n')
                {
                    rx1ReadPos++;
                    if (rx1ReadPos >= RX_BUFFER_SIZE1)
                    {
                        rx1ReadPos = 0;
                    }
                }
    }
    
    char* serialReadString1()
    {
        return rxBuffer1;
    }

Answer 1

我可以在您的代码中发现几个潜在问题：

1. 您不应该跳过hal_uart_irqhandler（）在usart1_irqhandler（）中的调用。通常需要在中断控制器（NVIC）和/或相应的外围单元（在您的情况下）中中断（已清除）。如果没有这样做，您可能会立即将中断处理程序再次召唤，尽管没有真正的新事件。

2. while（！（usart1-＆gt; sr＆amp; usart_sr_rxne）））在receed> receed> receed> receed char1（） and code> rechivestring1（）的开头。不需要必要，因为只有在RX不为空时才能生成中断。您的中断配置看起来正确，因此仅由于问题1（见上文）可能需要这是必要的。

3. 变量rxbuffer1和rx1ReadPos在evevesivestring1（） and code> writestring1（）中都操纵。由于rechivestring1（）是从usart1_irqhandler（）调用writestring1（）从main（Main（）调用此操作实际上可以并行发生。这可能会成为问题，原因有两个：

   • 编译器可能不知道，rxBuffer1的内容可能会在任何情况下发生变化（例如，在处理 for for witteString1（） loop时>）。可以通过将volatile关键字添加到rxbuffer1，rx1ReadPos以及writestring1（）的参数。这样，编译器将重新评估strlen（c）在 loop的的每个通过中。
   • 该代码仍然可能尝试更改rx1ReadPos几乎同时，例如，之前的那一刻，当evereivestring1（）收到新字符时rx1ReadPos在writestring1（）中重置为零，这将导致失去该字符。这称为A 种族条件，只能通过在有限的时间内阻止中断，或者以确保该并行执行不能导致数据损失的方式来避免。一种可能的解决方案可能是使用两个单独的缓冲区 - 一个用于接收和一个用于写作的缓冲区。

   


4. writestring1（）是通过sendchar1（）将字符写入接收数据的同一UART1。这主要不是可以的，但是发送数据是使用相同的慢速9600波特速率。这真的很可能是，writestring1（）被usart1_irqhandler（）中断，即收到其他数据。最好将配置为更高BAUD率的其他UART用于调试目的。

我想您的“ Ello”问题主要由问题3引起。

附录

以检查STM32是否正确接收Atmega的字符，可以通过直接从中断处理程序发送每个接收的字符来简化代码（避免异步缓冲区处理的复杂性）。
这可能是这样的：

int main(void)
{
  [...]
  while(1)
  {
    // everything is done in IRQ handler
  }
}

void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
  unsigned char newChar;
  newChar = USART1->DR; // read received char
  USART1->DR = newChar; // send it out again right away

  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

Addendum＃2

通过请求是草图如何改进缓冲区的方法：

char rxBuffer1[RX_BUFFER_SIZE1];
char rxBuffer2[RX_BUFFER_SIZE1];
char* volatile rxBufferPtr = rxBuffer1;
volatile bool SwitchBufferRequest = false;

void writeString1(const char buffer[])
{
    for (int i = 0; i<= strlen(buffer); i++)
    {
        sendChar1(buffer[i]);
    }
    memset(buffer,0,RX_BUFFER_SIZE1);
}

void receivestring1()
{
    static uint16_t rxBufferPos = 0;

    if (SwitchBufferRequest)
    {
        if (rxBufferPtr == rxBuffer1)
        {
            rxBufferPtr = rxBuffer2;
        }
        else
        {
            rxBufferPtr = rxBuffer1;
        }
        rxBufferPos = 0;
        SwitchBufferRequest = false;
    }
    
    rxBufferPtr[rxBufferPos] = USART1->DR;
    
    if (rxBufferPos < (RX_BUFFER_SIZE1 - 2)) // buffer full?
    {
        rxBufferPos++;
    }
}
    
char* serialReadString1()
{
    char* rxBufferWithData = rxBufferPtr;

    SwitchBufferRequest = true;
    while (SwitchBufferRequest == true) {;} // wait for buffer switch
    return rxBufferWithData;
}

void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
  receivestring1();
  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

int main(void)
{
  [...]
  while (1)
  {
    /* USER CODE END WHILE */

      readBuffer=serialReadString1();
      writeString1(readBuffer);
      HAL_Delay(500);

    /* USER CODE BEGIN 3 */
  }
}

注：
此草图试图尽可能少地修改代码。关键想法是：

1. 使用两个单独的缓冲区（rxbuffer1和rxbuffer2） - 一个用于接收数据，一个用于再次将接收到的数据发送。
2. 切换中需要新数据时，请切换缓冲区
3. 每次需要在main（） serialReadString1（）中请求缓冲区 。缓冲区切换本身是在ISR内完成的，以避免任何种族条件。
4. 注意serialReadString1（）中的操作顺序：首先，在switchbufferrequest设置为true 因为rxbufferptr可能会在此后的任何时间更改。
5. writestring1（）仅通过删除rxbufferpos（现在在ISR中完成）的重置并清除Rx Buffer，而不是不是 使用， 。 RX ISR。