So bauen Sie Ihr eigenes Smart Home an einem Nachmittag
Published: 2024-02-20 15:45:22

Das Internet der Dinge (Internet of Things, IoT) hat sich in den letzten Jahren stark gewandelt, und intelligente Häuser werden immer häufiger eingesetzt. Mit den neuesten Entwicklungen haben Hausbesitzer nun Zugang zu einer Vielzahl von Smart-Home-Technologien, die von ausgeklügelten Sicherheitssystemen bis hin zu intelligenten Hausassistenten reichen.

Es sind neue Produkte und Technologien aufgetaucht, wie _SmartThings_ und _Apple HomeKit-kompatible_ Geräte neben _Spotify-fähigen_ intelligenten Lautsprechern wie dem _HomePod_ und _Z-Wave-_ und _Zigbee-gesteuerten_ Geräten. Sogar Router werden jetzt mit Smart Home-Unterstützung angeboten. Trotz dieser Änderungen bietet dieser Artikel immer noch wertvolle Einblicke für alle, die an der Entwicklung von Smart Home-Projekten interessiert sind.

Erfahren Sie mehr darüber, wie PubNub [Tausende von Kunden weltweit](https://www.pubnub.com/customers/) unterstützt, in unseren [PubNub for Developers](https://www.pubnub.com/developers/) Ressourcen. Dort finden Sie auch mehrere Erfolgsgeschichten von Kunden, die die Wirksamkeit unserer Angebote in der Praxis veranschaulichen. Wenn Sie Anregungen oder Fragen zum Inhalt dieses Artikels haben, können Sie sich gerne an [devrel@pubnub.com](mailto:devrel@pubnub.com) wenden.

Heutzutage haben IoT-Technologien das [intelligente Haus und die Hausautomatisierung](https://www.pubnub.com/industry/iot-and-connected-devices/) weiter verbreitet. Hausbesitzer verwenden jetzt fortschrittliche Produkte wie die Geräteserie von Ring für die Heimsicherheit. Dazu gehören Bewegungssensoren, Videotürklingeln, intelligente Schlösser und hochmoderne Sicherheitskameras, die in Smart-Home-Produkte integriert sind, die von SmartThings und Apple HomeKit unterstützt werden.

Smart-Home-Systeme können Hausbesitzer auch bei ihren täglichen Routinen unterstützen. Produkte wie Nest Thermostat können die Temperatur automatisch regulieren, während intelligente Displays wie das Smart Display von Lenovo personalisierte Inhalte anzeigen können. Philips Hue ermöglicht es Hausbesitzern, Lichtschalter über intelligente Glühbirnen zu steuern, während Apple HomePod und Spotify-fähige Bose-Produkte intelligente Lautsprecherfunktionen bieten. Sprachsteuerung ist auch über persönliche Assistenten wie Google Home, Amazon Alexa, Amazon Echo oder Siri möglich, die die Steuerung verschiedener IoT-Geräte und die Einrichtung von Zeitschaltuhren ermöglichen. Trotz der umfangreichen Liste bestehender Smart-Home-Geräte, führt Sie dieses Tutorial in die Entwicklung Ihres eigenen Smart-Home-Systems mit PubNub.

Wir von PubNub haben uns darauf spezialisiert, die Welt des IoT der breiten Masse näher zu bringen. Mit unserer [Echtzeit-Daten-API](https://www.pubnub.com/learn/glossary/what-is-real-time-data/) und der [Virtual Spaces Platform](https://www.pubnub.com/learn/glossary/virtual-spaces/) können Sie sich auf PubNub verlassen, wenn es darum geht, Ihren Smart-Home-Hub zu betreiben. Lassen Sie uns herausfinden, wie Sie mit drei Smart-Home-Technologien ein intuitives und effizientes Smart-Home-System aufbauen können.

Bauen wir ein Smart Home-System auf
-----------------------------------

Was unterscheidet ein Smart Home von einem normalen Haus? Zwei entscheidende Faktoren: **Automatisierung** und **Zentralität**. Ein Smart Home automatisiert grundlegende Aufgaben und kann Informationen in beide Richtungen von einer zentralen Stelle aus übermitteln, in der Regel einer Home-App. In diesem Tutorial werden wir PubNub verwenden, um diese beiden Säulen des IoT zu implementieren und die folgenden Technologien aufzubauen:

-   Smart Light - Automatisierung der Beleuchtung
    
-   Lichtdetektor - Datenzentralisierung
    
-   Türdetektor - Datenzentralisierung
    

Anforderungen
-------------

Für die Erstellung dieser drei IoT-Technologien, die ein Smart-Home-System bilden, benötigen wir die folgenden Materialien und Hardware:

### Raspberry Pi

Um unsere IoT-Technologien zu programmieren und ihnen die Kommunikation zwischen Ihnen und Ihrem Haus zu ermöglichen, benötigen Sie einen [Mikrocontroller](https://www.techopedia.com/definition/3641/microcontroller). Einer der am einfachsten zu verwendenden Mikrocontroller ist die neueste Version des [Raspberry Pi](https://www.raspberrypi.com/products/), der ab Januar 2022 Raspberry Pi 4 heißt. Wenn Sie noch nie einen Raspberry Pi eingerichtet haben, finden Sie die [Anleitung](https://www.raspberrypi.org/documentation/setup/) auf der Website des Produkts.

### Relais

Um unseren Raspberry Pi vor hohen Spannungen zu schützen, die ihn beschädigen könnten, benötigen wir ein [Relais](https://en.wikipedia.org/wiki/Relay). Ein Relais ist im Grunde ein Schalter, der mit hohen Strömen und Spannungen umgehen kann, so dass der RPi dies nicht tun muss.

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

### Eine Lampe

Um eine intelligente Lampe zu bauen, brauchst du eine einfache, preiswerte Lampe.

### Fototransistor

Um einen intelligenten Lichtsensor zu bauen, brauchst du einen [Fototransistor](https://www.electronics-notes.com/articles/electronic_components/transistor/what-is-a-phototransistor-tutorial.php). Dieses Bauteil funktioniert wie ein Schalter, der nur bei Licht Strom fließen lässt. Damit ist er der ideale Sensor, um festzustellen, ob das Licht im Haus eingeschaltet ist.

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

### Zinnfolie und Draht

Um einen Türsensor herzustellen, müssen Sie Kontaktpads aus Zinnfolie verwenden, die Strom durchlassen, wenn die Pads in Kontakt kommen. Auf diese Weise können Sie ein Pad an einer Tür und ihrem Rahmen befestigen, so dass die Pads jedes Mal, wenn die Tür geschlossen wird, Kontakt herstellen und dem Raspberry Pi mitteilen, dass die Tür geschlossen ist. Sie müssen zwei Pads aus Stanniolfolie anfertigen und mit Drähten versehen, die mit jedem der Pads verbunden sind. Befestigen Sie ein Pad an der Tür und das andere mit Malerband am Rahmen.

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

Gehen wir nun zur Einrichtung der Hardware über.

Hardware-Einrichtung
--------------------

### Intelligente Lampe

Um aus einer gewöhnlichen Lampe eine intelligente Lampe zu machen, müssen Sie das Stromkabel in zwei Teile spleißen (natürlich im ungesteckten Zustand) und einen Teil des Gehäuses entfernen, um die Drähte freizulegen. Jede Lampe hat ein Stromkabel (normalerweise rot) und ein Erdungskabel (normalerweise schwarz).

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

Nehmen Sie nun Ihr Relais und verbinden Sie die Erdungsdrähte wieder miteinander, schließen Sie ein Ende des Stromkabels an den NO (Normalerweise offen) Anschluss des Relais an und das andere Ende an den NC (Normalerweise geschlossen) Anschluss des Relais.

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

Um nun das Lampen-Relais-Modul mit dem RPi zu verbinden, schließen Sie diese an die GPIO-Pins des RPi an.

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

### Lichtsensoren

Der Lichtsensor-Schaltkreis ist viel einfacher zu implementieren. Schließen Sie Ihren Fototransistor an einen der GPIO-Pins des RPi an.

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

### Türsensor

Für den Türsensor verdrahten Sie ein Pad mit einem GPIO-Pin des RPi und das andere Pad mit Masse (im Diagramm sind die Pads als LEDs dargestellt).

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

Entwerfen Sie das System
------------------------

Bevor Sie mit der Implementierung des Codes beginnen, sollten Sie sich für ein kostenloses [PubNub-Konto](https://admin.pubnub.com/#/register) anmelden, da Sie Ihre Publish/Subscribe-Schlüssel benötigen, um Informationen über das PubNub-Netzwerk zu senden.

### Aktivieren Sie SSH

Das Secure-Shell-Protokoll (SSH) ermöglicht den Fernzugriff auf den RPi vom Computer aus über WiFi. In Verbindung mit GitHub können Benutzer Code von ihren Computern zu einem entfernten Repository pushen, sich per SSH in das Pi-Terminal einloggen und den Code drahtlos abrufen. Dies ermöglicht einen schnelleren und reibungsloseren Entwicklungsprozess.

Um SSH auf Ihrem RPi zu aktivieren, folgen Sie den [einfachen und schnellen Anweisungen.](https://www.raspberrypi.org/documentation/remote-access/ssh/)

### Gerätebibliotheken und Abhängigkeiten herunterladen

Für unsere Geräte müssen Sie eine Ausgangsspannung von 1 oder 0 vom RPI verwenden, um die Geräte einzuschalten. Umgekehrt geben die Sensoren dem RPi eine Eingangsspannung von 1 oder 0, je nachdem, ob sie nass oder trocken sind. Beide Funktionen erfordern die Verwendung der GPIO-Pins des RPi.

Da Sie in Python programmieren werden, ist es nützlich, die [GPIO Zero Bibliothek](https://gpiozero.readthedocs.io/en/stable/) zu installieren, die es Ihnen ermöglicht, einfache Funktionsaufrufe zu machen, um die Pins zu aktivieren oder einzulesen.

_HINWEIS: Denken Sie daran, dass diese Bibliotheken auf dem RPi installiert werden müssen, indem Sie sich per SSH in Ihr Gerät einwählen und die unten stehenden Befehle ausführen._

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

### Erstellen Sie Ihre App mit PubNub

Der [vollständige Code für dieses Projekt befindet sich als Referenz in diesem Repository.](https://github.com/PubNubDevelopers/beginner-smarthome) Erstellen Sie ein Python-Skript, um unsere Sensoren mit dem Internet zu verbinden. Öffnen Sie ein neues Dokument in Ihrem bevorzugten Texteditor und importieren Sie die Bibliotheken und andere Abhängigkeiten, damit die Geräte über das PubNub-Netzwerk kommunizieren können.

```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)
#--------------------------------------------#
```

Sie müssen dem Raspberry Pi mitteilen, welche Geräte mit welchen seiner Pins verbunden sind:

```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)
#--------------------------------------------#
```

_HINWEIS: Die Lampe wird als LED deklariert, da Sie sie wie eine einfache LED steuern wollen. Die Sensoren werden als Taster initialisiert, da sie ein konstantes aktives Signal ausgeben, so wie ein Taster, wenn er gedrückt gehalten oder gedrückt wird. Das ist die Magie der GPIO-Zero-Bibliothek, da es mühelos ist, mit Sensoren und Geräten zu kommunizieren._

Sie sollten auch eine Zählervariable erstellen, damit Sie wissen, wie oft unsere Tür geöffnet wurde:

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

Damit unsere IoT-Lampe mit einem Client interagieren kann, müssen wir die Zwei-Wege-Pub/Sub-Funktion von PubNub nutzen. Dazu muss ein Listener hinzugefügt werden, der eingehende Nachrichten verwaltet, und ein Abonnement konfiguriert werden, das auf einen bestimmten Kanal hört.

```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
```

Im obigen Callback werden die eingehenden Präsenzdaten von `presence` und die Lampenkommandos von `message` verarbeitet. Wir schalten die Lampe ein, wenn der Client die Nachricht "ON" sendet. Umgekehrt schalten wir die Lampe aus, wenn die Nachricht "OFF" lautet.

```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()
```

Anschließend stellen wir sicher, dass unser Programm den `MySubscribeCallback()` hinzufügt und den gewählten Kanal, in diesem Fall "ch1", abonniert.

```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()
```

Achten Sie auf den Message Event Handler. Immer wenn Ihr Programm eine Nachricht vom Anwendungs-Client erhält, analysieren Sie die Nachricht mit `message.message`. Anschließend erstellen Sie Event-Handler mit if-Anweisungen, um die Lampe mit dem GPIO-Befehl `.on()` oder `.off()` ein- oder auszuschalten.

Wenn eine Nachricht an den Client zurückgegeben wird, wird der Benutzer darüber informiert, dass seine Anfrage erfolgreich ausgeführt wurde. In diesem Fall teilen Sie dem Client mit, ob die Lampe an oder aus ist.

Dieser Abschnitt ist optional (da Sie ihn für dieses Programm nicht verwenden), aber es kann ein Publisher-Callback erstellt werden, der jedes Mal, wenn eine Nachricht veröffentlicht wird, eine Funktion ausführt.

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

Das letzte Segment des Programms überprüft kontinuierlich die Sensoreingänge, um festzustellen, ob die Sensoren etwas erkennen. Die Haupt-While-Schleife, eine Art "Router", prüft wiederholt die Eingänge: Während Wahr:". Innerhalb dieser Haupt-While-Schleife können Sub-While-Schleifen konstruiert werden, um die Sensoren gezielt abzufragen. Da die Sensoren als Buttons aus der GPIO Zero-Bibliothek initialisiert wurden, ist die Funktion \`.is\_held\` erforderlich.

Auch wenn wir keine Taste verwenden, verhalten sich die Sensoren so, als wären sie Tasten, da sie das gleiche "Signal des Gedrückthaltens einer Taste" simulieren, wenn sie aktiv sind (d. h., sie erkennen etwas). Es gibt mehrere Codeschnipsel, die den Türsensor und die Beleuchtung abfragen und deren Status überprüfen. Wenn der Sensor aktiv ist, wird eine Nachricht an den Client zurückgesendet, die ihm mitteilt, ob der Sensor ein- oder ausgeschaltet ist. Ähnliche Prinzipien lassen sich auch auf andere Smart-Home-Produkte anwenden, z. B. SmartThings, Apple HomeKit-Geräte oder sogar Ihren HomePod, wodurch sich die Möglichkeiten Ihres Smart Home erheblich erweitern lassen.

### Hochladen Ihres Codes

Um Ihren Code auf Ihren Raspberry Pi hochzuladen, müssen Sie Ihren Code immer in Ihr Repository übertragen und ihn dann auf Ihren Raspberry Pi ziehen. Öffnen Sie Ihr Terminal, geben Sie Ihr Arbeitsverzeichnis ein und übertragen Sie Ihren Code mit diesen Befehlen in die Cloud.

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

Melden Sie sich per SSH an Ihrem Raspberry Pi an und wechseln Sie in das entsprechende Verzeichnis.

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

Holen Sie dann den Code aus der Cloud und führen Sie ihn aus. Während Sie warten, können Sie sich vielleicht etwas Zeit nehmen, um Ihre Lieblings-Spotify-Wiedergabeliste zu hören oder Timer für Ihre Aufgaben zu setzen. Multitasking-Effizienz ist eine der Schönheiten der vernetzten Welt!

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

### Erstellen eines Clients mit PubNub

Als Nächstes müssen wir ein Client-Skript erstellen, mit dem Sie über ein Mobiltelefon oder einen Computer Daten an unsere Sensoren senden und von ihnen empfangen können. Dazu muss eine HTML-Datei erstellt werden, die Schaltflächen verwendet, um Befehle an den Raspberry Pi zu senden, und Textfelder, um Daten vom Raspberry Pi abzurufen. Dies lässt sich mit einem einfachen HTML-Skript und dem Hinzufügen einiger Schaltflächen, ID-Tags und dem PubNub JavaScript SDK bewerkstelligen. Dieses System ist so flexibel, dass es mit verschiedenen Protokollen wie Z-Wave und ZigBee integriert werden kann, wodurch sich weitere Entwicklungsbereiche eröffnen.

```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);
        });
      }
```

Schließlich müssen wir den Kanal abhören, auf dem der Raspberry Pi unsere Lichtsensordaten veröffentlicht. Mit dem folgenden Codeblock können wir einen Listener einrichten:

```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>
```

Beachten Sie, dass Sie den Kanal ch2 abonniert haben. Das liegt daran, dass Sie einen eigenen Kanal für die Lichtsensordaten haben wollen, damit Sie die Daten nicht von denen anderer Sensoren unterscheiden müssen. Wenn Sie vergessen haben, die Daten im Rahmen der Anwendung auf einem bestimmten Kanal zu veröffentlichen, sollten Sie dies unbedingt nachholen.

Sobald Sie Ihr Skript gespeichert haben, öffnen Sie die Datei in einem Webbrowser, und Sie sollten etwa so aussehen:

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

Sie haben nun die Implementierung von drei einfachen Smart Home-Geräten auf einem Raspberry Pi abgeschlossen! Testen Sie Ihren Code, indem Sie sich per ssh in Ihren Raspberry Pi einloggen, um Ihren Python-Code auszuführen und dann mit Ihrem Client-Programm zu interagieren. Sie sollten in der Lage sein, Ihre Smart-Lampe mit den beiden Tasten zu steuern und Textmeldungen zu sehen, wenn Ihre Tür offen ist oder Ihr Licht eingeschaltet ist. Sie haben erfolgreich ein Smart-Home-System mit angeschlossenen Geräten erstellt, die mit PubNub kommunizieren.

Wenn Sie mehr darüber erfahren möchten, wie Sie Ihre IoT-Anwendungen und Smart-Home-Systeme betreiben können, werfen Sie einen Blick auf unsere IoT-Ressourcen.

-   [Interaktion mit einer IoT-Dashboard-Demo in Echtzeit](https://www.pubnub.com/demos/iot-dashboard/)
    
-   [Wie man eine IoT-Lösung entwickelt](https://www.pubnub.com/how-to/develop-an-iot-solution/)
    
-   [Aufbau einer IoT-Lösung mit PubNub](https://www.pubnub.com/tutorials/iot-dashboard/)
    
-   [Fünf Anforderungen zur Sicherung der IoT-Kommunikation](https://www.pubnub.com/resources/whitepaper/5-key-requirements-to-securing-iot-communications/)
    
-   [MQTT](https://www.pubnub.com/guides/mqtt/)
    

Wenn Sie weitere Fragen oder Bedenken haben, wenden Sie sich bitte [an](mailto:devrel@pubnub.com) devrel@pubnub.com.