ADAR1000 Phase Shifter Control for TX/RX Beamforming Patterns: Complete Implementation Guide

The ADAR1000 phase shifter control system uses SPI-based lookup tables (VM_I/VM_Q) to convert desired beam angles into per-channel phase codes, enabling electronic steering for both transmit and receive operations.

This repository implements a complete ADAR1000 phase shifter control solution for the AERIS-10 radar platform, providing precise electronic beam steering across four 4-channel ADAR1000 devices. The firmware architecture decouples high-level beamforming commands from low-level SPI register manipulation, allowing the radar to dynamically switch between TX and RX patterns while maintaining phase coherence.

Architecture Overview

The beamforming pipeline centers on the ADAR1000_Manager class, a C++ driver that abstracts the complexity of programming Analog Devices' beamformer chips. The manager handles:

• Phase lookup tables derived from datasheet specifications
• Angle-to-phase conversion using array geometry calculations
• TX/RX mode sequencing via integrated ADTR1107 RF switch control
• Custom pattern loading for arbitrary beam shapes

System Layers

Layer	Component	Responsibility
Hardware	4× ADAR1000 + ADTR1107	Physical phase shifting and RF path switching
Firmware	ADAR1000_Manager	SPI communication, phase computation, gain control
API	USB command interface	Bridge between GUI/Python and embedded driver
Application	Python GUI	User-facing beam angle and pattern controls

Phase Shifter Lookup Tables

