Interruptor Touchscreen Caseiro

Não custa lembrar que em tópicos anteriores eu consegui decodificar controles remotos e também simular estes controles utilizando uma placa arduíno conectada ao meu notebook. 
Agora estou fazendo um interruptor. Você pode até perguntar:  Onde é que está a automatização residencial ? Eu te respondo que está em cada postagem publicada até agora. Eu quero automatizar meu apartamento atacando cada problema separadamente, aprendi muito isso desenvolvendo softwares. No final, quando eu unir todas essas experiências, terei material e "know-how" suficiente para a montagem definitiva dos três módulos responsáveis por essa automatização (Módulo Receptor, Módulo de Controle Secundário e Módulo de Controle Principal). Portanto, tudo o que eu publicar estará mirando o objetivo principal do projeto.

Agora falando sobre o interruptor...

O meu amigo +José Antonio Leal de Farias (Jalf), que também está implementando um projeto de automação residencial, havia me dado algumas dicas, uma delas foi o endereço de um blog, o Crepúsculo Tecnológico, que ensina como fazer um interruptor "touchscreen" em casa (simula uma tela touch).

A idéia central é baseada no condutividade elétrica do corpo humano. Utilizando a biblioteca CapSense, uma simples folha de alumínio se transforma em um dispositivo capaz de "sentir" o toque (ou aproximação) do seu dedo.

Como funciona o sensor (Fonte: Arduíno Playground)

Refletindo sobre o assunto, imaginei algumas vantagens:

1.Não precisaria esperar interruptor importado da China;
2.Agregaria mais conhecimento sobre tecnologias Arduíno;
3.Seria feito ao meu gosto (customizável);
4.Mais "inteligência" que o interruptor importado (falarei daqui a pouco);
5.Mais próximo da proposta de "faça você mesmo" (reduz custos);

Com base nessas informações, resolvi fazer uma versão modificada desse referido interruptor, reforçando que a versão original é mérito do Crepúsculo Tecnológico.

Primeira modificação: Fiz o interruptor com dois botões, com o objetivo de utilizar em uma área do apartamento onde precisarei acender/apagar duas lâmpadas.

Segunda modificação: Utilizei "módulo relé" ao invés de simplesmente "relé". O módulo relé já vem com os demais componentes montados em uma pequena placa (resistores, diodos, transistores, etc.) e continua sendo um componente muito barato (máximo U$ 4,00 um módulo com 2 canais).

Importante:  Nas postagens anteriores sempre chamei o "módulo relé" pelo nome "relé", mas na verdade eu sempre vou utilizar módulo relé em todo o projeto, com receptor RF embarcado ou não, com alimentação direta em 220V ou não, mas sempre módulos com o circuito já montado. Isso quer dizer que onde eu estiver falando "relé", leia-se "módulo relé".

Terceira modificação: Fiz os valores que indicam a sensibilidade dos interruptores serem lidos/gravados na EEPROM da placa arduíno, assim eles poderão ser calibrados no próprio tablet. A calibração será muito importante porque esses valores de sensibilidade mudam bastante à medida que modificamos variáveis como fonte de alimentação, tamanho do sensor, tamanho dos fios. Tudo o que eu não quero é ter que arrancar um interruptor da parede para modificar o código-fonte, simplesmente porque a placa não está "sentindo" o toque para ligar/desligar a lâmpada.

Inteligência Extra

Uma vantagem de fazer o próprio interruptor é que posso acrescentar mais componentes, dando a ele mais "inteligência", como por exemplo, sempre que alguém ligá-lo utilizando o método tradicional (apertando o botão com o dedo), pode ser enviado um sinal para que o Módulo de Controle Principal tome conhecimento, com isso, eu poderei verificar se esqueci alguma lâmpada ligada simplesmente olhando para a interface da aplicação no tablet.
Quer outro exemplo ? Eu poderia utilizar no tablet uma funcionalidade de desligamento automático de todas as lâmpadas em determinado horário ou condições.
Quero implementar essa capacidade extra no momento oportuno, por enquanto estou deixando somente com o básico, o que já é um grande feito.


1.MONTAGEM DOS SENSORES

Agora sim, colocando as mãos na massa, vou relatar toda a experiência que tive mostrando as fases de montagem dos sensores e dos interruptores e todos os testes realizados.

1.1.Material para construção do sensor

• Placa Arduíno
• Protoboard
• Resistores 1M2 ohms (ou maiores)
• Folha de alumínio (encontrada em latas de leite, Nescau, etc.)
• Fios jumpers

1.2.Esquema com um único sensor

Esquema de montagem de um sensor simples

 

O esquema é simples:

• Pino 4: Envia sinal
• Pino 2: Recebe (Sensor)
• Ligando os dois pinos: Resistor de 1M2 ohms
• Folha de alumínio conectada ao receptor

