STM32CubeL4 MCU Firmware Package

https://github.com/stmicroelectronics/stm32cubel4
Admin
STM32CubeL4 is a comprehensive embedded software platform from STMicroelectronics, providing...
Tokens:1,045,070
Snippets:12,496
Trust Score:9.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/DSP/PythonWrapper/README.md

Install necessary packages for running examples.

```bash
> pip install numpy
> pip install scipy
> pip install matplotlib
```

--------------------------------

### Start Kernel Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Shows the standard pattern for initializing the kernel and starting thread execution.

```c
int main (void) {

// System Initialization

SystemCoreClockUpdate();

// ...

if(osKernelGetState() == osKernelInactive) {

osKernelInitialize();

}

; // ... Start Threads

if (osKernelGetState() == osKernelReady) { // If kernel is ready to run...

osKernelStart(); // ... start thread execution

}

while(1); // only reached in case of error

}
```

--------------------------------

### FIR Filter Example Setup

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_fir_example_f32_8c-example.html

Includes necessary headers, defines test parameters, and declares input/output buffers for the FIR filter example.

```c
/* ----------------------------------------------------------------------
* Copyright (C) 2010-2012 ARM Limited. All rights reserved.
*
* $Date: 17. January 2013
* $Revision: V1.4.0
*
* Project: CMSIS DSP Library
* Title: arm_fir_example_f32.c
*
* Description: Example code demonstrating how an FIR filter can be used
* as a low pass filter.
*
* Target Processor: Cortex-M4/Cortex-M3
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* - Neither the name of ARM LIMITED nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* -------------------------------------------------------------------- */

/* ----------------------------------------------------------------------
** Include Files
** ------------------------------------------------------------------- */
#include "arm_math.h"
#include "math_helper.h"

/* ----------------------------------------------------------------------
** Macro Defines
** ------------------------------------------------------------------- */
#define TEST_LENGTH_SAMPLES 320
#define SNR_THRESHOLD_F32 140.0f
#define BLOCK_SIZE 32
#define NUM_TAPS 29

/* -------------------------------------------------------------------
* The input signal and reference output (computed with MATLAB)
* are defined externally in arm_fir_lpf_data.c.
* ------------------------------------------------------------------- */
extern float32_t testInput_f32_1kHz_15kHz[TEST_LENGTH_SAMPLES];
extern float32_t refOutput[TEST_LENGTH_SAMPLES];

/* -------------------------------------------------------------------
* Declare Test output buffer
* ------------------------------------------------------------------- */
static float32_t testOutput[TEST_LENGTH_SAMPLES];

/* -------------------------------------------------------------------
* Declare State buffer of size (numTaps + blockSize - 1)
* ------------------------------------------------------------------- */
```

--------------------------------

### Initialize and Start RTX Kernel

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS2/html/cre_rtx_proj.html

Example showing the sequence for initializing the kernel, configuring NVIC priority grouping, creating threads, and starting the RTX kernel.

```C
osKernelInitialize(); // initialize RTX

NVIC_SetPriorityGrouping (3); // setup priority grouping

tread_id = osThreadNew(tread_func, NULL, NULL); // create some threads

osKernelStart (); // start RTX kernel
```

--------------------------------

### Dot Product Example Setup

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_dotproduct_example_f32_8c-example.html

Initializes the necessary headers, defines the block size, and provides the input data buffers for the dot product calculation.

```c
#include <math.h>
#include "arm_math.h"

/* ----------------------------------------------------------------------
* Defines each of the tests performed
* ------------------------------------------------------------------- */
#define MAX_BLOCKSIZE 32
#define DELTA (0.000001f)

/* ----------------------------------------------------------------------
* Test input data for Floating point Dot Product example for 32-blockSize
* Generated by the MATLAB randn() function
* ------------------------------------------------------------------- */

/* ----------------------------------------------------------------------
** Test input data of srcA for blockSize 32
** ------------------------------------------------------------------- */
float32_t srcA_buf_f32[MAX_BLOCKSIZE] =
{
-0.4325648115282207, -1.6655843782380970, 0.1253323064748307,
0.2876764203585489, -1.1464713506814637, 1.1909154656429988,
1.1891642016521031, -0.0376332765933176, 0.3272923614086541,
0.1746391428209245, -0.1867085776814394, 0.7257905482933027,
-0.5883165430141887, 2.1831858181971011, -0.1363958830865957,
0.1139313135208096, 1.0667682113591888, 0.0592814605236053,
-0.0956484054836690, -0.8323494636500225, 0.2944108163926404,
-1.3361818579378040, 0.7143245518189522, 1.6235620644462707,
-0.6917757017022868, 0.8579966728282626, 1.2540014216025324,
-1.5937295764474768, -1.4409644319010200, 0.5711476236581780,
-0.3998855777153632, 0.6899973754643451
};
```

--------------------------------

### Flash Driver Setup and Usage Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__flash__interface__gr.html

Demonstrates initializing a flash device, performing a read operation, and managing power states using the CMSIS-RTOS2 framework.

```c
#include "Driver_Flash.h"

#include "cmsis_os2.h" // ARM::CMSIS:RTOS2:Keil RTX5

/* Flash driver instance */

extern ARM_DRIVER_FLASH Driver_Flash0;

static ARM_DRIVER_FLASH * flashDev = &Driver_Flash0;

/* CMSIS-RTOS2 Thread Id */

osThreadId_t Flash_Thread_Id;

/* Flash signal event */

void Flash_Callback(uint32_t event)
{

if (event & ARM_FLASH_EVENT_READY) {

/* The read/program/erase operation is completed */

osThreadFlagsSet(Flash_Thread_Id, 1U);

}

if (event & ARM_FLASH_EVENT_ERROR) {

/* The read/program/erase operation is completed with errors */

/* Call debugger or replace with custom error handling */

__breakpoint(0);

}

}

/* CMSIS-RTOS2 Thread */

void Flash_Thread (void *argument)
{

/* Query drivers capabilities */

const ARM_FLASH_CAPABILITIES capabilities = flashDev->GetCapabilities();

/* Initialize Flash device */

if (capabilities.event_ready) {

flashDev->Initialize (&Flash_Callback);

} else {

flashDev->Initialize (NULL);

}

/* Power-on Flash device */

flashDev->PowerControl (ARM_POWER_FULL);

/* Read data taking data_width into account */

uint8_t buf[256U];

flashDev->ReadData (0x1000U, buf, sizeof(buf)>>capabilities.data_width);

/* Wait operation to be completed */

if (capabilities.event_ready) {

osThreadFlagsWait (1U, osFlagsWaitAny, 100U);

} else {

osDelay(100U);

}

/* Switch off gracefully */

flashDev->PowerControl (ARM_POWER_OFF);

flashDev->Uninitialize ();

}
```

--------------------------------

### Full Generator Configuration Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Pack/html/pdsc_generators_pg.html

Demonstrates a complete generator setup including exe, eclipse, and web launcher configurations with specific arguments.

```xml
<generators>

<generator id = "MyGen">

<gpdsc name ="$P/RTE/MyGen/myGen.gpdsc"/>

<exe>

<command host = "win">MyGen.bat</command>

<command host = "linux">MyGen.script</command>

<argument>$P/RTE/MyGen/myGen.gpdsc</argument>

<argument host="linux" switch="--device=">#D</argument>

<argument host="win" switch="/device=">#D</argument>

</exe>

<eclipse plugin="com.mygen.plugin" class="com.mygen.plugin.generator.launcher" method="launch" >

<argument>#D</argument>

<argument>$P/RTE/MyGen/myGen.gpdsc</argument>

</eclipse >

<web url="http://mygen.com/mygen">

<argument switch="device">#D</argument>

<argument switch="gpdsc">$P/RTE/MyGen/myGen.gpdsc</argument>

</web>

</generator>

</generators>
```

--------------------------------

### Ethernet Interface Initialization Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__eth__interface__gr.html

Demonstrates the typical setup sequence for initializing Ethernet MAC and PHY drivers, including capability checking and MAC address configuration.

```c
extern ARM_DRIVER_ETH_MAC Driver_ETH_MAC0;

extern ARM_DRIVER_ETH_PHY Driver_ETH_PHY0;

static ARM_DRIVER_ETH_MAC *mac;

static ARM_DRIVER_ETH_PHY *phy;

static ARM_ETH_MAC_ADDR own_mac_address;

static ARM_ETH_MAC_CAPABILITIES capabilities;

void ethernet_mac_notify (uint32_t event) {

switch (event) {

:

}

}

void initialize_ethernet_interface (void) {

mac = &Driver_ETH_MAC0;

phy = &Driver_ETH_PHY0;

// Initialize Media Access Controller

capabilities = mac->GetCapabilities ();

mac->Initialize (ethernet_mac_notify);

mac->PowerControl (ARM_POWER_FULL);

if (capabilities.mac_address == 0) {

// populate own_mac_address with the address to use

mac->SetMacAddress(&own_mac_address);

}

else {

mac->GetMacAddress(&own_mac_address);

}

// Initialize Physical Media Interface
```

--------------------------------

### Variance Calculation Example Setup

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_variance_example_f32_8c-example.html

Includes necessary headers, defines block sizes, and declares input/output buffers for the variance calculation.

