Cameras & sensorsExplainer

USB cameras on Jetson Nano: what UVC compliance means for you

What UVC gives a USB camera on Jetson Nano, the 5 Gb/s bus budget for 1080p60 streams, and the class check that separates driver-free from vendor SDK cameras.

LumaSpec Vision11 min read Share on LinkedIn

On this page 9 sections
  1. 01What UVC compliance actually gives you
  2. 02The Nano's USB 3.0 budget: four ports, one link
  3. 03The class check: UVC camera or vendor SDK
  4. 04The bus cost of a stream, in one formula
  5. 05Worked example: two 1080p60 cameras against the shared bus
  6. 06Where the limits show up in practice
  7. 07Choosing a USB3 camera for a Nano build
  8. 08Checks before you order
  9. 09Questions

You are wiring a USB camera to a Jetson Nano and the listing says 'UVC compliant'. That one line decides more than the sensor: it means the Nano's kernel claims the camera on its own, with no vendor driver and no SDK to build. What it does not decide is bandwidth. All four USB 3.0 ports on the Nano share one 5 Gb/s link, so the moment you want two cameras or a 4K stream, that shared number, not the sensor, sets the ceiling. Here you get the 30-second class check that confirms UVC behaviour, a one-line formula for the bus cost of any stream, a worked two-camera example, and the decision that follows for each case.

What UVC compliance actually gives you

UVC, the USB Video Class, is a device-class standard maintained by the USB Implementers Forum. A compliant camera describes itself through standard video interfaces, so the host needs no vendor driver: the Linux kernel's uvcvideo module claims the device, creates /dev/video0, /dev/video1 and so on, and exposes everything through V4L2 — the API that OpenCV, GStreamer's v4l2src and ffmpeg all read directly. The Nano's stock image ships the module, and the Jetson documentation walks USB camera discovery through V4L2 and uvcvideo.

Two consequences matter for a build. Bring-up becomes a bench test, not a porting project: a camera that appears in any Linux PC will appear on the Nano. Controls also stay inside what the class defines plus whatever the firmware maps as extension-unit (XU) controls; vendor-only settings that live in a Windows tool will not surface in V4L2 unless the firmware maps them.

The driver-free path for UVC cameras on embedded Linux walks that bring-up sequence step by step. This page stays on the Nano's side of the cable.

The developer kit gives you four USB 3.0 Type-A ports and one micro-B port. The micro-B is USB 2.0 OTG, meant for flashing and power; it is no place for a camera. The four Type-A ports sit behind one hub, so everything plugged into them shares a single 5 Gb/s SuperSpeed link. Four ports do not mean four budgets.

Treat 3.2 Gb/s as the working budget: 5 Gb/s of signaling carries 4.0 Gb/s of payload after 8b/10b encoding, and hosts sustain about 80% of that with real drivers and real traffic. Every camera decision below runs against that number. Power shares the ports too: a configured USB 3.0 port can supply up to 900 mA at 5 V (4.5 W), and four cameras at once ask for a proper supply — run the board from its DC barrel supply, not a phone charger.

When a camera can live on the CSI connector instead, its pixels never touch this bus; the built-in driver support for IMX219 and IMX477 modules on Jetson is the quick comparison. The same budget logic, watts and Gb/s together, runs across the multi-camera power and bandwidth plan for USB cameras on one host.

The class check: UVC camera or vendor SDK

'USB3 camera' on a machine-vision listing can mean two different devices: a UVC camera the kernel drives by itself, or a camera that streams only through its vendor's SDK. Both carry USB 3.0 plugs. Only the first runs driver-free on the Nano, and an SDK without an ARM64 build is a dead end for this board no matter how good the sensor is.

Run the check on any Linux PC, before you design a carrier around the camera:

  1. Run lsusb and find the camera. A UVC device reports the video class, 0x0E.
  2. Look for the /dev/video0 node the uvcvideo module created.
  3. Run v4l2-ctl -d /dev/video0 --list-formats-ext to print the pixel formats, frame sizes and rates the firmware offers.

If step 2 comes up empty, the camera is SDK-only: confirm an ARM64 SDK exists before planning around it. If step 3 offers fewer modes than the listing promised, believe step 3 — the firmware, not the sensor, defines what you can stream, and why a USB camera sticks at 4K explains how those modes get built. The split is physical: sensor and bridge chip each contribute part of the mode list, which is why two cameras on the same sensor can expose different streams; the sensor and bridge selection guide for USB MJPEG cameras walks that split.

The plug-and-play reality check for UVC camera compatibility and the driver-free support checklist for a UVC USB camera on an embedded board both start from this same test. Off-the-shelf industrial controllers can fail a compliant camera on one missing kernel option — the kernel configuration fix for UVC cameras on embedded controllers shows the pattern — but the Nano's image already carries uvcvideo.

The bus cost of a stream, in one formula

