Système intelligent de surveillance de la qualité de l'air intérieur et des déchets

Composants et fournitures

Raspberry Pi 3 Model B	×	1
Arduino UNO	×	1
NodeMCU ESP8266 Breakout Board	×	1
Capteur température/humidité DHT11 (4 broches)	×	1
Seeed Grove - Capteur de gaz (MQ2)	×	1
Capteur de gaz CO MQ-7 (générique)	×	1
Capteur ultrasonique HC-SR04 (générique)	×	1
Alimentation Raspberry Pi	×	1
Câble HDMI	×	1
Câble USB-A vers B	×	1
Fils de connexion (génériques)	×	1
Batterie 5V (générique)	×	1

Applications et services en ligne

IOTA Tangle
Node.js
Raspberry Pi Raspbian
Arduino IDE
MQTT

À propos de ce projet

1. Introduction

L'automatisation des bâtiments est le contrôle centralisé automatique du chauffage, de la ventilation, de la climatisation, de l'éclairage et d'autres systèmes d'un bâtiment via un système de gestion technique (BMS) ou un système d'automatisation des bâtiments (BAS). Les objectifs sont l'amélioration du confort des occupants, l'exploitation efficace des systèmes du bâtiment, la réduction de la consommation d'énergie et des coûts d'exploitation, et l'amélioration du cycle de vie des équipements.

Système intelligent de surveillance de la qualité de l air intérieur et des déchets

IOTA est une technologie de comptabilité distribuée open source, dont l'objectif est d'échanger de manière sécurisée informations et valeur dans l'Internet des objets. L'une des principales innovations d'IOTA est qu'au lieu de la blockchain traditionnelle, elle utilise sa propre architecture (Tangle) basée sur un concept mathématique appelé graphe acyclique orienté (DAG). Cette architecture permet l'absence de commissions, une faible latence réseau et de meilleures perspectives d'évolutivité. IOTA est actuellement en développement et devrait être prêt pour une adoption à grande échelle au cours de 2019.

Les spécifications du Raspberry Pi 3 B incluent :

CPU : Quad-core 64-bit ARM Cortex A53 à 1,2 GHz
GPU : VideoCore IV multimédia 400 MHz
Mémoire : 1 Go LPDDR2-900 SDRAM (900 MHz)
Ports USB : 4
Sorties vidéo : HDMI, vidéo composite (PAL et NTSC) via jack 3,5 mm
Réseau : Ethernet 10/100 Mbps et Wi-Fi 802.11n

Caractéristiques de la carte Arduino UNO :

Microcontrôleur : ATmega328
Tension de fonctionnement : 5V
Tension d'entrée (recommandée) : 7-12V
Tension d'entrée (limites) : 6-20V
Broches I/O numériques : 14 (dont 6 fournissent une sortie PWM)
Broches d'entrée analogique : 6
Courant DC par broche I/O : 40 mA
Courant DC pour broche 3,3V : 50 mA

NodeMCU, caractéristiques :

Module WiFi programmable
Matériel IO de type Arduino (défini par logiciel)
Programmable avec l'IDE Arduino
USB-TTL inclus, plug & play
10 GPIO D0-D10, fonctionnalité PWM, communication IIC et SPI, 1-Wire et ADC A0, le tout sur une seule carte

Ce projet est divisé en trois versions. Pour une meilleure compréhension, nous l'avons divisé en chapitres :

1. Introduction
2. Installation logicielle
3. Système de surveillance de la qualité de l'air intérieur v1
4. Système de surveillance de la qualité de l'air intérieur v2
5. Système de surveillance des déchets
6. Conclusions

2. Installation logicielle

a) Installer Raspbian sur le Raspberry PI 3 B

J'ai installé NOOBS, le lien de téléchargement et les instructions sont sur : https://www.raspberrypi.org/downloads/

b) Installer Node.JS

$ curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
$ sudo apt-get install -y nodejs

c) Télécharger et compiler la bibliothèque BCM2835 sur le Raspberry Pi. Cette bibliothèque nous aide à travailler avec le capteur DHT11.

