      ASN Filter Designer
DSP ANSI C v2.x SDK user’s guide




          July 2025
     ASN25-DOC003, Rev. 2
 Reference:                                         ASN25-DOC003                                          Rev      2


1. Overview

This document provides an overview of how to use the DSP ANSI C v2.x SDK with ASN Filter Designer v5.4.0 and
higher. A legacy document (ASN21-DOC012) is available for v1.x of the library, pertaining to ASN Filter Designer v5.3.5
and earlier versions.

The DSP ANSI C v2.x SDK provides significant improvements over v1.x, with strict data typing, improved memory
management, and support for single-sample and multi-sample modes — specifically designed to help Arm developers
implement reliable real-time embedded systems very easily.

Modes of operation:
1. multi-sample (MS) mode: highest speed – whereby 4 samples are computed in parallel. This method is
   approximately twice as fast as the single sample mode on most Arm processors with an HW FPU.
2. single-sample (SS) mode: good for real-time control applications, whereby single sample operation is required
   for minimising latency.

The SDK supports a variety of floating-point data types, including: complex double, complex float, float
and double precision.



         Fixed point arithmetic is currently not supported!



The content is as follows:
• Project folder structure generated from the ASN Filter Designer
• Filter cascade and non-linear functions
• Understanding main.c
• How to implement multiple filter cascades
• API description
• Setting up STM32 Cube IDE




Document Status:                                      for public release                                    Page: 2
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                           ASN25-DOC003                                       Rev     2


2. Project folder structure generated from the ASN Filter Designer

The ASN Filter Designer’s automatic code generator produces the following files and folders in the project folder:




ASN_DSP - This folder contains all the framework dependencies required to compile the filter code. The ASN Filter
Designer’s code generation wizard will automatically select the correct datatype, and produce the necessary
framework C files.

ASNFDConfig.c - This file contains API and filter structures of the designed filter(s).

ASNFDConfig.h – Associated header design file.

main.c - Contains example code to demonstrate the use of the SDK.

ASNFD.cbp –Code Blocks project file.

To use the filter code in your project, include the following folders and files in your project folder
ASN_DSP, ASNFDConfig.c, ASNFDConfig.c


Install Code Blocks or the MinGW compiler to quickly try the project.

The framework SDK files are arranged in the ANSI C directory, where SS pertains to single-sample mode and MS
pertains to multi-sample mode respectively.




Document Status:                                      for public release                                  Page: 3
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                         ASN25-DOC003                                                 Rev    2


3. Filter cascade and non-linear functions
In order to implement a complete application, the ASN Filter Designer uses a combination of filters and non-linear
functions, as described below in the architecture diagram. All blocks can be enabled or disabled from within the ASN
Filter Designer depending on the user's requirements.


                         Signal                            Input
                                                                                            x(n)
                        generator                          math()




              Hblw                      H1                               H2                             Heq


         BLW Tracker          FIR/IIR filter designed           FilterScript filter                 All-pass filter
                              via the filter designer                                                  cascade




                                                          Output
                                                                                           H3                    y(n)
                                                          math()

                                                        Math function                 Post filter

Depending on the application, we can enable or disable Input and Output math functions. These functions are helpful
for pre- or post-processing operations on the signal. The ASN Filter Designer supports the following math functions.
You can select one of them according to your application’s needs.


  Function ()                  Math operation                  Description
  None                                  -                      Disable the function block.
  Abs                          |𝑥| = √𝑎2 + 𝑏 2                 Absolute.
  Ln                                 𝑙𝑜𝑔𝑒 𝑥                    Natural logarithm.
                                           𝑏
  Angle                             𝑡𝑎𝑛−1 ( )                  Compute the arctangent (phase in radians).
                                           𝑎
                                    √𝑎2 + 𝑏 2
  RMS                                                          Root mean square.
                                       √2
  Sqr                                  𝑥2                      Square.
  Sqrt                                 √𝑥                      Square root.
  TKEO               𝑦(𝑛) = 𝑥 2 (𝑛 − 1) − 𝑥(𝑛)(𝑥 − 2)          TKEO (Teager-Kaiser energy operator) algorithm.




Document Status:                                      for public release                                          Page: 4
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                           ASN25-DOC003                                            Rev         2

3.1. Hblw filter

The Hblw filter (BLW tracker) precedes the H1 primary filter and is primarily intended for BLW (baseline wander)
suppression or tracking. The BLW tracker uses a linear phase Kolmogorov-Zurbenko filter cascade to implement either
a tracking (LPF) or removal (HPF) filter cascade. This filter is ideal for designing a variety of low-frequency filters,
such as biomedical BLW removal highpass filters for ECG and predictive maintenance applications, and lowpass DC
tracking filters for DC loadcell applications.


3.2. H1 filter

The H1 filter is the primary filter. It supports the design of standard prototype methods, such as Butterworth,
Chebyshev for IIR filters, and Parks-McClellan, Kaiser for FIR filters using the UI within the tool. The H1 filter may also
be fine-tuned via the pole-zero editor and even programmed with an exotic filter via ASN FilterScript.


3.3. H2 filter

The H2 filter block implements a single-section IIR/FIR floating point filter. This filter is available for performing
experiments with the P-Z editor or the ASN FilterScript scripting language. The FilterScript language is primarily
intended as a sandbox concept, allowing for the design and experimentation of transfer functions with symbolic
mathematical expressions.

         The Hblw, H1 and H2 filters may be fully programmed using ASN FilterScript.



3.4. H3 filter

Unlike the Hblw, H1 and H2 filters, the H3 filter is always lowpass and is preceded by an optional mathematical
function operation (i.e., Abs, Angle, Ln, RMS, Sqr or Sqrt, and TKEO).

H3 supports the following four types of filters:


          Type                       Transfer function                            Gain at DC                        Order

                                          1 + 2𝑧 −1 + 𝑧 −2                      1 + 2𝛼 + 𝛼 2
           IIR               𝐻3 (𝑧) =                                                                                2
                                        1 + 2𝛼𝑧 −1 + 𝛼 2 𝑧 −2                        4

                                                                                     1
   Moving Average           𝐻3 (𝑧) = 1 + 𝑧 −1 + 𝑧 −2 … + 𝑧 −𝑀                                                       1-200
                                                                                  (𝑀 + 1)

     Feed through                        𝐻3 (𝑧) = 1                                    1                              -

        Median                          data window                                    -                            3-195




Document Status:                                      for public release                                       Page: 5
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                           ASN25-DOC003                                       Rev     2


4. Understanding main.c

ASN Filter Designer’s code generator will automatically generate a C project for CodeBlocks using the requested
quantisation (i.e. float, double or complex). The C code is ANSI C compliant and is not processor-specific, so it can
be used agnostically on a variety of hardware platforms.
      Careful design has been undertaken to ensure that the complexities of the filtering operations are hidden from
the developer. Main.c will differ depending on which mode (single or multi) has been selected. You may also define
multiple filter cascade instances, as discussed in section 5.


4.1. multi-sample mode




As seen, the automatically generated code initialises the filter cascade via the ASNFD object and the
initFilterCascade() function. A test sinusoid is then defined (10Hz in this case) and assigned to the
InputValues array. FilterCascadeData() is then called on this test data in order to perform the filtering
operation. In order to achieve high implementation efficiency on Arm Cortex-M processors, 4 samples are computed
in parallel. Therefore, TEST_LENGTH_SAMPLES must be a multiple of 4 samples, where a good default value is 128
or 256.

An optional reset command ResetCascade(&ASNFD) may be called to reset the filter cascade by setting the
contents of the delaylines of all filters to zero.



        Calling this function will not affect the filter coefficients.




Document Status:                                      for public release                                  Page: 6
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                      ASN25-DOC003                                   Rev    2

4.2. single-sample mode




As seen, the automatically generated code initialises the filter cascade via the ASNFD object and the
initFilterCascade() function. A test sinusoid is then defined (10Hz in this case) and assigned to the Input
variable. FilterCascadeData() is then called on Input on a sample-by-sample basis in order to perform the
filtering operation.

       This mode is approximately twice as slow as the multi-sample mode version on most Arm Cortex-M
       processors with a HW FPU!




Document Status:                                      for public release                         Page: 7
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
                  Reference:                                      ASN25-DOC003                                  Rev    2


                 5. Support for multiple filter cascades

                 If more than one filter cascade is required, you must define an extra object in both main.c and
                 ASNFilterConfig.c. For example, to implement two filter cascades, we can define the objects as: ASNFD and
                 ASNFD2


                 extern ASNFDDefinition_t ASNFD, ASNFD2;                 (main.c)
                          ASNFDDefinition_t ASNFD, ASNFD2;               (ASNFilterConfig.c)

                 You may then define each cascade’s configuration in ASNFilterConfig.c – see below for an example.
First cascade
Second cascade




                 Document Status:                                      for public release                        Page: 8
                 Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                      ASN25-DOC003              Rev    2


For single-sample mode, the code in main.c would be




Document Status:                                      for public release    Page: 9
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                               ASN25-DOC003                                Rev     2


6. API description
A detailed overview of the ASN-DSP library’s API for both the single-sample and multi-sample mode of operation is
now given.

The content is as follows:

1. Initialise filter structure to default values
2. Release or deallocate the memory blocks
3. Initialise the filters and non-linear functions
4. Filtering using the filter cascade
5. Resetting the filter cascade
6. Setting the configuration of the Hblw filter
7. Setting the filter coefficients of the H1 filter
8. Setting the filter coefficients of the H2 filter
9. Setting the filter coefficients of the Heq filter
10. Setting the configuration of the H3 filter



6.1. Initialise filter structure to default values

Data type               API prototype
float                   void InitASNFDDefinition(ASNFDDefinition_t* filterptr);
double                  void InitASNFDDefinition(ASNFDDefinition_t* filterptr);
complex float           void CMPLX_InitASNFDDefinition(CMPLX_ASNFDDefinition_t* filterptr);
complex double          void CMPLX_InitASNFDDefinition(CMPLX_ASNFDDefinition_t* filterptr);


Description
Initialises the filter structure to its default values.

Argument
filterptr: pointer to filter structure.


Example
InitASNFDDefinition(&ASNFD);




 Document Status:                                      for public release                              Page: 10
 Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                          ASN25-DOC003                          Rev    2

6.2. Release or deallocate the memory blocks

Data type              API prototype
float                  void DeinitASNFDDefinition(ASNFDDefinition_t* filterptr);
double                 void DeinitASNFDDefinition(ASNFDDefinition_t* filterptr);
complex float          void CMPLX_DeinitASNFDDefinition(CMPLX_ASNFDDefinition_t* filterptr);
complex double         void CMPLX_DeinitASNFDDefinition(CMPLX_ASNFDDefinition_t* filterptr);


Description
Release or deallocates the memory blocks utilised by the filter structure.

Argument
filterptr: Pointer to filter structure.


Example
DeinitASNFDDefinition(&ASNFD);




6.3. Initialise the filters and non-linear functions

Data type               API prototype
float                   void InitialiseCascade(ASNFDDefinition_t* filterptr);
double                  void InitialiseCascade(ASNFDDefinition_t* filterptr);
complex float           void CMPLX_InitialiseCascade(CMPLX_ASNFDDefinition_t* filterptr);
complex double          void CMPLX_InitialiseCascade(CMPLX_ASNFDDefinition_t* filterptr);


Description
Initialises the filters and non-linear functions according to the design specifications.

Argument
filterptr: Pointer to filter structure.


Example
InitialiseCascade(&ASNFD);




Document Status:                                      for public release                    Page: 11
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                         ASN25-DOC003                                          Rev    2

6.4. Filtering using the filter cascade

The library supports two modes of operation: single-sample and multi-sample mode. As such, the
FilterCascadeData() method handles input data either as an array of values (multi-sample mode) or as scalar
value (single sample mode), as described in the following two sub-sections.



6.4.1.      single-sample mode

Data type              API prototype
float                  float FilterCascadeData(ASNFDDefinition_t* filterptr, const float
                       Input);
double                 double FilterCascadeData(ASNFDDefinition_t* filterptr, const double
                       Input);
complex float          complex float FilterCascadeData(ASNFDDefinition_t* filterptr, const
                       complex float Input);
complex double         complex double FilterCascadeData(ASNFDDefinition_t* filterptr, const
                       complex double Input);


Description
Performs the filtering operation using the filter cascade on a sample-by-sample basis, and returns the result.

This method is approximately twice as slow as the multi-sample mode version on most Arm Cortex-M with HW FPU.
As such, it is recommended to use the multi-sample mode version for performance, and this version for real-time
applications where low latency is paramount.



Arguments
filterptr: Pointer to filter structure.
Input: scalar input sample value.


Example
Output=FilterCascadeData(&ASNFD,Input);




Document Status:                                      for public release                                   Page: 12
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                         ASN25-DOC003                                        Rev     2

6.4.2.      multi-sample mode

Data type              API prototype
float                  void FilterCascadeData(ASNFDDefinition_t* filterptr, float* Output,
                       const float* Input, const uint32_t FrameSize);
double                 void FilterCascadeData(ASNFDDefinition_t* filterptr, double* Output,
                       const double* Input, const uint32_t FrameSize);
complex float          void CMPLX_FilterCascadeData(ASNFDDefinition_t* filterptr, float*
                       Output, const float* Input, const uint32_t FrameSize);
complex double         void CMPLX_FilterCascadeData(ASNFDDefinition_t* filterptr, double*
                       Output, const double* Input, const uint32_t FrameSize,);


Description
Performs the filtering operation using the filter cascade.

This method is advocated by virtue of its compatibility with data buffers in embedded applications, whereby a block
of sampled data is written to one buffer by the DMA while the CPU simultaneously processes the previous block from
the other buffer. This technique, known as ping-pong buffering, ensures seamless switching between buffers, enabling
continuous data flow with minimal latency and improved processor efficiency—particularly in real-time signal
processing and sensor data acquisition tasks.

In order to achieve high implementation efficiency on Arm Cortex-M processors, 4 samples are computed in parallel.
Therefore, FrameSize must be a multiple of 4 samples, where a good default value is 128 or 256.

Arguments
filterptr: Pointer to filter structure.
FrameSize: Size of input buffer data.
Output: Pointer to an output buffer.
Input: Pointer to the input buffer.


Example
FilterCascadeData(&ASNFD,1024,Output,Input);




Document Status:                                      for public release                                 Page: 13
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                           ASN25-DOC003                                           Rev      2

6.5. Reset the filter cascade

Data type               API prototype
float                   void ResetCascade(ASNFDDefinition_t* filterptr);
double                  void ResetCascade(ASNFDDefinition_t* filterptr);
complex float           void CMPLX_ResetCascade(CMPLX_ASNFDDefinition_t* filterptr);
complex double          void CMPLX_ResetCascade(CMPLX_ASNFDDefinition_t* filterptr);


Description
Resets the filter cascade by setting the contents of the delaylines of all filters to zero.

The coefficients will remain unaffected. This does not need to be called in normal operation, but is included for the
cases where you want to quickly reset the complete filter cascade.

Argument
filterptr: Pointer to filter structure.


Example
ResetCascade(&ASNFD);




6.6. Set configuration of Hblw filter

Description
Sets the configuration of the BLW Tracker.

Since the BLW Tracker is implemented as a cascade of moving average (MA) filters with unity coefficients, it is not
necessary to explicitly define the filter coefficients. Therefore, only three parameters are required, as described below.

Arguments
BLWTrackerMode: Mode of operation: Removal (highpass), Tracking (lowpass).
BLWTrackerL: Length of MA filter.
BLWTrackerR: number of sections.


Examples
ASNFD.BLWTrackerMode = Removal; // Highpass filtering
ASNFD.BLWTrackerL = 357;
ASNFD.BLWTrackerR = 3;


ASNFD.BLWTrackerMode = Tracking; // Lowpass filtering
ASNFD.BLWTrackerL = 53;
ASNFD.BLWTrackerR = 2;




 Document Status:                                      for public release                                     Page: 14
 Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                       ASN25-DOC003                             Rev      2

6.7. Set filter coefficients of H1 filter

