Jak zbudować własny inteligentny dom w jedno popołudnie?
Published: 2024-02-20 15:24:32

Internet rzeczy (IoT) znacznie się zmienił na przestrzeni lat, a inteligentne domy stają się coraz bardziej powszechne. Dzięki najnowszym osiągnięciom, właściciele domów mają teraz dostęp do różnych technologii inteligentnego domu, od zaawansowanych systemów bezpieczeństwa po inteligentnych asystentów domowych.

Pojawiły się nowe produkty i technologie, takie jak _SmartThings_ i urządzenia _kompatybilne z Apple HomeKit_, a także inteligentne głośniki _z obsługą Spotify_, takie jak _HomePod_, oraz urządzenia zasilane przez _Z-Wave_ i _Zigbee_. Nawet routery są teraz dostarczane z obsługą inteligentnego domu. Pomimo tych zmian, niniejszy artykuł nadal oferuje cenne informacje dla wszystkich zainteresowanych tworzeniem projektów inteligentnego domu.

Dowiedz się więcej o tym, jak PubNub wspiera [tysiące klientów na całym](https://www.pubnub.com/customers/) świecie w naszych zasobach [PubNub for Developers](https://www.pubnub.com/developers/). Można tam również znaleźć kilka historii sukcesu klientów, które ilustrują skuteczność naszej oferty w świecie rzeczywistym. Jeśli masz jakiekolwiek sugestie lub pytania dotyczące treści tego artykułu, skontaktuj się z nami pod adresem [devrel@pubnub.com](mailto:devrel@pubnub.com).

W dzisiejszych czasach technologie IoT sprawiły, że [inteligentne domy i automatyka domowa](https://www.pubnub.com/industry/iot-and-connected-devices/) stały się bardziej powszechne. Właściciele domów korzystają obecnie z zaawansowanych produktów, takich jak pakiet urządzeń Ring do ochrony domu. Asortyment ten obejmuje czujniki ruchu, dzwonki wideo do drzwi, inteligentne zamki i najnowocześniejsze kamery bezpieczeństwa zintegrowane z inteligentnymi produktami domowymi obsługiwanymi przez SmartThings i Apple HomeKit.

Systemy inteligentnego domu mogą również pomagać właścicielom domów w ich codziennych czynnościach. Produkty takie jak Nest Thermostat mogą automatycznie regulować temperaturę, podczas gdy inteligentne wyświetlacze, takie jak Lenovo Smart Display, mogą wyświetlać spersonalizowane treści. Philips Hue umożliwia właścicielom domów sterowanie włącznikami światła za pomocą inteligentnych żarówek, podczas gdy Apple HomePod i produkty Bose z obsługą Spotify oferują funkcje inteligentnego głośnika. Zarządzanie sterowaniem głosowym jest również możliwe przy użyciu osobistych asystentów, takich jak Google Home, Amazon Alexa, Amazon Echo lub Siri, które ułatwiają sterowanie różnymi urządzeniami IoT wraz z ustawianiem timerów. Pomimo obszernej listy istniejących urządzeń inteligentnego domu, niniejszy samouczek poprowadzi Cię przez proces tworzenia własnego systemu inteligentnego domu przy użyciu PubNub.

W PubNub specjalizujemy się w przybliżaniu sfery IoT masom. Dzięki naszemu [API danych w czasie rzeczywistym](https://www.pubnub.com/learn/glossary/what-is-real-time-data/) i [platformie Virtual Spaces](https://www.pubnub.com/learn/glossary/virtual-spaces/), możesz polegać na PubNub, aby zasilić swoje centrum inteligentnego domu. Sprawdźmy, jak stworzyć intuicyjny i wydajny system inteligentnego domu z trzema technologiami inteligentnego domu.

Stwórzmy system inteligentnego domu
-----------------------------------

Co odróżnia inteligentny dom od zwykłego? Dwa kluczowe czynniki: **automatyzacja** i **centralność**. Inteligentny dom automatyzuje podstawowe zadania i może przesyłać informacje w obie strony z centralnej lokalizacji, zazwyczaj aplikacji domowej. W tym samouczku użyjemy PubNub do wdrożenia tych dwóch filarów IoT i zbudujemy następujące technologie:

-   Smart Light - automatyzacja oświetlenia
    
-   Light Detector - centralizacja danych
    
-   Door Detector - centralizacja danych
    

Wymagania
---------

Do stworzenia tych trzech technologii IoT, które tworzą system inteligentnego domu, potrzebujemy następujących materiałów i sprzętu:

### Raspberry Pi

Aby zaprogramować nasze technologie IoT i umożliwić im komunikację między Tobą a Twoim domem, potrzebujesz [mikrokontrolera](https://www.techopedia.com/definition/3641/microcontroller). Jednym z najłatwiejszych w użyciu mikrokontrolerów jest najnowsza wersja [Raspberry Pi](https://www.raspberrypi.com/products/), którą od stycznia 2022 roku jest Raspberry Pi 4. Jeśli nigdy wcześniej go nie konfigurowałeś, [instrukcje](https://www.raspberrypi.org/documentation/setup/) można znaleźć na stronie internetowej produktu.

### Przekaźnik

Aby chronić nasze Raspberry Pi przed wysokimi napięciami, które mogłyby je uszkodzić, będziemy potrzebować [przekaźnika](https://en.wikipedia.org/wiki/Relay). Przekaźnik jest zasadniczo przełącznikiem, który może obsługiwać wysokie prądy i napięcia, dzięki czemu RPi nie musi tego robić.

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jfx/798b2af320f8250dbc8ce0de8bd57659/image4-1024x400.png)

### Lampa

Aby stworzyć inteligentną lampę, będziemy potrzebować prostej, niedrogiej lampy.

### Fototranzystor

Do zbudowania inteligentnego czujnika światła potrzebny będzie [fototranzystor](https://www.electronics-notes.com/articles/electronic_components/transistor/what-is-a-phototransistor-tutorial.php). Element ten działa jak przełącznik, umożliwiając przepływ prądu tylko w obecności światła, co czyni go idealnym czujnikiem do określania, czy światła w domu są włączone.

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jfy/e1a23b21d6c4ebae2e8564dba4fa99ea/image1-1024x768.png)

### Folia aluminiowa i drut

Aby stworzyć czujnik drzwiowy, należy użyć podkładek kontaktowych z folii cynowej, które umożliwiają przepływ prądu w przypadku zetknięcia się podkładek. W ten sposób można przymocować podkładkę do drzwi i ich ramy, tak aby za każdym razem, gdy drzwi są zamknięte, podkładki stykały się i informowały Raspberry Pi, że nasze drzwi są zamknięte. Będziesz musiał stworzyć dwie podkładki z folii cynowej, z przewodami podłączonymi do każdej z nich. Przymocuj jedną podkładkę do drzwi, a drugą do ramy za pomocą taśmy malarskiej.

![](https://www.pubnub.com/cdn/3prze68gbwl1/2E3nPnFTq0dJS77tTCxdGt/a40b63f3c1130fcef370ff8945ee8953/iot-tin-foil-prep.png)

Przejdźmy teraz do konfiguracji sprzętu.

Konfiguracja sprzętu
--------------------

### Inteligentna lampa

Aby stworzyć inteligentną lampę z dowolnej zwykłej lampy, należy rozdzielić kabel zasilający na dwie części (oczywiście po odłączeniu) i zdjąć część obudowy, aby odsłonić przewody. Każda lampa ma kabel zasilający (zazwyczaj czerwony) i kabel uziemiający (zazwyczaj czarny).

![](https://www.pubnub.com/cdn/3prze68gbwl1/3X0oSvQDbmvFgd8N9hFwO8/863deb74f4c162236b1c213266929df9/IoT_Splice_Power_Cable.png)

Teraz chwyć przekaźnik i podłącz przewody uziemienia z powrotem razem, podłącz jeden koniec przewodu zasilającego do portu NO (normalnie otwartego) przekaźnika, a drugi koniec do portu NC (normalnie zamkniętego) przekaźnika.

![](https://www.pubnub.com/cdn/3prze68gbwl1/7k8iovdFS1eXjN4W6JWvNr/259aa20723db1ac47dbe1d3371ed42c3/IoT_Relay_Connections.png)

Teraz, aby podłączyć moduł lampy-przekaźnika do RPi, podłącz je do pinów GPIO RPi.

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jg3/f16339a7dabec603ee165f67f535ece1/image8-1024x601.png)

### Czujniki światła

Obwód czujnika światła jest znacznie prostszy w implementacji. Podłącz fototranzystor do jednego z pinów GPIO RPI.

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jg4/f0789c8071f37ec279a90dafc868118c/image10-1024x904.png)

### Czujnik drzwi

W przypadku czujnika drzwi, podłącz jeden pad do pinu GPIO na RPi, a drugi pad do masy (dla celów diagramu pady są reprezentowane jako diody LED).

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jg5/9a1f1a3135aaf16f027810de40443f68/image2-1024x894.png)

Projektowanie systemu
---------------------

Przed rozpoczęciem implementacji kodu upewnij się, że założyłeś darmowe [konto PubNub](https://admin.pubnub.com/#/register), ponieważ będziesz potrzebował kluczy publikowania/subskrybowania do wysyłania informacji przez sieć PubNub.

### Włącz SSH

Protokół Secure Shell (SSH) umożliwia użytkownikom zdalny dostęp do terminali RPi z komputerów przez WiFi. W połączeniu z GitHub użytkownicy mogą przesyłać kod ze swoich komputerów do zdalnego repozytorium, SSH do terminala Pi i pobierać kod bezprzewodowo. Pozwala to na szybszy i płynniejszy proces rozwoju.

Aby włączyć SSH na swoim RPi, postępuj zgodnie z [prostymi i szybkimi instrukcjami](https://www.raspberrypi.org/documentation/remote-access/ssh/).

### Pobieranie bibliotek urządzeń i zależności

W przypadku naszych urządzeń, aby je włączyć, konieczne jest podanie napięcia wyjściowego 1 lub 0 z RPI. I odwrotnie, czujniki dają RPi napięcie wejściowe 1 lub 0, w zależności od tego, czy są mokre czy suche. Obie te funkcje wymagają użycia pinów GPIO RPi.

Ponieważ będziesz kodować w Pythonie, przydatne będzie zainstalowanie [biblioteki GPIO Zero](https://gpiozero.readthedocs.io/en/stable/), która pozwoli ci wykonywać proste wywołania funkcji w celu aktywacji lub odczytu pinów.

_UWAGA: Należy pamiętać, że biblioteki te muszą być zainstalowane na RPi poprzez SSH-ing do urządzenia i uruchomienie poniższych poleceń._

```js
sudo apt install python-gpiozero
```

### Tworzenie aplikacji za pomocą PubNub

[Pełny kod tego projektu znajduje się w tym repozytorium.](https://github.com/PubNubDevelopers/beginner-smarthome) Utwórz skrypt Pythona, aby połączyć nasze czujniki z Internetem. Otwórz nowy dokument w swoim ulubionym edytorze tekstu i zaimportuj biblioteki i inne zależności, aby umożliwić urządzeniom komunikację w sieci PubNub.

```js
#---------------Library Setup----------------#
import pubnub
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNOperationType, PNStatusCategory
 
from gpiozero import Button, LED
from time import sleep
 
#--------------------------------------------#
 
 
 
 
#----------------PubNub Setup----------------#
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "YOUR SUBSCRIBE KEY"
pnconfig.publish_key = "YOUR PUBLISH KEY"
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
#--------------------------------------------#
```

Musisz powiedzieć Raspberry Pi, które urządzenia są podłączone do którego z jego pinów:

```js
#------------Sensor Declarations-------------#
#lamp is connected to GPIO4 as an LED
lamp = LED(4)
 
#door sensor is connected to GPIO3 as a Button
door_sensor = Button(3)
#light sensor is connected to GPIO14 as a Button
light = Button(14)
#--------------------------------------------#
```

_UWAGA: Lampa jest zadeklarowana jako dioda LED, ponieważ chcesz nią sterować tak, jakby była zwykłą diodą LED. Czujniki są inicjowane jako przyciski, ponieważ wysyłają stały aktywny sygnał w taki sam sposób, jak przycisk po przytrzymaniu lub naciśnięciu. Na tym polega magia biblioteki GPIO Zero, ponieważ interfejs z czujnikami i urządzeniami nie wymaga wysiłku._

Należy również utworzyć zmienną licznika, aby wiedzieć, ile razy nasze drzwi zostały otwarte:

```js
#door counter
doorCount = 0
```

Aby nasza lampa IoT mogła wchodzić w interakcje z klientem, musimy wykorzystać dwukierunkową funkcję pub/sub PubNub. Wymaga to dodania listenera do zarządzania przychodzącymi wiadomościami i skonfigurowania subskrypcji do nasłuchiwania na określonym kanale.

```js
class MySubscribeCallback(SubscribeCallback):
    def status(self, pubnub, status):
        # The status object returned is always related to subscribe but could contain information about subscribe, heartbeat, or errors
        # use the operationType to switch on different options
        if status.operation == PNOperationType.PNSubscribeOperation or status.operation == PNOperationType.PNUnsubscribeOperation:
            if status.category == PNStatusCategory.PNConnectedCategory:
                # This is expected for a subscribe, this signifies no error or issue exists
            elif status.category == PNStatusCategory.PNReconnectedCategory:
                # This usually occurs if subscribe temporarily fails but reconnects. This indicates there was a temporary error but it has already been resolved
            elif status.category == PNStatusCategory.PNDisconnectedCategory:
                # This is the expected category for an unsubscribe. This means there was no error in unsubscribing from everything
            elif status.category == PNStatusCategory.PNUnexpectedDisconnectCategory:
                # This is usually an issue with the internet connection, this is an error, handle appropriately. A retry will be initiated automatically.
            elif status.category == PNStatusCategory.PNAccessDeniedCategory:
                # This indicates that PAM does not permit this client to subscribe to this channel and channel group configuration. This constitutes a specific error
            else:
                # This is usually an issue with the internet connection, this is an error, handle appropriately. A retry will be initiated automatically.
        elif status.operation == PNOperationType.PNSubscribeOperation:
            # Heartbeat operations can indeed encounter errors, so it is essential to verify if there's an error first. For more detailed information on how to configure heartbeat notifications through the status PNObjectEventListener callback, please refer to [PNConfiguration heartbeat config](https://www.pubnub.com/docs/sdks/javascript/api-reference/pn-configuration)
            if status.is_error():
                # There was an error with the heartbeat operation, handle here
            else:
                # Heartbeat operation was successful
        else:
            # Encountered unknown status type
```

W powyższym wywołaniu zwrotnym `obecność` obsługuje przychodzące dane obecności, podczas gdy `wiadomość` obsługuje polecenia lampy. Włączamy lampę, jeśli klient wyśle wiadomość "ON". I odwrotnie, jeśli wiadomość brzmi "OFF", wyłączamy lampę.

```js
def presence(self, pubnub, presence):
    pass  # handle incoming presence data
 
def message(self, pubnub, message):
    #message handler for Lamp commands
    #Turn the lamp on if client receives the message “ON”
    if message.message == 'ON':
        lamp.on()
        #let your subscriber client know that the lamp has been turned on
        pubnub.publish().channel('ch1').message("lamp has been turned on").sync()
        sleep(3)
    #Turn the lamp on if client receives the message “OFF”
    elif message.message == 'OFF':
        lamp.off()
        #let your subscriber client know that the lamp has been turned off
        pubnub.publish().channel('ch1').message("lamp has been turned off").sync()
```

Następnie upewniamy się, że nasz program dodaje funkcję `MySubscribeCallback()` i subskrybuje wybrany kanał, w tym przypadku "ch1".

```js
pubnub.add_listener(MySubscribeCallback())
#make sure to subscribe to the channel of your choice. In this case, we chose to create a channel called “ch1” to publish to
pubnub.subscribe().channels('ch1').execute()
```

Zwróć uwagę na obsługę zdarzeń wiadomości. Za każdym razem, gdy program otrzymuje wiadomość od klienta aplikacji, analizuje ją za pomocą `message.message`. Następnie należy utworzyć programy obsługi zdarzeń za pomocą instrukcji if, aby włączyć lub wyłączyć lampę za pomocą polecenia GPIO . `on` `(` `)` lub `.off()`.

Na koniec należy pamiętać, że gdy wiadomość jest publikowana z powrotem do klienta, użytkownik jest informowany, że jego żądanie zostało pomyślnie wykonane. W tym przypadku informujesz klienta, czy lampa jest włączona, czy wyłączona.

Ta sekcja jest opcjonalna (ponieważ nie jest używana w tym programie), ale można utworzyć wywołanie zwrotne wydawcy w celu wykonania funkcji za każdym razem, gdy wiadomość jest publikowana.

```js
def publish_callback(result, status):
    pass
    # Handle PNPublishResult and PNStatus
```

Ostatni segment programu będzie stale sprawdzał wejścia czujników, aby sprawdzić, czy czujniki coś wykrywają. Główna pętla while, będąca swego rodzaju "routerem", wielokrotnie sprawdza wejścia: \`while True:\`. W ramach tej głównej pętli while można skonstruować pętle podrzędne, aby sondować czujniki. Ponieważ czujniki zostały zainicjalizowane jako przyciski z biblioteki GPIO Zero, wymagana jest funkcja \`.is\_held\`.

Nawet jeśli nie używamy przycisku, czujniki działają tak, jakby były przyciskami, ponieważ symulują ten sam "sygnał przytrzymania przycisku", gdy są aktywne (tj. wykrywają coś). Istnieje kilka fragmentów kodu, które sondują czujnik drzwi i światła, sprawdzając ich stan. Jeśli czujnik jest aktywny, wiadomość jest publikowana z powrotem do klienta, informując go, czy czujnik jest włączony, czy wyłączony. Podobne zasady można zastosować do innych produktów inteligentnego domu, takich jak SmartThings, urządzenia Apple HomeKit, a nawet HomePod, znacznie rozszerzając możliwości inteligentnego domu.

### Przesyłanie kodu

Aby przesłać kod do Raspberry Pi, zawsze zatwierdzaj kod w repozytorium, a następnie przeciągnij go do Raspberry Pi. Otwórz terminal, wprowadź katalog roboczy i zatwierdź kod w chmurze za pomocą tych poleceń.

```js
git add .
git commit -m "updates"
git push
```

SSH do Raspberry Pi i przejdź do odpowiedniego katalogu.

```js
ssh pi@<YOUR IP ADDRESS>
cd <your directory>
```

Następnie pobierz kod z chmury i uruchom go. Być może podczas oczekiwania poświęcisz trochę czasu na posłuchanie ulubionej playlisty Spotify lub ustawienie timerów dla swoich zadań. Wielozadaniowość to jedna z zalet połączonego świata!

```js
git pull
python <Your program>.py
```

### Tworzenie klienta za pomocą PubNub

Następnie musimy zbudować skrypt klienta, który umożliwi korzystanie z telefonu komórkowego lub komputera do wysyłania i odbierania danych do i z naszych czujników. Wymaga to utworzenia pliku HTML, który używa przycisków do publikowania poleceń do Raspberry Pi i pól tekstowych do pobierania danych z Raspberry Pi. Można to osiągnąć za pomocą prostego skryptu HTML i dodania kilku przycisków, znaczników ID i PubNub JavaScript SDK. System ten jest wystarczająco elastyczny, aby zintegrować się z różnymi protokołami, w tym Z-Wave i ZigBee, otwierając dodatkowe obszary rozwoju.

```js
<!DOCTYPE html>
<html>
  <body>
    <button type="button" onclick="publish('ON')">Lamp ON</button>
    <button type="button" onclick="publish('OFF')">Lamp OFF</button>
    <p id="lights">Lights are on?</p>
    <script src="https://cdn.pubnub.com/sdk/javascript/pubnub.4.20.2.js"></script>
    <script>
    var pubnub = new PubNub({
      publishKey : 'pub-c-2d8f55f6-daa7-467b-923b-6a1e6570c9fc',
      subscribeKey : 'sub-c-1575c412-2116-11e8-a7d0-2e884fd949d2',
      });
      function publish(a){
        var publishConfig = 
        {
          channel : "ch1",   //Your publishing channel name
          message : a
        };
        pubnub.publish(publishConfig, function(status, response){
          console.log(status, response);
        });
      }
```

Na koniec należy nasłuchiwać kanału, na którym Raspberry Pi publikuje dane z czujnika światła. Możemy utworzyć instancję słuchacza za pomocą następującego bloku kodu:

```js
    pubnub.addListener({
            message: function(m) {
                // handle message
                var channelName = m.channel; // The channel for which the message belongs
                var channelGroup = m.subscription; // The channel group or wildcard subscription match (if exists)
                var pubTT = m.timetoken; // Publish timetoken
                var msg = m.message; // The Payload
                var publisher = m.publisher; //The Publisher
                document.getElementById("lights").innerHTML = msg;
                console.log(msg);
            },
            presence: function(p) {
                // handle presence
                var action = p.action; // Can be join, leave, state-change or timeout
                var channelName = p.channel; // The channel for which the message belongs
                var occupancy = p.occupancy; // No. of users connected with the channel
                var state = p.state; // User State
                var channelGroup = p.subscription; //  The channel group or wildcard subscription match (if exists)
                var publishTime = p.timestamp; // Publish timetoken
                var timetoken = p.timetoken;  // Current timetoken
                var uuid = p.uuid; // UUIDs of users who are connected with the channel
            },
            status: function(s) {
                var affectedChannelGroups = s.affectedChannelGroups;
                var affectedChannels = s.affectedChannels;
                var category = s.category;
                var operation = s.operation;
            }
        });
        pubnub.subscribe({
            channels: ['ch2'],
            
        });
    </script>
  </body>
</html>
```

Zwróć uwagę, że zasubskrybowałeś ch2. Wynika to z faktu, że chcesz mieć dedykowany kanał dla danych z czujnika światła, aby nie musieć odróżniać danych od innych czujników. Jeśli zapomniałeś opublikować dedykowany kanał w procesie aplikacji, upewnij się, że wróciłeś i zrobiłeś to.

Po zapisaniu skryptu otwórz plik w przeglądarce internetowej i powinieneś otrzymać coś takiego:

![](https://www.pubnub.com/cdn/3prze68gbwl1/asset-17suaysk1qa1jg6/06a91807b15406afcdf3499f565d6c1d/image7-1024x431.png)

Ukończyłeś implementację trzech prostych inteligentnych urządzeń domowych na Raspberry Pi! Przetestuj swój kod, łącząc się przez ssh z Raspberry Pi, aby uruchomić kod Pythona, a następnie wejść w interakcję z programem klienckim. Powinieneś być w stanie kontrolować swoją inteligentną lampę za pomocą dwóch przycisków, a także zobaczyć monity tekstowe, jeśli drzwi są otwarte lub światła są włączone. Udało ci się stworzyć inteligentny system domowy wykorzystujący podłączone urządzenia komunikujące się z PubNub.

Jeśli chcesz dowiedzieć się więcej o tym, jak zasilać aplikacje IoT i systemy inteligentnego domu, zapoznaj się z naszymi zasobami IoT.

-   [Interakcja z demonstracją pulpitu nawigacyjnego IoT w czasie rzeczywistym](https://www.pubnub.com/demos/iot-dashboard/)
    
-   [Jak opracować rozwiązanie IoT](https://www.pubnub.com/how-to/develop-an-iot-solution/)
    
-   [Tworzenie rozwiązania IoT przy użyciu PubNub](https://www.pubnub.com/tutorials/iot-dashboard/)
    
-   [Pięć wymagań dotyczących zabezpieczania komunikacji IoT](https://www.pubnub.com/resources/whitepaper/5-key-requirements-to-securing-iot-communications/)
    
-   [MQTT](https://www.pubnub.com/guides/mqtt/)
    

W razie jakichkolwiek pytań lub wątpliwości prosimy o kontakt [pod adresem](mailto:devrel@pubnub.com) devrel@pubnub.com.