怎样将串口收到的数据重新发到上位机并打印出来呢

　　1.首先说下printf函数
　　如下图所示，该方法是重定义fputc函数，让他变成向上位机发送数据，发送的数据会通过串口调试助手打印出来。
　　#if 1
　　#pragma import（__use_no_semihosting）
　　//标准库需要的支持函数
　　struct __FILE
　　{
　　int handle;
　　};
　　FILE __stdout;
　　//定义_sys_exit（）以避免使用半主机模式
　　void _sys_exit（int x）
　　{
　　x = x;
　　}
　　//重定义fputc函数
　　int fputc（int ch， FILE *f）
　　{
　　while（（USART1-》SR&0X40）==0）
　　{
　　}
　　//循环发送，直到发送完毕
　　USART1-》DR = （u8） ch;
　　return ch;
　　}
　　#endif
　　重定义stdio，这样写的原因猜测是让stm32可以使用printf函数来代替文件流输出数据，正常情况下c语言的printf是打印数据流在屏幕上，而keil编译后的二进制文件放在stm32芯片中，如果没有屏幕肯定是无法打印出来的（下次到lcd再仔细看看这个东西到底是个啥（ಥ_ಥ））
　　总之，没有这几行代码，没法收到下位机发过来的数据
　　好像还有微库啥的，我现在也不清楚
　　
　　stdio被用于这里
　　
　　关于半主机模式，好像去掉这两个没有任何影响，可能是目前我没有使用屏幕什么的原因吧（后面再看看这到底是是个什么鬼）
　　
　　让fputc重定义，同时printf重定义，使用串口1发送数据。在这里我猜测printf使用了fputc的实现，所以只要重定义fputc就可以顺便重定义printf。
　　
　　具体打印过程：因为这个是把串口收到的数据重新发到上位机，然后打印出来。
　　所以先让接收到的字符放到输出流，然后输出流通过串口传给上位机，上位机再把输出流的数据放在文本域中，他的接收窗口就是一个文本域，正好我用java写过一个类似的，这东西就是QQ聊天界面的原型（个人猜测，如有错误请指正）
　　
　　输出流中的字符以EOF结尾。
　　
　　其实接收到的输入流的数据也是以EOF结尾的，所以如果你自己换行然后发两行数据他只会读取第一行的数据。
　　
　　上个版本结束时候要发送回车换行rn，最近更新的xcom点击发送之后会自动拼接回车换行符，从发送数据可以看出来，下图我输出的是4个字符，而界面下面显示的是6个，说明直接点发送给自动拼接了回车换行符。
　　
　　2.再看看接收相关的
　　开启USART1代码就不用说了吧，APB2，PA9、PA10啥的，正点原子的开发指南里面有
　　还是贴一下代码吧，注释也都很详细了，以下是USART1也就是串口1的初始化配置，入口参数是波特率，我现在一般用到的都是115200
　　关于波特率，就是按多少频率，实际上是规定通信双方多长时间接收或者发送一个数据，这个和数据位或者数据与计算机底层的运算有关，原子哥在教程里面通俗易懂的讲了一点，具体讲的啥我忘了，后期有机会我会做一个 字节在计算机底层是怎么存储或传输相关的文章
　　void uart_init（u32 bound） {
　　//GPIO端口设置
　　GPIO_InitTypeDef GPIO_InitStructure;
　　USART_InitTypeDef USART_InitStructure;
　　NVIC_InitTypeDef NVIC_InitStructure;
　　RCC_APB2PeriphClockCmd（RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA， ENABLE）; //使能USART1，GPIOA时钟
　　//USART1_TX GPIOA.9
　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
　　GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
　　GPIO_Init（GPIOA， &GPIO_InitStructure）;//初始化GPIOA.9
　　//USART1_RX GPIOA.10初始化
　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
　　GPIO_Init（GPIOA， &GPIO_InitStructure）;//初始化GPIOA.10
　　//Usart1 NVIC 配置
　　NVIC_PriorityGroupConfig（NVIC_PriorityGroup_2）; //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
　　NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
　　NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
　　NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级3
　　NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
　　NVIC_Init（&NVIC_InitStructure）; //根据指定的参数初始化NVIC寄存器
　　//USART 初始化设置
　　USART_InitStructure.USART_BaudRate = bound;//串口波特率
　　USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
　　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（USART1， &USART_InitStructure）; //初始化串口1
　　USART_ITConfig（USART1， USART_IT_RXNE， ENABLE）;//开启串口接受中断
　　USART_Cmd（USART1， ENABLE）; //使能串口1
　　}
　　数据的接收主要是靠中断来实现
　　该中断的逻辑就是，接收数据，存到数组，判断回车换行符，有的话就停止往数组里面保存。
　　存完的数据会在主函数里面被发到上位机。
　　u32 Tag=0;
　　void USART1_IRQHandler（void） //串口1中断服务程序
　　{
　　u8 Res;
　　if（USART_GetITStatus（USART1， USART_IT_RXNE） ！= RESET）
　　{
　　Res = USART_ReceiveData（USART1）; //读取接收到的数据
　　//0x8000是1000 0000 0000 0000
　　//0x4000是100 0000 0000 0000
　　//0x0a是1010
　　//0x0d是1101
　　// if（（USART_RX_STA&0x8000）==0）//接收未完成
　　if（USART_RX_STA！=2）//下位机发送结束，开始接收数据
　　{
　　// if（USART_RX_STA&0x4000）
　　if（USART_RX_STA==1）
　　{
　　if（Res==0x0a） //换行符 n
　　USART_RX_STA=2;//接收错误，重新开始
　　// else
　　// {
　　// USART_RX_STA=2; //接收完成了
　　// }
　　}
　　else //还没收到0X0D
　　{
　　if（Res==0x0d） //回车符 r
　　USART_RX_STA=1;
　　else
　　{
　　//0X3FFF是11 1111 1111 1111 十进制表示16383
　　// USART_RX_BUF［USART_RX_STA&0X3FFF］=Res ;
　　// USART_RX_STA++;
　　USART_RX_BUF［Tag］=Res ;
　　Tag++;
　　// if（USART_RX_STA》（USART_REC_LEN-1））
　　// if（USART_RX_STA》199）
　　// USART_RX_STA=0;//接收数据错误，重新开始接收
　　if（Tag》200）
　　Tag=0;//接收数据错误，重新开始接收。..
　　}
　　}
　　}
　　}
　　}
　　usart.h头文件
　　#ifndef __USART_H
　　#define __USART_H
　　#include “stdio.h”
　　#include “sys.h”
　　#define USART_REC_LEN 200 //定义最大接收字节数 200
　　#define EN_USART1_RX 1 //使能（1）/禁止（0）串口1接收
　　extern u8 USART_RX_BUF［USART_REC_LEN］; //接收缓冲，最大USART_REC_LEN个字节。末字节为换行符
　　extern u16 USART_RX_STA; //接收状态标记
　　//如果想串口中断接收，请不要注释以下宏定义
　　void uart_init（u32 bound）;
　　#endif
　　我改了正点原子的串口实验代码，看他写了一堆的0x8000、0x800、0x4000、0x400，开始看的时候一脸懵逼，以为这又是什么寄存器的赋值操作，结果看到USART_RX_STA是变量值为1的时候就明白了，这就是个单纯的标志。
　　
　　如上我的代码，USART_RX_STA初始值为0，实际上你自己设置一个变量一点问题都没有。
　　这里我让USART_RX_STA初值为0，如果收到r设置为1，如果收到r，判断下一个数，如果是n则USART_RX_STA置2，同时不再进入中断，同时也就不再保存数据。如果判断r之后的一个数不是n则继续接收数据。
　　接收数据的主要参数就是在串口中断里面，只要开了串口中断，那么只要有数据通过串口发过来就会触发中断。只要读取中断的状态就知道数据有没有发送，同时TX线传输数据，这时候USART_ReceiveData（USART1）会从串口1读取数据。
　　
　　这个数据是一个位一个位来读取的，读取完成之后放在数组里面，数组大小是200，这个值随便设置。之前在做java时候看到个文章好像说一次传送多少个字节是最佳的，超过这个值会影响传输速率，具体是多少我忘了，大家有机会看到告诉我一下。
　　
　　为什么这里要在199时候重置？其实只要小于200就行，数组存够200个就置零，防止数组越界。所以她这个操作会导致如果传输201个字符时候，先存下200个字符，200个之后数组下标置零重新存数，导致覆盖之前的数据，因为Tag置零，所以数据长度也会被置零，因此实际上发送201个数据接受了201个，但是只保存了1个，因此在上位机的输出窗口只有1个。
　　
　　、
　　如下是一串超过200个字符的数据，串口显示情况
　　
　　3.最后看看发送相关的
　　发送相关代码主要在主函数里面实现
　　#include “stm32f10x.h”
　　#include “delay.h”
　　#include “led.h”
　　#include “pwm.h”
　　#include “usart.h”
　　#include “timer.h”
　　extern u32 timeSecond;
　　int main（void）
　　{
　　delay_init（）;
　　ledInit（）;
　　uart_init（115200）;
　　TIM3_Int_Init（7999，8999）;
　　u16 t;
　　u16 len;
　　extern u16 Tag;
　　while（1）
　　{
　　if（USART_RX_STA==2）
　　{
　　// len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
　　len=Tag;//得到此次接收到的数据长度
　　printf（“您发送的消息为：rn”）;
　　for（t=0; t《len; t++）
　　{
　　USART_SendData（USART1， USART_RX_BUF［t］）;//向串口1发送数据
　　while（USART_GetFlagStatus（USART1，USART_FLAG_TC）！=SET）
　　{
　　//等待发送结束
　　}
　　}
　　USART_RX_STA=0; //接收状态置零，否则任务一直在接收数据，从而一直输出上次接收的数据
　　Tag=0; //数据长度清零，否则会拼接上次的
　　printf（“rn”）;
　　}
　　}
　　}
　　在上面接收时候的串口中断里面，如果判断收到回车换行把USART_RX_STA置为2，在while里面判断USART_RX_STA为2就说明接收已经结束了然后开始发送，这样的操作我认为是半双工操作，如果开两个中断，即可以接收也可以发送应该就是全双工，需要修改的代码较多，关于全双工这里就不再探究了。
　　如上，先把Tag的值给len，实际上不用给len，直接比较也没问题，如下图所示。
　　
　　如上图，先使用USART_SendData（USART1， USART_RX_BUF［t］），把一个数据通过串口1传送出去。
　　传输过程中USART_GetFlagStatus（USART1，USART_FLAG_TC）！=SET，所以在这个时候while一直等待，让数据继续传输，等到数据传输完成USART_GetFlagStatus（USART1，USART_FLAG_TC）==SET，开始下一个字符传输，直到字符长度传输完成
　　数据传输完成之后再把USART_RX_STA置为0，实际上只要不是置为2和1，其他数都可以，这个在中断里面判断时候用。
　　同时把Tag置为0，让数组下标移到0，否则，下次接收数据会从当前位置继续累积，这个可以用作追加数据，比如在写文件时候，追加个覆盖两个操作（之前java写记事本时候这个追加和覆盖不是很明白，没想到这里直接从硬件底层了解到追加和覆盖的原理）
　　以上。
　　

　　1.首先说下printf函数
　　如下图所示，该方法是重定义fputc函数，让他变成向上位机发送数据，发送的数据会通过串口调试助手打印出来。
　　#if 1
　　#pragma import（__use_no_semihosting）
　　//标准库需要的支持函数
　　struct __FILE
　　{
　　int handle;
　　};
　　FILE __stdout;
　　//定义_sys_exit（）以避免使用半主机模式
　　void _sys_exit（int x）
　　{
　　x = x;
　　}
　　//重定义fputc函数
　　int fputc（int ch， FILE *f）
　　{
　　while（（USART1-》SR&0X40）==0）
　　{
　　}
　　//循环发送，直到发送完毕
　　USART1-》DR = （u8） ch;
　　return ch;
　　}
　　#endif
　　重定义stdio，这样写的原因猜测是让stm32可以使用printf函数来代替文件流输出数据，正常情况下c语言的printf是打印数据流在屏幕上，而keil编译后的二进制文件放在stm32芯片中，如果没有屏幕肯定是无法打印出来的（下次到lcd再仔细看看这个东西到底是个啥（ಥ_ಥ））
　　总之，没有这几行代码，没法收到下位机发过来的数据
　　好像还有微库啥的，我现在也不清楚
　　
　　stdio被用于这里
　　
　　关于半主机模式，好像去掉这两个没有任何影响，可能是目前我没有使用屏幕什么的原因吧（后面再看看这到底是是个什么鬼）
　　
　　让fputc重定义，同时printf重定义，使用串口1发送数据。在这里我猜测printf使用了fputc的实现，所以只要重定义fputc就可以顺便重定义printf。
　　
　　具体打印过程：因为这个是把串口收到的数据重新发到上位机，然后打印出来。
　　所以先让接收到的字符放到输出流，然后输出流通过串口传给上位机，上位机再把输出流的数据放在文本域中，他的接收窗口就是一个文本域，正好我用java写过一个类似的，这东西就是QQ聊天界面的原型（个人猜测，如有错误请指正）
　　
　　输出流中的字符以EOF结尾。
　　
　　其实接收到的输入流的数据也是以EOF结尾的，所以如果你自己换行然后发两行数据他只会读取第一行的数据。
　　
　　上个版本结束时候要发送回车换行rn，最近更新的xcom点击发送之后会自动拼接回车换行符，从发送数据可以看出来，下图我输出的是4个字符，而界面下面显示的是6个，说明直接点发送给自动拼接了回车换行符。
　　
　　2.再看看接收相关的
　　开启USART1代码就不用说了吧，APB2，PA9、PA10啥的，正点原子的开发指南里面有
　　还是贴一下代码吧，注释也都很详细了，以下是USART1也就是串口1的初始化配置，入口参数是波特率，我现在一般用到的都是115200
　　关于波特率，就是按多少频率，实际上是规定通信双方多长时间接收或者发送一个数据，这个和数据位或者数据与计算机底层的运算有关，原子哥在教程里面通俗易懂的讲了一点，具体讲的啥我忘了，后期有机会我会做一个 字节在计算机底层是怎么存储或传输相关的文章
　　void uart_init（u32 bound） {
　　//GPIO端口设置
　　GPIO_InitTypeDef GPIO_InitStructure;
　　USART_InitTypeDef USART_InitStructure;
　　NVIC_InitTypeDef NVIC_InitStructure;
　　RCC_APB2PeriphClockCmd（RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA， ENABLE）; //使能USART1，GPIOA时钟
　　//USART1_TX GPIOA.9
　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
　　GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
　　GPIO_Init（GPIOA， &GPIO_InitStructure）;//初始化GPIOA.9
　　//USART1_RX GPIOA.10初始化
　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
　　GPIO_Init（GPIOA， &GPIO_InitStructure）;//初始化GPIOA.10
　　//Usart1 NVIC 配置
　　NVIC_PriorityGroupConfig（NVIC_PriorityGroup_2）; //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
　　NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
　　NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
　　NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级3
　　NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
　　NVIC_Init（&NVIC_InitStructure）; //根据指定的参数初始化NVIC寄存器
　　//USART 初始化设置
　　USART_InitStructure.USART_BaudRate = bound;//串口波特率
　　USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
　　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（USART1， &USART_InitStructure）; //初始化串口1
　　USART_ITConfig（USART1， USART_IT_RXNE， ENABLE）;//开启串口接受中断
　　USART_Cmd（USART1， ENABLE）; //使能串口1
　　}
　　数据的接收主要是靠中断来实现
　　该中断的逻辑就是，接收数据，存到数组，判断回车换行符，有的话就停止往数组里面保存。
　　存完的数据会在主函数里面被发到上位机。
　　u32 Tag=0;
　　void USART1_IRQHandler（void） //串口1中断服务程序
　　{
　　u8 Res;
　　if（USART_GetITStatus（USART1， USART_IT_RXNE） ！= RESET）
　　{
　　Res = USART_ReceiveData（USART1）; //读取接收到的数据
　　//0x8000是1000 0000 0000 0000
　　//0x4000是100 0000 0000 0000
　　//0x0a是1010
　　//0x0d是1101
　　// if（（USART_RX_STA&0x8000）==0）//接收未完成
　　if（USART_RX_STA！=2）//下位机发送结束，开始接收数据
　　{
　　// if（USART_RX_STA&0x4000）
　　if（USART_RX_STA==1）
　　{
　　if（Res==0x0a） //换行符 n
　　USART_RX_STA=2;//接收错误，重新开始
　　// else
　　// {
　　// USART_RX_STA=2; //接收完成了
　　// }
　　}
　　else //还没收到0X0D
　　{
　　if（Res==0x0d） //回车符 r
　　USART_RX_STA=1;
　　else
　　{
　　//0X3FFF是11 1111 1111 1111 十进制表示16383
　　// USART_RX_BUF［USART_RX_STA&0X3FFF］=Res ;
　　// USART_RX_STA++;
　　USART_RX_BUF［Tag］=Res ;
　　Tag++;
　　// if（USART_RX_STA》（USART_REC_LEN-1））
　　// if（USART_RX_STA》199）
　　// USART_RX_STA=0;//接收数据错误，重新开始接收
　　if（Tag》200）
　　Tag=0;//接收数据错误，重新开始接收。..
　　}
　　}
　　}
　　}
　　}
　　usart.h头文件
　　#ifndef __USART_H
　　#define __USART_H
　　#include “stdio.h”
　　#include “sys.h”
　　#define USART_REC_LEN 200 //定义最大接收字节数 200
　　#define EN_USART1_RX 1 //使能（1）/禁止（0）串口1接收
　　extern u8 USART_RX_BUF［USART_REC_LEN］; //接收缓冲，最大USART_REC_LEN个字节。末字节为换行符
　　extern u16 USART_RX_STA; //接收状态标记
　　//如果想串口中断接收，请不要注释以下宏定义
　　void uart_init（u32 bound）;
　　#endif
　　我改了正点原子的串口实验代码，看他写了一堆的0x8000、0x800、0x4000、0x400，开始看的时候一脸懵逼，以为这又是什么寄存器的赋值操作，结果看到USART_RX_STA是变量值为1的时候就明白了，这就是个单纯的标志。
　　
　　如上我的代码，USART_RX_STA初始值为0，实际上你自己设置一个变量一点问题都没有。
　　这里我让USART_RX_STA初值为0，如果收到r设置为1，如果收到r，判断下一个数，如果是n则USART_RX_STA置2，同时不再进入中断，同时也就不再保存数据。如果判断r之后的一个数不是n则继续接收数据。
　　接收数据的主要参数就是在串口中断里面，只要开了串口中断，那么只要有数据通过串口发过来就会触发中断。只要读取中断的状态就知道数据有没有发送，同时TX线传输数据，这时候USART_ReceiveData（USART1）会从串口1读取数据。
　　
　　这个数据是一个位一个位来读取的，读取完成之后放在数组里面，数组大小是200，这个值随便设置。之前在做java时候看到个文章好像说一次传送多少个字节是最佳的，超过这个值会影响传输速率，具体是多少我忘了，大家有机会看到告诉我一下。
　　
　　为什么这里要在199时候重置？其实只要小于200就行，数组存够200个就置零，防止数组越界。所以她这个操作会导致如果传输201个字符时候，先存下200个字符，200个之后数组下标置零重新存数，导致覆盖之前的数据，因为Tag置零，所以数据长度也会被置零，因此实际上发送201个数据接受了201个，但是只保存了1个，因此在上位机的输出窗口只有1个。
　　
　　、
　　如下是一串超过200个字符的数据，串口显示情况
　　
　　3.最后看看发送相关的
　　发送相关代码主要在主函数里面实现
　　#include “stm32f10x.h”
　　#include “delay.h”
　　#include “led.h”
　　#include “pwm.h”
　　#include “usart.h”
　　#include “timer.h”
　　extern u32 timeSecond;
　　int main（void）
　　{
　　delay_init（）;
　　ledInit（）;
　　uart_init（115200）;
　　TIM3_Int_Init（7999，8999）;
　　u16 t;
　　u16 len;
　　extern u16 Tag;
　　while（1）
　　{
　　if（USART_RX_STA==2）
　　{
　　// len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
　　len=Tag;//得到此次接收到的数据长度
　　printf（“您发送的消息为：rn”）;
　　for（t=0; t《len; t++）
　　{
　　USART_SendData（USART1， USART_RX_BUF［t］）;//向串口1发送数据
　　while（USART_GetFlagStatus（USART1，USART_FLAG_TC）！=SET）
　　{
　　//等待发送结束
　　}
　　}
　　USART_RX_STA=0; //接收状态置零，否则任务一直在接收数据，从而一直输出上次接收的数据
　　Tag=0; //数据长度清零，否则会拼接上次的
　　printf（“rn”）;
　　}
　　}
　　}
　　在上面接收时候的串口中断里面，如果判断收到回车换行把USART_RX_STA置为2，在while里面判断USART_RX_STA为2就说明接收已经结束了然后开始发送，这样的操作我认为是半双工操作，如果开两个中断，即可以接收也可以发送应该就是全双工，需要修改的代码较多，关于全双工这里就不再探究了。
　　如上，先把Tag的值给len，实际上不用给len，直接比较也没问题，如下图所示。
　　
　　如上图，先使用USART_SendData（USART1， USART_RX_BUF［t］），把一个数据通过串口1传送出去。
　　传输过程中USART_GetFlagStatus（USART1，USART_FLAG_TC）！=SET，所以在这个时候while一直等待，让数据继续传输，等到数据传输完成USART_GetFlagStatus（USART1，USART_FLAG_TC）==SET，开始下一个字符传输，直到字符长度传输完成
　　数据传输完成之后再把USART_RX_STA置为0，实际上只要不是置为2和1，其他数都可以，这个在中断里面判断时候用。
　　同时把Tag置为0，让数组下标移到0，否则，下次接收数据会从当前位置继续累积，这个可以用作追加数据，比如在写文件时候，追加个覆盖两个操作（之前java写记事本时候这个追加和覆盖不是很明白，没想到这里直接从硬件底层了解到追加和覆盖的原理）
　　以上。
　　

