Início / Projetos Arduino / Projetos Squids / Básico / Projeto 25 - Criando cores com LED RGB usando 1 potenciômetro

---

Projeto 25 - Criando cores com LED RGB usando 1 potenciômetro

Angelo Luis Ferreira | 08/09/2017 Acessos: 11.432

Objetivo

Criar um circuito onde se pode gerar cores em um LED RGB através de um potenciômetro e botões (push buttons) seletores. Neste projeto teremos um botão para selecionar as cores em um Led RGB (ou 3 leds comuns), vermelho, verde ou azul,  que terão os seus brilhos ajustados por um potenciômetro. Outro botão seletor acionará o segundo Led RGB que exibirá a cor definida pelos valores ajustados anteriormente pelo potenciômetro.

Obs.: Fazendo o controle do brilho de cada um dos leds encapsulado em um Led RGB podemos misturar estes brilhos e produzir diversas cores diferentes. Combinando os valores de cada cor podemos criar até 16,7 milhões de cores diferentes (256 X 256 X 256).

Aplicação

Para fins didáticos, estudo do PWM (Pulse Width Modulation), valores RGB (Red, Green and Blue) e aplicações com LEDs.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 830 pontos
Jumpers	Kit cabos ligação macho / macho	1
Led RGB	Led RGB 5mm	2		Você poderá utilizar um LED RGB ânodo ou cátodo. Você poderá utilizar também um LED RGB difuso ou de alto brilho. Você poderá substituir 1 Led RGB por 3 Leds 5mm comuns, sendo 1 vermelho, 1 verde e um azul.
Resistor	Resistor	8		2 Resistor de 150Ω   4 Resistores de 100Ω 2 Resistores de 10KΩ (push button) Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado.
Push Button	Push Button 6x6x5m	2		Utilizar resistores de 10KΩ
Potenciômetro	Potenciômetro 10K	1		O valor do potenciômetro aumenta quando giramos o eixo do componente na direção do polo negativo para o polo positivo.
Arduino UNO R3	Arduino UNO	1

Obs.: Utilizar também uma folha de papel A4 para criar um difusor.

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.

Obs.: O Led RGB à esquerda poderá ser substituido por 3 leds comuns, sendo 1 vermelho, 1 verde e 1 azul.

Atenção:

1. O LED RGB nada mais é que três Leds em um só, ele é formado por um vermelho (R de red), um verde (G de green) e um azul (B de blue). Associando as cores e intensidade do brilho dos três Leds é possível se obter várias possibilidades de cores.

2. Lembre-se que existem 2 tipos de LED RGB, o ânodo comum e o cátodo comum. Observe que para cada uma das cores existe um terminal, e além disso o quarto terminal (maior) deverá ser conectado ao polo positivo (ânodo comum) e ao polo negativo (cátodo comum).

2.1. Leia também: Led RGB anodo comum ou o Led RGB catodo comum? Como identificar e usar com Arduino (circuito e programação).

3. ATENÇÃO: Podem existir no mercado outros tipos de LED RGB com configurações dos terminais diferentes dos LEDs RGB comuns (veja a imagem abaixo). Por isso é importante verificar com o fornecedor o tipo de LED que irá adquirir. Caso o seu LED RGB tenha os pinos configurados conforme figura abaixo ou de outro tipo, basta ajustar as variáveis globais R, G e B do sketch do nosso projeto.

4. Para determinar os valores dos resistores para o seu LED RGB, utilize os dados do fabricante (datasheet). No nosso projeto, utilizamos um LED RGB tipo ânodo comum com as seguintes características:

4.1. A partir destes dados calculamos o valor dos resistores (ou determine através da tabela prática: Tabela prática de utilização de leds 3mm e 5m). Para calcular o valor dos resistores leia: Como calcular o resistor adequado para o led ou utilize o aplicativo: Calculador de Led.

4.2. Após os cálculos determinamos os seguintes resistores: 2 resistores de 100Ω (terminais cor verde e azul) e 1 resistor de 150Ω (terminal cor vermelho).

