Tektronix 468
Sine Display Response
One of innovations, at the time, of the Tektronix 468 scope was the use of the sin(x)/x reconstruction of waveforms. Tektronix actually received a patent for this technique (US Patent 4647922 (Mar 3, 1987) see https://patents.justia.com/patent/4647922).
This technique is used when a waveform [WF] is "Time expanded" before being displayed. A 468 WF is expanded when a Time/Div selection of faster than 2 μSec/Div is selected (internal timebase [TB] value 20 or higher). 2 μSec/Div means 1 screen can show a WF of 20 μSec (10 divisions per screen). This value is also the maximum hardware digitization speed the 468 can handle (25 MS/sec or 40 uSec per sample). The AD converter and associated acquisition memory used in the 468 can sample one value every 40 μSec (fastest options). Since each regular WF has 512 samples, this means digitizing one WF takes 512 * 40 nSec = 20.48 μSec. This WF spans the 10 horizontal divisions per screen so 2 μSec/Div. Every Time/Div value setting faster than 2 μSec/Div (1, 0.5, 0.2, 0.1, 0.05 and 0.02) results in a displayed WF that is a "Time expanded" version of the WF acquired at 2 μSec/Div. Each sample is a 1 byte value.
When the 468 CPU processes the completion of an acquisition (both acquisition complete and the display queue must be ready), it determines that a WF needs to be processed specially if the target TB value is > 20. The CPU then determines how many expansion steps are needed (a maximum of 6 steps are allowed), where each step expands the WF to a memory buffer of the same size. This means that the number of samples in each WF doesn't change.
Instead, the WF is expanded by a factor of 2 by discarding the second half of the input WF and inserting an interpolated value between each sample from the first half of the input WF. For a normal case (Alternating Vertical Mode), the acquisition buffer holds 512 values but the "nSamples" argument is always <= 256, so only the first 256 samples of the input buffer are processed (<++pSrc> 256 times) but the output buffer is filled with 512 values (<pDest =+ 2> 256 times).
This is where the "Display Response" push button on the 468 front panel comes in. When PULSE is selected, the interpolated value is just the average value of its two neighbors. However, when the SINE button is selected, an sin(x)/x convolution is computed based on up to 10 surrounding values. The code for the first time expansion looks like this:
uint16_t *Sine_Convolution(uint16_t nSamples, uint8_t *pSrc, uint8_t *pDest)
{
uint16_t cnt, addition;
uint32_t v3;
uint8_t s2;
cnt = nSamples;
do {
addition = (uint16_t)*(pSrc + 0) + (uint16_t)*(pSrc + 9);
v3 = addition << 2;
addition = (uint16_t)*(pSrc + 1) + (uint16_t)*(pSrc + 8);
v3 -= (int16_t)(addition * 10);
addition = (uint16_t)*(pSrc + 2) + (uint16_t)*(pSrc + 7);
v3 += (addition * 21);
addition = (uint16_t)*(pSrc + 3) + (uint16_t)*(pSrc + 6);
v3 -= (int16_t)(addition * 47);
addition = (uint16_t)*(pSrc + 4) + (uint16_t)*(pSrc + 5);
v3 += ((uint32_t)addition * 160);
if ((uint8_t)v3 >= 0x80) { //round based on LSB of v3
v3 += 256;
}
s2 = ((uint16_t)v3 >> 8); //divide by 256
if ((uint32_t)v3 >= 0x10000) { //16 bit overflow
uint8_t tmp = ((v3 >> 16) & 0xff);
if (tmp != 0) {
s2 = (tmp < 0x80) ? 0xff : 0;
}
}
*(pDest) = *(pSrc + 4);
*(pDest + 1) = s2;
pDest += 2;
++pSrc;
} while (--cnt);
return (uint16_t *)pDest;
}
There is another scenario where WFs are Time expanded: if you freeze a WF using the SAVE option, it is possible to inspect that frozen WF in more detail by selecting a faster Time/Div value. In that case, the 468 will also expand the stored WF using the same technique as described above.
Even though this sin(x)/x code in the Tektronix firmware is heavily optimized 8085 assembly language, using lots of 16-bit add instructions to implement all the multiplications, the poor CPU is still extremely busy doing these interpolations and is only able to compute one or two new WFs per second when Time/Div is set to 50 nSec/Div: a newly acquired and magnified WF is shown on the screen only about once or twice per second! Most of the time, the previously acquired and expanded WF is shown over and over again.
Note that this method of creating a WF by repeatedly expanding into a complete buffer is not the best way of doing it if 2 or more steps are needed. It's faster to determine for each step how many WF samples are really needed to achieve the desired result and only expand that many samples. For example, when 2 steps are needed, the final expanded WF needs 512 samples, so the second step needs to expand 256 samples to 512 samples. This in turn means that the first step only needs to expand 128 samples to provide the required 256 samples to the second step. In reality, it's more complicated since the time difference between the various steps is non-linear but it's the same principle. This improved algorithm speeds up the Time expansion algorithm if there are more than 2 steps and is used in the Dutchtronix V3 firmware.
For suggestions and corrections, please contact me at:
