Conector IoT

El Conector IoT de Savitri permite a dispositivos del Internet de las Cosas enviar datos de sensores en cadena. Proporciona gestión de dispositivos, ingesta de datos, procesamiento en el borde, optimización por lotes y seguridad de nivel empresarial.

Arquitectura

IoT Devices (sensors, actuators, gateways)
    │
    ▼
Protocol Handlers (MQTT, CoAP)
    │ parse, validate, authenticate
    ▼
Edge Processing Engine
    │ rules engine, anomaly detection, aggregation
    ▼
Batch Processor
    │ compress, aggregate, schedule
    ▼
Blockchain Interface (savitri_sendRawTransaction)
    │ submit batch as IoT TX (0.00005 SAVT fee)
    ▼
On-chain Oracle Feed

Gestión de Dispositivos

Tipos de Dispositivos

Tipo	Descripción	Ejemplo
Sensor	Productor de datos de solo lectura	Sensor de temperatura
Actuator	Dispositivo controlable	Válvula inteligente
Gateway	Punto de agregación en el borde	Hub Raspberry Pi
EdgeNode	Unidad de procesamiento local	Servidor ML en el borde
Mobile	Dispositivo móvil	Smartphone
Industrial	Equipo industrial	PLC/SCADA

Registro de Dispositivos

pub struct Device {
    pub id: DeviceId,
    pub owner: [u8; 32],          // owner address
    pub public_key: [u8; 32],     // device signing key
    pub device_type: DeviceType,
    pub capabilities: Vec<String>,
    pub status: DeviceStatus,
    pub metadata: HashMap<String, String>,
}

Los dispositivos se registran en cadena con su clave pública para autenticación. Los grupos de dispositivos pueden gestionarse de forma colectiva.

Estado de Dispositivos

Estado	Descripción
Active	Operación normal
Inactive	Temporalmente fuera de línea
Suspended	Suspendido por el propietario/gobernanza
Banned	Revocado permanentemente

Ingesta de Datos

Soporte de Protocolos

Protocolo	Manejador	Caso de Uso
MQTT	MQTTHandler	Sensores de bajo consumo, pub/sub
CoAP	CoAPHandler	Dispositivos restringidos, UDP

Ambos implementan el trait ProtocolHandler:

pub trait ProtocolHandler: Send + Sync {
    async fn handle_connection(&self, stream: TcpStream) -> Result<()>;
    fn parse_data(&self, raw: &[u8]) -> Result<IoTData>;
    fn validate_device(&self, device_id: &str, signature: &[u8]) -> Result<bool>;
}

Formato de Datos IoT

pub struct IoTData {
    pub device_id: String,
    pub timestamp: u64,
    pub data_type: String,       // "temperature", "humidity", etc.
    pub value: DataValue,
    pub unit: String,            // "celsius", "percent", etc.
    pub quality: f64,            // 0.0-1.0 (data quality score)
    pub metadata: HashMap<String, String>,
}

pub enum DataValue {
    Float(f64),
    Integer(i64),
    Boolean(bool),
    String(String),
    Binary(Vec<u8>),
    Struct(HashMap<String, DataValue>),
    Array(Vec<DataValue>),
}

Procesamiento en el Borde

El motor de procesamiento en el borde filtra, transforma y agrega datos antes de su envío.

Motor de Reglas

// Example rule: alert if temperature > 40
Rule {
    condition: Condition::GT("temperature", 40.0),
    action: ProcessingAction::CriticalAlert,
}

// Logical operators
Condition::AND(vec![
    Condition::GT("temperature", 35.0),
    Condition::LT("humidity", 20.0),
])

Operadores: EQ, NEQ, GT, LT, GTE, LTE, CONTAINS, IN, AND, OR.

Detección de Anomalías

El procesador en el borde ejecuta detección de anomalías sobre los datos entrantes:

• Detección estadística de valores atípicos
• Reconocimiento de patrones
• Inferencia de modelos ML (modelos locales)

Las anomalías desencadenan envío automático independientemente del cronograma por lotes.

Agregación de Datos

Estrategia	Descripción
Average	Media de valores en la ventana
Sum	Total de valores
Min / Max	Extremos
Median	Valor central
Percentile(p)	Percentil P

Procesamiento por Lotes

Las lecturas individuales de sensores se agrupan en lotes para reducir costos de transacción:

pub struct BatchProcessor {
    pub batch_size: usize,       // max readings per batch
    pub max_delay_ms: u64,       // max time before forced submit
    pub compression: bool,       // compress batch payload
    pub aggregation: bool,       // aggregate before submit
}

Disparadores de Lote

Disparador	Descripción
Tamaño alcanzado	batch_size lecturas acumuladas
Retraso máximo	max_delay_ms transcurridos desde la primera lectura
Prioridad crítica	Anomalía o alerta crítica detectada

El procesamiento por lotes reduce las transacciones en blockchain hasta un 90% comparado con el envío por lectura individual.

Seguridad

Autenticación

Tres métodos de autenticación, combinables:

Método	Descripción
Certificado	Validación de cadena de certificados X.509
Token	Token API con caducidad
Biométrico	Verificación biométrica del dispositivo

Cifrado de Datos

• Cifrado AES-256 para datos en tránsito y en reposo
• Hash de integridad para detección de manipulaciones
• Verificación de revocación de certificados

Configuración del Conector

pub struct ConnectorConfig {
    pub max_requests_per_second: u32,
    pub timeout_ms: u64,
    pub retry_attempts: u32,
}

Integración en Cadena

Los datos IoT se envían como transacciones con la tarifa IoT:

let tx = TransactionBuilder::new()
    .oracle_call(
        "iot_oracle_address",
        "submit_sensor_data",
        &batch_payload,
    )
    .nonce(nonce)
    .fee(50_000_000_000_000)  // 0.00005 SAVT (IoT rate)
    .build_and_sign(&device_wallet)?;

Integración con Fuentes de Oráculos

Los datos IoT enviados quedan disponibles como fuentes de oráculos:

// Request latest sensor reading
let tx = oracle.request_data(
    &iot_oracle_address,
    "temperature",
    b"sensor_001",
).await?;

Métricas del Conector

pub struct ConnectorMetrics {
    pub requests_served: u64,
    pub errors_count: u64,
    pub average_response_time: f64,
}