Neste post, você aprenderá como usar um LED RGB (Red Green Blue) com um Arduino. Para o primeiro experimento você usará a função analogWrite do Arduino para controlar a cor do LED. Para o segundo experimento usaremos potenciômetros para alterar a cor do LED. 

 

À primeira vista, os LEDs RGB (Vermelho, Verde, Azul) se parecem com os LEDs comuns, no entanto, dentro do pacote LED usual, há três LEDs, um vermelho, um verde e sim, um azul. Ao controlar o brilho de cada um dos LEDs individuais, você pode misturar praticamente qualquer cor desejada.

Nós misturamos cores como se você mixasse áudio com um ‘quadro de mixagem’ ou pintasse em uma paleta – ajustando o brilho de cada um dos três LEDs. A maneira mais difícil de fazer isso seria usar resistores de valor diferentes (ou resistores variáveis). Isso é muito trabalho! Felizmente para nós, o Arduino tem uma função analogWrite que você pode usar com pinos marcados com ~ para gerar uma quantidade variável de energia para os LEDs apropriados.

Experimento 1 - Componentes usados

Arduino UNO
Half-size Breadboard
LED RGB 10mm
3 Resistores 270Ω
Pacote de fios de ligação

Experimento 1 - Montando o Circuito

Existem dois tipos de LEDs RGB: LED ânodo comum e LED catódico comum . A figura abaixo ilustra um ânodo comum e um LED de cátodo comum.

A conexão negativa comum do pacote de LED é o segundo pino do lado plano do pacote de LED. É também a mais longa das quatro derivações. Este eletrodo será conectado ao terra.

Cada LED dentro do pacote requer seu próprio resistor de 270Ω para evitar que muita corrente flua através dele. Os três cabos positivos dos LEDs (um vermelho, um verde e um azul) são conectados aos pinos de saída do Arduino usando esses resistores.

Se você estiver usando um LED ANODO comum em vez de um CATODO comum, conecte o pino longo a +5 em vez de solo

A razão que você pode misturar qualquer cor que você gosta, variando as quantidades de luz vermelha, verde e azul é que seu olho tem três tipos de receptores de luz (vermelho, verde e azul). Seu olho e cérebro processam as quantidades de vermelho, verde e azul e convertê-lo em uma cor do espectro.

De certa forma, usando os três LEDs, estamos jogando um truque no olho. Essa mesma ideia é usada em TVs, onde o LCD tem pontos vermelhos, verdes e azuis próximos um ao outro, formando cada pixel.

Se definirmos o brilho de todos os três LEDs como iguais, a cor geral da luz será branca. Se desligarmos o LED azul, para que apenas os LEDs vermelho e verde tenham o mesmo brilho, a luz aparecerá amarela.

Podemos controlar o brilho de cada uma das partes vermelha, verde e azul do LED separadamente, tornando possível misturar qualquer cor que desejarmos.

O preto não é tanto uma cor quanto uma ausência de luz. Então, o mais próximo que podemos chegar de preto com o nosso LED é desligar todas as três cores.

 

Experimento 1 - Programando o Arduino

O esboço de teste a seguir percorrerá as cores vermelho, verde, azul, amarelo, roxo e aqua. Essas cores são algumas das cores padrão da Internet.

/*Arduino – RGB LED/Experimento 1 */

int redPin = 11;

int greenPin = 10;

int bluePin = 9;

//Descomente a linha abaixo se estiver usando um LED Anodo comum

//#define COMMON_ANODE

void setup()

{

pinMode(redPin, OUTPUT);

pinMode(greenPin, OUTPUT);

pinMode(bluePin, OUTPUT);

}

void loop()

{

setColor(255, 0, 0); // vermelho

delay(1000);

setColor(0, 255, 0); // verde

delay(1000);

setColor(0, 0, 255); // azul

delay(1000);

setColor(255, 255, 0); // amarelo

delay(1000);

setColor(80, 0, 80); // roxo

delay(1000);

setColor(0, 255, 255); // aqua

delay(1000);

}

void setColor(int red, int green, int blue)

{

#se tiver descomentado a linha def COMMON_ANODE descomente as próximas três linhas

red = 255 – red;

green = 255 – green;

blue = 255 – blue;

#endif

analogWrite(redPin, red);

analogWrite(greenPin, green);

analogWrite(bluePin, blue);

}

Experimente o esboço e depois vamos dissecá-lo com algum detalhe …

Experimento 1 - Como o Código Funciona

O esboço começa especificando quais pinos serão usados para cada uma das cores:

int redPin = 11;

int greenPin = 10; 

int bluePin = 9; 

