Verwenden Sie einen Raspberry Pi und das Mozilla Open Framework, um schnell ein IoT-Gateway zu entwickeln

Gateway-Geräte schlagen die Brücke zwischen Cloud-Diensten und IoT-Endgeräten (Internet of Things) und beschleunigen damit die Verarbeitung, reduzieren die Latenz und sorgen für eine hohe Verfügbarkeit. Entwickler, die ein Gateway-Gerät entwickeln, sehen Sie sich jedoch schon bald mit einer verwirrenden Vielfalt an Optionen für Hardware und Software konfrontiert, die für die Anbindung der verschiedenen IoT-Peripheriegeräte an die Cloud benötigt wird.

Mit einem Raspberry Pi und Open-Source-Software von Mozilla lässt sich jetzt jedoch schnell und kostengünstig ein Gateway implementieren, das auf bestehenden und kommenden IoT-Standards basiert.

Dieser Artikel soll Entwicklern dabei als Orientierungshilfe dienen. Dazu beschreibt er zunächst kurz die Aufgabe von Gateways in IoT-Netzwerken, die wichtigsten Anforderungen an Gateways und die mit ihnen einhergehenden Herausforderungen bei der Implementierung. Anschließend werden die gegenwärtigen Anstrengungen zur Etablierung von Standards unter besonderer Berücksichtigung des Ansatzes des World Wide Web Consortium zur Beschreibung von Entitäten in IoT-Netzwerken erläutert.

Im Fokus dieses Artikels steht die Frage, wie sich mit einem Raspberry Pi 3, Drahtlos-Zusatzkomponenten und Open-Source-Software von Mozilla in kürzester Zeit ein Gateway realisieren lässt. Insbesondere wird beschrieben, wie Entwickler ihr Gateway mithilfe des Mozilla-Software-Frameworks auf einfache Art so erweitern können, dass es eine Reihe von Peripheriezusatzgeräten unterstützt, die für die Erfüllung spezieller Anforderungen an die Konnektivität benötigt werden.

Der wachsende Bedarf an Gateways

Im Web machen es Standardprotokolle möglich, dass Benutzer mit unterschiedlichen Browsern die Verbindung zu vielen verschiedenen Servern herstellen können – trotz großer Unterschiede in der zugrunde liegenden Hardware und Software der Browser- und Serverplattformen. Das IoT baut auf vielen dieser Standardprotokolle auf, birgt jedoch deutlich größere Herausforderungen, was die Realisierung der Interoperabilität angeht, die auch in Zukunft die treibende Kraft für das Web sein wird. Webbrowser bedienen sich der Request-Header, um sich selbst und ihre Fähigkeiten auszuweisen – analog dazu benötigen auch IoT-Geräte Standardkonzepte für die Ausweisung ihres Funktionsumfangs und der Art der von ihnen gelieferten Daten.

In einer typischen mehrschichtigen IoT-Architektur können Anzahl und Typ der Entitäten jedoch überwältigend groß sein, vor allem auf der untersten Schicht, die Sensoren und Aktuatoren umfasst. Als bevorzugte Lösung für die Erfüllung der unterschiedlichen Konnektivitätsanforderungen dieser Geräte haben sich Gateway-Geräte durchgesetzt. Mit ihrer Fähigkeit, mehrere drahtgebundene und drahtlose Konnektivitätsoptionen zu unterstützen, kommt Gateways in komplexen IoT-Systemen eine Schlüsselaufgabe zu. Weil IoT-Entwickler nicht nur ihre umfassende Konnektivität, sondern darüber hinaus ihre Fähigkeit nutzen, in komplexen IoT-Netzwerken umfangreichere Aufgaben zu erfüllen, ist der Aufgabenbereich von Gateways enorm gewachsen.

Die Aufgaben von Gateways

