Un tableau de bord d'utilisation de Claude sur le M5Stack Basic — limites de forfait et dépenses API sur votre bureau

J’utilise Claude tous les jours, et la question que je pose le plus souvent ne porte pas sur le code. C’est « combien de ma semaine me reste-t-il ? » L’écran /usage de Claude Code y répond, mais seulement quand je m’arrête pour le taper. Je voulais la réponse sur mon bureau, comme une horloge affiche l’heure.

Le M5Stack Basic est un bon choix. C’est un appareil fini — un écran de 2 pouces 320×240, trois boutons, une batterie et un ESP32 dans un boîtier de 54 mm. Pas de plaque de prototypage, pas de soudure.

Cet article décrit le tableau de bord — ce qu’il affiche, comment les données passent de Claude à l’écran, comment l’appareil se connecte sans aucune configuration, et les étapes pour construire le vôtre. L’interface a été conçue sur le M5Stack Core dans Velxio avant de toucher le matériel, et c’est la voie que je recommande si vous voulez en construire un. Vous pouvez aussi exécuter ce firmware dans votre navigateur, sur des données de démonstration, sans l’appareil.

Le tableau de bord sur l’appareil — regardez-le sur YouTube.

Tout le code, le firmware et le pont PC, est sur GitHub sous licence MIT — velxio/m5claude. La section « Le code, partie par partie » ci-dessous détaille ce que fait chaque fichier.

Le matériel

La carte est le M5Stack Basic Core IoT Development Kit v2.7 :

• ESP32-D0WDQ6-V3, deux cœurs à 240 MHz.
• 520 Ko de SRAM et pas de PSRAM. Cette contrainte façonne le firmware.
• 16 Mo de flash.
• Un panneau IPS de 2 pouces 320×240 avec un contrôleur ILI9342C, derrière une vitre sur la v2.7.
• Trois boutons (A, B, C) sur GPIO 39, 38 et 37.
• Une puce USB-vers-série CH9102, Wi-Fi et Bluetooth LE.
• Un haut-parleur de 1 W sur GPIO 25.
• Une puce d’alimentation IP5306 avec une batterie de 110 mAh, lisible via I2C.

Rien d’autre n’est nécessaire — le tableau de bord n’utilise que ce qui est dans le boîtier. La carte n’a pas d’IMU, de microphone, de LED ni d’horloge temps réel, donc le tableau de bord utilise tout le reste — l’écran et les boutons, le haut-parleur pour les alertes, le rétroéclairage pour économiser la batterie, et la puce d’alimentation pour afficher la charge.

Ce que l’écran affiche

Le tableau de bord fonctionne avec deux types de comptes Claude, et avec plusieurs de chaque :

• Abonnements Pro et Max. Ceux-ci ont des limites d’utilisation : une fenêtre de session de 5 heures, une limite hebdomadaire, et des limites hebdomadaires par modèle. L’écran affiche chacune d’elles sous forme de pourcentage avec son heure de réinitialisation.
• Organisations API. Celles-ci paient au token, donc l’écran affiche plutôt les dépenses : aujourd’hui et les sept derniers jours, en dollars.

Pour les deux, il affiche les tokens par jour sur la dernière semaine, répartis en entrée, sortie, lectures de cache et écritures de cache, et par modèle.

Il y a quatre vues. B passe à la suivante, A et C changent de compte, un appui long sur B demande des données fraîches au PC, et un appui long sur C ouvre les réglages. Voici tous les écrans, avec l’animation que chaque vue joue à son ouverture :

Vue d’ensemble. Une carte par compte. La disposition s’adapte au nombre de comptes : un compte remplit l’écran, deux obtiennent des cartes plus hautes avec une ligne pour l’usage du jour, et trois ou plus deviennent une liste défilante.

Limites. La limite hebdomadaire sous forme d’anneau, avec la session et les limites par modèle à côté. Les noms de modèles viennent de Claude lui-même, donc les lignes suivent les limites de votre forfait. Les couleurs changent à 60 % (ambre) et 85 % (rouge).

