Thermocontrol für Absorberkühlschränke

Autoren: Nicolas-Pascal Kosellek & Hendrik Schlemmer

Betreuer: Prof. Dr.-Ing. Mirek Göbel

→ zurück zur Übersicht: WS 21/22: Angewandte Elektrotechnik (BSE)

Thermocontrol für Absorberkühlschränke

Einleitung

Da die Kühlleistung von Absorberkühlschränken stark von der Umgebungstemperatur an den Kühlrippen abhängt, ist es von Vorteil, diese über Temperatursensoren zu überwachen und aktiv in einem Temperaturfenster zuhalten.
Gerade im Wohnmobilbereich sind diese Kühlschränke häufig serienmäßig verbaut, sodass hier oft das Problem eines Hitzestaus im Abluftbereich entsteht. Dies wirkt sich negativ auf die Kühlleistung des Absorberkühlschrankes aus. Erhöhte Außentemperaturen, wie sie in südlichen Urlaubsregionen auftreten, verschärfen die Problematik.
Außentemperaturen im Bereich der Frostgrenze erschweren wiederum das Erreichen des optimalen Temperaturfensters.

Anforderungen

MUSS-Anforderungen

• Messung der Außentemperatur

• Messung der Kühlrippentemperatur

• Ansteuerung der Lüftungsklappen mittels eines Servomotors

• Regelung der Lüfterdrehzahl

• Ausgabe der Sensorwerte auf einem Display

• Stromversorgung über 12V-Boardspannung

• Notstellung der Lüftungsgitter

KANN-Anforderungen:

• USV-Versorgung zur Notsteuerung bei Ausfall der 12V-Boardspannung

Funktionaler Systementwurf/Technischer Systementwurf

Die Regelung des Temperaturfensters wird realisiert über eine zusammenhängende Steuerung der Luftauslassklappe in Verbindung mit zwei parallel laufenden Lüftern zur Erzeugung eines optimierten Abluftstroms.

Für die Steuerung des Lüftungsgitters wird ein Servomotor benötigt, welcher die Luftzufuhr regelt. Die zwei vorhandenen Temperatursensoren messen die Temperatur oberhalb der Kühlrippen und die Außentemperatur. Die Erzeugung des Abluftstroms erfolgt über zwei, in der Drehzahl regelbare Lüfter. Die Regelung der Lüfterdrehzahl wird durch den Arduino zum Erhalt der Temperatur, im optimalen Arbeitsbereich, gesteuert.

Die aktuellen Temperaturen, Lüfterdrehzahl und der Öffnungsgrad des Lüftungsgitters werden für den Benutzer sichtbar auf einem LCD-Display ausgegeben. Sollten Fehler in der Regelung oder beim Verstellen des Lüftungsgitters auftreten, wird der Benutzer durch einen Signalton gewarnt und eine Notstellung angefahren.

Die Thermocontrol wird durch ein geschaltetes Plus-Signal vom Kühlschrank mit Spannung versorgt und beginnt die Regelung automatisiert.

Abbildung Nr.1: Funktionaler Systementwurf - Thermocontrol Absorberkühlschrank

Regelstrecke

Abbildung Nr.0: Regelstrecke der Thermocontrol-Steuerung

Komponentenspezifikation

Komponente	Beschreibung	Abbildung
Arduino UNO	Microcontroller 14 digitale I/O Pins 6 analoge Eingänge	Arduino Uno Board
LCD-Display	I2C-Verbindung 16x2 Pixel Auflösung Hintergrundbeleuchtung	I2C LCD Display
2x PWM-Lüfter	be Quiet! Gehäuse Lüfter Pure Wings 2 120mm Durchmesser 12V / 2,4W Dienen zur Erzeugung eines Abluftstromes zur Abführung der Wärme	be Quiet! Gehäuse Lüfter
2x Ein/Aus Schalter	Zwei Schaltzustände Dient zum Umschalten zwischen verschiedenen Modis	Ein-Aus Schalter
Potentiometer	10kOhm Potentiometer Dient zur Simulation der Lamellentemperatur	10kOhm Potentiometer
Ultraschallsensor	Misst den Abstand zu einem beliebigen Objekt Dient zur Erkennung der Abdeckung	Ultraschallsensor HC-SR04
RGB-LED	4-Pin RGB LED (ROT/GRÜN/BLAU) Dient zur Darstellung des Systemzustandes	RGB-Led
1-Kanal Relais Modul	Max. 10A / 30VDC Dient zur Spannungsfreigabe der Lüfter	1-Kanel Relais Modul
Piezo-Speaker	Lautsprecher nach dem Piezo-Prinzip Dient zur Ausgabe eines Signaltons	Piezo-Speaker

