（转）GD32F130FXP6学习笔记三：ARM的GPIO初识

1万 · 2018-8-4 10:24

出处：http://www.openedv.com/posts/list/32730.htm

最近在看数据手册的时候，发现在Cortex-M3里，对于GPIO的配置种类有8种之多：

（1）GPIO_Mode_AIN 模拟输入

（2）GPIO_Mode_IN_FLOATING 浮空输入

（3）GPIO_Mode_IPD 下拉输入

（4）GPIO_Mode_IPU 上拉输入

（5）GPIO_Mode_Out_OD 开漏输出

（6）GPIO_Mode_Out_PP 推挽输出

（7）GPIO_Mode_AF_OD 复用开漏输出

（8）GPIO_Mode_AF_PP 复用推挽输出

对于刚入门的新手，我想这几个概念是必须得搞清楚的，平时接触的最多的也就是推挽输出、开漏输出、上拉输入这三种，但一直未曾对这些做过归纳。因此，在这里做一个总结：

推挽输出:可以输出高,低电平,连接数字器件; 推挽结构一般是指两个三极管分别受两互补信号的控制,总是在一个三极管导通的时候另一个截止。高低电平由IC的电源低定。

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

详细理解：

如图所示，推挽放大器的输出级有两个“臂”（两组放大元件），一个“臂”的电流增加时，另一个“臂”的电流则减小，二者的状态轮流转换。对负载而言，好像是一个“臂”在推，一个“臂”在拉，共同完成电流输出任务。当输出高电平时，也就是下级负载门输入高电平时，输出端的电流将是下级门从本级电源经VT3拉出。这样一来，输出高低电平时，VT3 一路和 VT5 一路将交替工作，从而减低了功耗，提高了每个管的承受能力。又由于不论走哪一路，管子导通电阻都很小，使RC常数很小，转变速度很快。因此，推拉式输出级既提高电路的负载能力，又提高开关速度。

开漏输出:输出端相当于三极管的集电极. 要得到高电平状态需要上拉电阻才行. 适合于做电流型的驱动,其吸收电流的能力相对强(一般20ma以内).

开漏形式的电路有以下几个特点：

1.利用外部电路的驱动能力，减少IC内部的驱动。当IC内部MOSFET导通时，驱动电流是从外部的VCC流经R pull-up ，MOSFET到GND。IC内部仅需很下的栅极驱动电流。

2.一般来说，开漏是用来连接不同电平的器件，匹配电平用的，因为开漏引脚不连接外部的上拉电阻时，只能输出低电平，如果需要同时具备输出高电平的功能，则需要接上拉电阻，很好的一个优点是通过改变上拉电源的电压，便可以改变传输电平。比如加上上拉电阻就可以提供TTL/CMOS电平输出等。（上拉电阻的阻值决定了逻辑电平转换的沿的速度。阻值越大，速度越低功耗越小，所以负载电阻的选择要兼顾功耗和速度。）

3.OPEN-DRAIN提供了灵活的输出方式，但是也有其弱点，就是带来上升沿的延时。因为上升沿是通过外接上拉无源电阻对负载充电，所以当电阻选择小时延时就小，但功耗大；反之延时大功耗小。所以如果对延时有要求，则建议用下降沿输出。

4.可以将多个开漏输出的Pin，连接到一条线上。通过一只上拉电阻，在不增加任何器件的情况下，形成“与逻辑”关系。这也是I2C，SMBus等总线判断总线占用状态的原理。补充：什么是“线与”？：

在一个结点(线)上,连接一个上拉电阻到电源VCC或VDD和n个NPN或NMOS晶体管的集电极C或漏极D,这些晶体管的发射极E或源极S都接到地线上,只要有一个晶体管饱和,这个结点(线)就被拉到地线电平上.因为这些晶体管的基极注入电流(NPN)或栅极加上高电平(NMOS),晶体管就会饱和,所以这些基极或栅极对这个结点(线)的关系是或非NOR逻辑.如果这个结点后面加一个反相器,就是或OR逻辑.

其实可以简单的理解为：在所有引脚连在一起时，外接一上拉电阻，如果有一个引脚输出为逻辑0，相当于接地，与之并联的回路“相当于被一根导线短路”，所以外电路逻辑电平便为0，只有都为高电平时，与的结果才为逻辑1。

