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

最新推荐文章于 2024-05-30 01:21:48 发布
最新推荐文章于 2024-05-30 01:21:48 发布
阅读量3.3k 收藏 33
点赞数 16
分类专栏： 单片机 文章标签： 蓝桥杯 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);
	}
	
}
计算机小混子
关注
  • 16
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
蓝桥杯第七届决赛题
03-22
这个代码我是在参加2018年蓝桥杯嵌入式初赛前写的，代码有很多问题吧仅供参考
蓝桥杯第七届嵌入式国赛模拟题
10-03
第七届蓝桥杯国赛代码，功能实现，适用于参加蓝桥杯嵌入式竞赛的同学。
蓝桥杯嵌入式第七届程序设计题
m0_73572338的博客
04-02 380
本次的记录是第七届蓝桥杯省赛程序设计题在本次的题目中，除了按键消抖用到一个定时器外，还有测量R37的输出电压，三个LED灯这两个地方需要定时来操作。为了减少定时器的数目，所以我这里只定时了一个0.2秒的定时器，题目中的一秒就采用了计数的方式来实现，也不用一会儿开启一会儿关闭。/**********************************回调函数**********************************/i<4;
第七届蓝桥杯嵌入式（省赛）程序题
m0_51095029的博客
05-03 1215
第七届蓝桥杯（省赛）解读+程序解读：这里自己多读几遍设计任务以及要求再看下面`A):先搭总体框架`各初始化函数:`LCD初始化``按键初始化``ADC初始化``i2c初始化``USART2初始化``LED初始化`注：仅展示部分初始化函数，完整程序请下载工程查看`B):LCD处理函数``C):按键处理函数``D):ADC处理函数``E):UART处理函数``F):LED处理函数``G):整体程序设计参考` 解读： 模拟液位检测系统中，实验设计任务要求: 依据实验设计任务，所要用到的片内，.
STM32LED--基于HAL库(第七届蓝桥杯嵌入式省赛)
Octopus1633的博客
03-20 1224
STM32正持续关注LED与LCD的日益增长的冲突……
第七届蓝桥杯嵌入式（国赛）程序题
m0_51095029的博客
06-26 1472
第七届蓝桥杯（国赛）解读+程序任务书：分析：大体流程1.LCD显示2.实时时钟3.ADC采集（模拟温度）4.定时器输出比较（可调频率），输入捕获（模拟湿度）5.按键功能+采样周期+设置参数存储6.串口功能+存储7.报警功能程序整体设计完整工程下载 任务书： 先多读几遍任务书要求，需要用到哪些外设？需要实现哪些功能？各功之间如何较好的关联？ 分析： 任务书中自我感觉有两个稍废时间的功能，1.湿度的采集2，保存六十组数据并更新 后面重点讲解 大体流程 1.LCD显示 2.实时时钟 3.AD.
【STM32G431RBTx】备战蓝桥杯嵌入式→决赛试题→第七届
qq_66792436的博客
05-20 1061
无本篇文章只是为了存放我的代码，所以看不懂很正常，如果需要代码可以找我私信。
蓝桥杯嵌入式2016第七届省赛真题解答
qq_49552487的博客
04-05 3725
1 题目分析 使用到的外设：LED、LCD、按键、串口、ADC、I2C。 2 Cubemx配置 外设具体方法参考我写的其他文章 配置完成如下： 时钟树配置如下: 3 文件移植 其中灯和按键程序自己添加 添加到项目中 先编译，左边会显示出添加的文件 添加头文后再编译一下，确保头文件和.c文件都被正确引用 4代码 所有的外设配置Cubemx都配置好了，无需自己配置（巨省工作量） 下面介绍自己添加的部分 4.1 led和Key部分 头......
蓝桥杯嵌入式第七届省题
weixin_51914919的博客
02-25 1622
第七届蓝桥杯嵌入式 这一届的蓝桥杯省题他的用到的外设相对于来说还是比较多的，有用到ADC、EEPROM、USART、led、key这些外设，可以说除了没用到PWM、蜂鸣器之外，蓝桥杯嵌入式的考点涉及的外设大多都包含在里面了。可以说也是比较齐全了,不过我们也不要给自己太大的压力，把基本的配置学会了，main函数编写起来还是简单的。 第七届题目要求是模拟液位警报系统，要求通过模拟电压信号（ADC）计算他液位高度，并在液位等级发生变化的时候通过串口发送到PC机上。 下面我们看看具体的要求。 1.液位高度、ADC
蓝桥杯嵌入式第8届真题(完成) STM32G431
Johnor的博客
02-06 2610
对比第六届和第七届，这届的题目在逻辑思维上确实要麻烦不少，可以从题目看出，这届题目对时间顺序的要求很严格，所以就可以使用状态机的思想来编程，拿到类似题目不要急着写代码，一定要先分析好步骤，想出状态转换的逻辑后，在根据逻辑写代码写起来就很快了。
蓝桥杯嵌入式STM32G431资源包
03-02
赛场资源包
第十二届蓝桥杯大赛嵌入式组STM32G431资源包
01-29
文件内包括所有蓝桥杯官方给的程序资料，驱动，产品手册等
蓝桥杯十二届嵌入式 省赛试题，完整代码，STM32G431
04-07
思路参考bilibili视频中介绍的思路，感谢bilibili大学，感谢up主。 仅考虑普通情况，其余特殊情况仍需具体进一步完善，后续完成后上传。 如果不足，欢迎指正。
蓝桥杯嵌入式第七届试卷及答案
02-19
本压缩包包含第七届嵌入式蓝桥杯试卷及答案，其中答案为本人根据大神改的；不喜勿碰；仅供参考。
蓝桥杯嵌入式第9届真题(完成) STM32G431
Johnor的博客
02-12 6192
Time结构体定义了时间的数据类型，CountdownStatus是一个枚举类型，表示了定时器的三种状态。
蓝桥杯嵌入式主板G431例程
02-21
蓝桥杯嵌入式主板G431详细例程代码
蓝桥杯 超级胶水 答疑
weixin_72770922的博客
05-29 438
【代码】蓝桥杯 超级胶水 答疑。
蓝桥杯 付账问题，交换次数，密码脱落
最新发布
weixin_72770922的博客
05-30 315
【代码】蓝桥杯 付账问题，交换次数，密码脱落。
蓝桥杯嵌入式十二届模拟
04-09
蓝桥杯嵌入式十二届模拟是蓝桥杯嵌入式大赛的一次模拟赛。蓝桥杯嵌入式大赛是由中国教育部主办的全国性大学生计算机竞赛，旨在培养和选拔优秀的嵌入式系统开发人才。比赛内容主要包括嵌入式系统设计与开发、单片机编程、硬件电路设计等方面。 蓝桥杯嵌入式十二届模拟赛是为了帮助参赛选手熟悉比赛形式和题型，提前进行练习和准备而设立的。模拟赛的题目和难度与实际比赛相似，可以帮助选手了解比赛的要求和考察的知识点，提高解题能力和应试技巧。 参加蓝桥杯嵌入式十二届模拟赛可以帮助选手提前熟悉比赛流程和规则，了解自己在嵌入式系统开发方面的水平，并通过与其他选手的竞争来提高自己的技术能力。同时，模拟赛也是选拔优秀选手进入正式比赛的一个重要环节。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

计算机小混子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值