Edge devices et capteurs pour l'IA industrielle : guide de choix et modes opératoires

Le calcul qui change tout

Un capteur de vibration sur un moteur de broyeur echantillonne a 10 kHz. Chaque seconde, il produit 10 000 points de donnees. Sur une journee de production, ca represente 864 millions de points. Envoyer tout ca dans le cloud pour traitement couterait entre 5 et 15 euros par jour en bande passante et en tokens d’inference. Mais le vrai probleme n’est pas le cout : c’est la latence. Quand un roulement commence a lacher, le modele doit reagir en millisecondes, pas en secondes.

C’est exactement le role de l’edge computing : traiter les donnees la ou elles sont produites, au pied de la machine. Le modele tourne sur un device embarque, le capteur lui parle en direct, et la decision (alarme, ajustement, classification) est prise sans aller-retour vers un serveur distant.

Cet article couvre le choix du materiel — edge devices et capteurs — avec les specs reelles, les prix indicatifs, et deux modes operatoires complets pour passer de la theorie au terrain.

1. Pourquoi l’edge computing en industrie

Trois raisons fondamentales, par ordre de priorite.

Latence

Un modele de detection d’anomalie sur un Nvidia Jetson Orin Nano repond en 5 a 15 ms. Le meme modele heberge sur un serveur cloud repond en 200 a 800 ms, dont 80 % sont de la latence reseau. Pour du controle qualite en temps reel sur une ligne a 200 pieces/minute, 800 ms c’est deja 3 pieces qui sont passees sans etre analysees.

Bande passante

Une camera industrielle a 30 fps en resolution 1280x960 genere environ 110 Mo/s en flux brut. Meme compresse, ca fait 5 a 15 Mo/s. Multiplier par 10 cameras sur un site, ca sature n’importe quelle liaison montante. Le edge traite localement et ne remonte que les resultats — quelques Ko par seconde au lieu de dizaines de Mo.

Souverainete et disponibilite

Les donnees de production ne quittent pas le reseau de l’usine. Pas de dependance a une connexion Internet. Si le WAN tombe, l’edge continue de tourner. C’est un argument de poids pour les secteurs reglementees (defense, pharma, alimentaire) et pour toute ETI qui ne veut pas envoyer ses secrets de fabrication chez un hyperscaler americain.

2. Tableau comparatif des edge devices

Le choix du device depend de trois facteurs : la puissance de calcul necessaire (taille du modele), les interfaces d’entree (quels capteurs brancher), et l’environnement physique (temperature, poussiere, vibration).

Device	CPU	GPU / NPU	RAM	Stockage	I/O	Consommation	Enveloppe	Prix indicatif	Cas d’usage	Lien constructeur
Nvidia Jetson Orin Nano 8GB	6-core Arm Cortex-A78AE	1024-core Ampere, 40 TOPS	8 Go LPDDR5	microSD + NVMe M.2	USB 3.2, GbE, GPIO 40-pin, MIPI CSI	7-15 W	Fanless possible	~250 EUR	Vision, inference ONNX/TensorRT, modeles < 2B params	nvidia.com/jetson
Nvidia Jetson AGX Orin 64GB	12-core Arm Cortex-A78AE	2048-core Ampere, 275 TOPS	64 Go LPDDR5	NVMe M.2	USB 3.2 x4, 2x GbE, CAN, GPIO, MIPI CSI x6	15-60 W	Ventile	~1 500 EUR	Multi-camera, modeles 7-8B quantizes, inference lourde	nvidia.com/jetson
Raspberry Pi 5 (8 Go)	BCM2712 quad-core Cortex-A76	VideoCore VII (pas de CUDA)	8 Go LPDDR4X	microSD + NVMe via HAT	USB 3.0 x2, GbE, GPIO 40-pin, MIPI CSI	5-12 W	Passif ou ventilateur	~80 EUR	Collecte de donnees, pre-traitement leger, gateway capteurs	raspberrypi.com
Google Coral USB Accelerator	N/A (accessoire)	Edge TPU, 4 TOPS	N/A	N/A	USB 3.0	2 W	Dongle USB	~60 EUR	Acceleration TFLite sur Pi ou PC, classification d’images	coral.ai
Advantech UNO-2484G	Intel Core i7-1185G7	Intel Iris Xe (pas de CUDA)	Jusqu’a 64 Go DDR4	2x mSATA + 1x 2.5” SATA	4x GbE, 6x COM (RS-232/485), 4x USB 3.0, DIO	25-45 W	Fanless, -20 a 60°C	~800 EUR	Gateway OPC-UA, agregation multi-capteurs, Modbus bridge	advantech.com
Siemens SIMATIC IPC127E	Intel Atom x7-E3950	Aucun	8 Go DDR3L	128 Go eMMC	2x GbE (Profinet), 2x USB, DI/DO	10-15 W	Fanless, rail DIN, -30 a 60°C	~600 EUR	Edge natif ecosysteme Siemens, TIA Portal, Industrial Edge	siemens.com
OnLogic Helix 500	Intel Core i5-1245U	Intel Iris Xe	Jusqu’a 64 Go DDR5	NVMe M.2	2x 2.5GbE, 4x USB 3.2, 2x COM, TPM 2.0	20-35 W	Fanless, -30 a 70°C	~500 EUR	Edge polyvalent, compatible Docker/K3s, environnement severe	onlogic.com

