保姆级教学——蓝桥杯嵌入式入门真题——第十三届省赛程序设计试题及解析

最新推荐文章于 2025-04-15 18:08:11 发布
最新推荐文章于 2025-04-15 18:08:11 发布
阅读量2.1k 收藏 61
点赞数 54
文章标签： 蓝桥杯 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79871905/article/details/146265459
版权

文末有项目工程源文件！

第十三届嵌入式程设计与开发程序题

试题解析

（1）CubeMx基础配置

第一步，进入cubemx后打开RCC中的HSE(高速时钟)，设置为如图所示。

第二步，配置时钟。按照往届蓝桥杯嵌入式的规则，我们需要使用80MHz作为单片机的主频，所以此处可以在HCLK处直接修改为80后，按下回车键（Enter键），系统会自动调整和配置，最后再把Input frequency改写为24。最终效果如图所示。

第三步，设置好项目工程的路径和编译软件。此处需要格外注意，博主本人经过多次实验得出结论：在cubemx设置好了文件路径之后，一但将文件文件位置移动（或者是重命名），工程是打不开的。我强烈建议各位在开始写代码之前多加留心此处，避免后续重新创建工程带来的不必要的麻烦。

配置完路径之后，在下方的Toolchain/IDE中间编译器改为MDK_ARM，也就是我们熟悉的Keil进行编写。完成即可点击右上方的GENERATE CODE。之后会跳出弹窗，可以选择通过点击弹窗进入keil的项目工程，或者关闭后直接在刚刚设置的文件保持路径中寻找工程。

（2）按键部分

cubemx

蓝桥杯的按键1到4分别对应着PB0，PB1，PB2，PA0这四个口，都设置为Input即可。

代码

int key_scan(void)
{
	char gpio_state = 0;
	if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_0) == GPIO_PIN_RESET){gpio_state = 1;}
	else if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){gpio_state = 2;}
	else if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_2) == GPIO_PIN_RESET){gpio_state = 3;}
	else if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET){gpio_state = 4;}
  else
	{
		gpio_state = 0;
	}
	return gpio_state;
}

int key_pro(void)
{
	unsigned char Key_down,Key_now;
	static unsigned Key_last = 0;
	
	Key_now = key_scan();
	Key_down = Key_now & (Key_now^Key_last);
	Key_last = Key_now;
	
	return Key_down;
}

这段代码分为两个函数，实现了按键扫描与消抖处理的功能。

key_scan()函数
  • 功能：扫描指定的 GPIO 引脚，判断是否有按键被按下，并返回按键对应的编号。
  • 步骤：
    1. 初始化变量 gpio_state 为 0，表示没有按键按下。
    2. 依次检查 GPIOB 的 0 - 2 引脚和 GPIOA 的 0 引脚。使用 HAL_GPIO_ReadPin 函数读取引脚电平，若为低电平（GPIO_PIN_RESET），则认为对应按键被按下，将 gpio_state 设为相应编号（1 - 4）。
    3. 如果所有检查的引脚都不是低电平，将 gpio_state 保持为 0。
    4. 返回 gpio_state。
key_pro()函数
  • 功能：对 key_scan 函数的结果进行处理，识别按键的按下动作，实现简单的消抖。
  • 步骤：
    1. 定义两个局部变量 Key_down 和 Key_now，以及一个静态变量 Key_last 用于记录上一次的按键状态。静态变量只会初始化一次，后续调用函数时会保留上一次的值。
    2. 调用 key_scan 函数获取当前按键状态，存储在 Key_now 中。
    3. 通过位运算 Key_now & (Key_now^Key_last) 计算按键按下状态。Key_now^Key_last 得到两次状态的差异，再与 Key_now 相与，能筛选出当前按下且上一次未按下的按键。
    4. 更新 Key_last 为当前按键状态 Key_now，以便下一次使用。
    5. 返回 Key_down，表示当前新按下的按键。

（3）LED灯

cubemx

PC8到PC15对应着LED1到LED8这8个LED，PD2是控制LED的锁存器开关。以上这些IO口全部配置相同，具体配置内容如图所示。

代码

void changeAllLedByNumber(char ledstate)
{
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|
	GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15,(ledstate==1?GPIO_PIN_RESET:GPIO_PIN_SET));
	
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
	
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
}

void changeLedStateByLocation(uint16_t LEDLOCATION,char ledstate)
{
	HAL_GPIO_WritePin(GPIOC,LEDLOCATION,(ledstate==1?GPIO_PIN_RESET:GPIO_PIN_SET));
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
}
changeAllLedByNumber 函数
  • 功能：根据传入的参数 ledstate 控制 GPIOC 端口的 8 个引脚（GPIO_PIN_8 到 GPIO_PIN_15）连接的 LED 灯的亮灭状态。
  • 参数：
    • ledstate：一个字符型变量，用于指定 LED 灯的状态。当 ledstate 为 1 时，LED 灯点亮；当 ledstate 不为 1 时，LED 灯熄灭。
changeLedStateByLocation 函数
  • 功能：根据传入的参数 LEDLOCATION 和 ledstate 控制 GPIOC 端口指定引脚连接的 LED 灯的亮灭状态。
  • 参数：
    • LEDLOCATION：一个 16 位无符号整数，用于指定要控制的 LED 灯所连接的 GPIOC 端口的引脚。
    • ledstate：一个字符型变量，用于指定 LED 灯的状态。当 ledstate 为 1 时，LED 灯点亮；当 ledstate 不为 1 时，LED 灯熄灭。

对于蓝桥杯来说，基本上使用以上这两个LED函数就足以完成所有LED相关的功能，剩下的就是题目要求的一些逻辑处理。

（4）定时器(PWM和内部触发时钟)

cubemx

PWM的配置

图中的PSC代表的是分频系数，ARR的自动重装载值。因为我们设置的主频为80Mhz,所以此处为了便于后续参数调整，我们使用79（80 - 1）作为分频系数。(Pulse + 1) / (Center Period + 1)为初始设置的占空比大小。此处如果有不懂的建议看这位博主的PWM入门教学，讲的十分清楚：【STM32】HAL库——定时器PWM输出_hal库pwm输出-CSDN博客

内部触发时钟（博主最爱的操作）

内部触发时钟的意义和system_tick差不多，但是区别在于内部触发时钟的中断响应频率可以自由设置。Center Period表示的是一个技术周期，初始默认从0开始向上计数，当加到Center Period的数值时，就会触发定时器的一个溢出中断。如图所示，当前的中断触发频率为 f = 80 000 000 / (79 + 1) / (999 + 1) = 1000Hz，在程序中我们调用对应定时器的中断回调函数（作为内部触发时钟的定时器是任意的），即可实现动态的函数执行频率控制，具体操作在代码部分有讲解。

代码

此处我重点介绍内部触发时钟的代码操作

//定时器中断回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) // 1ms
{
	static u16 tim_tick = 0;
	tim_tick++;
	if(tim_tick % 20 == 0)//0.02s,50Hz
  {
		led_flag = 1;
		pwm_flag = 1;
	}
	if(tim_tick % 25 == 0)//0.025s,40Hz
	{
		operate_flag = 1;//OS
		if(pwmled_flag == 1)
		{
			if(++pwmled_count>=200){pwmled_flag = 0;pwmled_count = 0;show->page = 1;}//倒计时5s后，清空计数和标志位，将页面切换回1
		}
	}
	if(tim_tick % 50 == 0)//0.05s,20Hz
	{
		display_flag = 1;//LCD
	}
	if(tim_tick >= 100)//0.1s,10Hz
	{
		if(led_flash_flag == 1)//led2
		{
			led_toggle = 1 - led_toggle;
			if(++led_flash_count >= 50){led_flash_flag = 0;led_flash_count = 0;led_toggle = 1;}//倒计时5s后，清空标志位和计数值，同时刷新led_toggle
		}
		tim_tick = 0;
	}
}

                                                               中断回调函数

定时器厨房中断后最终会进入中断回调函数中，我们可以利用配置好的1ms一次（1000Hz）的中断响应频率进行资源的分配。如图所示，例如，对于LCD的刷新操作，我可以利用标志位，使得控制为每50ms给display_flag(LCD)赋值为1。具体什么是标志位，标志位有什么用，大家在此处先别急，之后我将逐步讲述清楚标志位的工作流程。我们目前只需要知道，我们可以根据题目的要求，设定合适的触发时间，只要对应功能的标志位赋值为1，相应的功能就能完成一次操作。

（5）串口通信

cubemx

