2022蓝桥杯嵌入式第十三届省赛第二场程序设计题

已于 2022-06-27 20:11:05 修改
阅读量2.7k 收藏 38
点赞数 4
分类专栏： STM32 文章标签： 蓝桥杯
于 2022-06-22 10:50:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sanctuary1307/article/details/125404382
版权

省一了，简单分享下（虽然国赛白给了
程序设计题很重要，有85分，客观题（15分）我都是乱蒙的，但我程序设计全实现了（大概）所以才能省一。

开发板是新板，型号：CT117E-M4（STM32G431RBT6）

题目

如下图
程序设计题
这道题的最大坑点在于EEPROM的初始化，要仔细看题目最后的要求，上电初始化价格都是1.0，而题目中又要求从eeprom读取价格信息。其实就是要做一个eeprom是否是第一次上电的判断，如果是就初始化1.0，否则就直接从eeprom里读取就行了。

要实现是否第一次上电的判断，就是在eeprom的某个地址（题目要求之外的地址）存储一个自己的标志位。

在这道题里，eeprom要用到的地址是0-3，而我是在地址5写自己的标志位，数值66。每一次上电都从地址5处读取信息，看数值是不是66，如果不是就说明是第一次上电，这时候就可以把66写进去，同时也按照题目要求初始化价格为1.0。如果读到了66就说明不是第一次上电了，可以直接从eeprom读取信息。

代码

代码用的cubemx配置生成的工程，这个软件用起来很方便，建议要参加蓝桥杯嵌入式的都学一下（不太清楚旧板子可不可以用）。
软件自动生成的英文注释懒得删了，自己写代码写在那些“User code begin”和“User code end”之间就不会被软件覆盖。

main.c
/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"

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

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

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

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

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
// 按键相关变量定义
__IO uint32_t uwTick_Key = 0;	// 消抖
uint8_t Key_Val, Key_Down, Key_Up, Key_Old;		// 存储键值

// LCD相关变量定义
__IO uint32_t uwTick_LCD = 0;	// 减速
uint8_t lstr[22];	// 屏幕显示字符串
int page = 1;			// 页面标号

// led
__IO uint32_t LD2 = 0;
__IO uint32_t LD1 = 0;
uint8_t led = 0;
int b4_flag = 0;

// EEPROM存储变量 
uint8_t xs, ys;		// 存储到eeprom中的商品库存
uint8_t xp, yp;		// 存储到eeprom中的商品价格
uint8_t num, num1= 66;			// 标记开发板是否第一次上电

// 串口相关变量定义
uint8_t rx;
char ustr1[20];
char ustr2[13];
int uflag = 0;	// 串口接收中断标志

// 商品相关变量定义
int x_buy = 0, y_buy = 0;						// 商品购买数量
uint8_t x_s, y_s;							// 商品存储数量
float x_price, y_price;	// 商品价格


// eeprom测试
//uint8_t eeprom_str1[5] = {0x11, 0x22, 0x33, 0x44, 0x55};
//uint8_t eeprom_str2[5] = {0};
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
// 功能函数定义
void KEY_Proc();		// 按键功能函数
void LCD_Proc();		// LCD屏幕显示功能函数
void UART_Proc1();	// B4按下串口发送信息
void UART_Proc2();	// 串口接收查询
void LED2_Proc();		// LED2控制程序 间隔0.1s闪烁
/* 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_USART1_UART_Init();
  MX_TIM2_Init();
  /* USER CODE BEGIN 2 */
	// 初始化LCD
	LCD_Init();
	LCD_Clear(Black);
	LCD_SetBackColor(Black);
	LCD_SetTextColor(White);
	
	// 初始化I2C
	I2CInit();
	xs = 10;	// 商品库存初始值10
	ys = 10;
	xp = 10;	// 商品价格初始值为1.0 放大10倍存入eeprom
	yp = 10;
	read_eeprom(&num, 5, 1);
	HAL_Delay(1);
	// 根据eeprom地址5的数据判断是否为第一次上电
	// 第一次上电需要将初始值写入EEPROM
	// 判断为非第一次上电将不会执行以下if段
	if(num != num1){							// 将num1的数值改为和eeprom地址5处数据不同 即判断为第一次上电
		write_eeprom(&xs, 0, 1);		// 不加延时会出错
		HAL_Delay(10);
		write_eeprom(&ys, 1, 1);
		HAL_Delay(10);
		write_eeprom(&xp, 2, 1);
		HAL_Delay(10);
		write_eeprom(&yp, 3, 1);
		HAL_Delay(10);
		num = num1;									// 第一次上电需要修改地址5处数值 以便下次上电判断
		write_eeprom(&num, 5, 1);
		HAL_Delay(1);
	}
	// 从EEPROM中读出
	read_eeprom(&xs, 0, 1);
	HAL_Delay(1);
	read_eeprom(&ys, 1, 1);
	HAL_Delay(1);
	read_eeprom(&xp, 2, 1);
	HAL_Delay(1);
	read_eeprom(&yp, 3, 1);
	
	
	x_s = xs;
	y_s = ys;
	x_price = (float)xp/10;
	y_price = (float)yp/10;
	// 初始化TIM2 PA1输出PWM
	HAL_TIM_Base_Start(&htim2);
	HAL_TIM_OC_Start_IT(&htim2, TIM_CHANNEL_2);
	
	// 开串口中断
	HAL_UART_Receive_IT(&huart1, &rx, 1);
	
	// EEPROM测试
