PWM Regelung von Ventilatoren oder Motoren

Wie man die Geschwindigkeit von Ventilatoren mit wenig Aufwand mittels PWM regelt.

Wie bereits im Beitrag „Der Server im Kasten des schwedischen Möbelherstellers“ erklärt, habe ich einen kleinen „Serverraum“ in einem Schuhkasten untergebracht.
Der Einbau von Ventilatoren hat die Temperatur schon um einiges gedrückt.
Nur einen Dauerlauf und somit verbunden, einiges an Lärm will man nicht wirklich.
Daher sollen die Ventilatoren mittels Mikrocontroller und PWM Steuerung in deren Geschwindigkeit variiert werden,
um ein Mittelmass an Kühlung und Lärm zu erreichen.

Überlegungen zu diesem Vorhaben:
Welche Ansteuerung der Ventilatoren?
Hardware: Welche Voraussetzungen sollen erfüllt werden?
Hardware: Welchen Mikrocontroller benutzen?
Software: Welche Sprache, Librarys vorhanden?

Welche Ansteuerung der Ventilatoren?
Es gibt mehrere Möglichkeiten, um Gleichstrom Ventilatoren zu steuern.
Ich habe mich für die Ansteuerung mittels PWM entschieden, da der Aufwand sich in Grenzen hält und Ventilatoren im Allgemeinen damit leicht zu steuern sind.
Der entscheidende Nachteil ist aber, dass man sich eine eventuelle EMV Schleuder bastelt.
Um dies zu verhindern, sollte die PWM Frequenz gut gewählt werden und die Leitungslängen so klein wie möglich gewählt werden.
Auch eine zusätzliche Schirmung der Leitungen kann die Störabstrahlung minimieren.
Es sollte aber auch erwähnt werden, dass sich nicht jeder Ventilator per PWM steuern lässt.
Ein zusätzliches LC oder RC Glied kann da meist Besserung bringen.
Wer es einfacher haben möchte, greift auf einen Ventilator mit integrierter Temperatursteuerung oder mit einem PWM Steuereingang zurück.

Hardware: Welche Voraussetzungen sollen erfüllt werden?
Es soll eine Platine mit dem Programm EAGLE entworfen werden, mit der die Ventilatoren angesteuert werden.
Alle drei sollen parallel geschalten werden, um den Bauteilaufwand gering zu halten.
Auf der Platine soll auch ein DS18B20 1wire Sensor Platz finden um die Temperatur im Kasten direkt messen zu können.
Anstatt des auf der Platine befindlichen DS18B20 im TO92 Package, soll auch ein DS18B20 mit Kabel und Edelstahlhülse verwendet werden können, um weiter entfernte Hotspots messen zu können.
Die PWM Steuerung an sich soll über einen N-Chanel Lowside Switch erfolgen, welcher gleich durch eine passende Freilaufdiode geschützt wird.
Auf RC und LC Filter wird auf der Platine verzichtet, da Diese nicht immer von Nöten sind und leicht nachgebaut werden können.
Die Platine soll universell gehalten werden um damit auch Heizungen mittels PWM steuern zu können!!!
Es sollen alle Versorgungen und Abgänge auf Leiterplattenklemmen gelegt werden, um den Anschluss zu vereinfachen.
Natürlich sollen nur bedrahtete Bauteile Einsatz finden, damit der Bausatz jederzeit nachgebaut werden kann.

Hardware: Welchen Mikrocontroller benutzen?
Der Mikrocontroller sollte einige einfache Voraussetzungen erfüllen:
Kleiner Footprint
Händisch lötbar
Mindestens einen PWM Ausgang
Mindestens zwei digitale Eingänge für einen digitalen Temperaturfühler und einer LED zum debuggen

Dadurch, dass ich sehr viel mit den PIC Controllern der Firma Microchip arbeite, fiel meine Wahl auf den PIC12F1572.
Der grösste Auswahlpunkt war, dass bereits die ganze Toolchain vorhanden ist und nicht neu erworben werden muss.

Software: Welche Sprache, Librarys vorhanden?
Hier fiel meine Wahl auf Mikrobasic Pro von der Firma Mikroe.
Bis 2kB ist die Demoversion frei und dadurch für dieses Projekt mehr als ausreichend.
Basic ist auch für Anfänger meist selbsterklärend und leicht lernbar.
Ein Beispiel zum Auslesen eines DS18B20 liegt der Demoversion bei, damit muss das Rad also nicht neu erfunden werden.
(Vielleicht übersetze ich die Software einmal bei Bedarf nach C.)

OK. Lets go ….

Am Anfang wird einmal ein Schaltplan gezeichnet und eine Platine designt.

