Trigger me this

by Bill Driver, Christian Gindorf, National Instruments

Conventional triggering methods in oscilloscopes have trouble capturing rare or complex events. New approaches employ FPGA technology to discern complicated triggering conditions and analyze signals in real time.

One important requirement for oscilloscopes and similar instruments is the ability to trigger on an event of interest. Many vendors offer upward of 100 predefined triggers to help users quickly isolate both common and occasional events. This plethora of trigger modes can make choosing the correct trigger more difficult than actually capturing the signal. Triggers can vary by type, speed, bandwidth, hold off, software and so on, but each carries trade-offs between flexibility and dead time.

Two aspects determine an oscilloscope’s trigger performance: Trigger flexibility describes how easily a trigger threshold or condition can be defined to see the signal conditions under test. Most oscilloscopes provide numerous trigger functions with minimal settings, such as level or width, but don’t provide a way to customize them. Trigger dead time is the time period over which the oscilloscope cannot detect trigger events between acquisitions. A scope can miss an event of interest falling into this dead time.

Trigger dead time is an inherent quality in all trigger architectures, but there are ways to minimize it. Many oscilloscope vendors offer software-based triggers to add more flexibility. But software-based triggering comes with a significant amount of dead time because of the necessary post-processing. It is not ideal for rare and infrequent events.

Edge triggering (starting an acquisition on a rising or falling signal transition) is one of the most common trigger modes on oscilloscopes today. The majority of simple debug and test functions are handled with an edge trigger. But it often takes a more complex trigger scenario to isolate a particular signal shape or multiple shapes in succession.

More advanced triggering options are also common on oscilloscopes and offer additional flexibility for capturing serial protocols like I2C or SPI, as well as advanced events and signal qualities such as glitches, runt, width, slew rate and timeout.

Many trigger conditions are implemented in hardware. But software is used to create more sophisticated trigger options and signal qualifications. Software triggers offer the most flexibility, but add to the data transfer and processing time during which the oscilloscopes cannot detect new triggers.

The trigger system dead time can easily be a magnitude longer than the actual acquired data record—in other words, oscilloscope trigger systems can be blind over 95% of the time. Besides making it harder to detect rare or infrequent events, lengthy dead times could give users the false idea that trigger events are rare because they were undetected during measurement times.

If the triggering or signal analysis capability of an oscilloscope isn’t up to the task, there’s only one remaining option: Acquire long waveform segments and download them to a PC for post-processing to find a specific event. But this task adds an additional layer of complexity to the overall system design and also causes longer test times because of the data transfer latency and necessary processing time.

Most software-based or smart trigger options can handle ordinary circuit design and test. But there are often rare events that can slow product development significantly if not isolated and corrected quickly. This is where the ability to implement user-defined algorithms on an oscilloscope can come in handy. Users can customize the instrument for specific tasks and not be limited to functions the instrument vendor defined. For example, users can create their own application-specific trigger conditions. This can help to significantly reduce test time by eliminating the need for post-processing of data on a PC.

FPGAs are the key enabling technology that give scopes both inline data processing as well as the flexibility to be reprogrammed. These programmable chips can perform custom signal processing and run control algorithms at high throughput rates in true parallel fashion. FPGAs allow for modifying or adding user-specific trigger algorithms. Their high-throughput processing enables the analysis of data samples in real time during acquisition, instead of in post-processing. This eliminates dead time, prevents missed trigger events and helps detect rare events much faster.

For an example of where a user-defined trigger is helpful, consider a case where there are signal shapes or transitions that don’t fit into the standard trigger definitions. In the accompanying diagram, a digital signal shows a nonmonotonic edge as can be caused by signal reflections or a faulty power supply powering the circuit. A standard edge or width trigger might not detect this undesired signal, and detection within normal means is almost impossible.

It takes a special trigger to accurately and consistently capture such an event. A software trigger can be developed to address scenarios like this; however, there’s a large trigger dead time associated with this method, so it might not detect a rare event quickly. An alternative approach employs a user-programmable FPGA. The FPGA can provide a number of window-triggers that compare acquired sample points with a mask. Whenever all window triggers simultaneously detect a valid trigger condition, a combined trigger is issued and the scope acquires the signal.

The FPGA evaluates the signal continuously and in real time. So the oscilloscope can capture single events as well as successive events without dead time between acquisitions.

For many years, test engineers have used software tools such as LabVIEW—instead of the fixed software in traditional boxed instruments—to automate test systems, analyze and present measurements, and reduce cost of test. This approach is flexible and takes advantage of the latest PC and CPU technologies. Often, however, users must also modify the way the instruments take measurements to better meet the needs of an application.

Off-the-shelf instruments traditionally have capabilities that are fixed. But more open, flexible instruments are emerging based on FPGA technology. The resulting off-the-shelf hardware has the best of both worlds: fixed, high-quality measurement technology; the latest digital bus integration; and user-customizable logic that is highly parallel, provides low latency and is tied directly to I/O for inline processing.

With open, vendor-provided software inside the FPGA, users can extend instrument capabilities with, for example, custom triggers or additional timing or control signals. Users can also implement their own algorithms in the FPGA of software-designed instruments to repurpose the hardware for a completely different task. An oscilloscope, for instance, can turn into a real-time spectrum analyzer, transient recorder, protocol analyzer, RF receiver and much more.

With this approach, there are fewer instruments to be purchased and maintained. FPGA-equipped instruments can be especially helpful wherever test and instrument capabilities are needed for 10 years or more. The classic example is in military or aerospace test systems. These applications often have a need to recreate the behavior of old instruments that are obsolete and no longer available.

Reconfigurable instruments are useful here because they can be reprogrammed to mimic the old instrument. The test system software requires much less re-work and recertification to work with this new instrument.

An example of this type of instrument is the NI PXIe-5171R reconfigurable oscilloscope, which uses a Xilinx Kintex-7 FPGA to process acquired samples from the eight inputs in real time. The user-programmable FPGA is integrated into the data path and also provides access to control and timing signals of the instrument.

NI PXIe-5171R reconfigurable oscilloscope
sine.ni.com/nips/cds/view/p/lang/en/nid/212657