Umsetzung (HW/SW)

Für die Umsetzung des Projektes in die Realität, wurde es in drei verschiedene Teilprojekte eingeteilt.

Hardware - Demo-Ständer

Um unser Projekt auf der Messe gut zu präsentieren, ohne ein Wohnmobil mitzubringen, bauten wir einen entsprechenden Präsentierständer, auf der alle Features zu sehen und auszuprobieren sind. Wir entschlossen uns für eine Edelstahlplatte, in der wir für den Einbaurahmen und der Kontrolleinheit passende Aussparungen schnitten. Um die Sicht auf den Ständer zu erleichtern, bauten wir zwei Holzfüße, welche einen 25 Grad winkeligen Einschnitt erhielten, welche wiederum die Edelstahlplatte halten. Die Lüfter werden im Einbaurahmen über drei Längsverstrebungen aus Edelstahl gehalten. Dies ermöglicht weiterhin die Demontage der Lüftungsgitter, für ein Erreichen der Kühllamellen. Auch der Ultraschallsensor wurde an dem Einbaurahmen befestigt.

Hardware - Schaltung

Abbildung Nr.2: PWM-Signal Verlauf über die Lamellentemperatur

Abbildung Nr.3: Rückansicht der Thermocontrol im Demo-Ständer

Wir fingen an die Schaltung, welche für die Drehzahl der Lüfter zuständig ist, aufzubauen.
Zu Beginn ließen wir lediglich einen Lüfter über unsere Steuerung laufen. Dafür war es notwendig die Temperatur der Kühllamellen eines Absorberkühlschranks über ein Drehpotentiometer zu simulieren, um schnell Änderungen in der Drehzahl der Lüfter erkennen zu können. Die in der Software hinterlegten Kennlinie des PWM-Signals über die Lamellentemperatur ist in der Abbildung X dargestellt. Die Lüfter und der Arduino wurden dabei direkt über ein 230 V Netzstecker, welcher die Spannung auf 12 V DC regelte, versorgt, um die anfallende Boardspannung eines Wohnmobils zu emittieren.
In der ersten Version verwendeten wir 12V Lüfter, welche keine PWM-Ansteuerung integriert hatten. So mussten wir unsere Schaltung mit einem MOSFET erweitern um somit die Versorgungsspannung der Lüfter zu regeln. Die Ansteuerung des MOSFETs erforderte eine PWM-Modulation.
Nach Rechersche im Internet, fanden wir regelbare 12V Lüfter mit PWM-Ansteurung. Die Beschaffung und Einbindung dieser Lüfter in die Schaltung vereinfachte den Aufbau. Nach diesem Schritt versuchten wir auf dem LCD die Temperatur und die Lüfterdrehzahl ausgeben zu lassen. Dies gelang uns jedoch erst nach dem Gebrauch der Arduino Software IDE.

Nun musste der Winterbetrieb der Thermocontrol realisiert werden. Nach mehreren Anläufen wurde uns bewusst, dass eine vollelektrische Lösung, bei der die Lüftungsgitter beim Unterschreiten einer Schwelltemperatur zu fahren, zu aufwendig zu konstruieren war. Wir beschlossen die mitgelieferte Winterabdeckung smart zu verwenden. Der Arduino soll nun bei Temperaturen um den Gefrierpunkt eine Fehlermeldung, ein akustisches Warnsignal und ein visuelles Warnsignal ausgeben, falls keine Winterabdeckung montiert wurde. Um dies elektronisch zu kontrollieren, montierten wir einen Ultraschallsensor in den Einbaurahmen, welcher durch eine Distanzmessung, die Abdeckung erkennt. Um auch den Außentemperaturbereich zu simulieren verwendeten wir einen Kippschalter, welcher den Sommer- oder Wintermodus einstellt.
Nach erfolgreicher Einbindung der Winterabdeckung sowohl in der Hard- als auch in der Software, mussten noch eine RGB-LED zur visuellen Unterstützung des Betriebszustandes und ein Piezo-Lautsprecher für akustische Warnsignale implementiert werden. Als Zusatz haben wir noch die Drehzahl aus dem Lüfter Ausgang ausgelesen und auf dem LCD-Display ausgegeben.
In der Abbildung 3 ist das finale Aufbau der Schaltung auf der Rückseite des Demo-Ständers aufgezeigt.

