当前位置： 首页 > article >正文

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

article 2025/3/19 6:15:22

文章目录

  • 1.题目解析
    • 1.1 分而治之，藕断丝连
    • 1.2 模块化思维导图
    • 1.3 模块解析
      • 1.3.1 KEY模块
      • 1.3.2 LED模块
      • 1.3.3 LCD模块
      • 1.3.4 TIM模块
        • 1.3.4.1 频率变化处理
        • 1.3.4.1 占空比计算
      • 1.3.5 ADC模块
  • 2.源码
  • 2.1cubemx配置
  • 3.第十四届题目

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

1.3.2 LED模块

ld1：数据界面亮，否则灭；
ld2：频率切换期间，以0.1s间隔闪烁；
ld3：占空比锁定亮，否则灭；
其他led保持熄灭状态。
解决办法，设置一个标志位代表ld1~ld8，改变对应位的的值，再将标志位写入ODR寄存器中来控制led的亮灭。
具体实现看源码

1.3.3 LCD模块

lcd显示三个界面，注意首次切换的时候得清屏。
根据B1进行三个界面的切换；
状态0：DATA；
在这里插入图片描述

状态1：PARA；
在这里插入图片描述
状态1：RECD。
在这里插入图片描述

具体实现看源码

1.3.4 TIM模块

TIM4产生0.1s时基。PSC：1699，ARR：9999；
TIM2，chn2: 16, 2499 , 4KHzPWM;
TIM3，chn2: 169, 9999, 捕获范围T<=10ms。
PSC和ARR计算公式（计算周期就是频率的倒数）：
在这里插入图片描述

1.3.4.1 频率变化处理
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    tim_100ms ^= 1;
    if(freq_conv_5s != 0){         //频率转换开始
        freq_conv_5s++;
    }
    Hv_2s = Hv_2s < 20 ? Hv_2s+1 : 20;   //最大值保持2s计时
    Lv_2s = Lv_2s < 20 ? Lv_2s+1 : 20;
    if(freq_conv_5s > 1){         //设置对应的输出频率
        if(current_freq_mode == 0){
            current_ARR -= 25;
            TIM2->ARR = current_ARR;
            TIM2->CCR2 = (uint32_t)current_ARR*old_duty;
        }
        else{
            current_ARR += 25;
            TIM2->ARR = current_ARR;
            TIM2->CCR2 = (uint32_t)current_ARR*old_duty;
        }
        if(freq_conv_5s == 51){
            freq_conv_5s = 0;
            current_freq_mode ^= 1;
            conv_N++;
        }
    }
    led_process();
    
    HAL_ADC_Start_IT(&hadc2);
}
1.3.4.1 占空比计算

看图可以知道这是一个分段函数。
在这里插入图片描述
我们可以这样解决

float caculate_duty()
{
    if(adc_smp_volt<=1.0){
        return 0.1;
    }
    else if(adc_smp_volt>1.0 && adc_smp_volt<=3.0){
        return (0.375*adc_smp_volt - 0.275);
    }
    else return 0.85;
}

1.3.5 ADC模块

这里adc采集R37电位器电压，这里就不多说。
具体请看源码

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

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

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

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define PI 3.14
/* 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_wait_pressed,
    key_long_pressed,
};

//记录低频和高频速度
struct{
    float ML_new;
    float MH_new;
    float ML_old;
    float MH_old;
} max_v = {0.0f};
/*
adc_smp_volt: adc采集电压
current_duty: 实时占空比
old_duty: 保持占空比，比如锁定会记录上一次占空比
*/
float adc_smp_volt = 0.0f, current_duty = 0.0f, old_duty = 0.0f;
/*
keys_volt: 按键电平
keys_state: 按键状态
RK_val: 实际起作用的RK值
RK_val_set: 设置时候的RK值
*/
uint8_t keys_volt[4] = {0}, keys_state[4] = {0}, RK_val[2] = {1,1}, RK_val_set[2] = {1,1};
/*
key_redu: 记录消抖时间戳
key_long_2s: 长按时间戳
current_ARR: tim3的arr值
IC_freq: 捕获到的频率
conv_N: 界面三N的值
*/  
uint32_t key_redu = 0, key_long_2s = 0, current_ARR = 2499, IC_freq = 0, conv_N = 0;
/*
lcd_show_conv: 界面切换标志
RK_choose_conv: RK按键切换选择
freq_conv_5s: 切换5s计时
duty_lock: 锁定标志
current_freq_mode: pinlv模式
Hv_2s: 高频速度2s计时
Lv_2s: 低频速度2s计时
lcd_clear_flag: 界面刷新
ld_flag: led控制标志
tim_100ms: 100ms标志
*/  
uint8_t lcd_show_conv = 0, RK_choose_conv = 0,freq_conv_5s = 0, duty_lock = 0, current_freq_mode = 0,
        Hv_2s = 0, Lv_2s = 0, lcd_clear_flag = 0, ld_flag = 0, tim_100ms = 0;
