Controlando LED RGB 02, com arduíno

 Wellington R. Domingos.

Nesse artigo, trago o projeto de um controlador de LED RGB com arduíno, com ele, poderemos controlar um LED RGB através de pulsos PWM, e poderemos ver o valor RGB em um display LCD, assim poderemos aplicar o valor que quisermos em nosso LED. Esse circuito já um pouco mais avançado, porem o arduíno  permite um aprendizado rápido e prático.

Há algumas semanas atrás, postamos aqui no blog o projeto de um circuito simples com transistores que permitia controlar um LED RGB usando potenciômetros comuns, nessa nova postagem, trago uma atualização desse projeto, desa vez, usando arduíno, que nos permitirá um controle mais preciso do nosso LED, além disso, poderemos ver o valor RGB em um display LCD, assim, basta saber os valores de cada cor para gerar a cor que queremos e aplicar no circuito.

O Circuito.

O circuito do nosso projeto foi feito para usar um LCD de 16x2, seja na configuração paralela de 4 bits quanto na configuração serial I2C. Na figura 01, temos o circuito do projeto usando um LCD na configuração paralela de 4 bits, esse é o que eremos montar e testa aqui no blog, já na figura 02, temos o circuito que utiliza um display serial I2C, ambos iram funcionar da mesma forma. O funcionamento do circuito é simples, o arduíno aplica nos LED, um sinal PWM para controlar seu brilho, aplicando um sinal em cada cor, conseguimos combiná-las para gerar outras cores.

Os potenciômetro são lidos pelas portas analógicas A0, A1 e A2, aplicando um nível de tensão de 0 a 5V nas entradas analógicas do arduíno, conseguimos variar o PWM entre 0 e 255, e amostrar esses valores no display, assim, só precisamos saber o valor RGB da cor que queremos gerar, para isso, bastar consultar uma tabela RGB para poder saber o código da cor que queremos gerar com nosso LED, veja na figura 03 uma tabela RGB do programa Inkscape.

O LED.

 O LED RGB utilizado nos nossos testes é omesmo usado do primeiro projeto sobre o tema postado aqui no blog, veja na figura 04 que se trata de um LED RGB difuso comum, não use LED de alto brilho, não tem um feito bom, o difuso é melhor para visualizar as cores. Notem na imagem os terminais do LED, eles podem mudar de fabricante para fabricante, consulte o datasheet do seu LED para saber mais informações sobre o mesmo, outra coisa é em relação ao circuito, na figura 01 e 02, temos o circuito para LEDs anodo comum, para se utilizar LEDs catodo comum, substitua os transistores BC547 por BC557, seguindo a ordem de ligação mostrada na primeira postagem feita aqui no blog sobre esse tema, clique aqui.

 

Teste e prática.

Observem que não é possível gerar com perfeição algumas cores, como por exemplo as mais claras, como se trata de luz é necessário alguns truques para poder visualizarmos as cores com o máximo de nitidez. Primeiramente aproxime o LED de uma superfície branca para que a sua luz ilumine-a, assim poderemos enxergar as cores, pois o LED irá iluminar a superfície com a cor que irá gerar. Ajuste nos potenciômetros os valores de cada cor do LED para a cor desejada, comparando o valor da tabela RGB com os valores exibidos no display, vá então combinando as cores, e veja como o circuito é capaz de regar várias cores, mesmo com limitações por conta do LED, o circuito funciona bem.

Montagem.

Figura 05: Montagem em proto-board.

A montagem do projeto foi feita em proto-board, figuras 05 e 06, como se trata de um arduíno, usamos jumps para fazer as conexões do mesmo com o restante do circuito, no entanto, é possível desenhar uma paca de circuito impresso, basta remover o microcontrolador ATMEG328P da paca arduíno e identificar os terminais do arduíno nos terminais do AVR, e então, desenhar a placa, não faremos isso aqui, pois o intuito é apenas mostrar o circuito funcionando, mais abaixo, temos o programa do nosso projeto.

 

Figura 06: Montagem em proto-board.

 

 

 

 

 

 

 

Programa.

 --------------------------------------------------------------------------------------------------------

