At the end of the last lesson,
I mentioned we would be looking at some problem-type signals in this lesson
and then use advanced triggering to isolate them.
What do I mean by "problem signals"?
One of the main reasons engineers use oscilloscopes is to debug their designs.
That means that when they're testing their designs,
they're often looking for the unexpected.
They're looking for the needle- in-a-haystack event
that might cause their design to unexpectedly fail
or perhaps not meet desired specifications.
Hi, I'm Johnnie Hancock, Product Manager for Keysight Infiniivision oscilloscopes.
Let's now look at some problem signals and see how we can isolate them
with advanced parametric triggering.
Now, I'm probing a clock signal, basically a square wave.
This happens to be one of the built-in training signals
of this particular oscilloscope that we use for training-education-type environments.
Everything looks normal right now, but let's zoom in and take a closer look.
There's one period of the clock on screen.
If you look closely, you might see something flickering.
I'm going to turn the waveform intensity up so we can see it more clearly,
and there we can see something popping in there.
Sometimes I call it a ghost waveform.
It's a very infrequent glitch.
This scope uncovers it.
Most scopes won't show you this.
This scope has an extremely fast waveform update rate.
Up to 200,000 times per second, it can update and retrigger and show you,
and it can uncover the needle-in-a-haystack, problem-type signal like this.
How can we isolate this?
If we can isolate it, then perhaps we can find the root cause,
what's causing it to happen.
The way we isolate things like this is to uniquely trigger on this occasional glitch.
What's unique and different about the glitch versus the normal clock signal?
What's unique and different is it's a very narrow pulse.
I can see the pulse width of the clock signal, I'm at 2 µs per division,
5 divisions, it's about 10 µs, a normal positive pulse on the clock.
I can see when this thing pops in there, it looks like it's about 1 µs wide.
Let's go into the trigger menu and see what our options are.
I'm going to press Trigger, Trigger Type,
and you can see we're triggering on an edge.
Our other options are Pulse Width, Pattern, Rise/Fall time,
Set Up and Hold, Video, and Serial.
The one that's going to work for us, and we'll get to some of the others later,
is pulse width triggering, and remember, it's a narrower pulse than a normal pulse.
Here it says Source Channel 1, that's the input I'm using.
I can say, is it a positive pulse or a positive glitch or a negative?
It looks like a positive one to me, so that little icon means positive.
Then, I can put a time qualifier on it.
Less than, greater than, or within a range, and then the specific time.
Right now, it says a positive pulse for less than 30 ns,
so right now, the scope is not triggering.
If I clear screen, you see nothing,
because it's looking for a pulse narrower than 30 ns.
Let's start increasing the value up to somewhere around 1.5 µs or 2 µs,
and it should start triggering on that narrow pulse.
I'm up to 500 ns.
There it is.
Now, it's triggering about one time per second.
That's how often it is happening.
If I change the time base here, you can see that it's a narrow glitch
buried amongst thousands of normal pulses, we've uncovered it.
At this point, what's causing that, I could take other channels of the scope
and probe other signals in the system and see what's correlated to it,
and that might help me find the root cause.
Here's another example.
This is a fairly complex signal.
It's a series of digital pulses, they're somewhat random.
You might think of them as serial data,
and we'll get to that, I believe, in the next lesson.
You can see different pulse widths, let's run,
but the signal does have a problem, signal integrity problem.
I'm going to zoom in, and if you take a close look at this rising edge,
I'm just triggering on rising edges,
again, we can see something flickering up here.
Let's increase the waveform intensity.
Normally, the edge has a nice smooth rising edge,
but sometimes it goes up, it stalls, and goes up again.
This is called a non-monotonic edge, "mono" means "one," one edge.
It's got two edges for a complete transition.
Let's measure the rise time.
A normal rise time not on the non-monotonic edge,
on the one with the monotonic edge, measures about 120 ns.
To isolate the non-monotonic edge,
let's go back into the triggering menu, select Trigger Type.
Right now we're triggering on edge, last time we triggered on pulse width.
The right selection this time is Rise and Fall Time.
We can set up a qualification to trigger on the slower rise time,
which the non-monotonic edge is slower.
Right now we're set up on Channel 1, rising edge.
If it occurs for greater than, about 120 ns,
so let's increase the time until we get up to about 130 ns,
and there you can see that it locks on to the non-monotonic edge.
Now again at this point, we've isolated the problem signal,
maybe use other channels of the scope,
maybe at the time of this edge, something else is occurring.
Find what that other thing is that might be coupling in and causing this problem,
and it was the advanced parametric triggering that allowed us to isolate this edge.
You've just seen a few examples of using the scope's advanced triggering
to synchronize acquisitions and waveform display on some fairly complex signals.
In this case, a random glitch and an infrequent non-monotonic edge.
I quickly showed you some of the other advanced trigger selections,
but we didn't have time to go into any details.
One of those was serial triggering.
In our next lesson, we'll be talking about serial bus analysis,
which may come in handy for you,
especially when you get to your capstone design project.
If you're interested in learning more about the importance of waveform update rate,
which we also briefly mentioned during this lesson,
go to the URL listed on your screen
to download a paper I authored on this topic.
It compares the odds of capturing something infrequent to rolling dice.
See you in Lesson 14.
Go, Stanford Tree!
A tree, really?