Software

Für die Softwareentwicklung für die Steuerung wurde die gesamte Software in kleinere Unterprogramme zerlegt und einzeln entwickelt. Für die finale Einbindung wurden die einzelnen Unterprogramme mittels der loop-Schleife in der Arduino IDE verbunden.

Für die Simulation der Lamellentemperatur wurde das Potentiometersignal von einem Wertebereich 0-1023 in einem Wertebereich von 0°C - 99°C umgerechnet. Hierdurch entsteht der Faktor 0.09765625. Ebenfalls wird diese Umrechnung bei der Prozentangabe der Lüfterdrehzahl verwendet, mit dem Wertebereich 0-1360 1/s.

Eine besondere Herausforderung innerhalb der Programmierung war die Erzeugung der notwendigen PWM-Frequenz für die Steuerung der Lüfter von 25000 Hz. Diese PWM-Frequenz ist ein Intel-Standart im Bereich der PV-Gehäuse Lüfter. Der Arduino kann eine so hohe PWM-Frequenz nicht darstellen, somit musste eine spezielle Arduino-Bibliothek hinzugefügt werden welche diese zur Verfügung stellt.

Ebenfalls musste für das Einlesen der Drehzahl aus dem Lüfter die PWM-Frequenz ausgewertet werden. Dieses wird wie im Unterprogramm dargestellt mittels eines Timers und einer pulseIn()-Funktion realisiert. Durch diese lässt sich die aktuelle Drehzahl der Lüfter berechnen.

Für die erfolgreiche Programmierung war die Einbindung von folgenden Bibliotheken notwendig:

• TimerOne.h (Erzeugung von beliebigen PWM-Frequenzen)
• LiquidCrystal_I2C.h (Einbindung des LCD-Display)

Im nachfolgenden sind der Arduino Code dargestellt inklusive der vorhandenen Unterprogrammen:

Arduino IDE - Softwarecode

//**************//
// Bibliotheken //
//**************//

// Display
#include <Wire.h>                           // Wire Bibliothek einbinden
#include <LiquidCrystal_I2C.h>              // Vorher hinzugefügte LiquidCrystal_I2C Bibliothek einbinden
LiquidCrystal_I2C lcd(0x27, 16, 2);         // Definieren vom Display (Adresse: 0x27 / 16 Spalten / 2 Zeilen)

//PWM Timer
#include <TimerOne.h>                       // Timer Bibliothek um die PWM-Frequenz zu ermöglichen

//**************//
//  Konstanten  //
//**************//

// Drehzahlabgriff Lüfter
const int Drehzahl_Pin = 6;                 // Pin des Tachosignals des Lüfters

//Poti-Einstellungen
const int Poti_TempLamellen_Pin = A0;       // Poti zur Temperatursimulation auf A0

//Lüfter-Einstellungen
const int Luefter_Pin = 10;                 // BeQuiet 120mm 2,4W (12V) auf Pin 10

const int PWM_Frequenz = 25000;             // Notwendige Frequenz für den Lüfter

//Lautsprecher-Einstellungen
const int Lautsprecher_PIN = 8;             // Lautsprecher an Pin 8 angeschlossen
const int TonFreq1 = 100;                   // Tonfrequenz 1 für Lautsprecherausgabe
const int DauerTon = 500;                   // Tondauer für Lautsprecherausgabe

// Ultraschallsensor-Einstellungen
const int US_Trigger_PIN = 12;              // Trigger vom Ultraschallsensor an PIN 12 angeschlossen
const int US_Echo_PIN = 13;                 // Echo vom Ultraschallsensor an PIN 13 angeschlossen
const int Abdeckung_Zu = 3;                 // Abstandswert bei geschlossener Abdeckung

// RGB-LED-Einstellungen
const int RGB_G_Pin = 3;                    // RGB-LED Grün auf PIN3
const int RGB_R_Pin = 2;                    // RGB-LED Rot auf PIN2

// StromRelais
const int StromRelais_Pin = 7;              // Relais-Steuerung auf PIN 7

//Schalter für Sommer-Winter-Modus
const int SommerWinter_PIN = 5;             // Schalter an Pin 5 angeschlossen
int SommerWinter = 0;                       // Sommer/Winter Modus
int SommerWinterPin = 0;                    // Zustand PIN

