一、单片机通信数据接收解析方法
前阵子一朋友使用单片机与某外设进行通信时，外设返回的是一堆格式如下的数据：
AA AA 04 80 02 00 02 7B AA AA 04 80 02 00 08 75 AA AA 04 80 02 00 9B E2 AA AA 04 80 02 00 F6 87 AA AA 04 80 02 00 EC 91
其中 AA AA 04 80 02 是数据校验头，后面三位是有效数据，问我怎么从外设不断返回的数据中取出有效的数据。
对于这种问题最容易想到的就是使用一个标志位用于标志当前正解析到一帧数据的第几位，然后判断当前接收的数据是否与校验数据一致，如果一致则将标志位加一，否则将标志位置0重新判断，使用这种方法解析数据的代码如下：
if(flag == 0)
{
if(tempData == 0xAA)
flag++;
else
flag = 0;
}
else if(flag == 1)
{
if(tempData == 0xAA)
flag++;
else
flag = 0;
}
else if(flag == 2)
{
if(tempData == 0x04)
flag++;
else
flag = 0;
}
else if(flag == 3)
{
if(tempData == 0x80)
flag++;
else
flag = 0;
}
else if(flag == 4)
{
if(tempData == 0x02)
flag++;
else
flag = 0;
}
else if(flag == 5 || flag == 6 || flag == 7)
{
data[flag-5] = tempData;
flag = (flag == 7) ? 0 : flag+1;
}使用上述方法是最容易想到的也是最简单的方法了，百度了一下基本上也都是使用类似的方法进行数据解析，但是使用这种方法有如下几个缺点：
1、 大量使用了判断，容易导致出现逻辑混乱。
2、 代码重复率高，抽象程度低。从上述代码可以看到一大堆代码仅仅是判断的数据不同，其他代码都完全一致。
3、 代码可复用性差。写好的代码无法用在其他类似的外设上，如果有多个外设就需要编写多份类似的代码。
4、 可扩展性低。如果外设还有一个数据校验尾需要校验或者数据校验头发生改变，就需要再次写多个判断重新用于校验，无法在原有的代码上进行扩展。
5、 容易出现误判 。
对此，这里提出了一种新的解决方案，可以通用与所有类似的数据解析，原理如下：
使用一个固定容量的队列用来缓存接收到的数据，队列容量等于一帧数据的大小，每来一个数据就将数据往队列里面加，当完整接收到一帧数据时此时队列中的全部数据也就是一帧完整的数据，因此只需要判断队列是否是数据校验头，队列尾是否是数据校验尾就可以得知当前是否已经接收到了一帧完整的数据，然后在将数据从队列中取出即可。原理图如下：
每来一个数据就往队列里面加：
当接收到一帧完整数据时队列头和数据校验头重合：
此时只需要从队列中取出有效数据即可。
如果有数据尾校验，仅仅只需要添加一个校验尾即可，如下图所示：
好，分析结束，开始编码。
首先需要一个队列，为了保证通用性，队列底层使用类似于双向链表的实现（当然也可以使用数组实现），需要封装的结构有队列容量、队列大小、队头节点和队尾节点，需要实现的操作有队列初始化、数据入队、数据出队、清空队列和释放队列，具体代码如下：
/* queue.h */
#ifndef _QUEUE_H_
#define _QUEUE_H_
#ifndef NULL
#define NULL ((void *)0)
#endif
typedef unsigned char uint8;
/* 队列节点 */
typedef struct Node
{
uint8 data;
struct Node *pre_node;
struct Node *next_node;
} Node;
/* 队列结构 */
typedef struct Queue
{
uint8 capacity; // 队列总容量
uint8 size; // 当前队列大小
Node *front; // 队列头节点
Node *back; // 队列尾节点
} Queue;
/* 初始化一个队列 */
Queue *init_queue(uint8 _capacity);
/* 数据入队 */
uint8 en_queue(Queue *_queue, uint8 _data);
/* 数据出队 */
uint8 de_queue(Queue *_queue);
/* 清空队列 */
void clear_queue(Queue *_queue);
/* 释放队列 */
void release_queue(Queue *_queue);
#endif/* queue.c */
#include <stdlib.h>
#include "parser.h"
/**
* 初始化一个队列
*
* @_capacity: 队列总容量
*/
Queue *init_queue(uint8 _capacity)
{
Queue *queue = (Queue *)malloc(sizeof(Queue));
queue->capacity = _capacity;
queue->size = 0;
return queue;
}
/**
* 数据入队
*
* @_queue: 队列
* @_data: 数据
**/
uint8 en_queue(Queue *_queue, uint8 _data)
{
if(_queue->size < _queue->capacity)
{
Node *node = (Node *)malloc(sizeof(Node));
node->data = _data;
node->next_node = NULL;
if(_queue->size == 0)
{
node->pre_node = NULL;
_queue->back = node;
_queue->front = _queue->back;
}
else
{
node->pre_node = _queue->back;
_queue->back->next_node = node;
_queue->back = _queue->back->next_node;
}
_queue->size++;
}
else
{
Node *temp_node = _queue->front->next_node;
_queue->front->pre_node = _queue->back;
_queue->back->next_node = _queue->front;
_queue->back = _queue->back->next_node;
_queue->back->data = _data;
_queue->back->next_node = NULL;
_queue->front = temp_node;
}
return _queue->size-1;
}
/**
* 数据出队
*
* @_queue: 队列
*
* @return: 出队的数据
*/
uint8 de_queue(Queue *_queue)
{
uint8 old_data = 0;
if(_queue->size > 0)
{
old_data = _queue->front->data;
if(_queue->size == 1)
{
free(_queue->front);
_queue->front = NULL;
_queue->back = NULL;
}
else
{
_queue->front = _queue->front->next_node;
free(_queue->front->pre_node);
_queue->front->pre_node = NULL;
}
_queue->size--;
}
return old_data;
}
/**
* 清空队列
*
* @_queue: 队列
*/
void clear_queue(Queue *_queue)
{
while(_queue->size > 0)
{
de_queue(_queue);
}
}
/**
* 释放队列
*
* @_queue: 队列
*/
void release_queue(Queue *_queue)
{
clear_queue(_queue);
free(_queue);
_queue = NULL;
}其次是解析器，需要封装的结构有解析数据队列、数据校验头、数据校验尾、解析结果以及指向解析结果的指针，需要实现的操作有解析器初始化、添加数据解析、获取解析结果、重置解析器和释放解析器，具体代码如下：
/* parser.h */
#ifndef _PARSER_H_
#define _PARSER_H_
#include "queue.h"
typedef enum
{
RESULT_FALSE,
RESULT_TRUE
} ParserResult;
/* 解析器结构 */
typedef struct DataParser
{
Queue *parser_queue; // 数据解析队列
Node *resule_pointer; // 解析结果数据指针
uint8 *data_header; // 数据校验头指针
uint8 header_size; // 数据校验头大小
uint8 *data_footer; // 数据校验尾指针
uint8 footer_size; // 数据校验尾大小
uint8 result_size; // 解析数据大小
ParserResult parserResult; // 解析结果
} DataParser;
/* 初始化一个解析器 */
DataParser *parser_init(uint8 *_data_header, uint8 _header_size, uint8 *_data_footer, uint8 _foot_size, uint8 _data_frame_size);
/* 将数据添加到解析器中进行解析 */
ParserResult parser_put_data(DataParser *_parser, uint8 _data);
/* 解析成功后从解析器中取出解析结果 */
int parser_get_data(DataParser *_parser, uint8 _index);
/* 重置解析器 */
void parser_reset(DataParser *_parser);
/* 释放解析器 */
void parser_release(DataParser *_parser);
#endif/* parser.c */
#include <stdlib.h>
#include "parser.h"
/**
* 初始化一个解析器
*
* @_data_header: 数据头指针
* @_header_size: 数据头大小
* @_data_footer: 数据尾指针
* @_foot_size: 数据尾大小
* @_data_frame_size: 一帧完整数据的大小
*
* @return: 解析器
*/
DataParser *parser_init(uint8 *_data_header, uint8 _header_size, uint8 *_data_footer, uint8 _foot_size, uint8 _data_frame_size)
{
if((_header_size+_foot_size) > _data_frame_size || (_header_size+_foot_size) == 0)
return NULL;
DataParser *parser = (DataParser *)malloc(sizeof(DataParser));
parser->parser_queue = init_queue(_data_frame_size);
parser->resule_pointer = NULL;
parser->data_header = _data_header;
parser->header_size = _header_size;
parser->data_footer = _data_footer;
parser->footer_size = _foot_size;
parser->result_size = _data_frame_size - parser->header_size - parser->footer_size;
parser->parserResult = RESULT_FALSE;
while(_data_frame_size-- > 0)
{
en_queue(parser->parser_queue, 0);
}
return parser;
}
/**
* 将数据添加到解析器中进行解析
*
* @_parser: 解析器
* @_data: 要解析的数据
*
* @return: 当前解析结果，返回 RESULT_TRUE 代表成功解析出一帧数据
*/
ParserResult parser_put_data(DataParser *_parser, uint8 _data)
{
uint8 i;
Node *node;
if(_parser == NULL)
return RESULT_FALSE;
en_queue(_parser->parser_queue, _data);
/* 校验数据尾 */
node = _parser->parser_queue->back;
for(i = _parser->footer_size; i > 0; i--)
{
if(node->data != _parser->data_footer[i-1])
goto DATA_FRAME_FALSE;
node = node->pre_node;
}
/* 校验数据头 */
node = _parser->parser_queue->front;
for(i = 0; i < _parser->header_size; i++)
{
if(node->data != _parser->data_header[i])
goto DATA_FRAME_FALSE;
node = node->next_node;
}
if(_parser->resule_pointer == NULL && _parser->result_size > 0)
_parser->resule_pointer = node;
if(_parser->parserResult != RESULT_TRUE)
_parser->parserResult = RESULT_TRUE;
return _parser->parserResult;
DATA_FRAME_FALSE:
if(_parser->resule_pointer != NULL)
_parser->resule_pointer = NULL;
if(_parser->parserResult != RESULT_FALSE)
_parser->parserResult = RESULT_FALSE;
return _parser->parserResult;
}
/**
* 解析成功后从解析器中取出解析结果
*
* @_parser: 解析器
* @_index: 解析结果集合中的第 _index 个数据
*
* @return: 获取解析成功的数据，返回 -1 代表数据获取失败
*/
int parser_get_data(DataParser *_parser, uint8 _index)
{
Node *node;
if(_parser == NULL
|| _parser->parserResult != RESULT_TRUE
|| _index >= _parser->result_size
|| _parser->resule_pointer == NULL)
return -1;
node = _parser->resule_pointer;
while(_index > 0)
{
node = node->next_node;
_index--;
}
return node->data;
}
/**
* 重置解析器
*
* @_parser: 解析器
*/
void parser_reset(DataParser *_parser)
{
uint8 _data_frame_size;
if(_parser == NULL)
return;
_data_frame_size = _parser->parser_queue->size;
while(_data_frame_size-- > 0)
{
en_queue(_parser->parser_queue, 0);
}
_parser->resule_pointer = NULL;
_parser->parserResult = RESULT_FALSE;
}
/**
* 释放解析器
*
* @_parser: 解析器
*/
void parser_release(DataParser *_parser)
{
if(_parser == NULL)
return;
release_queue(_parser->parser_queue);
free(_parser);
_parser = NULL;
}接下来编写测试代码测试一下：
/* main.c */
#include <stdio.h>
#include "parser.h"
int main()
{
uint8 i;
// 数据头
uint8 data_header[] = {0xAA, 0xAA, 0x04, 0x80, 0x02};
// 要解析的数据，测试用
uint8 data[] = {
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0x02, 0x7B, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0x08, 0x75, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0x9B, 0xE2,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0xF6, 0x87, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0xEC, 0x91, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x15, 0x67,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x49, 0x33, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0xE7, 0x96, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0x68, 0x15,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0x3C, 0x41, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0x66, 0x17, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0xA5, 0xD8,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x26, 0x56, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x01, 0x73, 0x09, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x64, 0x18,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x8B, 0xF1, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x01, 0xC6, 0xB6, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x7B, 0x01,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0xCB, 0xB2, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0x2C, 0x51, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0xFF, 0xE5, 0x99
};
/**
* 初始化一个解析器
* 第一个参数是数据头
* 第二个参数是数据头长度
* 第三个参数是数据尾指针
* 第四个参数是数据尾大小
* 第五个参数是一整帧数据的大小
*/
DataParser *data_parser = parser_init(data_header, sizeof(data_header), NULL, 0, 8);
// 将要解析的数据逐个取出，添加到解析器中
for(i = 0; i < sizeof(data); i++)
{
// 解析数据，返回 RESULT_TRUE 代表成功解析出一组数据
if(parser_put_data(data_parser, data[i]) == RESULT_TRUE)
{
printf("成功解析出一帧数据...\n");
/* 一位一位取出解析后的数据 */
printf("第一个数据是：0x%x\n", parser_get_data(data_parser, 0));
printf("第二个数据是：0x%x\n", parser_get_data(data_parser, 1));
printf("第三个数据是：0x%x\n\n\n", parser_get_data(data_parser, 2));
}
}
// 当不再需要解析器时，应该把解析器释放掉，回收内存，避免造成内存泄漏
parser_release(data_parser);
return 0;
}测试结果如下：
从上面可以看出，解析的结果与目标一致。
github地址：
二、STM32F103~CAN收发通信
CAN通信
CAN 是Controller Area Network 的缩写（以下称为CAN），该通信使用的是ISO11898标准，该标准的物理层特征如下图所示。
CAN协议是通过以下5种类型的帧进行的：
- 数据帧
- 摇控帧
- 错误帧
- 过载帧
- 帧间隔
另外，数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符（ID），扩展格式有29 个位的ID。
大部分系统使用的都是数据帧 ，我这里使用的也是数据帧。
数据帧一般由7个段构成，即：
（1） 帧起始。表示数据帧开始的段。
（2） 仲裁段。表示该帧优先级的段。
（3） 控制段。表示数据的字节数及保留位的段。
（4） 数据段。数据的内容，一帧可发送0~8个字节的数据。
（5） CRC段。检查帧的传输错误的段。
（6） ACK段。表示确认正常接收的段。
（7） 帧结束。表示数据帧结束的段。
明确了数据帧概念，还需要理解一下过滤器的作用。
STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个（互联型），但是STM32F103ZET6只有14个（增强型），每个滤波器组x由2个32为寄存器，CAN_FxR1和CAN_FxR2组成。
STM32每个过滤器组的位宽都可以独立配置，以满足应用程序的不同需求。根据位宽的不同，每个过滤器组可提供：
- 1个32位过滤器，包括：STDID[10:0]、EXTID[17:0]、IDE和RTR位
- 2个16位过滤器，包括：STDID[10:0]、IDE、RTR和EXTID[17:15]位
此外过滤器可配置为，屏蔽位模式和标识符列表模式。
在屏蔽位模式下，标识符寄存器和屏蔽寄存器一起，指定报文标识符的任何一位，应该按照“必须匹配”或“不用关心”处理。
而在标识符列表模式下，屏蔽寄存器也被当作标识符寄存器用。因此，不是采用一个标识符加一个屏蔽位的方式，而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章：CAN总线详解。
一般也都是使用标识符列表模式，这里使用的也是标识符列表模式。滤波过程举例如下：
在程序中就是：
//要过滤的ID高位
CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;
//要过滤的ID低位
CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
//过滤器屏蔽标识符的高16位值
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;
//过滤器屏蔽标识符的低16位值
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;这里的CAN_FilterId和CAN_FilterMaskId是配合使用的，意思是CAN_FilterId指出需要屏蔽ID的什么内容，什么格式；CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤，若CAN_FilterMaskId在某位上是1的话，ID对应位上的数值就必须和CAN_FilterId该位上的一样，保持一致，反之则是“不关心”。上述程序的设置的含义就是：只接收来自0x1314的数据，屏蔽其他ID的数据。
程序思路
这里准备做一个主机与从机的通信，主要用扩展标识符ExtId来区分，分配的标识符是：
主机：0x1314
从机：0x1311
主机负责接收所有从机的数据，不需要过滤，用扩展标识符ExtId来区分不同从机的数据；主机还可以向不同从机发送信息。而从机则只接收来自主机的数据，同样用扩展标识符ExtId来区分是否是发向自己的数据；同时，也能够向主机发送信息。
相关代码
代码也是非常简单的，这里贴出了主机和从机的can.c和can.h两个文件。
从机相关代码
can.c文件：
#include "can.h"
/* 在中断处理函数中返回 */
//__IO uint32_t ret = 0;
//接收数据缓冲器
u8 RxBuf[5];
u8 Rx_flag=0;
void CAN1_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
/* 复用功能和GPIOB端口时钟使能*/
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);
/* CAN1 模块时钟使能 */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
/* Configure CAN pin: RX */ // PB8
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Configure CAN pin: TX */ // PB9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
GPIO_Init(GPIOB, &GPIO_InitStructure);
//#define GPIO_Remap_CAN GPIO_Remap1_CAN1 本实验没有用到重映射I/O
GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
//CAN_NVIC_Configuration(); //CAN中断初始化
/* Configure the NVIC Preemption Priority Bits */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
#ifdef VECT_TAB_RAM
/* Set the Vector Table base location at 0x20000000 */
NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
#else /* VECT_TAB_FLASH */
/* Set the Vector Table base location at 0x08000000 */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
#endif
/* enabling interrupt */
NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
//CAN_INIT();//CA初始化N模块
/* CAN register init */
CAN_DeInit(CAN1); //将外设CAN的全部寄存器重设为缺省值
CAN_StructInit(&CAN_InitStructure); //把CAN_InitStruct中的每一个参数按缺省值填入
/* CAN cell init */
CAN_InitStructure.CAN_TTCM=DISABLE; //没有使能时间触发模式
CAN_InitStructure.CAN_ABOM=DISABLE; //没有使能自动离线管理
CAN_InitStructure.CAN_AWUM=DISABLE; //没有使能自动唤醒模式
CAN_InitStructure.CAN_NART=DISABLE; //没有使能非自动重传模式
CAN_InitStructure.CAN_RFLM=DISABLE; //没有使能接收FIFO锁定模式
CAN_InitStructure.CAN_TXFP=DISABLE; //没有使能发送FIFO优先级
CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
CAN_InitStructure.CAN_SJW=CAN_SJW_1tq; //重新同步跳跃宽度1个时间单位
CAN_InitStructure.CAN_BS1=CAN_BS1_3tq; //时间段1为3个时间单位
CAN_InitStructure.CAN_BS2=CAN_BS2_2tq; //时间段2为2个时间单位
CAN_InitStructure.CAN_Prescaler=60; //时间单位长度为60
CAN_Init(CAN1,&CAN_InitStructure); //波特率为：72M/2/60(1+3+2)=0.1 即波特率为100KBPs
// CAN filter init 过滤器，注意，只接收主机发过来的数据，屏蔽其他数据
CAN_FilterInitStructure.CAN_FilterNumber=1; //指定过滤器为1
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; //指定过滤器为标识符屏蔽位模式
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //过滤器位宽为32位
//CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;
CAN_FilterInitStructure.CAN_FilterIdHigh=0X00; //要过滤的ID高位
CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF; //过滤器屏蔽标识符的高16位值
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF; //过滤器屏蔽标识符的低16位值
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0; //设定了指向过滤器的FIFO为0
CAN_FilterInitStructure.CAN_FilterActivatinotallow=ENABLE; //使能过滤器
CAN_FilterInit(&CAN_FilterInitStructure); //按上面的参数初始化过滤器
/* CAN FIFO0 message pending interrupt enable */
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //使能FIFO0消息挂号中断
}
/* 发送两个字节的数据*/
u8 CAN_SetMsg(u8 Data1,u8 Data2)
{
u8 mbox;
u16 i=0;
CanTxMsg TxMessage;
TxMessage.StdId=0x0000; //标准标识符为0x00
TxMessage.ExtId=0x1311; //扩展标识符0x1311,可以更改该标识符以示区分不同从机
TxMessage.IDE=CAN_ID_EXT; //使用扩展标识符
TxMessage.RTR=CAN_RTR_DATA; //为数据帧
TxMessage.DLC=2; //消息的数据长度为2个字节
TxMessage.Data[0]=Data1; //第一个字节数据
TxMessage.Data[1]=Data2; //第二个字节数据
//发送数据
mbox= CAN_Transmit(CAN1, &TxMessage);
while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
i++; //等待发送结束
if(i>=0XFFF)
return 0;
return 1;
}
u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
{
if(Rx_flag == 1)//发现数据
{
*msg1=RxBuf[0];
*msg2=RxBuf[1];
Rx_flag=0;//数据已经取走，可以更新数据
return 1;
}else
return 0;
}
/* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
void USB_LP_CAN1_RX0_IRQHandler(void)
{
CanRxMsg RxMessage;
RxMessage.StdId=0x00;
RxMessage.ExtId=0x00;
RxMessage.IDE=0;
RxMessage.DLC=0;
RxMessage.FMI=0;
RxMessage.Data[0]=0x00;
RxMessage.Data[1]=0x00;
CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据
if(Rx_flag == 0)//数据已取走或者缓冲器为空
{
RxBuf[0]=RxMessage.Data[0];
RxBuf[1]=RxMessage.Data[1];
Rx_flag=1;//数据已经备好，等待取走
}
}can.h文件
#ifndef __CAN_H
#define __CAN_H
#include "sys.h"
void CAN1_Init(void);
u8 CAN_SetMsg(u8 Data1,u8 Data2);
u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
#endif /* __CAN_H */主机相关代码
这里主机代码大部分是和从机类似的，就只贴出不同的地方了。
can.c文件：
#include "can.h"
/* 在中断处理函数中返回 */
//__IO uint32_t ret = 0;
void CAN1_Init(void)
{
......//以上与从机部分相同
//CAN filter init 过滤器，已经设置为任意，可以通过ExtId标识符区分从机代号
CAN_FilterInitStructure.CAN_FilterNumber=1; //指定过滤器为1
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; //指定过滤器为标识符屏蔽位模式
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //过滤器位宽为32位
CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000; //过滤器标识符的高16位值
CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000; //过滤器屏蔽标识符的高16位值
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000; //过滤器屏蔽标识符的低16位值
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0; //设定了指向过滤器的FIFO为0
CAN_FilterInitStructure.CAN_FilterActivatinotallow=ENABLE; //使能过滤器
CAN_FilterInit(&CAN_FilterInitStructure); //按上面的参数初始化过滤器
/* CAN FIFO0 message pending interrupt enable */
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //使能FIFO0消息挂号中断
}
//接收数据缓冲器
u8 CAN_RX_BUF[CAN_RX_LEN]={0}; //接收缓冲,最大USART_REC_LEN个字节.
//接收标志位
u8 Rx_flag=0;
/* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
void USB_LP_CAN1_RX0_IRQHandler(void)
{
u8 i=0;
CanRxMsg RxMessage;
RxMessage.StdId=0x00;
RxMessage.ExtId=0x00;
RxMessage.IDE=0;
RxMessage.DLC=0;
RxMessage.FMI=0;
CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据
if(Rx_flag == 0)//数据已取走或者缓冲器为空
{
if((RxMessage.DLC) == 2)//是否收到2位字节数据
{
CAN_RX_BUF[0]=RxMessage.Data[0];
CAN_RX_BUF[1]=RxMessage.Data[1];
}
}
}
/* 发送两个字节的数据*/
u8 CAN_SendMsg(u8* data1, u8* data2)
{
u8 mbox;
u16 i=0;
CanTxMsg TxMessage;
TxMessage.StdId=0x0000; //标准标识符为0x00
TxMessage.ExtId=0x1314; //扩展标识符0x0000
TxMessage.IDE=CAN_ID_EXT; //使用扩展标识符
TxMessage.RTR=CAN_RTR_DATA; //为数据帧
TxMessage.DLC=2; //消息的数据长度为2个字节
TxMessage.Data[0]=Data1; //第一个字节数据
TxMessage.Data[1]=Data2; //第二个字节数据
//发送数据
mbox= CAN_Transmit(CAN1, &TxMessage);
while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
i++; //等待发送结束
if(i>=0XFFF)
return 0;//发送失败
return 1;//发送成功
}
u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
{
if(Rx_flag == 1)//发现数据
{
*msg1=CAN_RX_BUF[0];
*msg2=CAN_RX_BUF[1];
Rx_flag=0;//数据已经取走，可以更新数据
return 1;
}else
return 0;
}
void Clear_canBuffer(void)
{
Rx_flag=0;//清楚接收标志位
memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区
}
u8 Check_canRX(void)
{
return (Rx_flag == 6);
}can.h文件：
#ifndef __CAN_H
#define __CAN_H
#include "sys.h"
#include "string.h"
#define CAN_RX_LEN 30 //定义最大接收字节数
extern u8 CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
void CAN1_Init(void);
u8 CAN_SendMsg(u8* data1, u8* data2);
u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
#endif /* __CAN_H */开发板商城 天皓智联 上有相关设备
三、STM32基于onewire单总线的数据抽象实例
onewire(单总线) 是DALLAS公司推出的外围串行扩展总线技术总线，顾名思义，它是采用一根信号线进行通信，既传输时钟信号又传输数据，而且能够进行双向通信，具有节省I/O口线、资源结构简单、成本低廉、便于总线扩展和维护等诸多优点。
常用到单总线的器件，一般是温度传感器、EEPROM、唯一序列号芯片等，如DS18B20、DS2431。
在使用单总线时，往往很少CPU会提供硬件单总线，几乎都是根据单总线标准的时序图，通过普通IO翻转模拟实现单总线。而在模式实现时序图的过程中，需要根据CPU时钟频率等条件进行时序时间计算，如果更换CPU后，需要重新计算时序时间，如果时序代码和器件外设控制代码集成在一起，则代码改动比较大。
或者同一CPU需要模拟多根单总线时，传统的“复制”方式使得程序显得累赘，还增加ROM占用空间。因此，可以利用“函数指针”的方式，将时序部分抽象出来，达到“复用”代码的效果，减少重复代码编写。
2.onewire 抽象
2.1 onewire 结构体
onewire结构体主要是对与CPU底层相关的操作抽象分离，调用时只需将该结构体地址（指针）作为函数入口参数，通过该指针实现对底层函数的回调。该结构体我们命名为“struct ops_onewire_dev”，其原型如下：
struct ops_onewire_dev
{
void (*set_sdo)(int8_t state);
uint8_t (*get_sdo)(void);
void (*delayus)(uint32_t us);
};其中：
1）set_sdo：IO输出1bit，包括时钟和数据。
2）get_sdo：IO输入1bit，包括时钟和数据。
3）delayus：时序延时函数，根据CPU频率进行计算。
回调函数相关文章：C语言技巧之回调函数
2.2 onewire 对外接口
extern uint8_t ops_onewire_reset(struct ops_onewire_dev *onewire);
extern int ops_onewire_read(struct ops_onewire_dev *onewire,void *buff,int size);
extern int ops_onewire_write(struct ops_onewire_dev *onewire,void *buff,int size);1）分别为复位函数、读函数、写函数。
2）入口首参数为“struct ops_onewire_dev”结构体指针，此部分就是硬件层相关，需要后期初始化的.
3）其余入口参数易于理解，读/写缓存及数据大小。
2.3 onewire 抽象接口实现
分别实现上述三者函数接口。
2.3.1 复位函数
复位函数，在单总线初始化外设器件时需要用到，用于判断总线与器件是否通信上，类似“握手”的动作。如图，为DS18B20的复位时序图，以下与单总线相关的时序图，都是以DS18B20为例，因为此芯片为单总线应用的经典。
根据时序图，实现复位函数。
/**
* @brief 单总线复位时序
* @param onewire 总线结构体指针
* @retval 成功返回0
*/
uint8_t ops_onewire_reset(struct ops_onewire_dev *onewire)
{
uint8_t ret = 0;
onewire->set_sdo(1);
onewire->delayus(50);
onewire->set_sdo(0);
onewire->delayus(500);
onewire->set_sdo(1);
onewire->delayus(40);
ret = onewire->get_sdo();
onewire->delayus(500);
onewire->set_sdo(1);
return ret;
}读函数即以该函数，通过单总线从外设上读取数据，至于代码的实现，完全是时序图的实现，无特殊难点。先实现单字节读函数，再通过调用单字节读函数实现多字节读函数。
/**
* @brief 单总线读取一字节数据
* @param onewire 总线结构体指针
* @retval 返回读取的数据
*/
static char ops_onewire_read_byte(struct ops_onewire_dev *onewire)
{
char data = 0;
uint8_t i;
for(i=8;i>0;i--)
{
data >>= 1;
onewire->set_sdo(0);
onewire->delayus(5);
onewire->set_sdo(1);
onewire->delayus(5);
if(onewire->get_sdo())
data |= 0x80;
else
data &= 0x7f;
onewire->delayus(65);
onewire->set_sdo(1);
}
return data;
}
/**
* @brief 读取多字节
* @param onewire 总线结构体指针
* @param buff 存放数据缓存
* @param size 数据大小
* @retval 返回读取到的数据大小
*/
int ops_onewire_read(struct ops_onewire_dev *onewire,void *buff,int size)
{
int i;
char *p = (char*)buff;
for(i=0;i<size;i++)
p[i++]=ops_onewire_read_byte(onewire);
return i;
}写函数与读函数同理，即以该函数，通过单总线往外设写入数据，至于代码的实现，完全是时序图的实现，无特殊难点。先实现单字节写函数，再通过调用单字节写函数实现多字节写函数。
/**
* @brief 单总线写一字节
* @param onewire 总线结构体指针
* @param data 待写数据
* @retval 返回读取的数据
*/
static int ops_onewire_write_byte(struct ops_onewire_dev *onewire,char data)
{
uint8_t i;
for(i=8;i>0;i--)
{
onewire->set_sdo(0);
onewire->delayus(5);
if(data&0x01)
onewire->set_sdo(1);
else
onewire->set_sdo(0);
onewire->delayus(65);
onewire->set_sdo(1);
onewire->delayus(2);
data >>= 1;
}
return 0;
}
/**
* @brief 写多字节
* @param onewire 总线结构体指针
* @param buff 代写数据地址
* @param size 数据大小
* @retval 写入数据大小
*/
int ops_onewire_write(struct ops_onewire_dev *onewire,void *buff,int size)
{
int i;
char *p = (char*)buff;
for(i=0;i<size;i++)
{
if(ops_onewire_write_byte(onewire,p[i]) != 0)
break;
}
return i;
}至此，onewire（单总线）抽象化完成，此部分代码与硬件层分离，亦可单独作为一个模块，移植到不同平台CPU时，也几乎无需改动。剩下部分工作则是实现“struct ops_onewire_dev”中的函数指针原型，即可使用一根单总线。
3.onewire 抽象应用
以STM32F1为例，实现上述抽象接口。
3.1 “struct ops_onewire_dev” 实现
此部分即是与硬件相关部分，不同CPU平台改动该部分即可，如从51单片机移植到STM32上。下面涉及到的IO宏，是对应IO的宏定义，如“ONEWIRE1_PORT”、“ONEWIRE1_PIN”，实际使用的是PC13 IO口。
3.1.1 IO输出
static void gpio_set_sdo(int8_t state)
{
if (state)
GPIO_SetBits(ONEWIRE1_PORT,ONEWIRE1_PIN);
else
GPIO_ResetBits(ONEWIRE1_PORT,ONEWIRE1_PIN);
}static uint8_t gpio_get_sdo(void)
{
return (GPIO_ReadInputDataBit(ONEWIRE1_PORT,ONEWIRE1_PIN));
}static void gpio_delayus(uint32_t us)
{
#if 1 /* 不用系统延时时，开启 */
volatile int32_t i;
for (; us > 0; us--)
{
i = 30; //mini 17
while(i--);
}
#else
delayus(us);
#endif
}第一步：定义一个“struct ops_onewire_dev”结构体类型变量（全局）——onewire1_dev。
struct ops_onewire_dev onewire1_dev;第二步：实例化“onewire1_dev”中的函数指针。
onewire1_dev.get_sdo = gpio_get_sdo;
onewire1_dev.set_sdo = gpio_set_sdo;
onewire1_dev.delayus = gpio_delayus;第三步：使用时，通过传入“onewire1_dev”地址（指针）即可。
3.2.2 onewire 基础相关
初始基础部分，与使用的CPU硬件相关，如时钟、IO方向等。
/**
* @brief 初始化单总线
* @param none
* @retval none
*/
void stm32f1xx_onewire1_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(ONEWIRE1_RCC,ENABLE);
GPIO_InitStructure.GPIO_Pin = ONEWIRE1_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(ONEWIRE1_PORT, &GPIO_InitStructure);
ONEWIRE1_PORT->BSRR = ONEWIRE1_PIN;
/* device init */
onewire1_dev.get_sdo = gpio_get_sdo;
onewire1_dev.set_sdo = gpio_set_sdo;
onewire1_dev.delayus = gpio_delayus;
}经过前面的步骤后，我们已经通过IO口翻转，模拟实现了一根单总线——“onewire1_dev”，以DS18B20为例，调用第一部分中三者接口，实现对DS18B20的操作。
4.1 DS18B20操作
对于DS18B20，不陌生，即是温度传感器，不多赘述，使用的功能主要是作为温度检测，另外还有其内部的唯一序列号会作为同一总线上挂多个DS18B20时的“地址”识别。
亦可把DS18B20的唯一序列号作为模块、产品、通信总线等的唯一标识使用。因此，代码也是主要实现这两个功能。
#include "onewire_hw.h"
#include "ds18b20.h"
static uint8_t ds18b20_start(void)
{
char reg;
ops_onewire_reset(&onewire1_dev);
reg = 0xcc; /* 跳过ROM */
ops_onewire_write(&onewire1_dev,®,1);
reg = 0x44; /* 温度转换指令 */
ops_onewire_write(&onewire1_dev,®,1);
return 0;
}
/**
* @brief 读取温度
* @param none
* @retval 温度值，浮点型
*/
float ds18b20_readtemp(void)
{
uint8_t tl,th,sign;
uint16_t reg_temp;
char reg;
float temp;
ds18b20_start();
ops_onewire_reset(&onewire1_dev);
reg = 0xcc;
ops_onewire_write(&onewire1_dev,®,1); /* 跳过ROM */
reg = 0xbe;
ops_onewire_write(&onewire1_dev,®,1); /* 读取RAM */
ops_onewire_read(&onewire1_dev,&tl,1); /* 低8位数据 */
ops_onewire_read(&onewire1_dev,&th,1); /* 高8位数据 */
if(th > 7)
{/* - */
th = ~th;
tl = ~tl + 1;
sign = 0;
}
else
{/* + */
sign = 1;
}
reg_temp = (th<<8) | tl;
temp = reg_temp * 0.0625f;
if(sign)
{
return temp;
}
else
{
return -temp;
}
}
/**
* @brief 读唯一序列号
* @param rom 返回序列号缓存
* @retval none
*/
void ds18b20_readrom(char *rom)
{
uint8_t i;
char reg;
ops_onewire_reset(&onewire1_dev);
reg = 0x33;
ops_onewire_write(&onewire1_dev,®,1);
for (i = 0;i < 8;i++)
{
ops_onewire_read(&onewire1_dev,&rom[i],1);
}
}至此，完成单总线的抽象分层使用。
源码:https://github.com/Prry/drivers-for-mcu
来源:https://acuity.blog.csdn.net/article/
四、常见总线：IIC、IIS、SPI、UART、JTAG、CAN、SDIO、GPIO
IIC
IIC(Inter－Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备。I2C总线用两条线(SDA和SCL)在总线和装置之间传递信息，在微控制器和外部设备之间进行串行通讯或在主设备和从设备之间的双向数据传送。I2C是OD输出的，大部分I2C都是2线的（时钟和数据），一般用来传输控制信号。
IIS
I2S（Inter-IC Sound Bus）是飞利浦公司为数字音频设备之间的音频数据传输而制定的一种总线标准。I2S有3个主要信号：1.串行时钟SCLK，也叫位时钟，即对应数字音频的每一位数据，SCLK有1个脉冲。2.帧时钟LRCK，用于切换左右声道的数据。LRCK为“1”表示正在传输的是左声道的数据，为“0”则表示正在传输的是右声道的数据。3.串行数据SDATA，就是用二进制补码表示的音频数据。有时为了使系统间能够更好地同步，还需要另外传输一个信号MCLK，称为主时钟，也叫系统时钟（Sys Clock）。
SPI
SPI(Serial Peripheral Interface：串行外设接口);SPI是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在EEPROM,FLASH,实时时钟,AD转换器,还有数字信号处理器和数字信号解码器之间。SPI接口是以主从方式工作的,这种模式通常有一个主器件和一个或多个从器件,其接口包括以下四种信号：（1）MOSI – 主器件数据输出,从器件数据输入 （2）MISO – 主器件数据输入,从器件数据输出 （3）SCLK – 时钟信号,由主器件产生（4）/SS – 从器件使能信号,由主器件控制。
UART
UART(Universal Asynchronous Receiver Transmitter：通用异步收发器)。将由计算机内部传送过来的并行数据转换为输出的串行数据流。将计算机外部来的串行数据转换为字节，供计算机内部使用并行数据的器件使用。在输出的串行数据流中加入奇偶校验位，并对从外部接收的数据流进行奇偶校验。在输出数据流中加入启停标记，并从接收数据流中删除启停标记。处理由键盘或鼠标发出的中断信号（键盘和鼠票也是串行设备）。可以处理计算机与外部串行设备的同步管理问题。有一些比较高档的UART还提供输入输出数据的缓冲区。常用TXD，RXD，/RTS，/CTS。
JTAG
JTAG (Joint Test Action Group 联合测试行动小组)是一种国际标准测试协议（IEEE1149.1兼容），主要用于芯片内部测试。标准的JTAG接口是4线：TMS、TCK、TDI、TDO，分别为模式选择、时钟、数据输入和数据输出线。测试复位信号(TRST,一般以低电平有效)一般作为可选的第五个端口信号。一个含有JTAGDebug接口模块的CPU，只要时钟正常，就可以通过JTAG接口访问CPU的内部寄存器和挂在CPU总线上的设备，如FLASH，RAM，内置模块的寄存器，象UART，Timers，GPIO等等的寄存器。
CAN
CAN全称为“Controller Area Network”，即控制器局域网，是国际上应用最广泛的现场总线之一:总结CAN总线技术基础。最初，CAN被设计作为汽车环境中的微控制器通讯，在车载各电子控制装置ECU之 间交换信息，形成汽车电子控制网络。比如：发动机管理系统、变速箱控制器、仪表装备、电子主干系统中，均嵌入CAN控制装置。一个由CAN总线构成的单一网络中，理论上可以挂接无数个节点。实际应用中，节点数目受网络硬件的电气特性所限制。例如，当使用Philips P82C250作为CAN收发器时，同一网络中允许挂接110个节点。CAN 可提供高达1Mbit/s的数据传输速率，这使实时控制变得非常容易。另外，硬件的错误检定特性也增强了CAN的抗电磁干扰能力。
SDIO
SDIO是SD型的扩展接口，除了可以接SD卡外，还可以接支持SDIO接口的设备，插口的用途不止是插存储卡。支持 SDIO接口的PDA，笔记本电脑等都可以连接象GPS接收器，Wi-Fi或蓝牙适配器，调制解调器，局域网适配器，条型码读取器，FM无线电，电视接收 器，射频身份认证读取器，或者数码相机等等采用SD标准接口的设备。
GPIO
GPIO (General Purpose Input Output 通用输入/输出)或总线扩展器利用工业标准I²C、SMBus™或SPI™接口简化了I/O口的扩展:STM32的GPIO电路原理。当微控制器或芯片组没有足够的I/O端口，或当系统 需要采用远端串行通信或控制时，GPIO产品能够提供额外的控制和监视功能。
每个GPIO端口可通过软件分别配置成输入或输出。
