fbpx

Utilizando o LED RGB no Arduino


Olá pessoal,

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.

Figura 1: Combinação de cores.

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.

Figura 2: Modo de ligação dos LEDS RGB.

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 desligado. 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çãoVermelhoVerdeAzul
Vermelho()HIGHLOWLOW
Verde()LOWHIGHLOW
Azul()LOWLOWHIGH
Branco()HIGHHIGHHIGH
Magenta()HIGHLOWHIGH
Amarelo()HIGHHIGHLOW
Ciano()LOWHIGHHIGH
DesligadoLOWLOWLOW
Tabela 1 – Estado dos LEDs internos do LED RGB para exibir as cores.

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.

Att.,

Carol Correia Viana

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.