CDMA
Code division multiple access (CDMA) systems use exactly these codes to separate different users in
code space and to enable access to a shared medium without interference.
The main problem is how to find “good” codes and how to separate the signal from noise generated
by other signals and the environment.
A code for a certain user should have a good autocorrelation and should be orthogonal to other codes.
Orthogonal in code space has the same meaning as in standard space (i.e., the three dimensional space).
Think of a system of coordinates and vectors starting at the origin, i.e., in (0, 0, 0). Two vectors are called
orthogonal if their inner product is 0, as is the case for the two vectors (2, 5, 0) and (0, 0, 17): (2, 5,
0)*(0, 0, 17) = 0 + 0 + 0 = 0. But also vectors like (3, –2, 4) and (–2, 3, 3) are orthogonal: (3, –2, 4)*(–2, 3,
3) = –6 – 6 + 12 = 0. By contrast, the vectors (1,2,3) and (4,2, –6) are not orthogonal (the inner product is
–10), and (1, 2, 3) and (4, 2, –3) are “almost” orthogonal, with their inner product being –1 (which is
“close” to zero). This description is not precise in a mathematical sense. However, it is useful to
remember these simplified definitions when looking at the following examples where the original code
sequences may be distorted due to noise. Orthogonality cannot be guaranteed for initially orthogonal
codes.
Now let us translate this into code space and explain what we mean by a good autocorrelation. The
Barker code (+1, –1, +1, +1, –1, +1, +1, +1, –1, –1, –1), for example, has a good autocorrelation, i.e., the
inner product with itself is large, the result is 11. This code is used for ISDN and IEEE 802.11.
Problem
Two senders, A and B, want to send data. CDMA assigns the following unique and orthogonal
key sequences: key Ak = 010011 for sender A, key BK = 110101 for sender B. Sender A wants to
send the bit Ad = 1, sender B sends Bd = 0. To illustrate this example, let us assume that we
code a binary 0 as –1, a binary 1 as +1.
Both senders spread their signal using their key as chipping sequence (the term ‘spreading’ here
refers to the simple multiplication of the data bit with the whole chipping sequence). In reality,
parts of a much longer chipping sequence are applied to single bits for spreading.
Sender A then sends the signal As = Ad*Ak = +1*(–1, +1, –1, –1, +1, +1) = (–1, +1, –1, –1, +1, +1).
Sender B does the same with its data to spread the signal with the code:
Bs = Bd*Bk = –1*(+1, +1, –1, +1, –1, +1) = (–1, –1, +1, –1, +1, –1).
Both signals are then transmitted at the same time using the same frequency, so, the signals
superimpose in space (analog modulation is neglected in this example). Discounting interference
from other senders and environmental noise from this simple example, and assuming that the
signals have the same strength at the receiver, the following signal C is received at a receiver:
C = As + Bs = (–2, 0, 0, –2, +2, 0).
The receiver now wants to receive data from sender A and, therefore, tunes in to the code of A,
i.e., applies A’s code for despreading: C*Ak = (–2, 0, 0, –2, +2, 0)*(–1, +1, –1, –1, +1, +1) = 2 + 0 +
0 + 2 + 2 + 0 = 6. As the result is much larger than 0, the receiver detects a binary 1.
Tuning in to sender B, i.e., applying B’s code gives C*Bk = (–2, 0, 0, –2, +2, 0)* (+1, +1, –1, +1, –1,
+1) = –2 + 0 + 0 – 2 – 2 + 0 = –6. The result is negative, so a 0 has been detected.
This example involved several simplifications.
1. The codes were extremely simple, but at least orthogonal.
2. More importantly, noise was neglected. Noise would add to the transmitted signal C, the results
would not be as even with –6 and +6, but would maybe be close to 0, making it harder to decide
if this is still a valid 0 or 1.
3. Additionally, both spread bits were precisely superimposed and both signals are equally strong
when they reach the receiver.
What would happen if, for example, B was much stronger?
Assume that B’s strength is five times A’s strength.
Then, C' = As + 5*Bs = (–1, +1, –1, –1, +1, +1) + (–5, –5, +5, –5, +5, –5) = (–6, –4, +4, –6, +6, –4).
Again, a receiver wants to receive B: C'*Bk = –6 – 4 – 4 – 6 – 6 – 4= –30. It is easy to detect the binary 0
sent by B.
Now the receiver wants to receive A: C'*Ak = 6 – 4 – 4 + 6 + 6 – 4 = 6.
Clearly, the (absolute) value for the much stronger signal is higher (30 compared to 6). While –30 might
still be detected as 0, this is not so easy for the 6 because compared to 30, 6 is quite close to zero and
could be interpreted as noise.
Although simplified, this example shows that power control is essential for CDMA systems. This is one of
the biggest problems CDMA systems face as the power has to be adjusted over one thousand times per
second in some systems – this consumes a lot of energy.