Da die Fertigung der Platine ein wenig dauert kann gleich auf einen anderen wichtigen Punkt eingegangen werden:
Überlegungen zur Software, wann der Ventilator bei welcher Temperatur mit welcher Geschwindigkeit drehen soll.
Dafür habe ich einige Messungen durchgeführt.
Mangels PWM Regelung (Henne-Ei-Problem) wurde ein einstellbares Universalnetzteil verwendet, um die Geschwindigkeit der Ventilatoren zu steuern.
Parallel dazu wurden immer die Temperaturen des Kastens, des NAS sowie der zwei im NAS enthaltenen Festplatten ermittelt.
Nach einigen Tagen (Das System ist sehr träge !!!) habe ich endlich eine Tabelle erstellen können, welche mir gleich verkündete, dass die Kastentemperatur in etwa (Nur in etwa!) der Festplattentemperatur entspricht.
Das ist schon mal sehr gut, da die Ventilatoren primär für den Lebenserhalt der Festplatten verbaut wurden.

Was die Tabelle auch schön zeigt: Es genügt schon eine kleine Drehzahl (in diesem Fall Spannung), um die Temperatur signifikant zu senken.
Ein kleine Drehzahl bedeutet direkt proportional mehr Ruhe in der Hütte ! -> Ziel fast erreicht.

Eine Woche später … Hurra, die Platinen sind da!
Also ran ans löten.

Zuerst werden die zwei 10k Widerstände (R2 und R3) bestückt.

Danach der 4k7 Widerstand (R1).

Gefolgt vom 1k Widerstand (R9).

Gleich darauf die 100nF Keramikkondensatoren (C1,C2,C3,C4) und den Spannungsregler (IC1)

Danach den Pinheader für ICSP und den PIC Controller.
(Ich habe mich entschieden den PIC zu sockeln, um eventuell mal andere Prozessoren darin zu verwenden.)

Weiter geht es mit dem IRLZ34N Mosfet (Q1) und der MBR1060 Diode (D1).

Anschliessend die zwei 100µF Elektrolytkondensatoren (C5 und C6) und der grünen LED (LD).
Wie immer gilt bei der LED: Das lange Bein ist die Anode (Also +) !

Klemmen drauf und: FERTIG !

Den DS18B20 Sensor habe ich unbestückt gelassen, da ich den externen DS18B20 im Edelstahlgehäuse verwenden möchte.

Nächster Punkt: Die Software.

Diese soll in vier Teile aufgeteilt werden:

1. Einlesen der Temperatur vom DS18B20
2. Ausgabe der aktuellen Temperatur und Ventilatorendrehzahl per UART
3. Berechnen der notwendigen Ventilatorendrehzahl
4. Umrechnen von % in die benötigte Periode und Ausgabe am PWM Ausgang

1. Einlesen der Temperatur vom DS18B20:
Da Mikrobasic ein Sample zum Einlesen eines DS18B20 beilag, musste Dieses nur noch optimiert und angepasst werden:
sub procedure ReadTemperature
      dim temp as word   ‚Storage for 1wire read
      dim temp_whole as byte   ‚Temperature without fractions
     Ow_Reset(PortA, 5)   ‚Reset Onewire
     Ow_Write(PortA, 5, 0xCC)   ‚Send SKIP_ROM
     Ow_Write(PortA, 5, 0x44)   ‚Send CONVERT_T
     Delay_ms(1000)   ‚Wait 1 second for conversion end
     Ow_Reset(PortA, 5)   ‚Reset Onewire
     Ow_Write(PortA, 5, 0xCC)  ‚Send SKIP_ROM
     Ow_Write(PortA, 5, 0xBE)   ‚Send READ_SCRATCHPAD
     lo(temp) = Ow_Read(PortA, 5)   ‚Read first byte ‚Write to UART
     hi(temp) = Ow_Read(PortA, 5)   ‚Read second byte
     Temperature = word(temp >> 4)   ‚Discard the 4 right bits for DS18B20
end sub

2. Ausgabe der aktuellen Temperatur und Ventilatorendrehzahl per UART
Dank integrierter Librarys simpel zu bewerkstelligen:
UART_Write(Temperature)    ‚Send Temperature
UART_Write(Fan_Speed)    ‚Send Fan_Speed

3. Berechnen der notwendigen Ventilatorendrehzahl:

Die Steuerung soll recht einfach sein.
Bei einer Mindesttemperatur sollen die Ventilatoren mit einer Mindestdrehzahl drehen.
Steigt die Tempertur weiter an, so soll die Drehzahl linear bis zur Maximaltemperatur erhöht werden.
Also:
TempFloat = float(100.0 – MinimumSpeed) ‚Calculate the multiplier.
TempFloat = TempFloat / float(MaximumTemperature – MinimumTemperature) ‚Calculate the multiplier
TempWord = word(TempFloat * (Temperature – MinimumTemperature)) ‚Calculate the speed
TempWord = TempWord + MinimumSpeed ‚Calculate the speed
Fan_Speed = byte(TempWord) ‚Set the speed
If Fan_speed > 100 then ‚Limit the FAN speed to 100%
     Fan_speed = 100
end if
If Fan_speed < MinimumSpeed then ‚Limit the FAN speed to MinimumSpeed
     Fan_speed = MinimumSpeed
end if

Bei Unterschreiten einer Ausschalttemperatur, sollen die Ventilatoren stehen bleiben, um nicht unnötige Betriebsstunden zu generieren:
if Temperature <= SwitchOffTemperature then  ‚Switch off the FAN under SwitchOffTemperature
     Fan_Speed = 0
     FAN_Stop
end if
Dadurch, dass die Ventilatoren ausgeschalten werden können, kann sich ein anderes Problem ergeben welchem unbedingt vorgebeugt werden muss.
Wollen die Ventilatoren mit der Mindestdrehzahl starten und sind Diese schon einige Zeit im Einsatz, so kann es aufgrund von Verunreinigungen an den Lüfterblättern vorkommen, dass der Ventilator nicht wegläuft.
Die Gegenmassnahme ist simpel.
Wird der Start angefordert, so laufen die Ventilatoren für eine gewisse Zeit mit einer erhöhten Geschwindigkeit an, bevor Sie auf die vorgegebene Geschwindigkeit zurückkehren.
In der Software wird der Vorgang als „WindUp“ bezeichnet und die Zeit und Drehzahl in der Datei „Hardware.mbas“ frei wählbar. Es wird bei jedem FAN_Start ausgeführt:

sub procedure Fan_Start()
    PWM3TMRH = $00    ‚Set actual PWM3 timer to 0
    PWM3TMRL = $00    ‚Set actual PWM3 timer to 0
    PWM3OE_bit = 1    ‚Enable PWM3 output
    PWM3EN_bit = 1    ‚Enable PWM3
    If WindUpAtFanStart then    ‚Check if FAN windup is selected
         Fan_Speed = WindUpSpeed    ‚Set the windup speed, if enabled
         Fan_Set_Speed()    ‚Set the fan speed
         LED = true    ‚Switch on LED
    for TempByte = 0 to WindUpTime    ‚Wait the winduptime
         clrwdt    ‚Clear the watchdog timer
         delay_ms(1000)    ‚Wait 1 second
    next tempbyte
    LED = false    ‚Switch off LED
    end if
end sub

4. Umrechnen von % in die benötigte Periode und Ausgabe am PWM Ausgang

Bevor der PWM Ausgang befeuert werden kann, muss der dahintersteckende Timer wissen, wie weit er zählen soll und welche Taktquelle er verwenden soll.

Wir erledigen das gleich im Sub „InitHardware„ :
PWM3CLKCON = $00    ‚Config PWM 3
PWM3LDM_bit = 0    ‚Config PWM 3
PWM3CON = $00     ‚Config PWM 3
PWM3DCH = $00    ‚Config PWM 3
PWM3DCL = $00    ‚Config PWM 3
PWM3PHH = $00    ‚Config PWM 3
PWM3PHL = $00    ‚Config PWM 3
PWM3OFH = $00    ‚Config PWM 3
PWM3OFL = $00    ‚Config PWM 3
PWM3PRH = 5    ‚Config PWM 3 Frequency = 10666 Hz
PWM3PRL = 220    ‚Config PWM 3 Frequency = 10666 Hz

Am interessantesten ist natürlich das Register PWM3PRH und PWM3PRL.
Aber wie kommt man auf diesen Wert?
Recht einfach: Ausrechnen.

Der Value für das Period Count Register wird wie folgt berechnet:
(1 / PWM_Frequenz) * (CPU_Frequenz / Divider)
(Der Divider wird benötigt, falls der Wert 65535 überschreiten würde)

Bei mir ergibt sich bei einer Frequenz von 16Mhz und einer PWM Frequenz von 10666°Hz bei einem Vorteiler von 1 ein Wert von:
(1 / 10 666) * (16 000 000 / 1) = 1500

Dieser Wert ist natürlich ein Erfahrungswert und für uns sehr gut geeignet.
Denn um den Dutycycle zu setzen wird die folgende Funktion ausgeführt:
sub procedure Fan_Set_Speed()
    dim duty as word
    duty = Fan_speed * 15    ‚Calculate the new duty cycle
    PWM3DCH = hi(duty)    ‚Set the new duty cycle
    PWM3DCL = lo(duty)    ‚Set the new duty cycle
    PWM3LD_bit = 1    ‚Load PWM3 with new duty cycle
end sub
Wie Ihr sehen könnt, wird hier eine unötige Gleitpunkt Operation vermieden, welche dem freien Flashspeicherplatz zu Gute kommt.

Die Software inklusive Sourcecode könnt Ihr natürlich im Downloadbereich herunterladen.
Wenn Ihr die Software weiterverbreitet, bitte einen Link auf meine Seite setzen 😉

Ein Bausatz der PWM Regelung kann in unserem Shop bezogen werden.

Sodala. Projekt erfolgreich beendet 😀

Bei Wünschen und Anregungen könnt Ihr eueren Kommentar absetzen 😉