Fiz testes com vários resistores, de 1M a 10M ohms e no meu caso, os melhores resultados foram obtidos com resistores de 1.2M, portanto é bom que você também faça seus próprios testes e verifique o que melhor agradar. Ainda não foi um resultado definitivo porque pretendo utilizar capacitores (20 pF até 400 pF) ligados ao sensor para obter leituras mais estáveis, conforme é sugerido no site do  Arduino Playground (Capsense) . 


1.3.Fotos da montagem com um único sensor

Fotografia da montagem pronta

1.4.Código dos testes com um único sensor

Com base nos valores lidos, que se apresentavam entre a faixa de 200 a 400 sem toque, e acima de 1.000 quando eu tocava, fiz um pequeno sketch de teste que imprimia na saída serial as frases "LAMPADA LIGADA" e "LAMPADA DESLIGADA" sempre que eu tocava no sensor, simulando um interruptor. 

#include <CapacitiveSensor.h>

 
//Resistor ligando os pinos 4 e 2 (sender=4, receiver=2)

CapacitiveSensor   sensor = CapacitiveSensor(4,2);

int SENSIBILIDADE = 900; //Frontreira que defini entre tocar ou nao
bool ligado = 0; //Indica se a lampada esta ligada ou nao
int total = 0; //Valor colhido pelo pino receptor
void setup()  {
    Serial.begin(9600); //Saida serial
}

void loop()                  
{

    long total =  sensor.capacitiveSensor(30); //Le valor no pino receptor
    //Verifica se valor lido eh maior ou nao que a fronteira definida

    if (total > SENSIBILIDADE) {
         ligado = !ligado;
         if (ligado)
             Serial.println("LAMPADA LIGADA");
         else
             Serial.println("LAMPADA DESLIGADA");

          //Delay que simula o tempo de mudar intensidade do led no interruptor         

         for (int i=255; i>1; i--) {
             delay(5);
          }
    }                    
}

(Receba gratuitamente nossos códigos-fontes se inscrevendo no formulário no final dessa postagem)

1.5.Vídeos dos testes com um único sensor

A leitura dos dados ao tocar o dedo diretamente na folha de alumínio mostrou-se bastante sensível. Os valores baixinhos deram saltos bem perceptíveis, o que favorecia a diferenciação entre "toque" e "não toque". Quando utilizei a superfície de vidro de 4mm em cima da folha de alumínio, percebi uma queda drástica da sensibilidade, mesmo assim, ainda obtive resultados satisfatórios. O tamanho da folha de alumínio desse teste era bem maior que a folha utilizada nos interruptores depois de pronto, logo essa sensibilidade ainda cairia mais.

Rodando o código modificado, que mostrei ainda há pouco, consegui simular um interruptor como pode ser verificado no vídeo abaixo:

1.6.Esquema com dois sensores e um módulo relé de dois canais

Esquema com dois sensores e um módulo relé de dois canais

Após ter confirmado a eficácia do sensor, resolvi fazer mais próximo da minha realidade, acrescentando ao circuito mais um sensor e um módulo relé de dois canais, de modo que poderia ser possível controlar duas lâmpadas.

O esquema ficou:

• Pino 4: Envia sinal
• Pino 2: Recebe (Sensor 1)
• Pino 8: Recebe (Sensor 2)
• Ligando os três pinos: Resistores de 1M2 ohms
• Folha de alumínio conectada ao pino 2 e outra ao pino 8
• Relé conectado na placa (gnd->gnd, vcc->5v, in1->pino 11, in2->pino 10)

1.7.Fotos da montagem com dois sensores e um módulo relé

1.8.Código dos testes com dois sensores e um módulo relé

#include <CapacitiveSensor.h>

CapacitiveSensor   sensor1 = CapacitiveSensor(4,2);       
CapacitiveSensor   sensor2 = CapacitiveSensor(4,8);

int SENSIBILIDADE = 900;
int LAMPADA_1 = 13;
int LAMPADA_2 = 12;
bool ligado1 = 0;
bool ligado2 = 0;
int total = 0;

void setup(){
   pinMode(LAMPADA_1, OUTPUT);
   pinMode(LAMPADA_2, OUTPUT);
   digitalWrite(LAMPADA_1,HIGH);
   digitalWrite(LAMPADA_2,HIGH);
}

void loop() {

    long total1 =  sensor1.capacitiveSensor(30);
    long total2 =  sensor2.capacitiveSensor(30);
   
    if (total1 > SENSIBILIDADE) {
      ligado1 = !ligado1;
      if (ligado1)
        digitalWrite(LAMPADA_1,LOW);
      else
        digitalWrite(LAMPADA_1,HIGH);
      delay(2000);
    }
    if (total2 > SENSIBILIDADE) {
      ligado2 = !ligado2;
      if (ligado2)
        digitalWrite(LAMPADA_2,LOW);
      else
        digitalWrite(LAMPADA_2,HIGH);
      delay(2000);
    } 
   
}


1.9.Vídeo dos testes com dois sensores e um módulo relé

