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

出处：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进行重映射，然后再按复用功能的方式配置对应引脚。

 

 

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

 

一、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(整数)))//定义变量绝对地址，必须是立即数整数

 

<——————————————————————————————————————————————>

2019.10.02 07.32

今天用到了一个IO口控制继电器的项目，同时上位机要获得继电器的开启和关闭状态，方案有两种：

1、自己做一个标志位和继电器座状态“同步”；

2、每次获得状态，查询IO状态；

我刚开始想选用方案1，但是由于我控制的输出IO比较多，感觉方案1比较麻烦，于是我就想方案2是

否可行。

首先看手册：

PS：英文描述和中文翻译一个意思，这里就不再贴英文了。

有手册可知，当一个GPIO配置为输入时候，输出是禁止的，这个很好理解；当GPIO配置为输出时候，输入并没有说是

禁止的。

来看GPIO的框图：

有上图可知：

1、如果是读取端口输入数据寄存器(GPIOx_IDR)，那么读出是IO实际的电平；

2、如果是读取端口输出数据寄存器(GPIOx_ODR) (x=A..E)，那么读出是输出数据寄存器的值；

PS：输出数据寄存器的值不一定等于IO口实际输出值，比如IO口和低短路，你输出高电平，IO口仍然是低电平。

实际读取结果：

PS：当要获的一个输出IO口的实际电平值应读取端口输入数据寄存器(GPIOx_IDR)；

        当要获得一个输出口的输出数据寄存器值应读取端口输出数据寄存器(GPIOx_ODR) (x=A..E)；