Quando o IoT encontra a Inteligência Artificial: Automação residencial com Alexa e NodeMCU

Exploraremos neste tutorial, como usar a Alexa, um assistente pessoal inteligente desenvolvido pela Amazon Lab126, popularizado pelo Amazon Echo e Echo-Dot.

Alexa é capaz de interação de voz, reprodução de música, fazer listas de tarefas, configurar alarmes, transmitir podcasts, tocar audiobooks e fornecer informações meteorológicas, de trânsito e outras informações em tempo real. Alexa também pode controlar vários dispositivos inteligentes usando-se como um hub de automação residencial. Vamos usar neste projeto, o “Echo-Dot”, que permite aos usuários ativar o dispositivo usando um wake-word (no caso, “Alexa”).

No espaço da Domótica (automação residencial), Alexa pode interagir com vários dispositivos diferentes como Philips Hue, Belkin Wemo, SmartThings, etc. Em nosso caso, emularemos dispositivos do tipo WeMo, como estes mostrados abaixo (mas por apenas uma fração de seu preço):

WeMo é uma série de produtos da Belkin International, Inc. que permitem aos usuários controlar eletrônicos domésticos de qualquer lugar. A suite de produtos inclui um interruptor, sensor de movimento, Insight Switch, interruptor de luz, câmera e app. O WeMo Switch (nosso caso aqui) pode ser conectado a qualquer tomada de casa, que pode ser controlada a partir de um iOS ou Android smartphone executando o WeMo App, via rede doméstica WiFi ou rede de telefonia móvel.

O diagrama abaixo mostra o que será desenvolvido em nosso projeto:

E o vídeo abaixo, mostra como ficará o projeto ao final:

1: Lista de materiais (BoM)

Valores referenciais em USD

• NodeMCU ESP8266-12E ($8.79)

• Echo Dot (2nd Generation) – Black ($49.99)

• Mini BreadBoard ($1.00)

• 400-point Experiment Breadboard Breadboard ($ 4.97)

• 4-Channel Relay Module ($8.49)

• LEDs (vermelho e verde) ($1.00)

• 2 x Resistor (220 ohm)

• 5V 2 Terminals Electronic Continuous Sound Buzzer ($1.00)

• Male-Female Dupont Cables ($1.00)

• DC 5V 0.2A Cooling Fan ($4.00)

• Fonte de alimentação externa de 5V DC ou batteria

2: Emulando o WeMo Switch

 

Os dispositivos WeMo utilizam UPnP para executar certas funções através da rede. A função de detecção do dispositivo começa com o Echo ou Echo-Dot (em nosso caso aqui) à procura de dispositivos WeMo utilizando UPnP. O dispositivo então responde ao Echo-Dot com seu URL utilizando HTTP sobre UDP. OEcho-Dot então solicita a descrição do dispositivo utilizando esse URL HTTP. A descrição é então retornada como uma resposta HTTP. Neste ponto, o Echo-Dot já “descobriu” o dispositivo. O Echo-Dot simplesmente se conectará ao WeMo através da interface HTTP e emitirá um comando do tipo “SetBinaryState”. O WeMo então “obedecerá”, retornando uma confirmação via HTTP. O diagrama  acima resume a comunicação entre o Echo-Dote o WeMo Switch.

Este tutorial não entrará em muito mais detalhes sobre este tópico. Procurei compilar informações obtidas em vários projetos da web, simplificando sua apresentação de maneira a apresentar uma visão geral sobre o uso da Alexa na automação residencial .

Algumas excelentes fontes de informação sobre o assunto poderão ser encontradas nos links abaixo:

HOW TO MAKE AMAZON ECHO CONTROL FAKE WEMO DEVICES, escrito por Rick Osgut

Building an IoT power switch with the ESP8266 (and control it with your Amazon Echo!)  escrito por  Wai Lun

Amazon Alexa + WeMos switch made with Arduino D1 Mini , codigos desenvolvidos por Aruna Tennakoon:

Projects using NodeMCU, conjunto de códigos desenvolvidos por Christopher Kuzma