Tokens. Aujourd’hui, les sept derniers jours, et le montant en dollars, puis les tokens par jour avec une ligne pointillée à la moyenne. Pour un abonnement, le montant en dollars est ce que les mêmes tokens coûteraient aux prix catalogue de l’API. Ce n’est pas une facturation, mais c’est un moyen utile de voir à quel point vous utilisez le forfait.

Répartition. Les tokens de la semaine par type et par modèle. Avec Claude Code, les lectures de cache représentent généralement la majeure partie du total.

Le point à côté de l’horloge indique la liaison : vert quand les données sont fraîches, ambre quand elles sont périmées, rouge quand aucun PC n’est connecté. Les photos montrent mon propre compte. Les captures d’écran utilisent des comptes de démonstration.

Batterie, son et réglages

À côté de l’horloge se trouve la batterie, dessinée comme les téléphones le font : le niveau, et un éclair avec un remplissage qui monte pendant la charge. La puce d’alimentation IP5306 ne rapporte que quatre paliers (25, 50, 75 et 100 %), donc le nombre avance par pas de 25.

Le haut-parleur sert aux alertes. Quand une limite de session ou hebdomadaire dépasse 90 % (ou 80 %, si vous le choisissez), l’appareil joue un court carillon double et indique quel compte et quelle limite. Quand une limite se réinitialise, il joue un carillon montant. Les demandes d’approbation d’un nouvel ordinateur émettent aussi un son. Les clics de bouton sont optionnels.

Un appui long sur C ouvre les réglages. A et C se déplacent, B change une valeur, et un appui long sur B ferme l’écran. Les réglages sont enregistrés sur l’appareil.

• Langue. Anglais ou espagnol. Chaque chaîne de l’écran vit dans une seule table, donc ajouter une langue revient à ajouter une entrée.
• Luminosité. 25, 50, 75 ou 100 %.
• Sons. Désactivés, alertes uniquement, ou alertes et clics de bouton.
• Alerte à. 80 %, 90 % ou désactivée.
• Écran éteint sur batterie. Jamais, après une minute ou après cinq. N’importe quel bouton le réveille, et l’appui qui le réveille ne fait rien d’autre. Avec une batterie de 110 mAh, cela compte.
• Atténuation la nuit. Baisse le rétroéclairage de 22h00 à 07h00, en utilisant l’horloge du PC.
• Ordinateurs appairés. Combien sont approuvés, et B les oublie après une confirmation.

Faire durer 110 mAh

Le premier firmware vidait la batterie en bien moins d’une heure. Le CPU tournait à 240 MHz, l’écran se redessinait chaque seconde, et la radio émettait à pleine puissance avec un intervalle de connexion de 15 à 30 ms. Rien de tout cela n’est nécessaire pour afficher un nombre qui change une fois par minute. Sur batterie, le firmware fait désormais ceci :

• CPU à 80 MHz, la vitesse la plus basse prise en charge par Bluetooth. Il repasse à 240 MHz sur alimentation USB.
• Rétroéclairage : il s’atténue après 20 secondes sans appui sur un bouton, et s’éteint après le délai choisi dans les réglages.
• Veille : 15 secondes après l’extinction de l’écran, la radio s’arrête et l’ESP32 entre en veille légère. La RAM est conservée, donc n’importe quel bouton ramène l’écran immédiatement avec les dernières données, et le pont se reconnecte en quelques secondes. Toutes les 10 minutes, un minuteur le réveille pendant jusqu’à 45 secondes, l’écran restant éteint. Il récupère des données fraîches, et si une limite a franchi le seuil d’alerte, il allume l’écran et joue l’alerte.
• Radio : 0 dBm au lieu de +9, publicité toutes les 0,5 à 1 s, et un intervalle de connexion de 100 à 200 ms avec latence esclave. Un instantané de 600 octets par minute ne demande guère plus.
• Les rafraîchissements n’ont lieu que lorsque la minute change ou que de nouvelles données arrivent, et il n’y a pas d’animations au repos sur batterie.

Pour une utilisation toute la journée loin du bureau, le Battery Module 13.2 se fixe sous le Basic et ajoute 1500 mAh.

Comment ça fonctionne

