Covid-19 Data Monitor

2022-01-11 | By M5Stack

License: General Public License Programmers Arduino

* Thanks for the source code and project information provided by @Hans-Günther Nusseck

Software apps and online services

Story

Time-series data of confirmed infections and deaths during the Covid-19 pandemic strongly illustrate the seriousness of the situation.

Many websites or smartphone apps are available to view and compare this data. Interfaces and APIs to current data sets are also available, which makes it possible to evaluate and display the data by yourself.

I was interested in comparing the data of certain countries directly in one graph. So, I wrote software to load and display the data of 5 countries as combined graphs on a M5Stack.

graph output example

Source of data

Rodrigo Pombo (pomber) provides a JSON file on github in which the current data by country is summarized on a daily basis.

https://github.com/pomber/covid19

The software on the M5Stack establishes a secure connection to the github website and loads the JSON file. Since the file is very large, it cannot be stored on the M5Stack and processed with a JSON library. So I implemented a small parser which analyzes the data during loading and extracts only the needed data.

Note:

Up to 22.03 “recovered” data was still provided. However, since these data are not reliable enough to be meaningful, only data for “confirmed” and “death” cases are available from 22.03.2020. Therefore, I only display "confirmed" and "deaths".

WiFi connection

Since I want to use the M5Stack at different locations, I created an array with the different WiFi access data:

Copy Code

// WiFi network configuration:
// A simple method to configure multiple WiFi Access Configurations:
// Add the SSID and the password to the list.
// IMPORTANT: keep both arrays with the same length!
String WIFI_ssid[] = {"Home_ssid", "Work_ssid", "Mobile_ssid", "Best-Friend_ssid"};
String WIFI_password[] = {"Home_pwd", "Work_pwd", "Mobile_pwd", "Best-Friend_pwd"};

With this method I can use the M5Stack at home, at work or at my best friends flat without having to recompile the code. As many entries as desired can be made. The routine for establishing the connection goes through the list until a connection could be established:

Copy Code

// connect to WIFI
// Try all access configurations until a connection could be established.
int WIFI_location = 0;
while(WiFi.status() != WL_CONNECTED){
  delay(1000);
  connect_Wifi(WIFI_ssid[WIFI_location].c_str(), WIFI_password[WIFI_location].c_str());
  WIFI_location++;
  if(WIFI_location >= (sizeof(WIFI_ssid)/sizeof(WIFI_ssid[0])))
    WIFI_location = 0;
}
M5.Lcd.println("");
M5.Lcd.println("[OK] Connected to WiFi");

Secure connection

For the secure connection (https) the certificate for the server is required. This can be downloaded via a browser. Depending on the browser type, it may look a little different, but the certificate can always be accessed via the symbol next to the link:

open the certificate

In the Chrome browser, the certificate can be easily exported into a text file:

export a certificate in Chrome browser

Now the certificate can be included in the code as a string and the connection to the server can then be established as follows:

Copy Code

// set the certificate
client.setCACert(root_ca);
// connect to the server
M5.Lcd.println("Starting connection...");
if (!client.connect(data_server_name, 443))
  M5.Lcd.println("[ERR] Connection failed!");
else {
  // Make a HTTP request:
  client.println("GET https://pomber.github.io/covid19/timeseries.json HTTP/1.0");
  client.println("Host: pomber.github.io");
  client.println("Connection: close");
  client.println();
  //... do something here ...//
  client.stop();
}

Parsing the data

When the connection to the server is established, the JSON file can be fetched. The header data should be skipped and the JSON data can be read and evaluated line by line:

Copy Code

// skip the header data
while (client.connected()) {
  rcv_line = client.readStringUntil('\n').c_str();
  if (rcv_line == "\r") {
    M5.Lcd.println("[OK] header received");
    break;
  }
}

The JSON file has the following structure:

Copy Code

{
  ...
  "Germany": [
    {
      "date": "2020-1-22",
      "confirmed": 0,
      "deaths": 0,
      "recovered": 0
    },
    ...
  ],
  ...
}

For data evaluation 5 countries can be configured:

Copy Code

String country_names[6] = {"All countries", "China", "Germany", "US", "Italy", "Spain"};

The parser searches line by line for the country names and stores the data in an array until the country section is ended.

Data display

The graphic display is kept simple and straight forward. Only displaying the values as right-aligned text with a thousand separator was challenging. A special function is used to return the corresponding text for a given integer value:

Copy Code

const char *formatNumber(int value, char *buffer, int len);

The thousand separator can be adjusted. In Europe, we use a dot as thousand separator, but we also have the metric system ;-)

Copy Code

char thousand_separator = '.';
char buffer[11]; // 10 char + \0 = 11
M5.Lcd.printf("%s\n", formatNumber(1234567, format_buffer, sizeof(buffer)));
// output: " 1.234.567"

The buttons on the M5Stack can be used to switch between different views in order to display the data graphically or as text.

Update #1

Version v1.6 is loading the data of 30 countries first. Then, a set of five countries out of the list of 30 countries can be displayed.

M5Stack Covid-19 Monitor in action

Also, a "shifted" graph was added. In the "shifted" graphs, the curves of each country are superimposed from the respective occurrence of confirmed cases. This makes it easier to see the differences in trends between countries.

Update #2

The version v1.7 contains some interesting new features: First, the display is automatically dimmed after 20 seconds. As soon as you press a button, it gets brighter again. Additionally, the curve for "All countries" can now also be displayed. The main change, however, is that a statistic for Europe is added. A list of all countries in Europe is included in the source code for this purpose. Then the process_data() function adds up the values for all European countries.

This analysis is interesting to be able to compare the pandemic in the US with Europe. The USA has a population of about 330 million people. Europe has a population slightly more than twice as large. From this aspect a comparison of the infection and death rates is very interesting:

Analysis of data from Europe

Update #3

The new version v1.09 includes the possibility to save screenshots on an SD card. For this purpose, a formatted SD card must be inserted at startup. If you press and hold the left or right button for more than 2 seconds, a screenshot of the current image will be saved to the SD card.

The images are saved in .ppm format. Many graphics programs can open .ppm files directly. But there are also numerous online converters. A simple internet search will quickly find the appropriate links.

The converted screenshots look like this:

1/10.Screenshot of the graphical output

2/10.Screenshot of the graphical output

3/10.Screenshot of the graphical output

4/10.Screenshot of the graphical output

5/10.Screenshot of the graphical output

6/10.Screenshot of the graphical output

7/10.Screenshot of the graphical output

8/10.Screenshot of the graphical output

9/10.Screenshot of the graphical output

10/10.Screenshot of the graphical output

Feedback

I hope this application and the code can prove to be useful to the wider community.

Code

main.cppC/C++

Copy Code

/**************************************************************************
 * Covid-19 Data Monitor
 * 
 * Code to graphically display the current data of the Covid-19 pandemic
 * on a M5Stack (ESP32 MCU with integrated LCD)
 * 
 * Hague Nusseck @ electricidea
 * v1.09 03.October.2020
 * https://github.com/electricidea/M5Stack-Covid19-Monitor
 * 
 * Changelog:
 * v1.03 = - first published version
 * v1.04 = - Bugfix Screen height in graph routine
 *         - Changed color order
 * v1.05 = - Store data of multiple countries (30)
 *         - Load data after WiFi connection
 *         - Included weekly grid lines in graph
 *         - The entries are now editable
 *         - Bugfix scaling x-axis in Graph
 * v1.06 = - Added shifted graph analysis
 * v1.07 = - Added Europe analysis
 *         - add graph for "All Countries"
 *         - Auto Display dimming function
 *         - changed shifted threshold to 4000 (confirmed) and 500 (deaths)
 * v1.08 = - aded screen capture onto SD card
 * v1.09 = - aded smaller demo file to https://electricidea.github.io/
 *         - Option to load real data or short test data (36kB)
 *         - screen capute is let or right button is pressed for 2 seconds
 * 
 * Distributed as-is; no warranty is given.
**************************************************************************/

#include <Arduino.h>

#include <Preferences.h>
Preferences preferences;
String pref_fields[] = {"country_1", "country_2", "country_3", "country_4", "country_5"};
 
#include <M5Stack.h>
// install the library:
// pio lib install "M5Stack"

// Free Fonts for nice looking fonts on the screen
#include "Free_Fonts.h"

#include "WiFi.h"
#include <WiFiClientSecure.h>
// Init the Secure client object
WiFiClientSecure client;

// Stuff for the Graphical output
// The M5Stack screen pixel is 320x240, with the top left corner of the screen as the origin (0,0)
#define SCREEN_WIDTH 319
#define SCREEN_HEIGHT 239

// overall maximum to calculate the percentage of processing
#define max_number_countries 200
// country sekection array
// The names must match with the country names inside the JSON file
// 5 countries can be displayed at the same time
// The first one should always be index 0 = "All countries"
int country_selection[6]; 
// colors for the countries
const uint32_t country_color[6] = {LIGHTGREY, RED, GREEN, WHITE, MAGENTA, 0x51D};

// A String array to hold a set of country names
// Rules:
// The first entry is always for "All countries"
// The second entry is always for "Europe"
// The names must match with the country names inside the JSON file
#define n_countries 31
String country_names[n_countries] = {"All countries", "Europe", "Australia", "Austria", "Brazil", "Canada", "China", 
                      "Croatia", "Finland", "France", "Germany", "Greece", "Iran", "Italy", "Japan", "Korea, South", 
                      "Mexico", "Netherlands", "Norway", "Poland", "Portugal", "Romania", "Russia", 
                      "Spain", "Sweden", "Switzerland", "Taiwan", "Turkey", "United Kingdom", "US", "Vietnam"};

// A String array to hold a the names of country that are part of Europe
#define n_europe_countries 44               
String europe_names[n_europe_countries] = {"Albania", "Andorra", "Austria", "Belarus", "Belgium", "Bulgaria", 
                      "Bosnia and Herzegovina", "Czechia", "Croatia", "Denmark", "Estonia", "Finland", "France", "Germany", 
                      "Georgia", "Greece", "Hungary", "Ireland", "Iceland", "Italy", "Kazakhstan", "Kosovo", "Latvia", 
                      "Liechtenstein", "Lithuania", "Luxembourg", "Malta", "Moldova", "Monaco", "Montenegro", 
                      "Netherlands", "North Macedonia", "Norway", "Poland", "Portugal", "Romania", "San Marino", 
                      "Spain", "Sweden", "Switzerland", "Turkey", "Ukraine", "United Kingdom", "Vatican City"};
bool part_of_europe = false;

// Array field for the collected data out of the JSON file
// collected_data[confirmed, deaths][country][data point]
// the array is filled with data from all countries out of
// the country_names list
int collected_data[2][n_countries][SCREEN_WIDTH]; 
String data_name[] = {"confirmed", "deaths"};
// array to count the found data for each country
int data_count[n_countries];
// String to hold the last date found in the JSON file
std::string last_date = "";
// variable to switch between the graphical views
//  0 = no graphical display
// >0 = graphical and text display
int display_state = 0;
// varaible to switch between the menu states
int menu_state = 0;
// Index if a Country name field should be edited
int field_edit_index = 0;

