-
【STM32笔记】HAL库中的SPI传输（可利用中断或DMA进行连续传输）
【STM32】HAL库中的SPI传输（可利用中断或DMA进行连续传输）
SPI传输
SPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola(摩托罗拉)首先在其MC68HCXX系列处理器上定义的。
SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。
SPI主从模式
SPI分为主、从两种模式，一个SPI通讯系统需要包含一个（且只能是一个）主设备，一个或多个从设备。提供时钟的为主设备（Master），接收时钟的设备为从设备（Slave），SPI接口的读写操作，都是由主设备发起。当存在多个从设备时，通过各自的片选信号进行管理。
SPI是全双工且SPI没有定义速度限制，一般的实现通常能达到甚至超过10 Mbps
SPI信号线
SPI接口一般使用四条信号线通信：
SDI（数据输入），SDO（数据输出），SCK（时钟），CS（片选）MISO： 主设备输入/从设备输出引脚。该引脚在从模式下发送数据，在主模式下接收数据。
MOSI： 主设备输出/从设备输入引脚。该引脚在主模式下发送数据，在从模式下接收数据。
SCLK：串行时钟信号，由主设备产生。
CS/SS：从设备片选信号，由主设备控制。它的功能是用来作为“片选引脚”，也就是选择指定的从设备，让主设备可以单独地与特定从设备通讯，避免数据线上的冲突。
硬件上为4根线。四线SPI可以同时发送和接收数据
另外，还有一种三线SPI，即SCLK、CS、DIO，通过DIO一条线实现MISO和MOSI的功能，三线SPI同时发送或接收
SPI协议可以一对多传输 拉低哪个CS就同哪个芯片通信
SPI工作模式
根据时钟极性（CPOL）及相位（CPHA）不同，SPI有四种工作模式。
时钟极性(CPOL)定义了时钟空闲状态电平：CPOL=0为时钟空闲时为低电平
CPOL=1为时钟空闲时为高电平
时钟相位(CPHA)定义数据的采集时间。CPHA=0:在时钟的第一个跳变沿（上升沿或下降沿）进行数据采样。
CPHA=1:在时钟的第二个跳变沿（上升沿或下降沿）进行数据采样。
SPI通信的时序
传输一个字节
如图为传输一个24位的数据 在此期间片选SYNC一直为拉低的SPI配置
这是一般情况的配置
SPI配置中设置数据长度为8bit,MSB先输出分频为64分频，则波特率为125KBits/s。其他为默认设置。
Motorla格式，CPOL设置为Low,CPHA设置为第二个边沿。不开启CRC检验，NSS为软件控制。
（CPOL=0，CPHA=1）CRC根据设备需求来
NSS片选这里选择的是软件片选（GPIO设置为输出，由GPIO控制拉高拉低） 之所以推荐这个配置 后面会详细说明
CPOL和CPHA根据芯片来定
工作模式选择全双工有主机模式全双工/半双工
从机模式全双工/半双工
只接收主机模式/只接收从机模式
只发送主机模式SPI函数
在stm32f1xx_hal_spi.h头文件中可以看到spi的操作函数。分别对应轮询，中断和DMA三种控制方式。
轮询： 最基本的发送接收函数，就是正常的发送数据和接收数据（阻塞）
中断： 在SPI发送或者接收完成的时候，会进入SPI回调函数，用户可以编写回调函数，实现设定功能（非阻塞）
DMA： DMA传输SPI数据（非阻塞）利用SPI接口发送和接收数据主要调用以下两个函数：
HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);//发送数据 HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);//接收数据- 1
- 2
SPI发送数据函数：
HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);//发送数据- 1
参数:
*hspi: 选择SPI1/2，比如&hspi1，&hspi2
*pData ： 需要发送的数据，可以为数组
Size： 发送数据的字节数，1 就是发送一个字节数据
Timeout： 超时时间，就是执行发送函数最长的时间，超过该时间自动退出发送函数
SPI接收数据函数：HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);//接收数据- 1
参数:
*hspi: 选择SPI1/2，比如&hspi1，&hspi2
*pData ： 接收发送过来的数据的数组
Size： 接收数据的字节数，1 就是接收一个字节数据
Timeout： 超时时间，就是执行接收函数最长的时间，超过该时间自动退出接收函数
SPI接收回调函数：HAL_SPI_TransmitReceive_IT(&hspi1, TXbuf,RXbuf,CommSize);- 1
当SPI上接收出现了 CommSize个字节的数据后，中断函数会调用SPI回调函数：
HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)- 1
用户可以重新定义回调函数，编写预定功能即可，在接收完成之后便会进入回调函数
另外，最常用又最方便的是：
HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size,uint32_t Timeout)- 1
此函数可以同时发送和接收
比如发送2个字节而后又接收3个字节，则Size=5（实际上发送5个字节，在发送2个字节后，开始接收3个字节）
若要发送2个字节的同时接收2个字节，则Size=2
若要发送2个字节，但在发送1个字节后接收一个字节，则Size=2在这里 发送和接收同时进行，根据需求 Size填入的值为时序的总长度
注意！！！！
这里的TX和RX不能共用一个Buf
不然就会出现发送不了字节的情况SPI连续传输
在HAL库中，SPI的传输是不连续的
若是选择硬件NSS，则每次发送一个字节后，NSS都会拉高
所以我们选择软件NSS，这样就可以在完成传输后手动拉高另外，若CPHA设置为1edge，则默认开启NSSP，在每次传输1个字节后，都会有一段空闲，设置为2或关闭NSSP则没有
如图：
若是用阻塞的方式进行传输，则每传输完两个字节后会有一个空闲，如图：
为了使每两个字节传输中不间隔（连续传输）
则使用HAL_SPI_TransmitReceive_IT或HAL_SPI_TransmitReceive_DMA（这两个函数传参完全一致，中断只适用于低速SPI，DMA全都适用）
同时在cubemx中开启中断或DMA（两者选其一就好，DMA选择普通模式，开启TX和RX）
（其实说白了 DMA也算中断的一种 DMA不经过CPU传输 发送完成以后也会进入DMA中断回调函数）
由于这两个函数为非阻塞 固在使用时要加上阻塞判断
HAL_SPI_TransmitReceive_IT(hspi,pData,buf,x+y); while(hspi->State!=HAL_SPI_STATE_READY); Set_SPI_CS(hspi,GPIO_PIN_SET);- 1
- 2
- 3
若不加 软件片选会变成这样：
SPI函数包装如下：
/*! * @brief 对SPI设备进行发送和读取 * * @param [in] hspi: SPI_HandleTypeDef 变量地址 * [in] pData: 需要发送的数据变量地址 * [in] x: 发送数据个数 * [in] y: 读取数据个数，最大为4，若大于4，则返回0 * [in] us: 拉高CS后的延时时长 * [in] sync_flag: 同步标志 * 当sync_flag为true时，发送数据和读取数据同时进行，片选始终拉低，接收的数据为发送x个数据以后接收的y个数据 * 当sync_flag为false时，发送数据和读取数据分别进行，片选分两次拉低，接收的数据为第二次片选拉低时的数据 * * @return dat: SPI读取数据返回 */ uint32_t SPI_Send_x_Read_y(SPI_HandleTypeDef *hspi, uint8_t *pData, uint8_t x,uint8_t y,uint8_t us,bool sync_flag) { Set_SPI_CS(hspi,GPIO_PIN_SET); uint8_t buf[x+y]; memset(buf,0,sizeof(buf)); uint32_t dat=0; if(y>4 || x+y==0) { return 0; } if(sync_flag) { Set_SPI_CS(hspi,GPIO_PIN_RESET); if(pData!=NULL) { HAL_SPI_TransmitReceive_IT(hspi,pData,buf,x+y); while(hspi->State!=HAL_SPI_STATE_READY); Set_SPI_CS(hspi,GPIO_PIN_SET); delay_us(us); } else { Set_SPI_CS(hspi,GPIO_PIN_SET); delay_us(us); return 0; } } else { if(pData!=NULL && x!=0) { Set_SPI_CS(hspi,GPIO_PIN_RESET); HAL_SPI_Transmit_IT(hspi,pData,x); while(hspi->State!=HAL_SPI_STATE_READY); Set_SPI_CS(hspi,GPIO_PIN_SET); delay_us(us); } Set_SPI_CS(hspi,GPIO_PIN_RESET); HAL_SPI_Receive_IT(hspi,buf,y); while(hspi->State!=HAL_SPI_STATE_READY); Set_SPI_CS(hspi,GPIO_PIN_SET); delay_us(us); x=0; } for(uint8_t i=0;i<y;i++) { dat|=buf[x+i]<<(8*(y-1-i)); } Set_SPI_CS(hspi,GPIO_PIN_SET); return dat; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
连续传输后的时序如图：
软件片选中的拉高延迟50us，是为了满足有的设备对片选拉高时长的要求 50us可以满足大多数设备了另外，传输完成的拉高也可以放在IT和DMA的回调中去，但是回调也是非阻塞的，若是两次数据间隔时间长，则可以这样使用，这样就可以压缩CS的时间。但如果两次数据间隔很短，就要按刚刚说的软件片选拉高后给延时，如果用回调的话，延时部分会被压缩，原本延时50us，可能只能延时40us，所以尽量不用这个。
void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) { Set_SPI_CS(hspi,GPIO_PIN_SET); if (hspi == (&hspi2)) { } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
高速传输下的连续传输
我通过PLL分频到Systick为50MHz
SPI时钟分频如果为4的话 就是12.5MHz
实测发现 用普通传输方式和中断传输方式 在12.5MHz及以上的时钟频率进行传输时
会出现两个字节一组传输的情况
分频为8（速率降到6.25MHz及以下）时 不会出现该情况但是 采用DMA无论低速高速均不会造成问题
所以 我建议是高速使用DMA 低速使用中断的方式来连续传输
附录：Cortex-M架构的SysTick系统定时器精准延时和MCU位带操作
SysTick系统定时器精准延时
延时函数
SysTick->LOAD中的值为计数值
计算方法为工作频率值/分频值
比如工作频率/1000 则周期为1ms以ADuCM4050为例：
#include "ADuCM4050.h" void delay_ms(unsigned int ms) { SysTick->LOAD = 26000000/1000-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能52MHz的系统定时器 while(ms--) { while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 } SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 } void delay_us(unsigned int us) { SysTick->LOAD = 26000000/1000/1000-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能52MHz的系统定时器 while(us--) { while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 } SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
其中的52000000表示芯片的系统定时器频率 32系列一般为外部定时器频率的两倍
Cortex-M架构SysTick系统定时器阻塞和非阻塞延时
阻塞延时
首先是最常用的阻塞延时
void delay_ms(unsigned int ms) { SysTick->LOAD = 50000000/1000-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 while(ms--) { while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 } SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 } void delay_us(unsigned int us) { SysTick->LOAD = 50000000/1000/1000-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 while(us--) { while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 } SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
50000000表示工作频率
分频后即可得到不同的延时时间
以此类推那么 不用两个嵌套while循环 也可以写成：
void delay_ms(unsigned int ms) { SysTick->LOAD = 50000000/1000*ms-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 } void delay_us(unsigned int us) { SysTick->LOAD = 50000000/1000/1000*us-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
但是这种写法有个弊端
那就是输入ms后，最大定时不得超过计数值，也就是不能超过LOAD的最大值，否则溢出以后，则无法正常工作而LOAD如果最大是32位 也就是4294967295
晶振为50M的话 50M的计数值为1s 4294967295计数值约为85s
固最大定时时间为85s
但用嵌套while的话 最大可以支持定时4294967295*85s
非阻塞延时
如果采用非阻塞的话 直接改写第二种方法就好了：
void delay_ms(unsigned int ms) { SysTick->LOAD = 50000000/1000*ms-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 //while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 //SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 } void delay_us(unsigned int us) { SysTick->LOAD = 50000000/1000/1000*us-1; // Count from 255 to 0 (256 cycles) 载入计数值 定时器从这个值开始计数 SysTick->VAL = 0; // Clear current value as well as count flag 清空计数值到达0后的标记 SysTick->CTRL = 5; // Enable SysTick timer with processor clock 使能26MHz的系统定时器 //while ((SysTick->CTRL & 0x00010000)==0);// Wait until count flag is set 等待 //SysTick->CTRL = 0; // Disable SysTick 关闭系统定时器 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
将等待和关闭定时器语句去掉
在使用时加上判断即可变为阻塞：delay_ms(500); while ((SysTick->CTRL & 0x00010000)==0); SysTick->CTRL = 0;- 1
- 2
- 3
在非阻塞状态下 可以提交定时器后 去做别的事情 然后再来等待
不过这样又有一个弊端 那就是定时器会自动重载 可能做别的事情以后 定时器跑过了 然后就要等85s才能停下
故可以通过内部定时器来进行非阻塞延时函数的编写
基本上每个mcu的内部定时器都可以配置自动重载等功能 网上资料很多 这里就不再阐述了
位带操作
位带代码
M3、M4架构的单片机 其输出口地址为端口地址+20 输入为+16
M0架构的单片机 其输出口地址为端口地址+12 输入为+8
以ADuCM4050为列：位带宏定义
#ifndef __GPIO_H__ #define __GPIO_H__ #include "ADuCM4050.h" #include "adi_gpio.h" #define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) #define MEM_ADDR(addr) *((volatile unsigned long *)(addr)) #define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum)) #define GPIO0_ODR_Addr (ADI_GPIO0_BASE+20) //0x40020014 #define GPIO0_IDR_Addr (ADI_GPIO0_BASE+16) //0x40020010 #define GPIO1_ODR_Addr (ADI_GPIO1_BASE+20) //0x40020054 #define GPIO1_IDR_Addr (ADI_GPIO1_BASE+16) //0x40020050 #define GPIO2_ODR_Addr (ADI_GPIO2_BASE+20) //0x40020094 #define GPIO2_IDR_Addr (ADI_GPIO2_BASE+16) //0x40020090 #define GPIO3_ODR_Addr (ADI_GPIO3_BASE+20) //0x400200D4 #define GPIO3_IDR_Addr (ADI_GPIO3_BASE+16) //0x400200D0 #define P0_O(n) BIT_ADDR(GPIO0_ODR_Addr,n) //输出 #define P0_I(n) BIT_ADDR(GPIO0_IDR_Addr,n) //输入 #define P1_O(n) BIT_ADDR(GPIO1_ODR_Addr,n) //输出 #define P1_I(n) BIT_ADDR(GPIO1_IDR_Addr,n) //输入 #define P2_O(n) BIT_ADDR(GPIO2_ODR_Addr,n) //输出 #define P2_I(n) BIT_ADDR(GPIO2_IDR_Addr,n) //输入 #define P3_O(n) BIT_ADDR(GPIO3_ODR_Addr,n) //输出 #define P3_I(n) BIT_ADDR(GPIO3_IDR_Addr,n) //输入 #define Port0 (ADI_GPIO_PORT0) #define Port1 (ADI_GPIO_PORT1) #define Port2 (ADI_GPIO_PORT2) #define Port3 (ADI_GPIO_PORT3) #define Pin0 (ADI_GPIO_PIN_0) #define Pin1 (ADI_GPIO_PIN_1) #define Pin2 (ADI_GPIO_PIN_2) #define Pin3 (ADI_GPIO_PIN_3) #define Pin4 (ADI_GPIO_PIN_4) #define Pin5 (ADI_GPIO_PIN_5) #define Pin6 (ADI_GPIO_PIN_6) #define Pin7 (ADI_GPIO_PIN_7) #define Pin8 (ADI_GPIO_PIN_8) #define Pin9 (ADI_GPIO_PIN_9) #define Pin10 (ADI_GPIO_PIN_10) #define Pin11 (ADI_GPIO_PIN_11) #define Pin12 (ADI_GPIO_PIN_12) #define Pin13 (ADI_GPIO_PIN_13) #define Pin14 (ADI_GPIO_PIN_14) #define Pin15 (ADI_GPIO_PIN_15) void GPIO_OUT(unsigned int port,unsigned int pin,unsigned int flag); void GPIO_BUS_OUT(unsigned int port,unsigned int num); void P0_BUS_O(unsigned int num); unsigned int P0_BUS_I(void); void P1_BUS_O(unsigned int num); unsigned int P1_BUS_I(void); void P2_BUS_O(unsigned int num); unsigned int P2_BUS_I(void); void P3_BUS_O(unsigned int num); unsigned int P3_BUS_I(void); #endif- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
总线函数
#include "ADuCM4050.h" #include "adi_gpio.h" #include "GPIO.h" void GPIO_OUT(unsigned int port,unsigned int pin,unsigned int flag) { switch(port) { case 0:{ switch(pin) { case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_0));};break; case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_1));};break; case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_2));};break; case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_3));};break; case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_4));};break; case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_5));};break; case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_6));};break; case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_7));};break; case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_8));};break; case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_9));};break; case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_10));};break; case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_11));};break; case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_12));};break; case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_13));};break; case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_14));};break; case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT0),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT0),(ADI_GPIO_PIN_15));};break; default:pin=0;break; } }break; case 1:{ switch(pin) { case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_0));};break; case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_1));};break; case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_2));};break; case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_3));};break; case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_4));};break; case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_5));};break; case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_6));};break; case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_7));};break; case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_8));};break; case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_9));};break; case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_10));};break; case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_11));};break; case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_12));};break; case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_13));};break; case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_14));};break; case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT1),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT1),(ADI_GPIO_PIN_15));};break; default:pin=0;break; } }break; case 2:{ switch(pin) { case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_0));};break; case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_1));};break; case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_2));};break; case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_3));};break; case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_4));};break; case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_5));};break; case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_6));};break; case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_7));};break; case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_8));};break; case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_9));};break; case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_10));};break; case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_11));};break; case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_12));};break; case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_13));};break; case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_14));};break; case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT2),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT2),(ADI_GPIO_PIN_15));};break; default:pin=0;break; } }break; case 3:{ switch(pin) { case 0:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_0));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_0));};break; case 1:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_1));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_1));};break; case 2:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_2));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_2));};break; case 3:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_3));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_3));};break; case 4:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_4));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_4));};break; case 5:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_5));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_5));};break; case 6:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_6));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_6));};break; case 7:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_7));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_7));};break; case 8:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_8));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_8));};break; case 9:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_9));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_9));};break; case 10:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_10));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_10));};break; case 11:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_11));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_11));};break; case 12:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_12));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_12));};break; case 13:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_13));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_13));};break; case 14:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_14));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_14));};break; case 15:if(flag==1){adi_gpio_SetHigh((ADI_GPIO_PORT3),(ADI_GPIO_PIN_15));}else{adi_gpio_SetLow((ADI_GPIO_PORT3),(ADI_GPIO_PIN_15));};break; default:pin=0;break; } }break; default:port=0;break; } } void GPIO_BUS_OUT(unsigned int port,unsigned int num) //num最大为0xffff { int i; for(i=0;i<16;i++) { GPIO_OUT(port,i,(num>>i)&0x0001); } } void P0_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { P0_O(i)=(num>>i)&0x0001; } } unsigned int P0_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(P0_I(i)<<i)&0xFFFF; } return num; } void P1_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { P1_O(i)=(num>>i)&0x0001; } } unsigned int P1_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(P1_I(i)<<i)&0xFFFF; } return num; } void P2_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { P2_O(i)=(num>>i)&0x0001; } } unsigned int P2_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(P2_I(i)<<i)&0xFFFF; } return num; } void P3_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { P3_O(i)=(num>>i)&0x0001; } } unsigned int P3_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(P3_I(i)<<i)&0xFFFF; } return num; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
一、位带操作理论及实践
位带操作的概念其实30年前就有了，那还是 CM3 将此能力进化，这里的位带操作是 8051 位寻址区的威力大幅加强版
位带区： 支持位带操作的地址区
位带别名： 对别名地址的访问最终作 用到位带区的访问上（注意：这中途有一个 地址映射过程）
位带操作对于硬件 I/O 密集型的底层程序最有用处
支持了位带操作后，可以使用普通的加载/存储指令来对单一的比特进行读写。在CM4中，有两个区中实现了位带。其中一个是SRAM区的最低1MB范围，第二个则是片内外设区的最低1MB范围。这两个区中的地址除了可以像普通的RAM一样使用外，它们还都有自己的“位带别名区”，位带别名区把每个比特膨胀成一个32位的字。当你通过位带别名区访问这些字时，就可以达到访问原始比特的目的。
位操作就是可以单独的对一个比特位读和写，类似与51中sbit定义的变量，stm32中通过访问位带别名区来实现位操作的功能
STM32中有两个地方实现了位带，一个是SRAM，一个是片上外设。
（1）位带本质上是一块地址区（例如每一位地址位对应一个寄存器）映射到另一片地址区（实现每一位地址位对应一个寄存器中的一位），该区域就叫做位带别名区，将每一位膨胀成一个32位的字。
（2）位带区的4个字节对应实际寄存器或内存区的一个位，虽然变大到4个字节，但实际上只有最低位有效（代表0或1）只有位带可以直接用=赋值的方式来操作寄存器 位带是把寄存器上的每一位 膨胀到32位 映射到位带区 比如0x4002 0000地址的第0个bit 映射到位带区的0地址 那么其对应的位带映射地址为0x00 - 0x04 一共32位 但只有LSB有效 采用位带的方式用=赋值时 就是把位带区对应的LSB赋值 然后MCU再转到寄存器对应的位里面 寄存器操作时 如果不改变其他位上面的值 那就只能通过&=或者|=的方式进行
要设置0x2000 0000这个字节的第二个位bit2为1,使用位带操作的步骤有：
1、将1写入位 带别名区对应的映射地址（即0x22000008,因为1bit对应4个byte）；
2、将0x2000 0000的值 读取到内部的缓冲区（这一步骤是内核完成的，属于原子操作，不需要用户操作）；
3、将bit2置1，再把值写 回到0x2000 0000(属于原子操作，不需要用户操作)。关于GPIO引脚对应的访问地址，可以参考以下公式
寄存器位带别名 = 0x42000000 + (寄存器的地址-0x40000000)32 + 引脚编号4如：端口F访问的起始地址GPIOF_BASE
#define GPIOF ((GPIO_TypeDef *)GPIOF_BASE)
但好在官方库里面都帮我们定义好了 只需要在BASE地址加上便宜即可
例如：
GPIOF的ODR寄存器的地址 = GPIOF_BASE + 0x14
寄存器位带别名 = 0x42000000 + (寄存器的地址-0x40000000)32 + 引脚编号4
设置PF9引脚的话：
uint32_t *PF9_BitBand = *(uint32_t *)(0x42000000 + ((uint32_t )&GPIOF->ODR– 0x40000000) *32 + 9*4)- 1
- 2
- 3
封装一下：
#define PFout(x) *(volatile uint32_t *)(0x42000000 + ((uint32_t )&GPIOF->ODR – 0x40000000) *32 + x*4)- 1
- 2
现在 可以把通用部分封装成一个小定义：
#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) #define MEM_ADDR(addr) *((volatile unsigned long *)(addr)) #define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum))- 1
- 2
- 3
那么 设置PF引脚的函数可以定义：
#define GPIOF_ODR_Addr (GPIOF_BASE+20) //0x40021414 #define GPIOF_IDR_Addr (GPIOF_BASE+16) //0x40021410 #define PF_O(n) BIT_ADDR(GPIOF_ODR_Addr,n) //输出 #define PF_I(n) BIT_ADDR(GPIOF_IDR_Addr,n) //输入- 1
- 2
- 3
- 4
- 5
若使PF9输入输出则：
PF_O(9)=1; //输出高电平 uint8_t dat = PF_I(9); //获取PF9引脚的值- 1
- 2
总线输入输出：
void PF_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PF_O(i)=(num>>i)&0x0001; } } unsigned int PF_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PF_I(i)<<i)&0xFFFF; } return num; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
STM32的可用下面的函数：
#ifndef __GPIO_H__ #define __GPIO_H__ #include "stm32l496xx.h" #define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) #define MEM_ADDR(addr) *((volatile unsigned long *)(addr)) #define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum)) #define GPIOA_ODR_Addr (GPIOA_BASE+20) //0x40020014 #define GPIOB_ODR_Addr (GPIOB_BASE+20) //0x40020414 #define GPIOC_ODR_Addr (GPIOC_BASE+20) //0x40020814 #define GPIOD_ODR_Addr (GPIOD_BASE+20) //0x40020C14 #define GPIOE_ODR_Addr (GPIOE_BASE+20) //0x40021014 #define GPIOF_ODR_Addr (GPIOF_BASE+20) //0x40021414 #define GPIOG_ODR_Addr (GPIOG_BASE+20) //0x40021814 #define GPIOH_ODR_Addr (GPIOH_BASE+20) //0x40021C14 #define GPIOI_ODR_Addr (GPIOI_BASE+20) //0x40022014 #define GPIOA_IDR_Addr (GPIOA_BASE+16) //0x40020010 #define GPIOB_IDR_Addr (GPIOB_BASE+16) //0x40020410 #define GPIOC_IDR_Addr (GPIOC_BASE+16) //0x40020810 #define GPIOD_IDR_Addr (GPIOD_BASE+16) //0x40020C10 #define GPIOE_IDR_Addr (GPIOE_BASE+16) //0x40021010 #define GPIOF_IDR_Addr (GPIOF_BASE+16) //0x40021410 #define GPIOG_IDR_Addr (GPIOG_BASE+16) //0x40021810 #define GPIOH_IDR_Addr (GPIOH_BASE+16) //0x40021C10 #define GPIOI_IDR_Addr (GPIOI_BASE+16) //0x40022010 #define PA_O(n) BIT_ADDR(GPIOA_ODR_Addr,n) //输出 #define PA_I(n) BIT_ADDR(GPIOA_IDR_Addr,n) //输入 #define PB_O(n) BIT_ADDR(GPIOB_ODR_Addr,n) //输出 #define PB_I(n) BIT_ADDR(GPIOB_IDR_Addr,n) //输入 #define PC_O(n) BIT_ADDR(GPIOC_ODR_Addr,n) //输出 #define PC_I(n) BIT_ADDR(GPIOC_IDR_Addr,n) //输入 #define PD_O(n) BIT_ADDR(GPIOD_ODR_Addr,n) //输出 #define PD_I(n) BIT_ADDR(GPIOD_IDR_Addr,n) //输入 #define PE_O(n) BIT_ADDR(GPIOE_ODR_Addr,n) //输出 #define PE_I(n) BIT_ADDR(GPIOE_IDR_Addr,n) //输入 #define PF_O(n) BIT_ADDR(GPIOF_ODR_Addr,n) //输出 #define PF_I(n) BIT_ADDR(GPIOF_IDR_Addr,n) //输入 #define PG_O(n) BIT_ADDR(GPIOG_ODR_Addr,n) //输出 #define PG_I(n) BIT_ADDR(GPIOG_IDR_Addr,n) //输入 #define PH_O(n) BIT_ADDR(GPIOH_ODR_Addr,n) //输出 #define PH_I(n) BIT_ADDR(GPIOH_IDR_Addr,n) //输入 #define PI_O(n) BIT_ADDR(GPIOI_ODR_Addr,n) //输出 #define PI_I(n) BIT_ADDR(GPIOI_IDR_Addr,n) //输入 void PA_BUS_O(unsigned int num); unsigned int PA_BUS_I(void); void PB_BUS_O(unsigned int num); unsigned int PB_BUS_I(void); void PC_BUS_O(unsigned int num); unsigned int PC_BUS_I(void); void PD_BUS_O(unsigned int num); unsigned int PD_BUS_I(void); void PE_BUS_O(unsigned int num); unsigned int PE_BUS_I(void); void PF_BUS_O(unsigned int num); unsigned int PF_BUS_I(void); void PG_BUS_O(unsigned int num); unsigned int PG_BUS_I(void); void PH_BUS_O(unsigned int num); unsigned int PH_BUS_I(void); void PI_BUS_O(unsigned int num); unsigned int PI_BUS_I(void); #endif- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
#include "GPIO.h" void PA_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PA_O(i)=(num>>i)&0x0001; } } unsigned int PA_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PA_I(i)<<i)&0xFFFF; } return num; } void PB_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PB_O(i)=(num>>i)&0x0001; } } unsigned int PB_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PB_I(i)<<i)&0xFFFF; } return num; } void PC_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PC_O(i)=(num>>i)&0x0001; } } unsigned int PC_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PC_I(i)<<i)&0xFFFF; } return num; } void PD_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PD_O(i)=(num>>i)&0x0001; } } unsigned int PD_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PD_I(i)<<i)&0xFFFF; } return num; } void PE_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PE_O(i)=(num>>i)&0x0001; } } unsigned int PE_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PE_I(i)<<i)&0xFFFF; } return num; } void PF_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PF_O(i)=(num>>i)&0x0001; } } unsigned int PF_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PF_I(i)<<i)&0xFFFF; } return num; } void PG_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PG_O(i)=(num>>i)&0x0001; } } unsigned int PG_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PG_I(i)<<i)&0xFFFF; } return num; } void PH_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PH_O(i)=(num>>i)&0x0001; } } unsigned int PH_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PH_I(i)<<i)&0xFFFF; } return num; } void PI_BUS_O(unsigned int num) //输入值num最大为0xFFFF { int i; for(i=0;i<16;i++) { PI_O(i)=(num>>i)&0x0001; } } unsigned int PI_BUS_I(void) //输出值num最大为0xFFFF { unsigned int num; int i; for(i=0;i<16;i++) { num=num+(PI_I(i)<<i)&0xFFFF; } return num; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
二、如何判断MCU的外设是否支持位带
根据《ARM Cortex-M3与Cortex-M4权威指南(第3版)》中第6章第7节描述
也就是说 要实现对GPIO的位带操作 必须保证GPIO位于外设区域的第一个1MB中
第一个1MB应该是0x4010 0000之前 位带不是直接操作地址 而是操作地址映射 地址映射被操作以后 MCU自动会修改对应寄存器的值位带区只有1MB 所以只能改0x4000 0000 - 0x400F FFFF的寄存器
像F4系列 GPIO的首地址为0x4002 0000 就可以用位带来更改STM32L476的GPIO就不行：
AHB2的都不能用位带
ABP 还有AHB1都可以用
但是L476的寄存器里面 GPIO和ADC都是AHB2 -
相关阅读:
【鸿蒙软件开发】文本显示（Text/Span）
微信小程序实现预约生成二维码
【考研数学】概率论与数理统计 —— 第四章 | 随机变量的数字特征
【单片机毕业设计选题24005】-基于STM32的智能家居环境监测系统
js实现鼠标拖拽改变div大小的同时另一个div宽度也变化
HTTP 网络协议请求的消息结构，具体详解（2024-04-25）
SkyWalking分布式链路追踪学习
打造高效的分布式爬虫系统：利用Scrapy框架实现
初识JAVA中的包装类，时间复杂度及空间复杂度
前端设置env配置文件yaml/json格式 在项目中读取
- 原文地址：https://blog.csdn.net/weixin_53403301/article/details/128116423