jetson-print-device-info
NVIDIA/skills
Captura una instantánea de referencia del modelo del módulo del dispositivo Jetson, la versión de L4T, el kernel, la versión del sistema operativo y el modo de energía para pruebas o verificación de rendimiento.
...Expandir todojetson-print-device-info
Imprime un resumen conciso del dispositivo Jetson en el que se ejecuta esta habilidad.
Esta habilidad está diseñada como un ejemplo de referencia para el repositorio jetson-device-skills y la CI (integración continua) de habilidades a nivel de NVIDIA. Se ejecuta en el destino Jetson (no en la PC host) y realiza una inspección de solo lectura, lo cual es útil como captura de línea base antes de ejecutar pruebas de rendimiento.
Propósito
Capturar una instantánea de línea base de la pila de software y el modo de energía de un destino Jetson antes de ejecutar pruebas de rendimiento, regresión o compatibilidad.
Cuándo usarla
- Al iniciar una ejecución de rendimiento y se desea capturar una línea base de la pila de software y el modo de energía del dispositivo.
- Para verificar que un Jetson recién flasheado coincide con la versión esperada de L4T / JetPack.
Requisitos previos
- Ejecutarse en un destino Jetson (no en la PC host).
- CLIs estándar disponibles:
tr,cat,uname,uptime,lsb_release(o/etc/os-release). nvpmodeldisponible para el modo de energía (opcional: la habilidad se recupera con gracia si no está disponible).
Entradas
Ninguna. La habilidad lee únicamente desde el sistema de archivos local del Jetson y las CLIs estándar.
Instrucciones
Ejecute cada paso en orden e imprima los valores capturados en el informe que se muestra a continuación, bajo Formato de salida.
Capturar el modelo del módulo y validar que es un destino Jetson; salir anticipadamente en caso contrario:```
Las cadenas del árbol de dispositivos están terminadas en nulos, por lo que se eliminan los caracteres NUL antes de imprimir.
model=$(tr -d '\0' /dev/null) case "$model" in Jetson) ;; *) echo "No se está ejecutando en un destino Jetson (modelo: '${model:-unknown}')"; exit 1 ;; esac echo "$model"
Extraer la línea de encabezado de la versión L4T; omitir el resto del archivo (lista larga de SHAs de bibliotecas):``` head -1 /etc/nv_tegra_release 2>/dev/null || echo "No se encontró información de la versión L4T"
Equivalente: grep -m1 '^# R' /etc/nv_tegra_release
Ejecutar
nvpmodel -qy unir sus dos líneas de salida (NV Power Mode: <name></name>y el número del modo) en una sola línea.paste -sdsolo utiliza el primer carácter de su delimitador, por lo que se usaawkpara insertar el separador literal/:``` nvpmodel -q 2>/dev/null | awk 'NR==1{a=$0; next} {print a" / "$0}' \ || echo "nvpmodel no disponible"Imprimir la versión del kernel y el tiempo de actividad:``` uname -r uptime -p
Imprimir la versión del sistema operativo (preferir
lsb_release, con alternativa a/etc/os-release):``` lsb_release -ds 2>/dev/null || (. /etc/os-release && echo "$PRETTY_NAME") || echo "No se encontró la versión del sistema operativo"
Formato de salida
Imprimir un informe corto con estas secciones, una línea cada una cuando sea posible:
Modelo: <árbol-de-dispositivos>
Versión L4T: <versión>
Modo de energía: <nvpmodel> / <modo>
Kernel: <uname>
Tiempo activo: <uptime>
Versión del SO: <lsb_release></lsb_release></uptime></uname></mode></nvpmodel></release></device-tree>Ejemplos
Ejemplo de salida en un kit de desarrollo Orin AGX (L4T R36 / Ubuntu 22.04):
Modelo: NVIDIA Jetson AGX Orin Developer Kit
Versión L4T: # R36 (release), REVISION: 3.0
Modo de energía: NV Power Mode: MAXN / 0
Kernel: 5.15.136-tegra
Tiempo activo: up 2 hours, 14 minutes
Versión del SO: Ubuntu 22.04.4 LTS
Ejemplo de salida en un AGX Thor (L4T R39 / Ubuntu 24.04):
Modelo: NVIDIA Jetson AGX Thor Developer Kit
Versión L4T: # R39 (release), REVISION: 0.0
Modo de energía: NV Power Mode: 120W / 1
Kernel: 6.8.0-tegra
Tiempo activo: up 12 minutes
Versión del SO: Ubuntu 24.04 LTS
Manejo de errores
Cada comando tiene una alternativa a una cadena claramente etiquetada como "... not found" / "... not available" si falta el archivo o binario subyacente; la habilidad nunca genera un error intermedio en el informe. Si falta /proc/device-tree/model o no contiene una cadena de Jetson, salir anticipadamente con un mensaje claro de "no se está ejecutando en un destino Jetson".
Limitaciones
- Inspección de solo lectura: no detecta los relojes de GPU/CPU, el estado térmico ni la energía por riel.
- El formato de salida de
nvpmodelvaría entre versiones de L4T; la habilidad lo imprime tal cual en lugar de analizarlo.
Solución de problemas
- Error:
/proc/device-tree/model: No such file or directoryCausa: Ejecutándose en una PC host, no en un destino Jetson. Solución: Ejecutar la habilidad directamente en el dispositivo Jetson (por ejemplo, mediante SSH). - Error:
nvpmodel: command not foundCausa: No se instaló el BSP de L4T o se ejecuta en un contenedor mínimo sinnvpmodel. Solución: Es esperado en entornos no Jetson o reducidos; la habilidad imprime"nvpmodel not available"y continúa.
Notas
- Solo lectura. No cambiar el modo de energía, instalar paquetes ni modificar ningún archivo.
- Si la habilidad se invoca por error en una PC host,
/proc/device-tree/modelno contendrá una cadena de modelo de Jetson; detectar eso y salir con un mensaje claro en lugar de imprimir información engañosa.
---
name: jetson-print-device-info
description: Captures a baseline snapshot of a Jetson device's module model, L4T version, kernel, OS version, and power mode for performance testing or verification.
license: Apache-2.0
---
# jetson-print-device-info
Prints a concise summary of the Jetson device this skill runs on.
This skill is intended as a reference example for the `jetson-device-skills` repo and the NVIDIA-wide skills CI. It runs on the Jetson target (not the host PC) and performs read-only inspection — useful as a baseline capture before running performance tests.
## Purpose
Capture a baseline snapshot of a Jetson target's software stack and power mode before running performance, regression, or compatibility tests.
## When to use
- Starting a performance run and you want a captured baseline of the device's software stack and power mode.
- Verifying that a freshly flashed Jetson matches an expected L4T / JetPack version.
## Prerequisites
- Running on a Jetson target (not the host PC).
- Standard CLIs available: `tr`, `cat`, `uname`, `uptime`, `lsb_release` (or `/etc/os-release`).
- `nvpmodel` available for power mode (optional — skill falls back gracefully).
## Inputs
None. The skill reads only from the local Jetson filesystem and standard CLIs.
## Instructions
Run each step in order and print the captured values into the report shown under [Output format](#output-format).
1. **Capture** the module model and **validate** it is a Jetson target — exit early otherwise:
```bash
# Device-tree strings are null-terminated, so strip NULs before printing.
model=$(tr -d '\0' < /proc/device-tree/model 2>/dev/null)
case "$model" in
*Jetson*) ;;
*) echo "Not running on a Jetson target (model: '${model:-unknown}')"; exit 1 ;;
esac
echo "$model"
```
2. **Extract** the L4T release header line — skip the rest of the file (long list of library SHAs):
```bash
head -1 /etc/nv_tegra_release 2>/dev/null || echo "L4T release info not found"
# Equivalent: grep -m1 '^# R' /etc/nv_tegra_release
```
3. **Run** `nvpmodel -q` and **join** its two output lines (`NV Power Mode: <name>` and the mode number) onto one line. `paste -sd` only uses the first char of its delimiter, so use `awk` to insert the literal ` / ` separator:
```bash
nvpmodel -q 2>/dev/null | awk 'NR==1{a=$0; next} {print a" / "$0}' \
|| echo "nvpmodel not available"
```
4. **Print** the kernel version and uptime:
```bash
uname -r
uptime -p
```
5. **Print** the OS version (prefer `lsb_release`, fall back to `/etc/os-release`):
```bash
lsb_release -ds 2>/dev/null || (. /etc/os-release && echo "$PRETTY_NAME") || echo "OS version not found"
```
## Output format
Print a short report with these sections, one line each where possible:
```text
Model: <device-tree model string>
L4T release: <release header line>
Power mode: <nvpmodel name> / <mode number>
Kernel: <uname -r>
Uptime: <uptime -p>
OS version: <lsb_release / /etc/os-release output>
```
## Examples
Example output on an Orin AGX dev kit (L4T R36 / Ubuntu 22.04):
```text
Model: NVIDIA Jetson AGX Orin Developer Kit
L4T release: # R36 (release), REVISION: 3.0
Power mode: NV Power Mode: MAXN / 0
Kernel: 5.15.136-tegra
Uptime: up 2 hours, 14 minutes
OS version: Ubuntu 22.04.4 LTS
```
Example output on an AGX Thor (L4T R39 / Ubuntu 24.04):
```text
Model: NVIDIA Jetson AGX Thor Developer Kit
L4T release: # R39 (release), REVISION: 0.0
Power mode: NV Power Mode: 120W / 1
Kernel: 6.8.0-tegra
Uptime: up 12 minutes
OS version: Ubuntu 24.04 LTS
```
## Error handling
Each command falls back to a clearly labeled `"... not found"` / `"... not available"` string if the underlying file or binary is missing — the skill never errors out mid-report. If `/proc/device-tree/model` is missing or does not contain a Jetson string, exit early with a clear "not running on a Jetson target" message.
## Limitations
- Read-only inspection only — does not detect GPU/CPU clocks, thermal state, or per-rail power.
- `nvpmodel` output format varies between L4T versions; the skill prints it verbatim rather than parsing.
## Troubleshooting
- **Error:** `/proc/device-tree/model: No such file or directory`
**Cause:** Running on a host PC, not a Jetson target.
**Solution:** Run the skill on the Jetson device directly (e.g. via SSH).
- **Error:** `nvpmodel: command not found`
**Cause:** L4T BSP not installed, or running in a minimal container without `nvpmodel`.
**Solution:** Expected on non-Jetson or stripped environments — the skill prints `"nvpmodel not available"` and continues.
## Notes
- Read-only. Do not change power mode, install packages, or modify any files.
- If the skill is invoked on a host PC by mistake, `/proc/device-tree/model` will not contain a Jetson model string — detect that and exit with a clear message rather than printing misleading info.
Todos los archivos
5 archivosInstalar jetson-print-device-info
Descarga y extrae los archivos de habilidades en tu directorio .claude/skills/.
Descargar ZIPClona el repositorio y copia los archivos de la habilidad a tu proyecto.
git clone https://github.com/NVIDIA/skills/tree/main/skills/jetson-print-device-info # Copy SKILL.md to your .claude/skills/ directory
Copiar





Hogar