// buffer for formatting numbers with thousand separator
// see function description for further  details
char format_buffer[11];
char thousand_separator = '.';

// timer to dimm the display
unsigned long display_dimm_millis;
bool brightness_high = true;

// Filename for Screendump to SD Card
char Filename[24];

// WiFi network configuration:
// A simple method to configure multiple WiFi Access Configurations:
// Add the SSID and the password to the list.
// IMPORTANT: keep both arrays with the same length!
String WIFI_ssid[]     = {"Home_ssid", "Work_ssid", "Mobile_ssid", "Best-Friend_ssid"};
String WIFI_password[] = {"Home_pwd",  "Work_pwd",  "Mobile_pwd",  "Best-Friend_pwd"};

// uncomment this line to work with small test data (36kB)
// instead of the large real live data
//#define TEST_DATA
// the actual data are provided on this github page:
// https://github.com/pomber/covid19
// JSON time-series of coronavirus cases (confirmed, deaths and recovered) per country
// https://pomber.github.io/covid19/timeseries.json

#if defined(TEST_DATA)
  // small partial example JSON file from January 2020:
  // https://electricidea.github.io/M5Stack-Covid19-Monitor/20200128_timeseries.json
  const char*  data_server_name= "electricidea.github.io";  // Server URL
#else
  const char*  data_server_name= "pomber.github.io";  // Server URL
#endif

// Certificate for Website:
// https://github.io
const char* root_ca= \
"-----BEGIN CERTIFICATE-----\n" \
"MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs\n" \
"MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\n" \
"d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j\n" \
"ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL\n" \
"MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3\n" \
"LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug\n" \
"RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm\n" \
"+9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW\n" \
"PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM\n" \
"xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB\n" \
"Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3\n" \
"hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg\n" \
"EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF\n" \
"MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA\n" \
"FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec\n" \
"nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z\n" \
"eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF\n" \
"hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2\n" \
"Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe\n" \
"vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep\n" \
"+OkuE6N36B9K\n" \
"-----END CERTIFICATE-----\n";



//==============================================================
// function forward declaration
void scan_WIFI();
boolean connect_Wifi(const char * ssid, const char * password);
const char *formatNumber(int value, char *buffer, int len);
void ReplaceStringInPlace(std::string& subject, const std::string& search,
                          const std::string& replace);
void Clear_Screen();
int process_data();
void display_data_graph(int data_select);
void display_data_graph_shifted(int data_select);
void display_data_text(int data_select);
void print_list(int highlighted);
void print_menu(int menu_index);
void set_display_brightness(int brightness);
bool M5Screen2File(fs::FS &fs, const char * path);


void setup() {
    // initialize the M5Stack object
    M5.begin();
    // configure the Lcd display
    set_display_brightness(100); //Brightness (0: Off - 255: Full)
    M5.Lcd.setTextColor(WHITE);
    M5.Lcd.setTextSize(1);
    Clear_Screen();
    // configure centered String output
    M5.Lcd.setTextDatum(CC_DATUM);
    M5.Lcd.setFreeFont(FF2);
    M5.Lcd.drawString("Covid-19 Monitor", (int)(M5.Lcd.width()/2), (int)(M5.Lcd.height()/2), 1);
    M5.Lcd.setFreeFont(FF1);
    M5.Lcd.drawString("Version 1.09 | 03.10.2020", (int)(M5.Lcd.width()/2), M5.Lcd.height()-20, 1);
    // print Welcome screen over Serial connection
    // wait 5 seconds before start file action
    delay(5000);
    // configure Top-Left oriented String output
    M5.Lcd.setTextDatum(TL_DATUM);
    // scan and display available WIFI networks
    Clear_Screen();
    // ???
    if(WiFi.status() != WL_CONNECTED){
      scan_WIFI();
      delay(1000);
      // connect to WIFI
      // Try all access configurations until a connection could be established.
      int WIFI_location = 0;
      while(WiFi.status() != WL_CONNECTED){
        delay(1000);
        Clear_Screen();
        connect_Wifi(WIFI_ssid[WIFI_location].c_str(), WIFI_password[WIFI_location].c_str());
        WIFI_location++;
        if(WIFI_location >= (sizeof(WIFI_ssid)/sizeof(WIFI_ssid[0])))
          WIFI_location = 0;
      }
      M5.Lcd.println("");
      M5.Lcd.println("[OK] Connected to WiFi");
    }
    delay(2000);
    // init the array for "All Countries" and "Europe"#
    for(int i=0; i<SCREEN_WIDTH; i++){
      collected_data[0][0][i] = 0; 
      collected_data[1][0][i] = 0; 
      collected_data[0][1][i] = 0; 
      collected_data[1][1][i] = 0; 
    }
    // Download and parse the JSON data file
    Clear_Screen();
    // set the certificate for the https connection to github.io
    M5.Lcd.println("[OK] set certificate");
    client.setCACert(root_ca);
    // connect to the server
    M5.Lcd.println("Starting connection...");
    if (!client.connect(data_server_name, 443)){
      M5.Lcd.println("[ERR] Connection failed!");
      while(true)
        delay(100);
    } else {
      M5.Lcd.println("[OK] Connected to server");
      delay(200);
      // Make a HTTP request:
      #if defined(TEST_DATA)
        client.println("GET https://electricidea.github.io/M5Stack-Covid19-Monitor/20200128_timeseries.json HTTP/1.0");
        client.println("Host: electricidea.github.io");
      #else
        client.println("GET https://pomber.github.io/covid19/timeseries.json HTTP/1.0");
        client.println("Host: pomber.github.io");
      #endif
      client.println("Connection: close");
      client.println();
      // get the JSON data from the github server
      // and calculate the values
      process_data();
      // close the connection to the server
      client.stop();
      M5.Lcd.println("[DONE]");
      delay(2000);
    }
    // get the list of countries to be shown
    // the values are stored in the FLASH
    preferences.begin("country-config", false);
    country_selection[0] = 0; // Always "All countries"
    char Key_String[12];
    for(int n=1; n<6; n++){
      pref_fields[n].toCharArray(Key_String, sizeof(Key_String));
      country_selection[n] = preferences.getUInt(Key_String,n);
    }
    // close the preferences
    preferences.end();
    // ready to edit the list or visualize the data
    // print the start Menu
    field_edit_index = 0;
    print_list(field_edit_index);
    display_state = 0;
    menu_state = 1;
    print_menu(menu_state);
    // dimm the display after 20 seconds
    display_dimm_millis = millis() + 20000;
}


