stm32学习第十一天

最新推荐文章于 2023-11-19 16:01:18 发布
最新推荐文章于 2023-11-19 16:01:18 发布
阅读量517 收藏 3
点赞数
分类专栏： STM32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51178981/article/details/119811635
版权
本文详细记录了STM32串口通讯的编程步骤，包括配置GPIO、初始化串口、发送数据（单字节、双字节、数组、字符串）以及使用printf函数。还介绍了如何实现串口与PC之间的通讯，并通过中断服务函数处理串口接收的数据，以及通过串口控制LED灯的亮灭。
摘要由CSDN通过智能技术生成

文章目录


记录串口通讯编程的笔记。
首先，我不去追求串口通讯的原理，硬件没基础，比较绕，所以直接用现成的。

一、编程思路

  1. 打开时钟。
  2. 初始化 GPIO；
  3. 初始化串口，和控制USART的结构体；
  4. 中断配置；
  5. 使能串口；
  6. 编写发送和接受数据
  7. 编写中断服务函数；

在这之前一定要安装usb转串口驱动，然后板子上要有USB转串口，没有的话就就需要自己弄一个。
附上连接。

链接：https://pan.baidu.com/s/1HMcqSRr9FUT4HeM8wmzGJA 
提取码：ny28

二、pc发送数据到串口

我们通过通过按键来实现串口和板子之间的交流。
这里用GPIOA上的KEY1按键。（霸道板子上的）

霸道的板子上KEY1控制的是GPIOA，所以这里的串口就用GPIOA来进行控制。
GPIOA挂载到APB2上的。
大概流程就是下面这样。

2.1 串口通讯发送一个字节

配置bsp_lusart.c
这里我没有使用宏定义，先试一试行不行。

#include "bsp_usart.h"

void USART_CONFIG()
{
	/*定义结构体*/
	USART_InitTypeDef USART_CONFIG;
	GPIO_InitTypeDef 	GPIO_CONFIG;
	//打开GPIO时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	//打开外设串口时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	// 将USART Tx 的 GPIO 配置为推挽复用模式
	GPIO_CONFIG.GPIO_Mode 	= GPIO_Mode_AF_PP;
	GPIO_CONFIG.GPIO_Pin  	= GPIO_Pin_9;
	GPIO_CONFIG.GPIO_Speed 	= GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_CONFIG);
	// 将USART Rx的GPIO配置为浮空输入模式
	GPIO_CONFIG.GPIO_Mode 	= GPIO_Mode_IN_FLOATING;
	GPIO_CONFIG.GPIO_Pin  	= GPIO_Pin_10;
	GPIO_Init(GPIOA, &GPIO_CONFIG);
	
	/*.......配置串口的工作参数......*/
	// 配置波特率
	USART_CONFIG.USART_BaudRate = 115200;
	// 配置 针数据字长
	USART_CONFIG.USART_WordLength = USART_WordLength_8b;;
	// 配置停止位
	USART_CONFIG.USART_StopBits = USART_StopBits_1;
	// 配置校验位
	USART_CONFIG.USART_Parity = USART_Parity_No;
	// 配置硬件流控制
	USART_CONFIG.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	// 配置工作模式，收发一起
	USART_CONFIG.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	// 完成串口的初始化配置
	USART_Init(USART1,&USART_CONFIG);
	// 使能串口
	USART_Cmd(USART1, ENABLE);
}
void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t data)
{
	/* 发送一个字节数据到USART */
	USART_SendData(pUSARTx,data);
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}

配置bsp_lusart.h

#ifndef _BSP_USART_H
#define	_BSP_USART_H

#include "stm32f10x.h"

void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t data);
void USART_CONFIG(void);

#endif /*_BSP_USART_H*/

main.c


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

int main(void)
{	
	//初始化串口
	USART_CONFIG();
	//设定串口 和发送的数据
	Usart_SendByte(USART1,0x64);
	while (1)
	{	
	}
}

在这里插入图片描述

Usart_SendByte（）；这个函数只能用于发送一个字节大小的数据。

2.2 串口通讯发送两个字节

两个字节也就是16位，如果我们使用刚才Usart_SendByte（）；这个函数，我们就需要把这个16位的数据取出来，分成两个8位的，分别进行发送。
首先取出高八位，那就是吧低8位的数据清零，就是和0进行或运算。
再取出高八位，就是把高八位的清零。
分别发送低八位和高八位就行了。

void Usart_SendHalfWrold( USART_TypeDef * pUSARTx, uint16_t data)
{
	uint8_t temp_h,temp_l;
	//取高八位
	temp_h = (data&0xff00) >> 8;
	//低八位
	temp_l = (data&0xff);
	/* 发送高八位 */
	USART_SendData(pUSARTx,temp_h);
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
	/* 发送低八位 */
	USART_SendData(pUSARTx,temp_l );
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);		
}

