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

最新推荐文章于 2024-11-07 23:24:32 发布
最新推荐文章于 2024-11-07 23:24:32 发布
阅读量3.5k 收藏 34
点赞数 17
分类专栏： 单片机 文章标签： 蓝桥杯 stm32 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/johnor/article/details/135961531
版权

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

题目

image-20240131201129279

image-20240131201143262

image-20240131201151854

image-20240131201200654

image-20240131201208206

相关文件

main.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 "usart.h"
#include "gpio.h"

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

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
extern uint32_t adctimes;
extern float k;//K? 
extern float adcval;
extern uint32_t height;
extern uint8_t level;
extern unsigned char min,med,max;
uint8_t view = 0;
uint8_t lcdtext[30];
extern struct Key key[4];
extern uint32_t led1times,led2times,led3times;
extern uint8_t led2flag,led3flag;
extern uint8_t led1status,led2status,led3status;
extern uint8_t OneData;
extern uint8_t rxflag;
uint8_t txtext[20];
/* 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 lcd_process(void);
void led_process(void);
void adc_process(void);
void key_process(void);
void rx_process(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_TIM2_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
		HAL_TIM_Base_Start_IT(&htim2);
		HAL_UART_Receive_IT(&huart1,&OneData,1);
    LCD_Init();
		I2CInit(); 
  /* USER CODE END 2 */

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

    LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		E2PROM_Write(0x00,min);
		HAL_Delay(5);
		E2PROM_Write(0x01,med);
		HAL_Delay(5);
		E2PROM_Write(0x02,max);	
		HAL_Delay(5);
		LED_display(0x00);
    while (1)
    {
			adc_process();
			key_process();
			lcd_process();
			led_process();
			rx_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_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 */
void adc_process(void)
{
    float newadcval;
    uint8_t newlevel;
    uint32_t newheight;
    int change;
    min = E2PROM_Read(0x00);
    med = E2PROM_Read(0x01);
    max = E2PROM_Read(0x02);

    if(adctimes >= 1000)
    {
        adctimes = 0;
        newadcval = get_Adc(&hadc2);
        newheight = k * newadcval;

        if(newheight <= min)
        {
            newlevel = 0;
        }
        else if(newheight <= med)
        {
            newlevel = 1;
        }
        else if(newheight <= max)
        {
            newlevel = 2;
        }
        else
        {
            newlevel = 3;
        }


        if(level != newlevel)
        {
            led2flag = 1; // 激活液位变化指示
            change = newheight - height;
            height = newheight;
            adcval = newadcval; // 更新adcval
						level = newlevel;
            if(change > 0)
            {
                sprintf((char *)txtext, "A:H%d+L%d+U\r\n", height, level);
                HAL_UART_Transmit(&huart1, (uint8_t *)txtext, strlen((char *)txtext), 50);
            }
            else if(change < 0)
            {
                sprintf((char *)txtext, "A:H%d+L%d+D\r\n", height, level);
                HAL_UART_Transmit(&huart1, (uint8_t *)txtext, strlen((char *)txtext), 50);
            }
        }
    }
}



void lcd_process(void)
{
	switch(view)
	{
		case 0:
		{
			sprintf((char *)lcdtext,"    Liquid Level");
			LCD_DisplayStringLine(Line0,lcdtext);
			sprintf((char *)lcdtext,"   Height:%d",height);
			LCD_DisplayStringLine(Line2,lcdtext);
			sprintf((char *)lcdtext,"   ADC:%.2f",adcval);
			LCD_DisplayStringLine(Line4,lcdtext);
			sprintf((char *)lcdtext,"   Level:%d",level);
			LCD_DisplayStringLine(Line6,lcdtext);
		}
		break;
		case 1:
		{
			sprintf((char *)lcdtext,"    Parameter Setup");
			LCD_DisplayStringLine(Line0,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 1:%d",min);
			LCD_DisplayStringLine(Line2,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 2:%d",med);
			LCD_DisplayStringLine(Line4,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 3:%d",max);
			LCD_DisplayStringLine(Line6,lcdtext);
		}
		break;
		case 2:
		{
			sprintf((char *)lcdtext,"    Parameter Setup");
			LCD_DisplayStringLine(Line0,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 1:%d",min);
			LCD_SetTextColor(Green);
			LCD_DisplayStringLine(Line2,lcdtext);
			LCD_SetTextColor(White);
			sprintf((char *)lcdtext,"   Threshold 2:%d",med);
			LCD_DisplayStringLine(Line4,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 3:%d",max);
			LCD_DisplayStringLine(Line6,lcdtext);
		}
		break;
		case 3:
		{
			sprintf((char *)lcdtext,"    Parameter Setup");
			LCD_DisplayStringLine(Line0,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 1:%d",min);
			LCD_DisplayStringLine(Line2,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 2:%d",med);
			LCD_SetTextColor(Green);
			LCD_DisplayStringLine(Line4,lcdtext);
			LCD_SetTextColor(White);
			sprintf((char *)lcdtext,"   Threshold 3:%d",max);
			LCD_DisplayStringLine(Line6,lcdtext);
		}
		break;
		case 4:
		{
			sprintf((char *)lcdtext,"    Parameter Setup");
			LCD_DisplayStringLine(Line0,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 1:%d",min);
			LCD_DisplayStringLine(Line2,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 2:%d",med);
			LCD_DisplayStringLine(Line4,lcdtext);
			sprintf((char *)lcdtext,"   Threshold 3:%d",max);
			LCD_SetTextColor(Green);
			LCD_DisplayStringLine(Line6,lcdtext);
			LCD_SetTextColor(White);
		}
		break;
	
	}
}

void key_process(void)
{
	if(key[0].key_flag==1&&(view==0))
	{
		key[0].key_flag=0;
		view=1;
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
	}
	if(key[0].key_flag==1&&(view==1||view==2||view==3||view==4))
	{
		key[0].key_flag=0;
		view=0;
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
	}
	if(key[1].key_flag==1&&(view==1||view==2||view==3||view==4))
	{
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		key[1].key_flag=0;
		view++;
		if(view>4)
			view=2;
	}
	
	
	if(key[2].key_flag==1&&view==2)
	{
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		key[2].key_flag=0;
		min+=5;
		if(min>95)
			min=5;
		E2PROM_Write(0x00,min);
	}
	else if(key[2].key_flag==1&&view==3)
	{
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		key[2].key_flag=0;
		med+=5;
		if(med>95)
			med=5;
		E2PROM_Write(0x01,med);
	}
	else if(key[2].key_flag==1&&view==4)
	{
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		key[2].key_flag=0;
		max+=5;
		if(max>95)
			max=5;
		E2PROM_Write(0x02,max);
	}
	
	
	if(key[3].key_flag==1&&view==2)
	{
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		key[3].key_flag=0;
		min-=5;
		if(min<5)
			min=5;
		E2PROM_Write(0x00,min);
	}
	else if(key[3].key_flag==1&&view==3)
	{
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		key[3].key_flag=0;
		med-=5;
		if(med<5)
			med=5;
		E2PROM_Write(0x01,med);
	}
	else if(key[3].key_flag==1&&view==4)
	{
		LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		key[3].key_flag=0;
		max-=5;
		if(max<5)
			max=5;
		E2PROM_Write(0x01,max);
	}
}

void led_process(void)
{
    // LD1处理
    if(led1times >= 1000) // 每1秒
    {
        led1times = 0;
        led1status = !led1status;
        LED_display(led1status ? 0x01 : 0x00);
    }
    
    // LD2处理
    static int led2count = 0;
    if(led2flag && led2times >= 200) // 每0.2秒
    {
        led2times = 0;
        led2status = !led2status;
        LED_display(led2status ? 0x02 : 0x00);

        if(led2status) // 只在LED从关闭状态变为开启状态时增加计数
        {
            led2count++;
        }

        if(led2count >= 5) // 闪烁5次后停止
        {
            led2flag = 0;
            led2count = 0;
        }
    }
    
    // LD3处理
    static int led3count = 0;
    if(led3flag && led3times >= 200) // 每0.2秒
    {
        led3times = 0;
        led3status = !led3status;
        LED_display(led3status ? 0x04 : 0x00);

        if(led3status) // 只在LED从关闭状态变为开启状态时增加计数
        {
            led3count++;
        }

        if(led3count >= 5) // 闪烁5次后停止
        {
            led3flag = 0;
            led3count = 0;
        }
    }
}

void rx_process(void)
{
	if(rxflag==1)
	{
		led3flag = 1;
		rxflag = 0;
		switch(OneData)
		{
			case 'C':
			{
				sprintf((char *)txtext,"C:H%d+L%d\r\n",height,level);
				HAL_UART_Transmit(&huart1,(uint8_t *)txtext,strlen((char *)txtext),50);
			}
			break;
			case 'S':
			{
				sprintf((char *)txtext,"S:TL%d+TM%d+TH%d\r\n",min,med,max);
				HAL_UART_Transmit(&huart1,(uint8_t *)txtext,strlen((char *)txtext),50);
			}
			break;
			default:
			{
				sprintf((char *)txtext,"Error!\r\n");
				HAL_UART_Transmit(&huart1,(uint8_t *)txtext,strlen((char *)txtext),50);
			}
			break;
		}
	}
}
/* 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****/

adc_process 中1s读取一次使用1ms进入一次SysTick_Handler 中断定时

newadcval、newlevel、newheight都是最新一次数据，与上一次数据比较是否液位发生变化

led_process中题目要求三个led按要求变化，led1要一直闪烁，led2、led3满足特定条件后才变化翻转所以使用两个标志位led2flag和led3flag同时使用静态变量led2count计数闪烁五次后关闭

image-20240131201548545

i2c_hal.c
/*
  程序说明: CT117E-M4嵌入式竞赛板GPIO模拟I2C总线驱动程序
  软件环境: MDK-ARM HAL库
  硬件环境: CT117E-M4嵌入式竞赛板
  日    期: 2020-3-1
*/

#include "i2c_hal.h"

#define DELAY_TIME	20

/**
  * @brief SDA线输入模式配置
  * @param None
  * @retval None
  */
void SDA_Input_Mode()
{
    GPIO_InitTypeDef GPIO_InitStructure = {0};

    GPIO_InitStructure.Pin = GPIO_PIN_7;
    GPIO_InitStructure.Mode = GPIO_MODE_INPUT;
    GPIO_InitStructure.Pull = GPIO_PULLUP;
    GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
}

/**
  * @brief SDA线输出模式配置
  * @param None
  * @retval None
  */
void SDA_Output_Mode()
{
    GPIO_InitTypeDef GPIO_InitStructure = {0};

    GPIO_InitStructure.Pin = GPIO_PIN_7;
    GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_OD;
    GPIO_InitStructure.Pull = GPIO_NOPULL;
    GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
}

/**
  * @brief SDA线输出一个位
  * @param val 输出的数据
  * @retval None
  */
void SDA_Output( uint16_t val )
{
    if ( val )
    {
        GPIOB->BSRR |= GPIO_PIN_7;
    }
    else
    {
        GPIOB->BRR |= GPIO_PIN_7;
    }
}

/**
  * @brief SCL线输出一个位
  * @param val 输出的数据
  * @retval None
  */
void SCL_Output( uint16_t val )
{
    if ( val )
    {
        GPIOB->BSRR |= GPIO_PIN_6;
    }
    else
    {
        GPIOB->BRR |= GPIO_PIN_6;
    }
}

/**
  * @brief SDA输入一位
  * @param None
  * @retval GPIO读入一位
  */
uint8_t SDA_Input(void)
{
	if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_7) == GPIO_PIN_SET){
		return 1;
	}else{
		return 0;
	}
}


/**
  * @brief I2C的短暂延时
  * @param None
  * @retval None
  */
static void delay1(unsigned int n)
{
    uint32_t i;
    for ( i = 0; i < n; ++i);
}

/**
  * @brief I2C起始信号
  * @param None
  * @retval None
  */
void I2CStart(void)
{
    SDA_Output(1);
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    SDA_Output(0);
    delay1(DELAY_TIME);
    SCL_Output(0);
    delay1(DELAY_TIME);
}

/**
  * @brief I2C结束信号
  * @param None
  * @retval None
  */
void I2CStop(void)
{
    SCL_Output(0);
    delay1(DELAY_TIME);
    SDA_Output(0);
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    SDA_Output(1);
    delay1(DELAY_TIME);

}

/**
  * @brief I2C等待确认信号
  * @param None
  * @retval None
  */
unsigned char I2CWaitAck(void)
{
    unsigned short cErrTime = 5;
    SDA_Input_Mode();
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    while(SDA_Input())
    {
        cErrTime--;
        delay1(DELAY_TIME);
        if (0 == cErrTime)
        {
            SDA_Output_Mode();
            I2CStop();
            return ERROR;
        }
    }
    SDA_Output_Mode();
    SCL_Output(0);
    delay1(DELAY_TIME);
    return SUCCESS;
}

/**
  * @brief I2C发送确认信号
  * @param None
  * @retval None
  */
void I2CSendAck(void)
{
    SDA_Output(0);
    delay1(DELAY_TIME);
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    SCL_Output(0);
    delay1(DELAY_TIME);

}

/**
  * @brief I2C发送非确认信号
  * @param None
  * @retval None
  */
void I2CSendNotAck(void)
{
    SDA_Output(1);
    delay1(DELAY_TIME);
    delay1(DELAY_TIME);
    SCL_Output(1);
    delay1(DELAY_TIME);
    SCL_Output(0);
    delay1(DELAY_TIME);

}

/**
  * @brief I2C发送一个字节
  * @param cSendByte 需要发送的字节
  * @retval None
  */
void I2CSendByte(unsigned char cSendByte)
{
    unsigned char  i = 8;
    while (i--)
    {
        SCL_Output(0);
        delay1(DELAY_TIME);
        SDA_Output(cSendByte & 0x80);
        delay1(DELAY_TIME);
        cSendByte += cSendByte;
        delay1(DELAY_TIME);
        SCL_Output(1);
        delay1(DELAY_TIME);
    }
    SCL_Output(0);
    delay1(DELAY_TIME);
}

/**
  * @brief I2C接收一个字节
  * @param None
  * @retval 接收到的字节
  */
unsigned char I2CReceiveByte(void)
{
    unsigned char i = 8;
    unsigned char cR_Byte = 0;
    SDA_Input_Mode();
    while (i--)
    {
        cR_Byte += cR_Byte;
        SCL_Output(0);
        delay1(DELAY_TIME);
        delay1(DELAY_TIME);
        SCL_Output(1);
        delay1(DELAY_TIME);
        cR_Byte |=  SDA_Input();
    }
    SCL_Output(0);
    delay1(DELAY_TIME);
    SDA_Output_Mode();
    return cR_Byte;
}

//
void I2CInit(void)
{
    GPIO_InitTypeDef GPIO_InitStructure = {0};

    GPIO_InitStructure.Pin = GPIO_PIN_7 | GPIO_PIN_6;
    GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStructure.Pull = GPIO_PULLUP;
    GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
}


uint8_t E2PROM_Read(uint8_t addr)
{
	uint8_t val;
	I2CStart();
	I2CSendByte(0xA0);
	I2CWaitAck();
	I2CSendByte(addr);
	I2CWaitAck();
	//I2CStop();
	
	I2CStart();
	I2CSendByte(0xA1);
	I2CWaitAck();
	val = I2CReceiveByte();
	I2CWaitAck();
	I2CStop();
	
	return val;
}

void E2PROM_Write(uint8_t addr,uint8_t data)
{
	I2CStart();
	I2CSendByte(0xA0);
	I2CWaitAck();
	
	I2CSendByte(addr);
	I2CWaitAck();
	
	I2CSendByte(data);
	I2CWaitAck();
	I2CStop();
}
key.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<=3;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_status = 2;
						key[i].key_flag = 1;
					}
					else
					{
						key[i].key_status = 0;
					}
				}
				break;
				case 2:
				{
					if(key[i].key_gpio==1)
					{
						key[i].key_status = 0;
					}
				
				}
			}
		}
	}

}
led.c
#include "led.h"

uint32_t led1times,led2times,led3times;
uint8_t led1status=0,led2status=0,led3status=0;
uint8_t led2flag= 0,led3flag=0;
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);
}

