Gefriertruhensteuerung – Wacker-Elektro

Gefriertruhensteuerung für Hähnchenzucht

Willkommen auf der Projektseite für mein neuestes Projekt: eine maßgeschneiderte Gefriertruhensteuerung. Mein Kollege hat günstig eine Gefriertruhe aus einem Supermarkt erworben, die für seine Hähnchenzucht genutzt werden sollte. Leider hatte die Truhe ein Problem mit der Steuerung, die nicht mehr richtig funktionierte. Daher entschied ich mich, eine neue Steuerung mit einem Arduino zu programmieren, die auf mehreren Temperatursensoren und Relais basiert.

Projektübersicht

Ziel dieses Projekts:
Eine zuverlässige und effiziente Steuerung für eine Gefriertruhe zu entwickeln, die zwei Betriebsmodi (Kühlen und Gefrieren) unterstützt. Die Steuerung sollte auch in der Lage sein, Fehler zu erkennen und akustische Signale bei Problemen auszugeben.

Technische Details

Hardware:

Arduino Mikrocontroller:
- Verantwortlich für die Steuerung der Gefriertruhe und die Verarbeitung der Sensordaten.
Temperatursensoren (Adafruit MAX31865):
- PT100-Temperatursensor zur genauen Messung der Innentemperatur der Truhe.
Relais:
- Vier Relais zur Steuerung des Kompressors und anderer Komponenten.
Buzzer:
- Gibt akustische Signale bei Fehlern aus.
Schalter:
- Ermöglicht das Umschalten zwischen den Modi Kühlen und Gefrieren.
LCD Display (LiquidCrystal I2C):
- Zeigt die aktuelle Temperatur und den Betriebsmodus an.

Funktionen:

Temperaturregelung:
- Die Steuerung überwacht kontinuierlich die Innentemperatur der Gefriertruhe und schaltet den Kompressor je nach eingestelltem Modus ein oder aus.
- Zwei Modi: Kühlen (1°C) und Gefrieren (-21°C).
Fehlererkennung:
- Der Arduino überwacht die Temperatursensoren auf Fehler. Bei einem Fehler wird ein akustisches Signal ausgegeben und der Kompressor abgeschaltet.
- Fehler werden auf dem LCD-Display angezeigt.
Betriebsmodi:
- Ein Schalter ermöglicht das Umschalten zwischen den Betriebsmodi Kühlen und Gefrieren.

Projekt im Detail

Aufbau der Steuerung:

Der Arduino Mikrocontroller ist mit den Temperatursensoren, Relais, dem Buzzer und dem LCD-Display verbunden.
Die Temperatursensoren überwachen die Innentemperatur der Truhe und geben die Daten an den Arduino weiter.
Der Arduino steuert die Relais, die den Kompressor ein- und ausschalten, basierend auf der gemessenen Temperatur und dem gewählten Modus.
Ein Buzzer gibt akustische Warnungen aus, wenn ein Fehler erkannt wird.
Ein LCD-Display zeigt die aktuelle Temperatur und den Betriebsmodus an.
Ein Schalter ermöglicht das Umschalten zwischen den Modi Kühlen und Gefrieren.

Programmierung:

Der Code für die Steuerung wurde in Arduino IDE geschrieben und umfasst die Steuerung der Temperatursensoren, Relais und des Buzzers.
Der Code enthält auch Fehlererkennungsroutinen und die Logik für die verschiedenen Betriebsmodi.

#include <Adafruit_MAX31865.h>
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display

Adafruit_MAX31865 thermo = Adafruit_MAX31865(10); // Hardware SPI

// The value of the Rref resistor. Use 430.0 for PT100 and 4300.0 for PT1000
#define RREF      430.0
// The 'nominal' 0-degrees-C resistance of the sensor
// 100.0 for PT100, 1000.0 for PT1000
#define RNOMINAL  100.0

int kuehlen_an = 2; // Kompressor Kühlen An
int kuehlen_aus = -1; // Kompressor Kühlen Aus
int gefrieren_an = -18; // Kompressor Gefrieren An
int gefrieren_aus = -21; // Kompressor Gefrieren Aus

