Início / Projetos Maker / Arduino Maker / M01 - Aprenda a fazer um sensor de toque de 4 teclas com Arduino

---

M01 - Aprenda a fazer um sensor de toque de 4 teclas com Arduino

Angelo Luis Ferreira | 11/05/2021 Acessos: 8.175

Objetivo

Neste tutorial vamos aprender a fazer um sensor capacitivo simples de 4 teclas com papel alumínio, papelão ou isopor, resistores de 1MΩ e o Arduino. O dispositivo que vamos criar irá atuar como como um sensor de pressão de 4 teclas, permitindo identificar o toque humano com respostas bastante satisfatórias. Desta forma, poderemos utilizar essas teclas para acionar um componente eletrônico qualquer. No nosso exemplo vamos acender leds diferentes e mostrar no display LCD qual ou quais teclas estão sendo pressionadas instantaneamente.

Nosso sensor contará com 4 teclas capacitivas, possibilitando um comando exclusivo para cada tecla ou até mesmo para uma sequência de teclas. Podemos utilizá-lo como um componente de comando para uma determinada ação, como por exemplo, ligar e desligar lâmpadas, acionar robôs, abrir portas eletrônicas, acionam motores elétricos, entre muitas outras.

Conceitos abordados no nosso projeto:

Sensor de toque capacitivo: Sensor que utiliza a alteração da capacitância do seu próprio circuito para determinar o toque humano em uma região sensível, pela qual denominamos no nosso projeto de tecla. Portanto, ao encostar o dedo na tecla, a capacitância que existe no material do sensor será alterada, possibilitando assim a uma fácil e rápida leitura. Para saber mais: Sensor Capacitivo : O que é e como funciona?

Capacitância: é a capacidade de um material de armazenar carga elétrica. No campo da eletrônica, este princípio é geralmente associado ao dispositivo armazenador de energia chamado capacitor. Se deseja se aprofundar mais no assunto, leia: Capacitores e Capacitância.

Aplicação

Para fins didáticos e projetos maker em geral.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		Mínimo de 400 pontos
Jumpers	Kit cabos ligação macho / macho	1
Led 5mm	Led 5mm	4		Use leds de qualquer cor (3 ou 5mm)
Resistor	Resistor	8		4 Resistores de 150Ω (ou superior) - led 4 Resistores de 1MΩ  - sensor
Display LCD (opcional)	Display LCD 16 X 2	1		LCD que utilize o controlador HD44780 (veja na descrição ou datasheet do componente) O display poderá ser de qualquer cor (fundo verde, azul ou vermelho)
Módulo I2C (opcional)	Módulo I2C com CI PCF8574	1		O módulo I2C poderá vir separado ou já soldado no display LCD (datasheet) Se você não possui um módulo I2C para display LCD, poderá adaptar o projeto para o display LCD sem o adaptador.
Placa de Isopor ou papelão	Placa de Isopor 100X50X10 mm	1		Pode ser utilizado placa de isopor ou papelão com qualquer espessura
Fita dupla face	Fita dupla face 20mm	1		Utilize fita dupla face de 19mm de largura ou superior com qualquer espessura
Folha de papel alumínio	20mm X 20mm	4		Cortar 4 quadrados de 20 X 20 mm
Arduino UNO	Arduino UNO R3	1		Você poderá utilizar uma placa Arduino UNO original ou similar

1. Entendendo como um sensor capacitivo caseiro funciona

1.1. Antes de montarmos o nosso sensor de 4 teclas, vamos entender um pouquinho mais como funciona um circuito de um sensor capacitivo de toque. Vamos também criar o nosso  programa para fazer com que o circuito do sensor funcione corretamente com o Arduino.

1.2. O circuito do sensor que iremos utilizar está demonstrado na ilustração abaixo, onde uma superfície metálica, que no nosso caso é um pedaço de papel alumínio (foil em inglês), se conecta com 2 pinos do Arduino separados por um resistor. O sensor, portanto, funciona medindo o tempo de carga do capacitor formado pelo papel alumínio e suas interações com o ambiente e o circuito, cuja capacitância verificada no receive pin varia com a aproximação de um contato humano ou de outros objetos metálicos.

1.3. Na prática, vamos montar o circuito da seguinte forma:

1.3.1. Para o led utilize resistor com 150Ω (ou superior) e para o sensor utilize resistor com 1MΩ.

 1.4. Abaixo, copie o programa para rodar o nosso sensor acima:

