4.2.3 - Drehzahl mit Temperatursteuerung

 

Dieses Tutorial ist eine Zusammenführung von "3.4 - Temperaturgesteuerter Lüfter" und "4.2.1 - Statische Drehzahl auslesen".
Ich verschmelze dabei den Code um die Drehzahl des 4 Pin Lüfters auszulesen, mit dem des per 10kΩ NTC Wiederstand gesteuerten Lüfters und lasse die Drehzahl am Seriellen Monitor ausgeben.
 
 
 
 

Teileliste

 
 
 
 

Anschlussplan

 
anschluss 4.2.3     Schaltplan 4.2.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
byte 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
int abfrZeit = 1000;       // Zeitabstand für die Abfragen des Tachosignals
int rpm = 0;               // Variable für die gemittelte Drehzahl
float rps = 0;             // Variable mit Kommastelle für die Berechnung der Umdrehungen pro Sekunde
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
float durchschnitt = 0;    // Variable für das Mitteln der Temperatur
float temp;                // Variable für die Berechnung der temperatur nach Steinhart
unsigned long tachoMillis = abfrZeit;   // Variable zum speichern der Zeit


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()
{
  // Alle 1000ms die die Temperatur berechnen und die Drehzal auslesen
  if((millis() - tachoMillis) >= abfrZeit)
  { 
    temperaturberechnung();      // Startet die Temperaturerfassungsroutine
  
    // Lüftergeschwindigkeit über den Temperaturbereich verteilen
    // TMin->0% PWM | TMax->100% PWM
    fanSpeed = map(temp, tMin, tMax, 50, 255);    
  
    // Wenn die Temperatur unter tMin fällt, Lüfter auf niedrigste Stufe schalten
    if (temp < tMin)
    {
      fanSpeed = 0;
    }
    
    analogWrite(fanPin, fanSpeed);      // Den Lüfter mit dem PWM Wert ansteuern
    
    // Erfassen der Drehzahl
    flankenZeit = pulseIn(tachoPin, LOW);    // Abfrage der Zeit pro Puls in Mikrosekunden
    umdrZeit = ((flankenZeit * 4)/1000);     // Berechnung der Zeit pro Umdrehung in Millisekunden
    rps = (1000/umdrZeit);                   // Umrechnung auf Umdrehungen pro Sekunde
    rpm = (rps*6);                           // Schritt 1 zur Rundung auf 10er Schritte der Drehzahl
    rpm = (rpm*10);                          // Schritt 2 zur Rundung auf 10er Schritte der Drehzahl
    Serial.print("Drehzahl: ");              // Ausgabe der Drehzahl im Seriellen Monitor
    Serial.print(rpm);                       // Ausgabe der Drehzahl im Seriellen Monitor
    Serial.println(" RPM");                  // Ausgabe der Drehzahl im Seriellen Monitor
    tachoMillis = millis();      // Die TachoMillis werden aktualisiert um die nächsten 1000ms zählen zu können 
  }
} 


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

 
 
Fangen wir mit den Konstanten an. Hier haben wir ein paar für die Berechnung wichtige Werte, die ich jetzt erläutere.
  • ntcNominal = 10000 - Damit ist der Widerstand des NTC bei Nominaltemperatur gemeint. Dieser Wert wird immer im Namen schon angegeben.                                                                                       Ein 10kΩ NTC hat einen Widerstand von 10000Ω.
  • 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 Widerstand, der zusammen mit dem NTC Widerstand verbaut wird. In unserem Fall auch ein 10kΩ Widerstand.
  • abfrageZahl = 5
  • abfrage[abfrageZahl]
abfrageZahl und abfrage hängen zusammen und bestimmen mit wie vielen Messwerten des NTC gemittelt wird. Je höher der Wert, desto weniger sprunghaft ist der Temperaturwert, allerdings dauert die Erfassung auch länger.
Nachdem die Konstanten und Variablen gesetzt sind, starten wir im setup. Hier wird zu allererst die Frequenz 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 Abfragen der Zeit. Wenn 1000ms vergangen sind wird fie Funktion temberaturberechnung aufgerufen. 
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.
Jetzt folgt die Erfassung der Drehzahl. Dazu wird die Zeit zwischen zwei Flanken des Tachosignals per pulsIn Befehl (Erklärungerfasst und in der Variable flankenZeit gespeichert. 
Dann 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.
 
 
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ü