一、题目






二、模块初始化
这里就简单描述一下模块的配置方法，具体方法到基本模块中有描述。
1.LCD这里不用配置，直接使用提供的资源包就行
2.KEY, 四个按键IO口都要配置，分别是PB0, PB1,PB2,PA0依次是B0,B1,B2,B3不要弄错了
3.PWM:这里使用TIM16的CH1作为发生通道，TIM16→PSC:800-1,ARR:100-1,Pulse:80
4.LED:开启PC8,PD2输出模式就行了。
5.定时器:TIM3(按键消抖定时器)SC:80-1,ARR:10000-1, TIM4(控制时间每一秒流逝一次)SC:80-1,ARR:10000-1,TIM6(控制LED灯闪烁)SC:80-1,ARR:10000-1。


三、代码实现
bsp组有:



在这里只展示interrupt.h,interrupt.h,main.c,main.h的代码，其他文件的代码可到基本模块篇获取。
interrupt.h:

1. #ifndef __INTERRUPT_H__
   
2. #define __INTERRUPT_H__
   
3. 
   
4. #include "main.h"
   
5. #include "stdbool.h"
   
6. 
   
7. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim);
   
8. 
   
9. struct keys
   
10. {
    
11.         unsigned char jug_Sta;
    
12.         bool key_sta;
    
13.         bool single_flag;
    
14.         unsigned int key_time;
    
15.         bool long_flag;
    
16. };
    
17. 
    
18. #endif
    
19. 
    

复制代码

interrupt.c:

1. #include "interrupt.h"
   
2. #include "lcd.h"
   
3. #include "tim.h"
   
4. #include "i2c.h"
   
5. #include "led.h"
   
6. #include "stdio.h"
   
7. 
   
8. struct keys key[4] = {0, 0, 0, 0, 0};
   
9. extern int TimerDisplay[3];
   
10. unsigned char InternalTimer = 0;
    
11. extern unsigned char TimerMode;
    
12. extern unsigned char TimerStoreIndex;
    
13. unsigned char disLED = 0;
    
14. unsigned char LEDTimer = 0;
    
15. 
    
16. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
17. {
    
18.         if(htim->Instance == TIM3)
    
19.         {
    
20.                 key[0].key_sta = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
    
21.                 key[1].key_sta = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    
22.                 key[2].key_sta = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
    
23.                 key[3].key_sta = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
    
24.                
    
25.                 for(unsigned char i = 0; i < 4; i++)
    
26.                 {
    
27.                         switch(key[i].jug_Sta)
    
28.                         {
    
29.                                 case 0:
    
30.                                 {
    
31.                                         if(key[i].key_sta == 0)
    
32.                                         {
    
33. 
    
34.                                                 key[i].jug_Sta = 1;
    
35.                                                 key[i].key_time = 0;
    
36.                                         }
    
37.                                         break;
    
38.                                 }
    
39.                                 case 1:
    
40.                                 {
    
41.                                         if(key[i].key_sta == 0)
    
42.                                         {
    
43.                                                 key[i].jug_Sta = 2;
    
44.                                         }
    
45.                                         else
    
46.                                         {
    
47.                                                 key[i].jug_Sta = 0;
    
48.                                         }
    
49.                                         break;
    
50.                                 }
    
51.                                 case 2:
    
52.                                 {
    
53.                                         if(key[i].key_sta == 1)
    
54.                                         {
    
55.                                                 key[i].jug_Sta = 0;
    
56.                                                 if(key[i].key_time <= 80)
    
57.                                                 {
    
58.                                                         key[i].single_flag = 1;
    
59.                                                 }
    
60.                                         }
    
61.                                         else
    
62.                                         {
    
63.                                                 key[i].key_time++;
    
64.                                                 if(key[i].key_time > 80)
    
65.                                                 {
    
66.                                                         key[i].long_flag = 1;
    
67.                                                 }
    
68.                                         }
    
69.                                         break;
    
70.                                 }
    
71.                         }
    
72.                 }
    
73.         }
    
74.         if(htim->Instance == TIM4)
    
75.         {
    
76.                 if(TimerMode == RUNNING)
    
77.                 {
    
78.                         InternalTimer++;
    
79.                         if(InternalTimer == 100)
    
80.                         {
    
81.                                 TimerDisplay[SECOND]--;
    
82.                                 if(TimerDisplay[SECOND] == -1)
    
83.                                 {
    
84.                                         TimerDisplay[SECOND] = 59;
    
85.                                         TimerDisplay[MINUTE]--;
    
86.                                         if(TimerDisplay[MINUTE] == -1)
    
87.                                         {
    
88.                                                 TimerDisplay[MINUTE] = 59;
    
89.                                                 TimerDisplay[HOUR]--;
    
90.                                         }
    
91.                                 }
    
92.                                 InternalTimer = 0;
    
93.                         }
    
94.                         if(TimerDisplay[HOUR] == 0 && TimerDisplay[MINUTE] == 0 && TimerDisplay[SECOND] == 0)
    
95.                         {
    
96.                                 HAL_TIM_Base_Stop_IT(&htim4);
    
97.                                 InternalTimer = 0;
    
98.                                 TimerDisplay[HOUR] = eeprom_read(TimerStoreIndex * 3 + 1);
    
99.                                 TimerDisplay[MINUTE]= eeprom_read(TimerStoreIndex * 3 + 2);
    
100.                                 TimerDisplay[SECOND] = eeprom_read(TimerStoreIndex * 3 + 3);
     
101.                                 TimerMode = STANDBY;
     
102.                         }
     
103.                 }
     
104.         }
     
105.         if(htim->Instance == TIM6)
     
106.         {
     
107.                 if(TimerMode == RUNNING)
     
108.                 {
     
109.                         LEDTimer++;
     
110.                         if(LEDTimer == 50)
     
111.                         {
     
112.                                 disLED = !disLED;
     
113.                                 LED_Display(disLED);
     
114.                                 LEDTimer = 0;
     
115.                         }
     
116.                 }
     
117.                 else
     
118.                 {
     
119.                         LED_Display(0x00);
     
120.                         LEDTimer = 0;
     
121.                         HAL_TIM_Base_Stop_IT(&htim6);
     
122.                         HAL_TIM_PWM_Stop(&htim16, TIM_CHANNEL_1);
     
123.                 }
     
124.         }
     
125. }
     
126. 
     

复制代码

main.h:

1. /* USER CODE BEGIN Header */
   
2. /**
   
3.   ******************************************************************************
   
4.   * @file           : main.h
   
5.   * @brief          : Header for main.c file.
   
6.   *                   This file contains the common defines of the application.
   
7.   ******************************************************************************
   
8.   * @attention
   
9.   *
   
10.   * <h2><center>© Copyright (c) 2023 STMicroelectronics.
    
11.   * All rights reserved.</center></h2>
    
12.   *
    
13.   * This software component is licensed by ST under BSD 3-Clause license,
    
14.   * the "License"; You may not use this file except in compliance with the
    
15.   * License. You may obtain a copy of the License at:
    
16.   *                        opensource.org/licenses/BSD-3-Clause
    
17.   *
    
18.   ******************************************************************************
    
19.   */
    
20. /* USER CODE END Header */
    
21. 
    
22. /* Define to prevent recursive inclusion -------------------------------------*/
    
23. #ifndef __MAIN_H
    
24. #define __MAIN_H
    
25. 
    
26. #ifdef __cplusplus
    
