6.003: Signal Processing

Communications Systems

May 7, 2019

Matching Signals to Communications Media

A key problem in the design of any communications system is match-

ing characteristics of the signal to those of the media.

For example, to efficiently transduce radio waves, the size of an

antenna must be on the order of a wavelength λ (often λ/4).

λ

f = c/λ

1010.10.01

1010

109

108he

rtz

meters

Small antennae (as in cell phones) are most efficient at high fre-

quencies (>GHz). Not well matched to audio signals!

Matching Signals to Communications Media

A sampling of communications systems:

• cellular communications

• wifi

• broadband

• cable

• bluetooth

• GPS (the Global Positioning System)

• private networks: fire departments, police

• radar and navigation systems

• IOT (the Internet of Things)

− smart house / smart appliances

− smart car

− medical devices

• many more

Amplitude Modulation

Amplitude modulation is a common technique for modifying the

frequencies used to represent a signal.

In this scheme, the signal x(t) is multiplied by a high-frequency

carrier signal.

×x(t) y(t)

cos(ωct)

tx(t) cos(ωct)

tx(t)

tcos(ωct)

Describe the effect of this multiplication in the frequency domain.

How can x(t) be recovered from y(t)?

Amplitude Modulation

Frequency representation of AM signals.

y(t) = x(t) cos(ωct) = 12x(t)

(ejωct + e−jωct

)Y (ω) =

∫ ∞−∞

y(t)e−jωt dt =∫ ∞−∞

12x(t)

(ejωct + e−jωct

)e−jωt dt

= 12X(ω−ωc) + 1

2X(ω+ωc)

2ωm

ω

X(ω)

2ωm2ωmω

Y (ω)

−ωc ωc

Frequency Shift Property

If

x(t) ctft←→X(ω)

then

ejωctx(t) ctft←→X(ω − ωc)

Synchronous Demodulation

Recovering a signal after amplitude modulation.

× × LPFx(t)y(t) z(t)

x̂(t)

cos(ωct) 2 cos(ωct)

Multiply the received signal y(t) by the carrier and then lowpass filter.

This process is called synchronous demodulation.

y(t) = x(t) cos(ωct)

z(t) = y(t) × 2 cos(ωct) = 2x(t) × cos(ωct) × cos(ωct) = x(t) (1 + cos(2ωct))

Describe the synchronous demodulation process in frequency.

Synchronous Demodulation

Frequency representation of synchronous demodulation.

2ωm

ω

X(ω)

2ωm2ωmω

Y (ω)

−ωc ωc

2ωm2ωm2ωm

ω

Z(ω)

−2ωc 2ωc

Synchronous Demodulation

A problem with synchronous demodulation is that the carrier signal

must be known exactly! Even a time delay (phase shift) is problem-

atic. What happens if there is a phase shift φ between the signal

used to modulate and that used to demodulate?

× × LPFx(t)y(t) z(t)

x̂(t)

cos(ωct) 2 cos(ωct+φ)

z(t) = 2x(t) × cos(ωct) × cos(ωct+φ)= x(t) × (cos(φ) + cos(2ωct+φ))

Passing z(t) through a low pass filter yields x(t) cos(φ).

If φ = π/2, the output is zero!

If φ changes with time, then the signal “fades.”

AM with Carrier

A more robust method is to send the carrier along with the message.

× +

C

x(t) z(t)

cos(ωct)

z(t) = x(t) cos(ωct) + C cos(ωct) = (x(t) + C) cos(ωct)

t

z(t)

x(t) + C

Adding carrier is equivalent to shifting the DC value of x(t).If we shift the DC value sufficiently, the message is easy to decode:

it is just the envelope (minus the DC shift).

How would you reconstruct x(t) from z(t)?

AM with Carrier

AM with carrier requires more power to transmit the carrier than to

transmit the message!x(t)

xp

xrms

xp > 35xrms

t

Speech sounds have high crest factors (peak value divided by rms

value). The DC offset C must be larger than xp for simple envelope

detection to work.

The power needed to transmit the carrier can be 352 ≈ 1000× that

needed to transmit the message.

Okay for broadcast radio (WBZ: 50 kwatts).

Not for point-to-point (cell phone batteries wouldn’t last long!).

Amplitude Demodulation

In principle, the carrier signal can be inferred from an AM signal.

tx(t) cos(ωct)

tx(t)

tcos(ωct)

However, the required processing (e.g., using phase locked loops)

is not simple, and requires assumptions about the signal (e.g., that

x(t) is rarely 0).

AM Radio

Commercial AM radio

• 106 channels

• each channel is allocated 10 kHz bandwidth

