devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

第十五届蓝桥杯嵌入式模拟题二_蓝桥杯嵌入式第十五届真题

作者：小丑西瓜9 | 2024-06-12 02:27:17

赞

踩

蓝桥杯嵌入式第十五届真题

一、基本要求

使用大赛组委会提供的嵌入式竞赛实训平台（基于STM32G431RBT6微控制器设计），完成本试题的程序设计与调试。程序编写、调试完成后，选手需通过考试系统提交以准考证号命名的hex文件。

hex文件是唯一成绩评测依据，不符合以上文件提交要求的作品将被评为零分或者被酌情扣分。

二、硬件框图

图1 系统硬件框图

三、功能描述   

3.1 基本功能

1）通过微控制器的ADC功能，检测电位器R37上输出的模拟电压信号。

2）通过PA1引脚输出频率、占空比可调节的脉冲信号。

3）通过串口实现远程控制功能。

4）根据试题要求，通过LED和LCD完成数据显示和报警功能。

5）根据试题要求，通过按键实现切换界面和控制等功能。

3.2 显示功能

1）数据界面

数据界面如图2所示，显示要素包括界面名称（DATA）、温度值（TEMP）、当前控制模式（MODE）和档位（GEAR）。

图2 数据界面

2）睡眠界面

睡眠界面如图3所示，显示要素包括界面名称（SLEEPING）和温度值（TEMP）。

图3 睡眠界面

5s内按键无动作，或串口未下发命令，自动进入“睡眠界面”。

备注：

温度值（TEMP）单位为℃，保留小数点后1位有效数字；

当前控制模式（MODE）：Auto表示自动控制模式；Manu表示手动控制模式；

自动控制模式：

温度值 < 25℃时，档位为1档。

25℃ ≤ 温度值 ≤ 30℃，档位为2档。

温度值 > 30℃时，档位为3档。

显示说明

（1）显示背景颜色(BackColor)：黑色。

（2）显示字体颜色(TextColor)：白色。

（3）请严格按照图示要求设计各个信息项的名称（区分字母大小写）和相对行列位置。

3.3 模拟功能

通过检测电位器R37输出的模拟电压信号VR37模拟温度，VR37和与温度的关系如图4所示。

图4 VR37和温度关系图

3.3 按键功能

1）B1：定义为“模式”按键，在数据界面下，按下B1按键，切换自动控制模式和手动控制模式。切换顺序如图5所示。

图5 模式切换

2）B2：定义为“档位加”按键，在“手动控制”模式下，按下B2按键，调整当前档位。切换顺序如图6所示。

图5 档位加顺序

3）B3：定义为“档位减”按键，在“手动控制”模式下，按下B3按键，调整当前档位。切换顺序如图6所示。

图5 档位减顺序

注意：

（1）按键B2和B3仅在“手动控制”模式下有效。

（2）按键应进行有效的防抖处理，避免出现一次按键动作触发多次功能等情形。

（3）按键动作不应影响数据采集过程和屏幕显示效果。

（4）在“睡眠界面”下，按下按键B1、B2或B3切换到“数据界面”，且当前按键动作仅作唤醒“数据界面”使用，不触发按键功能。

3.5 串口功能

串口作远程遥控使用，串口功能如下：

串口发送‘B1’定义为按键B1，实现按键B1切换模式功能；

串口发送‘B2’，定义为按键B2，实现B2“档位加”功能；

串口发送‘B3’，定义为按键B3，实现B3“档位减”功能；

串口发送其他非法字符，返回“NULL”。

注意：

串口通信波特率9600；

除命令‘B1’、‘B2’和‘B3’外，其他字符均为非法字符。

在“睡眠界面”下，发送命令‘B1’、‘B2’和‘B3’界面切换到“数据界面”，且当前命令仅作唤醒“数据界面”使用，不触发功能。

3.6 PWM功能

通过PA1输出2kHz，占空比连续可调的频率信号，占空比和档位关系：

档位为1，占空比10%；

档位为2，占空比40%；

档位为3，占空比80%。

3.7 LED指示灯功能

1）在自动控制模式下，指示灯LD8点亮，否则熄灭；

2）档位为1时，指示灯LD1点亮，否则熄灭；

3）档位为2时，指示灯LD2点亮，否则熄灭；

4）档位为3时，指示灯LD3点亮，否则熄灭；

5）串口发送命令，同时指示灯LD4点亮，3秒后熄灭；

