首页 > 其他分享 >STM32F407学习

STM32F407学习

时间：2023-04-13 23:31:29浏览次数：40  
标签：Pin 引脚 学习 InitStructure GPIO STM32F407 CR RCC

读懂数据手册，根据数据手册实现功能代码

固件库点灯

main.c

void delay(uint32_t count)
{
	for(;count!=0;count--);
	

}

int main(void)
{
	/*在这里添加自己的程序*/
	
	LED_GPIO_Config();
	
	while(1)
	{
		/*流水灯*/
		/*
		GPIO_ResetBits(GPIOF,GPIO_Pin_6);
		delay(0xffffff);
		GPIO_SetBits(GPIOF,GPIO_Pin_6);
		
		GPIO_ResetBits(GPIOF,GPIO_Pin_7);
		delay(0xffffff);
		GPIO_SetBits(GPIOF,GPIO_Pin_7);
		
		GPIO_ResetBits(GPIOF,GPIO_Pin_8);
		delay(0xffffff);
		GPIO_SetBits(GPIOF,GPIO_Pin_8);
		*/
		
		/*三种灯一块亮*/
		/*
		GPIO_ResetBits(GPIOF,GPIO_Pin_6);
		delay(0xffffff);
		GPIO_ResetBits(GPIOF,GPIO_Pin_7);
		delay(0xffffff);
		GPIO_ResetBits(GPIOF,GPIO_Pin_8);
		*/
	}
}

bsp_led.c

#include "bsp_led.h"
#include "stm32f4xx_gpio.h"

void LED_GPIO_Config(void)
{
	/*第一步：打开外设的时钟*/
	 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF,ENABLE);
	
	/*第二步：定义一个GPIO初始化结构体*/
	GPIO_InitTypeDef GPIO_InitStruct;
	
	/*第三步：配置GPIO初始化结构体的成员*/
	GPIO_InitStruct.GPIO_Pin =	GPIO_Pin_6;//选择要控制的GPIO引脚
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;//设置引脚模式为输出模式
	GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;//设置引脚的输出类型为推挽输出
	GPIO_InitStruct.GPIO_Speed = GPIO_Low_Speed;	//设置引脚速率为2MHZ->low
	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP; //设置引脚为上拉模式

	/*第四步：调用GPIO初始化函数，将配置好的结构体成员的额参数写入寄存器*/
	GPIO_Init(GPIOF,&GPIO_InitStruct);
	GPIO_ResetBits(GPIOF,GPIO_Pin_6);
	
	GPIO_InitStruct.GPIO_Pin =	GPIO_Pin_7;
	GPIO_Init(GPIOF,&GPIO_InitStruct);
	
	GPIO_InitStruct.GPIO_Pin =	GPIO_Pin_8;
	GPIO_Init(GPIOF,&GPIO_InitStruct);
}

按键->点灯灭灯->扫描按键按下

main.c

#include "bsp_key.h"
#include "bsp_led.h"

void delay(uint32_t count)
{
	for(;count!=0;count--);
}

int main(void)
{
	/*
		LED_GPIO_Config();
	KEY_GPIO_Config();
	while(1)
	{
		if(Key_Scan(GPIOA,GPIO_Pin_0) ==KEY_ON)
		{
			delay(0x3fffff);
			if(Key_Scan(GPIOA,GPIO_Pin_0)==KEY_ON)
			{
				LED1_TOGGLE;
			}
		}
		if(Key_Scan(GPIOC,GPIO_Pin_13) ==KEY_ON)
		{
			delay(0x3fffff);
			if(Key_Scan(GPIOC,GPIO_Pin_13) ==KEY_ON)
			{
				LED2_TOGGLE;
			}
		}
	}
	*/

}

bsp_key.c

#include "bsp_key.h" 