Dito isto, com o que fui aprendendo nos diversos sites acima terminei chegando a um código de teste, o qual você poderá baixar desde meu GitHib: Alexa_LED_Control_V2_EXT.ino

Verifique se você possui todas as bibliotecas necessárias para executar o código, como: ESP8266WiFi.h, ESP8266WebServer.h e WiFiUdp.h. Caso não as tenha, você poderá obtê-las aqui:  Arduino core for ESP8266 WiFi chip.

3: Criando nosso WeMo Switch com o NodeMCU

Para o nosso primeiro teste, conectemos um LED ao NodeMCU pino D1 como mostrado no diagrama abaixo:

Abra o arquivo  Alexa_LED_Control_V2_EXT.ino , o qual você baixou de meu GitHub e entre com suas credenciais de rede:

const char* ssid = "YOUR SSID";
const char* password = "YOUR PASSWORD";

Confirme se você definiu corretamente o pino onde o LED está conectado e dê um nome ao seu dispositivo. Alexa reconhecerá seu dispositivo por este nome:

String device_name = "lights";  // Name of device
int relayPin = D1;              // Pin to toggle

No meu caso, o dispositivo será denominado “lights“. Aqui neste primeiro exemplo o dispositivo acionará um único LED, mas o NodeMCU poderia estar conectado a um relé que por sua vez poderia ligar as luzes de meu laboratório, por exemplo.

Carregue o código no NodeMCU.

No monitor serial você pode ver a mensagem “Connecting to UDP” e “Connection Successful”. Isso significa que do lado NodeMCU tudo está OK.

Estarei levando em consideração que voce já tenha o Echo-Dot instalado em sua rede., bem como o Alexa App em seu smartphone. Os procedimentos para a instalação de ambos é bem simples e basta seguir as instruções da Amazon fornecidas junto com o dispositivo.

Agora, necessitamos que a Alexa encontre seu dispositivo. Existem dois métodos para isso:

• Utilizando o aplicativo Alexa no smartphone como mostrado nas fotos abaixo. Em nosso caso, a Alexa encontrará “1 Smart Home device”:  lights WeMo Switch.

• Pedindo diretamente à Alexa através de um comando de voz, como por exemplo: “Alexa, Find connected devices” como poderá ser visto no vídeo abaixo:

Uma vez que a Alexa descobriu seu dispositivo, você poderá usar comandos de voz para o acionamento do dispositivo como mostrado abaixo:

4: Acionando vários dispositivos ao mesmo tempo

Aprofundando um pouco mais,  desenvolveremos um sistema um pouco mais realista que acionará vários dispositivos ao mesmo tempo. Desta maneira, o projeto poderia ser usado em projetos envolvendo automação residencial  (domótica).

Usaremos um módulo de relé de 4 canais para controlar 2 lâmpadas e 2 tomadas.

Esta parte do projeto foi baseada em grande parte no tutorial de Charles Gantt,

How To: DIY Home Automation With NodeMCU and Amazon Alexa.

Siga as instruções abaixo:

Conecte as entradas dos relés com os pinos do NodeMCU conforme descrito abaixo:

int relayOne = 14;  // NodeMCU pin D5
int relayTwo = 15;  // NodeMCU pin D8
int relayThree = 3; // NodeMCU pin RX
int relayFour = 1;  // NodeMCU pin TX

Nossos “smart devices” serão 2 lâmpadas fixas (“Lights”)e 2 tomadas para uso geral (“Outlets”). Como vimos nas etapas anteriores, deveremos emular “WeMo Devices” e para fazer isso devemos nomeá-los como abaixo:

• Light One

• Light Two

• Outlet One

• Outlet Two

Em seguida, deveremos defini-los em nosso código para que a Alexa consiga encontrá-los. Também definiremos 2 comandos (on e off) e um número de porta de comunicação (“Port”) para cada dispositivo.

O formato geral deve ser:

lightOne = new Switch("Light One", 80, lightOneOn, lightOneOff);
lightTwo = new Switch("Light Two", 81, lightTwoOn, lightTwoOff);
outletOne = new Switch("Outlet One", 82, outletOneOn, outletOneOff);
outletTwo = new Switch("Outlet Two", 83, outletTwoOn, outletTwoOff);

Agora, você deve definir as 2 funções relacionadas a cada condição do dispositivo:

Para as lampadas:

void lightOneOn() {
  Serial.print("Switch 1 turn on ...");
  digitalWrite(relayOne, LOW);   // sets relayOne on
}

void lightOneOff() {
  Serial.print("Switch 1 turn off ...");
  digitalWrite(relayOne, HIGH);   // sets relayOne off
}

void lightTwoOn() {
  Serial.print("Switch 2 turn on ...");
  digitalWrite(relayThree, LOW);   // sets relayTwo on
}

void lightTwoOff() {
  Serial.print("Switch 2 turn off ...");
  digitalWrite(relayThree, HIGH);   // sets relayTwo Off
}

E para as tomadas:

void outletOneOn() {
  Serial.print("Socket 1 turn on ...");
  digitalWrite(relayFour, LOW);   // sets relayThree on
}

void outletOneOff() {
  Serial.print("Socket 1 turn off ...");
  digitalWrite(relayFour, HIGH);   // sets relayThree off
}

void outletTwoOn() {
  Serial.print("Socket 2 turn on ...");
  digitalWrite(relayTwo, LOW);   // sets relayFour on
}

void outletTwoOff() {
  Serial.print("Socket 2 turn off ...");
  digitalWrite(relayTwo, HIGH);   // sets relayFour off
}

Uma vez que estamos utilizando relés, poderíamos testar o projeto com  qualquer tipo de dispositivo real como TVs, geladeiras, etc. Obviamente que pelas especificações dos relés utilizados neste projeto, os dispositivos estariam limitados a 250VAC/10A ou 30 VDA/30A.

Em meu caso, decidi testar os 4 WeMo switches com dispositivos alimentados externamente com 5 V DC .

• Como “Light 1”,  usarei um LED vermelho

• Como “Light 2”, usarei um LED verde

• Como “Outlet 2”, usarei um pequeno buzzer (pense em um rádio, aparelho de som…)

• Como “Outlet 1”, usarei um pequeno ventilador

Abaixo o diagrama elétrico com as conexões:

Com o HW pronto, baixe o código de meu GitHub: NODEMCU_ALEXA_WeMos_4X_Serial_Monitor_EXT.ino

Entre com suas credenciais de rede:

const char* ssid = "YOUR SSID";
const char* password = "YOUR PASSWORD";

E pronto!

Siga o mesmo procedimento como definido na etapa anterior para permitir que a Alexa encontre seus 4 dispositivos.

O vídeo abaixo mostra uma demonstração desta etapa:

5: Aplicação em Domótica (Automação Residencial)

Neste ponto do projeto, possuímos 4 dispositivos inteligentes funcionando adequadamente, os quais podem ser ativados e desativados individualmente. Mas suponha que queremos agrupá-los de maneira a serem utilizados em nossa casa. O que deveria ser feito?

Por exemplo, suponha que a nossa casa tenha 2 cômodos:

• Quarto (“Bed Room”)

• Sala (“Living Room”)

Agora, suponha que você queira ter uma lâmpada e uma tomada em cada habitação. O que devemos fazer, é agrupar nossos 4 dispositivos como mostrado no diagrama de blocos da introdução:

• Quarto (Bed Room)
  • Light 2
  • Outlet 1 (Ventilador)
• Sala (Living Room)
  • Light1
  • Outlet 2 (Buzzer)

Também criaremos outro grupo para lidar com todos os dispositivos, ativando / desativando todos os dispositivos ao mesmo tempo.

Criaremos uma versão 2 de nosso código onde teremos  3 novos “switches” que agora devem ser também  ser identificados pela Alexa. Para isto, adicionemos as seguintes linhas ao nosso código:

1. Definição das “Switches”:

Switch *allDevices = NULL;
Switch *bedRoom = NULL;
Switch *livingRoom = NULL;

2. Declaração dos “callbacks” para os novos grupos de dispositivos:

void allDevicesOn();
void allDevicesOff();
void bedRoomOn();
void bedRoomOff();
void livingRoomOn();
void livingRoomOff();

1. No setup(), devemos associar os switches com os novos callbacks and Ports (Lembre-se que temos um máximo de 14 dispositivos que podem ser manipulados com este código):

allDevices = new Switch("All Devices", 84, allDevicesOn, allDevicesOff);
bedRoom = new Switch("Bed Room", 85, bedRoomOn, bedRoomOff);
livingRoom = new Switch("Living Room", 86, livingRoomOn, livingRoomOff);

1. Adicionando “Switches upnp Broadcast Responder” ao setup():

upnpBroadcastResponder.addDevice(*allDevices);
upnpBroadcastResponder.addDevice(*bedRoom);
upnpBroadcastResponder.addDevice(*livingRoom);

1. Adicionando as linhas ao loop():

allDevices->serverLoop();
bedRoom->serverLoop();
livingRoom->serverLoop();

1. E finalmente, criemos as funções para os “grupos de dispositivos” com as ações a serem executadas quando a Alexa receber um comando de voz:

void allDevicesOn() 
{
  Serial.print("All Devices turn on ...");
  digitalWrite(relayOne, LOW);   // sets relay1 on
  digitalWrite(relayTwo, LOW);   // sets relay2 on
  digitalWrite(relayThree, LOW);   // sets relay3 on
  digitalWrite(relayFour, LOW);   // sets relay4 on
}

void allDevicesOff() 
{
  Serial.print("All Devices turn off ...");
  digitalWrite(relayOne, HIGH);   // sets relay1 off
  digitalWrite(relayTwo, HIGH);   // sets relay2 off
  digitalWrite(relayThree, HIGH);   // sets relay3 off
  digitalWrite(relayFour, HIGH);   // sets relay4 off
}

void bedRoomOn() 
{
  Serial.print("Bed Room turn on ...");
  digitalWrite(relayThree, LOW);   // sets relay3 on
  digitalWrite(relayFour, LOW);   // sets relay4 on
}

void bedRoomOff() 
{
  Serial.print("Bed Room turn off ...");
  digitalWrite(relayThree, HIGH);   // sets relay3 off
  digitalWrite(relayFour, HIGH);   // sets relay4 off
}

void livingRoomOn() 
{
  Serial.print("Living Room turn on ...");
  digitalWrite(relayOne, LOW);   // sets relay1 on
  digitalWrite(relayTwo, LOW);   // sets relay2 on
}

void livingRoomOff() 
{
  Serial.print("Living Room turn off ...");
  digitalWrite(relayOne, HIGH);   // sets relay1 off
  digitalWrite(relayTwo, HIGH);   // sets relay2 off
}

Este procedimento de 6 passos poderá ser utilizado para qualquer comando, dispositivo ou grupo de dispositivos que você deseja adicionar ao seu projeto.

Você poderá baixar o código completo desta etapa. desde meu GitHub:

NODEMCU_ALEXA_WeMos_4X_V2_EXT

Depois que o código é enviado e executado pelo NodeMCU, é hora de solicitar Alexa que “localize os novos dispositivos”. Como explicado anteriormente, você poderá fazê-lo usando um comando de voz ou pelo Alexa App. Em ambos casos, o resultado poderá ser verificado no aplicativo como mostrado abaixo. Sete dispositivos (“WeMo Switches”) deverão ser encontrados agora pela Alexa:

• Living Room

• Bed Room

• All Devices

• Outlet One

• Outlet Two

• Light One

• Light Two

O vídeo abaixo mostra como nosso projeto completo de Automação Residencial funcionará:

6: Conclusão

Home-Automation-with-Alexa-and-NodeMCU

E não deixe de visitar e seguir minha página: MJRoBot.org no Facebook

Saludos desde el sur del mundo!

Até o próximo tutorial!

Obrigado

Marcelo