Digital Signal Processing (DSP) From Ground Up™ in C

Explore gnuplot basics and learn to plot multiple signals in one window with a C IDE, customize line colors, grid, autoscale, and styles such as lines, impulses, and dots.

Learn to plot multiple signals in a single window using gnuplot, set up four quadrants, assign origins, and plot input, real, and imaginary parts with color-coded lines.

Define signal as a relationship between parameters and distinguish continuous from discrete signals. Explain ADC digitization, independent and dependent variables, and how samples form the digitized signal.

Compute the signal mean by averaging all samples. Understand the standard deviation as the measure of fluctuation from the mean, with variance representing the power of that fluctuation.

Develop a mean of a signal in C by implementing a function that sums a double input array and divides by its length, 320.

Compute the mean of a signal in c by using a function prototype, passing the signal array and its length, and printing the resulting double value.

Develop a variance algorithm for a signal in c by computing the mean, summing squared deviations with pow, and dividing by length. The lesson covers project setup and debugging.

Develop the standard deviation algorithm by implementing a double function that takes signal variance and returns the standard deviation via its square root in the signal variants project in C.

Explore the sampling theorem and Nyquist criterion, detailing quantization, sample-and-hold, ADC, and reconstruction with anti-aliasing and reconstruction filters.

Explore passive RC low-pass filters that pass low frequencies and attenuate high ones, and learn fc = 1/(2 pi RC) and the capacitor’s shorting action at high frequencies.

Explore how the passive high-pass RC filter passes high frequencies while blocking low ones, using a cutoff 1/(2πRC). Compare ideal vs practical filters and brick-wall behavior.

Compare active and passive filters, highlighting gain from operational amplifiers in active designs. Describe the common configurations—the Shepshed, Butterworth, and modified silent key filter—shaped by k one and k two.

Compare the frequency responses of Chebyshev, Butterworth, and Bessel filters, noting passband ripples, stop-band behavior, and step-response trade-offs across different poles.

Learn how linear systems map input signals to output signals, recognize time-domain and frequency-domain representations, and explore how information is encoded in sine waves and waveform shapes.

Explore superposition in linear systems, where the response to a sum of inputs equals the sum of individual responses, and learn decomposition and synthesis using the additive property.

Explore impulse and step decomposition by breaking a signal into impulse and step components, enabling sample-by-sample examination and allowing a system's output to be calculated from an impulse.

Define convolution as a math operation that combines an input signal and an impulse response to yield output. Represent impulse responses as shifted and scaled delta functions, i.e., the filter kernel or PSF.

Explore the convolution operation, using a low pass filter example, by combining an input signal with an impulse response to produce an output, illustrating length and the commutative property.

Demonstrates the commutative property of convolution and how each input sample contributes a scaled and shifted impulse response to synthesize the final output sample, illustrated at sample six.

Explore the convolution sum equation for discrete signals, combining input x(n) and impulse response h(n) to produce output y(n). Learn how output samples are computed with indices i and j.

Explore how the impulse response defines a linear system and guides digital low-pass filter design, with the delta function as the convolution identity enabling amplification, attenuation, and delays.

Develop a convolution algorithm by applying a 29-element impulse response to an input signal, producing a low-pass output that preserves 1 kHz and attenuates 15 kHz.

Develop and implement the convolution algorithm, plot input signal and impulse response, and explore the DFT-based visualization with MATLAB, highlighting a 6 kilohertz low-pass filter.

Develop and test a five-argument convolution function in C, initializing the destination, and compute the convolution sum with nested loops using input signal and impulse response.

Develop the convolution algorithm (part iv) to apply an impulse response to an input signal and produce a filtered output. Implement a low-pass filter with arrays and simple plotting.

Explore the first difference and running sum as discrete analogues of differentiation and integration for signals, and convolution's role in recursive difference equations for infinite impulse response filters in C.

Develop the running sum algorithm in C to compute a signal's running sum with input and output arrays. Use this simple filter to smooth signals and enable peak detection.

Explore how Fourier analysis decomposes signals into sine and cosine components, focusing on the discrete Fourier transform for discrete signals, and the four signal categories with real and complex versions.

Explore the discrete Fourier transform by converting a time-domain input into frequency-domain outputs, where the DFT engine yields cosine (real) and sine (imaginary) amplitudes.