payload per camera (Mb/s) = width px × height px × fps × bytes per pixel × 8 ÷ 1,000,000 MJPEG payload ≈ uncompressed payload ÷ compression ratio Nano working budget = 5 Gb/s × 8/10 (payload after 8b/10b) × 0.8 (real-world margin) = 3.2 Gb/s

UVC's common uncompressed format is YUYV (4:2:2 packed), 2 bytes per pixel. MJPEG compresses, typically 4:1 to 8:1 with the firmware's quality setting; plan on 5:1. Run the formula on the modes v4l2-ctl reports, never on the sensor's headline resolution.

Stream Format Arithmetic Bus load
1080p30 YUYV 2,073,600 × 30 × 2 × 8 ÷ 1,000,000 995 Mb/s
1080p60 YUYV 2,073,600 × 60 × 2 × 8 ÷ 1,000,000 1,991 Mb/s
1080p60 MJPEG, 5:1 1,991 ÷ 5 ≈ 400 Mb/s
720p60 YUYV 921,600 × 60 × 2 × 8 ÷ 1,000,000 885 Mb/s
4K30 (3840 × 2160) YUYV 8,294,400 × 30 × 2 × 8 ÷ 1,000,000 3,981 Mb/s

Read the last row twice: one uncompressed 4K30 stream alone consumes the entire 4.0 Gb/s payload of the shared link before host overhead. When a single high-resolution camera behaves this way, the bandwidth and pacing fix for a USB camera timeout at high resolution applies the same math to one stream.

Worked example: two 1080p60 cameras against the shared bus

Inputs. Two UVC cameras, each streaming 1920 × 1080 at 60 fps — the typical inspection ask, and the case behind most 'can you run two cameras' questions. Format: YUYV uncompressed, 2 bytes per pixel. Bus: the Nano's shared link, 5 Gb/s signaling, 4.0 Gb/s payload after 8b/10b, 3.2 Gb/s working budget.

Rule: payload per camera = width × height × fps × bytes per pixel × 8.

Arithmetic:

  • Pixels per frame: 1920 × 1080 = 2,073,600 px
  • Bytes per frame: 2,073,600 px × 2 B = 4,147,200 B ≈ 4.15 MB
  • Bytes per second: 4,147,200 B × 60 = 248,832,000 B/s ≈ 248.8 MB/s
  • Bits per second: 248.8 MB/s × 8 = 1,990.7 Mb/s ≈ 2.0 Gb/s per camera
  • Two cameras: 2 × 1,991 Mb/s = 3,981 Mb/s

Decision. 3,981 Mb/s against a 3.2 Gb/s working budget fails, and it clears the 4.0 Gb/s absolute payload by only 19 Mb/s — isochronous overhead eats that alone. Two uncompressed 1080p60 streams do not fit on one Nano. Three fixes, in this order:

  1. Drop to 30 fps: 995 Mb/s each, 1,990 Mb/s combined — fits, with about 1.2 Gb/s left for a third stream. No hardware changes.
  2. Switch the firmware to MJPEG: at 5:1 compression the pair needs 2 × 398 = 796 Mb/s ≈ 0.8 Gb/s, leaving 2.4 Gb/s of budget. The math allows eight such streams (3.2 ÷ 0.4); plan on four to five, because real scenes compress worse than test charts. The next ceiling becomes CPU time to decode the JPEGs.
  3. Move one camera to the CSI connector: its 2.0 Gb/s leaves the bus entirely, and the remaining USB camera runs uncompressed with full headroom.

If your cameras are 720p60 instead, two uncompressed streams need 2 × 885 = 1,770 Mb/s ≈ 1.8 Gb/s and fit without changing anything.

Where the limits show up in practice

At 480 Mb/s of signaling there is roughly 300 Mb/s of real payload, so not even one 1080p30 YUYV stream (995 Mb/s) can run; fixing the cable or the port comes before touching any setting.

Aggregate symptoms look different: INCOMPLETE frames, timeouts and freezes that start when the second camera opens. The host absorbs brief overload, then falls apart mid-batch. Cap each stream's rate explicitly and keep the combined load inside the working budget; the same diagnostic shape drives the Jetson fix for INCOMPLETE frames on two GigE cameras.

Decode load is the second ceiling: every MJPEG frame is decompressed on the Nano's CPU. Budget it like bandwidth — open every camera at the real size and rate and read the CPU percentage under load. Power is the third: a camera's draw is its stated current times 5 V; add the cameras, plus any hub, against what the supply leaves for the ports.

Choosing a USB3 camera for a Nano build

The board-level cameras are the natural fit for a carrier of your own: sensor plus compact board, C-mount or M12 optics, USB3 out. The housed area scan cameras add a chassis and a standard C-mount when the camera lives outside your housing.

For motion on a compact build, the LS-BCM-0003 pairs a 1/1.8" global-shutter sensor with a C-mount and streams 3.1 MP at 120 fps over USB3.