La règle de conception est que l’appareil ne sait rien. Il ne détient aucun identifiant Claude ni aucun paramètre Wi-Fi. Un petit programme sur le PC, le pont, collecte tout et envoie à l’appareil un instantané à dessiner. Cela garde les secrets hors d’un appareil posé sur un bureau, et cela signifie que changer d’ordinateur ou de réseau ne nécessite aucune reconfiguration.

D’où viennent les données

Le pont fait environ 1 100 lignes de Python avec deux dépendances (pyserial et bleak). Il lit trois sources :

1. Les limites de forfait, depuis la connexion de Claude Code. Chaque répertoire de configuration de Claude Code (~/.claude, ~/.claude-work, …) contient la connexion d’un compte. Le pont les trouve tous et utilise chaque token pour lire les mêmes limites que celles affichées par l’écran /usage de Claude Code. Il lit seulement le token et ne le rafraîchit jamais, car un rafraîchissement ferait tourner le token et déconnecterait Claude Code.
2. Les tokens, depuis les transcriptions de Claude Code. Chaque réponse que reçoit Claude Code est écrite dans un fichier JSONL sous projects/, avec son utilisation de tokens et son modèle. Le pont les additionne par jour, supprime les doublons (une session reprise copie les messages précédents dans un nouveau fichier), et les valorise avec la liste de prix de l’API.
3. Les dépenses des organisations API, depuis l’API Admin Usage and Cost. usage_report/messages donne les tokens par jour et par modèle. cost_report donne la dépense réelle. Les deux nécessitent une clé API Admin (sk-ant-admin01-...).

Deux leçons tirées de son exécution sur de vrais comptes :

• Le point de terminaison des limites est limité en débit. Pendant mes tests, il a commencé à renvoyer des HTTP 429 sans Retry-After. Le pont lit désormais les limites toutes les cinq minutes au lieu de chaque minute, conserve la dernière bonne réponse sur le disque, et continue de l’afficher pendant les erreurs temporaires. Les tokens se mettent toujours à jour chaque minute, car ils proviennent de fichiers locaux.
• Les transcriptions deviennent volumineuses. Les miennes faisaient 665 Mo. Le pont ne lit que les fichiers modifiés au cours des huit derniers jours et ne réanalyse un fichier que lorsque sa taille ou son heure de modification change. Un rafraîchissement prend environ une seconde.

L’instantané

Chaque rafraîchissement produit une ligne JSON d’environ 600 octets :

{"v":1,"ts":1792770195,"tz":3600,"acc":[
 {"n":"Personal","p":"Max 20x","k":"sub","ok":1,
  "s":[42,1792778235],"w":[67,1793037195],"x":[["Opus",54,1793037195],["Sonnet",31,1793037195]],
  "td":2840000,"tk":[2310000,1480000,15900000,1120000],"c":84.2,"ct":11.35,
  "d":[1900000,3400000,2600000,4100000,3300000,2670000,2840000],"m":[["Opus",61],["Sonnet",34],["Haiku",5]]}]}

s, w et x sont les limites de session, hebdomadaire et par modèle sous la forme [pourcentage, heure de réinitialisation]. d est le nombre de tokens par jour. ts et tz sont l’horloge du PC et son décalage UTC. Le M5Stack Basic n’a pas d’horloge temps réel ni de base de données de fuseaux horaires, donc l’appareil prend les deux depuis l’instantané et compte les secondes à partir de là. Cela suffit pour « réinitialisation dans 2h 14m » et « mar. 04:00 ».

Se connecter sans configuration

Je ne voulais aucune configuration du tout. Saisir un mot de passe Wi-Fi sur un appareil à trois boutons est désagréable. Enregistrer l’adresse IP du PC sur l’appareil casse dès que vous changez d’ordinateur. L’appareil prend donc en charge deux liaisons, et aucune ne nécessite de réglages.

USB. Branchez le câble. Le pont cherche les ports série dont la puce USB est celle d’un M5Stack (CH9102 ou CP2104). Il ouvre le port sans basculer DTR et RTS, pour que l’ESP32 ne redémarre pas, et attend un message d’accueil. Le firmware envoie {"hello":"m5claude",...} toutes les deux secondes jusqu’à ce que des données arrivent. Si aucun message d’accueil n’arrive dans les quelques secondes, le pont libère le port et le laisse tranquille un moment, pour que les autres cartes ESP32 et les outils de flashage ne soient pas affectés.

