Chapter 8
IQ Demodulation Theory

8.1 What is IQ Demodulation?

IQ (In-phase/Quadrature) demodulation is the core signal processing technique that allows us to extract both amplitude and phase information from a received signal. It's called "IQ" because we measure two components:

• I (In-phase): Component aligned with the transmitted signal
• Q (Quadrature): Component 90° out of phase with the transmitted signal

Together, these form a complex number that completely describes the signal's magnitude and phase at a specific frequency.

8.2 Mathematical Foundation

For a received signal s(t) and a reference frequency f, we calculate I and Q by mixing with sine and cosine:

After low-pass filtering to remove high-frequency components:

8.2.1 Why This Works

Consider a pure tone at frequency f with amplitude A and phase φ:

Mixing with cosine:

After low-pass filtering to remove the 2f term:

Similarly for Q:

Combining these:

Thus we've extracted both amplitude (scaled by 2) and phase!

8.3 Implementation in FCMD

The FCMD project implements IQ demodulation in IQDemodulator.kt:

class SingleToneDemodulator(
    private val frequency: Double,
    private val sampleRate: Int
) {
    private var phase = 0.0
    private val phaseIncrement = 2.0 * PI * frequency / sampleRate

    // IIR filter state
    private val filterAlpha = 0.01  // ~10 Hz cutoff
    private var iFiltered = 0.0
    private var qFiltered = 0.0

    fun analyze(samples: FloatArray): ToneAnalysis {
        for (sample in samples) {
            // Quadrature mixing
            val i = sample * cos(phase)
            val q = -sample * sin(phase)

            // IIR low-pass filter
            iFiltered = filterAlpha * i + (1.0 - filterAlpha) * iFiltered
            qFiltered = filterAlpha * q + (1.0 - filterAlpha) * qFiltered

            // Increment phase
            phase += phaseIncrement
            if (phase >= 2.0 * PI) phase -= 2.0 * PI
        }

        // Calculate amplitude and phase
        val amplitude = sqrt(iFiltered² + qFiltered²) * 2.0
        val phaseAngle = atan2(qFiltered, iFiltered)

        return ToneAnalysis(frequency, amplitude, phaseAngle,
                           iFiltered, qFiltered)
    }
}
    

8.3.1 Phase Tracking

The demodulator maintains a running phase that increments by phaseIncrement each sample. This is equivalent to generating cos(2πft) and sin(2πft) but more efficient than calling trigonometric functions every sample.

8.3.2 Low-Pass Filtering

The FCMD project uses a single-pole IIR filter rather than a moving average for computational efficiency:

With α = 0.01, the cutoff frequency is approximately:

This is fast enough to track targets moving past the coil while filtering out high-frequency noise.

8.4 Multi-Tone Processing

The FCMD project processes multiple frequencies simultaneously. For each audio buffer of 1920 samples, we run 24 separate IQ demodulators in parallel:

class IQDemodulator(
    private val sampleRate: Int,
    private val targetFrequencies: List
) {
    private val demodulators = targetFrequencies.map { freq ->
        SingleToneDemodulator(freq, sampleRate)
    }

    fun analyze(samples: FloatArray): List {
        return demodulators.map { demod ->
            demod.analyze(samples)
        }
    }
}
    

This parallel processing is efficient on modern multi-core CPUs and provides complete frequency response information every audio callback (23.2 Hz on typical hardware).

8.5 Frequency Selection Strategy

The FCMD project uses logarithmically-spaced frequencies from 1 kHz to 20 kHz:

Logarithmic spacing provides:

• More samples at low frequencies (better depth penetration)
• Adequate high-frequency coverage (surface detail)
• Even distribution on a log scale (how humans perceive frequency)

8.6 Performance Optimization

Several optimizations make real-time multi-tone IQ demodulation practical:

8.6.1 Incremental Phase Tracking

Rather than computing 2π × f × t / sampleRate each sample, we increment a phase accumulator. This replaces expensive multiplication with cheap addition.