//	write_eeprom(eeprom_str1, 0, 5);
//	HAL_Delay(10);
//	read_eeprom(eeprom_str2, 0, 5);
	

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		if(uflag) UART_Proc2();
		KEY_Proc();
		LCD_Proc();
		LED_Disp(led);
		if(x_s == 0&& y_s == 0){
			LED2_Proc();
		}
		else{
			led &= ~(0x02);
		}
		if(b4_flag){
			if((uwTick - LD1) >= 5000){
				led &= ~(0x01);
				__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_2, 25);
				b4_flag = 0;
			}
		}
    /* 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_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV3;
  RCC_OscInitStruct.PLL.PLLN = 20;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */
// 按键功能函数
void KEY_Proc()
{
	if((uwTick - uwTick_Key) < 20) return ;
	uwTick_Key = uwTick;
	
	Key_Val = KEY_Scan();
	Key_Down = Key_Val&(Key_Old^Key_Val);
	Key_Up = ~Key_Val&(Key_Old^Key_Val);
	Key_Old = Key_Val;
	
	// 按键B1 翻页
	if(Key_Down == 1){
		if(page < 3) page++;
		else page = 1;
		LCD_Clear(Black);
	}
	// 按键B2 商品X
	else if(Key_Down == 2){
		if(page == 1){
			if(x_buy < x_s) x_buy += 1;
			else{
				x_buy = 0;
				LCD_Clear(Black);
			}
		}
		else if(page == 2){
			if(x_price < 2) x_price += 0.1;
			else x_price = 1.0;
			xp = x_price * 10;
			write_eeprom(&xp, 2, 1);
		}
		else if(page == 3){
			x_s += 1;
			xs = x_s;
			write_eeprom(&xs, 0, 1);
		}
	}
	// 按键B3 商品Y
	else if(Key_Down == 3){
		if(page == 1){
			if(y_buy < y_s) y_buy += 1;
			else{
				y_buy = 0;
				LCD_Clear(Black);
			}
		}
		else if(page == 2){
			if(y_price < 2) y_price += 0.1;
			else y_price = 1.0;
			yp = y_price * 10;
			write_eeprom(&yp, 3, 1);
		}
		else if(page == 3){
			y_s += 1;
			ys = y_s;
			write_eeprom(&ys, 1, 1);
		}
	}
	// 按键B4 确认购买
	else if(Key_Down == 4){
		if(page == 1){
			x_s -= x_buy;
			y_s -= y_buy;
			UART_Proc1();
			xs = x_s;
			ys = y_s;
			write_eeprom(&xs, 0, 1);
			HAL_Delay(1);
			write_eeprom(&ys, 1, 1);
			x_buy = 0;
			y_buy = 0;
			LCD_Clear(Black);
			b4_flag = 1;
			LD1 = uwTick;
			led |= 0x01;
			__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_2, 150);
		}
	}
}

