3.4 - Temperaturgesteuerter Lüfter

 

Um seine Hardware bei möglichst niedriger Geräuschentwicklung kühl zu halten, aber trotzdem auf Lastwechsel im System reagieren zu können, greift man gerne zu einer Temperaturabhängigen Steuerung.
Ich verwende in diesem Tutorial zur Temperaturerfassung einen 10kΩ NTC Widerstand, da diese gewöhnlich auch im Wasser- und Luftkühlungsbereich verwendet werden und dabei auch noch sehr günstig sind. Die Geschwindigkeit des Lüfters lässt sich dabei am einfachsten per PWM Signal steuern. Das macht man mit dem Arduino, indem man per analogWrite Befehl ein PWM Signal zwischen 0 und 255 ausgibt, wobei 0 = 0% und 255 = 100% ist.
Der Code für 3 Pin Lüfter und 4 Pin PWM Lüfter unterscheidet sich dabei etwas, da sich 4 Pin PWM Lüfter in der Regel nicht abschalten lassen. Gibt man hier einen PWM Wert von 0 aus, läuft der Lüfter mit seiner Minimaldrehzahl weiter. Deshalb habe ich mich hier auch entschieden, für jeden Lüftertyp, eigenen Code zu schreiben. Der Aufbau der Schaltung unterscheidet sich dabei auch etwas.
Den 4 Pin PWM Lüfter kann man ohne zusätzliche Bauteile an eine 12V Stromversorgung und den Arduino anschließen, aber für die Ansteuerung eines 3 Pin Lüfters braucht man noch einen Transistor, der über den Arduino angesteuert wird, da die Ausgänge des Arduinos nicht genügend Strom und Spannung liefern um einen Lüfter anzutreiben.
 
 
 
 

Teileliste

 
 
 
 

Anschlussplan

 

 3 Pin Lüfter

anschluss 3.4 3pin     schaltplan 3.4 4pin
 
 
 
4 Pin PWM Lüfter
 
 anschluss 3.4 4pin     schaltplan 3.4 4pin
 
 
 
 

Code

 

// Konstanten
const int fanPin = 9;                 // Pin für den Lüfter
const int ntc = A0;                   // Pin für den 10kO NTC Wiederstand
const int ntcNominal = 10000;         // Wiederstand des NTC bei Nominaltemperatur
const int tempNominal = 25;           // Temperatur bei der der NTC den angegebenen Wiederstand hat
const int bCoefficient = 3977;        // Beta Coefficient(B25 aus Datenblatt des NTC)
const int serienWiederstand = 10000;  // Wert des Wiederstands der mit dem NTC in Serie geschalten ist

// Variablen
int fanSpeed = 0;          // Variable für die Lüftergeschwindigkeit
int fanMin = 60;           // Kleinster PWM Wert für den Lüfter befor er abschält
int fanOut = 1;            // Variable zum pürfen ob der Lüfter aus war
int tMin = 20;             // Untere Grenze des Temperaturbereichs
int tMax = 60;             // Obere Grenze des Temperaturbereichs
int abfrageZahl = 5;       // Je mehr abfragen, desto stabiler isr das Ergebnis, dauert aber länger
int abfrage[5];            // Array Variable für das Mitteln der Temperatur
float durchschnitt = 0;    // Variable für das Mitteln der Temperatur
float temp;                // Variable für die Berechnung der temperatur nach Steinhart


void setup()
{
  TCCR1B = TCCR1B & 0b11111000 | 0x01;   // Setzt Timer1 (Pin 9 und 10) auf 31300Hz
  Serial.begin(9600);             // Baudrate für die Ausgabe am Serial Monitor
  pinMode(fanPin, OUTPUT);        // Setzt den Pin des Lüfters als Ausgang
  pinMode(ntc, INPUT);            // Setzt den Pin des NTC Wiederstands als Eingang
}


void loop()
{
  temperaturberechnung();      // Startet die Temperaturerfassungsroutine
  
  // Lüftergeschwindigkeit über den Temperaturbereich einstellen
  // TMin->0% PWM | TMax->100% PWM
  fanSpeed = map(temp, tMin, tMax, 0, 255);    
  
  // Wenn der PWM Wert unter den van FanMin fällt, schält der Lüfter ab
  if (fanSpeed < fanMin)
  {
    fanSpeed = 0;
    fanOut = 1;
  }
  
  // Hysterese
  if (fanOut == 1)
  {
    fanSpeed = 0;
  }
  
  if(temp >= 32)
  {
    if(fanOut == 1)
    {
      fanOut = 0;
      analogWrite(fanPin, 255);
    }
  }
  
  // PWM Wert auf 255 begerenzen  
  if (fanSpeed > 255)
  { 
    fanSpeed = 255;
  }
  
  // Lüftergeschwindigkeit über den Seriellen Monitor ausgeben
  Serial.print("Lueftergeschwindigkeit: ");          
  Serial.println(fanSpeed);

  analogWrite(fanPin, fanSpeed);      // Den Lüfter mit dem PWM Wert ansteuern
  delay(500);  
} 