27. extern "C" {
    
28. #endif
    
29. 
    
30. /* Includes ------------------------------------------------------------------*/
    
31. #include "stm32g4xx_hal.h"
    
32. 
    
33. /* Private includes ----------------------------------------------------------*/
    
34. /* USER CODE BEGIN Includes */
    
35. 
    
36. /* USER CODE END Includes */
    
37. 
    
38. /* Exported types ------------------------------------------------------------*/
    
39. /* USER CODE BEGIN ET */
    
40. 
    
41. /* USER CODE END ET */
    
42. 
    
43. /* Exported constants --------------------------------------------------------*/
    
44. /* USER CODE BEGIN EC */
    
45. 
    
46. /* USER CODE END EC */
    
47. 
    
48. /* Exported macro ------------------------------------------------------------*/
    
49. /* USER CODE BEGIN EM */
    
50. 
    
51. /* USER CODE END EM */
    
52. 
    
53. /* Exported functions prototypes ---------------------------------------------*/
    
54. void Error_Handler(void);
    
55. 
    
56. /* USER CODE BEGIN EFP */
    
57. 
    
58. /* USER CODE END EFP */
    
59. 
    
60. /* Private defines -----------------------------------------------------------*/
    
61. /* USER CODE BEGIN Private defines */
    
62. #define HOUR 0
    
63. #define MINUTE 1
    
64. #define SECOND 2
    
65. #define STANDBY 0
    
66. #define SETTING 1
    
67. #define RUNNING 2
    
68. #define PAUSE 3
    
69. /* USER CODE END Private defines */
    
70. 
    
71. #ifdef __cplusplus
    
72. }
    
73. #endif
    
74. 
    
75. #endif /* __MAIN_H */
    
76. 
    
77. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
    
78. 
    

复制代码

main.c

1. /* USER CODE BEGIN Header */
   
2. /**
   
3.   ******************************************************************************
   
4.   * @file           : main.c
   
5.   * @brief          : Main program body
   
6.   ******************************************************************************
   
7.   * @attention
   
8.   *
   
9.   * <h2><center>© Copyright (c) 2023 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. /* Includes ------------------------------------------------------------------*/
    
21. #include "main.h"
    
22. #include "tim.h"
    
23. #include "gpio.h"
    
24. 
    
25. /* Private includes ----------------------------------------------------------*/
    
26. /* USER CODE BEGIN Includes */
    
27. #include "lcd.h"
    
28. #include "interrupt.h"
    
29. #include "stdio.h"
    
30. #include "i2c.h"
    
31. #include "led.h"
    
32. /* USER CODE END Includes */
    
33. 
    
34. /* Private typedef -----------------------------------------------------------*/
    
35. /* USER CODE BEGIN PTD */
    
36. 
    
37. /* USER CODE END PTD */
    
38. 
    
39. /* Private define ------------------------------------------------------------*/
    
40. /* USER CODE BEGIN PD */
    
41. /* USER CODE END PD */
    
42. 
    
43. /* Private macro -------------------------------------------------------------*/
    
44. /* USER CODE BEGIN PM */
    
45. 
    
46. /* USER CODE END PM */
    
47. 
    
48. /* Private variables ---------------------------------------------------------*/
    
49. 
    
50. /* USER CODE BEGIN PV */
    
51. extern struct keys key[4];
    
52. unsigned char TimerStore[5][3];
    
53. int TimerDisplay[3];
    
54. unsigned char TimerMode;
    
55. unsigned char SettingTimeIndex;
    
56. unsigned char longPressBufferTime;
    
57. unsigned char TimerStoreIndex;
    
58. extern unsigned char InternalTimer;
    
59. /* USER CODE END PV */
    
60. 
    
61. /* Private function prototypes -----------------------------------------------*/
    
62. void SystemClock_Config(void);
    
63. /* USER CODE BEGIN PFP */
    
64. void LCD_Display(void);
    
65. void DiseposeKey(void);
    
66. void LCD_Flash(void);
    
67. void Store_TimetoEEPROM(void);
    
68. /* USER CODE END PFP */
    
69. 
    
70. /* Private user code ---------------------------------------------------------*/
    
71. /* USER CODE BEGIN 0 */
    
72. 
    
73. /* USER CODE END 0 */
    
