(Note : ces informations ont été compilées à partir de différentes sources anglaises/françaises)

Il existe deux types d’architectures les plus courantes : - Request/Response (ReqRep) : Qui ressemble à la technologie client/serveur (comme HTTP) - Publish/Subscribe (PubSub) : Des entités “publishers” publient un message (dans un “topic”) sur le réseau sans se soucier des destinataires du message. Les “subscribers” s’abonnent à un “topic” et reçoit tous les messages du “topic”. Le “broker” fait office de centralisateur des messages des “publishers” et se charge des envoyés aux “subscribers”. Le gros désavantage de cette architecture est la présence du “broker” qui est en fait un SPoF (Single point of Failure).

Avantages et Inconvénients : Request-response vs. publish-subscribe

CoAP reprend les concepts du protocole HTTP en s’appuyant sur le protocole UDP et en allégeant les communications (paquet plus petit notamment)

Infos : The Constrained Application Protocol (CoAP)

Points clefs: - Request/Response Architecture - UDP/IP Based - QoS Support - Supports Unicast as well as Multicast - Uses DTLS for Security - Supports Resource Discovery - CoAP Node plays Server Role too (NAT Issues) - Decentralised (No Single Point of Failure)

REST (Representational State Transfer) est un concept, et non pas un protocole. Les API (application programming interface) REST utilisent des méthodes HTTP pour exécuter des actions. Il s’agit d’une interface pour permettre de communiquer avec l’objet.

Le gros désavantage du REST est qu’il s’agit d’une connexion à un seul sens.

Infos : MQTT Vs REST

Points clés: - Request/Response Architecture - TCP/IP Based - No QoS Support - Complex Implementation at Client Side - Larger Header compared to other IoT Protocols (Higher Bandwidth Requirement) - Uses SSL/TLS for Security

MQTT est un protocole de messagerie spécifiquement conçu pour des applications M2M (Machine To Machine) et IoT (Internet of Things), à cause notamment de sa légèreté (peu de consommation de bande passante et d’énergie).

De plus, il permet la publication des nouvelles données en temps, sans nécessiter d’interroger un serveur, ce qui permet une réactivité et une économie de bande passante supplémentaire.

MQTT offre une Qualité de service (QoS) à 3 niveaux : - QoS 0 : transmission de message sans accusé de réception - QoS 1 : transmission de message avec accusé de réception - QoS 2 : transmission de message avec accusé de réception et vérification du message transmis afin d’éviter qu’un même message ne soit pas transmis de nombreuses fois.

MQTT-SN (MQTT for Sensor Network) est une version optimisée pour les objets à très faibles ressources communiquant sans fil.

Points clés : - Publish/Subscribe Architecture - Light Weight (Min Header Size: 2 Bytes) - TCP/IP Based - QoS Support - Payload Agnostic - Uses SSL/TLS for Security - Broker could be Single Point of Failure

XMPP est à la base un protocole pour la messagerie instantanée (Jabber, iChat, ICQ, MSN, Google Talk, etc.), mais elle a été conçue de manière plus large et ouverte qu’une simple messagerie instantanée populaire et propriétaire. Cela lui permet de supporter aussi bien l’architecture request/response que publish/subscribe, via des flux de données au format XML.

• Publish/Subscribe and Request/Response Architecture
• Widely used for Instant Messaging, Presence, Voice/Video Calls etc.
• No QoS Support
• Text Based Communication (XML Payload)
• Secure Authentication (SASL) and TLS Based Security
• XML Payload creation and parsing may need extra compute and battery power.

AMQP est similaire à MQTT, à la différence prêt qu’il gère une file d’attente pour la distribution des messages. La présence de cette file nous permet un contrôle fin de la gestion des messages. Cependant, elle est assez lente dans les environnements à bandes passantes faibles.

Points clés : - Point to Point Message Exchange (Server to Server) - Flexible Messaging Patterns - TCP/IP Based - Smallest Packet Size: 60 Bytes - QoS Support - Uses SSL/TLS for Security

DDS a l’avantage de ne pas utiliser de “broker”, ce qui nous donne une gestion décentralisée (pas de présence de SPoF). Cependant, il semblerait que DDS ne fonctionnerait pas sur Arduino…

