RaspberryPi: Ein- und Ausblenden einer LED - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

Die folgenden Schritte sind Experimente, um zu veranschaulichen, wie LEDs funktionieren. Sie zeigen, wie man eine LED gleichmäßig dimmt und ein- und ausblendet.

Du wirst brauchen:

• RaspberryPi (Ich habe einen älteren Pi verwendet, mein Pi-3 wird verwendet, aber jeder Pi funktioniert.)
• Steckbrett
• 5 mm rote LED
• 330 Ω Widerstand (Nicht kritisch 220-560 Ω werden funktionieren.)
• Anschlusskabel

Der Pi-Cobbler, den ich von Adafruit verwendet habe, ist nicht notwendig, aber er erleichtert das Breadboarding.

WiringPi ist ein Satz von Bibliotheken zum Programmieren des RaspberryPi in C. Anweisungen zum Herunterladen, Installieren und Verwenden finden Sie unter

Um wiringPi zu installieren, folgen Sie den Anweisungen auf dieser Seite:

Um eine Liste der wiringPi-Pinnummern zu erhalten, geben Sie gpio readall in der Befehlszeile ein.

In neueren Versionen von Raspian ist wiringPi standardmäßig installiert.

Schritt 1: Pulsweitenmodulation

LEDs laufen unabhängig von der Helligkeit immer mit der gleichen Spannung. Die Helligkeit wird durch einen Rechteckwellenoszillator bestimmt und die Zeitdauer, in der die Spannung hoch ist, bestimmt die Helligkeit. Dies wird Pulsweitenmodulation (PWM) genannt. Dies wird durch die Funktion wiringPi pwmWrite(pin, n) gesteuert, wobei n einen Wert von 0 bis 255 hat. Bei n=2 leuchtet die LED doppelt so hell wie n=1. Die Helligkeit verdoppelt sich immer, wenn sich n verdoppelt. n=255 ist also doppelt so hell wie n=128.

Der Wert von n wird oft als Prozentsatz ausgedrückt, der als Tastverhältnis bezeichnet wird. Die Bilder zeigen Oszilloskopspuren für 25, 50 und 75% Tastverhältnis.

Schritt 2: LED und Widerstand

Dies ist nicht notwendig, aber wenn Sie ein paar davon zur Hand haben, kann das Breadboarding viel einfacher werden.

Löten Sie einen Widerstand an die kurze LED einer LED. Verwenden Sie einen 220-560 Ohm Widerstand.

Schritt 3: Ungleichmäßiges Dimmen

Bauen Sie die Schaltung wie im Diagramm auf. Dies ist genau wie die Schaltung zum Blinken einer LED. Es verwendet wiringPi Pin 1, da Sie einen PWM-fähigen Pin verwenden müssen. Kompilieren Sie das Programm und führen Sie es aus. Sie werden feststellen, dass je heller die LED ist, desto langsamer dimmt sie. Wenn es sich dem dunkelsten nähert, wird es sehr schnell dunkler.

/******************************************************************

* Kompilieren: gcc -o fade1 -Wall -I/usr/local/include -L/usr/local/lib * fade1.c -lwiringPi * * Ausführen: sudo./fade1 * * Alle Pin-Nummern sind wiringPi-Nummern, sofern nicht anders angegeben. ************************************************* ****************/ #include int main() { wiringPiSetup(); // Setup erforderlich von wiringPi pinMode (1, PWM_OUTPUT); // pwmSetMode (PWM_MODE_MS); // Mark/Space-Modus int i; while(1) { for (i = 255; i > -1; i--) { pwmWrite (1, i); Verzögerung(10); } für (i = 0; i < 256; i ++) { pwmWrite (1, i); Verzögerung(10); } } }

Der nächste Schritt zeigt, wie Sie die LED mit konstanter Rate und in einem für die Anweisung dimmen.

Schritt 4: Schritt 4: Auf und ab in einem For() und mit einer geraden Rate

Damit die LED mit einer konstanten Rate dimmt, muss die Verzögerung () mit einer exponentiellen Rate ansteigen, da das halbe Tastverhältnis immer die halbe Helligkeit erzeugt.

Die Linie:

int d = (16-i/16)^2;

berechnet das inverse Quadrat der Helligkeit, um die Länge der Verzögerung zu bestimmen. Kompilieren Sie dieses Programm und führen Sie es aus, und Sie werden sehen, dass die LED mit konstanter Geschwindigkeit ein- und ausblendet.

/******************************************************************

* Kompilieren: gcc -o fade1 -Wall -I/usr/local/include -L/usr/local/lib * fade2.c -lwiringPi * * Ausführen: sudo./fade2 * * Alle Pin-Nummern sind wiringPi-Nummern, sofern nicht anders angegeben. ************************************************* ****************/ #include int main() { wiringPiSetup(); // Setup erforderlich von wiringPi pinMode (1, PWM_OUTPUT); // pwmSetMode (PWM_MODE_MS); // Mark/Space-Modus while(1) { int i; intx = 1; für (i = 0; i > -1; i = i + x) {int d = (16-i/16)^2; // inverses Quadrat des Index berechnen pwmWrite(1, i); Verzögerung(d); wenn (i == 255) x = -1; // Richtung Spitze wechseln } } }