8.6.2 Single-Pole IIR Filter

As discussed, IIR filters are dramatically more efficient than FIR equivalents for moderate rolloff requirements.

8.6.3 Delayed Amplitude Calculation

We only calculate sqrt(I² + Q²) once per buffer, not per sample. The IIR filter provides continuous update of I and Q, but amplitude/phase are only needed at the callback rate (23.2 Hz), not sample rate (44.1 kHz).

8.7 Advantages Over FFT

Why use IQ demodulation instead of FFT (Fast Fourier Transform)?

Aspect	IQ Demodulation	FFT
Frequency Selection	Arbitrary	Fixed bins (f_s / N)
Time Resolution	Every sample	Block-based (trade with frequency resolution)
Computational Cost	O(N × M) for M tones	O(N log N)
Memory	Minimal (2 floats/tone)	Full buffer required
Latency	IIR filter delay only	Full window length

For our application with relatively few tones (24) and desire for low latency, IQ demodulation is superior to FFT.

8.8 Practical Considerations

8.8.1 Phase Unwrapping

The atan2 function returns phase in the range [-π, +π]. When monitoring phase over time, sudden jumps from +π to -π can occur. For metal detection, we don't typically need to unwrap phase (track continuous rotation) because we're interested in phase differences between frequencies, not absolute phase evolution.

8.8.2 DC Bias

Audio hardware may introduce DC bias (non-zero mean). This appears as a strong component at 0 Hz but doesn't affect our 1-20 kHz tones. Ground balance (Chapter 10) effectively removes DC bias by subtracting the baseline I/Q vector.

8.8.3 Filter Transients

The IIR filter has a startup transient. With α = 0.01 and callback rate of 23.2 Hz, the time constant is:

This means full settling takes ~20 seconds. In practice, 95% settling occurs in 3τ ≈ 13 seconds, which is acceptable for startup delay.

8.10 Coherent Demodulation: Solving Clock Drift

8.10.1 The Clock Drift Problem

When using external USB audio hardware (common with modern smartphones lacking headphone jacks), a critical challenge emerges: clock drift between the phone's digital signal processor and the USB audio dongle's clock.

The root cause: The phone generates the TX signal at its sample clock rate, but the USB dongle captures the RX signal at a slightly different rate. These independent clocks inevitably drift.

8.10.2 Coherent Reference Solution

The solution is elegant: use the actual transmitted signal as the demodulation reference rather than a synthesized local oscillator.

8.10.3 Hardware Connection

The coherent demodulation architecture requires a simple Y-cable modification:

Connection	Signal	Purpose
L Out → TX Coil	Multi-tone transmit	Generate EM field
L Out → R In	TX reference (loopback)	Coherent phase reference
L In ← RX Coil	Received signal	Target response
R Out → Headphones	Audio feedback	Operator monitoring

8.10.4 Mathematical Implementation

The coherent demodulation algorithm processes both RX and TX_ref signals:

This complex multiplication rotates the RX signal by the conjugate of the reference, yielding the phase and amplitude relative to the actual transmitted signal.

8.10.5 Why This Works

Key insight: Both RX and TX_ref are captured by the same USB audio clock. Any frequency error affects both identically:

The clock error cancels completely in the subtraction, leaving only the phase shift caused by the metal target.

8.10.6 Implementation in FCMD

The coherent demodulation is implemented in IQDemodulatorDSP.kt:

override fun processStereo(
    leftChannel: FloatArray,   // RX signal
    rightChannel: FloatArray,  // TX reference
    sampleRate: Int
): Pair<FloatArray, FloatArray> {
    // Demodulate both channels with same local oscillator
    val rxAnalysis = demodulator.analyze(leftChannel)
    val refAnalysis = referenceDemodulator.analyze(rightChannel)

    // Compute coherent phase/amplitude
    val coherentAnalysis = rxAnalysis.mapIndexed { i, rx ->
        val ref = refAnalysis[i]
        if (ref.amplitude > 0.01) {
            // Complex multiplication: RX × conj(REF) / |ref|²
            val refMagSq = ref.inPhase² + ref.quadrature²
            val coherentI = (rx.inPhase * ref.inPhase +
                           rx.quadrature * ref.quadrature) / refMagSq
            val coherentQ = (rx.quadrature * ref.inPhase -
                           rx.inPhase * ref.quadrature) / refMagSq

            ToneAnalysis(
                frequency = rx.frequency,
                amplitude = sqrt(coherentI² + coherentQ²),
                phase = atan2(coherentQ, coherentI),
                inPhase = coherentI,
                quadrature = coherentQ
            )
        } else rx  // Fallback if no reference
    }

    // Continue with VDI calculation using coherent analysis
    ...
}
    

8.10.7 Benefits

• Zero phase drift: Clock errors cancel completely
• Stable at all frequencies: 20 kHz behaves identically to 1 kHz
• No tracking algorithms needed: Perfect lock by hardware design
• High confidence scores: Phase consistency >85-95% typical
• Reliable VDI: Stable discrimination even with cheap USB audio

8.10.8 Practical Considerations

8.10.9 Performance Comparison

Metric	Without Coherent	With Coherent
Phase stability (20 kHz)	±90° cycling	±2-5° stable
Confidence score	3-10%	85-95%
VDI stability	Random 0-99	Stable ±3 counts
Settling time	N/A (never settles)	10-20 seconds
Hardware cost	None	$3 Y-cable

8.11 Summary

IQ demodulation provides:

• Simultaneous amplitude and phase measurement at specific frequencies
• Low computational cost suitable for real-time processing on smartphones
• Flexible frequency selection (logarithmic spacing optimal for metal detection)
• Low latency (no block processing delay like FFT)
• Coherent demodulation with TX reference eliminates clock drift issues

The FCMD implementation achieves this with simple, efficient code that processes up to 24 frequencies in real-time with minimal CPU usage. The coherent demodulation architecture ensures stable, accurate phase measurements even with inexpensive USB audio hardware.

Chapter 9
Phase Analysis and VDI Discrimination

9.1 The VDI Concept

VDI (Visual Discrimination Indicator) is a numerical scale, typically 0-99, that classifies detected targets by their electromagnetic properties. It originated with White's Electronics in the 1990s and has become an industry standard.

The goal: map the complex electromagnetic signature (amplitude and phase at multiple frequencies) to a single number that correlates with target composition.

9.1.1 Traditional VDI Scales

VDI Range	Typical Targets
0-30	Ferrous: iron nails, bottle caps, steel
30-45	Low conductors: aluminum foil, small rings
45-65	Mid conductors: brass, zinc pennies, pull tabs
50-70	Gold range: gold jewelry (overlaps mid)
70-99	High conductors: copper, silver, large targets

9.2 Phase Slope Analysis

The FCMD project's VDI calculation is based primarily on phase slope across frequencies. This is more reliable than single-frequency phase because it reveals magnetic properties.

9.2.1 Why Phase Slope Works

Recall from Chapter 2 that ferrous metals have high magnetic permeability. This causes phase to shift dramatically with frequency. The phase slope is:

Measured in degrees per kHz.

The steep negative slope is a clear signature of ferrous material!

9.3 FCMD VDI Algorithm

The complete VDI calculation combines multiple factors:

fun calculateVDI(analysis: List): VDIResult {
    // 1. Calculate phase slope
    val phaseSlope = calculatePhaseSlope(analysis)

    // 2. Calculate conductivity index
    val conductivityIndex = calculateConductivityIndex(analysis)

    // 3. Measure phase consistency
    val phaseConsistency = calculatePhaseConsistency(analysis)

    // 4. Calculate raw VDI
    val rawVDI = if (phaseSlope < 0) {
        // Ferrous: use slope steepness
        val normalized = (phaseSlope / -10.0).coerceIn(0.0, 1.0)
        (30 * (1.0 - normalized)).toInt()
    } else {
        // Non-ferrous: use conductivity
        (30 + (conductivityIndex * 69)).toInt()
    }

    // 5. Adjust for signal strength
    val amplitude = analysis.map { it.amplitude }.average()
    val adjustment = when {
        amplitude > 0.5 -> 5   // Strong signal
        amplitude < 0.1 -> -5  // Weak signal
        else -> 0
    }

    val vdi = (rawVDI + adjustment).coerceIn(0, 99)

    // 6. Classify and return
    return VDIResult(
        vdi, confidence, targetType,
        phaseSlope, conductivityIndex, depthEstimate
    )
}
    

9.3.1 Conductivity Index

For non-ferrous metals, conductivity index separates aluminum from copper/silver:

High conductors maintain amplitude at high frequencies (skin depth still allows penetration). Low conductors attenuate rapidly.

9.3.2 Phase Consistency

Phase consistency measures how "clean" the target signal is:

A single solid target has consistent phase across frequencies. Multiple targets, junk, or heavy mineralization show poor consistency.

9.4 Confidence Scoring

Not all VDI readings are equally reliable. The FCMD project calculates confidence as:

Phase consistency is weighted more heavily because it's the best indicator of a single, solid target versus trash or multiple objects.

Confidence Range	Interpretation	Action
0.8 - 1.0	High: Clean single target	Trust VDI, worth digging
0.5 - 0.8	Medium: Decent signal	VDI probably accurate
0.3 - 0.5	Low: Noisy or multiple targets	VDI uncertain
0.0 - 0.3	Very Low: Junk or interference	Returns UNKNOWN type

9.5 Target Type Classification

Based on VDI and phase slope, targets are classified:

fun classifyTarget(vdi: Int, phaseSlope: Double,
                   consistency: Double): TargetType {
    if (consistency < 0.3) return TargetType.UNKNOWN

    return when {
        vdi <= 30 && phaseSlope < -3.0 -> TargetType.FERROUS
        vdi <= 45 -> TargetType.LOW_CONDUCTOR
        vdi >= 70 -> TargetType.HIGH_CONDUCTOR
        vdi in 50..70 -> TargetType.GOLD_RANGE
        vdi in 46..69 -> TargetType.MID_CONDUCTOR
        else -> TargetType.UNKNOWN
    }
}
    

9.6 Limitations and Challenges

9.6.1 Target Size Ambiguity

VDI cannot distinguish between composition and size. A small copper coin gives similar VDI to a large aluminum can, despite different materials. This is fundamental - we measure electromagnetic response, not material directly.

9.6.2 Orientation Effects

A coin flat vs. edge-on can show different VDI (±10 points). Phase measurements are somewhat less sensitive to orientation than amplitude, which is why we weight phase slope heavily.

9.6.3 The Gold/Trash Problem

Gold jewelry (VDI 50-70) overlaps with aluminum pull tabs (VDI 45-65). No single-frequency or even multi-frequency detector can perfectly separate these. This is why detectorists learn to dig "iffy" signals in goldfields.

9.7 Calibration and Learning

VDI scales benefit from calibration with known targets. The FCMD thresholds (30, 45, 65, 70) are starting points. You can refine them:

1. Collect a set of known targets (coins, jewelry, trash)
2. Measure each target's VDI multiple times
3. Build a histogram of VDI values per target type
4. Adjust thresholds to minimize overlap

Machine learning approaches (Chapter 14) can automatically learn optimal thresholds from labeled data.

9.8 Summary

Effective VDI discrimination requires:

• Multi-frequency analysis (phase slope reveals ferrous vs. non-ferrous)
• Conductivity index (separates copper from aluminum among non-ferrous)
• Phase consistency (distinguishes single targets from junk)
• Confidence scoring (helps user know when to trust the reading)

The FCMD algorithm achieves good discrimination with modest computational cost, suitable for real-time operation on smartphone hardware.

