Raspberry Pi Lüfter steuern

Wir freuen uns, dass 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 dir 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 abgekühlt 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. Die LEDs und den Lüfter brauchst du dafür noch 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. Du kannst die Temperatur mit diesem Befehl auslesen:

cat /sys/class/thermal/thermal_zone0/temp

Das Ergebnis wird in Eintausendstel Grad Celsius dargestellt. Zum Beispiel: 45622 entspricht 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 die 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.

Es ist immer eine gute Idee ab und an 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.

temp_path = "/sys/class/thermal/thermal_zone0/temp"
file = open(temp_path, "r")
temp = int( file.readline() ) / 1000
file.close()
print("Deine CPU ist " + temp + " Grad Celsius warm")

Erst speichern wir den Pfad der zu öffnenden Datei in einer Variable. Dann öffnen wir die Datei mit Python. Das geschieht in Zeile 2. file = open(temp_path , "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. Das passiert mit der Methode file.readline(). Da wir den Wert allerdings als String (Text) und nicht als Integer (Zahl) erhalten, wanden wir String mit der eingebauten Funktion int() noch um. Jetzt, da wir die Temeratur als Zahl und nicht als Text haben, können wir in Python auch mit diesem Wert rechnen und viele weitere spannende Dinge machen. Da wir Die Temperatur ja als eintausendstel Grad Celsius erhalten, teilen wir den Wert zunächst durch 1000. Dadurch erhalten wir einen Wert in Grad Celsius. Diesen speichern wir in eine variable mit dem Namen temp. Mit file.close() schließen wir die Datei wieder. In der letzten Zeile geben wir die Temperatur mit der Funktion print() aus, wir wollen die Temeratur ja auch in der Konsole anzeigen lassen. Damit es schöner aussieht haben wir vor und hinter der Temperatur noch etwas Text angehangen.

Fassen wir das ganze noch einmal kurz zusammen:

Wir öffnen eine Datei. Lesen aus dieser die erste Zeile aus, konvertieren diese in eine Zahl und teilen diese durch 1000. Das schreiben wir dann in eine Variable. Wir schließen die Datei. Zum Schluss geben wir einen Text in der Konsole aus, dann die Variable und noch mehr Text.

Jetzt starten wir dein Programm. Das machst du so:

python3 temperatur.py

 Wenn du alles richtig gemacht hast, sollte dir das Programm dann die Temeratur der CPU deines PIs anzeigen.

2. Temperaturen festlegen

Jetzt wissen wir wir warm der Pi ist. Abhängig von der Temperatur wollen wir den Lüfter ein oder aus schlaten und die LEDs entsprechend 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.

warm = 45
hot = 50

Wie du siehst benötigen wir nur zwei Werte für die Drei LEDs. Das liegt daran, dass die diese Werte als Grenzwerte nutzen; d.h. alles über 50 ist hot (rote LED), alles zwischen 45 und 50 is warm (gelbe LED) und alles unter 45 ist normal (grüne LED). Diese Werte kannst du frei anpassen; achte aber darauf, dass hot größer als warm ist. Diese unterscheiden zwischen Text (String) und Nummern (Integer).

Jetzt vergleichen wir die Temperatur mit den Grenzwerten:

if temp > hot:
    print ("Die CPU ist heiss! rote LED an.")
elif temp > warm:
    print ("Die CPU ist warm, gelbe LED an")
else:
    print ("Die CPU normal warm, grüne LED ")

Eine If abfrage vergleicht zwei Werte und führt Befehle aus falls diese zutreffen oder nicht. In der ersten Zeile if temp > hot: fragen wir ab, ob die Temperatur größer als hot it. Wenn ja, wird der darunter Eingerückte Code ausgeführt. Falls die Bedingung nicht Eintritt, passiert eine weitere Abfrage: elif temp > warm:. elif steht für else if und bedeutet „oder wenn“. D.h. diese Bedingung wird nur überprüft, wenn die davor nicht eingetreten ist. Sollte die Temperatur größer als warm sein, wird der eingerückte Code ausgeführt. Sollten beiden Bendingungen nicht eintreten, wird der eingerückte Code nach else: („oder“) ausgeführt. 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.

NameSymbol
kleiner als<
größer als>
kleiner als oder gleich<=
größer als oder gleich>=
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. 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
23220 Ohmgrüne LED langes Bein
24220 Ohmgelbe LED langes Bein
25220 Ohmrote LED langes Bein
GNDGND Breadboard

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

4: LEDs 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 pausiert.

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 gut, wen du z.B. einen Taster an deinen Pi anschließen möchtest. Mit Ausgängen können wir eine Spannung anlegen und so z.B. eine LED zum leuchten bringen. Für unsere LEDs und den Lüfter brauchen wir Ausgänge. Es gibt zwei Nummerierungen der 40. Pins auf dem Pi. Wir benutzen BCM. Das ist die Belegung auf dem 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 23, 24, 25 als Ausgänge.

GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.OUT)
GPIO.setup(24, GPIO.OUT)
GPIO.setup(25, 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(23, GPIO.LOW)
GPIO.output(24, GPIO.LOW)
GPIO.output(25, GPIO.LOW)

Mit diesen Zeilen schalten wir die GPIO-Pins mit den Nummern 23, 24, 25 auf LOW, also auf aus. Du kannst die Pins auch auf HIGH (an) stellen. Das 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 solltetst du die Zeile GPIO.cleanup()  Dadurch wird die GPIO Pinbelegung wieder aufgehoben. Du kannst das in einem extra Script testen, das sieht dann so aus:

# LED Test Script
# schaltet Pin 23 für 10 Sekunden an

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM) # setze GPIO Pinout
GPIO.setup(2, GPIO.OUT) # setze Pin als Ausgang
GPIO.output(2, GPIO.HIGH) # setze Pin auf HIGH
time.sleep(2) # warte für 2 Sekunden
GPIO.output(2, GPIO.LOW) # setze Pin auf LOW