串口的配置相对来说比较简单。将Mode改为Asynchronous,再讲波特率调整为题目所需即可（此处要求为9600）。有一点需要特别注意，如果题目要求使用串口实现电脑与单片机的通信，串口一的RX和TX需要改为PA9和PA10（直接开启串口一默认不是这两个引脚，但是原理图中是配置的这两个引脚）。

代码

int fputc(int ch, FILE *f)
{
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
  return ch;
}

                                                           串口重定向函数

这里的核心代码就是串口重定向函数。简单的说，通过串口重定向，我们可以使用我们在c语言在常用的printf函数对数据进行传输，使用方法也是十分类似。这里要注意两点：第一，使用串口重定向需要引入头文件stdio.h；第二，需要勾选keil中的Use MircoLIB才能有效果，位置在keil的target(小锤子)中，如图所示。

（6）LCD

LCD无需cubemx配置，蓝桥杯官方的驱动中写好了配置，大家只需要正确导入对应的c，h文件即可（三个文件：lcd.c  lcd.h  font.h）

代码

//LCD初始化
	LCD_Init();
	LCD_Clear(Black);
	LCD_SetBackColor(Black);
	LCD_SetTextColor(White);

LCD_Init是LCD初始化配置。

LCD_Clear是将当前屏幕内容清除并填充为括号内的颜色。

SetBackColor是设置背景颜色。

SetTextColor是设置字体颜色。

（7）界面操作系统

void Os_operate(void)
{
	if(operate_flag == 1)
	{
		char key_state = 0;
		operate_flag = 0;
		key_state = key_pro();
		switch(key_state)
		{
			case 1:
			{
				if(count_flag_1 == 1)
        {
					if(++password->mima_1 >= 10){password->mima_1 = 0;}//保证输入的密码位在0到9之间循环
				}
				else if(count_flag_1 == 0)//1.初次上电 或者 2.重新回到页面1 或者 3.密码输入失败
        {
				  count_flag_1 = 1;//进入密码调整状态
					password->mima_1 = 0;
				}
				break;
			}
			case 2:
			{
				if(count_flag_2 == 1)
        {
					if(++password->mima_2 >= 10){password->mima_2 = 0;}
				}
				else if(count_flag_2 == 0)
        {
				  count_flag_2 = 1;
					password->mima_2 = 0;
				}
				break;
			}
			case 3:
			{
				if(count_flag_3 == 1)
        {
					if(++password->mima_3 >= 10){password->mima_3 = 0;}
				}
				else if(count_flag_3 == 0)
        {
				  count_flag_3 = 1;
					password->mima_3 = 0;
				}
				break;
			}
      case 4:
			{
				result_config();//密码判断
				if(password_result == 1)
        {
				  show->page = 2;
				  pwmled_flag = 1;
				}
				else if(password_result == 0)
				{
					if(++error_count >= 3){led_flash_flag = 1;error_count = 0;}
				}
				count_flag_1 = 0;//清空刚刚的密码输入状态
				count_flag_2 = 0;
				count_flag_3 = 0;
				password->mima_1 = 0;//清空刚刚的密码输入
				password->mima_2 = 0;
				password->mima_3 = 0;
				break;
			}
			default:
			{
				break;
			}
		}
	}
}

在这里首先把标志位的概念进行完善。正如之前所提到的，中断回调函数可以让各功能的标志位按照对应频率赋1。那么，当赋值为1后，各个函数的最外层if语句的逻辑才可以被顺利执行。换句话说，在标志位没有被赋值为1之前，这些功能函数就算一直执行，也无法执行对应的功能，相应的，也就不会占用单片机的资源。这里有个问题，就是哪里可以让我的代码一直执行呢？那么聪明的宝宝可能已经猜到了，是的，我们的所有功能操作函数最终都将被放在while(1)主循环中一直执行。

打个比方来说，while(1)循环里执行的函数像等红灯时的一辆辆汽车，汽车不会熄火，发动机也一直在响应，只是这个时候并没有时间的动作发生。当绿灯亮起，油门踩下，车辆才开始移动。从代码的执行角度，这种红绿灯的引入可以让代码有条不紊的进行，在多种功能的组合使用时显得更加重要。

这里还有一点需要注意，当标志位为1且以及进入对应函数的执行阶段时，注意要及时关闭标志位，避免造成不必要的麻烦。