$ wget https://www.airspayce.com/mikem/bcm2835/bcm2835-1.56.tar.gz
$ tar zxvf bcm2835-1.56.tar.gz
$ cd bcm2835-1.56
$ ./configure
$ make
$ sudo make check
$ sudo make install

d) Télécharger et installer le projet indoor-air-quality-iota sur le Raspberry Pi

$ cd ~
$ git clone https://github.com/guillengap/indoor-air-quality-and-garbage-monitoring-system.git
$ cd indoor-air-quality-and-garbage-monitoring-system
$ npm install

e) Télécharger et installer serialport

$ npm install serialport

f) Télécharger et installer l'IDE Arduino :

https://www.arduino.cc/en/Main/Software

3. Système de surveillance de la qualité de l'air intérieur v1

Les données du capteur DHT11 sont lues et publiées sur le Tangle en utilisant MAM.

Comment ça fonctionne ?

a) Le projet indoor-air-quality-iota comporte 3 fichiers JavaScript :

sensor.js : Lecture et affichage des données du capteur DHT11 : température et humidité.
mam_sensor.js : Lecture des données du DHT11 et publication sur le Tangle IOTA via MAM.
mam_receive.js : Extraction des données stockées sur le Tangle IOTA via MAM et affichage.

b) Le point de terminaison du nœud complet et la clé latérale sont codés en dur dans les fichiers JavaScript. Pour arrêter un script, appuyez sur CTRL+Z.

c) Connecter la carte Arduino UNO et le capteur DHT11.

d) Exécuter node sensor.js pour vérifier si le Raspberry Pi peut lire les données de température et d'humidité du module capteur DHT11.

$ node sensor.js

On peut voir les données d'humidité et de température capturées par le capteur DHT11. Si tout va bien, on passe à l'étape suivante.

e) Exécuter node mam_sensor.js. Ce script stockera les données de température et d'humidité du module capteur DHT11 sur le Tangle.

$ node mam_sensor.js

Nous avons testé avec trois nœuds et obtenu de meilleurs résultats avec : https://potato.iotasalad.org:14265

//const iota = new IOTA({ provider: 'https://nodes.testnet.iota.org:443' });
const iota = new IOTA({ provider: 'https://potato.iotasalad.org:14265' });
//const iota = new IOTA({ provider: 'https://peanut.iotasalad.org:14265' });

Vous pouvez consulter certains nœuds disponibles sur : https://iotasalad.org/nodes

Nous envoyons les informations suivantes :

Ville : MEXIQUE
Bâtiment : 65
Date et heure (UTC) : ANNÉE. MOIS, JOUR, HEURE. MINUTES ET SECONDES
Données : Température en degrés Celsius et Fahrenheit et Humidité relative en pourcentage

f) Ouvrir un autre terminal et taper : node mam_receive.js your_root et les données des capteurs stockées s'affichent. Par exemple :

$ node mam_receive.js AMBTIKZKEVEEQFCUGIDUOLDOXL9OZQ9GOMNBFYHVRAUCAMHDQQJBSNAMFZYRLTUVAHFDINHTTFKIPELIG

Le code qui gère les données reçues est :

// RÉCUPÉRATION DES DONNÉES DU TANGLE
const executeDataRetrieval = async function(rootVal, keyVal) {
 let resp = await Mam.fetch(rootVal, MODE, keyVal, function(data) {
 let json = JSON.parse(iota.utils.fromTrytes(data));
 console.log(`City: ${json.city}, Building: ${json.building}, Time: ${json.dateTime} UTC, Data: ${json.data}`);
 });
}

Test

Images

4. Système de surveillance de la qualité de l'air intérieur v2

Les données des capteurs DHT11, MQ-2 et MQ-7 sont lues et publiées sur le Tangle en utilisant MAM.

Comment ça fonctionne ?

a) Le projet indoor-air-quality-iota comporte 5 fichiers :

sensorArduino.ino : Ce code capture les données des trois capteurs : DHT11 (humidité et température), MQ-2 (gaz LPG) et MQ-7 (gaz CO).
listportsArduino.ino : Affiche les ports disponibles de la carte Arduino UNO.
sensorArduino.js : Lecture et affichage des données des capteurs DHT11, MQ-2 et MQ-7.
mam_sensorArduino.js : Lecture des données des capteurs DHT11, MQ-2 et MQ-7 et publication sur le Tangle via MAM.
mam_receiveArduino.js : Extraction des données stockées sur le Tangle via MAM et affichage.