Points clés : - Publish/Subscribe and Request/Response Architecture - Relational data modeling - QoS Support - Multicast support over plain UDP sockets - Leverages both TCP/IP and UDP/IP Transport - Uses TLS and DTLS for Security - Decentralised (No Single Point of Failure)

Au vu des différentes options qui s’offrent et surtout par rapport aux projets existants dans le domaine, nous avons décidé de choisir le protocole MQTT.

MQTT est un standard OASIS (ization for the Advancement of Structured Information Standards). MQTT est très largement utilisé dans tout ce qui est IoT car il est léger et ne consomme que très peu de bande passante.

Pour rappel, dans un système MQTT complet nous retrouvons quatre notions importantes : - Les publishers : L’origine des messages - Les subscribers : La destination des messages - Le broker : L’élément qui fait le lien entre les publishers et les subscribers - Les topics : Canaux de communications.

Message Queue Telemetry Transport, MQTT pour abréger, est un protocole de messagerie utile dans la communication entre les dispositifs de l’Internet des objets. Fait intéressant, le protocole a été développé en 1999, alors que l’IdO, qui connaît une croissance rapide, en était à ses balbutiement.

Le MQTT utilise un paradigme de publication-abonnement. Nous comprenons tous les connexions point à point entre les pairs. C’est la base des conversations téléphoniques entre deux personnes. La connexion client-serveur est un autre liaison point à point bien connu. Pour afficher une page Web, un navigateur, qui est le client, demande la page à un serveur HTML qui peut envoyer la page ou qui peut refuser de le faire. Dans ces types de liens, chaque partie doit adresser ses messages à son interlocuteur intentionnellement. Avec MQTT, les dispositifs peuvent publier des données ou s’abonner pour recevoir des données après d’un «courtier». Certains appareils publient en même temps qu’ils sont abonnés. Lorsqu’un dispositif publie des données, il n’est pas nécessaire qu’il sache quels seront les dispositifs qui sont abonnés pour les recevoir. Un dispositif abonné, reçoit des données lorsqu’elles sont disponibles sans avoir à les demander d’un dispositif particulier. Au lieu de cela, le courtier agit comme un centre d’information qui reçoit toutes les données publiées organisées par «sujets», et envoie ces données à tous les abonnés de chaque sujet spécifique.

L’utilisation d’un courtier signifie que la publication de données d’un à plusieurs dispositifs est possible en même temps que la lecture de données de plusieurs vers un seul dispositif. Voici un arrangement typique.

Le climatiseur est enregistré auprès du serveur MQTT pour recevoir toutes les messages au sujet de la «température» et de l’«humidité». Les capteurs de température et d’humidité ne sont pas enregistrés pour recevoir des messages, ils ne font que publier des messages vers le courtier.

Toutes les dix minutes, le capteur de température publie la température ambiante. Dans la pratique, cela signifie qu’il envoie un seul numéro, disons 23, sous le sujet «température» au courtier MQTT, pour qu’il fait actuellement 23°C. De même, toutes les quinze minutes, le capteur d’humidité publie des messages au sujet de l’«humidité» vers le courtier MQTT, pour signifier que le facteur d’humidité est de 62%. À son tour, le courtier MQTT transmet ces messages à l’unité de conditionnement d’air. Cette dernière décide si elle doit s’allumer ou s’éteindre sur la base de ces deux mesures. C’est Internet des objets au travail.

Un programme de domotique qui prend en charge le protocole MQTT peut être ajouté au système pour fournir “intelligence” et contrôle. L’architecture du système pourrait être quelque chose comme ci-dessous.

> Le programme de domotique est abonné auprès du courtier MQTT pour recevoir toutes les messages aux sujets de la «température», de la «pression» et de l’«état du climatiseur». Le climatiseur est abonné auprès du serveur MQTT pour recevoir toutes les messages sur le thème «climatisation».

Comme auparavant, les capteurs de température et d’humidité publient des données vers le courtier. Mais maintenant, le programme de domotique qui est abonné pour recevoir cette information décide si le climatiseur doit être allumé ou éteint en tenant compte des données du capteur, de l’heure, du délai depuis la dernière fois que l’appareil est allumé ou éteint, la présence de personnes dans la maison, etc. Il ordonne au climatiseur de se mettre en marche ou de cesser de fonctionner en publiant un message sur le thème «climatisation». Le climatiseur publie des modifications sur son état sous le thème “état du climatiseur”. Parce que le programme de domotique est abonné à ce thème, il sait quand la climatisation a été activée ou désactivée par un individu.