Data type                API prototype
float                    void setH1Numerator(ASNFDDefinition_t* filterptr,float* ptr,int
                         len);
                         void setH1Denominator(ASNFDDefinition_t* filterptr,float* ptr,int
                         len);
                         void setH1SOS(ASNFDDefinition_t* filterptr, float* h1sos);

double                   void setH1Numerator(ASNFDDefinition_t* filterptr, float* ptr, int
                         len);
                         void setH1Denominator(ASNFDDefinition_t* filterptr, float* ptr, int
                         len);
                         void setH1SOS(ASNFDDefinition_t* filterptr, float* h1sos);

complex float            void CMPLX_setH1Numerator(CMPLX_ASNFDDefinition_t* filterptr,
                         complex float* ptr,int len);
                         void CMPLX_setH1Denominator(CMPLX_ASNFDDefinition_t* filterptr,
                         complex float* ptr,int len);
                         void CMPLX_setH1SOS(CMPLX_ASNFDDefinition_t* filterptr,complex
                         float* h1sos);

complex double           void CMPLX_setH1Numerator(CMPLX_ASNFDDefinition_t* filterptr,
                         complex double* ptr, int len);
                         void CMPLX_setH1Denominator(CMPLX_ASNFDDefinition_t* filterptr,
                         complex double* ptr, int len);
                         void CMPLX_setH1SOS(CMPLX_ASNFDDefinition_t* filterptr,complex
                         double* h1sos);


Description
Sets the filter coefficients of the H1 filter.

Arguments
filterptr: pointer to filter structure.
ptr, h1sos: Pointer to the array.
len: length of the array.


Examples
float H1SOS[] = { 0.15919464484408, 0.15919464484408, 0.00000000000000,
0.68165454497010, 0.00000000000000},{ 0.04362563518631, 0.01333388307825,
0.04362563518631, 1.38973983422963,-0.49030168693325};

setH1SOS(&ASNFD, H1SOS);

float H1Numerator[] = { 0.98453370859690, -0.98453370859690,                  0.98453370859690, -
0.98453370859690};

setH1Numerator(&ASNFD,(float*) H1Numerator,4);

float H1Denominator[] = {-1.00000000000000,                  0.96906741719379, -0.92300230934793,
0.89445146398370};

setH1Denominator(&ASNFD,(float*) H1Denominator,4);

 Document Status:                                      for public release                   Page: 15
 Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                       ASN25-DOC003                     Rev    2

6.8. Set filter coefficients of H2 filter

Data type                API prototype
float                    void setH2Numerator(ASNFDDefinition_t* filterptr, float* ptr,int len);
                         void setH2Denominator(ASNFDDefinition_t* filterptr, float* ptr,int
                         len);
double                   void setH2Numerator(ASNFDDefinition_t* filterptr, double* ptr,int
                         len);
                         void setH2Denominator(ASNFDDefinition_t* filterptr, double* ptr,int
                         len);
complex float            void CMPLX_setH2Numerator(CMPLX_ASNFDDefinition_t* filterptr, complex
                         float* ptr,int len);
                         void CMPLX_setH2Denominator(CMPLX_ASNFDDefinition_t* filterptr,
                         complex float* ptr,int len);
complex double           void CMPLX_setH2Numerator(CMPLX_ASNFDDefinition_t* filterptr, complex
                         double* ptr,int len);
                         void CMPLX_setH2Denominator(CMPLX_ASNFDDefinition_t* filterptr,
                         complex double* ptr,int len);


Description
Sets the filter coefficients of the H2 filter.

Arguments
filterptr: Pointer to filter structure.
ptr: Pointer to the array.
len: Length of the array.



Example
float H2Numerator [] = {0.98453370859690, -0.98453370859690, 0.98453370859690, -
0.98453370859690};

setH2Numerator(&ASNFD,(float*) H2Numerator,4);

float H2Denominator [] = {-1.00000000000000, 0.96906741719379, -0.92300230934793,
0.89445146398370};

setH2Denominator(&ASNFD,(float*) H2Denominator,4);




 Document Status:                                      for public release           Page: 16
 Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                            ASN25-DOC003                  Rev    2

6.9. Set filter coefficients of Heq filter

