正经夜光杯

这个屌丝很懒，什么也没留下！

热门标签

【优秀课设】基于stm32f407ze的蜂鸣器音乐（生日快乐、In The End）、PWM呼吸灯及串口通信系统_stm32f407蜂鸣器发出音乐

作者：正经夜光杯 | 2024-07-17 04:47:31

踩

stm32f407蜂鸣器发出音乐

【优秀课设】基于stm32f407ze的蜂鸣器音乐（生日快乐、In The End）、PWM呼吸灯及串口通信系统

文章目录

STM32
- Cortex-M架构SysTick系统定时器阻塞和非阻塞延时
附录：Cortex-M架构的SysTick系统定时器精准延时和MCU位带操作

STM32

直接上代码：

# include "stm32f4xx.h"
# include  "GPIO.h"
# include  "DELAY.h"
# include  "GPIO_BUS.h"
static uint16_t tim13_period=0;
//串口初始化函数
void init_USART1(unsigned int Baud)
{
	//定义GPIO结构体
	GPIO_InitTypeDef GPIO_KEEY_InitStruct;
	//使能GPIOF时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
	//初始化结构体
	GPIO_KEEY_InitStruct.GPIO_Pin  = GPIO_Pin_9 | GPIO_Pin_10; //定义引脚
	GPIO_KEEY_InitStruct.GPIO_Mode = GPIO_Mode_AF;  //定义输出模式
	GPIO_KEEY_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;	//定义速度
	GPIO_KEEY_InitStruct.GPIO_OType = GPIO_OType_PP;		//定义推挽输出
	GPIO_KEEY_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;		//定义是否有上下拉电阻 普通
	//将结构体给GPIOF组
	GPIO_Init(GPIOA,&GPIO_KEEY_InitStruct);
	
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);  //复用功能
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);  //复用功能
	
	USART_InitTypeDef USART_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	//配置串口
	USART_InitStructure.USART_BaudRate = Baud;  //波特率
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;  //8位数据位
	USART_InitStructure.USART_StopBits = USART_StopBits_1;  //1个停止位
  USART_InitStructure.USART_Parity = USART_Parity_No;  //无校验位
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  //无硬件流控制
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;  //支持收发数据
	USART_Init(USART1, &USART_InitStructure);
	//中断方式
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);  //使能RX

	//中断优先级
	NVIC_InitTypeDef NVIC_InitStructure;
 
   /* Enable the USARTx Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	//使能串口
	USART_Cmd(USART1, ENABLE);
}
//蜂鸣器初始化
void init_BEEP(void)
{
	//定义GPIO结构体
	GPIO_InitTypeDef GPIOF_BEEP_InitStruct;
	//使能GPIOF时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
	//初始化结构体
	GPIOF_BEEP_InitStruct.GPIO_Pin  = GPIO_Pin_8; //定义引脚
	GPIOF_BEEP_InitStruct.GPIO_Mode = GPIO_Mode_OUT;  //定义输出模式
	GPIOF_BEEP_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;	//定义速度
	GPIOF_BEEP_InitStruct.GPIO_OType = GPIO_OType_PP;		//定义推挽输出
	GPIOF_BEEP_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN;		//定义是否有上下拉电阻 普通
	//将结构体给GPIOF组
	GPIO_Init(GPIOF,&GPIOF_BEEP_InitStruct);
}

void init_KEEY(void)
{
	//定义GPIO结构体
	GPIO_InitTypeDef GPIO_KEEY_InitStruct;
	//使能GPIOF时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
	//初始化结构体
	GPIO_KEEY_InitStruct.GPIO_Pin  = GPIO_Pin_0; //定义引脚
	GPIO_KEEY_InitStruct.GPIO_Mode = GPIO_Mode_IN;  //定义输出模式
	GPIO_KEEY_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;	//定义速度
	GPIO_KEEY_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;		//定义是否有上下拉电阻 普通
	//将结构体给GPIOF组
	GPIO_Init(GPIOA,&GPIO_KEEY_InitStruct);
	
	GPIO_KEEY_InitStruct.GPIO_Pin  = GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4;
	GPIO_Init(GPIOE,&GPIO_KEEY_InitStruct);
}
//两个引脚整体初始化函数
void init_GPIO_EF_OUT()
{
	//定义GPIO结构体
	GPIO_InitTypeDef GPIO_InitStruct;
	//使能GPIOF时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
	//初始化结构体
	GPIO_InitStruct.GPIO_Pin  = GPIO_Pin_9 | GPIO_Pin_10; //定义引脚
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;  //定义输出模式
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;	//定义速度
	GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;		//定义推挽输出
	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;		//定义是否有上下拉电阻 普通
	//将结构体给GPIOF组
	GPIO_Init(GPIOF,&GPIO_InitStruct);
	
	GPIO_InitStruct.GPIO_Pin  = GPIO_Pin_13 | GPIO_Pin_14; //定义引脚
	//将结构体给GPIOE组
	GPIO_Init(GPIOE,&GPIO_InitStruct);
}
//定时器14及PF9复用PWM初始化
void init_TIM14_PF9(void)
{
	//定义GPIO结构体
	GPIO_InitTypeDef GPIOF_InitStruct;
	//使能GPIOF时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
	//初始化结构体
	GPIOF_InitStruct.GPIO_Pin  = GPIO_Pin_9; //定义引脚
	GPIOF_InitStruct.GPIO_Mode = GPIO_Mode_AF;  //定义输出模式
	GPIOF_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;	//定义速度
	GPIOF_InitStruct.GPIO_OType = GPIO_OType_PP;		//定义推免输出
	GPIOF_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;		//定义是否有上下拉电阻 普通
	//复用功能 定时器14
	GPIO_PinAFConfig(GPIOF, GPIO_PinSource9, GPIO_AF_TIM14);
	//将结构体给GPIOF组
	GPIO_Init(GPIOF,&GPIOF_InitStruct);
	
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;  //定时器复用功能结构体
	//NVIC_InitTypeDef NVIC_InitStructure;
	/* TIM3 clock enable */ //使能定时器3时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM14, ENABLE);
	//重转载寄存器 定义计数值 决定了计数多少次就进行一次中断 不得大于分频以后的计数值 若改为5000为0.5秒
	TIM_TimeBaseStructure.TIM_Period = 100-1;  //10ms周期
	TIM_TimeBaseStructure.TIM_Prescaler = 8400-1;  //定时器预分频 168000000/2/8400=10000 其值系统默认+1 每10000次计数为1秒
	TIM_TimeBaseStructure.TIM_ClockDivision = 0;  //选择计数模式 向上计数
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //向上计数
	TIM_TimeBaseInit(TIM14, &TIM_TimeBaseStructure);
	//设置中断触发方式 计数更新
	TIM_ITConfig(TIM14,TIM_IT_Update, ENABLE);
	
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;  //PWM模式1  有效状态为小于计数的比较值时
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  //输出使能
	TIM_OCInitStructure.TIM_Pulse = 0;  //设置比较值 小于x时为有效 总计数值为100 周期为10ms
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;  //有效状态为高电平
	//输出化OC
	TIM_OC1Init(TIM14, &TIM_OCInitStructure);
	//使能OC
	TIM_OC1PreloadConfig(TIM14, TIM_OCPreload_Enable);
	
