Visuelles Programmieren mit Node-RED: Das Internet der Dinge mit Leichtigkeit verkabeln

Durch Programmierung bringen wir Maschinen dazu, komplexes Verhalten nachzuahmen, indem sie Folgen einfacher Anweisungen befolgen. Die Verwendung textueller Programmiersprachen wie Assembly, C, Python und JavaScript ist eine der wichtigsten Möglichkeiten, dies zu tun. Designer dieser Programmiersprachen haben unzählige Stunden damit verbracht, das Schreiben von Programmen durch ausdrucksstarke Syntax, robuste Programmierkonstrukte und leistungsstarke Toolchains so einfach wie möglich zu gestalten. Alle diese Programmiersprachen haben jedoch ein gemeinsames Merkmal: textuellen Quellcode.

Das Schreiben von Programmen in Text funktioniert, und in den meisten Fällen funktioniert es gut. Die Fähigkeit, Programme visuell auszudrücken, ist jedoch oft wünschenswert. Oft genügt es, den Informationsfluss durch verschiedene Komponenten eines größeren Systems zu gestalten. Visuelle Programmierwerkzeuge sind auch nachsichtig gegenüber allen, die neu in der Programmierung sind und Schwierigkeiten haben, mit verschiedenen Konzepten wie Variablen, Zeigern, Signalen, Bereichen usw. umzugehen.

Node-RED ist ein Tool zur visuellen Programmierung. Es zeigt Beziehungen und Funktionen visuell an und ermöglicht dem Benutzer zu programmieren, ohne eine Sprache eingeben zu müssen. Node-RED ist ein browserbasierter Flow-Editor, in dem Sie Knoten hinzufügen oder entfernen und miteinander verbinden können, damit sie miteinander kommunizieren.

In Node-RED ist jeder Knoten einer der folgenden zwei Typen: ein Injektionsknoten oder ein Funktionsknoten . Inject-Knoten erzeugen eine Nachricht, ohne dass eine Eingabe erforderlich ist, und schieben die Nachricht an den nächsten damit verbundenen Knoten. Funktionsknoten hingegen nehmen eine Eingabe entgegen und führen einige Arbeiten daran aus. Mit einer Vielzahl dieser Knoten zur Auswahl macht Node-RED die Verkabelung von Hardwaregeräten, APIs und Onlinediensten einfacher als je zuvor.

Erste Schritte mit Node-RED

Node-RED basiert auf Node.js. Um Node-RED zu installieren, müssen Sie sowohl Node.js als auch NPM installiert haben. Mit NPM ist es super einfach, Node-RED zu installieren:

 npm install -g node-red

Der Flow-Editor von Node-RED ist eine webbrowserbasierte Anwendung. Führen Sie Node-RED aus, um es verwenden zu können:

 node-red

&hellip und navigieren Sie zu http://localhost:1880.

Hallo Welt!

Welches Programmier-Tutorial für Anfänger ist vollständig, ohne zu lernen, „Hallo Welt“ zu sagen? Beginnen wir damit, genau das auszuprobieren:

1. Ziehen Sie einen Inject-Knoten per Drag-and-Drop in den Flow-Editor. Dann doppelklicken Sie und richten Sie die Payload als String ein und schreiben Sie „Hello world“.
2. Ziehen Sie einen Debug-Knoten per Drag-and-Drop auf die gleiche Weise wie beim Inject-Knoten.
3. Verdrahten Sie sie zusammen.
4. Klicken Sie auf die Schaltfläche „Bereitstellen“ in der rechten Ecke.
5. Klicken Sie auf die blaue Schaltfläche gleich links neben dem Injektionsknoten .

Versuch es. Sie werden so etwas sehen:

Nur JavaScript

Mit Node-RED sind Sie nicht nur auf einfache Nodes und Funktionalitäten beschränkt. Da Node-RED auf Node.js aufbaut, wird alles von JavaScript unterstützt. Knoten sind in der Tat Node.js-Module. Sie können unter http://flows.nodered.org/ gefunden werden, um sie also zu Ihrem linken Bereich hinzuzufügen, können Sie sie einfach „npm installieren“. Tatsächlich können Sie Ihren eigenen Flow entwickeln und ihn in das Flow-Repository hochladen. Anwendungen können so komplex sein, wie Sie möchten, da Sie JavaScript in Funktionsknoten innerhalb des von Node-RED bereitgestellten Code-Editors eingeben können.

