STM32串口通信的基本实验步骤有哪些呢

一、比较基于寄存器与基于固件库编程方式差异

1.寄存器

寄存器是中央处理器内的组成部分。寄存器是有限存贮容量的高速存贮部件，它们可用来暂存指令、数据和地址。
2.固件库

固件库就是一个固件函数包，它由程序、数据结构和宏组成，包括了微控制器所有外设的性能特征。固件库函数的作用就是：向下负责与寄存器直接打交道，向上提供用户函数调用的接口（API）。固件库将寄存器底层操作都封装起来，提供一套API供开发者使用。大多数情况下，不需要知道操作的是哪个寄存器，只需要知道调用哪些函数即可。
二、STM32串口通信

1.实验工具

野火stm32mini，ST-LINK V2 STM8，keil5，野火串口调试助手
2.实验步骤

打开工程文件





设置keil5










修改代码
main.c

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


// 接收缓冲，最大100个字节
uint8_t USART_RX_BUF[100];
// 接收状态标记位
uint16_t USART_RX_FLAG=0;


//串口中断服务函数
void DEBUG_USART_IRQHandler(void)
{
        uint8_t temp;
        //接收中断
        if(USART_GetFlagStatus(DEBUG_USARTx, USART_IT_RXNE) != RESET)
        {
                // 读取接收的数据
                temp = USART_ReceiveData(DEBUG_USARTx);
                //接收未完成
                if((USART_RX_FLAG & 0x8000)==0)
                {
                        //接收到了0x0d
                        if(USART_RX_FLAG & 0x4000)
                        {
                                // 接收错误,重新开始
                                if(temp != 0x0a) USART_RX_FLAG=0;
                                // 接收完成
                                else USART_RX_FLAG |= 0x8000;
                        }
                        // 还未接收到0x0d
                        else
                        {
                                if(temp == 0x0d)
                                {
                                        USART_RX_FLAG |= 0x4000;
                                }
                                else
                                {
                                        USART_RX_BUF[USART_RX_FLAG & 0x3FFF]=temp;
                                        USART_RX_FLAG++;
                                        //接收数据错误，重新开始接收
                                        if(USART_RX_FLAG > 99) USART_RX_FLAG=0;
                                }
                        }
                }
        }
}
int main(void)
{
        uint8_t len=0;
        uint8_t i=0;
        // USART初始化
        USART_Config();
        while(1)
        {
                if(USART_RX_FLAG & 0x8000)
                {
                        // 获取接收到的数据长度
                        len = USART_RX_FLAG & 0x3FFF;
                        Usart_Sendstr(DEBUG_USARTx, "你发送的消息：n");
                        for(i=0; i                         {
                                // 向串口发送数据
                                USART_SendData(DEBUG_USARTx, USART_RX_BUF);
                                //等待发送结束
                                while(USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TC)!=SET);
                        }
                        Usart_Sendstr(DEBUG_USARTx, "nn");
                        if(strcmp((char *)USART_RX_BUF,"Stop,stm32")==0)
                        {
                                Usart_Sendstr(DEBUG_USARTx, "stm32停止！");
                                break;
                        }
                        USART_RX_FLAG=0;
                        memset(USART_RX_BUF,0,sizeof(USART_RX_BUF));
                }
                else
                {
                        Usart_Sendstr(DEBUG_USARTx, "hello windows!n");
                        delay_ms(800);
                }
        }
}
bsp_usart.h


#ifndef __BSP_USART_H
#define __BSP_USART_H


#include "stm32f10x.h"
#include "string.h"


//串口1-USART1
#define  DEBUG_USARTx                   USART1
#define  DEBUG_USART_CLK                RCC_APB2Periph_USART1
#define  DEBUG_USART_APBxClkCmd         RCC_APB2PeriphClockCmd
#define  DEBUG_USART_BAUDRATE           115200


//USART GPIO 引脚宏定义
#define  DEBUG_USART_GPIO_CLK           (RCC_APB2Periph_GPIOA)
#define  DEBUG_USART_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd
   
#define  DEBUG_USART_TX_GPIO_PORT       GPIOA   
#define  DEBUG_USART_TX_GPIO_PIN        GPIO_Pin_9
#define  DEBUG_USART_RX_GPIO_PORT       GPIOA
#define  DEBUG_USART_RX_GPIO_PIN        GPIO_Pin_10


