en en de en de pl de en de de en en en de en de en de en tr sv tr hbs_lat en de de de en en en en en de de pt en de de de en en en en de de en en oc da zh de de de de pt en de de de en en de en de de en ca de de en en nl it en de et en de nl es de en de ru ms de es eu de de de de de en en de en en en en en en en en en en en
Alle Programme können von hier heruntergeladen werden.
Ein DC (Gleichstrom)-Gerät wird mit einer konstanten Versorgungsspannung U betrieben, wobei der Stromverbrauch I und damit die Leistungsaufnahme P = U * I in der Regel von der Spannung abhängig sind. So kann beispielsweise bei einer elektrischen Heizung mit dem (konstanten) Widerstand R und der Versorgungsspannung U die Leistungsaufnahme wie folgt berechnet werden:
P = U * I = U  *
Es gibt viele elektrische Geräte, die sich bezüglich der Leistungsaufnahme in guter Näherung wie (event. nicht konstante) Widerstände verhalten, darunter Gleichstrommotoren, Glühlampen und LEDs. Wenn ein solches Gerät durch einen digitalen Ausgang eines Mikrocontrollers angesteuert wird, ist seine Versorgungsspannung entweder 0 oder VCC. Die Ausgangsspannung eines digitalen Ports ist typischerweise VCC = 3.3V oder 5V, aber die Versorgungsspannung des Gerätes kann mit einem Vorwiderstand erniedrigt, oder mit einem Transistor- oder IC-Treiber erhöht werden.
Es ist ziemlich einfach, ein PWM-Signal mit einem eigenen Programm zu erzeugen. Dies ist aber gar nicht nötig, da bereits ein PWM-Generator in der GPIO-Bibliothek enthalten ist. Die Erzeugung von PWM-Signalen beansprucht aber wesentliche Rechnerleistung, insbesondere wenn mehrere PWM-Signale nötig sind. In diesem Fall ist es besser, die PWM-Signale mit einem speziell entwickelten externen PWM-Chip wie den PCA9685 zu erzeugen (Datenblatt).
Experiment 1: Dimmen einer LED
Mit einer LED, die über einen Vorwiderstand am Raspberry Pi angeschlossen ist, eine kleine Lichtshow erzeugen, indem man mit PWM periodisch die Helligkeit erhöht bzw. reduziert.
# PWM1.py # LED dimming import RPi.GPIO as GPIO import time P_LED = 22 # adapt to your wiring fPWM = 50 # Hz (not higher with software PWM) def setup(): global pwm GPIO.setmode(GPIO.BOARD) GPIO.setup(P_LED, GPIO.OUT) pwm = GPIO.PWM(P_LED, fPWM) pwm.start(0) print "starting" setup() duty = 0 isIncreasing = True while True: pwm.ChangeDutyCycle(duty) print "D =", duty, "%" if isIncreasing: duty += 10 else: duty -= 10 if duty == 100: isIncreasing = False if duty == 0: isIncreasing = True time.sleep(1)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)
Um einen GPIO-Port als PWM-Output zu verwenden, definieren Sie zuerst den Port (hier Port #22) als Output. Dann erzeugen Sie ein Objekt pwm mit einer bestimmten PWM-Frequenz fPWM (Anzahl der Perioden T (Zyklen) pro Sekunde, fPWM = 1/T). fPWM sollte hoch genug sein, um ein Flackern zu vermeiden (bei Verwendung der GPIO-Bibliothek liegt der maximale Wert bei 50 Hz). Der Dutycycle kann mit der Funktion ChangeDutyCycle() geändert werden.
Experiment 2: RGB-LEDs verwenden
Eine RGB-LED besteht aus drei kleinen LEDs, die rot, grün und blau leuchten und in einem gemeinsamen Gehäuse montiert sind. Eine RGB-LED hat insgesamt 4 Anschlüsse: Je einen Anodenanschluss (positiv) für jede Farbe (genannt R, G, B) und einen gemeinsamen Kathodenanschluss (negativ). Durch die Änderung der Leuchtkraft der Farbkomponenten kann jede RGB-Farbe erzeugt werden.
Mit einer RGB-LED eine kleine Farb-Lichtshow erzeugen, bei der alle 200 ms die RGB-Komponenten zufällig gewählt werden.
# PWM2.py # Set RGB color import RPi.GPIO as GPIO import time import random P_RED = 22 # adapt to your wiring P_GREEN = 24 # ditto P_BLUE = 26 # ditto fPWM = 50 # Hz (not higher with software PWM) def setup(): global pwmR, pwmG, pwmB GPIO.setmode(GPIO.BOARD) GPIO.setup(P_RED, GPIO.OUT) GPIO.setup(P_GREEN, GPIO.OUT) GPIO.setup(P_BLUE, GPIO.OUT) pwmR = GPIO.PWM(P_RED, fPWM) pwmG = GPIO.PWM(P_GREEN, fPWM) pwmB = GPIO.PWM(P_BLUE, fPWM) pwmR.start(0) pwmG.start(0) pwmB.start(0) def setColor(r, g, b): pwmR.ChangeDutyCycle(int(r / 255 * 100)) pwmG.ChangeDutyCycle(int(g / 255 * 100)) pwmB.ChangeDutyCycle(int(b / 255 * 100)) print "starting" setup() while True: r = random.randint(0, 255) g = random.randint(0, 255) b = random.randint(0, 255) print r, g, b setColor(r, g, b) time.sleep(0.2)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)
Die Seriewiderstände müssen den Strom etwa auf 10 mA begrenzen (entsprechend dem gemäß Datenblatt maximal erlaubten LED-Strom, aber nicht mehr als 16 mA, da dies der maximale Strom eines GPIO-Ports ist).
Experiment 3: RGB-LED-Streifen mit MOSFET-Treiber
RGB LED-Streifen (Strips oder Stripes) bestehen aus einer Reihe von Farb-LEDs (meist vom Typ SMD 5050). In der Regel sind 3 aufeinander folgende LEDs der gleichen Farbe und ein Widerstand in Serie geschaltet und werden mit 12 V DC versorgt. Bei einem Streifen werden mehrere solche Elemente parallel verbunden. Der Gesamtstrom ist von der Länge des Streifens abhängig, kann aber pro Farbe durchaus 1 A oder höher sein. Um diesen Strom zu liefern, wird daher ein Buffer- oder Treiber-Device benötigt, welches mindestens 1 A bei 12 V abgibt. Üblicherweise wird dazu ein bipolarer Transistor, ein MOSFET oder ein Darlington Array (Transistor-Paare in einem IC-Gehäuse) verwendet.
Rb = 1 kOhm
VCC (max): 40 V
IC (max): 0.8 A
RG = 100 kOhm
(optional um bei offenem Eingang das Gate auf GND zu ziehen)
VCC (max): 60 V
ID (max): 60 A
(Pin #9 Anschluss optional
(für jeden der 7 Kanäle)
Kaufen Sie im nächsten Einkaufszentrum einen günstigen RGB-LED-Streifen und ein stabilisiertes 12 V-Netzgerät. Verwenden Sie 3 MOSFET-Treiber (z.B. FQP30N06L) und realisieren Sie die unten abgebildete Schaltung (zusammenlöten oder Steckplatine verwenden). Schreiben Sie ein lustiges Programm für eine bunte Lichtshow.
Als ersten Ansatz können Sie das gleiche Programm wie oben verwenden. Es liegt aber an Ihnen, mit etwas Phantasie eine viel schönere Show zu gestalten.