Als je slechts geïnteresseerd bent in één specifieke frequentie, is het berekenen van een volledige Fast Fourier Transform (FFT) vaak “overkill”. Een FFT berekent namelijk de amplitude voor álle frequentie-bins tegelijk.

Voor een enkele frequentie kun je beter de Discrete Fourier Transform (DFT) formule direct toepassen voor die specifieke waarde, of de Goertzel-algoritme gebruiken als efficiëntie cruciaal is.

Hier is hoe je dit aanpakt in Python:

1. De directe methode (DFT)

De wiskundige kern van een Fourier-transformatie is het vermenigvuldigen van je signaal met een complexe sinusgolf van de doelfrequentie en daar het gemiddelde (of de som) van nemen.

X(f)=∑n=0N−1x[n]⋅e−j2πfn/fsX(f) = \sum_{n=0}^{N-1} x[n] \cdot e^{-j 2 \pi f n / f_s}X(f)=n=0∑N−1​x[n]⋅e−j2πfn/fs​

In Python ziet dat er zo uit:

Python

import numpy as np
def single_frequency_dft(signal, target_freq, fs):
n = np.arange(len(signal))
# De complexe exponentiële golf (draaiende vector)
fourier_basis = np.exp(-2j * np.pi * target_freq * n / fs)
# Puntproduct geeft de correlatie met die frequentie
result = np.dot(signal, fourier_basis)

amplitude = np.abs(result) * (2 / len(signal))
phase = np.angle(result)

return amplitude, phase

Voorbeeld data

fs = 1000  # Sample rate
t = np.linspace(0, 1, fs)
Signaal van 50Hz met wat ruis

signal = np.sin(2 * np.pi * 50 * t) + 0.5 * np.random.randn(len(t))
amp, phase = single_frequency_dft(signal, 50, fs)
print(f"Amplitude bij 50Hz: {amp:.4f}")

---

Waarom dit werkt

Stel je het signaal voor als een reeks vectoren. Door te vermenigvuldigen met e−jωte^{-j\omega t}e−jωt “ontrol” je het signaal rond de oorsprong. Alleen de component die exact op die frequentie zit, zal zich aan één kant van de grafiek ophopen, terwijl andere frequenties uitmiddelen naar nul.

---

2. Wanneer gebruik je wat?

Methode

Wanneer te gebruiken?

Voordeel

FFT (np.fft.fft)

Als je het hele spectrum wilt zien.

Razendsnel voor veel frequenties.

Directe DFT

Voor 1 tot ~10 specifieke frequenties.

Geen overhead, werkt op elke willekeurige frequentie (niet gebonden aan bins).

Goertzel

Voor real-time embedded systemen (bijv. DTMF detectie).

Extreem CPU-vriendelijk.

Let op de ‘Spectral Leakage’

Als je een frequentie kiest die niet precies in een “bin” valt van je signaallengte, kun je last krijgen van leakage. Het helpt vaak om een Window functie (zoals Hann of Hamming) over je signaal te leggen voordat je de berekening doet:

signal = signal * np.hanning(len(signal))

Zal ik je helpen om deze functie om te schrijven naar een versie die specifiek een reeks samples uit een real-time stream verwerkt?