#define  DEBUG_USART_IRQ                USART1_IRQn
#define  DEBUG_USART_IRQHandler         USART1_IRQHandler


//初始化串口
void USART_Config(void);
//发送一个字节
void Usart_SendByte(USART_TypeDef* pUSARTx,uint8_t data);
//发送字符串
void Usart_Sendstr(USART_TypeDef* pUSARTx,char *str);
//
void delay_ms(uint16_t delay_ms);


#endif /*__BSP_USART_H */
bsp_usart.c


#include "bsp_usart.h"


static void NVIC_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;
  
  // 嵌套向量中断控制器组选择
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  
  // 配置USART为中断源
  NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART_IRQ;
  // 抢断优先级
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  // 子优先级
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  // 使能中断
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  // 初始化配置NVIC
  NVIC_Init(&NVIC_InitStructure);
}


void USART_Config(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        USART_InitTypeDef USART_InitStructure;


        // 打开串口GPIO的时钟
        DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
       
        // 打开串口外设的时钟
        DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);


        // 将USART Tx的GPIO配置为推挽复用模式
        GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);


    // 将USART Rx的GPIO配置为浮空输入模式
        GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
        GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
       
        // 配置串口的工作参数
        // 配置波特率
        USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
        // 配置 针数据字长
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
        // 配置停止位
        USART_InitStructure.USART_StopBits = USART_StopBits_1;
        // 配置校验位
        USART_InitStructure.USART_Parity = USART_Parity_No ;
        // 配置硬件流控制
        USART_InitStructure.USART_HardwareFlowControl =
        USART_HardwareFlowControl_None;
        // 配置工作模式，收发一起
        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
        // 完成串口的初始化配置
        USART_Init(DEBUG_USARTx, &USART_InitStructure);
       
        // 串口中断优先级配置
        NVIC_Configuration();
       
        // 使能串口接收中断
        USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);       
       
        // 使能串口
        USART_Cmd(DEBUG_USARTx, ENABLE);
}




/*发送一个字节*/
void Usart_SendByte(USART_TypeDef * pUSARTx, uint8_t ch)
{
        // 发送一个字节数据到USART
        USART_SendData(pUSARTx, ch);
        // 等待发送数据寄存器为空
        while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}


void Usart_Sendstr(USART_TypeDef * pUSARTx, char *str)
{
        do
        {
                Usart_SendByte(pUSARTx, *str++);
        }while(*str != '');
        // 等待发送完成
        while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC) == RESET);
}




/*微秒级的延时*/
void delay_us(uint32_t delay_us)
{   
  volatile unsigned int num;
  volatile unsigned int t;

  
  for (num = 0; num < delay_us; num++)
  {
    t = 11;
    while (t != 0)
    {
      t--;
    }
  }
}




/*毫秒级的延时*/
void delay_ms(uint16_t delay_ms)
{   
  volatile unsigned int num;
  for (num = 0; num < delay_ms; num++)
  {
    delay_us(1000);
  }
}
————————————————
版权声明：本文为CSDN博主「yqpgalvzm」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yqpgalvzm/article/details/110727279
}

安装jt-link










编译程序





烧录程序





安装串口转换工具





实验结果





三、C 语言内存分区详解

1.C语言在内存中的分区

• 堆区：可以由编程人员手动分配和释放，分配方式类似于链表。由malloc分配，free释放。如果编程人员忘记释放，程序结束系统自动释放
  
• 栈区：由编译器自动分配和释放，例如，局部变量、函数形参等；
  
• 全局（静态）存储区：存放全局变量和静态变量。包括DATA段和BSS段
  DATA段：全局初始化区，存放初始化的变量；
  BSS段：全局未初始化区，存放未初始化的变量；在程序执行之前，未初始化变量已经是0了。
  
• 文字常量区：存放常量字符串，程序结束后自动释放；
  
• 程序代码区：存放函数体的二进制代码
  
  

为了更加直观的了解各个区域的内容，看以下的代码

//main.cpp
#include
using namespace std;
#include


int a = 0;  //全局初始化区
char *p1;  //全局未初始化区