void loop() {
  M5.update();  
  // dimm the display if no button was pressed
  if(brightness_high && millis() > display_dimm_millis){
    M5.Lcd.setBrightness(20); //Brightness (0: Off - 255: Full)
    brightness_high = false;
  }

  // if the left or right Button was pressed for 2 seconds,
  // a screen capture is saved to SD card
  if ((M5.BtnA.pressedFor(2000) || M5.BtnC.pressedFor(2000)) && Filename[0] == '/'){
    if(M5Screen2File(SD, Filename)){
      M5.Lcd.setTextColor(WHITE);
      M5.Lcd.setTextSize(1);
      Clear_Screen();
      // configure centered String output
      M5.Lcd.setTextDatum(CC_DATUM);
      M5.Lcd.setFreeFont(FF2);
      M5.Lcd.drawString("Screenshot saved", (int)(M5.Lcd.width()/2), (int)(M5.Lcd.height()/2), 1);
      M5.Lcd.setFreeFont(FF1);
      M5.Lcd.drawString(Filename, (int)(M5.Lcd.width()/2), M5.Lcd.height()-60, 1);
    } else {
      M5.Lcd.setTextColor(WHITE);
      M5.Lcd.setTextSize(1);
      Clear_Screen();
      // configure centered String output
      M5.Lcd.setTextDatum(CC_DATUM);
      M5.Lcd.setFreeFont(FF1);
      M5.Lcd.drawString("Unable to save Screenshot", (int)(M5.Lcd.width()/2), (int)(M5.Lcd.height()/2), 1);
    }
    // To prevent another screen dump if the Button is still hold down
    // next screendump only if a Filename is set
    Filename[0] = ' ';
  }
  
  // left Button
  if (M5.BtnA.wasPressed()){
    if(!brightness_high){
      set_display_brightness(100);
    } else {
      display_dimm_millis = millis() + 20000;
      switch (menu_state) {
        case 1: {   // EDIT 
          menu_state = 2;
          field_edit_index = 1;
          print_list(field_edit_index);
          print_menu(menu_state);
          break;       
        }
        case 2: {   //  NEXT
          if(++field_edit_index > 5)
              field_edit_index = 1;
          print_list(field_edit_index);
          print_menu(menu_state);
          break;       
        }
        case 3: {   //  < (Country name selection)
          if(--country_selection[field_edit_index] < 0)
            country_selection[field_edit_index] = n_countries-1;
          print_list(field_edit_index);
          print_menu(menu_state);
          break;       
        }
        case 4: {   // Prev Page
          display_state--;
          if(display_state < 1)
            display_state = 10;  
          if(display_state < 3)
            display_data_graph(display_state);
          else{
            if(display_state < 5)
              display_data_graph_shifted(display_state);
            else
              display_data_text(display_state);
          }
          break;       
        }
      } 
    }
  }

  // center Button
  if (M5.BtnB.wasPressed()){
    if(!brightness_high){
      set_display_brightness(100);
    } else {
      display_dimm_millis = millis() + 20000;
      switch (menu_state) {
        case 1: {   //  
        
          break;       
        }
        case 2: {   //  EDIT
          menu_state = 3;
          print_list(field_edit_index);
          print_menu(menu_state);
          break;       
        }
        case 3: {   //  OK
          menu_state = 2;
          char Key_String[12];
          pref_fields[field_edit_index].toCharArray(Key_String, sizeof(Key_String));
          // save selection
          preferences.begin("country-config", false);
          preferences.putUInt(Key_String, country_selection[field_edit_index]);
          preferences.end();
          print_list(field_edit_index);
          print_menu(menu_state);
          break;       
        }
        case 4: {   // Back 
          // print the start Menu
          display_state = 0;
          menu_state = 1;
          print_list(0);
          print_menu(menu_state);
          break;       
        }
      }
    }
  }

  // right Button
  if (M5.BtnC.wasPressed()){
    if(!brightness_high){
      set_display_brightness(100);
    } else {
      display_dimm_millis = millis() + 20000;
      switch (menu_state) {
        case 1: {   // SHOW 
          menu_state = 4;
          display_state = 1; 
          display_data_graph(display_state);
          break;       
        }
        case 2: {   // Done 
          // print the start Menu
          field_edit_index = 0;
          display_state = 0;
          menu_state = 1;
          print_list(0);
          print_menu(menu_state);
          break;       
        }
        case 3: {   //  > (Country name selection)
          if(++country_selection[field_edit_index] == n_countries)
            country_selection[field_edit_index] = 0;
          print_list(field_edit_index);
          print_menu(menu_state);
          break;       
        }
        case 4: {   // Next Page 
          display_state++;
          if(display_state > 10)
            display_state = 1;  
          if(display_state < 3)
            display_data_graph(display_state);
          else{
            if(display_state < 5)
              display_data_graph_shifted(display_state);
            else
              display_data_text(display_state);
          }
          break;       
        }
      }
    }
  }
}


