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

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

题目

image-20240212223046453

image-20240212223055564

image-20240212223105664

分析和代码

main.h

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

/* 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 */
#include "lcd.h"
/* USER CODE END Includes */

/* Exported types ------------------------------------------------------------*/
/* USER CODE BEGIN ET */
struct Time{
	uint8_t hours;
	uint8_t minutes;
	uint8_t seconds;
};

typedef enum {
    COUNTDOWN_STOPPED,
    COUNTDOWN_RUNNING,
    COUNTDOWN_PAUSED
} CountdownStatus;
/* 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 */

/* USER CODE END Private defines */

#ifdef __cplusplus
}
#endif

#endif /* __MAIN_H */

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

Time结构体定义了时间的数据类型，CountdownStatus是一个枚举类型，表示了定时器的三种状态

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

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

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
extern struct Key key[4];
uint8_t lcdtext[30];
uint8_t timerstatus[20]= "Standby";
uint8_t timernum = 0;
uint8_t view = 1;
CountdownStatus countdownStatus = COUNTDOWN_STOPPED; // 初始状态为停止
uint32_t ledtime;
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

struct Time time; //当前计时的时间
struct Time times[5];//存储五个准备好的定时时间
struct EeromAddr{
    uint8_t addr1;
    uint8_t addr2;
    uint8_t addr3;
} addr[5] = {
    {0x01, 0x02, 0x03},  // 第一个结构体的初值
    {0x04, 0x05, 0x06},  // 第二个结构体的初值
    {0x07, 0x08, 0x09},  // 第三个结构体的初值
    {0x0A, 0x0B, 0x0C},  // 第四个结构体的初值
    {0x0D, 0x0E, 0x0F}   // 第五个结构体的初值
};
/* 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 key_process(void);
void lcd_process(void);
void pwmAndLed_process(void);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void StartCountdown(void) {
    if (countdownStatus != COUNTDOWN_RUNNING) {
        countdownStatus = COUNTDOWN_RUNNING;
			sprintf((char *)timerstatus, "Running");
    }
}

void PauseCountdown(void) {
    if (countdownStatus == COUNTDOWN_RUNNING) {
        countdownStatus = COUNTDOWN_PAUSED;
				sprintf((char *)timerstatus, "Pause");
    }
}

void StopCountdown(void) {
    countdownStatus = COUNTDOWN_STOPPED;
    sprintf((char *)timerstatus, "Standby");
}


void ReadFromEeprom(void)
{
	for (int i = 0; i < 5; i++) {
				times[i].hours = EEROM_Read(addr[i].addr1);
				HAL_Delay(5);
				times[i].minutes = EEROM_Read(addr[i].addr2);
				HAL_Delay(5);
				times[i].seconds = EEROM_Read(addr[i].addr3);
				HAL_Delay(5);
		}
	
}
/* 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_TIM2_Init();
  MX_TIM16_Init();
  /* USER CODE BEGIN 2 */

    LCD_Init();
		HAL_TIM_Base_Start_IT(&htim2);
  /* USER CODE END 2 */

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

    LCD_Clear(Black);
    LCD_SetBackColor(Black);
    LCD_SetTextColor(White);
		LED_display(0x00);
		// 假设EEROM_Read是您用来读取EEPROM数据的函数
		ReadFromEeprom();
		time = times[timernum];//默认是第一个
    while (1)
    {
			pwmAndLed_process();
			lcd_process();
			key_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};

  /** 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();
  }
}

/* USER CODE BEGIN 4 */
void key_process(void)
{
    // 按键0：切换计时器编号并读取时间
    if (key[0].key_single_flag && view == 1) {
        key[0].key_single_flag = 0; // 清除标志位
        timernum = (timernum + 1) % 5; // 循环通过计时器编号
				LCD_Clear(Black);
				LCD_SetBackColor(Black); 
				LCD_SetTextColor(White); 
        // 从EEPROM读取时间
				ReadFromEeprom();
        time = times[timernum]; //加载存储的时间为当前时间
       
    }
		
    // 按键1（短按）：在主视图切换到设置视图，或在设置视图中切换设置项
    if (key[1].key_single_flag) {
        key[1].key_single_flag = 0; // 清除标志位
				LCD_Clear(Black);
				LCD_SetBackColor(Black); // 根据需要设置背景色
				LCD_SetTextColor(White); // 根据需要设置文字色
        if (view == 1) {
            // 如果在主视图，进入设置模式
            view = 2; // 进入设置视图
            sprintf((char *)timerstatus, "Setting");
					time = times[timernum];
        } else if (view >= 2 && view < 5) {
            // 在设置模式下，循环切换设置项
            view++;
        } else if (view == 5) {
            // 如果已经在设置秒的视图，回到设置小时视图
            view = 3;
        }
    }

    // 按键1（长按）：保存设置并返回主视图
    if (key[1].key_long_flag && (view >= 3 && view <= 5)) {
        key[1].key_long_flag = 0; // 清除标志位
        // 将当前时间写入EEPROM
        EEROM_Write(addr[timernum].addr1, time.hours);
				HAL_Delay(10);
        EEROM_Write(addr[timernum].addr2, time.minutes);
				HAL_Delay(10);
        EEROM_Write(addr[timernum].addr3, time.seconds);
				HAL_Delay(10);
				ReadFromEeprom();
        // 更新显示状态并返回主视图
        sprintf((char *)timerstatus, "Standby");
				// 清屏并准备显示主视图的信息
				LCD_Clear(Black);
				LCD_SetBackColor(Black); // 根据需要设置背景色
				LCD_SetTextColor(White); // 根据需要设置文字色
        view = 1;
				
    }

    // 按键2：根据当前视图调整时间
    if (key[2].key_single_flag) {
        key[2].key_single_flag = 0; // 清除标志位

        switch (view) {
            case 3: // 调整小时
                time.hours = (time.hours + 1) % 24;
                break;
            case 4: // 调整分钟
                time.minutes = (time.minutes + 1) % 60;
                break;
            case 5: // 调整秒
                time.seconds = (time.seconds + 1) % 60;
                break;
        }
    }
		
		// 处理B4的短按和长按事件
if (key[3].key_single_flag == 1) {
    key[3].key_single_flag = 0; // 清除短按标志位
		LCD_Clear(Black);
		LCD_SetBackColor(Black); // 根据需要设置背景色
		LCD_SetTextColor(White); // 根据需要设置文字色
    // 短按逻辑，用于开始、暂停和恢复倒计时
    if (view == 1 && countdownStatus == COUNTDOWN_STOPPED) {
        StartCountdown();//开始倒计时
    } else if (view == 1 && countdownStatus == COUNTDOWN_RUNNING) {
        PauseCountdown();
    } else if (view == 1 && countdownStatus == COUNTDOWN_PAUSED) {
        StartCountdown(); // 使用StartCountdown来恢复倒计时
    }
} else if (key[3].key_long_flag == 1) {
    key[3].key_long_flag = 0; // 清除长按标志位

    // 长按逻辑，用于取消倒计时并返回到初始状态
    if (view == 1) {
        StopCountdown();
        // 可能需要重置倒计时时间
        time.hours = times[timernum].hours;
        time.minutes = times[timernum].minutes;
        time.seconds = times[timernum].seconds ;
        
    }
}



}