（8）main函数代码

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2025 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
#define u8 unsigned char
#define u16 unsigned int
#define u32 unsigned long
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
struct Display*show;
struct mima*password;
struct Pwm*pwm_data;
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim3;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */
int fputc(int ch, FILE *f)
{
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
  return ch;
}
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM3_Init(void);
/* USER CODE BEGIN PFP */
void System_Init(void);
void Display(void);
void Os_operate(void);
void result_config(void);
void pwm_config(void);
void led_config(void);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
u8 operate_flag = 0;
u8 display_flag = 0;
u8 count_flag_1 = 0;
u8 count_flag_2 = 0;
u8 count_flag_3 = 0;
u8 pwm_flag = 0;
u8 led_flag = 0;
u8 pwmled_flag = 0;
u8 led_flash_flag = 0;
u8 led_toggle = 1;//一但触发，应该先亮再灭的闪烁
u8 pwmled_count = 0;
u8 led_flash_count = 0;
u8 error_count = 0;
u8 password_result = 0;
char ucRxbuff[7] = {0};
char mimabox_1[2] = {0};
char mimabox_2[2] = {0};
char mimabox_3[2] = {0};
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_TIM2_Init();
  MX_TIM3_Init();
  /* USER CODE BEGIN 2 */
  System_Init();
	printf("hello\r\n");
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		Os_operate();
		Display();
		pwm_config();
		led_config();
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV1;
  RCC_OscInitStruct.PLL.PLLN = 10;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief TIM2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM2_Init(void)
{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 80-1;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 999;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 499;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */
  HAL_TIM_MspPostInit(&htim2);

}

