Sistema de monitoreo de basura y calidad del aire interior

Acerca de este proyecto

1. Introducción

Automatización de edificios es el control centralizado automático de la calefacción, ventilación y aire acondicionado, iluminación y otros sistemas de un edificio a través de un sistema de gestión de edificios o un sistema de automatización de edificios (BAS). Los objetivos de la automatización de edificios son la mejora del confort de los ocupantes, el funcionamiento eficiente de los sistemas del edificio, la reducción del consumo de energía y los costos operativos y la mejora del ciclo de vida de los servicios públicos.

IOTA es una tecnología de contabilidad distribuida de código abierto, cuyo objetivo es intercambiar de forma segura información y valor en el Internet de las cosas. Una de las principales innovaciones de IOTA es que, en lugar del tradicional Blockchain, utiliza su propia arquitectura (Tangle) basada en un concepto matemático llamado Directed Acyclic Graph (DAG). Esta arquitectura posibilita que no haya comisiones, que la latencia de la red sea baja y mejores perspectivas de escalabilidad. IOTA se encuentra actualmente en desarrollo y se espera que, a lo largo de 2019, la tecnología esté lista para ser adoptada a gran escala.

Las especificaciones de Raspberry Pi 3 B incluir:

• CPU:ARM Cortex A53 de cuatro núcleos y 64 bits con frecuencia de reloj de 1,2 GHz.
• GPU:multimedia VideoCore IV de 400 MHz.
• Memoria:1GB LPDDR2-900 SDRAM (es decir, 900MHz)
• Puertos USB:4.
• Salidas de video:HDMI, video compuesto (PAL y NTSC) a través de un conector de 3,5 mm.
• Red:Ethernet de 10/100 Mbps y LAN inalámbrica 802.11n.

Características de Arduino UNO tablero :

• Microcontrolador:ATmega328.
• Voltaje de funcionamiento:5V.
• Voltaje de entrada (recomendado):7-12 V.
• Voltaje de entrada (límites):6-20V.
• Pines de E / S digitales:14 (de los cuales 6 proporcionan salida PWM)
• Pines de entrada analógica:6.
• Corriente CC por pin de E / S:40 mA.
• Corriente CC para pin de 3.3V:50 mA.

NodeMCU , características:

• Finalmente, módulo WiFi programable.
• IO de hardware similar a Arduino (definido por software).
• Se puede programar con Arduino IDE.
• USB-TTL incluido, plug &play.
• 10 GPIOs D0-D10, funcionalidad PWM, comunicación IIC y SPI, 1-Wire y ADC A0, etc., todo en una sola placa.

Este proyecto se divide en tres versiones. Para una mejor comprensión del proyecto lo hemos dividido en los siguientes capítulos:

• 1. Introducción
• 2. Instalación de software
• 3. Sistema de monitoreo de la calidad del aire interior v1
• 4. Sistema de monitoreo de la calidad del aire interior v2
• 5. Sistema de monitoreo de basura
• 6. Conclusiones

2. Instalación del software

a) Instale Raspbian en Raspberry PI 3 B

Instalé NOOBS , el enlace de descarga y las instrucciones se encuentran en:https://www.raspberrypi.org/downloads/

b) Instalar Node.JS

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

c) Descargue y cree la biblioteca BCM2835 en Raspberry Pi. Esta biblioteca nos ayuda a trabajar con el sensor DHT11.

  $ 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) Descargue e instale el proyecto iota de calidad de aire interior en la Raspberry Pi

  $ cd ~ 
 $ git clone https://github.com/guillengap/indoor-air-quality-and-garbage-monitoring-system.git 
 $ cd indoor-air -sistema-de-monitoreo-de-calidad-y-basura 
 $ npm install  

e) Descargue e instale serialport

  $ nmp install serialport  

f) Descargue e instale Arduino IDE:

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

3. Sistema de monitoreo de la calidad del aire interior v1

Los datos del sensor DHT11 se leen y publican en Tangle mediante MAM.

