Sistema Inteligente de Monitoramento de Qualidade do Ar Interno e Resíduos
Componentes e Materiais
- Raspberry Pi 3 Model B (1 unidade)
- Arduino UNO (1 unidade)
- NodeMCU ESP8266 Breakout Board (1 unidade)
- Sensor DHT11 Temperatura e Umidade (4 pinos) (1 unidade)
- Sensor de Gás Seeed Grove MQ2 (1 unidade)
- Sensor de Gás CO MQ-7 genérico (1 unidade)
- Sensor Ultrassônico HC-SR04 genérico (1 unidade)
- Fonte de alimentação Raspberry Pi (1 unidade)
- Cabo HDMI (1 unidade)
- Cabo USB-A para B (1 unidade)
- Jumpers genéricos (1 conjunto)
- Bateria 5V genérica (1 unidade)
Aplicativos e Serviços Online
- IOTA Tangle
- Node.js
- Raspberry Pi Raspbian
- Arduino IDE
- MQTT
Sobre o Projeto
1. Introdução
Automação predial é o controle centralizado automático de sistemas de aquecimento, ventilação, ar condicionado, iluminação e outros através de um sistema de gestão predial (BAS). Objetivos: conforto dos ocupantes, operação eficiente, redução de consumo de energia e custos, e maior vida útil dos equipamentos.

IOTA é uma tecnologia de contabilidade distribuída de código aberto para troca segura de informações e valor na Internet das Coisas. Sua inovação principal é o Tangle, baseado em Grafo Acíclico Direcionado (DAG), sem comissões, baixa latência e melhor escalabilidade. Espera-se adoção em larga escala.

Especificações do Raspberry Pi 3 B
- CPU: Quad-core 64-bit ARM Cortex A53 @ 1.2 GHz
- GPU: 400MHz VideoCore IV
- Memória: 1GB LPDDR2-900 SDRAM
- Portas USB: 4
- Saídas de vídeo: HDMI, vídeo composto (PAL/NTSC) via jack 3.5mm
- Rede: Ethernet 10/100 Mbps e Wireless LAN 802.11n

Características do Arduino UNO
- Microcontrolador: ATmega328
- Tensão de operação: 5V
- Tensão de entrada recomendada: 7-12V
- Pinos I/O Digitais: 14 (6 com PWM)
- Pinos de Entrada Analógica: 6
- Corrente DC por pino I/O: 40 mA
- Corrente DC para pino 3.3V: 50 mA

Características do NodeMCU
- Módulo WiFi programável
- Hardware IO estilo Arduino (software defined)
- Programável com Arduino IDE
- USB-TTL incluído, plug & play
- 10 GPIOs D0-D10, PWM, IIC, SPI, 1-Wire, ADC A0

Este projeto é dividido em três versões:
- Introdução
- Instalação de Software
- Sistema de Monitoramento de Qualidade do Ar Interno v1
- Sistema de Monitoramento de Qualidade do Ar Interno v2
- Sistema de Monitoramento de Lixo
- Conclusões
2. Instalação de Software
a) Instale o Raspbian no Raspberry Pi 3 B usando NOOBS: downloads
b) Instale Node.js:
$ curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
$ sudo apt-get install -y nodejs
c) Baixe e compile a biblioteca BCM2835 para o sensor 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) Baixe e instale o projeto indoor-air-quality-iota:
$ 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) Instale serialport:
$ npm install serialport
f) Baixe e instale Arduino IDE: site oficial
3. Sistema de Monitoramento de Qualidade do Ar Interno v1
Dados do sensor DHT11 são lidos e publicados no Tangle usando MAM (Masked Authenticated Messaging).
Como funciona?
a) O projeto tem 3 arquivos JavaScript:
- sensor.js: Lê e exibe dados do DHT11 (temperatura e umidade).
- mam_sensor.js: Lê dados do DHT11 e publica no IOTA Tangle via MAM.
- mam_receive.js: Extrai dados armazenados no Tangle via MAM e exibe.
b) Endpoint do full node e side key estão hardcoded nos arquivos JS. Para parar um script, pressione CTRL+Z.
c) Conecte o Arduino UNO ao sensor DHT11.

d) Execute node sensor.js para verificar leitura de temperatura e umidade.
e) Execute node mam_sensor.js para armazenar dados no Tangle.

Nó testado com melhores resultados: https://potato.iotasalad.org:14265
Consulte nós disponíveis em: iotasalad.org/nodes
Informações enviadas:
- Cidade: MEXICO
- Prédio: 65
- Data e Hora (UTC): ANO.MÊS.DIA HORA.MINUTOS.SEGUNDOS
- Dados: Temperatura em °C e °F, Umidade Relativa %
f) Em outro terminal: node mam_receive.js seu_root para ver dados armazenados.

