RaspberryPi: apagat i sortida d'un LED: 4 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

Els passos següents són experiments per il·lustrar el funcionament dels LED. Mostren com atenuar un LED a un ritme uniforme i com esvair-lo dins i fora.

Necessitarà:

• RaspberryPi (he utilitzat un Pi més antic, el meu Pi-3 està en ús, però qualsevol Pi funcionarà).
• Taula de pa
• LED vermell de 5 mm
• Resistència de 330 Ω (funcionarà 220-560 Ω no crític).
• Fil de connexió

El sabater Pi que he utilitzat a Adafruit no és necessari, però facilita la pràctica de la taula.

WiringPi és un conjunt de biblioteques per programar RaspberryPi a C. Les instruccions per descarregar, instal·lar i utilitzar es troben a

Per instal·lar wiringPi, seguiu les instruccions d'aquesta pàgina:

Per obtenir una llista dels números de pin de cablejat, introduïu gpio readall a la línia d’ordres.

A les versions més noves de Raspian, el cablejat PI està instal·lat per defecte.

Pas 1: modulació de l'amplada de pols

Els LED sempre funcionen al mateix voltatge independentment de la brillantor. La brillantor està determinada per un oscil·lador d’ones quadrades i la quantitat de temps que el voltatge és alt determina la brillantor. Això s’anomena modulació d’amplada de pols (PWM). Això està controlat per la funció wiringPi pwmWrite (pin, n) on n té un valor de 0 a 255. Si n = 2, el LED serà el doble de brillant que n = 1. La brillantor sempre es duplica quan n es duplica. Així doncs, n = 255 serà el doble de brillant que n = 128.

El valor de n sol expressar-se com un percentatge anomenat cicle de treball. Les imatges mostren traces de l’oscil·loscopi durant 25, 50 i 75% de cicles de treball.

Pas 2: LED i resistència

Això no és necessari, però tenir-ne alguns a la mà pot fer molt més fàcil la pràctica de taulers.

Soldeu una resistència al led curt d’un LED. Utilitzeu una resistència de 220-560 Ohm.

Pas 3: atenuació uniforme

Construeix el circuit com en el diagrama. Això és igual que el circuit per parpellejar un LED. Utilitza el pin 1 de wiringPi perquè heu d’utilitzar un pin habilitat per a PWM. Compileu el programa i executeu-lo. Notareu que com més brillant sigui el LED, més lent es va enfosquint. A mesura que s'aproximi al més feble, es tornarà més feble.

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

* Compileu: gcc -o fade1 -Wall -I / usr / local / include -L / usr / local / lib * fade1.c -lwiringPi * * Executeu: sudo./fade1 * * Tots els números de pin estan connectats a nombres PI, tret que s’especifiqui el contrari. *************************************************** **************** / #include int main () {wiringPiSetup (); // Configuració necessària per wiringPi pinMode (1, PWM_OUTPUT); // pwmSetMode (PWM_MODE_MS); // Mode de marcatge / espai int i; while (1) {for (i = 255; i> -1; i--) {pwmWrite (1, i); retard (10); } per a (i = 0; i <256; i ++) {pwmWrite (1, i); retard (10); }}}

El següent pas mostra com atenuar el LED a una velocitat constant i en un de sentència.

Pas 4: pas 4: pujar i baixar en un per a () i a un ritme uniforme

Perquè el LED s'enfosqueixi a una velocitat constant, el retard () ha d'augmentar a una velocitat exponencial perquè la meitat del cicle de treball sempre produirà la meitat de la brillantor.

La línia:

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

calcula el quadrat invers de la brillantor per determinar la durada del retard. Compileu i executeu aquest programa i veureu que el LED s’apagarà i s’apagarà a un ritme constant.

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

* Compila: gcc -o fade1 -Wall -I / usr / local / include -L / usr / local / lib * fade2.c -lwiringPi * * Executa: sudo./fade2 * * Tots els números de pin estan connectats a nombres Pi, tret que s’especifiqui el contrari. *************************************************** **************** / #include int main () {wiringPiSetup (); // Configuració necessària per wiringPi pinMode (1, PWM_OUTPUT); // pwmSetMode (PWM_MODE_MS); // Marqueu / mode Espai mentre (1) {int i; int x = 1; per a (i = 0; i> -1; i = i + x) {int d = (16-i / 16) ^ 2; // quadrat invers de calc de l’índex pwmWrite (1, i); retard (d); if (i == 255) x = -1; // canviar la direcció al màxim}}}