1. Simulação Básica de Sensor IoT (Arduino/ESP32)
// Simulação simples de sensor de temperatura/umidade
#include <DHT.h>
#define DHTPIN 4
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(115200);
dht.begin();
Serial.println("Sensor IoT iniciado - Simulando coleta de dados");
}
void loop() {
// Leitura dos sensores
float temperatura = dht.readTemperature();
float umidade = dht.readHumidity();
// Verificação de leitura válida
if (isnan(temperatura) || isnan(umidade)) {
Serial.println("Erro na leitura do sensor!");
return;
}
// Exibição dos dados
Serial.print("Temperatura: ");
Serial.print(temperatura);
Serial.print("°C | Umidade: ");
Serial.print(umidade);
Serial.println("%");
// Simulação do fluxo IoT: Sensor → Processamento → "Transmissão"
Serial.println("--- Fluxo IoT ---");
Serial.println("1. Dados coletados do sensor físico");
Serial.println("2. Processamento local (validação, formatação)");
Serial.println("3. Preparação para transmissão LoRaWAN");
Serial.println("4. Aguardando próxima leitura...");
Serial.println();
delay(5000); // 5 segundos entre leituras
}
2. Demonstração de Comunicação Básica LoRa (ESP32 + Módulo LoRa)
#include <SPI.h>
#include <LoRa.h>
// Pinos para ESP32
#define SS 18
#define RST 14
#define DIO0 26
void setup() {
Serial.begin(115200);
// Inicialização do módulo LoRa
LoRa.setPins(SS, RST, DIO0);
if (!LoRa.begin(915E6)) { // Frequência Brasil (915 MHz)
Serial.println("Erro ao iniciar LoRa!");
while (1);
}
Serial.println("Módulo LoRa iniciado com sucesso!");
Serial.println("Frequência: 915 MHz (AU915_0 - Brasil)");
Serial.println("Pronto para demonstrar comunicação básica");
}
void loop() {
// Simulação de envio de dados
Serial.println("Enviando pacote de dados...");
LoRa.beginPacket();
LoRa.print("Olá LoRaWAN! Pacote de teste #");
LoRa.print(millis() / 1000);
LoRa.endPacket();
Serial.println("Pacote enviado!");
// Verificação de pacotes recebidos
int packetSize = LoRa.parsePacket();
if (packetSize) {
Serial.println("Pacote recebido!");
while (LoRa.available()) {
Serial.print((char)LoRa.read());
}
Serial.print("' com RSSI ");
Serial.println(LoRa.packetRssi());
}
delay(10000); // 10 segundos entre transmissões
}
3. Simulação de Arquitetura IoT Básica (Python)
import time
import random
import json
class IoTSimulator:
def __init__(self):
self.devices = []
self.gateways = []
self.data_buffer = []
def add_device(self, device_id, device_type):
"""Adiciona um dispositivo IoT simulado"""
device = {
'id': device_id,
'type': device_type,
'status': 'active',
'last_reading': None
}
self.devices.append(device)
print(f"Dispositivo {device_id} ({device_type}) adicionado")
def add_gateway(self, gateway_id, location):
"""Adiciona um gateway LoRaWAN simulado"""
gateway = {
'id': gateway_id,
'location': location,
'connected_devices': 0,
'status': 'online'
}
self.gateways.append(gateway)
print(f"Gateway {gateway_id} em {location} adicionado")
def simulate_sensor_reading(self, device_id):
"""Simula leitura de sensor"""
device = next((d for d in self.devices if d['id'] == device_id), None)
if not device:
return None
if device['type'] == 'temperature':
reading = round(random.uniform(20, 35), 1)
unit = '°C'
elif device['type'] == 'humidity':
reading = round(random.uniform(30, 80), 1)
unit = '%'
elif device['type'] == 'soil_moisture':
reading = round(random.uniform(10, 90), 1)
unit = '%'
else:
reading = random.randint(0, 100)
unit = 'units'
timestamp = time.time()
data_point = {
'device_id': device_id,
'timestamp': timestamp,
'value': reading,
'unit': unit,
'device_type': device['type']
}
device['last_reading'] = data_point
return data_point
def transmit_to_gateway(self, device_id):
"""Simula transmissão de dados para gateway"""
data = self.simulate_sensor_reading(device_id)
if not data:
return False
# Simular transmissão LoRaWAN
print("
--- Transmissão LoRaWAN ---" print(f"Dispositivo: {data['device_id']}")
print(f"Dados: {data['value']} {data['unit']}")
print("Protocolo: LoRaWAN Classe A"
print("Frequência: 915 MHz (AU915_0)"
print("Status: Transmitido com sucesso"
# Adicionar ao buffer de dados
self.data_buffer.append(data)
return True
def process_gateway_data(self, gateway_id):
"""Simula processamento de dados no gateway"""
gateway = next((g for g in self.gateways if g['id'] == gateway_id), None)
if not gateway:
return False
if self.data_buffer:
data = self.data_buffer.pop(0)
print("
--- Processamento no Gateway ---" print(f"Gateway: {gateway_id} ({gateway['location']})")
print(f"Processando dados de: {data['device_id']}")
print("Dados enviados para Network Server"
gateway['connected_devices'] = len([d for d in self.devices if d['status'] == 'active'])
return True
return False
def display_system_status(self):
"""Exibe status do sistema IoT"""
print("\n=== STATUS DO SISTEMA IoT ===")
print(f"Dispositivos ativos: {len([d for d in self.devices if d['status'] == 'active'])}")
print(f"Gateways online: {len([g for g in self.gateways if g['status'] == 'online'])}")
print(f"Dados no buffer: {len(self.data_buffer)}")
print("\n--- Dispositivos ---")
for device in self.devices:
status = "✓" if device['status'] == 'active' else "✗"
print(f"{status} {device['id']} ({device['type']})")
print("\n--- Gateways ---")
for gateway in self.gateways:
status = "✓" if gateway['status'] == 'online' else "✗"
print(f"{status} {gateway['id']} - {gateway['location']} (Dispositivos: {gateway['connected_devices']})")
# Demonstração do simulador
def main():
iot = IoTSimulator()
# Adicionar dispositivos e gateways
iot.add_device("TEMP_001", "temperature")
iot.add_device("HUM_001", "humidity")
iot.add_device("SOIL_001", "soil_moisture")
iot.add_gateway("GW_BRASILIA", "Brasília-DF")
iot.add_gateway("GW_SAO_PAULO", "São Paulo-SP")
# Simular operações IoT
print("\n=== INICIANDO SIMULAÇÃO IoT ===")
for i in range(5):
print(f"\n--- Ciclo {i+1} ---")
# Simular transmissões
for device in iot.devices:
iot.transmit_to_gateway(device['id'])
time.sleep(0.5)
# Processar dados nos gateways
for gateway in iot.gateways:
iot.process_gateway_data(gateway['id'])
iot.display_system_status()
time.sleep(2)
if __name__ == "__main__":
main()
4. Link Budget Calculator (Python)
import math
class LoRaLinkBudgetCalculator:
def __init__(self):
# Constantes LoRa
self.c = 299792458 # Velocidade da luz (m/s)
def calculate_fspl(self, distance_km, frequency_mhz):
"""Calcula Free Space Path Loss"""
# FSPL = 20log(d) + 20log(f) + 32.44
fspl = 20 * math.log10(distance_km) + 20 * math.log10(frequency_mhz) + 32.44
return round(fspl, 2)
def get_receiver_sensitivity(self, sf, bw_khz):
"""Retorna sensibilidade do receptor baseada em SF e BW"""
# Valores típicos para LoRa
sensitivities = {
(7, 125): -124,
(8, 125): -127,
(9, 125): -130,
(10, 125): -133,
(11, 125): -135,
(12, 125): -137,
(8, 500): -122,
(9, 500): -126,
(10, 500): -129,
(11, 500): -133,
(12, 500): -137
}
return sensitivities.get((sf, bw_khz), -130) # Default
def calculate_link_budget(self, tx_power_dbm, tx_antenna_gain_dbi,
rx_antenna_gain_dbi, cable_losses_db,
distance_km, frequency_mhz, sf, bw_khz,
additional_losses_db=0):
"""
Calcula o link budget completo
Retorna: (potência_recebida, margem_link, sucesso_comunicacao)
"""
# 1. Potência efetiva de transmissão (EIRP)
eirp = tx_power_dbm + tx_antenna_gain_dbi
# 2. Free Space Path Loss
fspl = self.calculate_fspl(distance_km, frequency_mhz)
# 3. Potência recebida
received_power = eirp - fspl - cable_losses_db - additional_losses_db + rx_antenna_gain_dbi
# 4. Sensibilidade do receptor
sensitivity = self.get_receiver_sensitivity(sf, bw_khz)
# 5. Margem de link
link_margin = received_power - sensitivity
# 6. Avaliação de sucesso
success = link_margin > 0
return round(received_power, 2), round(link_margin, 2), success
# Exemplo de uso
def exemplo_link_budget():
calculator = LoRaLinkBudgetCalculator()
# Cenário: Sensor agrícola a 5km de distância
config = {
'tx_power_dbm': 20, # 100mW
'tx_antenna_gain_dbi': 2, # Antena pequena
'rx_antenna_gain_dbi': 5, # Antena gateway
'cable_losses_db': 2, # Cabos e conectores
'distance_km': 5, # 5km de distância
'frequency_mhz': 915, # AU915
'sf': 10, # SF10 para bom equilíbrio
'bw_khz': 125, # BW padrão
'additional_losses_db': 10 # Obstáculos (árvores, etc.)
}
received_power, link_margin, success = calculator.calculate_link_budget(**config)
print("=== CÁLCULO DE LINK BUDGET ===")
print(f"Distância: {config['distance_km']} km")
print(f"Frequência: {config['frequency_mhz']} MHz")
print(f"SF: {config['sf']}, BW: {config['bw_khz']} kHz")
print(f"FSPL: {calculator.calculate_fspl(config['distance_km'], config['frequency_mhz'])} dB")
print(f"Potência recebida: {received_power} dBm")
print(f"Sensibilidade receptor: {calculator.get_receiver_sensitivity(config['sf'], config['bw_khz'])} dBm")
print(f"Margem de link: {link_margin} dB")
print(f"Comunicação: {'POSSÍVEL' if success else 'NÃO POSSÍVEL'}")
return success
exemplo_link_budget()
5. Comparação Visual de Tecnologias LPWAN (Python com Matplotlib)
import matplotlib.pyplot as plt
import numpy as np
# Dados para comparação de tecnologias LPWAN
tecnologias = ['LoRaWAN', 'Sigfox', 'NB-IoT', 'Wi-Fi HaLow']
alcance = [10, 10, 10, 0.5] # km
consumo = [5, 5, 3, 2] # escala 1-5 (5 = menor consumo)
custo = [3, 4, 2, 3] # escala 1-5 (1 = menor custo)
taxa_dados = [0.05, 0.001, 0.1, 50] # kbps
# Criar gráfico de radar
fig, ax = plt.subplots(figsize=(10, 8), subplot_kw=dict(projection='polar'))
# Ângulos para cada categoria
categorias = ['Alcance (km)', 'Consumo de Energia', 'Custo', 'Taxa de Dados (kbps)']
angulos = np.linspace(0, 2 * np.pi, len(categorias), endpoint=False).tolist()
angulos += angulos[:1] # Fechar o círculo
# Plotar cada tecnologia
cores = ['blue', 'red', 'green', 'orange']
for i, (tech, cor) in enumerate(zip(tecnologias, cores)):
valores = [alcance[i], consumo[i], custo[i], taxa_dados[i]]
valores += valores[:1] # Fechar o círculo
ax.plot(angulos, valores, 'o-', linewidth=2, label=tech, color=cor)
ax.fill(angulos, valores, alpha=0.25, color=cor)
# Configurar gráfico
ax.set_xticks(angulos[:-1])
ax.set_xticklabels(categorias)
ax.set_ylim(0, 55)
ax.set_title('Comparação de Tecnologias LPWAN\nLoRaWAN vs Concorrentes', size=16, fontweight='bold', pad=20)
ax.legend(loc='upper right', bbox_to_anchor=(1.2, 1.0))
ax.grid(True)
# Adicionar anotações
ax.annotate('Melhor para IoT\nremoto', xy=(0, 10), xytext=(0.5, 12),
arrowprops=dict(facecolor='blue', shrink=0.05))
ax.annotate('Melhor para\ndados simples', xy=(np.pi/2, 5), xytext=(2, 7),
arrowprops=dict(facecolor='red', shrink=0.05))
plt.tight_layout()
plt.show()
print("\n=== ANÁLISE COMPARATIVA ===")
print("LoRaWAN se destaca em:")
print("✓ Maior alcance (até 10+ km)")
print("✓ Menor consumo de energia")
print("✓ Melhor custo-benefício para aplicações IoT")
print("✓ Adequado para Brasil (região AU915_0)")
print("\nConcorrentes:")
print("• Sigfox: Simplicidade, mas limitado a dados muito simples")
print("• NB-IoT: Boa integração celular, mas menor alcance")
print("• Wi-Fi HaLow: Alta velocidade, mas curto alcance")
Comentários