void lcd_process(void)
{
	switch(view)
	{
		case 1:
		{
	
			sprintf((char *)lcdtext,"  No %d",timernum+1);
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext,"     %02d:%02d:%02d",time.hours,time.minutes,time.seconds);
			LCD_DisplayStringLine(Line3,lcdtext);
			sprintf((char *)lcdtext,"      %s",timerstatus);
			LCD_DisplayStringLine(Line5,lcdtext);
		}break;
		case 2: //设置界面
		{
		
			sprintf((char *)lcdtext,"  No %d",timernum+1);
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext,"     %02d:%02d:%02d",time.hours,time.minutes,time.seconds);
			LCD_DisplayStringLine(Line3,lcdtext);
			sprintf((char *)lcdtext,"      %s",timerstatus);
			LCD_DisplayStringLine(Line5,lcdtext);
		}break;
		case 3: //设置小时
		{
		
			sprintf((char *)lcdtext,"  No %d",timernum+1);
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext,"     %02d:%02d:%02d",time.hours,time.minutes,time.seconds);
			LCD_DisplayStringLine(Line3,lcdtext);
			sprintf((char *)lcdtext,"     --");
			LCD_SetTextColor(Green);
			LCD_DisplayStringLine(Line4,lcdtext);
			LCD_SetTextColor(White);
			sprintf((char *)lcdtext,"      %s",timerstatus);
			LCD_DisplayStringLine(Line5,lcdtext);
		}break;
		case 4://设置分钟
		{
			
			sprintf((char *)lcdtext,"  No %d",timernum+1);
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext,"     %02d:%02d:%02d",time.hours,time.minutes,time.seconds);
			LCD_DisplayStringLine(Line3,lcdtext);
			
			sprintf((char *)lcdtext,"        --");
			LCD_SetTextColor(Green);
			LCD_DisplayStringLine(Line4,lcdtext);
			LCD_SetTextColor(White);
			sprintf((char *)lcdtext,"      %s",timerstatus);
			LCD_DisplayStringLine(Line5,lcdtext);
		}break;
		case 5://设置秒
		{
		
			sprintf((char *)lcdtext,"  No %d",timernum+1);
			LCD_DisplayStringLine(Line1,lcdtext);
			sprintf((char *)lcdtext,"     %02d:%02d:%02d",time.hours,time.minutes,time.seconds);
			LCD_DisplayStringLine(Line3,lcdtext);
			
			sprintf((char *)lcdtext,"           --");
			LCD_SetTextColor(Green);
			LCD_DisplayStringLine(Line4,lcdtext);
			LCD_SetTextColor(White); 
			sprintf((char *)lcdtext,"       %s",timerstatus);
			LCD_DisplayStringLine(Line5,lcdtext);
		}break;
	}
	
}
void pwmAndLed_process(void)
{
	static _Bool ledflag = false;
	if(countdownStatus == COUNTDOWN_RUNNING)
	{
		HAL_TIM_PWM_Start(&htim16, TIM_CHANNEL_1);
		__HAL_TIM_SET_COMPARE(&htim16,TIM_CHANNEL_1,800);
		if(uwTick-ledtime<500)
			return;
		ledtime = uwTick;//更新时间
		ledflag = !ledflag;
		if(ledflag)
		{
			LED_display(0x01);
		}else{
			
			LED_display(0x00);
		}
		
	}else{
		HAL_TIM_PWM_Stop(&htim16, TIM_CHANNEL_1);
		LED_display(0x00);
	}
}