void KEY_GPIO_Config(void)
{	
	/*第一步：打开GPIO的时钟*/
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA|RCC_AHB1Periph_GPIOC,ENABLE);
	
	/*第二步：定义一个GPIO初始化结构体*/
	GPIO_InitTypeDef GPIO_InitStruct;
	
	/*第三步：配置GPIO初始化结构体的成员*/
	GPIO_InitStruct.GPIO_Pin =	GPIO_Pin_0;//选择要控制的GPIO引脚
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;//设置引脚模式为输出模式
//GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;//设置引脚的输出类型为推挽输出
//GPIO_InitStruct.GPIO_Speed = GPIO_Low_Speed;	//设置引脚速率为2MHZ->low
	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL; //设置引脚为上拉模式

	/*第四步：调用GPIO初始化函数，将配置好的结构体成员的额参数写入寄存器*/
	GPIO_Init(GPIOA,&GPIO_InitStruct);
	
	
	
	/*第三步：配置GPIO初始化结构体的成员*/
	GPIO_InitStruct.GPIO_Pin =	GPIO_Pin_13;//选择要控制的GPIO引脚
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;//设置引脚模式为输出模式
//GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;//设置引脚的输出类型为推挽输出
//GPIO_InitStruct.GPIO_Speed = GPIO_Low_Speed;	//设置引脚速率为2MHZ->low
	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL; //设置引脚为上拉模式

	/*第四步：调用GPIO初始化函数，将配置好的结构体成员的额参数写入寄存器*/
	GPIO_Init(GPIOC,&GPIO_InitStruct);
}


uint8_t Key_Scan(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)
{
	if(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin)==KEY_ON)
	{
		while(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin)==KEY_ON)
		return KEY_ON;
	}
	else	return KEY_OFF;
}

bsp_led.c

#include "bsp_led.h"   


void LED_GPIO_Config(void)
{		
		/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;

		/*开启LED相关的GPIO外设时钟*/
		RCC_AHB1PeriphClockCmd ( LED1_GPIO_CLK|
	                           LED2_GPIO_CLK|
	                           LED3_GPIO_CLK, ENABLE); 

		/*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED1_PIN;	

		/*设置引脚模式为输出模式*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   
    
    /*设置引脚的输出类型为推挽输出*/
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
    /*设置引脚为上拉模式*/
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;

		/*设置引脚速率为2MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; 

		/*调用库函数，使用上面配置的GPIO_InitStructure初始化GPIO*/
		GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);	
    
    /*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED2_PIN;	
    GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);	
    
    /*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED3_PIN;	
    GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);	
		
		/*关闭RGB灯*/
		LED_RGBOFF;		
}

RCC.寄存器->实现闪烁

main.c

#include "stm32f4xx.h"
#include "./led/bsp_led.h"
#include "bsp_clkconfig.h"

void Delay(__IO u32 nCount); 

/**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
int main(void)
{
	/*程序来到这里的时候，系统的时钟已经由SystemInit这个函数初始化好了*/
	User_SetSysClock();
	//将startup_stm32f40xx.s中系统时钟初始化函数注释掉，系统自动使用HSI作为系统时钟
	
	/* LED 端口初始化 */
	LED_GPIO_Config();

	/* 控制LED灯 */
	while (1)
	{
		 
		LED1(ON);
		Delay(0xffffff);
		LED1(OFF);
		Delay(0Xffffff);
	
	}

}

void Delay(__IO uint32_t nCount)	 //简单的延时函数
{
	for(; nCount != 0; nCount--);
}

bsp_clkconfig.c

