【STM32笔记】低功耗模式配置及避坑汇总-Toy模板网

这篇具有很好参考价值的文章主要介绍了【STM32笔记】低功耗模式配置及避坑汇总。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【STM32】低功耗模式配置及配置汇总

低功耗模式

自己做的低功耗库函数：
【STM32】基于HAL库建立自己的低功耗模式配置库（STM32L4系列低功耗所有配置汇总）
gitee库

文章总结：（后续更新以相关文章为准）
【STM32笔记】低功耗模式、WFI命令等进入不了休眠的可能原因（系统定时器SysTick一直产生中断）

【STM32笔记】HAL库低功耗模式配置（ADC唤醒无法使用、低功耗模式无法烧录解决方案）

【STM32笔记】低功耗模式下GPIO省电配置避坑实验（闲置引脚配置为模拟输入其实更耗电）

【STM32笔记】低功耗模式下GPIO、外设、时钟省电配置避坑

【STM32笔记】低功耗模式下的RTC唤醒（非闹钟唤醒，而是采用RTC_WAKEUPTIMER）

【STM32笔记】HAL库低功耗STOP停止模式的串口唤醒（解决进入以后立马唤醒、串口唤醒和回调无法一起使用、接收数据不全的问题）

如果串口唤醒波特率比较高则可能第一个字节接收出错可以看如下文章：
【STM32】HAL库的STOP低功耗模式UART串口唤醒BUG，第一个接收字节出错的问题（已解决）

HAL库低功耗模式配置（ADC唤醒无法使用、低功耗模式无法烧录解决方案）

一、低功耗模式简介

系统提供了多个低功耗模式，可在 CPU 不需要运行时（例如等待外部事件时）节省功耗。由用户根据应用选择具体的低功耗模式，以在低功耗、短启动时间和可用唤醒源之间寻求最佳平衡。

睡眠模式、停止模式及待机模式中，若备份域电源正常供电，备份域内的 RTC 都可以正常运行，备份域内的寄存器的数据会被保存，不受功耗模式影响。

从表中可以看到，这三种低功耗模式层层递进，运行的时钟或芯片功能越来越少，因而功耗越来越低。

模式	说明	进入方式	唤醒	对1.8V区域时钟的影响	对VDD区域时钟的影响	调压器
睡眠模式	内核停止，所有外设包括M3核心的外设，如NVIC、系统时钟(SysTick)等仍在运行	WFI、WFE命令（HAL库直接调用）	任意中断/事件	内核时钟关，对其他时钟和ADC时钟无影响	无	开
–	–	–	–	–	–
停止模式	所有的时钟都已停止	配置PWR_CR寄存器的PDDS+LPDS位+SLEEPDEEP位+WFI或WFE命令	任意外部中断EXTI(在外部中断寄存器中设置)	关闭所有1.8V区域的时钟	HSI和HSE的振荡器关闭	开启或处于低功耗模式(依据电源控制寄存器的设定)
–	–	–	–	–	–
待机模式	1.8V电源关闭	配置PWR_CR寄存器的PDDS+SLEEPDEEP位+WFI或WFE命令	WKUP、引脚的RTC闹钟事件、NRST引脚上的外部复位、IWDG复位	关闭所有1.8V区域的时钟	HSI和HSE的振荡器关闭	关
–	–	–	–	–	–

L4及L4+的通用模式状态表可见手册
【STM32笔记】低功耗模式配置及避坑汇总

blog.csdn.net/weixin_53403301/article/details/129031935
【STM32笔记】低功耗模式下的RTC唤醒（非闹钟唤醒，而是采用RTC_WAKEUPTIMER）

blog.csdn.net/weixin_53403301/article/details/129055530
【STM32笔记】低功耗模式下GPIO省电配置避坑实验（闲置引脚配置为模拟输入其实更耗电）

blog.csdn.net/weixin_53403301/article/details/129060093
【STM32笔记】低功耗模式下GPIO、外设省电配置避坑

1.1 睡眠模式

在睡眠模式中，仅关闭了内核时钟，内核停止运行，但其片上外设，CM3 核心的外设全都还照常运行。有两种方式进入睡眠模式，它的进入方式决定了从睡眠唤醒的方式，分别是 WFI(wait for interrupt) 和 WFE(wait for event)，即由等待“中断”唤醒和由“事件”唤醒。

特性和说明：

立即睡眠： 在执行 WFI 或 WFE 指令时立即进入睡眠模式。
退出时睡眠： 在退出优先级最低的中断服务程序后才进入睡眠模式。
进入方式： 内核寄存器的 SLEEPDEEP=0 ，然后调用 WFI 或 WFE 指令即可进入睡眠模式；SLEEPONEXIT=1 时，进入“退出时睡眠”模式。
唤醒方式： 如果是使用 WFI 指令睡眠的，则可使用任意中断唤醒；如果是使用 WFE 指令睡眠的，则由事件唤醒。
睡眠时： 关闭内核时钟，内核停止，而外设正常运行，在软件上表现为不再执行新的代码。这个状态会保留睡眠前的内核寄存器、内存的数据。
唤醒延迟： 无延迟。
唤醒后： 若由中断唤醒，先进入中断，退出中断服务程序后，接着执行 WFI 指令后的程序；若由事件唤醒，直接接着执行 WFE 后的程序。

唤醒后即可开始行动继续程序无需配置任何寄存器

睡眠模式和低功耗睡眠模式是两个模式由PWR_MAINREGULATOR_ON和PWR_LOWPOWERREGULATOR_ON两个变量确定

要进入低功耗睡眠模式首先得进入低功耗运行模式
HAL_PWREx_EableLowPowerRunMode（）
且工作频率降低到2MHz以下

唤醒时睡眠模式直接唤醒

而低功耗睡眠模式唤醒后会进入到低功耗运行模式若想正常工作需用HAL_PWREx_DisableLowPowerRunMode（）退出

1.2 停止模式

在停止模式中，进一步关闭了其它所有的时钟，于是所有的外设都停止了工作，但由于其 1.8V 区域的部分电源没有关闭，还保留了内核的寄存器、内存的信息，所以从停止模式唤醒，并重新开启时钟后，还可以从上次停止处继续执行代码。停止模式可以由任意一个外部中断(EXTI)唤醒，在停止模式中可以选择电压调节器为开模式或低功耗模式。

特性和说明：

