source: S-port/trunk/Drivers/CMSIS/DSP/Include/arm_math.h

Last change on this file was 1, checked in by AlexLir, 3 years ago
File size: 247.5 KB
Line 
1/******************************************************************************
2 * @file arm_math.h
3 * @brief Public header file for CMSIS DSP LibraryU
4 * @version V1.5.3
5 * @date 10. January 2018
6 ******************************************************************************/
7/*
8 * Copyright (c) 2010-2018 Arm Limited or its affiliates. All rights reserved.
9 *
10 * SPDX-License-Identifier: Apache-2.0
11 *
12 * Licensed under the Apache License, Version 2.0 (the License); you may
13 * not use this file except in compliance with the License.
14 * You may obtain a copy of the License at
15 *
16 * www.apache.org/licenses/LICENSE-2.0
17 *
18 * Unless required by applicable law or agreed to in writing, software
19 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
20 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 * See the License for the specific language governing permissions and
22 * limitations under the License.
23 */
24
25/**
26 \mainpage CMSIS DSP Software Library
27 *
28 * Introduction
29 * ------------
30 *
31 * This user manual describes the CMSIS DSP software library,
32 * a suite of common signal processing functions for use on Cortex-M processor based devices.
33 *
34 * The library is divided into a number of functions each covering a specific category:
35 * - Basic math functions
36 * - Fast math functions
37 * - Complex math functions
38 * - Filters
39 * - Matrix functions
40 * - Transforms
41 * - Motor control functions
42 * - Statistical functions
43 * - Support functions
44 * - Interpolation functions
45 *
46 * The library has separate functions for operating on 8-bit integers, 16-bit integers,
47 * 32-bit integer and 32-bit floating-point values.
48 *
49 * Using the Library
50 * ------------
51 *
52 * The library installer contains prebuilt versions of the libraries in the <code>Lib</code> folder.
53 * - arm_cortexM7lfdp_math.lib (Cortex-M7, Little endian, Double Precision Floating Point Unit)
54 * - arm_cortexM7bfdp_math.lib (Cortex-M7, Big endian, Double Precision Floating Point Unit)
55 * - arm_cortexM7lfsp_math.lib (Cortex-M7, Little endian, Single Precision Floating Point Unit)
56 * - arm_cortexM7bfsp_math.lib (Cortex-M7, Big endian and Single Precision Floating Point Unit on)
57 * - arm_cortexM7l_math.lib (Cortex-M7, Little endian)
58 * - arm_cortexM7b_math.lib (Cortex-M7, Big endian)
59 * - arm_cortexM4lf_math.lib (Cortex-M4, Little endian, Floating Point Unit)
60 * - arm_cortexM4bf_math.lib (Cortex-M4, Big endian, Floating Point Unit)
61 * - arm_cortexM4l_math.lib (Cortex-M4, Little endian)
62 * - arm_cortexM4b_math.lib (Cortex-M4, Big endian)
63 * - arm_cortexM3l_math.lib (Cortex-M3, Little endian)
64 * - arm_cortexM3b_math.lib (Cortex-M3, Big endian)
65 * - arm_cortexM0l_math.lib (Cortex-M0 / Cortex-M0+, Little endian)
66 * - arm_cortexM0b_math.lib (Cortex-M0 / Cortex-M0+, Big endian)
67 * - arm_ARMv8MBLl_math.lib (Armv8-M Baseline, Little endian)
68 * - arm_ARMv8MMLl_math.lib (Armv8-M Mainline, Little endian)
69 * - arm_ARMv8MMLlfsp_math.lib (Armv8-M Mainline, Little endian, Single Precision Floating Point Unit)
70 * - arm_ARMv8MMLld_math.lib (Armv8-M Mainline, Little endian, DSP instructions)
71 * - arm_ARMv8MMLldfsp_math.lib (Armv8-M Mainline, Little endian, DSP instructions, Single Precision Floating Point Unit)
72 *
73 * The library functions are declared in the public file <code>arm_math.h</code> which is placed in the <code>Include</code> folder.
74 * Simply include this file and link the appropriate library in the application and begin calling the library functions. The Library supports single
75 * public header file <code> arm_math.h</code> for Cortex-M cores with little endian and big endian. Same header file will be used for floating point unit(FPU) variants.
76 * Define the appropriate preprocessor macro ARM_MATH_CM7 or ARM_MATH_CM4 or ARM_MATH_CM3 or
77 * ARM_MATH_CM0 or ARM_MATH_CM0PLUS depending on the target processor in the application.
78 * For Armv8-M cores define preprocessor macro ARM_MATH_ARMV8MBL or ARM_MATH_ARMV8MML.
79 * Set preprocessor macro __DSP_PRESENT if Armv8-M Mainline core supports DSP instructions.
80 *
81 *
82 * Examples
83 * --------
84 *
85 * The library ships with a number of examples which demonstrate how to use the library functions.
86 *
87 * Toolchain Support
88 * ------------
89 *
90 * The library has been developed and tested with MDK version 5.14.0.0
91 * The library is being tested in GCC and IAR toolchains and updates on this activity will be made available shortly.
92 *
93 * Building the Library
94 * ------------
95 *
96 * The library installer contains a project file to rebuild libraries on MDK toolchain in the <code>CMSIS\\DSP_Lib\\Source\\ARM</code> folder.
97 * - arm_cortexM_math.uvprojx
98 *
99 *
100 * The libraries can be built by opening the arm_cortexM_math.uvprojx project in MDK-ARM, selecting a specific target, and defining the optional preprocessor macros detailed above.
101 *
102 * Preprocessor Macros
103 * ------------
104 *
105 * Each library project have different preprocessor macros.
106 *
107 * - UNALIGNED_SUPPORT_DISABLE:
108 *
109 * Define macro UNALIGNED_SUPPORT_DISABLE, If the silicon does not support unaligned memory access
110 *
111 * - ARM_MATH_BIG_ENDIAN:
112 *
113 * Define macro ARM_MATH_BIG_ENDIAN to build the library for big endian targets. By default library builds for little endian targets.
114 *
115 * - ARM_MATH_MATRIX_CHECK:
116 *
117 * Define macro ARM_MATH_MATRIX_CHECK for checking on the input and output sizes of matrices
118 *
119 * - ARM_MATH_ROUNDING:
120 *
121 * Define macro ARM_MATH_ROUNDING for rounding on support functions
122 *
123 * - ARM_MATH_CMx:
124 *
125 * Define macro ARM_MATH_CM4 for building the library on Cortex-M4 target, ARM_MATH_CM3 for building library on Cortex-M3 target
126 * and ARM_MATH_CM0 for building library on Cortex-M0 target, ARM_MATH_CM0PLUS for building library on Cortex-M0+ target, and
127 * ARM_MATH_CM7 for building the library on cortex-M7.
128 *
129 * - ARM_MATH_ARMV8MxL:
130 *
131 * Define macro ARM_MATH_ARMV8MBL for building the library on Armv8-M Baseline target, ARM_MATH_ARMV8MML for building library
132 * on Armv8-M Mainline target.
133 *
134 * - __FPU_PRESENT:
135 *
136 * Initialize macro __FPU_PRESENT = 1 when building on FPU supported Targets. Enable this macro for floating point libraries.
137 *
138 * - __DSP_PRESENT:
139 *
140 * Initialize macro __DSP_PRESENT = 1 when Armv8-M Mainline core supports DSP instructions.
141 *
142 * <hr>
143 * CMSIS-DSP in ARM::CMSIS Pack
144 * -----------------------------
145 *
146 * The following files relevant to CMSIS-DSP are present in the <b>ARM::CMSIS</b> Pack directories:
147 * |File/Folder |Content |
148 * |------------------------------|------------------------------------------------------------------------|
149 * |\b CMSIS\\Documentation\\DSP | This documentation |
150 * |\b CMSIS\\DSP_Lib | Software license agreement (license.txt) |
151 * |\b CMSIS\\DSP_Lib\\Examples | Example projects demonstrating the usage of the library functions |
152 * |\b CMSIS\\DSP_Lib\\Source | Source files for rebuilding the library |
153 *
154 * <hr>
155 * Revision History of CMSIS-DSP
156 * ------------
157 * Please refer to \ref ChangeLog_pg.
158 *
159 * Copyright Notice
160 * ------------
161 *
162 * Copyright (C) 2010-2015 Arm Limited. All rights reserved.
163 */
164
165
166/**
167 * @defgroup groupMath Basic Math Functions
168 */
169
170/**
171 * @defgroup groupFastMath Fast Math Functions
172 * This set of functions provides a fast approximation to sine, cosine, and square root.
173 * As compared to most of the other functions in the CMSIS math library, the fast math functions
174 * operate on individual values and not arrays.
175 * There are separate functions for Q15, Q31, and floating-point data.
176 *
177 */
178
179/**
180 * @defgroup groupCmplxMath Complex Math Functions
181 * This set of functions operates on complex data vectors.
182 * The data in the complex arrays is stored in an interleaved fashion
183 * (real, imag, real, imag, ...).
184 * In the API functions, the number of samples in a complex array refers
185 * to the number of complex values; the array contains twice this number of
186 * real values.
187 */
188
189/**
190 * @defgroup groupFilters Filtering Functions
191 */
192
193/**
194 * @defgroup groupMatrix Matrix Functions
195 *
196 * This set of functions provides basic matrix math operations.
197 * The functions operate on matrix data structures. For example,
198 * the type
199 * definition for the floating-point matrix structure is shown
200 * below:
201 * <pre>
202 * typedef struct
203 * {
204 * uint16_t numRows; // number of rows of the matrix.
205 * uint16_t numCols; // number of columns of the matrix.
206 * float32_t *pData; // points to the data of the matrix.
207 * } arm_matrix_instance_f32;
208 * </pre>
209 * There are similar definitions for Q15 and Q31 data types.
210 *
211 * The structure specifies the size of the matrix and then points to
212 * an array of data. The array is of size <code>numRows X numCols</code>
213 * and the values are arranged in row order. That is, the
214 * matrix element (i, j) is stored at:
215 * <pre>
216 * pData[i*numCols + j]
217 * </pre>
218 *
219 * \par Init Functions
220 * There is an associated initialization function for each type of matrix
221 * data structure.
222 * The initialization function sets the values of the internal structure fields.
223 * Refer to the function <code>arm_mat_init_f32()</code>, <code>arm_mat_init_q31()</code>
224 * and <code>arm_mat_init_q15()</code> for floating-point, Q31 and Q15 types, respectively.
225 *
226 * \par
227 * Use of the initialization function is optional. However, if initialization function is used
228 * then the instance structure cannot be placed into a const data section.
229 * To place the instance structure in a const data
230 * section, manually initialize the data structure. For example:
231 * <pre>
232 * <code>arm_matrix_instance_f32 S = {nRows, nColumns, pData};</code>
233 * <code>arm_matrix_instance_q31 S = {nRows, nColumns, pData};</code>
234 * <code>arm_matrix_instance_q15 S = {nRows, nColumns, pData};</code>
235 * </pre>
236 * where <code>nRows</code> specifies the number of rows, <code>nColumns</code>
237 * specifies the number of columns, and <code>pData</code> points to the
238 * data array.
239 *
240 * \par Size Checking
241 * By default all of the matrix functions perform size checking on the input and
242 * output matrices. For example, the matrix addition function verifies that the
243 * two input matrices and the output matrix all have the same number of rows and
244 * columns. If the size check fails the functions return:
245 * <pre>
246 * ARM_MATH_SIZE_MISMATCH
247 * </pre>
248 * Otherwise the functions return
249 * <pre>
250 * ARM_MATH_SUCCESS
251 * </pre>
252 * There is some overhead associated with this matrix size checking.
253 * The matrix size checking is enabled via the \#define
254 * <pre>
255 * ARM_MATH_MATRIX_CHECK
256 * </pre>
257 * within the library project settings. By default this macro is defined
258 * and size checking is enabled. By changing the project settings and
259 * undefining this macro size checking is eliminated and the functions
260 * run a bit faster. With size checking disabled the functions always
261 * return <code>ARM_MATH_SUCCESS</code>.
262 */
263
264/**
265 * @defgroup groupTransforms Transform Functions
266 */
267
268/**
269 * @defgroup groupController Controller Functions
270 */
271
272/**
273 * @defgroup groupStats Statistics Functions
274 */
275/**
276 * @defgroup groupSupport Support Functions
277 */
278
279/**
280 * @defgroup groupInterpolation Interpolation Functions
281 * These functions perform 1- and 2-dimensional interpolation of data.
282 * Linear interpolation is used for 1-dimensional data and
283 * bilinear interpolation is used for 2-dimensional data.
284 */
285
286/**
287 * @defgroup groupExamples Examples
288 */
289#ifndef _ARM_MATH_H
290#define _ARM_MATH_H
291
292/* Compiler specific diagnostic adjustment */
293#if defined ( __CC_ARM )
294
295#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
296
297#elif defined ( __GNUC__ )
298#pragma GCC diagnostic push
299#pragma GCC diagnostic ignored "-Wsign-conversion"
300#pragma GCC diagnostic ignored "-Wconversion"
301#pragma GCC diagnostic ignored "-Wunused-parameter"
302
303#elif defined ( __ICCARM__ )
304
305#elif defined ( __TI_ARM__ )
306
307#elif defined ( __CSMC__ )
308
309#elif defined ( __TASKING__ )
310
311#else
312 #error Unknown compiler
313#endif
314
315
316#define __CMSIS_GENERIC /* disable NVIC and Systick functions */
317
318#if defined(ARM_MATH_CM7)
319 #include "core_cm7.h"
320 #define ARM_MATH_DSP
321#elif defined (ARM_MATH_CM4)
322 #include "core_cm4.h"
323 #define ARM_MATH_DSP
324#elif defined (ARM_MATH_CM3)
325 #include "core_cm3.h"
326#elif defined (ARM_MATH_CM0)
327 #include "core_cm0.h"
328 #define ARM_MATH_CM0_FAMILY
329#elif defined (ARM_MATH_CM0PLUS)
330 #include "core_cm0plus.h"
331 #define ARM_MATH_CM0_FAMILY
332#elif defined (ARM_MATH_ARMV8MBL)
333 #include "core_armv8mbl.h"
334 #define ARM_MATH_CM0_FAMILY
335#elif defined (ARM_MATH_ARMV8MML)
336 #include "core_armv8mml.h"
337 #if (defined (__DSP_PRESENT) && (__DSP_PRESENT == 1))
338 #define ARM_MATH_DSP
339 #endif
340#else
341 #error "Define according the used Cortex core ARM_MATH_CM7, ARM_MATH_CM4, ARM_MATH_CM3, ARM_MATH_CM0PLUS, ARM_MATH_CM0, ARM_MATH_ARMV8MBL, ARM_MATH_ARMV8MML"
342#endif
343
344#undef __CMSIS_GENERIC /* enable NVIC and Systick functions */
345#include "string.h"
346#include "math.h"
347#ifdef __cplusplus
348extern "C"
349{
350#endif
351
352
353 /**
354 * @brief Macros required for reciprocal calculation in Normalized LMS
355 */
356
357#define DELTA_Q31 (0x100)
358#define DELTA_Q15 0x5
359#define INDEX_MASK 0x0000003F
360#ifndef PI
361 #define PI 3.14159265358979f
362#endif
363
364 /**
365 * @brief Macros required for SINE and COSINE Fast math approximations
366 */
367
368#define FAST_MATH_TABLE_SIZE 512
369#define FAST_MATH_Q31_SHIFT (32 - 10)
370#define FAST_MATH_Q15_SHIFT (16 - 10)
371#define CONTROLLER_Q31_SHIFT (32 - 9)
372#define TABLE_SPACING_Q31 0x400000
373#define TABLE_SPACING_Q15 0x80
374
375 /**
376 * @brief Macros required for SINE and COSINE Controller functions
377 */
378 /* 1.31(q31) Fixed value of 2/360 */
379 /* -1 to +1 is divided into 360 values so total spacing is (2/360) */
380#define INPUT_SPACING 0xB60B61
381
382 /**
383 * @brief Macro for Unaligned Support
384 */
385#ifndef UNALIGNED_SUPPORT_DISABLE
386 #define ALIGN4
387#else
388 #if defined (__GNUC__)
389 #define ALIGN4 __attribute__((aligned(4)))
390 #else
391 #define ALIGN4 __align(4)
392 #endif
393#endif /* #ifndef UNALIGNED_SUPPORT_DISABLE */
394
395 /**
396 * @brief Error status returned by some functions in the library.
397 */
398
399 typedef enum
400 {
401 ARM_MATH_SUCCESS = 0, /**< No error */
402 ARM_MATH_ARGUMENT_ERROR = -1, /**< One or more arguments are incorrect */
403 ARM_MATH_LENGTH_ERROR = -2, /**< Length of data buffer is incorrect */
404 ARM_MATH_SIZE_MISMATCH = -3, /**< Size of matrices is not compatible with the operation. */
405 ARM_MATH_NANINF = -4, /**< Not-a-number (NaN) or infinity is generated */
406 ARM_MATH_SINGULAR = -5, /**< Generated by matrix inversion if the input matrix is singular and cannot be inverted. */
407 ARM_MATH_TEST_FAILURE = -6 /**< Test Failed */
408 } arm_status;
409
410 /**
411 * @brief 8-bit fractional data type in 1.7 format.
412 */
413 typedef int8_t q7_t;
414
415 /**
416 * @brief 16-bit fractional data type in 1.15 format.
417 */
418 typedef int16_t q15_t;
419
420 /**
421 * @brief 32-bit fractional data type in 1.31 format.
422 */
423 typedef int32_t q31_t;
424
425 /**
426 * @brief 64-bit fractional data type in 1.63 format.
427 */
428 typedef int64_t q63_t;
429
430 /**
431 * @brief 32-bit floating-point type definition.
432 */
433 typedef float float32_t;
434
435 /**
436 * @brief 64-bit floating-point type definition.
437 */
438 typedef double float64_t;
439
440 /**
441 * @brief definition to read/write two 16 bit values.
442 */
443#if defined ( __CC_ARM )
444 #define __SIMD32_TYPE int32_t __packed
445 #define CMSIS_UNUSED __attribute__((unused))
446 #define CMSIS_INLINE __attribute__((always_inline))
447
448#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
449 #define __SIMD32_TYPE int32_t
450 #define CMSIS_UNUSED __attribute__((unused))
451 #define CMSIS_INLINE __attribute__((always_inline))
452
453#elif defined ( __GNUC__ )
454 #define __SIMD32_TYPE int32_t
455 #define CMSIS_UNUSED __attribute__((unused))
456 #define CMSIS_INLINE __attribute__((always_inline))
457
458#elif defined ( __ICCARM__ )
459 #define __SIMD32_TYPE int32_t __packed
460 #define CMSIS_UNUSED
461 #define CMSIS_INLINE
462
463#elif defined ( __TI_ARM__ )
464 #define __SIMD32_TYPE int32_t
465 #define CMSIS_UNUSED __attribute__((unused))
466 #define CMSIS_INLINE
467
468#elif defined ( __CSMC__ )
469 #define __SIMD32_TYPE int32_t
470 #define CMSIS_UNUSED
471 #define CMSIS_INLINE
472
473#elif defined ( __TASKING__ )
474 #define __SIMD32_TYPE __unaligned int32_t
475 #define CMSIS_UNUSED
476 #define CMSIS_INLINE
477
478#else
479 #error Unknown compiler
480#endif
481
482#define __SIMD32(addr) (*(__SIMD32_TYPE **) & (addr))
483#define __SIMD32_CONST(addr) ((__SIMD32_TYPE *)(addr))
484#define _SIMD32_OFFSET(addr) (*(__SIMD32_TYPE *) (addr))
485#define __SIMD64(addr) (*(int64_t **) & (addr))
486
487#if !defined (ARM_MATH_DSP)
488 /**
489 * @brief definition to pack two 16 bit values.
490 */
491#define __PKHBT(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0x0000FFFF) | \
492 (((int32_t)(ARG2) << ARG3) & (int32_t)0xFFFF0000) )
493#define __PKHTB(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0xFFFF0000) | \
494 (((int32_t)(ARG2) >> ARG3) & (int32_t)0x0000FFFF) )
495
496#endif /* !defined (ARM_MATH_DSP) */
497
498 /**
499 * @brief definition to pack four 8 bit values.
500 */
501#ifndef ARM_MATH_BIG_ENDIAN
502
503#define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v0) << 0) & (int32_t)0x000000FF) | \
504 (((int32_t)(v1) << 8) & (int32_t)0x0000FF00) | \
505 (((int32_t)(v2) << 16) & (int32_t)0x00FF0000) | \
506 (((int32_t)(v3) << 24) & (int32_t)0xFF000000) )
507#else
508
509#define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v3) << 0) & (int32_t)0x000000FF) | \
510 (((int32_t)(v2) << 8) & (int32_t)0x0000FF00) | \
511 (((int32_t)(v1) << 16) & (int32_t)0x00FF0000) | \
512 (((int32_t)(v0) << 24) & (int32_t)0xFF000000) )
513
514#endif
515
516
517 /**
518 * @brief Clips Q63 to Q31 values.
519 */
520 CMSIS_INLINE __STATIC_INLINE q31_t clip_q63_to_q31(
521 q63_t x)
522 {
523 return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?
524 ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x;
525 }
526
527 /**
528 * @brief Clips Q63 to Q15 values.
529 */
530 CMSIS_INLINE __STATIC_INLINE q15_t clip_q63_to_q15(
531 q63_t x)
532 {
533 return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?
534 ((0x7FFF ^ ((q15_t) (x >> 63)))) : (q15_t) (x >> 15);
535 }
536
537 /**
538 * @brief Clips Q31 to Q7 values.
539 */
540 CMSIS_INLINE __STATIC_INLINE q7_t clip_q31_to_q7(
541 q31_t x)
542 {
543 return ((q31_t) (x >> 24) != ((q31_t) x >> 23)) ?
544 ((0x7F ^ ((q7_t) (x >> 31)))) : (q7_t) x;
545 }
546
547 /**
548 * @brief Clips Q31 to Q15 values.
549 */
550 CMSIS_INLINE __STATIC_INLINE q15_t clip_q31_to_q15(
551 q31_t x)
552 {
553 return ((q31_t) (x >> 16) != ((q31_t) x >> 15)) ?
554 ((0x7FFF ^ ((q15_t) (x >> 31)))) : (q15_t) x;
555 }
556
557 /**
558 * @brief Multiplies 32 X 64 and returns 32 bit result in 2.30 format.
559 */
560
561 CMSIS_INLINE __STATIC_INLINE q63_t mult32x64(
562 q63_t x,
563 q31_t y)
564 {
565 return ((((q63_t) (x & 0x00000000FFFFFFFF) * y) >> 32) +
566 (((q63_t) (x >> 32) * y)));
567 }
568
569 /**
570 * @brief Function to Calculates 1/in (reciprocal) value of Q31 Data type.
571 */
572
573 CMSIS_INLINE __STATIC_INLINE uint32_t arm_recip_q31(
574 q31_t in,
575 q31_t * dst,
576 q31_t * pRecipTable)
577 {
578 q31_t out;
579 uint32_t tempVal;
580 uint32_t index, i;
581 uint32_t signBits;
582
583 if (in > 0)
584 {
585 signBits = ((uint32_t) (__CLZ( in) - 1));
586 }
587 else
588 {
589 signBits = ((uint32_t) (__CLZ(-in) - 1));
590 }
591
592 /* Convert input sample to 1.31 format */
593 in = (in << signBits);
594
595 /* calculation of index for initial approximated Val */
596 index = (uint32_t)(in >> 24);
597 index = (index & INDEX_MASK);
598
599 /* 1.31 with exp 1 */
600 out = pRecipTable[index];
601
602 /* calculation of reciprocal value */
603 /* running approximation for two iterations */
604 for (i = 0U; i < 2U; i++)
605 {
606 tempVal = (uint32_t) (((q63_t) in * out) >> 31);
607 tempVal = 0x7FFFFFFFu - tempVal;
608 /* 1.31 with exp 1 */
609 /* out = (q31_t) (((q63_t) out * tempVal) >> 30); */
610 out = clip_q63_to_q31(((q63_t) out * tempVal) >> 30);
611 }
612
613 /* write output */
614 *dst = out;
615
616 /* return num of signbits of out = 1/in value */
617 return (signBits + 1U);
618 }
619
620
621 /**
622 * @brief Function to Calculates 1/in (reciprocal) value of Q15 Data type.
623 */
624 CMSIS_INLINE __STATIC_INLINE uint32_t arm_recip_q15(
625 q15_t in,
626 q15_t * dst,
627 q15_t * pRecipTable)
628 {
629 q15_t out = 0;
630 uint32_t tempVal = 0;
631 uint32_t index = 0, i = 0;
632 uint32_t signBits = 0;
633
634 if (in > 0)
635 {
636 signBits = ((uint32_t)(__CLZ( in) - 17));
637 }
638 else
639 {
640 signBits = ((uint32_t)(__CLZ(-in) - 17));
641 }
642
643 /* Convert input sample to 1.15 format */
644 in = (in << signBits);
645
646 /* calculation of index for initial approximated Val */
647 index = (uint32_t)(in >> 8);
648 index = (index & INDEX_MASK);
649
650 /* 1.15 with exp 1 */
651 out = pRecipTable[index];
652
653 /* calculation of reciprocal value */
654 /* running approximation for two iterations */
655 for (i = 0U; i < 2U; i++)
656 {
657 tempVal = (uint32_t) (((q31_t) in * out) >> 15);
658 tempVal = 0x7FFFu - tempVal;
659 /* 1.15 with exp 1 */
660 out = (q15_t) (((q31_t) out * tempVal) >> 14);
661 /* out = clip_q31_to_q15(((q31_t) out * tempVal) >> 14); */
662 }
663
664 /* write output */
665 *dst = out;
666
667 /* return num of signbits of out = 1/in value */
668 return (signBits + 1);
669 }
670
671
672/*
673 * @brief C custom defined intrinsic function for M3 and M0 processors
674 */
675#if !defined (ARM_MATH_DSP)
676
677 /*
678 * @brief C custom defined QADD8 for M3 and M0 processors
679 */
680 CMSIS_INLINE __STATIC_INLINE uint32_t __QADD8(
681 uint32_t x,
682 uint32_t y)
683 {
684 q31_t r, s, t, u;
685
686 r = __SSAT(((((q31_t)x << 24) >> 24) + (((q31_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF;
687 s = __SSAT(((((q31_t)x << 16) >> 24) + (((q31_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF;
688 t = __SSAT(((((q31_t)x << 8) >> 24) + (((q31_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF;
689 u = __SSAT(((((q31_t)x ) >> 24) + (((q31_t)y ) >> 24)), 8) & (int32_t)0x000000FF;
690
691 return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r )));
692 }
693
694
695 /*
696 * @brief C custom defined QSUB8 for M3 and M0 processors
697 */
698 CMSIS_INLINE __STATIC_INLINE uint32_t __QSUB8(
699 uint32_t x,
700 uint32_t y)
701 {
702 q31_t r, s, t, u;
703
704 r = __SSAT(((((q31_t)x << 24) >> 24) - (((q31_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF;
705 s = __SSAT(((((q31_t)x << 16) >> 24) - (((q31_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF;
706 t = __SSAT(((((q31_t)x << 8) >> 24) - (((q31_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF;
707 u = __SSAT(((((q31_t)x ) >> 24) - (((q31_t)y ) >> 24)), 8) & (int32_t)0x000000FF;
708
709 return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r )));
710 }
711
712
713 /*
714 * @brief C custom defined QADD16 for M3 and M0 processors
715 */
716 CMSIS_INLINE __STATIC_INLINE uint32_t __QADD16(
717 uint32_t x,
718 uint32_t y)
719 {
720/* q31_t r, s; without initialisation 'arm_offset_q15 test' fails but 'intrinsic' tests pass! for armCC */
721 q31_t r = 0, s = 0;
722
723 r = __SSAT(((((q31_t)x << 16) >> 16) + (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
724 s = __SSAT(((((q31_t)x ) >> 16) + (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF;
725
726 return ((uint32_t)((s << 16) | (r )));
727 }
728
729
730 /*
731 * @brief C custom defined SHADD16 for M3 and M0 processors
732 */
733 CMSIS_INLINE __STATIC_INLINE uint32_t __SHADD16(
734 uint32_t x,
735 uint32_t y)
736 {
737 q31_t r, s;
738
739 r = (((((q31_t)x << 16) >> 16) + (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
740 s = (((((q31_t)x ) >> 16) + (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
741
742 return ((uint32_t)((s << 16) | (r )));
743 }
744
745
746 /*
747 * @brief C custom defined QSUB16 for M3 and M0 processors
748 */
749 CMSIS_INLINE __STATIC_INLINE uint32_t __QSUB16(
750 uint32_t x,
751 uint32_t y)
752 {
753 q31_t r, s;
754
755 r = __SSAT(((((q31_t)x << 16) >> 16) - (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
756 s = __SSAT(((((q31_t)x ) >> 16) - (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF;
757
758 return ((uint32_t)((s << 16) | (r )));
759 }
760
761
762 /*
763 * @brief C custom defined SHSUB16 for M3 and M0 processors
764 */
765 CMSIS_INLINE __STATIC_INLINE uint32_t __SHSUB16(
766 uint32_t x,
767 uint32_t y)
768 {
769 q31_t r, s;
770
771 r = (((((q31_t)x << 16) >> 16) - (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
772 s = (((((q31_t)x ) >> 16) - (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
773
774 return ((uint32_t)((s << 16) | (r )));
775 }
776
777
778 /*
779 * @brief C custom defined QASX for M3 and M0 processors
780 */
781 CMSIS_INLINE __STATIC_INLINE uint32_t __QASX(
782 uint32_t x,
783 uint32_t y)
784 {
785 q31_t r, s;
786
787 r = __SSAT(((((q31_t)x << 16) >> 16) - (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF;
788 s = __SSAT(((((q31_t)x ) >> 16) + (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
789
790 return ((uint32_t)((s << 16) | (r )));
791 }
792
793
794 /*
795 * @brief C custom defined SHASX for M3 and M0 processors
796 */
797 CMSIS_INLINE __STATIC_INLINE uint32_t __SHASX(
798 uint32_t x,
799 uint32_t y)
800 {
801 q31_t r, s;
802
803 r = (((((q31_t)x << 16) >> 16) - (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
804 s = (((((q31_t)x ) >> 16) + (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
805
806 return ((uint32_t)((s << 16) | (r )));
807 }
808
809
810 /*
811 * @brief C custom defined QSAX for M3 and M0 processors
812 */
813 CMSIS_INLINE __STATIC_INLINE uint32_t __QSAX(
814 uint32_t x,
815 uint32_t y)
816 {
817 q31_t r, s;
818
819 r = __SSAT(((((q31_t)x << 16) >> 16) + (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF;
820 s = __SSAT(((((q31_t)x ) >> 16) - (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
821
822 return ((uint32_t)((s << 16) | (r )));
823 }
824
825
826 /*
827 * @brief C custom defined SHSAX for M3 and M0 processors
828 */
829 CMSIS_INLINE __STATIC_INLINE uint32_t __SHSAX(
830 uint32_t x,
831 uint32_t y)
832 {
833 q31_t r, s;
834
835 r = (((((q31_t)x << 16) >> 16) + (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
836 s = (((((q31_t)x ) >> 16) - (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
837
838 return ((uint32_t)((s << 16) | (r )));
839 }
840
841
842 /*
843 * @brief C custom defined SMUSDX for M3 and M0 processors
844 */
845 CMSIS_INLINE __STATIC_INLINE uint32_t __SMUSDX(
846 uint32_t x,
847 uint32_t y)
848 {
849 return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) -
850 ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) ));
851 }
852
853 /*
854 * @brief C custom defined SMUADX for M3 and M0 processors
855 */
856 CMSIS_INLINE __STATIC_INLINE uint32_t __SMUADX(
857 uint32_t x,
858 uint32_t y)
859 {
860 return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) +
861 ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) ));
862 }
863
864
865 /*
866 * @brief C custom defined QADD for M3 and M0 processors
867 */
868 CMSIS_INLINE __STATIC_INLINE int32_t __QADD(
869 int32_t x,
870 int32_t y)
871 {
872 return ((int32_t)(clip_q63_to_q31((q63_t)x + (q31_t)y)));
873 }
874
875
876 /*
877 * @brief C custom defined QSUB for M3 and M0 processors
878 */
879 CMSIS_INLINE __STATIC_INLINE int32_t __QSUB(
880 int32_t x,
881 int32_t y)
882 {
883 return ((int32_t)(clip_q63_to_q31((q63_t)x - (q31_t)y)));
884 }
885
886
887 /*
888 * @brief C custom defined SMLAD for M3 and M0 processors
889 */
890 CMSIS_INLINE __STATIC_INLINE uint32_t __SMLAD(
891 uint32_t x,
892 uint32_t y,
893 uint32_t sum)
894 {
895 return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
896 ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) +
897 ( ((q31_t)sum ) ) ));
898 }
899
900
901 /*
902 * @brief C custom defined SMLADX for M3 and M0 processors
903 */
904 CMSIS_INLINE __STATIC_INLINE uint32_t __SMLADX(
905 uint32_t x,
906 uint32_t y,
907 uint32_t sum)
908 {
909 return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) +
910 ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) +
911 ( ((q31_t)sum ) ) ));
912 }
913
914
915 /*
916 * @brief C custom defined SMLSDX for M3 and M0 processors
917 */
918 CMSIS_INLINE __STATIC_INLINE uint32_t __SMLSDX(
919 uint32_t x,
920 uint32_t y,
921 uint32_t sum)
922 {
923 return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) -
924 ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) +
925 ( ((q31_t)sum ) ) ));
926 }
927
928
929 /*
930 * @brief C custom defined SMLALD for M3 and M0 processors
931 */
932 CMSIS_INLINE __STATIC_INLINE uint64_t __SMLALD(
933 uint32_t x,
934 uint32_t y,
935 uint64_t sum)
936 {
937/* return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) + ((q15_t) x * (q15_t) y)); */
938 return ((uint64_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
939 ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) +
940 ( ((q63_t)sum ) ) ));
941 }
942
943
944 /*
945 * @brief C custom defined SMLALDX for M3 and M0 processors
946 */
947 CMSIS_INLINE __STATIC_INLINE uint64_t __SMLALDX(
948 uint32_t x,
949 uint32_t y,
950 uint64_t sum)
951 {
952/* return (sum + ((q15_t) (x >> 16) * (q15_t) y)) + ((q15_t) x * (q15_t) (y >> 16)); */
953 return ((uint64_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) +
954 ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) +
955 ( ((q63_t)sum ) ) ));
956 }
957
958
959 /*
960 * @brief C custom defined SMUAD for M3 and M0 processors
961 */
962 CMSIS_INLINE __STATIC_INLINE uint32_t __SMUAD(
963 uint32_t x,
964 uint32_t y)
965 {
966 return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
967 ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) ));
968 }
969
970
971 /*
972 * @brief C custom defined SMUSD for M3 and M0 processors
973 */
974 CMSIS_INLINE __STATIC_INLINE uint32_t __SMUSD(
975 uint32_t x,
976 uint32_t y)
977 {
978 return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) -
979 ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) ));
980 }
981
982
983 /*
984 * @brief C custom defined SXTB16 for M3 and M0 processors
985 */
986 CMSIS_INLINE __STATIC_INLINE uint32_t __SXTB16(
987 uint32_t x)
988 {
989 return ((uint32_t)(((((q31_t)x << 24) >> 24) & (q31_t)0x0000FFFF) |
990 ((((q31_t)x << 8) >> 8) & (q31_t)0xFFFF0000) ));
991 }
992
993 /*
994 * @brief C custom defined SMMLA for M3 and M0 processors
995 */
996 CMSIS_INLINE __STATIC_INLINE int32_t __SMMLA(
997 int32_t x,
998 int32_t y,
999 int32_t sum)
1000 {
1001 return (sum + (int32_t) (((int64_t) x * y) >> 32));
1002 }
1003
1004#endif /* !defined (ARM_MATH_DSP) */
1005
1006
1007 /**
1008 * @brief Instance structure for the Q7 FIR filter.
1009 */
1010 typedef struct
1011 {
1012 uint16_t numTaps; /**< number of filter coefficients in the filter. */
1013 q7_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
1014 q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
1015 } arm_fir_instance_q7;
1016
1017 /**
1018 * @brief Instance structure for the Q15 FIR filter.
1019 */
1020 typedef struct
1021 {
1022 uint16_t numTaps; /**< number of filter coefficients in the filter. */
1023 q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
1024 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
1025 } arm_fir_instance_q15;
1026
1027 /**
1028 * @brief Instance structure for the Q31 FIR filter.
1029 */
1030 typedef struct
1031 {
1032 uint16_t numTaps; /**< number of filter coefficients in the filter. */
1033 q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
1034 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
1035 } arm_fir_instance_q31;
1036
1037 /**
1038 * @brief Instance structure for the floating-point FIR filter.
1039 */
1040 typedef struct
1041 {
1042 uint16_t numTaps; /**< number of filter coefficients in the filter. */
1043 float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
1044 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
1045 } arm_fir_instance_f32;
1046
1047
1048 /**
1049 * @brief Processing function for the Q7 FIR filter.
1050 * @param[in] S points to an instance of the Q7 FIR filter structure.
1051 * @param[in] pSrc points to the block of input data.
1052 * @param[out] pDst points to the block of output data.
1053 * @param[in] blockSize number of samples to process.
1054 */
1055 void arm_fir_q7(
1056 const arm_fir_instance_q7 * S,
1057 q7_t * pSrc,
1058 q7_t * pDst,
1059 uint32_t blockSize);
1060
1061
1062 /**
1063 * @brief Initialization function for the Q7 FIR filter.
1064 * @param[in,out] S points to an instance of the Q7 FIR structure.
1065 * @param[in] numTaps Number of filter coefficients in the filter.
1066 * @param[in] pCoeffs points to the filter coefficients.
1067 * @param[in] pState points to the state buffer.
1068 * @param[in] blockSize number of samples that are processed.
1069 */
1070 void arm_fir_init_q7(
1071 arm_fir_instance_q7 * S,
1072 uint16_t numTaps,
1073 q7_t * pCoeffs,
1074 q7_t * pState,
1075 uint32_t blockSize);
1076
1077
1078 /**
1079 * @brief Processing function for the Q15 FIR filter.
1080 * @param[in] S points to an instance of the Q15 FIR structure.
1081 * @param[in] pSrc points to the block of input data.
1082 * @param[out] pDst points to the block of output data.
1083 * @param[in] blockSize number of samples to process.
1084 */
1085 void arm_fir_q15(
1086 const arm_fir_instance_q15 * S,
1087 q15_t * pSrc,
1088 q15_t * pDst,
1089 uint32_t blockSize);
1090
1091
1092 /**
1093 * @brief Processing function for the fast Q15 FIR filter for Cortex-M3 and Cortex-M4.
1094 * @param[in] S points to an instance of the Q15 FIR filter structure.
1095 * @param[in] pSrc points to the block of input data.
1096 * @param[out] pDst points to the block of output data.
1097 * @param[in] blockSize number of samples to process.
1098 */
1099 void arm_fir_fast_q15(
1100 const arm_fir_instance_q15 * S,
1101 q15_t * pSrc,
1102 q15_t * pDst,
1103 uint32_t blockSize);
1104
1105
1106 /**
1107 * @brief Initialization function for the Q15 FIR filter.
1108 * @param[in,out] S points to an instance of the Q15 FIR filter structure.
1109 * @param[in] numTaps Number of filter coefficients in the filter. Must be even and greater than or equal to 4.
1110 * @param[in] pCoeffs points to the filter coefficients.
1111 * @param[in] pState points to the state buffer.
1112 * @param[in] blockSize number of samples that are processed at a time.
1113 * @return The function returns ARM_MATH_SUCCESS if initialization was successful or ARM_MATH_ARGUMENT_ERROR if
1114 * <code>numTaps</code> is not a supported value.
1115 */
1116 arm_status arm_fir_init_q15(
1117 arm_fir_instance_q15 * S,
1118 uint16_t numTaps,
1119 q15_t * pCoeffs,
1120 q15_t * pState,
1121 uint32_t blockSize);
1122
1123
1124 /**
1125 * @brief Processing function for the Q31 FIR filter.
1126 * @param[in] S points to an instance of the Q31 FIR filter structure.
1127 * @param[in] pSrc points to the block of input data.
1128 * @param[out] pDst points to the block of output data.
1129 * @param[in] blockSize number of samples to process.
1130 */
1131 void arm_fir_q31(
1132 const arm_fir_instance_q31 * S,
1133 q31_t * pSrc,
1134 q31_t * pDst,
1135 uint32_t blockSize);
1136
1137
1138 /**
1139 * @brief Processing function for the fast Q31 FIR filter for Cortex-M3 and Cortex-M4.
1140 * @param[in] S points to an instance of the Q31 FIR structure.
1141 * @param[in] pSrc points to the block of input data.
1142 * @param[out] pDst points to the block of output data.
1143 * @param[in] blockSize number of samples to process.
1144 */
1145 void arm_fir_fast_q31(
1146 const arm_fir_instance_q31 * S,
1147 q31_t * pSrc,
1148 q31_t * pDst,
1149 uint32_t blockSize);
1150
1151
1152 /**
1153 * @brief Initialization function for the Q31 FIR filter.
1154 * @param[in,out] S points to an instance of the Q31 FIR structure.
1155 * @param[in] numTaps Number of filter coefficients in the filter.
1156 * @param[in] pCoeffs points to the filter coefficients.
1157 * @param[in] pState points to the state buffer.
1158 * @param[in] blockSize number of samples that are processed at a time.
1159 */
1160 void arm_fir_init_q31(
1161 arm_fir_instance_q31 * S,
1162 uint16_t numTaps,
1163 q31_t * pCoeffs,
1164 q31_t * pState,
1165 uint32_t blockSize);
1166
1167
1168 /**
1169 * @brief Processing function for the floating-point FIR filter.
1170 * @param[in] S points to an instance of the floating-point FIR structure.
1171 * @param[in] pSrc points to the block of input data.
1172 * @param[out] pDst points to the block of output data.
1173 * @param[in] blockSize number of samples to process.
1174 */
1175 void arm_fir_f32(
1176 const arm_fir_instance_f32 * S,
1177 float32_t * pSrc,
1178 float32_t * pDst,
1179 uint32_t blockSize);
1180
1181
1182 /**
1183 * @brief Initialization function for the floating-point FIR filter.
1184 * @param[in,out] S points to an instance of the floating-point FIR filter structure.
1185 * @param[in] numTaps Number of filter coefficients in the filter.
1186 * @param[in] pCoeffs points to the filter coefficients.
1187 * @param[in] pState points to the state buffer.
1188 * @param[in] blockSize number of samples that are processed at a time.
1189 */
1190 void arm_fir_init_f32(
1191 arm_fir_instance_f32 * S,
1192 uint16_t numTaps,
1193 float32_t * pCoeffs,
1194 float32_t * pState,
1195 uint32_t blockSize);
1196
1197
1198 /**
1199 * @brief Instance structure for the Q15 Biquad cascade filter.
1200 */
1201 typedef struct
1202 {
1203 int8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
1204 q15_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */
1205 q15_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */
1206 int8_t postShift; /**< Additional shift, in bits, applied to each output sample. */
1207 } arm_biquad_casd_df1_inst_q15;
1208
1209 /**
1210 * @brief Instance structure for the Q31 Biquad cascade filter.
1211 */
1212 typedef struct
1213 {
1214 uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
1215 q31_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */
1216 q31_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */
1217 uint8_t postShift; /**< Additional shift, in bits, applied to each output sample. */
1218 } arm_biquad_casd_df1_inst_q31;
1219
1220 /**
1221 * @brief Instance structure for the floating-point Biquad cascade filter.
1222 */
1223 typedef struct
1224 {
1225 uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
1226 float32_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */
1227 float32_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */
1228 } arm_biquad_casd_df1_inst_f32;
1229
1230
1231 /**
1232 * @brief Processing function for the Q15 Biquad cascade filter.
1233 * @param[in] S points to an instance of the Q15 Biquad cascade structure.
1234 * @param[in] pSrc points to the block of input data.
1235 * @param[out] pDst points to the block of output data.
1236 * @param[in] blockSize number of samples to process.
1237 */
1238 void arm_biquad_cascade_df1_q15(
1239 const arm_biquad_casd_df1_inst_q15 * S,
1240 q15_t * pSrc,
1241 q15_t * pDst,
1242 uint32_t blockSize);
1243
1244
1245 /**
1246 * @brief Initialization function for the Q15 Biquad cascade filter.
1247 * @param[in,out] S points to an instance of the Q15 Biquad cascade structure.
1248 * @param[in] numStages number of 2nd order stages in the filter.
1249 * @param[in] pCoeffs points to the filter coefficients.
1250 * @param[in] pState points to the state buffer.
1251 * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format
1252 */
1253 void arm_biquad_cascade_df1_init_q15(
1254 arm_biquad_casd_df1_inst_q15 * S,
1255 uint8_t numStages,
1256 q15_t * pCoeffs,
1257 q15_t * pState,
1258 int8_t postShift);
1259
1260
1261 /**
1262 * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4.
1263 * @param[in] S points to an instance of the Q15 Biquad cascade structure.
1264 * @param[in] pSrc points to the block of input data.
1265 * @param[out] pDst points to the block of output data.
1266 * @param[in] blockSize number of samples to process.
1267 */
1268 void arm_biquad_cascade_df1_fast_q15(
1269 const arm_biquad_casd_df1_inst_q15 * S,
1270 q15_t * pSrc,
1271 q15_t * pDst,
1272 uint32_t blockSize);
1273
1274
1275 /**
1276 * @brief Processing function for the Q31 Biquad cascade filter
1277 * @param[in] S points to an instance of the Q31 Biquad cascade structure.
1278 * @param[in] pSrc points to the block of input data.
1279 * @param[out] pDst points to the block of output data.
1280 * @param[in] blockSize number of samples to process.
1281 */
1282 void arm_biquad_cascade_df1_q31(
1283 const arm_biquad_casd_df1_inst_q31 * S,
1284 q31_t * pSrc,
1285 q31_t * pDst,
1286 uint32_t blockSize);
1287
1288
1289 /**
1290 * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4.
1291 * @param[in] S points to an instance of the Q31 Biquad cascade structure.
1292 * @param[in] pSrc points to the block of input data.
1293 * @param[out] pDst points to the block of output data.
1294 * @param[in] blockSize number of samples to process.
1295 */
1296 void arm_biquad_cascade_df1_fast_q31(
1297 const arm_biquad_casd_df1_inst_q31 * S,
1298 q31_t * pSrc,
1299 q31_t * pDst,
1300 uint32_t blockSize);
1301
1302
1303 /**
1304 * @brief Initialization function for the Q31 Biquad cascade filter.
1305 * @param[in,out] S points to an instance of the Q31 Biquad cascade structure.
1306 * @param[in] numStages number of 2nd order stages in the filter.
1307 * @param[in] pCoeffs points to the filter coefficients.
1308 * @param[in] pState points to the state buffer.
1309 * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format
1310 */
1311 void arm_biquad_cascade_df1_init_q31(
1312 arm_biquad_casd_df1_inst_q31 * S,
1313 uint8_t numStages,
1314 q31_t * pCoeffs,
1315 q31_t * pState,
1316 int8_t postShift);
1317
1318
1319 /**
1320 * @brief Processing function for the floating-point Biquad cascade filter.
1321 * @param[in] S points to an instance of the floating-point Biquad cascade structure.
1322 * @param[in] pSrc points to the block of input data.
1323 * @param[out] pDst points to the block of output data.
1324 * @param[in] blockSize number of samples to process.
1325 */
1326 void arm_biquad_cascade_df1_f32(
1327 const arm_biquad_casd_df1_inst_f32 * S,
1328 float32_t * pSrc,
1329 float32_t * pDst,
1330 uint32_t blockSize);
1331
1332
1333 /**
1334 * @brief Initialization function for the floating-point Biquad cascade filter.
1335 * @param[in,out] S points to an instance of the floating-point Biquad cascade structure.
1336 * @param[in] numStages number of 2nd order stages in the filter.
1337 * @param[in] pCoeffs points to the filter coefficients.
1338 * @param[in] pState points to the state buffer.
1339 */
1340 void arm_biquad_cascade_df1_init_f32(
1341 arm_biquad_casd_df1_inst_f32 * S,
1342 uint8_t numStages,
1343 float32_t * pCoeffs,
1344 float32_t * pState);
1345
1346
1347 /**
1348 * @brief Instance structure for the floating-point matrix structure.
1349 */
1350 typedef struct
1351 {
1352 uint16_t numRows; /**< number of rows of the matrix. */
1353 uint16_t numCols; /**< number of columns of the matrix. */
1354 float32_t *pData; /**< points to the data of the matrix. */
1355 } arm_matrix_instance_f32;
1356
1357
1358 /**
1359 * @brief Instance structure for the floating-point matrix structure.
1360 */
1361 typedef struct
1362 {
1363 uint16_t numRows; /**< number of rows of the matrix. */
1364 uint16_t numCols; /**< number of columns of the matrix. */
1365 float64_t *pData; /**< points to the data of the matrix. */
1366 } arm_matrix_instance_f64;
1367
1368 /**
1369 * @brief Instance structure for the Q15 matrix structure.
1370 */
1371 typedef struct
1372 {
1373 uint16_t numRows; /**< number of rows of the matrix. */
1374 uint16_t numCols; /**< number of columns of the matrix. */
1375 q15_t *pData; /**< points to the data of the matrix. */
1376 } arm_matrix_instance_q15;
1377
1378 /**
1379 * @brief Instance structure for the Q31 matrix structure.
1380 */
1381 typedef struct
1382 {
1383 uint16_t numRows; /**< number of rows of the matrix. */
1384 uint16_t numCols; /**< number of columns of the matrix. */
1385 q31_t *pData; /**< points to the data of the matrix. */
1386 } arm_matrix_instance_q31;
1387
1388
1389 /**
1390 * @brief Floating-point matrix addition.
1391 * @param[in] pSrcA points to the first input matrix structure
1392 * @param[in] pSrcB points to the second input matrix structure
1393 * @param[out] pDst points to output matrix structure
1394 * @return The function returns either
1395 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1396 */
1397 arm_status arm_mat_add_f32(
1398 const arm_matrix_instance_f32 * pSrcA,
1399 const arm_matrix_instance_f32 * pSrcB,
1400 arm_matrix_instance_f32 * pDst);
1401
1402
1403 /**
1404 * @brief Q15 matrix addition.
1405 * @param[in] pSrcA points to the first input matrix structure
1406 * @param[in] pSrcB points to the second input matrix structure
1407 * @param[out] pDst points to output matrix structure
1408 * @return The function returns either
1409 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1410 */
1411 arm_status arm_mat_add_q15(
1412 const arm_matrix_instance_q15 * pSrcA,
1413 const arm_matrix_instance_q15 * pSrcB,
1414 arm_matrix_instance_q15 * pDst);
1415
1416
1417 /**
1418 * @brief Q31 matrix addition.
1419 * @param[in] pSrcA points to the first input matrix structure
1420 * @param[in] pSrcB points to the second input matrix structure
1421 * @param[out] pDst points to output matrix structure
1422 * @return The function returns either
1423 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1424 */
1425 arm_status arm_mat_add_q31(
1426 const arm_matrix_instance_q31 * pSrcA,
1427 const arm_matrix_instance_q31 * pSrcB,
1428 arm_matrix_instance_q31 * pDst);
1429
1430
1431 /**
1432 * @brief Floating-point, complex, matrix multiplication.
1433 * @param[in] pSrcA points to the first input matrix structure
1434 * @param[in] pSrcB points to the second input matrix structure
1435 * @param[out] pDst points to output matrix structure
1436 * @return The function returns either
1437 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1438 */
1439 arm_status arm_mat_cmplx_mult_f32(
1440 const arm_matrix_instance_f32 * pSrcA,
1441 const arm_matrix_instance_f32 * pSrcB,
1442 arm_matrix_instance_f32 * pDst);
1443
1444
1445 /**
1446 * @brief Q15, complex, matrix multiplication.
1447 * @param[in] pSrcA points to the first input matrix structure
1448 * @param[in] pSrcB points to the second input matrix structure
1449 * @param[out] pDst points to output matrix structure
1450 * @return The function returns either
1451 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1452 */
1453 arm_status arm_mat_cmplx_mult_q15(
1454 const arm_matrix_instance_q15 * pSrcA,
1455 const arm_matrix_instance_q15 * pSrcB,
1456 arm_matrix_instance_q15 * pDst,
1457 q15_t * pScratch);
1458
1459
1460 /**
1461 * @brief Q31, complex, matrix multiplication.
1462 * @param[in] pSrcA points to the first input matrix structure
1463 * @param[in] pSrcB points to the second input matrix structure
1464 * @param[out] pDst points to output matrix structure
1465 * @return The function returns either
1466 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1467 */
1468 arm_status arm_mat_cmplx_mult_q31(
1469 const arm_matrix_instance_q31 * pSrcA,
1470 const arm_matrix_instance_q31 * pSrcB,
1471 arm_matrix_instance_q31 * pDst);
1472
1473
1474 /**
1475 * @brief Floating-point matrix transpose.
1476 * @param[in] pSrc points to the input matrix
1477 * @param[out] pDst points to the output matrix
1478 * @return The function returns either <code>ARM_MATH_SIZE_MISMATCH</code>
1479 * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1480 */
1481 arm_status arm_mat_trans_f32(
1482 const arm_matrix_instance_f32 * pSrc,
1483 arm_matrix_instance_f32 * pDst);
1484
1485
1486 /**
1487 * @brief Q15 matrix transpose.
1488 * @param[in] pSrc points to the input matrix
1489 * @param[out] pDst points to the output matrix
1490 * @return The function returns either <code>ARM_MATH_SIZE_MISMATCH</code>
1491 * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1492 */
1493 arm_status arm_mat_trans_q15(
1494 const arm_matrix_instance_q15 * pSrc,
1495 arm_matrix_instance_q15 * pDst);
1496
1497
1498 /**
1499 * @brief Q31 matrix transpose.
1500 * @param[in] pSrc points to the input matrix
1501 * @param[out] pDst points to the output matrix
1502 * @return The function returns either <code>ARM_MATH_SIZE_MISMATCH</code>
1503 * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1504 */
1505 arm_status arm_mat_trans_q31(
1506 const arm_matrix_instance_q31 * pSrc,
1507 arm_matrix_instance_q31 * pDst);
1508
1509
1510 /**
1511 * @brief Floating-point matrix multiplication
1512 * @param[in] pSrcA points to the first input matrix structure
1513 * @param[in] pSrcB points to the second input matrix structure
1514 * @param[out] pDst points to output matrix structure
1515 * @return The function returns either
1516 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1517 */
1518 arm_status arm_mat_mult_f32(
1519 const arm_matrix_instance_f32 * pSrcA,
1520 const arm_matrix_instance_f32 * pSrcB,
1521 arm_matrix_instance_f32 * pDst);
1522
1523
1524 /**
1525 * @brief Q15 matrix multiplication
1526 * @param[in] pSrcA points to the first input matrix structure
1527 * @param[in] pSrcB points to the second input matrix structure
1528 * @param[out] pDst points to output matrix structure
1529 * @param[in] pState points to the array for storing intermediate results
1530 * @return The function returns either
1531 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1532 */
1533 arm_status arm_mat_mult_q15(
1534 const arm_matrix_instance_q15 * pSrcA,
1535 const arm_matrix_instance_q15 * pSrcB,
1536 arm_matrix_instance_q15 * pDst,
1537 q15_t * pState);
1538
1539
1540 /**
1541 * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4
1542 * @param[in] pSrcA points to the first input matrix structure
1543 * @param[in] pSrcB points to the second input matrix structure
1544 * @param[out] pDst points to output matrix structure
1545 * @param[in] pState points to the array for storing intermediate results
1546 * @return The function returns either
1547 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1548 */
1549 arm_status arm_mat_mult_fast_q15(
1550 const arm_matrix_instance_q15 * pSrcA,
1551 const arm_matrix_instance_q15 * pSrcB,
1552 arm_matrix_instance_q15 * pDst,
1553 q15_t * pState);
1554
1555
1556 /**
1557 * @brief Q31 matrix multiplication
1558 * @param[in] pSrcA points to the first input matrix structure
1559 * @param[in] pSrcB points to the second input matrix structure
1560 * @param[out] pDst points to output matrix structure
1561 * @return The function returns either
1562 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1563 */
1564 arm_status arm_mat_mult_q31(
1565 const arm_matrix_instance_q31 * pSrcA,
1566 const arm_matrix_instance_q31 * pSrcB,
1567 arm_matrix_instance_q31 * pDst);
1568
1569
1570 /**
1571 * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4
1572 * @param[in] pSrcA points to the first input matrix structure
1573 * @param[in] pSrcB points to the second input matrix structure
1574 * @param[out] pDst points to output matrix structure
1575 * @return The function returns either
1576 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1577 */
1578 arm_status arm_mat_mult_fast_q31(
1579 const arm_matrix_instance_q31 * pSrcA,
1580 const arm_matrix_instance_q31 * pSrcB,
1581 arm_matrix_instance_q31 * pDst);
1582
1583
1584 /**
1585 * @brief Floating-point matrix subtraction
1586 * @param[in] pSrcA points to the first input matrix structure
1587 * @param[in] pSrcB points to the second input matrix structure
1588 * @param[out] pDst points to output matrix structure
1589 * @return The function returns either
1590 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1591 */
1592 arm_status arm_mat_sub_f32(
1593 const arm_matrix_instance_f32 * pSrcA,
1594 const arm_matrix_instance_f32 * pSrcB,
1595 arm_matrix_instance_f32 * pDst);
1596
1597
1598 /**
1599 * @brief Q15 matrix subtraction
1600 * @param[in] pSrcA points to the first input matrix structure
1601 * @param[in] pSrcB points to the second input matrix structure
1602 * @param[out] pDst points to output matrix structure
1603 * @return The function returns either
1604 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1605 */
1606 arm_status arm_mat_sub_q15(
1607 const arm_matrix_instance_q15 * pSrcA,
1608 const arm_matrix_instance_q15 * pSrcB,
1609 arm_matrix_instance_q15 * pDst);
1610
1611
1612 /**
1613 * @brief Q31 matrix subtraction
1614 * @param[in] pSrcA points to the first input matrix structure
1615 * @param[in] pSrcB points to the second input matrix structure
1616 * @param[out] pDst points to output matrix structure
1617 * @return The function returns either
1618 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1619 */
1620 arm_status arm_mat_sub_q31(
1621 const arm_matrix_instance_q31 * pSrcA,
1622 const arm_matrix_instance_q31 * pSrcB,
1623 arm_matrix_instance_q31 * pDst);
1624
1625
1626 /**
1627 * @brief Floating-point matrix scaling.
1628 * @param[in] pSrc points to the input matrix
1629 * @param[in] scale scale factor
1630 * @param[out] pDst points to the output matrix
1631 * @return The function returns either
1632 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1633 */
1634 arm_status arm_mat_scale_f32(
1635 const arm_matrix_instance_f32 * pSrc,
1636 float32_t scale,
1637 arm_matrix_instance_f32 * pDst);
1638
1639
1640 /**
1641 * @brief Q15 matrix scaling.
1642 * @param[in] pSrc points to input matrix
1643 * @param[in] scaleFract fractional portion of the scale factor
1644 * @param[in] shift number of bits to shift the result by
1645 * @param[out] pDst points to output matrix
1646 * @return The function returns either
1647 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1648 */
1649 arm_status arm_mat_scale_q15(
1650 const arm_matrix_instance_q15 * pSrc,
1651 q15_t scaleFract,
1652 int32_t shift,
1653 arm_matrix_instance_q15 * pDst);
1654
1655
1656 /**
1657 * @brief Q31 matrix scaling.
1658 * @param[in] pSrc points to input matrix
1659 * @param[in] scaleFract fractional portion of the scale factor
1660 * @param[in] shift number of bits to shift the result by
1661 * @param[out] pDst points to output matrix structure
1662 * @return The function returns either
1663 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
1664 */
1665 arm_status arm_mat_scale_q31(
1666 const arm_matrix_instance_q31 * pSrc,
1667 q31_t scaleFract,
1668 int32_t shift,
1669 arm_matrix_instance_q31 * pDst);
1670
1671
1672 /**
1673 * @brief Q31 matrix initialization.
1674 * @param[in,out] S points to an instance of the floating-point matrix structure.
1675 * @param[in] nRows number of rows in the matrix.
1676 * @param[in] nColumns number of columns in the matrix.
1677 * @param[in] pData points to the matrix data array.
1678 */
1679 void arm_mat_init_q31(
1680 arm_matrix_instance_q31 * S,
1681 uint16_t nRows,
1682 uint16_t nColumns,
1683 q31_t * pData);
1684
1685
1686 /**
1687 * @brief Q15 matrix initialization.
1688 * @param[in,out] S points to an instance of the floating-point matrix structure.
1689 * @param[in] nRows number of rows in the matrix.
1690 * @param[in] nColumns number of columns in the matrix.
1691 * @param[in] pData points to the matrix data array.
1692 */
1693 void arm_mat_init_q15(
1694 arm_matrix_instance_q15 * S,
1695 uint16_t nRows,
1696 uint16_t nColumns,
1697 q15_t * pData);
1698
1699
1700 /**
1701 * @brief Floating-point matrix initialization.
1702 * @param[in,out] S points to an instance of the floating-point matrix structure.
1703 * @param[in] nRows number of rows in the matrix.
1704 * @param[in] nColumns number of columns in the matrix.
1705 * @param[in] pData points to the matrix data array.
1706 */
1707 void arm_mat_init_f32(
1708 arm_matrix_instance_f32 * S,
1709 uint16_t nRows,
1710 uint16_t nColumns,
1711 float32_t * pData);
1712
1713
1714
1715 /**
1716 * @brief Instance structure for the Q15 PID Control.
1717 */
1718 typedef struct
1719 {
1720 q15_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */
1721#if !defined (ARM_MATH_DSP)
1722 q15_t A1;
1723 q15_t A2;
1724#else
1725 q31_t A1; /**< The derived gain A1 = -Kp - 2Kd | Kd.*/
1726#endif
1727 q15_t state[3]; /**< The state array of length 3. */
1728 q15_t Kp; /**< The proportional gain. */
1729 q15_t Ki; /**< The integral gain. */
1730 q15_t Kd; /**< The derivative gain. */
1731 } arm_pid_instance_q15;
1732
1733 /**
1734 * @brief Instance structure for the Q31 PID Control.
1735 */
1736 typedef struct
1737 {
1738 q31_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */
1739 q31_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */
1740 q31_t A2; /**< The derived gain, A2 = Kd . */
1741 q31_t state[3]; /**< The state array of length 3. */
1742 q31_t Kp; /**< The proportional gain. */
1743 q31_t Ki; /**< The integral gain. */
1744 q31_t Kd; /**< The derivative gain. */
1745 } arm_pid_instance_q31;
1746
1747 /**
1748 * @brief Instance structure for the floating-point PID Control.
1749 */
1750 typedef struct
1751 {
1752 float32_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */
1753 float32_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */
1754 float32_t A2; /**< The derived gain, A2 = Kd . */
1755 float32_t state[3]; /**< The state array of length 3. */
1756 float32_t Kp; /**< The proportional gain. */
1757 float32_t Ki; /**< The integral gain. */
1758 float32_t Kd; /**< The derivative gain. */
1759 } arm_pid_instance_f32;
1760
1761
1762
1763 /**
1764 * @brief Initialization function for the floating-point PID Control.
1765 * @param[in,out] S points to an instance of the PID structure.
1766 * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state.
1767 */
1768 void arm_pid_init_f32(
1769 arm_pid_instance_f32 * S,
1770 int32_t resetStateFlag);
1771
1772
1773 /**
1774 * @brief Reset function for the floating-point PID Control.
1775 * @param[in,out] S is an instance of the floating-point PID Control structure
1776 */
1777 void arm_pid_reset_f32(
1778 arm_pid_instance_f32 * S);
1779
1780
1781 /**
1782 * @brief Initialization function for the Q31 PID Control.
1783 * @param[in,out] S points to an instance of the Q15 PID structure.
1784 * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state.
1785 */
1786 void arm_pid_init_q31(
1787 arm_pid_instance_q31 * S,
1788 int32_t resetStateFlag);
1789
1790
1791 /**
1792 * @brief Reset function for the Q31 PID Control.
1793 * @param[in,out] S points to an instance of the Q31 PID Control structure
1794 */
1795
1796 void arm_pid_reset_q31(
1797 arm_pid_instance_q31 * S);
1798
1799
1800 /**
1801 * @brief Initialization function for the Q15 PID Control.
1802 * @param[in,out] S points to an instance of the Q15 PID structure.
1803 * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state.
1804 */
1805 void arm_pid_init_q15(
1806 arm_pid_instance_q15 * S,
1807 int32_t resetStateFlag);
1808
1809
1810 /**
1811 * @brief Reset function for the Q15 PID Control.
1812 * @param[in,out] S points to an instance of the q15 PID Control structure
1813 */
1814 void arm_pid_reset_q15(
1815 arm_pid_instance_q15 * S);
1816
1817
1818 /**
1819 * @brief Instance structure for the floating-point Linear Interpolate function.
1820 */
1821 typedef struct
1822 {
1823 uint32_t nValues; /**< nValues */
1824 float32_t x1; /**< x1 */
1825 float32_t xSpacing; /**< xSpacing */
1826 float32_t *pYData; /**< pointer to the table of Y values */
1827 } arm_linear_interp_instance_f32;
1828
1829 /**
1830 * @brief Instance structure for the floating-point bilinear interpolation function.
1831 */
1832 typedef struct
1833 {
1834 uint16_t numRows; /**< number of rows in the data table. */
1835 uint16_t numCols; /**< number of columns in the data table. */
1836 float32_t *pData; /**< points to the data table. */
1837 } arm_bilinear_interp_instance_f32;
1838
1839 /**
1840 * @brief Instance structure for the Q31 bilinear interpolation function.
1841 */
1842 typedef struct
1843 {
1844 uint16_t numRows; /**< number of rows in the data table. */
1845 uint16_t numCols; /**< number of columns in the data table. */
1846 q31_t *pData; /**< points to the data table. */
1847 } arm_bilinear_interp_instance_q31;
1848
1849 /**
1850 * @brief Instance structure for the Q15 bilinear interpolation function.
1851 */
1852 typedef struct
1853 {
1854 uint16_t numRows; /**< number of rows in the data table. */
1855 uint16_t numCols; /**< number of columns in the data table. */
1856 q15_t *pData; /**< points to the data table. */
1857 } arm_bilinear_interp_instance_q15;
1858
1859 /**
1860 * @brief Instance structure for the Q15 bilinear interpolation function.
1861 */
1862 typedef struct
1863 {
1864 uint16_t numRows; /**< number of rows in the data table. */
1865 uint16_t numCols; /**< number of columns in the data table. */
1866 q7_t *pData; /**< points to the data table. */
1867 } arm_bilinear_interp_instance_q7;
1868
1869
1870 /**
1871 * @brief Q7 vector multiplication.
1872 * @param[in] pSrcA points to the first input vector
1873 * @param[in] pSrcB points to the second input vector
1874 * @param[out] pDst points to the output vector
1875 * @param[in] blockSize number of samples in each vector
1876 */
1877 void arm_mult_q7(
1878 q7_t * pSrcA,
1879 q7_t * pSrcB,
1880 q7_t * pDst,
1881 uint32_t blockSize);
1882
1883
1884 /**
1885 * @brief Q15 vector multiplication.
1886 * @param[in] pSrcA points to the first input vector
1887 * @param[in] pSrcB points to the second input vector
1888 * @param[out] pDst points to the output vector
1889 * @param[in] blockSize number of samples in each vector
1890 */
1891 void arm_mult_q15(
1892 q15_t * pSrcA,
1893 q15_t * pSrcB,
1894 q15_t * pDst,
1895 uint32_t blockSize);
1896
1897
1898 /**
1899 * @brief Q31 vector multiplication.
1900 * @param[in] pSrcA points to the first input vector
1901 * @param[in] pSrcB points to the second input vector
1902 * @param[out] pDst points to the output vector
1903 * @param[in] blockSize number of samples in each vector
1904 */
1905 void arm_mult_q31(
1906 q31_t * pSrcA,
1907 q31_t * pSrcB,
1908 q31_t * pDst,
1909 uint32_t blockSize);
1910
1911
1912 /**
1913 * @brief Floating-point vector multiplication.
1914 * @param[in] pSrcA points to the first input vector
1915 * @param[in] pSrcB points to the second input vector
1916 * @param[out] pDst points to the output vector
1917 * @param[in] blockSize number of samples in each vector
1918 */
1919 void arm_mult_f32(
1920 float32_t * pSrcA,
1921 float32_t * pSrcB,
1922 float32_t * pDst,
1923 uint32_t blockSize);
1924
1925
1926 /**
1927 * @brief Instance structure for the Q15 CFFT/CIFFT function.
1928 */
1929 typedef struct
1930 {
1931 uint16_t fftLen; /**< length of the FFT. */
1932 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
1933 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
1934 q15_t *pTwiddle; /**< points to the Sin twiddle factor table. */
1935 uint16_t *pBitRevTable; /**< points to the bit reversal table. */
1936 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
1937 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
1938 } arm_cfft_radix2_instance_q15;
1939
1940/* Deprecated */
1941 arm_status arm_cfft_radix2_init_q15(
1942 arm_cfft_radix2_instance_q15 * S,
1943 uint16_t fftLen,
1944 uint8_t ifftFlag,
1945 uint8_t bitReverseFlag);
1946
1947/* Deprecated */
1948 void arm_cfft_radix2_q15(
1949 const arm_cfft_radix2_instance_q15 * S,
1950 q15_t * pSrc);
1951
1952
1953 /**
1954 * @brief Instance structure for the Q15 CFFT/CIFFT function.
1955 */
1956 typedef struct
1957 {
1958 uint16_t fftLen; /**< length of the FFT. */
1959 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
1960 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
1961 q15_t *pTwiddle; /**< points to the twiddle factor table. */
1962 uint16_t *pBitRevTable; /**< points to the bit reversal table. */
1963 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
1964 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
1965 } arm_cfft_radix4_instance_q15;
1966
1967/* Deprecated */
1968 arm_status arm_cfft_radix4_init_q15(
1969 arm_cfft_radix4_instance_q15 * S,
1970 uint16_t fftLen,
1971 uint8_t ifftFlag,
1972 uint8_t bitReverseFlag);
1973
1974/* Deprecated */
1975 void arm_cfft_radix4_q15(
1976 const arm_cfft_radix4_instance_q15 * S,
1977 q15_t * pSrc);
1978
1979 /**
1980 * @brief Instance structure for the Radix-2 Q31 CFFT/CIFFT function.
1981 */
1982 typedef struct
1983 {
1984 uint16_t fftLen; /**< length of the FFT. */
1985 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
1986 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
1987 q31_t *pTwiddle; /**< points to the Twiddle factor table. */
1988 uint16_t *pBitRevTable; /**< points to the bit reversal table. */
1989 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
1990 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
1991 } arm_cfft_radix2_instance_q31;
1992
1993/* Deprecated */
1994 arm_status arm_cfft_radix2_init_q31(
1995 arm_cfft_radix2_instance_q31 * S,
1996 uint16_t fftLen,
1997 uint8_t ifftFlag,
1998 uint8_t bitReverseFlag);
1999
2000/* Deprecated */
2001 void arm_cfft_radix2_q31(
2002 const arm_cfft_radix2_instance_q31 * S,
2003 q31_t * pSrc);
2004
2005 /**
2006 * @brief Instance structure for the Q31 CFFT/CIFFT function.
2007 */
2008 typedef struct
2009 {
2010 uint16_t fftLen; /**< length of the FFT. */
2011 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
2012 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
2013 q31_t *pTwiddle; /**< points to the twiddle factor table. */
2014 uint16_t *pBitRevTable; /**< points to the bit reversal table. */
2015 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
2016 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
2017 } arm_cfft_radix4_instance_q31;
2018
2019/* Deprecated */
2020 void arm_cfft_radix4_q31(
2021 const arm_cfft_radix4_instance_q31 * S,
2022 q31_t * pSrc);
2023
2024/* Deprecated */
2025 arm_status arm_cfft_radix4_init_q31(
2026 arm_cfft_radix4_instance_q31 * S,
2027 uint16_t fftLen,
2028 uint8_t ifftFlag,
2029 uint8_t bitReverseFlag);
2030
2031 /**
2032 * @brief Instance structure for the floating-point CFFT/CIFFT function.
2033 */
2034 typedef struct
2035 {
2036 uint16_t fftLen; /**< length of the FFT. */
2037 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
2038 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
2039 float32_t *pTwiddle; /**< points to the Twiddle factor table. */
2040 uint16_t *pBitRevTable; /**< points to the bit reversal table. */
2041 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
2042 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
2043 float32_t onebyfftLen; /**< value of 1/fftLen. */
2044 } arm_cfft_radix2_instance_f32;
2045
2046/* Deprecated */
2047 arm_status arm_cfft_radix2_init_f32(
2048 arm_cfft_radix2_instance_f32 * S,
2049 uint16_t fftLen,
2050 uint8_t ifftFlag,
2051 uint8_t bitReverseFlag);
2052
2053/* Deprecated */
2054 void arm_cfft_radix2_f32(
2055 const arm_cfft_radix2_instance_f32 * S,
2056 float32_t * pSrc);
2057
2058 /**
2059 * @brief Instance structure for the floating-point CFFT/CIFFT function.
2060 */
2061 typedef struct
2062 {
2063 uint16_t fftLen; /**< length of the FFT. */
2064 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
2065 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
2066 float32_t *pTwiddle; /**< points to the Twiddle factor table. */
2067 uint16_t *pBitRevTable; /**< points to the bit reversal table. */
2068 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
2069 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
2070 float32_t onebyfftLen; /**< value of 1/fftLen. */
2071 } arm_cfft_radix4_instance_f32;
2072
2073/* Deprecated */
2074 arm_status arm_cfft_radix4_init_f32(
2075 arm_cfft_radix4_instance_f32 * S,
2076 uint16_t fftLen,
2077 uint8_t ifftFlag,
2078 uint8_t bitReverseFlag);
2079
2080/* Deprecated */
2081 void arm_cfft_radix4_f32(
2082 const arm_cfft_radix4_instance_f32 * S,
2083 float32_t * pSrc);
2084
2085 /**
2086 * @brief Instance structure for the fixed-point CFFT/CIFFT function.
2087 */
2088 typedef struct
2089 {
2090 uint16_t fftLen; /**< length of the FFT. */
2091 const q15_t *pTwiddle; /**< points to the Twiddle factor table. */
2092 const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
2093 uint16_t bitRevLength; /**< bit reversal table length. */
2094 } arm_cfft_instance_q15;
2095
2096void arm_cfft_q15(
2097 const arm_cfft_instance_q15 * S,
2098 q15_t * p1,
2099 uint8_t ifftFlag,
2100 uint8_t bitReverseFlag);
2101
2102 /**
2103 * @brief Instance structure for the fixed-point CFFT/CIFFT function.
2104 */
2105 typedef struct
2106 {
2107 uint16_t fftLen; /**< length of the FFT. */
2108 const q31_t *pTwiddle; /**< points to the Twiddle factor table. */
2109 const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
2110 uint16_t bitRevLength; /**< bit reversal table length. */
2111 } arm_cfft_instance_q31;
2112
2113void arm_cfft_q31(
2114 const arm_cfft_instance_q31 * S,
2115 q31_t * p1,
2116 uint8_t ifftFlag,
2117 uint8_t bitReverseFlag);
2118
2119 /**
2120 * @brief Instance structure for the floating-point CFFT/CIFFT function.
2121 */
2122 typedef struct
2123 {
2124 uint16_t fftLen; /**< length of the FFT. */
2125 const float32_t *pTwiddle; /**< points to the Twiddle factor table. */
2126 const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
2127 uint16_t bitRevLength; /**< bit reversal table length. */
2128 } arm_cfft_instance_f32;
2129
2130 void arm_cfft_f32(
2131 const arm_cfft_instance_f32 * S,
2132 float32_t * p1,
2133 uint8_t ifftFlag,
2134 uint8_t bitReverseFlag);
2135
2136 /**
2137 * @brief Instance structure for the Q15 RFFT/RIFFT function.
2138 */
2139 typedef struct
2140 {
2141 uint32_t fftLenReal; /**< length of the real FFT. */
2142 uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
2143 uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
2144 uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
2145 q15_t *pTwiddleAReal; /**< points to the real twiddle factor table. */
2146 q15_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */
2147 const arm_cfft_instance_q15 *pCfft; /**< points to the complex FFT instance. */
2148 } arm_rfft_instance_q15;
2149
2150 arm_status arm_rfft_init_q15(
2151 arm_rfft_instance_q15 * S,
2152 uint32_t fftLenReal,
2153 uint32_t ifftFlagR,
2154 uint32_t bitReverseFlag);
2155
2156 void arm_rfft_q15(
2157 const arm_rfft_instance_q15 * S,
2158 q15_t * pSrc,
2159 q15_t * pDst);
2160
2161 /**
2162 * @brief Instance structure for the Q31 RFFT/RIFFT function.
2163 */
2164 typedef struct
2165 {
2166 uint32_t fftLenReal; /**< length of the real FFT. */
2167 uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
2168 uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
2169 uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
2170 q31_t *pTwiddleAReal; /**< points to the real twiddle factor table. */
2171 q31_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */
2172 const arm_cfft_instance_q31 *pCfft; /**< points to the complex FFT instance. */
2173 } arm_rfft_instance_q31;
2174
2175 arm_status arm_rfft_init_q31(
2176 arm_rfft_instance_q31 * S,
2177 uint32_t fftLenReal,
2178 uint32_t ifftFlagR,
2179 uint32_t bitReverseFlag);
2180
2181 void arm_rfft_q31(
2182 const arm_rfft_instance_q31 * S,
2183 q31_t * pSrc,
2184 q31_t * pDst);
2185
2186 /**
2187 * @brief Instance structure for the floating-point RFFT/RIFFT function.
2188 */
2189 typedef struct
2190 {
2191 uint32_t fftLenReal; /**< length of the real FFT. */
2192 uint16_t fftLenBy2; /**< length of the complex FFT. */
2193 uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
2194 uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
2195 uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
2196 float32_t *pTwiddleAReal; /**< points to the real twiddle factor table. */
2197 float32_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */
2198 arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */
2199 } arm_rfft_instance_f32;
2200
2201 arm_status arm_rfft_init_f32(
2202 arm_rfft_instance_f32 * S,
2203 arm_cfft_radix4_instance_f32 * S_CFFT,
2204 uint32_t fftLenReal,
2205 uint32_t ifftFlagR,
2206 uint32_t bitReverseFlag);
2207
2208 void arm_rfft_f32(
2209 const arm_rfft_instance_f32 * S,
2210 float32_t * pSrc,
2211 float32_t * pDst);
2212
2213 /**
2214 * @brief Instance structure for the floating-point RFFT/RIFFT function.
2215 */
2216typedef struct
2217 {
2218 arm_cfft_instance_f32 Sint; /**< Internal CFFT structure. */
2219 uint16_t fftLenRFFT; /**< length of the real sequence */
2220 float32_t * pTwiddleRFFT; /**< Twiddle factors real stage */
2221 } arm_rfft_fast_instance_f32 ;
2222
2223arm_status arm_rfft_fast_init_f32 (
2224 arm_rfft_fast_instance_f32 * S,
2225 uint16_t fftLen);
2226
2227void arm_rfft_fast_f32(
2228 arm_rfft_fast_instance_f32 * S,
2229 float32_t * p, float32_t * pOut,
2230 uint8_t ifftFlag);
2231
2232 /**
2233 * @brief Instance structure for the floating-point DCT4/IDCT4 function.
2234 */
2235 typedef struct
2236 {
2237 uint16_t N; /**< length of the DCT4. */
2238 uint16_t Nby2; /**< half of the length of the DCT4. */
2239 float32_t normalize; /**< normalizing factor. */
2240 float32_t *pTwiddle; /**< points to the twiddle factor table. */
2241 float32_t *pCosFactor; /**< points to the cosFactor table. */
2242 arm_rfft_instance_f32 *pRfft; /**< points to the real FFT instance. */
2243 arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */
2244 } arm_dct4_instance_f32;
2245
2246
2247 /**
2248 * @brief Initialization function for the floating-point DCT4/IDCT4.
2249 * @param[in,out] S points to an instance of floating-point DCT4/IDCT4 structure.
2250 * @param[in] S_RFFT points to an instance of floating-point RFFT/RIFFT structure.
2251 * @param[in] S_CFFT points to an instance of floating-point CFFT/CIFFT structure.
2252 * @param[in] N length of the DCT4.
2253 * @param[in] Nby2 half of the length of the DCT4.
2254 * @param[in] normalize normalizing factor.
2255 * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>fftLenReal</code> is not a supported transform length.
2256 */
2257 arm_status arm_dct4_init_f32(
2258 arm_dct4_instance_f32 * S,
2259 arm_rfft_instance_f32 * S_RFFT,
2260 arm_cfft_radix4_instance_f32 * S_CFFT,
2261 uint16_t N,
2262 uint16_t Nby2,
2263 float32_t normalize);
2264
2265
2266 /**
2267 * @brief Processing function for the floating-point DCT4/IDCT4.
2268 * @param[in] S points to an instance of the floating-point DCT4/IDCT4 structure.
2269 * @param[in] pState points to state buffer.
2270 * @param[in,out] pInlineBuffer points to the in-place input and output buffer.
2271 */
2272 void arm_dct4_f32(
2273 const arm_dct4_instance_f32 * S,
2274 float32_t * pState,
2275 float32_t * pInlineBuffer);
2276
2277
2278 /**
2279 * @brief Instance structure for the Q31 DCT4/IDCT4 function.
2280 */
2281 typedef struct
2282 {
2283 uint16_t N; /**< length of the DCT4. */
2284 uint16_t Nby2; /**< half of the length of the DCT4. */
2285 q31_t normalize; /**< normalizing factor. */
2286 q31_t *pTwiddle; /**< points to the twiddle factor table. */
2287 q31_t *pCosFactor; /**< points to the cosFactor table. */
2288 arm_rfft_instance_q31 *pRfft; /**< points to the real FFT instance. */
2289 arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */
2290 } arm_dct4_instance_q31;
2291
2292
2293 /**
2294 * @brief Initialization function for the Q31 DCT4/IDCT4.
2295 * @param[in,out] S points to an instance of Q31 DCT4/IDCT4 structure.
2296 * @param[in] S_RFFT points to an instance of Q31 RFFT/RIFFT structure
2297 * @param[in] S_CFFT points to an instance of Q31 CFFT/CIFFT structure
2298 * @param[in] N length of the DCT4.
2299 * @param[in] Nby2 half of the length of the DCT4.
2300 * @param[in] normalize normalizing factor.
2301 * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>N</code> is not a supported transform length.
2302 */
2303 arm_status arm_dct4_init_q31(
2304 arm_dct4_instance_q31 * S,
2305 arm_rfft_instance_q31 * S_RFFT,
2306 arm_cfft_radix4_instance_q31 * S_CFFT,
2307 uint16_t N,
2308 uint16_t Nby2,
2309 q31_t normalize);
2310
2311
2312 /**
2313 * @brief Processing function for the Q31 DCT4/IDCT4.
2314 * @param[in] S points to an instance of the Q31 DCT4 structure.
2315 * @param[in] pState points to state buffer.
2316 * @param[in,out] pInlineBuffer points to the in-place input and output buffer.
2317 */
2318 void arm_dct4_q31(
2319 const arm_dct4_instance_q31 * S,
2320 q31_t * pState,
2321 q31_t * pInlineBuffer);
2322
2323
2324 /**
2325 * @brief Instance structure for the Q15 DCT4/IDCT4 function.
2326 */
2327 typedef struct
2328 {
2329 uint16_t N; /**< length of the DCT4. */
2330 uint16_t Nby2; /**< half of the length of the DCT4. */
2331 q15_t normalize; /**< normalizing factor. */
2332 q15_t *pTwiddle; /**< points to the twiddle factor table. */
2333 q15_t *pCosFactor; /**< points to the cosFactor table. */
2334 arm_rfft_instance_q15 *pRfft; /**< points to the real FFT instance. */
2335 arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */
2336 } arm_dct4_instance_q15;
2337
2338
2339 /**
2340 * @brief Initialization function for the Q15 DCT4/IDCT4.
2341 * @param[in,out] S points to an instance of Q15 DCT4/IDCT4 structure.
2342 * @param[in] S_RFFT points to an instance of Q15 RFFT/RIFFT structure.
2343 * @param[in] S_CFFT points to an instance of Q15 CFFT/CIFFT structure.
2344 * @param[in] N length of the DCT4.
2345 * @param[in] Nby2 half of the length of the DCT4.
2346 * @param[in] normalize normalizing factor.
2347 * @return arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>N</code> is not a supported transform length.
2348 */
2349 arm_status arm_dct4_init_q15(
2350 arm_dct4_instance_q15 * S,
2351 arm_rfft_instance_q15 * S_RFFT,
2352 arm_cfft_radix4_instance_q15 * S_CFFT,
2353 uint16_t N,
2354 uint16_t Nby2,
2355 q15_t normalize);
2356
2357
2358 /**
2359 * @brief Processing function for the Q15 DCT4/IDCT4.
2360 * @param[in] S points to an instance of the Q15 DCT4 structure.
2361 * @param[in] pState points to state buffer.
2362 * @param[in,out] pInlineBuffer points to the in-place input and output buffer.
2363 */
2364 void arm_dct4_q15(
2365 const arm_dct4_instance_q15 * S,
2366 q15_t * pState,
2367 q15_t * pInlineBuffer);
2368
2369
2370 /**
2371 * @brief Floating-point vector addition.
2372 * @param[in] pSrcA points to the first input vector
2373 * @param[in] pSrcB points to the second input vector
2374 * @param[out] pDst points to the output vector
2375 * @param[in] blockSize number of samples in each vector
2376 */
2377 void arm_add_f32(
2378 float32_t * pSrcA,
2379 float32_t * pSrcB,
2380 float32_t * pDst,
2381 uint32_t blockSize);
2382
2383
2384 /**
2385 * @brief Q7 vector addition.
2386 * @param[in] pSrcA points to the first input vector
2387 * @param[in] pSrcB points to the second input vector
2388 * @param[out] pDst points to the output vector
2389 * @param[in] blockSize number of samples in each vector
2390 */
2391 void arm_add_q7(
2392 q7_t * pSrcA,
2393 q7_t * pSrcB,
2394 q7_t * pDst,
2395 uint32_t blockSize);
2396
2397
2398 /**
2399 * @brief Q15 vector addition.
2400 * @param[in] pSrcA points to the first input vector
2401 * @param[in] pSrcB points to the second input vector
2402 * @param[out] pDst points to the output vector
2403 * @param[in] blockSize number of samples in each vector
2404 */
2405 void arm_add_q15(
2406 q15_t * pSrcA,
2407 q15_t * pSrcB,
2408 q15_t * pDst,
2409 uint32_t blockSize);
2410
2411
2412 /**
2413 * @brief Q31 vector addition.
2414 * @param[in] pSrcA points to the first input vector
2415 * @param[in] pSrcB points to the second input vector
2416 * @param[out] pDst points to the output vector
2417 * @param[in] blockSize number of samples in each vector
2418 */
2419 void arm_add_q31(
2420 q31_t * pSrcA,
2421 q31_t * pSrcB,
2422 q31_t * pDst,
2423 uint32_t blockSize);
2424
2425
2426 /**
2427 * @brief Floating-point vector subtraction.
2428 * @param[in] pSrcA points to the first input vector
2429 * @param[in] pSrcB points to the second input vector
2430 * @param[out] pDst points to the output vector
2431 * @param[in] blockSize number of samples in each vector
2432 */
2433 void arm_sub_f32(
2434 float32_t * pSrcA,
2435 float32_t * pSrcB,
2436 float32_t * pDst,
2437 uint32_t blockSize);
2438
2439
2440 /**
2441 * @brief Q7 vector subtraction.
2442 * @param[in] pSrcA points to the first input vector
2443 * @param[in] pSrcB points to the second input vector
2444 * @param[out] pDst points to the output vector
2445 * @param[in] blockSize number of samples in each vector
2446 */
2447 void arm_sub_q7(
2448 q7_t * pSrcA,
2449 q7_t * pSrcB,
2450 q7_t * pDst,
2451 uint32_t blockSize);
2452
2453
2454 /**
2455 * @brief Q15 vector subtraction.
2456 * @param[in] pSrcA points to the first input vector
2457 * @param[in] pSrcB points to the second input vector
2458 * @param[out] pDst points to the output vector
2459 * @param[in] blockSize number of samples in each vector
2460 */
2461 void arm_sub_q15(
2462 q15_t * pSrcA,
2463 q15_t * pSrcB,
2464 q15_t * pDst,
2465 uint32_t blockSize);
2466
2467
2468 /**
2469 * @brief Q31 vector subtraction.
2470 * @param[in] pSrcA points to the first input vector
2471 * @param[in] pSrcB points to the second input vector
2472 * @param[out] pDst points to the output vector
2473 * @param[in] blockSize number of samples in each vector
2474 */
2475 void arm_sub_q31(
2476 q31_t * pSrcA,
2477 q31_t * pSrcB,
2478 q31_t * pDst,
2479 uint32_t blockSize);
2480
2481
2482 /**
2483 * @brief Multiplies a floating-point vector by a scalar.
2484 * @param[in] pSrc points to the input vector
2485 * @param[in] scale scale factor to be applied
2486 * @param[out] pDst points to the output vector
2487 * @param[in] blockSize number of samples in the vector
2488 */
2489 void arm_scale_f32(
2490 float32_t * pSrc,
2491 float32_t scale,
2492 float32_t * pDst,
2493 uint32_t blockSize);
2494
2495
2496 /**
2497 * @brief Multiplies a Q7 vector by a scalar.
2498 * @param[in] pSrc points to the input vector
2499 * @param[in] scaleFract fractional portion of the scale value
2500 * @param[in] shift number of bits to shift the result by
2501 * @param[out] pDst points to the output vector
2502 * @param[in] blockSize number of samples in the vector
2503 */
2504 void arm_scale_q7(
2505 q7_t * pSrc,
2506 q7_t scaleFract,
2507 int8_t shift,
2508 q7_t * pDst,
2509 uint32_t blockSize);
2510
2511
2512 /**
2513 * @brief Multiplies a Q15 vector by a scalar.
2514 * @param[in] pSrc points to the input vector
2515 * @param[in] scaleFract fractional portion of the scale value
2516 * @param[in] shift number of bits to shift the result by
2517 * @param[out] pDst points to the output vector
2518 * @param[in] blockSize number of samples in the vector
2519 */
2520 void arm_scale_q15(
2521 q15_t * pSrc,
2522 q15_t scaleFract,
2523 int8_t shift,
2524 q15_t * pDst,
2525 uint32_t blockSize);
2526
2527
2528 /**
2529 * @brief Multiplies a Q31 vector by a scalar.
2530 * @param[in] pSrc points to the input vector
2531 * @param[in] scaleFract fractional portion of the scale value
2532 * @param[in] shift number of bits to shift the result by
2533 * @param[out] pDst points to the output vector
2534 * @param[in] blockSize number of samples in the vector
2535 */
2536 void arm_scale_q31(
2537 q31_t * pSrc,
2538 q31_t scaleFract,
2539 int8_t shift,
2540 q31_t * pDst,
2541 uint32_t blockSize);
2542
2543
2544 /**
2545 * @brief Q7 vector absolute value.
2546 * @param[in] pSrc points to the input buffer
2547 * @param[out] pDst points to the output buffer
2548 * @param[in] blockSize number of samples in each vector
2549 */
2550 void arm_abs_q7(
2551 q7_t * pSrc,
2552 q7_t * pDst,
2553 uint32_t blockSize);
2554
2555
2556 /**
2557 * @brief Floating-point vector absolute value.
2558 * @param[in] pSrc points to the input buffer
2559 * @param[out] pDst points to the output buffer
2560 * @param[in] blockSize number of samples in each vector
2561 */
2562 void arm_abs_f32(
2563 float32_t * pSrc,
2564 float32_t * pDst,
2565 uint32_t blockSize);
2566
2567
2568 /**
2569 * @brief Q15 vector absolute value.
2570 * @param[in] pSrc points to the input buffer
2571 * @param[out] pDst points to the output buffer
2572 * @param[in] blockSize number of samples in each vector
2573 */
2574 void arm_abs_q15(
2575 q15_t * pSrc,
2576 q15_t * pDst,
2577 uint32_t blockSize);
2578
2579
2580 /**
2581 * @brief Q31 vector absolute value.
2582 * @param[in] pSrc points to the input buffer
2583 * @param[out] pDst points to the output buffer
2584 * @param[in] blockSize number of samples in each vector
2585 */
2586 void arm_abs_q31(
2587 q31_t * pSrc,
2588 q31_t * pDst,
2589 uint32_t blockSize);
2590
2591
2592 /**
2593 * @brief Dot product of floating-point vectors.
2594 * @param[in] pSrcA points to the first input vector
2595 * @param[in] pSrcB points to the second input vector
2596 * @param[in] blockSize number of samples in each vector
2597 * @param[out] result output result returned here
2598 */
2599 void arm_dot_prod_f32(
2600 float32_t * pSrcA,
2601 float32_t * pSrcB,
2602 uint32_t blockSize,
2603 float32_t * result);
2604
2605
2606 /**
2607 * @brief Dot product of Q7 vectors.
2608 * @param[in] pSrcA points to the first input vector
2609 * @param[in] pSrcB points to the second input vector
2610 * @param[in] blockSize number of samples in each vector
2611 * @param[out] result output result returned here
2612 */
2613 void arm_dot_prod_q7(
2614 q7_t * pSrcA,
2615 q7_t * pSrcB,
2616 uint32_t blockSize,
2617 q31_t * result);
2618
2619
2620 /**
2621 * @brief Dot product of Q15 vectors.
2622 * @param[in] pSrcA points to the first input vector
2623 * @param[in] pSrcB points to the second input vector
2624 * @param[in] blockSize number of samples in each vector
2625 * @param[out] result output result returned here
2626 */
2627 void arm_dot_prod_q15(
2628 q15_t * pSrcA,
2629 q15_t * pSrcB,
2630 uint32_t blockSize,
2631 q63_t * result);
2632
2633
2634 /**
2635 * @brief Dot product of Q31 vectors.
2636 * @param[in] pSrcA points to the first input vector
2637 * @param[in] pSrcB points to the second input vector
2638 * @param[in] blockSize number of samples in each vector
2639 * @param[out] result output result returned here
2640 */
2641 void arm_dot_prod_q31(
2642 q31_t * pSrcA,
2643 q31_t * pSrcB,
2644 uint32_t blockSize,
2645 q63_t * result);
2646
2647
2648 /**
2649 * @brief Shifts the elements of a Q7 vector a specified number of bits.
2650 * @param[in] pSrc points to the input vector
2651 * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right.
2652 * @param[out] pDst points to the output vector
2653 * @param[in] blockSize number of samples in the vector
2654 */
2655 void arm_shift_q7(
2656 q7_t * pSrc,
2657 int8_t shiftBits,
2658 q7_t * pDst,
2659 uint32_t blockSize);
2660
2661
2662 /**
2663 * @brief Shifts the elements of a Q15 vector a specified number of bits.
2664 * @param[in] pSrc points to the input vector
2665 * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right.
2666 * @param[out] pDst points to the output vector
2667 * @param[in] blockSize number of samples in the vector
2668 */
2669 void arm_shift_q15(
2670 q15_t * pSrc,
2671 int8_t shiftBits,
2672 q15_t * pDst,
2673 uint32_t blockSize);
2674
2675
2676 /**
2677 * @brief Shifts the elements of a Q31 vector a specified number of bits.
2678 * @param[in] pSrc points to the input vector
2679 * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right.
2680 * @param[out] pDst points to the output vector
2681 * @param[in] blockSize number of samples in the vector
2682 */
2683 void arm_shift_q31(
2684 q31_t * pSrc,
2685 int8_t shiftBits,
2686 q31_t * pDst,
2687 uint32_t blockSize);
2688
2689
2690 /**
2691 * @brief Adds a constant offset to a floating-point vector.
2692 * @param[in] pSrc points to the input vector
2693 * @param[in] offset is the offset to be added
2694 * @param[out] pDst points to the output vector
2695 * @param[in] blockSize number of samples in the vector
2696 */
2697 void arm_offset_f32(
2698 float32_t * pSrc,
2699 float32_t offset,
2700 float32_t * pDst,
2701 uint32_t blockSize);
2702
2703
2704 /**
2705 * @brief Adds a constant offset to a Q7 vector.
2706 * @param[in] pSrc points to the input vector
2707 * @param[in] offset is the offset to be added
2708 * @param[out] pDst points to the output vector
2709 * @param[in] blockSize number of samples in the vector
2710 */
2711 void arm_offset_q7(
2712 q7_t * pSrc,
2713 q7_t offset,
2714 q7_t * pDst,
2715 uint32_t blockSize);
2716
2717
2718 /**
2719 * @brief Adds a constant offset to a Q15 vector.
2720 * @param[in] pSrc points to the input vector
2721 * @param[in] offset is the offset to be added
2722 * @param[out] pDst points to the output vector
2723 * @param[in] blockSize number of samples in the vector
2724 */
2725 void arm_offset_q15(
2726 q15_t * pSrc,
2727 q15_t offset,
2728 q15_t * pDst,
2729 uint32_t blockSize);
2730
2731
2732 /**
2733 * @brief Adds a constant offset to a Q31 vector.
2734 * @param[in] pSrc points to the input vector
2735 * @param[in] offset is the offset to be added
2736 * @param[out] pDst points to the output vector
2737 * @param[in] blockSize number of samples in the vector
2738 */
2739 void arm_offset_q31(
2740 q31_t * pSrc,
2741 q31_t offset,
2742 q31_t * pDst,
2743 uint32_t blockSize);
2744
2745
2746 /**
2747 * @brief Negates the elements of a floating-point vector.
2748 * @param[in] pSrc points to the input vector
2749 * @param[out] pDst points to the output vector
2750 * @param[in] blockSize number of samples in the vector
2751 */
2752 void arm_negate_f32(
2753 float32_t * pSrc,
2754 float32_t * pDst,
2755 uint32_t blockSize);
2756
2757
2758 /**
2759 * @brief Negates the elements of a Q7 vector.
2760 * @param[in] pSrc points to the input vector
2761 * @param[out] pDst points to the output vector
2762 * @param[in] blockSize number of samples in the vector
2763 */
2764 void arm_negate_q7(
2765 q7_t * pSrc,
2766 q7_t * pDst,
2767 uint32_t blockSize);
2768
2769
2770 /**
2771 * @brief Negates the elements of a Q15 vector.
2772 * @param[in] pSrc points to the input vector
2773 * @param[out] pDst points to the output vector
2774 * @param[in] blockSize number of samples in the vector
2775 */
2776 void arm_negate_q15(
2777 q15_t * pSrc,
2778 q15_t * pDst,
2779 uint32_t blockSize);
2780
2781
2782 /**
2783 * @brief Negates the elements of a Q31 vector.
2784 * @param[in] pSrc points to the input vector
2785 * @param[out] pDst points to the output vector
2786 * @param[in] blockSize number of samples in the vector
2787 */
2788 void arm_negate_q31(
2789 q31_t * pSrc,
2790 q31_t * pDst,
2791 uint32_t blockSize);
2792
2793
2794 /**
2795 * @brief Copies the elements of a floating-point vector.
2796 * @param[in] pSrc input pointer
2797 * @param[out] pDst output pointer
2798 * @param[in] blockSize number of samples to process
2799 */
2800 void arm_copy_f32(
2801 float32_t * pSrc,
2802 float32_t * pDst,
2803 uint32_t blockSize);
2804
2805
2806 /**
2807 * @brief Copies the elements of a Q7 vector.
2808 * @param[in] pSrc input pointer
2809 * @param[out] pDst output pointer
2810 * @param[in] blockSize number of samples to process
2811 */
2812 void arm_copy_q7(
2813 q7_t * pSrc,
2814 q7_t * pDst,
2815 uint32_t blockSize);
2816
2817
2818 /**
2819 * @brief Copies the elements of a Q15 vector.
2820 * @param[in] pSrc input pointer
2821 * @param[out] pDst output pointer
2822 * @param[in] blockSize number of samples to process
2823 */
2824 void arm_copy_q15(
2825 q15_t * pSrc,
2826 q15_t * pDst,
2827 uint32_t blockSize);
2828
2829
2830 /**
2831 * @brief Copies the elements of a Q31 vector.
2832 * @param[in] pSrc input pointer
2833 * @param[out] pDst output pointer
2834 * @param[in] blockSize number of samples to process
2835 */
2836 void arm_copy_q31(
2837 q31_t * pSrc,
2838 q31_t * pDst,
2839 uint32_t blockSize);
2840
2841
2842 /**
2843 * @brief Fills a constant value into a floating-point vector.
2844 * @param[in] value input value to be filled
2845 * @param[out] pDst output pointer
2846 * @param[in] blockSize number of samples to process
2847 */
2848 void arm_fill_f32(
2849 float32_t value,
2850 float32_t * pDst,
2851 uint32_t blockSize);
2852
2853
2854 /**
2855 * @brief Fills a constant value into a Q7 vector.
2856 * @param[in] value input value to be filled
2857 * @param[out] pDst output pointer
2858 * @param[in] blockSize number of samples to process
2859 */
2860 void arm_fill_q7(
2861 q7_t value,
2862 q7_t * pDst,
2863 uint32_t blockSize);
2864
2865
2866 /**
2867 * @brief Fills a constant value into a Q15 vector.
2868 * @param[in] value input value to be filled
2869 * @param[out] pDst output pointer
2870 * @param[in] blockSize number of samples to process
2871 */
2872 void arm_fill_q15(
2873 q15_t value,
2874 q15_t * pDst,
2875 uint32_t blockSize);
2876
2877
2878 /**
2879 * @brief Fills a constant value into a Q31 vector.
2880 * @param[in] value input value to be filled
2881 * @param[out] pDst output pointer
2882 * @param[in] blockSize number of samples to process
2883 */
2884 void arm_fill_q31(
2885 q31_t value,
2886 q31_t * pDst,
2887 uint32_t blockSize);
2888
2889
2890/**
2891 * @brief Convolution of floating-point sequences.
2892 * @param[in] pSrcA points to the first input sequence.
2893 * @param[in] srcALen length of the first input sequence.
2894 * @param[in] pSrcB points to the second input sequence.
2895 * @param[in] srcBLen length of the second input sequence.
2896 * @param[out] pDst points to the location where the output result is written. Length srcALen+srcBLen-1.
2897 */
2898 void arm_conv_f32(
2899 float32_t * pSrcA,
2900 uint32_t srcALen,
2901 float32_t * pSrcB,
2902 uint32_t srcBLen,
2903 float32_t * pDst);
2904
2905
2906 /**
2907 * @brief Convolution of Q15 sequences.
2908 * @param[in] pSrcA points to the first input sequence.
2909 * @param[in] srcALen length of the first input sequence.
2910 * @param[in] pSrcB points to the second input sequence.
2911 * @param[in] srcBLen length of the second input sequence.
2912 * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
2913 * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
2914 * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen).
2915 */
2916 void arm_conv_opt_q15(
2917 q15_t * pSrcA,
2918 uint32_t srcALen,
2919 q15_t * pSrcB,
2920 uint32_t srcBLen,
2921 q15_t * pDst,
2922 q15_t * pScratch1,
2923 q15_t * pScratch2);
2924
2925
2926/**
2927 * @brief Convolution of Q15 sequences.
2928 * @param[in] pSrcA points to the first input sequence.
2929 * @param[in] srcALen length of the first input sequence.
2930 * @param[in] pSrcB points to the second input sequence.
2931 * @param[in] srcBLen length of the second input sequence.
2932 * @param[out] pDst points to the location where the output result is written. Length srcALen+srcBLen-1.
2933 */
2934 void arm_conv_q15(
2935 q15_t * pSrcA,
2936 uint32_t srcALen,
2937 q15_t * pSrcB,
2938 uint32_t srcBLen,
2939 q15_t * pDst);
2940
2941
2942 /**
2943 * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
2944 * @param[in] pSrcA points to the first input sequence.
2945 * @param[in] srcALen length of the first input sequence.
2946 * @param[in] pSrcB points to the second input sequence.
2947 * @param[in] srcBLen length of the second input sequence.
2948 * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
2949 */
2950 void arm_conv_fast_q15(
2951 q15_t * pSrcA,
2952 uint32_t srcALen,
2953 q15_t * pSrcB,
2954 uint32_t srcBLen,
2955 q15_t * pDst);
2956
2957
2958 /**
2959 * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
2960 * @param[in] pSrcA points to the first input sequence.
2961 * @param[in] srcALen length of the first input sequence.
2962 * @param[in] pSrcB points to the second input sequence.
2963 * @param[in] srcBLen length of the second input sequence.
2964 * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
2965 * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
2966 * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen).
2967 */
2968 void arm_conv_fast_opt_q15(
2969 q15_t * pSrcA,
2970 uint32_t srcALen,
2971 q15_t * pSrcB,
2972 uint32_t srcBLen,
2973 q15_t * pDst,
2974 q15_t * pScratch1,
2975 q15_t * pScratch2);
2976
2977
2978 /**
2979 * @brief Convolution of Q31 sequences.
2980 * @param[in] pSrcA points to the first input sequence.
2981 * @param[in] srcALen length of the first input sequence.
2982 * @param[in] pSrcB points to the second input sequence.
2983 * @param[in] srcBLen length of the second input sequence.
2984 * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
2985 */
2986 void arm_conv_q31(
2987 q31_t * pSrcA,
2988 uint32_t srcALen,
2989 q31_t * pSrcB,
2990 uint32_t srcBLen,
2991 q31_t * pDst);
2992
2993
2994 /**
2995 * @brief Convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4
2996 * @param[in] pSrcA points to the first input sequence.
2997 * @param[in] srcALen length of the first input sequence.
2998 * @param[in] pSrcB points to the second input sequence.
2999 * @param[in] srcBLen length of the second input sequence.
3000 * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
3001 */
3002 void arm_conv_fast_q31(
3003 q31_t * pSrcA,
3004 uint32_t srcALen,
3005 q31_t * pSrcB,
3006 uint32_t srcBLen,
3007 q31_t * pDst);
3008
3009
3010 /**
3011 * @brief Convolution of Q7 sequences.
3012 * @param[in] pSrcA points to the first input sequence.
3013 * @param[in] srcALen length of the first input sequence.
3014 * @param[in] pSrcB points to the second input sequence.
3015 * @param[in] srcBLen length of the second input sequence.
3016 * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
3017 * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
3018 * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
3019 */
3020 void arm_conv_opt_q7(
3021 q7_t * pSrcA,
3022 uint32_t srcALen,
3023 q7_t * pSrcB,
3024 uint32_t srcBLen,
3025 q7_t * pDst,
3026 q15_t * pScratch1,
3027 q15_t * pScratch2);
3028
3029
3030 /**
3031 * @brief Convolution of Q7 sequences.
3032 * @param[in] pSrcA points to the first input sequence.
3033 * @param[in] srcALen length of the first input sequence.
3034 * @param[in] pSrcB points to the second input sequence.
3035 * @param[in] srcBLen length of the second input sequence.
3036 * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
3037 */
3038 void arm_conv_q7(
3039 q7_t * pSrcA,
3040 uint32_t srcALen,
3041 q7_t * pSrcB,
3042 uint32_t srcBLen,
3043 q7_t * pDst);
3044
3045
3046 /**
3047 * @brief Partial convolution of floating-point sequences.
3048 * @param[in] pSrcA points to the first input sequence.
3049 * @param[in] srcALen length of the first input sequence.
3050 * @param[in] pSrcB points to the second input sequence.
3051 * @param[in] srcBLen length of the second input sequence.
3052 * @param[out] pDst points to the block of output data
3053 * @param[in] firstIndex is the first output sample to start with.
3054 * @param[in] numPoints is the number of output points to be computed.
3055 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3056 */
3057 arm_status arm_conv_partial_f32(
3058 float32_t * pSrcA,
3059 uint32_t srcALen,
3060 float32_t * pSrcB,
3061 uint32_t srcBLen,
3062 float32_t * pDst,
3063 uint32_t firstIndex,
3064 uint32_t numPoints);
3065
3066
3067 /**
3068 * @brief Partial convolution of Q15 sequences.
3069 * @param[in] pSrcA points to the first input sequence.
3070 * @param[in] srcALen length of the first input sequence.
3071 * @param[in] pSrcB points to the second input sequence.
3072 * @param[in] srcBLen length of the second input sequence.
3073 * @param[out] pDst points to the block of output data
3074 * @param[in] firstIndex is the first output sample to start with.
3075 * @param[in] numPoints is the number of output points to be computed.
3076 * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
3077 * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen).
3078 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3079 */
3080 arm_status arm_conv_partial_opt_q15(
3081 q15_t * pSrcA,
3082 uint32_t srcALen,
3083 q15_t * pSrcB,
3084 uint32_t srcBLen,
3085 q15_t * pDst,
3086 uint32_t firstIndex,
3087 uint32_t numPoints,
3088 q15_t * pScratch1,
3089 q15_t * pScratch2);
3090
3091
3092 /**
3093 * @brief Partial convolution of Q15 sequences.
3094 * @param[in] pSrcA points to the first input sequence.
3095 * @param[in] srcALen length of the first input sequence.
3096 * @param[in] pSrcB points to the second input sequence.
3097 * @param[in] srcBLen length of the second input sequence.
3098 * @param[out] pDst points to the block of output data
3099 * @param[in] firstIndex is the first output sample to start with.
3100 * @param[in] numPoints is the number of output points to be computed.
3101 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3102 */
3103 arm_status arm_conv_partial_q15(
3104 q15_t * pSrcA,
3105 uint32_t srcALen,
3106 q15_t * pSrcB,
3107 uint32_t srcBLen,
3108 q15_t * pDst,
3109 uint32_t firstIndex,
3110 uint32_t numPoints);
3111
3112
3113 /**
3114 * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
3115 * @param[in] pSrcA points to the first input sequence.
3116 * @param[in] srcALen length of the first input sequence.
3117 * @param[in] pSrcB points to the second input sequence.
3118 * @param[in] srcBLen length of the second input sequence.
3119 * @param[out] pDst points to the block of output data
3120 * @param[in] firstIndex is the first output sample to start with.
3121 * @param[in] numPoints is the number of output points to be computed.
3122 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3123 */
3124 arm_status arm_conv_partial_fast_q15(
3125 q15_t * pSrcA,
3126 uint32_t srcALen,
3127 q15_t * pSrcB,
3128 uint32_t srcBLen,
3129 q15_t * pDst,
3130 uint32_t firstIndex,
3131 uint32_t numPoints);
3132
3133
3134 /**
3135 * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
3136 * @param[in] pSrcA points to the first input sequence.
3137 * @param[in] srcALen length of the first input sequence.
3138 * @param[in] pSrcB points to the second input sequence.
3139 * @param[in] srcBLen length of the second input sequence.
3140 * @param[out] pDst points to the block of output data
3141 * @param[in] firstIndex is the first output sample to start with.
3142 * @param[in] numPoints is the number of output points to be computed.
3143 * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
3144 * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen).
3145 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3146 */
3147 arm_status arm_conv_partial_fast_opt_q15(
3148 q15_t * pSrcA,
3149 uint32_t srcALen,
3150 q15_t * pSrcB,
3151 uint32_t srcBLen,
3152 q15_t * pDst,
3153 uint32_t firstIndex,
3154 uint32_t numPoints,
3155 q15_t * pScratch1,
3156 q15_t * pScratch2);
3157
3158
3159 /**
3160 * @brief Partial convolution of Q31 sequences.
3161 * @param[in] pSrcA points to the first input sequence.
3162 * @param[in] srcALen length of the first input sequence.
3163 * @param[in] pSrcB points to the second input sequence.
3164 * @param[in] srcBLen length of the second input sequence.
3165 * @param[out] pDst points to the block of output data
3166 * @param[in] firstIndex is the first output sample to start with.
3167 * @param[in] numPoints is the number of output points to be computed.
3168 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3169 */
3170 arm_status arm_conv_partial_q31(
3171 q31_t * pSrcA,
3172 uint32_t srcALen,
3173 q31_t * pSrcB,
3174 uint32_t srcBLen,
3175 q31_t * pDst,
3176 uint32_t firstIndex,
3177 uint32_t numPoints);
3178
3179
3180 /**
3181 * @brief Partial convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4
3182 * @param[in] pSrcA points to the first input sequence.
3183 * @param[in] srcALen length of the first input sequence.
3184 * @param[in] pSrcB points to the second input sequence.
3185 * @param[in] srcBLen length of the second input sequence.
3186 * @param[out] pDst points to the block of output data
3187 * @param[in] firstIndex is the first output sample to start with.
3188 * @param[in] numPoints is the number of output points to be computed.
3189 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3190 */
3191 arm_status arm_conv_partial_fast_q31(
3192 q31_t * pSrcA,
3193 uint32_t srcALen,
3194 q31_t * pSrcB,
3195 uint32_t srcBLen,
3196 q31_t * pDst,
3197 uint32_t firstIndex,
3198 uint32_t numPoints);
3199
3200
3201 /**
3202 * @brief Partial convolution of Q7 sequences
3203 * @param[in] pSrcA points to the first input sequence.
3204 * @param[in] srcALen length of the first input sequence.
3205 * @param[in] pSrcB points to the second input sequence.
3206 * @param[in] srcBLen length of the second input sequence.
3207 * @param[out] pDst points to the block of output data
3208 * @param[in] firstIndex is the first output sample to start with.
3209 * @param[in] numPoints is the number of output points to be computed.
3210 * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
3211 * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
3212 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3213 */
3214 arm_status arm_conv_partial_opt_q7(
3215 q7_t * pSrcA,
3216 uint32_t srcALen,
3217 q7_t * pSrcB,
3218 uint32_t srcBLen,
3219 q7_t * pDst,
3220 uint32_t firstIndex,
3221 uint32_t numPoints,
3222 q15_t * pScratch1,
3223 q15_t * pScratch2);
3224
3225
3226/**
3227 * @brief Partial convolution of Q7 sequences.
3228 * @param[in] pSrcA points to the first input sequence.
3229 * @param[in] srcALen length of the first input sequence.
3230 * @param[in] pSrcB points to the second input sequence.
3231 * @param[in] srcBLen length of the second input sequence.
3232 * @param[out] pDst points to the block of output data
3233 * @param[in] firstIndex is the first output sample to start with.
3234 * @param[in] numPoints is the number of output points to be computed.
3235 * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
3236 */
3237 arm_status arm_conv_partial_q7(
3238 q7_t * pSrcA,
3239 uint32_t srcALen,
3240 q7_t * pSrcB,
3241 uint32_t srcBLen,
3242 q7_t * pDst,
3243 uint32_t firstIndex,
3244 uint32_t numPoints);
3245
3246
3247 /**
3248 * @brief Instance structure for the Q15 FIR decimator.
3249 */
3250 typedef struct
3251 {
3252 uint8_t M; /**< decimation factor. */
3253 uint16_t numTaps; /**< number of coefficients in the filter. */
3254 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
3255 q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
3256 } arm_fir_decimate_instance_q15;
3257
3258 /**
3259 * @brief Instance structure for the Q31 FIR decimator.
3260 */
3261 typedef struct
3262 {
3263 uint8_t M; /**< decimation factor. */
3264 uint16_t numTaps; /**< number of coefficients in the filter. */
3265 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
3266 q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
3267 } arm_fir_decimate_instance_q31;
3268
3269 /**
3270 * @brief Instance structure for the floating-point FIR decimator.
3271 */
3272 typedef struct
3273 {
3274 uint8_t M; /**< decimation factor. */
3275 uint16_t numTaps; /**< number of coefficients in the filter. */
3276 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
3277 float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
3278 } arm_fir_decimate_instance_f32;
3279
3280
3281 /**
3282 * @brief Processing function for the floating-point FIR decimator.
3283 * @param[in] S points to an instance of the floating-point FIR decimator structure.
3284 * @param[in] pSrc points to the block of input data.
3285 * @param[out] pDst points to the block of output data
3286 * @param[in] blockSize number of input samples to process per call.
3287 */
3288 void arm_fir_decimate_f32(
3289 const arm_fir_decimate_instance_f32 * S,
3290 float32_t * pSrc,
3291 float32_t * pDst,
3292 uint32_t blockSize);
3293
3294
3295 /**
3296 * @brief Initialization function for the floating-point FIR decimator.
3297 * @param[in,out] S points to an instance of the floating-point FIR decimator structure.
3298 * @param[in] numTaps number of coefficients in the filter.
3299 * @param[in] M decimation factor.
3300 * @param[in] pCoeffs points to the filter coefficients.
3301 * @param[in] pState points to the state buffer.
3302 * @param[in] blockSize number of input samples to process per call.
3303 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
3304 * <code>blockSize</code> is not a multiple of <code>M</code>.
3305 */
3306 arm_status arm_fir_decimate_init_f32(
3307 arm_fir_decimate_instance_f32 * S,
3308 uint16_t numTaps,
3309 uint8_t M,
3310 float32_t * pCoeffs,
3311 float32_t * pState,
3312 uint32_t blockSize);
3313
3314
3315 /**
3316 * @brief Processing function for the Q15 FIR decimator.
3317 * @param[in] S points to an instance of the Q15 FIR decimator structure.
3318 * @param[in] pSrc points to the block of input data.
3319 * @param[out] pDst points to the block of output data
3320 * @param[in] blockSize number of input samples to process per call.
3321 */
3322 void arm_fir_decimate_q15(
3323 const arm_fir_decimate_instance_q15 * S,
3324 q15_t * pSrc,
3325 q15_t * pDst,
3326 uint32_t blockSize);
3327
3328
3329 /**
3330 * @brief Processing function for the Q15 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4.
3331 * @param[in] S points to an instance of the Q15 FIR decimator structure.
3332 * @param[in] pSrc points to the block of input data.
3333 * @param[out] pDst points to the block of output data
3334 * @param[in] blockSize number of input samples to process per call.
3335 */
3336 void arm_fir_decimate_fast_q15(
3337 const arm_fir_decimate_instance_q15 * S,
3338 q15_t * pSrc,
3339 q15_t * pDst,
3340 uint32_t blockSize);
3341
3342
3343 /**
3344 * @brief Initialization function for the Q15 FIR decimator.
3345 * @param[in,out] S points to an instance of the Q15 FIR decimator structure.
3346 * @param[in] numTaps number of coefficients in the filter.
3347 * @param[in] M decimation factor.
3348 * @param[in] pCoeffs points to the filter coefficients.
3349 * @param[in] pState points to the state buffer.
3350 * @param[in] blockSize number of input samples to process per call.
3351 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
3352 * <code>blockSize</code> is not a multiple of <code>M</code>.
3353 */
3354 arm_status arm_fir_decimate_init_q15(
3355 arm_fir_decimate_instance_q15 * S,
3356 uint16_t numTaps,
3357 uint8_t M,
3358 q15_t * pCoeffs,
3359 q15_t * pState,
3360 uint32_t blockSize);
3361
3362
3363 /**
3364 * @brief Processing function for the Q31 FIR decimator.
3365 * @param[in] S points to an instance of the Q31 FIR decimator structure.
3366 * @param[in] pSrc points to the block of input data.
3367 * @param[out] pDst points to the block of output data
3368 * @param[in] blockSize number of input samples to process per call.
3369 */
3370 void arm_fir_decimate_q31(
3371 const arm_fir_decimate_instance_q31 * S,
3372 q31_t * pSrc,
3373 q31_t * pDst,
3374 uint32_t blockSize);
3375
3376 /**
3377 * @brief Processing function for the Q31 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4.
3378 * @param[in] S points to an instance of the Q31 FIR decimator structure.
3379 * @param[in] pSrc points to the block of input data.
3380 * @param[out] pDst points to the block of output data
3381 * @param[in] blockSize number of input samples to process per call.
3382 */
3383 void arm_fir_decimate_fast_q31(
3384 arm_fir_decimate_instance_q31 * S,
3385 q31_t * pSrc,
3386 q31_t * pDst,
3387 uint32_t blockSize);
3388
3389
3390 /**
3391 * @brief Initialization function for the Q31 FIR decimator.
3392 * @param[in,out] S points to an instance of the Q31 FIR decimator structure.
3393 * @param[in] numTaps number of coefficients in the filter.
3394 * @param[in] M decimation factor.
3395 * @param[in] pCoeffs points to the filter coefficients.
3396 * @param[in] pState points to the state buffer.
3397 * @param[in] blockSize number of input samples to process per call.
3398 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
3399 * <code>blockSize</code> is not a multiple of <code>M</code>.
3400 */
3401 arm_status arm_fir_decimate_init_q31(
3402 arm_fir_decimate_instance_q31 * S,
3403 uint16_t numTaps,
3404 uint8_t M,
3405 q31_t * pCoeffs,
3406 q31_t * pState,
3407 uint32_t blockSize);
3408
3409
3410 /**
3411 * @brief Instance structure for the Q15 FIR interpolator.
3412 */
3413 typedef struct
3414 {
3415 uint8_t L; /**< upsample factor. */
3416 uint16_t phaseLength; /**< length of each polyphase filter component. */
3417 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */
3418 q15_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */
3419 } arm_fir_interpolate_instance_q15;
3420
3421 /**
3422 * @brief Instance structure for the Q31 FIR interpolator.
3423 */
3424 typedef struct
3425 {
3426 uint8_t L; /**< upsample factor. */
3427 uint16_t phaseLength; /**< length of each polyphase filter component. */
3428 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */
3429 q31_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */
3430 } arm_fir_interpolate_instance_q31;
3431
3432 /**
3433 * @brief Instance structure for the floating-point FIR interpolator.
3434 */
3435 typedef struct
3436 {
3437 uint8_t L; /**< upsample factor. */
3438 uint16_t phaseLength; /**< length of each polyphase filter component. */
3439 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */
3440 float32_t *pState; /**< points to the state variable array. The array is of length phaseLength+numTaps-1. */
3441 } arm_fir_interpolate_instance_f32;
3442
3443
3444 /**
3445 * @brief Processing function for the Q15 FIR interpolator.
3446 * @param[in] S points to an instance of the Q15 FIR interpolator structure.
3447 * @param[in] pSrc points to the block of input data.
3448 * @param[out] pDst points to the block of output data.
3449 * @param[in] blockSize number of input samples to process per call.
3450 */
3451 void arm_fir_interpolate_q15(
3452 const arm_fir_interpolate_instance_q15 * S,
3453 q15_t * pSrc,
3454 q15_t * pDst,
3455 uint32_t blockSize);
3456
3457
3458 /**
3459 * @brief Initialization function for the Q15 FIR interpolator.
3460 * @param[in,out] S points to an instance of the Q15 FIR interpolator structure.
3461 * @param[in] L upsample factor.
3462 * @param[in] numTaps number of filter coefficients in the filter.
3463 * @param[in] pCoeffs points to the filter coefficient buffer.
3464 * @param[in] pState points to the state buffer.
3465 * @param[in] blockSize number of input samples to process per call.
3466 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
3467 * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.
3468 */
3469 arm_status arm_fir_interpolate_init_q15(
3470 arm_fir_interpolate_instance_q15 * S,
3471 uint8_t L,
3472 uint16_t numTaps,
3473 q15_t * pCoeffs,
3474 q15_t * pState,
3475 uint32_t blockSize);
3476
3477
3478 /**
3479 * @brief Processing function for the Q31 FIR interpolator.
3480 * @param[in] S points to an instance of the Q15 FIR interpolator structure.
3481 * @param[in] pSrc points to the block of input data.
3482 * @param[out] pDst points to the block of output data.
3483 * @param[in] blockSize number of input samples to process per call.
3484 */
3485 void arm_fir_interpolate_q31(
3486 const arm_fir_interpolate_instance_q31 * S,
3487 q31_t * pSrc,
3488 q31_t * pDst,
3489 uint32_t blockSize);
3490
3491
3492 /**
3493 * @brief Initialization function for the Q31 FIR interpolator.
3494 * @param[in,out] S points to an instance of the Q31 FIR interpolator structure.
3495 * @param[in] L upsample factor.
3496 * @param[in] numTaps number of filter coefficients in the filter.
3497 * @param[in] pCoeffs points to the filter coefficient buffer.
3498 * @param[in] pState points to the state buffer.
3499 * @param[in] blockSize number of input samples to process per call.
3500 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
3501 * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.
3502 */
3503 arm_status arm_fir_interpolate_init_q31(
3504 arm_fir_interpolate_instance_q31 * S,
3505 uint8_t L,
3506 uint16_t numTaps,
3507 q31_t * pCoeffs,
3508 q31_t * pState,
3509 uint32_t blockSize);
3510
3511
3512 /**
3513 * @brief Processing function for the floating-point FIR interpolator.
3514 * @param[in] S points to an instance of the floating-point FIR interpolator structure.
3515 * @param[in] pSrc points to the block of input data.
3516 * @param[out] pDst points to the block of output data.
3517 * @param[in] blockSize number of input samples to process per call.
3518 */
3519 void arm_fir_interpolate_f32(
3520 const arm_fir_interpolate_instance_f32 * S,
3521 float32_t * pSrc,
3522 float32_t * pDst,
3523 uint32_t blockSize);
3524
3525
3526 /**
3527 * @brief Initialization function for the floating-point FIR interpolator.
3528 * @param[in,out] S points to an instance of the floating-point FIR interpolator structure.
3529 * @param[in] L upsample factor.
3530 * @param[in] numTaps number of filter coefficients in the filter.
3531 * @param[in] pCoeffs points to the filter coefficient buffer.
3532 * @param[in] pState points to the state buffer.
3533 * @param[in] blockSize number of input samples to process per call.
3534 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
3535 * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.
3536 */
3537 arm_status arm_fir_interpolate_init_f32(
3538 arm_fir_interpolate_instance_f32 * S,
3539 uint8_t L,
3540 uint16_t numTaps,
3541 float32_t * pCoeffs,
3542 float32_t * pState,
3543 uint32_t blockSize);
3544
3545
3546 /**
3547 * @brief Instance structure for the high precision Q31 Biquad cascade filter.
3548 */
3549 typedef struct
3550 {
3551 uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
3552 q63_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */
3553 q31_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
3554 uint8_t postShift; /**< additional shift, in bits, applied to each output sample. */
3555 } arm_biquad_cas_df1_32x64_ins_q31;
3556
3557
3558 /**
3559 * @param[in] S points to an instance of the high precision Q31 Biquad cascade filter structure.
3560 * @param[in] pSrc points to the block of input data.
3561 * @param[out] pDst points to the block of output data
3562 * @param[in] blockSize number of samples to process.
3563 */
3564 void arm_biquad_cas_df1_32x64_q31(
3565 const arm_biquad_cas_df1_32x64_ins_q31 * S,
3566 q31_t * pSrc,
3567 q31_t * pDst,
3568 uint32_t blockSize);
3569
3570
3571 /**
3572 * @param[in,out] S points to an instance of the high precision Q31 Biquad cascade filter structure.
3573 * @param[in] numStages number of 2nd order stages in the filter.
3574 * @param[in] pCoeffs points to the filter coefficients.
3575 * @param[in] pState points to the state buffer.
3576 * @param[in] postShift shift to be applied to the output. Varies according to the coefficients format
3577 */
3578 void arm_biquad_cas_df1_32x64_init_q31(
3579 arm_biquad_cas_df1_32x64_ins_q31 * S,
3580 uint8_t numStages,
3581 q31_t * pCoeffs,
3582 q63_t * pState,
3583 uint8_t postShift);
3584
3585
3586 /**
3587 * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
3588 */
3589 typedef struct
3590 {
3591 uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
3592 float32_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */
3593 float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
3594 } arm_biquad_cascade_df2T_instance_f32;
3595
3596 /**
3597 * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
3598 */
3599 typedef struct
3600 {
3601 uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
3602 float32_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */
3603 float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
3604 } arm_biquad_cascade_stereo_df2T_instance_f32;
3605
3606 /**
3607 * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
3608 */
3609 typedef struct
3610 {
3611 uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
3612 float64_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */
3613 float64_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
3614 } arm_biquad_cascade_df2T_instance_f64;
3615
3616
3617 /**
3618 * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.
3619 * @param[in] S points to an instance of the filter data structure.
3620 * @param[in] pSrc points to the block of input data.
3621 * @param[out] pDst points to the block of output data
3622 * @param[in] blockSize number of samples to process.
3623 */
3624 void arm_biquad_cascade_df2T_f32(
3625 const arm_biquad_cascade_df2T_instance_f32 * S,
3626 float32_t * pSrc,
3627 float32_t * pDst,
3628 uint32_t blockSize);
3629
3630
3631 /**
3632 * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 2 channels
3633 * @param[in] S points to an instance of the filter data structure.
3634 * @param[in] pSrc points to the block of input data.
3635 * @param[out] pDst points to the block of output data
3636 * @param[in] blockSize number of samples to process.
3637 */
3638 void arm_biquad_cascade_stereo_df2T_f32(
3639 const arm_biquad_cascade_stereo_df2T_instance_f32 * S,
3640 float32_t * pSrc,
3641 float32_t * pDst,
3642 uint32_t blockSize);
3643
3644
3645 /**
3646 * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.
3647 * @param[in] S points to an instance of the filter data structure.
3648 * @param[in] pSrc points to the block of input data.
3649 * @param[out] pDst points to the block of output data
3650 * @param[in] blockSize number of samples to process.
3651 */
3652 void arm_biquad_cascade_df2T_f64(
3653 const arm_biquad_cascade_df2T_instance_f64 * S,
3654 float64_t * pSrc,
3655 float64_t * pDst,
3656 uint32_t blockSize);
3657
3658
3659 /**
3660 * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter.
3661 * @param[in,out] S points to an instance of the filter data structure.
3662 * @param[in] numStages number of 2nd order stages in the filter.
3663 * @param[in] pCoeffs points to the filter coefficients.
3664 * @param[in] pState points to the state buffer.
3665 */
3666 void arm_biquad_cascade_df2T_init_f32(
3667 arm_biquad_cascade_df2T_instance_f32 * S,
3668 uint8_t numStages,
3669 float32_t * pCoeffs,
3670 float32_t * pState);
3671
3672
3673 /**
3674 * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter.
3675 * @param[in,out] S points to an instance of the filter data structure.
3676 * @param[in] numStages number of 2nd order stages in the filter.
3677 * @param[in] pCoeffs points to the filter coefficients.
3678 * @param[in] pState points to the state buffer.
3679 */
3680 void arm_biquad_cascade_stereo_df2T_init_f32(
3681 arm_biquad_cascade_stereo_df2T_instance_f32 * S,
3682 uint8_t numStages,
3683 float32_t * pCoeffs,
3684 float32_t * pState);
3685
3686
3687 /**
3688 * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter.
3689 * @param[in,out] S points to an instance of the filter data structure.
3690 * @param[in] numStages number of 2nd order stages in the filter.
3691 * @param[in] pCoeffs points to the filter coefficients.
3692 * @param[in] pState points to the state buffer.
3693 */
3694 void arm_biquad_cascade_df2T_init_f64(
3695 arm_biquad_cascade_df2T_instance_f64 * S,
3696 uint8_t numStages,
3697 float64_t * pCoeffs,
3698 float64_t * pState);
3699
3700
3701 /**
3702 * @brief Instance structure for the Q15 FIR lattice filter.
3703 */
3704 typedef struct
3705 {
3706 uint16_t numStages; /**< number of filter stages. */
3707 q15_t *pState; /**< points to the state variable array. The array is of length numStages. */
3708 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */
3709 } arm_fir_lattice_instance_q15;
3710
3711 /**
3712 * @brief Instance structure for the Q31 FIR lattice filter.
3713 */
3714 typedef struct
3715 {
3716 uint16_t numStages; /**< number of filter stages. */
3717 q31_t *pState; /**< points to the state variable array. The array is of length numStages. */
3718 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */
3719 } arm_fir_lattice_instance_q31;
3720
3721 /**
3722 * @brief Instance structure for the floating-point FIR lattice filter.
3723 */
3724 typedef struct
3725 {
3726 uint16_t numStages; /**< number of filter stages. */
3727 float32_t *pState; /**< points to the state variable array. The array is of length numStages. */
3728 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */
3729 } arm_fir_lattice_instance_f32;
3730
3731
3732 /**
3733 * @brief Initialization function for the Q15 FIR lattice filter.
3734 * @param[in] S points to an instance of the Q15 FIR lattice structure.
3735 * @param[in] numStages number of filter stages.
3736 * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages.
3737 * @param[in] pState points to the state buffer. The array is of length numStages.
3738 */
3739 void arm_fir_lattice_init_q15(
3740 arm_fir_lattice_instance_q15 * S,
3741 uint16_t numStages,
3742 q15_t * pCoeffs,
3743 q15_t * pState);
3744
3745
3746 /**
3747 * @brief Processing function for the Q15 FIR lattice filter.
3748 * @param[in] S points to an instance of the Q15 FIR lattice structure.
3749 * @param[in] pSrc points to the block of input data.
3750 * @param[out] pDst points to the block of output data.
3751 * @param[in] blockSize number of samples to process.
3752 */
3753 void arm_fir_lattice_q15(
3754 const arm_fir_lattice_instance_q15 * S,
3755 q15_t * pSrc,
3756 q15_t * pDst,
3757 uint32_t blockSize);
3758
3759
3760 /**
3761 * @brief Initialization function for the Q31 FIR lattice filter.
3762 * @param[in] S points to an instance of the Q31 FIR lattice structure.
3763 * @param[in] numStages number of filter stages.
3764 * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages.
3765 * @param[in] pState points to the state buffer. The array is of length numStages.
3766 */
3767 void arm_fir_lattice_init_q31(
3768 arm_fir_lattice_instance_q31 * S,
3769 uint16_t numStages,
3770 q31_t * pCoeffs,
3771 q31_t * pState);
3772
3773
3774 /**
3775 * @brief Processing function for the Q31 FIR lattice filter.
3776 * @param[in] S points to an instance of the Q31 FIR lattice structure.
3777 * @param[in] pSrc points to the block of input data.
3778 * @param[out] pDst points to the block of output data
3779 * @param[in] blockSize number of samples to process.
3780 */
3781 void arm_fir_lattice_q31(
3782 const arm_fir_lattice_instance_q31 * S,
3783 q31_t * pSrc,
3784 q31_t * pDst,
3785 uint32_t blockSize);
3786
3787
3788/**
3789 * @brief Initialization function for the floating-point FIR lattice filter.
3790 * @param[in] S points to an instance of the floating-point FIR lattice structure.
3791 * @param[in] numStages number of filter stages.
3792 * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages.
3793 * @param[in] pState points to the state buffer. The array is of length numStages.
3794 */
3795 void arm_fir_lattice_init_f32(
3796 arm_fir_lattice_instance_f32 * S,
3797 uint16_t numStages,
3798 float32_t * pCoeffs,
3799 float32_t * pState);
3800
3801
3802 /**
3803 * @brief Processing function for the floating-point FIR lattice filter.
3804 * @param[in] S points to an instance of the floating-point FIR lattice structure.
3805 * @param[in] pSrc points to the block of input data.
3806 * @param[out] pDst points to the block of output data
3807 * @param[in] blockSize number of samples to process.
3808 */
3809 void arm_fir_lattice_f32(
3810 const arm_fir_lattice_instance_f32 * S,
3811 float32_t * pSrc,
3812 float32_t * pDst,
3813 uint32_t blockSize);
3814
3815
3816 /**
3817 * @brief Instance structure for the Q15 IIR lattice filter.
3818 */
3819 typedef struct
3820 {
3821 uint16_t numStages; /**< number of stages in the filter. */
3822 q15_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */
3823 q15_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */
3824 q15_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */
3825 } arm_iir_lattice_instance_q15;
3826
3827 /**
3828 * @brief Instance structure for the Q31 IIR lattice filter.
3829 */
3830 typedef struct
3831 {
3832 uint16_t numStages; /**< number of stages in the filter. */
3833 q31_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */
3834 q31_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */
3835 q31_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */
3836 } arm_iir_lattice_instance_q31;
3837
3838 /**
3839 * @brief Instance structure for the floating-point IIR lattice filter.
3840 */
3841 typedef struct
3842 {
3843 uint16_t numStages; /**< number of stages in the filter. */
3844 float32_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */
3845 float32_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */
3846 float32_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */
3847 } arm_iir_lattice_instance_f32;
3848
3849
3850 /**
3851 * @brief Processing function for the floating-point IIR lattice filter.
3852 * @param[in] S points to an instance of the floating-point IIR lattice structure.
3853 * @param[in] pSrc points to the block of input data.
3854 * @param[out] pDst points to the block of output data.
3855 * @param[in] blockSize number of samples to process.
3856 */
3857 void arm_iir_lattice_f32(
3858 const arm_iir_lattice_instance_f32 * S,
3859 float32_t * pSrc,
3860 float32_t * pDst,
3861 uint32_t blockSize);
3862
3863
3864 /**
3865 * @brief Initialization function for the floating-point IIR lattice filter.
3866 * @param[in] S points to an instance of the floating-point IIR lattice structure.
3867 * @param[in] numStages number of stages in the filter.
3868 * @param[in] pkCoeffs points to the reflection coefficient buffer. The array is of length numStages.
3869 * @param[in] pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1.
3870 * @param[in] pState points to the state buffer. The array is of length numStages+blockSize-1.
3871 * @param[in] blockSize number of samples to process.
3872 */
3873 void arm_iir_lattice_init_f32(
3874 arm_iir_lattice_instance_f32 * S,
3875 uint16_t numStages,
3876 float32_t * pkCoeffs,
3877 float32_t * pvCoeffs,
3878 float32_t * pState,
3879 uint32_t blockSize);
3880
3881
3882 /**
3883 * @brief Processing function for the Q31 IIR lattice filter.
3884 * @param[in] S points to an instance of the Q31 IIR lattice structure.
3885 * @param[in] pSrc points to the block of input data.
3886 * @param[out] pDst points to the block of output data.
3887 * @param[in] blockSize number of samples to process.
3888 */
3889 void arm_iir_lattice_q31(
3890 const arm_iir_lattice_instance_q31 * S,
3891 q31_t * pSrc,
3892 q31_t * pDst,
3893 uint32_t blockSize);
3894
3895
3896 /**
3897 * @brief Initialization function for the Q31 IIR lattice filter.
3898 * @param[in] S points to an instance of the Q31 IIR lattice structure.
3899 * @param[in] numStages number of stages in the filter.
3900 * @param[in] pkCoeffs points to the reflection coefficient buffer. The array is of length numStages.
3901 * @param[in] pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1.
3902 * @param[in] pState points to the state buffer. The array is of length numStages+blockSize.
3903 * @param[in] blockSize number of samples to process.
3904 */
3905 void arm_iir_lattice_init_q31(
3906 arm_iir_lattice_instance_q31 * S,
3907 uint16_t numStages,
3908 q31_t * pkCoeffs,
3909 q31_t * pvCoeffs,
3910 q31_t * pState,
3911 uint32_t blockSize);
3912
3913
3914 /**
3915 * @brief Processing function for the Q15 IIR lattice filter.
3916 * @param[in] S points to an instance of the Q15 IIR lattice structure.
3917 * @param[in] pSrc points to the block of input data.
3918 * @param[out] pDst points to the block of output data.
3919 * @param[in] blockSize number of samples to process.
3920 */
3921 void arm_iir_lattice_q15(
3922 const arm_iir_lattice_instance_q15 * S,
3923 q15_t * pSrc,
3924 q15_t * pDst,
3925 uint32_t blockSize);
3926
3927
3928/**
3929 * @brief Initialization function for the Q15 IIR lattice filter.
3930 * @param[in] S points to an instance of the fixed-point Q15 IIR lattice structure.
3931 * @param[in] numStages number of stages in the filter.
3932 * @param[in] pkCoeffs points to reflection coefficient buffer. The array is of length numStages.
3933 * @param[in] pvCoeffs points to ladder coefficient buffer. The array is of length numStages+1.
3934 * @param[in] pState points to state buffer. The array is of length numStages+blockSize.
3935 * @param[in] blockSize number of samples to process per call.
3936 */
3937 void arm_iir_lattice_init_q15(
3938 arm_iir_lattice_instance_q15 * S,
3939 uint16_t numStages,
3940 q15_t * pkCoeffs,
3941 q15_t * pvCoeffs,
3942 q15_t * pState,
3943 uint32_t blockSize);
3944
3945
3946 /**
3947 * @brief Instance structure for the floating-point LMS filter.
3948 */
3949 typedef struct
3950 {
3951 uint16_t numTaps; /**< number of coefficients in the filter. */
3952 float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
3953 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
3954 float32_t mu; /**< step size that controls filter coefficient updates. */
3955 } arm_lms_instance_f32;
3956
3957
3958 /**
3959 * @brief Processing function for floating-point LMS filter.
3960 * @param[in] S points to an instance of the floating-point LMS filter structure.
3961 * @param[in] pSrc points to the block of input data.
3962 * @param[in] pRef points to the block of reference data.
3963 * @param[out] pOut points to the block of output data.
3964 * @param[out] pErr points to the block of error data.
3965 * @param[in] blockSize number of samples to process.
3966 */
3967 void arm_lms_f32(
3968 const arm_lms_instance_f32 * S,
3969 float32_t * pSrc,
3970 float32_t * pRef,
3971 float32_t * pOut,
3972 float32_t * pErr,
3973 uint32_t blockSize);
3974
3975
3976 /**
3977 * @brief Initialization function for floating-point LMS filter.
3978 * @param[in] S points to an instance of the floating-point LMS filter structure.
3979 * @param[in] numTaps number of filter coefficients.
3980 * @param[in] pCoeffs points to the coefficient buffer.
3981 * @param[in] pState points to state buffer.
3982 * @param[in] mu step size that controls filter coefficient updates.
3983 * @param[in] blockSize number of samples to process.
3984 */
3985 void arm_lms_init_f32(
3986 arm_lms_instance_f32 * S,
3987 uint16_t numTaps,
3988 float32_t * pCoeffs,
3989 float32_t * pState,
3990 float32_t mu,
3991 uint32_t blockSize);
3992
3993
3994 /**
3995 * @brief Instance structure for the Q15 LMS filter.
3996 */
3997 typedef struct
3998 {
3999 uint16_t numTaps; /**< number of coefficients in the filter. */
4000 q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
4001 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
4002 q15_t mu; /**< step size that controls filter coefficient updates. */
4003 uint32_t postShift; /**< bit shift applied to coefficients. */
4004 } arm_lms_instance_q15;
4005
4006
4007 /**
4008 * @brief Initialization function for the Q15 LMS filter.
4009 * @param[in] S points to an instance of the Q15 LMS filter structure.
4010 * @param[in] numTaps number of filter coefficients.
4011 * @param[in] pCoeffs points to the coefficient buffer.
4012 * @param[in] pState points to the state buffer.
4013 * @param[in] mu step size that controls filter coefficient updates.
4014 * @param[in] blockSize number of samples to process.
4015 * @param[in] postShift bit shift applied to coefficients.
4016 */
4017 void arm_lms_init_q15(
4018 arm_lms_instance_q15 * S,
4019 uint16_t numTaps,
4020 q15_t * pCoeffs,
4021 q15_t * pState,
4022 q15_t mu,
4023 uint32_t blockSize,
4024 uint32_t postShift);
4025
4026
4027 /**
4028 * @brief Processing function for Q15 LMS filter.
4029 * @param[in] S points to an instance of the Q15 LMS filter structure.
4030 * @param[in] pSrc points to the block of input data.
4031 * @param[in] pRef points to the block of reference data.
4032 * @param[out] pOut points to the block of output data.
4033 * @param[out] pErr points to the block of error data.
4034 * @param[in] blockSize number of samples to process.
4035 */
4036 void arm_lms_q15(
4037 const arm_lms_instance_q15 * S,
4038 q15_t * pSrc,
4039 q15_t * pRef,
4040 q15_t * pOut,
4041 q15_t * pErr,
4042 uint32_t blockSize);
4043
4044
4045 /**
4046 * @brief Instance structure for the Q31 LMS filter.
4047 */
4048 typedef struct
4049 {
4050 uint16_t numTaps; /**< number of coefficients in the filter. */
4051 q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
4052 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
4053 q31_t mu; /**< step size that controls filter coefficient updates. */
4054 uint32_t postShift; /**< bit shift applied to coefficients. */
4055 } arm_lms_instance_q31;
4056
4057
4058 /**
4059 * @brief Processing function for Q31 LMS filter.
4060 * @param[in] S points to an instance of the Q15 LMS filter structure.
4061 * @param[in] pSrc points to the block of input data.
4062 * @param[in] pRef points to the block of reference data.
4063 * @param[out] pOut points to the block of output data.
4064 * @param[out] pErr points to the block of error data.
4065 * @param[in] blockSize number of samples to process.
4066 */
4067 void arm_lms_q31(
4068 const arm_lms_instance_q31 * S,
4069 q31_t * pSrc,
4070 q31_t * pRef,
4071 q31_t * pOut,
4072 q31_t * pErr,
4073 uint32_t blockSize);
4074
4075
4076 /**
4077 * @brief Initialization function for Q31 LMS filter.
4078 * @param[in] S points to an instance of the Q31 LMS filter structure.
4079 * @param[in] numTaps number of filter coefficients.
4080 * @param[in] pCoeffs points to coefficient buffer.
4081 * @param[in] pState points to state buffer.
4082 * @param[in] mu step size that controls filter coefficient updates.
4083 * @param[in] blockSize number of samples to process.
4084 * @param[in] postShift bit shift applied to coefficients.
4085 */
4086 void arm_lms_init_q31(
4087 arm_lms_instance_q31 * S,
4088 uint16_t numTaps,
4089 q31_t * pCoeffs,
4090 q31_t * pState,
4091 q31_t mu,
4092 uint32_t blockSize,
4093 uint32_t postShift);
4094
4095
4096 /**
4097 * @brief Instance structure for the floating-point normalized LMS filter.
4098 */
4099 typedef struct
4100 {
4101 uint16_t numTaps; /**< number of coefficients in the filter. */
4102 float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
4103 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
4104 float32_t mu; /**< step size that control filter coefficient updates. */
4105 float32_t energy; /**< saves previous frame energy. */
4106 float32_t x0; /**< saves previous input sample. */
4107 } arm_lms_norm_instance_f32;
4108
4109
4110 /**
4111 * @brief Processing function for floating-point normalized LMS filter.
4112 * @param[in] S points to an instance of the floating-point normalized LMS filter structure.
4113 * @param[in] pSrc points to the block of input data.
4114 * @param[in] pRef points to the block of reference data.
4115 * @param[out] pOut points to the block of output data.
4116 * @param[out] pErr points to the block of error data.
4117 * @param[in] blockSize number of samples to process.
4118 */
4119 void arm_lms_norm_f32(
4120 arm_lms_norm_instance_f32 * S,
4121 float32_t * pSrc,
4122 float32_t * pRef,
4123 float32_t * pOut,
4124 float32_t * pErr,
4125 uint32_t blockSize);
4126
4127
4128 /**
4129 * @brief Initialization function for floating-point normalized LMS filter.
4130 * @param[in] S points to an instance of the floating-point LMS filter structure.
4131 * @param[in] numTaps number of filter coefficients.
4132 * @param[in] pCoeffs points to coefficient buffer.
4133 * @param[in] pState points to state buffer.
4134 * @param[in] mu step size that controls filter coefficient updates.
4135 * @param[in] blockSize number of samples to process.
4136 */
4137 void arm_lms_norm_init_f32(
4138 arm_lms_norm_instance_f32 * S,
4139 uint16_t numTaps,
4140 float32_t * pCoeffs,
4141 float32_t * pState,
4142 float32_t mu,
4143 uint32_t blockSize);
4144
4145
4146 /**
4147 * @brief Instance structure for the Q31 normalized LMS filter.
4148 */
4149 typedef struct
4150 {
4151 uint16_t numTaps; /**< number of coefficients in the filter. */
4152 q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
4153 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
4154 q31_t mu; /**< step size that controls filter coefficient updates. */
4155 uint8_t postShift; /**< bit shift applied to coefficients. */
4156 q31_t *recipTable; /**< points to the reciprocal initial value table. */
4157 q31_t energy; /**< saves previous frame energy. */
4158 q31_t x0; /**< saves previous input sample. */
4159 } arm_lms_norm_instance_q31;
4160
4161
4162 /**
4163 * @brief Processing function for Q31 normalized LMS filter.
4164 * @param[in] S points to an instance of the Q31 normalized LMS filter structure.
4165 * @param[in] pSrc points to the block of input data.
4166 * @param[in] pRef points to the block of reference data.
4167 * @param[out] pOut points to the block of output data.
4168 * @param[out] pErr points to the block of error data.
4169 * @param[in] blockSize number of samples to process.
4170 */
4171 void arm_lms_norm_q31(
4172 arm_lms_norm_instance_q31 * S,
4173 q31_t * pSrc,
4174 q31_t * pRef,
4175 q31_t * pOut,
4176 q31_t * pErr,
4177 uint32_t blockSize);
4178
4179
4180 /**
4181 * @brief Initialization function for Q31 normalized LMS filter.
4182 * @param[in] S points to an instance of the Q31 normalized LMS filter structure.
4183 * @param[in] numTaps number of filter coefficients.
4184 * @param[in] pCoeffs points to coefficient buffer.
4185 * @param[in] pState points to state buffer.
4186 * @param[in] mu step size that controls filter coefficient updates.
4187 * @param[in] blockSize number of samples to process.
4188 * @param[in] postShift bit shift applied to coefficients.
4189 */
4190 void arm_lms_norm_init_q31(
4191 arm_lms_norm_instance_q31 * S,
4192 uint16_t numTaps,
4193 q31_t * pCoeffs,
4194 q31_t * pState,
4195 q31_t mu,
4196 uint32_t blockSize,
4197 uint8_t postShift);
4198
4199
4200 /**
4201 * @brief Instance structure for the Q15 normalized LMS filter.
4202 */
4203 typedef struct
4204 {
4205 uint16_t numTaps; /**< Number of coefficients in the filter. */
4206 q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
4207 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
4208 q15_t mu; /**< step size that controls filter coefficient updates. */
4209 uint8_t postShift; /**< bit shift applied to coefficients. */
4210 q15_t *recipTable; /**< Points to the reciprocal initial value table. */
4211 q15_t energy; /**< saves previous frame energy. */
4212 q15_t x0; /**< saves previous input sample. */
4213 } arm_lms_norm_instance_q15;
4214
4215
4216 /**
4217 * @brief Processing function for Q15 normalized LMS filter.
4218 * @param[in] S points to an instance of the Q15 normalized LMS filter structure.
4219 * @param[in] pSrc points to the block of input data.
4220 * @param[in] pRef points to the block of reference data.
4221 * @param[out] pOut points to the block of output data.
4222 * @param[out] pErr points to the block of error data.
4223 * @param[in] blockSize number of samples to process.
4224 */
4225 void arm_lms_norm_q15(
4226 arm_lms_norm_instance_q15 * S,
4227 q15_t * pSrc,
4228 q15_t * pRef,
4229 q15_t * pOut,
4230 q15_t * pErr,
4231 uint32_t blockSize);
4232
4233
4234 /**
4235 * @brief Initialization function for Q15 normalized LMS filter.
4236 * @param[in] S points to an instance of the Q15 normalized LMS filter structure.
4237 * @param[in] numTaps number of filter coefficients.
4238 * @param[in] pCoeffs points to coefficient buffer.
4239 * @param[in] pState points to state buffer.
4240 * @param[in] mu step size that controls filter coefficient updates.
4241 * @param[in] blockSize number of samples to process.
4242 * @param[in] postShift bit shift applied to coefficients.
4243 */
4244 void arm_lms_norm_init_q15(
4245 arm_lms_norm_instance_q15 * S,
4246 uint16_t numTaps,
4247 q15_t * pCoeffs,
4248 q15_t * pState,
4249 q15_t mu,
4250 uint32_t blockSize,
4251 uint8_t postShift);
4252
4253
4254 /**
4255 * @brief Correlation of floating-point sequences.
4256 * @param[in] pSrcA points to the first input sequence.
4257 * @param[in] srcALen length of the first input sequence.
4258 * @param[in] pSrcB points to the second input sequence.
4259 * @param[in] srcBLen length of the second input sequence.
4260 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4261 */
4262 void arm_correlate_f32(
4263 float32_t * pSrcA,
4264 uint32_t srcALen,
4265 float32_t * pSrcB,
4266 uint32_t srcBLen,
4267 float32_t * pDst);
4268
4269
4270 /**
4271 * @brief Correlation of Q15 sequences
4272 * @param[in] pSrcA points to the first input sequence.
4273 * @param[in] srcALen length of the first input sequence.
4274 * @param[in] pSrcB points to the second input sequence.
4275 * @param[in] srcBLen length of the second input sequence.
4276 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4277 * @param[in] pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
4278 */
4279 void arm_correlate_opt_q15(
4280 q15_t * pSrcA,
4281 uint32_t srcALen,
4282 q15_t * pSrcB,
4283 uint32_t srcBLen,
4284 q15_t * pDst,
4285 q15_t * pScratch);
4286
4287
4288 /**
4289 * @brief Correlation of Q15 sequences.
4290 * @param[in] pSrcA points to the first input sequence.
4291 * @param[in] srcALen length of the first input sequence.
4292 * @param[in] pSrcB points to the second input sequence.
4293 * @param[in] srcBLen length of the second input sequence.
4294 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4295 */
4296
4297 void arm_correlate_q15(
4298 q15_t * pSrcA,
4299 uint32_t srcALen,
4300 q15_t * pSrcB,
4301 uint32_t srcBLen,
4302 q15_t * pDst);
4303
4304
4305 /**
4306 * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4.
4307 * @param[in] pSrcA points to the first input sequence.
4308 * @param[in] srcALen length of the first input sequence.
4309 * @param[in] pSrcB points to the second input sequence.
4310 * @param[in] srcBLen length of the second input sequence.
4311 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4312 */
4313
4314 void arm_correlate_fast_q15(
4315 q15_t * pSrcA,
4316 uint32_t srcALen,
4317 q15_t * pSrcB,
4318 uint32_t srcBLen,
4319 q15_t * pDst);
4320
4321
4322 /**
4323 * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4.
4324 * @param[in] pSrcA points to the first input sequence.
4325 * @param[in] srcALen length of the first input sequence.
4326 * @param[in] pSrcB points to the second input sequence.
4327 * @param[in] srcBLen length of the second input sequence.
4328 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4329 * @param[in] pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
4330 */
4331 void arm_correlate_fast_opt_q15(
4332 q15_t * pSrcA,
4333 uint32_t srcALen,
4334 q15_t * pSrcB,
4335 uint32_t srcBLen,
4336 q15_t * pDst,
4337 q15_t * pScratch);
4338
4339
4340 /**
4341 * @brief Correlation of Q31 sequences.
4342 * @param[in] pSrcA points to the first input sequence.
4343 * @param[in] srcALen length of the first input sequence.
4344 * @param[in] pSrcB points to the second input sequence.
4345 * @param[in] srcBLen length of the second input sequence.
4346 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4347 */
4348 void arm_correlate_q31(
4349 q31_t * pSrcA,
4350 uint32_t srcALen,
4351 q31_t * pSrcB,
4352 uint32_t srcBLen,
4353 q31_t * pDst);
4354
4355
4356 /**
4357 * @brief Correlation of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4
4358 * @param[in] pSrcA points to the first input sequence.
4359 * @param[in] srcALen length of the first input sequence.
4360 * @param[in] pSrcB points to the second input sequence.
4361 * @param[in] srcBLen length of the second input sequence.
4362 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4363 */
4364 void arm_correlate_fast_q31(
4365 q31_t * pSrcA,
4366 uint32_t srcALen,
4367 q31_t * pSrcB,
4368 uint32_t srcBLen,
4369 q31_t * pDst);
4370
4371
4372 /**
4373 * @brief Correlation of Q7 sequences.
4374 * @param[in] pSrcA points to the first input sequence.
4375 * @param[in] srcALen length of the first input sequence.
4376 * @param[in] pSrcB points to the second input sequence.
4377 * @param[in] srcBLen length of the second input sequence.
4378 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4379 * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
4380 * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
4381 */
4382 void arm_correlate_opt_q7(
4383 q7_t * pSrcA,
4384 uint32_t srcALen,
4385 q7_t * pSrcB,
4386 uint32_t srcBLen,
4387 q7_t * pDst,
4388 q15_t * pScratch1,
4389 q15_t * pScratch2);
4390
4391
4392 /**
4393 * @brief Correlation of Q7 sequences.
4394 * @param[in] pSrcA points to the first input sequence.
4395 * @param[in] srcALen length of the first input sequence.
4396 * @param[in] pSrcB points to the second input sequence.
4397 * @param[in] srcBLen length of the second input sequence.
4398 * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
4399 */
4400 void arm_correlate_q7(
4401 q7_t * pSrcA,
4402 uint32_t srcALen,
4403 q7_t * pSrcB,
4404 uint32_t srcBLen,
4405 q7_t * pDst);
4406
4407
4408 /**
4409 * @brief Instance structure for the floating-point sparse FIR filter.
4410 */
4411 typedef struct
4412 {
4413 uint16_t numTaps; /**< number of coefficients in the filter. */
4414 uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */
4415 float32_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
4416 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
4417 uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */
4418 int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */
4419 } arm_fir_sparse_instance_f32;
4420
4421 /**
4422 * @brief Instance structure for the Q31 sparse FIR filter.
4423 */
4424 typedef struct
4425 {
4426 uint16_t numTaps; /**< number of coefficients in the filter. */
4427 uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */
4428 q31_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
4429 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
4430 uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */
4431 int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */
4432 } arm_fir_sparse_instance_q31;
4433
4434 /**
4435 * @brief Instance structure for the Q15 sparse FIR filter.
4436 */
4437 typedef struct
4438 {
4439 uint16_t numTaps; /**< number of coefficients in the filter. */
4440 uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */
4441 q15_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
4442 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
4443 uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */
4444 int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */
4445 } arm_fir_sparse_instance_q15;
4446
4447 /**
4448 * @brief Instance structure for the Q7 sparse FIR filter.
4449 */
4450 typedef struct
4451 {
4452 uint16_t numTaps; /**< number of coefficients in the filter. */
4453 uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */
4454 q7_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
4455 q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
4456 uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */
4457 int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */
4458 } arm_fir_sparse_instance_q7;
4459
4460
4461 /**
4462 * @brief Processing function for the floating-point sparse FIR filter.
4463 * @param[in] S points to an instance of the floating-point sparse FIR structure.
4464 * @param[in] pSrc points to the block of input data.
4465 * @param[out] pDst points to the block of output data
4466 * @param[in] pScratchIn points to a temporary buffer of size blockSize.
4467 * @param[in] blockSize number of input samples to process per call.
4468 */
4469 void arm_fir_sparse_f32(
4470 arm_fir_sparse_instance_f32 * S,
4471 float32_t * pSrc,
4472 float32_t * pDst,
4473 float32_t * pScratchIn,
4474 uint32_t blockSize);
4475
4476
4477 /**
4478 * @brief Initialization function for the floating-point sparse FIR filter.
4479 * @param[in,out] S points to an instance of the floating-point sparse FIR structure.
4480 * @param[in] numTaps number of nonzero coefficients in the filter.
4481 * @param[in] pCoeffs points to the array of filter coefficients.
4482 * @param[in] pState points to the state buffer.
4483 * @param[in] pTapDelay points to the array of offset times.
4484 * @param[in] maxDelay maximum offset time supported.
4485 * @param[in] blockSize number of samples that will be processed per block.
4486 */
4487 void arm_fir_sparse_init_f32(
4488 arm_fir_sparse_instance_f32 * S,
4489 uint16_t numTaps,
4490 float32_t * pCoeffs,
4491 float32_t * pState,
4492 int32_t * pTapDelay,
4493 uint16_t maxDelay,
4494 uint32_t blockSize);
4495
4496
4497 /**
4498 * @brief Processing function for the Q31 sparse FIR filter.
4499 * @param[in] S points to an instance of the Q31 sparse FIR structure.
4500 * @param[in] pSrc points to the block of input data.
4501 * @param[out] pDst points to the block of output data
4502 * @param[in] pScratchIn points to a temporary buffer of size blockSize.
4503 * @param[in] blockSize number of input samples to process per call.
4504 */
4505 void arm_fir_sparse_q31(
4506 arm_fir_sparse_instance_q31 * S,
4507 q31_t * pSrc,
4508 q31_t * pDst,
4509 q31_t * pScratchIn,
4510 uint32_t blockSize);
4511
4512
4513 /**
4514 * @brief Initialization function for the Q31 sparse FIR filter.
4515 * @param[in,out] S points to an instance of the Q31 sparse FIR structure.
4516 * @param[in] numTaps number of nonzero coefficients in the filter.
4517 * @param[in] pCoeffs points to the array of filter coefficients.
4518 * @param[in] pState points to the state buffer.
4519 * @param[in] pTapDelay points to the array of offset times.
4520 * @param[in] maxDelay maximum offset time supported.
4521 * @param[in] blockSize number of samples that will be processed per block.
4522 */
4523 void arm_fir_sparse_init_q31(
4524 arm_fir_sparse_instance_q31 * S,
4525 uint16_t numTaps,
4526 q31_t * pCoeffs,
4527 q31_t * pState,
4528 int32_t * pTapDelay,
4529 uint16_t maxDelay,
4530 uint32_t blockSize);
4531
4532
4533 /**
4534 * @brief Processing function for the Q15 sparse FIR filter.
4535 * @param[in] S points to an instance of the Q15 sparse FIR structure.
4536 * @param[in] pSrc points to the block of input data.
4537 * @param[out] pDst points to the block of output data
4538 * @param[in] pScratchIn points to a temporary buffer of size blockSize.
4539 * @param[in] pScratchOut points to a temporary buffer of size blockSize.
4540 * @param[in] blockSize number of input samples to process per call.
4541 */
4542 void arm_fir_sparse_q15(
4543 arm_fir_sparse_instance_q15 * S,
4544 q15_t * pSrc,
4545 q15_t * pDst,
4546 q15_t * pScratchIn,
4547 q31_t * pScratchOut,
4548 uint32_t blockSize);
4549
4550
4551 /**
4552 * @brief Initialization function for the Q15 sparse FIR filter.
4553 * @param[in,out] S points to an instance of the Q15 sparse FIR structure.
4554 * @param[in] numTaps number of nonzero coefficients in the filter.
4555 * @param[in] pCoeffs points to the array of filter coefficients.
4556 * @param[in] pState points to the state buffer.
4557 * @param[in] pTapDelay points to the array of offset times.
4558 * @param[in] maxDelay maximum offset time supported.
4559 * @param[in] blockSize number of samples that will be processed per block.
4560 */
4561 void arm_fir_sparse_init_q15(
4562 arm_fir_sparse_instance_q15 * S,
4563 uint16_t numTaps,
4564 q15_t * pCoeffs,
4565 q15_t * pState,
4566 int32_t * pTapDelay,
4567 uint16_t maxDelay,
4568 uint32_t blockSize);
4569
4570
4571 /**
4572 * @brief Processing function for the Q7 sparse FIR filter.
4573 * @param[in] S points to an instance of the Q7 sparse FIR structure.
4574 * @param[in] pSrc points to the block of input data.
4575 * @param[out] pDst points to the block of output data
4576 * @param[in] pScratchIn points to a temporary buffer of size blockSize.
4577 * @param[in] pScratchOut points to a temporary buffer of size blockSize.
4578 * @param[in] blockSize number of input samples to process per call.
4579 */
4580 void arm_fir_sparse_q7(
4581 arm_fir_sparse_instance_q7 * S,
4582 q7_t * pSrc,
4583 q7_t * pDst,
4584 q7_t * pScratchIn,
4585 q31_t * pScratchOut,
4586 uint32_t blockSize);
4587
4588
4589 /**
4590 * @brief Initialization function for the Q7 sparse FIR filter.
4591 * @param[in,out] S points to an instance of the Q7 sparse FIR structure.
4592 * @param[in] numTaps number of nonzero coefficients in the filter.
4593 * @param[in] pCoeffs points to the array of filter coefficients.
4594 * @param[in] pState points to the state buffer.
4595 * @param[in] pTapDelay points to the array of offset times.
4596 * @param[in] maxDelay maximum offset time supported.
4597 * @param[in] blockSize number of samples that will be processed per block.
4598 */
4599 void arm_fir_sparse_init_q7(
4600 arm_fir_sparse_instance_q7 * S,
4601 uint16_t numTaps,
4602 q7_t * pCoeffs,
4603 q7_t * pState,
4604 int32_t * pTapDelay,
4605 uint16_t maxDelay,
4606 uint32_t blockSize);
4607
4608
4609 /**
4610 * @brief Floating-point sin_cos function.
4611 * @param[in] theta input value in degrees
4612 * @param[out] pSinVal points to the processed sine output.
4613 * @param[out] pCosVal points to the processed cos output.
4614 */
4615 void arm_sin_cos_f32(
4616 float32_t theta,
4617 float32_t * pSinVal,
4618 float32_t * pCosVal);
4619
4620
4621 /**
4622 * @brief Q31 sin_cos function.
4623 * @param[in] theta scaled input value in degrees
4624 * @param[out] pSinVal points to the processed sine output.
4625 * @param[out] pCosVal points to the processed cosine output.
4626 */
4627 void arm_sin_cos_q31(
4628 q31_t theta,
4629 q31_t * pSinVal,
4630 q31_t * pCosVal);
4631
4632
4633 /**
4634 * @brief Floating-point complex conjugate.
4635 * @param[in] pSrc points to the input vector
4636 * @param[out] pDst points to the output vector
4637 * @param[in] numSamples number of complex samples in each vector
4638 */
4639 void arm_cmplx_conj_f32(
4640 float32_t * pSrc,
4641 float32_t * pDst,
4642 uint32_t numSamples);
4643
4644 /**
4645 * @brief Q31 complex conjugate.
4646 * @param[in] pSrc points to the input vector
4647 * @param[out] pDst points to the output vector
4648 * @param[in] numSamples number of complex samples in each vector
4649 */
4650 void arm_cmplx_conj_q31(
4651 q31_t * pSrc,
4652 q31_t * pDst,
4653 uint32_t numSamples);
4654
4655
4656 /**
4657 * @brief Q15 complex conjugate.
4658 * @param[in] pSrc points to the input vector
4659 * @param[out] pDst points to the output vector
4660 * @param[in] numSamples number of complex samples in each vector
4661 */
4662 void arm_cmplx_conj_q15(
4663 q15_t * pSrc,
4664 q15_t * pDst,
4665 uint32_t numSamples);
4666
4667
4668 /**
4669 * @brief Floating-point complex magnitude squared
4670 * @param[in] pSrc points to the complex input vector
4671 * @param[out] pDst points to the real output vector
4672 * @param[in] numSamples number of complex samples in the input vector
4673 */
4674 void arm_cmplx_mag_squared_f32(
4675 float32_t * pSrc,
4676 float32_t * pDst,
4677 uint32_t numSamples);
4678
4679
4680 /**
4681 * @brief Q31 complex magnitude squared
4682 * @param[in] pSrc points to the complex input vector
4683 * @param[out] pDst points to the real output vector
4684 * @param[in] numSamples number of complex samples in the input vector
4685 */
4686 void arm_cmplx_mag_squared_q31(
4687 q31_t * pSrc,
4688 q31_t * pDst,
4689 uint32_t numSamples);
4690
4691
4692 /**
4693 * @brief Q15 complex magnitude squared
4694 * @param[in] pSrc points to the complex input vector
4695 * @param[out] pDst points to the real output vector
4696 * @param[in] numSamples number of complex samples in the input vector
4697 */
4698 void arm_cmplx_mag_squared_q15(
4699 q15_t * pSrc,
4700 q15_t * pDst,
4701 uint32_t numSamples);
4702
4703
4704 /**
4705 * @ingroup groupController
4706 */
4707
4708 /**
4709 * @defgroup PID PID Motor Control
4710 *
4711 * A Proportional Integral Derivative (PID) controller is a generic feedback control
4712 * loop mechanism widely used in industrial control systems.
4713 * A PID controller is the most commonly used type of feedback controller.
4714 *
4715 * This set of functions implements (PID) controllers
4716 * for Q15, Q31, and floating-point data types. The functions operate on a single sample
4717 * of data and each call to the function returns a single processed value.
4718 * <code>S</code> points to an instance of the PID control data structure. <code>in</code>
4719 * is the input sample value. The functions return the output value.
4720 *
4721 * \par Algorithm:
4722 * <pre>
4723 * y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2]
4724 * A0 = Kp + Ki + Kd
4725 * A1 = (-Kp ) - (2 * Kd )
4726 * A2 = Kd </pre>
4727 *
4728 * \par
4729 * where \c Kp is proportional constant, \c Ki is Integral constant and \c Kd is Derivative constant
4730 *
4731 * \par
4732 * \image html PID.gif "Proportional Integral Derivative Controller"
4733 *
4734 * \par
4735 * The PID controller calculates an "error" value as the difference between
4736 * the measured output and the reference input.
4737 * The controller attempts to minimize the error by adjusting the process control inputs.
4738 * The proportional value determines the reaction to the current error,
4739 * the integral value determines the reaction based on the sum of recent errors,
4740 * and the derivative value determines the reaction based on the rate at which the error has been changing.
4741 *
4742 * \par Instance Structure
4743 * The Gains A0, A1, A2 and state variables for a PID controller are stored together in an instance data structure.
4744 * A separate instance structure must be defined for each PID Controller.
4745 * There are separate instance structure declarations for each of the 3 supported data types.
4746 *
4747 * \par Reset Functions
4748 * There is also an associated reset function for each data type which clears the state array.
4749 *
4750 * \par Initialization Functions
4751 * There is also an associated initialization function for each data type.
4752 * The initialization function performs the following operations:
4753 * - Initializes the Gains A0, A1, A2 from Kp,Ki, Kd gains.
4754 * - Zeros out the values in the state buffer.
4755 *
4756 * \par
4757 * Instance structure cannot be placed into a const data section and it is recommended to use the initialization function.
4758 *
4759 * \par Fixed-Point Behavior
4760 * Care must be taken when using the fixed-point versions of the PID Controller functions.
4761 * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered.
4762 * Refer to the function specific documentation below for usage guidelines.
4763 */
4764
4765 /**
4766 * @addtogroup PID
4767 * @{
4768 */
4769
4770 /**
4771 * @brief Process function for the floating-point PID Control.
4772 * @param[in,out] S is an instance of the floating-point PID Control structure
4773 * @param[in] in input sample to process
4774 * @return out processed output sample.
4775 */
4776 CMSIS_INLINE __STATIC_INLINE float32_t arm_pid_f32(
4777 arm_pid_instance_f32 * S,
4778 float32_t in)
4779 {
4780 float32_t out;
4781
4782 /* y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2] */
4783 out = (S->A0 * in) +
4784 (S->A1 * S->state[0]) + (S->A2 * S->state[1]) + (S->state[2]);
4785
4786 /* Update state */
4787 S->state[1] = S->state[0];
4788 S->state[0] = in;
4789 S->state[2] = out;
4790
4791 /* return to application */
4792 return (out);
4793
4794 }
4795
4796 /**
4797 * @brief Process function for the Q31 PID Control.
4798 * @param[in,out] S points to an instance of the Q31 PID Control structure
4799 * @param[in] in input sample to process
4800 * @return out processed output sample.
4801 *
4802 * <b>Scaling and Overflow Behavior:</b>
4803 * \par
4804 * The function is implemented using an internal 64-bit accumulator.
4805 * The accumulator has a 2.62 format and maintains full precision of the intermediate multiplication results but provides only a single guard bit.
4806 * Thus, if the accumulator result overflows it wraps around rather than clip.
4807 * In order to avoid overflows completely the input signal must be scaled down by 2 bits as there are four additions.
4808 * After all multiply-accumulates are performed, the 2.62 accumulator is truncated to 1.32 format and then saturated to 1.31 format.
4809 */
4810 CMSIS_INLINE __STATIC_INLINE q31_t arm_pid_q31(
4811 arm_pid_instance_q31 * S,
4812 q31_t in)
4813 {
4814 q63_t acc;
4815 q31_t out;
4816
4817 /* acc = A0 * x[n] */
4818 acc = (q63_t) S->A0 * in;
4819
4820 /* acc += A1 * x[n-1] */
4821 acc += (q63_t) S->A1 * S->state[0];
4822
4823 /* acc += A2 * x[n-2] */
4824 acc += (q63_t) S->A2 * S->state[1];
4825
4826 /* convert output to 1.31 format to add y[n-1] */
4827 out = (q31_t) (acc >> 31U);
4828
4829 /* out += y[n-1] */
4830 out += S->state[2];
4831
4832 /* Update state */
4833 S->state[1] = S->state[0];
4834 S->state[0] = in;
4835 S->state[2] = out;
4836
4837 /* return to application */
4838 return (out);
4839 }
4840
4841
4842 /**
4843 * @brief Process function for the Q15 PID Control.
4844 * @param[in,out] S points to an instance of the Q15 PID Control structure
4845 * @param[in] in input sample to process
4846 * @return out processed output sample.
4847 *
4848 * <b>Scaling and Overflow Behavior:</b>
4849 * \par
4850 * The function is implemented using a 64-bit internal accumulator.
4851 * Both Gains and state variables are represented in 1.15 format and multiplications yield a 2.30 result.
4852 * The 2.30 intermediate results are accumulated in a 64-bit accumulator in 34.30 format.
4853 * There is no risk of internal overflow with this approach and the full precision of intermediate multiplications is preserved.
4854 * After all additions have been performed, the accumulator is truncated to 34.15 format by discarding low 15 bits.
4855 * Lastly, the accumulator is saturated to yield a result in 1.15 format.
4856 */
4857 CMSIS_INLINE __STATIC_INLINE q15_t arm_pid_q15(
4858 arm_pid_instance_q15 * S,
4859 q15_t in)
4860 {
4861 q63_t acc;
4862 q15_t out;
4863
4864#if defined (ARM_MATH_DSP)
4865 __SIMD32_TYPE *vstate;
4866
4867 /* Implementation of PID controller */
4868
4869 /* acc = A0 * x[n] */
4870 acc = (q31_t) __SMUAD((uint32_t)S->A0, (uint32_t)in);
4871
4872 /* acc += A1 * x[n-1] + A2 * x[n-2] */
4873 vstate = __SIMD32_CONST(S->state);
4874 acc = (q63_t)__SMLALD((uint32_t)S->A1, (uint32_t)*vstate, (uint64_t)acc);
4875#else
4876 /* acc = A0 * x[n] */
4877 acc = ((q31_t) S->A0) * in;
4878
4879 /* acc += A1 * x[n-1] + A2 * x[n-2] */
4880 acc += (q31_t) S->A1 * S->state[0];
4881 acc += (q31_t) S->A2 * S->state[1];
4882#endif
4883
4884 /* acc += y[n-1] */
4885 acc += (q31_t) S->state[2] << 15;
4886
4887 /* saturate the output */
4888 out = (q15_t) (__SSAT((acc >> 15), 16));
4889
4890 /* Update state */
4891 S->state[1] = S->state[0];
4892 S->state[0] = in;
4893 S->state[2] = out;
4894
4895 /* return to application */
4896 return (out);
4897 }
4898
4899 /**
4900 * @} end of PID group
4901 */
4902
4903
4904 /**
4905 * @brief Floating-point matrix inverse.
4906 * @param[in] src points to the instance of the input floating-point matrix structure.
4907 * @param[out] dst points to the instance of the output floating-point matrix structure.
4908 * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
4909 * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.
4910 */
4911 arm_status arm_mat_inverse_f32(
4912 const arm_matrix_instance_f32 * src,
4913 arm_matrix_instance_f32 * dst);
4914
4915
4916 /**
4917 * @brief Floating-point matrix inverse.
4918 * @param[in] src points to the instance of the input floating-point matrix structure.
4919 * @param[out] dst points to the instance of the output floating-point matrix structure.
4920 * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
4921 * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.
4922 */
4923 arm_status arm_mat_inverse_f64(
4924 const arm_matrix_instance_f64 * src,
4925 arm_matrix_instance_f64 * dst);
4926
4927
4928
4929 /**
4930 * @ingroup groupController
4931 */
4932
4933 /**
4934 * @defgroup clarke Vector Clarke Transform
4935 * Forward Clarke transform converts the instantaneous stator phases into a two-coordinate time invariant vector.
4936 * Generally the Clarke transform uses three-phase currents <code>Ia, Ib and Ic</code> to calculate currents
4937 * in the two-phase orthogonal stator axis <code>Ialpha</code> and <code>Ibeta</code>.
4938 * When <code>Ialpha</code> is superposed with <code>Ia</code> as shown in the figure below
4939 * \image html clarke.gif Stator current space vector and its components in (a,b).
4940 * and <code>Ia + Ib + Ic = 0</code>, in this condition <code>Ialpha</code> and <code>Ibeta</code>
4941 * can be calculated using only <code>Ia</code> and <code>Ib</code>.
4942 *
4943 * The function operates on a single sample of data and each call to the function returns the processed output.
4944 * The library provides separate functions for Q31 and floating-point data types.
4945 * \par Algorithm
4946 * \image html clarkeFormula.gif
4947 * where <code>Ia</code> and <code>Ib</code> are the instantaneous stator phases and
4948 * <code>pIalpha</code> and <code>pIbeta</code> are the two coordinates of time invariant vector.
4949 * \par Fixed-Point Behavior
4950 * Care must be taken when using the Q31 version of the Clarke transform.
4951 * In particular, the overflow and saturation behavior of the accumulator used must be considered.
4952 * Refer to the function specific documentation below for usage guidelines.
4953 */
4954
4955 /**
4956 * @addtogroup clarke
4957 * @{
4958 */
4959
4960 /**
4961 *
4962 * @brief Floating-point Clarke transform
4963 * @param[in] Ia input three-phase coordinate <code>a</code>
4964 * @param[in] Ib input three-phase coordinate <code>b</code>
4965 * @param[out] pIalpha points to output two-phase orthogonal vector axis alpha
4966 * @param[out] pIbeta points to output two-phase orthogonal vector axis beta
4967 */
4968 CMSIS_INLINE __STATIC_INLINE void arm_clarke_f32(
4969 float32_t Ia,
4970 float32_t Ib,
4971 float32_t * pIalpha,
4972 float32_t * pIbeta)
4973 {
4974 /* Calculate pIalpha using the equation, pIalpha = Ia */
4975 *pIalpha = Ia;
4976
4977 /* Calculate pIbeta using the equation, pIbeta = (1/sqrt(3)) * Ia + (2/sqrt(3)) * Ib */
4978 *pIbeta = ((float32_t) 0.57735026919 * Ia + (float32_t) 1.15470053838 * Ib);
4979 }
4980
4981
4982 /**
4983 * @brief Clarke transform for Q31 version
4984 * @param[in] Ia input three-phase coordinate <code>a</code>
4985 * @param[in] Ib input three-phase coordinate <code>b</code>
4986 * @param[out] pIalpha points to output two-phase orthogonal vector axis alpha
4987 * @param[out] pIbeta points to output two-phase orthogonal vector axis beta
4988 *
4989 * <b>Scaling and Overflow Behavior:</b>
4990 * \par
4991 * The function is implemented using an internal 32-bit accumulator.
4992 * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.
4993 * There is saturation on the addition, hence there is no risk of overflow.
4994 */
4995 CMSIS_INLINE __STATIC_INLINE void arm_clarke_q31(
4996 q31_t Ia,
4997 q31_t Ib,
4998 q31_t * pIalpha,
4999 q31_t * pIbeta)
5000 {
5001 q31_t product1, product2; /* Temporary variables used to store intermediate results */
5002
5003 /* Calculating pIalpha from Ia by equation pIalpha = Ia */
5004 *pIalpha = Ia;
5005
5006 /* Intermediate product is calculated by (1/(sqrt(3)) * Ia) */
5007 product1 = (q31_t) (((q63_t) Ia * 0x24F34E8B) >> 30);
5008
5009 /* Intermediate product is calculated by (2/sqrt(3) * Ib) */
5010 product2 = (q31_t) (((q63_t) Ib * 0x49E69D16) >> 30);
5011
5012 /* pIbeta is calculated by adding the intermediate products */
5013 *pIbeta = __QADD(product1, product2);
5014 }
5015
5016 /**
5017 * @} end of clarke group
5018 */
5019
5020 /**
5021 * @brief Converts the elements of the Q7 vector to Q31 vector.
5022 * @param[in] pSrc input pointer
5023 * @param[out] pDst output pointer
5024 * @param[in] blockSize number of samples to process
5025 */
5026 void arm_q7_to_q31(
5027 q7_t * pSrc,
5028 q31_t * pDst,
5029 uint32_t blockSize);
5030
5031
5032
5033 /**
5034 * @ingroup groupController
5035 */
5036
5037 /**
5038 * @defgroup inv_clarke Vector Inverse Clarke Transform
5039 * Inverse Clarke transform converts the two-coordinate time invariant vector into instantaneous stator phases.
5040 *
5041 * The function operates on a single sample of data and each call to the function returns the processed output.
5042 * The library provides separate functions for Q31 and floating-point data types.
5043 * \par Algorithm
5044 * \image html clarkeInvFormula.gif
5045 * where <code>pIa</code> and <code>pIb</code> are the instantaneous stator phases and
5046 * <code>Ialpha</code> and <code>Ibeta</code> are the two coordinates of time invariant vector.
5047 * \par Fixed-Point Behavior
5048 * Care must be taken when using the Q31 version of the Clarke transform.
5049 * In particular, the overflow and saturation behavior of the accumulator used must be considered.
5050 * Refer to the function specific documentation below for usage guidelines.
5051 */
5052
5053 /**
5054 * @addtogroup inv_clarke
5055 * @{
5056 */
5057
5058 /**
5059 * @brief Floating-point Inverse Clarke transform
5060 * @param[in] Ialpha input two-phase orthogonal vector axis alpha
5061 * @param[in] Ibeta input two-phase orthogonal vector axis beta
5062 * @param[out] pIa points to output three-phase coordinate <code>a</code>
5063 * @param[out] pIb points to output three-phase coordinate <code>b</code>
5064 */
5065 CMSIS_INLINE __STATIC_INLINE void arm_inv_clarke_f32(
5066 float32_t Ialpha,
5067 float32_t Ibeta,
5068 float32_t * pIa,
5069 float32_t * pIb)
5070 {
5071 /* Calculating pIa from Ialpha by equation pIa = Ialpha */
5072 *pIa = Ialpha;
5073
5074 /* Calculating pIb from Ialpha and Ibeta by equation pIb = -(1/2) * Ialpha + (sqrt(3)/2) * Ibeta */
5075 *pIb = -0.5f * Ialpha + 0.8660254039f * Ibeta;
5076 }
5077
5078
5079 /**
5080 * @brief Inverse Clarke transform for Q31 version
5081 * @param[in] Ialpha input two-phase orthogonal vector axis alpha
5082 * @param[in] Ibeta input two-phase orthogonal vector axis beta
5083 * @param[out] pIa points to output three-phase coordinate <code>a</code>
5084 * @param[out] pIb points to output three-phase coordinate <code>b</code>
5085 *
5086 * <b>Scaling and Overflow Behavior:</b>
5087 * \par
5088 * The function is implemented using an internal 32-bit accumulator.
5089 * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.
5090 * There is saturation on the subtraction, hence there is no risk of overflow.
5091 */
5092 CMSIS_INLINE __STATIC_INLINE void arm_inv_clarke_q31(
5093 q31_t Ialpha,
5094 q31_t Ibeta,
5095 q31_t * pIa,
5096 q31_t * pIb)
5097 {
5098 q31_t product1, product2; /* Temporary variables used to store intermediate results */
5099
5100 /* Calculating pIa from Ialpha by equation pIa = Ialpha */
5101 *pIa = Ialpha;
5102
5103 /* Intermediate product is calculated by (1/(2*sqrt(3)) * Ia) */
5104 product1 = (q31_t) (((q63_t) (Ialpha) * (0x40000000)) >> 31);
5105
5106 /* Intermediate product is calculated by (1/sqrt(3) * pIb) */
5107 product2 = (q31_t) (((q63_t) (Ibeta) * (0x6ED9EBA1)) >> 31);
5108
5109 /* pIb is calculated by subtracting the products */
5110 *pIb = __QSUB(product2, product1);
5111 }
5112
5113 /**
5114 * @} end of inv_clarke group
5115 */
5116
5117 /**
5118 * @brief Converts the elements of the Q7 vector to Q15 vector.
5119 * @param[in] pSrc input pointer
5120 * @param[out] pDst output pointer
5121 * @param[in] blockSize number of samples to process
5122 */
5123 void arm_q7_to_q15(
5124 q7_t * pSrc,
5125 q15_t * pDst,
5126 uint32_t blockSize);
5127
5128
5129
5130 /**
5131 * @ingroup groupController
5132 */
5133
5134 /**
5135 * @defgroup park Vector Park Transform
5136 *
5137 * Forward Park transform converts the input two-coordinate vector to flux and torque components.
5138 * The Park transform can be used to realize the transformation of the <code>Ialpha</code> and the <code>Ibeta</code> currents
5139 * from the stationary to the moving reference frame and control the spatial relationship between
5140 * the stator vector current and rotor flux vector.
5141 * If we consider the d axis aligned with the rotor flux, the diagram below shows the
5142 * current vector and the relationship from the two reference frames:
5143 * \image html park.gif "Stator current space vector and its component in (a,b) and in the d,q rotating reference frame"
5144 *
5145 * The function operates on a single sample of data and each call to the function returns the processed output.
5146 * The library provides separate functions for Q31 and floating-point data types.
5147 * \par Algorithm
5148 * \image html parkFormula.gif
5149 * where <code>Ialpha</code> and <code>Ibeta</code> are the stator vector components,
5150 * <code>pId</code> and <code>pIq</code> are rotor vector components and <code>cosVal</code> and <code>sinVal</code> are the
5151 * cosine and sine values of theta (rotor flux position).
5152 * \par Fixed-Point Behavior
5153 * Care must be taken when using the Q31 version of the Park transform.
5154 * In particular, the overflow and saturation behavior of the accumulator used must be considered.
5155 * Refer to the function specific documentation below for usage guidelines.
5156 */
5157
5158 /**
5159 * @addtogroup park
5160 * @{
5161 */
5162
5163 /**
5164 * @brief Floating-point Park transform
5165 * @param[in] Ialpha input two-phase vector coordinate alpha
5166 * @param[in] Ibeta input two-phase vector coordinate beta
5167 * @param[out] pId points to output rotor reference frame d
5168 * @param[out] pIq points to output rotor reference frame q
5169 * @param[in] sinVal sine value of rotation angle theta
5170 * @param[in] cosVal cosine value of rotation angle theta
5171 *
5172 * The function implements the forward Park transform.
5173 *
5174 */
5175 CMSIS_INLINE __STATIC_INLINE void arm_park_f32(
5176 float32_t Ialpha,
5177 float32_t Ibeta,
5178 float32_t * pId,
5179 float32_t * pIq,
5180 float32_t sinVal,
5181 float32_t cosVal)
5182 {
5183 /* Calculate pId using the equation, pId = Ialpha * cosVal + Ibeta * sinVal */
5184 *pId = Ialpha * cosVal + Ibeta * sinVal;
5185
5186 /* Calculate pIq using the equation, pIq = - Ialpha * sinVal + Ibeta * cosVal */
5187 *pIq = -Ialpha * sinVal + Ibeta * cosVal;
5188 }
5189
5190
5191 /**
5192 * @brief Park transform for Q31 version
5193 * @param[in] Ialpha input two-phase vector coordinate alpha
5194 * @param[in] Ibeta input two-phase vector coordinate beta
5195 * @param[out] pId points to output rotor reference frame d
5196 * @param[out] pIq points to output rotor reference frame q
5197 * @param[in] sinVal sine value of rotation angle theta
5198 * @param[in] cosVal cosine value of rotation angle theta
5199 *
5200 * <b>Scaling and Overflow Behavior:</b>
5201 * \par
5202 * The function is implemented using an internal 32-bit accumulator.
5203 * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.
5204 * There is saturation on the addition and subtraction, hence there is no risk of overflow.
5205 */
5206 CMSIS_INLINE __STATIC_INLINE void arm_park_q31(
5207 q31_t Ialpha,
5208 q31_t Ibeta,
5209 q31_t * pId,
5210 q31_t * pIq,
5211 q31_t sinVal,
5212 q31_t cosVal)
5213 {
5214 q31_t product1, product2; /* Temporary variables used to store intermediate results */
5215 q31_t product3, product4; /* Temporary variables used to store intermediate results */
5216
5217 /* Intermediate product is calculated by (Ialpha * cosVal) */
5218 product1 = (q31_t) (((q63_t) (Ialpha) * (cosVal)) >> 31);
5219
5220 /* Intermediate product is calculated by (Ibeta * sinVal) */
5221 product2 = (q31_t) (((q63_t) (Ibeta) * (sinVal)) >> 31);
5222
5223
5224 /* Intermediate product is calculated by (Ialpha * sinVal) */
5225 product3 = (q31_t) (((q63_t) (Ialpha) * (sinVal)) >> 31);
5226
5227 /* Intermediate product is calculated by (Ibeta * cosVal) */
5228 product4 = (q31_t) (((q63_t) (Ibeta) * (cosVal)) >> 31);
5229
5230 /* Calculate pId by adding the two intermediate products 1 and 2 */
5231 *pId = __QADD(product1, product2);
5232
5233 /* Calculate pIq by subtracting the two intermediate products 3 from 4 */
5234 *pIq = __QSUB(product4, product3);
5235 }
5236
5237 /**
5238 * @} end of park group
5239 */
5240
5241 /**
5242 * @brief Converts the elements of the Q7 vector to floating-point vector.
5243 * @param[in] pSrc is input pointer
5244 * @param[out] pDst is output pointer
5245 * @param[in] blockSize is the number of samples to process
5246 */
5247 void arm_q7_to_float(
5248 q7_t * pSrc,
5249 float32_t * pDst,
5250 uint32_t blockSize);
5251
5252
5253 /**
5254 * @ingroup groupController
5255 */
5256
5257 /**
5258 * @defgroup inv_park Vector Inverse Park transform
5259 * Inverse Park transform converts the input flux and torque components to two-coordinate vector.
5260 *
5261 * The function operates on a single sample of data and each call to the function returns the processed output.
5262 * The library provides separate functions for Q31 and floating-point data types.
5263 * \par Algorithm
5264 * \image html parkInvFormula.gif
5265 * where <code>pIalpha</code> and <code>pIbeta</code> are the stator vector components,
5266 * <code>Id</code> and <code>Iq</code> are rotor vector components and <code>cosVal</code> and <code>sinVal</code> are the
5267 * cosine and sine values of theta (rotor flux position).
5268 * \par Fixed-Point Behavior
5269 * Care must be taken when using the Q31 version of the Park transform.
5270 * In particular, the overflow and saturation behavior of the accumulator used must be considered.
5271 * Refer to the function specific documentation below for usage guidelines.
5272 */
5273
5274 /**
5275 * @addtogroup inv_park
5276 * @{
5277 */
5278
5279 /**
5280 * @brief Floating-point Inverse Park transform
5281 * @param[in] Id input coordinate of rotor reference frame d
5282 * @param[in] Iq input coordinate of rotor reference frame q
5283 * @param[out] pIalpha points to output two-phase orthogonal vector axis alpha
5284 * @param[out] pIbeta points to output two-phase orthogonal vector axis beta
5285 * @param[in] sinVal sine value of rotation angle theta
5286 * @param[in] cosVal cosine value of rotation angle theta
5287 */
5288 CMSIS_INLINE __STATIC_INLINE void arm_inv_park_f32(
5289 float32_t Id,
5290 float32_t Iq,
5291 float32_t * pIalpha,
5292 float32_t * pIbeta,
5293 float32_t sinVal,
5294 float32_t cosVal)
5295 {
5296 /* Calculate pIalpha using the equation, pIalpha = Id * cosVal - Iq * sinVal */
5297 *pIalpha = Id * cosVal - Iq * sinVal;
5298
5299 /* Calculate pIbeta using the equation, pIbeta = Id * sinVal + Iq * cosVal */
5300 *pIbeta = Id * sinVal + Iq * cosVal;
5301 }
5302
5303
5304 /**
5305 * @brief Inverse Park transform for Q31 version
5306 * @param[in] Id input coordinate of rotor reference frame d
5307 * @param[in] Iq input coordinate of rotor reference frame q
5308 * @param[out] pIalpha points to output two-phase orthogonal vector axis alpha
5309 * @param[out] pIbeta points to output two-phase orthogonal vector axis beta
5310 * @param[in] sinVal sine value of rotation angle theta
5311 * @param[in] cosVal cosine value of rotation angle theta
5312 *
5313 * <b>Scaling and Overflow Behavior:</b>
5314 * \par
5315 * The function is implemented using an internal 32-bit accumulator.
5316 * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.
5317 * There is saturation on the addition, hence there is no risk of overflow.
5318 */
5319 CMSIS_INLINE __STATIC_INLINE void arm_inv_park_q31(
5320 q31_t Id,
5321 q31_t Iq,
5322 q31_t * pIalpha,
5323 q31_t * pIbeta,
5324 q31_t sinVal,
5325 q31_t cosVal)
5326 {
5327 q31_t product1, product2; /* Temporary variables used to store intermediate results */
5328 q31_t product3, product4; /* Temporary variables used to store intermediate results */
5329
5330 /* Intermediate product is calculated by (Id * cosVal) */
5331 product1 = (q31_t) (((q63_t) (Id) * (cosVal)) >> 31);
5332
5333 /* Intermediate product is calculated by (Iq * sinVal) */
5334 product2 = (q31_t) (((q63_t) (Iq) * (sinVal)) >> 31);
5335
5336
5337 /* Intermediate product is calculated by (Id * sinVal) */
5338 product3 = (q31_t) (((q63_t) (Id) * (sinVal)) >> 31);
5339
5340 /* Intermediate product is calculated by (Iq * cosVal) */
5341 product4 = (q31_t) (((q63_t) (Iq) * (cosVal)) >> 31);
5342
5343 /* Calculate pIalpha by using the two intermediate products 1 and 2 */
5344 *pIalpha = __QSUB(product1, product2);
5345
5346 /* Calculate pIbeta by using the two intermediate products 3 and 4 */
5347 *pIbeta = __QADD(product4, product3);
5348 }
5349
5350 /**
5351 * @} end of Inverse park group
5352 */
5353
5354
5355 /**
5356 * @brief Converts the elements of the Q31 vector to floating-point vector.
5357 * @param[in] pSrc is input pointer
5358 * @param[out] pDst is output pointer
5359 * @param[in] blockSize is the number of samples to process
5360 */
5361 void arm_q31_to_float(
5362 q31_t * pSrc,
5363 float32_t * pDst,
5364 uint32_t blockSize);
5365
5366 /**
5367 * @ingroup groupInterpolation
5368 */
5369
5370 /**
5371 * @defgroup LinearInterpolate Linear Interpolation
5372 *
5373 * Linear interpolation is a method of curve fitting using linear polynomials.
5374 * Linear interpolation works by effectively drawing a straight line between two neighboring samples and returning the appropriate point along that line
5375 *
5376 * \par
5377 * \image html LinearInterp.gif "Linear interpolation"
5378 *
5379 * \par
5380 * A Linear Interpolate function calculates an output value(y), for the input(x)
5381 * using linear interpolation of the input values x0, x1( nearest input values) and the output values y0 and y1(nearest output values)
5382 *
5383 * \par Algorithm:
5384 * <pre>
5385 * y = y0 + (x - x0) * ((y1 - y0)/(x1-x0))
5386 * where x0, x1 are nearest values of input x
5387 * y0, y1 are nearest values to output y
5388 * </pre>
5389 *
5390 * \par
5391 * This set of functions implements Linear interpolation process
5392 * for Q7, Q15, Q31, and floating-point data types. The functions operate on a single
5393 * sample of data and each call to the function returns a single processed value.
5394 * <code>S</code> points to an instance of the Linear Interpolate function data structure.
5395 * <code>x</code> is the input sample value. The functions returns the output value.
5396 *
5397 * \par
5398 * if x is outside of the table boundary, Linear interpolation returns first value of the table
5399 * if x is below input range and returns last value of table if x is above range.
5400 */
5401
5402 /**
5403 * @addtogroup LinearInterpolate
5404 * @{
5405 */
5406
5407 /**
5408 * @brief Process function for the floating-point Linear Interpolation Function.
5409 * @param[in,out] S is an instance of the floating-point Linear Interpolation structure
5410 * @param[in] x input sample to process
5411 * @return y processed output sample.
5412 *
5413 */
5414 CMSIS_INLINE __STATIC_INLINE float32_t arm_linear_interp_f32(
5415 arm_linear_interp_instance_f32 * S,
5416 float32_t x)
5417 {
5418 float32_t y;
5419 float32_t x0, x1; /* Nearest input values */
5420 float32_t y0, y1; /* Nearest output values */
5421 float32_t xSpacing = S->xSpacing; /* spacing between input values */
5422 int32_t i; /* Index variable */
5423 float32_t *pYData = S->pYData; /* pointer to output table */
5424
5425 /* Calculation of index */
5426 i = (int32_t) ((x - S->x1) / xSpacing);
5427
5428 if (i < 0)
5429 {
5430 /* Iniatilize output for below specified range as least output value of table */
5431 y = pYData[0];
5432 }
5433 else if ((uint32_t)i >= S->nValues)
5434 {
5435 /* Iniatilize output for above specified range as last output value of table */
5436 y = pYData[S->nValues - 1];
5437 }
5438 else
5439 {
5440 /* Calculation of nearest input values */
5441 x0 = S->x1 + i * xSpacing;
5442 x1 = S->x1 + (i + 1) * xSpacing;
5443
5444 /* Read of nearest output values */
5445 y0 = pYData[i];
5446 y1 = pYData[i + 1];
5447
5448 /* Calculation of output */
5449 y = y0 + (x - x0) * ((y1 - y0) / (x1 - x0));
5450
5451 }
5452
5453 /* returns output value */
5454 return (y);
5455 }
5456
5457
5458 /**
5459 *
5460 * @brief Process function for the Q31 Linear Interpolation Function.
5461 * @param[in] pYData pointer to Q31 Linear Interpolation table
5462 * @param[in] x input sample to process
5463 * @param[in] nValues number of table values
5464 * @return y processed output sample.
5465 *
5466 * \par
5467 * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
5468 * This function can support maximum of table size 2^12.
5469 *
5470 */
5471 CMSIS_INLINE __STATIC_INLINE q31_t arm_linear_interp_q31(
5472 q31_t * pYData,
5473 q31_t x,
5474 uint32_t nValues)
5475 {
5476 q31_t y; /* output */
5477 q31_t y0, y1; /* Nearest output values */
5478 q31_t fract; /* fractional part */
5479 int32_t index; /* Index to read nearest output values */
5480
5481 /* Input is in 12.20 format */
5482 /* 12 bits for the table index */
5483 /* Index value calculation */
5484 index = ((x & (q31_t)0xFFF00000) >> 20);
5485
5486 if (index >= (int32_t)(nValues - 1))
5487 {
5488 return (pYData[nValues - 1]);
5489 }
5490 else if (index < 0)
5491 {
5492 return (pYData[0]);
5493 }
5494 else
5495 {
5496 /* 20 bits for the fractional part */
5497 /* shift left by 11 to keep fract in 1.31 format */
5498 fract = (x & 0x000FFFFF) << 11;
5499
5500 /* Read two nearest output values from the index in 1.31(q31) format */
5501 y0 = pYData[index];
5502 y1 = pYData[index + 1];
5503
5504 /* Calculation of y0 * (1-fract) and y is in 2.30 format */
5505 y = ((q31_t) ((q63_t) y0 * (0x7FFFFFFF - fract) >> 32));
5506
5507 /* Calculation of y0 * (1-fract) + y1 *fract and y is in 2.30 format */
5508 y += ((q31_t) (((q63_t) y1 * fract) >> 32));
5509
5510 /* Convert y to 1.31 format */
5511 return (y << 1U);
5512 }
5513 }
5514
5515
5516 /**
5517 *
5518 * @brief Process function for the Q15 Linear Interpolation Function.
5519 * @param[in] pYData pointer to Q15 Linear Interpolation table
5520 * @param[in] x input sample to process
5521 * @param[in] nValues number of table values
5522 * @return y processed output sample.
5523 *
5524 * \par
5525 * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
5526 * This function can support maximum of table size 2^12.
5527 *
5528 */
5529 CMSIS_INLINE __STATIC_INLINE q15_t arm_linear_interp_q15(
5530 q15_t * pYData,
5531 q31_t x,
5532 uint32_t nValues)
5533 {
5534 q63_t y; /* output */
5535 q15_t y0, y1; /* Nearest output values */
5536 q31_t fract; /* fractional part */
5537 int32_t index; /* Index to read nearest output values */
5538
5539 /* Input is in 12.20 format */
5540 /* 12 bits for the table index */
5541 /* Index value calculation */
5542 index = ((x & (int32_t)0xFFF00000) >> 20);
5543
5544 if (index >= (int32_t)(nValues - 1))
5545 {
5546 return (pYData[nValues - 1]);
5547 }
5548 else if (index < 0)
5549 {
5550 return (pYData[0]);
5551 }
5552 else
5553 {
5554 /* 20 bits for the fractional part */
5555 /* fract is in 12.20 format */
5556 fract = (x & 0x000FFFFF);
5557
5558 /* Read two nearest output values from the index */
5559 y0 = pYData[index];
5560 y1 = pYData[index + 1];
5561
5562 /* Calculation of y0 * (1-fract) and y is in 13.35 format */
5563 y = ((q63_t) y0 * (0xFFFFF - fract));
5564
5565 /* Calculation of (y0 * (1-fract) + y1 * fract) and y is in 13.35 format */
5566 y += ((q63_t) y1 * (fract));
5567
5568 /* convert y to 1.15 format */
5569 return (q15_t) (y >> 20);
5570 }
5571 }
5572
5573
5574 /**
5575 *
5576 * @brief Process function for the Q7 Linear Interpolation Function.
5577 * @param[in] pYData pointer to Q7 Linear Interpolation table
5578 * @param[in] x input sample to process
5579 * @param[in] nValues number of table values
5580 * @return y processed output sample.
5581 *
5582 * \par
5583 * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
5584 * This function can support maximum of table size 2^12.
5585 */
5586 CMSIS_INLINE __STATIC_INLINE q7_t arm_linear_interp_q7(
5587 q7_t * pYData,
5588 q31_t x,
5589 uint32_t nValues)
5590 {
5591 q31_t y; /* output */
5592 q7_t y0, y1; /* Nearest output values */
5593 q31_t fract; /* fractional part */
5594 uint32_t index; /* Index to read nearest output values */
5595
5596 /* Input is in 12.20 format */
5597 /* 12 bits for the table index */
5598 /* Index value calculation */
5599 if (x < 0)
5600 {
5601 return (pYData[0]);
5602 }
5603 index = (x >> 20) & 0xfff;
5604
5605 if (index >= (nValues - 1))
5606 {
5607 return (pYData[nValues - 1]);
5608 }
5609 else
5610 {
5611 /* 20 bits for the fractional part */
5612 /* fract is in 12.20 format */
5613 fract = (x & 0x000FFFFF);
5614
5615 /* Read two nearest output values from the index and are in 1.7(q7) format */
5616 y0 = pYData[index];
5617 y1 = pYData[index + 1];
5618
5619 /* Calculation of y0 * (1-fract ) and y is in 13.27(q27) format */
5620 y = ((y0 * (0xFFFFF - fract)));
5621
5622 /* Calculation of y1 * fract + y0 * (1-fract) and y is in 13.27(q27) format */
5623 y += (y1 * fract);
5624
5625 /* convert y to 1.7(q7) format */
5626 return (q7_t) (y >> 20);
5627 }
5628 }
5629
5630 /**
5631 * @} end of LinearInterpolate group
5632 */
5633
5634 /**
5635 * @brief Fast approximation to the trigonometric sine function for floating-point data.
5636 * @param[in] x input value in radians.
5637 * @return sin(x).
5638 */
5639 float32_t arm_sin_f32(
5640 float32_t x);
5641
5642
5643 /**
5644 * @brief Fast approximation to the trigonometric sine function for Q31 data.
5645 * @param[in] x Scaled input value in radians.
5646 * @return sin(x).
5647 */
5648 q31_t arm_sin_q31(
5649 q31_t x);
5650
5651
5652 /**
5653 * @brief Fast approximation to the trigonometric sine function for Q15 data.
5654 * @param[in] x Scaled input value in radians.
5655 * @return sin(x).
5656 */
5657 q15_t arm_sin_q15(
5658 q15_t x);
5659
5660
5661 /**
5662 * @brief Fast approximation to the trigonometric cosine function for floating-point data.
5663 * @param[in] x input value in radians.
5664 * @return cos(x).
5665 */
5666 float32_t arm_cos_f32(
5667 float32_t x);
5668
5669
5670 /**
5671 * @brief Fast approximation to the trigonometric cosine function for Q31 data.
5672 * @param[in] x Scaled input value in radians.
5673 * @return cos(x).
5674 */
5675 q31_t arm_cos_q31(
5676 q31_t x);
5677
5678
5679 /**
5680 * @brief Fast approximation to the trigonometric cosine function for Q15 data.
5681 * @param[in] x Scaled input value in radians.
5682 * @return cos(x).
5683 */
5684 q15_t arm_cos_q15(
5685 q15_t x);
5686
5687
5688 /**
5689 * @ingroup groupFastMath
5690 */
5691
5692
5693 /**
5694 * @defgroup SQRT Square Root
5695 *
5696 * Computes the square root of a number.
5697 * There are separate functions for Q15, Q31, and floating-point data types.
5698 * The square root function is computed using the Newton-Raphson algorithm.
5699 * This is an iterative algorithm of the form:
5700 * <pre>
5701 * x1 = x0 - f(x0)/f'(x0)
5702 * </pre>
5703 * where <code>x1</code> is the current estimate,
5704 * <code>x0</code> is the previous estimate, and
5705 * <code>f'(x0)</code> is the derivative of <code>f()</code> evaluated at <code>x0</code>.
5706 * For the square root function, the algorithm reduces to:
5707 * <pre>
5708 * x0 = in/2 [initial guess]
5709 * x1 = 1/2 * ( x0 + in / x0) [each iteration]
5710 * </pre>
5711 */
5712
5713
5714 /**
5715 * @addtogroup SQRT
5716 * @{
5717 */
5718
5719 /**
5720 * @brief Floating-point square root function.
5721 * @param[in] in input value.
5722 * @param[out] pOut square root of input value.
5723 * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if
5724 * <code>in</code> is negative value and returns zero output for negative values.
5725 */
5726 CMSIS_INLINE __STATIC_INLINE arm_status arm_sqrt_f32(
5727 float32_t in,
5728 float32_t * pOut)
5729 {
5730 if (in >= 0.0f)
5731 {
5732
5733#if (__FPU_USED == 1) && defined ( __CC_ARM )
5734 *pOut = __sqrtf(in);
5735#elif (__FPU_USED == 1) && (defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050))
5736 *pOut = __builtin_sqrtf(in);
5737#elif (__FPU_USED == 1) && defined(__GNUC__)
5738 *pOut = __builtin_sqrtf(in);
5739#elif (__FPU_USED == 1) && defined ( __ICCARM__ ) && (__VER__ >= 6040000)
5740 __ASM("VSQRT.F32 %0,%1" : "=t"(*pOut) : "t"(in));
5741#else
5742 *pOut = sqrtf(in);
5743#endif
5744
5745 return (ARM_MATH_SUCCESS);
5746 }
5747 else
5748 {
5749 *pOut = 0.0f;
5750 return (ARM_MATH_ARGUMENT_ERROR);
5751 }
5752 }
5753
5754
5755 /**
5756 * @brief Q31 square root function.
5757 * @param[in] in input value. The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF.
5758 * @param[out] pOut square root of input value.
5759 * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if
5760 * <code>in</code> is negative value and returns zero output for negative values.
5761 */
5762 arm_status arm_sqrt_q31(
5763 q31_t in,
5764 q31_t * pOut);
5765
5766
5767 /**
5768 * @brief Q15 square root function.
5769 * @param[in] in input value. The range of the input value is [0 +1) or 0x0000 to 0x7FFF.
5770 * @param[out] pOut square root of input value.
5771 * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if
5772 * <code>in</code> is negative value and returns zero output for negative values.
5773 */
5774 arm_status arm_sqrt_q15(
5775 q15_t in,
5776 q15_t * pOut);
5777
5778 /**
5779 * @} end of SQRT group
5780 */
5781
5782
5783 /**
5784 * @brief floating-point Circular write function.
5785 */
5786 CMSIS_INLINE __STATIC_INLINE void arm_circularWrite_f32(
5787 int32_t * circBuffer,
5788 int32_t L,
5789 uint16_t * writeOffset,
5790 int32_t bufferInc,
5791 const int32_t * src,
5792 int32_t srcInc,
5793 uint32_t blockSize)
5794 {
5795 uint32_t i = 0U;
5796 int32_t wOffset;
5797
5798 /* Copy the value of Index pointer that points
5799 * to the current location where the input samples to be copied */
5800 wOffset = *writeOffset;
5801
5802 /* Loop over the blockSize */
5803 i = blockSize;
5804
5805 while (i > 0U)
5806 {
5807 /* copy the input sample to the circular buffer */
5808 circBuffer[wOffset] = *src;
5809
5810 /* Update the input pointer */
5811 src += srcInc;
5812
5813 /* Circularly update wOffset. Watch out for positive and negative value */
5814 wOffset += bufferInc;
5815 if (wOffset >= L)
5816 wOffset -= L;
5817
5818 /* Decrement the loop counter */
5819 i--;
5820 }
5821
5822 /* Update the index pointer */
5823 *writeOffset = (uint16_t)wOffset;
5824 }
5825
5826
5827
5828 /**
5829 * @brief floating-point Circular Read function.
5830 */
5831 CMSIS_INLINE __STATIC_INLINE void arm_circularRead_f32(
5832 int32_t * circBuffer,
5833 int32_t L,
5834 int32_t * readOffset,
5835 int32_t bufferInc,
5836 int32_t * dst,
5837 int32_t * dst_base,
5838 int32_t dst_length,
5839 int32_t dstInc,
5840 uint32_t blockSize)
5841 {
5842 uint32_t i = 0U;
5843 int32_t rOffset, dst_end;
5844
5845 /* Copy the value of Index pointer that points
5846 * to the current location from where the input samples to be read */
5847 rOffset = *readOffset;
5848 dst_end = (int32_t) (dst_base + dst_length);
5849
5850 /* Loop over the blockSize */
5851 i = blockSize;
5852
5853 while (i > 0U)
5854 {
5855 /* copy the sample from the circular buffer to the destination buffer */
5856 *dst = circBuffer[rOffset];
5857
5858 /* Update the input pointer */
5859 dst += dstInc;
5860
5861 if (dst == (int32_t *) dst_end)
5862 {
5863 dst = dst_base;
5864 }
5865
5866 /* Circularly update rOffset. Watch out for positive and negative value */
5867 rOffset += bufferInc;
5868
5869 if (rOffset >= L)
5870 {
5871 rOffset -= L;
5872 }
5873
5874 /* Decrement the loop counter */
5875 i--;
5876 }
5877
5878 /* Update the index pointer */
5879 *readOffset = rOffset;
5880 }
5881
5882
5883 /**
5884 * @brief Q15 Circular write function.
5885 */
5886 CMSIS_INLINE __STATIC_INLINE void arm_circularWrite_q15(
5887 q15_t * circBuffer,
5888 int32_t L,
5889 uint16_t * writeOffset,
5890 int32_t bufferInc,
5891 const q15_t * src,
5892 int32_t srcInc,
5893 uint32_t blockSize)
5894 {
5895 uint32_t i = 0U;
5896 int32_t wOffset;
5897
5898 /* Copy the value of Index pointer that points
5899 * to the current location where the input samples to be copied */
5900 wOffset = *writeOffset;
5901
5902 /* Loop over the blockSize */
5903 i = blockSize;
5904
5905 while (i > 0U)
5906 {
5907 /* copy the input sample to the circular buffer */
5908 circBuffer[wOffset] = *src;
5909
5910 /* Update the input pointer */
5911 src += srcInc;
5912
5913 /* Circularly update wOffset. Watch out for positive and negative value */
5914 wOffset += bufferInc;
5915 if (wOffset >= L)
5916 wOffset -= L;
5917
5918 /* Decrement the loop counter */
5919 i--;
5920 }
5921
5922 /* Update the index pointer */
5923 *writeOffset = (uint16_t)wOffset;
5924 }
5925
5926
5927 /**
5928 * @brief Q15 Circular Read function.
5929 */
5930 CMSIS_INLINE __STATIC_INLINE void arm_circularRead_q15(
5931 q15_t * circBuffer,
5932 int32_t L,
5933 int32_t * readOffset,
5934 int32_t bufferInc,
5935 q15_t * dst,
5936 q15_t * dst_base,
5937 int32_t dst_length,
5938 int32_t dstInc,
5939 uint32_t blockSize)
5940 {
5941 uint32_t i = 0;
5942 int32_t rOffset, dst_end;
5943
5944 /* Copy the value of Index pointer that points
5945 * to the current location from where the input samples to be read */
5946 rOffset = *readOffset;
5947
5948 dst_end = (int32_t) (dst_base + dst_length);
5949
5950 /* Loop over the blockSize */
5951 i = blockSize;
5952
5953 while (i > 0U)
5954 {
5955 /* copy the sample from the circular buffer to the destination buffer */
5956 *dst = circBuffer[rOffset];
5957
5958 /* Update the input pointer */
5959 dst += dstInc;
5960
5961 if (dst == (q15_t *) dst_end)
5962 {
5963 dst = dst_base;
5964 }
5965
5966 /* Circularly update wOffset. Watch out for positive and negative value */
5967 rOffset += bufferInc;
5968
5969 if (rOffset >= L)
5970 {
5971 rOffset -= L;
5972 }
5973
5974 /* Decrement the loop counter */
5975 i--;
5976 }
5977
5978 /* Update the index pointer */
5979 *readOffset = rOffset;
5980 }
5981
5982
5983 /**
5984 * @brief Q7 Circular write function.
5985 */
5986 CMSIS_INLINE __STATIC_INLINE void arm_circularWrite_q7(
5987 q7_t * circBuffer,
5988 int32_t L,
5989 uint16_t * writeOffset,
5990 int32_t bufferInc,
5991 const q7_t * src,
5992 int32_t srcInc,
5993 uint32_t blockSize)
5994 {
5995 uint32_t i = 0U;
5996 int32_t wOffset;
5997
5998 /* Copy the value of Index pointer that points
5999 * to the current location where the input samples to be copied */
6000 wOffset = *writeOffset;
6001
6002 /* Loop over the blockSize */
6003 i = blockSize;
6004
6005 while (i > 0U)
6006 {
6007 /* copy the input sample to the circular buffer */
6008 circBuffer[wOffset] = *src;
6009
6010 /* Update the input pointer */
6011 src += srcInc;
6012
6013 /* Circularly update wOffset. Watch out for positive and negative value */
6014 wOffset += bufferInc;
6015 if (wOffset >= L)
6016 wOffset -= L;
6017
6018 /* Decrement the loop counter */
6019 i--;
6020 }
6021
6022 /* Update the index pointer */
6023 *writeOffset = (uint16_t)wOffset;
6024 }
6025
6026
6027 /**
6028 * @brief Q7 Circular Read function.
6029 */
6030 CMSIS_INLINE __STATIC_INLINE void arm_circularRead_q7(
6031 q7_t * circBuffer,
6032 int32_t L,
6033 int32_t * readOffset,
6034 int32_t bufferInc,
6035 q7_t * dst,
6036 q7_t * dst_base,
6037 int32_t dst_length,
6038 int32_t dstInc,
6039 uint32_t blockSize)
6040 {
6041 uint32_t i = 0;
6042 int32_t rOffset, dst_end;
6043
6044 /* Copy the value of Index pointer that points
6045 * to the current location from where the input samples to be read */
6046 rOffset = *readOffset;
6047
6048 dst_end = (int32_t) (dst_base + dst_length);
6049
6050 /* Loop over the blockSize */
6051 i = blockSize;
6052
6053 while (i > 0U)
6054 {
6055 /* copy the sample from the circular buffer to the destination buffer */
6056 *dst = circBuffer[rOffset];
6057
6058 /* Update the input pointer */
6059 dst += dstInc;
6060
6061 if (dst == (q7_t *) dst_end)
6062 {
6063 dst = dst_base;
6064 }
6065
6066 /* Circularly update rOffset. Watch out for positive and negative value */
6067 rOffset += bufferInc;
6068
6069 if (rOffset >= L)
6070 {
6071 rOffset -= L;
6072 }
6073
6074 /* Decrement the loop counter */
6075 i--;
6076 }
6077
6078 /* Update the index pointer */
6079 *readOffset = rOffset;
6080 }
6081
6082
6083 /**
6084 * @brief Sum of the squares of the elements of a Q31 vector.
6085 * @param[in] pSrc is input pointer
6086 * @param[in] blockSize is the number of samples to process
6087 * @param[out] pResult is output value.
6088 */
6089 void arm_power_q31(
6090 q31_t * pSrc,
6091 uint32_t blockSize,
6092 q63_t * pResult);
6093
6094
6095 /**
6096 * @brief Sum of the squares of the elements of a floating-point vector.
6097 * @param[in] pSrc is input pointer
6098 * @param[in] blockSize is the number of samples to process
6099 * @param[out] pResult is output value.
6100 */
6101 void arm_power_f32(
6102 float32_t * pSrc,
6103 uint32_t blockSize,
6104 float32_t * pResult);
6105
6106
6107 /**
6108 * @brief Sum of the squares of the elements of a Q15 vector.
6109 * @param[in] pSrc is input pointer
6110 * @param[in] blockSize is the number of samples to process
6111 * @param[out] pResult is output value.
6112 */
6113 void arm_power_q15(
6114 q15_t * pSrc,
6115 uint32_t blockSize,
6116 q63_t * pResult);
6117
6118
6119 /**
6120 * @brief Sum of the squares of the elements of a Q7 vector.
6121 * @param[in] pSrc is input pointer
6122 * @param[in] blockSize is the number of samples to process
6123 * @param[out] pResult is output value.
6124 */
6125 void arm_power_q7(
6126 q7_t * pSrc,
6127 uint32_t blockSize,
6128 q31_t * pResult);
6129
6130
6131 /**
6132 * @brief Mean value of a Q7 vector.
6133 * @param[in] pSrc is input pointer
6134 * @param[in] blockSize is the number of samples to process
6135 * @param[out] pResult is output value.
6136 */
6137 void arm_mean_q7(
6138 q7_t * pSrc,
6139 uint32_t blockSize,
6140 q7_t * pResult);
6141
6142
6143 /**
6144 * @brief Mean value of a Q15 vector.
6145 * @param[in] pSrc is input pointer
6146 * @param[in] blockSize is the number of samples to process
6147 * @param[out] pResult is output value.
6148 */
6149 void arm_mean_q15(
6150 q15_t * pSrc,
6151 uint32_t blockSize,
6152 q15_t * pResult);
6153
6154
6155 /**
6156 * @brief Mean value of a Q31 vector.
6157 * @param[in] pSrc is input pointer
6158 * @param[in] blockSize is the number of samples to process
6159 * @param[out] pResult is output value.
6160 */
6161 void arm_mean_q31(
6162 q31_t * pSrc,
6163 uint32_t blockSize,
6164 q31_t * pResult);
6165
6166
6167 /**
6168 * @brief Mean value of a floating-point vector.
6169 * @param[in] pSrc is input pointer
6170 * @param[in] blockSize is the number of samples to process
6171 * @param[out] pResult is output value.
6172 */
6173 void arm_mean_f32(
6174 float32_t * pSrc,
6175 uint32_t blockSize,
6176 float32_t * pResult);
6177
6178
6179 /**
6180 * @brief Variance of the elements of a floating-point vector.
6181 * @param[in] pSrc is input pointer
6182 * @param[in] blockSize is the number of samples to process
6183 * @param[out] pResult is output value.
6184 */
6185 void arm_var_f32(
6186 float32_t * pSrc,
6187 uint32_t blockSize,
6188 float32_t * pResult);
6189
6190
6191 /**
6192 * @brief Variance of the elements of a Q31 vector.
6193 * @param[in] pSrc is input pointer
6194 * @param[in] blockSize is the number of samples to process
6195 * @param[out] pResult is output value.
6196 */
6197 void arm_var_q31(
6198 q31_t * pSrc,
6199 uint32_t blockSize,
6200 q31_t * pResult);
6201
6202
6203 /**
6204 * @brief Variance of the elements of a Q15 vector.
6205 * @param[in] pSrc is input pointer
6206 * @param[in] blockSize is the number of samples to process
6207 * @param[out] pResult is output value.
6208 */
6209 void arm_var_q15(
6210 q15_t * pSrc,
6211 uint32_t blockSize,
6212 q15_t * pResult);
6213
6214
6215 /**
6216 * @brief Root Mean Square of the elements of a floating-point vector.
6217 * @param[in] pSrc is input pointer
6218 * @param[in] blockSize is the number of samples to process
6219 * @param[out] pResult is output value.
6220 */
6221 void arm_rms_f32(
6222 float32_t * pSrc,
6223 uint32_t blockSize,
6224 float32_t * pResult);
6225
6226
6227 /**
6228 * @brief Root Mean Square of the elements of a Q31 vector.
6229 * @param[in] pSrc is input pointer
6230 * @param[in] blockSize is the number of samples to process
6231 * @param[out] pResult is output value.
6232 */
6233 void arm_rms_q31(
6234 q31_t * pSrc,
6235 uint32_t blockSize,
6236 q31_t * pResult);
6237
6238
6239 /**
6240 * @brief Root Mean Square of the elements of a Q15 vector.
6241 * @param[in] pSrc is input pointer
6242 * @param[in] blockSize is the number of samples to process
6243 * @param[out] pResult is output value.
6244 */
6245 void arm_rms_q15(
6246 q15_t * pSrc,
6247 uint32_t blockSize,
6248 q15_t * pResult);
6249
6250
6251 /**
6252 * @brief Standard deviation of the elements of a floating-point vector.
6253 * @param[in] pSrc is input pointer
6254 * @param[in] blockSize is the number of samples to process
6255 * @param[out] pResult is output value.
6256 */
6257 void arm_std_f32(
6258 float32_t * pSrc,
6259 uint32_t blockSize,
6260 float32_t * pResult);
6261
6262
6263 /**
6264 * @brief Standard deviation of the elements of a Q31 vector.
6265 * @param[in] pSrc is input pointer
6266 * @param[in] blockSize is the number of samples to process
6267 * @param[out] pResult is output value.
6268 */
6269 void arm_std_q31(
6270 q31_t * pSrc,
6271 uint32_t blockSize,
6272 q31_t * pResult);
6273
6274
6275 /**
6276 * @brief Standard deviation of the elements of a Q15 vector.
6277 * @param[in] pSrc is input pointer
6278 * @param[in] blockSize is the number of samples to process
6279 * @param[out] pResult is output value.
6280 */
6281 void arm_std_q15(
6282 q15_t * pSrc,
6283 uint32_t blockSize,
6284 q15_t * pResult);
6285
6286
6287 /**
6288 * @brief Floating-point complex magnitude
6289 * @param[in] pSrc points to the complex input vector
6290 * @param[out] pDst points to the real output vector
6291 * @param[in] numSamples number of complex samples in the input vector
6292 */
6293 void arm_cmplx_mag_f32(
6294 float32_t * pSrc,
6295 float32_t * pDst,
6296 uint32_t numSamples);
6297
6298
6299 /**
6300 * @brief Q31 complex magnitude
6301 * @param[in] pSrc points to the complex input vector
6302 * @param[out] pDst points to the real output vector
6303 * @param[in] numSamples number of complex samples in the input vector
6304 */
6305 void arm_cmplx_mag_q31(
6306 q31_t * pSrc,
6307 q31_t * pDst,
6308 uint32_t numSamples);
6309
6310
6311 /**
6312 * @brief Q15 complex magnitude
6313 * @param[in] pSrc points to the complex input vector
6314 * @param[out] pDst points to the real output vector
6315 * @param[in] numSamples number of complex samples in the input vector
6316 */
6317 void arm_cmplx_mag_q15(
6318 q15_t * pSrc,
6319 q15_t * pDst,
6320 uint32_t numSamples);
6321
6322
6323 /**
6324 * @brief Q15 complex dot product
6325 * @param[in] pSrcA points to the first input vector
6326 * @param[in] pSrcB points to the second input vector
6327 * @param[in] numSamples number of complex samples in each vector
6328 * @param[out] realResult real part of the result returned here
6329 * @param[out] imagResult imaginary part of the result returned here
6330 */
6331 void arm_cmplx_dot_prod_q15(
6332 q15_t * pSrcA,
6333 q15_t * pSrcB,
6334 uint32_t numSamples,
6335 q31_t * realResult,
6336 q31_t * imagResult);
6337
6338
6339 /**
6340 * @brief Q31 complex dot product
6341 * @param[in] pSrcA points to the first input vector
6342 * @param[in] pSrcB points to the second input vector
6343 * @param[in] numSamples number of complex samples in each vector
6344 * @param[out] realResult real part of the result returned here
6345 * @param[out] imagResult imaginary part of the result returned here
6346 */
6347 void arm_cmplx_dot_prod_q31(
6348 q31_t * pSrcA,
6349 q31_t * pSrcB,
6350 uint32_t numSamples,
6351 q63_t * realResult,
6352 q63_t * imagResult);
6353
6354
6355 /**
6356 * @brief Floating-point complex dot product
6357 * @param[in] pSrcA points to the first input vector
6358 * @param[in] pSrcB points to the second input vector
6359 * @param[in] numSamples number of complex samples in each vector
6360 * @param[out] realResult real part of the result returned here
6361 * @param[out] imagResult imaginary part of the result returned here
6362 */
6363 void arm_cmplx_dot_prod_f32(
6364 float32_t * pSrcA,
6365 float32_t * pSrcB,
6366 uint32_t numSamples,
6367 float32_t * realResult,
6368 float32_t * imagResult);
6369
6370
6371 /**
6372 * @brief Q15 complex-by-real multiplication
6373 * @param[in] pSrcCmplx points to the complex input vector
6374 * @param[in] pSrcReal points to the real input vector
6375 * @param[out] pCmplxDst points to the complex output vector
6376 * @param[in] numSamples number of samples in each vector
6377 */
6378 void arm_cmplx_mult_real_q15(
6379 q15_t * pSrcCmplx,
6380 q15_t * pSrcReal,
6381 q15_t * pCmplxDst,
6382 uint32_t numSamples);
6383
6384
6385 /**
6386 * @brief Q31 complex-by-real multiplication
6387 * @param[in] pSrcCmplx points to the complex input vector
6388 * @param[in] pSrcReal points to the real input vector
6389 * @param[out] pCmplxDst points to the complex output vector
6390 * @param[in] numSamples number of samples in each vector
6391 */
6392 void arm_cmplx_mult_real_q31(
6393 q31_t * pSrcCmplx,
6394 q31_t * pSrcReal,
6395 q31_t * pCmplxDst,
6396 uint32_t numSamples);
6397
6398
6399 /**
6400 * @brief Floating-point complex-by-real multiplication
6401 * @param[in] pSrcCmplx points to the complex input vector
6402 * @param[in] pSrcReal points to the real input vector
6403 * @param[out] pCmplxDst points to the complex output vector
6404 * @param[in] numSamples number of samples in each vector
6405 */
6406 void arm_cmplx_mult_real_f32(
6407 float32_t * pSrcCmplx,
6408 float32_t * pSrcReal,
6409 float32_t * pCmplxDst,
6410 uint32_t numSamples);
6411
6412
6413 /**
6414 * @brief Minimum value of a Q7 vector.
6415 * @param[in] pSrc is input pointer
6416 * @param[in] blockSize is the number of samples to process
6417 * @param[out] result is output pointer
6418 * @param[in] index is the array index of the minimum value in the input buffer.
6419 */
6420 void arm_min_q7(
6421 q7_t * pSrc,
6422 uint32_t blockSize,
6423 q7_t * result,
6424 uint32_t * index);
6425
6426
6427 /**
6428 * @brief Minimum value of a Q15 vector.
6429 * @param[in] pSrc is input pointer
6430 * @param[in] blockSize is the number of samples to process
6431 * @param[out] pResult is output pointer
6432 * @param[in] pIndex is the array index of the minimum value in the input buffer.
6433 */
6434 void arm_min_q15(
6435 q15_t * pSrc,
6436 uint32_t blockSize,
6437 q15_t * pResult,
6438 uint32_t * pIndex);
6439
6440
6441 /**
6442 * @brief Minimum value of a Q31 vector.
6443 * @param[in] pSrc is input pointer
6444 * @param[in] blockSize is the number of samples to process
6445 * @param[out] pResult is output pointer
6446 * @param[out] pIndex is the array index of the minimum value in the input buffer.
6447 */
6448 void arm_min_q31(
6449 q31_t * pSrc,
6450 uint32_t blockSize,
6451 q31_t * pResult,
6452 uint32_t * pIndex);
6453
6454
6455 /**
6456 * @brief Minimum value of a floating-point vector.
6457 * @param[in] pSrc is input pointer
6458 * @param[in] blockSize is the number of samples to process
6459 * @param[out] pResult is output pointer
6460 * @param[out] pIndex is the array index of the minimum value in the input buffer.
6461 */
6462 void arm_min_f32(
6463 float32_t * pSrc,
6464 uint32_t blockSize,
6465 float32_t * pResult,
6466 uint32_t * pIndex);
6467
6468
6469/**
6470 * @brief Maximum value of a Q7 vector.
6471 * @param[in] pSrc points to the input buffer
6472 * @param[in] blockSize length of the input vector
6473 * @param[out] pResult maximum value returned here
6474 * @param[out] pIndex index of maximum value returned here
6475 */
6476 void arm_max_q7(
6477 q7_t * pSrc,
6478 uint32_t blockSize,
6479 q7_t * pResult,
6480 uint32_t * pIndex);
6481
6482
6483/**
6484 * @brief Maximum value of a Q15 vector.
6485 * @param[in] pSrc points to the input buffer
6486 * @param[in] blockSize length of the input vector
6487 * @param[out] pResult maximum value returned here
6488 * @param[out] pIndex index of maximum value returned here
6489 */
6490 void arm_max_q15(
6491 q15_t * pSrc,
6492 uint32_t blockSize,
6493 q15_t * pResult,
6494 uint32_t * pIndex);
6495
6496
6497/**
6498 * @brief Maximum value of a Q31 vector.
6499 * @param[in] pSrc points to the input buffer
6500 * @param[in] blockSize length of the input vector
6501 * @param[out] pResult maximum value returned here
6502 * @param[out] pIndex index of maximum value returned here
6503 */
6504 void arm_max_q31(
6505 q31_t * pSrc,
6506 uint32_t blockSize,
6507 q31_t * pResult,
6508 uint32_t * pIndex);
6509
6510
6511/**
6512 * @brief Maximum value of a floating-point vector.
6513 * @param[in] pSrc points to the input buffer
6514 * @param[in] blockSize length of the input vector
6515 * @param[out] pResult maximum value returned here
6516 * @param[out] pIndex index of maximum value returned here
6517 */
6518 void arm_max_f32(
6519 float32_t * pSrc,
6520 uint32_t blockSize,
6521 float32_t * pResult,
6522 uint32_t * pIndex);
6523
6524
6525 /**
6526 * @brief Q15 complex-by-complex multiplication
6527 * @param[in] pSrcA points to the first input vector
6528 * @param[in] pSrcB points to the second input vector
6529 * @param[out] pDst points to the output vector
6530 * @param[in] numSamples number of complex samples in each vector
6531 */
6532 void arm_cmplx_mult_cmplx_q15(
6533 q15_t * pSrcA,
6534 q15_t * pSrcB,
6535 q15_t * pDst,
6536 uint32_t numSamples);
6537
6538
6539 /**
6540 * @brief Q31 complex-by-complex multiplication
6541 * @param[in] pSrcA points to the first input vector
6542 * @param[in] pSrcB points to the second input vector
6543 * @param[out] pDst points to the output vector
6544 * @param[in] numSamples number of complex samples in each vector
6545 */
6546 void arm_cmplx_mult_cmplx_q31(
6547 q31_t * pSrcA,
6548 q31_t * pSrcB,
6549 q31_t * pDst,
6550 uint32_t numSamples);
6551
6552
6553 /**
6554 * @brief Floating-point complex-by-complex multiplication
6555 * @param[in] pSrcA points to the first input vector
6556 * @param[in] pSrcB points to the second input vector
6557 * @param[out] pDst points to the output vector
6558 * @param[in] numSamples number of complex samples in each vector
6559 */
6560 void arm_cmplx_mult_cmplx_f32(
6561 float32_t * pSrcA,
6562 float32_t * pSrcB,
6563 float32_t * pDst,
6564 uint32_t numSamples);
6565
6566
6567 /**
6568 * @brief Converts the elements of the floating-point vector to Q31 vector.
6569 * @param[in] pSrc points to the floating-point input vector
6570 * @param[out] pDst points to the Q31 output vector
6571 * @param[in] blockSize length of the input vector
6572 */
6573 void arm_float_to_q31(
6574 float32_t * pSrc,
6575 q31_t * pDst,
6576 uint32_t blockSize);
6577
6578
6579 /**
6580 * @brief Converts the elements of the floating-point vector to Q15 vector.
6581 * @param[in] pSrc points to the floating-point input vector
6582 * @param[out] pDst points to the Q15 output vector
6583 * @param[in] blockSize length of the input vector
6584 */
6585 void arm_float_to_q15(
6586 float32_t * pSrc,
6587 q15_t * pDst,
6588 uint32_t blockSize);
6589
6590
6591 /**
6592 * @brief Converts the elements of the floating-point vector to Q7 vector.
6593 * @param[in] pSrc points to the floating-point input vector
6594 * @param[out] pDst points to the Q7 output vector
6595 * @param[in] blockSize length of the input vector
6596 */
6597 void arm_float_to_q7(
6598 float32_t * pSrc,
6599 q7_t * pDst,
6600 uint32_t blockSize);
6601
6602
6603 /**
6604 * @brief Converts the elements of the Q31 vector to Q15 vector.
6605 * @param[in] pSrc is input pointer
6606 * @param[out] pDst is output pointer
6607 * @param[in] blockSize is the number of samples to process
6608 */
6609 void arm_q31_to_q15(
6610 q31_t * pSrc,
6611 q15_t * pDst,
6612 uint32_t blockSize);
6613
6614
6615 /**
6616 * @brief Converts the elements of the Q31 vector to Q7 vector.
6617 * @param[in] pSrc is input pointer
6618 * @param[out] pDst is output pointer
6619 * @param[in] blockSize is the number of samples to process
6620 */
6621 void arm_q31_to_q7(
6622 q31_t * pSrc,
6623 q7_t * pDst,
6624 uint32_t blockSize);
6625
6626
6627 /**
6628 * @brief Converts the elements of the Q15 vector to floating-point vector.
6629 * @param[in] pSrc is input pointer
6630 * @param[out] pDst is output pointer
6631 * @param[in] blockSize is the number of samples to process
6632 */
6633 void arm_q15_to_float(
6634 q15_t * pSrc,
6635 float32_t * pDst,
6636 uint32_t blockSize);
6637
6638
6639 /**
6640 * @brief Converts the elements of the Q15 vector to Q31 vector.
6641 * @param[in] pSrc is input pointer
6642 * @param[out] pDst is output pointer
6643 * @param[in] blockSize is the number of samples to process
6644 */
6645 void arm_q15_to_q31(
6646 q15_t * pSrc,
6647 q31_t * pDst,
6648 uint32_t blockSize);
6649
6650
6651 /**
6652 * @brief Converts the elements of the Q15 vector to Q7 vector.
6653 * @param[in] pSrc is input pointer
6654 * @param[out] pDst is output pointer
6655 * @param[in] blockSize is the number of samples to process
6656 */
6657 void arm_q15_to_q7(
6658 q15_t * pSrc,
6659 q7_t * pDst,
6660 uint32_t blockSize);
6661
6662
6663 /**
6664 * @ingroup groupInterpolation
6665 */
6666
6667 /**
6668 * @defgroup BilinearInterpolate Bilinear Interpolation
6669 *
6670 * Bilinear interpolation is an extension of linear interpolation applied to a two dimensional grid.
6671 * The underlying function <code>f(x, y)</code> is sampled on a regular grid and the interpolation process
6672 * determines values between the grid points.
6673 * Bilinear interpolation is equivalent to two step linear interpolation, first in the x-dimension and then in the y-dimension.
6674 * Bilinear interpolation is often used in image processing to rescale images.
6675 * The CMSIS DSP library provides bilinear interpolation functions for Q7, Q15, Q31, and floating-point data types.
6676 *
6677 * <b>Algorithm</b>
6678 * \par
6679 * The instance structure used by the bilinear interpolation functions describes a two dimensional data table.
6680 * For floating-point, the instance structure is defined as:
6681 * <pre>
6682 * typedef struct
6683 * {
6684 * uint16_t numRows;
6685 * uint16_t numCols;
6686 * float32_t *pData;
6687 * } arm_bilinear_interp_instance_f32;
6688 * </pre>
6689 *
6690 * \par
6691 * where <code>numRows</code> specifies the number of rows in the table;
6692 * <code>numCols</code> specifies the number of columns in the table;
6693 * and <code>pData</code> points to an array of size <code>numRows*numCols</code> values.
6694 * The data table <code>pTable</code> is organized in row order and the supplied data values fall on integer indexes.
6695 * That is, table element (x,y) is located at <code>pTable[x + y*numCols]</code> where x and y are integers.
6696 *
6697 * \par
6698 * Let <code>(x, y)</code> specify the desired interpolation point. Then define:
6699 * <pre>
6700 * XF = floor(x)
6701 * YF = floor(y)
6702 * </pre>
6703 * \par
6704 * The interpolated output point is computed as:
6705 * <pre>
6706 * f(x, y) = f(XF, YF) * (1-(x-XF)) * (1-(y-YF))
6707 * + f(XF+1, YF) * (x-XF)*(1-(y-YF))
6708 * + f(XF, YF+1) * (1-(x-XF))*(y-YF)
6709 * + f(XF+1, YF+1) * (x-XF)*(y-YF)
6710 * </pre>
6711 * Note that the coordinates (x, y) contain integer and fractional components.
6712 * The integer components specify which portion of the table to use while the
6713 * fractional components control the interpolation processor.
6714 *
6715 * \par
6716 * if (x,y) are outside of the table boundary, Bilinear interpolation returns zero output.
6717 */
6718
6719 /**
6720 * @addtogroup BilinearInterpolate
6721 * @{
6722 */
6723
6724
6725 /**
6726 *
6727 * @brief Floating-point bilinear interpolation.
6728 * @param[in,out] S points to an instance of the interpolation structure.
6729 * @param[in] X interpolation coordinate.
6730 * @param[in] Y interpolation coordinate.
6731 * @return out interpolated value.
6732 */
6733 CMSIS_INLINE __STATIC_INLINE float32_t arm_bilinear_interp_f32(
6734 const arm_bilinear_interp_instance_f32 * S,
6735 float32_t X,
6736 float32_t Y)
6737 {
6738 float32_t out;
6739 float32_t f00, f01, f10, f11;
6740 float32_t *pData = S->pData;
6741 int32_t xIndex, yIndex, index;
6742 float32_t xdiff, ydiff;
6743 float32_t b1, b2, b3, b4;
6744
6745 xIndex = (int32_t) X;
6746 yIndex = (int32_t) Y;
6747
6748 /* Care taken for table outside boundary */
6749 /* Returns zero output when values are outside table boundary */
6750 if (xIndex < 0 || xIndex > (S->numRows - 1) || yIndex < 0 || yIndex > (S->numCols - 1))
6751 {
6752 return (0);
6753 }
6754
6755 /* Calculation of index for two nearest points in X-direction */
6756 index = (xIndex - 1) + (yIndex - 1) * S->numCols;
6757
6758
6759 /* Read two nearest points in X-direction */
6760 f00 = pData[index];
6761 f01 = pData[index + 1];
6762
6763 /* Calculation of index for two nearest points in Y-direction */
6764 index = (xIndex - 1) + (yIndex) * S->numCols;
6765
6766
6767 /* Read two nearest points in Y-direction */
6768 f10 = pData[index];
6769 f11 = pData[index + 1];
6770
6771 /* Calculation of intermediate values */
6772 b1 = f00;
6773 b2 = f01 - f00;
6774 b3 = f10 - f00;
6775 b4 = f00 - f01 - f10 + f11;
6776
6777 /* Calculation of fractional part in X */
6778 xdiff = X - xIndex;
6779
6780 /* Calculation of fractional part in Y */
6781 ydiff = Y - yIndex;
6782
6783 /* Calculation of bi-linear interpolated output */
6784 out = b1 + b2 * xdiff + b3 * ydiff + b4 * xdiff * ydiff;
6785
6786 /* return to application */
6787 return (out);
6788 }
6789
6790
6791 /**
6792 *
6793 * @brief Q31 bilinear interpolation.
6794 * @param[in,out] S points to an instance of the interpolation structure.
6795 * @param[in] X interpolation coordinate in 12.20 format.
6796 * @param[in] Y interpolation coordinate in 12.20 format.
6797 * @return out interpolated value.
6798 */
6799 CMSIS_INLINE __STATIC_INLINE q31_t arm_bilinear_interp_q31(
6800 arm_bilinear_interp_instance_q31 * S,
6801 q31_t X,
6802 q31_t Y)
6803 {
6804 q31_t out; /* Temporary output */
6805 q31_t acc = 0; /* output */
6806 q31_t xfract, yfract; /* X, Y fractional parts */
6807 q31_t x1, x2, y1, y2; /* Nearest output values */
6808 int32_t rI, cI; /* Row and column indices */
6809 q31_t *pYData = S->pData; /* pointer to output table values */
6810 uint32_t nCols = S->numCols; /* num of rows */
6811
6812 /* Input is in 12.20 format */
6813 /* 12 bits for the table index */
6814 /* Index value calculation */
6815 rI = ((X & (q31_t)0xFFF00000) >> 20);
6816
6817 /* Input is in 12.20 format */
6818 /* 12 bits for the table index */
6819 /* Index value calculation */
6820 cI = ((Y & (q31_t)0xFFF00000) >> 20);
6821
6822 /* Care taken for table outside boundary */
6823 /* Returns zero output when values are outside table boundary */
6824 if (rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1))
6825 {
6826 return (0);
6827 }
6828
6829 /* 20 bits for the fractional part */
6830 /* shift left xfract by 11 to keep 1.31 format */
6831 xfract = (X & 0x000FFFFF) << 11U;
6832
6833 /* Read two nearest output values from the index */
6834 x1 = pYData[(rI) + (int32_t)nCols * (cI) ];
6835 x2 = pYData[(rI) + (int32_t)nCols * (cI) + 1];
6836
6837 /* 20 bits for the fractional part */
6838 /* shift left yfract by 11 to keep 1.31 format */
6839 yfract = (Y & 0x000FFFFF) << 11U;
6840
6841 /* Read two nearest output values from the index */
6842 y1 = pYData[(rI) + (int32_t)nCols * (cI + 1) ];
6843 y2 = pYData[(rI) + (int32_t)nCols * (cI + 1) + 1];
6844
6845 /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 3.29(q29) format */
6846 out = ((q31_t) (((q63_t) x1 * (0x7FFFFFFF - xfract)) >> 32));
6847 acc = ((q31_t) (((q63_t) out * (0x7FFFFFFF - yfract)) >> 32));
6848
6849 /* x2 * (xfract) * (1-yfract) in 3.29(q29) and adding to acc */
6850 out = ((q31_t) ((q63_t) x2 * (0x7FFFFFFF - yfract) >> 32));
6851 acc += ((q31_t) ((q63_t) out * (xfract) >> 32));
6852
6853 /* y1 * (1 - xfract) * (yfract) in 3.29(q29) and adding to acc */
6854 out = ((q31_t) ((q63_t) y1 * (0x7FFFFFFF - xfract) >> 32));
6855 acc += ((q31_t) ((q63_t) out * (yfract) >> 32));
6856
6857 /* y2 * (xfract) * (yfract) in 3.29(q29) and adding to acc */
6858 out = ((q31_t) ((q63_t) y2 * (xfract) >> 32));
6859 acc += ((q31_t) ((q63_t) out * (yfract) >> 32));
6860
6861 /* Convert acc to 1.31(q31) format */
6862 return ((q31_t)(acc << 2));
6863 }
6864
6865
6866 /**
6867 * @brief Q15 bilinear interpolation.
6868 * @param[in,out] S points to an instance of the interpolation structure.
6869 * @param[in] X interpolation coordinate in 12.20 format.
6870 * @param[in] Y interpolation coordinate in 12.20 format.
6871 * @return out interpolated value.
6872 */
6873 CMSIS_INLINE __STATIC_INLINE q15_t arm_bilinear_interp_q15(
6874 arm_bilinear_interp_instance_q15 * S,
6875 q31_t X,
6876 q31_t Y)
6877 {
6878 q63_t acc = 0; /* output */
6879 q31_t out; /* Temporary output */
6880 q15_t x1, x2, y1, y2; /* Nearest output values */
6881 q31_t xfract, yfract; /* X, Y fractional parts */
6882 int32_t rI, cI; /* Row and column indices */
6883 q15_t *pYData = S->pData; /* pointer to output table values */
6884 uint32_t nCols = S->numCols; /* num of rows */
6885
6886 /* Input is in 12.20 format */
6887 /* 12 bits for the table index */
6888 /* Index value calculation */
6889 rI = ((X & (q31_t)0xFFF00000) >> 20);
6890
6891 /* Input is in 12.20 format */
6892 /* 12 bits for the table index */
6893 /* Index value calculation */
6894 cI = ((Y & (q31_t)0xFFF00000) >> 20);
6895
6896 /* Care taken for table outside boundary */
6897 /* Returns zero output when values are outside table boundary */
6898 if (rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1))
6899 {
6900 return (0);
6901 }
6902
6903 /* 20 bits for the fractional part */
6904 /* xfract should be in 12.20 format */
6905 xfract = (X & 0x000FFFFF);
6906
6907 /* Read two nearest output values from the index */
6908 x1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) ];
6909 x2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) + 1];
6910
6911 /* 20 bits for the fractional part */
6912 /* yfract should be in 12.20 format */
6913 yfract = (Y & 0x000FFFFF);
6914
6915 /* Read two nearest output values from the index */
6916 y1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) ];
6917 y2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) + 1];
6918
6919 /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 13.51 format */
6920
6921 /* x1 is in 1.15(q15), xfract in 12.20 format and out is in 13.35 format */
6922 /* convert 13.35 to 13.31 by right shifting and out is in 1.31 */
6923 out = (q31_t) (((q63_t) x1 * (0xFFFFF - xfract)) >> 4U);
6924 acc = ((q63_t) out * (0xFFFFF - yfract));
6925
6926 /* x2 * (xfract) * (1-yfract) in 1.51 and adding to acc */
6927 out = (q31_t) (((q63_t) x2 * (0xFFFFF - yfract)) >> 4U);
6928 acc += ((q63_t) out * (xfract));
6929
6930 /* y1 * (1 - xfract) * (yfract) in 1.51 and adding to acc */
6931 out = (q31_t) (((q63_t) y1 * (0xFFFFF - xfract)) >> 4U);
6932 acc += ((q63_t) out * (yfract));
6933
6934 /* y2 * (xfract) * (yfract) in 1.51 and adding to acc */
6935 out = (q31_t) (((q63_t) y2 * (xfract)) >> 4U);
6936 acc += ((q63_t) out * (yfract));
6937
6938 /* acc is in 13.51 format and down shift acc by 36 times */
6939 /* Convert out to 1.15 format */
6940 return ((q15_t)(acc >> 36));
6941 }
6942
6943
6944 /**
6945 * @brief Q7 bilinear interpolation.
6946 * @param[in,out] S points to an instance of the interpolation structure.
6947 * @param[in] X interpolation coordinate in 12.20 format.
6948 * @param[in] Y interpolation coordinate in 12.20 format.
6949 * @return out interpolated value.
6950 */
6951 CMSIS_INLINE __STATIC_INLINE q7_t arm_bilinear_interp_q7(
6952 arm_bilinear_interp_instance_q7 * S,
6953 q31_t X,
6954 q31_t Y)
6955 {
6956 q63_t acc = 0; /* output */
6957 q31_t out; /* Temporary output */
6958 q31_t xfract, yfract; /* X, Y fractional parts */
6959 q7_t x1, x2, y1, y2; /* Nearest output values */
6960 int32_t rI, cI; /* Row and column indices */
6961 q7_t *pYData = S->pData; /* pointer to output table values */
6962 uint32_t nCols = S->numCols; /* num of rows */
6963
6964 /* Input is in 12.20 format */
6965 /* 12 bits for the table index */
6966 /* Index value calculation */
6967 rI = ((X & (q31_t)0xFFF00000) >> 20);
6968
6969 /* Input is in 12.20 format */
6970 /* 12 bits for the table index */
6971 /* Index value calculation */
6972 cI = ((Y & (q31_t)0xFFF00000) >> 20);
6973
6974 /* Care taken for table outside boundary */
6975 /* Returns zero output when values are outside table boundary */
6976 if (rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1))
6977 {
6978 return (0);
6979 }
6980
6981 /* 20 bits for the fractional part */
6982 /* xfract should be in 12.20 format */
6983 xfract = (X & (q31_t)0x000FFFFF);
6984
6985 /* Read two nearest output values from the index */
6986 x1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) ];
6987 x2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) + 1];
6988
6989 /* 20 bits for the fractional part */
6990 /* yfract should be in 12.20 format */
6991 yfract = (Y & (q31_t)0x000FFFFF);
6992
6993 /* Read two nearest output values from the index */
6994 y1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) ];
6995 y2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) + 1];
6996
6997 /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 16.47 format */
6998 out = ((x1 * (0xFFFFF - xfract)));
6999 acc = (((q63_t) out * (0xFFFFF - yfract)));
7000
7001 /* x2 * (xfract) * (1-yfract) in 2.22 and adding to acc */
7002 out = ((x2 * (0xFFFFF - yfract)));
7003 acc += (((q63_t) out * (xfract)));
7004
7005 /* y1 * (1 - xfract) * (yfract) in 2.22 and adding to acc */
7006 out = ((y1 * (0xFFFFF - xfract)));
7007 acc += (((q63_t) out * (yfract)));
7008
7009 /* y2 * (xfract) * (yfract) in 2.22 and adding to acc */
7010 out = ((y2 * (yfract)));
7011 acc += (((q63_t) out * (xfract)));
7012
7013 /* acc in 16.47 format and down shift by 40 to convert to 1.7 format */
7014 return ((q7_t)(acc >> 40));
7015 }
7016
7017 /**
7018 * @} end of BilinearInterpolate group
7019 */
7020
7021
7022/* SMMLAR */
7023#define multAcc_32x32_keep32_R(a, x, y) \
7024 a = (q31_t) (((((q63_t) a) << 32) + ((q63_t) x * y) + 0x80000000LL ) >> 32)
7025
7026/* SMMLSR */
7027#define multSub_32x32_keep32_R(a, x, y) \
7028 a = (q31_t) (((((q63_t) a) << 32) - ((q63_t) x * y) + 0x80000000LL ) >> 32)
7029
7030/* SMMULR */
7031#define mult_32x32_keep32_R(a, x, y) \
7032 a = (q31_t) (((q63_t) x * y + 0x80000000LL ) >> 32)
7033
7034/* SMMLA */
7035#define multAcc_32x32_keep32(a, x, y) \
7036 a += (q31_t) (((q63_t) x * y) >> 32)
7037
7038/* SMMLS */
7039#define multSub_32x32_keep32(a, x, y) \
7040 a -= (q31_t) (((q63_t) x * y) >> 32)
7041
7042/* SMMUL */
7043#define mult_32x32_keep32(a, x, y) \
7044 a = (q31_t) (((q63_t) x * y ) >> 32)
7045
7046
7047#if defined ( __CC_ARM )
7048 /* Enter low optimization region - place directly above function definition */
7049 #if defined( ARM_MATH_CM4 ) || defined( ARM_MATH_CM7)
7050 #define LOW_OPTIMIZATION_ENTER \
7051 _Pragma ("push") \
7052 _Pragma ("O1")
7053 #else
7054 #define LOW_OPTIMIZATION_ENTER
7055 #endif
7056
7057 /* Exit low optimization region - place directly after end of function definition */
7058 #if defined ( ARM_MATH_CM4 ) || defined ( ARM_MATH_CM7 )
7059 #define LOW_OPTIMIZATION_EXIT \
7060 _Pragma ("pop")
7061 #else
7062 #define LOW_OPTIMIZATION_EXIT
7063 #endif
7064
7065 /* Enter low optimization region - place directly above function definition */
7066 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
7067
7068 /* Exit low optimization region - place directly after end of function definition */
7069 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
7070
7071#elif defined (__ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
7072 #define LOW_OPTIMIZATION_ENTER
7073 #define LOW_OPTIMIZATION_EXIT
7074 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
7075 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
7076
7077#elif defined ( __GNUC__ )
7078 #define LOW_OPTIMIZATION_ENTER \
7079 __attribute__(( optimize("-O1") ))
7080 #define LOW_OPTIMIZATION_EXIT
7081 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
7082 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
7083
7084#elif defined ( __ICCARM__ )
7085 /* Enter low optimization region - place directly above function definition */
7086 #if defined ( ARM_MATH_CM4 ) || defined ( ARM_MATH_CM7 )
7087 #define LOW_OPTIMIZATION_ENTER \
7088 _Pragma ("optimize=low")
7089 #else
7090 #define LOW_OPTIMIZATION_ENTER
7091 #endif
7092
7093 /* Exit low optimization region - place directly after end of function definition */
7094 #define LOW_OPTIMIZATION_EXIT
7095
7096 /* Enter low optimization region - place directly above function definition */
7097 #if defined ( ARM_MATH_CM4 ) || defined ( ARM_MATH_CM7 )
7098 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER \
7099 _Pragma ("optimize=low")
7100 #else
7101 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
7102 #endif
7103
7104 /* Exit low optimization region - place directly after end of function definition */
7105 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
7106
7107#elif defined ( __TI_ARM__ )
7108 #define LOW_OPTIMIZATION_ENTER
7109 #define LOW_OPTIMIZATION_EXIT
7110 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
7111 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
7112
7113#elif defined ( __CSMC__ )
7114 #define LOW_OPTIMIZATION_ENTER
7115 #define LOW_OPTIMIZATION_EXIT
7116 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
7117 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
7118
7119#elif defined ( __TASKING__ )
7120 #define LOW_OPTIMIZATION_ENTER
7121 #define LOW_OPTIMIZATION_EXIT
7122 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
7123 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
7124
7125#endif
7126
7127
7128#ifdef __cplusplus
7129}
7130#endif
7131
7132/* Compiler specific diagnostic adjustment */
7133#if defined ( __CC_ARM )
7134
7135#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
7136
7137#elif defined ( __GNUC__ )
7138#pragma GCC diagnostic pop
7139
7140#elif defined ( __ICCARM__ )
7141
7142#elif defined ( __TI_ARM__ )
7143
7144#elif defined ( __CSMC__ )
7145
7146#elif defined ( __TASKING__ )
7147
7148#else
7149 #error Unknown compiler
7150#endif
7151
7152#endif /* _ARM_MATH_H */
7153
7154/**
7155 *
7156 * End of file.
7157 */
Note: See TracBrowser for help on using the repository browser.