【STM32G431RBTx】备战蓝桥杯嵌入式→省赛试题→第七届

已于 2023-04-04 20:52:56 修改
阅读量360 收藏 6
点赞数 1
文章标签： 蓝桥杯 stm32 单片机
于 2023-01-28 18:40:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66792436/article/details/128774191
版权

文章目录

前言

无

一、题目

在这里插入图片描述

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

二、模块初始化

1.LCD这里不用配置，直接使用提供的资源包就行
2.KEY, 四个按键IO口都要配置，分别是PB0, PB1,PB2,PA0依次是B0,B1,B2,B3不要弄错了
3.LED:开启PC8,PC9,PC10,PD2输出模式就行了。
4.定时器:TIM3(按键消抖定时器):PSC:80-1,ARR:10000-1,TIM4(控制ADC每秒采集):PSC:80-1,ARR:10000-1,TIM6(控制LED闪烁):PSC:80-1,ARR:10000-1
5.ADC:PB15作为ADC2IN15通道，开启single-ended模式。
6.EEPROM:PB6,PB7输出模式。

三、代码实现

bsp组中共有:在这里插入图片描述
在这里只展示interrupt.h,interrupt.h,main.c,main.h的代码，其他文件的代码可到基本模块篇获取。
interrupt.h:

#ifndef __INTERRUPT_H__
#define __INTERRUPT_H__

#include "main.h"
#include "stdbool.h"

struct keys
{
	bool key_sta;
	unsigned char judge_sta;
	bool single_flag;
	unsigned int key_time;
	bool long_flag;
};

#endif

interrupt.c:

#include "interrupt.h"
#include "usart.h"
#include "badc.h"
#include "adc.h"

unsigned char RxBuffer[30];
unsigned char BufIndex = 0;
unsigned char Rxdat = 0;

extern unsigned char completeADCflag;
extern unsigned int globalADC;
extern unsigned char ADCTime;

extern unsigned char nowLevel;
extern unsigned char nowHeight;

extern unsigned char LED;

extern unsigned char TimeLD1;
extern unsigned char TimeLD2;
extern unsigned char TimeLD3;
extern unsigned char LD1Type;
extern unsigned char LD2Type;
extern unsigned char LD3Type;
extern unsigned char LevelChangeFlag;
extern unsigned char CheckDataFlag;

unsigned char LD2count;
unsigned char LD3count;

unsigned int adc[4];

