Lüftersteuerung Raspberry Pi

Lüftersteuerung Raspberry Pi Titelbild

Folgende Teile braucht ihr für die Anleitung

Lüftersteuerung Raspberry Pi Kit Produktbild

Lüftersteuerung Raspberry Pi Kit | 19.95€

Raspberry Pi Lüfter steuern

Wir freuen uns das du dich für ein Jugend Programmiert Kit entschieden hast. Programme sind überall, sichtbar und unsichtbar. Als Programmierer verstehst du die moderne Welt und hast die Macht diese etwas besser zu machen. Viel Spaß mit diesem praxisorientierten Python3 Hardware programmieren Tutorial, wünscht die das Team von Jugend Programmiert.

In dieser Anleitung zeigen wir dir wie man die einen Lüfter und drei Status LEDs an den Pi anschließt und steuert. Mit den LEDs zeigen wir wie warm dein Pi ist. Wird er zu heiß, schalten wir den Lüfter an. Wenn der Pi kalt ist schalten wir den Lüfter wieder aus. Wir benutzen Pyrthon3 als Programmiersprache. Einen Einstieg in Python3 bekommst du in unserem Starterkit.

Vor dem Start: Du brauchst einen Raspberry Pi mit installiertem Raspbian. Alle Informationen zum Installieren, Updaten, Upgraden und einrichten deines Systems bekommst du im Raspberry Pi 3 Starter Guide aus dem Pi3 Starter Set (link)

Was wir machen: In dieser Anleitung zeigen wir die die Grundlagen von Python3 beim steuern von GPIO Pins. In dem Raspberry Pi Temperatursteuerungs Kit, findest du die Hardware die du benötigst. Schritt für Schritt erklären wir dir, wir du deine Steuerung programmierst und aufbaust. Am Anfang programmieren wir das Auslesen der CPU Temperatur deines Raspberry Pi. Dann legen wir drei Temperaturbereiche fest. Mit LEDs zeigen wir an in welchem Temperatur-Bereich dein Pi gerade ist. Falls der Pi zu warm wird, schalten wir den Lüfter ein.

1: Temperatur auslesen

In diesem Teil lesen wir die Temperatur des Pi aus und vergleichen diese mit drei Werten für normal, warm und heiß. Wir geben eine Meldung aus wie warm der Pi gerade ist und welcher Temperaturbereich das ist. Hardware brauchst du dafür nicht, die nutzen wir im zweiten Teil.

Öffne ein Terminal oder logge dich über SSH auf der Konsole deines Pi ein.

Als erstes wollen wir die Temperatur auslesen. Die Temperatur deiner CPU steht in der Datei /sys/class/thermal/thermal_zone0/temp. Auslesen und ausgeben der Temperatur geht z.B. mit dem Befehl cat /sys/class/thermal/thermal_zone0/temp Das Ergebnis wird ohne , dargestellt aber mit 3 dezimalen. Zum Beispiel; 45622 das sind 45,622 Grad Celsius.

Jetzt wir wissen in welcher Datei die CPU Temperatur gespeichert ist. Diese Datei wollen wir mit Python auslesen.

Unser Programm heißt Temperatur.py und sollte im Verzeichnis /home/pi liegen. Erstelle oder öffne eine neue Datei mit dem Befehl nano Temperatur.py Falls es Datei schon gibt, wird diese geöffnet, falls nicht, erstellt der Pi eine neue leere Datei. Mit ctrl+o speicherst du die Datei. ctrl+x schließt du die Datei. Du kannst auch einen anderen Editor verwenden falls du nano nicht magst.

In die erste Zeile schreiben wir einen Kommentar. Kommentare fangen immer mit #an und werden beim ausführen des Programms ignoriert. Schreibe in die erste Zeile:

#Lüftersteuerung Version 1.
#Geschrieben von – Dein Name -

Es ist eine gute Idee Kommentare in dein Programm zu schreiben. Dann weist du später was dein Programm an dieser stelle macht. Wir fangen mit dem ersten Teil an, dem einlesen der Temperatur und der Ausgabe in der Konsole.

