LABORATORIO DI ARCHITETTURE E PROGRAMMAZIONE DEI SISTEMI ELETTRONICI INDUSTRIALI

Transcription

1 LABORATORIO DI ARCHITETTURE E PROGRAMMAZIONE DEI SISTEMI ELETTRONICI INDUSTRIALI Laboratory Lesson 10: CMSIS DSP Library and Functions Final Assignment Prof. Luca Benini <luca.benini@unibo.it> Prof Davide Rossi <davide.rossi@unibo.it> Simone Benatti <simone.benatti@unibo.it> Victor Kartsch<victorjavier.kartsch@unibo.it>

2 Info & Communications

3 Recap LAB1: IDE & Debug LAB2: GPIO & Systick LAB3: Advanced Debug LAB4: EXTI LAB5: Timers LAB6: FLASH & DMA LAB7: USART LAB8: ADC LAB9: SPI LAB10: CMSIS DSP CMSIS DSP lib and signal processing

4 CMSIS DSP Library

5 CMSIS CMSIS: Cortex Microcontroller Software Interface Standard Vendor-independent hardware abstraction layer for ARM Cortex-M Simple software interfaces for ARM core for: Peripherals interfaces Real-time operating systems Middleware DSP functions

6 DSP Functions Abs, dot products, fixed point operations, Complex math PIDs, Sin, cos, tan, FIR,IIR, conv, LMS Matrix multiplication, inverse, Mean, RMS, variance,... Conversion fix to float, FFTs Provides fast development for basic math for DSP SPEEDUP code execution

7 Example 1: Dot product Dot product or inner product or scalar product One of the most used operations in all signal processing domains Many efficient HW/SW implementations Intuition Algebraic function a b = a n b n n=1 In our world vectors are ARRAYS!

8 Dot product implementation The MATH a b = a n b n n=1 The CODE static int n; for(n = 0 ; n<array_dimension ; n++) { product += a[n]*b[n]; } Problems: 1. Many ldr & str operations 2. Many multiplications and sums

9 Dot product with CMSIS DSP arm_dot_prod_f32(&srca_buf_f32, &srcb_buf_f32, MAX_BLOCKSIZE, &testoutput); Vector 1 Vector 2 Dimension Output In your sample code compare the 2 executions: nonarm_product( &srca_buf_f32,&srcb_buf_f32, &multoutput, MAX_BLOCKSIZE) vs arm_dot_prod_f32(&srca_buf_f32,&srcb_buf_f32, MAX_BLOCKSIZE, &testoutput); 1900 cycles 1000 cycles SPEEDUP x2!!

10 Example 2 : Digital Filters There are two main digital filters categories: FIR (Finite Impulse Response) IIR (Infinite Impulse Response) FIR pros: 1. can be designed with linear phase 2. simple to implement 3. good for finite precision math FIR cons: 1. FIR requires more memory and computation (more coefficients) 2. Bigger filters cause delays

11 FIR basics Filter formula Filter diagram y(n) = N 1 k=0 h k x(n k) N = filter order (aka number of coeffs.) h(k) = Coefficients (aka taps) y(n) x(n-k) = Input data

12 Calculate the coefficients Use the following Matlab script: % Define sampling frequency Fs = 1000; %1kHz % Define cutoff frequency Cutoff_freq = 40; % Calculate Nyquist frequency Nyq_frequency = Fs/2; Cutoff_norm = Cutoff_freq/Nyq_frequency; % FIR order order = 4; % Calculate taps (coefficients) FIR_coeff = fir1(order,cutoff_norm);

13 Simple example with 3 coefficients In this case we have: y n = h 0 x n + h 1 x n 1 + h 2 x(n 2) Coefficients Input data

