Utilizando o LED RGB no Arduino

No tutorial de hoje vamos aprender como utilizar o LED RGB no Arduino. O propósito desse projeto é programar o Arduino para alterar as cores do LED RGB em intervalos de 1 segundo. Esse projeto visa colocar em prática o uso de funções.

Os LEDs RGB consistem na junção de três LEDs em um só dispositivo, mas que podem ser controlados individualmente. Cada um destes LEDs possuem uma cor distinta: Um vermelho (Red), um verde (Green) e um azul (Blue), que, quando associadas, podem formar outras cores.

A definição dessas cores é baseada na combinação aditiva das cores. Por exemplo, ao adicionar a cor verde a vermelha, obteremos a cor amarela, acrescentar a cor azul a vermelha, obteremos a cor magenta (violeta-púrpura), entre outras, conforme pode ser observada na Figura 1.

Os LEDs RGB podem ser do tipo:
Ânodo comum: quando os terminais das cores vermelha, verde e azul são conectados ao terminal negativo ou terra da fonte de energia;
Cátodo comum: quando os terminais das cores vermelha, verde e azul são conectados ao terminal positivo da fonte de energia.

MATERIAIS NECESSÁRIOS

1 x Placa UNO SMD R3 Atmega328 compatível com Arduino UNO;
1 x Cabo USB;
1 x Protoboard;
3 x Resistores de 220 Ω;
1 x LED RGB cátodo comum;
Fios de jumper macho-macho.

ESQUEMÁTICO DE LIGAÇÃO DOS COMPONENTES

Antes de iniciar a montagem elétrica do circuito, certifique-se que a sua placa Arduino esteja desligada. Logo após, monte o circuito utilizando a protoboard, o LED RGB, os resistores e os fios.

Ao montar seu circuito na protoboard preste atenção nos seguintes pontos:

• O primeiro terminal do LED RGB corresponde ao LED interno vermelho;
• O segundo terminal, de maior tamanho, do LED RGB é o cátodo (negativo) e deve ser conectado ao terra (GND);
• O terceiro terminal do LED RGB corresponde ao LED interno verde;
• O quarto terminal do LED RGB corresponde ao LED interno azul.

ELABORANDO O CÓDIGO

Inicialmente, vamos entender a lógica de programação a partir dos seguintes passos:

1- Definir as variáveis

A variável vermelho será utilizada para representar a porta 12, que está conectada ao LED interno vermelho. A variável verde será utilizada para representar a porta 10, que está conectada ao LED interno verde. A variável azul será utilizada para representar a porta 9, que está conectada ao LED interno azul.

2- Definir portas de saída

As variáveis vermelho (porta 12), verde (porta 10) e azul (porta 9) devem ser definidas como saída, ou seja, OUTPUT;

3- Chamar as funções no loop

Ao invés de escrever todas as instruções necessárias para acionamento do LED RGB para cada uma das cores, escreveremos no loop apenas o nome da função correspondente a cada uma dessas cores. Da seguinte maneira:

void loop() {
  Vermelho();//Função para acionamento na cor vermelha
  Verde();//Função para acionamento na cor verde
  Azul();//Função para acionamento na cor azul
  Branco();//Função para acionamento na cor branca
  Magenta();//Função para acionamento na cor magenta
  Amarelo();//Função para acionamento na cor amarela
  Ciano();//Função para acionamento na cor ciano
}

O uso de funções permite o reaproveitamento de código já construído, evita que um trecho do código seja repetido várias vezes e facilita a leitura do programa. Neste projeto, utilizaremos funções com o objetivo de facilitar a leitura lógica e melhorar organização do programa.

4- Escrever as funções para cada uma das cores do LED RGB

Conforme mencionado anteriormente, o LED RGB possui três LEDs internos, um vermelho, outro verde e outro azul. Para que ele exiba a cor vermelha, por exemplo, é necessário que o LED interno vermelho seja colocado em nível alto e os demais em nível baixo.

Para que o LED RGB exiba as cores branco, magenta, amarelo e ciano é necessário fazer uma combinação as cores emitidas pelos LEDs internos. Para que o LED RGB exiba a cor amarela, por exemplo, será preciso acionar os LEDs internos vermelho e verde.

A Tabela 1 detalha o estado dos LEDs internos do LED RGB para exibição de cada cor.

Função	Vermelho	Verde	Azul
Vermelho()	HIGH	LOW	LOW
Verde()	LOW	HIGH	LOW
Azul()	LOW	LOW	HIGH
Branco()	HIGH	HIGH	HIGH
Magenta()	HIGH	LOW	HIGH
Amarelo()	HIGH	HIGH	LOW
Ciano()	LOW	HIGH	HIGH
Desligado	LOW	LOW	LOW

Para cada uma das funções escritas no loop() deverão ser criadas, com nome idêntico declarado no loop. A primeira função que declaramos foi Vermelho() e sua estrutura deve ser a seguinte:

void Vermelho() {
  digitalWrite(vermelho, HIGH);
  delay(1000);
  digitalWrite(vermelho, LOW);
  delay(1000);
}

A função Vermelho() contém todas as instruções necessárias para acionamento do LED RGB na cor vermelha por 1 segundo e para o desligamento do mesmo por 1 segundo.

De modo semelhante e com auxílio das informações contidas na Tabela 1 escreveremos as funções para acionamento do LED RGB nas outras cores.

Desta forma, o Sketch ficará da seguinte forma:

int azul = 9;//Atribui o valor 9 a variável azul
int verde = 10;//Atribui o valor 10 a variável verde
int vermelho = 12;//Atribui o valor 12 a variável vermelho

void setup() {
  pinMode(azul, OUTPUT);//Define a variável azul como saída
  pinMode(verde, OUTPUT);//Define a variável verde como saída
  pinMode (vermelho, OUTPUT);//Define a variável vermelho como saída
}

void loop() {
  Vermelho();//Função para acionamento na cor vermelha
  Verde();//Função para acionamento na cor verde
  Azul();//Função para acionamento na cor azul
  Branco();//Função para acionamento na cor branca
  Magenta();//Função para acionamento na cor magenta
  Amarelo();//Função para acionamento na cor amarela
  Ciano();//Função para acionamento na cor ciano
}

void Vermelho() {
  digitalWrite(vermelho, HIGH);//Coloca vermelho em nível alto, ligando-o
  delay(1000);//Intervalo de 1 segundo
  digitalWrite(vermelho, LOW);//Coloca vermelho em nível baixo
  delay(1000);//Intervalo de 1 segundo
}
void Verde() {
  digitalWrite(verde, HIGH);//Coloca verde em nível alto
  delay(1000);//Intervalo de 1 segundo
  digitalWrite(verde, LOW);//Coloca verde em nível baixo
  delay(1000);//Intervalo de 1 segundo
}
void Azul() {
  digitalWrite(azul, HIGH);//Coloca azul em nível alto
  delay(1000);//Intervalo de 1 segundo
  digitalWrite(azul, LOW);//Coloca azul em nível baixo
  delay(1000);//Intervalo de 1 segundo
}
void Branco() {
  digitalWrite(azul, HIGH);//Coloca azul em nível alto
  digitalWrite(vermelho, HIGH);//Coloca vermelho em nível alto
  digitalWrite(verde, HIGH);//Coloca verde em nível alto, ligando-o
  delay(1000);//Intervalo de 1 segundo
  digitalWrite(azul, LOW);//Coloca azul em nível baixo
  digitalWrite(vermelho, LOW);//Coloca vermelho em nível baixo
  digitalWrite(verde, LOW);//Coloca verde em nível baixo
  delay(1000);//Intervalo de 1 segundo
}
void Magenta() {
  digitalWrite(azul, HIGH);//Coloca azul em nível alto
  digitalWrite(vermelho, HIGH);//Coloca vermelho em nível alto
  delay(1000);//Intervalo de 1 segundo
  digitalWrite(azul, LOW);//Coloca azul em nível baixo
  digitalWrite(vermelho, LOW);//Coloca vermelho em nível baixo
  delay(1000);//Intervalo de 1 segundo
}
void Amarelo() {
  digitalWrite(verde, HIGH);//Coloca verde em nível alto
  digitalWrite(vermelho, HIGH);//Coloca vermelho em nível alto
  delay(1000);//Intervalo de 1 segundo
  digitalWrite(verde, LOW);//Coloca verde em nível baixo
  digitalWrite(vermelho, LOW);//Coloca vermelho em nível baixo
  delay(1000);//Intervalo de 1 segundo
}
void Ciano() {
  digitalWrite(verde, HIGH);//Coloca verde em nível alto
  digitalWrite(azul, HIGH);//Coloca azul em nível baixo alto
  delay(1000);//Intervalo de 1 segundo
  digitalWrite(verde, LOW);//Coloca verde em nível baixo
  digitalWrite(azul, LOW);//Coloca azul  em nível baixo
  delay(1000);//Intervalo de 1 segundo
}

Espero que tenham gostado deste tutorial. Em caso de dúvidas, deixe seu comentário abaixo.