STM32串口通信

一、基于寄存器与基于固件库的STM32LED流水灯例子的编程方式差异比较

1、基于寄存器方式的开发特点：

（1）具体参数更直观；
（2）程序运行占用资源少。
但是它的缺陷也不可忽视，如下：
（1）开发速度慢；
（2）程序可读性差；
（3） 维护复杂。
上述缺陷直接影响了开发效率，程序维护成本，交流成本。通常情况下，只有在频繁调用的中断服务函数时利用直接配置寄存器的方式。
2、基于固态库方式开发，也就是直接调用库函数，特点就是：
（1）外设交流方便；
（2）查错简单；
（3）对主控制器STM32上手简单。
总的来说基于寄存器：资料丰富，容易理解，适合新手学习。
基于固件库：可移植性强，更贴近底层，要求对工作原理有深入理解，适合有丰富经验的人使用。

二、STM32的USART窗口通信

1.关于USART

USART是一个全双工通用同步/异步串行收发模块，该接口是一个高度灵活的串行通信设备。
主要特点：

• 全双工操作（相互独立的接收数据和发送数据）；

• 同步操作时，可主机时钟同步，也可从机时钟同步；

• 独立的高精度波特率发生器，不占用定时/计数器；

• 支持5、6、7、8和9位数据位，1或2位停止位的串行数据桢结构；

• 由硬件支持的奇偶校验位发生和检验；

• 数据溢出检测；

• 帧错误检测；

• 包括错误起始位的检测噪声滤波器和数字低通滤波器；

• 三个完全独立的中断，TX发送完成、TX发送数据寄存器空、RX接收完成；

• 支持多机通信模式；

• 支持倍速异步通信模式。

结构组成：

• USART收发模块一般分为三大部分：时钟发生器、数据发送器和接收器。控制寄存器为所有的模块共享。
• 时钟发生器由同步逻辑电路（在同步从模式下由外部时钟输入驱动）和波特率发生器组成。发送时钟引脚XCK仅用于同步发送模式下，发送器部分由一个单独的写入缓冲器（发送UDR）、一个串行移位寄存器、校验位发生器和用于处理不同帧结构的控制逻辑电路构成。使用写入缓冲器，实现了连续发送多帧数据无延时的通信。
• 接收器是USART模块最复杂的部分，最主要的是时钟和数据接收单元。数据接收单元用作异步数据的接收。除了接收单元，接收器还包括校验位校验器、控制逻辑、移位寄存器和两级接收缓冲器（接收UDR）。接收器支持与发送器相同的帧结构，同时支持帧错误、数据溢出和校验错误的检测。

2.USART原理图

3.STM32的USART窗口通信程序实战

打开官方资料里的USART1接发文件里的工程
修改stm32f10x_it.c的代码
代码如下：

int i=0;
uint8_t ucTemp[50];
void DEBUG_USART_IRQHandler(void)
{
	if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE)!=RESET)
	{
		ucTemp[i] = USART_ReceiveData(USART1);	
	}
  if(ucTemp[i] == '!')
	{
		if(ucTemp[i-1] == '2'&&ucTemp[i-2] == '3'&&ucTemp[i-3] == 'm'&&ucTemp[i-4] == 't'&&ucTemp[i-5] == 's'&&ucTemp[i-6] == ' ')
			if(ucTemp[i-7] == 'p'&&ucTemp[i-8] == 'o'&&ucTemp[i-9] == 't'&&ucTemp[i-10] == 's')
			{
				printf("收到！");
        while(1);
			}
	}
	i++;
}

修改主函数main.c
代码如下：

#include "stm32f10x.h"
#include "bsp_usart.h"


void delay(uint32_t count)
{
	while(count--);
}
int main(void)
{	
  USART_Config();
  while(1)
	{	
		printf("hello windows!\n");
		delay(5000000);
	}	
}

编译调试
开始准备烧录，点击options for target，选择仿真器

点击setting，设置串口
点击download，烧录

打开调试助手
发送stop stm32
停止发送hello windows
实验成功

三、C语言程序里全局变量、局部变量、堆，栈

1、简介

全局变量、静态局部变量保存在全局数据区，初始化的和未初始化的分别保存在一起。普通局部变量保存在堆栈中。
在C\C++中，通常可以把内存理解为4个分区：栈、堆、全局/静态存储区和常量存储区

栈区（stack）：指那些由编译器在需要的时候分配，不需要时自动清除的变量所在的储存区，如函数执行时，函数的形参以及函数内的局部变量分配在栈区，函数运行结束后，形参和局部变量去栈（自动释放）。栈内存分配运算内置与处理器的指令集中，效率高但是分配的内存空间有限。

堆区（heap）：指哪些由程序员手动分配释放的储存区，如果程序员不释放这块内存，内存将一直被占用，直到程序运行结束由系统自动收回，c语言中使用malloc，free申请和释放空间。