// LCD屏幕显示功能函数
void LCD_Proc()
{
	// 减速
//	if((uwTick - uwTick_LCD) < 100) return ;
//	uwTick_LCD = uwTick;
	
	// 商品购买界面
	if(page == 1){
		sprintf((char *)lstr, "        SHOP");
		LCD_DisplayStringLine(Line1, lstr);
		sprintf((char *)lstr, "     X:%d", x_buy);
		LCD_DisplayStringLine(Line3, lstr);
		sprintf((char *)lstr, "     Y:%d", y_buy);
		LCD_DisplayStringLine(Line4, lstr);
	}
	// 商品价格界面
	else if(page == 2){
		sprintf((char *)lstr, "        PRICE");
		LCD_DisplayStringLine(Line1, lstr);
		sprintf((char *)lstr, "     X:%.1f", x_price);
		LCD_DisplayStringLine(Line3, lstr);
		sprintf((char *)lstr, "     Y:%.1f", y_price);
		LCD_DisplayStringLine(Line4, lstr);
	}
	// 库存信息界面
	else if(page == 3){
		sprintf((char *)lstr, "        REP");
		LCD_DisplayStringLine(Line1, lstr);
		sprintf((char *)lstr, "     X:%d", x_s);
		LCD_DisplayStringLine(Line3, lstr);
		sprintf((char *)lstr, "     Y:%d", y_s);
		LCD_DisplayStringLine(Line4, lstr);
	}
	// eeprom测试
//	sprintf((char *)lstr, "EE: %02X,%02X,%02X,%02X,%02X", eeprom_str2[0],eeprom_str2[1],eeprom_str2[2],eeprom_str2[3],eeprom_str2[4]);
//	LCD_DisplayStringLine(Line3, lstr);
}

// LED1
void LED2_Proc()
{
	if((uwTick - LD2) < 100) return ;
	LD2 = uwTick;
	led ^= 0x02;
}

// 串口接收中断服务函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance == USART1){
		uflag = 1;	// 置串口接收标志位
	}
}

void UART_Proc1()
{
	float z = x_buy*x_price + y_buy*y_price;
	sprintf(ustr1, "X:%d,Y:%d,Z:%.1f\r\n", x_buy, y_buy, z);
	HAL_UART_Transmit(&huart1, (unsigned char *)ustr1, strlen(ustr1), 50);
}

void UART_Proc2()
{
	uflag = 0;	// 清串口接收标志位
	sprintf(ustr2, "X:%.1f,Y:%.1f\r\n", x_price, y_price);
	HAL_UART_Transmit(&huart1, (unsigned char *)ustr2, strlen(ustr2), 50);
	HAL_UART_Receive_IT(&huart1, &rx, 1);		// 再开中断
}

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
i2c_hal.c

这个文件比赛时官方有提供，就是其中的I2CWaitAck函数要改一下（倒数四行）。
还有eeprom读写函数要自己背下来。

/*
  程序说明: 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;
        }
    }
    // 以下三行有修改
    SCL_Output(0);
    delay1(DELAY_TIME);
		SDA_Output_Mode();
    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;
}

// I2C初始化
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);
}

//  函数功能： 写EEPROM
//	参数说明： data为写入的数据， addr指定E2PROM内部地址， len指示写入数据的长度
void write_eeprom(uint8_t* data, uint8_t addr, uint8_t len)
{
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	
	I2CSendByte(addr);
	I2CWaitAck();
	
	while(len--){
		I2CSendByte(*data++);
		I2CWaitAck();
	}
	I2CStop();
	delay1(500);
}

// 函数功能： 读EEPROM
// 参数说明： data存储读出的数据， addr指定要读的EEPROM内部地址， len指示读出数据的长度
void read_eeprom(uint8_t* data, uint8_t addr, uint8_t len)
{
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	
	I2CSendByte(addr);
	I2CWaitAck();
	
	I2CStart();
	I2CSendByte(0xa1);
	I2CWaitAck();
	while(len--){
		*data++ = I2CReceiveByte();
		if(len) I2CSendAck();
		else I2CSendNotAck();
	}
	I2CStop();

}
gpio.c

上面是cubemx生成的初始化代码不用管，下面的按键扫描函数和led控制函数都需要自己写，具体使用在主函数。

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    gpio.c
  * @brief   This file provides code for the configuration
  *          of all used GPIO pins.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "gpio.h"

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/*----------------------------------------------------------------------------*/
/* Configure GPIO                                                             */
/*----------------------------------------------------------------------------*/
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/** Configure pins as
        * Analog
        * Input
        * Output
        * EVENT_OUT
        * EXTI
*/
void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
                          |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12, GPIO_PIN_SET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);

  /*Configure GPIO pins : PC13 PC14 PC15 PC8
                           PC9 PC10 PC11 PC12 */
  GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
                          |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pin : PA0 */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : PB0 PB1 PB2 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PD2 */
  GPIO_InitStruct.Pin = GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

}

/* USER CODE BEGIN 2 */
// 按键扫描函数
uint8_t KEY_Scan()
{
	uint8_t value = 0;
	if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0) == GPIO_PIN_RESET) value = 1;
	if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == GPIO_PIN_RESET) value = 2;
	if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == GPIO_PIN_RESET) value = 3;
	if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET) value = 4;
	return value;
}

