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

news2024/9/22 5:33:17

蓝桥杯嵌入式第七届真题(完成) 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);
	}
	
}


本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1431265.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

NuxtJs安装Sass后出现ERROR:Cannot find module ‘webpack/lib/RuleSet‘

最近了解NuxtJs时&#xff0c;发现问题比较多&#xff0c;对于初学者来说是件比较头痛的事。这次是安装sass预处理器&#xff0c;通过命令安装后&#xff0c;出现了ERROR&#xff1a;Cannot find module webpack/lib/RuleSet 错误&#xff0c;于是根据之前经验&#xff0c;对版…

软件测试Bug系列之4个基本步骤(一)

目录 1.发现bug 2.提交bug 3.跟踪bug 4.总结bug 只要你一个测试人员 &#xff0c;就肯定离不开提交bug&#xff0c;跟踪bug的工作 。对于大多数的功能测试人员来说 &#xff0c;占比最多的工作就是和bug打交道 。可以说它是我们最重要的一块业绩 。所以&#xff0c;有必要静…

Python 连接 mysql 详解(mysql-connector-python)

文章目录 1 概述1.1 第三方库&#xff1a;mysql-connector-python1.2 可视化工具&#xff1a;navicat1.3 创建测试数据库 2 连接 mysql 数据库2.1 创建一个连接2.2 捕获连接异常2.3 从配置文件中获取连接信息 3 执行 sql 语句3.1 插入、更新、删除3.2 查询 1 概述 1.1 第三方库…

MySQL 小技巧:使用 xtrabackup 2.4 实现 完全备份及还原

演示&#xff1a;使用 xtrabackup 2.4 实现 完全备份及还原 本案例基于 CentOS 7 的 Mariadb5.5 实现&#xff0c;也支持 MySQL5.5 和 MySQL5.7 1) 安装 xtrabackup 包 // 先安装 Mariadb5.5 和 xtrabackup 包 [rootcentos7 ~] yum install mariadb-server -y [rootcentos7 ~]…

备份RK35XX 设备的ubuntu根文件系统的方法

简介 我们使用 RK35XX 提供的SDK包制作了一个完整的 ubuntu 镜像,烧录到设备中,会在设备中安装很多我们需要的软件,运行的一些自己写的脚本和业务程序,当我们有很多台设备时,不可能每台都一个个去安装,此时我们就需要一个工具来备份当前设备的根文件系统,然后再放到 SD…

面试八股文(3)

文章目录 1.HashSet如何检查重复2.comparable和Comparator区别3.ConcurrentHashMap和Hashtable区别4.线程和进程5.并发与并行的区别6.为什么使用多线程7.使用多线程可能带来问题8.线程的生命周期和状态9.什么是上下文切换10.线程死锁11.产生死锁四个条件12.如何避免死锁 1.Hash…

【项目日记(八)】第三层: 页缓存的具体实现(下)

&#x1f493;博主CSDN主页:杭电码农-NEO&#x1f493;   ⏩专栏分类:项目日记-高并发内存池⏪   &#x1f69a;代码仓库:NEO的学习日记&#x1f69a;   &#x1f339;关注我&#x1faf5;带你做项目   &#x1f51d;&#x1f51d; 开发环境: Visual Studio 2022 项目日…

在windows和Linux中的安装 boost 以及 安装 muduo 和 mysql

一、CMake安装 Ubuntu Linux 下安装和卸载cmake 3.28.2版本-CSDN博客https://blog.csdn.net/weixin_41987016/article/details/135960115?spm1001.2014.3001.5501二、安装boost boost官网&#xff1a;boost官网 我下载的boost版本&#xff1a; windows:boost_1_84_0.zipli…

基于SpringBoot的家电销售展示网页的设计与实现

文章目录 项目介绍主要功能截图&#xff1a;部分代码展示设计总结项目获取方式 &#x1f345; 作者主页&#xff1a;超级无敌暴龙战士塔塔开 &#x1f345; 简介&#xff1a;Java领域优质创作者&#x1f3c6;、 简历模板、学习资料、面试题库【关注我&#xff0c;都给你】 &…