GPIO.cleanup() # hebe Pinbelegung auf

Die erste LED sollte für 2 Sekunden leuchten und dann wieder ausgehen. Kannst du auch alle LEDs einschalten? Oder alle nach einander leuchten lassen? Probiere es aus.

5. Lüfter anschließen.

Wenn deine LEDs funktionieren ist es an der Zeit den Lüfter anzuschließen. (Wir stellen den Lüfter in der Abbildung als Motor da.)

Ü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 (2N2222A). Ein Transistor hat drei Beine und funktioniert so ähnlich 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), kann kein Strom fließen. Damit der Transisor nicht durchbrennt, musst du – wie die in der Grafik zu sehen – zwischen GPIO-Pin und dem Transisor noch einen Wiederstand setzen. Beachte auch, dass der Strom vom Collector zum Ermitter fließen muss, nicht anders herum. Die Plus-Leitung vom Lüfter schließt du am Pi an 5V an. Die Minus-Leitung verbindest du mit dem Collector. Der Ermitter wird mit GND (Ground) des PIs verbunden. Die Base verbindest du über den Wiederstand mit deinem GPIO Pin. In unserem Beispiel Pin 18.
Der Lüfter aus deinem Kit ist ein 5V Lüfter. Er funktioniert mit 5V und 3,3V. Du kannst Ihn auch an 3,3V anschließen, dann ist er aber etwas leiser, aber kühlt auch weniger. Um den Lüfter zu testen, kannst du das gleiche Skript, wie für die LED nuzten, du musst nur den Pin anpassen. Wenn alles funktioniert machen wir mit dem nächsten Schritt weiter.

6: Lüftersteuerung

