RaspberryPi : Fondu d'entrée et de sortie d'une LED : 4 étapes (avec photos)

2025 Auteur: John Day | [email protected]. Dernière modifié: 2025-01-23 14:46

Les étapes suivantes sont des expériences pour illustrer le fonctionnement des LED. Ils montrent comment assombrir une LED à un taux uniforme et comment l'atténuer.

Tu auras besoin de:

• RaspberryPi (j'ai utilisé un Pi plus ancien, mon Pi-3 est en cours d'utilisation, mais n'importe quel Pi fonctionnera.)
• Planche à pain
• LED rouge 5 mm
• Résistance de 330 (pas critique 220-560 Ω fonctionnera.)
• Brancher le fil

Le Pi-cobbler que j'ai utilisé d'Adafruit n'est pas nécessaire, mais il facilite la planche à pain.

WiringPi est un ensemble de bibliothèques pour programmer le RaspberryPi en C. Les instructions de téléchargement, d'installation et d'utilisation se trouvent sur

Pour installer câblagePi suivez les instructions sur cette page:

Pour obtenir une liste des numéros de broche de câblagePi, entrez gpio readall sur la ligne de commande.

Dans les versions plus récentes de Raspian, le câblage Pi est installé par défaut.

Étape 1: Modulation de largeur d'impulsion

Les LED fonctionnent toujours à la même tension quelle que soit la luminosité. La luminosité est déterminée par un oscillateur à onde carrée et la durée pendant laquelle la tension est élevée détermine la luminosité. C'est ce qu'on appelle la modulation de largeur d'impulsion (PWM). Ceci est contrôlé par la fonction wirePi pwmWrite(pin, n) où n a une valeur de 0 à 255. Si n=2, la LED sera deux fois plus lumineuse que n=1. La luminosité double toujours lorsque n double. Donc n=255 sera deux fois plus brillant que n=128.

La valeur de n est souvent exprimée en pourcentage appelé cycle de service. Les images montrent des traces d'oscilloscope pour 25, 50 et 75 % de cycles de service.

Étape 2: LED et résistance

Ce n'est pas nécessaire, mais en avoir quelques-uns à portée de main peut rendre la planche à pain beaucoup plus facile.

Soudez une résistance à la led courte d'une LED. Utilisez une résistance de 220-560 Ohm.

Étape 3: Gradation irrégulière

Construisez le circuit comme sur le schéma. C'est comme le circuit pour faire clignoter une LED. Il utilise la broche 1 de wirePi car vous devez utiliser une broche compatible PWM. Compilez le programme et exécutez-le. Vous remarquerez que plus la LED est lumineuse, plus elle s'assombrit lentement. Au fur et à mesure qu'il s'approche du plus sombre, il deviendra très rapidement plus sombre.

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

* Compiler: gcc -o fade1 -Wall -I/usr/local/include -L/usr/local/lib * fade1.c -lwiringPi * * Exécuter: sudo./fade1 * * Tous les numéros de broche sont des numéros de wirePi sauf indication contraire. ******************************************************** **************/ #include int main() { câblagePiSetup(); // Configuration requise par le câblagePi pinMode (1, PWM_OUTPUT); // pwmSetMode(PWM_MODE_MS); // Mode Marque/Espace int i; while(1) { pour (i = 255; i > -1; i--) { pwmWrite(1, i); retard(10); } pour (i = 0; i < 256; i++) { pwmWrite(1, i); retard(10); } } }

L'étape suivante montre comment assombrir la LED à un taux constant, et en une seule fois.

Étape 4: Étape 4: Monter et descendre dans One For(), et à un rythme régulier

Pour que la LED diminue à un taux constant, le délai () doit augmenter à un taux exponentiel car la moitié du cycle de service produira toujours la moitié de la luminosité.

La ligne:

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

calcule l'inverse du carré de la luminosité pour déterminer la longueur du retard. Compilez et exécutez ce programme et vous verrez que la LED s'allumera et s'éteindra à un rythme constant.

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

* Compiler: gcc -o fade1 -Wall -I/usr/local/include -L/usr/local/lib * fade2.c -lwiringPi * * Exécuter: sudo./fade2 * * Tous les numéros de broche sont des numéros de wirePi sauf indication contraire. ************************************************** **************/ #include int main() { câblagePiSetup(); // Configuration requise par le câblagePi pinMode (1, PWM_OUTPUT); // pwmSetMode(PWM_MODE_MS); // Mode Marque/Espace while(1) { int i; entier x = 1; pour (i = 0; i > -1; i = i + x) { int d = (16-i/16)^2; // calc inverse carré de l'index pwmWrite(1, i); retard(d); si (i == 255) x = -1; // change de direction au pic } } }