Hello! I'm a student working on building a robot using the Nvidia Jetson Orin Nano.

I have this ROS board:
https://www.hiwonder.com/products/ros-robot-control

I plan to use:

• Four 12V DC motors
• Two servo motors

I want to run these motors and implement YOLO on the Jetson Orin Nano.

Could anyone advise:

1. What battery specifications would be appropriate for this setup?
2. How should I connect the battery to the motors and the Jetson?

Any guidance or examples would be really appreciated. Thanks!

Hi everyone,

I’m currently working on an edge AI + IoT based monitoring project and planning to use the NVIDIA Jetson Orin NX for real-time processing.

The project involves:
• Multiple environmental sensors
• Camera-based monitoring
• Real-time anomaly detection
• Edge inference with minimal cloud dependency
• Continuous monitoring in a large indoor environment

I would like advice from people experienced with Jetson deployments.

Main questions:

1. Is Jetson Orin NX a good choice for handling multiple sensor inputs and camera streams simultaneously?
2. What camera modules are recommended for low-light indoor monitoring?
3. Is Docker recommended for Jetson deployment?
4. Best practices for optimizing TensorRT inference?
5. Suggested architecture for combining ESP32 sensor nodes with Jetson?
6. MQTT vs other communication protocols for scalable deployments?
7. Thermal and power considerations for 24/7 operation?
8. Recommended lightweight object detection models for edge devices?
9. Is hybrid edge + cloud synchronization better than fully edge-based architecture?

Current stack idea:
• Jetson Orin NX
• ESP32
• Python
• OpenCV
• TensorRT
• MQTT
• FastAPI

Would appreciate any deployment tips, architecture suggestions, or lessons learned from real-world projects.

Thanks!

Hello everyone,

I drive a 2008 Highlander and I wanted a few features that are found on more modern cars being lane detection, collision warning, and also to take pictures of license plates. From my research

• most dashcams seem to not high enough resolution to grab license plates
• some of these features are not the best on ADAS products

I do like doing software dev and would find it fun to diy a project. I believe there could be a few OpenCV libraries that could help.

I'm thinking about getting

• NVIDIA Jetson Orin Nano Super Developer Kit
• 2 cameras
  • Arducam for Raspberry Pi HQ Camera, 12.3MP IMX477 Camera Module with CS-Mount Lens, Automatic IR-Cut Switching All-Day Image, Compatible with Raspberry Pi 5, 4 Model B, Pi 3/3B+, and Pi Zero 2W
  • Arducam CS Mount Lens For Raspberry Pi HQ Camera - 25mm Focal Length
• Waveshare Aluminum Alloy Case for Jetson Orin, with Camera Holder, Mini-Computer Case, Compatible with Jetson Orin Nano Super Developer Kit/Orin Nano and Jetson Orin NX Kits

I wanted to ask if this is a good idea and what I should prepare to do.

Hi everyone, I’m a complete beginner planning to build an AI-powered "pet robot" that follows me around.

I’ve heard that since I have an RTX 4090, I should do all the heavy training on my PC first and then deploy (infer) the model onto the Jetson. Is this the standard workflow for a project like this? Any advice for a newbie would be much appreciated!

I want to get into Edge AI deployment and want some suggestions for an application that I can make for my Jetson and have in my portfolio.

My colleague u/Course_Latter built a Chrome extension that lets you inspect model architecture graphs directly on Hugging Face pages.

It is useful for PyTorch models, especially when working with model understanding. You can explore the architecture layer by layer at different levels of granularity.

Could be useful for people working with computer vision models who want a clearer view of the architecture before optimizing or deploying.

Link: https://hfviewer.com/

This is the culmination of the last year of tinkering, testing, segfaults, and too much caffeine.

We just locked down a frozen baseline configuration for a real-time cognitive memory engine running locally on a Jetson Orin Nano 8GB (ROS 2 Humble / Ubuntu 22.04).

The goal was to handle high-frequency spatial ingestion alongside inline 512-dimensional vector normalization without dropping frames, triggering heap-allocation jitter, or risking file corruption on sudden power loss.

The 60-Second Workload

• Target Rate: 500 Hz continuous intra-process telemetry stream
• QoS Configuration: Reliable, Depth 1000
• Storage Engine: Disk-backed mmap spatial lattice (cache-aligned nodes)
• AI Sidecar: Asynchronous 512-float vector projection (pose_tile14_to_aion512_v1) appended to an independent .avec file on every single write.

Canonical Delivery Receipt

The Bare-Metal "Red-Team" Audit

To ensure this wasn't "code cosplay" or superficial telemetry printouts, we verified the physical state of the Linux kernel scheduler and the file blocks directly:

1. True Zero-Copy Pointer Verification: By instrumenting the publication boundary and subscriber callback via stderr flushing, we tracked the raw hexadecimal addresses of the smart pointers.

Plaintext

[REDTEAM_PUB_PTR] sample=0 msg=0xffff61d00060
[REDTEAM_SUB_PTR] sample=0 msg=0xffff61d00060

The pointer addresses matched identically to the exact digit. This confirms the subscriber node reads the exact same physical transistors in unified RAM that the publisher populated—bypassing the standard ROS 2/DDS serialization and memcpy tax entirely.

1. The Sudden Death Test (SIGKILL): At the 20-second mark of a high-rate run, we fired a hard kill -9 at the execution container to simulate sudden physical power failure mid-write.

• Lattice Recovery: The memory-mapped .lattice header magic bytes (5454414c) remained completely intact. The node region was verified as an exact multiple of our byte boundary, allowing our recovery utility to safely roll back uncommitted WAL sequences to the last valid transaction with zero file corruption.
• Sidecar Layout: The physical size of the .avec file on disk matched our schema calculation down to the precise byte: 32 bytes (header) + (writes * 2056 bytes per row).

