STM32F401CCU6 LSE Real Time Clock LCD Example

Overview

The STM32F4 has an internal Real Time Clock (RTC) module that can generate date, time, alarm etc. This module can driven from its internal 32KHz oscillator or even an external precise 32.768KHz crystal oscillator.

 

STM32CubeIDE Programming

The STM32F401CCU6 Black Pill has pins-compatible the STM32 Blu Pill (STM32F103CxTx). But I use the specific device in schematic design. Proteus VSM 8.19 also able to simulate the firmware.

Schematic Design in Proteus VSM

 

I use the STM32CubeIDE to write its C source codes. Its code generation wizard is very user-friendly and time-saving. First I need to configure the following blocks,

• Input/Output pins selection
• Select its 16MHz HSI Clock
• Enable the LSE clock source 
• Select its external precise 32.768KHz crystal oscillator
• Enable the RTC in Timer Tab

Then click on generate source codes.

1. GPIO Setting 

I select GPIOA for 4-bit LCD connections and GPIOB for input switches.

STM32CubeIDE GPIO Setting for the STM32F401CCU6

 

It has internal pull-ups resistors for GPIO input mode. However I need to add external pull-up resistors around 3.9kOhm to the input buttons.

2. RCC 

I enable the Low Speed Clock (LSE) that's already on the STM32 Black Pill board with a frequency of 32.768KHz. However I select the 16MHz HSI clock source for main micro-controller clock.

STM32CubeIDE RCC Setting for the STM32F401CCU6

 3. RTC

I enable the internal Real Time Clock (RTC) and Calendar. The date and time data format are in binary that is easy to adjust.

STM32CubeIDE RTC setting for the STM32F401CCU6

Then click on the generate source code to get its skeleton C program with our proffered setting.

I need to add the HD44780 4-bit LCD driver in project Inc and Src directories before it can be called in C main program.

I add my own source code to the main.c file as follow.

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) 2025 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 "lcd4bits.h"
23. 
    
24. RTC_HandleTypeDef hrtc;
25. 
    
26. /* Private function prototypes -----------------------------------------------*/
27. void SystemClock_Config(void);
28. static void MX_GPIO_Init(void);
29. static void MX_RTC_Init(void);
30. 
    
31. uint8_t select=0, old_seconds=0, counter=0;
32. char sDate[17],sTime[16];
33. RTC_DateTypeDef rtc_date;
34. RTC_TimeTypeDef rtc_time;
35. 
    
36. 
    
37. /**
38. * @brief The application entry point.
39. * @retval int
40. */
41. int main(void)
42. {
43. 
    
44. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
45. HAL_Init();
46. 
    
47. /* Configure the system clock */
48. SystemClock_Config();
49. 
    
50. /* Initialize all configured peripherals */
51. MX_GPIO_Init();
52. 
    
53. MX_RTC_Init();
54. 
    
55. 
    
56. lcdInit();
57. lcdStr(" STM32F401CCU6");
58. lcdXY(1,2);
59. lcdStr("LSE RTC Example");
60. HAL_Delay(3000);
61. lcdClear();
62. //Cursor OFF
63. lcdCmd(0x0C);
64. HAL_Delay(5);
65. 
    
66. /* Infinite loop */
67. /* USER CODE BEGIN WHILE */
68. while (1)
69. {
70. HAL_RTC_GetTime(&hrtc,&rtc_time,RTC_FORMAT_BIN);
71. HAL_RTC_GetDate(&hrtc,&rtc_date,RTC_FORMAT_BIN);
72. 
    
73. sprintf(sDate,"Date: %04d/%02d/%02d",2000+rtc_date.Year,
74. rtc_date.Month,rtc_date.Date);
75. sprintf(sTime,"Time: %02d:%02d:%02d",rtc_time.Hours,
76. rtc_time.Minutes,rtc_time.Seconds);
77. 
    
78. lcdXY(1,1); lcdStr(sDate);
79. lcdXY(1,2); lcdStr(sTime);
80. 
    
81. if(select!=0){
82. lcdCmd(0x0F);
83. RTC_Select();
84. RTC_Adjust();
85. counter++;
86. if(counter>=100) { counter=0; select=0; lcdCmd(0x0C); }
87. }
88. 
    
89. if(HAL_GPIO_ReadPin(SELECT_GPIO_Port, SELECT_Pin)==0) {
90. select++;
91. counter=0;
92. }
93. 
    
94. HAL_Delay(250);
95. 
    
96. }
97. /* USER CODE END 3 */
98. }
99. 
    
100. 
     