¿Cómo funciona?

a) El proyecto indoor-air-quality-iota tiene 3 archivos de script java:

• sensor.js :Se leen y se muestran los datos del sensor DHT11:temperatura y humedad.
• mam_sensor.js :Los datos del sensor DHT11 se leen y se publican en IOTA Tangle mediante MAM.
• mam_receive.js :Extraiga los datos almacenados de IOTA Tangle usando MAM y muestre los datos.

b) El punto final del nodo completo y la clave lateral están codificados en los archivos javascript. Para detener la ejecución de una secuencia de comandos, presione CTRL + Z .

c) Conéctese a la placa Arduino UNO, el sensor DHT11.

d) Ejecute nodesensor.js para comprobar si la Raspberry Pi puede leer los datos de temperatura y humedad del módulo del sensor DHT11.

  $ node sensor.js  

Aquí podemos ver los datos de humedad y temperatura capturados por el sensor DHT11. Si todo está bien, vamos al siguiente paso.

e) Ejecuta nodo mam_sensor.js . Este script almacenará los datos de temperatura y humedad del módulo del sensor DHT11 en el Tangle.

  $ node mam_sensor.js  

Probamos con tres nodos y obtuvimos mejores resultados con:https://potato.iotasalad.org:14265

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

Puedes consultar algunos nodos disponibles en:https://iotasalad.org/nodes

Enviamos la siguiente información:

• Ciudad:MÉXICO
• Edificio:65
• Fecha y hora (UTC):AÑO. MES, DÍA, HORA. MINUTOS Y SEGUNDOS
• Datos:temperatura en grados Celsius y Fahrenheit y porcentaje de humedad relativa

f) Abra otra terminal y escriba: nodo mam_receive.js your_root y se muestran los datos almacenados del sensor. Por ejemplo:

  $ node mam_receive.js AMBTIKZKEVEEQFCUGIDUOLDOXL9OZQ9GOMNBFYHVRAUCAMHDQQJBSNAMFZYRLTUVAHFDINHTTFKIPELIG  

El código que gestiona los datos recibidos es:

  // RECIBIR DATOS DEL TANGLE 
 const executeDataRetrieval =función asíncrona (rootVal, keyVal) {
 let resp =await Mam.fetch (rootVal, MODE, keyVal, function (data) {
 let json =JSON.parse (iota.utils.fromTrytes (data)); 
 console.log (`Ciudad:$ {json.city}, Edificio:$ {json.building}, Hora :$ {json.dateTime} UTC, Datos:$ {json.data} `); 
}); 
}  

Prueba

Imágenes

4. Sistema de monitoreo de la calidad del aire interior v2

Los datos de los sensores DHT11, MQ-2 y MQ-7 se leen y publican en Tangle usando MAM

¿Cómo funciona?

a) El proyecto iota de calidad del aire interior tiene 5 archivos:

• sensorArduino.ino :Este código es para capturar los datos de los tres sensores:sensor de temperatura y humedad DHT11, sensor de gas LPG MQ-2 y sensor de gas CO MQ-7.
• listportsArduino.ino :Nos muestra los puertos disponibles de la placa Arduino UNO.
• sensorArduino.js :Se leen y se muestran los datos de los sensores DHT11, MQ-2 y MQ-7.
• mam_sensorArduino.js :Los datos de los sensores DHT11, MQ-2 y MQ-7 se leen y publican en Tangle mediante MAM.
• mam_receiveArduino.js :Extraiga los datos almacenados de Tangle usando MAM y muestre los datos.

b) El punto final del nodo completo y la clave lateral están codificados en los archivos javascript. Para detener la ejecución de una secuencia de comandos, presione CTRL + Z .

c) Conecte a la placa Arduino UNO, los sensores:DHT11, MQ-2 y MQ-7.

d) En la carpeta "sensorArduino", que se encuentra en el proyecto indoor-air-quality-iota, tenemos las bibliotecas de sensores:DHT11, MQ-2 y MQ7. Debemos instalarlos en las bibliotecas de Arduino.