Bluetooth LE. Le firmware annonce un service GATT avec deux caractéristiques : une dans laquelle le PC écrit des lignes, et une sur laquelle l’appareil envoie des notifications. Le pont recherche l’UUID du service et se connecte. Il n’y a pas de boîte de dialogue d’appairage Windows, et rien à choisir dans une liste.

Comme n’importe quel ordinateur à portée pourrait trouver l’appareil, chaque nouveau PC est approuvé une fois, sur l’appareil :

Le pont conserve un id aléatoire dans ~/.m5claude/pc_id. L’appareil stocke les ids de jusqu’à quatre PC approuvés dans la NVS. Un PC connu est accepté immédiatement, et maintenir A à l’allumage les oublie tous. Un appareil déjà connecté en USB est ignoré en Bluetooth, pour qu’il ne soit pas invité à approuver deux fois le même PC.

Tant que le pont ne tourne pas, l’appareil affiche quoi faire :

Le firmware

Le firmware est un sketch Arduino compilé avec arduino-cli sur le cœur arduino-esp32 2.0. Il utilise trois bibliothèques :

• LovyanGFX pour dessiner l’écran.
• NimBLE-Arduino pour le Bluetooth. NimBLE utilise environ la moitié de la RAM de la pile Bluedroid par défaut.
• ArduinoJson 7 pour analyser les instantanés.

Le code de l’interface ne dépend pas du matériel. Il dessine dans une cible LovyanGFX et lit les trois boutons. Tout ce qui est spécifique à la carte (l’écran, l’USB, le BLE, la NVS) vit dans le sketch.

Quelques détails qui lui donnent l’air d’un produit plutôt que d’une démo :

• Texte anticrénelé. Les polices sont Inter, converties au format VLW lissé de LovyanGFX par un petit script Python en six tailles. Le script n’inclut que les caractères utilisés par chaque taille, environ 77 Ko au total.
• Jaunes anticrénelés. Les anneaux sont dessinés pixel par pixel : la couverture est calculée à partir de la distance aux bords de l’anneau, et les extrémités sont arrondies. Les barres et les cartes utilisent les rectangles arrondis lissés de LovyanGFX.
• Animations courtes. À chaque changement de vue, les barres et les nombres croissent vers leurs valeurs sur une demi-seconde avec une courbe d’accélération-décélération.

Dessiner sans PSRAM, et les traînées diagonales

Une image complète de 320×240 en couleur 16 bits fait 150 Ko. Le plus grand bloc de mémoire libre de l’ESP32, avec le Bluetooth en marche, est plus petit que cela. L’interface est donc dessinée quatre fois par image dans une bande de 320×60 (38 Ko). Chaque passe dessine tout décalé vers le haut de l’offset de la bande, et les parties qui tombent hors de la bande sont découpées.

La première fois que cela a tourné sur la carte, l’écran affichait des traînées diagonales, et les boutons de l’invite d’approbation apparaissaient deux fois, en haut et en bas. La configuration de l’écran était mon premier suspect. Je l’ai réécrite à la main d’après la documentation de M5Stack, et rien n’a changé. La cause était ailleurs :

LovyanGFX envoie un sprite à l’écran avec le DMA, en arrière-plan. Ma boucle commençait à dessiner la bande suivante dans le même tampon pendant que la précédente était encore en cours d’envoi, donc l’écran recevait la moitié d’une bande et la moitié de la suivante. Le correctif utilise deux tampons à tour de rôle et attend le transfert précédent avant de pousser :

for (int y = 0, k = 0; y < 240; y += 60, k ^= 1) {
  LGFX_Sprite& band = bands[k];
  band.fillScreen(BG);
  draw_ui(band, /*offset_y=*/y);   // runs while the other buffer is still being sent
  lcd.waitDMA();                    // the other buffer's transfer has finished
  band.pushSprite(&lcd, 0, y);      // starts this buffer's transfer
}
lcd.waitDMA();

Cela coûte un tampon de 38 Ko de plus, sur environ 275 Ko de RAM libre.

Le code, partie par partie

