Deep Memory In PC Oscilloscopes

Introduction
The PicoScope 5000 series PC Oscilloscopes have huge waveform buffers of 32 to 128 megasamples – many times larger than competing scopes. Most other scopes with large buffers slow down when trying to use large amounts of memory, so that you have to manually adjust the buffer size to suit each application. You don’t have to worry about this with the PicoScope 5000 series scopes, as you can always use the entire buffer while displaying at full speed. Deep memory produces several benefits: fast sampling at long timebases, timebase zoom, and memory segmentation to let you capture a sequence of events.

Fast Sampling at Long Timebases
Sampling rate is one of the headline specifications of any digital oscilloscope. The PicoScope 5000 series scopes can sample at 1 gigasample (a thousand million samples) per second, making them the fastest USB PC Oscilloscopes available at the time of writing. With some scopes, high speed comes at a price. When you set them up to capture a large number of samples, the PC has to process a large amount of data to make it fit the scope display. This slows down the refresh rate of the display so that you see a delayed, slow-moving picture of the incoming signal, making troubleshooting more difficult. Also, while the scope is processing data, there is a long ‘dead time’ during which it stops sampling the signal and can miss the event you are looking for.

The PicoScope 5000 series scopes overcome this problem by ‘downsampling’ the data using special hardware inside the scope, reducing the amount of work the PC has to do. The scope still collects and stores the requested number of samples, but intelligently time–compresses the data before sending it to the PC so that you see the right level of detail for the size of the display. Any time you want to see more detail, you can zoom into the contents of the buffer and the PC will request a new view of the same data from the scope, all without slowing down the display.


Figure 1: Long 50 ms capture with fast 1 GS/s sampling rate

 Figure 1 shows a serial data stream from the D+ line of a Full-Speed (12 Mbps) USB link displayed using the PicoScope 6 software. We wanted to sample at 50 or more times the bit rate to check the signal quality, which required a sample rate of 600 MS/s. PicoScope 6 chose the nearest available timebase of 1 GS/s. At this sample rate, the PicoScope 5204 captured data for 50 milliseconds, or 600,000 bit periods of the USB waveform. The trace shows regular bursts of activity every millisecond.

Even at the top sampling rate of 1 gigasample per second, the PicoScope 5204 still used almost all of its memory to capture 50 milliseconds of data, and did this repeatedly without slowing down the update rate of the display. (You may have calculated that a 128–megasample buffer should be able to store 134 milliseconds of data at 1 GS/s. However, in this example, PicoScope is using the scope’s hardware zoom function, which uses part of the scope’s memory for processing data. If you write your own application using the driver supplied, you can turn off this feature and collect up to 134 million samples.)

To see all the detail in this data we will have to use the timebase zoom function, which is discussed later.

Sampling Rate Versus Memory Depth
A digital oscilloscope stores its data in a waveform buffer. At high sampling rates this buffer memory is quickly filled, so the only way the oscilloscope can collect data for long periods of time is by turning down the sampling rate. The result is that an oscilloscope with a high sampling rate and small buffer memory (say 1 GS/s and 10 kilosamples, to take a typical example) can only collect at the quoted sampling rate for the top few timebases. For the longer timebases, it has to reduce the sampling rate to avoid running out of memory. For example, at a timebase of 5 ms/div, the scope with the 10 k memory will have reduced its sampling to 0.2 MS/s while the PicoScope 5204 using a 50 million sample buffer will still be sampling at 1 GS/s. The scope with the smaller buffer is sampling 5,000 times slower than the PicoScope 5204, even though both have the same theoretical top sampling rate.


Figure 2: The effect of memory depth on sampling rate

Figure 2 shows that the PicoScope 5204 samples faster than the 10 k sample oscilloscope at all timebases longer than 1 µs/div. It carries on sampling at 1 GS/s all the way down to the 5 ms/div timebase, when it becomes limited by its buffer size.

Writing your own programs using the PicoScope 5000 series SDK, as mentioned earlier, allows you to squeeze even more storage time out of the scope: by switching off the hardware zoom function and using the entire buffer, you can capture data for 134 ms at the maximum 1 GS/s sampling rate, which is equivalent to using a scope timebase of 13.4 ms/div.

In conclusion, when choosing an oscilloscope, you must consider whether the scope has enough memory depth to allow it to use its maximum sampling rate at the timebases you want to use.

Timebase Zoom
As we have seen, PicoScope 6 begins by showing an overview of the entire capture, compressing it if necessary to fit the display. We will now see how you can zoom into the data to make highly accurate time measurements.

In the PicoScope 6 software, zooming is controlled by five buttons. The Zoom In and Zoom Out buttons zoom in and out by a factor of two on each axis. With Windowed Zoom, you draw a rectangle around the area of interest and PicoScope 6 magnifies it to fit the screen. Once you have zoomed in, the Hand button lets you drag the picture around. The Zoom to full view button zooms back out to the original scale.


Figure 3: Zoom controls in PicoScope 6

The high zoom factors possible with PicoScope 6, together with the large scope memory, let you examine complex signals at widely differing timescales. The display we saw in Figure 1 gave a wide view of the activity on a USB cable, but Figure 4 shows what happens when we zoom in to measure the duration of one burst of data. We can zoom in even closer (Figure 5) to check for ringing, noise and timing errors on individual bits. The time resolution of over 80 samples per bit enables us to measure the pulse width accurately.


Figure 4: Original view in Figure 1 zoomed in 1000x

 


Figure 5: Original view in Figure 1 zoomed in over 65,000x

Memory Segmentation
When you’re searching for a rare, high-speed event, deep memory is a great help. You can capture a long period of time at high resolution, giving you a good chance of catching at least one event. The only disadvantage is that you then have to scan through all the data, relying on your eyes to spot the event. Imaging scrolling through over 65,000 screenfuls of data like the one in Figure 5 – at a typical desktop screen size, that’s about 10 miles of waveform!

A more efficient approach is to split the memory into segments, set up a trigger condition as narrowly as possible for your event, and then store a separate capture in each segment. With this method, you avoid wasting memory on the time between events when nothing is happening. Using the PicoScope 6 software, you can then step through the memory one segment at a time until you find the event you are looking for.


Figure 6: A sequence of waveforms from the buffer

Figure 6 shows just a few of the buffer segments out of the total number available, in this case 1000, each containing its own waveform. The buffer navigation buttons let you scroll through the buffer to find the event you want. You can also save the whole buffer and examine it at a later date. PicoScope 6 also lets you choose the number of segments to make the best use of the waveform buffer.

Conclusion
The deep memory on the PicoScope 5000 series scopes gives you more than just extended record length. It also allows you to sample faster, display faster, capture transient events more reliably and find problems more easily.

Infobox
Mbps = megabits (1,000,000 bits) per second
ms/div = milliseconds (1/1,000 second) per division
µs/div = microseconds (1/1,000,000 second) per division
MS/s = megasamples (1,000,000 samples) per second
GS/s = gigasamples (1,000,000,000 samples) per second