b) Le point de terminaison du nœud complet et la clé latérale sont codés en dur dans les fichiers JavaScript. Pour arrêter un script, appuyez sur CTRL+Z.

c) Connecter la carte Arduino UNO et les capteurs : DHT11, MQ-2 et MQ-7.

d) Dans le dossier "sensorArduino", qui se trouve dans le projet indoor-air-quality-iota, nous avons les bibliothèques des capteurs : DHT11, MQ-2 et MQ7. Nous devons les installer dans les bibliothèques Arduino.

e) Téléverser le sketch sensorArduino.ino sur la carte Arduino UNO et l'exécuter. Sélectionner le port de communication avec l'Arduino UNO, dans mon cas : Outils > Port > /dev/ttyACM0

f) Ouvrir un terminal et exécuter node listportsArduino.js pour vérifier que notre port est actif.

$ node listportsArduino.js

g) Exécuter node mam_sensorArduino.js. Ce script stockera les données de la carte Arduino UNO sur le Tangle.

$ node mam_sensorArduino.js

Nous envoyons les informations suivantes :

Ville : NY
Bâtiment : 13
Date et heure (UTC) : ANNÉE. MOIS, JOUR, HEURE. MINUTES ET SECONDES
Données : Gaz LPG en ppm, Gaz CO en ppm, Température en degrés Celsius, Pourcentage d'humidité relative

h) Ouvrir un autre terminal et taper : node mam_receiveArduino.js your_root et les données des capteurs stockées s'affichent. Par exemple :

Le code qui gère les données reçues est :

// RÉCUPÉRATION DES DONNÉES DU TANGLE
const executeDataRetrieval = async function(rootVal, keyVal) {
 let resp = await Mam.fetch(rootVal, MODE, keyVal, function(data) {
 let json = JSON.parse(iota.utils.fromTrytes(data));
 console.log(`City: ${json.city}, Building: ${json.building}, Time: ${json.time} UTC, Data: ${json.data}`);
 });
 executeDataRetrieval(resp.nextRoot, keyVal);
}

Test

Images

5. Système de surveillance des déchets

Envoi des données du capteur SRF05 via NodeMCU et MQTT vers le Tangle IOTA en utilisant MAM.

Comment ça fonctionne ?

a) Ce projet comporte 3 fichiers :

trashcan.ino : Ce code calcule la quantité de déchets dans une poubelle en %. Puis, envoie les données à la carte Raspberry Pi 3B via le protocole MQTT.
nodemcu_mqtt_mam.js : Les données du capteur SRF05 sont lues et publiées sur le Tangle via MAM.
nodemcu_mam_receive.js : Extraction des données stockées sur le Tangle via MAM et affichage.

b) Le point de terminaison du nœud complet et la clé latérale sont codés en dur dans les fichiers JavaScript. Pour arrêter un script, appuyez sur CTRL+Z.

c) Connecter la carte NodeMCU et les capteurs ultrasoniques SRF05.

d) Installer les packages esp8266 via le gestionnaire de cartes. Ouvrir les préférences de l'IDE Arduino et entrer dans le champ "URLs supplémentaires du gestionnaire de cartes" : https://arduino.esp8266.com/stable/package_esp8266com_index.json

Sélectionner le menu : Outils > Carte > Gestionnaire de cartes... Dans le champ de recherche, taper : esp8266 et installer la dernière version.

e) Faire communiquer le NodeMCU avec un serveur mosquitto. Commencer par ajouter la bibliothèque PubSubClient à l'IDE Arduino. Cette bibliothèque est pour la messagerie MQTT et supporte NodeMCU.

Sélectionner le menu : Croquis > Inclure une bibliothèque > Gérer les bibliothèques
Rechercher : PubSub
Sélectionner PubSubClient (Nick O'Leary) et installer la dernière version

f) Installer Mosquitto (MQTT) sur le Raspberry Pi 3B. Le protocole MQTT fournit une méthode légère pour effectuer la messagerie selon un modèle publication/souscription. Cela le rend adapté à la messagerie IoT comme avec des capteurs à faible consommation ou des appareils mobiles tels que téléphones, ordinateurs embarqués ou microcontrôleurs. Connectez-vous à votre Raspberry Pi, ouvrez un terminal et tapez :