Data type                API prototype
float                    void setHeqSOS(ASNFDDefinition_t* filterptr, float* heq);
double                   void setHeqSOS(ASNFDDefinition_t* filterptr, double* heq);
                         void CMPLX_setHeqSOS(CMPLX_ASNFDDefinition_t* filterptr, complex
complex float
                         float* heq);
                         void CMPLX_setHeqSOS(CMPLX_ASNFDDefinition_t* filterptr, complex
complex double
                         double* heq);


Description
Sets the filter coefficients of the all-pass equalisation filter (if enabled).

Arguments
filterptr: Pointer to filter structure.
heq: Pointer to the array.
len: Length of the array.



Example
float HeqSOS[]= {0.15919464484408, 0.15919464484408, 0.00000000000000,
0.68165454497010, 0.00000000000000},{ 0.04362563518631, 0.01333388307825,
0.04362563518631, 1.38973983422963,-0.49030168693325};

setHeqSOS(&ASNFD, HeqSOS);




 Document Status:                                      for public release             Page: 17
 Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                             ASN25-DOC003                          Rev      2

6.10. Set configuration of H3 filter

Data type                API prototype
float                    void setH3Numerator(ASNFDDefinition_t* filterptr, float* ptr, int
                         len);
                         void setH3Denominator(ASNFDDefinition_t* filterptr, float* ptr, int
                         len);

double                   void setH3Numerator(ASNFDDefinition_t* filterptr, double* ptr,int
                         len);
                         void setH3Denominator(ASNFDDefinition_t* filterptr, double* ptr, int
                         len);

complex float            void CMPLX_setH3Numerator(ASNFDDefinition_t* filterptr, complex float*
                         ptr, int len);
                         void CMPLX_setH3Denominator(ASNFDDefinition_t* filterptr, complex
                         float* ptr, int len);

complex double           void CMPLX_setH3Numerator(CMPLX_ASNFDDefinition_t* filterptr, complex
                         double* ptr, int len);
                         void CMPLX_setH3Denominator(CMPLX_ASNFDDefinition_t* filterptr,
                         complex double* ptr, int len);



Description
Sets the filter coefficients of the H3 filter (if enabled).

Arguments
filterptr: Pointer to filter structure.
ptr: Pointer to the array.
len: Length of the array.


Example
float H3Numerator[] = { 0.98453370859690, -0.98453370859690,                     0.98453370859690, -
0.98453370859690};

setH3Numerator(&ASNFD,(float*) H3Numerator,4);

float H3Denominator[] = {-1.00000000000000,                     0.96906741719379, -0.92300230934793,
0.89445146398370};

setH3Denominator(&ASNFD,(float*) H3Denominator,4);




 Document Status:                                      for public release                      Page: 18
 Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
 Reference:                                         ASN25-DOC003                                         Rev     2


7. STM32 Cube IDE and deploying to an STM32 Discovery kit
The STM32F469 Discovery kit is a very popular development platform for biomedical signal
processing applications. The onboard Arm Cortex-M4 based microcontroller is a very capable
processor, providing enough computational performance while maintaining low power and
cost with floating-point operations.

The following steps should be undertaken for integrating the deployed C code library into an
STM32CUBE-IDE project.

1. Generate the ANSI C filter project using ASN Filter Designer – see section 2.

    After generating the code, the working directory of the project should look like below.




2. Copy the ASN_DSP folder to your project folder.

3. Copy ASNFDConfig.c to the Src folder and ASNFDConfig.h file to the Inc folder.

4. Now open your project with STM32Cube-IDE, and go to Properties  C/C++ General  Paths & Symbols

5. Click on the “Add” button and enter the path of the ASN_DSP library folder.




                                                                                                Step 2: Click on “Add”




                                                                                               Step 3: Enter the path to
                                                                                               the folder

                                                                                               Step 4: Click on “OK”


    Step 1: Click on “paths and Symbols”


Document Status:                                      for public release                                  Page: 19
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
Reference:                                        ASN25-DOC003                          Rev    2


Document Revision Status


  Rev.                             Description                                Date

    1        Document released                                             20/06/2025

    2        Added STM32 Cube integration steps                            16/07/2025




Document Status:                                      for public release                 Page: 20
Copyright © 2025 Advanced Solutions Nederland. All rights reserved.