e) Sube el boceto sensorArduino.ino , a la placa Arduino UNO y ejecútelo. Seleccione el puerto de comunicación con la placa Arduino UNO, en mi caso es:Herramientas> Puerto> / dev / ttyACM0

f) Abra una terminal y ejecute node listportsArduino.js para verificar que nuestro puerto esté activo.

  $ node listportsArduino.js  

g) Ejecute nodo mam_sensorArduino.js . Este script almacenará los datos de la placa Arduino UNO en Tangle.

  $ node mam_sensorArduino.js  

Enviamos la siguiente información:

• Ciudad:NY
• Edificio:13
• Fecha y hora (UTC):AÑO. MES, DÍA, HORA. MINUTOS Y SEGUNDOS
• Datos:gas LPG en ppm, gas CO en ppm, temperatura en grados Celsius, porcentaje de humedad relativa,

h) Abra otra terminal y escriba: nodo mam_receiveArduino.js your_root y se muestran los datos almacenados del sensor. Por ejemplo:

El código que gestiona los datos recibidos es:

  // RECIBIR DATOS DEL TANGLE 
 const executeDataRetrieval =función asíncrona (rootVal, keyVal) {
 let resp =await Mam.fetch (rootVal, MODE, keyVal, function (data) {
 let json =JSON.parse (iota.utils.fromTrytes (data)); 
 console.log (`Ciudad:$ {json.city}, Edificio:$ {json.building}, Hora :$ {json.time} UTC, Datos:$ {json.data} `); 
}); 
 executeDataRetrieval (resp.nextRoot, keyVal); 
}  

Prueba

Imágenes

5. Sistema de monitoreo de basura

Envíe los datos del sensor SRF05 usando NodeMCU y MQTT a IOTA Tangle usando MAM

¿Cómo funciona?

a) Este proyecto tiene 3 archivos:

• trashcan.ino :Este código calcula la cantidad de basura dentro de un basurero en%. Luego, envíe los datos a la placa Raspberry Pi 3B, utilizando el protocolo MQTT.
• nodemcu_mqtt_mam .js :Los datos del sensor SRF05 se leen y se publican en Tangle mediante MAM.
• nodemcu_mam_receive.js :Extraiga los datos almacenados de Tangle usando MAM y muestre los datos.

b) El punto final del nodo completo y la clave lateral están codificados en los archivos javascript. Para detener la ejecución de una secuencia de comandos, presione CTRL + Z .

c) Conéctese a NodeMCUboard, los sensores ultrasónicos SRF05.

d) Instale los paquetes esp8266 usando Boards Manager. Abra la ventana de preferencias de Arduino IDE e ingrese en el campo URL del administrador de placa adicional:http://arduino.esp8266.com/stable/package_esp8266com_index.json

Seleccione el menú:Herramientas> Tablero> Administrador de tablero ... En el campo de búsqueda, escriba:esp8266 e instale la última versión.

e) Ahora hagamos que NodeMCU se comunique con un servidor mosquitto. Primero comience agregando la biblioteca PubSubClient al IDE de Arduino. Esta biblioteca es para mensajería MQTT y es compatible con NodeMCU.

• Seleccione el menú:Sketch> Incluir biblioteca> Administrar bibliotecas
• Buscar:PubSub
• Seleccione PubSubClient (Nick O'Leary) e instale la última versión

f) Siguiente instalar Mosquitto (MQTT) en el RaspberryPi 3B. El protocolo MQTT proporciona un método ligero para realizar mensajes mediante un modelo de publicación / suscripción. Esto lo hace adecuado para la mensajería de Internet de las cosas, como con sensores de baja potencia o dispositivos móviles como teléfonos, computadoras integradas o microcontroladores. Inicie sesión en su Raspberry Pi, abra una terminal y escriba:

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

Ahora instale lo siguiente:

  $ 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  

La última versión de libss ... la puedes encontrar aquí:http://security.debian.org/debian-security/pool/updates/main/o/openssl/

