Radar ranging experiments use the length of the pulse to determine the height resolution. For finer range resolution you need to use a shorter pulse length. The drawback to this is the amount of energy you can transmit in a single pulse will then decrease. A way around this is to transmit a coded pulse. This is a long pulse where the phase or amplitude is changed during the pulse. If the changes are discreet then the time between changes is the baud length. The entire length of the pulse is called the code length.
The coded pulse will have the power of a long single pulse and the (approximate) height resolution of a single baud. To extract the signal from code/signal combination you need to decode the received signal. The sections below explain this:
The transmitted signal:
Decoding the signal:
Using the fft to decode:
The transmitted signal:
Assume we transmit a coded radar pulse with a code length of 3 bauds. The coded pulse reflects off of the object (atmosphere, asteroid, planet..) and returns to the sender. The figure below shows the echoes from 3 heights (H0(t),H1(t), and H2(t)) starting at time t=0. Let R(t) be the received signal where t=0 is centered at H0(0) (we've ignored the time delay from H0 to the receiver).
The bauds of the code are color coded: (C0: baud0, C1 baud1, C2 baud2). The Heights have been labeled H0,H1, and H2. The time step has duration of 1 baud. The distance between heights is baudlen/2*c. For each height and time, the defined height is centered at the center of the baud (eg at t=0 baud 0 is centered at H0). You can see that the time series for height (the columns of the equations) are offset from the adjacent one by .5 bauds (just the time for the pulse to move from 1 height to the next).
If we assume that the Height value does not change much over 1 code length then the received signal can be written as:
This is a convolution of the transmitted code with the heights funcion.
Decoding the signal:
Most codes used for radar coding have the property that their autocorrelation has a spike at zero delay and have very small values at other delays:
. When Cacf is a maximum. For Cacf is a small value.
Multiply R(0:codelen-1) by and assume that the values Hn(0:2) are constant over the time (0:codelen-1). Looking down the columns of the above equations, you can see that the first column will decode. If you multiple R(1:codelen) by C you will decode the second column. The other columns will give small values since Cacf of the code for values away from 0 is small. We can write the Decode heights Hdcd as:
Writing this in terms of the received signal R(t) gives:
The received signal is the convolution of the code with the heights. The above shows that to decode the data you correlate the received signal with the code C.
Some things to keep in mind about the decoding:
Hn(t) should be constant over the codelength: We assumed that Hn(t) is slowly varying during the length of the code. If it is not then Hdcdn is not just the acf of the code times the height (since we can't factor out the Hn).
Decoding reduces the noise bandwidth of the signal: We have ignored the fact that the signal from Hn(t) is normally small and that most of R(t) is noise. Hdcdn has been averaged over codelength time samples. This decreases the noise bandwidth of Hdcdn by 1/codelength relative to R().
The last codelen -1 samples can not be completely decoded: In the example if you had tried to decode starting at R(3) then you would not have had enough points to completely decode (you only have C0,C1.. you are missing C2). This shows that when N data samples are taken, we only get N-(codelen-1) completely decoded output points.
The convolution theorem says that convolving in the time domain is the same as multiplying in the frequency domain. The steps are:
Do all the heights at once. Assume we have N sampled points. We need to zero extend the code to N values:C(codelength)-> C(N).
Compute the complex conjugate C*(N). To decode we multiply the code by its complex conjugate. To see that why the conjugate is needed assume that the code is purely imaginary. The code would rotate the height data through an angle theta. To undo the code you would need to rotate by -theta. This is just the complex conjugate of the code.
Transform the extended code: C(N) = fft(C*(N),dir=-1)
Transform the N sampled data points: R(0:N-1)=fft(R(0:N-1))
Take the conjugate of the non lagged function (the code): This is because we are doing a correlation rather than a convolution (of course i'm just saying this because it happens to work... i haven't proved it..).
Multiply R * C*
Transform back to the time dome using the reverse transform: fft( R * C*, dir=1).
It turns out that it is a bit faster to use a forward transform (- exp) rather than the inverse (+exp). By conjugating the variables you can switch the direction of the transform (cos(-th) + i*sin(-th)= cos(th) – i*sin(th)).
Putting this all together with the short cuts gives:
conjugate the code, zero extend to N points, forward xform to the frequency domain.
Grab N sampled data points and xform to the frequency domain
Conjugate the transformed data points and multiply by the code. We are going to use a forward xform to go back to the time domain. (conjugate R*C*) = R**C.
do a forward transform to get back to the time domain.
Throw out the last codelen-1 decoded points.
The scale factor will depend on the fft you used. Since we didn't do the forward transform you may have to scale by fftlen. The signal has also gotten bigger by the codelen so you may want to divide by that.