Automatyka domowa z Alexą

Kilka lat temu, zbadałem tutaj, jak używać Alexy, inteligentnego osobistego asystenta, który stał się popularny dzięki Amazon Echo i Echo-Dot, w projektach automatyki domowej: Kiedy IoT spotyka się z AI: Automatyka domowa z Alexą i NodeMCU oraz Alexa – NodeMCU: Prosta emulacja WeMo.

Alexa jest zdolna do interakcji głosowej, odtwarzania muzyki, tworzenia list rzeczy do zrobienia, ustawiania alarmów, przesyłania strumieniowego podcastów, odtwarzania audiobooków oraz dostarczania informacji o pogodzie, ruchu drogowym i innych informacji w czasie rzeczywistym. Alexa może również kontrolować kilka inteligentnych urządzeń, używając siebie jako centrum automatyki domowej. Będziemy używać w tym projekcie, "Echo Dot", które pozwala użytkownikom aktywować urządzenie za pomocą słowa budzenia, takiego jak "Alexa" lub "Komputer", jak w "Star Treku"!

W przestrzeni automatyki domowej, Alexa może współdziałać z kilkoma różnymi urządzeniami, takimi jak Philips Hue, Belkin Wemo, Sonoff, itp. W poprzednich projektach, emulowaliśmy urządzenia WeMo, używając biblioteki fauxmoESP, która obecnie wydaje się być przestarzała i nie jest odpowiednio utrzymywana. Tutaj będziemy używać Espalexa, łatwej w użyciu biblioteki Arduino kompatybilnej zarówno z ESP8266 jak i ESP32.

Poniższy schemat blokowy pokazuje, co będzie rozwijane w naszym projekcie:

Poniższy filmik, pokazuje jak projekt będzie wyglądał na końcu:

Instalacja płytek ESP

W Arduino IDE Preferences -> Additional boards Manager URLs należy wpisać: 

https://dl.espressif.com/dl/package_esp32_index.json, http://arduino.esp8266.com/stable/package_esp8266com_index.json

Następnie w Arduino IDE Tools/Boards Manager, Install boards:

W tym projekcie użyjemy NodeMCU, ale kod może być łatwo przystosowany do pracy z ESP32. Zatem również jego zainstalujmy:

Rozkład pinów ESP8266 NodeMCU:

Biblioteka Espalexa

Espalexa umożliwia ustawienie wartości zakresu (np. jasności, temperatury) i opcjonalnie koloru, oprócz standardowego sterowania włącz/wyłącz. Możemy na przykład powiedzieć – "Alexa, włącz światło do 75% ".

Espalexa emuluje część protokołu SSDP oraz API Philips hue, tylko na tyle, aby mógł być wykryty i kontrolowany przez Alexę.

Domyślnie możliwe jest dodanie do 10 urządzeń, ponieważ każdy "slot" urządzenia zajmuje pamięć, nawet jeśli żadne urządzenie nie jest zainicjowane. Można zmienić maksymalną liczbę urządzeń, dodając np. 

#define ESPALEXA_MAXDEVICES 20

przed wywołaniem biblioteki:

#include <Espalexa.h>

Zalecane jest ustawienie MAXDEVICES na dokładną liczbę urządzeń, które chcemy dodać, aby zoptymalizować wykorzystanie pamięci. Aby zainstalować bibliotekę, przejdźmy do Arduino IDE Tools/Manage Libraries i wpiszmy espalexa:

Prototyp automatyki domowej

Nasz projekt automatyki domowej zostanie stworzony w oparciu o cztery inteligentne urządzenia, które mogą być indywidualnie zdalnie sterowane. Załóżmy jednak, że chcemy pogrupować nasze urządzenia, które mają być używane w naszym domu. Co należy zrobić?

Na przykład załóżmy, że nasz dom ma dwa pokoje:

• Sypialnię
• Salon

Teraz załóżmy, że chcemy mieć jedną lampę i jedno gniazdko w każdym pokoju. Pogrupujmy więc nasze cztery urządzenia tak, jak pokazano na schemacie blokowym na wstępie:

Sypialnia

• Światło 2
• Gniazdko 1 (wentylator)

Salon

• Światło 1
• Gniazdko 2 (Brzęczyk)

Nasz projekt automatyki domowej będzie wyglądał mniej więcej tak:

Montaż sprzętu do testowania

Do celów testowych, jako "urządzenia IoT" zostaną użyte cztery kolorowe LEDy. Należy je zamontować w sposób pokazany na schemacie i spisany poniżej:

==> Czerwony LED (Light1) ==> NodeMCU D1 (GPIO5) – Salon