Raspberry Pi 5 + Coral : le combo low-cost

Pour un premier prototype ou un POC, le duo Raspberry Pi 5 + Coral USB Accelerator est imbattable en rapport performance/prix. Le Pi gere la collecte de donnees, le reseau, et le stockage local. Le Coral accelere l’inference de modeles TensorFlow Lite a ~4 TOPS, ce qui suffit pour de la classification d’images a 30 fps en 224x224.

Limites : Le Coral ne supporte que TFLite (pas ONNX, pas TensorRT). L’inference de modeles plus gros que MobileNetV2 est lente. Pour de la production reelle, passez au Jetson.

Jetson Orin Nano : le standard de fait

Le Jetson Orin Nano est devenu le standard de l’IA embarquee industrielle en 2025-2026. Il combine un GPU Ampere capable de faire tourner des modeles ONNX/TensorRT avec un format compact, une consommation de 7 a 15 W, et un ecosysteme logiciel mature (JetPack, DeepStream, Isaac). A 250 euros, il revient moins cher qu’un mois d’inference cloud pour un seul cas d’usage.

Advantech et Siemens : quand l’integrabilite compte plus que la puissance brute

Les IPC (Industrial PC) d’Advantech et de Siemens n’ont pas de GPU. Leur force est l’integration dans l’environnement industriel existant : montage rail DIN, temperature etendue, certifications (CE, UL, ATEX pour certains modeles), et surtout les interfaces industrielles natives (Profinet, COM RS-485, DIO). Ils sont le bon choix quand le device doit servir de gateway entre les capteurs et un serveur d’inference plus puissant en salle serveur.

3. Capteurs par type de mesure

Le device ne sert a rien sans les capteurs qui l’alimentent. Voici les principales familles de capteurs utilises en IA industrielle, avec les modeles de reference et leurs protocoles de sortie.

Vibration

La vibration est le signal le plus utilise en maintenance predictive. Un roulement qui se degrade genere des frequences caracteristiques mesurables plusieurs semaines avant la panne.

Capteur	Type	Bande passante	Sortie	Montage	Prix indicatif	Lien
PCB Piezotronics 352C33	Piezoelectrique, IEPE	0.5 Hz - 10 kHz	Analogique (mV/g), IEPE/ICP	Goujon M5 ou aimant	~400 EUR	pcb.com
ifm VSA001	MEMS 3 axes	10 Hz - 1 kHz	IO-Link	Vis M8, IP67	~250 EUR	ifm.com
Siemens Sitrans MS200	Piezoelectrique	2 Hz - 5 kHz	4-20 mA ou Modbus RTU	Goujon M8	~600 EUR	siemens.com
Banner QM42VT2	MEMS 3 axes + temperature	10 Hz - 1 kHz	IO-Link, Modbus RTU	Vis M12, IP67	~350 EUR	bannerengineering.com

IO-Link vs 4-20 mA. Pour un projet IA, privilegiez IO-Link quand c’est possible. Le protocole est numerique, bidirectionnel, et transporte la donnee avec ses metadonnees (unite, echelle, diagnostic capteur). Le 4-20 mA ne transporte qu’une valeur analogique brute qu’il faut convertir cote device.

Temperature

