Wireless

/ˌ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.

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

n. "Dynamic channel blacklist adaptation for FHSS systems avoiding interfered frequencies in real-time."

AFH, short for Adaptive Frequency Hopping, monitors channel quality during FHSS operation and removes "bad" channels from the hop sequence—Bluetooth masters classify 1/3 of 79 channels as unusable (PER>threshold) then broadcasts reduced map (20-79 channels) via baseband packet, forcing synchronized slaves to mirror avoidance. Essential for 2.4GHz ISM coexistence with WiFi, where fixed WLAN channels create interference islands amid pseudorandom hopping.

Key characteristics of AFH include: Channel Classification RSSI/PER monitoring tags channels "bad" (used/noisy) vs "good" (unused/clean); Map Exchange master broadcasts 10-octet channel map every connection event; Hop Remapping LFSR reseeds across reduced N_channels (20-79); AFH Disable backwards compatibility with legacy slaves; Channel Assessment RSSI histograms + packet error rate tracking.

Conceptual example of AFH usage:

/* Bluetooth AFH channel map exchange */
#define NUM_CHANNELS 79
#define BAD_CHANNEL_THRESHOLD 0x20  // PER > 32/128 pkts

uint8_t channel_map;  // 79 bits packed
uint8_t good_channels = 79;
uint16_t bad_channel_timer[NUM_CHANNELS];

void afh_channel_assessment(uint8_t ch) {
    if (packet_error_count[ch] > BAD_CHANNEL_THRESHOLD) {
        channel_map[ch/8] &= ~(1 << (ch%8));  // Mark bad
        good_channels--;
    }
}

void afh_map_update() {
    // Master → slave baseband packet every 32 slots
    l2cap_afh_packet(channel_map, good_channels);
    
    // Slave syncs map, reseeds hop selection kernel
    regenerate_hop_sequence(channel_map);
    
    // Clear assessment counters
    memset(bad_channel_timer, 0, sizeof(bad_channel_timer));
}

Conceptually, AFH transforms blind FHSS into interference-aware hopping—Bluetooth piconets probe packet error rates across 2.4GHz then collaboratively blacklist WiFi-occupied channels (1,6,11), shrinking hop table from 79→20 clean channels. Periodic map exchange maintains synchronization during TDMA slots; contrasts static WiFi channels by continuous adaptation, enabling robust PAN links where traditional FHSS fails amid spectrum congestion.

/ˌtiː diː ɛm ˈeɪ/

n. "Multiple access technique allocating time slots to users sharing single frequency channel unlike FDMA subcarriers."

TDMA, short for Time Division Multiple Access, divides shared radio channel into sequential time slots assigned to multiple stations, enabling simultaneous voice/data transmission across single carrier via precise synchronization—base station broadcasts frame timing while mobiles adjust transmit timing based on propagation delay. Classic 2G GSM uses 8-slot TDMA frames (4.615ms) with 200kHz carriers supporting 8 simultaneous calls, contrasting FHSS constant hopping by fixed-channel slotting within each hop.

Key characteristics of TDMA include: Fixed/Virtual Slot Allocation 8 slots/frame (GSM) or dynamic OFDMA RUs (WiFi 6); Frame Synchronization via beacon/reference burst aligning mobile clocks; Guard Periods prevent slot overlap from propagation/timing errors; Burst Transmission GMSK/8PSK packets fill 156.25 bits/slot; Timing Advance compensates round-trip delay (max 68 chips GSM).

Conceptual example of TDMA usage:

/* GSM TDMA frame structure - 8 slots x 4.615ms */
#define FRAME_MS     4.615
#define SLOT_MS      0.577
#define BITS_PER_SLOT 156
#define GUARD_BITS   8.25

typedef struct {
    uint8_t slot_id;     // 0-7
    uint16_t timing_advance;  // chips (0-63)
    uint8_t burst_type;  // Normal/Access/SCH
} tdma_slot;

void gsm_transmit_slot(tdma_slot *s) {
    // Timing advance: delay TX by 2 * propagation_distance/c
    delay_us(s->timing_advance * 3.69);  
    
    // Burst format: training sequence + data + tail bits
    rf_transmit_gmsk(
        tail_bits,
        training_seq,
        data[s->slot_id],
        tail_bits,
        guard_period
    );
    
    // Next slot @ 577us - slot_id wraps 0-7
}

Conceptually, TDMA arbitrates channel contention by time-slicing—base stations dictate frame timing while mobiles advance timing to align "in the air," enabling 8x voice capacity over analog AMPS. Modern LTE TDD combines TDMA principles with OFDMA subcarrier allocation; Bluetooth piconets use master-slave TDMA within FHSS hops, where guard times absorb T/R switching unlike continuous SerDes links requiring CTLE always-on.

/ˌtiː diː ˈdiː/

n. "Single-frequency duplexing alternating uplink/downlink time slots unlike FDD paired spectrum."

TDD, short for Time Division Duplexing, transmits uplink and downlink over identical frequency channel by partitioning time into alternating transmit/receive slots (e.g., Bluetooth 625μs master/slave slots), enabling bidirectional communication without separate bands. Contrasts FHSS constant hopping by fixed-channel TDD within each hop, with guard times preventing TX-to-RX bleed—powers asymmetric traffic like LTE TDD (3:1 DL:UL) and WiFi 6 OFDMA resource units.

Key characteristics of TDD include: Single Frequency shared UL/DL band halves spectrum needs vs FDD; Dynamic Slot Allocation adjusts UL:DL ratio (WiMAX 3:1→1:3); Guard Periods prevent TX/RX switching transients; Frame Synchronization master dictates slot timing; Asymmetric Efficiency suits web browsing (80% DL) unlike voice FDD.

Conceptual example of TDD usage:

/* Bluetooth Classic TDD master/slave slot timing */
#define SLOT_DURATION_US  625
#define GUARD_TIME_US     150  // TX→RX ramp

volatile uint32_t system_clock;
uint8_t is_master = 1;

void tdd_frame() {
    // Master TX slot
    if (is_master) {
        rf_transmit_gfsk(tx_packet, packet_len);
        delay_us(SLOT_DURATION_US - GUARD_TIME_US);
        rf_switch_to_rx();  // T/R switch
        delay_us(GUARD_TIME_US);
        
        // Slave RX→TX response
        if (rf_receive(rx_packet, &rx_len, 400)) {
            process_rx_packet();
        }
    } else {
        // Slave RX slot
        rf_switch_to_rx();
        if (rf_receive(rx_packet, &rx_len, 400)) {
            rf_transmit_gfsk(tx_packet, rx_len);
        }
    }
    
    system_clock += SLOT_DURATION_US;
}

Conceptually, TDD slices time axis into master TX/slave RX alternation on fixed carrier—Bluetooth piconets synchronize via master's clock while LTE eNodeB broadcasts SFN (System Frame Number) dictating dynamic UL:DL via RRC signaling. Guard periods absorb PA ramp/LO settling unlike FDD duplexers; WiFi 6 TDD OFDMA assigns RUs per slot serving IoT asymmetry where PAN sensors upload sparingly versus streaming DL.

/ˌɛ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.