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

已于 2023-05-18 16:55:20 修改
阅读量509 收藏 4
点赞数
文章标签： stm32 蓝桥杯 单片机
于 2023-05-17 22:07:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66792436/article/details/130716088
版权

文章目录

前言

无

一、题目

请添加图片描述

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

二、模块初始化

1.LCD这里不用配置，直接使用提供的资源包就行
2.双ADC:开启双ADCsingle-ended
3.LED:开启PC8-15,PD2输出模式就行了。
4.定时器:TIM3(按键消抖定时器):PSC:80-1,ARR:10000-1，TIM4(串口发送计时器)：PSC:80-1,ARR:4999，TIM6(LED计时定时器):PSC:80-1,ARR:999，TIM17(输入捕获定时器):PSC:80,ARR:65535
5.i2c:设置PB6,PB7为GPIO_Output模式即可
6.SEG:打开PA1,PA2,PA3GPIO_Output模式
7.打开串口串行输出

三、代码实现

bsp组中共有:
在这里插入图片描述

interrupt.h:

#ifndef __INTERRUPT_H__
#define __INTERRUPT_H__

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

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

#endif

interrupt.c:

#include "interrupt.h"
#include "ds18b20.h"
#include "stdio.h"
#include "led.h"
/* Captured Values */
uint32_t uwIC1Value1_T17CH1 = 0;
uint32_t uwIC1Value2_T17CH1 = 0;
uint32_t uwHighCapture_T17CH1 = 0;
uint32_t uwLowCapture_T17CH1 = 0;
/* Capture index */
uint16_t uhCaptureIndex_T17CH1 = 0;

/* Frequency Value */
uint32_t uwFrequency_T17CH1 = 0;
double uwDuty_T17CH1 = 0;

extern double Temperature;
extern unsigned char readokFlag;

extern unsigned char ICfirstflag;
unsigned char should_printf;
extern unsigned char printfok;
extern unsigned char LD8FlashFlag;
extern unsigned char LD8FlashTick;
unsigned char LD8Type;
extern unsigned char LED;

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == TIM17)
	{
		if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)
		{
			if(uhCaptureIndex_T17CH1 == 0)
			{
				/* Get the 1st Input Capture value */
				uwIC1Value1_T17CH1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
				__HAL_TIM_SET_CAPTUREPOLARITY(htim, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_FALLING);
				uhCaptureIndex_T17CH1 = 1;
			}
			else if(uhCaptureIndex_T17CH1 == 1)
			{
				/* Get the 2nd Input Capture value */
				uwIC1Value2_T17CH1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1); 
				__HAL_TIM_SET_CAPTUREPOLARITY(htim, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_RISING);
				/* Capture computation */
				if (uwIC1Value2_T17CH1 > uwIC1Value1_T17CH1)
				{
					uwHighCapture_T17CH1 = (uwIC1Value2_T17CH1 - uwIC1Value1_T17CH1); 
				}
				else if (uwIC1Value2_T17CH1 < uwIC1Value1_T17CH1)
				{
					/* 0xFFFF is max TIM1_CCRx value */
					uwHighCapture_T17CH1 = ((0xFFFF - uwIC1Value1_T17CH1) + uwIC1Value2_T17CH1) + 1;
				}
				else
				{
					/* If capture values are equal, we have reached the limit of frequency
						 measures */
					Error_Handler();
				}
				uhCaptureIndex_T17CH1 = 2;
				uwIC1Value1_T17CH1 = uwIC1Value2_T17CH1;
				/* Frequency computation: for this example TIMx (TIM1) is clocked by
					 APB2Clk */      
			}
			else if(uhCaptureIndex_T17CH1 == 2)
			{
				uwIC1Value2_T17CH1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
				if (uwIC1Value2_T17CH1 > uwIC1Value1_T17CH1)
				{
					uwLowCapture_T17CH1 = (uwIC1Value2_T17CH1 - uwIC1Value1_T17CH1); 
				}
				else if (uwIC1Value2_T17CH1 < uwIC1Value1_T17CH1)
				{
					/* 0xFFFF is max TIM1_CCRx value */
					uwLowCapture_T17CH1 = ((0xFFFF - uwIC1Value1_T17CH1) + uwIC1Value2_T17CH1) + 1;
				}
				uwFrequency_T17CH1 = 1000000 / (uwLowCapture_T17CH1 + uwHighCapture_T17CH1);
				uwDuty_T17CH1 = uwHighCapture_T17CH1 * 100.0 / (uwLowCapture_T17CH1 + uwHighCapture_T17CH1);
				uhCaptureIndex_T17CH1 = 0;
				readokFlag = 0;
				ICfirstflag = 1;
				HAL_TIM_IC_Stop_IT(htim, TIM_CHANNEL_1);
			}
		}
	}
}

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

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