Instale el broker MQTT y los clientes mosquito.

  $ sudo apt-get install mosquitto mosquitto-clients  

Si tiene algún problema con la instalación de MQTT, puede intentar:

  $ npm install mqtt --save  

Reinicia la Raspberry Pi. Abra una terminal y verifique la versión de mosquito:

  $ mosquito -v  

Puede iniciar y detener el servidor de mosquitos:

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

Verificamos la IP de la Raspberry Pi:

  $ ifconfig  

g) Sube el boceto trashcan.ino , a la placa NodeMCU. Verifique los siguientes datos:

• Placa NodeMCU 1.0
• Puerto serie
• Serial.begin (115200);
• const char * wifi_ssid ="ARRIS-WXYZ";
• const char * wifi_password ="XXXXXXXXXXXX";
• const char * mqtt_server ="192.168.0.12"; // IP DE FRAMBUESA
• int trashcan =25; // MI BOTE DE BASURA TIENE 25 CM DE LONGITUD

h) Ejecute nodemcu_mqtt_mam.js , este script almacenará los datos de la placa NodeMCU en Tangle.

  $ nodemcu_mqtt_mam.js  

Enviamos la siguiente información:

• Ciudad:BERLIN
• Edificio:7
• Fecha y hora (UTC):AÑO. MES, DÍA, HORA. MINUTOS Y SEGUNDOS
• Datos:porcentaje de papelera.

i) Abra otra terminal y escriba: nodo mam_receiveArduino.js your_root y se muestran los datos almacenados del sensor. Por ejemplo:

El código que gestiona los datos recibidos es:

  // RECIBIR DATOS DEL ENREDO 
 const executeDataRetrieval =async function (rootVal, keyVal) {
 let resp =await Mam.fetch (rootVal, MODE, keyVal, function (data) {
 let json =JSON.parse (iota.utils.fromTrytes (datos)); 
 console.log (`Ciudad:$ {json.city}, Edificio:$ {json.building}, dateTime :$ {json.dateTime} UTC, Datos:$ {json.data} `); 
}); 
 executeDataRetrieval (resp.nextRoot, keyVal); 
}  

En esta ocasión el nodo disponible fue diferente:https://iotasalad.org/nodes

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

Prueba

Imágenes

6. Conclusiones

Sistema de control de la calidad del aire interior v1:

Este proyecto ha funcionado satisfactoriamente y monitorizamos la calidad del aire en el interior de un edificio, como podemos ver en los resultados obtenidos. Simulamos este proyecto en un edificio que se encuentra en la Ciudad de México. Esta fue una prueba básica utilizando el sensor de humedad y temperatura DHT11 y la placa Raspberry Pi 3B, el código Java Script y el protocolo IOTA.

Sistema de control de la calidad del aire interior v2:

En este proyecto hemos utilizado los sensores DHT11, MQ-2 (LPG) y MQ-7 (CO). En esta ocasión. simulamos la captura de datos en un edificio ubicado en la ciudad de Nueva York, y enviamos estos datos usando placas Arduino UNO y Raspberry Pi, a IOTA Tangle usando Masked Authenticated Messaging (MAM). Esta fue una forma práctica y rápida de agregar más sensores. Esta versión se puede usar en edificios inteligentes y en industrias donde se usa gas LP y donde el monóxido de carbono es producido por incendios.

Sistema de control de basura:

El objetivo de este proyecto es tomar el control del depósito de basura en un edificio inteligente ubicado en la ciudad de Berlín o en cualquier distrito. La acumulación de basura, puede producir malos olores de productos en descomposición, pero ahora podemos saber cuánto tiempo tiene un bote de basura con basura y el porcentaje de esta basura.

Código

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

sensor.js JavaScript