5）指示灯LD5~LD7始终处于熄灭状态。

3.8 初始状态说明

设备上电后，初始状态如下：

1）自动控制模式；

2）处于数据界面。

备注：请严格按照此初始状态设计功能。

具体代码如下：

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file           : main.c
  5.   * @brief          : Main program body
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * <h2><center>&copy; Copyright (c) 2024 STMicroelectronics.
  10.   * All rights reserved.</center></h2>
  11.   *
  12.   * This software component is licensed by ST under BSD 3-Clause license,
  13.   * the "License"; You may not use this file except in compliance with the
  14.   * License. You may obtain a copy of the License at:
  15.   *                        opensource.org/licenses/BSD-3-Clause
  16.   *
  17.   ******************************************************************************
  18.   */
  19. /* USER CODE END Header */
  20.  
  21. /* Includes ------------------------------------------------------------------*/
  22. #include "main.h"
  23. #include "adc.h"
  24. #include "tim.h"
  25. #include "usart.h"
  26. #include "gpio.h"
  27.  
  28. /* Private includes ----------------------------------------------------------*/
  29. /* USER CODE BEGIN Includes */
  30. #include "stdio.h"
  31. #include "string.h"
  32. #include "led.h"
  33. #include "myadc.h"
  34. #include "lcd.h"
  35. #include "interrupt.h"
  36. /* USER CODE END Includes */
  37.  
  38. /* Private typedef -----------------------------------------------------------*/
  39. /* USER CODE BEGIN PTD */
  40. extern struct key_t key[4];
  41. extern struct adc2_t adc2;
  42. extern struct interface_t interface;
  43. extern struct uart1_t uart1;
  44. /* USER CODE END PTD */
  45.  
  46. /* Private define ------------------------------------------------------------*/
  47. /* USER CODE BEGIN PD */
  48.  
  49. /* USER CODE END PD */
  50.  
  51. /* Private macro -------------------------------------------------------------*/
  52. /* USER CODE BEGIN PM */
  53. void lcd_process(void)
  54. {
  55. 		char buf[30];
  56. 	  if(interface.flg == 0)//DATA
  57. 		{
  58. 				if(interface.clean_flg)
  59. 				{
  60. 					  LCD_Clear(Black);
  61. 						interface.clean_flg = 0;
  62. 				}
  63. 				sprintf(buf,"        DATA");
  64. 			  LCD_DisplayStringLine(Line1,(uint8_t*)buf);
  65. 			  sprintf(buf,"     TEMP:%.1f",adc2.temp);
  66. 			  LCD_DisplayStringLine(Line3,(uint8_t*)buf);	  
  67. 			  if(interface.mode == 0)
  68. 				{ 
  69. 				    sprintf(buf,"     MODE:Auto");
  70. 				}
  71. 				else if(interface.mode == 1)
  72. 				{
  73. 						sprintf(buf,"     MODE:Manu");
  74. 				}
  75. 			  LCD_DisplayStringLine(Line4,(uint8_t*)buf);	 
  76. 			  sprintf(buf,"     GEAR:%d",interface.gears);
  77. 			  LCD_DisplayStringLine(Line5,(uint8_t*)buf);	 
  78. 		}
  79. 	  if(interface.flg == 1)//sleep
  80. 		{ 
  81.         if(interface.sleep_clean)
  82. 				{
  83. 					 LCD_Clear(Black);
  84. 				 interface.sleep_clean = 0;
  85. 				}
  86. 			  sprintf(buf,"     SLEEPING");
  87. 			  LCD_DisplayStringLine(Line4,(uint8_t*)buf);	 
  88. 			  sprintf(buf,"     TEMP:%.1f",adc2.temp);
  89. 			  LCD_DisplayStringLine(Line5,(uint8_t*)buf);	 
  90. 		}
  91.  
  92. 		
  93. }
  94.  
  95. void key_process(void)
  96. {
  97. 		//B1
  98. 	  if(key[0].short_flg == 1 && interface.flg == 0)
  99. 		{
  100.  
  101. 			  interface.sleep_time = 500;
  102. 			  interface.mode++;
  103. 			  if(interface.mode > 1)
  104. 				{
  105. 						interface.mode = 0;
  106. 				}
  107. 				key[0].short_flg = 0;
  108. 		}
  109. 	  if(key[0].short_flg == 1 && interface.flg == 1)
  110. 		{
  111. 				interface.clean_flg = 1;
  112. 			  interface.sleep_time = 500;
  113. 				key[0].short_flg = 0;
  114. 		}
  115. 	  //B2
  116. 	  if(key[1].short_flg == 1 && interface.mode == 1 && interface.flg == 0)
  117. 		{
  118. 		
  119. 			 interface.sleep_time = 500;
  120. 			  interface.gears++;
  121. 			  if(interface.gears >= 3)
  122. 				{
  123. 						interface.gears = 3;
  124. 				}
  125. 				key[1].short_flg = 0;
  126. 		}
  127. 	  if(key[1].short_flg == 1&& interface.flg == 1)
  128. 		{
  129. 				interface.clean_flg = 1;
  130. 			  interface.sleep_time = 500;
  131. 				key[1].short_flg = 0;
  132. 		}
  133. 	  if(key[1].short_flg == 1&& interface.flg == 0)
  134. 		{
  135. 				
  136. 			  interface.sleep_time = 500;
  137. 				key[1].short_flg = 0;
  138. 		}
  139. 	  //B3
  140. 	  if(key[2].short_flg == 1 && interface.mode == 1&& interface.flg == 0)
  141. 		{
  142. 		
  143. 			 interface.sleep_time = 500;
  144. 			  interface.gears--;
  145. 			  if(interface.gears <= 1)
  146. 				{
  147. 						interface.gears = 1;
  148. 				}
  149. 				key[2].short_flg = 0;
  150. 		}
  151. 	  if(key[2].short_flg == 1 && interface.flg == 1)
  152. 		{
  153. 				interface.clean_flg = 1;
  154. 			  interface.sleep_time = 500;
  155. 				key[2].short_flg = 0;
  156. 		}
  157. 	  if(key[2].short_flg == 1 && interface.flg == 0)
  158. 		{
  159. 			
  160. 			  interface.sleep_time = 500;
  161. 				key[2].short_flg = 0;
  162. 		}
  163.  
  164. }
  165.  
  166. void adc_process(void)
  167. {
  168. 		adc2.vol = get_adc();
  169. 	  if(adc2.vol <= 1.0f)
  170. 		{
  171. 		  adc2.temp = 20.0f;
  172. 		}
  173. 		else if(adc2.vol >= 3.0f)
  174. 		{
  175. 		  adc2.temp = 40.0f;
  176. 		}
  177. 		else
  178. 		{
  179. 				adc2.temp = 10.f*adc2.vol +10;
  180. 		}
  181. 		
  182. 		if(interface.mode == 0)
  183. 		{
  184. 				if(adc2.temp < 25)
  185. 				{
  186. 						interface.gears = 1;
  187. 				}
  188. 				else if(adc2.temp <= 30)
  189. 				{
  190. 						interface.gears = 2;
  191. 				}
  192. 				else
  193. 				{
  194. 						interface.gears = 3;
  195. 				}
  196. 		}
  197. 		
  198. 		
  199. }
  200.  
  201. void pwm_process(void)
  202. {
  203. 		if(interface.gears == 1)
  204. 		{
  205. 		   __HAL_TIM_SetCompare(&htim2,TIM_CHANNEL_2,10);
  206. 		}
  207. 		else if(interface.gears == 2)
  208. 		{
  209. 		 __HAL_TIM_SetCompare(&htim2,TIM_CHANNEL_2,40);
  210. 		}
  211. 		else if(interface.gears == 3)
  212. 		{
  213. 				 __HAL_TIM_SetCompare(&htim2,TIM_CHANNEL_2,80);
  214. 		}
  215. }
  216.  
  217. void myprintf(uint8_t *buf)
  218. {
  219. 		while(*buf != 0)
  220. 		{
  221. 				HAL_UART_Transmit(&huart1,buf++,1,0xffff);
  222. 		}
  223. }
  224.  
  225. void uart_process(void)
  226. {
  227. 	  uint8_t str[10];
  228. 		if(uart1.place > 0)
  229. 		{
  230. 				uart1.lenght = uart1.place;
  231. 			  HAL_Delay(1);
  232. 			  if(uart1.lenght == uart1.place)
  233. 				{
  234. 					  uart1.led_flg = 1;
  235. 					  if(uart1.place == 4)
  236. 						{
  237. 						   sscanf((char*)uart1.buf,"%2s",str);
  238. 					
  239. 							 if(!strcmp((char*)str,"B1"))
  240. 							 {
  241. 										//B1
  242. 										if(interface.flg == 0)
  243. 										{
  244. 											interface.sleep_time = 500;
  245. 											interface.mode++;
  246. 											if(interface.mode > 1)
  247. 											{
  248. 													interface.mode = 0;
  249. 											}
  250. 										}
  251. 										else if(interface.flg == 1)
  252. 										{
  253. 												interface.clean_flg = 1;
  254. 												interface.sleep_time = 500;
  255. 										}
  256. 										else if(interface.flg == 0)
  257. 										{
  258. 												
  259. 												interface.sleep_time = 500;
  260. 										}								
  261. 							 }
  262. 							 else if (!strcmp((char*)str,"B2"))
  263. 							 {
  264. 										//B1
  265. 										if(interface.flg == 0 && interface.mode== 1)
  266. 										{
  267. 												 interface.sleep_time = 500;
  268. 													interface.gears++;
  269. 													if(interface.gears >= 3)
  270. 													{
  271. 															interface.gears = 3;
  272. 													}
  273. 										}
  274. 										else if(interface.flg == 1)
  275. 										{
  276. 												interface.clean_flg = 1;
  277. 												interface.sleep_time = 500;
  278. 										}
  279. 										else if(interface.flg == 0)
  280. 										{
  281. 											
  282. 												interface.sleep_time = 500;
  283. 										}
  284. 							 }
  285. 							 else if (!strcmp((char*)str,"B3"))
  286. 							 {
  287. 										//B1
  288. 										if(interface.flg == 0 && interface.mode== 1)
  289. 										{
  290. 											 interface.sleep_time = 500;
  291. 												interface.gears--;
  292. 												if(interface.gears <= 1)
  293. 												{
  294. 														interface.gears = 1;
  295. 												}
  296. 										}
  297. 										else if(interface.flg == 1)
  298. 										{
  299. 												interface.clean_flg = 1;
  300. 												interface.sleep_time = 500;
  301. 										}
  302. 										else if(interface.flg == 0)
  303. 										{
  304. 											
  305. 												interface.sleep_time = 500;
  306. 										}
  307. 							 }
  308. 							 else
  309. 							 {
  310. 									myprintf((uint8_t*)"NULL\r\n");
  311. 							 }
  312. 						}
  313. 						else
  314. 						{
  315. 									myprintf((uint8_t*)"NULL\r\n");
  316. 						}
  317. 					  uart1.place = 0;
  318. 						memset(uart1.buf,0,sizeof(uart1.buf));
  319. 					
  320. 				}
  321. 		}
  322. }
  323.  
  324. void led_process(void)
  325. {
  326. 		uint8_t mode = 0;
  327. 	  if(interface.mode == 0)
  328. 		{
  329. 					mode |= 0x80;
  330. 		}
  331. 		else
  332. 		{
  333. 					mode &= 0x7f;
  334. 		}
  335. 		
  336. 		if(interface.gears == 1)
  337. 		{
  338. 							mode |= 0x01;
  339. 		}
  340. 		else
  341. 		{
  342. 				mode &= 0xfe;
  343. 		}
  344. 		
  345. 		if(interface.gears == 2)
  346. 		{
  347. 				mode |= 0x02;
  348. 		}
  349. 		else
  350. 		{
  351. 				mode &= 0xfd;
  352. 		}
  353. 		
  354. 		if(interface.gears == 3)
  355. 		{
  356. 				mode |= 0x04;
  357. 		}
  358. 		else
  359. 		{
  360. 				mode &= 0xfb;
  361. 		}
  362. 		
  363. 		if(uart1.led_flg)
  364. 		{
  365. 				mode |= 0x08;
  366. 		}
  367. 		else
  368. 		{
  369. 				mode &= 0xf7;
  370. 		}
  371. 		
  372. 		LED_Disp(mode);
  373. }
  374. /* USER CODE END PM */
  375.  
  376. /* Private variables ---------------------------------------------------------*/
  377.  
  378. /* USER CODE BEGIN PV */
  379.  
  380. /* USER CODE END PV */
  381.  
  382. /* Private function prototypes -----------------------------------------------*/
  383. void SystemClock_Config(void);
  384. /* USER CODE BEGIN PFP */
  385.  
  386. /* USER CODE END PFP */
  387.  
  388. /* Private user code ---------------------------------------------------------*/
  389. /* USER CODE BEGIN 0 */
  390.  
  391. /* USER CODE END 0 */
  392.  
  393. /**
  394.   * @brief  The application entry point.
  395.   * @retval int
  396.   */
  397. int main(void)
  398. {
  399.   /* USER CODE BEGIN 1 */
  400.  
  401.   /* USER CODE END 1 */
  402.   
  403.  
  404.   /* MCU Configuration--------------------------------------------------------*/
  405.  
  406.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  407.   HAL_Init();
  408.  
  409.   /* USER CODE BEGIN Init */
  410.  
  411.   /* USER CODE END Init */
  412.  
  413.   /* Configure the system clock */
  414.   SystemClock_Config();
  415.  
  416.   /* USER CODE BEGIN SysInit */
  417.  
  418.   /* USER CODE END SysInit */
  419.  
  420.   /* Initialize all configured peripherals */
  421.   MX_GPIO_Init();
  422.   MX_ADC2_Init();
  423.   MX_TIM2_Init();
  424.   MX_TIM4_Init();
  425.   MX_USART1_UART_Init();
  426.   /* USER CODE BEGIN 2 */
  427. 	 interface.sleep_time = 500;
  428. 	 interface.mode = 0;
  429. 	LCD_Init();
  430. 	LCD_Clear(Black);
  431. 	LCD_SetBackColor(Black);
  432. 	LCD_SetTextColor(White);
  433.   HAL_TIM_Base_Start_IT(&htim4);
  434. 	HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
  435. 	HAL_UART_Receive_IT(&huart1,&uart1.data,1);
  436.   /* USER CODE END 2 */
  437.  
  438.   /* Infinite loop */
  439.   /* USER CODE BEGIN WHILE */
  440.   while (1)
  441.   {
  442.     /* USER CODE END WHILE */
  443.  
  444.     /* USER CODE BEGIN 3 */
  445.  
  446. 		lcd_process();
  447. 		key_process();
  448. 		uart_process();
  449. 		adc_process();
  450. 		pwm_process();
  451. 		led_process();
  452.  
  453.   }
  454.   /* USER CODE END 3 */
  455. }
  456.  
  457. /**
  458.   * @brief System Clock Configuration
  459.   * @retval None
  460.   */
  461. void SystemClock_Config(void)
  462. {
  463.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  464.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  465.   RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  466.  
  467.   /** Configure the main internal regulator output voltage 
  468.   */
  469.   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
  470.   /** Initializes the CPU, AHB and APB busses clocks 
  471.   */
  472.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  473.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  474.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  475.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  476.   RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV3;
  477.   RCC_OscInitStruct.PLL.PLLN = 20;
  478.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  479.   RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  480.   RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  481.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  482.   {
  483.     Error_Handler();
  484.   }
  485.   /** Initializes the CPU, AHB and APB busses clocks 
  486.   */
  487.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  488.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  489.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  490.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  491.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  492.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  493.  
  494.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
  495.   {
  496.     Error_Handler();
  497.   }
  498.   /** Initializes the peripherals clocks 
  499.   */
  500.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_ADC12;
  501.   PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
  502.   PeriphClkInit.Adc12ClockSelection = RCC_ADC12CLKSOURCE_SYSCLK;
  503.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  504.   {
  505.     Error_Handler();
  506.   }
  507. }
  508.  
  509. /* USER CODE BEGIN 4 */
  510.  
  511. /* USER CODE END 4 */
  512.  
  513. /**
  514.   * @brief  This function is executed in case of error occurrence.
  515.   * @retval None
  516.   */
  517. void Error_Handler(void)
  518. {
  519.   /* USER CODE BEGIN Error_Handler_Debug */
  520.   /* User can add his own implementation to report the HAL error return state */
  521.  
  522.   /* USER CODE END Error_Handler_Debug */
  523. }
  524.  
  525. #ifdef  USE_FULL_ASSERT
  526. /**
  527.   * @brief  Reports the name of the source file and the source line number
  528.   *         where the assert_param error has occurred.
  529.   * @param  file: pointer to the source file name
  530.   * @param  line: assert_param error line source number
  531.   * @retval None
  532.   */
  533. void assert_failed(uint8_t *file, uint32_t line)
  534. { 
  535.   /* USER CODE BEGIN 6 */
  536.   /* User can add his own implementation to report the file name and line number,
  537.      tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  538.   /* USER CODE END 6 */
  539. }
  540. #endif /* USE_FULL_ASSERT */
  541.  
  542. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/705751
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号