In ihrer einfachsten Rolle puffern Gateway-Geräte die Kommunikation zwischen Cloud-Verbindungen mit hohem Durchsatz und Hunderten oder Tausenden von IoT-Peripheriegeräten, die Datenströme mit Raten erzeugen, die zwischen den einzelnen Geräten und der Cloud um mehrere Größenordnungen variieren können. Gehen Verbindungen zur Cloud verloren, kann das Gateway den IoT-Geräten lokale Versionen der Dienste bereitstellen. Dasselbe gilt umgekehrt: Wenn ein IoT-Gerät aus irgendeinem Grund offline geht, kann das Gateway der Cloud ein virtuelles IoT-Gerät bereitstellen, das die Grundfunktionen sowie den letzten bekannten Status des entsprechenden physischen IoT-Geräts emuliert. In beiden Fällen kann die IoT-Anwendung der höheren Ebene trotz der Verbindungsunterbrechung normal weiterlaufen.

Weil sie in der Regel nicht den Echtzeit- und Leistungsbeschränkungen von IoT-Peripheriegeräten unterliegen, können IoT-Edge-Geräte die Vorteile von leistungsstarken Prozessorarchitekturen nutzen, um nahe an der Quelle der IoT-Daten eine hohe Verarbeitungsleistung zu bieten. IoT-Spezialisten machen sich diese lokale Verarbeitungsleistung zunutze, indem sie komplexere Cloud-Dienste und sogar hochentwickelte Maschinenlernalgorithmen von diesen Geräten verarbeiten lassen. Das sorgt bei lokalen Prozessen für kürzere Reaktionsschleifen und verringert die Datenmengen, die in Richtung der Cloud-Anwendung fließen.

Kommerzielle IoT-Plattformen wie Amazon Web Services IoT, IBM Watson IoT und Microsoft Azure IoT bieten in ihren Komplett-Serviceangeboten ihre eigenen proprietären Schnittstellen (Abbildung 1). Aus vielerlei Gründen – wie etwa der Sorge um die Abhängigkeit von einem Anbieter oder aufgrund komplexerer Anforderungen – suchen IoT-Anwendungsentwickler jedoch weiterhin nach Lösungen für die vereinfachte Nutzung einer größeren Vielfalt an IoT-Geräten und -Diensten.

Abbildung 1: Kommerzielle IoT-Plattformen wie Amazon Web Services (AWS) IoT nutzen Internetstandards der niedrigen Ebene, um die einzelnen Schichten einer IoT-Anwendung zu unterstützen, müssen aber aufgrund fehlender IoT-spezifischer Standards eigene Lösungen bereitstellen. (Bildquelle: Amazon Web Services)

Führend bei der Formulierung von IoT-Standards ist das World Wide Web Consortium (W3C), auch wenn es noch andere gibt, die an der Definition der Elemente einer Standard-IoT-Architektur arbeiten. In seinen eigenen entstehenden Spezifikationen definiert das W3C Web of Things (WoT) einige Schlüsselschnittstellen, die es einzelnen Geräten ermöglichen, mit einem Gateway, Cloud-Server, Webclient oder sogar einem anderen IoT-Gerät zu kommunizieren (Abbildung 2).

Abbildung 2: Das W3C will die Interoperabilität im Web of Things über eine Reihe von Standardschnittstellen und Datenmodelle wie die Thing Description (Dreieck) realisieren, die Informationen für jedes Gerät enthält. (Bildquelle: W3C)

Die Details der W3C-Architektur würden den Rahmen dieses Artikels sprengen, einige zentrale Definitionen sollen jedoch nicht unerwähnt bleiben. Ein Schlüsselelement ist das Thing, das ein physisches Gerät und seine Metadaten umfasst, bzw. die Thing Description – dargestellt durch die kleinen Dreiecke in Abbildung 2.

Über eine bloße Auflistung grundlegender Metadaten wie Name und Klartextbeschreibung hinaus kann die Thing Description die Anwendung mit bestimmten Features direkt unterstützen – dazu zählen die Typisierung von Daten, die Validierung und sogar spezifische Endpunkte, die andere Entitäten aufrufen können, um diese Thing-spezifischen Funktionen auszuführen.