注意i2c再写数据时注意要间隔5ms以上要不然会数据异常

myadc.c
#include "myadc.h"

uint32_t adctimes = 0;
float k = 100/(3.3f);//Kֵ 
uint32_t height;
float adcval;
uint8_t level;
unsigned char min=30,med=50,max=70;
float get_Adc(ADC_HandleTypeDef *hadc){
   int val = 0.0f;
   for(int i = 0; i < 5; i++)
   {
      HAL_ADC_Start(hadc);
      HAL_ADC_PollForConversion(hadc, 100); // 等待转换完成
      val += HAL_ADC_GetValue(hadc);
      HAL_ADC_Stop(hadc); // 停止ADC转换
   }
   return val * 3.3f / 4096.0f / 5.0f; // 计算平均电压值
}
usart2.c
#include "usart2.h"

uint8_t OneData;
uint8_t rxflag;

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance==USART1)
	{
		rxflag = 1;
		HAL_UART_Receive_IT(huart,&OneData,1);
	}
	
}
计算机小混子
关注
专栏目录
蓝桥杯嵌入式STM32G431资源包
03-02
【嵌入式STM32G431资源包】是一个专为参加【蓝桥杯】比赛的参赛者设计的学习和实践素材。STM32G431是STMicroelectronics公司推出的一款高性能、低功耗的微控制器，属于STM32家族中的G4系列。这个资源包针对的是...
蓝桥杯嵌入式第11届真题(完成) STM32G431，2024年最新2024最新Linux运维面试笔试题目分享
2401_83946570的博客
04-16 948
16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?2、在工作中，运维人员经常需要跟运营人员打交道，请问运营人员是做什么工作的?6、Squid、Varinsh和Nginx有什么区别，工作中你怎么选择?5、LVS、Nginx、HAproxy有什么区别?9、讲述一下Tomcat8005、8009、8080三个端口的含义？7、Tomcat和Resin有什么区别，工作中你怎么选择?
STM32LED--基于HAL库(第七届蓝桥杯嵌入式省赛)
Octopus1633的博客
03-20 1293
STM32正持续关注LED与LCD的日益增长的冲突……
第七届蓝桥杯嵌入式（国赛）程序题
菜鸟江多多的博客
06-26 1604
第七届蓝桥杯（国赛）解读+程序任务书：分析：大体流程1.LCD显示2.实时时钟3.ADC采集（模拟温度）4.定时器输出比较（可调频率），输入捕获（模拟湿度）5.按键功能+采样周期+设置参数存储6.串口功能+存储7.报警功能程序整体设计完整工程下载 任务书： 先多读几遍任务书要求，需要用到哪些外设？需要实现哪些功能？各功之间如何较好的关联？ 分析： 任务书中自我感觉有两个稍废时间的功能，1.湿度的采集2，保存六十组数据并更新 后面重点讲解 大体流程 1.LCD显示 2.实时时钟 3.AD.
【STM32G431RBTx】备战蓝桥杯嵌入式→省赛试题→第七届
qq_66792436的博客
01-28 360
蓝桥杯
蓝桥杯嵌入式（G431）备赛笔记——I2C
玄奕子的博客
04-12 737
蓝桥杯嵌入式（G431）备赛笔记——I2C
【STM32G431RBTx】备战蓝桥杯嵌入式→决赛试题→第七届
qq_66792436的博客
05-20 1189
无本篇文章只是为了存放我的代码，所以看不懂很正常，如果需要代码可以找我私信。
第十二届蓝桥杯大赛嵌入式组STM32G431资源包
01-29
【标题】"第十二届蓝桥杯大赛嵌入式组STM32G431资源包" 提供的是一系列关于STM32G431微控制器的学习资源，该资源包是针对蓝桥杯大赛嵌入式组的比赛而设计的。蓝桥杯大赛是一项面向全国高校学生的重要编程竞赛，旨在...
蓝桥杯十二届嵌入式 省赛试题，完整代码，STM32G431
04-07
标题中的“蓝桥杯十二届嵌入式省赛试题，完整代码，STM32G431”揭示了几个关键知识点。首先，“蓝桥杯”是一项知名的全国性信息技术竞赛，专注于软件和电子设计，尤其在嵌入式系统领域。这个标题意味着我们将探讨的...
蓝桥杯嵌入式STM32G431RBT6程序源码+项目说明.zip
01-27
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...蓝桥杯嵌入式STM32G431RBT6程序源码+项目说明.zip
蓝桥杯第七届嵌入式国赛模拟题
10-03
第七届蓝桥杯国赛代码，功能实现，适用于参加蓝桥杯嵌入式竞赛的同学。
蓝桥杯第七届决赛题
03-22
这个代码我是在参加2018年蓝桥杯嵌入式初赛前写的，代码有很多问题吧仅供参考
蓝桥杯嵌入式（基础教程三）STM32G431RBT6-LCD的配置与使用
01-25
嵌入式系统通常用于控制、监视或优化设备和系统的操作，比如我们今天讨论的STM32G431RBT6微控制器。这种微控制器在各种应用中都有广泛使用，包括工业自动化、物联网(IoT)设备、消费电子产品等。 【STM32G431RBT6...
蓝桥杯嵌入式2016第七届省赛真题解答
qq_49552487的博客
04-05 3824
1 题目分析 使用到的外设：LED、LCD、按键、串口、ADC、I2C。 2 Cubemx配置 外设具体方法参考我写的其他文章 配置完成如下： 时钟树配置如下: 3 文件移植 其中灯和按键程序自己添加 添加到项目中 先编译，左边会显示出添加的文件 添加头文后再编译一下，确保头文件和.c文件都被正确引用 4代码 所有的外设配置Cubemx都配置好了，无需自己配置（巨省工作量） 下面介绍自己添加的部分 4.1 led和Key部分 头......
【蓝桥杯选拔赛真题78】python电话号码 第十五届青少年组蓝桥杯python选拔赛真题 算法思维真题解析
青少年编程学习指导
10-25 1609
给定一个长度为 11 的字符串 S，表示电话号码，然后将电话号码中第三位数字后的连续四位数字用"*"替换，并输出替换后的字符串。例如:S ="13900001234",用“*”"替换第三位数字后的连续四位数字为“139****1234”。输入一个长度为 11 的字符串 S(字符串仅包含 0~9 之间的数字且首个字符只能为 1)，表示电话号码。（注：input（）输入函数的括号中不允许添加任何信息）第十五届蓝桥杯青少年组python比赛选拔赛真题。输出一个字符串，表示替换后的字符串。
蓝桥杯第21场小白入门赛补题
2302_79372568的博客
11-05 984
【代码】蓝桥杯第21场小白入门赛补题。
蓝桥杯练习笔记（二十-日期问题）
m0_73902771的博客
11-02 713
日期题常见于填空题，关键点涉及闰年的判断和星期几的判断。
蓝桥杯 python day01 第一题
qq_73454087的博客
10-30 980
确定字符串是否包含唯一字符。
(蓝桥杯C/C++）——基础算法(下)
最新发布
2402_82385099的博客
11-07 1417
概念:递归是指函数直接或间接调用自身的过程。基本情况(递归终止条件):递归函数中的一个条件，当满足该条件时，递归终止，避免无限递归。可以理解为直接解决极小规模问题的方法。递归表达式(递归调用):递归函数中的语句，用于解决规模更小的子问题，再将子问题的答案合井成为当前问题的答案。枚举算法是一种基本的算法思想，它通过穷举所有可能的情况来解决问题。它的基本思想是将问题的解空间中的每个可能的解都枚举出来，并进行验证和比较，找到满足问题条件的最优解或者所有解。枚举算法适用于问题规模较小、解空间可穷举的情况。
蓝桥杯嵌入式stm32g431资源包
01-08
蓝桥杯嵌入式stm32g431资源包是一个专门为蓝桥杯嵌入式比赛准备的开发资源包。其中包含了stm32g431系列芯片的开发板、软件开发工具以及相关的学习资料。 stm32g431是意法半导体推出的一款高性能32位微控制器，具有强大的计算和通信能力，广泛应用于工业控制、消费电子和物联网等领域。 资源包中的开发板是一个基于stm32g431芯片的硬件平台，具有丰富的外设，如数字接口、模拟接口、通信接口等，可以满足各类应用的需要。 软件开发工具包含了stm32g431芯片的开发环境，其中包括了编译器、调试器、下载器等工具，可以帮助开发者快速编写和调试嵌入式软件。 另外，资源包还附带了详尽的学习资料，包括stm32g431芯片的技术手册、编程手册和应用指南等，帮助开发者了解芯片的特性和使用方法。同时还提供了丰富的案例程序和实例代码，供开发者学习和参考。 通过使用蓝桥杯嵌入式stm32g431资源包，开发者可以快速入门和掌握stm32g431芯片的开发技术，为参加蓝桥杯嵌入式比赛做好准备。无论是初学者还是有经验的开发者都可以通过资源包中提供的文档和代码进行学习和实践，从而提升自己的嵌入式开发能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

计算机小混子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值