STM32实战总结:HAL之串口

串口基础参考:嵌入式常见接口协议总结_路溪非溪的博客-CSDN博客

串口内容补充

在STM32中的参考手册中,只讲了USART,并没有提及UART,一开始很疑惑。

难道STM32没有UART?

后面看了数据手册,里面讲了有3个USART和2个UART。

这里讲一下这两个的区别。

UART是通用异步收发器,而USART是通用同步异步收发器。
一般而言,单片机中:

  • 名称为UART的接口一般只能用于异步串行通讯。
  • 名称为USART的接口既可以用于同步串行通讯,也能用于异步串行通讯。

事实上当我们使用USART在异步通信的时候,它与UART没有什么差别。

可是用在同步通信的时候,差别就非常明显了:大家都知道同步通信需要时钟来触发数据传输,也就是说USART相对UART的差别之中的一个就是能提供主动时钟。
如STM32的USART能够提供时钟支持ISO7816的智能卡接口。

在实际使用中,基本不会用到USART的同步功能,又因为USART异步功能和UART一样,所以,基本上可以看做STM32有5个UART。

除了开头链接中讲的基本概念外,以下再补充一些关于串口的知识: 

通信原理

UART用一条传输线将数据一位位地顺序传送,以字符为传输单位。通信中两个字符间的时间间隔多少是不固定的,然而在同一个字符中的两个相邻位间的时间间隔是固定的。

一个字符的信息由起始位、数据位、奇偶校验位和停止位组成。

STM32实战总结:HAL之串口_第1张图片

首先明确,高电平为空闲位;

  • 起始位: 先发出一个逻辑0信号, 表示传输字符的开始,因为串口的起始位都是统一规定的,所以通常不必特意设置。
  • 数据位: 在STM32中,支持8位(包含奇偶校验位)或9位数据位(包含奇偶校验位)
  • 校验位: 数据位加上这一位后, 使得1的位数应为偶数(偶校验)或奇数(奇校验)
  • 停止位: 它是一个字符数据的结束标志. 可以是1位、1.5位、2位的高电平。
  • 空闲位: 处于逻辑1状态, 表示当前线路上没有数据传送。

根据以上可知,每传递一个字符,在不需要奇偶校验的情况下,需要传送10bit。 

常用的波特率有4800、9600、115200,最常用的就是9600。

115200虽然速度快,但是不太稳定,传输距离近。 

查看参考手册

 STM32实战总结:HAL之串口_第2张图片

32F103xE有5个USART接口。

3个USART,2个UART.

更多功能描述和寄存器操作细节自行查阅参考手册。

老实讲,STM32的参考手册讲的USART比较多,看不太懂,在此记录UART相关的重点内容。

◆PCLK1用于USART2345PCLK2用于USART1

◆全双工的,异步通信。

◆USART利用分数波特率发生器提供宽范围的波特率选择。不要在通信进行中改变波特率寄存器的数值。

◆使用多缓冲器配置的DMA方式,可以实现高速数据通信。

◆总线在发送或接收前应处于空闲状态

◆一个起始位

◆可编程数据字长度(8位或9)

◆校验控制

─ 发送校验位

─ 对接收数据进行校验

◆可配置的停止位-支持12个停止位,由此表明数据帧的结束

◆空闲帧包括了停止位。

◆单独的发送器和接收器使能位

◆检测标志

─ 接收缓冲器满

─ 发送缓冲器空

─ 传输结束标志

◆四个错误检测标志

─ 溢出错误

─ 噪音错误

─ 帧错误

─ 校验错误

◆RX:接收数据串行输。通过过采样技术来区别数据和噪音,从而恢复数据。

◆TX:发送数据输出。当发送器被禁止时,输出引脚恢复到它的I/O端口配置。当发送器被激活, 并且不发送数据时,TX引脚处于高电平。

查看原理图

查看电路设计,如果有使用到相关芯片,再查看相关芯片的数据手册。

STM32实战总结:HAL之串口_第3张图片

这里的CH340是一个USB和TTL的转换芯片。

接到了单片机的USART1接口:

因为需要向PC端打印调试信息,所以,当前只关注发送引脚,即PA9

初始化

打开之前的工程,打开MX文件,接着配置串口。

1、起始位

