Cameras & sensorsTroubleshooting

Camera multiplexer no cameras available: select the channel first

Why a CSI camera stack reports no cameras available behind an I2C multiplexer, and the fix order: scan the bus, select the channel, then launch capture.

LumaSpec Vision9 min read Share on LinkedIn

On this page 8 sections
  1. 01What a no cameras available report actually measures
  2. 02How a two-channel adapter switches the signal
  3. 03Likely causes, in order of probability
  4. 04Fix it in this order
  5. 05Worked example: the bring-up grid and the cost of alternating
    1. The grid a healthy bring-up produces
    2. What alternating capture costs
  6. 06When the shared port cannot carry the inspection
  7. 07Keep it working
  8. 08Questions

Two cameras, one CSI port, an adapter board that switches between them: each camera works plugged in alone, and the capture software still reports no cameras available. The failure is almost never the cameras. On a multiplexer board the sensor sits behind an I2C switch, and until code selects the channel, the sensor is not on the bus at all. This walkthrough is for engineers bringing up multi-camera boards on embedded systems. It follows the chain from switch to sensor to driver, ranks the likely causes, gives the bus-scan test that shows where the chain breaks, and ends with the rate calculation that decides whether the shared port can carry the inspection at all.

What a no cameras available report actually measures

A libcamera-class capture stack builds its camera list once, when the manager starts. It walks the declared I2C buses, probes every sensor the device tree describes, and whatever answers in that moment becomes the camera list for the whole run. Nothing that happens later adds a camera. The error is a snapshot with one meaning: at the instant the manager started, no sensor answered.

That leaves two failure classes. Either the sensor was off the bus because the multiplexer channel was never selected, or the overlay never declared a sensor behind the switch, so nothing probed it even with the channel connected. A pass on the harness test alongside an empty camera list is the signature of a software ordering problem, not a wiring one: the sensor-to-host capture sequence runs probe before stream, every time.

How a two-channel adapter switches the signal

The adapter sits between the SoC and the camera flexes. One small I2C switch, at its own 7-bit address, gates the sensor control bus and the MIPI CSI-2 data lines of exactly one camera onto the port at a time. Three consequences drive everything else:

  • The sensor is invisible until you select it. With no channel connected, a bus scan shows the switch and nothing else.
  • Identical sensors share one address. Two of the same part answer at the same 7-bit address, so the scan of channel A and the scan of channel B look identical. The switch state, not the address grid, tells you which camera is live.
  • Ungated control lines probe whoever is first. If both sensors' I2C pins are tied straight onto the bus without the switch, the first sensor probed claims the address and the second goes silent or answers with a NACK. That case and the bus topologies that avoid it are covered in two sensors with the same I2C address.

Shared control buses behave this way at any scale, which is why multiple camera modules on one host needs the same discipline: scan first, select second.

Likely causes, in order of probability

  1. The channel was never selected before capture started. The select step lives in a side script, runs after the manager starts, or was never written. Test: scan the bus — a switch that answers with no sensor behind it points here.
  2. The overlay does not describe the switched camera. A single-camera overlay probes the CSI port once at boot, finds the channel closed and binds nothing. Test: read the boot log for the sensor driver's probe; if it loaded the wrong binding or never ran, reading dmesg and fixing the overlay is the procedure.
  3. The board is an active bridge, not a passive switch, and the bridge is not up. Some multi-camera boards carry logic that needs its own driver before any camera appears. Test: the switch chip itself never answers a scan — bring the bridge up first, as in CSI camera multiplexer not detected.
  4. The physical layer. A flex not seated or inserted reversed, a missing power rail, a damaged connector. Test: still no sensor after the channel write — then follow no data received from sensor.

Cause 1 dominates wherever the cameras pass a direct test: the only new element is the switch, and the switch defaults to disconnected.

Fix it in this order

  1. Keep the direct-connect baseline. You have already proved sensor and driver work alone; note the overlay that worked, because the switched overlay is derived from it. If even the direct test fails, run the firmware-level check in a camera that is not detected before touching the adapter.
  2. Apply the overlay that matches the adapter — a sensor node declared behind the switch — and reboot. The sensor driver should probe cleanly or say why it did not.
  3. Scan the bus with no channel selected. Expect the switch, commonly in the 0x70–0x77 range set by its address pins, and no sensor. Record the grid.
  4. Select the channel, then scan again. Write the channel byte to the switch; on bit-mapped switches 0x01 connects channel 0 and 0x02 connects channel 1. The sensor's address must now appear. Setting both bits at once ties two sensors onto one control bus, wanted only when their addresses differ.
  5. Read the sensor's chip-ID registers at that address. An ACK proves a wire exists; the expected ID proves the sensor. Check the chip ID over I2C shows the read.
  6. Start the capture manager only now. One camera should be listed. To change cameras: stop streaming, write the other channel byte, restart the manager — the list is rebuilt only at start, never mid-run.

The addresses in that sequence are board-specific; a worked pass with illustrative values looks like this:

bus    = 1          # I2C bus the adapter sits on
mux    = 0x70       # 7-bit address of the switch
sensor = 0x36       # address the sensor is expected at
ch_a   = 0x01       # control byte: connect channel 0
ch_b   = 0x02       # control byte: connect channel 1

# scan 1, no channel set -> only mux (0x70) answers
# write ch_a to mux, scan 2 -> sensor (0x36) appears
# read ID registers at 0x36 -> expected chip ID returns
# start manager -> camera list holds one entry

Worked example: the bring-up grid and the cost of alternating

The grid a healthy bring-up produces