void User_SetSysClock(void)
{
	RCC_DeInit();//复位RCC的所有寄存器
/******************************************************************************/
/*            PLL (clocked by HSE) used as System clock source                */
/******************************************************************************/
  __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
  
  /* Enable HSE */	//使能HSE
  RCC->CR |= ((uint32_t)RCC_CR_HSEON);
 
  /* Wait till HSE is ready and if Time out is reached exit */
	/*等待HSE启动稳定，如果超时则推出*/
  do
  {
    HSEStatus = RCC->CR & RCC_CR_HSERDY;
    StartUpCounter++;
  } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));

  if ((RCC->CR & RCC_CR_HSERDY) != RESET)
  {
    HSEStatus = (uint32_t)0x01;
  }
  else
  {
    HSEStatus = (uint32_t)0x00;
  }
	/*HSE 启动成功*/
  if (HSEStatus == (uint32_t)0x01)
  {
    /* Select regulator voltage output Scale 1 mode */
    /*选择电压调节器的模式为1*/
		RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    PWR->CR |= PWR_CR_VOS;
		
    /* HCLK = SYSCLK / 1*/
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1;
    /* PCLK2 = HCLK / 2*/
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV2; 
    /* PCLK1 = HCLK / 4*/
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV4;
    /* Configure the main PLL */
    /*配置主PLL*/
//		RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
//                   (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);
			RCC->PLLCFGR = 25 | (336 << 6) | (((2 >> 1) -1) << 16) |
                   (RCC_PLLCFGR_PLLSRC_HSE) | (7 << 24);
    /* Enable the main PLL */
		/*使能主PLL，使能后参数不能更改*/
    RCC->CR |= RCC_CR_PLLON;
    /* Wait till the main PLL is ready */
		/*等待主PLL稳定*/
    while((RCC->CR & RCC_CR_PLLRDY) == 0)
    {
    }  
    /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    /*配置FLASH预取指，指令缓存，数据缓存，等待周期*/
		FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
    /* Select the main PLL as system clock source */
    /*选择PLL时钟为系统时钟*/
		RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    RCC->CFGR |= RCC_CFGR_SW_PLL;
    /* Wait till the main PLL is used as system clock source */
    /*确保主PLL时钟选为系统时钟*/
		while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
    {
    }
  }
  else
  { /* If HSE fails to start-up, the application will have wrong clock
         configuration. User can add here some code to deal with this error */
		/*HSE启动失败，在这里添加启动失败的处理代码*/
	}
}

bsp_led.c

#include "./led/bsp_led.h"   

 /**
  * @brief  初始化控制LED的IO
  * @param  无
  * @retval 无
  */
void LED_GPIO_Config(void)
{		
		/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;

		/*开启LED相关的GPIO外设时钟*/
		RCC_AHB1PeriphClockCmd ( LED1_GPIO_CLK|
	                           LED2_GPIO_CLK|
	                           LED3_GPIO_CLK, ENABLE); 
		/*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED1_PIN;	
		/*设置引脚模式为输出模式*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   
    /*设置引脚的输出类型为推挽输出*/
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;  
    /*设置引脚为上拉模式*/
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
		/*设置引脚速率为2MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; 
		/*调用库函数，使用上面配置的GPIO_InitStructure初始化GPIO*/
		GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);	   
    /*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED2_PIN;	
    GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);	    
    /*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED3_PIN;	
    GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);			
		/*关闭RGB灯*/
		LED_RGBOFF;		
}

RCC.固件库->实现闪烁

main.c

#include "./led/bsp_led.h"
#include "bsp_clkconfig.h"

void Delay(__IO u32 nCount); 

/**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
int main(void)
{
	/*程序来到这里的时候，系统的时钟已经由SystemInit这个函数初始化好了*/
	//User_SetSysClock();
	/*如果开发板的外部晶振不是25M时，修改第一个形参M*/
//HSE_SetSysClock(25,336,2,7);
	HSI_SetSysClock(16, 336, 2, 7);

	//将startup_stm32f40xx.s中系统时钟初始化函数注释掉，系统自动使用HSI作为系统时钟
	
	/* LED 端口初始化 */
	LED_GPIO_Config();
	
	MCO1_GPIO_Config();
	MCO2_GPIO_Config();
	
  RCC_MCO1Config(RCC_MCO1Source_PLLCLK, RCC_MCO1Div_1);
  RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_1);

	/* 控制LED灯 */
	while (1)
	{
		LED1(ON);
		Delay(0xfffff);
		LED1(OFF);
		Delay(0Xfffff);
	}
}

