temperaturabhängige Lüftersteuerung, 4 Kanäle mit dem Arduino Nano

Erstellt: 17. November 2020
Zuletzt aktualisiert: 21. Mai 2021

Im Video beschreibe ich meine Version einer temperaturabhängigen Lüftersteuerung mit dem Arduino NANO und dem DS 18B20.

Besonderheiten

Messung auf 4 Kanälen
Lüftergeschwindigkeiten in mehreren Stufen oder alternativ stufenlos regelbar
Steuerung von 4 unabhängigen PWM-Lüftern
Alarm-Buzzer bei 80°C
Ansteuerung von 4 Relais zur Sicherheitsabschaltung bei 90°C
alle Temperaturgrenzen und PWM-Werte frei einstellbar

Mit der Schaltung kann man zb. an 4 Kühlkörpern die Lüfter unabhängig gemäß gemessener Temperatur steuern. Die verschiedenen Temperaturstufen sowie die zugehörigen PWM-Ausgabewerte sind frei wählbar.

Im Beispiel bleiben die Lüfter bis 30°C aus, darüber - bis 60°C - laufen die Lüfter mit mittlerer Geschwindigkeit. Ab 80°C dann mit höchster Geschwindigkeit und Ausgabe eines Warntons. Ab 90 °C kann per separater Digitalausgänge für jeden Kanal ein Sicherheitsrelais die Energiezufuhr (not)abschalten.

Alternativ zum "Stufenalgorithmus" steht eine lineare Regelung zur Auswahl. Hier wird im Bereich 30°C ... 80°C linear von der minimal möglichen bis zur maximalen Drehzahl geregelt. Warnton und Abschaltrelais funktionieren genau so, wie im Stufenalgorithmus.

#include <Arduino.h>
/*
  Basiert auf:
  DS18B20 1-Wire digital temperature sensor with Arduino example code. More info: https://www.makerguides.com

Christian Haubitz-Reinke
  17.11.2020, Edit: 10.01.2021
  https://youtu.be/0TjYxWFdi2g

*/
// Include the required Arduino libraries:
#include <OneWire.h>
#include <DallasTemperature.h>
DeviceAddress sensorDeviceAddress;

// Definieren der Anschluss-Pins
#define ONE_WIRE_BUS 2 // Pin 2 für 1-Draht-Bus

// Wieviel bits werden für die Sensorwerte gelesen: 9, 10, 11 or 12
// 9 bits: increments of 0.5C, 93.75ms to measure temperature;
// 10 bits: increments of 0.25C, 187.5ms to measure temperature;
// 11 bits: increments of 0.125C, 375ms to measure temperature;
// 12 bits: increments of 0.0625C, 750ms to measure temperature.
#define SENSOR_RESOLUTION 9

// Index of sensors connected to data pin, default: 0
#define SENSOR_INDEX 0

#define buzzerInterval 400;    //Buzzer ON/OFF 500ms
unsigned long time_for_action; // Delay für millis() (Buzzer)

int pot_pin = A0;                 // Poti dient nur zur Simulation von Temp-Sensoren, die nicht angeschlossen sind
int AnzahlLuefter = 4;            // Anzahl der überwachten Sensoren / anzusteuernden Lüfter
int PWMpin[4] = {3, 5, 6, 9};     // PWM-Ausgabe-Pins für Lüfter 1...4
int BuzzerPin = 10;               // Ausgabe-Pin für Alarmgeber
int RelaisPin[4] = {4, 7, 8, 12}; // Ausgabe-Pins für Notfall-Relais 1...4

// Definition VARIABLEN
int poti;
int Temp[4] = {0, 0, 0, 0}; // Temperaturwert je Sensor [0]...[3]
int TempI = 30;             // 1. Temperaturstufe, Lüfter startet mit Minimaldrehzahl
int TempII = 60;            // 2. Temperaturstufe, Lüfter auf mittlere Drehzahl
int TempIII = 80;           // 3. Temperaturstufe, Lüfter auf Maximaldrehzahl, Alarm (Buzzer) wird ausgelöst
int TempIV = 90;            // 4. Temperaturstufe, Lüfter auf Maximaldrehzahl, zugehöriges Notfall-Relais wird ausgelöst
int LuefterMode = 0;        // 0 - Steps, 1 - Linear
int PWMoff = 0;             // AUS
int PWMlow = 10;            // min. Lüfterdrehzahl in %, an Lüfter anpassen
int PWMmid = 40;            // mittlere Drehzahl in %, ggf. anpassen
int PWMfull = 100;          // max. Drehzahl in %
int linearOutput = 0;       // gemappter Ausgabewert für linearen Lüfter-Mode
int buzzer = 0;             // Variable für den Buzzer, verwendet für AN/AUS-Intervall (Alarm I)

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