//Schalter für System
const int System_PIN = 4;                   // Schalter an Pin 4 angeschlossen
int System = 0;                             // System An/Aus
int SystemPin = 0;                          // Zustand PIN

// Variablen
int Luefter_Drehzahl = 0;                   // Speichern der Lüfter Drehzahl

int fanSpeed = 0;                           // Variable für die Lüftergeschwindigkeit
int potiVar = 0 ;                           // Variable zum speichern des Potentiometereingangs
int PotiLamellen = 0;                       // Variable zum
int TempLamellen = 0;                       // Variable zum

int PWM_Luefter = 0;                        // PWM der Lüfter

int LuefterDrehzahlPro = 0;                 //Lüfterauslastung in %
//int LuefterDrehzahl = 0;                  //Lüfterdrehzahl aus Rückgabewert vom Lüfter

// Drehzahl
int AbfrZeit = 1000;                        // Zeitabstand für die Abfragen des Tachosignals
long DrehzahlMillis = AbfrZeit;             // Zeitabstand für Pulse Stretching Funktion
float DrehzahlSek = 0;                      // Variable mit Kommastelle zur Berechnung der Umdrehungen pro Sekunde
int Drehzahl = 0;                           // Variable für die gemittelte Drehzahl
float UmdrehungMilli = 0;                   // Variable mit Kommastelle für die Zeit pro Umdrehung des Lüfters
float FlankenZeit = 0;                      // Variable mit Kommastelle für die Zeit pro Puls des Lüfters

// Ultraschallsensor
int US_t = 0;                               // Zeitvariable für den US
int Abstand = 0;                            // Gemessener Abstand in cm
int AbstandGrenze = 4;                      // in cm
int AbdeckungStatus = 0;                    // Status ob Abdeckung vorhanden

void setup()
{
  Serial.begin(9600);                           // Baudrate für die Ausgabe am Seriellen Monitor

  Timer1.initialize(1000000 / PWM_Frequenz);    // Initialisierung des PWM Timers - Frequenz des PWM Signals für den Lüfter = 25000 Hz = 25kHz
  Timer1.pwm(Luefter_Pin, 0);                   // PWM des Timers setzen, zunächst 0

  pinMode(Luefter_Pin, OUTPUT);                 // Lüfterpin als Ausgang
  pinMode(Poti_TempLamellen_Pin, INPUT) ;       // Setzt den PotiPin als Ausgang

  pinMode(SommerWinter_PIN, INPUT_PULLUP) ;     //Setzt den SchalterPin als Ausgang
  pinMode(System_PIN, INPUT_PULLUP) ;           //Setzt den SchalterPin als Ausgang

  pinMode(StromRelais_Pin, OUTPUT);             // RelaisPin als Ausgang

  pinMode(RGB_G_Pin, OUTPUT);                   // LED PIN als Ausgang
  pinMode(RGB_R_Pin, OUTPUT);                   // LED PIN als Ausgang

  pinMode(Lautsprecher_PIN, OUTPUT);            // Speaker PIN als Ausgang

  pinMode(US_Trigger_PIN, OUTPUT);              // US Trigger PIN als Ausgang
  pinMode(US_Echo_PIN, INPUT);                  // US Echo PIN als Eingang

  pinMode(Drehzahl_Pin, INPUT);                 // Setzt den Tacho Pin als Eingang

  lcd.init();                                   //Im Setup wird der LCD gestartet
  lcd.backlight();                              //Hintergrundbeleuchtung einschalten (lcd.noBacklight(); schaltet die Beleuchtung aus).
  Startsequenz();                               //
}


void loop()
{
  SystemSchalter();
  SommerWinterSchalter();
  SensorDaten();
  AbdeckungKontrolle();

  if (System == 1)                      // Wenn Systemschalter auf EIN-Stellung
  {
    if (SommerWinter == 1)              // SOMMER MODUS
    {
      DisplayBeschriftung();
      DisplayMesswerteSchreiben();
      LuefterAnsteuerung();
      LED_G_An();
    }

    if (SommerWinter == 0)              // WINTER MODUS
    {
      if (AbdeckungStatus == 1)
      {
        DisplayBeschriftung();
        SensorDaten();
        DisplayMesswerteSchreiben();
        LuefterAnsteuerung();
        LED_G_An();
      }
      if (AbdeckungStatus == 0)
      {
        StromRelaisAus();
        AbdeckungFehler();
        LED_R_An();
      }
    }
  }
  if (System == 0)                      // Wenn Systemschalter auf AUS-Stellung
  {
    LED_R_An();
    StromRelaisAus();
    DisplaySystemAus();
  }
  delay(100);                           // Reaktionswartezeit
}