int r1 = 2; // Relais 1
int r2 = 3; // Relais 2
int r3 = 4; // Relais 3
int r4 = 5; // Relais 4
int summer = 14; // Summer Alarm
int schalter = 6; // Temperatur Umschalter
int schalterState = 0; // Merker Temperatur Umschalter
int state = HIGH;
int reading;
int previous = LOW;
int fehler = 0; // Merker Fehler Fühler

long time = 0;
long debounce = 200;

void setup() {
  Serial.begin(115200);
  lcd.init(); // Initialisierung des Displays
  lcd.init();
  lcd.backlight();

  pinMode(r1, OUTPUT);
  pinMode(r2, OUTPUT);
  pinMode(r3, OUTPUT);
  pinMode(r4, OUTPUT);
  pinMode(summer, OUTPUT);
  pinMode(schalter, INPUT);

  thermo.begin(MAX31865_3WIRE);  // set to 2WIRE or 4WIRE as necessary

  delay(200);
}

void loop() {
  uint16_t rtd = thermo.readRTD();

  //Serial.print("RTD value: "); Serial.println(rtd);
  float ratio = rtd;
  ratio /= 32768;
  /*Serial.print("Ratio = "); Serial.println(ratio,8);
  Serial.print("Resistance = "); Serial.println(RREF*ratio,8);
  Serial.print("Temperature = "); Serial.println(thermo.temperature(RNOMINAL, RREF));
  Serial.println();*/

  digitalWrite(r4, HIGH);
  
  schalterState = digitalRead(schalter);

  Kompressor(); // Kompressorsteuerung

  Solltemperatur(); // Solltemperatur einstellen

  delay(500); // Zeit in Millisekunden für Aktualisierung
  
  if (fehler == 1) {
    digitalWrite(r1, HIGH); // Kühler ausschalten
  } else if (fehler == 0) {
    digitalWrite(r1, LOW); // Kühler einschalten
  }
}

void Solltemperatur() {

  // Fehlercodes und deren Bedeutung

  uint8_t fault = thermo.readFault();
  if (fault) {
    fehler = 1;
    digitalWrite(summer, HIGH);
    lcd.init();
    lcd.setCursor(0,0);
    lcd.print("Fault 0x");
    lcd.print(fault, HEX);
    if (fault & MAX31865_FAULT_HIGHTHRESH) {
      lcd.setCursor(0,1);
      lcd.print("Fuehler Bruch"); 
    }
    if (fault & MAX31865_FAULT_LOWTHRESH) {
      lcd.setCursor(0,1);
      lcd.print("Fuehler Schluss"); 
    }
    if (fault & MAX31865_FAULT_REFINLOW) {
      lcd.setCursor(0,1);
      lcd.print("REFIN- > 0.85 x Bias"); // REFIN- > 0.85 x Bias
    }
    if (fault & MAX31865_FAULT_REFINHIGH) {
      lcd.setCursor(0,1);
      lcd.print("REFIN- < FORCE- open"); // REFIN- < 0.85 x Bias - FORCE- open
    }
    if (fault & MAX31865_FAULT_RTDINLOW) {
      lcd.setCursor(0,1);
      lcd.print("RTDIN- < FORCE- open"); // RTDIN- < 0.85 x Bias - FORCE- open
    }
    if (fault & MAX31865_FAULT_OVUV) {
      lcd.setCursor(0,1);
      lcd.print("Under/Over Voltage"); 
    }
    thermo.clearFault();
    delay(300);
    digitalWrite(summer, LOW);
    delay(500);
    lcd.init();
    } else {
      // Temperaturanzeige
      
    digitalWrite(summer, LOW);
    lcd.setCursor(0,0);
    lcd.print("Temp:");
    lcd.setCursor(6,0);
    lcd.print(thermo.temperature(RNOMINAL, RREF));
    lcd.print((char) 223);
    lcd.print("C  ");
    lcd.setCursor(0,1);
    lcd.print("Soll:");
    lcd.setCursor(6,1);
    if (schalterState == HIGH){
      lcd.print("1.0");
      lcd.print((char) 223);
      lcd.print("C  ");
    } else if (schalterState == LOW){
      lcd.print("-21.0");
      lcd.print((char) 223);
      lcd.print("C  ");
    }
    }
}