//==============================================================
// Print the list of countries that are selected to show.
void print_list(int highlighted){
  Clear_Screen();
  // center aligned String output
  M5.Lcd.setTextDatum(CC_DATUM);
  M5.Lcd.setFreeFont(FF2);
  M5.Lcd.drawString("Covid-19 Monitor", (int)(M5.Lcd.width()/2), (int)(M5.Lcd.height()/6), 1);
  M5.Lcd.setFreeFont(FF1);
  // Country names
  int y_pos = (int)(M5.Lcd.height()/6)+50;
  for(int n=1; n<6; n++){
    M5.Lcd.setTextColor(country_color[n]);
    // highlight a line if selected
    if(highlighted == n){
      M5.Lcd.fillRect(0, y_pos-10, M5.Lcd.width(), 22, 0x528A);
    }
    M5.Lcd.drawString(country_names[country_selection[n]].c_str(), (int)(M5.Lcd.width()/2), y_pos, 1);
    y_pos = y_pos + 20;
  }
  // left aligned String output
  M5.Lcd.setTextDatum(TL_DATUM);
  M5.Lcd.setTextColor(WHITE);
}

//==============================================================
// Print a small menu at the bottom of the display above the buttons
void print_menu(int menu_index){
    M5.Lcd.fillRect(0, M5.Lcd.height()-25, M5.Lcd.width(), 25, 0x7BEF);
    M5.Lcd.setCursor(0, 230);    
    M5.Lcd.setFreeFont(FF1);
    M5.Lcd.setTextColor(WHITE);
    switch (menu_index) {
      case 0: { // never used 
        M5.Lcd.print("      -       -        - ");
        break;       
      }
      case 1: { // start menu
        M5.Lcd.print("    EDIT             SHOW");
        break;
      }
      case 2: { // Edit submenu for line selection
        M5.Lcd.print("    NEXT    EDIT     DONE ");
        break;
      }
      case 3: { // submenu for changing the country  
        M5.Lcd.print("      <       OK       > ");
        break;
      }
      case 4: { // menu for display the data 
        M5.Lcd.print("      <      BACK      > ");
        break;
      }
      default: { // should never been called
        M5.Lcd.print("      -       -        - ");
        break;
      }
    }
}


//==============================================================
// function to set the brightness and the dimming timer
void set_display_brightness(int brightness){
  M5.Lcd.setBrightness(brightness); //Brightness (0: Off - 255: Full)
  display_dimm_millis = millis() + 20000;
  brightness_high = true;
  // Delay as helping function to detect a single key press of the butons
  delay(500);
}

//==============================================================
// Scan for available Wifi networks
// print result als simple list
void scan_WIFI() {
      M5.Lcd.println("WiFi scan ...");
      // WiFi.scanNetworks returns the number of networks found
      int n = WiFi.scanNetworks();
      if (n == 0) {
          M5.Lcd.println("[ERR] no networks found");
      } else {
          //M5.Lcd.println("[OK] %i networks found:\n",n);
          for (int i = 0; i < n; ++i) {
              // Print SSID for each network found
              M5.Lcd.printf("  %i: ",i+1);
              M5.Lcd.println(WiFi.SSID(i));
              delay(10);
          }
      }
}

//==============================================================
// establish the connection to an Wifi Access point
boolean connect_Wifi(const char * ssid, const char * password){
  // Establish connection to the specified network until success.
  // Important to disconnect in case that there is a valid connection
  WiFi.disconnect();
  M5.Lcd.println("Connecting to ");
  M5.Lcd.println(ssid);
  delay(500);
  //Start connecting (done by the ESP in the background)
  WiFi.begin(ssid, password);
  // read wifi Status
  wl_status_t wifi_Status = WiFi.status();  
  int n_trials = 0;
  // loop while waiting for Wifi connection
  // run only for 5 trials.
  while (wifi_Status != WL_CONNECTED && n_trials < 5) {
    // Check periodicaly the connection status using WiFi.status()
    // Keep checking until ESP has successfuly connected
    // or maximum number of trials is reached
    wifi_Status = WiFi.status();
    n_trials++;
    switch(wifi_Status){
      case WL_NO_SSID_AVAIL:
          M5.Lcd.println("[ERR] SSID not available");
          break;
      case WL_CONNECT_FAILED:
          M5.Lcd.println("[ERR] Connection failed");
          break;
      case WL_CONNECTION_LOST:
          M5.Lcd.println("[ERR] Connection lost");
          break;
      case WL_DISCONNECTED:
          M5.Lcd.println("[ERR] WiFi disconnected");
          break;
      case WL_IDLE_STATUS:
          M5.Lcd.println("[ERR] WiFi idle status");
          break;
      case WL_SCAN_COMPLETED:
          M5.Lcd.println("[OK] WiFi scan completed");
          break;
      case WL_CONNECTED:
          M5.Lcd.println("[OK] WiFi connected");
          break;
      default:
          M5.Lcd.println("[ERR] unknown Status");
          break;
    }
    delay(500);
  }
  if(wifi_Status == WL_CONNECTED){
    // connected
    M5.Lcd.print("IP address: ");
    M5.Lcd.println(WiFi.localIP());
    return true;
  } else {
    // not connected
    M5.Lcd.println("");
    M5.Lcd.println("[ERR] unable to connect Wifi");
    return false;
  }
}