　　1.首先说下printf函数
　　如下图所示，该方法是重定义fputc函数，让他变成向上位机发送数据，发送的数据会通过串口调试助手打印出来。
　　#if 1
　　#pragma import（__use_no_semihosting）
　　//标准库需要的支持函数
　　struct __FILE
　　{
　　int handle;
　　};
　　FILE __stdout;
　　//定义_sys_exit（）以避免使用半主机模式
　　void _sys_exit（int x）
　　{
　　x = x;
　　}
　　//重定义fputc函数
　　int fputc（int ch， FILE *f）
　　{
　　while（（USART1-》SR&0X40）==0）
　　{
　　}
　　//循环发送，直到发送完毕
　　USART1-》DR = （u8） ch;
　　return ch;
　　}
　　#endif
　　重定义stdio，这样写的原因猜测是让stm32可以使用printf函数来代替文件流输出数据，正常情况下c语言的printf是打印数据流在屏幕上，而keil编译后的二进制文件放在stm32芯片中，如果没有屏幕肯定是无法打印出来的（下次到lcd再仔细看看这个东西到底是个啥（ಥ_ಥ））
　　总之，没有这几行代码，没法收到下位机发过来的数据
　　好像还有微库啥的，我现在也不清楚
　　
　　stdio被用于这里
　　
　　关于半主机模式，好像去掉这两个没有任何影响，可能是目前我没有使用屏幕什么的原因吧（后面再看看这到底是是个什么鬼）
　　
　　让fputc重定义，同时printf重定义，使用串口1发送数据。在这里我猜测printf使用了fputc的实现，所以只要重定义fputc就可以顺便重定义printf。
　　
　　具体打印过程：因为这个是把串口收到的数据重新发到上位机，然后打印出来。
　　所以先让接收到的字符放到输出流，然后输出流通过串口传给上位机，上位机再把输出流的数据放在文本域中，他的接收窗口就是一个文本域，正好我用java写过一个类似的，这东西就是QQ聊天界面的原型（个人猜测，如有错误请指正）
　　
　　输出流中的字符以EOF结尾。
　　
　　其实接收到的输入流的数据也是以EOF结尾的，所以如果你自己换行然后发两行数据他只会读取第一行的数据。
　　
　　上个版本结束时候要发送回车换行rn，最近更新的xcom点击发送之后会自动拼接回车换行符，从发送数据可以看出来，下图我输出的是4个字符，而界面下面显示的是6个，说明直接点发送给自动拼接了回车换行符。
　　
　　2.再看看接收相关的
　　开启USART1代码就不用说了吧，APB2，PA9、PA10啥的，正点原子的开发指南里面有
　　还是贴一下代码吧，注释也都很详细了，以下是USART1也就是串口1的初始化配置，入口参数是波特率，我现在一般用到的都是115200
　　关于波特率，就是按多少频率，实际上是规定通信双方多长时间接收或者发送一个数据，这个和数据位或者数据与计算机底层的运算有关，原子哥在教程里面通俗易懂的讲了一点，具体讲的啥我忘了，后期有机会我会做一个 字节在计算机底层是怎么存储或传输相关的文章
　　void uart_init（u32 bound） {
　　//GPIO端口设置
　　GPIO_InitTypeDef GPIO_InitStructure;
　　USART_InitTypeDef USART_InitStructure;
　　NVIC_InitTypeDef NVIC_InitStructure;
　　RCC_APB2PeriphClockCmd（RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA， ENABLE）; //使能USART1，GPIOA时钟
　　//USART1_TX GPIOA.9
　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
　　GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
　　GPIO_Init（GPIOA， &GPIO_InitStructure）;//初始化GPIOA.9
　　//USART1_RX GPIOA.10初始化
　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
　　GPIO_Init（GPIOA， &GPIO_InitStructure）;//初始化GPIOA.10
　　//Usart1 NVIC 配置
　　NVIC_PriorityGroupConfig（NVIC_PriorityGroup_2）; //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
　　NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
　　NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
　　NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级3
　　NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
　　NVIC_Init（&NVIC_InitStructure）; //根据指定的参数初始化NVIC寄存器
　　//USART 初始化设置
　　USART_InitStructure.USART_BaudRate = bound;//串口波特率
　　USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
　　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（USART1， &USART_InitStructure）; //初始化串口1
　　USART_ITConfig（USART1， USART_IT_RXNE， ENABLE）;//开启串口接受中断
　　USART_Cmd（USART1， ENABLE）; //使能串口1
　　}
　　数据的接收主要是靠中断来实现
　　该中断的逻辑就是，接收数据，存到数组，判断回车换行符，有的话就停止往数组里面保存。
　　存完的数据会在主函数里面被发到上位机。
　　u32 Tag=0;
　　void USART1_IRQHandler（void） //串口1中断服务程序
　　{
　　u8 Res;
　　if（USART_GetITStatus（USART1， USART_IT_RXNE） ！= RESET）
　　{
　　Res = USART_ReceiveData（USART1）; //读取接收到的数据
　　//0x8000是1000 0000 0000 0000
　　//0x4000是100 0000 0000 0000
　　//0x0a是1010
　　//0x0d是1101
　　// if（（USART_RX_STA&0x8000）==0）//接收未完成
　　if（USART_RX_STA！=2）//下位机发送结束，开始接收数据
　　{
　　// if（USART_RX_STA&0x4000）
　　if（USART_RX_STA==1）
　　{
　　if（Res==0x0a） //换行符 n
　　USART_RX_STA=2;//接收错误，重新开始
　　// else
　　// {
　　// USART_RX_STA=2; //接收完成了
　　// }
　　}
　　else //还没收到0X0D
　　{
　　if（Res==0x0d） //回车符 r
　　USART_RX_STA=1;
　　else
　　{
　　//0X3FFF是11 1111 1111 1111 十进制表示16383
　　// USART_RX_BUF［USART_RX_STA&0X3FFF］=Res ;
　　// USART_RX_STA++;
　　USART_RX_BUF［Tag］=Res ;
　　Tag++;
　　// if（USART_RX_STA》（USART_REC_LEN-1））
　　// if（USART_RX_STA》199）
　　// USART_RX_STA=0;//接收数据错误，重新开始接收
　　if（Tag》200）
　　Tag=0;//接收数据错误，重新开始接收。..
　　}
　　}
　　}
　　}
　　}
　　usart.h头文件
　　#ifndef __USART_H
　　#define __USART_H
　　#include “stdio.h”
　　#include “sys.h”
　　#define USART_REC_LEN 200 //定义最大接收字节数 200
　　#define EN_USART1_RX 1 //使能（1）/禁止（0）串口1接收
　　extern u8 USART_RX_BUF［USART_REC_LEN］; //接收缓冲，最大USART_REC_LEN个字节。末字节为换行符
　　extern u16 USART_RX_STA; //接收状态标记
　　//如果想串口中断接收，请不要注释以下宏定义
　　void uart_init（u32 bound）;
　　#endif
　　我改了正点原子的串口实验代码，看他写了一堆的0x8000、0x800、0x4000、0x400，开始看的时候一脸懵逼，以为这又是什么寄存器的赋值操作，结果看到USART_RX_STA是变量值为1的时候就明白了，这就是个单纯的标志。
　　
　　如上我的代码，USART_RX_STA初始值为0，实际上你自己设置一个变量一点问题都没有。
　　这里我让USART_RX_STA初值为0，如果收到r设置为1，如果收到r，判断下一个数，如果是n则USART_RX_STA置2，同时不再进入中断，同时也就不再保存数据。如果判断r之后的一个数不是n则继续接收数据。
　　接收数据的主要参数就是在串口中断里面，只要开了串口中断，那么只要有数据通过串口发过来就会触发中断。只要读取中断的状态就知道数据有没有发送，同时TX线传输数据，这时候USART_ReceiveData（USART1）会从串口1读取数据。
　　
　　这个数据是一个位一个位来读取的，读取完成之后放在数组里面，数组大小是200，这个值随便设置。之前在做java时候看到个文章好像说一次传送多少个字节是最佳的，超过这个值会影响传输速率，具体是多少我忘了，大家有机会看到告诉我一下。
　　
　　为什么这里要在199时候重置？其实只要小于200就行，数组存够200个就置零，防止数组越界。所以她这个操作会导致如果传输201个字符时候，先存下200个字符，200个之后数组下标置零重新存数，导致覆盖之前的数据，因为Tag置零，所以数据长度也会被置零，因此实际上发送201个数据接受了201个，但是只保存了1个，因此在上位机的输出窗口只有1个。
　　
　　、
　　如下是一串超过200个字符的数据，串口显示情况
　　
　　3.最后看看发送相关的
　　发送相关代码主要在主函数里面实现
　　#include “stm32f10x.h”
　　#include “delay.h”
　　#include “led.h”
　　#include “pwm.h”
　　#include “usart.h”
　　#include “timer.h”
　　extern u32 timeSecond;
　　int main（void）
　　{
　　delay_init（）;
　　ledInit（）;
　　uart_init（115200）;
　　TIM3_Int_Init（7999，8999）;
　　u16 t;
　　u16 len;
　　extern u16 Tag;
　　while（1）
　　{
　　if（USART_RX_STA==2）
　　{
　　// len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
　　len=Tag;//得到此次接收到的数据长度
　　printf（“您发送的消息为：rn”）;
　　for（t=0; t《len; t++）
　　{
　　USART_SendData（USART1， USART_RX_BUF［t］）;//向串口1发送数据
　　while（USART_GetFlagStatus（USART1，USART_FLAG_TC）！=SET）
　　{
　　//等待发送结束
　　}
　　}
　　USART_RX_STA=0; //接收状态置零，否则任务一直在接收数据，从而一直输出上次接收的数据
　　Tag=0; //数据长度清零，否则会拼接上次的
　　printf（“rn”）;
　　}
　　}
　　}
　　在上面接收时候的串口中断里面，如果判断收到回车换行把USART_RX_STA置为2，在while里面判断USART_RX_STA为2就说明接收已经结束了然后开始发送，这样的操作我认为是半双工操作，如果开两个中断，即可以接收也可以发送应该就是全双工，需要修改的代码较多，关于全双工这里就不再探究了。
　　如上，先把Tag的值给len，实际上不用给len，直接比较也没问题，如下图所示。
　　
　　如上图，先使用USART_SendData（USART1， USART_RX_BUF［t］），把一个数据通过串口1传送出去。
　　传输过程中USART_GetFlagStatus（USART1，USART_FLAG_TC）！=SET，所以在这个时候while一直等待，让数据继续传输，等到数据传输完成USART_GetFlagStatus（USART1，USART_FLAG_TC）==SET，开始下一个字符传输，直到字符长度传输完成
　　数据传输完成之后再把USART_RX_STA置为0，实际上只要不是置为2和1，其他数都可以，这个在中断里面判断时候用。
　　同时把Tag置为0，让数组下标移到0，否则，下次接收数据会从当前位置继续累积，这个可以用作追加数据，比如在写文件时候，追加个覆盖两个操作（之前java写记事本时候这个追加和覆盖不是很明白，没想到这里直接从硬件底层了解到追加和覆盖的原理）
　　以上。
　　

