DSP From Ground Up™ on ARM Processors [UPDATED]

Demonstrates enabling the FPU on an ARM Cortex-M4, plotting a five-hertz signal with the debugger's logic analyzer, and preparing a UART-driven path to an external plotter.

Enable the floating point unit and plot an input signal on the internal logic analyzer by looping through samples with a pseudo delay and exposing a plot function.

Develop a bare metal uart driver to transmit data to an external plotter. Configure uart2 on pa2/pa3 as af7, enable apb1 and gpio clocks, and set baud rate.

Enable gpio a clock, set pa2 to alternate function mode, and assign af7 in the afrl0 for pa2, preparing the uart driver configuration.

Enable the UART clock via the APB1 enable register and compute the baud rate from the 16 MHz system clock. Enable transmitter and UART in CR1 to complete init.

Implement the uart transmit function by waiting for status register TXE bit (bit 7) using a bitwise and, then write 8-bit data masked with 0xf to the transmit data register.

Retarget printf to the UART driver on STM32, test the UART by transmitting to the COM port via USB, and validate with a serial program before plotting signals.

Plot five hertz signals using a uart driver and a serial plotter by printing samples, enabling float printing, and using the Arduino serial plotter for real-time visualization.

Learn to integrate the CMSIS-DSP library into a STM32 project by copying the DSP folder, adding the library, and configuring paths and symbols for Cortex-M4 and FPU.

Test and validate the CMSIS-DSP float32_t data type by building a signal with 1 kHz and 15 kHz components, plotting it, and preparing for a discrete Fourier transform demonstration.

Define a signal as the relation between parameters, explore signal statistics and noise, distinguish independent and dependent variables and samples, with continuous versus discrete signals from an adc.

Compute the signal mean by summing all samples and dividing by n, denoted mu. Then quantify fluctuations with the standard deviation sigma, whose square is the variance.

Develop and implement a C function to compute the mean of a signal by summing values and dividing by length, supporting DC removal and peak detection.

Compute the signal variance by implementing a function that takes the signal, its mean, and length, accumulates squared deviations with the power function, and returns the variance.

Develop and verify a standard deviation algorithm by implementing a variance-to-standard-deviation function, viewing results in debug, and comparing it with the CMS CSP library on an STM32 project.

Compute the standard deviation of a signal using the CMSIS-DSP standard deviation function, compare results with a hand-rolled version, and learn the input, length (block size), and result variable arguments.

Explore the sampling theorem and its role in converting continuous signals to discrete data, detailing quantization, sample-and-hold, anti-aliasing filters, Nyquist, and DAC reconstruction.

Explore how passive RC low-pass filters use a resistor and capacitor to pass low frequencies and block high ones, with cutoff frequency fc = 1/(2πRC) and a three db point.

Explore how a passive high-pass filter uses resistors and capacitors (RC) to pass high frequencies while blocking low ones, with cutoff given by 1/(2πRC). Contrast ideal brick-wall and practical filters.

Compare active and passive filters, explain gain from operational amplifiers in active low-pass configurations, and present the modified silent key filter as the building block for Butterworth and shabby shape.

Analyze the frequency and step responses of Chebyshev, Butterworth, and Bessel filters; more poles sharpen roll-off, Butterworth yields a flat passband, and Bessel offers the best step response.

Explore how Arm cortex-m dsp features—hardware floating point unit, simd, mac, and cms dsp library—enable real-time computation on digital signal controllers with Harvard architecture.

Define a system as a process that outputs a signal from an input, and outline time-domain and frequency-domain naming conventions plus linear-system properties: homogeneity, additive behavior, and shift in variance.

Explore superposition in linear systems by decomposing inputs into components and synthesizing them to reproduce the output, highlighting the additive property with x(n) = x1(n) + x2(n).

Explore impulse and step decomposition to analyze signals sample-by-sample. See how impulse decomposition isolates single non-zero samples and step decomposition highlights adjacent-sample differences to predict a system's response.

Explore convolution in digital filter design by linking input signals, impulse responses, and outputs, and learn how delta functions form unit impulses and kernels (psf).

Learn how the convolution operation, denoted by the star, combines input signals and impulse responses to produce outputs. Explore output length, decomposition and synthesis, and the commutative property with examples.

Explore how convolution combines input components with the impulse response, demonstrating the commutative property and how the output samples arise from synthesizing nonzero contributions, like at sample six.

Learn the convolution sum equation, computing each output sample independently from the input X(0..n-1) and impulse response H(0..m-1), with i selecting the sample and j iterating through the impulse response.

Plot the impulse response and input signal for a convolution, then implement the algorithm on ARM DSP using MATLAB to design a six kilohertz low-pass response that preserves 1 kHz.

Develop a convolution algorithm using input signal, impulse response, and an output buffer. Compute the output length as input length plus impulse response length minus one, then plot results.

