Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- arduino:flaschenkuehler:programmversion_0.2 [11.07.2017 21:24] – Frickelpiet
+++ arduino:flaschenkuehler:programmversion_0.2 [18.05.2023 12:34] (aktuell) – Externe Bearbeitung 127.0.0.1
@@ Zeile 1: / Zeile 1: @@
 ====== Flaschenkühler - Programmversion 0.2 ======
-Diese Programmversion bindet das OLED-Display ein. Für MISO und SCLK werden die Hardwarepins verwendet. Es könnten auch andere digitale Pins verwendet werden, was sich aber negativ auf die Performanz auswirken soll. Die anderen Pins können ohne Einbußen bei der Performanz frei gewählt werden.
+Diese Programmversion bindet das OLED-Display ein. Für MISO und SCLK werden die Hardwarepins verwendet. Es könnten auch andere digitale Pins verwendet werden, was sich aber negativ auf die Performanz auswirken soll. Die anderen Pins können ohne Einbußen bei der Performanz frei gewählt werden. Außerdem wurden die beiden Taster integriert, mit denen perspektivisch die Solltemperatur eingestellt können werden soll. Die eingestellte Solltemperatur wird im EEPROM gespeichert. Darüber hinaus wird die Drehzahl des Lüfters überwacht: Sollte der Lüfter sich drehen, dreht sich aber nicht, wird eine Fehlfunktion auf dem Display angegeben. Schließlich wurde noch ein Betriebsstundenzähler programmiert.
+Der Code wurde hier und da optimiert, so dass er schneller ausgeführt wird. Beispielsweise wird der Thermistor nun nur noch alle 10 Millisekunden ausgelesen und die Isttemperatur berechnet. Außerdem werden nur die Bereiche auf dem Display neu aufgebaut, die sich geändert haben.
+===== OLED-Display =====
 Das OLED-Display ist an den folgenden Pins angeschlossen:
 <code>
@@ Zeile 20: / Zeile 23: @@
   * Character Map: https://community.arduboy.com/t/a-small-program-to-display-the-font/145/3
