Dauerkalender

Lüftersteuerung via PWM

(ESP32, PWM Lüfter mit Tacho, Interrupt, Zweipunktregler)

In dem Versuch wird die Drehzahl eines Lüfters gesteuert. Bei dem Lüfter handelt es sich um das Model Noctua NF-A4x20 PWM. Der Lüfter weist vier Anschlüsse auf. Zwei Anschlüsse dienen der Spannungsversorgung, die 12 VDC beträgt. Der dritte Anschluss ist die Tacholeitung. Über die Tacholeitung ist es möglich, die aktuelle Drehzahl des Lüfters zu ermitteln. Pro eine Umdrehung liefert der Lüfter an der Leitung zwei Signale, die gezählt werden können. Die Signale werden wir als Rückmeldung zur aktuellen Drehzahl in unserem Steuerkreis verwenden. Über den vierten Anschluss lässt sich der Lüfter mithilfe eines PWM-Signals steuern. Diesen Anschluss nutzen wir, um die aktuelle Drehzahl des Lüfters zu beeinflussen. Die Drehzahl des Lüfters wird im Bereich 2000 bis 5000 Umdrehungen pro Minute geregelt. Bei niedrigeren Drehzahlen verhält sich der Lüfter schon ziemlich unzuverlässig, eine verlässliche Regelung ist hier nicht möglich. Bei ganz niedrigen Drehzahlen bleibt der Lüfter stehen. Die Regelung selbst realisieren wir auf dem einfachsten Wege: mit einem Zweipunktregler. Ist die aktuelle Drehzahl zu niedrig, wird der Lüfter beschleunigt. Und entsprechend umgekehrt: Ist die Drehzahl zu hoch, wird der Lüfter abgebremst. Damit unser Regelkreis gelegentlich auch zur Ruhe kommt und sich keine Schwingungen einstellen, legen wir hier zugrunde eine Drehzahltoleranz von +/- 100 Umdrehungen pro Minute. Das Ziel, die gewünschte Drehzahl, wird mithilfe eines Potentiometers eingestellt. Die Vergleich- und Rechenaufgaben erledigt für uns der Mikrocontroller ESP32.

ESP32

Das Fundament unseres Regelkreises besteht aus zwei Faktoren, für die zwei GPIOs des Mikrocontrollers zuständig sind. Mit dem Eingang GPIO 32 wird die aktuelle Drehzahl des Lüfters ermittelt. Für die Zählung der Signale, die der Lüfter liefert, ist ein Interrupt zuständig. Dabei handelt es sich um eine Funktion, die in Echtzeit ausgeführt wird. Eine Interrupt-Funktion wird immer in dem Zeitpunkt ausgeführt, in dem ein Ereignis eintritt und zwar unabhängig davon, was das Hauptprogramm gerade macht. Mit dem zweiten GPIO Nummer 18 wird die Drehzahl des Lüfters beeinflusst. Hier wird ein PWM-Signal ausgegeben, das von der internen Elektronik des Lüfters ausgewertet wird.

ESP32

Lüfter NF-A4x20 PWM

Der Lüfter ist ein Noctua NF-A4x20 PWM. Er benötigt eine konstante Spannungsversorgung von 12 VDC. Seine Drehzahl kann mithilfe eines PWM Signals gesteuert werden. An seinem Tacho-Anschluss liefert er zwei Signale pro Umdrehung, die es ermöglichen, seine aktuelle Drehzahl zu ermitteln. Sofern man die PWM Steuerung nicht nutzen will, kann die Drehzahl des Lüfters auch durch Änderung der Spannungsversorgung beeinflusst werden.

Lüfter Frontansicht

Rückansicht

Technische Daten:
Versorgungsspannung: 12 VDC
Drehzahl: 1200 - 5000 U/Min
Steuerung: PWM
Luftstrom: 9,4 m³/h
Geräuschpegel: 14,9 dB
Leistung: 0,6 W
Stromaufnahme: 0,05 A
Anschluss: 4-Pin
Tacho: 2 Signale pro Umdrehung
Abmessungen: 40 x 40 x 20 mm
Lebensdauer: 150.000 h

Anschluss

Display

Auf dem zweizeiligen Display werden die aktuellen Werte der Ist- und der Solldrehzahl angezeigt.

Spannungsregler

Spannungsregler mit LM2596

Spannungsregler mit LM317

In der Form arbeitet die Schaltung mit drei Spannungen. Die Hauptversorgung des Lüfters beträgt 12 VDC. Der Mikrocontroller arbeitet grundsätzlich mit 3,3 VDC. Das Display verlangt eine Spannungsversorgung von 5 VDC. Für die 3,3V ist ein fertiges Modul mit einer 7-Segmentanzeige zuständig. Das Modul basiert auf dem IC LM2596. Die 5 VDC liefert ein selbst gebasteltes Modul, das auf dem einstellbaren Spannungsregler LM317 basiert.

Der Schaltplan

Der Schaltplan.

Die Testschaltung

Die Testschaltung

Das Programm (Sketch)

  #include "LiquidCrystal_I2C.h"                     // 16x2 anbinden
  LiquidCrystal_I2C lcd(0x27,16,2);                  // Adresse, Zeichen, Zeilen
 
  int Zaehler = 0;
  int TachoPin = 32;                                 // GPIO für Rückmeldung vom Lüfter
  int Poti_Eingang = 33;                             // GPIO Potentiometer (SOLL)
  int Drehzahl_IST;                                  // Drehzahl IST Mittelwert
  int Drehzahl_SOLL;                                 // Drehzahl SOLL Mittelwert
  int PWM_Wert;                                      // PWM Wert am GPIO 18
  int PWM_Ausgang = 18;                              // GPIO für PWM
  float Wertetabelle [2][11];                        // Mittelwerte 0-Soll, 1-Ist
                                                     