$ cd ~
$ wget https://repo.mosquitto.org/debian/mosquitto-repo.gpg.key
$ apt-key add mosquitto-repo.gpg.key
$ cd /etc/apt/sources.list.d/
$ wget https://repo.mosquitto.org/debian/mosquitto-stretch.list

Maintenant installer ce qui suit :

$ cd ~
$ wget https://security.debian.org/debian-security/pool/updates/main/o/openssl/libssl1.0.0_1.0.1t-1+deb8u11_armhf.deb
$ sudo dpkg -i libssl1.0.0_1.0.1t-1+deb8u11_armhf.deb
$ wget https://ftp.nz.debian.org/debian/pool/main/libw/libwebsockets/libwebsockets3_1.2.2-1_armhf.deb
$ sudo dpkg -i libwebsockets3_1.2.2-1_armhf.deb

La dernière version de libssl... vous pouvez la trouver ici : https://security.debian.org/debian-security/pool/updates/main/o/openssl/

Installer le broker MQTT et les clients mosquitto.

$ sudo apt-get install mosquitto mosquitto-clients

Si vous avez un problème avec l'installation de MQTT, vous pouvez essayer :

$ npm install mqtt --save

Redémarrer le Raspberry Pi. Ouvrir un terminal et vérifier la version de mosquitto :

$ mosquitto -v

Vous pouvez démarrer et arrêter le serveur mosquitto :

$ sudo /etc/init.d/mosquitto start
$ sudo /etc/init.d/mosquitto stop

Vérifier l'IP du Raspberry Pi :

$ ifconfig

g) Téléverser le sketch trashcan.ino sur la carte NodeMCU. Vérifier les données suivantes :

Carte NodeMCU 1.0
Port série
Serial.begin(115200);
const char* wifi_ssid = "ARRIS-WXYZ";
const char* wifi_password = "XXXXXXXXXXXX";
const char* mqtt_server = "192.168.0.12"; // IP RASPBERRY
int trashcan = 25; // MA POUBELLE A 25 CM DE LONGUEUR

h) Exécuter nodemcu_mqtt_mam.js, ce script stockera les données de la carte NodeMCU sur le Tangle.

$ node nodemcu_mqtt_mam.js

Nous envoyons les informations suivantes :

Ville : BERLIN
Bâtiment : 7
Date et heure (UTC) : ANNÉE. MOIS, JOUR, HEURE. MINUTES ET SECONDES
Données : pourcentage de remplissage de la poubelle.

i) Ouvrir un autre terminal et taper : node mam_receiveArduino.js your_root et les données des capteurs stockées s'affichent. Par exemple :

Le code qui gère les données reçues est :

// RÉCUPÉRATION DES DONNÉES DU TANGLE
const executeDataRetrieval = async function(rootVal, keyVal) {
 let resp = await Mam.fetch(rootVal, MODE, keyVal, function(data) {
 let json = JSON.parse(iota.utils.fromTrytes(data));
 console.log(`City: ${json.city}, Building: ${json.building}, dateTime: ${json.dateTime} UTC, Data: ${json.data}`);
 });
 executeDataRetrieval(resp.nextRoot, keyVal);
}

Cette fois, le nœud disponible était différent : https://iotasalad.org/nodes

const iota = new IOTA({ provider: 'https://durian.iotasalad.org:14265' });

Test

Images

6. Conclusions

Système de surveillance de la qualité de l'air intérieur v1 :

Ce projet a fonctionné de manière satisfaisante et nous surveillons la qualité de l'air à l'intérieur d'un bâtiment, comme on peut le voir dans les résultats obtenus. Nous avons simulé ce projet dans un bâtiment situé à Mexico. C'était un test de base utilisant le capteur d'humidité et température DHT11 et la carte Raspberry Pi 3B, du code JavaScript et le protocole IOTA.

Système de surveillance de la qualité de l'air intérieur v2 :

