Módulo Didático: MQTT

1. Introdução

Imagine conectar sensores, dispositivos e sistemas em tempo real, com eficiência e simplicidade, mesmo em ambientes com conexões instáveis ou limitadas. Essa é a proposta do MQTT (Message Queuing Telemetry Transport), um protocolo leve, robusto e amplamente utilizado em projetos de Internet das Coisas (IoT). Desenvolvido pela IBM nos anos 1990, o MQTT destaca-se pela sua capacidade de comunicação rápida e eficiente, utilizando o mínimo possível de recursos, sendo ideal para aplicações como automação residencial, agricultura de precisão e monitoramento industrial.

Neste módulo, você terá acesso a um guia completo, combinando teoria e prática, para dominar o uso do MQTT em sistemas distribuídos. Serão abordados os fundamentos do protocolo, a arquitetura publish/subscribe e o funcionamento de tópicos e brokers. Além disso, você colocará os conceitos aprendidos em prática utilizando ferramentas modernas e amplamente adotadas no mercado, como a biblioteca Paho-MQTT para programação em Python, o Node-RED para desenvolvimento visual de fluxos de comunicação, o Grafana para criação de dashboards interativos, e o HiveMQ como broker MQTT em nuvem.

Ao finalizar este módulo, você estará capacitado para projetar, implementar e gerenciar sistemas baseados em MQTT, apto a enfrentar desafios práticos reais e criar soluções inovadoras e escaláveis em diversos contextos da IoT e sistemas distribuídos.

2. O Protocolo MQTT

O MQTT (Message Queuing Telemetry Transport) é um protocolo de comunicação aberto, leve e eficiente, projetado para ambientes com recursos limitados, como redes com baixa largura de banda, alta latência ou conectividade intermitente. Baseado no modelo publish/subscribe, ele foi inicialmente desenvolvido pela IBM nos anos 1990 para monitoramento de oleodutos remotos e rapidamente se tornou um padrão amplamente adotado em aplicações de IoT e sistemas distribuídos.

2.1. Como o MQTT Funciona

O MQTT opera em uma arquitetura cliente-servidor centrada em um componente chamado broker. Clientes podem atuar como:

• Publisher: Envia mensagens ao broker.
• Subscriber: Recebe mensagens dos tópicos.

Tópicos são strings hierárquicas que organizam mensagens, funcionando como canais de comunicação. Por exemplo: sala/temperatura.

2.2. Características Principais

• Leveza: Baixo consumo de recursos.
• Desacoplamento: Comunicação assíncrona via broker.
• Escalabilidade: Milhares de clientes simultâneos.
• Resiliência: Recursos como Last Will and Testament.
• Segurança: Autenticação, TLS/SSL, ACLs.

2.3. Níveis de Qualidade de Serviço (QoS)

O MQTT oferece três níveis de QoS:

• QoS 0 (At most once): Entrega rápida, sem garantia.
• QoS 1 (At least once): Garantia mínima de entrega, risco de duplicação.
• QoS 2 (Exactly once): Entrega garantida e única.

2.4. Exemplos de Aplicação

• Automação Residencial: Integração de dispositivos domésticos.
• Agricultura Inteligente: Sensores para gestão agrícola.
• Monitoramento Industrial: Métricas para manutenção preditiva.
• Logística: Rastreamento e otimização de rotas.

2.5. Comparação com Outros Protocolos

O MQTT, comparado a protocolos como HTTP e CoAP, oferece comunicação mais eficiente e assíncrona, especialmente útil em redes limitadas.

2.6. Limitações do MQTT

• Dependência do Broker: Ponto único de falha.
• Payload Limitado: Não ideal para grandes volumes de dados.
• Complexidade QoS 2: Maior latência e processamento.

3. Arquitetura Publish/Subscribe

A arquitetura Publish/Subscribe (Pub/Sub) é o núcleo do protocolo MQTT e foi projetada para facilitar a comunicação assíncrona, eficiente e escalável entre dispositivos em sistemas distribuídos, especialmente em ambientes de Internet das Coisas (IoT). Diferentemente do modelo tradicional cliente-servidor, no Pub/Sub os dispositivos não se comunicam diretamente, mas sim por meio de um intermediário central: o broker.

3.1. Como Funciona o Modelo Publish/Subscribe

No modelo Pub/Sub, cada dispositivo conectado ao sistema pode assumir dois papéis:

• Publisher: Envia mensagens para tópicos específicos no broker.
• Subscriber: Inscreve-se em tópicos de interesse e recebe mensagens relacionadas.

O broker atua como ponto central, recebendo todas as mensagens dos publishers e distribuindo-as para os subscribers com base nos tópicos aos quais estão inscritos.

3.2. Tópicos e Wildcards

Os tópicos funcionam como canais identificados por strings hierárquicas, como casa/sala/temperatura. Essa estrutura organiza a comunicação e permite grande escalabilidade.

Para maior flexibilidade, o MQTT oferece dois wildcards:

• +: Corresponde a um único nível. Ex.: casa/+/temperatura.
• #: Corresponde a vários níveis. Ex.: casa/#.

3.3. Vantagens do Modelo Pub/Sub

• Escalabilidade: Um único broker pode gerenciar milhares de dispositivos.
• Eficiência: Redução de tráfego desnecessário na rede.
• Flexibilidade: A estrutura de tópicos permite personalizações avançadas.
• Resiliência: Funciona mesmo com falhas temporárias de conectividade.
• Simplicidade: Design claro, com papéis bem definidos para cada cliente.

3.4. Limitações