O próximo passo é escrever a função ‘setup’. A função de configuração ‘setup’ é executada apenas uma vez depois que o Arduino é reiniciado. Neste caso, tudo o que tem a fazer é definir os três pinos que estamos usando como saídas.

void setup() { 

pinMode(redPin, OUTPUT); 

pinMode(greenPin, OUTPUT); 

pinMode(bluePin, OUTPUT); 

} 

Antes de darmos uma olhada na função ‘loop’, vamos ver a última função do exemplo.

void setColor(int red, int green, int blue) {

analogWrite(redPin, red);

analogWrite(greenPin, green); 

analogWrite(bluePin, blue);

}

Essa função leva três argumentos, um para o brilho dos LEDs vermelho, verde e azul. Em cada caso, o número estará no intervalo de 0 a 255, onde 0 significa desligado e 255 significa brilho máximo. A função então chama ‘analogWrite’ para definir o brilho de cada LED.

Se você observar a função ‘loop’, verá que estamos definindo a quantidade de luz vermelha, verde e azul que queremos exibir e, em seguida, pausando por um segundo antes de passar para a próxima cor.

void loop() { 

setColor(255, 0, 0); // red 

delay(1000); 

setColor(0, 255, 0); // green 

delay(1000); 

setColor(0, 0, 255); // azul 

delay(1000); 

setColor(255, 255, 0); // amarelo 

delay(1000); 

setColor(80, 0, 80); // roxo 

delay(1000); 

setColor(0, 255, 255); // aqua 

delay(1000); 

}

Tente adicionar algumas cores ao esboço e observe o efeito no seu LED.

Se você estiver usando um LED RGB de ânodo comum, precisará alterar os valores de gravação analógica para que a cor seja subtraída de 255. Remova o comentário da linha #define COMMON_ANODE no esboço!

Usando Cores da Internet

Se você fez alguma programação na Internet, provavelmente estará ciente de que as cores geralmente são representadas como um número ‘hexadecimal’. Por exemplo, a cor vermelha tem o número #FF0000. Você pode encontrar os números associados a uma determinada cor usando tabelas como estas:

http://www.devguru.com/content/features/colors.html

Os seis dígitos do número são na verdade três pares de números; o primeiro par é o componente vermelho da cor, os dois dígitos seguintes a parte verde e o par final a parte azul. Vermelho é #FF0000, porque seu máximo vermelho (FF é 255 em hexadecimal) e não tem parte verde ou azul.

Seria muito útil poder discar um desses números de cor para que ele seja exibido no LED RGB.

