Raumluftqualitäts- und Abfallüberwachungssystem

Apps und Onlinedienste

	IOTA Tangle
	Node.js
	Raspberry Pi Raspbian
	Arduino-IDE
	MQTT

Über dieses Projekt

1. Einführung

Gebäudeautomatisierung ist die automatische zentrale Steuerung der Heizungs-, Lüftungs- und Klimatisierungs-, Beleuchtungs- und anderen Systeme eines Gebäudes durch ein Gebäudemanagementsystem oder Gebäudeautomationssystem (BAS). Die Ziele der Gebäudeautomation sind ein verbesserter Nutzerkomfort, ein effizienter Betrieb von Gebäudesystemen, eine Reduzierung des Energieverbrauchs und der Betriebskosten sowie eine verbesserte Lebensdauer der Versorgungseinrichtungen.

IOTA ist eine verteilte Open-Source-Buchhaltungstechnologie, deren Ziel es ist, Informationen und Werte im Internet der Dinge sicher auszutauschen. Eine der Hauptinnovationen von IOTA besteht darin, dass es anstelle der traditionellen Blockchain eine eigene Architektur (Tangle) verwendet, die auf einem mathematischen Konzept namens Directed Acyclic Graph (DAG) basiert. Diese Architektur ermöglicht, dass keine Provisionen anfallen, die Latenz des Netzwerks gering ist und bessere Perspektiven der Skalierbarkeit. IOTA befindet sich derzeit in der Entwicklung und es wird erwartet, dass die Technologie im Laufe des Jahres 2019 in großem Umfang eingeführt werden kann.

Die Spezifikationen für den Raspberry Pi 3 B beinhalten:

• CPU:Quad-Core 64-Bit ARM Cortex A53 mit 1,2 GHz getaktet.
• GPU:400MHz VideoCore IV Multimedia.
• Speicher:1 GB LPDDR2-900 SDRAM (d. h. 900 MHz)
• USB-Anschlüsse:4.
• Videoausgänge:HDMI, Composite-Video (PAL und NTSC) über 3,5-mm-Buchse.
• Netzwerk:10/100 Mbit/s Ethernet und 802.11n Wireless LAN.

Funktionen der Arduino UNO Vorstand:

• Mikrocontroller:ATmega328.
• Betriebsspannung:5V.
• Eingangsspannung (empfohlen):7-12V.
• Eingangsspannung (Grenzwerte):6-20V.
• Digitale E/A-Pins:14 (davon 6 mit PWM-Ausgang)
• Analoge Eingangspins:6.
• Gleichstrom pro E/A-Pin:40 mA.
• Gleichstrom für 3,3-V-Pin:50 mA.

NodeMCU , Funktionen:

• Endlich programmierbares WLAN-Modul.
• Arduino-ähnliche (softwaredefinierte) Hardware-IO.
• Kann mit der Arduino IDE programmiert werden.
• USB-TTL inklusive, Plug &Play.
• 10 GPIOs D0-D10, PWM-Funktionalität, IIC- und SPI-Kommunikation, 1-Wire und ADC A0 usw. alles in einem Board.

Dieses Projekt ist in drei Versionen unterteilt. Zum besseren Verständnis des Projekts haben wir es in folgende Kapitel unterteilt:

• 1. Einführung
• 2. Softwareinstallation
• 3. System zur Überwachung der Luftqualität in Innenräumen v1
• 4. System zur Überwachung der Luftqualität in Innenräumen v2
• 5. Abfallüberwachungssystem
• 6. Schlussfolgerungen

2. Softwareinstallation

a) Raspbian auf dem Raspberry PI 3 B installieren

Ich habe NOOBS installiert , den Download-Link und die Anleitung finden Sie unter:https://www.raspberrypi.org/downloads/

b) Node.JS installieren

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

c) Laden Sie die BCM2835-Bibliothek herunter und erstellen Sie sie auf dem Raspberry Pi. Diese Bibliothek hilft uns, mit dem DHT11-Sensor zu arbeiten.