Unter Rückgriff auf standardmäßige Kommunikationsverfahren („WoT Binding Templates“ in Abbildung 2) müssen die verschiedenen Teilnehmer in einer IoT-Anwendung lediglich die Thing Description eines neuen Geräts oder Gateways „lesen“, um zu ermitteln, wie mit ihm und seinen Datenfähigkeiten gearbeitet werden kann. Mit seinen Datenmodell- und API-Definitionen bietet Mozilla den Entwicklern eines der ersten verfügbaren Frameworks für die Entwicklung dieser Art von interoperablen Gateways.

Mozilla-Gateway

Im Rahmen der W3C WoT-Arbeit umfasst die Things-Gateway-Spezifikation von Mozilla ein Datenmodell für eine Thing Description und zugehörige Thing-Typen sowie einfache APIs für die Nutzung von WebSockets oder einfachen REST-Mechanismen. Die Thing Description von Mozilla spezifiziert grundlegende Metadaten wie Name, Typ und Beschreibung sowie Eigenschaften wie „ein“ und „Pegel“ für eine angeschlossene LED-Leuchte (Auflistung 1).

Kopieren

{

  "name":"Meine Lampe",

  "type": "thing",

  "description": "Eine per Web vernetzte Lampe",

  "properties": {

    "on": {

      "type": "boolean",

      "description": "Ob die Lampe eingeschaltet ist",

      "href": "/things/lamp/properties/on"

    },

    "level" : {

      "type": "number",

      "description": "Der Lichtpegel von 0-100",

      "minimum" : 0,

      "maximum" : 100,

      "href": "/things/lamp/properties/level"

    }

  },

  "actions": {

    "fade": {

      "description": "Dimmen der Lampe auf einen bestimmten Pegel",

      "input": {

        "type": "object",

"properties": {

          "level": {

"type": "number",

            "minimum": 0,

            "maximum": 100

          },

          "duration": {

"type": "number",

            "unit": "milliseconds"

          }

        }

      },

      "href": "/things/lamp/actions/fade"

    }

  },

  "events": {

    "overheated": {

      "type": "number",

      "unit": "celsius",

      "description": "Die sichere Betriebstemperatur der Lampe wurde überschritten",

      "href": "/things/lamp/events/overheated"

    }

  },

  "links": [

    {

      "rel": "properties",

      "href": "/things/lamp/properties"

    },

    {

      "rel": "actions",

      "href": "/things/lamp/actions"

    },

    {

      "rel": "events",

      "href": "/things/lamp/events"

    },

    {

      "rel": "alternate",

      "href": "wss://mywebthingserver.com/things/lamp"

    },

    {

      "rel": "alternate",

      "mediaType": "text/html",

      "href": "/things/lamp"

    }

  ]

}

Auflistung 1: Die Mozilla Gateway Thing Description nutzt zur Beschreibung eines Thing und seines Funktionsumfangs ein JSON-Standardformat. (Codequelle: Mozilla)

Andere Einträge in der Thing Description enthalten komplexere Objekte mit Handlungen wie beispielsweise dem Dimmen einer Leuchte. Durch Zugriff auf „fade“ (Dimmen) in der Thing Description kann ein Gateway oder eine andere Entität den Einstiegspunkt zu einer Funktion finden, die auf der Basis von Eigenschaften wie Dimmstufe und -dauer den „fade“-Vorgang ausführen kann. Folglich bietet die Thing Description ein Standardkonzept für die Identifizierung eines IoT-Gerätes und die Ausführung der verschiedenen Aufgaben, für die es konstruiert wurde.

Für die Interaktion mit einem Thing können Entwickler das bekannte REST-Webprotokoll zum Lesen (GET) oder Schreiben (PUT oder POST) von in der Thing Description definierten Thing-Eigenschaften nutzen. Die reguläre REST-Antwort liefert ihrerseits die mit einem Lesebefehl angeforderten Daten oder den Status des Schreibvorgangs.

