Vipin Ranka
This is the final version of Mini Gateway for Automation and Security desgined for Renesas GR Peach Design Contest
Dependencies: GR-PEACH_video GraphicsFramework HTTPServer R_BSP mbed-rpc mbed-rtos Socket lwip-eth lwip-sys lwip FATFileSystem
Fork of
mbed-os-example-mbed5-blinky
by 
mbed-os-examples
Embed:
(wiki syntax)
Show/hide line numbers
arm_math.h
00001 /* ---------------------------------------------------------------------- 00002 * Copyright (C) 2010-2015 ARM Limited. All rights reserved. 00003 * 00004 * $Date: 19. March 2015 00005 * $Revision: V.1.4.5 00006 * 00007 * Project: CMSIS DSP Library 00008 * Title: arm_math.h 00009 * 00010 * Description: Public header file for CMSIS DSP Library 00011 * 00012 * Target Processor: Cortex-M7/Cortex-M4/Cortex-M3/Cortex-M0 00013 * 00014 * Redistribution and use in source and binary forms, with or without 00015 * modification, are permitted provided that the following conditions 00016 * are met: 00017 * - Redistributions of source code must retain the above copyright 00018 * notice, this list of conditions and the following disclaimer. 00019 * - Redistributions in binary form must reproduce the above copyright 00020 * notice, this list of conditions and the following disclaimer in 00021 * the documentation and/or other materials provided with the 00022 * distribution. 00023 * - Neither the name of ARM LIMITED nor the names of its contributors 00024 * may be used to endorse or promote products derived from this 00025 * software without specific prior written permission. 00026 * 00027 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 00028 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 00029 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 00030 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 00031 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 00032 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 00033 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 00034 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00035 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 00036 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 00037 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 00038 * POSSIBILITY OF SUCH DAMAGE. 00039 * -------------------------------------------------------------------- */ 00040 00041 /** 00042 \mainpage CMSIS DSP Software Library 00043 * 00044 * Introduction 00045 * ------------ 00046 * 00047 * This user manual describes the CMSIS DSP software library, 00048 * a suite of common signal processing functions for use on Cortex-M processor based devices. 00049 * 00050 * The library is divided into a number of functions each covering a specific category: 00051 * - Basic math functions 00052 * - Fast math functions 00053 * - Complex math functions 00054 * - Filters 00055 * - Matrix functions 00056 * - Transforms 00057 * - Motor control functions 00058 * - Statistical functions 00059 * - Support functions 00060 * - Interpolation functions 00061 * 00062 * The library has separate functions for operating on 8-bit integers, 16-bit integers, 00063 * 32-bit integer and 32-bit floating-point values. 00064 * 00065 * Using the Library 00066 * ------------ 00067 * 00068 * The library installer contains prebuilt versions of the libraries in the <code>Lib</code> folder. 00069 * - arm_cortexM7lfdp_math.lib (Little endian and Double Precision Floating Point Unit on Cortex-M7) 00070 * - arm_cortexM7bfdp_math.lib (Big endian and Double Precision Floating Point Unit on Cortex-M7) 00071 * - arm_cortexM7lfsp_math.lib (Little endian and Single Precision Floating Point Unit on Cortex-M7) 00072 * - arm_cortexM7bfsp_math.lib (Big endian and Single Precision Floating Point Unit on Cortex-M7) 00073 * - arm_cortexM7l_math.lib (Little endian on Cortex-M7) 00074 * - arm_cortexM7b_math.lib (Big endian on Cortex-M7) 00075 * - arm_cortexM4lf_math.lib (Little endian and Floating Point Unit on Cortex-M4) 00076 * - arm_cortexM4bf_math.lib (Big endian and Floating Point Unit on Cortex-M4) 00077 * - arm_cortexM4l_math.lib (Little endian on Cortex-M4) 00078 * - arm_cortexM4b_math.lib (Big endian on Cortex-M4) 00079 * - arm_cortexM3l_math.lib (Little endian on Cortex-M3) 00080 * - arm_cortexM3b_math.lib (Big endian on Cortex-M3) 00081 * - arm_cortexM0l_math.lib (Little endian on Cortex-M0 / CortexM0+) 00082 * - arm_cortexM0b_math.lib (Big endian on Cortex-M0 / CortexM0+) 00083 * 00084 * The library functions are declared in the public file <code>arm_math.h</code> which is placed in the <code>Include</code> folder. 00085 * Simply include this file and link the appropriate library in the application and begin calling the library functions. The Library supports single 00086 * 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. 00087 * Define the appropriate pre processor MACRO ARM_MATH_CM7 or ARM_MATH_CM4 or ARM_MATH_CM3 or 00088 * ARM_MATH_CM0 or ARM_MATH_CM0PLUS depending on the target processor in the application. 00089 * 00090 * Examples 00091 * -------- 00092 * 00093 * The library ships with a number of examples which demonstrate how to use the library functions. 00094 * 00095 * Toolchain Support 00096 * ------------ 00097 * 00098 * The library has been developed and tested with MDK-ARM version 5.14.0.0 00099 * The library is being tested in GCC and IAR toolchains and updates on this activity will be made available shortly. 00100 * 00101 * Building the Library 00102 * ------------ 00103 * 00104 * 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. 00105 * - arm_cortexM_math.uvprojx 00106 * 00107 * 00108 * 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. 00109 * 00110 * Pre-processor Macros 00111 * ------------ 00112 * 00113 * Each library project have differant pre-processor macros. 00114 * 00115 * - UNALIGNED_SUPPORT_DISABLE: 00116 * 00117 * Define macro UNALIGNED_SUPPORT_DISABLE, If the silicon does not support unaligned memory access 00118 * 00119 * - ARM_MATH_BIG_ENDIAN: 00120 * 00121 * Define macro ARM_MATH_BIG_ENDIAN to build the library for big endian targets. By default library builds for little endian targets. 00122 * 00123 * - ARM_MATH_MATRIX_CHECK: 00124 * 00125 * Define macro ARM_MATH_MATRIX_CHECK for checking on the input and output sizes of matrices 00126 * 00127 * - ARM_MATH_ROUNDING: 00128 * 00129 * Define macro ARM_MATH_ROUNDING for rounding on support functions 00130 * 00131 * - ARM_MATH_CMx: 00132 * 00133 * Define macro ARM_MATH_CM4 for building the library on Cortex-M4 target, ARM_MATH_CM3 for building library on Cortex-M3 target 00134 * and ARM_MATH_CM0 for building library on Cortex-M0 target, ARM_MATH_CM0PLUS for building library on Cortex-M0+ target, and 00135 * ARM_MATH_CM7 for building the library on cortex-M7. 00136 * 00137 * - __FPU_PRESENT: 00138 * 00139 * Initialize macro __FPU_PRESENT = 1 when building on FPU supported Targets. Enable this macro for M4bf and M4lf libraries 00140 * 00141 * <hr> 00142 * CMSIS-DSP in ARM::CMSIS Pack 00143 * ----------------------------- 00144 * 00145 * The following files relevant to CMSIS-DSP are present in the <b>ARM::CMSIS</b> Pack directories: 00146 * |File/Folder |Content | 00147 * |------------------------------|------------------------------------------------------------------------| 00148 * |\b CMSIS\\Documentation\\DSP | This documentation | 00149 * |\b CMSIS\\DSP_Lib | Software license agreement (license.txt) | 00150 * |\b CMSIS\\DSP_Lib\\Examples | Example projects demonstrating the usage of the library functions | 00151 * |\b CMSIS\\DSP_Lib\\Source | Source files for rebuilding the library | 00152 * 00153 * <hr> 00154 * Revision History of CMSIS-DSP 00155 * ------------ 00156 * Please refer to \ref ChangeLog_pg. 00157 * 00158 * Copyright Notice 00159 * ------------ 00160 * 00161 * Copyright (C) 2010-2015 ARM Limited. All rights reserved. 00162 */ 00163 00164 00165 /** 00166 * @defgroup groupMath Basic Math Functions 00167 */ 00168 00169 /** 00170 * @defgroup groupFastMath Fast Math Functions 00171 * This set of functions provides a fast approximation to sine, cosine, and square root. 00172 * As compared to most of the other functions in the CMSIS math library, the fast math functions 00173 * operate on individual values and not arrays. 00174 * There are separate functions for Q15, Q31, and floating-point data. 00175 * 00176 */ 00177 00178 /** 00179 * @defgroup groupCmplxMath Complex Math Functions 00180 * This set of functions operates on complex data vectors. 00181 * The data in the complex arrays is stored in an interleaved fashion 00182 * (real, imag, real, imag, ...). 00183 * In the API functions, the number of samples in a complex array refers 00184 * to the number of complex values; the array contains twice this number of 00185 * real values. 00186 */ 00187 00188 /** 00189 * @defgroup groupFilters Filtering Functions 00190 */ 00191 00192 /** 00193 * @defgroup groupMatrix Matrix Functions 00194 * 00195 * This set of functions provides basic matrix math operations. 00196 * The functions operate on matrix data structures. For example, 00197 * the type 00198 * definition for the floating-point matrix structure is shown 00199 * below: 00200 * <pre> 00201 * typedef struct 00202 * { 00203 * uint16_t numRows; // number of rows of the matrix. 00204 * uint16_t numCols; // number of columns of the matrix. 00205 * float32_t *pData; // points to the data of the matrix. 00206 * } arm_matrix_instance_f32; 00207 * </pre> 00208 * There are similar definitions for Q15 and Q31 data types. 00209 * 00210 * The structure specifies the size of the matrix and then points to 00211 * an array of data. The array is of size <code>numRows X numCols</code> 00212 * and the values are arranged in row order. That is, the 00213 * matrix element (i, j) is stored at: 00214 * <pre> 00215 * pData[i*numCols + j] 00216 * </pre> 00217 * 00218 * \par Init Functions 00219 * There is an associated initialization function for each type of matrix 00220 * data structure. 00221 * The initialization function sets the values of the internal structure fields. 00222 * Refer to the function <code>arm_mat_init_f32()</code>, <code>arm_mat_init_q31()</code> 00223 * and <code>arm_mat_init_q15()</code> for floating-point, Q31 and Q15 types, respectively. 00224 * 00225 * \par 00226 * Use of the initialization function is optional. However, if initialization function is used 00227 * then the instance structure cannot be placed into a const data section. 00228 * To place the instance structure in a const data 00229 * section, manually initialize the data structure. For example: 00230 * <pre> 00231 * <code>arm_matrix_instance_f32 S = {nRows, nColumns, pData};</code> 00232 * <code>arm_matrix_instance_q31 S = {nRows, nColumns, pData};</code> 00233 * <code>arm_matrix_instance_q15 S = {nRows, nColumns, pData};</code> 00234 * </pre> 00235 * where <code>nRows</code> specifies the number of rows, <code>nColumns</code> 00236 * specifies the number of columns, and <code>pData</code> points to the 00237 * data array. 00238 * 00239 * \par Size Checking 00240 * By default all of the matrix functions perform size checking on the input and 00241 * output matrices. For example, the matrix addition function verifies that the 00242 * two input matrices and the output matrix all have the same number of rows and 00243 * columns. If the size check fails the functions return: 00244 * <pre> 00245 * ARM_MATH_SIZE_MISMATCH 00246 * </pre> 00247 * Otherwise the functions return 00248 * <pre> 00249 * ARM_MATH_SUCCESS 00250 * </pre> 00251 * There is some overhead associated with this matrix size checking. 00252 * The matrix size checking is enabled via the \#define 00253 * <pre> 00254 * ARM_MATH_MATRIX_CHECK 00255 * </pre> 00256 * within the library project settings. By default this macro is defined 00257 * and size checking is enabled. By changing the project settings and 00258 * undefining this macro size checking is eliminated and the functions 00259 * run a bit faster. With size checking disabled the functions always 00260 * return <code>ARM_MATH_SUCCESS</code>. 00261 */ 00262 00263 /** 00264 * @defgroup groupTransforms Transform Functions 00265 */ 00266 00267 /** 00268 * @defgroup groupController Controller Functions 00269 */ 00270 00271 /** 00272 * @defgroup groupStats Statistics Functions 00273 */ 00274 /** 00275 * @defgroup groupSupport Support Functions 00276 */ 00277 00278 /** 00279 * @defgroup groupInterpolation Interpolation Functions 00280 * These functions perform 1- and 2-dimensional interpolation of data. 00281 * Linear interpolation is used for 1-dimensional data and 00282 * bilinear interpolation is used for 2-dimensional data. 00283 */ 00284 00285 /** 00286 * @defgroup groupExamples Examples 00287 */ 00288 #ifndef _ARM_MATH_H 00289 #define _ARM_MATH_H 00290 00291 #define __CMSIS_GENERIC /* disable NVIC and Systick functions */ 00292 00293 #if defined(ARM_MATH_CM7) 00294 #include "core_cm7.h" 00295 #elif defined (ARM_MATH_CM4) 00296 #include "core_cm4.h" 00297 #elif defined (ARM_MATH_CM3) 00298 #include "core_cm3.h" 00299 #elif defined (ARM_MATH_CM0) 00300 #include "core_cm0.h" 00301 #define ARM_MATH_CM0_FAMILY 00302 #elif defined (ARM_MATH_CM0PLUS) 00303 #include "core_cm0plus.h" 00304 #define ARM_MATH_CM0_FAMILY 00305 #else 00306 #error "Define according the used Cortex core ARM_MATH_CM7, ARM_MATH_CM4, ARM_MATH_CM3, ARM_MATH_CM0PLUS or ARM_MATH_CM0" 00307 #endif 00308 00309 #undef __CMSIS_GENERIC /* enable NVIC and Systick functions */ 00310 #include "string.h" 00311 #include "math.h" 00312 #ifdef __cplusplus 00313 extern "C" 00314 { 00315 #endif 00316 00317 00318 /** 00319 * @brief Macros required for reciprocal calculation in Normalized LMS 00320 */ 00321 00322 #define DELTA_Q31 (0x100) 00323 #define DELTA_Q15 0x5 00324 #define INDEX_MASK 0x0000003F 00325 #ifndef PI 00326 #define PI 3.14159265358979f 00327 #endif 00328 00329 /** 00330 * @brief Macros required for SINE and COSINE Fast math approximations 00331 */ 00332 00333 #define FAST_MATH_TABLE_SIZE 512 00334 #define FAST_MATH_Q31_SHIFT (32 - 10) 00335 #define FAST_MATH_Q15_SHIFT (16 - 10) 00336 #define CONTROLLER_Q31_SHIFT (32 - 9) 00337 #define TABLE_SIZE 256 00338 #define TABLE_SPACING_Q31 0x400000 00339 #define TABLE_SPACING_Q15 0x80 00340 00341 /** 00342 * @brief Macros required for SINE and COSINE Controller functions 00343 */ 00344 /* 1.31(q31) Fixed value of 2/360 */ 00345 /* -1 to +1 is divided into 360 values so total spacing is (2/360) */ 00346 #define INPUT_SPACING 0xB60B61 00347 00348 /** 00349 * @brief Macro for Unaligned Support 00350 */ 00351 #ifndef UNALIGNED_SUPPORT_DISABLE 00352 #define ALIGN4 00353 #else 00354 #if defined (__GNUC__) 00355 #define ALIGN4 __attribute__((aligned(4))) 00356 #else 00357 #define ALIGN4 __align(4) 00358 #endif 00359 #endif /* #ifndef UNALIGNED_SUPPORT_DISABLE */ 00360 00361 /** 00362 * @brief Error status returned by some functions in the library. 00363 */ 00364 00365 typedef enum 00366 { 00367 ARM_MATH_SUCCESS = 0, /**< No error */ 00368 ARM_MATH_ARGUMENT_ERROR = -1, /**< One or more arguments are incorrect */ 00369 ARM_MATH_LENGTH_ERROR = -2, /**< Length of data buffer is incorrect */ 00370 ARM_MATH_SIZE_MISMATCH = -3, /**< Size of matrices is not compatible with the operation. */ 00371 ARM_MATH_NANINF = -4, /**< Not-a-number (NaN) or infinity is generated */ 00372 ARM_MATH_SINGULAR = -5, /**< Generated by matrix inversion if the input matrix is singular and cannot be inverted. */ 00373 ARM_MATH_TEST_FAILURE = -6 /**< Test Failed */ 00374 } arm_status; 00375 00376 /** 00377 * @brief 8-bit fractional data type in 1.7 format. 00378 */ 00379 typedef int8_t q7_t; 00380 00381 /** 00382 * @brief 16-bit fractional data type in 1.15 format. 00383 */ 00384 typedef int16_t q15_t; 00385 00386 /** 00387 * @brief 32-bit fractional data type in 1.31 format. 00388 */ 00389 typedef int32_t q31_t; 00390 00391 /** 00392 * @brief 64-bit fractional data type in 1.63 format. 00393 */ 00394 typedef int64_t q63_t; 00395 00396 /** 00397 * @brief 32-bit floating-point type definition. 00398 */ 00399 typedef float float32_t; 00400 00401 /** 00402 * @brief 64-bit floating-point type definition. 00403 */ 00404 typedef double float64_t; 00405 00406 /** 00407 * @brief definition to read/write two 16 bit values. 00408 */ 00409 #if defined __CC_ARM 00410 #define __SIMD32_TYPE int32_t __packed 00411 #define CMSIS_UNUSED __attribute__((unused)) 00412 #elif defined __ICCARM__ 00413 #define __SIMD32_TYPE int32_t __packed 00414 #define CMSIS_UNUSED 00415 #elif defined __GNUC__ 00416 #define __SIMD32_TYPE int32_t 00417 #define CMSIS_UNUSED __attribute__((unused)) 00418 #elif defined __CSMC__ /* Cosmic */ 00419 #define __SIMD32_TYPE int32_t 00420 #define CMSIS_UNUSED 00421 #elif defined __TASKING__ 00422 #define __SIMD32_TYPE __unaligned int32_t 00423 #define CMSIS_UNUSED 00424 #else 00425 #error Unknown compiler 00426 #endif 00427 00428 #define __SIMD32(addr) (*(__SIMD32_TYPE **) & (addr)) 00429 #define __SIMD32_CONST(addr) ((__SIMD32_TYPE *)(addr)) 00430 00431 #define _SIMD32_OFFSET(addr) (*(__SIMD32_TYPE *) (addr)) 00432 00433 #define __SIMD64(addr) (*(int64_t **) & (addr)) 00434 00435 #if defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) 00436 /** 00437 * @brief definition to pack two 16 bit values. 00438 */ 00439 #define __PKHBT(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0x0000FFFF) | \ 00440 (((int32_t)(ARG2) << ARG3) & (int32_t)0xFFFF0000) ) 00441 #define __PKHTB(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0xFFFF0000) | \ 00442 (((int32_t)(ARG2) >> ARG3) & (int32_t)0x0000FFFF) ) 00443 00444 #endif 00445 00446 00447 /** 00448 * @brief definition to pack four 8 bit values. 00449 */ 00450 #ifndef ARM_MATH_BIG_ENDIAN 00451 00452 #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v0) << 0) & (int32_t)0x000000FF) | \ 00453 (((int32_t)(v1) << 8) & (int32_t)0x0000FF00) | \ 00454 (((int32_t)(v2) << 16) & (int32_t)0x00FF0000) | \ 00455 (((int32_t)(v3) << 24) & (int32_t)0xFF000000) ) 00456 #else 00457 00458 #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v3) << 0) & (int32_t)0x000000FF) | \ 00459 (((int32_t)(v2) << 8) & (int32_t)0x0000FF00) | \ 00460 (((int32_t)(v1) << 16) & (int32_t)0x00FF0000) | \ 00461 (((int32_t)(v0) << 24) & (int32_t)0xFF000000) ) 00462 00463 #endif 00464 00465 00466 /** 00467 * @brief Clips Q63 to Q31 values. 00468 */ 00469 static __INLINE q31_t clip_q63_to_q31( 00470 q63_t x) 00471 { 00472 return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ? 00473 ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x; 00474 } 00475 00476 /** 00477 * @brief Clips Q63 to Q15 values. 00478 */ 00479 static __INLINE q15_t clip_q63_to_q15( 00480 q63_t x) 00481 { 00482 return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ? 00483 ((0x7FFF ^ ((q15_t) (x >> 63)))) : (q15_t) (x >> 15); 00484 } 00485 00486 /** 00487 * @brief Clips Q31 to Q7 values. 00488 */ 00489 static __INLINE q7_t clip_q31_to_q7( 00490 q31_t x) 00491 { 00492 return ((q31_t) (x >> 24) != ((q31_t) x >> 23)) ? 00493 ((0x7F ^ ((q7_t) (x >> 31)))) : (q7_t) x; 00494 } 00495 00496 /** 00497 * @brief Clips Q31 to Q15 values. 00498 */ 00499 static __INLINE q15_t clip_q31_to_q15( 00500 q31_t x) 00501 { 00502 return ((q31_t) (x >> 16) != ((q31_t) x >> 15)) ? 00503 ((0x7FFF ^ ((q15_t) (x >> 31)))) : (q15_t) x; 00504 } 00505 00506 /** 00507 * @brief Multiplies 32 X 64 and returns 32 bit result in 2.30 format. 00508 */ 00509 00510 static __INLINE q63_t mult32x64( 00511 q63_t x, 00512 q31_t y) 00513 { 00514 return ((((q63_t) (x & 0x00000000FFFFFFFF) * y) >> 32) + 00515 (((q63_t) (x >> 32) * y))); 00516 } 00517 00518 00519 //#if defined (ARM_MATH_CM0_FAMILY) && defined ( __CC_ARM ) 00520 //#define __CLZ __clz 00521 //#endif 00522 00523 //note: function can be removed when all toolchain support __CLZ for Cortex-M0 00524 #if defined (ARM_MATH_CM0_FAMILY) && ((defined (__ICCARM__)) ) 00525 00526 static __INLINE uint32_t __CLZ( 00527 q31_t data); 00528 00529 00530 static __INLINE uint32_t __CLZ( 00531 q31_t data) 00532 { 00533 uint32_t count = 0; 00534 uint32_t mask = 0x80000000; 00535 00536 while((data & mask) == 0) 00537 { 00538 count += 1u; 00539 mask = mask >> 1u; 00540 } 00541 00542 return (count); 00543 00544 } 00545 00546 #endif 00547 00548 /** 00549 * @brief Function to Calculates 1/in (reciprocal) value of Q31 Data type. 00550 */ 00551 00552 static __INLINE uint32_t arm_recip_q31( 00553 q31_t in, 00554 q31_t * dst, 00555 q31_t * pRecipTable) 00556 { 00557 00558 uint32_t out, tempVal; 00559 uint32_t index, i; 00560 uint32_t signBits; 00561 00562 if(in > 0) 00563 { 00564 signBits = __CLZ(in) - 1; 00565 } 00566 else 00567 { 00568 signBits = __CLZ(-in) - 1; 00569 } 00570 00571 /* Convert input sample to 1.31 format */ 00572 in = in << signBits; 00573 00574 /* calculation of index for initial approximated Val */ 00575 index = (uint32_t) (in >> 24u); 00576 index = (index & INDEX_MASK); 00577 00578 /* 1.31 with exp 1 */ 00579 out = pRecipTable[index]; 00580 00581 /* calculation of reciprocal value */ 00582 /* running approximation for two iterations */ 00583 for (i = 0u; i < 2u; i++) 00584 { 00585 tempVal = (q31_t) (((q63_t) in * out) >> 31u); 00586 tempVal = 0x7FFFFFFF - tempVal; 00587 /* 1.31 with exp 1 */ 00588 //out = (q31_t) (((q63_t) out * tempVal) >> 30u); 00589 out = (q31_t) clip_q63_to_q31(((q63_t) out * tempVal) >> 30u); 00590 } 00591 00592 /* write output */ 00593 *dst = out; 00594 00595 /* return num of signbits of out = 1/in value */ 00596 return (signBits + 1u); 00597 00598 } 00599 00600 /** 00601 * @brief Function to Calculates 1/in (reciprocal) value of Q15 Data type. 00602 */ 00603 static __INLINE uint32_t arm_recip_q15( 00604 q15_t in, 00605 q15_t * dst, 00606 q15_t * pRecipTable) 00607 { 00608 00609 uint32_t out = 0, tempVal = 0; 00610 uint32_t index = 0, i = 0; 00611 uint32_t signBits = 0; 00612 00613 if(in > 0) 00614 { 00615 signBits = __CLZ(in) - 17; 00616 } 00617 else 00618 { 00619 signBits = __CLZ(-in) - 17; 00620 } 00621 00622 /* Convert input sample to 1.15 format */ 00623 in = in << signBits; 00624 00625 /* calculation of index for initial approximated Val */ 00626 index = in >> 8; 00627 index = (index & INDEX_MASK); 00628 00629 /* 1.15 with exp 1 */ 00630 out = pRecipTable[index]; 00631 00632 /* calculation of reciprocal value */ 00633 /* running approximation for two iterations */ 00634 for (i = 0; i < 2; i++) 00635 { 00636 tempVal = (q15_t) (((q31_t) in * out) >> 15); 00637 tempVal = 0x7FFF - tempVal; 00638 /* 1.15 with exp 1 */ 00639 out = (q15_t) (((q31_t) out * tempVal) >> 14); 00640 } 00641 00642 /* write output */ 00643 *dst = out; 00644 00645 /* return num of signbits of out = 1/in value */ 00646 return (signBits + 1); 00647 00648 } 00649 00650 00651 /* 00652 * @brief C custom defined intrinisic function for only M0 processors 00653 */ 00654 #if defined(ARM_MATH_CM0_FAMILY) 00655 00656 static __INLINE q31_t __SSAT( 00657 q31_t x, 00658 uint32_t y) 00659 { 00660 int32_t posMax, negMin; 00661 uint32_t i; 00662 00663 posMax = 1; 00664 for (i = 0; i < (y - 1); i++) 00665 { 00666 posMax = posMax * 2; 00667 } 00668 00669 if(x > 0) 00670 { 00671 posMax = (posMax - 1); 00672 00673 if(x > posMax) 00674 { 00675 x = posMax; 00676 } 00677 } 00678 else 00679 { 00680 negMin = -posMax; 00681 00682 if(x < negMin) 00683 { 00684 x = negMin; 00685 } 00686 } 00687 return (x); 00688 00689 00690 } 00691 00692 #endif /* end of ARM_MATH_CM0_FAMILY */ 00693 00694 00695 00696 /* 00697 * @brief C custom defined intrinsic function for M3 and M0 processors 00698 */ 00699 #if defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) 00700 00701 /* 00702 * @brief C custom defined QADD8 for M3 and M0 processors 00703 */ 00704 static __INLINE q31_t __QADD8( 00705 q31_t x, 00706 q31_t y) 00707 { 00708 00709 q31_t sum; 00710 q7_t r, s, t, u; 00711 00712 r = (q7_t) x; 00713 s = (q7_t) y; 00714 00715 r = __SSAT((q31_t) (r + s), 8); 00716 s = __SSAT(((q31_t) (((x << 16) >> 24) + ((y << 16) >> 24))), 8); 00717 t = __SSAT(((q31_t) (((x << 8) >> 24) + ((y << 8) >> 24))), 8); 00718 u = __SSAT(((q31_t) ((x >> 24) + (y >> 24))), 8); 00719 00720 sum = 00721 (((q31_t) u << 24) & 0xFF000000) | (((q31_t) t << 16) & 0x00FF0000) | 00722 (((q31_t) s << 8) & 0x0000FF00) | (r & 0x000000FF); 00723 00724 return sum; 00725 00726 } 00727 00728 /* 00729 * @brief C custom defined QSUB8 for M3 and M0 processors 00730 */ 00731 static __INLINE q31_t __QSUB8( 00732 q31_t x, 00733 q31_t y) 00734 { 00735 00736 q31_t sum; 00737 q31_t r, s, t, u; 00738 00739 r = (q7_t) x; 00740 s = (q7_t) y; 00741 00742 r = __SSAT((r - s), 8); 00743 s = __SSAT(((q31_t) (((x << 16) >> 24) - ((y << 16) >> 24))), 8) << 8; 00744 t = __SSAT(((q31_t) (((x << 8) >> 24) - ((y << 8) >> 24))), 8) << 16; 00745 u = __SSAT(((q31_t) ((x >> 24) - (y >> 24))), 8) << 24; 00746 00747 sum = 00748 (u & 0xFF000000) | (t & 0x00FF0000) | (s & 0x0000FF00) | (r & 00749 0x000000FF); 00750 00751 return sum; 00752 } 00753 00754 /* 00755 * @brief C custom defined QADD16 for M3 and M0 processors 00756 */ 00757 00758 /* 00759 * @brief C custom defined QADD16 for M3 and M0 processors 00760 */ 00761 static __INLINE q31_t __QADD16( 00762 q31_t x, 00763 q31_t y) 00764 { 00765 00766 q31_t sum; 00767 q31_t r, s; 00768 00769 r = (q15_t) x; 00770 s = (q15_t) y; 00771 00772 r = __SSAT(r + s, 16); 00773 s = __SSAT(((q31_t) ((x >> 16) + (y >> 16))), 16) << 16; 00774 00775 sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); 00776 00777 return sum; 00778 00779 } 00780 00781 /* 00782 * @brief C custom defined SHADD16 for M3 and M0 processors 00783 */ 00784 static __INLINE q31_t __SHADD16( 00785 q31_t x, 00786 q31_t y) 00787 { 00788 00789 q31_t sum; 00790 q31_t r, s; 00791 00792 r = (q15_t) x; 00793 s = (q15_t) y; 00794 00795 r = ((r >> 1) + (s >> 1)); 00796 s = ((q31_t) ((x >> 17) + (y >> 17))) << 16; 00797 00798 sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); 00799 00800 return sum; 00801 00802 } 00803 00804 /* 00805 * @brief C custom defined QSUB16 for M3 and M0 processors 00806 */ 00807 static __INLINE q31_t __QSUB16( 00808 q31_t x, 00809 q31_t y) 00810 { 00811 00812 q31_t sum; 00813 q31_t r, s; 00814 00815 r = (q15_t) x; 00816 s = (q15_t) y; 00817 00818 r = __SSAT(r - s, 16); 00819 s = __SSAT(((q31_t) ((x >> 16) - (y >> 16))), 16) << 16; 00820 00821 sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); 00822 00823 return sum; 00824 } 00825 00826 /* 00827 * @brief C custom defined SHSUB16 for M3 and M0 processors 00828 */ 00829 static __INLINE q31_t __SHSUB16( 00830 q31_t x, 00831 q31_t y) 00832 { 00833 00834 q31_t diff; 00835 q31_t r, s; 00836 00837 r = (q15_t) x; 00838 s = (q15_t) y; 00839 00840 r = ((r >> 1) - (s >> 1)); 00841 s = (((x >> 17) - (y >> 17)) << 16); 00842 00843 diff = (s & 0xFFFF0000) | (r & 0x0000FFFF); 00844 00845 return diff; 00846 } 00847 00848 /* 00849 * @brief C custom defined QASX for M3 and M0 processors 00850 */ 00851 static __INLINE q31_t __QASX( 00852 q31_t x, 00853 q31_t y) 00854 { 00855 00856 q31_t sum = 0; 00857 00858 sum = 00859 ((sum + 00860 clip_q31_to_q15((q31_t) ((q15_t) (x >> 16) + (q15_t) y))) << 16) + 00861 clip_q31_to_q15((q31_t) ((q15_t) x - (q15_t) (y >> 16))); 00862 00863 return sum; 00864 } 00865 00866 /* 00867 * @brief C custom defined SHASX for M3 and M0 processors 00868 */ 00869 static __INLINE q31_t __SHASX( 00870 q31_t x, 00871 q31_t y) 00872 { 00873 00874 q31_t sum; 00875 q31_t r, s; 00876 00877 r = (q15_t) x; 00878 s = (q15_t) y; 00879 00880 r = ((r >> 1) - (y >> 17)); 00881 s = (((x >> 17) + (s >> 1)) << 16); 00882 00883 sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); 00884 00885 return sum; 00886 } 00887 00888 00889 /* 00890 * @brief C custom defined QSAX for M3 and M0 processors 00891 */ 00892 static __INLINE q31_t __QSAX( 00893 q31_t x, 00894 q31_t y) 00895 { 00896 00897 q31_t sum = 0; 00898 00899 sum = 00900 ((sum + 00901 clip_q31_to_q15((q31_t) ((q15_t) (x >> 16) - (q15_t) y))) << 16) + 00902 clip_q31_to_q15((q31_t) ((q15_t) x + (q15_t) (y >> 16))); 00903 00904 return sum; 00905 } 00906 00907 /* 00908 * @brief C custom defined SHSAX for M3 and M0 processors 00909 */ 00910 static __INLINE q31_t __SHSAX( 00911 q31_t x, 00912 q31_t y) 00913 { 00914 00915 q31_t sum; 00916 q31_t r, s; 00917 00918 r = (q15_t) x; 00919 s = (q15_t) y; 00920 00921 r = ((r >> 1) + (y >> 17)); 00922 s = (((x >> 17) - (s >> 1)) << 16); 00923 00924 sum = (s & 0xFFFF0000) | (r & 0x0000FFFF); 00925 00926 return sum; 00927 } 00928 00929 /* 00930 * @brief C custom defined SMUSDX for M3 and M0 processors 00931 */ 00932 static __INLINE q31_t __SMUSDX( 00933 q31_t x, 00934 q31_t y) 00935 { 00936 00937 return ((q31_t) (((q15_t) x * (q15_t) (y >> 16)) - 00938 ((q15_t) (x >> 16) * (q15_t) y))); 00939 } 00940 00941 /* 00942 * @brief C custom defined SMUADX for M3 and M0 processors 00943 */ 00944 static __INLINE q31_t __SMUADX( 00945 q31_t x, 00946 q31_t y) 00947 { 00948 00949 return ((q31_t) (((q15_t) x * (q15_t) (y >> 16)) + 00950 ((q15_t) (x >> 16) * (q15_t) y))); 00951 } 00952 00953 /* 00954 * @brief C custom defined QADD for M3 and M0 processors 00955 */ 00956 static __INLINE q31_t __QADD( 00957 q31_t x, 00958 q31_t y) 00959 { 00960 return clip_q63_to_q31((q63_t) x + y); 00961 } 00962 00963 /* 00964 * @brief C custom defined QSUB for M3 and M0 processors 00965 */ 00966 static __INLINE q31_t __QSUB( 00967 q31_t x, 00968 q31_t y) 00969 { 00970 return clip_q63_to_q31((q63_t) x - y); 00971 } 00972 00973 /* 00974 * @brief C custom defined SMLAD for M3 and M0 processors 00975 */ 00976 static __INLINE q31_t __SMLAD( 00977 q31_t x, 00978 q31_t y, 00979 q31_t sum) 00980 { 00981 00982 return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) + 00983 ((q15_t) x * (q15_t) y)); 00984 } 00985 00986 /* 00987 * @brief C custom defined SMLADX for M3 and M0 processors 00988 */ 00989 static __INLINE q31_t __SMLADX( 00990 q31_t x, 00991 q31_t y, 00992 q31_t sum) 00993 { 00994 00995 return (sum + ((q15_t) (x >> 16) * (q15_t) (y)) + 00996 ((q15_t) x * (q15_t) (y >> 16))); 00997 } 00998 00999 /* 01000 * @brief C custom defined SMLSDX for M3 and M0 processors 01001 */ 01002 static __INLINE q31_t __SMLSDX( 01003 q31_t x, 01004 q31_t y, 01005 q31_t sum) 01006 { 01007 01008 return (sum - ((q15_t) (x >> 16) * (q15_t) (y)) + 01009 ((q15_t) x * (q15_t) (y >> 16))); 01010 } 01011 01012 /* 01013 * @brief C custom defined SMLALD for M3 and M0 processors 01014 */ 01015 static __INLINE q63_t __SMLALD( 01016 q31_t x, 01017 q31_t y, 01018 q63_t sum) 01019 { 01020 01021 return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) + 01022 ((q15_t) x * (q15_t) y)); 01023 } 01024 01025 /* 01026 * @brief C custom defined SMLALDX for M3 and M0 processors 01027 */ 01028 static __INLINE q63_t __SMLALDX( 01029 q31_t x, 01030 q31_t y, 01031 q63_t sum) 01032 { 01033 01034 return (sum + ((q15_t) (x >> 16) * (q15_t) y)) + 01035 ((q15_t) x * (q15_t) (y >> 16)); 01036 } 01037 01038 /* 01039 * @brief C custom defined SMUAD for M3 and M0 processors 01040 */ 01041 static __INLINE q31_t __SMUAD( 01042 q31_t x, 01043 q31_t y) 01044 { 01045 01046 return (((x >> 16) * (y >> 16)) + 01047 (((x << 16) >> 16) * ((y << 16) >> 16))); 01048 } 01049 01050 /* 01051 * @brief C custom defined SMUSD for M3 and M0 processors 01052 */ 01053 static __INLINE q31_t __SMUSD( 01054 q31_t x, 01055 q31_t y) 01056 { 01057 01058 return (-((x >> 16) * (y >> 16)) + 01059 (((x << 16) >> 16) * ((y << 16) >> 16))); 01060 } 01061 01062 01063 /* 01064 * @brief C custom defined SXTB16 for M3 and M0 processors 01065 */ 01066 static __INLINE q31_t __SXTB16( 01067 q31_t x) 01068 { 01069 01070 return ((((x << 24) >> 24) & 0x0000FFFF) | 01071 (((x << 8) >> 8) & 0xFFFF0000)); 01072 } 01073 01074 01075 #endif /* defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) */ 01076 01077 01078 /** 01079 * @brief Instance structure for the Q7 FIR filter. 01080 */ 01081 typedef struct 01082 { 01083 uint16_t numTaps; /**< number of filter coefficients in the filter. */ 01084 q7_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 01085 q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 01086 } arm_fir_instance_q7; 01087 01088 /** 01089 * @brief Instance structure for the Q15 FIR filter. 01090 */ 01091 typedef struct 01092 { 01093 uint16_t numTaps; /**< number of filter coefficients in the filter. */ 01094 q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 01095 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 01096 } arm_fir_instance_q15; 01097 01098 /** 01099 * @brief Instance structure for the Q31 FIR filter. 01100 */ 01101 typedef struct 01102 { 01103 uint16_t numTaps; /**< number of filter coefficients in the filter. */ 01104 q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 01105 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ 01106 } arm_fir_instance_q31; 01107 01108 /** 01109 * @brief Instance structure for the floating-point FIR filter. 01110 */ 01111 typedef struct 01112 { 01113 uint16_t numTaps; /**< number of filter coefficients in the filter. */ 01114 float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 01115 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ 01116 } arm_fir_instance_f32; 01117 01118 01119 /** 01120 * @brief Processing function for the Q7 FIR filter. 01121 * @param[in] *S points to an instance of the Q7 FIR filter structure. 01122 * @param[in] *pSrc points to the block of input data. 01123 * @param[out] *pDst points to the block of output data. 01124 * @param[in] blockSize number of samples to process. 01125 * @return none. 01126 */ 01127 void arm_fir_q7( 01128 const arm_fir_instance_q7 * S, 01129 q7_t * pSrc, 01130 q7_t * pDst, 01131 uint32_t blockSize); 01132 01133 01134 /** 01135 * @brief Initialization function for the Q7 FIR filter. 01136 * @param[in,out] *S points to an instance of the Q7 FIR structure. 01137 * @param[in] numTaps Number of filter coefficients in the filter. 01138 * @param[in] *pCoeffs points to the filter coefficients. 01139 * @param[in] *pState points to the state buffer. 01140 * @param[in] blockSize number of samples that are processed. 01141 * @return none 01142 */ 01143 void arm_fir_init_q7( 01144 arm_fir_instance_q7 * S, 01145 uint16_t numTaps, 01146 q7_t * pCoeffs, 01147 q7_t * pState, 01148 uint32_t blockSize); 01149 01150 01151 /** 01152 * @brief Processing function for the Q15 FIR filter. 01153 * @param[in] *S points to an instance of the Q15 FIR structure. 01154 * @param[in] *pSrc points to the block of input data. 01155 * @param[out] *pDst points to the block of output data. 01156 * @param[in] blockSize number of samples to process. 01157 * @return none. 01158 */ 01159 void arm_fir_q15( 01160 const arm_fir_instance_q15 * S, 01161 q15_t * pSrc, 01162 q15_t * pDst, 01163 uint32_t blockSize); 01164 01165 /** 01166 * @brief Processing function for the fast Q15 FIR filter for Cortex-M3 and Cortex-M4. 01167 * @param[in] *S points to an instance of the Q15 FIR filter structure. 01168 * @param[in] *pSrc points to the block of input data. 01169 * @param[out] *pDst points to the block of output data. 01170 * @param[in] blockSize number of samples to process. 01171 * @return none. 01172 */ 01173 void arm_fir_fast_q15( 01174 const arm_fir_instance_q15 * S, 01175 q15_t * pSrc, 01176 q15_t * pDst, 01177 uint32_t blockSize); 01178 01179 /** 01180 * @brief Initialization function for the Q15 FIR filter. 01181 * @param[in,out] *S points to an instance of the Q15 FIR filter structure. 01182 * @param[in] numTaps Number of filter coefficients in the filter. Must be even and greater than or equal to 4. 01183 * @param[in] *pCoeffs points to the filter coefficients. 01184 * @param[in] *pState points to the state buffer. 01185 * @param[in] blockSize number of samples that are processed at a time. 01186 * @return The function returns ARM_MATH_SUCCESS if initialization was successful or ARM_MATH_ARGUMENT_ERROR if 01187 * <code>numTaps</code> is not a supported value. 01188 */ 01189 01190 arm_status arm_fir_init_q15( 01191 arm_fir_instance_q15 * S, 01192 uint16_t numTaps, 01193 q15_t * pCoeffs, 01194 q15_t * pState, 01195 uint32_t blockSize); 01196 01197 /** 01198 * @brief Processing function for the Q31 FIR filter. 01199 * @param[in] *S points to an instance of the Q31 FIR filter structure. 01200 * @param[in] *pSrc points to the block of input data. 01201 * @param[out] *pDst points to the block of output data. 01202 * @param[in] blockSize number of samples to process. 01203 * @return none. 01204 */ 01205 void arm_fir_q31( 01206 const arm_fir_instance_q31 * S, 01207 q31_t * pSrc, 01208 q31_t * pDst, 01209 uint32_t blockSize); 01210 01211 /** 01212 * @brief Processing function for the fast Q31 FIR filter for Cortex-M3 and Cortex-M4. 01213 * @param[in] *S points to an instance of the Q31 FIR structure. 01214 * @param[in] *pSrc points to the block of input data. 01215 * @param[out] *pDst points to the block of output data. 01216 * @param[in] blockSize number of samples to process. 01217 * @return none. 01218 */ 01219 void arm_fir_fast_q31( 01220 const arm_fir_instance_q31 * S, 01221 q31_t * pSrc, 01222 q31_t * pDst, 01223 uint32_t blockSize); 01224 01225 /** 01226 * @brief Initialization function for the Q31 FIR filter. 01227 * @param[in,out] *S points to an instance of the Q31 FIR structure. 01228 * @param[in] numTaps Number of filter coefficients in the filter. 01229 * @param[in] *pCoeffs points to the filter coefficients. 01230 * @param[in] *pState points to the state buffer. 01231 * @param[in] blockSize number of samples that are processed at a time. 01232 * @return none. 01233 */ 01234 void arm_fir_init_q31( 01235 arm_fir_instance_q31 * S, 01236 uint16_t numTaps, 01237 q31_t * pCoeffs, 01238 q31_t * pState, 01239 uint32_t blockSize); 01240 01241 /** 01242 * @brief Processing function for the floating-point FIR filter. 01243 * @param[in] *S points to an instance of the floating-point FIR structure. 01244 * @param[in] *pSrc points to the block of input data. 01245 * @param[out] *pDst points to the block of output data. 01246 * @param[in] blockSize number of samples to process. 01247 * @return none. 01248 */ 01249 void arm_fir_f32( 01250 const arm_fir_instance_f32 * S, 01251 float32_t * pSrc, 01252 float32_t * pDst, 01253 uint32_t blockSize); 01254 01255 /** 01256 * @brief Initialization function for the floating-point FIR filter. 01257 * @param[in,out] *S points to an instance of the floating-point FIR filter structure. 01258 * @param[in] numTaps Number of filter coefficients in the filter. 01259 * @param[in] *pCoeffs points to the filter coefficients. 01260 * @param[in] *pState points to the state buffer. 01261 * @param[in] blockSize number of samples that are processed at a time. 01262 * @return none. 01263 */ 01264 void arm_fir_init_f32( 01265 arm_fir_instance_f32 * S, 01266 uint16_t numTaps, 01267 float32_t * pCoeffs, 01268 float32_t * pState, 01269 uint32_t blockSize); 01270 01271 01272 /** 01273 * @brief Instance structure for the Q15 Biquad cascade filter. 01274 */ 01275 typedef struct 01276 { 01277 int8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ 01278 q15_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ 01279 q15_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ 01280 int8_t postShift; /**< Additional shift, in bits, applied to each output sample. */ 01281 01282 } arm_biquad_casd_df1_inst_q15; 01283 01284 01285 /** 01286 * @brief Instance structure for the Q31 Biquad cascade filter. 01287 */ 01288 typedef struct 01289 { 01290 uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ 01291 q31_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ 01292 q31_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ 01293 uint8_t postShift; /**< Additional shift, in bits, applied to each output sample. */ 01294 01295 } arm_biquad_casd_df1_inst_q31; 01296 01297 /** 01298 * @brief Instance structure for the floating-point Biquad cascade filter. 01299 */ 01300 typedef struct 01301 { 01302 uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ 01303 float32_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */ 01304 float32_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */ 01305 01306 01307 } arm_biquad_casd_df1_inst_f32; 01308 01309 01310 01311 /** 01312 * @brief Processing function for the Q15 Biquad cascade filter. 01313 * @param[in] *S points to an instance of the Q15 Biquad cascade structure. 01314 * @param[in] *pSrc points to the block of input data. 01315 * @param[out] *pDst points to the block of output data. 01316 * @param[in] blockSize number of samples to process. 01317 * @return none. 01318 */ 01319 01320 void arm_biquad_cascade_df1_q15( 01321 const arm_biquad_casd_df1_inst_q15 * S, 01322 q15_t * pSrc, 01323 q15_t * pDst, 01324 uint32_t blockSize); 01325 01326 /** 01327 * @brief Initialization function for the Q15 Biquad cascade filter. 01328 * @param[in,out] *S points to an instance of the Q15 Biquad cascade structure. 01329 * @param[in] numStages number of 2nd order stages in the filter. 01330 * @param[in] *pCoeffs points to the filter coefficients. 01331 * @param[in] *pState points to the state buffer. 01332 * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format 01333 * @return none 01334 */ 01335 01336 void arm_biquad_cascade_df1_init_q15( 01337 arm_biquad_casd_df1_inst_q15 * S, 01338 uint8_t numStages, 01339 q15_t * pCoeffs, 01340 q15_t * pState, 01341 int8_t postShift); 01342 01343 01344 /** 01345 * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4. 01346 * @param[in] *S points to an instance of the Q15 Biquad cascade structure. 01347 * @param[in] *pSrc points to the block of input data. 01348 * @param[out] *pDst points to the block of output data. 01349 * @param[in] blockSize number of samples to process. 01350 * @return none. 01351 */ 01352 01353 void arm_biquad_cascade_df1_fast_q15( 01354 const arm_biquad_casd_df1_inst_q15 * S, 01355 q15_t * pSrc, 01356 q15_t * pDst, 01357 uint32_t blockSize); 01358 01359 01360 /** 01361 * @brief Processing function for the Q31 Biquad cascade filter 01362 * @param[in] *S points to an instance of the Q31 Biquad cascade structure. 01363 * @param[in] *pSrc points to the block of input data. 01364 * @param[out] *pDst points to the block of output data. 01365 * @param[in] blockSize number of samples to process. 01366 * @return none. 01367 */ 01368 01369 void arm_biquad_cascade_df1_q31( 01370 const arm_biquad_casd_df1_inst_q31 * S, 01371 q31_t * pSrc, 01372 q31_t * pDst, 01373 uint32_t blockSize); 01374 01375 /** 01376 * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4. 01377 * @param[in] *S points to an instance of the Q31 Biquad cascade structure. 01378 * @param[in] *pSrc points to the block of input data. 01379 * @param[out] *pDst points to the block of output data. 01380 * @param[in] blockSize number of samples to process. 01381 * @return none. 01382 */ 01383 01384 void arm_biquad_cascade_df1_fast_q31( 01385 const arm_biquad_casd_df1_inst_q31 * S, 01386 q31_t * pSrc, 01387 q31_t * pDst, 01388 uint32_t blockSize); 01389 01390 /** 01391 * @brief Initialization function for the Q31 Biquad cascade filter. 01392 * @param[in,out] *S points to an instance of the Q31 Biquad cascade structure. 01393 * @param[in] numStages number of 2nd order stages in the filter. 01394 * @param[in] *pCoeffs points to the filter coefficients. 01395 * @param[in] *pState points to the state buffer. 01396 * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format 01397 * @return none 01398 */ 01399 01400 void arm_biquad_cascade_df1_init_q31( 01401 arm_biquad_casd_df1_inst_q31 * S, 01402 uint8_t numStages, 01403 q31_t * pCoeffs, 01404 q31_t * pState, 01405 int8_t postShift); 01406 01407 /** 01408 * @brief Processing function for the floating-point Biquad cascade filter. 01409 * @param[in] *S points to an instance of the floating-point Biquad cascade structure. 01410 * @param[in] *pSrc points to the block of input data. 01411 * @param[out] *pDst points to the block of output data. 01412 * @param[in] blockSize number of samples to process. 01413 * @return none. 01414 */ 01415 01416 void arm_biquad_cascade_df1_f32( 01417 const arm_biquad_casd_df1_inst_f32 * S, 01418 float32_t * pSrc, 01419 float32_t * pDst, 01420 uint32_t blockSize); 01421 01422 /** 01423 * @brief Initialization function for the floating-point Biquad cascade filter. 01424 * @param[in,out] *S points to an instance of the floating-point Biquad cascade structure. 01425 * @param[in] numStages number of 2nd order stages in the filter. 01426 * @param[in] *pCoeffs points to the filter coefficients. 01427 * @param[in] *pState points to the state buffer. 01428 * @return none 01429 */ 01430 01431 void arm_biquad_cascade_df1_init_f32( 01432 arm_biquad_casd_df1_inst_f32 * S, 01433 uint8_t numStages, 01434 float32_t * pCoeffs, 01435 float32_t * pState); 01436 01437 01438 /** 01439 * @brief Instance structure for the floating-point matrix structure. 01440 */ 01441 01442 typedef struct 01443 { 01444 uint16_t numRows; /**< number of rows of the matrix. */ 01445 uint16_t numCols; /**< number of columns of the matrix. */ 01446 float32_t *pData; /**< points to the data of the matrix. */ 01447 } arm_matrix_instance_f32; 01448 01449 01450 /** 01451 * @brief Instance structure for the floating-point matrix structure. 01452 */ 01453 01454 typedef struct 01455 { 01456 uint16_t numRows; /**< number of rows of the matrix. */ 01457 uint16_t numCols; /**< number of columns of the matrix. */ 01458 float64_t *pData; /**< points to the data of the matrix. */ 01459 } arm_matrix_instance_f64; 01460 01461 /** 01462 * @brief Instance structure for the Q15 matrix structure. 01463 */ 01464 01465 typedef struct 01466 { 01467 uint16_t numRows; /**< number of rows of the matrix. */ 01468 uint16_t numCols; /**< number of columns of the matrix. */ 01469 q15_t *pData; /**< points to the data of the matrix. */ 01470 01471 } arm_matrix_instance_q15; 01472 01473 /** 01474 * @brief Instance structure for the Q31 matrix structure. 01475 */ 01476 01477 typedef struct 01478 { 01479 uint16_t numRows; /**< number of rows of the matrix. */ 01480 uint16_t numCols; /**< number of columns of the matrix. */ 01481 q31_t *pData; /**< points to the data of the matrix. */ 01482 01483 } arm_matrix_instance_q31; 01484 01485 01486 01487 /** 01488 * @brief Floating-point matrix addition. 01489 * @param[in] *pSrcA points to the first input matrix structure 01490 * @param[in] *pSrcB points to the second input matrix structure 01491 * @param[out] *pDst points to output matrix structure 01492 * @return The function returns either 01493 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01494 */ 01495 01496 arm_status arm_mat_add_f32( 01497 const arm_matrix_instance_f32 * pSrcA, 01498 const arm_matrix_instance_f32 * pSrcB, 01499 arm_matrix_instance_f32 * pDst); 01500 01501 /** 01502 * @brief Q15 matrix addition. 01503 * @param[in] *pSrcA points to the first input matrix structure 01504 * @param[in] *pSrcB points to the second input matrix structure 01505 * @param[out] *pDst points to output matrix structure 01506 * @return The function returns either 01507 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01508 */ 01509 01510 arm_status arm_mat_add_q15( 01511 const arm_matrix_instance_q15 * pSrcA, 01512 const arm_matrix_instance_q15 * pSrcB, 01513 arm_matrix_instance_q15 * pDst); 01514 01515 /** 01516 * @brief Q31 matrix addition. 01517 * @param[in] *pSrcA points to the first input matrix structure 01518 * @param[in] *pSrcB points to the second input matrix structure 01519 * @param[out] *pDst points to output matrix structure 01520 * @return The function returns either 01521 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01522 */ 01523 01524 arm_status arm_mat_add_q31( 01525 const arm_matrix_instance_q31 * pSrcA, 01526 const arm_matrix_instance_q31 * pSrcB, 01527 arm_matrix_instance_q31 * pDst); 01528 01529 /** 01530 * @brief Floating-point, complex, matrix multiplication. 01531 * @param[in] *pSrcA points to the first input matrix structure 01532 * @param[in] *pSrcB points to the second input matrix structure 01533 * @param[out] *pDst points to output matrix structure 01534 * @return The function returns either 01535 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01536 */ 01537 01538 arm_status arm_mat_cmplx_mult_f32( 01539 const arm_matrix_instance_f32 * pSrcA, 01540 const arm_matrix_instance_f32 * pSrcB, 01541 arm_matrix_instance_f32 * pDst); 01542 01543 /** 01544 * @brief Q15, complex, matrix multiplication. 01545 * @param[in] *pSrcA points to the first input matrix structure 01546 * @param[in] *pSrcB points to the second input matrix structure 01547 * @param[out] *pDst points to output matrix structure 01548 * @return The function returns either 01549 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01550 */ 01551 01552 arm_status arm_mat_cmplx_mult_q15( 01553 const arm_matrix_instance_q15 * pSrcA, 01554 const arm_matrix_instance_q15 * pSrcB, 01555 arm_matrix_instance_q15 * pDst, 01556 q15_t * pScratch); 01557 01558 /** 01559 * @brief Q31, complex, matrix multiplication. 01560 * @param[in] *pSrcA points to the first input matrix structure 01561 * @param[in] *pSrcB points to the second input matrix structure 01562 * @param[out] *pDst points to output matrix structure 01563 * @return The function returns either 01564 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01565 */ 01566 01567 arm_status arm_mat_cmplx_mult_q31( 01568 const arm_matrix_instance_q31 * pSrcA, 01569 const arm_matrix_instance_q31 * pSrcB, 01570 arm_matrix_instance_q31 * pDst); 01571 01572 01573 /** 01574 * @brief Floating-point matrix transpose. 01575 * @param[in] *pSrc points to the input matrix 01576 * @param[out] *pDst points to the output matrix 01577 * @return The function returns either <code>ARM_MATH_SIZE_MISMATCH</code> 01578 * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01579 */ 01580 01581 arm_status arm_mat_trans_f32( 01582 const arm_matrix_instance_f32 * pSrc, 01583 arm_matrix_instance_f32 * pDst); 01584 01585 01586 /** 01587 * @brief Q15 matrix transpose. 01588 * @param[in] *pSrc points to the input matrix 01589 * @param[out] *pDst points to the output matrix 01590 * @return The function returns either <code>ARM_MATH_SIZE_MISMATCH</code> 01591 * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01592 */ 01593 01594 arm_status arm_mat_trans_q15( 01595 const arm_matrix_instance_q15 * pSrc, 01596 arm_matrix_instance_q15 * pDst); 01597 01598 /** 01599 * @brief Q31 matrix transpose. 01600 * @param[in] *pSrc points to the input matrix 01601 * @param[out] *pDst points to the output matrix 01602 * @return The function returns either <code>ARM_MATH_SIZE_MISMATCH</code> 01603 * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01604 */ 01605 01606 arm_status arm_mat_trans_q31( 01607 const arm_matrix_instance_q31 * pSrc, 01608 arm_matrix_instance_q31 * pDst); 01609 01610 01611 /** 01612 * @brief Floating-point matrix multiplication 01613 * @param[in] *pSrcA points to the first input matrix structure 01614 * @param[in] *pSrcB points to the second input matrix structure 01615 * @param[out] *pDst points to output matrix structure 01616 * @return The function returns either 01617 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01618 */ 01619 01620 arm_status arm_mat_mult_f32( 01621 const arm_matrix_instance_f32 * pSrcA, 01622 const arm_matrix_instance_f32 * pSrcB, 01623 arm_matrix_instance_f32 * pDst); 01624 01625 /** 01626 * @brief Q15 matrix multiplication 01627 * @param[in] *pSrcA points to the first input matrix structure 01628 * @param[in] *pSrcB points to the second input matrix structure 01629 * @param[out] *pDst points to output matrix structure 01630 * @param[in] *pState points to the array for storing intermediate results 01631 * @return The function returns either 01632 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01633 */ 01634 01635 arm_status arm_mat_mult_q15( 01636 const arm_matrix_instance_q15 * pSrcA, 01637 const arm_matrix_instance_q15 * pSrcB, 01638 arm_matrix_instance_q15 * pDst, 01639 q15_t * pState); 01640 01641 /** 01642 * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4 01643 * @param[in] *pSrcA points to the first input matrix structure 01644 * @param[in] *pSrcB points to the second input matrix structure 01645 * @param[out] *pDst points to output matrix structure 01646 * @param[in] *pState points to the array for storing intermediate results 01647 * @return The function returns either 01648 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01649 */ 01650 01651 arm_status arm_mat_mult_fast_q15( 01652 const arm_matrix_instance_q15 * pSrcA, 01653 const arm_matrix_instance_q15 * pSrcB, 01654 arm_matrix_instance_q15 * pDst, 01655 q15_t * pState); 01656 01657 /** 01658 * @brief Q31 matrix multiplication 01659 * @param[in] *pSrcA points to the first input matrix structure 01660 * @param[in] *pSrcB points to the second input matrix structure 01661 * @param[out] *pDst points to output matrix structure 01662 * @return The function returns either 01663 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01664 */ 01665 01666 arm_status arm_mat_mult_q31( 01667 const arm_matrix_instance_q31 * pSrcA, 01668 const arm_matrix_instance_q31 * pSrcB, 01669 arm_matrix_instance_q31 * pDst); 01670 01671 /** 01672 * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4 01673 * @param[in] *pSrcA points to the first input matrix structure 01674 * @param[in] *pSrcB points to the second input matrix structure 01675 * @param[out] *pDst points to output matrix structure 01676 * @return The function returns either 01677 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01678 */ 01679 01680 arm_status arm_mat_mult_fast_q31( 01681 const arm_matrix_instance_q31 * pSrcA, 01682 const arm_matrix_instance_q31 * pSrcB, 01683 arm_matrix_instance_q31 * pDst); 01684 01685 01686 /** 01687 * @brief Floating-point matrix subtraction 01688 * @param[in] *pSrcA points to the first input matrix structure 01689 * @param[in] *pSrcB points to the second input matrix structure 01690 * @param[out] *pDst points to output matrix structure 01691 * @return The function returns either 01692 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01693 */ 01694 01695 arm_status arm_mat_sub_f32( 01696 const arm_matrix_instance_f32 * pSrcA, 01697 const arm_matrix_instance_f32 * pSrcB, 01698 arm_matrix_instance_f32 * pDst); 01699 01700 /** 01701 * @brief Q15 matrix subtraction 01702 * @param[in] *pSrcA points to the first input matrix structure 01703 * @param[in] *pSrcB points to the second input matrix structure 01704 * @param[out] *pDst points to output matrix structure 01705 * @return The function returns either 01706 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01707 */ 01708 01709 arm_status arm_mat_sub_q15( 01710 const arm_matrix_instance_q15 * pSrcA, 01711 const arm_matrix_instance_q15 * pSrcB, 01712 arm_matrix_instance_q15 * pDst); 01713 01714 /** 01715 * @brief Q31 matrix subtraction 01716 * @param[in] *pSrcA points to the first input matrix structure 01717 * @param[in] *pSrcB points to the second input matrix structure 01718 * @param[out] *pDst points to output matrix structure 01719 * @return The function returns either 01720 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01721 */ 01722 01723 arm_status arm_mat_sub_q31( 01724 const arm_matrix_instance_q31 * pSrcA, 01725 const arm_matrix_instance_q31 * pSrcB, 01726 arm_matrix_instance_q31 * pDst); 01727 01728 /** 01729 * @brief Floating-point matrix scaling. 01730 * @param[in] *pSrc points to the input matrix 01731 * @param[in] scale scale factor 01732 * @param[out] *pDst points to the output matrix 01733 * @return The function returns either 01734 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01735 */ 01736 01737 arm_status arm_mat_scale_f32( 01738 const arm_matrix_instance_f32 * pSrc, 01739 float32_t scale, 01740 arm_matrix_instance_f32 * pDst); 01741 01742 /** 01743 * @brief Q15 matrix scaling. 01744 * @param[in] *pSrc points to input matrix 01745 * @param[in] scaleFract fractional portion of the scale factor 01746 * @param[in] shift number of bits to shift the result by 01747 * @param[out] *pDst points to output matrix 01748 * @return The function returns either 01749 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01750 */ 01751 01752 arm_status arm_mat_scale_q15( 01753 const arm_matrix_instance_q15 * pSrc, 01754 q15_t scaleFract, 01755 int32_t shift, 01756 arm_matrix_instance_q15 * pDst); 01757 01758 /** 01759 * @brief Q31 matrix scaling. 01760 * @param[in] *pSrc points to input matrix 01761 * @param[in] scaleFract fractional portion of the scale factor 01762 * @param[in] shift number of bits to shift the result by 01763 * @param[out] *pDst points to output matrix structure 01764 * @return The function returns either 01765 * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking. 01766 */ 01767 01768 arm_status arm_mat_scale_q31( 01769 const arm_matrix_instance_q31 * pSrc, 01770 q31_t scaleFract, 01771 int32_t shift, 01772 arm_matrix_instance_q31 * pDst); 01773 01774 01775 /** 01776 * @brief Q31 matrix initialization. 01777 * @param[in,out] *S points to an instance of the floating-point matrix structure. 01778 * @param[in] nRows number of rows in the matrix. 01779 * @param[in] nColumns number of columns in the matrix. 01780 * @param[in] *pData points to the matrix data array. 01781 * @return none 01782 */ 01783 01784 void arm_mat_init_q31( 01785 arm_matrix_instance_q31 * S, 01786 uint16_t nRows, 01787 uint16_t nColumns, 01788 q31_t * pData); 01789 01790 /** 01791 * @brief Q15 matrix initialization. 01792 * @param[in,out] *S points to an instance of the floating-point matrix structure. 01793 * @param[in] nRows number of rows in the matrix. 01794 * @param[in] nColumns number of columns in the matrix. 01795 * @param[in] *pData points to the matrix data array. 01796 * @return none 01797 */ 01798 01799 void arm_mat_init_q15( 01800 arm_matrix_instance_q15 * S, 01801 uint16_t nRows, 01802 uint16_t nColumns, 01803 q15_t * pData); 01804 01805 /** 01806 * @brief Floating-point matrix initialization. 01807 * @param[in,out] *S points to an instance of the floating-point matrix structure. 01808 * @param[in] nRows number of rows in the matrix. 01809 * @param[in] nColumns number of columns in the matrix. 01810 * @param[in] *pData points to the matrix data array. 01811 * @return none 01812 */ 01813 01814 void arm_mat_init_f32( 01815 arm_matrix_instance_f32 * S, 01816 uint16_t nRows, 01817 uint16_t nColumns, 01818 float32_t * pData); 01819 01820 01821 01822 /** 01823 * @brief Instance structure for the Q15 PID Control. 01824 */ 01825 typedef struct 01826 { 01827 q15_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ 01828 #ifdef ARM_MATH_CM0_FAMILY 01829 q15_t A1; 01830 q15_t A2; 01831 #else 01832 q31_t A1; /**< The derived gain A1 = -Kp - 2Kd | Kd.*/ 01833 #endif 01834 q15_t state[3]; /**< The state array of length 3. */ 01835 q15_t Kp; /**< The proportional gain. */ 01836 q15_t Ki; /**< The integral gain. */ 01837 q15_t Kd; /**< The derivative gain. */ 01838 } arm_pid_instance_q15; 01839 01840 /** 01841 * @brief Instance structure for the Q31 PID Control. 01842 */ 01843 typedef struct 01844 { 01845 q31_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ 01846 q31_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */ 01847 q31_t A2; /**< The derived gain, A2 = Kd . */ 01848 q31_t state[3]; /**< The state array of length 3. */ 01849 q31_t Kp; /**< The proportional gain. */ 01850 q31_t Ki; /**< The integral gain. */ 01851 q31_t Kd; /**< The derivative gain. */ 01852 01853 } arm_pid_instance_q31; 01854 01855 /** 01856 * @brief Instance structure for the floating-point PID Control. 01857 */ 01858 typedef struct 01859 { 01860 float32_t A0; /**< The derived gain, A0 = Kp + Ki + Kd . */ 01861 float32_t A1; /**< The derived gain, A1 = -Kp - 2Kd. */ 01862 float32_t A2; /**< The derived gain, A2 = Kd . */ 01863 float32_t state[3]; /**< The state array of length 3. */ 01864 float32_t Kp; /**< The proportional gain. */ 01865 float32_t Ki; /**< The integral gain. */ 01866 float32_t Kd; /**< The derivative gain. */ 01867 } arm_pid_instance_f32; 01868 01869 01870 01871 /** 01872 * @brief Initialization function for the floating-point PID Control. 01873 * @param[in,out] *S points to an instance of the PID structure. 01874 * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. 01875 * @return none. 01876 */ 01877 void arm_pid_init_f32( 01878 arm_pid_instance_f32 * S, 01879 int32_t resetStateFlag); 01880 01881 /** 01882 * @brief Reset function for the floating-point PID Control. 01883 * @param[in,out] *S is an instance of the floating-point PID Control structure 01884 * @return none 01885 */ 01886 void arm_pid_reset_f32( 01887 arm_pid_instance_f32 * S); 01888 01889 01890 /** 01891 * @brief Initialization function for the Q31 PID Control. 01892 * @param[in,out] *S points to an instance of the Q15 PID structure. 01893 * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. 01894 * @return none. 01895 */ 01896 void arm_pid_init_q31( 01897 arm_pid_instance_q31 * S, 01898 int32_t resetStateFlag); 01899 01900 01901 /** 01902 * @brief Reset function for the Q31 PID Control. 01903 * @param[in,out] *S points to an instance of the Q31 PID Control structure 01904 * @return none 01905 */ 01906 01907 void arm_pid_reset_q31( 01908 arm_pid_instance_q31 * S); 01909 01910 /** 01911 * @brief Initialization function for the Q15 PID Control. 01912 * @param[in,out] *S points to an instance of the Q15 PID structure. 01913 * @param[in] resetStateFlag flag to reset the state. 0 = no change in state 1 = reset the state. 01914 * @return none. 01915 */ 01916 void arm_pid_init_q15( 01917 arm_pid_instance_q15 * S, 01918 int32_t resetStateFlag); 01919 01920 /** 01921 * @brief Reset function for the Q15 PID Control. 01922 * @param[in,out] *S points to an instance of the q15 PID Control structure 01923 * @return none 01924 */ 01925 void arm_pid_reset_q15( 01926 arm_pid_instance_q15 * S); 01927 01928 01929 /** 01930 * @brief Instance structure for the floating-point Linear Interpolate function. 01931 */ 01932 typedef struct 01933 { 01934 uint32_t nValues; /**< nValues */ 01935 float32_t x1; /**< x1 */ 01936 float32_t xSpacing; /**< xSpacing */ 01937 float32_t *pYData; /**< pointer to the table of Y values */ 01938 } arm_linear_interp_instance_f32; 01939 01940 /** 01941 * @brief Instance structure for the floating-point bilinear interpolation function. 01942 */ 01943 01944 typedef struct 01945 { 01946 uint16_t numRows; /**< number of rows in the data table. */ 01947 uint16_t numCols; /**< number of columns in the data table. */ 01948 float32_t *pData; /**< points to the data table. */ 01949 } arm_bilinear_interp_instance_f32; 01950 01951 /** 01952 * @brief Instance structure for the Q31 bilinear interpolation function. 01953 */ 01954 01955 typedef struct 01956 { 01957 uint16_t numRows; /**< number of rows in the data table. */ 01958 uint16_t numCols; /**< number of columns in the data table. */ 01959 q31_t *pData; /**< points to the data table. */ 01960 } arm_bilinear_interp_instance_q31; 01961 01962 /** 01963 * @brief Instance structure for the Q15 bilinear interpolation function. 01964 */ 01965 01966 typedef struct 01967 { 01968 uint16_t numRows; /**< number of rows in the data table. */ 01969 uint16_t numCols; /**< number of columns in the data table. */ 01970 q15_t *pData; /**< points to the data table. */ 01971 } arm_bilinear_interp_instance_q15; 01972 01973 /** 01974 * @brief Instance structure for the Q15 bilinear interpolation function. 01975 */ 01976 01977 typedef struct 01978 { 01979 uint16_t numRows; /**< number of rows in the data table. */ 01980 uint16_t numCols; /**< number of columns in the data table. */ 01981 q7_t *pData; /**< points to the data table. */ 01982 } arm_bilinear_interp_instance_q7; 01983 01984 01985 /** 01986 * @brief Q7 vector multiplication. 01987 * @param[in] *pSrcA points to the first input vector 01988 * @param[in] *pSrcB points to the second input vector 01989 * @param[out] *pDst points to the output vector 01990 * @param[in] blockSize number of samples in each vector 01991 * @return none. 01992 */ 01993 01994 void arm_mult_q7( 01995 q7_t * pSrcA, 01996 q7_t * pSrcB, 01997 q7_t * pDst, 01998 uint32_t blockSize); 01999 02000 /** 02001 * @brief Q15 vector multiplication. 02002 * @param[in] *pSrcA points to the first input vector 02003 * @param[in] *pSrcB points to the second input vector 02004 * @param[out] *pDst points to the output vector 02005 * @param[in] blockSize number of samples in each vector 02006 * @return none. 02007 */ 02008 02009 void arm_mult_q15( 02010 q15_t * pSrcA, 02011 q15_t * pSrcB, 02012 q15_t * pDst, 02013 uint32_t blockSize); 02014 02015 /** 02016 * @brief Q31 vector multiplication. 02017 * @param[in] *pSrcA points to the first input vector 02018 * @param[in] *pSrcB points to the second input vector 02019 * @param[out] *pDst points to the output vector 02020 * @param[in] blockSize number of samples in each vector 02021 * @return none. 02022 */ 02023 02024 void arm_mult_q31( 02025 q31_t * pSrcA, 02026 q31_t * pSrcB, 02027 q31_t * pDst, 02028 uint32_t blockSize); 02029 02030 /** 02031 * @brief Floating-point vector multiplication. 02032 * @param[in] *pSrcA points to the first input vector 02033 * @param[in] *pSrcB points to the second input vector 02034 * @param[out] *pDst points to the output vector 02035 * @param[in] blockSize number of samples in each vector 02036 * @return none. 02037 */ 02038 02039 void arm_mult_f32( 02040 float32_t * pSrcA, 02041 float32_t * pSrcB, 02042 float32_t * pDst, 02043 uint32_t blockSize); 02044 02045 02046 02047 02048 02049 02050 /** 02051 * @brief Instance structure for the Q15 CFFT/CIFFT function. 02052 */ 02053 02054 typedef struct 02055 { 02056 uint16_t fftLen; /**< length of the FFT. */ 02057 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ 02058 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ 02059 q15_t *pTwiddle; /**< points to the Sin twiddle factor table. */ 02060 uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02061 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02062 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ 02063 } arm_cfft_radix2_instance_q15; 02064 02065 /* Deprecated */ 02066 arm_status arm_cfft_radix2_init_q15( 02067 arm_cfft_radix2_instance_q15 * S, 02068 uint16_t fftLen, 02069 uint8_t ifftFlag, 02070 uint8_t bitReverseFlag); 02071 02072 /* Deprecated */ 02073 void arm_cfft_radix2_q15( 02074 const arm_cfft_radix2_instance_q15 * S, 02075 q15_t * pSrc); 02076 02077 02078 02079 /** 02080 * @brief Instance structure for the Q15 CFFT/CIFFT function. 02081 */ 02082 02083 typedef struct 02084 { 02085 uint16_t fftLen; /**< length of the FFT. */ 02086 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ 02087 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ 02088 q15_t *pTwiddle; /**< points to the twiddle factor table. */ 02089 uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02090 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02091 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ 02092 } arm_cfft_radix4_instance_q15; 02093 02094 /* Deprecated */ 02095 arm_status arm_cfft_radix4_init_q15( 02096 arm_cfft_radix4_instance_q15 * S, 02097 uint16_t fftLen, 02098 uint8_t ifftFlag, 02099 uint8_t bitReverseFlag); 02100 02101 /* Deprecated */ 02102 void arm_cfft_radix4_q15( 02103 const arm_cfft_radix4_instance_q15 * S, 02104 q15_t * pSrc); 02105 02106 /** 02107 * @brief Instance structure for the Radix-2 Q31 CFFT/CIFFT function. 02108 */ 02109 02110 typedef struct 02111 { 02112 uint16_t fftLen; /**< length of the FFT. */ 02113 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ 02114 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ 02115 q31_t *pTwiddle; /**< points to the Twiddle factor table. */ 02116 uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02117 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02118 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ 02119 } arm_cfft_radix2_instance_q31; 02120 02121 /* Deprecated */ 02122 arm_status arm_cfft_radix2_init_q31( 02123 arm_cfft_radix2_instance_q31 * S, 02124 uint16_t fftLen, 02125 uint8_t ifftFlag, 02126 uint8_t bitReverseFlag); 02127 02128 /* Deprecated */ 02129 void arm_cfft_radix2_q31( 02130 const arm_cfft_radix2_instance_q31 * S, 02131 q31_t * pSrc); 02132 02133 /** 02134 * @brief Instance structure for the Q31 CFFT/CIFFT function. 02135 */ 02136 02137 typedef struct 02138 { 02139 uint16_t fftLen; /**< length of the FFT. */ 02140 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ 02141 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ 02142 q31_t *pTwiddle; /**< points to the twiddle factor table. */ 02143 uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02144 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02145 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ 02146 } arm_cfft_radix4_instance_q31; 02147 02148 /* Deprecated */ 02149 void arm_cfft_radix4_q31( 02150 const arm_cfft_radix4_instance_q31 * S, 02151 q31_t * pSrc); 02152 02153 /* Deprecated */ 02154 arm_status arm_cfft_radix4_init_q31( 02155 arm_cfft_radix4_instance_q31 * S, 02156 uint16_t fftLen, 02157 uint8_t ifftFlag, 02158 uint8_t bitReverseFlag); 02159 02160 /** 02161 * @brief Instance structure for the floating-point CFFT/CIFFT function. 02162 */ 02163 02164 typedef struct 02165 { 02166 uint16_t fftLen; /**< length of the FFT. */ 02167 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ 02168 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ 02169 float32_t *pTwiddle; /**< points to the Twiddle factor table. */ 02170 uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02171 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02172 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ 02173 float32_t onebyfftLen; /**< value of 1/fftLen. */ 02174 } arm_cfft_radix2_instance_f32; 02175 02176 /* Deprecated */ 02177 arm_status arm_cfft_radix2_init_f32( 02178 arm_cfft_radix2_instance_f32 * S, 02179 uint16_t fftLen, 02180 uint8_t ifftFlag, 02181 uint8_t bitReverseFlag); 02182 02183 /* Deprecated */ 02184 void arm_cfft_radix2_f32( 02185 const arm_cfft_radix2_instance_f32 * S, 02186 float32_t * pSrc); 02187 02188 /** 02189 * @brief Instance structure for the floating-point CFFT/CIFFT function. 02190 */ 02191 02192 typedef struct 02193 { 02194 uint16_t fftLen; /**< length of the FFT. */ 02195 uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */ 02196 uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */ 02197 float32_t *pTwiddle; /**< points to the Twiddle factor table. */ 02198 uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02199 uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02200 uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */ 02201 float32_t onebyfftLen; /**< value of 1/fftLen. */ 02202 } arm_cfft_radix4_instance_f32; 02203 02204 /* Deprecated */ 02205 arm_status arm_cfft_radix4_init_f32( 02206 arm_cfft_radix4_instance_f32 * S, 02207 uint16_t fftLen, 02208 uint8_t ifftFlag, 02209 uint8_t bitReverseFlag); 02210 02211 /* Deprecated */ 02212 void arm_cfft_radix4_f32( 02213 const arm_cfft_radix4_instance_f32 * S, 02214 float32_t * pSrc); 02215 02216 /** 02217 * @brief Instance structure for the fixed-point CFFT/CIFFT function. 02218 */ 02219 02220 typedef struct 02221 { 02222 uint16_t fftLen; /**< length of the FFT. */ 02223 const q15_t *pTwiddle; /**< points to the Twiddle factor table. */ 02224 const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02225 uint16_t bitRevLength; /**< bit reversal table length. */ 02226 } arm_cfft_instance_q15; 02227 02228 void arm_cfft_q15( 02229 const arm_cfft_instance_q15 * S, 02230 q15_t * p1, 02231 uint8_t ifftFlag, 02232 uint8_t bitReverseFlag); 02233 02234 /** 02235 * @brief Instance structure for the fixed-point CFFT/CIFFT function. 02236 */ 02237 02238 typedef struct 02239 { 02240 uint16_t fftLen; /**< length of the FFT. */ 02241 const q31_t *pTwiddle; /**< points to the Twiddle factor table. */ 02242 const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02243 uint16_t bitRevLength; /**< bit reversal table length. */ 02244 } arm_cfft_instance_q31; 02245 02246 void arm_cfft_q31( 02247 const arm_cfft_instance_q31 * S, 02248 q31_t * p1, 02249 uint8_t ifftFlag, 02250 uint8_t bitReverseFlag); 02251 02252 /** 02253 * @brief Instance structure for the floating-point CFFT/CIFFT function. 02254 */ 02255 02256 typedef struct 02257 { 02258 uint16_t fftLen; /**< length of the FFT. */ 02259 const float32_t *pTwiddle; /**< points to the Twiddle factor table. */ 02260 const uint16_t *pBitRevTable; /**< points to the bit reversal table. */ 02261 uint16_t bitRevLength; /**< bit reversal table length. */ 02262 } arm_cfft_instance_f32; 02263 02264 void arm_cfft_f32( 02265 const arm_cfft_instance_f32 * S, 02266 float32_t * p1, 02267 uint8_t ifftFlag, 02268 uint8_t bitReverseFlag); 02269 02270 /** 02271 * @brief Instance structure for the Q15 RFFT/RIFFT function. 02272 */ 02273 02274 typedef struct 02275 { 02276 uint32_t fftLenReal; /**< length of the real FFT. */ 02277 uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ 02278 uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ 02279 uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02280 q15_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ 02281 q15_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ 02282 const arm_cfft_instance_q15 *pCfft; /**< points to the complex FFT instance. */ 02283 } arm_rfft_instance_q15; 02284 02285 arm_status arm_rfft_init_q15( 02286 arm_rfft_instance_q15 * S, 02287 uint32_t fftLenReal, 02288 uint32_t ifftFlagR, 02289 uint32_t bitReverseFlag); 02290 02291 void arm_rfft_q15( 02292 const arm_rfft_instance_q15 * S, 02293 q15_t * pSrc, 02294 q15_t * pDst); 02295 02296 /** 02297 * @brief Instance structure for the Q31 RFFT/RIFFT function. 02298 */ 02299 02300 typedef struct 02301 { 02302 uint32_t fftLenReal; /**< length of the real FFT. */ 02303 uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ 02304 uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ 02305 uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02306 q31_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ 02307 q31_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ 02308 const arm_cfft_instance_q31 *pCfft; /**< points to the complex FFT instance. */ 02309 } arm_rfft_instance_q31; 02310 02311 arm_status arm_rfft_init_q31( 02312 arm_rfft_instance_q31 * S, 02313 uint32_t fftLenReal, 02314 uint32_t ifftFlagR, 02315 uint32_t bitReverseFlag); 02316 02317 void arm_rfft_q31( 02318 const arm_rfft_instance_q31 * S, 02319 q31_t * pSrc, 02320 q31_t * pDst); 02321 02322 /** 02323 * @brief Instance structure for the floating-point RFFT/RIFFT function. 02324 */ 02325 02326 typedef struct 02327 { 02328 uint32_t fftLenReal; /**< length of the real FFT. */ 02329 uint16_t fftLenBy2; /**< length of the complex FFT. */ 02330 uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */ 02331 uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */ 02332 uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */ 02333 float32_t *pTwiddleAReal; /**< points to the real twiddle factor table. */ 02334 float32_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */ 02335 arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */ 02336 } arm_rfft_instance_f32; 02337 02338 arm_status arm_rfft_init_f32( 02339 arm_rfft_instance_f32 * S, 02340 arm_cfft_radix4_instance_f32 * S_CFFT, 02341 uint32_t fftLenReal, 02342 uint32_t ifftFlagR, 02343 uint32_t bitReverseFlag); 02344 02345 void arm_rfft_f32( 02346 const arm_rfft_instance_f32 * S, 02347 float32_t * pSrc, 02348 float32_t * pDst); 02349 02350 /** 02351 * @brief Instance structure for the floating-point RFFT/RIFFT function. 02352 */ 02353 02354 typedef struct 02355 { 02356 arm_cfft_instance_f32 Sint; /**< Internal CFFT structure. */ 02357 uint16_t fftLenRFFT; /**< length of the real sequence */ 02358 float32_t * pTwiddleRFFT; /**< Twiddle factors real stage */ 02359 } arm_rfft_fast_instance_f32 ; 02360 02361 arm_status arm_rfft_fast_init_f32 ( 02362 arm_rfft_fast_instance_f32 * S, 02363 uint16_t fftLen); 02364 02365 void arm_rfft_fast_f32( 02366 arm_rfft_fast_instance_f32 * S, 02367 float32_t * p, float32_t * pOut, 02368 uint8_t ifftFlag); 02369 02370 /** 02371 * @brief Instance structure for the floating-point DCT4/IDCT4 function. 02372 */ 02373 02374 typedef struct 02375 { 02376 uint16_t N; /**< length of the DCT4. */ 02377 uint16_t Nby2; /**< half of the length of the DCT4. */ 02378 float32_t normalize; /**< normalizing factor. */ 02379 float32_t *pTwiddle; /**< points to the twiddle factor table. */ 02380 float32_t *pCosFactor; /**< points to the cosFactor table. */ 02381 arm_rfft_instance_f32 *pRfft; /**< points to the real FFT instance. */ 02382 arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */ 02383 } arm_dct4_instance_f32; 02384 02385 /** 02386 * @brief Initialization function for the floating-point DCT4/IDCT4. 02387 * @param[in,out] *S points to an instance of floating-point DCT4/IDCT4 structure. 02388 * @param[in] *S_RFFT points to an instance of floating-point RFFT/RIFFT structure. 02389 * @param[in] *S_CFFT points to an instance of floating-point CFFT/CIFFT structure. 02390 * @param[in] N length of the DCT4. 02391 * @param[in] Nby2 half of the length of the DCT4. 02392 * @param[in] normalize normalizing factor. 02393 * @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. 02394 */ 02395 02396 arm_status arm_dct4_init_f32( 02397 arm_dct4_instance_f32 * S, 02398 arm_rfft_instance_f32 * S_RFFT, 02399 arm_cfft_radix4_instance_f32 * S_CFFT, 02400 uint16_t N, 02401 uint16_t Nby2, 02402 float32_t normalize); 02403 02404 /** 02405 * @brief Processing function for the floating-point DCT4/IDCT4. 02406 * @param[in] *S points to an instance of the floating-point DCT4/IDCT4 structure. 02407 * @param[in] *pState points to state buffer. 02408 * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. 02409 * @return none. 02410 */ 02411 02412 void arm_dct4_f32( 02413 const arm_dct4_instance_f32 * S, 02414 float32_t * pState, 02415 float32_t * pInlineBuffer); 02416 02417 /** 02418 * @brief Instance structure for the Q31 DCT4/IDCT4 function. 02419 */ 02420 02421 typedef struct 02422 { 02423 uint16_t N; /**< length of the DCT4. */ 02424 uint16_t Nby2; /**< half of the length of the DCT4. */ 02425 q31_t normalize; /**< normalizing factor. */ 02426 q31_t *pTwiddle; /**< points to the twiddle factor table. */ 02427 q31_t *pCosFactor; /**< points to the cosFactor table. */ 02428 arm_rfft_instance_q31 *pRfft; /**< points to the real FFT instance. */ 02429 arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */ 02430 } arm_dct4_instance_q31; 02431 02432 /** 02433 * @brief Initialization function for the Q31 DCT4/IDCT4. 02434 * @param[in,out] *S points to an instance of Q31 DCT4/IDCT4 structure. 02435 * @param[in] *S_RFFT points to an instance of Q31 RFFT/RIFFT structure 02436 * @param[in] *S_CFFT points to an instance of Q31 CFFT/CIFFT structure 02437 * @param[in] N length of the DCT4. 02438 * @param[in] Nby2 half of the length of the DCT4. 02439 * @param[in] normalize normalizing factor. 02440 * @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. 02441 */ 02442 02443 arm_status arm_dct4_init_q31( 02444 arm_dct4_instance_q31 * S, 02445 arm_rfft_instance_q31 * S_RFFT, 02446 arm_cfft_radix4_instance_q31 * S_CFFT, 02447 uint16_t N, 02448 uint16_t Nby2, 02449 q31_t normalize); 02450 02451 /** 02452 * @brief Processing function for the Q31 DCT4/IDCT4. 02453 * @param[in] *S points to an instance of the Q31 DCT4 structure. 02454 * @param[in] *pState points to state buffer. 02455 * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. 02456 * @return none. 02457 */ 02458 02459 void arm_dct4_q31( 02460 const arm_dct4_instance_q31 * S, 02461 q31_t * pState, 02462 q31_t * pInlineBuffer); 02463 02464 /** 02465 * @brief Instance structure for the Q15 DCT4/IDCT4 function. 02466 */ 02467 02468 typedef struct 02469 { 02470 uint16_t N; /**< length of the DCT4. */ 02471 uint16_t Nby2; /**< half of the length of the DCT4. */ 02472 q15_t normalize; /**< normalizing factor. */ 02473 q15_t *pTwiddle; /**< points to the twiddle factor table. */ 02474 q15_t *pCosFactor; /**< points to the cosFactor table. */ 02475 arm_rfft_instance_q15 *pRfft; /**< points to the real FFT instance. */ 02476 arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */ 02477 } arm_dct4_instance_q15; 02478 02479 /** 02480 * @brief Initialization function for the Q15 DCT4/IDCT4. 02481 * @param[in,out] *S points to an instance of Q15 DCT4/IDCT4 structure. 02482 * @param[in] *S_RFFT points to an instance of Q15 RFFT/RIFFT structure. 02483 * @param[in] *S_CFFT points to an instance of Q15 CFFT/CIFFT structure. 02484 * @param[in] N length of the DCT4. 02485 * @param[in] Nby2 half of the length of the DCT4. 02486 * @param[in] normalize normalizing factor. 02487 * @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. 02488 */ 02489 02490 arm_status arm_dct4_init_q15( 02491 arm_dct4_instance_q15 * S, 02492 arm_rfft_instance_q15 * S_RFFT, 02493 arm_cfft_radix4_instance_q15 * S_CFFT, 02494 uint16_t N, 02495 uint16_t Nby2, 02496 q15_t normalize); 02497 02498 /** 02499 * @brief Processing function for the Q15 DCT4/IDCT4. 02500 * @param[in] *S points to an instance of the Q15 DCT4 structure. 02501 * @param[in] *pState points to state buffer. 02502 * @param[in,out] *pInlineBuffer points to the in-place input and output buffer. 02503 * @return none. 02504 */ 02505 02506 void arm_dct4_q15( 02507 const arm_dct4_instance_q15 * S, 02508 q15_t * pState, 02509 q15_t * pInlineBuffer); 02510 02511 /** 02512 * @brief Floating-point vector addition. 02513 * @param[in] *pSrcA points to the first input vector 02514 * @param[in] *pSrcB points to the second input vector 02515 * @param[out] *pDst points to the output vector 02516 * @param[in] blockSize number of samples in each vector 02517 * @return none. 02518 */ 02519 02520 void arm_add_f32( 02521 float32_t * pSrcA, 02522 float32_t * pSrcB, 02523 float32_t * pDst, 02524 uint32_t blockSize); 02525 02526 /** 02527 * @brief Q7 vector addition. 02528 * @param[in] *pSrcA points to the first input vector 02529 * @param[in] *pSrcB points to the second input vector 02530 * @param[out] *pDst points to the output vector 02531 * @param[in] blockSize number of samples in each vector 02532 * @return none. 02533 */ 02534 02535 void arm_add_q7( 02536 q7_t * pSrcA, 02537 q7_t * pSrcB, 02538 q7_t * pDst, 02539 uint32_t blockSize); 02540 02541 /** 02542 * @brief Q15 vector addition. 02543 * @param[in] *pSrcA points to the first input vector 02544 * @param[in] *pSrcB points to the second input vector 02545 * @param[out] *pDst points to the output vector 02546 * @param[in] blockSize number of samples in each vector 02547 * @return none. 02548 */ 02549 02550 void arm_add_q15( 02551 q15_t * pSrcA, 02552 q15_t * pSrcB, 02553 q15_t * pDst, 02554 uint32_t blockSize); 02555 02556 /** 02557 * @brief Q31 vector addition. 02558 * @param[in] *pSrcA points to the first input vector 02559 * @param[in] *pSrcB points to the second input vector 02560 * @param[out] *pDst points to the output vector 02561 * @param[in] blockSize number of samples in each vector 02562 * @return none. 02563 */ 02564 02565 void arm_add_q31( 02566 q31_t * pSrcA, 02567 q31_t * pSrcB, 02568 q31_t * pDst, 02569 uint32_t blockSize); 02570 02571 /** 02572 * @brief Floating-point vector subtraction. 02573 * @param[in] *pSrcA points to the first input vector 02574 * @param[in] *pSrcB points to the second input vector 02575 * @param[out] *pDst points to the output vector 02576 * @param[in] blockSize number of samples in each vector 02577 * @return none. 02578 */ 02579 02580 void arm_sub_f32( 02581 float32_t * pSrcA, 02582 float32_t * pSrcB, 02583 float32_t * pDst, 02584 uint32_t blockSize); 02585 02586 /** 02587 * @brief Q7 vector subtraction. 02588 * @param[in] *pSrcA points to the first input vector 02589 * @param[in] *pSrcB points to the second input vector 02590 * @param[out] *pDst points to the output vector 02591 * @param[in] blockSize number of samples in each vector 02592 * @return none. 02593 */ 02594 02595 void arm_sub_q7( 02596 q7_t * pSrcA, 02597 q7_t * pSrcB, 02598 q7_t * pDst, 02599 uint32_t blockSize); 02600 02601 /** 02602 * @brief Q15 vector subtraction. 02603 * @param[in] *pSrcA points to the first input vector 02604 * @param[in] *pSrcB points to the second input vector 02605 * @param[out] *pDst points to the output vector 02606 * @param[in] blockSize number of samples in each vector 02607 * @return none. 02608 */ 02609 02610 void arm_sub_q15( 02611 q15_t * pSrcA, 02612 q15_t * pSrcB, 02613 q15_t * pDst, 02614 uint32_t blockSize); 02615 02616 /** 02617 * @brief Q31 vector subtraction. 02618 * @param[in] *pSrcA points to the first input vector 02619 * @param[in] *pSrcB points to the second input vector 02620 * @param[out] *pDst points to the output vector 02621 * @param[in] blockSize number of samples in each vector 02622 * @return none. 02623 */ 02624 02625 void arm_sub_q31( 02626 q31_t * pSrcA, 02627 q31_t * pSrcB, 02628 q31_t * pDst, 02629 uint32_t blockSize); 02630 02631 /** 02632 * @brief Multiplies a floating-point vector by a scalar. 02633 * @param[in] *pSrc points to the input vector 02634 * @param[in] scale scale factor to be applied 02635 * @param[out] *pDst points to the output vector 02636 * @param[in] blockSize number of samples in the vector 02637 * @return none. 02638 */ 02639 02640 void arm_scale_f32( 02641 float32_t * pSrc, 02642 float32_t scale, 02643 float32_t * pDst, 02644 uint32_t blockSize); 02645 02646 /** 02647 * @brief Multiplies a Q7 vector by a scalar. 02648 * @param[in] *pSrc points to the input vector 02649 * @param[in] scaleFract fractional portion of the scale value 02650 * @param[in] shift number of bits to shift the result by 02651 * @param[out] *pDst points to the output vector 02652 * @param[in] blockSize number of samples in the vector 02653 * @return none. 02654 */ 02655 02656 void arm_scale_q7( 02657 q7_t * pSrc, 02658 q7_t scaleFract, 02659 int8_t shift, 02660 q7_t * pDst, 02661 uint32_t blockSize); 02662 02663 /** 02664 * @brief Multiplies a Q15 vector by a scalar. 02665 * @param[in] *pSrc points to the input vector 02666 * @param[in] scaleFract fractional portion of the scale value 02667 * @param[in] shift number of bits to shift the result by 02668 * @param[out] *pDst points to the output vector 02669 * @param[in] blockSize number of samples in the vector 02670 * @return none. 02671 */ 02672 02673 void arm_scale_q15( 02674 q15_t * pSrc, 02675 q15_t scaleFract, 02676 int8_t shift, 02677 q15_t * pDst, 02678 uint32_t blockSize); 02679 02680 /** 02681 * @brief Multiplies a Q31 vector by a scalar. 02682 * @param[in] *pSrc points to the input vector 02683 * @param[in] scaleFract fractional portion of the scale value 02684 * @param[in] shift number of bits to shift the result by 02685 * @param[out] *pDst points to the output vector 02686 * @param[in] blockSize number of samples in the vector 02687 * @return none. 02688 */ 02689 02690 void arm_scale_q31( 02691 q31_t * pSrc, 02692 q31_t scaleFract, 02693 int8_t shift, 02694 q31_t * pDst, 02695 uint32_t blockSize); 02696 02697 /** 02698 * @brief Q7 vector absolute value. 02699 * @param[in] *pSrc points to the input buffer 02700 * @param[out] *pDst points to the output buffer 02701 * @param[in] blockSize number of samples in each vector 02702 * @return none. 02703 */ 02704 02705 void arm_abs_q7( 02706 q7_t * pSrc, 02707 q7_t * pDst, 02708 uint32_t blockSize); 02709 02710 /** 02711 * @brief Floating-point vector absolute value. 02712 * @param[in] *pSrc points to the input buffer 02713 * @param[out] *pDst points to the output buffer 02714 * @param[in] blockSize number of samples in each vector 02715 * @return none. 02716 */ 02717 02718 void arm_abs_f32( 02719 float32_t * pSrc, 02720 float32_t * pDst, 02721 uint32_t blockSize); 02722 02723 /** 02724 * @brief Q15 vector absolute value. 02725 * @param[in] *pSrc points to the input buffer 02726 * @param[out] *pDst points to the output buffer 02727 * @param[in] blockSize number of samples in each vector 02728 * @return none. 02729 */ 02730 02731 void arm_abs_q15( 02732 q15_t * pSrc, 02733 q15_t * pDst, 02734 uint32_t blockSize); 02735 02736 /** 02737 * @brief Q31 vector absolute value. 02738 * @param[in] *pSrc points to the input buffer 02739 * @param[out] *pDst points to the output buffer 02740 * @param[in] blockSize number of samples in each vector 02741 * @return none. 02742 */ 02743 02744 void arm_abs_q31( 02745 q31_t * pSrc, 02746 q31_t * pDst, 02747 uint32_t blockSize); 02748 02749 /** 02750 * @brief Dot product of floating-point vectors. 02751 * @param[in] *pSrcA points to the first input vector 02752 * @param[in] *pSrcB points to the second input vector 02753 * @param[in] blockSize number of samples in each vector 02754 * @param[out] *result output result returned here 02755 * @return none. 02756 */ 02757 02758 void arm_dot_prod_f32( 02759 float32_t * pSrcA, 02760 float32_t * pSrcB, 02761 uint32_t blockSize, 02762 float32_t * result); 02763 02764 /** 02765 * @brief Dot product of Q7 vectors. 02766 * @param[in] *pSrcA points to the first input vector 02767 * @param[in] *pSrcB points to the second input vector 02768 * @param[in] blockSize number of samples in each vector 02769 * @param[out] *result output result returned here 02770 * @return none. 02771 */ 02772 02773 void arm_dot_prod_q7( 02774 q7_t * pSrcA, 02775 q7_t * pSrcB, 02776 uint32_t blockSize, 02777 q31_t * result); 02778 02779 /** 02780 * @brief Dot product of Q15 vectors. 02781 * @param[in] *pSrcA points to the first input vector 02782 * @param[in] *pSrcB points to the second input vector 02783 * @param[in] blockSize number of samples in each vector 02784 * @param[out] *result output result returned here 02785 * @return none. 02786 */ 02787 02788 void arm_dot_prod_q15( 02789 q15_t * pSrcA, 02790 q15_t * pSrcB, 02791 uint32_t blockSize, 02792 q63_t * result); 02793 02794 /** 02795 * @brief Dot product of Q31 vectors. 02796 * @param[in] *pSrcA points to the first input vector 02797 * @param[in] *pSrcB points to the second input vector 02798 * @param[in] blockSize number of samples in each vector 02799 * @param[out] *result output result returned here 02800 * @return none. 02801 */ 02802 02803 void arm_dot_prod_q31( 02804 q31_t * pSrcA, 02805 q31_t * pSrcB, 02806 uint32_t blockSize, 02807 q63_t * result); 02808 02809 /** 02810 * @brief Shifts the elements of a Q7 vector a specified number of bits. 02811 * @param[in] *pSrc points to the input vector 02812 * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. 02813 * @param[out] *pDst points to the output vector 02814 * @param[in] blockSize number of samples in the vector 02815 * @return none. 02816 */ 02817 02818 void arm_shift_q7( 02819 q7_t * pSrc, 02820 int8_t shiftBits, 02821 q7_t * pDst, 02822 uint32_t blockSize); 02823 02824 /** 02825 * @brief Shifts the elements of a Q15 vector a specified number of bits. 02826 * @param[in] *pSrc points to the input vector 02827 * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. 02828 * @param[out] *pDst points to the output vector 02829 * @param[in] blockSize number of samples in the vector 02830 * @return none. 02831 */ 02832 02833 void arm_shift_q15( 02834 q15_t * pSrc, 02835 int8_t shiftBits, 02836 q15_t * pDst, 02837 uint32_t blockSize); 02838 02839 /** 02840 * @brief Shifts the elements of a Q31 vector a specified number of bits. 02841 * @param[in] *pSrc points to the input vector 02842 * @param[in] shiftBits number of bits to shift. A positive value shifts left; a negative value shifts right. 02843 * @param[out] *pDst points to the output vector 02844 * @param[in] blockSize number of samples in the vector 02845 * @return none. 02846 */ 02847 02848 void arm_shift_q31( 02849 q31_t * pSrc, 02850 int8_t shiftBits, 02851 q31_t * pDst, 02852 uint32_t blockSize); 02853 02854 /** 02855 * @brief Adds a constant offset to a floating-point vector. 02856 * @param[in] *pSrc points to the input vector 02857 * @param[in] offset is the offset to be added 02858 * @param[out] *pDst points to the output vector 02859 * @param[in] blockSize number of samples in the vector 02860 * @return none. 02861 */ 02862 02863 void arm_offset_f32( 02864 float32_t * pSrc, 02865 float32_t offset, 02866 float32_t * pDst, 02867 uint32_t blockSize); 02868 02869 /** 02870 * @brief Adds a constant offset to a Q7 vector. 02871 * @param[in] *pSrc points to the input vector 02872 * @param[in] offset is the offset to be added 02873 * @param[out] *pDst points to the output vector 02874 * @param[in] blockSize number of samples in the vector 02875 * @return none. 02876 */ 02877 02878 void arm_offset_q7( 02879 q7_t * pSrc, 02880 q7_t offset, 02881 q7_t * pDst, 02882 uint32_t blockSize); 02883 02884 /** 02885 * @brief Adds a constant offset to a Q15 vector. 02886 * @param[in] *pSrc points to the input vector 02887 * @param[in] offset is the offset to be added 02888 * @param[out] *pDst points to the output vector 02889 * @param[in] blockSize number of samples in the vector 02890 * @return none. 02891 */ 02892 02893 void arm_offset_q15( 02894 q15_t * pSrc, 02895 q15_t offset, 02896 q15_t * pDst, 02897 uint32_t blockSize); 02898 02899 /** 02900 * @brief Adds a constant offset to a Q31 vector. 02901 * @param[in] *pSrc points to the input vector 02902 * @param[in] offset is the offset to be added 02903 * @param[out] *pDst points to the output vector 02904 * @param[in] blockSize number of samples in the vector 02905 * @return none. 02906 */ 02907 02908 void arm_offset_q31( 02909 q31_t * pSrc, 02910 q31_t offset, 02911 q31_t * pDst, 02912 uint32_t blockSize); 02913 02914 /** 02915 * @brief Negates the elements of a floating-point vector. 02916 * @param[in] *pSrc points to the input vector 02917 * @param[out] *pDst points to the output vector 02918 * @param[in] blockSize number of samples in the vector 02919 * @return none. 02920 */ 02921 02922 void arm_negate_f32( 02923 float32_t * pSrc, 02924 float32_t * pDst, 02925 uint32_t blockSize); 02926 02927 /** 02928 * @brief Negates the elements of a Q7 vector. 02929 * @param[in] *pSrc points to the input vector 02930 * @param[out] *pDst points to the output vector 02931 * @param[in] blockSize number of samples in the vector 02932 * @return none. 02933 */ 02934 02935 void arm_negate_q7( 02936 q7_t * pSrc, 02937 q7_t * pDst, 02938 uint32_t blockSize); 02939 02940 /** 02941 * @brief Negates the elements of a Q15 vector. 02942 * @param[in] *pSrc points to the input vector 02943 * @param[out] *pDst points to the output vector 02944 * @param[in] blockSize number of samples in the vector 02945 * @return none. 02946 */ 02947 02948 void arm_negate_q15( 02949 q15_t * pSrc, 02950 q15_t * pDst, 02951 uint32_t blockSize); 02952 02953 /** 02954 * @brief Negates the elements of a Q31 vector. 02955 * @param[in] *pSrc points to the input vector 02956 * @param[out] *pDst points to the output vector 02957 * @param[in] blockSize number of samples in the vector 02958 * @return none. 02959 */ 02960 02961 void arm_negate_q31( 02962 q31_t * pSrc, 02963 q31_t * pDst, 02964 uint32_t blockSize); 02965 /** 02966 * @brief Copies the elements of a floating-point vector. 02967 * @param[in] *pSrc input pointer 02968 * @param[out] *pDst output pointer 02969 * @param[in] blockSize number of samples to process 02970 * @return none. 02971 */ 02972 void arm_copy_f32( 02973 float32_t * pSrc, 02974 float32_t * pDst, 02975 uint32_t blockSize); 02976 02977 /** 02978 * @brief Copies the elements of a Q7 vector. 02979 * @param[in] *pSrc input pointer 02980 * @param[out] *pDst output pointer 02981 * @param[in] blockSize number of samples to process 02982 * @return none. 02983 */ 02984 void arm_copy_q7( 02985 q7_t * pSrc, 02986 q7_t * pDst, 02987 uint32_t blockSize); 02988 02989 /** 02990 * @brief Copies the elements of a Q15 vector. 02991 * @param[in] *pSrc input pointer 02992 * @param[out] *pDst output pointer 02993 * @param[in] blockSize number of samples to process 02994 * @return none. 02995 */ 02996 void arm_copy_q15( 02997 q15_t * pSrc, 02998 q15_t * pDst, 02999 uint32_t blockSize); 03000 03001 /** 03002 * @brief Copies the elements of a Q31 vector. 03003 * @param[in] *pSrc input pointer 03004 * @param[out] *pDst output pointer 03005 * @param[in] blockSize number of samples to process 03006 * @return none. 03007 */ 03008 void arm_copy_q31( 03009 q31_t * pSrc, 03010 q31_t * pDst, 03011 uint32_t blockSize); 03012 /** 03013 * @brief Fills a constant value into a floating-point vector. 03014 * @param[in] value input value to be filled 03015 * @param[out] *pDst output pointer 03016 * @param[in] blockSize number of samples to process 03017 * @return none. 03018 */ 03019 void arm_fill_f32( 03020 float32_t value, 03021 float32_t * pDst, 03022 uint32_t blockSize); 03023 03024 /** 03025 * @brief Fills a constant value into a Q7 vector. 03026 * @param[in] value input value to be filled 03027 * @param[out] *pDst output pointer 03028 * @param[in] blockSize number of samples to process 03029 * @return none. 03030 */ 03031 void arm_fill_q7( 03032 q7_t value, 03033 q7_t * pDst, 03034 uint32_t blockSize); 03035 03036 /** 03037 * @brief Fills a constant value into a Q15 vector. 03038 * @param[in] value input value to be filled 03039 * @param[out] *pDst output pointer 03040 * @param[in] blockSize number of samples to process 03041 * @return none. 03042 */ 03043 void arm_fill_q15( 03044 q15_t value, 03045 q15_t * pDst, 03046 uint32_t blockSize); 03047 03048 /** 03049 * @brief Fills a constant value into a Q31 vector. 03050 * @param[in] value input value to be filled 03051 * @param[out] *pDst output pointer 03052 * @param[in] blockSize number of samples to process 03053 * @return none. 03054 */ 03055 void arm_fill_q31( 03056 q31_t value, 03057 q31_t * pDst, 03058 uint32_t blockSize); 03059 03060 /** 03061 * @brief Convolution of floating-point sequences. 03062 * @param[in] *pSrcA points to the first input sequence. 03063 * @param[in] srcALen length of the first input sequence. 03064 * @param[in] *pSrcB points to the second input sequence. 03065 * @param[in] srcBLen length of the second input sequence. 03066 * @param[out] *pDst points to the location where the output result is written. Length srcALen+srcBLen-1. 03067 * @return none. 03068 */ 03069 03070 void arm_conv_f32( 03071 float32_t * pSrcA, 03072 uint32_t srcALen, 03073 float32_t * pSrcB, 03074 uint32_t srcBLen, 03075 float32_t * pDst); 03076 03077 03078 /** 03079 * @brief Convolution of Q15 sequences. 03080 * @param[in] *pSrcA points to the first input sequence. 03081 * @param[in] srcALen length of the first input sequence. 03082 * @param[in] *pSrcB points to the second input sequence. 03083 * @param[in] srcBLen length of the second input sequence. 03084 * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. 03085 * @param[in] *pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 03086 * @param[in] *pScratch2 points to scratch buffer of size min(srcALen, srcBLen). 03087 * @return none. 03088 */ 03089 03090 03091 void arm_conv_opt_q15( 03092 q15_t * pSrcA, 03093 uint32_t srcALen, 03094 q15_t * pSrcB, 03095 uint32_t srcBLen, 03096 q15_t * pDst, 03097 q15_t * pScratch1, 03098 q15_t * pScratch2); 03099 03100 03101 /** 03102 * @brief Convolution of Q15 sequences. 03103 * @param[in] *pSrcA points to the first input sequence. 03104 * @param[in] srcALen length of the first input sequence. 03105 * @param[in] *pSrcB points to the second input sequence. 03106 * @param[in] srcBLen length of the second input sequence. 03107 * @param[out] *pDst points to the location where the output result is written. Length srcALen+srcBLen-1. 03108 * @return none. 03109 */ 03110 03111 void arm_conv_q15( 03112 q15_t * pSrcA, 03113 uint32_t srcALen, 03114 q15_t * pSrcB, 03115 uint32_t srcBLen, 03116 q15_t * pDst); 03117 03118 /** 03119 * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 03120 * @param[in] *pSrcA points to the first input sequence. 03121 * @param[in] srcALen length of the first input sequence. 03122 * @param[in] *pSrcB points to the second input sequence. 03123 * @param[in] srcBLen length of the second input sequence. 03124 * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. 03125 * @return none. 03126 */ 03127 03128 void arm_conv_fast_q15( 03129 q15_t * pSrcA, 03130 uint32_t srcALen, 03131 q15_t * pSrcB, 03132 uint32_t srcBLen, 03133 q15_t * pDst); 03134 03135 /** 03136 * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 03137 * @param[in] *pSrcA points to the first input sequence. 03138 * @param[in] srcALen length of the first input sequence. 03139 * @param[in] *pSrcB points to the second input sequence. 03140 * @param[in] srcBLen length of the second input sequence. 03141 * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. 03142 * @param[in] *pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 03143 * @param[in] *pScratch2 points to scratch buffer of size min(srcALen, srcBLen). 03144 * @return none. 03145 */ 03146 03147 void arm_conv_fast_opt_q15( 03148 q15_t * pSrcA, 03149 uint32_t srcALen, 03150 q15_t * pSrcB, 03151 uint32_t srcBLen, 03152 q15_t * pDst, 03153 q15_t * pScratch1, 03154 q15_t * pScratch2); 03155 03156 03157 03158 /** 03159 * @brief Convolution of Q31 sequences. 03160 * @param[in] *pSrcA points to the first input sequence. 03161 * @param[in] srcALen length of the first input sequence. 03162 * @param[in] *pSrcB points to the second input sequence. 03163 * @param[in] srcBLen length of the second input sequence. 03164 * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. 03165 * @return none. 03166 */ 03167 03168 void arm_conv_q31( 03169 q31_t * pSrcA, 03170 uint32_t srcALen, 03171 q31_t * pSrcB, 03172 uint32_t srcBLen, 03173 q31_t * pDst); 03174 03175 /** 03176 * @brief Convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 03177 * @param[in] *pSrcA points to the first input sequence. 03178 * @param[in] srcALen length of the first input sequence. 03179 * @param[in] *pSrcB points to the second input sequence. 03180 * @param[in] srcBLen length of the second input sequence. 03181 * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. 03182 * @return none. 03183 */ 03184 03185 void arm_conv_fast_q31( 03186 q31_t * pSrcA, 03187 uint32_t srcALen, 03188 q31_t * pSrcB, 03189 uint32_t srcBLen, 03190 q31_t * pDst); 03191 03192 03193 /** 03194 * @brief Convolution of Q7 sequences. 03195 * @param[in] *pSrcA points to the first input sequence. 03196 * @param[in] srcALen length of the first input sequence. 03197 * @param[in] *pSrcB points to the second input sequence. 03198 * @param[in] srcBLen length of the second input sequence. 03199 * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. 03200 * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 03201 * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). 03202 * @return none. 03203 */ 03204 03205 void arm_conv_opt_q7( 03206 q7_t * pSrcA, 03207 uint32_t srcALen, 03208 q7_t * pSrcB, 03209 uint32_t srcBLen, 03210 q7_t * pDst, 03211 q15_t * pScratch1, 03212 q15_t * pScratch2); 03213 03214 03215 03216 /** 03217 * @brief Convolution of Q7 sequences. 03218 * @param[in] *pSrcA points to the first input sequence. 03219 * @param[in] srcALen length of the first input sequence. 03220 * @param[in] *pSrcB points to the second input sequence. 03221 * @param[in] srcBLen length of the second input sequence. 03222 * @param[out] *pDst points to the block of output data Length srcALen+srcBLen-1. 03223 * @return none. 03224 */ 03225 03226 void arm_conv_q7( 03227 q7_t * pSrcA, 03228 uint32_t srcALen, 03229 q7_t * pSrcB, 03230 uint32_t srcBLen, 03231 q7_t * pDst); 03232 03233 03234 /** 03235 * @brief Partial convolution of floating-point sequences. 03236 * @param[in] *pSrcA points to the first input sequence. 03237 * @param[in] srcALen length of the first input sequence. 03238 * @param[in] *pSrcB points to the second input sequence. 03239 * @param[in] srcBLen length of the second input sequence. 03240 * @param[out] *pDst points to the block of output data 03241 * @param[in] firstIndex is the first output sample to start with. 03242 * @param[in] numPoints is the number of output points to be computed. 03243 * @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]. 03244 */ 03245 03246 arm_status arm_conv_partial_f32( 03247 float32_t * pSrcA, 03248 uint32_t srcALen, 03249 float32_t * pSrcB, 03250 uint32_t srcBLen, 03251 float32_t * pDst, 03252 uint32_t firstIndex, 03253 uint32_t numPoints); 03254 03255 /** 03256 * @brief Partial convolution of Q15 sequences. 03257 * @param[in] *pSrcA points to the first input sequence. 03258 * @param[in] srcALen length of the first input sequence. 03259 * @param[in] *pSrcB points to the second input sequence. 03260 * @param[in] srcBLen length of the second input sequence. 03261 * @param[out] *pDst points to the block of output data 03262 * @param[in] firstIndex is the first output sample to start with. 03263 * @param[in] numPoints is the number of output points to be computed. 03264 * @param[in] * pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 03265 * @param[in] * pScratch2 points to scratch buffer of size min(srcALen, srcBLen). 03266 * @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]. 03267 */ 03268 03269 arm_status arm_conv_partial_opt_q15( 03270 q15_t * pSrcA, 03271 uint32_t srcALen, 03272 q15_t * pSrcB, 03273 uint32_t srcBLen, 03274 q15_t * pDst, 03275 uint32_t firstIndex, 03276 uint32_t numPoints, 03277 q15_t * pScratch1, 03278 q15_t * pScratch2); 03279 03280 03281 /** 03282 * @brief Partial convolution of Q15 sequences. 03283 * @param[in] *pSrcA points to the first input sequence. 03284 * @param[in] srcALen length of the first input sequence. 03285 * @param[in] *pSrcB points to the second input sequence. 03286 * @param[in] srcBLen length of the second input sequence. 03287 * @param[out] *pDst points to the block of output data 03288 * @param[in] firstIndex is the first output sample to start with. 03289 * @param[in] numPoints is the number of output points to be computed. 03290 * @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]. 03291 */ 03292 03293 arm_status arm_conv_partial_q15( 03294 q15_t * pSrcA, 03295 uint32_t srcALen, 03296 q15_t * pSrcB, 03297 uint32_t srcBLen, 03298 q15_t * pDst, 03299 uint32_t firstIndex, 03300 uint32_t numPoints); 03301 03302 /** 03303 * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 03304 * @param[in] *pSrcA points to the first input sequence. 03305 * @param[in] srcALen length of the first input sequence. 03306 * @param[in] *pSrcB points to the second input sequence. 03307 * @param[in] srcBLen length of the second input sequence. 03308 * @param[out] *pDst points to the block of output data 03309 * @param[in] firstIndex is the first output sample to start with. 03310 * @param[in] numPoints is the number of output points to be computed. 03311 * @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]. 03312 */ 03313 03314 arm_status arm_conv_partial_fast_q15( 03315 q15_t * pSrcA, 03316 uint32_t srcALen, 03317 q15_t * pSrcB, 03318 uint32_t srcBLen, 03319 q15_t * pDst, 03320 uint32_t firstIndex, 03321 uint32_t numPoints); 03322 03323 03324 /** 03325 * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4 03326 * @param[in] *pSrcA points to the first input sequence. 03327 * @param[in] srcALen length of the first input sequence. 03328 * @param[in] *pSrcB points to the second input sequence. 03329 * @param[in] srcBLen length of the second input sequence. 03330 * @param[out] *pDst points to the block of output data 03331 * @param[in] firstIndex is the first output sample to start with. 03332 * @param[in] numPoints is the number of output points to be computed. 03333 * @param[in] * pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 03334 * @param[in] * pScratch2 points to scratch buffer of size min(srcALen, srcBLen). 03335 * @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]. 03336 */ 03337 03338 arm_status arm_conv_partial_fast_opt_q15( 03339 q15_t * pSrcA, 03340 uint32_t srcALen, 03341 q15_t * pSrcB, 03342 uint32_t srcBLen, 03343 q15_t * pDst, 03344 uint32_t firstIndex, 03345 uint32_t numPoints, 03346 q15_t * pScratch1, 03347 q15_t * pScratch2); 03348 03349 03350 /** 03351 * @brief Partial convolution of Q31 sequences. 03352 * @param[in] *pSrcA points to the first input sequence. 03353 * @param[in] srcALen length of the first input sequence. 03354 * @param[in] *pSrcB points to the second input sequence. 03355 * @param[in] srcBLen length of the second input sequence. 03356 * @param[out] *pDst points to the block of output data 03357 * @param[in] firstIndex is the first output sample to start with. 03358 * @param[in] numPoints is the number of output points to be computed. 03359 * @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]. 03360 */ 03361 03362 arm_status arm_conv_partial_q31( 03363 q31_t * pSrcA, 03364 uint32_t srcALen, 03365 q31_t * pSrcB, 03366 uint32_t srcBLen, 03367 q31_t * pDst, 03368 uint32_t firstIndex, 03369 uint32_t numPoints); 03370 03371 03372 /** 03373 * @brief Partial convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 03374 * @param[in] *pSrcA points to the first input sequence. 03375 * @param[in] srcALen length of the first input sequence. 03376 * @param[in] *pSrcB points to the second input sequence. 03377 * @param[in] srcBLen length of the second input sequence. 03378 * @param[out] *pDst points to the block of output data 03379 * @param[in] firstIndex is the first output sample to start with. 03380 * @param[in] numPoints is the number of output points to be computed. 03381 * @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]. 03382 */ 03383 03384 arm_status arm_conv_partial_fast_q31( 03385 q31_t * pSrcA, 03386 uint32_t srcALen, 03387 q31_t * pSrcB, 03388 uint32_t srcBLen, 03389 q31_t * pDst, 03390 uint32_t firstIndex, 03391 uint32_t numPoints); 03392 03393 03394 /** 03395 * @brief Partial convolution of Q7 sequences 03396 * @param[in] *pSrcA points to the first input sequence. 03397 * @param[in] srcALen length of the first input sequence. 03398 * @param[in] *pSrcB points to the second input sequence. 03399 * @param[in] srcBLen length of the second input sequence. 03400 * @param[out] *pDst points to the block of output data 03401 * @param[in] firstIndex is the first output sample to start with. 03402 * @param[in] numPoints is the number of output points to be computed. 03403 * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 03404 * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). 03405 * @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]. 03406 */ 03407 03408 arm_status arm_conv_partial_opt_q7( 03409 q7_t * pSrcA, 03410 uint32_t srcALen, 03411 q7_t * pSrcB, 03412 uint32_t srcBLen, 03413 q7_t * pDst, 03414 uint32_t firstIndex, 03415 uint32_t numPoints, 03416 q15_t * pScratch1, 03417 q15_t * pScratch2); 03418 03419 03420 /** 03421 * @brief Partial convolution of Q7 sequences. 03422 * @param[in] *pSrcA points to the first input sequence. 03423 * @param[in] srcALen length of the first input sequence. 03424 * @param[in] *pSrcB points to the second input sequence. 03425 * @param[in] srcBLen length of the second input sequence. 03426 * @param[out] *pDst points to the block of output data 03427 * @param[in] firstIndex is the first output sample to start with. 03428 * @param[in] numPoints is the number of output points to be computed. 03429 * @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]. 03430 */ 03431 03432 arm_status arm_conv_partial_q7( 03433 q7_t * pSrcA, 03434 uint32_t srcALen, 03435 q7_t * pSrcB, 03436 uint32_t srcBLen, 03437 q7_t * pDst, 03438 uint32_t firstIndex, 03439 uint32_t numPoints); 03440 03441 03442 03443 /** 03444 * @brief Instance structure for the Q15 FIR decimator. 03445 */ 03446 03447 typedef struct 03448 { 03449 uint8_t M; /**< decimation factor. */ 03450 uint16_t numTaps; /**< number of coefficients in the filter. */ 03451 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 03452 q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 03453 } arm_fir_decimate_instance_q15; 03454 03455 /** 03456 * @brief Instance structure for the Q31 FIR decimator. 03457 */ 03458 03459 typedef struct 03460 { 03461 uint8_t M; /**< decimation factor. */ 03462 uint16_t numTaps; /**< number of coefficients in the filter. */ 03463 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 03464 q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 03465 03466 } arm_fir_decimate_instance_q31; 03467 03468 /** 03469 * @brief Instance structure for the floating-point FIR decimator. 03470 */ 03471 03472 typedef struct 03473 { 03474 uint8_t M; /**< decimation factor. */ 03475 uint16_t numTaps; /**< number of coefficients in the filter. */ 03476 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 03477 float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 03478 03479 } arm_fir_decimate_instance_f32; 03480 03481 03482 03483 /** 03484 * @brief Processing function for the floating-point FIR decimator. 03485 * @param[in] *S points to an instance of the floating-point FIR decimator structure. 03486 * @param[in] *pSrc points to the block of input data. 03487 * @param[out] *pDst points to the block of output data 03488 * @param[in] blockSize number of input samples to process per call. 03489 * @return none 03490 */ 03491 03492 void arm_fir_decimate_f32( 03493 const arm_fir_decimate_instance_f32 * S, 03494 float32_t * pSrc, 03495 float32_t * pDst, 03496 uint32_t blockSize); 03497 03498 03499 /** 03500 * @brief Initialization function for the floating-point FIR decimator. 03501 * @param[in,out] *S points to an instance of the floating-point FIR decimator structure. 03502 * @param[in] numTaps number of coefficients in the filter. 03503 * @param[in] M decimation factor. 03504 * @param[in] *pCoeffs points to the filter coefficients. 03505 * @param[in] *pState points to the state buffer. 03506 * @param[in] blockSize number of input samples to process per call. 03507 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if 03508 * <code>blockSize</code> is not a multiple of <code>M</code>. 03509 */ 03510 03511 arm_status arm_fir_decimate_init_f32( 03512 arm_fir_decimate_instance_f32 * S, 03513 uint16_t numTaps, 03514 uint8_t M, 03515 float32_t * pCoeffs, 03516 float32_t * pState, 03517 uint32_t blockSize); 03518 03519 /** 03520 * @brief Processing function for the Q15 FIR decimator. 03521 * @param[in] *S points to an instance of the Q15 FIR decimator structure. 03522 * @param[in] *pSrc points to the block of input data. 03523 * @param[out] *pDst points to the block of output data 03524 * @param[in] blockSize number of input samples to process per call. 03525 * @return none 03526 */ 03527 03528 void arm_fir_decimate_q15( 03529 const arm_fir_decimate_instance_q15 * S, 03530 q15_t * pSrc, 03531 q15_t * pDst, 03532 uint32_t blockSize); 03533 03534 /** 03535 * @brief Processing function for the Q15 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4. 03536 * @param[in] *S points to an instance of the Q15 FIR decimator structure. 03537 * @param[in] *pSrc points to the block of input data. 03538 * @param[out] *pDst points to the block of output data 03539 * @param[in] blockSize number of input samples to process per call. 03540 * @return none 03541 */ 03542 03543 void arm_fir_decimate_fast_q15( 03544 const arm_fir_decimate_instance_q15 * S, 03545 q15_t * pSrc, 03546 q15_t * pDst, 03547 uint32_t blockSize); 03548 03549 03550 03551 /** 03552 * @brief Initialization function for the Q15 FIR decimator. 03553 * @param[in,out] *S points to an instance of the Q15 FIR decimator structure. 03554 * @param[in] numTaps number of coefficients in the filter. 03555 * @param[in] M decimation factor. 03556 * @param[in] *pCoeffs points to the filter coefficients. 03557 * @param[in] *pState points to the state buffer. 03558 * @param[in] blockSize number of input samples to process per call. 03559 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if 03560 * <code>blockSize</code> is not a multiple of <code>M</code>. 03561 */ 03562 03563 arm_status arm_fir_decimate_init_q15( 03564 arm_fir_decimate_instance_q15 * S, 03565 uint16_t numTaps, 03566 uint8_t M, 03567 q15_t * pCoeffs, 03568 q15_t * pState, 03569 uint32_t blockSize); 03570 03571 /** 03572 * @brief Processing function for the Q31 FIR decimator. 03573 * @param[in] *S points to an instance of the Q31 FIR decimator structure. 03574 * @param[in] *pSrc points to the block of input data. 03575 * @param[out] *pDst points to the block of output data 03576 * @param[in] blockSize number of input samples to process per call. 03577 * @return none 03578 */ 03579 03580 void arm_fir_decimate_q31( 03581 const arm_fir_decimate_instance_q31 * S, 03582 q31_t * pSrc, 03583 q31_t * pDst, 03584 uint32_t blockSize); 03585 03586 /** 03587 * @brief Processing function for the Q31 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4. 03588 * @param[in] *S points to an instance of the Q31 FIR decimator structure. 03589 * @param[in] *pSrc points to the block of input data. 03590 * @param[out] *pDst points to the block of output data 03591 * @param[in] blockSize number of input samples to process per call. 03592 * @return none 03593 */ 03594 03595 void arm_fir_decimate_fast_q31( 03596 arm_fir_decimate_instance_q31 * S, 03597 q31_t * pSrc, 03598 q31_t * pDst, 03599 uint32_t blockSize); 03600 03601 03602 /** 03603 * @brief Initialization function for the Q31 FIR decimator. 03604 * @param[in,out] *S points to an instance of the Q31 FIR decimator structure. 03605 * @param[in] numTaps number of coefficients in the filter. 03606 * @param[in] M decimation factor. 03607 * @param[in] *pCoeffs points to the filter coefficients. 03608 * @param[in] *pState points to the state buffer. 03609 * @param[in] blockSize number of input samples to process per call. 03610 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if 03611 * <code>blockSize</code> is not a multiple of <code>M</code>. 03612 */ 03613 03614 arm_status arm_fir_decimate_init_q31( 03615 arm_fir_decimate_instance_q31 * S, 03616 uint16_t numTaps, 03617 uint8_t M, 03618 q31_t * pCoeffs, 03619 q31_t * pState, 03620 uint32_t blockSize); 03621 03622 03623 03624 /** 03625 * @brief Instance structure for the Q15 FIR interpolator. 03626 */ 03627 03628 typedef struct 03629 { 03630 uint8_t L; /**< upsample factor. */ 03631 uint16_t phaseLength; /**< length of each polyphase filter component. */ 03632 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ 03633 q15_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */ 03634 } arm_fir_interpolate_instance_q15; 03635 03636 /** 03637 * @brief Instance structure for the Q31 FIR interpolator. 03638 */ 03639 03640 typedef struct 03641 { 03642 uint8_t L; /**< upsample factor. */ 03643 uint16_t phaseLength; /**< length of each polyphase filter component. */ 03644 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ 03645 q31_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */ 03646 } arm_fir_interpolate_instance_q31; 03647 03648 /** 03649 * @brief Instance structure for the floating-point FIR interpolator. 03650 */ 03651 03652 typedef struct 03653 { 03654 uint8_t L; /**< upsample factor. */ 03655 uint16_t phaseLength; /**< length of each polyphase filter component. */ 03656 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */ 03657 float32_t *pState; /**< points to the state variable array. The array is of length phaseLength+numTaps-1. */ 03658 } arm_fir_interpolate_instance_f32; 03659 03660 03661 /** 03662 * @brief Processing function for the Q15 FIR interpolator. 03663 * @param[in] *S points to an instance of the Q15 FIR interpolator structure. 03664 * @param[in] *pSrc points to the block of input data. 03665 * @param[out] *pDst points to the block of output data. 03666 * @param[in] blockSize number of input samples to process per call. 03667 * @return none. 03668 */ 03669 03670 void arm_fir_interpolate_q15( 03671 const arm_fir_interpolate_instance_q15 * S, 03672 q15_t * pSrc, 03673 q15_t * pDst, 03674 uint32_t blockSize); 03675 03676 03677 /** 03678 * @brief Initialization function for the Q15 FIR interpolator. 03679 * @param[in,out] *S points to an instance of the Q15 FIR interpolator structure. 03680 * @param[in] L upsample factor. 03681 * @param[in] numTaps number of filter coefficients in the filter. 03682 * @param[in] *pCoeffs points to the filter coefficient buffer. 03683 * @param[in] *pState points to the state buffer. 03684 * @param[in] blockSize number of input samples to process per call. 03685 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if 03686 * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>. 03687 */ 03688 03689 arm_status arm_fir_interpolate_init_q15( 03690 arm_fir_interpolate_instance_q15 * S, 03691 uint8_t L, 03692 uint16_t numTaps, 03693 q15_t * pCoeffs, 03694 q15_t * pState, 03695 uint32_t blockSize); 03696 03697 /** 03698 * @brief Processing function for the Q31 FIR interpolator. 03699 * @param[in] *S points to an instance of the Q15 FIR interpolator structure. 03700 * @param[in] *pSrc points to the block of input data. 03701 * @param[out] *pDst points to the block of output data. 03702 * @param[in] blockSize number of input samples to process per call. 03703 * @return none. 03704 */ 03705 03706 void arm_fir_interpolate_q31( 03707 const arm_fir_interpolate_instance_q31 * S, 03708 q31_t * pSrc, 03709 q31_t * pDst, 03710 uint32_t blockSize); 03711 03712 /** 03713 * @brief Initialization function for the Q31 FIR interpolator. 03714 * @param[in,out] *S points to an instance of the Q31 FIR interpolator structure. 03715 * @param[in] L upsample factor. 03716 * @param[in] numTaps number of filter coefficients in the filter. 03717 * @param[in] *pCoeffs points to the filter coefficient buffer. 03718 * @param[in] *pState points to the state buffer. 03719 * @param[in] blockSize number of input samples to process per call. 03720 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if 03721 * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>. 03722 */ 03723 03724 arm_status arm_fir_interpolate_init_q31( 03725 arm_fir_interpolate_instance_q31 * S, 03726 uint8_t L, 03727 uint16_t numTaps, 03728 q31_t * pCoeffs, 03729 q31_t * pState, 03730 uint32_t blockSize); 03731 03732 03733 /** 03734 * @brief Processing function for the floating-point FIR interpolator. 03735 * @param[in] *S points to an instance of the floating-point FIR interpolator structure. 03736 * @param[in] *pSrc points to the block of input data. 03737 * @param[out] *pDst points to the block of output data. 03738 * @param[in] blockSize number of input samples to process per call. 03739 * @return none. 03740 */ 03741 03742 void arm_fir_interpolate_f32( 03743 const arm_fir_interpolate_instance_f32 * S, 03744 float32_t * pSrc, 03745 float32_t * pDst, 03746 uint32_t blockSize); 03747 03748 /** 03749 * @brief Initialization function for the floating-point FIR interpolator. 03750 * @param[in,out] *S points to an instance of the floating-point FIR interpolator structure. 03751 * @param[in] L upsample factor. 03752 * @param[in] numTaps number of filter coefficients in the filter. 03753 * @param[in] *pCoeffs points to the filter coefficient buffer. 03754 * @param[in] *pState points to the state buffer. 03755 * @param[in] blockSize number of input samples to process per call. 03756 * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if 03757 * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>. 03758 */ 03759 03760 arm_status arm_fir_interpolate_init_f32( 03761 arm_fir_interpolate_instance_f32 * S, 03762 uint8_t L, 03763 uint16_t numTaps, 03764 float32_t * pCoeffs, 03765 float32_t * pState, 03766 uint32_t blockSize); 03767 03768 /** 03769 * @brief Instance structure for the high precision Q31 Biquad cascade filter. 03770 */ 03771 03772 typedef struct 03773 { 03774 uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ 03775 q63_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */ 03776 q31_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ 03777 uint8_t postShift; /**< additional shift, in bits, applied to each output sample. */ 03778 03779 } arm_biquad_cas_df1_32x64_ins_q31; 03780 03781 03782 /** 03783 * @param[in] *S points to an instance of the high precision Q31 Biquad cascade filter structure. 03784 * @param[in] *pSrc points to the block of input data. 03785 * @param[out] *pDst points to the block of output data 03786 * @param[in] blockSize number of samples to process. 03787 * @return none. 03788 */ 03789 03790 void arm_biquad_cas_df1_32x64_q31( 03791 const arm_biquad_cas_df1_32x64_ins_q31 * S, 03792 q31_t * pSrc, 03793 q31_t * pDst, 03794 uint32_t blockSize); 03795 03796 03797 /** 03798 * @param[in,out] *S points to an instance of the high precision Q31 Biquad cascade filter structure. 03799 * @param[in] numStages number of 2nd order stages in the filter. 03800 * @param[in] *pCoeffs points to the filter coefficients. 03801 * @param[in] *pState points to the state buffer. 03802 * @param[in] postShift shift to be applied to the output. Varies according to the coefficients format 03803 * @return none 03804 */ 03805 03806 void arm_biquad_cas_df1_32x64_init_q31( 03807 arm_biquad_cas_df1_32x64_ins_q31 * S, 03808 uint8_t numStages, 03809 q31_t * pCoeffs, 03810 q63_t * pState, 03811 uint8_t postShift); 03812 03813 03814 03815 /** 03816 * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter. 03817 */ 03818 03819 typedef struct 03820 { 03821 uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ 03822 float32_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */ 03823 float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ 03824 } arm_biquad_cascade_df2T_instance_f32; 03825 03826 03827 03828 /** 03829 * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter. 03830 */ 03831 03832 typedef struct 03833 { 03834 uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ 03835 float32_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */ 03836 float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ 03837 } arm_biquad_cascade_stereo_df2T_instance_f32; 03838 03839 03840 03841 /** 03842 * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter. 03843 */ 03844 03845 typedef struct 03846 { 03847 uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */ 03848 float64_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */ 03849 float64_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */ 03850 } arm_biquad_cascade_df2T_instance_f64; 03851 03852 03853 /** 03854 * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 03855 * @param[in] *S points to an instance of the filter data structure. 03856 * @param[in] *pSrc points to the block of input data. 03857 * @param[out] *pDst points to the block of output data 03858 * @param[in] blockSize number of samples to process. 03859 * @return none. 03860 */ 03861 03862 void arm_biquad_cascade_df2T_f32( 03863 const arm_biquad_cascade_df2T_instance_f32 * S, 03864 float32_t * pSrc, 03865 float32_t * pDst, 03866 uint32_t blockSize); 03867 03868 03869 /** 03870 * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 2 channels 03871 * @param[in] *S points to an instance of the filter data structure. 03872 * @param[in] *pSrc points to the block of input data. 03873 * @param[out] *pDst points to the block of output data 03874 * @param[in] blockSize number of samples to process. 03875 * @return none. 03876 */ 03877 03878 void arm_biquad_cascade_stereo_df2T_f32( 03879 const arm_biquad_cascade_stereo_df2T_instance_f32 * S, 03880 float32_t * pSrc, 03881 float32_t * pDst, 03882 uint32_t blockSize); 03883 03884 /** 03885 * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 03886 * @param[in] *S points to an instance of the filter data structure. 03887 * @param[in] *pSrc points to the block of input data. 03888 * @param[out] *pDst points to the block of output data 03889 * @param[in] blockSize number of samples to process. 03890 * @return none. 03891 */ 03892 03893 void arm_biquad_cascade_df2T_f64( 03894 const arm_biquad_cascade_df2T_instance_f64 * S, 03895 float64_t * pSrc, 03896 float64_t * pDst, 03897 uint32_t blockSize); 03898 03899 03900 /** 03901 * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter. 03902 * @param[in,out] *S points to an instance of the filter data structure. 03903 * @param[in] numStages number of 2nd order stages in the filter. 03904 * @param[in] *pCoeffs points to the filter coefficients. 03905 * @param[in] *pState points to the state buffer. 03906 * @return none 03907 */ 03908 03909 void arm_biquad_cascade_df2T_init_f32( 03910 arm_biquad_cascade_df2T_instance_f32 * S, 03911 uint8_t numStages, 03912 float32_t * pCoeffs, 03913 float32_t * pState); 03914 03915 03916 /** 03917 * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter. 03918 * @param[in,out] *S points to an instance of the filter data structure. 03919 * @param[in] numStages number of 2nd order stages in the filter. 03920 * @param[in] *pCoeffs points to the filter coefficients. 03921 * @param[in] *pState points to the state buffer. 03922 * @return none 03923 */ 03924 03925 void arm_biquad_cascade_stereo_df2T_init_f32( 03926 arm_biquad_cascade_stereo_df2T_instance_f32 * S, 03927 uint8_t numStages, 03928 float32_t * pCoeffs, 03929 float32_t * pState); 03930 03931 03932 /** 03933 * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter. 03934 * @param[in,out] *S points to an instance of the filter data structure. 03935 * @param[in] numStages number of 2nd order stages in the filter. 03936 * @param[in] *pCoeffs points to the filter coefficients. 03937 * @param[in] *pState points to the state buffer. 03938 * @return none 03939 */ 03940 03941 void arm_biquad_cascade_df2T_init_f64( 03942 arm_biquad_cascade_df2T_instance_f64 * S, 03943 uint8_t numStages, 03944 float64_t * pCoeffs, 03945 float64_t * pState); 03946 03947 03948 03949 /** 03950 * @brief Instance structure for the Q15 FIR lattice filter. 03951 */ 03952 03953 typedef struct 03954 { 03955 uint16_t numStages; /**< number of filter stages. */ 03956 q15_t *pState; /**< points to the state variable array. The array is of length numStages. */ 03957 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ 03958 } arm_fir_lattice_instance_q15; 03959 03960 /** 03961 * @brief Instance structure for the Q31 FIR lattice filter. 03962 */ 03963 03964 typedef struct 03965 { 03966 uint16_t numStages; /**< number of filter stages. */ 03967 q31_t *pState; /**< points to the state variable array. The array is of length numStages. */ 03968 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ 03969 } arm_fir_lattice_instance_q31; 03970 03971 /** 03972 * @brief Instance structure for the floating-point FIR lattice filter. 03973 */ 03974 03975 typedef struct 03976 { 03977 uint16_t numStages; /**< number of filter stages. */ 03978 float32_t *pState; /**< points to the state variable array. The array is of length numStages. */ 03979 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */ 03980 } arm_fir_lattice_instance_f32; 03981 03982 /** 03983 * @brief Initialization function for the Q15 FIR lattice filter. 03984 * @param[in] *S points to an instance of the Q15 FIR lattice structure. 03985 * @param[in] numStages number of filter stages. 03986 * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. 03987 * @param[in] *pState points to the state buffer. The array is of length numStages. 03988 * @return none. 03989 */ 03990 03991 void arm_fir_lattice_init_q15( 03992 arm_fir_lattice_instance_q15 * S, 03993 uint16_t numStages, 03994 q15_t * pCoeffs, 03995 q15_t * pState); 03996 03997 03998 /** 03999 * @brief Processing function for the Q15 FIR lattice filter. 04000 * @param[in] *S points to an instance of the Q15 FIR lattice structure. 04001 * @param[in] *pSrc points to the block of input data. 04002 * @param[out] *pDst points to the block of output data. 04003 * @param[in] blockSize number of samples to process. 04004 * @return none. 04005 */ 04006 void arm_fir_lattice_q15( 04007 const arm_fir_lattice_instance_q15 * S, 04008 q15_t * pSrc, 04009 q15_t * pDst, 04010 uint32_t blockSize); 04011 04012 /** 04013 * @brief Initialization function for the Q31 FIR lattice filter. 04014 * @param[in] *S points to an instance of the Q31 FIR lattice structure. 04015 * @param[in] numStages number of filter stages. 04016 * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. 04017 * @param[in] *pState points to the state buffer. The array is of length numStages. 04018 * @return none. 04019 */ 04020 04021 void arm_fir_lattice_init_q31( 04022 arm_fir_lattice_instance_q31 * S, 04023 uint16_t numStages, 04024 q31_t * pCoeffs, 04025 q31_t * pState); 04026 04027 04028 /** 04029 * @brief Processing function for the Q31 FIR lattice filter. 04030 * @param[in] *S points to an instance of the Q31 FIR lattice structure. 04031 * @param[in] *pSrc points to the block of input data. 04032 * @param[out] *pDst points to the block of output data 04033 * @param[in] blockSize number of samples to process. 04034 * @return none. 04035 */ 04036 04037 void arm_fir_lattice_q31( 04038 const arm_fir_lattice_instance_q31 * S, 04039 q31_t * pSrc, 04040 q31_t * pDst, 04041 uint32_t blockSize); 04042 04043 /** 04044 * @brief Initialization function for the floating-point FIR lattice filter. 04045 * @param[in] *S points to an instance of the floating-point FIR lattice structure. 04046 * @param[in] numStages number of filter stages. 04047 * @param[in] *pCoeffs points to the coefficient buffer. The array is of length numStages. 04048 * @param[in] *pState points to the state buffer. The array is of length numStages. 04049 * @return none. 04050 */ 04051 04052 void arm_fir_lattice_init_f32( 04053 arm_fir_lattice_instance_f32 * S, 04054 uint16_t numStages, 04055 float32_t * pCoeffs, 04056 float32_t * pState); 04057 04058 /** 04059 * @brief Processing function for the floating-point FIR lattice filter. 04060 * @param[in] *S points to an instance of the floating-point FIR lattice structure. 04061 * @param[in] *pSrc points to the block of input data. 04062 * @param[out] *pDst points to the block of output data 04063 * @param[in] blockSize number of samples to process. 04064 * @return none. 04065 */ 04066 04067 void arm_fir_lattice_f32( 04068 const arm_fir_lattice_instance_f32 * S, 04069 float32_t * pSrc, 04070 float32_t * pDst, 04071 uint32_t blockSize); 04072 04073 /** 04074 * @brief Instance structure for the Q15 IIR lattice filter. 04075 */ 04076 typedef struct 04077 { 04078 uint16_t numStages; /**< number of stages in the filter. */ 04079 q15_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ 04080 q15_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ 04081 q15_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ 04082 } arm_iir_lattice_instance_q15; 04083 04084 /** 04085 * @brief Instance structure for the Q31 IIR lattice filter. 04086 */ 04087 typedef struct 04088 { 04089 uint16_t numStages; /**< number of stages in the filter. */ 04090 q31_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ 04091 q31_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ 04092 q31_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ 04093 } arm_iir_lattice_instance_q31; 04094 04095 /** 04096 * @brief Instance structure for the floating-point IIR lattice filter. 04097 */ 04098 typedef struct 04099 { 04100 uint16_t numStages; /**< number of stages in the filter. */ 04101 float32_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */ 04102 float32_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */ 04103 float32_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */ 04104 } arm_iir_lattice_instance_f32; 04105 04106 /** 04107 * @brief Processing function for the floating-point IIR lattice filter. 04108 * @param[in] *S points to an instance of the floating-point IIR lattice structure. 04109 * @param[in] *pSrc points to the block of input data. 04110 * @param[out] *pDst points to the block of output data. 04111 * @param[in] blockSize number of samples to process. 04112 * @return none. 04113 */ 04114 04115 void arm_iir_lattice_f32( 04116 const arm_iir_lattice_instance_f32 * S, 04117 float32_t * pSrc, 04118 float32_t * pDst, 04119 uint32_t blockSize); 04120 04121 /** 04122 * @brief Initialization function for the floating-point IIR lattice filter. 04123 * @param[in] *S points to an instance of the floating-point IIR lattice structure. 04124 * @param[in] numStages number of stages in the filter. 04125 * @param[in] *pkCoeffs points to the reflection coefficient buffer. The array is of length numStages. 04126 * @param[in] *pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1. 04127 * @param[in] *pState points to the state buffer. The array is of length numStages+blockSize-1. 04128 * @param[in] blockSize number of samples to process. 04129 * @return none. 04130 */ 04131 04132 void arm_iir_lattice_init_f32( 04133 arm_iir_lattice_instance_f32 * S, 04134 uint16_t numStages, 04135 float32_t * pkCoeffs, 04136 float32_t * pvCoeffs, 04137 float32_t * pState, 04138 uint32_t blockSize); 04139 04140 04141 /** 04142 * @brief Processing function for the Q31 IIR lattice filter. 04143 * @param[in] *S points to an instance of the Q31 IIR lattice structure. 04144 * @param[in] *pSrc points to the block of input data. 04145 * @param[out] *pDst points to the block of output data. 04146 * @param[in] blockSize number of samples to process. 04147 * @return none. 04148 */ 04149 04150 void arm_iir_lattice_q31( 04151 const arm_iir_lattice_instance_q31 * S, 04152 q31_t * pSrc, 04153 q31_t * pDst, 04154 uint32_t blockSize); 04155 04156 04157 /** 04158 * @brief Initialization function for the Q31 IIR lattice filter. 04159 * @param[in] *S points to an instance of the Q31 IIR lattice structure. 04160 * @param[in] numStages number of stages in the filter. 04161 * @param[in] *pkCoeffs points to the reflection coefficient buffer. The array is of length numStages. 04162 * @param[in] *pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1. 04163 * @param[in] *pState points to the state buffer. The array is of length numStages+blockSize. 04164 * @param[in] blockSize number of samples to process. 04165 * @return none. 04166 */ 04167 04168 void arm_iir_lattice_init_q31( 04169 arm_iir_lattice_instance_q31 * S, 04170 uint16_t numStages, 04171 q31_t * pkCoeffs, 04172 q31_t * pvCoeffs, 04173 q31_t * pState, 04174 uint32_t blockSize); 04175 04176 04177 /** 04178 * @brief Processing function for the Q15 IIR lattice filter. 04179 * @param[in] *S points to an instance of the Q15 IIR lattice structure. 04180 * @param[in] *pSrc points to the block of input data. 04181 * @param[out] *pDst points to the block of output data. 04182 * @param[in] blockSize number of samples to process. 04183 * @return none. 04184 */ 04185 04186 void arm_iir_lattice_q15( 04187 const arm_iir_lattice_instance_q15 * S, 04188 q15_t * pSrc, 04189 q15_t * pDst, 04190 uint32_t blockSize); 04191 04192 04193 /** 04194 * @brief Initialization function for the Q15 IIR lattice filter. 04195 * @param[in] *S points to an instance of the fixed-point Q15 IIR lattice structure. 04196 * @param[in] numStages number of stages in the filter. 04197 * @param[in] *pkCoeffs points to reflection coefficient buffer. The array is of length numStages. 04198 * @param[in] *pvCoeffs points to ladder coefficient buffer. The array is of length numStages+1. 04199 * @param[in] *pState points to state buffer. The array is of length numStages+blockSize. 04200 * @param[in] blockSize number of samples to process per call. 04201 * @return none. 04202 */ 04203 04204 void arm_iir_lattice_init_q15( 04205 arm_iir_lattice_instance_q15 * S, 04206 uint16_t numStages, 04207 q15_t * pkCoeffs, 04208 q15_t * pvCoeffs, 04209 q15_t * pState, 04210 uint32_t blockSize); 04211 04212 /** 04213 * @brief Instance structure for the floating-point LMS filter. 04214 */ 04215 04216 typedef struct 04217 { 04218 uint16_t numTaps; /**< number of coefficients in the filter. */ 04219 float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 04220 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ 04221 float32_t mu; /**< step size that controls filter coefficient updates. */ 04222 } arm_lms_instance_f32; 04223 04224 /** 04225 * @brief Processing function for floating-point LMS filter. 04226 * @param[in] *S points to an instance of the floating-point LMS filter structure. 04227 * @param[in] *pSrc points to the block of input data. 04228 * @param[in] *pRef points to the block of reference data. 04229 * @param[out] *pOut points to the block of output data. 04230 * @param[out] *pErr points to the block of error data. 04231 * @param[in] blockSize number of samples to process. 04232 * @return none. 04233 */ 04234 04235 void arm_lms_f32( 04236 const arm_lms_instance_f32 * S, 04237 float32_t * pSrc, 04238 float32_t * pRef, 04239 float32_t * pOut, 04240 float32_t * pErr, 04241 uint32_t blockSize); 04242 04243 /** 04244 * @brief Initialization function for floating-point LMS filter. 04245 * @param[in] *S points to an instance of the floating-point LMS filter structure. 04246 * @param[in] numTaps number of filter coefficients. 04247 * @param[in] *pCoeffs points to the coefficient buffer. 04248 * @param[in] *pState points to state buffer. 04249 * @param[in] mu step size that controls filter coefficient updates. 04250 * @param[in] blockSize number of samples to process. 04251 * @return none. 04252 */ 04253 04254 void arm_lms_init_f32( 04255 arm_lms_instance_f32 * S, 04256 uint16_t numTaps, 04257 float32_t * pCoeffs, 04258 float32_t * pState, 04259 float32_t mu, 04260 uint32_t blockSize); 04261 04262 /** 04263 * @brief Instance structure for the Q15 LMS filter. 04264 */ 04265 04266 typedef struct 04267 { 04268 uint16_t numTaps; /**< number of coefficients in the filter. */ 04269 q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 04270 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ 04271 q15_t mu; /**< step size that controls filter coefficient updates. */ 04272 uint32_t postShift; /**< bit shift applied to coefficients. */ 04273 } arm_lms_instance_q15; 04274 04275 04276 /** 04277 * @brief Initialization function for the Q15 LMS filter. 04278 * @param[in] *S points to an instance of the Q15 LMS filter structure. 04279 * @param[in] numTaps number of filter coefficients. 04280 * @param[in] *pCoeffs points to the coefficient buffer. 04281 * @param[in] *pState points to the state buffer. 04282 * @param[in] mu step size that controls filter coefficient updates. 04283 * @param[in] blockSize number of samples to process. 04284 * @param[in] postShift bit shift applied to coefficients. 04285 * @return none. 04286 */ 04287 04288 void arm_lms_init_q15( 04289 arm_lms_instance_q15 * S, 04290 uint16_t numTaps, 04291 q15_t * pCoeffs, 04292 q15_t * pState, 04293 q15_t mu, 04294 uint32_t blockSize, 04295 uint32_t postShift); 04296 04297 /** 04298 * @brief Processing function for Q15 LMS filter. 04299 * @param[in] *S points to an instance of the Q15 LMS filter structure. 04300 * @param[in] *pSrc points to the block of input data. 04301 * @param[in] *pRef points to the block of reference data. 04302 * @param[out] *pOut points to the block of output data. 04303 * @param[out] *pErr points to the block of error data. 04304 * @param[in] blockSize number of samples to process. 04305 * @return none. 04306 */ 04307 04308 void arm_lms_q15( 04309 const arm_lms_instance_q15 * S, 04310 q15_t * pSrc, 04311 q15_t * pRef, 04312 q15_t * pOut, 04313 q15_t * pErr, 04314 uint32_t blockSize); 04315 04316 04317 /** 04318 * @brief Instance structure for the Q31 LMS filter. 04319 */ 04320 04321 typedef struct 04322 { 04323 uint16_t numTaps; /**< number of coefficients in the filter. */ 04324 q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 04325 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ 04326 q31_t mu; /**< step size that controls filter coefficient updates. */ 04327 uint32_t postShift; /**< bit shift applied to coefficients. */ 04328 04329 } arm_lms_instance_q31; 04330 04331 /** 04332 * @brief Processing function for Q31 LMS filter. 04333 * @param[in] *S points to an instance of the Q15 LMS filter structure. 04334 * @param[in] *pSrc points to the block of input data. 04335 * @param[in] *pRef points to the block of reference data. 04336 * @param[out] *pOut points to the block of output data. 04337 * @param[out] *pErr points to the block of error data. 04338 * @param[in] blockSize number of samples to process. 04339 * @return none. 04340 */ 04341 04342 void arm_lms_q31( 04343 const arm_lms_instance_q31 * S, 04344 q31_t * pSrc, 04345 q31_t * pRef, 04346 q31_t * pOut, 04347 q31_t * pErr, 04348 uint32_t blockSize); 04349 04350 /** 04351 * @brief Initialization function for Q31 LMS filter. 04352 * @param[in] *S points to an instance of the Q31 LMS filter structure. 04353 * @param[in] numTaps number of filter coefficients. 04354 * @param[in] *pCoeffs points to coefficient buffer. 04355 * @param[in] *pState points to state buffer. 04356 * @param[in] mu step size that controls filter coefficient updates. 04357 * @param[in] blockSize number of samples to process. 04358 * @param[in] postShift bit shift applied to coefficients. 04359 * @return none. 04360 */ 04361 04362 void arm_lms_init_q31( 04363 arm_lms_instance_q31 * S, 04364 uint16_t numTaps, 04365 q31_t * pCoeffs, 04366 q31_t * pState, 04367 q31_t mu, 04368 uint32_t blockSize, 04369 uint32_t postShift); 04370 04371 /** 04372 * @brief Instance structure for the floating-point normalized LMS filter. 04373 */ 04374 04375 typedef struct 04376 { 04377 uint16_t numTaps; /**< number of coefficients in the filter. */ 04378 float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 04379 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ 04380 float32_t mu; /**< step size that control filter coefficient updates. */ 04381 float32_t energy; /**< saves previous frame energy. */ 04382 float32_t x0; /**< saves previous input sample. */ 04383 } arm_lms_norm_instance_f32; 04384 04385 /** 04386 * @brief Processing function for floating-point normalized LMS filter. 04387 * @param[in] *S points to an instance of the floating-point normalized LMS filter structure. 04388 * @param[in] *pSrc points to the block of input data. 04389 * @param[in] *pRef points to the block of reference data. 04390 * @param[out] *pOut points to the block of output data. 04391 * @param[out] *pErr points to the block of error data. 04392 * @param[in] blockSize number of samples to process. 04393 * @return none. 04394 */ 04395 04396 void arm_lms_norm_f32( 04397 arm_lms_norm_instance_f32 * S, 04398 float32_t * pSrc, 04399 float32_t * pRef, 04400 float32_t * pOut, 04401 float32_t * pErr, 04402 uint32_t blockSize); 04403 04404 /** 04405 * @brief Initialization function for floating-point normalized LMS filter. 04406 * @param[in] *S points to an instance of the floating-point LMS filter structure. 04407 * @param[in] numTaps number of filter coefficients. 04408 * @param[in] *pCoeffs points to coefficient buffer. 04409 * @param[in] *pState points to state buffer. 04410 * @param[in] mu step size that controls filter coefficient updates. 04411 * @param[in] blockSize number of samples to process. 04412 * @return none. 04413 */ 04414 04415 void arm_lms_norm_init_f32( 04416 arm_lms_norm_instance_f32 * S, 04417 uint16_t numTaps, 04418 float32_t * pCoeffs, 04419 float32_t * pState, 04420 float32_t mu, 04421 uint32_t blockSize); 04422 04423 04424 /** 04425 * @brief Instance structure for the Q31 normalized LMS filter. 04426 */ 04427 typedef struct 04428 { 04429 uint16_t numTaps; /**< number of coefficients in the filter. */ 04430 q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 04431 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ 04432 q31_t mu; /**< step size that controls filter coefficient updates. */ 04433 uint8_t postShift; /**< bit shift applied to coefficients. */ 04434 q31_t *recipTable; /**< points to the reciprocal initial value table. */ 04435 q31_t energy; /**< saves previous frame energy. */ 04436 q31_t x0; /**< saves previous input sample. */ 04437 } arm_lms_norm_instance_q31; 04438 04439 /** 04440 * @brief Processing function for Q31 normalized LMS filter. 04441 * @param[in] *S points to an instance of the Q31 normalized LMS filter structure. 04442 * @param[in] *pSrc points to the block of input data. 04443 * @param[in] *pRef points to the block of reference data. 04444 * @param[out] *pOut points to the block of output data. 04445 * @param[out] *pErr points to the block of error data. 04446 * @param[in] blockSize number of samples to process. 04447 * @return none. 04448 */ 04449 04450 void arm_lms_norm_q31( 04451 arm_lms_norm_instance_q31 * S, 04452 q31_t * pSrc, 04453 q31_t * pRef, 04454 q31_t * pOut, 04455 q31_t * pErr, 04456 uint32_t blockSize); 04457 04458 /** 04459 * @brief Initialization function for Q31 normalized LMS filter. 04460 * @param[in] *S points to an instance of the Q31 normalized LMS filter structure. 04461 * @param[in] numTaps number of filter coefficients. 04462 * @param[in] *pCoeffs points to coefficient buffer. 04463 * @param[in] *pState points to state buffer. 04464 * @param[in] mu step size that controls filter coefficient updates. 04465 * @param[in] blockSize number of samples to process. 04466 * @param[in] postShift bit shift applied to coefficients. 04467 * @return none. 04468 */ 04469 04470 void arm_lms_norm_init_q31( 04471 arm_lms_norm_instance_q31 * S, 04472 uint16_t numTaps, 04473 q31_t * pCoeffs, 04474 q31_t * pState, 04475 q31_t mu, 04476 uint32_t blockSize, 04477 uint8_t postShift); 04478 04479 /** 04480 * @brief Instance structure for the Q15 normalized LMS filter. 04481 */ 04482 04483 typedef struct 04484 { 04485 uint16_t numTaps; /**< Number of coefficients in the filter. */ 04486 q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */ 04487 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */ 04488 q15_t mu; /**< step size that controls filter coefficient updates. */ 04489 uint8_t postShift; /**< bit shift applied to coefficients. */ 04490 q15_t *recipTable; /**< Points to the reciprocal initial value table. */ 04491 q15_t energy; /**< saves previous frame energy. */ 04492 q15_t x0; /**< saves previous input sample. */ 04493 } arm_lms_norm_instance_q15; 04494 04495 /** 04496 * @brief Processing function for Q15 normalized LMS filter. 04497 * @param[in] *S points to an instance of the Q15 normalized LMS filter structure. 04498 * @param[in] *pSrc points to the block of input data. 04499 * @param[in] *pRef points to the block of reference data. 04500 * @param[out] *pOut points to the block of output data. 04501 * @param[out] *pErr points to the block of error data. 04502 * @param[in] blockSize number of samples to process. 04503 * @return none. 04504 */ 04505 04506 void arm_lms_norm_q15( 04507 arm_lms_norm_instance_q15 * S, 04508 q15_t * pSrc, 04509 q15_t * pRef, 04510 q15_t * pOut, 04511 q15_t * pErr, 04512 uint32_t blockSize); 04513 04514 04515 /** 04516 * @brief Initialization function for Q15 normalized LMS filter. 04517 * @param[in] *S points to an instance of the Q15 normalized LMS filter structure. 04518 * @param[in] numTaps number of filter coefficients. 04519 * @param[in] *pCoeffs points to coefficient buffer. 04520 * @param[in] *pState points to state buffer. 04521 * @param[in] mu step size that controls filter coefficient updates. 04522 * @param[in] blockSize number of samples to process. 04523 * @param[in] postShift bit shift applied to coefficients. 04524 * @return none. 04525 */ 04526 04527 void arm_lms_norm_init_q15( 04528 arm_lms_norm_instance_q15 * S, 04529 uint16_t numTaps, 04530 q15_t * pCoeffs, 04531 q15_t * pState, 04532 q15_t mu, 04533 uint32_t blockSize, 04534 uint8_t postShift); 04535 04536 /** 04537 * @brief Correlation of floating-point sequences. 04538 * @param[in] *pSrcA points to the first input sequence. 04539 * @param[in] srcALen length of the first input sequence. 04540 * @param[in] *pSrcB points to the second input sequence. 04541 * @param[in] srcBLen length of the second input sequence. 04542 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04543 * @return none. 04544 */ 04545 04546 void arm_correlate_f32( 04547 float32_t * pSrcA, 04548 uint32_t srcALen, 04549 float32_t * pSrcB, 04550 uint32_t srcBLen, 04551 float32_t * pDst); 04552 04553 04554 /** 04555 * @brief Correlation of Q15 sequences 04556 * @param[in] *pSrcA points to the first input sequence. 04557 * @param[in] srcALen length of the first input sequence. 04558 * @param[in] *pSrcB points to the second input sequence. 04559 * @param[in] srcBLen length of the second input sequence. 04560 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04561 * @param[in] *pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 04562 * @return none. 04563 */ 04564 void arm_correlate_opt_q15( 04565 q15_t * pSrcA, 04566 uint32_t srcALen, 04567 q15_t * pSrcB, 04568 uint32_t srcBLen, 04569 q15_t * pDst, 04570 q15_t * pScratch); 04571 04572 04573 /** 04574 * @brief Correlation of Q15 sequences. 04575 * @param[in] *pSrcA points to the first input sequence. 04576 * @param[in] srcALen length of the first input sequence. 04577 * @param[in] *pSrcB points to the second input sequence. 04578 * @param[in] srcBLen length of the second input sequence. 04579 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04580 * @return none. 04581 */ 04582 04583 void arm_correlate_q15( 04584 q15_t * pSrcA, 04585 uint32_t srcALen, 04586 q15_t * pSrcB, 04587 uint32_t srcBLen, 04588 q15_t * pDst); 04589 04590 /** 04591 * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4. 04592 * @param[in] *pSrcA points to the first input sequence. 04593 * @param[in] srcALen length of the first input sequence. 04594 * @param[in] *pSrcB points to the second input sequence. 04595 * @param[in] srcBLen length of the second input sequence. 04596 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04597 * @return none. 04598 */ 04599 04600 void arm_correlate_fast_q15( 04601 q15_t * pSrcA, 04602 uint32_t srcALen, 04603 q15_t * pSrcB, 04604 uint32_t srcBLen, 04605 q15_t * pDst); 04606 04607 04608 04609 /** 04610 * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4. 04611 * @param[in] *pSrcA points to the first input sequence. 04612 * @param[in] srcALen length of the first input sequence. 04613 * @param[in] *pSrcB points to the second input sequence. 04614 * @param[in] srcBLen length of the second input sequence. 04615 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04616 * @param[in] *pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 04617 * @return none. 04618 */ 04619 04620 void arm_correlate_fast_opt_q15( 04621 q15_t * pSrcA, 04622 uint32_t srcALen, 04623 q15_t * pSrcB, 04624 uint32_t srcBLen, 04625 q15_t * pDst, 04626 q15_t * pScratch); 04627 04628 /** 04629 * @brief Correlation of Q31 sequences. 04630 * @param[in] *pSrcA points to the first input sequence. 04631 * @param[in] srcALen length of the first input sequence. 04632 * @param[in] *pSrcB points to the second input sequence. 04633 * @param[in] srcBLen length of the second input sequence. 04634 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04635 * @return none. 04636 */ 04637 04638 void arm_correlate_q31( 04639 q31_t * pSrcA, 04640 uint32_t srcALen, 04641 q31_t * pSrcB, 04642 uint32_t srcBLen, 04643 q31_t * pDst); 04644 04645 /** 04646 * @brief Correlation of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4 04647 * @param[in] *pSrcA points to the first input sequence. 04648 * @param[in] srcALen length of the first input sequence. 04649 * @param[in] *pSrcB points to the second input sequence. 04650 * @param[in] srcBLen length of the second input sequence. 04651 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04652 * @return none. 04653 */ 04654 04655 void arm_correlate_fast_q31( 04656 q31_t * pSrcA, 04657 uint32_t srcALen, 04658 q31_t * pSrcB, 04659 uint32_t srcBLen, 04660 q31_t * pDst); 04661 04662 04663 04664 /** 04665 * @brief Correlation of Q7 sequences. 04666 * @param[in] *pSrcA points to the first input sequence. 04667 * @param[in] srcALen length of the first input sequence. 04668 * @param[in] *pSrcB points to the second input sequence. 04669 * @param[in] srcBLen length of the second input sequence. 04670 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04671 * @param[in] *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2. 04672 * @param[in] *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen). 04673 * @return none. 04674 */ 04675 04676 void arm_correlate_opt_q7( 04677 q7_t * pSrcA, 04678 uint32_t srcALen, 04679 q7_t * pSrcB, 04680 uint32_t srcBLen, 04681 q7_t * pDst, 04682 q15_t * pScratch1, 04683 q15_t * pScratch2); 04684 04685 04686 /** 04687 * @brief Correlation of Q7 sequences. 04688 * @param[in] *pSrcA points to the first input sequence. 04689 * @param[in] srcALen length of the first input sequence. 04690 * @param[in] *pSrcB points to the second input sequence. 04691 * @param[in] srcBLen length of the second input sequence. 04692 * @param[out] *pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1. 04693 * @return none. 04694 */ 04695 04696 void arm_correlate_q7( 04697 q7_t * pSrcA, 04698 uint32_t srcALen, 04699 q7_t * pSrcB, 04700 uint32_t srcBLen, 04701 q7_t * pDst); 04702 04703 04704 /** 04705 * @brief Instance structure for the floating-point sparse FIR filter. 04706 */ 04707 typedef struct 04708 { 04709 uint16_t numTaps; /**< number of coefficients in the filter. */ 04710 uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ 04711 float32_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ 04712 float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 04713 uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ 04714 int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ 04715 } arm_fir_sparse_instance_f32; 04716 04717 /** 04718 * @brief Instance structure for the Q31 sparse FIR filter. 04719 */ 04720 04721 typedef struct 04722 { 04723 uint16_t numTaps; /**< number of coefficients in the filter. */ 04724 uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ 04725 q31_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ 04726 q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 04727 uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ 04728 int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ 04729 } arm_fir_sparse_instance_q31; 04730 04731 /** 04732 * @brief Instance structure for the Q15 sparse FIR filter. 04733 */ 04734 04735 typedef struct 04736 { 04737 uint16_t numTaps; /**< number of coefficients in the filter. */ 04738 uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ 04739 q15_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ 04740 q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 04741 uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ 04742 int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ 04743 } arm_fir_sparse_instance_q15; 04744 04745 /** 04746 * @brief Instance structure for the Q7 sparse FIR filter. 04747 */ 04748 04749 typedef struct 04750 { 04751 uint16_t numTaps; /**< number of coefficients in the filter. */ 04752 uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */ 04753 q7_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */ 04754 q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/ 04755 uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */ 04756 int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */ 04757 } arm_fir_sparse_instance_q7; 04758 04759 /** 04760 * @brief Processing function for the floating-point sparse FIR filter. 04761 * @param[in] *S points to an instance of the floating-point sparse FIR structure. 04762 * @param[in] *pSrc points to the block of input data. 04763 * @param[out] *pDst points to the block of output data 04764 * @param[in] *pScratchIn points to a temporary buffer of size blockSize. 04765 * @param[in] blockSize number of input samples to process per call. 04766 * @return none. 04767 */ 04768 04769 void arm_fir_sparse_f32( 04770 arm_fir_sparse_instance_f32 * S, 04771 float32_t * pSrc, 04772 float32_t * pDst, 04773 float32_t * pScratchIn, 04774 uint32_t blockSize); 04775 04776 /** 04777 * @brief Initialization function for the floating-point sparse FIR filter. 04778 * @param[in,out] *S points to an instance of the floating-point sparse FIR structure. 04779 * @param[in] numTaps number of nonzero coefficients in the filter. 04780 * @param[in] *pCoeffs points to the array of filter coefficients. 04781 * @param[in] *pState points to the state buffer. 04782 * @param[in] *pTapDelay points to the array of offset times. 04783 * @param[in] maxDelay maximum offset time supported. 04784 * @param[in] blockSize number of samples that will be processed per block. 04785 * @return none 04786 */ 04787 04788 void arm_fir_sparse_init_f32( 04789 arm_fir_sparse_instance_f32 * S, 04790 uint16_t numTaps, 04791 float32_t * pCoeffs, 04792 float32_t * pState, 04793 int32_t * pTapDelay, 04794 uint16_t maxDelay, 04795 uint32_t blockSize); 04796 04797 /** 04798 * @brief Processing function for the Q31 sparse FIR filter. 04799 * @param[in] *S points to an instance of the Q31 sparse FIR structure. 04800 * @param[in] *pSrc points to the block of input data. 04801 * @param[out] *pDst points to the block of output data 04802 * @param[in] *pScratchIn points to a temporary buffer of size blockSize. 04803 * @param[in] blockSize number of input samples to process per call. 04804 * @return none. 04805 */ 04806 04807 void arm_fir_sparse_q31( 04808 arm_fir_sparse_instance_q31 * S, 04809 q31_t * pSrc, 04810 q31_t * pDst, 04811 q31_t * pScratchIn, 04812 uint32_t blockSize); 04813 04814 /** 04815 * @brief Initialization function for the Q31 sparse FIR filter. 04816 * @param[in,out] *S points to an instance of the Q31 sparse FIR structure. 04817 * @param[in] numTaps number of nonzero coefficients in the filter. 04818 * @param[in] *pCoeffs points to the array of filter coefficients. 04819 * @param[in] *pState points to the state buffer. 04820 * @param[in] *pTapDelay points to the array of offset times. 04821 * @param[in] maxDelay maximum offset time supported. 04822 * @param[in] blockSize number of samples that will be processed per block. 04823 * @return none 04824 */ 04825 04826 void arm_fir_sparse_init_q31( 04827 arm_fir_sparse_instance_q31 * S, 04828 uint16_t numTaps, 04829 q31_t * pCoeffs, 04830 q31_t * pState, 04831 int32_t * pTapDelay, 04832 uint16_t maxDelay, 04833 uint32_t blockSize); 04834 04835 /** 04836 * @brief Processing function for the Q15 sparse FIR filter. 04837 * @param[in] *S points to an instance of the Q15 sparse FIR structure. 04838 * @param[in] *pSrc points to the block of input data. 04839 * @param[out] *pDst points to the block of output data 04840 * @param[in] *pScratchIn points to a temporary buffer of size blockSize. 04841 * @param[in] *pScratchOut points to a temporary buffer of size blockSize. 04842 * @param[in] blockSize number of input samples to process per call. 04843 * @return none. 04844 */ 04845 04846 void arm_fir_sparse_q15( 04847 arm_fir_sparse_instance_q15 * S, 04848 q15_t * pSrc, 04849 q15_t * pDst, 04850 q15_t * pScratchIn, 04851 q31_t * pScratchOut, 04852 uint32_t blockSize); 04853 04854 04855 /** 04856 * @brief Initialization function for the Q15 sparse FIR filter. 04857 * @param[in,out] *S points to an instance of the Q15 sparse FIR structure. 04858 * @param[in] numTaps number of nonzero coefficients in the filter. 04859 * @param[in] *pCoeffs points to the array of filter coefficients. 04860 * @param[in] *pState points to the state buffer. 04861 * @param[in] *pTapDelay points to the array of offset times. 04862 * @param[in] maxDelay maximum offset time supported. 04863 * @param[in] blockSize number of samples that will be processed per block. 04864 * @return none 04865 */ 04866 04867 void arm_fir_sparse_init_q15( 04868 arm_fir_sparse_instance_q15 * S, 04869 uint16_t numTaps, 04870 q15_t * pCoeffs, 04871 q15_t * pState, 04872 int32_t * pTapDelay, 04873 uint16_t maxDelay, 04874 uint32_t blockSize); 04875 04876 /** 04877 * @brief Processing function for the Q7 sparse FIR filter. 04878 * @param[in] *S points to an instance of the Q7 sparse FIR structure. 04879 * @param[in] *pSrc points to the block of input data. 04880 * @param[out] *pDst points to the block of output data 04881 * @param[in] *pScratchIn points to a temporary buffer of size blockSize. 04882 * @param[in] *pScratchOut points to a temporary buffer of size blockSize. 04883 * @param[in] blockSize number of input samples to process per call. 04884 * @return none. 04885 */ 04886 04887 void arm_fir_sparse_q7( 04888 arm_fir_sparse_instance_q7 * S, 04889 q7_t * pSrc, 04890 q7_t * pDst, 04891 q7_t * pScratchIn, 04892 q31_t * pScratchOut, 04893 uint32_t blockSize); 04894 04895 /** 04896 * @brief Initialization function for the Q7 sparse FIR filter. 04897 * @param[in,out] *S points to an instance of the Q7 sparse FIR structure. 04898 * @param[in] numTaps number of nonzero coefficients in the filter. 04899 * @param[in] *pCoeffs points to the array of filter coefficients. 04900 * @param[in] *pState points to the state buffer. 04901 * @param[in] *pTapDelay points to the array of offset times. 04902 * @param[in] maxDelay maximum offset time supported. 04903 * @param[in] blockSize number of samples that will be processed per block. 04904 * @return none 04905 */ 04906 04907 void arm_fir_sparse_init_q7( 04908 arm_fir_sparse_instance_q7 * S, 04909 uint16_t numTaps, 04910 q7_t * pCoeffs, 04911 q7_t * pState, 04912 int32_t * pTapDelay, 04913 uint16_t maxDelay, 04914 uint32_t blockSize); 04915 04916 04917 /* 04918 * @brief Floating-point sin_cos function. 04919 * @param[in] theta input value in degrees 04920 * @param[out] *pSinVal points to the processed sine output. 04921 * @param[out] *pCosVal points to the processed cos output. 04922 * @return none. 04923 */ 04924 04925 void arm_sin_cos_f32( 04926 float32_t theta, 04927 float32_t * pSinVal, 04928 float32_t * pCcosVal); 04929 04930 /* 04931 * @brief Q31 sin_cos function. 04932 * @param[in] theta scaled input value in degrees 04933 * @param[out] *pSinVal points to the processed sine output. 04934 * @param[out] *pCosVal points to the processed cosine output. 04935 * @return none. 04936 */ 04937 04938 void arm_sin_cos_q31( 04939 q31_t theta, 04940 q31_t * pSinVal, 04941 q31_t * pCosVal); 04942 04943 04944 /** 04945 * @brief Floating-point complex conjugate. 04946 * @param[in] *pSrc points to the input vector 04947 * @param[out] *pDst points to the output vector 04948 * @param[in] numSamples number of complex samples in each vector 04949 * @return none. 04950 */ 04951 04952 void arm_cmplx_conj_f32( 04953 float32_t * pSrc, 04954 float32_t * pDst, 04955 uint32_t numSamples); 04956 04957 /** 04958 * @brief Q31 complex conjugate. 04959 * @param[in] *pSrc points to the input vector 04960 * @param[out] *pDst points to the output vector 04961 * @param[in] numSamples number of complex samples in each vector 04962 * @return none. 04963 */ 04964 04965 void arm_cmplx_conj_q31( 04966 q31_t * pSrc, 04967 q31_t * pDst, 04968 uint32_t numSamples); 04969 04970 /** 04971 * @brief Q15 complex conjugate. 04972 * @param[in] *pSrc points to the input vector 04973 * @param[out] *pDst points to the output vector 04974 * @param[in] numSamples number of complex samples in each vector 04975 * @return none. 04976 */ 04977 04978 void arm_cmplx_conj_q15( 04979 q15_t * pSrc, 04980 q15_t * pDst, 04981 uint32_t numSamples); 04982 04983 04984 04985 /** 04986 * @brief Floating-point complex magnitude squared 04987 * @param[in] *pSrc points to the complex input vector 04988 * @param[out] *pDst points to the real output vector 04989 * @param[in] numSamples number of complex samples in the input vector 04990 * @return none. 04991 */ 04992 04993 void arm_cmplx_mag_squared_f32( 04994 float32_t * pSrc, 04995 float32_t * pDst, 04996 uint32_t numSamples); 04997 04998 /** 04999 * @brief Q31 complex magnitude squared 05000 * @param[in] *pSrc points to the complex input vector 05001 * @param[out] *pDst points to the real output vector 05002 * @param[in] numSamples number of complex samples in the input vector 05003 * @return none. 05004 */ 05005 05006 void arm_cmplx_mag_squared_q31( 05007 q31_t * pSrc, 05008 q31_t * pDst, 05009 uint32_t numSamples); 05010 05011 /** 05012 * @brief Q15 complex magnitude squared 05013 * @param[in] *pSrc points to the complex input vector 05014 * @param[out] *pDst points to the real output vector 05015 * @param[in] numSamples number of complex samples in the input vector 05016 * @return none. 05017 */ 05018 05019 void arm_cmplx_mag_squared_q15( 05020 q15_t * pSrc, 05021 q15_t * pDst, 05022 uint32_t numSamples); 05023 05024 05025 /** 05026 * @ingroup groupController 05027 */ 05028 05029 /** 05030 * @defgroup PID PID Motor Control 05031 * 05032 * A Proportional Integral Derivative (PID) controller is a generic feedback control 05033 * loop mechanism widely used in industrial control systems. 05034 * A PID controller is the most commonly used type of feedback controller. 05035 * 05036 * This set of functions implements (PID) controllers 05037 * for Q15, Q31, and floating-point data types. The functions operate on a single sample 05038 * of data and each call to the function returns a single processed value. 05039 * <code>S</code> points to an instance of the PID control data structure. <code>in</code> 05040 * is the input sample value. The functions return the output value. 05041 * 05042 * \par Algorithm: 05043 * <pre> 05044 * y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2] 05045 * A0 = Kp + Ki + Kd 05046 * A1 = (-Kp ) - (2 * Kd ) 05047 * A2 = Kd </pre> 05048 * 05049 * \par 05050 * where \c Kp is proportional constant, \c Ki is Integral constant and \c Kd is Derivative constant 05051 * 05052 * \par 05053 * \image html PID.gif "Proportional Integral Derivative Controller" 05054 * 05055 * \par 05056 * The PID controller calculates an "error" value as the difference between 05057 * the measured output and the reference input. 05058 * The controller attempts to minimize the error by adjusting the process control inputs. 05059 * The proportional value determines the reaction to the current error, 05060 * the integral value determines the reaction based on the sum of recent errors, 05061 * and the derivative value determines the reaction based on the rate at which the error has been changing. 05062 * 05063 * \par Instance Structure 05064 * The Gains A0, A1, A2 and state variables for a PID controller are stored together in an instance data structure. 05065 * A separate instance structure must be defined for each PID Controller. 05066 * There are separate instance structure declarations for each of the 3 supported data types. 05067 * 05068 * \par Reset Functions 05069 * There is also an associated reset function for each data type which clears the state array. 05070 * 05071 * \par Initialization Functions 05072 * There is also an associated initialization function for each data type. 05073 * The initialization function performs the following operations: 05074 * - Initializes the Gains A0, A1, A2 from Kp,Ki, Kd gains. 05075 * - Zeros out the values in the state buffer. 05076 * 05077 * \par 05078 * Instance structure cannot be placed into a const data section and it is recommended to use the initialization function. 05079 * 05080 * \par Fixed-Point Behavior 05081 * Care must be taken when using the fixed-point versions of the PID Controller functions. 05082 * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered. 05083 * Refer to the function specific documentation below for usage guidelines. 05084 */ 05085 05086 /** 05087 * @addtogroup PID 05088 * @{ 05089 */ 05090 05091 /** 05092 * @brief Process function for the floating-point PID Control. 05093 * @param[in,out] *S is an instance of the floating-point PID Control structure 05094 * @param[in] in input sample to process 05095 * @return out processed output sample. 05096 */ 05097 05098 05099 static __INLINE float32_t arm_pid_f32( 05100 arm_pid_instance_f32 * S, 05101 float32_t in) 05102 { 05103 float32_t out; 05104 05105 /* y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2] */ 05106 out = (S->A0 * in) + 05107 (S->A1 * S->state[0]) + (S->A2 * S->state[1]) + (S->state[2]); 05108 05109 /* Update state */ 05110 S->state[1] = S->state[0]; 05111 S->state[0] = in; 05112 S->state[2] = out; 05113 05114 /* return to application */ 05115 return (out); 05116 05117 } 05118 05119 /** 05120 * @brief Process function for the Q31 PID Control. 05121 * @param[in,out] *S points to an instance of the Q31 PID Control structure 05122 * @param[in] in input sample to process 05123 * @return out processed output sample. 05124 * 05125 * <b>Scaling and Overflow Behavior:</b> 05126 * \par 05127 * The function is implemented using an internal 64-bit accumulator. 05128 * The accumulator has a 2.62 format and maintains full precision of the intermediate multiplication results but provides only a single guard bit. 05129 * Thus, if the accumulator result overflows it wraps around rather than clip. 05130 * In order to avoid overflows completely the input signal must be scaled down by 2 bits as there are four additions. 05131 * After all multiply-accumulates are performed, the 2.62 accumulator is truncated to 1.32 format and then saturated to 1.31 format. 05132 */ 05133 05134 static __INLINE q31_t arm_pid_q31( 05135 arm_pid_instance_q31 * S, 05136 q31_t in) 05137 { 05138 q63_t acc; 05139 q31_t out; 05140 05141 /* acc = A0 * x[n] */ 05142 acc = (q63_t) S->A0 * in; 05143 05144 /* acc += A1 * x[n-1] */ 05145 acc += (q63_t) S->A1 * S->state[0]; 05146 05147 /* acc += A2 * x[n-2] */ 05148 acc += (q63_t) S->A2 * S->state[1]; 05149 05150 /* convert output to 1.31 format to add y[n-1] */ 05151 out = (q31_t) (acc >> 31u); 05152 05153 /* out += y[n-1] */ 05154 out += S->state[2]; 05155 05156 /* Update state */ 05157 S->state[1] = S->state[0]; 05158 S->state[0] = in; 05159 S->state[2] = out; 05160 05161 /* return to application */ 05162 return (out); 05163 05164 } 05165 05166 /** 05167 * @brief Process function for the Q15 PID Control. 05168 * @param[in,out] *S points to an instance of the Q15 PID Control structure 05169 * @param[in] in input sample to process 05170 * @return out processed output sample. 05171 * 05172 * <b>Scaling and Overflow Behavior:</b> 05173 * \par 05174 * The function is implemented using a 64-bit internal accumulator. 05175 * Both Gains and state variables are represented in 1.15 format and multiplications yield a 2.30 result. 05176 * The 2.30 intermediate results are accumulated in a 64-bit accumulator in 34.30 format. 05177 * There is no risk of internal overflow with this approach and the full precision of intermediate multiplications is preserved. 05178 * After all additions have been performed, the accumulator is truncated to 34.15 format by discarding low 15 bits. 05179 * Lastly, the accumulator is saturated to yield a result in 1.15 format. 05180 */ 05181 05182 static __INLINE q15_t arm_pid_q15( 05183 arm_pid_instance_q15 * S, 05184 q15_t in) 05185 { 05186 q63_t acc; 05187 q15_t out; 05188 05189 #ifndef ARM_MATH_CM0_FAMILY 05190 __SIMD32_TYPE *vstate; 05191 05192 /* Implementation of PID controller */ 05193 05194 /* acc = A0 * x[n] */ 05195 acc = (q31_t) __SMUAD(S->A0, in); 05196 05197 /* acc += A1 * x[n-1] + A2 * x[n-2] */ 05198 vstate = __SIMD32_CONST(S->state); 05199 acc = __SMLALD(S->A1, (q31_t) *vstate, acc); 05200 05201 #else 05202 /* acc = A0 * x[n] */ 05203 acc = ((q31_t) S->A0) * in; 05204 05205 /* acc += A1 * x[n-1] + A2 * x[n-2] */ 05206 acc += (q31_t) S->A1 * S->state[0]; 05207 acc += (q31_t) S->A2 * S->state[1]; 05208 05209 #endif 05210 05211 /* acc += y[n-1] */ 05212 acc += (q31_t) S->state[2] << 15; 05213 05214 /* saturate the output */ 05215 out = (q15_t) (__SSAT((acc >> 15), 16)); 05216 05217 /* Update state */ 05218 S->state[1] = S->state[0]; 05219 S->state[0] = in; 05220 S->state[2] = out; 05221 05222 /* return to application */ 05223 return (out); 05224 05225 } 05226 05227 /** 05228 * @} end of PID group 05229 */ 05230 05231 05232 /** 05233 * @brief Floating-point matrix inverse. 05234 * @param[in] *src points to the instance of the input floating-point matrix structure. 05235 * @param[out] *dst points to the instance of the output floating-point matrix structure. 05236 * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match. 05237 * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR. 05238 */ 05239 05240 arm_status arm_mat_inverse_f32( 05241 const arm_matrix_instance_f32 * src, 05242 arm_matrix_instance_f32 * dst); 05243 05244 05245 /** 05246 * @brief Floating-point matrix inverse. 05247 * @param[in] *src points to the instance of the input floating-point matrix structure. 05248 * @param[out] *dst points to the instance of the output floating-point matrix structure. 05249 * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match. 05250 * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR. 05251 */ 05252 05253 arm_status arm_mat_inverse_f64( 05254 const arm_matrix_instance_f64 * src, 05255 arm_matrix_instance_f64 * dst); 05256 05257 05258 05259 /** 05260 * @ingroup groupController 05261 */ 05262 05263 05264 /** 05265 * @defgroup clarke Vector Clarke Transform 05266 * Forward Clarke transform converts the instantaneous stator phases into a two-coordinate time invariant vector. 05267 * Generally the Clarke transform uses three-phase currents <code>Ia, Ib and Ic</code> to calculate currents 05268 * in the two-phase orthogonal stator axis <code>Ialpha</code> and <code>Ibeta</code>. 05269 * When <code>Ialpha</code> is superposed with <code>Ia</code> as shown in the figure below 05270 * \image html clarke.gif Stator current space vector and its components in (a,b). 05271 * and <code>Ia + Ib + Ic = 0</code>, in this condition <code>Ialpha</code> and <code>Ibeta</code> 05272 * can be calculated using only <code>Ia</code> and <code>Ib</code>. 05273 * 05274 * The function operates on a single sample of data and each call to the function returns the processed output. 05275 * The library provides separate functions for Q31 and floating-point data types. 05276 * \par Algorithm 05277 * \image html clarkeFormula.gif 05278 * where <code>Ia</code> and <code>Ib</code> are the instantaneous stator phases and 05279 * <code>pIalpha</code> and <code>pIbeta</code> are the two coordinates of time invariant vector. 05280 * \par Fixed-Point Behavior 05281 * Care must be taken when using the Q31 version of the Clarke transform. 05282 * In particular, the overflow and saturation behavior of the accumulator used must be considered. 05283 * Refer to the function specific documentation below for usage guidelines. 05284 */ 05285 05286 /** 05287 * @addtogroup clarke 05288 * @{ 05289 */ 05290 05291 /** 05292 * 05293 * @brief Floating-point Clarke transform 05294 * @param[in] Ia input three-phase coordinate <code>a</code> 05295 * @param[in] Ib input three-phase coordinate <code>b</code> 05296 * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha 05297 * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta 05298 * @return none. 05299 */ 05300 05301 static __INLINE void arm_clarke_f32( 05302 float32_t Ia, 05303 float32_t Ib, 05304 float32_t * pIalpha, 05305 float32_t * pIbeta) 05306 { 05307 /* Calculate pIalpha using the equation, pIalpha = Ia */ 05308 *pIalpha = Ia; 05309 05310 /* Calculate pIbeta using the equation, pIbeta = (1/sqrt(3)) * Ia + (2/sqrt(3)) * Ib */ 05311 *pIbeta = 05312 ((float32_t) 0.57735026919 * Ia + (float32_t) 1.15470053838 * Ib); 05313 05314 } 05315 05316 /** 05317 * @brief Clarke transform for Q31 version 05318 * @param[in] Ia input three-phase coordinate <code>a</code> 05319 * @param[in] Ib input three-phase coordinate <code>b</code> 05320 * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha 05321 * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta 05322 * @return none. 05323 * 05324 * <b>Scaling and Overflow Behavior:</b> 05325 * \par 05326 * The function is implemented using an internal 32-bit accumulator. 05327 * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. 05328 * There is saturation on the addition, hence there is no risk of overflow. 05329 */ 05330 05331 static __INLINE void arm_clarke_q31( 05332 q31_t Ia, 05333 q31_t Ib, 05334 q31_t * pIalpha, 05335 q31_t * pIbeta) 05336 { 05337 q31_t product1, product2; /* Temporary variables used to store intermediate results */ 05338 05339 /* Calculating pIalpha from Ia by equation pIalpha = Ia */ 05340 *pIalpha = Ia; 05341 05342 /* Intermediate product is calculated by (1/(sqrt(3)) * Ia) */ 05343 product1 = (q31_t) (((q63_t) Ia * 0x24F34E8B) >> 30); 05344 05345 /* Intermediate product is calculated by (2/sqrt(3) * Ib) */ 05346 product2 = (q31_t) (((q63_t) Ib * 0x49E69D16) >> 30); 05347 05348 /* pIbeta is calculated by adding the intermediate products */ 05349 *pIbeta = __QADD(product1, product2); 05350 } 05351 05352 /** 05353 * @} end of clarke group 05354 */ 05355 05356 /** 05357 * @brief Converts the elements of the Q7 vector to Q31 vector. 05358 * @param[in] *pSrc input pointer 05359 * @param[out] *pDst output pointer 05360 * @param[in] blockSize number of samples to process 05361 * @return none. 05362 */ 05363 void arm_q7_to_q31( 05364 q7_t * pSrc, 05365 q31_t * pDst, 05366 uint32_t blockSize); 05367 05368 05369 05370 05371 /** 05372 * @ingroup groupController 05373 */ 05374 05375 /** 05376 * @defgroup inv_clarke Vector Inverse Clarke Transform 05377 * Inverse Clarke transform converts the two-coordinate time invariant vector into instantaneous stator phases. 05378 * 05379 * The function operates on a single sample of data and each call to the function returns the processed output. 05380 * The library provides separate functions for Q31 and floating-point data types. 05381 * \par Algorithm 05382 * \image html clarkeInvFormula.gif 05383 * where <code>pIa</code> and <code>pIb</code> are the instantaneous stator phases and 05384 * <code>Ialpha</code> and <code>Ibeta</code> are the two coordinates of time invariant vector. 05385 * \par Fixed-Point Behavior 05386 * Care must be taken when using the Q31 version of the Clarke transform. 05387 * In particular, the overflow and saturation behavior of the accumulator used must be considered. 05388 * Refer to the function specific documentation below for usage guidelines. 05389 */ 05390 05391 /** 05392 * @addtogroup inv_clarke 05393 * @{ 05394 */ 05395 05396 /** 05397 * @brief Floating-point Inverse Clarke transform 05398 * @param[in] Ialpha input two-phase orthogonal vector axis alpha 05399 * @param[in] Ibeta input two-phase orthogonal vector axis beta 05400 * @param[out] *pIa points to output three-phase coordinate <code>a</code> 05401 * @param[out] *pIb points to output three-phase coordinate <code>b</code> 05402 * @return none. 05403 */ 05404 05405 05406 static __INLINE void arm_inv_clarke_f32( 05407 float32_t Ialpha, 05408 float32_t Ibeta, 05409 float32_t * pIa, 05410 float32_t * pIb) 05411 { 05412 /* Calculating pIa from Ialpha by equation pIa = Ialpha */ 05413 *pIa = Ialpha; 05414 05415 /* Calculating pIb from Ialpha and Ibeta by equation pIb = -(1/2) * Ialpha + (sqrt(3)/2) * Ibeta */ 05416 *pIb = -0.5 * Ialpha + (float32_t) 0.8660254039 *Ibeta; 05417 05418 } 05419 05420 /** 05421 * @brief Inverse Clarke transform for Q31 version 05422 * @param[in] Ialpha input two-phase orthogonal vector axis alpha 05423 * @param[in] Ibeta input two-phase orthogonal vector axis beta 05424 * @param[out] *pIa points to output three-phase coordinate <code>a</code> 05425 * @param[out] *pIb points to output three-phase coordinate <code>b</code> 05426 * @return none. 05427 * 05428 * <b>Scaling and Overflow Behavior:</b> 05429 * \par 05430 * The function is implemented using an internal 32-bit accumulator. 05431 * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. 05432 * There is saturation on the subtraction, hence there is no risk of overflow. 05433 */ 05434 05435 static __INLINE void arm_inv_clarke_q31( 05436 q31_t Ialpha, 05437 q31_t Ibeta, 05438 q31_t * pIa, 05439 q31_t * pIb) 05440 { 05441 q31_t product1, product2; /* Temporary variables used to store intermediate results */ 05442 05443 /* Calculating pIa from Ialpha by equation pIa = Ialpha */ 05444 *pIa = Ialpha; 05445 05446 /* Intermediate product is calculated by (1/(2*sqrt(3)) * Ia) */ 05447 product1 = (q31_t) (((q63_t) (Ialpha) * (0x40000000)) >> 31); 05448 05449 /* Intermediate product is calculated by (1/sqrt(3) * pIb) */ 05450 product2 = (q31_t) (((q63_t) (Ibeta) * (0x6ED9EBA1)) >> 31); 05451 05452 /* pIb is calculated by subtracting the products */ 05453 *pIb = __QSUB(product2, product1); 05454 05455 } 05456 05457 /** 05458 * @} end of inv_clarke group 05459 */ 05460 05461 /** 05462 * @brief Converts the elements of the Q7 vector to Q15 vector. 05463 * @param[in] *pSrc input pointer 05464 * @param[out] *pDst output pointer 05465 * @param[in] blockSize number of samples to process 05466 * @return none. 05467 */ 05468 void arm_q7_to_q15( 05469 q7_t * pSrc, 05470 q15_t * pDst, 05471 uint32_t blockSize); 05472 05473 05474 05475 /** 05476 * @ingroup groupController 05477 */ 05478 05479 /** 05480 * @defgroup park Vector Park Transform 05481 * 05482 * Forward Park transform converts the input two-coordinate vector to flux and torque components. 05483 * The Park transform can be used to realize the transformation of the <code>Ialpha</code> and the <code>Ibeta</code> currents 05484 * from the stationary to the moving reference frame and control the spatial relationship between 05485 * the stator vector current and rotor flux vector. 05486 * If we consider the d axis aligned with the rotor flux, the diagram below shows the 05487 * current vector and the relationship from the two reference frames: 05488 * \image html park.gif "Stator current space vector and its component in (a,b) and in the d,q rotating reference frame" 05489 * 05490 * The function operates on a single sample of data and each call to the function returns the processed output. 05491 * The library provides separate functions for Q31 and floating-point data types. 05492 * \par Algorithm 05493 * \image html parkFormula.gif 05494 * where <code>Ialpha</code> and <code>Ibeta</code> are the stator vector components, 05495 * <code>pId</code> and <code>pIq</code> are rotor vector components and <code>cosVal</code> and <code>sinVal</code> are the 05496 * cosine and sine values of theta (rotor flux position). 05497 * \par Fixed-Point Behavior 05498 * Care must be taken when using the Q31 version of the Park transform. 05499 * In particular, the overflow and saturation behavior of the accumulator used must be considered. 05500 * Refer to the function specific documentation below for usage guidelines. 05501 */ 05502 05503 /** 05504 * @addtogroup park 05505 * @{ 05506 */ 05507 05508 /** 05509 * @brief Floating-point Park transform 05510 * @param[in] Ialpha input two-phase vector coordinate alpha 05511 * @param[in] Ibeta input two-phase vector coordinate beta 05512 * @param[out] *pId points to output rotor reference frame d 05513 * @param[out] *pIq points to output rotor reference frame q 05514 * @param[in] sinVal sine value of rotation angle theta 05515 * @param[in] cosVal cosine value of rotation angle theta 05516 * @return none. 05517 * 05518 * The function implements the forward Park transform. 05519 * 05520 */ 05521 05522 static __INLINE void arm_park_f32( 05523 float32_t Ialpha, 05524 float32_t Ibeta, 05525 float32_t * pId, 05526 float32_t * pIq, 05527 float32_t sinVal, 05528 float32_t cosVal) 05529 { 05530 /* Calculate pId using the equation, pId = Ialpha * cosVal + Ibeta * sinVal */ 05531 *pId = Ialpha * cosVal + Ibeta * sinVal; 05532 05533 /* Calculate pIq using the equation, pIq = - Ialpha * sinVal + Ibeta * cosVal */ 05534 *pIq = -Ialpha * sinVal + Ibeta * cosVal; 05535 05536 } 05537 05538 /** 05539 * @brief Park transform for Q31 version 05540 * @param[in] Ialpha input two-phase vector coordinate alpha 05541 * @param[in] Ibeta input two-phase vector coordinate beta 05542 * @param[out] *pId points to output rotor reference frame d 05543 * @param[out] *pIq points to output rotor reference frame q 05544 * @param[in] sinVal sine value of rotation angle theta 05545 * @param[in] cosVal cosine value of rotation angle theta 05546 * @return none. 05547 * 05548 * <b>Scaling and Overflow Behavior:</b> 05549 * \par 05550 * The function is implemented using an internal 32-bit accumulator. 05551 * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. 05552 * There is saturation on the addition and subtraction, hence there is no risk of overflow. 05553 */ 05554 05555 05556 static __INLINE void arm_park_q31( 05557 q31_t Ialpha, 05558 q31_t Ibeta, 05559 q31_t * pId, 05560 q31_t * pIq, 05561 q31_t sinVal, 05562 q31_t cosVal) 05563 { 05564 q31_t product1, product2; /* Temporary variables used to store intermediate results */ 05565 q31_t product3, product4; /* Temporary variables used to store intermediate results */ 05566 05567 /* Intermediate product is calculated by (Ialpha * cosVal) */ 05568 product1 = (q31_t) (((q63_t) (Ialpha) * (cosVal)) >> 31); 05569 05570 /* Intermediate product is calculated by (Ibeta * sinVal) */ 05571 product2 = (q31_t) (((q63_t) (Ibeta) * (sinVal)) >> 31); 05572 05573 05574 /* Intermediate product is calculated by (Ialpha * sinVal) */ 05575 product3 = (q31_t) (((q63_t) (Ialpha) * (sinVal)) >> 31); 05576 05577 /* Intermediate product is calculated by (Ibeta * cosVal) */ 05578 product4 = (q31_t) (((q63_t) (Ibeta) * (cosVal)) >> 31); 05579 05580 /* Calculate pId by adding the two intermediate products 1 and 2 */ 05581 *pId = __QADD(product1, product2); 05582 05583 /* Calculate pIq by subtracting the two intermediate products 3 from 4 */ 05584 *pIq = __QSUB(product4, product3); 05585 } 05586 05587 /** 05588 * @} end of park group 05589 */ 05590 05591 /** 05592 * @brief Converts the elements of the Q7 vector to floating-point vector. 05593 * @param[in] *pSrc is input pointer 05594 * @param[out] *pDst is output pointer 05595 * @param[in] blockSize is the number of samples to process 05596 * @return none. 05597 */ 05598 void arm_q7_to_float( 05599 q7_t * pSrc, 05600 float32_t * pDst, 05601 uint32_t blockSize); 05602 05603 05604 /** 05605 * @ingroup groupController 05606 */ 05607 05608 /** 05609 * @defgroup inv_park Vector Inverse Park transform 05610 * Inverse Park transform converts the input flux and torque components to two-coordinate vector. 05611 * 05612 * The function operates on a single sample of data and each call to the function returns the processed output. 05613 * The library provides separate functions for Q31 and floating-point data types. 05614 * \par Algorithm 05615 * \image html parkInvFormula.gif 05616 * where <code>pIalpha</code> and <code>pIbeta</code> are the stator vector components, 05617 * <code>Id</code> and <code>Iq</code> are rotor vector components and <code>cosVal</code> and <code>sinVal</code> are the 05618 * cosine and sine values of theta (rotor flux position). 05619 * \par Fixed-Point Behavior 05620 * Care must be taken when using the Q31 version of the Park transform. 05621 * In particular, the overflow and saturation behavior of the accumulator used must be considered. 05622 * Refer to the function specific documentation below for usage guidelines. 05623 */ 05624 05625 /** 05626 * @addtogroup inv_park 05627 * @{ 05628 */ 05629 05630 /** 05631 * @brief Floating-point Inverse Park transform 05632 * @param[in] Id input coordinate of rotor reference frame d 05633 * @param[in] Iq input coordinate of rotor reference frame q 05634 * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha 05635 * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta 05636 * @param[in] sinVal sine value of rotation angle theta 05637 * @param[in] cosVal cosine value of rotation angle theta 05638 * @return none. 05639 */ 05640 05641 static __INLINE void arm_inv_park_f32( 05642 float32_t Id, 05643 float32_t Iq, 05644 float32_t * pIalpha, 05645 float32_t * pIbeta, 05646 float32_t sinVal, 05647 float32_t cosVal) 05648 { 05649 /* Calculate pIalpha using the equation, pIalpha = Id * cosVal - Iq * sinVal */ 05650 *pIalpha = Id * cosVal - Iq * sinVal; 05651 05652 /* Calculate pIbeta using the equation, pIbeta = Id * sinVal + Iq * cosVal */ 05653 *pIbeta = Id * sinVal + Iq * cosVal; 05654 05655 } 05656 05657 05658 /** 05659 * @brief Inverse Park transform for Q31 version 05660 * @param[in] Id input coordinate of rotor reference frame d 05661 * @param[in] Iq input coordinate of rotor reference frame q 05662 * @param[out] *pIalpha points to output two-phase orthogonal vector axis alpha 05663 * @param[out] *pIbeta points to output two-phase orthogonal vector axis beta 05664 * @param[in] sinVal sine value of rotation angle theta 05665 * @param[in] cosVal cosine value of rotation angle theta 05666 * @return none. 05667 * 05668 * <b>Scaling and Overflow Behavior:</b> 05669 * \par 05670 * The function is implemented using an internal 32-bit accumulator. 05671 * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format. 05672 * There is saturation on the addition, hence there is no risk of overflow. 05673 */ 05674 05675 05676 static __INLINE void arm_inv_park_q31( 05677 q31_t Id, 05678 q31_t Iq, 05679 q31_t * pIalpha, 05680 q31_t * pIbeta, 05681 q31_t sinVal, 05682 q31_t cosVal) 05683 { 05684 q31_t product1, product2; /* Temporary variables used to store intermediate results */ 05685 q31_t product3, product4; /* Temporary variables used to store intermediate results */ 05686 05687 /* Intermediate product is calculated by (Id * cosVal) */ 05688 product1 = (q31_t) (((q63_t) (Id) * (cosVal)) >> 31); 05689 05690 /* Intermediate product is calculated by (Iq * sinVal) */ 05691 product2 = (q31_t) (((q63_t) (Iq) * (sinVal)) >> 31); 05692 05693 05694 /* Intermediate product is calculated by (Id * sinVal) */ 05695 product3 = (q31_t) (((q63_t) (Id) * (sinVal)) >> 31); 05696 05697 /* Intermediate product is calculated by (Iq * cosVal) */ 05698 product4 = (q31_t) (((q63_t) (Iq) * (cosVal)) >> 31); 05699 05700 /* Calculate pIalpha by using the two intermediate products 1 and 2 */ 05701 *pIalpha = __QSUB(product1, product2); 05702 05703 /* Calculate pIbeta by using the two intermediate products 3 and 4 */ 05704 *pIbeta = __QADD(product4, product3); 05705 05706 } 05707 05708 /** 05709 * @} end of Inverse park group 05710 */ 05711 05712 05713 /** 05714 * @brief Converts the elements of the Q31 vector to floating-point vector. 05715 * @param[in] *pSrc is input pointer 05716 * @param[out] *pDst is output pointer 05717 * @param[in] blockSize is the number of samples to process 05718 * @return none. 05719 */ 05720 void arm_q31_to_float( 05721 q31_t * pSrc, 05722 float32_t * pDst, 05723 uint32_t blockSize); 05724 05725 /** 05726 * @ingroup groupInterpolation 05727 */ 05728 05729 /** 05730 * @defgroup LinearInterpolate Linear Interpolation 05731 * 05732 * Linear interpolation is a method of curve fitting using linear polynomials. 05733 * Linear interpolation works by effectively drawing a straight line between two neighboring samples and returning the appropriate point along that line 05734 * 05735 * \par 05736 * \image html LinearInterp.gif "Linear interpolation" 05737 * 05738 * \par 05739 * A Linear Interpolate function calculates an output value(y), for the input(x) 05740 * using linear interpolation of the input values x0, x1( nearest input values) and the output values y0 and y1(nearest output values) 05741 * 05742 * \par Algorithm: 05743 * <pre> 05744 * y = y0 + (x - x0) * ((y1 - y0)/(x1-x0)) 05745 * where x0, x1 are nearest values of input x 05746 * y0, y1 are nearest values to output y 05747 * </pre> 05748 * 05749 * \par 05750 * This set of functions implements Linear interpolation process 05751 * for Q7, Q15, Q31, and floating-point data types. The functions operate on a single 05752 * sample of data and each call to the function returns a single processed value. 05753 * <code>S</code> points to an instance of the Linear Interpolate function data structure. 05754 * <code>x</code> is the input sample value. The functions returns the output value. 05755 * 05756 * \par 05757 * if x is outside of the table boundary, Linear interpolation returns first value of the table 05758 * if x is below input range and returns last value of table if x is above range. 05759 */ 05760 05761 /** 05762 * @addtogroup LinearInterpolate 05763 * @{ 05764 */ 05765 05766 /** 05767 * @brief Process function for the floating-point Linear Interpolation Function. 05768 * @param[in,out] *S is an instance of the floating-point Linear Interpolation structure 05769 * @param[in] x input sample to process 05770 * @return y processed output sample. 05771 * 05772 */ 05773 05774 static __INLINE float32_t arm_linear_interp_f32( 05775 arm_linear_interp_instance_f32 * S, 05776 float32_t x) 05777 { 05778 05779 float32_t y; 05780 float32_t x0, x1; /* Nearest input values */ 05781 float32_t y0, y1; /* Nearest output values */ 05782 float32_t xSpacing = S->xSpacing; /* spacing between input values */ 05783 int32_t i; /* Index variable */ 05784 float32_t *pYData = S->pYData; /* pointer to output table */ 05785 05786 /* Calculation of index */ 05787 i = (int32_t) ((x - S->x1) / xSpacing); 05788 05789 if(i < 0) 05790 { 05791 /* Iniatilize output for below specified range as least output value of table */ 05792 y = pYData[0]; 05793 } 05794 else if((uint32_t)i >= S->nValues) 05795 { 05796 /* Iniatilize output for above specified range as last output value of table */ 05797 y = pYData[S->nValues - 1]; 05798 } 05799 else 05800 { 05801 /* Calculation of nearest input values */ 05802 x0 = S->x1 + i * xSpacing; 05803 x1 = S->x1 + (i + 1) * xSpacing; 05804 05805 /* Read of nearest output values */ 05806 y0 = pYData[i]; 05807 y1 = pYData[i + 1]; 05808 05809 /* Calculation of output */ 05810 y = y0 + (x - x0) * ((y1 - y0) / (x1 - x0)); 05811 05812 } 05813 05814 /* returns output value */ 05815 return (y); 05816 } 05817 05818 /** 05819 * 05820 * @brief Process function for the Q31 Linear Interpolation Function. 05821 * @param[in] *pYData pointer to Q31 Linear Interpolation table 05822 * @param[in] x input sample to process 05823 * @param[in] nValues number of table values 05824 * @return y processed output sample. 05825 * 05826 * \par 05827 * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. 05828 * This function can support maximum of table size 2^12. 05829 * 05830 */ 05831 05832 05833 static __INLINE q31_t arm_linear_interp_q31( 05834 q31_t * pYData, 05835 q31_t x, 05836 uint32_t nValues) 05837 { 05838 q31_t y; /* output */ 05839 q31_t y0, y1; /* Nearest output values */ 05840 q31_t fract; /* fractional part */ 05841 int32_t index; /* Index to read nearest output values */ 05842 05843 /* Input is in 12.20 format */ 05844 /* 12 bits for the table index */ 05845 /* Index value calculation */ 05846 index = ((x & 0xFFF00000) >> 20); 05847 05848 if(index >= (int32_t)(nValues - 1)) 05849 { 05850 return (pYData[nValues - 1]); 05851 } 05852 else if(index < 0) 05853 { 05854 return (pYData[0]); 05855 } 05856 else 05857 { 05858 05859 /* 20 bits for the fractional part */ 05860 /* shift left by 11 to keep fract in 1.31 format */ 05861 fract = (x & 0x000FFFFF) << 11; 05862 05863 /* Read two nearest output values from the index in 1.31(q31) format */ 05864 y0 = pYData[index]; 05865 y1 = pYData[index + 1u]; 05866 05867 /* Calculation of y0 * (1-fract) and y is in 2.30 format */ 05868 y = ((q31_t) ((q63_t) y0 * (0x7FFFFFFF - fract) >> 32)); 05869 05870 /* Calculation of y0 * (1-fract) + y1 *fract and y is in 2.30 format */ 05871 y += ((q31_t) (((q63_t) y1 * fract) >> 32)); 05872 05873 /* Convert y to 1.31 format */ 05874 return (y << 1u); 05875 05876 } 05877 05878 } 05879 05880 /** 05881 * 05882 * @brief Process function for the Q15 Linear Interpolation Function. 05883 * @param[in] *pYData pointer to Q15 Linear Interpolation table 05884 * @param[in] x input sample to process 05885 * @param[in] nValues number of table values 05886 * @return y processed output sample. 05887 * 05888 * \par 05889 * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. 05890 * This function can support maximum of table size 2^12. 05891 * 05892 */ 05893 05894 05895 static __INLINE q15_t arm_linear_interp_q15( 05896 q15_t * pYData, 05897 q31_t x, 05898 uint32_t nValues) 05899 { 05900 q63_t y; /* output */ 05901 q15_t y0, y1; /* Nearest output values */ 05902 q31_t fract; /* fractional part */ 05903 int32_t index; /* Index to read nearest output values */ 05904 05905 /* Input is in 12.20 format */ 05906 /* 12 bits for the table index */ 05907 /* Index value calculation */ 05908 index = ((x & 0xFFF00000) >> 20u); 05909 05910 if(index >= (int32_t)(nValues - 1)) 05911 { 05912 return (pYData[nValues - 1]); 05913 } 05914 else if(index < 0) 05915 { 05916 return (pYData[0]); 05917 } 05918 else 05919 { 05920 /* 20 bits for the fractional part */ 05921 /* fract is in 12.20 format */ 05922 fract = (x & 0x000FFFFF); 05923 05924 /* Read two nearest output values from the index */ 05925 y0 = pYData[index]; 05926 y1 = pYData[index + 1u]; 05927 05928 /* Calculation of y0 * (1-fract) and y is in 13.35 format */ 05929 y = ((q63_t) y0 * (0xFFFFF - fract)); 05930 05931 /* Calculation of (y0 * (1-fract) + y1 * fract) and y is in 13.35 format */ 05932 y += ((q63_t) y1 * (fract)); 05933 05934 /* convert y to 1.15 format */ 05935 return (y >> 20); 05936 } 05937 05938 05939 } 05940 05941 /** 05942 * 05943 * @brief Process function for the Q7 Linear Interpolation Function. 05944 * @param[in] *pYData pointer to Q7 Linear Interpolation table 05945 * @param[in] x input sample to process 05946 * @param[in] nValues number of table values 05947 * @return y processed output sample. 05948 * 05949 * \par 05950 * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part. 05951 * This function can support maximum of table size 2^12. 05952 */ 05953 05954 05955 static __INLINE q7_t arm_linear_interp_q7( 05956 q7_t * pYData, 05957 q31_t x, 05958 uint32_t nValues) 05959 { 05960 q31_t y; /* output */ 05961 q7_t y0, y1; /* Nearest output values */ 05962 q31_t fract; /* fractional part */ 05963 uint32_t index; /* Index to read nearest output values */ 05964 05965 /* Input is in 12.20 format */ 05966 /* 12 bits for the table index */ 05967 /* Index value calculation */ 05968 if (x < 0) 05969 { 05970 return (pYData[0]); 05971 } 05972 index = (x >> 20) & 0xfff; 05973 05974 05975 if(index >= (nValues - 1)) 05976 { 05977 return (pYData[nValues - 1]); 05978 } 05979 else 05980 { 05981 05982 /* 20 bits for the fractional part */ 05983 /* fract is in 12.20 format */ 05984 fract = (x & 0x000FFFFF); 05985 05986 /* Read two nearest output values from the index and are in 1.7(q7) format */ 05987 y0 = pYData[index]; 05988 y1 = pYData[index + 1u]; 05989 05990 /* Calculation of y0 * (1-fract ) and y is in 13.27(q27) format */ 05991 y = ((y0 * (0xFFFFF - fract))); 05992 05993 /* Calculation of y1 * fract + y0 * (1-fract) and y is in 13.27(q27) format */ 05994 y += (y1 * fract); 05995 05996 /* convert y to 1.7(q7) format */ 05997 return (y >> 20u); 05998 05999 } 06000 06001 } 06002 /** 06003 * @} end of LinearInterpolate group 06004 */ 06005 06006 /** 06007 * @brief Fast approximation to the trigonometric sine function for floating-point data. 06008 * @param[in] x input value in radians. 06009 * @return sin(x). 06010 */ 06011 06012 float32_t arm_sin_f32( 06013 float32_t x); 06014 06015 /** 06016 * @brief Fast approximation to the trigonometric sine function for Q31 data. 06017 * @param[in] x Scaled input value in radians. 06018 * @return sin(x). 06019 */ 06020 06021 q31_t arm_sin_q31( 06022 q31_t x); 06023 06024 /** 06025 * @brief Fast approximation to the trigonometric sine function for Q15 data. 06026 * @param[in] x Scaled input value in radians. 06027 * @return sin(x). 06028 */ 06029 06030 q15_t arm_sin_q15( 06031 q15_t x); 06032 06033 /** 06034 * @brief Fast approximation to the trigonometric cosine function for floating-point data. 06035 * @param[in] x input value in radians. 06036 * @return cos(x). 06037 */ 06038 06039 float32_t arm_cos_f32( 06040 float32_t x); 06041 06042 /** 06043 * @brief Fast approximation to the trigonometric cosine function for Q31 data. 06044 * @param[in] x Scaled input value in radians. 06045 * @return cos(x). 06046 */ 06047 06048 q31_t arm_cos_q31( 06049 q31_t x); 06050 06051 /** 06052 * @brief Fast approximation to the trigonometric cosine function for Q15 data. 06053 * @param[in] x Scaled input value in radians. 06054 * @return cos(x). 06055 */ 06056 06057 q15_t arm_cos_q15( 06058 q15_t x); 06059 06060 06061 /** 06062 * @ingroup groupFastMath 06063 */ 06064 06065 06066 /** 06067 * @defgroup SQRT Square Root 06068 * 06069 * Computes the square root of a number. 06070 * There are separate functions for Q15, Q31, and floating-point data types. 06071 * The square root function is computed using the Newton-Raphson algorithm. 06072 * This is an iterative algorithm of the form: 06073 * <pre> 06074 * x1 = x0 - f(x0)/f'(x0) 06075 * </pre> 06076 * where <code>x1</code> is the current estimate, 06077 * <code>x0</code> is the previous estimate, and 06078 * <code>f'(x0)</code> is the derivative of <code>f()</code> evaluated at <code>x0</code>. 06079 * For the square root function, the algorithm reduces to: 06080 * <pre> 06081 * x0 = in/2 [initial guess] 06082 * x1 = 1/2 * ( x0 + in / x0) [each iteration] 06083 * </pre> 06084 */ 06085 06086 06087 /** 06088 * @addtogroup SQRT 06089 * @{ 06090 */ 06091 06092 /** 06093 * @brief Floating-point square root function. 06094 * @param[in] in input value. 06095 * @param[out] *pOut square root of input value. 06096 * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if 06097 * <code>in</code> is negative value and returns zero output for negative values. 06098 */ 06099 06100 static __INLINE arm_status arm_sqrt_f32( 06101 float32_t in, 06102 float32_t * pOut) 06103 { 06104 if(in >= 0.0f) 06105 { 06106 06107 // #if __FPU_USED 06108 #if (__FPU_USED == 1) && defined ( __CC_ARM ) 06109 *pOut = __sqrtf(in); 06110 #else 06111 *pOut = sqrtf(in); 06112 #endif 06113 06114 return (ARM_MATH_SUCCESS); 06115 } 06116 else 06117 { 06118 *pOut = 0.0f; 06119 return (ARM_MATH_ARGUMENT_ERROR); 06120 } 06121 06122 } 06123 06124 06125 /** 06126 * @brief Q31 square root function. 06127 * @param[in] in input value. The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF. 06128 * @param[out] *pOut square root of input value. 06129 * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if 06130 * <code>in</code> is negative value and returns zero output for negative values. 06131 */ 06132 arm_status arm_sqrt_q31( 06133 q31_t in, 06134 q31_t * pOut); 06135 06136 /** 06137 * @brief Q15 square root function. 06138 * @param[in] in input value. The range of the input value is [0 +1) or 0x0000 to 0x7FFF. 06139 * @param[out] *pOut square root of input value. 06140 * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if 06141 * <code>in</code> is negative value and returns zero output for negative values. 06142 */ 06143 arm_status arm_sqrt_q15( 06144 q15_t in, 06145 q15_t * pOut); 06146 06147 /** 06148 * @} end of SQRT group 06149 */ 06150 06151 06152 06153 06154 06155 06156 /** 06157 * @brief floating-point Circular write function. 06158 */ 06159 06160 static __INLINE void arm_circularWrite_f32( 06161 int32_t * circBuffer, 06162 int32_t L, 06163 uint16_t * writeOffset, 06164 int32_t bufferInc, 06165 const int32_t * src, 06166 int32_t srcInc, 06167 uint32_t blockSize) 06168 { 06169 uint32_t i = 0u; 06170 int32_t wOffset; 06171 06172 /* Copy the value of Index pointer that points 06173 * to the current location where the input samples to be copied */ 06174 wOffset = *writeOffset; 06175 06176 /* Loop over the blockSize */ 06177 i = blockSize; 06178 06179 while(i > 0u) 06180 { 06181 /* copy the input sample to the circular buffer */ 06182 circBuffer[wOffset] = *src; 06183 06184 /* Update the input pointer */ 06185 src += srcInc; 06186 06187 /* Circularly update wOffset. Watch out for positive and negative value */ 06188 wOffset += bufferInc; 06189 if(wOffset >= L) 06190 wOffset -= L; 06191 06192 /* Decrement the loop counter */ 06193 i--; 06194 } 06195 06196 /* Update the index pointer */ 06197 *writeOffset = wOffset; 06198 } 06199 06200 06201 06202 /** 06203 * @brief floating-point Circular Read function. 06204 */ 06205 static __INLINE void arm_circularRead_f32( 06206 int32_t * circBuffer, 06207 int32_t L, 06208 int32_t * readOffset, 06209 int32_t bufferInc, 06210 int32_t * dst, 06211 int32_t * dst_base, 06212 int32_t dst_length, 06213 int32_t dstInc, 06214 uint32_t blockSize) 06215 { 06216 uint32_t i = 0u; 06217 int32_t rOffset, dst_end; 06218 06219 /* Copy the value of Index pointer that points 06220 * to the current location from where the input samples to be read */ 06221 rOffset = *readOffset; 06222 dst_end = (int32_t) (dst_base + dst_length); 06223 06224 /* Loop over the blockSize */ 06225 i = blockSize; 06226 06227 while(i > 0u) 06228 { 06229 /* copy the sample from the circular buffer to the destination buffer */ 06230 *dst = circBuffer[rOffset]; 06231 06232 /* Update the input pointer */ 06233 dst += dstInc; 06234 06235 if(dst == (int32_t *) dst_end) 06236 { 06237 dst = dst_base; 06238 } 06239 06240 /* Circularly update rOffset. Watch out for positive and negative value */ 06241 rOffset += bufferInc; 06242 06243 if(rOffset >= L) 06244 { 06245 rOffset -= L; 06246 } 06247 06248 /* Decrement the loop counter */ 06249 i--; 06250 } 06251 06252 /* Update the index pointer */ 06253 *readOffset = rOffset; 06254 } 06255 06256 /** 06257 * @brief Q15 Circular write function. 06258 */ 06259 06260 static __INLINE void arm_circularWrite_q15( 06261 q15_t * circBuffer, 06262 int32_t L, 06263 uint16_t * writeOffset, 06264 int32_t bufferInc, 06265 const q15_t * src, 06266 int32_t srcInc, 06267 uint32_t blockSize) 06268 { 06269 uint32_t i = 0u; 06270 int32_t wOffset; 06271 06272 /* Copy the value of Index pointer that points 06273 * to the current location where the input samples to be copied */ 06274 wOffset = *writeOffset; 06275 06276 /* Loop over the blockSize */ 06277 i = blockSize; 06278 06279 while(i > 0u) 06280 { 06281 /* copy the input sample to the circular buffer */ 06282 circBuffer[wOffset] = *src; 06283 06284 /* Update the input pointer */ 06285 src += srcInc; 06286 06287 /* Circularly update wOffset. Watch out for positive and negative value */ 06288 wOffset += bufferInc; 06289 if(wOffset >= L) 06290 wOffset -= L; 06291 06292 /* Decrement the loop counter */ 06293 i--; 06294 } 06295 06296 /* Update the index pointer */ 06297 *writeOffset = wOffset; 06298 } 06299 06300 06301 06302 /** 06303 * @brief Q15 Circular Read function. 06304 */ 06305 static __INLINE void arm_circularRead_q15( 06306 q15_t * circBuffer, 06307 int32_t L, 06308 int32_t * readOffset, 06309 int32_t bufferInc, 06310 q15_t * dst, 06311 q15_t * dst_base, 06312 int32_t dst_length, 06313 int32_t dstInc, 06314 uint32_t blockSize) 06315 { 06316 uint32_t i = 0; 06317 int32_t rOffset, dst_end; 06318 06319 /* Copy the value of Index pointer that points 06320 * to the current location from where the input samples to be read */ 06321 rOffset = *readOffset; 06322 06323 dst_end = (int32_t) (dst_base + dst_length); 06324 06325 /* Loop over the blockSize */ 06326 i = blockSize; 06327 06328 while(i > 0u) 06329 { 06330 /* copy the sample from the circular buffer to the destination buffer */ 06331 *dst = circBuffer[rOffset]; 06332 06333 /* Update the input pointer */ 06334 dst += dstInc; 06335 06336 if(dst == (q15_t *) dst_end) 06337 { 06338 dst = dst_base; 06339 } 06340 06341 /* Circularly update wOffset. Watch out for positive and negative value */ 06342 rOffset += bufferInc; 06343 06344 if(rOffset >= L) 06345 { 06346 rOffset -= L; 06347 } 06348 06349 /* Decrement the loop counter */ 06350 i--; 06351 } 06352 06353 /* Update the index pointer */ 06354 *readOffset = rOffset; 06355 } 06356 06357 06358 /** 06359 * @brief Q7 Circular write function. 06360 */ 06361 06362 static __INLINE void arm_circularWrite_q7( 06363 q7_t * circBuffer, 06364 int32_t L, 06365 uint16_t * writeOffset, 06366 int32_t bufferInc, 06367 const q7_t * src, 06368 int32_t srcInc, 06369 uint32_t blockSize) 06370 { 06371 uint32_t i = 0u; 06372 int32_t wOffset; 06373 06374 /* Copy the value of Index pointer that points 06375 * to the current location where the input samples to be copied */ 06376 wOffset = *writeOffset; 06377 06378 /* Loop over the blockSize */ 06379 i = blockSize; 06380 06381 while(i > 0u) 06382 { 06383 /* copy the input sample to the circular buffer */ 06384 circBuffer[wOffset] = *src; 06385 06386 /* Update the input pointer */ 06387 src += srcInc; 06388 06389 /* Circularly update wOffset. Watch out for positive and negative value */ 06390 wOffset += bufferInc; 06391 if(wOffset >= L) 06392 wOffset -= L; 06393 06394 /* Decrement the loop counter */ 06395 i--; 06396 } 06397 06398 /* Update the index pointer */ 06399 *writeOffset = wOffset; 06400 } 06401 06402 06403 06404 /** 06405 * @brief Q7 Circular Read function. 06406 */ 06407 static __INLINE void arm_circularRead_q7( 06408 q7_t * circBuffer, 06409 int32_t L, 06410 int32_t * readOffset, 06411 int32_t bufferInc, 06412 q7_t * dst, 06413 q7_t * dst_base, 06414 int32_t dst_length, 06415 int32_t dstInc, 06416 uint32_t blockSize) 06417 { 06418 uint32_t i = 0; 06419 int32_t rOffset, dst_end; 06420 06421 /* Copy the value of Index pointer that points 06422 * to the current location from where the input samples to be read */ 06423 rOffset = *readOffset; 06424 06425 dst_end = (int32_t) (dst_base + dst_length); 06426 06427 /* Loop over the blockSize */ 06428 i = blockSize; 06429 06430 while(i > 0u) 06431 { 06432 /* copy the sample from the circular buffer to the destination buffer */ 06433 *dst = circBuffer[rOffset]; 06434 06435 /* Update the input pointer */ 06436 dst += dstInc; 06437 06438 if(dst == (q7_t *) dst_end) 06439 { 06440 dst = dst_base; 06441 } 06442 06443 /* Circularly update rOffset. Watch out for positive and negative value */ 06444 rOffset += bufferInc; 06445 06446 if(rOffset >= L) 06447 { 06448 rOffset -= L; 06449 } 06450 06451 /* Decrement the loop counter */ 06452 i--; 06453 } 06454 06455 /* Update the index pointer */ 06456 *readOffset = rOffset; 06457 } 06458 06459 06460 /** 06461 * @brief Sum of the squares of the elements of a Q31 vector. 06462 * @param[in] *pSrc is input pointer 06463 * @param[in] blockSize is the number of samples to process 06464 * @param[out] *pResult is output value. 06465 * @return none. 06466 */ 06467 06468 void arm_power_q31( 06469 q31_t * pSrc, 06470 uint32_t blockSize, 06471 q63_t * pResult); 06472 06473 /** 06474 * @brief Sum of the squares of the elements of a floating-point vector. 06475 * @param[in] *pSrc is input pointer 06476 * @param[in] blockSize is the number of samples to process 06477 * @param[out] *pResult is output value. 06478 * @return none. 06479 */ 06480 06481 void arm_power_f32( 06482 float32_t * pSrc, 06483 uint32_t blockSize, 06484 float32_t * pResult); 06485 06486 /** 06487 * @brief Sum of the squares of the elements of a Q15 vector. 06488 * @param[in] *pSrc is input pointer 06489 * @param[in] blockSize is the number of samples to process 06490 * @param[out] *pResult is output value. 06491 * @return none. 06492 */ 06493 06494 void arm_power_q15( 06495 q15_t * pSrc, 06496 uint32_t blockSize, 06497 q63_t * pResult); 06498 06499 /** 06500 * @brief Sum of the squares of the elements of a Q7 vector. 06501 * @param[in] *pSrc is input pointer 06502 * @param[in] blockSize is the number of samples to process 06503 * @param[out] *pResult is output value. 06504 * @return none. 06505 */ 06506 06507 void arm_power_q7( 06508 q7_t * pSrc, 06509 uint32_t blockSize, 06510 q31_t * pResult); 06511 06512 /** 06513 * @brief Mean value of a Q7 vector. 06514 * @param[in] *pSrc is input pointer 06515 * @param[in] blockSize is the number of samples to process 06516 * @param[out] *pResult is output value. 06517 * @return none. 06518 */ 06519 06520 void arm_mean_q7( 06521 q7_t * pSrc, 06522 uint32_t blockSize, 06523 q7_t * pResult); 06524 06525 /** 06526 * @brief Mean value of a Q15 vector. 06527 * @param[in] *pSrc is input pointer 06528 * @param[in] blockSize is the number of samples to process 06529 * @param[out] *pResult is output value. 06530 * @return none. 06531 */ 06532 void arm_mean_q15( 06533 q15_t * pSrc, 06534 uint32_t blockSize, 06535 q15_t * pResult); 06536 06537 /** 06538 * @brief Mean value of a Q31 vector. 06539 * @param[in] *pSrc is input pointer 06540 * @param[in] blockSize is the number of samples to process 06541 * @param[out] *pResult is output value. 06542 * @return none. 06543 */ 06544 void arm_mean_q31( 06545 q31_t * pSrc, 06546 uint32_t blockSize, 06547 q31_t * pResult); 06548 06549 /** 06550 * @brief Mean value of a floating-point vector. 06551 * @param[in] *pSrc is input pointer 06552 * @param[in] blockSize is the number of samples to process 06553 * @param[out] *pResult is output value. 06554 * @return none. 06555 */ 06556 void arm_mean_f32( 06557 float32_t * pSrc, 06558 uint32_t blockSize, 06559 float32_t * pResult); 06560 06561 /** 06562 * @brief Variance of the elements of a floating-point vector. 06563 * @param[in] *pSrc is input pointer 06564 * @param[in] blockSize is the number of samples to process 06565 * @param[out] *pResult is output value. 06566 * @return none. 06567 */ 06568 06569 void arm_var_f32( 06570 float32_t * pSrc, 06571 uint32_t blockSize, 06572 float32_t * pResult); 06573 06574 /** 06575 * @brief Variance of the elements of a Q31 vector. 06576 * @param[in] *pSrc is input pointer 06577 * @param[in] blockSize is the number of samples to process 06578 * @param[out] *pResult is output value. 06579 * @return none. 06580 */ 06581 06582 void arm_var_q31( 06583 q31_t * pSrc, 06584 uint32_t blockSize, 06585 q31_t * pResult); 06586 06587 /** 06588 * @brief Variance of the elements of a Q15 vector. 06589 * @param[in] *pSrc is input pointer 06590 * @param[in] blockSize is the number of samples to process 06591 * @param[out] *pResult is output value. 06592 * @return none. 06593 */ 06594 06595 void arm_var_q15( 06596 q15_t * pSrc, 06597 uint32_t blockSize, 06598 q15_t * pResult); 06599 06600 /** 06601 * @brief Root Mean Square of the elements of a floating-point vector. 06602 * @param[in] *pSrc is input pointer 06603 * @param[in] blockSize is the number of samples to process 06604 * @param[out] *pResult is output value. 06605 * @return none. 06606 */ 06607 06608 void arm_rms_f32( 06609 float32_t * pSrc, 06610 uint32_t blockSize, 06611 float32_t * pResult); 06612 06613 /** 06614 * @brief Root Mean Square of the elements of a Q31 vector. 06615 * @param[in] *pSrc is input pointer 06616 * @param[in] blockSize is the number of samples to process 06617 * @param[out] *pResult is output value. 06618 * @return none. 06619 */ 06620 06621 void arm_rms_q31( 06622 q31_t * pSrc, 06623 uint32_t blockSize, 06624 q31_t * pResult); 06625 06626 /** 06627 * @brief Root Mean Square of the elements of a Q15 vector. 06628 * @param[in] *pSrc is input pointer 06629 * @param[in] blockSize is the number of samples to process 06630 * @param[out] *pResult is output value. 06631 * @return none. 06632 */ 06633 06634 void arm_rms_q15( 06635 q15_t * pSrc, 06636 uint32_t blockSize, 06637 q15_t * pResult); 06638 06639 /** 06640 * @brief Standard deviation of the elements of a floating-point vector. 06641 * @param[in] *pSrc is input pointer 06642 * @param[in] blockSize is the number of samples to process 06643 * @param[out] *pResult is output value. 06644 * @return none. 06645 */ 06646 06647 void arm_std_f32( 06648 float32_t * pSrc, 06649 uint32_t blockSize, 06650 float32_t * pResult); 06651 06652 /** 06653 * @brief Standard deviation of the elements of a Q31 vector. 06654 * @param[in] *pSrc is input pointer 06655 * @param[in] blockSize is the number of samples to process 06656 * @param[out] *pResult is output value. 06657 * @return none. 06658 */ 06659 06660 void arm_std_q31( 06661 q31_t * pSrc, 06662 uint32_t blockSize, 06663 q31_t * pResult); 06664 06665 /** 06666 * @brief Standard deviation of the elements of a Q15 vector. 06667 * @param[in] *pSrc is input pointer 06668 * @param[in] blockSize is the number of samples to process 06669 * @param[out] *pResult is output value. 06670 * @return none. 06671 */ 06672 06673 void arm_std_q15( 06674 q15_t * pSrc, 06675 uint32_t blockSize, 06676 q15_t * pResult); 06677 06678 /** 06679 * @brief Floating-point complex magnitude 06680 * @param[in] *pSrc points to the complex input vector 06681 * @param[out] *pDst points to the real output vector 06682 * @param[in] numSamples number of complex samples in the input vector 06683 * @return none. 06684 */ 06685 06686 void arm_cmplx_mag_f32( 06687 float32_t * pSrc, 06688 float32_t * pDst, 06689 uint32_t numSamples); 06690 06691 /** 06692 * @brief Q31 complex magnitude 06693 * @param[in] *pSrc points to the complex input vector 06694 * @param[out] *pDst points to the real output vector 06695 * @param[in] numSamples number of complex samples in the input vector 06696 * @return none. 06697 */ 06698 06699 void arm_cmplx_mag_q31( 06700 q31_t * pSrc, 06701 q31_t * pDst, 06702 uint32_t numSamples); 06703 06704 /** 06705 * @brief Q15 complex magnitude 06706 * @param[in] *pSrc points to the complex input vector 06707 * @param[out] *pDst points to the real output vector 06708 * @param[in] numSamples number of complex samples in the input vector 06709 * @return none. 06710 */ 06711 06712 void arm_cmplx_mag_q15( 06713 q15_t * pSrc, 06714 q15_t * pDst, 06715 uint32_t numSamples); 06716 06717 /** 06718 * @brief Q15 complex dot product 06719 * @param[in] *pSrcA points to the first input vector 06720 * @param[in] *pSrcB points to the second input vector 06721 * @param[in] numSamples number of complex samples in each vector 06722 * @param[out] *realResult real part of the result returned here 06723 * @param[out] *imagResult imaginary part of the result returned here 06724 * @return none. 06725 */ 06726 06727 void arm_cmplx_dot_prod_q15( 06728 q15_t * pSrcA, 06729 q15_t * pSrcB, 06730 uint32_t numSamples, 06731 q31_t * realResult, 06732 q31_t * imagResult); 06733 06734 /** 06735 * @brief Q31 complex dot product 06736 * @param[in] *pSrcA points to the first input vector 06737 * @param[in] *pSrcB points to the second input vector 06738 * @param[in] numSamples number of complex samples in each vector 06739 * @param[out] *realResult real part of the result returned here 06740 * @param[out] *imagResult imaginary part of the result returned here 06741 * @return none. 06742 */ 06743 06744 void arm_cmplx_dot_prod_q31( 06745 q31_t * pSrcA, 06746 q31_t * pSrcB, 06747 uint32_t numSamples, 06748 q63_t * realResult, 06749 q63_t * imagResult); 06750 06751 /** 06752 * @brief Floating-point complex dot product 06753 * @param[in] *pSrcA points to the first input vector 06754 * @param[in] *pSrcB points to the second input vector 06755 * @param[in] numSamples number of complex samples in each vector 06756 * @param[out] *realResult real part of the result returned here 06757 * @param[out] *imagResult imaginary part of the result returned here 06758 * @return none. 06759 */ 06760 06761 void arm_cmplx_dot_prod_f32( 06762 float32_t * pSrcA, 06763 float32_t * pSrcB, 06764 uint32_t numSamples, 06765 float32_t * realResult, 06766 float32_t * imagResult); 06767 06768 /** 06769 * @brief Q15 complex-by-real multiplication 06770 * @param[in] *pSrcCmplx points to the complex input vector 06771 * @param[in] *pSrcReal points to the real input vector 06772 * @param[out] *pCmplxDst points to the complex output vector 06773 * @param[in] numSamples number of samples in each vector 06774 * @return none. 06775 */ 06776 06777 void arm_cmplx_mult_real_q15( 06778 q15_t * pSrcCmplx, 06779 q15_t * pSrcReal, 06780 q15_t * pCmplxDst, 06781 uint32_t numSamples); 06782 06783 /** 06784 * @brief Q31 complex-by-real multiplication 06785 * @param[in] *pSrcCmplx points to the complex input vector 06786 * @param[in] *pSrcReal points to the real input vector 06787 * @param[out] *pCmplxDst points to the complex output vector 06788 * @param[in] numSamples number of samples in each vector 06789 * @return none. 06790 */ 06791 06792 void arm_cmplx_mult_real_q31( 06793 q31_t * pSrcCmplx, 06794 q31_t * pSrcReal, 06795 q31_t * pCmplxDst, 06796 uint32_t numSamples); 06797 06798 /** 06799 * @brief Floating-point complex-by-real multiplication 06800 * @param[in] *pSrcCmplx points to the complex input vector 06801 * @param[in] *pSrcReal points to the real input vector 06802 * @param[out] *pCmplxDst points to the complex output vector 06803 * @param[in] numSamples number of samples in each vector 06804 * @return none. 06805 */ 06806 06807 void arm_cmplx_mult_real_f32( 06808 float32_t * pSrcCmplx, 06809 float32_t * pSrcReal, 06810 float32_t * pCmplxDst, 06811 uint32_t numSamples); 06812 06813 /** 06814 * @brief Minimum value of a Q7 vector. 06815 * @param[in] *pSrc is input pointer 06816 * @param[in] blockSize is the number of samples to process 06817 * @param[out] *result is output pointer 06818 * @param[in] index is the array index of the minimum value in the input buffer. 06819 * @return none. 06820 */ 06821 06822 void arm_min_q7( 06823 q7_t * pSrc, 06824 uint32_t blockSize, 06825 q7_t * result, 06826 uint32_t * index); 06827 06828 /** 06829 * @brief Minimum value of a Q15 vector. 06830 * @param[in] *pSrc is input pointer 06831 * @param[in] blockSize is the number of samples to process 06832 * @param[out] *pResult is output pointer 06833 * @param[in] *pIndex is the array index of the minimum value in the input buffer. 06834 * @return none. 06835 */ 06836 06837 void arm_min_q15( 06838 q15_t * pSrc, 06839 uint32_t blockSize, 06840 q15_t * pResult, 06841 uint32_t * pIndex); 06842 06843 /** 06844 * @brief Minimum value of a Q31 vector. 06845 * @param[in] *pSrc is input pointer 06846 * @param[in] blockSize is the number of samples to process 06847 * @param[out] *pResult is output pointer 06848 * @param[out] *pIndex is the array index of the minimum value in the input buffer. 06849 * @return none. 06850 */ 06851 void arm_min_q31( 06852 q31_t * pSrc, 06853 uint32_t blockSize, 06854 q31_t * pResult, 06855 uint32_t * pIndex); 06856 06857 /** 06858 * @brief Minimum value of a floating-point vector. 06859 * @param[in] *pSrc is input pointer 06860 * @param[in] blockSize is the number of samples to process 06861 * @param[out] *pResult is output pointer 06862 * @param[out] *pIndex is the array index of the minimum value in the input buffer. 06863 * @return none. 06864 */ 06865 06866 void arm_min_f32( 06867 float32_t * pSrc, 06868 uint32_t blockSize, 06869 float32_t * pResult, 06870 uint32_t * pIndex); 06871 06872 /** 06873 * @brief Maximum value of a Q7 vector. 06874 * @param[in] *pSrc points to the input buffer 06875 * @param[in] blockSize length of the input vector 06876 * @param[out] *pResult maximum value returned here 06877 * @param[out] *pIndex index of maximum value returned here 06878 * @return none. 06879 */ 06880 06881 void arm_max_q7( 06882 q7_t * pSrc, 06883 uint32_t blockSize, 06884 q7_t * pResult, 06885 uint32_t * pIndex); 06886 06887 /** 06888 * @brief Maximum value of a Q15 vector. 06889 * @param[in] *pSrc points to the input buffer 06890 * @param[in] blockSize length of the input vector 06891 * @param[out] *pResult maximum value returned here 06892 * @param[out] *pIndex index of maximum value returned here 06893 * @return none. 06894 */ 06895 06896 void arm_max_q15( 06897 q15_t * pSrc, 06898 uint32_t blockSize, 06899 q15_t * pResult, 06900 uint32_t * pIndex); 06901 06902 /** 06903 * @brief Maximum value of a Q31 vector. 06904 * @param[in] *pSrc points to the input buffer 06905 * @param[in] blockSize length of the input vector 06906 * @param[out] *pResult maximum value returned here 06907 * @param[out] *pIndex index of maximum value returned here 06908 * @return none. 06909 */ 06910 06911 void arm_max_q31( 06912 q31_t * pSrc, 06913 uint32_t blockSize, 06914 q31_t * pResult, 06915 uint32_t * pIndex); 06916 06917 /** 06918 * @brief Maximum value of a floating-point vector. 06919 * @param[in] *pSrc points to the input buffer 06920 * @param[in] blockSize length of the input vector 06921 * @param[out] *pResult maximum value returned here 06922 * @param[out] *pIndex index of maximum value returned here 06923 * @return none. 06924 */ 06925 06926 void arm_max_f32( 06927 float32_t * pSrc, 06928 uint32_t blockSize, 06929 float32_t * pResult, 06930 uint32_t * pIndex); 06931 06932 /** 06933 * @brief Q15 complex-by-complex multiplication 06934 * @param[in] *pSrcA points to the first input vector 06935 * @param[in] *pSrcB points to the second input vector 06936 * @param[out] *pDst points to the output vector 06937 * @param[in] numSamples number of complex samples in each vector 06938 * @return none. 06939 */ 06940 06941 void arm_cmplx_mult_cmplx_q15( 06942 q15_t * pSrcA, 06943 q15_t * pSrcB, 06944 q15_t * pDst, 06945 uint32_t numSamples); 06946 06947 /** 06948 * @brief Q31 complex-by-complex multiplication 06949 * @param[in] *pSrcA points to the first input vector 06950 * @param[in] *pSrcB points to the second input vector 06951 * @param[out] *pDst points to the output vector 06952 * @param[in] numSamples number of complex samples in each vector 06953 * @return none. 06954 */ 06955 06956 void arm_cmplx_mult_cmplx_q31( 06957 q31_t * pSrcA, 06958 q31_t * pSrcB, 06959 q31_t * pDst, 06960 uint32_t numSamples); 06961 06962 /** 06963 * @brief Floating-point complex-by-complex multiplication 06964 * @param[in] *pSrcA points to the first input vector 06965 * @param[in] *pSrcB points to the second input vector 06966 * @param[out] *pDst points to the output vector 06967 * @param[in] numSamples number of complex samples in each vector 06968 * @return none. 06969 */ 06970 06971 void arm_cmplx_mult_cmplx_f32( 06972 float32_t * pSrcA, 06973 float32_t * pSrcB, 06974 float32_t * pDst, 06975 uint32_t numSamples); 06976 06977 /** 06978 * @brief Converts the elements of the floating-point vector to Q31 vector. 06979 * @param[in] *pSrc points to the floating-point input vector 06980 * @param[out] *pDst points to the Q31 output vector 06981 * @param[in] blockSize length of the input vector 06982 * @return none. 06983 */ 06984 void arm_float_to_q31( 06985 float32_t * pSrc, 06986 q31_t * pDst, 06987 uint32_t blockSize); 06988 06989 /** 06990 * @brief Converts the elements of the floating-point vector to Q15 vector. 06991 * @param[in] *pSrc points to the floating-point input vector 06992 * @param[out] *pDst points to the Q15 output vector 06993 * @param[in] blockSize length of the input vector 06994 * @return none 06995 */ 06996 void arm_float_to_q15( 06997 float32_t * pSrc, 06998 q15_t * pDst, 06999 uint32_t blockSize); 07000 07001 /** 07002 * @brief Converts the elements of the floating-point vector to Q7 vector. 07003 * @param[in] *pSrc points to the floating-point input vector 07004 * @param[out] *pDst points to the Q7 output vector 07005 * @param[in] blockSize length of the input vector 07006 * @return none 07007 */ 07008 void arm_float_to_q7( 07009 float32_t * pSrc, 07010 q7_t * pDst, 07011 uint32_t blockSize); 07012 07013 07014 /** 07015 * @brief Converts the elements of the Q31 vector to Q15 vector. 07016 * @param[in] *pSrc is input pointer 07017 * @param[out] *pDst is output pointer 07018 * @param[in] blockSize is the number of samples to process 07019 * @return none. 07020 */ 07021 void arm_q31_to_q15( 07022 q31_t * pSrc, 07023 q15_t * pDst, 07024 uint32_t blockSize); 07025 07026 /** 07027 * @brief Converts the elements of the Q31 vector to Q7 vector. 07028 * @param[in] *pSrc is input pointer 07029 * @param[out] *pDst is output pointer 07030 * @param[in] blockSize is the number of samples to process 07031 * @return none. 07032 */ 07033 void arm_q31_to_q7( 07034 q31_t * pSrc, 07035 q7_t * pDst, 07036 uint32_t blockSize); 07037 07038 /** 07039 * @brief Converts the elements of the Q15 vector to floating-point vector. 07040 * @param[in] *pSrc is input pointer 07041 * @param[out] *pDst is output pointer 07042 * @param[in] blockSize is the number of samples to process 07043 * @return none. 07044 */ 07045 void arm_q15_to_float( 07046 q15_t * pSrc, 07047 float32_t * pDst, 07048 uint32_t blockSize); 07049 07050 07051 /** 07052 * @brief Converts the elements of the Q15 vector to Q31 vector. 07053 * @param[in] *pSrc is input pointer 07054 * @param[out] *pDst is output pointer 07055 * @param[in] blockSize is the number of samples to process 07056 * @return none. 07057 */ 07058 void arm_q15_to_q31( 07059 q15_t * pSrc, 07060 q31_t * pDst, 07061 uint32_t blockSize); 07062 07063 07064 /** 07065 * @brief Converts the elements of the Q15 vector to Q7 vector. 07066 * @param[in] *pSrc is input pointer 07067 * @param[out] *pDst is output pointer 07068 * @param[in] blockSize is the number of samples to process 07069 * @return none. 07070 */ 07071 void arm_q15_to_q7( 07072 q15_t * pSrc, 07073 q7_t * pDst, 07074 uint32_t blockSize); 07075 07076 07077 /** 07078 * @ingroup groupInterpolation 07079 */ 07080 07081 /** 07082 * @defgroup BilinearInterpolate Bilinear Interpolation 07083 * 07084 * Bilinear interpolation is an extension of linear interpolation applied to a two dimensional grid. 07085 * The underlying function <code>f(x, y)</code> is sampled on a regular grid and the interpolation process 07086 * determines values between the grid points. 07087 * Bilinear interpolation is equivalent to two step linear interpolation, first in the x-dimension and then in the y-dimension. 07088 * Bilinear interpolation is often used in image processing to rescale images. 07089 * The CMSIS DSP library provides bilinear interpolation functions for Q7, Q15, Q31, and floating-point data types. 07090 * 07091 * <b>Algorithm</b> 07092 * \par 07093 * The instance structure used by the bilinear interpolation functions describes a two dimensional data table. 07094 * For floating-point, the instance structure is defined as: 07095 * <pre> 07096 * typedef struct 07097 * { 07098 * uint16_t numRows; 07099 * uint16_t numCols; 07100 * float32_t *pData; 07101 * } arm_bilinear_interp_instance_f32; 07102 * </pre> 07103 * 07104 * \par 07105 * where <code>numRows</code> specifies the number of rows in the table; 07106 * <code>numCols</code> specifies the number of columns in the table; 07107 * and <code>pData</code> points to an array of size <code>numRows*numCols</code> values. 07108 * The data table <code>pTable</code> is organized in row order and the supplied data values fall on integer indexes. 07109 * That is, table element (x,y) is located at <code>pTable[x + y*numCols]</code> where x and y are integers. 07110 * 07111 * \par 07112 * Let <code>(x, y)</code> specify the desired interpolation point. Then define: 07113 * <pre> 07114 * XF = floor(x) 07115 * YF = floor(y) 07116 * </pre> 07117 * \par 07118 * The interpolated output point is computed as: 07119 * <pre> 07120 * f(x, y) = f(XF, YF) * (1-(x-XF)) * (1-(y-YF)) 07121 * + f(XF+1, YF) * (x-XF)*(1-(y-YF)) 07122 * + f(XF, YF+1) * (1-(x-XF))*(y-YF) 07123 * + f(XF+1, YF+1) * (x-XF)*(y-YF) 07124 * </pre> 07125 * Note that the coordinates (x, y) contain integer and fractional components. 07126 * The integer components specify which portion of the table to use while the 07127 * fractional components control the interpolation processor. 07128 * 07129 * \par 07130 * if (x,y) are outside of the table boundary, Bilinear interpolation returns zero output. 07131 */ 07132 07133 /** 07134 * @addtogroup BilinearInterpolate 07135 * @{ 07136 */ 07137 07138 /** 07139 * 07140 * @brief Floating-point bilinear interpolation. 07141 * @param[in,out] *S points to an instance of the interpolation structure. 07142 * @param[in] X interpolation coordinate. 07143 * @param[in] Y interpolation coordinate. 07144 * @return out interpolated value. 07145 */ 07146 07147 07148 static __INLINE float32_t arm_bilinear_interp_f32( 07149 const arm_bilinear_interp_instance_f32 * S, 07150 float32_t X, 07151 float32_t Y) 07152 { 07153 float32_t out; 07154 float32_t f00, f01, f10, f11; 07155 float32_t *pData = S->pData; 07156 int32_t xIndex, yIndex, index; 07157 float32_t xdiff, ydiff; 07158 float32_t b1, b2, b3, b4; 07159 07160 xIndex = (int32_t) X; 07161 yIndex = (int32_t) Y; 07162 07163 /* Care taken for table outside boundary */ 07164 /* Returns zero output when values are outside table boundary */ 07165 if(xIndex < 0 || xIndex > (S->numRows - 1) || yIndex < 0 07166 || yIndex > (S->numCols - 1)) 07167 { 07168 return (0); 07169 } 07170 07171 /* Calculation of index for two nearest points in X-direction */ 07172 index = (xIndex - 1) + (yIndex - 1) * S->numCols; 07173 07174 07175 /* Read two nearest points in X-direction */ 07176 f00 = pData[index]; 07177 f01 = pData[index + 1]; 07178 07179 /* Calculation of index for two nearest points in Y-direction */ 07180 index = (xIndex - 1) + (yIndex) * S->numCols; 07181 07182 07183 /* Read two nearest points in Y-direction */ 07184 f10 = pData[index]; 07185 f11 = pData[index + 1]; 07186 07187 /* Calculation of intermediate values */ 07188 b1 = f00; 07189 b2 = f01 - f00; 07190 b3 = f10 - f00; 07191 b4 = f00 - f01 - f10 + f11; 07192 07193 /* Calculation of fractional part in X */ 07194 xdiff = X - xIndex; 07195 07196 /* Calculation of fractional part in Y */ 07197 ydiff = Y - yIndex; 07198 07199 /* Calculation of bi-linear interpolated output */ 07200 out = b1 + b2 * xdiff + b3 * ydiff + b4 * xdiff * ydiff; 07201 07202 /* return to application */ 07203 return (out); 07204 07205 } 07206 07207 /** 07208 * 07209 * @brief Q31 bilinear interpolation. 07210 * @param[in,out] *S points to an instance of the interpolation structure. 07211 * @param[in] X interpolation coordinate in 12.20 format. 07212 * @param[in] Y interpolation coordinate in 12.20 format. 07213 * @return out interpolated value. 07214 */ 07215 07216 static __INLINE q31_t arm_bilinear_interp_q31( 07217 arm_bilinear_interp_instance_q31 * S, 07218 q31_t X, 07219 q31_t Y) 07220 { 07221 q31_t out; /* Temporary output */ 07222 q31_t acc = 0; /* output */ 07223 q31_t xfract, yfract; /* X, Y fractional parts */ 07224 q31_t x1, x2, y1, y2; /* Nearest output values */ 07225 int32_t rI, cI; /* Row and column indices */ 07226 q31_t *pYData = S->pData; /* pointer to output table values */ 07227 uint32_t nCols = S->numCols; /* num of rows */ 07228 07229 07230 /* Input is in 12.20 format */ 07231 /* 12 bits for the table index */ 07232 /* Index value calculation */ 07233 rI = ((X & 0xFFF00000) >> 20u); 07234 07235 /* Input is in 12.20 format */ 07236 /* 12 bits for the table index */ 07237 /* Index value calculation */ 07238 cI = ((Y & 0xFFF00000) >> 20u); 07239 07240 /* Care taken for table outside boundary */ 07241 /* Returns zero output when values are outside table boundary */ 07242 if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) 07243 { 07244 return (0); 07245 } 07246 07247 /* 20 bits for the fractional part */ 07248 /* shift left xfract by 11 to keep 1.31 format */ 07249 xfract = (X & 0x000FFFFF) << 11u; 07250 07251 /* Read two nearest output values from the index */ 07252 x1 = pYData[(rI) + nCols * (cI)]; 07253 x2 = pYData[(rI) + nCols * (cI) + 1u]; 07254 07255 /* 20 bits for the fractional part */ 07256 /* shift left yfract by 11 to keep 1.31 format */ 07257 yfract = (Y & 0x000FFFFF) << 11u; 07258 07259 /* Read two nearest output values from the index */ 07260 y1 = pYData[(rI) + nCols * (cI + 1)]; 07261 y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; 07262 07263 /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 3.29(q29) format */ 07264 out = ((q31_t) (((q63_t) x1 * (0x7FFFFFFF - xfract)) >> 32)); 07265 acc = ((q31_t) (((q63_t) out * (0x7FFFFFFF - yfract)) >> 32)); 07266 07267 /* x2 * (xfract) * (1-yfract) in 3.29(q29) and adding to acc */ 07268 out = ((q31_t) ((q63_t) x2 * (0x7FFFFFFF - yfract) >> 32)); 07269 acc += ((q31_t) ((q63_t) out * (xfract) >> 32)); 07270 07271 /* y1 * (1 - xfract) * (yfract) in 3.29(q29) and adding to acc */ 07272 out = ((q31_t) ((q63_t) y1 * (0x7FFFFFFF - xfract) >> 32)); 07273 acc += ((q31_t) ((q63_t) out * (yfract) >> 32)); 07274 07275 /* y2 * (xfract) * (yfract) in 3.29(q29) and adding to acc */ 07276 out = ((q31_t) ((q63_t) y2 * (xfract) >> 32)); 07277 acc += ((q31_t) ((q63_t) out * (yfract) >> 32)); 07278 07279 /* Convert acc to 1.31(q31) format */ 07280 return (acc << 2u); 07281 07282 } 07283 07284 /** 07285 * @brief Q15 bilinear interpolation. 07286 * @param[in,out] *S points to an instance of the interpolation structure. 07287 * @param[in] X interpolation coordinate in 12.20 format. 07288 * @param[in] Y interpolation coordinate in 12.20 format. 07289 * @return out interpolated value. 07290 */ 07291 07292 static __INLINE q15_t arm_bilinear_interp_q15( 07293 arm_bilinear_interp_instance_q15 * S, 07294 q31_t X, 07295 q31_t Y) 07296 { 07297 q63_t acc = 0; /* output */ 07298 q31_t out; /* Temporary output */ 07299 q15_t x1, x2, y1, y2; /* Nearest output values */ 07300 q31_t xfract, yfract; /* X, Y fractional parts */ 07301 int32_t rI, cI; /* Row and column indices */ 07302 q15_t *pYData = S->pData; /* pointer to output table values */ 07303 uint32_t nCols = S->numCols; /* num of rows */ 07304 07305 /* Input is in 12.20 format */ 07306 /* 12 bits for the table index */ 07307 /* Index value calculation */ 07308 rI = ((X & 0xFFF00000) >> 20); 07309 07310 /* Input is in 12.20 format */ 07311 /* 12 bits for the table index */ 07312 /* Index value calculation */ 07313 cI = ((Y & 0xFFF00000) >> 20); 07314 07315 /* Care taken for table outside boundary */ 07316 /* Returns zero output when values are outside table boundary */ 07317 if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) 07318 { 07319 return (0); 07320 } 07321 07322 /* 20 bits for the fractional part */ 07323 /* xfract should be in 12.20 format */ 07324 xfract = (X & 0x000FFFFF); 07325 07326 /* Read two nearest output values from the index */ 07327 x1 = pYData[(rI) + nCols * (cI)]; 07328 x2 = pYData[(rI) + nCols * (cI) + 1u]; 07329 07330 07331 /* 20 bits for the fractional part */ 07332 /* yfract should be in 12.20 format */ 07333 yfract = (Y & 0x000FFFFF); 07334 07335 /* Read two nearest output values from the index */ 07336 y1 = pYData[(rI) + nCols * (cI + 1)]; 07337 y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; 07338 07339 /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 13.51 format */ 07340 07341 /* x1 is in 1.15(q15), xfract in 12.20 format and out is in 13.35 format */ 07342 /* convert 13.35 to 13.31 by right shifting and out is in 1.31 */ 07343 out = (q31_t) (((q63_t) x1 * (0xFFFFF - xfract)) >> 4u); 07344 acc = ((q63_t) out * (0xFFFFF - yfract)); 07345 07346 /* x2 * (xfract) * (1-yfract) in 1.51 and adding to acc */ 07347 out = (q31_t) (((q63_t) x2 * (0xFFFFF - yfract)) >> 4u); 07348 acc += ((q63_t) out * (xfract)); 07349 07350 /* y1 * (1 - xfract) * (yfract) in 1.51 and adding to acc */ 07351 out = (q31_t) (((q63_t) y1 * (0xFFFFF - xfract)) >> 4u); 07352 acc += ((q63_t) out * (yfract)); 07353 07354 /* y2 * (xfract) * (yfract) in 1.51 and adding to acc */ 07355 out = (q31_t) (((q63_t) y2 * (xfract)) >> 4u); 07356 acc += ((q63_t) out * (yfract)); 07357 07358 /* acc is in 13.51 format and down shift acc by 36 times */ 07359 /* Convert out to 1.15 format */ 07360 return (acc >> 36); 07361 07362 } 07363 07364 /** 07365 * @brief Q7 bilinear interpolation. 07366 * @param[in,out] *S points to an instance of the interpolation structure. 07367 * @param[in] X interpolation coordinate in 12.20 format. 07368 * @param[in] Y interpolation coordinate in 12.20 format. 07369 * @return out interpolated value. 07370 */ 07371 07372 static __INLINE q7_t arm_bilinear_interp_q7( 07373 arm_bilinear_interp_instance_q7 * S, 07374 q31_t X, 07375 q31_t Y) 07376 { 07377 q63_t acc = 0; /* output */ 07378 q31_t out; /* Temporary output */ 07379 q31_t xfract, yfract; /* X, Y fractional parts */ 07380 q7_t x1, x2, y1, y2; /* Nearest output values */ 07381 int32_t rI, cI; /* Row and column indices */ 07382 q7_t *pYData = S->pData; /* pointer to output table values */ 07383 uint32_t nCols = S->numCols; /* num of rows */ 07384 07385 /* Input is in 12.20 format */ 07386 /* 12 bits for the table index */ 07387 /* Index value calculation */ 07388 rI = ((X & 0xFFF00000) >> 20); 07389 07390 /* Input is in 12.20 format */ 07391 /* 12 bits for the table index */ 07392 /* Index value calculation */ 07393 cI = ((Y & 0xFFF00000) >> 20); 07394 07395 /* Care taken for table outside boundary */ 07396 /* Returns zero output when values are outside table boundary */ 07397 if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1)) 07398 { 07399 return (0); 07400 } 07401 07402 /* 20 bits for the fractional part */ 07403 /* xfract should be in 12.20 format */ 07404 xfract = (X & 0x000FFFFF); 07405 07406 /* Read two nearest output values from the index */ 07407 x1 = pYData[(rI) + nCols * (cI)]; 07408 x2 = pYData[(rI) + nCols * (cI) + 1u]; 07409 07410 07411 /* 20 bits for the fractional part */ 07412 /* yfract should be in 12.20 format */ 07413 yfract = (Y & 0x000FFFFF); 07414 07415 /* Read two nearest output values from the index */ 07416 y1 = pYData[(rI) + nCols * (cI + 1)]; 07417 y2 = pYData[(rI) + nCols * (cI + 1) + 1u]; 07418 07419 /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 16.47 format */ 07420 out = ((x1 * (0xFFFFF - xfract))); 07421 acc = (((q63_t) out * (0xFFFFF - yfract))); 07422 07423 /* x2 * (xfract) * (1-yfract) in 2.22 and adding to acc */ 07424 out = ((x2 * (0xFFFFF - yfract))); 07425 acc += (((q63_t) out * (xfract))); 07426 07427 /* y1 * (1 - xfract) * (yfract) in 2.22 and adding to acc */ 07428 out = ((y1 * (0xFFFFF - xfract))); 07429 acc += (((q63_t) out * (yfract))); 07430 07431 /* y2 * (xfract) * (yfract) in 2.22 and adding to acc */ 07432 out = ((y2 * (yfract))); 07433 acc += (((q63_t) out * (xfract))); 07434 07435 /* acc in 16.47 format and down shift by 40 to convert to 1.7 format */ 07436 return (acc >> 40); 07437 07438 } 07439 07440 /** 07441 * @} end of BilinearInterpolate group 07442 */ 07443 07444 07445 //SMMLAR 07446 #define multAcc_32x32_keep32_R(a, x, y) \ 07447 a = (q31_t) (((((q63_t) a) << 32) + ((q63_t) x * y) + 0x80000000LL ) >> 32) 07448 07449 //SMMLSR 07450 #define multSub_32x32_keep32_R(a, x, y) \ 07451 a = (q31_t) (((((q63_t) a) << 32) - ((q63_t) x * y) + 0x80000000LL ) >> 32) 07452 07453 //SMMULR 07454 #define mult_32x32_keep32_R(a, x, y) \ 07455 a = (q31_t) (((q63_t) x * y + 0x80000000LL ) >> 32) 07456 07457 //SMMLA 07458 #define multAcc_32x32_keep32(a, x, y) \ 07459 a += (q31_t) (((q63_t) x * y) >> 32) 07460 07461 //SMMLS 07462 #define multSub_32x32_keep32(a, x, y) \ 07463 a -= (q31_t) (((q63_t) x * y) >> 32) 07464 07465 //SMMUL 07466 #define mult_32x32_keep32(a, x, y) \ 07467 a = (q31_t) (((q63_t) x * y ) >> 32) 07468 07469 07470 #if defined ( __CC_ARM ) //Keil 07471 07472 //Enter low optimization region - place directly above function definition 07473 #ifdef ARM_MATH_CM4 07474 #define LOW_OPTIMIZATION_ENTER \ 07475 _Pragma ("push") \ 07476 _Pragma ("O1") 07477 #else 07478 #define LOW_OPTIMIZATION_ENTER 07479 #endif 07480 07481 //Exit low optimization region - place directly after end of function definition 07482 #ifdef ARM_MATH_CM4 07483 #define LOW_OPTIMIZATION_EXIT \ 07484 _Pragma ("pop") 07485 #else 07486 #define LOW_OPTIMIZATION_EXIT 07487 #endif 07488 07489 //Enter low optimization region - place directly above function definition 07490 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER 07491 07492 //Exit low optimization region - place directly after end of function definition 07493 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT 07494 07495 #elif defined(__ICCARM__) //IAR 07496 07497 //Enter low optimization region - place directly above function definition 07498 #ifdef ARM_MATH_CM4 07499 #define LOW_OPTIMIZATION_ENTER \ 07500 _Pragma ("optimize=low") 07501 #else 07502 #define LOW_OPTIMIZATION_ENTER 07503 #endif 07504 07505 //Exit low optimization region - place directly after end of function definition 07506 #define LOW_OPTIMIZATION_EXIT 07507 07508 //Enter low optimization region - place directly above function definition 07509 #ifdef ARM_MATH_CM4 07510 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER \ 07511 _Pragma ("optimize=low") 07512 #else 07513 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER 07514 #endif 07515 07516 //Exit low optimization region - place directly after end of function definition 07517 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT 07518 07519 #elif defined(__GNUC__) 07520 07521 #define LOW_OPTIMIZATION_ENTER __attribute__(( optimize("-O1") )) 07522 07523 #define LOW_OPTIMIZATION_EXIT 07524 07525 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER 07526 07527 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT 07528 07529 #elif defined(__CSMC__) // Cosmic 07530 07531 #define LOW_OPTIMIZATION_ENTER 07532 #define LOW_OPTIMIZATION_EXIT 07533 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER 07534 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT 07535 07536 #elif defined(__TASKING__) // TASKING 07537 07538 #define LOW_OPTIMIZATION_ENTER 07539 #define LOW_OPTIMIZATION_EXIT 07540 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER 07541 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT 07542 07543 #endif 07544 07545 07546 #ifdef __cplusplus 07547 } 07548 #endif 07549 07550 07551 #endif /* _ARM_MATH_H */ 07552 07553 /** 07554 * 07555 * End of file. 07556 */
Generated on Tue Jul 12 2022 15:10:46 by
1.7.2