$ wget http://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) Laden Sie das Indoor-Air-Quality-Iota-Projekt herunter und installieren Sie es auf dem Raspberry Pi

$ cd ~
$ git clone https://github.com/guillengap/indoor-air-quality-and-garbage-monitoring-system.git
$ cd indoor-air -Qualitäts-und-Müllüberwachungssystem
$ npm install 

e) Serialport herunterladen und installieren

$ nmp serielle Schnittstelle installieren 

f) Laden Sie die Arduino-IDE herunter und installieren Sie sie:

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

3. System zur Überwachung der Luftqualität in Innenräumen v1

Die DHT11-Sensordaten werden mit MAM gelesen und im Tangle veröffentlicht.

Wie funktioniert es?

a) Das Indoor-Air-Quality-Iota-Projekt hat 3 Java-Script-Dateien:

• sensor.js :Die DHT11-Sensordaten werden gelesen und angezeigt:Temperatur und Luftfeuchtigkeit.
• mam_sensor.js :Die DHT11-Sensordaten werden mit MAM gelesen und im IOTA Tangle veröffentlicht.
• mam_receive.js :Extrahiere die gespeicherten Daten mit MAM aus dem IOTA Tangle und zeige die Daten an.

b) Der vollständige Knotenendpunkt und der Seitenschlüssel sind beide in den Javascript-Dateien fest codiert. Um die Ausführung eines Skripts zu stoppen, drücken Sie STRG+Z .

c) Verbinden Sie sich mit dem Arduino UNO-Board, dem DHT11-Sensor.

d) Führen Sie nodesensor.js aus um zu überprüfen, ob der Raspberry Pi Temperatur- und Feuchtigkeitsdaten vom DHT11-Sensormodul lesen kann.

$-Knotensensor.js 

Hier sehen wir die vom DHT11-Sensor erfassten Feuchtigkeits- und Temperaturdaten. Wenn alles in Ordnung ist, gehen wir zum nächsten Schritt.

e) Knoten ausführen mam_sensor.js . Dieses Skript speichert die Temperatur- und Feuchtigkeitsdaten vom DHT11-Sensormodul im Tangle.

$-Knoten mam_sensor.js 

Wir haben mit drei Knoten getestet und hatten bessere Ergebnisse mit: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({ Anbieter:'https://peanut.iotasalad.org:14265' }); 

Sie können einige verfügbare Knoten einsehen unter:https://iotasalad.org/nodes

Wir senden die folgenden Informationen:

• Stadt:MEXIKO
• Gebäude:65
• Datum und Uhrzeit (UTC):JAHR. MONAT, TAG, STUNDE. MINUTEN UND SEKUNDEN
• Daten:Temperatur in Grad Celsius und Fahrenheit und Prozentsatz der relativen Luftfeuchtigkeit

f) Öffnen Sie ein anderes Terminal und geben Sie ein:node mam_receive.js your_root und die gespeicherten Sensordaten werden angezeigt. Zum Beispiel:

$-Knoten mam_receive.js AMBTIKZKEVEEQFCUGIDUOLDOXL9OZQ9GOMNBFYHVRAUCAMHDQQJBSNAMFZYRLTUVAHFDINHTTFKIPELIG 

Der Code, der die empfangenen Daten verwaltet, ist:

// DATEN AUS DEM TANGLE EMPFANGEN
const executeDataRetrieval =async function(rootVal, keyVal) {
 let resp =wait 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, Daten:${json.data}`);
 }); 
} 

Test

Bilder

4. Überwachungssystem für die Luftqualität in Innenräumen v2

Die Daten der Sensoren DHT11, MQ-2 und MQ-7 werden gelesen und mit MAM im Tangle veröffentlicht

Wie funktioniert es?

a) Das Indoor-Air-Quality-Iota-Projekt hat 5 Dateien:

• sensorArduino.ino :Dieser Code erfasst die Daten der drei Sensoren:DHT11 Feuchtigkeits- und Temperatursensor, MQ-2 LPG-Gassensor und MQ-7 CO-Gassensor.
• listportsArduino.ino :Es zeigt uns die verfügbaren Ports des Arduino UNO-Boards.
• sensorArduino.js :Die Daten der Sensoren DHT11, MQ-2 und MQ-7 werden gelesen und angezeigt.
• mam_sensorArduino.js :Die Daten der Sensoren DHT11, MQ-2 und MQ-7 werden gelesen und mit MAM im Tangle veröffentlicht.
• mam_receiveArduino.js :Extrahiere die gespeicherten Daten mit MAM aus dem Tangle und zeige die Daten an.

b) Der vollständige Knotenendpunkt und der Seitenschlüssel sind beide in den Javascript-Dateien fest codiert. Um die Ausführung eines Skripts zu stoppen, drücken Sie STRG+Z .

c) Verbinden Sie die Sensoren mit dem Arduino UNO-Board:DHT11, MQ-2 und MQ-7.

d) Im Ordner "sensorArduino", der im Projekt indoor-air-quality-iota zu finden ist, haben wir die Sensorbibliotheken:DHT11, MQ-2 und MQ7. Wir müssen sie in den Arduino-Bibliotheken installieren.

e) Laden Sie die Skizze sensorArduino.ino . hoch , zum Arduino UNO-Board und führen Sie es aus. Wählen Sie den Kommunikationsport mit dem Arduino UNO-Board aus, in meinem Fall ist es:Tools> Port> / dev / ttyACM0

f) Öffnen Sie ein Terminal und führen Sie Knoten listportsArduino.js aus um zu überprüfen, ob unser Port aktiv ist.

$-Knoten listportsArduino.js 

g) Führen Sie Knoten mam_sensorArduino.js aus . Dieses Skript speichert die Daten vom Arduino UNO-Board im Tangle.

$-Knoten mam_sensorArduino.js 

Wir senden die folgenden Informationen:

• Stadt:NY
• Gebäude:13
• Datum und Uhrzeit (UTC):JAHR. MONAT, TAG, STUNDE. MINUTEN UND SEKUNDEN
• Daten:LPG-Gas in ppm, CO-Gas in ppm, Temperatur in Grad Celsius, Prozentsatz der relativen Luftfeuchtigkeit,

h) Öffnen Sie ein anderes Terminal und geben Sie ein:node mam_receiveArduino.js your_root und die gespeicherten Sensordaten werden angezeigt. Zum Beispiel:

Der Code, der die empfangenen Daten verwaltet, ist:

// DATEN AUS DEM TANGLE EMPFANGEN
const executeDataRetrieval =async function(rootVal, keyVal) {
 let resp =wait 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

Bilder

5. Müllüberwachungssystem

Senden Sie SRF05-Sensordaten mit NodeMCU und MQTT an IOTA Tangle mit MAM

Wie funktioniert es?

a) Dieses Projekt hat 3 Dateien:

• Mülleimer.ino :Dieser Code berechnet die Müllmenge in einem Mülleimer in %. Senden Sie dann die Daten über das MQTT-Protokoll an das Raspberry Pi 3B-Board.
• nodemcu_mqtt_mam .js :Die SRF05-Sensordaten werden mit MAM gelesen und im Tangle veröffentlicht.
• nodemcu_mam_receive.js :Extrahiere die gespeicherten Daten mit MAM aus dem Tangle und zeige die Daten an.

b) Der vollständige Knotenendpunkt und der Seitenschlüssel sind beide in den Javascript-Dateien fest codiert. Um die Ausführung eines Skripts zu stoppen, drücken Sie STRG+Z .

c) Verbinden Sie sich mit dem NodeMCUboard, den SRF05-Ultraschallsensoren.

d) Installieren Sie esp8266-Pakete mit dem Boards Manager. Öffnen Sie das Arduino IDE-Einstellungsfenster und geben Sie in das Feld Additional Board Manager URLs ein:http://arduino.esp8266.com/stable/package_esp8266com_index.json

Wählen Sie das Menü:Tools> Board> Board Manager... Geben Sie in das Suchfeld Folgendes ein:esp8266 und installieren Sie die neueste Version.

e) Lassen Sie uns nun die NodeMCU mit einem Mosquitto-Server kommunizieren. Beginnen Sie mit dem Hinzufügen der PubSubClient-Bibliothek zur Arduino-IDE. Diese Bibliothek ist für MQTT-Messaging und unterstützt NodeMCU.

• Menü auswählen:Skizze> Bibliothek einschließen> Bibliotheken verwalten
• Suchen nach:PubSub
• Wählen Sie PubSubClient (Nick O'Leary) aus und installieren Sie die neueste Version

f) Als nächstes Mosquitto (MQTT) installieren auf dem RaspberryPi 3B. Das MQTT-Protokoll bietet eine einfache Methode zum Ausführen von Nachrichten unter Verwendung eines Publish/Subscribe-Modells. Dies macht es für das Internet der Dinge geeignet, z. B. mit Sensoren mit geringem Stromverbrauch oder mobilen Geräten wie Telefonen, eingebetteten Computern oder Mikrocontrollern. Melden Sie sich bei Ihrem Raspberry Pi an, öffnen Sie ein Terminal und geben Sie Folgendes ein:

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

Installieren Sie nun Folgendes:

$ cd~
$ wget http://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 http://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 

Die neueste Version der libss finden Sie hier:http://security.debian.org/debian-security/pool/updates/main/o/openssl/

Installieren Sie MQTT-Broker und Moskito-Clients.

$ sudo apt-get install mosquitto mosquitto-clients 

Wenn Sie ein Problem mit der Installation von MQTT haben, können Sie Folgendes versuchen:

$ npm install mqtt --save 

Starten Sie den Raspberry Pi neu. Öffnen Sie ein Terminal und überprüfen Sie die Moskito-Version:

$ Mücke -v 

Sie können den Moskito-Server starten und stoppen:

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

Wir überprüfen die IP des Raspberry Pi:

$ ifconfig 

g) Laden Sie die Skizze trashcan.ino . hoch , zum NodeMCU-Board. Nächste Daten überprüfen:

• NodeMCU 1.0-Board
• Serieller Anschluss
• Seriell.begin(115200);
• const char* wifi_ssid ="ARRIS-WXYZ";
• const char* wifi_password ="XXXXXXXXXXXX";
• const char* mqtt_server ="192.168.0.12"; // Himbeer-IP
• int Mülleimer =25; // MEIN MÜLL HAT 25 CM LÄNGE

h) Führen Sie nodemcu_mqtt_mam.js aus , dieses Skript speichert die Daten vom NodeMCU-Board im Tangle.

$ nodemcu_mqtt_mam.js 

Wir senden die folgenden Informationen:

• Stadt:BERLIN
• Gebäude:7
• Datum und Uhrzeit (UTC):JAHR. MONAT, TAG, STUNDE. MINUTEN UND SEKUNDEN
• Daten:Mülleimer-Prozentsatz.

i) Öffnen Sie ein anderes Terminal und geben Sie ein:node mam_receiveArduino.js your_root und die gespeicherten Sensordaten werden angezeigt. Zum Beispiel:

Der Code, der die empfangenen Daten verwaltet, ist:

// RECEIVE DATA FRON THE TANGLE
const executeDataRetrieval =async function(rootVal, keyVal) {
 let resp =wait 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);
} 

Bei dieser Gelegenheit war der verfügbare Knoten ein anderer:https://iotasalad.org/nodes

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

Test

Bilder

6. Schlussfolgerungen

Überwachungssystem für die Luftqualität in Innenräumen v1:

Dieses Projekt hat zufriedenstellend funktioniert und wir überwachen die Qualität der Luft im Inneren eines Gebäudes, wie wir an den erhaltenen Ergebnissen sehen können. Wir simulieren dieses Projekt in einem Gebäude in Mexiko-Stadt. Dies war ein grundlegender Test mit dem DHT11-Feuchtigkeits- und Temperatursensor und dem Raspberry Pi 3B-Board, Java-Script-Code und dem IOTA-Protokoll.

Überwachungssystem für die Luftqualität in Innenräumen v2:

In diesem Projekt haben wir die Sensoren DHT11, MQ-2 (LPG) und MQ-7 (CO) verwendet. Bei dieser Gelegenheit. Wir simulieren die Erfassung der Daten in einem Gebäude in New York City und senden diese Daten mithilfe von Arduino UNO- und Raspberry Pi-Boards an IOTA Tangle mithilfe von Masked Authenticated Messaging (MAM). Dies war eine praktische und schnelle Möglichkeit, weitere Sensoren hinzuzufügen. Diese Version kann in intelligenten Gebäuden und in Industrien verwendet werden, in denen Flüssiggas verwendet wird und Kohlenmonoxid durch Brände entsteht.

Müllüberwachungssystem:

Das Ziel dieses Projekts ist es, die Kontrolle über die Mülldeponie in einem intelligenten Gebäude in der Berliner Stadt oder einem beliebigen Bezirk zu übernehmen. Die Ansammlung von Müll kann bei Zersetzungsprodukten unangenehme Gerüche erzeugen, aber jetzt können wir wissen, wie lange ein Müllboot mit Müll ist und wie viel Prozent dieses Mülls sind.

Code

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

sensor.jsJavaScript

const sensor =require('node-dht-sensor');const TIMEINTERVAL =10; // SECONDSconst SENSORTYPE =11; // 11=DHT11, 22=DHT22const GPIOPIN =4; // HIMBEER-GPIO-PIN VOM DHT11 SENSORfunction readSensor () { sensor.read (SENSORTYPE, GPIOPIN, function (err, Temperatur, Feuchtigkeit) { if (!err) { console.log ('temp:' + temperature.toFixed (1 .) ) + 'C, ' + 'Luftfeuchtigkeit:' + Feuchte.toFixed(1) + '%'); } else { console.log(err); } });}readSensor();// SENSORWERT ALLES AUTOMATISCH AKTUALISIEREN 10 SECONDSsetInterval(readSensor, TIMEINTERVAL*1000);

mam_sensor.jsJavaScript

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 ='eingeschränkt'; // PUBLIC, PRIVATE ODER RESTRICTEDconst SIDEKEY ='mysecret'; // NUR IM EINGESCHRÄNKTEN MODUS VERWENDETconst SECURITYLEVEL =3; const ZEITINTERVALL =30; // SECONDSconst SENSORTYPE =11; // 11=DHT11, 22=DHT22const GPIOPIN =14; // RASPBERRY GPIO PIN FROM DHT11 SENSOR // INITIALIZE MAM STATElet mamState =Mam.init(iota, undefined, SECURITYLEVEL); // CHANNEL MODEif (MODE =='restricted') { const key =iota.utils.toTrytes(SIDEKEY); mamState =Mam.changeMode(mamState, MODE, key);} else { mamState =Mam.changeMode(mamState, MODE);}// PUBLISH TO TANGLEconst publish =async function(packet) { // CREATE MAM PAYLOAD const trytes =iota .utils.toTrytes(JSON.stringify(Paket)); const message =Mam.create(mamState, trytes); // NEUEN MAMSTATE SPEICHERN mamState =message.state; console.log('Root:', Nachricht.root); console.log('Adresse:', Nachricht.Adresse); // ATTACH THE PAYLOAD wait Mam.attach(message.payload, message.address); return message.root;}function readSensor(){ sensor.read(SENSORTYPE, GPIOPIN, async function(err, temperature, Luftfeuchtigkeit) { 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); } });}// STARTEN SIE ITreadSensor();// SENSORWERT AUTOMATISCH AKTUALISIEREN ALLE 30 SEKUNDENsetInterval(readSensor, TIMEINTERVAL*1000);

mam_receive.jsJavaScript

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({ Anbieter:'https://peanut.iotasalad.org:14265' });const MODE ='eingeschränkt'; // PUBLIC, PRIVATE ODER RESTRICTEDconst SIDEKEY ='mysecret'; // NUR IM EINGESCHRÄNKTEN MODE VERWENDETlet root;let key;// ARGUMENTE PRÜFENconst args =process.argv;if(args.length !=3) { console.log('Stamm als Argument fehlt:Knoten mam_receive.js  '); process.exit();} else if(!iota.valid.isAddress(args[2])){ console.log('Sie haben ein ungültiges Root eingegeben:'+ args[2]); process.exit();} else { root =args[2];} // INITIALISE MAM STATElet mamState =Mam.init(iota); // SET CHANNEL MODEif (MODE =='restricted') { key =iota.utils .toTrytes(SIDEKEY); mamState =Mam.changeMode(mamState, MODE, key);} else { mamState =Mam.changeMode(mamState, MODE);}// DATEN AUS DEM TANGLE EMPFANGENconst executeDataRetrieval =async function(rootVal, keyVal) { let resp =wait Mam .fetch(rootVal, MODE, keyVal, function(data) { let json =JSON.parse(iota.utils.fromTrytes(data)); console.log(`City:${json.city}, Building:${json .building}, Zeit:${json.dateTime} UTC, Daten:${json.data}`); }); }executeDataRetrieval(root, key);

mam_sensorArduino.jsJavaScript

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({ Anbieter:'https://potato.iotasalad.org:14265' });const MODE ='eingeschränkt'; // ÖFFENTLICH, PRIVAT, EINGESCHRÄNKTconst SIDEKEY ='mysecret'; // NUR ASCII-ZEICHENconst SECURITYLEVEL =3; // 1, 2, 3const PORTNAME ='/dev/ttyACM1'; // GÜLTIGEN PORT EINGEBEN const port =new SerialPort(PORTNAME, { baudRate:9600, autoOpen:true});const Readline =SerialPort.parsers.Readline;const parser =port.pipe(new Readline({ delimiter:'\r\ n' })); // INITIALIZE MAM STATElet mamState =Mam.init(iota, undefined, SECURITYLEVEL); // SET CHANNEL MODEif (MODE =='restricted') { const key =iota.utils.toTrytes(SIDEKEY); mamState =Mam.changeMode(mamState, MODE, key);} else { mamState =Mam.changeMode(mamState, MODE);}// PUBLISH TO TANGLEconst publish =async function(packet) { // CREATE MAM PAYLOAD const trytes =iota .utils.toTrytes(JSON.stringify(Paket)); const message =Mam.create(mamState, trytes); // NEUEN MAMSTATE SPEICHERN mamState =message.state; console.log('Root:', Nachricht.root); console.log('Adresse:', Nachricht.Adresse); // ATTACH THE PAYLOAD wait Mam.attach(message.payload, message.address); return message.root;}// SERIAL PORT LIBRARY EVENTSport.on('open', showPortOpen);parser.on('data', readSerialData);port.on('close', showPortClose);port.on('error ', showError);// CALLBACK FUNCTIONSfunction 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 Gebäude =('13'); json['Zeit'] =Zeit; 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.jsJavaScript

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 ='eingeschränkt'; // PUBLIC, PRIVATE ODER RESTRICTEDconst SIDEKEY ='mysecret'; // NUR ASCII-ZEICHEN EINGEBENlet root;let key;// ARGUMENTE PRÜFENconst args =process.argv;if(args.length !=3) { console.log('Stamm als Argument fehlt:Knoten 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];}// INITIALIZE MAM STATElet mamState =Mam.init(iota);// SET CHANNEL MODEif (MODE =='restricted') { key =iota.utils.toTrytes(SIDEKEY); mamState =Mam.changeMode(mamState, MODE, key);} else { mamState =Mam.changeMode(mamState, MODE);}// RECEIVE DATA FROM THE TANGLEconst 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);

Schaltpläne