//==============================================================
// Function to format a integer number into a string 
// with thousand separator and a fixed length
// useful to get a nice right aligned string output
// inspired from:
// https://stackoverflow.com/questions/1449805/how-to-format-a-number-from-1123456789-to-1-123-456-789-in-c
// Use as following:
//
// char buffer[11]; // 10 char + \0 = 11
// M5.Lcd.printf("%s\n", formatNumber(1234567, format_buffer, sizeof(buffer)));
// output: " 1.234.567"
const char *formatNumber (int value, char *buffer, int len) {
    int charCount;
    char *endOfbuffer = buffer+len;
    int savedValue = value;
    if (value < 0)
        value = - value;
    // \0 Termination char at the end
    *--endOfbuffer = 0;
    charCount = -1;
    do{
        if (++charCount == 3){
            charCount = 0;
            *--endOfbuffer = thousand_separator;
            if(endOfbuffer <= buffer)
              break;
        }
        *--endOfbuffer = (char) (value % 10 + '0');
    } while ((value /= 10) != 0 && endOfbuffer > buffer);
    // add a minus sign if the original value was negative
    if (savedValue < 0 && endOfbuffer > buffer)
        *--endOfbuffer = '-';
    // fill up with spaces, to the full string length
    while(endOfbuffer > buffer){
      *--endOfbuffer = ' ';
    }
    return endOfbuffer;
}

//==============================================================
// A String-Replace function...
// from:
// https://stackoverflow.com/questions/5878775/how-to-find-and-replace-string
void ReplaceStringInPlace(std::string& subject, const std::string& search,
                          const std::string& replace) {
    size_t pos = 0;
    while ((pos = subject.find(search, pos)) != std::string::npos) {
         subject.replace(pos, search.length(), replace);
         pos += replace.length();
    }
}

//==============================================================
// Clear the entire screen and add one row
// The added row is important. Otherwise the first row is not visible
void Clear_Screen(){
  M5.Lcd.fillScreen(BLACK);
  M5.Lcd.setCursor(0, 0);
  M5.Lcd.println("");
}

//==============================================================
// receive the JSON file from the server
// go through the file line by line
// search for keywords and sum the values
int process_data(){
  // Number of lines received from the server and processed
  int line_count = 0;
  // total number of countries found in the JSON file
  int countries_found = 0;
  for(int n=0; n<6; n++)
    data_count[n] = 0;
  // strings to hold the received data
  std::string rcv_line = "";
  std::string analyze_line = "";
  // skip the header data
  while (client.connected()) {
    rcv_line = client.readStringUntil('\n').c_str();
    if (rcv_line == "\r") {
      M5.Lcd.println("[OK] header received");
      break;
    }
  }
  // Index of a found country section
  // Country_index = 0 --> looking for a configured countrie
  // Country_index > 0 --> country found. collecting data
  int Country_index = 0;

  // Basic format information from the JSOM data:
  // Country START string:
  // "  \"Germany\": [\n"
  // Country END string:
  // "  ],\n" or "  ]\n"
  // value strings:
  // "      \"confirmed\": 0,\n"
  // "      \"deaths\": 0,\n"
  // "      \"recovered\": 0\n"
  
  // if there are incoming bytes available
  while (client.available()) {
    // get one line from the server data
    rcv_line = client.readStringUntil('\n').c_str();

    // looking for the "country seperator"
    // only to display the percentage on the screen
    if (rcv_line.find(": [", 0)  != std::string::npos){ 
      // count the overall number of countries
      countries_found++;
      // the data from all countries should summed up
      data_count[0] = 0;
      // print the percentage of processing
      Clear_Screen();
      M5.Lcd.setTextDatum(CC_DATUM);
      M5.Lcd.setFreeFont(FF3);
      char text_buffer[32];
      snprintf(text_buffer, sizeof(text_buffer), "%3.0f%%",
              (100.0/max_number_countries)*countries_found);
      M5.Lcd.drawString(text_buffer, (int)(M5.Lcd.width()/2), (int)(M5.Lcd.height()/2), 1);
    }
    // count the number of confirmed, deaths and recovered over all countries
    // looking for a "confirmed" data line
    if (rcv_line.find("confirmed", 0)  != std::string::npos){
      analyze_line = rcv_line;
      // delete everything out of the string exept the number
      ReplaceStringInPlace(analyze_line, "      \"confirmed\": ", "");
      ReplaceStringInPlace(analyze_line, ",", "");
      ReplaceStringInPlace(analyze_line, "\n", "");
      int value = atoi(analyze_line.c_str());
      // add the value to the "All countries" Array
      collected_data[0][0][data_count[0]] = collected_data[0][0][data_count[0]] + value;
      // if we are inside an configure country section, set the value inside the Array
      if(Country_index > 0){
        collected_data[0][Country_index][data_count[Country_index]] = value;
      }
      // if country is part of europe, add the value
      if(part_of_europe){
        collected_data[0][1][data_count[1]] = collected_data[0][1][data_count[1]] + value;
      }
    }
    // looking for a "deaths" data line
    if (rcv_line.find("deaths", 0)  != std::string::npos){
      analyze_line = rcv_line;
      // delete everything out of the string exept the number
      ReplaceStringInPlace(analyze_line, "      \"deaths\": ", "");
      ReplaceStringInPlace(analyze_line, ",", "");
      ReplaceStringInPlace(analyze_line, "\n", "");
      int value = atoi(analyze_line.c_str());
      // add the value to the "All countries" Array
      collected_data[1][0][data_count[0]] = collected_data[1][0][data_count[0]] + value;
      data_count[0]++;
      // Array can contain maximum SCREEN_WIDTH datapoints
      if(data_count[0] >= SCREEN_WIDTH)
        data_count[0] = 0;
      // if we are inside an configure country section
      if(Country_index > 0){
        collected_data[1][Country_index][data_count[Country_index]] = value;
        data_count[Country_index]++;
        if(data_count[Country_index] >= SCREEN_WIDTH)
          data_count[Country_index] = 0;
      }
      // if country is part of europe, add the value to the Europe Array
      if(part_of_europe){
        collected_data[1][1][data_count[1]] = collected_data[1][1][data_count[1]] + value;
        data_count[1]++;
        if(data_count[1] >= SCREEN_WIDTH){
          data_count[1] = 0;}
      }
    }
    // store the last "date" line to get the last actualization date
    // looking for a "date" data line
    if (rcv_line.find("date", 0)  != std::string::npos){
      last_date = rcv_line;
    }
    // if outside an country section
    if(Country_index == 0) {
      // check if country is part of the country list
      for(int n=2; n<n_countries; n++){
        if (rcv_line.find(country_names[n].c_str(), 0)  != std::string::npos){
          Country_index = n;
          // reset the data point counter so that it starts always
          // with the first day
          data_count[0] = 0;
        }
      }
      // check for country as part of europe
      for(int n=1; n<n_europe_countries; n++){
        if (rcv_line.find(europe_names[n].c_str(), 0)  != std::string::npos){
          part_of_europe = true;
          data_count[1] = 0;
        }
      }
    }
    if(Country_index > 0 || part_of_europe) {
      // otherwise check for END of country-section
      if (rcv_line.find("]", 0)  != std::string::npos){
        Country_index = 0;
        part_of_europe = false;
      }
    }
    line_count++;
    // Sometimes, we need to wait for new data from the server
    // to not exit the loop before all data are received
    // Last data line is "}"
    for(int n=0; n<10; n++){
      if (!client.available() && rcv_line != "}"){
        delay(550);
      }
    }
  }
  // delete everything out of the last_date string exept the date
  ReplaceStringInPlace(last_date, "      \"date\": \"", "");
  ReplaceStringInPlace(last_date, "\",", "");
  ReplaceStringInPlace(last_date, "\n", "");
  return line_count;
}