//*************************************************************//
//* Programa controle RGB com arduino                      *//
//* Escrito por Wellington R. Domingos                         *//
//* Utiliza arduino UNO R3                                            *//
//* Utiliza 3 potenciometros de 10K                               *//
//* Utiliza um LED RGB anodo comum                         *//
//* Utiliza display LCD 16 x 2                                        *//
//* Escrito em 10/10/2018                                              *//
//* Atualização 08/02/2019                                            *//
//*************************************************************//

//*************************************************************//
// Chama bibliotecas                                                      *//
//*************************************************************//

#include <LiquidCrystal.h>                     //Chama biblioteca para controle do display
//#include <LiquidCrystal_I2C.h>

//*************************************************************//
// Define rotinas do programa                                        *//
//*************************************************************//

void LeitPot();                                         //Rotina de leitura dos pontenciometros
void ConLEDs();                                     //Rotina de controle do LED
void DispLcd();                                       //Rotina de controle do display
void CorrLcd();                                       //Rotina para correçao de variaves

//*************************************************************//
// Define variáves                                                          *//
//*************************************************************//

int Red, Green, Blue;                             //Armezena os valores para RGB
int Pwm1, Pwm2, Pwm3;                       //Armazena os valores para pulsos de PWM

//*************************************************************//
// Definição de hardware                                               *//
//*************************************************************//

#define Pot1 A0                                     //Potenciometro 1 ligado no pino analgico A0
#define Pot2 A1                                     //Potenciometro 2 ligado no pino analgico A2
#define Pot3 A2                                     //Potenciometro 3 ligado no pino analgico A3
#define LedR 3                                      //LED vermelho ligado no pino digital 3
#define LedG 5                                      //LED verde ligado no pino digital 5
#define LedB 6                                      //LED azul ligado no pino digital 6

//*************************************************************//
// Cria objeto para o display LCD                                  *//
//*************************************************************//

LiquidCrystal Lcd(12, 11, 10, 9, 8, 7);
//LiquidCrystal_I2C Lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);

//*************************************************************//
// Programa principal                                                     *//
//*************************************************************//

void setup() {
 
  Lcd.begin(16, 2);                                   //Define display de 16 caracter e 2 linhas
 
  pinMode(Pot1, INPUT);                         //Define pino analgico A0 como entrada
  pinMode(Pot2, INPUT);                         //Define pino analgico A2 como entrada
  pinMode(Pot3, INPUT);                         //Define pino analgico A3 como entrada
  pinMode(LedR, OUTPUT);                    //Define pino digital 3 como saida
  pinMode(LedG, OUTPUT);                    //Define pino digital 5 como saida
  pinMode(LedB, OUTPUT);                    //Define pino digital 6 como saida

  //Lcd.setBacklight(HIGH);                      //Liga luz de fundo do LCD
  Lcd.setCursor(0, 0);                               //Posicione cursor do display na linha 1 e na coluna 1
  Lcd.print("Cont. LED RGB 02");            //Escreve menssagem no display
  Lcd.setCursor(0, 1);                              //Posiciona cursor do display na linha 2 e na coluna 1
  Lcd.print("R    G    B");                          //Escreve menssagem no display
 
  delay(500);                                           //Espera 500 milissegundos para atualizaço do display
 
}                                                              //Fim setup

//*************************************************************//
// Loop infinito                                                                *//
//*************************************************************//

void loop() {
 
  LeitPot();                                           //Chama rotina de leitura dos potenciometros
  ConLEDs();                                       //Chama rotina de controle do LED RGB
  DispLcd();                                         //Chama rotina de controle do display
  CorrLcd();                                         //Chama rotina de correçao das leituras
 
}                                                          //Fim loop infinito

//*************************************************************//
// Rotina para leitura dos protenciômetros                    *//
//*************************************************************//

void LeitPot() {
 
  Red   = analogRead(Pot1);                     //Red recebe valor de potenciometro 1
  Green = analogRead(Pot2);                    //Green recebe valor de potenciometro 2
  Blue  = analogRead(Pot3);                      //Blue receve valor de potenciometro 3
 
  Pwm1 = map(Red, 0, 1023, 0, 255);       //Converte 10 bits do conversor analogico em 8 bits do PWM
  Pwm2 = map(Green, 0, 1023, 0, 255);    //Converde 10 bits do conversor analogico em 8 bits do PWM
  Pwm3 = map(Blue, 0, 1023, 0, 255);       //Converte 10 bits do conversor analogico em 8 bits do PWM
 
}                                                                 //Fim LeitPot

