RaspberryPi: Fade um LED dentro e fora: 4 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

As etapas a seguir são experimentos para ilustrar como os LEDs funcionam. Eles mostram como diminuir a intensidade de um LED em uma taxa uniforme e como aumentar e diminuir o brilho.

Você vai precisar de:

• RaspberryPi (usei um Pi mais antigo, meu Pi-3 está em uso, mas qualquer Pi funcionará.)
• Tábua de pão
• LED vermelho de 5 mm
• 330 Ω Resistor (não crítico 220-560 Ω funcionará.)
• Fio de conexão

O Pi-cobbler que usei da Adafruit não é necessário, mas facilita o breadboarding.

WiringPi é um conjunto de bibliotecas para programar o RaspberryPi em C. As instruções para download, instalação e uso estão localizadas em

Para instalar o wiringPi, siga as instruções nesta página:

Para obter uma lista de números de pinos wiringPi, digite gpio readall na linha de comando.

Nas versões mais recentes do Raspian, o wiringPi é instalado por padrão.

Etapa 1: modulação por largura de pulso

Os LEDs sempre funcionam com a mesma voltagem, independentemente do brilho. O brilho é determinado por um oscilador de onda quadrada e a quantidade de tempo que a tensão fica alta determina o brilho. Isso é chamado de modulação por largura de pulso (PWM). Isso é controlado pela função wiringPi pwmWrite (pin, n), onde n tem um valor de 0 a 255. Se n = 2, o LED será duas vezes mais brilhante do que n = 1. O brilho sempre dobra quando n dobra. Portanto, n = 255 será duas vezes mais brilhante do que n = 128.

O valor de n é geralmente expresso como uma porcentagem chamada de ciclo de trabalho. As imagens mostram os traçados do osciloscópio para ciclos de trabalho de 25, 50 e 75%.

Etapa 2: LED e resistor

Isso não é necessário, mas ter alguns desses à mão pode tornar o breadboarding muito mais fácil.

Solde um resistor para o led curto de um LED. Use um resistor de 220-560 Ohm.

Etapa 3: escurecimento uniforme

Construa o circuito como no diagrama. Isso é como o circuito para piscar um LED. Ele usa wiringPi pino 1 porque você precisa usar um pino habilitado para PWM. Compile o programa e execute-o. Você notará que quanto mais brilhante o LED é, mais devagar ele escurece. À medida que fica mais escuro, ele vai ficando mais escuro muito rápido.

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

* Compilar: gcc -o fade1 -Wall -I / usr / local / include -L / usr / local / lib * fade1.c -lwiringPi * * Executar: sudo./fade1 * * Todos os números de pinos são números de wiringPi, a menos que especificado de outra forma. ************************************************** **************** / #include int main () {wiringPiSetup (); // Configuração exigida por wiringPi pinMode (1, PWM_OUTPUT); // pwmSetMode (PWM_MODE_MS); // Modo Marca / Espaço int i; enquanto (1) {para (i = 255; i> -1; i--) {pwmWrite (1, i); atraso (10); } para (i = 0; i <256; i ++) {pwmWrite (1, i); atraso (10); }}}

A próxima etapa mostra como diminuir o brilho do LED em uma taxa constante e em um para declaração.

Etapa 4: Etapa 4: para cima e para baixo em um para () e em uma taxa uniforme

Para que o LED diminua a uma taxa constante, o atraso () deve aumentar a uma taxa exponencial porque metade do ciclo de trabalho sempre produzirá metade do brilho.

A linha:

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

calcula o quadrado inverso do brilho para determinar a duração do atraso. Compile e execute este programa e você verá que o LED acenderá e apagará a uma taxa constante.

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

* Compilar: gcc -o fade1 -Wall -I / usr / local / include -L / usr / local / lib * fade2.c -lwiringPi * * Executar: sudo./fade2 * * Todos os números de pinos são números de wiringPi, a menos que especificado de outra forma. *************************************************** **************** / #include int main () {wiringPiSetup (); // Configuração exigida por wiringPi pinMode (1, PWM_OUTPUT); // pwmSetMode (PWM_MODE_MS); // Modo Marca / Espaço while (1) {int i; int x = 1; para (i = 0; i> -1; i = i + x) {int d = (16-i / 16) ^ 2; // calcula o quadrado inverso do índice pwmWrite (1, i); atraso (d); se (i == 255) x = -1; // mudar de direção no pico}}}