调压器低功耗模式： 在停止模式下调压器可工作在正常模式或低功耗模式，可进一步降低功耗。
进入方式： 内核寄存器的 SLEEPDEEP=1，PWR_CR 寄存器中的 PDDS=0，然后调用 WFI 或 WFE 指令即可进入停止模式；PWR_CR 寄存器的 LPDS=0 时，调压器工作在正常模式，LPDS=1 时工作在低功耗模式。
唤醒方式： 如果是使用 WFI 指令睡眠的，可使用任意 EXTI 线的中断唤醒；如果是使用 WFE 指令睡眠的，可使用任意配置为事件模式的 EXTI 线事件唤醒。
停止时： 内核停止，片上外设也停止。这个状态会保留停止前的内核寄存器、内存的数据。
唤醒延迟： 基础延迟为 HSI 振荡器的启动时间，若调压器工作在低功耗模式，还需要加上调压器从低功耗切换至正常模式下的时间。
唤醒后： 若由中断唤醒，先进入中断，退出中断服务程序后，接着执行 WFI 指令后的程序；若由事件唤醒，直接接着执行 WFE 后的程序。唤醒后，STM32 会使用 HSI 作为系统时钟。

只能由外部中断唤醒唤醒后需要重新使能时钟（SystemClock_Config();）
建议将一条外部中断线专门作为唤醒中断，执行中断后进入回调进行时钟使能

停止模式0和1由PWR_MAINREGULATOR_ON和PWR_LOWPOWERREGULATOR_ON两个变量确定

停止模式0和1可以被串口 I2C等设备唤醒（具体看手册）

停止模式2则在pwr_ex.c中进入

停止模式2 只能被特定器件（如LPUART等在内部与EXTI有链接的器件）唤醒

详情见后续关于STOP模式串口唤醒的文章

blog.csdn.net/weixin_53403301/article/details/129014963
【STM32笔记】HAL库低功耗STOP停止模式的串口唤醒（解决串口唤醒和回调无法一起使用的问题）

1.3 待机模式

翻译成shutdown更为合适
待机模式，它除了关闭所有的时钟，还把 1.8V 区域的电源也完全关闭了，也就是说，从待机模式唤醒后，由于没有之前代码的运行记录，只能对芯片复位，重新检测 boot 条件，从头开始执行程序。它有四种唤醒方式，分别是 WKUP(PA0)引脚的上升沿，RTC 闹钟事件，NRST 引脚的复位和 IWDG(独立看门狗)复位。

特性和说明：

进入方式： 内核寄存器的 SLEEPDEEP=1，PWR_CR 寄存器中的 PDDS=1，PWR_CR 寄存器中的唤醒状态位 WUF=0，然后调用 WFI 或 WFE 指令即可进入待机模式。
唤醒方式： 通过 WKUP ，RTC 闹钟、唤醒、入侵、时间戳事件或 NRST 引脚外部复位及 IWDG 复位唤醒。
待机时： 内核停止，片上外设也停止；内核寄存器、内存的数据会丢失；除复位引脚、RTC_AF1 引脚及 WKUP 引脚，其它 I/O 口均工作在高阻态。
唤醒延迟： 芯片复位的时间。
唤醒后： 相当于芯片复位，在程序表现为从头开始执行代码。

代码实操

SYS配置：
【STM32笔记】低功耗模式配置及避坑汇总
选择Serial Wire模式可以在某些情况下进行调试如（SWD）

配置外部中断就不说了

进入低功耗模式的函数

引脚指定只对待机模式有效
HAL_PWR_EnableWakeUpPin(WakeUpPinPolarity);
该函数指定的引脚不受引脚其他的配置影响（比如已经被配成了复用）

__HAL_RCC_PWR_CLK_ENABLE(); 可要可不要

/*!
 * @brief       	进入低功耗模式   	
 *
 * @param 	[in]	mode_flag: 模式标志
 * 								0/大于4 不进入任何模式，1 进入睡眠，2 进入停止，3 进入待机，4 关机
 *  				[in]	WakeUpPinPolarity: 待机模式下WKUP唤醒引脚极性配置，其他模式无用
 *
 * @return				None
 */
void Enter_Low_PWR(uint8_t mode_flag,uint32_t WakeUpPinPolarity)
{
	__HAL_RCC_PWR_CLK_ENABLE();
	switch(mode_flag)
	{
		case 0:
		{
			printf("[INFO] 不进入低功耗模式\n");
			break;
		}
		case 1:
		{
			printf("[INFO] 进入睡眠模式\n");
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);	
			HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON,PWR_SLEEPENTRY_WFI);
			break;
		}
		case 2:
		{
			printf("[INFO] 进入停止模式\n");
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON,PWR_SLEEPENTRY_WFI);
			break;
		}
		case 3:
		{
			printf("[INFO] 三秒后进入待机模式\n");
			delay_ms(3000);
			printf("[INFO] 进入待机模式\n");
			HAL_PWR_EnableWakeUpPin(WakeUpPinPolarity);
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWR_EnterSTANDBYMode();
			break;
		}
		case 4:
		{
			printf("[INFO] 三秒后进入关机模式\n");
			delay_ms(3000);
			printf("[INFO] 进入关机模式\n");
			HAL_PWR_EnableWakeUpPin(WakeUpPinPolarity);
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWREx_EnterSHUTDOWNMode();
			break;
		}
		default:
		{
			printf("[INFO] 不进入低功耗模式\n");
			break;
		}
	}
}

外部中断回调（只对STOP模式有效果 SLEEP模式可以省略）：

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	switch(GPIO_Pin)
	{
		case WAKE_UP_Pin:
		{
			__HAL_RCC_PWR_CLK_ENABLE();
			SystemClock_Config();
		}
		default:
		{			
			break;
		}
	}
	__HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);
}

ADC唤醒无法使用的解决方案

从STOP模式唤醒会导致L4系列等MCU的ADC无法使用
原因就是PLLSAI时钟被关闭了就算从头开始初始化也没用
所以只需要更换时钟源即可
【STM32笔记】低功耗模式配置及避坑汇总

低功耗模式无法烧录解决方案

在进入到待机模式后相当于强行死机了无法进行烧录只能手动复位后烧录
但在调试时将进入待机模式的函数放得太前则完全无法烧录这时候就需要从硬件方面解决

把烧写程序用的软件复位NREST引脚与硬件复位短接那么在烧写时复位引脚就会被拉低这样的话就算是shutdown模式也能正常烧写程序就不用像之前那样一直按复位卡时间点了

省电优化

在CubeMX里面有一项设置，就是把没有用到的引脚全部设置为省电（模拟输入）这样可以更省电
【STM32笔记】低功耗模式配置及避坑汇总

HAL库低功耗STOP停止模式的串口唤醒（解决进入以后立马唤醒、串口唤醒和回调无法一起使用的问题）

低功耗模式如图所示

停止模式有三种分别是0 1 2
其中 0 1可以由串口唤醒
2只能由LPUART唤醒
【STM32笔记】低功耗模式配置及避坑汇总

