[8] ESP32 - Arduino - NTP

W tym poście chciałbym opisać sposób implementacji klienta NTP.

[Źródło: http://paulobrien.co.nz/2017/03/16/esp32-programming-with-arduino-on-windows/]

Na samym początku należy zdefiniować dane do połączenia po WIFI oraz nazwę serwera NTP:

1. #include <WiFi.h>
2. #include "time.h"
3. //----------------------------------------------
4. #define TIME_VALUE 3600
5. #define GMT_OFFSET 0
6. #define DAY_OFFSET 3600
7. //----------------------------------------------
8. const char* ssid     = "SSID";
9. const char* password = "PASSWORD";
11. const char* ntpServer_0 = "0.pl.pool.ntp.org";
12. const char* ntpServer_1 = "1.pl.pool.ntp.org";
13. const char* ntpServer_2 = "2.pl.pool.ntp.org";
15. uint16_t readTimeCounter = 0;

W funkcji setup następuje inicjalizacja UART'u, podłączenie do sieci wifi, ustawienie parametrów do pobrania danych z serwera NTP.

1. void setup(){
2.   //-------------------------------------------
3.   Serial.begin(115200);
4.   //-------------------------------------------
5.   Serial.print("Connect to: ");
6.   Serial.println(ssid);
7.   Serial.println(password);
8.   WiFi.begin(ssid, password);
9.   //-------------------------------------------
10.   while (WiFi.status() != WL_CONNECTED) {
11.     delay(1000);
12.     Serial.print(".");
13.   }
14.   //-------------------------------------------
15.   Serial.println("WiFi connected!!");
16.   //-------------------------------------------
17.   configTime(GMT_OFFSET, DAY_OFFSET, ntpServer_0,
18.   ntpServer_1, ntpServer_2);
19.   displayTime();
20.   //-------------------------------------------
21.   //Disconnect wifi to save power
22.   WiFi.disconnect(true);
23.   WiFi.mode(WIFI_OFF);
24. }

Funkcja odpowiedzialna za połączenie z serwerem NTP została zdefiniowana w pliku time.h.

1. void configTime(long gmtOffset_sec, int daylightOffset_sec, const char* server1, const char* server2, const char* server3)
2. {
3.     tcpip_adapter_init();  // Should not hurt anything if already inited
4.     if(sntp_enabled()){
5.         sntp_stop();
6.     }
7.     sntp_setoperatingmode(SNTP_OPMODE_POLL);
8.     sntp_setservername(0, (char*)server1);
9.     sntp_setservername(1, (char*)server2);
10.     sntp_setservername(2, (char*)server3);
11.     sntp_init();
12.     setTimeZone(-gmtOffset_sec, daylightOffset_sec);
13. }

Do funkcji można podać maksymalnie trzy rodzaje serwerów. Wyłączanie wifi jest wykonywane w celu oszczędzenia energii.

W pętli głównej wyświetlam czas umieszczony na serwerach NTP. Dodatkowo raz na godzinę wykonuje ponowne połączenie z serwerem NTP.

1. void loop(){
2.   delay(1000);
3.   displayTime();
5.   if(readTimeCounter >= TIME_VALUE) {
6.     readTimeCounter = 0;
7.     connectToWifiAndGetTime();
8.   }
9.   readTimeCounter++;
10. }

Funkcja wykonywająca ponowne odczytanie danych:

1. void connectToWifiAndGetTime()
2. {
3.   uint8_t connectionCounter = 0;
5.   Serial.print("Reconnect to ");
6.   Serial.println(ssid);
7.   WiFi.begin(ssid, password);
9.   while (WiFi.status() != WL_CONNECTED) {
10.     delay(1000);
11.     Serial.print(".");
12.     connectionCounter++;
13.    
14.     if(connectionCounter >= 6)
15.     {
16.       Serial.println("Connection error...");
17.       connectionCounter = 0xFF;
18.       break;
19.     }
20.   }
22.   if(connectionCounter == 0xFF)
23.   {
24.     /* Data calculated with previos time settings */
25.     return;
26.   }
28.   Serial.println("WiFi connected!!");
30.   configTime(GMT_OFFSET, DAY_OFFSET, ntpServer_0, ntpServer_1, ntpServer_2);
31.   displayTime();
33.   WiFi.disconnect(true);
34.   WiFi.mode(WIFI_OFF);
35. }

Wyświetlenie czasu:

1. void displayTime(){
2.   struct tm timeinfo;
3.   if(!getLocalTime(&timeinfo)){
4.     Serial.println("Get local time error!");
5.     return;
6.   }
7.   Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
8.   Serial.print(" DOW: ");
9.   Serial.print(&timeinfo, "%A");
10.   Serial.print(" Month: ");
11.   Serial.print(&timeinfo, "%B");
12.   Serial.print(" DOM: ");
13.   Serial.print(&timeinfo, "%d");
14.   Serial.print(" Year: ");
15.   Serial.println(&timeinfo, "%Y");
16.   Serial.print(" Hour: ");
17.   Serial.print(&timeinfo, "%H");
18.   Serial.print(" Hour (12 hour format): ");
19.   Serial.print(&timeinfo, "%I");
20.   Serial.print(" Minute: ");
21.   Serial.print(&timeinfo, "%M");
22.   Serial.print(" Second: ");
23.   Serial.println(&timeinfo, "%S");
24. }

Funkcja odpowiedzialna za odczytanie danych z czasem została zdefiniowana w bibliotekach ESP:

1. bool getLocalTime(struct tm * info, uint32_t ms)
2. {
3.     uint32_t start = millis();
4.     time_t now;
5.     while((millis()-start) <= ms) {
6.         time(&now);
7.         localtime_r(&now, info);
8.         if(info->tm_year > (2016 - 1900)){
9.             return true;
10.         }
11.         delay(10);
12.     }
13.     return false;
14. }

Cały projekt wygląda następująco:

1. #include <WiFi.h>
2. #include "time.h"
3. //----------------------------------------------
4. #define TIME_VALUE 3600
5. #define GMT_OFFSET 0
6. #define DAY_OFFSET 3600
7. //----------------------------------------------
8. const char* ssid     = "SSID";
9. const char* password = "PASSWORD";
11. const char* ntpServer_0 = "0.pl.pool.ntp.org";
12. const char* ntpServer_1 = "1.pl.pool.ntp.org";
13. const char* ntpServer_2 = "2.pl.pool.ntp.org";
15. uint16_t readTimeCounter = 0;
17. void setup(){
18.   //-------------------------------------------
19.   Serial.begin(115200);
20.   //-------------------------------------------
21.   Serial.print("Connect to: ");
22.   Serial.println(ssid);
23.   Serial.println(password);
24.   WiFi.begin(ssid, password);
25.   //-------------------------------------------
26.   while (WiFi.status() != WL_CONNECTED) {
27.     delay(1000);
28.     Serial.print(".");
29.   }
30.   //-------------------------------------------
31.   Serial.println("WiFi connected!!");
32.   //-------------------------------------------
33.   configTime(GMT_OFFSET, DAY_OFFSET, ntpServer_0,
34.   ntpServer_1, ntpServer_2);
35.   displayTime();
36.   //-------------------------------------------
37.   //Disconnect wifi to save power
38.   WiFi.disconnect(true);
39.   WiFi.mode(WIFI_OFF);
40. }
42. void loop(){
43.   delay(1000);
44.   displayTime();
46.   if(readTimeCounter >= TIME_VALUE) {
47.     readTimeCounter = 0;
48.     connectToWifiAndGetTime();
49.   }
50.   readTimeCounter++;
51. }
53. void connectToWifiAndGetTime()
54. {
55.   uint8_t connectionCounter = 0;
57.   Serial.print("Reconnect to ");
58.   Serial.println(ssid);
59.   WiFi.begin(ssid, password);
61.   while (WiFi.status() != WL_CONNECTED) {
62.     delay(1000);
63.     Serial.print(".");
64.     connectionCounter++;
65.    
66.     if(connectionCounter >= 6)
67.     {
68.       Serial.println("Connection error...");
69.       connectionCounter = 0xFF;
70.       break;
71.     }
72.   }
74.   if(connectionCounter == 0xFF)
75.   {
76.     /* Data calculated with previos time settings */
77.     return;
78.   }
80.   Serial.println("WiFi connected!!");
82.   configTime(GMT_OFFSET, DAY_OFFSET, ntpServer_0, ntpServer_1, ntpServer_2);
83.   displayTime();
85.   WiFi.disconnect(true);
86.   WiFi.mode(WIFI_OFF);
87. }
89. void displayTime(){
90.   struct tm timeinfo;
91.   if(!getLocalTime(&timeinfo)){
92.     Serial.println("Get local time error!");
93.     return;
94.   }
95.   Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
96.   Serial.print(" DOW: ");
97.   Serial.print(&timeinfo, "%A");
98.   Serial.print(" Month: ");
99.   Serial.print(&timeinfo, "%B");
100.   Serial.print(" DOM: ");
101.   Serial.print(&timeinfo, "%d");
102.   Serial.print(" Year: ");
103.   Serial.println(&timeinfo, "%Y");
104.   Serial.print(" Hour: ");
105.   Serial.print(&timeinfo, "%H");
106.   Serial.print(" Hour (12 hour format): ");
107.   Serial.print(&timeinfo, "%I");
108.   Serial.print(" Minute: ");
109.   Serial.print(&timeinfo, "%M");
110.   Serial.print(" Second: ");
111.   Serial.println(&timeinfo, "%S");
112. }