Obs: Se você não tiver os dados do fabricante, utilize como referência os valores dos resistores que mostramos acima, tanto para o LED alto brilho como para o LED difuso. Se não tiver os resistores com os valores exatos ao determinado, utilize resistores com valores mais altos. No nosso exemplo utilizamos 2 resistores de 100Ω (terminais cor verde e azul) e 1 resistor de 150Ω (terminal cor vermelho).

5. Veja na imagem abaixo como posicionamos o nosso LED RGB cátodo comum (conectado ao polo negativo GND) no protoboard.

6. Veja na figura abaixo como deve ser montado o potenciômetro. Observe a ligação do cabo positivo e negativo no potenciômetro. O cabo amarelo (pino de centro) se conecta com o pino analógico do Arduino. Nesta montagem, quando girarmos o eixo do potenciômetro no sentido horário, o o brilho do led aumentará.

7. Veja na imagem abaixo que utilizamos 2 LEDs RGB cátodo comum (conectado ao polo negativo GND) e que a montagem do circuito 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.

Obs 1: Caso tenha um LED RGB ânodo comum, conecte o terminal mais logo no 5V (polo positivo do Arduino).

Obs 2: Se você não tiver 2 LEDs RGB, substitua o led à esquerda por 3 leds comuns, sendo 1 vermelho, 1 verde e 1 azul. Você também poderá substituir os 2 LEDs RGB por leds comuns.

Testando a conexão do Led RGB

Para testarmos o circuito e verificar se o LED RGB cátodo comum está corretamente conectado, utilize o código abaixo:

Obs.: No Led RGB cátodo comum a cor é ativada com sinal digital de nível alto, ou seja HIGH (nível lógico 1).

Para testarmos o circuito e verificar se o LED RGB está corretamente conectado, utilize o código abaixo:

/*******************************************************************************
*
*    Usando um LED RGB CATODO COMUM(TESTE)
*            http://squids.com.br/arduino
*
*******************************************************************************/
 
// define pinos de entrada e saída do Arduino 
const int R = 9;   // terminal Red (vermelho)
const int G = 10;  // terminal Green (verde)
const int B = 11;  // terminal Blue (azul)

void setup(){
// pin mode - definie entradas e saídas 
    pinMode(R, OUTPUT); 
    pinMode(G, OUTPUT); 
    pinMode(B, OUTPUT); 
}

void loop(){
    // VERMELHO PURO
    digitalWrite(R, HIGH);
    digitalWrite(G, LOW);
    digitalWrite(B, LOW);
    delay(1000);
    // VERDE PURO
    digitalWrite(R, LOW);
    digitalWrite(G, HIGH);
    digitalWrite(B, LOW);
    delay(1000);
    // AZUL PURO
    digitalWrite(R, LOW);
    digitalWrite(G, LOW);
    digitalWrite(B, HIGH);
    delay(1000);
}

Observe que a cada segundo (1000ms) aparecerá as cores Vermelho, Verde e Azul sucessivamente, nesta ordem.

Se o LED RGB não acender, inverta a conexão do terminal maior (de GND para 5V), pois possivelmente o led que você está utilizando é um LED RGB ânodo comum.

Da mesma forma, verifique se o LED RGB ânodo comum está corretamente conectado, utilize o código abaixo:

Obs.: No Led RGB ânodo comum a cor é ativada com sinal digital de nível baixo, ou seja LOW (nível lógico 0).

/*******************************************************************************
*
*    Usando um LED RGB ANODO COMUM (TESTE)
*            http://squids.com.br/arduino
*
*******************************************************************************/

// define pinos de entrada e saída do Arduino 
const int R = 9;   // terminal Red (vermelho)
const int G = 10;  // terminal Green (verde)
const int B = 11;  // terminal Blue (azul)

void setup(){
// pin mode - definie entradas e saídas 
    pinMode(R, OUTPUT); 
    pinMode(G, OUTPUT); 
    pinMode(B, OUTPUT); 
}

