Assista no YouTube

Introdução ao Módulo de Toque Capacitivo TTP223 para Arduino

Neste tutorial, exploraremos o módulo de toque capacitivo TTP223 e como ele pode ser integrado a um Arduino para criar um interruptor sensível ao toque. O TTP223 é um módulo simples e eficaz que permite ligar ou desligar dispositivos como relés ou luzes com apenas um toque. Este projeto demonstrará como conectar o módulo e escrever um programa básico em Arduino para ler entradas de toque e controlar um dispositivo de saída.O código e a fiação para este projeto serão explicados em detalhes para que você possa replicar a configuração facilmente. Para os aprendizes visuais, recomendo assistir ao vídeo tutorial associado para esclarecimentos sobre a configuração e o processo de codificação (no vídeo às 03:15).

Hardware Explicado

O módulo de toque capacitivo TTP223 é um dispositivo compacto e fácil de usar que detecta entradas de toque através de sensoriamento capacitivo. Ele possui um único pino de saída que fica alto quando o toque é detectado, tornando-o ideal para aplicações onde você deseja controlar eletrônicos com um simples toque. O módulo opera com uma tensão de alimentação de 2,0 a 5,5 volts, o que o torna compatível com a maioria das placas Arduino. O módulo geralmente tem alguns pinos: VCC para alimentação, GND para terra e o pino de saída que envia um sinal quando um toque é detectado. Este pino de saída pode ser conectado a um pino de entrada digital na Arduino, permitindo que você leia facilmente o status do toque. O módulo TTP223 é especialmente útil em projetos onde um interruptor físico não é desejável.

Detalhes da Ficha Técnica

• Assegure um fornecimento de tensão adequado (2,0 - 5,5 V) para evitar danos ao módulo.
• O pino de saída pode ser conectado a qualquer pino digital no Arduino.
• Conecte o pino GND ao terra do Arduino.
• Mantenha o módulo afastado de fontes de ruído elétrico para evitar disparos falsos.
• Use resistores de pull-up se necessário para leituras estáveis.

Instruções de Fiação

Para conectar o módulo de toque capacitivo TTP223 ao seu Arduino, comece conectando o pino VCC do módulo ao pino 5V do Arduino. Em seguida, conecte o pino GND do módulo a um dos pinos GND do Arduino. O pino de saída do TTP223, que envia o sinal de toque, deve ser conectado a um pino digital do Arduino, por exemplo, o pino 2. Se você estiver usando um relé com o módulo de toque, conecte o pino de controle do relé a outro pino digital, como o pino 8. Certifique-se de que a fonte de alimentação do relé esteja conectada corretamente, de acordo com suas especificações. Se você estiver usando vários módulos de toque, pode conectar pinos de saída adicionais a outros pinos digitais do Arduino e repetir o processo de fiação conforme necessário.

Exemplos de Código e Passo a Passo

O seguinte trecho de código inicializa os pinos e configura a comunicação serial. A variáveltouchPinestá conectado à saída do módulo TTP223, enquantorelayPincontrola o relé.

int touchPin = 2; // connect output from TTP223 to this
int relayPin = 8; // Connected to relay

void setup() {
  Serial.begin(9600);
  pinMode(touchPin, INPUT); 
  pinMode(relayPin, OUTPUT);
}

Este código inicializa o módulo de toque e o pino do relé, preparando-os para uso na função de loop.Serial.begin(9600)o comando define a taxa de transmissão para comunicação serial, permitindo que você monitore o status do toque através do Monitor Serial. No loop, o programa verifica o status da entrada de toque e alterna o relé de acordo. Se o toque for detectado, ele imprime "Tocado" no Monitor Serial e liga o relé.

void loop() {
  val = digitalRead(touchPin); 
  if(val == 1) {
    Serial.println("Touched");
    digitalWrite(relayPin, LOW); // turn relay ON
  }
  delay(100);
}

Este trecho demonstra como a entrada por toque é lida e processada.digitalRead(touchPin)a função verifica se o toque foi detectado. Se foi, o relé é ativado configurandorelayPinpara BAIXO.