Chapter 10
Ground Balance Algorithms

10.1 The Ground Mineralization Problem

Ground minerals produce constant I/Q vectors that can overwhelm weak target signals. Ground balance algorithms measure and subtract this baseline, effectively "nulling out" the ground while preserving target signatures.

10.2 Four Ground Balance Modes

10.2.1 OFF Mode

No ground balance applied. Use in air tests or clean beach sand.

10.2.2 Manual Mode ("Pump and Set")

User pumps coil over ground 10 times while system captures I/Q baseline. This baseline is then subtracted from all subsequent readings.

10.2.3 Auto-Tracking Mode

Continuously adapts baseline using slow IIR filter (α = 0.0005). Freezes when strong target detected (amplitude > 0.3) to avoid nulling the target.

Time constant ~86 seconds, allowing gradual adaptation to ground changes.

10.2.4 Manual+Tracking Mode

Combines manual preset with auto-tracking for optimal performance in variable ground.

10.3 Vector Subtraction with Offset

Ground balance subtracts baseline I/Q vector from measured vector. User-adjustable offset (±50) rotates baseline by ±45° for fine-tuning:

// Apply offset rotation
val offsetRadians = (offset / 50.0) * (π/4)
val rotatedI = baseI * cos(offset) - baseQ * sin(offset)
val rotatedQ = baseI * sin(offset) + baseQ * cos(offset)

// Subtract
val newI = currentI - rotatedI
val newQ = currentQ - rotatedQ

// Recalculate amplitude/phase
val amplitude = sqrt(newI² + newQ²)
val phase = atan2(newQ, newI)
    

10.4 Freeze Detection

Critical feature: when amplitude exceeds threshold (0.3), stop tracking. Otherwise, auto-tracking will try to null out the target itself!

10.5 Summary

Ground balance is essential for real-world metal detection. The FCMD multi-mode approach provides flexibility for different soils and user skill levels.

Chapter 11
Depth Estimation Techniques

11.1 Why Depth Estimation is Hard

Signal strength ∝ 1/r³, but we don't know target size. A large shallow target looks identical to a small deep target. Depth estimation must account for this fundamental ambiguity.

11.2 Multi-Factor Approach

11.2.1 Signal Amplitude

11.2.2 Frequency Ratio (Skin Effect)

Deep targets attenuate high frequencies more → ratio > 1.5

11.2.3 Size Normalization from VDI

Use target type to estimate expected size:

• HIGH_CONDUCTOR (copper/silver): 1.5× (large)
• GOLD_RANGE: 1.0× (medium)
• LOW_CONDUCTOR (foil): 0.8× (small)

11.3 Category-Based Estimation

Rather than claiming "6.2 inches," FCMD returns honest categories:

• ●●●● SURFACE (0-2")
• ●●●○ SHALLOW (2-4")
• ●●○○ MEDIUM (4-6")
• ●○○○ DEEP (6-8")
• ○○○○ VERY_DEEP (8"+)

11.4 Expected Accuracy

With calibration: ±1 category (±2")
Without calibration: ±1-2 categories (±4")

11.5 Calibration Procedure

1. Bury test targets at known depths (2", 4", 6", 8")
2. Measure depth factor for each
3. Adjust thresholds in code
4. Repeat for different soil types

Appendix A: Mathematics Reference

A.1 Complex Numbers and Phasors

IQ demodulation represents signals as complex numbers:

A.2 Fourier Transform

Relationship between time and frequency domains:

A.3 Digital Filters

A.3.1 Single-Pole IIR

A.3.2 Moving Average FIR

A.4 Statistics

A.4.1 Standard Deviation

A.4.2 Confidence Intervals

For normally distributed measurements, 95% confidence interval:

Appendix B: Android Audio API Guide

B.1 AudioTrack Setup (Output)

audioTrack = AudioTrack.Builder()
    .setAudioAttributes(
        AudioAttributes.Builder()
            .setUsage(AudioAttributes.USAGE_MEDIA)
            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
            .build()
    )
    .setAudioFormat(
        AudioFormat.Builder()
            .setSampleRate(44100)
            .setChannelMask(AudioFormat.CHANNEL_OUT_STEREO)
            .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
            .build()
    )
    .setBufferSizeInBytes(minBufferSize)
    .setTransferMode(AudioTrack.MODE_STREAM)
    .build()
    

B.2 AudioRecord Setup (Input)

audioRecord = AudioRecord.Builder()
    .setAudioSource(MediaRecorder.AudioSource.MIC)
    .setAudioFormat(
        AudioFormat.Builder()
            .setSampleRate(44100)
            .setChannelMask(AudioFormat.CHANNEL_IN_MONO)
            .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
            .build()
    )
    .setBufferSizeInBytes(minBufferSize)
    .build()
    

B.3 Thread Priority

android.os.Process.setThreadPriority(
    android.os.Process.THREAD_PRIORITY_URGENT_AUDIO
)
    

B.4 Buffer Size Calculation

val minBufferSize = AudioTrack.getMinBufferSize(
    sampleRate,
    channelConfig,
    audioFormat
)

// Multiply by 1 for lowest latency
// Multiply by 2-4 for more stability
val actualBufferSize = minBufferSize * multiplier
    

B.5 Common Pitfalls

B.5.1 Buffer Underruns

If processing takes too long, audio stutters. Solution: increase buffer size or optimize processing.

B.5.2 Permission Requirements

<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
    

B.5.3 Sample Rate Support

Not all devices support all rates. Always check with getMinBufferSize() - if it returns ERROR, rate is unsupported.

Appendix C: FCMD Code Reference

C.1 Project Structure

FCMD/
├── AudioEngine.kt           - Audio I/O management
├── IQDemodulator.kt         - Core DSP processing
├── VDICalculator.kt         - Target discrimination
├── GroundBalanceManager.kt  - Ground balance algorithms
├── DepthEstimator.kt        - Depth estimation
├── MultiToneGenerator.kt    - Transmit signal generation
├── AudioToneGenerator.kt    - Audio feedback
└── MainActivity.kt          - UI and coordination
    

C.2 Key Classes

C.2.1 AudioEngine

Purpose: Manages AudioTrack and AudioRecord, handles playback and record loops.

Key Methods:

• start() - Initialize audio hardware
• stop() - Cleanup audio resources
• setFrequencyRange() - Configure TX frequencies
• setDspProcessor() - Attach signal processing

C.2.2 IQDemodulator

Purpose: Extract amplitude/phase from received signal at each frequency.

Key Methods:

• analyze(samples) - Process audio buffer
• reset() - Clear filter states

C.2.3 VDICalculator

Purpose: Calculate VDI and classify targets.

Key Methods:

• calculateVDI(analysis) - Main VDI calculation
• getTargetDescription() - Human-readable output

C.3 Data Flow

AudioRecord → FloatArray samples
    ↓
IQDemodulator.analyze(samples) → List<ToneAnalysis>
    ↓
GroundBalanceManager.applyGroundBalance() → balanced List<ToneAnalysis>
    ↓
VDICalculator.calculateVDI() → VDIResult
    ↓
DepthEstimator.estimateDepth() → VDIResult with DepthEstimate
    ↓
MainActivity callback → UI update
    

C.4 Performance Characteristics

Metric	Typical Value
Sample Rate	44,100 Hz
Buffer Size	1920 samples (device-dependent)
Callback Rate	23.2 Hz
Latency	43.5 ms
Update Rate	30 Hz (configurable, max ~23 Hz)
CPU Usage	15-25% single core

References and Bibliography

Foundational Physics

Metal Detection Theory

Digital Signal Processing

IQ Demodulation

Android Audio Programming

Embedded Real-Time Systems

Practical Metal Detecting

Open Source Projects and Resources

Online Resources and Tutorials

Standards and Specifications