void Delay(__IO uint32_t nCount)	 //简单的延时函数
{
	for(; nCount != 0; nCount--);
}

bsp_clkconfig.c

#include "bsp_clkconfig.h"
#include "stm32f4xx.h"

void User_SetSysClock(void)
{
	RCC_DeInit();//复位RCC的所有寄存器
/******************************************************************************/
/*            PLL (clocked by HSE) used as System clock source                */
/******************************************************************************/
  __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
  
  /* Enable HSE */	//使能HSE
  RCC->CR |= ((uint32_t)RCC_CR_HSEON);
 
  /* Wait till HSE is ready and if Time out is reached exit */
	/*等待HSE启动稳定，如果超时则推出*/
  do
  {
    HSEStatus = RCC->CR & RCC_CR_HSERDY;
    StartUpCounter++;
  } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));

  if ((RCC->CR & RCC_CR_HSERDY) != RESET)
  {
    HSEStatus = (uint32_t)0x01;
  }
  else
  {
    HSEStatus = (uint32_t)0x00;
  }
	/*HSE 启动成功*/
  if (HSEStatus == (uint32_t)0x01)
  {
    /* Select regulator voltage output Scale 1 mode */
    /*选择电压调节器的模式为1*/
		RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    PWR->CR |= PWR_CR_VOS;
		
    /* HCLK = SYSCLK / 1*/
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1;
    /* PCLK2 = HCLK / 2*/
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV2; 
    /* PCLK1 = HCLK / 4*/
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV4;
    /* Configure the main PLL */
    /*配置主PLL*/
//		RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
//                   (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);
			RCC->PLLCFGR = 25 | (336 << 6) | (((2 >> 1) -1) << 16) |
                   (RCC_PLLCFGR_PLLSRC_HSE) | (7 << 24);
    /* Enable the main PLL */
		/*使能主PLL，使能后参数不能更改*/
    RCC->CR |= RCC_CR_PLLON;
    /* Wait till the main PLL is ready */
		/*等待主PLL稳定*/
    while((RCC->CR & RCC_CR_PLLRDY) == 0)
    {}  
    /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    /*配置FLASH预取指，指令缓存，数据缓存，等待周期*/
		FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
    /* Select the main PLL as system clock source */
    /*选择PLL时钟为系统时钟*/
		RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    RCC->CFGR |= RCC_CFGR_SW_PLL;
    /* Wait till the main PLL is used as system clock source */
    /*确保主PLL时钟选为系统时钟*/
		while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
    {}
  }
  else
  { /* If HSE fails to start-up, the application will have wrong clock
         configuration. User can add here some code to deal with this error */
		/*HSE启动失败，在这里添加启动失败的处理代码*/
	}
}

void HSE_SetSysClock(uint32_t PLLM, uint32_t PLLN, uint32_t PLLP, uint32_t PLLQ)
{
	ErrorStatus HSE_ErrorStatus = ERROR;
	RCC_DeInit();
  /* Enable HSE */	//使能HSE
	RCC_HSEConfig(RCC_HSE_ON);
	HSE_ErrorStatus	= RCC_WaitForHSEStartUp();	
	if(HSE_ErrorStatus == SUCCESS)
	{
    /*选择电压调节器的模式为1*/
		RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    PWR->CR |= PWR_CR_VOS;
		RCC_HCLKConfig(RCC_SYSCLK_Div1);
		RCC_PCLK1Config(RCC_SYSCLK_Div4);
		RCC_PCLK2Config(RCC_HCLK_Div2);
		RCC_PLLConfig(RCC_PLLSource_HSE, PLLM, PLLN, PLLP, PLLQ);
		RCC_PLLCmd(ENABLE);		
		while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
		{}		
		/*配置FLASH预取指，指令缓存，数据缓存，等待周期*/
		FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS; 
		/*选择PLL时钟为系统时钟*/
		RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
		while(RCC_GetSYSCLKSource() != 0x08)
		{}
	}
	else
	{
		/*HSE启动失败，在这里添加启动失败的代码*/		
	}
}