Dans ce projet, nous avons utilisé les capteurs DHT11, MQ-2 (LPG) et MQ-7 (CO). Cette fois-ci, nous simulons la capture de données dans un bâtiment situé à New York, et nous envoyons ces données en utilisant les cartes Arduino UNO et Raspberry Pi, vers le Tangle IOTA en utilisant la messagerie authentifiée masquée (MAM). C'était une façon pratique et rapide d'ajouter plus de capteurs. Cette version peut être utilisée dans les bâtiments intelligents et dans les industries où du gaz LP est utilisé et où du monoxyde de carbone est produit par des incendies.

Système de surveillance des déchets :

L'objectif de ce projet est de prendre le contrôle du dépôt de déchets dans un bâtiment intelligent situé à Berlin ou dans n'importe quel quartier. L'accumulation de déchets peut produire de mauvaises odeurs de produits en décomposition, mais maintenant nous pouvons savoir depuis combien de temps une poubelle contient des déchets et le pourcentage de ces déchets.

Code

sensor.js
mam_sensor.js
mam_receive.js
mam_sensorArduino.js
mam_receiveArduino.js

sensor.js (JavaScript)

Système de surveillance de la qualité de l'air intérieur v1 - Code pour tester le capteur DHT11

const sensor = require('node-dht-sensor');
const TIMEINTERVAL = 10; // SECONDES
const SENSORTYPE = 11; // 11=DHT11, 22=DHT22
const GPIOPIN = 4; // BROCHE GPIO RASPBERRY DU CAPTEUR DHT11

function readSensor() {
  sensor.read(SENSORTYPE, GPIOPIN, function(err, temperature, humidity) {
    if (!err) {
      console.log('temp: ' + temperature.toFixed(1) + 'C, ' + 'humidity: ' + humidity.toFixed(1) + '%');
    } else {
      console.log(err);
    }
  });
}

readSensor();
// MISE À JOUR AUTOMATIQUE DE LA VALEUR DU CAPTEUR TOUTES LES 10 SECONDES
setInterval(readSensor, TIMEINTERVAL * 1000);

mam_sensor.js (JavaScript)

Système de surveillance de la qualité de l'air intérieur v1 - Ce code stocke les données de température et d'humidité du module capteur DHT11 sur le Tangle

const sensor = require('node-dht-sensor');
const Mam = require('./lib/mam.client.js');
const IOTA = require('iota.lib.js');
const moment = require('moment');
//const iota = new IOTA({ provider: 'https://nodes.testnet.iota.org:443' });
const iota = new IOTA({ provider: 'https://potato.iotasalad.org:14265' });
//const iota = new IOTA({ provider: 'https://peanut.iotasalad.org:14265' });
const MODE = 'restricted'; // PUBLIC, PRIVATE OU RESTRICTED
const SIDEKEY = 'mysecret'; // UTILISÉ UNIQUEMENT EN MODE RESTRICTED
const SECURITYLEVEL = 3;
const TIMEINTERVAL = 30; // SECONDES
const SENSORTYPE = 11; // 11=DHT11, 22=DHT22
const GPIOPIN = 14; // BROCHE GPIO RASPBERRY DU CAPTEUR DHT11

// INITIALISER L'ÉTAT MAM
let mamState = Mam.init(iota, undefined, SECURITYLEVEL);

// MODE CANAL
if (MODE == 'restricted') {
  const key = iota.utils.toTrytes(SIDEKEY);
  mamState = Mam.changeMode(mamState, MODE, key);
} else {
  mamState = Mam.changeMode(mamState, MODE);
}

// PUBLIER SUR LE TANGLE
const publish = async function(packet) {
  // CRÉER LA CHARGE UTILE MAM
  const trytes = iota.utils.toTrytes(JSON.stringify(packet));
  const message = Mam.create(mamState, trytes);
  // SAUVEGARDER LE NOUVEL ÉTAT MAM
  mamState = message.state;
  console.log('Root: ', message.root);
  console.log('Address: ', message.address);
  // ATTACHER LA CHARGE UTILE
  await Mam.attach(message.payload, message.address);
  return message.root;
}

