Projeto 19 - Efeito RGB Mood Lamp usando 3 leds (cores aleatórias)
- Detalhes
- angelo
- Acessos: 4026
Objetivo
Criar um efeito tipo "mood lamp" utilizando-se 3 LEDs (um vermelho, um verde e um azul). Neste projeto, a mistura das cores dos LEDs irá gerar novas cores aleatórias.
Observação: Uma "mood lamp" é uma lâmpada de propósito geralmente estético, que serve para iluminar um ambiente, mais com o intuito de indicar e caracterizar o “humor” (mood) do ambiente, do que propriamente servir como fonte de iluminação.
Aplicação
Para fins didáticos, estudo do PWM (Pulse Width Modulation), valores RGB (Red, Green and Blue) e aplicações em efeitos com led.
Componentes necessários
Referência |
Componente |
Quantidade |
Imagem |
Observação |
Protoboard | Protoboard 830 pontos | 1 | ![]() |
No mínimo utilizar protoboard com 830 pontos |
Led Alto Brilho 5mm | Led alto brilho 5mm | 3 | ![]() |
1 led de alto brilho transparente vermelho 1 led de alto brilho transparente verde 1 led de alto brilho transparente azul Se você não tiver um led de alto brilho poderá utilizar um led difuso 5mm nas mesma cores. |
Resistor | Resistor | 1 |
1 Resistor de 200Ω 2 Resistores de 100Ω Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado - Calcular Resistor. |
|
Arduino UNO R3 | Arduino UNO | 1 | ![]() |
Obs.: Utilizar também Cabos de ligação e uma folha de papel A4.
Montagem do Circuito
Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito. Veja a simulação no link --> Projeto 19 - simulação online.
Atenção:
1) Lembre-se que o LED tem polaridade: O terminal maior tem polaridade positiva e o lado do chanfro tem polaridade negativa.
2) Determinamos o valor do resistor através da tabela prática: Tabela prática de utilização de leds 3mm e 5mm. Entretanto, o mais correto é sempre verificar o datasheet do fabricante do LED para você ter os exatos valores de tensão e corrente do mesmo - leia Como calcular o resistor adequado para o led.
3) A montagem abaixo foi realizada em um protoboard com linhas de alimentação separadas. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas - sabia mais em protoboard
Código do Projeto (sketch)
Digite o código abaixo no ambiente de desenvolvimento do Arduino. Faça a verificação e o upload.
/******************************************************************************* * * Projeto 19 – Efeito RGB Mood Lamp usando 3 leds (aleatório) * http://squids.com.br/arduino * *******************************************************************************/ float COR1[3]; float COR2[3]; float INC[3]; int red, green, blue; int redPin = 11; int greenPin = 10; int bluePin = 9; void setup() { randomSeed(analogRead(0)); COR1[0] = 0; COR1[1] = 0; COR1[2] = 0; COR2[0] = random(256); COR2[1] = random(256); COR2[2] = random(256); pinMode(redPin, OUTPUT); pinMode(greenPin, OUTPUT); pinMode(bluePin, OUTPUT); } void loop() { randomSeed(analogRead(0)); for (int x=0; x<3; x++) { INC[x] = (COR1[x] - COR2[x]) / 256; } for (int x=0; x<256; x++) { red = int(COR1[0]); green = int(COR1[1]); blue = int(COR1[2]); analogWrite (redPin, red); analogWrite (greenPin, green); analogWrite (bluePin, blue); delay(100); COR1[0] -= INC[0]; COR1[1] -= INC[1]; COR1[2] -= INC[2]; } for (int x=0; x<3; x++) { COR2[x] = random(556)-300; COR2[x] = constrain(COR2[x], 0, 255); delay(1000); } }
Vídeo
Como o projeto deve funcionar
1. Após iniciar o programa, a mistura das cores dos 3 LEDs (vermelho, verde e azul) irá criar novas cores diferentes que vão se alterando lentamente e de forma aleatória.
2. Esta mistura de cores se dá ajustando-se o brilho de cada um dos 3 LED, graças ao PWM (Pulse Width Modulation, em português, modulação por largura de pulso) para que resultem em valores RGB diferentes, ou seja, cores diferentes. Este efeito funciona de forma similar a um monitor de computador que é formado de pequenos pontos vermelhos, verdes e azuis.
3. Difundindo a luz com o cilindro de papel (folha A4), você mistura as cores agradavelmente. Os LEDs podem ser colocados dentro de qualquer objeto capaz de difundir a luz; outra opção é refletir a luz com um difusor reflexivo. Experimente colocar as luzes dentro de uma pequena garrafa plástica (quanto mais fino o plástico, melhor).
Observação: Alternativamente, pode-se utilizar um Led RGB em substituição aos LEDs vermelho, verde e azul.
PWM - Pulse With Modulation
Como demonstrado nos projetos Projeto 14 - Led com efeito dimmer usando potenciômetro e Projeto 18 - Efeito lâmpada pulsante, este experimento também utiliza o conceito o PWM (Pulse Width Modulation, em português, modulação por largura de pulso) no controle da luminosidade (brilho dos LEDs).
O Arduino UNO, que utilizamos no exemplo, possui 6 saídas digitais que podem ser utilizadas como PWM, sendo elas: 11, 10, 9, 6, 5 e 3.
Para saber mais sobre PWM, leia o tutorial: O que é PWM e para que serve?
Valores RGB
Um valor RGB (255, 0, 0) é vermelho puro, enquanto um valor (0, 255, 0) é verde puro e (0, 0, 255), azul puro. Misturando esses valores você pode obter todas as cores. Mesmo se estivesse simplesmente acendendo e apagando os LEDs, sem utilizar luminosidades diferentes, ainda se conseguiria cores diferentes como mostramos na figura abaixo.
Cores disponíveis acendendo e apagando os LEDs em combinações diferentes
Ao ajustar o brilho utilizando PWM, você também pode obter outras cores. Colocando os LEDs próximos uns dos outros e misturando seus valores, através de um cilindro de papel, por exemplo, o espectro de luz das três cores adicionadas cria uma única cor. O número total de cores disponíveis, utilizando PWM com um intervalo de 0 a 255, é de 16.777.216 cores (256 x 256 x 256).
Explicando o Código do Projeto
1. Primeiro declaramos as variáveis (COR[], INC[], red, green, blue, redPin, greenPin e bluePin).
float COR1[3]; float COR2[3]; float INC[3]; int red, green, blue; int redPin = 11; int greenPin = 10; int bluePin = 9;
1.1. Observe que utilizamos variáveis tipo "float" e tipo "int". Veja na tabela abaixo as diferenças nos tipos de constantes e variáveis:
Tipo | Valores Válidos para Variáveis e Constantes |
char | letras e símbolos: 'a', 'b', 'H', '^', '*','1','0' |
int | de -32767 até 32767 (apenas números inteiros) |
float | de -3.4 x 1038 até +3.4 x 10+38 com até 6 dígitos de precisão (2 casas depois da vírgula) |
double | de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de precisão |
1.3. As variáveis arrays COR1[3], COR2[3] e INC[3], tipo float (flutuante), se referem aos valores RGB e o valor de Incremento.
1.2. As variáveis tipo inteiro red, green e blue, tipo inteiro, se referem aos valores RGB a serem armazenados;
1.3. As variáveis tipo inteiro redPin, greenPin e bluePin, se referem aos LEDs 5mm de alto brilho conectados nos pinos 11, 10 e 9 do controlador Arduino (saídas utilizada como PWM).
2. Através da estrutura void setup(), definimos:
void setup() { randomSeed(analogRead(0)); COR1[0] = 0; COR1[1] = 0; COR1[2] = 0; COR2[0] = random(256); COR2[1] = random(256); COR2[2] = random(256); pinMode(redPin, OUTPUT); pinMode(greenPin, OUTPUT); pinMode(bluePin, OUTPUT); }
2.1. O comando randomSeed cria números aleatórios. Nesse caso, o valor atribuído a randomSeed é um valor lido do pino analógico 0. Como não há nada conectado a ele, será lido um número aleatório, criado por ruído analógico. Assim que definido o comando randomSeed, poderemos utilizar a função random() para criar números aleatórios.
2.2. Definimos os valores da array COR1[], com zero para todos os elementos. Desta forma definimos o conjunto de valores RGB inicial da lâmpada (neste caso, todos são zero, ou desligados).
2.3. Definimos os valores do array COR2[] , conjunto de valores RGB que se deseja, como um conjunto de números aleatórios criados pela função random(256), o que resultará em um número entre 0 e 255 (o limite superior não entra no intervalo de resultados da função porque o número sempre irá variar de zero em diante). --> Referencia Arduino - random()
2.4. Definimos as variáveis redPin, greenPin e bluePin como saídas do controlador Arduino (OUTPUT) conectados aos pinos 11, 10 e 9 respectivamente.
3. Através da estrutura void loop(), obtemos:
void loop() { randomSeed(analogRead(0)); for (int x=0; x<3; x++) { INC[x] = (COR1[x] - COR2[x]) / 256; } for (int x=0; x<256; x++) { red = int(COR1[0]); green = int(COR1[1]); blue = int(COR1[2]); analogWrite (redPin, red); analogWrite (greenPin, green); analogWrite (bluePin, blue); delay(100); COR1[0] -= INC[0]; COR1[1] -= INC[1]; COR1[2] -= INC[2]; } for (int x=0; x<3; x++) { COR2[x] = random(556)-300; COR2[x] = constrain(COR2[x], 0, 255); delay(1000); } }
3.1. Primeiro criamos uma estrutura loop "for" para x que vai de 0 a 2 para consultar os valores RGB de início e de fim e avaliar qual valor é necessaro para avançar de um valor para o outro em 256 vezes (uma vez que o valor PWM pode estar apenas entre o e 255). Isto definirá os valores de incremento para os canais R, G e B, calculando a diferença entre os dois valores de brilho e dividindo o resultado por 256, da seguinte maneira:
for (int x=0; x<3; x++) { INC[x] = (COR1[x] - COR2[x]) / 256; }
3.2. Depois criamos um loop "for" que pega os valores de vermelho (red), verde (green) e azul (blue) do array COR1[]. Depois, ele escreve nos pinos digitais 9, 10 e 11 definindo o brilho dos LEDs vermelho, verde e azul através da função ananogWrite(). Após, subtrai o valor de incremento e repete o processo 256 vezes para avançar de uma cor para a outra. A espera de 100ms entre cada processo garante uma progressão lenta e constante.
Obs.: Você poderá ajustar o valor de espera para que as alterações ocorram de forma mais rápida ou mais lenta. Também é possível adicionar um potenciômetro para permitir que o usuário regule a velocidade de transição.
for (int x=0; x<256; x++) { red = int(COR1[0]); green = int(COR1[1]); blue = int(COR1[2]); analogWrite (redPin, red); analogWrite (greenPin, green); analogWrite (bluePin, blue); delay(100); COR1[0] -= INC[0]; COR1[1] -= INC[1]; COR1[2] -= INC[2]; }
3.3. Depois de percorrer 256 passos entre uma cor aleatória e a próxima, o array COR1[] terá praticamente os mesmos valores do array COR2[]. Desta forma, devemos criar outro conjunto de valores aleatórios para a próxima transição. Isso é feito com outro loop "for", onde o número aleatório será escolhido selecionando um número entre 0 e 555 (255 + 300) e subtraindo 300, garantindo a ocorrência, de tempos em tempos, das cores primárias, evitando que não tenha sempre apenas tons pastéis.
for (int x=0; x<3; x++) { COR2[x] = random(556)-300; COR2[x] = constrain(COR2[x], 0, 255); delay(1000); }
3.4 Melhor explicando o loop acima, o projeto terá 300 chances em 556 de obter um número negativo, e de criar, dessa forma, uma tendência a um ou mais dos outros dois canais de cores. O comando seguinte garante que os números enviados aos pinos PWM não sejam negativos, utilizando a função constrain() --> Referencia Arduino - constrain()
3.5 A função constrain() requer três parâmetros: x, a e b, em que x é o número que você deseja restringir, a é o menor valor do intervalo e b, o maior valor. Assim, a função constrain() verifica o valor de x e garante que ele esteja entre a e b. Se x for menor que a, a função o define como a; se x for maior que b, ela o define como b. No nosso caso, asseguramos que o número esteja entre 0 e 255, intervalo válido para a saída PWM e para definir cores primárias.