STM32学习笔记——USART

STM32的USART组件支持异步、同步、单线半双工、多处理器、IrDA、LIN、SmartCard等模式，本文介绍的是异步即UART模式。

总线通信有三种模型：轮询、中断和DMA。DMA对我来说是陌生的内容，以后单独开篇细讲。

HAL

HAL把寄存器组组织成组件，组件包含外设的各个寄存器。在USART这里，寄存器不足以描述外设的所有状态，HAL用handle来包装组件。一个handle包含指向组件的指针、初始化参数、状态、与其他组件的链接（如DMA）和内部状态等。

图源ST官方MOOC，打开之前注意调低音量。

USART的初始化除了USART本身的寄存器以外，还要设置GPIO的复用功能，这两项任务分别在stm32f4xx_hal_uart.c中的HAL_UART_Init和stm32f4xx_hal_msp.c的HAL_UART_MspInit中完成（MSP意为“MCU Specific Package”）。stm32f4xx_hal_uart.c中也定义了HAL_UART_MspInit，添加了weak属性（提供实现，允许被覆写）。

轮询

轮询是与中断相对的。对于发送，轮询是指写一个字节（或一个packet），等待它发送完，再写下一个字节，直到所有数据被发送完才返回；对于接受，轮询是指等待直到接收到一定长度的数据。轮询相对简单，但是效率很低。

#include "main.h"
#include <string.h>

UART_HandleTypeDef huart1;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
void uart_transmit(const char* string);

int main(void)
{
  char buffer[2] = {0};
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  uart_transmit("hello\n");
  while (1)
  {
    HAL_StatusTypeDef status = HAL_UART_Receive(&huart1, buffer, 1, 1000);
    if (status == HAL_OK)
    {
      uart_transmit("received: ");
      uart_transmit(buffer);
      uart_transmit("\n");
    }
    else
      uart_transmit("timeout\n");
  }
}

void uart_transmit(const char* string)
{
  HAL_UART_Transmit(&huart1, string, strlen(string), 1000);
}

static void MX_USART1_UART_Init(void)
{
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  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(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
}

// ...

HAL的UART接收只能指定数据长度而不能指定终止符。在轮询模式下，可以设置数据长度为1，即每次读取一个字节，判断它是否为终止符。

中断

在中断模式下，函数立即返回，数据在中断中发送或接收。在发送或接收完成后，相应的回调函数会被调用。

#include "main.h"
#include <stdbool.h>
UART_HandleTypeDef huart1;
volatile bool finished = false;
char buffer[3] = {0};

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
void uart_transmit(const char* string);
void uart_transmit_it(const char* string);

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  uart_transmit_it("hello\n");
  const char* info = finished ? "already finished\n" : "still transmitting\n";
  while (!finished)
    ;
  finished = false;
  uart_transmit_it(info);
  uart_transmit_it(info);
  while (!finished)
    ;
  while (1)
  {
    finished = false;
    HAL_UART_Receive_IT(&huart1, buffer, 2);
    while (!finished)
      ;
    uart_transmit("received: ");
    uart_transmit(buffer);
    uart_transmit("\n");
  }
}

void uart_transmit(const char* string)
{
  HAL_UART_Transmit(&huart1, string, strlen(string), 1000);
}

void uart_transmit_it(const char* string)
{
  HAL_UART_Transmit_IT(&huart1, string, strlen(string));
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
  if (huart == &huart1)
  {
    finished = true;
  }
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  if (huart == &huart1)
  {
    finished = true;
  }
}

// ...

串口输出still transmitting，说明HAL_UART_Transmit_IT确实是发送完成前就返回的；still transmitting只出现一次，因为第二次调用时第一次的发送还没结束。

读了HAL的源码，我发现中断发送的数据是拷贝指针的，也就是浅拷贝的，需要保证发送期间该地址上的数据有效。比如，如果一个函数把局部变量数组作为参数传给HAL_UART_Transmit_IT，未等待发送完成便返回，那么发送的数据将会是错误的，甚至导致程序行为未定义。

如果给单片机发送了多余所需量的数据，程序会崩溃，我没有debug出问题在哪。

缓冲区

这样的接收连差强人意都算不上，我的终极目标是实现scanf那样的接收函数。中断发送只能缓冲一次和浅拷贝等问题也相当愚蠢，我想顺便把发送也改造成printf。改造的工具是用循环队列实现的缓冲区，这个我在AVR单片机教程中还煞有其事地写过，正好可以作为现在的练习。

queue.h：

#ifndef QUEUE_H
#define QUEUE_H

#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>