Demonstração / O que Esperar

Quando você executar o código e tocar no módulo TTP223, deverá ver "Tocado" impresso no Monitor Serial, indicando que o toque foi detectado. O relé conectado arelayPintambém será ativado, permitindo que você controle qualquer dispositivo conectado a ele. Fique atento ao efeito de debounce; se você tocar no sensor muito rapidamente, pode registrar toques múltiplos. Para uma configuração mais complexa, você pode adicionar vários módulos TTP223 para controlar dispositivos diferentes. Cada módulo pode ser conectado a um pino de entrada separado e gerenciado na mesma função de loop, permitindo um controle versátil de múltiplas saídas (no vídeo às 10:45).

Marcas de Tempo do Vídeo

• 00:00- Introdução ao Módulo TTP223
• 03:15- Instruções de Fiação
• 05:30- Demonstração de Código
• 10:45- Demonstração do Módulo de Toque

/*
 * Este é o código Arduino para um módulo de toque TTP223. Ao tocar no módulo, o pino 8 envia um sinal para ligar o relé ou interruptor.
 * 
 * Escrito por Ahmad S. para Robojax.com
 * Data: 1 de abril de 2017, em Ajax, Ontário, Canadá
 * Permissão concedida para compartilhar este código, desde que esta
 * observação seja mantida com o código.
 * Isenção de responsabilidade: Este código é "COMO ESTÁ" e para fins educacionais apenas.
 */
int touchPin = 2; // conecte a saída do TTP223 a isto
int val = 0;
int relayPin = 8; // Conectado ao relé

void setup() {
 Serial.begin(9600);
 pinMode(touchPin, INPUT);
  pinMode(relayPin, OUTPUT);

}

void loop() {
  digitalWrite(relayPin, HIGH);
  val = digitalRead(touchPin);
  if(val ==1){
  Serial.println("Touched");
  digitalWrite(relayPin, LOW);
  }
  delay(100);
  Serial.println();
}

/*
 * This is the Arduino code for a TTP223 touch module switch.
 * By touching the module, the pin 8 is sending a signal to turn the relay or switch ON.
 * 
 * Written by Ahmad S. for Robojax.com 
 * Date: April 1, 2017, in Ajax, Ontario, Canada
 * Permission granted to share this code, given that this
 * note is kept with the code.
 * Disclaimer: This code is "AS IS" and for educational purposes only.
 * 
 */

 // 1st channel
int touchPin1 = 2;// connect output from TTP223 to this
int val = 0; 
int relayPin = 8;// Connected to relay

 // 2nd channel
int touchPin2 = 3;// connect output from TTP223 to this
int val2 = 0; 
int relayPin2 = 9;// Connected to relay

void setup() {
 Serial.begin(9600);
 pinMode(touchPin, INPUT); // input from touch
 pinMode(relayPin, OUTPUT);// output to relay
 
  pinMode(touchPin2, INPUT); // input from touch (2)
 pinMode(relayPin2, OUTPUT);// output to relay (2)

}

void loop() {
 // start of channel 1 code 
  digitalWrite(relayPin, HIGH);// set the relay to HIGH (if your relay is low-trigger. If not, remove this line)
  val = digitalRead(touchPin); // read channel 1 touch module value
  if(val ==1){
  Serial.println("Channel 1 Touched");
  digitalWrite(relayPin, LOW);// turn relay (of switch) 1 ON
  }
  delay(100);
  Serial.println();
   // end of channel 1 code 
  
 // start of channel 2 code   
  digitalWrite(relayPin2, HIGH);// set the relay to HIGH (if your relay is low-trigger. If not, remove this line)
  val2 = digitalRead(touchPin2); // read channel 2 touch module value
  if(val2 ==1){
  Serial.println("Channel 2 Touched");
  digitalWrite(relayPin2, LOW);// turn relay (of switch) 2 ON
  }
  delay(100);
  Serial.println();
  // end of channel 2 code 
}