option
MaisonMaison Skill DevOps et CI/CD jetson-print-device-info

jetson-print-device-info

NVIDIA/skills NVIDIA/skills

Capture un instantané de référence du modèle de module d'un appareil Jetson, de la version L4T, du noyau, de la version du système d'exploitation et du mode d'alimentation pour les tests ou la vérification des performances.

...Développer tout
0
Heure mise à jour 27 septembre 2026

jetson-print-device-info

Affiche un résumé concis des informations de l'appareil Jetson sur lequel cette compétence s'exécute.

Cette compétence est conçue comme un exemple de référence pour le dépôt jetson-device-skills et l'intégration continue (CI) des compétences à l'échelle de NVIDIA. Elle s'exécute sur la cible Jetson (et non sur le PC hôte) et effectue une inspection en lecture seule — utile pour capturer un état de référence avant d'exécuter des tests de performance.

Objectif

Capturer un instantané de référence de la pile logicielle et du mode d'alimentation d'une cible Jetson avant d'exécuter des tests de performance, de régression ou de compatibilité.

Quand l'utiliser

  • Au démarrage d'une exécution de performance, lorsque vous souhaitez capturer un état de référence de la pile logicielle et du mode d'alimentation de l'appareil.
  • Pour vérifier qu'une Jetson fraîchement flashée correspond à la version L4T / JetPack attendue.

Prérequis

  • S'exécuter sur une cible Jetson (et non sur le PC hôte).
  • Outils en ligne de commande (CLI) standard disponibles : tr, cat, uname, uptime, lsb_release (ou /etc/os-release).
  • nvpmodel disponible pour le mode d'alimentation (facultatif — la compétence gère le cas d'échec avec élégance).

Entrées

Aucune. La compétence lit uniquement depuis le système de fichiers local de la Jetson et les outils CLI standard.

Instructions

Exécutez chaque étape dans l'ordre et imprimez les valeurs capturées dans le rapport affiché sous la section Format de sortie.

  1. Capturer le modèle du module et valider qu'il s'agit bien d'une cible Jetson — quitter prématurément dans le cas contraire :```

    Les chaînes de l'arbre de périphériques sont terminées par des caractères NUL, il faut donc les supprimer avant l'impression.

    model=$(tr -d '\0' /dev/null) case "$model" in Jetson) ;; *) echo "Exécution sur une cible Jetson (modèle : '${model:-inconnu}')"; exit 1 ;; esac echo "$model"

  2. Extraire la ligne d'en-tête de la version L4T — ignorer le reste du fichier (longue liste de hachages SHA des bibliothèques) :``` head -1 /etc/nv_tegra_release 2>/dev/null || echo "Informations de version L4T non trouvées"

    Équivalent : grep -m1 '^# R' /etc/nv_tegra_release

  3. Exécuter nvpmodel -q et joindre ses deux lignes de sortie (Mode d'alimentation NV : <nom></nom> et le numéro du mode) sur une seule ligne. paste -sd n'utilise que le premier caractère de son délimiteur, utilisez donc awk pour insérer le séparateur littéral / :``` nvpmodel -q 2>/dev/null | awk 'NR==1{a=$0; next} {print a" / "$0}' \ || echo "nvpmodel non disponible"

  4. Imprimer la version du noyau et le temps de fonctionnement :``` uname -r uptime -p

  5. Imprimer la version du système d'exploitation (préférer lsb_release, revenir à /etc/os-release en cas d'échec) :``` lsb_release -ds 2>/dev/null || (. /etc/os-release && echo "$PRETTY_NAME") || echo "Version du système d'exploitation non trouvée"

Format de sortie

Imprimer un rapport court avec ces sections, une ligne par section si possible :

Modèle :            <arbre-de-périphériques>
Version L4T :       <version>
Mode d'alimentation : <nvpmodel> / <mode>
Noyau :             <uname>
Temps de fonctionnement : <uptime>
Version OS :        <lsb_release></lsb_release></uptime></uname></mode></nvpmodel></release></device-tree>

Exemples

Exemple de sortie sur un kit de développement Orin AGX (L4T R36 / Ubuntu 22.04) :

Modèle :            NVIDIA Jetson AGX Orin Developer Kit
Version L4T :       # R36 (release), REVISION: 3.0
Mode d'alimentation : Mode d'alimentation NV : MAXN / 0
Noyau :             5.15.136-tegra
Temps de fonctionnement : up 2 hours, 14 minutes
Version OS :        Ubuntu 22.04.4 LTS

Exemple de sortie sur un AGX Thor (L4T R39 / Ubuntu 24.04) :

Modèle :            NVIDIA Jetson AGX Thor Developer Kit
Version L4T :       # R39 (release), REVISION: 0.0
Mode d'alimentation : Mode d'alimentation NV : 120W / 1
Noyau :             6.8.0-tegra
Temps de fonctionnement : up 12 minutes
Version OS :        Ubuntu 24.04 LTS

Gestion des erreurs

Chaque commande revient à une chaîne clairement étiquetée "... non trouvée" / "... non disponible" si le fichier ou le binaire sous-jacent est manquant — la compétence ne génère jamais d'erreur en milieu de rapport. Si /proc/device-tree/model est manquant ou ne contient pas de chaîne Jetson, quitter prématurément avec un message clair indiquant "exécution sur une cible Jetson".

Limitations

  • Inspection en lecture seule uniquement — ne détecte pas les fréquences GPU/CPU, l'état thermique ou la puissance par rail.
  • Le format de sortie de nvpmodel varie entre les versions L4T ; la compétence l'imprime tel quel plutôt que de l'analyser.

Dépannage

  • Erreur : /proc/device-tree/model: Aucun fichier ou dossier de ce typeCause : Exécution sur un PC hôte, et non sur une cible Jetson. Solution : Exécuter la compétence directement sur l'appareil Jetson (par exemple via SSH).
  • Erreur : nvpmodel : commande introuvableCause : BSP L4T non installé, ou exécution dans un conteneur minimal sans nvpmodel. Solution : Attendu sur les environnements non Jetson ou allégés — la compétence imprime "nvpmodel non disponible" et continue.

Notes

  • Lecture seule. Ne modifiez pas le mode d'alimentation, n'installez pas de packages et ne modifiez aucun fichier.
  • Si la compétence est invoquée par erreur sur un PC hôte, /proc/device-tree/model ne contiendra pas de chaîne de modèle Jetson — détectez-le et quittez avec un message clair plutôt que d'imprimer des informations trompeuses.
Voir sur GitHub
---
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.

Tous les fichiers

5 fichiers
SKILL.md 5.1k
Voir

Installer jetson-print-device-info

Téléchargez et extrayez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

git clone https://github.com/NVIDIA/skills/tree/main/skills/jetson-print-device-info # Copy SKILL.md to your .claude/skills/ directory

Copier Copier
Configuration rapide: Copiez le dossier des compétences dans .claude/skills/ Claude détectera et utilisera automatiquement la compétence
Dépôt NVIDIA/skills

Compétences similaires

Verification &amp; Quality Assurance
Heure mise à jour 29 juin 2026
klingai-upgrade-migration
Heure mise à jour 3 juillet 2026
base44-cli
Heure mise à jour 29 juin 2026
Railway CLI Management
Heure mise à jour 2 juillet 2026
OR