file_path
stringlengths 20
202
| content
stringlengths 9
3.85M
| size
int64 9
3.85M
| lang
stringclasses 9
values | avg_line_length
float64 3.33
100
| max_line_length
int64 8
993
| alphanum_fraction
float64 0.26
0.93
|
|---|---|---|---|---|---|---|
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_tests.h
|
#ifndef _SUPPORT_TESTS_H_
#define _SUPPORT_TESTS_H_
/*--------------------------------------------------------------------------------*/
/* Test/Group Declarations */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(copy_tests);
JTEST_DECLARE_GROUP(fill_tests);
JTEST_DECLARE_GROUP(x_to_y_tests);
#endif /* _SUPPORT_TESTS_H_ */
| 386 |
C
| 31.249997 | 84 | 0.401554 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_test_group.h
|
#ifndef _SUPPORT_TEST_GROUP_H_
#define _SUPPORT_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(support_tests);
#endif /* _SUPPORT_TEST_GROUP_H_ */
| 332 |
C
| 32.299997 | 84 | 0.343373 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_test_data.h
|
#ifndef ARM_SUPPORT_TEST_DATA_H
#define ARM_SUPPORT_TEST_DATA_H
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arr_desc.h"
/*--------------------------------------------------------------------------------*/
/* Declare Variables */
/*--------------------------------------------------------------------------------*/
/* Input/Output Buffers */
ARR_DESC_DECLARE(support_output_fut);
ARR_DESC_DECLARE(support_output_ref);
/* Block Sizes*/
ARR_DESC_DECLARE(support_block_sizes);
/* Numbers */
ARR_DESC_DECLARE(support_elts);
/* Float Inputs */
ARR_DESC_DECLARE(support_zeros);
ARR_DESC_DECLARE(support_f_2);
ARR_DESC_DECLARE(support_f_15);
ARR_DESC_DECLARE(support_f_32);
ARR_DESC_DECLARE(support_f_all);
#endif
| 865 |
C
| 26.062499 | 84 | 0.436994 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_templates.h
|
#ifndef _SUPPORT_TEMPLATES_H_
#define _SUPPORT_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"
/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/
/**
* Compare the outputs from the function under test and the reference function.
*/
#define SUPPORT_COMPARE_INTERFACE(block_size, \
output_type) \
do \
{ \
TEST_ASSERT_BUFFERS_EQUAL( \
support_output_ref.data_ptr, \
support_output_fut.data_ptr, \
block_size * sizeof(output_type)); \
} while (0) \
/*--------------------------------------------------------------------------------*/
/* Input Interfaces */
/*--------------------------------------------------------------------------------*/
/*
* General:
* Input interfaces provide inputs to functions inside test templates. They
* ONLY provide the inputs. The output variables should be hard coded.
*
* The input interfaces must have the following format:
*
* ARM_xxx_INPUT_INTERFACE() or
* REF_xxx_INPUT_INTERFACE()
*
* The xxx must be lowercase, and is intended to be the indentifying substring
* in the function's name. Acceptable values are 'sub' or 'add' from the
* functions arm_add_q31.
*/
#define ARM_copy_INPUT_INTERFACE(input, block_size) \
PAREN(input, support_output_fut.data_ptr, block_size)
#define REF_copy_INPUT_INTERFACE(input, block_size) \
PAREN(input, support_output_ref.data_ptr, block_size)
#define ARM_fill_INPUT_INTERFACE(elt, block_size) \
PAREN(elt, support_output_fut.data_ptr, block_size)
#define REF_fill_INPUT_INTERFACE(elt, block_size) \
PAREN(elt, support_output_ref.data_ptr, block_size)
#define ARM_x_to_y_INPUT_INTERFACE(input, block_size) \
PAREN(input, support_output_fut.data_ptr, block_size)
#define REF_x_to_y_INPUT_INTERFACE(input, block_size) \
PAREN(input, support_output_ref.data_ptr, block_size)
/*--------------------------------------------------------------------------------*/
/* Test Templates */
/*--------------------------------------------------------------------------------*/
/**
* Specialization of #TEST_TEMPLATE_BUF1_BLK() for support tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define SUPPORT_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name, \
suffix, \
input_type, \
output_type, \
comparison_interface) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_BUF1_BLK( \
support_f_all, \
support_block_sizes, \
input_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
comparison_interface); \
}
/**
* Specialization of #TEST_TEMPLATE_ELT1_BLK() for support tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define SUPPORT_DEFINE_TEST_TEMPLATE_ELT1_BLK(fn_name, \
suffix, \
elt_type, \
output_type, \
comparison_interface) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_ELT1_BLK( \
support_elts, \
support_block_sizes, \
elt_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
comparison_interface); \
}
#endif /* _SUPPORT_TEMPLATES_H_ */
| 5,539 |
C
| 44.785124 | 84 | 0.368659 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_test_group.h
|
#ifndef _FILTERING_TEST_GROUP_H_
#define _FILTERING_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(filtering_tests);
#endif /* _FILTERING_TEST_GROUP_H_ */
| 340 |
C
| 33.099997 | 84 | 0.358824 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_tests.h
|
#ifndef _FILTERING_TESTS_H_
#define _FILTERING_TESTS_H_
/*--------------------------------------------------------------------------------*/
/* Test/Group Declarations */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(biquad_tests);
JTEST_DECLARE_GROUP(conv_tests);
JTEST_DECLARE_GROUP(correlate_tests);
JTEST_DECLARE_GROUP(fir_tests);
JTEST_DECLARE_GROUP(iir_tests);
JTEST_DECLARE_GROUP(lms_tests);
#endif /* _FILTERING_TESTS_H_ */
| 494 |
C
| 29.937498 | 84 | 0.491903 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_templates.h
|
#ifndef _FILTERING_TEMPLATES_H_
#define _FILTERING_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"
/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/
/*
* Comparison SNR thresholds for the data types used in statistics_tests.
*/
#define FILTERING_SNR_THRESHOLD_float64_t 120
#define FILTERING_SNR_THRESHOLD_float32_t 99
#define FILTERING_SNR_THRESHOLD_q31_t 90
#define FILTERING_SNR_THRESHOLD_q15_t 60
#define FILTERING_SNR_THRESHOLD_q7_t 30
/**
* Compare reference and fut outputs using SNR.
*
* @note The outputs are converted to float32_t before comparison.
*/
#define FILTERING_SNR_COMPARE_INTERFACE(block_size, \
output_type) \
FILTERING_SNR_COMPARE_INTERFACE_OFFSET(0, block_size, output_type)
/**
* Compare reference and fut outputs starting at some offset using SNR.
*/
#define FILTERING_SNR_COMPARE_INTERFACE_OFFSET(offset, \
block_size, \
output_type) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
filtering_output_f32_ref, \
(output_type *) filtering_output_ref + offset, \
filtering_output_f32_fut, \
(output_type *) filtering_output_fut + offset, \
block_size, \
output_type, \
FILTERING_SNR_THRESHOLD_##output_type \
); \
} while (0)
/**
* Compare reference and fut outputs starting at some offset using SNR.
* Special case for float64_t
*/
#define FILTERING_DBL_SNR_COMPARE_INTERFACE(block_size, \
output_type) \
do \
{ \
TEST_ASSERT_DBL_SNR( \
(float64_t*)filtering_output_ref, \
(float64_t*)filtering_output_fut, \
block_size, \
FILTERING_SNR_THRESHOLD_##output_type \
); \
} while (0)
/*--------------------------------------------------------------------------------*/
/* Input Interfaces */
/*--------------------------------------------------------------------------------*/
/*
* General:
* Input interfaces provide inputs to functions inside test templates. They
* ONLY provide the inputs. The output variables should be hard coded.
*
* The input interfaces must have the following format:
*
* ARM_xxx_INPUT_INTERFACE() or
* REF_xxx_INPUT_INTERFACE()
*
* The xxx must be lowercase, and is intended to be the indentifying substring
* in the function's name. Acceptable values are 'sub' or 'add' from the
* functions arm_add_q31.
*/
/*--------------------------------------------------------------------------------*/
/* Test Templates */
/*--------------------------------------------------------------------------------*/
#endif /* _FILTERING_TEMPLATES_H_ */
| 3,851 |
C
| 40.869565 | 84 | 0.386133 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_test_data.h
|
#ifndef FILTERING_TEST_DATA_H
#define FILTERING_TEST_DATA_H
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arr_desc.h"
#include "arm_math.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define FILTERING_MAX_BLOCKSIZE 33
#define LMS_MAX_BLOCKSIZE 512
#define FILTERING_MAX_NUMTAPS 34
#define FILTERING_MAX_NUMSTAGES 14
#define FILTERING_MAX_POSTSHIFT 8
#define FILTERING_MAX_TAP_DELAY 0xFF
#define FILTERING_MAX_L 3
#define FILTERING_MAX_M 33
/*--------------------------------------------------------------------------------*/
/* Declare Variables */
/*--------------------------------------------------------------------------------*/
/* Input/Output Buffers */
extern float32_t filtering_output_fut[LMS_MAX_BLOCKSIZE*2];
extern float32_t filtering_output_ref[LMS_MAX_BLOCKSIZE*2];
extern float32_t filtering_output_f32_fut[LMS_MAX_BLOCKSIZE*2];
extern float32_t filtering_output_f32_ref[LMS_MAX_BLOCKSIZE*2];
extern float32_t filtering_input_lms[LMS_MAX_BLOCKSIZE*2];
extern float32_t filtering_pState[LMS_MAX_BLOCKSIZE + FILTERING_MAX_NUMTAPS];
extern float32_t filtering_scratch[FILTERING_MAX_BLOCKSIZE * 3];
extern float32_t filtering_scratch2[FILTERING_MAX_BLOCKSIZE * 3];
extern float32_t filtering_coeffs_lms[FILTERING_MAX_NUMTAPS];
extern const float64_t filtering_f64_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
extern const float32_t filtering_f32_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
extern const q31_t filtering_q31_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
extern const q15_t * filtering_q15_inputs;
extern const q7_t * filtering_q7_inputs;
/* Block Sizes */
ARR_DESC_DECLARE(filtering_blocksizes);
ARR_DESC_DECLARE(lms_blocksizes);
ARR_DESC_DECLARE(filtering_numtaps);
ARR_DESC_DECLARE(filtering_numtaps2);
ARR_DESC_DECLARE(filtering_postshifts);
ARR_DESC_DECLARE(filtering_numstages);
ARR_DESC_DECLARE(filtering_Ls);
ARR_DESC_DECLARE(filtering_Ms);
/* Coefficient Lists */
extern const float64_t filtering_coeffs_f64[FILTERING_MAX_NUMSTAGES * 6 + 2];
extern const float64_t filtering_coeffs_b_f64[FILTERING_MAX_NUMSTAGES * 6 + 2];
extern const float32_t filtering_coeffs_f32[FILTERING_MAX_NUMSTAGES * 6 + 2];
extern const float32_t filtering_coeffs_b_f32[FILTERING_MAX_NUMSTAGES * 6 + 2];
extern const float32_t *filtering_coeffs_c_f32;
extern float32_t filtering_coeffs_lms_f32[FILTERING_MAX_NUMTAPS];
extern const q31_t filtering_coeffs_q31[FILTERING_MAX_NUMSTAGES * 6 + 2];
extern const q31_t *filtering_coeffs_b_q31;
extern const q31_t *filtering_coeffs_c_q31;
extern q31_t filtering_coeffs_lms_q31[FILTERING_MAX_NUMTAPS];
extern const q15_t filtering_coeffs_q15[FILTERING_MAX_NUMSTAGES * 6 + 4];
extern const q15_t *filtering_coeffs_b_q15;
extern const q15_t *filtering_coeffs_c_q15;
extern q15_t filtering_coeffs_lms_q15[FILTERING_MAX_NUMTAPS];
extern const q7_t filtering_coeffs_q7[FILTERING_MAX_NUMSTAGES * 6 + 8];
extern const q7_t *filtering_coeffs_b_q7;
extern const q7_t *filtering_coeffs_c_q7;
/* Tap Delay Lists */
extern const int32_t filtering_tap_delay[FILTERING_MAX_NUMTAPS];
/* Numbers */
/* Float Inputs */
#endif
| 3,481 |
C
| 41.463414 | 111 | 0.65757 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_tests.h
|
#ifndef _CONTROLLER_TESTS_H_
#define _CONTROLLER_TESTS_H_
/*--------------------------------------------------------------------------------*/
/* Test/Group Declarations */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(pid_reset_tests);
JTEST_DECLARE_GROUP(sin_cos_tests);
JTEST_DECLARE_GROUP(pid_tests);
#endif /* _CONTROLLER_TESTS_H_ */
| 400 |
C
| 32.416664 | 84 | 0.4225 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_templates.h
|
#ifndef _CONTROLLER_TEMPLATES_H_
#define _CONTROLLER_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"
#include <string.h> /* memcpy() */
/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/
/**
* Comparison SNR thresholds for the data types used in transform_tests.
*/
#define CONTROLLER_SNR_THRESHOLD_float32_t 110
#define CONTROLLER_SNR_THRESHOLD_q31_t 100
#define CONTROLLER_SNR_THRESHOLD_q15_t 45
/**
* Compare the outputs from the function under test and the reference
* function using SNR.
*/
#define CONTROLLER_SNR_COMPARE_INTERFACE(block_size, \
output_type) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
controller_output_f32_ref, \
(output_type *) controller_output_ref, \
controller_output_f32_fut, \
(output_type *) controller_output_fut, \
block_size, \
output_type, \
CONTROLLER_SNR_THRESHOLD_##output_type \
); \
} while (0)
/*--------------------------------------------------------------------------------*/
/* TEST Templates */
/*--------------------------------------------------------------------------------*/
#endif /* _CONTROLLER_TEMPLATES_H_ */
| 1,858 |
C
| 38.553191 | 84 | 0.342842 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_test_group.h
|
#ifndef _CONTROLLER_TEST_GROUP_H_
#define _CONTROLLER_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Group */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(controller_tests);
#endif /* _CONTROLLER_TEST_GROUP_H_ */
| 343 |
C
| 33.399997 | 84 | 0.364431 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_test_data.h
|
#ifndef _CONTROLLER_TEST_DATA_H_
#define _CONTROLLER_TEST_DATA_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arm_math.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define CONTROLLER_MAX_LEN 1024
#define CONTROLLER_MAX_COEFFS_LEN (12 * 3)
#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
/*--------------------------------------------------------------------------------*/
/* Variable Declarations */
/*--------------------------------------------------------------------------------*/
extern float32_t controller_output_fut[CONTROLLER_MAX_LEN];
extern float32_t controller_output_ref[CONTROLLER_MAX_LEN];
extern float32_t controller_output_f32_fut[CONTROLLER_MAX_LEN];
extern float32_t controller_output_f32_ref[CONTROLLER_MAX_LEN];
extern const float32_t controller_f32_inputs[CONTROLLER_MAX_LEN];
extern const q31_t controller_q31_inputs[CONTROLLER_MAX_LEN];
extern const q15_t * controller_q15_inputs;
extern const float32_t controller_f32_coeffs[CONTROLLER_MAX_COEFFS_LEN];
extern const q31_t controller_q31_coeffs[CONTROLLER_MAX_COEFFS_LEN];
extern const q15_t controller_q15_coeffs[CONTROLLER_MAX_COEFFS_LEN];
#endif /* _CONTROLLER_TEST_DATA_H_ */
| 1,463 |
C
| 42.058822 | 84 | 0.50581 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_templates.h
|
#ifndef _MATRIX_TEMPLATES_H_
#define _MATRIX_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"
/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/
/**
* Compare the outputs from the function under test and the reference
* function.
*/
#define MATRIX_COMPARE_INTERFACE(output_type, output_content_type) \
TEST_ASSERT_BUFFERS_EQUAL( \
((output_type *) &matrix_output_ref)->pData, \
((output_type *) &matrix_output_fut)->pData, \
((output_type *) &matrix_output_fut)->numRows * \
((output_type *) &matrix_output_ref)->numCols * \
sizeof(output_content_type))
/**
* Comparison SNR thresholds for the data types used in matrix_tests.
*/
#define MATRIX_SNR_THRESHOLD 120
/**
* Compare the outputs from the function under test and the reference
* function using SNR.
*/
#define MATRIX_SNR_COMPARE_INTERFACE(output_type, output_content_type) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
(float32_t *)matrix_output_f32_ref, \
((output_type *) &matrix_output_ref)->pData, \
(float32_t *)matrix_output_f32_fut, \
((output_type *) &matrix_output_ref)->pData, \
((output_type *) &matrix_output_fut)->numRows * \
((output_type *) &matrix_output_ref)->numCols, \
output_content_type, \
MATRIX_SNR_THRESHOLD \
); \
} while (0)
/**
* Compare the outputs from the function under test and the reference
* function using SNR. This is special for float64_t
*/
#define MATRIX_DBL_SNR_COMPARE_INTERFACE(output_type) \
do \
{ \
TEST_ASSERT_DBL_SNR( \
(float64_t *)matrix_output_f32_ref, \
(float64_t *)matrix_output_f32_fut, \
((output_type *) &matrix_output_fut)->numRows * \
((output_type *) &matrix_output_ref)->numCols, \
MATRIX_SNR_THRESHOLD \
); \
} while (0)
/*--------------------------------------------------------------------------------*/
/* Input Interfaces */
/*--------------------------------------------------------------------------------*/
/*
* General:
* Input interfaces provide inputs to functions inside test templates. They
* ONLY provide the inputs. The output variables should be hard coded.
*
* The input interfaces must have the following format:
*
* ARM_xxx_INPUT_INTERFACE() or
* REF_xxx_INPUT_INTERFACE()
*
* The xxx must be lowercase, and is intended to be the indentifying substring
* in the function's name. Acceptable values are 'sub' or 'add' from the
* functions arm_add_q31.
*/
#define ARM_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
#define REF_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
#define ARM_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
#define REF_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
#define ARM_mat_inverse_INPUT_INTERFACE(input_ptr) \
PAREN(input_ptr, (void *) &matrix_output_fut)
#define REF_mat_inverse_INPUT_INTERFACE(input_ptr) \
PAREN(input_ptr, (void *) &matrix_output_ref)
#define ARM_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
#define REF_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
#define ARM_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
#define REF_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
#define ARM_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
#define REF_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
#define ARM_mat_trans_INPUT_INTERFACE(input_ptr) \
PAREN(input_ptr, (void *) &matrix_output_fut)
#define REF_mat_trans_INPUT_INTERFACE(input_ptr) \
PAREN(input_ptr, (void *) &matrix_output_ref)
/*--------------------------------------------------------------------------------*/
/* Dimension Validation Interfaces */
/*--------------------------------------------------------------------------------*/
#define MATRIX_TEST_VALID_ADDITIVE_DIMENSIONS(input_type, \
matrix_a_ptr, \
matrix_b_ptr) \
((((input_type) (matrix_a_ptr))->numRows == \
((input_type) (matrix_b_ptr))->numRows) && \
(((input_type) (matrix_a_ptr))->numCols == \
((input_type) (matrix_b_ptr))->numCols))
#define MATRIX_TEST_VALID_MULTIPLICATIVE_DIMENSIONS(input_type, \
matrix_a_ptr, \
matrix_b_ptr) \
(((input_type) (matrix_a_ptr))->numCols == \
((input_type) (matrix_b_ptr))->numRows)
#define MATRIX_TEST_VALID_SQUARE_DIMENSIONS(input_type, \
matrix_ptr) \
(((input_type)(matrix_ptr))->numRows == \
((input_type)(matrix_ptr))->numCols)
#define MATRIX_TEST_VALID_DIMENSIONS_ALWAYS(input_type, \
matrix_ptr) \
(1 == 1) \
/*--------------------------------------------------------------------------------*/
/* Output Configuration Interfaces */
/*--------------------------------------------------------------------------------*/
/* The matrix tests assume the output matrix is always the correct size. These
* interfaces size the properly size the output matrices according to the input
* matrices and the operation at hand.*/
#define MATRIX_TEST_CONFIG_ADDITIVE_OUTPUT(input_type, \
matrix_a_ptr, \
matrix_b_ptr) \
do \
{ \
((input_type) &matrix_output_fut)->numRows = \
((input_type)(matrix_a_ptr))->numRows; \
((input_type) &matrix_output_fut)->numCols = \
((input_type)(matrix_a_ptr))->numCols; \
((input_type) &matrix_output_ref)->numRows = \
((input_type)(matrix_a_ptr))->numRows; \
((input_type) &matrix_output_ref)->numCols = \
((input_type)(matrix_a_ptr))->numCols; \
} while (0)
#define MATRIX_TEST_CONFIG_MULTIPLICATIVE_OUTPUT(input_type, \
matrix_a_ptr, \
matrix_b_ptr) \
do \
{ \
((input_type) &matrix_output_fut)->numRows = \
((input_type)(matrix_a_ptr))->numRows; \
((input_type) &matrix_output_fut)->numCols = \
((input_type)(matrix_b_ptr))->numCols; \
((input_type) &matrix_output_ref)->numRows = \
((input_type)(matrix_a_ptr))->numRows; \
((input_type) &matrix_output_ref)->numCols = \
((input_type)(matrix_b_ptr))->numCols; \
} while (0)
#define MATRIX_TEST_CONFIG_SAMESIZE_OUTPUT(input_type, \
matrix_ptr) \
do \
{ \
((input_type) &matrix_output_fut)->numRows = \
((input_type)(matrix_ptr))->numRows; \
((input_type) &matrix_output_fut)->numCols = \
((input_type)(matrix_ptr))->numCols; \
((input_type) &matrix_output_ref)->numRows = \
((input_type)(matrix_ptr))->numRows; \
((input_type) &matrix_output_ref)->numCols = \
((input_type)(matrix_ptr))->numCols; \
} while (0)
#define MATRIX_TEST_CONFIG_TRANSPOSE_OUTPUT(input_type, \
matrix_ptr) \
do \
{ \
((input_type) &matrix_output_fut)->numRows = \
((input_type)(matrix_ptr))->numCols; \
((input_type) &matrix_output_fut)->numCols = \
((input_type)(matrix_ptr))->numRows; \
((input_type) &matrix_output_ref)->numRows = \
((input_type)(matrix_ptr))->numCols; \
((input_type) &matrix_output_ref)->numCols = \
((input_type)(matrix_ptr))->numRows; \
} while (0)
/*--------------------------------------------------------------------------------*/
/* TEST Templates */
/*--------------------------------------------------------------------------------*/
#define MATRIX_TEST_TEMPLATE_ELT1(arr_desc_inputs, \
input_type, \
output_type, output_content_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
output_config_interface, \
dim_validation_interface, \
compare_interface) \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
input_idx, input_type, input, arr_desc_inputs \
, \
JTEST_DUMP_STRF("Matrix Dimensions: %dx%d\n", \
(int)input->numRows, \
(int)input->numCols); \
\
if (dim_validation_interface(input_type, \
input)) { \
output_config_interface(input_type, \
input); \
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface(input), \
ref, ref_arg_interface(input)); \
compare_interface(output_type, \
output_content_type); \
} else { \
arm_status matrix_test_retval; \
TEST_CALL_FUT( \
matrix_test_retval = fut, \
fut_arg_interface(input)); \
\
/* If dimensions are known bad, the fut should */ \
/* detect it. */ \
if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) { \
return JTEST_TEST_FAILED; \
} \
}); \
return JTEST_TEST_PASSED; \
} while (0)
#define MATRIX_TEST_TEMPLATE_ELT2(arr_desc_inputs_a, \
arr_desc_inputs_b, \
input_type, \
output_type, output_content_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
output_config_interface, \
dim_validation_interface, \
compare_interface) \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
input_a_idx, input_type, input_a, arr_desc_inputs_a \
, \
input_type input_b = ARR_DESC_ELT( \
input_type, input_a_idx, \
&(arr_desc_inputs_b)); \
\
JTEST_DUMP_STRF("Matrix Dimensions: A %dx%d B %dx%d\n", \
(int)input_a->numRows, \
(int)input_a->numCols, \
(int)input_b->numRows, \
(int)input_b->numCols); \
\
if (dim_validation_interface(input_type, \
input_a, \
input_b)) { \
\
output_config_interface(input_type, \
input_a, \
input_b); \
\
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface(input_a, input_b), \
ref, ref_arg_interface(input_a, input_b)); \
\
compare_interface(output_type, output_content_type); \
\
} else { \
arm_status matrix_test_retval; \
TEST_CALL_FUT( \
matrix_test_retval = fut, fut_arg_interface(input_a, input_b)); \
\
/* If dimensions are known bad, the fut should */ \
/* detect it. */ \
if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) { \
return JTEST_TEST_FAILED; \
} \
}); \
return JTEST_TEST_PASSED; \
} while (0)
/**
* Specialization of #MATRIX_TEST_TEMPLATE_ELT2() for matrix tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define MATRIX_DEFINE_TEST_TEMPLATE_ELT2(fn_name, suffix, \
output_config_interface, \
dim_validation_interface, \
comparison_interface) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
MATRIX_TEST_TEMPLATE_ELT2( \
matrix_##suffix##_a_inputs, \
matrix_##suffix##_b_inputs, \
arm_matrix_instance_##suffix * , \
arm_matrix_instance_##suffix, \
TYPE_FROM_ABBREV(suffix), \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
output_config_interface, \
dim_validation_interface, \
comparison_interface); \
} \
/**
* Specialization of #MATRIX_TEST_TEMPLATE_ELT1() for matrix tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define MATRIX_DEFINE_TEST_TEMPLATE_ELT1(fn_name, suffix, \
output_config_interface, \
dim_validation_interface) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
MATRIX_TEST_TEMPLATE_ELT1( \
matrix_##suffix##_a_inputs, \
arm_matrix_instance_##suffix * , \
arm_matrix_instance_##suffix, \
TYPE_FROM_ABBREV(suffix), \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
output_config_interface, \
dim_validation_interface, \
MATRIX_COMPARE_INTERFACE); \
} \
#endif /* _MATRIX_TEMPLATES_H_ */
| 20,533 |
C
| 54.347709 | 85 | 0.348269 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_tests.h
|
#ifndef _MATRIX_TESTS_H_
#define _MATRIX_TESTS_H_
/*--------------------------------------------------------------------------------*/
/* Test/Group Declarations */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(mat_add_tests);
JTEST_DECLARE_GROUP(mat_cmplx_mult_tests);
JTEST_DECLARE_GROUP(mat_init_tests);
JTEST_DECLARE_GROUP(mat_inverse_tests);
JTEST_DECLARE_GROUP(mat_mult_tests);
JTEST_DECLARE_GROUP(mat_mult_fast_tests);
JTEST_DECLARE_GROUP(mat_sub_tests);
JTEST_DECLARE_GROUP(mat_trans_tests);
JTEST_DECLARE_GROUP(mat_scale_tests);
#endif /* _MATRIX_TESTS_H_ */
| 629 |
C
| 33.999998 | 84 | 0.551669 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_test_data.h
|
#ifndef _MATRIX_TEST_DATA_H_
#define _MATRIX_TEST_DATA_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arr_desc.h"
#include "arm_math.h" /* float32_t */
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define MATRIX_TEST_MAX_ROWS 4
#define MATRIX_TEST_MAX_COLS 4
#define MATRIX_TEST_BIGGEST_INPUT_TYPE float64_t
#define MATRIX_TEST_MAX_ELTS (MATRIX_TEST_MAX_ROWS * MATRIX_TEST_MAX_COLS)
#define MATRIX_MAX_COEFFS_LEN 16
#define MATRIX_MAX_SHIFTS_LEN 5
/**
* Declare the matrix inputs defined by MATRIX_DEFINE_INPUTS.
*/
#define MATRIX_DECLARE_INPUTS(suffix) \
ARR_DESC_DECLARE(matrix_##suffix##_a_inputs); \
ARR_DESC_DECLARE(matrix_##suffix##_b_inputs); \
ARR_DESC_DECLARE(matrix_##suffix##_invertible_inputs)
/*--------------------------------------------------------------------------------*/
/* Declare Variables */
/*--------------------------------------------------------------------------------*/
/* Input/Output Buffers */
extern arm_matrix_instance_f32 matrix_output_fut;
extern arm_matrix_instance_f32 matrix_output_ref;
extern arm_matrix_instance_f64 matrix_output_fut64;
extern arm_matrix_instance_f64 matrix_output_ref64;
extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_f32_fut[MATRIX_TEST_MAX_ELTS];
extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_f32_ref[MATRIX_TEST_MAX_ELTS];
extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_scratch[MATRIX_TEST_MAX_ELTS];
/* Matrix Inputs */
MATRIX_DECLARE_INPUTS(f64);
MATRIX_DECLARE_INPUTS(f32);
MATRIX_DECLARE_INPUTS(q31);
MATRIX_DECLARE_INPUTS(q15);
extern const float32_t matrix_f32_scale_values[MATRIX_MAX_COEFFS_LEN];
extern const q31_t matrix_q31_scale_values[MATRIX_MAX_COEFFS_LEN];
extern const q15_t matrix_q15_scale_values[MATRIX_MAX_COEFFS_LEN];
extern const int32_t matrix_shift_values[MATRIX_MAX_SHIFTS_LEN];
#endif /* _MATRIX_TEST_DATA_H_ */
| 2,170 |
C
| 38.472727 | 84 | 0.565438 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_test_group.h
|
#ifndef _MATRIX_TEST_GROUP_H_
#define _MATRIX_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(matrix_tests);
#endif /* _MATRIX_TEST_GROUP_H_ */
| 328 |
C
| 31.899997 | 84 | 0.335366 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/intrinsics_tests/intrinsics_test_group.h
|
#ifndef _INTRINSICS_TEST_GROUP_H_
#define _INTRINSICS_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(intrinsics_tests);
#endif /* _INTRINSICS_TEST_GROUP_H_ */
| 344 |
C
| 33.499997 | 84 | 0.366279 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/intrinsics_tests/intrinsics_test_data.h
|
#ifndef _INTRINSICS_TEST_DATA_H_
#define _INTRINSICS_TEST_DATA_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arm_math.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define INTRINSICS_MAX_LEN 1024
/*--------------------------------------------------------------------------------*/
/* Variable Declarations */
/*--------------------------------------------------------------------------------*/
extern q63_t intrinsics_output_fut[INTRINSICS_MAX_LEN];
extern q63_t intrinsics_output_ref[INTRINSICS_MAX_LEN];
extern float32_t intrinsics_output_f32_fut[INTRINSICS_MAX_LEN];
extern float32_t intrinsics_output_f32_ref[INTRINSICS_MAX_LEN];
extern const q63_t intrinsics_q63_inputs[INTRINSICS_MAX_LEN];
extern const q31_t *intrinsics_q31_inputs;
#endif /* _INTRINSICS_TEST_DATA_H_ */
| 1,088 |
C
| 37.892856 | 84 | 0.401654 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_test_data.h
|
#ifndef _STATISTICS_TEST_DATA_H_
#define _STATISTICS_TEST_DATA_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arr_desc.h"
#include "arm_math.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define STATISTICS_MAX_INPUT_ELEMENTS 32
#define STATISTICS_BIGGEST_INPUT_TYPE float32_t
/*--------------------------------------------------------------------------------*/
/* Declare Variables */
/*--------------------------------------------------------------------------------*/
/* Input/Output Buffers */
ARR_DESC_DECLARE(statistics_output_fut);
ARR_DESC_DECLARE(statistics_output_ref);
extern uint32_t statistics_idx_fut;
extern uint32_t statistics_idx_ref;
extern STATISTICS_BIGGEST_INPUT_TYPE
statistics_output_f32_ref[STATISTICS_MAX_INPUT_ELEMENTS];
extern STATISTICS_BIGGEST_INPUT_TYPE
statistics_output_f32_fut[STATISTICS_MAX_INPUT_ELEMENTS];
/* Block Sizes */
ARR_DESC_DECLARE(statistics_block_sizes);
/* Float Inputs */
ARR_DESC_DECLARE(statistics_zeros);
ARR_DESC_DECLARE(statistics_f_2);
ARR_DESC_DECLARE(statistics_f_15);
ARR_DESC_DECLARE(statistics_f_32);
ARR_DESC_DECLARE(statistics_f_all);
#endif /* _STATISTICS_TEST_DATA_H_ */
| 1,448 |
C
| 31.199999 | 84 | 0.491713 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_templates.h
|
#ifndef _STATISTICS_TEMPLATES_H_
#define _STATISTICS_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"
/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/
/**
* Compare the outputs from the function under test and the reference function.
*/
#define STATISTICS_COMPARE_INTERFACE(block_size, \
output_type) \
do \
{ \
TEST_ASSERT_BUFFERS_EQUAL( \
statistics_output_ref.data_ptr, \
statistics_output_fut.data_ptr, \
1 * sizeof(output_type) /* All fns return one value*/ \
); \
TEST_ASSERT_EQUAL( \
statistics_idx_fut, \
statistics_idx_ref); \
} while (0) \
/*
* Comparison SNR thresholds for the data types used in statistics_tests.
*/
#define STATISTICS_SNR_THRESHOLD_float32_t 120
#define STATISTICS_SNR_THRESHOLD_q31_t 100
#define STATISTICS_SNR_THRESHOLD_q15_t 60
#define STATISTICS_SNR_THRESHOLD_q7_t 30
/**
* Compare reference and fut outputs using SNR.
*
* @note The outputs are converted to float32_t before comparison.
*/
#define STATISTICS_SNR_COMPARE_INTERFACE(block_size, \
output_type) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
statistics_output_f32_ref, \
statistics_output_ref.data_ptr, \
statistics_output_f32_fut, \
statistics_output_fut.data_ptr, \
1, /* All fns return one element*/ \
output_type, \
STATISTICS_SNR_THRESHOLD_##output_type \
); \
} while (0)
/*--------------------------------------------------------------------------------*/
/* Input Interfaces */
/*--------------------------------------------------------------------------------*/
/*
* General:
* Input interfaces provide inputs to functions inside test templates. They
* ONLY provide the inputs. The output variables should be hard coded.
*
* The input interfaces must have the following format:
*
* ARM_xxx_INPUT_INTERFACE() or
* REF_xxx_INPUT_INTERFACE()
*
* The xxx must be lowercase, and is intended to be the indentifying substring
* in the function's name. Acceptable values are 'sub' or 'add' from the
* functions arm_add_q31.
*/
#define ARM_max_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, \
statistics_output_fut.data_ptr, &statistics_idx_fut)
#define REF_max_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, \
statistics_output_ref.data_ptr, &statistics_idx_ref)
#define ARM_mean_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_fut.data_ptr)
#define REF_mean_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_ref.data_ptr)
#define ARM_min_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, \
statistics_output_fut.data_ptr, &statistics_idx_fut)
#define REF_min_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, \
statistics_output_ref.data_ptr, &statistics_idx_ref)
#define ARM_power_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_fut.data_ptr)
#define REF_power_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_ref.data_ptr)
#define ARM_rms_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_fut.data_ptr)
#define REF_rms_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_ref.data_ptr)
#define ARM_std_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_fut.data_ptr)
#define REF_std_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_ref.data_ptr)
#define ARM_var_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_fut.data_ptr)
#define REF_var_INPUT_INTERFACE(input, block_size) \
PAREN(input, block_size, statistics_output_ref.data_ptr)
/*--------------------------------------------------------------------------------*/
/* Test Templates */
/*--------------------------------------------------------------------------------*/
/**
* Specialization of #TEST_TEMPLATE_BUF1_BLK() for statistics tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name, \
suffix, \
input_type, \
output_type, \
comparison_interface) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_BUF1_BLK( \
statistics_f_all, \
statistics_block_sizes, \
input_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
comparison_interface); \
}
#endif /* _STATISTICS_TEMPLATES_H_ */
| 6,811 |
C
| 42.113924 | 84 | 0.442373 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_tests.h
|
#ifndef _STATISTICS_TESTS_H_
#define _STATISTICS_TESTS_H_
/*--------------------------------------------------------------------------------*/
/* Test/Group Declarations */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(max_tests);
JTEST_DECLARE_GROUP(mean_tests);
JTEST_DECLARE_GROUP(min_tests);
JTEST_DECLARE_GROUP(power_tests);
JTEST_DECLARE_GROUP(rms_tests);
JTEST_DECLARE_GROUP(std_tests);
JTEST_DECLARE_GROUP(var_tests);
#endif /* _STATISTICS_TESTS_H_ */
| 521 |
C
| 31.624998 | 84 | 0.506718 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_test_group.h
|
#ifndef _STATISTICS_TEST_GROUP_H_
#define _STATISTICS_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(statistics_tests);
#endif /* _STATISTICS_TEST_GROUP_H_ */
| 344 |
C
| 33.499997 | 84 | 0.366279 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_test_group.h
|
#ifndef _COMPLEX_MATH_TEST_GROUP_H_
#define _COMPLEX_MATH_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(complex_math_tests);
#endif /* _COMPLEX_MATH_TEST_GROUP_H_ */
| 352 |
C
| 34.299997 | 84 | 0.369318 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_templates.h
|
#ifndef _COMPLEX_MATH_TEMPLATES_H_
#define _COMPLEX_MATH_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"
/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/
/**
* Compare the real outputs from the function under test and the reference
* function.
*/
#define COMPLEX_MATH_COMPARE_RE_INTERFACE(block_size, output_type) \
TEST_ASSERT_BUFFERS_EQUAL( \
complex_math_output_ref_a.data_ptr, \
complex_math_output_fut_a.data_ptr, \
block_size * sizeof(output_type))
/**
* Compare the real and imaginary outputs from the function under test and the
* reference function.
*/
#define COMPLEX_MATH_COMPARE_CMPLX_INTERFACE(block_size, output_type) \
do \
{ \
COMPLEX_MATH_COMPARE_RE_INTERFACE(block_size * 2, output_type); \
} while (0)
/*
* Comparison SNR thresholds for the data types used in complex_math_tests.
*/
#define COMPLEX_MATH_SNR_THRESHOLD_float32_t 120
#define COMPLEX_MATH_SNR_THRESHOLD_q31_t 100
#define COMPLEX_MATH_SNR_THRESHOLD_q15_t 75
/**
* Compare reference and fut outputs using SNR.
*
* The output_suffix specifies which output buffers to use for the
* comparison. An output_suffix of 'a' expands to the following buffers:
*
* - complex_math_output_f32_ref_a
* - complex_math_output_f32_fut_a
* - complex_math_output_ref_a
* - complex_math_output_fut_a
*
* @note The outputs are converted to float32_t before comparison.
*/
#define COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size, \
output_type, \
output_suffix) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
complex_math_output_f32_ref_##output_suffix, \
complex_math_output_ref_##output_suffix.data_ptr, \
complex_math_output_f32_fut_##output_suffix, \
complex_math_output_fut_##output_suffix.data_ptr, \
block_size, \
output_type, \
COMPLEX_MATH_SNR_THRESHOLD_##output_type \
); \
} while (0)
/**
* Specification of #COMPLEX_MATH_SNR_COMPARE_INTERFACE() for real outputs.
*/
#define COMPLEX_MATH_SNR_COMPARE_RE_INTERFACE(block_size, \
output_type) \
COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size, \
output_type, \
a)
/**
* Specification of #COMPLEX_MATH_SNR_COMPARE_INTERFACE() for complex outputs.
*/
#define COMPLEX_MATH_SNR_COMPARE_CMPLX_INTERFACE(block_size, \
output_type) \
COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size * 2, \
output_type, \
a)
/**
* Compare reference and fut split outputs using SNR.
*
* 'Split' refers to two separate output buffers; one for real and one for
* complex.
*/
#define COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE(block_size, \
output_type) \
do \
{ \
COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size, \
output_type, \
a); \
COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size, \
output_type, \
b); \
} while (0)
/*--------------------------------------------------------------------------------*/
/* Input Interfaces */
/*--------------------------------------------------------------------------------*/
/*
* General:
* Input interfaces provide inputs to functions inside test templates. They
* ONLY provide the inputs. The output variables should be hard coded.
*
* The input interfaces must have the following format:
*
* ARM_xxx_INPUT_INTERFACE() or
* REF_xxx_INPUT_INTERFACE()
*
* The xxx must be lowercase, and is intended to be the indentifying substring
* in the function's name. Acceptable values are 'sub' or 'add' from the
* functions arm_add_q31.
*/
#define ARM_cmplx_conj_INPUT_INTERFACE(input, block_size) \
PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
#define REF_cmplx_conj_INPUT_INTERFACE(input, block_size) \
PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
#define ARM_cmplx_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, block_size, \
complex_math_output_fut_a.data_ptr, \
complex_math_output_fut_b.data_ptr)
#define REF_cmplx_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, block_size, \
complex_math_output_ref_a.data_ptr, \
complex_math_output_ref_b.data_ptr)
#define ARM_cmplx_mag_INPUT_INTERFACE(input, block_size) \
PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
#define REF_cmplx_mag_INPUT_INTERFACE(input, block_size) \
PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
#define ARM_cmplx_mag_squared_INPUT_INTERFACE(input, block_size) \
PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
#define REF_cmplx_mag_squared_INPUT_INTERFACE(input, block_size) \
PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
#define ARM_cmplx_mult_cmplx_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, complex_math_output_fut_a.data_ptr, block_size)
#define REF_cmplx_mult_cmplx_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, complex_math_output_ref_a.data_ptr, block_size)
#define ARM_cmplx_mult_real_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, complex_math_output_fut_a.data_ptr, block_size)
#define REF_cmplx_mult_real_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, complex_math_output_ref_a.data_ptr, block_size)
/*--------------------------------------------------------------------------------*/
/* Test Templates */
/*--------------------------------------------------------------------------------*/
/**
* Specialization of #TEST_TEMPLATE_BUF1_BLK() for complex math tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name, \
suffix, \
input_type, \
output_type, \
comparison_interface) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_BUF1_BLK( \
complex_math_f_all, \
complex_math_block_sizes, \
input_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
comparison_interface); \
}
/**
* Specialization of #TEST_TEMPLATE_BUF2_BLK1() for complex math tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(fn_name, \
suffix, \
input_type, \
output_type, \
comparison_interface) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_BUF2_BLK( \
complex_math_f_all, \
complex_math_f_all, \
complex_math_block_sizes, \
input_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
comparison_interface); \
}
#endif /* _COMPLEX_MATH_TEMPLATES_H_ */
| 10,414 |
C
| 45.704036 | 84 | 0.43163 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_tests.h
|
#ifndef _COMPLEX_MATH_TESTS_H_
#define _COMPLEX_MATH_TESTS_H_
/*--------------------------------------------------------------------------------*/
/* Test/Group Declarations */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(cmplx_conj_tests);
JTEST_DECLARE_GROUP(cmplx_dot_prod_tests);
JTEST_DECLARE_GROUP(cmplx_mag_tests);
JTEST_DECLARE_GROUP(cmplx_mag_squared_tests);
JTEST_DECLARE_GROUP(cmplx_mult_cmplx_tests);
JTEST_DECLARE_GROUP(cmplx_mult_real_tests);
#endif /* _COMPLEX_MATH_TESTS_H_ */
| 555 |
C
| 36.066664 | 84 | 0.526126 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_test_data.h
|
#ifndef _COMPLEX_MATH_TEST_DATA_H_
#define _COMPLEX_MATH_TEST_DATA_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arr_desc.h"
#include "arm_math.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define COMPLEX_MATH_MAX_INPUT_ELEMENTS 32
#define COMPLEX_MATH_BIGGEST_INPUT_TYPE float32_t
/*--------------------------------------------------------------------------------*/
/* Decalare Variables */
/*--------------------------------------------------------------------------------*/
/* Input/Output Buffers */
ARR_DESC_DECLARE(complex_math_output_fut_a);
ARR_DESC_DECLARE(complex_math_output_fut_b);
ARR_DESC_DECLARE(complex_math_output_ref_a);
ARR_DESC_DECLARE(complex_math_output_ref_b);
extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
complex_math_output_f32_ref_a[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
complex_math_output_f32_ref_b[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
complex_math_output_f32_fut_a[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
complex_math_output_f32_fut_b[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
/* Block Sizes*/
ARR_DESC_DECLARE(complex_math_block_sizes);
/* Float Inputs */
ARR_DESC_DECLARE(complex_math_zeros);
ARR_DESC_DECLARE(complex_math_f_2);
ARR_DESC_DECLARE(complex_math_f_15);
ARR_DESC_DECLARE(complex_math_f_32);
ARR_DESC_DECLARE(complex_math_f_all);
#endif /* _COMPLEX_MATH_TEST_DATA_H_ */
| 1,736 |
C
| 33.058823 | 84 | 0.529954 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/templates/template.h
|
#ifndef _TEMPLATE_H_
#define _TEMPLATE_H_
/*--------------------------------------------------------------------------------*/
/* Looping and Iteration */
/*--------------------------------------------------------------------------------*/
/**
* Template for the general structure of a loop.
*/
#define TEMPLATE_LOOP(setup, loop_def, body) \
do \
{ \
setup; \
loop_def { \
body; \
} \
} while (0)
/**
* Template for looping over an array-like sequence.
*/
#define TEMPLATE_DO_ARR_LIKE(iter_idx, type, \
arr, arr_length, \
iter_elem_setup, \
body) \
do \
{ \
TEMPLATE_LOOP( \
int iter_idx, \
for(iter_idx = 0; iter_idx < (arr_length); ++iter_idx), \
iter_elem_setup; \
body); \
} while (0)
/**
* Template for looping over the contents of an array.
*/
#define TEMPLATE_DO_ARR(iter_idx, type, iter_elem, arr, arr_length, body) \
do \
{ \
TEMPLATE_DO_ARR_LIKE( \
iter_idx, type, arr, arr_length, \
type iter_elem = (arr)[iter_idx], \
body); \
} while (0)
/**
* Template for looping over the contents of an #ARR_DESC.
*/
#define TEMPLATE_DO_ARR_DESC(iter_idx, type, iter_elem, arr_desc, body) \
do \
{ \
TEMPLATE_DO_ARR_LIKE( \
iter_idx, type, arr_desc, (arr_desc).element_count, \
type iter_elem = ARR_DESC_ELT(type, iter_idx, &(arr_desc)), \
body); \
} while (0)
/*--------------------------------------------------------------------------------*/
/* Test Definition */
/*--------------------------------------------------------------------------------*/
/**
* Template for the general structure of a test.
*/
#define TEMPLATE_TEST(setup, body, teardown) \
do \
{ \
setup; \
body; \
teardown; \
} while (0)
/**
* Template for calling a function.
*
* @note Surround function arguments with the #PAREN() macro.
*
* @example
* void my_func(int arg1, int arg2);
*
* TEMPLATE_CALL_FN(my_func, PAREN(3, 7));
*/
#define TEMPLATE_CALL_FN(fn, fn_args) \
fn fn_args
#endif /* _TEMPLATE_H_ */
| 3,644 |
C
| 39.955056 | 84 | 0.272777 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/templates/test_templates.h
|
#ifndef _TEST_TEMPLATES_H_
#define _TEST_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "template.h"
#include <string.h> /* memcmp() */
#include <inttypes.h> /* PRIu32 */
#include "math_helper.h" /* arm_snr_f32() */
/*--------------------------------------------------------------------------------*/
/* Function Aliases for use in Templates. */
/*--------------------------------------------------------------------------------*/
#define ref_q31_t_to_float ref_q31_to_float
#define ref_q15_t_to_float ref_q15_to_float
#define ref_q7_t_to_float ref_q7_to_float
#define ref_float_to_q31_t ref_float_to_q31
#define ref_float_to_q15_t ref_float_to_q15
#define ref_float_to_q7_t ref_float_to_q7
#define ref_float32_t_to_float ref_copy_f32
#define ref_float_to_float32_t ref_copy_f32
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Call the function-under-test.
*/
#define TEST_CALL_FUT(fut, fut_args) \
JTEST_COUNT_CYCLES(TEMPLATE_CALL_FN(fut, fut_args))
/**
* Call the reference-function.
*/
#define TEST_CALL_REF(ref, ref_args) \
TEMPLATE_CALL_FN(ref, ref_args)
/**
* Call the function-under-test and the reference-function.
*/
#define TEST_CALL_FUT_AND_REF(fut, fut_args, ref, ref_args) \
do { \
TEST_CALL_FUT(fut, fut_args); \
TEST_CALL_REF(ref, ref_args); \
} while (0)
/**
* This macro eats a variable number of arguments and evaluates to a null
* statement.
*/
#define TEST_NULL_STATEMENT(...) (void) "TEST_NULL_STATEMENT"
/**
* A function name, Usable in any template where a fut or ref name is accepted,
* that evaluates to a #TEST_NULL_STATEMENT().
*/
#define TEST_NULL_FN TEST_NULL_STATEMENT
/**
* Assert that buffers A and B are byte-equivalent for a number of bytes.
*/
#define TEST_ASSERT_BUFFERS_EQUAL(buf_a, buf_b, bytes)\
do \
{ \
if (memcmp(buf_a, buf_b, bytes) != 0) \
{ \
return JTEST_TEST_FAILED; \
} \
} while (0)
/**
* Assert that the two entities are equal.
*/
#define TEST_ASSERT_EQUAL(a, b) \
do \
{ \
if ((a) != (b)) \
{ \
return JTEST_TEST_FAILED;\
} \
} while (0)
/**
* Convert elements to from src_type to float.
*/
#define TEST_CONVERT_TO_FLOAT(src_ptr, dst_ptr, block_size, src_type) \
do \
{ \
ref_##src_type##_to_float( \
src_ptr, \
dst_ptr, \
block_size); \
} while (0) \
/**
* Convert elements to from float to dst_type .
*/
#define TEST_CONVERT_FLOAT_TO(src_ptr, dst_ptr, block_size, dst_type) \
do \
{ \
ref_float_to_##dst_type( \
src_ptr, \
dst_ptr, \
block_size); \
} while (0) \
/**
* Assert that the SNR between a reference and test sample is above a given
* threshold.
*/
#define TEST_ASSERT_SNR(ref_ptr, tst_ptr, block_size, threshold) \
do \
{ \
float32_t snr = arm_snr_f32(ref_ptr, tst_ptr, block_size);\
if ( snr <= threshold) \
{ \
JTEST_DUMP_STRF("SNR: %f\n", snr); \
return JTEST_TEST_FAILED; \
} \
} while (0)
/**
* Assert that the SNR between a reference and test sample is above a given
* threshold. Special case for float64_t
*/
#define TEST_ASSERT_DBL_SNR(ref_ptr, tst_ptr, block_size, threshold)\
do \
{ \
float64_t snr = arm_snr_f64(ref_ptr, tst_ptr, block_size); \
if ( snr <= threshold) \
{ \
JTEST_DUMP_STRF("SNR: %f\n", snr); \
return JTEST_TEST_FAILED; \
} \
} while (0)
/**
* Compare test and reference elements by converting to float and
* calculating an SNR.
*
* This macro is a merger of the #TEST_CONVERT_TO_FLOAT() and
* #TEST_ASSERT_SNR() macros.
*/
#define TEST_CONVERT_AND_ASSERT_SNR(ref_dst_ptr, ref_src_ptr, \
tst_dst_ptr, tst_src_ptr, \
block_size, \
tst_src_type, \
threshold) \
do \
{ \
TEST_CONVERT_TO_FLOAT(ref_src_ptr, \
ref_dst_ptr, \
block_size, \
tst_src_type); \
TEST_CONVERT_TO_FLOAT(tst_src_ptr, \
tst_dst_ptr, \
block_size, \
tst_src_type); \
TEST_ASSERT_SNR(ref_dst_ptr, \
tst_dst_ptr, \
block_size, \
threshold); \
} while (0)
/**
* Execute statements only if the combination of block size, function type
* specifier, and input ARR_DESC_t are valid.
*
* @example An ARR_DESC_t that contains 64 bytes cant service a 32 element
* block size if they are extracted in float32_t increments.
*
* 8 * 32 = 256 > 64.
*/
#define TEST_DO_VALID_BLOCKSIZE(block_size, fn_type_spec, \
input_arr_desc, body) \
do \
{ \
if (block_size * sizeof(fn_type_spec) <= \
ARR_DESC_BYTES(input_arr_desc)) \
{ \
JTEST_DUMP_STRF("Block Size: %"PRIu32"\n", block_size); \
body; \
} \
} while (0) \
/**
* Template for tests that rely on one input buffer and a blocksize parameter.
*
* The buffer is an #ARR_DESC_t. It is iterated over and it's values are
* passed to the function under test and reference functions through their
* appropriate argument interfaces. The argument interfaces this template to
* execute structurally similar functions.
*
*/
#define TEST_TEMPLATE_BUF1_BLK(arr_desc_inputs, \
arr_desc_block_sizes, \
input_type, output_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
compare_interface) \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
, \
TEMPLATE_DO_ARR_DESC( \
block_size_idx, uint32_t, block_size, arr_desc_block_sizes \
, \
void * input_data_ptr = input_ptr->data_ptr; \
\
TEST_DO_VALID_BLOCKSIZE( \
block_size, input_type, input_ptr \
, \
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface( \
input_data_ptr, block_size), \
ref, ref_arg_interface( \
input_data_ptr, block_size)); \
\
compare_interface(block_size, output_type)))); \
\
return JTEST_TEST_PASSED; \
\
} while (0)
/**
* Template for tests that rely on an input buffer and an element.
*
* An element can is any thing which doesn't walk and talk like a
* sequence. Examples include numbers, and structures.
*/
#define TEST_TEMPLATE_BUF1_ELT1(arr_desc_inputs, \
arr_desc_elts, \
input_type, elt_type, output_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
compare_interface) \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
, \
TEMPLATE_DO_ARR_DESC( \
elt_idx, elt_type, elt, arr_desc_elts \
, \
void * input_data_ptr = input_ptr->data_ptr; \
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface(input_data_ptr, elt), \
ref, ref_arg_interface(input_data_ptr, elt)); \
\
compare_interface(output_type))); \
return JTEST_TEST_PASSED; \
} while (0)
/**
* Template for tests that rely on an input buffer, an element, and a blocksize
* parameter.
*/
#define TEST_TEMPLATE_BUF1_ELT1_BLK(arr_desc_inputs, \
arr_desc_elts, \
arr_desc_block_sizes, \
input_type, elt_type, output_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
compare_interface); \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
inut_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
, \
TEMPLATE_DO_ARR_DESC( \
block_size_idx, uint32_t, block_size, \
arr_desc_block_sizes \
, \
TEMPLATE_DO_ARR_DESC( \
elt_idx, elt_type, elt, arr_desc_elts \
, \
void * input_data_ptr = input_ptr->data_ptr; \
TEST_DO_VALID_BLOCKSIZE( \
block_size, input_type, input_ptr, \
\
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface( \
input_data_ptr, elt, block_size), \
ref, ref_arg_interface( \
input_data_ptr, elt, block_size)); \
compare_interface(block_size, output_type))))); \
return JTEST_TEST_PASSED; \
} while (0)
/**
* Template for tests that rely on an input buffer, two elements, and a blocksize
* parameter.
*/
#define TEST_TEMPLATE_BUF1_ELT2_BLK(arr_desc_inputs, \
arr_desc_elt1s, \
arr_desc_elt2s, \
arr_desc_block_sizes, \
input_type, elt1_type, \
elt2_type, output_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
compare_interface) \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
inut_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
, \
TEMPLATE_DO_ARR_DESC( \
block_size_idx, uint32_t, block_size, \
arr_desc_block_sizes \
, \
TEMPLATE_DO_ARR_DESC( \
elt1_idx, elt1_type, elt1, arr_desc_elt1s \
, \
TEMPLATE_DO_ARR_DESC( \
elt2_idx, elt2_type, elt2, arr_desc_elt2s \
, \
void * input_data_ptr = input_ptr->data_ptr; \
TEST_DO_VALID_BLOCKSIZE( \
block_size, input_type, input_ptr, \
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface( \
input_data_ptr, elt1, elt2, block_size), \
ref, ref_arg_interface( \
input_data_ptr, elt1, elt2, block_size)); \
compare_interface(block_size, output_type)))))); \
return JTEST_TEST_PASSED; \
} while (0)
/**
* Template for tests that rely on two input buffers and a blocksize parameter.
*
* The two #ARR_DESC_t, input buffers are iterated through in parallel. The
* length of the first #ARR_DESC_t determines the length of the iteration.
*/
#define TEST_TEMPLATE_BUF2_BLK(arr_desc_inputs_a, \
arr_desc_inputs_b, \
arr_desc_block_sizes, \
input_type, output_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
compare_interface) \
do \
{ \
/* Iterate over two input arrays in parallel.*/ \
TEMPLATE_DO_ARR_DESC( \
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs_a \
, \
TEMPLATE_DO_ARR_DESC( \
block_size_idx, uint32_t, block_size, arr_desc_block_sizes, \
void * input_a_ptr = input_ptr->data_ptr; \
void * input_b_ptr = ARR_DESC_ELT( \
ARR_DESC_t *, input_idx, \
&(arr_desc_inputs_b))->data_ptr; \
\
TEST_DO_VALID_BLOCKSIZE( \
block_size, input_type, input_ptr \
, \
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface( \
input_a_ptr, input_b_ptr, block_size), \
ref, ref_arg_interface( \
input_a_ptr, input_b_ptr, block_size)); \
\
compare_interface(block_size, output_type)))); \
return JTEST_TEST_PASSED; \
} while (0)
/**
* Test template that uses a single element.
*/
#define TEST_TEMPLATE_ELT1(arr_desc_elts, \
elt_type, output_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
compare_interface) \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
elt_idx, elt_type, elt, arr_desc_elts \
, \
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface( \
elt), \
ref, ref_arg_interface( \
elt)); \
/* Comparison interfaces typically accept */ \
/* a block_size. Pass a dummy value 1.*/ \
compare_interface(1, output_type)); \
return JTEST_TEST_PASSED; \
} while (0)
/**
* Test template that iterates over two sets of elements in parallel.
*
* The length of the first set determines the number of iteratsions.
*/
#define TEST_TEMPLATE_ELT2(arr_desc_elts_a, \
arr_desc_elts_b, \
elt_a_type, elt_b_type, output_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
compare_interface) \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
elt_a_idx, elt_a_type, elt_a, arr_desc_elts_a \
, \
elt_b_type * elt_b = ARR_DESC_ELT( \
elt_b_type, \
elt_a_idx, \
arr_desc_elts_b); \
\
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface( \
elt_a, elt_b), \
ref, ref_arg_interface( \
elt_a, elt_b)); \
/* Comparison interfaces typically accept */ \
/* a block_size. Pass a dummy value 1.*/ \
compare_interface(1, output_type)); \
return JTEST_TEST_PASSED; \
} while (0)
/**
* Test template that uses an element and a block size.
*/
#define TEST_TEMPLATE_ELT1_BLK(arr_desc_elts, \
arr_desc_block_sizes, \
elt_type, output_type, \
fut, fut_arg_interface, \
ref, ref_arg_interface, \
compare_interface) \
do \
{ \
TEMPLATE_DO_ARR_DESC( \
block_size_idx, uint32_t, block_size, \
arr_desc_block_sizes \
, \
TEMPLATE_DO_ARR_DESC( \
elt_idx, elt_type, elt, arr_desc_elts \
, \
JTEST_DUMP_STRF("Block Size: %d\n", \
(int)block_size); \
TEST_CALL_FUT_AND_REF( \
fut, fut_arg_interface( \
elt, block_size), \
ref, ref_arg_interface( \
elt, block_size)); \
compare_interface(block_size, output_type))); \
return JTEST_TEST_PASSED; \
} while (0)
#endif /* _TEST_TEMPLATES_H_ */
| 24,938 |
C
| 52.402569 | 84 | 0.29846 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_test_data.h
|
#ifndef _TRANSFORM_TEST_DATA_H_
#define _TRANSFORM_TEST_DATA_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arr_desc.h"
#include "arm_math.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define TRANSFORM_MAX_FFT_LEN 4096
#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
/*--------------------------------------------------------------------------------*/
/* Variable Declarations */
/*--------------------------------------------------------------------------------*/
/* Lengths are multiplied by 2 to accomodate complex numbers*/
extern float32_t transform_fft_output_fut[TRANSFORM_MAX_FFT_LEN * 2];
extern float32_t transform_fft_output_ref[TRANSFORM_MAX_FFT_LEN * 2];
extern float32_t transform_fft_input_fut[TRANSFORM_MAX_FFT_LEN * 2];
extern float32_t transform_fft_input_ref[TRANSFORM_MAX_FFT_LEN * 2];
extern float32_t transform_fft_output_f32_fut[TRANSFORM_MAX_FFT_LEN * 2];
extern float32_t transform_fft_output_f32_ref[TRANSFORM_MAX_FFT_LEN * 2];
extern float32_t * transform_fft_inplace_input_fut;
extern float32_t * transform_fft_inplace_input_ref;
extern float32_t transform_fft_f32_inputs[TRANSFORM_MAX_FFT_LEN * 2];
extern q31_t transform_fft_q31_inputs[TRANSFORM_MAX_FFT_LEN * 2];
extern q15_t * transform_fft_q15_inputs;
extern q15_t dct4_transform_fft_q15_inputs[TRANSFORM_MAX_FFT_LEN * 2];
/* FFT Lengths */
ARR_DESC_DECLARE(transform_radix2_fftlens);
ARR_DESC_DECLARE(transform_radix4_fftlens);
ARR_DESC_DECLARE(transform_rfft_fftlens);
ARR_DESC_DECLARE(transform_rfft_fast_fftlens);
ARR_DESC_DECLARE(transform_dct_fftlens);
/* CFFT Structs */
ARR_DESC_DECLARE(transform_cfft_f32_structs);
ARR_DESC_DECLARE(transform_cfft_q31_structs);
ARR_DESC_DECLARE(transform_cfft_q15_structs);
#endif /* _TRANSFORM_TEST_DATA_H_ */
| 2,047 |
C
| 40.795918 | 84 | 0.570591 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_test_group.h
|
#ifndef _TRANSFORM_TEST_GROUP_H_
#define _TRANSFORM_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(transform_tests);
#endif /* _TRANSFORM_TEST_GROUP_H_ */
| 340 |
C
| 33.099997 | 84 | 0.358824 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_tests.h
|
#ifndef _TRANSFORM_TESTS_H_
#define _TRANSFORM_TESTS_H_
/*--------------------------------------------------------------------------------*/
/* Test/Group Declarations */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(cfft_tests);
JTEST_DECLARE_GROUP(cfft_family_tests);
JTEST_DECLARE_GROUP(dct4_tests);
JTEST_DECLARE_GROUP(rfft_tests);
JTEST_DECLARE_GROUP(rfft_fast_tests);
#endif /* _TRANSFORM_TESTS_H_ */
| 468 |
C
| 32.499998 | 84 | 0.476496 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_templates.h
|
#ifndef _TRANSFORM_TEMPLATES_H_
#define _TRANSFORM_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"
#include <string.h> /* memcpy() */
/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/
/**
* Comparison SNR thresholds for the data types used in transform_tests.
*/
#define TRANSFORM_SNR_THRESHOLD_float32_t 90
#define TRANSFORM_SNR_THRESHOLD_q31_t 90
#define TRANSFORM_SNR_THRESHOLD_q15_t 30
#define DCT4_TRANSFORM_SNR_THRESHOLD_float32_t 80
#define DCT4_TRANSFORM_SNR_THRESHOLD_q31_t 75
#define DCT4_TRANSFORM_SNR_THRESHOLD_q15_t 11
/**
* Compare the outputs from the function under test and the reference
* function using SNR.
*/
#define TRANSFORM_SNR_COMPARE_INTERFACE(block_size, \
output_type) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
transform_fft_output_f32_ref, \
(output_type *) transform_fft_output_ref, \
transform_fft_output_f32_fut, \
(output_type *) transform_fft_output_fut, \
block_size, \
output_type, \
TRANSFORM_SNR_THRESHOLD_##output_type \
); \
} while (0)
/**
* Compare the outputs from the function under test and the reference
* function using SNR.
*/
#define DCT_TRANSFORM_SNR_COMPARE_INTERFACE(block_size, \
output_type) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
transform_fft_output_f32_ref, \
(output_type *) transform_fft_output_ref, \
transform_fft_output_f32_fut, \
(output_type *) transform_fft_output_fut, \
block_size, \
output_type, \
DCT4_TRANSFORM_SNR_THRESHOLD_##output_type \
); \
} while (0) \
/**
* Specialization on #TRANSFORM_SNR_COMPARE_INTERFACE() to fix the block_size
* for complex datasets.
*/
#define TRANSFORM_SNR_COMPARE_CMPLX_INTERFACE(block_size, output_type) \
/* Complex numbers have two components*/ \
TRANSFORM_SNR_COMPARE_INTERFACE(block_size * 2, output_type )
/**
* This macro copys data from the input_ptr into input arrays.
*
* Some functions modify their input data; in order to provide the same data to
* multiple tests, copies must be made so the changes from one function don't
* impact the others.
*/
#define TRANSFORM_COPY_INPUTS(input_ptr, \
bytes) \
do \
{ \
memcpy( \
transform_fft_input_fut, \
input_ptr, \
bytes); \
memcpy( \
transform_fft_input_ref, \
input_ptr, \
bytes); \
} while (0)
/**
* This macro copys data from the input_ptr into input arrays. It also creates
* symmetric input data for rfft inverse.
*
* The 4.534234f just makes the middle entry of the array semi random. It's
* actual value doesn't seem to matter much.
*
* Some functions modify their input data; in order to provide the same data to
* multiple tests, copies must be made so the changes from one function don't
* impact the others.
*/
#define TRANSFORM_PREPARE_INVERSE_INPUTS(input_ptr, \
fftlen, input_type, bytes) \
do \
{ \
uint32_t i; \
\
memcpy( \
transform_fft_input_fut, \
input_ptr, \
bytes); \
\
((input_type*)transform_fft_input_fut)[1] = 0; \
((input_type*)transform_fft_input_fut)[fftlen + 0] = 0; \
((input_type*)transform_fft_input_fut)[fftlen + 1] = 0; \
for(i=1;i<fftlen/2;i++) \
{ \
*((input_type*)transform_fft_input_fut + fftlen + 2*i + 0) = \
*((input_type*)transform_fft_input_fut + fftlen - 2*i + 0); \
*((input_type*)transform_fft_input_fut + fftlen + 2*i + 1) = \
-(*((input_type*)transform_fft_input_fut + fftlen - 2*i + 1)); \
\
} \
\
memcpy( \
transform_fft_input_ref, \
transform_fft_input_fut, \
bytes * 2); \
} while (0)
/**
* This macro copys data from the input_ptr into the in-place input arrays.
*
* Some functions modify their input data; in order to provide the same data to
* multiple tests, copies must be made so the changes from one function don't
* impact the others.
*/
#define TRANSFORM_PREPARE_INPLACE_INPUTS_DOWNSHIFT(input_ptr, \
bytes, \
type) \
do \
{ \
uint32_t i; \
memcpy( \
transform_fft_inplace_input_fut, \
input_ptr, \
bytes); \
memcpy( \
transform_fft_inplace_input_ref, \
input_ptr, \
bytes); \
for(i=0;i<bytes/sizeof(type);i++) { \
*((type*)transform_fft_inplace_input_fut + i) >>= 1; \
*((type*)transform_fft_inplace_input_ref + i) >>= 1;} \
} while (0)
/**
* This macro copys data from the input_ptr into the in-place input arrays.
*
* Some functions modify their input data; in order to provide the same data to
* multiple tests, copies must be made so the changes from one function don't
* impact the others.
*/
#define TRANSFORM_PREPARE_INPLACE_INPUTS(input_ptr, \
bytes) \
do \
{ \
memcpy( \
transform_fft_inplace_input_fut, \
input_ptr, \
bytes); \
memcpy( \
transform_fft_inplace_input_ref, \
input_ptr, \
bytes); \
} while (0)
#endif /* _TRANSFORM_TEMPLATES_H_ */
| 9,044 |
C
| 48.697802 | 84 | 0.347302 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_tests.h
|
#ifndef _BASIC_MATH_TESTS_H_
#define _BASIC_MATH_TESTS_H_
/*--------------------------------------------------------------------------------*/
/* Test/Group Declarations */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(abs_tests);
JTEST_DECLARE_GROUP(add_tests);
JTEST_DECLARE_GROUP(dot_prod_tests);
JTEST_DECLARE_GROUP(mult_tests);
JTEST_DECLARE_GROUP(negate_tests);
JTEST_DECLARE_GROUP(offset_tests);
JTEST_DECLARE_GROUP(scale_tests);
JTEST_DECLARE_GROUP(shift_tests);
JTEST_DECLARE_GROUP(sub_tests);
#endif /* _BASIC_MATH_TESTS_H_ */
| 598 |
C
| 32.277776 | 84 | 0.540134 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_templates.h
|
#ifndef _BASIC_MATH_TEMPLATES_H_
#define _BASIC_MATH_TEMPLATES_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"
/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/
/**
* Compare the outputs used by basic math tests for the function under test and
* the reference function.
*/
#define BASIC_MATH_COMPARE_INTERFACE(block_size, output_type) \
TEST_ASSERT_BUFFERS_EQUAL( \
basic_math_output_ref.data_ptr, \
basic_math_output_fut.data_ptr, \
block_size * sizeof(output_type))
/*
* Comparison SNR thresholds for the data types used in basic_math_tests.
*/
#define BASIC_MATH_SNR_THRESHOLD_float32_t 120
#define BASIC_MATH_SNR_THRESHOLD_q31_t 100
#define BASIC_MATH_SNR_THRESHOLD_q15_t 75
#define BASIC_MATH_SNR_THRESHOLD_q7_t 25
/**
* Compare reference and fut outputs using SNR.
*
* @note The outputs are converted to float32_t before comparison.
*/
#define BASIC_MATH_SNR_COMPARE_INTERFACE(block_size, output_type) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
basic_math_output_f32_ref, \
basic_math_output_ref.data_ptr, \
basic_math_output_f32_fut, \
basic_math_output_fut.data_ptr, \
block_size, \
output_type, \
BASIC_MATH_SNR_THRESHOLD_##output_type \
); \
} while (0)
/**
* Compare reference and fut outputs using SNR.
*
* @note The outputs are converted to float32_t before comparison.
*/
#define BASIC_MATH_SNR_ELT1_COMPARE_INTERFACE(block_size, output_type) \
do \
{ \
TEST_CONVERT_AND_ASSERT_SNR( \
basic_math_output_f32_ref, \
basic_math_output_ref.data_ptr, \
basic_math_output_f32_fut, \
basic_math_output_fut.data_ptr, \
1, \
output_type, \
BASIC_MATH_SNR_THRESHOLD_##output_type \
); \
} while (0)
/*--------------------------------------------------------------------------------*/
/* Input Interfaces */
/*--------------------------------------------------------------------------------*/
/*
* General:
* Input interfaces provide inputs to functions inside test templates. They
* ONLY provide the inputs. The output variables should be hard coded.
*
* The input interfaces must have the following format:
*
* ARM_xxx_INPUT_INTERFACE() or
* REF_xxx_INPUT_INTERFACE()
*
* The xxx must be lowercase, and is intended to be the indentifying substring
* in the function's name. Acceptable values are 'sub' or 'add' from the
* functions arm_add_q31.
*/
#define ARM_abs_INPUT_INTERFACE(input, block_size) \
PAREN(input, basic_math_output_fut.data_ptr, block_size)
#define REF_abs_INPUT_INTERFACE(input, block_size) \
PAREN(input, basic_math_output_ref.data_ptr, block_size)
#define ARM_add_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
#define REF_add_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
#define ARM_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, block_size, basic_math_output_fut.data_ptr) \
#define REF_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, block_size, basic_math_output_ref.data_ptr) \
#define ARM_mult_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
#define REF_mult_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
#define ARM_negate_INPUT_INTERFACE(input, block_size) \
PAREN(input, basic_math_output_fut.data_ptr, block_size)
#define REF_negate_INPUT_INTERFACE(input, block_size) \
PAREN(input, basic_math_output_ref.data_ptr, block_size)
#define ARM_offset_INPUT_INTERFACE(input, elt, block_size) \
PAREN(input, elt, basic_math_output_fut.data_ptr, block_size) \
#define REF_offset_INPUT_INTERFACE(input, elt, block_size) \
PAREN(input, elt, basic_math_output_ref.data_ptr, block_size) \
#define ARM_shift_INPUT_INTERFACE(input, elt, block_size) \
PAREN(input, elt, basic_math_output_fut.data_ptr, block_size) \
#define REF_shift_INPUT_INTERFACE(input, elt, block_size) \
PAREN(input, elt, basic_math_output_ref.data_ptr, block_size) \
#define ARM_scale_float_INPUT_INTERFACE(input, elt, block_size) \
PAREN(input, elt, basic_math_output_fut.data_ptr, block_size) \
#define REF_scale_float_INPUT_INTERFACE(input, elt, block_size) \
PAREN(input, elt, basic_math_output_ref.data_ptr, block_size) \
/* These two are for the fixed point functions */
#define ARM_scale_INPUT_INTERFACE(input, elt1, elt2, block_size) \
PAREN(input, elt1, elt2, basic_math_output_fut.data_ptr, block_size) \
#define REF_scale_INPUT_INTERFACE(input, elt1, elt2, block_size) \
PAREN(input, elt1, elt2, basic_math_output_ref.data_ptr, block_size) \
#define ARM_sub_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
#define REF_sub_INPUT_INTERFACE(input_a, input_b, block_size) \
PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
/*--------------------------------------------------------------------------------*/
/* Test Templates */
/*--------------------------------------------------------------------------------*/
/**
* Specialization of #TEST_TEMPLATE_BUF1_BLK() for basic math tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name, \
suffix, \
input_type, \
output_type) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_BUF1_BLK( \
basic_math_f_all, \
basic_math_block_sizes, \
input_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
BASIC_MATH_COMPARE_INTERFACE); \
}
/**
* Specialization of #TEST_TEMPLATE_BUF2_BLK() for basic math tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(fn_name, \
suffix, \
input_type, \
output_type, \
comparison_interface) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_BUF2_BLK( \
basic_math_f_all, \
basic_math_f_all, \
basic_math_block_sizes, \
input_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
comparison_interface); \
}
/**
* Specialization of #TEST_TEMPLATE_BUF1_ELT1_BLK() for basic math tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT1_BLK(fn_name, \
suffix, \
input_type, \
elt_type, \
output_type) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_BUF1_ELT1_BLK( \
basic_math_f_all, \
basic_math_elts, \
basic_math_block_sizes, \
input_type, \
elt_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
BASIC_MATH_COMPARE_INTERFACE); \
}
/**
* Specialization of #TEST_TEMPLATE_BUF1_ELT2_BLK() for basic math tests.
*
* @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
* REF_xxx_INPUT_INTERFACEs.
*/
#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT2_BLK(fn_name, \
suffix, \
input_type, \
elt1_type, \
elt2_type, \
output_type) \
JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test, \
arm_##fn_name##_##suffix) \
{ \
TEST_TEMPLATE_BUF1_ELT2_BLK( \
basic_math_f_all, \
basic_math_elts, \
basic_math_elts2, \
basic_math_block_sizes, \
input_type, \
elt1_type, \
elt2_type, \
output_type, \
arm_##fn_name##_##suffix, \
ARM_##fn_name##_INPUT_INTERFACE, \
ref_##fn_name##_##suffix, \
REF_##fn_name##_INPUT_INTERFACE, \
BASIC_MATH_COMPARE_INTERFACE); \
}
#endif /* _BASIC_MATH_TEMPLATES_H_ */
| 13,314 |
C
| 48.682836 | 84 | 0.398828 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_test_data.h
|
#ifndef ARM_BASIC_MATH_TEST_DATA_H
#define ARM_BASIC_MATH_TEST_DATA_H
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arr_desc.h"
#include "arm_math.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define BASIC_MATH_MAX_INPUT_ELEMENTS 32
#define BASIC_MATH_BIGGEST_INPUT_TYPE float32_t
/*--------------------------------------------------------------------------------*/
/* Declare Variables */
/*--------------------------------------------------------------------------------*/
/* Input/Output Buffers */
ARR_DESC_DECLARE(basic_math_output_fut);
ARR_DESC_DECLARE(basic_math_output_ref);
extern BASIC_MATH_BIGGEST_INPUT_TYPE
basic_math_output_f32_ref[BASIC_MATH_MAX_INPUT_ELEMENTS];
extern BASIC_MATH_BIGGEST_INPUT_TYPE
basic_math_output_f32_fut[BASIC_MATH_MAX_INPUT_ELEMENTS];
/* Block Sizes*/
ARR_DESC_DECLARE(basic_math_block_sizes);
/* Numbers */
ARR_DESC_DECLARE(basic_math_elts);
ARR_DESC_DECLARE(basic_math_elts2);
ARR_DESC_DECLARE(basic_math_eltsf);
/* Float Inputs */
ARR_DESC_DECLARE(basic_math_zeros);
ARR_DESC_DECLARE(basic_math_f_2);
ARR_DESC_DECLARE(basic_math_f_15);
ARR_DESC_DECLARE(basic_math_f_32);
ARR_DESC_DECLARE(basic_math_f_all);
#endif
| 1,469 |
C
| 30.276595 | 84 | 0.485364 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_test_group.h
|
#ifndef _BASIC_MATH_TEST_GROUP_H_
#define _BASIC_MATH_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(basic_math_tests);
#endif /* _BASIC_MATH_TEST_GROUP_H_ */
| 344 |
C
| 33.499997 | 84 | 0.354651 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/fast_math_tests/fast_math_test_data.h
|
#ifndef _FAST_MATH_TEST_DATA_H_
#define _FAST_MATH_TEST_DATA_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "arm_math.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
#define FAST_MATH_MAX_LEN 1024
#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
/*--------------------------------------------------------------------------------*/
/* Variable Declarations */
/*--------------------------------------------------------------------------------*/
extern float32_t fast_math_output_fut[FAST_MATH_MAX_LEN];
extern float32_t fast_math_output_ref[FAST_MATH_MAX_LEN];
extern float32_t fast_math_output_f32_fut[FAST_MATH_MAX_LEN];
extern float32_t fast_math_output_f32_ref[FAST_MATH_MAX_LEN];
extern const float32_t fast_math_f32_inputs[FAST_MATH_MAX_LEN];
extern const q31_t fast_math_q31_inputs[FAST_MATH_MAX_LEN];
extern const q15_t * fast_math_q15_inputs;
#endif /* _FAST_MATH_TEST_DATA_H_ */
| 1,192 |
C
| 38.766665 | 84 | 0.42198 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/fast_math_tests/fast_math_test_group.h
|
#ifndef _FAST_MATH_TEST_GROUP_H_
#define _FAST_MATH_TEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Declare Test Groups */
/*--------------------------------------------------------------------------------*/
JTEST_DECLARE_GROUP(fast_math_tests);
#endif /* _FAST_MATH_TEST_GROUP_H_ */
| 340 |
C
| 33.099997 | 84 | 0.347059 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_generic.c
|
#if (defined (ARMCM0))
#include "system_ARMCM0.c"
#elif (defined (ARMCM0P))
#include "system_ARMCM0plus.c"
#elif (defined (ARMCM3))
#include "system_ARMCM3.c"
#elif (defined (ARMCM4) || defined (ARMCM4_FP))
#include "system_ARMCM4.c"
#elif (defined (ARMCM7) || defined (ARMCM7_SP) || defined (ARMCM7_DP))
#include "system_ARMCM7.c"
#elif defined (ARMv8MBL)
#include "system_ARMv8MBL.c"
#elif (defined (ARMv8MML) || defined (ARMv8MML_DSP) || \
defined (ARMv8MML_SP) || defined (ARMv8MML_DSP_SP) || \
defined (ARMv8MML_DP) || defined (ARMv8MML_DSP_DP) )
#include "system_ARMv8MML.c"
#else
#error "No appropriate system file found!"
#endif
| 685 |
C
| 23.499999 | 70 | 0.655474 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCC/Retarget.c
|
/*----------------------------------------------------------------------------
* Name: Retarget.c
* Purpose: 'Retarget' layer for target-dependent low level functions
* Note(s):
*----------------------------------------------------------------------------
* This file is part of the uVision/ARM development tools.
* This software may only be used under the terms of a valid, current,
* end user licence from KEIL for a compatible version of KEIL software
* development tools. Nothing else gives you the right to use this software.
*
* This software is supplied "AS IS" without warranties of any kind.
*
* Copyright (c) 2011 Keil - An ARM Company. All rights reserved.
*----------------------------------------------------------------------------*/
#include <stdio.h>
#include <rt_misc.h>
#include "Serial.h"
#pragma import(__use_no_semihosting_swi)
struct __FILE { int handle; /* Add whatever you need here */ };
FILE __stdout;
FILE __stdin;
int fputc(int c, FILE *f) {
return (SER_PutChar(c));
}
int fgetc(FILE *f) {
return (SER_GetChar());
}
int ferror(FILE *f) {
/* Your implementation of ferror */
return EOF;
}
void _ttywrch(int c) {
SER_PutChar(c);
}
void _sys_exit(int return_code) {
label: goto label; /* endless loop */
}
| 1,274 |
C
| 23.056603 | 80 | 0.55416 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/GCC/Retarget.c
|
/*----------------------------------------------------------------------------
* Name: Retarget.c
* Purpose: 'Retarget' layer for target-dependent low level functions
* Note(s):
*----------------------------------------------------------------------------
* This file is part of the uVision/ARM development tools.
* This software may only be used under the terms of a valid, current,
* end user licence from KEIL for a compatible version of KEIL software
* development tools. Nothing else gives you the right to use this software.
*
* This software is supplied "AS IS" without warranties of any kind.
*
* Copyright (c) 2012 Keil - An ARM Company. All rights reserved.
*----------------------------------------------------------------------------*/
#include <sys/stat.h>
#include <string.h>
#include <errno.h>
int SER_PutChar (int c) {
return (c);
}
int SER_GetChar (void) {
return (-1);
}
/*-- GCC - Newlib runtime support --------------------------------------------*/
extern int __HeapBase;
extern int __HeapLimit;
int _open (const char * path, int flags, ...)
{
return (-1);
}
int _close (int fd)
{
return (-1);
}
int _lseek (int fd, int ptr, int dir)
{
return (0);
}
int __attribute__((weak)) _fstat (int fd, struct stat * st)
{
memset (st, 0, sizeof (* st));
st->st_mode = S_IFCHR;
return (0);
}
int _isatty (int fd)
{
return (1);
}
int _read (int fd, char * ptr, int len)
{
char c;
int i;
for (i = 0; i < len; i++)
{
c = SER_GetChar();
if (c == 0x0D) break;
*ptr++ = c;
SER_PutChar(c);
}
return (len - i);
}
int _write (int fd, char * ptr, int len)
{
int i;
for (i = 0; i < len; i++) SER_PutChar (*ptr++);
return (i);
}
caddr_t _sbrk (int incr)
{
static char * heap;
char * prev_heap;
if (heap == NULL)
{
heap = (char *)&__HeapBase;
}
prev_heap = heap;
if ((heap + incr) > (char *)&__HeapLimit)
{
errno = ENOMEM;
return (caddr_t) -1;
}
heap += incr;
return (caddr_t) prev_heap;
}
| 2,035 |
C
| 18.028037 | 80 | 0.504668 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_cycle.c
|
#include "../inc/jtest_cycle.h"
#include <inttypes.h>
/*--------------------------------------------------------------------------------*/
/* Define Module Variables */
/*--------------------------------------------------------------------------------*/
/* const char * JTEST_CYCLE_STRF = "Running: %s\nCycles: %" PRIu32 "\n"; */
const char * JTEST_CYCLE_STRF = "Cycles: %" PRIu32 "\n"; /* function name + parameter string skipped */
| 436 |
C
| 42.699996 | 103 | 0.396789 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_fw.c
|
#include "../inc/jtest.h"
/*--------------------------------------------------------------------------------*/
/* Define Global Variables */
/*--------------------------------------------------------------------------------*/
char JTEST_FW_STR_BUFFER[JTEST_BUF_SIZE] = {0};
volatile JTEST_FW_t JTEST_FW = {0};
| 313 |
C
| 30.399997 | 84 | 0.300319 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_dump_str_segments.c
|
#include "jtest_fw.h"
/**
* Dump the JTEST_FW.str_buffer the Keil framework in pieces.
*
* The JTEST_FW.str_buffer contains more characters than the Keil framework can
* dump at once. This function dumps them in blocks.
*/
void jtest_dump_str_segments(void)
{
uint32_t seg_idx = 0;
uint32_t memmove_idx = 0;
uint32_t seg_cnt =
(strlen(JTEST_FW.str_buffer) / JTEST_STR_MAX_OUTPUT_SIZE) + 1;
for( seg_idx = 0; seg_idx < seg_cnt; ++seg_idx)
{
JTEST_TRIGGER_ACTION(dump_str);
if (seg_idx < JTEST_STR_MAX_OUTPUT_SEGMENTS)
{
memmove_idx = 0;
while (memmove_idx < (seg_cnt - seg_idx -1) )
{
memmove(
JTEST_FW.str_buffer+
(memmove_idx* JTEST_STR_MAX_OUTPUT_SIZE),
JTEST_FW.str_buffer+
((memmove_idx+1)*JTEST_STR_MAX_OUTPUT_SIZE),
JTEST_BUF_SIZE);
++memmove_idx;
}
}
}
return;
}
| 1,035 |
C
| 26.999999 | 80 | 0.518841 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_trigger_action.c
|
#include "jtest_fw.h"
void test_start (void) {
// ;
JTEST_FW.test_start++;
}
void test_end (void) {
// ;
JTEST_FW.test_end++;
}
void group_start (void) {
// ;
JTEST_FW.group_start++;
}
void group_end (void) {
// ;
JTEST_FW.group_end++;
}
void dump_str (void) {
// ;
JTEST_FW.dump_str++;
}
void dump_data (void) {
// ;
JTEST_FW.dump_data++;
}
void exit_fw (void) {
// ;
JTEST_FW.exit_fw++;
}
| 449 |
C
| 10.842105 | 27 | 0.512249 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_group_define.h
|
#ifndef _JTEST_GROUP_DEFINE_H_
#define _JTEST_GROUP_DEFINE_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "jtest_util.h"
#include "jtest_define.h"
#include "jtest_group.h"
/* For defining macros with optional arguments */
#include "opt_arg/opt_arg.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Prefix for all #JTEST_GROUP_t structs.
*/
#define JTEST_GROUP_STRUCT_NAME_PREFIX G_JTEST_GROUP_STRUCT_
/**
* Define test template used by #JTEST_GROUP_t tests.
*/
#define JTEST_GROUP_FN_TEMPLATE(group_fn) \
void group_fn(void)
#define JTEST_GROUP_FN_PROTOTYPE JTEST_GROUP_FN_TEMPLATE /**< Alias for
#JTEST_GROUP_FN_TEMPLATE. */
/**
* Evaluate to the name of the #JTEST_GROUP_t struct associated with group_fn.
*/
#define JTEST_GROUP_STRUCT_NAME(group_fn) \
JTEST_STRUCT_NAME(JTEST_GROUP_STRUCT_NAME_PREFIX, group_fn)
/**
* Define a #JTEST_GROUP_t struct based on the given group_fn.
*/
#define JTEST_GROUP_DEFINE_STRUCT(group_fn) \
JTEST_DEFINE_STRUCT(JTEST_GROUP_t, \
JTEST_GROUP_STRUCT_NAME(group_fn))
/**
* Declare a #JTEST_GROUP_t struct based on the given group_fn.
*/
#define JTEST_GROUP_DECLARE_STRUCT(group_fn) \
JTEST_DECLARE_STRUCT(JTEST_GROUP_DEFINE_STRUCT(group_fn))
/**
* Contents needed to initialize a JTEST_GROUP_t struct.
*/
#define JTEST_GROUP_STRUCT_INIT(group_fn) \
group_fn, \
STR_NL(group_fn), \
JTEST_PF_MEMBER_INIT
/**
* Initialize the contents of a #JTEST_GROUP_t struct.
*/
#define JTEST_GROUP_INIT(group_fn) \
JTEST_GROUP_DEFINE_STRUCT(group_fn) = { \
JTEST_GROUP_STRUCT_INIT(group_fn) \
}
/* Test Definition Macro */
/*--------------------------------------------------------------------------------*/
/**
* Define a #JTEST_GROUP_t object and a test function.
*/
#define JTEST_DEFINE_GROUP(group_fn) \
JTEST_GROUP_FN_PROTOTYPE(group_fn); \
JTEST_GROUP_INIT(group_fn); \
JTEST_GROUP_FN_PROTOTYPE(group_fn) /* Notice the lacking semicolon */
/**
* Declare a #JTEST_GROUP_t object and a test function prototype.
*/
#define JTEST_DECLARE_GROUP(group_fn) \
JTEST_GROUP_FN_PROTOTYPE(group_fn); \
JTEST_GROUP_DECLARE_STRUCT(group_fn) /* Note the lacking semicolon */
#endif /* _JTEST_GROUP_DEFINE_H_ */
| 2,747 |
C
| 30.227272 | 88 | 0.524572 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_fw.h
|
#ifndef _JTEST_FW_H_
#define _JTEST_FW_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include <stdint.h> /* int32_t */
#include <string.h> /* strcpy() */
#include <stdio.h> /* sprintf() */
#include "jtest_pf.h" /* Extend JTEST_FW_t with Pass/Fail data */
#include "jtest_group.h"
/*--------------------------------------------------------------------------------*/
/* Type Definitions */
/*--------------------------------------------------------------------------------*/
/**
* A struct used to interface with the Keil Debugger.
*/
typedef struct JTEST_FW_struct
{
/* Action Triggers: The Keil debugger monitors these values for changes. In
* response to a change, the debugger executes code on the host. */
volatile int32_t test_start;
volatile int32_t test_end;
volatile int32_t group_start;
volatile int32_t group_end;
volatile int32_t dump_str;
volatile int32_t dump_data;
volatile int32_t exit_fw;
JTEST_GROUP_t * current_group_ptr;
/* Buffers: The C-code cannot send strings and data directly to the
* debugging framework. Instead, the debugger can be told to read 128 byte
* (by default) chunks of memory. Data received in this manner requires
* post-processing to be legible.*/
char * str_buffer;
char * data_buffer;
/* Pass/Fail Data */
JTEST_PF_MEMBERS;
} JTEST_FW_t;
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Default name for the JTEST_FW struct.
*
* Define your own if you want the variable containing the #JTEST_FW_t to have
* a different name.
*/
#ifndef JTEST_FW
#define JTEST_FW JTEST_FW
#endif
/**
* Default name for the JTEST_FW_STR_BUFFER.
*
* Define your own if you want the variable containing the char buffer to have
* a different name.
*/
#ifndef JTEST_FW_STR_BUFFER
#define JTEST_FW_STR_BUFFER JTEST_FW_STR_BUFFER
#endif
/**
* Size of the #JTEST_FW_t, output string-buffer.
*
* If you change this value, make sure the "dump_str_fn" and "dump_data_fn"
* functions in jtest_fns.ini uses the same size. If you aren't sure, read the
* documentation Keil Debugger Command 'DISPLAY'.
*/
#define JTEST_BUF_SIZE 256
/**
* The maximum number of bytes output at once using #JTEST_DUMP_STRF().
*/
#define JTEST_STR_MAX_OUTPUT_SIZE 128
/**
* The maximum number of block transimissions needed to send a string from a
* buffer with JTEST_BUF_SIZE.
*/
#define JTEST_STR_MAX_OUTPUT_SEGMENTS \
(JTEST_BUF_SIZE / JTEST_STR_MAX_OUTPUT_SIZE)
/**
* Initialize the JTEST framework.
*/
#define JTEST_INIT() \
do \
{ \
JTEST_FW.str_buffer = JTEST_FW_STR_BUFFER; \
} while (0)
/* Debugger Action-triggering Macros */
/*--------------------------------------------------------------------------------*/
/**
* Dispatch macro to trigger various actions in the Keil Debugger.
*/
#define JTEST_TRIGGER_ACTION(action_name) \
do \
{ \
action_name(); \
} while (0)
/**
* Trigger the "Test Start" action in the Keil Debugger.
*/
#define JTEST_ACT_TEST_START() \
JTEST_TRIGGER_ACTION(test_start)
/**
* Trigger the "Test End" action in the Keil Debugger.
*/
#define JTEST_ACT_TEST_END() \
JTEST_TRIGGER_ACTION(test_end)
/**
* Trigger the "Group Start" action in the Keil Debugger.
*/
#define JTEST_ACT_GROUP_START() \
JTEST_TRIGGER_ACTION(group_start)
/**
* Trigger the "Group End" action in the Keil Debugger.
*/
#define JTEST_ACT_GROUP_END() \
JTEST_TRIGGER_ACTION(group_end)
/**
* Fill the buffer named buf_name with value and dump it to the Keil debugger
* using action.
*/
#if defined(ARMv7A) || defined(FILEIO)
#define JTEST_ACT_DUMP(action, buf_name, value) \
do \
{ \
JTEST_CLEAR_BUFFER(buf_name); \
printf("%s",value); \
strcpy(JTEST_FW.buf_name, (value)); \
JTEST_TRIGGER_ACTION(action); \
} while (0)
#else
#define JTEST_ACT_DUMP(action, buf_name, value) \
do \
{ \
JTEST_CLEAR_BUFFER(buf_name); \
strcpy(JTEST_FW.buf_name, (value)); \
JTEST_TRIGGER_ACTION(action); \
} while (0)
#endif
/**
* Trigger the "Exit Framework" action in the Keil Debugger.
*/
#define JTEST_ACT_EXIT_FW() \
do \
{ \
JTEST_TRIGGER_ACTION(exit_fw); \
} while (0)
/* Buffer Manipulation Macros */
/*--------------------------------------------------------------------------------*/
/**
* Clear the JTEST_FW buffer with name buf_name.
*/
#define JTEST_CLEAR_BUFFER(buf_name) \
do \
{ \
memset(JTEST_FW.buf_name, 0, JTEST_BUF_SIZE); \
} while (0)
/**
* Clear the memory needed for the JTEST_FW's string buffer.
*/
#define JTEST_CLEAR_STR_BUFFER() \
JTEST_CLEAR_BUFFER(str_buffer)
/**
* Clear the memory needed for the JTEST_FW's data buffer.
*/
#define JTEST_CLEAR_DATA_BUFFER() \
JTEST_CLEAR_BUFFER(data_buffer)
/**
* Dump the given string to the Keil Debugger.
*/
#define JTEST_DUMP_STR(string) \
JTEST_ACT_DUMP(dump_str, str_buffer, string)
/**
* Dump a formatted string to the Keil Debugger.
*/
#if defined(ARMv7A) || defined(FILEIO)
#define JTEST_DUMP_STRF(format_str, ... ) \
do \
{ \
JTEST_CLEAR_STR_BUFFER(); \
sprintf(JTEST_FW.str_buffer,format_str, __VA_ARGS__); \
printf("%s",JTEST_FW.str_buffer); \
jtest_dump_str_segments(); \
} while (0)
#else
#define JTEST_DUMP_STRF(format_str, ... ) \
do \
{ \
JTEST_CLEAR_STR_BUFFER(); \
sprintf(JTEST_FW.str_buffer,format_str, __VA_ARGS__); \
jtest_dump_str_segments(); \
} while (0)
#endif
/* Pass/Fail Macros */
/*--------------------------------------------------------------------------------*/
/**
* Increment the number of passed tests in #JTEST_FW.
*/
#define JTEST_FW_INC_PASSED(amount) \
JTEST_PF_INC_PASSED(&JTEST_FW, amount)
/**
* Increment the number of passed tests in #JTEST_FW.
*/
#define JTEST_FW_INC_FAILED(amount) \
JTEST_PF_INC_FAILED(&JTEST_FW, amount)
/* Manipulating the Current Group */
/*--------------------------------------------------------------------------------*/
/**
* Evaluate to the current_group_ptr in #JTEST_FW.
*/
#define JTEST_CURRENT_GROUP_PTR() \
(JTEST_FW.current_group_ptr)
#define JTEST_SET_CURRENT_GROUP(group_ptr) \
do \
{ \
JTEST_CURRENT_GROUP_PTR() = group_ptr; \
} while (0)
/*--------------------------------------------------------------------------------*/
/* Declare Global Variables */
/*--------------------------------------------------------------------------------*/
extern char JTEST_FW_STR_BUFFER[JTEST_BUF_SIZE];
extern volatile JTEST_FW_t JTEST_FW;
/*--------------------------------------------------------------------------------*/
/* Function Prototypes */
/*--------------------------------------------------------------------------------*/
void jtest_dump_str_segments(void);
void test_start (void);
void test_end (void);
void group_start (void);
void group_end (void);
void dump_str (void);
void dump_data (void);
void exit_fw (void);
#endif /* _JTEST_FW_H_ */
| 9,019 |
C
| 30.872791 | 84 | 0.439517 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_define.h
|
#ifndef _JTEST_DEFINE_H_
#define _JTEST_DEFINE_H_
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Makes a symbol for use as a struct name. Names made this way have two parts;
* the first parts is a prefix common to all structs of that class. The second
* is a specifier which differs for each instance of that struct type.
*/
#define JTEST_STRUCT_NAME(prefix, specifier) \
CONCAT(prefix, specifier)
/**
* Define a struct with type with a name generated by #JTEST_STRUCT_NAME().
*/
#define JTEST_DEFINE_STRUCT(type, struct_name) \
type struct_name
/**
* Declare a struct with type with a name generated by #JTEST_STRUCT_NAME().
*/
#define JTEST_DECLARE_STRUCT(struct_definition) \
extern struct_definition
/**
* Define and initialize a struct (created with JTEST_DEFINE_STRUCT()) and
* initialize it with init_values.
*/
#define JTEST_INIT_STRUCT(struct_definition, init_values) \
struct_definition = { \
init_values \
}
#endif /* _JTEST_DEFINE_H_ */
| 1,249 |
C
| 31.894736 | 84 | 0.546037 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test_define.h
|
#ifndef _JTEST_TEST_DEFINE_H_
#define _JTEST_TEST_DEFINE_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "jtest_util.h"
#include "jtest_define.h"
#include "jtest_test.h"
/* For defining macros with optional arguments */
#include "opt_arg/opt_arg.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Prefix for all #JTEST_TEST_t structs.
*/
#define JTEST_TEST_STRUCT_NAME_PREFIX G_JTEST_TEST_STRUCT_
/**
* Define test template used by #JTEST_TEST_t tests.
*/
#define JTEST_TEST_FN_TEMPLATE(test_fn) \
JTEST_TEST_RET_t test_fn(void)
#define JTEST_TEST_FN_PROTOTYPE JTEST_TEST_FN_TEMPLATE /**< Alias for
* #JTEST_TEST_FN_TEMPLATE. */
/**
* Evaluate to the name of the #JTEST_TEST_t struct associated with test_fn.
*/
#define JTEST_TEST_STRUCT_NAME(test_fn) \
JTEST_STRUCT_NAME(JTEST_TEST_STRUCT_NAME_PREFIX, test_fn)
/**
* Define a #JTEST_TEST_t struct based on the given test_fn.
*/
#define JTEST_TEST_DEFINE_STRUCT(test_fn) \
JTEST_DEFINE_STRUCT(JTEST_TEST_t, \
JTEST_TEST_STRUCT_NAME(test_fn))
/**
* Declare a #JTEST_TEST_t struct based on the given test_fn.
*/
#define JTEST_TEST_DECLARE_STRUCT(test_fn) \
JTEST_DECLARE_STRUCT(JTEST_TEST_DEFINE_STRUCT(test_fn))
/**
* Contents needed to initialize a JTEST_TEST_t struct.
*/
#define JTEST_TEST_STRUCT_INIT(test_fn, fut, enable) \
test_fn, \
STR_NL(test_fn), \
STR_NL(fut), \
{ \
{ \
enable, \
0 \
} \
} \
/**
* Initialize the contents of a #JTEST_TEST_t struct.
*/
#define JTEST_TEST_INIT(test_fn, fut, enable) \
JTEST_TEST_DEFINE_STRUCT(test_fn) = { \
JTEST_TEST_STRUCT_INIT(test_fn, fut, enable) \
}
/* Test Definition Macro */
/*--------------------------------------------------------------------------------*/
/**
* Define a #JTEST_TEST_t object and a test function.
*/
#define _JTEST_DEFINE_TEST(test_fn, fut, enable) \
JTEST_TEST_FN_PROTOTYPE(test_fn); \
JTEST_TEST_INIT(test_fn, fut, enable); \
JTEST_TEST_FN_PROTOTYPE(test_fn) /* Notice the lacking semicolon */
/**
* Declare a #JTEST_TEST_t object and a test function prototype.
*/
#define JTEST_DECLARE_TEST(test_fn) \
JTEST_TEST_FN_PROTOTYPE(test_fn); \
JTEST_TEST_DECLARE_STRUCT(test_fn) /* Note the lacking semicolon */
/*--------------------------------------------------------------------------------*/
/* Macros with optional arguments */
/*--------------------------------------------------------------------------------*/
/* Top-level Interface */
#define JTEST_DEFINE_TEST(...) \
JTEST_DEFINE_TEST_(PP_NARG(__VA_ARGS__), ##__VA_ARGS__)
/* Dispatch Macro*/
#define JTEST_DEFINE_TEST_(N, ...) \
SPLICE(JTEST_DEFINE_TEST_, N)(__VA_ARGS__)
/* Default Arguments */
#define JTEST_DEFINE_TEST_DEFAULT_FUT /* Blank */
#define JTEST_DEFINE_TEST_DEFAULT_ENABLE \
JTEST_TRUE /* Tests enabled by
* default. */
/* Dispatch Cases*/
#define JTEST_DEFINE_TEST_1(_1) \
_JTEST_DEFINE_TEST( \
_1, \
JTEST_DEFINE_TEST_DEFAULT_FUT, \
JTEST_DEFINE_TEST_DEFAULT_ENABLE \
)
#define JTEST_DEFINE_TEST_2(_1, _2) \
_JTEST_DEFINE_TEST( \
_1, \
_2, \
JTEST_DEFINE_TEST_DEFAULT_ENABLE \
)
#define JTEST_DEFINE_TEST_3(_1, _2, _3) \
_JTEST_DEFINE_TEST( \
_1, \
_2, \
_3 \
)
#endif /* _JTEST_TEST_DEFINE_H_ */
| 5,074 |
C
| 36.873134 | 85 | 0.379582 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_util.h
|
#ifndef _JTEST_UTIL_H_
#define _JTEST_UTIL_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "util/util.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/* Define boolean values for the framework. */
#define JTEST_TRUE 1 /**< Value used for TRUE in JTEST. */
#define JTEST_FALSE 0 /**< Value used for FALSE in JTEST. */
/**
* Set the value of the attribute in the struct to by struct_ptr to value.
*/
#define JTEST_SET_STRUCT_ATTRIBUTE(struct_ptr, attribute, value) \
do \
{ \
(struct_ptr)->attribute = (value); \
} while (0)
#endif /* _JTEST_UTIL_H_ */
| 1,051 |
C
| 36.571427 | 84 | 0.323501 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_systick.h
|
#ifndef _JTEST_SYSTICK_H_
#define _JTEST_SYSTICK_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
/* Get access to the SysTick structure. */
#if defined ARMCM0
#include "ARMCM0.h"
#elif defined ARMCM0P
#include "ARMCM0plus.h"
#elif defined ARMCM0P_MPU
#include "ARMCM0plus_MPU.h"
#elif defined ARMCM3
#include "ARMCM3.h"
#elif defined ARMCM4
#include "ARMCM4.h"
#elif defined ARMCM4_FP
#include "ARMCM4_FP.h"
#elif defined ARMCM7
#include "ARMCM7.h"
#elif defined ARMCM7_SP
#include "ARMCM7_SP.h"
#elif defined ARMCM7_DP
#include "ARMCM7_DP.h"
#elif defined ARMSC000
#include "ARMSC000.h"
#elif defined ARMSC300
#include "ARMSC300.h"
#elif defined ARMv8MBL
#include "ARMv8MBL.h"
#elif defined ARMv8MML
#include "ARMv8MML.h"
#elif defined ARMv8MML_DSP
#include "ARMv8MML_DSP.h"
#elif defined ARMv8MML_SP
#include "ARMv8MML_SP.h"
#elif defined ARMv8MML_DSP_SP
#include "ARMv8MML_DSP_SP.h"
#elif defined ARMv8MML_DP
#include "ARMv8MML_DP.h"
#elif defined ARMv8MML_DSP_DP
#include "ARMv8MML_DSP_DP.h"
#elif defined ARMv7A
/* TODO */
#else
#warning "no appropriate header file found!"
#endif
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Initial value for the SysTick module.
*
* This is also the maximum value, important as SysTick is a decrementing counter.
*/
#define JTEST_SYSTICK_INITIAL_VALUE 0xFFFFFF
/**
* Reset the SysTick, decrementing timer to it's maximum value and disable it.
*
* This macro should leave the SysTick timer in a state that's ready for cycle
* counting.
*/
#define JTEST_SYSTICK_RESET(systick_ptr) \
do \
{ \
(systick_ptr)->CTRL = SysTick_CTRL_CLKSOURCE_Msk; \
\
(systick_ptr)->LOAD = JTEST_SYSTICK_INITIAL_VALUE; \
(systick_ptr)->VAL = JTEST_SYSTICK_INITIAL_VALUE; \
} while (0)
/**
* Start the SysTick timer, sourced by the processor clock.
*/
#define JTEST_SYSTICK_START(systick_ptr) \
do \
{ \
(systick_ptr)->CTRL = \
SysTick_CTRL_ENABLE_Msk | \
SysTick_CTRL_CLKSOURCE_Msk; \
} while (0)
/**
* Evaluate to the current value of the SysTick timer.
*/
#define JTEST_SYSTICK_VALUE(systick_ptr) \
((systick_ptr)->VAL)
#endif /* _JTEST_SYSTICK_H_ */
| 3,075 |
C
| 31.378947 | 84 | 0.48065 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test_call.h
|
#ifndef _JTEST_TEST_CALL_H_
#define _JTEST_TEST_CALL_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "jtest_test.h"
#include "jtest_test_define.h"
#include "jtest_fw.h"
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Exectute the test in the #JTEST_TEST_t struct associated with the identifier
* test_fn and store the result in retval.
*/
#define JTEST_TEST_RUN(retval, test_fn) \
do \
{ \
JTEST_DUMP_STR("Test Name:\n"); \
JTEST_DUMP_STR(JTEST_TEST_STRUCT_NAME(test_fn).test_fn_str); \
JTEST_DUMP_STR("Function Under Test:\n"); \
JTEST_DUMP_STR(JTEST_TEST_STRUCT_NAME(test_fn).fut_str); \
retval = JTEST_TEST_STRUCT_NAME(test_fn).test_fn_ptr(); \
} while (0)
/**
* Update the enclosing #JTEST_GROUP_t's pass/fail information based on
* test_retval.
*
* @param test_retval A #JTEST_TEST_RET_enum for the current test.
*
* @warning Only use if #JTEST_TEST_t is called in the context of a
* #JTEST_GROUP_t.
*/
#define JTEST_TEST_UPDATE_PARENT_GROUP_PF(test_retval) \
do \
{ \
/* Update enclosing JTEST_GROUP_t with pass/fail info */ \
if (test_retval == JTEST_TEST_PASSED) \
{ \
JTEST_GROUP_INC_PASSED(JTEST_CURRENT_GROUP_PTR(), 1); \
} else { \
JTEST_GROUP_INC_FAILED(JTEST_CURRENT_GROUP_PTR(), 1); \
} \
} while (0)
/**
* Update the #JTEST_FW with pass/fail information based on test_retval.
*
* @param test_retval A #JTEST_TEST_RET_enum for the current test.
*/
#define JTEST_TEST_UPDATE_FW_PF(test_retval) \
do \
{ \
/* Update the JTEST_FW with pass/fail info */ \
if (test_retval == JTEST_TEST_PASSED) \
{ \
JTEST_FW_INC_PASSED( 1); \
} else { \
JTEST_FW_INC_FAILED(1); \
} \
} while (0)
/**
* Update the enclosing JTEST_GROUP_t's pass/fail information, or the
* #JTEST_FW's if this test has no enclosing #JTEST_GROUP_t.
*
* @param test_retval A #JTEST_TEST_RET_enum for the current test.
*/
#define JTEST_TEST_UPDATE_PARENT_GROUP_OR_FW_PF(test_retval) \
do \
{ \
/* Update pass-fail information */ \
if (JTEST_CURRENT_GROUP_PTR() /* Non-null */) \
{ \
JTEST_TEST_UPDATE_PARENT_GROUP_PF(test_retval); \
} else { \
JTEST_TEST_UPDATE_FW_PF(test_retval); \
} \
} while (0)
/**
* Dump the results of the test to the Keil Debugger.
*/
#define JTEST_TEST_DUMP_RESULTS(test_retval) \
do \
{ \
if (test_retval == JTEST_TEST_PASSED) \
{ \
JTEST_DUMP_STR("Test Passed\n"); \
} else { \
JTEST_DUMP_STR("Test Failed\n"); \
} \
} while (0)
/**
* Call the #JTEST_TEST_t assocaited with the identifier test_fn.
*/
#define JTEST_TEST_CALL(test_fn) \
do \
{ \
if (JTEST_TEST_IS_ENABLED(&JTEST_TEST_STRUCT_NAME(test_fn))) \
{ \
/* Default to failure */ \
JTEST_TEST_RET_t __jtest_test_ret = JTEST_TEST_FAILED; \
\
JTEST_ACT_TEST_START(); \
JTEST_TEST_RUN(__jtest_test_ret, test_fn); \
\
/* Update pass-fail information */ \
JTEST_TEST_UPDATE_PARENT_GROUP_OR_FW_PF(__jtest_test_ret); \
\
JTEST_TEST_DUMP_RESULTS(__jtest_test_ret); \
JTEST_ACT_TEST_END(); \
} \
} while (0)
#endif /* _JTEST_TEST_CALL_H_ */
| 6,034 |
C
| 48.467213 | 84 | 0.31654 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_pf.h
|
#ifndef _JTEST_PF_H_
#define _JTEST_PF_H_
/*--------------------------------------------------------------------------------*/
/* Purpose */
/*--------------------------------------------------------------------------------*/
/* jtest_pf.h Contains macros useful for capturing pass/fail data. */
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Members that can be added to other structs to extend them pass/fail data and
* corresponding functionality.
*/
#define JTEST_PF_MEMBERS \
uint32_t passed; \
uint32_t failed /* Note the lacking semicolon*/ \
/**
* Used for initializing JTEST_PF_MEMBERS in a struct declaration.
*/
#define JTEST_PF_MEMBER_INIT \
0, \
0
/* Member-Incrementing Macros */
/*--------------------------------------------------------------------------------*/
/**
* Dispatch macro for incrementing #JTEST_PF_MEMBERS.
*
* @param xxx Values: 'passed', 'failed'
*/
#define JTEST_PF_INC_XXX(xxx, struct_pf_ptr, amount) \
do \
{ \
((struct_pf_ptr)->xxx) += (amount); \
} while (0)
/**
* Specialization of the #JTEST_PF_INC_XXX macro to increment the passed
* member.
*/
#define JTEST_PF_INC_PASSED(struct_pf_ptr, amount) \
JTEST_PF_INC_XXX(passed, struct_pf_ptr, amount)
/**
* Specialization of the #JTEST_PF_INC_XXX macro to increment the failed
* member.
*/
#define JTEST_PF_INC_FAILED(struct_pf_ptr, amount) \
JTEST_PF_INC_XXX(failed, struct_pf_ptr, amount)
/* Member-Resetting Macros */
/*--------------------------------------------------------------------------------*/
/**
* Dispatch macro for setting #JTEST_PF_MEMBERS to zero.
*
* @param xxx Values: 'passed', 'failed'
*/
#define JTEST_PF_RESET_XXX(xxx, struct_pf_ptr) \
do \
{ \
((struct_pf_ptr)->xxx) = UINT32_C(0); \
} while (0)
/**
* Specialization of #JTEST_PF_RESET_XXX for the 'passed' member.
*/
#define JTEST_PF_RESET_PASSED(struct_pf_ptr) \
JTEST_PF_RESET_XXX(passed, struct_pf_ptr)
/**
* Specialization of #JTEST_PF_RESET_XXX for the 'failed' member.
*/
#define JTEST_PF_RESET_FAILED(struct_pf_ptr) \
JTEST_PF_RESET_XXX(failed, struct_pf_ptr)
#endif /* _JTEST_PF_H_ */
| 2,655 |
C
| 29.883721 | 84 | 0.441808 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest.h
|
#ifndef _JTEST_H_
#define _JTEST_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "jtest_fw.h"
#include "jtest_test.h"
#include "jtest_test_define.h"
#include "jtest_test_call.h"
#include "jtest_group.h"
#include "jtest_group_define.h"
#include "jtest_group_call.h"
#include "jtest_cycle.h"
#endif /* _JTEST_H_ */
| 465 |
C
| 24.888888 | 84 | 0.432258 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_cycle.h
|
#ifndef _JTEST_CYCLE_H_
#define _JTEST_CYCLE_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "jtest_fw.h" /* JTEST_DUMP_STRF() */
#include "jtest_systick.h"
#include "jtest_util.h" /* STR() */
/*--------------------------------------------------------------------------------*/
/* Declare Module Variables */
/*--------------------------------------------------------------------------------*/
extern const char * JTEST_CYCLE_STRF;
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Wrap the function call, fn_call, to count execution cycles and display the
* results.
*/
/* skipp function name + param
#define JTEST_COUNT_CYCLES(fn_call) \
do \
{ \
uint32_t __jtest_cycle_end_count; \
\
JTEST_SYSTICK_RESET(SysTick); \
JTEST_SYSTICK_START(SysTick); \
\
fn_call; \
\
__jtest_cycle_end_count = \
JTEST_SYSTICK_VALUE(SysTick); \
\
JTEST_SYSTICK_RESET(SysTick); \
JTEST_DUMP_STRF(JTEST_CYCLE_STRF, \
STR(fn_call), \
(JTEST_SYSTICK_INITIAL_VALUE - \
__jtest_cycle_end_count)); \
} while (0)
*/
#ifndef ARMv7A
#define JTEST_COUNT_CYCLES(fn_call) \
do \
{ \
uint32_t __jtest_cycle_end_count; \
\
JTEST_SYSTICK_RESET(SysTick); \
JTEST_SYSTICK_START(SysTick); \
\
fn_call; \
\
__jtest_cycle_end_count = \
JTEST_SYSTICK_VALUE(SysTick); \
\
JTEST_SYSTICK_RESET(SysTick); \
JTEST_DUMP_STRF(JTEST_CYCLE_STRF, \
(JTEST_SYSTICK_INITIAL_VALUE - \
__jtest_cycle_end_count)); \
} while (0)
#else
/* TODO */
#define JTEST_COUNT_CYCLES(fn_call) \
do \
{ \
fn_call; \
} while (0)
#endif
#endif /* _JTEST_CYCLE_H_ */
| 3,264 |
C
| 39.8125 | 84 | 0.262868 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test_ret.h
|
#ifndef _JTEST_TEST_RET_H_
#define _JTEST_TEST_RET_H_
/*--------------------------------------------------------------------------------*/
/* Type Definitions */
/*--------------------------------------------------------------------------------*/
/**
* Values a #JTEST_TEST_t can return.
*/
typedef enum JTEST_TEST_RET_enum
{
JTEST_TEST_PASSED,
JTEST_TEST_FAILED
} JTEST_TEST_RET_t;
#endif /* _JTEST_TEST_RET_H_ */
| 429 |
C
| 22.888888 | 84 | 0.389277 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_group_call.h
|
#ifndef _JTEST_GROUP_CALL_H_
#define _JTEST_GROUP_CALL_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "jtest_fw.h"
#include <inttypes.h>
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Execute the test in the #JTEST_GROUP_t struct associated witht he identifier
* group_fn.
*/
#define JTEST_GROUP_RUN(group_fn) \
do \
{ \
JTEST_DUMP_STR("Group Name:\n"); \
JTEST_DUMP_STR(JTEST_GROUP_STRUCT_NAME(group_fn).name_str); \
JTEST_GROUP_STRUCT_NAME(group_fn).group_fn_ptr(); \
} while (0)
/**
* Update the enclosing #JTEST_GROUP_t's pass/fail information using the
* current #JTEST_GROUP_t's.
*
* @param group_ptr Pointer to the current #JTEST_GROUP_t.
* @param parent_ptr Pointer to the enclosing #JTEST_GROUP_t.
*
* @warning Only run this if the current #JTEST_GROUP_t is being called within
* the context of another #JTEST_GROUP_t.
*/
#define JTEST_GROUP_UPDATE_PARENT_GROUP_PF(group_ptr, parent_group_ptr) \
do \
{ \
JTEST_GROUP_INC_PASSED(parent_group_ptr, \
(group_ptr)->passed); \
JTEST_GROUP_INC_FAILED(parent_group_ptr, \
(group_ptr)->failed); \
} while (0)
/**
* Update the #JTEST_FW's pass/fail information using the current
* #JTEST_GROUP_t's.
*/
#define JTEST_GROUP_UPDATE_FW_PF(group_ptr) \
do \
{ \
JTEST_FW_INC_PASSED((group_ptr)->passed); \
JTEST_FW_INC_FAILED((group_ptr)->failed); \
} while (0)
/**
* Update the enclosing context with the current #JTEST_GROUP_t's pass/fail
* information. If this group isn't in an enclosing group, it updates the
* #JTEST_FW's pass/fail info by default.
*/
#define JTEST_GROUP_UPDATE_PARENT_GROUP_OR_FW_PF(group_ptr, \
parent_group_ptr) \
do \
{ \
/* Update the pass fail counts in the parent group */ \
if (parent_group_ptr /* Null implies Top*/) \
{ \
JTEST_GROUP_UPDATE_PARENT_GROUP_PF( \
group_ptr, \
parent_group_ptr); \
} else { \
JTEST_GROUP_UPDATE_FW_PF( \
group_ptr); \
} \
} while (0)
/**
* Dump the results of running the #JTEST_GROUP_t to the Keil Debugger.
*/
#define JTEST_GROUP_DUMP_RESULTS(group_ptr) \
do \
{ \
JTEST_DUMP_STRF( \
"Tests Run: %" PRIu32 "\n" \
"----------\n" \
" Passed: %" PRIu32 "\n" \
" Failed: %" PRIu32 "\n", \
(group_ptr)->passed + (group_ptr)->failed, \
(group_ptr)->passed, \
(group_ptr)->failed); \
} while (0)
/**
* Call the #JTEST_GROUP_t associated with the identifier group_fn.
*/
#define JTEST_GROUP_CALL(group_fn) \
do \
{ /* Save the current group from JTEST_FW_t before swapping */ \
/* it to this group (in order to restore it later )*/ \
JTEST_GROUP_t * __jtest_temp_group_ptr = \
JTEST_CURRENT_GROUP_PTR(); \
JTEST_SET_CURRENT_GROUP(&JTEST_GROUP_STRUCT_NAME(group_fn)); \
\
/* Reset this group's pass/fail count. Each group */ \
/* should only remember counts for its last execution. */ \
JTEST_GROUP_RESET_PF(JTEST_CURRENT_GROUP_PTR()); \
\
/* Run the current group */ \
JTEST_ACT_GROUP_START(); \
JTEST_GROUP_RUN(group_fn); \
JTEST_ACT_GROUP_END(); \
\
/* Update the pass fail counts in the parent group (or FW) */ \
JTEST_GROUP_UPDATE_PARENT_GROUP_OR_FW_PF( \
JTEST_CURRENT_GROUP_PTR(), \
__jtest_temp_group_ptr); \
\
JTEST_GROUP_DUMP_RESULTS(JTEST_CURRENT_GROUP_PTR()); \
\
/* Restore the previously current group */ \
JTEST_SET_CURRENT_GROUP(__jtest_temp_group_ptr); \
} while (0)
#endif /* _JTEST_GROUP_CALL_H_ */
| 6,546 |
C
| 50.551181 | 84 | 0.328903 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test.h
|
#ifndef _JTEST_TEST_H_
#define _JTEST_TEST_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include <stdint.h>
#include "jtest_util.h"
#include "jtest_test_ret.h"
/*--------------------------------------------------------------------------------*/
/* Type Definitions */
/*--------------------------------------------------------------------------------*/
/**
* A struct which represents a Test in the JTEST framework. This struct is
* used to enable, run, and describe the test it represents.
*/
typedef struct JTEST_TEST_struct
{
JTEST_TEST_RET_t ( * test_fn_ptr)(void); /**< Pointer to the test function. */
char * test_fn_str; /**< Name of the test function */
char * fut_str; /**< Name of the function under test. */
/**
* Flags that govern how the #JTEST_TEST_t behaves.
*/
union {
struct {
unsigned enabled : 1;
unsigned unused : 7;
} bits;
uint8_t byte; /* Access all flags at once. */
} flags;
} JTEST_TEST_t;
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Assign a test function to the #JTEST_TEST_t struct.
*/
#define JTEST_TEST_SET_FN(jtest_test_ptr, fn_ptr) \
JTEST_SET_STRUCT_ATTRIBUTE(jtest_test_ptr, test_fn_ptr, fn_ptr)
/**
* Specify a function under test (FUT) for the #JTEST_TEST_t struct.
*/
#define JTEST_TEST_SET_FUT(jtest_test_ptr, str) \
JTEST_SET_STRUCT_ATTRIBUTE(jtest_test_ptr, fut_str, str)
/* Macros concerning JTEST_TEST_t flags */
/*--------------------------------------------------------------------------------*/
#define JTEST_TEST_FLAG_SET 1 /**< Value of a set #JTEST_TEST_t flag. */
#define JTEST_TEST_FLAG_CLR 0 /**< Value of a cleared #JTEST_TEST_t flag. */
/**
* Evaluate to the flag in #JTEST_TEST_t having flag_name.
*/
#define JTEST_TEST_FLAG(jtest_test_ptr, flag_name) \
((jtest_test_ptr)->flags.bits.flag_name)
/**
* Dispatch macro for setting and clearing #JTEST_TEST_t flags.
*
* @param jtest_test_ptr Pointer to a #JTEST_TEST_t struct.
* @param flag_name Name of the flag to set in #JTEST_TEST_t.flags.bits
* @param xxx Vaid values: "SET" or "CLR"
*
* @note This function depends on JTEST_TEST_FLAG_SET and JTEST_TEST_FLAG_CLR.
*/
#define JTEST_TEST_XXX_FLAG(jtest_test_ptr, flag_name, xxx) \
do \
{ \
JTEST_TEST_FLAG(jtest_test_ptr, flag_name) = JTEST_TEST_FLAG_##xxx ; \
} while (0)
/**
* Specification of #JTEST_TEST_XXX_FLAG to set #JTEST_TEST_t flags.
*/
#define JTEST_TEST_SET_FLAG(jtest_test_ptr, flag_name) \
JTEST_TEST_XXX_FLAG(jtest_test_ptr, flag_name, SET)
/**
* Specification of #JTEST_TEST_XXX_FLAG to clear #JTEST_TEST_t flags.
*/
#define JTEST_TEST_CLR_FLAG(jtest_test_ptr, flag_name) \
JTEST_TEST_XXX_FLAG(jtest_test_ptr, flag_name, CLR)
/**
* Evaluate to true if the #JTEST_TEST_t is enabled.
*/
#define JTEST_TEST_IS_ENABLED(jtest_test_ptr) \
(JTEST_TEST_FLAG(jtest_test_ptr, enabled) == JTEST_TEST_FLAG_SET)
#endif /* _JTEST_TEST_H_ */
| 3,606 |
C
| 34.712871 | 84 | 0.481143 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_group.h
|
#ifndef _JTEST_GROUP_H_
#define _JTEST_GROUP_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "jtest_pf.h"
#include "jtest_util.h"
/*--------------------------------------------------------------------------------*/
/* Type Definitions */
/*--------------------------------------------------------------------------------*/
/**
* A struct which represents a group of #JTEST_TEST_t structs. This struct is
* used to run the group of tests, and report on their outcomes.
*/
typedef struct JTEST_GROUP_struct
{
void (* group_fn_ptr) (void); /**< Pointer to the test group */
char * name_str; /**< Name of the group */
/* Extend the #JTEST_GROUP_t with Pass/Fail information.*/
JTEST_PF_MEMBERS;
} JTEST_GROUP_t;
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Set the name of JTEST_GROUP_t.
*/
#define JTEST_GROUP_SET_NAME(group_ptr, name) \
JTEST_SET_STRUCT_ATTRIBUTE(group_ptr, name_str, name)
#define JTEST_GROUP_SET_FN(group_ptr, fn_ptr) \
JTEST_SET_STRUCT_ATTRIBUTE(group_ptr, group_fn_ptr, fn_ptr)
/**
* Increment the number of tests passed in the JTEST_GROUP_t pointed to by
* group_ptr.
*/
#define JTEST_GROUP_INC_PASSED(group_ptr, amount) \
JTEST_PF_INC_PASSED(group_ptr, amount)
/**
* Increment the number of tests failed in the JTEST_GROUP_t pointed to by
* group_ptr.
*/
#define JTEST_GROUP_INC_FAILED(group_ptr, amount) \
JTEST_PF_INC_FAILED(group_ptr, amount)
/**
* Reset the pass/fail information of the #JTEST_GROUP_t pointed to by
* group_ptr.
*/
#define JTEST_GROUP_RESET_PF(group_ptr) \
do \
{ \
JTEST_PF_RESET_PASSED(group_ptr); \
JTEST_PF_RESET_FAILED(group_ptr); \
} while (0)
#endif /* _JTEST_GROUP_H_ */
| 2,149 |
C
| 31.089552 | 84 | 0.46161 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/arr_desc/arr_desc.h
|
#ifndef _ARR_DESC_H_
#define _ARR_DESC_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include <stdint.h>
#include <string.h> /* memset() */
#include "../util/util.h" /* CONCAT() */
/*--------------------------------------------------------------------------------*/
/* Type Definitions */
/*--------------------------------------------------------------------------------*/
/**
* Array-descriptor struct.
*/
typedef struct ARR_DESC_struct
{
void * data_ptr; /* Pointer to the array contents. */
int32_t element_count; /* Number of current elements. */
int32_t element_size; /* Size of current elements in bytes. */
int32_t underlying_size; /* Size of underlying array in bytes. */
} ARR_DESC_t;
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Prefix of the array variable's name when creating an array and an array
* descriptor at the same time.
*/
#define ARR_DESC_ARR_PREFIX ARR_DESC_ARR_
/**
* Evaluate to the array variable's name when creating an array and an array
* descriptor at the same time.
*/
#define ARR_DESC_ARR_NAME(name) \
CONCAT(ARR_DESC_ARR_PREFIX, name)
/**
* Define an #ARR_DESC_t by itself.
*
* @note The user must supply an array to store the data used by the
* #ARR_DESC_t.
*/
#define ARR_DESC_INTERNAL_DEFINE(name, data_ptr, \
element_count, element_size) \
ARR_DESC_t name = { \
data_ptr, \
element_count, \
element_size, \
element_count * element_size \
} \
/**
* Define both an array and an #ARR_DESC_t that describes it.
*
* @note Use the #CURLY() macro for the content field; it provides the curly
* braces necessary for an array initialization.
*/
#define ARR_DESC_DEFINE(type, name, element_count, content) \
type ARR_DESC_ARR_NAME(name)[element_count] = content; \
ARR_DESC_INTERNAL_DEFINE(name, \
&ARR_DESC_ARR_NAME(name), \
element_count, \
sizeof(type)) /* Note the lacking semicolon */
/**
* Create a #ARR_DESC_t which refers to a subset of the data in another.
*
* The new #ARR_DESC_t shares the same underlying array as the aliased
* #ARR_DESC_t, but only describes a subset of the originals values.
*/
#define ARR_DESC_DEFINE_SUBSET(name, original, element_cnt) \
ARR_DESC_INTERNAL_DEFINE(name, \
&ARR_DESC_ARR_NAME(original), \
element_cnt, \
sizeof(ARR_DESC_ARR_NAME(original)[0]) \
) /* Note the lacking semicolon */
/**
* Creat an #ARR_DESC_t which points to the data in an existing array.
*
* @param start_idx Offset in array_ptr of first element.
* @param element_cnt Number of elements to include in the #ARR_DESC_t.
*
* @example
*
* float my_floats[4] = {0.0f, 1.0f, 2.0f, 3.0f};
*
* ARR_DESC_DEFINE_USING_ARR(my_arr_desc, my_floats, 1, 3);
*
* printf("Element 0: %f\n", ARR_DESC_ELT(float, 0, &my_arr_desc));
* printf("Element 1: %f\n", ARR_DESC_ELT(float, 1, &my_arr_desc));
*
* Outputs:
*
* Element 0: 1.000000
* Element 1: 2.000000
*
* @warning There are no checks in place to catch invalid start indices; This
* is left to the user.
*/
#define ARR_DESC_DEFINE_USING_ARR(type, name, array_ptr, start_idx, element_cnt) \
ARR_DESC_INTERNAL_DEFINE( \
name, \
(type *) (array_ptr + start_idx), \
element_cnt, \
sizeof(type) \
) /* Note the lacking semicolon*/
/**
* Declare an #ARR_DESC_t object.
*/
#define ARR_DESC_DECLARE(name) \
extern ARR_DESC_t name /* Note the lacking semicolon */
/**
* Evaluate to the number of bytes stored in the #ARR_DESC_t.
*/
#define ARR_DESC_BYTES(arr_desc_ptr) \
((arr_desc_ptr)->element_count * (arr_desc_ptr)->element_size)
/**
* Set the contents of #ARR_DESC_t to value.
*/
#define ARR_DESC_MEMSET(arr_desc_ptr, value, bytes) \
do \
{ \
memset((arr_desc_ptr)->data_ptr, \
value, \
BOUND(0, \
(arr_desc_ptr)->underlying_size, \
bytes) \
); \
} while (0)
/**
* Perform a memcpy of 'bytes' bytes from the source #ARR_DESC_t to the
* destination #ARR_DESC_t.
*/
#define ARR_DESC_MEMCPY(arr_desc_dest_ptr, arr_desc_src_ptr, bytes) \
do \
{ \
memcpy((arr_desc_dest_ptr)->data_ptr, \
(arr_desc_src_ptr)->data_ptr, \
BOUND(0, \
(arr_desc_dest_ptr)->underlying_size, \
bytes)); \
} while (0)
/**
* Evaluate to true if the source #ARR_DESC_t contents will fit into the
* destination #ARR_DESC_t and false otherwise.
*/
#define ARR_DESC_COPYABLE(arr_desc_dest_ptr, arr_desc_src_ptr) \
(ARR_DESC_BYTES(arr_desc_src_ptr) <= \
(arr_desc_dest_ptr)->underlying_size)
/**
* Copy all the data from the source #ARR_DESC_t to the destination
* #ARR_DESC_t.
*
* @note If the destination #ARR_DESC_t is too small to fit the source data the
* copy is aborted and nothing happens.
*/
#define ARR_DESC_COPY(arr_desc_dest_ptr, arr_desc_src_ptr) \
do \
{ \
if (ARR_DESC_COPYABLE(arr_desc_dest_ptr, \
arr_desc_src_ptr)) \
{ \
ARR_DESC_MEMCPY(arr_desc_dest_ptr, \
arr_desc_src_ptr, \
ARR_DESC_BYTES(arr_desc_src_ptr)); \
/* Update the properties*/ \
(arr_desc_dest_ptr)->element_count = \
(arr_desc_src_ptr)->element_count; \
(arr_desc_dest_ptr)->element_size = \
(arr_desc_src_ptr)->element_size; \
} \
} while (0)
/**
* Compare the data in two #ARR_DESC_t structs for the specified number of
* bytes.
*/
#define ARR_DESC_MEMCMP(arr_desc_ptr_a, arr_desc_ptr_b, bytes) \
memcmp((arr_desc_ptr_a)->data_ptr, \
(arr_desc_ptr_b)->data_ptr, \
bytes) /* Note the lacking semicolon */ \
/**
* Zero out the contents of the #ARR_DESC_t.
*/
#define ARR_DESC_ZERO(arr_desc_ptr) \
ARR_DESC_MEMSET(arr_desc_ptr, \
0, \
(arr_desc_ptr)->underlying_size)
/**
* Evaluate to the data address in #ARR_DESC_t at offset.
*/
#define ARR_DESC_DATA_ADDR(type, arr_desc_ptr, offset) \
((void*)(((type *) \
((arr_desc_ptr)->data_ptr)) \
+ offset))
/**
* Evaluate to the element in #ARR_DESC_t with type at idx.
*/
#define ARR_DESC_ELT(type, idx, arr_desc_ptr) \
(*((type *) ARR_DESC_DATA_ADDR(type, \
arr_desc_ptr, \
idx)))
#endif /* _ARR_DESC_H_ */
| 8,980 |
C
| 39.638009 | 84 | 0.412027 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/util/util.h
|
#ifndef _UTIL_H_
#define _UTIL_H_
/*--------------------------------------------------------------------------------*/
/* Macros and Defines */
/*--------------------------------------------------------------------------------*/
/**
* Convert a symbol to a string and add a 'NewLine'.
*/
#define STR_NL(x) STR1_NL(x)
#define STR1_NL(x) (STR2_NL(x)"\n")
#define STR2_NL(x) #x
/**
* Convert a symbol to a string.
*/
#define STR(x) STR1(x)
#define STR1(x) STR2(x)
#define STR2(x) #x
/**
* Concatenate two symbols.
*/
#define CONCAT(a, b) CONCAT1(a, b)
#define CONCAT1(a, b) CONCAT2(a, b)
#define CONCAT2(a, b) a##b
/**
* Place curly braces around a varaible number of macro arguments.
*/
#define CURLY(...) {__VA_ARGS__}
/**
* Place parenthesis around a variable number of macro arguments.
*/
#define PAREN(...) (__VA_ARGS__)
/* Standard min/max macros. */
#define MIN(x,y) (((x) < (y)) ? (x) : (y) )
#define MAX(x,y) (((x) > (y)) ? (x) : (y) )
/**
* Bound value using low and high limits.
*
* Evaluate to a number in the range, endpoint inclusive.
*/
#define BOUND(low, high, value) \
MAX(MIN(high, value), low)
#endif /* _UTIL_H_ */
| 1,186 |
C
| 21.396226 | 84 | 0.50253 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/pp_narg.h
|
#ifndef _PP_NARG_H_
#define _PP_NARG_H_
#define PP_NARG(...) \
PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...) \
PP_ARG_N(__VA_ARGS__)
#define PP_ARG_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
_61,_62,_63,N,...) N
#define PP_RSEQ_N() \
63,62,61,60, \
59,58,57,56,55,54,53,52,51,50, \
49,48,47,46,45,44,43,42,41,40, \
39,38,37,36,35,34,33,32,31,30, \
29,28,27,26,25,24,23,22,21,20, \
19,18,17,16,15,14,13,12,11,10, \
9,8,7,6,5,4,3,2,1,0
#endif /* _PP_NARG_H_ */
| 1,157 |
C
| 43.53846 | 59 | 0.306828 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/opt_arg.h
|
#ifndef _OPT_ARG_H_
#define _OPT_ARG_H_
/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "pp_narg.h"
#include "splice.h"
/* If you are Joseph Jaoudi, you have a snippet which expands into an
example. If you are not Joseph, but possess his code, study the examples. If
you have no examples, turn back contact Joseph. */
#endif /* _OPT_ARG_H_ */
| 499 |
C
| 30.249998 | 84 | 0.448898 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/splice.h
|
#ifndef _SPLICE_H_
#define _SPLICE_H_
#define SPLICE(a,b) SPLICE_1(a,b)
#define SPLICE_1(a,b) SPLICE_2(a,b)
#define SPLICE_2(a,b) a##b
#endif /* _SPLICE_H_ */
| 161 |
C
| 16.999998 | 35 | 0.63354 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/rfft.c
|
#include "ref.h"
#include "arm_const_structs.h"
void ref_rfft_f32(
arm_rfft_instance_f32 * S,
float32_t * pSrc,
float32_t * pDst)
{
uint32_t i;
if (S->ifftFlagR)
{
for(i=0;i<S->fftLenReal*2;i++)
{
pDst[i] = pSrc[i];
}
}
else
{
for(i=0;i<S->fftLenReal;i++)
{
pDst[2*i+0] = pSrc[i];
pDst[2*i+1] = 0.0f;
}
}
switch(S->fftLenReal)
{
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, pDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, pDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, pDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 8192:
ref_cfft_f32(&ref_cfft_sR_f32_len8192, pDst, S->ifftFlagR, S->bitReverseFlagR);
break;
}
if (S->ifftFlagR)
{
//throw away the imaginary part which should be all zeros
for(i=0;i<S->fftLenReal;i++)
{
pDst[i] = pDst[2*i];
}
}
}
void ref_rfft_fast_f32(
arm_rfft_fast_instance_f32 * S,
float32_t * p, float32_t * pOut,
uint8_t ifftFlag)
{
uint32_t i,j;
if (ifftFlag)
{
for(i=0;i<S->fftLenRFFT;i++)
{
pOut[i] = p[i];
}
//unpack first sample's complex part into middle sample's real part
pOut[S->fftLenRFFT] = pOut[1];
pOut[S->fftLenRFFT+1] = 0;
pOut[1] = 0;
j=4;
for(i = S->fftLenRFFT / 2 + 1;i < S->fftLenRFFT;i++)
{
pOut[2*i+0] = p[2*i+0 - j];
pOut[2*i+1] = -p[2*i+1 - j];
j+=4;
}
}
else
{
for(i=0;i<S->fftLenRFFT;i++)
{
pOut[2*i+0] = p[i];
pOut[2*i+1] = 0.0f;
}
}
switch(S->fftLenRFFT)
{
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, pOut, ifftFlag, 1);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, pOut, ifftFlag, 1);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, pOut, ifftFlag, 1);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, pOut, ifftFlag, 1);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, pOut, ifftFlag, 1);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, pOut, ifftFlag, 1);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, pOut, ifftFlag, 1);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, pOut, ifftFlag, 1);
break;
}
if (ifftFlag)
{
//throw away the imaginary part which should be all zeros
for(i=0;i<S->fftLenRFFT;i++)
{
pOut[i] = pOut[2*i];
}
}
else
{
//pack last sample's real part into first sample's complex part
pOut[1] = pOut[S->fftLenRFFT];
}
}
void ref_rfft_q31(
const arm_rfft_instance_q31 * S,
q31_t * pSrc,
q31_t * pDst)
{
uint32_t i;
float32_t *fDst = (float32_t*)pDst;
if (S->ifftFlagR)
{
for(i=0;i<S->fftLenReal*2;i++)
{
fDst[i] = (float32_t)pSrc[i] / 2147483648.0f;
}
}
else
{
for(i=0;i<S->fftLenReal;i++)
{
fDst[2*i+0] = (float32_t)pSrc[i] / 2147483648.0f;
fDst[2*i+1] = 0.0f;
}
}
switch(S->fftLenReal)
{
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 8192:
ref_cfft_f32(&ref_cfft_sR_f32_len8192, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
}
if (S->ifftFlagR)
{
//throw away the imaginary part which should be all zeros
for(i=0;i<S->fftLenReal;i++)
{
//read the float data, scale up for q31, cast to q31
pDst[i] = (q31_t)( fDst[2*i] * 2147483648.0f);
}
}
else
{
for(i=0;i<S->fftLenReal;i++)
{
//read the float data, scale up for q31, cast to q31
pDst[i] = (q31_t)( fDst[i] * 2147483648.0f / (float32_t)S->fftLenReal);
}
}
}
void ref_rfft_q15(
const arm_rfft_instance_q15 * S,
q15_t * pSrc,
q15_t * pDst)
{
uint32_t i;
float32_t *fDst = (float32_t*)pDst;
if (S->ifftFlagR)
{
for(i=0;i<S->fftLenReal*2;i++)
{
fDst[i] = (float32_t)pSrc[i] / 32768.0f;
}
}
else
{
for(i=0;i<S->fftLenReal;i++)
{
//read the q15 data, cast to float, scale down for float
fDst[2*i+0] = (float32_t)pSrc[i] / 32768.0f;
fDst[2*i+1] = 0.0f;
}
}
switch(S->fftLenReal)
{
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
case 8192:
ref_cfft_f32(&ref_cfft_sR_f32_len8192, fDst, S->ifftFlagR, S->bitReverseFlagR);
break;
}
if (S->ifftFlagR)
{
//throw away the imaginary part which should be all zeros
for(i=0;i<S->fftLenReal;i++)
{
pDst[i] = (q15_t)( fDst[2*i] * 32768.0f);
}
}
else
{
for(i=0;i<S->fftLenReal;i++)
{
pDst[i] = (q15_t)( fDst[i] * 32768.0f / (float32_t)S->fftLenReal);
}
}
}
| 6,134 |
C
| 19.247525 | 82 | 0.59537 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/TransformFunctions.c
|
#include "cfft.c"
#include "dct4.c"
#include "rfft.c"
| 55 |
C
| 10.199998 | 17 | 0.654545 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/bitreversal.c
|
#include "ref.h"
;/*
;* @brief In-place bit reversal function.
;* @param[in, out] *pSrc points to the in-place buffer of unknown 32-bit data type.
;* @param[in] bitRevLen bit reversal table length
;* @param[in] *pBitRevTab points to bit reversal table.
;* @return none.
;*/
void ref_arm_bitreversal_32(uint32_t *pSrc, uint32_t bitRevLen, uint32_t *pBitRevTab)
{
uint32_t a,b,i,tmp;
for(i=0; i<bitRevLen; i++)
{
a = pBitRevTab[2*i];
b = pBitRevTab[2*i + 1];
//real
tmp = pSrc[a];
pSrc[a] = pSrc[b];
pSrc[b] = tmp;
//complex
tmp = pSrc[a+1];
pSrc[a+1] = pSrc[b+1];
pSrc[b+1] = tmp;
}
}
| 657 |
C
| 20.225806 | 91 | 0.579909 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/dct4.c
|
#include "ref.h"
void ref_dct4_f32(
const arm_dct4_instance_f32 * S,
float32_t * pState,
float32_t * pInlineBuffer)
{
uint32_t n,k;
float32_t sum;
float32_t pi_by_N = 3.14159265358979f / (float32_t)S->N;
float32_t tmp;
float32_t normalize = sqrtf(2.0f / (float32_t)S->N);
for(k=0;k<S->N;k++)
{
sum=0.0f;
tmp = ((float32_t)k + 0.5f)*pi_by_N;
for(n=0;n<S->N;n++)
{
sum += pInlineBuffer[n] * cosf(tmp * ((float32_t)n + 0.5f));
}
scratchArray[k] = normalize * sum;
}
for(k=0;k<S->N;k++)
{
pInlineBuffer[k] = scratchArray[k];
}
}
void ref_dct4_q31(
const arm_dct4_instance_q31 * S,
q31_t * pState,
q31_t * pInlineBuffer)
{
arm_dct4_instance_f32 SS;
float32_t *fSrc = (float32_t*)pInlineBuffer;
uint32_t i;
SS.N = S->N;
for(i=0;i<S->N;i++)
{
//read the q31 data, cast to float, scale down for float
fSrc[i] = (float32_t)pInlineBuffer[i] / 2147483648.0f;
}
ref_dct4_f32(&SS,(float32_t*)0,fSrc);
for(i=0;i<S->N;i++)
{
fSrc[i] = fSrc[i] * 2147483648.0f / (float32_t)S->N ;
fSrc[i] += (fSrc[i] > 0) ? 0.5f : -0.5f;
pInlineBuffer[i] = (q31_t)fSrc[i];
}
}
void ref_dct4_q15(
const arm_dct4_instance_q15 * S,
q15_t * pState,
q15_t * pInlineBuffer)
{
arm_dct4_instance_f32 SS;
float32_t *fSrc = (float32_t*)pInlineBuffer;
uint32_t i;
SS.N = S->N;
for(i=0;i<S->N;i++)
{
//read the q15 data, cast to float, scale down for float, place in temporary buffer
scratchArray[i] = (float32_t)pInlineBuffer[i] / 32768.0f;
}
for(i=0;i<S->N;i++)
{
//copy from temp buffer to final buffer
fSrc[i] = scratchArray[i];
}
ref_dct4_f32(&SS,(float32_t*)0,fSrc);
for(i=0;i<S->N;i++)
{
fSrc[i] = fSrc[i] * 32768.0f / (float32_t)S->N;
fSrc[i] += (fSrc[i] > 0) ? 0.5f : -0.5f;
pInlineBuffer[i] = (q15_t)fSrc[i];
}
}
| 1,808 |
C
| 19.1 | 85 | 0.587389 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/cfft.c
|
#include "ref.h"
#include "arm_const_structs.h"
void ref_cfft_f32(
const arm_cfft_instance_f32 * S,
float32_t * p1,
uint8_t ifftFlag,
uint8_t bitReverseFlag)
{
int n, mmax, m, j, istep, i;
float32_t wtemp, wr, wpr, wpi, wi, theta;
float32_t tempr, tempi;
float32_t * data = p1;
uint32_t N = S->fftLen;
int32_t dir = (ifftFlag) ? -1 : 1;
// decrement pointer since the original version used fortran style indexing.
data--;
n = N << 1;
j = 1;
for (i = 1; i < n; i += 2) {
if (j > i) {
tempr = data[j]; data[j] = data[i]; data[i] = tempr;
tempr = data[j+1]; data[j+1] = data[i+1]; data[i+1] = tempr;
}
m = n >> 1;
while (m >= 2 && j > m) {
j -= m;
m >>= 1;
}
j += m;
}
mmax = 2;
while (n > mmax) {
istep = 2*mmax;
theta = -6.283185307179586f/(dir*mmax);
wtemp = sinf(0.5f*theta);
wpr = -2.0f*wtemp*wtemp;
wpi = sinf(theta);
wr = 1.0f;
wi = 0.0f;
for (m = 1; m < mmax; m += 2) {
for (i = m; i <= n; i += istep) {
j =i + mmax;
tempr = wr*data[j] - wi*data[j+1];
tempi = wr*data[j+1] + wi*data[j];
data[j] = data[i] - tempr;
data[j+1] = data[i+1] - tempi;
data[i] += tempr;
data[i+1] += tempi;
}
wr = (wtemp = wr)*wpr - wi*wpi + wr;
wi = wi*wpr + wtemp*wpi + wi;
}
mmax = istep;
}
// Inverse transform is scaled by 1/N
if (ifftFlag)
{
data++;
for(i = 0; i<2*N; i++)
{
data[i] /= N;
}
}
}
void ref_cfft_q31(
const arm_cfft_instance_q31 * S,
q31_t * p1,
uint8_t ifftFlag,
uint8_t bitReverseFlag)
{
uint32_t i;
float32_t *fSrc = (float32_t*)p1;
for(i=0;i<S->fftLen*2;i++)
{
//read the q31 data, cast to float, scale down for float
fSrc[i] = (float32_t)p1[i] / 2147483648.0f;
}
switch(S->fftLen)
{
case 16:
ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, ifftFlag, bitReverseFlag);
break;
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, ifftFlag, bitReverseFlag);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, ifftFlag, bitReverseFlag);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, ifftFlag, bitReverseFlag);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, ifftFlag, bitReverseFlag);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, ifftFlag, bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, ifftFlag, bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, ifftFlag, bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, ifftFlag, bitReverseFlag);
break;
}
if (ifftFlag)
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q31, cast to q31
p1[i] = (q31_t)( fSrc[i] * 2147483648.0f );
}
}
else
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q31, cast to q31
p1[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_q15(
const arm_cfft_instance_q15 * S,
q15_t * pSrc,
uint8_t ifftFlag,
uint8_t bitReverseFlag)
{
uint32_t i;
float32_t *fSrc = (float32_t*)pSrc;
for(i=0;i<S->fftLen*2;i++)
{
//read the q15 data, cast to float, scale down for float, place in temporary buffer
scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
}
for(i=0;i<S->fftLen*2;i++)
{
//copy from temp buffer to final buffer
fSrc[i] = scratchArray[i];
}
switch(S->fftLen)
{
case 16:
ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, ifftFlag, bitReverseFlag);
break;
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, ifftFlag, bitReverseFlag);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, ifftFlag, bitReverseFlag);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, ifftFlag, bitReverseFlag);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, ifftFlag, bitReverseFlag);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, ifftFlag, bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, ifftFlag, bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, ifftFlag, bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, ifftFlag, bitReverseFlag);
break;
}
if (ifftFlag)
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
}
}
else
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_radix2_f32(
const arm_cfft_radix2_instance_f32 * S,
float32_t * pSrc)
{
switch(S->fftLen)
{
case 16:
ref_cfft_f32(&arm_cfft_sR_f32_len16, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
}
}
void ref_cfft_radix2_q31(
const arm_cfft_radix2_instance_q31 * S,
q31_t * pSrc)
{
uint32_t i;
float32_t *fSrc = (float32_t*)pSrc;
for(i=0;i<S->fftLen*2;i++)
{
//read the q31 data, cast to float, scale down for float
fSrc[i] = (float32_t)pSrc[i] / 2147483648.0f;
}
switch(S->fftLen)
{
case 16:
ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
}
if (S->ifftFlag)
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q31, cast to q31
pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f );
}
}
else
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q31, cast to q31
pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_radix2_q15(
const arm_cfft_radix2_instance_q15 * S,
q15_t * pSrc)
{
uint32_t i;
float32_t *fSrc = (float32_t*)pSrc;
for(i=0;i<S->fftLen*2;i++)
{
//read the q15 data, cast to float, scale down for float, place in temporary buffer
scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
}
for(i=0;i<S->fftLen*2;i++)
{
//copy from temp buffer to final buffer
fSrc[i] = scratchArray[i];
}
switch(S->fftLen)
{
case 16:
ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
}
if (S->ifftFlag)
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
}
}
else
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_radix4_f32(
const arm_cfft_radix4_instance_f32 * S,
float32_t * pSrc)
{
switch(S->fftLen)
{
case 16:
ref_cfft_f32(&arm_cfft_sR_f32_len16, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, pSrc, S->ifftFlag, S->bitReverseFlag);
break;
}
}
void ref_cfft_radix4_q31(
const arm_cfft_radix4_instance_q31 * S,
q31_t * pSrc)
{
uint32_t i;
float32_t *fSrc = (float32_t*)pSrc;
for(i=0;i<S->fftLen*2;i++)
{
//read the q31 data, cast to float, scale down for float
fSrc[i] = (float32_t)pSrc[i] / 2147483648.0f;
}
switch(S->fftLen)
{
case 16:
ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
}
if (S->ifftFlag)
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q31, cast to q31
pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f );
}
}
else
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q31, cast to q31
pSrc[i] = (q31_t)( fSrc[i] * 2147483648.0f / (float32_t)S->fftLen);
}
}
}
void ref_cfft_radix4_q15(
const arm_cfft_radix4_instance_q15 * S,
q15_t * pSrc)
{
uint32_t i;
float32_t *fSrc = (float32_t*)pSrc;
for(i=0;i<S->fftLen*2;i++)
{
//read the q15 data, cast to float, scale down for float, place in temporary buffer
scratchArray[i] = (float32_t)pSrc[i] / 32768.0f;
}
for(i=0;i<S->fftLen*2;i++)
{
//copy from temp buffer to final buffer
fSrc[i] = scratchArray[i];
}
switch(S->fftLen)
{
case 16:
ref_cfft_f32(&arm_cfft_sR_f32_len16, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 32:
ref_cfft_f32(&arm_cfft_sR_f32_len32, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 64:
ref_cfft_f32(&arm_cfft_sR_f32_len64, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 128:
ref_cfft_f32(&arm_cfft_sR_f32_len128, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 256:
ref_cfft_f32(&arm_cfft_sR_f32_len256, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 512:
ref_cfft_f32(&arm_cfft_sR_f32_len512, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 1024:
ref_cfft_f32(&arm_cfft_sR_f32_len1024, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 2048:
ref_cfft_f32(&arm_cfft_sR_f32_len2048, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
case 4096:
ref_cfft_f32(&arm_cfft_sR_f32_len4096, fSrc, S->ifftFlag, S->bitReverseFlag);
break;
}
if (S->ifftFlag)
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)( fSrc[i] * 32768.0f );
}
}
else
{
for(i=0;i<S->fftLen*2;i++)
{
//read the float data, scale up for q15, cast to q15
pSrc[i] = (q15_t)( fSrc[i] * 32768.0f / (float32_t)S->fftLen);
}
}
}
| 13,641 |
C
| 21.774624 | 85 | 0.606627 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/Intrinsics/Intrinsics_.c
|
#include "intrinsics.c"
| 26 |
C
| 5.749999 | 23 | 0.692308 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/Intrinsics/intrinsics.c
|
#include "ref.h"
q31_t ref__QADD8(q31_t x, q31_t y)
{
q31_t sum;
q7_t r, s, t, u;
r = (q7_t) x;
s = (q7_t) y;
r = ref_sat_n((q31_t) (r + s), 8);
s = ref_sat_n(((q31_t) (((x << 16) >> 24) + ((y << 16) >> 24))), 8);
t = ref_sat_n(((q31_t) (((x << 8) >> 24) + ((y << 8) >> 24))), 8);
u = ref_sat_n(((q31_t) ((x >> 24) + (y >> 24))), 8);
sum =
(((q31_t) u << 24) & 0xFF000000) | (((q31_t) t << 16) & 0x00FF0000) |
(((q31_t) s << 8) & 0x0000FF00) | (r & 0x000000FF);
return sum;
}
q31_t ref__QSUB8(q31_t x, q31_t y)
{
q31_t sum;
q31_t r, s, t, u;
r = (q7_t) x;
s = (q7_t) y;
r = ref_sat_n((r - s), 8);
s = ref_sat_n(((q31_t) (((x << 16) >> 24) - ((y << 16) >> 24))), 8) << 8;
t = ref_sat_n(((q31_t) (((x << 8) >> 24) - ((y << 8) >> 24))), 8) << 16;
u = ref_sat_n(((q31_t) ((x >> 24) - (y >> 24))), 8) << 24;
sum = (u & 0xFF000000) | (t & 0x00FF0000) | (s & 0x0000FF00) | (r & 0x000000FF);
return sum;
}
q31_t ref__QADD16(q31_t x, q31_t y)
{
q31_t sum;
q31_t r, s;
r = (q15_t) x;
s = (q15_t) y;
r = ref_sat_q15(r + s);
s = (q31_t)ref_sat_q15(((q31_t) ((x >> 16) + (y >> 16)))) << 16;
sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);
return sum;
}
q31_t ref__SHADD16(q31_t x, q31_t y)
{
q31_t sum;
q31_t r, s;
r = (q15_t) x;
s = (q15_t) y;
r = (r + s) >> 1;
s = ((q31_t) (((x >> 16) + (y >> 16)) >> 1) << 16);
sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);
return sum;
}
q31_t ref__QSUB16(q31_t x, q31_t y)
{
q31_t sum;
q31_t r, s;
r = (q15_t) x;
s = (q15_t) y;
r = ref_sat_q15(r - s);
s = (q31_t)ref_sat_q15(((q31_t) ((x >> 16) - (y >> 16)))) << 16;
sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);
return sum;
}
q31_t ref__SHSUB16(q31_t x, q31_t y)
{
q31_t diff;
q31_t r, s;
r = (q15_t) x;
s = (q15_t) y;
r = ((r >> 1) - (s >> 1));
s = (((x >> 17) - (y >> 17)) << 16);
diff = (s & 0xFFFF0000) | (r & 0x0000FFFF);
return diff;
}
q31_t ref__QASX(q31_t x, q31_t y)
{
q31_t sum = 0;
q31_t xL, xH, yL, yH;
// extract bottom halfword and sign extend
xL = (q15_t)(x & 0xffff);
// extract bottom halfword and sign extend
yL = (q15_t)(y & 0xffff);
// extract top halfword and sign extend
xH = (q15_t)(x >> 16);
// extract top halfword and sign extend
yH = (q15_t)(y >> 16);
sum = (((q31_t)ref_sat_q15(xH + yL )) << 16) |
(((q31_t)ref_sat_q15(xL - yH )) & 0xffff);
return sum;
}
q31_t ref__SHASX(q31_t x, q31_t y)
{
q31_t sum;
q31_t r, s;
r = (q15_t) x;
s = (q15_t) y;
r = (r - (y >> 16)) / 2;
s = (((x >> 16) + s) << 15);
sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);
return sum;
}
q31_t ref__QSAX(q31_t x, q31_t y)
{
q31_t sum = 0;
q31_t xL, xH, yL, yH;
// extract bottom halfword and sign extend
xL = (q15_t)(x & 0xffff);
// extract bottom halfword and sign extend
yL = (q15_t)(y & 0xffff);
// extract top halfword and sign extend
xH = (q15_t)(x >> 16);
// extract top halfword and sign extend
yH = (q15_t)(y >> 16);
sum = (((q31_t)ref_sat_q15(xH - yL )) << 16) |
(((q31_t)ref_sat_q15(xL + yH )) & 0xffff);
return sum;
}
q31_t ref__SHSAX(q31_t x, q31_t y)
{
q31_t sum;
q31_t r, s;
r = (q15_t) x;
s = (q15_t) y;
r = (r + (y >> 16)) / 2;
s = (((x >> 16) - s) << 15);
sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);
return sum;
}
q31_t ref__SMUSDX(q31_t x, q31_t y)
{
return ((q31_t) (((q15_t) x * (q15_t) (y >> 16)) - ((q15_t) (x >> 16) * (q15_t) y)));
}
q31_t ref__SMUADX(q31_t x, q31_t y)
{
return ((q31_t) (((q15_t) x * (q15_t) (y >> 16)) + ((q15_t) (x >> 16) * (q15_t) y)));
}
q31_t ref__QADD(q31_t x, q31_t y)
{
return ref_sat_q31((q63_t) x + y);
}
q31_t ref__QSUB(q31_t x, q31_t y)
{
return ref_sat_q31((q63_t) x - y);
}
q31_t ref__SMLAD(q31_t x, q31_t y, q31_t sum)
{
return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) + ((q15_t) x * (q15_t) y));
}
q31_t ref__SMLADX(q31_t x, q31_t y, q31_t sum)
{
return (sum + ((q15_t) (x >> 16) * (q15_t) (y)) + ((q15_t) x * (q15_t) (y >> 16)));
}
q31_t ref__SMLSDX(q31_t x, q31_t y, q31_t sum)
{
return (sum - ((q15_t) (x >> 16) * (q15_t) (y)) + ((q15_t) x * (q15_t) (y >> 16)));
}
q63_t ref__SMLALD(q31_t x, q31_t y, q63_t sum)
{
return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) + ((q15_t) x * (q15_t) y));
}
q63_t ref__SMLALDX(q31_t x, q31_t y, q63_t sum)
{
return (sum + ((q15_t) (x >> 16) * (q15_t) y)) + ((q15_t) x * (q15_t) (y >> 16));
}
q31_t ref__SMUAD(q31_t x, q31_t y)
{
return (((x >> 16) * (y >> 16)) + (((x << 16) >> 16) * ((y << 16) >> 16)));
}
q31_t ref__SMUSD(q31_t x, q31_t y)
{
return (-((x >> 16) * (y >> 16)) + (((x << 16) >> 16) * ((y << 16) >> 16)));
}
q31_t ref__SXTB16(q31_t x)
{
return ((((x << 24) >> 24) & 0x0000FFFF) | (((x << 8) >> 8) & 0xFFFF0000));
}
| 4,901 |
C
| 19.51046 | 88 | 0.450928 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/HelperFunctions/mat_helper.c
|
#include "ref.h"
float32_t ref_detrm(float32_t *pSrc, float32_t *temp, uint32_t size)
{
float32_t s = 1, det = 0;
int i, j, m, n, c;
if ( size == 1 )
{
return ( pSrc[ 0 ] );
}
else
{
det = 0;
for ( c = 0;c < size;c++ )
{
m = 0;
n = 0;
for ( i = 0;i < size;i++ )
{
for ( j = 0;j < size;j++ )
{
temp[ i*size + j ] = 0;
if ( i != 0 && j != c )
{
temp[ m*(size-1) + n ] = pSrc[ i*size + j ];
if ( n < ( size - 2 ) )
{
n++;
}
else
{
n = 0;
m++;
}
}
}
}
det += s * ( pSrc[ c ] * ref_detrm( temp, temp + size*size, size - 1 ) );
s = -s;
}
}
return ( det );
}
void ref_cofact(float32_t *pSrc, float32_t *pDst, float32_t *temp, uint32_t size)
{
int p, q, m, n, i, j;
if (size == 1)
{
pDst[0] = 1;
return;
}
for ( q = 0;q < size;q++ )
{
for ( p = 0;p < size;p++ )
{
m = 0;
n = 0;
for ( i = 0;i < size;i++ )
{
for ( j = 0;j < size;j++ )
{
temp[ i*size + j ] = 0;
if ( i != q && j != p )
{
temp[ m*(size-1) + n ] = pSrc[ i*size + j ];
if ( n < ( size - 2 ) )
{
n++;
}
else
{
n = 0;
m++;
}
}
}
}
pDst[ q*size + p ] = ref_pow( -1, q + p ) * ref_detrm( temp, temp + (size-1)*(size-1), size - 1 );
}
}
}
float64_t ref_detrm64(float64_t *pSrc, float64_t *temp, uint32_t size)
{
float64_t s = 1, det = 0;
int i, j, m, n, c;
if ( size == 1 )
{
return ( pSrc[ 0 ] );
}
else
{
det = 0;
for ( c = 0;c < size;c++ )
{
m = 0;
n = 0;
for ( i = 0;i < size;i++ )
{
for ( j = 0;j < size;j++ )
{
temp[ i*size + j ] = 0;
if ( i != 0 && j != c )
{
temp[ m*(size-1) + n ] = pSrc[ i*size + j ];
if ( n < ( size - 2 ) )
{
n++;
}
else
{
n = 0;
m++;
}
}
}
}
det += s * ( pSrc[ c ] * ref_detrm64( temp, temp + size*size, size - 1 ) );
s = -s;
}
}
return ( det );
}
void ref_cofact64(float64_t *pSrc, float64_t *pDst, float64_t *temp, uint32_t size)
{
int p, q, m, n, i, j;
if (size == 1)
{
pDst[0] = 1;
return;
}
for ( q = 0;q < size;q++ )
{
for ( p = 0;p < size;p++ )
{
m = 0;
n = 0;
for ( i = 0;i < size;i++ )
{
for ( j = 0;j < size;j++ )
{
temp[ i*size + j ] = 0;
if ( i != q && j != p )
{
temp[ m*(size-1) + n ] = pSrc[ i*size + j ];
if ( n < ( size - 2 ) )
{
n++;
}
else
{
n = 0;
m++;
}
}
}
}
pDst[ q*size + p ] = ref_pow( -1, q + p ) * ref_detrm64( temp, temp + (size-1)*(size-1), size - 1 );
}
}
}
| 3,723 |
C
| 18.195876 | 109 | 0.262423 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/HelperFunctions/HelperFunctions.c
|
#include "mat_helper.c"
#include "ref_helper.c"
| 50 |
C
| 9.199998 | 23 | 0.68 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/HelperFunctions/ref_helper.c
|
#include "ref.h"
float32_t scratchArray[8192*2];
arm_cfft_instance_f32 ref_cfft_sR_f32_len8192 = { 8192, 0, 0, 0 };
q31_t ref_sat_n(q31_t num, uint32_t bits)
{
int32_t posMax, negMin;
uint32_t i;
posMax = 1;
for (i = 0; i < (bits - 1); i++)
{
posMax = posMax * 2;
}
if (num > 0)
{
posMax = (posMax - 1);
if (num > posMax)
{
num = posMax;
}
}
else
{
negMin = -posMax;
if (num < negMin)
{
num = negMin;
}
}
return (num);
}
q31_t ref_sat_q31(q63_t num)
{
if (num > (q63_t)INT_MAX)
{
return INT_MAX;
}
else if (num < (q63_t)0xffffffff80000000ll)
{
return INT_MIN;
}
else
{
return (q31_t)num;
}
}
q15_t ref_sat_q15(q31_t num)
{
if (num > (q31_t)SHRT_MAX)
{
return SHRT_MAX;
}
else if (num < (q31_t)0xffff8000)
{
return SHRT_MIN;
}
else
{
return (q15_t)num;
}
}
q7_t ref_sat_q7(q15_t num)
{
if (num > (q15_t)SCHAR_MAX)
{
return SCHAR_MAX;
}
else if (num < (q15_t)0xff80)
{
return SCHAR_MIN;
}
else
{
return (q7_t)num;
}
}
float32_t ref_pow(float32_t a, uint32_t b)
{
uint32_t i;
float32_t r = a;
for(i=1;i<b;i++)
{
r *= a;
}
if ( b == 0)
{
return 1;
}
return r;
}
| 1,173 |
C
| 10.288461 | 66 | 0.543052 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/cmplx_mag.c
|
#include "ref.h"
void ref_cmplx_mag_f32(
float32_t * pSrc,
float32_t * pDst,
uint32_t numSamples)
{
uint32_t i;
for(i=0;i<numSamples*2;i+=2)
{
*pDst++ = sqrtf(pSrc[i] * pSrc[i] + pSrc[i+1] * pSrc[i+1]);
}
}
void ref_cmplx_mag_q31(
q31_t * pSrc,
q31_t * pDst,
uint32_t numSamples)
{
uint32_t i;
q31_t acc0,acc1,out;
for(i=0;i<numSamples*2;i+=2)
{
acc0 = (q31_t)(((q63_t)pSrc[i] * pSrc[i]) >> 33);
acc1 = (q31_t)(((q63_t)pSrc[i+1] * pSrc[i+1]) >> 33);
out = acc0 + acc1;
*pDst++ = (q31_t)(sqrtf((float)out / 2147483648.0f) * 2147483648.0f);
}
}
void ref_cmplx_mag_q15(
q15_t * pSrc,
q15_t * pDst,
uint32_t numSamples)
{
uint32_t i;
q31_t acc0,acc1;
q15_t out;
for(i=0;i<numSamples*2;i+=2)
{
acc0 = pSrc[i] * pSrc[i];
acc1 = pSrc[i+1] * pSrc[i+1];
out = (q15_t) (((q63_t) acc0 + acc1) >> 17);
*pDst++ = (q15_t)(sqrtf((float)out / 32768.0f) * 32768.0f);
}
}
| 914 |
C
| 17.3 | 71 | 0.557987 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/cmplx_dot_prod.c
|
#include "ref.h"
void ref_cmplx_dot_prod_f32(
float32_t * pSrcA,
float32_t * pSrcB,
uint32_t numSamples,
float32_t * realResult,
float32_t * imagResult)
{
float32_t sumr, sumi;
uint32_t i;
sumr = 0;
sumi = 0;
for(i=0;i<numSamples*2;i+=2)
{
sumr += pSrcA[i] * pSrcB[i] - pSrcA[i+1] * pSrcB[i+1];
sumi += pSrcA[i] * pSrcB[i+1] + pSrcA[i+1] * pSrcB[i];
}
*realResult = sumr;
*imagResult = sumi;
}
void ref_cmplx_dot_prod_q31(
q31_t * pSrcA,
q31_t * pSrcB,
uint32_t numSamples,
q63_t * realResult,
q63_t * imagResult)
{
q63_t sumr, sumi;
uint32_t i;
sumr = 0;
sumi = 0;
for(i=0;i<numSamples*2;i+=2)
{
//shifting down 14 here to provide guard bits
sumr += (((q63_t)pSrcA[i] * pSrcB[i] ) >> 14) - (((q63_t)pSrcA[i+1] * pSrcB[i+1]) >> 14);
sumi += (((q63_t)pSrcA[i] * pSrcB[i+1]) >> 14) + (((q63_t)pSrcA[i+1] * pSrcB[i] ) >> 14);
}
*realResult = sumr;
*imagResult = sumi;
}
void ref_cmplx_dot_prod_q15(
q15_t * pSrcA,
q15_t * pSrcB,
uint32_t numSamples,
q31_t * realResult,
q31_t * imagResult)
{
q63_t sumr, sumi;
uint32_t i;
sumr = 0;
sumi = 0;
for(i=0;i<numSamples*2;i+=2)
{
sumr += (q31_t)pSrcA[i] * pSrcB[i] - (q31_t)pSrcA[i+1] * pSrcB[i+1];
sumi += (q31_t)pSrcA[i] * pSrcB[i+1] + (q31_t)pSrcA[i+1] * pSrcB[i];
}
//shifting down 6 at the end here because there are already 32 guard bits available, this method is more accurate
*realResult = (q31_t)(sumr >> 6);
*imagResult = (q31_t)(sumi >> 6);
}
| 1,493 |
C
| 19.465753 | 114 | 0.585399 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/cmplx_mult_real.c
|
#include "ref.h"
void ref_cmplx_mult_real_f32(
float32_t * pSrcCmplx,
float32_t * pSrcReal,
float32_t * pCmplxDst,
uint32_t numSamples)
{
uint32_t i;
for(i=0;i<numSamples;i++)
{
pCmplxDst[2*i+0] = pSrcCmplx[2*i+0] * pSrcReal[i];
pCmplxDst[2*i+1] = pSrcCmplx[2*i+1] * pSrcReal[i];
}
}
void ref_cmplx_mult_real_q31(
q31_t * pSrcCmplx,
q31_t * pSrcReal,
q31_t * pCmplxDst,
uint32_t numSamples)
{
uint32_t i;
q31_t tempR, tempI;
for(i=0;i<numSamples;i++)
{
tempR = ((q63_t) pSrcCmplx[2*i+0] * pSrcReal[i]) >> 32;
tempI = ((q63_t) pSrcCmplx[2*i+1] * pSrcReal[i]) >> 32;
pCmplxDst[2*i+0] = ref_sat_n(tempR, 31) << 1;
pCmplxDst[2*i+1] = ref_sat_n(tempI, 31) << 1;
}
}
void ref_cmplx_mult_real_q15(
q15_t * pSrcCmplx,
q15_t * pSrcReal,
q15_t * pCmplxDst,
uint32_t numSamples)
{
uint32_t i;
q31_t tempR, tempI;
for(i=0;i<numSamples;i++)
{
tempR = ((q31_t) pSrcCmplx[2*i+0] * pSrcReal[i]) >> 15;
tempI = ((q31_t) pSrcCmplx[2*i+1] * pSrcReal[i]) >> 15;
pCmplxDst[2*i+0] = ref_sat_q15(tempR);
pCmplxDst[2*i+1] = ref_sat_q15(tempI);
}
}
| 1,091 |
C
| 19.603773 | 57 | 0.60495 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/cmplx_mult_cmplx.c
|
#include "ref.h"
void ref_cmplx_mult_cmplx_f32(
float32_t * pSrcA,
float32_t * pSrcB,
float32_t * pDst,
uint32_t numSamples)
{
uint32_t i;
for(i=0;i<numSamples*2;i+=2)
{
pDst[i] = pSrcA[i] * pSrcB[i] - pSrcA[i+1] * pSrcB[i+1];
pDst[i+1] = pSrcA[i] * pSrcB[i+1] + pSrcA[i+1] * pSrcB[i];
}
}
void ref_cmplx_mult_cmplx_q31(
q31_t * pSrcA,
q31_t * pSrcB,
q31_t * pDst,
uint32_t numSamples)
{
uint32_t i;
q31_t mul1, mul2, mul3, mul4;
for(i=0;i<numSamples*2;i+=2)
{
mul1 = ((q63_t)pSrcA[i] * pSrcB[i]) >> 33;
mul2 = ((q63_t)pSrcA[i+1] * pSrcB[i+1]) >> 33;
mul3 = ((q63_t)pSrcA[i] * pSrcB[i+1]) >> 33;
mul4 = ((q63_t)pSrcA[i+1] * pSrcB[i]) >> 33;
pDst[i] = mul1 - mul2;
pDst[i+1] = mul3 + mul4;
}
}
void ref_cmplx_mult_cmplx_q15(
q15_t * pSrcA,
q15_t * pSrcB,
q15_t * pDst,
uint32_t numSamples)
{
uint32_t i;
q31_t mul1, mul2, mul3, mul4;
for(i=0;i<numSamples*2;i+=2)
{
mul1 = ((q31_t)pSrcA[i] * pSrcB[i]) >> 17;
mul2 = ((q31_t)pSrcA[i+1] * pSrcB[i+1]) >> 17;
mul3 = ((q31_t)pSrcA[i] * pSrcB[i+1]) >> 17;
mul4 = ((q31_t)pSrcA[i+1] * pSrcB[i]) >> 17;
pDst[i] = mul1 - mul2;
pDst[i+1] = mul3 + mul4;
}
}
| 1,195 |
C
| 19.982456 | 62 | 0.540586 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/ComplexMathFunctions.c
|
#include "cmplx_conj.c"
#include "cmplx_dot_prod.c"
#include "cmplx_mag.c"
#include "cmplx_mag_squared.c"
#include "cmplx_mult_cmplx.c"
#include "cmplx_mult_real.c"
| 167 |
C
| 17.666665 | 30 | 0.712575 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/cmplx_conj.c
|
#include "ref.h"
void ref_cmplx_conj_f32(
float32_t * pSrc,
float32_t * pDst,
uint32_t numSamples)
{
uint32_t i;
for(i=0;i<numSamples*2;i+=2)
{
pDst[i] = pSrc[i];
pDst[i+1] = -pSrc[i+1];
}
}
void ref_cmplx_conj_q31(
q31_t * pSrc,
q31_t * pDst,
uint32_t numSamples)
{
uint32_t i;
for(i=0;i<numSamples*2;i+=2)
{
pDst[i] = pSrc[i];
pDst[i+1] = -pSrc[i+1];
}
}
void ref_cmplx_conj_q15(
q15_t * pSrc,
q15_t * pDst,
uint32_t numSamples)
{
uint32_t i;
for(i=0;i<numSamples*2;i+=2)
{
pDst[i] = pSrc[i];
pDst[i+1] = -pSrc[i+1];
}
}
| 568 |
C
| 12.878048 | 29 | 0.566901 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ControllerFunctions/sin_cos.c
|
#include "ref.h"
void ref_sin_cos_f32(
float32_t theta,
float32_t * pSinVal,
float32_t * pCosVal)
{
//theta is given in degrees
*pSinVal = sinf(theta * 6.28318530717959f / 360.0f);
*pCosVal = cosf(theta * 6.28318530717959f / 360.0f);
}
void ref_sin_cos_q31(
q31_t theta,
q31_t * pSinVal,
q31_t * pCosVal)
{
//theta is given in the range [-1,1) to represent [-pi,pi)
*pSinVal = (q31_t)(sinf((float32_t)theta * 3.14159265358979f / 2147483648.0f) * 2147483648.0f);
*pCosVal = (q31_t)(cosf((float32_t)theta * 3.14159265358979f / 2147483648.0f) * 2147483648.0f);
}
| 580 |
C
| 25.40909 | 96 | 0.667241 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ControllerFunctions/pid.c
|
#include "ref.h"
float32_t ref_pid_f32(
arm_pid_instance_f32 * S,
float32_t in)
{
float32_t out;
/* y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2] */
out = S->state[2] + S->A0 * in + S->A1 * S->state[0] + S->A2 * S->state[1];
/* Update state */
S->state[1] = S->state[0];
S->state[0] = in;
S->state[2] = out;
/* return to application */
return (out);
}
q31_t ref_pid_q31(
arm_pid_instance_q31 * S,
q31_t in)
{
q63_t acc;
q31_t out;
/* acc = A0 * x[n] */
acc = (q63_t) S->A0 * in;
/* acc += A1 * x[n-1] */
acc += (q63_t) S->A1 * S->state[0];
/* acc += A2 * x[n-2] */
acc += (q63_t) S->A2 * S->state[1];
/* convert output to 1.31 format to add y[n-1] */
out = (q31_t) (acc >> 31U);
/* out += y[n-1] */
out += S->state[2];
/* Update state */
S->state[1] = S->state[0];
S->state[0] = in;
S->state[2] = out;
/* return to application */
return (out);
}
q15_t ref_pid_q15(
arm_pid_instance_q15 * S,
q15_t in)
{
q63_t acc;
q15_t out;
q15_t A1, A2;
#if defined (ARM_MATH_DSP)
#ifndef ARM_MATH_BIG_ENDIAN
A2 = S->A1 >> 16;
A1 = (q15_t)S->A1;
#else
A1 = S->A1 >> 16;
A2 = (q15_t)S->A1;
#endif
#else
A1 = S->A1;
A2 = S->A2;
#endif
/* acc = A0 * x[n] */
acc = ((q31_t) S->A0) * in;
/* acc += A1 * x[n-1] + A2 * x[n-2] */
acc += (q31_t) A1 * S->state[0];
acc += (q31_t) A2 * S->state[1];
/* acc += y[n-1] */
acc += (q31_t) S->state[2] << 15;
/* saturate the output */
out = ref_sat_q15(acc >> 15);
/* Update state */
S->state[1] = S->state[0];
S->state[0] = in;
S->state[2] = out;
/* return to application */
return (out);
}
| 1,618 |
C
| 15.520408 | 76 | 0.493201 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ControllerFunctions/ControllerFunctions.c
|
#include "pid.c"
#include "sin_cos.c"
| 40 |
C
| 7.199999 | 20 | 0.625 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/FastMathFunctions/FastMathFunctions.c
|
#include "cos.c"
#include "sin.c"
#include "sqrt.c"
| 54 |
C
| 8.166665 | 17 | 0.62963 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/FastMathFunctions/sqrt.c
|
#include "ref.h"
arm_status ref_sqrt_q31(q31_t in, q31_t * pOut)
{
*pOut = (q31_t)(sqrtf((float32_t)in / 2147483648.0f) * 2147483648.0f);
return ARM_MATH_SUCCESS;
}
arm_status ref_sqrt_q15(q15_t in, q15_t * pOut)
{
*pOut = (q15_t)(sqrtf((float32_t)in / 32768.0f) * 32768.0f);
return ARM_MATH_SUCCESS;
}
| 313 |
C
| 18.624999 | 71 | 0.642173 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/FastMathFunctions/cos.c
|
#include "ref.h"
q31_t ref_cos_q31(q31_t x)
{
return (q31_t)(cosf((float32_t)x * 6.28318530717959f / 2147483648.0f) * 2147483648.0f);
}
q15_t ref_cos_q15(q15_t x)
{
return (q15_t)(cosf((float32_t)x * 6.28318530717959f / 32768.0f) * 32768.0f);
}
| 249 |
C
| 19.833332 | 88 | 0.654618 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/FastMathFunctions/sin.c
|
#include "ref.h"
q31_t ref_sin_q31(q31_t x)
{
return (q31_t)(sinf((float32_t)x * 6.28318530717959f / 2147483648.0f) * 2147483648.0f);
}
q15_t ref_sin_q15(q15_t x)
{
return (q15_t)(sinf((float32_t)x * 6.28318530717959f / 32768.0f) * 32768.0f);
}
| 249 |
C
| 19.833332 | 88 | 0.654618 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/SupportFunctions/fill.c
|
#include "ref.h"
void ref_fill_f32(
float32_t value,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = value;
}
}
void ref_fill_q31(
q31_t value,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = value;
}
}
void ref_fill_q15(
q15_t value,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = value;
}
}
void ref_fill_q7(
q7_t value,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = value;
}
}
| 594 |
C
| 10.018518 | 25 | 0.572391 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/SupportFunctions/copy.c
|
#include "ref.h"
void ref_copy_f32(
float32_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i];
}
}
void ref_copy_q31(
q31_t * pSrc,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i];
}
}
void ref_copy_q15(
q15_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i];
}
}
void ref_copy_q7(
q7_t * pSrc,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i];
}
}
| 606 |
C
| 10.240741 | 25 | 0.554455 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/SupportFunctions/fixed_to_fixed.c
|
#include "ref.h"
void ref_q31_to_q15(
q31_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] >> 16;
}
}
void ref_q31_to_q7(
q31_t * pSrc,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] >> 24;
}
}
void ref_q15_to_q31(
q15_t * pSrc,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ((q31_t)pSrc[i]) << 16;
}
}
void ref_q15_to_q7(
q15_t * pSrc,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] >> 8;
}
}
void ref_q7_to_q31(
q7_t * pSrc,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ((q31_t)pSrc[i]) << 24;
}
}
void ref_q7_to_q15(
q7_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ((q15_t)pSrc[i]) << 8;
}
}
| 958 |
C
| 10.9875 | 35 | 0.533403 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/SupportFunctions/SupportFunctions.c
|
#include "copy.c"
#include "fill.c"
#include "fixed_to_fixed.c"
#include "fixed_to_float.c"
#include "float_to_fixed.c"
| 121 |
C
| 16.428569 | 27 | 0.694215 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/SupportFunctions/fixed_to_float.c
|
#include "ref.h"
void ref_q63_to_float(
q63_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ((float32_t)pSrc[i]) / 9223372036854775808.0f;
}
}
void ref_q31_to_float(
q31_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ((float32_t)pSrc[i]) / 2147483648.0f;
}
}
void ref_q15_to_float(
q15_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ((float32_t)pSrc[i]) / 32768.0f;
}
}
void ref_q7_to_float(
q7_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ((float32_t)pSrc[i]) / 128.0f;
}
}
| 746 |
C
| 12.833333 | 58 | 0.581769 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/SupportFunctions/float_to_fixed.c
|
#include "ref.h"
void ref_float_to_q31(
float32_t * pSrc,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
float32_t in;
for(i=0;i<blockSize;i++)
{
in = pSrc[i];
in *= 2147483648.0f; //scale up
in += in > 0.0f ? 0.5f : -0.5f; //round
pDst[i] = ref_sat_q31((q63_t)in); //cast and saturate
}
}
void ref_float_to_q15(
float32_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
float32_t in;
for(i=0;i<blockSize;i++)
{
in = pSrc[i];
in *= 32768.0f;
in += in > 0.0f ? 0.5f : -0.5f;
pDst[i] = ref_sat_q15((q31_t)in);
}
}
void ref_float_to_q7(
float32_t * pSrc,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
float32_t in;
for(i=0;i<blockSize;i++)
{
in = pSrc[i];
in *= 128.0f;
in += in > 0.0f ? 0.5f : -0.5f;
pDst[i] = ref_sat_q7((q15_t)in);
}
}
| 818 |
C
| 14.45283 | 55 | 0.545232 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/shift.c
|
#include "ref.h"
void ref_shift_q31(
q31_t * pSrc,
int8_t shiftBits,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
if (shiftBits < 0)
{
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] << shiftBits;
}
}
else
{
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] >> -shiftBits;
}
}
}
void ref_shift_q15(
q15_t * pSrc,
int8_t shiftBits,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
if (shiftBits < 0)
{
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] << shiftBits;
}
}
else
{
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] >> -shiftBits;
}
}
}
void ref_shift_q7(
q7_t * pSrc,
int8_t shiftBits,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
if (shiftBits < 0)
{
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] << shiftBits;
}
}
else
{
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] >> -shiftBits;
}
}
}
| 893 |
C
| 11.081081 | 35 | 0.529675 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/sub.c
|
#include "ref.h"
void ref_sub_f32(
float32_t * pSrcA,
float32_t * pSrcB,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrcA[i] - pSrcB[i];
}
}
void ref_sub_q31(
q31_t * pSrcA,
q31_t * pSrcB,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ref_sat_q31( (q63_t)pSrcA[i] - pSrcB[i] );
}
}
void ref_sub_q15(
q15_t * pSrcA,
q15_t * pSrcB,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ref_sat_q15( (q31_t)pSrcA[i] - pSrcB[i] );
}
}
void ref_sub_q7(
q7_t * pSrcA,
q7_t * pSrcB,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ref_sat_q7( (q15_t)pSrcA[i] - pSrcB[i] );
}
}
| 790 |
C
| 12.637931 | 54 | 0.558228 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/negate.c
|
#include "ref.h"
void ref_negate_f32(
float32_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = -pSrc[i];
}
}
void ref_negate_q31(
q31_t * pSrc,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = -pSrc[i];
}
}
void ref_negate_q15(
q15_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = -pSrc[i];
}
}
void ref_negate_q7(
q7_t * pSrc,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = -pSrc[i];
}
}
| 618 |
C
| 10.462963 | 25 | 0.556634 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/dot_prod.c
|
#include "ref.h"
void ref_dot_prod_f32(
float32_t * pSrcA,
float32_t * pSrcB,
uint32_t blockSize,
float32_t * result)
{
uint32_t i;
float32_t sum = 0.0f;
for(i=0;i<blockSize;i++)
{
sum += pSrcA[i] * pSrcB[i];
}
*result = sum;
}
void ref_dot_prod_q31(
q31_t * pSrcA,
q31_t * pSrcB,
uint32_t blockSize,
q63_t * result)
{
uint32_t i;
q63_t sum = 0.0f;
for(i=0;i<blockSize;i++)
{
sum += ((q63_t)pSrcA[i] * pSrcB[i]) >> 14; //16.48
}
*result = sum;
}
void ref_dot_prod_q15(
q15_t * pSrcA,
q15_t * pSrcB,
uint32_t blockSize,
q63_t * result)
{
uint32_t i;
q63_t sum = 0.0f;
for(i=0;i<blockSize;i++)
{
sum += (q31_t)pSrcA[i] * pSrcB[i]; //34.30
}
*result = sum;
}
void ref_dot_prod_q7(
q7_t * pSrcA,
q7_t * pSrcB,
uint32_t blockSize,
q31_t * result)
{
uint32_t i;
q31_t sum = 0.0f;
for(i=0;i<blockSize;i++)
{
sum += (q31_t)pSrcA[i] * pSrcB[i]; //18.14
}
*result = sum;
}
| 947 |
C
| 13.363636 | 52 | 0.555438 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/offset.c
|
#include "ref.h"
void ref_offset_f32(
float32_t * pSrc,
float32_t offset,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] + offset;
}
}
void ref_offset_q31(
q31_t * pSrc,
q31_t offset,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ref_sat_q31( (q63_t)pSrc[i] + offset );
}
}
void ref_offset_q15(
q15_t * pSrc,
q15_t offset,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ref_sat_q15( (q31_t)pSrc[i] + offset );
}
}
void ref_offset_q7(
q7_t * pSrc,
q7_t offset,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = ref_sat_q7( (q15_t)pSrc[i] + offset );
}
}
| 782 |
C
| 12.5 | 51 | 0.574169 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/mult.c
|
#include "ref.h"
void ref_mult_f32(
float32_t * pSrcA,
float32_t * pSrcB,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrcA[i] * pSrcB[i];
}
}
void ref_mult_q31(
q31_t * pSrcA,
q31_t * pSrcB,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
q63_t temp;
for(i=0;i<blockSize;i++)
{
temp = ((q63_t)pSrcA[i] * pSrcB[i]) >> 32;
temp = temp << 1;
pDst[i] = ref_sat_q31(temp);
}
}
void ref_mult_q15(
q15_t * pSrcA,
q15_t * pSrcB,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
q31_t temp;
for(i=0;i<blockSize;i++)
{
temp = ((q31_t)pSrcA[i] * pSrcB[i]) >> 15; //this comment is for JD, this is specifically 15 and not 16 like the q31 case might imply. This is because CMSIS DSP lib does it this way. No other reason.
pDst[i] = ref_sat_q15(temp);
}
}
void ref_mult_q7(
q7_t * pSrcA,
q7_t * pSrcB,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
q15_t temp;
for(i=0;i<blockSize;i++)
{
temp = ((q15_t)pSrcA[i] * pSrcB[i]) >> 7;
pDst[i] = ref_sat_q7(temp);
}
}
| 1,074 |
C
| 15.538461 | 203 | 0.583799 |
Tbarkin121/GuardDog/stm32/MotorDrive/LegDay/Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/scale.c
|
#include "ref.h"
void ref_scale_f32(
float32_t * pSrc,
float32_t scale,
float32_t * pDst,
uint32_t blockSize)
{
uint32_t i;
for(i=0;i<blockSize;i++)
{
pDst[i] = pSrc[i] * scale;
}
}
void ref_scale_q31(
q31_t * pSrc,
q31_t scaleFract,
int8_t shift,
q31_t * pDst,
uint32_t blockSize)
{
uint32_t i;
int8_t kShift = shift + 1; /* Shift to apply after scaling */
int8_t sign = (kShift & 0x80);
q63_t temp;
for(i=0;i<blockSize;i++)
{
temp = ((q63_t) pSrc[i] * scaleFract) >> 32;
if (sign)
pDst[i] = temp >> -kShift;
else
pDst[i] = ref_sat_q31( (q63_t)temp << kShift );
}
}
void ref_scale_q15(
q15_t * pSrc,
q15_t scaleFract,
int8_t shift,
q15_t * pDst,
uint32_t blockSize)
{
uint32_t i;
int8_t kShift = 15 - shift; /* Shift to apply after scaling */
for(i=0;i<blockSize;i++)
{
pDst[i] = ref_sat_q15(((q31_t) pSrc[i] * scaleFract) >> kShift);
}
}
void ref_scale_q7(
q7_t * pSrc,
q7_t scaleFract,
int8_t shift,
q7_t * pDst,
uint32_t blockSize)
{
uint32_t i;
int8_t kShift = 7 - shift; /* Shift to apply after scaling */
for(i=0;i<blockSize;i++)
{
pDst[i] = ref_sat_q7(((q15_t) pSrc[i] * scaleFract) >> kShift);
}
}
| 1,262 |
C
| 17.042857 | 85 | 0.558637 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.