tempData = "/sys/class/thermal/thermal_zone0/temp"
dateilesen = open(tempData, "r")
temperatur = dateilesen.readline(2)
dateilesen.close()
print("Deine CPU hat " + temperatur + " Grad")

Erst speichern wir den Pfad der zu öffnenden Datei in einer Variable. Dann öffnen wir die Datei mit Python. Das geschieht in Zeile 2. dateilesen = open(„Pfad zu der Datei die du lesen willst“, „r“) das , „r“ steht für das englische Wort Read. Wir wollen die Datei ja nur lesen. In der dritten Zeile lesen wir die erste Zeile unserer Datei und speichern den Wert in eine variable mit dem Namen temperatur. Die (2) ist die Anzahl der Zeichen dir wir einlesen wollen. Ohne die 2 wird die ganze Zeile eingelesen, auch der nicht sichtbare Zeilenumbruch am Ende. Das kannst du einfach mal ausprobieren. Mit dateilesen.close() schließen wir die Datei, wir brauchen Sie nicht mehr. Der Wert, die Temperatur, haben wir ja gerade in die Variable temperatur geschrieben. Die 5. Zeile gibt unsere Temperatur aus. Damit es schöner aussieht haben wir vor und hinter der Temperatur noch etwas Text geschrieben.

Damit dich dieser erste Teil nicht überfordert fassen wir das ganze noch mal zusammen.

Wir öffnen eine Datei. Lesen aus dieser die erste Zeile aus und schreiben den Inhalt dieser Zeile in eine Variable. Wir schließen die Datei. Dann geben wir einen Text in der Konsole aus, dann die Variable und noch mehr Text.

Jetzt starten wir dein Programm. Das machst du mit dem Befehl python3 Temperatur.py Es sollte dir diesen Satz ausgeben:

Deine CPU hat 45 Grad

2. Temperaturen festlegen

Jetzt wissen wir wir warm der Pi ist. Abhängig von der Temperatur wollen wir den Lüfter ein oder aus machen und eine oder mehr LEDs zum leuchten bringen.

Wir müssen unserem Programm sagen welche Temperatur normal, warm oder heiß ist. Dafür öffnest du wieder dein Programm mit nano und schreibst folgende Zeilen rein.

normal = 30
warm = 50
heiss = 60

Diese Werte könnt Ihr frei anpassen, achtet darauf, dass normal kälter als warm ist und warm kälter als heiss. In Python werden Werte in Variablen gespeichert. Diese unterscheiden zwischen Text (String) und Nummern (Integer). Es gibt Variablen in denen stehen Sachen wie „Ich bin ein Text“ und andere in denen stehen Nummern zum Beispiel 5132. Unsere Temperaturen sind Nummern, also Integer. Aus der CPU Temperatur Datei bekommen wir einen Text. (String). Zum Glück ist der String eine Nummer. Wir wandeln den String in einen Integer um mit den Zeilen:

temperatur = int(temperatur)

Jetzt vergleichen wir die Temperatur mit unseren Werten:

if temperatur <= normal:
    print ("Die CPU ist normal, grüne LED an.")
if temperatur <= warm:
    print ("Die CPU ist warm, gelbe LED an")
if temperatur >= heiss:
    print ("Die CPU heiss! Rote LED an!")
        print ("Den Lüfter schalten wir auch an.")

Eine If abfrage vergleicht zwei Werte und führt Befehle aus falls diese zutreffen oder nicht. In der ersten Zeile sagen wir if temperatur <= normal geben die folgende Zeile aus. Falls die Temperatur nicht kleiner ist, wird der Befehl nicht ausgeführt. In der nächsten Zeile fragen wir ob die Temperatur > (größer) als warm ist und falls das zutrifft führen wir den nächsten Befehl aus. Die letzte Abfrage schaut ob die Temperatur größer oder gleich heiss ist und führt einen Befehl aus, oder auch nicht. Achtet darauf dass der Code der ausgeführt werden soll mit SPACE (Leertaste) oder Tab eingerückt werden muss. Wir listen dir noch mal alle Vergleichsoperatoren auf. Python kann nicht nur kleiner, größer, usw. sonder auch == (ist gleich) und != ist nicht gleich.