在手册里可以查到

进入也很简单：

/*!
 * @brief       	进入低功耗模式   	
 *
 * @param 	[in]	mode_flag: 模式标志
 * 								0/大于4 不进入任何模式，1 进入睡眠，2 进入停止，3 进入待机，4 关机
 *  				[in]	WakeUpPinPolarity: 待机模式下WKUP唤醒引脚极性配置，其他模式无用
 *
 * @return				None
 */
void Enter_Low_PWR(uint8_t mode_flag,uint32_t WakeUpPinPolarity)
{	
	__HAL_RCC_PWR_CLK_ENABLE();
	switch(mode_flag)
	{
		case 0:
		{
			printf("[INFO] 不进入低功耗模式\n");
			break;
		}
		case 1:
		{
			printf("[INFO] 进入睡眠模式\n");
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);	
			HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON,PWR_SLEEPENTRY_WFI);
			break;
		}
		case 2:
		{
			printf("[INFO] 进入停止模式\n");
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON,PWR_SLEEPENTRY_WFI);
			break;
		}
		case 3:
		{
			printf("[INFO] 三秒后进入待机模式\n");
			delay_ms(3000);
			printf("[INFO] 进入待机模式\n");
			HAL_PWR_EnableWakeUpPin(WakeUpPinPolarity);
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWR_EnterSTANDBYMode();
			break;
		}
		case 4:
		{
			printf("[INFO] 三秒后进入关机模式\n");
			delay_ms(3000);
			printf("[INFO] 进入关机模式\n");
			HAL_PWR_EnableWakeUpPin(WakeUpPinPolarity);
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWREx_EnterSHUTDOWNMode();
			break;
		}
		default:
		{
			printf("[INFO] 不进入低功耗模式\n");
			break;
		}
	}
}

要进入停止2模式则需要在pwr_ex.c中配置
HAL_PWREx_EnterSTOP2Mode();函数

其中
HAL_PWR_EnterSTOPMode中的PWR_MAINREGULATOR_ON、PWR_LOWPOWERREGULATOR_ON分别是开启稳压器和关闭稳压器分别对应STOP 0和1

特性和说明：

调压器低功耗模式： 在停止模式下调压器可工作在正常模式或低功耗模式，可进一步降低功耗。
进入方式： 内核寄存器的 SLEEPDEEP=1，PWR_CR 寄存器中的 PDDS=0，然后调用 WFI 或 WFE 指令即可进入停止模式；PWR_CR 寄存器的 LPDS=0 时，调压器工作在正常模式，LPDS=1 时工作在低功耗模式。
唤醒方式： 如果是使用 WFI 指令睡眠的，可使用任意 EXTI 线的中断唤醒；如果是使用 WFE 指令睡眠的，可使用任意配置为事件模式的 EXTI 线事件唤醒。
停止时： 内核停止，片上外设也停止。这个状态会保留停止前的内核寄存器、内存的数据。
唤醒延迟： 基础延迟为 HSI 振荡器的启动时间，若调压器工作在低功耗模式，还需要加上调压器从低功耗切换至正常模式下的时间。
唤醒后： 若由中断唤醒，先进入中断，退出中断服务程序后，接着执行 WFI 指令后的程序；若由事件唤醒，直接接着执行 WFE 后的程序。唤醒后，STM32 会使用 HSI 作为系统时钟。

只能由外部中断唤醒唤醒后需要重新使能时钟（SystemClock_Config();）
建议将一条外部中断线专门作为唤醒中断，执行中断后进入回调进行时钟使能

停止模式0和1由PWR_MAINREGULATOR_ON和PWR_LOWPOWERREGULATOR_ON两个变量确定

停止模式0和1可以被串口 I2C等设备唤醒（具体看手册）

停止模式2则在pwr_ex.c中进入

停止模式2 只能被特定器件（如LPUART等在内部与EXTI有链接的器件）唤醒

若要配置UART唤醒则需要：

/*!
 * @brief       	配置串口在停止模式下的唤醒   	
 *
 * @param 	[in]	huart: UART_HandleTypeDef类型的器件
 *					[in]	EnableNotDisable: 使能或者关闭
 *
 * @return				None
 */
void Ctrl_UART_StopMode_WakeUp(UART_HandleTypeDef *huart,bool EnableNotDisable)
{	
	if(EnableNotDisable)
	{
		__HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI);	//保留唤醒用的HSI线 串口初始化时钟也必须要配置为HSI
	
		UART_WakeUpTypeDef UART_WakeUpStruct={0};
		UART_WakeUpStruct.WakeUpEvent=UART_WAKEUP_ON_READDATA_NONEMPTY;  //接收数据不为空时唤醒
		HAL_UARTEx_StopModeWakeUpSourceConfig(huart,UART_WakeUpStruct);
	
		__HAL_UART_ENABLE_IT(huart,UART_IT_WUF);	//开启唤醒中断
		HAL_UARTEx_EnableClockStopMode(huart);
		HAL_UARTEx_EnableStopMode(huart);		//开启模式
	}
	else
	{
		__HAL_UART_DISABLE_IT(huart,UART_IT_WUF);	//关闭唤醒中断
		HAL_UARTEx_DisableClockStopMode(huart);
		HAL_UARTEx_DisableStopMode(huart);		//关闭模式
	}
}

配置为接收数据就唤醒

若要使用则UART必须为HSI或MSI时钟配置太麻烦所以我建议直接在HAL里面配置
【STM32笔记】低功耗模式配置及避坑汇总
串口回调一般是：

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart==&huart2)
  {		
		HAL_UART_Transmit(&huart2,&RxBuffer,1,0xFFFF);
		HAL_UART_Receive_IT(&huart2,&RxBuffer,1);
  }
	if(huart==&huart4)
  {		
		HAL_UART_Transmit(&huart4,&RxBuffer,1,0xFFFF);
		HAL_UART_Receive_IT(&huart4,&RxBuffer,1);
  }
}

接收数据后发送数据
而唤醒回调则是：

void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart)
{
	if(huart==&huart2)
  {		
		__HAL_RCC_PWR_CLK_ENABLE();
		SystemClock_Config();		
		Ctrl_UART_StopMode_WakeUp(huart,false);
  }
}

停止模式的官方文档的说明

官方文档提到在进行HSI时钟作为唤醒时钟时有两种可行性方案第一次在调试时我没看见直到首字节出错才发现这个问题后面找到了该文档
【STM32笔记】低功耗模式配置及避坑汇总
上文中的函数：

__HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI);

