Modulation

/ˌpiː ɛs ˈkeɪ/

n. "Carrier phase modulation encoding bits via discrete phase states unlike GFSK frequency modulation."

PSK, short for Phase Shift Keying, encodes data by discretely shifting carrier phase to represent symbols—BPSK toggles 0°/180° (1 bit/symbol), QPSK uses 0°/90°/180°/270° (2 bits), 8PSK/16APSK pack 3/4 bits via 8/16 phase states. Requires coherent demodulation with phase-locked carrier recovery unlike noncoherent GFSK, enabling higher spectral efficiency (2-6 bits/Hz) for satellite/cellular but sensitive to phase noise and demanding precise constellation tracking.

Key characteristics of PSK include: Constellation Mapping BPSK=2/QPSK=4/8PSK=8 points on unit circle; Coherent Demodulation PLL/Carrier Recovery tracks phase reference; Spectral Efficiency 2b/Hz QPSK vs 1b/Hz GFSK; Phase Noise Sensitivity requires oscillator phase noise <-90dBc/Hz; Differential Encoding π/4-DQPSK avoids absolute phase ambiguity.

Conceptual example of PSK usage:

/* QPSK modulator I/Q mapping */
typedef enum {
    PSK_00 = 0,  // 45°
    PSK_01 = 1,  // 135°  
    PSK_10 = 2,  // 225°
    PSK_11 = 3   // 315°
} psk_symbol_t;

const complex float qpsk_constellation = {
    0.707f + 0.707fj,  // 45°  (00)
   -0.707f + 0.707fj,  // 135° (01)
   -0.707f - 0.707fj,  // 225° (10)
    0.707f - 0.707fj   // 315° (11)
};

void qpsk_modulate(complex float *samples, uint8_t *bits, int num_symbols) {
    for (int i = 0; i < num_symbols; i++) {
        uint8_t dibit = (bits[i*2] << 1) | bits[i*2+1];
        samples[i] = qpsk_constellation[dibit];
    }
    
    // Raised cosine pulse shaping
    pulse_shape(samples, rc_filter, num_symbols);
}

Conceptually, PSK imprints data onto carrier phase via I/Q vector rotation—QPSK packs 2 bits per symbol doubling BPSK throughput while π/4-DQPSK rotates constellation each symbol preventing origin trajectory. Demodulators project onto I/Q axes making hard decisions amid AWGN; contrasts GFSK FM discrimination by demanding clean LO unlike constant-envelope Class-E PAs thriving on nonlinear distortion.

/ˌdʒiː ɛf ɛs ˈkeɪ/

n. "Gaussian-filtered continuous-phase FSK modulation for spectral containment in Bluetooth unlike squarewave MSK."

GFSK, short for Gaussian Frequency Shift Keying, applies Gaussian low-pass filtering (BT=0.5) to rectangular NRZ data before FSK modulation, smoothing frequency transitions to minimize spectral sidebands while maintaining constant envelope for nonlinear PA efficiency. Bluetooth Classic uses ±160kHz deviation at 1Mbps yielding 1MHz occupied BW, contrasting raw FSK's infinite tails—enables 79-channel FHSS packing within 2.4GHz ISM alongside WiFi.

Key characteristics of GFSK include: Gaussian Pre-Filtering (BT=0.3-0.5) smoothes NRZ edges reducing 99% BW from infinite; Continuous Phase avoids phase discontinuities unlike CPFSK/MSK; Constant Envelope enables Class-C/E PA unlike QAM; Modulation Index h=0.28-0.35 (Bluetooth) balances orthogonality vs bandwidth; Non-Coherent Demodulation FM discriminator vs MSK coherent sync.

Conceptual example of GFSK usage:

/* GFSK modulator BT=0.5 implementation */
#define BT     0.5f    // Gaussian BW*bit_time product
#define FDEV   160e3   // ±160kHz deviation (Bluetooth)
#define FSYM   1e6     // 1Mbps symbol rate

