[8] ESP32 - Arduino - Pobranie danych z przypadkami koronowirusa

Ten post chciałbym poświęcić na przygotowanie programu pobierającego dane o koronowirusie.

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

W celu pobrania aktualnych danych posłużę się następującym serwerem NovelCovid. Link do strony na githubie: https://github.com/novelcovid/api

Aby pobrać aktualne dane dla Polski należy wysłać następujące żądanie:

1. https://corona.lmao.ninja/countries/poland

W odpowiedzi wyświetlą się następujące informacje w formacie JSON:

1. {
2.     "country":"Poland",
3.     "cases":425,
4.     "todayCases":70,
5.     "deaths":5,
6.     "todayDeaths":0,
7.     "recovered":13,
8.     "active":407,
9.     "critical":3,
10.     "casesPerOneMillion":11
11. }

Powyższa ramka jest już nieaktualna. Została zastąpiona następującą:

1. {
2.     "country":"Poland",
3.     "countryInfo
4.     {
5.         "_id":616,
6.         "iso2":"PL",
7.         "iso3":"POL",
8.         "lat":52,
9.         "long":20,
10.       "flag":"https://raw.githubusercontent.com/NovelCOVID/API/master/assets/flags/pl.png"
11.     },
12.     "cases":2055,
13.     "todayCases":193,
14.     "deaths":31,
15.     "todayDeaths":9,
16.     "recovered":7,
17.     "active":2017,
18.     "critical":3,
19.     "casesPerOneMillion":54,
20.     "deathsPerOneMillion":0.8,
21.     "updated":1585600658521
22. }

Zmiany polegają na dodaniu dokładniejszych informacji o kraju, ilości śmierci na milion mieszkańców oraz czas aktualizacji.

Innym sposobem jest pobranie wszystkich wyników z całego świata:

1. https://corona.lmao.ninja/all

Odczytana odpowiedź to:

1. {
2.     "cases":776069,
3.     "deaths":37126,
4.     "recovered":164622,
5.     "updated":1585601858656,
6.     "active":574321
7. }

//---------------------------------------------------------------------------------------------------------------------

###AKTUALIZACJA###:

Adres strony został zmieniony. Tym razem dane można pobrać wykorzystując następujące linki:

1. https://corona.lmao.ninja/v2/countries/
2. https://corona.lmao.ninja/v2/all/

Dodatkowo ilość danych dla wszystkich krajów została zwiększona. Teraz JSON wygląda następująco:

1. {
2.     "updated":1587114100141,
3.     "cases":2190317,
4.     "todayCases":9009,
5.     "deaths":147027,
6.     "todayDeaths":1556,
7.     "recovered":553672,
8.     "active":1489618,
9.     "critical":56601,
10.     "casesPerOneMillion":281,
11.     "deathsPerOneMillion":18,
12.     "tests":18455619,
13.     "testsPerOneMillion":2367.7,
14.     "affectedCountries":212
15. }

//---------------------------------------------------------------------------------------------------------------------

Pozostałe opcje można sprawdzić na stronie projektu na Githubie.

Poniżej przykładowy program wypisujący dane w przez uart:

Powyższy przykład pozwala na wyciągnięcie danych dla trzech krajów oraz dla danych globalnych.

1. #include <ArduinoJson.h>
2. #include <WiFi.h>
3. #include <HTTPClient.h>
4. //-------------------------------------------------
5. #define JSON_BUFF_DIMENSION 500
6. //---------------------------------------------------
7. #define POLAND "poland"
8. #define ITALY "italy"
9. #define GERMANY "germany"
10. //---------------------------------------------------
11. const char* ssid = "SSID";
12. const char* password =  "PASSWORD";
13. //---------------------------------------------------
14. const String COUNTRIES_STRING = "https://corona.lmao.ninja/v2/countries/";
15. const String GLOBAL_DATA_STRING = "https://corona.lmao.ninja/v2/all";
16. //---------------------------------------------------
17. String jsonStringText;
18. String countryArray[3] = {POLAND, ITALY, GERMANY};
19. //---------------------------------------------------
20. void setup() {
21.   Serial.begin(115200);
22.   WiFi.begin(ssid, password);
23.   while (WiFi.status() != WL_CONNECTED) {
24.     delay(1000);
25.     Serial.print("Connection with WIFI Network....");
26.   }
27.   Serial.println("Connected!");
28.   jsonStringText.reserve(JSON_BUFF_DIMENSION);
29. }
30. //---------------------------------------------------
31. void loop(){
32.   if ((WiFi.status() == WL_CONNECTED))
33.   {
34.     HTTPClient http;
35.    
36.     for(uint8_t i=0;i<3;i++)
37.     {
38.       http.begin(COUNTRIES_STRING + countryArray[i]); //Specify the URL
39.       int httpResponseCode = http.GET();  //Make the request
40.      
41.       if (httpResponseCode > 0)
42.       {
43.         jsonStringText = http.getString();
44.         Serial.println(httpResponseCode);
45.         Serial.println(jsonStringText);
46.         parseCountryJsonData(jsonStringText.c_str());
47.       }
48.       else
49.       {
50.         Serial.println("Http Request Error");
51.       }
52.     }
54.     http.begin(GLOBAL_DATA_STRING); //Specify the URL
55.     int httpResponseCode = http.GET();  //Make the request
56.      
57.     if (httpResponseCode > 0)
58.     {
59.       jsonStringText = http.getString();
60.       Serial.println(httpResponseCode);
61.       Serial.println(jsonStringText);
62.       parseGlobalJsonData(jsonStringText.c_str());
63.     }
64.     else
65.     {
66.       Serial.println("Http Request Error");
67.     }
68.     http.end();
69.   }
70.   delay(100000);
71. }
73. void parseGlobalJsonData(const char * jsonString)
74. {
75.   DynamicJsonDocument jsonBuffer(1000);
76.   auto error = deserializeJson(jsonBuffer, jsonString);
78.   if (error) {
79.     Serial.println("Deserialize error");
80.     Serial.println(error.c_str());
81.     return;
82.   }
83.   else
84.   {
85.     Serial.println("Deserialize OK!");
86.   }
87.   //---------------------------------------------------
88.   size_t len = measureJson(jsonBuffer);
89.   Serial.println("Msg Len: " + String(len));
90.   Serial.println("********************************************************");
91.   Serial.println("Global data:");
93.   int cases = jsonBuffer["cases"];
94.   Serial.println("1 - Cases: " + String(cases));
96.   int deaths = jsonBuffer["deaths"];
97.   Serial.println("2 - Deaths: " + String(deaths));
99.   int recovered = jsonBuffer["recovered"];
100.   Serial.println("3 - Recovered: " + String(recovered));
101.    
102.   Serial.println("********************************************************");
103. }
105. void parseCountryJsonData(const char * jsonString)
106. {
107.   //----------------------------------------------------
108.   DynamicJsonDocument jsonBuffer(1500);
109.   auto error = deserializeJson(jsonBuffer, jsonString);
110.   //----------------------------------------------------
111.   if (error) {
112.     Serial.println("Deserialize error");
113.     Serial.println(error.c_str());
114.     return;
115.   }
116.   else
117.   {
118.     Serial.println("Deserialize OK!");
119.   }
120.   //---------------------------------------------------
121.   size_t len = measureJson(jsonBuffer);
122.   Serial.println("Msg Len: " + String(len));
123.   //---------------------------------------------------
124.   Serial.println("********************************************************");
125.   String country = jsonBuffer["country"];
126.   Serial.println("1 - Country: " + country);
128.   int cases = jsonBuffer["cases"];
129.   Serial.println("2 - Cases: " + String(cases));
131.   int todayCases = jsonBuffer["todayCases"];
132.   Serial.println("3 - Today cases: " + String(todayCases));
134.   int deaths = jsonBuffer["deaths"];
135.   Serial.println("4 - Deaths: " + String(deaths));
137.   int todayDeaths = jsonBuffer["todayDeaths"];
138.   Serial.println("5 - Today deaths: " + String(todayDeaths));
140.   int recovered = jsonBuffer["recovered"];
141.   Serial.println("6 - Recovered: " + String(recovered));
143.   int active = jsonBuffer["active"];
144.   Serial.println("7 - Active: " + String(active));
146.   int critical = jsonBuffer["critical"];
147.   Serial.println("8 - Critical: " + String(critical));
149.   int casesPerOneMillion = jsonBuffer["casesPerOneMillion"];
150.   Serial.println("8 - Case Per One Million: " + String(casesPerOneMillion));
152.   Serial.println("********************************************************");
153. }

Dla powyższego programu dane zostaną wyświetlone w konsoli. Poniżej otrzymane wyniki operacji dla trzech wybranych krajów.

Dane dla wszystkich przypadków:

Do lepszej prezentacji danych można wykorzystać np. wyświetlacz 2x16 lub inny dostępny.

Ja wykorzystałem wyświetlacz TFT 4'3 cala o rozdzielczości 480x272 (producent AV-Display). Sterowanie wyświetlaczem odbywa się przez interfejs UART (sklep, dokumentacja).

Głównym powodem jego wykorzystania jest prosta obsługa oraz to, że akurat mam taki model nieużywany.

Sterowanie odbywa się przez przesłanie odpowiedniej ramki danych do wyświetlacza.

Chciałbym tutaj jeszcze zaznaczyć, że wykorzystuje czcionki podstawowe bez polskich znaków. Dlatego teksty wyświetlane na ekranie będą w języku angielskim.

Głównym powodem zastosowania języka angielskiego jest dosyć mozolny i nieprzyjemny proces przygotowania czcionki z polskimi znakami. Jest to oczywiście możliwe, natomiast zajmuje sporo czasu i trzeba poświecić sporo uwagi na obsługę programu w języku chińskim.

Tak więc w celu wyświetlenia tekstu na ekranie należy przesłać:

1. HZBXX Xa Ya C Cb Str

Gdzie XX oznacza wielkość czcionki:

• 16,
• 24,
• 32,
• 48,
• 64.

W celu wyświetlenia tekstu należy podać kolor jakim zostanie uzupełnione tło pod napisem. Niestety nie widzę w dokumentacji możliwości wyświetlenia tekstu w transparentnego. Co oznacza, że najlepiej jako tło pod tekstem zastosować jednolity kolor dostępny na wyświetlaczu zamiast np. zdjęcia.

Załadowanie zdjęcia umieszczonego na karcie SD przy wyświetlaczu:

1. LOAD Xa Ya Path

Wyświetlacz pozwala na wyświetlenie plików jpg, gif, png itp. w tym plików png transparentnych.

ESP32 posiada następujące interfejsy UART:

UART0 - RX: GPIO3; TX: GPIO1;
UART1 - RX: GPIO9; TX: GPIO10;
UART2 - RX: GPIO3; TX: GPIO17;

Interfejs UART0 wykorzystywany jest przez podłączenie kablem USB. Wobec tego wykorzystam UART1. Głównym powodem jest chęć zostawienia łatwego interfejsu UART w celu debugowania bądź wyświetlania danych po transmisji szeregowej.

Należy także pamiętać, że w ESP32 min. linie UART mogą zostać przypisane przez użytkownika do innych wyprowadzeń w dowolny sposób.

Do przesłania danych przygotowuję osobny plik description.h zawierający dostępne wartości czcionek:

1. enum enum_FontSize {
2.   FontSize_16 = 16,
3.   FontSize_24 = 24,
4.   FontSize_32 = 32,
5.   FontSize_48 = 48,
6.   FontSize_64 = 64
7. };

Funkcje odpowiedzialne za sterowanie wyświetlaczem:

1. void LCD_PrintStringWithBg(const char * str, const uint16_t len, const enum enum_FontSize fontSize,
2.                            const uint16_t posX, const uint16_t posY, const uint16_t textColor, const uint16_t bgColor) {
3.   uint8_t text[len + 1];
4.   memset(text, 0, sizeof text);
5.   memcpy(text, str, len);
7.   char bufferOut[64];
8.   int bufSize = sprintf(bufferOut, "HZB%d %d %d %d %d %s\n\r", fontSize, posX, posY, textColor, bgColor, text);
9.   Serial2.write((uint8_t *)bufferOut, bufSize);
10. }
12. void LCD_LoadPicture(const char * path, const uint16_t posX, const uint16_t posY) {
14.   char bufferOut[64];
15.   memset(bufferOut, 0, sizeof bufferOut);
16.   int bufSize = sprintf(bufferOut, "LOAD %d %d %s\n\r", posX, posY, path);
17.   Serial2.write((uint8_t *)bufferOut, bufSize);
18. }
20. int LCD_ClearScreen(uint16_t bgColor) {
21.   if(bgColor > 65535) {
22.     return 0;
23.   }
25.   char bufferOut[16];
26.   int bufSize = sprintf(bufferOut, "CLS %d\n\r", bgColor);
27.   Serial2.write((uint8_t *)bufferOut, bufSize);
28.   return bufSize;
29. }

Poniżej całość programu:

1. #include <ArduinoJson.h>
2. #include <WiFi.h>
3. #include <HTTPClient.h>
4. #include "declaration.h"
5. //-------------------------------------------------
6. #define COLOR_AQUA        (uint16_t)0x07FF
7. #define COLOR_BLACK       (uint16_t)0x0000
8. #define COLOR_BLUE        (uint16_t)0x001F
9. #define COLOR_FUCHSIA     (uint16_t)0xF81F
10. #define COLOR_GREEN       (uint16_t)0x0400
11. #define COLOR_GREY        (uint16_t)0x8410
12. #define COLOR_LIME        (uint16_t)0x07E0
13. #define COLOR_MAROON      (uint16_t)0x8000
14. #define COLOR_NAVY        (uint16_t)0x0010
15. #define COLOR_OLIVE       (uint16_t)0x8400
16. #define COLOR_PURPLE      (uint16_t)0xC00F
17. #define COLOR_RED         (uint16_t)0x9800
18. #define COLOR_SILVER      (uint16_t)0xC618
19. #define COLOR_TEAL        (uint16_t)0x0410
20. #define COLOR_YELLOW      (uint16_t)0xFF40
21. #define COLOR_WHITE       (uint16_t)0xFFFF  
22. //-------------------------------------------------
23. #define JSON_BUFF_DIMENSION 500
24. //---------------------------------------------------
25. #define POLAND "poland"
26. #define ITALY "italy"
27. #define GERMANY "germany"
28. #define USA "usa"
29. //---------------------------------------------------
30. typedef struct CountryData{
31.   String country;
32.   int cases;
33.   int todayCases;
34.   int deaths;
35.   int todayDeaths;
36.   int recovered;
37.   int active;
38.   int critical;
39.   int casesPerOneMillion;
40. }CountryDataTypeDef;
42. CountryDataTypeDef CountryData[5];  //[0] Polska
43.                                     //[1] Włochy
44.                                     //[2] Niemcy
45.                                     //[3] USA
46.                                     //[4] Świat
48. //---------------------------------------------------
49. const char* ssid = "SSID";
50. const char* password =  "PASSWORD";
51. //---------------------------------------------------
52. const String COUNTRIES_STRING = "https://corona.lmao.ninja/v2/countries/";
53. const String GLOBAL_DATA_STRING = "https://corona.lmao.ninja/v2/all";
54. //---------------------------------------------------
55. String jsonStringText;
56. String countryArray[4] = {POLAND, ITALY, GERMANY, USA};
57. //---------------------------------------------------
58. int period = 0;
59. unsigned long time_now = 0;
60. //---------------------------------------------------
61. String command;
62. //---------------------------------------------------
63. int touchCounter = 0;
64. int displayCountry = 0;
65. int errorCounter = 0;
66. //---------------------------------------------------
67. void setup() {
68.   Serial.begin(115200);
69.   Serial2.begin(115200, SERIAL_8N1, 16, 17);
71.   /* Czas potrzebny do uruchomienia wyświetlacza po starcie zasilania */
72.   delay(3000);
74.   WiFi.begin(ssid, password);
75.   while (WiFi.status() != WL_CONNECTED) {
76.     delay(1000);
77.     Serial.print("Connection with WIFI Network....");
78.   }
79.   Serial.println("Connected!");
81.   jsonStringText.reserve(JSON_BUFF_DIMENSION);
82.   LCD_ClearScreen(COLOR_NAVY);
83.   LCD_PrintStringWithBg("Pobieranie danych...", 17, FontSize_32, 10, 5, COLOR_WHITE, COLOR_NAVY);
84. }
85. //---------------------------------------------------
86. void loop(){
87.   if(Serial2.available()){
88.      command = Serial2.readStringUntil('\n');
89.      if(command.indexOf("XY") > 0) {
90.       touchCounter++;
91.      }
93.      if(touchCounter == 5) {
94.       touchCounter = 0;
95.       displayCountry++;
96.      
97.       if(displayCountry == 5)
98.       {
99.         displayCountry = 0;
100.       }
101.       LCD_ClearScreen(COLOR_NAVY);
102.       LoadSettingsIntoScreen(displayCountry);
103.       LCD_LoadPicture("jpg/cvlog.jpg", 44, 175);
104.      }
105.   }
107.   if ((WiFi.status() == WL_CONNECTED) && (millis() - time_now > period))
108.   {
109.     HTTPClient http;
111.     errorCounter = 0;
112.     for(uint8_t i=0;i<4;i++)
113.     {
114.       http.begin(COUNTRIES_STRING + countryArray[i]); //Specify the URL
115.       int httpResponseCode = http.GET();  //Make the request
116.      
117.       if (httpResponseCode > 0)
118.       {
119.         errorCounter=0;
120.         jsonStringText = http.getString();
121.         Serial.println(httpResponseCode);
122.         Serial.println(jsonStringText);
123.         parseCountryJsonData(jsonStringText.c_str(), i);
124.       }
125.       else
126.       {
127.         errorCounter++;
128.         if(errorCounter == 2)
129.         {
130.           errorCounter=0;
131.         }
132.         else
133.         {
134.           i--;
135.         }
136.         Serial.println("Http Request Error");
137.       }
138.     }
140.     http.begin(GLOBAL_DATA_STRING); //Specify the URL
141.     int httpResponseCode = http.GET();  //Make the request
142.      
143.     if (httpResponseCode > 0)
144.     {
145.       jsonStringText = http.getString();
146.       Serial.println(httpResponseCode);
147.       Serial.println(jsonStringText);
148.       parseGlobalJsonData(jsonStringText.c_str());
149.     }
150.     else
151.     {
152.       Serial.println("Http Request Error");
153.     }
154.     http.end();
156.     LCD_ClearScreen(COLOR_NAVY);
157.     LoadSettingsIntoScreen(0);
158.     LCD_LoadPicture("jpg/cvlog.jpg", 44, 175);
159.     time_now = millis();
160.     period = 200000;
161.   }
162. }
164. void parseGlobalJsonData(const char * jsonString)
165. {
166.   DynamicJsonDocument jsonBuffer(1000);
167.   auto error = deserializeJson(jsonBuffer, jsonString);
169.   if (error) {
170.     Serial.println("Deserialize error");
171.     Serial.println(error.c_str());
172.     return;
173.   }
174.   else
175.   {
176.     Serial.println("Deserialize OK!");
177.   }
178.   //---------------------------------------------------
179.   size_t len = measureJson(jsonBuffer);
180.   Serial.println("Msg Len: " + String(len));
181.   Serial.println("********************************************************");
182.   Serial.println("Global data:");
184.   CountryData[4].country = "World";
185.   CountryData[4].todayCases = 0;
186.   CountryData[4].todayDeaths = 0;
187.   CountryData[4].critical = 0;
188.   CountryData[4].casesPerOneMillion = 0;
190.   CountryData[4].cases = jsonBuffer["cases"];;
191.   Serial.println("1 - Cases: " + String(CountryData[4].cases));
193.   CountryData[4].deaths = jsonBuffer["deaths"];
194.   Serial.println("2 - Deaths: " + String(CountryData[4].deaths));
196.   CountryData[4].recovered = jsonBuffer["recovered"];
197.   Serial.println("3 - Recovered: " + String(CountryData[4].recovered ));
199.   CountryData[4].active = jsonBuffer["active"];
200.   Serial.println("4 - Active: " + String(CountryData[4].active));
202.   Serial.println("********************************************************");
203. }
205. void parseCountryJsonData(const char * jsonString, int structPosition)
206. {
207.   //----------------------------------------------------
208.   DynamicJsonDocument jsonBuffer(1500);
209.   auto error = deserializeJson(jsonBuffer, jsonString);
210.   //----------------------------------------------------
211.   if (error) {
212.     Serial.println("Deserialize error");
213.     Serial.println(error.c_str());
214.     return;
215.   }
216.   else
217.   {
218.     Serial.println("Deserialize OK!");
219.   }
220.   //---------------------------------------------------
221.   size_t len = measureJson(jsonBuffer);
222.   Serial.println("Msg Len: " + String(len));
223.   //---------------------------------------------------
224.   Serial.println("********************************************************");
226.   String country = (jsonBuffer["country"]);
227.   CountryData[structPosition].country = country;
228.   Serial.println("1 - Country: " + CountryData[structPosition].country );
230.   CountryData[structPosition].cases = jsonBuffer["cases"];
231.   Serial.println("2 - Cases: " + String(CountryData[structPosition].cases));
233.   CountryData[structPosition].todayCases = jsonBuffer["todayCases"];
234.   Serial.println("3 - Today cases: " + String(CountryData[structPosition].todayCases));
236.   CountryData[structPosition].deaths = jsonBuffer["deaths"];
237.   Serial.println("4 - Deaths: " + String(CountryData[structPosition].deaths));
239.   CountryData[structPosition].todayDeaths = jsonBuffer["todayDeaths"];
240.   Serial.println("5 - Today deaths: " + String(CountryData[structPosition].todayDeaths));
242.   CountryData[structPosition].recovered = jsonBuffer["recovered"];
243.   Serial.println("6 - Recovered: " + String(CountryData[structPosition].recovered));
245.   CountryData[structPosition].active = jsonBuffer["active"];
246.   Serial.println("7 - Active: " + String(CountryData[structPosition].active));
248.   CountryData[structPosition].critical = jsonBuffer["critical"];
249.   Serial.println("8 - Critical: " + String(CountryData[structPosition].critical));
251.   CountryData[structPosition].casesPerOneMillion = jsonBuffer["casesPerOneMillion"];
252.   Serial.println("8 - Case Per One Million: " + String(CountryData[structPosition].casesPerOneMillion));
254.   Serial.println("********************************************************");
255. }
256. void LoadSettingsIntoScreen(int structPosCountryNumber)
257. {
258.   char dataToDisplay[50] = {0x00};
259.   int bufferSize = sprintf(dataToDisplay, "Country: %s", &CountryData[structPosCountryNumber].country[0]);
260.   LCD_PrintStringWithBg(dataToDisplay, bufferSize - 1, FontSize_32, 10, 5, COLOR_WHITE, COLOR_NAVY);
262.   bufferSize = sprintf(dataToDisplay, "Cases: %d", CountryData[structPosCountryNumber].cases);
263.   LCD_PrintStringWithBg(dataToDisplay, bufferSize - 1, FontSize_24, 10, 35, COLOR_WHITE, COLOR_NAVY);
265.   bufferSize = sprintf(dataToDisplay, "Today cases: %d", CountryData[structPosCountryNumber].todayCases);
266.   LCD_PrintStringWithBg(dataToDisplay, bufferSize - 1,  FontSize_24, 210, 35, COLOR_WHITE, COLOR_NAVY);
268.   bufferSize = sprintf(dataToDisplay, "Deaths: %d", CountryData[structPosCountryNumber].deaths);
269.   LCD_PrintStringWithBg(dataToDisplay, bufferSize - 1, FontSize_24, 10, 65, COLOR_WHITE, COLOR_NAVY);
271.   bufferSize = sprintf(dataToDisplay, "Today deaths: %d", CountryData[structPosCountryNumber].todayDeaths);
272.   LCD_PrintStringWithBg(dataToDisplay, bufferSize - 1, FontSize_24, 210, 65, COLOR_WHITE, COLOR_NAVY);
274.   bufferSize = sprintf(dataToDisplay, "Recover: %d", CountryData[structPosCountryNumber].recovered);
275.   LCD_PrintStringWithBg(dataToDisplay, bufferSize - 1, FontSize_24, 10, 95, COLOR_WHITE, COLOR_NAVY);
277.   bufferSize = sprintf(dataToDisplay, "Active: %d", CountryData[structPosCountryNumber].active);
278.   LCD_PrintStringWithBg(dataToDisplay, bufferSize - 1, FontSize_24, 210, 95, COLOR_WHITE, COLOR_NAVY);
280.   bufferSize = sprintf(dataToDisplay, "Critical: %d", CountryData[structPosCountryNumber].critical);
281.   LCD_PrintStringWithBg(dataToDisplay, bufferSize - 1, FontSize_24, 10, 130, COLOR_WHITE, COLOR_NAVY);
282. }
283. //----------------------------------------------------------------------------
284. /* Display Functions */
285. void LCD_PrintStringWithBg(const char * str, const uint16_t len, const enum enum_FontSize fontSize,
286.                            const uint16_t posX, const uint16_t posY, const uint16_t textColor, const uint16_t bgColor) {
288.   uint8_t text[len + 1];
289.   memset(text, 0, sizeof text);
290.   memcpy(text, str, len);
292.   char bufferOut[64];
293.   int bufSize = sprintf(bufferOut, "HZB%d %d %d %d %d %s\n\r", fontSize, posX, posY, textColor, bgColor, str);
294.   Serial2.write((uint8_t *)bufferOut, bufSize);
295.   Serial.write((uint8_t *)bufferOut, bufSize);
296. }
298. void LCD_LoadPicture(const char * path, const uint16_t posX, const uint16_t posY) {
299.   char bufferOut[64];
301.   memset(bufferOut, 0, sizeof bufferOut);
302.   int bufSize = sprintf(bufferOut, "LOAD %d %d %s\n\r", posX, posY, path);
303.   Serial2.write((uint8_t *)bufferOut, bufSize);
304. }
306. int LCD_ClearScreen(uint16_t bgColor) {
307.   if(bgColor > 65535) { return 0; }
309.   char bufferOut[16];
310.   int bufSize = sprintf(bufferOut, "CLS %d\n\r", bgColor);
311.   Serial2.write((uint8_t *)bufferOut, bufSize);
312.   return bufSize;
313. }

Poniżej zdjęcie ekranu głównego po załadowaniu danych:

Po podłączeniu do sieci WIFI urządzenie czeka na pobranie wszystkich informacji. Domyślnie pierwszym wyświetlanym krajem jest Polska.

Gdy nastąpi przytrzymanie palca na ekranie to po chwili zostaną załadowane dane z wartościami z następnego kraju. Po zdefiniowanym interwale czasowym następuje ponowne pobranie danych. Po aktualizacji ekran główny wyświetli informację z Polski.