2.MONTAGEM DOS INTERRUPTORES

Com o sensor funcionando, entrei no passo seguinte, que a princípio achei ser o mais simples, no entanto me deu muita dor de cabeça. Cortar papel "contact" fazendo círculos não é a minha praia, ainda mais quando não se encontra compasso de corte no mercado. 

2.1.Material

• Placa de vidro fumê
• Leds de alto brilho
• Folha de alumínio (encontrada em latas de leite, Nescau, etc.)
• Papel contact preto
• Tampa de desodorante (ou qualquer substituto para cobrir os leds)

2.2.Construção

É evidente que aqui não tenho muito o que mostrar porque envolve um processo bem pequeno e o material praticamente já estava pronto, mas a experiência vivenciada acaba por ser um aprendizado interessante. O Crepúsculo Tecnológico tem mais informações, site de onde praticamente retirei 100% do que foi feito aqui.

Inicialmente imaginei que utilizando vidro transparente com papel contact branco seria mais adequado para a minha parede branca (imagem acima), mas infelizmente não deu certo porque ao colar o papel contact, a cor não ficou, digamos, um branco neve, pareceu um branco gelo, uma cor que não ficou bem ao meu gosto, sem contar que poderia transparecer o interior do interruptor ao acender os leds, então abortei essa idéia, passando então a utilizar o vidro fumê com papel contact preto.

Para produzir as placas de vidro eu levei uma capinha branca dessas de interruptores que não são usadas, para uma vidraçaria próxima de casa e pedi para cortarem várias plaquinhas com as mesmas dimensões. Cada plaquinha me custou R$ 3,00, muito barato. O papel contact eu encontrei em papelarias comuns.

Para cortar os círculos representando os interruptores, demorei mas encontrei um compasso de corte, que me fez perder muito papel, pois o compasso sempre deslizava em cima do vidro e daí o circulo ficava com imperfeições. Para resolver esse problema, coloquei uns pedaços de fita adesiva no centro do círculo para segurar a perna do compasso e mantê-lo parado.

3.MONTAGEM FINAL

Depois do sensor e dos interruptores prontos, fiz a junção dos dois e acrescentei vários outros componentes para me ajudar nos testes finais.

Acrescentei algumas novidades no circuito,  tais como potenciômetros e pushbuttons, que não serão componentes definitivos, serviram apenas para me ajudar na configuração da sensibilidade e gravação na EEPROM da placa. Essas ações de calibragem da sensibilidade, como já falei antes, será funcionalidade a ser implementada de forma definitiva via tablet.

Circuito completo do interruptor touchscreen

Os testes com leitura/gravação da sensibilidade consistia em girar o potenciômetro e à medida que girava, seus valores de resistência aumentavam ou diminuíam, semelhante ao volume de um aparelho de som. Ao apertar o pushbutton, esse valor era gravado na EEPROM e o interruptor buscava esses valores para saber o limite que existia entre o tocar e o não tocar de tela.

Abaixo segue vídeo com esse teste:

E para o teste final, fiz uma instalação elétrica para testes com lâmpadas reais, afinal ainda não era o momento de instalar na parede.
Nunca é demais falar que essa minha gambiarra elétrica teve que ser utilizada com muito cuidado porque estou falando de 220V de corrente alternada e descuidos podem ter consequências desastrosas.

Montagem final do interruptor touchscreen

Abaixo um vídeo mostrando meu teste final:

Não se assuste com tanta coisa para ser colocada por trás de  um interruptor, na verdade quase tudo o que você está vendo será substituído quando chegar o momento de fixar na parede, por exemplo, não utilizarei protoboard, farei minha própria placa de circuito impresso (mostrarei isso) em dimensões muito menores. Também será substituído o Arduíno Uno por um Pro Mini. Metade desses fios sumirão e componentes extras utilizados apenas nos testes também serão retirados (potenciômetros, push button e resistores).

Para melhorar a qualidade na leitura dos dados dos sensores, acrescentei dois transistores de 100pF em cada um deles e isso me trouxe bons resultados.

E por fim, para não estender essa postagem que já está longa, vou te dispensar de ver o código final e caso queira analizá-lo, melhorá-lo, estudá-lo, enfim, utilizá-lo para qualquer fim, me avise nos comentários.

Em breve, mais novidades, ainda tem muita coisa pela frente...

(Atualizado em 23/11/2016) - Hoje em dia, um módulo interessante de ser explorado nesses projetos é o ESP8266, ele é pequeno, pode fazer a comunicação wifi entre os vários pontos da casa e seu preço é bem mais em conta que muitos outros módulos wifi encontrados no mercado. E mais, é possível utilizá-lo sem o Arduíno, programando os controles necessários diretamente nele como se fosse um Arduíno. Faremos um versão de nossos trabalhos utilizando ele muito em breve

Receba grátis todos os códigos-fontes se inscrevendo em nosso canal

Informe seu e-mail *