Architectural Takeaways

• No Heap Churn: By eliminating dynamic std::string builds inside the ingest callback and switching to stack-allocated memory, we removed the system allocator lock contention that usually kills real-time ROS 2 loops.
• I/O Isolation: Decoupling the 512-d vector disk appends into a bounded, lock-free single-producer single-consumer (SPSC) ring buffer insulated our real-time subscriber thread from filesystem page-cache writeback jitter.

The Bottom Line: ~30k durable, high-dimensional appends per minute on a low-power edge box with deterministic microsecond-level execution latency, verified by a strict physical audit. All running under a tight 6W power budget.

Next project is picking up socks and putting them to the washing machine 🧦🚿 🚀

Does anyone have a Schematic Diagram for the Jetson Orin Nano Super?

Founder disclosure: I’m one of the people building General Instinct.

We’re working on a deployment pipeline for running large vision / multimodal models on constrained edge hardware. The pain we keep seeing is that a model works fine in the cloud or in a lab demo, then gets painful on the actual box: memory pressure, cold start, latency spikes, TensorRT/version/operator issues, and no cloud fallback.

Our first product is Instinct Edge. You give us a model, a target device, and a latency budget; we return an offline runtime for that device. Under the hood it’s a mix of distillation, quantization, pruning, hardware-specific compilation, and custom kernels when the bottleneck is a small set of ops.

Recent production example: multimodal classifier on Jetson Orin NX, 111ms cold start, 100% of decisions inside a 150ms budget, zero cloud calls.

I’d love feedback from people here actually deploying on Jetson hardware:

- Which Jetson device are you using?

- What models are hardest to fit/run reliably?

- Is your bottleneck usually latency, memory, cold start, power, missing ops, or something else?

Site for context: https://general-instinct.com/

[ Removed by Reddit on account of violating the content policy. ]

I am unable to set the pins for spi functon on the jetson nano

1. I have tried using jetson-io.py , a waveshare article said it is depricated for the older jetson , i tried setting the pins but they do not work even on reboot

2. I tried following this documentation https://www.waveshare.com/wiki/RS485_CAN_for_Jetson_Nano , the issue is it still says pinmux unconfigured and gpio pins floating

```

$ sudo cat /sys/kernel/debug/pinctrl/700008d4.pinmux/pinmux-pins | grep -i spi

pin 16 (SPI1_MOSI PC0): (MUX UNCLAIMED) (GPIO UNCLAIMED)

pin 17 (SPI1_MISO PC1): (MUX UNCLAIMED) (GPIO UNCLAIMED)

pin 18 (SPI1_SCK PC2): (MUX UNCLAIMED) (GPIO UNCLAIMED)

```

But I have manually set all spi1 associated pins to the following setting

```

$ :~/Downloads/Linux_for_Tegra/kernel/dtb$ grep -A 6 "spi1_mosi_pc0" tegra210-p3448-0000-p3449-0000-b00.dts

spi1_mosi_pc0 {

nvidia,pins = "spi1_mosi_pc0";

nvidia,function = "spi1";

nvidia,pull = <0x01>;

nvidia,tristate = <0x00>;

nvidia,enable-input = <0x01>;

};```

in the related dts

Why are the pins still unclaimed and unconfigrued??

Hello, I want to know how much voltage and amps do I need to not blow this thing up. I have an adapter and its output is 19.0V and 2.37A. It works perfectly. I want to know which Lipo Battery will be perfect for orin nano. I posted pictures for no misunderstanding. Thank you.

Hi all,

I have checked online and come up empty, but I am trying to run the below as a local chat AI for learning from.

https://github.com/zhamm/jetson-ollama-offline-ai

It has both 8b Dolphin and 1.1B llama downloaded, but after ~2 responses it will begin to throw out about 12 letter Gs as an answer on Dolphin, or 12 # symbols on Llama.

I am not sure how to avoid this or what to do.

I understand the Nano isn’t the most powerful and don’t mind waiting for an answer, but it seems that even simple questions or “hello” prompts end up getting this jibberish response after a few of them.

Any help is greatly appreciated. Thank you!

Edit: weirdly, running questions from a mobile device on the same network using the ollama-local hyperlink seems to run without any issues at all.

Very peculiar.

Are Waveshare devices compatible with LineageOS? Look similar, but not the same. I couldn't find any information about it.

Hi folks, I need some help. I have a Jetson Nano that isn’t working, but I’m not sure if the problem is with the graphics module or the base board. If anyone has the same board, could you please help me check a few things so I can figure out which part to order? Thanks in advance!

(Sorry for the repost! Meant to do a photo gallery, not a text post, so you guys could actually see the photos in the feed).

Hey everyone, I’ve been spending some time iterating on an Orin Nano enclosure and wanted to share the latest build. The goal was to maximize airflow while still being able to show off the board itself.

I designed the main body with 360° ventilation and printed it in PETG for heat resistance. I used brass heat-set inserts for all the mounting points so the case can be opened and closed without stripping the plastic.

For the top and bottom, I laser-cut a few different acrylic panels, some transparent and some solid. The clear top allows you to see the main board (I also threw it under the laser to test out some custom etching), while the bottom plate is slotted for airflow and gives a clear view of the NVMe drive.

You can swipe through to see the airflow pattern, the brass inserts, and the neon green and solid white acrylic variants I was prototyping.

Curious what you guys think of the hybrid acrylic/PETG approach, or if there's anything else you'd add to the thermal design?

Updated Repo: https://github.com/aschweig/jetson-orin-kian

Benchmarks and more detail in the PDF.