Python para IoT: Coletando e Processando Dados de Sensores

A Internet das Coisas (IoT) conecta dispositivos, sensores e sistemas para coletar dados do mundo físico e transformá-los em informações úteis. Python se tornou uma linguagem popular para desenvolver aplicações IoT, devido à sua simplicidade, vasta biblioteca e compatibilidade com microcontroladores, computadores embarcados e sistemas de análise de dados.

Neste post, vamos explorar como coletar, processar e analisar dados de sensores usando Python, com exemplos práticos para projetos reais.

---

1. Por que usar Python em projetos IoT?

Python oferece vantagens claras para IoT:

• Compatível com plataformas populares: Raspberry Pi, MicroPython em ESP32, BeagleBone, entre outros.

• Bibliotecas robustas para sensores e comunicação: leitura de GPIO, I2C, SPI, MQTT, HTTP, BLE.

• Facilidade de prototipagem: scripts rápidos para coleta de dados e testes de sensores.

• Integração com análise de dados: Pandas, NumPy, Matplotlib, SciPy, TensorFlow para processamento avançado.

Python é ideal para criar provas de conceito rapidamente, que depois podem ser otimizadas ou integradas a sistemas de produção.

---

2. Arquitetura típica de um projeto IoT com Python

Um sistema IoT completo geralmente segue esta arquitetura:

1. Dispositivos sensores (Edge)

   • Arduino, ESP32, Raspberry Pi, sensores de temperatura, umidade, pressão, luz, etc.

   • Python roda no dispositivo (Raspberry Pi) ou microcontrolador com MicroPython.

2. Gateway / Coletor de dados

   • Raspberry Pi ou servidor local que recebe dados de sensores.

   • Pode aplicar pré-processamento: filtragem, agregação ou compressão.

3. Transmissão e protocolo

   • MQTT, HTTP, CoAP, WebSocket ou TCP/UDP.

   • Segurança: TLS/SSL, autenticação de dispositivo.

4. Armazenamento e análise

   • Banco de dados: InfluxDB, SQLite, PostgreSQL, MongoDB.

   • Processamento: Python com Pandas, NumPy ou frameworks de machine learning.

5. Visualização / Dashboard

   • Grafana, Plotly Dash, Streamlit, web apps personalizados.

---

3. Coletando dados de sensores com Python

3.1 Sensores conectados a Raspberry Pi

GPIO e sensores digitais/analógicos:

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.IN)  # sensor digital no pino 18

try:
    while True:
        sensor_estado = GPIO.input(18)
        print("Sensor acionado!" if sensor_estado else "Sensor desligado")
        time.sleep(1)
except KeyboardInterrupt:
    GPIO.cleanup()

Observações:

• Para sensores analógicos, use ADCs externos como MCP3008.

• Bibliotecas populares: Adafruit_GPIO, RPi.GPIO, gpiozero.

---

3.2 Sensores via I2C e SPI

Exemplo: leitura de sensor de temperatura BMP280 via I2C:

import board
import busio
import adafruit_bmp280

i2c = busio.I2C(board.SCL, board.SDA)
bmp280 = adafruit_bmp280.Adafruit_BMP280_I2C(i2c)

print("Temperatura: {:.2f} C".format(bmp280.temperature))
print("Pressão: {:.2f} hPa".format(bmp280.pressure))

Dicas:

• Sempre verifique endereço I2C com i2cdetect -y 1.

• Bibliotecas Adafruit são amplamente compatíveis com sensores populares.

---

4. Transmissão de dados

4.1 MQTT

MQTT é o protocolo mais usado para IoT, leve e confiável.

import paho.mqtt.client as mqtt

broker = "broker.emqx.io"
topic = "sensor/temperatura"

def on_connect(client, userdata, flags, rc):
    print("Conectado com código:", rc)

client = mqtt.Client()
client.on_connect = on_connect
client.connect(broker, 1883, 60)
client.loop_start()

# Enviando dados do sensor
temperature = 24.5
client.publish(topic, temperature)

Vantagens do MQTT: QoS configurável, retenção de mensagens, suporte a múltiplos clientes simultâneos.

---

4.2 HTTP / REST

Para sistemas simples ou integração com dashboards web:

import requests

data = {"temperature": 24.5, "humidity": 60}
response = requests.post("http://meuservidor:5000/sensor", json=data)
print(response.status_code)

Dica: use HTTPS para produção e autenticação básica/token.

---

5. Armazenamento de dados

5.1 Banco de dados SQL

• SQLite: leve, fácil de usar em Raspberry Pi.

• PostgreSQL: ideal para múltiplos dispositivos e histórico maior.

import sqlite3

conn = sqlite3.connect("sensores.db")
cursor = conn.cursor()
cursor.execute("""CREATE TABLE IF NOT EXISTS temperatura(
                    id INTEGER PRIMARY KEY,
                    valor REAL,
                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP)""")
cursor.execute("INSERT INTO temperatura(valor) VALUES(?)", (24.5,))
conn.commit()
conn.close()

5.2 Banco de dados Time Series

• InfluxDB: otimizado para séries temporais, consultas rápidas por intervalo de tempo.

• Python: influxdb-client para enviar e consultar dados.

---

6. Processamento e análise de dados

Python permite processamento em tempo real ou batch:

6.1 Pré-processamento

• Filtragem de ruído: médias móveis, median filters (scipy.signal).

• Transformações: normalização, padronização, detecção de outliers.

import pandas as pd

df = pd.read_csv("dados_sensores.csv")
df["media_movel"] = df["temperatura"].rolling(window=5).mean()
print(df.head())

6.2 Machine Learning / Anomaly Detection

• Detectar falhas ou padrões: regressão, clustering, redes neurais simples.

• Bibliotecas: scikit-learn, TensorFlow, PyTorch.

Exemplo simples de detecção de anomalias:

from sklearn.ensemble import IsolationForest
import pandas as pd

df = pd.read_csv("dados_sensores.csv")
model = IsolationForest(contamination=0.05)
df['anomalia'] = model.fit_predict(df[['temperatura']])
print(df[df['anomalia']==-1])  # valores anômalos

---

7. Visualização e dashboards

• Matplotlib / Seaborn: gráficos estáticos.

• Plotly Dash / Streamlit: dashboards interativos.

• Grafana: integração com InfluxDB ou Prometheus para visualização de dados em tempo real.

Exemplo simples com Matplotlib:

import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv("dados_sensores.csv")
plt.plot(df["timestamp"], df["temperatura"])
plt.xlabel("Tempo")
plt.ylabel("Temperatura (C)")
plt.title("Dados do sensor")
plt.show()

---

8. Boas práticas em Python para IoT

1. Evite loops infinitos sem sleep: economiza CPU e energia.

2. Trate exceções de comunicação: sensores podem falhar ou desconectar.

3. Use logging e persistência: registre dados críticos e falhas.

4. Segurança: criptografe dados sensíveis, use TLS e autenticação.

5. Gerencie memória: dispositivos embarcados têm recursos limitados.

6. Atualizações OTA (Over-The-Air): implemente forma segura de atualizar scripts Python nos dispositivos.

---

9. Projeto de exemplo completo

Cenário: Raspberry Pi coleta dados de temperatura e envia via MQTT para servidor Python que grava no InfluxDB e exibe dashboard em Grafana.

Estrutura sugerida:

iot_project/
├── sensors/             # scripts de leitura (Raspberry Pi)
│   └── bmp280_reader.py
├── backend/             # servidor Python MQTT -> InfluxDB
│   ├── main.py
│   ├── requirements.txt
│   └── Dockerfile
├── dashboards/          # Grafana dashboards JSON
└── docs/

Fluxo:

1. Sensor lê dados e publica no broker MQTT.

2. Servidor Python consome mensagens, valida e grava no banco.

3. Grafana se conecta ao InfluxDB e exibe visualizações em tempo real.

---

10. Conclusão

Python é uma linguagem extremamente eficiente para IoT, permitindo coletar, processar e analisar dados de sensores de forma rápida e flexível. Com bibliotecas adequadas, protocolos confiáveis e boas práticas de segurança, é possível criar sistemas IoT robustos, escaláveis e interativos.

Dicas finais:

• Comece com protótipos simples (Raspberry Pi + sensor).

• Use MQTT para comunicação confiável entre dispositivos.

• Integre visualização e análise com dashboards interativos.

• Sempre considere segurança e eficiência em dispositivos limitados.