ESP8266 & Apple HomeKit – Zacznijmy od początku

Istnieje całkiem sporo różnego rodzaju systemów inteligentnego domu, zwanych również smart home. Każdy ma swoje wady i zalety, a wybór odpowiedniego systemu zależy tak naprawdę od indywidualnych preferencji użytkownika. Jednym z takich systemów jest HomeKit od firmy Apple. W tym oraz kolejnych materiałach z tej serii chciałbym opowiedzieć wam nieco o sposobie integracji HomeKita i dobrze wszystkim znanych modułów ESP8266. Pokaże wam jak skonfigurować taki moduł, tak aby jego działaniem można było sterować z poziomu iPhona, MacBooka lub Apple Watcha. Poza tym do wyjść naszego mikrokontrolera podłączymy różnego rodzaju moduły peryferyjne, których działaniem będzie sterować ESP.  

Zobacz też:

Co-kryje-wnetrze-zarowki-1-1024x576

Czym jest Apple HomeKit?

Widok aplikacji Dom na komputerze

Apple HomeKit to nic innego jak jeden z systemów umożliwiających zbudowanie inteligentnego domu. Na każdym sprzęcie firmy z Cupertino domyślnie znajduje się aplikacja Dom, która pozwala sterować różnego rodzaju akcesoriami oraz odczytywać dane z czujników.  Wspiera ona wiele typów urządzeń wykonawczych, na których niekoniecznie musi być umieszczone logo nadgryzionego jabłka.

Wszystkimi akcesoriami możemy sterować z dowolnego urządzenia Apple podłączonego do tej samej sieci. Chcąc uzyskać dostęp zdalny, należy wyposażyć się w oryginalny hub, może to być Apple HomePod lub Apple TV. Niestety bez tego nie ma możliwości sterowania urządzeniami z dowolnego miejsca na świecie. Dodając do systemu hub, zyskujemy też możliwość automatyzacji i synchronizacji, czyli inteligentnego sterowania akcesoriami według wcześniej ustalonego planu – lampka przy łóżku uruchamia się w dni robocze o 6 rano, gdy włączamy telewizor, światło przygasa, a klimatyzacja wyłącza się, gdy otwieramy okno. Możliwości jest całkiem sporo i wszystko zależy tak naprawdę od naszej wyobraźni. Poza tym hub pozwala też sterować akcesoriami poprzez asystenta głosowego – Siri.

Hardware i software, czyli co będzie nam potrzebne?

Istnieje całkiem spor różnego rodzaju urządzeń wspieranych przez Apple HomeKit, ale nic nie stoi na przeszkodzie, aby zbudować coś takiego samodzielnie, wystarczy, że mamy moduł ESP8266. Ten niewielki, pochodzący z Chin SoC zyskał sporą popularność przede wszystkim dzięki prostocie użytkowania, niskiej cenie i dużym możliwością. Układ ten wspiera WIFI w standardzie 802.11 b/g/n, dzięki czemu idealnie nadaje się do budowy niewielkich urządzeń IoT.