```c
#include <math.h>
#include "arm_math.h"

/* ----------------------------------------------------------------------
* Defines each of the tests performed
* ------------------------------------------------------------------- */

#define MAX_BLOCKSIZE 32
#define DELTA (0.000001f)

/* ----------------------------------------------------------------------
* Declare I/O buffers
* ------------------------------------------------------------------- */

float32_t wire1[MAX_BLOCKSIZE];
float32_t wire2[MAX_BLOCKSIZE];
float32_t wire3[MAX_BLOCKSIZE];

/* ----------------------------------------------------------------------
* Test input data for Floating point Variance example for 32-blockSize
* Generated by the MATLAB randn() function
* ------------------------------------------------------------------- */

float32_t testInput_f32[32] =
{
-0.432564811528221, -1.665584378238097, 0.125332306474831, 0.287676420358549,
-1.146471350681464, 1.190915465642999, 1.189164201652103, -0.037633276593318,
0.327292361408654, 0.174639142820925, -0.186708577681439, 0.725790548293303,
```

--------------------------------

### Adaptive Filter Convergence Example Setup

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_signal_converge_example_f32_8c-example.html

Initializes global definitions, FIR state buffers, and LMSNorm structures for the adaptive filter simulation.

```c
/* ----------------------------------------------------------------------

* Copyright (C) 2010-2012 ARM Limited. All rights reserved.

*

* $Date: 17. January 2013

* $Revision: V1.4.0

*

* Project: CMSIS DSP Library

* Title: arm_signal_converge_example_f32.c

*

* Description: Example code demonstrating convergence of an adaptive

* filter.

*

* Target Processor: Cortex-M4/Cortex-M3

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* - Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* - Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in

* the documentation and/or other materials provided with the

* distribution.

* - Neither the name of ARM LIMITED nor the names of its contributors

* may be used to endorse or promote products derived from this

* software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

* -------------------------------------------------------------------- */

#include "arm_math.h"

#include "math_helper.h"

/* ----------------------------------------------------------------------

** Global defines for the simulation

* ------------------------------------------------------------------- */

#define TEST_LENGTH_SAMPLES 1536

#define NUMTAPS 32

#define BLOCKSIZE 32

#define DELTA_ERROR 0.000001f

#define DELTA_COEFF 0.0001f

#define MU 0.5f

#define NUMFRAMES (TEST_LENGTH_SAMPLES / BLOCKSIZE)

/* ----------------------------------------------------------------------

* Declare FIR state buffers and structure

* ------------------------------------------------------------------- */

float32_t firStateF32[NUMTAPS + BLOCKSIZE];

arm_fir_instance_f32 LPF_instance;

/* ----------------------------------------------------------------------

* Declare LMSNorm state buffers and structure

* ------------------------------------------------------------------- */

float32_t lmsStateF32[NUMTAPS + BLOCKSIZE];
```

--------------------------------

### Echo Client Thread Implementation

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__wifi__socket__gr.html

Example demonstrating the initialization of a WiFi driver and socket setup for an echo client thread.

```C
extern ARM_DRIVER_WIFI Driver_WiFi0;

static ARM_DRIVER_WIFI *wifi;

static const char message[] = { "The quick brown fox jumps over the lazy dog." };

void Echo_Client_Thread (void *arg) {

uint8_t ip[4] = { 192U, 168U, 0U, 100U };

int32_t sock, res;

char dbuf[120];

while (1) {

wifi = &Driver_WiFi0;
```

--------------------------------

### Start a Timer

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__TimerMgmt.html

Example demonstrating the creation and starting of a periodic timer using osTimerStart.

```c
#include "cmsis_os.h"

void Time_Callback (void const *arg) { // timer callback function

// arg contains &exec

// called every second after osTimerStart

}

osTimerDef (Timer, Time_Callback); // define timer

uint32_t exec; // argument for the timer call back function

void TimerStart_example (void) {

osTimerId id; // timer id

uint32_t timerDelay; // timer value

osStatus status; // function return status

// Create periodic timer

exec = 1;

id = osTimerCreate(osTimer(Timer), osTimerPeriodic, &exec);

if (id) {

timerDelay = 1000;

status = osTimerStart (id, timerDelay); // start timer

if (status != osOK) {

// Timer could not be started

}

}

:

}
```

--------------------------------

### Floating-point Convolution Example Setup

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_convolution_example_f32_8c-example.html

Includes necessary headers, defines constants for block size and thresholds, and declares input/output buffers for the convolution operation.

```c
#include "arm_math.h"
#include "math_helper.h"

/* ----------------------------------------------------------------------
* Defines each of the tests performed
* ------------------------------------------------------------------- */
#define MAX_BLOCKSIZE 128
#define DELTA (0.000001f)
#define SNR_THRESHOLD 90

/* ----------------------------------------------------------------------
* Declare I/O buffers
* ------------------------------------------------------------------- */
float32_t Ak[MAX_BLOCKSIZE]; /* Input A */
float32_t Bk[MAX_BLOCKSIZE]; /* Input B */
float32_t AxB[MAX_BLOCKSIZE * 2]; /* Output */

/* ----------------------------------------------------------------------
* Test input data for Floating point Convolution example for 32-blockSize
* Generated by the MATLAB randn() function
* ------------------------------------------------------------------- */
float32_t testInputA_f32[64] =
{
-0.808920, 1.357369, 1.180861, -0.504544, 1.762637, -0.703285,
1.696966, 0.620571, -0.151093, -0.100235, -0.872382, -0.403579,
```

