51c嵌入式~IO合集1

whaosoft-1432024-11-01 14:18

我自己的原文哦~https://blog.51cto.com/whaosoft/12383193

一、单片机通信数据接收解析方法

前阵子一朋友使用单片机与某外设进行通信时，外设返回的是一堆格式如下的数据：

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地址：

​​https://github.com/528787067/DataFrameParser​​

二、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个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。

一般也都是使用标识符列表模式，这里使用的也是标识符列表模式。滤波过程举例如下：

在程序中就是：

//要过滤的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单总线的数据抽象实例

1.前言

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频率进行计算。

回调函数​

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;
}

2.3.2 读函数

读函数即以该函数，通过单总线从外设上读取数据，至于代码的实现，完全是时序图的实现，无特殊难点。先实现单字节读函数，再通过调用单字节读函数实现多字节读函数。

/**
  * @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;
}

2.3.3 写函数

写函数与读函数同理，即以该函数，通过单总线往外设写入数据，至于代码的实现，完全是时序图的实现，无特殊难点。先实现单字节写函数，再通过调用单字节写函数实现多字节写函数。

/**
  * @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); 
}

3.1.2 IO输入

static uint8_t gpio_get_sdo(void)
{
    return (GPIO_ReadInputDataBit(ONEWIRE1_PORT,ONEWIRE1_PIN));
}

3.1.3 延时函数

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
}

3.2 onewire 总线初始化3.2.1 onewire 抽象相关

第一步：定义一个"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;
}

4.onewire 使用

经过前面的步骤后，我们已经通过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://git​​hub.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端口可通过软件分别配置成输入或输出。

五、STM32中GPIO工作原理详解

STM32的GPIO介绍

GPIO是通用输入/输出端口的简称，是STM32可控制的引脚。GPIO的引脚与外部硬件设备连接，可实现与外部通讯、控制外部硬件或者采集外部硬件数据的功能。

STM32F103ZET6芯片为144脚芯片，包括7个通用目的的输入/输出口（GPIO）组，分别为GPIOA、GPIOB、GPIOC、GPIOD、GPIOE、GPIOF、GPIOG，同时每组GPIO口组有16个GPIO口。通常简略称为PAx、PBx、PCx、PDx、PEx、PFx、PGx，其中x为0-15。whaoの开发板商城aiot物联网设备

STM32的大部分引脚除了当GPIO使用之外，还可以复用为外设功能引脚（比如串口），这部分在【STM32】STM32端口复用和重映射（AFIO辅助功能时钟） 中有详细的介绍。

GPIO基本结构

每个GPIO内部都有这样的一个电路结构，这个结构在本文下面会具体介绍。

电路图分析

保护二极管：IO引脚上下两边两个二极管用于防止引脚外部过高、过低的电压输入。当引脚电压高于VDD时，上方的二极管导通；当引脚电压低于VSS时，下方的二极管导通，防止不正常电压引入芯片导致芯片烧毁。但是尽管如此，还是不能直接外接大功率器件，须加大功率及隔离电路驱动，防止烧坏芯片或者外接器件无法正常工作。

P-MOS管和N-MOS管：由P-MOS管和N-MOS管组成的单元电路使得GPIO具有"推挽输出"和"开漏输出"的模式。这里的电路会在下面很详细地分析到。

TTL肖特基触发器：信号经过触发器后，模拟信号转化为0和1的数字信号。但是，当GPIO引脚作为ADC采集电压的输入通道时，用其"模拟输入"功能，此时信号不再经过触发器进行TTL电平转换。ADC外设要采集到的原始的模拟信号。

这里需要注意的是，在查看《STM32中文参考手册V10》中的GPIO的表格时，会看到有"FT"一列，这代表着这个GPIO口时兼容3.3V和5V的；如果没有标注"FT"，就代表着不兼容5V。​

STM32的GPIO工作方式

GPIO支持4种输入模式（浮空输入、上拉输入、下拉输入、模拟输入）和4种输出模式（开漏输出、开漏复用输出、推挽输出、推挽复用输出）。同时，GPIO还支持三种最大翻转速度（2MHz、10MHz、50MHz）。每个I/O口可以自由编程，但I/O口寄存器必须按32位字被访问。

GPIO的八种工作方式

  • 浮空输入模式（浮空输入模式下，I/O端口的电平信号直接进入输入数据寄存器。也就是说，I/O的电平状态是不确定的，完全由外部输入决定；如果在该引脚悬空（在无信号输入）的情况下，读取该端口的电平是不确定的。）
  • 上拉输入模式（上拉输入模式下，I/O端口的电平信号直接进入输入数据寄存器。但是在I/O端口悬空（在无信号输入）的情况下，输入端的电平可以保持在高电平；并且在I/O端口输入为低电平的时候，输入端的电平也还是低电平。）
  • 下拉输入模式（下拉输入模式下，I/O端口的电平信号直接进入输入数据寄存器。但是在I/O端口悬空（在无信号输入）的情况下，输入端的电平可以保持在低电平；并且在I/O端口输入为高电平的时候，输入端的电平也还是高电平。）
  • 模拟输入模式（模拟输入模式下，I/O端口的模拟信号（电压信号，而非电平信号）直接模拟输入到片上外设模块，比如ADC模块等等。）
  • 开漏输出模式（开漏输出模式下，通过设置位设置/清除寄存器或者输出数据寄存器的值，途经N-MOS管，最终输出到I/O端口。这里要注意N-MOS管，当设置输出的值为高电平的时候，N-MOS管处于关闭状态，此时I/O端口的电平就不会由输出的高低电平决定，而是由I/O端口外部的上拉或者下拉决定；当设置输出的值为低电平的时候，N-MOS管处于开启状态，此时I/O端口的电平就是低电平。同时，I/O端口的电平也可以通过输入电路进行读取；注意，I/O端口的电平不一定是输出的电平。）
  • 开漏复用输出模式（开漏复用输出模式，与开漏输出模式很是类似。只是输出的高低电平的来源，不是让CPU直接写输出数据寄存器，取而代之利用片上外设模块的复用功能输出来决定的。）
  • 推挽输出模式（推挽输出模式下，通过设置位设置/清除寄存器或者输出数据寄存器的值，途经P-MOS管和N-MOS管，最终输出到I/O端口。这里要注意P-MOS管和N-MOS管，当设置输出的值为高电平的时候，P-MOS管处于开启状态，N-MOS管处于关闭状态，此时I/O端口的电平就由P-MOS管决定：高电平；当设置输出的值为低电平的时候，P-MOS管处于关闭状态，N-MOS管处于开启状态，此时I/O端口的电平就由N-MOS管决定：低电平。同时，I/O端口的电平也可以通过输入电路进行读取；注意，此时I/O端口的电平一定是输出的电平。）
  • 推挽复用输出模式（推挽复用输出模式，与推挽输出模式很是类似。只是输出的高低电平的来源，不是让CPU直接写输出数据寄存器，取而代之利用片上外设模块的复用功能输出来决定的。）

什么是推挽结构和推挽电路？

推挽结构一般是指两个参数相同的三极管或MOS管分别受两互补信号的控制，总是在一个三极管或MOS管导通的时候另一个截止。高低电平由输出电平决定。

推挽电路是两个参数相同的三极管或MOSFET，以推挽方式存在于电路中，各负责正负半周的波形放大任务。电路工作时，两只对称的功率开关管每次只有一个导通，所以导通损耗小、效率高。输出既可以向负载灌电流，也可以从负载抽取电流。推拉式输出级既提高电路的负载能力，又提高开关速度。

开漏输出和推挽输出的区别？

开漏输出：只可以输出强低电平，高电平得靠外部电阻拉高。输出端相当于三极管的集电极。适合于做电流型的驱动，其吸收电流的能力相对强(一般20ma以内)；

  • 推挽输出:可以输出强高、低电平，连接数字器件。
  • 关于推挽输出和开漏输出，最后用一幅最简单的图形来概括：

该图中左边的便是推挽输出模式，其中比较器输出高电平时下面的PNP三极管截止，而上面NPN三极管导通，输出电平VS+；当比较器输出低电平时则恰恰相反，PNP三极管导通，输出和地相连，为低电平。右边的则可以理解为开漏输出形式，需要接上拉。

STM32中的I/O模式

六、串口通信及其常见问题

什么是串口通信

串口通信，就是传数据只有一根线传输，一次只能传一个位，要传一个字节就需要传8次。串口通信就是把数据串在一根线上传输，所以就叫串口吧。

在对速率要求不高的情况，使用一根线发送数据是带来大大的方便和实用价值的。

为了能正常发送和接收正确的数据，那异步串口通信就需要如下图的格式。

在串口的通信参数上，就有了波特率、起始位、数据位、校验位、停止位这几个参数。

串口通信主要为分232，485，422三种通信方式，这三种有什么区别呢？

232

232通信主要是由RX、TX、GND三根线组成。

RX接TX，TX接RX，GND接GND。这里发送和接收分别是由不同的线处理的，也就是能同时发送数据和接收数据，这就是所谓的全双工通信。

在这里扩展一下，串口通信还有一个功能叫做全功能串口通信，也叫标准串口。因为在两个设备间进行数据传输，有些设备处理速度比较快，有些数据比较慢。为了保证数据能正常传输，在RX、TX的基础上，还增加了几个控制引脚，最后成了9个引脚，也就是常见的DB9这个东西，如下图所示。

但是，如今很多控制器、人机界面、PLC等使用串口通信中一般不使用标准串口，而是直接使用RX、TX、GND三根线来通信的。

485

485的出现，是为了解决232通信距离受限的问题。

485通信只需要+、-两根线，或者也叫A、B两根线。A，B两根线的差分电平信号就是作为数据信号传输。由于发送与接收都是用这两根线，也就是说每次只能用作发送或者只能用作接收。所以，485是半双工通信。

485就是这样牺牲了232全双工的效率来达到自己传输距离远的代价。

422

422的出现，是为了既实现232的全双工通信方式，又能像485这样提高传输距离。422也常被标注为485-4，而485被标注为485-2。因为485-2是2根线，485-4是4根线，下图是422的示意图。

422就是把232的RX分成两根线，RX+，RX-，把TX分成TX+,TX-。这样就可以同时发送和同时接收了，还可以像485这样，有较远的传输距离。可是这样一种很有优势的通信方式，却用的不多，最常用到的是232跟485。

串口通信常见问题

电脑使用USB转串口可以和设备通信上，换成屏与设备就通信不上了

1）有可能电脑USB转串口接到设备上，使用的是标准串口功能，也就是除了RX，TX，GDN外，还使用了其它引脚。比如像欧姆龙PLC，三菱PLC，在实际与屏的通信中，就需要接某些引脚短接的情况。

2）电脑与控制器或PLC通信时，是扫描波特率参数，自适应的，屏通信可能参数没有设备好。在三菱，基恩士等PLC，就存在变化波特率进行通信交互的过程。

3）也有可能是接线方式不对。因为有些DB9，还需要公头，母头。如果不注意的话，也会存在把TX接到TX上，把RX接到RX上，这样需要注意的地方。

4） 在这里补充一下，有时候可能会使用一些串口助手发送测试数据与控制器通信，有些串口助手的奇偶校验是不起作用，这个要提醒一下。

这A家的屏可以和设备通信，换成B家的屏就通信不上了

1） 首先确认一下接线是否正确了，RX和TX是否兼容。

2） 地线是否没有接。

3） 除了RX，TX，GND，是否还有其它引脚需要短接的。

4） 通信协议是否一致或不完善，波特率是否一样。

以前不接地线可以通信，换个设备为什么需要接地线了

这个问题和上一个类似，因为有些设备使用了隔离电源。以前不接地可以通信，有可能实际上地线已经接了，所以才可以通信。可能换了个带隔离电源的，两个设备的地是隔离的，就需要在串口上把地线接起来。这个我是自身经历过的，有个客户老说他的设备通信不上，后来拍个照我给我，他地线没有接，他说以前不接地线可以通信的。于是我就给他科普了一下。

一个设备是232，另一个设备是422，没有转换设备，怎么办

这个情况我遇到过，客户的设备是422通信的，但是我手上并没有422设备，只有232通信可以测试。因此就需要把422转成232进行通信。

刚才也讲了422和232的接线，因为这两个都是全双工的，接收和发送都是分到的，而422只是以一种差分信号进行传输。

把422的Rx+与232的TX接，422的RX-与232的GND接。

把422的TX+与232的RX接，422的TX-与232的GDN接。

这样，422设备要发送数据的，就可以发送到了232的RX上。232的TX发数据后，由于TX和GND也形成了差分信号给422，422就可以接收到数据了。

用232通信没问题，用485通信没问题，使用232转485之后就通信不稳定

232和485从通信原理上，最大一个差别是全双工和半双工的区别。可是应用层发送数据和接收数据才不管底下是全双工还是半双工。

但是485就得管了。因为既然是半双工，就得严格保证通路上只能有发送或只能有接收的数据，一旦同时有发送和接收，数据就会冲突了。所以解决的办法就是主站设备，也就是主动命令的一方就需要严格控制好发送数据命令的节奏了。当然有些232转485的设备做的比较好了，可以优化这个，但是主站还是要控制，比较把通信速率调节慢一些。

要想实现两个屏或两个主站通过485访问modbus设备，有什么好的办法

在485通信中，基本上是一主多从。但是遇到一些客户实际使用中，有客户想用两个屏来访问一个modbus设备的。目前暂时还没有好的办法。等这个功能出来后，再来给大家演示操作吧。

串口通信的弱点

1）信号干扰的问题

建议使用带屏蔽线，接线要严格，比如要接地。有些485通信上，还考虑接上终端电阻来匹配。如果是232，尽量不要让线太长。通信协议上尽量避免长报文的数据通信。

2）波特率匹配的问题

因为有些设备的计算的波特率是存在误差的，特别是一些控制器，由于使用的晶振不一样。因此在一些波特率比如9600波特率就存在误差。存在误差带来的影响是什么呢。因为接收方是通过时间来计算一个位的。那么如果一个报文过长，就会存在误差积累的问题，算着算着就偏了。所以，这也是串口通信不稳定的一些地方，在使用上应注意避免发送太长数据的包。

3）在一些可能会存在干扰的情况，可以考虑使用奇校验或者偶校验

因为虽说出现错误的可能性不大，但既然存在干扰，如果加了校验，至少可以把错误的报文过滤掉。总好比没有校验然后通信数据错了不知道。或者尽量使用一些带校验的协议，防止数据出错。

4） 串口通信本来就比较慢，请降低对数据响应的要求

因为串口通信本身就比以太网慢。而且，串口通信并不是能像CPU那样多线程处理。因为就一个口一个线数据出去，即便你应用到程序再怎么用多线程处理数据，但是最底下也只有一个口出去，一次也只能传一个位，一个字节过去。因为有客户在使用9600的波特率通信，但是又希望多少的数据可以在多少毫秒内得到响应。

但是串口通信还是要事实求是，所以正确认识串口通信对应用，对开发，对沟通都有着很大的帮助的。

为什么不用同步通信

刚才提到，同步通信需要依赖于时钟信号。这就存在一个问题，这个时钟信号是谁来发起呢。在同步通信中，往往需要一个主设备发起时钟信号读从模块的数据。在实际中，有屏读PLC，有屏读屏的数据。而单纯地从异步串口通信来说，是没有主从之说，双方都是平等的角色，都可以互发信息，互收信息。而同步通信一般是应用于CPU读一些模块，由CPU发起时钟信号，比如读SD卡模块，就可以通过SPI方式，还有一些传感器模块。

七、STM32串口通信简明知识

1 什么是串口通讯？

串行通讯是指仅用一根接收线和一根发送线就能将数据以位进行传输的一种通讯方式。尽管串行通讯的比按字节传输的并行通信慢，但是串口可以在仅仅使用两根线的情况下就能实现数据的传输。​​[付费]STM32嵌入式资料包​​

典型的串口通信使用3根线完成，分别是地线、发送、接收。由于串口通信是异步的，所以端口能够在一根线上发送数据同时在另一根线上接收数据。串口通信最重要的参数是波特率、数据位、停止位和奇偶的校验。对于两个需要进行串口通信的端口，这些参数必须匹配，这也是能够实现串口通讯的前提。如下是串行通讯示数据传输意图。

2 串口通讯的通讯协议

最初数据是模拟信号输出简单过程量，后来仪表接口出现了RS232接口，这种接口可以实现点对点的通信方式，但这种方式不能实现联网功能，这就促生了RS485。

我们知道串口通信的数据传输都是0和1，在单总线、I2C、UART中都是通过一根线的高低电平来判断逻辑1或者逻辑0，但这种信号线的GND再与其他设备形成共地模式的通信，这种共地模式传输容易产生干扰，并且抗干扰性能也比较弱。所以差分通信、支持多机通信、抗干扰强的RS485就被广泛的使用了。

RS485通信最大特点就是传输速度可以达到10Mb/s以上，传输距离可以达到3000米左右。大家需要注意的是虽然485最大速度和最大传输距离都很大，但是传输的速度是会随距离的增加而变慢的，所以两者是不可以兼得的。​

3 串口通讯的物理层

串口通讯的物理层有很多标准，例如上面提到的，我们主要讲解RS-232标准，RS-232标准主要规定了信号的用途、通讯接口以及信号的电平标准。

在上面的通讯方式中，两个通讯设备的"DB9接口"之间通过串口信号线建立起连接，串口信号线中使用"RS-232标准"传输数据信号。由于RS-232电平标准的信号不能直接被控制器直接识别，所以这些信号会经过一个"电平转换芯片"转换成控制器能识别的"TTL校准"的电平信号，才能实现通讯。

下图为DB9标准串口通讯接口：

DB9引脚说明：

上表中的是计算机端的DB9公头标准接法，由于两个通讯设备之间的收发信号(RXD与TXD)应交叉相连，所以调制调解器端的DB9母头的收发信号接法一般与公头的相反，两个设备之间连接时，只要使用"直通型"的串口线连接起来即可。

串口线中的RTS、CTS、DSR、DTR及DCD信号，使用逻辑 1表示信号有效，逻辑0表示信号无效。例如，当计算机端控制DTR信号线表示为逻辑1时，它是为了告知远端的调制调解器，本机已准备好接收数据，0则表示还没准备就绪。​

4 波特率

波特率是指数据信号对载波的调制速率，它用单位时间内载波调制状态改变的次数来表示。

比如波特率为9600bps；代表的就是每秒中传输9600bit，也就是相当于每一秒中划分成了9600等份。

因此，那么每1bit的时间就是1/9600秒=104.1666...us。约0.1ms。既然是9600等份，即每1bit紧接着下一个比特，不存在额外的间隔。两台设备要想实现串口通讯，这收发端设置的波特率必须相同，否则是没办法实现通讯的:​​动图演示常用通信协议原理​​。

收发波特率一致可以实现通讯：

收发波特率不一致，导致RX端不能正常接收：

5 串口通讯的数据结构

起始位： 起始位必须是持续一个比特时间的逻辑0电平，标志传输一个字符的开始，接收方可用起始位使自己的接收时钟与发送方的数据同步。

数据位： 数据位紧跟在起始位之后，是通信中的真正有效信息。数据位的位数可以由通信双方共同约定。传输数据时先传送字符的低位，后传送字符的高位。

奇偶校验位： 奇偶校验位仅占一位，用于进行奇校验或偶校验，奇偶检验位不是必须有的。如果是奇校验，需要保证传输的数据总共有奇数个逻辑高位；如果是偶校验，需要保证传输的数据总共有偶数个逻辑高位。

停止位： 停止位可以是是1位、1.5位或2位，可以由软件设定。它一定是逻辑1电平，标志着传输一个字符的结束。

空闲位： 空闲位是指从一个字符的停止位结束到下一个字符的起始位开始，表示线路处于空闲状态，必须由高电平来填充。​

6 单双工通讯

单工： 数据传输只支持数据在一个方向上传输；

半双工： 允许数据在两个方向上传输，但某一时刻只允许数据在一个方向上传输，实际上是一种切换方向的单工通信，不需要独立的接收端和发送端，两者可合并为一个端口；

全双工： 允许数据同时在两个方向上传输，因此全双工通信是两个单工方式的结合，需要独立的接收端和发送端。

7 STM32中的串口通讯

STM32串口通信接口有两种，分别是：UART(通用异步收发器)、USART(通用同步异步收发器)，对于大容量STM32F10x系列芯片，分别由3个USART和两个UART。

TXD：数据发送引脚；

RXD：数据输入引脚

对于两芯片的间的连接，两个芯片GND共地，同时TXD和RXD交叉连接，这样两个芯片间可进行TTL电平通信。

但如果对于芯片和PC机相连，除了共地条件外，不能使用如上的直接交叉连接，虽然两者都有TXD和RXD引脚，但通常PC机使用的是RS232接口（9针），通常是TXC和RXD经过电平转换得到，故如果要使芯片与PC机的RS232接口直接通信，需要将芯片的输入输出端口也电平转换为RS232类型，再交叉连接。

二者的电平标准不同：

  • 单片机的点评标准(TTL电平）：+5V表示1，0V表示0；
  • RS232电平标准：+15/+13V表示0，-15/-13表示1。

因此单片机与PC机进行串口通信应该遵循：在单片机串口与上位机给出的RS232口之间，通过电平转换电路实现TTL电平与RS232电平间的转换。

如果使用USB转串口也可以实现串口通讯，USB转串口电路图如下所示。

STM32中串口通讯已经给大家建好了相应的库函数，大家在使用和配置串口的时候直接进行调用库函数和配置就行了

​​ STM32实例-用按键控制串口发送数据，文末附代码​​

请大家参照一下代码：

1、初始化结构体代码

typedef struct {
 uint32_t USART_BaudRate; // 波特率
 uint16_t USART_WordLength; // 字长
 uint16_t USART_StopBits; // 停止位
 uint16_t USART_Parity; // 校验位
 uint16_t USART_Mode; // USART 模式
 uint16_t USART_HardwareFlowControl; // 硬件流控制
 } USART_InitTypeDef;

2、NVIC配置中断优先级

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);
}

3、USART配置函数

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


 /* 第一步：初始化GPIO */
  // 打开串口GPIO的时钟
 DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_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); 


 /* 第二步：配置串口的初始化结构体 */
  // 打开串口外设的时钟
 DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
 // 配置串口的工作参数
 // 配置波特率
 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); 
}
相关推荐
Whappy0012 小时前
6. STM32之TIM实验--编码器接口（）--（实验5：PWM驱动直流电机）
stm32·单片机·嵌入式硬件
东芝、铠侠总代136100683933 小时前
TOSHIBA 74VHC00FT COMS汽车、工业企业的选择
嵌入式硬件
WIZnet7 小时前
W55RP20-EVB-Pico评估板介绍
单片机·嵌入式硬件·wiznet·w55rp20·以太网开发板
Wx120不知道取啥名8 小时前
微控制器（MCU）如何运行存储在Flash的程序？？？
单片机·嵌入式硬件·mcu
云卓科技10 小时前
无人机之中继通信技术篇
科技·嵌入式硬件·安全·机器人·无人机
潇洒的电磁波10 小时前
半波正弦信号的FFT变换
嵌入式硬件
Lin20123010 小时前
STM32 + CubeMX + 硬件SPI + W5500 +TcpClient
stm32·单片机·嵌入式硬件
极客小张10 小时前
基于STM32的智能温室环境监测与控制系统设计（代码示例）
c语言·arm开发·stm32·单片机·嵌入式硬件·物联网·毕业设计
玉树临风江流儿10 小时前
STM32标准库-待机模式
stm32·单片机·嵌入式硬件
北京迅为13 小时前
【北京迅为】《STM32MP157开发板嵌入式开发指南》-第七十六章 C++入门
stm32·单片机·嵌入式硬件
热门推荐
01Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04制冷毛细管的计算方法介绍05(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明06【经验分享】Ubuntu22.04安装微信(linux官方版)07MacBook外接键盘修改键位08【Java】Ruoyi-Vue-Plus 整合 文件分片上传至 minio、阿里云、七牛云等OSS-【后端篇】09RAG 实践- Ollama+RagFlow 部署本地知识库10支付宝短视频平台创作分成激励项目