Início / Projetos Arduino / Projetos Squids / Básico / Projeto 26 - Criando cores com Led RGB com 1 potenciômetro (simplificado)

---

Projeto 26 - Criando cores com Led RGB com 1 potenciômetro (simplificado)

Angelo Luis Ferreira | 25/09/2017 Acessos: 19.638

Objetivo

Criar um circuito para gerar cores em um LED RGB através de um potenciômetro e botões (push buttons) seletores. Neste projeto teremos três botões para selecionar as cores vermelho, verde ou azul em um Led RGB, que terão os seus brilhos ajustados por um potenciômetro. Quando nenhum botão é acionado, o Led RGB exibe a combinação de cores e brilhos definidos anteriormente pelo potenciômetro.

Obs.: Fazendo o controle do brilho de cada uma das cores de um Led RGB podemos obter 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	1		Você poderá utilizar um LED RGB ânodo ou cátodo (difuso ou de alto brilho) Você poderá substituir o Led RGB por 3 Leds 5mm comuns, sendo 1 vermelho, 1 verde e um azul (difuso ou de alto brilho)
Resistor	Resistor	6		1 Resistor de 150Ω   2 Resistores de 100Ω   3 Resistores de 10KΩ (push button) Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado ou utilize resistores com valores maiores que os indicados.
Push Button	Push Button 6x6x5m	3		Utilizar resistores de 10KΩ (ligação pull-down)
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 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. Monte os botões (push buttons) com resistores pull-down. Desta forma, quando o botão estiver pressionado, o Arduino retornará "high" ou '1'. Leia mais em Resistores Pull-down e pull-up.

Obs.: Esses resistores (pull-up e pull-down) garantem nível lógico estável quando por exemplo uma tecla não está pressionada. Geralmente utiliza-se um resistor de 10K para esse propósito. A seguir é exibida a ligação desses resistores no circuito para leitura de tecla:

7. 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á.

8. Veja 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 LED RGB no 5V (polo positivo do Arduino).

Obs 2: Se você não tiver um LED RGB, substitua-o por 3 leds comuns, sendo 1 vermelho, 1 verde e 1 azul.

Testando o circuito

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).

/*******************************************************************************
*
*    Projeto 23 – 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).

/*******************************************************************************
*
*    Projeto 23 – 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 programa, como no exemplo abaixo:

const int R = 6;
const int G = 3;
const int B = 5;

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 26 – Criando cores - LED RGB utilizando 1 potenciômetro (simplificado)
*                           (LED RGB Cátodo Comum)
*                   http://squids.com.br/arduino
*
*******************************************************************************/
 
// Define as conexões para cada cor do RGB
const int R = 3;
const int G = 5;
const int B = 6;

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

// Define as conexões dos botões seletores
const int botR = 13;
const int botG = 12;
const int botB = 11;

// Define a conexão do potenciômetro
const int pot = A0;

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

// Indica que os pinos são ENTRADA do Arduino
    pinMode(botR, INPUT);
    pinMode(botG, INPUT);
    pinMode(botB, INPUT);
    pinMode(pot, INPUT);
} 

void loop() 
{ 
   //Verifica se os botões seletores estão acionados     
   while (digitalRead(botR) == HIGH) // enquanto o botão R estiver acionado
   {
      ValorR = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,ValorR);
      analogWrite(G,0);
      analogWrite(B,0);
      // Chama a função para mostrar na tela
      monitorSerial();

   }
    while (digitalRead(botG) == HIGH) // enquanto o botão G estiver acionado 
   {
      ValorG = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,0);
      analogWrite(G,ValorG);
      analogWrite(B,0);
      // Chama a função para mostrar na tela
      monitorSerial();        
   }
    while (digitalRead(botB) == HIGH)// enquanto o botão G estiver acionado 
    {
      ValorB = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,0);
      analogWrite(G,0);
      analogWrite(B,ValorB); 
      // Chama a função para mostrar na tela
      monitorSerial();
    }
    
    // Atualiza o led RGB com a cor da mistura
        analogWrite(R, ValorR);
        analogWrite(G, ValorG);
        analogWrite(B, ValorB);
 }

void monitorSerial()
{
//mostra os valores no PC - Monitor Serial valor do potenciômetro
     Serial.print("R = ");
     Serial.print(ValorR);
     Serial.print(" | G= ");
     Serial.print(ValorG);
     Serial.print(" | B= ");
     Serial.println(ValorB);
     delay(50);
} 

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 26 – Criando cores - LED RGB utilizando 1 potenciômetro (simplificado)
*                           (LED RGB Ânodo Comum - Vcc)
*                   http://squids.com.br/arduino
*
*******************************************************************************/
 
// Define as conexões para cada cor do RGB
const int R = 3;
const int G = 5;
const int B = 6;

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

// Define as conexões dos botões seletores
const int botR = 13;
const int botG = 12;
const int botB = 11;

// Define a conexão do potenciômetro
const int pot = A0;

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

// Indica que os pinos são ENTRADA do Arduino
    pinMode(botR, INPUT);
    pinMode(botG, INPUT);
    pinMode(botB, INPUT);
    pinMode(pot, INPUT);
} 

void loop() 
{ 
   //Verifica se os botões seletores estão acionados     
   while (digitalRead(botR) == HIGH) // enquanto o botão R estiver acionado
   {
      ValorR = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,255-ValorR);
      analogWrite(G,255);
      analogWrite(B,255);
      // Chama a função para mostrar na tela
      monitorSerial();

   }
    while (digitalRead(botG) == HIGH) // enquanto o botão G estiver acionado 
   {
      ValorG = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,255);
      analogWrite(G,255-ValorG);
      analogWrite(B,255);
      // Chama a função para mostrar na tela
      monitorSerial();        
   }
    while (digitalRead(botB) == HIGH)// enquanto o botão G estiver acionado 
    {
      ValorB = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,255);
      analogWrite(G,255);
      analogWrite(B,255-ValorB); 
      // Chama a função para mostrar na tela
      monitorSerial();
    }
    
    // Atualiza o led RGB com a cor da mistura
        analogWrite(R, 255-ValorR);
        analogWrite(G, 255-ValorG);
        analogWrite(B, 255-ValorB);
 }

void monitorSerial()
{
//mostra os valores no PC - Monitor Serial valor do potenciômetro
     Serial.print("R = ");
     Serial.print(ValorR);
     Serial.print(" | G= ");
     Serial.print(ValorG);
     Serial.print(" | B= ");
     Serial.println(ValorB);
     delay(50);
} 

Vídeo

Como o projeto deve funcionar

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

2. Pressione o primeiro botão (mais a esquerda) e ajuste o brilho da cor vermelha 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.

5. Neste projeto teremos três botões para selecionar as cores vermelho, verde ou azul em um Led RGB, que terão os seus brilhos ajustados por um potenciômetro. Faça os ajustes também para as cores verde e azul.  Ajuste os brilhos se orientando pelo monitor serial:

6. Quando nenhum botão é acionado, o Led RGB exibe a combinação de cores e brilhos definidos anteriormente pelo potenciômetro.

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 = 3;
const int G = 5;
const int B = 6;

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

// Define as conexões dos botões seletores
const int botR = 13;
const int botG = 12;
const int botB = 11;

// Define a conexão do potenciômetro
const int pot = A0; 

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 às portas digitais 3, 5 e 6 do controlador Arduino (saídas utilizada como PWM).

1.3. Declaramos as variáveis globais ValorR, ValorG e ValorB com valores iguais a 255, 0 e 0 respectivamente.

1.4. Declaramos também as constantes tipo inteiro botR, botV e botB que se referem aos terminais do botões (push button) conectados às portas 13, 12 e 11 do Arduino.

1.5. Declaramos a constante pot que se refere à conexão do terminal do potenciômetro à porta analógica A0 do Arduino.

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

// Indica que os pinos são ENTRADA do Arduino
    pinMode(botR, INPUT);
    pinMode(botG, INPUT);
    pinMode(botB, INPUT);
    pinMode(pot, INPUT);
}  

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 3, 5 e 6 respectivamente.

2.3. Define-se as constantes botR, botV e botB como entradas do controlador Arduino (INPUT) conectados aos pinos 13, 12 e 11 respectivamente.

2.4. Define-se o valor constante pot como entrada do controlador do Arduino (INPUT) conectado ao pino analógico A0.

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

void loop() 
{ 
   //Verifica se os botões seletores estão acionados     
   while (digitalRead(botR) == HIGH) // enquanto o botão R estiver acionado
   {
      ValorR = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,ValorR);
      analogWrite(G,0);
      analogWrite(B,0);
      // Chama a função para mostrar na tela
      monitorSerial();

   }
    while (digitalRead(botG) == HIGH) // enquanto o botão G estiver acionado 
   {
      ValorG = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,0);
      analogWrite(G,ValorG);
      analogWrite(B,0);
      // Chama a função para mostrar na tela
      monitorSerial();        
   }
    while (digitalRead(botB) == HIGH)// enquanto o botão G estiver acionado 
    {
      ValorB = map(analogRead(pot),0,1023,0,255); 
      analogWrite(R,0);
      analogWrite(G,0);
      analogWrite(B,ValorB); 
      // Chama a função para mostrar na tela
      monitorSerial();
    }
    
    // Atualiza o led RGB com a cor da mistura
        analogWrite(R, ValorR);
        analogWrite(G, ValorG);
        analogWrite(B, ValorB);
 } 

3.1. Através do comando While e da função digitalRead, verificamos se algum botão botR, botG ou botB está acionado (lê o valor como HIGH).

3.2. Enquanto algum botão estiver acionado, a variável ValorR, ValorG ou ValorB, dependendo do botão acionado, armazena o valor lido no potenciômetro entre 0 e 1023, porém convertido em valores proporcionais entre 0 e 255. Isto acontece através da função map(analogRead(pot),0,1023,0,255);

Obs.: A função analogRead() 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 constante pot 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.

3.2.1. Depois, através da função analogWrite o Led RGB irá exibir a cor e brilho definida pela variável ValorR, ValorG ou ValorB. (Obs.: As cores diferentes da cor relacionada com o botão acionado, são definidas com 0, ou seja, ficam desabilitadas):

      analogWrite(R,ValorR);
      analogWrite(G,0);
      analogWrite(B,0);

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.2.2. Continuando o loop While, é chamada a função monitorSerial(); que criamos para exibir os valores das cores ajustados pelo potenciômetro.

3.2. Após soltarmos o botão (push button), o led RGB se atualizará exibindo a cor resultante.

4. Função monitorSerial(), criada para exibir os valores ajustados pelos botões seletores e o potenciômetro.

void monitorSerial()
{
//mostra os valores no PC - Monitor Serial valor do potenciômetro
     Serial.print("R = ");
     Serial.print(ValorR);
     Serial.print(" | G= ");
     Serial.print(ValorG);
     Serial.print(" | B= ");
     Serial.println(ValorB);
     delay(50);
} 

 4.1. 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.

Comentários