Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- arduino:flaschenkuehler:programmversion_0.3 [23.07.2017 10:54] – Frickelpiet
+++ arduino:flaschenkuehler:programmversion_0.3 [27.10.2018 08:01] – Frickelpiet
@@ Zeile 12: / Zeile 12: @@
 Eine erhebliche Beschleunigung der Ausführung des Codes (nämlich um ca. 229 %) konnte dadurch erreicht werden, den PID-Regler nicht in jeder Programmschleife einmal auszuführen, sondern nur alle 10 Millisekunden.
+<code>
+// Flaschenkühler - Programmversion 0.3
+// Diese Version steuert einen PC-Lüfter mit 4-Pin-Anschluss ...
+// ... liest das Tachosignal aus ...
+// ... berechnet die Drehzahl des Lüfters ...
+// ... liest einen Thermistor aus und berechnet die Temperatur ...
+// ... stellt über ein Poti die ZieltemperatureHotSidee ein ...
+// ... regelt den Lüfter mit einem PID-Modul ...
+// ... zeigt verschiedene Werte auf einem OLED-Display an ...
+// ... zählt die Betriebsstunden (viertelstundengenau) und speichert sie im EEPROM ...
+// ... pollt die Taster und speichert die Solltemperatur im EEPROM.
+//------------------------- Eingebundene Bibliotheken ---------------------//
+#include <Adafruit_GFX.h>         // Grafik-Bibliothek für OLED-Display
+#include <Adafruit_SSD1351.h>     // Bibliothek für OLED-Display (Adafruit OLED Breakout Board 1.27")
+#include <SPI.h>                  // Bibliothek Serial Peripheral Interface (SPI)
+#include <PWM.h>                  // Bibliothek für Änderung der Frequenz der Timer
+#include <RunningAverage.h>       // Bibliothek für Berechnung von Mittelwerten
+#include <ResponsiveAnalogRead.h> // Bibliothek zur Glättung analoger Inpots
+#include <PID_v1.h>               // Bibliothek für PID-Regler
+#include <ButtonEvents.h>         // Bibliothek zum Entprellen der Taster
+#include <EEPROMex.h>             // Bibliothek für Lesen und Schreiben des EEPROMS
-Tags: #Arduino #Flaschenkühler #Peltier
+//------------------------- Definition der Inputs und Outputs ---------------------//
+#define potiPin         A0        // Input-Pin für den Lüfter
+#define thermistorPin   A1        // Input-Pin für den Thermistor
+#define tachoPin        2         // Pin für Tachosignal des Lüfters
+#define peltierPin      3         // PWM-Pin für Peltier-Element (hier zunächst nur als Funktionstest)
+#define powerPin        4         // Schaltet den MOSFET für den Lüfter
+#define dc              5         //
+#define cs              6         // Chip Select
+#define rst             7         // Reset
+#define button1Pin      8         // Taster 1
+#define fanPin          9         // PWM-Pin für Lüfter
+#define button2Pin      12        // Taster 2
+//------------------------- Definition der Farben ---------------------//
+#define BLACK           0x0000
+#define BLUE            0x0418
+#define BLUEBERRY       0xF810
+#define RED             0xF800
+#define GREEN           0x07E0
+#define CYAN            0x07FF
+#define MAGENTA         0xF81F
+#define YELLOW          0xFFE0
+#define WHITE           0xFFFF
+//------------------------- Definition der Variablen ---------------------//
+float thermistorValue = 0;         // Variable in der der Wert des Thermistors gespeichert wird
+int potiValue = 0;                 // variable to store the value coming from the sensor
+// PWM Frequenzen
+uint16_t frequencyFan = 25000;     // PWM-Frequenz für den Lüfter (in Hz)
+uint16_t frequencyPeltier = 50000; // PWM-Frequenz für den Lüfter (in Hz)
+// Lüfter
+int tachoSignal;                   // Tachosignal
+uint32_t pulseOn = 0;              // Ansteigende Signalflanke (Variablenformat nicht verändern!)
+uint32_t pulseOff = 0;             // Abfallende Signalflanke (Variablenformat nicht verändern!)
+uint32_t duration;                 // Zeit in Mikrosekunden zwischen ansteigender und abfallender Flanke (Variablenformat nicht verändern!)
+bool high = false;                 // Statevariable
+int rpm = 0;                       // Drehzahl des Lüfters in U/Min
+float rpmAverage = 0;              // Gemittelte Drehzahl des Lüfters in U/min
+bool fanAlert = false;             // Wird wahr, wenn der Lüfter blockiert ist
+bool fanAlertState = true;
+unsigned long fanAlertDelay = 2000;// Gibt die Verzögerung des Alarms "Lüfterfehlfunktion" in Millisekunden an
+unsigned long previousMillis = 0;
+// Temperaturen
+float temperatureHotSide = 0;
+float previousTempHotSide = 0;     // Wird verwendet um festzustellen, ob die Anzeige der Isttemperatur auf dem OLED-Display aktualisiert werden muss.
+// Betriebsstundenzähler und Serviceintervall
+float operatingTime;               // Betriebsstunden als Dezimalwert
+long lastTime = 0;
+float serviceInterval;             // Serviceintervall als Dezimalwert
+bool serviceIntervalReset = false; // Wird wahr, wenn das Service Intervall zurückgesetzt wird
+// Adressen im EEPROM
+int addrOperatingTime = 0;         // Startadresse für eine Variable im Datentyp float (4 Byte!)
+int addrTargetTemp = 4;            // Startadresse für eine Variable im Datentyp double (8 Byte!)
+int addrDisplayMode = 13;          // Adresse für den Anzeigemodus (2 Byte reserviert)
+int addrServiceInterval = 15;      // Startadresse für eine Variable im Datentyp float (4 Byte!)
+// Definiert das OLED
+Adafruit_SSD1351 tft = Adafruit_SSD1351(cs, dc, rst);
+// Definiert ein Array, aus dem Farbwerte ausgelesen werden
+unsigned long colors[] = {0x07FF, 0x07DF, 0x077F, 0x06FF, 0x069F, 0x063F, 0x05DF, 0x057F, 0x053F, 0x049F, 0x043F, 0x03DF, 0x037F, 0x031F, 0x029F, 0x023F, 0x01DF, 0x017F, 0x011F, 0x009F,
+x003F, 0x001F, 0x101F, 0x201F, 0x281F, 0x381F, 0x401F,0x501F, 0x601F, 0x681F, 0x781F, 0x801F, 0x901F, 0x981F, 0xA81F, 0xB81F, 0xC01F, 0xD01F, 0xD81F, 0xE81F,
+xF81F, 0xF81F, 0xF81D, 0xF81B, 0xF81A, 0xF818, 0xF817, 0xF815, 0xF813, 0xF812, 0xF810, 0xF80F, 0xF80D, 0xF80C, 0xF80A, 0xF808, 0xF807, 0xF805, 0xF804, 0xF802, 0xF800};
+// Informationsanzeige
+int displayMode;                   // Anzeigemodus ("0" = Einfach; "1" = Erweitert; "2" = grafisch)
+bool refreshPeltier = true;        // Wird wahr, wenn der Anzeigebereich für das Peltier-Element aktualisiert werden muss
+bool refreshTargettemp = true;     // Wird wahr, wenn der Anzeigebereich für die Solltemperatur aktualisiert werden muss
+//bool refreshActualtemp = true;
+bool refreshFan = true;            // Wird wahr, wenn der Anzeigebereich für den Lüfter aktualisiert werden muss
+int x = 0;
+// Instantiiert ButtonEvents-Objekte
+ButtonEvents button1;
+ButtonEvents button2;
+// Instantiiert ein RunningAverage-Objekt zur Bechnung von Mittelwerten
+RunningAverage averageRPM(25);         // Mittelwert aus 25 Messungen
+// Instantiirt ResponsiveAnalogRead-Objekte zur Glättung der analogen Inputs
+ResponsiveAnalogRead analog(thermistorPin, true);
+// Definiert den PID-Regler
+double Setpoint, Input, Output;
+double Kp=2, Ki=5, Kd=1;
+PID fanPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, REVERSE);
+// Definiert die Tracking-Variablen für die IF-Abfragen
+unsigned long previousMillisCalculateTemperatures = 0; // Auslesen der analogen Inputs und Berechnung der Temperaturen
+unsigned long previousMillisCalculatePID = 0;          // Berechnung der PID-Regler (Lüfter und Peltier-Element)
+unsigned long previousMillisCalculateFanSpeed = 0;     // Berechnung der Drehzahl des Lüfters
+unsigned long previousMillisDisplayActualtemp = 0;     // Ausgabe der Ist-Temperatur an das OLED-Display
+unsigned long previousMillisDisplayFanSpeed = 0;       // Ausgabe der gemittelten Lüfterdrehzahl an das OLED-Display
+unsigned long previousMillisDisplayGraph = 0;          // Ausgabe der gemittelten Lüfterdrehzahl an das OLED-Display
+unsigned long previousMillisSerialPrint = 0;           // Ausgabe an die serielle Schnittstelle
+// Definiert die Intervalle für die IF-Abfragen in Millisekunden
+const unsigned long intervalCalculateTemperatures = 10;// Auslesen der analogen Inputs und Berechnung der Temperaturen
+const unsigned long intervalCalculatePID = 10;         // Berechnung der PID-Regler (Lüfter und Peltier-Element)
+const unsigned long intervalCalculateFanSpeed = 100;   // Berechnung der Drehzahl des Lüfters
+const unsigned long intervalDisplayActualtemp = 500;   // Ausgabe der Ist-Temperatur an das OLED-Display
+const unsigned long intervalDisplayFanSpeed = 500;     // Ausgabe der gemittelten Lüfterdrehzahl an das OLED-Display
+const unsigned long intervalDisplayGraph = 1000;       // Ausgabe der gemittelten Lüfterdrehzahl an das OLED-Display
+const unsigned long intervalSerialPrint = 500;         // Ausgabe an die serielle Schnittstelle
+int loopCounter = 0;
+//------------------------- Setup ---------------------//
+void setup() {
+  Serial.begin(115200);
+  // Initialisiert das OLED-Dispaly
+  tft.begin();
+  // Definiert die Pins
+  pinMode(tachoPin, INPUT_PULLUP);                    // Tachosignal des Lüfters
+  pinMode(powerPin, OUTPUT);                          // Schaltet den MOSFET für den Lüfter
+  pinMode(fanPin, OUTPUT);                            // PWM-Signal für Lüfter
+  pinMode(peltierPin, OUTPUT);                        // PWM-Signal für Peltier-Element
+  pinMode(button1Pin, INPUT_PULLUP);                  // Intur Taster 1
+  pinMode(button2Pin, INPUT_PULLUP);                  // Input Taster 2
+  // Initialisiert die ButtonEvents-Objekte
+  button1.attach(button1Pin);
+  button1.debounceTime(10);
+  button1.doubleTapTime(70);
+  button1.holdTime(1000);
+  button2.attach(button2Pin);
+  button2.debounceTime(10);
+  button2.doubleTapTime(70);
+  button2.holdTime(1000);
+  // Initialisiert timer1 und timer2 (timer0 bleibt unberührt)
+  InitTimersSafe();
+  // Definiert die Frequenzen für die angegebenen Pins
+  bool successFan = SetPinFrequencySafe(fanPin, frequencyFan);
+  bool successPeltier = SetPinFrequencySafe(peltierPin, frequencyPeltier);
+  /*
+  //if the pin frequency was set successfully, turn pin 13 on
+  if(successFan) {
+    pinMode(13, OUTPUT);
+    digitalWrite(13, HIGH);
+    Serial.print("PWM frequency PIN D9 and D10 is set to: "); Serial.println(frequencyFan);
+  }
+  if(successPeltier) {
+    Serial.print("PWM frequency PIN D3 and D11 is set to: "); Serial.println(frequencyPeltier);
+  }
+  */
+  // Initialisiert die PID-Regler
+  fanPID.SetMode(AUTOMATIC);
+  // Liest die im EEPROM gespeicherten Variablen aus
+  displayMode = EEPROM.read(addrDisplayMode);
+  operatingTime = EEPROM.readFloat(addrOperatingTime);
+  serviceInterval = EEPROM.readFloat(addrServiceInterval);
+  Setpoint = EEPROM.readDouble(addrTargetTemp);
+  //operatingTime = 0;                 // Soll auf "0" gesetzt werden, bis die Testphase abgeschlossen ist
+  //Setpoint = 0;
+  //serviceInterval = 0;
+  // Meldung "Klar zum Start!"
+  Serial.println("<Arduino is ready! Turn the potentiometer, please ...>");
+  Serial.print("<Operating Time of the System: "); Serial.print(operatingTime); Serial.println(" hours>");
+  Serial.print("<Service Interval: "); Serial.print(serviceInterval); Serial.println(" hours>");
+  // Startbildschirm
+  tft.fillScreen(BLACK);
+  tft.setCursor(25, 32);
+  tft.setTextColor(WHITE, BLACK);
+  tft.setTextSize(0);
+  tft.print("Flaschenk"); tft.print((char)154); tft.print("hler");
+  tft.setCursor(20, 55);
+  tft.print("Programmversion");
+  tft.setCursor(45, 75);
+  tft.setTextSize(2);
+  tft.print("0.3");
+  if (serviceInterval >= 1.00) {
+    tft.setCursor(0, 96);
+    tft.setTextColor(RED, BLACK);
+    tft.setTextSize(0);
+  tft.print("Reinigung empfohlen!");
+  }
+  tft.setCursor(10, 108);
+  tft.setTextColor(WHITE, BLACK);
+  tft.setTextSize(0);
+  tft.print("Betriebsstunden:");
+  tft.setCursor(10, 121);
+  tft.print(operatingTime); tft.print(" Stunden");
+  delay(2000);
+  tft.fillScreen(BLACK);
+}
+//------------------------- Loop ---------------------//
+void loop() {
+  // Aktuelle Zeit abfragen
+  unsigned long currentMillis = millis();
+loopCounter++;
+//------------------------- Abfrage der Taster ---------------------//
+// Lesen und entprellen des Tasters
+  button1.update();
+  button2.update();
+  if (button1.tapped() == true) {
+    Setpoint = Setpoint + 0.5;
+    EEPROM.updateDouble(addrTargetTemp, Setpoint);
+    //Serial.print("Updated Setpoint: "); Serial.println(Setpoint);
+    refreshTargettemp = true;
+    if (Setpoint >= 30.00) {
+      Setpoint = 30.00;
+    }
+  }
+  if (button1.held() == true) {
+    displayMode++;
+    if (displayMode > 2) {
+      displayMode = 0;
+    }
+    tft.fillScreen(BLACK);                       // Der Bildschirm muss einmalig gelöscht werden
+    EEPROM.update(addrDisplayMode, displayMode);
+    //Serial.print("Displaymode: "); Serial.println(displayMode);
+    refreshPeltier = true;
+    refreshTargettemp = true;
+    previousTempHotSide = 150;
+    refreshFan= true;
+    x = 0;
+  }
+  if (button1.doubleTapped() == true) {
+    serviceInterval = 0;
+    EEPROM.updateFloat(addrServiceInterval, serviceInterval);
+    Serial.println("Service Interval reseted!");
+    serviceIntervalReset = true;
+  }
+  if (button2.tapped() == true) {
+    Setpoint = Setpoint - 0.5;
+    EEPROM.updateDouble(addrTargetTemp, Setpoint);
+    //Serial.print("Updated Setpoint: "); Serial.println(Setpoint);
+    refreshTargettemp = true;
+    if (Setpoint <= 0.00) {
+      Setpoint = 0.00;
+    }
+  }
+  if (button2.held() == true) {
+    displayMode--;
+    if (displayMode < 0) {
+      displayMode = 2;
+    }
+    tft.fillScreen(BLACK);                       // Der Bildschirm muss einmalig gelöscht werden
+    EEPROM.update(addrDisplayMode, displayMode);
+    //Serial.print("Displaymode: "); Serial.println(displayMode);
+    refreshPeltier = true;
+    refreshTargettemp = true;
+    previousTempHotSide = 150;
+    refreshFan= true;
+    x = 0;
+  }
+//------------------------- Auslesen der analogen Inputs (Thermistoren) und Berechnung der Temperaturen ---------------------//
+  if ((unsigned long)(currentMillis - previousMillisCalculateTemperatures) >= intervalCalculateTemperatures) {
+    // Lese die analogen Inputs aus
+    potiValue = analogRead(potiPin);                    // Poti
+    analog.update();                                    // Das ResponsiveAnalogRead-Objekt wird aktualisiert
+    thermistorValue = analog.getValue();                // Das Ergebnis wird ausgelesen
+    // Berechnung der Temperatur
+    thermistorValue = 1023 / thermistorValue - 1;
+    thermistorValue = 10000 / thermistorValue;          // Der Wert wird in einen Widerstand umgerechnet
+    //float temperatureHotSide;
+    temperatureHotSide = thermistorValue / 10000;       // (R/Ro)
+    temperatureHotSide = log(temperatureHotSide);       // ln(R/Ro)
+    temperatureHotSide /= 3950;                         // 1/B * ln(R/Ro)
+    temperatureHotSide += 1.0 / (25 + 273.15);          // + (1/To)
+    temperatureHotSide = 1.0 / temperatureHotSide;      // Invert
+    temperatureHotSide -= 273.15;                       // convert to C
+    previousMillisCalculateTemperatures = currentMillis;
+  }
+//------------------------- Regelung des Lüfters (TEST) ---------------------//
+  if ((unsigned long)(currentMillis - previousMillisCalculatePID) >= intervalCalculatePID) {
+    Input = temperatureHotSide;                                 // Input ist die temperatureHotSide des Thermistors in *C
+    fanPID.Compute();                                   // PID-Regler wir aufgerufen
+    pwmWrite(fanPin, Output);                           // Gibt den Output des PID-Reglers an den Lüfter
+    // Wenn der Output des PID-Reglers Null ist, wird der Lüfter ausgeschaltet.
+    if (Output > 0) {
+      digitalWrite(powerPin, HIGH);
+      //Serial.print("HIGH"); Serial.print("; ");
+    }
+    else {
+      digitalWrite(powerPin, LOW);
+      //Serial.print("LOW"); Serial.print("; ");
+    }
+    //use this functions instead of analogWrite on 'initialized' pins
+    pwmWrite(peltierPin, potiValue / 4);                // Nur zu Testzwecken
+    previousMillisCalculatePID = currentMillis;
+  }
+//------------------------- Tachosignal und Drehzahl des Lüfters ---------------------//
+  // Messung der Pulsweite des Tachosignals
+  tachoSignal = digitalRead(tachoPin);
+  if (tachoSignal == HIGH && high != true) {          // Zeit in micros bei ansteigender Flanke
+    pulseOn = micros();
+    high = true;
+  }
+  else if (tachoSignal == LOW && high == true) {
+    pulseOff = micros();                              // Zeit in micros bei fallender Flanke
+    high = false;
+    duration = pulseOff - pulseOn;                    // Aus der Differenz wir die Dauer berechnet, die das Tachosignal HIGH ist
+    if (duration > 7000 && duration < 150000) {       // Liegt die Variable über bzw. unter den angegebenen Werten, liegt ein Messfehler vor
+      rpm = float(100000 * 2 * 60 / duration);        // Berechnung der RPM
+    }
+    else {
+      rpm = 0;
+    }
+    //averageRPM.addValue(rpm);
+  }
+  // Berechnung der gemittelten Drehzahl des Lüfters
+  if ((unsigned long)(currentMillis - previousMillisCalculateFanSpeed) >= intervalCalculateFanSpeed) {
+    averageRPM.addValue(rpm);                         // Aktualisiert das RunningAverage-Objekt
+    // Wenn der Lüfter angehalten wird, soll die Drehzahl "0" angezeigt werden
+    if (Output == 0) {
+      rpm = 0;
+      averageRPM.addValue(rpm);
+    }
+    // Liest die durchschnittliche Drehzahl aus und speichert das Ergebnis in eine Variable
+    rpmAverage = averageRPM.getAverage();
+    // Meldet eine Fehlfunktion des Lüfters, wenn das Tachosignal "0" ist, obwohl der Lüfter sich drehen sollte
+    if (millis() >= 10000) {                             // Diese Funktion wird erst nach 10 Sekunden aktiv.
+      if (Output > 0) {                                    // Wenn der Lüfter sich drehen sollte ...
+        if (rpmAverage == 0) {                             // ... aber die gemittelte Drehzahl gleich "0" ist ...
+          if (millis() - previousMillis > fanAlertDelay) { // ... und eine definierte Zeit verstrichen ist.
+            previousMillis = millis();
+            fanAlert = true;
+            fanAlertState = true;
+            Serial.println("Fan blocked!");
+            refreshFan = true;
+          }
+        }
+        else if (rpmAverage > 0) {                    // ... und die gemittelte Drehzahl größer "0" ist ...
+          fanAlert = false;
+        }
+      }
+      else if (Output == 0) {                         // Wenn der Lüfter sich nicht drehen soll kann nicht festgestellt werden, ob er blockiert ist.
+        fanAlert = false;
+        previousMillis = millis();                     // Muss aktualisiert werden, damit
+        if (fanAlert != fanAlertState) {
+          refreshFan = true;
+          fanAlertState = false;
+        }
+      }
+    }
+  previousMillisCalculateFanSpeed = currentMillis;
+  }
+//------------------------- Betriebsstunden ---------------------//
+// Die Betriebsstunden werden alle 15 Minuten im EEPROM gespeichert. Die Einheit der Variable operatinTime ist also 0,25 Stunden.
+  if (millis() - lastTime >= 900000) {
+    // Betriebsstundenzähler
+    operatingTime = operatingTime + 0.25;
+    lastTime = millis();
+    EEPROM.updateFloat(addrOperatingTime, operatingTime);
+    Serial.print("Updated operatingTime: "); Serial.println(operatingTime);
+    // Serviceintervallzähler
+    serviceInterval = serviceInterval + 0.25;
+    EEPROM.updateFloat(addrServiceInterval, serviceInterval);
+  }
+//------------------------- Ausgabe an das Display ---------------------//
+  // Anzeige "Serviceintervall zurückgesetzt
+  if (serviceIntervalReset == true) {
+    tft.fillScreen(BLACK);
+    tft.setCursor(15, 65);
+    tft.setTextColor(WHITE, BLACK);
+    tft.setTextSize(0);
+    tft.print("Service Intervall");
+    tft.setCursor(26, 85);
+    tft.print("zur"); tft.print((char)154); tft.print("ckgesetzt");
+    delay(2000);
+    tft.fillScreen(BLACK);
+    refreshPeltier = true;
+    refreshTargettemp = true;
+    previousTempHotSide = 150;
+    refreshFan= true;
+    serviceIntervalReset = false;
+  }
+  // Anzeigemodus "0" (einfach)
+  if (displayMode == 0) {
+    // Anzeige Infobereich Zieltemperatur
+    if (refreshTargettemp == true) {
+      tft.setCursor(15, 49);
+      int i = Setpoint * 2;                      // Berechnet den Index für den Array "colors"
+      if (i < 0) i = 0;                          // i soll nicht kleiner als "0" werden
+      if (i > 60) i = 60;                        // i soll nicht größer als "60" werden
+      tft.setTextColor(colors[i], BLACK);
+      tft.setTextSize(0);
+      tft.print("Solltemperatur");
+      tft.setCursor(15, 62);
+      tft.setTextSize(2);
+        if (Setpoint < 10.00) {
+        tft.print("0");
+      }
+      tft.print(Setpoint); tft.print(" "); tft.print((char)247); tft.print("C");
+      tft.setTextColor(BLACK, BLACK);
+      tft.print((char)218);
+      refreshTargettemp = false;
+    }
+    // Anzeige Infobereich Isttemperatur
+    if ((unsigned long)(currentMillis - previousMillisDisplayActualtemp) >= intervalSerialPrint) {
+      if (temperatureHotSide != previousTempHotSide) {
+        tft.setCursor(15, 85);
+        int i = temperatureHotSide * 2;          // Berechnet den Index für den Array "colors"
+        if (i < 0) i = 0;                        // i soll nicht kleiner als "0" werden
+        if (i > 60) i = 60;                      // i soll nicht größer als "60" werden
+        tft.setTextColor(colors[i], BLACK);
+        tft.setTextSize(0);
+        tft.print("Isttemperatur");
+        tft.setCursor(15, 98);
+        tft.setTextSize(2);
+        if (temperatureHotSide < 10.00) {
+          tft.print("0");
+        }
+        tft.print(temperatureHotSide); tft.print(" "); tft.print((char)247); tft.print("C");
+        tft.setTextColor(BLACK, BLACK);
+        tft.print((char)218);
+        previousTempHotSide = temperatureHotSide;
+      }
+      previousMillisDisplayActualtemp = currentMillis;
+    }
+  }
+  // Anzeigemodus "1" (erweitert)
+  if (displayMode == 1) {
+    // Anzeige Infobereich Peltier-Element
+    if (refreshPeltier == true) {
+      tft.setCursor(0, 32);
+      tft.setTextColor(WHITE, BLACK);
+      tft.setTextSize(0);
+      tft.print("Infos Peltier-Element");
+      refreshPeltier = false;
+    }
+    // Anzeige Infobereich Zieltemperatur
+    if (refreshTargettemp == true) {
+      tft.setCursor(15, 49);
+      int i = Setpoint * 2;                      // Berechnet den Index für den Array "colors"
+      if (i < 0) i = 0;                          // i soll nicht kleiner als "0" werden
+      if (i > 60) i = 60;                        // i soll nicht größer als "60" werden
+      tft.setTextColor(colors[i], BLACK);
+      tft.setTextSize(0);
+      tft.print("Solltemperatur");
+      tft.setCursor(15, 62);
+      tft.setTextSize(2);
+        if (Setpoint < 10.00) {
+        tft.print("0");
+      }
+      tft.print(Setpoint); tft.print(" "); tft.print((char)247); tft.print("C");
+      tft.setTextColor(BLACK, BLACK);
+      tft.print((char)218);
+      refreshTargettemp = false;
+    }
+    // Anzeige Infobereich Isttemperatur
+    if ((unsigned long)(currentMillis - previousMillisDisplayActualtemp) >= intervalDisplayActualtemp) {
+      if (temperatureHotSide != previousTempHotSide) {
+        tft.setCursor(15, 85);
+        int i = temperatureHotSide * 2;          // Berechnet den Index für den Array "colors"
+        if (i < 0) i = 0;                        // i soll nicht kleiner als "0" werden
+        if (i > 60) i = 60;                      // i soll nicht größer als "60" werden
+        tft.setTextColor(colors[i], BLACK);
+        tft.setTextSize(0);
+        tft.print("Isttemperatur");
+        tft.setCursor(15, 98);
+        tft.setTextSize(2);
+        if (temperatureHotSide < 10.00) {
+          tft.print("0");
+        }
+        tft.print(temperatureHotSide); tft.print(" "); tft.print((char)247); tft.print("C");
+        tft.setTextColor(BLACK, BLACK);
+        tft.print((char)218);
+        previousTempHotSide = temperatureHotSide;
+      }
+      previousMillisDisplayActualtemp = currentMillis;
+    }
+    // Anzeige Infobereich Lüfter
+    if (fanAlert == true) {
+      if (refreshFan == true) {
+        tft.setCursor(0, 121);
+        tft.setTextSize(0);
+        tft.setTextColor(RED, BLACK);
+        tft.print("L"); tft.print((char)154); tft.print("fterfehlfunktion!");
+        refreshFan = false;
+      }
+    }
+    else if (fanAlert == false) {
+      if (rpmAverage > 0) {                    // Wenn die Drehzahl größer "0" ist, aktualisiere den Anzeigebereich all 500 Millisekunden
+        if ((unsigned long)(currentMillis - previousMillisDisplayFanSpeed) >= intervalDisplayFanSpeed) {
+          tft.setCursor(0, 121);
+          tft.setTextSize(0);
+          tft.setTextColor(WHITE, BLACK);
+          tft.print("L"); tft.print((char)154); tft.print("fter ");  tft.print(int(rpmAverage)); tft.print(" U/min");
+          tft.setTextColor(BLACK, BLACK);
+          for (int i=0; i<5; i++) {            // Füllt die Zeile mit schwarzen Kästchen; i muss ggf. angepasst werden
+            tft.print((char)218);
+          }
+          refreshFan = true;
+          previousMillisDisplayFanSpeed = currentMillis;
+        }
+      }
+      else if (rpmAverage == 0) {
+        if (refreshFan == true) {
+          tft.setCursor(0, 121);
+          tft.setTextSize(0);
+          tft.setTextColor(WHITE, BLACK);
+          tft.print("L"); tft.print((char)154); tft.print("fter aus");
+          tft.setTextColor(BLACK, BLACK);
+          for (int i=0; i<12; i++) {            // Füllt die Zeile mit schwarzen Kästchen; i muss ggf. angepasst werden
+            tft.print((char)218);
+          }
+          refreshFan = false;
+        }
+      }
+    }
+  }
+  // Anzeigemodus "2" (grafisch)
+  if (displayMode == 2) {
+    // Anzeige Isttemperatur
+    if ((unsigned long)(currentMillis - previousMillisDisplayActualtemp) >= intervalDisplayActualtemp) {
+      if (temperatureHotSide != previousTempHotSide) {
+        tft.setCursor(0, 32);
+        tft.setTextSize(0);
+        int i = temperatureHotSide * 2;                      // Berechnet den Index für den Array "colors"
+        if (i < 0) i = 0;                          // i soll nicht kleiner als "0" werden
+        if (i > 60) i = 60;                        // i soll nicht größer als "60" werden
+        tft.setTextColor(colors[i], BLACK);
+        tft.print("Ist ");
+        if (temperatureHotSide < 10.00) {
+          tft.print("0");
+        }
+        tft.print(temperatureHotSide);
+        tft.setTextColor(BLACK, BLACK);
+        tft.print((char)218);
+        previousTempHotSide = temperatureHotSide;
+      }
+      previousMillisDisplayActualtemp = currentMillis;
+    }
+    // Anzeige Solltemperatur
+    if (refreshTargettemp == true) {
+      tft.setCursor(64, 32);
+      tft.setTextColor(WHITE, BLACK);
+      tft.setTextSize(0);
+      tft.print("Soll ");
+        if (Setpoint < 10.00) {
+        tft.print("0");
+        }
+      tft.print(Setpoint);
+      refreshTargettemp = false;
+    }
+    // Anzeige Graphen
+    if ((unsigned long)(currentMillis - previousMillisDisplayGraph) >= intervalDisplayGraph) {
+      x++;
+      if (x >= 128) {
+        x = 0;
+        //tft.fillScreen(BLACK);
+        tft.fillRect(0, 40, 128, 80, BLACK);
+        //tft.drawLine(0, 44, 127, 44, WHITE);
+        //tft.drawLine(0, 114, 127, 114, WHITE);
+        //previousTempHotSide = 150;
+        //refreshTargettemp = true;
+        //refreshFan = true;
+        //refreshPeltier = true;
+      }
+      // Graph Solltemperatur
+      int y = 114 - Setpoint * 2;
+      tft.drawPixel(x, y, WHITE);
+      // Graph Isttemperatur
+      int z = 114 - temperatureHotSide *2;
+      int i = temperatureHotSide * 2;                      // Berechnet den Index für den Array "colors"
+      if (i < 0) i = 0;                          // i soll nicht kleiner als "0" werden
+      if (i > 60) i = 60;                        // i soll nicht größer als "60" werden
+      tft.drawPixel(x, z, colors[i]);
+      // Graph Lüfterdrehzahl
+      int d = 114 - rpmAverage / 21;
+      tft.drawPixel(x, d, BLUE);
+      //Serial.print("x = ");Serial.print(x);
+      //Serial.print("; y = ");Serial.print(y);
+      //Serial.print("; z = ");Serial.print(z);
+      //Serial.print("; d = ");Serial.println(d);
+    // Anzeige Peltier-Element
+    if (refreshPeltier == true) {
+      tft.setCursor(0, 121);
+      tft.setTextColor(BLUEBERRY, BLACK);
+      tft.setTextSize(0);
+      tft.print("Peltier");
+      refreshPeltier = false;
+    }
+    // Anzeige Lüfter
+    if (rpmAverage > 0) {
+      if ((unsigned long)(currentMillis - previousMillisDisplayFanSpeed) >= intervalDisplayFanSpeed) {
+        tft.setCursor(60, 121);
+        tft.setTextSize(0);
+        tft.setTextColor(BLUE, BLACK);
+        tft.print(" U/min "); tft.print(int(rpmAverage));
+        tft.setTextColor(BLACK, BLACK);
+        for (int i=0; i<3; i++) {            // Füllt die Zeile mit schwarzen Kästchen; i muss ggf. angepasst werden
+          tft.print((char)218);
+        }
+        refreshFan = true;
+        previousMillisDisplayFanSpeed = currentMillis;
+      }
+    }
+    if (rpmAverage == 0) {
+      if (refreshFan == true) {
+        tft.setCursor(60, 121);
+        tft.setTextSize(0);
+        tft.setTextColor(BLUE, BLACK);
+        tft.print(int(rpmAverage)); tft.print(" U/min");
+        tft.setTextColor(BLACK, BLACK);
+        for (int i=0; i<3; i++) {            // Füllt die Zeile mit schwarzen Kästchen; i muss ggf. angepasst werden
+          tft.print((char)218);
+        }
+        refreshFan = false;
+      }
+    }
+    previousMillisDisplayGraph = currentMillis;
+    }
+  }
+//------------------------- Ausgabe an die serielle Schnittstelle ---------------------//
+  if ((unsigned long)(currentMillis - previousMillisSerialPrint) >= intervalSerialPrint) {
+    // Ausgabe für den seriellen Monitor
+    Serial.print("Setpoint: ");Serial.print(Setpoint);
+    Serial.print("; Input: ");Serial.print(Input);
+    Serial.print("; Output: ");Serial.print(Output);
+    //Serial.print("; pulseOn: ");Serial.print(pulseOn);
+    //Serial.print("; pulseOff: ");Serial.print(pulseOff);
+    //Serial.print("; Duration: "); Serial.print(duration);
+    Serial.print("; RPM: "); Serial.print(rpm);
+    Serial.print("; average RPM: "); Serial.print(rpmAverage);
+    //Serial.print("; fanAlert: "); Serial.print(fanAlert);
+    //Serial.print("; temperatureHotSide: "); Serial.println(temperatureHotSide);
+    Serial.print("; operatingTime: "); Serial.print(operatingTime);
+    Serial.print("; serviceInterval: "); Serial.print(serviceInterval);
+    Serial.print("; Displaymode: "); Serial.print(displayMode);
+    Serial.print("; Loops: "); Serial.println(loopCounter);
+    loopCounter = 0;
+  //Speichere die aktuelle Zeit in die zughörige Variable
+  previousMillisSerialPrint = currentMillis;
+  }
+}
+</code>
+Der Sketch verwendet 24248 Bytes (78%) des Programmspeicherplatzes. Das Maximum sind 30720 Bytes.
+Globale Variablen verwenden 1504 Bytes (73%) des dynamischen Speichers, 544 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.
+Tags: #Arduino #Flaschenkühler #OLED #Peltier