usart的头文件记得添加函数。再在主函数里面运行。这里记得把void Usart_SendHalfWrold( USART_TypeDef * pUSARTx, uint16_t data)这个形参改为16位的，不然会报错。

int main(void)
{	

	USART_CONFIG();
	//设定串口 和发送的数据
	//Usart_SendByte(USART1,0x64);
	Usart_SendHalfWrold( USART1,0xff56);
	while (1)
	{	
	}
}

下载，按复位键就可以看到我们串口出现数据了。
在这里插入图片描述

2.3 串口通讯发送数组

同样的道理


void Usart_SendArray( USART_TypeDef * pUSARTx, uint8_t *array,uint8_t num)
{
	uint8_t i;
	for(i = 0;i < num; i++)
	{
		Usart_SendByte(pUSARTx,array[i]);
	}
	//这里发送的多个字符，USART_FLAG_TC（TXE改为TC）
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);
}

记得这里要改标识符，之前说过。
main.c


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

int main(void)
{	
	//定义你要发送的数组
	uint8_t array[10] = {1,2,3,4,5,6,7,8,9,10};
	USART_CONFIG();
	//设定串口 和发送的数据
	//Usart_SendByte(USART1,0x64);
	//Usart_SendHalfWrold( USART1,0xff56);
	
	Usart_SendArray( USART1, array ,10);
	while (1)
	{	
	}
}

在这里插入图片描述

2.4 串口通讯发送字符串

在这里插入图片描述我不知道为啥这样要报错。

void Usart_SendStr(USART_TypeDef * pUSARTx,char *Str)
{
//后面补充，这样会产生乱码。
	do 
  {
		//Str++字符串往后移动
    Usart_SendByte( pUSARTx, *(Str++));
  } while( *(Str++)!= '\0');
  
  /* 等待发送完成 */
  while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
  {}
}


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

int main(void)
{	
	//定义你要发送的数组
	//uint8_t array[10] = {1,2,3,4,5,6,7,8,9,10};
	USART_CONFIG();
	//设定串口 和发送的数据
	//Usart_SendByte(USART1,0x64);
	//Usart_SendHalfWrold( USART1,0xff56);
	//Usart_SendArray( USART1, array ,10);
	Usart_SendStr(USART1,"欢迎阅读我的STM32学习记录\n");
	while (1)
	{	
	}
}

在这里插入图片描述
。。。显示乱码。不慌，去找找问题。
半个小时过后。。
我修改了时钟配置，然后也修改了晶振倍频，都是乱码。
最后参考了火哥的配置。发现是代码问题。

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

只能这样写，他也不报错了。显示也没问题了。
在这里插入图片描述佛了。

2.5 用printf函数显示

这里和普通的编译器不一样，这里面调用printf函数需要一个定向函数，用来在C库里面寻找printf这个函数。

///重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
		/* 发送一个字节数据到串口 */
		USART_SendData(USART1, (uint8_t) ch);
		
		/* 等待发送完毕 */
		while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);		
	
		return (ch);
}

因为要用C语言的库，所以记得添加头文件 <stdio.h>.
代码：
bsp_usart.c添加 头文件添加C库<stdio.h>。

///重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
		/* 发送一个字节数据到串口 */
		USART_SendData(USART1, (uint8_t) ch);
		
		/* 等待发送完毕 */
		while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);		
	
		return (ch);
}

main.c


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

int main(void)
{	
	//定义你要发送的数组
	//uint8_t array[10] = {1,2,3,4,5,6,7,8,9,10};
	USART_CONFIG();
	//设定串口 和发送的数据
	//Usart_SendByte(USART1,0x64);
	//Usart_SendHalfWrold( USART1,0xff56);
	//Usart_SendArray( USART1, array ,10);
	Usart_SendStr(USART1,"欢迎阅读我的STM32学习记录\n");
	printf("来自小黑黑！\n");
	while (1)
	{	
	}
}

在这里插入图片描述ok了！
为了后期的方便，我这里已经移植了野火的代码的宏定义。
bsp_usart.h

#ifndef _BSP_USART_H
#define	_BSP_USART_H

#include "stm32f10x.h"
#include <stdio.h>


/** 
  * 串口宏定义，不同的串口挂载的总线不一样，移植时需要修改这几个宏
  */
#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_SendByte( USART_TypeDef * pUSARTx, uint8_t data);
void USART_CONFIG(void);

void Usart_SendHalfWrold( USART_TypeDef * pUSARTx, uint16_t data);
void Usart_SendArray( USART_TypeDef * pUSARTx, uint8_t *array,uint8_t num);
void Usart_SendStr(USART_TypeDef * pUSARTx,char *Str);
#endif /*_BSP_USART_H*/