Plot and analyze the convolution output by visualizing the input signal, impulse response, and output signal, exploring phase shifts, offsets, and CMS's DSP library comparison on ARM.

Apply CMSIS-DSP convolution with 32-bit floats to convolve an input signal and an impulse response, specifying lengths and an output buffer, then plot and compare results on the board.

Learn to measure dynamic performance by using the Cortex-M SysTick timer to time a DSP convolution, comparing CMS DSP against a custom implementation.

Measure the dynamic performance of CMSIS-DSP convolution using a cycle counter to capture before-and-after times, then convert cycles at 16 megahertz to seconds and milliseconds for comparison.

Compare the CMSIS-DSP convolution function with a custom version on STM32, measure cycles and time within the same project, and show CMSIS-DSP runs about 11.5 times faster.

Explore how the delta function acts as the identity in convolution for impulse responses. Learn how amplitude scaling yields amplification or attenuation and how shifts produce delays or advances.

Learn the discrete first difference and running sum for ARM processors. Compute y[n] = x[n] - x[n-1], the slope between adjacent samples, and the running sum accumulates all prior samples.

Implement the running sum algorithm on an input signal, storing results in an output array, and use it to reduce noise and clarify peaks in DSP.

Explore the discrete Fourier transform (DFT) by distinguishing continuous and discrete signals. Understand periodic and aperiodic cases and how Fourier transform and Fourier series apply.

Explore how the discrete Fourier transform converts a time-domain input signal into frequency-domain cosine and sine amplitudes, revealing real and imaginary components as normal numbers.

Explore forward and inverse dft, distinguishing analysis from synthesis, as time-domain signals become frequency-domain with labels 0 to N/2, 0 to 0.5 of the sampling rate, or 0 to pi.

Develop the discrete Fourier transform algorithm in C, computing real and imaginary parts and magnitude, and plot frequency components while noting fft motivation.

Analyze an ECG signal by applying the DFT to reveal its frequency components, then perform the inverse DFT to reconstruct the time-domain signal, with hands-on plotting and verification.

Develop the inverse discrete Fourier transform algorithm on ARM by implementing input handling for x and imx arrays, normalizing amplitudes, and producing an output buffer for the DFT engine.

Develop the inverse dft algorithm (part ii) by implementing the idft with nested loops, test on an eeg signal, and plot the original versus idft output using a serial plotter.

Configure the clock tree to reach 100 megahertz on the microcontroller by selecting the eight megahertz high speed external clock, enabling hsc, deriving the m, n, and p values, and setting apb1 and apb2 prescalers using cubeMx.

Outline steps to derive a 100 megahertz system clock by enabling the HSC oscillator, configuring prescalers, enabling the PLL, applying flash latency, and selecting the PLL as the clock source.

Enable the H.S. oscillator via the RCC control register, then wait for HSC ready bit. Configure the RCC configuration register to set the clock pre scalar and prescalers (APB1=2, APB2=1).

Configure the RCC PLL to generate 100 MHz by setting M, N, P, Q and selecting HSE; enable PLL, wait for ready, and switch the system clock to PLL.

Test the 100 mhz clock tree, observe peripheral clock effects on apb, and run inverse dft and dft to compare speed with 60 mhz using a plotter.

Learn to generate and test signals in MATLAB for embedded design, selecting sampling frequency and signal frequency, combining signals, performing convolution, and preparing code for deployment.

Generate three sine signals at 10, 100, and 500 Hz with a 2 kHz sampling rate, then combine and plot them to reveal three DFT spikes and a filter design.

Design a low-pass filter kernel in Matlab using fir1 with a 70 Hz cutoff at 2 kHz to clean a 10/100/500 Hz signal, then save as csv for microcontroller use.

Design a high-pass filter kernel in MATLAB with fir1 at 400 Hz and 2 kHz sampling, save the kernel, then convolve and plot input and output to verify high-pass behavior.

Compute the DFT of the original signal in MATLAB using FFT, obtain the one-sided magnitude spectrum, and identify the three frequency components at 10 Hz, 100 Hz, and 500 Hz.

Design FIR filters in MATLAB with the FDA Tool, selecting low-pass or high-pass types, setting passband and stopband, exporting coefficients and viewing magnitude and impulse responses.

Design a digital low pass filter on an embedded device using MATLAB kernels. Implement convolution with a 101-sample impulse response and a 70 hertz cutoff, verifying with ten hertz input.

Implement a 400 hertz high-pass filter on an embedded arm device, test via Matlab, adjust input and output lengths, and validate convolution with the impulse response for embedded validation.

Compare the embedded device's DFT results with MATLAB by running the DFT, computing magnitude, and plotting to validate identical spectra for a periodic signal.

implement a moving average filter on ARM processors to smooth noisy signals, reduce high-frequency noise, and explore 11-point and smaller configurations with a practical input-output function and plotting.