Moduł ESP8266, a dokładniej model ESP-12E, który wykorzystam w moich poradnikach, może być programowany, między innymi z poziomu dobrze znanego wszystkim elektroniką Arduino IDE. Jednak środowisko trzeba najpierw odpowiednio przygotować.  

  1. Pierwszym krokiem jest dodanie wsparcia dla samego modułu ESP. W tym celu należy otworzyć okno preferencji programu i w polu „Dodatkowe adresy URL dla menadżera płytek” wkleić link, który umieściłem poniżej. Jeśli linków jest więcej, należy rozdzielić je przecinkami. (https://arduino.esp8266.com/stable/package_esp8266com_index.json)

    Po wklejeniu adresu rozwijamy menu dostępnych płytek i otwieramy „Menadżer płytek”, w którym należy odszukać pakiet ESP8266 i go zainstalować.

  2. Drugim krokiem jest dodanie do Arduino IDE odpowiedniej biblioteki wspierającej Apple HomeKit. Możecie pobrać ją tutaj, ściągnięty pakiet zip należy dodać do środowiska. W tym celu w zakładce „Szkic” odszukujemy polecenie „Dodaj bibliotekę .ZIP” i wybieramy chwilę wcześniej pobrany plik.

Tym sposobem przygotowaliśmy środowisko, czyli dodaliśmy obsługę modułów ESP8266 oraz wsparcie dla systemu Apple HomeKit, dzięki dodatkowej bibliotece.

Sterowanie wyjściem ESP8266

Każdy projekt łączący moduł ESP z Apple HomeKit bazuje na trzech plikach, nie będziemy przyglądać się całości, opisze wam tylko główne założenia każdego z nich oraz fragmenty kodu, które należy zmodyfikować „pod siebie”, tak aby zbudować własne urządzenie.

Wszystkie kody dostępne są na moim profilu GitHub, jeśli chcesz pobrać projekt, pozwalający sterować wyjściami ESP8266 kliknij tutaj.

Jak już wspomniałem, kody łączące ESP i Apple HomeKit składają się w rzeczywistości z trzech plików:

  • ESP_HomeKit_Output_control.ino – jest to główny plik, zawierający kod wykonywany przez moduł ESP8266 odwołujący się do pozostałych plików. To tutaj umieszczono podstawowe parametry konfiguracyjne. Poza tym, gdy w przyszłości będziemy podłączać do naszego mikrokontrolera moduły peryferyjne, to ich obsługę opiszemy właśnie w tym miejscu.

  • my_accessory.c – W tym pliku umieszczony został konfiguracja naszego urządzenia jako całości. Znajdziemy tutaj informację o nazwie, numerze seryjnym oraz haśle dostępu pozwalającym połączyć się ze sprzętem z poziomu HomeKit.

  • wifi_info.h – Ostatni z plików, będący plikiem nagłówkowym zawiera informację o sieci, z którą chcemy się połączyć. To tutaj umieścimy jej nazwę oraz hasło.

Gdy wiemy już, z czego składać będzie się nasz projekt, możemy przejść do uruchomienia pierwszego projektu. Będzie to prosty przełącznik, umożliwiający sterowanie wyjściem ESP z poziomu Apple HomeKit. W przykładzie do wyjścia modułu podłączyłem diodę LED, ale nic nie stoi na przeszkodzie, aby podłączyć tam na przykład przekaźnik. Dzięki niemu sterować można innymi, nawet zasilanymi napięciem sieciowym urządzeniami.

//==============================
// HomeKit setup and loop
//==============================

// access your HomeKit characteristics defined in my_accessory.c
extern "C" homekit_server_config_t config;
extern "C" homekit_characteristic_t cha_switch_on;

static uint32_t next_heap_millis = 0;

#define PIN_SWITCH 2

W głównym kodzie zwrócić uwagę musimy tak naprawdę tylko na jedną linijkę kodu. To tutaj umieszczona została definicja pinu, którym chcemy sterować. Innymi słowy, wybieramy tutaj numer wyjścia, którego stan będziemy modyfikować. W przykładzie umieściłem cyfrę 2, co oznacza, że sterować będziemy wyprowadzeniem D4, ponieważ dwójka odnosi się tak naprawdę do oznaczenia GPIO, w tym przypadku GPIO2, wyprowadzone jest na port D4.

homekit_accessory_t *accessories[] = {
    HOMEKIT_ACCESSORY(.id=1, .category=homekit_accessory_category_switch, 
    .services=(homekit_service_t*[]) {
        HOMEKIT_SERVICE(ACCESSORY_INFORMATION, 
        .characteristics=(homekit_characteristic_t*[]) {
            HOMEKIT_CHARACTERISTIC(NAME, "LED Switch"),
            HOMEKIT_CHARACTERISTIC(MANUFACTURER, "HomeKit Rafal"),
            HOMEKIT_CHARACTERISTIC(SERIAL_NUMBER, "0123456"),
            HOMEKIT_CHARACTERISTIC(MODEL, "ESP8266"),
            HOMEKIT_CHARACTERISTIC(FIRMWARE_REVISION, "1.0"),
            HOMEKIT_CHARACTERISTIC(IDENTIFY, my_accessory_identify),
            NULL
        }),
		HOMEKIT_SERVICE(SWITCH, 
		.primary=true, .characteristics=(homekit_characteristic_t*[]){
			&cha_switch_on,
			&cha_name,
			NULL
		}),
        NULL
    }),
    NULL
};

homekit_server_config_t config = {
		.accessories = accessories,
		.password = "111-11-111"
};

W pliku my_accessory.c umieścić możemy identyfikatory naszego urządzenia. Pierwszym z nich jest nazwa, czyli tekst, pod jakim sprzęt będzie widoczny w panelu aplikacji Dom. Przykładowy projekt nazwałem po prostu „LED Switch”, zauważcie, że nazwa występuje w dwóch miejscach.

W kolejnym polu znalazła się informacja o producencie, umieściłem tam tekst „HomeKit Rafal”. Dzięki czemu łatwo jest odróżnić zbudowane przez siebie urządzenie od pozostałych sprzętów innych producentów.

Pozostałe linijki kodu zawierają numer seryjny urządzenia, jego model oraz numeryczne oznaczenie wersji programu.

Na końcu pliku znalazła się bardzo ważna informacja, czyli hasło umożliwiające połączenie się z modułem ESP. W przykładzie składa się ono z samych jedynek, ale budując docelowe urządzenie, warto je zmienić.

const char *ssid = "your-ssid";
const char *password = "your-password";

W ostatnim pliku umieścić musimy informację o sieci, z którą połączyć ma się ESP8266. Jest to jej SSID, czyli nazwa oraz hasło.

Po zmianie kluczowych informacji w kodzie można przygotować testowy obwód oraz zaprogramować moduł ESP. W moim przykładzie do pinu D4 (GPIO2), czyli tego, którego numer umieściłem w główny pliku, podłączyłem diodę LED, dzięki niej będziemy mogli zobaczyć rzeczywiste efekty sterowania mikrokontrolerem.

Konfiguracja urządzenia w aplikacji Dom

Gdy moduł ESP jest już zaprogramowany, możemy dodać go w aplikacji Dom. Najłatwiejszym sposobem jest otwarcie jej na iPhonie i kliknięcie w „+” widoczny przy górnej krawędzi. Następnie wybieramy opcję „Dodaj akcesorium”.

W nowo widocznym oknie, wybieramy „Więcej opcji”, ponieważ ESP nie posiada kodu QR, który można by zeskanować.

Po chwili moduł ESP powinien być widoczny na ekranie jako LED Switch, po jego kliknięciu może pojawić się ostrzeżenia informujące, że akcesorium nie posiada certyfikatu. Należy je zignorować i wybrać opcję „Dodaj mimo to”.

Kolejnym krokiem jest wpisanie kodu konfiguracyjnego, umieściliśmy go na końcu pliku my_accessory.c.

Dalej zostaniemy poproszenie o wybranie pokoju, czyli miejsca, w jakim znajduje się urządzenie. Na potrzeby testu utworzyłem u siebie specjalny pokój o nazwie „Test”. Następnie możemy nazwać dodawany sprzęt, domyślnie przyjmie on nazwę, którą umieściliśmy wcześniej w kodzie.

W ostatnim już kroku poproszeni zostaniemy o wybranie, czym jest nasze urządzenie. Po przejściu przez wszystkie etapy konfiguracji klikamy przycisk „Gotowe”.

Od teraz możemy sterować modułem ESP8266 z poziomu aplikacji Dom na dowolnym sprzęcie firmy z Cupertino. Na filmie powyżej możecie zobaczyć, że mimo skonfigurowania mikrokontrolera z poziomu iPhona od razu można sterować modułem z MacBooka. Jak widać zmieniając położenie switcha na komputerze, zmienia się również stan diody LED podłączonej do ESP. W ten o to prosty sposób połączyliśmy ten niewielki SoC z Apple HomeKit.

Reset ESP i zmiana kodu

void setup() {
	Serial.begin(115200);
	wifi_connect(); // in wifi_info.h
	//homekit_storage_reset(); // to remove the previous HomeKit pairing 
	//storage when you first run this new HomeKit example
	my_homekit_setup();
}

Jest jeszcze jedna kwestia, o której muszę napisać. Chodzi o zerowanie modułu ESP8266 i łączenie się z nim po modyfikacji kodu. Trzeba pamiętać, że po zaprogramowaniu modułu i połączeniu się z nim przez sprzęt Appla ten zostaje zapamiętany, nie tylko w aplikacji Dom, ale także samo ESP zapamiętuje pewne dane konfiguracyjne. Skutkuje to tym, że po drobnej modyfikacji kodu, chociażby nazwy urządzenia to nie będzie dostępne, mówiąc inaczej, nie będzie można się z nim połączyć. Dlatego przy każdorazowej modyfikacji trzeba stosować się do z góry ustalonej procedury.

Chcąc zmienić kod i ponownie połączyć się z urządzeniem, należy od komentować polecenie homekit_storage_reset(); znajdujące się w pliku .ino i wgrać kod. Następnie należy chwilę odczekać, tak aby ESP się uruchomiło. Po tym procesie należy z powrotem za komentować linijkę homekit_storage_reset(); i wgrać nowy kod. Operacja ta wymazuje wszystkie dane konfiguracyjne z ESP i umożliwia ponowne połączenie z Apple HomeKit.

Zobacz też:

Źródła:

  • https://github.com/Mixiaoxiao/Arduino-HomeKit-ESP8266/tree/master
  • https://github.com/esp8266/Arduino

Chcesz być na bieżąco?
Dołącz do newslettera

Otrzymywać będziesz powiadomienia o nowych artykułach oraz informacje o projektach, nad którymi pracuję.

Leave a Comment

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *

Przewiń do góry