// Definição de pinos
const byte sendPin = 2;
const byte receivePin = 4;
const byte ledPin = 13;

// Variável para armazenar o valor lido no sensor
unsigned int valor;

// variável para leituras no monitor serial
unsigned long anterior = 0;

// Inicializa as variáveis e o modo dos pinos
void setup() {
  
  // Define o modo dos pinos
  pinMode(ledPin, OUTPUT);
  pinMode(sendPin, OUTPUT);
  pinMode(receivePin, INPUT);

  // Inicializa a comunicação serial em 9600 bits por segundo
  Serial.begin(9600);
}

// Executa as instruções em sequência e repete para sempre
void loop() {

  // Lê o valor do sensor
  valor = sensorCapacitivo(5);
  
  // Imprime o valor no monitor seial a cada 15 segundos
  imprimeMonitor();
  
  // Se o valor for maior que um dado limite (threshold) acende o led
  if (valor > 20) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

// Função para leitura do sensor
// Executa pelo número de amostras passado e retorna o valor lido
byte sensorCapacitivo(byte amostras) {

  unsigned long sum = 0;
  unsigned long tempo = 0;
  
  // Executa função 'amostras' vezes
  for (int i = 0; i < amostras; i++) {
    digitalWrite(sendPin, LOW);
    
    // Coloca o pino do sensor como saída para garantir nível baixo
    pinMode(receivePin, OUTPUT);
    digitalWrite(receivePin, LOW);
    delayMicroseconds(100); // Delay para estabilidade
    
    // Atera o modo do pino do sensor para entrada
    pinMode(receivePin, INPUT);
    
    // Inicia carga do sensor
    digitalWrite(sendPin, HIGH);
    
    // Aguarda pino atingir nível alto (aproximadamente 2.5V)
    while (digitalRead(receivePin) == LOW) {
      tempo++; // Acumula tempo para atingir nível alto
    }
        
    // Acumula valor para média
    sum += tempo;
  }
  
  // Realiza média e retorna valor lido
    return (unsigned int)sum/amostras;  
}

// imprime valor no monitor serial a cada 15 segundos
void imprimeMonitor() {
  unsigned long atual = millis();
  if (atual - anterior > 250) {
    Serial.println(valor);
    anterior = atual;
  }
}

1.5. Observe que o programa do sensor acima calcula o tempo para que o pino receivePin (pino 4 do Arduino) atinja o nível alto (HIGH). Esse tempo irá variar dependendo das condições que a superfície sensível, que no nosso caso é um pedaço de papel alumínio, interaja com o ambiente. Quando tocamos nesta superfície, variamos estas condições e mudamos o tempo para que o pino receivPin atinja o nível alto. Para isso, é preciso invertemos sempre o modo do pino receivePin:

1.5.1. Iniciamos no modo OUTPUT (saída do Arduino) para garantirmos um sinal de baixo nível (LOW) no pino 4 do Arduino (receivePin).

1.5.2. Depois alteramos de novo, agora no modo INPUT (entrada do Arduino). O sensor capacitivo (papel alumínio) vai enviando sinais para o Arduino até atingir o nível alto (HIGH), ou seja, até que (digitalRead(receivePin) != LOW). O tempo é calculado incrementando em 1 a variável tempo.

1.5.3. Para obtermos uma maior estabilidade do tempo calculado, determinamos a média em 5 amostras por vez. Essa média é retornada e atribuída a variável valor.

1.5.4. Depois a variável valor é comparada com 20, que é o limite (threshold) que utilizamos para identificar que houve o toque humano. Se maior que 20, o Arduino entende que houve o toque e executa uma ação, que no nosso exemplo é para acender o led.

Calibrando o nosso sensor capacitivo

 1.6. Lembramos que o valor que utilizamos como limite (threshold) no nosso exemplo pode não funcionar no seu projeto. Para isso, identifique no monitor serial as variações lidas no sensor livre e quando você toca nele. A partir das leituras, altere o valor do limite para o mais adequado e rode novamente o programa. Repita isso até você encontrar o melhor valor para funcionar o seu sensor.

1.6.1. O valor limite (threshold) deverá ser um pouco superior ao valor médio lido no sensor livre. No exemplo abaixo, poderíamos utilizar o valor limite entre 15 a 20. Valores limite muito altos podem deixar instável a identificação do toque humano.

1.7. Veja a seguir o vídeo do nosso sensor funcionando.

1.7.1. Observe que podemos utilizar qualquer tipo de superfície metálica funcional como região sensível do nosso sensor capacitivo. No vídeo abaixo utilizamos um pedaço de papel alumínio e um clip, todos conectados no pino 4 do Arduino.

2. Construindo o nosso sensor capacitivo de 4 teclas

2.1. Agora que já entendemos como deve funcionar um sensor capacitivo, podemos construir o nosso sensor de toque com 4 teclas. Veja a seguir o passo a passo para a montagem do sensor:

2.1.1. Corte uma placa de isopor ou papelão de qualquer espessura com 100mm de largura e 50mm de profundidade.

2.1.2. Corte 4 pedaços de papel alumínio com 20mm X 20mm (quadrado).

2.1.3. Aplique a fita dupla face de 20mm no sentido longitudinal da placa de isopor, de forma que fique centralizada. Veja a figura abaixo:

2.1.4. Aplique os pedaços de papel alumínio sobre a fita dupla face, deixando um espaço livre de aproximadamente 4mm entre eles e nas bordas.

ATENÇÃO: Ao aplicar os pedaços de papel alumínio, fixe os terminais dos jumpers abaixo deles. Veja a imagem na imagem a seguir:

2.1.5. Finalmente, aplique fita crepe para fixar os cabos. Isto é muito importante para evitar que o papel alumínio se rompa.

3. Montagem do Circuito

3.1. 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 energia elétrica enquanto você monta o circuito.

4. Atenção

4.1. Lembre-se que o LED tem polaridade: O terminal maior tem polaridade positiva e o lado do chanfro tem polaridade negativa.

4.2. Determinamos o valor do resistor através da tabela prática: Tabela prática de utilização de leds 3mm e 5mm. Entretanto, o mais correto é sempre verificar o datasheet do fabricante do LED para você ter os exatos valores de tensão e corrente do mesmo - leia Leds ligados em série e em paralelo.

4.2.1. Valores mínimos utilizados para nossos projetos: LEDs difusos ou de alto brilho: Vermelho, Laranja e Amarelo: 150 Ω | Led Verde e Azul: 100 Ω

4.3. A utilização do display LCD é opcional. O projeto poderá ser realizado apenas acendendo os leds ao clicar nas teclas do sensor capacitivo. Agora, se desejar utilizar o display, siga as orientações abaixo:

4.3.1. Caso você ainda não tenha instalado a biblioteca  LiquidCrystal_I2C responsável pelo funcionamento do display LCD, acesse o Projeto 48 - Como controlar um display LCD com o módulo I2C. Nele terá mais informações sobre a utilização do display LCD com o módulo I2C.

 4.3.2. Se você não tiver um módulo I2C, poderá adequar o projeto para o display LCD sem o adaptador. Veja como montar o display no projeto Projeto 38 - Controlando um display LCD (instalação e comandos básicos).

4.4. A montagem do sensor é bem simples. Temos um jumper ligando o pino 2 (saída) do Arduino. Entre o pino 2 (saída) e os pinos dos sensores (teclas) adicionamos os resistores de 1MΩ. Desta forma, ao enviarmos um sinal HIGH pelo pino 2, o Arduino poderá medir o tempo para que os pinos dos sensores passem de LOW para HIGH. Comparando as diferenças, pode-se determinar se houve ou não o contato humano.

4.4.1. Observe que utilizamos os pinos 4, 5, 6 e 7 para os sensores, ou melhor, para a teclas do nosso sensor capacitivo.

4.5. Veja a imagem abaixo que mostra a montagem completa do circuito.

Código do Projeto (Sketch)

Faça o dowload e abra o arquivo mk001.ino no IDE do Arduino:  DOWNLOAD - mk001.ino

Se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    Maker 001 - Construindo sensor capacitivo de 4 teclas - Arduino
*    Autor: Angelo Luis Ferreira
*    19/05/2021
*    http://squids.com.br/arduino
*
*******************************************************************************/
#include //Carrega a biblioteca lcd com I2C

// definição de pinos
const byte sendPin = 2; // pino saída do Arduino (carga)
const byte sensor[] = {4,5,6,7}; // pinos do sensor 4 teclas
const byte ledPin[] = {8, 9, 10, 11}; // pinos dos leds

// declarações de constantes e variáveis
/******************************************************************************* */
// dados dos sensores (ou teclas)
const byte amostras = 5; // default 5
const byte sensorAmount = 4; // quantidade de sensores (ou teclas)
/******************************************************************************* */

// variável para armazenar os valores lidos nos sensores
int valor[sensorAmount];

// constante que indica limite para ação do sensor
const byte threshold=13;

// variável para leituras no monitor serial
unsigned long anterior = 0;

//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);

// setup de inicialização
void setup() {
  // define modo dos pinos
  pinMode(sendPin, OUTPUT); // 
  for (byte i = 0; i threshold ? digitalWrite(ledPin[0],HIGH) : digitalWrite(ledPin[0],LOW);
    valor[1] > threshold ? digitalWrite(ledPin[1],HIGH) : digitalWrite(ledPin[1],LOW);
    valor[2] > threshold ? digitalWrite(ledPin[2],HIGH) : digitalWrite(ledPin[2],LOW);
    valor[3] > threshold ? digitalWrite(ledPin[3],HIGH) : digitalWrite(ledPin[3],LOW);
}

// mostra tecla no display LCD
void mostraDisplay(){
  lcd.setCursor(0,0); // Define o cursor na posição de início
  lcd.print("Teclas digitadas");
  lcd.setCursor(0,1);
  valor[0] > threshold ? lcd.print("01") : lcd.print("--");
  lcd.setCursor(5,1);
  valor[1] > threshold ? lcd.print("02") : lcd.print("--");
  lcd.setCursor(9,1);
  valor[2] > threshold ? lcd.print("03") : lcd.print("--");
  lcd.setCursor(13,1);
  valor[3] > threshold ? lcd.print("04") : lcd.print("--");  
}

// imprime valor no monitor serial a cada 15 segundos (calibragem)
void imprimeMonitor() {
  unsigned long atual = millis();
  if (atual - anterior > 250) {
    Serial.print("Tecla1 = ");
    Serial.print(valor[0]);
    Serial.print(" | Tecla2 = ");
    Serial.print(valor[1]);
    Serial.print(" | Tecla3 = ");
    Serial.print(valor[2]);
    Serial.print(" | Tecla4 = ");
    Serial.println(valor[3]);
    anterior = atual;
  }
}

/*******************************************************************************
*
*    Rotina para rodar sensores capacitivos maker
*    sensorAmount = sensores = nº de sensores ou de teclas
*    amostras = número de amostras no cáluclo da média dos valores lidos
*
*******************************************************************************/
void  sensorCapacitivo(byte sensores) {
  for (byte i=0; i

Vídeo

Como o projeto deve funcionar

1. Após rodar o programa, toque em qualquer tecla (1,2,3 ou 4) para acender os leds, conforme a tabela abaixo:

1.1. O led permanecerá aceso enquanto o sensor (tecla) estiver pressionada. Ao retirar o dedo do sensor (tecla), o led deverá se apagar.

2. Se você utilizou o display LCD poderá visualizar qual tecla foi tocada.

3. Você poderá pressionar mais de um sensor (tecla) simultaneamente, fazendo com que os respectivos leds acendam simultaneamente também.

Calibrando o sensor capacitivo de 4 teclas

Como já mencionamos antes, o valor que utilizamos como limite (threshold) no nosso exemplo pode não funcionar no seu projeto. Para isso, identifique no monitor serial as variações lidas nos sensores (teclas) livres e quando você toca nele. A partir das leituras, altere o valor do limite para o mais adequado e rode novamente o programa. Repita isso até você encontrar o melhor valor para funcionar o seu sensor.

DICA: O valor limite (threshold) deverá ser um pouco superior ao valor médio lido no sensor livre. Observe que os valores lidos variam de tecla para tecla, pois dependem da forma que foram montados, tamanho do papel alumínio, etc. No nosso exemplo, tomamos como base a maior leitura, que é 9 (tecla 4). Portanto, adotamos 13 com valor limite (threshold).

O valor de limite (threshold) é muito importante neste projeto, pois se mal dimensionado o led poderá ficar piscando enquanto tocamos no sensor, ou então, acender 2 ou mais leds simultaneamente enquanto tocamos em apenas uma tecla.

Desafios

Com base neste projeto, resolva o seguinte desafio: Desafio 87

Comentários