Da die Plattform auf Node.js basiert, nutzt sie dasselbe ereignisgesteuerte, nicht blockierende Modell. So kann eine auf Node-RED aufgebaute Anwendung sowohl auf kostengünstiger Hardware wie dem Raspberry Pi als auch in der Cloud ausgeführt werden.

Jetzt Let's Go Pro: Zeit für Heimautomatisierung

Um zu demonstrieren, wie Node-RED in den Bereich des Internets der Dinge passt, lassen Sie uns eine Anwendung erstellen, um die Farbe einer intelligenten Glühbirne zu ändern. Möglicherweise verfügt nicht jeder über das gleiche intelligente Beleuchtungssystem, aber Sie müssen sich keine Sorgen machen, da Sie das passende Node-RED-Modul im offiziellen Flow-Repository finden können. Um die Dinge jedoch noch einfacher zu machen, sollten wir uns für etwas Klügeres entscheiden.

Treffen Sie Netbeast. Es ist eine Open-Source-Plattform für die Entwicklung von Anwendungen für Internet-of-Things-Appliances und -Geräte, ohne sich um Details wie drahtlose Protokolle, Markenkompatibilität oder den Umgang mit jeder spezifischen API da draußen kümmern zu müssen. Es ermöglicht uns, virtuelle Geräte zu verwenden, die sich wie echte verhalten! Auch wenn Sie keine intelligente Glühbirne haben, steht Ihnen eine virtuelle zur Verfügung.

Wir können das Netbeast for Node-RED npm-Paket global wie folgt installieren:

 npm install -g node-red-contrib-netbeast

Der rote Netbeast-Knoten stellt das Netbeast-Dashboard dar, das seine API-Grundelemente auf alle Ihre intelligenten Geräte übersetzt, die Sie zu Hause haben. Zum Glück gibt es ihn auch als Modul!

Netbeast starten:

 npm install -g netbeast-cli netbeast start

Dadurch wird das Dashboard auf Port 8000 und SSL auf 8443 verfügbar. Öffnen Sie als nächstes Ihren Browser zu http://localhost:8000 und navigieren Sie zu Explore. Dort finden wir viele Apps und Plugins. Suchen Sie nach den Marken Ihrer intelligenten Glühbirnen (Philips Hue, LIFX, WeMo) oder versuchen Sie, das Glühbirnen-Plug-in herunterzuladen, wenn Sie keine haben. Überprüfen Sie, ob Ihre Dashboard-Plugins eines davon enthalten!

Das gelbe Abzeichen zeigt an, dass die Plugins ausgeführt werden, aber keine Geräte finden können. Klicken Sie auf das Glühbirnen-Plugin, um eine virtuelle Glühbirne zu erstellen. Alle anderen erkannten Geräte sollten unter Netzwerk angezeigt werden.

Wenn alles an Ort und Stelle ist, machen wir uns wieder an die Arbeit. Wir werden einen einfachen Fluss machen:

1. Ziehen Sie einen Injektionsknoten per Drag-and-Drop.
2. Ziehen Sie den Netbeast-Knoten per Drag-and-Drop.
3. Ziehen Sie einen Debug-Knoten per Drag-and-Drop.
4. Verdrahten Sie alles wie unten gezeigt:

Lassen Sie uns nun eine HTTP-Anforderung an das Dashboard senden. Mit der Netbeast-API müssen wir über den Inject-Knoten einen JSON senden, der die Werte enthält, die wir auf unserer Glühbirne auslösen möchten.

Drücken Sie die Taste, um allen Ihren intelligenten Glühbirnen Farbe und Energie zu verleihen!

Jedes Thema steht für eine andere Art von Gerät. So gibt es Themen für Licht, aber auch für Musik, Heizung und Video; sowie Sensoren für Feuchtigkeit, Anwesenheit, Temperatur und die Liste geht weiter. In ihrer Dokumentation finden Sie eine Liste von Themen und deren empfohlene Struktur, die auf alle Arten von Geräten übersetzt werden können. Diese IoT-Engine ist unausgereift, aber leistungsstark. Open Source, das es Entwicklern ermöglicht, Informationen wiederzuverwenden, um Szenarien zu erstellen, die wirklich verbunden und damit intelligent sind.

Lass uns tiefer gehen

Als Nächstes erstellen wir einen zweiten Flow mit einem anderen Plugin, einem Umgebungsgeräuschdetektor, um ihn als Auslöser zu verwenden, um die Farbe der Glühbirne als Rauschsemaphor zu ändern. In diesem Tutorial verwenden wir ein virtuelles, sodass Sie keine neue Hardware kaufen müssen. Beginnen wir damit, im Node-RED-Editor auf die Schaltfläche „Plus“ zu klicken.