int main(void)
{
    int b;  //栈
        char s[] = "abc";  //"abc"在常量区，s在栈上。
        char *p2;  //栈
        char *p3 = (char*)"123456";  //123456";在常量区，p3在栈上。
        static int c = 0;  //全局（静态）初始化区


        p1 = (char *)malloc(10);
        p2 = (char *)malloc(20); //分配得来的 10 和 20 字节的区域就在堆区。

        strcpy(p1, "123456");  //123456放在常量区，编译器可能会将它与 p3 所指向的"123456"优化成一个地方。


        delete p1, p2;
        return 0;
}
2.C语言动态与静态分配内存空间

动态内存分配是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法
静态内存分配是指分配固定大小的内存分配方法
3.进程在内存中的映射

• 栈区：主要用来存放局部变量, 传递参数, 存放函数的返回地址。.esp 始终指向栈顶, 栈中的数据越多, esp的值越小。
  
• 堆区：用于存放动态分配的对象, 当你使用 malloc和new 等进行分配时,所得到的空间就在堆中。动态分配得到的内存区域附带有分配信息, 所以你能够 free和delete它们。
  
• 数据区：全局，静态和常量是分配在数据区中的，数据区包括bss（未初始化数据区）和初始化数据区。
  
  

注意：

• 堆向高内存地址生长；
  
• 栈向低内存地址生长；
  
• 堆和栈相向而生，堆和栈之间有个临界点，称为stkbrk
  
  

假设现在有一个程序，它的函数调用顺序如下：
main(…) ->; func_1(…) ->; func_2(…) ->; func_3(…)，即：主函数main调用函数func_1; 函数func_1调用函数func_2; 函数func_2调用函数func_3。
当一个程序***作系统调入内存运行, 其对应的进程在内存中的映射如下图所示





四、探究 STM32 内存分区方式

代码编写，在串口通讯的代码上进行修改
在bsp_usart.h 文件添加头文件
#include
#include




修改bsp_usart.c 文件

int fputc(int ch, FILE *f)
{
        USART_SendData(DEBUG_USARTx, (uint8_t)ch);
       
        while(USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
       
        return (ch);
}



修改main.c 文件

#include "stm32f10x.h"
#include "bsp_usart.h"  //添加 bsp_usart.h 头文件


int init_global_a = 1;
int uninit_global_a;
static int inits_global_b = 2;
static int uninits_global_b;


void output(int a)
{
        printf("hello");
        printf("%d",a);
        printf("n");
}


int main(void)
{       
        //定义局部变量
        int a=2;
        static int inits_local_c=2, uninits_local_c;
        int init_local_d = 1;
        char *p;
        char str[10] = "lyy";
        //定义常量字符串
        char *var1 = "1234567890";
        char *var2 = "qwertyuiop";
        //动态分配
        int *p1=malloc(4);
        int *p2=malloc(4);
        USART_Config();//串口初始化
        output(a);
        //释放
        free(p1);
        free(p2);
        printf("栈区-变量地址n");
        printf("                a：%pn", &a);
        printf("                init_local_d：%pn", &init_local_d);
        printf("                p：%pn", &p);
        printf("              str：%pn", str);
        printf("n堆区-动态申请地址n");
        printf("                   %pn", p1);
        printf("                   %pn", p2);
        printf("n全局区-全局变量和静态变量n");
        printf("n.bss段n");
        printf("全局外部无初值 uninit_global_a：%pn", &uninit_global_a);
        printf("静态外部无初值 uninits_global_b：%pn", &uninits_global_b);
        printf("静态内部无初值 uninits_local_c：%pn", &uninits_local_c);
        printf("n.data段n");
        printf("全局外部有初值 init_global_a：%pn", &init_global_a);
        printf("静态外部有初值 inits_global_b：%pn", &inits_global_b);
        printf("静态内部有初值 inits_local_c：%pn", &inits_local_c);
        printf("n文字常量区n");
        printf("文字常量地址     ：%pn",var1);
        printf("文字常量地址     ：%pn",var2);
        printf("n代码区n");
        printf("程序区地址       ：%pn",&main);
        printf("函数地址         ：%pn",&output);
        return 0;
}




编译并烧录程序





结果展示