蓝桥杯嵌入式第10届真题(完成) STM32G431

蓝桥杯嵌入式第10届真题(完成) STM32G431

题目

main.c

c 复制代码
/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "adc.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "led.h"
#include "key.h"
#include "myadc.h"
#include "stdbool.h"
#include "stdio.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
int8_t upled = 0x01;
int8_t uplednum = 1;
int8_t lowled = 0x02;
int8_t lowlednum = 2;
float upval = 2.4;
float lowval = 1.2;
float val;
uint32_t led1time = 0;
uint32_t led2time = 0;
uint8_t led1enable = 0;//开关
uint8_t led2enable = 0;
uint8_t view = 0;
uint8_t lcdtext[30];
uint8_t status[30];
extern struct Key key[4];
/* 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 */
void led_process(void);
void lcd_process(void);
void adc_process(void);
void key_process(void);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void lcdclear(void)
{
	 LCD_Clear(Black);
   LCD_SetBackColor(Black);
   LCD_SetTextColor(White);
}
/* 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_ADC2_Init();
  MX_TIM2_Init();
  /* USER CODE BEGIN 2 */
		HAL_TIM_Base_Start_IT(&htim2);
    LCD_Init();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */

    lcdclear();

   
		led_display(0x00);
    while (1)
    {
			key_process();
			adc_process();
			lcd_process();
			led_process();
    /* USER CODE END WHILE */
		 
    
			
    /* USER CODE BEGIN 3 */
    }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {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_DIV2;
  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();
  }
  /** Initializes the peripherals clocks
  */
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC12;
  PeriphClkInit.Adc12ClockSelection = RCC_ADC12CLKSOURCE_SYSCLK;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */
void led_process(void)
{
    static bool led1flag = false;
    static bool led2flag = false;
    uint32_t currentTick = HAL_GetTick(); // 获取当前的系统时刻

    if(led1enable && (currentTick - led1time >= 200))
    {
        led1time = currentTick; // 更新时间戳
        led1flag = !led1flag; // 切换标志状态
        if(led1flag)
        {
            led_display(upled); // 点亮LED
        }
        else
        {
            led_display(0x00); // 熄灭LED
        }
    }

    if(led2enable && (currentTick - led2time >= 200))
    {
        led2time = currentTick; // 更新时间戳
        led2flag = !led2flag; // 切换标志状态
        if(led2flag)
        {
            led_display(lowled); // 点亮LED
        }
        else
        {
            led_display(0x00); // 熄灭LED
        }
    }
}