Um eine LED im Verlauf einer zweisekündigen Übergangsphase auf 50 % der Helligkeit zu dimmen, schickt der Entwickler mit POST den entsprechenden JSON-Body an den zugehörigen Fade-Endpunkt. Als Antwort erhält er eine 201-Antwort und einen JSON-Body zur Bestätigung der Eigenschaften und des Status der vom Gerät angeforderten Aktion (Auflistung 2).

Kopieren

POST https://mythingserver.com/things/lamp/actions/

Accept: application/json

{

  "fade": {

    "input": {

      "level": 50,

      "duration": 2000

    }

  }

}

201 Created

{

  "fade": {

    "input": {

      "level": 50,

      "duration": 2000

    },

    "href": "/things/lamp/actions/fade/123e4567-e89b-12d3-a456-426655"

    "status": "pending"

  }

}

Auflistung 2: Unter Rückgriff auf den in der Thing Description spezifizierten Einstiegspunkt sowie die zugehörigen Eigenschaften kann der Entwickler per POST eine Fade-Anforderung schicken. Als Antwort erhält er eine 201-Antwort und einen JSON-Body zur Bestätigung der Eigenschaften und des Status der angeforderten Aktion. (Codequelle: Mozilla)

Auch wenn die Mozilla-Dokumentation eine detaillierte Beschreibung ihrer Datenmodelle und APIs bietet, müssen Entwickler nach wie vor die umfangreichen Softwarepakete schreiben, die erforderlich sind, damit aus diesem theoretischen Rahmen ein funktionsfähiges Gateway wird. Glücklicherweise verzichtet Mozilla in einer vollständigen Implementierung speziell für die Raspberry Pi-Familie auf die theoretischen Aspekte ihrer Spezifikation.

Gateway-Plattform

Wie bereits eingangs erwähnt, stellt die Entwicklung eines Gateways relativ moderate Anforderungen im Hinblick auf seine elementare Aufgabe, mehrere Konnektivitätsoptionen zu bieten, um verschiedene IoT-Peripheriegeräte im Mischbetrieb verwenden und aufeinander abstimmen zu können. Die Raspberry Pi-Familie bietet eine effektive Hardwarebasis für die Entwicklung solcher Geräte. In der neuesten Version, dem Raspberry Pi 3 Model B+, wird die Familie mit einem erheblich höheren Durchsatz für drahtgebundene und drahtlose Netzwerke gleichermaßen aufgewertet. Basierend auf dem Vierkern-Prozessor Arm^® Cortex^®-A53 bietet diese Karte zudem eine effektive Plattform für die Arbeit mit den eingangs erwähnten Fähigkeiten der lokalen Verarbeitung.

Ohne bereits das volle Verarbeitungspotenzial des Raspberry Pi 3 Model B+ auszuschöpfen, können Entwickler mit den Gateway-Basisfunktionen experimentieren, indem sie einfach eine Firmware auf die Karte laden, die als kostenloser Download von einem Mozilla Github Repository erhältlich ist. Die Firmware implementiert einen Basis-Gateway, auf dessen Grundlage Entwickler drahtlose Peripheriegeräte anbinden können, indem sie einfach an den Standard-USB-Anschluss des Raspberry Pi 3 einen Wireless-Controller anschließen. Die Mozilla-Softwareimplementierung unterstützt werkseitig zahlreiche USB-Dongles wie den Z-Wave-USB-Controller ACC-UZB3-U-STA von Sigma Designs.

Nach Einschalten der Karte wird der Entwickler von der Software durch einige grundlegende Initialisierungsschritte geführt. Anschließend beginnt sofort die Suche nach Drahtlosgeräten in der Umgebung. Über eine Web-Schnittstelle mit Schaltflächen lassen sich gefundene Geräte mit dem Gateway verbinden (Abbildung 3A) und anschließend Geräteeigenschaften anzeigen oder ändern (Abbildung 3B) – gemäß Definition in der entsprechenden Thing Description.

Abbildung 3: Mit der Things-Gateway-Software von Mozilla lassen sich Things einfach an ein Gateway (A) anbinden. Zudem kann mit jedem Gerät (B) entsprechend seiner Fähigkeiten gemäß Definition in der Thing Description interagiert werden. (Bildquelle: Mozilla)

Optimierung von Gateways mittels Ökosystem-Hardware

Neben der einfachen Realisierung eines Basis-Gateways bietet die Kombination aus Raspberry Pi-Ökosystem und Open-Source-Code von Mozilla Entwicklern eine umfangreiche Umgebung für die Erweiterung des Basissystems. Diese können das komplette Qellcodepaket des Entwurfs herunterladen, um einen besseren Einblick in den Betrieb des Gateways zu erhalten, bestimmte Betriebsmerkmale zu ändern oder sogar eigene Gateway-Anwendungen zu entwickeln. Der auf die Ausführung auf Node.js ausgelegte Quellcode veranschaulicht wichtige Entwurfsmuster für die einzelnen Komponenten einer komplexen Gateway-Softwareanwendung.

Unter Verwendung dieser Entwicklungsplattform lassen sich in kurzer Zeit Gateways entwickeln, die dank eines breiten Angebots an Hardware-Zusatzkarten eine Vielzahl von Konnektivitätsoptionen unterstützen. So können Sie eine Raspberry Pi-Karte beispielsweise um die Automation HAT-Karte PIM213 von Pimoroni ergänzen, damit das betreffende Gateway auch verdrahtete Hochspannungs- und Hochstromanschlüsse unterstützt, wie sie in Industrieumgebungen benötigt werden.

Bei Betriebsumgebungen mit fehlender oder schlechter Internetanbindung können Sie ein Gateway um Schmalband-LTE-Konnektivität erweitern: durch Anschluss einer NL-AB-RPI-Entwicklungskarte mit LTE CAT M1-Modul NL-SW-LTE-SVZM20 von NimbeLink und einer 4G-LTE-Antenne von Taoglas Limited an die Raspberry Pi-Karte.

Die Auswahl ist dabei jedoch nicht auf Raspberry Pi-Zusatzkomponenten beschränkt. Es lassen sich verschiedene Adapterkarten an Raspberry Pi-Karten anschließen, um auf das umfassende Angebot an Zusatzkarten mit anderen Schnittstellenstandards zugreifen zu können. Unter Verwendung des Arduino-Adapters 103990079 von Seeed Technology und einer XK-WDM-Karte von Digi International lässt sich ein Gateway beispielsweise um die stromsparende DigiMesh-Maschennetzwerkkonnektivität erweitern. Bei Anwendungen, die eine Standard-Mesh-Konnektivitätsoption benötigen, schließen Sie die Zigbee-Karte XKB2-Z7T-WZM von Digi an.

Analog dazu lassen sich mit dem Grove-Adapter 103010002 von Seeed das LoRaWAN-Mesh-Networking mit der Grove-LoRaWAN-Karte 113060006 oder mit der Grove RF-Link-Zusatzkarte 113060000 von Seeed Sub-GHz-Netzwerke mit größerer Reichweite unterstützen.

Mit dem reichhaltigen Angebot an Zusatzkarten können Entwickler ihre Hardwareplattform im Handumdrehen aufwerten und um mehrere Konnektivitätsoptionen erweitern. Auf der Softwareseite bietet das Mozilla-Projekt eine überschaubare Menge an Anforderungen und Beispielen für die Implementierung der Softwareschnittstellen, die für die Unterstützung neuer Hardware benötigt werden.

Zur Entwicklung einer Erweiterung für das Things-Gateway benötigen Entwickler Code für drei Entitäten: Device, Property und Adapter. Der Device-Code erweitert die Device-Basisklasse in der Regel um geräte- oder gerätetypspezifische Attribute und Verfahren (Funktionen).