Source : https://www.sigmdel.ca/michel/ha/domo/domo03fr.html// ===== Pratique ===== Dans cette partie, nous allons créer un broker sur un Raspberry Pi et les publishers seront des Arduino. ==== Raspberry Pi : Préparation de la carte SD ==== * Télécharger la dernière version de la distribution Raspbian * Télécharger Win32DiskImager (pour création depuis windows) * Flasher l’image sur la carte SD ==== Raspberry Pi : Installation et sécurisation ==== Pour une configuration “Headless”, c.-à-d. sans écran et sans clavier, pour que celle-ci puisse démarrer et se connecter en Wifi à votre réseau internet : - Activer la connexion SSH en créant un fichier ssh (sans extension) dans la partition boot - Créer un fichier wpa_supplicant.conf, situé à la racine de la partition boot de la carte avec : <code> country=fr update_config=1 ctrl_interface=/var/run/wpa_supplicant network={ scan_ssid=1 ssid=“LE2P” psk=“XXXXXX” } </code> <HTML><ul></HTML> <HTML><li></HTML>[Optionnel] Fixer l’adresse IP de la machine si besoin pour le wifi<HTML></li></HTML> <HTML><li></HTML><HTML><p></HTML>Faire sudo nano /etc/dhcpcd.conf et mettre ceci<HTML></p></HTML> <code> interface wlan0 static ip_address=192.168.1.2/24 static routers=192.168.1.1 static domain_name_servers=192.168.1.1 </code><HTML></li></HTML> <HTML><li></HTML><HTML></li></HTML> <HTML><li></HTML>Au besoin désactiver le ipV6 en éditant le faisant sudo nano /etc/sysctl.d/local.conf et en mettant la ligne suivante net.ipv6.conf.all.disable_ipv6=1<HTML></li></HTML> <HTML><li></HTML>Faire ensuite sudo ifconfig wlan0 down && sudo ifconfig wlan0 up<HTML></li></HTML> <HTML><li></HTML>Configurer raspberry avec sudo raspi-config<HTML></li></HTML> <HTML><li></HTML>Changer les options de localisations (FR etc.)<HTML></li></HTML> <HTML><li></HTML>sudo apt-get update && sudo apt-get upgrade<HTML></li></HTML> <HTML><li></HTML>sudo apt-get install ntpdate<HTML></li></HTML> <HTML><li></HTML>Changer le mot de passe par défaut : passwd<HTML></li></HTML> <HTML><li></HTML>Mettre à jour la date du Raspberry :<HTML></li></HTML> <HTML><li></HTML>Faire sudo apt-get install ntp<HTML></li></HTML> <HTML><li></HTML>Editer le fichier sudo nano /etc/ntp.conf et dans les pools rajouter ntp.univ.run (uniquement dans le cas d’un serveur interne à L’université de la Réunion)<HTML></li></HTML> <HTML><li></HTML>[Optionnel] Créer un username différent :<HTML></li></HTML> <HTML><li></HTML>Faire sudo adduser house001 et entrer le mot de passante<HTML></li></HTML> <HTML><li></HTML>Faire sudo adduser house001 sudo pour l’ajouter au groupe sudo<HTML></li></HTML> <HTML><li></HTML>Au besoin, supprimer l’utilisateur pi en faisant sudo deluser -remove-home pi ou encore le désactiver en faisant sudo passwd --lock pi<HTML></li></HTML> <HTML><li></HTML>[Optionnel] Pour plus de sécurité, il est possible ensuite (tuto sur ce site) :<HTML></li></HTML> <HTML><li></HTML>Interdire l’accès root en SSH<HTML></li></HTML> <HTML><li></HTML>Obliger le mot de passe pour les sudo<HTML></li></HTML> <HTML><li></HTML>Forcer l’utilisation de clés SSH<HTML></li></HTML> <HTML><li></HTML>Installer un firewall (ufw ou iptables)<HTML></li></HTML> <HTML><li></HTML><HTML><p></HTML>Installer fail2ban<HTML></p></HTML><HTML></li></HTML><HTML></ul></HTML> ==== Raspberry Pi : Installation du broker ==== <HTML><ul></HTML> <HTML><li></HTML>sudo apt-get install mosquitto<HTML></li></HTML> <HTML><li></HTML>Vérifier la bonne installation en faisant systemctl status mosquitto, éventuellement après un reboot<HTML></li></HTML> <HTML><li></HTML>Dans le cas où cela ne fonctionne pas après le reboot, faire sudo systemctl enable mosquitto.service<HTML></li></HTML> <HTML><li></HTML>[Optionnel] Créer un accès par mot de passe<HTML></li></HTML> <HTML><li></HTML>sudo mosquitto_passwd -c /etc/mosquitto/passwd user<HTML></li></HTML> <HTML><li></HTML><HTML><p></HTML>Dans /etc/mosquitto/mosquitto.conf, rajouter les lignes<HTML></p></HTML> <code> allow_anonymous false password_file /etc/mosquitto/passwd </code><HTML></li></HTML> <HTML><li></HTML><HTML><ul></HTML> <HTML><li></HTML>Faire systemctl restart mosquitto<HTML></li></HTML><HTML></ul></HTML> <HTML></li></HTML><HTML></ul></HTML> Nous interdisons l’accès en anonyme et nous allons autoriser les connexions uniquement avec un identifiant mot de passe (dont la liste se trouve le fichier passwd que nous avons créé et est de la forme user:motdepasse). Il est possible aussi pour plus de sécurité de changer le port par défaut (1883), mais dans ce cas, on s’éloigne du standard. * Pour tester la connexion depuis un autre appareil, il est possible d’utiliser le client Java (fichier jar) mqtt-spy à fois comme publisher et subscribers (Infos sur l'appli) ou encore MyMQTT sur Android ==== Rappel : Fonctionnement des flux ==== Source : https://www.sigmdel.ca/michel/ha/domo/domo03fr.html//