/* 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****/

EeromAddr是一个用于存储时间的小时分钟还有秒的数据地址，这个地址是EEPROM中的地址，题目要求可以设置五个默认的定时时间，struct Time times[5];用于存储五个定时时间，uint8_t timernum = 0;相当于一个指针，指向当前定时的时间，范围在times的范围0-4之间，time是当前使用的定时器的时间，view是屏幕显示状态的索引。

StartCountdown调用后开始计时，PauseCountdown调用后暂停计时，StopCountdown调用后停止计时

ReadFromEeprom用于将EEPROM中的存储的时间读取到times数组中，每次读取后与下一次读取需要有时间间隔防止实训混乱

key_process中按键以用于切换五个不同的定时时间，仅仅在view=1即展示状态才可以切换，使用mod运算timernum = (timernum + 1) % 5;保证timernum在0-4时间，为了防止后续修改与当前数组的值不同，每次按下按键以切换不同定时值时都需要调用ReadFromEeprom函数将times数组中的时间更新为最新的值

按下按键2后，通过判断不同的view确定不同的动作，当前在view=1展示状态下后点击按键2进入view=2设置状态，再次按下进入设置小时的状态下，之后每次按键按下都在设置小时、分钟、秒之间切换

如果长按按键2，保存当前设置的值到EEPROM中，同样每次写入时需要间隔一定时间，调用ReadFromEeprom更新times数组，回到view=1展示状态

