Maybe someone has a cleaner solution, but here's how you could brute-force it.
1. Wire the two signals as Gate inputs for two different counters.
2. Configure both counters for triggered buffered event counting using the signals in question as Gates. Make sure the same trigger specs are fed to both.
3. Configure both counters to use an internal timebase as a source. Note: at 80 MHz, you'll have 50-some seconds of counting before the 32-bit counters roll over. At 20 MHz you get about 3.5 minutes and at 100 kHz you get almost 12 hours.
4. Start up the counters and feed them a trigger. Monitor (poll) the second counter for the 'available points' attribute. When it changes, read out the value, which represents # of source cycles since the trigger, i.e., time. We'll call this t2.
5. Query the first counter for 'available points', then read them all. Ideally, the last buffered value will be the one you care about -- let's call it t1.
In the real world however, you need to make sure that t1 < t2. If not, you'll need to backtrack through the array until you first find a value such that t1 < t2.
Then, your delta time is (t2-t1) * (source period).
Additional notes for the more ambitious:
----------------------------------------
2a. You can generate the trigger signal yourself if there isn't an appropriate signal in the outside world. Programmatically, you could use a digital output or another counter. Manually, you could wire in a manual switch.
2b. If you need both high resolution *and* long measurement times, you could instead set up for buffered period measurements. However, you'd need to then pay attention to *all* the buffered values coming in and keep track of a cumulative sum on your own. (The sum would need to be kept in floating point too because the integer datatypes would roll over just like the counter.)
2c. If you need both high resolution *and* long measurement times, you could set up one of the counters to "pulse on terminal count". Then you'll need to configure a third counter to do event counting on that output signal. Call this count c3. Then your times would be:
corrected t1 = raw t1 + c3 * (2^32)
corrected t2 = raw t2 + c3 * (2^32)
Be sure to convert 'raw t1' and 'raw t2' to floating point before performing the addition.
3a. If your real needs fall somewhere between the 100 kHz and 20 MHz clocks, you could use another of the 6602's counters to generate a pulse train that you use as a source signal.
4a. If there's more than one value in the second counter's buffer, just go through the step 5 procedure for whichever one(s) you care about.
5a. There's some chance that the last value in the counter 1 buffer will be needed for your *next* instance of a pulse into counter 2's Gate. Be prepared to hang onto that last value -- you may need it on your next cycle through the loop.
ALERT! LabVIEW's subscription-only policy came to an end (finally!). Unfortunately, pricing favors the captured and committed over new adopters -- so tread carefully.
