Migrating Camera SDK from RK1808 to Jetson Orin Nano: Compilation and Adaptation

Issue Overview

The user is attempting to migrate a previously developed camera SDK, including model inference deployment code, from a Rockchip RK1808 platform to the Nvidia Jetson Orin Nano 8GB development board. The main challenges involve compiling the existing code, creating an appropriate Makefile, and adapting the SDK to work with the new hardware. The user is unsure about the correct approach to migration, compilation, and the necessary steps after flashing JetPack on the Jetson Orin Nano.

Possible Causes

1. Platform differences: The RK1808 and Jetson Orin Nano have different architectures and software ecosystems, which may lead to compatibility issues.

2. Library incompatibilities: Some libraries used in the RK1808 version may not be compatible with the Jetson platform.

3. API differences: NVIDIA-specific APIs may need to be used to replace certain functions in the existing code.

4. Compilation environment: The user is transitioning from a cross-compilation setup to native compilation on the Jetson device.

5. Makefile configuration: The existing Makefile may not be suitable for the new platform and development environment.

6. Lack of familiarity: The user is new to NVIDIA adaptation, which may lead to uncertainty about the correct migration approach.

Troubleshooting Steps, Solutions & Fixes

1. Understand the Jetson Orin Nano environment:

   • Confirm that JetPack has been successfully flashed on the Jetson Orin Nano.
   • Familiarize yourself with the Jetson Linux environment and available tools.

2. Set up the development environment:

   • Install the NVIDIA Multimedia API package:

     sudo apt install nvidia-l4t-jetson-multimedia-api
     

   • Locate and read the readme file for instructions on compiling sample applications.

3. Obtain necessary development resources:

   • Download the Driver Package (BSP) Sources for public release from the Jetson Linux r363 release.
   • While not strictly necessary for on-device development, you may want to download the Jetson Linux Toolchain for additional build options.

4. Adapt the existing code:

   • Review the camera SDK code and identify components that need modification.
   • Replace RK1808-specific libraries and APIs with NVIDIA equivalents, particularly for image and video encoding/decoding.
   • Consult the Jetson Linux API Reference (https://docs.nvidia.com/jetson/l4t/index.html#page/Tegra%20Linux%20Driver%20Package%20Development%20Guide/jetson_linux_api_reference.html) for guidance on using NVIDIA-specific APIs.

5. Update the Makefile:

   • Create a new Makefile or modify the existing one to work with the Jetson Orin Nano environment.
   • Ensure that the Makefile includes the correct paths to NVIDIA libraries and headers.
   • Set appropriate compiler flags for the Jetson Orin Nano architecture.

6. Compile the code:

   • As the Jetson Orin Nano is a complete development platform, compile the code directly on the device.
   • Use the native GCC compiler available on the Jetson Orin Nano instead of cross-compilation tools.

7. Iterative debugging and testing:

   • Compile the code and address any errors that arise.
   • Test each component of the camera SDK to ensure proper functionality on the new platform.
   • Use NVIDIA-provided debugging tools and documentation to resolve issues.

8. Optimize for Jetson Orin Nano:

   • Once the basic functionality is working, consider optimizing the code to take advantage of the Jetson Orin Nano’s capabilities, such as its 40 TOPS of AI performance.

9. Document changes and new dependencies:

   • Keep track of all modifications made to the original code.
   • Document any new NVIDIA-specific libraries or APIs used in the adapted version.

10. Seek community support:

    • If you encounter persistent issues, consider reaching out to the NVIDIA Developer Forums or community channels for assistance.

Remember that migrating from RK1808 to Jetson Orin Nano involves a significant platform change. Take an incremental approach, addressing one component at a time, and thoroughly test each part of the SDK as you adapt it to the new environment.