A depth camera not found after reboot — when it ran fine the day you installed the SDK — is failing at the permission or kernel layer, not in the hardware and rarely in the driver. The giveaway is the reinstall loop: after each reinstall the camera works once, and the next boot kills it again. That pattern means one setup step is being re-run by the installer but never written anywhere a reboot can find it. This guide splits the failure with three checks — lsusb, the /dev video nodes and the kernel version — and turns the fix into one pass, plus two lines in your provisioning script so it stays fixed.
Read lsusb before you touch anything
On the failing boot, open a terminal and run:
lsusb
Find the camera's line — the vendor and product ID pair on its own bus. The answer sorts the whole fault into three buckets:
- Camera listed, and /dev/video nodes exist.* Linux sees the device and a driver bound to it. The failure is permissions — the most common bucket by far. Read the next two sections.
- Camera listed, but no /dev/video nodes.* The driver layer failed: the SDK's patched module did not load for the running kernel. Read the kernel section.
- Camera absent. Nothing in the permission layer matters because Linux never enumerated the device. Read the boot-order section.
Run ls -l /dev/video* in the same terminal so you hold both answers before changing anything. This one-minute split is what ends the reinstall cycle.
Cause 1: the udev permission rules never stuck
Every depth-camera SDK for Linux ships a udev rules step in its install notes. The step writes small rules files into /etc/udev/rules.d/ that tell udev to hand the device nodes to a group — video on Debian-family distributions, sometimes plugdev on desktop installs — or to set the node mode to 0666 instead of the default 0660. When the step is skipped, only root can open the nodes. Your capture process runs as a normal user, the SDK's enumeration call hits an access error on every node, and the wrapper — the ROS nodelet manager or a plain viewer — reports it as no devices found.
It works right after an install because you ran the viewer or the install test with sudo, which steps around the permission layer. The reboot returns you to the plain user, and the plain user has no access. That is the whole mechanism behind the loop most of the time.
The test takes ten seconds:
ls -l /dev/video*
groups
Nodes owned by root:video, with no video in your group list: that is this fault.
The fix, done once:
- Run the SDK's rule-install step exactly as its Linux install notes present it.
- Reload and retrigger udev:
sudo udevadm control --reload-rules && sudo udevadm trigger. - Replug the camera so the fresh rules apply to the device that is already enumerated. Give it 2–3 seconds before you check the node again.
- If groups showed no video, add your account to it. On a machine whose login is cell01, run
sudo usermod -aG video cell01, then log out and back in — group changes never reach sessions that are already open.
The same layer, written up with the same lsusb-first logic, is udev rules for USB cameras on Linux: fix permission denied.
The permission math, decoded off the node line
Here is the worked example, with a node line of the shape this fault produces (device numbers illustrative):
crw-rw----+ 1 root video 81, 0 Jan 10 06:41 /dev/video0
groups
cell01 adm cdrom sudo dip plugdev lpadmin
Decode the mode string character by character. The leading c marks a character device; the next nine characters are three triads of the permission bits read (4), write (2) and execute (1):
- owner triad rw- = 4 + 2 = 6
- group triad rw- = 4 + 2 = 6
- others triad --- = 0
So the node is mode 0660, owned root:video. Owner and group may read and write; everyone else gets exactly nothing. cell01's groups list has no video in it, so its open() on /dev/video0 fails before the SDK exchanges one byte with the camera — and the SDK reports no devices found even though lsusb and the driver are perfect. After usermod -aG video cell01 and a re-login, id -nG lists video, and the same 0660 node now grants the session read-write access. Nothing was reinstalled; the arithmetic never changed — the user moved into the group the arithmetic permits.
The trailing + on the mode line means an access control list sits on the node. If you suspect it is overriding the group check, getfacl /dev/video0 shows who really holds access.
Cause 2: the kernel predates the INZI depth format
One depth format draws a hard kernel line: INZI, written V4L2_PIX_FMT_INZI in the kernel's user-space API. It is a multi-planar format at 32 bits per pixel that packs an infrared image followed by the depth data into one frame. Two planes under one code is why the kernel needs explicit support for it, and the first kernel series that documented it is 4.12 — the kernel's own V4L2 API documentation lists INZI among the depth-data pixel formats from that series on.
On a kernel older than 4.12 — the 4.10 series, for example — opening that stream fails with an ioctl error, and the message names INZI, says the kernel does not support it natively, and points at a patch or an upgrade to 4.12 or later. If you see that text, stop reinstalling the SDK: the SDK is fine, the kernel is the missing part.
uname -r
Anything below 4.12 needs the upgrade, not a patch you maintain by hand. In the documented cases of this fault, 4.16-series kernels were where enumeration held, with one Ubuntu setup stuck on 4.15 until it moved to 4.16 because a module built for the old kernel had not been rebuilt.
If uname -r reads 4.12 or newer and you still get the INZI text, a leftover module from an older, patched install is in the way: re-run the SDK's module step for the running kernel and reboot before you change anything else.
Cause 3: the camera never enumerates at boot
If lsusb is silent after the reboot, stop editing permissions — Linux never saw the device, so no rule can apply. This bucket is electrical and boot-order, and it has two documented shapes on this site.
First, the camera needs power later than the boot sequence gives it, which is an enumeration-order problem: see startup order fixes when the camera is not recognized after a reboot. Second, a USB port that keeps VBUS energized across the reboot holds the camera in a stale state, so it never re-enumerates cleanly: see VBUS that stays on and breaks enumeration after a reboot.
The quick discriminator: with the machine up and the failure showing, unplug the camera at the camera end, wait five seconds, replug. If it appears in lsusb and your capture runs, you were in this bucket — and the cure lives in those two articles, not in udev.
Why reinstalling the SDK fixes it until the next reboot
The reinstall loop is not mysterious; the installer simply re-runs the steps you skipped. Installing writes the udev rules, and the replug at the end of the install applies them to the live device, so the camera works immediately. A reboot then undoes it for exactly two reasons: the rules were never written into /etc/udev/rules.d/ in the form a boot-time enumeration reads, or the install patched a kernel module against the kernel that was running at install time, and a kernel update since then has left the camera driverless.
This is why the loop feels intermittent but never is: it breaks on the boot after a kernel update, and survives ordinary reboots once the rules are truly in place. A second trap with the same symptom — a stale SDK copy answering before the current one — is covered in why a script finds no device but the viewer works.
The fix order that survives reboots
Work this sequence on the failing boot; it lands on the cause inside ten minutes:
-
lsusb— camera present? If not, fix power and boot order (previous section) and stop here. -
ls -l /dev/video*— nodes present? If not, re-run the SDK's patched-module step for the running kernel and reboot. -
groups— video missing? Then run the SDK's rule-install step,sudo udevadm control --reload-rules && sudo udevadm trigger, replug, and add your login to video as in the worked example above. - Error text names INZI? Run
uname -r. Below 4.12, move to the newest kernel your distribution supports and reboot. - Prove it: boot twice and run your capture each time. Two clean boots in a row, with no install step in between, is the pass condition.
Windows machines fail at a different layer entirely — the driver stack, not udev. That side has its own ordered fix in the Windows depth-camera driver fix order.
Symptom table: name the failure before you fix it
| What you see | Layer | The fix that sticks |
|---|---|---|
| lsusb lists the camera; SDK says no devices found; a reinstall revives it once | udev permission rules | Install the SDK's rules once; add your account to video; replug |
| Message names INZI with an ioctl error | Kernel below 4.12 | Move to the newest supported kernel; do not reinstall the SDK |
| lsusb lists the camera; /dev/video* nodes missing | Patched module not loaded | Re-run the SDK's module step for the running kernel; reboot |
| lsusb silent; camera appears after a manual unplug and replug | Boot order or held VBUS | Change enumeration order; move off the port that holds power |
| The viewer finds the camera; your script does not | Duplicate SDK installs | Remove the stale copy; keep one SDK version per machine |
Prevention: four lines that keep it fixed
- Rules belong in provisioning. Run the SDK's rule-install step from the script that builds each capture machine. Why: the step done by hand is the step that gets skipped on the rebuilt machine.
- Module step after every kernel update. If your install patches kernel modules, re-run that step before the next capture shift. Why: the update removes the patch, and the next reboot is where you find out.
- Pin the kernel on capture machines. Hold one known-good kernel — 4.12 or newer, in practice a 4.16-series — and upgrade on purpose, with a capture test afterward. Why: an unattended upgrade is how this fault returns months later.
- One SDK per machine. Why: a second copy on the library path answers first, with stale rules and old expectations, and looks exactly like this fault.
When to stop debugging the host
Put a second, known-good depth camera on the same port. If it fails the same way, the machine image is the fault — rebuild it with the rules and the module step baked in. If the first camera behaves identically on every host, the sensor itself is the fault, and that is a hardware decision, not a Linux one.
When you are specifying the replacement, start from the 3D sensors range and the camera finder: a laser profiler or a structured-light camera with current firmware support spends its life above this layer. The configurator walks the chain if you are adding a sensor to an existing cell, and more boot-time failures sit on the 3D topic page. If a replacement still misbehaves on a clean host, reach the team through the contact page.
Questions
Do I really have to reinstall the SDK after every reboot?
No. The reinstall only re-runs the two steps you skipped: the udev rule installation and, where your install uses one, the patched-module build. Write the rules to /etc/udev/rules.d/ once, confirm kernel 4.12 or newer, and rebuild the module after kernel updates. Reboots then stop mattering; a capture run after two consecutive boots, with nothing reinstalled in between, is the proof.
How do I check my kernel version, and which version do I need?
Run uname -r. The INZI depth format needs 4.12 or newer; a 4.10-series kernel throws the patch-required error. On a capture machine, pick the newest long-term kernel your distribution supports — in the documented cases, 4.16-series kernels held — and upgrade only on purpose, with a capture test afterward.
Which Linux group gives access to the camera nodes?
The video group on Debian-family distributions; some desktop installs also use plugdev. Check with groups or id -nG. Missing membership means every open of a /dev/video* node fails even when the udev rules are correct. Add yourself with usermod -aG video and log out and back in, since group changes do not reach running sessions.
What is the INZI pixel format?
A four-character code for a multi-planar frame that some depth cameras stream: 32 bits per pixel, with the infrared plane packed first and the depth data behind it. Because two planes share one format code, the kernel needs explicit support for it — native since the 4.12 series, per the kernel's own V4L2 documentation.
The camera shows in lsusb but the SDK still finds nothing after the rules are in place. What now?
Two SDK copies are the usual culprit: an old install still on the library search path answers first and enumerates with stale rules or an outdated API. Remove the duplicate, keep one SDK version per machine, and confirm your capture script links against the same library the working viewer uses.