==> Zielony LED (Outlet1) ==> NodeMCU D2 (GPIO4) – Salon

==> Niebieski LED (Light2) ==> NodeMCU D5 (GPIO14) – Sypialnia

==> Żółty LED (Outlet2) ==> NodeMCU D6 (GPIO12) – Sypialnia

Czerwony i zielony LED będą symulować urządzenia, które mają być zainstalowane w "Salonie", a niebieski i żółty LED będą symulować urządzenia zainstalowane w „Sypialni"

Tworzenie naszych urządzeń IoT w Arduino IDE

Po pierwsze, musimy wywołać biblioteki:

#include <ESP8266WiFi.h>
#include <Espalexa.h>

Poniżej definicje pinów NodeMCU, które mają być podłączone do urządzeń (w fazie testowej będą to LEDy, a w końcowym projekcie wejścia przekaźnikowe):

#define RelayPin1 5  //D1
#define RelayPin2 4  //D2
#define RelayPin3 14 //D5
#define RelayPin4 12 //D6

Gdy mamy już cztery urządzenia, należy zdefiniować przynajmniej cztery bezpośrednie funkcje callback:

void device1Changed(uint8_t brightness);
void device2Changed(uint8_t brightness);
void device3Changed(uint8_t brightness);
void device4Changed(uint8_t brightness);

Parametr jasność zawiera nowy stan urządzenia (0:wyłączony, 255:włączony, 1-254:przyciemniony), który zostanie wysłany przez Alexę po wywołaniu tej funkcji callback (wywołania zwrotnego). Ale funkcja callback może być w rzeczywistości dowolną funkcją do wykonania pod komendą Alexy. Zdefiniujemy więc tutaj trzy dodatkowe funkcje specjalne do wywołania, które będą obsługiwać wiele urządzeń IoT:

void devFunc1Changed(uint8_t brightness);
void devFunc2Changed(uint8_t brightness);
void devFunc3Changed(uint8_t brightness);

Powyższe funkcje callback będą powiązane z:

• Wszystkimi urządzeniami domowymi (Światło1, Światło2, Gniazdko1 i Gniazdko2 czyli Light1, Light2, Outlet1 i Outlet2)
• Salon (Światło1 i Gniazdko1)
• Sypialnia (Światło2 i Gniazdko2)

Tak więc Alexa będzie w rzeczywistości obsługiwać siedem "urządzeń IoT". Dla każdego z nich musimy zdefiniować unikalną nazwę, która będzie wywoływana przez Alexę:

// nazwy urządzeń
String Device_1_Name = "Red light";
String Device_2_Name = "Green light";
String Device_3_Name = "Blue light";
String Device_4_Name = "Yellow light";
 
// nazwy funkcji urządzeń (device_function)
String Dev_Func_1_Name = "Living Room";
String Dev_Func_2_Name = "Bed Room";
String Dev_Func_3_Name = "All Home Devices";

W fazie testowania będziemy nazywać LEDy "{jego kolor} Light". Na naszym finalnym projekcie możemy zmienić te zmienne na ich ostateczne nazwy ("Light 1", "Outlet 2", itd.). Ostatnią, ale nie mniej ważną rzeczą jest zadeklarowanie zmiennych, które będą używane przez espalexę:

Espalexa espalexa;

i do komunikacji:

boolean connectWifi();
boolean wifiConnected = false;
const char* ssid = „NASZE SSID";
const char* password = „NASZE HASŁO";

W fazie Setup, oprócz standardowych definicji pinów i szeregowych prędkości transferu oraz procedur startu komunikacji, należy mieć każde z urządzeń IoT z prawidłowo skojarzoną własną nazwą i uruchomioną espalexa:

// Zdefiniuj tutaj swoje urządzenia.
espalexa.addDevice(Device_1_Name, device1Changed);
espalexa.addDevice(Device_2_Name, device2Changed);
espalexa.addDevice(Device_3_Name, device3Changed);
espalexa.addDevice(Device_4_Name, device4Changed);
 
// Zdefiniuj tutaj funkcje swoich urządzeń.
espalexa.addDevice(Dev_Func_1_Name, devFunc1Changed);
espalexa.addDevice(Dev_Func_2_Name, devFunc2Changed);
espalexa.addDevice(Dev_Func_3_Name, devFunc3Changed);
 
espalexa.begin();

Funkcja pętli powinna być bardzo prosta:

void loop()
{
espalexa.loop();
delay(1);
}

Ostatnim zabiegiem będzie stworzenie funkcji callback, albo najlepiej, co musi być zrobione, gdy Alexa wyśle komendę. Poniższa funkcja callback może być dostosowana do wszystkich czterech urządzeń IoT:

