[26] STM32F4 - RTC DS3231

Ten post chciałbym poświęcić na opisanie programowania zegara RTC DS3231. Jest to zegar czasu rzeczywistego wyprodukowany przez firmę MAXIM. Komunikacja odbywa się poprzez interfejs I2C.

[Źródło: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

Dokumentacja do układu jest do pobrania pod tym linkiem.

Cube Mx:

Program w CubeMx należy wyposażyć właściwie tylko w obsługę I2C w celu poprawnego odczytywania danych z układu RTC. Do prezentacji wyników może posłużyć USART bądź LCD.

Dla RTC wykorzystałem I2C1, natomiast dla prezentacji wyników USART2.

Konfiguracja zegarów:

Konfiguracja I2C:

Konfiguracja USART:

Przygotowanie programu:

Wpisywanie oraz odbieranie danych z układu:

1. typedef enum{
2.     I2C_Buf_Error = 0x00,
3.     I2C_Buf_OK
4. }Error_Stat;
6. void I2C_WriteBuffer(I2C_HandleTypeDef handler, uint8_t address, uint8_t *buf, uint8_t buffer_sizee)
7. {
8.     while(HAL_I2C_Master_Transmit(&handler, (uint16_t) address, (uint8_t*)buf, (uint16_t) buffer_size, (uint32_t)500)!=HAL_OK)
9.     {
10.             if(HAL_I2C_GetError(&hi)!=HAL_I2C_ERROR_AF) {
11.                 return I2C_Buf_Error;
12.             }
13.     }
14.     return I2C_Buf_OK;
15. }
17. uint8_t I2C_ReadBuffer(I2C_HandleTypeDef handler, uint8_t address, uint8_t *buffer, uint8_t buffer_size)
18. {
19.     while(HAL_I2C_Master_Receive(&handler, (uint16_t) address, (uint8_t*)buffer, (uint16_t)buffer_size, (uint32_t)500)!=HAL_OK)
20.     {
21.             if(HAL_I2C_GetError(&hi)!=HAL_I2C_ERROR_AF){
22.                 return I2C_Buf_Error;
23.             }
24.     }
25.     return I2C_Buf_OK;
26. }

Funkcje w zależności od statusu operacji zwracają odpowiednią wartość result albo Ok albo Error.

RTC rozpocznie odliczanie po podaniu do niego wartości 0. Wobec tego aby go zainicjalizować należy wysłać adres RTC czyli 0x0D po czym przesłać rejestr do którego chce się wprowadzać dane. Na końcu przesyłane są główne dane jakie należy wprowadzić do układu:

1. /*
2.     * Clear control register
3. */
4. uint8_t RTC_Init(void)
5. {
6.     uint8_t data[2] = {DS3231_Control_REG, 0x00};
7.     I2C_WriteBuffer(hi2c1, DS3231_RTC_ADDR, data, sizeof(data));
8. }

Konwersja danych następuje przy użyciu następujących funkcji. Dane z czujnika podawane są w formacie BCD:

1. inline static uint8_t RTC_ConvertFromDec(uint8_t c){
2.     return ((c>>4)*10+(0x0F&c));
3. }
4. //-----------------------------------------------
5. inline static uint8_t RTC_ConvertFromBinDec(uint8_t c){
6.     return ((c/10)<<4)|(c%10);
7. }

Wybranie danych z bufora prezentuje się następująco:

1. void getTimeAndDate(void)
2. {
3.     clearDS3231Buffer();    //Czyszczenie bufora
4.    
5.     I2C_WriteBuffer(hi2c1,(uint16_t)0xD0, rtcData, 1);
6.     while(HAL_I2C_GetState(&hi2c1)!=HAL_I2C_STATE_READY) { }
7.     I2C_ReadBuffer(hi2c1,(uint16_t)0xD0, rtcData, 7);
8.    
9.     DS3231_Time.year = rtcData[6];
10.     DS3231_Time.year = RTC_ConvertFromDec(DS3231_Time.year);   
11.    
12.     DS3231_Time.month = rtcData[5];
13.     DS3231_Time.month = RTC_ConvertFromDec(DS3231_Time.month);
14.    
15.     DS3231_Time.date = rtcData[4];
16.     DS3231_Time.date = RTC_ConvertFromDec(DS3231_Time.date);
17.    
18.     DS3231_Time.day = rtcData[3];
19.     DS3231_Time.day = RTC_ConvertFromDec(DS3231_Time.day);
20.    
21.     DS3231_Time.hours = rtcData[2];
22.     DS3231_Time.hours = RTC_ConvertFromDec(DS3231_Time.hours);
23.    
24.     DS3231_Time.minutes = rtcData[1];
25.     DS3231_Time.minutes = RTC_ConvertFromDec(DS3231_Time.minutes);
26.    
27.     DS3231_Time.seconds = rtcData[0];
28.     DS3231_Time.seconds = RTC_ConvertFromDec(DS3231_Time.seconds);
29.    
30.     DS3231_Time.yearTab[0] = (char)((DS3231_Time.year/10)%10)+0x30;
31.     DS3231_Time.yearTab[1] = (char)(DS3231_Time.year%10)+0x30;
32.    
33.     DS3231_Time.monthTab[0] = (char)(((DS3231_Time.month/10)%10)+0x30);
34.     DS3231_Time.monthTab[1] = (char)((DS3231_Time.month%10)+0x30);
35.    
36.     DS3231_Time.dateTab[0] = (char)((DS3231_Time.date/10)%10)+0x30;
37.     DS3231_Time.dateTab[1] = ((char)(DS3231_Time.date%10)+0x30);
38.        
39.     DS3231_Time.dayTab = ((char)(DS3231_Time.day%10)+0x30);
40.    
41.     DS3231_Time.hoursTab[0] = ((char)((DS3231_Time.hours/10)%10)+0x30);
42.     DS3231_Time.hoursTab[1] = ((char)(DS3231_Time.hours%10)+0x30);
43.    
44.     DS3231_Time.minutesTab[0] = ((char)((DS3231_Time.minutes/10)%10)+0x30);
45.     DS3231_Time.minutesTab[1] = ((char)(DS3231_Time.minutes%10)+0x30);
46.    
47.     DS3231_Time.secondsTab[0] = (char)((DS3231_Time.seconds/10)%10)+0x30;
48.     DS3231_Time.secondsTab[1] = (char)(DS3231_Time.seconds%10)+0x30;
49.    
50.     PrintData(&DS3231_Time);
51. }

Wypisanie danych na ekran wygląda następująco:

1. static void PrintData(DS3231_Time_t *DS3231_Values)
2. {
3.     char toSend[30];
4.     uint8_t calculateSize;
5.     //------------------------------------------------------------------
6.     sprintf(toSend, "Date: %c%c\r\n", DS3231_Time.dateTab[0],DS3231_Time.dateTab[1]);
7.     for(uint8_t i = 0; i<30;i++){
8.         if(toSend[i] == '\n'){
9.             calculateSize = i;
10.             break;
11.         }
12.     }
13.     HAL_UART_Transmit(&huart2, (uint8_t*)toSend, calculateSize, 0xFFFF);
14.     //------------------------------------------------------------------
15.     sprintf(toSend, "Month: %c%c\r\n", DS3231_Time.monthTab[0],DS3231_Time.monthTab[1]);
16.     for(uint8_t i = 0; i<30;i++){
17.         if(toSend[i] == '\n'){
18.             calculateSize = i;
19.             break;
20.         }
21.     }
22.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
23.     //------------------------------------------------------------------
24.     sprintf(toSend, "Year: %c%c\r\n", DS3231_Time.yearTab[0],DS3231_Time.yearTab[1]);  
25.     for(uint8_t i = 0; i<30;i++){
26.         if(toSend[i] == '\n'){
27.             calculateSize = i;
28.             break;
29.         }
30.     }
31.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
32.     //------------------------------------------------------------------
33.     sprintf(toSend, "Day: %c\r\n",  DS3231_Time.dayTab);
34.     for(uint8_t i = 0; i<30;i++){
35.         if(toSend[i] == '\n'){
36.             calculateSize = i;
37.             break;
38.         }
39.     }
40.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
41.     //------------------------------------------------------------------
42.     sprintf(toSend, "Hour: %c%c\r\n", DS3231_Time.hoursTab[0],  DS3231_Time.hoursTab[1]);
43.     for(uint8_t i = 0; i<30;i++){
44.         if(toSend[i] == '\n'){
45.             calculateSize = i;
46.             break;
47.         }
48.     }
49.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
50.     //------------------------------------------------------------------
51.     sprintf(toSend, "Min: %c%c\r\n", DS3231_Time.minutesTab[0],DS3231_Time.minutesTab[1]);
52.        
53.     for(uint8_t i = 0; i<30;i++){
54.         if(toSend[i] == '\n'){
55.             calculateSize = i;
56.             break;
57.         }
58.     }
59.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
60.     //------------------------------------------------------------------
61.     sprintf(toSend, "Sec: %c%c\r\n", DS3231_Time.secondsTab[0],DS3231_Time.secondsTab[1]); 
62.     for(uint8_t i = 0; i<30;i++){
63.         if(toSend[i] == '\n'){
64.             calculateSize = i;
65.             break;
66.         }
67.     }
68.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
69. }

Data oraz czas są pobierane z układu, po czym są wprowadzane do zmiennej strukturalnej, po czym są wypisywane na ekran.

Inicjalizacja i czyszczenie bufora domyślnymi wartościami wygląda następująco:

1. static uint8_t clearDS3231Buffer(void){
2.     DS3231_Time.seconds = 0;
3.     DS3231_Time.minutes = 0;
4.     DS3231_Time.hours = 0;
5.     DS3231_Time.day = 0;   
6.     DS3231_Time.date = 0;
7.     DS3231_Time.month = 0;
8.     DS3231_Time.year = 0;
9. }

Główna pętla programu wygląda następująco:

1. int main(void)
2. {
3.   /* USER CODE BEGIN 1 */
4.   uint8_t str1[]="USART Transmit\r\n";
5.   /* USER CODE END 1 */
7.   /* MCU Configuration----------------------------------------------------------*/
9.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
10.   HAL_Init();
12.   /* USER CODE BEGIN Init */
14.   /* USER CODE END Init */
16.   /* Configure the system clock */
17.   SystemClock_Config();
19.   /* USER CODE BEGIN SysInit */
21.   /* USER CODE END SysInit */
23.   /* Initialize all configured peripherals */
24.   MX_GPIO_Init();
25.   MX_USART2_UART_Init();
26.   MX_I2C1_Init();
28.   /* USER CODE BEGIN 2 */
29.   HAL_UART_Transmit(&huart2,str1,16,0xFFFF);
30.   /* USER CODE END 2 */
32.   /* Infinite loop */
33.   /* USER CODE BEGIN WHILE */
34.   while (1)
35.   {
36.         /* USER CODE END WHILE */
37.         /* USER CODE BEGIN 3 */
38.         getTimeAndDate();
39.         HAL_Delay(1000);
40.   }
41.   /* USER CODE END 3 */
42. }

Plik konfiguracyje dla DS3231 oraz I2C. Na początku sd3231_i2c.c:

1. #include "ds3231_i2c.h"
2. //--------------------------------------
3. extern I2C_HandleTypeDef hi2c1;
4. extern UART_HandleTypeDef huart2;
5. //--------------------------------------
6. extern uint8_t rtcData[8];
7. char str[100];
8. //--------------------------------------
9. typedef enum ErrorStat{
10.     I2C_Buf_Error = 0x00,
11.     I2C_Buf_OK = 0x01
12. }Error_Stat_Typedef;
14. typedef enum weekDay_Enum_Struct{
15.     wdSunday = 0x01,
16.     wdMonday = 0x02,
17.     wdTuesday = 0x03,
18.     wdWednesday = 0x04,
19.     wdThursday = 0x05,
20.     wdFriday = 0x06,
21.     weSaturday = 0x07
22. }weekDay_t;
24. typedef struct{
25.     uint8_t seconds;    /*Seconds 00-59 */
26.         char secondsTab[2]; /* Contains coverted seconds data*/
27.     uint8_t minutes;    /*Minutes 00-59 */
28.         char minutesTab[2]; /* Contains coverted minutes data*/
29.         uint8_t hours;      /* Hours 00-23 */
30.     char hoursTab[2];       /* Contains coverted hours data*/
31.         uint8_t day;        /* Day in a week 1-7 */
32.     weekDay_t dayTab;       /* Contains coverted day data*/
33.         uint8_t date;       /* Day in a month    1-31 */
34.     char dateTab[2];        /* Contains coverted date data*/
35.         uint8_t month;      /* Month 1-12 */
36.         char monthTab[2];       /* Contains coverted month data*/
37.         uint8_t year;       /* Year                00-99 */
38.         char yearTab[2];        /* Contains coverted year data*/
39. }DS3231_Time_t;
40. //--------------------------------------
41. DS3231_Time_t DS3231_Time;
42. //--------------------------------------
43. static uint8_t clearDS3231Buffer(void)
44. {
45.     DS3231_Time.seconds = 0;
46.     DS3231_Time.minutes = 0;
47.     DS3231_Time.hours = 0;
48.     DS3231_Time.day = 0;   
49.     DS3231_Time.date = 0;
50.     DS3231_Time.month = 0;
51.     DS3231_Time.year = 0;
52. }
53. //--------------------------------------
54. uint8_t I2C_WriteBuffer(I2C_HandleTypeDef hi, uint8_t DEV_ADDR, uint8_t *buf, uint8_t sizebuf)
55. {
56.     while(HAL_I2C_Master_Transmit(&hi, (uint16_t)DEV_ADDR,(uint8_t*)buf,
57.                 (uint16_t)sizebuf, (uint32_t)500)!= HAL_OK)
58.     {
59.         if (HAL_I2C_GetError(&hi) != HAL_I2C_ERROR_AF)
60.         {
61.             return I2C_Buf_Error;
62.         }
63.     }
64.     return I2C_Buf_OK;
65. }
66. //--------------------------------------
67. uint8_t I2C_ReadBuffer(I2C_HandleTypeDef hi, uint8_t DEV_ADDR, uint8_t *buf, uint8_t sizebuf)
68. {
69.     while(HAL_I2C_Master_Receive(&hi, (uint16_t)DEV_ADDR, (uint8_t*)buf,
70.                 (uint16_t)sizebuf, (uint32_t)500)!= HAL_OK)
71.     {
72.         if (HAL_I2C_GetError(&hi) != HAL_I2C_ERROR_AF)
73.         {  
74.             return I2C_Buf_Error;
75.         }
76.     }
77.     return I2C_Buf_OK;
78. }
80. //-----------------------------------------------
81. inline static uint8_t RTC_ConvertFromDec(uint8_t c)
82. {
83.     return ((c>>4)*10+(0x0F&c));
84. }
86. //-----------------------------------------------
87. inline static uint8_t RTC_ConvertFromBinDec(uint8_t c)
88. {
89.     return ((c/10)<<4)|(c%10);
90. }
91. //-----------------------------------------------
92. static void PrintData(DS3231_Time_t *DS3231_Values)
93. {
94.     char toSend[30];
95.     uint8_t calculateSize;
96.     //------------------------------------------------------------------
97.     sprintf(toSend, "Date: %c%c\r\n", DS3231_Time.dateTab[0],DS3231_Time.dateTab[1]);
98.     for(uint8_t i = 0; i<30;i++){
99.         if(toSend[i] == '\n'){
100.             calculateSize = i;
101.             break;
102.         }
103.     }
104.     HAL_UART_Transmit(&huart2, (uint8_t*)toSend, calculateSize, 0xFFFF);
105.     //------------------------------------------------------------------
106.     sprintf(toSend, "Month: %c%c\r\n", DS3231_Time.monthTab[0],DS3231_Time.monthTab[1]);
107.     for(uint8_t i = 0; i<30;i++){
108.         if(toSend[i] == '\n'){
109.             calculateSize = i;
110.             break;
111.         }
112.     }
113.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
114.     //------------------------------------------------------------------
115.     sprintf(toSend, "Year: %c%c\r\n", DS3231_Time.yearTab[0],DS3231_Time.yearTab[1]);  
116.     for(uint8_t i = 0; i<30;i++){
117.         if(toSend[i] == '\n'){
118.             calculateSize = i;
119.             break;
120.         }
121.     }
122.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
123.     //------------------------------------------------------------------
124.     sprintf(toSend, "Day: %c\r\n",  DS3231_Time.dayTab);
125.     for(uint8_t i = 0; i<30;i++){
126.         if(toSend[i] == '\n'){
127.             calculateSize = i;
128.             break;
129.         }
130.     }
131.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
132.     //------------------------------------------------------------------
133.     sprintf(toSend, "Hour: %c%c\r\n", DS3231_Time.hoursTab[0],  DS3231_Time.hoursTab[1]);
134.     for(uint8_t i = 0; i<30;i++){
135.         if(toSend[i] == '\n'){
136.             calculateSize = i;
137.             break;
138.         }
139.     }
140.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
141.     //------------------------------------------------------------------
142.     sprintf(toSend, "Min: %c%c\r\n", DS3231_Time.minutesTab[0],DS3231_Time.minutesTab[1]);
143.        
144.     for(uint8_t i = 0; i<30;i++){
145.         if(toSend[i] == '\n'){
146.             calculateSize = i;
147.             break;
148.         }
149.     }
150.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
151.     //------------------------------------------------------------------
152.     sprintf(toSend, "Sec: %c%c\r\n", DS3231_Time.secondsTab[0],DS3231_Time.secondsTab[1]); 
153.     for(uint8_t i = 0; i<30;i++){
154.         if(toSend[i] == '\n'){
155.             calculateSize = i;
156.             break;
157.         }
158.     }
159.     HAL_UART_Transmit(&huart2,(uint8_t*)toSend,calculateSize,0xFFFF);
160. }
161. //-----------------------------------------------
162. void getTimeAndDate(void)
163. {
164.     //clearDS3231Buffer();
165.    
166.     I2C_WriteBuffer(hi2c1, (uint16_t)0xD0, rtcData, 1);
167.     while(HAL_I2C_GetState(&hi2c1)!=HAL_I2C_STATE_READY) { }
168.     I2C_ReadBuffer(hi2c1, (uint16_t)0xD0, rtcData, 7);
169.    
170.     DS3231_Time.year = rtcData[6];
171.     DS3231_Time.year = RTC_ConvertFromDec(DS3231_Time.year);   
172.    
173.     DS3231_Time.month = rtcData[5];
174.     DS3231_Time.month = RTC_ConvertFromDec(DS3231_Time.month);
175.    
176.     DS3231_Time.date = rtcData[4];
177.     DS3231_Time.date = RTC_ConvertFromDec(DS3231_Time.date);
178.    
179.     DS3231_Time.day = rtcData[3];
180.     DS3231_Time.day = RTC_ConvertFromDec(DS3231_Time.day);
181.    
182.     DS3231_Time.hours = rtcData[2];
183.     DS3231_Time.hours = RTC_ConvertFromDec(DS3231_Time.hours);
184.    
185.     DS3231_Time.minutes = rtcData[1];
186.     DS3231_Time.minutes = RTC_ConvertFromDec(DS3231_Time.minutes);
187.    
188.     DS3231_Time.seconds = rtcData[0];
189.     DS3231_Time.seconds = RTC_ConvertFromDec(DS3231_Time.seconds);
190.    
191.     DS3231_Time.yearTab[0] = (char)((DS3231_Time.year/10)%10)+0x30;
192.     DS3231_Time.yearTab[1] = (char)(DS3231_Time.year%10)+0x30;
193.    
194.     DS3231_Time.monthTab[0] = (char)(((DS3231_Time.month/10)%10)+0x30);
195.     DS3231_Time.monthTab[1] = (char)((DS3231_Time.month%10)+0x30);
196.    
197.     DS3231_Time.dateTab[0] = (char)((DS3231_Time.date/10)%10)+0x30;
198.     DS3231_Time.dateTab[1] = ((char)(DS3231_Time.date%10)+0x30);
199.        
200.     DS3231_Time.dayTab = ((char)(DS3231_Time.day%10)+0x30);
201.    
202.     DS3231_Time.hoursTab[0] = ((char)((DS3231_Time.hours/10)%10)+0x30);
203.     DS3231_Time.hoursTab[1] = ((char)(DS3231_Time.hours%10)+0x30);
204.    
205.     DS3231_Time.minutesTab[0] = ((char)((DS3231_Time.minutes/10)%10)+0x30);
206.     DS3231_Time.minutesTab[1] = ((char)(DS3231_Time.minutes%10)+0x30);
207.    
208.     DS3231_Time.secondsTab[0] = (char)((DS3231_Time.seconds/10)%10)+0x30;
209.     DS3231_Time.secondsTab[1] = (char)(DS3231_Time.seconds%10)+0x30;
210.    
211.     PrintData(&DS3231_Time);
212. }

Plik .h wygląda następująco:

1. #include "stm32f4xx_hal.h"
2. #include "stm32f4xx_hal_i2c.h"
3. #include <stdint.h>
4. #include <string.h>
5. #include <stdlib.h>
6. #include "main.h"
7. //-----------------------------------------------
8. #define DS3231_ADD  (uint16_t)0xD0
9. #define DS3231_SECONDS_REGISTER 0x00
10. #define DS3231_ALARM1_SECONDS_REGISTER 0x07
11. #define DS3231_ALARM2_SECONDS_REGISTER 0x0B
12. #define DS3231_TEMPERATURE_MSB_REGISTER 0x11
13. #define DS3231_CONTROL_REGISTER 0x0F
14. //-----------------------------------------------
15. extern uint8_t rtcData[8];
16. //-----------------------------------------------
17. uint8_t I2C_WriteBuffer(I2C_HandleTypeDef hi, uint8_t DEV_ADDR, uint8_t *buf, uint8_t sizebuf);
18. uint8_t I2C_ReadBuffer(I2C_HandleTypeDef hi, uint8_t DEV_ADDR, uint8_t *buf, uint8_t sizebuf);
19. /* ======================= */
20. void getTimeAndDate(void);
21. //-----------------------------------------------