it's getting hotter - use the arduino thermometer

/* Air quality sensor
  by smi1100 - 06/16/2022
  My third project. The following components are needed:
  - Arduino Mega
  - OLED display (in my case waveshare - 128x128, General 1.5inch OLED display module)
  - two RGB-LED and 6 220 Ohm resistors
  - 2 Voltmeter (in my case 5 Volt Voltmeter 85C1)
  - 1 push button momentary
  - air quality sensor (in my case Grove - Air Quality Sensor v1.3)
  - DS3231 real time clock
  - DHT22 sensor (measuring humidity)
  - DS18B20 sensor (measuring temperature) and a resistor 4,7K Ohm
  - bread board
  - casing
*/

/* module 0 - Arduino Mega --------------------------------------------------------------------- */

  #include <Arduino.h>
  #include <SPI.h>                  // library for the serial bus

/* module 1 - OLED Display ----------------------------------------------------------------
   
  List of fonds https://github.com/olikraus/u8g2/wiki/fntlist8x8 */
   
  #include <U8x8lib.h>              // library necessary to display text on the oled display
  U8X8_SSD1327_WS_128X128_4W_SW_SPI u8x8(/* clock=*/ 32, /* data=*/ 34, /* cs=*/ 30, /* dc=*/ 28, /* reset=*/ 26);

  // change the pages of the OLED display without using delay

  int Seite = 0;
  int Zeit_auf_Seite = 7000;
  unsigned long aktuelleZeit;
  unsigned long letzterZustandsWechsel;

  /* description of the variables
  Seite - pagenumber of the oled-display
  Zeit_auf_Seite - time to change to the next page on the oled display
  wait without using delay
    aktuelleZeit
    letzterZustandswechsel
  */

// module 2 - real time clock ---------------------------------------------------------------------

  #include "RTClib.h"               // library for the real time clock (RTC)
  RTC_DS3231 rtc;                   // RTC - from left to right - GND, VCC, SDA (Mega - 20, Uno - A4), SCL (Mega - 21, Uno - A5) - input voltage of the RTC - 3.3 or 5V
  char daysOfTheWeek[7][12] = {"Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerst.", "Freitag", "Samstag"};
  // in english char weekday[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

  String day, month, hour, minute;
  String weekday;

// module 3 - DS18B20 sensor -----------------------------------------------------------------

  #include <OneWire.h>              // library for the 1-wire
  #include <DallasTemperature.h>    // digital, serial bus from the manufacturer Maxim (former Dallas) 

  #define ONE_WIRE_BUS 22           // connection to digital PIN 22 - input voltage of the sensor - 3.3 or 5V

  OneWire oneWire(ONE_WIRE_BUS);
  DallasTemperature sensor(&oneWire);

// module 4 - air quality sensor ------------------------------------------------------------

  #include "Air_Quality_Sensor.h"
  AirQualitySensor sensore(A0);     // connection to analog PIN A0 -  - input voltage of the sensor - 3.3 or 5V
  
// module 5 - EEPROM Arduino --------------------------------------------------------------

  #include <EEPROM.h>

  float t = 20;                     // current temperature - when switching on set to 20 C
  float t_diff;                     // difference between t and t_vorher
  String positiv = "+";             // If the difference is positive, a "+" sign is added

  // save the data after turning on

  float t_vorher = 15;              // temperature - in this example - 1 hour ago (change with variable Bezugsgre)
  int t_vorher_adress = 280;
  float bezugsgroesse = 3600000;    // Bezugsgre in milli seconds -> 1000 milliseconds * 60 sek * 60 min = 3.600.000 msek (1 hour)
  unsigned long letzterZustandsWechselA;
  unsigned long aktuelleZeitA;
  
  // initial values of Tmax and Tmin are chosen so that they are overwritten on the first run
  
  float t_max = 10.99;
  float t_min = 39.99;
  
  int t_max_adress = 0;
  int t_min_adress = 50;

  // save that time with T maximun
  
  String t_max_hour = "12";
  int t_max_hour_adress = 100;
  String t_max_minute = "12";
  int t_max_minute_adress = 120; 
  String t_max_day = "12";
  int t_max_day_adress = 140;
  String t_max_month = "12";
  int t_max_month_adress = 160; 

  // save that time with T minimum
  
  String t_min_hour = "12";
  int t_min_hour_adress = 180;
  String t_min_minute = "12";
  int t_min_minute_adress = 200; 
  String t_min_day = "12";
  int t_min_day_adress = 220;
  String t_min_month = "12";
  int t_min_month_adress = 240;