void Kompressor() {

  // Kompressorsteuerung

  if (schalterState == HIGH) {
  // Temperatur 1 Grad
  if (thermo.temperature(RNOMINAL, RREF) >= kuehlen_an && fehler == 0) { // Kompressor an
    digitalWrite(r2, LOW);
    delay(200);
    digitalWrite(r3, LOW);
    lcd.setCursor(15,1);
    lcd.print("*");
  } else if (thermo.temperature(RNOMINAL, RREF) <= kuehlen_aus || fehler == 1) { // Kompressor aus
    digitalWrite(r3, HIGH);
    delay(200);
    digitalWrite(r2, HIGH);
    lcd.setCursor(15,1);
    lcd.print(" ");
  }} else if (schalterState == LOW) {
    // Temperatur -21 Grad
  if (thermo.temperature(RNOMINAL, RREF) >= gefrieren_an && fehler == 0) { // Kompressor an
    digitalWrite(r2, LOW);
    delay(200);
    digitalWrite(r3, LOW);
    lcd.setCursor(15,1);
    lcd.print("*");
  } else if (thermo.temperature(RNOMINAL, RREF) <= gefrieren_aus || fehler == 1) { // Kompressor aus
    digitalWrite(r3, HIGH);
    delay(200);
    digitalWrite(r2, HIGH);
    lcd.setCursor(15,1);
    lcd.print(" ");
  }
  }
  if (fehler == 1) {
    fehler = 0;
  }
}

void Fehlercodes() {

  // Fehlercodes und deren Bedeutung

  uint8_t fault = thermo.readFault();
  if (fault) {
    Serial.print("Fault 0x"); Serial.println(fault, HEX);
    if (fault & MAX31865_FAULT_HIGHTHRESH) {
      Serial.println("RTD High Threshold"); 
    }
    if (fault & MAX31865_FAULT_LOWTHRESH) {
      Serial.println("RTD Low Threshold"); 
    }
    if (fault & MAX31865_FAULT_REFINLOW) {
      Serial.println("REFIN- > 0.85 x Bias"); 
    }
    if (fault & MAX31865_FAULT_REFINHIGH) {
      Serial.println("REFIN- < 0.85 x Bias - FORCE- open"); 
    }
    if (fault & MAX31865_FAULT_RTDINLOW) {
      Serial.println("RTDIN- < 0.85 x Bias - FORCE- open"); 
    }
    if (fault & MAX31865_FAULT_OVUV) {
      Serial.println("Under/Over voltage"); 
    }
    thermo.clearFault();
}
}

void Flankenmerker() {
  
  //  Trigger Flanke von Schalter Temperatur
  
  reading = digitalRead(schalter);

  // if the input just went from LOW and HIGH and we've waited long enough
  // to ignore any noise on the circuit, toggle the output pin and remember
  // the time
  if (reading == HIGH && previous == LOW && millis() - time > debounce) {
    if (state == HIGH) {
      state = LOW;
      lcd.init();
    } else {
      state = HIGH;
      lcd.init();

    time = millis();    
    }}

  previous = reading;
}

Fazit

Die neue Steuerung für die Gefriertruhe hat sich als äußerst zuverlässig und effizient erwiesen. Seit der Installation gab es keinen einzigen Ausfall mehr. Mit der Möglichkeit, zwischen Kühlen und Gefrieren umzuschalten, und der integrierten Fehlererkennung bietet diese Lösung eine optimale Steuerung für die Hähnchenzucht meines Kollegen.

Vielen Dank, dass du dir die Zeit genommen hast, mehr über mein Projekt zu erfahren. Ich freue mich darauf, weitere interessante Projekte mit dir zu teilen!