Understand forward and inverse DFT, including analysis and synthesis, and how time signals transform into frequency representations. Review x-axis options: 0 to n/2, 0 to 0.5 Fs, 0 to pi.

Develop and implement a discrete Fourier transform algorithm in C, building a console project from scratch, initialize inputs, and compute real and imaginary frequency components.

Develop the discrete Fourier transform in C by implementing a DFT function, handling input and output signals, iterating over data, and writing results to files for plotting.

Develops the DFT algorithm by guiding you through plotting input signals, setting origins and colors, and comparing time-domain and frequency-domain representations in a C DSP project.

Develop the inverse DFT algorithm (part i) by converting frequency-domain real and imaginary parts back to the time-domain signal, and validate it with a new idft function.

Develop the inverse dft algorithm in c by implementing idft with nested loops, initializing the output array, and computing the real and imaginary parts using cosine and sine terms.

Develop and validate the inverse DFT algorithm by plotting time-domain inputs and frequency-domain real and imaginary parts, then compare the IDFT output with the forward DFT results to verify consistency.

Compute the discrete Fourier transform of a 640-point ECG signal in MATLAB, then apply the inverse DFT to verify the original waveform and analyze the magnitude spectrum.

Compute the DFT and IDFT of an ECG signal, plot the time and frequency domains, and verify reconstruction by feeding the real and imaginary parts through the inverse transform.

Compute the DFT magnitude from real and imaginary parts to identify the signal’s frequency components, revealing 1 kHz and 15 kHz under a 48 kHz sampling rate.

Explore the duality between time and frequency domains in dsp, where a single frequency point yields a time-domain sinusoid and convolution and multiplication swap across domains.

Learn how to convert rectangular and polar notations in the frequency domain, compute magnitude and phase, and decide when rectangular or polar notation is best for computation or communication.

Convert a complex time-domain signal from rectangular notation to polar notation in a C project, computing magnitude and phase from real and imaginary parts while handling anomalies.

Learn to convert a signal from rectangular to polar notation in C by computing magnitude and phase. Implement a function prototype and validate results with plotting and debugging.

Explore complex numbers as an extension of ordinary math, representing two parts as a single quantity on the complex plane with real and imaginary parts, enabling fft in dsp.

Represent complex numbers in polar notation and convert between rectangular form using magnitude and phase angle. Compute real and imaginary parts as M cos theta and M sin theta.

Explore Euler's relation e^{j x} = cos x + j sin x and its forms used in digital signal processing, with multiplication adding angles and division subtracting exponents.

Discover how complex numbers simplify representing sinusoids in DSP, showing sinusoids as a cos(omega t) + b sin(omega t) and as a polar form M cos(omega t + phi).

Represent linear systems using complex numbers, converting input signals and outputs between complex notation and rectangular form.

Learn how real DFT extends to complex numbers, decomposing a time-domain signal into cosine and sine components with amplitudes in X(K) and iX(K) via forward transform to the frequency domain.

Discover how sine and cosine waves can be written in complex form using Euler's notation, expressing cos and sin as sums of positive and negative exponentials.

Explains the complex dft equation in polar notation for the time-domain x(n) and the frequency-domain X(k), rewrites it in rectangular form with Euler's relation, and compares to the real dft.

Compare real and complex DFT representations: real DFT maps a real time-domain signal to two real frequency components. Complex DFT uses both positive and negative frequencies, unlike real DFT.

Develops the complex discrete Fourier transform equation (part i) to handle time-domain signals with real and imaginary parts in C, extending the real-valued DFT in C.

Develop and test a complex dft implementation in C by wiring inputs, handling data types, and computing the dft while visualizing time-domain and frequency-domain outputs.

Explore how the fast Fourier transform decomposes a time-domain signal into single-point components, computes frequency spectra, and synthesizes them into a single spectrum, with bit reversal and interlaced decomposition.

Explain the endpoint complexity of the dft for a sequence of length n and show it requires 4n^2 multiplications and n(4n-2) additions, with the fft as a more efficient option.

Decompose an eight-point dft using the decimation-in-time fft, splitting into two four-point dfts by grouping even and odd samples and leveraging periodicity.