bsp_usart.c

#include "bsp_usart.h"

void USART_CONFIG()
{
	/*定义结构体*/
	USART_InitTypeDef USART_CONFIG;
	GPIO_InitTypeDef 	GPIO_CONFIG;
	//打开GPIO时钟
	RCC_APB2PeriphClockCmd(DEBUG_USART_GPIO_CLK, ENABLE);
	//打开外设串口时钟
	RCC_APB2PeriphClockCmd(DEBUG_USART_CLK, ENABLE);
	// 将USART Tx 的 GPIO 配置为推挽复用模式
	GPIO_CONFIG.GPIO_Mode 	= GPIO_Mode_AF_PP;
	GPIO_CONFIG.GPIO_Pin  	= DEBUG_USART_TX_GPIO_PIN;
	GPIO_CONFIG.GPIO_Speed 	= GPIO_Speed_50MHz;
	GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_CONFIG);
	// 将USART Rx的GPIO配置为浮空输入模式
	GPIO_CONFIG.GPIO_Mode 	= GPIO_Mode_IN_FLOATING;
	GPIO_CONFIG.GPIO_Pin  	= DEBUG_USART_RX_GPIO_PIN;
	GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_CONFIG);
	
	/*.......配置串口的工作参数......*/
	// 配置波特率
	USART_CONFIG.USART_BaudRate = DEBUG_USART_BAUDRATE;
	// 配置 针数据字长
	USART_CONFIG.USART_WordLength = USART_WordLength_8b;;
	// 配置停止位
	USART_CONFIG.USART_StopBits = USART_StopBits_1;
	// 配置校验位
	USART_CONFIG.USART_Parity = USART_Parity_No;
	// 配置硬件流控制
	USART_CONFIG.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	// 配置工作模式，收发一起
	USART_CONFIG.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	// 完成串口的初始化配置
	USART_Init(DEBUG_USARTx,&USART_CONFIG);
	// 使能串口接收中断
	USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);
	// 使能串口
	USART_Cmd(DEBUG_USARTx, ENABLE);
}
//半字
void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t data)
{
	/* 发送一个字节数据到USART */
	USART_SendData(pUSARTx,data);
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}
void Usart_SendHalfWrold( USART_TypeDef * pUSARTx, uint16_t data)
{
	uint8_t temp_h,temp_l;
	//取高八位
	temp_h = (data&0xff00) >> 8;
	//低八位
	temp_l = (data&0xff);
	/* 发送高八位 */
	USART_SendData(pUSARTx,temp_h);
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
	/* 发送低八位 */
	USART_SendData(pUSARTx,temp_l );
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);		
}
//数组
void Usart_SendArray( USART_TypeDef * pUSARTx, uint8_t *array,uint8_t num)
{
	uint8_t i;
	for(i = 0;i < num; i++)
	{
		Usart_SendByte(pUSARTx,array[i]);
	}
	//这里发送的多个字符，USART_FLAG_TC（TXE改为TC）
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);
}
/*
void Usart_SendStr(USART_TypeDef * pUSARTx,char *Str)
{

	do 
  {
		//Str++字符串往后移动
		unsigned int i = 0;
    Usart_SendByte( pUSARTx, *(Str+i));
		i++;
  } while(*(Str + i)!= '\0');
//乱码问题。。
	do 
  {
		//Str++字符串往后移动
    Usart_SendByte( pUSARTx, *(Str++));
  } while( *(Str++)!= '\0');
  
	等待发送完成
  while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
  {}
}
*/
void Usart_SendStr( USART_TypeDef * pUSARTx, char *str)
{
	unsigned int k=0;
  do 
  {
      Usart_SendByte( pUSARTx, *(str + k) );
      k++;
  } while(*(str + k)!='\0');
  
  /* 等待发送完成 */
  while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
  {}
}
///重定向c库函数printf到串口，重定向后可使用printf函数
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_led.h"
#include "bsp_usart.h"


int main(void)
{	
	//定义你要发送的数组
	//uint8_t array[10] = {1,2,3,4,5,6,7,8,9,10};
	USART_CONFIG();
	//设定串口 和发送的数据
	//Usart_SendByte(DEBUG_USARTx,0x64);
	//Usart_SendHalfWrold( DEBUG_USARTx,0xff56);
	//Usart_SendArray( DEBUG_USARTx, array ,10);
	Usart_SendStr(DEBUG_USARTx,"欢迎阅读我的STM32学习记录\n");
	printf("来自小黑黑！\n");
	while (1)
	{	
	}
}

三、串口与PC端之间的通讯

