[Intermediate] — the tooling, the applications that show DSP is everywhere, and the one hardware reality that separates textbook DSP from shipped DSP.
The kid version first
Everything in this folder is maths until you run it on real signals. In practice DSP is: load samples, transform, filter, measure, reconstruct — usually in a few lines of NumPy/SciPy for analysis, or in C on a tiny chip for real-time work. This note is where the concepts meet the keyboard, and where you see how many things you use every day are quietly DSP.
The tooling
For learning and analysis — Python:
import numpy as np
from scipy import signal, fft
import matplotlib.pyplot as plt
# the whole workflow in five lines
x = np.loadtxt("signal.csv") # samples
X = fft.rfft(x * signal.windows.hann(len(x))) # windowed spectrum
b, a = signal.butter(4, 0.2) # a 4th-order low-pass
y = signal.filtfilt(b, a, x) # zero-phase filtering
plt.specgram(x, Fs=fs) # a spectrogram, one callscipy.signal is the workhorse — filter design, convolution, spectrograms, resampling, all of it → the Python data stack. librosa for audio specifically (loading, mel-spectrograms, feature extraction). numpy.fft or scipy.fft for transforms. This is where you should learn DSP — instant feedback, plots, no hardware.
For real-time and embedded — C/C++:
- CMSIS-DSP — ARM’s optimised library for microcontrollers → embedded
- Vendor libraries for DSP chips (TI, Analog Devices)
- The maths is identical; the constraints (fixed-point, latency, memory) are the whole difficulty
For radio — GNU Radio + an RTL-SDR dongle → SDR. MATLAB/Octave remains common in academia and legacy signal-processing shops.
Fixed-point vs floating-point — the hardware reality
This is the single biggest gap between DSP-on-a-laptop and DSP-on-a-chip.
Your NumPy code uses floating-point — huge dynamic range, you never think about it. Cheap embedded DSP chips often have no floating-point unit, so they use fixed-point integer arithmetic, and that changes everything:
- You manage the decimal point yourself (Q-format: how many bits are the fractional part). Get the scaling wrong and values overflow or lose all precision
- Overflow wraps or saturates — a large intermediate result silently becomes garbage or clamps
- Coefficient quantisation destabilises filters — an IIR filter that’s perfectly stable in floating-point can have a pole pushed outside the unit circle when its coefficients are rounded to fixed-point, and then it oscillates or explodes. This is a real, shipped-product failure mode
Why bother with fixed-point: it’s faster, cheaper, and lower-power — critical for battery devices and high-volume chips. The craft of embedded DSP is largely making floating-point algorithms survive fixed-point, and it’s why “it worked in my simulation” is not the end of the job → data representation.
DSP is genuinely everywhere
The point of this note is to make the ubiquity concrete — you interact with DSP constantly:
Audio:
- Every noise-cancelling headphone runs adaptive filters in real time
- MP3/AAC compression transforms to a frequency domain and discards the inaudible → compression
- Voice assistants convert speech to mel-spectrograms before the ML model sees it
- EQ, autotune, reverb, and every audio effect is filtering and convolution
Images and video:
- JPEG is DSP — the DCT (a Fourier relative), quantise, discard imperceptible detail
- Blur, sharpen, edge-detect are 2-D convolution → graphics
Communications — every phone, Wi-Fi router, GPS receiver and satellite link is DSP modulating and demodulating → modulation.
Sensors and control — filtering noisy accelerometer/gyro data (a Kalman filter has DSP in it), extracting a heartbeat from a noisy ECG → state estimation, robotics.
Machine learning — the connection worth internalising:
- A CNN’s convolution layer is DSP convolution with learned kernels → computer vision
- Audio and speech models run on spectrograms, not raw waveforms — the DSP front-end is half the pipeline
- Data augmentation (pitch shift, time stretch, adding noise) is DSP
That so many fields reduce to “sample, transform, convolve, filter” is the reason DSP is a foundation, not a niche.
The practical workflow
How real signal work actually goes:
- Look at it — in both domains. Plot the time signal and its spectrum before doing anything. Half of all “bugs” are visible immediately (a DC offset, a mains hum spike, clipping, obvious aliasing)
- Check the sample rate and units. Most confusion is a mislabelled frequency axis or a wrong
fs→ sampling - Filter conservatively. It’s easy to filter out signal along with noise; compare before/after spectra
- Prototype in Python, then port. Get it right in floating-point NumPy where it’s easy to inspect, then deal with fixed-point and real-time constraints
- Validate against reality, like all of control theory — a filter that looks right in simulation must be checked on real recorded data with real noise
Key insight
DSP in practice is “sample, transform, filter, reconstruct” — a few lines of SciPy for analysis — and the one thing that separates it from textbook DSP is fixed-point arithmetic, where a filter that’s stable in floating-point can destabilise once its coefficients are quantised for a cheap chip. The reason to learn it despite the maths is ubiquity: audio, images, comms, sensors and even CNNs all reduce to the same handful of operations, so understanding convolution and the frequency domain pays off across an unusually wide span of the vault.
Related
- the DSP course
- computer vision — convolution, learned
- embedded systems — where fixed-point bites
- the Python data stack — NumPy/SciPy
Source: [reference] — Aug 2026.
Software engineering
Infrastructure & security
Computer science
Hardware & engineering