I have the following signal activity :
There are thousands of CS_n pulses that occur in a sequential one-shot fashion, and I'd like to be able to "stack" or "fold" them over a period of 5ns or so to make some measurements between CS_n and CLK.
Simply triggering on the falling CS_n edge does not accomplish this. The acquisition looks like this:
Is there a way to accomplish this?
Infinite persistence is certainly relevant in achieving the view I want, and it's enabled as you can see from the several acquisitions in the second image. I initially expected to see thousands of "stacked" or "folded" acquisitions given the amount of signal activity that occurs. But as I've thought about this more, I don't think that's right.
Given that the signal activity is "one shot" where thousands of pulses occur and then stop, the scope is only storing those after the trigger (outlined in orange) given the memory depth/sampling rate.
In the view below, those 7 pulses are "folded" ( I think)
I imagine if I trigged the "one shot" activity again, acquisitions would continue to fold. My initial thought was that all of the pulses in the one shot pulse train (even those occurring off screen) would fold, but after considering the memory depth, this seems like the wrong conclusion.
It seems like the "folding" occurs once per trigger acquisition? Is this the right way to describe what's happening?
Folding, to me, implies overlaid data. If you clear persistence and perform a Single acquisition, no data is overlaid. You are seeing only what is in acquisition memory. If you continue to perform Single acquisitions, you will see persistence data (and measurement results) accumulate. Running is like repeatedly performing single acquisitions as fast as possible; persistence data and measurement results accumulate with each acquisition.
Persistence is a pixel hit database. When acquired data hits a pixel, the hit is stored in the database and displayed as a dimmed color on the screen. Infinite persistence never clears the database as acquisitions continue to be made. Variable persistence clears pixel hits after a certain amount of time. Color grade persistence counts the number of hits and displays different colors for different hit count ranges.
The pixel hit database has information about acquisitions that have occurred in the past and are no longer in memory, just like accumulated measurement results do, but there is no way to know which acquisition caused a pixel hit.
In a real-time eye, folding happens within a single acquisition as all the Unit Intervals (UI) in the acquisition are overlaid. True, the real-time eye result is displayed using a pixel database, but the data is still in memory and the real-time eye can be "unfolded" to show a particular UI in the acquisition.
Segmented memory is another case where data in remains in memory but can be overlaid using persistence. "Playing" the captured segments causes persistence pixel hits and measurement results to accumulate as if multiple acquisitions have taken place, but you can go back to a particular memory segment that caused a pixel hit.
"Acquisition folding" makes me think of segmented memory acquisitions. "Folding" by itself makes me think of real-time eye, color grade view, or infinite or color grade persistence. Do any of these features help you accomplish what you want?