// ******************************************************************************************
  void setup() {

      lcd.init();                                    // Display initialisieren 
      lcd.backlight();                               // Hintergrundbeleuchtung Ein
      pinMode (TachoPin, INPUT_PULLUP);              // Eingang Tacho als PullUp
      ledcSetup (0, 100, 13);                        // PWM: Kanal, Frequenz, Auflösung
      ledcAttachPin (PWM_Ausgang, 0);                // GPIO 18, Kanal 0
                                                     // Interrupt, fallende Flanke
                                                     
      attachInterrupt(digitalPinToInterrupt(TachoPin), Impuls_Zaehler, FALLING);
  }

// ******************************************************************************************
  void loop() {

                                                                 // Aktuelle Werte eintragen
      Wertetabelle [0][10] = analogRead (Poti_Eingang) * 1.2212; // 5000 / 4095 = 1.221
      Wertetabelle [1][10] = Zaehler * 30;                       // = (Zaehler / 2) * 60;      
      Mittelwert_Berechnung ();                                  // Mittelwerte berechnen
    
      lcd.setCursor(0,0);                                        // Display Cursor Position
      lcd.print ("RPM SOLL: " + String(Drehzahl_SOLL) + "  ");   // Display Ausgabe SOLL-Wert
      
      lcd.setCursor(0,1);                                        // Display Cursor Position
      lcd.print ("RPM IST:  " + String(Drehzahl_IST) + "  ");    // Display Ausgabe SOLL-Wert
      
      String Im_Ziel = "*";                                        // Regelziel erreicht
      int Schritt = abs(Drehzahl_SOLL - Drehzahl_IST) / 4;       // Nachstellwert
      if (Drehzahl_SOLL - Drehzahl_IST > 100) {                  // Aktuelle Werte prüfen
          PWM_Wert = PWM_Wert + Schritt;                         // ggf. PWM Wert erhöhen
          Im_Ziel = "-";                                         // Regelziel verfehlt
      }
      if (Drehzahl_IST - Drehzahl_SOLL > 100) {
          PWM_Wert = PWM_Wert - Schritt;                         // oder erniedrigen
          Im_Ziel = "-";                                         // Regelziel verfehlt
      }
      lcd.setCursor(15,1);                                       // Display Cursor Position
      lcd.print (Im_Ziel);                                       // Display Ausgabe Regelziel      
      if (PWM_Wert < 800) { PWM_Wert = 800; }                    // PWM untere Grenze
      if (PWM_Wert > 7150) { PWM_Wert = 7150; }                  // PWM obere Grenze
      ledcWrite (0, PWM_Wert);                                   // PWM Signal ausgeben
      Zaehler = 0;                                               // Zähler nullen
      delay (1000);                                              // Wartezeit 1 Sek.  }

// ******************************************************************************************
  void Impuls_Zaehler() {                                        // Tacho Signale
                                                           
      Zaehler++;                                                 // Zähler um 1 erhöhen
  }  

// ******************************************************************************************
  void Mittelwert_Berechnung () {                                // Mittelwerte
      
      for (int i=0; i<9; i++) {
          Wertetabelle [0][i] = Wertetabelle [0][i+1];
          Wertetabelle [1][i] = Wertetabelle [1][i+1];
      }
      Wertetabelle [0][9] = Wertetabelle [0][10];
      Wertetabelle [1][9] = Wertetabelle [1][10];
      float Summe1 = 0;
      float Summe2 = 0;
      for (int i=0; i<10; i++) {
          Summe1 = Summe1 + Wertetabelle [0][i];
          Summe2 = Summe2 + Wertetabelle [1][i];
      }
      Drehzahl_SOLL = Summe1 / 10;
      if (Drehzahl_SOLL < 2000) { Drehzahl_SOLL = 2000; }        // SOLL untere Grenze
      Drehzahl_IST = Summe2 / 10;
  }

// ******************************************************************************************   
  

Das Programm besteht aus zwei Teilen. Den ersten Teil bildet der Interrupt mit seiner Zählfunktion. Sobald ein Signal von Lüfter am Eingang GPIO 32 auftaucht (Das Signal ist LOW aktiv. Mit dem Signal wird der Eingang mit Masse verbunden), wird das Hauptprogramm unterbrochen und das Unterprogramm „Impuls_Zaehler()“ ausgeführt.
In dem zweiten Teil (Hauptprogramm) agiert unser einfacher Zweipunktregler. Es wird einmal pro Sekunde die aktuelle Drehzahl mit der Sollvorgabe verglichen und entsprechend mithilfe des PWM-Signals der Lüfter beschleunigt oder abgebremst.
Diese einfache Regelung schafft es innerhalb von einigen Sekunden den Lüfter auf die gewünschte Drehzahl einzustellen.
Da die Signale so von dem Potentiometer als auch von der Tacholeitung ein wenig hier und her wandern, arbeite ich hier mit Mittelwerten. Zur Bestimmung der aktuellen Ist- und Solldrehzahl werden stets die zehn letzten Messungen berücksichtigt.

Kurzvideo

Kurzvideo

Weitere Themen: