PicoScope 7 Software
Available on Windows, Mac and Linux
PicoScope deep-memory oscilloscopes have waveform buffer sizes up to 2 gigasamples – many times larger than competing scopes of either PC-based or traditional benchtop design. Most other scopes with large buffers slow down when trying to use a lot of memory, so you have to manually adjust the buffer size to suit each application. You don’t have to worry about this with PicoScope deep-memory scopes as hardware acceleration ensures you can always use deep memory 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.
Sampling rate is one of the headline specifications of any digital oscilloscope. The PicoScope 6404D, for example, can sample at 5 gigasamples per second (5 GS/s). With some competitors’ scopes, high speed comes at a price. When you use an inferior USB oscilloscope to capture a large number of samples, it transfers the raw data to your PC, forcing the CPU to process the data for display. Windows-based benchtop scopes, although more expensive, also slow down as they use the main CPU to process large amounts of data for display. Both of these approaches slow 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.
PicoScope deep-memory scopes overcome this problem by providing hardware acceleration 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 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 shows a serial data stream from the D+ line of a Full-Speed USB link captured at 5 GS/s using the PicoScope 6404D. Thanks to the scope’s deep memory, it was able to sample at this rate for a total 200 milliseconds or 2.4 million bit periods of the USB waveform. Even with a billion samples of data, the display update rate was still faster than once per second – that’s an average capture and display rate of around 1.5 to 2.5 billion samples per second.
You may have calculated that a scope with a 2 GS buffer sampling at 5 GS/s should be able to store 400 ms of data. In practice, the number of samples that the scope actually captures depends on the range of timebases available. Timebases in most scopes are constrained to be multiples of 1, 2 or 5, so 20 ms/div (200 ms total) is the longest available timebase that will fit in the buffer. A second constraint is that, in repetitive trigger modes, most scopes use half of the buffer for transferring data to the PC while capturing data into the other half. This restriction can be avoided, if continuous capture is not required, by using ‘single’ trigger mode.
At high sampling rates a digital oscilloscope’s buffer memory is quickly filled, so the only way the scope can operate on very long timebases is to reduce the sampling rate. The result is that an oscilloscope with a high sampling rate and small buffer memory (say 5 GS/s and 10k samples, to take a real-world example from a competing benchtop scope) 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 20 ms/div, the scope with the 10k memory will have reduced its sampling rate to 25 kS/s while the PicoScope 6404D with its 2 GS buffer will still be sampling at 5 GS/s. The scope with the smaller buffer is sampling 200 000 times slower than the PicoScope 6404D, even though both have the same maximum sampling rate specification.
Figure 2 shows that the PicoScope 6404D samples faster than the 10 ksample oscilloscope at all timebases longer than 100 ns/div. It carries on sampling at 5 GS/s all the way down to the 20 ms/div timebase, when it finally becomes limited by its buffer size. (For these calculations, we have assumed that both scopes use a double-buffering scheme with the memory split in half, as explained earlier.)
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.
As we have seen, PicoScope software 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.
The PicoScope software zoom toolbar contains a number of buttons to control zooming. The Zoom In and Zoom Out buttons change the scale by a factor of two - on both axes if you click the scope view, or only on the horizontal axis if you click that axis. With Windowed Zoom, you draw a rectangle around the area of interest and PicoScope software 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. Undo Zoom returns to the previous zoom setting.
The high zoom factors possible with PicoScope software, together with the large buffer memory, let you examine complex signals at widely differing timescales. The display that we saw in Figure 1 gave a broad view of the activity on a USB cable, but Figure 4 shows what happens when we zoom in on a 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 400 samples per bit enables us to measure the pulse width accurately.
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 (16 km) 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. For closely-spaced events, the latest PicoScopes operating in rapid trigger mode can capture waveforms with as little as 1 µs dead time in between. Using the PicoScope software, you can then step through the memory one segment at a time until you find the event you are looking for.
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 software also lets you choose the number of segments, up to a maximum to 10 000, to make the best use of the waveform buffer.
PicoScopes with deep memory give you more than just extended record length. They also allow you to sample faster, display faster, capture transient events more reliably and find problems more easily.