The ADAR1000 encodes phase states as single bytes where the lower 5 bits store magnitude and bit 6 stores polarity. These values are pre-computed from the device datasheet and stored as constant arrays in [ADAR1000_Manager.cpp](https://github.com/NawfalMotii79/PLFM_RADAR/blob/main/9_Firmware/9_1_Microcontroller/9_1_1_C_Cpp_Libraries/ADAR1000_Manager.cpp):

// Lines 43-60: VM_I lookup table (128 phase states)
const uint8_t ADAR1000Manager::VM_I[128] = {
    0x27, 0x27, 0x27, 0x27, 0x26, 0x26, 0x26, 0x26,
    0x25, 0x25, 0x24, 0x24, 0x23, 0x23, 0x22, 0x21,
    // ... continues for all 128 entries
};

// Lines 62-79: VM_Q lookup table (128 phase states)
const uint8_t ADAR1000Manager::VM_Q[128] = {
    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
    0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
    // ... continues for all 128 entries
};

These tables enable 5.625° phase resolution (360°/64 states per quadrant), sufficient for precise beam steering at X-band frequencies.

Beam Angle to Phase Conversion

The setBeamAngle() method converts user-specified angles into device-specific phase configurations:

bool ADAR1000Manager::setBeamAngle(float angle_degrees, BeamDirection direction) {
    uint8_t phase_settings[4];
    calculatePhaseSettings(angle_degrees, phase_settings);
    
    // Apply phases and default VGA gains to each ADAR1000 device
    for (uint8_t dev = 0; dev < 4; ++dev) {
        for (uint8_t ch = 0; ch < 4; ++ch) {
            if (direction == BeamDirection::TX) {
                adarSetTxPhase(dev, ch + 1, phase_settings[dev], BROADCAST_OFF);
                adarSetTxAttenuation(dev, ch + 1, 0, BROADCAST_OFF); // 0 dB default
            } else {
                adarSetRxPhase(dev, ch + 1, phase_settings[dev], BROADCAST_OFF);
                adarSetRxAttenuation(dev, ch + 1, 0, BROADCAST_OFF);
            }
        }
    }
    loadSPIAll(); // Commit changes via SPI
    return true;
}

Phase Calculation Mathematics

The calculatePhaseSettings() helper implements standard array factor equations:

void ADAR1000Manager::calculatePhaseSettings(float angle_degrees, 
                                            uint8_t phase_settings[4]) {
    const float freq_hz = 10.5e9;           // X-band center frequency
    const float c = 3e8;                    // Speed of light
    const float wavelength = c / freq_hz;
    const float element_spacing = wavelength / 2;  // λ/2 spacing
    
    float angle_rad = angle_degrees * M_PI / 180.0;
    float phase_shift = (2 * M_PI * element_spacing * sin(angle_rad)) / wavelength;
    
    for (int i = 0; i < 4; ++i) {
        float element_phase = i * phase_shift;
        // Normalize to [0, 2π)
        while (element_phase < 0) element_phase += 2 * M_PI;
        while (element_phase >= 2 * M_PI) element_phase -= 2 * M_PI;
        // Convert to 0-127 index
        phase_settings[i] = static_cast<uint8_t>(
            (element_phase / (2 * M_PI)) * 128
        );
    }
}

TX/RX Mode Sequencing

ADAR1000 phase shifter control requires careful coordination with the ADTR1107 RF switch. The manager provides dedicated mode transition methods:

• setAllDevicesTXMode() — Configures ADTR1107 for transmit, disables RX path, enables TX bias
• setAllDevicesRXMode() — Configures ADTR1107 for receive, disables TX path, enables LNA bias

These ensure phase values are applied only when the RF path is correctly configured, preventing signal leakage and protecting sensitive receiver front-ends.

Custom Beam Pattern APIs

Beyond simple angle steering, the implementation supports arbitrary phase distributions for advanced beamforming.

4-Element Per-Device Pattern

// Set custom pattern for a single ADAR1000 device
bool ADAR1000Manager::setCustomBeamPattern(uint8_t device_id,
                                           const uint8_t phases[4],
                                           BeamDirection direction) {
    for (uint8_t ch = 0; ch < 4; ++ch) {
        if (direction == BeamDirection::TX)
            adarSetTxPhase(device_id, ch + 1, phases[ch], BROADCAST_OFF);
        else
            adarSetRxPhase(device_id, ch + 1, phases[ch], BROADCAST_OFF);
    }
    loadSPI(device_id);
    return true;
}

Full 16-Element Array Pattern

The setCustomBeamPattern16() method enables direct control of all antenna elements:

bool ADAR1000Manager::setCustomBeamPattern16(const uint8_t phase_pattern[16],
                                             BeamDirection direction) {
    for (uint8_t dev = 0; dev < 4; ++dev) {
        for (uint8_t ch = 0; ch < 4; ++ch) {
            uint8_t phase = phase_pattern[dev * 4 + ch];
            if (direction == BeamDirection::TX)
                adarSetTxPhase(dev, ch + 1, phase, BROADCAST_OFF);
            else
                adarSetRxPhase(dev, ch + 1, phase, BROADCAST_OFF);
        }
    }
    loadSPIAll();
    return true;
}

This API supports:

• Taylor distributions for sidelobe control
• Chebyshev weighting for uniform sidelobe levels
• Null placement for interference rejection
• Monopulse difference patterns for angle tracking

Beam Sweeping Engine

The manager includes an automated sweep capability for sector scanning:

// Configure and start automated beam steering
void ADAR1000Manager::setBeamSequence(const std::vector<float>& angles,
                                      BeamDirection direction);
bool ADAR1000Manager::startBeamSweeping();
void ADAR1000Manager::updateBeamPosition();  // Called from timer interrupt

The sweep engine advances through pre-computed angles without requiring host intervention, minimizing latency between beam positions.

Key Source Files

File	Purpose	Link
ADAR1000_Manager.cpp	Complete driver implementation with SPI commands, lookup tables, and beamforming logic	View source
ADAR1000_Manager.h	Class definition, BeamDirection enum, and public method declarations	View source
adar1000_vm_reference.py	Datasheet-derived reference tables for validation testing	View source
test_cross_layer_contract.py	Contract tests verifying firmware behavior matches Python reference	View source
workers.py	Python GUI worker thread calling manager APIs via USB	View source

Summary

• The ADAR1000_Manager class provides complete ADAR1000 phase shifter control for TX/RX beamforming patterns in the AERIS-10 radar
• Lookup tables (VM_I/VM_Q) encode 128 phase states per the ADAR1000 datasheet, enabling 5.625° resolution
• setBeamAngle() converts steering angles to per-device phase codes using λ/2 array geometry
• setCustomBeamPattern16() supports arbitrary 16-element phase distributions for advanced beam shaping
• TX/RX mode switching is coordinated with the ADTR1107 RF switch to ensure proper signal path configuration
• Beam sweeping engine automates sector scanning without host CPU overhead

Frequently Asked Questions

How does the ADAR1000 phase resolution affect beam steering accuracy?

The ADAR1000 provides 5-bit phase control (32 states per quadrant, 128 total), yielding 5.625° quantization steps. For a 4-element array at 10.5 GHz with λ/2 spacing, this translates to approximately 0.4° angle quantization at broadside, increasing to ~1.2° at 60° scan angle. The calculatePhaseSettings() function rounds computed phases to the nearest available state.

What is the difference between setBeamAngle and setCustomBeamPattern?

setBeamAngle() computes progressive phase shifts automatically based on a single steering angle parameter, ideal for standard beam steering. setCustomBeamPattern() and setCustomBeamPattern16() accept explicit phase values for each element, enabling arbitrary amplitude and phase distributions independent of simple geometric steering—required for sidelobe tapering, null formation, or shaped beams.

How is TX/RX switching synchronized with phase shifter updates?

The manager calls setAllDevicesTXMode() or setAllDevicesRXMode() before applying phase updates to ensure the ADTR1107 switch state matches the intended operation. The SPI transactions for mode switching complete before loadSPIAll() commits phase values, preventing transient misconfigurations that could damage receiver front-ends or distort transmitted waveforms.

Can the ADAR1000 phase shifter control operate during chirp transmission?

Yes. The phase values are loaded via SPI and held in ADAR1000 internal registers. Once programmed, the phase state persists without continuous SPI traffic, allowing chirp generation and ADC sampling to proceed without interference. Fast beam switching requires only ~10 µs for SPI register updates, enabling sub-pulse beam agility when needed.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}