//*************************************************************//
// Rotina para controle do LED RGB                            *//
//*************************************************************//

void ConLEDs() {
 
  analogWrite(LedR, Pwm1);                  //Gera pulso PWM para o LED vermelho
  analogWrite(LedG, Pwm2);                  //Gera pulso PWM para o LED verde
  analogWrite(LedB, Pwm3);                  //Gera pulso PWM para o LED azul
 
}                                                              //Fim ConLEDs

//*************************************************************//
// Rotina para controle do display LCD                         *//
//*************************************************************//

void DispLcd() {
 
  Red = map(Red, 0, 1023, 0, 255);             //Converte valor de 10 bits para 8 bits
  Green = map(Green, 0, 1023, 0, 255);      //Converte valor de 10 bits para 8 bits
  Blue = map(Blue, 0, 1023, 0, 255);           //Converte valor de 10 bits para 8 bits
 
  Lcd.setCursor(1, 1);                                  //Posiciona o cursor do display na segunda lina e na coluna 2
  Lcd.print(Red);                                          //Mostra o valor de Red no display
 
  Lcd.setCursor(6, 1);                                 //Posiciona o cursor do display na linha 2 e na coluna 7
  Lcd.print(Green);                                      //Mostra o valor de Green no display
 
  Lcd.setCursor(11, 1);                                //Posiciona o cursor do display na linha 2 e na coluna 12
  Lcd.print(Blue);                                         //Mostra o valor de Blue no display
 
}                                                                  //Fim DispLcd

//*************************************************************//
// Rotina para correção das informações no LCD         *//
//*************************************************************//

void CorrLcd() {
 
  if(Red < 100) {                                      //Se o valor de Red for menor que 100
 
    Lcd.setCursor(3, 1);                           //Posiciona o cursor do display na linha 2 e na coluna 5
    Lcd.print(" ");                                      //Escreve um espaço e apaga a terceira casa decinal de Red
    
    if(Red < 10) {                                     //Se o valor de Red for menor que 10
    
      Lcd.setCursor(2, 1);                         //Posiciona o cursor do display na linha 2 e na coluna 4
      Lcd.print(" ");                                    //Escreve um espaço e apa a segunda casa decimal de Red
    }
  }

  if(Green < 100) {                                 //Se o valor de Green for menor que 100
 
    Lcd.setCursor(8, 1);                         //Posiciona o cursor do display na linha 2 e na coluna 10
    Lcd.print(" ");                                    //Escreve um espaço e apaga a terceira casa decinal de Red
    
    if(Green < 10) {                                 //Se o valor de Red for menor que 10
    
      Lcd.setCursor(7, 1);                       //Posiciona o cursor do display na linha 2 e na coluna 9
      Lcd.print(" ");                                  //Escreve um espaço e apa a segunda casa decimal de Red
    }
  }
 
   if(Blue < 100) {                                 //Se o valor de Red for menor que 100
 
    Lcd.setCursor(13, 1);                      //Posiciona o cursor do display na linha 2 e na coluna 15
    Lcd.print(" ");                                   //Escreve um espaço e apaga a terceira casa decinal de Red
    
    if(Blue < 10) {                                  //Se o valor de Red for menor que 10
    
      Lcd.setCursor(12, 1);                    //Posiciona o cursor do display na linha 2 e na coluna 14
      Lcd.print(" ");                                 //Escreve um espaço e apa a segunda casa decimal de Red
    }
  }
}                                                          //Fim CorrLcd

----------------------------------------------------------------------------------------------------------

Conclusão.

Abordamos nessa postagem sobre os LEDs RGB, e apresentamos uma forma de como controlar um usando o arduíno, existem outras formas de controlar LEDs RGB, iremos trazer mais conteúdo sobre o assunto em postagens futuras. Fiquem atentos também no nosso canal no YouTube, Canal WD Projetos, os projetos são postados primeiramente lá em forma de vídeos, vamos ficando por qui, nos vemos na próxima pastagem, até lá.

Vídeo.

Vejam o vídeo desse projeto que foi postado em nosso canal do YouTube, nele explico o funcionamento do circuito e mostro o seu funcionamento, aproveite para se inscrever em nosso canal para ficar por dentro de novos conteúdos sobre eletrônica, Canal WD Projetos, clique aqui.

 

Arquivos do projeto.

Baixe os arquivos do projeto, imagens e o código do arduíno.

Clique aqui.