void loop(){
    // VERMELHO PURO
    digitalWrite(R, LOW);
    digitalWrite(G, HIGH);
    digitalWrite(B, HIGH);
    delay(1000);
    // VERDE PURO
    digitalWrite(R, HIGH);
    digitalWrite(G, LOW);
    digitalWrite(B, HIGH);
    delay(1000);
    // AZUL PURO
    digitalWrite(R, HIGH);
    digitalWrite(G, HIGH);
    digitalWrite(B, LOW);
    delay(1000);
}

Se ao iniciar o programa e não aparecer a cor vermelho em primeiro lugar, possivelmente é porque o LED RGB que você está utilizando é um tipo configuração diferente dos LEDs mais comuns. Neste caso, altere as variáveis globais do probrama, como no exemplo abaixo:

const int R = 11;
const int G = 9;
const int B = 10;

Faça novamente o e ajuste o sketch até encontrar os valores corretos. Depois utilize esses valores para declarar as variáveis no nosso projeto a seguir.

Código do Projeto (sketch) - USANDO LED RGB CÁTODO COMUM

Neste projeto vamos criar diversas combinações de cores utilizando um LED RGB e o PWM (Pulse width modulation - Modulação).

Digite o código abaixo no ambiente de desenvolvimento do Arduino. Faça a verificação e o upload.

/*******************************************************************************
*
*    Projeto 25 – Criando cores em um LED RGB utilizando um potenciômetro
*                     (Led RGB cátodo comum)
*                   http://squids.com.br/arduino
*
*******************************************************************************/
 
// Define as conexões para cada cor do RGB
const int R = 9;
const int G = 10;
const int B = 11;
int intensidadeR;
int intensidadeG;
int intensidadeB;

// Armazena os valores para cada cor entre (0-255)
int ValorR=255;
int ValorG=0;
int ValorB=0;

// Define as conexões do botão seletor e do potenciomentro (analógico)
const int seletor = 2;
const int pot = A2;

// Define as conexões do LED RGB e acionador
const int ledRGB = 7; // botão acionador
const int Red = 3;
const int Green = 5;
const int Blue = 6;

void setup() 
{ 
// Define Monitor Serial (visualização de dados)
  Serial.begin(9600); // taxa de comunicação entre Arduino e PC
  
// Indica que os pinos dos botões são de SAÍDA do Arduino 
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(seletor, INPUT);
  pinMode(Red, OUTPUT);
  pinMode(Green, OUTPUT);
  pinMode(Blue, OUTPUT);
  pinMode(ledRGB, INPUT);
  pinMode(pot, INPUT);
  
  analogWrite(R, 255);  //coloca valor inicial para vermeho (padrão inicial)
} 
 
// Valor padrão inicial (pinLed): vermelho
// 0= Vermelho, 1 = Verde, 2 = Azul
int pinLed = 0;
int pinLed2 = 0;
 
void loop() 
{ 
        
   if (digitalRead(seletor) == HIGH) 
   {
      pinLed2 = 0;
      pinLed++; 
      
      // Limita o número de cores
      if (pinLed > 2) { pinLed=0; }
   
      // Apagamos todas as cores
      analogWrite(R, 0);
      analogWrite(G, 0);
      analogWrite(B, 0); 

      analogWrite(Red, 0);
      analogWrite(Green, 0);
      analogWrite(Blue, 0);
      
      // Espera soltar o botão seletor
      while (digitalRead(seletor) == HIGH) {  }            
      delay(10); //
   }

    //define valor do potenciômetro
     int valPoten = analogRead(pot);
     if (pinLed == 0) { intensidadeR = map(valPoten,0,1023,0,255);}
     if (pinLed == 1) { intensidadeG = map(valPoten,0,1023,0,255);}
     if (pinLed == 2) { intensidadeB = map(valPoten,0,1023,0,255); }
     Serial.print("R = ");
     Serial.print(intensidadeR);
     Serial.print(" | G= ");
     Serial.print(intensidadeG);
     Serial.print(" | B= ");
     Serial.println(intensidadeB);

     delay(50);
   
    // Atualiza variáveis com valores do potenciômetro
   
     if (pinLed == 0) { ValorR = intensidadeR; }
     if (pinLed == 1) { ValorG = intensidadeG; }
     if (pinLed == 2) { ValorB = intensidadeB; }
     
     delay(10);
    
    // Atualiza o valor da cor selecionada se o Led2 estiver desligado
    if (pinLed2 ==0) {
    if (pinLed == 0) { analogWrite(R, ValorR); }
    if (pinLed == 1) { analogWrite(G, ValorG); }
    if (pinLed == 2) { analogWrite(B, ValorB); }
    }
    
    if (digitalRead(ledRGB) == HIGH) {
      pinLed2 = 1;
      // Apagamos todas as cores
      analogWrite(R, 0);
      analogWrite(G, 0);
      analogWrite(B, 0); 
    }            
      
    // Espera soltar o botão seletor
      while (digitalRead(ledRGB) == HIGH) {  
      delay(10); //

      analogWrite(Red, ValorR);
      analogWrite(Green, ValorG);
      analogWrite(Blue, ValorB);
      
      // Apagamos todas as cores
      analogWrite(R, 0);
      analogWrite(G, 0);
      analogWrite(B, 0);  
      
      } 
}