这里需要中断，如果串口调试助手有信息传输，USART接收到这个信息，就会判断这个中断事件是真是假，如果是真的，就会把这个数据发送给原设备，即串口助手，我们就能看到了。
我们就在刚才的代码上增加一个中断函数就行了。
配置中断服务函数
stm32f10x_it.c

// 串口中断服务函数
void DEBUG_USART_IRQHandler(void)
{
  uint8_t ucTemp;
	if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE)!=RESET)
	{		
		ucTemp = USART_ReceiveData(DEBUG_USARTx);
    USART_SendData(DEBUG_USARTx,ucTemp);    
	}	 
}

因为有宏定义，记得添加头文件。
bsp_usart.h

#ifndef _BSP_USART_H
#define	_BSP_USART_H

#include "stm32f10x.h"
#include <stdio.h>


/** 
  * 串口宏定义，不同的串口挂载的总线不一样，移植时需要修改这几个宏
  */
#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_SendByte( USART_TypeDef * pUSARTx, uint8_t data);
void USART_CONFIG(void);

void Usart_SendHalfWrold( USART_TypeDef * pUSARTx, uint16_t data);
void Usart_SendArray( USART_TypeDef * pUSARTx, uint8_t *array,uint8_t num);
void Usart_SendStr(USART_TypeDef * pUSARTx,char *Str);
#endif /*_BSP_USART_H*/

bsp_usart.c

#include "bsp_usart.h"

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

void USART_CONFIG()
{
	/*定义结构体*/
	USART_InitTypeDef USART_CONFIG;
	GPIO_InitTypeDef 	GPIO_CONFIG;
	//打开GPIO时钟
	RCC_APB2PeriphClockCmd(DEBUG_USART_GPIO_CLK, ENABLE);
	//打开外设串口时钟
	RCC_APB2PeriphClockCmd(DEBUG_USART_CLK, ENABLE);
	// 将USART Tx 的 GPIO 配置为推挽复用模式
	GPIO_CONFIG.GPIO_Mode 	= GPIO_Mode_AF_PP;
	GPIO_CONFIG.GPIO_Pin  	= DEBUG_USART_TX_GPIO_PIN;
	GPIO_CONFIG.GPIO_Speed 	= GPIO_Speed_50MHz;
	GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_CONFIG);
	// 将USART Rx的GPIO配置为浮空输入模式
	GPIO_CONFIG.GPIO_Mode 	= GPIO_Mode_IN_FLOATING;
	GPIO_CONFIG.GPIO_Pin  	= DEBUG_USART_RX_GPIO_PIN;
	GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_CONFIG);
	
	/*.......配置串口的工作参数......*/
	// 配置波特率
	USART_CONFIG.USART_BaudRate = DEBUG_USART_BAUDRATE;
	// 配置 针数据字长
	USART_CONFIG.USART_WordLength = USART_WordLength_8b;;
	// 配置停止位
	USART_CONFIG.USART_StopBits = USART_StopBits_1;
	// 配置校验位
	USART_CONFIG.USART_Parity = USART_Parity_No;
	// 配置硬件流控制
	USART_CONFIG.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	// 配置工作模式，收发一起
	USART_CONFIG.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	// 完成串口的初始化配置
	USART_Init(DEBUG_USARTx,&USART_CONFIG);
	// 串口中断优先级配置
	NVIC_Configuration();
	// 使能串口接收中断
	USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);
	// 使能串口
	USART_Cmd(DEBUG_USARTx, ENABLE);
}
//半字
void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t data)
{
	/* 发送一个字节数据到USART */
	USART_SendData(pUSARTx,data);
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}
void Usart_SendHalfWrold( USART_TypeDef * pUSARTx, uint16_t data)
{
	uint8_t temp_h,temp_l;
	//取高八位
	temp_h = (data&0xff00) >> 8;
	//低八位
	temp_l = (data&0xff);
	/* 发送高八位 */
	USART_SendData(pUSARTx,temp_h);
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
	/* 发送低八位 */
	USART_SendData(pUSARTx,temp_l );
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);		
}
//数组
void Usart_SendArray( USART_TypeDef * pUSARTx, uint8_t *array,uint8_t num)
{
	uint8_t i;
	for(i = 0;i < num; i++)
	{
		Usart_SendByte(pUSARTx,array[i]);
	}
	//这里发送的多个字符，USART_FLAG_TC（TXE改为TC）
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);
}
/*
void Usart_SendStr(USART_TypeDef * pUSARTx,char *Str)
{

	do 
  {
		//Str++字符串往后移动
		unsigned int i = 0;
    Usart_SendByte( pUSARTx, *(Str+i));
		i++;
  } while(*(Str + i)!= '\0');
//乱码问题。。
	do 
  {
		//Str++字符串往后移动
    Usart_SendByte( pUSARTx, *(Str++));
  } while( *(Str++)!= '\0');
  
	等待发送完成
  while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
  {}
}
*/
void Usart_SendStr( USART_TypeDef * pUSARTx, char *str)
{
	unsigned int k=0;
  do 
  {
      Usart_SendByte( pUSARTx, *(str + k) );
      k++;
  } while(*(str + k)!='\0');
  
  /* 等待发送完成 */
  while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
  {}
}
///重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
		/* 发送一个字节数据到串口 */
		USART_SendData(DEBUG_USARTx, (uint8_t) ch);
		
		/* 等待发送完毕 */
		while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);		
	
		return (ch);
}

