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