Básico - Projeto 25

Criando cores com Led RGB usando 1 potenciômetro

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 Resultado de imagem para protoboard 830v No mínimo utilizar protoboard com 830 pontos
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 - Calcular Resistor.
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 Cabos de ligação e 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).

Esquema LED RGB

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.

Resultado de imagem para rgb led pins

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:

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.

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 - sabia mais em protoboard.

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 está corretamente conectado, utilize o código abaixo:

/*******************************************************************************
*
*             Usando um LED RGB (TESTE)
*            http://squids.com.br/arduino
*
*******************************************************************************/
 
const int R = 9;
const int G = 10;
const int B = 11;

void setup(){
    pinMode(R, OUTPUT);
    pinMode(G, OUTPUT);
    pinMode(B, OUTPUT);
}
void loop(){
    digitalWrite(R, HIGH);
    digitalWrite(G, LOW);
    digitalWrite(B, LOW);
    delay(1000);
    digitalWrite(R, LOW);
    digitalWrite(G, HIGH);
    digitalWrite(B, LOW);
    delay(1000);
    digitalWrite(R, LOW);
    digitalWrite(G, LOW);
    digitalWrite(B, HIGH);
    delay(1000);
}

Observe que a cada segundo (1000ms) aparecerá as cores vermelho, azul e verde sucessivamente, nesta ordem. Se o LED RGB não acender, inverta a conexão do terminal maior (de 5V para GND ou vice-versa dependendo do tipo LED que esteja utilizando, ânodo comum ou cátodo comum).

Esquema LED RGB

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;

Resultado de imagem para rgb led pins

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)

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
*                   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);  
      
      } 
}

Vídeo

Como o projeto deve funcionar

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 (intensidade do 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

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:

Tipo Valores Válidos para Variáveis e Constantes
char letras e símbolos: 'a', 'b', 'H', '^', '*','1','0'
int de -32767 até 32767 (apenas números inteiros)
float de -3.4 x 1038 até +3.4 x 10+38 com até 6 dígitos de precisão (2 casas depois da vírgula)
double de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de precisão

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 210 = 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);   



Compartilhe:

Doações

Contribua pra manter o site online :)

Inscreva-se no canal Squids

Squids Arduino News

CB09 : Dimmer para leds com CI 555 sem Arduino Objetivo Criar um circuito gerador de pulsos modulados (PWM - Pulse Width Modulation) para alterar a intensidade do brilho de um led. Para este pro...

Como usar temporizadores no Arduino

Funções de temporização na programação com Arduino Objetivo Nesta dica vamos mostrar utilizar as diversas funções de temporização disponíveis na programação com Arduino. As funções de Temporizaç...

Intermediário - Projeto 11 Contador de acessos utilizando leds infravermelhos e Arduino Objetivo O objetivo deste projeto é criar um sistema de contagem de visitantes que entram e saem de uma s...

Básico - Projeto 94 Simulando um botão na tela do display OLED Objetivo O objetivo deste projeto é simular um botão de controle no display OLED. O botão servirá para controlar a iluminação de u...

Básico - Projeto 93 Criando um relógio analógico com Oled SSD1306 Objetivo O objetivo deste projeto é exibir no display OLED um relógio com estilo analógico, ou seja, com ponteiros. Utilizaremo...

Outros artigos

Mais: Circuitos básicos Dicas de Software Projetos Intermediários Projetos Básicos Desafios Jogos

Você está preparado?

Topo