/**
  * @brief TIM3 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM3_Init(void)
{

  /* USER CODE BEGIN TIM3_Init 0 */

  /* USER CODE END TIM3_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 80-1;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 999;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */

  /* USER CODE END TIM3_Init 2 */

}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 9600;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * @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_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
                          |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12, GPIO_PIN_SET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);

  /*Configure GPIO pins : PC13 PC14 PC15 PC8
                           PC9 PC10 PC11 PC12 */
  GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
                          |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pin : KEY4_Pin */
  GPIO_InitStruct.Pin = KEY4_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(KEY4_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : KEY1_Pin KEY2_Pin KEY3_Pin */
  GPIO_InitStruct.Pin = KEY1_Pin|KEY2_Pin|KEY3_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  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_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

//系统初始化函数
void System_Init(void)
{
	//LCD初始化
	LCD_Init();
	LCD_Clear(Black);
	LCD_SetBackColor(Black);
	LCD_SetTextColor(White);
	
	//关闭所有LED灯
	changeAllLedByNumber(OFF);
	
	//打开串口
	HAL_UART_Receive_IT(&huart1,(uint8_t *)&ucRxbuff,sizeof(ucRxbuff));
	
	//结构体初始化
	show = (struct Display*)malloc(sizeof(struct Display));//根据结构体大小分配内存
	password = (struct mima*)malloc(sizeof(struct mima));
	pwm_data = (struct Pwm*)malloc(sizeof(struct Pwm));
	
	//LCD显示页数
	show->page = 1;
	
	//按键调整的输入密码
	password->mima_1 = 0;
	password->mima_2 = 0;
	password->mima_3 = 0;
	
	//正确的密码
	password->mima_true_1 = 1;
	password->mima_true_2 = 2;
	password->mima_true_3 = 3;
	
	//PWM的频率和占空比
	pwm_data->fre = 1000;
	pwm_data->duty = 50;
	
	//定时器时钟初始化
	HAL_TIM_Base_Start_IT(&htim3);
	
	//开启PWM
	HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
}

//LCD显示函数
void Display(void)
{
	char temp[20];
	if(display_flag == 1)
	{
		display_flag = 0;
		if(show->page == 1)
		{
				LCD_DisplayStringLine(Line1,(uint8_t*)"       PSD  ");
			
			  if(count_flag_1 == 1){sprintf(temp,"    B1:%d    ",password->mima_1);}
				else if(count_flag_1 == 0){sprintf(temp,"    B1:@     ");}
				LCD_DisplayStringLine(Line3,(uint8_t*)temp);
				 
				if(count_flag_2 == 1){sprintf(temp,"    B2:%d    ",password->mima_2);}
				else if(count_flag_2 == 0){sprintf(temp,"    B2:@     ");}
				LCD_DisplayStringLine(Line4,(uint8_t*)temp);
				
				if(count_flag_3 == 1){sprintf(temp,"    B3:%d    ",password->mima_3);}
				else if(count_flag_3 == 0){sprintf(temp,"    B3:@     ");}
				LCD_DisplayStringLine(Line5,(uint8_t*)temp);
		}
		else if(show->page == 2)
		{
			LCD_DisplayStringLine(Line1,(uint8_t*)"       STA  ");
			sprintf(temp,"    F:%dHz   ",pwm_data->fre);
			LCD_DisplayStringLine(Line3,(uint8_t*)temp);
			sprintf(temp,"    D:%d%%   ",pwm_data->duty);//连用两个百分号是强制打印一个百分号
			LCD_DisplayStringLine(Line4,(uint8_t*)temp);
			sprintf(temp,"             ");//用空白进行覆盖
			LCD_DisplayStringLine(Line5,(uint8_t*)temp);
		}
	}
}

//操作系统处理函数
void Os_operate(void)
{
	if(operate_flag == 1)
	{
		char key_state = 0;
		operate_flag = 0;
		key_state = key_pro();
		switch(key_state)
		{
			case 1:
			{
				if(count_flag_1 == 1)
        {
					if(++password->mima_1 >= 10){password->mima_1 = 0;}//保证输入的密码位在0到9之间循环
				}
				else if(count_flag_1 == 0)//1.初次上电 或者 2.重新回到页面1 或者 3.密码输入失败
        {
				  count_flag_1 = 1;//进入密码调整状态
					password->mima_1 = 0;
				}
				break;
			}
			case 2:
			{
				if(count_flag_2 == 1)
        {
					if(++password->mima_2 >= 10){password->mima_2 = 0;}
				}
				else if(count_flag_2 == 0)
        {
				  count_flag_2 = 1;
					password->mima_2 = 0;
				}
				break;
			}
			case 3:
			{
				if(count_flag_3 == 1)
        {
					if(++password->mima_3 >= 10){password->mima_3 = 0;}
				}
				else if(count_flag_3 == 0)
        {
				  count_flag_3 = 1;
					password->mima_3 = 0;
				}
				break;
			}
      case 4:
			{
				result_config();//密码判断
				if(password_result == 1)
        {
				  show->page = 2;
				  pwmled_flag = 1;
				}
				else if(password_result == 0)
				{
					if(++error_count >= 3){led_flash_flag = 1;error_count = 0;}
				}
				count_flag_1 = 0;//清空刚刚的密码输入状态
				count_flag_2 = 0;
				count_flag_3 = 0;
				password->mima_1 = 0;//清空刚刚的密码输入
				password->mima_2 = 0;
				password->mima_3 = 0;
				break;
			}
			default:
			{
				break;
			}
		}
	}
}

//密码判断函数
void result_config(void)
{
	if((password->mima_1 == password->mima_true_1) && (password->mima_2 == password->mima_true_2) && (password->mima_3 == password->mima_true_3))
	{
		password_result = 1;
	}
	else
	{
		password_result = 0;
	}
}

//PWM判断函数
void pwm_config(void)
{
	if(pwm_flag == 1)
	{
		pwm_flag = 0;
		if(pwmled_flag == 1)
		{
			pwm_data->duty = 10;
			pwm_data->fre = 2000;
			__HAL_TIM_SetAutoreload(&htim2,500-1);//2kHz
			__HAL_TIM_SetCompare(&htim2,TIM_CHANNEL_2,50-1);//10%
		}
		else
		{
			pwm_data->duty = 50;
			pwm_data->fre = 1000;
			__HAL_TIM_SetAutoreload(&htim2,1000-1);//1kHz
			__HAL_TIM_SetCompare(&htim2,TIM_CHANNEL_2,500-1);//50%
		}
	}
}

void led_config(void)
{
	if(led_flag == 1)
	{
		led_flag = 0;
		changeAllLedByNumber(OFF);
		
		if(pwmled_flag == 1)
		{
			changeLedStateByLocation(LED1,ON);
		}
		else
		{
			changeLedStateByLocation(LED1,OFF);
		}
		
		if(led_flash_flag == 1)
		{
			if(led_toggle == 1){changeLedStateByLocation(LED2,ON);}
			else if(led_toggle == 0){changeLedStateByLocation(LED2,OFF);}
		}
	}
}

//定时器中断回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) // 1ms
{
	static u16 tim_tick = 0;
	tim_tick++;
	if(tim_tick % 20 == 0)//0.02s,50Hz
  {
		led_flag = 1;
		pwm_flag = 1;
	}
	if(tim_tick % 25 == 0)//0.025s,40Hz
	{
		operate_flag = 1;//OS
		if(pwmled_flag == 1)
		{
			if(++pwmled_count>=200){pwmled_flag = 0;pwmled_count = 0;show->page = 1;}//倒计时5s后，清空计数和标志位，将页面切换回1
		}
	}
	if(tim_tick % 50 == 0)//0.05s,20Hz
	{
		display_flag = 1;//LCD
	}
	if(tim_tick >= 100)//0.1s,10Hz
	{
		if(led_flash_flag == 1)//led2
		{
			led_toggle = 1 - led_toggle;
			if(++led_flash_count >= 50){led_flash_flag = 0;led_flash_count = 0;led_toggle = 1;}//倒计时5s后，清空标志位和计数值，同时刷新led_toggle
		}
		tim_tick = 0;
	}
}

//串口接收中断回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance == USART1)//串口一接收
  {
		sprintf(mimabox_1,"%d",password->mima_true_1);
		sprintf(mimabox_2,"%d",password->mima_true_2);
		sprintf(mimabox_3,"%d",password->mima_true_3);
    if((ucRxbuff[0] == mimabox_1[0]) && (ucRxbuff[1] == mimabox_2[0]) && (ucRxbuff[2] == mimabox_3[0])) 
    {
			password->mima_true_1 = ucRxbuff[4] - '0';
			password->mima_true_2 = ucRxbuff[5] - '0';
			password->mima_true_3 = ucRxbuff[6] - '0';
			printf("%d\r\n",password->mima_true_1);
			printf("%d\r\n",password->mima_true_2);
			printf("%d\r\n",password->mima_true_3);
    }
    HAL_UART_Receive_IT(&huart1, (uint8_t*)ucRxbuff, sizeof(ucRxbuff)); 
  }
}
/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