• center frequencies from 540 kHz to 1600 kHz

Continuousto Discrete

SoftwareRadio

Discrete toContinuous

x(t) x[n] y[n] y(t)

fc

Design the Software Radio:

• Assume that x(t) is sampled at 10 M samples/second.

• Decode the channel centered on fc [Hz].

• Save results to .wav file, sample frequency 44,100 samples/second.

AM Radio

Simulation:

• 10 seconds of data

• 24 channels

• sampled at 10 Msamples/second.

Plot of DFT magnitude and zoomed version.

Software Radio

Process in 10 second blocks.

× LPFx(t)y(t)

x̂(t)

2 cos(ωct)

Implementation.

• fetch x[0:N] where N = 108

• y = [x[n]*2*cos(2*pi*fc/fs*n) for n in range(N)]• Y = fft(y)• set Y[k] = 0 for k outside LPF passband

• z = ifft(Y)-1• downsample to 44, 100 samples/second

Q: Do you really need to multiply by cos(ωct)?

A: No. Just shift the k’s near ωc down to k = 0.

Software Radio

Final code.

def receive(x,fs,fc,filename):N = len(x)X = fft(x)Y = numpy.zeros(N,dtype=complex)for k in range(-5000*N//fs,5000*N//fs+1):

Y[k] = X[k+fc*N//fs]y = 2*numpy.real(ifft(Y))-1z = [y[n*fs//44100] for n in range(N*44100//fs)]wav_write(z,44100,filename)

receive(x,10000000,570000,’z570.wav’)receive(x,10000000,660000,’z660.wav’)receive(x,10000000,700000,’z700.wav’)receive(x,10000000,780000,’z780.wav’)

Strategy 1

Works fine.

Listen to examples: z660.wav, z570.wav, z700.wav, z780.wav

One problem: none of output is ready until all of output is processed.

Not good for streaming.

Strategy 2

Process the input stream in 0.01 second chunks.

def receive(x,fs,fc,filename):N = len(x)NN = N//1000zz = []for c in range(N//NN):

xx = x[c*NN:c*NN+NN]XX = fft(xx)YY = numpy.zeros(NN,dtype=complex)for k in range(-5000*NN//fs,5000*NN//fs+1):

YY[k] = XX[k+fc*NN//fs]yy = 2*numpy.real(ifft(YY))-1zz.extend(list(yy))

ww = [zz[n*fs//44100] for n in range(len(zz)*44100//fs)]wav_write(ww,44100,filename)

receive(x,10000000,780000,’zz780.wav’)

Listen to result: zz780.wav. What causes the distortions?

Strategy 2

The problem is with the “ideal” lowpass filtering.

N = 100000

H[k] ={

1 if −5 ≤ k ≤ 50 otherwise

k

H[k]

−5 5

n

h[n]

−N/11 N/11

When lowpass filtering with a DFT, the convolution is circular.

The resulting signal wraps from end to end.

Overlap-Add Method

Can fix this problem using overlap add.

x[n]

n

N

N

N

Window 0

Window 1

Window 2s

s

Fill each window with s samples of the input and N−s zeros.

Then convolve each window with a filter of length N−s and sum the

windows.

Strategy 3

Use overlap add.

def filter(x,fs,fc):N = 100000s = N*3//4

H = numpy.zeros(N,dtype=complex)for k in range(-5000*N//fs,5000*N//fs+1):

H[k] = 1h1 = list(ifft(H))h2 = h1[N-N//8+1:]+h1[:N//8+1]+(3*N//4)*[0]

# Hann windowfor n in range(N//4):

h2[n] *= (1-cos(2*pi*n/(N//4)))/2return fft(h2)

The resulting filter h[n] has length N but only N−s non-zero values.

Strategy 3 (continued)

def receive(x,fs,H,fc,filename):N = 100000s = N*3//4out = []keep = (N-s)*[0]for i in range(len(x)//s):

X = fft(list(x[i*s:i*s+s])+(N-s)*[0])Y = numpy.zeros(N,dtype=complex)for k in range(-5000*N//fs,5000*N//fs+1):

Y[k] = X[k+fc*N//fs]Z = [y*h for y,h in zip(Y,H)]z = numpy.real(ifft(Z))out.extend([k+z for k,z in zip(keep,z[0:len(keep)])])out.extend(z[len(keep):s])keep = z[s:]

w = [2*out[n*fs//44100]-1 for n in range(N//4,len(out)*44100//fs)]wav_write(w,44100,filename)

H = filter(x,10000000,780000)receive(x,10000000,H,780000,’zzz780.wav’)

Listen to result: zzz780.wav.