--------------------------------

### Initialize progressive reader

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Projects/32L4P5GDISCOVERY/Demonstrations/Watermark/lib/libpng-1.6.17/libpng-manual.txt

This example demonstrates the setup of the progressive read interface, including error handling and callback registration.

```c
png_structp png_ptr;
png_infop info_ptr;

 /*  An example code fragment of how you would
     initialize the progressive reader in your
     application. */
 int
 initialize_png_reader()
 {
    png_ptr = png_create_read_struct
        (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
         user_error_fn, user_warning_fn);

    if (!png_ptr)
        return (ERROR);

    info_ptr = png_create_info_struct(png_ptr);

    if (!info_ptr)
    {
       png_destroy_read_struct(&png_ptr,
          (png_infopp)NULL, (png_infopp)NULL);
       return (ERROR);
    }

    if (setjmp(png_jmpbuf(png_ptr)))
    {
       png_destroy_read_struct(&png_ptr, &info_ptr,
          (png_infopp)NULL);
       return (ERROR);
    }

    /* This one's new.  You can provide functions
       to be called when the header info is valid,
       when each row is completed, and when the image
       is finished.  If you aren't using all functions,
       you can specify NULL parameters.  Even when all
       three functions are NULL, you need to call
       png_set_progressive_read_fn().  You can use
       any struct as the user_ptr (cast to a void pointer
       for the function call), and retrieve the pointer
       from inside the callbacks using the function

          png_get_progressive_ptr(png_ptr);

       which will return a void pointer, which you have
       to cast appropriately.
     */
    png_set_progressive_read_fn(png_ptr, (void *)user_ptr,
        info_callback, row_callback, end_callback);

    return 0;
 }
```

--------------------------------

### I2C Slave Mode Setup

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__i2c__interface__gr.html

Example of initializing and configuring the I2C interface in slave mode.

```c
#include "Driver_I2C.h"

/* I2C driver instance */

extern ARM_DRIVER_I2C Driver_I2C0;

static ARM_DRIVER_I2C *I2Cdrv = &Driver_I2C0;

static volatile uint32_t I2C_Event;

/* I2C Signal Event function callback */

static void I2C_SignalEvent (uint32_t event) {

I2C_Event |= event;

}

int main (void) {

uint8_t cnt = 0;

/* Initialize I2C peripheral */

I2Cdrv->Initialize(I2C_SignalEvent);

/* Power-on I2C peripheral */

I2Cdrv->PowerControl(ARM_POWER_FULL);

/* Configure I2C bus */
```

--------------------------------

### Graphic Equalizer Q31 Example Setup

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_graphic_equalizer_example_q31_8c-example.html

Includes necessary headers, defines constants for processing blocks, and declares state buffers for the Q31 Biquad filters.

```c
/* ----------------------------------------------------------------------

* Copyright (C) 2010-2012 ARM Limited. All rights reserved.

*

* $Date: 17. January 2013

* $Revision: V1.4.0

*

* Project: CMSIS DSP Library

* Title: arm_graphic_equalizer_example_q31.c

*

* Description: Example showing an audio graphic equalizer constructed

* out of Biquad filters.

*

* Target Processor: Cortex-M4/Cortex-M3

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* - Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* - Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in

* the documentation and/or other materials provided with the

* distribution.

* - Neither the name of ARM LIMITED nor the names of its contributors

* may be used to endorse or promote products derived from this

* software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

* -------------------------------------------------------------------- */

#include "arm_math.h"

#include "math_helper.h"

/* Length of the overall data in the test */

#define TESTLENGTH 320

/* Block size for the underlying processing */

#define BLOCKSIZE 32

/* Total number of blocks to run */

#define NUMBLOCKS (TESTLENGTH/BLOCKSIZE)

/* Number of 2nd order Biquad stages per filter */

#define NUMSTAGES 2

#define SNR_THRESHOLD_F32 98

/* -------------------------------------------------------------------

* External Declarations for Input and Output buffers

* ------------------------------------------------------------------- */

extern float32_t testInput_f32[TESTLENGTH];

static float32_t testOutput[TESTLENGTH];

extern float32_t testRefOutput_f32[TESTLENGTH];

/* ----------------------------------------------------------------------

** Q31 state buffers for Band1, Band2, Band3, Band4, Band5

** ------------------------------------------------------------------- */

static q63_t biquadStateBand1Q31[4 * 2];
```

--------------------------------

### Initialize RTOS Objects

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__Message.html

Example setup for memory pools, message queues, and threads using CMSIS-RTOS macros.