Capteur	Technologie	Plage	Precision	Sortie	Prix indicatif	Lien
PT100 classe A (ex: Endress+Hauser TR10)	RTD (resistance)	-200 a +600°C	+/- 0.15°C a 0°C	Analogique (4-20 mA via transmetteur)	~80 EUR (sonde seule)	endress.com
Thermocouple type K (ex: RS PRO)	Thermocouple	-200 a +1 200°C	+/- 1.5°C	Analogique (mV, necessite compensateur)	~30 EUR	rs-online.com
Optris CT LT	Infrarouge sans contact	-50 a +975°C	+/- 1%	Analogique 4-20 mA, Modbus RTU, USB	~350 EUR	optris.com
ifm TN2531	RTD PT1000	-40 a +150°C	+/- 0.3°C	IO-Link, 4-20 mA	~120 EUR	ifm.com

Regle pratique : PT100 pour la precision en process (agroalimentaire, pharma). Thermocouple K pour les hautes temperatures (four, soudure). Infrarouge pour les zones inaccessibles ou les pieces en mouvement.

Vision

Camera	Capteur	Resolution	Interface	Fps max	Prix indicatif	Lien
Basler ace2 a2A1920-160ucBAS	CMOS Sony IMX392	1920x1200	USB 3.0	160 fps	~500 EUR	baslerweb.com
FLIR Blackfly S BFS-U3-16S2C	CMOS Sony IMX273	1440x1080	USB 3.0	226 fps	~600 EUR	flir.com
Basler ace2 a2A5320-23ucBAS	CMOS Sony IMX542	5328x3040	USB 3.0	23 fps	~1 200 EUR	baslerweb.com
Webcam USB industrielle (ex: ELP 4K)	CMOS	3840x2160	USB 2.0/3.0	30 fps	~60-100 EUR	aliexpress.com
FLIR A50/A70 (thermique)	VOx microbolometer	464x348 / 640x480	GigE, USB	30 fps	~2 500-3 000 EUR	flir.com

Pour un premier POC en controle qualite visuel, une webcam USB a 80 euros sur un Jetson suffit. La qualite optique et le controle d’exposition ne sont pas au niveau d’une camera industrielle, mais ca suffit pour valider le concept avant d’investir.

Courant et puissance electrique

Capteur	Technologie	Plage	Sortie	Prix indicatif	Lien
LEM DHAB S/14	Effet Hall, bipolaire	+/- 200 A	Analogique (tension)	~50 EUR	lem.com
Fluke i400s	Pince amperemetrique AC	1 - 400 A	Analogique 1 mV/A	~150 EUR	fluke.com
ifm SM9000	Inductif, AC	0 - 60 A	IO-Link, 4-20 mA	~200 EUR	ifm.com
Schneider PowerLogic PM5320	Analyseur reseau complet	V, A, kW, kWh, PF	Modbus TCP, Ethernet	~800 EUR	se.com

Conseil : pour monitorer la consommation electrique d’une machine a des fins de maintenance predictive, un simple capteur a effet Hall non-invasif (pince) suffit. Il se clippe autour d’un cable sans coupure d’alimentation. L’analyseur reseau Schneider est reserve aux cas ou l’on veut un bilan energetique complet (puissance active, reactive, facteur de puissance, harmoniques).

4. Mode operatoire : connecter un capteur vibration ifm a un Jetson Nano via Modbus TCP

Ce mode operatoire decrit la chaine complete, du capteur au stockage des donnees, pour un cas d’usage de maintenance predictive.

Materiel necessaire

1x ifm VSA001 (capteur vibration IO-Link)
1x ifm AL1350 (maitre IO-Link vers Modbus TCP)
1x Nvidia Jetson Orin Nano (Developer Kit)
1x switch Ethernet industriel ou cable RJ45 direct
1x alimentation 24V DC pour le maitre IO-Link

Schema de cablage

[Capteur ifm VSA001] --cable M12 4 broches--> [Maitre IO-Link ifm AL1350]
                                                    |
                                                port Ethernet RJ45
                                                    |
                                            [Switch Ethernet]
                                                    |
                                            [Jetson Orin Nano]
                                            port Ethernet GbE

Le capteur VSA001 communique en IO-Link avec le maitre AL1350. Le maitre convertit les donnees IO-Link en registres Modbus TCP accessibles a l’adresse IP du maitre. Le Jetson interroge ces registres en TCP/IP standard.

Configuration du maitre IO-Link