Sistema de monitoreo de la calidad del aire interior v1
Código para probar el sensor DHT11

 const sensor =require ('node-dht-sensor'); const TIMEINTERVAL =10; // SECONDSconst SENSORTYPE =11; // 11 =DHT11, 22 =DHT22const GPIOPIN =4; // PIN GPIO DE FRAMBUESA DEL SENSOR DHT11 función readSensor () {sensor.read (SENSORTYPE, GPIOPIN, función (err, temperatura, humedad) {if (! Err) {console.log ('temp:' + temperature.toFixed (1 ) + 'C,' + 'humedad:' + humedad.toFixed (1) + '%');} else {console.log (err);}});} readSensor (); // ACTUALIZA AUTOMÁTICAMENTE EL VALOR DEL SENSOR CADA VEZ 10 SECONDSsetInterval (readSensor, TIMEINTERVAL * 1000); 

mam_sensor.js JavaScript

Sistema de monitoreo de la calidad del aire interior v1
Este código almacena los datos de temperatura y humedad del módulo del sensor DHT11 al 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 ({proveedor:'https://nodes.testnet.iota.org:443 '}); const iota =new IOTA ({proveedor:' https://potato.iotasalad.org:14265 '}); // const iota =new IOTA ({proveedor:' https://peanut.iotasalad.org :14265 '}); const MODE =' restringido '; // PÚBLICO, PRIVADO O RESTRINGIDOconst SIDEKEY ='mysecret'; // UTILIZADO ÚNICAMENTE EN MODO RESTRINGIDOconst SECURITYLEVEL =3; const TIMEINTERVAL =30; // SECONDSconst SENSORTYPE =11; // 11 =DHT11, 22 =DHT22const GPIOPIN =14; // PIN GPIO DE FRAMBUESA DEL SENSOR DHT11 // INICIALIZAR MAM STATElet mamState =Mam.init (iota, undefined, SECURITYLEVEL); // MODO DE CANALif (MODO =='restringido') {clave constante =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 (paquete)); mensaje constante =Mam.create (mamState, trytes); // GUARDAR NUEVO MAMSTATE mamState =message.state; console.log ('Raíz:', message.root); console.log ('Dirección:', mensaje.address); // ADJUNTAR EL PAYLOAD await Mam.attach (message.payload, message.address); return message.root;} function readSensor () {sensor.read (SENSORTYPE, GPIOPIN, función asíncrona (err, temperatura, humedad) {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), Humedad:$ {humedad.toFixed (1)}%} `; const json ={" data ":data," dateTime ":dateTime," edificio ":edificio," ciudad ":ciudad}; const root =aguardar publicar (json); console.log (` Ciudad:$ {json.city}, Edificio:$ {json.building}, Hora:$ {json. dateTime} UTC, Data:$ {json.data}, root:$ {root} `);} else {console.log (err);}});} // INICIAR ITreadSensor (); // ACTUALIZAR AUTOMÁTICAMENTE EL VALOR DEL SENSOR CADA 30 SEGUNDOSsetInterval (readSensor, TIMEINTERVAL * 1000); 

mam_receive.js JavaScript

Sistema de monitoreo de la calidad del aire interior v1
Se muestran los datos almacenados del sensor.

 const Mam =require ('./ lib / mam.client.js'); const IOTA =require ('iota.lib.js'); // const iota =new IOTA ( {proveedor:'https://nodes.testnet.iota.org:443'}); const iota =new IOTA ({proveedor:'https://potato.iotasalad.org:14265'}); // const iota =nuevo IOTA ({proveedor:'https://peanut.iotasalad.org:14265'}); const MODE ='restringido'; // PÚBLICO, PRIVADO O RESTRINGIDOconst SIDEKEY ='mysecret'; // SE UTILIZA SÓLO EN MODO RESTRINGIDOlet root; let key; // COMPROBAR LOS ARGUMENTOSconst args =process.argv; if (args.length! =3) {console.log ('Falta la raíz como argumento:nodo mam_receive.js  '); process.exit ();} else if (! iota.valid.isAddress (args [2])) {console.log ('Has ingresado una raíz inválida:' + args [2]); process.exit ();} else {root =args [2];} // INICIALIZAR ESTADO DE MAMlet mamState =Mam.init (iota); // ESTABLECER MODO DE CANALif (MODO =='restringido') {clave =iota.utils .to Trytes (LLAVE LATERAL); mamState =Mam.changeMode (mamState, MODE, key);} else {mamState =Mam.changeMode (mamState, MODE);} // RECIBIR DATOS DEL TANGLEconst executeDataRetrieval =función asíncrona (rootVal, keyVal) {let resp =await Mam .fetch (rootVal, MODE, keyVal, function (data) {let json =JSON.parse (iota.utils.fromTrytes (data)); console.log (`Ciudad:$ {json.city}, Edificio:$ {json .building}, Hora:$ {json.dateTime} UTC, Datos:$ {json.data} `);}); } executeDataRetrieval (raíz, clave); 