void deviceNChanged(uint8_t brightness)
{
  //Kontrolowanie urządzenia 
  if (brightness == 255)
    {
      digitalWrite(RelayPinN, HIGH);
      Serial.println("DeviceN ON");
    }
  else
  {
    digitalWrite(RelayPinN, LOW);
    Serial.println("DeviceN OFF");
  }
}

Zmieniając "N" w powyższym kodzie na 1, 2 3 i 4, uzyskamy cztery bezpośrednie funkcje callback. Pamiętajmy, że parametr jasności wysyłany przez Alexę, zawiera nowy stan urządzenia, który będzie: 0 ==> OFF; 255 ==> ON, oraz 1-254 dla "przyciemnionego światła".

Tak więc, możemy rozszerzyć powyższą prostą funkcję ON-OFF do specjalnej funkcji, w której można kontrolować natężenie światła. Zrobimy to dla device1 (czerwony LED):

void device1Changed(uint8_t brightness){
//Kontrolowanie urządzenia
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("%");
}
}

Kompletny kod można pobrać z mojego GitHuba: Alexa_NodeMCU_Home_Automation

Po skompilowaniu kodu w Arduino IDE i wgraniu go do NodeMCU, na monitorze szeregowym można zobaczyć wymieniane komunikaty. Gdy NodeMCU jest podłączony do sieci WiFi, powinien pojawić się podobny komunikat (dane sieciowe):

• Korzystanie z aplikacji Alexa w smartfonie
• Prosząc Alexę, aby zrobić to bezpośrednio za pomocą polecenia głosowego, jak np.: "Alexa, znajdź urządzenia".

Po 45 sekundach powinniśmy otrzymać potwierdzenie od Alexy, że zostało znalezione siedem urządzeń. Możemy to zobaczyć na zakładce "Light" jak pokazano poniżej:

Gdy Alexa wykryje nasze urządzenia, możemy wydawać jej polecenia głosowe, jak pokazano poniżej:

Poniższy zrzut ekranu pokazuje odpowiedź monitora szeregowego.

Montaż kompletnego zestawu sprzętu

Zamiast LEDów i rezystorów, należy podłączyć wyjścia GPIO do modelu czterokanałowego przekaźnika, jak pokazano poniżej:

W zasadzie można użyć tego samego kodu opracowanego na potrzeby testów, ALE należy potwierdzić logikę stosowaną przez moduł przekaźnika. W powyższym module, na przykład, należy utrzymywać wejścia "Open" lub HIGH, zmieniając je na LOW, aby aktywować wyjście przekaźnikowe. Tak więc, kod musi być zmieniony zgodnie z tym.

• W fazie setup() należy zdefiniować wyjścia GPIO jako HIGH
• W funkcjach CallBack należy zmienić HIGH na LOW i odwrotnie

Poprawność działania przekaźników można potwierdzić zarówno poprzez dźwięk zamykania przekaźnika wyjściowego, jak i świecenie czerwonej diody w module.

Gdy wszystko działa już poprawnie przychodzi czas na kompletną instalację naszych "inteligentnych urządzeń", czyli dwóch stałych „lamp" i dwóch "gniazdek". Zmieńmy im odpowiednio nazwy:

• Light One (Światło pierwsze)
• Light One (Światło drugie)
• Outlet One (Gniazdko pierwsze)
• Outlet Two (Gniazdko drugie)

// nazwy urządzeń
String Device_1_Name = "Light One"; 
String Device_2_Name = "Light Two";
String Device_3_Name = "Outlet One";
String Device_4_Name = "Outlet Two";

Aby zakończyć nasz projekt tak jak pokazano na filmie na początku tego poradnika, podłączamy kilka urządzeń, które mają być sterowane przez przekaźniki. W moim przypadku używam dwóch LEDów jako lampek i podłączam wentylator do gniazdka 1 oraz brzęczyk do gniazdka 2 (aby symulować urządzenie takie jak na przykład radio). Poniżej schemat przedstawiający zainstalowane urządzenia.
 
Zauważmy, że gdy przekaźniki są prawdziwe, możemy zainstalować prawdziwe lampy i urządzenia, które mają być kontrolowane za pomocą Alexy.

Podsumowanie

Jak zawsze mam nadzieję, że ten projekt pomoże innym odnaleźć się w ekscytującym świecie elektroniki i IoT!

Proszę odwiedzić mój GitHub, aby zobaczyć zaktualizowane pliki: Alexa_NodeMCU_Home_Automation.