Téléchargez le code avec git clone https://github.com/velxio/m5claude.git, ou sous forme de ZIP depuis le bouton Code du dépôt. Il comporte deux moitiés qui ne partagent que le protocole : bridge/ s’exécute sur le PC, et firmware/ plus src/ s’exécutent sur le M5Stack.

Sur le M5Stack

firmware/m5claude/m5claude.ino : tout ce qui est spécifique à la carte.

• La configuration de l’écran : ILI9342C sur VSPI, ses broches, sa rotation et l’inversion des couleurs.
• La liaison USB. Elle lit le port série et écrit les réponses.
• La liaison Bluetooth. C’est un service GATT NimBLE avec une caractéristique dans laquelle le PC écrit et une sur laquelle l’appareil notifie. Les octets reçus dans les callbacks de NimBLE vont dans un tampon de flux et sont traités dans loop(), de sorte que le reste du code ne s’exécute jamais sur la tâche Bluetooth.
• La liste des PC approuvés et les réglages, conservés dans la NVS avec Preferences.
• La batterie : toutes les deux secondes, elle lit le niveau, la charge et le bit de charge complète de l’IP5306 via I2C.
• Le haut-parleur : un petit séquenceur joue les tonalités d’alerte, de réinitialisation et d’appairage avec des ondes carrées LEDC à un faible rapport cyclique, puis maintient la broche à l’état bas pour que le haut-parleur ne siffle pas entre les sons.

src/app/app.cpp : le protocole, indépendant de la liaison.

• Chaque liaison (USB ou Bluetooth) dispose de son propre tampon de ligne et de son propre état. Il analyse une ligne à chaque saut de ligne, et répète le message d’accueil toutes les deux secondes jusqu’à ce que des données arrivent.
• Une liaison non approuvée passe par une validation : l’appareil interroge l’interface, mémorise la réponse et réplique pair: ok ou denied.
• Il transforme un appui long sur B en {"req":"refresh"}.
• Il conserve une copie de l’instantané précédent, afin que l’interface puisse détecter quand une limite a franchi le seuil d’alerte ou a été réinitialisée.
• Il tient l’horloge : l’heure du dernier instantané plus les secondes écoulées depuis son arrivée.

src/model/ : les données.

• model.h décrit un compte : forfait, limites en pourcentage et heure de réinitialisation, tokens par jour, coût et modèles.
• parse.cpp remplit le modèle à partir d’un instantané avec ArduinoJson. Il analyse dans une copie séparée et ne remplace les données actuelles que si la ligne entière est valide, de sorte qu’une ligne corrompue ne peut jamais laisser l’écran à moitié mis à jour.
• mock.cpp contient les comptes de démonstration utilisés dans les captures d’écran de cet article, utiles pendant la conception.

src/ui/ : les écrans.

• ui.cpp dessine les quatre vues, les réglages et l’invite d’approbation. Il gère les boutons : un clic, ou un appui long après 650 ms. Il exécute les animations d’une demi-seconde, décide du niveau de rétroéclairage (luminosité choisie, atténuation nocturne, extinction en veille sur batterie), déclenche les alertes de limite, et effectue le rendu par bandes avec deux tampons DMA.
• i18n.h contient toutes les chaînes affichées à l’écran, en anglais et en espagnol, y compris les noms des jours de la semaine et les messages d’erreur du pont.
• gfx.h contient les couleurs et les fonctions de dessin : barres arrondies, anneau anticrénelé, et le décalage qui permet au même code de dessin de remplir n’importe quelle bande.
• fonts_gen.h contient les polices Inter. Elles sont générées par tools/make_fonts.py.

Sur le PC

Le pont se trouve dans bridge/m5claude_bridge/. Ses seules dépendances sont pyserial et bleak. Les appels HTTPS utilisent la bibliothèque standard.

__main__.py : la ligne de commande et la boucle principale.

• Les commandes sont run, snapshot, accounts, init, add-api et autostart.
• Avant de s’exécuter, il prend un verrou (un socket en écoute sur localhost), de sorte qu’un seul pont s’exécute à la fois.
• run collecte un instantané toutes les 60 secondes, ou immédiatement lorsqu’un appareil en demande un, et le transmet au hub.