k8s Sidecar filebeat 收集容器中的trace日志和app日志

目录 一、背景 二、设计 三、具体实现 Filebeat配置 K8S SideCar yaml Logstash配置 一、背景 将容器中服务的trace日志和应用日志收集到KAFKA&#xff0c;需要注意的是 trace 日志和app 日志需要存放在同一个KAFKA两个不同的topic中。分别为APP_TOPIC和TRACE_TOPIC 二、…

vulhub中spring的CVE-2022-22947漏洞复现

Spring Cloud Gateway是Spring中的一个API网关。其3.1.0及3.0.6版本&#xff08;包含&#xff09;以前存在一处SpEL表达式注入漏洞&#xff0c;当攻击者可以访问Actuator API的情况下&#xff0c;将可以利用该漏洞执行任意命令。 参考链接&#xff1a; https://tanzu.vmware.c…

SpringBoot security 安全认证(三)——自定义注解实现接口放行配置

背景&#xff1a;通过Security实现了安全管理&#xff0c;可以配置哪些接口可以无token直接访问。但一个麻烦就是每增加一个匿名访问接口时都要去修改SecurityConfig配置&#xff0c;从程序设计上讲是不太让人接受的。 本节内容&#xff1a;即是解决以上问题&#xff0c;增加一…

获取未来的5分钟整点时间05,10,15,20,25...

比如预约网约车的时候&#xff0c;是按5分钟的整点时间 GetMapping("/getFiveNextTime")public String fiveNextTime(RequestParam(defaultValue "0") Integer interval) {Calendar calendar Calendar.getInstance();calendar.add(Calendar.MINUTE, (5 …

MySQL进阶45讲【13】为什么表数据删掉一半,表文件大小不变?

1 前言 有些小伙伴在删数据库数据时&#xff0c;会产生一个疑问&#xff0c;我的数据库占用空间大&#xff0c;我把一个最大的表删掉了一半的数据&#xff0c;怎么表文件的大小还是没变&#xff1f; 那么这篇文章&#xff0c;就介绍一下数据库表的空间回收&#xff0c;看看如…

以太网帧格式及ARP协议简介

在以太网中&#xff0c;一个主机和另一个主机进行通信&#xff0c;必须要知道目的主机的MAC地址&#xff08;物理地址&#xff09;&#xff0c;只要知道目的主机的IP地址&#xff0c;就可以通过ARP协议获取目的主机的MAC地址。 1、ARP协议简介 ARP&#xff08;Address Resolut…

leetcode刷题(剑指offer) 297.二叉树的序列化和反序列化

297.二叉树的序列化与反序列化 序列化是将一个数据结构或者对象转换为连续的比特位的操作&#xff0c;进而可以将转换后的数据存储在一个文件或者内存中&#xff0c;同时也可以通过网络传输到另一个计算机环境&#xff0c;采取相反方式重构得到原数据。 请设计一个算法来实现…

C语言-2

自定义类型 基本认识 /*引入&#xff1a;学生&#xff1a;姓名&#xff0c;学号&#xff0c;年龄&#xff0c;成绩请为学生们专门定制一个类型&#xff08;创造一个类型&#xff09;结构体格式&#xff1a;struct 标识符 // 标识符即自定义类型的名称{成员; // 自己设置…

H5 自适应超人背景引导页源码

H5 自适应超人背景引导页源码 源码介绍&#xff1a;一款自适应引导页源码&#xff0c;带超人背景。有四个跳转按钮。 下载地址&#xff1a; https://www.changyouzuhao.cn/11608.html

深度学习实战 | 卷积神经网络LeNet手写数字识别(带手写板GUI界面)

引言 在深度学习领域&#xff0c;卷积神经网络&#xff08;Convolutional Neural Network, CNN&#xff09;是一种广泛应用于图像识别任务的神经网络结构。LeNet是一种经典的CNN结构&#xff0c;被广泛应用于基础的图像分类任务。本文将介绍如何使用LeNet卷积神经网络实现手写…