Vamos tentar fazer a cor índigo (# 4B0082).

As partes vermelha, verde e azul do índigo são (em hexadecimal) 4B, 00 e 82, respectivamente. Nós podemos conectá-los na função ‘setColor’ assim:

setColor(0x4B, 0x0, 0x82); // indigo

Nós usamos números hexadecimais para as três partes da cor colocando ‘0x’ na frente deles.

Tente adicionar algumas cores à função ‘loop’. Não esqueça de adicionar um atraso após cada um.

Teoria - PWM

Modulação de largura de pulso (Pulse Width Modulation ou PWM) é uma técnica para controle de energia. Nós também usamos aqui para controlar o brilho de cada um dos LEDs.

O diagrama abaixo mostra o sinal de um dos pinos PWM no Arduino

Aproximadamente a cada 1/500 de segundo, a saída PWM produzirá um pulso. A duração desse pulso é controlada pela função ‘analogWrite’. Portanto, ‘analogWrite (0)’ não produzirá nenhum pulso e ‘analogWrite (255)’ produzirá um pulso que durará até o próximo pulso, de modo que a saída esteja realmente ligada o tempo todo.

Se nós especificarmos um valor no analogWrite que esteja em algum lugar entre 0 e 255, então nós iremos produzir um pulso. Se o pulso de saída for alto apenas por 5% do tempo, o que estivermos dirigindo só receberá 5% da potência total.

Se, no entanto, a saída estiver em 5V por 90% do tempo, a carga receberá 90% da energia fornecida a ela. Nós não podemos ver os LEDs ligando e desligando a essa velocidade, então para nós, parece que o brilho está mudando.

Experimento 2 - Componentes usados

Estaremos usando um LED de ânodo comum para este projeto, mas se você já tem um LED de cátodo comum, é bom usar isso; apenas atente para as diferenças observadas na fiação e no código do circuito.

  • Arduino UNO
  • LED RGB
  • 3 potenciômetros  1kΩ
  •  Breadboard 
  • 3 resistores  220Ω
  • Pacote de fios de ligação
  • Cabo conector USB

Experimento 2 - Montando o Circuito

Importante: se você estiver usando um LED RGB de catodo comum, será necessário conectar o condutor maior a GND em vez de 5V.

 

Experimento 2 - Programando o Arduino

Mais tarde, na mesma página, está a tabela de características elétricas.

/*Arduino – RGB LED/Experimento 2*/

 

int redPin = 3;     // pino vermelho -> D3

int greenPin = 5;   // pino verde -> D5

int bluePin = 6;    // pino azul -> D6

 

int potRed = A0;     // potenciômetro que controla o pino vermelho -> A0

int potGreen = A1;   // potenciômetro que controla o pino verde -> A1

int potBlue = A2;    // potenciômetro que controla o pino azul -> A2

 

void setup() {

  pinMode(redPin,OUTPUT);

  pinMode(bluePin,OUTPUT);

  pinMode(greenPin, OUTPUT);

 

  pinMode(potRed, INPUT); 

  pinMode(potGreen, INPUT); 

  pinMode(potBlue, INPUT); 

}

 

void loop() {

  // Lê a posição atual do potenciômetro e converte em um valor entre 0 e 255 para controlar o LED RGB anodo comum. 

  analogWrite(redPin, 255-(255./1023.)*analogRead(potRed));

  analogWrite(greenPin, 255-(255./1023.)*analogRead(potGreen));

  analogWrite(bluePin, 255-(255./1023.)*analogRead(potBlue));

 

  // Descomente o bloco de código abaixo para LED RGB catodo comum e comente o anterior

  /*

  analogWrite(redPin, (255./1023.)*analogRead(potRed));

  analogWrite(greenPin, (255./1023.)*analogRead(potGreen));

  analogWrite(bluePin, (255./1023.)*analogRead(potBlue));

  */

 

  delay(10);

Experimento 2 - Como o Código Funciona

O código para controlar um LED RGB é muito simples. Em nosso esboço, começamos definindo três variáveis inteiras chamadas redPin , greenPin e bluePin que se referem aos pinos aos quais os LEDs estão conectados:

int redPin = 3;     // pino vermelho -> D3

int greenPin = 5;   // pino verde -> D5

int bluePin = 6;    // pino azul -> D6

Então, também declaramos variáveis para nos referirmos aos potenciômetros. O potRed controlará o lead vermelho e assim por diante.

int potRed = A0;     // potenciômetro que controla o pino vermelho -> A0

int potGreen = A1;   // potenciômetro que controla o pino verde -> A1

int potBlue = A2;    // potenciômetro que controla o pino azul -> A2

Os potenciômetros devem ser conectados aos pinos analógicos do Arduino, porque queremos ler um valor analógico dos potenciômetros.

Na função setup () , você define os pinos do LED como saídas:

pinMode(redPin, OUTPUT);

pinMode(bluePin, OUTPUT);

pinMode(greenPin, OUTPUT);

E os potenciômetros como entradas:

pinMode(potRed, INPUT);

pinMode(potGreen, INPUT);

pinMode(potBlue, INPUT);

No loop () , lemos o valor dos potenciômetros e controlamos cada LED do LED RGB de acordo.

Para ler o valor de um potenciômetro, precisamos usar a função analogRead () . Por exemplo, para ler o valor de potRed :

analogRead(potRed)

A função analogRead () retorna um valor entre 0 e 1023.

Para enviar um sinal PWM para os LEDs, usamos a função analogWrite () . A função analogWrite () aceita como argumentos o pino que queremos controlar e um valor entre 0 e 255, no qual 0 corresponde a zero de brilho e 255 de brilho máximo. No entanto, um LED RGB de ânodo comum funciona ao contrário. O envio de 0 define o LED para o brilho máximo e 255 define o brilho mais baixo (desligado). Então, precisamos subtrair o resultado para 255.

Como lemos um valor entre 0 e 1023 e precisamos gerar um valor entre 0 e 255, precisamos multiplicar o valor lido por (255/1023).

analogWrite(redPin,255-(255./1023.)*analogRead(potRed));

analogWrite(greenPin,255-(255./1023.)*analogRead(potGreen));

analogWrite(bluePin,255-(255./1023.)*analogRead(potBlue));

Para controlar o LED RGB de catodo comum, comente as linhas anteriores e descomente as próximas.

analogWrite(redPin,(255./1023.)*analogRead(potRed)); 

analogWrite(greenPin,(255./1023.)*analogRead(potGreen)); 

analogWrite(bluePin,(255./1023.)*analogRead(potBlue));

O envio de 255 define os LEDs para o brilho máximo e 0 define o brilho mais baixo.

Abaixo, segue um vídeo mostrando passo a passo destes experimentos:

Quem Somos!

Loja Virtual

Útimos Posts

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *