Uma forma interessante de automatizar a sua casa é tornar o acendimento das lâmpadas automáticos. Com isto, você deixa a sua casa moderna e ainda tem a oportunidade de economizar energia.
Portanto, neste post, veremos como projetar um sistema para controlar a luz de um cômodo automaticamente. E esta é a segunda versão do projeto.
Ressalvas
Conforme disse, esta é a versão 2 do projeto. Caso queira ver a primeira, acesse este link.
É importante dizer que o projeto requer alguns recursos (componentes SMD) e habilidades (solda SMD) não muito comuns. Sendo assim, o objetivo deste post é mais o aprendizado, pois mostrarei alguns conhecimentos pertinentes envolvendo projetos de hardware, firmware e estrutura (para criar um sistema embarcado).
Entretanto, se você deseja recriar o projeto, também é possível, pois vou disponibilizar os arquivos necessários.
Eu poderia melhorar o projeto corrigindo os erros existentes antes de apresentá-lo, mas o principal objetivo do site é o aprendizado e os erros têm muito a nos ensinar.
Por fim, vale mencionar que este projeto demorou vários meses para chegar no seu estado final. Então, leia o post com calma para entender todos os detalhes.
Discutindo a ideia
Objetivo e características
Seguindo o raciocínio da versão 1, o objetivo do projeto é acender a luz de um cômodo automaticamente a partir da presença de alguém. E as mesmas regras de antes são válidas:
- A luz só acende se as duas condições abaixo forem cumpridas:
- Se houver no mínimo uma pessoa no cômodo
- Se o cômodo estiver escuro
- Senão, a luz apaga
A definição de “escuro” e “bem iluminado” vai depender da sua necessidade, do quanto de luz você considera suficiente para o ambiente estar “bem iluminado”. Portanto, este será um parâmetro ajustável.
Além destas características, defini que o sistema também teria que ser capaz de ser acessado pela internet. Sendo mais específico, o sistema terá uma página (webserver) com informações dos sensores e com controles da lâmpada.
Detecção de pessoas no cômodo
Na primeira versão, utilizei 2 sensores ultrassônicos para fazer a detecção de entrada e saída de pessoas no cômodo. A lógica de funcionamento está explicada na imagem abaixo:
A princípio, resolvi seguir o mesmo caminho, só que utilizando sensores de distância infravermelhos. Fiz esta troca, pois o sensor ultrassônico não mede corretamente superfícies inclinadas. E, quando uma pessoa está passando, a superfície na frente do sensor não vai ser nada plana, seja ela um pedaço do braço, perna etc… Portanto, ele não é nada ideal para a aplicação.
Por outro lado, o sensor infravermelho apresenta melhores resultados para superfícies inclinadas. Embora, na prática, eu tenha percebido que ele também não funcionou tão bem para movimentos rápidos. De toda forma, funcionou bem melhor que o sensor ultrassônico.
O sensor infravermelho que resolvi utilizar foi o VL53L0X, no caso utilizei 2. Mas acabei tendo outra ideia que simplificou e barateou o projeto. Esta ideia foi trocar os dois sensores infravermelhos por um único sensor de gestos. E o sensor de gestos tem as seguintes vantagens:
- É mais barato.
- 1 sensor de gestos é mais barato do que 2 sensores de distância infravermelhos.
- O código fica simples e menor.
- Ele é feito para detectar movimentos, sendo ideal para detectar a saída/entrada de pessoas no cômodo.
Falarei qual é o sensor no tópico do Hardware.
Detecção da iluminação
Assim como na primeira versão, a detecção da iluminação foi feita por meio de um LDR.
Acesso à internet
Seguindo o caminho mais simples e bem conhecido, optei por utilizar um Esp8266 para permitir o controle do sistema pela internet. O termo internet aqui está um pouco vago, mas o que quero dizer com isto é que o sistema se conecta a uma rede Wi-Fi e qualquer computador ou dispositivo conectado na mesma rede pode acessar o Webserver criado pelo Esp8266.
Seria possível acessar o sistema por uma rede externa também, mas seria preciso fazer uma das duas coisas:
- Abrir a porta do servidor no Modem.
- Fazer o sistema se comunicar com um servidor externo (Firebase por exemplo).
A primeira opção não é muito interessante, pois, assim, qualquer um com acesso ao seu IP externo poderia controlar o sistema. Por outro lado, a segunda opção é segura, mas como não pretendia controlar o sistema fora de casa, resolvi deixar a coisa simples e manter o acesso ao Webserver apenas local.
Projeto do hardware
Os arquivos referentes ao hardware podem ser baixados neste link do Github.
O circuito do projeto conta com vários componentes PTH e SMD. Se você não tem muita familiaridade com estes componentes, principalmente os SMD, recomendo dar uma lida neste post. E, se você acha que soldar componente pequenos é coisa de outro mundo, sugiro assistir aos vídeos de como soldar componentes SMD e PTH.
Metodologia
Na primeira versão, usei o software Fritzing para desenhar a placa do sistema e a montagem foi feita em uma placa ilhada universal. Além disto, também utilizei um carregador de celular para alimentar a placa com 5V. De modo geral, a montagem ficou bem gambiarrada e nada prática, como pode ser visto na imagem abaixo:
Felizmente, depois disso, aprendi muita coisa nova e resolvi utilizar estes conhecimentos para desenvolver um projeto com um aspecto mais profissional e que fosse mais fácil de montar. Portanto, optei por elaborar uma placa de circuito impresso (PCB ou PCI).
Para a criação da PCB, utilizei o Software EasyEDA, que é gratuito, simples de usar e de fácil aprendizado. Além disto, o EasyEDA é integrado à uma empresa que fabrica PCBs. Ou seja, após desenhar o esquemático e o layout da placa, foi questão de alguns cliques para encomendar a PCB do projeto.
Vale mencionar que a PCB vem da China e demora cerca de 1 mês para chegar. E foi bem barato encomendar 5 placas (pedido mínimo).
Enfim, recomendo você experimentar o EasyEDA, pois ele é uma ferramenta bem útil e ainda é integrado a uma loja de componentes eletrônicos, o que facilita a obtenção dos footprints e da pinagem dos componentes.
Esquemático
Veja o esquemático do projeto abaixo e adiante discutiremos alguns pontos separadamente.
Conectores
Para facilitar a montagem, utilizei bornes parafuso (KF301 de 2 pinos) na entrada de alimentação, na conexão da lâmpada e na conexão do LDR. Assim, dá menos trabalho para instalar o sistema e dar manutenção se necessário.
Os bornes são os componentes CN1 até CN4.
Alimentação
A alimentação do circuito foi feita utilizando a rede elétrica. E o circuito necessita de dois níveis diferentes de tensão: 3,3 e 5V.
- 5V serve para alimentar o relé (e o VL53L0X).
- 3,3V serve para alimentar o ESP8266, o sensor de gesto, criar o divisor de tensão do LDR etc…
Portanto, resolvi utilizar um módulo conversor AC/DC que converte de 100 a 240Vac em 5V, chamado HLK-PM01. Ele foi considerado, pois é barato, compacto e funciona bem. Isso comparado ao caso em que eu utilizaria um transformador, com um retificado etc.
E, para converter o 5V em 3,3V, utilizei um regulador de tensão chamado AMS1117-3.3 (pode ser encontrado em alguns Arduinos).
Proteção do circuito
O circuito conta com duas proteções diferentes: sobrecorrente (curto) e sobretensão. Para o primeiro caso, a proteção é garantida pelo termistor PTC (F1). E ele funciona da seguinte forma:
Um aumento na corrente do circuito faz com que a temperatura do PTC aumente e, consequentemente, sua resistência interna também. Se sua resistência interna aumenta, quer dizer que ele limita a corrente do circuito e faz ela diminuir. Portanto, ele funciona como se fosse um fusível que se “reinicia” sozinho (depois que o curto for removido, ele volta a corrente ao seu valor normal).
E existem diferentes PTCs para diferentes limites de corrente. No caso, escolhi um com corrente limite de 120mA chamado TRF250-120. Mais à frente veremos que ele ficou sobredimensionado.
Certo, e na sequência, temos o varistor (VDR1) que garante a proteção contra sobretensão. Ele funciona da seguinte forma:
Quando uma tensão elevada chega na entrada do circuito, a resistência interna do VDR1 cai para um valor bem pequeno criando praticamente um curto. E, por ser praticamente um curto, a tensão em cima dele será pequena e isto evita que a sobretensão passe para o circuito do conversor AC/DC.
Se o varistor fosse utilizado sozinho, a sobretensão seria suficiente para danificar o componente e torná-lo inutilizável. Mas, graças ao PTC, a alta corrente é limitada e o varistor é protegido.
Leitura do LDR
A leitura do LDR foi feita simplesmente por meio de um divisor de tensão. Veja este post para mais detalhes desta configuração.
A única particularidade deste circuito foi o diodo (D1). Acontece que a tensão máxima lida pelo ESP8266 é 1V e, para evitar que o pino da leitura AD seja danificado, utilizei o diodo D1 para limitar a tensão em 0,7V.
Ligação do sensor
Veja a imagem abaixo para entender um ponto que comentarei adiante.
Repare que a placa fica no mesmo “sentido” da parede e o sensor fica na lateral da caixa. A ideia inicial foi esta e, para que fosse possível interligar o sensor na placa, utilizei uma barra de pinos 1×6. Com isto, na montagem, basta apenas utilizar cabos fêmea-fêmea para fazer a conexão. Isto é útil, pois evita o trabalho de ter que ficar soldando fios no sensor e na placa.
Na realidade, o esquemático possui duas barras de pinos 1×6 para ligar o sensor. Isso ocorre, pois, conforme disse, inicialmente utilizei dois sensores infravermelhos VL53L0X. Mas, depois tive a ideia de utilizar um sensor de gestos. Sendo assim, existem duas principais possibilidades de escolha, o sensor APDS-9960 e o PAJ7620.
Cheguei a testar os dois e o que funcionou melhor foi o PAJ7620. Não tenho total certeza do motivo, mas acho que tem relação com a distância de detecção do gesto. O APDS só funcionou bem quando o gesto de entrada/saída foi feito próximo ao sensor. Já o PAJ7620 funcionou bem mesmo passando um pouco longe. É possível ajustar a sensibilidade do APDS, mas mesmo assim não obtive sucesso.
Como o projeto inicial foi feito pensando no VL53L0X, o barramento de conexão com sensor possui um pino de 5V, o qual não é adequado para o PAJ7620. Por isto, na imagem acima, o cabo vermelho (alimentação) está sendo ligado em outro barramento (3,3V do barramento de programação).
Acionamento da lâmpada
O circuito de acionamento da lâmpada é igual ao da versão 1. Nada mais é do que um relé de 5V sendo acionado por um transistor (T1). Se você quiser ler mais detalhes deste circuito e aprender a calcular os parâmetros dele, veja este post.
ESP8266
Assim como disse anteriormente, fiz uso do ESP8266 para possibilitar ao sistema o acesso à internet. Sendo mais específico, utilizei um módulo chamado ESP12F, que pode ser visto na imagem abaixo.
Este módulo possui o CI ESP8266 já ligado aos componentes recomendados: antena, memória flash, cristal etc. Portanto, é mais fácil de trabalhar com ele, pois a garantia de funcionamento do circuito como um todo aumenta consideravelmente.
É possível programar ele exatamente da mesma forma que você faria com uma placa de desenvolvimento NodeMcu por exemplo (utilizando a IDE do Arduino ou outra). E o código é enviado para ele utilizando os dois pinos na parte superior direita, que são o TX e RX. No caso, utilizarei um conversor USB para TTL para fazer a comunicação do computador com a placa.
Para permitir o acesso a estes pinos, utilizei uma barra de pinos 1×4 (H2 no esquemático). O GND desta barra de pinos é obrigatório para que o programador (conversor USB para TTL) esteja no mesmo referencial da placa. E o 3,3V serve para o programador alimentar a placa (para quando ela não estiver ligada na alimentação).
Além dos pinos de programação, o ESP8266 possui um pino (IO0) para definir o “modo de inicialização”. Se IO0 estiver em nível baixo quando o ESP8266 for reiniciado, a placa entra no modo de programação. Caso contrário, ela entra no modo de operação normal.
Para definir o valor deste pino, utilizei uma barra de pinos 1×3 com um jumper. Então, para trocar os modos, é só trocar o jumper de lado. Percebi depois que seria mais prático ter utilizado um botão para fazer o IO0 entrar no modo de programação, pois ficar tirando e colocando o jumper pode ser trabalhoso quando você está testando e reprogramando o código toda hora.
Criação do Layout
A criação da placa foi feita em conjunto com o projeto da estrutura. Isso, porque um tem relação direta com o outro e levar em conta os aspectos de cada um é crucial para que não apareçam inconvenientes na parte da montagem.
Sendo mais específico, é preciso considerar qual o tamanho e formato da placa, bem como onde posicionar os furos. Além de outras questões como posicionamento adequado dos componentes.
Fica complicado explicitar todos os pontos que considerei, mas um deles foi o posicionamento das entradas de alimentação e do circuito da lâmpada. Decidi colocar as entradas à esquerda, pois é o lado onde ficará o interruptor que é de onde puxarei os fios de alimentação e da lâmpada.
De toda forma, cabe ressaltar que a criação do layout é trabalhosa, demorada e me parece algo mais artístico do que técnico. Claro, existem recomendações e boas práticas que podem ser seguidas para deixar seu projeto mais profissional e mais bem acabado.
Uma dica que posso dar é o livro “AVR e Arduino Técnicas de Projeto”, que é disponibilizado gratuitamente pelos seus autores. O foco do livro não é a criação de layouts, mas ele possui uma parte com dicas muito úteis sobre o assunto.
Resultados
Adiante é possível ver como ficou a placa com os componentes já soldados.
Erros no layout da placa
1 – Capacitor C5
O capacitor C5 deveria ser um capacitor de desacoplamento atrelado ao ESP12F. Entretanto, na hora de desenhar o layout, acabei esquecendo deste fato e posicionei ele longe dos pinos de alimentação do ESP12F. Na primeira imagem acima, dá para ver ele no canto superior direito.
No arquivo do Github, este problema já foi resolvido.
2 – ESP12F
É altamente recomendado posicionar o ESP12F na extremidade da placa com a parte da antena para fora da placa. Este detalhe passou despercebido e a única coisa que acabei fazendo foi remover o plano de terra ao redor da antena (no layer superior). A falta de seguir esta recomendação de fato teve impacto, pois a potência do sinal recebido estava bem abaixo do “normal” (o normal foi uma plaquinha NodeMcu medindo a potência no mesmo ponto).
3 – Diâmetro dos furos dos bornes
Acabei pegando o footprint errado para os bornes parafuso e o diâmetro dos furos ficou menor do que o valor real. Consegui alargar os furos, mas isso danificou um pouco a placa e a solda deles ficou estranha. No arquivo do Github, este problema já foi resolvido.
Projeto do firmware
Os arquivos referentes ao firmware podem ser baixados neste link do Github.
O código final é um pouco grande, então vou explicar apenas alguns pontos mais importantes.
Plataforma de desenvolvimento
Aqui no site tem um curso focado na programação do NodeMcu em Lua. Entretanto, à medida que fui mexendo com este projeto, percebi que a programação do ESP8266 na IDE do Arduino seria melhor por alguns motivos diferentes. Isso, porque o Arduino tem uma comunidade maior, tem diversos códigos de exemplo e códigos mais simples de implementar. Lembrando que esta é minha opinião.
Então, foi apenas uma questão de baixar os drivers para as placas do ESP8266 na IDE do Arduino para começar a programar. Não pretendo mostrar como, pois existem muitos tutoriais na internet explicando isto.
Arquitetura do firmware
Para facilitar o desenvolvimento e a manutenção do código, dividi ele em 3 principais partes:
- FW-LZAUT-1.1
- Código principal que contém a rotina de setup e do loop.
- conectividade.h e conectividade.ino
- Biblioteca com funções referentes à parte da conexão com o Wi-Fi, criação do Webserver e da programação OTA.
- gesto.h e gesto.c
- Biblioteca com funções referentes ao sensor de gestos.
Configuração da rede Wi-Fi
A rede Wi-fi pode ser configurada alterando as linhas 9 e 10 do arquivo “conectividade.h”:
#define NW_NAME “rede_wifi”
#define NW_PASSWORD “senha_rede”
Programação OTA
Como o sistema ficará fixado na parede ao lado da porta do cômodo, fica complicado ficar passando um cabo para programar o ESP8266 quando for preciso. Então, resolvi adicionar a programação “pelo ar” (Over The Air ou OTA). Para isso, basta acessar o Webserver e adicionar ‘/firmware’ no fim da url.
Exemplo: 192.168.0.10/firmware
Com isto, você é redirecionado para uma página onde pode enviar o arquivo de programação (.bin) para o ESP8266 diretamente pela rede Wi-fi. E quando você compila um programa na IDE do Arduino, o arquivo .bin é gerado na pasta “C:\Users\SEU_USUARIO\AppData\Local\Temp\arduino_build_ALGUM_NUMERO”.
Além disto, quando você acessa a página do OTA (‘/firmware’), é necessário que você digite um login. Por padrão, o usuário é ‘admin’ e a senha também é ‘admin’. Mas isso pode ser alterado no arquivo “conectividade.h”. Nele também é possível alterar o endereço do OTA (de ‘/firmware’ para outro).
Código do sensor
Para ler o sensor PAJ7620, utilizei a seguinte biblioteca. Basta procurar “PAJ” no “Gerenciador de Biblioteca” da IDE do Arduino.
O código do sensor segue o formato encontrado no código de exemplo da biblioteca. A diferença é que troquei o delay de “saída” por uma esquema de timeout para evitar que o programa principal ficasse congelado.
Além disto, adicionei o seguinte código depois de iniciar o sensor:
1 2 3 4 5 | paj7620SelectBank(BANK1); delay(1); paj7620WriteReg(0x65, 0xB7); delay(1); paj7620SelectBank(BANK0); |
Estes comandos servem para alterar o tempo do estado ‘IDLE’ do sensor (consequentemente outras coisas). No caso, o valor que coloquei (0xB7) garante que a distância de detecção seja longa o suficiente pro sistema funcionar bem. É difícil encontrar informações mais precisas do PAJ7620, pois o único datasheet que achei é bem superficial. Mas, por sorte, esta mudança acima deixou o sensor funcionando muito bem.
Configuração do módulo Wi-Fi
Na função ‘wifi_begin’ encontrada no arquivo ‘conectividade.ino’, existem dois comandos comentados que podem ser utilizados para melhorar alguns aspectos do sistema:
WiFi.setPhyMode(WIFI_PHY_MODE_11B);
WiFi.setSleepMode(WIFI_NONE_SLEEP);
O primeiro serve para mudar o modo da conexão. O padrão é o modo 802.11g, mas o modo 802.11b tem uma sensibilidade maior (reconhece sinais de menor potência). Este comando é útil para “contornar” o problema causado pelo erro no posicionamento do ESP12F que atrapalhou a potência do sinal recebido.
Acabei comentando ele, porque percebi certas “inconstâncias” na comunicação com o Webserver neste modo ‘b’.
Já o segundo comando serve para manter o módulo Wi-fi do ESP8266 acordado o tempo todo. Por padrão, o periférico do Wi-fi fica dormindo e acorda de tempos em tempos. Mas isto pode gerar certo atraso na hora de conectar no Webserver. Portanto, utilizar este comando deixa o sistema bastante ágil.
Vale dizer que este comando faz o consumo de corrente aumentar. E como a resposta normal do sistema estava satisfatória para mim, resolvi deixar o comando comentado.
Leitura do LDR
A leitura do LDR está localizada no arquivo ‘FW-LZAUT-1.1.ino’ na função ‘ldr_escuro’.
A princípio, ela é algo simples, pois basta fazer uma leitura analógica e verificar se o valor lido está acima/abaixo de um determinado limiar para declarar que o ambiente está claro/escuro. Entretanto, este procedimento me deu muita dor de cabeça e me fez perder horas com um problema bem estranho.
Inicialmente, eu estava executando o comando ‘analogRead(A0)’ diversas vezes por segundo e isto estava fazendo o Webserver parar de responder. Depois que descobri o problema, vi que é necessário criar um delay de alguns milissegundos entre cada chamada da função ‘analogRead’. Se isto não for feito, o Wi-fi parece perder a conexão.
Por fim, a lógica da leitura do LDR é igual a da versão 1: o ambiente só será reconhecido como escuro se o valor da leitura ficar abaixo do limiar por mais de X segundos. Este tempo e o valor do limiar podem ser ajustados nas linhas 19 e 20 do código principal:
#define LDR_TIMEOUT 3000
#define LDR_LIMIAR 45
Webserver
Primeiro, criei o Webserver em um arquivo “.html” e depois transcrevi o código para o Arduino. O resultado pode ser visto abaixo:
Alguns pontos interessantes:
1 – Todas as imagens foram utilizadas a partir de links da internet.
Exemplo: <img src=”link_da_internet” />.
2 – O botão de ligar/desligar foi feito utilizando um form que direciona a página para ela mesma (“/”). Por isso, quando você clica no botão, a página apenas atualiza ao invés de ser redirecionada.
<form action=”/” method=”POST”>
E o Webserver processa o payload (dados recebidos) no início da função de exibição da página do Webserver (função ‘ws_pagina_init’):
1 2 3 4 5 6 7 8 | for (uint8_t i = 0; i < server.args(); i++) { if(server.argName(i).indexOf("rele_bot") >= 0) { ws_rele_change(); break; } } |
Projeto da estrutura
Os arquivos referentes à estrutura podem ser baixados neste link do Github.
A estrutura foi feita com a ajuda de uma impressora 3D.
Características
Conforme comentei na parte do hardware, a estrutura foi pensada em conjunto com o hardware. Enfim, veja a imagem abaixo com a indicação de algumas características importantes dela:
1 – Ponto para encaixe do sensor de gestos.
O furo circular serve para parafusar o PAJ7620 na estrutura e a abertura é para passar a barra de pinos do sensor.
2 – Suportes para parafusar e apoiar a PCB.
3 – Furo para passar o LDR.
4 – Abertura para criar o acesso aos bornes parafuso.
5 – “Trilho” para encaixar uma tampa deslizante.
O “trilho” está presente nos dois lados da estrutura. E esta característica facilita bastante o acesso à parte interna da estrutura, pois basta deslizar a tampa.
Rampa como base
Quando fui instalar a estrutura na parede ao lado da porta, percebi que o sensor estava sendo bloqueado pelo ‘portal’ da porta. Então, tive que projetar uma espécie de rampa, para elevar o sensor. A imagem abaixo mostra a estrutura em cima da rampa.
Fixação da estrutura na parede
Talvez você tenha reparado que a estrutura não possui nenhum furo para poder fixá-la na parede com um parafuso. Isso, porque a ideia é fixá-la utilizando uma fita dupla face.
Resultados
Para dar um acabamento na estrutura, pintei ela com tinta acrílica preta, passando um primer antes. Veja o resultado abaixo:
Montagem
Ligação do LDR
Para conectar o LDR, é só encaixar ele diretamente no 4º borne parafuso (CN2) e dobrar os terminais dele da seguinte forma:
Depois que a PCB for parafusada na estrutura, resta apenas encaixar o LDR no furo dele (conforme visto no tópico da estrutura).
PCB
A montagem da PCB é bem direta. Depois que os componentes foram soldados, a placa foi parafusada na estrutura com parafusos M3.
Programação do ESP12F
Para programar o ESP12F foi preciso utilizar um conversor USB para TTL e ligar fios na barra de pinos H2 (3,3V, GND, TX e RX). E, antes de fazer upload do código, é necessário trocar o jumper da barra de pinos H1 e reiniciar a placa para ela entrar no modo de programação.
Uma vez tendo feito este procedimento, a placa pode ser programada pelo ar (OTA) acessando o Webserver.
Sensor PAJ7620
Para conectar o sensor na PCB, utilizei 4 cabinhos fêmea-fêmea: 2 para alimentação (3,3V e GND) e 2 para dados. O GND e os pinos de dados foram conectados na barra de pinos S1. Já o 3,3V foi conectado na barra de pinos H1.
Além disto, o sensor foi parafusado na parede da estrutura utilizando um parafuso M3. A imagem abaixo dá uma noção do que foi feito.
Ligação elétrica
É preciso tomar muito cuidado nesta parte, pois você corre o risco de tomar choque e de danificar a placa. Então é 100% recomendado fazer a ligação elétrica com o disjuntor do cômodo desligado. Não me responsabilizo por eventuais danos que possam acontecer no seu procedimento.
Enfim, a ligação elétrica consiste em 5 fios:
- 2 fios para alimentação: fase e neutro.
- 3 fios para a lâmpada: fase e retornos.
- Talvez você só precise de dois fios: fase e retorno. No meu caso são 3, porque o interruptor é three-way.
Para obter estes fios, abri o interruptor que fica ao lado da porta e soldei os fios nos pontos de interesse. Veja abaixo:
Os 2 fios da parte de cima são de alimentação. Eles devem ser ligados no primeiro borne da PCB (CN1).
Já os outros 3 são da lâmpada. O fio verde é a fase e os outros dois são retorno. A fase deve ser ligada no lado direito do segundo borne (CN3), e um retorno no lado esquerdo deste mesmo borne (CN3). Se houver o 2º fio de retorno, é só ligar ele no lado esquerdo do 3º borne (CN4).
Baixa potência no sinal do Wi-fi
Como eu disse no tópico do hardware, a potência do sinal recebido foi prejudicada devido ao posicionamento do ESP12F. E, para piorar, a pintura da caixa também atrapalhou neste ponto. Isso, porque o primer possui diversas partículas metálicas e a tinta acrílica é à base de água. Ou seja, a pintura como um todo, cria uma barreira para as ondas eletromagnéticas da rede Wi-fi.
Para complicar ainda mais, a antena do ESP12 acabou ficando “de costas” para o modem que gera a rede Wi-fi. E este tipo de antena da placa não é muito bom para sinais que são recebidos nas suas “costas”. Para mais detalhes procure “padrão de radiação de antena patch”.
A soma destes efeitos foi negativa de fato e pra piorar eu acabei queimando o ESP12F (imagem abaixo). Ele funcionava “normalmente”, mas não conectava em nenhuma rede.
Antes de descobrir que o ESP12F estava queimado, achei que o problema era a caixa e acabei voltando atrás e utilizando a caixa sem pintar. No fim das contas, acabei tendo que soldar a placa de novo (não consegui tirar o ESP12F sem estragar os pads da PCB).
O importante é que no fim tudo funcionou como o esperado.
Resultados
O projeto com a montagem finalizada pode ser visto nas figuras adiante (caixa pintada antes de descobrir que o ESP12F estava danificado):
E o vídeo do projeto funcionando está no começo deste post.