Connettore IoT

Il Connettore IoT di Savitri consente ai dispositivi Internet-of-Things di inviare dati dei sensori on-chain. Fornisce gestione dei dispositivi, acquisizione dei dati, elaborazione edge, ottimizzazione batch e sicurezza di livello enterprise.

Architettura

Dispositivi IoT (sensori, attuatori, gateway)
    │
    ▼
Gestori di Protocollo (MQTT, CoAP)
    │ analisi, validazione, autenticazione
    ▼
Motore di Elaborazione Edge
    │ motore di regole, rilevamento anomalie, aggregazione
    ▼
Elaboratore Batch
    │ compressione, aggregazione, pianificazione
    ▼
Interfaccia Blockchain (savitri_sendRawTransaction)
    │ invia batch come TX IoT (commissione 0,00005 SAVT)
    ▼
Feed Oracle On-chain

Gestione dei Dispositivi

Tipi di Dispositivo

Tipo	Descrizione	Esempio
Sensor	Produttore di dati in sola lettura	Sensore di temperatura
Actuator	Dispositivo controllabile	Valvola intelligente
Gateway	Punto di aggregazione edge	Hub Raspberry Pi
EdgeNode	Unità di elaborazione locale	Server ML edge
Mobile	Dispositivo mobile	Smartphone
Industrial	Apparecchiatura industriale	PLC/SCADA

Registrazione del Dispositivo

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>,
}

I dispositivi vengono registrati on-chain con la loro chiave pubblica per l'autenticazione. I gruppi di dispositivi possono essere gestiti collettivamente.

Stato del Dispositivo

Stato	Descrizione
Active	Operatività normale
Inactive	Temporaneamente offline
Suspended	Sospeso dal proprietario/governance
Banned	Revocato definitivamente

Acquisizione dei Dati

Supporto dei Protocolli

Protocollo	Gestore	Caso d'Uso
MQTT	MQTTHandler	Sensori a bassa potenza, pub/sub
CoAP	CoAPHandler	Dispositivi vincolati, UDP

Entrambi implementano il 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 Dati 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>),
}

Elaborazione Edge

Il motore di elaborazione edge filtra, trasforma e aggrega i dati prima dell'invio.

Motore di Regole

// Esempio di regola: alert se temperatura > 40
Rule {
    condition: Condition::GT("temperature", 40.0),
    action: ProcessingAction::CriticalAlert,
}

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

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

Rilevamento delle Anomalie

Il processore edge esegue il rilevamento delle anomalie sui dati in ingresso:

• Rilevamento dei valori anomali statistici
• Riconoscimento dei pattern
• Inferenza del modello ML (modelli locali)

Le anomalie attivano l'invio automatico indipendentemente dalla pianificazione batch.

Aggregazione dei Dati

Strategia	Descrizione
Average	Media dei valori nella finestra
Sum	Totale dei valori
Min / Max	Valori estremi
Median	Valore mediano
Percentile(p)	P-esimo percentile

Elaborazione Batch

Le letture individuali dei sensori vengono raggruppate per ridurre i costi delle transazioni:

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
}

Trigger del Batch

Trigger	Descrizione
Dimensione raggiunta	batch_size letture accumulate
Ritardo massimo	max_delay_ms trascorsi dalla prima lettura
Priorità critica	Anomalia o alert critico rilevati

Il batching riduce le transazioni blockchain fino al 90% rispetto all'invio per singola lettura.

Sicurezza

Autenticazione

Tre metodi di autenticazione, combinabili:

Metodo	Descrizione
Certificate	Validazione della catena di certificati X.509
Token	Token API con scadenza
Biometric	Verifica biometrica del dispositivo

Cifratura dei Dati

• Cifratura AES-256 per i dati in transito e a riposo
• Hash di integrità per il rilevamento delle manomissioni
• Controllo della revoca dei certificati

Configurazione del Connettore

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

Integrazione On-Chain

I dati IoT vengono inviati come transazioni con la tariffa 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)?;

Integrazione Feed Oracle

I dati IoT inviati diventano disponibili come feed oracle:

// Richiedi l'ultima lettura del sensore
let tx = oracle.request_data(
    &iot_oracle_address,
    "temperature",
    b"sensor_001",
).await?;

Metriche del Connettore

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