**Radar Decoding**

25mar06

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:

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 (H_{0}(t),H_{1}(t), and
H_{2}(t)) starting at time t=0. Let R(t) be the received
signal where t=0 is centered at H_{0}(0) (we've ignored the
time delay from H_{0 }to the receiver).

The bauds of the code are color coded: (C0: baud0, C1
baud1, C2 baud2). The Heights
have been labeled H_{0},H_{1}, and H_{2}. 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 H_{0}).
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 H_{n}(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:

generalizing 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**:

**H**: We assumed that H_{n}(t) should be constant over the codelength_{n}(t) is slowly varying during the length of the code. If it is not then Hdcd_{n }is not just the acf of the code times the height (since we can't factor out the H_{n}).**Decoding reduces the noise bandwidth of the signal**: We have ignored the fact that the signal from H_{n}(t) is normally small and that most of R(t) is noise. Hdcd_{n}has been averaged over codelength time samples. This decreases the noise bandwidth of Hdcd_{n}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.

**Using the fft to
decode the data**:

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**. 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.^{*}(N)**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.