autostart.py enregistre le pont pour qu’il démarre à l’ouverture de session sans fenêtre : la clé de registre Run avec pythonw sous Windows, un LaunchAgent sous macOS, une unité utilisateur systemd sous Linux.

config.py : les comptes.

• Il détecte chaque répertoire de configuration de Claude Code comportant une connexion.
• Sinon, il lit ~/.m5claude/config.json, où vous pouvez nommer les comptes et ajouter des organisations API.

sources/ : un fichier par source de données.

• subscription.py lit la connexion Claude Code d’un compte et les limites de son forfait.
• local_logs.py lit les transcriptions de Claude Code. Il analyse de manière incrémentale, supprime les messages en double, et totalise les tokens par jour et par modèle.
• admin_api.py lit l’API Admin Usage and Cost pour les organisations API, en suivant la pagination.

pricing.py contient les tarifs catalogue de l’API par famille de modèles. Il estime la valeur de l’utilisation d’un abonnement.

snapshot.py : construit l’instantané.

• Il collecte chaque compte en parallèle, de sorte qu’un compte lent ne retarde pas les autres.
• Il applique la politique de limites : toutes les cinq minutes, avec la dernière bonne réponse mise en cache sur disque et conservée en cas d’erreurs temporaires.

hub.py conserve l’instantané le plus récent et le fournit à chaque appareil connecté. Une liaison lente ne reçoit que le dernier, jamais un arriéré.

transports/ : un fichier par liaison.

• usb_serial.py trouve les puces USB du M5Stack et ne conserve un port que si le firmware l’accueille.
• ble.py scanne, se connecte, attend l’approbation, et écrit par blocs adaptés au MTU négocié.
• tcp.py est une liaison locale pour le développement.

Le README du dépôt propose le même tour d’horizon sous forme de tableaux, ainsi qu’une section de dépannage.

Créez le vôtre

L’ordre que je recommande : concevez les écrans dans Velxio, puis flashez la carte, puis connectez le pont.

1. Exécutez-le et modifiez-le sur le M5Stack Core dans Velxio

Velxio simule le M5Stack Core avec son écran 320×240, les boutons A, B et C et la puce de batterie. Aménager un écran de 2 pouces, c’est beaucoup de petits ajustements (une étiquette deux pixels trop bas, un nombre qui ne rentre pas dans sa carte), et chacun prend quelques secondes dans le navigateur au lieu d’un cycle de flashage.

Le tableau de bord se trouve dans la galerie d’exemples de Velxio, avec les mêmes fichiers sources que le dépôt :

1. Ouvrez M5Stack Core: Claude usage dashboard (m5claude) et cliquez sur le bouton de lecture. Aucune inscription n’est nécessaire. Il démarre sur les comptes de démonstration de cet article.
2. Cliquez sur A et C pour choisir un compte et sur B pour parcourir les vues. Le simulateur exécute le firmware plus lentement que la carte, donc pour ouvrir les paramètres, maintenez C pendant quelques secondes.
3. Pour voir vos propres chiffres, exécutez m5claude-bridge snapshot sur votre PC et collez la ligne qu’il affiche dans le moniteur série. Le premier commentaire du sketch contient un exemple de ligne que vous pouvez modifier.
4. Modifiez les écrans dans ui.cpp et relancez. Quand ils vous conviennent, flashez la carte.

Deux choses diffèrent de la carte : Velxio n’a pas de Bluetooth, donc cette liaison est omise et le moniteur série est la seule liaison, et le code du haut-parleur utilise les appels du noyau ESP32 Arduino plus récent. Chaque changement est signalé dans le sketch.

Pour démarrer votre propre tableau de bord à partir d’un écran vide, M5Stack Core: Hello LCD + Buttons est l’exemple le plus simple. Il utilise M5GFX de M5Stack, qui est construit sur LovyanGFX et partage son API de dessin, donc le code passe de l’un à l’autre.

2. Flashez le firmware

git clone https://github.com/velxio/m5claude.git && cd m5claude
arduino-cli core install esp32:esp32
arduino-cli lib install LovyanGFX NimBLE-Arduino ArduinoJson

./firmware/build.sh /dev/ttyUSB0      # Linux / macOS
.\firmware\build.ps1 -Upload          # Windows, finds the COM port by itself