struct keys key[4] = {0, 0, 0, 0, 0};

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance == USART1)
	{
		RxBuffer[BufIndex++] = Rxdat;
		HAL_UART_Receive_IT(huart, &Rxdat, 1);
	}
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == TIM3)
	{
		key[0].key_sta = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
		key[1].key_sta = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
		key[2].key_sta = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
		key[3].key_sta = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
		
		for(unsigned char i = 0; i < 4; i++)
		{
			switch(key[i].judge_sta)
			{
				case 0:
				{
					if(key[i].key_sta == 0)
					{
						key[i].judge_sta = 1;
						key[i].key_time = 0;
					}
					break;
				}
				case 1:
				{
					if(key[i].key_sta == 0)
					{
						key[i].judge_sta = 2;
					}
					else
					{
						key[i].judge_sta = 0;
					}
					break;
				}
				case 2:
				{
					if(key[i].key_sta == 1)
					{
						key[i].judge_sta = 0;
						if(key[i].key_time <= 80)
						{
							key[i].single_flag = 1;
						}
					}
					else
					{
						key[i].key_time++;
						if(key[i].key_time > 80)
						{
							key[i].long_flag = 1;
						}
					}
					break;
				}
			}
		}
	}
	if(htim->Instance == TIM4)
	{
		ADCTime++;
		if(ADCTime == 25)
		{
			adc[0] = getADC(&hadc2);
		}
		else if(ADCTime == 50)
		{
			adc[1] = getADC(&hadc2);
		}
		else if(ADCTime == 75)
		{
			adc[2] = getADC(&hadc2);
		}
		else if(ADCTime == 100)
		{
			ADCTime = 0;
			adc[3] = getADC(&hadc2);
			globalADC = (adc[0] + adc[1] + adc[2] + adc[3]) / 4;
			completeADCflag = 1;
			nowHeight = (unsigned char)(globalADC / 4096.0 * 100);

		}
	}
	if(htim->Instance == TIM6)
	{
		if(1)
		{
			TimeLD1++;
			if(TimeLD1 == 100)
			{
				LD1Type = !LD1Type;
				LED = LED & 0xfe | (LD1Type << 0);
				TimeLD1 = 0;
			}
		}
		if(LevelChangeFlag == 1)
		{
			TimeLD2++;
			if(TimeLD2 == 20)
			{
				LD2Type = !LD2Type;
				LED = LED & 0xfd | (LD2Type << 1);
				TimeLD2 = 0;
				LD2count++;
				if(LD2count == 10)
				{
					LD2count = 0;
					LevelChangeFlag = 0;
				}
			}
		}
		if(CheckDataFlag == 1)
		{
			TimeLD3++;
			if(TimeLD3 == 20)
			{
				LD3Type = !LD3Type;
				LED = LED & 0xfb | (LD3Type << 2);
				TimeLD3 = 0;
				LD3count++;
				if(LD3count == 10)
				{
					LD3count = 0;
					CheckDataFlag = 0;
				}
			}
		}
	}
}

main.h:

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.h
  * @brief          : Header for main.c file.
  *                   This file contains the common defines of the application.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 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 */

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __MAIN_H
#define __MAIN_H

#ifdef __cplusplus
extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "stm32g4xx_hal.h"

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

/* USER CODE END Includes */

/* Exported types ------------------------------------------------------------*/
/* USER CODE BEGIN ET */

/* USER CODE END ET */

/* Exported constants --------------------------------------------------------*/
/* USER CODE BEGIN EC */

/* USER CODE END EC */

/* Exported macro ------------------------------------------------------------*/
/* USER CODE BEGIN EM */

/* USER CODE END EM */

/* Exported functions prototypes ---------------------------------------------*/
void Error_Handler(void);

/* USER CODE BEGIN EFP */

/* USER CODE END EFP */

/* Private defines -----------------------------------------------------------*/
/* USER CODE BEGIN Private defines */
#define DATA 0
#define PARA 1
/* USER CODE END Private defines */

#ifdef __cplusplus
}
#endif

#endif /* __MAIN_H */

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

