GPIO trigger routing on a serializer board: one input, six cameras

An IP67-housed camera on a serializer link usually exposes no trigger connector, yet the sensor inside it still has a trigger pin. The way in runs through the hub board: the same coax that carries video back also carries GPIO forward, and a pin-mapping table on the board decides which board signal reaches which camera pin. This guide shows how to map one 3.3-5 V input onto the trigger pins of all six cameras, return a strobe to a light controller, and prove both directions before the rig ships.

The decision in one paragraph

Map one board input, BOARD_GPIN1, to the trigger GPIO of every channel on the hub board, and a single pulse fires all cameras together. On one six-channel board the working set of pairs looks like this — target pin first, source signal second, one line per camera:

DESER1_GPIO1  BOARD_GPIN1
DESER1_GPIO3  BOARD_GPIN1
DESER2_GPIO1  BOARD_GPIN1
DESER3_GPIO1  BOARD_GPIN1
DESER4_GPIO1  BOARD_GPIN1
DESER4_GPIO3  BOARD_GPIN1

Six lines, six sensors, one pulse. The gate is sensor trigger support: the routing lands on the sensor's trigger pin only when that sensor implements triggering, so confirm hardware trigger support in each camera model before the rig is planned around it. A sensor without trigger support ignores the line no matter how the map is written — that camera stays on software capture while the rest sync in hardware. If no pulse source exists yet, a frame grabber can generate the camera trigger pulse train.

Why the trigger can ride the coax

Each camera carries a serializer; the hub board holds the deserializer chips — four of them on the six-channel example board — and every camera connects over one coax or shielded pair. A serializer in this class runs a 4.16 Gbps forward channel for video and a 50 Mbps bidirectional control channel on the same cable, with power riding the same conductor in power-over-coax builds. GPIO forwarding uses that control channel: a level change at a board input reappears at the camera end with no software in the path.

That is the whole trick behind triggering a sealed camera, and the same technique underlies FPD-Link III and GMSL multi-camera systems. It is also why the trigger question here is a pin-mapping question, not a wiring one — the signal path already exists; you choose which pins it joins. Getting the host side of these boards running is its own task, covered in FPD-Link III camera bring-up when no board guide exists.

The signals on the board

The names come from the six-channel example board; the mapping tool of your board prints its own set, and the principle is identical. Inputs listen and outputs drive: GPIN is where your pulse arrives, GPOUT is where signals leave. An output can also be forced by hand — setting GPOUT1 to logic 1 and GPOUT2 to logic 0 is two arguments to the same tool — which is handy on the bench when a strobe input needs a steady level.

Route one input to every trigger pin

1. Print the map. Run the board's pin-mapping tool with no arguments; it lists the current routing, which is your baseline and your rollback point.
2. Prove control of the board. Toggle BOARD_LED on, then off. If the LED obeys, the tool talks to the board; if it does not, fix the driver before touching pin routing.
3. Write the pairs. Enter the six target-source pairs above so every channel's trigger GPIO follows BOARD_GPIN1.
4. Wire the pulse. Drive GPIN1 from a 3.3-5 V logic source and tie the source's ground to the board's ground. Open-collector or floating sources need a pull-up — GPIO input pull-up configuration and pin loading covers the resistor values and the input current.
5. Arm the cameras. On every camera, leave free-run and select the hardware line as trigger source, with the same activation edge and the same fixed exposure on all six. The free-run default you must defeat is covered in hardware trigger configuration per camera.
6. Count frames. Feed a slow pulse near 1 Hz and watch the counters: one frame per pulse on each of the six streams, none between pulses. When one stream drifts, multi-camera exposure synchronization with a shared trigger isolates whether the camera or the pulse is at fault.

Bring a strobe back to a light

The return direction is what makes synchronized lighting possible. A sensor with strobe support raises a signal during its exposure; route it deserializer-to-board so it appears on a board output. The example pair drives BOARD_GPOUT1 from DESER1_GPIO0, the strobe pin of the first camera. Wire that GPOUT into the strobe input of a light controller and let the controller switch the LED load:

The LS-CTL-0070 is a digital control box with four channels, 200 W and a strobe feature, set over RS232. The GPOUT is a logic signal; the controller's 24 V constant-voltage outputs are what power the light. Sequencing several lights per frame is the same idea on a larger scale — multi-channel light controller sequencing for photometric stereo walks it.

Pick cameras the pulse can actually use

Hardware triggering starts the readouts together; only a global-shutter sensor also exposes the whole frame at once, so choose global shutter whenever the six images must represent the same instant. The area scan cameras finder filters on shutter type, and high-speed global-shutter models like the MV-CH120-11UC — a 12 MP USB3 camera on the IMX304 sensor — sit at that end of the list.

On the host side, the hub board hands over six synchronized streams through one interface. A direct-link build aggregates cameras the conventional way instead, with a multi-port card such as the MV-GS1104F-DF, a 4-port XoF frame grabber with an SFP+ slot. Either way, frame grabbers are chosen by port count and interface first.

Worked example: trigger-rate ceiling on a mixed six-camera rig

Inputs: six channels share one GPIN. Five cameras are LS-CMR-0166 models, 12 MP at 30 fps; the sixth is an LS-CMR-0053, the same IMX226 sensor on GigE at 9 fps.

Rule: the trigger period must exceed the frame period of the slowest camera, plus a 20% margin for readout jitter and processing spread.

Arithmetic with the 9 fps camera in the rig: frame period = 1 / 9 fps = 0.111 s = 111 ms. With margin: 111 ms × 1.2 = 133 ms. Ceiling: f_max = 1 / 0.133 s = 7.5 Hz, so run at 7 Hz. Host load at that rate: 6 cameras × 7 frames/s = 42 frames/s.

Decision: hold the pulse generator at 7 Hz or slower while the 9 fps camera is in the rig. Swapping it for a sixth 30 fps model moves the frame period to 1 / 30 s = 33 ms, the margined period to 33 ms × 1.2 = 40 ms, and the ceiling to 1 / 0.040 s = 25 Hz — about 3.5x more synchronized sets per second for one camera change. The serializer links forward edges far faster than any sensor reads out; the slowest sensor, not the board, owns the ceiling.

When the usual answer is wrong

• The sensor has no trigger support. The map reaches the pin and nothing listens. That camera belongs on a software-timed station, or replace it.
• You trigger the host instead of the cameras. A pulse into a grabber timestamps frames; it does not start exposure inside sealed cameras. Synchronization has to land on the sensor's trigger pin.
• You read GPOUT as an input. Outputs drive, inputs listen, and the pair names are not interchangeable.
• Two boards share one pulse source. Each hub board maps its own GPIN, so a two-board rig needs the pulse fanned out to both inputs — fanning out one TTL pulse safely shows the buffering that keeps the edges clean.

If a camera ignores pulses after all of this, the cause is almost always the camera-side line setting rather than the board map: hardware trigger source not detected walks the line configuration. For two-camera rigs specifically, stereo camera trigger synchronization with a shared pulse covers the paired case.

Checklist before the rig ships

• Hardware trigger support confirmed for all six camera models.
• LED toggle obeys the tool; the original pin map was printed before any change.
• Six target-source pairs written; every stream delivers exactly one frame per 1 Hz pulse.
• Pulse source at 3.3-5 V, grounds tied, idle level defined when the source is disconnected.
• Trigger rate at or below the ceiling from the worked example.
• Strobe pair mapped; the light flashes inside the exposure window.
• The pin map is re-applied by the machine's start-up script, so a reboot cannot ship an unmapped rig.

Next step: size the sensors in the camera finder, add the light controller for the strobe, or start the vision system configurator. For a board whose pin names differ from the ones here, contact the applications team with the map your tool prints.