关于推挽输出和开漏输出，最后用一幅最简单的图形来概括：

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

浮空输入：对于浮空输入，一直没找到很权威的解释，只好从以下图中去理解了

由于浮空输入一般多用于外部按键输入，结合图上的输入部分电路，我理解为浮空输入状态下，IO的电平状态是不确定的，完全由外部输入决定，如果在该引脚悬空的情况下，读取该端口的电平是不确定的。

上拉输入/下拉输入/模拟输入：这几个概念很好理解，从字面便能轻易读懂。

复用开漏输出、复用推挽输出：可以理解为GPIO口被用作第二功能时的配置情况（即并非作为通用IO口使用）

最后总结下使用情况：

在STM32中选用IO模式

（1）浮空输入_IN_FLOATING ——浮空输入，可以做KEY识别，RX1

（2）带上拉输入_IPU——IO内部上拉电阻输入

（3）带下拉输入_IPD—— IO内部下拉电阻输入

（4）模拟输入_AIN ——应用ADC模拟输入，或者低功耗下省电

（5）开漏输出_OUT_OD ——IO输出0接GND，IO输出1，悬空，需要外接上拉电阻，才能实现输出高电平。当输出为1时，IO口的状态由上拉电阻拉高电平，但由于是开漏输出模式，这样IO口也就可以由外部电路改变为低电平或不变。可以读IO输入电平变化，实现C51的IO双向功能

（6）推挽输出_OUT_PP ——IO输出0-接GND， IO输出1 -接VCC，读输入值是未知的

（7）复用功能的推挽输出_AF_PP ——片内外设功能（I2C的SCL,SDA）

（8）复用功能的开漏输出_AF_OD——片内外设功能（TX1,MOSI,MISO.SCK.SS）

STM32设置实例：

（1）模拟I2C使用开漏输出_OUT_OD，接上拉电阻，能够正确输出0和1；读值时先GPIO_SetBits(GPIOB, GPIO_Pin_0)；拉高，然后可以读IO的值；使用GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_0)；

（2）如果是无上拉电阻，IO默认是高电平；需要读取IO的值，可以使用带上拉输入_IPU和浮空输入_IN_FLOATING和开漏输出_OUT_OD；

通常有5种方式使用某个引脚功能，它们的配置方式如下：

1）作为普通GPIO输入：根据需要配置该引脚为浮空输入、带弱上拉输入或带弱下拉输入，同时不要使能该引脚对应的所有复用功能模块。

2）作为普通GPIO输出：根据需要配置该引脚为推挽输出或开漏输出，同时不要使能该引脚对应的所有复用功能模块。

3）作为普通模拟输入：配置该引脚为模拟输入模式，同时不要使能该引脚对应的所有复用功能模块。

4）作为内置外设的输入：根据需要配置该引脚为浮空输入、带弱上拉输入或带弱下拉输入，同时使能该引脚对应的某个复用功能模块。

5）作为内置外设的输出：根据需要配置该引脚为复用推挽输出或复用开漏输出，同时使能该引脚对应的所有复用功能模块。

注意如果有多个复用功能模块对应同一个引脚，只能使能其中之一，其它模块保持非使能状态。

比如要使用STM32F103VBT6的47、48脚的USART3功能，则需要配置47脚为复用推挽输出或复用开漏输出，配置48脚为某种输入模式，同时使能USART3并保持I2C2的非使能状态。

如果要使用STM32F103VBT6的47脚作为TIM2_CH3，则需要对TIM2进行重映射，然后再按复用功能的方式配置对应引脚。

1万 · 2018-8-4 10:24

一、GPIO模式配置

1、输入/输出模式（参考stm32手册）

2、GPIO输出模式下，几种速度的区别：

(1). GPIO 引脚速度： GPIO_Speed_2MHz (10MHz, 50MHz) ;

又称输出驱动电路的响应速度：（芯片内部在I/O口的输出部分安排了多个响应速度不同的输出驱动电路，用户可以根据自己的需要选择合适的驱动电路，通过选择速度来选择不同的输出驱动模块，达到最佳的噪声控制和降低功耗的目的。）