Vergleiche in Python
kleiner als <
größer als >
kleiner oder gleich als <=
größer oder kleiner als >=
gleich ==
nicht gleich !=

Jetzt haben wir schon eine funktionierende Temperatur Anzeige. Führe dein Programm aus mit python3 Temperatur.py. Im nächsten Teil bringen wir die GPIOs ins Spiel und lassen die LEDs leuchten.


3: LED Aufbau

In diesem Teil zeigen wir dir wie man die GPIO Pins des Raspberry Pi benutzt. Mit diesen bringen wir unsere LEDs zum leuchten und steuern den Lüfter. Auf dem Bild siehst du den Aufbau. Schalte deinen Pi aus und baue den Aufbau mit den mitgelieferten Teilen nach. Anstatt des Lüfters verwenden wir erstmal eine LED. Die LEDs solltest du immer über Widerstand anschließen, ansonsten können sie kaputt gehen. Das lange Bein der LED ist die Anode (+) und das kurze Bein die Kathode (-). Der Aufbau ist immer Pin, Widerstand, LED, und dann zu GND (Ground oder Minus)

Pin
2 Widerstand 56 Ohm Grüne LED langes Bein
3 Widerstand 56 Ohm Gelbe LED langes Bein
4 Widerstand 56 Ohm Rote LED langes Bein
17 Widerstand 56 Ohm LED langes Bein
GND Verbindest du mit Minus auf dem Breadboard

Die kurzen Beine der LED verbindest du direkt mit Ground (minus) auf dem Breadboard. Super jetzt wollen wir die LEDs zum leuchten bringen. Starte deinen Pi.

4: Lüfter und LEDs über Steuern

Damit wir die GPIOs mit Python steuern, brauchen wir die GPIO Bibliothek. Diese binden wir am Anfang unseres Scripts ein. Außerdem importieren wir die Bibliothek time. Diese ermöglicht uns den Zugriff auf Befehle wie z.B. time.sleep(10) was unser Programm 10 Sekunden schlafen lässt.

import RPi.GPIO as GPIO
import time

Jetzt definieren wir die Pins die wir belegen wollen. Für jedes Signal brauchen wir einen Pin. Wir benutzen 3 LEDs. Grün, gelb, rot und den Lüfter wir brauchen also 4 Pins. Dazu kommen noch + und - . Die GPIO Pins können als Eingang oder Ausgang benutzt werden. Eingänge sind für Signale z.B.von Temperatursensoren. Mit Ausgängen kann man Dinge mit Energie versorgen. Für unsere LEDs und den Lüfter brauchen wir Ausgänge. Es gibt verschiedene Möglichkeiten um die 40. Pins auf dem Pi zu zählen. Wir benutzen BCM. Das ist die Belegung auf dem roten Referenzbord aus dem Starter Kit und auf der kleinen Karte die im Set liegt. Wie wir die Pins ansprechen definieren wir mit der Zeile GPIO.setmode(GPIO.BCM). Jetzt müssen wir noch festlegen welche Pins wir benutzen wollen. Jeden Pin müssen wir einzeln aktivieren. Wir nutzen 2,3,4 und 17 als Ausgänge.

GPIO.setmode(GPIO.BCM)
GPIO.setup(2, GPIO.OUT)
GPIO.setup(3, GPIO.OUT)
GPIO.setup(4, GPIO.OUT)
GPIO.setup(17, GPIO.OUT)

Das Programm weiß nun, dass wir diese Pins als Ausgang nutzen. Ein Ausgang kann zwei Zustände haben. An (high) oder aus (low). Wir machen erst mal alle Pins aus.

GPIO.output(2, GPIO.LOW)
GPIO.output(3, GPIO.LOW)
GPIO.output(4, GPIO.LOW)
GPIO.output(17, GPIO.LOW)

Mit diesen Zeilen schalten wir die GPIO.output Pins mit den Nummern 2,3,4,17 auf LOW, also auf aus. Du kannst die Pins auch auf HIGH stellen, der Code sieht dann so aus:

GPIO.output(5, GPIO.HIGH)

Stelle sicher dass deine LEDs richtig angeschlossen sind und schalte sie an und aus. Zwischen dem an und aus kannst du Pausen einbauen, ohne pause schaltet die LED so schnell, dass du das nicht sehen kannst.

Pausen macht man mit dem Befehl time.sleep(2) für eine 2. Sekunden Pause. Am Ende deines Programms solltets du die Zeile GPIO.cleanup() einfügen um Fehler zu vermeiden. Durch GPIO.cleanup() wird die GPIO Pinbelegung wieder aufgehoben. Du kannst das in einem extra Script testen, das sieht dann so aus:

# LED Test Script
# schaltet 4 Pins für 10 Sekunden an

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(2, GPIO.OUT)
GPIO.setup(3, GPIO.OUT)
GPIO.setup(4, GPIO.OUT)
GPIO.setup(17, GPIO.OUT)

GPIO.output(2, GPIO.LOW)
GPIO.output(3, GPIO.LOW)
GPIO.output(4, GPIO.LOW)
GPIO.output(17, GPIO.LOW)

GPIO.output(2, GPIO.HIGH)
GPIO.output(3, GPIO.HIGH)
GPIO.output(4, GPIO.HIGH)
GPIO.output(17, GPIO.HIGH)

time.sleep(10)

GPIO.output(2, GPIO.LOW)
GPIO.output(3, GPIO.LOW)
GPIO.output(4, GPIO.LOW)
GPIO.output(17, GPIO.LOW)

GPIO.cleanup()

Alle LEDs sollten für 10 Sekunden leuchten und dann wieder ausgehen. Kannst du die LEDs nach einander leuchten lassen? Probiere es aus.

5. Lüfter anschließen.

Wenn deine LEDs funktionieren ist es an der Zeit deinen Lüfter an zu schleißen.

Über die GPIO Pins bekommen deine LEDs 3,3V. Leider reicht das nicht um den Lüfter direkt zu betreiben. Deswegen findest du in dem Kit auch einen Transistor (BC337). Ein Transistor hat drei Beine und funktioniert wie ein Schalter. Das Bein in der Mitte ist der Schalter (Base). Mit diesem schaltest du die Verbindung zwischen den anderen beiden Beinen (Collector & Emitter). Wenn du die Base mit einem GPIO Pin verbindest und diesen auf HIGH (An) setzt dann fließt zwischen den anderen beiden Beinen der Strom. Ist der Pin auf LOW (aus), dann ist die Verbindung unterbrochen. Wichtig ist die Reihenfolge ! Der Strom muss vom Collector zum Ermitter fließen. Die Plus Leitung vom Lüfter schließt du am Pi an 3,3V an. Die Minus Leitung verbindest du mit dem Collector. Der Ermitter wird mit dem Gnd (Ground) des Pi verbunden. Den Basepin verbindest du mit deinem GPIO Pin. In unserem Beispiel Pin 17.


Der Lüfter aus deinem Kit ist ein 5V Lüfter. Er funktioniert mit 5V und 3,3V. Du kannst Ihn auch an 5V anschließen, dann ist er aber etwas lauter. Daher empfehlen wir Ihn an 3,3V an zu schließen. Wenn alles funktioniert machen wir mit dem nächsten Schritt weiter.

6: GPIO und Temperatur

Wir verbinden die Abfrage der Temperatur und deine IF Schleifen mit der GPIO Steuerung. Öffne dafür wider die datei Temperatur.py. Am Anfang importieren wir wieder unsere GPIO und time Bibliothek und definieren unsere 4 Pins. Die 4 Pins schalten wir erstmal auf Low (aus).

import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(2, GPIO.OUT)
GPIO.setup(3, GPIO.OUT)
GPIO.setup(4, GPIO.OUT)
GPIO.setup(17, GPIO.OUT)

GPIO.output(2, GPIO.LOW)
GPIO.output(3, GPIO.LOW)
GPIO.output(4, GPIO.LOW)
GPIO.output(17, GPIO.LOW)

