SEEED Wio Terminal LoRa MQTT Gateway using Arduino IDE

/****************************************************************************
**                                                                         **
** Name:        WioTerminal_05_LoRaWan_MQTT_Gateway                        **
** Author:      Achim Kern                                                 **
** Interpreter: Arduino IDE 2.0.4 MacOS                                    **
** Licence:     Freeware                                                   **
** Function:    Main Program                                               **
**                                                                         **
** Notes:       based on idea from SEEED STUDIO and LCARS SmartHome        **
**                                                                         **
** History:                                                                **
**                                                                         **
** 1.00        - 01.11.2021 - initial release                              **
**                          - LoRa working                                 **
**                          - MQTT secured server now working              **
** 1.01        - 06.05.2022 - Grove LoRa modul to the left Grove port      **
**                          - (I2C Grove)                                  **                          
**                          - secure MQTT Broker on Synology NAS           ** 
**                          - code optimized from GPS Tracker              **
** 1.02        - 10.01.2023 - config_lora.txt on SD card                   **
** 1.03        - 11.01.2023 - LoRa frequency from SD card                  **
** 1.04        - 12.01.2023 - MATRIX Graphics and ShowMessages             **
** 1.05        - 12.01.2023 - SERIALDEBUG                                  **
** 1.06        - 12.01.2023 - Wio inbuild 3 buttons - TFT screen on /off   **
** 1.07        - 13.01.2023 - TFT screen off after 60 secs                 **
** 1.08        - 13.01.2023 - DHT11 sensor - Wio Terminal SensorNode       **
** 1.09        - 14.01.2023 - Wio inbuild sound mic sensor                 **
** 1.10        - 16.01.2023 - sound mic trigger on SD card                 **
**                          - Wio inbuild light sensor                     **
** 1.11        - 17.01.2023 - screen display connected sensors             **
** 1.12        - 07.02.2023 - MQTT problem solving                         **
**                          - hackster.io version                          **
**                                                                         **                          
****************************************************************************/

/*
 * Application and Version
 */
   const char* application  = "WioTerminal_05_LoRa_MQTT_Gateway";
   const char* aktu_version = "1.12";
   
/*
 * DEBUG:
 * If the following line is uncommented, messages are being printed out to the
 * serial connection for debugging purposes. When using the Arduino Integrated
 * Development Environment (Arduino IDE), these messages are displayed in the
 * Serial Monitor selecting the proper port and a baudrate of 115200.
 *
 */
#define SERIALDEBUG
 
#ifdef SERIALDEBUG
  #define SERIALDEBUG_PRINT(...)   Serial.print(__VA_ARGS__)
  #define SERIALDEBUG_PRINTLN(...) Serial.println(__VA_ARGS__)
#else
  #define SERIALDEBUG_PRINT(...)
  #define SERIALDEBUG_PRINTLN(...)
#endif

/*
 *  RF95, WiFi and MQTT libs
 * 
 */
   // we need these libraries
   #include <wiring_private.h>
   #include "rpcWiFi.h"
   #include "PubSubClient.h"
   #include "ArduinoJson.h"
  
/*
 *  WiFi and MQTT clients
 * 
 */
   WiFiClient     mqttClient;
   PubSubClient   MQTT(mqttClient);

/*
 * WIO Terminal TFT Display and SD card
 * 
 */
   #include <SPI.h>
   #include <Seeed_FS.h>
   #include <SD/Seeed_SD.h>
   #include <SDConfigFile.h>
   
   File myFile;
   int BUFSIZE;
   const char CONFIG_FILE[] = "config_lora.txt";
   boolean readConfiguration();                        
   boolean didReadConfig;
   
   // WIO Terminal SD Card
   char* sd_ssid;
   char* sd_password;
   char* sd_mqttServer;
   int   sd_mqttPort;
   char* sd_mqttUser;
   char* sd_mqttPassword;   
   char* sd_TOPIC_SUBSCRIBE;
   char* sd_TOPIC_PUBLISH;
   int   sd_lora_freq;
   int   sd_mic_trigger;

   // Wio Terminal TFT display
   #include "Free_Fonts.h"
   #include <LGFX_TFT_eSPI.hpp>
   static TFT_eSPI tft;
   // pictures on the sd card
   String iot_picture=""; 
   // Control Pin of LCD
   #define LCD_BACKLIGHT (72Ul)
   bool tft_backlight = true;
   // sleeping counter
   int tft_counter = 0;
   // sending counter
   int MQTT_counter = 0;
   // room or sensor display
   int aktu_room = 1;
   int max_room  = 1; 