main.c:

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 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 "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "interrupt.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "lcd.h"
#include "i2c.h"
#include "led.h"
#include "badc.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 */
extern unsigned char RxBuffer[30];
extern unsigned char BufIndex;
extern unsigned char Rxdat;
extern struct keys key[4];
unsigned int globalADC;
unsigned char ADCTime;
unsigned char completeADCflag;
unsigned char nowLevel;
unsigned char nowHeight;
unsigned char StoreThreshold[3] = {10, 20, 30};
unsigned char displayMode;
unsigned char SettingIndex;
unsigned char tempLevel;
unsigned char LED = 0x00;
unsigned char TimeLD1;
unsigned char TimeLD2;
unsigned char TimeLD3;
unsigned char LD1Type;
unsigned char LD2Type;
unsigned char LD3Type;
unsigned char LevelChangeFlag;
unsigned char CheckDataFlag;
unsigned char InitFlag = 1;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
void Rx_Proc(void);
void DisposeKey(void);
void LCD_Display(void);
void Judge_Level(void);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 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_ADC2_Init();
  MX_TIM3_Init();
  MX_TIM4_Init();
  MX_TIM6_Init();
  /* USER CODE BEGIN 2 */
	HAL_UART_Receive_IT(&huart1, &Rxdat, 1);
	HAL_TIM_Base_Start_IT(&htim3);
	HAL_TIM_Base_Start_IT(&htim4);
	HAL_TIM_Base_Start_IT(&htim6);
	LCD_Init();
	LCD_Clear(Black);
	LCD_SetBackColor(Black);
	LCD_SetTextColor(White);
	StoreThreshold[0] = eeprom_read(0x01);
	StoreThreshold[1] = eeprom_read(0x02);
	StoreThreshold[2] = eeprom_read(0x03);
	globalADC = getADC(&hadc2);
	nowHeight = (unsigned char)(globalADC / 4096.0 * 100);
	Judge_Level();
	tempLevel = nowLevel;
	HAL_Delay(1000);
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
		if(BufIndex != 0)
		{
			unsigned char temp = BufIndex;
			HAL_Delay(1);
			if(temp == BufIndex)
			{
				Rx_Proc();
			}
		}
		DisposeKey();
		Judge_Level();
		if(tempLevel != nowLevel)
		{
			if(nowLevel > tempLevel)
			{
				printf("A:H%d+L%d+U\r\n", nowHeight, nowLevel);
			}
			else if(nowLevel < tempLevel)
			{
				printf("A:H%d+L%d+D\r\n", nowHeight, nowLevel);
			}
			tempLevel = nowLevel;

			LevelChangeFlag = 1;
			
		
		}
		if(InitFlag == 0)
		{
			LED_Display(LED);
			LCD_Display();
		}
		InitFlag = 0;

		
  }
  /* 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_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();
  }
  /** Initializes the peripherals clocks
  */
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_ADC12;
  PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
  PeriphClkInit.Adc12ClockSelection = RCC_ADC12CLKSOURCE_SYSCLK;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */
int fputc(int ch, FILE *f)
{
	HAL_UART_Transmit(&huart1, (unsigned char *)&ch, 1, HAL_MAX_DELAY);
	return ch;
}

void Rx_Proc(void)
{
	if(RxBuffer[0] == 'C')
	{
		printf("C:H%d+L%d\r\n", nowHeight, nowLevel);
		CheckDataFlag = 1;
	}
	if(RxBuffer[0] == 'S')
	{
		printf("S:TL%d+TM%d+TH%d\r\n", StoreThreshold[0], StoreThreshold[1], StoreThreshold[2]);
		CheckDataFlag = 1;
	}
	BufIndex = 0;
	memset(RxBuffer, 0, 30);
}

void DisposeKey(void)
{
	if(key[0].single_flag)
	{
		if(displayMode == DATA)
		{
			displayMode = PARA;
			LCD_Clear(Black);
		}
		else if(displayMode == PARA)
		{
			displayMode = DATA;
			eeprom_write(0x01, StoreThreshold[0]);
			HAL_Delay(1);
			eeprom_write(0x02, StoreThreshold[1]);
			HAL_Delay(1);
			eeprom_write(0x03, StoreThreshold[2]);
			HAL_Delay(1);
			LCD_Clear(Black);
		}
		key[0].single_flag = 0;
	}
	if(key[1].single_flag)
	{
		if(displayMode == PARA)
		{
			SettingIndex++;
			SettingIndex %= 3;
		}
		key[1].single_flag = 0;
	}
	if(key[2].single_flag)
	{
		if(displayMode == PARA)
		{
			if(SettingIndex == 2)
			{
				StoreThreshold[2] += 5;
				if(StoreThreshold[2] > 95)
				{
					StoreThreshold[2] = StoreThreshold[1] + 5;
				}
			}
			if(SettingIndex == 1)
			{
				StoreThreshold[1] += 5;
				if(StoreThreshold[1] >= StoreThreshold[2])
				{
					StoreThreshold[1] = StoreThreshold[0] + 5;
				}
			}
			if(SettingIndex == 0)
			{
				StoreThreshold[0] += 5;
				if(StoreThreshold[0] >= StoreThreshold[1])
				{
					StoreThreshold[0] = 5;
				}
			}
		}
		key[2].single_flag = 0;
	}
	if(key[3].single_flag)
	{
		if(displayMode == PARA)
		{
			if(SettingIndex == 2)
			{
				StoreThreshold[2] -= 5;
				if(StoreThreshold[2] <= StoreThreshold[1])
				{
					StoreThreshold[2] = 95;
				}
			}
			if(SettingIndex == 1)
			{
				StoreThreshold[1] -= 5;
				if(StoreThreshold[1] <= StoreThreshold[0])
				{
					StoreThreshold[1] = StoreThreshold[2] - 5;
				}
			}
			if(SettingIndex == 0)
			{
				StoreThreshold[0] -= 5;
				if(StoreThreshold[0] == 0)
				{
					StoreThreshold[0] = StoreThreshold[1] - 5;
				}
			}
		}
		key[3].single_flag = 0;
	}
}

void LCD_Display(void)
{
	if(displayMode == DATA)
	{
		LCD_DisplayStringLine(Line1, "     Liquid Level");
		char text[30];
		sprintf(text, "    Height:%2dcm", nowHeight);
		LCD_DisplayStringLine(Line3, text);
		if(completeADCflag)
		{
			sprintf(text, "    ADC: %.2fV", globalADC * 3.3 / 4096);
			LCD_DisplayStringLine(Line5, text);
			completeADCflag = 0;
		}
		sprintf(text, "    Level: %d", nowLevel);
		LCD_DisplayStringLine(Line7, text);
	}
	if(displayMode == PARA)
	{
		LCD_DisplayStringLine(Line1, "   Parameter Setup");
		char text[30];
		if(SettingIndex == 0)
		{
			LCD_SetTextColor(Green);
		}
		sprintf(text, "Threshold1: %02dcm", StoreThreshold[0]);
		LCD_DisplayStringLine(Line3, text);
		LCD_SetTextColor(White);
		if(SettingIndex == 1)
		{
			LCD_SetTextColor(Green);
		}
		sprintf(text, "Threshold2: %02dcm", StoreThreshold[1]);
		LCD_DisplayStringLine(Line5, text);
		LCD_SetTextColor(White);
		if(SettingIndex == 2)
		{
			LCD_SetTextColor(Green);
		}
		sprintf(text, "Threshold3: %02dcm", StoreThreshold[2]);
		LCD_DisplayStringLine(Line7, text);
		LCD_SetTextColor(White);
	}
}

void Judge_Level(void)
{
	if(nowHeight <= StoreThreshold[0])
	{
		nowLevel = 0;
	}
	else if(nowHeight > StoreThreshold[0] && nowHeight <= StoreThreshold[1])
	{
		nowLevel = 1;
	}
	else if(nowHeight > StoreThreshold[1] && nowHeight <= StoreThreshold[2])
	{
		nowLevel = 2;
	}
	else if(nowHeight > StoreThreshold[2])
	{
		nowLevel = 3;
	}
}
/* 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 */

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

四、完成效果

蓝桥杯嵌入式第七届省赛试题实现效果

五、总结

其实说本篇文章只是为了存放我的代码，所以看不懂很正常，如果需要代码可以找我私信。