74. 
    
75. /**
    
76.   * @brief  The application entry point.
    
77.   * @retval int
    
78.   */
    
79. int main(void)
    
80. {
    
81.   /* USER CODE BEGIN 1 */
    
82. 
    
83.   /* USER CODE END 1 */
    
84. 
    
85.   /* MCU Configuration--------------------------------------------------------*/
    
86. 
    
87.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
88.   HAL_Init();
    
89. 
    
90.   /* USER CODE BEGIN Init */
    
91. 
    
92.   /* USER CODE END Init */
    
93. 
    
94.   /* Configure the system clock */
    
95.   SystemClock_Config();
    
96. 
    
97.   /* USER CODE BEGIN SysInit */
    
98. 
    
99.   /* USER CODE END SysInit */
    
100. 
     
101.   /* Initialize all configured peripherals */
     
102.   MX_GPIO_Init();
     
103.   MX_TIM3_Init();
     
104.   MX_TIM4_Init();
     
105.   MX_TIM16_Init();
     
106.   MX_TIM6_Init();
     
107.   /* USER CODE BEGIN 2 */
     
108.         LCD_Init();
     
109.         LCD_Clear(Black);
     
110.         LCD_SetBackColor(Black);
     
111.         LCD_SetTextColor(White);
     
112.         HAL_TIM_Base_Start_IT(&htim3);
     
113.         LED_Display(0x00);
     
114.         TimerDisplay[HOUR] = eeprom_read(1);
     
115.         TimerDisplay[MINUTE]= eeprom_read(2);
     
116.         TimerDisplay[SECOND] = eeprom_read(3);
     
117.   /* USER CODE END 2 */
     
118. 
     
119.   /* Infinite loop */
     
120.   /* USER CODE BEGIN WHILE */
     
121.   while (1)
     
122.   {
     
123.     /* USER CODE END WHILE */
     
124. 
     
125.     /* USER CODE BEGIN 3 */
     
126.                 LCD_Display();
     
127.                 DiseposeKey();
     
128.   }
     
129.   /* USER CODE END 3 */
     
130. }
     
131. 
     
132. /**
     
133.   * @brief System Clock Configuration
     
134.   * @retval None
     
135.   */
     
136. void SystemClock_Config(void)
     
137. {
     
138.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     
139.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
     
140. 
     
141.   /** Configure the main internal regulator output voltage
     
142.   */
     
143.   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
     
144.   /** Initializes the RCC Oscillators according to the specified parameters
     
145.   * in the RCC_OscInitTypeDef structure.
     
146.   */
     
147.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
     
148.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
     
149.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
     
150.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
     
151.   RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV3;
     
152.   RCC_OscInitStruct.PLL.PLLN = 20;
     
153.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
     
154.   RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
     
155.   RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
     
156.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     
157.   {
     
158.     Error_Handler();
     
159.   }
     
160.   /** Initializes the CPU, AHB and APB buses clocks
     
161.   */
     
162.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
     
163.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
     
164.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
     
165.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     
166.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     
167.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     
168. 
     
169.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
     
170.   {
     
171.     Error_Handler();
     
172.   }
     
173. }
     
174. 
     
175. /* USER CODE BEGIN 4 */
     
176. void LCD_Flash(void)
     
177. {
     
178.         switch(SettingTimeIndex)
     
179.         {
     
180.                 case HOUR:
     
181.                 {
     
182.                         char text[30];
     
183.                         sprintf(text, "      %02d:  :  ", TimerDisplay[HOUR]);
     
184.                         LCD_DisplayStringLine(Line3, text);
     
185.                         break;
     
186.                 }
     
187.                 case MINUTE:
     
188.                 {
     
189.                         char text[30];
     
190.                         sprintf(text, "        :%02d:  ", TimerDisplay[MINUTE]);
     
191.                         LCD_DisplayStringLine(Line3, text);
     
192.                         break;
     
193.                 }
     
194.                 case SECOND:
     
195.                 {
     
196.                         char text[30];
     
197.                         sprintf(text, "        :  :%02d", TimerDisplay[SECOND]);
     
198.                         LCD_DisplayStringLine(Line3, text);
     
199.                         break;
     
200.                 }
     
201.         }
     
202. }
     
203. 
     
204. void LCD_Display(void)
     
205. {
     
206.         char text[30];
     
207.         if(TimerMode == STANDBY)
     
208.         {
     
209.                 sprintf(text, "       STANDBY");               
     
210.         }
     
211.         else if(TimerMode == SETTING)
     
212.         {
     
213.                 sprintf(text, "       SETTING");
     
214.         }
     
215.         else if(TimerMode == RUNNING)
     
216.         {
     
217.                 sprintf(text, "       RUNNING");
     
218.         }
     
219.         else if(TimerMode == PAUSE)
     
220.         {
     
221.                 sprintf(text, "       PAUSE  ");               
     
222.         }
     
223.         LCD_DisplayStringLine(Line5, text);
     
224.         sprintf(text, "NO.%d", TimerStoreIndex + 1);
     
225.         LCD_DisplayStringLine(Line1, text);
     
226.         sprintf(text, "      %02d:%02d:%02d", TimerDisplay[HOUR], TimerDisplay[MINUTE], TimerDisplay[SECOND]);
     
227.         LCD_DisplayStringLine(Line3, text);
     
228.         if(TimerMode == SETTING)
     
229.                 LCD_Flash();
     
230. }
     
231. 
     
232. void Store_TimetoEEPROM(void)
     
233. {
     
234.         eeprom_write(TimerStoreIndex * 3 + 1, TimerDisplay[HOUR]);
     
235.         HAL_Delay(2);
     
236.         eeprom_write(TimerStoreIndex * 3 + 2, TimerDisplay[MINUTE]);
     
237.         HAL_Delay(2);
     
238.         eeprom_write(TimerStoreIndex * 3 + 3, TimerDisplay[SECOND]);
     
239. }
     
240. 
     
241. void DiseposeKey(void)
     