4. Sistema de Monitoramento de Qualidade do Ar Interno v2
Dados dos sensores DHT11, MQ-2 e MQ-7 são lidos e publicados no Tangle via MAM.
Como funciona?
a) O projeto tem 5 arquivos:
- sensorArduino.ino: Captura dados dos três sensores.
- listportsArduino.ino: Mostra portas disponíveis do Arduino UNO.
- sensorArduino.js: Lê e exibe dados dos sensores.
- mam_sensorArduino.js: Publica dados no Tangle via MAM.
- mam_receiveArduino.js: Extrai e exibe dados do Tangle.
b) Endpoint e side key hardcoded. Pare scripts com CTRL+Z.
c) Conecte Arduino UNO aos sensores DHT11, MQ-2 e MQ-7.

d) Na pasta "sensorArduino", instale as bibliotecas DHT11, MQ-2 e MQ7 no Arduino IDE.
e) Carregue o sketch sensorArduino.ino no Arduino UNO. Selecione porta (ex: /dev/ttyACM0).
f) Execute node listportsArduino.js para verificar porta ativa.

g) Execute node mam_sensorArduino.js para armazenar dados no Tangle.

Informações enviadas:
- Cidade: NY
- Prédio: 13
- Data e Hora (UTC)
- Dados: Gás LPG em ppm, CO em ppm, Temperatura °C, Umidade %
h) Em outro terminal: node mam_receiveArduino.js seu_root

5. Sistema de Monitoramento de Lixo
Envia dados do sensor SRF05 usando NodeMCU e MQTT para IOTA Tangle via MAM.
Como funciona?
a) Três arquivos:
- trashcan.ino: Calcula % de lixo na lixeira e envia via MQTT ao Raspberry Pi 3B.
- nodemcu_mqtt_mam.js: Lê dados do sensor SRF05 e publica no Tangle via MAM.
- nodemcu_mam_receive.js: Extrai e exibe dados do Tangle.
b) Endpoint e side key hardcoded. Pare com CTRL+Z.
c) Conecte NodeMCU ao sensor ultrassônico SRF05.

d) Instale pacotes ESP8266 no Board Manager do Arduino IDE. URL: https://arduino.esp8266.com/stable/package_esp8266com_index.json

e) Adicione biblioteca PubSubClient para MQTT no Arduino IDE.
f) Instale Mosquitto (MQTT) no Raspberry Pi 3B:
$ 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
$ 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
$ sudo apt-get install mosquitto mosquitto-clients
Se houver problemas: $ npm install mqtt --save
Reinicie o Pi. Verifique versão: $ mosquitto -v
Inicie/pare o servidor: $ sudo /etc/init.d/mosquitto start/stop
Verifique IP do Pi: $ ifconfig
g) Carregue trashcan.ino no NodeMCU. Configure:
- Placa NodeMCU 1.0
- Porta Serial
- Serial.begin(115200)
- SSID e senha WiFi
- IP do Raspberry Pi como mqtt_server
- Comprimento da lixeira em cm (ex: 25)

h) Execute node nodemcu_mqtt_mam.js para armazenar dados no Tangle.

Informações enviadas:
- Cidade: BERLIN
- Prédio: 7
- Data e Hora (UTC)
- Dados: porcentagem da lixeira
i) Em outro terminal: node mam_receiveArduino.js seu_root