Step Bus scan shows Meaning
Before the write 0x70 only Switch alive, channel open, sensor unseen: expected
After 0x01 0x70 and 0x36 Channel A connected, sensor answering
After 0x02 0x70 and 0x36 Channel B connected; identical sensor, identical address

The third row is the one that catches people: with identical cameras the bus cannot tell you which camera you switched to — only your write history can.

What alternating capture costs

Model each service of a camera as its capture window plus one switch:

T_service = T_capture + T_switch T_cycle = N_cameras × T_service fps_per_camera = 1 / T_cycle

Take a 100 ms capture window per camera (a 10 fps capability you intend to use) and a full switch — stream stop, channel write, re-probe, sensor re-init, stream start — measured at 450 ms on the target board. Two cameras give T_cycle = 2 × (100 ms + 450 ms) = 1100 ms, so each camera is serviced once every 1.1 s: 1 ÷ 1.1 s ≈ 0.9 frames per second per camera.

The decision follows directly: if the inspection needs 2 frames per second per camera, this shared port fails and no software change fixes it. The switch time is what moves the result: cut the measured switch to 200 ms and T_cycle = 2 × (100 ms + 200 ms) = 600 ms, which is 1 ÷ 0.6 s ≈ 1.7 frames per second per camera. Measure the switch once with a timestamp at each stage. The register traffic itself is tens of milliseconds at a 400 kHz bus; the rest is driver teardown and re-probe, so a few hundred milliseconds is the realistic floor on the small CPUs these adapters run on.

When the shared port cannot carry the inspection

Two requirements disqualify a channel switch outright. Simultaneity: stereo depth, or any inspection where both sensors must expose the same instant of a moving part, cannot be done sequentially at any switch speed. Rate: alternating capture that lands below the fps-per-camera number you just calculated.

The upgrades, in order of effort:

  • A second CSI port, if the SoC has one — each sensor gets its own bus and overlay, and the I2C and device-tree checks then apply per port.
  • A hardware stereo adapter that interleaves both sensors into one larger frame on the single port: simultaneous, at the cost of a bigger frame sharing one bandwidth budget.
  • Two independent cameras on separate buses, the standard industrial answer: USB3 multi-camera acquisition and GigE bandwidth planning for six cameras give the bandwidth arithmetic for each interface, with none of the switch overhead.

USB3 is the simple path at bench length; GigE once distance enters. Both interfaces run through the board-level cameras range, and long or flex-rated runs live in the camera data cables category.

For the two-stream case, rate first: the LS-BCM-0003 is a 3.1 MP USB3 board-level camera with an IMX252 sensor, a 1/1.8" global shutter and 120 fps.

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

When the cameras sit metres from the host instead of centimetres, the GigE counterpart takes over: the LS-BCM-0020 runs 6.3 MP on an IMX178, a 1/1.8" rolling shutter at 18 fps, with a CS-mount lens holder.

Board-level cameras6.3 MP board-level camera, IMX178, 1/1.8" rolling shutter, 18 fps (LS-BCM-0020)LS-BCM-0020
Sensor format
1/1.8"
Lens mount
CS-mount
Resolution
6-10 MP
Shutter
Rolling
$290.00View partBuild a system with it

Keep it working

  • Select the channel inside the application start-up, immediately before the manager starts — never in a separate script that may not run. The list is fixed at start, so the write must precede it.
  • Assert the scan result. Log the grid at boot and fail fast when the sensor address is missing; an unasserted bus resurfaces later as the silent peripheral in I2C slave NACK on address read.
  • Re-check overlay and switch address together after any hardware revision change; hardware revision compatibility before you reorder is the same discipline applied at purchase time.
  • Map each channel byte to a physical camera on the bench and in code. With identical sensors the grid cannot tell them apart, so a labelled photo next to the control bytes saves an hour at the next bring-up.
  • Before scaling past two cameras, work through the board camera evaluation checklist; probe order, power and bus loading all scale with camera count.

If the numbers say the inspection needs two true streams, pick the interface first and let parts follow: the cameras finder filters board-level models by resolution, shutter and mount, the build-a-system configurator starts at the camera step, and the rest of the multi-camera bring-up guides sit on the cameras topic page.

Questions

Why does even the switch not show up on the bus scan?

The switch is a plain I2C peripheral, so its bus must be enabled in the system configuration before any scan can see it. Check, in order: the I2C controller is enabled in the boot configuration, the adapter's SDA and SCL lines land on that controller, and the board's pull-up resistors are fitted. If the controller comes up but nothing answers, the wiring or the adapter's power is the suspect, not the cameras.

Can I put two different sensor models on one multiplexer?

Usually not with a single overlay. The overlay typically declares one sensor node behind the switch, so both channels are expected to carry the same part at the same address. Two different sensors need a driver and overlay that define a node and power sequencing per channel; where the driver does not support that, the second sensor is never probed. Two cameras on separate buses avoids the question entirely.

How long does one channel switch take?

Treat a switch as a sensor re-probe, not a relay flip: the driver stops the stream, rewrites the sensor's register set and renegotiates the link. If your bus runs at 100 kHz instead of 400 kHz, register traffic alone grows fourfold, and a slow CPU adds driver re-probe time on top. Time one full switch with a log timestamp at each stage; that measured number, not a guess, sets your cycle budget.

Can I switch channels without stopping the stream?

No. The CSI link is negotiated for one sensor's timing; changing the channel mid-stream desynchronises it and delivers blank or corrupt frames rather than a faster cycle. Stop capture, write the channel byte, let the driver re-probe, then start again. The teardown and re-probe is the price of a shared port, and it is already in your cycle budget.