void SensorDaten()                              // Funktion, welche die Unterfunktionen der SensorDaten zusammenfasst
{
  SystemSchalter();                             // Aufrufen der Unterfunktion Systemschalter
  SommerWinterSchalter();                       // Aufrufen der Unterfunktion SommerWinterSchalter
  US_Abstand();                                 // Aufrufen der Unterfunktion US_Abstand
  LamellenTemp();                               // Aufrufen der Unterfunktion LamellenTemp
  PWMSignal();                                  // Aufrufen der Unterfunktion PWMSignal
  LuefterProzent();                             // Aufrufen der Unterfunktion LuefterProzent
  DrehzahlMessung();                            // Aufrufen der Unterfunktion DrehzahlMessung
}

void LuefterAnsteuerung()                                                  // Ansteurung der Lüfter über PWM
{
  Timer1.setPwmDuty(Luefter_Pin, map(Luefter_Drehzahl, 0, 100, 0, 1023));  //Ansteuerung der Lüfter über map() von 0-100 umgerechnet zu 0-1023
}

void DrehzahlMessung()                              // Unterprogramm zur Drehzahlmessung
{
  if ((millis() - DrehzahlMillis) >= AbfrZeit)      // Timer um die Messung zu definierten Zeitpunkten durchzuführen
  {
    FlankenZeit = pulseIn(Drehzahl_Pin, LOW);       // Abfrage der Zeit pro Puls in Mikrosekunden
    UmdrehungMilli = ((FlankenZeit * 4) / 1000);    // Berechnung der Zeit pro Umdrehung in Millisekunden
    DrehzahlSek = (1000 / UmdrehungMilli);          // Umrechnung auf Umdrehungen pro Sekunde
    Drehzahl = (DrehzahlSek * 6);                   // Schritt 1 zur Rundung auf 10er Schritte der Drehzahl
    Drehzahl = (Drehzahl * 10);                     // Schritt 2 zur Rundung auf 10er Schritte der Drehzahl
    DrehzahlMillis = millis();                      // Die TachoMillis werden aktualisiert um die nächsten 1000ms zählen zu können
  }
}

void PWMSignal()                    // PWM-Signal abhäning von der Lamellentemperatur
{
  const int VarPWM = TempLamellen;  // Variable zur Fallunterscheidung
  switch (VarPWM)                   // Variable zur Fallunterscheidung
  {
    case 0 ... 40:                  // Wenn Temperatur von 0°C bis 40°C
      StromRelaisAus();             // Dann Relais aus
      break;                        //
    case 41 ... 50:                 // Wenn Temperatur von 41°C bis 50°C
      if (SommerWinter == 0)        // SommerModus aus
      {
        StromRelaisAus();           // Dann Relais aus
      }
      else
      {
        StromRelaisAn();            // Dann Relais an 
        Luefter_Drehzahl = 30;      // Lüfterdrehl 30%
      }
      break;                        
    case 51 ... 60:                 
      if (SommerWinter == 0)
      {
        StromRelaisAus();             
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 50;        
      }
      break;                        
    case 61 ... 70:                 
      if (SommerWinter == 0)
      {
        StromRelaisAus();            
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 75;       
      }
      break;                       
    case 71 ... 80:                 
      if (SommerWinter == 0)
      {
        StromRelaisAus();            
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 80;       
      }
      break;                       
    case 81 ... 90:                
      if (SommerWinter == 0)
      {
        StromRelaisAus();            
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 90;      
      }
      break;                       
    case 91 ... 99:                     // Wenn Temperatur von 91°C bis 99°C 
      if (SommerWinter == 0)            // Wintermodus an
      {
        StromRelaisAn();                // Relais an
        Luefter_Drehzahl = 100;         // Lüfter auf 100%
        LED_R_An();                     // Rote LED an
        Speaker();                      // Lautsprecher Ton an
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 100;      
      }
      break;                       
  }
}

void LuefterProzent()                          
{
  LuefterDrehzahlPro = (Drehzahl * 0.073529411764706);    //1360 max. Drehzahl (1360/1024)
}