按键3按下根据不同view设置时分秒的值

最后一个按键按键4，根据当前定时器的状态，控制短按需要执行的函数，同样只有view=1按下当前按键才有用，如果当前在停止或者暂停状态，短按按键4进入开始状态，然后短按暂停，长按停止同时将当前time的值设置为初始值

lcd_process中利用switch-case状态机模式显示不同的lcd状态

pwmAndLed_process用于处理pwm和led的状态，当countdownStatus == COUNTDOWN_RUNNING运行状态时，开始输出pwm设置占空比为80%，同时利用滴答定时器的UWTick来计时实现led以0.5s的周期闪烁，

led.h

#ifndef __LED_H
#define __LED_H

#include "stm32g4xx_hal.h"
#include "main.h"
void LED_display(uint8_t led);
#endif

led.c

#include "led.h"

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);
}

PD2是一个锁存器高电平打开引脚，设置的值才可以到led中

key.h

#ifndef __KEY_H
#define __KEY_H

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

struct Key{
	uint8_t key_status;
	bool key_gpio;
	bool key_single_flag;
	bool key_long_flag;
	uint8_t key_times;
};
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim);
#endif

比上次几个版本多了判断长时间按下和按下按键的时间

key.c

#include "key.h"
#define FAST_INCREMENT_PERIOD 10 // 快速增加的周期计数阈值
struct Key key[4]={0,0,0,0};
extern struct Time time;
extern uint8_t view;

void IncreaseSettingValue(void) {
    // 根据当前设置的位置，递增小时、分钟或秒
    switch (view) {
        case 3:
			time.hours = (time.hours + 1) % 24;
            break;
        case 4:
             time.minutes = (time.minutes + 1) % 60;
            break;
        case 5:
            time.seconds = (time.seconds + 1) % 60;
            break;
    }

}


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<4;i++)
		{
			switch(key[i].key_status)
			{
				case 0:
				{
					if(key[i].key_gpio==0)
					{
						key[i].key_times = 0;//最新的一次按下
						key[i].key_status = 1;
					}
				}break;
				case 1:
				{
					if(key[i].key_gpio==0)
					{
						
						key[i].key_status = 2;
					}else{
							key[i].key_status = 0;
					}
				}break;
				case 2:
				{
					if(key[i].key_gpio==1) //按键已经松开
					{
						key[i].key_status = 0;
						if(key[i].key_times<80)
						{
							key[i].key_single_flag = 1;//短按
						}
						
					}else{ //按键没有松开，开始计时
							key[i].key_times++;
							if(key[i].key_times>80) //0.8s
							{
								key[i].key_long_flag = 1; //长按
								if (key[2].key_times % FAST_INCREMENT_PERIOD == 0) {
                
               					 IncreaseSettingValue(); 
								}
							}
					}
				}break;
			}
		}
		
	}
		

}

在case2中按键如果没有松开开始计时，该定时器中断是10ms进入一次，key_times++一次相当于过去了10ms，所以判断key[i].key_times>80可以判断是否为长按，在长按中判断是不是按键3按下并且设置一个FAST_INCREMENT_PERIOD周期实现每100ms调用IncreaseSettingValue增加一次

i2c_hal.h

#ifndef __I2C_HAL_H
#define __I2C_HAL_H

#include "stm32g4xx_hal.h"