Wir verbinden die Abfrage der Temperatur und deine IF Schleifen mit der GPIO Steuerung. Erstelle dafür die Datei lueftersteuerung.py in /home/pi. Zu Beginn Anfang importieren wir wieder unsere GPIO und time Bibliothek und definieren die 4 Pins. Die 4 Pins schalten wir erstmal auf Low (aus).

import time
import RPi.GPIO as GPIO

fan = 18
leds = [23, 24, 25]

GPIO.setmode(GPIO.BCM)
GPIO.setup(fan, GPIO.OUT)
GPIO.output(fan, False)

for i in leds:
  GPIO.setup(i, GPIO.OUT)
  GPIO.output(i, False)

Damit wir uns ein wenig Schreibarbeit sparen, speichern wir die Pins der LEDs in einem Array – das kannst du dir wie eine Liste vorstellen. In der Zeile for i in leds: benutzen wir eine for-Schleife. Diese geht alle Einträge des Arrays durch. Dabei nimmt die variable i jeweils bei jedem Durchlauf den entsprechenden Wert an. Auch hier muss alles, was in der Schleife sein soll eingerückt werden.

Zunächst müssen wir noch die Grenztemperaturen und den Dateipfad für die Temperatur setzen:

temp_path = '/sys/class/thermal/thermal_zone0/temp'
hot = 50
warm = 45

Jetzt lernen wir noch etwas Neues: Funktionen. Das sind Codeblöcke, die wir in unserem Skript an verschiedenen Stellen immer wieder nutzen können. Dazu muss jediglich die Funktion an dieser Stelle Aufgerufen werden. Funktionen werden z.B. so definiert: def funktions_name(parameter):. Wie du in dem Beispiel siehst können wir Funktionen Parameter (Variable) übergeben, wenn wir sie später ausführen. Wir erstellen eine Solche Funktion mit dem Parameter temp um die richtigen LEDs zum leuchten zu bringen. Dazu benutzen wir die Abfrage von vorhin.

def set_led(temp):
  # alle leds ausschalten
  for i in leds:
    GPIO.output(i, False)
  # richtige LED einschalten
  if temp > hot:
    GPIO.output(leds[0], True)
  elif temp > warm:
    GPIO.output(leds[1], True)
  else:
    GPIO.output(leds[2], True)

Außerdem definieren wir eine Funktion, um die aktuelle Temperatur zu erfahen:

def get_temp():
  temp = int(open(temp_path, 'r').readline())/1000
  close(temp_path)
  print('aktuelle Temperatur: '+str(temp))
  set_led(temp)
  return temp

Auch mit set_led(temp) rufen wir die Funktion set_led auf, welche die richtige LED einschaltet.
Mit dem Befehlt return geben wir einen Wert zurück. Wenn wir also später die Funktion get_temp() aufrufen, wird die richtige LED gesetzt und wir erhalten die aktuelle Temperatur.

Es gibt auch Schleifen, die laufen einfach bis ins unendliche. Genau so eine Schleife brauchen wir, damit wir das Skript nicht immer wieder neu starten müssen. Die sieht so aus:

While True:
  # mache etwas

Alles was nachwhile True: eingerückt ist, wird immer wieder ausgeführt, bis du dein Programm stoppst. Das geht mit Strg+C. Genau wie 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.

while True:
  if get_temp() > hot:
    print('Lüfter an')
    GPIO.output(fan, True)
    time.sleep(4)
    while get_temp() > warm:
      time.sleep(2)
    print('Lüfter aus')
    GPIO.output(fan, False)
  time.sleep(2)

