Mixes ("heterodynes") the information signal with a carrier signal, called Double Sideband (AM-DSB). The information signal is "shifted up" from baseband to a carrier frequency.

Two variations:

- Transmitted Carrier (AMD-DSB-TC)
- Suppressed Carrier (AMD-DSB-SC) (the one used in chapter 5)

- Information signal has amplitude Ai, Frequency fi, si(t) = Ai*cos(2*pi*fi*t)
- Carrier signal has amplitude Ac, Frequency fc (higher than fi), sc(t) = Ac*cos(2*pi*fc*t)
- Modulated, ("heterodyned") signal s
_{am-dsb-sc}= Ai*cos(2*pi*fi*t)*Ac*cos(2*pi*fc*t) - Simplified s
_{am-dsb-sc}= ((Ai*Ac)/2)*(cos(wc-wi)*t + cos(wc+wi)*t), where- wc = 2*pi*fc
- wi = 2*pi*fi

- If the information signal had a bandwidth of fh Hz, the result modulated signal has a bandwidth of 2*fh Hz

- supressed carrier AM require "sophisticated coherent demodulators"
- Transmitted Carrier AM allows use of "non-coherent demodulators"

Information signal si(t) plus DC offset Ao is multiplied with carrier sc(t),
result is s_{am-dsb-tc}(t) = [Ao + si(t)] * sc(t)

= Ao*Ac*cos(wc)*t + (AiAc/2)(cos(wc - wi)t + cos(wc + wi)t)

Alternative representation uses AM modulation index 'm':

- Ao*Ac*cos(wc*t)+(Ao*Ac*m/2)(cos(wc - wi)t + cos(wc+wi)t)
- m = Ai/Ao

m can be expressed as a percentage. The max value of m which preserves the information envolope is 1 (100%)

Double Sideband AM uses twice the bandwidth of the information signal; Single Sideband AM uses the same amount of bandwidth

Modulated signal is calculated via:

- Multipliy si(t) by the inphase carrier wave sc(t) (0 degrees phase, cosine)
- Hilbert transform si(t)
- From wikipedia: "The Hilbert transform has a particularly simple representation in the frequency domain: it imparts a phase shift of -90° to every Fourier component of a function. For example, the Hilbert transform of cos(wt), where w>0, is cos(wt - pi/2)"

- multiply the output of hilbert(si(t)) by quadrature version of sc(t) (90 degree phase, sine)
- Subtract the outputs of the I/Q multiplications for s
_{susb}(t), or add them for s_{slsb}(t)

The results are:

- s
_{am-slsb}(t) = AiAc * cos(wc + wi)t - s
_{am-susb}(t) = AiAc * cos(wc - wi)t

The difference between the upper and lower sideband modulations is that the modulated signal for lower sideband is to the left (lower) of the carrier frequency while the modulated upper sideband is to the right (higher) of the carrier frequency:

Uses a bandpass filter (BPF) on Transmitted Carrier (TC) AM to further reduce bandwidth. The reduced width sideband is called a Vestigial Sideband

The modulated signal is BPF([Ao + si(t)]sc(t))

To demodulate an AM signal, it must be multiplied with the EXACT frequency and phase which was used as the carrier signal; however it is unlikely that these exactly match on the receiving end

The signal the RTL sdr uses to get its IQ samples from, when receiving AM-DSB-TC signals is:

- s
_{RTL-SDR}(t) = LPF[s_{am-dsb-tc}(t)*e^{-jwlot}] - e
^{-jwlot}is a complex oscillator inside the RTL-SDR (w_{lo}is the local oscialltor frequency*2pi)- which can be expressed using e
^{jwt}= cos(wt) + jsin(wt) - = cos(w
_{lo}t) - jsin(w_{lo}t)

- which can be expressed using e

However, this assumes the oscillator frequency exactly matches the carrier frequency. This there is an additional frequency offset used in actual demodulation

Simplest non-coherent demodulator is the "envelope detector": a lowpass filter which smooths gaps between the pearks of the carrier wave

Digital, software implementation is as follows:

- Saturate the real component of complex input (saturates negative amplitude to 0)
- Send the saturated output through a low pass filter

Optimized version is as follows:

- Convert the amplitude to magnitude (converts negative amplitudes to positive, sqrt(real_component**2))
- Send the saturated output through a low pass filter

No low pass filter required; converts both the in-phase and quadrature components of the complex input signal to magnitude. This is the equivalent of the radius between the two signals between the I and Q plane:

- demodulated out = sqrt(si(n)**2 + sq(n)**2)
- = |si(n) + jsq(n)|

This is the most optimized version; recommends using