void I2CStart(void);
void I2CStop(void);
unsigned char I2CWaitAck(void);
void I2CSendAck(void);
void I2CSendNotAck(void);
void I2CSendByte(unsigned char cSendByte);
unsigned char I2CReceiveByte(void);
void I2CInit(void);
void EEROM_Write(uint8_t addr,uint8_t data); 
uint8_t EEROM_Read(uint8_t addr);
#endif

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);
}

void EEROM_Write(uint8_t addr,uint8_t data)
{
	I2CStart();
	I2CSendByte(0xA0);
	I2CWaitAck();
	I2CSendByte(addr);
	I2CWaitAck();
	I2CSendByte(data);
	I2CWaitAck();
	I2CStop();
}

uint8_t EEROM_Read(uint8_t addr)
{
	uint8_t data = 0; // 定义一个变量来存储接收到的数据
	I2CStart();
	I2CSendByte(0xA0);
	I2CWaitAck();
	I2CSendByte(addr);
	I2CWaitAck();
	I2CStop();
	
	I2CStart();
	I2CSendByte(0xA1);
	I2CWaitAck();
	data = I2CReceiveByte();
	I2CWaitAck();
	I2CStop();
	
	return data; // 返回接收到的数据
}

stm32g4xx_it.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    stm32g4xx_it.c
  * @brief   Interrupt Service Routines.
  ******************************************************************************
  * @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 "stm32g4xx_it.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN TD */
extern struct Time time;
extern CountdownStatus countdownStatus;
/* USER CODE END TD */

/* 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 -----------------------------------------------*/
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/* External variables --------------------------------------------------------*/
extern TIM_HandleTypeDef htim2;
/* USER CODE BEGIN EV */

/* USER CODE END EV */

/******************************************************************************/
/*           Cortex-M4 Processor Interruption and Exception Handlers          */
/******************************************************************************/
/**
  * @brief This function handles Non maskable interrupt.
  */
void NMI_Handler(void)
{
  /* USER CODE BEGIN NonMaskableInt_IRQn 0 */

  /* USER CODE END NonMaskableInt_IRQn 0 */
  /* USER CODE BEGIN NonMaskableInt_IRQn 1 */

  /* USER CODE END NonMaskableInt_IRQn 1 */
}

/**
  * @brief This function handles Hard fault interrupt.
  */
void HardFault_Handler(void)
{
  /* USER CODE BEGIN HardFault_IRQn 0 */

  /* USER CODE END HardFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_HardFault_IRQn 0 */
    /* USER CODE END W1_HardFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Memory management fault.
  */
void MemManage_Handler(void)
{
  /* USER CODE BEGIN MemoryManagement_IRQn 0 */

  /* USER CODE END MemoryManagement_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */
    /* USER CODE END W1_MemoryManagement_IRQn 0 */
  }
}

/**
  * @brief This function handles Prefetch fault, memory access fault.
  */
void BusFault_Handler(void)
{
  /* USER CODE BEGIN BusFault_IRQn 0 */

  /* USER CODE END BusFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_BusFault_IRQn 0 */
    /* USER CODE END W1_BusFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Undefined instruction or illegal state.
  */
void UsageFault_Handler(void)
{
  /* USER CODE BEGIN UsageFault_IRQn 0 */

  /* USER CODE END UsageFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_UsageFault_IRQn 0 */
    /* USER CODE END W1_UsageFault_IRQn 0 */
  }
}

/**
  * @brief This function handles System service call via SWI instruction.
  */
void SVC_Handler(void)
{
  /* USER CODE BEGIN SVCall_IRQn 0 */

  /* USER CODE END SVCall_IRQn 0 */
  /* USER CODE BEGIN SVCall_IRQn 1 */

  /* USER CODE END SVCall_IRQn 1 */
}

/**
  * @brief This function handles Debug monitor.
  */
void DebugMon_Handler(void)
{
  /* USER CODE BEGIN DebugMonitor_IRQn 0 */

  /* USER CODE END DebugMonitor_IRQn 0 */
  /* USER CODE BEGIN DebugMonitor_IRQn 1 */

  /* USER CODE END DebugMonitor_IRQn 1 */
}