Les sujets/flux/themes MQTT sont hiérarchiques et représentés d’une manière très similaire aux chemins de fichiers complets (en utilisant le séparateur Unix /). Et, un peu comme les noms de fichiers, il existe des caractères génériques :

• # qui représente tous les sujets de niveau inférieur. Par conséquent, s’abonner à la maison/# signifie que le courtier enverra tous les messages avec des sujets tels que maison, maison/humidité, maison/température, maison/température/centigrade, maison/température/fahrenheit, et ainsi de suite.
• + qui représente un niveau unique dans la hiérarchie des sujets. Par conséquent, l’abonnement à la maison/+/commutateurs signifie que les messages avec des sujets tels que maison/chambre/commutateurs et maison/cuisine/commutateurs seront reçus, mais pas ceux dont le thème est maison/interrupteurs ni maison ni interrupteurs.

Pour des raisons évidentes, vous ne pouvez pas avoir un des caractères /, #, + dans le sujet. Il n’est pas judicieux d’inclure ces caractères dans un nom d’utilisateur ou un identifiant de client (voir le conseil de sécurité CVE-2017-7650 de mosquitto.org.) Vous pouvez utiliser le texte codé UTF-8 dans des sujets tels que /saison/été.

Lors du débogage de la communication avec un serveur MQTT, il peut s’avérer utile de s’abonner à toutes les rubriques en faisant mosquitto_sub -h 192.168.0.22 -v -t "#"

Dans notre cas, nous avons utilisé : - Un Arduino Uno R3 - Un Grove Base Shield - Un Grove - LCD RGB Backlight - Un Adafruit ATWINC1500 WiFi Shield

Le Grove - LCD RGB Backlight est branché sur le 1er port I2C du Grove Base Shield. Ce dernier (mis sous 5V) a été placé entre le WiFi Shield et l’Arduino.

L’Arduino est alimenté par une source externe par connecteur Jack, à 7V, en respectant la polarité (le + est à l’intérieur et le - à l’extérieur).

Les Adafruit ATWINC1500 WiFi Shield ont été mis à jour avec le dernier firmware (Voir Site officiel).

Un réseau wifi (avec le ssid opale) a été créé avec un routeur wifi pour permettre au Raspberry Pi et à l’Arduino de communiquer.

Il est important de bien configurer l’IDE et d’importer les bibliothèques nécessaires : - Librairies : - WiFi101 - Adafruit IO Arduino - Grove - LCD RGB Backlight - Pubsubclient ← non utilisé - Configuration : - Type de carte : Arduino/Genuino Uno - Serial : 9600 baud