struct keys key[4] = {0, 0, 0, 0, 0};
unsigned char SegTick = 0;
extern unsigned char SegDispflag;

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].key_judge)
			{
				case 0:
				{
					if(key[i].key_sta == 0)
					{
						key[i].key_judge = 1;
						key[i].key_time = 0;
					}
					break;
				}
				case 1:
				{
					if(key[i].key_sta == 0)
					{
						key[i].key_judge = 2;
					}
					else
					{
						key[i].key_judge = 0;
					}
					break;
				}
				case 2:
				{
					if(key[i].key_sta == 1)
					{
						key[i].key_judge = 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;
				}
			}
		}
		SegTick++;
		if(SegTick == 200)
		{
			SegTick = 0;
			SegDispflag = !SegDispflag;
		}
	}
	if(htim->Instance == TIM4)
	{
		should_printf = !should_printf;
		if(should_printf == 1)
			printfok = 0;
	}
	if(htim->Instance == TIM6)
	{
		LD8FlashTick++;

		if(LD8FlashTick == 200)
		{
			LD8FlashTick = 0;
			LD8Type = !LD8Type;
			LED = LED & 0x7f | (LD8Type << 7);
		}
	}
}

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
  *
  * Copyright (c) 2023 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 */

/* 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 MAIN 0
#define PARA 1
#define AO1 0
#define AO2 1
/* USER CODE END Private defines */

#ifdef __cplusplus
}
#endif

#endif /* __MAIN_H */

