STM32数据寄存器为USARTx->DR寄存器
可以看到DR寄存器只有[8:0]位可以使用，第8位用于奇偶校验，也就是DR寄存器一次只能接受8bit既1字节的数据。
打个比方就是一个篮子 (DR寄存器) 只能装8 (bit) 个物品，
我们用这个篮子把水果放到我们的仓库 (MCU) 中，
别人把物品一个一个放入篮子里，装满8个我们就把这篮子东西放到仓库里。
但是我们觉得这样放太乱了，就在仓库里面划了一片地,在上面贴了一个苹果标签，以后接收到的东西就放这里。
但是仓库里又不只是放苹果，而且我们也不能确定装进我篮子里的是不是苹果，也就是说我们单次接受数据的时候基本没有办法判断数据的可靠性，而且数据也是单一的。
那这样吧，我们定个规矩，你往我篮子里放了3个苹果5个橘子就代表你要开始发送有用数据了，
第二篮子你就放苹果，
第三篮子你就放橘子，
第四篮子如果放的是3个橘子5个苹果，那这次接收就结束了，
然后我也不用检查哪一个篮子是苹果哪一个是橘子，
直接就可以把第二篮放到苹果的位置，第三篮放到橘子的位置。
打的比方有些不太恰当，但基本就是这么个意思，这样我们就可以一帧接收多样的数据，通过确定开始和结束的协议也提高数据的可靠性。
但是问题又来了，我们只有一个篮子，一下子接收不了那么多篮子的数据，
那怎么办，我们在仓库立划个缓存区用于存储别人发送的数据，也就是我们把这次的数据接收完再做处理，但是这个缓冲区一般都是使用数组定义，也就是要事先规定好，你发给我8个篮子的东西，我就划8个篮子的地方，一旦开始接收数据，我事先划的地放大小就不能改了，因为数组定义的时候要事先给定长度。
呐有没有可以边接收边划分空间的方法呢，最近也在看链表的相关知识于是便想到将链表用于数据缓冲区，这样就可以边接受数据边开辟空间了。
struct Frame
{
u8 data; //数据域
struct Frame *next; //指针域指向下一个节点
};
我使用的链表比较简单，一是用于节省空间，另一方面自己会的也不多。
数据域就用于存储串口传来的8bit数据，
指针域就用于指向下一个节点，把两个节点联系起来，最后一个节点指向NULL代表链表结尾。
基本结构就是这样：
头结点的作用是用于指向下一个数据，data存储一帧的节点数量。
比如一帧的数据为 ：A5 34 56 5A
那么：Head->data=4,也就是除去头结点一共接收了4个节点
一定要注意 ！！不用的指针一定要指向NULL，防止产生野指针造成内存泄漏。
那么我们定义一个全局的头指针就可以在程序了任何地方使用了
struct Frame *Head=NULL; //头指针
extern struct Frame *Head;//声明全局变量
这个头指针现在是没有存储空间的因为它现在只是个地址信息
/**
**********************************
* 函数名：Head_Init
* 描述 ：初始化头结点
* 输入 ：无
* 输出 : 无
* 注 ：
**********************************
*/
void Head_Init(void)
{
Head=(struct Frame *)malloc(sizeof(struct Frame));
if(Head==NULL)
exit(1);
Head->data=0;
Head->next=NULL;
}
我们给头指针分配完内存,头指针就是头结点了，
头节点的data就可以存储节点长度了。
然后我们就可以在串口中断里写我们规定的协议了
#define Frame_Head 0xA5 //帧头
#define Frame_END 0x5A //帧尾
/**********帧头帧尾标志位**********/
bool Frame_Head_sta=0;
bool Frame_End_sta=0;
/**
**********************************
* 函数名：USART1_IRQHandler
* 描述 ：接受数据格式为：数据长度->帧头->数据->数据...->帧尾
* 例：4 A5 12 34 56 5A
* 输入 ：无
* 输出 : 无
* 注 ：
**********************************
*/
void USART1_IRQHandler(void)
{
u8 Res;
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
{
Res =USART_ReceiveData(USART1); //读取接收到的数据
//判断是否接受到帧头
if(Res==Frame_Head)
{
Frame_Head_sta=1;
}//判断是否接受到帧尾->若还没有接受到帧头不接受帧尾
else if(Res==Frame_END)
{
Frame_End_sta=1;
}
//已经接受到帧头或者帧尾
if((Frame_Head_sta==1)||(Frame_End_sta==1))
{
//数据长度加一
Head->data+=1;
//添加数据进入链表->尾插法
Head=Add_Data(&Head,Res);
}
}
}
协议定的比较简单，看一下注释基本就明白了
链表的插入方法采用的尾插法，其实头插法更快一些，不需要轮训数据，但是我感觉这样处理数据不太舒服，于是便写成了尾插法。
/**
**********************************
* 函数名：Add_Data
* 描述 ：尾插法插入节点
* 输入 ：(指向头结点的指针 需要插入的数据)
* 输出 : 无
* 注 ：
**********************************
*/
struct Frame* Add_Data(struct Frame **head,u8 Res)
{
struct Frame *data,*temp;
//分配内存
data=(struct Frame *)malloc(sizeof(struct Frame));
//数据域存储串口数据
data->data=Res;
//指针域指向NULL
data->next=NULL;
//指向头指针指向的位置不是NULL ->头结点后面已经连接了其他节点
if(*head!=NULL)
{
//指向头节点的指针传给temp ->保证*head不发生变化
temp=*head;
//一个节点一个节点往后查询直到temp->next=NULL，也就是最后一个节点的位置
while(temp->next)
{
temp=temp->next;
}
//把最后一个节点指向的位置改成data也就是在最后一个节点插入新的节点
temp->next=data;
}
else//头节点后还未插入节点
{
*head=data;
}
return *head;
}
一帧数据接受完之后一定要及时处理释放内存空间，不然会造成内存溢出，程序跑飞。
写到这里我又遇到一个问题，我接受的数据是不定长的，那么我存储起来也要是不定长的
但是我当时还没有好的思路，于是写了下面这坨代码
/**
/**
**********************************
* 函数名：Frame_Manage
* 描述 ：链表数据处理
* 输入 ：无
* 输出 : 无
* 注 ：
**********************************
*/
void Frame_Manage( u8 *data0,u8 *data1,u8 *data2,
u8 *data3,u8 *data4,u8 *data5,
u8 *data6,u8 *data7,u8 *data8)
{
u8 i;
//接受到帧头和帧尾
if(Frame_Head_sta&&Frame_End_sta)
{
//标志位清零
Frame_Head_sta=0;
Frame_End_sta=0;
//遍历链表并存储数据
while(Head!=NULL)
{
switch(i)
{
case 0: *data0=Head->data;break;
case 1: *data1=Head->data;break;
case 2: *data2=Head->data;break;
case 3: *data3=Head->data;break;
case 4: *data4=Head->data;break;
case 5: *data5=Head->data;break;
case 6: *data6=Head->data;break;
case 7: *data7=Head->data;break;
case 8: *data8=Head->data;break;
}
//释放节点内存
free(Head);
//地址往下走
Head=Head->next;
i++;
}
//再次分配内存给头结点 因为已经释放了投机点的内存
Head_Init();
}
}
这个代码真是相当难受，明明是不定长的接受，后来又变成固定长度的存储
后来我才想到头结点里存放的数据长度，
可以直接利用这个数据长度，使用malloc开辟一个相同长度的空间存储帧数据，
使用u8类型的指针指向开辟的内存空间，用于存放一帧的数据，
记录好首地址的位置，经过 Frame_Manage() 函数后，
我们的帧数据就存储在 *Frame_data 所指向的空间
下次帧数据来了以后再释放空间就可以了，重新更新数据长度就可以了
修改后的代码如下：
u8 *Frame_data=NULL; //帧数据缓冲区
u8 *Frame_data_Head=NULL;//只用于存放缓冲区首地址
extern u8 *Frame_data; //帧数据存储
extern u8 *Frame_data_Head;//只用于存放缓冲区首地址
/**
**********************************
* 函数名：Frame_Manage
* 描述 ：链表数据处理
* 输入 ：无
* 输出 : 无
* 注 ：
**********************************
*/
void Frame_Manage(void)
{
//如果接收到帧头 帧尾
if(Frame_Head_sta&&Frame_End_sta)
{
//释放上次缓冲区空间->放入Frame_data_Head
free(Frame_data_Head);
//指向NULL->防止乱指
Frame_data=NULL;
//开辟一帧的大小(可变)
Frame_data=(u8 *)malloc(sizeof(u8)*(Head->data));
//存放空间首地址->用于free和读取数据
Frame_data_Head=Frame_data;
//清除标志位
Frame_Head_sta=0;
Frame_End_sta=0;
while(Head!=NULL)
{
//存放帧数据
*Frame_data=(Head->data);
//地址->后移
Frame_data++;
free(Head);
Head=Head->next;
}
Head_Init();
//归还空间首地址
Frame_data=Frame_data_Head;
}
}
这片空间的用法和指向数组的指针的用法相同，
通过下面这个代码就可以读取数据帧任意一点的数据了
/**
**********************************
* 函数名：Find_Frame
* 描述 ：读取固定位置数据
* 输入 ：位置，起始地址
* 输出 : u8 数据
* 帧格式 ：4 A5 34 56 5A
* 位置 : 0 1 2 3 4
**********************************
*/
u8 Find_Frame(u8 team,u8 *head)
{
head+=team;
return *head;
}
很显然8bit无符号型明显是不够用的
就写了俩u8融合成u16的，其他类型的融合思路基本相似
/**
**********************************
* 函数名：Fusion
* 描述 ：u8融合u16
* 输入 ：team0 高8位位置 team1 低8位位置
* 输出 : 无
* 注 ：
**********************************
*/
u16 Fusion(u8 team0,u8 team1)
{
team0=Find_Frame(team0,Frame_data);
team1=Find_Frame(team1,Frame_data);
return ((team0<<8)+team1);
}
我们直接用串口发送16进制且包含帧头 (A5) 帧尾 (5A) 的数据帧STM32就可以接受到数据帧并打印出来。
可以看出我们发送数据帧长度变化的时候，STM32同样可以接收该长度的数据帧，完全不用修改程序，非常的方便,而且也是用多少拿多少，非常的人性化。
文件放在下面了，芯片类型为F103VCT6
提取码：qqy7