Código do Projeto (Sketch) - USANDO LED RGB ÂNODO COMUM

Neste projeto vamos criar diversas combinações de cores utilizando um LED RGB e o PWM (Pulse width modulation - Modulação).

Atenção: O Led RGB ânodo comum deverá estar conectado no Vcc

Digite o código abaixo no ambiente de desenvolvimento do Arduino. Faça a verificação e o upload.

/*******************************************************************************
*
*    Projeto 25 – Criando cores em um LED RGB utilizando um potenciômetro
*                     (Led RGB ânodo comum)
*                   http://squids.com.br/arduino
*
*******************************************************************************/
 
// Define as conexões para cada cor do RGB
const int R = 9;
const int G = 10;
const int B = 11;
int intensidadeR;
int intensidadeG;
int intensidadeB;

// Armazena os valores para cada cor entre (0-255)
int ValorR=255;
int ValorG=0;
int ValorB=0;

// Define as conexões do botão seletor e do potenciomentro (analógico)
const int seletor = 2;
const int pot = A2;

// Define as conexões do LED RGB e acionador
const int ledRGB = 7; // botão acionador
const int Red = 3;
const int Green = 5;
const int Blue = 6;

void setup() 
{ 
// Define Monitor Serial (visualização de dados)
  Serial.begin(9600); // taxa de comunicação entre Arduino e PC
  
// Indica que os pinos dos botões são de SAÍDA do Arduino 
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(seletor, INPUT);
  pinMode(Red, OUTPUT);
  pinMode(Green, OUTPUT);
  pinMode(Blue, OUTPUT);
  pinMode(ledRGB, INPUT);
  pinMode(pot, INPUT);
  
  analogWrite(R, 255-ValorR);  //coloca valor inicial para vermeho (padrão inicial)
  analogWrite(R, 255-ValorG);  //coloca valor inicial para vermeho (padrão inicial)
  analogWrite(R, 255-ValorB);  //coloca valor inicial para vermeho (padrão inicial)
} 
 
// Valor padrão inicial (pinLed): vermelho
// 0= Vermelho, 1 = Verde, 2 = Azul
int pinLed = 0;
int pinLed2 = 0;
 