///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{
		/* 等待串口输入数据 */
		while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);

		return (int)USART_ReceiveData(DEBUG_USARTx);
}

main.c


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


int main(void)
{	
	//定义你要发送的数组
	//uint8_t array[10] = {1,2,3,4,5,6,7,8,9,10};
	USART_CONFIG();
	//设定串口 和发送的数据
	//Usart_SendByte(DEBUG_USARTx,0x64);
	//Usart_SendHalfWrold( DEBUG_USARTx,0xff56);
	//Usart_SendArray( DEBUG_USARTx, array ,10);
	Usart_SendStr(DEBUG_USARTx,"这是一个串口中断接收回显实验\n");
	//printf("来自小黑黑！\n");
	while (1)
	{	
	}
}

四、串口控制灯的亮灭

这里主要是调用一个getchar函数来判断串口输人的是多少，由此来打开我们对应颜色的led灯。这样就实现了我们由串口来控制灯的亮灭。
这里需要一个重定向函数int fgetc(FILE *f) 上面的代码已经写了。所以这里就不写了。然后就是我们要关闭调中断函数，因为打开中断函数那么PC就会发送对应的数据，可能会对产口输入产生干扰。
这里我是直接COPY的野火的代码。
bsp_led.h

#ifndef __LED_H
#define	__LED_H


#include "stm32f10x.h"


/* 定义LED连接的GPIO端口, 用户只需要修改下面的代码即可改变控制的LED引脚 */
// R-红色
#define LED1_GPIO_PORT    	GPIOB			              /* GPIO端口 */
#define LED1_GPIO_CLK 	    RCC_APB2Periph_GPIOB		/* GPIO端口时钟 */
#define LED1_GPIO_PIN		GPIO_Pin_5			        /* 连接到SCL时钟线的GPIO */

// G-绿色
#define LED2_GPIO_PORT    	GPIOB			              /* GPIO端口 */
#define LED2_GPIO_CLK 	    RCC_APB2Periph_GPIOB		/* GPIO端口时钟 */
#define LED2_GPIO_PIN				GPIO_Pin_0			        /* 连接到SCL时钟线的GPIO */

// B-蓝色
#define LED3_GPIO_PORT    	GPIOB			              /* GPIO端口 */
#define LED3_GPIO_CLK 	    RCC_APB2Periph_GPIOB		/* GPIO端口时钟 */
#define LED3_GPIO_PIN				GPIO_Pin_1			        /* 连接到SCL时钟线的GPIO */


/** the macro definition to trigger the led on or off 
  * 1 - off
  *0 - on
  */
#define ON  0
#define OFF 1