/*
 * LoRa Modul
 * Grove LoRa module can be connected on the back (Hardware Serial is required to use the Grove LoRa module)
 * Also with the help of Serial Communication Interfaces (SERCOM) you can easily connect the Grove LoRa module
 * to the left Grove port. (i2c Grove) - actual used
 *
 */
   #ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE    
     #include <RH_RF95.h>
     static Uart Serial3(&sercom3, PIN_WIRE_SCL, PIN_WIRE_SDA, SERCOM_RX_PAD_1, UART_TX_PAD_0);
     RH_RF95 <Uart> rf95(Serial3);
   #endif   

/*
 * Wio Terminal inbuild Buzzer
 * ---------------------------
 */
   // Wio Buzzer
   // sig pin of the buzzer
   #define BUZZER_PIN WIO_BUZZER
   // the number of notes 
   int length = 15;
   char notes[] = "ccggaagffeeddc ";
   int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };
   int tempo = 300; 

/*
 * Wio Terminal inbuild Sound Sensor
 * ---------------------------------
 */
   int mic_level = 0;
   int mic_trigger = 300;
   long int mic_counter = 0;
   #define MicSamples (1024*2)  

/*
 * Wio Terminal inbuild Light Sensor
 * ---------------------------------
 */
   int light;
   uint8_t light_percentage;

/*
 * Wio Terminal inbuild LED
 * ------------------------
 */
   int led = 13;

/*
 * GROVE DHT11 Sensor (blue)
 * -------------------------
 * This Temperature&Humidity sensor provides a pre-calibrated digital output. 
 * A unique capacitive sensor element measures relative humidity and the temperature
 * is measured by a negative temperature coefficient (NTC) thermistor. 
 * It has excellent reliability and long term stability. 
 * Please note that this sensor will not work for temperatures below 0 degree.
 * 
 */ 
   // Enable/disable sensor measurements if you want to
   #define ENABLE_SENSOR_DHT
   // Sensors enabled, but not found in the hardware will be ignored
   #ifdef ENABLE_SENSOR_DHT
     // we need library
     #include <Adafruit_Sensor.h>
     #include <DHT.h>
     #include <DHT_U.h>
     // signal pin of your dht11 sensor 
     #define DHT_PIN 0
     // type of sensor (dht11=blue, dht22=white)
     #define DHTTYPE DHT11
     // intialize sensor
     DHT_Unified dht(DHT_PIN, DHTTYPE);
     uint32_t delayMS;
     int   grove_dht_temp = 0;
     int   grove_dht_humi = 0;
     /*-----------------------------------------*/
     /* Function void sensor_dht()              */
     /*                                         */
     /* TASK    : read out dht sensor data      */
     /* UPDATE  : 28.08.2020                    */
     /*-----------------------------------------*/   
     void sensor_dht()
     {
       delay(delayMS);
       // Get temperature event and print its value
       sensors_event_t event;
       dht.temperature().getEvent(&event);
       if (isnan(event.temperature)) 
       {
         SERIALDEBUG_PRINTLN(F("[!] Error reading DHTxx temperature!"));
       }
       else 
       {
         grove_dht_temp = event.temperature;
       }
       // Get humidity event and print its value.
       dht.humidity().getEvent(&event);
       if (isnan(event.relative_humidity)) 
       {
         SERIALDEBUG_PRINTLN(F("[!] Error reading DHTxx humidity!"));
       }
       else 
       {
         grove_dht_humi= event.relative_humidity+18;
       }
     }    
   #endif   

/*
 *  list of functions used
 * 
 */
   /* 01 */ boolean readConfiguration();
   /* 02 */ void init_wifi(void);
   /* 03 */ void connect_wifi(void);
   /* 04 */ void verify_wifi(void);
   /* 05 */ void init_mqtt(void);
   /* 06 */ void connect_mqtt(void);
   /* 07 */ void verify_mqtt(void);
   /* 08 */ void mqtt_callback(char* topic, byte* payload, unsigned int length);
   /* 09 */ void ShowMessage(String msg, int Cursor);
   /* 10 */ void LCD();
   /* 11 */ void TransmitData();
   /* 12 */ void tft_display_room_screen(String room_name, long int room_bg);
   /* 13 */ void tft_display_status_bar(String room_name, long int room_bg);
   /* 14 */ void tft_display_sensor_temperature(int temperature);
   /* 15 */ void tft_display_sensor_humidity(int humidity);
   /* 16 */ void tft_display_sensor_noise(int noise);
   /* 17 */ void tft_display_sensor_lux(int lux);
   /* 18 */ void tft_display_wioterminal(void);
   /* 19 */ void tft_display_matrix(void);
   
   void setup();
   void loop();

/*
 * Generally, you should use "unsigned long" for variables that hold time
 * The value will quickly become too large for an int to store
 */
   // this timer is used to update tft display and lorawan data send frequence
   unsigned long previousMillis = 0;
   // send every 10 minutes
   // unsigned long interval = 600000;  
   // send every 3 minutes
   // unsigned long interval = 180000;
   // send every 30 seconds
   unsigned long interval = 30000;   
   unsigned long counter  = 0;