Gehen Sie erneut auf dem Dashboard http://localhost:8000/explore zum Abschnitt Explore und suchen Sie nach Volume-Plugin. Es ist eine sehr rudimentäre Web-App, die getUserMedia() im Browser nutzt, um Medien aus einer einfachen HTML-App zu erfassen. Es wird also wahrscheinlich nur auf modernen Browsern funktionieren!

Klicken Sie darauf, um es zu öffnen, wie bei der virtuellen Glühbirne. Es wird um Erlaubnis gebeten, von Ihrem Mikrofon aufzunehmen. Dann werden die Nachrichten an den MQTT-Broker von Netbeast gesendet, die über das gesamte Dashboard geteilt werden, sodass wir uns anmelden können. Dazu müssen wir nur einen Netbeast-Trigger- Knoten in den Editor von node-red ziehen und dort ablegen. Dann fügen wir eine Funktion zwischen dem Trigger und dem Netbeast-Knoten ein, damit wir entscheiden, wann es zu laut ist oder nicht. Außerdem sollten wir einige Debug-Knoten verwenden, um zu überprüfen, ob alles in Ordnung ist. Das Schema sieht jetzt etwa so aus:

Lassen Sie uns nun etwas Code in den TooLoud-Funktionsknoten eingeben. Ja, ich weiß, ich habe versprochen, dass Sie programmieren können, ohne programmieren zu müssen, aber ich habe bereits gezeigt, dass Sie es können! Und Sie können versuchen, die verschiedenen verfügbaren Elemente oder andere Knoten aus der Registrierung zu kombinieren, um Folgendes zu erreichen.

 var volume = msg.payload.volume node.log(volume) if (volume < 50) { return { topic: 'lights', payload: { power: 1, color: '#00CC00'}} } else if (volume < 75) { return { topic: 'lights', payload: { power: 1, color: '#CCCC00'}} } else { return { topic: 'lights', payload: { power: 1, color: '#FF0000'}} }

Dieses ziemlich einfache Code-Snippet gibt eine der drei Nutzlasten für den nächsten Knoten mit einem bestimmten Farbcode zurück, abhängig von der vom vorherigen Knoten gemeldeten Lautstärke.

Jetzt sind wir startklar! Lassen Sie uns erneut auf die Schaltfläche Deploy treten und etwas Lärm machen. Lassen Sie uns sehen, wie die Glühbirne sofort von einer Farbe zur anderen wechselt!

Da das von Ihnen verwendete Mikrofon und der Webbrowser möglicherweise unterschiedlich sind, können Sie die Funktionswerte und Schwellenwerte anpassen und auch mit den Farbwerten spielen, um zu sehen, wie sich Ihre Glühbirnen ändern.

Eigene Plugins erstellen

Diese Glühbirne in reinem CSS wurde von diesem CSSDeck inspiriert.

Wie Sie vielleicht bemerkt haben, ist die virtuelle Glühbirne von vorher sehr rudimentär, also möchten Sie sie vielleicht optimieren. Oder noch besser, Sie können Ihre eigenen Smart-Home-Controller erstellen. Wir werden also den Prozess der Erstellung eines virtuellen Plugins für Netbeast durchlaufen, mit dem Sie Ihre eigenen Controller für intelligente Geräte erstellen können.

Sie können das Paket netbeast-cli verwenden, um automatisch Code zu generieren. Durch Ausführen von netbeast create myplugin --plugin würden wir am Ende ein einfaches Projekt wie das folgende erhalten:

 myplugin ├── README.md ├── index.js ├── package.json └── test.js

Das Frontend

Beginnen wir nun damit, die Glühbirne mit einem Frontend zu imitieren. Gerätecontroller haben normalerweise keinen, daher ist noch kein öffentlicher Ordner im Scaffold-Befehl enthalten. Lassen Sie uns ein public Verzeichnis innerhalb des Projekts erstellen und dort die folgenden HTML-, CSS- und JS-Dateien platzieren.