/* 使用标准的固件库控制IO*/
#define LED1(a)	if (a)	\
					GPIO_SetBits(LED1_GPIO_PORT,LED1_GPIO_PIN);\
					else		\
					GPIO_ResetBits(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2(a)	if (a)	\
					GPIO_SetBits(LED2_GPIO_PORT,LED2_GPIO_PIN);\
					else		\
					GPIO_ResetBits(LED2_GPIO_PORT,LED2_GPIO_PIN)

#define LED3(a)	if (a)	\
					GPIO_SetBits(LED3_GPIO_PORT,LED3_GPIO_PIN);\
					else		\
					GPIO_ResetBits(LED3_GPIO_PORT,LED3_GPIO_PIN)


/* 直接操作寄存器的方法控制IO */
#define	digitalHi(p,i)		 {p->BSRR=i;}	 //输出为高电平		
#define digitalLo(p,i)		 {p->BRR=i;}	 //输出低电平
#define digitalToggle(p,i) {p->ODR ^=i;} //输出反转状态


/* 定义控制IO的宏 */
#define LED1_TOGGLE		 digitalToggle(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_OFF		   digitalHi(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_ON			   digitalLo(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2_TOGGLE		 digitalToggle(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_OFF		   digitalHi(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_ON			   digitalLo(LED2_GPIO_PORT,LED2_GPIO_PIN)

#define LED3_TOGGLE		 digitalToggle(LED3_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_OFF		   digitalHi(LED3_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_ON			   digitalLo(LED3_GPIO_PORT,LED3_GPIO_PIN)

/* 基本混色，后面高级用法使用PWM可混出全彩颜色,且效果更好 */

//红
#define LED_RED  \
					LED1_ON;\
					LED2_OFF\
					LED3_OFF

//绿
#define LED_GREEN		\
					LED1_OFF;\
					LED2_ON\
					LED3_OFF

//蓝
#define LED_BLUE	\
					LED1_OFF;\
					LED2_OFF\
					LED3_ON

					
//黄(红+绿)					
#define LED_YELLOW	\
					LED1_ON;\
					LED2_ON\
					LED3_OFF
//紫(红+蓝)
#define LED_PURPLE	\
					LED1_ON;\
					LED2_OFF\
					LED3_ON

//青(绿+蓝)
#define LED_CYAN \
					LED1_OFF;\
					LED2_ON\
					LED3_ON
					
//白(红+绿+蓝)
#define LED_WHITE	\
					LED1_ON;\
					LED2_ON\
					LED3_ON
					
//黑(全部关闭)
#define LED_RGBOFF	\
					LED1_OFF;\
					LED2_OFF\
					LED3_OFF

void LED_GPIO_Config(void);

#endif /* __LED_H */

bsp_led.c

 
#include "./led/bsp_led.h"   

 /**
  * @brief  初始化控制LED的IO
  * @param  无
  * @retval 无
  */
void LED_GPIO_Config(void)
{		
		/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;

		/*开启LED相关的GPIO外设时钟*/
		RCC_APB2PeriphClockCmd( LED1_GPIO_CLK | LED2_GPIO_CLK | LED3_GPIO_CLK, ENABLE);
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED1_GPIO_PIN;	

		/*设置引脚模式为通用推挽输出*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   

		/*设置引脚速率为50MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 

		/*调用库函数，初始化GPIO*/
		GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);	
		
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED2_GPIO_PIN;

		/*调用库函数，初始化GPIO*/
		GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);
		
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED3_GPIO_PIN;

		/*调用库函数，初始化GPIOF*/
		GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);

		/* 关闭所有led灯	*/
		GPIO_SetBits(LED1_GPIO_PORT, LED1_GPIO_PIN);
		
		/* 关闭所有led灯	*/
		GPIO_SetBits(LED2_GPIO_PORT, LED2_GPIO_PIN);	 
    
    /* 关闭所有led灯	*/
		GPIO_SetBits(LED3_GPIO_PORT, LED3_GPIO_PIN);
}

void assert_failed(uint8_t* file, uint32_t line)
{
	// 断言错误时执行的代码
	LED1_ON;
}
/*********************************************END OF FILE**********************/

bsp_usart.h

#ifndef __USART_H
#define	__USART_H


#include "stm32f10x.h"
#include <stdio.h>

/** 
  * 串口宏定义，不同的串口挂载的总线不一样，移植时需要修改这几个宏
  */
#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 ch);
void Usart_SendString( USART_TypeDef * pUSARTx, char *str);
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch);

#endif /* __USART_H */

bsp_usart.c


	
#include "bsp_usart.h"

 /**
  * @brief  USART GPIO 配置,工作参数配置
  * @param  无
  * @retval 无
  */
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);	
	
	// 使能串口
	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_SendString( USART_TypeDef * pUSARTx, char *str)
{
	unsigned int k=0;
  do 
  {
      Usart_SendByte( pUSARTx, *(str + k) );
      k++;
  } while(*(str + k)!='\0');
  
  /* 等待发送完成 */
  while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
  {}
}

/*****************  发送一个16位数 **********************/
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)
{
	uint8_t temp_h, temp_l;
	
	/* 取出高八位 */
	temp_h = (ch&0XFF00)>>8;
	/* 取出低八位 */
	temp_l = ch&0XFF;
	
	/* 发送高八位 */
	USART_SendData(pUSARTx,temp_h);	
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
	
	/* 发送低八位 */
	USART_SendData(pUSARTx,temp_l);	
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}

///重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
		/* 发送一个字节数据到串口 */
		USART_SendData(DEBUG_USARTx, (uint8_t) ch);
		
		/* 等待发送完毕 */
		while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);		
	
		return (ch);
}

///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{
		/* 等待串口输入数据 */
		while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);

		return (int)USART_ReceiveData(DEBUG_USARTx);
}

main.c


#include "stm32f10x.h"
#include "./led/bsp_led.h" 
#include "./usart/bsp_usart.h" 

static void Show_Message(void);
  
/**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
int main(void)
{	
  char ch;
  
  /* 初始化RGB彩灯 */
  LED_GPIO_Config();
  
  /* 初始化USART 配置模式为 115200 8-N-1 */
  USART_Config();
	
  /* 打印指令输入提示信息 */
  Show_Message();
  while(1)
	{	
    /* 获取字符指令 */
    ch=getchar();
    printf("接收到字符：%c\n",ch);
    
    /* 根据字符指令控制RGB彩灯颜色 */
    switch(ch)
    {
      case '1':
        LED_RED;
      break;
      case '2':
        LED_GREEN;
      break;
      case '3':
        LED_BLUE;
      break;
      case '4':
        LED_YELLOW;
      break;
      case '5':
        LED_PURPLE;
      break;
      case '6':
        LED_CYAN;
      break;
      case '7':
        LED_WHITE;
      break;
      case '8':
        LED_RGBOFF;
      break;
      default:
        /* 如果不是指定指令字符，打印提示信息 */
        Show_Message();
        break;      
    }   
	}	
}


/**
  * @brief  打印指令输入提示信息
  * @param  无
  * @retval 无
  */
static void Show_Message(void)
{
  printf("\r\n   这是一个通过串口通信指令控制RGB彩灯实验 \n");
  printf("使用  USART  参数为：%d 8-N-1 \n",DEBUG_USART_BAUDRATE);
  printf("开发板接到指令后控制RGB彩灯颜色，指令对应如下：\n");
  printf("   指令   ------ 彩灯颜色 \n");
  printf("     1    ------    红 \n");
  printf("     2    ------    绿 \n");
  printf("     3    ------    蓝 \n");
  printf("     4    ------    黄 \n");
  printf("     5    ------    紫 \n");
  printf("     6    ------    青 \n");
  printf("     7    ------    白 \n");
  printf("     8    ------    灭 \n");  
}

/*********************************************END OF FILE**********************/

编译，下载到开发板就好了，没反应就按下复位键。然后你的串口助手就可以看到这段消息。
在这里插入图片描述

