RaspberryPi: dissolvenza in entrata e in uscita di un LED: 4 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

I passaggi seguenti sono esperimenti per illustrare come funzionano i LED. Mostrano come attenuare un LED a una velocità uniforme e come sfumarlo in entrata e in uscita.

Avrai bisogno:

• RaspberryPi (ho usato un Pi vecchio, il mio Pi-3 è in uso, ma qualsiasi Pi funzionerà.)
• tagliere
• LED rosso da 5 mm
• Resistore 330 (non critico 220-560 Ω funzionerà.)
• Cavo di collegamento

Il Pi-cobbler che ho usato da Adafruit non è necessario, ma rende più facile il breadboard.

WiringPi è un insieme di librerie per la programmazione del RaspberryPi in C. Le istruzioni per il download, l'installazione e l'uso si trovano su

Per installare cablaggioPi segui le istruzioni in questa pagina:

Per ottenere un elenco dei numeri di pin di cablaggioPi, inserisci gpio readall nella riga di comando.

Nelle versioni più recenti di Raspian cablaggioPi è installato per impostazione predefinita.

Passaggio 1: modulazione dell'ampiezza dell'impulso

I LED funzionano sempre alla stessa tensione indipendentemente dalla luminosità. La luminosità è determinata da un oscillatore ad onda quadra e la quantità di tempo in cui la tensione è alta determina la luminosità. Questo è chiamato Pulse Width Modulation (PWM). Questo è controllato dalla funzione cablaggioPi pwmWrite(pin, n) dove n ha un valore compreso tra 0 e 255. Se n=2 il LED sarà due volte più luminoso di n=1. La luminosità raddoppia sempre quando n raddoppia. Quindi n=255 sarà due volte più luminoso di n=128.

Il valore di n è spesso espresso come una percentuale chiamata duty cycle. Le immagini mostrano le tracce dell'oscilloscopio per i cicli di lavoro del 25, 50 e 75%.

Passaggio 2: LED e resistore

Questo non è necessario, ma avere alcuni di questi a portata di mano può rendere il breadboard molto più semplice.

Saldare una resistenza al led corto di un LED. Utilizzare un resistore da 220-560 Ohm.

Passaggio 3: attenuazione non uniforme

Costruisci il circuito come nello schema. Questo è proprio come il circuito per far lampeggiare un LED. Utilizza il pin 1 di cablaggioPi perché è necessario utilizzare un pin abilitato PWM. Compila il programma ed eseguilo. Noterai che più il LED è luminoso, più lentamente si attenua. Man mano che si avvicina al minimo, diventerà molto più scuro.

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

* Compila: gcc -o fade1 -Wall -I/usr/local/include -L/usr/local/lib * fade1.c -lwiringPi * * Esegui: sudo./fade1 * * Tutti i numeri di pin sono numeri di cablaggioPi se non diversamente specificato. ************************************************** ****************/ #include int main() { cablaggioPiSetup(); // Setup richiesto dal cablaggioPi pinMode (1, PWM_OUTPUT); // pwmSetMode(PWM_MODE_MS); // Modalità Segna/Spazio int i; while(1) { for (i = 255; i > -1; i--) { pwmWrite(1, i); ritardo(10); } for (i = 0; i < 256; i++) { pwmWrite(1, i); ritardo(10); } } }

Il passaggio successivo mostra come attenuare il LED a una velocità costante e in una dichiarazione.

Passaggio 4: Passaggio 4: su e giù in uno per () e a un tasso pari

Affinché il LED si attenui a una velocità costante, il ritardo() deve aumentare a una velocità esponenziale perché metà del ciclo di lavoro produrrà sempre metà della luminosità.

La linea:

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

calcola l'inverso del quadrato della luminosità per determinare la lunghezza del ritardo. Compila ed esegui questo programma e vedrai che il LED si sbiadirà in entrata e in uscita a una velocità costante.

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

* Compila: gcc -o fade1 -Wall -I/usr/local/include -L/usr/local/lib * fade2.c -lwiringPi * * Esegui: sudo./fade2 * * Tutti i numeri di pin sono numeri di cablaggioPi se non diversamente specificato. ************************************************** ****************/ #include int main() { cablaggioPiSetup(); // Setup richiesto dal cablaggioPi pinMode (1, PWM_OUTPUT); // pwmSetMode(PWM_MODE_MS); // Modalità Segna/Spazio while(1) { int i; intero x = 1; for (i = 0; i > -1; i = i + x) { int d = (16-i/16)^2; // calcola il quadrato inverso dell'indice pwmWrite(1, i); ritardo(d); se (i == 255) x = -1; // cambia direzione al massimo } } }