float gaussian_filter(float t, float bt) {
    // Gaussian pulse h(t) = exp(-(t*ln2/(2*sqrt(2)*bt*Ts))^2)
    float x = t * FSYM * log(2) / (2 * sqrt(2) * bt);
    return expf(-x*x);
}

void gfsk_modulate(float *samples, uint8_t *bits, int num_bits) {
    float phase = 0.0f;
    float freq_dev;
    
    for (int i = 0; i < num_bits; i++) {
        // NRZ → ±1, Gaussian filter
        float nrzi = (bits[i] == 1) ? 1.0f : -1.0f;
        freq_dev = FDEV * nrzi;
        
        // Integrate frequency → phase
        for (int j = 0; j < SAMPLES_PER_SYMBOL; j++) {
            phase += 2 * M_PI * freq_dev / FSYM;
            samples[j] = sinf(phase);
        }
    }
}

Conceptually, GFSK trades sharp spectral edges for smooth Gaussian rolloff—Bluetooth transmits 366μs packets per TDMA slot within AFH-selected channels, where FM limiters tolerate 10dB multipath unlike coherent QPSK. Spectral regrowth minimal at saturation enables 40dBm Class-E PAs; demodulators use zero-crossing discriminators tracking instantaneous frequency amid FHSS hops every 625μs.

/ˌɛf eɪtʃ ɛs ɛs/

n. "Pseudo-random carrier frequency switching spreading narrowband signal across wide spectrum for Bluetooth anti-jamming."

FHSS, short for Frequency-Hopping Spread Spectrum, transmits data bursts across rapidly changing carrier frequencies (1600 hops/sec in Bluetooth) following a PN sequence known to TX/RX, minimizing narrowband interference impact since each hop duration (~625μs) sees only fraction of total energy. Contrasts WiFi DSSS by occupying full channel briefly vs spreading chip sequence continuously, enabling multiple piconets sharing 2.4GHz ISM band with low mutual interference.

Key characteristics of FHSS include: Pseudo-Random Hop Sequence generated via LFSR across 79 x 1MHz channels (Bluetooth Classic); Fast Hop Rate 1600 hops/sec (400ms period/79 channels); Adaptive FHSS blacklists interfered channels; Short Dwell Time 625μs/classic slot limits jammer effectiveness; CDMA Capability multiple transmitters share band via unique hop patterns.

Conceptual example of FHSS usage:

/* Bluetooth Classic FHSS hop sequence generator */
#define NUM_CHANNELS 79
#define HOP_PERIOD   625  // microseconds

uint8_t hop_sequence[NUM_CHANNELS];
uint16_t clock;  // 12.5ms native + 625us slots
uint8_t current_channel;

void generate_bluetooth_hop_seq(uint16_t clk_28) {
    // Native clock → 5-bit channel select via permutation
    uint8_t page = (clk_28 >> 7) & 0x1F;  // Page hop bits
    uint8_t inquiry = (clk_28 >> 3) & 0x1F; // Inquiry bits
    
    current_channel = permute(page ^ inquiry ^ clk_28);
    set_rf_channel(current_channel);  // Synth tune 2402 + ch MHz
}

void transmit_slot() {
    // 625us dwell: transmit GFSK packet
    transmit_gfsk_packet(data_buffer, 366);  // 366us max
    delay_us(625);  // Slot time
    generate_bluetooth_hop_seq(++clock);  // Next hop
}

Conceptually, FHSS evades interference by transmitting brief packets across wide spectrum—Bluetooth piconets hop pseudorandomly while AFH detects/avoid busy channels, ensuring reliable PAN links amid WiFi 2.4GHz congestion. Military origins (Hedy Lamarr torpedo guidance) evolved to civilian WPANs where hop synchrony via master clock maintains TDD timing; contrasts SerDes fixed carriers requiring CTLE equalization, with spectrum analyzers revealing FHSS as impulsive wideband noise versus OFDM comb lines.