You call fetch_buffer() on a camera that enumerated cleanly, opened without a complaint, and let you write the node map — and the call comes back None. No exception, no log line, nothing in the console. This page is for that exact case: a GenICam GenTL consumer that can talk to the camera but never receives a buffer. None has one meaning here — no complete buffer arrived within the wait — so the question is never 'why did the call fail' but 'why did nothing arrive'. The cause is one of five things: a wait shorter than the frame interval, a camera that is not producing frames, a stream held by another client, a producer that cannot deliver buffers for this model, or packets lost on the wire. Each cause below has a one-line test, a fix, and its place in the running order.
What None actually means
In a GenTL set-up, the producer — the .cti file your consumer loads — owns the camera and the transport. Your consumer announces buffers, starts acquisition, and asks the producer for the next completed one; the image travels as the payload of that buffer, fetched through the ImageAcquirer class. When the ask expires with the queue still empty, the try-style fetch (try_fetch()) does what it is defined to do: give up and return None if no complete buffer was acquired during the defined period. There is no failure state further down — the call simply found nothing to hand you.
Control is separately alive in this case. The camera enumerated, start_acquisition(True) succeeded, and node map writes went through — the case behind this page wrote a Gamma of 2.0 through remote_device.node_map mid-session. Enumeration, control and XML are proven; only delivery is in doubt. That split cuts the search to five causes.
None is also not the failures next door. A -1009 invalid parameter at fetch is a rejected call, and a padding_y fetch crash is a buffer-geometry mismatch that dies loudly. None is the quiet one: delivery, not decoding.
First fix the wait: a timeout shorter than the frame interval
The cheapest cause to eliminate first. Trigger-driven cameras, long exposures and slow lines can all have a delivered interval longer than the consumer's default wait, and every fetch returns None on a perfectly healthy stream. Give the fetch at least three times the longest interval between frames, plus half a second of margin for the transport to recover from one lost-packet resync:
On a triggered line, t_frame is trigger gap plus exposure plus readout, not the free-run period. A one-second wait suits continuous free run on most area scan cameras. Ten seconds is the diagnostic value: a stream that cannot deliver one buffer in ten seconds is not slow, it is broken. The call in this case came back None, so it was the giving-up kind of fetch — pass the wait explicitly, as a timeout argument in seconds, rather than trusting the default.
Worked example: the 10-second test on a 5 MP GigE camera at 14 fps
Inputs, with their sources:
- Camera: a 5 MP GigE area scan camera in 8-bit mode, running 14 fps at full resolution — the class of camera in this case, with the rate taken from its model designation.
- Frame period: 1 / 14 fps = 71 ms.
- Payload: about 5 MB per frame (≈5 million pixels × 1 byte), so 14 fps × 5 MB = 70 MB/s = 560 Mbit/s before overhead — comfortably under the roughly 950 Mbit/s of usable payload a clean GigE link carries, a typical figure for GigE Vision. The link is not the bottleneck in free run.
Rule in words: a healthy free-run stream delivers a frame every 71 ms, so any wait of three frames plus 0.5 s must return a buffer, and a 10-second wait covers about 140 frame periods — it separates 'slow' from 'never'.
Arithmetic:
- Frame period: 1 / 14 fps = 0.071 s = 71 ms.
- Minimum sane wait: 3 × 71 ms + 500 ms = 213 ms + 500 ms = 713 ms ≈ 0.7 s.
- Diagnostic coverage: 10 s / 0.071 s ≈ 140 frames per wait.
Result: a healthy stream answers any fetch of 0.7 s or more within a frame or two; only broken delivery survives a 10-second wait empty.
Decision: run one fetch at 10 s. A buffer inside ten seconds means timing or configuration — tighten the wait to 0.7 s afterwards and fix the cause you found. None after ten seconds rules out timing entirely; move down the list. Buffers arriving seconds apart against a 71 ms period mean frames are produced and then lost — packet loss or a stuttering trigger.
Cause two: the camera is not producing frames
Node map writes succeeding tells you control works — not that the acquisition configuration makes sense. Two states deliver exactly zero buffers:
- Trigger mode on with the source on a line that never pulses, or software trigger armed and never issued. The camera waits; the queue stays empty; every fetch returns None forever.
- Acquisition mode wrong for the expectation — single-shot set where you meant continuous — or acquisition stopped after an earlier error. A stopped acquisition is quiet.
Test: force free run. Set acquisition mode to continuous, trigger mode off, and fix the exposure at a short 1,000 µs. Start acquisition and fetch with a 10-second wait. A buffer now? The trigger configuration was the cause: put trigger mode back, wire the source for real, and walk the per-camera hardware trigger set-up — each camera family keeps its trigger features under different names.
Exposure eats frames more subtly too: a 100 ms exposure against a trigger every 50 ms drops delivery to about 10 frames per second, and short waits start returning None even though the stream is alive. Same symptom, different fix.
Cause three: another client holds the stream
GigE Vision gives exactly one client the stream channel. Many cameras accept a second connection for control, so you can enumerate, read and even write the node map while the primary client keeps pulling the frames. The camera's own viewer left open from an earlier test is the usual holder; an SDK tool or a resident service does it too. This is why 'it works in the vendor viewer' proves less than it seems: the viewer may be the cause, not the proof.
Test: close every application that opens the camera — viewer, SDK tools, services — power-cycle the camera to release the stream cleanly, re-enumerate, and start acquisition fresh with a 10-second fetch. A buffer now? Keep one client per camera in production, and release before another tool grabs the camera.
The same rule bites elsewhere: the ROS one-client case is the clearest walk-through, and the configuration-tool variant shows a monitoring tool holding the same door.
Cause four: the producer cannot deliver this model's buffers
The rarest cause, and the one this case landed on. The signature: no buffer at any wait, ever; the same consumer and producer pull images fine from a different camera model; the problem camera streams perfectly in its own tool. Control and delivery exercise different parts of the producer, and a producer build can lack the buffer-delivery path for one model's feature set. What mismatch looks like on other calls is in the producer-consumer compatibility check and the silent exit on unimplemented functions.
Three tests, in order:
- Run a different camera model through the same consumer and producer. Buffers arrive? The producer-model pair is your problem.
- Run the same camera through a second consumer, or a second producer .cti. If the second consumer delivers, keep it — nobody should ship a stack that does not deliver.
- Update producer and consumer to current versions before concluding anything. If you added a new .cti recently, validate it before you enumerate — a file that loads without errors has proven nothing.
In this case, two similar GigE cameras shared one consumer and only one delivered buffers, so the camera that failed stayed on its maker's own stack. That is a legitimate answer: pin a working pair per camera model and record it in your build notes.
Cause five: packets are lost before they reach the queue
On GigE, one dropped packet breaks a frame, and the producer discards the incomplete image and delivers nothing. The only symptom is a late or missing buffer — over an evening, a log full of Nones. If buffers arrive but seconds apart against a 71 ms frame period, this is your section.
Check in order: the producer's stream statistics for packet errors or resends, where it exposes them; the camera's packet size against the network's MTU; and whether the camera shares an adapter or subnet with unrelated traffic. The fixes are ordinary GigE hygiene — packet size matched to jumbo frames end to end, a dedicated adapter or VLAN for the camera, headroom under the link rate. The GigE stream timeout guide carries the packet-size and NIC settings, and the adjacent symptom — buffers that arrive with empty components — is the GigE stability fix.
The five-minute sequence that finds your cause
Run it top to bottom and stop at the first buffer that lands. Every step uses a 10-second wait so timing never confounds the result.
- Set the wait to 10 s and fetch once. Buffer: your waits were too short — tighten to 3 × t_frame + 0.5 s and move on.
- Force free run: acquisition mode continuous, trigger mode off, exposure 1,000 µs. Buffer: the trigger configuration was the cause — rebuild it against the hardware trigger guide.
- Close every other client, power-cycle the camera, re-enumerate, start fresh. Buffer: one-client discipline was the cause.
- Swap in another camera model through the same consumer and producer. Buffers: producer-model mismatch — update the pair or keep this model on its maker's stack.
- Read the stream counters and match packet size to MTU. Loss found: apply the GigE hygiene above.
- None at every step with a camera proven in its own tool: record consumer, producer and camera-model versions together and take the pair to support with those details.
Keep it from coming back
Three habits prevent the silent None from returning:
- Log every None with a timestamp and the wait you used. Nones every 2.0 s against a 71 ms frame period tells you far more than 'it stopped working'.
- Pin producer and consumer versions together and re-run the 10-second test after any update on either side.
- Announce enough buffers and reuse them. A queue that is too short adds fetch failures of its own, and per-frame allocation adds stalls — the buffer reuse pattern shows the fix.
When the pair itself is the problem, choose it deliberately. The GigE area scan cameras category lists what is current, the frame grabbers category covers the card-based route for CoaXPress and Camera Link, and the camera finder filters by interface; the system configurator starts at the camera step. More stream and delivery diagnostics sit on the systems topic page, and if you want a second pair of eyes on a camera-producer-consumer combination before you commit, talk to us — free expert support with every order.
Questions
Does fetch_buffer ever raise instead of returning None?
Yes, but not for a timeout. Exceptions at fetch time are consumer-side: an invalid parameter passed in, a handle already released, or a producer function the consumer needs that the producer does not implement. The timeout path is quiet by design — the try-style fetch gives up and returns None when no complete buffer arrives during the wait. Treat exceptions as code or pairing bugs; treat None as a delivery problem at the camera, the network or the producer.
The camera streams in its own viewer but fetch_buffer still returns None — why?
The viewer proves the sensor, cable and network are good; it says nothing about your consumer's buffer delivery. Work the ranked list, starting with a held stream: viewers grab the stream channel exclusively, and some cameras let a second client keep control while the primary keeps the frames. Close every tool that opens the camera, power-cycle it, re-enumerate and start acquisition fresh. If a 10-second fetch still returns None with no other client, move on to producer-model compatibility.
What fetch timeout should I set for a triggered inspection?
Set the wait above your longest interval between frames: trigger gap plus exposure plus readout, times three, plus half a second of margin. For a line that stops between parts that can be several seconds. A 10-second wait is a safe diagnostic ceiling — anything that cannot deliver a frame in 10 seconds is not slow, it is broken. Log each None with a timestamp so you can later tell a dead trigger line from a lost packet.
Can network problems cause a silent None instead of an error?
Yes. On a GigE Vision stream a dropped packet breaks one frame; the producer discards the incomplete image and delivers nothing, so the only sign is a late or absent buffer. Watch the producer's packet-error or resend counters where it exposes them, match the camera's packet size to the network's MTU, and keep the camera on a dedicated adapter or subnet. Persistent loss also shows up as incomplete images in the buffers that do arrive.
Is this behavior different on USB3 or CoaXPress cameras?
No. None means no complete buffer arrived within the wait on every transport; only the physical cause changes. GigE adds packet loss and exclusive stream access to the list, USB3 adds controller power management, and CoaXPress adds link and frame grabber configuration. The five-minute sequence is identical on all three: a 10-second fetch first, then forced free run, then a single client, then a second camera model through the same producer.