4.1.3 - Drehzahl mit Temperatursteuerung

 

Dieses Tutorial ist eine Zusammenführung von "3.4 - Temperaturgesteuerter Lüfter" und "4.1.1 - Statische Drehzahl auslesen".
Ich füge dabei den benötigten Code um die Drehzahl des 3 Pin Lüfters auszulesen, aus dem Teil 4.1.1 in 3.4 ein und lasse die Drehzahl am Seriellen Monitor ausgeben. Das erfassen der Drehzahl passiert wieder über das schon von mir beschriebene Pulse Stretching.
 
 
 
 

Teileliste

 
 
 
 

Anschlussplan

 
anschlussplan 4.3     schaltplan 4.3
 
 
 
 

Code

 

// Konstanten
const int fanPin = 9;                 // Pin für den Lüfter
const int tachoPin = 2;               // Pin des Tachosignals des Lüfters
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
const int abfrageZahl = 5;            // Je mehr abfragen, desto stabiler isr das Ergebnis, dauert aber länger

// 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 abfrage[abfrageZahl];    // Array Variable für das Mitteln der Temperatur http://arduino.cc/de/pmwiki.php?n=Reference/Array
float durchschnitt = 0;      // Variable für das Mitteln der Temperatur
float temp;                  // Variable für die Berechnung der temperatur nach Steinhart
int abfrZeit = 2000;         // Zeitabstand für die Abfragen des Tachosignals
long tachoMillis = abfrZeit; // Zeitabstand für Pulse Stretching Funktion 
float rps = 0;               // Variable mit Kommastelle für die Berechnung der Umdrehungen pro Sekunde
int rpm = 0;                 // Variable für die gemittelte Drehzahl
float umdrZeit = 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 
 

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
  pinMode(tachoPin, INPUT);       //Setzt den Tacho Pin 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;
  }
  
  analogWrite(fanPin, fanSpeed);      // Den Lüfter mit dem PWM Wert ansteuern
  
  // Alle 2000ms pulse_stretch starten um die Drehzal auszulesen
  if((millis() - tachoMillis) >= abfrZeit)
  {      
    pulse_stretch();
  } 
} 


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);
}


void pulse_stretch()
{
  if (fanOut == 0)
  {
    analogWrite(fanPin, 255);              // Den Lüfter konstant mit Strom versorgen damit das Tachosignal funktioniert
    flankenZeit = pulseIn(tachoPin, HIGH); // Abfrage der Zeit pro Puls in Mikrosekunden
    analogWrite(fanPin, fanSpeed);         // Setzt die Lüftergeschwindigkeit zurück
    umdrZeit = ((flankenZeit * 4)/1000);   // Berechnung der Zeit pro Umdrehung in Millisekunden
    rps = (1000/umdrZeit);                 // Umrechnung auf Umdrehungen pro Sekunde
    rpm = (rps*60);                        // Umrechnung auf Umdrehungen pro Minute
  
    Serial.println(rpm);                   // Ausgabe der Drehzahl im Seriellen Monitor
  }
  else
  {
    Serial.println("0");                   // Ausgabe von 0 RPM
  }
  
  tachoMillis = millis();      // Die TachoMillis werden aktualisiert um die nächsten 2000ms zählen zu können    
}

 
 
Nachdem die Konstanten und Variablen gesetzt sind, starten wir im setup. Hier wird zu allererst dieFrequenz des PWM Ausgangs 9 und 10 auf 31300kHz gesetzt, damit der Lüfter nicht pfeift und dann die Ein- und Ausgänge deklariert.
Im loop angekommen starten wir mit dem Aufruf der temberaturberechnung Funktion.
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 soetwas störend ist, Farge 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 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.
 
Als nächstes wird per if Befehl abgefragt, ob 2000ms vergangen sind. Wenn das zutrifft wird die Funktion pulse_stretch ausgeführt.
In der puls_stretch Funktion wird als erstes mit einer if Abfrage geprüft, ob der Wert von fanOut 0 ist und der Lüfter somit läuft. Wenn das zutrifft, wird der Lüfter mit einem PWM Wert von 255 (100%) angesteuert, damit er ein sauberes Tachosignal ausgibt.
Dann wird die Zeit zwischen zwei Flanken des Tachosignals per pulsIn Befehl (Erklärungerfasst und in der Variable flankenZeit gespeichert. Dieser Vorgang dauert nur wenige Millisekunden und beeinflusst so die Drehzahl nicht viel. Anschließend senken wir die Geschwindigkeit des Lüfters wieder auf seinen Ausgangswert.
Jetzt kommt die Berechnung der Drehzahl mittels der erfassten flankenZeitDer berechnete Wert wird dann am Seriellen Monitor dargestellt.
Zum Schluss muss die Variable tachoMillis auf den aktuellen Wert der millis gesetzt werden, damit die nächste Abfrage im loop funktioniert und pulse_stretch wieder ausgeführt werden kann.
 
 
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ü