Estacao
Meteorologica IoT

// ═══════════════════════════════════════════════════════════
//  Estação Meteorológica IoT — Firmware HTTP/REST
//  PI3 — Eng. Telecomunicações — IFSC São José
// ═══════════════════════════════════════════════════════════

#include <WiFi.h>
#include <HTTPClient.h>
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <ArduinoJson.h>

// ── Configuração ──
const char* WIFI_SSID     = "SUA_REDE_WIFI";
const char* WIFI_PASSWORD = "SUA_SENHA_WIFI";
const char* API_URL       = "http://192.168.1.100:8000/api/v1/weather";
const char* API_KEY       = "chave-secreta-estacao-01";
const char* STATION_ID    = "ESP32_Estacao_01";

#define PIN_ANEMOMETRO  34
#define PIN_PLUVIOMETRO 35
#define INTERVALO_LEITURA 30000

Adafruit_BME280 bme;
volatile unsigned long pulsos_vento = 0;
volatile unsigned long pulsos_chuva = 0;
unsigned long ultimo_envio = 0;
unsigned long ultimo_debounce_chuva = 0;

void IRAM_ATTR isr_anemometro()  { pulsos_vento++; }
void IRAM_ATTR isr_pluviometro() {
  unsigned long agora = millis();
  if (agora - ultimo_debounce_chuva > 300) {
    pulsos_chuva++;
    ultimo_debounce_chuva = agora;
  }
}

void conectar_wifi() {
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  Serial.printf("WiFi OK! IP: %s\n", WiFi.localIP().toString().c_str());
}

// ── Envia dados via HTTP POST ──
void enviar_http(float temp, float umid, float press, float vento, float chuva) {
  HTTPClient http;
  http.begin(API_URL);
  http.addHeader("Content-Type", "application/json");
  http.addHeader("X-API-Key", API_KEY);

  JsonDocument doc;
  doc["station_id"]  = STATION_ID;
  doc["temperatura"] = temp;
  doc["umidade"]     = umid;
  doc["pressao"]     = press;
  doc["vento_kmh"]   = vento;
  doc["chuva_mm"]    = chuva;

  char payload[256];
  serializeJson(doc, payload);

  int httpCode = http.POST(payload);
  if (httpCode == 201) {
    Serial.printf("[HTTP] POST OK (201): %s\n", payload);
  } else {
    Serial.printf("[HTTP] Erro: %d — %s\n", httpCode, http.errorToString(httpCode).c_str());
  }
  http.end();
}

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  bme.begin(0x76);
  pinMode(PIN_ANEMOMETRO, INPUT);
  pinMode(PIN_PLUVIOMETRO, INPUT);
  attachInterrupt(digitalPinToInterrupt(PIN_ANEMOMETRO), isr_anemometro, FALLING);
  attachInterrupt(digitalPinToInterrupt(PIN_PLUVIOMETRO), isr_pluviometro, FALLING);
  conectar_wifi();
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) conectar_wifi();

  unsigned long agora = millis();
  if (agora - ultimo_envio >= INTERVALO_LEITURA) {
    unsigned long dt = agora - ultimo_envio;

    noInterrupts();
    unsigned long pv = pulsos_vento; pulsos_vento = 0;
    unsigned long pc = pulsos_chuva;
    interrupts();

    enviar_http(
      bme.readTemperature(),
      bme.readHumidity(),
      bme.readPressure() / 100.0,
      (dt > 0) ? (float)pv / ((float)dt/1000.0) * 2.4 : 0,
      pc * 0.2794
    );
    ultimo_envio = agora;
  }
}

// ═══════════════════════════════════════════════════════════
//  Estação Meteorológica IoT — Firmware LoRaWAN (TTN)
//  PI3 — Eng. Telecomunicações — IFSC São José
//  Usa biblioteca LMIC (MCCI LoRaWAN LMIC Library)
// ═══════════════════════════════════════════════════════════

#include <lmic.h>
#include <hal/hal.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_BME280.h>

// ── TTN OTAA Keys (substitua pelas suas!) ──
static const u1_t PROGMEM APPEUI[8]  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static const u1_t PROGMEM DEVEUI[8]  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static const u1_t PROGMEM APPKEY[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

void os_getArtEui(u1_t* buf) { memcpy_P(buf, APPEUI, 8); }
void os_getDevEui(u1_t* buf) { memcpy_P(buf, DEVEUI, 8); }
void os_getDevKey(u1_t* buf) { memcpy_P(buf, APPKEY, 16); }

// ── Pin mapping LoRa SX1276 ──
const lmic_pinmap lmic_pins = {
  .nss  = 18,
  .rxtx = LMIC_UNUSED_PIN,
  .rst  = 14,
  .dio  = {26, 33, 32},
};

Adafruit_BME280 bme;
static osjob_t sendjob;
const unsigned TX_INTERVAL = 300; // 5 minutos (LoRa = baixa frequência)

// ── Empacota payload (binário, eficiente) ──
void empacotar_payload(uint8_t* buf) {
  int16_t temp  = (int16_t)(bme.readTemperature() * 100);
  uint16_t umid = (uint16_t)(bme.readHumidity() * 100);
  uint16_t pres = (uint16_t)(bme.readPressure() / 10); // em 0.1 hPa

  buf[0] = temp >> 8;    buf[1] = temp & 0xFF;
  buf[2] = umid >> 8;    buf[3] = umid & 0xFF;
  buf[4] = pres >> 8;    buf[5] = pres & 0xFF;
  // Bytes 6-9: vento e chuva (implementar similar)
}

// ── Envia payload LoRaWAN ──
void do_send(osjob_t* j) {
  if (LMIC.opmode & OP_TXRXPEND) {
    Serial.println("[LoRa] TX pendente, ignorando");
  } else {
    uint8_t payload[10];
    empacotar_payload(payload);
    LMIC_setTxData2(1, payload, sizeof(payload), 0);
    Serial.println("[LoRa] Pacote enfileirado");
  }
}

// ── Callback de eventos LMIC ──
void onEvent(ev_t ev) {
  switch(ev) {
    case EV_JOINED:
      Serial.println("[LoRa] Join aceito!");
      LMIC_setLinkCheckMode(0);
      break;
    case EV_TXCOMPLETE:
      Serial.println("[LoRa] TX completo");
      // Agenda próximo envio
      os_setTimedCallback(&sendjob,
        os_getTime() + sec2osticks(TX_INTERVAL), do_send);
      break;
    case EV_JOIN_FAILED:
      Serial.println("[LoRa] Join falhou!");
      break;
    default:
      break;
  }
}

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  bme.begin(0x76);

  // Inicializa LMIC
  os_init();
  LMIC_reset();
  // Configura para AU915 (Brasil)
  LMIC_selectSubBand(1); // Sub-band 2 (canais 8-15 + 65)

  // Inicia join OTAA + primeiro envio
  do_send(&sendjob);
}

void loop() {
  os_runloop_once();
}

# ═══════════════════════════════════════════════════════════
#  MQTT Subscriber — Recebe dados do broker e grava no DB
# ═══════════════════════════════════════════════════════════

import json
import os
import psycopg2
from psycopg2.extras import RealDictCursor
import paho.mqtt.client as mqtt

# ── Configuração ──
MQTT_BROKER = os.getenv("MQTT_BROKER", "mosquitto")
MQTT_PORT   = int(os.getenv("MQTT_PORT", "1883"))
MQTT_TOPIC  = os.getenv("MQTT_TOPIC", "estacao/#")
DB_URL      = os.getenv("DATABASE_URL",
    "postgresql://postgres:postgres@timescaledb:5432/weather")

# ── Conexão DB ──
def get_db_conn():
    return psycopg2.connect(DB_URL)

# ── Callbacks MQTT ──
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print(f"[MQTT] Conectado ao broker {MQTT_BROKER}:{MQTT_PORT}")
        client.subscribe(MQTT_TOPIC, qos=1)
        print(f"[MQTT] Inscrito em: {MQTT_TOPIC}")
    else:
        print(f"[MQTT] Falha na conexão, rc={rc}")

def on_message(client, userdata, msg):
    try:
        payload = json.loads(msg.payload.decode())
        print(f"[MQTT] {msg.topic}: {payload}")

        # Filtra só mensagens de sensores
        if "sensores" not in msg.topic:
            return

        conn = get_db_conn()
        with conn.cursor() as cur:
            cur.execute("""
                INSERT INTO weather_data
                    (time, station_id, temperatura, umidade,
                     pressao, vento_kmh, chuva_mm)
                VALUES (NOW(), %s, %s, %s, %s, %s, %s)
            """, (
                payload.get("station_id", "unknown"),
                payload.get("temperatura"),
                payload.get("umidade"),
                payload.get("pressao"),
                payload.get("vento_kmh", 0),
                payload.get("chuva_mm", 0),
            ))
            conn.commit()
        conn.close()
        print("[DB] Dados inseridos com sucesso")

    except Exception as e:
        print(f"[ERRO] {e}")

# ── Main ──
if __name__ == "__main__":
    client = mqtt.Client(client_id="weather-subscriber")
    client.username_pw_set("estacao", "senha_mqtt")
    client.on_connect = on_connect
    client.on_message = on_message

    print("[MQTT] Iniciando subscriber...")
    client.connect(MQTT_BROKER, MQTT_PORT, keepalive=60)
    client.loop_forever()

-- ═══════════════════════════════════════════════════════════
--  Inicialização TimescaleDB — Estação Meteorológica IoT
-- ═══════════════════════════════════════════════════════════

-- Habilita extensão TimescaleDB
CREATE EXTENSION IF NOT EXISTS timescaledb;

-- Tabela principal de dados meteorológicos
CREATE TABLE IF NOT EXISTS weather_data (
    time          TIMESTAMPTZ    NOT NULL,
    station_id    TEXT           NOT NULL,
    temperatura   DOUBLE PRECISION,
    umidade       DOUBLE PRECISION,
    pressao       DOUBLE PRECISION,
    vento_kmh     DOUBLE PRECISION DEFAULT 0,
    chuva_mm      DOUBLE PRECISION DEFAULT 0
);

-- Converte para hypertable (particionamento temporal automático)
SELECT create_hypertable(
    'weather_data',
    'time',
    if_not_exists => TRUE
);

-- Índice para consultas por estação
CREATE INDEX IF NOT EXISTS idx_station_time
    ON weather_data (station_id, time DESC);

-- ── Continuous Aggregate: média horária ──
CREATE MATERIALIZED VIEW IF NOT EXISTS weather_hourly
WITH (timescaledb.continuous) AS
SELECT
    time_bucket('1 hour', time) AS bucket,
    station_id,
    AVG(temperatura)  AS avg_temp,
    MIN(temperatura)  AS min_temp,
    MAX(temperatura)  AS max_temp,
    AVG(umidade)      AS avg_umid,
    AVG(pressao)      AS avg_press,
    MAX(vento_kmh)    AS max_vento,
    SUM(chuva_mm)     AS total_chuva,
    COUNT(*)          AS amostras
FROM weather_data
GROUP BY bucket, station_id
WITH NO DATA;

-- Política de refresh automático
SELECT add_continuous_aggregate_policy('weather_hourly',
    start_offset  => INTERVAL '3 hours',
    end_offset    => INTERVAL '1 hour',
    schedule_interval => INTERVAL '1 hour',
    if_not_exists => TRUE
);

-- Política de retenção: remove dados brutos após 90 dias
SELECT add_retention_policy('weather_data',
    INTERVAL '90 days',
    if_not_exists => TRUE
);

-- Insere dados de exemplo para teste
INSERT INTO weather_data (time, station_id, temperatura, umidade, pressao, vento_kmh, chuva_mm)
VALUES
    (NOW() - INTERVAL '2 hours', 'ESP32_Estacao_01', 24.5, 68.2, 1013.25, 12.3, 0.0),
    (NOW() - INTERVAL '1 hour',  'ESP32_Estacao_01', 23.8, 71.5, 1012.80, 15.7, 0.28),
    (NOW(),                       'ESP32_Estacao_01', 22.1, 78.3, 1011.50, 8.9,  1.12);

# ═══════════════════════════════════════════════════════════
#  Modelos Pydantic — Validação de dados
# ═══════════════════════════════════════════════════════════

from pydantic import BaseModel, Field
from datetime import datetime
from typing import Optional

class WeatherData(BaseModel):
    """Payload recebido do ESP32"""
    station_id:  str   = Field(..., example="ESP32_Estacao_01")
    temperatura: float = Field(..., ge=-50, le=60,  description="°C")
    umidade:     float = Field(..., ge=0,   le=100, description="%RH")
    pressao:     float = Field(..., ge=300, le=1100, description="hPa")
    vento_kmh:   float = Field(0,   ge=0,   le=300, description="km/h")
    chuva_mm:    float = Field(0,   ge=0,              description="mm")

class WeatherResponse(BaseModel):
    """Resposta da API"""
    time:        datetime
    station_id:  str
    temperatura: float
    umidade:     float
    pressao:     float
    vento_kmh:   float
    chuva_mm:    float