void loop() 
{ 
        
   if (digitalRead(seletor) == HIGH) 
   {
      pinLed2 = 0;
      pinLed++; 
      
      // Limita o número de cores
      if (pinLed > 2) { pinLed=0; }
   
      // Apagamos todas as cores
      analogWrite(R, 255);
      analogWrite(G, 255);
      analogWrite(B, 255); 

      analogWrite(Red, 255);
      analogWrite(Green, 255);
      analogWrite(Blue, 255);
      
      // Espera soltar o botão seletor
      while (digitalRead(seletor) == HIGH) {  }            
      delay(10); //
   }

    //define valor do potenciômetro
     int valPoten = analogRead(pot);
     if (pinLed == 0) { intensidadeR = map(valPoten,0,1023,0,255);}
     if (pinLed == 1) { intensidadeG = map(valPoten,0,1023,0,255);}
     if (pinLed == 2) { intensidadeB = map(valPoten,0,1023,0,255); }
     Serial.print("R = ");
     Serial.print(intensidadeR);
     Serial.print(" | G= ");
     Serial.print(intensidadeG);
     Serial.print(" | B= ");
     Serial.println(intensidadeB);

     delay(50);
   
    // Atualiza variáveis com valores do potenciômetro
   
     if (pinLed == 0) { ValorR = intensidadeR; }
     if (pinLed == 1) { ValorG = intensidadeG; }
     if (pinLed == 2) { ValorB = intensidadeB; }
     
     delay(10);
    
    // Atualiza o valor da cor selecionada se o Led2 estiver desligado
    if (pinLed2 ==0) {
    if (pinLed == 0) { analogWrite(R, 255-ValorR); }
    if (pinLed == 1) { analogWrite(G, 255-ValorG); }
    if (pinLed == 2) { analogWrite(B, 255-ValorB); }
    }
    
    if (digitalRead(ledRGB) == HIGH) {
      pinLed2 = 1;
      // Apagamos todas as cores
      analogWrite(R, 255);
      analogWrite(G, 255);
      analogWrite(B, 255); 
    }            
      
    // Espera soltar o botão seletor
      while (digitalRead(ledRGB) == HIGH) {  
      delay(10); //

      analogWrite(Red, 255-ValorR);
      analogWrite(Green, 255-ValorG);
      analogWrite(Blue, 255-ValorB);
      
      // Apagamos todas as cores
      analogWrite(R, 255);
      analogWrite(G, 255);
      analogWrite(B, 255);  
      
      } 
}

Vídeo

Como o projeto deve funcionar - (usando Led RGB cátodo comum)

1. Após iniciar o programa no Arduino, o Led RGB ficará aceso na cor vermelho.

2. Ajuste o brilho do led girando o eixo do potenciômetro. O sentido do eixo do potenciômetro será definido pela polaridade, ou seja, no sentido horário o brilho do led aumentará.

3. Para visualizar os valores definidos pelo potenciômetro, clique no ícone monitor serial do IDE do Arduino, como mostra a figura abaixo:

4. Girando o eixo do potenciômetro alteramos o brilho e o valor da variável. No exemplo vamos criar a cor Orchild2 (Tabela cores Visual Dicas), ou seja R = 238, G = 122 e B = 233. Então, vamos ajustar primeiro o vermelho para 238. Obs.: No vídeo do nosso exemplo acima utilizamos as cores Amarelo - R=255|V=205|B=0 e Pink R=255|V=0|b=205.

5. Ao clicar o botão seletor (botão mais à esquerda), alternamos as cores para verde e depois para o azul. Através do potenciômetro, fazemos os ajustes de brilho nestas cores também até atingirmos os valores da cor desejada (R = vermelho, V= Verde e B = azul).

6. Agora é só clicar no segundo botão (mais a direita) para visualizarmos a cor desejada no segundo LED RGB (botão mais à direita). Observe que a o Led à esquerda deverá ficar apagado.

7. Utilize um difusor (cilindro de papel A4, por exemplo) para que a mistura de cores fique mais agradável, fazendo com que você visualize melhor a cor resultante.

Observações:

a) Alternativamente, pode-se utilizar 3 LEDs comuns, sendo um vermelho, um verde e um azul para um ou para os dois LEDs RGB.

b) Combinando os valores do brilho de cada cor, vermelho, verde e azul, podemos criar até 16,7 milhões de cores diferentes (256 X 256 X 256).

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, variando de 0 a 255, você também pode obter outras cores. Colocando o LED RPG através de um cilindro de papel, por exemplo, o espectro de luz das três cores primárias e suas intensidades criará 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 - (usando Led RGB cátodo comum)

1. Primeiro declaramos as constantes e as variáveis do projeto.

// Define as conexões para cada cor do RGB
const int R = 9;
const int G = 10;
const int B = 11;
int intensidadeR;
int intensidadeG;
int intensidadeB;

