ProventusNova DeveloperWiki - User contributions [en]

How to read EEPROM data from NVIDIA Jetson platforms

2025-12-05T17:22:36Z

Nico: /* Identifying your Jetson SoM by reading the EEPROM */

=How to read EEPROM data from NVIDIA Jetson Platforms=
''Keywords'': ''NVIDIA Jetson, validation, verification, system-on-module, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
Use this table to cross-reference the module part number obtained from the EEPROM dump.

{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== What is EEPROM? ==
EEPROM stand for electrically erasable programmable read-only memory. Is a non-volatile memory chip used to store important information, such as the module's part number, used for identifying and validating the System-on-Module (SoM).

== Identifying your Jetson SoM ==
The most reliable and authoritative approach is reading the module’s EEPROM over I²C, which contains the official part number and hardware information programmed by NVIDIA. Additional commands are included to cross-check the module type using the device tree, system interfaces, and other board-level data. For this wiki, an NVIDIA Jetson OrinNX 16GB is used as reference.

=== Reading the EEPROM ===
The EEPROM address on NVIDIA Jetson Platforms is usually on I²C bus 0 address 0x50. Follow below steps to read the EEPROM from your SoM:

1. Detect EEPROM:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

You should see a '''UU''' on address 0x50 which represents the EEPROM.
<syntaxhighlight lang="bash">
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

2. Dump EEPROM content:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Take for example the output for a Jetson OrinNX 16GB module:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

3. From this output we can see the module part number here:
<syntaxhighlight lang="bash">
699-13767-0000-301
</syntaxhighlight>

From the table on section '''NVIDIA Jetson SoM models and part number''', it is confirmed the NVIDIA Jetson module is an '''OrinNX 16GB'''.

=== Additional Commands for Module Verification ===
These commands provide supplementary ways to check your Jetson SoM and board information. Unlike reading the EEPROM, these methods are '''not authoritative''' and can be modified by software. Use these commands only for cross-checking or convenience.

1. Run the following command to check your board’s model:
<syntaxhighlight lang="bash">
cat /sys/firmware/devicetree/base/model
</syntaxhighlight>

Should return something like:
<syntaxhighlight lang="bash">
nvidia,p3768-0000+p3767-0000nvidia,p3767-0000nvidia,tegra234
</syntaxhighlight>

2. Check the SoM with:
<syntaxhighlight lang="bash">
cat /proc/device-tree/compatible
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to read EEPROM data from NVIDIA Jetson platforms

2025-12-05T17:22:08Z

Nico: /* How to read EEPROM data from NVIDIA Jetson Platforms */

=How to read EEPROM data from NVIDIA Jetson Platforms=
''Keywords'': ''NVIDIA Jetson, validation, verification, system-on-module, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
Use this table to cross-reference the module part number obtained from the EEPROM dump.

{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== What is EEPROM? ==
EEPROM stand for electrically erasable programmable read-only memory. Is a non-volatile memory chip used to store important information, such as the module's part number, used for identifying and validating the System-on-Module (SoM).

== Identifying your Jetson SoM by reading the EEPROM ==
The most reliable and authoritative approach is reading the module’s EEPROM over I²C, which contains the official part number and hardware information programmed by NVIDIA. Additional commands are included to cross-check the module type using the device tree, system interfaces, and other board-level data. For this wiki, an NVIDIA Jetson OrinNX 16GB is used as reference.

=== Reading the EEPROM ===
The EEPROM address on NVIDIA Jetson Platforms is usually on I²C bus 0 address 0x50. Follow below steps to read the EEPROM from your SoM:

1. Detect EEPROM:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

You should see a '''UU''' on address 0x50 which represents the EEPROM.
<syntaxhighlight lang="bash">
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

2. Dump EEPROM content:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Take for example the output for a Jetson OrinNX 16GB module:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

3. From this output we can see the module part number here:
<syntaxhighlight lang="bash">
699-13767-0000-301
</syntaxhighlight>

From the table on section '''NVIDIA Jetson SoM models and part number''', it is confirmed the NVIDIA Jetson module is an '''OrinNX 16GB'''.

=== Additional Commands for Module Verification ===
These commands provide supplementary ways to check your Jetson SoM and board information. Unlike reading the EEPROM, these methods are '''not authoritative''' and can be modified by software. Use these commands only for cross-checking or convenience.

1. Run the following command to check your board’s model:
<syntaxhighlight lang="bash">
cat /sys/firmware/devicetree/base/model
</syntaxhighlight>

Should return something like:
<syntaxhighlight lang="bash">
nvidia,p3768-0000+p3767-0000nvidia,p3767-0000nvidia,tegra234
</syntaxhighlight>

2. Check the SoM with:
<syntaxhighlight lang="bash">
cat /proc/device-tree/compatible
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

Main Page

2025-12-05T17:18:55Z

Nico: /* ⚙️ Technical Resources */

__NOTOC__
= Welcome to the ProventusNova Developer Wiki =
'''Expert knowledge for Embedded Systems, AI, and Software Development.'''

Looking to build high-performance embedded systems, optimize AI models, or streamline multimedia processing? This wiki is a '''public knowledge hub''' designed to help engineers, developers, and businesses solve real-world technical challenges.

Here, you’ll find '''step-by-step tutorials, best practices, and deep technical insights''' to help you bring your projects to life.

== 🚀 What You’ll Find Here ==

<div style="display: flex; flex-wrap: wrap; gap: 1em;">

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🛠️ Hands-on Tutorials'''
Practical guides to get you started quickly.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''📋 Industry Best Practices'''
Proven workflows and methodologies.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''⚡ Optimized Solutions'''
Performance tuning for embedded, AI, and multimedia applications.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🌍 Open-Source Resources'''
Code samples, frameworks, and tools to accelerate development.
</div>

</div>

Whether you're an individual developer, a startup, or an enterprise, you’ll find resources here to '''enhance your expertise and improve your products'''.

== ⚙️ Technical Resources ==

Learn about core development domains, including embedded systems, AI, multimedia pipelines, and cloud-native solutions. Each section provides curated insights, guides, and best practices to help you build with assurance.

<div style="display: flex; flex-wrap: wrap; gap: 1em;">


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Embedded Systems Development]] – BSPs, firmware, and real-time processing.
</div>
<div style="padding: 1em;">
<div style="font-weight: bold; margin-top: 1em;">Embedded</div>
<ul>
<li>[[Embedded Platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Yocto</div>
<ul>
<li>[[How to create a custom yocto meta layer|Create custom Yocto meta layer]]</li>
<li>[[How to create a custom yocto recipe|Create custom Yocto recipe]]</li>
<li>[[Create custom Yocto meta layer for MediaTek G510 board|Create custom Yocto meta layer for MediaTek G510 board]]</li>
<li>[[How to add a custom partition layout to NVIDIA Jetson Platforms]]</li>
<li>[[How to read EEPROM data from NVIDIA Jetson platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Nvidia</div>
<ul>
<li>[[Nvidia Jetson Nano developer setup]]</li>
<li>[[Nvidia Jetson Orin NX with CTI Boson carrier board setup]]</li>
<li>[[Jetson Linux BSP and Kernel Source Setup]]</li>
<li> [[Adding Custom device tree overlay to JetPack 6.x]]</li>
<li> [[How to add a loadable kernel module (LKM) to JetPack 6.x]]</li>
<li> [[Jetson CSI Camera Bring-Up, Debugging, and Development Guide]]<li>
<li> [[How to run NVIDIA NanoOWL tutorial]]<li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[AI & Computer Vision]] – Edge AI, model training, and deployment.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[GStreamer Development]] – High-performance video and audio streaming.
</div>
<div style="padding: 1em;">
<ul>
<li>[[GStreamer Fundamentals]]</li>
<li>[[GStreamer Daemon]]</li>
<li>[[GStreamer Interpipes]]</li>
<li>[[GStreamer Application Development]]</li>
<li>[[GStreamer Best Practices]]</li>
<li>[[GStreamer video streaming, recording and snapshots with tee on Python]]</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Web & Cloud Solutions]] – Scalable, production-ready applications.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>

</div>

== 👀 Are you a PM looking to expand your knowledge in the software development industry? ==

This tutorial is for you!
Explore essential concepts that will help you navigate technical discussions with engineers and clients more confidently.

📄'''[[Project Manager Tutorials]]'''

== 🛠️ Developer Tools ==

This section provides essential guidelines and practices to ensure consistency, clarity, and efficiency across all development efforts. These tools and standards help teams collaborate better and maintain high-quality codebases.

🔀 '''[[Git workflow]]''': A structured guide to how our team uses Git—from branching strategies to pull request protocols—ensuring smooth collaboration and clean version history.

🧾 '''[[Naming Conventions]]''': Standardized naming rules for code elements such as variables, functions, classes, and files, helping improve readability and maintainability across projects.

== 🐞🛠️ Debugging methods and error/bug fixes ==
This section provides the best debugging methods as well as common error/bug fixes.

'''Yocto'''<br>
Yocto Project related debugging methods and error/bug fixes <br>
*[[Error:_BitBake_%2B_AppArmor_User_Namespace_Restriction_Fix|Error: BitBake+AppArmor User Namespace Restriction Fix]]

'''Nvidia'''<br>
Nvidia related debugging methods and error/bug fixes <br>
*[[Debug_NVIDIA_Jetson_nvv4l2av1enc_VPR_Violation_(EMEM_decode_error)| Debug NVIDIA Jetson nvv4l2av1enc VPR Violation (EMEM decode error)]]


{{Footer}}

How to read EEPROM data from NVIDIA Jetson platforms

2025-12-05T17:18:12Z

Nico: /* Reading the EEPROM information */

=How to read EEPROM data from NVIDIA Jetson Platforms=
''Keywords'': ''Orin Nano, Orin NX, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
Use this table to cross-reference the module part number obtained from the EEPROM dump.

{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== What is EEPROM? ==
EEPROM stand for electrically erasable programmable read-only memory. Is a non-volatile memory chip used to store important information, such as the module's part number, used for identifying and validating the System-on-Module (SoM).

== Identifying your Jetson SoM ==
The most reliable and authoritative approach is reading the module’s EEPROM over I²C, which contains the official part number and hardware information programmed by NVIDIA. Additional commands are included to cross-check the module type using the device tree, system interfaces, and other board-level data. For this wiki, an NVIDIA Jetson OrinNX 16GB is used as reference.

The EEPROM address on NVIDIA Jetson Platforms is usually on I²C bus 0 address 0x50. Follow below steps to read the EEPROM from your SoM:

1. Detect EEPROM:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

You should see a '''UU''' on address 0x50 which represents the EEPROM.
<syntaxhighlight lang="bash">
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

2. Dump EEPROM content:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Take for example the output for a Jetson OrinNX 16GB module:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

3. From this output we can see the module part number here:
<syntaxhighlight lang="bash">
699-13767-0000-301
</syntaxhighlight>

From the table on section '''NVIDIA Jetson SoM models and part number''', it is confirmed the NVIDIA Jetson module is an '''OrinNX 16GB'''.

=== Additional Commands for Module Verification ===
These commands provide supplementary ways to check your Jetson SoM and board information. Unlike reading the EEPROM, these methods are '''not authoritative''' and can be modified by software. Use these commands only for cross-checking or convenience.

1. Run the following command to check your board’s model:
<syntaxhighlight lang="bash">
cat /sys/firmware/devicetree/base/model
</syntaxhighlight>

Should return something like:
<syntaxhighlight lang="bash">
nvidia,p3768-0000+p3767-0000nvidia,p3767-0000nvidia,tegra234
</syntaxhighlight>

2. Check the SoM with:
<syntaxhighlight lang="bash">
cat /proc/device-tree/compatible
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to read EEPROM data from NVIDIA Jetson platforms

2025-12-05T17:16:46Z

Nico: /* Description */

=How to read EEPROM data from NVIDIA Jetson Platforms=
''Keywords'': ''Orin Nano, Orin NX, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
Use this table to cross-reference the module part number obtained from the EEPROM dump.

{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== What is EEPROM? ==
EEPROM stand for electrically erasable programmable read-only memory. Is a non-volatile memory chip used to store important information, such as the module's part number, used for identifying and validating the System-on-Module (SoM).

== Reading the EEPROM information ==
In this tutorial I will be using an '''Orin NX 16GB''' SoM part number '''p3767-0000'''.

1. Identify the I2C bus where the EEPROM device is. It should be located at address '''0x50''' of the bus for the SoM. For example for I2C bus 0:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

Returns:
<syntaxhighlight lang="bash">
nvidia@tegra-ubuntu:~$ sudo i2cdetect -y -r 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

At address '''0x50''', the '''UU''' references the EEPROM.

2. Read EEPROM contents:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Returns:
<syntaxhighlight lang="bash">
nico@tegra-ubuntu:~$ sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

Notice the '''699-13767-0000-301''' references my '''Orin NX 16GB''' SoM.
= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to read EEPROM data from NVIDIA Jetson platforms

2025-12-05T17:16:17Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T17:13:48Z

Nico: /* Validation and Verification of NVIDIA Jetson SoMs */

=Validation and Verification of NVIDIA Jetson SoMs=
''Keywords'': ''NVIDIA Jetson, validation, verification,system-on-module, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
Use this table to cross-reference the module part number obtained from the EEPROM dump.

{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== Identifying your Jetson SoM ==
The most reliable and authoritative approach is reading the module’s EEPROM over I²C, which contains the official part number and hardware information programmed by NVIDIA. Additional commands are included to cross-check the module type using the device tree, system interfaces, and other board-level data. For this wiki, an NVIDIA Jetson OrinNX 16GB is used as reference.

=== Reading the EEPROM ===

The EEPROM address on NVIDIA Jetson Platforms is usually on I²C bus 0 address 0x50. Follow below steps to read the EEPROM from your SoM:

1. Detect EEPROM:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

You should see a '''UU''' on address 0x50 which represents the EEPROM.
<syntaxhighlight lang="bash">
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

2. Dump EEPROM content:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Take for example the output for a Jetson OrinNX 16GB module:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

3. From this output we can see the module part number here:
<syntaxhighlight lang="bash">
699-13767-0000-301
</syntaxhighlight>

From the table on section '''NVIDIA Jetson SoM models and part number''', it is confirmed the NVIDIA Jetson module is an '''OrinNX 16GB'''.

=== Additional Commands for Module Verification ===
These commands provide supplementary ways to check your Jetson SoM and board information. Unlike reading the EEPROM, these methods are '''not authoritative''' and can be modified by software. Use these commands only for cross-checking or convenience.

1. Run the following command to check your board’s model:
<syntaxhighlight lang="bash">
cat /sys/firmware/devicetree/base/model
</syntaxhighlight>

Should return something like:
<syntaxhighlight lang="bash">
nvidia,p3768-0000+p3767-0000nvidia,p3767-0000nvidia,tegra234
</syntaxhighlight>

2. Check the SoM with:
<syntaxhighlight lang="bash">
cat /proc/device-tree/compatible
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T17:11:53Z

Nico: /* Additional Commands for Module Verification */

=Validation and Verification of NVIDIA Jetson SoMs=
''Keywords'': ''NVIDIA Jetson, validation, verification,system-on-module, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== Identifying your Jetson SoM ==
The most reliable and authoritative approach is reading the module’s EEPROM over I²C, which contains the official part number and hardware information programmed by NVIDIA. Additional commands are included to cross-check the module type using the device tree, system interfaces, and other board-level data. For this wiki, an NVIDIA Jetson OrinNX 16GB is used as reference.

=== Reading the EEPROM ===

The EEPROM address on NVIDIA Jetson Platforms is usually on I²C bus 0 address 0x50. Follow below steps to read the EEPROM from your SoM:

1. Detect EEPROM:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

You should see a '''UU''' on address 0x50 which represent the EEPROM.
<syntaxhighlight lang="bash">
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

2. Dump EEPROM content:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Take for example the output for a Jetson OrinNX 16GB module:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

3. From this output we can see the module part number here:
<syntaxhighlight lang="bash">
699-13767-0000-301
</syntaxhighlight>

From the table on section '''NVIDIA Jetson SoM models and part number''', it is confirmed the NVIDIA Jetson module is an '''OrinNX 16GB'''.

=== Additional Commands for Module Verification ===
These commands provide supplementary ways to check your Jetson SoM and board information. Unlike reading the EEPROM, these methods are not authoritative and can be modified by software. Use these commands only for cross-checking or convenience.

1. Run the following command to check your board’s model:
<syntaxhighlight lang="bash">
cat /sys/firmware/devicetree/base/model
</syntaxhighlight>

Should return something like:
<syntaxhighlight lang="bash">
nvidia,p3768-0000+p3767-0000nvidia,p3767-0000nvidia,tegra234
</syntaxhighlight>

2. Check the SoM with:
<syntaxhighlight lang="bash">
cat /proc/device-tree/compatible
</syntaxhighlight>
= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T17:11:17Z

Nico: /* Reading the EEPROM */

=Validation and Verification of NVIDIA Jetson SoMs=
''Keywords'': ''NVIDIA Jetson, validation, verification,system-on-module, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== Identifying your Jetson SoM ==
The most reliable and authoritative approach is reading the module’s EEPROM over I²C, which contains the official part number and hardware information programmed by NVIDIA. Additional commands are included to cross-check the module type using the device tree, system interfaces, and other board-level data. For this wiki, an NVIDIA Jetson OrinNX 16GB is used as reference.

=== Reading the EEPROM ===

The EEPROM address on NVIDIA Jetson Platforms is usually on I²C bus 0 address 0x50. Follow below steps to read the EEPROM from your SoM:

1. Detect EEPROM:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

You should see a '''UU''' on address 0x50 which represent the EEPROM.
<syntaxhighlight lang="bash">
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

2. Dump EEPROM content:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Take for example the output for a Jetson OrinNX 16GB module:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

3. From this output we can see the module part number here:
<syntaxhighlight lang="bash">
699-13767-0000-301
</syntaxhighlight>

From the table on section '''NVIDIA Jetson SoM models and part number''', it is confirmed the NVIDIA Jetson module is an '''OrinNX 16GB'''.

=== Additional Commands for Module Verification ===
These commands provide supplementary ways to check your Jetson SoM and board information. Unlike reading the EEPROM, these methods are not authoritative and can be modified by software. Use these commands only for cross-checking or convenience.

1. Run the following command to check your board’s model:
<syntaxhighlight lang="bash">
cat /sys/firmware/devicetree/base/model
</syntaxhighlight>

Should return something like:
<syntaxhighlight lang="bash">
nvidia,p3768-0000+p3767-0000nvidia,p3767-0000nvidia,tegra234
</syntaxhighlight>

2. Check the SoM with:
<syntaxhighlight lang="bash">
cat /proc/device-tree/compatible
</syntaxhighlight>

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:55:36Z

Nico: /* Reading the EEPROM */

=Validation and Verification of NVIDIA Jetson SoMs=
''Keywords'': ''NVIDIA Jetson, validation, verification,system-on-module, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== Identifying your Jetson SoM ==
The most reliable and authoritative approach is reading the module’s EEPROM over I²C, which contains the official part number and hardware information programmed by NVIDIA. Additional commands are included to cross-check the module type using the device tree, system interfaces, and other board-level data. For this wiki, an NVIDIA Jetson OrinNX 16GB is used as reference.

=== Reading the EEPROM ===

The EEPROM address on NVIDIA Jetson Platforms is usually on I²C bus 0 address 0x50. Follow below steps to read the EEPROM from your SoM:

1. Detect EEPROM:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

You should see a '''UU''' on address 0x50 which represent the EEPROM.
<syntaxhighlight lang="bash">
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

2. Dump EEPROM content:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Take for example the output for a Jetson OrinNX 16GB module:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

3. From this output we can see the module part number here:
<syntaxhighlight lang="bash">
699-13767-0000-301
</syntaxhighlight>

From the table on section '''NVIDIA Jetson SoM models and part number''', it is confirmed the NVIDIA Jetson module is an '''OrinNX 16GB'''.

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:54:35Z

Nico: /* Identifying your Jetson SoM */

=Validation and Verification of NVIDIA Jetson SoMs=
''Keywords'': ''NVIDIA Jetson, validation, verification,system-on-module, EEPROM''
==Description==
This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your carrier board.

== NVIDIA Jetson SoM models and part number ==
{| class="wikitable"
! Module name
! P-number
! Description
|-
| Jetson Orin Nano 8GB
| P3767-0003
| Commercial module
|-
| Jetson Orin Nano 4GB
| P3767-0004
| Commercial module
|-
| Jetson Orin Nano 8GB with SD card slot
| P3767-0005
| For the Developer Kit only
|-
| Jetson Orin NX 16GB
| P3767-0000
| Commercial module
|-
| Jetson Orin NX 8GB
| P3767-0001
| Commercial module
|-
| Jetson AGX Orin TM
| P3701-0000
| For the Developer Kit only
|-
| Jetson AGX Orin 32GB
| P3701-0004
| Commercial module
|-
| Jetson AGX Orin 64GB
| P3701-0005
| Commercial module
|-
| Jetson Xavier NX
| P3668-0000
| For the developer kit only
|-
| Jetson Xavier NX
| P3668-0001
| Commercial module
|-
| Jetson Xavier NX 16GB
| P3668-0003
| Commercial module
|-
| Jetson AGX Xavier
| P2888-0001
| Original dev-kit module
|-
| Jetson AGX Xavier
| P2888-0004
| Dev-kit module
|-
| Jetson AGX Xavier 64GB
| P2888-0005
| With 64 GB RAM
|-
| Jetson AGX Xavier industrial
| P2888-0008
| Industrial grade module with 32 GB RAM
|}

== Identifying your Jetson SoM ==
The most reliable and authoritative approach is reading the module’s EEPROM over I²C, which contains the official part number and hardware information programmed by NVIDIA. Additional commands are included to cross-check the module type using the device tree, system interfaces, and other board-level data. For this wiki, an NVIDIA Jetson OrinNX 16GB is used as reference.

=== Reading the EEPROM ===

The EEPROM address on NVIDIA Jetson Platforms is usually on I²C bus 0 address 0x50. Follow below steps to read the EEPROM from your SoM:

1. Detect EEPROM:
<syntaxhighlight lang="bash">
sudo i2cdetect -y -r 0
</syntaxhighlight>

You should see a '''UU''' on address 0x50 which represent the EEPROM.
<syntaxhighlight lang="bash">
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- 67 -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</syntaxhighlight>

2. Dump EEPROM content:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
</syntaxhighlight>

Take for example the output for a Jetson OrinNX 16GB module:
<syntaxhighlight lang="bash">
sudo i2cdump -f -y 0 0x50
No size specified (using byte-data access)
0 1 2 3 4 5 6 7 8 9 a b c d e f 0123456789abcdef
00: 02 00 fe 00 00 00 00 00 00 00 00 ff 00 00 00 00 ?.?.............
10: 00 01 00 01 36 39 39 2d 31 33 37 36 37 2d 30 30 .?.?699-13767-00
20: 30 30 2d 33 30 31 20 47 2e 31 00 00 00 00 00 00 00-301 G.1......
30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
40: b0 48 00 00 13 66 1f 66 6d 3c 31 34 32 30 32 32 ?H..?f?fm<142022
50: 35 30 35 36 34 32 33 00 00 00 00 00 00 00 00 00 5056423.........
60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
90: 00 00 00 00 00 00 4e 56 43 42 00 ff 4d 31 00 00 ......NVCB..M1..
a0: 00 00 00 00 00 00 00 00 00 00 00 00 13 66 1f 66 ............?f?f
b0: 6d 3c 01 00 00 00 00 00 00 00 00 00 00 00 00 00 m<?.............
c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5e ...............^
</syntaxhighlight>

3. From this output we can see the module part number here:
<syntaxhighlight lang="bash">
699-13767-0000-301
</syntaxhighlight>

From the table on section Confirming my NVIDIA Jetson module is an '''OrinNX 16GB'''.

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:47:07Z

Nico: /* Validation and Verification of NVIDIA Jetson SoMs */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:40:46Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:39:04Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:34:35Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:25:11Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:24:55Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:24:10Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:23:57Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:22:30Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:21:49Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:19:52Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:16:21Z

Nico: /* Description */

Validation and Verification of NVIDIA Jetson SoMs

2025-12-05T16:11:53Z

Nico: Created page with "=Validation and Verification of NVIDIA Jetson SoMs= ''Keywords'': ''NVIDIA Jetson, validation, verification,system-on-module, EEPROM'' ==Description== This page explains how to validate and verify your NVIDIA Jetson System-on-Module (SoM) by identifying its hardware part number and related information. It includes steps for reading module data over I²C, interpreting the results, and using additional system commands to confirm the exact Jetson module installed on your ca..."

Main Page

2025-12-05T15:57:36Z

Nico: /* ⚙️ Technical Resources */

__NOTOC__
= Welcome to the ProventusNova Developer Wiki =
'''Expert knowledge for Embedded Systems, AI, and Software Development.'''

Looking to build high-performance embedded systems, optimize AI models, or streamline multimedia processing? This wiki is a '''public knowledge hub''' designed to help engineers, developers, and businesses solve real-world technical challenges.

Here, you’ll find '''step-by-step tutorials, best practices, and deep technical insights''' to help you bring your projects to life.

== 🚀 What You’ll Find Here ==

<div style="display: flex; flex-wrap: wrap; gap: 1em;">

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🛠️ Hands-on Tutorials'''
Practical guides to get you started quickly.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''📋 Industry Best Practices'''
Proven workflows and methodologies.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''⚡ Optimized Solutions'''
Performance tuning for embedded, AI, and multimedia applications.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🌍 Open-Source Resources'''
Code samples, frameworks, and tools to accelerate development.
</div>

</div>

Whether you're an individual developer, a startup, or an enterprise, you’ll find resources here to '''enhance your expertise and improve your products'''.

== ⚙️ Technical Resources ==

Learn about core development domains, including embedded systems, AI, multimedia pipelines, and cloud-native solutions. Each section provides curated insights, guides, and best practices to help you build with assurance.

<div style="display: flex; flex-wrap: wrap; gap: 1em;">


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Embedded Systems Development]] – BSPs, firmware, and real-time processing.
</div>
<div style="padding: 1em;">
<div style="font-weight: bold; margin-top: 1em;">Embedded</div>
<ul>
<li>[[Embedded Platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Yocto</div>
<ul>
<li>[[How to create a custom yocto meta layer|Create custom Yocto meta layer]]</li>
<li>[[How to create a custom yocto recipe|Create custom Yocto recipe]]</li>
<li>[[Create custom Yocto meta layer for MediaTek G510 board|Create custom Yocto meta layer for MediaTek G510 board]]</li>
<li>[[How to add a custom partition layout to NVIDIA Jetson Platforms]]</li>
<li>[[How to read EEPROM data from NVIDIA Jetson platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Nvidia</div>
<ul>
<li>[[Nvidia Jetson Nano developer setup]]</li>
<li>[[Nvidia Jetson Orin NX with CTI Boson carrier board setup]]</li>
<li>[[Jetson Linux BSP and Kernel Source Setup]]</li>
<li> [[Adding Custom device tree overlay to JetPack 6.x]]</li>
<li> [[How to add a loadable kernel module (LKM) to JetPack 6.x]]</li>
<li> [[Jetson CSI Camera Bring-Up, Debugging, and Development Guide]]<li>
<li> [[How to run NVIDIA NanoOWL tutorial]]<li>
<li>[[Validation and Verification of NVIDIA Jetson SoMs]]<li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[AI & Computer Vision]] – Edge AI, model training, and deployment.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[GStreamer Development]] – High-performance video and audio streaming.
</div>
<div style="padding: 1em;">
<ul>
<li>[[GStreamer Fundamentals]]</li>
<li>[[GStreamer Daemon]]</li>
<li>[[GStreamer Interpipes]]</li>
<li>[[GStreamer Application Development]]</li>
<li>[[GStreamer Best Practices]]</li>
<li>[[GStreamer video streaming, recording and snapshots with tee on Python]]</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Web & Cloud Solutions]] – Scalable, production-ready applications.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>

</div>

== 👀 Are you a PM looking to expand your knowledge in the software development industry? ==

This tutorial is for you!
Explore essential concepts that will help you navigate technical discussions with engineers and clients more confidently.

📄'''[[Project Manager Tutorials]]'''

== 🛠️ Developer Tools ==

This section provides essential guidelines and practices to ensure consistency, clarity, and efficiency across all development efforts. These tools and standards help teams collaborate better and maintain high-quality codebases.

🔀 '''[[Git workflow]]''': A structured guide to how our team uses Git—from branching strategies to pull request protocols—ensuring smooth collaboration and clean version history.

🧾 '''[[Naming Conventions]]''': Standardized naming rules for code elements such as variables, functions, classes, and files, helping improve readability and maintainability across projects.

== 🐞🛠️ Debugging methods and error/bug fixes ==
This section provides the best debugging methods as well as common error/bug fixes.

'''Yocto'''<br>
Yocto Project related debugging methods and error/bug fixes <br>
*[[Error:_BitBake_%2B_AppArmor_User_Namespace_Restriction_Fix|Error: BitBake+AppArmor User Namespace Restriction Fix]]

'''Nvidia'''<br>
Nvidia related debugging methods and error/bug fixes <br>
*[[Debug_NVIDIA_Jetson_nvv4l2av1enc_VPR_Violation_(EMEM_decode_error)| Debug NVIDIA Jetson nvv4l2av1enc VPR Violation (EMEM decode error)]]


{{Footer}}

Main Page

2025-12-05T15:54:08Z

Nico: /* ⚙️ Technical Resources */

__NOTOC__
= Welcome to the ProventusNova Developer Wiki =
'''Expert knowledge for Embedded Systems, AI, and Software Development.'''

Looking to build high-performance embedded systems, optimize AI models, or streamline multimedia processing? This wiki is a '''public knowledge hub''' designed to help engineers, developers, and businesses solve real-world technical challenges.

Here, you’ll find '''step-by-step tutorials, best practices, and deep technical insights''' to help you bring your projects to life.

== 🚀 What You’ll Find Here ==

<div style="display: flex; flex-wrap: wrap; gap: 1em;">

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🛠️ Hands-on Tutorials'''
Practical guides to get you started quickly.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''📋 Industry Best Practices'''
Proven workflows and methodologies.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''⚡ Optimized Solutions'''
Performance tuning for embedded, AI, and multimedia applications.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🌍 Open-Source Resources'''
Code samples, frameworks, and tools to accelerate development.
</div>

</div>

Whether you're an individual developer, a startup, or an enterprise, you’ll find resources here to '''enhance your expertise and improve your products'''.

== ⚙️ Technical Resources ==

Learn about core development domains, including embedded systems, AI, multimedia pipelines, and cloud-native solutions. Each section provides curated insights, guides, and best practices to help you build with assurance.

<div style="display: flex; flex-wrap: wrap; gap: 1em;">


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Embedded Systems Development]] – BSPs, firmware, and real-time processing.
</div>
<div style="padding: 1em;">
<div style="font-weight: bold; margin-top: 1em;">Embedded</div>
<ul>
<li>[[Embedded Platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Yocto</div>
<ul>
<li>[[How to create a custom yocto meta layer|Create custom Yocto meta layer]]</li>
<li>[[How to create a custom yocto recipe|Create custom Yocto recipe]]</li>
<li>[[Create custom Yocto meta layer for MediaTek G510 board|Create custom Yocto meta layer for MediaTek G510 board]]</li>
<li>[[How to add a custom partition layout to NVIDIA Jetson Platforms]]</li>
<li>[[How to read EEPROM data from NVIDIA Jetson platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Nvidia</div>
<ul>
<li>[[Nvidia Jetson Nano developer setup]]</li>
<li>[[Nvidia Jetson Orin NX with CTI Boson carrier board setup]]</li>
<li>[[Jetson Linux BSP and Kernel Source Setup]]</li>
<li> [[Adding Custom device tree overlay to JetPack 6.x]]</li>
<li> [[How to add a loadable kernel module (LKM) to JetPack 6.x]]</li>
<li> [[Jetson CSI Camera Bring-Up, Debugging, and Development Guide]]<li>
<li> [[How to run NVIDIA NanoOWL tutorial]]<li>
<li>[[Validation and Verification of NVIDIA Jetson SoM Modules]]<li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[AI & Computer Vision]] – Edge AI, model training, and deployment.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[GStreamer Development]] – High-performance video and audio streaming.
</div>
<div style="padding: 1em;">
<ul>
<li>[[GStreamer Fundamentals]]</li>
<li>[[GStreamer Daemon]]</li>
<li>[[GStreamer Interpipes]]</li>
<li>[[GStreamer Application Development]]</li>
<li>[[GStreamer Best Practices]]</li>
<li>[[GStreamer video streaming, recording and snapshots with tee on Python]]</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Web & Cloud Solutions]] – Scalable, production-ready applications.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>

</div>

== 👀 Are you a PM looking to expand your knowledge in the software development industry? ==

This tutorial is for you!
Explore essential concepts that will help you navigate technical discussions with engineers and clients more confidently.

📄'''[[Project Manager Tutorials]]'''

== 🛠️ Developer Tools ==

This section provides essential guidelines and practices to ensure consistency, clarity, and efficiency across all development efforts. These tools and standards help teams collaborate better and maintain high-quality codebases.

🔀 '''[[Git workflow]]''': A structured guide to how our team uses Git—from branching strategies to pull request protocols—ensuring smooth collaboration and clean version history.

🧾 '''[[Naming Conventions]]''': Standardized naming rules for code elements such as variables, functions, classes, and files, helping improve readability and maintainability across projects.

== 🐞🛠️ Debugging methods and error/bug fixes ==
This section provides the best debugging methods as well as common error/bug fixes.

'''Yocto'''<br>
Yocto Project related debugging methods and error/bug fixes <br>
*[[Error:_BitBake_%2B_AppArmor_User_Namespace_Restriction_Fix|Error: BitBake+AppArmor User Namespace Restriction Fix]]

'''Nvidia'''<br>
Nvidia related debugging methods and error/bug fixes <br>
*[[Debug_NVIDIA_Jetson_nvv4l2av1enc_VPR_Violation_(EMEM_decode_error)| Debug NVIDIA Jetson nvv4l2av1enc VPR Violation (EMEM decode error)]]


{{Footer}}

Jetson CSI Camera Bring-Up, Debugging, and Development Guide

2025-12-04T23:13:20Z

Nico: Created page with "=NVIDIA Jetson CSI Camera bring up, debugging and development guide= ''Keywords'': ''NVIDIA Jetson, camera drivers, CSI cameras, Linux kernel'' ==Description== This wiki page provides a guide to camera driver debugging, sensor bring-up, and driver development on the NVIDIA Jetson platform. It covers essential diagnostic steps, tools, and workflows for validating CSI camera connectivity, verifying I²C communication, checking device-tree configuration, reviewing kernel lo..."

=NVIDIA Jetson CSI Camera bring up, debugging and development guide=
''Keywords'': ''NVIDIA Jetson, camera drivers, CSI cameras, Linux kernel''
==Description==
This wiki page provides a guide to camera driver debugging, sensor bring-up, and driver development on the NVIDIA Jetson platform.
It covers essential diagnostic steps, tools, and workflows for validating CSI camera connectivity, verifying I²C communication, checking device-tree configuration, reviewing kernel logs, testing V4L2 operation, and confirming Argus camera-stack functionality.
This resource is intended for developers integrating custom camera modules, writing or modifying camera drivers, or troubleshooting sensor issues on Jetson devices.

== Required tools ==
This section lists the essential software utilities used for camera bring-up and debugging on NVIDIA Jetson platforms. These tools allow you to verify I²C communication, inspect V4L2 video devices, and perform low-level camera diagnostics.

* I2C-Tools: Provides utilities such as '''i2cdetect, i2cget, and i2cset''' for scanning the I²C bus, reading sensor registers, and validating camera presence. Install with:
<syntaxhighlight lang="bash">
sudo apt-get install -y i2c-tools
</syntaxhighlight>

* V4L-Utils: A set of tools for interacting with Linux Video4Linux2 (V4L2) devices. This is the primary tool for listing video devices, testing raw streaming, querying formats and inspecting V4L2 controls for linux devices. Install with:
<syntaxhighlight lang="bash">
sudo apt-get install -y v4l-utils
</syntaxhighlight>

== Camera driver debugging ==

== Camera driver bring up ==

== Device tree development ==

Main Page

2025-12-04T21:46:52Z

Nico: /* ⚙️ Technical Resources */

__NOTOC__
= Welcome to the ProventusNova Developer Wiki =
'''Expert knowledge for Embedded Systems, AI, and Software Development.'''

Looking to build high-performance embedded systems, optimize AI models, or streamline multimedia processing? This wiki is a '''public knowledge hub''' designed to help engineers, developers, and businesses solve real-world technical challenges.

Here, you’ll find '''step-by-step tutorials, best practices, and deep technical insights''' to help you bring your projects to life.

== 🚀 What You’ll Find Here ==

<div style="display: flex; flex-wrap: wrap; gap: 1em;">

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🛠️ Hands-on Tutorials'''
Practical guides to get you started quickly.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''📋 Industry Best Practices'''
Proven workflows and methodologies.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''⚡ Optimized Solutions'''
Performance tuning for embedded, AI, and multimedia applications.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🌍 Open-Source Resources'''
Code samples, frameworks, and tools to accelerate development.
</div>

</div>

Whether you're an individual developer, a startup, or an enterprise, you’ll find resources here to '''enhance your expertise and improve your products'''.

== ⚙️ Technical Resources ==

Learn about core development domains, including embedded systems, AI, multimedia pipelines, and cloud-native solutions. Each section provides curated insights, guides, and best practices to help you build with assurance.

<div style="display: flex; flex-wrap: wrap; gap: 1em;">


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Embedded Systems Development]] – BSPs, firmware, and real-time processing.
</div>
<div style="padding: 1em;">
<div style="font-weight: bold; margin-top: 1em;">Embedded</div>
<ul>
<li>[[Embedded Platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Yocto</div>
<ul>
<li>[[How to create a custom yocto meta layer|Create custom Yocto meta layer]]</li>
<li>[[How to create a custom yocto recipe|Create custom Yocto recipe]]</li>
<li>[[Create custom Yocto meta layer for MediaTek G510 board|Create custom Yocto meta layer for MediaTek G510 board]]</li>
<li>[[How to add a custom partition layout to NVIDIA Jetson Platforms]]</li>
<li>[[How to read EEPROM data from NVIDIA Jetson platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Nvidia</div>
<ul>
<li>[[Nvidia Jetson Nano developer setup]]</li>
<li>[[Nvidia Jetson Orin NX with CTI Boson carrier board setup]]</li>
<li>[[Jetson Linux BSP and Kernel Source Setup]]</li>
<li> [[Adding Custom device tree overlay to JetPack 6.x]]</li>
<li> [[How to add a loadable kernel module (LKM) to JetPack 6.x]]</li>
<li> [[Jetson CSI Camera Bring-Up, Debugging, and Development Guide]]
<li> [[How to run NVIDIA NanoOWL tutorial]]<li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[AI & Computer Vision]] – Edge AI, model training, and deployment.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[GStreamer Development]] – High-performance video and audio streaming.
</div>
<div style="padding: 1em;">
<ul>
<li>[[GStreamer Fundamentals]]</li>
<li>[[GStreamer Daemon]]</li>
<li>[[GStreamer Interpipes]]</li>
<li>[[GStreamer Application Development]]</li>
<li>[[GStreamer Best Practices]]</li>
<li>[[GStreamer video streaming, recording and snapshots with tee on Python]]</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Web & Cloud Solutions]] – Scalable, production-ready applications.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>

</div>

== 👀 Are you a PM looking to expand your knowledge in the software development industry? ==

This tutorial is for you!
Explore essential concepts that will help you navigate technical discussions with engineers and clients more confidently.

📄'''[[Project Manager Tutorials]]'''

== 🛠️ Developer Tools ==

This section provides essential guidelines and practices to ensure consistency, clarity, and efficiency across all development efforts. These tools and standards help teams collaborate better and maintain high-quality codebases.

🔀 '''[[Git workflow]]''': A structured guide to how our team uses Git—from branching strategies to pull request protocols—ensuring smooth collaboration and clean version history.

🧾 '''[[Naming Conventions]]''': Standardized naming rules for code elements such as variables, functions, classes, and files, helping improve readability and maintainability across projects.

== 🐞🛠️ Debugging methods and error/bug fixes ==
This section provides the best debugging methods as well as common error/bug fixes.

'''Yocto'''<br>
Yocto Project related debugging methods and error/bug fixes <br>
*[[Error:_BitBake_%2B_AppArmor_User_Namespace_Restriction_Fix|Error: BitBake+AppArmor User Namespace Restriction Fix]]

'''Nvidia'''<br>
Nvidia related debugging methods and error/bug fixes <br>
*[[Debug_NVIDIA_Jetson_nvv4l2av1enc_VPR_Violation_(EMEM_decode_error)| Debug NVIDIA Jetson nvv4l2av1enc VPR Violation (EMEM decode error)]]


{{Footer}}

How to add a custom partition layout to NVIDIA Jetson Platforms

2025-12-03T18:19:09Z

Nico: /* Understanding the Flashing Process and Partition Layout */

=How to Add a Custom Partition Layout to NVIDIA Jetson Platforms=
''Keywords'': ''NVMe, partition, flash, custom layout, JetPack''
==Description==
This wiki pages shows how to add a memory partition on NVIDIA'S Jetson Platforms. This procedure was tested on a NVIDIA Jetson Orin NX with CTI Boson carrier board running JetPack 6.2.1(L4T R36.4.4) and demonstrates how to add an additional 2GiB partition on NVMe storage.

==Understanding the Flashing Process and Partition Layout==

* When flashing a Jetson platform that uses NVMe storage as the root device, the following command is typically used:

<pre>
sudo ./tools/kernel_flash/l4t_initrd_flash.sh --external-device nvme0n1p1 -c tools/kernel_flash/flash_l4t_external.xml -p '-c bootloader/generic/cfg/flash_t234_qspi.xml' --showlogs --network usb0 <board-config> internal
</pre>

The '''flash_l4t_external.xml''' file is the Jetson Linux (L4T) partition configuration file. It defines how partitions are laid out on the target storage device — in this case, the NVMe drive.

* After flashing the board you can check the partition layout by running '''lsblk'''. The output should look similar to this:

<syntaxhighlight lang="bash">
nvidia@nvidia:~$ lsblk -o NAME,SIZE,TYPE,MOUNTPOINT,PARTLABEL
NAME SIZE TYPE MOUNTPOINT PARTLABEL
loop0 16M loop
zram0 1.9G disk [SWAP]
zram1 1.9G disk [SWAP]
zram2 1.9G disk [SWAP]
zram3 1.9G disk [SWAP]
nvme0n1 119.2G disk
├─nvme0n1p1 117.8G part / APP
├─nvme0n1p2 128M part A_kernel
├─nvme0n1p3 768K part A_kernel-dtb
├─nvme0n1p4 31.6M part A_reserved_on_user
├─nvme0n1p5 128M part B_kernel
├─nvme0n1p6 768K part B_kernel-dtb
├─nvme0n1p7 31.6M part B_reserved_on_user
├─nvme0n1p8 80M part recovery
├─nvme0n1p9 512K part recovery-dtb
├─nvme0n1p10 64M part /boot/efi esp
├─nvme0n1p11 80M part recovery_alt
├─nvme0n1p12 512K part recovery-dtb_alt
├─nvme0n1p13 64M part esp_alt
├─nvme0n1p14 400M part UDA
└─nvme0n1p15 479.5M part reserved
</syntaxhighlight>

* To add a new partition we need to modify the partition layout in this '''flash_l4t_external.xml''' file.

* '''Important''': Notice NVMe size of '''119.2G'''.

== Creating a custom partition layout ==

In this section you will find the steps for adding an extra partition called '''EXTRA_DATA''' with size '''20 GiB''' to the partition layout file for flashing.

1. Create a copy of the original file in case we need the default partition configuration. Let's call it: '''flash_l4t_external_copy.xml'''

2. Add the following section code before the '''APP''' partition to create a new partition block called '''EXTRA_DATA'''.
<pre>
<partition name="EXTRA_DATA" type="data">
<allocation_policy> sequential </allocation_policy>
<filesystem_type> basic </filesystem_type>
<size> <EXTRA_DATA_SIZE> </size>
<file_system_attribute> 0 </file_system_attribute>
<allocation_attribute> 0x8 </allocation_attribute>
<percent_reserved> 0 </percent_reserved>
<align_boundary> 16384 </align_boundary>
<description> **Required.** This partition may be mounted and used to store user
data. </description>
</partition>
</pre>
3. Define how much size will be assigned to the new partition. To calculate the size in bytes use the next formula:
<syntaxhighlight lang="bash">
SIZE (GiB) * 1024^3 = Size (BYTES)
</syntaxhighlight>

For 20 GiB:
<syntaxhighlight lang="bash">
20 (GiB) * 1024^3 = 21474836480 bytes
</syntaxhighlight>

Change '''EXTRA_DATA_SIZE''' for '''21474836480'''.

4. Recalculate APP size to adjust for the extra partition added:
<syntaxhighlight lang="bash">
(119.8 GiB - 20 GiB ) * 1024^3 = 105011950387 bytes
</syntaxhighlight>

5. Change '''APP size''' for '''105011950387'''.

6. With this changes the file should look like this:
<pre>
<partition name="EXTRA_DATA" type="data">
<allocation_policy> sequential </allocation_policy>
<filesystem_type> basic </filesystem_type>
<size> 21474836480 </size>
<file_system_attribute> 0 </file_system_attribute>
<allocation_attribute> 0x8 </allocation_attribute>
<percent_reserved> 0 </percent_reserved>
<align_boundary> 16384 </align_boundary>
<description> **Required.** This partition may be mounted and used to store user
data. </description>
</partition>
<partition name="APP" id="1" type="data">
<allocation_policy> sequential </allocation_policy>
<filesystem_type> basic </filesystem_type>
<size> 105011950387 </size>
<file_system_attribute> 0 </file_system_attribute>
<allocation_attribute> 0x808 </allocation_attribute>
<align_boundary> 16384 </align_boundary>
<percent_reserved> 0 </percent_reserved>
<unique_guid> APPUUID </unique_guid>
<filename> APPFILE </filename>
<description> **Required.** Contains the rootfs. This partition must be assigned
the "1" for id as it is physically put to the end of the device, so that it
can be accessed as the fixed known special device `/dev/nvme0n1p1`. </description>
</partition>
</pre>
== Flashing with new partition layout ==

1. To flash, use the new XML file created:
<pre>
sudo ./tools/kernel_flash/l4t_initrd_flash.sh --external-device nvme0n1p1 -c tools/kernel_flash/flash_l4t_external_copy.xml -p '-c bootloader/generic/cfg/flash_t234_qspi.xml' --showlogs --network usb0 <board-config> internal
</pre>

2. Wait for board to flash and boot.

3. Run '''lsusb''' command. The output should look like this:
<syntaxhighlight lang="bash">
nvidia@nvidia:~$ lsblk -o NAME,SIZE,TYPE,MOUNTPOINT,PARTLABEL
NAME SIZE TYPE MOUNTPOINT PARTLABEL
loop0 16M loop
zram0 1.9G disk [SWAP]
zram1 1.9G disk [SWAP]
zram2 1.9G disk [SWAP]
zram3 1.9G disk [SWAP]
nvme0n1 119.2G disk
├─nvme0n1p1 97.8G part / APP
├─nvme0n1p2 128M part A_kernel
├─nvme0n1p3 768K part A_kernel-dtb
├─nvme0n1p4 31.6M part A_reserved_on_user
├─nvme0n1p5 128M part B_kernel
├─nvme0n1p6 768K part B_kernel-dtb
├─nvme0n1p7 31.6M part B_reserved_on_user
├─nvme0n1p8 80M part recovery
├─nvme0n1p9 512K part recovery-dtb
├─nvme0n1p10 64M part /boot/efi esp
├─nvme0n1p11 80M part recovery_alt
├─nvme0n1p12 512K part recovery-dtb_alt
├─nvme0n1p13 64M part esp_alt
├─nvme0n1p14 400M part UDA
├─nvme0n1p15 479.5M part reserved
└─nvme0n1p16 20G part EXTRA_DATA
</syntaxhighlight>

You should see '''EXTRA_DATA''' partition with size '''20G'''. For APP, the size is now '''97.8G'''.

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T23:30:19Z

Nico: /* Installing the NVIDIA out-of-tree modules */

=How to add a loadable kernel module (LKM) to JetPack 6.x=
''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot''
==Description==
This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x.

== Adding loadable kernel module ==

Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications are required:

* Add the driver source files: '''nv_customcam.c''' and '''nv_customcam.h'''
* Add register mode-table configuration file for the sensor's operating modes: '''customcam_mode_tbls.h'''.
* Add a Kconfig entry for the driver.
* Update Makefile to compile driver.
=== Adding the source and header files ===
1. Add source code file '''nv_customcam.c''' to directory '''nvidia-oot/drivers/media/i2c/'''.

2. Add header file '''nv_customcam.h''' to directory '''nvidia-oot/include/media/'''.

3. Add register mode-table configuration file '''customcam_mode_tbls.h''' to directory '''nvidia-oot/drivers/media/i2c/'''.

=== Intergrating the driver into the kernel build system ===

1. Add a new entry to '''Kconfig''' file in directory '''kernel/kernel-jammy-src/drivers/media/i2c/'''. This defines a configuration option that controls whether the module is built and how it is included on the kernel.

<syntaxhighlight lang="bash">
config NV_VIDEO_CUSTOMCAM
tristate "Custom cam"
depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
help
This driver supports CUSTOMCAM camera sensor.

To compile this driver as a module, choose M here: the module
will be called CUSTOMCAM.

</syntaxhighlight>

2. Add the following line to file '''defconfig''' in directory '''kernel/kernel-jammy-src/arch/arm64/configs/''' to configure the kernel for building the CUSTOMCAM driver as a module.
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Modify '''Makefile''' inside directory '''nvidia-oot/drivers/media/i2c/''' to build the new camera module added. Add the following line inside the '''Makefile'''.
<syntaxhighlight lang="bash">
obj-$(CONFIG_NV_VIDEO_CUSTOMCAM) += nv_customcam.o
</syntaxhighlight>

=== Building the NVIDIA out-of-tree modules ===

First build the kernel to update the kernel configuration file.

1. Go to '''Linux_for_Tegra/source''' directory. Set the following environment variables:
<syntaxhighlight lang="bash">
export CROSS_COMPILE=$HOME/l4t-gcc/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
export KERNEL_OUTPUT=$PWD/kernel_out
</syntaxhighlight>

2. Build the kernel.
<syntaxhighlight lang="bash">
make -C kernel
</syntaxhighlight>

Wait for the kernel to build. The kernel build will be under '''kernel_out''' set with environment variable '''KERNEL_OUTPUT'''. You can verify the changes to the files defconfig and the Kconfig inside '''kernel_out/.config'''. You should see this set:
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Set the install path environment variable.
<syntaxhighlight lang="bash">
export INSTALL_MOD_PATH=<PATH_TO>/Linux_for_Tegra/rootfs/
</syntaxhighlight>

4. Build the NVIDIA OoT modules:
<syntaxhighlight lang="bash">
make modules
</syntaxhighlight>

Compiled files will be under directory: '''nvidia-oot/drivers/media/i2c/'''. You should see file: '''nv_customcam.ko'''.

=== Installing the NVIDIA out-of-tree modules ===
1. Install the module.

<syntaxhighlight lang="bash">
sudo -E make modules_install
</syntaxhighlight>

After this the module should be inside directory: '''Linux_for_Tegra/rootfs/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/'''.

From this point the kernel module is ready for use. You can either:

1. Flash the board.

2. Copy the module to the board using scp.
<syntaxhighlight lang="bash">
scp $INSTALL_MOD_PATH/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/nv_customcam.ko nvidia@<board-ip>:/tmp
</syntaxhighlight>

2.1 Inside the board:
<syntaxhighlight lang="bash">
sudo cp /tmp/nv_customcam.ko /lib/modules/5.15.148-tegra/updates/drivers/media/i2c/
sudo depmod -a 5.15.148-tegra
</syntaxhighlight>

2.2 Load the module

<syntaxhighlight lang="bash">
sudo modprobe nv_customcam
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T23:29:49Z

Nico: /* Building the NVIDIA out-of-tree modules */

=How to add a loadable kernel module (LKM) to JetPack 6.x=
''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot''
==Description==
This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x.

== Adding loadable kernel module ==

Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications are required:

* Add the driver source files: '''nv_customcam.c''' and '''nv_customcam.h'''
* Add register mode-table configuration file for the sensor's operating modes: '''customcam_mode_tbls.h'''.
* Add a Kconfig entry for the driver.
* Update Makefile to compile driver.
=== Adding the source and header files ===
1. Add source code file '''nv_customcam.c''' to directory '''nvidia-oot/drivers/media/i2c/'''.

2. Add header file '''nv_customcam.h''' to directory '''nvidia-oot/include/media/'''.

3. Add register mode-table configuration file '''customcam_mode_tbls.h''' to directory '''nvidia-oot/drivers/media/i2c/'''.

=== Intergrating the driver into the kernel build system ===

1. Add a new entry to '''Kconfig''' file in directory '''kernel/kernel-jammy-src/drivers/media/i2c/'''. This defines a configuration option that controls whether the module is built and how it is included on the kernel.

<syntaxhighlight lang="bash">
config NV_VIDEO_CUSTOMCAM
tristate "Custom cam"
depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
help
This driver supports CUSTOMCAM camera sensor.

To compile this driver as a module, choose M here: the module
will be called CUSTOMCAM.

</syntaxhighlight>

2. Add the following line to file '''defconfig''' in directory '''kernel/kernel-jammy-src/arch/arm64/configs/''' to configure the kernel for building the CUSTOMCAM driver as a module.
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Modify '''Makefile''' inside directory '''nvidia-oot/drivers/media/i2c/''' to build the new camera module added. Add the following line inside the '''Makefile'''.
<syntaxhighlight lang="bash">
obj-$(CONFIG_NV_VIDEO_CUSTOMCAM) += nv_customcam.o
</syntaxhighlight>

=== Building the NVIDIA out-of-tree modules ===

First build the kernel to update the kernel configuration file.

1. Go to '''Linux_for_Tegra/source''' directory. Set the following environment variables:
<syntaxhighlight lang="bash">
export CROSS_COMPILE=$HOME/l4t-gcc/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
export KERNEL_OUTPUT=$PWD/kernel_out
</syntaxhighlight>

2. Build the kernel.
<syntaxhighlight lang="bash">
make -C kernel
</syntaxhighlight>

Wait for the kernel to build. The kernel build will be under '''kernel_out''' set with environment variable '''KERNEL_OUTPUT'''. You can verify the changes to the files defconfig and the Kconfig inside '''kernel_out/.config'''. You should see this set:
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Set the install path environment variable.
<syntaxhighlight lang="bash">
export INSTALL_MOD_PATH=<PATH_TO>/Linux_for_Tegra/rootfs/
</syntaxhighlight>

4. Build the NVIDIA OoT modules:
<syntaxhighlight lang="bash">
make modules
</syntaxhighlight>

Compiled files will be under directory: '''nvidia-oot/drivers/media/i2c/'''. You should see file: '''nv_customcam.ko'''.

=== Installing the NVIDIA out-of-tree modules ===
1. Install the module.

<syntaxhighlight lang="bash">
sudo -E make modules_install
</syntaxhighlight>

After this the module should be inside directory: '''Linux_for_Tegra/rootfs/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/'''.

From this point the kernel module is ready for use. You can either:

1. Flash the board.
2. Copy the module to the board using scp.
<syntaxhighlight lang="bash">
scp $INSTALL_MOD_PATH/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/nv_customcam.ko nvidia@<board-ip>:/tmp
</syntaxhighlight>

2.1 Inside the board:
<syntaxhighlight lang="bash">
sudo cp /tmp/nv_customcam.ko /lib/modules/5.15.148-tegra/updates/drivers/media/i2c/
sudo depmod -a 5.15.148-tegra
</syntaxhighlight>

2.2 Load the module

<syntaxhighlight lang="bash">
sudo modprobe nv_customcam
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T23:06:50Z

Nico: /* Intergrating the driver into the kernel build system */

=How to add a loadable kernel module (LKM) to JetPack 6.x=
''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot''
==Description==
This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x.

== Adding loadable kernel module ==

Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications are required:

* Add the driver source files: '''nv_customcam.c''' and '''nv_customcam.h'''
* Add register mode-table configuration file for the sensor's operating modes: '''customcam_mode_tbls.h'''.
* Add a Kconfig entry for the driver.
* Update Makefile to compile driver.
=== Adding the source and header files ===
1. Add source code file '''nv_customcam.c''' to directory '''nvidia-oot/drivers/media/i2c/'''.

2. Add header file '''nv_customcam.h''' to directory '''nvidia-oot/include/media/'''.

3. Add register mode-table configuration file '''customcam_mode_tbls.h''' to directory '''nvidia-oot/drivers/media/i2c/'''.

=== Intergrating the driver into the kernel build system ===

1. Add a new entry to '''Kconfig''' file in directory '''kernel/kernel-jammy-src/drivers/media/i2c/'''. This defines a configuration option that controls whether the module is built and how it is included on the kernel.

<syntaxhighlight lang="bash">
config NV_VIDEO_CUSTOMCAM
tristate "Custom cam"
depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
help
This driver supports CUSTOMCAM camera sensor.

To compile this driver as a module, choose M here: the module
will be called CUSTOMCAM.

</syntaxhighlight>

2. Add the following line to file '''defconfig''' in directory '''kernel/kernel-jammy-src/arch/arm64/configs/''' to configure the kernel for building the CUSTOMCAM driver as a module.
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Modify '''Makefile''' inside directory '''nvidia-oot/drivers/media/i2c/''' to build the new camera module added. Add the following line inside the '''Makefile'''.
<syntaxhighlight lang="bash">
obj-$(CONFIG_NV_VIDEO_CUSTOMCAM) += nv_customcam.o
</syntaxhighlight>

=== Building the NVIDIA out-of-tree modules ===

First build the kernel to update the kernel configuration file.

1. Go to '''Linux_for_Tegra/source''' directory. Set the following environment variables:
<syntaxhighlight lang="bash">
export CROSS_COMPILE=$HOME/l4t-gcc/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
export KERNEL_OUTPUT=$PWD/kernel_out
</syntaxhighlight>

2. Build the kernel.
<syntaxhighlight lang="bash">
make -C kernel
</syntaxhighlight>

Wait for the kernel to build. The kernel build will be under '''kernel_out''' set with environment variable '''KERNEL_OUTPUT'''. You can verify the changes to the files defconfig and the Kconfig inside '''kernel_out/.config'''. You should see this set:
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Set the install path environment variable.
<syntaxhighlight lang="bash">
export INSTALL_MOD_PATH=<PATH_TO>/Linux_for_Tegra/rootfs/
</syntaxhighlight>

4. Build the NVIDIA OoT modules:
<syntaxhighlight lang="bash">
make modules
</syntaxhighlight>

Compiled files will be under directory: '''nvidia-oot/drivers/media/i2c/'''. You should see file: '''nv_customcam.ko'''.

5. Install the module.

<syntaxhighlight lang="bash">
sudo -E make modules_install
</syntaxhighlight>

After this the module should be inside directory: '''Linux_for_Tegra/rootfs/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/'''.

6. Copy the module to the board using scp.
<syntaxhighlight lang="bash">
scp $INSTALL_MOD_PATH/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/nv_customcam.ko nvidia@<board-ip>:/tmp
</syntaxhighlight>

7. Inside the board:
<syntaxhighlight lang="bash">
sudo cp /tmp/nv_customcam.ko /lib/modules/5.15.148-tegra/updates/drivers/media/i2c/
sudo depmod -a 5.15.148-tegra
</syntaxhighlight>

8. Load the module

<syntaxhighlight lang="bash">
sudo modprobe nv_customcam
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T22:55:28Z

Nico: /* How to add a loadable kernel module (LKM) to JetPack 6.x */

=How to add a loadable kernel module (LKM) to JetPack 6.x=
''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot''
==Description==
This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x.

== Adding loadable kernel module ==

Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications are required:

* Add the driver source files: '''nv_customcam.c''' and '''nv_customcam.h'''
* Add register mode-table configuration file for the sensor's operating modes: '''customcam_mode_tbls.h'''.
* Add a Kconfig entry for the driver.
* Update Makefile to compile driver.
=== Adding the source and header files ===
1. Add source code file '''nv_customcam.c''' to directory '''nvidia-oot/drivers/media/i2c/'''.

2. Add header file '''nv_customcam.h''' to directory '''nvidia-oot/include/media/'''.

3. Add register mode-table configuration file '''customcam_mode_tbls.h''' to directory '''nvidia-oot/drivers/media/i2c/'''.

=== Intergrating the driver into the kernel build system ===

1. Add a new entry to '''Kconfig''' file in directory '''kernel/kernel-jammy-src/drivers/media/i2c/'''. This defines a configuration option that controls whether the module is built and how it is included on the kernel.

<syntaxhighlight lang="bash">
config NV_VIDEO_CUSTOMCAM
tristate "Custom cam"
depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
help
This driver supports CUSTOMCAM camera sensor.

To compile this driver as a module, choose M here: the module
will be called CUSTOMCAM.

</syntaxhighlight>

2. Add the following line to file '''defconfig''' in directory '''kernel/kernel-jammy-src/arch/arm64/configs/''' to configure the kernel for building the CUSTOMCAM driver as a module.
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Modify '''Makefile''' inside directory '''nvidia-oot/drivers/media/i2c/''' to build the new camera module added. Add the following line inside the '''Makefile'''.
<syntaxhighlight lang="bash">
obj-$(CONFIG_NV_VIDEO_CUSTOMCAM) += nv_imx708.o
</syntaxhighlight>

=== Building the NVIDIA out-of-tree modules ===

First build the kernel to update the kernel configuration file.

1. Go to '''Linux_for_Tegra/source''' directory. Set the following environment variables:
<syntaxhighlight lang="bash">
export CROSS_COMPILE=$HOME/l4t-gcc/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
export KERNEL_OUTPUT=$PWD/kernel_out
</syntaxhighlight>

2. Build the kernel.
<syntaxhighlight lang="bash">
make -C kernel
</syntaxhighlight>

Wait for the kernel to build. The kernel build will be under '''kernel_out''' set with environment variable '''KERNEL_OUTPUT'''. You can verify the changes to the files defconfig and the Kconfig inside '''kernel_out/.config'''. You should see this set:
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Set the install path environment variable.
<syntaxhighlight lang="bash">
export INSTALL_MOD_PATH=<PATH_TO>/Linux_for_Tegra/rootfs/
</syntaxhighlight>

4. Build the NVIDIA OoT modules:
<syntaxhighlight lang="bash">
make modules
</syntaxhighlight>

Compiled files will be under directory: '''nvidia-oot/drivers/media/i2c/'''. You should see file: '''nv_customcam.ko'''.

5. Install the module.

<syntaxhighlight lang="bash">
sudo -E make modules_install
</syntaxhighlight>

After this the module should be inside directory: '''Linux_for_Tegra/rootfs/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/'''.

6. Copy the module to the board using scp.
<syntaxhighlight lang="bash">
scp $INSTALL_MOD_PATH/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/nv_customcam.ko nvidia@<board-ip>:/tmp
</syntaxhighlight>

7. Inside the board:
<syntaxhighlight lang="bash">
sudo cp /tmp/nv_customcam.ko /lib/modules/5.15.148-tegra/updates/drivers/media/i2c/
sudo depmod -a 5.15.148-tegra
</syntaxhighlight>

8. Load the module

<syntaxhighlight lang="bash">
sudo modprobe nv_customcam
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T22:37:55Z

Nico: /* Building the NVIDIA out-of-tree modules */

=How to add a loadable kernel module (LKM) to JetPack 6.x=
''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot''
==Description==
This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x.

== Adding loadable kernel module ==

Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications are required:

* Add the driver source files: '''nv_customcam.c''' and '''nv_customcam.h'''
* Add register mode-table configuration file for the sensor's operating modes: '''customcam_mode_tbls.h'''.
* Add a Kconfig entry for the driver.
* Update Makefile to compile driver.
=== Adding the source and header files ===
1. Add source code file '''nv_customcam.c''' to directory '''nvidia-oot/drivers/media/i2c/'''.

2. Add header file '''nv_customcam.h''' to directory '''nvidia-oot/include/media/'''.

3. Add register mode-table configuration file '''customcam_mode_tbls.h''' to directory '''nvidia-oot/drivers/media/i2c/'''.

=== Intergrating the driver into the kernel build system ===

1. Add a new entry to '''Kconfig''' file in directory '''kernel/kernel-jammy-src/drivers/media/i2c/'''. This defines a configuration option that controls whether the module is built and how it is included on the kernel.

<syntaxhighlight lang="bash">
config NV_VIDEO_CUSTOMCAM
tristate "Custom cam"
depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
help
This driver supports CUSTOMCAM camera sensor.

To compile this driver as a module, choose M here: the module
will be called CUSTOMCAM.

</syntaxhighlight>

2. Add the following line to file '''defconfig''' in directory '''kernel/kernel-jammy-src/arch/arm64/configs/''' to configure the kernel for building the CUSTOMCAM driver as a module.
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Modify '''Makefile''' inside directory '''nvidia-oot/drivers/media/i2c/''' to build the new camera module added. Add the following line inside the '''Makefile'''.
<syntaxhighlight lang="bash">
obj-$(CONFIG_NV_VIDEO_CUSTOMCAM) += nv_imx708.o
</syntaxhighlight>

=== Building the NVIDIA out-of-tree modules ===

First build the kernel to update the kernel configuration file.

1. Go to '''Linux_for_Tegra/source''' directory. Set the following environment variables:
<syntaxhighlight lang="bash">
export CROSS_COMPILE=$HOME/l4t-gcc/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
export KERNEL_OUTPUT=$PWD/kernel_out
</syntaxhighlight>

2. Build the kernel.
<syntaxhighlight lang="bash">
make -C kernel
</syntaxhighlight>

Wait for the kernel to build. The kernel build will be under '''kernel_out''' set with environment variable '''KERNEL_OUTPUT'''. You can verify the changes to the files defconfig and the Kconfig inside '''kernel_out/.config'''. You should see this set:
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Set the install path environment variable.
<syntaxhighlight lang="bash">
export INSTALL_MOD_PATH=<PATH_TO>/Linux_for_Tegra/rootfs/
</syntaxhighlight>

4. Build the NVIDIA OoT modules:
<syntaxhighlight lang="bash">
make modules
</syntaxhighlight>

Compiled files will be under directory: '''nvidia-oot/drivers/media/i2c/'''. You should see file: '''nv_customcam.ko'''.

5. Install the module.

<syntaxhighlight lang="bash">
sudo -E make modules_install
</syntaxhighlight>

After this the module should be inside directory: '''Linux_for_Tegra/rootfs/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/'''.

6. Copy the module to the board using scp.
<syntaxhighlight lang="bash">
scp $INSTALL_MOD_PATH/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/nv_customcam.ko nvidia@<board-ip>:/tmp
</syntaxhighlight>

7. Inside the board:
<syntaxhighlight lang="bash">
sudo cp /tmp/nv_customcam.ko /lib/modules/5.15.148-tegra/updates/drivers/media/i2c/
sudo depmod -a 5.15.148-tegra
</syntaxhighlight>

8. Load the module

<syntaxhighlight lang="bash">
sudo modprobe nv_customcam
</syntaxhighlight>

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T22:25:16Z

Nico: /* Building the NVIDIA out-of-tree modules */

=How to add a loadable kernel module (LKM) to JetPack 6.x=
''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot''
==Description==
This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x.

== Adding loadable kernel module ==

Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications are required:

* Add the driver source files: '''nv_customcam.c''' and '''nv_customcam.h'''
* Add register mode-table configuration file for the sensor's operating modes: '''customcam_mode_tbls.h'''.
* Add a Kconfig entry for the driver.
* Update Makefile to compile driver.
=== Adding the source and header files ===
1. Add source code file '''nv_customcam.c''' to directory '''nvidia-oot/drivers/media/i2c/'''.

2. Add header file '''nv_customcam.h''' to directory '''nvidia-oot/include/media/'''.

3. Add register mode-table configuration file '''customcam_mode_tbls.h''' to directory '''nvidia-oot/drivers/media/i2c/'''.

=== Intergrating the driver into the kernel build system ===

1. Add a new entry to '''Kconfig''' file in directory '''kernel/kernel-jammy-src/drivers/media/i2c/'''. This defines a configuration option that controls whether the module is built and how it is included on the kernel.

<syntaxhighlight lang="bash">
config NV_VIDEO_CUSTOMCAM
tristate "Custom cam"
depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
help
This driver supports CUSTOMCAM camera sensor.

To compile this driver as a module, choose M here: the module
will be called CUSTOMCAM.

</syntaxhighlight>

2. Add the following line to file '''defconfig''' in directory '''kernel/kernel-jammy-src/arch/arm64/configs/''' to configure the kernel for building the CUSTOMCAM driver as a module.
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Modify '''Makefile''' inside directory '''nvidia-oot/drivers/media/i2c/''' to build the new camera module added. Add the following line inside the '''Makefile'''.
<syntaxhighlight lang="bash">
obj-$(CONFIG_NV_VIDEO_CUSTOMCAM) += nv_imx708.o
</syntaxhighlight>

=== Building the NVIDIA out-of-tree modules ===

First build the kernel to update the kernel configuration file.

1. Go to '''Linux_for_Tegra/source''' directory. Set the following environment variables:
<syntaxhighlight lang="bash">
export CROSS_COMPILE=$HOME/l4t-gcc/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
export KERNEL_OUTPUT=$PWD/kernel_out
</syntaxhighlight>

2. Build the kernel.
<syntaxhighlight lang="bash">
make -C kernel
</syntaxhighlight>

Wait for the kernel to build. The kernel build will be under '''kernel_out''' set with environment variable '''KERNEL_OUTPUT'''. You can verify the changes to the files defconfig and the Kconfig inside '''kernel_out/.config'''. You should see this set:
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Set the install path environment variable.
<syntaxhighlight lang="bash">
export INSTALL_MOD_PATH=<PATH_TO>/Linux_for_Tegra/rootfs/
</syntaxhighlight>

4. Build the NVIDIA OoT modules:
<syntaxhighlight lang="bash">
make modules
</syntaxhighlight>

Compiled files will be under directory: '''nvidia-oot/drivers/media/i2c/'''. You should see file: '''nv_customcam.ko'''.

5. Install the module.

<syntaxhighlight lang="bash">
sudo -E make modules_install
</syntaxhighlight>

After this the module should be inside directory: '''Linux_for_Tegra/rootfs/usr/lib/modules/5.15.148-tegra/updates/drivers/media/i2c/'''.

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T21:59:27Z

Nico: /* Building the NVIDIA out-of-tree modules */

=How to add a loadable kernel module (LKM) to JetPack 6.x=
''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot''
==Description==
This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x.

== Adding loadable kernel module ==

Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications are required:

* Add the driver source files: '''nv_customcam.c''' and '''nv_customcam.h'''
* Add register mode-table configuration file for the sensor's operating modes: '''customcam_mode_tbls.h'''.
* Add a Kconfig entry for the driver.
* Update Makefile to compile driver.
=== Adding the source and header files ===
1. Add source code file '''nv_customcam.c''' to directory '''nvidia-oot/drivers/media/i2c/'''.

2. Add header file '''nv_customcam.h''' to directory '''nvidia-oot/include/media/'''.

3. Add register mode-table configuration file '''customcam_mode_tbls.h''' to directory '''nvidia-oot/drivers/media/i2c/'''.

=== Intergrating the driver into the kernel build system ===

1. Add a new entry to '''Kconfig''' file in directory '''kernel/kernel-jammy-src/drivers/media/i2c/'''. This defines a configuration option that controls whether the module is built and how it is included on the kernel.

<syntaxhighlight lang="bash">
config NV_VIDEO_CUSTOMCAM
tristate "Custom cam"
depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
help
This driver supports CUSTOMCAM camera sensor.

To compile this driver as a module, choose M here: the module
will be called CUSTOMCAM.

</syntaxhighlight>

2. Add the following line to file '''defconfig''' in directory '''kernel/kernel-jammy-src/arch/arm64/configs/''' to configure the kernel for building the CUSTOMCAM driver as a module.
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Modify '''Makefile''' inside directory '''nvidia-oot/drivers/media/i2c/''' to build the new camera module added. Add the following line inside the '''Makefile'''.
<syntaxhighlight lang="bash">
obj-$(CONFIG_NV_VIDEO_CUSTOMCAM) += nv_imx708.o
</syntaxhighlight>

=== Building the NVIDIA out-of-tree modules ===

First build the kernel to update the kernel configuration file.

1. Go to '''Linux_for_Tegra/source''' directory. Set the following environment variables:
<syntaxhighlight lang="bash">
export CROSS_COMPILE=$HOME/l4t-gcc/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
export KERNEL_OUTPUT=$PWD/kernel_out
</syntaxhighlight>

2. Build the kernel.
<syntaxhighlight lang="bash">
make -C kernel
</syntaxhighlight>

Wait for the kernel to build. The kernel build will be under '''kernel_out''' set with environment variable '''KERNEL_OUTPUT'''. You can verify the changes to the files defconfig and the Kconfig inside '''kernel_out/.config'''. You should see this set:
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Set the install path environment variable.
<syntaxhighlight lang="bash">
export INSTALL_MOD_PATH=<PATH_TO>/Linux_for_Tegra/rootfs/
</syntaxhighlight>

4. Build the NVIDIA OoT modules:
<syntaxhighlight lang="bash">
make modules
</syntaxhighlight>

Compiled files will be under directory: '''nvidia-oot/drivers/media/i2c/'''. You should see file: '''nv_customcam.ko'''.

5. Install the module.

<syntaxhighlight lang="bash">
sudo -E make modules_install
</syntaxhighlight>

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T21:47:36Z

Nico: /* Intergrating the driver into the kernel build system */

=How to add a loadable kernel module (LKM) to JetPack 6.x=
''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot''
==Description==
This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x.

== Adding loadable kernel module ==

Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications are required:

* Add the driver source files: '''nv_customcam.c''' and '''nv_customcam.h'''
* Add register mode-table configuration file for the sensor's operating modes: '''customcam_mode_tbls.h'''.
* Add a Kconfig entry for the driver.
* Update Makefile to compile driver.
=== Adding the source and header files ===
1. Add source code file '''nv_customcam.c''' to directory '''nvidia-oot/drivers/media/i2c/'''.

2. Add header file '''nv_customcam.h''' to directory '''nvidia-oot/include/media/'''.

3. Add register mode-table configuration file '''customcam_mode_tbls.h''' to directory '''nvidia-oot/drivers/media/i2c/'''.

=== Intergrating the driver into the kernel build system ===

1. Add a new entry to '''Kconfig''' file in directory '''kernel/kernel-jammy-src/drivers/media/i2c/'''. This defines a configuration option that controls whether the module is built and how it is included on the kernel.

<syntaxhighlight lang="bash">
config NV_VIDEO_CUSTOMCAM
tristate "Custom cam"
depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
help
This driver supports CUSTOMCAM camera sensor.

To compile this driver as a module, choose M here: the module
will be called CUSTOMCAM.

</syntaxhighlight>

2. Add the following line to file '''defconfig''' in directory '''kernel/kernel-jammy-src/arch/arm64/configs/''' to configure the kernel for building the CUSTOMCAM driver as a module.
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Modify '''Makefile''' inside directory '''nvidia-oot/drivers/media/i2c/''' to build the new camera module added. Add the following line inside the '''Makefile'''.
<syntaxhighlight lang="bash">
obj-$(CONFIG_NV_VIDEO_CUSTOMCAM) += nv_imx708.o
</syntaxhighlight>

=== Building the NVIDIA out-of-tree modules ===

First build the kernel to update the kernel configuration file.

1. Go to '''Linux_for_Tegra/source''' directory. Set the following environment variables:
<syntaxhighlight lang="bash">
export CROSS_COMPILE=$HOME/l4t-gcc/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-
export KERNEL_HEADERS=$PWD/kernel/kernel-jammy-src
export KERNEL_OUTPUT=$PWD/kernel_out
</syntaxhighlight>

2. Build the kernel.
<syntaxhighlight lang="bash">
make -C kernel
</syntaxhighlight>

Wait for the kernel to build. The kernel build will be under '''kernel_out''' set with environment variable '''KERNEL_OUTPUT'''. You can verify the changes to the files defconfig and the Kconfig inside '''kernel_out/.config'''. You should see this set:
<syntaxhighlight lang="bash">
CONFIG_NV_VIDEO_CUSTOMCAM=m
</syntaxhighlight>

3. Set the install path environment variable.
<syntaxhighlight lang="bash">
export INSTALL_MOD_PATH=<PATH_TO>/Linux_for_Tegra/rootfs/
</syntaxhighlight>

4. Build the NVIDIA OoT modules:
<syntaxhighlight lang="bash">
make modules
</syntaxhighlight>

Compiled files will be under directory: '''nvidia-oot/drivers/media/i2c/'''. You should see file: '''nv_customcam.ko'''.

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T21:32:02Z

Nico: /* Intergrating the driver into the kernel build system */

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T21:30:47Z

Nico: /* Intergrating the driver into the kernel build system */

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T17:50:28Z

Nico: /* How to add a loadable kernel module (LKM) to JetPack 6.x */

How to add a loadable kernel module (LKM) to JetPack 6.x

2025-12-02T17:26:09Z

Nico: Created page with "=How to add a loadable kernel module (LKM) to JetPack 6.x= ''Keywords'': ''NVIDIA Jetson, JetPack, kernel customization, kernel modules, NVIDIA oot'' ==Description== This wiki page explains how to add a camera driver as a loadable kernel module on NVIDIA platforms running JetPack 6.x. == Adding loadable kernel module == Take '''nv_customcam''' as the example camera driver to be added as a loadable kernel module. For adding a new LKM the following kernel modifications..."

Main Page

2025-12-02T15:32:10Z

Nico: /* ⚙️ Technical Resources */

__NOTOC__
= Welcome to the ProventusNova Developer Wiki =
'''Expert knowledge for Embedded Systems, AI, and Software Development.'''

Looking to build high-performance embedded systems, optimize AI models, or streamline multimedia processing? This wiki is a '''public knowledge hub''' designed to help engineers, developers, and businesses solve real-world technical challenges.

Here, you’ll find '''step-by-step tutorials, best practices, and deep technical insights''' to help you bring your projects to life.

== 🚀 What You’ll Find Here ==

<div style="display: flex; flex-wrap: wrap; gap: 1em;">

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🛠️ Hands-on Tutorials'''
Practical guides to get you started quickly.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''📋 Industry Best Practices'''
Proven workflows and methodologies.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''⚡ Optimized Solutions'''
Performance tuning for embedded, AI, and multimedia applications.
</div>

<div style="flex: 1 1 250px; border: 1px solid #ccc; border-radius: 8px; padding: 1em; background-color: #f9f9f9;">
'''🌍 Open-Source Resources'''
Code samples, frameworks, and tools to accelerate development.
</div>

</div>

Whether you're an individual developer, a startup, or an enterprise, you’ll find resources here to '''enhance your expertise and improve your products'''.

== ⚙️ Technical Resources ==

Learn about core development domains, including embedded systems, AI, multimedia pipelines, and cloud-native solutions. Each section provides curated insights, guides, and best practices to help you build with assurance.

<div style="display: flex; flex-wrap: wrap; gap: 1em;">


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Embedded Systems Development]] – BSPs, firmware, and real-time processing.
</div>
<div style="padding: 1em;">
<div style="font-weight: bold; margin-top: 1em;">Embedded</div>
<ul>
<li>[[Embedded Platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Yocto</div>
<ul>
<li>[[How to create a custom yocto meta layer|Create custom Yocto meta layer]]</li>
<li>[[How to create a custom yocto recipe|Create custom Yocto recipe]]</li>
<li>[[Create custom Yocto meta layer for MediaTek G510 board|Create custom Yocto meta layer for MediaTek G510 board]]</li>
<li>[[How to add a custom partition layout to NVIDIA Jetson Platforms]]</li>
<li>[[How to read EEPROM data from NVIDIA Jetson platforms]]</li>
</ul>
<div style="font-weight: bold; margin-top: 1em;">Nvidia</div>
<ul>
<li>[[Nvidia Jetson Nano developer setup]]</li>
<li>[[Nvidia Jetson Orin NX with CTI Boson carrier board setup]]</li>
<li>[[Jetson Linux BSP and Kernel Source Setup]]</li>
<li> [[Adding Custom device tree overlay to JetPack 6.x]]</li>
<li> [[How to add a loadable kernel module (LKM) to JetPack 6.x]]</li>
<li> [[How to run NVIDIA NanoOWL tutorial]]
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[AI & Computer Vision]] – Edge AI, model training, and deployment.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[GStreamer Development]] – High-performance video and audio streaming.
</div>
<div style="padding: 1em;">
<ul>
<li>[[GStreamer Fundamentals]]</li>
<li>[[GStreamer Daemon]]</li>
<li>[[GStreamer Interpipes]]</li>
<li>[[GStreamer Application Development]]</li>
<li>[[GStreamer Best Practices]]</li>
<li>[[GStreamer video streaming, recording and snapshots with tee on Python]]</li>
</ul>
</div>
</div>


<div style="flex: 1 1 calc(50% - 1em); min-width: 300px; border: 1px solid #ccc; border-radius: 8px; overflow: hidden; background-color: #eef6ff;">
<div style="background-color: #d9eaff; padding: 0.75em; font-weight: bold; font-size: 1.1em;">
[[Web & Cloud Solutions]] – Scalable, production-ready applications.
</div>
<div style="padding: 1em;">
<ul>
<li>Coming Soon!</li>
</ul>
</div>
</div>

</div>

== 👀 Are you a PM looking to expand your knowledge in the software development industry? ==

This tutorial is for you!
Explore essential concepts that will help you navigate technical discussions with engineers and clients more confidently.

📄'''[[Project Manager Tutorials]]'''

== 🛠️ Developer Tools ==

This section provides essential guidelines and practices to ensure consistency, clarity, and efficiency across all development efforts. These tools and standards help teams collaborate better and maintain high-quality codebases.

🔀 '''[[Git workflow]]''': A structured guide to how our team uses Git—from branching strategies to pull request protocols—ensuring smooth collaboration and clean version history.

🧾 '''[[Naming Conventions]]''': Standardized naming rules for code elements such as variables, functions, classes, and files, helping improve readability and maintainability across projects.

== 🐞🛠️ Debugging methods and error/bug fixes ==
This section provides the best debugging methods as well as common error/bug fixes.

'''Yocto'''<br>
Yocto Project related debugging methods and error/bug fixes <br>
*[[Error:_BitBake_%2B_AppArmor_User_Namespace_Restriction_Fix|Error: BitBake+AppArmor User Namespace Restriction Fix]]

'''Nvidia'''<br>
Nvidia related debugging methods and error/bug fixes <br>
*[[Debug_NVIDIA_Jetson_nvv4l2av1enc_VPR_Violation_(EMEM_decode_error)| Debug NVIDIA Jetson nvv4l2av1enc VPR Violation (EMEM decode error)]]


{{Footer}}

How to run NVIDIA NanoOWL tutorial

2025-11-26T18:59:45Z

Nico: /* Performance improvements */

=How to run NVIDIA NanoOWL tutorial=
''Keywords'': ''NVIDIA Jetson, NanoOWL, object detection''
==Description==
This wiki pages shows how to run the tree prediction with a live camera tutorial from NVIDIA NanoOWL. NanoOWL is a project that optimizes OWL-ViT to run '''real-time''' on NVIDIA Jetson Orin Platforms with NVIDIA TensorRT. NanoOWL also introduces a new "tree detection" pipeline that combines OWL-ViT and CLIP to enable nested detection and classification of anything, at any level, simply by providing text.

==Set up==
Minimal requirements:
* One of the following Jetson:
** Jetson Orin NX (16 GB)
** Jetson Orin Nano (8 GB)
** Jetson AGX Orin (32 GB or 64 GB)

* Running one of the following JetPack versions:
** Jetpack 5 (L4T r35.x)
** Jetpack 6 (L4T r36.x)

This tutorial was tested with the following setup:
* x86/x64 based host machine running Ubuntu 24.04
* Jetson Orin NX (16 GB) + CTI Boson carrier board running Jetpack 6.2.1 (L4T 36.4.4).
* One Framos IMX464 camera
* Ethernet cable

1. Connect to the board via ssh:
<syntaxhighlight lang="bash">
ssh <user>@<board_ip>
</syntaxhighlight>

Now you should be inside the board.

== Tutorial ==

1. Clone and setup '''jetson-containers'''

<syntaxhighlight lang="bash">
git clone https://github.com/dusty-nv/jetson-containers
bash jetson-containers/install.sh
</syntaxhighlight>

2. Run the following to pull or build a compatible container image.
<syntaxhighlight lang="bash">
jetson-containers run --workdir /opt/nanoowl $(autotag nanoowl)
</syntaxhighlight>

After running above command you should be in workdir ('''/opt/nanoowl''') inside the container.

3. Verify you have a camera connected:
<syntaxhighlight lang="bash">
ls /dev/video*
</syntaxhighlight>

4. Install missing module inside container:

<syntaxhighlight lang="bash">
pip install aiohttp
</syntaxhighlight>

Note: If this takes too long or fails, try the following command:
<syntaxhighlight lang="bash">
pip install aiohttp --index-url https://pypi.org/simple --prefer-binary
</syntaxhighlight>

5. Run the '''tree_demo.py''' example.
<syntaxhighlight lang="bash">
cd examples/tree_demo
python3 tree_demo.py --camera 0 --resolution 640x480 ../../data/owl_image_encoder_patch32.engine
</syntaxhighlight>

You should see the following after the application starts:
<syntaxhighlight lang="bash">
======== Running on http://0.0.0.0:7860 ========
(Press CTRL+C to quit)
</syntaxhighlight>

6. On your host PC, open browser to:
<syntaxhighlight lang="bash">
http://<board_ip>:7860
</syntaxhighlight>

7. Now you are ready to test some prompts! Use the following as examples:
* [a face]
* [a face, a ball]
* [a face [a nose, an eye]]

== Adaptations ==

* If you are using a camera that does not support the GStreamer '''v4l2src''' element—for example, a CSI-connected camera—you may encounter an error similar to the following:
<syntaxhighlight lang="bash">
[ WARN:0@15.685] global cap_gstreamer.cpp:2829 handleMessage OpenCV | GStreamer warning: Embedded video playback halted; module v4l2src0 reported: Internal data stream error.
</syntaxhighlight>

To enable frame capture from such a camera, modify the '''detection_loop''' method as follows:
<syntaxhighlight lang="python">
# Delete or comment the three lines of code below
# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)

# Add the following GStreamer pipeline to use nvarguscamerasrc
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
</syntaxhighlight>

== Performance improvements ==

* Observation: In the original implementation, both frame capture and model prediction were executed inside the same synchronous function ('''_read_and_encode_image'''). This caused the entire video pipeline to block while waiting for the model to finish inference, resulting in several seconds of latency in the browser.

* Improvement: To resolve this, the prediction logic was moved into a separate asynchronous background task ('''prediction_loop'''). This design fully decouples capture from prediction, ensuring that the video stream remains smooth and low-latency, even when inference takes several seconds.

Find below the complete code implementation separating the capture loop from the prediction loop.

<syntaxhighlight lang="python">
# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import asyncio
import argparse
from aiohttp import web, WSCloseCode
import logging
import weakref
import cv2
import time
import PIL.Image
import matplotlib.pyplot as plt
from typing import List
from nanoowl.tree import Tree
from nanoowl.tree_predictor import (
TreePredictor
)
from nanoowl.tree_drawing import draw_tree_output
from nanoowl.owl_predictor import OwlPredictor

if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("image_encode_engine", type=str)
parser.add_argument("--image_quality", type=int, default=50)
parser.add_argument("--port", type=int, default=7860)
parser.add_argument("--host", type=str, default="0.0.0.0")
parser.add_argument("--camera", type=int, default=0)
parser.add_argument("--resolution", type=str, default="640x480", help="Camera resolution as WIDTHxHEIGHT")
args = parser.parse_args()
width, height = map(int, args.resolution.split("x"))

CAMERA_DEVICE = args.camera
IMAGE_QUALITY = args.image_quality

predictor = TreePredictor(
owl_predictor=OwlPredictor(
image_encoder_engine=args.image_encode_engine
)
)

prompt_data = None

# Shared state between capture and prediction
shared_state = {
"latest_frame": None,
"latest_detections": None,
"frame_count": 0
}

def get_colors(count: int):
cmap = plt.cm.get_cmap("rainbow", count)
colors = []
for i in range(count):
color = cmap(i)
color = [int(255 * value) for value in color]
colors.append(tuple(color))
return colors

def cv2_to_pil(image):
t0 = time.perf_counter_ns()
t1 = time.perf_counter_ns()
dt = (t1 - t0) / 1e9
logging.info(f"CV2 to PIL time: {dt:.3f}s")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
return PIL.Image.fromarray(image)

async def handle_index_get(request: web.Request):
logging.info("handle_index_get")
return web.FileResponse("./index.html")

async def websocket_handler(request):

global prompt_data

ws = web.WebSocketResponse()

await ws.prepare(request)

logging.info("Websocket connected.")

request.app['websockets'].add(ws)

try:
async for msg in ws:
logging.info(f"Received message from websocket.")
if "prompt" in msg.data:
header, prompt = msg.data.split(":")
logging.info("Received prompt: " + prompt)
try:
tree = Tree.from_prompt(prompt)
clip_encodings = predictor.encode_clip_text(tree)
owl_encodings = predictor.encode_owl_text(tree)
prompt_data = {
"tree": tree,
"clip_encodings": clip_encodings,
"owl_encodings": owl_encodings
}
logging.info("Set prompt: " + prompt)
except Exception as e:
print(e)
finally:
request.app['websockets'].discard(ws)

return ws

async def on_shutdown(app: web.Application):
for ws in set(app['websockets']):
await ws.close(code=WSCloseCode.GOING_AWAY,
message='Server shutdown')

async def detection_loop(app: web.Application):

loop = asyncio.get_running_loop()

logging.info("Opening camera.")

# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
logging.info("Loading predictor.")

def _read_and_encode_image():
re, image = camera.read()
if not re:
return re, None

shared_state["latest_frame"] = image.copy() # keep a copy for prediction
shared_state["frame_count"] += 1

# draw predictions if available (non-blocking)
if prompt_data is not None and shared_state["latest_detections"] is not None:
image = draw_tree_output(image, shared_state["latest_detections"], prompt_data["tree"])

image_jpeg = bytes(
cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, IMAGE_QUALITY])[1]
)
return re, image_jpeg

while True:

re, image = await loop.run_in_executor(None, _read_and_encode_image)

if not re:
break

for ws in app["websockets"]:
await ws.send_bytes(image)

camera.release()

async def prediction_loop():
loop = asyncio.get_running_loop()
while True:
await asyncio.sleep(0)

if prompt_data is None or shared_state["latest_frame"] is None:
continue

# Copy latest frame for prediction
frame_to_predict = shared_state["latest_frame"].copy()
image_pil = cv2_to_pil(frame_to_predict)

# Run predictor in thread pool (non-blocking)
detections = await loop.run_in_executor(
None,
lambda: predictor.predict(
image_pil,
tree=prompt_data['tree'],
clip_text_encodings=prompt_data['clip_encodings'],
owl_text_encodings=prompt_data['owl_encodings']
)
)

shared_state["latest_detections"] = detections

async def run_detection_loop(app):
try:
task_video = asyncio.create_task(detection_loop(app))
task_pred = asyncio.create_task(prediction_loop())

yield
await asyncio.gather(task_video, task_pred)
except asyncio.CancelledError:
pass
finally:
task_video.cancel()
task_pred.cancel()
await asyncio.gather(task_video, task_pred, return_exceptions=True)

logging.basicConfig(level=logging.INFO)
app = web.Application()
app['websockets'] = weakref.WeakSet()
app.router.add_get("/", handle_index_get)
app.router.add_route("GET", "/ws", websocket_handler)
app.on_shutdown.append(on_shutdown)
app.cleanup_ctx.append(run_detection_loop)
web.run_app(app, host=args.host, port=args.port)
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to run NVIDIA NanoOWL tutorial

2025-11-26T18:58:55Z

Nico: /* Performance improvements */

=How to run NVIDIA NanoOWL tutorial=
''Keywords'': ''NVIDIA Jetson, NanoOWL, object detection''
==Description==
This wiki pages shows how to run the tree prediction with a live camera tutorial from NVIDIA NanoOWL. NanoOWL is a project that optimizes OWL-ViT to run '''real-time''' on NVIDIA Jetson Orin Platforms with NVIDIA TensorRT. NanoOWL also introduces a new "tree detection" pipeline that combines OWL-ViT and CLIP to enable nested detection and classification of anything, at any level, simply by providing text.

==Set up==
Minimal requirements:
* One of the following Jetson:
** Jetson Orin NX (16 GB)
** Jetson Orin Nano (8 GB)
** Jetson AGX Orin (32 GB or 64 GB)

* Running one of the following JetPack versions:
** Jetpack 5 (L4T r35.x)
** Jetpack 6 (L4T r36.x)

This tutorial was tested with the following setup:
* x86/x64 based host machine running Ubuntu 24.04
* Jetson Orin NX (16 GB) + CTI Boson carrier board running Jetpack 6.2.1 (L4T 36.4.4).
* One Framos IMX464 camera
* Ethernet cable

1. Connect to the board via ssh:
<syntaxhighlight lang="bash">
ssh <user>@<board_ip>
</syntaxhighlight>

Now you should be inside the board.

== Tutorial ==

1. Clone and setup '''jetson-containers'''

<syntaxhighlight lang="bash">
git clone https://github.com/dusty-nv/jetson-containers
bash jetson-containers/install.sh
</syntaxhighlight>

2. Run the following to pull or build a compatible container image.
<syntaxhighlight lang="bash">
jetson-containers run --workdir /opt/nanoowl $(autotag nanoowl)
</syntaxhighlight>

After running above command you should be in workdir ('''/opt/nanoowl''') inside the container.

3. Verify you have a camera connected:
<syntaxhighlight lang="bash">
ls /dev/video*
</syntaxhighlight>

4. Install missing module inside container:

<syntaxhighlight lang="bash">
pip install aiohttp
</syntaxhighlight>

Note: If this takes too long or fails, try the following command:
<syntaxhighlight lang="bash">
pip install aiohttp --index-url https://pypi.org/simple --prefer-binary
</syntaxhighlight>

5. Run the '''tree_demo.py''' example.
<syntaxhighlight lang="bash">
cd examples/tree_demo
python3 tree_demo.py --camera 0 --resolution 640x480 ../../data/owl_image_encoder_patch32.engine
</syntaxhighlight>

You should see the following after the application starts:
<syntaxhighlight lang="bash">
======== Running on http://0.0.0.0:7860 ========
(Press CTRL+C to quit)
</syntaxhighlight>

6. On your host PC, open browser to:
<syntaxhighlight lang="bash">
http://<board_ip>:7860
</syntaxhighlight>

7. Now you are ready to test some prompts! Use the following as examples:
* [a face]
* [a face, a ball]
* [a face [a nose, an eye]]

== Adaptations ==

* If you are using a camera that does not support the GStreamer '''v4l2src''' element—for example, a CSI-connected camera—you may encounter an error similar to the following:
<syntaxhighlight lang="bash">
[ WARN:0@15.685] global cap_gstreamer.cpp:2829 handleMessage OpenCV | GStreamer warning: Embedded video playback halted; module v4l2src0 reported: Internal data stream error.
</syntaxhighlight>

To enable frame capture from such a camera, modify the '''detection_loop''' method as follows:
<syntaxhighlight lang="python">
# Delete or comment the three lines of code below
# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)

# Add the following GStreamer pipeline to use nvarguscamerasrc
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
</syntaxhighlight>

== Performance improvements ==

* Observation: In the original implementation, both frame capture and model prediction were executed inside the same synchronous function ('''_read_and_encode_image'''). This caused the entire video pipeline to block while waiting for the model to finish inference, resulting in several seconds of latency in the browser.

* Improvement: To resolve this, the prediction logic was moved into a separate asynchronous background task ('''prediction_loop'''). This design fully decouples capture from prediction, ensuring that the video stream remains smooth and low-latency, even when inference takes several seconds.

Find below the complete code implementation separating the capture loop from the prediction loop.

<syntaxhighlight lang="python">
# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import asyncio
import argparse
from aiohttp import web, WSCloseCode
import logging
import weakref
import cv2
import time
import PIL.Image
import matplotlib.pyplot as plt
from typing import List
from nanoowl.tree import Tree
from nanoowl.tree_predictor import (
TreePredictor
)
from nanoowl.tree_drawing import draw_tree_output
from nanoowl.owl_predictor import OwlPredictor

if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("image_encode_engine", type=str)
parser.add_argument("--image_quality", type=int, default=50)
parser.add_argument("--port", type=int, default=7860)
parser.add_argument("--host", type=str, default="0.0.0.0")
parser.add_argument("--camera", type=int, default=0)
parser.add_argument("--resolution", type=str, default="640x480", help="Camera resolution as WIDTHxHEIGHT")
args = parser.parse_args()
width, height = map(int, args.resolution.split("x"))

CAMERA_DEVICE = args.camera
IMAGE_QUALITY = args.image_quality

predictor = TreePredictor(
owl_predictor=OwlPredictor(
image_encoder_engine=args.image_encode_engine
)
)

prompt_data = None

# Shared state between capture and prediction
shared_state = {
"latest_frame": None,
"latest_detections": None,
"frame_count": 0
}

def get_colors(count: int):
cmap = plt.cm.get_cmap("rainbow", count)
colors = []
for i in range(count):
color = cmap(i)
color = [int(255 * value) for value in color]
colors.append(tuple(color))
return colors

def cv2_to_pil(image):
t0 = time.perf_counter_ns()
t1 = time.perf_counter_ns()
dt = (t1 - t0) / 1e9
logging.info(f"CV2 to PIL time: {dt:.3f}s")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
return PIL.Image.fromarray(image)

async def handle_index_get(request: web.Request):
logging.info("handle_index_get")
return web.FileResponse("./index.html")

async def websocket_handler(request):

global prompt_data

ws = web.WebSocketResponse()

await ws.prepare(request)

logging.info("Websocket connected.")

request.app['websockets'].add(ws)

try:
async for msg in ws:
logging.info(f"Received message from websocket.")
if "prompt" in msg.data:
header, prompt = msg.data.split(":")
logging.info("Received prompt: " + prompt)
try:
tree = Tree.from_prompt(prompt)
clip_encodings = predictor.encode_clip_text(tree)
owl_encodings = predictor.encode_owl_text(tree)
prompt_data = {
"tree": tree,
"clip_encodings": clip_encodings,
"owl_encodings": owl_encodings
}
logging.info("Set prompt: " + prompt)
except Exception as e:
print(e)
finally:
request.app['websockets'].discard(ws)

return ws

async def on_shutdown(app: web.Application):
for ws in set(app['websockets']):
await ws.close(code=WSCloseCode.GOING_AWAY,
message='Server shutdown')

async def detection_loop(app: web.Application):

loop = asyncio.get_running_loop()

logging.info("Opening camera.")

# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
logging.info("Loading predictor.")
frame_count = 0
predict_every_n_frames = 1 # predict every 15 frames

def _read_and_encode_image():
re, image = camera.read()
if not re:
return re, None

shared_state["latest_frame"] = image.copy() # keep a copy for prediction
shared_state["frame_count"] += 1

# draw predictions if available (non-blocking)
if prompt_data is not None and shared_state["latest_detections"] is not None:
image = draw_tree_output(image, shared_state["latest_detections"], prompt_data["tree"])

image_jpeg = bytes(
cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, IMAGE_QUALITY])[1]
)
return re, image_jpeg

while True:

re, image = await loop.run_in_executor(None, _read_and_encode_image)

if not re:
break

for ws in app["websockets"]:
await ws.send_bytes(image)

camera.release()

async def prediction_loop():
loop = asyncio.get_running_loop()
while True:
await asyncio.sleep(0)

if prompt_data is None or shared_state["latest_frame"] is None:
continue

# Copy latest frame for prediction
frame_to_predict = shared_state["latest_frame"].copy()
image_pil = cv2_to_pil(frame_to_predict)

# Run predictor in thread pool (non-blocking)
detections = await loop.run_in_executor(
None,
lambda: predictor.predict(
image_pil,
tree=prompt_data['tree'],
clip_text_encodings=prompt_data['clip_encodings'],
owl_text_encodings=prompt_data['owl_encodings']
)
)

shared_state["latest_detections"] = detections

async def run_detection_loop(app):
try:
task_video = asyncio.create_task(detection_loop(app))
task_pred = asyncio.create_task(prediction_loop())

yield
await asyncio.gather(task_video, task_pred)
except asyncio.CancelledError:
pass
finally:
task_video.cancel()
task_pred.cancel()
await asyncio.gather(task_video, task_pred, return_exceptions=True)

logging.basicConfig(level=logging.INFO)
app = web.Application()
app['websockets'] = weakref.WeakSet()
app.router.add_get("/", handle_index_get)
app.router.add_route("GET", "/ws", websocket_handler)
app.on_shutdown.append(on_shutdown)
app.cleanup_ctx.append(run_detection_loop)
web.run_app(app, host=args.host, port=args.port)
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to run NVIDIA NanoOWL tutorial

2025-11-26T18:58:42Z

Nico: /* Performance improvements */

=How to run NVIDIA NanoOWL tutorial=
''Keywords'': ''NVIDIA Jetson, NanoOWL, object detection''
==Description==
This wiki pages shows how to run the tree prediction with a live camera tutorial from NVIDIA NanoOWL. NanoOWL is a project that optimizes OWL-ViT to run '''real-time''' on NVIDIA Jetson Orin Platforms with NVIDIA TensorRT. NanoOWL also introduces a new "tree detection" pipeline that combines OWL-ViT and CLIP to enable nested detection and classification of anything, at any level, simply by providing text.

==Set up==
Minimal requirements:
* One of the following Jetson:
** Jetson Orin NX (16 GB)
** Jetson Orin Nano (8 GB)
** Jetson AGX Orin (32 GB or 64 GB)

* Running one of the following JetPack versions:
** Jetpack 5 (L4T r35.x)
** Jetpack 6 (L4T r36.x)

This tutorial was tested with the following setup:
* x86/x64 based host machine running Ubuntu 24.04
* Jetson Orin NX (16 GB) + CTI Boson carrier board running Jetpack 6.2.1 (L4T 36.4.4).
* One Framos IMX464 camera
* Ethernet cable

1. Connect to the board via ssh:
<syntaxhighlight lang="bash">
ssh <user>@<board_ip>
</syntaxhighlight>

Now you should be inside the board.

== Tutorial ==

1. Clone and setup '''jetson-containers'''

<syntaxhighlight lang="bash">
git clone https://github.com/dusty-nv/jetson-containers
bash jetson-containers/install.sh
</syntaxhighlight>

2. Run the following to pull or build a compatible container image.
<syntaxhighlight lang="bash">
jetson-containers run --workdir /opt/nanoowl $(autotag nanoowl)
</syntaxhighlight>

After running above command you should be in workdir ('''/opt/nanoowl''') inside the container.

3. Verify you have a camera connected:
<syntaxhighlight lang="bash">
ls /dev/video*
</syntaxhighlight>

4. Install missing module inside container:

<syntaxhighlight lang="bash">
pip install aiohttp
</syntaxhighlight>

Note: If this takes too long or fails, try the following command:
<syntaxhighlight lang="bash">
pip install aiohttp --index-url https://pypi.org/simple --prefer-binary
</syntaxhighlight>

5. Run the '''tree_demo.py''' example.
<syntaxhighlight lang="bash">
cd examples/tree_demo
python3 tree_demo.py --camera 0 --resolution 640x480 ../../data/owl_image_encoder_patch32.engine
</syntaxhighlight>

You should see the following after the application starts:
<syntaxhighlight lang="bash">
======== Running on http://0.0.0.0:7860 ========
(Press CTRL+C to quit)
</syntaxhighlight>

6. On your host PC, open browser to:
<syntaxhighlight lang="bash">
http://<board_ip>:7860
</syntaxhighlight>

7. Now you are ready to test some prompts! Use the following as examples:
* [a face]
* [a face, a ball]
* [a face [a nose, an eye]]

== Adaptations ==

* If you are using a camera that does not support the GStreamer '''v4l2src''' element—for example, a CSI-connected camera—you may encounter an error similar to the following:
<syntaxhighlight lang="bash">
[ WARN:0@15.685] global cap_gstreamer.cpp:2829 handleMessage OpenCV | GStreamer warning: Embedded video playback halted; module v4l2src0 reported: Internal data stream error.
</syntaxhighlight>

To enable frame capture from such a camera, modify the '''detection_loop''' method as follows:
<syntaxhighlight lang="python">
# Delete or comment the three lines of code below
# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)

# Add the following GStreamer pipeline to use nvarguscamerasrc
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
</syntaxhighlight>

== Performance improvements ==

<details>
<summary>Click to show full code</summary>

<syntaxhighlight lang="python">
# ... your code here ...
</syntaxhighlight>

</details>

* Observation: In the original implementation, both frame capture and model prediction were executed inside the same synchronous function ('''_read_and_encode_image'''). This caused the entire video pipeline to block while waiting for the model to finish inference, resulting in several seconds of latency in the browser.

* Improvement: To resolve this, the prediction logic was moved into a separate asynchronous background task ('''prediction_loop'''). This design fully decouples capture from prediction, ensuring that the video stream remains smooth and low-latency, even when inference takes several seconds.

Find below the complete code implementation separating the capture loop from the prediction loop.

<syntaxhighlight lang="python">
# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import asyncio
import argparse
from aiohttp import web, WSCloseCode
import logging
import weakref
import cv2
import time
import PIL.Image
import matplotlib.pyplot as plt
from typing import List
from nanoowl.tree import Tree
from nanoowl.tree_predictor import (
TreePredictor
)
from nanoowl.tree_drawing import draw_tree_output
from nanoowl.owl_predictor import OwlPredictor

if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("image_encode_engine", type=str)
parser.add_argument("--image_quality", type=int, default=50)
parser.add_argument("--port", type=int, default=7860)
parser.add_argument("--host", type=str, default="0.0.0.0")
parser.add_argument("--camera", type=int, default=0)
parser.add_argument("--resolution", type=str, default="640x480", help="Camera resolution as WIDTHxHEIGHT")
args = parser.parse_args()
width, height = map(int, args.resolution.split("x"))

CAMERA_DEVICE = args.camera
IMAGE_QUALITY = args.image_quality

predictor = TreePredictor(
owl_predictor=OwlPredictor(
image_encoder_engine=args.image_encode_engine
)
)

prompt_data = None

# Shared state between capture and prediction
shared_state = {
"latest_frame": None,
"latest_detections": None,
"frame_count": 0
}

def get_colors(count: int):
cmap = plt.cm.get_cmap("rainbow", count)
colors = []
for i in range(count):
color = cmap(i)
color = [int(255 * value) for value in color]
colors.append(tuple(color))
return colors

def cv2_to_pil(image):
t0 = time.perf_counter_ns()
t1 = time.perf_counter_ns()
dt = (t1 - t0) / 1e9
logging.info(f"CV2 to PIL time: {dt:.3f}s")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
return PIL.Image.fromarray(image)

async def handle_index_get(request: web.Request):
logging.info("handle_index_get")
return web.FileResponse("./index.html")

async def websocket_handler(request):

global prompt_data

ws = web.WebSocketResponse()

await ws.prepare(request)

logging.info("Websocket connected.")

request.app['websockets'].add(ws)

try:
async for msg in ws:
logging.info(f"Received message from websocket.")
if "prompt" in msg.data:
header, prompt = msg.data.split(":")
logging.info("Received prompt: " + prompt)
try:
tree = Tree.from_prompt(prompt)
clip_encodings = predictor.encode_clip_text(tree)
owl_encodings = predictor.encode_owl_text(tree)
prompt_data = {
"tree": tree,
"clip_encodings": clip_encodings,
"owl_encodings": owl_encodings
}
logging.info("Set prompt: " + prompt)
except Exception as e:
print(e)
finally:
request.app['websockets'].discard(ws)

return ws

async def on_shutdown(app: web.Application):
for ws in set(app['websockets']):
await ws.close(code=WSCloseCode.GOING_AWAY,
message='Server shutdown')

async def detection_loop(app: web.Application):

loop = asyncio.get_running_loop()

logging.info("Opening camera.")

# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
logging.info("Loading predictor.")
frame_count = 0
predict_every_n_frames = 1 # predict every 15 frames

def _read_and_encode_image():
re, image = camera.read()
if not re:
return re, None

shared_state["latest_frame"] = image.copy() # keep a copy for prediction
shared_state["frame_count"] += 1

# draw predictions if available (non-blocking)
if prompt_data is not None and shared_state["latest_detections"] is not None:
image = draw_tree_output(image, shared_state["latest_detections"], prompt_data["tree"])

image_jpeg = bytes(
cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, IMAGE_QUALITY])[1]
)
return re, image_jpeg

while True:

re, image = await loop.run_in_executor(None, _read_and_encode_image)

if not re:
break

for ws in app["websockets"]:
await ws.send_bytes(image)

camera.release()

async def prediction_loop():
loop = asyncio.get_running_loop()
while True:
await asyncio.sleep(0)

if prompt_data is None or shared_state["latest_frame"] is None:
continue

# Copy latest frame for prediction
frame_to_predict = shared_state["latest_frame"].copy()
image_pil = cv2_to_pil(frame_to_predict)

# Run predictor in thread pool (non-blocking)
detections = await loop.run_in_executor(
None,
lambda: predictor.predict(
image_pil,
tree=prompt_data['tree'],
clip_text_encodings=prompt_data['clip_encodings'],
owl_text_encodings=prompt_data['owl_encodings']
)
)

shared_state["latest_detections"] = detections

async def run_detection_loop(app):
try:
task_video = asyncio.create_task(detection_loop(app))
task_pred = asyncio.create_task(prediction_loop())

yield
await asyncio.gather(task_video, task_pred)
except asyncio.CancelledError:
pass
finally:
task_video.cancel()
task_pred.cancel()
await asyncio.gather(task_video, task_pred, return_exceptions=True)

logging.basicConfig(level=logging.INFO)
app = web.Application()
app['websockets'] = weakref.WeakSet()
app.router.add_get("/", handle_index_get)
app.router.add_route("GET", "/ws", websocket_handler)
app.on_shutdown.append(on_shutdown)
app.cleanup_ctx.append(run_detection_loop)
web.run_app(app, host=args.host, port=args.port)
</syntaxhighlight>

= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to run NVIDIA NanoOWL tutorial

2025-11-26T18:57:19Z

Nico: /* How to run NVIDIA NanoOWL tutorial */

=How to run NVIDIA NanoOWL tutorial=
''Keywords'': ''NVIDIA Jetson, NanoOWL, object detection''
==Description==
This wiki pages shows how to run the tree prediction with a live camera tutorial from NVIDIA NanoOWL. NanoOWL is a project that optimizes OWL-ViT to run '''real-time''' on NVIDIA Jetson Orin Platforms with NVIDIA TensorRT. NanoOWL also introduces a new "tree detection" pipeline that combines OWL-ViT and CLIP to enable nested detection and classification of anything, at any level, simply by providing text.

==Set up==
Minimal requirements:
* One of the following Jetson:
** Jetson Orin NX (16 GB)
** Jetson Orin Nano (8 GB)
** Jetson AGX Orin (32 GB or 64 GB)

* Running one of the following JetPack versions:
** Jetpack 5 (L4T r35.x)
** Jetpack 6 (L4T r36.x)

This tutorial was tested with the following setup:
* x86/x64 based host machine running Ubuntu 24.04
* Jetson Orin NX (16 GB) + CTI Boson carrier board running Jetpack 6.2.1 (L4T 36.4.4).
* One Framos IMX464 camera
* Ethernet cable

1. Connect to the board via ssh:
<syntaxhighlight lang="bash">
ssh <user>@<board_ip>
</syntaxhighlight>

Now you should be inside the board.

== Tutorial ==

1. Clone and setup '''jetson-containers'''

<syntaxhighlight lang="bash">
git clone https://github.com/dusty-nv/jetson-containers
bash jetson-containers/install.sh
</syntaxhighlight>

2. Run the following to pull or build a compatible container image.
<syntaxhighlight lang="bash">
jetson-containers run --workdir /opt/nanoowl $(autotag nanoowl)
</syntaxhighlight>

After running above command you should be in workdir ('''/opt/nanoowl''') inside the container.

3. Verify you have a camera connected:
<syntaxhighlight lang="bash">
ls /dev/video*
</syntaxhighlight>

4. Install missing module inside container:

<syntaxhighlight lang="bash">
pip install aiohttp
</syntaxhighlight>

Note: If this takes too long or fails, try the following command:
<syntaxhighlight lang="bash">
pip install aiohttp --index-url https://pypi.org/simple --prefer-binary
</syntaxhighlight>

5. Run the '''tree_demo.py''' example.
<syntaxhighlight lang="bash">
cd examples/tree_demo
python3 tree_demo.py --camera 0 --resolution 640x480 ../../data/owl_image_encoder_patch32.engine
</syntaxhighlight>

You should see the following after the application starts:
<syntaxhighlight lang="bash">
======== Running on http://0.0.0.0:7860 ========
(Press CTRL+C to quit)
</syntaxhighlight>

6. On your host PC, open browser to:
<syntaxhighlight lang="bash">
http://<board_ip>:7860
</syntaxhighlight>

7. Now you are ready to test some prompts! Use the following as examples:
* [a face]
* [a face, a ball]
* [a face [a nose, an eye]]

== Adaptations ==

* If you are using a camera that does not support the GStreamer '''v4l2src''' element—for example, a CSI-connected camera—you may encounter an error similar to the following:
<syntaxhighlight lang="bash">
[ WARN:0@15.685] global cap_gstreamer.cpp:2829 handleMessage OpenCV | GStreamer warning: Embedded video playback halted; module v4l2src0 reported: Internal data stream error.
</syntaxhighlight>

To enable frame capture from such a camera, modify the '''detection_loop''' method as follows:
<syntaxhighlight lang="python">
# Delete or comment the three lines of code below
# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)

# Add the following GStreamer pipeline to use nvarguscamerasrc
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
</syntaxhighlight>

== Performance improvements ==

* Observation: In the original implementation, both frame capture and model prediction were executed inside the same synchronous function ('''_read_and_encode_image'''). This caused the entire video pipeline to block while waiting for the model to finish inference, resulting in several seconds of latency in the browser.

* Improvement: To resolve this, the prediction logic was moved into a separate asynchronous background task ('''prediction_loop'''). This design fully decouples capture from prediction, ensuring that the video stream remains smooth and low-latency, even when inference takes several seconds.

Find below the complete code implementation separating the capture loop from the prediction loop.

<syntaxhighlight lang="python">
# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import asyncio
import argparse
from aiohttp import web, WSCloseCode
import logging
import weakref
import cv2
import time
import PIL.Image
import matplotlib.pyplot as plt
from typing import List
from nanoowl.tree import Tree
from nanoowl.tree_predictor import (
TreePredictor
)
from nanoowl.tree_drawing import draw_tree_output
from nanoowl.owl_predictor import OwlPredictor

if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("image_encode_engine", type=str)
parser.add_argument("--image_quality", type=int, default=50)
parser.add_argument("--port", type=int, default=7860)
parser.add_argument("--host", type=str, default="0.0.0.0")
parser.add_argument("--camera", type=int, default=0)
parser.add_argument("--resolution", type=str, default="640x480", help="Camera resolution as WIDTHxHEIGHT")
args = parser.parse_args()
width, height = map(int, args.resolution.split("x"))

CAMERA_DEVICE = args.camera
IMAGE_QUALITY = args.image_quality

predictor = TreePredictor(
owl_predictor=OwlPredictor(
image_encoder_engine=args.image_encode_engine
)
)

prompt_data = None

# Shared state between capture and prediction
shared_state = {
"latest_frame": None,
"latest_detections": None,
"frame_count": 0
}

def get_colors(count: int):
cmap = plt.cm.get_cmap("rainbow", count)
colors = []
for i in range(count):
color = cmap(i)
color = [int(255 * value) for value in color]
colors.append(tuple(color))
return colors

def cv2_to_pil(image):
t0 = time.perf_counter_ns()
t1 = time.perf_counter_ns()
dt = (t1 - t0) / 1e9
logging.info(f"CV2 to PIL time: {dt:.3f}s")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
return PIL.Image.fromarray(image)

async def handle_index_get(request: web.Request):
logging.info("handle_index_get")
return web.FileResponse("./index.html")

async def websocket_handler(request):

global prompt_data

ws = web.WebSocketResponse()

await ws.prepare(request)

logging.info("Websocket connected.")

request.app['websockets'].add(ws)

try:
async for msg in ws:
logging.info(f"Received message from websocket.")
if "prompt" in msg.data:
header, prompt = msg.data.split(":")
logging.info("Received prompt: " + prompt)
try:
tree = Tree.from_prompt(prompt)
clip_encodings = predictor.encode_clip_text(tree)
owl_encodings = predictor.encode_owl_text(tree)
prompt_data = {
"tree": tree,
"clip_encodings": clip_encodings,
"owl_encodings": owl_encodings
}
logging.info("Set prompt: " + prompt)
except Exception as e:
print(e)
finally:
request.app['websockets'].discard(ws)

return ws

async def on_shutdown(app: web.Application):
for ws in set(app['websockets']):
await ws.close(code=WSCloseCode.GOING_AWAY,
message='Server shutdown')

async def detection_loop(app: web.Application):

loop = asyncio.get_running_loop()

logging.info("Opening camera.")

# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
logging.info("Loading predictor.")
frame_count = 0
predict_every_n_frames = 1 # predict every 15 frames

def _read_and_encode_image():
re, image = camera.read()
if not re:
return re, None

shared_state["latest_frame"] = image.copy() # keep a copy for prediction
shared_state["frame_count"] += 1

# draw predictions if available (non-blocking)
if prompt_data is not None and shared_state["latest_detections"] is not None:
image = draw_tree_output(image, shared_state["latest_detections"], prompt_data["tree"])

image_jpeg = bytes(
cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, IMAGE_QUALITY])[1]
)
return re, image_jpeg

while True:

re, image = await loop.run_in_executor(None, _read_and_encode_image)

if not re:
break

for ws in app["websockets"]:
await ws.send_bytes(image)

camera.release()

async def prediction_loop():
loop = asyncio.get_running_loop()
while True:
await asyncio.sleep(0)

if prompt_data is None or shared_state["latest_frame"] is None:
continue

# Copy latest frame for prediction
frame_to_predict = shared_state["latest_frame"].copy()
image_pil = cv2_to_pil(frame_to_predict)

# Run predictor in thread pool (non-blocking)
detections = await loop.run_in_executor(
None,
lambda: predictor.predict(
image_pil,
tree=prompt_data['tree'],
clip_text_encodings=prompt_data['clip_encodings'],
owl_text_encodings=prompt_data['owl_encodings']
)
)

shared_state["latest_detections"] = detections

async def run_detection_loop(app):
try:
task_video = asyncio.create_task(detection_loop(app))
task_pred = asyncio.create_task(prediction_loop())

yield
await asyncio.gather(task_video, task_pred)
except asyncio.CancelledError:
pass
finally:
task_video.cancel()
task_pred.cancel()
await asyncio.gather(task_video, task_pred, return_exceptions=True)

logging.basicConfig(level=logging.INFO)
app = web.Application()
app['websockets'] = weakref.WeakSet()
app.router.add_get("/", handle_index_get)
app.router.add_route("GET", "/ws", websocket_handler)
app.on_shutdown.append(on_shutdown)
app.cleanup_ctx.append(run_detection_loop)
web.run_app(app, host=args.host, port=args.port)
</syntaxhighlight>
= Need Further Support? =

'''📞 Book Consultation Call:''' [https://proventusnova.com/contact-us/ Show Calendar!]

'''📩 Contact Via Email:''' [mailto:support@proventusnova.com support@proventusnova.com]

'''🌐 Visit Our Website:''' [https://proventusnova.com ProventusNova.com]

How to run NVIDIA NanoOWL tutorial

2025-11-26T18:56:38Z

Nico: /* Adaptations */

=How to run NVIDIA NanoOWL tutorial=
''Keywords'': ''NVIDIA Jetson, NanoOWL, object detection''
==Description==
This wiki pages shows how to run the tree prediction with a live camera tutorial from NVIDIA NanoOWL. NanoOWL is a project that optimizes OWL-ViT to run '''real-time''' on NVIDIA Jetson Orin Platforms with NVIDIA TensorRT. NanoOWL also introduces a new "tree detection" pipeline that combines OWL-ViT and CLIP to enable nested detection and classification of anything, at any level, simply by providing text.

==Set up==
Minimal requirements:
* One of the following Jetson:
** Jetson Orin NX (16 GB)
** Jetson Orin Nano (8 GB)
** Jetson AGX Orin (32 GB or 64 GB)

* Running one of the following JetPack versions:
** Jetpack 5 (L4T r35.x)
** Jetpack 6 (L4T r36.x)

This tutorial was tested with the following setup:
* x86/x64 based host machine running Ubuntu 24.04
* Jetson Orin NX (16 GB) + CTI Boson carrier board running Jetpack 6.2.1 (L4T 36.4.4).
* One Framos IMX464 camera
* Ethernet cable

1. Connect to the board via ssh:
<syntaxhighlight lang="bash">
ssh <user>@<board_ip>
</syntaxhighlight>

Now you should be inside the board.

== Tutorial ==

1. Clone and setup '''jetson-containers'''

<syntaxhighlight lang="bash">
git clone https://github.com/dusty-nv/jetson-containers
bash jetson-containers/install.sh
</syntaxhighlight>

2. Run the following to pull or build a compatible container image.
<syntaxhighlight lang="bash">
jetson-containers run --workdir /opt/nanoowl $(autotag nanoowl)
</syntaxhighlight>

After running above command you should be in workdir ('''/opt/nanoowl''') inside the container.

3. Verify you have a camera connected:
<syntaxhighlight lang="bash">
ls /dev/video*
</syntaxhighlight>

4. Install missing module inside container:

<syntaxhighlight lang="bash">
pip install aiohttp
</syntaxhighlight>

Note: If this takes too long or fails, try the following command:
<syntaxhighlight lang="bash">
pip install aiohttp --index-url https://pypi.org/simple --prefer-binary
</syntaxhighlight>

5. Run the '''tree_demo.py''' example.
<syntaxhighlight lang="bash">
cd examples/tree_demo
python3 tree_demo.py --camera 0 --resolution 640x480 ../../data/owl_image_encoder_patch32.engine
</syntaxhighlight>

You should see the following after the application starts:
<syntaxhighlight lang="bash">
======== Running on http://0.0.0.0:7860 ========
(Press CTRL+C to quit)
</syntaxhighlight>

6. On your host PC, open browser to:
<syntaxhighlight lang="bash">
http://<board_ip>:7860
</syntaxhighlight>

7. Now you are ready to test some prompts! Use the following as examples:
* [a face]
* [a face, a ball]
* [a face [a nose, an eye]]

== Adaptations ==

* If you are using a camera that does not support the GStreamer '''v4l2src''' element—for example, a CSI-connected camera—you may encounter an error similar to the following:
<syntaxhighlight lang="bash">
[ WARN:0@15.685] global cap_gstreamer.cpp:2829 handleMessage OpenCV | GStreamer warning: Embedded video playback halted; module v4l2src0 reported: Internal data stream error.
</syntaxhighlight>

To enable frame capture from such a camera, modify the '''detection_loop''' method as follows:
<syntaxhighlight lang="python">
# Delete or comment the three lines of code below
# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)

# Add the following GStreamer pipeline to use nvarguscamerasrc
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
</syntaxhighlight>

== Performance improvements ==

* Observation: In the original implementation, both frame capture and model prediction were executed inside the same synchronous function ('''_read_and_encode_image'''). This caused the entire video pipeline to block while waiting for the model to finish inference, resulting in several seconds of latency in the browser.

* Improvement: To resolve this, the prediction logic was moved into a separate asynchronous background task ('''prediction_loop'''). This design fully decouples capture from prediction, ensuring that the video stream remains smooth and low-latency, even when inference takes several seconds.

Find below the complete code implementation separating the capture loop from the prediction loop.

<syntaxhighlight lang="python">
# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import asyncio
import argparse
from aiohttp import web, WSCloseCode
import logging
import weakref
import cv2
import time
import PIL.Image
import matplotlib.pyplot as plt
from typing import List
from nanoowl.tree import Tree
from nanoowl.tree_predictor import (
TreePredictor
)
from nanoowl.tree_drawing import draw_tree_output
from nanoowl.owl_predictor import OwlPredictor

if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("image_encode_engine", type=str)
parser.add_argument("--image_quality", type=int, default=50)
parser.add_argument("--port", type=int, default=7860)
parser.add_argument("--host", type=str, default="0.0.0.0")
parser.add_argument("--camera", type=int, default=0)
parser.add_argument("--resolution", type=str, default="640x480", help="Camera resolution as WIDTHxHEIGHT")
args = parser.parse_args()
width, height = map(int, args.resolution.split("x"))

CAMERA_DEVICE = args.camera
IMAGE_QUALITY = args.image_quality

predictor = TreePredictor(
owl_predictor=OwlPredictor(
image_encoder_engine=args.image_encode_engine
)
)

prompt_data = None

# Shared state between capture and prediction
shared_state = {
"latest_frame": None,
"latest_detections": None,
"frame_count": 0
}

def get_colors(count: int):
cmap = plt.cm.get_cmap("rainbow", count)
colors = []
for i in range(count):
color = cmap(i)
color = [int(255 * value) for value in color]
colors.append(tuple(color))
return colors

def cv2_to_pil(image):
t0 = time.perf_counter_ns()
t1 = time.perf_counter_ns()
dt = (t1 - t0) / 1e9
logging.info(f"CV2 to PIL time: {dt:.3f}s")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
return PIL.Image.fromarray(image)

async def handle_index_get(request: web.Request):
logging.info("handle_index_get")
return web.FileResponse("./index.html")

async def websocket_handler(request):

global prompt_data

ws = web.WebSocketResponse()

await ws.prepare(request)

logging.info("Websocket connected.")

request.app['websockets'].add(ws)

try:
async for msg in ws:
logging.info(f"Received message from websocket.")
if "prompt" in msg.data:
header, prompt = msg.data.split(":")
logging.info("Received prompt: " + prompt)
try:
tree = Tree.from_prompt(prompt)
clip_encodings = predictor.encode_clip_text(tree)
owl_encodings = predictor.encode_owl_text(tree)
prompt_data = {
"tree": tree,
"clip_encodings": clip_encodings,
"owl_encodings": owl_encodings
}
logging.info("Set prompt: " + prompt)
except Exception as e:
print(e)
finally:
request.app['websockets'].discard(ws)

return ws

async def on_shutdown(app: web.Application):
for ws in set(app['websockets']):
await ws.close(code=WSCloseCode.GOING_AWAY,
message='Server shutdown')

async def detection_loop(app: web.Application):

loop = asyncio.get_running_loop()

logging.info("Opening camera.")

# camera = cv2.VideoCapture(CAMERA_DEVICE)
# camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
# camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
gst_pipeline = (
f"nvarguscamerasrc ! "
f"video/x-raw(memory:NVMM), width={width}, height={height}, format=NV12, framerate=30/1 ! "
f"nvvidconv ! video/x-raw, format=BGRx ! videoconvert ! "
f"appsink"
)

camera = cv2.VideoCapture(gst_pipeline, cv2.CAP_GSTREAMER)
camera.set(cv2.CAP_PROP_BUFFERSIZE, 1)
logging.info("Loading predictor.")
frame_count = 0
predict_every_n_frames = 1 # predict every 15 frames

def _read_and_encode_image():
re, image = camera.read()
if not re:
return re, None

shared_state["latest_frame"] = image.copy() # keep a copy for prediction
shared_state["frame_count"] += 1

# draw predictions if available (non-blocking)
if prompt_data is not None and shared_state["latest_detections"] is not None:
image = draw_tree_output(image, shared_state["latest_detections"], prompt_data["tree"])

image_jpeg = bytes(
cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, IMAGE_QUALITY])[1]
)
return re, image_jpeg

while True:

re, image = await loop.run_in_executor(None, _read_and_encode_image)

if not re:
break

for ws in app["websockets"]:
await ws.send_bytes(image)

camera.release()

async def prediction_loop():
loop = asyncio.get_running_loop()
while True:
await asyncio.sleep(0)

if prompt_data is None or shared_state["latest_frame"] is None:
continue

# Copy latest frame for prediction
frame_to_predict = shared_state["latest_frame"].copy()
image_pil = cv2_to_pil(frame_to_predict)

# Run predictor in thread pool (non-blocking)
detections = await loop.run_in_executor(
None,
lambda: predictor.predict(
image_pil,
tree=prompt_data['tree'],
clip_text_encodings=prompt_data['clip_encodings'],
owl_text_encodings=prompt_data['owl_encodings']
)
)

shared_state["latest_detections"] = detections

async def run_detection_loop(app):
try:
task_video = asyncio.create_task(detection_loop(app))
task_pred = asyncio.create_task(prediction_loop())

yield
await asyncio.gather(task_video, task_pred)
except asyncio.CancelledError:
pass
finally:
task_video.cancel()
task_pred.cancel()
await asyncio.gather(task_video, task_pred, return_exceptions=True)

logging.basicConfig(level=logging.INFO)
app = web.Application()
app['websockets'] = weakref.WeakSet()
app.router.add_get("/", handle_index_get)
app.router.add_route("GET", "/ws", websocket_handler)
app.on_shutdown.append(on_shutdown)
app.cleanup_ctx.append(run_detection_loop)
web.run_app(app, host=args.host, port=args.port)
</syntaxhighlight>

How to run NVIDIA NanoOWL tutorial

2025-11-26T18:39:39Z

Nico: /* Tutorial */

How to run NVIDIA NanoOWL tutorial

2025-11-26T18:38:42Z

Nico: /* Tutorial */

How to run NVIDIA NanoOWL tutorial

2025-11-26T18:34:02Z

Nico: /* Set up */