火花页.
关注
蓝桥杯嵌入式第七届真题(完成) STM32G431
Johnor的博客
01-31 3588
adc_process 中1s读取一次使用1ms进入一次SysTick_Handler 中断定时newadcval、newlevel、newheight都是最新一次数据，与上一次数据比较是否液位发生变化led_process中题目要求三个led按要求变化，led1要一直闪烁，led2、led3满足特定条件后才变化翻转所以使用两个标志位led2flag和led3flag同时使用静态变量led2count计数闪烁五次后关闭。
【STM32G431RBTx】备战蓝桥杯嵌入式→决赛试题→第八届
qq_66792436的博客
05-15 548
学习完了所有模块之后(LIS302考点取消了, 扩展板也找不到了，如果你能找到可能你不是在十四届省赛后买的扩展板), 跟省赛一样，先拿第八届开刀。第八届省赛是目前为止我认为难度最高的，但第八届决赛题难度还行，不会太难为人，难点就在输入捕获采集频率。本篇文章只是为了存放我的代码，所以看不懂很正常，如果需要代码可以找我私信。
蓝桥杯嵌入式（G431）备赛笔记——I2C
玄奕子的博客
04-12 734
蓝桥杯嵌入式（G431）备赛笔记——I2C
蓝桥杯嵌入式2016第七届省赛真题解答
qq_49552487的博客
04-05 3823
1 题目分析 使用到的外设：LED、LCD、按键、串口、ADC、I2C。 2 Cubemx配置 外设具体方法参考我写的其他文章 配置完成如下： 时钟树配置如下: 3 文件移植 其中灯和按键程序自己添加 添加到项目中 先编译，左边会显示出添加的文件 添加头文后再编译一下，确保头文件和.c文件都被正确引用 4代码 所有的外设配置Cubemx都配置好了，无需自己配置（巨省工作量） 下面介绍自己添加的部分 4.1 led和Key部分 头......
蓝桥杯嵌入式第七届省赛真题
qq_51663309的博客
11-26 2940
蓝桥杯嵌入式第七届省赛真题 代码结尾自取 完全免费！！！！！！ 代码结尾自取 完全免费！！！！！！ 代码结尾自取 完全免费！！！！！！ 目录蓝桥杯嵌入式第七届省赛真题1.题目2.题目分析3.项目结构3.1 函数结构和全局变量3.2 界面3.3 K3，K4按键控制3.4 串口控制3.5 液位控制3.6 Led控制3.7主函数 1.题目 ​ “模拟液位检测告警系统”通过采集模拟电压信号计算液位高度，并根据用户设定的液位阈值执行报警动作，在液位等级发生变化时，通过串行通讯接口将液位信息发送到 PC
蓝桥杯嵌入式STM32G431资源包
03-02
【嵌入式STM32G431资源包】是一个专为参加【蓝桥杯】比赛的参赛者设计的学习和实践素材。STM32G431是STMicroelectronics公司推出的一款高性能、低功耗的微控制器，属于STM32家族中的G4系列。这个资源包针对的是...
蓝桥杯十二届嵌入式 省赛试题，完整代码，STM32G431
04-07
标题中的“蓝桥杯十二届嵌入式省赛试题，完整代码，STM32G431”揭示了几个关键知识点。首先，“蓝桥杯”是一项知名的全国性信息技术竞赛，专注于软件和电子设计，尤其在嵌入式系统领域。这个标题意味着我们将探讨的...
第十二届蓝桥杯大赛嵌入式组STM32G431资源包
01-29
【标题】"第十二届蓝桥杯大赛嵌入式组STM32G431资源包" 提供的是一系列关于STM32G431微控制器的学习资源，该资源包是针对蓝桥杯大赛嵌入式组的比赛而设计的。蓝桥杯大赛是一项面向全国高校学生的重要编程竞赛，旨在...
蓝桥杯嵌入式主板G431例程
02-21
【嵌入式主板G431例程】是针对蓝桥杯竞赛中涉及的嵌入式硬件平台——G431主板的详细编程实例。蓝桥杯是一项专注于培养IT和电子创新技术人才的全国性赛事，其中嵌入式部分主要考察参赛者对微处理器、嵌入式操作系统...
蓝桥杯嵌入式STM32G431RBT6程序源码+项目说明.zip
01-27
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...蓝桥杯嵌入式STM32G431RBT6程序源码+项目说明.zip
备战蓝桥杯（2）——第七届蓝桥杯嵌入式省赛赛题实战
SUPPER__xxh的博客
01-13 1796
第七届蓝桥杯嵌入式省赛赛题实战，文末有工程项目链接，用的是CT117E-M4平台，cubemx和keil开发。
第七届 蓝桥杯 嵌入式设计与开发项目 省赛
z945738307的博客
05-14 282
框架赛题部分程序主函数按键功能函数、ADC功能函数串口功能函数LED功能函数LCD功能函数完整程序下载 赛题 部分程序 主函数 /* USER CODE BEGIN 2 */ EEPROM_init(); LED_init(); KEY_init(); LCD_Init(); USER_DATA_init(); //数据初始化 TASK_TIMES_init(); /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE
蓝桥杯嵌入式第七届省题
weixin_51914919的博客
02-25 1705
第七届蓝桥杯嵌入式 这一届的蓝桥杯省题他的用到的外设相对于来说还是比较多的，有用到ADC、EEPROM、USART、led、key这些外设，可以说除了没用到PWM、蜂鸣器之外，蓝桥杯嵌入式的考点涉及的外设大多都包含在里面了。可以说也是比较齐全了,不过我们也不要给自己太大的压力，把基本的配置学会了，main函数编写起来还是简单的。 第七届题目要求是模拟液位警报系统，要求通过模拟电压信号（ADC）计算他液位高度，并在液位等级发生变化的时候通过串口发送到PC机上。 下面我们看看具体的要求。 1.液位高度、ADC
【STM32学习笔记】（10）——蜂鸣器实验详解
热门推荐
qq_53918631的博客
06-12 1万+
本文讲述了蜂鸣器的基本知识，和如何用STM32精英版来编写蜂鸣器实验的代码。
【蓝桥杯_练习】
qq_42733748的博客
03-20 2000
【代码】【蓝桥杯_练习】
蓝桥杯嵌入式第十三届省赛题目及详细编程解答
qq_63871189的博客
01-18 2233
这是第一次发关于嵌入式的题目解答，后续会将其他届的题目和解答一并发出，详见我的博客，总体来说嵌入式的题目不会特别难，现在官方提供了CUBEMX,用这个软件生成一些底层代码，相当好用，但是目前一个明显缺点是用一次软件生成代码后重新编译会比较慢，可能会用两分钟左右，所以为了编译速度快一点，我们可以将代码合理排列在main.c里面，这样不用怕编译后自己的.c和.h文件丢失（当然也可以不用这样，让代码更直观）。废话不多说直接给代码。
蓝桥杯嵌入式STM32G431——第七届省赛真题模拟液位检测告警系统
qq_52542756的博客
02-12 1430
第七届省赛真题 主函数部分的代码功能实现 #include "main.h" #include "rcc.h" #include "led_key.h" #include "lcd.h" #include "i2c.h" #include "uart.h" #include "adc.h" //***函数执行速度控制变量 __IO uint32_t uwTick_LED_Speed_Ctrl; __IO uint32_t uwTick_KEY_Speed_Ctrl; __IO uint32_t uwT
蓝桥杯专项---一维前缀/差分巩固题目
binhyun的博客
11-02 1168
1.一维前缀和--区间的次方求和问题 1.1下面的这个是从0开始的： 1.2下面的这个是从1开始的 2.一维差分---小兰的操作 3.字符迁移 4.类一维前缀---第15届蓝桥杯真题---类斐波那契循环数
蓝桥杯第21场小白入门赛补题
最新发布
2302_79372568的博客
11-05 525
【代码】蓝桥杯第21场小白入门赛补题。
蓝桥杯嵌入式省赛STM32G431完整代码解析
十二届嵌入式省赛试题中涉及的STM32G431是一款基于ARM® Cortex®-M4内核的高性能微控制器。以下是详细的知识点说明： 1. 蓝桥杯嵌入式设计与开发竞赛背景： 蓝桥杯是中国信息技术领域的重要竞赛之一，涵盖了算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值