只是将以下寄存器置位
配置的是唤醒时的时钟以及CSS备份时钟只开启这个寄存器虽然能唤醒但首字节会丢失
原因是串口唤醒需要时间这个寄存器只管唤醒后用的是什么时钟而停止模式下没有这个时钟
位于RCC_CFGR寄存器
【STM32笔记】低功耗模式配置及避坑汇总
而用到STOP模式下HSI能强制工作的寄存器在这：
位于RCC_CR寄存器

其实这里如果配置了就没事了但是我下文用到的是第二种方法（我也更推荐该方法因为第二种方法的寄存器位于外设下而不是RCC下随便乱动RCC可能会有其他BUG）

进入以后立马唤醒

若是串口悬空或硬件设计问题串口数据不定则可能进入以后立马被唤醒
【STM32笔记】低功耗模式配置及避坑汇总
在外部硬件上加下拉或者软件配置下拉（或上拉）即可不过下拉更省电

串口唤醒和回调无法一起使用的问题

在调试时发现串口唤醒和回调无法一起使用进入了回调以后就退出了不会进入串口唤醒

其实就是

__HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI);	//保留唤醒用的HSI线 串口初始化时钟也必须要配置为HSI

的问题

若不使用这个语句虽然串口可以用也能接收数据并返回但是进不了唤醒回调

其实就是因为时序被改变了

进入低功耗以后接收数据唤醒则先进入接收回调然后发一次数据但不会进行唤醒因为时序有问题 mcu认为接收的数据不正常

保留这个语句以后就好了

另外每次进入低功耗前都要先调用

Ctrl_UART_StopMode_WakeUp(huart,true);

语句否则无法正常唤醒也不能再次进入低功耗模式

为了避免出错每次唤醒以后都应该清空调唤醒中断

STOP模式会关闭时钟所以建议是回调以后就初始化时钟一次

Ctrl_UART_StopMode_WakeUp(&huart2,true);
Enter_Low_PWR(2,0);

LPUART的配置同理完全一模一样的语句

首字节接收出错的问题

低功耗模式下的RTC唤醒（非闹钟唤醒，而是采用RTC_WAKEUPTIMER）

低功耗模式如图所示

停止模式有三种分别是0 1 2
其中 0 1可以由串口唤醒
2只能由LPUART唤醒
【STM32笔记】低功耗模式配置及避坑汇总

在手册里可以查到

进入也很简单：

/*!
 * @brief       	进入低功耗模式   	
 *
 * @param 	[in]	mode_flag: 模式标志
 * 								0/大于4 不进入任何模式，1 进入睡眠，2 进入停止，3 进入待机，4 关机
 *  				[in]	WakeUpPinPolarity: 待机模式下WKUP唤醒引脚极性配置，其他模式无用
 *
 * @return				None
 */
void Enter_Low_PWR(uint8_t mode_flag,uint32_t WakeUpPinPolarity)
{	
	__HAL_RCC_PWR_CLK_ENABLE();
	switch(mode_flag)
	{
		case 0:
		{
			printf("[INFO] 不进入低功耗模式\n");
			break;
		}
		case 1:
		{
			printf("[INFO] 进入睡眠模式\n");
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);	
			HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON,PWR_SLEEPENTRY_WFI);
			break;
		}
		case 2:
		{
			printf("[INFO] 进入停止模式\n");
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON,PWR_SLEEPENTRY_WFI);
			break;
		}
		case 3:
		{
			printf("[INFO] 三秒后进入待机模式\n");
			delay_ms(3000);
			printf("[INFO] 进入待机模式\n");
			HAL_PWR_EnableWakeUpPin(WakeUpPinPolarity);
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWR_EnterSTANDBYMode();
			break;
		}
		case 4:
		{
			printf("[INFO] 三秒后进入关机模式\n");
			delay_ms(3000);
			printf("[INFO] 进入关机模式\n");
			HAL_PWR_EnableWakeUpPin(WakeUpPinPolarity);
			delay_ms(10);  //消抖
			__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
			HAL_PWREx_EnterSHUTDOWNMode();
			break;
		}
		default:
		{
			printf("[INFO] 不进入低功耗模式\n");
			break;
		}
	}
}

要进入停止2模式则需要在pwr_ex.c中配置
HAL_PWREx_EnterSTOP2Mode();函数

其中
HAL_PWR_EnterSTOPMode中的PWR_MAINREGULATOR_ON、PWR_LOWPOWERREGULATOR_ON分别是开启稳压器和关闭稳压器分别对应STOP 0和1

所有的模式都可以用RTC唤醒
【STM32笔记】低功耗模式配置及避坑汇总

可以在手册里面找到外部中断线所以RTC可以唤醒任一模式

RTC开启Internal WakeUp

General配置中 CK_APRE和CK_SPRE这两个值也是用来配置RTC定时器计时的分频的（与唤醒无关）
公示如下：
【STM32笔记】低功耗模式配置及避坑汇总
配置这里预分配寄存器也可以使时钟变成1MHz

如果用的是内部RC（32K）则配置为124和255
如果用的是外部晶振（32.768K）则配置为127和255

在Wake Up配置中完全不用设置（后面的语句可以直接配）
另外开启唤醒中断
【STM32笔记】低功耗模式配置及避坑汇总
在进入低功耗前需要先调用RTC唤醒中断配置

HAL_RTCEx_SetWakeUpTimer_IT(&hrtc,counter,clock);

同样退出时要在注册的回调里面关闭中断

void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
{
	__HAL_RCC_PWR_CLK_ENABLE();
	SystemClock_Config();
	__HAL_RTC_WAKEUPTIMER_EXTI_DISABLE_IT();	
}

打包一下就是：

/*!
 * @brief       	配置RTC在低功耗模式下的唤醒   	
 *
 * @param 	[in]	counter: 计数值
 *					[in]	clock: 时钟值
 *					[in]	EnableNotDisable: 使能或者关闭
 *
 * @return				None
 */
void Ctrl_RTC_WakeUp(uint32_t counter,uint32_t clock,bool EnableNotDisable)
{	
	if(EnableNotDisable)
	{
		HAL_RTCEx_SetWakeUpTimer_IT(&hrtc,counter,clock);
	}
	else
	{
		__HAL_RTC_WAKEUPTIMER_EXTI_DISABLE_IT();	
	}
}

调用：

	Ctrl_UART_StopMode_WakeUp(&huart2,true);
	Ctrl_RTC_WakeUp(2000,RTC_WAKEUPCLOCK_RTCCLK_DIV16,true);
	Enter_Low_PWR(2,0);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		printf("[INFO] ADC: %f\n",Get_Real_ADC_Value(&hadc2));
		Count_ADXL345();
		Count_TMP75();
		TIM_Delay_ms(1000,&htim6);
		Ctrl_UART_StopMode_WakeUp(&huart2,true);
		Ctrl_RTC_WakeUp(2000,RTC_WAKEUPCLOCK_RTCCLK_DIV16,true);
		Enter_Low_PWR(2,0);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }

低功耗模式下GPIO、外设、时钟省电配置避坑

省电外设配置

在进入低功耗模式前可以通过降低时钟频率关闭GPIO口（通常是配置为模拟输入或降低GPIO时钟）以及关闭不需要的外设来降低功耗（尤其是在SLEEP、STOP模式）

时钟的话如果用不上或者进入STOP等模式则也不需要配置进入模式时时钟本身就会被配置

关闭外设的函数在进入低功耗的前一步执行相关唤醒配置需要在关闭外设前执行且要注意不能关闭用于唤醒的外设及其GPIO口

而用不到的外设和对应的GPIO口建议同时关闭

以我的为例：

/*!
 * @brief       	所有外设初始化配置，根据使用需求来写
 *
 * @param 	[in]	EnableNotDisable: 使能或者关闭
 *								true: 进行初始化外设（不包含时钟初始化）
 *								false: 或者关闭所有外设，所有GPIO配置为无上拉下拉且模拟输入，仅保留系统时钟和系统所需的GPIO口复用
 *								该函数在进入低功耗前调用（false）
 *								建议在进入该函数前（false）先配置用于唤醒的外设 如指定UART或RTC作为唤醒使用 然后再调用该函数 且不能关闭有唤醒功能的外设
 *								若用于唤醒后的初始化，则建议先初始化时钟，再执行该函数的初始化（true）
 *								在休眠期间使用的外设，不要关闭，也不要关闭GPIO等；相反，外设和GPIO等建议同时关闭（避免出现bug，并且也省电）
 *								未关闭，但唤醒时重复初始化外设并不受影响
 *								若未关闭的外设在运行中改变了初始化值，则建议不在唤醒时运行该初始化（前提是外设的GPIO等也没有作改动）
 *								若需要在初始化后更改初始化值，则建议要么不进行初始化且不关闭（也包括GPIO等），或重新设置新值
 *
 * @return				None
 */
void PWR_Device_Init(bool EnableNotDisable)
{
	if(EnableNotDisable)
	{
		//这里是系统最初的初始化值
		GPIO_Reset_Init(false);  //重置GPIO		
		MX_GPIO_Init();
		MX_USART2_UART_Init();
		MX_UART4_Init();
		MX_ADC1_Init();
		MX_ADC2_Init();
		MX_TIM6_Init();
		MX_RTC_Init();
		MX_ADC3_Init();
		
		//这里放初始化后还要更改的配置，若要重新初始化，建议先运行外设DeInit
//		HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8,GPIO_PIN_SET);
//		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4,GPIO_PIN_SET);
	}
	else
	{
		HAL_ADC_DeInit(&hadc1);
		HAL_ADC_DeInit(&hadc2);
		HAL_ADC_DeInit(&hadc3);
//		HAL_UART_DeInit(&huart2);		//唤醒用的串口 最好不要关闭：若不用于唤醒 则可以关闭 GPIO等同步关闭；若用于唤醒 则不能关闭 GPIO等也不能关闭
		HAL_UART_DeInit(&huart4);
		HAL_TIM_Base_DeInit(&htim6);
//		HAL_RTC_DeInit(&hrtc);		//唤醒用的RTC 最好不要关闭		

		GPIO_Reset_Init(true);  //GPIO配置为复用
	}
}

true: 进行初始化外设（不包含时钟初始化）
false: 或者关闭所有外设，所有GPIO配置为无上拉下拉且模拟输入，仅保留系统时钟和系统所需的GPIO口复用
该函数在进入低功耗前调用（false）
建议在进入该函数前（false）先配置用于唤醒的外设如指定UART或RTC作为唤醒使用然后再调用该函数且不能关闭有唤醒功能的外设
若用于唤醒后的初始化，则建议先初始化时钟，再执行该函数的初始化（true）
在休眠期间使用的外设，不要关闭，也不要关闭GPIO等；相反，外设和GPIO等建议同时关闭（避免出现bug，并且也省电）
未关闭，但唤醒时重复初始化外设并不受影响
若未关闭的外设在运行中改变了初始化值，则建议不在唤醒时运行该初始化（前提是外设的GPIO等也没有作改动）
若需要在初始化后更改初始化值，则建议要么不进行初始化且不关闭（也包括GPIO等），或重新设置新值

GPIO配置也是个坑
（相关配置及唤醒功能等见前文）

/*!
 * @brief       	重置GPIO（都会进行），或再将除外部高低速晶振复用、SWCLK、SWDIO复用的所有GPIO配置为模拟输入（false）
 *								注意：用于串口唤醒等的引脚，不可配置为模拟输入，也不可关闭
 *								在进行GPIO初始化前，先将GPIO_DeInit，但是不做也不影响，不过还是建议跑一下
 *								以优先级顺序来看：
 *								如果这一组GPIO都没用到过 那么直接不开启时钟就最省电
 *								如果这一组GPIO有引脚用过了 时钟不能关 那么就将用过的引脚配置为模拟输入
 *								切记！！！：
 *								不要将没用过的引脚配置为模拟输入 耗电量其实会稍微增加一点！
 *								不要将没用过的GPIO时钟打开以后再配置为模拟输入 耗电量会增加很多 就算配置后再关时钟也没用！
 *								尽量不要勾选CubeMX中的配置闲置引脚为模拟输入的选项 没用到的时钟还开启了会增加很多耗电
 *								低功耗模式配置：
 *								在进入STOP模式时 GPIO会保留原本的状态 所以把开启后不需要再保留的GPIO配置为模拟输入确实省电 时钟的话不用的肯定关 其他的反正都会关（除了保留的时钟）
 *								在进入SLEEP模式时 时钟并不会关闭 所以时钟应手动关闭 且将开启后的GPIO配置为模拟输入
 *								待机模式和关机模式就更不用在意GPIO口耗电了
 *								https://blog.csdn.net/weixin_53403301/article/details/129055530
 *
 * @param 	[in]	EnableNotDisable: 使所有GPIO变成模拟输入或不进行模拟配置
 *
 * @return				None
 */
