Sign in Subscribe

Connecting to Your NVIDIA Jetson AGX Thor via Type C cable on macOS

No monitor? No problem. Learn how a simple USB Type-C charging cable and serial console access saved a student demo at our Docker meetup.

Ajeet Singh Raina

Ajeet Singh Raina

— 5 min read
Connecting to Your NVIDIA Jetson AGX Thor via Type C cable on macOS

The Saturday Meetup Crisis

Last Saturday afternoon at our Docker meetup event. A group of enthusiastic students are about to showcase their AI project running on the brand new NVIDIA Jetson AGX Thor. They're excited, the audience is waiting, and then... reality hits.

No HDMI cable. No monitor. No keyboard.

The main speakers are busy presenting via Zoom and Microsoft Teams, all the display equipment is tied up, and these students are standing there with their cutting-edge Jetson Thor looking increasingly worried. Their demo slot is in 15 minutes.

All we had? A MacBook and the NVIDIA Thor. Then I spotted it—a USB Type-C cable someone was using to charge their phone. That's when I knew we could save this demo.

Getting Started with NVIDIA Jetson AGX Thor Developer Kit: A Complete Reference Guide
If you’re building robots, you’re going to want to hear about this.
Ajeet Singh RainaAjeet Singh Raina

The Solution: USB Serial Console to the Rescue

What happened next became an impromptu crash course in accessing embedded Linux devices without traditional peripherals. Here's exactly how we got that Jetson Thor up and running in under 10 minutes.

Step 1: Identifying the USB Serial Device

First, I grabbed the Type-C cable and connected it to both the Mac and the Jetson Thor. Then we checked what devices were available:

ls /dev/tty.*

Initially, you might only see Bluetooth devices.

Once you connect your Jetson device via the USB Type-C cable, run the command again:

ls /dev/tty.*

Before connecting the cable, we only saw:

/dev/tty.Bluetooth-Incoming-Port

After plugging in the Jetson Thor via USB Type-C:

/dev/tty.Bluetooth-Incoming-Port 
/dev/tty.usbmodemTOPOA735A12B2   
/dev/tty.usbmodemTOPOA735A12B4
/dev/tty.usbmodemTOPOA735A12B6
/dev/tty.usbmodemTOPOA735A12B8

Perfect! The usbmodem devices appeared—these are the Jetson's serial interfaces. The students watched in amazement as I explained that a simple charging cable could become our lifeline to the device.

Step 2: Establishing Serial Connection with Screen

With the device identified, I opened a serial console using the screen utility:

TERM=xterm-256color sudo screen /dev/tty.usbmodemTOPOA735A12B2 115200
```

**Breaking down this command:**
- `TERM=xterm-256color` - Sets the terminal type for proper color support
- `sudo` - Required for accessing serial devices
- `screen` - The terminal multiplexer/serial console tool
- `/dev/tty.usbmodemTOPOA735A12B2` - The serial device path
- `115200` - The baud rate (communication speed)

## Step 3: Logging Into Your Jetson

Once connected, you'll see the login prompt. Enter your credentials:
```
ajeetraina login: ajeetraina
Password: ********
```

After successful login, you'll see the Ubuntu welcome message:
```
Welcome to Ubuntu 24.04.3 LTS (GNU/Linux 6.8.12-tegra aarch64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/pro

We were in! The students' faces lit up as they realized their demo was back on track.

Step 4: Quick PyTorch Setup

Since they needed PyTorch for their AI demo, we quickly installed the NVIDIA-optimized build:

pip3 install --no-cache \
  https://developer.download.nvidia.com/compute/redist/jp/v60/pytorch/torch-2.3.0-cp312-cp312-linux_aarch64.whl \
  --break-system-packages

Key points about this command:

  • --no-cache - Prevents caching of the download, ensuring a fresh installation
  • The URL points to PyTorch 2.3.0 built for JetPack 6.0 (jp/v60)
  • --break-system-packages - Allows installation outside a virtual environment (use with caution)
Note: The --break-system-packages flag bypasses Python's externally-managed-environment protection. For production use, consider using a virtual environment instead.

The Demo Was a Success

With just a Type-C cable and a MacBook, we transformed what could have been a canceled presentation into a successful demo. The students ran their AI inference models, showed off their results via screen sharing, and even got questions from remote attendees who were impressed by the makeshift setup.

This Saturday meetup incident perfectly illustrates why understanding serial console access is essential for anyone working with edge devices:

1. No Display Required

Edge devices often operate headless in production. Knowing how to access them without monitors is crucial.

2. Minimal Hardware Needs

A simple USB Type-C cable that you might have in your pocket can save the day.

3. Remote Troubleshooting

When devices are deployed in the field, serial access might be your only option for debugging.

4. Boot-Level Access

Unlike SSH, serial console access works even when the network stack isn't running—invaluable for troubleshooting boot issues.

Exiting the Serial Console

When you're done with your session, you can exit screen by pressing:

  • Ctrl + A, then K (to kill the session)
  • Or Ctrl + A, then D (to detach, keeping the session running)

The Bigger Picture: Edge AI in the Real World

This Saturday meetup incident reminds us that edge AI development isn't always glamorous. It's not just about training models and achieving high accuracy—it's about being resourceful, thinking on your feet, and having the fundamental skills to work with hardware when things don't go as planned.

The NVIDIA Jetson AGX Thor is an incredible piece of hardware with 1000 TOPS of AI performance, but at the end of the day, it's still a Linux computer that needs to be accessed, configured, and debugged. Whether you're:

  • Deploying robots in warehouses
  • Running inference at the edge
  • Building autonomous systems
  • Prototyping AI applications

...you need to be comfortable working with these devices in less-than-ideal conditions.

Lessons Learned

That Saturday, those students learned something more valuable than just their AI demo:

  1. Always have a backup plan - Hardware fails, cables go missing, monitors are occupied
  2. Simple tools are powerful - A charging cable and basic Linux knowledge saved the day
  3. Community matters - The Docker and Collabnix community came together to help
  4. Fundamentals are essential - Fancy AI models mean nothing if you can't access your device

Conclusion

The next time you're working with an NVIDIA Jetson device—whether it's at a meetup, in your lab, or deploying in production—remember this story. That humble USB Type-C cable in your bag might just be the hero you need.

Serial console access isn't just a nice-to-have skill for edge AI developers; it's an essential tool that can mean the difference between a successful demo and a missed opportunity.

Keep that Type-C cable handy, bookmark this guide, and never let the lack of a monitor stop you from showcasing your amazing AI projects!

Read more