#ifdef __cplusplus
extern "C"
{
#endif

typedef struct
{
    uint16_t mask;
    uint16_t head;
    uint16_t tail;
    queue_element_t data[0];
} queue_t;

static inline queue_t* queue_create(uint16_t _size)
{
    if (_size & (_size - 1))
        _size = 256;
    queue_t* q = malloc(sizeof(queue_t) + _size * sizeof(queue_element_t));
    if (q)
    {
        q->mask = _size - 1;
        q->head = q->tail = 0;
    }
    return q;
}

static inline bool queue_empty(const volatile queue_t* _queue)
{
    return _queue->head == _queue->tail;
}

static inline bool queue_full(const volatile queue_t* _queue)
{
    return ((_queue->tail + 1) & _queue->mask) == _queue->head;
}

static inline uint16_t queue_size(const volatile queue_t* _queue)
{
    return (_queue->tail - _queue->head) & _queue->mask;
}

static inline uint16_t queue_capacity(const volatile queue_t* _queue)
{
    return _queue->mask;
}

static inline queue_element_t queue_peek(const volatile queue_t* _queue)
{
    return _queue->data[_queue->head];
}

static inline void queue_push(volatile queue_t* _queue, const queue_element_t _ele)
{
    _queue->data[_queue->tail] = _ele;
    _queue->tail = (_queue->tail + 1) & _queue->mask;
}

static inline void queue_pop(volatile queue_t* _queue)
{
    _queue->head = (_queue->head + 1) & _queue->mask;
}

#ifdef __cplusplus
}
#endif

#endif

写inline遇到了点问题，原来C和C++中的inline是不一样的！改成static inline就好了。有空再去深究这个问题。

main.c：

#include "main.h"
#include <string.h>
#include "cmsis_gcc.h"
typedef char queue_element_t;
#include "queue.h"
UART_HandleTypeDef huart1;
queue_t* tx_buffer;
queue_t* rx_buffer;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void usart1_init_0();
static void usart1_init_2();
static void usart1_transmit(const char* string);
static void usart1_receive(char* dest, char delim);

int main(void)
{
  char buffer[80];
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  usart1_transmit("hello\n");
  while (1)
  {
    usart1_receive(buffer, '\n');
    usart1_transmit("received: ");
    usart1_transmit(buffer);
    usart1_transmit("\n");
  }
}

void usart1_init_0()
{
  tx_buffer = queue_create(1024);
  rx_buffer = queue_create(1024);
}

void usart1_init_2()
{
  USART1->CR1 |= USART_CR1_RXNEIE & UART_IT_MASK;
}

void usart1_transmit(const char* string)
{
  uint16_t capacity = queue_capacity(tx_buffer);
  uint16_t size = strlen(string);
  bool ok = false;
  while (1)
  {
    __disable_irq();
    ok = capacity - queue_size(tx_buffer) >= size;
    if (ok)
        break;
    __enable_irq();
    __NOP();
  }
  for (uint16_t i = 0; i != size; ++i)
      queue_push(tx_buffer, string[i]);
  USART1->CR1 |= USART_CR1_TXEIE & UART_IT_MASK;
  __enable_irq();
}

void usart1_receive(char* dest, char delim)
{
  while (1)
  {
    bool ok = false;
    while (1)
    {
      __disable_irq();
      ok = !queue_empty(rx_buffer);
      if (ok)
        break;
      __enable_irq();
      __NOP();
    }
    char c = queue_peek(rx_buffer);
    queue_pop(rx_buffer);
    __enable_irq();
    if (c == delim)
      break;
    *dest++ = c;
  }
  *dest = '\0';
}

void usart1_transmit_handler()
{
  USART1->DR = queue_peek(tx_buffer);
  queue_pop(tx_buffer);
  if (queue_empty(tx_buffer))
    USART1->CR1 &= ~USART_CR1_TXEIE & UART_IT_MASK;
}

void usart1_receive_handler()
{
  queue_push(rx_buffer, USART1->DR);
}

void USART1_IRQHandler(void)
{
  uint32_t isrflags   = USART1->SR;
  uint32_t cr1its     = USART1->CR1;
  uint32_t errorflags = 0x00U;
  errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
  if (errorflags == RESET)
  {
    if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
    {
      usart1_receive_handler();
      return;
    }
    if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
    {
      usart1_transmit_handler();
      return;
    }
  }
  
  HAL_UART_IRQHandler(&huart1);
}

static void MX_USART1_UART_Init(void)
{
  usart1_init_0();
  
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  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(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  
  usart1_init_2();
}

中断的调用流程是：USART1中断请求调用USART1_IRQHandler（这个名字在startup_stm32f407vetx.s中定义），由STM32CubeMX生成的USART1_IRQHandler调用HAL_UART_IRQHandler，里面进行各种判断和处理，在合适的时机调用HAL_UART_TxCpltCallback等。我在USART1_IRQHandler中插入了一些代码，把TXE和RXNE两种中断拦截了下来，其余还是丢给HAL_UART_IRQHandler处理（Chain of Responsibility设计模式？）。

queue上的操作不是原子的，主函数与中断共享需要加锁。__disable_irq关闭全局中断，__enable_irq开启全局中断。ARM说在开中断之后Cortex-M3/4还可能执行2条指令才响应中断，而在汇编代码中cpsie后第二句就是cpsid，所以我在__enable_irq后加一句__NOP空指令，以保证中断请求能被响应。

离printf和scanf只有一步之遥了，但我想把它放到下一篇。20pin的ST-LINK/V2已经在路上了。