4.该程序整个代码
　　main.c
　　#include “stm32f10x.h”
　　#include “delay.h”
　　#include “led.h”
　　#include “pwm.h”
　　#include “usart.h”
　　#include “timer.h”
　　extern u32 timeSecond;
　　int main（void）
　　{
　　delay_init（）;
　　ledInit（）;
　　uart_init（115200）;
　　TIM3_Int_Init（7999，8999）;
　　u16 t;
　　u16 len;
　　extern u16 Tag;
　　while（1）
　　{
　　if（USART_RX_STA==2）
　　{
　　// len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
　　// len=Tag;//得到此次接收到的数据长度
　　printf（“您发送的消息为：rn”）;
　　for（t=0; t《Tag; t++）
　　{
　　USART_SendData（USART1， USART_RX_BUF［t］）;//向串口1发送数据
　　while（USART_GetFlagStatus（USART1，USART_FLAG_TC）！=SET）
　　{
　　//等待发送结束
　　}
　　}
　　USART_RX_STA=0; //接收状态置零，否则任务一直在接收数据，从而一直输出上次接收的数据
　　Tag=0; //数据长度清零，否则会拼接上次的
　　printf（“rn”）;
　　}
　　}
　　}
　　usart.h
　　#ifndef __USART_H
　　#define __USART_H
　　#include “stdio.h”
　　#include “sys.h”
　　#define USART_REC_LEN 200 //定义最大接收字节数 200
　　#define EN_USART1_RX 1 //使能（1）/禁止（0）串口1接收
　　extern u8 USART_RX_BUF［USART_REC_LEN］; //接收缓冲，最大USART_REC_LEN个字节。末字节为换行符
　　extern u16 USART_RX_STA; //接收状态标记
　　//如果想串口中断接收，请不要注释以下宏定义
　　void uart_init（u32 bound）;
　　#endif
　　usart.c
　　#include “sys.h”
　　#include “usart.h”
　　#if 1
　　//#pragma import（__use_no_semihosting）
　　//标准库需要的支持函数
　　struct __FILE
　　{
　　};
　　FILE __stdout;
　　//定义_sys_exit（）以避免使用半主机模式
　　//void _sys_exit（int x）
　　//{
　　//
　　//}
　　//重定义fputc函数
　　int fputc（int ch， FILE *f）
　　{
　　while（（USART1-》SR&0X40）==0）
　　{
　　}
　　//循环发送，直到发送完毕
　　USART1-》DR = （u8） ch;
　　return ch;
　　}
　　#endif
　　#if EN_USART1_RX //如果使能了接收 值为1，宏定义
　　//串口1中断服务程序
　　//注意，读取USARTx-》SR能避免莫名其妙的错误
　　u8 USART_RX_BUF［USART_REC_LEN］; //接收缓冲，最大USART_REC_LEN个字节。
　　//接收状态
　　//bit15， 接收完成标志
　　//bit14， 接收到0x0d
　　//bit13~0， 接收到的有效字节数目
　　u16 USART_RX_STA=0; //接收状态标记
　　void uart_init（u32 bound） {
　　//GPIO端口设置
　　GPIO_InitTypeDef GPIO_InitStructure;
　　USART_InitTypeDef USART_InitStructure;
　　NVIC_InitTypeDef NVIC_InitStructure;
　　RCC_APB2PeriphClockCmd（RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA， ENABLE）; //使能USART1，GPIOA时钟
　　//USART1_TX GPIOA.9
　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
　　GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
　　GPIO_Init（GPIOA， &GPIO_InitStructure）;//初始化GPIOA.9
　　//USART1_RX GPIOA.10初始化
　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
　　GPIO_Init（GPIOA， &GPIO_InitStructure）;//初始化GPIOA.10
　　//Usart1 NVIC 配置
　　NVIC_PriorityGroupConfig（NVIC_PriorityGroup_2）; //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
　　NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
　　NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
　　NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级3
　　NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
　　NVIC_Init（&NVIC_InitStructure）; //根据指定的参数初始化NVIC寄存器
　　//USART 初始化设置
　　USART_InitStructure.USART_BaudRate = bound;//串口波特率
　　USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
　　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（USART1， &USART_InitStructure）; //初始化串口1
　　USART_ITConfig（USART1， USART_IT_RXNE， ENABLE）;//开启串口接受中断
　　USART_Cmd（USART1， ENABLE）; //使能串口1
　　}
　　u32 Tag=0;
　　void USART1_IRQHandler（void） //串口1中断服务程序
　　{
　　u8 Res;
　　if（USART_GetITStatus（USART1， USART_IT_RXNE） ！= RESET）
　　{
　　Res = USART_ReceiveData（USART1）; //读取接收到的数据
　　//0x8000是1000 0000 0000 0000
　　//0x4000是100 0000 0000 0000
　　//0x0a是1010
　　//0x0d是1101
　　// if（（USART_RX_STA&0x8000）==0）//接收未完成
　　if（USART_RX_STA！=2）//下位机发送结束，开始接收数据
　　{
　　// if（USART_RX_STA&0x4000）
　　if（USART_RX_STA==1）
　　{
　　if（Res==0x0a） //换行符 n
　　USART_RX_STA=2;//接收错误，重新开始
　　// else
　　// {
　　// USART_RX_STA=2; //接收完成了
　　// }
　　}
　　else //还没收到0X0D
　　{
　　if（Res==0x0d） //回车符 r
　　USART_RX_STA=1;
　　else
　　{
　　//0X3FFF是11 1111 1111 1111 十进制表示16383
　　// USART_RX_BUF［USART_RX_STA&0X3FFF］=Res ;
　　// USART_RX_STA++;
　　USART_RX_BUF［Tag］=Res ;
　　Tag++;
　　// if（USART_RX_STA》（USART_REC_LEN-1））
　　// if（USART_RX_STA》199）
　　// USART_RX_STA=0;//接收数据错误，重新开始接收
　　if（Tag》200）
　　Tag=0;//接收数据错误，重新开始接收。..
　　}
　　}
　　}
　　}
　　}
　　#endif
　　时间原因，sys相关代码不再贴上，usart代码应该是需要sys.c代码的。
　　sys.c代码在正点原子例程里面有，或者下次有时间再写一篇关于sys.c的文章。