Acendendo led RGB por meio do pino “Touch” do ESP-32

No último post, exploramos o fascinante mundo dos pinos touch do ESP-32, aprendendo a acionar um LED simples com o toque de um dedo. Agora, vamos expandir essa ideia e mergulhar mais fundo no potencial desses pinos. Neste tutorial, vamos elevar nossos projetos a um novo patamar de interatividade e cor, aprendendo a controlar as cores de um LED RGB usando os pinos touch do ESP-32. Prepare-se.

MATERIAIS UTILIZADOS:

Todos os itens vocês encontram na WJ Componentes.

Como no post anterior, iremos utilizar no nosso projeto o software do Arduino.ide para programarmos o ESP. Se você ainda não instalou a placa ESP ao seu Arduino.ide basta clicar abaixo para voltar no post anterior que tem as dicas de instalação.

LED RGB

Um led RGB é um LED que possui três cores, sendo elas: vermelho, verde e azul, por isso seu nome, R (red), G (green) e B (blue). Essas cores podem acender uma por uma ou pode ser feito uma mistura de cores, acendendo duas cores ou as três ao mesmo tempo.

Existem dois tipos de Led RGB, os de ânodo comum e os de cátodo comum, no projeto, está sendo utilizado o led de cátodo comum, por isso ligamos ele ao GND do nosso ESP-32.

MONTAGEM DO PROJETO

Pinos utilizados:

→ D5 – GPIO5

→ D18 – GPIO18

→ D19 – GPIO19

→ D15 – Pino Touch

O pino touch está conectado apenas a um jumper, para assim podermos tocá-lo.

CÓDIGO FONTE

const byte vermelho = 5; //GPIO5
const byte verde = 18; //GPIO18
const byte azul = 19; //GPIO19

int touch;
char flag = 0; //Realiza a contagem

void setup() 
 {
  	Serial.begin(9600); 
  	pinMode(vermelho, OUTPUT);
 	pinMode(verde, OUTPUT);
 	pinMode(azul, OUTPUT);
 }


void loop() 
 {
 	 touch = touchRead (15); //Realiza a leitura do pino touch
  	 Serial.println (touch); //Mostra o valor serial do pino touch - Valor:15
  
  if(touch<=15 && flag==0)
   {
    	digitalWrite (vermelho, HIGH); 
    	digitalWrite (verde, LOW);
    	digitalWrite (azul, LOW);
    	delay(200);
	//cor: vermelho
    	flag=1;
   }
  else if(touch<=15 && flag==1)
   {
    	digitalWrite (vermelho, LOW);
    	digitalWrite (verde, HIGH);
    	digitalWrite (azul, LOW);
   	delay(200);
	//cor: verde
   	 flag=2;
   }
  else if(touch<=15 && flag==2)
   {
    	digitalWrite (vermelho, LOW);
    	digitalWrite (verde, LOW);
    	digitalWrite (azul, HIGH);
   	 delay(200);
	//cor: azul

   	 flag=3;
   }
  else if(touch<=15 && flag==3)
   {
     	digitalWrite (vermelho, HIGH);
    	digitalWrite (verde, HIGH);
    	digitalWrite (azul, LOW);
    	delay(200);
	//cor: amarelo
   	flag=4;
   }
  else if(touch<=15 && flag==4)
   {
    	digitalWrite (vermelho, LOW);
    	digitalWrite (verde, HIGH);
   	digitalWrite (azul, HIGH);
    	delay(200);
//cor: azul ciano
    	flag=5;
   }
  else if(touch<=15 && flag==5)
   {
    	digitalWrite (vermelho, HIGH);
    	digitalWrite (verde, HIGH);
    	digitalWrite (azul, HIGH);
    	delay(200);
	//cor: rosa
    	flag=6;
   }
  else
  {
     	digitalWrite (vermelho, LOW); //desligando leds
    	digitalWrite (verde, LOW);
    	digitalWrite (azul, LOW);
    	flag=0; //zerando a flag
   }
 }

Olhando o código mais de perto:

Declarando constantes e variáveis:

const byte vermelho = 5; //GPIO5
const byte verde = 18; //GPIO18
const byte azul = 19; //GPIO19

int touch;
char flag = 0; //Realiza a contagem

Este trecho de código inicializa a configuração dos Pinos. Ele atribui os pinos 5, 18 e 19 do ESP-32 as cores vermelho, verde e azul, respectivamente, e estabelece duas variáveis principais: touch para ler o valor do pino touch e flag como um contador iniciado em zero, que será usado para alternar entre as cores do LED RGB.

Funções setup:

void setup() 
 {
  	Serial.begin(9600); 
  	pinMode(vermelho, OUTPUT);
 	pinMode(verde, OUTPUT);
 	pinMode(azul, OUTPUT);
 }

Neste trecho de código da função setup(), são estabelecidas as configurações iniciais para o projeto. Inicializa-se a comunicação serial com uma taxa de transmissão de 9600 bits por segundo para monitoramento de dados, e configura-se os pinos do ESP-32 conectados ao LEDs como saídas.

Função loop

void loop() 
 {
 	 touch = touchRead (15); //Realiza a leitura do pino touch
  	 Serial.println (touch); //Mostra o valor serial do pino touch - Valor:15
  
  if(touch<=15 && flag==0)
   {
    	digitalWrite (vermelho, HIGH); 
    	digitalWrite (verde, LOW);
    	digitalWrite (azul, LOW);
    	delay(200);
	//cor: vermelho
    	flag=1;
   }
  else if(touch<=15 && flag==1)
   {
    	digitalWrite (vermelho, LOW);
    	digitalWrite (verde, HIGH);
    	digitalWrite (azul, LOW);
   	delay(200);
	//cor: verde
   	 flag=2;
   }
  else if(touch<=15 && flag==2)
   {
    	digitalWrite (vermelho, LOW);
    	digitalWrite (verde, LOW);
    	digitalWrite (azul, HIGH);
   	 delay(200);
	//cor: azul

   	 flag=3;
   }
  else if(touch<=15 && flag==3)
   {
     	digitalWrite (vermelho, HIGH);
    	digitalWrite (verde, HIGH);
    	digitalWrite (azul, LOW);
    	delay(200);
	//cor: amarelo
   	flag=4;
   }
  else if(touch<=15 && flag==4)
   {
    	digitalWrite (vermelho, LOW);
    	digitalWrite (verde, HIGH);
   	digitalWrite (azul, HIGH);
    	delay(200);
//cor: azul ciano
    	flag=5;
   }
  else if(touch<=15 && flag==5)
   {
    	digitalWrite (vermelho, HIGH);
    	digitalWrite (verde, HIGH);
    	digitalWrite (azul, HIGH);
    	delay(200);
	//cor: rosa
    	flag=6;
   }
  else
  {
     	digitalWrite (vermelho, LOW); //desligando leds
    	digitalWrite (verde, LOW);
    	digitalWrite (azul, LOW);
    	flag=0; //zerando a flag
   }
 }

No trecho de código da função loop(), o programa lê continuamente o valor do pino touch (pino 15) do ESP-32 e exibe este valor no monitor serial. A leitura do pino touch é utilizada para determinar se um toque foi detectado (valor menor ou igual a 15). Dependendo do estado atual da variável flag, que serve como contador, o programa controla as cores do LED RGB. Inicialmente, se flag estiver em 0 e um toque for detectado, o LED vermelho é aceso (e os outros apagados), e a flag é incrementada para 1.

Nos passos subsequentes, a cada novo toque detectado, o programa passa por uma série de condições else if para alternar as cores do LED RGB. Quando flag é 1, o LED verde é aceso, para flag igual a 2, o LED azul, e assim por diante, passando pelas cores amarelo, azul ciano e rosa, cada uma acionada em diferentes estados da flag (3, 4 e 5, respectivamente). Após exibir cada cor, há um atraso de 200 milissegundos e a flag é incrementada para mudar para a próxima cor na sequência.

Finalmente, se todas as cores forem exibidas (quando flag atinge 6) ou se nenhum toque for detectado, o programa desliga todos os LEDs e reinicia a flag para 0, preparando o sistema para começar o ciclo de cores novamente no próximo toque. Este loop cria um efeito de mudança de cores no LED RGB, controlado pela interação do usuário com o pino touch.

Neste tutorial, avançamos além do básico, explorando a capacidade dos pinos touch do ESP-32 para criar um projeto vibrante e colorido com um LED RGB. Demonstramos como o toque pode não apenas acionar um LED, mas também controlar uma variedade de cores, proporcionando uma experiência interativa e educativa. Esperamos que este guia tenha sido um passo estimulante na sua jornada de exploração com o ESP-32, abrindo caminho para mais inovações e criatividade em seus futuros empreendimentos eletrônicos.