void temperaturberechnung()
{
  // Nimmt N Abfragen in einer Reihe, mit einem kurzen delay
  for (int i=0; i < abfrageZahl; i++)
  {
    abfrage[i] = analogRead(ntc);
    delay(10);
  }
  
  // Mittelt alle Abfragen
  durchschnitt = 0;
  for (int i=0; i < abfrageZahl; i++)
  {
    durchschnitt += abfrage[i];
  }
  durchschnitt /= abfrageZahl;
  
  // Umwandlung des Wertes in Wiederstand
  durchschnitt = 1023 / durchschnitt - 1;
  durchschnitt = serienWiederstand / durchschnitt;
  
  // Umrechnung aller Ergebnisse in die Temperatur mittels einer Steinhard Berechnung
  temp = durchschnitt / ntcNominal;     // (R/Ro)
  temp = log(temp);                     // ln(R/Ro)
  temp /= bCoefficient;                 // 1/B * ln(R/Ro)
  temp += 1.0 / (tempNominal + 273.15); // + (1/To)
  temp = 1.0 / temp;                    // Invertieren
  temp -= 273.15;                       // Umwandeln in °C
  
  // Ausgabe an den Seriellen Monitor
  Serial.print("Temperatur ");
  Serial.print(temp);
  Serial.println(" *C");
  
  delay(500);
}

 
 

Fangen wir mit den Konstanten an. Hier haben wir diesmal ein paar für die Berechnung wichtigen Werte, die ich jetzt erläutere.

  • ntcNominal = 10000 - Damit ist der Wiederstand des NTC bei Nominaltemperatur gemeint. Dieser Wert wird immer im Namen schon angegeben. Ein 10kΩ NTC hat einen Wiederstand von 10000 Ohm.
  • tempNominal = 25 - Das ist die Nominaltemperatur. Diese ist im Normalfall 25°.
  • bCoefficient = 3977 - Der Beta Coefficient ist eine Materialkonstante und ist im Datenblatt des NTC zu finden und wird mit B25 bezeichnet.
  • serienWiederstand = 10000 - Das ist der Wert in Ohm, des Wiederstand, der zusammen mit dem NTC als Spannungsteiler verbaut wird. In unserem Fall auch ein 10kΩ Wiederstand.
Bei den Variablen gibt es ein paar Einstellmöglichkeiten, die je nach Geschmack oder Anwendungsfall zu wählen sind. Ich habe diese Werte nur exemplarisch gewählt.

  • fanMin = 60 - Das ist der kleinste PWm Wert den der Lüfter macht. Fällt der PWM Wert durch die Temperatursteuerung darunter, schält der Lüfter ab. Wählt diesen Wert so, dass euer Lüfter damit noch läuft.
  • tMin = 20 - Untere Tegeltemperaturgrenze 
  • tMax = 60 - Obere Regeltemperaturgrenze
Über den Temperaturbereich zwischen tMin und tMax wird im Code der PWM Wert linear verteilt. Sprich 20° (TMin) = 0 PWM und 60° (TMax) = 255 PWM. Ich habe hier mit fanMin festgelegt das der Lüfter erst bei einem PWM Wert von 60 startet. Das entspricht ca. 30°. Alles was darunter liegt resultiert in einem stehenden Lüfter.

  • abfrageZahl = 5
  • abfrage[abfrageZahl]

abfrageZahl und abfrage hängen zusammen und bestimmen mit wievielen Messwerten des NTC gemittelt wird. Je höher der Wert, desto weniger sprunghaft ist der Temperaturwert, allerdings dauert die Erfassung auch länger.

Nach dem setzen der Konstanten und Variablen, wird im setup die Frequenz des PWM Signals eingestellt, sowie die Ein- und Ausgänge deklariert.
Der loop startet mit der temberaturberechnung.
Hier wird als erstes der NTC so oft ausgelesen und dessen Werte gespeichert, wie mit abfrageZahl und abfrage festelegt ist.
Als nächstes werden die Werte zusammengezählt und durch abfrageZahl geteilt um den durchschnitt zu bilden.
Jetzt wird der Durchschnitt in einen Wiederstandswert umgerechnet. Ist das erledigt, wird die Temperatur mittels der Steinhart Formel berechnet.
Die Berechnete Temperatur wird nun in °C im Seriellen Monitor ausgegeben.

Weiter im loop geht es mit dem festlegen des PWM Wertes von fanSpeed. Dieser wird mittels des map Befehls linear auf den Temperaturbereich verteilt.
Wenn der PWM Wert unter den Wert von fanMin (60) fällt, was in diesem fall ca. 30°C sind, schaltet der Lüfter ab und setzt die Variable fanOut auf 1. Das mache ich, um zu registrieren, dass der Lüfter ausgegangen ist. Würde man den Lüfter bei 30°C einfach wieder anspringen lassen, könnte es passieren, dass der Lüfter ständig an und aus geht, wenn die Temperatur um 30°C pendelt. Da so etwas störend ist, frage ich fanOut ab. Wenn fanOut = 1 ist weiß der Arduino, dass der Lüfter aus ist und wir sagen ihm er soll aus bleiben, solange fanOut auf 1 steht.
Wenn die Temperatur jetzt auf 32 °C steigt, setze ich fanOut wieder auf 0 zurück. Jetzt kann der Lüfter wieder anlaufen. Auf diesem Weg haben wir eine Einschaltdifferenz (Hysterese) von ca. 2°C eingebaut. Der Lüfter schaltet bei 30°C ab und erst bei 32°C wieder an.
Ausserdem lasse ich den Lüfter kurz mit 100% PWM Wert anlaufen um das Anlaufmomend des Lüfters zu überwinden.
Zu guterletzt wird noch fanSpeed am Seriellen Monitor, und dann per analogWrite an den Lüfter ausgegeben.
 
 
Das war es auch schon  fertig
 
 
 
 
downloadbutton arduino
 
 

 

Seitennavigation
 
arrow button prev               arrow button up                            

Einen Kommentar verfassen

Als Gast kommentieren

0
  • Keine Kommentare gefunden
Zum Seitenanfang Menü