main.c:

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

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "lcd.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "ds18b20.h"
#include "seg.h"
#include "dadc.h"
#include "interrupt.h"
#include "i2c.h"
#include "led.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 */
char text[30];
float Temperature;
unsigned int SegNum;
double volt_AO1;
double volt_AO2;
extern uint32_t uwFrequency_T17CH1;
extern double uwDuty_T17CH1;
extern char RxBuffer[30];
extern unsigned char BufIndex;
extern unsigned char Rxdat;
unsigned char readokFlag;
extern struct keys key[4];
unsigned char eeprom_readData;
unsigned char eeprom_writeData;
unsigned char DisplayMode;
uint16_t N;
unsigned char T = 30;
unsigned char X;
unsigned char Ttemp = 30;
unsigned char Xtemp;
unsigned char SettingIndex;
unsigned char keywait;
unsigned char SegDispflag;
unsigned char reportFlag;
unsigned char ICfirstflag;
extern unsigned char should_printf;
unsigned char printfok;
unsigned char LED;
unsigned char LD8FlashFlag;
unsigned char LD8FlashTick;
extern unsigned char LD8Type;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
void Rx_Proc(void);
void DisposeKey(void);
void LCD_Disp(void);
void Seg_Echo(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_ADC2_Init();
  MX_TIM17_Init();
  MX_USART1_UART_Init();
  MX_TIM16_Init();
  MX_TIM3_Init();
  MX_TIM4_Init();
  MX_TIM6_Init();
  /* USER CODE BEGIN 2 */
	while((unsigned int)(ds18b20_readT()) == 85)
	{
		if(uwTick > 200) break;
	}
	HAL_TIM_IC_Start_IT(&htim17, TIM_CHANNEL_1);
	getDualADC(&hadc2);
	HAL_Delay(2);
	getDualADC(&hadc2);
	volt_AO1 = adc2_in17_AO1 * 3.3 / 4096;
	volt_AO2 = adc2_in13_AO2 * 3.3 / 4096;
	LED_Disp(0x00);
	if(ICfirstflag)
	{
		if(X == AO1)
		{
			if(volt_AO1 > uwDuty_T17CH1 / 100.0 * 3.3)
			{
				reportFlag = 1;
			}
			else
			{
				reportFlag = 0;
//				printf("duty:%.2f\n", volt_AO1);
			}
		}
		if(X == AO2)
		{
			if(volt_AO2 > uwDuty_T17CH1 / 100.0 * 3.3)
				reportFlag = 1;
			else reportFlag = 0;
		}
	}
	N = eeprom_read(0) | eeprom_read(1) << 8;
	LCD_Init();
	LCD_Clear(Black);
	LCD_SetBackColor(Black);
	LCD_SetTextColor(White);
	HAL_UART_Receive_IT(&huart1, &Rxdat, 1);
	HAL_TIM_Base_Start_IT(&htim3);
//	while((unsigned int)uwDuty_T17CH1 == 0)
//	{
		if(uwTick > 999) break;
//	}
  /* USER CODE END 2 */

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

    /* USER CODE BEGIN 3 */
		getDualADC(&hadc2);
		volt_AO1 = adc2_in17_AO1 * 3.3 / 4096;
		volt_AO2 = adc2_in13_AO2 * 3.3 / 4096;
		if(readokFlag == 0)
		{
			Temperature = ds18b20_readT();
			HAL_TIM_IC_Start_IT(&htim17, TIM_CHANNEL_1);
			readokFlag = 1;
		}
		if(Temperature > (double)T)
		{
			LD8FlashFlag = 1;
			HAL_TIM_Base_Start_IT(&htim6);
		}
		else
		{
			HAL_TIM_Base_Stop_IT(&htim6);
			__HAL_TIM_SetCounter(&htim6, 0);
			LD8FlashTick = 0;
			LD8FlashFlag = 0;
			LD8Type = 0;
			LED = LED & 0x7f;
		}
		if(BufIndex != 0)
		{
			unsigned char Indextemp = BufIndex;
			HAL_Delay(1);
			if(BufIndex == Indextemp)
				Rx_Proc();
		}
		if(X == AO1)
		{
			if(volt_AO1 > uwDuty_T17CH1 / 100.0 * 3.3)
			{
				reportFlag = 1;
			}
			else
			{
				reportFlag = 0;
//				printf("duty:%.2f\n", volt_AO1);
			}
		}
		if(X == AO2)
		{
			if(volt_AO2 > uwDuty_T17CH1 / 100.0 * 3.3)
				reportFlag = 1;
			else reportFlag = 0;
		}
		if(reportFlag)
		{
			LED = LED & 0xfe | 0x01;
			HAL_TIM_Base_Start_IT(&htim4);
		}
		else
		{
			LED = LED & 0xfe;
			HAL_TIM_Base_Stop_IT(&htim4);
			__HAL_TIM_SetCounter(&htim4, 0);
			should_printf = 0;
		}
		DisposeKey();
		LCD_Disp();
		Seg_Echo();
		LED_Disp(LED);
		if(should_printf)
		{
			if(printfok == 0)
			{
				printf("$%.2lf\r\n", Temperature);
				printfok = 1;
			}
		}
//		HAL_Delay(500);
  }
  /* 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 */
int fputc(int ch, FILE * f)
{
	HAL_UART_Transmit(&huart1, (unsigned char *)&ch, 1, HAL_MAX_DELAY);
	return ch;
}

void Rx_Proc(void)
{
	if(strncmp(RxBuffer, "ST", 2) == 0)
	{
		printf("$%.2lf\r\n", Temperature);
	}
	if(strncmp(RxBuffer, "PARA", 4) == 0)
	{
		printf("#%d,AO%d\r\n", T, X+1);
	}
	memset(RxBuffer, 0, 30);
	BufIndex = 0;
}

void DisposeKey(void)
{
	if(key[0].single_flag)
	{
		LCD_Clear(Black);
		if(DisplayMode == MAIN)
		{
			DisplayMode = PARA;
		}
		else if(DisplayMode == PARA)
		{
			DisplayMode = MAIN;
			if(X != Xtemp || (unsigned char)Ttemp != (unsigned char)T)
			{
				if(N + 1 == 65536)
					N = 65535;
				else
					N += 1;
				Xtemp = X;
				Ttemp = T;
				eeprom_write(0, N & 0xff);
				HAL_Delay(10);
				eeprom_write(1, (N >> 8) & 0xff);
			}
		}
		key[0].single_flag = 0;
	}
	if(key[1].single_flag)
	{
		if(DisplayMode == PARA)
		{
			SettingIndex = !SettingIndex;
		}
		key[1].single_flag = 0;
	}
	if(key[2].single_flag)
	{
		if(DisplayMode == PARA)
		{
			if(SettingIndex == 0)
			{
				if((unsigned char)(T+1) <= 40)
					T += 1;
			}
			if(SettingIndex == 1)
			{
				X = !X;
			}
		}
		key[2].single_flag = 0;
	}
	if(key[2].long_flag)
	{
		if(DisplayMode == PARA)
		{
			if(SettingIndex == 0)
			{
				keywait++;
				if(keywait == 4)
				{
					keywait = 0;
					if((unsigned char)(T+1) <= 40)
						T += 1;
				}
			}
		}
		key[2].long_flag = 0;
	}
	if(key[3].single_flag)
	{
		if(DisplayMode == PARA)
		{
			if(SettingIndex == 0)
			{
				if((unsigned char)(T-1) >= 20)
					T -= 1;
			}
			if(SettingIndex == 1)
			{
				X = !X;
			}
		}
		key[3].single_flag = 0;
	}
	if(key[3].long_flag)
	{
		if(DisplayMode == PARA)
		{
			if(SettingIndex == 0)
			{
				keywait++;
				if(keywait == 4)
				{
					keywait = 0;
					if((unsigned char)(T-1) >= 20)
						T -= 1;
				}
			}
		}
		key[3].long_flag = 0;
	}
}

void LCD_Disp(void)
{
	if(DisplayMode == MAIN)
	{
		LCD_DisplayStringLine(Line0, "        Main");
		sprintf(text, "  A01:%.2fV", volt_AO1);
		LCD_DisplayStringLine(Line1, text);
		sprintf(text, "  A02:%.2fV", volt_AO2);
		LCD_DisplayStringLine(Line3, text);
		sprintf(text, "  PWM2:%d%% ", (unsigned char)uwDuty_T17CH1);
		LCD_DisplayStringLine(Line5, text);
		sprintf(text, "  Temp:%.2fC ", Temperature);
		LCD_DisplayStringLine(Line7, text);
		sprintf(text, "  N:%d", N);
		LCD_DisplayStringLine(Line9, text);
	}
	if(DisplayMode == PARA)
	{
		LCD_DisplayStringLine(Line0, "        Para");
		sprintf(text, "T:%d                ", (unsigned char)T);
		if(SettingIndex == 0) LCD_SetBackColor(Yellow);
		LCD_DisplayStringLine(Line2, text);
		LCD_SetBackColor(Black);
		sprintf(text, "X:A0%d               ", X+1);
		if(SettingIndex == 1) LCD_SetBackColor(Yellow);
		LCD_DisplayStringLine(Line4, text);
		LCD_SetBackColor(Black);
	}
}

void Seg_Echo(void)
{
	if(SegDispflag == 0)
	{
		SEG_Disp(12, T / 10, T % 10);
	}
	else
	{
		SEG_Disp(10, 0, X + 1);
	}
}
/* 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 */

四、完成效果

蓝桥杯嵌入式第十届国赛试题实现效果

五、总结

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