-Außerdem soll ein Betriebsstundenzähler integriert werden. Einerseits just for fun, andererseits könnte z.B. alle 100 Stunden oder so eine Aufforderung erscheinen, den Lüfter zu reinigen.
+Die Datenübertragung zum Display ist ziemlich langsam. Um die Ausführung des Codes zu beschleunigen, werden immer nur die Bildschirmbereiche aktualisiert, die sich geändert haben.
-  * https://playground.arduino.cc/Code/EEPROMReadWriteLong
+===== Betriebsstunden, Taster, EEPROM =====
-  * http://thijs.elenbaas.net/2012/07/extended-eeprom-library-for-arduino/
+Außerdem werden die Betriebsstunden viertelstundengenau gezählt und im EEPROM gespeichert. Die viertelstundengenaue Zählweise schont das EEPROM. Später soll eine Funktion programmiert werden, die z.B. alle 100 Stunden zur Reinigung des Geräts (insbesondere des Lüfters) auffordert.
+Das Programm fragt einmal pro Schleife die beiden Taster ab. Diese Lösung ist gegenüber der Nutzung von Interrupts nicht die erste Wahl, weil der Arduino Nano jedoch nur zwei interruptfähige Pins hat (Pin 2 und Pin 3) und einer der beiden Pins (3) für die PWM-Ansteuerung des Peltier-Elements verwendet wird, fällt diese Variante aus. Die Taster sind entprellt und lösen erst beim Loslassen aus. Die Solltemperatur wird im EEPROM gespeichert.
+Sowohl für den Betriebsstundenzähler als auch für die Speicherung der Solltemperatur müssen Variablen mit dem Dateityp float bzw. double im EEPROM gespeichert werden. Zu diesem Zweck wurde die Bibliothek [[https://playground.arduino.cc/Code/EEPROMex|EEPROMex]] eingebunden.
+To dos:
+  * Es soll eine Sicherungsschaltung programmiert werden, die das Peltierelement ausschaltet, falls der Lüfter blockiert. Das erscheint mir sinnvoll, da vor dem Lüfter kein Schutzgitter montiert wird, um Luftgeräusche zu minimieren.
+  * Es soll zwischen verschiedenen Anzeigemodi gewechselt werden können, indem die Taster länger gedrückt werden.
+<code>
+// Flaschenkühler - Programmversion 0.2
+// 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 <PID_v1.h>               // Bibliothek für PID-Regler
+#include <EEPROMex.h>             // Bibliothek für Lesen und Schreiben des EEPROMS
+//------------------------- 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            0x001F
+#define RED             0xF800
+#define GREEN           0x07E0
+#define CYAN            0x07FF
+#define MAGENTA         0xF81F
+#define YELLOW          0xFFE0
+#define WHITE           0xFFFF
+//------------------------- Definition der Variablen ---------------------//
+int button1state = HIGH;       // aktuelles Signal vom Tasterpin
+int button1pressed = 0;        // abfragen ob Taster gedrückt war
+int button2state = HIGH;       // aktuelles Signal vom Tasterpin
+int button2pressed = 0;        // abfragen ob Taster gedrückt war
+int debouncetime = 5;          // Zeit für Entprellung ggf. anpassen
+unsigned long button1time = 0;
+unsigned long button2time = 0;
+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;
+// Betriebszeit
+float operatingTime;               // Betriebsstunden als Dezimalwert
+long lastTime = 0;
+// 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!)
+// Definiert das OLED
+Adafruit_SSD1351 tft = Adafruit_SSD1351(cs, dc, rst);
+// Informationsanzeige
+bool refreshPeltier = true;
+bool refreshTargettemp = true;
+//bool refreshActualtemp = true;
+bool refreshFan = true;
+// Instantiiert RunningAverage-Objekte zur Bechnung von Mittelwerten
+RunningAverage averageRPM(25);         // Mittelwert aus 25 Messungen
+RunningAverage averageThermistor(10);  // MIttelwert aus 10 Messungen
+// 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;// Berechnung der Temperaturen
+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 previousMillisSerialPrint = 0;          // Ausgabe an die serielle Schnittstelle
+// Definiert die Intervalle für die IF-Abfragen in Millisekunden
+const unsigned long intervalCalculateTemperatures = 10;
+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 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 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
+  operatingTime = EEPROM.readFloat(addrOperatingTime);
+  Setpoint = EEPROM.readDouble(addrTargetTemp);
+  // Stellt sicher, dass im ersten Durchlauf der Programmschleife nicht fälschlicherweise eine Lüfterfehlfunktion gemeldet wird
+  previousMillis = fanAlertDelay;
+  // 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>");
+  // 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(22, 60);
+  tft.print("Programmversion");
+  tft.setCursor(45, 75);
+  tft.setTextSize(2);
+  tft.print("0.2");
+  tft.setCursor(10, 108);
+  tft.setTextSize(0);
+  tft.print("Betriebsstunden:");
+  tft.setCursor(10, 120);
+  tft.print(operatingTime); tft.print(" Stunden");
+  delay(1000);
+  tft.fillScreen(BLACK);
+}
+//------------------------- Loop ---------------------//
+void loop() {
+  // Aktuelle Zeit abfragen
+  unsigned long currentMillis = millis();
+loopCounter++;
+//------------------------- Abfrage der Taster ---------------------//
+// Lesen und entprellen des Tasters
+  button1state = digitalRead(button1Pin);
+  button2state = digitalRead(button2Pin);
+  // Wenn der Taster 1 gedrückt ist...
+  if (button1state == LOW)
+  {
+    button1time = millis();                      // aktualisiere tasterZeit
+    button1pressed = 1;                          // speichert, dass Taster gedrückt wurde
+  }
+  // Wenn die gewählte entprellZeit vergangen ist und der Taster gedrückt war...
+  if ((millis() - button1time > debouncetime) && button1pressed == 1) {
+    button1pressed = 0;                        // setzt gedrückten Taster zurück
+    Setpoint = Setpoint + 0.5;
+    EEPROM.updateDouble(addrTargetTemp, Setpoint);
+    Serial.print("Updated Setpoint: "); Serial.println(Setpoint);
+    refreshTargettemp = true;
+    if (Setpoint == 30) {
+      Setpoint = 30;                   // setzt die NeoPixel zurück
+    }
+    //Serial.print("Setpoint: "); Serial.print(Setpoint);
+  }
+   // Wenn der Taster 2 gedrückt ist...
+  if (button2state == LOW)
+  {
+    button2time = millis();                      // aktualisiere tasterZeit
+    button2pressed = 1;                          // speichert, dass Taster gedrückt wurde
+  }
+  // Wenn die gewählte entprellZeit vergangen ist und der Taster gedrückt war...
+  if ((millis() - button2time > debouncetime) && button2pressed == 1) {
+    button2pressed = 0;                        // setzt gedrückten Taster zurück
+    Setpoint = Setpoint - 0.5;
+    EEPROM.updateDouble(addrTargetTemp, Setpoint);
+    Serial.print("Updated Setpoint: "); Serial.println(Setpoint);
+    refreshTargettemp = true;
+    if (Setpoint == 0) {
+      Setpoint = 0;                   // setzt die NeoPixel zurück
+    }
+    //Serial.print("Setpoint: "); Serial.print(Setpoint);
+  }
+//------------------------- Auslesen der Thermistoren und Berechnung der Temperaturen ---------------------//
+  if ((unsigned long)(currentMillis - previousMillisCalculateTemperatures) >= intervalCalculateTemperatures) {
+    // Lese die analogen Inputs aus
+    potiValue = analogRead(potiPin);                    // Poti
+    thermistorValue = analogRead(thermistorPin);        // Thermistor
+    averageThermistor.addValue(thermistorValue);        // Wert wird an Running Average übergeben
+    // Berechnung der Temperatur
+    thermistorValue = averageThermistor.getAverage();   // Der Mittelwert wird eingelesen
+    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) ---------------------//
+  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
+//------------------------- 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 (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) {
+    operatingTime = operatingTime + 0.25;
+    lastTime = millis();
+    EEPROM.updateFloat(addrOperatingTime, operatingTime);
+    Serial.print("Updated operatingTime: "); Serial.println(operatingTime);
+  }
+//------------------------- Ausgabe an das Display ---------------------//
+  // 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);
+    tft.setTextColor(YELLOW, 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) {
+    tft.setCursor(15, 85);
+    tft.setTextColor(RED, 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);
+    //refreshActualtemp = false;
+    previousMillisDisplayActualtemp = currentMillis;
+  }
+  // Anzeige Infobereich Lüfter
+  if (fanAlert == true) {
+    if (refreshFan == true) {
+      tft.setCursor(0, 120);
+      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, 120);
+        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, 120);
+        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;
+      }
+    }
+  }
+//------------------------- Ausgabe an die serielle Schnittstelle ---------------------//
+  if ((unsigned long)(currentMillis - previousMillisSerialPrint) >= intervalSerialPrint) {
+    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("; Loops: "); Serial.println(loopCounter);
+    loopCounter = 0;
+  //Speichere die aktuelle Zeit in die zughörige Variable
+  previousMillisSerialPrint = currentMillis;
+  }
+}
+</code>
+Der Sketch verwendet 19020 Bytes (61%) des Programmspeicherplatzes. Das Maximum sind 30720 Bytes.
+Globale Variablen verwenden 1054 Bytes (51%) des dynamischen Speichers, 994 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.
 Tags: #Arduino #Flaschenkühler #Nano #OLED