//==============================================================
// display the data as curves / graphs including a legend
void display_data_graph(int data_select){
  print_menu(4);
  delay(200);
  M5.Lcd.fillScreen(BLACK);
  int selected_country;
  // get maximum value to scale the y-axis
  int max_y = 0;
  for(int n=1; n<6; n++){
    selected_country = country_selection[n];
    for(int i = 0; i < data_count[selected_country]; i++){
      if(collected_data[data_select-1][selected_country][i] > max_y)
        max_y = collected_data[data_select-1][selected_country][i];
    }
  }
  // draw weekly grid lines
  // start from the end and go backwards
  int xpos = data_count[country_selection[1]]-7;
  float x_scale = float(SCREEN_WIDTH) / data_count[1];
  while(xpos > 0){
    M5.Lcd.drawLine(trunc(x_scale*xpos), 0, trunc(x_scale*xpos), (SCREEN_HEIGHT-1), 0x528A);
    xpos = xpos -7;
  }
  // draw line graph
  for(int n=1; n<6; n++){
    selected_country = country_selection[n];
    x_scale = float(SCREEN_WIDTH) / data_count[selected_country];
    for(int i = 1; i < data_count[selected_country]; i++){
      M5.Lcd.drawLine(trunc(x_scale*(i-1)), 
                      (SCREEN_HEIGHT-1)-(round((float((SCREEN_HEIGHT-1)) / max_y) * collected_data[data_select-1][selected_country][i-1])), 
                      trunc(x_scale*i), 
                      (SCREEN_HEIGHT-1)-(round((float((SCREEN_HEIGHT-1)) / max_y) * collected_data[data_select-1][selected_country][i])), 
                      country_color[n]);
    }
  }
  // draw legend
  M5.Lcd.setFreeFont(FF1);
  M5.Lcd.setCursor(0, 0);
  // headline
  M5.Lcd.printf("\n%s (%s)\n\n", data_name[data_select-1], last_date.c_str());
  // Country name and value
  for(int n=1; n<6; n++){
    selected_country = country_selection[n];
    M5.Lcd.setTextColor(country_color[n]);
    M5.Lcd.printf("%s:\n%s\n", country_names[selected_country].c_str(), 
                               formatNumber(collected_data[data_select-1][selected_country][data_count[selected_country]-1], 
                                            format_buffer, 
                                            sizeof(format_buffer)));
  }
  M5.Lcd.setTextColor(WHITE);
  // Filename for Screen-dump to SD Card
  snprintf(Filename, sizeof(Filename), "/graph_%i.ppm",data_select);
}