function readSensor() {
  sensor.read(SENSORTYPE, GPIOPIN, async function(err, temperature, humidity) {
    if (!err) {
      const city = ('MEXICO');
      const building = ('65');
      const dateTime = moment().utc().format('YYYY/MM/DD hh:mm:ss');
      const data = `{Temperature: ${temperature.toFixed(1)}°C (${(temperature.toFixed(1)*1.8)+32}°F), Humidity: ${humidity.toFixed(1)}%}`;
      const json = {"data": data, "dateTime": dateTime, "building": building, "city": city};
      const root = await publish(json);
      console.log(`City: ${json.city}, Building: ${json.building}, Time: ${json.dateTime} UTC, Data: ${json.data}, root: ${root}`);
    } else {
      console.log(err);
    }
  });
}

// DÉMARRER
readSensor();
// MISE À JOUR AUTOMATIQUE DE LA VALEUR DU CAPTEUR TOUTES LES 30 SECONDES
setInterval(readSensor, TIMEINTERVAL * 1000);

mam_receive.js (JavaScript)

Système de surveillance de la qualité de l'air intérieur v1 - Les données des capteurs stockées sont affichées.

const Mam = require('./lib/mam.client.js');
const IOTA = require('iota.lib.js');
//const iota = new IOTA({ provider: 'https://nodes.testnet.iota.org:443' });
const iota = new IOTA({ provider: 'https://potato.iotasalad.org:14265' });
//const iota = new IOTA({ provider: 'https://peanut.iotasalad.org:14265' });
const MODE = 'restricted'; // PUBLIC, PRIVATE OU RESTRICTED
const SIDEKEY = 'mysecret'; // UTILISÉ UNIQUEMENT EN MODE RESTRICTED
let root;
let key;

// VÉRIFIER LES ARGUMENTS
const args = process.argv;
if(args.length !=3) {
  console.log('Missing root as argument: node mam_receive.js ');
  process.exit();
} else if(!iota.valid.isAddress(args[2])){
  console.log('You have entered an invalid root: '+ args[2]);
  process.exit();
} else {
  root = args[2];
}

// INITIALISER L'ÉTAT MAM
let mamState = Mam.init(iota);

// DÉFINIR LE MODE CANAL
if (MODE == 'restricted') {
  key = iota.utils.toTrytes(SIDEKEY);
  mamState = Mam.changeMode(mamState, MODE, key);
} else {
  mamState = Mam.changeMode(mamState, MODE);
}

// RÉCUPÉRATION DES DONNÉES DU TANGLE
const executeDataRetrieval = async function(rootVal, keyVal) {
  let resp = await Mam.fetch(rootVal, MODE, keyVal, function(data) {
    let json = JSON.parse(iota.utils.fromTrytes(data));
    console.log(`City: ${json.city}, Building: ${json.building}, Time: ${json.dateTime} UTC, Data: ${json.data}`);
  });
}
executeDataRetrieval(root, key);

mam_sensorArduino.js (JavaScript)

Système de surveillance de la qualité de l'air intérieur v2 - Les données des capteurs DHT11, MQ-2 et MQ-7 sont lues et publiées sur le Tangle via MAM.

const SerialPort = require('serialport');
const moment = require('moment');
const IOTA = require('iota.lib.js');
const Mam = require('./lib/mam.client.js');
//const iota = new IOTA({ provider: 'https://nodes.testnet.iota.org:443' });
const iota = new IOTA({ provider: 'https://potato.iotasalad.org:14265' });
const MODE = 'restricted'; // PUBLIC, PRIVATE, RESTRICTED
const SIDEKEY = 'mysecret'; // CARACTÈRES ASCII UNIQUEMENT
const SECURITYLEVEL = 3; // 1, 2, 3
const PORTNAME = '/dev/ttyACM1'; // SAISIR UN PORT VALIDE
const port = new SerialPort(PORTNAME, { baudRate: 9600, autoOpen: true });
const Readline = SerialPort.parsers.Readline;
const parser = port.pipe(new Readline({ delimiter: '\r\n' }));

// INITIALISER L'ÉTAT MAM
let mamState = Mam.init(iota, undefined, SECURITYLEVEL);