可理解为: 输出驱动电路的带宽：即一个驱动电路可以不失真地通过信号的最大频率。

(如果一个信号的频率超过了驱动电路的响应速度，就有可能信号失真。失真因素？)

如果信号频率为10MHz，而你配置了2MHz的带宽，则10MHz的方波很可能就变成了正弦波。就好比是公路的设计时速，汽车速度低于设计时速时，可以平稳地运行，如果超过设计时速就会颠簸，甚至翻车。

关键是： GPIO的引脚速度跟应用相匹配，速度配置越高，噪声越大，功耗越大。

带宽速度高的驱动器耗电大、噪声也大，带宽低的驱动器耗电小、噪声也小。使用合适的驱动器可以降低功耗和噪声

比如：高频的驱动电路，噪声也高，当不需要高的输出频率时，请选用低频驱动电路，这样非常有利于提高系统的EMI性能。当然如果要输出较高频率的信号，但却选用了较低频率的驱动模块，很可能会得到失真的输出信号。关键是GPIO的引脚速度跟应用匹配（推荐10倍以上？）。

比如：

①　USART串口，若最大波特率只需115.2k，那用2M的速度就够了，既省电也噪声小。

②　I2C接口，若使用400k波特率，若想把余量留大些，可以选用10M的GPIO引脚速度。

③　SPI接口，若使用18M或9M波特率，需要选用50M的GPIO的引脚速度。

(2). GPIO的翻转速度指：输入/输出寄存器的0 ，1 值反映到外部引脚(APB2上)高低电平的速度.手册上指出GPIO最大翻转速度可达18MHz。

@通过简单的程序测试，用示波器观察到的翻转时间: 是综合的时间，包括取指令的时间、指令执行的时间、指令执行后信号传递到寄存器的时间(这其中可能经过很多环节，比如AHB、APB、总线仲裁等)，最后才是信号从寄存器传输到引脚所经历的时间。

如：有上拉电阻，其阻值越大，RC延时越大，即逻辑电平转换的速度越慢，功耗越大。

(3).GPIO 输出速度：与程序有关，(程序中写的多久输出一个信号)。

2、GPIO口设为输入时，输出驱动电路与端口是断开，所以输出速度配置无意义。

3、在复位期间和刚复位后，复用功能未开启，I/O端口被配置成浮空输入模式。

4、所有端口都有外部中断能力。为了使用外部中断线，端口必须配置成输入模式。

5、GPIO口的配置具有上锁功能，当配置好GPIO口后，可以通过程序锁住配置组合，直到下次芯片复位才能解锁。

一般应用：

模拟输入_AIN ——应用ADC模拟输入，或者低功耗下省电。

浮空输入_IN_FLOATING ——可以做KEY识别，RX1

开漏输出_Out_OD——应用于I2C总线；（STM32开漏输出若外部不接上拉电阻只能输出0）

二. 管脚的复用功能重映射

1、复用功能：内置外设是与I/O口共用引出管脚（不同的功能对应同一管脚）

STM32 所有内置外设的外部引脚都是与标准GPIO引脚复用的，如果有多个复用功能模块对应同一个引脚，只能使能其中之一，其它模块保持非使能状态。

2、重映射功能：复用功能的引出脚可以通过重映射，从不同的I/O管脚引出，即复用功能的引出脚位是可通过程序改变到其他的引脚上！

直接好处：PCB电路板的设计人员可以在需要的情况下，不必把某些信号在板上绕一大圈完成联接，方便了PCB的设计同时潜在地减少了信号的交叉干扰。

如：USART1： 0: 没有重映像(TX/PA9，RX/PA10)； 1: 重映像(TX/PB6，RX/PB7)。

（参考AFIO_MAPR寄存器介绍）[0,1为一寄存器的bit值]

【注】下述复用功能的引出脚具有重映射功能：

- 晶体振荡器的引脚在不接晶体时，可以作为普通I/O口

- CAN模块； - JTAG调试接口；- 大部分定时器的引出接口； - 大部分USART引出接口

- I2C1的引出接口； - SPI1的引出接口；

举例：对于STM32F103VBT6，47引脚为PB10，它的复用功能是I2C2_SCL和 USART3_TX，表示在上电之后它的默认功能为PB10，而I2C2的SCL和USART3的TX为它的复用功能；另外在TIM2的引脚重映射后，TIM2_CH3也成为这个引脚的复用功能。