Le déroulement du programme est le suivant : - Imports & Initialisations - Connexion au WiFi - Inscription au flux user/feeds/onoff - Boucle : - Connection au serveur MQTT (si non connecté ou si déconnexion) - Ecoute au flux user/feeds/onoff et affiche sur le LCD s’il y ON ou OFF reçus. - Publication d’un entier (croissant au fur et à mesure) sur le flux user/feeds/numbers

Le code du programme MQTT_Basic est :

/***************************************************
  Adafruit MQTT Library WINC1500 Modified by Yassine
 
  Demo written by Limor Fried/Ladyada for Adafruit Industries.
  Modified by Yassine Gangat for LE²P.
 
  MIT license, all text above must be included in any redistribution
 ****************************************************/
#include <SPI.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
#include <WiFi101.h>
 
// ---------------------------- GROVE LCD Lib -------------------------
//#include <Wire.h>           // i2c LIB to use LCD
#include "rgb_lcd.h"        // lcd LIB
 
#include "arduino_secrets.h"
///////please enter your sensitive data in the Secret tab/arduino_secrets.h
const char ssid[] = SECRET_SSID;        // your network SSID (name)
const char pass[] = SECRET_PASS;       // your network password (use for WPA, or use as key for WEP)
int status = WL_IDLE_STATUS;     // the WiFi radio's status
// int keyIndex = 0;                // your network key Index number (needed only for WEP)
 
/************************* Broker Setup **********************************/
 
#define SERVER      "192.168.2.2"
#define SERVERPORT  1883
#define USERNAME    "user"
#define PWD         "apqm"
 
/******************************* Global State  ****************************/
 
//Set up the wifi client & Adafruit MQTT Client
WiFiClient client;
Adafruit_MQTT_Client mqtt(&client, SERVER, SERVERPORT, USERNAME, PWD);
 
#define halt(s) { Serial.println(F( s )); while(1);  }
 
/****************************** Feeds ***************************************/
 
// Setup a feed called 'photocell' for publishing.
// Notice MQTT paths for AIO follow the form: <username>/feeds/<feedname>
Adafruit_MQTT_Publish numbers = Adafruit_MQTT_Publish(&mqtt, USERNAME "/feeds/numbers");
 
// Setup a feed called 'onoff' for subscribing to changes.
Adafruit_MQTT_Subscribe onoffmsg = Adafruit_MQTT_Subscribe(&mqtt, USERNAME "/feeds/onoff");
 
 
 
/*************************** Sketch Code ************************************/
 
// --------------------------- Variables & others --------------------------------
rgb_lcd lcd;
byte heart[8] = {
    0b00000,
    0b01010,
    0b11111,
    0b11111,
    0b11111,
    0b01110,
    0b00100,
    0b00000
};
 
void setup() {
    // ------------------------- Initialization Serial ------------------------------
    while (!Serial);  // wait for serial port to connect. Needed for native USB port only
    Serial.begin(9600);
 
    Serial.println(F("Adafruit MQTT Library WINC1500 Modified by Yassine"));
 
    // ---------------------- Initialization Wifi WINC1500 --------------------------
    // Initialise the Client
    Serial.print(F("\nInit the WiFi module..."));
    // check for the presence of the breakout
    if (WiFi.status() == WL_NO_SHIELD) {
        Serial.println(F("WINC1500 not present"));
        // don't continue:
        while (true);
    }
    Serial.println(F("ATWINC OK!"));
 
    // ------------------------------ Physical part ----------------------------------
 
    Serial.println(F("LCD Init"));
    // set up the LCD's number of columns and rows:
    lcd.begin(16, 2);
 
    // Print a message to the LCD.
#if 1
    lcd.createChar(0, heart);
#endif
    lcd.setCursor(0, 0);
    lcd.print(F("Made with "));
    lcd.write((unsigned char)0);
    lcd.setCursor(0, 1);
    lcd.print(F("     by Yassine"));
 
    // --------------------------- Variables & others --------------------------------
    mqtt.subscribe(&onoffmsg);
}
 
uint32_t x = 0;
 