101. void RTC_Set(void){
102. RTC_TimeTypeDef sTime;
103. RTC_DateTypeDef sDate ;
104. 
     
105. hrtc.Instance = RTC;
106. hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
107. hrtc.Init.AsynchPrediv = 127;
108. hrtc.Init.SynchPrediv = 255;
109. hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
110. hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
111. hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
112. if (HAL_RTC_Init(&hrtc) != HAL_OK)
113. {
114. Error_Handler();
115. }
116. 
     
117. sDate.WeekDay = RTC_WEEKDAY_SATURDAY;
118. sDate.Month = rtc_date.Month;
119. sDate.Date = rtc_date.Date;
120. sDate.Year = rtc_date.Year;
121. 
     
122. if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
123. {
124. Error_Handler();
125. }
126. 
     
127. sTime.Hours = rtc_time.Hours;
128. sTime.Minutes = rtc_time.Minutes;
129. sTime.Seconds = rtc_time.Seconds;
130. sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
131. sTime.StoreOperation = RTC_STOREOPERATION_SET;
132. if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
133. {
134. Error_Handler();
135. }
136. }
137. 
     
138. void RTC_Select(void){
139. 
     
140. switch(select){
141. case 1: lcdXY(10,1); break;
142. case 2: lcdXY(13,1); break;
143. case 3: lcdXY(16,1); break;
144. case 4: lcdXY(8,2); break;
145. case 5: lcdXY(11,2); break;
146. case 6: lcdXY(14,2); break;
147. case 7: select=0; lcdCmd(0x0C); break;
148. }
149. }
150. 
     
151. void RTC_Adjust(void){
152. 
     
153. switch(select){
154. case 1:
155. if(HAL_GPIO_ReadPin(GPIOB,UP_Pin)==0){
156. if(rtc_date.Year<99) rtc_date.Year++;
157. RTC_Set(); counter=0; HAL_Delay(200);
158. }
159. if(HAL_GPIO_ReadPin(GPIOB,DOWN_Pin)==0){
160. if(rtc_date.Year>1) rtc_date.Year--;
161. RTC_Set(); counter=0; HAL_Delay(200);
162. }
163. break;
164. case 2:
165. if(HAL_GPIO_ReadPin(GPIOB,UP_Pin)==0){
166. if(rtc_date.Month<12) rtc_date.Month++;
167. RTC_Set(); counter=0; HAL_Delay(200);
168. }
169. if(HAL_GPIO_ReadPin(GPIOB,DOWN_Pin)==0){
170. if(rtc_date.Month>1) rtc_date.Month--;
171. RTC_Set(); counter=0; HAL_Delay(200);
172. }
173. break;
174. case 3:
175. if(HAL_GPIO_ReadPin(GPIOB,UP_Pin)==0){
176. if(rtc_date.Date<30) rtc_date.Date++;
177. RTC_Set(); counter=0; HAL_Delay(200);
178. }
179. if(HAL_GPIO_ReadPin(GPIOB,DOWN_Pin)==0){
180. if(rtc_date.Date>1) rtc_date.Date--;
181. RTC_Set(); counter=0; HAL_Delay(200);
182. }
183. break;
184. case 4:
185. if(HAL_GPIO_ReadPin(GPIOB,UP_Pin)==0){
186. if(rtc_time.Hours<23) rtc_time.Hours++;
187. RTC_Set(); counter=0; HAL_Delay(200);
188. }
189. if(HAL_GPIO_ReadPin(GPIOB,DOWN_Pin)==0){
190. if(rtc_time.Hours>1) rtc_time.Hours--;
191. RTC_Set(); counter=0; HAL_Delay(200);
192. }
193. break;
194. case 5:
195. if(HAL_GPIO_ReadPin(GPIOB,UP_Pin)==0){
196. if(rtc_time.Minutes<59) rtc_time.Minutes++;
197. RTC_Set(); counter=0;
198. HAL_Delay(200);
199. }
200. if(HAL_GPIO_ReadPin(GPIOB,DOWN_Pin)==0){
201. if(rtc_time.Minutes>1) rtc_time.Minutes--;
202. RTC_Set(); counter=0; HAL_Delay(200);
203. }
204. break;
205. case 6:
206. if(HAL_GPIO_ReadPin(GPIOB,UP_Pin)==0){
207. if(rtc_time.Seconds<59) rtc_time.Seconds++;
208. RTC_Set(); counter=0; HAL_Delay(100);
209. }
210. if(HAL_GPIO_ReadPin(GPIOB,DOWN_Pin)==0){
211. if(rtc_time.Seconds>1) rtc_time.Seconds--;
212. RTC_Set(); counter=0; HAL_Delay(100);
213. }
214. break;
215. 
     
216. }
217. }
218. 
     
219. /**
220. * @brief System Clock Configuration
221. * @retval None
222. */
223. void SystemClock_Config(void)
224. {
225. RCC_OscInitTypeDef RCC_OscInitStruct = {0};
226. RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
227. RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
228. 
     
229. /** Configure the main internal regulator output voltage
230. */
231. __HAL_RCC_PWR_CLK_ENABLE();
232. __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
233. /** Initializes the RCC Oscillators according to the specified parameters
234. * in the RCC_OscInitTypeDef structure.
235. */
236. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_LSE;
237. RCC_OscInitStruct.LSEState = RCC_LSE_ON;
238. RCC_OscInitStruct.HSIState = RCC_HSI_ON;
239. RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
240. RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
241. if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
242. {
243. Error_Handler();
244. }
245. /** Initializes the CPU, AHB and APB buses clocks
246. */
247. RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
248. |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
249. RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
250. RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
251. RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
252. RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
253. 
     
254. if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
255. {
256. Error_Handler();
257. }
258. PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
259. PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
260. if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
261. {
262. Error_Handler();
263. }
264. 
     
265. }
266. 
     