/*-------------------------------------------------------------------------------*/
/* (01) Function boolean readConfiguration()                                     */
/*                                                                               */
/* TASK    : read your config.txt file from the SD Card                          */
/* UPDATE  : 29.04.2022                                                          */
/*-------------------------------------------------------------------------------*/
boolean readConfiguration() 
{
  const uint8_t CONFIG_LINE_LENGTH = 127;
  SDConfigFile cfg;
  
  // Open the configuration file.
  if (!cfg.begin(CONFIG_FILE, CONFIG_LINE_LENGTH)) 
  {
    SERIALDEBUG_PRINT("[x] Failed to open configuration file: ");
    SERIALDEBUG_PRINT(CONFIG_FILE);
    SERIALDEBUG_PRINT(F("\n"));
    return false;
  }
  SERIALDEBUG_PRINT("[x] read out settings from file ");
  SERIALDEBUG_PRINT(CONFIG_FILE);
  SERIALDEBUG_PRINT("\n\n");
  
  // Read each setting from the file.
  while (cfg.readNextSetting()) 
  {
    if (cfg.nameIs("WifiSSID")) 
    {
       sd_ssid = cfg.copyValue();
       SERIALDEBUG_PRINT("[?] WifiSSID:      ");
       SERIALDEBUG_PRINTLN(sd_ssid);
    }  
    else if (cfg.nameIs("WifiPASS")) 
    {
       sd_password = cfg.copyValue();
       SERIALDEBUG_PRINT("[?] WifiPASS:      ");
       SERIALDEBUG_PRINTLN(sd_password);
    }
    else if (cfg.nameIs("MQTTSERVER")) 
    {
       sd_mqttServer = cfg.copyValue();
       SERIALDEBUG_PRINT("[?] MQTTSERVER:    ");
       SERIALDEBUG_PRINTLN(sd_mqttServer);
    }
    else if (cfg.nameIs("MQTTPORT")) 
    {
       sd_mqttPort = cfg.getIntValue();
       SERIALDEBUG_PRINT("[?] MQTTPORT:      ");
       SERIALDEBUG_PRINTLN(String(sd_mqttPort));
    }
    else if (cfg.nameIs("MQTTUSER")) 
    {
       sd_mqttUser = cfg.copyValue();
       SERIALDEBUG_PRINT("[?] MQTTUSER:      ");
       SERIALDEBUG_PRINTLN(sd_mqttUser);
    } 
    else if (cfg.nameIs("MQTTPASSWORD")) 
    {
       sd_mqttPassword = cfg.copyValue();
       SERIALDEBUG_PRINT("[?] MQTTPASSWORD:  ");
       SERIALDEBUG_PRINTLN(sd_mqttPassword);
    }
    else if (cfg.nameIs("MQTTSUBSCRIBE")) 
    {
       sd_TOPIC_SUBSCRIBE = cfg.copyValue();
       SERIALDEBUG_PRINT("[?] MQTTSUBSCRIBE: ");
       SERIALDEBUG_PRINTLN(sd_TOPIC_SUBSCRIBE);
    }
    else if (cfg.nameIs("MQTTPUBLISH")) 
    {
       sd_TOPIC_PUBLISH = cfg.copyValue();
       SERIALDEBUG_PRINT("[?] MQTTPUBLISH:   ");
       SERIALDEBUG_PRINTLN(sd_TOPIC_PUBLISH);
    }
    else if (cfg.nameIs("LORAFREQ")) 
    {
       sd_lora_freq = cfg.getIntValue();
       SERIALDEBUG_PRINT("[?] LORAFREQ:      ");
       SERIALDEBUG_PRINTLN(String(sd_lora_freq));
    }
    else if (cfg.nameIs("MICTRIGGER")) 
    {
       sd_mic_trigger = cfg.getIntValue();
       SERIALDEBUG_PRINT("[?] MICTRIGGER:    ");
       SERIALDEBUG_PRINTLN(String(sd_mic_trigger));
       mic_trigger=sd_mic_trigger;
    }                                                  
    else 
    {
      // report unrecognized names
      SERIALDEBUG_PRINT("[?] Unknown name in config: ");
      SERIALDEBUG_PRINTLN(cfg.getName());
    }
  }
  
  // clean up
  cfg.end();
  SERIALDEBUG_PRINTLN("");
  return true;
}

/*-------------------------------------------------------------------------------*/
/* (02) Function void init_wifi(void)                                            */
/*                                                                               */
/* TASK    : do not provide a wifi hotspot                                       */
/* UPDATE  : 30.08.2020                                                          */
/*-------------------------------------------------------------------------------*/
void init_wifi(void)
{
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(2000);
}