(1)要使用STM32F103VBT6的47、48脚的USART3功能，则需要配置47脚为复用推挽输出或复用开漏输出，配置48脚为某种输入模式，同时使能USART3并保持I2C2的非使能状态。

(2)使用STM32F103VBT6的47脚作为TIM2_CH3，则需要对TIM2进行重映射，然后再按复用功能的方式配置对应引脚.

===================================================================================

输入输出快速切换

#define HD7279_DAT_OUT GPIOB->CRH=(GPIOB->CRH&(~(0x0000000F<<20)))|0x00000003<<20 //推挽输出

#define HD7279_DAT_IN GPIOB->CRH=(GPIOB->CRH&(~(0x0000000F<<20)))|0x00000004<<20 //浮空输入

=========================================华丽的分割线==========================================

看来下GD提供的驱动库，里面的GPIO操作都是函数：

void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitPara* GPIO_InitParaStruct)
{
uint32_t pin = 0x00;

for (pin = 0x00; pin < 0x10; pin++)
{
      if(((GPIO_InitParaStruct->GPIO_Pin) & (((uint32_t)0x01) << pin))!=0)
      {
         if ((GPIO_InitParaStruct->GPIO_Mode == GPIO_MODE_OUT) || (GPIO_InitParaStruct->GPIO_Mode == GPIO_MODE_AF))
         {
            /* Speed configuration */
            GPIOx->OSPD &= ~(GPIO_OSPD_OSPD0 << (pin * 2));
            GPIOx->OSPD |= ((uint32_t)(GPIO_InitParaStruct->GPIO_Speed) << (pin * 2));

            /* Output type configuration */
            GPIOx->OMODE &= ~((GPIO_OMODE_OM0) << ((uint16_t)pin));
            GPIOx->OMODE |= (uint16_t)(((uint16_t)GPIO_InitParaStruct->GPIO_OType) << ((uint16_t)pin));
         }

         /* Pull-up Pull-down configuration */
         GPIOx->PUPD &= ~(GPIO_PUPD_PUPD0 << ((uint16_t)pin * 2));
         GPIOx->PUPD |= (((uint32_t)GPIO_InitParaStruct->GPIO_PuPd) << (pin * 2));

         /* GPIO mode configuration */
         GPIOx->CTLR  &= ~(GPIO_CTLR_CTLR0 << (pin * 2));
         GPIOx->CTLR |= (((uint32_t)GPIO_InitParaStruct->GPIO_Mode) << (pin * 2));
      }
}
}

uint8_t GPIO_ReadOutputBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
if ((GPIOx->DOR & GPIO_Pin) != (uint32_t)Bit_RESET)
{
      return (uint8_t)Bit_SET;
}
else
{
      return (uint8_t)Bit_RESET;
}
}

void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
GPIOx->BOR = GPIO_Pin;
}

类似这些函数，如果仅仅是读取一个IO值，都要去入栈和出栈，显然有些多余，于是我进行了如下改造：

/* 宏定义-------------------------------------------------------------------*/
#define NOP()                                  __asm("NOP")

#define USER_GPIO_SETBITS_OUT(GPIOx,GPIO_Pin)          do{                                                             \
                                                         GPIOx->CTLR  &= ~(GPIO_CTLR_CTLR0 << (GPIO_Pin));          \
                                                         GPIOx->CTLR  |= (((uint32_t)GPIO_MODE_OUT) << (GPIO_Pin));\
                                                      }while(0)

#define USER_GPIO_SETBITS_IN(GPIOx,GPIO_Pin)          do{                                                          \
                                                         GPIOx->CTLR  &= ~(GPIO_CTLR_CTLR0 << (GPIO_Pin));       \
                                                         GPIOx->CTLR  |= (((uint32_t)GPIO_MODE_IN) << (GPIO_Pin)); \
                                                      }while(0)