```C
mpool = osPoolCreate(osPool(mpool)); // create memory pool

MsgBox = osMessageCreate(osMessageQ(MsgBox), NULL); // create msg queue

tid_thread1 = osThreadCreate(osThread(send_thread), NULL);

tid_thread2 = osThreadCreate(osThread(recv_thread), NULL);
```

--------------------------------

### packChk.exe Output Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Pack/html/createPack_DFP.html

Example output from the packChk.exe utility indicating a missing startup file.

```text
*** INFO M350:
  No 'Startup' found for [Generic:5] 'MVCM3110' ()
```

--------------------------------

### Create Source Files for Manual Installation

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Projects/32L4P5GDISCOVERY/Demonstrations/Watermark/lib/zlib-1.2.8/as400/readme.txt

Commands to create the necessary source files when installing from the original distribution.

```CL
CRTSRCPF FILE(ZLIB/SOURCES) RCDLEN(112) TEXT('ZLIB library modules')
CRTSRCPF FILE(ZLIB/H)       RCDLEN(112) TEXT('ZLIB library includes')
CRTSRCPF FILE(ZLIB/TOOLS)   RCDLEN(112) TEXT('ZLIB library control utilities')
```

--------------------------------

### Define Installation Rules

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Projects/32L4P5GDISCOVERY/Demonstrations/Watermark/lib/zlib-1.2.8/CMakeLists.txt

Specifies installation paths for libraries, headers, man pages, and pkg-config files.

```cmake
if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
    install(TARGETS zlib zlibstatic
        RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
        ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
        LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
endif()
if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
    install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}")
endif()
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
    install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3")
endif()
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
    install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")
endif()
```

--------------------------------

### FFT Bin Example Implementation

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_fft_bin_example_f32_8c-example.html

Initializes buffers and global variables required for the FFT bin calculation example.

```c
/* ----------------------------------------------------------------------
* Copyright (C) 2010-2012 ARM Limited. All rights reserved.
*
* $Date: 17. January 2013
* $Revision: V1.4.0
*
* Project: CMSIS DSP Library
* Title: arm_fft_bin_example_f32.c
*
* Description: Example code demonstrating calculation of Max energy bin of
* frequency domain of input signal.
*
* Target Processor: Cortex-M4/Cortex-M3
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* - Neither the name of ARM LIMITED nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* -------------------------------------------------------------------- */

#include "arm_math.h"
#include "arm_const_structs.h"

#define TEST_LENGTH_SAMPLES 2048

/* -------------------------------------------------------------------
* External Input and Output buffer Declarations for FFT Bin Example
* ------------------------------------------------------------------- */

extern float32_t testInput_f32_10khz[TEST_LENGTH_SAMPLES];
static float32_t testOutput[TEST_LENGTH_SAMPLES/2];

/* ------------------------------------------------------------------
* Global variables for FFT Bin Example
* ------------------------------------------------------------------- */

uint32_t fftSize = 1024;
uint32_t ifftFlag = 0;
uint32_t doBitReverse = 1;

/* Reference index at which max energy of bin ocuurs */
uint32_t refIndex = 213, testIndex = 0;

/* ----------------------------------------------------------------------
* Max magnitude FFT Bin test
* ------------------------------------------------------------------- */
```

--------------------------------

### Compile and Execute ZLIB Installation

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Projects/32L4P5GDISCOVERY/Demonstrations/Watermark/lib/zlib-1.2.8/as400/readme.txt

Commands to compile the installation utility and execute the service program generation.

```CL
CRTCLPGM PGM(ZLIB/COMPILE) SRCFILE(ZLIB/TOOLS) SRCMBR(COMPILE)
```

```CL
CALL PGM(ZLIB/COMPILE)
```

--------------------------------

### Install Headers and Executables

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Projects/32L4P5GDISCOVERY/Demonstrations/Watermark/lib/libpng-1.6.17/CMakeLists.txt

Installs public header files and configuration scripts to the appropriate system directories.

```cmake
if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
  install(FILES ${libpng_public_hdrs}   DESTINATION include)
  install(FILES ${libpng_public_hdrs}   DESTINATION include/${PNGLIB_NAME})
endif()
if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL )
  if(NOT WIN32 OR CYGWIN OR MINGW)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config DESTINATION bin)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
            DESTINATION bin)
  endif(NOT WIN32 OR CYGWIN OR MINGW)
endif()
```

--------------------------------

### Define Example Project

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Pack/html/createPack_DFP.html

Add an <examples> section to the PDSC file to include project templates and board associations.

```xml
<examples>

<example name="Dummy" doc="Abstract.txt" folder="Examples/dummy">

<description>Dummy project</description>

<board name="MVCM3 Starter Kit" vendor="MyVendor"/>

<project>

<environment name="uv" load="dummy.uvprojx"/>

</project>

<attributes>

<category>Getting Started</category>

</attributes>

</example>

</examples>
```

--------------------------------

### Build and Run Examples

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/DSP/README.md

Commands to trigger the build process and execute the resulting binary on a Fixed Virtual Platform (FVP).

```bash
make VERBOSE=1
```

```bash
FVP_MPS2_Cortex-M7.exe -a arm_variance_example
```

--------------------------------

### MPU Configuration Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Core/html/group__mpu__functions.html

Demonstrates setting up a memory region, enabling the MPU, and disabling it after execution.

```C
void main()

{

// Set Region 0

ARM_MPU_SetRegionEx(0UL, 0x08000000UL, MPU_RASR(0UL, ARM_MPU_AP_FULL, 0UL, 0UL, 1UL, 1UL, 0x00UL, ARM_MPU_REGION_SIZE_1MB));

ARM_MPU_Enable(0);

// Execute application code that is access protected by the MPU

ARM_MPU_Disable();

}
```

--------------------------------

### Get Socket Option

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__wifi__socket__gr.html

Example of using SocketGetOpt to determine the type of a socket.

```c
uint32_t type;

wifi->SocketGetOpt (sock, ARM_SOCKET_SO_TYPE, &type, sizeof(type));

if (type == ARM_SOCKET_SOCK_STREAM) {

// Stream socket

}

if (type == ARM_SOCKET_SOCK_DGRAM) {

// Datagram socket

}
```

--------------------------------

### Get Driver Capabilities Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__usart__interface__gr.html

Demonstrates how to retrieve the capabilities structure of the USART driver.

```c
extern ARM_DRIVER_USART Driver_USART0;

ARM_DRIVER_USART *drv_info;

void read_capabilities (void) {

ARM_USART_CAPABILITIES drv_capabilities;

drv_info = &Driver_USART0;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

--------------------------------

### Get Driver Capabilities Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__usbd__interface__gr.html

Retrieves and interrogates the capabilities of the USB Device driver.

```c
extern ARM_DRIVER_USBD Driver_USBD0;

ARM_DRIVER_USBD *drv_info;

void read_capabilities (void) {

ARM_USBD_CAPABILITIES drv_capabilities;

drv_info = &Driver_USBD0;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

--------------------------------

### Get Driver Capabilities Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__i2c__interface__gr.html

Demonstrates how to retrieve the capabilities structure of the I2C driver.

```c
extern ARM_DRIVER_I2C Driver_I2C0;

ARM_DRIVER_I2C *drv_info;

void read_capabilities (void) {

ARM_I2C_CAPABILITIES drv_capabilities;

drv_info = &Driver_I2C0;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

--------------------------------

### Initialize Kernel Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Demonstrates checking the kernel state and initializing it if it is currently inactive.

```c
int main (void) {

// System Initialization

SystemCoreClockUpdate();

// ...

if(osKernelGetState() == osKernelInactive) { // Is the kernel initialized?

osKernelInitialize(); // Initialize CMSIS-RTOS kernel

}

;

}
```

--------------------------------

### Get Driver Version Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__i2c__interface__gr.html

Demonstrates how to retrieve and verify the API version of the I2C driver.

```c
extern ARM_DRIVER_I2C Driver_I2C0;

ARM_DRIVER_I2C *drv_info;

void setup_i2c (void) {

ARM_DRIVER_VERSION version;

drv_info = &Driver_I2C0;

version = drv_info->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```

--------------------------------

### Get Thread Priority Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__ThreadMgmt.html

Demonstrates how to retrieve the priority of the currently running thread using osThreadGetPriority.

```C
#include "cmsis_os.h"

void Thread_1 (void const *arg) { // Thread function

osThreadId id; // id for the currently running thread

osPriority priority; // thread priority

id = osThreadGetId (); // Obtain ID of current running thread

if (id != NULL) {

priority = osThreadGetPriority (id);

}

else {

// Failed to get the id

}

}
```

--------------------------------

### Create AS400 Library and Save File

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Projects/32L4P5GDISCOVERY/Demonstrations/Watermark/lib/zlib-1.2.8/as400/readme.txt

Initial setup commands to create the ZLIB library and a work save file.

```CL
CRTLIB LIB(ZLIB) TYPE(*PROD) TEXT('ZLIB compression API library')
```

```CL
CRTSAVF FILE(ZLIB/ZLIBSAVF)
```

--------------------------------

### Get Driver Version Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__usart__interface__gr.html

Demonstrates how to retrieve and verify the driver version using the GetVersion function.

```c
extern ARM_DRIVER_USART Driver_USART0;

ARM_DRIVER_USART *drv_info;

void setup_usart (void) {

ARM_DRIVER_VERSION version;

drv_info = &Driver_USART0;

version = drv_info->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```

--------------------------------

### Timer Management Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__TimerMgmt.html

Demonstrates defining, creating, starting, and stopping a periodic timer using CMSIS-RTOS APIs.

```C
#include "cmsis_os.h"

void Timer_Callback (void const *arg); // prototype for timer callback function

osTimerDef (Timer, Timer_Callback); // define timer

void TimerStop_example (void) {

osTimerId id; // timer id

osStatus status; // function return status

// Create periodic timer

exec = 1;

id = osTimerCreate(osTimer(Timer2), osTimerPeriodic, NULL);

osTimerStart (id, 1000); // start timer

:

status = osTimerStop (id); // stop timer

if (status != osOK) {

// Timer could not be stopped

}

:

osTimerStart (id, 1000); // start timer again

:}
```

--------------------------------

### Initialize and Start RTOS Kernel

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Demonstrates the standard sequence for initializing the RTOS, creating a main thread, and starting the kernel execution.

```c
#include "RTE_Components.h"
#include CMSIS_device_header
#include "cmsis_os2.h"

/*----------------------------------------------------------------------------
* Application main thread
*---------------------------------------------------------------------------*/
void app_main (void *argument) {

// ...

for (;;) {}

}

int main (void) {

// System Initialization
SystemCoreClockUpdate();

// ...

osKernelInitialize(); // Initialize CMSIS-RTOS

osThreadNew(app_main, NULL, NULL); // Create application main thread

osKernelStart(); // Start thread execution

for (;;) {}

}
```

--------------------------------

### Get Driver Version Example

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/Driver/html/group__usbd__interface__gr.html

Retrieves the driver version and checks if the API version meets the minimum requirement.

```c
extern ARM_DRIVER_USBD Driver_USBD0;

ARM_DRIVER_USBD *drv_info;

void setup_usbd (void) {

ARM_DRIVER_VERSION version;

drv_info = &Driver_USBD0;

version = drv_info->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```

--------------------------------

### Initialize and Start RTOS Kernel

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__KernelCtrl.html

Demonstrates the standard sequence for initializing the kernel, setting up peripherals, and starting thread execution within the main function.

```c
int main (void) {

osKernelInitialize (); // initialize CMSIS-RTOS

// initialize peripherals here

// create 'thread' functions that start executing,

// example: tid_name = osThreadCreate (osThread(name), NULL);

osKernelStart (); // start thread execution

}
```

--------------------------------

### osKernelStart()

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/RTOS/html/globals.html

Start the RTOS kernel and begin thread execution.

```APIDOC
## osKernelStart()

### Description
Start the RTOS kernel and begin thread execution.
```

--------------------------------

### Floating-point Convolution Data and Initialization

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_convolution_example_f32_8c-example.html

Contains the input arrays, reference output, and the main function setup for the convolution example.

```c
-0.860749, -0.382648, -1.052338, 0.128113, -0.646269, 1.093377,

-2.209198, 0.471706, 0.408901, 1.266242, 0.598252, 1.176827,

-0.203421, 0.213596, -0.851964, -0.466958, 0.021841, -0.698938,

-0.604107, 0.461778, -0.318219, 0.942520, 0.577585, 0.417619,

0.614665, 0.563679, -1.295073, -0.764437, 0.952194, -0.859222,

-0.618554, -2.268542, -1.210592, 1.655853, -2.627219, -0.994249,

-1.374704, 0.343799, 0.025619, 1.227481, -0.708031, 0.069355,

-1.845228, -1.570886, 1.010668, -1.802084, 1.630088, 1.286090,

-0.161050, -0.940794, 0.367961, 0.291907

};

[float32_t](arm__math_8h.html#a4611b605e45ab401f02cab15c5e38715) [testInputB_f32](arm__convolution__example__f32_8c.html#acb22287e7e096b677e352dfd363ba60d)[64] =

{

0.933724, 0.046881, 1.316470, 0.438345, 0.332682, 2.094885,

0.512081, 0.035546, 0.050894, -2.320371, 0.168711, -1.830493,

-0.444834, -1.003242, -0.531494, -1.365600, -0.155420, -0.757692,

-0.431880, -0.380021, 0.096243, -0.695835, 0.558850, -1.648962,

0.020369, -0.363630, 0.887146, 0.845503, -0.252864, -0.330397,

1.269131, -1.109295, -1.027876, 0.135940, 0.116721, -0.293399,

-1.349799, 0.166078, -0.802201, 0.369367, -0.964568, -2.266011,

0.465178, 0.651222, -0.325426, 0.320245, -0.784178, -0.579456,

0.093374, 0.604778, -0.048225, 0.376297, -0.394412, 0.578182,

-1.218141, -1.387326, 0.692462, -0.631297, 0.153137, -0.638952,

0.635474, -0.970468, 1.334057, -0.111370

};

const float [testRefOutput_f32](arm__convolution__example__f32_8c.html#a7ede41b07b8766013744c8fdbb80af75)[127] =

{

-0.818943, 1.229484, -0.533664, 1.016604, 0.341875, -1.963656,

5.171476, 3.478033, 7.616361, 6.648384, 0.479069, 1.792012,

-1.295591, -7.447818, 0.315830, -10.657445, -2.483469, -6.524236,

-7.380591, -3.739005, -8.388957, 0.184147, -1.554888, 3.786508,

-1.684421, 5.400610, -1.578126, 7.403361, 8.315999, 2.080267,

11.077776, 2.749673, 7.138962, 2.748762, 0.660363, 0.981552,

1.442275, 0.552721, -2.576892, 4.703989, 0.989156, 8.759344,

-0.564825, -3.994680, 0.954710, -5.014144, 6.592329, 1.599488,

-13.979146, -0.391891, -4.453369, -2.311242, -2.948764, 1.761415,

-0.138322, 10.433007, -2.309103, 4.297153, 8.535523, 3.209462,

8.695819, 5.569919, 2.514304, 5.582029, 2.060199, 0.642280,

7.024616, 1.686615, -6.481756, 1.343084, -3.526451, 1.099073,

-2.965764, -0.173723, -4.111484, 6.528384, -6.965658, 1.726291,

1.535172, 11.023435, 2.338401, -4.690188, 1.298210, 3.943885,

8.407885, 5.168365, 0.684131, 1.559181, 1.859998, 2.852417,

8.574070, -6.369078, 6.023458, 11.837963, -6.027632, 4.469678,

-6.799093, -2.674048, 6.250367, -6.809971, -3.459360, 9.112410,

-2.711621, -1.336678, 1.564249, -1.564297, -1.296760, 8.904013,

-3.230109, 6.878013, -7.819823, 3.369909, -1.657410, -2.007358,

-4.112825, 1.370685, -3.420525, -6.276605, 3.244873, -3.352638,

1.545372, 0.902211, 0.197489, -1.408732, 0.523390, 0.348440, 0

};

/* ----------------------------------------------------------------------

* Declare Global variables

* ------------------------------------------------------------------- */

uint32_t [srcALen](arm__convolution__example__f32_8c.html#ace48ed566e2cd6a680f0681192e6af28) = 64; /* Length of Input A */

uint32_t [srcBLen](arm__convolution__example__f32_8c.html#aea71286f498978c5ed3775609b974fc8) = 64; /* Length of Input B */

uint32_t [outLen](arm__convolution__example__f32_8c.html#a9c49c44c8bc5c432d220d33a26b4b589); /* Length of convolution output */

[float32_t](arm__math_8h.html#a4611b605e45ab401f02cab15c5e38715) [snr](arm__convolution__example__f32_8c.html#af06013f588a7003278de222913c9d819); /* output SNR */

int32_t [main](arm__convolution__example__f32_8c.html#a52d2cba30e6946c95578be946ac12a65)(void)

{

[arm_status](arm__math_8h.html#a5e459c6409dfcd2927bb8a57491d7cf6) [status](arm__dotproduct__example__f32_8c.html#a88ccb294236ab22b00310c47164c53c3); /* Status of the example */

[arm_cfft_radix4_instance_f32](structarm__cfft__radix4__instance__f32.html) cfft_instance; /* CFFT Structure instance */

/* CFFT Structure instance pointer */

[arm_cfft_radix4_instance_f32](structarm__cfft__radix4__instance__f32.html) *cfft_instance_ptr =

([arm_cfft_radix4_instance_f32](structarm__cfft__radix4__instance__f32.html)*) &cfft_instance;

/* output length of convolution */

[outLen](arm__convolution__example__f32_8c.html#a9c49c44c8bc5c432d220d33a26b4b589) = [srcALen](arm__convolution__example__f32_8c.html#ace48ed566e2cd6a680f0681192e6af28) + [srcBLen](arm__convolution__example__f32_8c.html#aea71286f498978c5ed3775609b974fc8) - 1;

/* Initialise the fft input buffers with all zeros */

[arm_fill_f32](group__Fill.html#ga2248e8d3901b4afb7827163132baad94)(0.0, [Ak](arm__convolution__example__f32_8c.html#aed74eacd4b96cc7f71b64d18f2e95705), [MAX_BLOCKSIZE](arm__convolution__example__f32_8c.html#af8a1d2ed31f7c9a00fec46a798edb61b));
```

--------------------------------

### Linear Interpolation Example Setup

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/docs/DSP/html/arm_linear_interp_example_f32_8c-example.html

Includes necessary headers and defines constants for the linear interpolation test, including SNR threshold and test sample length.

```c
#include "arm_math.h"
#include "math_helper.h"

#define SNR_THRESHOLD 90
#define TEST_LENGTH_SAMPLES 10
#define XSPACING (0.00005f)
```

--------------------------------

### Install NumPy

Source: https://github.com/stmicroelectronics/stm32cubel4/blob/master/Drivers/CMSIS/DSP/PythonWrapper/README.md

Install the required numpy package locally.

```bash
> pip install numpy --user
```
Tokens:
Raw