HOW-TO GUIDE
How to Use Oscilloscope Segmented Memory for Intermittent Faults
By the OhmSavvy Research Team ·
Safety when hunting faults on live equipment
- Long unattended captures often run on powered equipment. Keep the probe ground clip on circuit ground only; on mains-referenced circuits use a differential probe or an isolated supply.
- Relay contacts may switch mains. Probe only the low-voltage side, or use a rated differential probe, and keep fingers clear while the equipment cycles.
What oscilloscope segmented memory is
In normal mode a digital scope fills its whole record with one acquisition, processes and displays it, then re-arms. Events that arrive during that processing are missed, and the next trigger overwrites the last capture. Segmented memory (also called sequence or history, depending on the maker) changes the arrangement: the memory is divided into N segments, every trigger fills just one, and the scope re-arms with minimal dead time between them. Display updates are deferred until the run finishes, which is why re-arming can be so quick.
That makes it a good fit for intermittent faults: problems that appear in short bursts separated by long stretches of normal behavior.
1Trigger on the fault condition, not on everything
Every segment is spent on a trigger, so the trigger decides what you collect. Triggering on every clock edge fills memory with normal cycles in a fraction of a second. Narrow it to the condition that only the fault produces: a pulse narrower than normal, a runt that fails to reach full height, an edge on a line that should stay quiet, or a level crossing above the expected maximum. The basics of edge, level and holdoff are in how to trigger an oscilloscope.
If you don't yet know what the fault looks like, trigger on the normal event that precedes it and collect many segments. The odd one becomes the template for a tighter trigger on the next run.
2Choose segment length vs segment count
Segment length is the time each capture covers, set by the timebase: ten divisions times the time per division. Points per segment are that time multiplied by the sample rate. Total memory is fixed, so longer segments mean fewer of them. Scopes also cap the maximum segment count regardless of memory, so check both limits.
| Setting | Gives you | Costs you |
|---|---|---|
| Short segments (fast timebase) | Many segments, high sample rate per event | Little context before and after the trigger |
| Long segments (slow timebase) | Context around each event | Fewer segments, or a lower sample rate |
| Trigger near the left of the screen | More time after the event | Less view of what led up to it |
| Trigger near the center | Balanced pre- and post-trigger view | Nothing extra, a sensible default |
Worked example
3Run the capture
01
Set trigger
On the fault condition
02
Set timebase
Segment length
03
Set count
Within memory limits
04
Run
Until full or stopped
05
Review
Segments and timestamps
Use Normal trigger mode, not Auto, so the scope never fills a segment with an untriggered sweep. Then start the sequence and leave it. Most scopes stop when the last segment fills; some can overwrite the oldest. For a fault that appears once an hour, a trigger that fires only on the fault makes even a modest segment count last all day.
4Review segments and timestamps to find the rare one
After the run, the scope offers a player or a list. Step through segments with the multipurpose knob, or play them back as an animation; a shape that jumps out of the sequence is your suspect. Many scopes can also overlay every segment at once, which shows the outlier as a stray line, then let you jump to that segment and run measurements or cursors on it alone.
| Timestamp pattern | What it often points to |
|---|---|
| Even spacing | A periodic source: timer interrupt, firmware task, switching cycle |
| Clusters | An external event: motor start, relay switching, a radio transmitting |
| Gaps that grow over time | Temperature or load dependence |
| Only at start of the run | A warm-up or initialisation problem |
Examples: serial bursts, a sporadic reset pulse, relay bounce
Serial bursts
A UART or SPI link sends short packets between long idle periods. Trigger on the start of each burst, size segments to one packet, and every packet is stored without the idle time. Timestamps show packet spacing; a missing or late packet stands out at once.
Sporadic reset pulse
A microcontroller resets now and then. Put CH1 on the reset line and trigger on its falling edge, with CH2 on the supply rail. Each segment then shows whether the rail sagged at the moment of reset, and timestamps reveal whether resets line up with a load switching on.
Relay bounce
Trigger on the first edge of the contact signal and capture each actuation. After a hundred operations, compare segments: bounce that grows longer across the run, or one segment with far more bounces, points to worn or contaminated contacts.
Segmented memory vs persistence for intermittent faults
Both tools collect many events, but they keep different information. Persistence stacks captures on screen and keeps only the picture; segmented memory keeps every capture as data, with time.
| Persistence | Segmented memory | |
|---|---|---|
| What is kept | An overlaid image | Each capture, separately |
| Timing of each event | Not recorded | Timestamp per segment |
| Measure the rare event | No, only see it | Yes, with cursors and automatic measurements |
| Number of events | Unlimited while running | Limited to the segment count |
| Best for | Spotting that a rare shape exists | Measuring it and finding when it occurs |
A sensible sequence is to start with persistence to find intermittent glitches, then switch to segments once you know what to trigger on. If the fault is a fast transient, set up the probe and trigger level as described in how to capture a brief voltage spike before you start the sequence.
Check your scope supports segmented memory
Models vary a lot here. Some scopes have no segmented mode; others offer it with different maximum segment counts, timestamp resolution and dead time, and the feature can depend on firmware version or an option. Our product data does not list segmented memory for the scopes below, so treat the manual as the authority before relying on it. Compare channel counts and bandwidth in the best beginner oscilloscopes roundup; extra channels help when you want the fault and its likely cause in the same segment.
Four-channel scopes in our reviews
50MHz, 4 channels, 1 GSa/s. Menus have a learning curve; community documentation is strong.
100MHz, 4 channels, 1 GSa/s, with more bandwidth headroom than entry-level scopes.
As an Amazon Associate I earn from qualifying purchases. Prices and availability are shown on Amazon.
Frequently asked questions
What is segmented memory on an oscilloscope?
It is an acquisition mode that divides the scope's record memory into many smaller blocks. Each trigger fills one block with a short capture and a timestamp, then the scope re-arms almost immediately for the next. You end up with a numbered set of separate captures of the same kind of event, which you can review one by one after the run.
Is segmented memory the same as history mode?
They are closely related, and names vary by manufacturer: segmented memory, sequence mode, history, waveform record and frame acquisition are all used. Some scopes keep a rolling history of recent normal acquisitions, while a dedicated sequence mode captures segments back to back with less dead time. The manual tells you which your scope offers and how many segments it can hold.
How many segments do I need to catch an intermittent fault?
Enough that the fault is likely to occur at least once before memory fills. If the fault appears roughly once per hundred normal events and your trigger cannot tell them apart, a few hundred segments gives a good chance. A trigger that fires only on the fault itself needs far fewer, because every segment is then a fault capture.
Why do the timestamps on my segments matter?
They show when each event happened relative to the first. Evenly spaced timestamps suggest a periodic cause, such as a timer, a firmware task or a switching cycle. Clusters suggest something external, like a motor starting or a relay switching nearby. Gaps tell you the fault stopped for a while, which can point to temperature or load dependence.
Does segmented memory reduce the sample rate?
Not necessarily. The total memory is shared among segments, so each segment is shorter, but the sample rate inside each one can stay high because every segment only covers a short time window. Asking for more segments or longer segments than the memory can hold is what forces a compromise, usually a lower maximum segment count.