/*-------------------------------------------------------------------------------*/
/* (03) Function void connect_wifi(void)                                         */
/*                                                                               */
/* TASK    : connect to your WiFi                                                */
/* UPDATE  : 30.08.2020                                                          */
/*-------------------------------------------------------------------------------*/
void connect_wifi(void)
{
  /* are we already connect to wifi */
  if (WiFi.status() == WL_CONNECTED)
        return;
    
  SERIALDEBUG_PRINTLN("[?] Connecting to your Wi-Fi");
  ShowMessage("Connecting to your Wi-Fi", 196);
  delay(1000);   
  WiFi.begin(sd_ssid, sd_password);
 
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(100);
    // Serial.print(".");
  }
 
  SERIALDEBUG_PRINTLN("[x] Wi-Fi connected");
  SERIALDEBUG_PRINT("[x] IP: ");
  SERIALDEBUG_PRINTLN(WiFi.localIP()); 
  SERIALDEBUG_PRINTLN("");
  ShowMessage("Wi-Fi connected", 196);
  delay(1000);       
}

/*-------------------------------------------------------------------------------*/
/* (04) Function void verify_wifi(void)                                          */
/*                                                                               */
/* TASK    : check if WiFi connection is stable                                  */
/* UPDATE  : 30.08.2020                                                          */
/*-------------------------------------------------------------------------------*/
void verify_wifi(void)
{
  connect_wifi();
}

/*-------------------------------------------------------------------------------*/
/* (05) Function void init_mqtt(void)                                            */
/*                                                                               */
/* TASK    : init your MQTT broker                                               */
/* UPDATE  : 30.08.2020                                                          */
/*-------------------------------------------------------------------------------*/
void init_mqtt(void)
{
  MQTT.setServer(sd_mqttServer, sd_mqttPort);
  MQTT.setCallback(mqtt_callback);   
}

/*-------------------------------------------------------------------------------*/
/* (06) Function void connect_mqtt(void)                                         */
/*                                                                               */
/* TASK    : connect to your MQTT broker                                         */
/* UPDATE  : 30.08.2020                                                          */
/*-------------------------------------------------------------------------------*/
void connect_mqtt(void)
{ 
  while (!MQTT.connected()) 
  {
    SERIALDEBUG_PRINTLN("[?] Connecting to your MQTT Broker");
    ShowMessage("Connecting to your MQTT Broker", 196);
    delay(1000);
    char *user = sd_mqttUser;
    char *password = sd_mqttPassword;
    if (MQTT.connect("LoRaMQTTGateway", user, password)) 
    {
      SERIALDEBUG_PRINTLN("[x] MQTT Broker connected");
      SERIALDEBUG_PRINTLN("");
      ShowMessage("MQTT Broker connected", 196);
      delay(500);   
      MQTT.subscribe(sd_TOPIC_SUBSCRIBE);
    }
    else
    {
      SERIALDEBUG_PRINT("[!] MQTT failed with state ");
      SERIALDEBUG_PRINTLN(String(MQTT.state()));
      delay(2000);
    }
  }
}

/*-------------------------------------------------------------------------------*/
/* (07) Function void verify_mqtt(void)                                          */
/*                                                                               */
/* TASK    : check if MQTT connection is stable                                  */
/* UPDATE  : 30.08.2020                                                          */
/*-------------------------------------------------------------------------------*/
void verify_mqtt(void)
{
  connect_mqtt();
}

/*------------------------------------------------------------------------------------*/
/* (08) Function void mqtt_callback(char* topic, byte* payload, unsigned int length)  */
/*                                                                                    */
/* TASK    : setup all needed requirements                                            */
/* UPDATE  : 30.08.2020                                                               */
/*------------------------------------------------------------------------------------*/
void mqtt_callback(char* topic, byte* payload, unsigned int length)
{
  SERIALDEBUG_PRINT("[>] Message arrived in topic: ");
  SERIALDEBUG_PRINTLN(topic);
  SERIALDEBUG_PRINT("[>] Message:");
  for(int i = 0; i < length; i++) 
  {
    SERIALDEBUG_PRINT(String((char)payload[i]));
  }
  SERIALDEBUG_PRINTLN("");

  char p[length + 1];
  memcpy(p, payload, length);
  p[length] = NULL;
  String message(p);
    
  // Parse the command payload if json (V6)
  StaticJsonDocument<200> doc;
  #ifdef SERIALDEBUG
    deserializeJson(doc, (char*)payload);
    SERIALDEBUG_PRINT("[x] Command received:");
    serializeJson(doc, Serial);
    SERIALDEBUG_PRINTLN("");
  #endif
  if (aktu_room==1) { ShowMessage(p, 196); }
}

/*-------------------------------------------------------------------------------*/
/* (09) Function void ShowMessage(String msg, int Cursor)                        */
/*                                                                               */
/* TASK    : display a short message on the WioTerminal TFT screen               */
/* UPDATE  : 29.04.2022                                                          */
/*-------------------------------------------------------------------------------*/
void ShowMessage(String msg, int Cursor) 
{
  tft.setTextColor(TFT_GREEN,TFT_BLACK);
  tft.setCursor(0, Cursor);
  tft.print("                                                                                           ");
  tft.print("                                                                                           ");
  tft.print("                                                                                           ");
  tft.setCursor((320 - tft.textWidth(msg))/2, Cursor);
  tft.print("                                                                                                          ");
  tft.print(msg);
}