/**
  * @brief This function handles Pendable request for system service.
  */
void PendSV_Handler(void)
{
  /* USER CODE BEGIN PendSV_IRQn 0 */

  /* USER CODE END PendSV_IRQn 0 */
  /* USER CODE BEGIN PendSV_IRQn 1 */

  /* USER CODE END PendSV_IRQn 1 */
}

/**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */
	static uint32_t ticks = 0;
    
    if (countdownStatus == COUNTDOWN_RUNNING && ++ticks >= 1000) {
        ticks = 0; // 重置计数器
        // 倒计时逻辑
        if (time.seconds > 0) {
            time.seconds--;
        } else if (time.minutes > 0) {
            time.minutes--;
            time.seconds = 59;
        } else if (time.hours > 0) {
            time.hours--;
            time.minutes = 59;
            time.seconds = 59;
        } else {
            // 倒计时结束
            countdownStatus = COUNTDOWN_STOPPED;
           
        }
    }
  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */

  /* USER CODE END SysTick_IRQn 1 */
}

/******************************************************************************/
/* STM32G4xx Peripheral Interrupt Handlers                                    */
/* Add here the Interrupt Handlers for the used peripherals.                  */
/* For the available peripheral interrupt handler names,                      */
/* please refer to the startup file (startup_stm32g4xx.s).                    */
/******************************************************************************/

/**
  * @brief This function handles TIM2 global interrupt.
  */
void TIM2_IRQHandler(void)
{
  /* USER CODE BEGIN TIM2_IRQn 0 */

  /* USER CODE END TIM2_IRQn 0 */
  HAL_TIM_IRQHandler(&htim2);
  /* USER CODE BEGIN TIM2_IRQn 1 */

  /* USER CODE END TIM2_IRQn 1 */
}

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

SysTick_Handler是1ms进入一次使用SysTick_Handler定时ticks累积到1000时代表过去了1s，在这里倒计时

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【开源】SpringBoot框架开发数字化社区网格管理系统

【开源】SpringBoot框架开发数字化社区网格管理系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块三、开发背景四、系统展示五、核心源码5.1 查询企事业单位5.2 查询流动人口5.3 查询精准扶贫5.4 查询案件5.5 查询人口 六、免责说明 一、摘要 1.1 项目介绍 基于JAVAVueSpringBootMySQL的数字化社区网格管理系统&#xf…
阅读更多...
Prometheus服务器、Prometheus被监控端、Grafana、监控MySQL数据库、自动发现概述、配置自动发现、Alertmanager

Prometheus服务器、Prometheus被监控端、Grafana、监控MySQL数据库、自动发现概述、配置自动发现、Alertmanager

目录 Prometheus概述 部署Prometheus服务器 环境说明&#xff1a; 配置时间 安装Prometheus服务器 添加被监控端 部署通用的监控exporter Grafana 概述 部署Grafana 展示node1的监控信息 监控MySQL数据库 配置MySQL 配置mysql exporter 配置mysql exporter 配置…
阅读更多...
InternLM大模型实战-6.OpenCompass大模型评测

InternLM大模型实战-6.OpenCompass大模型评测

文章目录 前言笔记正文关于模型评测的三个问题为什么需要评测我们需要测什么怎么测试大语言模型 主流大模型评测框架OpenCompass大模型评测领域的挑战 前言 本文是对于InternLM全链路开源体系系列课程的学习笔记。【OpenCompass 大模型评测】 https://www.bilibili.com/video/…
阅读更多...
【开源】SpringBoot框架开发木马文件检测系统

【开源】SpringBoot框架开发木马文件检测系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 数据中心模块2.2 木马分类模块2.3 木马软件模块2.4 安全资讯模块2.5 脆弱点模块2.6 软件检测模块 三、系统设计3.1 用例设计3.2 数据库设计3.2.1 木马分类表3.2.2 木马软件表3.2.3 资讯表3.2.4 脆弱点表3.2.5 软件检测表…
阅读更多...
AtCoder Beginner Contest 340（A-G）

