arduino:flaschenkuehler:programmversion_0.3
Flaschenkühler - Programmversion 0.3
In dieser Version soll die Regelung des Peltier-Elements in Angriff genommen werden. Um den PID-Regler einstellen zu können wäre es gut, wenn man die Daten der seriellen Schnittstelle direkt in Excel oder so speichern könnte.
Das OLED-Display hat nun drei Anzeigemodi: einfach, erweitert und grafisch. Zwischen den Anzeigemodi kann durch einen langen Druck auf den oberen oder unteren Taster gewechselt werden. Diese Funktion stellt sehr komfortabel die Bibliothek ButtonEvents zur Verfügung.
Im einfachen und erweiterten Anzeigemodus werden die Soll- und Isttemperaturen nun in einer Schrittweite von 0,5°C temperaturabhängig in spezifischen Farbwerte angezeigt. 30°C werden in rot angezeigt, 0°C in türkis. Die Farbwerte habe ich mit diesem Online-Tool erzeugt.
Ab dieser Programmversion erscheint nach 100 Betriebsstunden eine Aufforderung auf dem Startbildschirm, den Flaschenkühler zu reinigen. Das Reinigungsintervall kann mit einem (schnellen) Doppeldruck auf Taster 1 zurückgesetzt werden. Das Zurücksetzen wird mit einer entsprechenden Anzeige auf dem OLED-Display quittiert.
Zur Glättung der analogen Inputs, also der Thermistoren, wird ab dieser Programmversion die Bibliothek ResponsiveAnalogRead verwendet. Was die Bibliothek leistet wird sehr anschaulich auf dieser Webseite erklärt. Die Anzeige der Isttemperatur auf dem Display wird dadurch sehr viel stabiler. Die Ausführung des Codes verlangsamt sich dadurch zwar um etwa 1 %, andererseits muss nun das Display nicht mehr alle 500 Millisekunden aktualisiert werden, sondern nur noch dann, wenn sich die Isttemperatur tatsächlich verändert hat. Dadurch wird die Ausführung des Programms um ca. 129 % beschleunigt.
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.
// 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
//------------------------- 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,
0x003F, 0x001F, 0x101F, 0x201F, 0x281F, 0x381F, 0x401F,0x501F, 0x601F, 0x681F, 0x781F, 0x801F, 0x901F, 0x981F, 0xA81F, 0xB81F, 0xC01F, 0xD01F, 0xD81F, 0xE81F,
0xF81F, 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;
}
}
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
arduino/flaschenkuehler/programmversion_0.3.txt · Zuletzt geändert: 18.05.2023 12:34 von 127.0.0.1