// module 6 - Voltmeter temperature --------------------------------------------------------
  
  int Voltmeter_Temp_PIN = 2;     //PWM PIN
  int MIN_TEMP = 20;
  int MAX_TEMP = 35;
  int RANGE_TEMP = MAX_TEMP - MIN_TEMP;
  int voltage_temp;         // 0 - 255 -> variable for the both voltmeter
  int temp;                 // temp = 100 * t
  
// module 7 - RGB LED Voltmeter -------------------------------------------------------------
  // Do not connect the GND of the LED to the same GND of the voltmeter -> changes the values on the voltmeter
    
  int ledrot_temp=4;        //PWM PIN
  int ledblau_temp=5;       //PWM PIN
  int ledgruen_temp=6;      //PWM PIN
  
// module 8 - DHT 22 ------------------------------------------------------------------------

  #include "DHT.h"

  #define DHT22PIN 24                 // connection to digital PIN 24 - input voltage of the sensor - 3.3 or 5V
  #define DHT22TYPE DHT22

  DHT dht22(DHT22PIN, DHT22TYPE);

  float humidity;
  float temperature_dht22;            // compare values with DS18B20

// module 9 - Voltmeter hygrometer -----------------------------------------------------------------
  
  int Voltmeter_Hygro_PIN = 3;        //PWM PIN
  int MIN_Hygro = 20;
  int MAX_Hygro = 35;
  int RANGE_Hygro = MAX_Hygro - MIN_Hygro;
  int voltage_Hygro;
    
// module 10 - RGB LED Voltmeter
  // Do not connect the GND of the LED to the same GND of the voltmeter -> changes the values on the voltmeter
  
  int ledrot_hygro=7;         //PWM PIN
  int ledblau_hygro=8;        //PWM PIN
  int ledgruen_hygro=9;       //PWM PIN
  
// module 11 - momentary button display

  const int buttonPin = 36;
  int buttonState = 0;

  