Jetzt gehen wir zu dem Teil mit der IF Schleife. Diese erweitern wir mit dem Code zum anschalten der LED.

if temperatur <= normal:
        print ("CPU Normal, grüne LED an.")
        GPIO.output(2, GPIO.HIGH)

Unter der Ausgabe mit print fügen wir die Zeile GPIO.output(2, GPIO.HIGH) ein damit die grüne LED angeht wenn die Temperatur kleiner oder gleich dem Wert für normal ist.

Das wiederholen wir mit dem Wert für warm. Falls die Temperatur größer als warm ist machen wir die grüne und die gelbe LED an.

if temperatur > normal:
        print ("CPU Warm, Gelbe LED an")
        GPIO.output(2, GPIO.HIGH)
    GPIO.output(3, GPIO.HIGH)

Als letztes vergleichen wir die Temperatur mit dem Wert heiss. Falls die Temperatur größer ist als heiß, aktivieren wir die rote LED und unseren Lüfter.

if temperatur > heiss:
        print ("CPU heiss! Rote LED und Lüfter an!")
        GPIO.output(4, GPIO.HIGH)
        GPIO.output(17, GPIO.HIGH)

Damit die LEDs und der Lüfter nicht sofort wieder ausgehen, bauen wir eine Pause ein. time.sleep(60) läßt unser Programm eine Minute warten. In dieser Minute dreht sich der Lüfter falls der Pi zu heiß war und die LEDs leuchten.

Am Ende räumen wir noch auf mit:

GPIO.cleanup()

Dein Programm kann jetzt die aktuelle CPU Temperatur deines Pi abrufen, diese mit deinen Grenzwerten für Temperatur vergleichen, LEDs und den Lüfter an und aus machen. Am Ende geht das Programm aus.

Du kannst das Programm neu starten um die Temperatur ab zu fragen und den Lüfter zu aktivieren. Viel cooler wäre es aber wenn das Programm automatisch im Hintergrund läuft.

Dafür brauchen wir eine Schleife. Schleifen laufen so lange bis etwas eintrifft. Eine While Schleife kann man mit „Solange Schleife“ übersetzen. Solange die Sonne scheint, lasse die Fenster auf. Wenn die Sonne aber nicht mehr scheint, dann schließe das Fenster.

Oder, solange die Uhrzeit nicht 9:00 Uhr ist, aktiviere nicht die Musik. Eine ähnliche Schleife läuft in deinem Wecker.

Es gibt aber auch Schleifen die laufen einfach bis ins unendliche. Genau so eine Schleife brauchen wir. Die sieht so aus:

While 1:
 #mache etwas

Am Anfang deines Programms binden wir die Bibliotheken ein und belegen die GPIO Pins. Das brauchen wir nicht jedes mal zu wiederholen. Das einlesen der Temperatur Datei wollen wir aber in jedem durchlauf wiederholen. Sonst haben wir ja keinen aktuellen Wert. Deswegen fügen wir davor die Schleife ein.

while 1:
 tempData = "/sys/class/thermal/thermal_zone0/temp"
 dateilesen = open(tempData, "r")
 temperatur = dateilesen.readline(2)
#usw

Alles nach While 1: wird immer wieder ausgeführt bis du dein Programm stoppst. Das geht mit Strg+c. Genau wir bei IF Abfragen müssen wir den Code in der While Schleife mit TAB oder Space einrücken. Also alles was in der Schleife liegen soll muss eingerückt werden. Auch der Inhalt der IF Schleifen ! Dieser muss jetzt also 2x eingerückt sein.

Starte dein Programm mit python3 temperatur.py Es gibt dir jetzt jede Minute die aktuelle Temperatur aus. Cooler wäre es aber wenn das Programm automatisch im Hintergrund startet, das machen wir im nächsten Schritt.

7: Automatisch starten

Du kannst dein Programm auch Automatisch starten wenn dein Pi startet. Dafür gibt es den so genannten Cronjob. Ein cronjob startet ein Programm z.B. alle 5 Minuten oder einmal die Woche, jedes Jahr an Weihnachten usw. Du kannst das einstellen.

