Rétro-ingénierie : faire parler l'écran LCD d'une RTX 5090 sous Linux

Le point de départ : un bel écran qui ne sert à rien
La MSI RTX 5090 Lightning Z a une particularité : un écran LCD de 9,6 pouces (1280×800) intégré à la carte graphique. Sous Windows, l'application MSI Lightning Hub y affiche des images, des vidéos, l'état du PC. Sous Linux, rien. L'écran joue en boucle son animation d'usine, un éclair et le mot « LIGHTNING », et on ne peut rien en faire.
Mon poste de travail tourne sous Fedora. L'objectif était donc simple à énoncer : prendre la main sur cet écran depuis Linux, y afficher un tableau de bord de la machine en continu, et le faire proprement, avec un vrai logiciel installable et pas un script qui tient par miracle.
Voici où nous en sommes arrivés :

Cet article raconte tout le chemin, y compris les impasses. Ce sont elles qui ont le plus appris. Il s'adresse autant aux curieux du matériel qu'aux équipes qui se demandent comment aborder un système qu'elles ne connaissent pas : la démarche est la même que pour diagnostiquer une infrastructure héritée sans documentation.
En bref
- L'écran est un « USB Display » ArtInChip rebadgé MSI, vu par Linux comme un périphérique USB
0db0:7881à deux interfaces : un canal de données (bulk) et un canal de commandes (HID). - Pour afficher une image, il faut : basculer l'écran en « mode étendu » par HID, s'authentifier en RSA sur le canal bulk, puis envoyer des JPEG précédés d'un en-tête de 20 octets.
- Le verrou qui nous a bloqués le plus longtemps : le firmware ne lit le canal HID qu'une fois toutes les ~4,1 secondes. Une commande envoyée une seule fois se perd.
- Le prototype Python a été réécrit en Rust : une bibliothèque de protocole, un démon piloté par D-Bus, une application GNOME (GTK 4 + libadwaita), des paquets RPM et Flatpak, 126 tests et une CI.
Le cadre : interopérabilité et prudence
Avant la première commande, deux règles ont été posées. Elles ont guidé toutes les décisions qui suivent.
1. Un but d'interopérabilité, rien d'autre. Le but est de faire fonctionner sous Linux un matériel acheté dans le commerce. Le protocole a été retrouvé en observant le matériel, son pilote et son service Windows. Le dépôt ne contient aucun code du constructeur, et la seule clé qui y figure est une clé publique.
2. Ne jamais risquer la carte. L'écran équipe une carte graphique très chère, avec un firmware non documenté. Nous nous sommes donc interdit :
- toute écriture dans la mémoire flash de l'écran. La commande existe (upload de médias), nous l'avons identifiée, et elle n'a jamais été envoyée ;
- toute commande inconnue envoyée « pour voir ». On n'émet que ce qu'on a compris.
Ces règles sont aujourd'hui écrites dans le CONTRIBUTING.md du projet : une contribution qui ajoute l'écriture en flash sera refusée. C'est l'équivalent matériel d'un terraform plan obligatoire avant un apply en production : la prudence fait partie de la méthode.
Étape 1 : l'inventaire, regarder avant de toucher
La première étape d'une rétro-ingénierie ressemble à un audit : on observe sans rien modifier. Sur la machine, lsusb révèle quatre périphériques MSI :
| Périphérique | VID:PID | Rôle supposé |
|---|---|---|
| V530-9.6 Lightning | 0db0:7881 | l'écran |
| DYNAMIC DASHBOARD III | 0db0:84df | contrôleur secondaire |
| MYSTIC LIGHT | 0db0:0076 | éclairage RGB |
| USB Audio | 0db0:e5c3 | audio de la carte |
Les descripteurs USB de l'écran (lsusb -v -d 0db0:7881) racontent déjà beaucoup :
- Interface 0, classe « Vendor Specific » : deux points de terminaison bulk (
0x01en sortie,0x81en entrée), aucun pilote noyau. C'est typiquement là que passent de gros volumes de données, des images par exemple. - Interface 1, classe HID : des rapports de 1024 octets sans report ID, dans une page d'usage « Vendor Defined ». Le noyau y attache
usbhid, ce qui crée un/dev/hidrawN. C'est typiquement un canal de commandes.
Des requêtes de contrôle en lecture (bmRequestType 0xC0) renvoient aussi des informations : la requête 0x01 répond 00 05 20 03 3c 00, soit en entiers 16 bits petit-boutistes 1280, 800, 60 : la résolution et la fréquence. La requête 0x00 renvoie 160 octets contenant un EDID, la carte d'identité standard d'un écran, au nom de « USB Display ».
Première hypothèse de travail : les images passent par l'interface 0, les réglages par l'interface 1. Elle s'est révélée juste. Le reste a demandé beaucoup plus de temps.
Étape 2 : trois murs et une fausse piste
Les premiers essais datent d'avril 2026. Ils se sont heurtés à des murs que nous avons longtemps mal interprétés.
Mur n°1 : l'écran disparaît après 2560 octets. On peut réclamer l'interface 0 et y écrire. Mais après exactement cinq paquets de 512 octets, l'écran se déconnecte du bus USB (errno 19: No such device), puis réapparaît quelques secondes plus tard. Le contenu n'y change rien : même des zéros provoquent la coupure.
Mur n°2 : le HID « muet ». Les écritures de 1024 octets sur /dev/hidrawN sont toujours acceptées sans erreur, mais aucune réponse ne revient jamais, et rien ne change à l'écran.
Les requêtes de contrôle en écriture (0x40) font elles aussi disparaître l'écran immédiatement.
À ce stade, nous avions noté dans notre documentation une conclusion du type : « le périphérique attend un handshake spécifique, probablement via HID d'abord ». Elle était à moitié juste, et l'autre moitié nous a fait perdre du temps.
La fausse piste : les écrans OLED d'autres produits MSI. D'autres produits MSI ont un petit écran, et il était tentant de supposer un protocole commun. Il n'avait aucun rapport avec celui-ci. Les scripts d'exploration conservés dans le dossier legacy/ du dépôt (explore*.py, hid_probe.py, find_header.py…) gardent la trace de ces premiers essais.
Leçon n°1. Une observation (« ça se déconnecte après 2560 octets ») n'est pas une cause. Nous avions décrit le symptôme avec précision, mais l'interprétation (« il manque un handshake HID ») était une supposition présentée comme une conclusion. Distinguer les deux dans ses notes évite de construire sur du sable.
Étape 3 : changer d'angle, chercher la puce et pas la marque
Le déblocage est venu en changeant de question. Plutôt que « comment parle un écran MSI ? », nous nous sommes demandé : « qui a fabriqué l'électronique de cet écran ? »
Le pilote d'affichage livré avec la carte pour Windows donne la réponse. C'est un pilote Indirect Display (le mécanisme Windows pour les écrans « virtuels » alimentés par USB) d'ArtInChip, un fabricant de puces. Il est déclaré pour toute une plage d'identifiants, de 0db0:7880 à 0db0:7919. MSI n'a pas conçu ce protocole : il a intégré une puce du marché et lui a donné son identifiant.
Or les écrans USB ArtInChip (aussi appelés AiCast) existent sous d'autres marques, et la communauté open source s'y est déjà intéressée : des projets comme artinchip-linux ou eM3499-Monitor pilotent sous Linux des écrans ArtInChip 33c3:0e02, en s'appuyant sur des en-têtes du pilote Linux AiCast. En comparant :
- les constantes « magiques »
0xA1C62B01,0xA1C62B10et0xA1C62B11étaient identiques ; - la clé publique RSA était identique.
Le mur des 2560 octets s'expliquait d'un coup : l'écran exige une authentification avant d'accepter des images. Sans elle, il tolère quelques paquets puis se déconnecte, en guise de protection.
Leçon n°2. Le matériel grand public est souvent un assemblage de composants génériques. Remonter à la puce, au SDK ou au fournisseur d'origine ouvre l'accès à tout ce que d'autres ont déjà compris. C'est vrai aussi en infrastructure : derrière une appliance propriétaire, il y a souvent un nginx, un PostgreSQL ou un Linux bien connus.
Étape 4 : l'authentification RSA, sans aucun secret
L'authentification se déroule sur le canal bulk, en deux phases. Elle est élégante, car l'hôte n'a besoin d'aucun secret : la clé publique suffit.
Chaque message commence par un en-tête de 20 octets (petit-boutiste) :
magic (u32) | longueur (u32) | frame_id (u16) | format (u16) | 0 (u32) | magic (u32)
Phase 1 : l'écran prouve son identité. L'hôte tire 32 octets au hasard (un « défi »), les chiffre avec la clé publique (RSA-2048, bourrage PKCS#1 v1.5) et les envoie derrière un en-tête 0xA1C62B10. Seul le détenteur de la clé privée, l'écran, peut les déchiffrer. Il renvoie le défi en clair : c'est la preuve qu'il est authentique.
Phase 2 : l'hôte prouve qu'il parle le protocole. Après un en-tête 0xA1C62B11, l'écran envoie un bloc de 256 octets signé avec sa clé privée. L'hôte lui applique la clé publique, retire le bourrage (PKCS#1 type 1) et renvoie le contenu : 153 octets sur notre exemplaire.
Voici la version Rust de cette séquence, extraite de la bibliothèque lightning-lcd :
/// Authentification RSA en deux phases.
fn authenticate(handle: &DeviceHandle<GlobalContext>) -> Result<()> {
let block_len = rsa::BLOCK_LEN as u32;
let mut buf = [0u8; 512];
// Phase 1 : l'écran prouve qu'il détient la clé privée en déchiffrant un défi.
let mut challenge = [0u8; 32];
rsa::random_bytes(&mut challenge)?;
write_all(handle, &frame::bulk_header(AUTH_DEV_MAGIC, block_len, 0, 0))?;
write_all(handle, &rsa::encrypt(&challenge)?)?;
let n = handle.read_bulk(EP_IN, &mut buf, AUTH_TIMEOUT)?;
if n < challenge.len() || buf[..challenge.len()] != challenge {
return Err(Error::Auth("l'écran n'a pas renvoyé le défi"));
}
// Phase 2 : l'écran envoie un bloc signé, l'hôte en renvoie le contenu.
write_all(handle, &frame::bulk_header(AUTH_HOST_MAGIC, block_len, 0, 0))?;
let n = handle.read_bulk(EP_IN, &mut buf, AUTH_TIMEOUT)?;
let plain = rsa::public_recover(&buf[..n])?;
write_all(handle, &plain)?;
Ok(())
}
Pas besoin de bibliothèque cryptographique complète : une opération RSA « publique » est une simple exponentiation modulaire (m^65537 mod n). Nous l'avons écrite avec num-bigint, en une trentaine de lignes, et testée contre deux références : un vecteur calculé par le prototype Python, et un vrai bloc renvoyé par l'écran le jour où l'authentification a fonctionné.
Une fois authentifié, l'écran ne se déconnectait plus. Les images étaient acceptées… mais l'animation MSI restait obstinément affichée.
Étape 5 : le canal HID et son protocole « BY »
Il manquait une étape que le pilote d'affichage ne fait pas : c'est le service Windows de la carte qui, au démarrage, envoie à l'écran deux requêtes sur le canal HID. La première se présente (conn), la seconde demande le passage en « mode écran étendu » (extendedDisplay). Sans cette bascule, l'écran reste en mode autonome : il accepte les images par USB mais affiche son animation interne.
Le format de ces requêtes est étonnant : du texte façon HTTP, emballé dans une petite trame binaire.
La trame est délimitée par l'octet 0x5A. Elle contient la longueur (16 bits gros-boutiste), le texte, une somme de contrôle sur 8 bits, puis le délimiteur de fin. Pour que 0x5A ne puisse jamais apparaître au milieu, il est échappé (5A → 5B 01, et donc 5B → 5B 02). C'est le même principe que le byte stuffing de PPP ou de SLIP. Le tout est complété par des zéros jusqu'à 1024 octets.
L'encodeur tient en une fonction pure, ce qui la rend triviale à tester :
/// Encode un texte dans une trame BY :
/// `5A | longueur BE16 (= texte + 5) | texte | somme8 | 5A`.
pub fn by_frame(text: &[u8]) -> Vec<u8> {
let len = u16::try_from(text.len() + 5).expect("texte trop long pour une trame BY");
let mut body = Vec::with_capacity(text.len() + 3);
body.extend_from_slice(&len.to_be_bytes());
body.extend_from_slice(text);
let sum = body.iter().fold(0u8, |acc, b| acc.wrapping_add(*b));
body.push(sum);
let mut out = vec![DELIM];
for b in body {
match b {
DELIM => out.extend_from_slice(&[ESCAPE, 0x01]),
ESCAPE => out.extend_from_slice(&[ESCAPE, 0x02]),
other => out.push(other),
}
}
out.push(DELIM);
out
}
La requête conn renvoie l'état complet du firmware en JSON. C'est une mine d'informations :
{"OS":"RTOS","Manufacturer":"MSI","model":"V530-9.6 Lightning",
"version":{"app":"V1.0.1","firmware":"V530-9.6 Lightning_20251212v01","sdk":"V1.2.0","hardware":"V2.0"},
"brightness":100,"degree":90,"bootFinish":1,"realtimeDisplay":0,"extendedDisplay":0}
Le champ qui nous intéresse est "extendedDisplay":0. Il doit passer à 1.
Étape 6 : le déclic des 4,1 secondes
Nous avions donc les bonnes requêtes, au bon format. Et pourtant, envoyées une fois, elles ne faisaient rien. Exactement comme en avril : le HID semblait muet.
La clé était dans le temps, pas dans les octets. En envoyant la même requête en boucle plutôt qu'une seule fois, les réponses sont enfin arrivées, et leur rythme a tout expliqué : le firmware ne consulte son entrée HID qu'environ une fois toutes les 4,1 secondes, et jette tout ce qui arrive entre deux lectures.
Une requête envoyée une seule fois tombe donc presque toujours « entre deux lectures » et disparaît. La solution : répéter la requête toutes les 100 ms jusqu'à obtenir une réponse, avec un délai maximal de 9 secondes (deux périodes).
Un second piège s'est révélé à ce moment : le firmware garde en file quelques copies de la requête précédente. Juste après avoir changé de requête, le premier rapport reçu peut donc répondre à l'ancienne. Chaque requête porte un SeqNumber, chaque réponse un AckNumber = SeqNumber + 1 : il suffit de filtrer les réponses sur ce numéro. Notre prototype Python ne le faisait pas, la version Rust le fait.
Avec ces deux corrections, l'état relu passe à "extendedDisplay":1… et l'animation MSI disparaît.
Leçon n°3. « Ça ne répond pas » et « ça ne répond pas tout de suite » sont deux diagnostics différents. Notre conclusion d'avril, « le HID est muet », était fausse : la commande unique était simplement perdue. Avant de conclure qu'un système ignore une entrée, il faut vérifier sur quelle échelle de temps il la lit. Les habitués de Kubernetes reconnaîtront le principe : une boucle de réconciliation qui réessaie jusqu'à converger.
Étape 7 : la première image, puis la séquence complète
Le 14 novembre 2026, l'écran a affiché, dans l'ordre : du rouge, du vert, du bleu, une mire de test, une photo, puis une vidéo à 30 images par seconde décodée par ffmpeg. Chaque étape a été confirmée à l'œil, devant la carte. C'est le seul juge de paix quand on écrit vers un écran qui ne renvoie aucun accusé de réception pour les images.
Voici la séquence complète, telle qu'elle est aujourd'hui figée dans la bibliothèque :
Une contrainte forte sur le format : l'écran annonce le JPEG comme format média (0x10), et son décodeur n'a été validé qu'avec du JPEG baseline, sous-échantillonnage 4:2:0, exactement 1280×800. Toute image est donc redimensionnée, puis encodée dans ce format précis avant l'envoi.
Ce qui est prouvé, et ce qui ne l'est pas
Nous avons tenu dans la documentation du protocole un tableau honnête de ce qui est démontré et de ce qui est supposé :
| Point | Statut |
|---|---|
| Authentification RSA (défi renvoyé, bloc signé valide) | prouvé par les réponses de l'écran |
extendedDisplay 0 → 1 après la commande HID | prouvé par l'état relu |
| Couleurs, mire, image, vidéo 30 img/s | confirmé visuellement |
| Sans bascule HID : images acceptées mais non affichées | constaté |
Commande rotate du firmware | connue, non testée |
| Encodage H.264 | non testé (l'écran annonce JPEG) |
Ce tableau évite qu'une supposition d'hier devienne une « vérité » demain. C'est exactement l'erreur que nous avions commise en avril.
Les comportements étranges qu'il a fallu apprivoiser
Faire fonctionner une démonstration et faire un logiciel fiable sont deux choses différentes. L'écran a révélé plusieurs comportements qui, ignorés, rendaient l'ensemble instable.
L'authentification n'est acceptée qu'une fois par énumération USB. Une seconde tentative reste sans réponse, mais les images passent quand même. Nous mémorisons donc la clé bus:adresse de la dernière énumération authentifiée dans $XDG_RUNTIME_DIR : un nouveau processus sait s'il doit s'authentifier ou non. Et un timeout pendant l'authentification n'est pas traité comme une erreur fatale.
Les requêtes vendor font réénumérer l'écran. Lire les paramètres d'affichage (0xC0, requête 0x00) en mode étendu fait disparaître l'écran du bus dans la demi-seconde. Nous l'avons reproduit quatre fois. Plus tard, nous avons constaté que c'était vrai aussi après un retour au mode autonome, ce qui provoquait une boucle de reconnexion. La décision a été radicale : le mode 1280×800@60 étant fixe, la bibliothèque n'émet plus aucune requête vendor.
L'écran se réénumère 13 secondes après une énumération s'il n'a pas reçu un « vrai » flux. Une seule image ne suffit pas, quelques dizaines si. Quand on affiche une image fixe juste après une authentification, nous la réémettons donc pendant 1,5 seconde. C'est une heuristique, et elle est documentée comme telle (« non vérifiée isolément »).
Deux processus qui écrivent en même temps corrompent l'affichage. Un verrou flock sur $XDG_RUNTIME_DIR/msi-lightning-lcd.lock garantit qu'un seul processus pilote l'écran. Un second lancement échoue avec un message clair au lieu de perturber le premier.
Rendre l'écran à MSI. La requête extendedDisplay {"enable":false} est acquittée et remet le firmware en mode autonome, sans réénumération USB. C'est ce que fait lightning restore, et ce qu'on peut demander à l'arrêt du service (--on-exit restore).
Leçon n°4. Chaque comportement étrange est consigné avec sa date, ses conditions de reproduction et son statut (prouvé, constaté, heuristique). Le fichier
PROTOCOL.mddu projet est autant un journal d'enquête qu'une spécification. Ses premières sections disent ce qui marche, la fin garde l'historique des observations initiales, y compris celles qui se sont révélées fausses.
Étape 8 : du prototype Python au Rust
Le prototype Python (lcd.py, environ 600 lignes avec pyusb et Pillow) a rempli son rôle : il a permis d'itérer vite et a servi de référence. Mais l'objectif était un tableau de bord affiché en permanence, donc un service qui tourne des semaines sans surveillance. Nous l'avons réécrit en Rust pour plusieurs raisons :
- un binaire unique, sans interpréteur ni dépendances Python à installer ;
- une empreinte mémoire et CPU minime pour un processus permanent ;
- un typage strict pour un protocole où une erreur d'un octet déconnecte l'écran ;
- des tests faciles à écrire au plus près du protocole.
La réécriture a été faite à comportement identique d'abord : les tests unitaires Rust vérifient les encodages contre des valeurs produites par le prototype Python (trames BY, chiffrement RSA avec un bourrage fixé) et contre de vraies réponses capturées sur l'écran (JSON d'état, bloc signé). Le code Python est conservé dans legacy/ comme référence historique.
Le projet est découpé en crates (bibliothèques Rust) aux responsabilités nettes :
| Crate | Rôle |
|---|---|
lightning-lcd | le protocole seul : trame BY, RSA, session bulk, reconnexion |
lightning-dashboard | collecte des métriques et rendu de l'image 1280×800 |
lightning | le binaire : commandes directes, démon D-Bus, ctl, diaporama, sorties |
lightning-ipc | l'interface D-Bus partagée (noms, proxy) |
lightning-gtk | l'application GNOME de réglage |
lightning-i18n | les traductions |
La bibliothèque de protocole s'utilise en deux lignes :
let mut display = lightning_lcd::Display::open()?;
display.show_rgb(&pixels)?; // 1280 × 800 × 3 octets
Toute la complexité (bascule HID, authentification, reconnexion, verrou) est cachée derrière open().
Étape 9 : l'architecture, un démon et des clients
Afficher une image en ligne de commande, c'est bien. Changer de contenu à chaud depuis une application graphique, c'est mieux. Nous avons donc séparé celui qui parle à l'écran de ceux qui donnent des ordres.
- Le démon (
lightning daemon) est un service systemd utilisateur. C'est le seul processus qui touche au matériel. Ses réglages sont modifiables à chaud et enregistrés dans~/.config/lightning/config.toml. - Il expose une interface D-Bus sur le bus de session (
cloud.wizops.Lightning.Daemon) : des méthodes (SetMode,ShowImage,SetBrightness…) et des propriétés observables (LcdState,Mode,MeasuredFps…) avec notificationPropertiesChanged. lightning ctlpilote le démon en ligne de commande, pratique pour les scripts.- L'application « Lightning » (GTK 4 + libadwaita) ne touche jamais au matériel : elle parle au démon par D-Bus, et à systemd par son API D-Bus pour démarrer ou arrêter le service.
À l'intérieur du démon, la couche D-Bus n'est qu'un adaptateur. Le moteur (Engine) possède l'état et reçoit des demandes (Request) par un canal. Après chaque changement, il publie un PublicState dont chaque champ correspond à une propriété D-Bus. Cette séparation rend le moteur testable sans D-Bus, et garantit qu'il n'y a qu'un seul propriétaire de l'état : pas de verrous éparpillés.
Les opérations lentes ont leur propre fil d'exécution : la luminosité (chaque appel HID peut prendre plusieurs secondes, à cause de la fenêtre des 4,1 s, et seule la dernière valeur demandée est appliquée), le préchargement du diaporama, l'observation des lecteurs audio, l'import de photos.
Étape 10 : d'une métrique à un pixel
La collecte. Les métriques viennent directement du noyau, sans dépendance externe : /proc/stat pour la charge CPU (par cœur), /proc/meminfo, /proc/net/dev, les capteurs hwmon de /sys pour les températures, et NVML (la bibliothèque de NVIDIA) pour le GPU : charge, température, puissance, fréquences, VRAM, ventilateur. Le collecteur garde les relevés précédents pour calculer les débits et alimente de petits historiques affichés en courbes.
Le rendu. L'image est dessinée en mémoire avec tiny-skia (rendu 2D vectoriel) et fontdue (rastérisation de police, avec la police JetBrains Mono embarquée), sans aucune dépendance graphique système. Jauges circulaires sur 270°, barres, mini-courbes : tout est du code Rust, testable et reproductible au pixel près.
La diffusion. Chaque image est encodée une seule fois en JPEG (qualité 85 par défaut, deux images par seconde pour le tableau de bord), puis remise à plusieurs sorties :
lcd, l'écran réel ;window, une fenêtre d'aperçu sur le bureau (Wayland ou X11), avec un bandeau de debug : cadence réelle, temps de rendu et d'encodage, taille du JPEG, état de la liaison ;http, un petit serveur local qui sert un flux MJPEG, la dernière image et un/status.json;memory, qui garde la dernière image pour l'aperçu en direct dans l'application.
Chaque sortie a son propre fil et ne garde que la dernière image. Une sortie lente ou bloquée ne ralentit donc jamais les autres : si l'écran est débranché, l'aperçu continue.
La sortie lcd est une machine à états (connexion, connecté, reconnexion, absent). L'écran peut disparaître à tout moment : réénumération, câble, autre processus. La sortie se reconnecte seule et publie son état, que l'on voit dans l'application, dans le bandeau de debug et sur D-Bus.
Développer sans l'écran. C'est probablement la décision qui a le plus accéléré le développement. Avec --no-lcd --output window, tout le logiciel tourne sans toucher au matériel. Avec --demo, les métriques sont factices et déterministes. Toute l'interface peut donc être développée, testée et capturée sans risque pour la carte.
Étape 11 : au-delà du tableau de bord
Une fois le socle solide, ajouter un contenu revient à écrire une nouvelle source d'image. L'écran sait aujourd'hui afficher :
- le tableau de bord du PC, avec des panneaux à choisir et à réordonner par glisser-déposer ;
- une image ou une vidéo (décodée par
ffmpegen MJPEG) ; - un diaporama de dossiers de photos : ordre aléatoire ou chronologique (date EXIF), orientation EXIF respectée, photo entière sur fond flou, fondu enchaîné, légende. La photo suivante est décodée à l'avance. Les photos HEIC des téléphones sont prises en charge en option ;
- des photos Google Photos. Depuis le 31 mars 2025, l'API Library ne donne plus accès à la bibliothèque. Nous passons donc par la Picker API : l'utilisateur choisit ses photos dans l'interface de Google, l'application ne voit que celles-là. Le jeton est rangé dans le trousseau de la session (Secret Service), avec repli sur un fichier en mode 0600 ;
- une horloge plein écran ;
- le morceau en cours de lecture (Spotify, Rhythmbox, navigateurs…) via MPRIS, avec pochette et progression ;
- une couleur unie, ou l'animation MSI d'origine.
| Horloge | Lecture en cours |
|---|---|
![]() | ![]() |
L'application de réglage regroupe tout cela, avec un aperçu en direct de l'écran :

Étape 12 : industrialiser, comme pour n'importe quel produit
Un outil qu'on est seul à pouvoir installer n'est pas fini. Nous avons appliqué au projet les mêmes pratiques que sur nos missions DevOps.
Intégration continue. À chaque pull request et sur main : cargo fmt --check, cargo clippy -- -D warnings (aucun avertissement toléré) et cargo test, avec et sans l'option HEIC. Les 126 tests n'accèdent jamais au matériel : on ne fait pas tourner une CI sur une carte graphique à plusieurs milliers d'euros.
Releases. Chaque étiquette v* déclenche la construction des binaires, de l'archive et des sommes SHA-256. La release est créée en brouillon et n'est publiée qu'après une vérification humaine.
Paquets Linux.
- RPM Fedora en deux paquets : le démon (avec la règle udev et le service systemd utilisateur) et l'application. Les dépendances Rust sont embarquées pour une construction hors ligne, compatible COPR.
- Flatpak pour l'application seule. Le démon, qui a besoin de l'USB, reste installé sur le système, et l'application lui parle par le bus de session.
- Une archive avec un
install.shpour les autres distributions.
Pas de root. Une règle udev donne accès à l'écran (USB et hidraw de 0db0:7881 uniquement) à l'utilisateur de la session. Le démon tourne comme service systemd utilisateur.
Captures reproductibles. Les captures de la documentation (y compris celles de cet article) sont produites par un script : compositeur mutter --headless, démon en mode démonstration, faux gestionnaire systemd sur un bus D-Bus privé. Ni l'écran ni le vrai service ne sont touchés, et une capture se régénère à l'identique après chaque changement d'interface.
Traductions. L'interface, la ligne de commande et les textes dessinés sur l'écran existent en français et en anglais. Les catalogues PO sont compilés dans les binaires : rien à installer dans /usr/share/locale, ce qui simplifie les quatre modes d'installation. Un test vérifie que chaque texte marqué a sa traduction.
Fichiers de projet. CONTRIBUTING.md (avec les règles de sécurité du matériel), SECURITY.md, modèles d'issue et de pull request.
Un binôme humain et IA
Ce projet a été mené en binôme avec un agent de développement IA. La répartition des rôles s'est dessinée naturellement, et elle mérite d'être décrite parce qu'elle a beaucoup compté.
L'agent a pris en charge ce qui demande du volume et de la patience : écrire et réécrire les scripts d'exploration, analyser les réponses octet par octet, croiser les constantes avec les projets ArtInChip existants, puis écrire la bibliothèque Rust, le démon, l'application, les tests et le packaging.
L'humain a gardé ce qui ne se délègue pas :
- les yeux sur l'écran. Aucun outil ne peut dire si une image est réellement affichée : le tableau « prouvé / supposé » distingue explicitement ce qui a été « confirmé visuellement par l'utilisateur ». Le constat décisif « les images sont acceptées mais l'animation reste » est une observation humaine ;
- les décisions de risque. Ne jamais écrire en flash, ne jamais envoyer de commande inconnue : ces lignes rouges ont été fixées avant d'écrire du code et n'ont jamais été négociées ;
- le produit. Ce qu'on affiche, pour qui, et quand c'est « fini ».
Une fois le protocole compris, le passage du prototype au logiciel complet (démon, application, paquets, traductions) s'est fait en quelques jours, en petites pull requests relues et testées. La vitesse vient de l'agent ; la direction et les garde-fous, de l'humain.
Ce que nous retenons
- Observer avant d'agir. Inventaire complet, descripteurs, requêtes en lecture seule : on n'écrit qu'après avoir compris ce qu'on peut casser.
- Séparer les faits des interprétations. Nos notes d'avril mêlaient les deux, et une interprétation fausse (« HID muet ») nous a longtemps orientés dans la mauvaise direction.
- Remonter au composant d'origine. La marque sur la boîte n'est pas le fabricant de la puce. Le savoir de la communauté se trouve souvent sous un autre nom.
- Penser en temps, pas seulement en octets. Un système qui « n'écoute pas » peut simplement écouter lentement. Répéter jusqu'à convergence, filtrer les réponses périmées.
- Documenter le statut de chaque affirmation. Prouvé, constaté, heuristique, non testé : un tableau simple qui empêche les suppositions de devenir des certitudes.
- Prototyper vite, puis réécrire à comportement identique. Le Python a servi de référence exécutable ; les tests Rust le vérifient.
- Isoler le matériel. Une bibliothèque de protocole minimale, un seul processus propriétaire de l'écran, des sorties qui ne se bloquent pas, et tout le reste développable sans la carte.
- Industrialiser même un projet personnel. CI stricte, releases vérifiées, paquets, captures reproductibles : c'est ce qui transforme un « ça marche chez moi » en logiciel.
Limites et suites
- L'upload de médias dans la flash de l'écran n'est volontairement pas implémenté, et ne le sera pas.
- La rotation se fait en logiciel (0 et 180°) ; la commande
rotatedu firmware est connue mais pas utilisée. - Le retour visuel complet à l'animation MSI d'origine demande encore de couper l'alimentation de l'écran.
- Seule la Lightning Z a été testée. D'autres cartes avec un écran ArtInChip de la même famille (
0db0:7880à0db0:7919) pourraient fonctionner avec peu de changements : les retours sont les bienvenus.
Le projet lightning-lcd est un logiciel libre sous licence GPL v3, indépendant de MSI et de NVIDIA. Le code, la documentation du protocole et les paquets sont sur GitHub.
Rétro-ingénierie, diagnostic d'un système sans documentation, industrialisation d'un outil interne : c'est le quotidien de nos missions d'infogérance et d'accompagnement DevOps. Vous avez un système hérité que personne ne comprend plus, ou un outil à rendre fiable et installable ? Parlons-en.