Nó usado: https://durian.iotasalad.org:14265
6. Conclusões
Sistema v1: Funcionou satisfatoriamente monitorando qualidade do ar em edifício na Cidade do México. Teste básico com DHT11, Raspberry Pi 3B, JavaScript e protocolo IOTA.
Sistema v2: Usou DHT11, MQ-2 (LPG) e MQ-7 (CO). Simulou captura em NYC, enviando dados via Arduino UNO e Raspberry Pi para IOTA Tangle via MAM. Prático para adicionar mais sensores. Útil em edifícios inteligentes e indústrias com gás LP e monóxido de carbono.
Monitoramento de Lixo: Controla depósito de lixo em edifício inteligente em Berlim. Evita maus odores de decomposição, informando tempo e porcentagem de enchimento da lixeira.
Código
- sensor.js
- mam_sensor.js
- mam_receive.js
- mam_sensorArduino.js
- mam_receiveArduino.js
sensor.js (JavaScript)
const sensor = require('node-dht-sensor');
const TIMEINTERVAL = 10; // SEGUNDOS
const SENSORTYPE = 11; // 11=DHT11, 22=DHT22
const GPIOPIN = 4; // GPIO RASPBERRY DO SENSOR 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();
setInterval(readSensor, TIMEINTERVAL * 1000);
mam_sensor.js (JavaScript)
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://potato.iotasalad.org:14265' });
const MODE = 'restricted';
const SIDEKEY = 'mysecret';
const SECURITYLEVEL = 3;
const TIMEINTERVAL = 30;
const SENSORTYPE = 11;
const GPIOPIN = 14;
let mamState = Mam.init(iota, undefined, SECURITYLEVEL);
if (MODE == 'restricted') {
const key = iota.utils.toTrytes(SIDEKEY);
mamState = Mam.changeMode(mamState, MODE, key);
} else {
mamState = Mam.changeMode(mamState, MODE);
}
const publish = async function(packet) {
const trytes = iota.utils.toTrytes(JSON.stringify(packet));
const message = Mam.create(mamState, trytes);
mamState = message.state;
console.log('Root: ', message.root);
console.log('Address: ', message.address);
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);
}
});
}
readSensor();
setInterval(readSensor, TIMEINTERVAL * 1000);
mam_receive.js (JavaScript)
const Mam = require('./lib/mam.client.js');
const IOTA = require('iota.lib.js');
const iota = new IOTA({ provider: 'https://potato.iotasalad.org:14265' });
const MODE = 'restricted';
const SIDEKEY = 'mysecret';
let root, key;
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];
}
let mamState = Mam.init(iota);
if (MODE == 'restricted') {
key = iota.utils.toTrytes(SIDEKEY);
mamState = Mam.changeMode(mamState, MODE, key);
} else {
mamState = Mam.changeMode(mamState, MODE);
}
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)
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://potato.iotasalad.org:14265' });
const MODE = 'restricted';
const SIDEKEY = 'mysecret';
const SECURITYLEVEL = 3;
const PORTNAME = '/dev/ttyACM1';
const port = new SerialPort(PORTNAME, { baudRate: 9600, autoOpen: true });
const Readline = SerialPort.parsers.Readline;
const parser = port.pipe(new Readline({ delimiter: '\r\n' }));
let mamState = Mam.init(iota, undefined, SECURITYLEVEL);
if (MODE == 'restricted') {
const key = iota.utils.toTrytes(SIDEKEY);
mamState = Mam.changeMode(mamState, MODE, key);
} else {
mamState = Mam.changeMode(mamState, MODE);
}
const publish = async function(packet) {
const trytes = iota.utils.toTrytes(JSON.stringify(packet));
const message = Mam.create(mamState, trytes);
mamState = message.state;
console.log('Root: ', message.root);
console.log('Address: ', message.address);
await Mam.attach(message.payload, message.address);
return message.root;
}
port.on('open', showPortOpen);
parser.on('data', readSerialData);
port.on('close', showPortClose);
port.on('error', showError);
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)
const Mam = require('./lib/mam.client.js');
const IOTA = require('iota.lib.js');
const iota = new IOTA({ provider: 'https://potato.iotasalad.org:14265' });
const MODE = 'restricted';
const SIDEKEY = 'mysecret';
let root, key;
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];
}
let mamState = Mam.init(iota);
if (MODE == 'restricted') {
key = iota.utils.toTrytes(SIDEKEY);
mamState = Mam.changeMode(mamState, MODE, key);
} else {
mamState = Mam.changeMode(mamState, MODE);
}
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);
Esquemáticos
Diagramas esquemáticos disponíveis nas imagens do projeto original.
Processo de manufatura
- Construa uma Estação Meteorológica e de Qualidade do Ar com Raspberry Pi, InfluxDB e Grafana
- Monitoramento Eficiente de Temperatura de Salas com Raspberry Pi e Nagios
- Construa um Sensor de Temperatura Remoto com Raspberry Pi e Python – Guia Passo a Passo
- Home Energy Centre: Monitoramento Solar PV, Painéis Térmicos e Temperaturas de Ambientes com Raspberry Pi e Moteino
- Construa um Sensor de Movimento Infravermelho DIY para Raspberry Pi – Guia Passo a Passo
- Sistema de Registro e Alerta de Fotocélula com Raspberry Pi – Construa um Sensor de Luz de Baixa Potência com Python
- Construa um Sistema de Monitoramento de Temperatura e Luz Multi-Sensor com Raspberry Pi e DS18B20
- Sensor de Ocupação de Banheiro com Raspberry Pi: Alertas por Voz e SMS via Twilio
- Dominando Controle de Sensores e Atuadores no Raspberry Pi: Acelerômetro, Servo e Streaming de Dados
- Construa um Sistema Aeropônico Automatizado com Raspberry Pi e Sensor de Umidade