Touch capacitivo - ESP32

Touch capacitivo com ESP32

Nesse tutorial aprenderemos a usar sensores de touch capacitivo em nossos projetos com o ESP32, que tem suporte nativo a este recurso incrível. Em vários projetos, precisamos adicionar botões ou algum tipo de sensor para toque (pressão); o mais usado por ser barato e fácil, é o Push Button, porem, alem de dar um aspecto "velho" ao projeto, pode gerar problemas mais frequentes como por exemplo Bounce. Para contornar estes problemas, usaremos o Touch capacitivo, que é o mesmo do seu celular moderno (Smartphone), ao mínimo toque, é detectado e executado tal tarefa.

Mãos à obra - Implementando um touch capacitivo no ESP32

Componentes necessários

• 1x ESP32 (Usaremos o NodeMCU32).
• 1x Jumper.

Montando o projeto

A montagem é simples, apenas sendo necessário ligar o jumper ao GPIO4, ficara parecido com o nosso:

Programando

long lastms;//Váriavel para guardar o ultimo toque.

void setup()
{
    Serial.begin(9600);//Inicia a comunicação Serial para visualização dos valores do Touch.
    pinMode(LED_BUILTIN, OUTPUT);//Define o LED OnBoard como saída
    touchAttachInterrupt(4, led, 20);//Atribui uma função (led) quando for detectado um valor menor de (20) ao pino (4).
    lastms = 0;//Inicializa a váriavel em 0.

    //Para chegar a este valor usado (20), é necessário apenas ver os valores que aparece no Serial monitor,
    //toque o fio e veja qual sera o novo valor. Ao tocar, a tendencia do valor é aproximar-se de 0.
}


void loop()
{
    Serial.println(touchRead(4));//Mostra o valor do touch no monitor.
    delay(100);
}

void led()//função que foi atribuida para o evento do touch.
{
    if (millis() - lastms > 150)//Verifica se o ultimo toque faz mais de 150mS
    {
        digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));//Inverte o estado do led.
        lastms = millis();//Salva o ultimo tempo em que foi tocado.
    }
}

Colocando para funcionar

Após o upload, podemos tocar na ponta do fio que perceberemos o LED invertendo seu estado. Se você manter tocado, verá que o LED ficará piscando, no intervalo de 150mS. Veja como ficou o nosso neste video:

Entendendo a fundo

Software

- Função de Interrupção touch -  touchAttachInterrupt()

touchAttachInterrupt(4, led, 20);

Esta função, atribui uma rotina de interrupção para quando for detectado um valor abaixo do definido para o pino. Neste caso, quando o ESP32 detectar um valor abaixo de 20 no pino 4, irá chamar a função led(). A nossa função led() apenas inverte o estado do led com um intervalo de tempo para que não pisque muito rápido.

Lembre-se que a função interrupção é como uma chamada telefônica. O controlador para tudo que está fazendo para atende-la.

- Função led()

A função led() é chamada através da interrupção no pino 4.

void led()//função que foi atribuida para o evento do touch.
{
    if (millis() - lastms > 150)//Verifica se o ultimo toque faz mais de 150mS
    {
        digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));//Inverte o estado do led.
        lastms = millis();//Salva o ultimo tempo em que foi tocado.
    }
}

Sabemos que o processamento de um microcontrolador é muito mais rápido do que podemos interagir. Quando acionamos o touch, o ESP chamará milhares de vezes a interrupção que foi atribuída a função led(). Por isso é importante implementarmos uma maneira de fazer com que a iteração do LED ocorra apenas após um determinado tempo

Uma forma de fazer isso é usar um contador de tempo com o auxilio da função millis(), uma variável auxiliar e um IF.

1.  A função millis() conta o tempo em milissegundos desde que o ESP32 foi ligado.
2.  A variável auxiliar armazena o valor do millis() da ultima vez que houve alteração do estado do LED
3. A condicional IF compara o tempo atual do millis() com o tempo armazenado na variável auxiliar, se for maior que o tempo escolhido, ele entra na rotina do IF, altera o estado do LED e novamente armazena o novo tempo de millis().

Ou seja: Essa rotina subtrai o tempo atual com o anterior, e se for maior que 150mS, irá inverter o LED e salvar o novo tempo. Dessa forma, só invertemos o estado do LED depois que passou 150ms da ultima mudança de estado.

Veja que se você ficar com o dedo pressionado o tempo todo, teremos o LED ligando e desligando de 150ms em 150ms.

Você poderia usar delay() também, mas o problema é que o delay mantem o microcontrolador parado contando o tempo enquanto esse tipo de rotina implementada permite que o controlador continue com a execução das outras tarefas.

Por isso essa função condicional é bastante usada para atribuir intervalos entre as ações, uma alternativa saudável para o delay().

- Função de leitura do touch

touchRead(4)

Esta função, retorna o valor do pino (Threshold). Este valor pode váriar de acordo do lugar de ESP32. Em nossos testes, ao plugar o ESP32 na Protoboard, o valor foi de 84 para 60. Os valores quando não estamos tocando ficaram em média de 60, e ao tocar, aproximou-se de 0.

Por isso definimos 20 na função anterior, pois ao tocar, o valor aproxima-se de 0, então colocando 20, teremos certeza que foi um toque e chamamos a função para inverter o LED.

- Uma outra forma de implementar o touch

Veja que você poderia implementar a leitura no seu programa sem usar a interrupção. Usando um IF na função loop por exemplo.

void loop()
{
    Serial.println(touchRead(4));//Mostra o valor do touch no monitor.
    delay(100);

    if(touchRead(4) < 20) //verifica se o valor lido é menor que 20
    {
      if (millis() - lastms > 150)//Verifica se o ultimo toque faz mais de 150mS
        {
          digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));//Inverte o estado do led.
          lastms = millis();//Salva o ultimo tempo em que foi tocado.
        }
    }
}

O programa todo ficaria assim:

long lastms;//Váriavel para guardar o ultimo toque.

void setup()
{
    Serial.begin(9600);//Inicia a comunicação Serial para visualização dos valores do Touch.
    pinMode(LED_BUILTIN, OUTPUT);//Define o LED OnBoard como saída
    lastms = 0;
}

void loop()
{
    Serial.println(touchRead(4));//Mostra o valor do touch no monitor.
    delay(100);

    if(touchRead(4) < 20) //verifica se o valor lido é menor que 20
    {
      if (millis() - lastms > 150)//Verifica se o ultimo toque faz mais de 150mS
        {
          digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));//Inverte o estado do led.
          lastms = millis();//Salva o ultimo tempo em que foi tocado.
        }
    }
}

Hardware

Antes do touch capacitivo entrar em uso continuo em celulares, o touch era resistivo, sendo necessário tocar a tela com certa pressão para que fosse detectado o toque. Já o touch capacitivo, é mais sensível e permitindo um manuseio mais fácil da tela. Veja a imagem representando o touch capacitivo:

Quando você toca no fio ou tela, há uma troca de elétrons entre as partes, e com isso, permite o nosso sistema detecta-lo.

Desafio

O desafio desta vez, é que você monte um teclado matricial com o touch do ESP32 para digitar uma senha por exemplo.

Fechamento

Hoje você aprendeu a usar esta íncrivel função que ESP32 nos dá. Com ela, é possível deixar nosso projetos extremamente modernos e bonitos. Alem disto, você também pode usa-lo em conjunto com o ULP para acordar o ESP32 de Deep-Sleep, viabilizando projetos portáteis e vestíveis. Se houver alguma sugestão, dúvida ou crítica, comente abaixo que iremos te responder.

by José Morais