void GPIO_Reset_Init(bool EnableNotDisable)
{
//	HAL_GPIO_DeInit(GPIOA,GPIO_PIN_2|GPIO_PIN_3);		//用于串口唤醒的引脚 不可变动
	
	HAL_GPIO_DeInit(GPIOA,GPIO_PIN_0|GPIO_PIN_1
												|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
												|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11
												|GPIO_PIN_12|GPIO_PIN_15);
	
	HAL_GPIO_DeInit(GPIOB,GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_10
												|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14
												|GPIO_PIN_15|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5
												|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9);
	
	HAL_GPIO_DeInit(GPIOC,GPIO_PIN_13|GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2
												|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6
												|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10
												|GPIO_PIN_11|GPIO_PIN_12);
	
	HAL_GPIO_DeInit(GPIOD,GPIO_PIN_2);
	
	HAL_GPIO_DeInit(GPIOH,GPIO_PIN_3);
	
	if(EnableNotDisable)
	{
		GPIO_InitTypeDef GPIO_InitStruct = {0};

		/* GPIO Ports Clock Enable */
		__HAL_RCC_GPIOC_CLK_ENABLE();
		__HAL_RCC_GPIOH_CLK_ENABLE();
		__HAL_RCC_GPIOA_CLK_ENABLE();
		__HAL_RCC_GPIOB_CLK_ENABLE();
		__HAL_RCC_GPIOD_CLK_ENABLE();

		/*Configure GPIO pins : PC13 PC0 PC1 PC2
														 PC3 PC4 PC5 PC6
														 PC7 PC8 PC9 PC10
														 PC11 PC12 */
		GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2
														|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6
														|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10
														|GPIO_PIN_11|GPIO_PIN_12;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

		/*Configure GPIO pins : PA0 PA1 PA2 PA3
														 PA4 PA5 PA6 PA7
														 PA8 PA9 PA10 PA11
														 PA12 PA15 */
		GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1
														|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
														|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11
														|GPIO_PIN_12|GPIO_PIN_15;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
		
//		//用于串口唤醒的 不可变动
//		GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
//		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
//		GPIO_InitStruct.Pull = GPIO_NOPULL;
//		HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
		
		/*Configure GPIO pins : PB0 PB1 PB2 PB10
														 PB11 PB12 PB13 PB14
														 PB15 PB3 PB4 PB5
														 PB6 PB7 PB8 PB9 */
		GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_10
														|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14
														|GPIO_PIN_15|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5
														|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

		/*Configure GPIO pin : PD2 */
		GPIO_InitStruct.Pin = GPIO_PIN_2;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

		/*Configure GPIO pin : PH3 */
		GPIO_InitStruct.Pin = GPIO_PIN_3;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);
	}
}

注意：用于串口唤醒等的引脚，不可配置为模拟输入，也不可关闭
在进行GPIO初始化前，先将GPIO_DeInit，但是不做也不影响，不过还是建议跑一下
以优先级顺序来看：
如果这一组GPIO都没用到过那么直接不开启时钟就最省电
如果这一组GPIO有引脚用过了时钟不能关那么就将用过的引脚配置为模拟输入
切记！！！：
不要将没用过的引脚配置为模拟输入耗电量其实会稍微增加一点！
不要将没用过的GPIO时钟打开以后再配置为模拟输入耗电量会增加很多就算配置后再关时钟也没用！
尽量不要勾选CubeMX中的配置闲置引脚为模拟输入的选项没用到的时钟还开启了会增加很多耗电
低功耗模式配置：
在进入STOP模式时 GPIO会保留原本的状态所以把开启后不需要再保留的GPIO配置为模拟输入确实省电时钟的话不用的肯定关其他的反正都会关（除了保留的时钟）
在进入SLEEP模式时时钟并不会关闭所以时钟应手动关闭且将开启后的GPIO配置为模拟输入
待机模式和关机模式就更不用在意GPIO口耗电了

而低功耗进入则改成了：
（相关配置及唤醒功能等见前文）

printf("[INFO] 进入停止模式\n");
delay_ms(10);  //消抖
PWR_Device_Init(false);			
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON,PWR_SLEEPENTRY_WFI);
break;

同样在唤醒后唤醒回调里面也得先配置时钟再进行外设初始化

void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart)
{
	if(huart==&huart2)
  {		
		__HAL_RCC_PWR_CLK_ENABLE();
		HAL_Init();
		SystemClock_Config();		
		Ctrl_UART_StopMode_WakeUp(huart,false);
		PWR_Device_Init(true);
  }
}

void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
{
	__HAL_RCC_PWR_CLK_ENABLE();
	HAL_Init();
	SystemClock_Config();
	Ctrl_RTC_WakeUp(0,0,false);
	PWR_Device_Init(true);
}

不过 HAL_Init可以省略但是为了避免出现bug 还是放在这里.

调用的时候：

	Ctrl_UART_StopMode_WakeUp(&huart2,true);
	Ctrl_RTC_WakeUp(20000,RTC_WAKEUPCLOCK_RTCCLK_DIV16,true);
	Enter_Low_PWR(2,0);

先配置唤醒用的功能再进入低功耗

当然唤醒用的外设也需要在最开始进行初始化配置

GPIO省电模式实验

众所周知 GPIO配置为模拟输入最省电

在CubeMX中有一项可以将未用到的引脚全部配置为模拟输入

【STM32笔记】低功耗模式配置及避坑汇总
若是不开启任何GPIO 以STM32L496RGT6为例函数为：

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();

  /*Configure GPIO pins : PC13 PC0 PC1 PC2
                           PC3 PC4 PC5 PC6
                           PC7 PC8 PC9 PC10
                           PC11 PC12 */
  GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2
                          |GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6
                          |GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10
                          |GPIO_PIN_11|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pins : PA0 PA1 PA2 PA3
                           PA4 PA5 PA6 PA7
                           PA8 PA9 PA10 PA11
                           PA12 PA15 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
                          |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
                          |GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11
                          |GPIO_PIN_12|GPIO_PIN_15;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : PB0 PB1 PB2 PB10
                           PB11 PB12 PB13 PB14
                           PB15 PB3 PB4 PB5
                           PB6 PB7 PB8 PB9 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_10
                          |GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14
                          |GPIO_PIN_15|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5
                          |GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PD2 */
  GPIO_InitStruct.Pin = GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

  /*Configure GPIO pin : PH3 */
  GPIO_InitStruct.Pin = GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);

}

可以看到在配置之前需要先开启GPIO时钟

另外如果配置了外部晶振或系统调试则仅会开启时钟而不会有任何引脚复用的配置

  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

但无论是官方手册还是官方例程引脚配置前都应开启时钟再进行配置
所以在进行模拟输入配置时都会把所有的引脚时钟开启

以我做的最小系统板进行测试：
download.csdn.net/download/weixin_53403301/86930297

【STM32笔记】低功耗模式配置及避坑汇总
其主要耗电为两个LED灯
去掉这两个LED灯并且进入待机模式后实测只有8uA以下的功耗

这两个LED灯也是为了方便测试

在恒压源3.3V供电的前提下从以下四个方面进行测试每次都在电流稳定后读取三次复位以后取平均值精度10uA：

