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:

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.