242. {
     
243.         if(key[0].single_flag)
     
244.         {
     
245.                 if(TimerMode == SETTING || TimerMode == STANDBY)
     
246.                 {
     
247.                         TimerStoreIndex++;
     
248.                         TimerStoreIndex %= 5;
     
249.                         TimerDisplay[HOUR] = eeprom_read(TimerStoreIndex * 3 + 1);
     
250.                         TimerDisplay[MINUTE]= eeprom_read(TimerStoreIndex * 3 + 2);
     
251.                         TimerDisplay[SECOND] = eeprom_read(TimerStoreIndex * 3 + 3);
     
252.                 }
     
253.                 key[0].single_flag = 0;
     
254.         }
     
255.         if(key[1].single_flag)
     
256.         {
     
257.                 if(TimerMode == STANDBY || TimerMode == PAUSE)
     
258.                 {
     
259.                         TimerMode = SETTING;
     
260.                         InternalTimer = 0;
     
261.                 }
     
262.                 else
     
263.                 {
     
264.                         SettingTimeIndex++;
     
265.                         SettingTimeIndex %= 3;                               
     
266.                 }
     
267.                 key[1].single_flag = 0;
     
268.         }
     
269.         if(key[1].long_flag)
     
270.         {
     
271.                 if(TimerMode == SETTING)
     
272.                 {
     
273.                         Store_TimetoEEPROM();
     
274.                         TimerMode = STANDBY;
     
275.                 }
     
276.                 key[1].long_flag = 0;
     
277.         }
     
278.         if(key[2].single_flag)
     
279.         {
     
280.                 if(TimerMode == SETTING)
     
281.                 {
     
282.                         TimerDisplay[SettingTimeIndex]++;
     
283.                         if(SettingTimeIndex == 0)
     
284.                         {
     
285.                                 TimerDisplay[SettingTimeIndex] %= 24;
     
286.                         }
     
287.                         else
     
288.                         {
     
289.                                 TimerDisplay[SettingTimeIndex] %= 60;
     
290.                         }
     
291.                 }
     
292.                 key[2].single_flag = 0;
     
293.         }
     
294.         if(key[2].long_flag)
     
295.         {
     
296.                 if(TimerMode == SETTING)
     
297.                 {
     
298.                         longPressBufferTime++;
     
299.                         if(longPressBufferTime == 10)
     
300.                         {
     
301.                                 longPressBufferTime = 0;
     
302.                                 TimerDisplay[SettingTimeIndex]++;
     
303.                                 if(SettingTimeIndex == 0)
     
304.                                 {
     
305.                                         TimerDisplay[SettingTimeIndex] %= 24;
     
306.                                 }
     
307.                                 else
     
308.                                 {
     
309.                                         TimerDisplay[SettingTimeIndex] %= 60;
     
310.                                 }
     
311.                         }
     
312.                 }
     
313.                 key[2].long_flag = 0;
     
314.         }
     
315.         if(key[3].single_flag)
     
316.         {
     
317.                 if(TimerMode == PAUSE || TimerMode == STANDBY || TimerMode == SETTING)
     
318.                 {
     
319.                         TimerMode = RUNNING;
     
320.                         HAL_TIM_Base_Start_IT(&htim4);
     
321.                         HAL_TIM_Base_Start_IT(&htim6);
     
322.                         HAL_TIM_PWM_Start(&htim16, TIM_CHANNEL_1);
     
323.                 }
     
324.                 else if(TimerMode == RUNNING)
     
325.                 {
     
326.                         TimerMode = PAUSE;
     
327.                 }
     
328.                 key[3].single_flag = 0;
     
329.         }
     
330.        
     
331.         if(key[3].long_flag)
     
332.         {
     
333.                 if(TimerMode == PAUSE || TimerMode == RUNNING)
     
334.                 {
     
335.                         TimerMode = STANDBY;
     
336.                         InternalTimer = 0;
     
337.                         HAL_TIM_Base_Stop_IT(&htim4);
     
338.                         TimerDisplay[HOUR] = eeprom_read(TimerStoreIndex * 3 + 1);
     
339.                         TimerDisplay[MINUTE]= eeprom_read(TimerStoreIndex * 3 + 2);
     
340.                         TimerDisplay[SECOND] = eeprom_read(TimerStoreIndex * 3 + 3);
     
341.                 }
     
342.                 key[3].long_flag = 0;
     
343.         }
     
344. }
     
345. /* USER CODE END 4 */
     
346. 
     
347. /**
     
348.   * @brief  This function is executed in case of error occurrence.
     
349.   * @retval None
     
350.   */
     
351. void Error_Handler(void)
     
352. {
     
353.   /* USER CODE BEGIN Error_Handler_Debug */
     
354.   /* User can add his own implementation to report the HAL error return state */
     
355.   __disable_irq();
     
356.   while (1)
     
357.   {
     
358.   }
     
359.   /* USER CODE END Error_Handler_Debug */
     
360. }
     
361. 
     
362. #ifdef  USE_FULL_ASSERT
     
363. /**
     
364.   * @brief  Reports the name of the source file and the source line number
     
365.   *         where the assert_param error has occurred.
     
366.   * @param  file: pointer to the source file name
     
367.   * @param  line: assert_param error line source number
     
368.   * @retval None
     
369.   */
     
370. void assert_failed(uint8_t *file, uint32_t line)
     
371. {
     
372.   /* USER CODE BEGIN 6 */
     
373.   /* User can add his own implementation to report the file name and line number,
     
374.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
375.   /* USER CODE END 6 */
     
376. }
     
377. #endif /* USE_FULL_ASSERT */
     
378. 
     
379. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
     

复制代码

————————————————
版权声明：火花页.