项目工程文件

主打一个开源共享，一起进步。

通过网盘分享的文件：shengsai_13.zip
链接: https://pan.baidu.com/s/19LEb8qbN3v4hjwiA7zbzMA?pwd=1732 提取码: 1732

可以照搬使用我的代码，但如果用于参加比赛或者其他公开使用，请务必私信联系我，并表明出处。

多数UP主讲错的超声波测距编写——蓝桥杯单片机模块保姆式教学最完整版3
zhenghuangjie的博客
04-05 916
超声波测距不要再模拟方波啦
13 万字 C 语言从入门到精通保姆级教程2021 年版
热门推荐
李南江
06-07 61万+
13 万字C语言保姆级教程，从入门到精通。
第十三届蓝桥杯嵌入式省赛真题
04-10
第一部分 客观试题（15分） 1）在STM32系列微控制器中，可以作为主时钟MCO输出的时钟源是（ ）。 A. HSI B. HSE C. SYSCLK D. HSE/2 2）三态门的输出状态包括（ ）。 A.高电平 B.低电平 C.模拟输出 D.高阻态 …… 第二部分 程序设计试题（85分） 3. 功能要求 3.1 功能概述. 1) 支持通过串口设定3位密码。 2) 通过竞赛板上的B1到B3按键，输入0-9密码值，通过B4按键确认密码。 3)通过PA1 引脚完成控制信号输出功能。 4)依试题要求，
蓝桥杯第十六届嵌入式省赛真题
最新发布
蓝桥杯嵌入式讲解，帮你一周拿奖，两周冲刺国赛。
04-15 1258
这里先发布蓝桥杯第十六届嵌入式省赛真题，后续会发布整理完成的程序代码，确保功能能完全实现，且讲述清晰。
第十三届蓝桥杯嵌入式国赛真题(基于HAL库的巨简代码＋超级详解)
关于你的一切我都在意
06-21 2万+
开发板：CT117E-M4(STM32G431RBT6) 开发环境： CubeMX+Keil5 涉及题目：第十三届蓝桥杯嵌入式国赛真题 难点：双路AD测量电压、输入捕获测频率、LCD屏幕翻转、冒泡法、初始上电判断、按键长短按
蓝桥杯嵌入式第十三届省赛真题1
qq_51663309的博客
05-02 2137
目录1 题目2 分析3 项目结构3.1 LCD显示部分3.2 按键控制部分3.3 密码部分3.4 LED部分3.5 数据处理部分3.6 PWM控制部分3.7 Systick中断部分3.8 主函数While(1) 1 题目 2 分析 总的来说是一道逻辑非常简单的题目，整体的难度都比较低。看到后马上就能想到思路的那种。只有一部分的小细节需要注意 源码在这各位可以随意下载，最好帮我点个star嘛 我的思路是 把三位密码拆成三个变量，省的到时候取个数，十位数，百位数比较麻烦。 通过按键的输入进入不同
蓝桥杯嵌入式历年真题.zip
04-20
蓝桥杯嵌入式真题
保姆级教学：从0搭建微信小程序SpringBoot+Vue(二) 对应前端Vue源码资源
12-04
本文将是一篇保姆级的教学指南，旨在帮助初学者快速理解并实践微信小程序的开发流程。 首先，需要对SpringBoot和Vue.js有基本的了解。SpringBoot是一种基于Spring框架的开源Java平台，它为快速搭建独立的、生产级别...
Xilinx FPGA PCIe 保姆级教程 ——基于 PCIe XDMA IP核.zip(毕设&课设&实训&大作业&竞赛&项目
09-21
【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目...
蓝桥杯嵌入式保姆级总结。
2301_79958007的博客
04-06 703
​（避免死机、数据错误）​。
蓝桥杯嵌入式历年赛题汇总
02-14
包含历年蓝桥杯嵌入式的试题，资料全面，包含客观题以及程序题。
2022 十三届 蓝桥杯省赛 嵌入式组真题（客观+程序设计）
04-09
2022 十三届 蓝桥杯省赛 嵌入式组真题（客观+程序设计）
蓝桥杯第十三届嵌入式省赛真题及答案
04-10
蓝桥杯第十三届嵌入式省赛真题及答案
蓝桥杯嵌入式13届省赛题
06-01
蓝桥杯嵌入式13届省赛题
2024年蓝桥杯嵌入式真题
04-13
2024年蓝桥杯嵌入式真题
蓝桥杯嵌入式第十三届省赛题目解析
qq_53221728的博客
04-07 5411
新版开发板（G431）蓝桥杯嵌入式第十三届 客观题，主观题解析。 程序设计题目的解析，CubeMX的配置以及全部代码演示。 还有蓝桥杯历年的比赛题目和解析喔。
【蓝桥杯嵌入式】蓝桥杯第十届省赛真题，程序题全解析（含代码）
勾栏听曲_0的博客
03-30 6802
蓝桥杯第十届省赛真题，蓝桥杯嵌入式第十届省赛真题，ADC模数转换，LCD高亮选择，各模块解析，完整题目分析。功能模块描述，注意事项分析，整体代码设计思路。
【蓝桥杯嵌入式】第十三届蓝桥杯嵌入式省赛真题P2
Cx330Biao的博客
02-16 640
用于学习蓝桥杯嵌入式第十三届省赛真题P2
蓝桥杯 嵌入式历年 真题
01-04
### 蓝桥杯嵌入式类别历年真题概述 蓝桥杯竞赛中的嵌入式项目涵盖了多个不同年份的真题，这些题目不仅考察参赛者的理论基础，还测试实际编程能力。对于希望深入了解历届比赛情况的学生来说，有几项资源特别有用。 #### 第十四届省赛程序真题分析 针对第十四届的比赛，已经提供了详细的程序真题解析和代码讲解[^1]。这包括对原理图的具体解释、各个功能模块的工作机制探讨以及完整的试题解答过程。特别是考虑到该年度使用的特定微控制器型号——STM32G431RBT6，在此版本中也进行了相应的技术调整和技术说明更新[^2]。 #### 客观题部分 除了编程实践外，还有专门针对客观题的部分提供了解析文档。例如第八届（2017年）的省级赛事就有关于如何处理基于旧款MCU的问题集锦；而到了更近期的第十五届，则记录了一位参赛者对自己错误点的经验分享和个人反思，这对于后来的学习者具有很高的参考价值[^3]。 通过上述资料可以了解到，蓝桥杯嵌入式的历年真题覆盖广泛的主题领域，并且随着硬件平台的变化不断更新其内容以适应最新的技术和教学需求。 ```python # 示例：获取并打印某一年度的真题列表 (伪代码) def fetch_exam_questions(year): questions = get_questions_from_database(year) # 获取指定年的所有问题 for q in questions: print(f"Question ID:{q.id}, Description: {q.description}") fetch_exam_questions(2023) # 假设要查看2023年的真题 ```
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值