Three GigE cameras stream cleanly one at a time, then fall apart the moment you run them together over a single Ethernet port: incomplete frames, timeouts, a frame rate a third of what each camera does alone. The cause is almost never the cameras. It is the one gigabit uplink they all share, and the fact that each camera assumes it owns it. This page gives you the bandwidth budget for that link, the device link throughput limit values that make the cameras pace themselves, and the point at which the honest fix is more network ports instead of a slower cell.
What you are seeing
Run one camera on its own and it reaches full frame rate with no drops. Add the second and third behind the same host port and the logs fill with incomplete frames, the effective frame rate collapses, and grabs start to time out. That pattern — each camera clean alone, every combination dirty together — is the signature of a shared-link bandwidth problem, not a bad sensor.
If instead a camera fails to open at all with a could-not-initialize error, start with the causes table below; that failure usually has a different root. And once frames do stream, never feed a short one to your processing: treat it the way incomplete frames stay incomplete: discard, requeue, grab a new one describes.
The symptom looks the same across SDKs and drivers, and so does the fix; troubleshooting multi-camera frame drops on GigE cameras walks the same ground from the integrator side.
Typical cameras in these shared-uplink cells:
- Sensor format
- 1/1.8"
- Lens mount
- C-mount
- Sensor format
- 1/1.7"
- Lens mount
- C-mount
- Sensor format
- 1"
- Lens mount
- C-mount
Likely causes, in order of probability
Rank your fault against this list before touching settings; the first two causes cover most three-camera cells.
| # | Likely cause | Test | Fix |
|---|---|---|---|
| 1 | Combined payload exceeds the uplink (≈118 MB/s usable) | Add width × height × bytes per pixel × frame rate over all cameras; compare with 118 MB/s | Throughput limits, section below |
| 2 | Throughput limit unset — each camera uses the whole link | Read DeviceLinkThroughputLimit per camera in your SDK's feature browser | Set device_link_throughput_limit on every camera |
| 3 | One shared trigger: all cameras burst at once | Fire all three together; drops appear even when the average fits | The limit's pacing flattens the burst |
| 4 | MTU mismatch along the path | Camera, switch ports and NIC must all show the same MTU | MTU 9000 everywhere, section below |
| 5 | Kernel socket buffers too small | Receive errors in NIC counters at moderate load | Raise net.core.rmem_max, section below |
| 6 | Another client holds the camera | Close viewers and stray driver processes; the open then succeeds | One owner per camera |
| 7 | Port negotiated at 100 Mbit/s | Link speed reads 100 on NIC or switch port | Re-seat or replace the cable; force 1 Gbit/s |
Two failure families hide in that table. Rows 1-5 break streaming; row 6 breaks opening, and if a camera will not even enumerate, camera SDK cannot find device: isolate Linux access errors covers the access side. Row 3 deserves its own test: multiple GigE cameras, same trigger: why frames arrive incomplete shows how simultaneous exposure turns an average that fits into a burst that does not.
The budget on one gigabit uplink
One gigabit per second is 125,000,000 bytes per second (1,000,000,000 bit/s ÷ 8, decimal as Ethernet counts). You never deliver all of it as pixels. Every UDP data packet carries 66 bytes that are not image data: 8 preamble, 14 Ethernet header, 20 IP, 8 UDP, 4 FCS and a 12-byte inter-frame gap. At MTU 1500 that is 66 bytes per 1472 of payload — a 4.5 % tax. At MTU 9000 it is 66 per 8972, about 0.7 %. Add heartbeats, discovery and control traffic on top, and the planning number is about 118 MB/s of image payload per uplink.
The cameras cannot see each other. Each one sizes its packets for a full free link unless you cap it, and capping is your job, set in the driver or in the camera itself.
The same arithmetic scales up: GigE multi camera bandwidth planning for six cameras on one switch runs it for six cameras, and GigE camera network planning: switch ports and bandwidth covers the port-counting and cabling side.
Fix one: cap every camera's throughput
- Compute the share. Three cameras: 118,000,000 ÷ 3 ≈ 39,300,000 bytes/s each. A natural first setting is one third of the raw link instead: 125,000,000 ÷ 3 = 41,666,666 bytes/s (≈333 Mbit/s).
- Set it on every camera behind the uplink. Driver launch and configuration files expose it as device_link_throughput_limit; the camera-side GenICam feature is DeviceLinkThroughputLimit, in bytes per second.
- Let the camera pace itself. From the limit, the firmware derives the inter-packet delay (the GigE Vision register GevSCPD) and a matching maximum frame rate, so packets leave spaced out instead of in bursts.
- Stream all cameras together — on the shared trigger if that is your wiring — for a few thousand frames each and count incomplete frames.
- If any appear, step the limit down about 5 % at a time (41,666,666 → 40,000,000 → 38,000,000) until the count stays at zero, then keep one step of margin as the final value.
Some stacks expose a separate maximum-data-rate setting for compressed streams; set it to the same value as the throughput limit so the two do not fight over the same pipe.
Worked example: three cameras on one host port
Three identical 1920 × 1200 mono 8-bit cameras at 20 fps behind one gigabit uplink:
- Frame: 1920 × 1200 = 2,304,000 pixels × 1 byte = 2,304,000 bytes ≈ 2.3 MB
- Per camera: 2,304,000 × 20 fps = 46,080,000 bytes/s ≈ 46 MB/s
- Three cameras: 3 × 46,080,000 = 138,240,000 bytes/s ≈ 138 MB/s
- Budget: ≈118 MB/s — the cell is over by about 20 MB/s, which is exactly when incomplete frames start
- Capped at 40,000,000 bytes/s each, the frame rate that fits is 40,000,000 ÷ 2,304,000 = 17.4, so about 17 fps per camera
Decision, per case. If the inspection needs 15 fps or less, set 40,000,000 bytes/s on all three and the cell runs stable. If it needs the full 20 fps, throttling cannot deliver it — no limit value carries 138 MB/s through a 118 MB/s link — so go straight to rewiring. Heavier sensors move the break point fast: a 2448 × 2048 mono camera at 10 fps already draws 50,135,040 bytes/s ≈ 50 MB/s, so two of those eat most of the uplink. Run this arithmetic before you wire the cell, not after.
Fix two: jumbo frames and socket buffers
Jumbo frames shrink the per-packet tax from 4.5 % to 0.7 %, worth roughly 4-5 MB/s of payload on this link — take them. Set MTU 9000 on the camera's network configuration, on every switch port in the path, and on the host NIC. A 9000-byte packet meeting a 1500-byte port is its own failure mode, distinct from raw bandwidth: GigE incomplete frames from a driver and NIC MTU mismatch covers the symptoms, and GigE camera packet size error when your link drops below gigabit the related negotiation fault.
On the Linux host, raise the kernel's UDP receive buffer ceiling so a burst of jumbo packets is not dropped before your application reads it. A configuration that works for a three-camera cell sets in /etc/sysctl.conf: net.core.rmem_max = 104857600, net.core.rmem_default = 104857600, net.core.wmem_max = 104857600, net.core.wmem_default = 1048576, applied with sysctl -p. Inside the application, keep at least three frames in flight per camera — camera streaming buffer count: why three frames beat one shows why three is the floor, not the target.
When the right fix is more ports
The throughput limit is rationing, not new capacity: it protects the link but cannot make 138 MB/s fit through 118 MB/s. When the budget says no, rewire.
- One camera per host NIC port. Direct camera-to-NIC connections give each camera an uncontested gigabit, and the non-camera sensors go on their own switch — the arrangement that ends the fight outright.
- A multi-port gigabit NIC adds ports without a switch in the path.
- A faster uplink between switch and host — 2.5G, 5G or 10G — with a NIC to match.
- A faster camera interface when the frames themselves are big. If the cell must carry 25 MP frames at full rate, a gigabit uplink was never going to be enough — the same family exists with a 10GigE interface:
- Sensor format
- APS-H
- Lens mount
- F-mount
- Interface
- 10GigE
- Resolution
- Over 25 MP
Browse area scan cameras by interface and resolution in the camera finder, or start from the camera step of the build-a-system configurator. For the CPU side of many cameras on one host — decode load, not just link load — see multiple GigE cameras on one computer: bandwidth and CPU budget.
Prevention: budget before you wire
- Run the demand sum for every camera on the uplink and keep 5 % or more headroom below ≈118 MB/s — the overload you prevent stays invisible until a future frame-rate bump.
- Set MTU 9000 on camera, switch and NIC together; a half-jumbo path fails intermittently and wastes a day.
- Configure device_link_throughput_limit at commissioning even when the cell fits, so later changes cannot silently overload the link.
- Keep one owner per camera: close viewers and stale driver processes before your application opens.
- Confirm every port negotiates 1 Gbit/s; a 100 Mbit/s port hides until the first real stream.
- Size the kernel buffers and keep at least three buffers per stream in the application.
- Test with all cameras firing together, since simultaneous triggers create the worst burst the uplink will ever see.
More fixes in this family live on the systems topic page. If you are sizing a cell now, send the frame sizes and rates through the contact page and we will check the budget with you before you order.
Questions
How do I calculate the bandwidth one GigE camera needs?
Multiply width × height × bytes per pixel × frame rate. A 1920 × 1200 mono 8-bit camera at 30 fps needs 1920 × 1200 × 1 × 30 = 69,120,000 bytes/s, about 69 MB/s — over half of the ≈118 MB/s usable on a shared gigabit uplink. The same camera in color 8-bit doubles that to about 138 MB/s and cannot share the link with anything at that rate. Compute it per camera before wiring the cell.
What DeviceLinkThroughputLimit value should three cameras get?
Set every camera behind the uplink to one third of the raw link: 125,000,000 ÷ 3 = 41,666,666 bytes/s (about 333 Mbit/s) per camera. Mind the unit: the GenICam feature DeviceLinkThroughputLimit is in bytes per second, so typing a bit-rate value there leaves you 8× over budget. Expect to step down toward 40,000,000 bytes/s until all cameras stream thousands of frames with zero incomplete ones.
Do I need jumbo frames to run several cameras through one switch?
Not strictly, but they recover most of the per-packet overhead. Every packet carries 66 bytes of headers and gaps; at MTU 1500 that is a 4.5 % tax, at MTU 9000 about 0.7 %, worth roughly 4-5 MB/s of payload on a 125 MB/s link. The real requirement is consistency: camera, every switch port in the path and the host NIC must all use the same MTU, or frames fragment or fail.
Why does the second camera fail to open while the first streams?
That is usually an exclusive-access problem, not bandwidth. A GigE camera serves one client at a time: a vendor viewer left running, a stray driver process from an earlier launch, or another application holding the handle will make the second camera report an initialization failure. Close every other client on the host, confirm no leftover process from a previous launch, then open the cameras again — one owner per camera.
Why do drops get worse when all three cameras fire on one trigger?
A shared trigger makes all cameras start sending within microseconds of each other, so the instantaneous rate at the uplink is three times its average — the switch port buffer fills and packets drop even when the average budget fits. The throughput limit fixes exactly this: the camera spreads each frame's packets using the derived inter-packet delay, flattening the burst. Trigger all cameras together in your test, never one at a time, to prove the fix.