按CubeMX生成的所有闲置引脚模拟输入代码直接烧录进去
按CubeMX生成的代码去掉GPIOB和GPIOD的时钟（仅保留系统调试和高低速外部晶振）再进行初始化
按CubeMX生成的代码进行初始化以后再去掉GPIOB和GPIOD的时钟（仅保留系统调试和高低速外部晶振）
不进行GPIO初始化 GPIO时钟仅保留系统调试和高低速外部晶振时钟关闭GPIOB和GPIOD的时钟
只开启GPIOC、GPIOA、GPIOH的时钟，并且将C、A、H剩下的引脚配置为模拟输入关闭GPIOB和GPIOD的时钟且不对其进行任何配置

其实测电流如下：

1	2	3	4	5
按CubeMX生成的所有闲置引脚模拟输入代码直接烧录进去	按CubeMX生成的代码去掉GPIOB和GPIOD的时钟（仅保留系统调试和高低速外部晶振）再进行初始化	按CubeMX生成的代码进行初始化以后再去掉GPIOB和GPIOD的时钟（仅保留系统调试和高低速外部晶振）	不进行GPIO初始化 GPIO时钟仅保留系统调试和高低速外部晶振时钟关闭GPIOB和GPIOD的时钟	只开启GPIOC、GPIOA、GPIOH的时钟，并且将C、A、H剩下的引脚配置为模拟输入关闭GPIOB和GPIOD的时钟且不对其进行任何配置
1.27mA	1.12mA	1.29mA	1.08mA	1.13mA（同2）

其中功耗最低的是不进行模拟输入初始化的方案仅关闭不需要的时钟其次是仅配置需要保留的GPIO组时钟并把其他引脚配置为模拟输入

在关闭时钟时 GPIO配置其实是无效的（还是会进行配置将相关参数写入寄存器但GPIO不会工作所以无效）

所以方案2和方案5等价的这两者都是在初始化之前没开启时钟方案2虽然将寄存器写入但功耗其实和5差不多实验也存在误差所以可以忽略不计

而方案4则更加直接了没有进行任何GPIO配置直接关闭不用的时钟

重点是1和3
1的话就是开启了所有时钟然后把闲置引脚都配置为模拟输入
3则是进行1之后再关闭闲置时钟
其中 3的耗电量是最高的尽管初始化后面关闭了时钟但其实最多就是跟1差不多完全比不上2 4 5 甚至功耗比1还高（虽然可能存在误差）

所以综合来说以省电优先级顺序来看：
如果这一组GPIO都没用到过那么直接不开启时钟就最省电
如果这一组GPIO有引脚用过了时钟不能关那么就将用过的引脚配置为模拟输入
尽量不要勾选CubeMX中的配置闲置引脚为模拟输入的选项没用到的时钟还开启了会增加很多耗电

切记！！！：
不要将没用过的引脚配置为模拟输入耗电量其实会稍微增加一点！
不要将没用过的GPIO时钟打开以后再配置为模拟输入耗电量会增加很多就算配置后再关时钟也没用！

低功耗模式扩展

在进入STOP模式时 GPIO会保留原本的状态所以把开启后不需要再保留的GPIO配置为模拟输入确实省电时钟的话不用的肯定关其他的反正都会关（除了保留的时钟）

在进入SLEEP模式时时钟并不会关闭所以时钟应手动关闭且将开启后的GPIO配置为模拟输入

待机模式和关机模式就更不用在意GPIO口耗电了

附上我进入低功耗前的GPIO配置函数：

/*!
 * @brief       	重置GPIO（都会进行），或再将除外部高低速晶振复用、SWCLK、SWDIO复用的所有GPIO配置为模拟输入（false）
 *								注意：用于串口唤醒等的引脚，不可配置为模拟输入，也不可关闭
 *								在进行GPIO初始化前，先将GPIO_DeInit，但是不做也不影响，不过还是建议跑一下
 *								以优先级顺序来看：
 *								如果这一组GPIO都没用到过 那么直接不开启时钟就最省电
 *								如果这一组GPIO有引脚用过了 时钟不能关 那么就将用过的引脚配置为模拟输入
 *								切记！！！：
 *								不要将没用过的引脚配置为模拟输入 耗电量其实会稍微增加一点！
 *								不要将没用过的GPIO时钟打开以后再配置为模拟输入 耗电量会增加很多 就算配置后再关时钟也没用！
 *								尽量不要勾选CubeMX中的配置闲置引脚为模拟输入的选项 没用到的时钟还开启了会增加很多耗电
 *								低功耗模式配置：
 *								在进入STOP模式时 GPIO会保留原本的状态 所以把开启后不需要再保留的GPIO配置为模拟输入确实省电 时钟的话不用的肯定关 其他的反正都会关（除了保留的时钟）
 *								在进入SLEEP模式时 时钟并不会关闭 所以时钟应手动关闭 且将开启后的GPIO配置为模拟输入
 *								待机模式和关机模式就更不用在意GPIO口耗电了
 *								https://blog.csdn.net/weixin_53403301/article/details/129055530
 *
 * @param 	[in]	EnableNotDisable: 使所有GPIO变成模拟输入或不进行模拟配置
 *
 * @return				None
 */
void GPIO_Reset_Init(bool EnableNotDisable)
{
//	HAL_GPIO_DeInit(GPIOA,GPIO_PIN_2|GPIO_PIN_3);		//用于串口唤醒的引脚 不可变动
	
	HAL_GPIO_DeInit(GPIOA,GPIO_PIN_0|GPIO_PIN_1
												|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
												|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11
												|GPIO_PIN_12|GPIO_PIN_15);
	
	HAL_GPIO_DeInit(GPIOB,GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_10
												|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14
												|GPIO_PIN_15|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5
												|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9);
	
	HAL_GPIO_DeInit(GPIOC,GPIO_PIN_13|GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2
												|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6
												|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10
												|GPIO_PIN_11|GPIO_PIN_12);
	
	HAL_GPIO_DeInit(GPIOD,GPIO_PIN_2);
	
	HAL_GPIO_DeInit(GPIOH,GPIO_PIN_3);
	
	if(EnableNotDisable)
	{
		GPIO_InitTypeDef GPIO_InitStruct = {0};

		/* GPIO Ports Clock Enable */
		__HAL_RCC_GPIOC_CLK_ENABLE();
		__HAL_RCC_GPIOH_CLK_ENABLE();
		__HAL_RCC_GPIOA_CLK_ENABLE();
		__HAL_RCC_GPIOB_CLK_ENABLE();
		__HAL_RCC_GPIOD_CLK_ENABLE();

		/*Configure GPIO pins : PC13 PC0 PC1 PC2
														 PC3 PC4 PC5 PC6
														 PC7 PC8 PC9 PC10
														 PC11 PC12 */
		GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2
														|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6
														|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10
														|GPIO_PIN_11|GPIO_PIN_12;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

		/*Configure GPIO pins : PA0 PA1 PA2 PA3
														 PA4 PA5 PA6 PA7
														 PA8 PA9 PA10 PA11
														 PA12 PA15 */
		GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1
														|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
														|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11
														|GPIO_PIN_12|GPIO_PIN_15;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
		
//		//用于串口唤醒的 不可变动
//		GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
//		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
//		GPIO_InitStruct.Pull = GPIO_NOPULL;
//		HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
		
		/*Configure GPIO pins : PB0 PB1 PB2 PB10
														 PB11 PB12 PB13 PB14
														 PB15 PB3 PB4 PB5
														 PB6 PB7 PB8 PB9 */
		GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_10
														|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14
														|GPIO_PIN_15|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5
														|GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

		/*Configure GPIO pin : PD2 */
		GPIO_InitStruct.Pin = GPIO_PIN_2;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

		/*Configure GPIO pin : PH3 */
		GPIO_InitStruct.Pin = GPIO_PIN_3;
		GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
		GPIO_InitStruct.Pull = GPIO_NOPULL;
		HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);
	}
}