void MCO1_GPIO_Config(void)
{
	/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;
		/*开启LED相关的GPIO外设时钟*/
		RCC_AHB1PeriphClockCmd ( RCC_AHB1Periph_GPIOA, ENABLE); 
		/*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;	
		/*设置引脚模式为输出模式*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;      
    /*设置引脚的输出类型为推挽输出*/
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;   
    /*设置引脚为上拉模式*/
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
		/*设置引脚速率为2MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_High_Speed; 
		/*调用库函数，使用上面配置的GPIO_InitStructure初始化GPIO*/
		GPIO_Init(GPIOA, &GPIO_InitStructure);	   
}

void MCO2_GPIO_Config(void)
{
	/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;
		/*开启LED相关的GPIO外设时钟*/
		RCC_AHB1PeriphClockCmd ( RCC_AHB1Periph_GPIOC, ENABLE); 
		/*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;	
		/*设置引脚模式为输出模式*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;      
    /*设置引脚的输出类型为推挽输出*/
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;   
    /*设置引脚为上拉模式*/
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
		/*设置引脚速率为2MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_High_Speed; 
		/*调用库函数，使用上面配置的GPIO_InitStructure初始化GPIO*/
		GPIO_Init(GPIOC, &GPIO_InitStructure);	
    
}

void HSI_SetSysClock(uint32_t PLLM, uint32_t PLLN, uint32_t PLLP, uint32_t PLLQ)
{
	volatile uint32_t HSI_ErrorStatus = 0;
	RCC_DeInit();
  /* Enable HSE */	
	//使能HSI
	RCC_HSICmd(ENABLE);	
	HSI_ErrorStatus = RCC->CR & RCC_CR_HSIRDY;	
	if(HSI_ErrorStatus == RCC_CR_HSIRDY)
	{
    /*选择电压调节器的模式为1*/
		RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    PWR->CR |= PWR_CR_VOS;
		RCC_HCLKConfig(RCC_SYSCLK_Div1);
		RCC_PCLK1Config(RCC_SYSCLK_Div4);
		RCC_PCLK2Config(RCC_HCLK_Div2);	
		RCC_PLLConfig(RCC_PLLSource_HSI, PLLM, PLLN, PLLP, PLLQ);		
		RCC_PLLCmd(ENABLE);		
		while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
		{}		
		/*配置FLASH预取指，指令缓存，数据缓存，等待周期*/
		FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
		/*选择PLL时钟为系统时钟*/
		RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
		while(RCC_GetSYSCLKSource() != 0x08)
		{}
	}
	else
	{
		/*HSI启动失败，在这里添加启动失败的代码*/	
	}
}

bsp_led.c

#include "./led/bsp_led.h"   

 /**
  * @brief  初始化控制LED的IO
  * @param  无
  * @retval 无
  */
void LED_GPIO_Config(void)
{		
		/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;

		/*开启LED相关的GPIO外设时钟*/
		RCC_AHB1PeriphClockCmd ( LED1_GPIO_CLK|
	                           LED2_GPIO_CLK|
	                           LED3_GPIO_CLK, ENABLE); 

		/*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED1_PIN;	

		/*设置引脚模式为输出模式*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   
    
    /*设置引脚的输出类型为推挽输出*/
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
    /*设置引脚为上拉模式*/
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;

		/*设置引脚速率为2MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; 

		/*调用库函数，使用上面配置的GPIO_InitStructure初始化GPIO*/
		GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);	
    
    /*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED2_PIN;	
    GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);	
    
    /*选择要控制的GPIO引脚*/															   
		GPIO_InitStructure.GPIO_Pin = LED3_PIN;	
    GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);	
		
		/*关闭RGB灯*/
		LED_RGBOFF;		
}


标签：Pin,引脚,学习,InitStructure,GPIO,STM32F407,CR,RCC
From： https://blog.51cto.com/u_15929197/6188719