Cronjobs kannst du über den cron Manager anlegen. Das machst du mit crontab -e Beim ersten Start wirst du nach dem Editor gefragt. Da nimmst du am besten nano, Nr. 2. In der crontab kannst du befehle hinterlegen die dein Computer zu einem festgelegten Zeitpunkt ausführt. Unser Programm soll beim starten ausgeführt werden, deswegen geben wir als Zeitpunkt an:

@reboot

gefolgt von dem Befehl. Achte darauf, dass du bei cronjobs mit ganzen Pfaden arbeiten musst. Der Cronjob muss so aussehen

@reboot python3 /home/pi/Temperatur.py

Speicher deine Datei und beende den Editor. Jetzt kannst du deinen Pi neu starten. Dein Programm startet jetzt im Hintergrund. An den LEDs siehst du, dass etwas passiert. Die Ausgaben im Terminal erscheien nicht mehr. Deswegen können wir unser Script etwas schlanker machen. Alle ausgaben mit print kannst du entfernen, die sieht ja niemand mehr. Wir haben Sie hier mit # auskommentiert.

Dein fertiges Programm sollte so aussehen.

# Jugend Programmiert Raspberry Pi Lüftersteuerung
# Fertiges Programm, geschrieben in Python3
# Details und Anmerkunden auf JP42.io/Projekt/Luefter

import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(2, GPIO.OUT)
GPIO.setup(3, GPIO.OUT)
GPIO.setup(4, GPIO.OUT)
GPIO.setup(17, GPIO.OUT)

GPIO.output(2, GPIO.LOW)
GPIO.output(3, GPIO.LOW)
GPIO.output(4, GPIO.LOW)
GPIO.output(17, GPIO.LOW)

while 1:
 tempData = "/sys/class/thermal/thermal_zone0/temp"
 dateilesen = open(tempData, "r")
 temperatur = dateilesen.readline(2)
 dateilesen.close()
 print("Deine CPU hat " + temperatur + " Grad")

 normal = 30
 warm = 55
 heiss = 60
 temperatur = int(temperatur)
 if temperatur <= normal:
  #print ("Die CPU ist Normal, die grüne LED geht an.")
  GPIO.output(2, GPIO.HIGH)
 if temperatur > normal:
  #print ("Die CPU ist Warm, die Gelbe LED geht auch an")
  GPIO.output(2, GPIO.HIGH)
  GPIO.output(3, GPIO.HIGH)
 if temperatur > heiss:
  #print ("Die CPU ist wärmer als warm! Die Rote LED geht an und wir schalten den Lüfter ein !")
  GPIO.output(4, GPIO.HIGH)
  GPIO.output(17, GPIO.HIGH)
 time.sleep(60)
GPIO.cleanup()











Herzlichen Glückwunsch.

Du hast deine eigene Raspberry Pi Lüftersteuerung gebaut. Deinen Aufbau vom Breadboard kannst nutzen um die Steuerung in ein Gehäuse oder in den mitgelieferten Rahmen zu integrieren,

Wenn du möchtest kannst du die Temperaturdaten auch direkt in ein Google Spreadcheet einfügen. Oder dir eine Email Schreiben falls dein Pi zu heiß ist. Dies und viele andere coole Projekte findest du auf unserer Homepage. Dort helfen wir dir auch gerne bei Problemen und geben Tipps falls etwas nicht funktioniert. Auf unserer Disussionsplattform kannst du dich mit anderen Usern austauschen und dein Programm und Projekt vorstellen. Wir freuen uns auf deinen Besuch.

Auf Wiedersehen

Wir hoffen, dass dir dieses Projekt gefallen hat! Wenn du noch mehr erleben und möchstest, findest du zahlreiche weitere Kits und Bastelprojekte für deinen Raspberry Pi auf CodingWorld.io

Noch Fragen oder Feedback?

Bevor du eine Frage stellen kannst musst du dich zuerst Anmelden oder Regestrieren!