//==============================================================
// display the data as curves shifted in x so that all countries
// aligned with the first increase of data
void display_data_graph_shifted(int data_select){
  print_menu(4);
  delay(200);
  M5.Lcd.fillScreen(BLACK);
  int selected_country;
  // get maximum value to scale the y-axis
  int max_y = 0;
  for(int n=1; n<6; n++){
    selected_country = country_selection[n];
    for(int i = 0; i < data_count[selected_country]; i++){
      if(collected_data[data_select-3][selected_country][i] > max_y)
        max_y = collected_data[data_select-3][selected_country][i];
    }
  }
  // draw weekly grid lines
  // start from the left and go forward
  int xpos = 0;
  float x_scale = float(SCREEN_WIDTH) / data_count[1];
  while(xpos < data_count[country_selection[1]]){
    M5.Lcd.drawLine(trunc(x_scale*xpos), 0, trunc(x_scale*xpos), (SCREEN_HEIGHT-1), 0x528A);
    xpos = xpos +7;
  }
  // find the x position of first grow of data for each country
  // threshold is a value above 4000 (confirmed) and 500 (deaths)
  int y_threshold = 4000;
  if(data_select-3 == 1)
    y_threshold = 500;
  int first_y[6];
  int first_y_max = 0;
  for(int n=1; n<6; n++){
    selected_country = country_selection[n];
    first_y[n] = 0;
    for(int i = 0; i < data_count[selected_country]; i++){
      if(collected_data[data_select-3][selected_country][i] < y_threshold){
        first_y[n] = i-14; // go back 2 Weeks
        // find the largest position
        if(i > first_y_max)
          first_y_max = i;
      }
    }
  }
  // draw the shifted line graph
  for(int n=1; n<6; n++){
    selected_country = country_selection[n];
    x_scale = float(SCREEN_WIDTH) / data_count[selected_country];
    for(int i = first_y[n]; i < data_count[selected_country]; i++){
      if(i > 0){
        M5.Lcd.drawLine(trunc(x_scale*((i-first_y[n])-1)), 
                        (SCREEN_HEIGHT-1)-(round((float((SCREEN_HEIGHT-1)) / max_y) * collected_data[data_select-3][selected_country][i-1])), 
                        trunc(x_scale*(i-first_y[n])), 
                        (SCREEN_HEIGHT-1)-(round((float((SCREEN_HEIGHT-1)) / max_y) * collected_data[data_select-3][selected_country][i])), 
                        country_color[n]);
      }
    }
  }
  // draw legend
  M5.Lcd.setFreeFont(FF1);
  M5.Lcd.setCursor(0, 0);
  // headline
  M5.Lcd.printf("\n%s (shifted)\n\n", data_name[data_select-3]);
  // Country name
  for(int n=1; n<6; n++){
    selected_country = country_selection[n];
    M5.Lcd.setTextColor(country_color[n]);
    M5.Lcd.printf("%s\n", country_names[selected_country].c_str());
  }
  M5.Lcd.setTextColor(WHITE);
  // Filename for Screen-dump to SD Card
  snprintf(Filename, sizeof(Filename), "/graph_shifted_%i.ppm",data_select);
}

//==============================================================
// display the data as summarized text output
void display_data_text(int data_select){
  Clear_Screen();
  print_menu(4);
  int selected_country = country_selection[data_select-5];
  // draw text output
  M5.Lcd.setFreeFont(FF2);
  M5.Lcd.setCursor(0, 0);
  M5.Lcd.setTextColor(country_color[data_select-5]);
  M5.Lcd.printf("\n%s:\n\n", country_names[selected_country].c_str());
  M5.Lcd.setFreeFont(FF1);
  M5.Lcd.setTextColor(WHITE);
  int n_confirmed = collected_data[0][selected_country][data_count[selected_country]-1];
  int n_deaths = collected_data[1][selected_country][data_count[selected_country]-1];
  M5.Lcd.printf("  confirmed:  %s\n", formatNumber(n_confirmed, format_buffer, sizeof(format_buffer)));
  M5.Lcd.printf("  deaths:     %s\n\n",    formatNumber(n_deaths, format_buffer, sizeof(format_buffer)));
  M5.Lcd.printf("  death rate:    %6.2f%%\n", (100.0/n_confirmed) * n_deaths);
  // Filename for Screen-dump to SD Card
  snprintf(Filename, sizeof(Filename), "/text_%i.ppm",data_select);
}

//==============================================================
// Dump the screen to a File
// Image file format: .ppm
// example for screen capture onto SD-Card: 
//    M5Screen2File(SD, "/screen.ppm");
bool M5Screen2File(fs::FS &fs, const char * path){
  // Open file for writing
  // The existing image file will be replaced
  File file = fs.open(path, FILE_WRITE);
  if(file){
    // M5Stack:  TFT_WIDTH = 240 / TFT_HEIGHT = 320
    // M5StickC: TFT_WIDTH =  80 / TFT_HEIGHT = 160
    // write PPM file header
    file.printf("P6\n%d %d\n255\n", TFT_HEIGHT, TFT_WIDTH);
    // To keep the required memory low, the image is captured line by line
    // M5Stack: 1 line * 320 pixel * 3 color bytes = 960 bytes.
    static unsigned char line_data[TFT_HEIGHT*3];
    // The function readRectRGB reads a screen area and returns the RGB 8 bit colour values of each pixel
...

This file has been truncated, please download it to see its full contents.


github repository

https://github.com/electricidea/M5Stack-Covid19-Monitor

Add all DigiKey Parts to Cart

Have questions or comments? Continue the conversation on TechForum, DigiKey's online community and technical resource.

Covid-19 Data Monitor

2022-01-11 | By M5Stack

INFORMATION

HELP

CONTACT US

FOLLOW US