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 *

Controlando a TV com Notebook

Continuando minhas experiências com infravermelho, após capturar e anotar os códigos enviados como demonstrados no tópico Decodificando Controles Remotos, resolvi verificar se realmente funcionaria o envio de sinais seguindo os mesmos padrões.

Lembre-se que o Módulo de Controle Secundário do projeto de automação que estou fazendo é responsável por ligar/desligar TVs, logo essa tarefa de hoje é muito importante para este módulo.

Enviei alguns comandos utilizando um led emissor infravermelho comum, que veio no kit infravermelho citado no tópico Material Necessário.

O resultado foi positivo no quesito PRECISÃO DO CÓDIGO, porém insatisfatório no quesito QUALIDADE DO SINAL. Em alguns momentos foi preciso enviar o mesmo comando várias vezes para que ele funcionasse, mas este ponto negativo já era esperado,  daí o motivo de eu ter colocado na lista de compras um led emissor infravermelho multiângulo, que é composto de 4 leds IR enviando o mesmo sinal, ao mesmo tempo, em várias direções.

Esse led chegará em breve e darei o feedback sobre os resultados com ele, mas por enquanto tenho que me contentar com o led comum.

O desenvolvimento do transmissor deu-se da seguinte forma:

MATERIAL

• Placa Arduíno Uno R3
• Cabo USB
• Led infravermelho comum
• Resistor 220 ohms
• Fios jumpers

Esquema de montagem do transmissor IR na protoboard

Talvez eu não precisasse montar a protoboard utilizando o Fritzing por se tratar de um circuito fácil de montar, mas para não perder o costume, prefiro manter o hábito de primeiro desenhar para depois montar de verdade.

O circuito montado ficou assim:

Protoboard montada com o led emissor infravermelho

Para fazer o envio do sinal infravermelho utilizando os métodos IRRemote, você precisa ligar o pólo positivo do led ao pino 3 da placa Arduíno. Perceba que não existe referência ao pino 3 no código, está implícito.

A codificação, como em todos os outros exemplos mostrados, foi muito simples, a biblioteca IRRemote trata dos pequenos detalhes, tudo o que precisei enviar foi o código hexadecimal da tecla que simulei pressionar (e o tamanho em bits desse comando) através do método sendNEC (existe outros métodos para o mesmo fim, que varia de acordo com cada protocolo: sendSony, sendNEC, etc.).

Considerando que obtive os seguintes códigos do controle de minha TV à cabo:

• Liga/Desliga: E17A48B7 
• Sobe Canal:   E17A08F7 
• Desce Canal:  E17A58A7

 Ficou o sketch da seguinte forma:

 
#include <IRremote.h>

IRsend irsend;

void setup() {
  Serial.begin(9600);
}

void loop() {
  char comando = Serial.read();
  if (comando == 'L')
      ligaDesliga();
  else if (comando == 'S')
      sobeCanal();
  else if (comando == 'D')
      desceCanal();
}

//Envia o comando LIGA com 32 bits utilizando protocolo NEC
void ligaDesliga() {
  for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0xE17A48B7, 32);
  }
}

//Envia o comando SOBE CANAL com 32 bits utilizando protolo NEC
void sobeCanal() {
  for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0xE17A08F7, 32);
  }
}
//Envia o comando DESCE CANAL com 32 bits utilizando protocolo NEC
void desceCanal() {
  for (int i = 0; i < 3; i++) {
    irsend.sendNEC(0xE17A58A7, 32);
  }
}

Fiz um vídeo demonstrando os resultados, não repare a falta de qualidade, mas estava difícil filmar tudo com um celular em uma mão e o computador em outra.

Ao teclar a letra "S" eu mandava subir o canal, a tecla "D" para descer e a tecla "L" para ligar/desligar.

 

Com isso terminei todos os experimentos referente ao controle de equipamentos por meio de luz infravermelha, o que implica que para o Módulo de Controle Secundário ficar completo, precisarei apenas acrescentar um receptor RF-433Mhz, assunto esse que abordarei em breve.

Andei trocando idéias com o Jalf, amigo e ex-colega de universidade (UFCG - Campina Grande - PB) e ele me passou várias informações e sugestões que podem melhorar meu projeto, tais como interruptor touchscreen feito em casa, módulos RF com maior alcance, dentre outras, que irei tratar na minha próxima postagem (valeu Jalf !!!).

Então, inté, te "vejo" em breve !

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

Informe seu e-mail *

Decodificando Controles Remotos

Dessa vez coloquei as mãos na massa e com o material que já tenho, pude dar o primeiro passo para montagem do Módulo Controlador Secundário, mais precisamente, a parte que envia comandos infravermelhos para as TV's.

O controle remoto manda esses comandos através de pulsos de luz infravermelha (invisíveis aos nossos olhos) que são decodificados pela sua TV seguindo protocolos específicos. Isso significa dizer que, dependendo do aparelho, existem formas diferentes de tratar esses pulsos. Para quem tiver interesse em saber mais alguns detalhes sobre esse assunto, pode dar uma olhadinha em http://eletronicos.hsw.uol.com.br/controle-remoto2.htm

Lidar com envio/recebimento infravermelho de um controle remoto de maneira crua (raw data) foi algo que descartei de imediato.
Graças a abençoada abstração nossa de cada dia, foi possível tratar tudo isso de forma tranquila. Utilizando a biblioteca IRRemote (https://github.com/shirriff/Arduino-IRremote), pude descobrir os códigos, o protocolo e o número de bits dos comandos enviados por vários controles. 

Baixei a biblioteca, copiei para a pasta libraries onde está instalada a minha IDE Arduíno e dessa forma ficou pronta para uso.
 

MATERIAL

• Módulo receptor infravermelho
• Placa Arduíno Uno R3
• Fios jumpers
• Cabo USB
• Controle Remoto

Material para decodificação

Utilizei o Fritzing (http://fritzing.org) para elaborar o esquema da montagem na protoboard. Esse software também será importante para desenhar a placa de circuito impresso, portanto, se você tem interesse em fazer essas montagens virtuais e ainda não conhece nenhuma ferramenta, recomendo fortemente o Fritzing.

Receptor IR - Esquema de montagem na protoboard

Montar esse esquema foi bastante simples. Dois fios saindo dos pinos GND e 5V da placa Arduíno para compor a alimentação na protoboard e mais um fio saindo do pino 11 para ser conectado ao pino de sinal do receptor IR.

Receptor IR - Visão frontal da placa Arduíno

Receptor IR - Ligação dos fios entre a placa e a protoboard

Feita a conexão dos fios, pluguei o receptor IR, composto por três pinos, conforme a associação abaixo:

Pino "-": fio vindo do GND
Pino "+": fio vindo do 5V
Pino "S":  fio vindo do pino 11

Associação do receptor IR aos fios jumpers

Resultado final do circuito montado

O sketch que utilizei para receber os sinais infravermelhos, decodificar e mostrar na tela para o usuário,  acompanha a biblioteca IRRemote, o IRRecvDump:

 

Não foi necessário fazer nenhuma modificação no código original. Destaquei os pontos importantes onde a biblioteca faz a sua parte.

#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup() {

     Serial.begin(9600);

     irrecv.enableIRIn(); //Inicializa o receptor IR
}
//Identifica o protocolo utilizado e imprime o código enviado

 
void dump(decode_results *results) {

     int count = results->rawlen;
     if (results->decode_type == UNKNOWN) {
          Serial.println("Could not decode message");
     }
     else {
          if (results->decode_type == NEC) {
               Serial.print("Decoded NEC: ");
          }
         else if (results->decode_type == SONY) {
              Serial.print("Decoded SONY: ");
         }
         else if (results->decode_type == RC5) {
              Serial.print("Decoded RC5: ");
         }
         else if (results->decode_type == RC6) {
              Serial.print("Decoded RC6: ");
         }
         Serial.print(results->value, HEX);
         Serial.print(" (");
         Serial.print(results->bits, DEC);
         Serial.println(" bits)");
     }
     Serial.print("Raw (");
     Serial.print(count, DEC);
     Serial.print("): ");

     for (int i = 0; i < count; i++) {
          if ((i % 2) == 1) {
               Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
          }
          else {
               Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
          }
          Serial.print(" ");
     }
     Serial.println("");
}

void loop() { 

     if (irrecv.decode(&results)) {  // Aqui a MÁGICA acontece.
          Serial.println(results.value, HEX);
          dump(&results);
          irrecv.resume(); // Lê mais valores caso existam
      }
}

Após a protoboard montada e sketch codificado, conectei o cabo USB ligando a placa ao computador e fiz o upload desse sketch, em seguida abri a console serial da IDE Arduíno e começei os testes. Veja alguns resultados obtidos:

 

Dispositivo: Controle remoto do kit infravermelho
Botão: 0

Protocolo: NEC

Código: FF6897

Bits: 32

Dispositivo: Controle remoto da TV da sala 
Botão: Baixar volume

Protocolo: NEC

Código: 20DFC03F

Bits: 32

Dispositivo: Controle remoto do receptor de TV a cabo
Botão: Subir volume

Protocolo: NEC

Código: E17AB04F

Bits: 32

Dispositivo: Controle remoto do home theater
Botão: Desligar

Protocolo: SONY

Código: B

Bits: 15

Após receber cada código, fiz anotação de todos os valores, conforme estes mostrados acima, pois precisarei deles para substituir os controles remotos e poder controlar tudo a partir do meu tablet.

No próximo post, farei testes com esses códigos obtidos, enviando comandos para ligar e desligar minha TV à partir do meu notebook. Até breve...

 

Esquema de Montagem

Em um primeiro instante montarei e testarei os módulos em protoboards para me certificar de que o seu funcionamento estará adequado. Após confirmação de que está tudo certo, passarei para a fase final, que seria a montagem de todos eles em placas de circuito impressos.

A criação das placas de circuito impresso e a soldagem dos componentes serão elementos de dicussão no final deste projeto, porém não deverei criar placas perfeitas e não mostrarei as melhores técnicas de criação delas, focarei em um método que considero o mais simples e que atende meu objetivo.

1.MÓDULO DE CONTROLE PRINCIPAL

1.1.Material para montagem:

• Placa Arduino Uno R3 - Para processamento dos comandos
• Led fnfravermelho - Para envio de sinais infravermelhos para TV próxima
• Transmissor RF433Mhz - Para repassar comandos para os outros módulos
• Shield Ethernet - Para comunicação com o roteador wireless e consequentemente com o tablet
• Plug de Bateria - Para conectar a bateria à placa Arduino
• Bateria 9V - Para alimentar a placa Arduino e seus acessórios

1.2.Esquema

Esquema de montagem do Módulo de Controle Principal

Estou mostrando a placa Arduino Uno ao lado do Shield Ethernet apenas para fins de melhor entendimento e visualização, mas quem utiliza esse shield já sabe que eles tem um encaixe perfeito exatamente um em cima do outro, como mostrado na imagem abaixo:

Shield Ethernet acoplado em cima da placa principal

2.MÓDULO DE CONTROLE SECUNDÁRIO

2.1.Material para montagem:

• Placa Arduino Pró-Mini 5v - Para processamento dos comandos
• Led Infravermelho - Para envio de sinais infravermelhos para TV e condicionar de ar
• Receptor RF433Mhz - Para recebimento de sinais RF vindos do Módulo Principal (comandos)
• Plug de Bateria - Para conectar a bateria à placa Arduino
• Bateria 9V - Para alimentar a placa Arduino e seus acessórios

2.2.Esquema

Esquema de montagem do Módulo de Controle Secundário

Atenção: Em todos os módulos, os leds transmissores de sinal infravermelho estão conectados diretamente em 5V. Posso fazer isso porque esse tipo de led multiângulo que encontrei trabalha nessa voltagem, mas se você utilizar leds infravermelhos de outro tipo, verifique sua tensão de trabalho, eles podem precisar de resistores para não queimar. Se você tiver interesse em saber mais detalhe sobre esse assunto, indico o seguinte site: http://learn.adafruit.com/all-about-leds. Lá você vai encontrar muita informação sobre leds, Lei de Kirchhoff e Lei de Ohm.

3.MÓDULO RECEPTOR

3.1.Material para montagem

• Relé RF433Mhz - Para recebimento de sinais RF vindos do Módulo Principal e controle das lâmpadas.

3.2.Esquema

Módulo Receptor: Resume-se apenas a um relé com RF embutido.

Não existe esquema de montagem, ele é uma peça única, o fato de eu ter encontrado um relé com receptor RF-430Mhz embarcado e funcionando totalmente em 220V me livrou de montar um esquema parecido com os mostrados nos tópicos acima, caso contrário eu precisaria de mais um Arduino Pró-Mini, mais um Receptor RF-430Mhz e um relé comum conectado a eles, e o que é pior, precisaria de uma fonte de alimentação de corrente contínua (provavelmente mais uma bateria de 9V) para alimentar o Arduino, ou seja, esses interruptores iriam ficar feios prá caramba e totalmente expostos na parede (não poderia embutir algo que precisasse ser recarregado).

Agora veja só como as coisas mudaram para o Módulo Receptor em curto tempo de pesquisa:

1a. versão: Arduino + relé comum + receptor + bateria

2a. versão: Arduino + relé com receptor embarcado + bateria

3a. versão: Relé com receptor embarcado sem Arduíno e sem bateria. 

Você acha que terminei por aqui ? e a USABILIDADE disso ?

Questão: os Módulos Receptores substituirão os interruptores ou conviverão com eles ?  Imagine você sendo um visitante sem acesso ao meu tablet precisando ligar uma lâmpada, vai querer simplesmente apertar um interruptor ou vai atrás de mim pedir meu tablet emprestado ? E se o tablet cai no chão e se "espatifa" em mil pedaços ? Como vou ligar as lâmpadas ? Então, de fato, a resposta é uma só: O MÓDULO RECEPTOR PRECISA CONVIVER COM O INTERRUPTOR COMUM.

Existe uma maneira, que ainda não explorei, mas seria utilizar o interruptor ligado em paralelo com o Módulo Receptor, ambos ligando e desligando as lâmpadas. Problema da usabilidade resolvido ! 

Pronto, a minha 3a. versão do Módulo Receptor ligado em paralelo com o interruptor vai resolver meu problema. 

Mas, e se eu disser que pode haver uma 4a. versão ainda melhor que as anteriores ?

4a. versão : Módulo Receptor da 3a. versão + interruptor embarcado

Essa 4a. versão (U$ 29,00), além de chique é muito prática. Trata-se de interruptores touch screen feitos em vidro temperado com iluminação em led e  controle remoto, podendo ligar até três lâmpadas. Nesse caso eu precisaria apenas decodificar o controle e fazer o Módulo Principal enviar o sinal RF-433Mhz. É uma boa opção para interruptores de 3 lâmpadas porque o custo sai quase o mesmo da 3a. versão (substitui três relés de R$ 8,36 cada).

Focarei na solução da 3a. versão para interruptores simples e como informação extra, caso funcione, demonstrarei a 4a. versão no final do projeto para aqueles que precisem trabalhar com três interruptores.

 

Com isso encerro o esquema de montagem dos módulos, os detalhes da estrutura e do fluxo dos comandos serão mostrados quando eu estiver falando sobre o desenvolvimento do software de controle das placas Arduino.

Falando em software, também desenvolverei a interface do usuário que funcionará em um tablet com Android 4.0 (Ice Cream Sandwich).

Massssssss, isso é uma outra história....