• Dependência do broker: Pode se tornar um ponto único de falha.
• Gerenciamento de tópicos: Pode se tornar complexo em sistemas grandes.
• Latência em QoS elevado: Maior sobrecarga em ambientes com QoS 2.

3.5. Exemplo Prático

Imagine uma casa inteligente com um sensor de movimento que publica detectado no tópico sala/movimento. Um controlador inscrito nesse tópico envia um comando para sala/luz/estado com o valor ligar. A lâmpada, inscrita nesse último tópico, recebe o comando e acende.

3.6. Comparação com Outros Modelos

No modelo cliente-servidor (como no HTTP), a comunicação é síncrona e exige conexões diretas. No Pub/Sub, o modelo é assíncrono, ideal para IoT. Já o modelo ponto-a-ponto, apesar de simples, não escala bem.

3.7. Papel no MQTT

O modelo Pub/Sub implementado no MQTT explora ao máximo os recursos do protocolo, como leveza, tópicos hierárquicos, wildcards e QoS. Isso o torna ideal para aplicações que exigem comunicação eficiente, confiável e em tempo real entre múltiplos dispositivos.

4. Ferramentas Utilizadas

Este módulo faz uso de um conjunto integrado de ferramentas amplamente reconhecidas no mercado para proporcionar uma aprendizagem prática e aplicada do protocolo MQTT. Essas ferramentas cobrem todas as etapas do desenvolvimento de soluções IoT: da programação e simulação de dispositivos até a visualização e monitoramento de dados em tempo real.

4.1. Visão Geral das Ferramentas

• Paho-MQTT (Python): Biblioteca oficial da Eclipse Foundation para desenvolvimento de clientes MQTT em Python. Utilizada para simular sensores, atuadores e automatizar envios/recebimentos de mensagens.
• Node-RED: Plataforma de desenvolvimento visual baseada em fluxos, ideal para integrar e manipular dados MQTT sem necessidade de programação complexa.
• Grafana: Ferramenta de visualização para dashboards interativos, usada para exibir dados de sensores em tempo real.
• HiveMQ: Broker MQTT em nuvem usado como ponto central de comunicação entre dispositivos e sistemas distribuídos.
• MQTT Explorer: Cliente gráfico usado para debugar e visualizar a árvore de tópicos MQTT durante o desenvolvimento.

4.2. Integração das Ferramentas no Fluxo de Trabalho

As ferramentas se complementam em um fluxo de trabalho coeso, que será explorado nos projetos práticos:

1. Desenvolvimento: Simulação de dispositivos e scripts MQTT com Python + Paho.
2. Prototipagem: Criação de lógicas com Node-RED (ex.: automações, dashboards).
3. Comunicação: Troca de mensagens centralizada via broker HiveMQ.
4. Visualização: Dashboards interativos com Grafana.
5. Depuração: Inspeção e testes com MQTT Explorer.

4.3. Benefícios Educacionais

• Didática prática: Foco em atividades reais com simulações e dashboards.
• Acessibilidade: Todas as ferramentas têm versões gratuitas ou open-source.
• Relevância profissional: Amplamente usadas em projetos de IoT e na indústria.
• Progressão natural: Suporte a tarefas simples e também a desafios mais avançados.

4.4. Alternativas Complementares

Outras ferramentas e bibliotecas poderão ser exploradas em fases avançadas ou projetos pessoais:

• Mosquitto: Broker leve para instalação local.
• InfluxDB + Telegraf: Armazenamento de séries temporais para uso com Grafana.
• MQTT.js: Cliente MQTT para aplicações em JavaScript.
• MQTT Lens: Alternativa ao MQTT Explorer com interface distinta.

4.5. Preparação para os Projetos

As ferramentas serão utilizadas em conjunto na seção de Projetos Práticos. Um exemplo será a criação de um sistema completo de monitoramento de temperatura com:

• Simulador de sensor em Python (Paho-MQTT);
• Processamento e lógica de controle no Node-RED;
• Envio e recebimento de mensagens via HiveMQ;
• Visualização em tempo real com Grafana;
• Depuração e testes com MQTT Explorer.

5. Uso do Paho-MQTT

A biblioteca Paho-MQTT, mantida pela Eclipse Foundation, é uma das ferramentas mais populares e versáteis para desenvolver clientes MQTT em Python. Com uma API intuitiva, suporte a autenticação, TLS/SSL e múltiplos níveis de QoS, ela permite a criação de sensores e atuadores virtuais, simulação de cenários IoT e integração com sistemas distribuídos em tempo real.

5.1. Instalação

Instale a biblioteca com:

pip3 install paho-mqtt==2.1.0

Recomenda-se o uso de ambientes virtuais para evitar conflitos:

python3 -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate   # Windows
pip3 install paho-mqtt==2.1.0

5.2. Estrutura Básica

• Criação do cliente (mqtt.Client());
• Definição dos callbacks (on_connect, on_message);
• Conexão ao broker (connect());
• Publicação/subscrição em tópicos;
• Manutenção do loop (loop_forever() ou loop_start()).

5.3. Exemplo: Sensor Virtual

import paho.mqtt.client as mqtt
import time, random

broker = "broker.hivemq.com"
topico = "ufpr/iot/temperatura"
cliente = mqtt.Client(client_id=f"sensor-{random.randint(0, 999)}")

cliente.connect(broker)

while True:
    temperatura = round(random.uniform(20, 30), 2)
    cliente.publish(topico, f"{temperatura}")
    print(f"Publicado: {temperatura} °C")
    time.sleep(5)

5.4. Exemplo: Atuador com Lógica

import paho.mqtt.client as mqtt

def on_connect(c, u, f, rc):
    if rc == 0:
        print("Conectado!")
        c.subscribe("ufpr/iot/temperatura")

def on_message(c, u, msg):
    valor = float(msg.payload.decode())
    print(f"Temperatura: {valor} °C")
    print("Ventilador: LIGADO" if valor > 28 else "Ventilador: DESLIGADO")

cliente = mqtt.Client("atuador-ventilador")
cliente.on_connect = on_connect
cliente.on_message = on_message
cliente.connect("broker.hivemq.com")
cliente.loop_forever()

5.5. Cliente Seguro com TLS

import paho.mqtt.client as mqtt, ssl

cliente = mqtt.Client("cliente-seguro")
cliente.username_pw_set("usuario", "senha")
cliente.tls_set(tls_version=ssl.PROTOCOL_TLSv1_2)
cliente.connect("seu-broker.hivemq.cloud", 8883)
cliente.loop_start()

5.6. Sensor com Reconexão

def on_disconnect(client, userdata, rc):
    print("Desconectado. Reconectando...")
    client.reconnect()

5.7. Boas Práticas

• Use client_id único para evitar desconexões.
• Implemente reconexão automática.
• Use JSON como payload para dados complexos.
• Adicione logs com on_log para debug.
• Combine com ferramentas como MQTT Explorer para validação.

5.8. Aplicações no Curso

• Sensores e atuadores virtuais em projetos práticos;
• Comunicação com Node-RED e Grafana via HiveMQ;
• Exploração de tópicos, QoS e segurança em MQTT.

6. Uso do Node-RED

O Node-RED é uma plataforma de desenvolvimento visual baseada em fluxogramas, criada pela IBM e mantida como projeto open-source. Amplamente utilizada em projetos de Internet das Coisas (IoT), automação, integração de APIs e prototipagem rápida, ela permite criar sistemas conectados arrastando e conectando blocos (nodes) em uma interface intuitiva. Com pouco ou nenhum código, os alunos podem construir fluxos complexos que integram dispositivos MQTT, processam dados e exibem resultados em tempo real, reduzindo a curva de aprendizado e incentivando a experimentação.

6.1. Instalação Detalhada

6.1.1. Linux (Ubuntu, Mint, Debian)

Para instalação em sistemas baseados em Debian:

1. Atualize o sistema:
   sudo apt update && sudo apt upgrade -y
2. Instale Node.js e npm (recomendamos a versão LTS):
   

   curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - 
   sudo apt install -y nodejs

3. Verifique as versões:
   

   node -v  # Deve retornar v20.x.x
   npm -v   # Deve retornar 10.x.x

4. Instale o Node-RED globalmente:
   

   sudo npm install -g --unsafe-perm node-red

5. Inicie o Node-RED:
   

   node-red

6. (Opcional) Configure como serviço para inicialização automática:
   

   sudo systemctl enable nodered.service
   sudo systemctl start nodered.service

7. Acesse no navegador: http://localhost:1880

6.1.2. Windows

Para instalação no Windows:

1. Baixe e instale o Node.js (LTS) em nodejs.org
2. Verifique a instalação no Prompt de Comando:
   

   node -v
   npm -v

3. Instale o Node-RED:
   

   npm install -g --unsafe-perm node-red

4. Inicie:
   

   node-red

5. Acesse: http://localhost:1880

6.2. Conceitos Fundamentais

Nodes

Blocos básicos de funcionalidade no Node-RED. Cada node tem uma função específica e pode ser configurado.

// Exemplo de node function
if (msg.payload > 30) {
    msg.alert = "ALERTA: Temperatura alta!";
}
return msg;

Fluxos

Sequência de nodes conectados que formam uma lógica de processamento.

Mensagens

Objetos que transitam entre os nodes, contendo dados no formato JSON.

{
  "payload": 25.5,
  "topic": "sensor/temperatura",
  "timestamp": 1625097600
}

6.3. Exemplos Avançados

6.3.1. Integração com Banco de Dados

Armazenando dados MQTT em um banco de dados SQLite:

// Instale o node-red-node-sqlite
npm install node-red-node-sqlite

// Fluxo exemplo:
1. MQTT In (tópico: "sensor/umidade")
2. Function Node:
   msg.query = "INSERT INTO sensor_data VALUES(datetime('now'), " + 
               msg.payload + ");";
   return msg;
3. SQLite Node (configurado com arquivo 'dados.db')
4. Debug Node para verificação

6.3.2. API REST com Node-RED

Criando um endpoint para consulta de dados:

1. HTTP In Node (GET /api/temperatura)
2. Function Node:
   // Consulta ao banco de dados
   msg.query = "SELECT * FROM sensor_data ORDER BY timestamp DESC LIMIT 1";
   return msg;
3. SQLite Node
4. Function Node para formatar resposta:
   msg.payload = {
     temperatura: msg.payload[0].value,
     timestamp: msg.payload[0].timestamp
   };
   return msg;
5. HTTP Response Node

6.4. Boas Práticas

• Organização: Use tabs para separar fluxos lógicos diferentes
• Comentários: Adicione notes para explicar fluxos complexos
• Versionamento: Exporte regularmente seus fluxos para arquivos JSON
• Segurança: Proteja a interface de administração com autenticação
• Monitoramento: Use o node 'status' para verificar saúde dos nodes

6.5. Solução de Problemas Comuns

6.6. Recursos Adicionais

• Documentação Oficial
• Biblioteca de Nodes
• Repositórios GitHub
• Fórum da Comunidade

7. Dashboards com Grafana e HiveMQ

7.1. Arquitetura de Integração Avançada

1

Dispositivos IoT publicam dados via MQTT para o HiveMQ

2

Telegraf coleta os dados e envia para InfluxDB

3

Grafana visualiza os dados armazenados no InfluxDB

7.2. Configuração Detalhada das Ferramentas

# Ubuntu/Debian
wget -qO- https://repos.influxdata.com/influxdb.key | sudo apt-key add -
echo "deb https://repos.influxdata.com/debian stable main" | sudo tee /etc/apt/sources.list.d/influxdb.list
sudo apt update
sudo apt install influxdb2
sudo systemctl start influxdb

[[inputs.mqtt_consumer]]
  servers = ["tcp://broker.hivemq.com:1883"]
  topics = [
    "ufpr/iot/temperatura",
    "ufpr/iot/umidade",
    "ufpr/iot/status"
  ]
  data_format = "value"
  data_type = "float"  # Para dados numéricos

[[outputs.influxdb_v2]]
  urls = ["http://localhost:8086"]
  token = "$INFLUX_TOKEN"
  organization = "ufpr"
  bucket = "iot_data"

7.3. Exemplos Práticos Aprimorados

import paho.mqtt.client as mqtt
import random, time

client = mqtt.Client()
client.connect("broker.hivemq.com", 1883)

while True:
    temp = round(random.uniform(20, 35), 1)
    hum = random.randint(40, 90)
    aqi = random.randint(0, 500)
    
    client.publish("ambiente/sensor1/temperatura", temp)
    client.publish("ambiente/sensor1/umidade", hum)
    client.publish("ambiente/sensor1/aqi", aqi)
    
    time.sleep(30)

[[inputs.mqtt_consumer]]
  servers = ["tcp://broker.hivemq.com:1883"]
  topics = [
    "ambiente/+/temperatura",
    "ambiente/+/umidade",
    "ambiente/+/aqi"
  ]
  data_format = "value"
  data_type = "float"

[[inputs.mqtt_consumer]]
  servers = ["tcp://broker.hivemq.com:1883"]
  topics = ["fabrica/linha1/vibracao"]
  data_format = "value"
  data_type = "float"

[[processors.starlark]]
  source = '''
def apply(metric):
    if metric.fields["value"] > 5.0:
        metric.fields["status"] = "CRITICO"
    elif metric.fields["value"] > 3.0:
        metric.fields["status"] = "ALERTA"
    else:
        metric.fields["status"] = "NORMAL"
    return metric
'''

7.4. Node-RED Dashboard como Alternativa

Implementação Rápida

1. Instale o pacote:

   npm install node-red-dashboard

2. Crie um fluxo simples:

   [MQTT In] -> [Function] -> [UI Gauge]

3. Acesse em:

   http://localhost:1880/ui

Recurso	Grafana	Node-RED Dashboard
Curva de aprendizado	Moderada	Baixa
Visualizações	Profissionais e completas	Básicas
Armazenamento	Banco de dados externo	Memória (volátil)
Melhor para	Sistemas de produção	Protótipos rápidos

7.5. Integração com Hardware Real

#include 
#include 
#include "DHT.h"

#define DHTPIN 4
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);
WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  dht.begin();
  client.setServer("broker.hivemq.com", 1883);
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  if (!isnan(h) && !isnan(t)) {
    client.publish("ufpr/iot/temperatura", String(t).c_str());
    client.publish("ufpr/iot/umidade", String(h).c_str());
  }
  delay(10000);
}

# No Raspberry Pi OS
curl -s https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
sudo apt update
sudo apt install grafana
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

7.6. Boas Práticas e Otimizações

localizacao/dispositivo/tipo-dado
ex: 
  ufpr/lab1/temperatura
  ufpr/lab1/umidade
  casa/sala/iluminacao

8. Instalação das Ferramentas

Esta seção fornece um guia completo para instalar as ferramentas utilizadas no módulo MQTT, cobrindo Python com Paho-MQTT, Node-RED, InfluxDB, Telegraf, Grafana, MQTT Explorer e brokers MQTT. As instruções são detalhadas para Linux (Ubuntu, Linux Mint, Debian), com adaptações para Windows e macOS, além de alternativas para ambientes restritos (ex.: laboratórios de universidade).

Python + Paho-MQTT

Para desenvolvimento de clientes MQTT

Node-RED

Plataforma de fluxos visuais para IoT

InfluxDB + Telegraf

Armazenamento e coleta de dados temporais

Grafana

Visualização de dados em dashboards

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

brew install python
python3 -m venv mqtt-venv
source mqtt-venv/bin/activate
pip3 install paho-mqtt==2.1.0

brew install node
sudo npm install -g --unsafe-perm node-red
node-red

brew install influxdb telegraf grafana
brew services start influxdb
brew services start telegraf
brew services start grafana

8.4. Verificação Pós-Instalação

8.5. Solução de Problemas

8.6. Configuração para Laboratórios

#!/bin/bash
# Instala todas as dependências
sudo apt update
sudo apt install -y python3 python3-pip python3-venv
pip3 install paho-mqtt

# Instala Node-RED
curl -sL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs
sudo npm install -g --unsafe-perm node-red

# ... (adicionar outras ferramentas)

docker run -d -p 1880:1880 -v node_red_data:/data --name nodered nodered/node-red

docker run -d -p 8086:8086 -v influxdb_data:/var/lib/influxdb2 influxdb:latest
docker run -d -p 3000:3000 -v grafana_data:/var/lib/grafana grafana/grafana

9. Projetos Práticos com MQTT

9.1. Monitoramento de Temperatura e Umidade com Dashboard

Visão Geral Código Node-RED Grafana

Objetivo

Criar um sistema completo para monitoramento ambiental com:

• Coleta de dados de sensores
• Transmissão via MQTT
• Visualização em tempo real
• Alertas automáticos

Fluxo de Dados

1. Sensor → MQTT → Node-RED
2. Node-RED → InfluxDB
3. InfluxDB → Grafana
4. Grafana → Alertas

Simulador de Sensor Python

Copiar

import paho.mqtt.client as mqtt
import time, random

client = mqtt.Client("sensor-ambiental")
client.connect("broker.hivemq.com", 1883)

while True:
    temp = round(random.uniform(20, 35), 2)
    umid = round(random.uniform(40, 80), 2)
    client.publish("ufpr/iot/temperatura", temp)
    client.publish("ufpr/iot/umidade", umid)
    print(f"Temp: {temp}°C, Umid: {umid}%")
    time.sleep(5)

Configuração Telegraf

[[inputs.mqtt_consumer]]
  servers = ["tcp://broker.hivemq.com:1883"]
  topics = ["ufpr/iot/temperatura", "ufpr/iot/umidade"]
  data_format = "value"
  data_type = "float"

[[outputs.influxdb_v2]]
  urls = ["http://localhost:8086"]
  token = "SEU_TOKEN"
  organization = "ufpr"
  bucket = "iot_dados"

Fluxo Node-RED

Passos para Configuração:

1. Adicione nodes MQTT de entrada para cada tópico
2. Conecte a nodes de dashboard (gauge, chart)
3. Configure um node de função para alertas:

   if (msg.payload > 30) {
       msg.alert = "ALERTA: Temperatura alta!";
   } else {
       msg.alert = "Normal";
   }
   return msg;

4. Implante o fluxo

Dashboard Grafana

Configuração:

1. Crie nova fonte de dados InfluxDB
2. Adicione painel com query:

   from(bucket: "iot_dados")
     |> range(start: v.timeRangeStart)
     |> filter(fn: (r) => r._measurement == "mqtt_consumer")
     |> filter(fn: (r) => r._field == "value")
     |> filter(fn: (r) => r.topic == "ufpr/iot/temperatura")

3. Configure alertas para valores > 30°C

9.2. Detecção de Som de Motosserra na Floresta

Arquitetura do Sistema

Este projeto implementa uma solução completa para monitoramento acústico em áreas florestais:

Captura de Áudio

Microfone conectado a Raspberry Pi ou computador

Processamento

Análise de espectro de frequência em Python

Comunicação

Alertas transmitidos via MQTT

Visualização

Dashboard Node-RED com histórico no Grafana

Implementação do Detector

Detecção por Frequência

Copiar

import sounddevice as sd
import numpy as np
import paho.mqtt.client as mqtt

# Configuração MQTT
client = mqtt.Client("detector-motosserra")
client.connect("broker.hivemq.com", 1883)

def audio_callback(indata, frames, time_info, status):
    # Transformada de Fourier
    freq = np.fft.fftfreq(len(indata), 1/44100)
    fft = np.abs(np.fft.fft(indata[:, 0]))
    
    # Verifica picos na faixa de motosserra (500-2000Hz)
    if np.max(fft[(freq > 500) & (freq < 2000)]) > 1000:
        client.publish("floresta/alerta", "Motosserra detectada!")
        print("Alerta enviado!")

# Inicia captura
with sd.InputStream(callback=audio_callback, 
                   samplerate=44100, 
                   channels=1):
    print("Monitorando ambiente...")
    while True:
        time.sleep(0.1)

Simulação para Testes

# Simulador para laboratório
import time, random
import paho.mqtt.client as mqtt

client = mqtt.Client("simulador-motosserra")
client.connect("broker.hivemq.com", 1883)

while True:
    if random.random() > 0.7:  # 30% chance de alerta
        client.publish("floresta/alerta", "Motosserra detectada!")
        print("Alerta simulado enviado")
    time.sleep(10)

Fluxo Node-RED

Configuração básica para receber alertas e acionar notificações

Técnicas Avançadas

Machine Learning

Implementação de modelo TensorFlow para melhorar a precisão da detecção:

# Carrega modelo pré-treinado
model = tf.keras.models.load_model('motosserra_model.h5')

# Extrai features (ex.: MFCC)
mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=40)
prediction = model.predict(mfccs.T.mean(axis=0).reshape(1, -1))

Notificações Multiplataforma

Configuração no Node-RED para enviar alertas por:

• E-mail (node-red-contrib-email)
• Telegram (node-red-contrib-telegrambot)
• SMS (via Twilio)

9.3. Sistema de Identificação de Animais

Visão Geral

Sistema completo para monitoramento de fauna silvestre com:

• Captura de imagens por câmera trap
• Processamento em tempo real
• Alertas para espécies específicas
• Mapa de ocorrências

Implementação

Simulação OpenCV YOLO

Versão para Simulação em Laboratório

import paho.mqtt.client as mqtt
import time, random

client = mqtt.Client("camera-trap-sim")
client.connect("broker.hivemq.com", 1883)

animais = ["onca", "veado", "tamandua", "nada"]

while True:
    animal = random.choice(animais)
    if animal == "onca":
        client.publish("floresta/animais", 
                      "Onça detectada! -15.123,-45.321")
        print("Alerta: Onça detectada!")
    time.sleep(15)

Implementação com OpenCV

import cv2
import paho.mqtt.client as mqtt

# Carrega classificador Haar Cascade
animal_cascade = cv2.CascadeClassifier('haarcascade_animal.xml')

client = mqtt.Client("camera-trap")
client.connect("broker.hivemq.com", 1883)

cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    animais = animal_cascade.detectMultiScale(gray, 1.3, 5)
    
    if len(animais) > 0:
        client.publish("floresta/animais", 
                      f"Animal detectado - {len(animais)} objetos")
    
    cv2.imshow('Camera Trap', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()

Implementação com YOLO

from ultralytics import YOLO
import paho.mqtt.client as mqtt

model = YOLO('yolov8n.pt')  # Modelo pré-treinado
client = mqtt.Client("camera-trap-yolo")
client.connect("broker.hivemq.com", 1883)

results = model.track(source=0, show=True, stream=True)

for r in results:
    if 'animal' in r.names.values():
        client.publish("floresta/animais", 
                      f"{r.names[0]} detectado - {r.boxes.xyxy}")

Visualização no Node-RED

Elementos do Dashboard:

• Card de último animal detectado
• Mapa com localização
• Histórico de detecções
• Controle de sensibilidade

9.5. Integração com o Curso

Simulação de dispositivos e sensores

Orquestração e automação de fluxos

Visualização profissional de dados

Comunicação centralizada via MQTT

Resultados de Aprendizado

• Domínio dos conceitos de publish/subscribe
• Integração de múltiplas tecnologias IoT
• Desenvolvimento de soluções para problemas reais
• Prototipagem rápida de sistemas distribuídos

9. Projetos Práticos com MQTT

9.1. Monitoramento de Temperatura e Umidade com Dashboard

Visão Geral Código Node-RED Grafana

Objetivo

Criar um sistema completo para monitoramento ambiental com:

• Coleta de dados de sensores
• Transmissão via MQTT
• Visualização em tempo real
• Alertas automáticos

Fluxo de Dados

1. Sensor → MQTT → Node-RED
2. Node-RED → InfluxDB
3. InfluxDB → Grafana
4. Grafana → Alertas

Simulador de Sensor Python

Copiar

import paho.mqtt.client as mqtt
import time, random

client = mqtt.Client("sensor-ambiental")
client.connect("broker.hivemq.com", 1883)

while True:
    temp = round(random.uniform(20, 35), 2)
    umid = round(random.uniform(40, 80), 2)
    client.publish("ufpr/iot/temperatura", temp)
    client.publish("ufpr/iot/umidade", umid)
    print(f"Temp: {temp}°C, Umid: {umid}%")
    time.sleep(5)

Configuração Telegraf

[[inputs.mqtt_consumer]]
  servers = ["tcp://broker.hivemq.com:1883"]
  topics = ["ufpr/iot/temperatura", "ufpr/iot/umidade"]
  data_format = "value"
  data_type = "float"

[[outputs.influxdb_v2]]
  urls = ["http://localhost:8086"]
  token = "SEU_TOKEN"
  organization = "ufpr"
  bucket = "iot_dados"

Fluxo Node-RED

Passos para Configuração:

1. Adicione nodes MQTT de entrada para cada tópico
2. Conecte a nodes de dashboard (gauge, chart)
3. Configure um node de função para alertas:

   if (msg.payload > 30) {
       msg.alert = "ALERTA: Temperatura alta!";
   } else {
       msg.alert = "Normal";
   }
   return msg;

4. Implante o fluxo

Dashboard Grafana

Configuração:

1. Crie nova fonte de dados InfluxDB
2. Adicione painel com query:

   from(bucket: "iot_dados")
     |> range(start: v.timeRangeStart)
     |> filter(fn: (r) => r._measurement == "mqtt_consumer")
     |> filter(fn: (r) => r._field == "value")
     |> filter(fn: (r) => r.topic == "ufpr/iot/temperatura")

3. Configure alertas para valores > 30°C

9.2. Detecção de Som de Motosserra na Floresta

Arquitetura do Sistema

Este projeto implementa uma solução completa para monitoramento acústico em áreas florestais:

Captura de Áudio

Microfone conectado a Raspberry Pi ou computador

Processamento

Análise de espectro de frequência em Python

Comunicação

Alertas transmitidos via MQTT

Visualização

Dashboard Node-RED com histórico no Grafana

Implementação do Detector

Detecção por Frequência

Copiar

import sounddevice as sd
import numpy as np
import paho.mqtt.client as mqtt

# Configuração MQTT
client = mqtt.Client("detector-motosserra")
client.connect("broker.hivemq.com", 1883)

def audio_callback(indata, frames, time_info, status):
    # Transformada de Fourier
    freq = np.fft.fftfreq(len(indata), 1/44100)
    fft = np.abs(np.fft.fft(indata[:, 0]))
    
    # Verifica picos na faixa de motosserra (500-2000Hz)
    if np.max(fft[(freq > 500) & (freq < 2000)]) > 1000:
        client.publish("floresta/alerta", "Motosserra detectada!")
        print("Alerta enviado!")

# Inicia captura
with sd.InputStream(callback=audio_callback, 
                   samplerate=44100, 
                   channels=1):
    print("Monitorando ambiente...")
    while True:
        time.sleep(0.1)

Simulação para Testes

# Simulador para laboratório
import time, random
import paho.mqtt.client as mqtt

client = mqtt.Client("simulador-motosserra")
client.connect("broker.hivemq.com", 1883)

while True:
    if random.random() > 0.7:  # 30% chance de alerta
        client.publish("floresta/alerta", "Motosserra detectada!")
        print("Alerta simulado enviado")
    time.sleep(10)

Fluxo Node-RED

Configuração básica para receber alertas e acionar notificações

Técnicas Avançadas

Machine Learning

Implementação de modelo TensorFlow para melhorar a precisão da detecção:

# Carrega modelo pré-treinado
model = tf.keras.models.load_model('motosserra_model.h5')

# Extrai features (ex.: MFCC)
mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=40)
prediction = model.predict(mfccs.T.mean(axis=0).reshape(1, -1))

Notificações Multiplataforma

Configuração no Node-RED para enviar alertas por:

• E-mail (node-red-contrib-email)
• Telegram (node-red-contrib-telegrambot)
• SMS (via Twilio)

9.3. Sistema de Identificação de Animais

Visão Geral

Sistema completo para monitoramento de fauna silvestre com:

• Captura de imagens por câmera trap
• Processamento em tempo real
• Alertas para espécies específicas
• Mapa de ocorrências

Implementação

Simulação OpenCV YOLO

Versão para Simulação em Laboratório

import paho.mqtt.client as mqtt
import time, random

client = mqtt.Client("camera-trap-sim")
client.connect("broker.hivemq.com", 1883)

animais = ["onca", "veado", "tamandua", "nada"]

while True:
    animal = random.choice(animais)
    if animal == "onca":
        client.publish("floresta/animais", 
                      "Onça detectada! -15.123,-45.321")
        print("Alerta: Onça detectada!")
    time.sleep(15)

Implementação com OpenCV

import cv2
import paho.mqtt.client as mqtt

# Carrega classificador Haar Cascade
animal_cascade = cv2.CascadeClassifier('haarcascade_animal.xml')

client = mqtt.Client("camera-trap")
client.connect("broker.hivemq.com", 1883)

cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    animais = animal_cascade.detectMultiScale(gray, 1.3, 5)
    
    if len(animais) > 0:
        client.publish("floresta/animais", 
                      f"Animal detectado - {len(animais)} objetos")
    
    cv2.imshow('Camera Trap', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()

Implementação com YOLO

from ultralytics import YOLO
import paho.mqtt.client as mqtt

model = YOLO('yolov8n.pt')  # Modelo pré-treinado
client = mqtt.Client("camera-trap-yolo")
client.connect("broker.hivemq.com", 1883)

results = model.track(source=0, show=True, stream=True)

for r in results:
    if 'animal' in r.names.values():
        client.publish("floresta/animais", 
                      f"{r.names[0]} detectado - {r.boxes.xyxy}")

Visualização no Node-RED

Elementos do Dashboard:

• Card de último animal detectado
• Mapa com localização
• Histórico de detecções
• Controle de sensibilidade

9.5. Integração com o Curso

Simulação de dispositivos e sensores

Orquestração e automação de fluxos

Visualização profissional de dados

Comunicação centralizada via MQTT

Resultados de Aprendizado

• Domínio dos conceitos de publish/subscribe
• Integração de múltiplas tecnologias IoT
• Desenvolvimento de soluções para problemas reais
• Prototipagem rápida de sistemas distribuídos

10. Desafios e Próximos Passos

Com os conceitos de MQTT dominados e os projetos práticos concluídos, é hora de explorar novos horizontes. Esta seção apresenta desafios que estimulam a criatividade, o pensamento crítico e a integração interdisciplinar (IoT, computação embarcada, IA, visualização de dados), além de próximos passos para aprofundar seu aprendizado. Prepare-se para transformar conhecimento em soluções inovadoras, trabalhando individualmente ou em equipe!

10.1. Desafios Propostos

Os desafios a seguir ampliam os projetos das seções 9.1 a 9.7, incentivando a aplicação de MQTT em cenários complexos. Cada um inclui objetivos, ferramentas sugeridas e dicas para começar.

import 'package:mqtt_client/mqtt_client.dart';

void main() async {
  final client = MqttClient('broker.hivemq.com', 'app-client');
  await client.connect();
  client.subscribe('casa/sala/presenca', MqttQos.atMostOnce);
  client.updates.listen((msg) => print(msg[0].payload.message));
  client.publishMessage('casa/sala/luz', MqttQos.atMostOnce, 'ligar'.codeUnits);
}

10.2. Próximos Passos

Para continuar sua jornada em IoT e MQTT, experimente estas sugestões práticas e amplie suas habilidades:

• Explore Brokers Locais:
  • Configure o Mosquitto em uma Raspberry Pi ou máquina virtual (seção 8.7).
  • Teste recursos avançados como QoS 2, retenção de mensagens e bridge entre brokers.
  • Recurso: Documentação oficial (mosquitto.org).
• Substitua Sensores Virtuais por Reais:
  • Use ESP8266/ESP32 com sensores como DHT11/DHT22 (temperatura/umidade), LDR (luz), MQ-135 (CO₂), relés para atuadores.
  • Adapte os scripts Paho-MQTT (seção 9) para MicroPython no ESP.
  • Exemplo: from umqtt.simple import MQTTClient; client.publish("topico", "valor").
• Integração com Serviços Externos:
  • Consuma APIs públicas (ex.: OpenWeatherMap para clima, Google Maps para localização).
  • Publique dados da API em tópicos MQTT e integre no Node-RED/Grafana.
  • Exemplo: Use node-red-contrib-http-request para buscar clima e publicar em meteo/clima.
• Documente e Compartilhe:
  • Crie relatórios com diagramas (ex.: Draw.io), capturas de tela (dashboards, fluxos), códigos e vídeos curtos.
  • Publique em plataformas como GitHub ou Hackster.io para portfólio.
  • Dica: Grave um vídeo de 1-2 minutos mostrando o funcionamento do seu projeto.
• Participe de Comunidades:
  • Entre em fóruns (Stack Overflow, Reddit r/IoT), grupos de Telegram/WhatsApp de IoT, ou comunidades MQTT (HiveMQ Community).
  • Participe de hackathons ou eventos makers locais.
  • Recurso: community.hivemq.com.
• Monte uma Bancada IoT:
  • Reúna ESP32, sensores (DHT22, LDR, PIR), atuadores (LEDs, relés), breadboard, protoboard, cabos jumper.
  • Teste protótipos físicos integrados ao MQTT (ex.: ligar LED via comando do Node-RED).
  • Investimento inicial: Kit básico (~R$100-200 em lojas como Mercado Livre).
• Aprofunde-se em Ferramentas Avançadas:
  • Experimente Docker para rodar Mosquitto, InfluxDB e Grafana em containers.
  • Explore plataformas como Home Assistant ou ThingsBoard para IoT completo.
  • Recurso: Tutoriais Docker (docker.com).

10.3. Inspiração e Motivação

11. Referências

11.1. Documentações e Recursos Online

• Eclipse Foundation. (s.d.). Paho Project. Disponível em: https://www.eclipse.org/paho/ DOCUMENTAÇÃO
  Relevância: Documentação oficial da biblioteca Paho-MQTT (Python e outras linguagens), usada nos projetos práticos (seção 9) para publicação e subscrição de mensagens MQTT.
• HiveMQ. (s.d.). MQTT Essentials. Disponível em: https://www.hivemq.com/mqtt-essentials/ TUTORIAL
  Relevância: Guia introdutório sobre o protocolo MQTT, cobrindo tópicos, QoS e casos de uso, essencial para os fundamentos do módulo (seção 5).
• IBM. (s.d.). Node-RED – Flow-based Programming for the Internet of Things. Disponível em: https://nodered.org/ DOCUMENTAÇÃO
  Relevância: Site oficial do Node-RED, com documentação e exemplos práticos para criação de fluxos IoT, amplamente usado nas seções 6 e 9.
• Grafana Labs. (s.d.). Grafana Documentation. Disponível em: https://grafana.com/docs/ DOCUMENTAÇÃO
  Relevância: Guia oficial do Grafana, detalhando configuração de dashboards e integração com InfluxDB, essencial para visualização de dados (seções 7 e 9).
• MQTT.org. (s.d.). MQTT Standard. Disponível em: https://mqtt.org/ PADRÃO
  Relevância: Portal oficial do protocolo MQTT, com especificações técnicas e histórico, útil para entender os padrões aplicados no curso.
• InfluxData. (s.d.). InfluxDB Documentation. Disponível em: https://docs.influxdata.com/influxdb/ DOCUMENTAÇÃO
  Relevância: Documentação do InfluxDB, usada para armazenar dados de séries temporais nos projetos (seções 7 e 9).
• InfluxData. (s.d.). Telegraf Documentation. Disponível em: https://docs.influxdata.com/telegraf/ DOCUMENTAÇÃO
  Relevância: Guia do Telegraf, ferramenta de coleta de dados integrada ao InfluxDB, aplicada na captura de mensagens MQTT (seção 7).
• Edge Impulse. (s.d.). Documentation and Tutorials. Disponível em: https://docs.edgeimpulse.com/ TUTORIAL
  Relevância: Tutoriais para treinamento de modelos de IA embarcada (som, imagem), usados nos desafios (seção 10) e Projetos 9.5 e 9.6.
• Eclipse Foundation. (s.d.). Mosquitto – An Open Source MQTT Broker. Disponível em: https://mosquitto.org/ DOCUMENTAÇÃO
  Relevância: Documentação do Mosquitto, broker MQTT recomendado para configurações locais (seções 8.7 e 10).
• MQTT Explorer. (s.d.). MQTT Explorer Documentation. Disponível em: https://mqtt-explorer.com/ DOCUMENTAÇÃO
  Relevância: Guia da ferramenta de depuração MQTT Explorer, usada para monitoramento de tópicos (seções 8.6 e 9).

11.2. Livros e Publicações

• Richards, M., & Monk, S. (2018). Internet das Coisas com ESP8266. 1ª ed. São Paulo: Novatec. LIVRO
  Relevância: Livro prático sobre IoT com ESP8266, abordando sensores e MQTT, útil para transição de simulações para hardware (seções 9 e 10).
• Almeida, A. D., et al. (2021). Redes de Sensores sem Fio e Internet das Coisas. 1ª ed. Rio de Janeiro: Ciência Moderna. LIVRO
  Relevância: Obra brasileira que explora redes de sensores e IoT, com exemplos aplicáveis aos projetos práticos e desafios (seções 9 e 10).
• Hanes, D., et al. (2017). IoT Fundamentals: Networking Technologies, Protocols, and Use Cases for the Internet of Things. 1ª ed. Cisco Press. LIVRO
  Relevância: Livro abrangente sobre fundamentos de IoT, incluindo MQTT, ideal para contextualizar os conceitos do módulo (seção 5).
• Schwartz, M. (2016). Internet of Things with ESP8266. 1ª ed. Packt Publishing. LIVRO
  Relevância: Guia prático para projetos IoT com ESP8266 e MQTT, complementar às seções de hardware (seções 8 e 9).

11.3. Recursos Adicionais

• OpenWeatherMap. (s.d.). Weather API. Disponível em: https://openweathermap.org/api API
  Relevância: API gratuita para integração de dados climáticos nos projetos e desafios (seções 9.4 e 10).
• Flutter. (s.d.). Flutter Documentation. Disponível em: https://flutter.dev/docs DOCUMENTAÇÃO
  Relevância: Documentação do Flutter, sugerida para o Desafio 3 (seção 10) sobre aplicativos móveis com MQTT.
• Home Assistant. (s.d.). Home Assistant Documentation. Disponível em: https://www.home-assistant.io/docs/ PLATAFORMA
  Relevância: Plataforma de automação IoT com suporte a MQTT, indicada como próximo passo (seção 10).