/*-------------------------------------------------------------------------------*/
/* (10) Function void LCD()                                                      */
/*                                                                               */
/* TASK    : switch LCD on or off                                                */
/* UPDATE  : 14.10.2022                                                          */
/*-------------------------------------------------------------------------------*/
void LCD()
{
  tft_backlight = !tft_backlight;
  // Turning off the LCD backlight
  if (tft_backlight == false) 
  { digitalWrite(LCD_BACKLIGHT, LOW); 
    tft.setBrightness(0); 
    SERIALDEBUG_PRINT("TFT display OFF\n\r"); 
  }
  // Turning on the LCD backlight
  if (tft_backlight == true)  
  { 
    digitalWrite(LCD_BACKLIGHT, HIGH); 
    tft.setBrightness(255); 
    SERIALDEBUG_PRINT("TFT display ON\n\r"); }  
}

/*-------------------------------------------------------------------------------*/
/* (11) Function void TransmitData()                                             */
/*                                                                               */
/* TASK    : transmit your sensor data to TTN V3 console                         */
/* UPDATE  : 14.10.2022                                                          */
/*-------------------------------------------------------------------------------*/
void TransmitData()
{
  // tft.fillScreen(TFT_BLACK);
  SERIALDEBUG_PRINTLN(F("[x] load and display picture - iot.jpg"));
  tft.drawJpgFile(SD, "iot.jpg");
  delay(1000); 

  // read out all available sensors
  SERIALDEBUG_PRINTLN(F(""));
  SERIALDEBUG_PRINTLN(F("[x] read out all available sensors"));
  
  // Get the Wio Terminal inbuild mic value 
  SERIALDEBUG_PRINT(F("[?] WIO MIC inbuild >>> NoiseCounter:"));  
  SERIALDEBUG_PRINTLN(String(mic_level));
  
  // Get the Wio Terminal inbuild light value 
  light = analogRead(WIO_LIGHT);
  SERIALDEBUG_PRINT(F("[?] WIO LIGHT inbuild >>> AnalogRead:"));  
  SERIALDEBUG_PRINT(String(light));
  // Light (Illuminance) level/percentage in greenhouse
  light_percentage = map(light, 0, 1024, 0, 100);
  SERIALDEBUG_PRINT(F("  Percentage:"));
  SERIALDEBUG_PRINT(light_percentage);
  SERIALDEBUG_PRINT(F("%\n"));

  // create json msg
  char textA[150] = "{\"node\": \"LoRa_MQTT_Gateway\"";
  // sensor data
  char array_sensor[1];	

  #ifdef ENABLE_SENSOR_DHT
     // read the dht sensor */
     sensor_dht();
     SERIALDEBUG_PRINT(F("[?] GROVE DHT >>> "));
     SERIALDEBUG_PRINT(F("T:")); SERIALDEBUG_PRINT(grove_dht_temp);
     SERIALDEBUG_PRINT(F("  H:")); SERIALDEBUG_PRINTLN(grove_dht_humi);
     // sensor humidity
     sprintf(array_sensor, "%d", grove_dht_humi);
     strcat(textA,",\"H\":");
     strcat(textA,array_sensor);
     // sensor temperature
     sprintf(array_sensor, "%d", grove_dht_temp);
     strcat(textA,",\"T\":");
     strcat(textA,array_sensor);
  #endif 

  // sensor wio inbuild sound mic
  sprintf(array_sensor, "%d", mic_level);
  strcat(textA,",\"N\":");
  strcat(textA,array_sensor);

  // sensor wio inbuild light
  sprintf(array_sensor, "%d", light_percentage);
  strcat(textA,",\"L\":");
  strcat(textA,array_sensor);  

  // json end
  strcat(textA,"}");
  // show and publish sensor msg
  SERIALDEBUG_PRINT("[>] Message:");  
  SERIALDEBUG_PRINTLN((char*)textA);
  ShowMessage(textA,196);
  MQTT.publish(sd_TOPIC_PUBLISH,textA);       
  SERIALDEBUG_PRINTLN(F("[x] Uplink to your MQTT broker done\n"));
  mic_level=0; 

  aktu_room=1;
  tft_display_matrix();      
}