index.html

 <head> <title>Netbeast Bulb Plugin</title> <link rel="stylesheet" href="bulb.css" media="screen" charset="utf-8"> </head> <body> <div class="top-decoration"></div> <div> </div> <div class="bulb-container small"> <div class="bulb light"> <div> <div class="bulb top"></div> <div class="bulb middle-1"></div> <div class="bulb middle-2"></div> <div class="bulb middle-3"></div> <div class="bulb bottom"></div> </div> <div> <div class="screw-top"></div> <div class="screw a"></div> <div class="screw b"></div> <div class="screw a"></div> <div class="screw b"></div> <div class="screw a"></div> <div class="screw b"></div> <div class="screw c"></div> <div class="screw d"></div> </div> </div> </div> <div class="code-container"> <pre><i class="txt-red">beast</i>(<i class="txt-green">'lights'</i>).<i class="txt-blue">set</i>({ <i class="txt-green">color</i>: <i class="txt-green">"<input type="text" class="color" name="color" value="00fea5">"</i>, <i class="txt-green">power</i>: <i class="txt-green">"<input type="text" class="power" name="power" value="on">"</i> })</pre> <button> RUN </button> </div><!-- wrapper --> <!-- declares bulb features and methods --> <script type="text/javascript" src="bulb.js"></script> <!-- real time comms library --> <script type="text/javascript" src="socketio.js"></script> <!-- simulates hardware communication --> <script type="text/javascript" src="hw-api.js"></script> </body>

bulb.css

 section { float: left; padding: 20px 50px 20px 50px; } .bulb-light { border: 0; background: transparent; margin: 0 auto !important; padding: 0 !important; display: block; z-index: 1; } #bulb { opacity: 1; z-index: 3; display: block;} .bulb.top { border: 0; width: 300px; height: 300px; margin: 0 auto; padding: 0; border-radius: 999px; background: #E7E7E7; } .bulb.middle-1 { margin: -75px auto 0 auto; width: 190px; border-left: 35px solid transparent; border-right: 35px solid transparent; border-top: 55px solid #E7E7E7; } .bulb.middle-2 { margin: -22px auto 0 auto; width: 178px; border-left: 19px solid transparent; border-right: 19px solid transparent; border-top: 50px solid #E7E7E7; } .bulb.middle-3 { margin: -20px auto 0 auto; width: 182px; border-left: 5px solid transparent; border-right: 5px solid transparent; border-top: 30px solid #E7E7E7; } .bulb.bottom { width: 184px; height: 65px; margin: -8px auto 0 auto; padding: 0; border-radius: 0 0 999px 999px; background: #E7E7E7; } #base { position:relative; z-index: 2; } .screw { transform: rotate(-3deg); -ms-transform: rotate(-3deg); -webkit-transform: rotate(-3deg); padding: 0; } .screw-top { margin: -18px auto -4px auto; padding: 0; width: 132px; height: 0; border-left: 15px solid transparent; border-right: 15px solid transparent; border-top: 21px solid #D3D3D3; border-radius: 999px; } .screw.a { background: #DDD; width: 150px; height: 15px; border-radius: 999px; margin: -1px auto 0px; } .screw.b { background: #D9D9D9; width: 135px; height: 15px; margin: -1px auto 0px; } .screw.c { margin: -1px auto 0px; width: 78px; height: 0; border-left: 30px solid transparent; border-right: 30px solid transparent; border-top: 20px solid #DDD; border-radius: 8px; } .screw.d { margin: 0 auto; width: 15px; height: 0; border-left: 30px solid transparent; border-right: 30px solid transparent; border-top: 15px solid #444; } .on #light { -moz-opacity: 1; -khtml-opacity: 1; opacity: 1; } .bulb.top, .bulb.bottom { transition: all 0.5s ease-in-out; } .bulb.middle-1, .bulb.middle-2, .bulb.middle-3 { transition: all 0.5s ease-in-out; }

Mit diesen HTML- und CSS-Dateien sollten Sie bereits eine Zwiebelform in Ihrem Browser sehen können. Gehen Sie voran und öffnen Sie Ihre HTML-Datei, um sie live zu sehen! Funktioniert es? Großartig, jetzt wollen wir ihm etwas Funktionalität geben.

bulb.js

Diese Datei imitiert das Verhalten einer Glühbirne mit einem einfachen Klick auf, Klick aus und richtet ein paar Funktionen ein, die in Kürze verwendet werden, um ihre Farbe über Netbeast zu ändern.

 var color = document.getElementById('color') var power = document.getElementById('power') var bulb = document.getElementById('bulb') var button = document.getElementById('run-btn') var light = document.getElementById('light') button.onclick = function toggleBulbState () { changeBulbParams({ color: color.value, power: power.value }) } function setBulbParams (params) { if (params.power === 'off') { params = { color: 'E7E7E7' } } console.log('set params', params) var bulb_parts = ['.bulb.middle-1', '.bulb.middle-2', '.bulb.middle-3'] document.querySelector('.bulb.top').style.boxShadow = '0px 0px 98px #' + params.color document.querySelector('.bulb.top').style.backgroundColor = params.color document.querySelector('.bulb.bottom').style.backgroundColor = params.color bulb_parts.forEach(function (className) { document.querySelector(className).style.borderTopColor = params.color }) } function changeBulbParams (params) { console.log('change params', params) /* Overwrite html fields if necessary */ color.value = params.color || color.value power.value = params.power || power.value setBulbParams({color: color.value, power: power.value}) }