相关文章

  • 《Spring揭秘》-第三章- 学习记录
    掌管大局的IoCServiceProvider虽然业务对象可以通过IoC方式声明相应的依赖，但是最终仍然需要通过某种角色或者服务将这些相互依赖的对象绑定到一起，而IoCServiceProvider就对应IoC场景中的这一角色。IoCServiceProvider在这里是一个抽象出来的概念，它可以代指任何将IoC场景中......
  • 使用Pytorch实现强化学习——DQN算法
    使用Pytorch实现强化学习——DQN算法强化学习的主要构成强化学习主要由两部分组成：智能体（agent）和环境（env）。在强化学习过程中，智能体与环境一直在交互。智能体在环境里面获取某个状态后，它会利用该状态输出一个动作（action）。然后这个动作会在环境之中被执行，环境会根据智能体采取的动......
  • pytest学习笔记
    pytest是python的一种单元测试框架，与python自带的unittest测试框架类似，但是比unittest框架使用起来更简洁，效率更高。根据pytest的官方网站介绍，它具有如下特点：非常容易上手，入门简单，文档丰富，文档中有很多实例可以参考能够支持简单的单元测试和复杂的功能测试支持参数化执行测......
  • springcloud学习——网关
    1.网关的作用如图，微服务之间调用使用的feign帮我们发送请求。当用户需要访问微服务时，就需要网关来帮忙。网关主要实现三大作用：权限控制：网关作为微服务入口，需要校验用户是是否有请求资格，如果没有则进行拦截。路由和负载均衡：一切请求都必须先经过gateway，但网关不处理业务，而是根......
  • 华为认证HCIE Datacom培训理论技术学习关于中队列技术
    华为认证HCIEDatacom培训理论技术学习关于中队列技术关注WOLFLAB网络技术实验室，讲师：崔志鹏，杨广成。关注我，每周都会更新，华为认证WOLFLAB网络技术实验室！华为认证HCIE（1） FIFO：先进先出队列，是单队列技术，不会引入额外延迟，延迟只与队列长度有关，不提供任何差分服务。（2） RR：轮询调度，采用轮询......
  • unicorn 入门学习
    序言最近在学习如何使用自动化脚本解除OLLVM控制流平坦化的混淆时，遇到了一个难题。对于真实块的执行顺序与上下文存在关联时，如何找到真实块间的执行顺序，然后恢复控制流？所幸已经有前辈给出了答案！2022祥云杯CTF中babyparser的题解通过unicorn模拟执行解决。但是没学习过unico......
  • CPU缓存学习
    cpu缓存分为L1cache,L2cache,L3cacheL1为每个cpu独有缓存，L3为几个cpu的共有缓存，所以内存大小L3也是最大相应的L1，L2，L3速度也是由快到慢cpucache从内存读取数据的单位是缓存块(CacheLine)，大小取决于coherency_line_size访问cpucache，需要从cpuline中读取，地址索引由组标记，cpulin......
  • 函数调用栈学习
    栈：在函数调用时，第一个进栈的是主函数中函数调用后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最......
  • 虚幻引擎 4 学习笔记 [1] ：蓝图编程 Demo
    虚幻引擎4学习笔记[1]：蓝图编程Demo​ 最近学习虚幻引擎，主要看的是Siki学院的课，课程链接：Unreal蓝图案例-基础入门-SiKi学院|SiKi学堂-unity|u3d|虚幻|ue4/5|java|python|人工智能|视频教程|在线课程(sikiedu.com)​ 以下为课程笔记：1.创建工程​ 选择蓝图，不带初......
  • ROS学习笔记（二）- 提供服务和调用服务
    书接上回-https://www.cnblogs.com/lihan829/p/17315435.html前面展示了ROS节点发布和订阅消息，这次展示如何提供服务和调用服务。提供服务和调用服务很好理解，概念和行为上并不深奥，就是远程过程调用，可类比为http接口的远程调用，grpc接口的远程调用等等。1，服务提供方，定义服务，服......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99