/*------------------------------------------------------------------------------------*/
/* (12) Function void tft_display_room_screen(String room_name, long int room_bg)     */
/*                                                                                    */
/* TASK    : show tft display room screen                                             */
/* UPDATE  : 22.09.2020                                                               */
/*           08.01.2021 - room_name pos -22                                           */
/*------------------------------------------------------------------------------------*/
void tft_display_room_screen(String room_name, long int room_bg) 
{
  tft.fillScreen(TFT_WHITE);
  tft.fillRect(0,0,320,50,room_bg);
  tft.setFreeFont(FMB18);
  tft.setTextColor(TFT_WHITE);
  tft.setCursor((320 - tft.textWidth(room_name)) / 2, 32-22);
  tft.print(room_name);
  // drawing verticle line
  tft.drawFastVLine(150,50,190,TFT_DARKGREEN);
  // drawing horizontal line
  tft.drawFastHLine(0,140,320,TFT_DARKGREEN);  
}

/*-------------------------------------------------------------------------------------*/
/* (13) Function void tft_display_status_bar(String room_name, long int room_bg)       */
/*                                                                                     */
/* TASK    : show tft display status bar                                               */
/* UPDATE  : 22.09.2020                                                                */
/*           08.01.2021 - room_name pos -22                                            */
/*-------------------------------------------------------------------------------------*/
void tft_display_status_bar(String room_name, long int room_bg) 
{
  tft.fillRect(0,0,320,50,room_bg);
  tft.setFreeFont(FMB18);
  tft.setTextColor(TFT_WHITE);
  tft.setCursor((320 - tft.textWidth(room_name)) / 2, 32-22);
  tft.print(room_name); 
}

/*-------------------------------------------------------------------------------*/
/* (14) Function void tft_display_sensor_temperature(int temperature)            */
/*                                                                               */
/* TASK    : show tft display sensor temperature                                 */
/* UPDATE  : 22.09.2020                                                          */
/*-------------------------------------------------------------------------------*/
void tft_display_sensor_temperature(int temperature) 
{
  // setting the temperature
  tft.setTextColor(TFT_BLACK);
  tft.setFreeFont(FMB9);
  tft.drawString("Temperature",15,65);
  tft.setTextColor(TFT_BLACK);
  tft.setFreeFont(FMB18);
  tft.drawNumber(temperature,50,95);
  //tft.drawNumber(21,50,95);
  tft.setFreeFont(FMB12);
  tft.drawString("C",100,95); 
}

/*-------------------------------------------------------------------------------*/
/* (15) Function void tft_display_sensor_humidity(int humidity)                  */
/*                                                                               */
/* TASK    : show tft display sensor humidity                                    */
/* UPDATE  : 22.09.2020                                                          */
/*-------------------------------------------------------------------------------*/
void tft_display_sensor_humidity(int humidity) 
{
  // setting the humidity
  tft.setTextColor(TFT_BLACK);
  tft.setFreeFont(FMB9);
  tft.drawString("Humidity",30,160);
  tft.setTextColor(TFT_BLACK);
  tft.setFreeFont(FMB18);
  tft.drawNumber(humidity,50,190);
  tft.setFreeFont(FMB12);
  tft.drawString("%",100,190);
}

/*-------------------------------------------------------------------------------*/
/* (16) Function void tft_display_sensor_noise(int noise)                        */
/*                                                                               */
/* TASK    : show tft display sensor noise                                       */
/* UPDATE  : 22.09.2020                                                          */
/*-------------------------------------------------------------------------------*/
void tft_display_sensor_noise(int noise) 
{
  // setting the voc
  tft.setTextColor(TFT_BLACK);
  tft.setFreeFont(FMB9);
  tft.drawString("Sounds",200,65);
  tft.setTextColor(TFT_BLACK);
  tft.setFreeFont(FMB18);
  //tft.drawNumber(noise,160,95);
  tft.drawNumber(noise,200,95);
  //tft.setFreeFont(FMB12);
  //tft.drawString("sum",250,95);
}

/*-------------------------------------------------------------------------------*/
/* (17) Function void tft_display_sensor_lux(int lux)                            */
/*                                                                               */
/* TASK    : show tft display sensor lux                                         */
/* UPDATE  : 22.09.2020                                                          */
/*-------------------------------------------------------------------------------*/
void tft_display_sensor_lux(int lux) 
{ 
  // setting the luminance lux
  tft.setTextColor(TFT_BLACK);
  tft.setFreeFont(FMB9);
  tft.drawString("Luminance",185,160);
  tft.setTextColor(TFT_BLACK);
  tft.setFreeFont(FMB18);
  tft.drawNumber(lux,200,190);
  tft.setFreeFont(FMB12);
  tft.drawString("%",250,190);
}

