Un panel de uso de Claude en el M5Stack Basic: límites del plan y gasto de API en tu escritorio

Uso Claude todos los días, y la pregunta que más me hago no es sobre código. Es “¿cuánto me queda de semana?”. La pantalla /usage de Claude Code la responde, pero solo cuando me paro a escribirla. Quería la respuesta en mi escritorio, como un reloj muestra la hora.

El M5Stack Basic encaja bien. Es un dispositivo terminado: una pantalla de 2 pulgadas y 320×240, tres botones, una batería y un ESP32 en una carcasa de 54 mm. Sin protoboard, sin soldaduras.

Este artículo describe el panel: qué muestra, cómo llegan los datos de Claude a la pantalla, cómo se conecta el dispositivo sin ninguna configuración y los pasos para construir el tuyo. La interfaz se diseñó en el M5Stack Core en Velxio antes de tocar el hardware, y esa es la ruta que recomiendo si quieres construir uno. También puedes ejecutar este firmware en tu navegador, con datos de demostración, sin el dispositivo.

El panel en el dispositivo: míralo en YouTube.

Todo el código, el firmware y el puente en el PC, está en GitHub bajo la licencia MIT: velxio/m5claude. La sección “El código, parte por parte” de más abajo repasa qué hace cada archivo.

El hardware

La placa es el M5Stack Basic Core IoT Development Kit v2.7:

• ESP32-D0WDQ6-V3, dos núcleos a 240 MHz.
• 520 KB de SRAM y sin PSRAM. Esa restricción condiciona el firmware.
• 16 MB de flash.
• Un panel IPS de 2 pulgadas y 320×240 con controlador ILI9342C, tras cristal en la v2.7.
• Tres botones (A, B, C) en GPIO 39, 38 y 37.
• Un chip USB a serie CH9102, Wi-Fi y Bluetooth LE.
• Un altavoz de 1 W en GPIO 25.
• Un chip de alimentación IP5306 con una batería de 110 mAh, legible por I2C.

No hace falta nada más: el panel usa solo lo que viene en la carcasa. La placa no tiene IMU, micrófono, LEDs ni reloj en tiempo real, así que el panel usa todo lo demás: la pantalla y los botones, el altavoz para las alertas, la retroiluminación para ahorrar batería y el chip de alimentación para mostrar la carga.

Qué muestra la pantalla

El panel funciona con dos tipos de cuentas de Claude, y con varias de cada uno:

• Suscripciones Pro y Max. Tienen límites de uso: una ventana de sesión de 5 horas, un límite semanal y límites semanales por modelo. La pantalla muestra cada uno como un porcentaje con su hora de reinicio.
• Organizaciones de API. Pagan por token, así que la pantalla muestra el gasto en su lugar: hoy y los últimos siete días, en dólares.

Para ambos, muestra los tokens por día de la última semana, desglosados en entrada, salida, lecturas de caché y escrituras de caché, y por modelo.

Hay cuatro vistas. B pasa a la siguiente, A y C cambian entre cuentas, mantener pulsado B pide datos nuevos al PC y mantener pulsado C abre los ajustes. Estas son todas las pantallas, con la animación que reproduce cada vista al abrirse:

Vista general. Una tarjeta por cuenta. El diseño se adapta a cuántas cuentas hay: una cuenta llena la pantalla, dos tienen tarjetas más altas con una fila para el uso de hoy, y tres o más se convierten en una lista desplazable.

Límites. El límite semanal como un anillo, con la sesión y los límites por modelo al lado. Los nombres de los modelos vienen del propio Claude, así que las filas siguen los límites que tenga tu plan. Los colores cambian al 60% (ámbar) y al 85% (rojo).

Tokens. Hoy, los últimos siete días y la cifra en dólares, y luego los tokens por día con una línea discontinua en la media. Para una suscripción, la cifra en dólares es lo que costarían esos mismos tokens a los precios de lista de la API. No es un cargo, pero es una forma útil de ver con qué intensidad usas el plan.

Desglose. Los tokens de la semana por tipo y por modelo. Con Claude Code, las lecturas de caché suelen ser la mayor parte del total.

El punto junto al reloj muestra el enlace: verde mientras los datos están frescos, ámbar cuando están desactualizados, rojo cuando no hay ningún PC conectado. Las fotos muestran mi propia cuenta. Las capturas usan cuentas de demostración.

Batería, sonido y ajustes

Junto al reloj está la batería, dibujada como la dibujan los teléfonos: el nivel, y un rayo con un relleno que sube mientras carga. El chip de alimentación IP5306 solo informa de cuatro pasos (25, 50, 75 y 100%), así que el número avanza en pasos de 25.

El altavoz se usa para las alertas. Cuando una sesión o un límite semanal supera el 90% (o el 80%, si lo eliges), el dispositivo reproduce un breve doble timbre y muestra qué cuenta y qué límite. Cuando un límite se reinicia, reproduce un timbre ascendente. Las solicitudes de aprobación de un ordenador nuevo también suenan. Los clics de los botones son opcionales.

Mantener pulsado C abre los ajustes. A y C se mueven, B cambia un valor y mantener pulsado B cierra la pantalla. Los ajustes se guardan en el dispositivo.

• Idioma. Inglés o español. Cada texto de la pantalla vive en una sola tabla, así que añadir un idioma es una entrada más.
• Brillo. 25, 50, 75 o 100%.
• Sonidos. Desactivados, solo alertas, o alertas y clics de botones.
• Alerta al. 80%, 90% o desactivada.
• Apagar pantalla con batería. Nunca, tras un minuto o tras cinco. Cualquier botón la despierta, y la pulsación que la despierta no hace nada más. Con una batería de 110 mAh, esto importa.
• Atenuar de noche. Baja la retroiluminación de 22:00 a 07:00, usando el reloj del PC.
• Ordenadores emparejados. Cuántos están aprobados, y B los olvida tras una confirmación.

Hacer que 110 mAh duren

El primer firmware agotaba la batería en bastante menos de una hora. La CPU iba a 240 MHz, la pantalla se repintaba cada segundo y la radio transmitía a plena potencia con un intervalo de conexión de 15–30 ms. Nada de eso hace falta para mostrar un número que cambia una vez por minuto. Con batería, el firmware ahora hace esto:

• CPU a 80 MHz, la velocidad más baja que admite Bluetooth. Vuelve a 240 MHz con alimentación por USB.
• Retroiluminación: se atenúa tras 20 segundos sin pulsar un botón, y se apaga tras el tiempo elegido en los ajustes.
• Reposo: 15 segundos después de que se apague la pantalla, la radio se apaga y el ESP32 entra en sueño ligero. La RAM se conserva, así que cualquier botón devuelve la pantalla al instante con los últimos datos, y el puente se reconecta en segundos. Cada 10 minutos un temporizador lo despierta hasta 45 segundos con la pantalla aún apagada. Obtiene datos nuevos y, si un límite cruzó el umbral de alerta, enciende la pantalla y reproduce la alerta.
• Radio: 0 dBm en lugar de +9, anunciando cada 0,5–1 s, y un intervalo de conexión de 100–200 ms con latencia esclava. Una instantánea de 600 bytes por minuto necesita poco más.
• Los repintados ocurren solo cuando cambia el minuto o llegan datos nuevos, y no hay animaciones inactivas con batería.

Para un uso de todo el día lejos del escritorio, el Battery Module 13.2 se apila debajo del Basic y añade 1500 mAh.

Cómo funciona

La regla de diseño es que el dispositivo no sabe nada. No guarda credenciales de Claude ni ajustes de Wi-Fi. Un pequeño programa en el PC, el puente, lo recopila todo y envía al dispositivo una instantánea para dibujar. Así los secretos no están en un dispositivo que descansa sobre un escritorio, y cambiar de ordenador o de red no requiere reconfigurar nada.

De dónde vienen los datos

El puente son unas 1.100 líneas de Python con dos dependencias (pyserial y bleak). Lee tres fuentes:

1. Límites del plan, desde el inicio de sesión de Claude Code. Cada directorio de configuración de Claude Code (~/.claude, ~/.claude-work, …) guarda el inicio de sesión de una cuenta. El puente los encuentra todos y usa cada token para leer los mismos límites que muestra la pantalla /usage de Claude Code. Solo lee el token y nunca lo renueva, porque renovarlo rotaría el token y cerraría la sesión de Claude Code.
2. Tokens, desde las transcripciones de Claude Code. Cada respuesta que recibe Claude Code se escribe en un archivo JSONL dentro de projects/, con su uso de tokens y su modelo. El puente los suma por día, elimina duplicados (una sesión reanudada copia mensajes anteriores a un archivo nuevo) y les asigna precio con la lista de precios de la API.
3. Gasto de las organizaciones de API, desde la Usage and Cost Admin API. usage_report/messages da los tokens por día y modelo. cost_report da el gasto real. Ambas necesitan una clave de Admin API (sk-ant-admin01-...).

Dos lecciones de ejecutarlo contra cuentas reales:

• El endpoint de límites tiene límite de peticiones. Mientras probaba, empezó a devolver HTTP 429 sin Retry-After. Ahora el puente lee los límites cada cinco minutos en lugar de cada minuto, guarda la última respuesta buena en disco y la sigue mostrando durante errores temporales. Los tokens se siguen actualizando cada minuto, porque vienen de archivos locales.
• Las transcripciones se hacen grandes. Las mías eran de 665 MB. El puente solo lee los archivos modificados en los últimos ocho días y vuelve a analizar un archivo solo cuando cambia su tamaño o su fecha de modificación. Una actualización tarda alrededor de un segundo.

La instantánea

Cada actualización produce una línea JSON de unos 600 bytes:

{"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 y x son los límites de sesión, semanal y por modelo como [porcentaje, hora de reinicio]. d son los tokens por día. ts y tz son el reloj del PC y su desfase UTC. El M5Stack Basic no tiene reloj en tiempo real ni base de datos de zonas horarias, así que el dispositivo toma ambos de la instantánea y cuenta los segundos a partir de ahí. Eso basta para “se reinicia en 2h 14m” y “mar 04:00”.

Conectar sin configuración

Quería que no hubiera que configurar nada. Escribir una contraseña de Wi-Fi en un dispositivo con tres botones es desagradable. Guardar la dirección IP del PC en el dispositivo deja de funcionar en cuanto cambias de ordenador. Así que el dispositivo admite dos enlaces, y ninguno necesita ajustes.

USB. Enchufa el cable. El puente busca puertos serie cuyo chip USB sea de un M5Stack (CH9102 o CP2104). Abre el puerto sin conmutar DTR y RTS, para que el ESP32 no se reinicie, y espera un saludo. El firmware envía {"hello":"m5claude",...} cada dos segundos hasta que llegan datos. Si no llega ningún saludo en unos segundos, el puente libera el puerto y lo deja tranquilo un rato, para no afectar a otras placas ESP32 ni a herramientas de flasheo.

Bluetooth LE. El firmware anuncia un servicio GATT con dos características: una en la que el PC escribe líneas y otra en la que el dispositivo envía notificaciones. El puente busca el UUID del servicio y se conecta. No hay diálogo de emparejamiento de Windows ni nada que elegir de una lista.

Como cualquier ordenador dentro del alcance podría encontrar el dispositivo, cada PC nuevo se aprueba una vez, en el dispositivo:

El puente guarda un id aleatorio en ~/.m5claude/pc_id. El dispositivo almacena en NVS los ids de hasta cuatro PCs aprobados. Un PC conocido se acepta al instante, y mantener pulsado A al encender olvida todos. Un dispositivo que ya está conectado por USB se omite en Bluetooth, para no pedirle que apruebe dos veces el mismo PC.

Hasta que el puente está en marcha, el dispositivo muestra qué hacer:

El firmware

El firmware es un sketch de Arduino compilado con arduino-cli sobre el core arduino-esp32 2.0. Usa tres librerías:

• LovyanGFX para dibujar la pantalla.
• NimBLE-Arduino para Bluetooth. NimBLE usa aproximadamente la mitad de RAM que la pila Bluedroid por defecto.
• ArduinoJson 7 para analizar las instantáneas.

El código de la interfaz no depende del hardware. Dibuja sobre un destino de LovyanGFX y lee los tres botones. Todo lo específico de la placa (el panel, USB, BLE, NVS) vive en el sketch.

Algunos detalles que hacen que parezca un producto y no una demo:

• Texto con antialiasing. Las fuentes son Inter, convertidas al formato suave VLW de LovyanGFX por un pequeño script de Python en seis tamaños. El script incluye solo los caracteres que usa cada tamaño, unos 77 KB en total.
• Indicadores con antialiasing. Los anillos se dibujan píxel a píxel: la cobertura se calcula a partir de la distancia a los bordes del anillo, y los extremos son redondeados. Las barras y las tarjetas usan los rectángulos redondeados suaves de LovyanGFX.
• Animaciones breves. En cada cambio de vista, las barras y los números crecen hasta sus valores en medio segundo con una curva de desaceleración.

Dibujar sin PSRAM, y las rayas diagonales

Un fotograma completo de 320×240 en color de 16 bits son 150 KB. El mayor bloque de memoria libre del ESP32, con Bluetooth en marcha, es menor que eso. Así que la interfaz se dibuja cuatro veces por fotograma en una banda de 320×60 (38 KB). Cada pasada dibuja todo desplazado por el desfase de la banda, y las partes que caen fuera de la banda se recortan.

La primera vez que esto se ejecutó en la placa, la pantalla mostró rayas diagonales, y los botones del aviso de aprobación aparecieron dos veces, arriba y abajo. La configuración del panel fue mi primera sospecha. La reescribí a mano a partir de la documentación de M5Stack, y nada cambió. La causa estaba en otro sitio:

LovyanGFX envía un sprite al panel con DMA, en segundo plano. Mi bucle empezaba a dibujar la siguiente banda en el mismo búfer mientras la anterior todavía se estaba enviando, así que el panel recibía la mitad de una banda y la mitad de la siguiente. La solución usa dos búferes por turnos y espera a la transferencia anterior antes de enviar:

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();

Cuesta un búfer más de 38 KB, de unos 275 KB de RAM libre.

El código, parte por parte

Descarga el código con git clone https://github.com/velxio/m5claude.git, o como ZIP desde el botón Code del repositorio. Tiene dos mitades que no comparten nada salvo el protocolo: bridge/ se ejecuta en el PC, y firmware/ más src/ se ejecutan en el M5Stack.

En el M5Stack

firmware/m5claude/m5claude.ino: todo lo específico de la placa.

• La configuración del panel: ILI9342C en VSPI, sus pines, la rotación y la inversión de color.
• El enlace USB. Lee el puerto serie y escribe las respuestas.
• El enlace Bluetooth. Es un servicio GATT de NimBLE con una característica en la que escribe el PC y otra sobre la que el dispositivo notifica. Los bytes recibidos en los callbacks de NimBLE van a un búfer de flujo y se procesan en loop(), así que el resto del código nunca se ejecuta en la tarea de Bluetooth.
• La lista de PCs aprobados y los ajustes, guardados en NVS con Preferences.
• La batería: cada dos segundos lee por I2C los bits de nivel, carga y carga completa del IP5306.
• El altavoz: un pequeño secuenciador reproduce los tonos de alerta, reinicio y emparejamiento con ondas cuadradas de LEDC a un ciclo de trabajo bajo, y luego mantiene el pin en bajo para que el altavoz no sisee entre sonidos.

src/app/app.cpp: el protocolo, independiente del enlace.

• Cada enlace (USB o Bluetooth) tiene su propio búfer de línea y su estado. Analiza una línea en cada salto de línea, y repite el saludo cada dos segundos hasta que llegan datos.
• Un enlace no confiable pasa por aprobación: el dispositivo pregunta a la interfaz, recuerda la respuesta y contesta pair: ok o denied.
• Convierte una pulsación larga de B en {"req":"refresh"}.
• Guarda una copia de la instantánea anterior, para que la interfaz pueda saber cuándo un límite cruzó el umbral de alerta o se reinició.
• Lleva el reloj: la hora de la última instantánea más los segundos transcurridos desde que llegó.

src/model/: los datos.

• model.h describe una cuenta: plan, límites en porcentaje y hora de reinicio, tokens por día, coste y modelos.
• parse.cpp rellena el modelo a partir de una instantánea con ArduinoJson. Analiza en una copia aparte y sustituye los datos actuales solo si la línea entera es válida, así que una línea corrupta nunca puede dejar la pantalla a medio actualizar.
• mock.cpp tiene las cuentas de demostración usadas en las capturas de este artículo, útiles durante el diseño.

src/ui/: las pantallas.

• ui.cpp dibuja las cuatro vistas, los ajustes y el aviso de aprobación. Gestiona los botones: una pulsación, o una pulsación larga tras 650 ms. Ejecuta las animaciones de medio segundo, decide el nivel de la retroiluminación (brillo elegido, atenuación nocturna, apagado cuando está inactivo con batería), lanza las alertas de límite y renderiza por bandas con dos búferes de DMA.
• i18n.h contiene todas las cadenas de la pantalla, en inglés y español, incluidos los nombres de los días de la semana y los mensajes de error del puente.
• gfx.h contiene los colores y los ayudantes de dibujo: barras redondeadas, el anillo con antialiasing y el desplazamiento que permite que el mismo código de dibujo rellene cualquier banda.
• fonts_gen.h contiene las fuentes Inter. Las genera tools/make_fonts.py.

En el PC

El puente vive en bridge/m5claude_bridge/. Sus únicas dependencias son pyserial y bleak. Las llamadas HTTPS usan la biblioteca estándar.

__main__.py: la línea de comandos y el bucle principal.

• Los comandos son run, snapshot, accounts, init, add-api y autostart.
• Antes de ejecutarse, toma un bloqueo (un socket a la escucha en localhost), así que solo se ejecuta un puente a la vez.
• run recopila una instantánea cada 60 segundos, o inmediatamente cuando un dispositivo pide una, y se la entrega al hub.

autostart.py registra el puente para que se inicie al iniciar sesión sin ventana: la clave de registro Run con pythonw en Windows, un LaunchAgent en macOS, una unidad de usuario de systemd en Linux.

config.py: las cuentas.

• Detecta cada directorio de configuración de Claude Code con un inicio de sesión.
• Como alternativa, lee ~/.m5claude/config.json, donde puedes nombrar cuentas y añadir organizaciones de API.

sources/: un archivo por fuente de datos.

• subscription.py lee el inicio de sesión de Claude Code de una cuenta y los límites de su plan.
• local_logs.py lee las transcripciones de Claude Code. Analiza de forma incremental, elimina los mensajes duplicados y totaliza los tokens por día y por modelo.
• admin_api.py lee la Usage and Cost Admin API para las organizaciones de API, siguiendo la paginación.

pricing.py contiene los precios de lista de la API por familia de modelos. Estima el valor del uso de la suscripción.

snapshot.py: construye la instantánea.

• Recopila cada cuenta en paralelo, así que una cuenta lenta no retrasa al resto.
• Aplica la política de límites: cada cinco minutos, con la última respuesta buena en caché en disco y conservada durante los errores temporales.

hub.py guarda la instantánea más reciente y se la da a cada dispositivo conectado. Un enlace lento solo recibe la última, nunca un acumulado.

transports/: un archivo por enlace.

• usb_serial.py encuentra los chips USB del M5Stack y solo conserva un puerto si el firmware lo saluda.
• ble.py escanea, conecta, espera la aprobación y escribe en fragmentos que caben en el MTU negociado.
• tcp.py es un enlace local para desarrollo.

El README del repositorio tiene el mismo recorrido en tablas, además de la solución de problemas.

Crea el tuyo

El orden que recomiendo: diseña las pantallas en Velxio, luego flashea la placa y después conecta el puente.

1. Ejecútalo y modifícalo en el M5Stack Core en Velxio

Velxio simula el M5Stack Core con su pantalla de 320×240, los botones A, B y C y el chip de batería. Maquetar una pantalla de 2 pulgadas implica muchos ajustes pequeños (una etiqueta dos píxeles más abajo, un número que no cabe en su tarjeta), y cada uno lleva segundos en el navegador en lugar de un ciclo de flasheo.

El panel está en la galería de ejemplos de Velxio, con los mismos archivos fuente que el repositorio:

1. Abre M5Stack Core: Claude usage dashboard (m5claude) y haz clic en el botón de reproducir. No hace falta registrarse. Arranca con las cuentas de demostración de este artículo.
2. Haz clic en A y C para elegir una cuenta y en B para recorrer las vistas. El simulador ejecuta el firmware más lento que la placa, así que para abrir los ajustes, mantén pulsado C unos segundos.
3. Para ver tus propios números, ejecuta m5claude-bridge snapshot en tu PC y pega la línea que imprime en el monitor serie. El primer comentario del sketch tiene una línea de ejemplo que puedes editar.
4. Cambia las pantallas en ui.cpp y vuelve a ejecutar. Cuando se vean bien, flashea la placa.

Dos cosas difieren de la placa: Velxio no tiene Bluetooth, así que ese enlace se omite y el monitor serie es el único enlace, y el código del altavoz usa las llamadas del core de ESP32 Arduino más reciente. Cada cambio está marcado en el sketch.

Para empezar un panel propio desde una pantalla vacía, M5Stack Core: Hello LCD + Buttons es el ejemplo más pequeño. Usa M5GFX de M5Stack, que está construido sobre LovyanGFX y comparte su API de dibujo, así que el código se mueve entre los dos.

2. Flashea el 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

Los scripts compilan para el M5Stack Core con un esquema de particiones que deja espacio para una app grande (PartitionScheme=no_ota). El firmware ocupa unos 820 KB. Dos ajustes me pillaron por sorpresa:

• C++17. El core arduino-esp32 2.0 compila como C++11 por defecto, y el código usa características de C++14 y C++17. Añade --build-property "compiler.cpp.extra_flags=-std=gnu++17".
• El panel. Configuro el ILI9342C explícitamente (VSPI, MOSI 23, MISO 19, SCK 18, CS 14, DC 27, RST 33, retroiluminación 32, offset_rotation = 3) en lugar de usar la autodetección de placa de LovyanGFX. El panel IPS del v2.7 necesita colores invertidos. Se detecta igual que lo hacen las propias librerías de M5Stack: a través de cómo se lee la línea de reset.

3. Ejecuta el puente

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 registra el puente para que se inicie al iniciar sesión, sin ventana. En Windows añade un valor bajo la clave de registro Run del usuario que lanza pythonw. En macOS instala un LaunchAgent, y en Linux un servicio de usuario de systemd. autostart status muestra si está en ejecución y las últimas líneas de su log, en ~/.m5claude/bridge.log. Solo se ejecuta un puente a la vez: un segundo competiría por el puerto USB y la conexión Bluetooth, así que sale con un mensaje. Ejecutar m5claude-bridge por sí solo lo mantiene en primer plano, con el log en la terminal.

Las cuentas Pro y Max se encuentran a partir de los directorios de configuración de Claude Code. Para añadir una segunda suscripción, iníciala bajo su propio directorio:

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

Las organizaciones de API necesitan una clave de Admin API, desde la Claude Console en Settings → Admin keys:

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

4. Conecta

Enchufa el cable USB, o deja el dispositivo en el escritorio y deja que Bluetooth lo encuentre. La primera vez por Bluetooth, pulsa C en el dispositivo para aprobar el PC. Los datos aparecen en unos segundos.

Advertencias

• El endpoint de límites del plan no es una API pública. Es el endpoint que usa la pantalla /usage de Claude Code, y podría cambiar. El puente recurre a nombres de campo más antiguos, pero un cambio de formato requeriría una actualización.
• Los inicios de sesión caducan. Claude Code renueva su token cuando lo usas. Una cuenta que no has usado durante unas horas muestra “Login expired” hasta que Claude Code se ejecuta con ella de nuevo.
• La cifra en dólares para las suscripciones es una estimación a los precios de lista de la API. Las organizaciones de API muestran su gasto real del informe de costes.

Qué viene después

• Un icono en la bandeja del PC que muestre el estado del enlace.
• Un historial en la tarjeta microSD, para gráficos de más de siete días.
• Un LED RGB en el puerto Grove que se ponga rojo al pasar del 90%, visible desde el otro lado de la habitación.
• Un enlace Wi-Fi opcional, configurado desde el puente por USB o Bluetooth, para que el dispositivo pueda estar en otra habitación.

El código está en github.com/velxio/m5claude. Las issues y pull requests son bienvenidas.

Gracias a M5Stack por una placa que está lista para usar nada más sacarla de la caja, y a los autores de LovyanGFX, NimBLE-Arduino, ArduinoJson y bleak.

Los enlaces a la tienda de M5Stack en esta página son enlaces de afiliado: si compras a través de ellos, Velxio gana una pequeña comisión sin coste adicional para ti, y ayuda a mantener el simulador gratuito.