void US_Abstand() // Von Funduino             
{
  digitalWrite(US_Trigger_PIN, LOW);            // Ausgang LOW setzten
  delay(5);                                     // Wartezeit
  digitalWrite(US_Trigger_PIN, HIGH);           // Ausgang HIGH setzen (Signal losschicken)
  delay(10);                                    // Wartezeit
  digitalWrite(US_Trigger_PIN, LOW);            // Ausgang LOW setzen (Signal fertig)
  US_t = pulseIn(US_Echo_PIN, HIGH);            // Eingang abfragen
  Abstand = (US_t / 2) * 0.03432;               // Abstand in cm bestimmen
}

void AbdeckungKontrolle()
{
  if (Abstand <= AbstandGrenze)     // Wenn Abstand kleiner der AbstandsGrenze
  {
    AbdeckungStatus = 1;            // 1 = Abdeckung vorhanden
  }
  else
  {
    AbdeckungStatus = 0;            // 0 = Abdeckung nicht vorhanden
  }
}

void AbdeckungFehler()
{
  lcd.clear();
  lcd.setCursor(0, 0);                          // Position des ersten Zeichens festgelegt
  lcd.print("Abdeckung       ");                // Ausgabe vom print-Befehl
  lcd.setCursor(0, 1);                          // Position des ersten Zeichens festgelegt
  lcd.print("fehlerhaft!      ");               // Ausgabe vom print-Befehl
}

void LamellenTemp()
{
  PotiLamellen = analogRead(Poti_TempLamellen_Pin);      // Einlesen des Potis über analogen Eingang
  TempLamellen = (PotiLamellen * (0.09765625));          // Zur Simulation einer Temperatur von 0°C bis 99°C (100/1024)
}

void PWMSignal()                    // PWM-Signal abhäning von der Lamellentemperatur
{
  const int VarPWM = TempLamellen;  // Variable zur Fallunterscheidung
  switch (VarPWM)                   // Variable zur Fallunterscheidung
  {
    case 0 ... 40:                  // Wenn Temperatur von 0°C bis 40°C
      StromRelaisAus();             // Dann Relais aus
      break;                        //
    case 41 ... 50:                 // Wenn Temperatur von 41°C bis 50°C
      if (SommerWinter == 0)        // SommerModus aus
      {
        StromRelaisAus();           // Dann Relais aus
      }
      else
      {
        StromRelaisAn();            // Dann Relais an 
        Luefter_Drehzahl = 30;      // Lüfterdrehl 30%
      }
      break;                        
    case 51 ... 60:                 
      if (SommerWinter == 0)
      {
        StromRelaisAus();             
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 50;        
      }
      break;                        
    case 61 ... 70:                 
      if (SommerWinter == 0)
      {
        StromRelaisAus();            
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 75;       
      }
      break;                       
    case 71 ... 80:                 
      if (SommerWinter == 0)
      {
        StromRelaisAus();            
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 80;       
      }
      break;                       
    case 81 ... 90:                
      if (SommerWinter == 0)
      {
        StromRelaisAus();            
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 90;      
      }
      break;                       
    case 91 ... 99:                     // Wenn Temperatur von 91°C bis 99°C 
      if (SommerWinter == 0)            // Wintermodus an
      {
        StromRelaisAn();                // Relais an
        Luefter_Drehzahl = 100;         // Lüfter auf 100%
        LED_R_An();                     // Rote LED an
        Speaker();                      // Lautsprecher Ton an
      }
      else
      {
        StromRelaisAn();
        Luefter_Drehzahl = 100;      
      }
      break;                       
  }
}

void SystemSchalter()                     // Schalterstellung überprüfen
{
  SystemPin = digitalRead(System_PIN);    // Zustand vom PIN auslesen
  if (SystemPin == HIGH)                  // Wenn PIN HIGH
  {
    System = 0;                           // System MODUS = 0
  }
  if (SystemPin == LOW)                   // Wenn PIN LOW
  {
    System = 1;                           // System MODUS = 0
  }
}

void SommerWinterSchalter()                           // Schalterstellung überprüfen
{
  SommerWinterPin = digitalRead(SommerWinter_PIN);    // Zustand vom PIN auslesen
  if (SommerWinterPin == HIGH)                        // Wenn PIN HIGH
  {
    SommerWinter = 1;                                 // SOMMER MODUS = 1
  }
  if (SommerWinterPin == LOW)                         // Wenn PIN LOW
  {
    SommerWinter = 0;                                 // WINTER MODUS = 0
  }
}

void LED_G_An()                         // Rote LED ein -> Grüne LED aus
{
  digitalWrite(RGB_G_Pin, 255);         // Rote LED einschalten (Digitalausgang HIGH schalten)
  digitalWrite(RGB_R_Pin, 0);           // Grüne LED ausschalten (Digitalausgang LOW schalten)
}

void LED_R_An()                         // Grüne LED ein -> Rote LED aus
{
  digitalWrite(RGB_R_Pin, 255);         // Rot LED einschalten (Digitalausgang HIGH schalten)
  digitalWrite(RGB_G_Pin, 0);           // Grüne LED ausschalten (Digitalausgang LOW schalten)
}

void LED_Aus()                          // Gesamte LED ausschalten
{
  digitalWrite(RGB_R_Pin, 0);           // Rote LED ausschalten (Digitalausgang LOW schalten)
  digitalWrite(RGB_G_Pin, 0);           // Grüne LED ausschalten (Digitalausgang LOW schalten)
}

void Speaker()                          // Lautsprecher einschalten/ausschalten
{
  tone(Lautsprecher_PIN, TonFreq1);     // Einschalten des Tons mit TonFreq1
  delay(DauerTon);                      // Tondauer
  noTone(Lautsprecher_PIN);             // Ausschalten des Tons
}

void StromRelaisAn()                          
{
  digitalWrite(StromRelais_Pin, HIGH);        // Relais ein
}

void StromRelaisAus()                          
{
  digitalWrite(StromRelais_Pin, LOW);         // Relais aus
}

void DisplaySystemAus()                         //
{
  lcd.setCursor(0, 0);                          //Hier wird die Position des ersten Zeichens festgelegt. In diesem Fall bedeutet (0,0) das erste Zeichen in der ersten Zeile.
  lcd.print("Thermocontrol   ");                //
  lcd.setCursor(0, 1);                          // In diesem Fall bedeutet (0,1) das erste Zeichen in der zweiten Zeile.
  lcd.print("ausgeschaltet!  ");                 //
}

void DisplayBeschriftung()                      // Funktion schreibt die Beschriftung aus Display
{
  lcd.setCursor(0, 0);                          
  lcd.print("t_L=");                            
  lcd.setCursor(10, 0);                         
  lcd.print("n=");                              
}

void DisplayMesswerteSchreiben()                // Die Funktion schreibt die Messwerte in Felder
{
  DisplayMesswerteLoeschen();                   

  lcd.setCursor(4, 0);                          
  lcd.print(TempLamellen);                      
  lcd.print("\xDF" "C  ");                      

  lcd.setCursor(0, 1);                          
  if (SommerWinter == 1)                        
  {
    lcd.print("SOMMER      ");                  
  }
  if (SommerWinter == 0)                        
  {
    lcd.print("WINTER      ");                  
  }

  lcd.setCursor(12, 0);                         
  lcd.print(Drehzahl);                          

  lcd.setCursor(12, 1);                         
  lcd.print(LuefterDrehzahlPro);                
  lcd.print("%");                               
}

void DisplayMesswerteLoeschen()                 // Die Funktion überschreibt die Messwert-Felder
{
  lcd.setCursor(4, 0);                          
  lcd.print("     ");                          
  lcd.setCursor(12, 0);                         
  lcd.print("      ");                          
  lcd.setCursor(12, 1);                         
  lcd.print("     ");                           
}

void Startsequenz()                             // Funktion, welche die Startsequenz des System darstellt
{
  lcd.setCursor(0, 0);                          // Hier wird die Position des ersten Zeichens festgelegt. In diesem Fall bedeutet (0,0) das erste Zeichen in der ersten Zeile.
  lcd.print("Thermocontrol V1");                //
  lcd.setCursor(0, 1);                          // In diesem Fall bedeutet (0,1) das erste Zeichen in der zweiten Zeile.
  lcd.print("System startet!");                 //
  delay(500);                                   // Systemwartezeit
  lcd.clear();                                  // LCD-Bildschirm wird komplett geleert
}

Komponententest

Die verwendeten Komponenten wie zum Beispiel die Lüfter oder das Drehpotenziometer wurden vor der Integration in das System getestet. Dies erfolgte über das Schreiben kleiner Testprogramme, indem die fehlerfreie Funktion erkannt werden konnte.

Folgende Testprogramme wurden angelegt und erfolgreich getestet:

• LCD_Display.ino
• Potentiometer.ino
• PWM_Auswertung.ino
• Ultraschall.ino

Unter folgendem Link [SVN-Link SVN] sind die Beispielprogramme vorhanden.

Ergebnis

Abbildung Nr.3: Vorderansicht der Thermocontrol im Demo-Ständer

Das Ergebnis des Fachpraktikums ist eine smarte Ablufttemperatursteuerung für den Einsatz mit Absorberkühlschränken.
Bei steigenden Temperaturen erhöht sich die Drehzahl der Lüfter,gemäß Abbildung X, sodass eine optimale Arbeitstemperatur des Absorberkühlschrankes gewährleistet werden kann. Ebenfalls wurde eine optische Kontrolle mittels einer RGB-LED umgesetzt, sowie eine akustische Ausgabe über einen Piezo-Speaker.
Durch das Display, welcher im realen Verbau im Innenraum vorzufinden wäre, ermöglicht die Thermocontrol dem Anwender, durch die Ausgabe der Temperaturen und der Lüfter Drehzahlen, ein sicheres Gefühl zu haben, dass der Kühlschrank optimale Kühlleistungen erbringen kann.
Das Problem gerade in warmen Urlaubsregionen von einem kühlen Getränk zu Träumen fällt von nun an weg und der Traum wird zur Realität!

Zusammenfassung

Lessons Learned

Durch die Arbeit an dem Projekt Thermocontrol für Absorberkühlschränke konnten wir das gemeinsame Arbeiten an einem realen Projekt erlernen. Es mussten alle Teilaufgaben für das erfolgreiche Abschließen der Arbeit geplant und durchgeführt werden.

Die Disziplinen waren unter anderen Aufgeteilt in:

Programmierung

Dort wurden die bisherigen Kenntnisse aus dem Fach Informatik und den dazugehörigen Praktika gefordert und weiter in Eigeninitiative ausgebaut, gerade die Programmierung in der Sprache C kam zum Einsatz.

Projektplanung

Die Durchführung eines eigenen Projekts wurde bislang nur theoretisch oder im Praxissemester vertieft, sodass das Projekt uns die Möglichkeit bat unser theoretisches Wissen mit praktischen Erfahrungen zu füllen.

Elektrotechnik

Sicherlich mussten auch die erlernten Grundlagen des Faches Elektrotechnik eingesetzt werden, um die Schaltungen richtig umsetzen zu können und auch die Widerstände zu bestimmen.

Handwerkliches Geschick

Während der gesamten Bauphase standen wir immer wieder vor kleinen oder auch großen Hürden, welche wir jedoch gut durch den richtigen Einsatz von Werkzeugen und der Bearbeitung von Werkstücken bewältigen konnten.

Es ist auf jeden Fall festzuhalten, dass dieses Projekt dem Lernerfolg in vielen Aspekten des Studiums weiterhilft und einem einen kleinen, aber doch sehr hilfreichen, Einblick in die praktische Arbeit bietet.

Projektunterlagen

Projektplan

Zu Beginn des Projektes wurde folgender Projektplan festgelegt. Die jeweiligen Aufgaben innerhalb des Projektes wurde gemäß dem Projektplan ausgeführt und abgearbeitet.

Abbildung Nr.4: GANTT-Diagramm

Projektdurchführung

Zu Beginn des Projektes zur Erstellung einer Thermocontrol, wurde Überlegungen angestellt, wie der Systemaufbau zu gestalten ist. Ebenfalls wurde in diesem Arbeitsschritt auch die notwendigen Bauteile definiert.
Durch den zuvor getätigten Kauf der Funduino-Arduino Box, war nur die Beschaffung der Lüfter und eines Potentiometer notwendig. Im ersten Versuchsaufbau, wurden Lüfter ohne interne PWM-Steuerung verwendet, sodass ebenfalls eine Transistorschaltung notwendig war. Aufgrund der Möglichkeit zur Verwendung von PWM gesteuerten Lüftern wurde die Schaltung im Laufe des Projektes ersetzt. Dieser Austausch hatte aber keine weiteren Auswirkungen auf den Projektaufbau. Weiter ausgeführt ist dieser Punkt in "Lessons Learned".
Zeitgleich wurde mit dem Hardware-Aufbau und des Fertigung des Demo-Ständers begonnen.
Abschließend konnte das Gesamtsystem aufgebaut werden und erfolgreich getestet werden.

YouTube Video

Im nachfolgenden Video ist das Projektergebnis darstellt:

Literatur

---

→ zurück zur Übersicht: WS 21/22: Angewandte Elektrotechnik (BSE)