/*-------------------------------------------------------------------------------*/
/* (18) Function void tft_display_wioterminal(void)                              */
/*                                                                               */
/* TASK    : show tft display wioterminal (own connected sensors)                */
/* UPDATE  : 30.11.2020                                                          */
/*-------------------------------------------------------------------------------*/
void tft_display_wioterminal(void) 
{
  // display wioterminal screen
  tft_display_room_screen("WioTerminal 5", TFT_DARKGREEN); 
  // display temperature sensor
  #ifdef ENABLE_SENSOR_DHT
     // read the dht sensor
     sensor_dht();
     tft_display_sensor_temperature(grove_dht_temp);
     // display humidity sensor
     tft_display_sensor_humidity(grove_dht_humi);
  #endif    
  // display noise sensor
  tft_display_sensor_noise(mic_level); 
  // display light sensor
  light = analogRead(WIO_LIGHT);
  // Light (Illuminance) level/percentage in greenhouse
  light_percentage = map(light, 0, 1024, 0, 100);
  tft_display_sensor_lux(light_percentage); 
}

/*-------------------------------------------------------------------------------*/
/* (19) Function void tft_display_matrix(void)                                   */
/*                                                                               */
/* TASK    : show tft display matrix (lora and mqtt connected sensors)           */
/* UPDATE  : 30.11.2020                                                          */
/*-------------------------------------------------------------------------------*/
void tft_display_matrix(void) 
{
  // display matrix screen
  tft.fillScreen(TFT_BLACK);
  SERIALDEBUG_PRINTLN(F("[x] load and display picture - matrix.jpg"));
  tft.drawJpgFile(SD, "matrix.jpg");
  tft.setTextColor(TFT_GREEN);
  tft.setFreeFont(FMB12);
  tft.setCursor((320 - tft.textWidth("LoRa MQTT GATEWAY"))/2, 3);
  tft.print("LoRa MQTT GATEWAY");
  tft.setTextFont(0);
  ShowMessage("Waiting until receiving LoRa or MQTT packet...", 196);
  delay(1000);
  SERIALDEBUG_PRINTLN("[>] Waiting until receiving LoRa or MQTT packet");
  SERIALDEBUG_PRINTLN("");
}

/*-------------------------------------------------------------------------------*/
/* Functions void SERCOM3_x_Handler()                                            */
/*                                                                               */
/* TASK    : Serial COM Handler                                                  */
/* UPDATE  : 29.04.2022                                                          */
/*-------------------------------------------------------------------------------*/

void SERCOM3_0_Handler()
{
  Serial3.IrqHandler();
}

void SERCOM3_1_Handler()
{
  Serial3.IrqHandler();
}

void SERCOM3_2_Handler()
{
  Serial3.IrqHandler();
}

void SERCOM3_3_Handler()
{
  Serial3.IrqHandler();
}