Connecter le maitre AL1350 au reseau Ethernet
Acceder a l’interface web du maitre (IP par defaut : 192.168.0.1)
Configurer l’adresse IP du maitre dans le sous-reseau du Jetson (ex: 192.168.1.100)
Brancher le capteur VSA001 sur le port 1
Le maitre detecte automatiquement le capteur (auto-parametrisation IO-Link)
Noter les adresses des registres Modbus dans l’interface web :
- Registre 400 : vibration RMS (axe X), FLOAT32
- Registre 402 : vibration RMS (axe Y), FLOAT32
- Registre 404 : vibration RMS (axe Z), FLOAT32
- Registre 406 : temperature capteur, INT16 (x10)

Code Python : lecture Modbus TCP

"""
Lecture capteur vibration ifm VSA001 via maitre IO-Link Modbus TCP.
Stockage dans InfluxDB.
"""
import time
import struct
from pymodbus.client import ModbusTcpClient
from influxdb_client import InfluxDBClient, Point
from influxdb_client.client.write_api import SYNCHRONOUS

# --- Configuration ---
MODBUS_HOST = "192.168.1.100"  # IP du maitre IO-Link
MODBUS_PORT = 502
UNIT_ID = 1

INFLUX_URL = "http://localhost:8086"
INFLUX_TOKEN = "your-token-here"
INFLUX_ORG = "factory"
INFLUX_BUCKET = "vibration"

POLL_INTERVAL_S = 1.0  # Frequence de lecture (1 Hz)

# --- Fonctions utilitaires ---
def read_float32(client, address, unit=1):
    """Lit un FLOAT32 sur 2 registres Modbus (big-endian)."""
    result = client.read_holding_registers(address, count=2, slave=unit)
    if result.isError():
        raise IOError(f"Erreur lecture registre {address}: {result}")
    raw = struct.pack(">HH", result.registers[0], result.registers[1])
    return struct.unpack(">f", raw)[0]

def read_int16(client, address, unit=1):
    """Lit un INT16 sur 1 registre Modbus."""
    result = client.read_holding_registers(address, count=1, slave=unit)
    if result.isError():
        raise IOError(f"Erreur lecture registre {address}: {result}")
    return result.registers[0]

# --- Boucle principale ---
def main():
    # Connexion Modbus
    modbus = ModbusTcpClient(MODBUS_HOST, port=MODBUS_PORT)
    if not modbus.connect():
        raise ConnectionError(f"Impossible de se connecter a {MODBUS_HOST}:{MODBUS_PORT}")
    print(f"Connecte au maitre IO-Link {MODBUS_HOST}")

    # Connexion InfluxDB
    influx = InfluxDBClient(url=INFLUX_URL, token=INFLUX_TOKEN, org=INFLUX_ORG)
    write_api = influx.write_api(write_options=SYNCHRONOUS)
    print(f"Connecte a InfluxDB {INFLUX_URL}")

    try:
        while True:
            # Lecture des 3 axes de vibration + temperature
            vib_x = read_float32(modbus, 400, UNIT_ID)
            vib_y = read_float32(modbus, 402, UNIT_ID)
            vib_z = read_float32(modbus, 404, UNIT_ID)
            temp_raw = read_int16(modbus, 406, UNIT_ID)
            temp_c = temp_raw / 10.0  # Conversion en degres Celsius

            # Ecriture dans InfluxDB
            point = (
                Point("vibration")
                .tag("machine", "broyeur-01")
                .tag("capteur", "VSA001-port1")
                .field("rms_x_mm_s", round(vib_x, 3))
                .field("rms_y_mm_s", round(vib_y, 3))
                .field("rms_z_mm_s", round(vib_z, 3))
                .field("temperature_c", round(temp_c, 1))
            )
            write_api.write(bucket=INFLUX_BUCKET, record=point)

            print(f"X={vib_x:.2f} mm/s | Y={vib_y:.2f} mm/s | Z={vib_z:.2f} mm/s | T={temp_c:.1f}°C")
            time.sleep(POLL_INTERVAL_S)

    except KeyboardInterrupt:
        print("Arret demande")
    finally:
        modbus.close()
        influx.close()

if __name__ == "__main__":
    main()

Installation des dependances sur le Jetson

# Sur Jetson Orin Nano (JetPack 6.x, Ubuntu 22.04)
sudo apt update && sudo apt install -y python3-pip
pip3 install pymodbus==3.6.9 influxdb-client==1.40.0

Alternative : TimescaleDB. Si vous preferez PostgreSQL a InfluxDB, remplacez le client InfluxDB par psycopg2 et inserez les donnees dans une hypertable TimescaleDB. L’avantage de TimescaleDB est la compatibilite SQL native, ce qui simplifie les requetes pour les data scientists habitues a SQL.