永不秃头的程序员
关注
专栏目录
C语言senddata串口发送数据,STM32的串口函数_库函数USART_SendData问题和解决方法
weixin_39918248的博客
05-24 4914
1. 问题及现象运用USART_SendData()函数非接连发送单个字符是没有问题的；当接连发送字符时(两个字符间没有延时)，就会发现发送缓冲区有溢呈现象。若发送的数据量很小时，此刻串口发送的仅仅最终一个字符，当发送数据量大时，就会导致发送的数据不可思议的丢掉。如：12for(TxCounter = 0;TxCounter < RxCounter; TxCounter++)USART_Se...
STM32的串口函数_库函数USART_SendData问题和解决方法--硬件复位导致第一个字节丢失
热门推荐
奋斗的菜鸟博客
07-10 4万+
本文转自：http://blog.sina.com.cn/s/blog_717116870102vb4c.html 个人记录： 昨天做串口实验的时候一直没有成功的原因，连续调用USART_SendData总是会出现前一个被后一个覆盖的情况。 之前觉得ST的官方库应该没有问题就没往这方面想，现在查查，确实有库的问题，还是自己对库不太理解。 还有遇到的硬件复位以后，
STM32-基本知识梳理6-USART通讯及使用
ADAS_sunshine的博客
04-09 1786
2，初始化usart，按照上述配置即可，关键是在usart头文件中，要将中断函数的temp，用extern引用出来，在主函数中接受，并判断。2，初始化usart，按照上述配置即可，关键是在usart头文件中，要将中断函数的temp，用extern引用出来，在主函数中接受，并判断。④波特率发生器：主要根据配置的时钟，选择对应波特率，由此处发送时钟信号，从而按照波特率的具体值，发送对应频率的数据；关键点：在中断服务函数，首先检测标志位（数据位非空，规定动作），然后转数据接受给临时变量TEMP。
串口通信 输入输出
weixin_45800550的博客
11-21 5864
https://blog.csdn.net/qq_35281599/article/details/80299770 串口发送数据： 1. 串口发送数据最直接的方式就是标准调用库函数 。 void USART_SendData(USART_TypeDef* USARTx, uint16_t Data); 第一个参数是发送的串口号，第二个参数是要发送的数据了。但是用过的朋友应该觉得不好用，一...
串口通信时用USART_SendData和printf的区别
kuzuiu001的专栏
05-27 1万+
USART_SendData是一个一个发送，printf本质也是一样,一类STM32自带的读写函数，一类是MICRO库复写后的读写输入输出函数。
STM32单片机学习入门基础教程PPT课件（共49个）.zip
05-30
STM32入门100步（第11步）SPI、CAN、USB接口.pptx STM32入门100步（第12步）CRC校验和芯片ID.pptx STM32入门100步（第13步）内部功能回顾总结.pptx STM32入门100步（第14步）接口定义.pptx STM32入门100步（第17步）...
第十一届蓝桥杯物联网设计与开发实验（合集）STM32学习
01-06
ex11 定时器实验 ex12 USART串口发送实验 ex13 USART串口接收实验 外设资源实验目录 – 基于省赛资源套装 ex1 OLED显示实验 ex2 OLED显示实验（硬件I2C） ex3 2*3矩阵键盘实验 ex4 继电器驱动实验 ex5 串口通讯收发...
STM32F103CT86原理图+STM32F103手册
06-19
STM32F103CT86是一款基于ARM Cortex-M3内核的微控制器，由意法半导体...总之，STM32F103CT86是一款功能强大、应用广泛的微控制器，结合其原理图和手册，开发者可以深入学习并开发出满足各种需求的嵌入式系统。
STM32编程直流有刷电机PID速度闭环精准变速控制 电机控制例程分享 （第十一期）.zip
12-11
总的来说，这个资源对于学习和实践STM32控制直流电机具有很高的价值。通过分析和实践提供的代码，开发者不仅可以掌握PID速度闭环的基本原理，还能了解如何在STM32平台上有效地实现这一控制策略。这将有助于提升在...
STM32第十一届嵌入式代码
04-06
总的来说，STM32第十一届嵌入式代码是一个综合性的学习资源，适合想要提升STM32开发技能的工程师或者对嵌入式系统感兴趣的初学者。通过深入研究这些代码，可以深入了解STM32的工作原理以及如何利用它来构建实际的...
三，USART串口
qq_64005599的博客
02-06 1500
的时候，一个字节的数据就会被写入发送数据寄存器(TDR),注意USART_FLAG_TXE这个标志位，不发送数据的时候，闲着的时候都是0，当检测到数据写入发送数据寄存器TDR的时候，就会立刻将USART_FLAG_TXE置1，然后数据移位寄存器（TSR）就开始从TDR寄存器中取数据，一位一位的取走发送出去，当被取完的时候，发送数据寄存器TDR也就为空了，所以此时USART_FLAG_TXE*标志位就会被置0 ，所以也是我们while检测这个标志的原因。USART_FLAG_TC（发送完成标志位）
STM32串口发送问题
低功耗蓝牙技术研究及推广
06-11 1315
stm32 USART_SendData()
STM32串口基础+应用
最新发布
xddwg521125的博客
11-19 892
本文记录stm32串口常用的库函数，以及利用在项目中使用串口，进一步巩固串口方面的知识。本文介绍了串口的基本库函数，以及串口常见的应用。
STM32f103 串口应用代码
Light&Electricity的博客
03-18 2676
关于stm32f103的串口使用的代码，方便同时配置和使用多个串口
stm32f1串口通信（两串口之间互相通信以及USART_SendData函数的bug）
qq_43745917的博客
07-10 1万+
stm32f1串口通信（两串口之间互相通信以及USART_SendData函数的bug） 简要功能 串口识别另一串口的内容然后进行相应回应（以“521” “1314”为例） 主要函数介绍 （相关串口配置初始化网上代码很多，几乎也都差不多，我在这里也不介绍了，但是需要注意的是串口二的配置串口时钟和GPIOA的时钟不在一条总线上，两串口中断优先级也会有一定的影响。） 串口中断接受立即发送 *...
【中移芯昇】3. uart读写
qq_38091632的博客
06-01 4939
uart读写，rx使用dma实现不定长度接收。
USART串口协议和USART串口外设(USART串口发送&串口发送和接收)
m0_68997646的博客
04-25 4031
USART串口协议和USART串口外设(USART串口发送&串口发送和接收)
串口发送数组时，内部数值的十六进制显示与非十六进制显示
kaoyanshiyong的博客
09-04 989
直接在主程序中定义： uint8_t a[10]={1,2,3,4,5,6,7,8,9,0}; uint8_t b[10]={10,2,3,4,5,6,7,8,9,0}; uint8_t c[10]={100,2,3,4,5,6,7,8,9,0}; 在驱动程序中已定义过void Usart_SendArray(USART_TypeDef* pUSARTx, uint8_t *array, uint...
STM32学习笔记（五）串口空闲中断+DMA实现不定长收发（stm32c8t6）
RobertPeiGen的博客
12-30 2689
串口空闲中断+DMA实现不定长收发
基于CUBE_HAL的STM32F103学习笔记更新至第11课
基于CUBE_HAL的STM32F103学习笔记（更新至第11课）是一份详细的学习笔记，旨在帮助读者掌握STM32F103系列微控制器的基本使用方法和相关技术。本文总结了学习笔记中的内容，共有11个章节，从STM32 CUBE的初始化设置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

永不秃头的程序员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值