/*-------------------------------------------------------------------------------*/
/* Function void setup()                                                         */
/*                                                                               */
/* TASK    : setup all needed requirements                                       */
/* UPDATE  : 28.08.2020                                                          */
/*-------------------------------------------------------------------------------*/
void setup() 
{  
  // Serial baud rate
  #ifdef SERIALDEBUG
    Serial.begin(9600);
  #endif  

  // boot application
  delay(3000);
  SERIALDEBUG_PRINTLN(F(" "));
  SERIALDEBUG_PRINTLN(F(" "));
  SERIALDEBUG_PRINTLN(F("Starting..."));
  SERIALDEBUG_PRINT(F(application)); SERIALDEBUG_PRINT(F(" Version ")); SERIALDEBUG_PRINTLN(F(aktu_version));
  SERIALDEBUG_PRINTLN(F("connected via LORA WIFI WLAN MQTT"));
  SERIALDEBUG_PRINTLN(F(" "));  

  // Display Setup
  tft.begin();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  //Initialise SD card
  if (!SD.begin(SDCARD_SS_PIN, SDCARD_SPI)) 
  {
    SERIALDEBUG_PRINTLN("[!] SD Card init failed!");
    ShowMessage("SD Card init FAILED", 196);
    while (1);
  }
  SERIALDEBUG_PRINTLN("[x] SD Card init OK");
  ShowMessage("SD Card init OK", 196);
  delay(1000);

  // read config file from sd card
  SERIALDEBUG_PRINT(F("[?] Read configuration file from SD\n"));
  ShowMessage("Read configuration file from SD", 196);
  delay(1000);
  didReadConfig = readConfiguration();
  if (!didReadConfig) 
  {
    SERIALDEBUG_PRINT(F("[!] Read configuration file FAILED!\n"));
    while (1);
  }
  else
  {
    SERIALDEBUG_PRINT(F("[x] Configuration file loaded\n\n"));
    ShowMessage("Configuration file loaded", 196);
  }
  delay(1000);

  // display IoT picture
  SERIALDEBUG_PRINTLN(F("[x] load and display picture - iot.jpg"));
  tft.drawJpgFile(SD, "iot.jpg");
  delay(2000);

  tft.fillScreen(TFT_BLACK);
  SERIALDEBUG_PRINTLN(F("[x] load and display picture - matrix.jpg"));
  tft.drawJpgFile(SD, "matrix.jpg");
  tft.setTextColor(TFT_GREEN);
  tft.setFreeFont(FMB12);
  tft.setCursor((320 - tft.textWidth("LoRa MQTT GATEWAY"))/2, 3);
  tft.print("LoRa MQTT GATEWAY");
  tft.setTextColor(TFT_YELLOW);
  tft.setTextFont(0);
  ShowMessage("CREATING THE MATRIX", 196);
  delay(1000); 

  // Wio Terminal inbuild sensors and actors
  pinMode(WIO_LIGHT,INPUT);
  pinMode(BUZZER_PIN,OUTPUT);
  pinMode(WIO_MIC,INPUT);

  // Wio Terminal Joystick
  pinMode(WIO_5S_PRESS,INPUT_PULLUP);
  pinMode(WIO_5S_UP,INPUT_PULLUP);
  pinMode(WIO_5S_DOWN,INPUT_PULLUP);
  pinMode(WIO_5S_LEFT,INPUT_PULLUP);
  pinMode(WIO_5S_RIGHT,INPUT_PULLUP);

  // 3 Wio Terminal buttons
  pinMode(WIO_KEY_A, INPUT_PULLUP);
  pinMode(WIO_KEY_B, INPUT_PULLUP);
  pinMode(WIO_KEY_C, INPUT_PULLUP);
  SERIALDEBUG_PRINTLN("[x] initialize inbuild sensors, joystick, buttons and buzzer");

  // LoRa Serial
  pinPeripheral(PIN_WIRE_SCL, PIO_SERCOM_ALT);
  pinPeripheral(PIN_WIRE_SDA, PIO_SERCOM_ALT);
  SERIALDEBUG_PRINTLN("[x] initialize pinPeripheral SCL and SCA");
  SERIALDEBUG_PRINTLN("");
  delay(100); 

  #ifdef ENABLE_SENSOR_DHT
     // start the dht sensor
     dht.begin();
     SERIALDEBUG_PRINT(F("[x] GROVE DHT Sensor connected\n"));
     // read the dht sensor */
     sensor_dht();
     SERIALDEBUG_PRINT(F("[?] GROVE DHT --> "));
     SERIALDEBUG_PRINT(F("T:")); SERIALDEBUG_PRINT(grove_dht_temp);
     SERIALDEBUG_PRINT(F("  H:")); SERIALDEBUG_PRINTLN(grove_dht_humi);
     SERIALDEBUG_PRINTLN("");
  #endif  

  // connect to WiFi
  SERIALDEBUG_PRINT(F("[?] RPC-System-Firmware-Version: "));
  SERIALDEBUG_PRINTLN(F(rpc_system_version())); 
  init_wifi();
  connect_wifi();

  // connect to MQTT Broker secured
  init_mqtt();
  connect_mqtt();
  delay(2000);

  SERIALDEBUG_PRINTLN("[?] LoRa RF95 server init");
  ShowMessage("LoRa RF95 server init", 196);

  pinMode(led, OUTPUT);

  if (!rf95.init()) 
  {
    SERIALDEBUG_PRINTLN("[!] LoRa R95 server init failed");
    while (1);
  }
  // Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on

  // The default transmitter power is 13dBm, using PA_BOOST.
  // If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then
  // you can set transmitter powers from 5 to 23 dBm:
  //rf95.setTxPower(13, false);
 
  // rf95.setFrequency(868.0);  
  rf95.setFrequency(sd_lora_freq);  

  ShowMessage("Waiting until receiving LoRa or MQTT packet...", 196);
  delay(1000);
  SERIALDEBUG_PRINTLN("[>] Waiting until receiving LoRa or MQTT packet");
  SERIALDEBUG_PRINTLN("");    
}

/*-------------------------------------------------------------------------------*/
/* Function void loop()                                                          */
/*                                                                               */
/* TASK    : this runs forever                                                   */
/* UPDATE  : 28.08.2020                                                          */
/*           08.01.2021 - backlight on/off no only works via brightness change   */
/*-------------------------------------------------------------------------------*/
void loop() 
{
  // check if all connections are stable
  verify_wifi();
  verify_mqtt();
  MQTT.loop();

  //first we check noise level on the WIO inbuild MIC
  long signalAvg = 0, signalMax = 0, signalMin = 1024, t0 = millis();
  for (int i = 0; i < MicSamples; i++)
  {
    int k = analogRead(WIO_MIC);
    signalMin = min(signalMin, k);
    signalMax = max(signalMax, k);
    signalAvg += k;
  }
  signalAvg /= MicSamples;

  // if ((signalMax - signalMin) > 75)  
  if ((signalMax - signalMin) > mic_trigger)    
  {  
    SERIALDEBUG_PRINTLN("[x] Noise detected"); 
    SERIALDEBUG_PRINTLN("[?] Span: " + String(signalMax - signalMin));
    mic_level=mic_level+1;
    SERIALDEBUG_PRINTLN("[x] noise-counter: " + String(mic_level));
...

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