/*
old_IC_val: 采集CCR值，计算频率 
new_IC_val: 采集CCR值
*/
uint16_t old_IC_val = 0, new_IC_val = 0;
//lcd显示
char lcd_str[25] = {0};

void key_state_gain();
void key_process();
void lcd_process();
void led_process();
float caculate_duty();
void caculate_v();

/* 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_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
  /* 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();
  MX_TIM4_Init();
  MX_ADC2_Init();
  /* USER CODE BEGIN 2 */
    HAL_ADCEx_Calibration_Start(&hadc2, ADC_SINGLE_ENDED);
    HAL_TIM_Base_Start_IT(&htim4);
    HAL_TIM_PWM_Start_IT(&htim2, TIM_CHANNEL_2);
    HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_2);
    HAL_ADC_Start_IT(&hadc2);
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
      key_state_gain();
      key_process();
      caculate_v();
      lcd_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_BOOST);

  /** 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_DIV6;
  RCC_OscInitStruct.PLL.PLLN = 85;
  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_4) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */
//获取按键状态
void key_state_gain()
{
    keys_volt[0] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
    keys_volt[1] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    keys_volt[2] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
    keys_volt[3] = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
    for(uint8_t i=0;i<4;i++){
        if(keys_volt[i] == 0){
            if(keys_state[i] == key_released){
                key_redu = HAL_GetTick();
                keys_state[i] = key_reduction;
            }
            else if(keys_state[i] == key_reduction){
                if(HAL_GetTick()-key_redu>=10){
                    keys_state[i] = key_short_pressed;
                    key_long_2s = HAL_GetTick();
                }   
            }
            else if(keys_state[i] == key_short_pressed){
                keys_state[i] = key_wait_pressed;
            }
            else if(keys_state[i] == key_wait_pressed){
                if(HAL_GetTick() - key_long_2s>=2000){
                    keys_state[i] = key_long_pressed;
                }
            }
            else if(keys_state[i] == key_long_pressed){
                keys_state[i] = key_wait_pressed;
            }
        }
        else{
            if(keys_state[i] == key_short_pressed || keys_state[i] == key_wait_pressed ||
                            keys_state[i] == key_long_pressed){
                keys_state[i] = key_reduction;
                key_redu = HAL_GetTick();             
            }
            else if(keys_state[i] == key_reduction){
                if(HAL_GetTick()-key_redu>=10){
                    keys_state[i] = key_released;
                }   
            }
        }
    }
}
//根据按键状态设置对应标志位
void key_process()
{
    if(keys_state[0] == key_short_pressed){
        lcd_show_conv = lcd_show_conv!=2 ? lcd_show_conv+1 : 0;
        if(lcd_show_conv == 2){
            RK_val[0] = RK_val_set[0];
            RK_val[1] = RK_val_set[1];
        }
    }
    if(keys_state[1] == key_short_pressed){
        if(lcd_show_conv == 0){
            if(freq_conv_5s == 0){
                freq_conv_5s = 1;
                old_duty = current_duty;
            }   
        }
        else if(lcd_show_conv == 1){
            RK_choose_conv ^= 1;
        }
    }
    if(keys_state[2] == key_short_pressed){
        if(lcd_show_conv == 1){
            RK_val_set[RK_choose_conv] = RK_val_set[RK_choose_conv]<10?RK_val_set[RK_choose_conv]+1:10;
        }
    }
    if(keys_state[3] == key_short_pressed){
        if(lcd_show_conv == 1){
            RK_val_set[RK_choose_conv] = RK_val_set[RK_choose_conv]>1?RK_val_set[RK_choose_conv]-1:1;
        }
        duty_lock = 0;
    }
    if(keys_state[3] == key_long_pressed){
        duty_lock = 1;
        old_duty = current_duty;
    }
}
//lcd显示
void lcd_process()
{
    switch(lcd_show_conv){
        case 0:
            if(lcd_clear_flag == 2){
                LCD_Clear(Black);
                lcd_clear_flag = 0;
            }
            LCD_DisplayStringLine(Line1, (uint8_t*)"        DATA      ");
            if(current_freq_mode == 0) 
                sprintf(lcd_str, "     M=L  ");
            else 
                sprintf(lcd_str, "     M=H  ");
            LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
            if(duty_lock == 1 || freq_conv_5s != 0) {
                sprintf(lcd_str, "     P=%d%%    ", (int)(old_duty*100));
            }
            else 
                sprintf(lcd_str, "     P=%d%%     ", (int)(current_duty*100));
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            
                sprintf(lcd_str, "     V=%.1f      ", (float)IC_freq*PI*RK_val[0]/50.0/RK_val[1]);
            LCD_DisplayStringLine(Line5, (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, "     R=%hhu     ", RK_val_set[0]);
            LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     K=%hhu     " , RK_val_set[1]);
            LCD_DisplayStringLine(Line4, (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, "     N=%u     ", conv_N);
            LCD_DisplayStringLine(Line3, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     MH=%.1f    ", max_v.MH_old);
            LCD_DisplayStringLine(Line4, (uint8_t*)lcd_str);
            sprintf(lcd_str, "     ML=%.1f     ", max_v.ML_old);
            LCD_DisplayStringLine(Line5, (uint8_t*)lcd_str);
            break;
    }
}
//led处理
void led_process()
{
    if(lcd_show_conv == 0){
        ld_flag = 1;
    }else ld_flag = 0;
    if(freq_conv_5s!=0){
        ld_flag += tim_100ms << 1;
    }
    if(duty_lock == 1){
        ld_flag += 1<<2;
    }
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2,1);
    GPIOC->ODR = 0xffff ^ ld_flag << 8;
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2,0);
}

//计算占空比
float caculate_duty()
{
    if(adc_smp_volt<=1.0) return 0.1;
    else if(adc_smp_volt>1.0 && adc_smp_volt<3.0) return 0.375*adc_smp_volt - 0.275;
    else return 0.85;
}

//计算速度最大值
void caculate_v(){
    static float maxl = 0, maxh = 0;
    if(maxh != max_v.MH_new){
        Hv_2s = 0;
        maxh = max_v.MH_new;
    }
    else{
        if(Hv_2s == 20 && max_v.MH_old < maxh){
            max_v.MH_old = maxh;
        }
    }
    if(maxl != max_v.ML_new){
        Lv_2s = 0;
        maxl = max_v.ML_new;
    }
    else{
        if(Lv_2s == 20 && max_v.ML_old < maxl){
            max_v.ML_old = maxl;
        }
    }
}

void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
{
    if(duty_lock == 1){  //锁定状态占空比不变
        TIM2->CCR2 = (uint32_t)current_ARR*old_duty;
    }
    else{ 
        TIM2->CCR2 = (uint32_t)current_ARR*current_duty;
    }
}

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    new_IC_val = TIM3 -> CCR2;    //采集ccr值
    if(new_IC_val > old_IC_val){   
        IC_freq = 100*10000/(new_IC_val - old_IC_val);  //f2 = f1的arr /f2的arr * f1
    }
    else{
        IC_freq = 100*10000/(new_IC_val + 10000 - old_IC_val);
    }
    old_IC_val = new_IC_val;
    if(current_freq_mode == 0){           //根据模式计算更新速度最大值
        max_v.ML_new = (float)IC_freq*PI*RK_val[0]/50.0/RK_val[1];
    }else max_v.MH_new = (float)IC_freq*PI*RK_val[0]/50.0/RK_val[1];
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    tim_100ms ^= 1;
    if(freq_conv_5s != 0){         //频率转换开始
        freq_conv_5s++;
    }
    Hv_2s = Hv_2s < 20 ? Hv_2s+1 : 20;   //最大值保持2s计时
    Lv_2s = Lv_2s < 20 ? Lv_2s+1 : 20;
    if(freq_conv_5s > 1){         //设置对应的输出频率
        if(current_freq_mode == 0){
            current_ARR -= 25;
            TIM2->ARR = current_ARR;
            TIM2->CCR2 = (uint32_t)current_ARR*old_duty;
        }
        else{
            current_ARR += 25;
            TIM2->ARR = current_ARR;
            TIM2->CCR2 = (uint32_t)current_ARR*old_duty;
        }
        if(freq_conv_5s == 51){
            freq_conv_5s = 0;
            current_freq_mode ^= 1;
            conv_N++;
        }
    }
    led_process();
    
    HAL_ADC_Start_IT(&hadc2);
}

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
{
    adc_smp_volt = HAL_ADC_GetValue(hadc)*3.3/4096;
    current_duty = caculate_duty();
}
/* 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.第十四届题目

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


http://www.kler.cn/a/590781.html

相关文章：

  • 【一起来学kubernetes】17、Configmap使用详解
  • 程序包jakarta.annotation不存在
  • 求余在程序设计中的用处
  • Netty基础—Netty实现消息推送服务
  • IntelliJ IDEA 调试技巧指南
  • apache-maven-3.9.9 详细安装配置教程（2025版）
  • 散货拼柜业务，如何管理多个客户和供应商的财务账单？
  • Android audio(8)-native音频服务的启动与协作（audiopolicyservice和audioflinger）
  • Linux 入门：权限的认识和学习
  • ThreadPoolExecutor 源码分析
  • 【设计模式】3W 学习法深入剖析创建型模式：原理、实战与开源框架应用（含 Java 代码）
  • 电动车出入库管理软件，电动车维修保养售后服务管理系统，佳易王电动车店管理系统操作教程
  • OpenResty/Lua 编码指南/指南
  • 7、vue3做了什么
  • 3.17学习总结
  • vue3 引入element-plus组件后，发现输入的时候没有提示，而且鼠标移到el-button显示unknown的简单解决方法
  • 4.angular 服务
  • SpringBoot第三站：配置嵌入式服务器使用外置的Servlet容器
  • 【软件系统架构】单体架构
  • Android Fresco 框架兼容模块源码深度剖析(六)