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