// Armazena os valores para cada cor entre (0-255)
int ValorR=255;
int ValorG=0;
int ValorB=0;

// Define as conexões do botão seletor e do potenciomentro (analógico)
const int seletor = 2;
const int pot = A2;

// Define as conexões do LED RGB e acionador
const int ledRGB = 7; // botão acionador
const int Red = 3;
const int Green = 5;
const int Blue = 6;

1.1. Observe que utilizamos constantes e variáveis tipo "int". Veja na tabela abaixo as diferenças nos tipos de constantes e variáveis:

1.2. As constantes tipo inteiro R, G e B, se referem aos terminais do LED RGB conectados aos pinos 9, 10 e 11 do controlador Arduino (saídas utilizada como PWM).

1.3. As constantes tipo inteiro Red, Green e Blue, se referem aos terminais do LED RGB conectados aos pinos 3, 5 e 6 do controlador Arduino (saídas utilizada como PWM).

1.4. As constantes seletor e LedRGB se referem aos terminais do botão seletor e do botão que aciona o Led RGB aos terminais 2 e 7 do Arduino.

1.5. A constante pot se refere ao terminal do potenciômetro conectado ao pino analógico A2 do Arduino.

1.6. Declaramos as variáveis ValorR, ValorG e ValorB com valor igual a 255 e zero.

1.7. Declaramos também as variáveis globais: intensidadeR, intensidadeV e intensidadeB que armazenarão os valores projetados para definir a cor resultante do Led RGB. 

2. Através da estrutura void setup():

void setup() 
{ 
// Define Monitor Serial (visualização de dados)
  Serial.begin(9600); // taxa de comunicação entre Arduino e PC
  
// Indica que os pinos dos botões são de SAÍDA do Arduino 
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(seletor, INPUT);
  pinMode(Red, OUTPUT);
  pinMode(Green, OUTPUT);
  pinMode(Blue, OUTPUT);
  pinMode(ledRGB, INPUT);
  pinMode(pot, INPUT);
  
  analogWrite(R, 255);  //coloca valor inicial para vermeho (padrão inicial)
}

2.1. A função Serial.begin() serve para dizer ao Arduino que será coletado dados para o computador a partir da porta serial e o cabo USB. O número entre os parênteses significa qual é a taxa de dados que a placa vai se comunicar com o computador. Utilizaremos a taxa padrão de 9600bps (bits-per-second). 

2.2. Define-se as constantes R, G e B como saídas do controlador Arduino (OUTPUT) conectados aos pinos 9, 10 e 11 respectivamente.

2.3. Define-se as constantes Red, Green e Blue como saídas do controlador Arduino (OUTPUT) conectados aos pinos 3, 5 e 6 respectivamente.

2.4. Define-se os valores dos botões como entradas no controlador Arduino (INPUT) conectados aos pinos 2 e 7 respectivamente.

2.5. Define-se o valor da entrada do controlador do Arduino (INPUT) conectado ao pino analógico A2.

2.6 Através da função analogWrite(R , 255) define-se o valor inicial do primeiro LED RGB na cor vermelho (R) com a intensidade máxima de brilho (255).

Obs.: A função analogWrite grava um valor analógico referente à onda PWM, ou seja, grava um valor analógico nas variáveis R, G e B. Está predefinido no Arduino que para ter 0% de PWM, basta escrever: analogWrite(pino a ser gravado, 0); do mesmo modo que, para obter 100% de PWM, basta escrever: analogWrite(pino a ser gravado, 255), ou seja, na estrutura que o Arduino entende como PWM, os valores que vão de 0 (mínimo, ou seja, 0%) até 255 (máximo, ou seja,100%). Neste projeto, cada cor do LED RGB parecerá mais escuro ou mais claro, com intensidade do brilho variando entre 0 e 255, de acordo com os valores indicados pelas variáveis ValorR, ValorG e ValorB.

3. Através da estrutura void loop(), obtemos:

void loop() 
{ 
        
   if (digitalRead(seletor) == HIGH) 
   {
      pinLed2 = 0;
      pinLed++; 
      
      // Limita o número de cores
      if (pinLed > 2) { pinLed=0; }
   
      // Apagamos todas as cores
      analogWrite(R, 0);
      analogWrite(G, 0);
      analogWrite(B, 0); 

      analogWrite(Red, 0);
      analogWrite(Green, 0);
      analogWrite(Blue, 0);
      
      // Espera soltar o botão seletor
      while (digitalRead(seletor) == HIGH) {  }            
      delay(10); //
   }

    //define valor do potenciômetro
     int valPoten = analogRead(pot);
     if (pinLed == 0) { intensidadeR = map(valPoten,0,1023,0,255);}
     if (pinLed == 1) { intensidadeG = map(valPoten,0,1023,0,255);}
     if (pinLed == 2) { intensidadeB = map(valPoten,0,1023,0,255); }
     Serial.print("R = ");
     Serial.print(intensidadeR);
     Serial.print(" | G= ");
     Serial.print(intensidadeG);
     Serial.print(" | B= ");
     Serial.println(intensidadeB);

     delay(50);
   
    // Atualiza variáveis com o valor do potenciômetro
   
     if (pinLed == 0) { ValorR = intensidadeR; }
     if (pinLed == 1) { ValorG = intensidadeG; }
     if (pinLed == 2) { ValorB = intensidadeB; }
     
     delay(10);
    
    // Atualiza o valor da cor selecionada se o Led2 estiver desligado
    if (pinLed2 ==0) {
    if (pinLed == 0) { analogWrite(R, ValorR); }
    if (pinLed == 1) { analogWrite(G, ValorG); }
    if (pinLed == 2) { analogWrite(B, ValorB); }
    }
    
    if (digitalRead(ledRGB) == HIGH) {
      pinLed2 = 1;
      // Apagamos todas as cores
      analogWrite(R, 0);
      analogWrite(G, 0);
      analogWrite(B, 0); 
    }            
      
    // Espera soltar o botão seletor
      while (digitalRead(ledRGB) == HIGH) {  
      delay(10); //

      analogWrite(Red, ValorR);
      analogWrite(Green, ValorG);
      analogWrite(Blue, ValorB);
      
      // Apagamos todas as cores
      analogWrite(R, 0);
      analogWrite(G, 0);
      analogWrite(B, 0);  
      
      } 
}

3.1. Inicialmente definimos o LED para iniciar com a cor vermelho. Depois, através da condicional if (digitalRead(seletor) == HIGH), o programa verifica se o botão seletor de cores está acionado ou não. Se acionado, a variável pinLED é incrementada. Verifica-se então se a variável pinLED é maior que 2. Caso positivo, a variável retorna ao valor 0, limitando-a sempre entre 0 e 2.

3.2. Através das funções analogWrite(R , 0), analogWrite(G , 0) e analogWrite(B , 0) e  analogWrite(Red , 0), analogWrite(Green , 0) e analogWrite(Blue , 0) , apaga-se todas as cores, ou seja, torna a intensidade do brilho igual a zero para todas as cores (em função do PWM). Assim, enquanto estivermos com o botão seletor de cores acionado, os 2 LEDs RGB ficarão apagados.

3.3. Define-se o valor para a variável pinLed2 igual a zero.

3.4. Aguarda-se 10 microsegundos, delay(10), após o usuário soltar o botão seletor de cores.

3.5. A variável ValorPoten será igual aos valores lidos diretamente pelo pino analógico onde está conectado o potenciômetro, através da função analogRead() que faz a conversão de analógico para digital. Esta leitura é feita pelo ADC (Analog to Digital Converter - conversor analógico para digital) sem tratamento nenhum. A variável foi definida localmente como tipo inteiro (int), e portanto, vai de 0 a 1023, ou seja, possui 2¹⁰ = 1024 valores inteiros (referente à resolução de 10 bits do ADC para controladores Arduino UNO, Mega e Leonardo). Assim, quando o eixo do potenciômetro estiver totalmente posicionado do lado do polo negativo, o valor lido será zero, e quando o eixo for deslocado totalmente para o lado do polo positivo, o valor será de 1023, variando proporcionalmente conforme a posição do eixo do componente entre estes dois extremos.