In dieser While-Schleife bringen wir alles zusammen und steuern auch noch den Motor. Zu Beginn beziehen wir die aktuelle Temperatur mit der Funktion get_temp(). Die LEDs werden ja automatisch schon gesetzt, wenn wir diese Funktion aufrufen, das müssen wir also nicht mehr manuell machen. Den Wert, den wir von der Funktoin erhalten fragen wir ab, ob dieser überhalb des Grenzwertes hot liegt. Wenn ja, schalten wir den Motor ein, indem wir den in der Variable fan definierten Pin auf HIGH schalten. Damit der Motor nicht sofort nach dem einschalten wieder ausgeht, warten wir zunächst 4 Sekunden time.sleep(4). Dann folgt eine While-Schleife, die immer wieder 2 Sekunden wartet, bis der Wert den unteren Grenzwert erreicht hat. Wenn das passiert ist, wird der Motor wieder ausgeschaltet. Jetzt warten wir 2 Sekunden und dann geht es immer wieder am Anfang der while True:-Schleife weiter. Und immer so weiter…

Dein fertiges Programm sollte so aussehen:

import time
import RPi.GPIO as GPIO

fan = 18
leds = [23, 24, 25]

GPIO.setmode(GPIO.BCM)
GPIO.setup(fan, GPIO.OUT)
GPIO.output(fan, False)

for i in leds:
  GPIO.setup(i, GPIO.OUT)
  GPIO.output(i, False)

temp_path = '/sys/class/thermal/thermal_zone0/temp'

hot = 50
warm = 45

def set_led(temp):
  for i in leds:
    GPIO.output(i, False)
  if temp > hot:
    GPIO.output(leds[0], True)
  elif temp > warm:
    GPIO.output(leds[1], True)
  else:
    GPIO.output(leds[2], True)

def get_temp():
  temp = int(open(temp_path, 'r').readline())/1000
  close(temp_path)
  print('aktuelle Temperatur: '+str(temp))
  set_led(temp)
  return temp

while True:
  if get_temp() > hot:
    print('Lüfter an')
    GPIO.output(fan, True)
    time.sleep(4)
    while get_temp() > warm:
      time.sleep(2)
    print('Lüfter aus')
    GPIO.output(fan, False)
  time.sleep(2)

Starte dein Programm mit python3 lueftersteuerung.py Dein skript steuert jetzt die LEDs und den Lüfter. Cooler wäre es aber wenn das Programm automatisch im Hintergrund startet, das machen wir im nächsten Schritt.

7: Automatisch starten

Damit du das Skript nicht immer manuell starten muss, wenn du den Pi neu startest, können wir auf dem Pi das Skript als Service hinzufügen. Das hat auch den Vorteil, dass dein Skript austomatisch neu gestartet wird, falls es aus unerklärlichen Gründen mal abstürzen sollte. Solche Services werden auf dem Pi einfach als Textdatei in dem Ordner /etc/systemd/system/ gespeichert.

Erstelle eine Datei mit dem Namen lueftersteuerung.service mit nano in diesem Ordner:

sudo nano /etc/systemd/system/lueftersteuerung.service
[Unit]
Description=Lueftersteuerung
After=multi-user.target

[Service]
Type=simple
Restart=always
ExecStart=/usr/bin/python3 /home/pi/lueftersteuerung.py

[Install]
WantedBy=multi-user.target

Wenn du das gemach hast musst du erstmal deinem Pi sagen, dass er nach neuen Servies suchen soll, dazu laden wir den init-daemon neu:

sudo systemctl daemon-reload

Jetzt müssen wir den Service noch aktivieren:

sudo systemctl enable luefersteuerung.service

Wenn du deinen Pi jetzt neu starten würdest, würde dein Skript automatisch ausgeführt werden. Wir können uns das aber auch sparen und den Service jetzt direkt manuell starten:

sudo systemctl start lueftersteuerung.service

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.

Löten und Zusammenbau

Jetzt kannst du zum Schluss noch die Bauteile zusammenlöten und an der Beigelegten Halterung befestigen. Die Kabel kannst du einfach abisolieen und direkt an die LEDs löten. Bei uns sah das zum Beispiel so aus:

Wenn du das gemacht das, kannst du den Lüfter mi den beigelegten Schrauben auf deinen Pi schrauben:

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 eine Tabelle einfügen lassen. 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