// LED控制函数
void LED_Disp(uint8_t leds)
{
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
                          |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12, 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, leds << 8, GPIO_PIN_RESET);
	HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
}
/* USER CODE END 2 */
Weird0_
关注
  • 4
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
2022 十三届 蓝桥杯省赛 嵌入式组真题（客观+程序设计）
04-09
2022 十三届 蓝桥杯省赛 嵌入式组真题（客观+程序设计）
蓝桥杯第十三届第二场程序设计题
05-15
蓝桥杯第十三届第二场程序设计题
蓝桥杯 单片机设计与开发项目 省赛历届真题
最新发布
m0_59473260的博客
03-16 1037
正在上传…重新上传取消第八届 蓝桥杯单片机设计与开发项目省赛 单片机设计与开发项目基础知识试题（30 分）一、填空题 1.1 IAP15F2K61S2单片机的定时器0具有4 种工作模式，当采用外部 12MHz晶振时，定时器最大定时长度为65536 μS。 1.2电路如下图所示，其输入电压UI1、UI2分别为0.1V和0.2V，试计算出输出电压UO的值-2.4 V。 正在上传…重新上传取消 正在上传…重新上传取消二、...
第十三届蓝桥杯嵌入式省赛真题
04-10
第一部分 客观试题（15分） 1）在STM32系列微控制器中，可以作为主时钟MCO输出的时钟源是（ ）。 A. HSI B. HSE C. SYSCLK D. HSE/2 2）三态门的输出状态包括（ ）。 A.高电平 B.低电平 C.模拟输出 D.高阻态 …… 第二部分 程序设计试题（85分） 3. 功能要求 3.1 功能概述. 1) 支持通过串口设定3位密码。 2) 通过竞赛板上的B1到B3按键，输入0-9密码值，通过B4按键确认密码。 3)通过PA1 引脚完成控制信号输出功能。 4)依试题要求，
第十三届蓝桥杯嵌入式程序设计
04-21
第十三届蓝桥杯嵌入式程序设计
第十届蓝桥杯嵌入式赛后总结及对以后参赛同学的建议
a568713197的博客
05-28 9006
赛后总结及对以后参赛同学的建议赛后总结个人情况关于蓝桥杯这个比赛参赛指导建议赛前准备比赛时的一些事项一些别的点 赛后总结 个人情况 自己在这次的蓝桥杯（第十届）中省赛以 省一（也是陕西赛区嵌入式组第一名）出线，在国赛中获得了 国二 的成绩（大概是国二五六名的样子，差国一应该也就是俩三个客观题的分数）。 自己从大一下学期开始学习32到现在有一年多的时间，用32做过不少的项目，参加电赛时使用的也是32...
第十三届蓝桥杯嵌入式国赛真题(基于HAL库的巨简代码＋超级详解)
关于你的一切我都在意
06-21 1万+
开发板：CT117E-M4(STM32G431RBT6) 开发环境： CubeMX+Keil5 涉及题目：第十三届蓝桥杯嵌入式国赛真题 难点：双路AD测量电压、输入捕获测频率、LCD屏幕翻转、冒泡法、初始上电判断、按键长短按
蓝桥杯嵌入式第十届省赛真题
qq_51663309的博客
11-24 9271
https://pan.baidu.com/s/1q2MypmcIN25I3ANcP2lJhg
蓝桥杯嵌入式历届程序题
qq_45591395的博客
04-11 602
蓝桥杯嵌入式历届程序题总结 总结 这是参加十三届蓝桥杯嵌入式所四处搜集的历届蓝桥杯嵌入式程序题包含第三到十三届，本人有完成一部分题目，已上传到gitee， 仓库链接 文件地址 免费开源 ...
蓝桥杯嵌入式——第十二届蓝桥杯嵌入式国赛客观题
FILWY_M
06-08 7501
1 填空题 嵌入式竞赛平台上板载的微控制器是： 3 级流水线，具有 128 Kbytes的Flash存储空间。（请在第一、二空格处填写10进制数值） 解析：STM32G431RBT6采用采用的是CotexM4，STM32F103RBT6采用的是CotexM3，都是采用三级流水线结构。 STM32G431RBT6数据手册里面可以查到拥有128KB得Flash。 嵌入式竞赛平台上板载的微控制器提供了 2 个逐次逼近模拟数字转换器，在12位、右对齐模式下，参考电压3.3V，当ADC数据寄存器中的值为0x381
嵌入式蓝桥杯客观题总结（4.19）
qq_52922190的博客
04-16 4893
1.DMA：存储器直接访问，既不需要CPU也不需要CPU的干预，用来提供存储器和外设之间，存储器和存储器之间的高速数据传输，通过硬件为RAM与I/O设备之间开辟一条之间传输数据的通道，节省CPU的资源，使CPU效率提高。 2.选用什么类型的比较器可以提高电压比较器的抗干扰能力？ 常用的电压比较器有：单限比较器，滞回比较器，窗口比较器，三态电压比较器等 简单的电压比较器结构简单，灵敏度高，但抗干扰能力差，因此我们要对其进行改进。改进后的电压比较器：滞回比较器，窗口比较器。 3.STM32G43.
第十三届第二场蓝桥杯嵌入式G431，程序题完美实现！
06-11
该压缩包文件包含完整的程序设计题工程文件，在第十三届第一场中主要使用到了串口通信、PWM产生、定时器的应用、EEPROM以及基本的LED,LCD,按键的应用。 其中串口通信使用的是DMA空闲中断的方式接收数据，定时器主要...
#蓝桥杯嵌入式组#历年客观题解析
vircorns的博客
04-07 1万+
文章目录 因为第十二届硬件平台更新了，MCU型号改成了STM32G431
2022年第十三届蓝桥杯省赛真题及部分答案解析(Java B组)
热门推荐
MysticalDream的博客
04-09 5万+
2022年第十三届蓝桥杯省赛javaB组真题及解析 试题 B: 山 【问题描述】 这天小明正在学数数。他突然发现有些正整数的形状像一座“山”，比如 123565321 、 145541 ，它们左右对称（回文）且数位上的数字先单调不减，后单调不增。 小明数了很久也没有数完，他想让你告诉他在区间[2022,2022222022]中有多少个数的形状像一座“山”。这是一道结果填空的题，你只需要算出结果后提交即可。本题的结
【蓝桥杯嵌入式】第十三届蓝桥杯嵌入式国赛客观题以及详细题解
黑心萝卜三条杠的博客
03-24 6056
【蓝桥杯嵌入式】第十三届蓝桥杯嵌入式国赛客观题以及详细题解
关于学科竞赛的经验
Teemos的博客
12-18 6072
莫西莫西，我系提莫莫队长，平时喜欢种种蘑菇。 起因是思梦姐姐找到我，希望给20级的同志分享下学科竞赛相关的经验，于是乎我答应了，于是乎又有了新的故事。 emmm，我在线下已经和部分师弟师妹们分享过了，在这里以文字的形式将分享的内容分享出来，方便师弟师妹们学习。
【速成】蓝桥杯嵌入式省一教程
weixin_60921752的博客
01-16 2012
蓝桥杯虽然是水赛，含金量不如其他老牌竞赛那么高，但对提高自身的能力还是有一定帮助的。无论你是想混个奖项加加综测分，还是想学学单片机、嵌入式的知识，蓝桥杯电子类的嵌入式竞赛都值得参加一次。当然蓝桥杯电子类竞赛还有其他组别，嵌入式组主要考察的是STM32的基本使用，而单片机组考察的是CT107D单片机（博主也没听过，貌似是蓝桥杯竞赛专用板）。我个人认为无论是入门单片机，还是入门嵌入式，又或者是为今后做项目、实习工作等做准备，STM32都是非常值得学的，也非常适合入门。
蓝桥杯嵌入式 eeprom初次上电判断
m0_52560903的博客
03-13 7702
问题： 比赛往往要求初值确定如k=0.1，运行过程中改变k的值，再次上电k的值保存 若直接 Write_at24c02(0,u8(k*10)); 初始化时 k=0.1*Read_at24c02(0); 第一次上电不一定0地址内存中的值为1，所以不可取 解决： 上电时检查特定内存（如0x30）中的内容是否为自己设定的id（如3713）. 若是，则不是初次上电，可以读取存入指定内存的值， 若否，则是初次上电，0x30存入3713. 上电时检查id union My_ID {...
蓝桥杯单片机零基础到国二经验分享
m0_64627761的博客
11-16 2万+
蓝桥杯单片机零基础到国二备赛经验分享，零基础到省三，省三到省二，省二到省一，省一到国二详细教程
蓝桥杯嵌入式第十三届省赛题目pdf
07-05
蓝桥杯嵌入式第十三届省赛题目pdf是指蓝桥杯嵌入式程序设计竞赛第十三届省级赛事的题目文档，采用PDF格式。蓝桥杯嵌入式程序设计竞赛是中国高校计算机类专业的一项大型赛事，旨在发掘和培养具有创新能力和实践能力的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值