5. Mode operatoire : deployer un modele ONNX sur Jetson avec TensorRT

TensorRT est le runtime d’inference de Nvidia. Il prend un modele au format ONNX et le compile en un moteur optimise pour le GPU Jetson. Les gains de performance sont substantiels : 2x a 10x plus rapide que l’inference ONNX Runtime par defaut.

Prerequis

Jetson Orin Nano avec JetPack 6.1+ installe
Un modele ONNX (par exemple, un modele de classification de defauts visuels)
Connexion SSH au Jetson

Etape 1 : transferer le modele ONNX

# Depuis votre poste de travail
scp defaut_classifier.onnx nika@192.168.1.50:/home/nika/models/

Etape 2 : convertir ONNX en TensorRT

# Sur le Jetson
cd /home/nika/models/

# Conversion avec trtexec (inclus dans JetPack)
/usr/src/tensorrt/bin/trtexec \
    --onnx=defaut_classifier.onnx \
    --saveEngine=defaut_classifier.trt \
    --fp16 \
    --workspace=2048 \
    --verbose

# Verifier le resultat
ls -lh defaut_classifier.trt

Le flag --fp16 active l’inference en demi-precision (FP16), ce qui double le debit d’inference sur le GPU Ampere du Jetson sans perte de precision significative pour la plupart des modeles de classification et detection.

Etape 3 : inference avec le moteur TensorRT

"""
Inference TensorRT sur Jetson Orin Nano.
Charge un moteur .trt et effectue la classification d'image.
"""
import numpy as np
import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
from PIL import Image

TRT_LOGGER = trt.Logger(trt.Logger.WARNING)

def load_engine(engine_path):
    """Charge un moteur TensorRT depuis un fichier .trt."""
    with open(engine_path, "rb") as f, trt.Runtime(TRT_LOGGER) as runtime:
        return runtime.deserialize_cuda_engine(f.read())

def preprocess_image(image_path, input_shape=(1, 3, 224, 224)):
    """Charge et pretraite une image pour le modele."""
    img = Image.open(image_path).convert("RGB")
    img = img.resize((input_shape[3], input_shape[2]))
    arr = np.array(img, dtype=np.float32) / 255.0
    # Normalisation ImageNet
    mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
    std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
    arr = (arr - mean) / std
    # HWC -> CHW -> NCHW
    arr = arr.transpose(2, 0, 1)
    arr = np.expand_dims(arr, axis=0)
    return np.ascontiguousarray(arr)

def infer(engine, input_data):
    """Execute l'inference TensorRT."""
    context = engine.create_execution_context()

    # Allocation memoire GPU
    d_input = cuda.mem_alloc(input_data.nbytes)
    output_shape = (1, engine.get_tensor_shape(engine.get_tensor_name(1))[1])
    output_data = np.empty(output_shape, dtype=np.float32)
    d_output = cuda.mem_alloc(output_data.nbytes)

    # Transfert host -> device
    cuda.memcpy_htod(d_input, input_data)

    # Inference
    context.set_tensor_address(engine.get_tensor_name(0), int(d_input))
    context.set_tensor_address(engine.get_tensor_name(1), int(d_output))
    context.execute_async_v3(stream_handle=cuda.Stream().handle)

    # Transfert device -> host
    cuda.memcpy_dtoh(output_data, d_output)

    return output_data

# --- Utilisation ---
CLASSES = ["ok", "rayure", "bavure", "deformation", "tache"]

engine = load_engine("/home/nika/models/defaut_classifier.trt")
image = preprocess_image("/home/nika/images/piece_042.jpg")

import time
start = time.perf_counter()
output = infer(engine, image)
elapsed_ms = (time.perf_counter() - start) * 1000

predicted_class = CLASSES[np.argmax(output)]
confidence = float(np.max(output))

print(f"Classe: {predicted_class} ({confidence:.1%})")
print(f"Latence: {elapsed_ms:.1f} ms")

Benchmark de latence

Resultats mesures sur un Jetson Orin Nano 8 Go, modele ResNet-18 (classification 5 classes, 224x224, FP16) :

Runtime	Latence (P50)	Latence (P99)	Debit max
ONNX Runtime (CPU)	45 ms	62 ms	~22 fps
ONNX Runtime (CUDA)	12 ms	18 ms	~80 fps
TensorRT FP32	5.2 ms	7.1 ms	~190 fps
TensorRT FP16	3.1 ms	4.8 ms	~320 fps