14 FIR C Implementation float X[1000]; float Y[1000]; float h[n] = { , , }; int main() { float yn = 0; int i,k; const int N = 3; float x[n] = {0,0,0}; X[0] = 1; for(i=0; i<1000; i++) { for(k=0; k < N-1; k++) { x[n-k-1] = x[n-k-2]; //shift the data } x[0] = X[i]; // move input sample to buffer yn = 0; // clear output sample for(k=0; k < N; k++) { yn += h[k]*x[k]; // multiply and accumulate data with coefficients } } } Y[i] = yn; // move output sample to buffer

15 CMSIS DSP Implementation #define BLOCK_SIZE 32 #define NUM_TAPS 29 #define TEST_LENGTH_SAMPLES 320 uint32_t numblocks = TEST_LENGTH_SAMPLES/BLOCK_SIZE;... int main(void) {... /* Initialize input and output buffer pointers */ inputf32 = &testinput_f32_1khz_15khz[0]; outputf32 = &testoutput[0]; /* Call FIR init function to initialize the instance structure. */ arm_fir_init_f32(&s, NUM_TAPS, (float32_t *)&fircoeffs32[0], &firstatef32[0], blocksize); /* Call the FIR process function for every blocksize samples */ for(i=0; i < numblocks; i++) { arm_fir_f32(&s, inputf32 + (i * blocksize), outputf32 + (i * blocksize), blocksize); } }... Check the code implementation!

16 Optimization: going faster! You can tell your compiler to optimize the code when compiling, making the execution faster ( >50% faster). Optimization is not for dummies, use it only when you carefully debugged the code. some code that work without optimization may NOT work when you optimize, so pay attention! It is strongly compiler dependent (in our case GCC) We have several optimization flags (O0 O3). The most popular are: O0 No optimization. Direct correspondence between each line of code and the resulting machine instructions O2 Enables more optimizations. This mode turns on nearly all optimizations.

17 Optimization: going faster! To set an optimization level in your project: Project proprieties -> C/C++ Build -> Settings -> MCU GCC Compiler -> Optimization -> select optimization level If the code is well-written, optimization is more effective CMSIS functions are specifically wellwritten for our platform: they enable loop unrolling, MAC instructions and other DSP features of our Cortex M4 MCU

18 KCycles Performance: Dot product 2 1,5 1 0,5 NO CMSIS CMSIS DSP 0 Dot product -O0 Dot product -O2 NO CMSIS CMSIS DSP Dot product -O0 1,9 0,99 Dot product -O2 0,3 0,24

19 KCycles Performance: FIR filter NO CMSIS CMSIS DSP 0 FIR -O0 FIR -O2 NO CMSIS CMSIS DSP FIR -O FIR -O

20 Libraries and code organization

21 Functions: declaration Function prototype: function name (must be unique) type of input parameters (may be void) type of return variable (may be void) equivalent to variable declaration

22 Functions: implementation Function implementation: The actual code that is executed when the function is called The code is written only once, but it can be used several times with different input parameters

23 Functions: use Function use: the actual call to the function defines when the code is called during the execution of a program must provide the correct input parameters

24 Functions: libraries Local function: Delared and implemented in the current file Can be only called within that file Library function: Declared in separate header file (.h) and implemented in dedicated source file (.c) Can be used in any file that includes its header

25 Code organization Until now we have always put everything in the main file: OK for simple projects NOT OK for complex and large projects NOT OK for code sharing and re-use You can create your own libraries! Different files with collection of useful functions, for easy re-use Try to be organized: group functions in a logical way You have functions that compute mean, variance and min/max, and you want to put them in a features library how? Create file features.h in the./inc subdirectory of your project Put the functions prototypes in features.h Create file features.c in the./src subdirectory of your project Put the functions implementations in features.c In main: add #include functions.h and call your functions with the correct parameters.

26 Libraries and folders When dealing with multiple files and libraries you can use folders and sub-folders to organize them It is up to you, but some common practices are good to follow

27 Libraries and folders When dealing with multiple files and libraries you can use folders and sub-folders to organize them It is up to you, but some common practices are good to follow When you create a project you already have a starting folder structure: Main application files are in./inc and./src

28 Libraries and folders When dealing with multiple files and libraries you can use folders and sub-folders to organize them It is up to you, but some common practices are good to follow When you create a project you already have a starting folder structure: Main application files are in./inc and./src StdPeriph_Driver: library organized with inc and src sub-floders

29 Libraries and folders When dealing with multiple files and libraries you can use folders and sub-folders to organize them It is up to you, but some common practices are good to follow When you create a project you already have a starting folder structure: Main application files are in./inc and./src StdPeriph_Driver: library organized with inc and src sub-floders Utilities: library with a common folder for header and source files

30 Libraries and folders When dealing with multiple files and libraries you can use folders and sub-folders to organize them It is up to you, but some common practices are good to follow When you create a project you already have a starting folder structure: Main application files are in./inc and./src StdPeriph_Driver: library organized with inc and src sub-floders Utilities: library with a common folder for header and source files So what is the difference between putting a header file in./inc or./utilities or./stdperiph_driver/inc or creating a new (sub)directory? Nothing, but you must ensure that the compiler and linker know when to get those files!

31 Libraries: project settings If you add your files in the main src/inc folders everything will be ok but, if you create a new folder to organize your files, it will give you lots of errors! You have to add the new folders to the compiler and linker paths! Create the folder/files you want or copy them in the project s main folder If you copy files outside Eclipse, you have to refresh to see them You have to add any folder containing header files (.h) to the include paths You have to add any folder containing source files (.c) to the source paths If a folder contains both, add it in both paths Subfolders are usually ok, but you may have to check

32 Libraries: include paths You have to add any folder containing header files (.h) to the include paths: Project proprieties -> C/C++ Build -> Settings -> MCU GCC Compiler -> Includes -> add the desired folder in the Include paths panel You should use relative paths: If you copy or export the project it will work use project directory or workspace directory as reference copy from the folders already listed there

33 Libraries: source paths You have to add any folder containing source files (.c) to the source paths: Project proprieties -> C/C++ General -> Paths and Symbols -> Source Location (TAB) -> add the desired folder