Ein Beispiel: Ein Gerätemodul kann separate Klassen enthalten, die mit den verschiedenen Varianten des Basisgeräts verknüpft sind – z. B. eine Klasse für eine Basis-LED und eine weitere für eine intelligente Glühlampe. Das Property-Modul erweitert die Property-Basisklasse um Eigenschaftsklassen mit Verfahren zum Aktualisieren bestimmter Geräteeigenschaften wie der Farbe oder Helligkeit einer LED (Auflistung 3).

Kopieren

class TPLinkProperty(Property):

    """TP-Link property type."""

    def __init__(self, device, name, description, value):

        """

        Initialize the object.

        device -- the Device this property belongs to

        name -- name of the property

        description -- description of the property, as a dictionary

        value -- current value of this property

        """

        Property.__init__(self, device, name, description)

        self.set_cached_value(value)

   .

   .

   .

class TPLinkBulbProperty(TPLinkProperty):

    """Property type for TP-Link smart bulbs."""

    def set_value(self, value):

        """

        Set the current value of the property.

        value -- the value to set

        """

        try:

            if self.name == 'on':

                self.device.hs100_dev.state = 'ON' if value else 'OFF'

            elif self.name == 'color':

                self.device.hs100_dev.hsv = rgb_to_hsv(value)

            elif self.name == 'level':

                self.device.hs100_dev.brightness = value

            elif self.name == 'colorTemperature':

                value = max(value, self.description['min'])

                value = min(value, self.description['max'])

                self.device.hs100_dev.color_temp = int(value)

            else:

                return

        except SmartDeviceException:

            return

        self.set_cached_value(value)

        self.device.notify_property_changed(self)

   .

   .

   .

Auflistung 3: Bei der Entwicklung eigener Gateway-Zusatzsoftwarepakete können Entwickler zentrale Entwurfsmuster wie diesen Codeauszug verwenden. Es zeigt die Property-Klasse, die bei einer Python-basierten Things-Gateway-Erweiterung für intelligente TP-Link-Geräte genutzt wird. (Codequelle: Mozilla)

Und das Adapter-Modul schließlich erweitert die Adapter-Basisklasse um Klassen, die den Gerätekommunikationskanal initialisieren, die Netzwerkinbetriebnahme unterstützen und Unterstützung für andere geräte- oder kommunikationsspezifische Funktionen liefern.

Das Gateway-Hauptpaket ist zwar in Javascript für Node.js implementiert, die Plattform unterstützt aber offiziell auch Python. Ungeachtet dessen lassen sich konzeptuell kompatible Erweiterungen in jeder geeigneten Sprache entwickeln. So wurden beispielsweise bereits Erweiterungen in Rust, der C++ ähnelnden Speichersicherheitssprache von Mozilla, entwickelt. Für Entwickler, die das bestehende Node.js-Backend nutzen können, bietet dieses relativ simple Erweiterungskonzept eine leistungsfähige Funktion für die schnelle Entwicklung von Gateways, die über verschiedene Konnektivitätsoptionen die Verbindung zu einer großen Bandbreite an IoT-Peripheriegeräten herstellen können.

Fazit

Bei IoT-Gateways stehen Entwickler vor der Herausforderung, die Interoperabilität zwischen unterschiedlichen IoT-Geräten, Gateways und Servern sicherstellen zu müssen. Standardisierungsgremien entwickeln derzeit zwar geeignete Spezifikationen für die IoT-Interoperabilität, bisher blieb es jedoch den Entwicklern überlassen, diese Spezifikationen in funktionsfähige Lösungen umzusetzen.

Auf der Basis der Things-Gateway-Software von Mozilla in Kombination mit einem Raspberry Pi 3 können Entwickler – wie geschildert – schnell und kostengünstig Gateway-Anwendungen evaluieren und das Gateway um die Unterstützung diverser Konnektivitätsoptionen erweitern.