void lcd_process(void)
{
	switch(view)
	{
		case 0:
		{
			sprintf((char *)lcdtext,"        Main");
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext,"  Volt:%.2f",val);
			LCD_DisplayStringLine(Line4,lcdtext);
			sprintf((char *)lcdtext,"  Status:%s",status);
			LCD_DisplayStringLine(Line6,lcdtext);
		}break;
		case 1:
		{
			sprintf((char *)lcdtext,"        Setting");
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext," Max Volt:%.2f",upval);
			LCD_DisplayStringLine(Line3,lcdtext);
			sprintf((char *)lcdtext," Min Volt:%.2f",lowval);
			LCD_DisplayStringLine(Line5,lcdtext);
			sprintf((char *)lcdtext," Upper:LD%d",uplednum);
			LCD_DisplayStringLine(Line7,lcdtext);
			sprintf((char *)lcdtext," Lower:LD%d",lowlednum);
			LCD_DisplayStringLine(Line9,lcdtext);
		}break;
		case 2://maxval
		{
			sprintf((char *)lcdtext,"        Setting");
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext," Max Volt:%.2f",upval);
			LCD_SetBackColor(Green);
			LCD_DisplayStringLine(Line3,lcdtext);
			LCD_SetBackColor(Black);
			sprintf((char *)lcdtext," Min Volt:%.2f",lowval);
			LCD_DisplayStringLine(Line5,lcdtext);
			sprintf((char *)lcdtext," UpperLD:%d",uplednum);
			LCD_DisplayStringLine(Line7,lcdtext);
			sprintf((char *)lcdtext," Lower:LD%d",lowlednum);
			LCD_DisplayStringLine(Line9,lcdtext);
		}break;
		case 3://minval
		{
			sprintf((char *)lcdtext,"        Setting");
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext," Max Volt:%.2f",upval);
			LCD_DisplayStringLine(Line3,lcdtext);
			sprintf((char *)lcdtext," Min Volt:%.2f",lowval);
			LCD_SetBackColor(Green);
			LCD_DisplayStringLine(Line5,lcdtext);
			LCD_SetBackColor(Black);
			sprintf((char *)lcdtext," Upper:LD%d",uplednum);
			LCD_DisplayStringLine(Line7,lcdtext);
			sprintf((char *)lcdtext," Lower:LD%d",lowlednum);
			LCD_DisplayStringLine(Line9,lcdtext);
		}break;
		case 4://led1
		{
			sprintf((char *)lcdtext,"        Setting");
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext," Max Volt:%.2f",upval);
			LCD_DisplayStringLine(Line3,lcdtext);
			sprintf((char *)lcdtext," Min Volt:%.2f",lowval);
			LCD_DisplayStringLine(Line5,lcdtext);
			sprintf((char *)lcdtext," Upper:LD%d",uplednum);
			LCD_SetBackColor(Green);
			LCD_DisplayStringLine(Line7,lcdtext);
			LCD_SetBackColor(Black);
			sprintf((char *)lcdtext," Lower:LD%d",lowlednum);
			LCD_DisplayStringLine(Line9,lcdtext);
		}break;
		case 5://led2
		{
			sprintf((char *)lcdtext,"        Setting");
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext," Max Volt:%.2f",upval);
			LCD_DisplayStringLine(Line3,lcdtext);
			sprintf((char *)lcdtext," Min Volt:%.2f",lowval);
			LCD_DisplayStringLine(Line5,lcdtext);
			sprintf((char *)lcdtext," Upper:LD%d",uplednum);
			LCD_DisplayStringLine(Line7,lcdtext);
			sprintf((char *)lcdtext," Lower:LD%d",lowlednum);
			LCD_SetBackColor(Green);
			LCD_DisplayStringLine(Line9,lcdtext);
			LCD_SetBackColor(Black);
		}break;
	}
}
void adc_process(void)
{
	
	val = getADcVal(&hadc2);
	if(val>upval)
	{
		led1enable = 1;
		led2enable = 0;
		sprintf((char *)status,"Upper ");
	}else if(val<=upval&&val>=lowval)
	{
		led1enable = 0;
		led2enable = 0;
		led_display(0x00);
		sprintf((char *)status,"Normal ");
	}else{
		led1enable = 0;
		led2enable = 1;
		sprintf((char *)status,"Lower ");
	}
}
void key_process(void)
{
	
	if(key[0].key_single_flag)
	{
		lcdclear();
		key[0].key_single_flag = 0;
		if(view==0)
		{
			view = 1;
		}else if(view==1||view==2||view==3||view==4||view==5)
		{
			view = 0;
		}
	}
	
	if(key[1].key_single_flag)
	{
		lcdclear();
		key[1].key_single_flag = 0;
		if(view==1)
		{
			view = 2;
		
		}else if(view>=2&&view<=5)
		{
			view++;
			if(view>5)
				view = 2;
		}
		
	}
	
	if(key[2].key_single_flag) {
		key[2].key_single_flag = 0; // 清除按键标志位
		
		if(view == 4) { // 选择upled
				uplednum = (uplednum % 8) + 1; // 循环遍历1到8
				upled = 0x01 << (uplednum - 1); // 更新upled位掩码
		} else if(view == 5) { // 选择lowled
				lowlednum = (lowlednum % 8) + 1; // 循环遍历1到8
				lowled = 0x01 << (lowlednum - 1); // 更新lowled位掩码
		}
	}

	if(key[3].key_single_flag) {
			key[3].key_single_flag = 0; // 清除按键标志位
			if(view == 4) { // 选择upled
					uplednum = (uplednum == 1) ? 8 : uplednum - 1; // 反向循环遍历8到1
					upled = 0x01 << (uplednum - 1); // 更新upled位掩码
			} else if(view == 5) { // 选择lowled
					lowlednum = (lowlednum == 1) ? 8 : lowlednum - 1; // 反向循环遍历8到1
					lowled = 0x01 << (lowlednum - 1); // 更新lowled位掩码
			}
	}

	

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

  /* 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,
       tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */



/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

key.c

c 复制代码
#include "key.h"

struct Key key[4]={0,0,0,0};
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance==TIM2)
	{
		key[0].key_gpio = HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_0);
		key[1].key_gpio = HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1);
		key[2].key_gpio = HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_2);
		key[3].key_gpio = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0);
		for(int i = 0;i<4;i++)
		{
			switch(key[i].key_status)
			{
				case 0:
				{
					if(key[i].key_gpio==0)
					{
						key[i].key_status = 1;
					}
				}break;
				case 1:
				{
					if(key[i].key_gpio==0)
					{
						key[i].key_single_flag = 1;
						key[i].key_status = 2;
					}else{
						key[i].key_status = 0;
					}
				}break;
				case 2:
				{
					if(key[i].key_gpio==1)
					{
						key[i].key_status = 0;
					}
				}break;
			}
		}
	}
}

led.c

c 复制代码
#include "led.h"


void led_display(uint8_t led)
{
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_All,GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
	HAL_GPIO_WritePin(GPIOC,led<<8,GPIO_PIN_RESET);
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,GPIO_PIN_RESET);
}

myadc.c

c 复制代码
#include "myadc.h"
float getADcVal(ADC_HandleTypeDef *hadc)
{
	float val;
	HAL_ADC_Start(hadc);
	val = HAL_ADC_GetValue(hadc);
	return val*3.3f/4096;

}
相关推荐
LateBloomer77712 分钟前
FreeRTOS——信号量
笔记·stm32·学习·freertos
wenchm1 小时前
细说STM32单片机DMA中断收发RTC实时时间并改善其鲁棒性的另一种方法
stm32·单片机·嵌入式硬件
茶猫_2 小时前
力扣面试题 - 25 二进制数转字符串
c语言·算法·leetcode·职场和发展
Rstln5 小时前
【DP】个人练习-Leetcode-2019. The Score of Students Solving Math Expression
算法·leetcode·职场和发展
嵌新程5 小时前
day03(单片机高级)RTOS
stm32·单片机·嵌入式硬件·freertos·rtos·u575
Lin2012305 小时前
STM32 Keil5 attribute 关键字的用法
stm32·单片机·嵌入式硬件
电工小王(全国可飞)6 小时前
STM32 RAM在Memory Map中被分为3个区域
stm32·单片机·嵌入式硬件
maxiumII6 小时前
Diving into the STM32 HAL-----DAC笔记
笔记·stm32·嵌入式硬件
陪学8 小时前
百度遭初创企业指控抄袭,维权还是碰瓷?
人工智能·百度·面试·职场和发展·产品运营
时光の尘9 小时前
C语言菜鸟入门·关键字·float以及double的用法
运维·服务器·c语言·开发语言·stm32·单片机·c