Danach sollten die Felder und die Schaltfläche „Ausführen“ einen Sinn ergeben. Sie können damit beginnen, die verschiedenen Farben auf Ihrer brandneuen virtuellen Glühbirne auszuprobieren. Der Grund, warum wir den ganzen Weg hierher gekommen sind, war jedoch, es zu einem weiteren Gerät unseres Internet-der-Dinge-Ökosystems zu machen.

hw-api.js

Das letzte unserer selbst erstellten Frontend-JS. Es täuscht eine drahtlose Verbindung mit dem Server vor, wie es eine WiFi- oder Bluetooth-Glühbirne mit ihrer Fernbedienung tun würde, z. B. einem Telefon, Server oder Hub. Es ist die Schnittstelle, die der eigentliche Plugin-Code verwendet, um es zu steuern!

 var socket = io.connect() socket.on('connect', function () { console.log('ws:// bulb is online') }) socket.on('disconnect', function () { console.log('ws:// connection with bulb lost') }) socket.on('set', function (params) { changeBulbParams(params) // uses functions from bulb.js! }) socket.on('get', function () { const params = { power: power.value, color: color.value } socket.emit('params', params) })

Schließlich müssen wir die WebSocket-Bibliothek aus unserem HTML-Code einbinden, damit das Frontend fertig ist. Sie können die Quelle von https://raw.githubusercontent.com/netbeast/bulb-plugin/master/public/socketio.js kopieren und in eine Datei namens socketio.js einfügen . Von einem Terminal mit curl oder wget können Sie dies einfach tun:

 curl https://raw.githubusercontent.com/netbeast/bulb-plugin/master/public/socketio.js > public/socketio.js

Wir hätten jetzt eine Dateistruktur, die so aussieht:

 myplugin ├── README.md ├── index.js ├── package.json ├── public │ ├── bulb.css │ ├── bulb.js │ ├── hw-api.js │ ├── index.html │ └── socketio.js └── test.js

Das Backend

Jetzt werden wir die Schnittstelle mit dem Gerät implementieren und es in der Netbeast-Engine registrieren. Es wartet auf Websockets, um zu erkennen, dass eine Glühbirne im Netzwerk installiert wurde, und führt dann einen POST an die Dashboard-API durch, damit die neuen Ressourcen verfügbar sind.

Schauen wir uns dazu die Dateien an, die wir zuvor generiert haben:

Paket.json

Diese Datei enthält alle Abhängigkeiten und Informationen, die zum Ausführen Ihrer App erforderlich sind. Netbeast verwendet die reguläre package.json auch, um einige Informationen wie den Namen oder den Typ abzurufen. Es ist wichtig anzugeben, dass dieses Paket ein Plugin ist!

 { "name": "myplugin", "version": "0.0.0", "description": "Netbeast plugin for... <your description>", "main": "index.js", "netbeast": { "bootOnLoad": true, "type": "plugin" }, "dependencies": { "bluebird": "^3.3.5", "body-parser": "^1.15.0", "express": "^4.13.4", "minimist": "^1.2.0", "mocha": "^2.3.2", "morgan": "^1.6.1", "netbeast": "^1.0.6", "socket.io": "^1.4.5", "superagent": "^1.8.3" }, "devDependencies": {}, "scripts": { "test": "node test.js", "start": "node index.js" }, "repository": { "type": "git", "url": "GITHUB_REPOSITORY" }, "keywords": [ "iot", "netbeast", "plugin" ], "author": "YOUR_EMAIL", "license": "GPL 3", "bugs": { "url": "ISSUES_CHANNEL" }, "homepage": "HOMEPAGE" }

index.js

Dies ist der Code, der vom Netbeast-Dashboard aufgerufen wird, um das Plugin zu starten! Es muss den Port durch Befehlszeilenargumente akzeptieren, um zu wissen, wo eingehende Anfragen akzeptiert werden sollen. Es wird gestartet, als ob wir node myplugin.js --port <a free port number> . Bitte beachtet auch den Hashbang am Anfang! #!/usr/bin/env node .

 #!/usr/bin/env node var io = require('socket.io')() var express = require('express') var bodyParser = require('body-parser') var app = express() // Netbeast apps need to accept the port to be launched by parameters var argv = require('minimist')(process.argv.slice(2)) app.use(express.static('public')) // will serve our app in an HTTP server app.use(bodyParser.json()) // will parse JSON API calls app.use('/api', require('./plugin')(io)) var server = app.listen(argv.port || 31416, function () { console.log('Bulb plugin listening at http://%s:%s', server.address().address, server.address().port) }) // we need websockets to push updates to browser view io.listen(server)

Wie Sie sehen können, fehlte uns eine Datei, um es zu starten, diejenige, die die socket.io- Controller tatsächlich implementiert. Nichts Besonderes!

plugin.js

 var express = require('express') var netbeast = require('netbeast') var router = express.Router() var bulbParams // auxiliar variable, nasty way to transmit changes, but works module.exports = function (io) { io = io // Create resource that works on lights topic and listens on /api route netbeast('lights').create({ app: 'myplugin', hook: '/api' }) io.on('connection', function () { console.log('ws:// bulb has connected to plugin') }) io.on('disconnection', function () { console.log('ws:// bulb has disconnected from plugin') }) io.on('connect_failure', function (err) { console.trace(err) }) router.post('/', function (req, res) { io.emit('set', { power: req.body.power, color: req.body.color, }) res.status(200).json(req.body) }) router.get('/', function (req, res) { io.emit('get') var timerReference = setTimeout(function () { if (bulbParams) { res.json(bulbParams) } else { res.status(200).json({ error: 'No bulb available' }) } }, 3000) }) return router }

Starten Sie Ihre App

Jetzt ist es an der Zeit, Ihre App zu testen. Sie können dies tun, indem Sie sie in ein tar.gz -Format packen und im Drag-and-Drop-Bereich http://localhost:8000/install auf Ihr Dashboard hochladen.

 beast package # Compresses your app when ran in myplugin dir

Voila! Sie können jetzt zu Ihren Plugins gehen und es ausprobieren. Gehen Sie zum Netzwerkbereich (http://localhost:8000/devices), um zu sehen, wie es ausgeführt wird, und ändern Sie von dort aus seine Farbe.

Wenn etwas schief geht oder Sie glauben, ein Detail übersehen zu haben, versuchen Sie, es lokal mit node index.js , und vielleicht ist es einfacher zu debuggen als im netbeast start .

Veröffentlichen Sie Ihre Arbeit

Wenn Sie möchten, dass Ihre App im Abschnitt „Erkunden“ des Netbeast-Dashboards angezeigt wird, müssen Sie ein Repository in GitHub mit der Netbeast-App oder dem Netbeast-Plugin erstellen, die beide in der Beschreibung und in README.md enthalten sind .

Um die Apps zu finden, verwenden wir die Such-API von GitHub. Wir sehen die gleichen Ergebnisse, die erscheinen, wenn Sie eine GET-Anfrage an: https://api.github.com/search/repositories?q=netbeast+language:javascript stellen

Sie wissen, dass Ihre App angezeigt wird, wenn sie dort erscheint!

Was kommt als nächstes?

Beide Projekte sind Open Source und haben wirklich involvierte Communities. Wenn Sie mit der Erstellung Ihrer eigenen Flows oder Knoten für Node-RED beginnen möchten, werfen Sie einen Blick auf die offizielle Dokumentation. Folgen Sie den dort beschriebenen Schritten und Sie sollten in kürzester Zeit Ihren eigenen Knoten oder Flow veröffentlichen können.

Wenn Sie andererseits in Netbeast eintauchen möchten, können Sie auch deren Dokumentation folgen oder einen Blick auf das Dashboard-Repository werfen. Mit der Netbeast-API müssen Sie sich nicht mehr auf einzelne Geräte, Marken oder Technologien konzentrieren, also probieren Sie es aus. Sie können hier mehr darüber erfahren oder ihrem Slack-Kanal beitreten und über Node-RED, IoT oder Node.js diskutieren.

Wenn Sie dieses Zeug auf einem Raspberry Pi, Beagle Bone oder einem alten Server installieren möchten, würden Sie es ohne Code in einen hackbaren Smart Hub verwandeln! Es gibt vorgefertigte Builds für sie auf beiden Seiten.

Fröhliches Hacken.