void setup()
{
  Serial.begin(9600);
  Serial.println("+++++++++++++++++++ SETUP +++++++++++++++++++");Serial.println("");
  
  // OLED Display --------------------------------------------------------------

  u8x8.begin();                   // input voltage of the display - 3.3 or 5V
  Serial.println("OLED Display ready");Serial.println("");
  
  // real time clock -------------------------------------------------------------------
  
  if (! rtc.begin())              // Check if RTC is connected correctly:
  {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (rtc.lostPower())            // Check if the RTC lost power and if so, set the time:
  {
    Serial.println("RTC lost power, lets set the time!");
    // The following line sets the RTC to the date & time this sketch was compiled:
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    //rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }

  Serial.println("RTC ready"); Serial.println("");
   
  // Temp. sensor --------------------------------------------------------------

  sensor.begin();
  Serial.print("Temperatursensor - DS 18B20 - Anzahl Sensoren: ");
  Serial.println(sensor.getDeviceCount());
  Serial.println("Sensor DS 18B20 ready"); Serial.println("");

// Air quality sensor ------------------------------------------------------------
 
    while (!Serial);

    u8x8.clear();
    u8x8.setFont(u8x8_font_7x14_1x2_r);
    
    u8x8.setCursor(3,6);
    u8x8.print("Booting ...");
    
    Serial.println("Luftgtesensor - Waiting sensor to init (10 sek)...");
    delay(10000);
    
    if (sensore.init())
    {
        Serial.println("Sensor Luftgte ready");
        Serial.println("");
    }
    else
    {
        Serial.println("Sensor Luftgte ERROR!");
        Serial.println("");
    }
  
  // EEPROM --------------------------------------------------------------------

  EEPROM.put(t_min_adress, t_min);
  Serial.print("MIN Initial aus EEPROM (adress - value): "); Serial.print(t_min_adress); Serial.print(" - "); Serial.println(t_min);
  EEPROM.put(t_max_adress, t_max);
  Serial.print("MAX Initial aus EEPROM (adress - value): "); Serial.print(t_max_adress); Serial.print(" - "); Serial.println(t_max);Serial.println("");
  
  // VOLTMETER temperature und humidity -----------------------------------------------------------------
  
  // Test accuracy of voltmeter - calibrate with adjusting screw if necessary
  
  int MIN = 0;
  int MAX = 255;
 
  analogWrite(Voltmeter_Temp_PIN, MIN);
  analogWrite(Voltmeter_Hygro_PIN, MIN);
  Serial.println("Voltmeter Teilstrich 0");
  delay(2000);

  analogWrite(Voltmeter_Temp_PIN, MAX*1/5);
  analogWrite(Voltmeter_Hygro_PIN, MAX*1/5);
  Serial.println("Voltmeter Teilstrich 1");
  delay(2000);

  analogWrite(Voltmeter_Temp_PIN, MAX*2/5);
  analogWrite(Voltmeter_Hygro_PIN, MAX*2/5);
  Serial.println("Voltmeter Teilstrich 2");
  delay(2000);

  analogWrite(Voltmeter_Temp_PIN, MAX*3/5);
  analogWrite(Voltmeter_Hygro_PIN, MAX*3/5);
  Serial.println("Voltmeter Teilstrich 3");
  delay(2000);

  analogWrite(Voltmeter_Temp_PIN, MAX*4/5);
  analogWrite(Voltmeter_Hygro_PIN, MAX*4/5);
  Serial.println("Voltmeter Teilstrich 4");
  delay(2000);

  analogWrite(Voltmeter_Temp_PIN, MAX*5/5);
  analogWrite(Voltmeter_Hygro_PIN, MAX*5/5);
  Serial.println("Voltmeter Teilstrich 5");
  delay(2000);

  analogWrite(Voltmeter_Temp_PIN, MIN);
  analogWrite(Voltmeter_Hygro_PIN, MIN);
  Serial.println("Voltmeter Teilstrich 0");Serial.println("");

  Serial.println("Voltmeter ready");Serial.println("");
  
  // RGB LED ------------------------------------------------------------------------

  analogWrite(ledrot_temp,255);analogWrite(ledrot_hygro,255);
  analogWrite(ledblau_temp,0);analogWrite(ledblau_hygro,0);
  analogWrite(ledgruen_temp,0);analogWrite(ledgruen_hygro,0);
  Serial.println("LED Farbe rot");
  delay (2000);
    
  analogWrite(ledrot_temp,0);analogWrite(ledrot_hygro,0);
  analogWrite(ledblau_temp,255);analogWrite(ledblau_hygro,255);
  analogWrite(ledgruen_temp,0);analogWrite(ledgruen_hygro,0);
  Serial.println("LED Farbe blau");
  delay (2000);
      
  analogWrite(ledrot_temp,0);analogWrite(ledrot_hygro,0);
  analogWrite(ledblau_temp,0);analogWrite(ledblau_hygro,0);
  analogWrite(ledgruen_temp,255);analogWrite(ledgruen_hygro,255);
  Serial.println("LED Farbe grn");
  delay (2000);
  
  analogWrite(ledrot_temp,0);analogWrite(ledrot_hygro,0);
  analogWrite(ledblau_temp,0);analogWrite(ledblau_hygro,0);
  analogWrite(ledgruen_temp,0);analogWrite(ledgruen_hygro,0);
  delay (2000);
  Serial.println("LED ready");Serial.println("");
    

  // Hygrometer ------------------------------------------------------------------------

  dht22.begin();
  Serial.println("DHT22 ready");Serial.println("");

  // Taster ----------------------------------------------------------------------------

  pinMode(buttonPin, INPUT_PULLUP);
  
}

void loop()
{
  
  // Display

   buttonState = digitalRead(buttonPin);
   if (buttonState == LOW)
   {
      //Serial.println("Display Schalter ON");
      u8x8.setPowerSave(0);
   }
   else
   {
      //Serial.println("Display Schalter OFF");
      u8x8.setPowerSave(1);
   }

  aktuelleZeit = millis();
        
  if(aktuelleZeit - letzterZustandsWechsel > Zeit_auf_Seite)
  {                                              
    letzterZustandsWechsel = aktuelleZeit;       
    switch (Seite)
    {
      case 0: page1();break;
      case 1: page2();break;
      case 2: page3();break;
      case 3: page4();break;
      case 4: page5();break;
      case 5: page6();break;
    }  
    Seite++;
    if (Seite>5) {Seite = 0; }    
   }
}
  
void page1()
{

  // OLED Display - date and weekday
    Serial.println("");
    Serial.println("Page 1 - Datum und Wochentag");
    
    DateTime now = rtc.now();   // Get current date and time:
   
    if (now.day() < 10) {day = String(0) + String(now.day());} else {day = now.day();}
    if (now.month() < 10) {month = String("0") + String(now.month());} else {month = now.month();}
    weekday = String(daysOfTheWeek[now.dayOfTheWeek()]);

    Serial.print("Datum: "); Serial.print(day); Serial.print("."); Serial.println(month);
       
    u8x8.clear();
    u8x8.setFont(u8x8_font_profont29_2x3_f);  
    
    u8x8.setCursor(3,6);
    u8x8.print(day);
    u8x8.drawString(7,6,".");       
    u8x8.setCursor(9,6);
    u8x8.print(month);
    
    u8x8.setCursor(4,11);
    u8x8.setFont(u8x8_font_7x14_1x2_r);
    u8x8.print(weekday);
}

void page2 ()
{
  
  // OLED display - time
    Serial.println("");
    Serial.println("Page 2 - Uhrzeit");
    
    DateTime now = rtc.now();   // Get current date and time:
   
    if (now.hour() < 10) {hour = String("0") + String(now.hour());} else {hour = now.hour();}
    if (now.minute() < 10) {minute = String("0") + String(now.minute()); }else {minute = now.minute();}
    
    Serial.print("Zeit: "); Serial.print(hour); Serial.print(":"); Serial.println(minute);
    
    u8x8.clear();
    u8x8.setFont(u8x8_font_profont29_2x3_f);  
         
    u8x8.setCursor(3,7);
    u8x8.print(hour);
    u8x8.drawString(7,7,":");       
    u8x8.setCursor(9,7);
    u8x8.print(minute);
    
}

void page3()
{
  // OLED display - temperature difference
  
  Serial.println("");
  Serial.println("Page 3 - Temperaturdifferenz");
  
  // save status before

  aktuelleZeitA = millis();
  Serial.print("aktuelle Zeit = "); Serial.print(aktuelleZeitA/1000/60); Serial.print(" min. - ");
  Serial.print("neuer Bezugszeitraum nach = X * "); Serial.print(bezugsgroesse/1000/60); Serial.println(" min.");
  
  if(aktuelleZeitA - letzterZustandsWechselA > bezugsgroesse)
  {
    letzterZustandsWechselA = aktuelleZeitA;
    Serial.println("********** Temp vor einer Stunde NEUER WERT **********");
    t_vorher = sensor.getTempCByIndex(0);
    EEPROM.put(t_vorher_adress, t_vorher);
    Serial.print("Temp vor einer Stunde NEU: "); Serial.print(t_vorher_adress); Serial.print(" - "); Serial.print(t_vorher);Serial.println(" C");Serial.println("");
  } 

  // compare two sensors (DHT22 <> DS18B20)

  sensor.requestTemperatures();
  t = sensor.getTempCByIndex(0);
  temperature_dht22 = dht22.readTemperature();
  Serial.print("Differenz = DS18B20: ");Serial.print(t); Serial.print(" C <> DHT22: "); Serial.print(temperature_dht22); Serial.print(" C = "); Serial.print(t-temperature_dht22); Serial.println(" C ");
  
  // Tem. sensor DS18B20 --------------------------------------------------------------

  Serial.print("DS18B20 - Temp.: "); Serial.print(t);Serial.print(" C");Serial.print(" -> "); 

  // Voltmeter Temp ----------------------------------------------------------------------

  if (t <= 20)
  {
      voltage_temp = 0;
      analogWrite(Voltmeter_Temp_PIN,voltage_temp);
      Serial.println("Temperatur <= 20 C --> Farbe blau");
      
      analogWrite(ledrot_temp,0);
      analogWrite(ledblau_temp,255);
      analogWrite(ledgruen_temp,0);
  }

  if (t > 20 && t < 28)
  {
      temp = 100 * t;
      voltage_temp = (temp-(MIN_TEMP*100))/RANGE_TEMP*255/100;
      analogWrite(Voltmeter_Temp_PIN,voltage_temp);
      Serial.println("Temperatur > 20 C & < 28 C --> keine Farbe");
      analogWrite(ledrot_temp,0);
      analogWrite(ledblau_temp,0);
      analogWrite(ledgruen_temp,0);
  }

  if (t > 28 && t < 35)
  {
        temp = 100 * t;
        voltage_temp = (temp-(MIN_TEMP*100))/RANGE_TEMP*255/100;
        analogWrite(Voltmeter_Temp_PIN,voltage_temp);
        Serial.println("Temperatur > 28 C & <= 35C --> Farbe rot");
        analogWrite(ledrot_temp,255);
        analogWrite(ledblau_temp,0);
        analogWrite(ledgruen_temp,0);        
  }

  if (t > 35)
  {
      voltage_temp = 255;
      analogWrite(Voltmeter_Temp_PIN,voltage_temp);
      Serial.println("Temperatur > 35 C --> Farbe rot");
      analogWrite(ledrot_temp,255);
      analogWrite(ledblau_temp,0);
      analogWrite(ledgruen_temp,0);
  }
   
  // OLED Display - temperature

    u8x8.clear();
    t_vorher = EEPROM.put(t_vorher_adress, t_vorher);   // LSCHEN
    t_diff = t - t_vorher;
    Serial.print("Temp.differenz: "); Serial.print(t_diff);Serial.print(" = "); Serial.print(t);Serial.print(" - "); Serial.println(t_vorher);

    if (t_diff >= 0)
    {
      u8x8.setFont(u8x8_font_7x14_1x2_r);
      u8x8.setCursor(3,10);
      u8x8.print(positiv);
      Serial.print("Vorzeichen= "); Serial.println(positiv);
    }
    else
    {
    Serial.print("Vorzeichen= "); Serial.println("negativ");
    }

    u8x8.setFont(u8x8_font_profont29_2x3_f);
    u8x8.setCursor(2,4);
    u8x8.print(t);
    u8x8.drawString(10,4," C");       

    u8x8.setFont(u8x8_font_7x14_1x2_r);
    u8x8.setCursor(5,10);
    u8x8.print(t_diff);
    u8x8.drawString(9,10," C");
    u8x8.drawString(0,13,"gg. Stunde davor");           
   
}

void page4()
{
  Serial.println("");
  Serial.println("Page 4 - Temp. MAX und MIN");
  
  // OLED Display - temperature MAX, MIN
    
    if (t > (EEPROM.get(t_max_adress, t_max)))
    {
      Serial.println ("********** EEPROM-Wert MAX Korrektur **********");
      Serial.print ("alter EEPROM-Wert MAX: "); Serial.println(EEPROM.get(t_max_adress, t_max));
      t_max = t;
      EEPROM.put(t_max_adress, t_max);
      Serial.print ("neuer EEPROM-Wert MAX: "); Serial.println(EEPROM.get(t_max_adress, t_max));
      t_max_hour = hour;
      EEPROM.put(t_max_hour_adress, t_max_hour);
      t_max_minute = minute;
      EEPROM.put(t_max_minute_adress, t_max_minute);
      t_max_day = day;
      EEPROM.put(t_max_day_adress, t_max_day);
      t_max_month = month;
      EEPROM.put(t_max_month_adress, t_max_month);
      Serial.print ("neuer EEPROM-Wert MAX_Time: ");
      Serial.print(EEPROM.get(t_max_day_adress, t_max_day));
      Serial.print(".");
      Serial.print(EEPROM.get(t_max_month_adress, t_max_month));
      Serial.print(" ");
      Serial.print(EEPROM.get(t_max_hour_adress, t_max_hour));
      Serial.print(":");
      Serial.println(EEPROM.get(t_max_minute_adress, t_max_minute));
    }
    else
    {
    Serial.println ("kein neuer EEPROM-Wert MAX_Time");
    }
    
    if (t < (EEPROM.get(t_min_adress, t_min)) && t > 1)       // Avoid measuring errors (-127 C) of the sensor when displaying the minimum temperature
    {
      Serial.println ("********** EEPROM-Wert MIN Korrektur **********");
      Serial.print ("alter EEPROM-Wert MIN: "); Serial.println(EEPROM.get(t_min_adress, t_min));
      t_min = t;
      EEPROM.put(t_min_adress, t_min);
      Serial.print ("neuer EEPROM-Wert MIN: "); Serial.println(EEPROM.get(t_min_adress, t_min));
      t_min_hour = hour;
      EEPROM.put(t_min_hour_adress, t_min_hour);
      t_min_minute = minute;
      EEPROM.put(t_min_minute_adress, t_min_minute);
      t_min_day = day;
      EEPROM.put(t_min_day_adress, t_min_day);
      t_min_month = month;
      EEPROM.put(t_min_month_adress, t_min_month);
      Serial.print ("neuer EEPROM-Wert MIN_Time: ");
      Serial.print(EEPROM.get(t_min_day_adress, t_min_day));
      Serial.print(".");
      Serial.print(EEPROM.get(t_min_month_adress, t_min_month));
      Serial.print(" ");
      Serial.print(EEPROM.get(t_min_hour_adress, t_min_hour));
      Serial.print(":");
      Serial.println(EEPROM.get(t_min_minute_adress, t_min_minute));
    }
    else
    {
    Serial.println ("kein neuer EEPROM-Wert MIN_Time");
    }

    u8x8.clear();
    u8x8.setFont(u8x8_font_7x14_1x2_r);  
  
    u8x8.drawString(0,2,"Temp.MAX");       
    
    u8x8.setCursor(2,4); u8x8.print(EEPROM.get(t_max_adress, t_max)); u8x8.drawString(6,4," C");
    
    u8x8.setCursor(2,6); u8x8.print(EEPROM.get(t_max_day_adress, t_max_day));
    u8x8.drawString(4,6,".");  
    
    u8x8.setCursor(5,6); u8x8.print(EEPROM.get(t_max_month_adress, t_max_month));
    u8x8.drawString(7,6," ");

    u8x8.setCursor(8,6); u8x8.print(EEPROM.get(t_max_hour_adress, t_max_hour));
    u8x8.drawString(10,6,":");

    u8x8.setCursor(11,6); u8x8.print(EEPROM.get(t_max_minute_adress, t_max_minute));

    
    u8x8.drawString(0,9,"Temp.MIN");       
    
    u8x8.setCursor(2,11); u8x8.print(EEPROM.get(t_min_adress, t_min)); u8x8.drawString(6,11," C");
    
    u8x8.setCursor(2,13); u8x8.print(EEPROM.get(t_min_day_adress, t_min_day));
    u8x8.drawString(4,13,".");  
    
    u8x8.setCursor(5,13); u8x8.print(EEPROM.get(t_min_month_adress, t_min_month));
    u8x8.drawString(7,13," ");

    u8x8.setCursor(8,13); u8x8.print(EEPROM.get(t_min_hour_adress, t_min_hour));
    u8x8.drawString(10,13,":");

    u8x8.setCursor(11,13); u8x8.print(EEPROM.get(t_min_minute_adress, t_min_minute));
      
}

void page5()
{
  Serial.println("");
  Serial.println("Page 5 - Luftfeuchte");
  
  // Voltmeter Hygrometer

  humidity = dht22.readHumidity();
  Serial.print("DHT22 - Feuchtigkeit: "); Serial.print(humidity);Serial.print(" % - ");
  
  voltage_Hygro = humidity*255/100;
  analogWrite(Voltmeter_Hygro_PIN,voltage_Hygro);

  if (humidity >80 || humidity <20)
  {
      Serial.println("Feuchtigkeit <20 oder >80 --> rot");
      analogWrite(ledrot_hygro,255);
      analogWrite(ledblau_hygro,0);
      analogWrite(ledgruen_hygro,0);
  }

  if (humidity <80 || humidity >20)
  {
      Serial.println("Feuchtigkeit zw. 20 und 80 --> keine Farbe");
      analogWrite(ledrot_hygro,0);
      analogWrite(ledblau_hygro,0);
      analogWrite(ledgruen_hygro,0);
  }

    
  // Display Hygrometer  
        
    u8x8.clear();
    u8x8.setFont(u8x8_font_7x14_1x2_r);  

    u8x8.drawString(3,2,"Luftfeuchte"); 
        
    u8x8.setCursor(5,5); u8x8.print(humidity);
    u8x8.drawString(11,5,"%"); 
        
    u8x8.setCursor(4,8); u8x8.print("zu feucht");
    u8x8.setCursor(4,10); u8x8.print("normal");
    u8x8.setCursor(4,12); u8x8.print("zu trocken");
        
    int x = 8;
            
    if (humidity > 65)
    {
        x = x+0;
    }
    else if (humidity > 40 && humidity < 65)
    {
        x = x+2;
    }
    else if (humidity < 40)
    {
        x = x+4;
    }

    u8x8.setCursor(2,x); u8x8.print("X");
}


void page6()
{
  Serial.println("");
  Serial.println("Page 6 - Luftqualitt");
  
  // air quality 

    Serial.print("Grove Air quality - Luftguete: ");
    Serial.println(sensore.slope());
        
    u8x8.clear();
    u8x8.setFont(u8x8_font_7x14_1x2_r);  

    u8x8.drawString(3,2,"Luftguete"); 
    
    u8x8.setCursor(4,6); u8x8.print("ALARM!");
    u8x8.setCursor(4,8); u8x8.print("Schlecht");
    u8x8.setCursor(4,10); u8x8.print("Mittel");
    u8x8.setCursor(4,12); u8x8.print("Frischluft");
    
    int x = 6;
            
    if (sensore.slope() == 0)
    {
        x = x+0;
        Serial.println("Air Quality: ALARM!");
    }
    else if (sensore.slope() == 1)
    {
        x = x+2;
        Serial.println("Air Quality: Schlecht");
    }
    else if (sensore.slope() == 2)
    {
        x = x+4;
        Serial.println("Air Quality: Mittel");
    }
    else if (sensore.slope() == 3)
    {
        x = x+6;
        Serial.println("Air Quality: Frischluft");
    }

    u8x8.setCursor(2,x); u8x8.print("X");    
}