![]()
| 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. ESP32Das 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 PWMDer 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:
![]() 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)// ******************************************************************************************// Lüfter Regelung mit PWM // Drehzahlregelung eines PWM-Tacho-Lüfters mit Zweipunktregler // Schaltung mit dem Mikrocontroller ESP32 und NF-A4x20 Lüfters (4 Pins) // IDE 1.8.19 // ****************************************************************************************** #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.
|
Google-Suche auf MEINE-SCHALTUNG.de : |