蓝桥杯嵌入式组第十五届省赛题目解析+STM32G431RBT6实现源码

已于 2025-04-09 16:46:33 修改
阅读量932 收藏 10
点赞数 16
分类专栏： 单片机 文章标签： 蓝桥杯 stm32 c语言 单片机 学习
于 2025-03-19 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80754203/article/details/146313352
版权

文章目录


前言：STM32G431RBT6实现嵌入式组第十五届题目解析+源码，本文默认读者具备基础的stm32知识。文章末尾附有第十五届题目。

1.题目解析

1.1 分而治之，藕断丝连

还是那句话，将不同模块进行封装，通过变量进行模块间的合作。
函数将模块分而治之，变量使模块间藕断丝连。

1.2 模块化思维导图

下图根据题目梳理。还是使用思维导图。
在这里插入图片描述

1.3 模块解析

1.3.1 KEY模块

还是控制按一次处理一次。老朋友了我们就不多说了，题目限制了按键消抖和单次处理，所以我们要加上消抖，和前几届的一样。
正常按键逻辑：
开始按下—>按下—>释放；
但是题目要求得按一次处理一次，根据代码逻辑加了一种等待释放状态
根据机械按键的特性开始和结束都得消抖，加上按一次执行一次，所以我们的处理逻辑是：
开始按下—>按下消抖—>短按—>等待弹起—>长按—>弹起—>弹起消抖—>释放；
为了实现按一次执行一次，中间加了一个等待弹起状态（key_state_gain()函数获取到按键状态，key_state_set()设置按键对应按键涉及标志位，下一次进入到key_state_gain()函数中，按键状态就变成了等待弹起状态，这就保证了，短按长按只执行key_state_set()一次）
这里主要说逻辑，具体看源码

if(按键按下){
	if(是否是释放状态){					//开始按下
		进入消抖状态，开始消抖计时
	}
	else if(是否是消抖状态){    			//按下消抖
		if(当前时间-消抖计时>=消抖时长){
			消抖完成，进入按下状态
		}
	}
	else if(是否是短按状态 || 是否是长按状态){				//等待弹起状态
		等待释放状态
		记录长按1s开始时间
	}
	else if(是否是等待状态){              //长按实现
		if(时间达到1s) 长按状态
	}
}
else{//没有按下
	if(是否是等待释放或者按下状态){		//弹起
		进入消抖状态，开始消抖计时
	}
	else if(是否是消抖状态){				//弹起消抖
		if(当前时间-消抖计时>=消抖时长){
			消抖完成，按键释放
		}
	}
}

1.3.2 LED模块

ld1：数据界面亮，否则灭；
ld2：fA>PH,亮，否则灭；
ld3：fA>PH,亮，否则灭；
ld4：NDA>=3||NDB>=3亮，否则灭；
其他保持灭。
解决办法，设置一个标志位代表ld1~ld8，改变对应位的的值，再将标志位写入ODR寄存器中来控制led的亮灭。
具体实现看源码

1.3.3 LCD模块

lcd显示三个界面，注意首次切换的时候得清屏。
根据B1进行三个界面的切换；
状态0：DATA；
状态1：PARA；
状态1：RECD。

具体实现看源码

1.3.4 TIM模块

TIM2：799， 9999，0.1时基；
TIM3，chn2: 19, 39999，采集400Hz~20KHz之间的频率PB4；
TIM8，chn2: 19, 39999，采集400Hz~20KHz之间的频率PA15。
PSC和ARR计算公式（计算周期就是频率的倒数）：
在这里插入图片描述

2.源码

我所有的实现都在main.c文件中。

2.1cubemx配置

在这里插入图片描述

/* 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"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "stdlib.h"
#include "lcd.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

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

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
enum{                //按键的几种状态枚举
    key_released = 0U,
    key_reduction,
    key_short_pressed,   
    key_short_wait_released,   //目的短按执行一次
    key_long_pressed,
    key_long_wait_released,    //目的长按执行一次
};     
typedef struct{    //参数界面三个变量
    int PD;
    int PH;
    int PX;
}para_t;
para_t para = {1000, 5000, 0};

typedef struct{   //记录界面四个变量
    int NDA;
    int NDB;
    int NHA;
    int NHB;
}recd_t;    
recd_t recd = {0};

typedef struct{     //输入捕获计算频率
    uint32_t new_val;    //记录当前CCR的值
    uint32_t old_val;    //记录上一次CCR的值
    float freq;          //0.1s更新一次频率
    float update_freq;    //每次捕获到的频率
}freq_t;
freq_t freqA = {0}, freqB = {0};

/*
key_state: 按键状态
key_volt: 按键电平
*/
uint8_t key_state[4] = {0}, key_volt[4] = {0};       
/*
key_redu: 按键消抖时间戳
key_1s_tim: 按键长按时间戳
A_100ms_t: A频率100ms更新时间戳
B_100ms_t: B频率100ms更新时间戳
lcd_100ms_tim: lcd100ms刷新时间戳
*/
uint32_t key_redu = 0, key_1s_tim = 0, A_100ms_t = 0, B_100ms_t = 0, lcd_100ms_tim = 0;
/*
para_conv_flag: 参数切换标志
lcd_conv_flag: lcd界面切换标志
FT_conv_flag: 频率周期切换标志
lcd_clear_flag: lcd界面切换清屏标志
*/
uint8_t para_conv_flag = 0, lcd_conv_flag = 0, FT_conv_flag = 0, lcd_clear_flag = 0; 

//lcd显示
char lcd_str[21] = {0};

/*
获取按键状态标志
释放-->按下消抖-->短按-->短按等待-->长按-->长按等待-->弹起消抖-->释放
*/
void gain_key_state()
{
    key_volt[0] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
    key_volt[1] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    key_volt[2] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
    key_volt[3] = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
    for(uint8_t i=0;i<4;i++)
    {
        if(key_volt[i] == 0)
        {
            if(key_state[i] == key_released){
                key_redu = HAL_GetTick();
                key_state[i] = key_reduction;
            }
            else if(key_state[i] == key_reduction){
                if(HAL_GetTick() - key_redu>=10){
                    key_state[i] = key_short_pressed;
                }
            }
            else if(key_state[i] == key_short_pressed){
                key_1s_tim = HAL_GetTick();
                key_state[i] = key_short_wait_released;
            }
            else if(key_state[i] == key_short_wait_released){
                if(HAL_GetTick()-key_1s_tim >=1000){
                    key_state[i] = key_long_pressed;
                }
            }
            else if(key_state[i] == key_long_pressed){
                key_state[i] = key_long_wait_released;
            }
        }
        else{
           if(key_state[i] != key_reduction && key_state[i] != key_released) {
                key_redu = HAL_GetTick();
               key_state[i] = key_reduction;
           }
           else if(key_state[i] == key_reduction){
                if(HAL_GetTick() - key_redu>=10){
                    key_state[i] = key_released;
                }
           }
        }
    }
}

//根据按键状态设置对应标志
void key_process()
{
    if(key_state[0] == key_short_pressed){     //B1参数累加
        if(para_conv_flag == 0){
            para.PD = para.PD < 1000 ? para.PD+100 : 1000;
        }
        else if(para_conv_flag == 1){
            para.PH = para.PH < 10000 ? para.PH+100 : 10000;
        }
        else{
            para.PX = para.PX < 1000 ? para.PX+100 : 1000;
        }
    }
    else if(key_state[1] == key_short_pressed){   //B1参数累减
        if(para_conv_flag == 0){
            para.PD = para.PD > 100 ? para.PD-100 : 100;
        }
        else if(para_conv_flag == 1){
            para.PH = para.PH > 1000 ? para.PH-100 : 1000;
        }
        else{
            para.PX = para.PX > -1000 ? para.PX-100 : -1000;
        }
    }
    else if(key_state[2] == key_short_pressed){    
        if(lcd_conv_flag == 0){    //数据界面FT转换
            FT_conv_flag ^= 1;
        }
        else if(lcd_conv_flag == 1){    //参数界面参数转换
            para_conv_flag = para_conv_flag !=2 ? para_conv_flag+1 : 0;
        }
    }
    else if(key_state[2] == key_long_pressed){    //B3长按记录界面参数清0
        recd.NDA = 0; recd.NDB = 0; recd.NHA = 0; recd.NHB = 0;
    }
    else if(key_state[3] == key_short_pressed){    //B4界面切换，对应回到界面默认状态
        lcd_conv_flag = lcd_conv_flag !=2 ? lcd_conv_flag+1 : 0;
        para_conv_flag = 0;
        FT_conv_flag = 0;
    }
}

void lcd_process()
{
    switch(lcd_conv_flag)
    {
        case 0:     //数据界面
            if(lcd_clear_flag == 2){
                LCD_Clear(Black);
                lcd_clear_flag = 0;
            }
            LCD_DisplayStringLine(Line1, (uint8_t*)"        DATA      ");
            if(FT_conv_flag == 0){
                if(freqA.freq < 0) sprintf(lcd_str, "     A=NULL     ");
                else if(freqA.freq > 1000) sprintf(lcd_str, "     A=%.2fKHz   ", freqA.freq/1000.0);
                else sprintf(lcd_str, "     A=%dHz      ", (int)freqA.freq);
                LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
                if(freqB.freq < 0) sprintf(lcd_str,"     B=NULL      ");
                else if(freqB.freq > 1000) sprintf(lcd_str, "     B=%.2fKHz   ", freqB.freq/1000.0);
                else sprintf(lcd_str, "     B=%dHz     ", (int)freqB.freq);
                LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            }
            
            else{
                if(freqA.freq < 0) sprintf(lcd_str, "     A=NULL      ");
                else if(1000.0/freqA.freq > 1) sprintf(lcd_str, "     A=%.2fmS      ", 1000.0/freqA.freq);
                else sprintf(lcd_str, "     A=%duS       ", 1000000/(int)freqA.freq);
                LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
                if(freqB.freq < 0) sprintf(lcd_str, "     B=NULL      ");
                else if(1000.0/freqB.freq > 1) sprintf(lcd_str, "     B=%.2fmS      ", 1000.0/freqB.freq);
                else sprintf(lcd_str, "     B=%duS      ", 1000000/(int)freqB.freq);
                LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            }
            
            break;
        case 1:    //参数界面
            if(lcd_clear_flag == 0){
                LCD_Clear(Black);
                lcd_clear_flag = 1;
            }
            LCD_DisplayStringLine(Line1, (uint8_t*)"        PARA      ");
            sprintf(lcd_str, "     PD=%dHz      ", para.PD);
            LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     PH=%dHz      ", para.PH);
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     PX=%dHz      ", para.PX);
            LCD_DisplayStringLine(Line5, (uint8_t*)lcd_str);
            break;
        case 2:     //记录界面
            if(lcd_clear_flag == 1){
                LCD_Clear(Black);
                lcd_clear_flag = 2;
            }
            LCD_DisplayStringLine(Line1, (uint8_t*)"        RECD      ");
            sprintf(lcd_str, "     NDA=%u     ", recd.NDA);
            LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     NDB=%u     ", recd.NDB);
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     NHA=%u      ", recd.NHA);
            LCD_DisplayStringLine(Line5, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     NHB=%u      ", recd.NHB);
            LCD_DisplayStringLine(Line6, (uint8_t*)lcd_str);
            break;
    }
}

/*
A_3s_data: A通道3s时间窗口记录数据
B_3s_data: B通道3s时间窗口记录数据
*/
float A_3s_data[30] = {0.0}, B_3s_data[30] = {0.0};
uint8_t A_cnt = 0, B_cnt = 0;    //记录采集数据

//对应数组中添加数据
void add_freq(float *arr, float freq, uint8_t *cnt)
{
    arr[*cnt] = freq;
    (*cnt)++;
}

//寻找最大最小值
uint8_t find_min_max(float *arr)
{
    float min = arr[0], max = arr[0];
    for(uint8_t i=1;i<30;i++){
        if(arr[i] < min) min = arr[i];
        else if(arr[i] > max) max = arr[i]; 
    }
    if((int)(max - min) > para.PD) return 1;
    return 0;
}

//A/B通道突变记录一次限制标志
uint8_t A_PH_flag = 0, B_PH_flag = 0;

void recd_process()
{
    if((int)freqA.freq > para.PH && A_PH_flag == 0){
        A_PH_flag = 1;
        recd.NHA++;
    }
    else if((int)freqA.freq < para.PH) A_PH_flag = 0;
    if((int)freqB.freq > para.PH && B_PH_flag == 0){
        B_PH_flag = 1;
        recd.NHB++;
    }
    else if((int)freqB.freq < para.PH) B_PH_flag = 0;
    if(A_cnt == 30){
        A_cnt = 0;
        if(find_min_max(A_3s_data)) recd.NDA++;
        for(uint8_t i=0;i<30;i++){
            A_3s_data[i] = 0.0;
        }
    }
    if(B_cnt == 30){
        B_cnt = 0;
        if(find_min_max(B_3s_data)) recd.NDB++;
        for(uint8_t i=0;i<30;i++){
            B_3s_data[i] = 0.0;
        }
    }
}

//led状态
uint8_t led_flag = 0;

//led处理
void led_process()
{
    if(lcd_conv_flag == 0) led_flag = 1;
    else led_flag = 0;
    if(freqA.freq > para.PH) led_flag += 1<<1;
    if(freqB.freq > para.PH) led_flag += 1<<2;
    if(recd.NDA >= 3 || recd.NDB >= 3) led_flag += 1<<7;
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 1);
    GPIOC->ODR = 0xffff ^ led_flag << 8;
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, 0);
}