// DÉFINIR LE MODE CANAL
if (MODE == 'restricted') {
  const key = iota.utils.toTrytes(SIDEKEY);
  mamState = Mam.changeMode(mamState, MODE, key);
} else {
  mamState = Mam.changeMode(mamState, MODE);
}

// PUBLIER SUR LE TANGLE
const publish = async function(packet) {
  // CRÉER LA CHARGE UTILE MAM
  const trytes = iota.utils.toTrytes(JSON.stringify(packet));
  const message = Mam.create(mamState, trytes);
  // SAUVEGARDER LE NOUVEL ÉTAT MAM
  mamState = message.state;
  console.log('Root: ', message.root);
  console.log('Address: ', message.address);
  // ATTACHER LA CHARGE UTILE
  await Mam.attach(message.payload, message.address);
  return message.root;
}

// ÉVÉNEMENTS DE LA BIBLIOTHÈQUE PORT SÉRIE
port.on('open', showPortOpen);
parser.on('data', readSerialData);
port.on('close', showPortClose);
port.on('error', showError);

// FONCTIONS DE RAPPEL
function showPortOpen() {
  console.log('Serial port open. Data rate: ' + port.baudRate);
}

async function readSerialData(data) {
  let json = {};
  const time = moment().utc().format('YYYY/MM/DD hh:mm:ss');
  const city = ('NY');
  const building = ('13');
  json['time'] = time;
  json['city'] = `${city}`;
  json['building'] = `${building}`;
  json['data'] = `{${data}}`;
  console.log('json = ',json);
  const root = await publish(json);
}

function showPortClose() {
  console.log('Serial port closed.');
}

function showError(error) {
  console.log('Serial port error: ' + error);
}

mam_receiveArduino.js (JavaScript)

Système de surveillance de la qualité de l'air intérieur v2 - Extraction des données stockées sur le Tangle via MAM et affichage.

const Mam = require('./lib/mam.client.js');
const IOTA = require('iota.lib.js');
//const iota = new IOTA({ provider: 'https://nodes.testnet.iota.org:443' });
const iota = new IOTA({ provider: 'https://potato.iotasalad.org:14265' });
const MODE = 'restricted'; // PUBLIC, PRIVATE OU RESTRICTED
const SIDEKEY = 'mysecret'; // SAISIR UNIQUEMENT DES CARACTÈRES ASCII
let root;
let key;

// VÉRIFIER LES ARGUMENTS
const args = process.argv;
if(args.length !=3) {
  console.log('Missing root as argument: node mam_receive.js ');
  process.exit();
} else if(!iota.valid.isAddress(args[2])){
  console.log('You have entered an invalid root: '+ args[2]);
  process.exit();
} else {
  root = args[2];
}

// INITIALISER L'ÉTAT MAM
let mamState = Mam.init(iota);

// DÉFINIR LE MODE CANAL
if (MODE == 'restricted') {
  key = iota.utils.toTrytes(SIDEKEY);
  mamState = Mam.changeMode(mamState, MODE, key);
} else {
  mamState = Mam.changeMode(mamState, MODE);
}

// RÉCUPÉRATION DES DONNÉES DU TANGLE
const executeDataRetrieval = async function(rootVal, keyVal) {
  let resp = await Mam.fetch(rootVal, MODE, keyVal, function(data) {
    let json = JSON.parse(iota.utils.fromTrytes(data));
    console.log(`City: ${json.city}, Building: ${json.building}, Time: ${json.time} UTC, Data: ${json.data}`);
  });
  executeDataRetrieval(resp.nextRoot, keyVal);
}
executeDataRetrieval(root, key);

Schémas

Diagramme schématique

Système intelligent de surveillance de la qualité de l air intérieur et des déchets

Diagramme schématique

Système intelligent de surveillance de la qualité de l air intérieur et des déchets

Diagramme schématique

Système intelligent de surveillance de la qualité de l air intérieur et des déchets

Construire un oscilloscope Arduino 20 kHz sur écran Nokia 5110 – Guide DIY facile Créer votre propre jeu de roulette à 37 LED avec Arduino Nano

Processus de fabrication

impression en 3D

Système de contrôle d'automatisation

Technologie industrielle