静态储存区（static）：全局变量和静态变量的储存是放在一块的，其中初始化的全局变量和静态变量在一个区域，这块空间当程序运行结束后由系统释放。

常量储存区（const）：常量字符串就是储存在这里的，如“ABC”字符串就储存在常量区，储存在常量区的只读不可写。const修饰的全局变量也储存在常量区，const修饰的局部变量依然在栈上。

程序代码区：存放源程序的二进制代码。

2.ubuntu中进行编程验证

创建test.c文件

代码：

```c
#include <stdio.h>
#include <stdlib.h>

int k1 = 1;        //已初始化全局int型变量k1
int k2;            //未初始化全局int型变量k2
static int k3 = 2; //已初始化静态全局int型变量k3
static int k4;     //未初始化静态全局int型变量k4

int test()
{
	int j1;
    int j2;
    printf("未初始化局部int型变量j1       ：%p\n", &j1);
    printf("未初始化局部int型变量j2       ：%p\n", &j2);
return 0;
}
int main()
{
    static int m1 = 2;      //已初始化静态局部int型变量m1
    static int m2;          //未初始化静态局部int型变量m2
    int i1;              //未初始化局部int型变量i1
    int i2;				//未初始化局部int型变量i2
    char *p;                //未初始化局部char型指针变量p
    char str[10] = "hello"; //已初始化局部char型数组str
    char *var1 = "123456";  //已初始化局部char型指针变量var1
    char *var2 = "abcdef";  //已初始化局部char型指针变量var2
    int *p1 = malloc(4);    //已初始化局部int型指针变量p1
    int *p2 = malloc(4);    //已初始化局部int型指针变量p2


    printf("栈区-变量地址\n");
    printf("未初始化局部int型变量i        ：%p\n", &i1);
    printf("未初始化局部int型变量i2       ：%p\n", &i2);
    printf("未初始化局部char型指针变量p   ：%p\n", &p);
    printf("已初始化局部char型数组str     ：%p\n", str);
    test();

    printf("\n堆区-动态申请地址\n");
    printf("已初始化局部int型指针变量p1   ：%p\n", p1);
    printf("已初始化局部int型指针变量p2   ：%p\n", p2);

    printf("\n.bss段地址\n");
    printf("未初始化全局int型变量 k2      ：%p\n", &k2);
    printf("未初始化静态全局int型变量k4   ：%p\n", &k4);
    printf("未初始化静态局部int型变量m2   ：%p\n", &m2);

    printf("\n.data段地址\n");
    printf("已初始化全局int型变量k1       ：%p\n", &k1);
    printf("已初始化静态全局int型变量k3   ：%p\n", &k3);
    printf("已初始化静态局部int型变量m1   ：%p\n", &m1);

    printf("\n常量区地址\n");
    printf("已初始化局部char型指针变量var1：%p\n", var1);
    printf("已初始化局部char型指针变量var2：%p\n", var2);

    printf("\n代码区地址\n");
    printf("程序代码区main函数入口地址    ：%p\n", &main);

    free(p1);
    free(p2);
    
    return 0;
}

执行

3.在keil中对stm32进行编程验证

打开官方资料中的BH_F103工程，对main.c进行修改

#include "stm32f10x.h"
#include "bsp_usart.h"

char global1[16];
char global2[16];
char global3[16];
	
int main(void)
{	
  char part1[16];
  char part2[16];
  char part3[16];

  USART_Config();

  printf("part1: 0x%p\n", part1);
  printf("part2: 0x%p\n", part2);
  printf("part3: 0x%p\n", part3);
	 
  printf("global1: 0x%p\n", global1);
  printf("global2: 0x%p\n", global2);
  printf("global3: 0x%p\n", global3);
  while(1)
	{	
		
	}	
}

编译，烧录

可以看出这里前3个part为局部变量，位于栈中，地址逐个减小。后3个global为全局变量，位于静态区，地址逐个增加。

对main.c再次修改

#include "stm32f10x.h"
#include "bsp_usart.h"
#include <stdlib.h>

int main(void)
{	
  static char st1[16];
  static char st2[16];
  static char st3[16];
  char *p1;
  char *p2;
  char *p3;

 
  USART_Config();

  printf("st1: 0x%p\n", st1);
  printf("st2: 0x%p\n", st2);
  printf("st3: 0x%p\n", st3);
	 
  p1 = (char *)malloc(sizeof(char) * 16);
  p2 = (char *)malloc(sizeof(char) * 16);
  p3 = (char *)malloc(sizeof(char) * 16);
	
  printf("p1: 0x%p\n", p1);
  printf("p2: 0x%p\n", p2);
  printf("p3: 0x%p\n", p3);
  while(1)
	{	
		
	}	
}

编译，烧录
可以看出这里前3个静态变量位于静态区，地址依次增加。后3个指针位于堆，地址依次增加。
实验成功。