Experiência 6: Monitorização Remota Avançada (IoMT)

Experiência 6: Monitorização Remota Avançada com IoMT

Objetivo

Implementar um sistema completo de Internet of Medical Things (IoMT) para monitorização remota de pacientes em tempo real. A experiência integra as competências das fases anteriores para construir uma pipeline segura, escalável e robusta, desde o sensor até ao dashboard clínico, abordando desafios de segurança, latência e fiabilidade.

Objetivos de Aprendizagem

Implementar uma arquitetura completa de IoMT
Desenvolver sistemas de telemonitorização seguros e eficientes
Avaliar e mitigar riscos de segurança em dispositivos médicos conectados
Otimizar protocolos de comunicação para baixa latência e baixo consumo
Integrar dados de múltiplos sensores em tempo real
Garantir a conformidade com regulamentações (GDPR, HIPAA)

Resultados de Aprendizagem

Ao completar esta experiência, os estudantes serão capazes de:

Configurar dispositivos ESP32 para transmissão segura (TLS/SSL)
Implementar comunicação MQTT com autenticação e encriptação
Integrar dados de IoMT com a pipeline de saúde completa
Desenvolver workflows de processamento em tempo real com Node-RED
Avaliar performance e fiabilidade do sistema end-to-end
Implementar mecanismos de segurança e privacidade

Exercício Prático Detalhado

Fase 1: Configuração Segura do Dispositivo (45 min)

Firmware ESP32 com segurança avançada:

#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include "secrets.h" // Ficheiro com credenciais

// Configuração Wi-Fi e MQTT
const char* ssid = WIFI_SSID;
const char* password = WIFI_PASSWORD;
const char* mqtt_server = MQTT_SERVER_IP;
const int mqtt_port = 8883; // Porta segura

// Certificados para TLS
const char* root_ca = \
"-----BEGIN CERTIFICATE-----\n" \
"MIID... (Root CA Certificate) ...\n" \
"-----END CERTIFICATE-----\n";

WiFiClientSecure espClient;
PubSubClient client(espClient);

void setup_wifi() {
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connected");
}

void setup_mqtt() {
  espClient.setCACert(root_ca);
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback); // Função para receber mensagens
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    if (client.connect("ESP32Client-secure", MQTT_USER, MQTT_PASSWORD)) {
      Serial.println("connected");
      client.subscribe("patient/+/commands");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(5000);
    }
  }
}

void publish_sensor_data() {
  // Recolher dados dos sensores (Experiência 1)
  float temperature = readTemperature();
  int heart_rate = readHeartRate();

  // Criar JSON payload
  StaticJsonDocument<200> doc;
  doc["deviceId"] = "ESP32_ICU_01";
  doc["timestamp"] = millis();

  JsonObject vitals = doc.createNestedObject("vitals");
  vitals["temperature"] = temperature;
  vitals["heartRate"] = heart_rate;

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

  // Publicar no tópico MQTT
  client.publish("patient/PAT001/vitals", buffer);
}

void setup() {
  Serial.begin(115200);
  setup_wifi();
  setup_mqtt();
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  publish_sensor_data();
  delay(5000); // Publicar a cada 5 segundos
}

Fase 2: Broker MQTT Seguro e Node-RED (60 min)

Configuração Mosquitto com TLS e autenticação:

# mosquitto.conf
listener 8883
cafile /etc/mosquitto/certs/ca.crt
certfile /etc/mosquitto/certs/server.crt
keyfile /etc/mosquitto/certs/server.key
require_certificate false
tls_version tlsv1.2

allow_anonymous false
password_file /etc/mosquitto/passwd

Workflow Node-RED para processamento em tempo real:

[
    {
        "id": "flow1",
        "type": "tab",
        "label": "IoMT Pipeline"
    },
    {
        "id": "mqtt_in",
        "type": "mqtt in",
        "name": "Vitals from ESP32",
        "topic": "patient/+/vitals",
        "broker": "mqtt_broker",
        "x": 150,
        "y": 100,
        "wires": [["json_parser"]]
    },
    {
        "id": "json_parser",
        "type": "json",
        "name": "Parse JSON",
        "x": 350,
        "y": 100,
        "wires": [["process_vitals"]]
    },
    {
        "id": "process_vitals",
        "type": "function",
        "name": "Process and Enrich",
        "func": "
// Extrair dados
var deviceId = msg.payload.deviceId;
var patientId = msg.topic.split('/')[1];
var vitals = msg.payload.vitals;

// Enriquecer com metadados
msg.payload.patientId = patientId;
msg.payload.received_at = new Date().toISOString();

// Aplicar regras de negócio (Experiência 5)
if (vitals.heartRate > 120) {
    msg.payload.alert = 'critical';
} else {
    msg.payload.alert = 'normal';
}

return msg;
        ",
        "x": 550,
        "y": 100,
        "wires": [["fhir_converter", "dashboard_out"]]
    },
    {
        "id": "fhir_converter",
        "type": "function",
        "name": "Convert to FHIR",
        "func": "
// Converter para FHIR Observation (Experiência 4)
var obs = {
    resourceType: 'Observation',
    status: 'final',
    code: { coding: [{ system: 'http://loinc.org', code: '8867-4' }] },
    subject: { reference: 'Patient/' + msg.payload.patientId },
    valueQuantity: {
        value: msg.payload.vitals.heartRate,
        unit: 'bpm'
    }
};
msg.payload = obs;
return msg;
        ",
        "x": 750,
        "y": 100,
        "wires": [["fhir_server_out"]]
    },
    {
        "id": "fhir_server_out",
        "type": "http request",
        "name": "Send to HL7 FHIR Server",
        "method": "POST",
        "url": "http://hapi-fhir:8080/fhir/Observation",
        "x": 950,
        "y": 100,
        "wires": [[]]
    },
    {
        "id": "dashboard_out",
        "type": "websocket out",
        "name": "Update Dashboard",
        "path": "/ws/vitals",
        "x": 750,
        "y": 200,
        "wires": [[]]
    }
]

Fase 3: Integração com a Pipeline Completa (45 min)

Simulação de workflow end-to-end:

Dispositivo ESP32 recolhe dados e publica via MQTT/TLS.
Mosquitto broker recebe e autentica a mensagem.
Node-RED subscreve, processa, enriquece e aplica regras.
Dados processados são enviados para:
- Servidor FHIR (HAPI) como Observation.
- Dashboard Grafana via WebSocket para visualização em tempo real.
- Sistema de Alertas (Experiência 5) se forem detetados valores críticos.
Mirth Connect (Experiência 4) deteta novo recurso FHIR e o traduz para HL7v2 para sistemas legacy.

Fase 4: Análise de Segurança e Performance (30 min)

Checklist de segurança IoMT:

Comunicação Encriptada: TLS v1.2/1.3 para MQTT e HTTP.
Autenticação Forte: Certificados de cliente ou tokens JWT.
Firmware Seguro: Assinatura de firmware, updates OTA seguros.
Gestão de Dispositivos: Provisionamento, revogação de certificados.
Segregação de Rede: Isolar dispositivos IoMT em VLANs.
Minimização de Dados: Enviar apenas os dados estritamente necessários.

Testes de performance:

Latência end-to-end: Medir tempo desde a aquisição no sensor até à visualização no dashboard.
Throughput: Quantas mensagens por segundo o sistema suporta.
Consumo de bateria: Otimizar firmware para maior autonomia.

Recursos Necessários

Hardware

ESP32 DevKitC com múltiplos sensores (ECG, PPG, Temp).
Gateway/Router com suporte para VLANs.
Servidor para hospedar Mosquitto, Node-RED, etc. (pode ser o mesmo da Exp. 4).

Software

Mosquitto MQTT Broker.
Node-RED.
OpenSSL para geração de certificados.
Ferramentas de teste: mqtt-cli, wrk (testes de carga).

Metodologias de Ensino

Sessão Prática (180 min)

Segurança no dispositivo (60 min): Configurar TLS e MQTT seguro no ESP32.
Configuração do Broker e Node-RED (60 min): Instalar, proteger e criar o workflow.
Testes de integração (60 min): Validar a pipeline completa e analisar performance.

Avaliação

Critérios de Avaliação

Implementação de segurança (30 pts): TLS, autenticação, firmware.
Workflow de integração (30 pts): Funcionalidade e robustez da pipeline.
Análise de performance e segurança (20 pts): Testes e relatório.
Documentação (20 pts): Arquitetura, configurações, procedimentos.

Entregáveis

Código fonte do firmware seguro para ESP32.
Configurações do Mosquitto e export do flow Node-RED.
Relatório de análise de segurança e performance.
Diagrama de arquitetura da solução IoMT completa.

Extensões Avançadas

Edge Computing

Processamento de sinais e deteção de anomalias no próprio ESP32.
Implementar modelos de Machine Learning com TensorFlow Lite for Microcontrollers.

Gestão de Dispositivos

Implementar um sistema de Over-The-Air (OTA) updates para o firmware.
Criar um dashboard para gestão de frota de dispositivos IoMT.

Integração Final da Pipeline

Esta experiência consolida todo o conhecimento adquirido:

Exp 1 (Recolha): O ESP32 recolhe os dados.
Exp 2 (Processamento): Algoritmos podem ser movidos para o Edge (ESP32) ou para o Node-RED.
Exp 3 (Armazenamento): Os dados acabam no RedCap/FHIR.
Exp 4 (Interoperabilidade): O Node-RED comunica com o servidor FHIR e Mirth.
Exp 5 (Análise): O dashboard é alimentado em tempo real pelos dados do IoMT.