void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim){  
    if(htim == &htim2) //pa15
    {   
        freqA.new_val = TIM2->CCR1;
        if(freqA.new_val > freqA.old_val){
           freqA.update_freq =  20000.0/(freqA.new_val-freqA.old_val)*200;
        }
        else{
            freqA.update_freq =  20000.0/(19999+freqA.new_val-freqA.old_val)*200;
        }
        freqA.old_val = freqA.new_val;
        if(HAL_GetTick()-A_100ms_t>=100){
           freqA.freq =  freqA.update_freq+para.PX;
            if(A_cnt < 30) add_freq(A_3s_data, freqA.freq, &A_cnt);
            A_100ms_t = HAL_GetTick();
        }
    }
    if(htim == &htim3){       //pb4
        freqB.new_val = TIM3->CCR1;
        if(freqB.new_val > freqB.old_val){
           freqB.update_freq =  20000.0/(freqB.new_val-freqB.old_val)*200;
        }
        else{
            freqB.update_freq =  20000.0/(19999+freqB.new_val-freqB.old_val)*200;
        }
        freqB.old_val = freqB.new_val;
        if(HAL_GetTick()-B_100ms_t>=100){
           freqB.freq =  freqB.update_freq+para.PX;
            if(B_cnt < 30) add_freq(B_3s_data, freqB.freq, &B_cnt);
            B_100ms_t = HAL_GetTick();
        }
    }
}

/* 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 */
    LCD_Init();
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
    LCD_Clear(Black);
  /* 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_TIM2_Init();
  MX_TIM3_Init();
  /* USER CODE BEGIN 2 */
    HAL_TIM_IC_Start_IT(&htim2, TIM_CHANNEL_1);
    HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_1);
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
     gain_key_state();
      key_process();
      if(HAL_GetTick()-lcd_100ms_tim>=100){
          lcd_process();
          recd_process();
          lcd_100ms_tim = HAL_GetTick();
      }
      led_process();
  }
  /* 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_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV3;
  RCC_OscInitStruct.PLL.PLLN = 20;
  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();
  }
}

/* USER CODE BEGIN 4 */

/* 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 */

3.第十五届题目

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值