mam_sensorArduino.js JavaScript

Sistema de monitoreo de la calidad del aire interior v2
Los datos de los sensores DHT11, MQ-2 y MQ-7 se leen y publican en Tangle usando 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 ({proveedor:'https://nodes.testnet.iota. org:443 '}); const iota =new IOTA ({proveedor:' https://potato.iotasalad.org:14265 '}); const MODE =' restringido '; // PUBLIC, PRIVATE, RESTRICTEDconst SIDEKEY ='mysecret'; // SOLO CARACTERES ASCIIconst SECURITYLEVEL =3; // 1, 2, 3const PORTNAME ='/ dev / ttyACM1'; // ENTRAR PUERTO VÁLIDO const port =new SerialPort (PORTNAME, {baudRate:9600, autoOpen:true}); const Readline =SerialPort.parsers.Readline; const parser =port.pipe (new Readline ({delimiter:'\ r \ n '})); // INICIALIZAR MAM STATElet mamState =Mam.init (iota, undefined, SECURITYLEVEL); // ESTABLECER MODO DE CANALif (MODO ==' restringido ') {tecla constante =iota.utils.toTrytes (LLAVE LATERAL); 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 (paquete)); mensaje constante =Mam.create (mamState, trytes); // GUARDAR NUEVO MAMSTATE mamState =message.state; console.log ('Raíz:', message.root); console.log ('Dirección:', mensaje.address); // ADJUNTAR EL PAYLOAD await 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); // FUNCIONES DE LLAMADAfunction showPortOpen () {console.log (' Puerto serie abierto. Velocidad de datos:'+ port.baudRate);} función asíncrona readSerialData (datos) {let json ={}; tiempo constante =momento (). utc (). formato ('AAAA / MM / DD hh:mm:ss'); ciudad constante =('NY'); edificio const =('13'); json ['tiempo'] =tiempo; json ['ciudad'] =`$ {ciudad}`; json ['edificio'] =`$ {edificio}`; json ['datos'] =`{$ {datos}}`; 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

Sistema de monitoreo de la calidad del aire interior v2
Extraiga los datos almacenados de Tangle usando MAM y muestre los datos.

 const Mam =require ('./ lib / mam.client.js'); const IOTA =require ('iota.lib.js'); / / const iota =new IOTA ({proveedor:'https://nodes.testnet.iota.org:443'}); const iota =new IOTA ({proveedor:'https://potato.iotasalad.org:14265' }); const MODE ='restringido'; // PÚBLICO, PRIVADO O RESTRINGIDOconst SIDEKEY ='mysecret'; // ENTRAR SOLO CARACTERES ASCII Raíz delet; let key; // VERIFICAR LOS ARGUMENTOSconst args =process.argv; if (args.length! =3) {console.log ('Falta la raíz como argumento:nodo mam_receive.js ' ); process.exit ();} else if (! iota.valid.isAddress (args [2])) {console.log ('Has ingresado una raíz inválida:' + 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);

Esquemas

Schematic diagram Schematic diagram Schematic diagram

DIY Osciloscopio Arduino simple de 20 kHz en Nokia 5110 LCD Juego de ruleta DIY 37 LED