História

Há alguns anos, explorei como usar a Alexa, uma assistente pessoal inteligente popularizada pela Amazon Echo e Echo-Dot, em projetos de automação residencial:

Quando a IoT encontra a IA: Automação residencial com Alexa e NodeMCU e Alexa – NodeMCU: emulação WeMo simplificada.

A Alexa é capaz de interação por voz, reprodução de música, listas de tarefas, configuração de alarmes, streaming de podcasts, reprodução de audio livros, além de fornecer previsões acerca do clima, trânsito e outras informações em tempo real.

A Alexa também pode controlar vários dispositivos inteligentes usando a si mesma como um hub de automação residencial. Usaremos neste projeto, o “Echo Dot“, que permite aos usuários ativar o dispositivo usando uma palavra de alerta, como “Alexa” ou até mesmo “Computador”, como em “Star Trek!”.

No espaço da automação residencial, A Alexa pode interagir com diversos dispositivos diferentes como Philips Hue, Belkin Wemo, Sonoff, etc. 

Nos projetos anteriores (listados acima), foram emulados dispositivos do tipo WeMo, usando a biblioteca fauxmoESP, que infelizmante está desatualizada, não possuíndo atualmante uma manutenção adequada.  Neste projeto, usaremos Espalexa , uma biblioteca Arduino fácil de usar compatível com ESP8266 e ESP32.

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

O vídeo abaixo mostra como o projeto ficará no final:

1. Lista de materiais (BoM)

(Todos os valores são referenciados em USD)

• NodeMCU ESP8266-12E ( $ 6,49)
  
• Echo Dot (a partir de $ 24,99)
  
• Módulo de relé de 4 canais ( $ 7,79)
  
• Fonte de alimentação externa 5V ou bateria
  
• 4 x LEDs coloridos
  
• 4 resistores de 220 ohm
   

2. Instale placas ESP

Em Preferências do IDE Arduino -> URLs de gerenciador de placas adicionais, insira com:

https://dl.espressif.com/dl/package_esp32_index.json

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Em seguida, em Arduino IDE Tools / Boards Manager, instale as placas:

Neste projeto, usaremos o NodeMCU, mas o código poderia ser facilmente adaptado para funcionar também com ESP32. Então, vamos instalá-lo também:

Pinagem NodeMCU ESP8266:

3. A Biblioteca Espalexa
Espalexa permite definir uma gama de valores, por exemplo, brilho, temperatura e, opcionalmente, uma cor, além do controle liga / desliga padrão. Por exemplo, você pode dizer — “Alexa, ligue a luz para 75%”.

Espalexa emula partes do protocolo SSDP e da API hue Philips, apenas o suficiente para ser descoberto e controlado por Alexa.

Por padrão, é possível somar um total de 10 dispositivos uma vez que cada “slot” de dispositivo ocupa memória, mesmo se nenhum dispositivo for inicializado. Você pode, por exemplo, alterar o número máximo de dispositivos acionando o código,:

#define ESPALEXA_MAXDEVICES 20

A definicão anterior deve estar no código antes de se chamar a biblioteca:

#include <Espalexa.h>

Recomenda-se definir MAXDEVICES para o número exato de dispositivos que se deseja adicionar para otimizar o uso da memória.

Para instalar a biblioteca, acesse Arduino IDE Tools / Manage Libraries e entre com espalexa:

4. Protótipo de automação residencial

Nosso projeto de Domótica será criado com quatro dispositivos que poderão ser controlados individualmente à distância.

Mas suponha que desejemos agrupar nossos dispositivos para serem usados ​​em nossa casa. O que deveria ser feito?

Por exemplo, suponha que nossa casa tenha:

• 2 Quartos
  
• 2 Salas de estar
  

Agora, suponha que você queira uma lâmpada e uma tomada em cada cômodo. Então, agrupemos nossos quatro dispositivos, conforme mostrado no diagrama de blocos, da introdução deste artigo:

Quarto

• Luz 2
  
• Saída 1 (Ventilador)
  

Sala de estar

• Light1
  
• Saída 2 (campainha)

Nosso Projeto de Automação Residencial ficará mais ou menos assim:

5. Montagem do HW para teste
Para fins de teste, quatro LEDs coloridas serão usados ​​como “dispositivos IoT”. Eles devem ser instalados conforme mostrado no diagrama e listados abaixo:

==> LED vermelho (luz1) ==> NodeMCU D1 (GPIO5) – sala de estar

==> LED Verde (Outlet1) ==> NodeMCU D2 (GPIO4) – Sala de Estar

==> LED Azul (Luz2) ==> NodeMCU D5 (GPIO14) – Quarto

==> LED amarelo (Outlet2) ==> NodeMCU D6 (GPIO12) – Quarto

Os LEDs vermelho e verde simulam os dispositivos instalados na “sala” (Living Room) e os LEDs azul e amarelo simulam os instalados no “quarto” (Bed Room).

6. Criando nossos dispositivos IoT no IDE Arduino

Primeiro, devemos chamar as bibliotecas:

#include <ESP8266WiFi.h>

#include <Espalexa.h>

A seguir, as definições dos pinos NodeMCU a serem conectados aos dispositivos (na fase de teste estarão os LEDs e no projeto final, as entradas dos relés):

#define RelayPin1 5  //D1

#define RelayPin2 4  //D2

#define RelayPin3 14 //D5

#define RelayPin4 12 //D6

Após a definição da pinagem dos 4 dispositivos, definiremos 4 funções de retorno de chamada direta (“CallBack”):

void device1Changed(uint8_t brightness);

void device2Changed(uint8_t brightness);

void device3Changed(uint8_t brightness);

void device4Changed(uint8_t brightness);

O parâmetro brilho contém o novo estado do dispositivo (0: desligado, 255: ligado, 1-254: esmaecido) que será enviado pela Alexa quando essa função de retorno de chamada for chamada.

Mas a função de retorno de chamada pode ser qualquer função a ser executada sob o comando da Alexa, assim, definiremos três novas funções especiais que lidarão com os múltiplos dispositivos IoT:

void devFunc1Changed(uint8_t brightness);

void devFunc2Changed(uint8_t brightness);

void devFunc3Changed(uint8_t brightness);

As funções de retorno de chamada acima serão associadas a:

• Todos os dispositivos domésticos (Light1, Light2, Outlet1 e Outlet2)
  
• Sala de estar (Light1 e Outlet1)
  
• Quarto com cama (Light2 e Outlet2)
  

A Alexa vai de fato lidar com 7 “dispositivos IoT”. Para cada um deles, devemos definir um nome único a ser chamado por Alexa:

// device names

String Device_1_Name = “Red light”;

String Device_2_Name = “Green light”;

String Device_3_Name = “Blue light”;

String Device_4_Name = “Yellow light”;

———

// device_function names

String Dev_Func_1_Name = “Living Room”;

String Dev_Func_2_Name = “Bed Room”;

String Dev_Func_3_Name = “All Home Devices”;

Durante a fase de teste, chamaremos os LEDs de “{sua cor} Light”. Em nosso projeto final, podemos alterar essas variáveis ​​pelo seu nome final (“Light 1”, “Outlet2”, etc).

Por último, mas não menos importante, devemos declarar as variáveis ​​a serem utilizadas pela espalexa:

Espalexa espalexa;

E para comunicação:

boolean connectWifi();

boolean wifiConnected = false;

const char* ssid = “YOUR SSID HERE”;

const char* password = “YOUR PASSWORD HERE”;

Na fase de configuração, você deve, além das definições usuais de pinos e seriais, iniciar os procedimentos de comunicação, ter cada um dos dispositivos IoT com seu nome devidamente associado e a biblioteca ESPAlexa iniciada:

// Define your devices here.

espalexa.addDevice(Device_1_Name, device1Changed);

espalexa.addDevice(Device_2_Name, device2Changed);

espalexa.addDevice(Device_3_Name, device3Changed);

espalexa.addDevice(Device_4_Name, device4Changed);

// Define your devices functions here.

espalexa.addDevice(Dev_Func_1_Name, devFunc1Changed);

espalexa.addDevice(Dev_Func_2_Name, devFunc2Changed);

espalexa.addDevice(Dev_Func_3_Name, devFunc3Changed);

espalexa.begin();

A função de loop deve ser muito simples:

void loop()

{

espalexa.loop();

delay(1);

}

O último procedimento será a criação de funções de callback, ou melhor, o que deve ser feito quando a Alexa receber um comando.

A função de retorno do comando abaixo pode ser adaptada para todos os 4 (quatros) dispositivos IoT:

void deviceNChanged(uint8_t brightness)

{

 //Control the device

 if (brightness == 255)

   {

     digitalWrite(RelayPinN, HIGH);

     Serial.println(“DeviceN ON”);

   }

 else

 {

   digitalWrite(RelayPinN, LOW);

   Serial.println(“DeviceN OFF”);

 }

}

Alterando-se “N” no código acima por 1, 2, 3 e 4 , se obterá as quatro funções de retorno de chamada direta. Lembre-se que o parâmetro de brilho enviado pela Alexa, contém o novo estado do dispositivo que será:

• 0 ==> OFF;
  
• 255 ==> ON

1 a 254 ==> DIMMED LIGHT (brilho da luz)

Podemos expandir a função simples ON-OFF acima para uma função especial onde a intensidade da luz pode ser controlada. Faremos isso para o dispositivo 1 (o LED vermelho):

void device1Changed(uint8_t brightness){

//Control the device

if (brightness == 255)

{

 digitalWrite(RelayPin1, HIGH);

 Serial.println(“Device1 ON”);

}

else if (brightness == 0)

{

 digitalWrite(RelayPin1, LOW);

 Serial.println(“Device1 OFF”);

}

else

{

 int brigh_perc = (brightness/255.)*100;

 analogWrite(RelayPin1, brightness);

 Serial.print(“Device1 Brightness: “);

 Serial.print(brigh_perc);

 Serial.println(“%”);

}

}