#define USER_GPIO_READ_INPUTBIT(GPIOx,GPIO_Pin)             ((GPIOx->DIR & GPIO_Pin) != (uint32_t)Bit_RESET)
#define USER_GPIO_READ_OUTPUTBIT(GPIOx,GPIO_Pin)       ((GPIOx->DOR & GPIO_Pin) != (uint32_t)Bit_RESET)
#define USER_GPIO_SETBITS(GPIOx,GPIO_Pin)             (GPIOx->BOR = GPIO_Pin)
#define USER_GPIO_RESETBITS(GPIOx,GPIO_Pin)          (GPIOx->BCR = GPIO_Pin)

这样用起来就清爽了许多。

但是我还是不习惯，因为输出是这样的：

#define USER_GPIO_OUT(GPIOx,GPIO_Pin,__VALUE)          do{                                                          \
                                                         if(__VALUE){                                              \
                                                            USER_GPIO_SETBITS(GPIOx,GPIO_Pin);                   \
                                                         }else{                                                    \
                                                            USER_GPIO_RESETBITS(GPIOx,GPIO_Pin);                   \
                                                         }                                                          \
                                                      }while(0)

于是我进行了如下改造，首先定义一个匿名结构体：
struct Uint16_bit
{
uint16_t bit0:1;
uint16_t bit1:1;
uint16_t bit2:1;
uint16_t bit3:1;
uint16_t bit4:1;
uint16_t bit5:1;
uint16_t bit6:1;
uint16_t bit7:1;
uint16_t bit8:1;
uint16_t bit9:1;
uint16_t bit10:1;
uint16_t bit11:1;
uint16_t bit12:1;
uint16_t bit13:1;
uint16_t bit14:1;
uint16_t bit15:1;
};

#if defined(__CC_ARM)
union Commonwealth_16
{
      struct
      {
         uint16_t bit0:1;
         uint16_t bit1:1;
         uint16_t bit2:1;
         uint16_t bit3:1;
         uint16_t bit4:1;
         uint16_t bit5:1;
         uint16_t bit6:1;
         uint16_t bit7:1;
         uint16_t bit8:1;
         uint16_t bit9:1;
         uint16_t bit10:1;
         uint16_t bit11:1;
         uint16_t bit12:1;
         uint16_t bit13:1;
         uint16_t bit14:1;
         uint16_t bit15:1;
      };
      struct Uint16_bit tData_Uint16_bit;
      uint16_t             hwAll;
};
#else
union Commonwealth_16
{
      struct Uint16_bit tData_Uint16_bit;
      uint16_t             hwAll;
};
#endif

然后定义变量：
/************************************  IO定义区  ********************************/
#define GPIOA_OUT_PUT_ADDR       (GPIOA_BASE+0x14)
#pragma anon_unions
__IO union Commonwealth_16    tGPIOAOutPutBits    __attribute__((at(GPIOA_OUT_PUT_ADDR)));

#define GPIOA_IN_PUT_ADDR          (GPIOA_BASE+0x10)
#pragma anon_unions
__IO union Commonwealth_16    tGPIOAInPutBits       __attribute__((at(GPIOA_IN_PUT_ADDR)));

#define GPIOB_OUT_PUT_ADDR       (GPIOB_BASE+0x14)
#pragma anon_unions
__IO union Commonwealth_16    tGPIOBOutPutBits    __attribute__((at(GPIOB_OUT_PUT_ADDR)));

#define GPIOB_IN_PUT_ADDR          (GPIOB_BASE+0x10)
#pragma anon_unions
__IO union Commonwealth_16    tGPIOBInPutBits       __attribute__((at(GPIOB_IN_PUT_ADDR)));

在系统头文件里声明下：
/*****************GPIO**************/
extern  __IO union Commonwealth_16    tGPIOAOutPutBits;
extern  __IO union Commonwealth_16    tGPIOAInPutBits;
extern  __IO union Commonwealth_16    tGPIOBOutPutBits;
extern  __IO union Commonwealth_16    tGPIOBInPutBits;

IO口配置好后，在自己的程序直接引用即可：
tGPIOAOutPutBits.bit7 = 0;

=========================================华丽的分割线==========================================

补充一点预编译只是：

__CC_ARM ：MDK预定于宏

__ICCARM__ ：IAR for RAM 预定义宏

__GNUC__ ：GNU编译器预定于宏

#pragma anon_unions //预编译命令，支持匿名结构体和联合体

__attribute__((at(整数)))//定义变量绝对地址，必须是立即数整数