void loop() {
    // ------------------------------ MQTT Connection --------------------------------
    // Ensure the connection to the MQTT server is alive (this will make the first
    // connection and automatically reconnect when disconnected).
    MQTT_connect();
    lcd.setRGB(255,165,0);
    // ------------------------------ Subscription -----------------------------------
    Adafruit_MQTT_Subscribe *subscription;
    while ((subscription = mqtt.readSubscription(5000))) {
        if (subscription == &onoffmsg) {
            Serial.print(F("Got: "));
            Serial.println((char *)onoffmsg.lastread);
 
            if (0 == strcmp((char *)onoffmsg.lastread, "OFF")) {
                lcd.setRGB(255,0,0);
                lcd.setCursor(0, 1);
                lcd.print(F("Received OFF    "));
            }
            if (0 == strcmp((char *)onoffmsg.lastread, "ON")) {
                lcd.setRGB(0,255,0);
                lcd.setCursor(0, 1);
                lcd.print(F("Received ON     "));
            }
        }
    }
 
    // ------------------------------ Publication ----------------------------------
    Serial.print(F("\nSending "));
    Serial.print(x);
    lcd.setCursor(0, 1);
    lcd.print(F("Sending         "));
    lcd.setCursor(8, 1);
    lcd.print(x);
 
    if (! numbers.publish(x++)) {
        Serial.println(F("...Failed"));
    } else {
        Serial.println(F("...OK!"));
    }
 
}
 
// Function to connect and reconnect as necessary to the MQTT server.
// Should be called in the loop function and it will take care if connecting.
void MQTT_connect() {
    int8_t ret;
 
    // attempt to connect to Wifi network:
    while (WiFi.status() != WL_CONNECTED) {
        Serial.print(F("Attempting to connect to SSID: "));
        Serial.println(ssid);
        // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
        status = WiFi.begin(ssid, pass);
 
        // wait 10 seconds for connection:
        uint8_t timeout = 10;
        while (timeout && (WiFi.status() != WL_CONNECTED)) {
            timeout--;
            delay(1000);
        }
    }
 
    // Stop if already connected.
    if (mqtt.connected()) {
        return;
    }
 
    Serial.print(F("Connecting to MQTT... "));
 
    while ((ret = mqtt.connect()) != 0) { // connect will return 0 for connected
        Serial.println(mqtt.connectErrorString(ret));
        Serial.println(ret);
        Serial.println(F("Retrying MQTT connection in 5 seconds..."));
        mqtt.disconnect();
        delay(5000);  // wait 5 seconds
    }
    Serial.println(F("MQTT Connected!"));
}

Remarques sur ce code : - Le USERNAME et PWD sont ceux qui ont été défini dans les mosquitto_passwd (voir précédemment). - Le mot de passe du wifi est stocké dans arduino_secrets.h (mais celui du broker, volontairement) - Dès que la mémoire dynamique (vive) est utilisé à plus de 80%, il y a des soucis de connexion au wifi comme au MQTT. - La solution la plus rapide pour diminuer ce nombre a été de remplacer Serial.println("Text") par Serial.println(F("Text")). Cela fonctionne aussi pour les lcd.print. - Une autre solution est de mettre const partout où celà est possible ! - Une solution plus complexe mais envisageable à la fin est d’utiliser PROGMEM. - Sachant que les Serial.println utilise beaucoup cette SRAM, il est possible : - de le supprimer lorsque tout fonctionne - d’utiliser ce genre d’astuce

#define DEBUG    //que l'on commente avant de téléverser

puis dans le code…

#ifdef DEBUG
Serial.prinlln(F("Affichage\n"));
#endif

Plus d’informations sur la fonction F() et sur la gestion de mémoire sont disponible : - en français sur ce site et ce site. - en anglais sur ce site et ce forum.

Il est possible d’accéder au broker depuis l’extérieur en suivant une partie du tuto suivant : Tuto IpDynamique

Node-RED est un outil puissant pour construire des applications de l’Internet des Objets (IoT) en mettant l’accent sur la simplification de la programmation qui se fait grâce à des blocs de code prédéfinis, appelés « nodes » pour effectuer des tâches. Il utilise une approche de programmation visuelle qui permet aux développeurs de connecter les blocs de code ensemble. Les nœuds connectés, généralement une combinaison de nœuds d’entrée, de nœuds de traitement et de nœuds de sortie, lorsqu’ils sont câblés ensemble, constituent un « flow ». Tuto Node-Red

La vocation de cette solution est de permettre de lier aisément des sources de données à des composants de traitement, locaux ou distants, et de créer des chaines de valeurs en quelques clics.

Node-RED est compatible avec MQTT : Tuto MQTT Node-Red