void setup()
{
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);

// Start up the library:
  sensors.begin();

for (int x = 0; x < AnzahlLuefter; x++)
  {
    sensors.getAddress(sensorDeviceAddress, x); // Sensor-Adresse auslesen, Auflösung einstellen für alle 4 Sensoren
    sensors.setResolution(sensorDeviceAddress, SENSOR_RESOLUTION);
  }
  pinMode(PWMpin[0], OUTPUT); // PWM-Pins als Ausgänge festlegen
  pinMode(PWMpin[1], OUTPUT);
  pinMode(PWMpin[2], OUTPUT);
  pinMode(PWMpin[3], OUTPUT);

pinMode(BuzzerPin, OUTPUT); // Buzzer-Pin als Ausgang festlegen

pinMode(RelaisPin[0], OUTPUT); // Relais-Pins als Ausgänge festlegen
  pinMode(RelaisPin[1], OUTPUT);
  pinMode(RelaisPin[2], OUTPUT);
  pinMode(RelaisPin[3], OUTPUT);

PWMlow = map(PWMlow, 0, 100, 0, 255); // Lüfterstufen von % auf Werte zw. 0...255 mappen
  PWMmid = map(PWMmid, 0, 100, 0, 255);
  PWMfull = map(PWMfull, 0, 100, 0, 255);

// Setup für Timer
}