AtCoder Beginner Contest 340（A-G）

A - Arithmetic Progression (atcoder.jp) 1.思路&#xff1a;循环输出即可 2.代码&#xff1a; #include <bits/stdc.h> #define rep(i,z,n) for(int i z;i < n; i) #define per(i,n,z) for(int i n;i > z; i--) #define PII pair<int,int> #define fi f…
阅读更多...
利用Windows10漏洞破解密码(保姆级教学)

利用Windows10漏洞破解密码(保姆级教学)

前言: 本篇博客只是技术分享并非非法传播知识,实验内容均是在虚拟机中进行,并非真实环境 正文: 一.windows10电脑密码破解 1)开启windows10虚拟机,停留在这个页面 2&#xff09;按5次Shift键,出现这个粘滞键,如果没有出现的,则说明漏洞已经修复 3)重新启动,在这个页面的时候…
阅读更多...
Tied Block Convolution: 具有共享较薄滤波器的更简洁、更出色的CNN

Tied Block Convolution: 具有共享较薄滤波器的更简洁、更出色的CNN

摘要 https://arxiv.org/pdf/2009.12021.pdf 卷积是卷积神经网络&#xff08;CNN&#xff09;的主要构建块。我们观察到&#xff0c;随着通道数的增加&#xff0c;优化后的CNN通常具有高度相关的滤波器&#xff0c;这降低了特征表示的表达力。我们提出了Tied Block Convolutio…
阅读更多...
文件包含知识点详细总结

文件包含知识点详细总结

如果想看图片和观感更好的话，可以直接去我的github或者gitbook github：https://github.com/kakaandhanhan/cybersecurity_knowledge_book-gitbook.22kaka.fun gitbook：http://22kaka.fun description: 这里将通过参考文章和做题一起进行总结，并且文件包含漏洞，很多都利用了…
阅读更多...
Hive调优——explain执行计划

Hive调优——explain执行计划

一、explain查询计划概述 explain将Hive SQL 语句的实现步骤、依赖关系进行解析&#xff0c;帮助用户理解一条HQL 语句在底层是如何实现数据的查询及处理&#xff0c;通过分析执行计划来达到Hive 调优&#xff0c;数据倾斜排查等目的。 https://cwiki.apache.org/confluence/d…
阅读更多...
C++ //练习 5.24 修改你的程序，使得当第二个数是0时抛出异常。先不要设定catch子句，运行程序并真的为除数输入0，看看会发生什么？

C++ //练习 5.24 修改你的程序，使得当第二个数是0时抛出异常。先不要设定catch子句，运行程序并真的为除数输入0，看看会发生什么？

C Primer&#xff08;第5版&#xff09; 练习 5.24 练习 5.24 修改你的程序&#xff0c;使得当第二个数是0时抛出异常。先不要设定catch子句&#xff0c;运行程序并真的为除数输入0&#xff0c;看看会发生什么&#xff1f; 环境&#xff1a;Linux Ubuntu&#xff08;云服务器…
阅读更多...
那些也许你不知道的操作符！

那些也许你不知道的操作符！

前言 操作符有很多种&#xff0c;目前我们已经了解了一部分 例如最简单的、-、*、/、&#xff0c;还有我们学到的&&&#xff0c;||&#xff0c;!等&#xff0c;但是操作符可不是就只有这么些的&#xff0c;让我们一起来看看吧 目录 1. 移位操作符 原码、反码、补码…
阅读更多...
Ubuntu Desktop - scrolling (Terminal 缓存更多终端历史输出内容)

Ubuntu Desktop - scrolling (Terminal 缓存更多终端历史输出内容)