Board-level cameras3.1 MP USB3 board-level camera, IMX252, 1/1.8" global shutter, 120 fps (LS-BCM-0003)LS-BCM-0003
Sensor format
1/1.8"
Lens mount
C-mount
Interface
USB3
Resolution
5 MP
$690.00View partBuild a system with it

For embedding without a housing, the MV-CB060-10UM-B is a bare-board 6 MP USB3 camera on a 1/1.8" rolling-shutter IMX178.

Board-level camerasHikrobot MV-CB060-10UM-B 6 MP Board Level Camera, USB3, IMX178, Mono, Bare Board, V4MV-CB060-10UM-B
Sensor format
1/1.8"
Interface
USB3
Resolution
6-10 MP
Shutter
Rolling
$239.00View partBuild a system with it

When detail matters more than frame rate, the MV-CS200-10UM carries a 20 MP mono sensor behind a 1" format and C-mount on the same USB3.0 interface.

Area scan camerasHikrobot MV-CS200-10UM 20 MP Area Scan Camera, USB3.0, IMX183, 2nd Gen., MonoMV-CS200-10UM
Sensor format
1"
Lens mount
C-mount
Interface
USB3
Resolution
16-25 MP
$759.00View partBuild a system with it

Run the formula on the modes each camera's firmware offers and hold the total against the budget — a 20 MP frame is 3.3× the pixels of a 6 MP frame at the same rate, and pixels cost bus time. Lens choice follows the mount: board camera lens mount thread sizes sorts out M12 versus C-mount optics, and the sensor format decides the lens image circle. The cameras finder filters this range by interface, shutter and resolution, and the camera step of the configurator builds the rest of the chain.

Checks before you order

  • Class: lsusb shows the video class 0x0E and a /dev/video0 node appears — the one check that separates driver-free UVC from SDK-only.
  • Modes: v4l2-ctl --list-formats-ext shows YUYV or MJPEG at your target size and rate; plan the bus from that row, not the listing.
  • Count: add the per-camera loads from the formula and stay under 3.2 Gb/s of working budget on the shared link.
  • Cable: USB 3.0-rated, 3 m or shorter, in a Type-A port — never the micro-B OTG port.
  • Power: sum the camera draws and run the Nano from its DC barrel supply.
  • Decode: open every camera at the real size and rate and read CPU load before freezing the design.

When the numbers leave no room on the bus, cut frame rate before pixels, choose MJPEG before adding hardware, and move a stream to CSI or GigE only after that. The rest of the integration guides sit on the systems topic page, and if a build will not close on paper, send us the stream list through the contact page and we will size the bus with you.

Questions

How do I check that a USB camera is UVC-compliant before building around the Nano?

Plug it into any Linux machine and run lsusb. A UVC device reports the video class, 0x0E, and the uvcvideo module creates a /dev/video0 node. Then v4l2-ctl --list-formats-ext prints the formats, frame sizes and rates the firmware actually offers. If no /dev/video node appears, the camera streams only through a vendor SDK, and you should confirm that SDK ships an ARM64 build before you plan around the Nano.

Why does my camera enumerate as USB 2.0 at 480 Mb/s on the Nano?

SuperSpeed needs USB 3.0 in every link: camera bridge, cable and host port. A USB 2.0 cable in a blue Type-A plug, or any pass-through hub without SuperSpeed, caps the link at 480 Mb/s of signaling, roughly 300 Mb/s of real payload. An uncompressed 1080p30 stream alone needs about 1 Gb/s, so the firmware drops to MJPEG or smaller frames. Swap in a USB 3.0-rated cable of 3 m or less and use a Type-A port, not the micro-B OTG port.

Can I run USB cameras and a CSI camera on the same Nano?

Yes, and it is the standard escape hatch for a full bus. CSI modules connect to the dedicated camera connector with drivers built into the JetPack image for common sensors such as IMX219 and IMX477, so their pixels never touch the shared 5 Gb/s USB link. Keep the CSI camera on the stream that never changes, put the USB cameras on the streams you need to re-cable, and re-run the formula for what remains on the bus.

How do I set MJPEG in OpenCV on Jetson Nano?

Open the camera with VideoCapture(index, CAP_V4L2), then set CAP_PROP_FOURCC to the 'MJPG' code and set CAP_PROP_FRAME_WIDTH, CAP_PROP_FRAME_HEIGHT and CAP_PROP_FPS before the first read(). Properties set after streaming starts are ignored, and OpenCV's defaults can pick YUYV or a smaller frame than you planned the bus around. Confirm what you actually got with cap.get(CAP_PROP_FOURCC) and the frame shape.

How many USB cameras can one Jetson Nano run at the same time?

Budget against about 3.2 Gb/s of working bandwidth on the shared link. Four 1080p30 MJPEG streams at 5:1 compression take roughly 200 Mb/s each, about 0.8 Gb/s combined, and fit with room to spare; four uncompressed YUYV streams need 4.0 Gb/s combined and do not fit. After bandwidth, JPEG decode time on the CPU is the next ceiling, so test with every camera open at your real frame rate before locking the design.