Observação: Nosso exemplo, o potenciômetro varia de 0V a 5V(leitura analógica), ou seja, de 0 a 1023 quando convertido em leitura digital através do ADC do controlador Arduino.

3.6. Seguindo o "sketch", verifica-se agora, através das funções if (pinLed == 0) { intensidadeR = map(valPoten,0,1023,0,255);}, if (pinLed == 1) { intensidadeG = map(valPoten,0,1023,0,255);} e if (pinLed == 2) { intensidadeB = map(valPoten,0,1023,0,255);} qual cor foi definida pelo botão seletor.

Desta forma, a variável intensidadeR, intensidadeG ou intensidadeB, dependendo do valor definido pelo seletor (pinLed), irá fazer o mapeamento da variável valPoten, ou seja, ficará definido entre 0 a 255 proporcionalmente à variação do potenciômentro (valPoten) que ficará definido entre 0 e 1023. Portanto, os valores da intensidadeR, intensidadeG ou intensidadeB  irão variar entre 0 a 255, conforme a posição do eixo do potenciômetro, variando entre 0 a 1023.

3.7. Escrevermos na tela do Monitor Serial os valores para R, G e B através dos comandos Serial.print() e Serial.println(), referentes às variáveis intensidadeR, intensidadeG ou intensidadeB. O comando println diferentemente do comando print diz ao monitor que se deve pular uma linha após escrever o valor definido entre parêntesis.

     Serial.print("R = ");
     Serial.print(intensidadeR);
     Serial.print(" | G= ");
     Serial.print(intensidadeG);
     Serial.print(" | B= ");
     Serial.println(intensidadeB);

3.8. Depois os valores das variáveis ValorR, ValorG e ValorB são atualizadas de acordo com os valores do potenciômetro mapeados pelas variáveis intensidadeR, intensidadeG ou intensidadeB. Lembramos sempre que o valor ajustado será definido pelo seletor pinLed (0, 1 ou 2). É realizado uma pausa de 10 msegundos.

// Atualiza variáveis com o valor do potenciômetro
   
     if (pinLed == 0) { ValorR = intensidadeR; }
     if (pinLed == 1) { ValorG = intensidadeG; }
     if (pinLed == 2) { ValorB = intensidadeB; }
     
     delay(10);

 3.9. Agora, se o segundo Led RGB (pinLed2==0) estiver desligado, atualizaremos o primeiro LED RGB com os valores do brilho PWM utilizando o comando analogWrite() para o vermelho R, verde V e azul B.

// Atualiza o valor da cor selecionada se o Led2 estiver desligado
    if (pinLed2 ==0) {
    if (pinLed == 0) { analogWrite(R, ValorR); }
    if (pinLed == 1) { analogWrite(G, ValorG); }
    if (pinLed == 2) { analogWrite(B, ValorB); }
    }

3.10. Verifica se o segundo botão push bottom (ledRGB) está acionado. Se sim, altera a variável pinLed2 para 1 e apaga todas cores do primeiro LED RGB. Depois, aguarda-se 10 microsegundos, delay(10), após o usuário soltar o segundo botão (mais à direita).

if (digitalRead(ledRGB) == HIGH) {
      pinLed2 = 1;
      // Apagamos todas as cores
      analogWrite(R, 0);
      analogWrite(G, 0);
      analogWrite(B, 0); 
    }            
      
    // Espera soltar o botão seletor
      while (digitalRead(ledRGB) == HIGH) {  
      delay(10); //

3.11. Ainda após soltar o segundo botão, atualiza-se o valores da mistura de cores no segundo Led RGB através da função analogWrite(), gerando a cor desejada. Em seguida, as cores do primeiro Led RGB é apagada. Por fim, repete-se o loop sucessivamente.

      analogWrite(Red, ValorR);
      analogWrite(Green, ValorG);
      analogWrite(Blue, ValorB);
      
      // Apagamos todas as cores
      analogWrite(R, 0);
      analogWrite(G, 0);
      analogWrite(B, 0);

Comentários