Ubuntu Desktop - scrolling [Terminal 缓存更多终端历史输出内容] 1. ubuntu-14.04.5-desktop-amd64.iso2. ubuntu-16.04.3-desktop-amd64.isoReferences Terminal -> 右键 Profiles -> Profile Preferences 1. ubuntu-14.04.5-desktop-amd64.iso 2. ubuntu-16.04.3-de…
阅读更多...
手动汉化unity编辑器，解决下载中文语言报错问题

手动汉化unity编辑器，解决下载中文语言报错问题

手动汉化unity编辑器&#xff0c;解决下载中文语言报错问题 START 最近在下载支持微信小程序版本的编辑器时&#xff0c;中文语言包&#xff0c;一直无法下载。记录一下 手动汉化unity编辑器的方法 &#xff0c;帮助和我遇到同样问题的人。 解决方案 1. 下载汉化包 https:…
阅读更多...
origin技巧

origin技巧

origin技巧 1.去掉白边2.曲线平滑3.合并多层图例3.图例换方向 1.去掉白边 ctrlu 2.曲线平滑 3.合并多层图例 3.图例换方向 图例右键 “图例” 水平排布修改图例字&#xff1a;双击图例修改 https://blog.csdn.net/m0_47746156/article/details/121295151 https://blog.csdn.…
阅读更多...
Ocr之TesseractOcr的安装及使用

Ocr之TesseractOcr的安装及使用

目录 一、安装环境 二、安装内容 三、安装过程及识别测试 1. 安装过程 2. 程序编写 总结 1. 安装复杂度较低 2. 国外开源Ocr 3. 可设置识别参数 4. 工具类 一、 系统环境windows 10 linux环境也可安装, 可借鉴此篇文章>> | 二、安装内容 Tesseract exe 程序安…
阅读更多...
CVE-2022-25578 漏洞复现

CVE-2022-25578 漏洞复现

CVE-2022-25578 路由/admin/admin.php是后台&#xff0c;登录账号和密码默认是admin、tao&#xff0c;选择文件管理。 是否还记得文件上传中的.htaccess配置文件绕过发&#xff0c;在这个文件中加入一句AddType application/x-httpd-php .jpg&#xff0c;将所有jpg文件当作php…
阅读更多...
位运算+leetcode（1）

位运算+leetcode（1）

基础 1.基础知识 以下都是针对数字的二进制进行操作 >> 右移操作符<< 左移操作符~ 取反操作符 & 有0就是0&#xff0c;全一才一 | 有一才一 &#xff0c;全0才0^ 相同为0&#xff0c;相异为1 异或( ^ )运算的规律 a ^ 0 a a ^ a 0a ^ b ^ c a ^ (b …
阅读更多...
【Java程序设计】【C00252】基于Springboot的实习管理系统（有论文）

【Java程序设计】【C00252】基于Springboot的实习管理系统（有论文）

基于Springboot的实习管理系统&#xff08;有论文&#xff09; 项目简介项目获取开发环境项目技术运行截图 项目简介 这是一个基于Springboot的实习管理系统 本系统分为前台功能模块、管理员功能模块、教师功能模块、学生功能模块以及实习单位功能模块。 前台功能模块&#xf…
阅读更多...
hook函数——useMemo

hook函数——useMemo

useMemo 1.useMemo定义 useMemo 是一个 React Hook&#xff0c;它在每次重新渲染的时候能够缓存计算的结果。 const 变量名 useMemo(calculateValue, dependencies) calculateValue&#xff1a;要缓存计算值的函数。它应该是一个没有任何参数的纯函数&#xff0c;并且可以返…
阅读更多...
【程序设计竞赛】竞赛中的细节优化

【程序设计竞赛】竞赛中的细节优化

必须强调下&#xff0c;以下的任意一种优化&#xff0c;都应该是在本身采用的算法没有任何问题情况下的“锦上添花”&#xff0c;而不是“雪中送炭”。 如果下面的说法存在误导&#xff0c;请专业大佬评论指正 读写优化 C读写优化——解除流绑定 在ACM里&#xff0c;经常出现…
阅读更多...
最新文章

Copyright @ 2022~2023