// ############################### L O O P #####################################
void loop()
{

for (int i = 0; i < AnzahlLuefter; i++)
  {

//   DS18B20 Code

// Kommando zum erfassen der Temperaturwerte aller angeschlossener Sensoren
    sensors.requestTemperatures();
    // Rückgabe des Temperaturwertes in °C, jeweils für den aktuellen Sensor/Lüfter (Index "i")
    float tempC = sensors.getTempCByIndex(i);

// Poti als Ersatz für die Sensorwerte auslesen, wenn Sensor nicht angeschlossen, Mapping auf 0...100°C
    if (tempC != -127.00)
    { // Sensorwert bei abgeklemmtem Sensor: -127°C
      Temp[i] = tempC;
      Serial.print("Sensor "); // Ausgabe Sensorwert
      Serial.print(i);
      Serial.print(" :");
      Serial.print(tempC);
      Serial.print(" \xC2\xB0"); // Ausgabe °
      Serial.print("C");
      Serial.print("\t"); // Tabulator
    }
    else
    { // bei abgeklemmten Sensoren Potiwert übernehmen
      poti = analogRead(pot_pin);
      Temp[i] = map(poti, 0, 1023, 0, 100);
      Serial.print("Sensor "); // Ausgabe Fehler "Sensor Not Connected"
      Serial.print(i);
      Serial.print(" :");
      Serial.print("N.C.");
      Serial.print("  ");
      Serial.print("\t"); // Tabulator
      //delay(100);
    }

// Fall-Abfrage, je nach oben eingestelltem Lüftermodus
    switch (LuefterMode)
    {
    case 0: // Case 0 = Lüfter schaltet in 3 Stufen
      // statements
      if (Temp[i] < TempI)
      {                                 // wenn T unter Stufe 1
        analogWrite(PWMpin[i], PWMoff); // dann Lüfter AUS
        digitalWrite(RelaisPin[i], 0);  // Relais AUS
        Serial.print("Sensor ");        // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(PWMoff);
      }
      if (Temp[i] >= TempI and Temp[i] < TempII)
      {                                 // wenn T zwischen Stufe 1 und 2
        analogWrite(PWMpin[i], PWMlow); // dann Lüfter auf Minimaldrehzahl
        digitalWrite(RelaisPin[i], 0);  // Relais AUS
        Serial.print("Sensor ");        // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(PWMlow);
      }
      if (Temp[i] >= TempII and Temp[i] < TempIII)
      {                                 // wenn T zwischen Stufe 2 und 3
        analogWrite(PWMpin[i], PWMmid); // dann Lüfter auf mittlere Drehzahl
        digitalWrite(RelaisPin[i], 0);  // Relais AUS
        Serial.print("Sensor ");        // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(PWMmid);
      }
      if (Temp[i] >= TempIII and Temp[i] < TempIV)
      {                                  // wenn T zwischen Stufe 3 und 4
        analogWrite(PWMpin[i], PWMfull); // dann Lüfter auf maximale Drehzahl
        digitalWrite(RelaisPin[i], 0);   // Relais AUS
        Serial.print("Sensor ");         // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(PWMfull);
      }
      if (Temp[i] >= TempIV)
      {                                  // wenn T über Stufe 4
        analogWrite(PWMpin[i], PWMfull); // dann Lüfter auf maximale Drehzahl
        digitalWrite(RelaisPin[i], 1);   // Relais AN
        Serial.print("Sensor ");         // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(PWMfull);
      }
      break;
    case 1: // Case 1 = Lüfter regelt linear ab Stufe 2
      // statements
      if (Temp[i] < TempI)
      {                                 // wenn T zwischen Stufe 1 und 2
        analogWrite(PWMpin[i], PWMoff); // dann Lüfter AUS
        digitalWrite(RelaisPin[i], 0);  // Relais AUS
        Serial.print("Sensor ");        // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(PWMoff);
      }
      if (Temp[i] >= TempI and Temp[i] < TempIII)
      {                                                               // wenn T zwischen Stufe 1 und 3
        linearOutput = map(Temp[i], TempI, TempIII, PWMlow, PWMfull); // dann regle zwischen min und max
        analogWrite(PWMpin[i], linearOutput);                         // Ausgabe des PWM-Wertes
        digitalWrite(RelaisPin[i], 0);                                // Relais AUS
        Serial.print("Sensor ");                                      // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(linearOutput);
      }
      if (Temp[i] >= TempIII and Temp[i] < TempIV)
      {                                  // wenn T zwischen Stufe 3 und 4
        analogWrite(PWMpin[i], PWMfull); // dann Lüfter auf maximale Drehzahl
        digitalWrite(RelaisPin[i], 0);   // Relais AUS
        Serial.print("Sensor ");         // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(PWMfull);
      }
      if (Temp[i] >= TempIV)
      {                                  // wenn T zwischen Stufe 3 und 4
        analogWrite(PWMpin[i], PWMfull); // dann Lüfter auf maximale Drehzahl
        digitalWrite(RelaisPin[i], 1);   // Relais AN
        Serial.print("Sensor ");         // Ausgabe für Serial-Monitor
        Serial.print(i);
        Serial.print(": ");
        Serial.print(Temp[i]);
        Serial.print(" \xC2\xB0"); // shows degree symbol
        Serial.print("C");
        Serial.print("\t");
        Serial.print("  LüfterPWM ");
        Serial.print(i);
        Serial.print(": ");
        Serial.println(PWMfull);
      }
      break;
    case 2:
      // statements
      break;
    default:
      // statements
      break;
    } // Ende Switch...Case

} // Ende 1...4 Schleife

// wenn einer der Sensoren über TempIII steigt, Alarm auslösen (Intervall-Beep)
  if (Temp[0] >= TempIII || Temp[1] >= TempIII || Temp[2] >= TempIII || Temp[3] >= TempIII)
  {
    if (millis() > time_for_action) // Wenn Zeitzähler am Auslösewert vorbei kommt ...
    {
      time_for_action = millis() + (unsigned long)buzzerInterval; // aktueller Zeitpunkt + ### ms = nächster Umschaltzeitpunkt
      buzzer = !buzzer;                                           // Buzzer-Zustand invertieren: Aus->An, An->Aus
      digitalWrite(BuzzerPin, buzzer);                            // An oder Aus an Buzzerpin übergeben
    }
  }
  // wenn einer der Sensoren über TempIV steigt, Alarm auslösen (Dauer-Beep)
  if (Temp[0] >= TempIV || Temp[1] >= TempIV || Temp[2] >= TempIV || Temp[3] >= TempIV)
  {
    digitalWrite(BuzzerPin, 1); // Buzzer einschalten
  }
  // wenn alle Sensoren unter TempIII fallen, Buzzer wieder abschalten
  if (Temp[0] < TempIII && Temp[1] < TempIII && Temp[2] < TempIII && Temp[3] < TempIII)
  {
    digitalWrite(BuzzerPin, 0); // Buzzer ausschalten
  }
}
// Ende void loop
// ################################ L O O P    E N D E  ##############################

Markieren & Kopieren