Les scripts compilent pour le M5Stack Core avec un schéma de partitions qui laisse de la place pour une grande application (PartitionScheme=no_ota). Le firmware fait environ 820 Ko. Deux réglages m’ont posé problème :

• C++17. Le noyau arduino-esp32 2.0 compile en C++11 par défaut, et le code utilise des fonctionnalités de C++14 et C++17. Ajoutez --build-property "compiler.cpp.extra_flags=-std=gnu++17".
• Le panneau. Je configure l’ILI9342C explicitement (VSPI, MOSI 23, MISO 19, SCK 18, CS 14, DC 27, RST 33, rétroéclairage 32, offset_rotation = 3) au lieu d’utiliser l’autodétection de carte de LovyanGFX. Le panneau IPS du v2.7 nécessite des couleurs inversées. Il est détecté de la même manière que les bibliothèques de M5Stack le font : via la façon dont la ligne de reset est relue.

3. Lancez le pont

pip install -e bridge                # from the repository root; installs pyserial and bleak
m5claude-bridge accounts             # which accounts it found
m5claude-bridge autostart on         # start now, and at every login

autostart on enregistre le pont pour qu’il démarre à votre connexion, sans fenêtre. Sous Windows, il ajoute une valeur sous la clé de registre Run de l’utilisateur qui lance pythonw. Sous macOS, il installe un LaunchAgent, et sous Linux un service utilisateur systemd. autostart status indique s’il est en cours d’exécution et les dernières lignes de son journal, dans ~/.m5claude/bridge.log. Un seul pont s’exécute à la fois : un second entrerait en concurrence pour le port USB et la connexion Bluetooth, il se termine donc avec un message. Lancer m5claude-bridge seul le maintient au premier plan, avec le journal dans le terminal.

Les comptes Pro et Max sont trouvés à partir des répertoires de configuration de Claude Code. Pour ajouter un second abonnement, connectez-le sous son propre répertoire :

$env:CLAUDE_CONFIG_DIR = "$HOME\.claude-work"; claude    # then /login

Les organisations API nécessitent une clé Admin API, depuis la Claude Console sous Settings → Admin keys :

m5claude-bridge add-api "Acme API" --key-env ACME_ADMIN_KEY

4. Connectez

Branchez le câble USB, ou laissez l’appareil sur le bureau et laissez le Bluetooth le trouver. La première fois en Bluetooth, appuyez sur C sur l’appareil pour approuver le PC. Les données apparaissent en quelques secondes.

Mises en garde

• Le point de terminaison des limites de forfait n’est pas une API publique. C’est le point de terminaison utilisé par l’écran /usage de Claude Code, et il pourrait changer. Le pont se rabat sur des noms de champs plus anciens, mais un changement de format nécessiterait une mise à jour.
• Les connexions expirent. Claude Code rafraîchit son token lorsque vous l’utilisez. Un compte que vous n’avez pas utilisé depuis quelques heures affiche « Login expired » jusqu’à ce que Claude Code s’exécute à nouveau avec lui.
• Le montant en dollars pour les abonnements est une estimation aux prix catalogue de l’API. Les organisations API affichent leurs dépenses réelles à partir du rapport de coûts.

Et ensuite

• Une icône dans la barre d’état du PC indiquant l’état de la liaison.
• Un historique sur la carte microSD, pour des graphiques de plus de sept jours.
• Une LED RGB sur le port Grove qui passe au rouge au-delà de 90 %, visible depuis l’autre bout de la pièce.
• Une liaison Wi-Fi optionnelle, configurée depuis le pont via USB ou Bluetooth, pour que l’appareil puisse se trouver dans une autre pièce.

Le code est sur github.com/velxio/m5claude. Les issues et les pull requests sont les bienvenues.

Merci à M5Stack pour une carte prête à l’emploi dès la sortie de la boîte, et aux auteurs de LovyanGFX, NimBLE-Arduino, ArduinoJson et bleak.

Les liens vers la boutique M5Stack sur cette page sont des liens d’affiliation : si vous achetez par leur intermédiaire, Velxio perçoit une petite commission sans coût supplémentaire pour vous, et cela aide à garder le simulateur gratuit.