__WFI()；进入不了休眠的可能原因

__WFI();为汇编指令

/**
  \brief   Wait For Interrupt
  \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs.
 */
#define __WFI                             __wfi

其作用就是设备休眠并等待任意中断实践唤醒
【STM32笔记】低功耗模式配置及避坑汇总

实际调用：

	__WFI();

但是基本上直接都执行不了

最常见的就是中断没清理掉

【STM32笔记】低功耗模式配置及避坑汇总
在Keil的调试中可以看到活跃的中断

EPA分别表示Enable Pending Active

前两个表示开启但未发生 Active表示正在发生

所以进入休眠前需要调用中断清理
如：

__disable_irq();

或：

__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);	  //清理唤醒标志 防止立刻唤醒

等标志

另外实测发现即使没有中断或唤醒标志也会导致__WFI();无法进入特别是程序刚开始运行的时候这里其实就是没消抖需要延时一会（哪怕1us）

	delay_us(1);
	__WFI();

再者在进行调试时如果采用单步调试（也相当于一种中断）则会执行__WFI();后立马执行下一句

所以可以在__WFI();之前和之后打一个断点用全速跑来判断是否进入

附录：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  关闭系统定时器
}

其中的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  关闭系统定时器
}

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  关闭系统定时器
}

但是这种写法有个弊端
那就是输入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  关闭系统定时器
}

将等待和关闭定时器语句去掉
在使用时加上判断即可变为阻塞：

delay_ms(500);
while ((SysTick->CTRL & 0x00010000)==0);
SysTick->CTRL = 0;

在非阻塞状态下可以提交定时器后去做别的事情然后再来等待

不过这样又有一个弊端那就是定时器会自动重载可能做别的事情以后定时器跑过了然后就要等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

总线函数

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

一、位带操作理论及实践

位带操作的概念其实30年前就有了，那还是 CM3 将此能力进化，这里的位带操作是 8051 位寻址区的威力大幅加强版

位带区：支持位带操作的地址区

位带别名：对别名地址的访问最终作用到位带区的访问上（注意：这中途有一个地址映射过程）

位带操作对于硬件 I/O 密集型的底层程序最有用处

支持了位带操作后，可以使用普通的加载/存储指令来对单一的比特进行读写。在CM4中，有两个区中实现了位带。其中一个是SRAM区的最低1MB范围，第二个则是片内外设区的最低1MB范围。这两个区中的地址除了可以像普通的RAM一样使用外，它们还都有自己的“位带别名区”，位带别名区把每个比特膨胀成一个32位的字。当你通过位带别名区访问这些字时，就可以达到访问原始比特的目的。

位操作就是可以单独的对一个比特位读和写，类似与51中sbit定义的变量，stm32中通过访问位带别名区来实现位操作的功能
STM32中有两个地方实现了位带，一个是SRAM，一个是片上外设。
【STM32笔记】低功耗模式配置及避坑汇总
（1）位带本质上是一块地址区（例如每一位地址位对应一个寄存器）映射到另一片地址区（实现每一位地址位对应一个寄存器中的一位），该区域就叫做位带别名区，将每一位膨胀成一个32位的字。
（2）位带区的4个字节对应实际寄存器或内存区的一个位，虽然变大到4个字节，但实际上只有最低位有效（代表0或1）

只有位带可以直接用=赋值的方式来操作寄存器位带是把寄存器上的每一位膨胀到32位映射到位带区比如0x4002 0000地址的第0个bit 映射到位带区的0地址那么其对应的位带映射地址为0x00 - 0x04 一共32位但只有LSB有效采用位带的方式用=赋值时就是把位带区对应的LSB赋值然后MCU再转到寄存器对应的位里面寄存器操作时如果不改变其他位上面的值那就只能通过&=或者|=的方式进行

【STM32笔记】低功耗模式配置及避坑汇总

要设置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)

【STM32笔记】低功耗模式配置及避坑汇总

但好在官方库里面都帮我们定义好了只需要在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)

封装一下：

#define PFout(x) *(volatile uint32_t *)(0x42000000 + ((uint32_t )&GPIOF->ODR – 0x40000000) *32 + x*4)

现在可以把通用部分封装成一个小定义：

#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))

那么设置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)  //输入

若使PF9输入输出则：

PF_O(9)=1;  //输出高电平
uint8_t dat = PF_I(9);  //获取PF9引脚的值

总线输入输出：

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

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

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

二、如何判断MCU的外设是否支持位带

根据《ARM Cortex-M3与Cortex-M4权威指南(第3版)》中第6章第7节描述
【STM32笔记】低功耗模式配置及避坑汇总
也就是说要实现对GPIO的位带操作必须保证GPIO位于外设区域的第一个1MB中
第一个1MB应该是0x4010 0000之前位带不是直接操作地址而是操作地址映射地址映射被操作以后 MCU自动会修改对应寄存器的值

位带区只有1MB 所以只能改0x4000 0000 - 0x400F FFFF的寄存器
像F4系列 GPIO的首地址为0x4002 0000 就可以用位带来更改

STM32L476的GPIO就不行：
【STM32笔记】低功耗模式配置及避坑汇总
AHB2的都不能用位带
ABP 还有AHB1都可以用

但是L476的寄存器里面 GPIO和ADC都是AHB2文章来源地址https://www.toymoban.com/news/detail-461649.html