//	NVIC_InitTypeDef NVIC_InitStruct;
//	NVIC_InitStruct.NVIC_IRQChannel = TIM8_TRG_COM_TIM14_IRQn;
//	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0; //中断抢占优先级
//	NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1; //响应优先级
//	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;  //这一项关闭的话 定时器也会关闭
//	NVIC_Init(&NVIC_InitStruct);
	
	TIM_Cmd(TIM14, ENABLE);
	TIM_CtrlPWMOutputs(TIM14,ENABLE);		//使能PWM输出控制
}
//定时器1及PE13复用PWM初始化
void init_TIM1_PE13(void)
{
	//定义GPIO结构体
	GPIO_InitTypeDef GPIOE_InitStruct;
	//使能GPIOF时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
	//初始化结构体
	GPIOE_InitStruct.GPIO_Pin  = GPIO_Pin_13; //定义引脚
	GPIOE_InitStruct.GPIO_Mode = GPIO_Mode_AF;  //定义输出模式
	GPIOE_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;	//定义速度
	GPIOE_InitStruct.GPIO_OType = GPIO_OType_PP;		//定义推免输出
	GPIOE_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;		//定义是否有上下拉电阻 普通
	//复用功能 定时器14
	GPIO_PinAFConfig(GPIOE, GPIO_PinSource13, GPIO_AF_TIM1);
	//将结构体给GPIOF组
	GPIO_Init(GPIOE,&GPIOE_InitStruct);
	
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;  //定时器复用功能结构体
	//NVIC_InitTypeDef NVIC_InitStructure;
	/* TIM3 clock enable */ //使能定时器3时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
	//重转载寄存器 定义计数值 决定了计数多少次就进行一次中断 不得大于分频以后的计数值 若改为5000为0.5秒
	TIM_TimeBaseStructure.TIM_Period = 100-1;  //10ms周期
	TIM_TimeBaseStructure.TIM_Prescaler = 8400-1;  //定时器预分频 168000000/2/8400=10000 其值系统默认+1 每10000次计数为1秒
	TIM_TimeBaseStructure.TIM_ClockDivision = 0;  //选择计数模式 向上计数
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //向上计数
	TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
	//设置中断触发方式 计数更新
	TIM_ITConfig(TIM1,TIM_IT_Update, ENABLE);
	
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;  //PWM模式1  有效状态为小于计数的比较值时
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  //输出使能
	TIM_OCInitStructure.TIM_Pulse = 0;  //设置比较值 小于x时为有效 总计数值为100 周期为10ms
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;  //有效状态为高电平
	//输出化OC
	TIM_OC3Init(TIM1, &TIM_OCInitStructure);	//OC3表示通道3 即CH3
	//使能OC
	TIM_OC3PreloadConfig(TIM1, TIM_OCPreload_Enable);
	
//	NVIC_InitTypeDef NVIC_InitStruct;
//	NVIC_InitStruct.NVIC_IRQChannel = TIM8_TRG_COM_TIM14_IRQn;
//	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0; //中断抢占优先级
//	NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1; //响应优先级
//	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;  //这一项关闭的话 定时器也会关闭
//	NVIC_Init(&NVIC_InitStruct);
	
	TIM_Cmd(TIM1, ENABLE);
	TIM_CtrlPWMOutputs(TIM1,ENABLE);		//使能PWM输出控制
}
//定时器1及PE14复用PWM初始化
void init_TIM1_PE14(void)
{
	//定义GPIO结构体
	GPIO_InitTypeDef GPIOE_InitStruct;
	//使能GPIOF时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
	//初始化结构体
	GPIOE_InitStruct.GPIO_Pin  = GPIO_Pin_14; //定义引脚
	GPIOE_InitStruct.GPIO_Mode = GPIO_Mode_AF;  //定义输出模式
	GPIOE_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;	//定义速度
	GPIOE_InitStruct.GPIO_OType = GPIO_OType_PP;		//定义推免输出
	GPIOE_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;		//定义是否有上下拉电阻 普通
	//复用功能 定时器14
	GPIO_PinAFConfig(GPIOE, GPIO_PinSource14, GPIO_AF_TIM1);
	//将结构体给GPIOF组
	GPIO_Init(GPIOE,&GPIOE_InitStruct);
	
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;  //定时器复用功能结构体
	//NVIC_InitTypeDef NVIC_InitStructure;
	/* TIM3 clock enable */ //使能定时器3时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
	//重转载寄存器 定义计数值 决定了计数多少次就进行一次中断 不得大于分频以后的计数值 若改为5000为0.5秒
	TIM_TimeBaseStructure.TIM_Period = 100-1;  //10ms周期
	TIM_TimeBaseStructure.TIM_Prescaler = 8400-1;  //定时器预分频 168000000/2/8400=10000 其值系统默认+1 每10000次计数为1秒
	TIM_TimeBaseStructure.TIM_ClockDivision = 0;  //选择计数模式 向上计数
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //向上计数
	TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
	//设置中断触发方式 计数更新
	TIM_ITConfig(TIM1,TIM_IT_Update, ENABLE);
	
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;  //PWM模式1  有效状态为小于计数的比较值时
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  //输出使能
	TIM_OCInitStructure.TIM_Pulse = 0;  //设置比较值 小于x时为有效 总计数值为100 周期为10ms
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;  //有效状态为高电平
	//输出化OC
	TIM_OC4Init(TIM1, &TIM_OCInitStructure);	//OC4表示通道4 即CH4
	//使能OC
	TIM_OC4PreloadConfig(TIM1, TIM_OCPreload_Enable);
	
//	NVIC_InitTypeDef NVIC_InitStruct;
//	NVIC_InitStruct.NVIC_IRQChannel = TIM8_TRG_COM_TIM14_IRQn;
//	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0; //中断抢占优先级
//	NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1; //响应优先级
//	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;  //这一项关闭的话 定时器也会关闭
//	NVIC_Init(&NVIC_InitStruct);
	
	TIM_Cmd(TIM1, ENABLE);
	TIM_CtrlPWMOutputs(TIM1,ENABLE);		//使能PWM输出控制
}
//定时器13及PF8复用PWM初始化
void init_TIM13_PF8_F(uint32_t freq)
{
	//定义GPIO结构体
	GPIO_InitTypeDef GPIOF_InitStruct;
	//使能GPIOF时钟
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
	//初始化结构体
	GPIOF_InitStruct.GPIO_Pin  = GPIO_Pin_8; //定义引脚
	GPIOF_InitStruct.GPIO_Mode = GPIO_Mode_AF;  //定义输出模式
	GPIOF_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;	//定义速度
	GPIOF_InitStruct.GPIO_OType = GPIO_OType_PP;		//定义推免输出
	GPIOF_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;		//定义是否有上下拉电阻 普通
	//复用功能 定时器14
	GPIO_PinAFConfig(GPIOF, GPIO_PinSource8, GPIO_AF_TIM13);
	//将结构体给GPIOF组
	GPIO_Init(GPIOF,&GPIOF_InitStruct);
	
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;  //定时器复用功能结构体
	//NVIC_InitTypeDef NVIC_InitStructure;
	/* TIM3 clock enable */ //使能定时器3时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM13, ENABLE);
	//重转载寄存器 定义计数值 决定了计数多少次就进行一次中断 不得大于分频以后的计数值 若改为5000为0.5秒
	TIM_TimeBaseStructure.TIM_Period = (10000/freq)-1;  //10ms周期
	tim13_period = TIM_TimeBaseStructure.TIM_Period;
	TIM_TimeBaseStructure.TIM_Prescaler = 8400-1;  //定时器预分频 168000000/2/8400=10000 其值系统默认+1 每10000次计数为1秒
	TIM_TimeBaseStructure.TIM_ClockDivision = 0;  //选择计数模式 向上计数
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //向上计数
	TIM_TimeBaseInit(TIM13, &TIM_TimeBaseStructure);
	//设置中断触发方式 计数更新
	TIM_ITConfig(TIM13,TIM_IT_Update, ENABLE);
	
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;  //PWM模式1  有效状态为小于计数的比较值时
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  //输出使能
	TIM_OCInitStructure.TIM_Pulse = 0;  //设置比较值 小于x时为有效 总计数值为100 周期为10ms
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;  //有效状态为高电平
	//输出化OC
	TIM_OC1Init(TIM13, &TIM_OCInitStructure);
	//使能OC
	TIM_OC1PreloadConfig(TIM13, TIM_OCPreload_Enable);

//	NVIC_InitTypeDef NVIC_InitStruct;
//	NVIC_InitStruct.NVIC_IRQChannel = TIM8_UP_TIM13_IRQn;
//	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0; //中断抢占优先级
//	NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2; //响应优先级
//	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;  //这一项关闭的话 定时器也会关闭
//	NVIC_Init(&NVIC_InitStruct);
	
	TIM_Cmd(TIM13, ENABLE);
}
//设置定时器13的PWM占空比
//0%~100%  0.0 ~ 1
void TIM13_Set_duty(uint16_t duty)
{
	uint32_t cmp=0;
	
	cmp = (tim13_period+1)*duty/100;//比较值
	
	TIM_SetCompare1(TIM13,cmp);
}
int main(void)
{
//	init_KEEY();
	init_GPIO_EF_OUT();
	delay_ms(500);
	PF_BUS_O(0xFFFF);
	PE_BUS_O(0xFFFF);
//	init_TIM14_PF9();
//	init_TIM1_PE13();
//	init_TIM1_PE14();
	TIM_SetCompare1(TIM14,100);  //设置比较值
	TIM_SetCompare3(TIM1,100);
	TIM_SetCompare4(TIM1,100);
	int PWM;
	init_BEEP();
	PF_O(8)=0;
	TIM_Cmd(TIM13, DISABLE);
	init_USART1(115200);
	USART_SendData(USART1,'y');
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
	USART_SendData(USART1,'y');
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
	USART_SendData(USART1,'y');
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
	while(1)
	{	
		while(PE_I(3)==0)
		{
			while(1)
			{
				init_TIM13_PF8_F(880);
				TIM13_Set_duty(25);
				delay_ms(500);
				init_TIM13_PF8_F(1318);
				TIM13_Set_duty(25);
				delay_ms(500);
				init_TIM13_PF8_F(1318);
				TIM13_Set_duty(25);
				delay_ms(500);
				init_TIM13_PF8_F(1046);
				TIM13_Set_duty(25);
				delay_ms(500);
				init_TIM13_PF8_F(988);
				TIM13_Set_duty(25);
				delay_ms(500);
				init_TIM13_PF8_F(988);
				TIM13_Set_duty(25);
				delay_ms(500);
				init_TIM13_PF8_F(988);
				TIM13_Set_duty(25);
				delay_ms(500);
				init_TIM13_PF8_F(988);
				TIM13_Set_duty(25);
				delay_ms(250);
				init_TIM13_PF8_F(1046);
				TIM13_Set_duty(25);
				delay_ms(250);
			}
			//if(PA_I(0)==1)TIM13_Set_duty(0);break;
		}
		
		while(PA_I(0)==0)
		{
			init_TIM13_PF8_F(784*2/3);
			TIM13_Set_duty(25);
			delay_ms(250);
			init_TIM13_PF8_F(784*2/3);
			TIM13_Set_duty(25);
			delay_ms(250);
			init_TIM13_PF8_F(880*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(784*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(1046*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(987*2/3);
			TIM13_Set_duty(25);
			delay_ms(1000);
			
			init_TIM13_PF8_F(784*2/3);
			TIM13_Set_duty(25);
			delay_ms(250);
			init_TIM13_PF8_F(784*2/3);
			TIM13_Set_duty(25);
			delay_ms(250);
			init_TIM13_PF8_F(880*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(784*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(1175*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(1046*2/3);
			TIM13_Set_duty(25);
			delay_ms(1000);
			
			init_TIM13_PF8_F(784*2/3);
			TIM13_Set_duty(25);
			delay_ms(250);
			init_TIM13_PF8_F(784*2/3);
			TIM13_Set_duty(25);
			delay_ms(250);
			init_TIM13_PF8_F(1568*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(1318*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(1046*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(987*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(880*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			delay_ms(500);
			
			init_TIM13_PF8_F(1397*2/3);
			TIM13_Set_duty(25);
			delay_ms(250);
			init_TIM13_PF8_F(1397*2/3);
			TIM13_Set_duty(25);
			delay_ms(250);
			init_TIM13_PF8_F(1318*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(1046*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(1175*2/3);
			TIM13_Set_duty(25);
			delay_ms(500);
			init_TIM13_PF8_F(1046*2/3);
			TIM13_Set_duty(25);
			delay_ms(2000);
			if(PA_I(0)==1)TIM13_Set_duty(0);break;
		}

		while(PE_I(2)==0)
		{
			for(PWM=100;PWM>0;PWM--)
			{
				TIM_SetCompare1(TIM14,100-PWM);  //设置比较值
				TIM_SetCompare3(TIM1,100-PWM);
				TIM_SetCompare4(TIM1,100-PWM);
				delay_ms(10);
				if(PE_I(2)==1)
				{
					TIM_SetCompare1(TIM14,100);  //设置比较值
					TIM_SetCompare3(TIM1,100);
					TIM_SetCompare4(TIM1,100);
					break;
				}
			}
			for(PWM=0;PWM<100;PWM++)
			{
				TIM_SetCompare1(TIM14,100-PWM);  //设置比较值
				TIM_SetCompare3(TIM1,100-PWM);
				TIM_SetCompare4(TIM1,100-PWM);
				delay_ms(10);
				if(PE_I(2)==1)
				{
					TIM_SetCompare1(TIM14,100);  //设置比较值
					TIM_SetCompare3(TIM1,100);
					TIM_SetCompare4(TIM1,100);
					break;
				}
			}
			if(PE_I(2)==1)
			{
				TIM_SetCompare1(TIM14,100);  //设置比较值
				TIM_SetCompare3(TIM1,100);
				TIM_SetCompare4(TIM1,100);
				break;
			}
		}
	}
}
void USART1_IRQHandler(void)  //串口1中断服务函数
{
	if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET)
	{	
		char data = USART_ReceiveData(USART1);
		USART_SendData(USART1,data);
		while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
		if(data=='0')//接收数据
		{
			PE_BUS_O(0x0000);
			PF_BUS_O(0x0000);
		}
		if(data=='1')//接收数据
		{
			PE_BUS_O(0xFFFF);
			PF_BUS_O(0xFFFF);
		}
		USART_ClearITPendingBit(USART1,USART_IT_RXNE);//清空标志位
	}
}

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
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524

之前的文章：
blog.csdn.net/weixin_53403301/article/details/121599951

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的内部定时器都可以配置自动重载等功能网上资料很多这里就不再阐述了

附录：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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/838048