środa, 1 kwietnia 2020

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

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

Znalezione obrazy dla zapytania arduino esp32
[Ź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.
Autor: o
Etykiety: