Connecteur IoT

Le Connecteur IoT de Savitri permet aux appareils de l'Internet des Objets de soumettre des données capteurs en chaîne. Il offre la gestion des appareils, l'ingestion de données, le traitement en périphérie, l'optimisation par lots et une sécurité de niveau entreprise.

Architecture

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

Gestion des Appareils

Types d'Appareils

Type	Description	Exemple
Sensor	Producteur de données en lecture seule	Capteur de température
Actuator	Appareil contrôlable	Vanne intelligente
Gateway	Point d'agrégation en périphérie	Hub Raspberry Pi
EdgeNode	Unité de traitement local	Serveur ML en périphérie
Mobile	Appareil mobile	Smartphone
Industrial	Équipement industriel	PLC/SCADA

Enregistrement des Appareils

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

Les appareils sont enregistrés en chaîne avec leur clé publique pour l'authentification. Les groupes d'appareils peuvent être gérés collectivement.

Statut des Appareils

Statut	Description
Active	Fonctionnement normal
Inactive	Temporairement hors ligne
Suspended	Suspendu par le propriétaire/la gouvernance
Banned	Révoqué définitivement

Ingestion de Données

Support des Protocoles

Protocole	Gestionnaire	Cas d'Usage
MQTT	MQTTHandler	Capteurs basse consommation, pub/sub
CoAP	CoAPHandler	Appareils contraints, UDP

Les deux implémentent le 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>;
}

Format des Données 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>),
}

Traitement en Périphérie

Le moteur de traitement en périphérie filtre, transforme et agrège les données avant soumission.

Moteur de Règles

// 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),
])

Opérateurs : EQ, NEQ, GT, LT, GTE, LTE, CONTAINS, IN, AND, OR.

Détection d'Anomalies

Le processeur de périphérie exécute la détection d'anomalies sur les données entrantes :

• Détection des valeurs aberrantes statistiques
• Reconnaissance de motifs
• Inférence de modèle ML (modèles locaux)

Les anomalies déclenchent une soumission automatique indépendamment du calendrier de traitement par lots.

Agrégation des Données

Stratégie	Description
Average	Moyenne des valeurs dans la fenêtre
Sum	Total des valeurs
Min / Max	Valeurs extrêmes
Median	Valeur médiane
Percentile(p)	P-ième percentile

Traitement par Lots

Les lectures individuelles des capteurs sont regroupées par lots pour réduire les coûts de transaction :

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
}

Déclencheurs de Lot

Déclencheur	Description
Taille atteinte	batch_size lectures accumulées
Délai maximum	max_delay_ms écoulé depuis la première lecture
Priorité critique	Anomalie ou alerte critique détectée

Le traitement par lots réduit les transactions blockchain jusqu'à 90 % par rapport à la soumission par lecture individuelle.

Sécurité

Authentification

Trois méthodes d'authentification, combinables :

Méthode	Description
Certificat	Validation de chaîne de certificat X.509
Jeton	Jeton API avec expiration
Biométrique	Vérification biométrique de l'appareil

Chiffrement des Données

• Chiffrement AES-256 pour les données en transit et au repos
• Hachage d'intégrité pour la détection des altérations
• Vérification de révocation des certificats

Configuration du Connecteur

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

Intégration en Chaîne

Les données IoT sont soumises comme transactions avec le tarif de frais 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)?;

Intégration avec les Flux Oracle

Les données IoT soumises deviennent disponibles en tant que flux oracle :

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

Métriques du Connecteur

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