Lembre-se de que o NodeMCU possui saídas PWM que podem ser usadas com a função analogWrite () do Arduino.

Se um ESP32 for usado, uma função PWM deve ser criada, pois uma como analogWrite () não existe.

O código completo pode ser baixado do meu GitHub:

Alexa_NodeMCU_Home_Automation

Atenção: não se esqueça de alterar as credenciais wi-fi fictícias com as suas.

Depois de compilar o código no Arduino IDE e carregá-lo no NodeMCU, você pode ver as mensagens trocadas no monitor Serial. 

Assim que o NodeMCU estiver conectado ao seu wi-fi, uma mensagem semelhante (com os dados da sua rede) deve aparecer:

Consideramos que você já possui uma Alexa devidamente instalada na mesma rede onde o seu NodeMcu está conectado.

Agora, vamos pedir a Alexa para encontrar seus dispositivos. Existem dois métodos para se fazer isso:

• Usando o aplicativo Alexa em seu smartphone
  
• Pedir a Alexa para fazer isso diretamente usando um comando de voz, como: “Alexa, discovery devices” (Alexa, encontre dispositivos).

Após 45 segundos, você deve receber a confirmação de Alexa de que sete dispositivos foram encontrados. Você pode ver isso na página “Light tab” do aplicativo, conforme abaixo:

A captura de tela abaixo mostra a resposta do monitor serial.

7. Montagem do HW completo

Em vez de LEDs e resistores, as saídas GPIOs devem ser conectadas ao modelo de relé de 4 canais conforme abaixo:

Não alimente o Módulo de Relé diretamente do pino de saída NodeMcu 5V. 

Use uma fonte de alimentação externa para isso. Uma fonte de alimentação 1A deve ser suficiente. Confirme com o fabricante do Módulo de Relé se outra versão é usada. Não se esqueça de conectar os GNDs todos juntos.

Em princípio, pode-se usar o mesmo código desenvolvido para teste, MAS você deve confirmar a lógica do Módulo Relé. 

Por exemplo, no módulo acima, você deve manter as entradas “Abertas” ou ALTAS, mudando para BAIXAS para ativar a saída do Relé. Portanto, o código deve ser alterado de acordo.

• Durante a fase de configuração (), defina as saídas GPIOs como HIGH
  
• No CallBack, as funções mudam de HIGH para LOW e vice-versa

Você pode confirmar se os relés estão funcionando corretamente pelo som do relé de saída fechando e por um led vermelho no módulo.

Depois que tudo estiver funcionando corretamente é o momento de instalação completa dos nossos “dispositivos inteligentes”, que são duas “Lâmpadas” fixas e 2 “Tomadas gerais”, vamos renomeá-los adequadamente:

• Light One (Lâmpada 1)
  
• Light Two (Lâmpada 1)
  
• Outlet One (Tomada 1)
  
• Outlet Two (Tomada 2)

// device names

String Device_1_Name = “Light One”;

String Device_2_Name = “Light Two”;

String Device_3_Name = “Outlet One”;

String Device_4_Name = “Outlet Two”;

Conforme mostrado no vídeo no início deste tutorial, para completar nosso projeto, conecte alguns dispositivos para serem controlados por relés. 

No meu caso, utilizo dois LEDs como lâmpadas e coloco um ventilador na saída 1 e um buzzer na saída 2 (para simular um aparelho como um rádio, por exemplo). 

O diagrama abaixo mostra os aparelhos instalados:

Observe que você pode instalar lâmpadas CA reais e aparelhos a serem controlados usando a Alexa, uma vez que os relés podem lidar com eles.

8. Considerações Finais sobre as “Funções do Dispositivo”

Partindo do conceito de emular dispositivos IoT simples, como WeMo ou Philips Hue, também usamos Alexa para acionar funções mais complexas: “the Device Functions”. Nessas funções, várias saídas foram usadas como um grupo de dispositivos divididos por cômodos.

Em meu tutorial, Computer, Firing All Weapons, algumas das armas Star Trek Enterprise, como Photon Torpedos e Phasers, foram simuladas usando tais funções.

Esta é uma ferramenta poderosa a ser explorada no campo da IoT, onde um simples comando de voz pode acionar processos mais complexos usando microcontroladores, como pode ser observado no vídeo abaixo:

Conclusão
Como sempre, espero que este projeto possa ajudar outras pessoas a encontrar seu caminho no emocionante mundo da eletrônica e da IoT!

Visite meu GitHub para arquivos atualizados:

Alexa_NodeMCU_Home_Automation

NOTA: O artigo foi escrito originalmente em inglês, por isso alguns nome e termos foram mantidos em seu original para ser compatível com o código e vídeos. Vale ressaltar que o Echo-Dot a partir da geração 3, já funciona com comandos em português. O código pode ser facilmente alterado, somente com os nomes dos dispositivos em português:
Ex:
– “Lâmpada Vermelha”
– Tomada do Quarto
– etc.

Saludos do sul do mundo!

Vejo vocês no meu próximo tutorial!

Obrigado