2、数据位

3、校验位

4、停止位

5、波特率

具体过程如下:

选中USAT1

STM32实战总结:HAL之串口_第4张图片

模式这里选择异步,就相当于是UART

STM32实战总结:HAL之串口_第5张图片

硬件流控不需要。

接着进行基本参数的设置。

注意

字长包含了奇偶校验位

如果不设置奇偶校验位,字长就选8位;

如果设置奇偶校验位,字长就选择9位;

总之,保证数据位是8位

停止位1位即可

采样率默认即可

STM32实战总结:HAL之串口_第6张图片

配置示例:

STM32实战总结:HAL之串口_第7张图片

其他选项可暂时不管。

OK,重新生成代码。

打开新代码,可以看到,多了usart.c文件,以及对应的头文件。

STM32实战总结:HAL之串口_第8张图片

文件里面同样是自动生成的该外设的初始化代码。

看一下其中的一个初始化函数:

void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  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;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

第一行

huart1是一个结构体变量,通过调用Instance指针来设置USART1各寄存器的地址。通常,初始化第一步就是这样,定义好寄存器的各地址,方便后续操作。

STM32实战总结:HAL之串口_第9张图片

第二行及往后,都是在设置串口,分别是波特率、数据位长度、停止位、奇偶校验、发送还是接收、流控、采样等。这里,和MX中设置的是一致的。

电路连接

将USB连接到单片机的串口电路,并在PC端安装CH340驱动。

STM32实战总结:HAL之串口_第10张图片

打开SecureCRT,创建终端。

STM32实战总结:HAL之串口_第11张图片

点击确定连接。

查看HAL串口库函数

前期工作都准备好了,现在开始写代码,通过串口输出信息。

那么,HAL中串口相关的函数有哪些呢?

查看相关驱动层文件stm32f1xx_hal_uart.h和stm32f1xx_hal_uart.c

有很多输出函数:

/* Exported functions --------------------------------------------------------*/
/** @addtogroup UART_Exported_Functions
  * @{
  */

/** @addtogroup UART_Exported_Functions_Group1 Initialization and de-initialization functions
  * @{
  */

/* Initialization/de-initialization functions  **********************************/
HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength);
HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod);
HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart);
void HAL_UART_MspInit(UART_HandleTypeDef *huart);
void HAL_UART_MspDeInit(UART_HandleTypeDef *huart);

/* Callbacks Register/UnRegister functions  ***********************************/
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
HAL_StatusTypeDef HAL_UART_RegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID, pUART_CallbackTypeDef pCallback);
HAL_StatusTypeDef HAL_UART_UnRegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID);

HAL_StatusTypeDef HAL_UART_RegisterRxEventCallback(UART_HandleTypeDef *huart, pUART_RxEventCallbackTypeDef pCallback);
HAL_StatusTypeDef HAL_UART_UnRegisterRxEventCallback(UART_HandleTypeDef *huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */

/**
  * @}
  */

/** @addtogroup UART_Exported_Functions_Group2 IO operation functions
  * @{
  */

/* IO operation functions *******************************************************/
HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);
HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);
HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart);

HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint16_t *RxLen, uint32_t Timeout);
HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);

/* Transfer Abort functions */
HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart);

void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);
void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart);

void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size);

/**
  * @}
  */

/** @addtogroup UART_Exported_Functions_Group3
  * @{
  */
/* Peripheral Control functions  ************************************************/
HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_MultiProcessor_ExitMuteMode(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart);
/**
  * @}
  */

/** @addtogroup UART_Exported_Functions_Group4
  * @{
  */
/* Peripheral State functions  **************************************************/
HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart);
uint32_t              HAL_UART_GetError(UART_HandleTypeDef *huart);

当前,我们需要向PC端发送信息,所以目前重点关注函数是IO operation functions中的发送函数,发送结束后不用中断提醒,采用常规的轮询模式来发送即可。

HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);

其返回值是一个状态:

typedef enum
{
  HAL_OK       = 0x00U,
  HAL_ERROR    = 0x01U,
  HAL_BUSY     = 0x02U,
  HAL_TIMEOUT  = 0x03U
} HAL_StatusTypeDef;

