About CMSIS DSP
ARM Ltd have developed a range of optimized DSP functions for all of the Cortex MCU's.
I have found them a challenge to use in "baremetal" gcc based projects as they rely on
a particular directory structure and certain compiler directives. The project outlined
below tackles these difficulties and implements a real-time Finite Impulse Response FIR
filter on an STM32F303 Nucleo board. You can download the CMSIS libraries from https://github.com/ARM-software/CMSIS (download zip)
The program behaved as hoped - resulting in a very sharp cutoff at 1kHz.
The CMSIS library zip file was extracted and placed into a file system hierarchy as shown below. The project in this
article is in the 'fir' directory as shown. The relative placement of these directores is important and is reflected
in the variables used in the Makefile shown later.
The full Makefile is listed below followed by an explanation of the CCFLAGS and LIBSSPEC
# Specify the compiler to use
# Specify the assembler to use
# Specity the linker to use
CCFLAGS=-mcpu=cortex-m4 -mthumb -g -mfloat-abi=hard -fsingle-precision-constant -mfpu=fpv4-sp-d16 -I ../../CMSIS/CMSIS-master/CMSIS/Include -D ARM_MATH_CM4 -D __FPU_PRESENT=1
# Tell the linker where to find the libraries -> important: use thumb versions
LIBSPEC=-L /usr/local/gcc-arm-none-eabi/lib/gcc/arm-none-eabi/4.8.3/armv7-m -L../../CMSIS/CMSIS-master/CMSIS/Lib/GCC -larm_cortexM4lf_math
# List the object files involved in this project
OBJS= init.o \
# The default 'target' (output) is main.elf and it depends on the object files being there.
# These object files are linked together to create main.elf
main.elf : $(OBJS)
$(LD) $(OBJS) $(LIBSPEC) -lgcc -T linker_script.ld --cref -Map main.map -nostartfiles -o main.elf
# The object file main.o depends on main.c. main.c is compiled to make main.o
$(CC) -c $(CCFLAGS) main.c -o main.o
$(CC) -c $(CCFLAGS) init.c -o init.o
$(CC) -c $(CCFLAGS) serial.c -o serial.o
# if someone types in 'make clean' then remove all object files and executables
# associated wit this project
The compiler flags (CCFLAGS)
-mcpu=cortex-m4: The STM32F303 has an an ARM Cortex M4F core
-mthumb: generate Thumb rather than ARM machine code
-g: generate debugging information
-mfloat-abi=hard: generate code that uses hardware floating point
-mfpu=fpv4-sp-d16: this is the particular floating point unit in the 'F303
-fsingle-precision-constant: treat floating point constants as single precision
-D ARM_MATH_CM4: This is required by the CMSIS library - it causes particular sections to be included
-D __FPU_PRESENT=1: Tells CMSIS library that there is an FPU available
-I ../../CMSIS/CMSIS-master/CMSIS/Include: Header files for CMSIS are back up in these directories
The library specification (LIBSPEC)
-L /usr/local/gcc-arm-none-eabi/lib/gcc/arm-none-eabi/4.8.3/armv7-m: Tell the linker where to find libraries like gcc
-lgcc: (appears later in makefile) Include code from the gcc library e.g. long divide
-L../../CMSIS/CMSIS-master/CMSIS/Lib/GCC: Tell the linker where to find the CMSIS maths libraries
-larm_cortexM4lf_math: Include code from the CMSIS Cortex M4 library
This program implements an FIR filter. The ARM CMSIS code for FIR filters processes data
in blocks. The program must acquire a block of data, pass it to the FIR function, and then
output the resulting data. In a real-time application you can use double buffering with block data processing
to achieve continuous data flows. Data is acquired and output on a timed interrupt basis. At each
interrupt, data is inserted into an input buffer and read from an output buffer. When the input buffer
is full (and the output buffer is empty), the program switches to a different pair of input/output buffers
and passes the freshly acquired data to the data processing function. The next time the input buffer is full
these original buffers are swapped back and acquisition/output continues in this vein with more buffer swapping.
Two input buffers and two output buffers are used by this program. Each buffer holds 256 samples (some experimenting
should be done here to optimize this buffer size).
The SysTick timer is used to generates a 20kHz interrupt rate. During the interrupt service routine, the ADC is read
and the the DAC is written; a count is maintained and when the input buffer is full, the buffers are swapped. The example code
normalizes (on input) and denormalizes (on output). Strictly speaking this is not necessary and the values of 0 to 4095 from
the ADC could be passed to the filter function - indeed many would say that doing floating point in an interrupt service
routine is bad. Either way, the filter works fine although the SysTick ISR executes a lot faster without the (de)normaization.
The actual FIR function is carried out in the main loop. The SysTick interrupt service routine uses a shared global
variable (DataReady) to trigger the main loop into running the FIR function.
The code includes serial i/o functions for debugging and uses D13 (the LED) for performance measurement using an oscilloscope
The filter coefficients
Octave was used to generate the filter coefficients as follows:
pkg load signal;
The coefficients were written to a CSV file as follows:
The cutoff frequency (FcN) is expressed as a 'Normalized' value i.e. divied by the Nyquist frequency (sample rate divided by 2)
The filter order is 127 which requires 128 taps.
The contents of this file were then pasted into the declaration of the filter coefficients in the program code.
Get the code
You can download the progam code here. The CMSIS library should be downloaded from the github
Back to the STM32F303Nuclueo home page