火花页.
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
蓝桥杯嵌入式STM32G431资源包
03-02
赛场资源包
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→DAC
qq_66792436的博客
01-19 984
蓝桥杯
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→UART
qq_66792436的博客
01-16 1341
蓝桥杯
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→ADC
qq_66792436的博客
01-16 961
蓝桥杯
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→TIM→PWM
qq_66792436的博客
01-15 942
蓝桥杯
【STM32G431RBTx】备战蓝桥杯嵌入式→基本模块→LCD
qq_66792436的博客
01-14 1266
蓝桥杯
第十二届蓝桥杯大赛嵌入式组STM32G431资源包
01-29
文件内包括所有蓝桥杯官方给的程序资料，驱动，产品手册等
蓝桥杯十二届嵌入式 省赛试题，完整代码，STM32G431
04-07
思路参考bilibili视频中介绍的思路，感谢bilibili大学，感谢up主。 仅考虑普通情况，其余特殊情况仍需具体进一步完善，后续完成后上传。 如果不足，欢迎指正。
蓝桥杯嵌入式主板G431例程
02-21
蓝桥杯嵌入式主板G431详细例程代码
嵌入式开发-STM32G431RBTx-产生PWM
03-22
嵌入式开发-STM32G431RBTx-产生PWM
STM32快速入门（定时器之输入捕获）
m0_52566365的博客
05-08 1272
讲解了一下定时器输入捕获的功能，能够测量PWM波形的频率、占空比等
ADC STM32
A person does not really understand something until after teaching it to a computer. Donald.E.Knuth
05-07 500
/////
HAL PWM 配置 占空比 频率 stm32 学习笔记
Pyangthon的博客
05-06 479
HALPWM配置占空比频率。
STM32接入CH340芯片的初始化进入升级模式（死机）问题处理
uyoev123abc的博客
05-07 936
MCU-REST 在 MCU-BOOT0 处于低电平状态下，进行下拉操作，在MCU-REST 与 MCU-BOOT0 恢复正常电平时，将导致MCU死机，MCU-REST 先于 MCU-BOOT0 下拉可解决该问题；MCU-REST 在 上升沿结束时将判断 MCU-BOOT0 的状态，MCU-BOOT0 处于高电平，MCU死机，MCU-BOOT0 处于低电平 MCU 正常；
STM32-07-STM32_外部中断
最新发布
L的博客
05-11 708
STM32外部中断介绍，包含中断系统、NVIC、EXTI、AFIO、中断配置步骤、外部中断代码几部分进行叙述
嵌入式开发四：STM32 基础知识入门
weixin_47040031的博客
05-03 1620
define 是 C 语言中的预处理命令，它用于宏定义，可以提高源代码的可读性，为编程提供方 便。常见的格式：#define 标识符 字符串“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。例如： #define HSE_VALUE 8000000U#define PLL_M 8 //定义标识符 PLL_M 的值为 8。定义标识符 HSE_VALUE 的值为 8000000，数字后的 U 表示 unsigned 的意思。
项目1:STM32+DHT11+FreeRTOS+emwin+LCD
hmh520i的博客
05-08 1003
项目1:STM32+DHT11+FreeRTOS+emwin+LCD
stm32之hal库i2s驱动的封装记录
scl8295的博客
05-07 278
【代码】stm32之hal库i2s驱动的封装记录。
STM32（六）：定时器PWM呼吸灯 （标准库函数）
liutuoqi123的博客
05-07 957
PWM的全称是脉冲宽度调制（Pulse-width modulation），是指在具有惯性的系统中，可以通过对一系列脉冲的宽度进行调制，来等效的地获得所需要的模拟参量，常应用于电机控速等领域。在STM32微控制器的应用中，PWM技术也非常重要，因为它能够提供精确的信号控制，从而达到对设备行为的精确管理。频率：一秒钟内从高电平时间在到低电平时间，再从低电平跳到高电平的瞬间次数，也就是一秒钟内有多少个PWM的周期，f = 1/Ts。周期：一秒钟内从高电平时间在到低电平时间，Ts= 1/f。PWM信号产生。
stm32cubemx如何配置stm32G431RBTx
05-23
配置 STM32G431RBTx 可以通过以下步骤进行： 1. 打开 STM32CubeMX 软件并创建一个新项目。 2. 在搜索栏中输入 STM32G431RBTx 并选择该芯片。 3. 选择适当的时钟源和时钟频率，可以根据具体的应用场景进行选择。 4. 配置 GPIO，这里可以根据需要进行选择，并将其配置为输入或输出。 5. 配置外设，例如 USART，SPI，I2C 等等。根据需要进行选择和配置。 6. 配置中断，根据具体的需要进行选择和配置。 7. 生成代码并导出到 Keil 或者其他 IDE 中。 以上就是使用 STM32CubeMX 配置 STM32G431RBTx 的基本步骤，具体的配置内容可以根据实际需求进行选择和配置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值