TensorRT FP16 est 15x plus rapide que l’inference CPU et 4x plus rapide que ONNX Runtime CUDA. Sur un modele plus lourd (YOLOv8s par exemple), le gain est encore plus marque : 8 ms en TRT FP16 contre 85 ms en CPU.

6. Arbre de decision : quel edge device choisir

%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#1a1a2e', 'primaryTextColor': '#ffffff', 'primaryBorderColor': '#e94560', 'lineColor': '#e94560', 'secondaryColor': '#16213e', 'tertiaryColor': '#0f3460', 'fontSize': '14px'}}}%%
flowchart TD
    A["Quel est votre besoin ?"] --> B{"Inference IA\nsur le device ?"}
    
    B -->|Non, collecte seule| C{"Budget"}
    B -->|Oui| D{"Taille du modele ?"}
    
    C -->|"< 150 EUR"| E["**Raspberry Pi 5**\n80 EUR\nCollecte + gateway"]
    C -->|"> 500 EUR"| F["**Advantech UNO-2484G**\n800 EUR\nGateway industriel\nModbus/OPC-UA natif"]
    
    D -->|"Leger\n(MobileNet, ResNet)"| G{"Ecosysteme ?"}
    D -->|"Moyen\n(YOLOv8, 1-3B params)"| H["**Jetson Orin Nano**\n250 EUR\n40 TOPS, FP16"]
    D -->|"Lourd\n(7-8B params, multi-cam)"| I["**Jetson AGX Orin**\n1 500 EUR\n275 TOPS"]
    
    G -->|TensorFlow Lite| J["**Pi 5 + Coral USB**\n140 EUR\n4 TOPS, TFLite only"]
    G -->|ONNX / TensorRT| H
    
    A --> K{"Ecosysteme\nSiemens existant ?"}
    K -->|Oui| L["**SIMATIC IPC127E**\n600 EUR\nIndustrial Edge natif\nProfinet integre"]
    K -->|Non| B

    style A fill:#1a1a2e,stroke:#e94560,color:#ffffff
    style B fill:#16213e,stroke:#e94560,color:#ffffff
    style C fill:#16213e,stroke:#e94560,color:#ffffff
    style D fill:#16213e,stroke:#e94560,color:#ffffff
    style E fill:#0f3460,stroke:#e94560,color:#ffffff
    style F fill:#0f3460,stroke:#e94560,color:#ffffff
    style G fill:#16213e,stroke:#e94560,color:#ffffff
    style H fill:#0f3460,stroke:#e94560,color:#ffffff
    style I fill:#0f3460,stroke:#e94560,color:#ffffff
    style J fill:#0f3460,stroke:#e94560,color:#ffffff
    style K fill:#16213e,stroke:#e94560,color:#ffffff
    style L fill:#0f3460,stroke:#e94560,color:#ffffff

Combien ca coute au total

Pour ancrer le propos, voici le cout complet d’une chaine de maintenance predictive par vibration, du capteur au dashboard :

Composant	Prix	Recurrence
Capteur ifm VSA001	~250 EUR	Achat unique
Maitre IO-Link ifm AL1350	~350 EUR	Achat unique
Jetson Orin Nano Dev Kit	~250 EUR	Achat unique
Alimentation 24V + cablage	~80 EUR	Achat unique
InfluxDB / TimescaleDB (open source)	0 EUR	—
Grafana (open source)	0 EUR	—
Electricite Jetson (15 W, 24/7)	~12 EUR/an	Annuel
Total premiere annee	~942 EUR
Total annees suivantes	~12 EUR/an

Moins de 1 000 euros pour instrumenter un moteur critique. A comparer au cout d’un arret non planifie d’une ligne de production, qui se chiffre typiquement entre 5 000 et 50 000 euros par heure selon le secteur.

L’equation est simple. Un seul arret evite rembourse l’investissement.

Ce qu’on n’a pas couvert

Cet article se concentre sur le choix et la connexion du materiel. Les sujets suivants feront l’objet d’articles dedies :

Entrainer un modele de detection d’anomalie vibratoire (EWMA + Isolation Forest + XGBoost)
Deployer un pipeline vision avec DeepStream sur Jetson (multi-camera, tracking)
Connecter un automate Siemens ou Schneider a l’edge (OPC-UA, snap7, Modbus TCP)
Securiser la chaine edge (TLS, certificats, segmentation reseau, mise a jour firmware)