3D visionTroubleshooting

Depth camera stuck waiting for device on a network streaming node

A depth-camera streaming server prints waiting for device because the host never enumerated it on USB. Fix power, port, cable and SDK before the network.

LumaSpec Vision10 min read Share on LinkedIn

On this page 9 sections
  1. 01What does 'waiting for device' actually mean?
  2. 02How do I check whether the node sees the camera at all?
  3. 03Why does power come before every other fix?
  4. 04Does the USB port and cable change the outcome?
  5. 05Why does a camera that works on a PC fail on the streaming node?
  6. 06When is it finally a network problem?
  7. 07How should a multi-camera streaming rig be laid out?
  8. 08What is the fastest isolation sequence to run next time?
  9. 09Questions

The streaming service on your capture node boots, prints 'waiting for device', and sits there while you re-check the switch, the IP plan and the client for the tenth time. Stop there: the message is local. A depth-camera streaming server scans the node's own USB bus for an enumerated device before it publishes any stream, so when it waits, the camera never came up on that bus. Most dead-on-arrival cases are the port, cable or power trio covered in depth camera not detected: wrong port, wrong cable or wrong power, but a streaming node adds two twists: the server-side SDK must know the camera, and the network layer sits downstream of all of it. This guide gives you the test order — enumeration, power, port and cable, SDK generation, then network — so you stop at the first step that changes what the node reports.

What does 'waiting for device' actually mean?

It means the streaming server started and found no depth camera on the node's own USB bus; it scans locally for an enumerated device before it publishes any stream, so no switch, IP address or client setting can clear this message by itself.

The pipeline from camera to screen runs device, then SDK, then server process, then RTSP client. 'Waiting for device' fails at the first stage, which is why the client error you see later — a timeout line in the style of 'client time out - 3' on the viewing station — is the echo of an empty server, not a second fault. A camera proven good in the vendor's desktop viewer on a PC narrows the field nicely: the sensor and its firmware work, so the fault sits between the node's USB port and the server process. The sections below follow that order by probability: enumeration first, power second, port and cable third, SDK version fourth, network last.

How do I check whether the node sees the camera at all?

Run lsusb on the node over SSH: if the camera's vendor and product ID is not in the list, Linux never enumerated the device, and every later stage — SDK, service, client — is running against an empty bus.

List the bus, then watch the kernel while you replug. sudo dmesg -w tails kernel messages live; a healthy plug-in prints a 'new USB device' line within a second or two, followed by the camera's ID in lsusb. Replugging and diffing the lsusb output tells you the camera's ID at the same time. Three results decide the branch:

  • New ID appears — enumeration works; skip to the SDK check below.
  • Nothing appears — power, port or cable; the next two sections.
  • Over-current reports or repeating disconnects, often logged as error -71 — supply or cable; power first.

Repeated -71 disconnects have their own diagnosis path in depth camera USB disconnect errors: diagnosing -71 in dmesg. And if lsusb lists the camera but the vision SDK still finds nothing, that is the SDK-side failure walked through in USB camera in lsusb but not detected by the vision SDK on Linux.

Why does power come before every other fix?

A USB 3.0 port supplies up to 900 mA at 5 V — 4.5 W — a small streaming board shares its port budget across one supply rail, and the camera is usually the largest load on that rail, so an under-fed board drops or half-enumerates exactly the device you need.

The signatures are consistent: enumerated at plug-in, gone the moment streams start; the server exiting immediately with a destructor-style line instead of waiting; over-current or repeated-disconnect lines in dmesg. The Ethernet-streaming setups published for these boards call for the board's own external supply — 5 V at 3 A class through its USB-C input — or a Power-over-Ethernet add-on board. A monitor's USB port or an unmarked phone charger is not a supply you can trust here.

Test with the streams running, not at idle: swap in a supply rated 5 V at 3 A or better and watch dmesg through a 60-second stream. If the camera has power but the host never lists it, the port-side checks run in a fixed order too — see camera has power but not detected: USB link checks after a cable swap.

Does the USB port and cable change the outcome?

Plug the camera straight into the node's USB 3.0 port on the shortest cable that reaches — about 3 m is the practical ceiling for a reliable USB 3.0 copper link — because hubs, passive extensions and charge-only leads are the most common reason a camera with a lit LED never enumerates.

A worn connector gives itself away: if wiggling the plug changes the dmesg output, replace the cable, not the camera. Extensions can also pass a desktop test and fail only when the depth stream runs, as in USB extension cable fails only when you record the depth stream.

A USB 2.0 port or a USB 2.0-only cable fails differently: the camera enumerates, then the streams do not fit the link. Take a representative mode — 848 × 480 pixels at 30 fps on depth and colour, with 16-bit depth (2 bytes per pixel) plus 8-bit colour (1 byte per pixel), 3 bytes per pixel in total:

frame size = width × height × bytes per pixel stream rate = frame size × frames per second

Frame size: 848 × 480 × 3 B = 1,221,120 B, about 1.22 MB. Stream rate: 1.22 MB × 30 fps = 36.6 MB/s, about 293 Mbit/s. A USB 2.0 link moves roughly 35 MB/s (280 Mbit/s) of real payload, so depth plus colour does not fit — the depth stream starves or the stack falls back to low resolution. USB 3.0's practical 400 MB/s carries the same pair several times over. What a USB 2.0 fallback looks like is worked through in depth stream has no data on a USB 2.0 port and depth camera stuck at low resolution.

For a bench or cabinet run, a purpose-built lead from the camera data cables range beats the drawer special. The LS-CBL-0219 is a 3 m USB 3.0 camera cable with a high-flex, drag-chain build.

Cables3 m USB3.0 camera cable, high-flex (drag chain) (LS-CBL-0219)LS-CBL-0219$62.00View partBuild a system with it

Why does a camera that works on a PC fail on the streaming node?

When lsusb lists the camera but the SDK — and therefore the streaming service — still waits, suspect the server-side SDK generation: streaming images built for these boards often carry an SDK release that predates the camera model, so the device enumerates but the SDK has no support entry for it.

The test takes a minute on the node: build and run the SDK's own device-list example. An empty list while lsusb shows the camera is a version problem, not a hardware one.

The fix is to install the current SDK release on the node and keep the client on a matching generation, then restart the service — on the open-source builds that service is rs-server, and sudo systemctl restart rs-server.service does it. If you rebuild the node at all, re-image with a current build rather than the original pre-built image, and write the SDK and firmware versions on each node's label so the next mismatch takes seconds to spot.

Version pairing across the stack is the same discipline as matching SDK and firmware when deploying code to a smart camera. The general rule — check the SDK version before blaming the cable — is in depth camera not detected: check the SDK version before the cable, and the bare 'no device found' signature in 3D camera SDK v2 firmware version mismatch.

When is it finally a network problem?

Only once the server prints a running, device-bound line — on the open-source builds, rs-server reporting 'server is running' with no 'waiting for device' — do the client's IP and stream settings matter; before that, a client timeout simply means nothing is serving yet.

Then follow the setup guide's sequence: static IP addresses on the node and the client, ping, then add the network device in the client viewer pointing at the node's address. An address in 169.254.0.0/16 on the node means DHCP answered nothing and no static address applied — set the static address again and confirm with ip addr before touching the client.

A 'client time out - 3' line at this stage means the RTSP server is not bound at the address you entered: re-check the address and the server's own console output. A stream that connects and then degrades over long sessions points at the node's USB bandwidth instead — see stereo depth turns noisy after long streaming.

How should a multi-camera streaming rig be laid out?

Give each depth camera its own node — one camera per board — so every camera gets a dedicated USB 3.0 port, its own rated supply and an independent restart cycle, and the switch aggregates one stream per node instead of several cameras fighting for one bus.

Name each node for the camera serial it carries and give it its own hostname; on the client, add each node's IP as a separate network device. Even the uncompressed worked example above — 293 Mbit/s — fits a standard 1 Gbit/s switch link with room to spare, so the switch is rarely the constraint; the shared USB bus and supply are. If you do put several cameras on one host, the bandwidth and sync trade-offs are in acquire from multiple USB cameras, and identical-looking units are told apart by serial, not by port order — see USB port ID the same for all cameras.

What is the fastest isolation sequence to run next time?

Work this list in order and stop at the first step that changes what lsusb reports; each step tests exactly one cause, and the whole sequence takes about ten minutes on a bench.

  1. Prove the camera. Run the vendor's desktop viewer on a PC. If it streams there, the camera is good and the node is the suspect.
  2. Check enumeration. Run lsusb on the node, replug, and diff the output. No new ID means no enumeration; go to step 4.
  3. Read dmesg. sudo dmesg -w while replugging: a 'new USB device' line is good; over-current or repeated -71 lines point at power or cable.
  4. Fix the supply. Power the node from its rated 5 V, 3 A supply, or from Power over Ethernet — never from a monitor port.
  5. Fix the port and cable. Direct USB 3.0 port, short purpose-built cable, no hub, no extension.
  6. Match the SDK. Run the SDK's device-list example on the node; an empty list means update the server-side SDK, then restart the service.
  7. Confirm the bind. The service should report running with the device bound — no more 'waiting for device'.
  8. Then the network. Static addresses on both ends, ping, add the network device on the client.

A rig debugged this way stays debugged: label every node with its supply rating and SDK version, and label the camera cable at both ends. When you are specifying hardware for a new cell instead of rescuing one, the 3D sensors range and the camera finder filter by interface and resolution, and more depth-camera field fixes are collected on the 3D topic page. If a streaming cell keeps dropping cameras after the full sequence, send the dmesg capture and your SDK versions through the contact page and we will work through it with you.

Questions

Can I put the depth camera on a powered USB hub instead of the node's own port?

Sometimes, but treat it as a workaround rather than the plan. A powered USB 3.0 hub gives each downstream port its own 900 mA at 5 V, which removes the power problem, but it adds a second enumeration hop and shares one upstream link. Bench with a direct port first; if a hub must stay in the build, use a mains-powered USB 3.0 model and re-check dmesg for disconnects under load.

Does the client PC's SDK version cause the waiting for device message?

No. The message is printed by the server process on the node before any client connects, so the client's SDK, viewer build and RTSP settings cannot cause it. Keep both sides on a current, matching SDK generation so the stream decodes correctly, but while 'waiting for device' is on screen, the fix is on the node, not the viewing station.

Why does my streaming node show a 169.254.x.x address instead of the static IP I set?

Addresses in 169.254.0.0/16 are link-local: the board assigned itself one because no DHCP server answered and no static address applied, while the Ethernet link itself is up. Give the node its static address again, confirm with ip addr, put the client on the same subnet, then ping both ways before adding the network device in the viewer.

Can I plug the camera in after the streaming server has already started?

Usually yes: the service rescans the bus and binds a device when one appears. If it stays on 'waiting for device' after a hot plug, restart the service once; a camera that enumerated during a supply sag can sit half-configured until a replug or reboot clears it. Check lsusb after the restart to confirm the bind before blaming the client.