第一个参数是指定哪个串口,已经在初始化中定义过了,具体参数就是初始化的参数:

UART_HandleTypeDef huart1;

第二个参数是个char *,也就是要发送的字符/字符串;

第三个参数是要发送的内容的字节大小;

第四个参数是超时时间,也就是说,必须在规定的时间内发送完,因为开串口的时候用的是systick,所以是毫秒为单位(HAL库中只有少量的TimeOut是us级别,大部分都是ms级别;

具体实现,查看定义:

/**
  * @brief  Sends an amount of data in blocking mode.
  * @note   When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
  *         the sent data is handled as a set of u16. In this case, Size must indicate the number
  *         of u16 provided through pData.
  * @param  huart Pointer to a UART_HandleTypeDef structure that contains
  *               the configuration information for the specified UART module.
  * @param  pData Pointer to data buffer (u8 or u16 data elements).
  * @param  Size  Amount of data elements (u8 or u16) to be sent
  * @param  Timeout Timeout duration
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
{
  uint8_t  *pdata8bits;
  uint16_t *pdata16bits;
  uint32_t tickstart = 0U;

  /* Check that a Tx process is not already ongoing */
  if (huart->gState == HAL_UART_STATE_READY)
  {
    if ((pData == NULL) || (Size == 0U))
    {
      return  HAL_ERROR;
    }

    /* Process Locked */
    __HAL_LOCK(huart);

    huart->ErrorCode = HAL_UART_ERROR_NONE;
    huart->gState = HAL_UART_STATE_BUSY_TX;

    /* Init tickstart for timeout management */
    tickstart = HAL_GetTick();

    huart->TxXferSize = Size;
    huart->TxXferCount = Size;

    /* In case of 9bits/No Parity transfer, pData needs to be handled as a uint16_t pointer */
    if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    {
      pdata8bits  = NULL;
      pdata16bits = (uint16_t *) pData;
    }
    else
    {
      pdata8bits  = pData;
      pdata16bits = NULL;
    }

    /* Process Unlocked */
    __HAL_UNLOCK(huart);

    while (huart->TxXferCount > 0U)
    {
      if (UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
      {
        return HAL_TIMEOUT;
      }
      if (pdata8bits == NULL)
      {
        huart->Instance->DR = (uint16_t)(*pdata16bits & 0x01FFU);
        pdata16bits++;
      }
      else
      {
        huart->Instance->DR = (uint8_t)(*pdata8bits & 0xFFU);
        pdata8bits++;
      }
      huart->TxXferCount--;
    }

    if (UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    {
      return HAL_TIMEOUT;
    }

    /* At end of Tx process, restore huart->gState to Ready */
    huart->gState = HAL_UART_STATE_READY;

    return HAL_OK;
  }
  else
  {
    return HAL_BUSY;
  }
}

代码实现

在myapplication.h中添加usart.h头文件。

本来是可以添加新文件来实现串口的,不过串口算是一个各个地方都会用到的函数,所以直接放到public文件中。

在public.h中的结构体中增加一个函数指针。

#ifndef _PUBLIC_H_
#define _PUBLIC_H_

#include "stdint.h"

typedef struct 
{
    void (*printToScreen)(uint8_t * stringSize);

} public_operator;

extern public_operator publicOperator;

#endif

实现对应的public.c文件

#include "myapplication.h"

static void PrintToScreen(uint8_t *);

public_operator publicOperator =
{
    PrintToScreen
};

static void PrintToScreen(uint8_t *string)
{
    uint16_t stringSize= sizeof(string);
    uint32_t outtime = stringSize * 8 / 115200 * 1000 + 5;
    
    HAL_UART_Transmit(&huart1, string, stringSize, outtime);
}

在设备初始化函数中调用

static void Peripheral_Set(void)
{
    publicOperator.printToScreen((uint8_t *)"program now begin!");
}

以上代码编译烧录后,会发现可以输出到屏幕上,但是只能看到prog这四个字母,为啥?

这里又犯了一个指针传递的问题,使用sizeof时,一定要注意你算出来的是指针的大小还是指针指向的数据的大小。

当我将“program now begin!”传入发送函数时,我其实传入的是一个首字符的首地址

(uint8_t *)"program now begin!" //强转后是个地址

在发送函数中,使用sizeof计算出的,实际上是指针的大小,也就是4个字节。所以,字节和超时时间的计算都错了。这就是为什么只能打印出4个字节的原因。

这里,先将后两个参数写死吧。

static void PrintToScreen(uint8_t *string)
{ 
    HAL_UART_Transmit(&huart1, string, 20, 5);
}

成功输出:

STM32实战总结:HAL之串口_第12张图片

代码优化

printf函数。

我们输出打印信息,通常会使用printf函数,这是标准输入输出头文件stdio.h中定义的函数。为了更加通用,我们能不能去重写printf,让printf的输出被重定位到我们的串口上呢?

为了实现这一目标,我们要先了解一下printf函数的源码。

跳转到printf的定义,只能到这里:

   /*
    * is equivalent to fprintf, but does not support floating-point formats.
    * You can use instead of fprintf to improve code size.
    * Returns: as fprintf.
    */
#pragma __printf_args
extern _ARMABI int printf(const char * __restrict /*format*/, ...) __attribute__((__nonnull__(1)));

再想跳转,跳不过去了。难道底层源码不对外开放?

看不到源码,只能去其他地方找资料了。将收集到的资料进行记录。

printf函数是将输入的内容以某种指定的格式输出到指定的端口,所以,在printf函数中,有两个最关键的函数:

一个是格式化函数vsprintf,主要功能是格式化打印信息,最终得到纯字符串格式的信息等待输出;

另外一个就是输出字符串的函数,要知道,在C中,是没有真正意义上的字符串的,所以,printf中输出字符串,是通过一个循环来一个一个输出字符来实现的。这个字符输出函数是fputc,该函数也是c的一个标准库函数,被printf调用,输出到指定的硬件上:

C 库函数 int fputc(int ch, FILE *stream) 把参数 char 指定的字符(一个无符号字符)写入到指定的流 stream 中,并把位置标识符往前移动。

网上一个课程里写了个大概实现,参考:

STM32实战总结:HAL之串口_第13张图片

移植的时候,格式化不用管。

既然printf是通过调用fputc来输出的,那么,我们就重写fputc,让输出通过串口输出。

_weak

既然要重写fputc,那么,问题来了,我们根本就进不去fputc这个函数,而且,人家写的好好的库函数,肯定不会轻易让你修改,一旦修改,肯定很多地方都会出错。

怎么办呢?

虽然没有在网上找到相关资料。但是,听课程里说,原fputc函数是个弱函数,在该函数前面加了_weak关键字。

函数名称前面加上__weak 修饰符,我们一般称这个函数为“弱函数”。

加上了__weak 修饰符的函数,用户可以在用户文件中重新定义一个同名函数,最终编译器编译的时候,会选择用户定义的函数,如果用户没有重新定义这个函数,那么编译器就会执行__weak 声明的函数,并且编译器不会报错。所以我们可以在别的地方定义一个相同名字的函数,而不必也尽量不要修改之前的函数,。
 

可见,弱函数就是个“备胎”,先用着,有了正式的就自然而然地被替换掉了。

更多详情参考:嵌入式C进阶三 —— weak | 陌路之引

fputc重写

于是,我们就可以直接写个fputc函数,就能实现重写fputc的目的。

这样,也不用再封装结构体来实现串口输出了。

将之前public中串口相关的内容删除。然后重写fputc,fputc中指定输出到串口即可。

int fputc(int ch, FILE *stream)
{
    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 5);
    return ch;
}

重写了fputc,也在外设初始化代码那里调用了printf

static void Peripheral_Set(void)
{
    printf("2022-09-07");
}

但是很奇怪,不仅没有输出字符串,而且,连状态机的流水灯也没了。

问题在哪里?

仔细想了想,会不会是设置的问题?

记起来之前学习工程设置时,好像有时候需要勾选工程里的这个选项,表示要使用自带的标准库:

STM32实战总结:HAL之串口_第14张图片

勾选之后,再下载,果然就可以了。

也是,printf本来就是自带的库函数,既然用到了,这里肯定要勾选。

至此,只重写了fputc函数,就实现了串口打印。

实现了printf的移植,可以使用其格式化方式,并且,输出到串口中查看输出。

你可能感兴趣的:(stm32,单片机,arm)