267. /**
268. * @brief RTC Initialization Function
269. * @param None
270. * @retval None
271. */
272. static void MX_RTC_Init(void)
273. {
274. 
     
275. /* USER CODE BEGIN RTC_Init 0 */
276. 
     
277. /* USER CODE END RTC_Init 0 */
278. 
     
279. RTC_TimeTypeDef sTime = {0};
280. RTC_DateTypeDef sDate = {0};
281. 
     
282. /* USER CODE BEGIN RTC_Init 1 */
283. 
     
284. /* USER CODE END RTC_Init 1 */
285. /** Initialize RTC Only
286. */
287. hrtc.Instance = RTC;
288. hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
289. hrtc.Init.AsynchPrediv = 127;
290. hrtc.Init.SynchPrediv = 255;
291. hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
292. hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
293. hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
294. if (HAL_RTC_Init(&hrtc) != HAL_OK)
295. {
296. Error_Handler();
297. }
298. 
     
299. /* USER CODE BEGIN Check_RTC_BKUP */
300. 
     
301. /* USER CODE END Check_RTC_BKUP */
302. 
     
303. /** Initialize RTC and set the Time and Date
304. */
305. sTime.Hours = 18;
306. sTime.Minutes = 20;
307. sTime.Seconds = 30;
308. sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
309. sTime.StoreOperation = RTC_STOREOPERATION_SET;
310. if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
311. {
312. Error_Handler();
313. }
314. sDate.WeekDay = RTC_WEEKDAY_SATURDAY;
315. sDate.Month = RTC_MONTH_NOVEMBER;
316. sDate.Date = 8;
317. sDate.Year = 25;
318. 
     
319. if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
320. {
321. Error_Handler();
322. }
323. /* USER CODE BEGIN RTC_Init 2 */
324. 
     
325. /* USER CODE END RTC_Init 2 */
326. 
     
327. }
328. 
     
329. /**
330. * @brief GPIO Initialization Function
331. * @param None
332. * @retval None
333. */
334. static void MX_GPIO_Init(void)
335. {
336. GPIO_InitTypeDef GPIO_InitStruct = {0};
337. 
     
338. /* GPIO Ports Clock Enable */
339. __HAL_RCC_GPIOC_CLK_ENABLE();
340. __HAL_RCC_GPIOA_CLK_ENABLE();
341. __HAL_RCC_GPIOB_CLK_ENABLE();
342. 
     
343. /*Configure GPIO pin Output Level */
344. HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_4|GPIO_PIN_5
345. |GPIO_PIN_6|GPIO_PIN_7, GPIO_PIN_RESET);
346. 
     
347. /*Configure GPIO pins : PA0 PA1 PA4 PA5
348. PA6 PA7 */
349. GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_4|GPIO_PIN_5
350. |GPIO_PIN_6|GPIO_PIN_7;
351. GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
352. GPIO_InitStruct.Pull = GPIO_NOPULL;
353. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
354. HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
355. 
     
356. /*Configure GPIO pins : SELECT_Pin UP_Pin DOWN_Pin */
357. GPIO_InitStruct.Pin = SELECT_Pin|UP_Pin|DOWN_Pin;
358. GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
359. GPIO_InitStruct.Pull = GPIO_PULLUP;
360. HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
361. 
     
362. }
363. 
     
364. /* USER CODE BEGIN 4 */
365. 
     
366. /* USER CODE END 4 */
367. 
     
368. /**
369. * @brief This function is executed in case of error occurrence.
370. * @retval None
371. */
372. void Error_Handler(void)
373. {
374. /* USER CODE BEGIN Error_Handler_Debug */
375. /* User can add his own implementation to report the HAL error return state */
376. __disable_irq();
377. while (1)
378. {
379. }
380. /* USER CODE END Error_Handler_Debug */
381. }
382. 
     
383. #ifdef USE_FULL_ASSERT
384. /**
385. * @brief Reports the name of the source file and the source line number
386. * where the assert_param error has occurred.
387. * @param file: pointer to the source file name
388. * @param line: assert_param error line source number
389. * @retval None
390. */
391. void assert_failed(uint8_t *file, uint32_t line)
392. {
393. /* USER CODE BEGIN 6 */
394. /* User can add his own implementation to report the file name and line number,
395. ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
396. /* USER CODE END 6 */
397. }
398. #endif /* USE_FULL_ASSERT */
399. 
     
400. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Tesing this program in Proteus is very easy without abruption. 

Proteus Simulation #1

 

Simulation #2

 

I prototype this STM32 Black Pill board on my bread board withing a short time. It works fine.

Breadboard Prototype #1

Breadboard Prototype #2

Click here to download its source file.