├── .mxproject ├── Core ├── Inc │ ├── dma.h │ ├── gpio.h │ ├── main.h │ ├── stm32f1xx_hal_conf.h │ ├── stm32f1xx_it.h │ └── usart.h └── Src │ ├── dma.c │ ├── gpio.c │ ├── main.c │ ├── stm32f1xx_hal_msp.c │ ├── stm32f1xx_it.c │ ├── system_stm32f1xx.c │ └── usart.c ├── Drivers ├── CMSIS │ ├── Core │ │ ├── Include │ │ │ ├── cmsis_armcc.h │ │ │ ├── cmsis_armclang.h │ │ │ ├── cmsis_compiler.h │ │ │ ├── cmsis_gcc.h │ │ │ ├── cmsis_iccarm.h │ │ │ ├── cmsis_version.h │ │ │ ├── core_armv8mbl.h │ │ │ ├── core_armv8mml.h │ │ │ ├── core_cm0.h │ │ │ ├── core_cm0plus.h │ │ │ ├── core_cm1.h │ │ │ ├── core_cm23.h │ │ │ ├── core_cm3.h │ │ │ ├── core_cm33.h │ │ │ ├── core_cm4.h │ │ │ ├── core_cm7.h │ │ │ ├── core_sc000.h │ │ │ ├── core_sc300.h │ │ │ ├── mpu_armv7.h │ │ │ ├── mpu_armv8.h │ │ │ └── tz_context.h │ │ └── Template │ │ │ └── ARMv8-M │ │ │ ├── main_s.c │ │ │ └── tz_context.c │ ├── Core_A │ │ ├── Include │ │ │ ├── cmsis_armcc.h │ │ │ ├── cmsis_armclang.h │ │ │ ├── cmsis_compiler.h │ │ │ ├── cmsis_cp15.h │ │ │ ├── cmsis_gcc.h │ │ │ ├── cmsis_iccarm.h │ │ │ ├── core_ca.h │ │ │ └── irq_ctrl.h │ │ └── Source │ │ │ └── irq_ctrl_gic.c │ ├── DSP │ │ ├── DSP_Lib_TestSuite │ │ │ ├── Common │ │ │ │ ├── JTest │ │ │ │ │ ├── inc │ │ │ │ │ │ ├── arr_desc │ │ │ │ │ │ │ └── arr_desc.h │ │ │ │ │ │ ├── jtest.h │ │ │ │ │ │ ├── jtest_cycle.h │ │ │ │ │ │ ├── jtest_define.h │ │ │ │ │ │ ├── jtest_fw.h │ │ │ │ │ │ ├── jtest_group.h │ │ │ │ │ │ ├── jtest_group_call.h │ │ │ │ │ │ ├── jtest_group_define.h │ │ │ │ │ │ ├── jtest_pf.h │ │ │ │ │ │ ├── jtest_systick.h │ │ │ │ │ │ ├── jtest_test.h │ │ │ │ │ │ ├── jtest_test_call.h │ │ │ │ │ │ ├── jtest_test_define.h │ │ │ │ │ │ ├── jtest_test_ret.h │ │ │ │ │ │ ├── jtest_util.h │ │ │ │ │ │ ├── opt_arg │ │ │ │ │ │ │ ├── opt_arg.h │ │ │ │ │ │ │ ├── pp_narg.h │ │ │ │ │ │ │ └── splice.h │ │ │ │ │ │ └── util │ │ │ │ │ │ │ └── util.h │ │ │ │ │ └── src │ │ │ │ │ │ ├── jtest_cycle.c │ │ │ │ │ │ ├── jtest_dump_str_segments.c │ │ │ │ │ │ ├── jtest_fw.c │ │ │ │ │ │ └── jtest_trigger_action.c │ │ │ │ ├── inc │ │ │ │ │ ├── all_tests.h │ │ │ │ │ ├── basic_math_tests │ │ │ │ │ │ ├── basic_math_templates.h │ │ │ │ │ │ ├── basic_math_test_data.h │ │ │ │ │ │ ├── basic_math_test_group.h │ │ │ │ │ │ └── basic_math_tests.h │ │ │ │ │ ├── complex_math_tests │ │ │ │ │ │ ├── complex_math_templates.h │ │ │ │ │ │ ├── complex_math_test_data.h │ │ │ │ │ │ ├── complex_math_test_group.h │ │ │ │ │ │ └── complex_math_tests.h │ │ │ │ │ ├── controller_tests │ │ │ │ │ │ ├── controller_templates.h │ │ │ │ │ │ ├── controller_test_data.h │ │ │ │ │ │ ├── controller_test_group.h │ │ │ │ │ │ └── controller_tests.h │ │ │ │ │ ├── fast_math_tests │ │ │ │ │ │ ├── fast_math_templates.h │ │ │ │ │ │ ├── fast_math_test_data.h │ │ │ │ │ │ └── fast_math_test_group.h │ │ │ │ │ ├── filtering_tests │ │ │ │ │ │ ├── filtering_templates.h │ │ │ │ │ │ ├── filtering_test_data.h │ │ │ │ │ │ ├── filtering_test_group.h │ │ │ │ │ │ └── filtering_tests.h │ │ │ │ │ ├── intrinsics_tests │ │ │ │ │ │ ├── intrinsics_templates.h │ │ │ │ │ │ ├── intrinsics_test_data.h │ │ │ │ │ │ └── intrinsics_test_group.h │ │ │ │ │ ├── math_helper.h │ │ │ │ │ ├── matrix_tests │ │ │ │ │ │ ├── matrix_templates.h │ │ │ │ │ │ ├── matrix_test_data.h │ │ │ │ │ │ ├── matrix_test_group.h │ │ │ │ │ │ └── matrix_tests.h │ │ │ │ │ ├── statistics_tests │ │ │ │ │ │ ├── statistics_templates.h │ │ │ │ │ │ ├── statistics_test_data.h │ │ │ │ │ │ ├── statistics_test_group.h │ │ │ │ │ │ └── statistics_tests.h │ │ │ │ │ ├── support_tests │ │ │ │ │ │ ├── support_templates.h │ │ │ │ │ │ ├── support_test_data.h │ │ │ │ │ │ ├── support_test_group.h │ │ │ │ │ │ └── support_tests.h │ │ │ │ │ ├── templates │ │ │ │ │ │ ├── template.h │ │ │ │ │ │ └── test_templates.h │ │ │ │ │ ├── transform_tests │ │ │ │ │ │ ├── transform_templates.h │ │ │ │ │ │ ├── transform_test_data.h │ │ │ │ │ │ ├── transform_test_group.h │ │ │ │ │ │ └── transform_tests.h │ │ │ │ │ └── type_abbrev.h │ │ │ │ ├── platform │ │ │ │ │ ├── ARMCC │ │ │ │ │ │ ├── Retarget.c │ │ │ │ │ │ ├── startup_armv6-m.s │ │ │ │ │ │ └── startup_armv7-m.s │ │ │ │ │ ├── ARMCLANG │ │ │ │ │ │ ├── startup_armv6-m.S │ │ │ │ │ │ └── startup_armv7-m.S │ │ │ │ │ ├── GCC │ │ │ │ │ │ ├── Retarget.c │ │ │ │ │ │ ├── startup_armv6-m.S │ │ │ │ │ │ └── startup_armv7-m.S │ │ │ │ │ ├── startup_generic.S │ │ │ │ │ ├── system_ARMCM0.c │ │ │ │ │ ├── system_ARMCM23.c │ │ │ │ │ ├── system_ARMCM3.c │ │ │ │ │ ├── system_ARMCM33.c │ │ │ │ │ ├── system_ARMCM4.c │ │ │ │ │ ├── system_ARMCM7.c │ │ │ │ │ ├── system_ARMSC000.c │ │ │ │ │ ├── system_ARMSC300.c │ │ │ │ │ ├── system_ARMv8MBL.c │ │ │ │ │ ├── system_ARMv8MML.c │ │ │ │ │ └── system_generic.c │ │ │ │ └── src │ │ │ │ │ ├── all_tests.c │ │ │ │ │ ├── basic_math_tests │ │ │ │ │ ├── abs_tests.c │ │ │ │ │ ├── add_tests.c │ │ │ │ │ ├── basic_math_test_common_data.c │ │ │ │ │ ├── basic_math_test_group.c │ │ │ │ │ ├── dot_prod_tests.c │ │ │ │ │ ├── mult_tests.c │ │ │ │ │ ├── negate_tests.c │ │ │ │ │ ├── offset_tests.c │ │ │ │ │ ├── scale_tests.c │ │ │ │ │ ├── shift_tests.c │ │ │ │ │ └── sub_tests.c │ │ │ │ │ ├── complex_math_tests │ │ │ │ │ ├── cmplx_conj_tests.c │ │ │ │ │ ├── cmplx_dot_prod_tests.c │ │ │ │ │ ├── cmplx_mag_squared_tests.c │ │ │ │ │ ├── cmplx_mag_tests.c │ │ │ │ │ ├── cmplx_mult_cmplx_tests.c │ │ │ │ │ ├── cmplx_mult_real_test.c │ │ │ │ │ ├── complex_math_test_common_data.c │ │ │ │ │ └── complex_math_test_group.c │ │ │ │ │ ├── controller_tests │ │ │ │ │ ├── controller_test_common_data.c │ │ │ │ │ ├── controller_test_group.c │ │ │ │ │ ├── pid_reset_tests.c │ │ │ │ │ ├── pid_tests.c │ │ │ │ │ └── sin_cos_tests.c │ │ │ │ │ ├── fast_math_tests │ │ │ │ │ ├── fast_math_tests.c │ │ │ │ │ └── fast_math_tests_common_data.c │ │ │ │ │ ├── filtering_tests │ │ │ │ │ ├── biquad_tests.c │ │ │ │ │ ├── conv_tests.c │ │ │ │ │ ├── correlate_tests.c │ │ │ │ │ ├── filtering_test_common_data.c │ │ │ │ │ ├── filtering_test_group.c │ │ │ │ │ ├── fir_tests.c │ │ │ │ │ ├── iir_tests.c │ │ │ │ │ └── lms_tests.c │ │ │ │ │ ├── intrinsics_tests │ │ │ │ │ ├── intrinsics_tests.c │ │ │ │ │ └── intrinsics_tests_common_data.c │ │ │ │ │ ├── main.c │ │ │ │ │ ├── math_helper.c │ │ │ │ │ ├── matrix_tests │ │ │ │ │ ├── mat_add_tests.c │ │ │ │ │ ├── mat_cmplx_mult_tests.c │ │ │ │ │ ├── mat_init_tests.c │ │ │ │ │ ├── mat_inverse_tests.c │ │ │ │ │ ├── mat_mult_fast_tests.c │ │ │ │ │ ├── mat_mult_tests.c │ │ │ │ │ ├── mat_scale_tests.c │ │ │ │ │ ├── mat_sub_tests.c │ │ │ │ │ ├── mat_trans_tests.c │ │ │ │ │ ├── matrix_test_common_data.c │ │ │ │ │ └── matrix_test_group.c │ │ │ │ │ ├── statistics_tests │ │ │ │ │ ├── max_tests.c │ │ │ │ │ ├── mean_tests.c │ │ │ │ │ ├── min_tests.c │ │ │ │ │ ├── power_tests.c │ │ │ │ │ ├── rms_tests.c │ │ │ │ │ ├── statistics_test_common_data.c │ │ │ │ │ ├── statistics_test_group.c │ │ │ │ │ ├── std_tests.c │ │ │ │ │ └── var_tests.c │ │ │ │ │ ├── support_tests │ │ │ │ │ ├── copy_tests.c │ │ │ │ │ ├── fill_tests.c │ │ │ │ │ ├── support_test_common_data.c │ │ │ │ │ ├── support_test_group.c │ │ │ │ │ └── x_to_y_tests.c │ │ │ │ │ └── transform_tests │ │ │ │ │ ├── cfft_family_tests.c │ │ │ │ │ ├── cfft_tests.c │ │ │ │ │ ├── dct4_tests.c │ │ │ │ │ ├── rfft_fast_tests.c │ │ │ │ │ ├── rfft_tests.c │ │ │ │ │ ├── transform_test_group.c │ │ │ │ │ └── transform_tests_common_data.c │ │ │ ├── DspLibTest_FVP │ │ │ │ ├── ARMCM23_config.txt │ │ │ │ ├── ARMCM33_DSP_FP_config.txt │ │ │ │ ├── ARMCM33_DSP_config.txt │ │ │ │ ├── ARMCM33_FP_config.txt │ │ │ │ └── ARMCM33_config.txt │ │ │ ├── DspLibTest_MPS2 │ │ │ │ └── HowTo.txt │ │ │ ├── HowTo.txt │ │ │ └── RefLibs │ │ │ │ ├── inc │ │ │ │ └── ref.h │ │ │ │ └── src │ │ │ │ ├── BasicMathFunctions │ │ │ │ ├── abs.c │ │ │ │ ├── add.c │ │ │ │ ├── dot_prod.c │ │ │ │ ├── mult.c │ │ │ │ ├── negate.c │ │ │ │ ├── offset.c │ │ │ │ ├── scale.c │ │ │ │ ├── shift.c │ │ │ │ └── sub.c │ │ │ │ ├── ComplexMathFunctions │ │ │ │ ├── cmplx_conj.c │ │ │ │ ├── cmplx_dot_prod.c │ │ │ │ ├── cmplx_mag.c │ │ │ │ ├── cmplx_mag_squared.c │ │ │ │ ├── cmplx_mult_cmplx.c │ │ │ │ └── cmplx_mult_real.c │ │ │ │ ├── ControllerFunctions │ │ │ │ ├── pid.c │ │ │ │ └── sin_cos.c │ │ │ │ ├── FastMathFunctions │ │ │ │ ├── cos.c │ │ │ │ ├── sin.c │ │ │ │ └── sqrt.c │ │ │ │ ├── FilteringFunctions │ │ │ │ ├── biquad.c │ │ │ │ ├── conv.c │ │ │ │ ├── correlate.c │ │ │ │ ├── fir.c │ │ │ │ ├── fir_decimate.c │ │ │ │ ├── fir_interpolate.c │ │ │ │ ├── fir_lattice.c │ │ │ │ ├── fir_sparse.c │ │ │ │ ├── iir_lattice.c │ │ │ │ └── lms.c │ │ │ │ ├── HelperFunctions │ │ │ │ ├── mat_helper.c │ │ │ │ └── ref_helper.c │ │ │ │ ├── Intrinsics │ │ │ │ └── intrinsics.c │ │ │ │ ├── MatrixFunctions │ │ │ │ ├── mat_add.c │ │ │ │ ├── mat_cmplx_mult.c │ │ │ │ ├── mat_inverse.c │ │ │ │ ├── mat_mult.c │ │ │ │ ├── mat_scale.c │ │ │ │ ├── mat_sub.c │ │ │ │ └── mat_trans.c │ │ │ │ ├── StatisticsFunctions │ │ │ │ ├── max.c │ │ │ │ ├── mean.c │ │ │ │ ├── min.c │ │ │ │ ├── power.c │ │ │ │ ├── rms.c │ │ │ │ ├── std.c │ │ │ │ └── var.c │ │ │ │ ├── SupportFunctions │ │ │ │ ├── copy.c │ │ │ │ ├── fill.c │ │ │ │ ├── fixed_to_fixed.c │ │ │ │ ├── fixed_to_float.c │ │ │ │ └── float_to_fixed.c │ │ │ │ └── TransformFunctions │ │ │ │ ├── bitreversal.c │ │ │ │ ├── cfft.c │ │ │ │ ├── dct4.c │ │ │ │ └── rfft.c │ │ ├── Examples │ │ │ └── ARM │ │ │ │ ├── arm_class_marks_example │ │ │ │ ├── Abstract.txt │ │ │ │ └── arm_class_marks_example_f32.c │ │ │ │ ├── arm_convolution_example │ │ │ │ ├── Abstract.txt │ │ │ │ ├── arm_convolution_example_f32.c │ │ │ │ ├── math_helper.c │ │ │ │ └── math_helper.h │ │ │ │ ├── arm_dotproduct_example │ │ │ │ ├── Abstract.txt │ │ │ │ └── arm_dotproduct_example_f32.c │ │ │ │ ├── arm_fft_bin_example │ │ │ │ ├── Abstract.txt │ │ │ │ ├── arm_fft_bin_data.c │ │ │ │ └── arm_fft_bin_example_f32.c │ │ │ │ ├── arm_fir_example │ │ │ │ ├── Abstract.txt │ │ │ │ ├── arm_fir_data.c │ │ │ │ ├── arm_fir_example_f32.c │ │ │ │ ├── math_helper.c │ │ │ │ └── math_helper.h │ │ │ │ ├── arm_graphic_equalizer_example │ │ │ │ ├── Abstract.txt │ │ │ │ ├── arm_graphic_equalizer_data.c │ │ │ │ ├── arm_graphic_equalizer_example_q31.c │ │ │ │ ├── math_helper.c │ │ │ │ └── math_helper.h │ │ │ │ ├── arm_linear_interp_example │ │ │ │ ├── Abstract.txt │ │ │ │ ├── arm_linear_interp_data.c │ │ │ │ ├── arm_linear_interp_example_f32.c │ │ │ │ ├── math_helper.c │ │ │ │ └── math_helper.h │ │ │ │ ├── arm_matrix_example │ │ │ │ ├── Abstract.txt │ │ │ │ ├── arm_matrix_example_f32.c │ │ │ │ ├── math_helper.c │ │ │ │ └── math_helper.h │ │ │ │ ├── arm_signal_converge_example │ │ │ │ ├── Abstract.txt │ │ │ │ ├── arm_signal_converge_data.c │ │ │ │ ├── arm_signal_converge_example_f32.c │ │ │ │ ├── math_helper.c │ │ │ │ └── math_helper.h │ │ │ │ ├── arm_sin_cos_example │ │ │ │ ├── Abstract.txt │ │ │ │ └── arm_sin_cos_example_f32.c │ │ │ │ └── arm_variance_example │ │ │ │ ├── Abstract.txt │ │ │ │ └── arm_variance_example_f32.c │ │ ├── Include │ │ │ ├── arm_common_tables.h │ │ │ ├── arm_const_structs.h │ │ │ └── arm_math.h │ │ └── Source │ │ │ ├── BasicMathFunctions │ │ │ ├── arm_abs_f32.c │ │ │ ├── arm_abs_q15.c │ │ │ ├── arm_abs_q31.c │ │ │ ├── arm_abs_q7.c │ │ │ ├── arm_add_f32.c │ │ │ ├── arm_add_q15.c │ │ │ ├── arm_add_q31.c │ │ │ ├── arm_add_q7.c │ │ │ ├── arm_dot_prod_f32.c │ │ │ ├── arm_dot_prod_q15.c │ │ │ ├── arm_dot_prod_q31.c │ │ │ ├── arm_dot_prod_q7.c │ │ │ ├── arm_mult_f32.c │ │ │ ├── arm_mult_q15.c │ │ │ ├── arm_mult_q31.c │ │ │ ├── arm_mult_q7.c │ │ │ ├── arm_negate_f32.c │ │ │ ├── arm_negate_q15.c │ │ │ ├── arm_negate_q31.c │ │ │ ├── arm_negate_q7.c │ │ │ ├── arm_offset_f32.c │ │ │ ├── arm_offset_q15.c │ │ │ ├── arm_offset_q31.c │ │ │ ├── arm_offset_q7.c │ │ │ ├── arm_scale_f32.c │ │ │ ├── arm_scale_q15.c │ │ │ ├── arm_scale_q31.c │ │ │ ├── arm_scale_q7.c │ │ │ ├── arm_shift_q15.c │ │ │ ├── arm_shift_q31.c │ │ │ ├── arm_shift_q7.c │ │ │ ├── arm_sub_f32.c │ │ │ ├── arm_sub_q15.c │ │ │ ├── arm_sub_q31.c │ │ │ └── arm_sub_q7.c │ │ │ ├── CommonTables │ │ │ ├── arm_common_tables.c │ │ │ └── arm_const_structs.c │ │ │ ├── ComplexMathFunctions │ │ │ ├── arm_cmplx_conj_f32.c │ │ │ ├── arm_cmplx_conj_q15.c │ │ │ ├── arm_cmplx_conj_q31.c │ │ │ ├── arm_cmplx_dot_prod_f32.c │ │ │ ├── arm_cmplx_dot_prod_q15.c │ │ │ ├── arm_cmplx_dot_prod_q31.c │ │ │ ├── arm_cmplx_mag_f32.c │ │ │ ├── arm_cmplx_mag_q15.c │ │ │ ├── arm_cmplx_mag_q31.c │ │ │ ├── arm_cmplx_mag_squared_f32.c │ │ │ ├── arm_cmplx_mag_squared_q15.c │ │ │ ├── arm_cmplx_mag_squared_q31.c │ │ │ ├── arm_cmplx_mult_cmplx_f32.c │ │ │ ├── arm_cmplx_mult_cmplx_q15.c │ │ │ ├── arm_cmplx_mult_cmplx_q31.c │ │ │ ├── arm_cmplx_mult_real_f32.c │ │ │ ├── arm_cmplx_mult_real_q15.c │ │ │ └── arm_cmplx_mult_real_q31.c │ │ │ ├── ControllerFunctions │ │ │ ├── arm_pid_init_f32.c │ │ │ ├── arm_pid_init_q15.c │ │ │ ├── arm_pid_init_q31.c │ │ │ ├── arm_pid_reset_f32.c │ │ │ ├── arm_pid_reset_q15.c │ │ │ ├── arm_pid_reset_q31.c │ │ │ ├── arm_sin_cos_f32.c │ │ │ └── arm_sin_cos_q31.c │ │ │ ├── FastMathFunctions │ │ │ ├── arm_cos_f32.c │ │ │ ├── arm_cos_q15.c │ │ │ ├── arm_cos_q31.c │ │ │ ├── arm_sin_f32.c │ │ │ ├── arm_sin_q15.c │ │ │ ├── arm_sin_q31.c │ │ │ ├── arm_sqrt_q15.c │ │ │ └── arm_sqrt_q31.c │ │ │ ├── FilteringFunctions │ │ │ ├── arm_biquad_cascade_df1_32x64_init_q31.c │ │ │ ├── arm_biquad_cascade_df1_32x64_q31.c │ │ │ ├── arm_biquad_cascade_df1_f32.c │ │ │ ├── arm_biquad_cascade_df1_fast_q15.c │ │ │ ├── arm_biquad_cascade_df1_fast_q31.c │ │ │ ├── arm_biquad_cascade_df1_init_f32.c │ │ │ ├── arm_biquad_cascade_df1_init_q15.c │ │ │ ├── arm_biquad_cascade_df1_init_q31.c │ │ │ ├── arm_biquad_cascade_df1_q15.c │ │ │ ├── arm_biquad_cascade_df1_q31.c │ │ │ ├── arm_biquad_cascade_df2T_f32.c │ │ │ ├── arm_biquad_cascade_df2T_f64.c │ │ │ ├── arm_biquad_cascade_df2T_init_f32.c │ │ │ ├── arm_biquad_cascade_df2T_init_f64.c │ │ │ ├── arm_biquad_cascade_stereo_df2T_f32.c │ │ │ ├── arm_biquad_cascade_stereo_df2T_init_f32.c │ │ │ ├── arm_conv_f32.c │ │ │ ├── arm_conv_fast_opt_q15.c │ │ │ ├── arm_conv_fast_q15.c │ │ │ ├── arm_conv_fast_q31.c │ │ │ ├── arm_conv_opt_q15.c │ │ │ ├── arm_conv_opt_q7.c │ │ │ ├── arm_conv_partial_f32.c │ │ │ ├── arm_conv_partial_fast_opt_q15.c │ │ │ ├── arm_conv_partial_fast_q15.c │ │ │ ├── arm_conv_partial_fast_q31.c │ │ │ ├── arm_conv_partial_opt_q15.c │ │ │ ├── arm_conv_partial_opt_q7.c │ │ │ ├── arm_conv_partial_q15.c │ │ │ ├── arm_conv_partial_q31.c │ │ │ ├── arm_conv_partial_q7.c │ │ │ ├── arm_conv_q15.c │ │ │ ├── arm_conv_q31.c │ │ │ ├── arm_conv_q7.c │ │ │ ├── arm_correlate_f32.c │ │ │ ├── arm_correlate_fast_opt_q15.c │ │ │ ├── arm_correlate_fast_q15.c │ │ │ ├── arm_correlate_fast_q31.c │ │ │ ├── arm_correlate_opt_q15.c │ │ │ ├── arm_correlate_opt_q7.c │ │ │ ├── arm_correlate_q15.c │ │ │ ├── arm_correlate_q31.c │ │ │ ├── arm_correlate_q7.c │ │ │ ├── arm_fir_decimate_f32.c │ │ │ ├── arm_fir_decimate_fast_q15.c │ │ │ ├── arm_fir_decimate_fast_q31.c │ │ │ ├── arm_fir_decimate_init_f32.c │ │ │ ├── arm_fir_decimate_init_q15.c │ │ │ ├── arm_fir_decimate_init_q31.c │ │ │ ├── arm_fir_decimate_q15.c │ │ │ ├── arm_fir_decimate_q31.c │ │ │ ├── arm_fir_f32.c │ │ │ ├── arm_fir_fast_q15.c │ │ │ ├── arm_fir_fast_q31.c │ │ │ ├── arm_fir_init_f32.c │ │ │ ├── arm_fir_init_q15.c │ │ │ ├── arm_fir_init_q31.c │ │ │ ├── arm_fir_init_q7.c │ │ │ ├── arm_fir_interpolate_f32.c │ │ │ ├── arm_fir_interpolate_init_f32.c │ │ │ ├── arm_fir_interpolate_init_q15.c │ │ │ ├── arm_fir_interpolate_init_q31.c │ │ │ ├── arm_fir_interpolate_q15.c │ │ │ ├── arm_fir_interpolate_q31.c │ │ │ ├── arm_fir_lattice_f32.c │ │ │ ├── arm_fir_lattice_init_f32.c │ │ │ ├── arm_fir_lattice_init_q15.c │ │ │ ├── arm_fir_lattice_init_q31.c │ │ │ ├── arm_fir_lattice_q15.c │ │ │ ├── arm_fir_lattice_q31.c │ │ │ ├── arm_fir_q15.c │ │ │ ├── arm_fir_q31.c │ │ │ ├── arm_fir_q7.c │ │ │ ├── arm_fir_sparse_f32.c │ │ │ ├── arm_fir_sparse_init_f32.c │ │ │ ├── arm_fir_sparse_init_q15.c │ │ │ ├── arm_fir_sparse_init_q31.c │ │ │ ├── arm_fir_sparse_init_q7.c │ │ │ ├── arm_fir_sparse_q15.c │ │ │ ├── arm_fir_sparse_q31.c │ │ │ ├── arm_fir_sparse_q7.c │ │ │ ├── arm_iir_lattice_f32.c │ │ │ ├── arm_iir_lattice_init_f32.c │ │ │ ├── arm_iir_lattice_init_q15.c │ │ │ ├── arm_iir_lattice_init_q31.c │ │ │ ├── arm_iir_lattice_q15.c │ │ │ ├── arm_iir_lattice_q31.c │ │ │ ├── arm_lms_f32.c │ │ │ ├── arm_lms_init_f32.c │ │ │ ├── arm_lms_init_q15.c │ │ │ ├── arm_lms_init_q31.c │ │ │ ├── arm_lms_norm_f32.c │ │ │ ├── arm_lms_norm_init_f32.c │ │ │ ├── arm_lms_norm_init_q15.c │ │ │ ├── arm_lms_norm_init_q31.c │ │ │ ├── arm_lms_norm_q15.c │ │ │ ├── arm_lms_norm_q31.c │ │ │ ├── arm_lms_q15.c │ │ │ └── arm_lms_q31.c │ │ │ ├── MatrixFunctions │ │ │ ├── arm_mat_add_f32.c │ │ │ ├── arm_mat_add_q15.c │ │ │ ├── arm_mat_add_q31.c │ │ │ ├── arm_mat_cmplx_mult_f32.c │ │ │ ├── arm_mat_cmplx_mult_q15.c │ │ │ ├── arm_mat_cmplx_mult_q31.c │ │ │ ├── arm_mat_init_f32.c │ │ │ ├── arm_mat_init_q15.c │ │ │ ├── arm_mat_init_q31.c │ │ │ ├── arm_mat_inverse_f32.c │ │ │ ├── arm_mat_inverse_f64.c │ │ │ ├── arm_mat_mult_f32.c │ │ │ ├── arm_mat_mult_fast_q15.c │ │ │ ├── arm_mat_mult_fast_q31.c │ │ │ ├── arm_mat_mult_q15.c │ │ │ ├── arm_mat_mult_q31.c │ │ │ ├── arm_mat_scale_f32.c │ │ │ ├── arm_mat_scale_q15.c │ │ │ ├── arm_mat_scale_q31.c │ │ │ ├── arm_mat_sub_f32.c │ │ │ ├── arm_mat_sub_q15.c │ │ │ ├── arm_mat_sub_q31.c │ │ │ ├── arm_mat_trans_f32.c │ │ │ ├── arm_mat_trans_q15.c │ │ │ └── arm_mat_trans_q31.c │ │ │ ├── StatisticsFunctions │ │ │ ├── arm_max_f32.c │ │ │ ├── arm_max_q15.c │ │ │ ├── arm_max_q31.c │ │ │ ├── arm_max_q7.c │ │ │ ├── arm_mean_f32.c │ │ │ ├── arm_mean_q15.c │ │ │ ├── arm_mean_q31.c │ │ │ ├── arm_mean_q7.c │ │ │ ├── arm_min_f32.c │ │ │ ├── arm_min_q15.c │ │ │ ├── arm_min_q31.c │ │ │ ├── arm_min_q7.c │ │ │ ├── arm_power_f32.c │ │ │ ├── arm_power_q15.c │ │ │ ├── arm_power_q31.c │ │ │ ├── arm_power_q7.c │ │ │ ├── arm_rms_f32.c │ │ │ ├── arm_rms_q15.c │ │ │ ├── arm_rms_q31.c │ │ │ ├── arm_std_f32.c │ │ │ ├── arm_std_q15.c │ │ │ ├── arm_std_q31.c │ │ │ ├── arm_var_f32.c │ │ │ ├── arm_var_q15.c │ │ │ └── arm_var_q31.c │ │ │ ├── SupportFunctions │ │ │ ├── arm_copy_f32.c │ │ │ ├── arm_copy_q15.c │ │ │ ├── arm_copy_q31.c │ │ │ ├── arm_copy_q7.c │ │ │ ├── arm_fill_f32.c │ │ │ ├── arm_fill_q15.c │ │ │ ├── arm_fill_q31.c │ │ │ ├── arm_fill_q7.c │ │ │ ├── arm_float_to_q15.c │ │ │ ├── arm_float_to_q31.c │ │ │ ├── arm_float_to_q7.c │ │ │ ├── arm_q15_to_float.c │ │ │ ├── arm_q15_to_q31.c │ │ │ ├── arm_q15_to_q7.c │ │ │ ├── arm_q31_to_float.c │ │ │ ├── arm_q31_to_q15.c │ │ │ ├── arm_q31_to_q7.c │ │ │ ├── arm_q7_to_float.c │ │ │ ├── arm_q7_to_q15.c │ │ │ └── arm_q7_to_q31.c │ │ │ └── TransformFunctions │ │ │ ├── arm_bitreversal.c │ │ │ ├── arm_bitreversal2.S │ │ │ ├── arm_cfft_f32.c │ │ │ ├── arm_cfft_q15.c │ │ │ ├── arm_cfft_q31.c │ │ │ ├── arm_cfft_radix2_f32.c │ │ │ ├── arm_cfft_radix2_init_f32.c │ │ │ ├── arm_cfft_radix2_init_q15.c │ │ │ ├── arm_cfft_radix2_init_q31.c │ │ │ ├── arm_cfft_radix2_q15.c │ │ │ ├── arm_cfft_radix2_q31.c │ │ │ ├── arm_cfft_radix4_f32.c │ │ │ ├── arm_cfft_radix4_init_f32.c │ │ │ ├── arm_cfft_radix4_init_q15.c │ │ │ ├── arm_cfft_radix4_init_q31.c │ │ │ ├── arm_cfft_radix4_q15.c │ │ │ ├── arm_cfft_radix4_q31.c │ │ │ ├── arm_cfft_radix8_f32.c │ │ │ ├── arm_dct4_f32.c │ │ │ ├── arm_dct4_init_f32.c │ │ │ ├── arm_dct4_init_q15.c │ │ │ ├── arm_dct4_init_q31.c │ │ │ ├── arm_dct4_q15.c │ │ │ ├── arm_dct4_q31.c │ │ │ ├── arm_rfft_f32.c │ │ │ ├── arm_rfft_fast_f32.c │ │ │ ├── arm_rfft_fast_init_f32.c │ │ │ ├── arm_rfft_init_f32.c │ │ │ ├── arm_rfft_init_q15.c │ │ │ ├── arm_rfft_init_q31.c │ │ │ ├── arm_rfft_q15.c │ │ │ └── arm_rfft_q31.c │ ├── Device │ │ └── ST │ │ │ └── STM32F1xx │ │ │ ├── Include │ │ │ ├── stm32f100xb.h │ │ │ ├── stm32f100xe.h │ │ │ ├── stm32f101x6.h │ │ │ ├── stm32f101xb.h │ │ │ ├── stm32f101xe.h │ │ │ ├── stm32f101xg.h │ │ │ ├── stm32f102x6.h │ │ │ ├── stm32f102xb.h │ │ │ ├── stm32f103x6.h │ │ │ ├── stm32f103xb.h │ │ │ ├── stm32f103xe.h │ │ │ ├── stm32f103xg.h │ │ │ ├── stm32f105xc.h │ │ │ ├── stm32f107xc.h │ │ │ ├── stm32f1xx.h │ │ │ └── system_stm32f1xx.h │ │ │ ├── License.md │ │ │ └── Source │ │ │ └── Templates │ │ │ ├── arm │ │ │ ├── startup_stm32f100xb.s │ │ │ ├── startup_stm32f100xe.s │ │ │ ├── startup_stm32f101x6.s │ │ │ ├── startup_stm32f101xb.s │ │ │ ├── startup_stm32f101xe.s │ │ │ ├── startup_stm32f101xg.s │ │ │ ├── startup_stm32f102x6.s │ │ │ ├── startup_stm32f102xb.s │ │ │ ├── startup_stm32f103x6.s │ │ │ ├── startup_stm32f103xb.s │ │ │ ├── startup_stm32f103xe.s │ │ │ ├── startup_stm32f103xg.s │ │ │ ├── startup_stm32f105xc.s │ │ │ └── startup_stm32f107xc.s │ │ │ ├── gcc │ │ │ ├── startup_stm32f100xb.s │ │ │ ├── startup_stm32f100xe.s │ │ │ ├── startup_stm32f101x6.s │ │ │ ├── startup_stm32f101xb.s │ │ │ ├── startup_stm32f101xe.s │ │ │ ├── startup_stm32f101xg.s │ │ │ ├── startup_stm32f102x6.s │ │ │ ├── startup_stm32f102xb.s │ │ │ ├── startup_stm32f103x6.s │ │ │ ├── startup_stm32f103xb.s │ │ │ ├── startup_stm32f103xe.s │ │ │ ├── startup_stm32f103xg.s │ │ │ ├── startup_stm32f105xc.s │ │ │ └── startup_stm32f107xc.s │ │ │ ├── iar │ │ │ ├── linker │ │ │ │ ├── stm32f100xb_flash.icf │ │ │ │ ├── stm32f100xb_sram.icf │ │ │ │ ├── stm32f100xe_flash.icf │ │ │ │ ├── stm32f100xe_sram.icf │ │ │ │ ├── stm32f101x6_flash.icf │ │ │ │ ├── stm32f101x6_sram.icf │ │ │ │ ├── stm32f101xb_flash.icf │ │ │ │ ├── stm32f101xb_sram.icf │ │ │ │ ├── stm32f101xe_flash.icf │ │ │ │ ├── stm32f101xe_sram.icf │ │ │ │ ├── stm32f101xg_flash.icf │ │ │ │ ├── stm32f101xg_sram.icf │ │ │ │ ├── stm32f102x6_flash.icf │ │ │ │ ├── stm32f102x6_sram.icf │ │ │ │ ├── stm32f102xb_flash.icf │ │ │ │ ├── stm32f102xb_sram.icf │ │ │ │ ├── stm32f103x6_flash.icf │ │ │ │ ├── stm32f103x6_sram.icf │ │ │ │ ├── stm32f103xb_flash.icf │ │ │ │ ├── stm32f103xb_sram.icf │ │ │ │ ├── stm32f103xe_flash.icf │ │ │ │ ├── stm32f103xe_sram.icf │ │ │ │ ├── stm32f103xg_flash.icf │ │ │ │ ├── stm32f103xg_sram.icf │ │ │ │ ├── stm32f105xc_flash.icf │ │ │ │ ├── stm32f105xc_sram.icf │ │ │ │ ├── stm32f107xc_flash.icf │ │ │ │ └── stm32f107xc_sram.icf │ │ │ ├── startup_stm32f100xb.s │ │ │ ├── startup_stm32f100xe.s │ │ │ ├── startup_stm32f101x6.s │ │ │ ├── startup_stm32f101xb.s │ │ │ ├── startup_stm32f101xe.s │ │ │ ├── startup_stm32f101xg.s │ │ │ ├── startup_stm32f102x6.s │ │ │ ├── startup_stm32f102xb.s │ │ │ ├── startup_stm32f103x6.s │ │ │ ├── startup_stm32f103xb.s │ │ │ ├── startup_stm32f103xe.s │ │ │ ├── startup_stm32f103xg.s │ │ │ ├── startup_stm32f105xc.s │ │ │ └── startup_stm32f107xc.s │ │ │ └── system_stm32f1xx.c │ ├── Include │ │ ├── cmsis_armcc.h │ │ ├── cmsis_armclang.h │ │ ├── cmsis_compiler.h │ │ ├── cmsis_gcc.h │ │ ├── cmsis_iccarm.h │ │ ├── cmsis_version.h │ │ ├── core_armv8mbl.h │ │ ├── core_armv8mml.h │ │ ├── core_cm0.h │ │ ├── core_cm0plus.h │ │ ├── core_cm1.h │ │ ├── core_cm23.h │ │ ├── core_cm3.h │ │ ├── core_cm33.h │ │ ├── core_cm4.h │ │ ├── core_cm7.h │ │ ├── core_sc000.h │ │ ├── core_sc300.h │ │ ├── mpu_armv7.h │ │ ├── mpu_armv8.h │ │ └── tz_context.h │ ├── LICENSE.txt │ ├── Lib │ │ ├── ARM │ │ │ ├── arm_cortexM3b_math.lib │ │ │ └── arm_cortexM3l_math.lib │ │ ├── GCC │ │ │ └── libarm_cortexM3l_math.a │ │ └── IAR │ │ │ ├── iar_cortexM3b_math.a │ │ │ └── iar_cortexM3l_math.a │ ├── NN │ │ ├── Examples │ │ │ └── ARM │ │ │ │ └── arm_nn_examples │ │ │ │ ├── cifar10 │ │ │ │ ├── RTE │ │ │ │ │ ├── Compiler │ │ │ │ │ │ └── EventRecorderConf.h │ │ │ │ │ ├── _ARMCM0 │ │ │ │ │ │ └── RTE_Components.h │ │ │ │ │ ├── _ARMCM3 │ │ │ │ │ │ └── RTE_Components.h │ │ │ │ │ ├── _ARMCM4_FP │ │ │ │ │ │ └── RTE_Components.h │ │ │ │ │ └── _ARMCM7_SP │ │ │ │ │ │ └── RTE_Components.h │ │ │ │ ├── arm_nnexamples_cifar10.cpp │ │ │ │ ├── arm_nnexamples_cifar10_inputs.h │ │ │ │ ├── arm_nnexamples_cifar10_parameter.h │ │ │ │ ├── arm_nnexamples_cifar10_weights.h │ │ │ │ └── readme.txt │ │ │ │ └── gru │ │ │ │ ├── RTE │ │ │ │ ├── Compiler │ │ │ │ │ └── EventRecorderConf.h │ │ │ │ ├── _ARMCM0 │ │ │ │ │ └── RTE_Components.h │ │ │ │ ├── _ARMCM3 │ │ │ │ │ └── RTE_Components.h │ │ │ │ ├── _ARMCM4_FP │ │ │ │ │ └── RTE_Components.h │ │ │ │ └── _ARMCM7_SP │ │ │ │ │ └── RTE_Components.h │ │ │ │ ├── arm_nnexamples_gru.cpp │ │ │ │ ├── arm_nnexamples_gru_test_data.h │ │ │ │ └── readme.txt │ │ ├── Include │ │ │ ├── arm_nn_tables.h │ │ │ ├── arm_nnfunctions.h │ │ │ └── arm_nnsupportfunctions.h │ │ ├── NN_Lib_Tests │ │ │ └── nn_test │ │ │ │ ├── RTE │ │ │ │ ├── _ARMCM0 │ │ │ │ │ └── RTE_Components.h │ │ │ │ ├── _ARMCM3 │ │ │ │ │ └── RTE_Components.h │ │ │ │ ├── _ARMCM4_FP │ │ │ │ │ └── RTE_Components.h │ │ │ │ └── _ARMCM7_SP │ │ │ │ │ └── RTE_Components.h │ │ │ │ ├── Ref_Implementations │ │ │ │ ├── arm_convolve_HWC_q15_ref.c │ │ │ │ ├── arm_convolve_HWC_q15_ref_nonsquare.c │ │ │ │ ├── arm_convolve_HWC_q7_ref.c │ │ │ │ ├── arm_convolve_HWC_q7_ref_nonsquare.c │ │ │ │ ├── arm_depthwise_separable_conv_HWC_q7_ref.c │ │ │ │ ├── arm_depthwise_separable_conv_HWC_q7_ref_nonsquare.c │ │ │ │ ├── arm_fully_connected_mat_q7_vec_q15_opt_ref.c │ │ │ │ ├── arm_fully_connected_mat_q7_vec_q15_ref.c │ │ │ │ ├── arm_fully_connected_q15_opt_ref.c │ │ │ │ ├── arm_fully_connected_q15_ref.c │ │ │ │ ├── arm_fully_connected_q7_opt_ref.c │ │ │ │ ├── arm_fully_connected_q7_ref.c │ │ │ │ ├── arm_nn_mult_ref.c │ │ │ │ ├── arm_pool_ref.c │ │ │ │ ├── arm_relu_ref.c │ │ │ │ ├── fully_connected_testing_weights.h │ │ │ │ └── ref_functions.h │ │ │ │ ├── arm_nnexamples_nn_test.cpp │ │ │ │ ├── arm_nnexamples_nn_test.h │ │ │ │ └── readme.txt │ │ └── Source │ │ │ ├── ActivationFunctions │ │ │ ├── arm_nn_activations_q15.c │ │ │ ├── arm_nn_activations_q7.c │ │ │ ├── arm_relu_q15.c │ │ │ └── arm_relu_q7.c │ │ │ ├── ConvolutionFunctions │ │ │ ├── arm_convolve_1x1_HWC_q7_fast_nonsquare.c │ │ │ ├── arm_convolve_HWC_q15_basic.c │ │ │ ├── arm_convolve_HWC_q15_fast.c │ │ │ ├── arm_convolve_HWC_q15_fast_nonsquare.c │ │ │ ├── arm_convolve_HWC_q7_RGB.c │ │ │ ├── arm_convolve_HWC_q7_basic.c │ │ │ ├── arm_convolve_HWC_q7_basic_nonsquare.c │ │ │ ├── arm_convolve_HWC_q7_fast.c │ │ │ ├── arm_convolve_HWC_q7_fast_nonsquare.c │ │ │ ├── arm_depthwise_separable_conv_HWC_q7.c │ │ │ ├── arm_depthwise_separable_conv_HWC_q7_nonsquare.c │ │ │ ├── arm_nn_mat_mult_kernel_q7_q15.c │ │ │ └── arm_nn_mat_mult_kernel_q7_q15_reordered.c │ │ │ ├── FullyConnectedFunctions │ │ │ ├── arm_fully_connected_mat_q7_vec_q15.c │ │ │ ├── arm_fully_connected_mat_q7_vec_q15_opt.c │ │ │ ├── arm_fully_connected_q15.c │ │ │ ├── arm_fully_connected_q15_opt.c │ │ │ ├── arm_fully_connected_q7.c │ │ │ └── arm_fully_connected_q7_opt.c │ │ │ ├── NNSupportFunctions │ │ │ ├── arm_nn_mult_q15.c │ │ │ ├── arm_nn_mult_q7.c │ │ │ ├── arm_nntables.c │ │ │ ├── arm_q7_to_q15_no_shift.c │ │ │ └── arm_q7_to_q15_reordered_no_shift.c │ │ │ ├── PoolingFunctions │ │ │ └── arm_pool_q7_HWC.c │ │ │ └── SoftmaxFunctions │ │ │ ├── arm_softmax_q15.c │ │ │ └── arm_softmax_q7.c │ ├── RTOS │ │ └── Template │ │ │ └── cmsis_os.h │ ├── RTOS2 │ │ ├── Include │ │ │ ├── cmsis_os2.h │ │ │ └── os_tick.h │ │ ├── Source │ │ │ ├── os_systick.c │ │ │ ├── os_tick_gtim.c │ │ │ └── os_tick_ptim.c │ │ └── Template │ │ │ ├── cmsis_os.h │ │ │ └── cmsis_os1.c │ └── docs │ │ └── General │ │ └── html │ │ └── LICENSE.txt └── STM32F1xx_HAL_Driver │ ├── Inc │ ├── Legacy │ │ ├── stm32_hal_legacy.h │ │ ├── stm32f1xx_hal_can_ex_legacy.h │ │ └── stm32f1xx_hal_can_legacy.h │ ├── stm32_assert_template.h │ ├── stm32f1xx_hal.h │ ├── stm32f1xx_hal_adc.h │ ├── stm32f1xx_hal_adc_ex.h │ ├── stm32f1xx_hal_can.h │ ├── stm32f1xx_hal_cec.h │ ├── stm32f1xx_hal_conf_template.h │ ├── stm32f1xx_hal_cortex.h │ ├── stm32f1xx_hal_crc.h │ ├── stm32f1xx_hal_dac.h │ ├── stm32f1xx_hal_dac_ex.h │ ├── stm32f1xx_hal_def.h │ ├── stm32f1xx_hal_dma.h │ ├── stm32f1xx_hal_dma_ex.h │ ├── stm32f1xx_hal_eth.h │ ├── stm32f1xx_hal_exti.h │ ├── stm32f1xx_hal_flash.h │ ├── stm32f1xx_hal_flash_ex.h │ ├── stm32f1xx_hal_gpio.h │ ├── stm32f1xx_hal_gpio_ex.h │ ├── stm32f1xx_hal_hcd.h │ ├── stm32f1xx_hal_i2c.h │ ├── stm32f1xx_hal_i2s.h │ ├── stm32f1xx_hal_irda.h │ ├── stm32f1xx_hal_iwdg.h │ ├── stm32f1xx_hal_mmc.h │ ├── stm32f1xx_hal_nand.h │ ├── stm32f1xx_hal_nor.h │ ├── stm32f1xx_hal_pccard.h │ ├── stm32f1xx_hal_pcd.h │ ├── stm32f1xx_hal_pcd_ex.h │ ├── stm32f1xx_hal_pwr.h │ ├── stm32f1xx_hal_rcc.h │ ├── stm32f1xx_hal_rcc_ex.h │ ├── stm32f1xx_hal_rtc.h │ ├── stm32f1xx_hal_rtc_ex.h │ ├── stm32f1xx_hal_sd.h │ ├── stm32f1xx_hal_smartcard.h │ ├── stm32f1xx_hal_spi.h │ ├── stm32f1xx_hal_sram.h │ ├── stm32f1xx_hal_tim.h │ ├── stm32f1xx_hal_tim_ex.h │ ├── stm32f1xx_hal_uart.h │ ├── stm32f1xx_hal_usart.h │ ├── stm32f1xx_hal_wwdg.h │ ├── stm32f1xx_ll_adc.h │ ├── stm32f1xx_ll_bus.h │ ├── stm32f1xx_ll_cortex.h │ ├── stm32f1xx_ll_crc.h │ ├── stm32f1xx_ll_dac.h │ ├── stm32f1xx_ll_dma.h │ ├── stm32f1xx_ll_exti.h │ ├── stm32f1xx_ll_fsmc.h │ ├── stm32f1xx_ll_gpio.h │ ├── stm32f1xx_ll_i2c.h │ ├── stm32f1xx_ll_iwdg.h │ ├── stm32f1xx_ll_pwr.h │ ├── stm32f1xx_ll_rcc.h │ ├── stm32f1xx_ll_rtc.h │ ├── stm32f1xx_ll_sdmmc.h │ ├── stm32f1xx_ll_spi.h │ ├── stm32f1xx_ll_system.h │ ├── stm32f1xx_ll_tim.h │ ├── stm32f1xx_ll_usart.h │ ├── stm32f1xx_ll_usb.h │ ├── stm32f1xx_ll_utils.h │ └── stm32f1xx_ll_wwdg.h │ ├── License.md │ └── Src │ ├── stm32f1xx_hal.c │ ├── stm32f1xx_hal_adc.c │ ├── stm32f1xx_hal_adc_ex.c │ ├── stm32f1xx_hal_can.c │ ├── stm32f1xx_hal_cec.c │ ├── stm32f1xx_hal_cortex.c │ ├── stm32f1xx_hal_crc.c │ ├── stm32f1xx_hal_dac.c │ ├── stm32f1xx_hal_dac_ex.c │ ├── stm32f1xx_hal_dma.c │ ├── stm32f1xx_hal_eth.c │ ├── stm32f1xx_hal_exti.c │ ├── stm32f1xx_hal_flash.c │ ├── stm32f1xx_hal_flash_ex.c │ ├── stm32f1xx_hal_gpio.c │ ├── stm32f1xx_hal_gpio_ex.c │ ├── stm32f1xx_hal_hcd.c │ ├── stm32f1xx_hal_i2c.c │ ├── stm32f1xx_hal_i2s.c │ ├── stm32f1xx_hal_irda.c │ ├── stm32f1xx_hal_iwdg.c │ ├── stm32f1xx_hal_mmc.c │ ├── stm32f1xx_hal_msp_template.c │ ├── stm32f1xx_hal_nand.c │ ├── stm32f1xx_hal_nor.c │ ├── stm32f1xx_hal_pccard.c │ ├── stm32f1xx_hal_pcd.c │ ├── stm32f1xx_hal_pcd_ex.c │ ├── stm32f1xx_hal_pwr.c │ ├── stm32f1xx_hal_rcc.c │ ├── stm32f1xx_hal_rcc_ex.c │ ├── stm32f1xx_hal_rtc.c │ ├── stm32f1xx_hal_rtc_ex.c │ ├── stm32f1xx_hal_sd.c │ ├── stm32f1xx_hal_smartcard.c │ ├── stm32f1xx_hal_spi.c │ ├── stm32f1xx_hal_sram.c │ ├── stm32f1xx_hal_tim.c │ ├── stm32f1xx_hal_tim_ex.c │ ├── stm32f1xx_hal_timebase_rtc_alarm_template.c │ ├── stm32f1xx_hal_timebase_tim_template.c │ ├── stm32f1xx_hal_uart.c │ ├── stm32f1xx_hal_usart.c │ ├── stm32f1xx_hal_wwdg.c │ ├── stm32f1xx_ll_adc.c │ ├── stm32f1xx_ll_crc.c │ ├── stm32f1xx_ll_dac.c │ ├── stm32f1xx_ll_dma.c │ ├── stm32f1xx_ll_exti.c │ ├── stm32f1xx_ll_fsmc.c │ ├── stm32f1xx_ll_gpio.c │ ├── stm32f1xx_ll_i2c.c │ ├── stm32f1xx_ll_pwr.c │ ├── stm32f1xx_ll_rcc.c │ ├── stm32f1xx_ll_rtc.c │ ├── stm32f1xx_ll_sdmmc.c │ ├── stm32f1xx_ll_spi.c │ ├── stm32f1xx_ll_tim.c │ ├── stm32f1xx_ll_usart.c │ ├── stm32f1xx_ll_usb.c │ └── stm32f1xx_ll_utils.c ├── F103_UART_MODBUS.ioc ├── MDK-ARM ├── .vscode │ ├── c_cpp_properties.json │ ├── settings.json │ └── uv4.log.lock ├── DebugConfig │ └── F103_UART_MODBUS_STM32F103C8_1.0.0.dbgconf ├── F103_UART_MODBUS.uvoptx ├── F103_UART_MODBUS.uvprojx ├── F103_UART_MODBUS │ ├── ExtDll.iex │ ├── F103_UART_MODBUS.axf │ ├── F103_UART_MODBUS.build_log.htm │ ├── F103_UART_MODBUS.hex │ ├── F103_UART_MODBUS.htm │ ├── F103_UART_MODBUS.lnp │ ├── F103_UART_MODBUS.map │ ├── F103_UART_MODBUS.sct │ ├── F103_UART_MODBUS_F103_UART_MODBUS.dep │ ├── F103_UART_MODBUS_sct.Bak │ ├── dma.crf │ ├── dma.d │ ├── dma.o │ ├── gpio.crf │ ├── gpio.d │ ├── gpio.o │ ├── main.crf │ ├── main.d │ ├── main.o │ ├── modbus_crc.crf │ ├── modbus_crc.d │ ├── modbus_crc.o │ ├── modbus_master.crf │ ├── modbus_master.d │ ├── modbus_master.o │ ├── startup_stm32f103xb.d │ ├── startup_stm32f103xb.o │ ├── stm32f1xx_hal.crf │ ├── stm32f1xx_hal.d │ ├── stm32f1xx_hal.o │ ├── stm32f1xx_hal_cortex.crf │ ├── stm32f1xx_hal_cortex.d │ ├── stm32f1xx_hal_cortex.o │ ├── stm32f1xx_hal_dma.crf │ ├── stm32f1xx_hal_dma.d │ ├── stm32f1xx_hal_dma.o │ ├── stm32f1xx_hal_exti.crf │ ├── stm32f1xx_hal_exti.d │ ├── stm32f1xx_hal_exti.o │ ├── stm32f1xx_hal_flash.crf │ ├── stm32f1xx_hal_flash.d │ ├── stm32f1xx_hal_flash.o │ ├── stm32f1xx_hal_flash_ex.crf │ ├── stm32f1xx_hal_flash_ex.d │ ├── stm32f1xx_hal_flash_ex.o │ ├── stm32f1xx_hal_gpio.crf │ ├── stm32f1xx_hal_gpio.d │ ├── stm32f1xx_hal_gpio.o │ ├── stm32f1xx_hal_gpio_ex.crf │ ├── stm32f1xx_hal_gpio_ex.d │ ├── stm32f1xx_hal_gpio_ex.o │ ├── stm32f1xx_hal_msp.crf │ ├── stm32f1xx_hal_msp.d │ ├── stm32f1xx_hal_msp.o │ ├── stm32f1xx_hal_pwr.crf │ ├── stm32f1xx_hal_pwr.d │ ├── stm32f1xx_hal_pwr.o │ ├── stm32f1xx_hal_rcc.crf │ ├── stm32f1xx_hal_rcc.d │ ├── stm32f1xx_hal_rcc.o │ ├── stm32f1xx_hal_rcc_ex.crf │ ├── stm32f1xx_hal_rcc_ex.d │ ├── stm32f1xx_hal_rcc_ex.o │ ├── stm32f1xx_hal_tim.crf │ ├── stm32f1xx_hal_tim.d │ ├── stm32f1xx_hal_tim.o │ ├── stm32f1xx_hal_tim_ex.crf │ ├── stm32f1xx_hal_tim_ex.d │ ├── stm32f1xx_hal_tim_ex.o │ ├── stm32f1xx_hal_uart.crf │ ├── stm32f1xx_hal_uart.d │ ├── stm32f1xx_hal_uart.o │ ├── stm32f1xx_it.crf │ ├── stm32f1xx_it.d │ ├── stm32f1xx_it.o │ ├── system_stm32f1xx.crf │ ├── system_stm32f1xx.d │ ├── system_stm32f1xx.o │ ├── usart.crf │ ├── usart.d │ └── usart.o ├── RTE │ ├── RTE_Components.h │ └── _F103_UART_MODBUS │ │ └── RTE_Components.h ├── startup_stm32f103xb.lst └── startup_stm32f103xb.s ├── Utility ├── Inc │ ├── modbus_crc.h │ └── modbus_master.h └── Src │ ├── modbus_crc.c │ └── modbus_master.c ├── image ├── ModbusPoll数据页.png ├── ModbusSlave连接配置.png ├── STM32主机ModbusSlave从机.png ├── 串口助手主机STM32从机.png └── 虚拟串口.png └── readme.md /Core/Inc/dma.h: -------------------------------------------------------------------------------- 1 | /* USER CODE BEGIN Header */ 2 | /** 3 | ****************************************************************************** 4 | * @file dma.h 5 | * @brief This file contains all the function prototypes for 6 | * the dma.c file 7 | ****************************************************************************** 8 | * @attention 9 | * 10 | * Copyright (c) 2023 STMicroelectronics. 11 | * All rights reserved. 12 | * 13 | * This software is licensed under terms that can be found in the LICENSE file 14 | * in the root directory of this software component. 15 | * If no LICENSE file comes with this software, it is provided AS-IS. 16 | * 17 | ****************************************************************************** 18 | */ 19 | /* USER CODE END Header */ 20 | /* Define to prevent recursive inclusion -------------------------------------*/ 21 | #ifndef __DMA_H__ 22 | #define __DMA_H__ 23 | 24 | #ifdef __cplusplus 25 | extern "C" { 26 | #endif 27 | 28 | /* Includes ------------------------------------------------------------------*/ 29 | #include "main.h" 30 | 31 | /* DMA memory to memory transfer handles -------------------------------------*/ 32 | 33 | /* USER CODE BEGIN Includes */ 34 | 35 | /* USER CODE END Includes */ 36 | 37 | /* USER CODE BEGIN Private defines */ 38 | 39 | /* USER CODE END Private defines */ 40 | 41 | void MX_DMA_Init(void); 42 | 43 | /* USER CODE BEGIN Prototypes */ 44 | 45 | /* USER CODE END Prototypes */ 46 | 47 | #ifdef __cplusplus 48 | } 49 | #endif 50 | 51 | #endif /* __DMA_H__ */ 52 | 53 | -------------------------------------------------------------------------------- /Core/Inc/gpio.h: -------------------------------------------------------------------------------- 1 | /* USER CODE BEGIN Header */ 2 | /** 3 | ****************************************************************************** 4 | * @file gpio.h 5 | * @brief This file contains all the function prototypes for 6 | * the gpio.c file 7 | ****************************************************************************** 8 | * @attention 9 | * 10 | * Copyright (c) 2023 STMicroelectronics. 11 | * All rights reserved. 12 | * 13 | * This software is licensed under terms that can be found in the LICENSE file 14 | * in the root directory of this software component. 15 | * If no LICENSE file comes with this software, it is provided AS-IS. 16 | * 17 | ****************************************************************************** 18 | */ 19 | /* USER CODE END Header */ 20 | /* Define to prevent recursive inclusion -------------------------------------*/ 21 | #ifndef __GPIO_H__ 22 | #define __GPIO_H__ 23 | 24 | #ifdef __cplusplus 25 | extern "C" { 26 | #endif 27 | 28 | /* Includes ------------------------------------------------------------------*/ 29 | #include "main.h" 30 | 31 | /* USER CODE BEGIN Includes */ 32 | 33 | /* USER CODE END Includes */ 34 | 35 | /* USER CODE BEGIN Private defines */ 36 | 37 | /* USER CODE END Private defines */ 38 | 39 | void MX_GPIO_Init(void); 40 | 41 | /* USER CODE BEGIN Prototypes */ 42 | 43 | /* USER CODE END Prototypes */ 44 | 45 | #ifdef __cplusplus 46 | } 47 | #endif 48 | #endif /*__ GPIO_H__ */ 49 | 50 | -------------------------------------------------------------------------------- /Core/Src/gpio.c: -------------------------------------------------------------------------------- 1 | /* USER CODE BEGIN Header */ 2 | /** 3 | ****************************************************************************** 4 | * @file gpio.c 5 | * @brief This file provides code for the configuration 6 | * of all used GPIO pins. 7 | ****************************************************************************** 8 | * @attention 9 | * 10 | * Copyright (c) 2023 STMicroelectronics. 11 | * All rights reserved. 12 | * 13 | * This software is licensed under terms that can be found in the LICENSE file 14 | * in the root directory of this software component. 15 | * If no LICENSE file comes with this software, it is provided AS-IS. 16 | * 17 | ****************************************************************************** 18 | */ 19 | /* USER CODE END Header */ 20 | 21 | /* Includes ------------------------------------------------------------------*/ 22 | #include "gpio.h" 23 | 24 | /* USER CODE BEGIN 0 */ 25 | 26 | /* USER CODE END 0 */ 27 | 28 | /*----------------------------------------------------------------------------*/ 29 | /* Configure GPIO */ 30 | /*----------------------------------------------------------------------------*/ 31 | /* USER CODE BEGIN 1 */ 32 | 33 | /* USER CODE END 1 */ 34 | 35 | /** Configure pins as 36 | * Analog 37 | * Input 38 | * Output 39 | * EVENT_OUT 40 | * EXTI 41 | */ 42 | void MX_GPIO_Init(void) 43 | { 44 | 45 | /* GPIO Ports Clock Enable */ 46 | __HAL_RCC_GPIOC_CLK_ENABLE(); 47 | __HAL_RCC_GPIOD_CLK_ENABLE(); 48 | __HAL_RCC_GPIOA_CLK_ENABLE(); 49 | 50 | } 51 | 52 | /* USER CODE BEGIN 2 */ 53 | 54 | /* USER CODE END 2 */ 55 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest.h: -------------------------------------------------------------------------------- 1 | #ifndef _JTEST_H_ 2 | #define _JTEST_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "jtest_fw.h" 9 | #include "jtest_test.h" 10 | #include "jtest_test_define.h" 11 | #include "jtest_test_call.h" 12 | #include "jtest_group.h" 13 | #include "jtest_group_define.h" 14 | #include "jtest_group_call.h" 15 | #include "jtest_cycle.h" 16 | 17 | #endif /* _JTEST_H_ */ 18 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_define.h: -------------------------------------------------------------------------------- 1 | #ifndef _JTEST_DEFINE_H_ 2 | #define _JTEST_DEFINE_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Macros and Defines */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | /** 9 | * Makes a symbol for use as a struct name. Names made this way have two parts; 10 | * the first parts is a prefix common to all structs of that class. The second 11 | * is a specifier which differs for each instance of that struct type. 12 | */ 13 | #define JTEST_STRUCT_NAME(prefix, specifier) \ 14 | CONCAT(prefix, specifier) 15 | 16 | /** 17 | * Define a struct with type with a name generated by #JTEST_STRUCT_NAME(). 18 | */ 19 | #define JTEST_DEFINE_STRUCT(type, struct_name) \ 20 | type struct_name 21 | 22 | /** 23 | * Declare a struct with type with a name generated by #JTEST_STRUCT_NAME(). 24 | */ 25 | #define JTEST_DECLARE_STRUCT(struct_definition) \ 26 | extern struct_definition 27 | 28 | /** 29 | * Define and initialize a struct (created with JTEST_DEFINE_STRUCT()) and 30 | * initialize it with init_values. 31 | */ 32 | #define JTEST_INIT_STRUCT(struct_definition, init_values) \ 33 | struct_definition = { \ 34 | init_values \ 35 | } 36 | 37 | #endif /* _JTEST_DEFINE_H_ */ 38 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test_ret.h: -------------------------------------------------------------------------------- 1 | #ifndef _JTEST_TEST_RET_H_ 2 | #define _JTEST_TEST_RET_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Type Definitions */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | /** 9 | * Values a #JTEST_TEST_t can return. 10 | */ 11 | typedef enum JTEST_TEST_RET_enum 12 | { 13 | JTEST_TEST_PASSED, 14 | JTEST_TEST_FAILED 15 | } JTEST_TEST_RET_t; 16 | 17 | #endif /* _JTEST_TEST_RET_H_ */ 18 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_util.h: -------------------------------------------------------------------------------- 1 | #ifndef _JTEST_UTIL_H_ 2 | #define _JTEST_UTIL_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "util/util.h" 9 | 10 | /*--------------------------------------------------------------------------------*/ 11 | /* Macros and Defines */ 12 | /*--------------------------------------------------------------------------------*/ 13 | 14 | /* Define boolean values for the framework. */ 15 | #define JTEST_TRUE 1 /**< Value used for TRUE in JTEST. */ 16 | #define JTEST_FALSE 0 /**< Value used for FALSE in JTEST. */ 17 | 18 | /** 19 | * Set the value of the attribute in the struct to by struct_ptr to value. 20 | */ 21 | #define JTEST_SET_STRUCT_ATTRIBUTE(struct_ptr, attribute, value) \ 22 | do \ 23 | { \ 24 | (struct_ptr)->attribute = (value); \ 25 | } while (0) 26 | 27 | #endif /* _JTEST_UTIL_H_ */ 28 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/opt_arg.h: -------------------------------------------------------------------------------- 1 | #ifndef _OPT_ARG_H_ 2 | #define _OPT_ARG_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "pp_narg.h" 9 | #include "splice.h" 10 | 11 | /* If you are Joseph Jaoudi, you have a snippet which expands into an 12 | example. If you are not Joseph, but possess his code, study the examples. If 13 | you have no examples, turn back contact Joseph. */ 14 | 15 | #endif /* _OPT_ARG_H_ */ 16 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/pp_narg.h: -------------------------------------------------------------------------------- 1 | #ifndef _PP_NARG_H_ 2 | #define _PP_NARG_H_ 3 | 4 | #define PP_NARG(...) \ 5 | PP_NARG_(__VA_ARGS__,PP_RSEQ_N()) 6 | #define PP_NARG_(...) \ 7 | PP_ARG_N(__VA_ARGS__) 8 | #define PP_ARG_N( \ 9 | _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \ 10 | _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \ 11 | _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \ 12 | _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \ 13 | _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \ 14 | _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \ 15 | _61,_62,_63,N,...) N 16 | #define PP_RSEQ_N() \ 17 | 63,62,61,60, \ 18 | 59,58,57,56,55,54,53,52,51,50, \ 19 | 49,48,47,46,45,44,43,42,41,40, \ 20 | 39,38,37,36,35,34,33,32,31,30, \ 21 | 29,28,27,26,25,24,23,22,21,20, \ 22 | 19,18,17,16,15,14,13,12,11,10, \ 23 | 9,8,7,6,5,4,3,2,1,0 24 | 25 | #endif /* _PP_NARG_H_ */ 26 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/splice.h: -------------------------------------------------------------------------------- 1 | #ifndef _SPLICE_H_ 2 | #define _SPLICE_H_ 3 | 4 | #define SPLICE(a,b) SPLICE_1(a,b) 5 | #define SPLICE_1(a,b) SPLICE_2(a,b) 6 | #define SPLICE_2(a,b) a##b 7 | 8 | #endif /* _SPLICE_H_ */ 9 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/util/util.h: -------------------------------------------------------------------------------- 1 | #ifndef _UTIL_H_ 2 | #define _UTIL_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Macros and Defines */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | /** 9 | * Convert a symbol to a string and add a 'NewLine'. 10 | */ 11 | #define STR_NL(x) STR1_NL(x) 12 | #define STR1_NL(x) (STR2_NL(x)"\n") 13 | #define STR2_NL(x) #x 14 | 15 | /** 16 | * Convert a symbol to a string. 17 | */ 18 | #define STR(x) STR1(x) 19 | #define STR1(x) STR2(x) 20 | #define STR2(x) #x 21 | 22 | /** 23 | * Concatenate two symbols. 24 | */ 25 | #define CONCAT(a, b) CONCAT1(a, b) 26 | #define CONCAT1(a, b) CONCAT2(a, b) 27 | #define CONCAT2(a, b) a##b 28 | 29 | 30 | /** 31 | * Place curly braces around a varaible number of macro arguments. 32 | */ 33 | #define CURLY(...) {__VA_ARGS__} 34 | 35 | /** 36 | * Place parenthesis around a variable number of macro arguments. 37 | */ 38 | #define PAREN(...) (__VA_ARGS__) 39 | 40 | /* Standard min/max macros. */ 41 | #define MIN(x,y) (((x) < (y)) ? (x) : (y) ) 42 | #define MAX(x,y) (((x) > (y)) ? (x) : (y) ) 43 | 44 | /** 45 | * Bound value using low and high limits. 46 | * 47 | * Evaluate to a number in the range, endpoint inclusive. 48 | */ 49 | #define BOUND(low, high, value) \ 50 | MAX(MIN(high, value), low) 51 | 52 | #endif /* _UTIL_H_ */ 53 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_cycle.c: -------------------------------------------------------------------------------- 1 | #include "../inc/jtest_cycle.h" 2 | #include 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Define Module Variables */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | /* const char * JTEST_CYCLE_STRF = "Running: %s\nCycles: %" PRIu32 "\n"; */ 9 | const char * JTEST_CYCLE_STRF = "Cycles: %" PRIu32 "\n"; /* function name + parameter string skipped */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_dump_str_segments.c: -------------------------------------------------------------------------------- 1 | #include "jtest_fw.h" 2 | 3 | /** 4 | * Dump the JTEST_FW.str_buffer the Keil framework in pieces. 5 | * 6 | * The JTEST_FW.str_buffer contains more characters than the Keil framework can 7 | * dump at once. This function dumps them in blocks. 8 | */ 9 | void jtest_dump_str_segments(void) 10 | { 11 | uint32_t seg_idx = 0; 12 | uint32_t memmove_idx = 0; 13 | uint32_t seg_cnt = 14 | (strlen(JTEST_FW.str_buffer) / JTEST_STR_MAX_OUTPUT_SIZE) + 1; 15 | 16 | for( seg_idx = 0; seg_idx < seg_cnt; ++seg_idx) 17 | { 18 | JTEST_TRIGGER_ACTION(dump_str); 19 | 20 | if (seg_idx < JTEST_STR_MAX_OUTPUT_SEGMENTS) 21 | { 22 | memmove_idx = 0; 23 | while (memmove_idx < (seg_cnt - seg_idx -1) ) 24 | { 25 | memmove( 26 | JTEST_FW.str_buffer+ 27 | (memmove_idx* JTEST_STR_MAX_OUTPUT_SIZE), 28 | JTEST_FW.str_buffer+ 29 | ((memmove_idx+1)*JTEST_STR_MAX_OUTPUT_SIZE), 30 | JTEST_BUF_SIZE); 31 | ++memmove_idx; 32 | } 33 | } 34 | } 35 | return; 36 | } 37 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_fw.c: -------------------------------------------------------------------------------- 1 | #include "../inc/jtest.h" 2 | 3 | /*--------------------------------------------------------------------------------*/ 4 | /* Define Global Variables */ 5 | /*--------------------------------------------------------------------------------*/ 6 | 7 | char JTEST_FW_STR_BUFFER[JTEST_BUF_SIZE] = {0}; 8 | 9 | volatile JTEST_FW_t JTEST_FW = {0}; 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_trigger_action.c: -------------------------------------------------------------------------------- 1 | 2 | #include "jtest_fw.h" 3 | 4 | void test_start (void) { 5 | // ; 6 | JTEST_FW.test_start++; 7 | } 8 | 9 | void test_end (void) { 10 | // ; 11 | JTEST_FW.test_end++; 12 | } 13 | 14 | void group_start (void) { 15 | // ; 16 | JTEST_FW.group_start++; 17 | } 18 | 19 | void group_end (void) { 20 | // ; 21 | JTEST_FW.group_end++; 22 | } 23 | 24 | void dump_str (void) { 25 | // ; 26 | JTEST_FW.dump_str++; 27 | } 28 | 29 | void dump_data (void) { 30 | // ; 31 | JTEST_FW.dump_data++; 32 | } 33 | 34 | void exit_fw (void) { 35 | // ; 36 | JTEST_FW.exit_fw++; 37 | } 38 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/all_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _ALL_TESTS_H_ 2 | #define _ALL_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(all_tests); 8 | 9 | #endif /* _ALL_TESTS_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_test_data.h: -------------------------------------------------------------------------------- 1 | #ifndef ARM_BASIC_MATH_TEST_DATA_H 2 | #define ARM_BASIC_MATH_TEST_DATA_H 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "arr_desc.h" 9 | #include "arm_math.h" 10 | 11 | /*--------------------------------------------------------------------------------*/ 12 | /* Macros and Defines */ 13 | /*--------------------------------------------------------------------------------*/ 14 | #define BASIC_MATH_MAX_INPUT_ELEMENTS 32 15 | #define BASIC_MATH_BIGGEST_INPUT_TYPE float32_t 16 | 17 | /*--------------------------------------------------------------------------------*/ 18 | /* Declare Variables */ 19 | /*--------------------------------------------------------------------------------*/ 20 | 21 | /* Input/Output Buffers */ 22 | ARR_DESC_DECLARE(basic_math_output_fut); 23 | ARR_DESC_DECLARE(basic_math_output_ref); 24 | 25 | extern BASIC_MATH_BIGGEST_INPUT_TYPE 26 | basic_math_output_f32_ref[BASIC_MATH_MAX_INPUT_ELEMENTS]; 27 | 28 | extern BASIC_MATH_BIGGEST_INPUT_TYPE 29 | basic_math_output_f32_fut[BASIC_MATH_MAX_INPUT_ELEMENTS]; 30 | 31 | /* Block Sizes*/ 32 | ARR_DESC_DECLARE(basic_math_block_sizes); 33 | 34 | /* Numbers */ 35 | ARR_DESC_DECLARE(basic_math_elts); 36 | ARR_DESC_DECLARE(basic_math_elts2); 37 | ARR_DESC_DECLARE(basic_math_eltsf); 38 | 39 | /* Float Inputs */ 40 | ARR_DESC_DECLARE(basic_math_zeros); 41 | ARR_DESC_DECLARE(basic_math_f_2); 42 | ARR_DESC_DECLARE(basic_math_f_15); 43 | ARR_DESC_DECLARE(basic_math_f_32); 44 | ARR_DESC_DECLARE(basic_math_f_all); 45 | 46 | #endif 47 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _BASIC_MATH_TEST_GROUP_H_ 2 | #define _BASIC_MATH_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(basic_math_tests); 8 | 9 | #endif /* _BASIC_MATH_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _BASIC_MATH_TESTS_H_ 2 | #define _BASIC_MATH_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Test/Group Declarations */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(abs_tests); 8 | JTEST_DECLARE_GROUP(add_tests); 9 | JTEST_DECLARE_GROUP(dot_prod_tests); 10 | JTEST_DECLARE_GROUP(mult_tests); 11 | JTEST_DECLARE_GROUP(negate_tests); 12 | JTEST_DECLARE_GROUP(offset_tests); 13 | JTEST_DECLARE_GROUP(scale_tests); 14 | JTEST_DECLARE_GROUP(shift_tests); 15 | JTEST_DECLARE_GROUP(sub_tests); 16 | 17 | #endif /* _BASIC_MATH_TESTS_H_ */ 18 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _COMPLEX_MATH_TEST_GROUP_H_ 2 | #define _COMPLEX_MATH_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(complex_math_tests); 8 | 9 | #endif /* _COMPLEX_MATH_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _COMPLEX_MATH_TESTS_H_ 2 | #define _COMPLEX_MATH_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Test/Group Declarations */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(cmplx_conj_tests); 8 | JTEST_DECLARE_GROUP(cmplx_dot_prod_tests); 9 | JTEST_DECLARE_GROUP(cmplx_mag_tests); 10 | JTEST_DECLARE_GROUP(cmplx_mag_squared_tests); 11 | JTEST_DECLARE_GROUP(cmplx_mult_cmplx_tests); 12 | JTEST_DECLARE_GROUP(cmplx_mult_real_tests); 13 | 14 | #endif /* _COMPLEX_MATH_TESTS_H_ */ 15 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_test_data.h: -------------------------------------------------------------------------------- 1 | #ifndef _CONTROLLER_TEST_DATA_H_ 2 | #define _CONTROLLER_TEST_DATA_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "arm_math.h" 9 | 10 | /*--------------------------------------------------------------------------------*/ 11 | /* Macros and Defines */ 12 | /*--------------------------------------------------------------------------------*/ 13 | 14 | #define CONTROLLER_MAX_LEN 1024 15 | #define CONTROLLER_MAX_COEFFS_LEN (12 * 3) 16 | #define TRANFORM_BIGGEST_INPUT_TYPE float32_t 17 | 18 | /*--------------------------------------------------------------------------------*/ 19 | /* Variable Declarations */ 20 | /*--------------------------------------------------------------------------------*/ 21 | 22 | extern float32_t controller_output_fut[CONTROLLER_MAX_LEN]; 23 | extern float32_t controller_output_ref[CONTROLLER_MAX_LEN]; 24 | extern float32_t controller_output_f32_fut[CONTROLLER_MAX_LEN]; 25 | extern float32_t controller_output_f32_ref[CONTROLLER_MAX_LEN]; 26 | extern const float32_t controller_f32_inputs[CONTROLLER_MAX_LEN]; 27 | extern const q31_t controller_q31_inputs[CONTROLLER_MAX_LEN]; 28 | extern const q15_t * controller_q15_inputs; 29 | extern const float32_t controller_f32_coeffs[CONTROLLER_MAX_COEFFS_LEN]; 30 | extern const q31_t controller_q31_coeffs[CONTROLLER_MAX_COEFFS_LEN]; 31 | extern const q15_t controller_q15_coeffs[CONTROLLER_MAX_COEFFS_LEN]; 32 | 33 | #endif /* _CONTROLLER_TEST_DATA_H_ */ 34 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _CONTROLLER_TEST_GROUP_H_ 2 | #define _CONTROLLER_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Group */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(controller_tests); 8 | 9 | #endif /* _CONTROLLER_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _CONTROLLER_TESTS_H_ 2 | #define _CONTROLLER_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Test/Group Declarations */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(pid_reset_tests); 8 | JTEST_DECLARE_GROUP(sin_cos_tests); 9 | JTEST_DECLARE_GROUP(pid_tests); 10 | 11 | #endif /* _CONTROLLER_TESTS_H_ */ 12 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/fast_math_tests/fast_math_test_data.h: -------------------------------------------------------------------------------- 1 | #ifndef _FAST_MATH_TEST_DATA_H_ 2 | #define _FAST_MATH_TEST_DATA_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "arm_math.h" 9 | 10 | /*--------------------------------------------------------------------------------*/ 11 | /* Macros and Defines */ 12 | /*--------------------------------------------------------------------------------*/ 13 | 14 | #define FAST_MATH_MAX_LEN 1024 15 | #define TRANFORM_BIGGEST_INPUT_TYPE float32_t 16 | 17 | /*--------------------------------------------------------------------------------*/ 18 | /* Variable Declarations */ 19 | /*--------------------------------------------------------------------------------*/ 20 | 21 | extern float32_t fast_math_output_fut[FAST_MATH_MAX_LEN]; 22 | extern float32_t fast_math_output_ref[FAST_MATH_MAX_LEN]; 23 | extern float32_t fast_math_output_f32_fut[FAST_MATH_MAX_LEN]; 24 | extern float32_t fast_math_output_f32_ref[FAST_MATH_MAX_LEN]; 25 | extern const float32_t fast_math_f32_inputs[FAST_MATH_MAX_LEN]; 26 | extern const q31_t fast_math_q31_inputs[FAST_MATH_MAX_LEN]; 27 | extern const q15_t * fast_math_q15_inputs; 28 | 29 | #endif /* _FAST_MATH_TEST_DATA_H_ */ 30 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/fast_math_tests/fast_math_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _FAST_MATH_TEST_GROUP_H_ 2 | #define _FAST_MATH_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(fast_math_tests); 8 | 9 | #endif /* _FAST_MATH_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _FILTERING_TEST_GROUP_H_ 2 | #define _FILTERING_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(filtering_tests); 8 | 9 | #endif /* _FILTERING_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _FILTERING_TESTS_H_ 2 | #define _FILTERING_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Test/Group Declarations */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | JTEST_DECLARE_GROUP(biquad_tests); 9 | JTEST_DECLARE_GROUP(conv_tests); 10 | JTEST_DECLARE_GROUP(correlate_tests); 11 | JTEST_DECLARE_GROUP(fir_tests); 12 | JTEST_DECLARE_GROUP(iir_tests); 13 | JTEST_DECLARE_GROUP(lms_tests); 14 | 15 | #endif /* _FILTERING_TESTS_H_ */ 16 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/intrinsics_tests/intrinsics_test_data.h: -------------------------------------------------------------------------------- 1 | #ifndef _INTRINSICS_TEST_DATA_H_ 2 | #define _INTRINSICS_TEST_DATA_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "arm_math.h" 9 | 10 | /*--------------------------------------------------------------------------------*/ 11 | /* Macros and Defines */ 12 | /*--------------------------------------------------------------------------------*/ 13 | 14 | #define INTRINSICS_MAX_LEN 1024 15 | 16 | /*--------------------------------------------------------------------------------*/ 17 | /* Variable Declarations */ 18 | /*--------------------------------------------------------------------------------*/ 19 | 20 | extern q63_t intrinsics_output_fut[INTRINSICS_MAX_LEN]; 21 | extern q63_t intrinsics_output_ref[INTRINSICS_MAX_LEN]; 22 | extern float32_t intrinsics_output_f32_fut[INTRINSICS_MAX_LEN]; 23 | extern float32_t intrinsics_output_f32_ref[INTRINSICS_MAX_LEN]; 24 | extern const q63_t intrinsics_q63_inputs[INTRINSICS_MAX_LEN]; 25 | extern const q31_t *intrinsics_q31_inputs; 26 | 27 | #endif /* _INTRINSICS_TEST_DATA_H_ */ 28 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/intrinsics_tests/intrinsics_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _INTRINSICS_TEST_GROUP_H_ 2 | #define _INTRINSICS_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(intrinsics_tests); 8 | 9 | #endif /* _INTRINSICS_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _MATRIX_TEST_GROUP_H_ 2 | #define _MATRIX_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(matrix_tests); 8 | 9 | #endif /* _MATRIX_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _MATRIX_TESTS_H_ 2 | #define _MATRIX_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Test/Group Declarations */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(mat_add_tests); 8 | JTEST_DECLARE_GROUP(mat_cmplx_mult_tests); 9 | JTEST_DECLARE_GROUP(mat_init_tests); 10 | JTEST_DECLARE_GROUP(mat_inverse_tests); 11 | JTEST_DECLARE_GROUP(mat_mult_tests); 12 | JTEST_DECLARE_GROUP(mat_mult_fast_tests); 13 | JTEST_DECLARE_GROUP(mat_sub_tests); 14 | JTEST_DECLARE_GROUP(mat_trans_tests); 15 | JTEST_DECLARE_GROUP(mat_scale_tests); 16 | 17 | #endif /* _MATRIX_TESTS_H_ */ 18 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_test_data.h: -------------------------------------------------------------------------------- 1 | #ifndef _STATISTICS_TEST_DATA_H_ 2 | #define _STATISTICS_TEST_DATA_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "arr_desc.h" 9 | #include "arm_math.h" 10 | 11 | /*--------------------------------------------------------------------------------*/ 12 | /* Macros and Defines */ 13 | /*--------------------------------------------------------------------------------*/ 14 | #define STATISTICS_MAX_INPUT_ELEMENTS 32 15 | #define STATISTICS_BIGGEST_INPUT_TYPE float32_t 16 | 17 | /*--------------------------------------------------------------------------------*/ 18 | /* Declare Variables */ 19 | /*--------------------------------------------------------------------------------*/ 20 | 21 | /* Input/Output Buffers */ 22 | ARR_DESC_DECLARE(statistics_output_fut); 23 | ARR_DESC_DECLARE(statistics_output_ref); 24 | extern uint32_t statistics_idx_fut; 25 | extern uint32_t statistics_idx_ref; 26 | 27 | extern STATISTICS_BIGGEST_INPUT_TYPE 28 | statistics_output_f32_ref[STATISTICS_MAX_INPUT_ELEMENTS]; 29 | 30 | extern STATISTICS_BIGGEST_INPUT_TYPE 31 | statistics_output_f32_fut[STATISTICS_MAX_INPUT_ELEMENTS]; 32 | 33 | 34 | /* Block Sizes */ 35 | ARR_DESC_DECLARE(statistics_block_sizes); 36 | 37 | /* Float Inputs */ 38 | ARR_DESC_DECLARE(statistics_zeros); 39 | ARR_DESC_DECLARE(statistics_f_2); 40 | ARR_DESC_DECLARE(statistics_f_15); 41 | ARR_DESC_DECLARE(statistics_f_32); 42 | ARR_DESC_DECLARE(statistics_f_all); 43 | 44 | #endif /* _STATISTICS_TEST_DATA_H_ */ 45 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _STATISTICS_TEST_GROUP_H_ 2 | #define _STATISTICS_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(statistics_tests); 8 | 9 | #endif /* _STATISTICS_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _STATISTICS_TESTS_H_ 2 | #define _STATISTICS_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Test/Group Declarations */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(max_tests); 8 | JTEST_DECLARE_GROUP(mean_tests); 9 | JTEST_DECLARE_GROUP(min_tests); 10 | JTEST_DECLARE_GROUP(power_tests); 11 | JTEST_DECLARE_GROUP(rms_tests); 12 | JTEST_DECLARE_GROUP(std_tests); 13 | JTEST_DECLARE_GROUP(var_tests); 14 | 15 | #endif /* _STATISTICS_TESTS_H_ */ 16 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_test_data.h: -------------------------------------------------------------------------------- 1 | #ifndef ARM_SUPPORT_TEST_DATA_H 2 | #define ARM_SUPPORT_TEST_DATA_H 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Includes */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | #include "arr_desc.h" 9 | 10 | /*--------------------------------------------------------------------------------*/ 11 | /* Declare Variables */ 12 | /*--------------------------------------------------------------------------------*/ 13 | 14 | /* Input/Output Buffers */ 15 | ARR_DESC_DECLARE(support_output_fut); 16 | ARR_DESC_DECLARE(support_output_ref); 17 | 18 | /* Block Sizes*/ 19 | ARR_DESC_DECLARE(support_block_sizes); 20 | 21 | /* Numbers */ 22 | ARR_DESC_DECLARE(support_elts); 23 | 24 | /* Float Inputs */ 25 | ARR_DESC_DECLARE(support_zeros); 26 | ARR_DESC_DECLARE(support_f_2); 27 | ARR_DESC_DECLARE(support_f_15); 28 | ARR_DESC_DECLARE(support_f_32); 29 | ARR_DESC_DECLARE(support_f_all); 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _SUPPORT_TEST_GROUP_H_ 2 | #define _SUPPORT_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(support_tests); 8 | 9 | #endif /* _SUPPORT_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _SUPPORT_TESTS_H_ 2 | #define _SUPPORT_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Test/Group Declarations */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(copy_tests); 8 | JTEST_DECLARE_GROUP(fill_tests); 9 | JTEST_DECLARE_GROUP(x_to_y_tests); 10 | 11 | #endif /* _SUPPORT_TESTS_H_ */ 12 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_test_group.h: -------------------------------------------------------------------------------- 1 | #ifndef _TRANSFORM_TEST_GROUP_H_ 2 | #define _TRANSFORM_TEST_GROUP_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Declare Test Groups */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(transform_tests); 8 | 9 | #endif /* _TRANSFORM_TEST_GROUP_H_ */ 10 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_tests.h: -------------------------------------------------------------------------------- 1 | #ifndef _TRANSFORM_TESTS_H_ 2 | #define _TRANSFORM_TESTS_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Test/Group Declarations */ 6 | /*--------------------------------------------------------------------------------*/ 7 | JTEST_DECLARE_GROUP(cfft_tests); 8 | JTEST_DECLARE_GROUP(cfft_family_tests); 9 | JTEST_DECLARE_GROUP(dct4_tests); 10 | JTEST_DECLARE_GROUP(rfft_tests); 11 | JTEST_DECLARE_GROUP(rfft_fast_tests); 12 | 13 | #endif /* _TRANSFORM_TESTS_H_ */ 14 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/type_abbrev.h: -------------------------------------------------------------------------------- 1 | #ifndef _TYPE_ABBREV_H_ 2 | #define _TYPE_ABBREV_H_ 3 | 4 | /*--------------------------------------------------------------------------------*/ 5 | /* Macros and Defines */ 6 | /*--------------------------------------------------------------------------------*/ 7 | 8 | /** 9 | * Expand the abbreviation for a type into the type itself. 10 | */ 11 | #define TYPE_FROM_ABBREV(abbrev) \ 12 | TYPE_ABBREV_##abbrev \ 13 | 14 | /** 15 | * Expand the type to an abbreviation for that type. 16 | * 17 | * Inverse of #TYPE_FROM_ABBREV(). 18 | * 19 | * @note Should be able to get a type back by writing. 20 | * TYPE_FROM_ABBREV(ABBREV_FROM_TYPE(type)) 21 | */ 22 | #define ABBREV_FROM_TYPE(type) \ 23 | TYPE_SUFFIX_##type 24 | 25 | #define TYPE_ABBREV_f64 float64_t 26 | #define TYPE_ABBREV_f32 float32_t 27 | #define TYPE_ABBREV_q31 q31_t 28 | #define TYPE_ABBREV_q15 q15_t 29 | #define TYPE_ABBREV_q7 q7_t 30 | 31 | #define TYPE_SUFFIX_float64_t f64 32 | #define TYPE_SUFFIX_float32_t f32 33 | #define TYPE_SUFFIX_q31_t q31 34 | #define TYPE_SUFFIX_q15_t q15 35 | #define TYPE_SUFFIX_q7_t q7 36 | 37 | #endif /* _TYPE_ABBREV_H_ */ 38 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCC/Retarget.c: -------------------------------------------------------------------------------- 1 | /*---------------------------------------------------------------------------- 2 | * Name: Retarget.c 3 | * Purpose: 'Retarget' layer for target-dependent low level functions 4 | * Note(s): 5 | *---------------------------------------------------------------------------- 6 | * This file is part of the uVision/ARM development tools. 7 | * This software may only be used under the terms of a valid, current, 8 | * end user licence from KEIL for a compatible version of KEIL software 9 | * development tools. Nothing else gives you the right to use this software. 10 | * 11 | * This software is supplied "AS IS" without warranties of any kind. 12 | * 13 | * Copyright (c) 2011 Keil - An ARM Company. All rights reserved. 14 | *----------------------------------------------------------------------------*/ 15 | 16 | #include 17 | #include 18 | #include "Serial.h" 19 | 20 | #pragma import(__use_no_semihosting_swi) 21 | 22 | 23 | 24 | struct __FILE { int handle; /* Add whatever you need here */ }; 25 | FILE __stdout; 26 | FILE __stdin; 27 | 28 | 29 | int fputc(int c, FILE *f) { 30 | return (SER_PutChar(c)); 31 | } 32 | 33 | 34 | int fgetc(FILE *f) { 35 | return (SER_GetChar()); 36 | } 37 | 38 | 39 | int ferror(FILE *f) { 40 | /* Your implementation of ferror */ 41 | return EOF; 42 | } 43 | 44 | 45 | void _ttywrch(int c) { 46 | SER_PutChar(c); 47 | } 48 | 49 | 50 | void _sys_exit(int return_code) { 51 | label: goto label; /* endless loop */ 52 | } 53 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_generic.c: -------------------------------------------------------------------------------- 1 | 2 | #if (defined (ARMCM0)) 3 | #include "system_ARMCM0.c" 4 | 5 | #elif (defined (ARMCM0P)) 6 | #include "system_ARMCM0plus.c" 7 | 8 | #elif (defined (ARMCM3)) 9 | #include "system_ARMCM3.c" 10 | 11 | #elif (defined (ARMCM4) || defined (ARMCM4_FP)) 12 | #include "system_ARMCM4.c" 13 | 14 | #elif (defined (ARMCM7) || defined (ARMCM7_SP) || defined (ARMCM7_DP)) 15 | #include "system_ARMCM7.c" 16 | 17 | #elif defined (ARMv8MBL) 18 | #include "system_ARMv8MBL.c" 19 | 20 | #elif (defined (ARMv8MML) || defined (ARMv8MML_DSP) || \ 21 | defined (ARMv8MML_SP) || defined (ARMv8MML_DSP_SP) || \ 22 | defined (ARMv8MML_DP) || defined (ARMv8MML_DSP_DP) ) 23 | #include "system_ARMv8MML.c" 24 | 25 | #else 26 | #error "No appropriate system file found!" 27 | #endif 28 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/all_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_group.h" 3 | #include "complex_math_test_group.h" 4 | #include "controller_test_group.h" 5 | #include "fast_math_test_group.h" 6 | #include "filtering_test_group.h" 7 | #include "matrix_test_group.h" 8 | #include "statistics_test_group.h" 9 | #include "support_test_group.h" 10 | #include "transform_test_group.h" 11 | #include "intrinsics_test_group.h" 12 | 13 | JTEST_DEFINE_GROUP(all_tests) 14 | { 15 | /* 16 | To skip a test, comment it out 17 | */ 18 | JTEST_GROUP_CALL(basic_math_tests); 19 | JTEST_GROUP_CALL(complex_math_tests); 20 | JTEST_GROUP_CALL(controller_tests); 21 | JTEST_GROUP_CALL(fast_math_tests); 22 | JTEST_GROUP_CALL(filtering_tests); 23 | JTEST_GROUP_CALL(matrix_tests); 24 | JTEST_GROUP_CALL(statistics_tests); 25 | JTEST_GROUP_CALL(support_tests); 26 | JTEST_GROUP_CALL(transform_tests); 27 | JTEST_GROUP_CALL(intrinsics_tests); 28 | 29 | return; 30 | } 31 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/abs_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "basic_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_ABS_TEST(suffix) \ 11 | BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | abs, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix)) 16 | 17 | JTEST_ARM_ABS_TEST(f32); 18 | JTEST_ARM_ABS_TEST(q31); 19 | JTEST_ARM_ABS_TEST(q15); 20 | JTEST_ARM_ABS_TEST(q7 ); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(abs_tests) 27 | { 28 | JTEST_TEST_CALL(arm_abs_f32_test); 29 | JTEST_TEST_CALL(arm_abs_q31_test); 30 | JTEST_TEST_CALL(arm_abs_q15_test); 31 | JTEST_TEST_CALL(arm_abs_q7_test); 32 | } 33 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/add_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "basic_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_ADD_TEST(suffix) \ 11 | BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK( \ 12 | add, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | BASIC_MATH_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_ADD_TEST(f32); 19 | JTEST_ARM_ADD_TEST(q31); 20 | JTEST_ARM_ADD_TEST(q15); 21 | JTEST_ARM_ADD_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(add_tests) 28 | { 29 | JTEST_TEST_CALL(arm_add_f32_test); 30 | JTEST_TEST_CALL(arm_add_q31_test); 31 | JTEST_TEST_CALL(arm_add_q15_test); 32 | JTEST_TEST_CALL(arm_add_q7_test); 33 | } 34 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/basic_math_test_group.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_tests.h" 3 | 4 | JTEST_DEFINE_GROUP(basic_math_tests) 5 | { 6 | JTEST_GROUP_CALL(abs_tests); 7 | JTEST_GROUP_CALL(add_tests); 8 | JTEST_GROUP_CALL(dot_prod_tests); 9 | JTEST_GROUP_CALL(mult_tests); 10 | JTEST_GROUP_CALL(negate_tests); 11 | JTEST_GROUP_CALL(offset_tests); 12 | JTEST_GROUP_CALL(scale_tests); 13 | JTEST_GROUP_CALL(shift_tests); 14 | JTEST_GROUP_CALL(sub_tests); 15 | 16 | return; 17 | } 18 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/dot_prod_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "basic_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_DOT_PROD_TEST(suffix) \ 11 | BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK( \ 12 | dot_prod, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | BASIC_MATH_SNR_ELT1_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_DOT_PROD_TEST(f32); 19 | JTEST_ARM_DOT_PROD_TEST(q31); 20 | JTEST_ARM_DOT_PROD_TEST(q15); 21 | JTEST_ARM_DOT_PROD_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(dot_prod_tests) 28 | { 29 | JTEST_TEST_CALL(arm_dot_prod_f32_test); 30 | JTEST_TEST_CALL(arm_dot_prod_q31_test); 31 | JTEST_TEST_CALL(arm_dot_prod_q15_test); 32 | JTEST_TEST_CALL(arm_dot_prod_q7_test); 33 | } 34 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/mult_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "basic_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_MULT_TEST(suffix, compare_interface) \ 11 | BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK( \ 12 | mult, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | compare_interface) 17 | 18 | JTEST_ARM_MULT_TEST(f32, BASIC_MATH_COMPARE_INTERFACE); 19 | JTEST_ARM_MULT_TEST(q31, BASIC_MATH_SNR_COMPARE_INTERFACE); 20 | JTEST_ARM_MULT_TEST(q15, BASIC_MATH_COMPARE_INTERFACE); 21 | JTEST_ARM_MULT_TEST(q7 , BASIC_MATH_COMPARE_INTERFACE); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(mult_tests) 28 | { 29 | JTEST_TEST_CALL(arm_mult_f32_test); 30 | JTEST_TEST_CALL(arm_mult_q31_test); 31 | JTEST_TEST_CALL(arm_mult_q15_test); 32 | JTEST_TEST_CALL(arm_mult_q7_test); 33 | } 34 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/negate_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "basic_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_NEGATE_TEST(suffix) \ 11 | BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | negate, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix)) 16 | 17 | JTEST_ARM_NEGATE_TEST(f32); 18 | JTEST_ARM_NEGATE_TEST(q31); 19 | JTEST_ARM_NEGATE_TEST(q15); 20 | JTEST_ARM_NEGATE_TEST(q7); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(negate_tests) 27 | { 28 | JTEST_TEST_CALL(arm_negate_f32_test); 29 | JTEST_TEST_CALL(arm_negate_q31_test); 30 | JTEST_TEST_CALL(arm_negate_q15_test); 31 | JTEST_TEST_CALL(arm_negate_q7_test); 32 | } 33 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/offset_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "basic_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_OFFSET_TEST(suffix) \ 11 | BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT1_BLK( \ 12 | offset, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | TYPE_FROM_ABBREV(suffix)) 17 | 18 | JTEST_ARM_OFFSET_TEST(f32); 19 | JTEST_ARM_OFFSET_TEST(q31); 20 | JTEST_ARM_OFFSET_TEST(q15); 21 | JTEST_ARM_OFFSET_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(offset_tests) 28 | { 29 | JTEST_TEST_CALL(arm_offset_f32_test); 30 | JTEST_TEST_CALL(arm_offset_q31_test); 31 | JTEST_TEST_CALL(arm_offset_q15_test); 32 | JTEST_TEST_CALL(arm_offset_q7_test); 33 | } 34 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/shift_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "basic_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_SHIFT_TEST(suffix) \ 11 | BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT1_BLK( \ 12 | shift, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | int8_t, /*elt_type*/ \ 16 | TYPE_FROM_ABBREV(suffix)) 17 | 18 | JTEST_ARM_SHIFT_TEST(q31); 19 | JTEST_ARM_SHIFT_TEST(q15); 20 | JTEST_ARM_SHIFT_TEST(q7); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(shift_tests) 27 | { 28 | JTEST_TEST_CALL(arm_shift_q31_test); 29 | JTEST_TEST_CALL(arm_shift_q15_test); 30 | JTEST_TEST_CALL(arm_shift_q7_test); 31 | } 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/sub_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "basic_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "basic_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_SUB_TEST(suffix) \ 11 | BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK( \ 12 | sub, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | BASIC_MATH_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_SUB_TEST(f32); 19 | JTEST_ARM_SUB_TEST(q31); 20 | JTEST_ARM_SUB_TEST(q15); 21 | JTEST_ARM_SUB_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(sub_tests) 28 | { 29 | JTEST_TEST_CALL(arm_sub_f32_test); 30 | JTEST_TEST_CALL(arm_sub_q31_test); 31 | JTEST_TEST_CALL(arm_sub_q15_test); 32 | JTEST_TEST_CALL(arm_sub_q7_test); 33 | } 34 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/cmplx_conj_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "complex_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "complex_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_CMPLX_CONJ_TEST(suffix) \ 11 | COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | cmplx_conj, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | COMPLEX_MATH_SNR_COMPARE_CMPLX_INTERFACE) 17 | 18 | JTEST_ARM_CMPLX_CONJ_TEST(f32); 19 | JTEST_ARM_CMPLX_CONJ_TEST(q31); 20 | JTEST_ARM_CMPLX_CONJ_TEST(q15); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(cmplx_conj_tests) 27 | { 28 | JTEST_TEST_CALL(arm_cmplx_conj_f32_test); 29 | JTEST_TEST_CALL(arm_cmplx_conj_q31_test); 30 | JTEST_TEST_CALL(arm_cmplx_conj_q15_test); 31 | } 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/cmplx_dot_prod_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "complex_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "complex_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_CMPLX_DOT_PROD_TEST(suffix, comparison_interface) \ 11 | COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK( \ 12 | cmplx_dot_prod, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | comparison_interface) 17 | 18 | JTEST_ARM_CMPLX_DOT_PROD_TEST(f32, COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE); 19 | JTEST_ARM_CMPLX_DOT_PROD_TEST(q31, COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE); 20 | JTEST_ARM_CMPLX_DOT_PROD_TEST(q15, COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(cmplx_dot_prod_tests) 27 | { 28 | JTEST_TEST_CALL(arm_cmplx_dot_prod_f32_test); 29 | JTEST_TEST_CALL(arm_cmplx_dot_prod_q31_test); 30 | JTEST_TEST_CALL(arm_cmplx_dot_prod_q15_test); 31 | } 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/cmplx_mag_squared_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "complex_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "complex_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_CMPLX_MAG_SQUARED_TEST(suffix) \ 11 | COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | cmplx_mag_squared, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | COMPLEX_MATH_COMPARE_RE_INTERFACE) 17 | 18 | JTEST_ARM_CMPLX_MAG_SQUARED_TEST(f32); 19 | JTEST_ARM_CMPLX_MAG_SQUARED_TEST(q31); 20 | JTEST_ARM_CMPLX_MAG_SQUARED_TEST(q15); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(cmplx_mag_squared_tests) 27 | { 28 | JTEST_TEST_CALL(arm_cmplx_mag_squared_f32_test); 29 | JTEST_TEST_CALL(arm_cmplx_mag_squared_q31_test); 30 | JTEST_TEST_CALL(arm_cmplx_mag_squared_q15_test); 31 | } 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/cmplx_mag_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "complex_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "complex_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_CMPLX_MAG_TEST(suffix, comparison_interface) \ 11 | COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | cmplx_mag, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | comparison_interface) 17 | 18 | JTEST_ARM_CMPLX_MAG_TEST(f32, COMPLEX_MATH_COMPARE_RE_INTERFACE); 19 | JTEST_ARM_CMPLX_MAG_TEST(q31, COMPLEX_MATH_SNR_COMPARE_RE_INTERFACE); 20 | JTEST_ARM_CMPLX_MAG_TEST(q15, COMPLEX_MATH_SNR_COMPARE_RE_INTERFACE); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(cmplx_mag_tests) 27 | { 28 | JTEST_TEST_CALL(arm_cmplx_mag_f32_test); 29 | JTEST_TEST_CALL(arm_cmplx_mag_q31_test); 30 | JTEST_TEST_CALL(arm_cmplx_mag_q15_test); 31 | } 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/cmplx_mult_cmplx_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "complex_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "complex_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_CMPLX_MULT_CMPLX_TEST(suffix) \ 11 | COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK( \ 12 | cmplx_mult_cmplx, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | COMPLEX_MATH_COMPARE_CMPLX_INTERFACE) 17 | 18 | JTEST_ARM_CMPLX_MULT_CMPLX_TEST(f32); 19 | JTEST_ARM_CMPLX_MULT_CMPLX_TEST(q31); 20 | JTEST_ARM_CMPLX_MULT_CMPLX_TEST(q15); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(cmplx_mult_cmplx_tests) 27 | { 28 | JTEST_TEST_CALL(arm_cmplx_mult_cmplx_f32_test); 29 | JTEST_TEST_CALL(arm_cmplx_mult_cmplx_q31_test); 30 | JTEST_TEST_CALL(arm_cmplx_mult_cmplx_q15_test); 31 | } 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/cmplx_mult_real_test.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "complex_math_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "complex_math_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_CMPLX_MULT_REAL_TEST(suffix, comparison_interface) \ 11 | COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK( \ 12 | cmplx_mult_real, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | comparison_interface) 17 | 18 | JTEST_ARM_CMPLX_MULT_REAL_TEST(f32, COMPLEX_MATH_COMPARE_CMPLX_INTERFACE); 19 | JTEST_ARM_CMPLX_MULT_REAL_TEST(q31, COMPLEX_MATH_SNR_COMPARE_CMPLX_INTERFACE); 20 | JTEST_ARM_CMPLX_MULT_REAL_TEST(q15, COMPLEX_MATH_COMPARE_CMPLX_INTERFACE); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(cmplx_mult_real_tests) 27 | { 28 | JTEST_TEST_CALL(arm_cmplx_mult_real_f32_test); 29 | JTEST_TEST_CALL(arm_cmplx_mult_real_q31_test); 30 | JTEST_TEST_CALL(arm_cmplx_mult_real_q15_test); 31 | } 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/complex_math_test_group.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "complex_math_tests.h" 3 | 4 | JTEST_DEFINE_GROUP(complex_math_tests) 5 | { 6 | JTEST_GROUP_CALL(cmplx_conj_tests); 7 | JTEST_GROUP_CALL(cmplx_dot_prod_tests); 8 | JTEST_GROUP_CALL(cmplx_mag_tests); 9 | JTEST_GROUP_CALL(cmplx_mag_squared_tests); 10 | JTEST_GROUP_CALL(cmplx_mult_cmplx_tests); 11 | JTEST_GROUP_CALL(cmplx_mult_real_tests); 12 | 13 | return; 14 | } 15 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/controller_tests/controller_test_group.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "controller_tests.h" 3 | 4 | JTEST_DEFINE_GROUP(controller_tests) 5 | { 6 | /* 7 | To skip a test, comment it out. 8 | */ 9 | JTEST_GROUP_CALL(pid_reset_tests); 10 | JTEST_GROUP_CALL(pid_tests); 11 | JTEST_GROUP_CALL(sin_cos_tests); 12 | return; 13 | } 14 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/fast_math_tests/fast_math_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "ref.h" 3 | #include "arr_desc.h" 4 | #include "fast_math_templates.h" 5 | #include "fast_math_test_data.h" 6 | #include "type_abbrev.h" 7 | 8 | SQRT_TEST_TEMPLATE_ELT1(q31); 9 | SQRT_TEST_TEMPLATE_ELT1(q15); 10 | 11 | SIN_COS_TEST_TEMPLATE_ELT1(f32, float32_t, sin); 12 | SIN_COS_TEST_TEMPLATE_ELT1(q31, q31_t, sin); 13 | SIN_COS_TEST_TEMPLATE_ELT1(q15, q15_t, sin); 14 | 15 | SIN_COS_TEST_TEMPLATE_ELT1(f32, float32_t, cos); 16 | SIN_COS_TEST_TEMPLATE_ELT1(q31, q31_t, cos); 17 | SIN_COS_TEST_TEMPLATE_ELT1(q15, q15_t, cos); 18 | 19 | /*--------------------------------------------------------------------------------*/ 20 | /* Collect all tests in a group */ 21 | /*--------------------------------------------------------------------------------*/ 22 | 23 | JTEST_DEFINE_GROUP(fast_math_tests) 24 | { 25 | /* 26 | To skip a test, comment it out. 27 | */ 28 | JTEST_TEST_CALL(arm_sqrt_q31_test); 29 | JTEST_TEST_CALL(arm_sqrt_q15_test); 30 | 31 | JTEST_TEST_CALL(arm_sin_f32_test); 32 | JTEST_TEST_CALL(arm_sin_q31_test); 33 | JTEST_TEST_CALL(arm_sin_q15_test); 34 | 35 | JTEST_TEST_CALL(arm_cos_f32_test); 36 | JTEST_TEST_CALL(arm_cos_q31_test); 37 | JTEST_TEST_CALL(arm_cos_q15_test); 38 | } 39 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/filtering_tests/filtering_test_group.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "filtering_tests.h" 3 | 4 | JTEST_DEFINE_GROUP(filtering_tests) 5 | { 6 | /* 7 | To skip a test, comment it out. 8 | */ 9 | JTEST_GROUP_CALL(biquad_tests); 10 | JTEST_GROUP_CALL(conv_tests); 11 | JTEST_GROUP_CALL(correlate_tests); 12 | JTEST_GROUP_CALL(fir_tests); 13 | JTEST_GROUP_CALL(iir_tests); 14 | JTEST_GROUP_CALL(lms_tests); 15 | 16 | return; 17 | } 18 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/main.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "all_tests.h" 3 | #include "arm_math.h" 4 | 5 | 6 | #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) 7 | asm(" .global __ARM_use_no_argv\n"); 8 | #endif 9 | 10 | 11 | void debug_init(void) 12 | { 13 | uint32_t * SHCSR_ptr = (uint32_t *) 0xE000ED24; /* System Handler Control and State Register */ 14 | *SHCSR_ptr |= 0x70000; /* Enable UsageFault, BusFault, and MemManage fault*/ 15 | } 16 | 17 | int main(void) 18 | { 19 | debug_init(); 20 | 21 | JTEST_INIT(); /* Initialize test framework. */ 22 | 23 | JTEST_GROUP_CALL(all_tests); /* Run all tests. */ 24 | 25 | JTEST_ACT_EXIT_FW(); /* Exit test framework. */ 26 | while (1); /* Never return. */ 27 | } 28 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/matrix_tests/mat_add_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "matrix_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "matrix_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_MAT_ADD_TEST(suffix) \ 11 | MATRIX_DEFINE_TEST_TEMPLATE_ELT2( \ 12 | mat_add, \ 13 | suffix, \ 14 | MATRIX_TEST_CONFIG_ADDITIVE_OUTPUT, \ 15 | MATRIX_TEST_VALID_ADDITIVE_DIMENSIONS, \ 16 | MATRIX_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_MAT_ADD_TEST(f32); 19 | JTEST_ARM_MAT_ADD_TEST(q31); 20 | JTEST_ARM_MAT_ADD_TEST(q15); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(mat_add_tests) 27 | { 28 | JTEST_TEST_CALL(arm_mat_add_f32_test); 29 | JTEST_TEST_CALL(arm_mat_add_q31_test); 30 | JTEST_TEST_CALL(arm_mat_add_q15_test); 31 | } 32 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/matrix_tests/mat_sub_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "matrix_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "matrix_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_MAT_SUB_TEST(suffix) \ 11 | MATRIX_DEFINE_TEST_TEMPLATE_ELT2( \ 12 | mat_sub, \ 13 | suffix, \ 14 | MATRIX_TEST_CONFIG_ADDITIVE_OUTPUT, \ 15 | MATRIX_TEST_VALID_ADDITIVE_DIMENSIONS, \ 16 | MATRIX_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_MAT_SUB_TEST(f32); 19 | JTEST_ARM_MAT_SUB_TEST(q31); 20 | JTEST_ARM_MAT_SUB_TEST(q15); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(mat_sub_tests) 27 | { 28 | /* 29 | To skip a test, comment it out. 30 | */ 31 | JTEST_TEST_CALL(arm_mat_sub_f32_test); 32 | JTEST_TEST_CALL(arm_mat_sub_q31_test); 33 | JTEST_TEST_CALL(arm_mat_sub_q15_test); 34 | } 35 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/matrix_tests/mat_trans_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "matrix_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "matrix_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_MAT_TRANS_TEST(suffix) \ 11 | MATRIX_DEFINE_TEST_TEMPLATE_ELT1( \ 12 | mat_trans, \ 13 | suffix, \ 14 | MATRIX_TEST_CONFIG_TRANSPOSE_OUTPUT, \ 15 | MATRIX_TEST_VALID_DIMENSIONS_ALWAYS) 16 | 17 | JTEST_ARM_MAT_TRANS_TEST(f32); 18 | JTEST_ARM_MAT_TRANS_TEST(q31); 19 | JTEST_ARM_MAT_TRANS_TEST(q15); 20 | 21 | /*--------------------------------------------------------------------------------*/ 22 | /* Collect all tests in a group. */ 23 | /*--------------------------------------------------------------------------------*/ 24 | 25 | JTEST_DEFINE_GROUP(mat_trans_tests) 26 | { 27 | /* 28 | To skip a test, comment it out. 29 | */ 30 | JTEST_TEST_CALL(arm_mat_trans_f32_test); 31 | JTEST_TEST_CALL(arm_mat_trans_q31_test); 32 | JTEST_TEST_CALL(arm_mat_trans_q15_test); 33 | } 34 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/matrix_tests/matrix_test_group.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "matrix_tests.h" 3 | 4 | JTEST_DEFINE_GROUP(matrix_tests) 5 | { 6 | /* 7 | To skip a test, comment it out. 8 | */ 9 | JTEST_GROUP_CALL(mat_add_tests); 10 | JTEST_GROUP_CALL(mat_cmplx_mult_tests); 11 | JTEST_GROUP_CALL(mat_init_tests); 12 | JTEST_GROUP_CALL(mat_inverse_tests); 13 | JTEST_GROUP_CALL(mat_mult_tests); 14 | JTEST_GROUP_CALL(mat_mult_fast_tests); 15 | JTEST_GROUP_CALL(mat_sub_tests); 16 | JTEST_GROUP_CALL(mat_trans_tests); 17 | JTEST_GROUP_CALL(mat_scale_tests); 18 | return; 19 | } 20 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/statistics_tests/max_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "statistics_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "statistics_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_MAX_TEST(suffix) \ 11 | STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | max, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | STATISTICS_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_MAX_TEST(f32); 19 | JTEST_ARM_MAX_TEST(q31); 20 | JTEST_ARM_MAX_TEST(q15); 21 | JTEST_ARM_MAX_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(max_tests) 28 | { 29 | /* 30 | To skip a test, comment it out. 31 | */ 32 | JTEST_TEST_CALL(arm_max_f32_test); 33 | JTEST_TEST_CALL(arm_max_q31_test); 34 | JTEST_TEST_CALL(arm_max_q15_test); 35 | JTEST_TEST_CALL(arm_max_q7_test); 36 | } 37 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/statistics_tests/mean_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "statistics_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "statistics_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_MEAN_TEST(suffix) \ 11 | STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | mean, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | STATISTICS_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_MEAN_TEST(f32); 19 | JTEST_ARM_MEAN_TEST(q31); 20 | JTEST_ARM_MEAN_TEST(q15); 21 | JTEST_ARM_MEAN_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(mean_tests) 28 | { 29 | /* 30 | To skip a test, comment it out. 31 | */ 32 | JTEST_TEST_CALL(arm_mean_f32_test); 33 | JTEST_TEST_CALL(arm_mean_q31_test); 34 | JTEST_TEST_CALL(arm_mean_q15_test); 35 | JTEST_TEST_CALL(arm_mean_q7_test); 36 | } 37 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/statistics_tests/min_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "statistics_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "statistics_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_MIN_TEST(suffix) \ 11 | STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | min, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | STATISTICS_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_MIN_TEST(f32); 19 | JTEST_ARM_MIN_TEST(q31); 20 | JTEST_ARM_MIN_TEST(q15); 21 | JTEST_ARM_MIN_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(min_tests) 28 | { 29 | /* 30 | To skip a test, comment it out. 31 | */ 32 | JTEST_TEST_CALL(arm_min_f32_test); 33 | JTEST_TEST_CALL(arm_min_q31_test); 34 | JTEST_TEST_CALL(arm_min_q15_test); 35 | JTEST_TEST_CALL(arm_min_q7_test); 36 | } 37 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/statistics_tests/power_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "statistics_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "statistics_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_POWER_TEST(suffix, output_type) \ 11 | STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | power, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | STATISTICS_SNR_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_POWER_TEST(f32, float32_t); 19 | JTEST_ARM_POWER_TEST(q31, q63_t); 20 | JTEST_ARM_POWER_TEST(q15, q63_t); 21 | JTEST_ARM_POWER_TEST(q7, q31_t); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(power_tests) 28 | { 29 | /* 30 | To skip a test, comment it out. 31 | */ 32 | JTEST_TEST_CALL(arm_power_f32_test); 33 | JTEST_TEST_CALL(arm_power_q31_test); 34 | JTEST_TEST_CALL(arm_power_q15_test); 35 | JTEST_TEST_CALL(arm_power_q7_test); 36 | } 37 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/statistics_tests/rms_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "statistics_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "statistics_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_RMS_TEST(suffix) \ 11 | STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | rms, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | STATISTICS_SNR_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_RMS_TEST(f32); 19 | JTEST_ARM_RMS_TEST(q31); 20 | JTEST_ARM_RMS_TEST(q15); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(rms_tests) 27 | { 28 | /* 29 | To skip a test, comment it out. 30 | */ 31 | JTEST_TEST_CALL(arm_rms_f32_test); 32 | JTEST_TEST_CALL(arm_rms_q31_test); 33 | JTEST_TEST_CALL(arm_rms_q15_test); 34 | } 35 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/statistics_tests/statistics_test_group.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "statistics_tests.h" 3 | 4 | JTEST_DEFINE_GROUP(statistics_tests) 5 | { 6 | JTEST_GROUP_CALL(max_tests); 7 | JTEST_GROUP_CALL(mean_tests); 8 | JTEST_GROUP_CALL(min_tests); 9 | JTEST_GROUP_CALL(power_tests); 10 | JTEST_GROUP_CALL(rms_tests); 11 | JTEST_GROUP_CALL(std_tests); 12 | JTEST_GROUP_CALL(var_tests); 13 | return; 14 | } 15 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/statistics_tests/std_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "statistics_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "statistics_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_STD_TEST(suffix) \ 11 | STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | std, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | STATISTICS_SNR_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_STD_TEST(f32); 19 | JTEST_ARM_STD_TEST(q31); 20 | JTEST_ARM_STD_TEST(q15); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(std_tests) 27 | { 28 | /* 29 | To skip a test, comment it out. 30 | */ 31 | JTEST_TEST_CALL(arm_std_f32_test); 32 | JTEST_TEST_CALL(arm_std_q31_test); 33 | JTEST_TEST_CALL(arm_std_q15_test); 34 | } 35 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/statistics_tests/var_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "statistics_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "statistics_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_VAR_TEST(suffix) \ 11 | STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | var, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | STATISTICS_SNR_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_VAR_TEST(f32); 19 | JTEST_ARM_VAR_TEST(q31); 20 | JTEST_ARM_VAR_TEST(q15); 21 | 22 | /*--------------------------------------------------------------------------------*/ 23 | /* Collect all tests in a group. */ 24 | /*--------------------------------------------------------------------------------*/ 25 | 26 | JTEST_DEFINE_GROUP(var_tests) 27 | { 28 | /* 29 | To skip a test, comment it out. 30 | */ 31 | JTEST_TEST_CALL(arm_var_f32_test); 32 | JTEST_TEST_CALL(arm_var_q31_test); 33 | JTEST_TEST_CALL(arm_var_q15_test); 34 | } 35 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/support_tests/copy_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "support_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "support_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_COPY_TEST(suffix) \ 11 | SUPPORT_DEFINE_TEST_TEMPLATE_BUF1_BLK( \ 12 | copy, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | SUPPORT_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_COPY_TEST(f32); 19 | JTEST_ARM_COPY_TEST(q31); 20 | JTEST_ARM_COPY_TEST(q15); 21 | JTEST_ARM_COPY_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(copy_tests) 28 | { 29 | JTEST_TEST_CALL(arm_copy_f32_test); 30 | JTEST_TEST_CALL(arm_copy_q31_test); 31 | JTEST_TEST_CALL(arm_copy_q15_test); 32 | JTEST_TEST_CALL(arm_copy_q7_test); 33 | } 34 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/support_tests/fill_tests.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "support_test_data.h" 3 | #include "arr_desc.h" 4 | #include "arm_math.h" /* FUTs */ 5 | #include "ref.h" /* Reference Functions */ 6 | #include "test_templates.h" 7 | #include "support_templates.h" 8 | #include "type_abbrev.h" 9 | 10 | #define JTEST_ARM_FILL_TEST(suffix) \ 11 | SUPPORT_DEFINE_TEST_TEMPLATE_ELT1_BLK( \ 12 | fill, \ 13 | suffix, \ 14 | TYPE_FROM_ABBREV(suffix), \ 15 | TYPE_FROM_ABBREV(suffix), \ 16 | SUPPORT_COMPARE_INTERFACE) 17 | 18 | JTEST_ARM_FILL_TEST(f32); 19 | JTEST_ARM_FILL_TEST(q31); 20 | JTEST_ARM_FILL_TEST(q15); 21 | JTEST_ARM_FILL_TEST(q7); 22 | 23 | /*--------------------------------------------------------------------------------*/ 24 | /* Collect all tests in a group. */ 25 | /*--------------------------------------------------------------------------------*/ 26 | 27 | JTEST_DEFINE_GROUP(fill_tests) 28 | { 29 | /* 30 | To skip a test, comment it out. 31 | */ 32 | JTEST_TEST_CALL(arm_fill_f32_test); 33 | JTEST_TEST_CALL(arm_fill_q31_test); 34 | JTEST_TEST_CALL(arm_fill_q15_test); 35 | JTEST_TEST_CALL(arm_fill_q7_test); 36 | } 37 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/support_tests/support_test_group.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "support_tests.h" 3 | 4 | JTEST_DEFINE_GROUP(support_tests) 5 | { 6 | JTEST_GROUP_CALL(copy_tests); 7 | JTEST_GROUP_CALL(fill_tests); 8 | JTEST_GROUP_CALL(x_to_y_tests); 9 | return; 10 | } 11 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/transform_tests/transform_test_group.c: -------------------------------------------------------------------------------- 1 | #include "jtest.h" 2 | #include "transform_tests.h" 3 | 4 | JTEST_DEFINE_GROUP(transform_tests) 5 | { 6 | JTEST_GROUP_CALL(cfft_tests); 7 | JTEST_GROUP_CALL(cfft_family_tests); 8 | JTEST_GROUP_CALL(rfft_tests); 9 | JTEST_GROUP_CALL(rfft_fast_tests); 10 | JTEST_GROUP_CALL(dct4_tests); 11 | } 12 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/DspLibTest_MPS2/HowTo.txt: -------------------------------------------------------------------------------- 1 | 2 | Used board: 3 | MPS2+. 4 | 5 | Used BIOS: 6 | mbb_v121.ebf ; use this for ULINKpro 7 | mbb_v220.ebf ; CMSIS-DAP 8 | 9 | Used Images: 10 | AN382\an382_v3.txt ; Cortex-M0 11 | AN385\an385_v3.txt ; Cortex-M3 12 | AN386\an386_v3.txt ; Cortex-M4 13 | AN500\an500_v1.txt ; Cortex-M7 14 | AN505\an505_v2.txt ; Cortex-M33 (IoT Kit) 15 | AN519\an519_v1.txt ; Cortex-M23 (IoT Kit) 16 | 17 | Used Debugger: 18 | IoT Kit: 19 | ULINKpro, JTAG, 25MHz, HW Reset 20 | other: 21 | ULINKpro, JTAG, 25MHz, Autodetect 22 | 23 | Memory Settings: 24 | IoT Kit: 25 | ROM: 0x10000000 26 | RAM: 0x38000000 27 | other: 28 | ROM: 0x00000000 29 | RAM: 0x20000000 -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/abs.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_abs_f32( 4 | float32_t * pSrc, 5 | float32_t * pDst, 6 | uint32_t blockSize) 7 | { 8 | uint32_t i; 9 | 10 | for(i=0;i> 14; //16.48 31 | } 32 | *result = sum; 33 | } 34 | 35 | void ref_dot_prod_q15( 36 | q15_t * pSrcA, 37 | q15_t * pSrcB, 38 | uint32_t blockSize, 39 | q63_t * result) 40 | { 41 | uint32_t i; 42 | q63_t sum = 0.0f; 43 | 44 | for(i=0;i> 32; 29 | temp = temp << 1; 30 | pDst[i] = ref_sat_q31(temp); 31 | } 32 | } 33 | 34 | void ref_mult_q15( 35 | q15_t * pSrcA, 36 | q15_t * pSrcB, 37 | q15_t * pDst, 38 | uint32_t blockSize) 39 | { 40 | uint32_t i; 41 | q31_t temp; 42 | 43 | for(i=0;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. 46 | pDst[i] = ref_sat_q15(temp); 47 | } 48 | } 49 | 50 | void ref_mult_q7( 51 | q7_t * pSrcA, 52 | q7_t * pSrcB, 53 | q7_t * pDst, 54 | uint32_t blockSize) 55 | { 56 | uint32_t i; 57 | q15_t temp; 58 | 59 | for(i=0;i> 7; 62 | pDst[i] = ref_sat_q7(temp); 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/negate.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_negate_f32( 4 | float32_t * pSrc, 5 | float32_t * pDst, 6 | uint32_t blockSize) 7 | { 8 | uint32_t i; 9 | 10 | for(i=0;i> 32; 32 | if (sign) 33 | pDst[i] = temp >> -kShift; 34 | else 35 | pDst[i] = ref_sat_q31( (q63_t)temp << kShift ); 36 | } 37 | } 38 | 39 | void ref_scale_q15( 40 | q15_t * pSrc, 41 | q15_t scaleFract, 42 | int8_t shift, 43 | q15_t * pDst, 44 | uint32_t blockSize) 45 | { 46 | uint32_t i; 47 | int8_t kShift = 15 - shift; /* Shift to apply after scaling */ 48 | 49 | for(i=0;i> kShift); 52 | } 53 | } 54 | 55 | void ref_scale_q7( 56 | q7_t * pSrc, 57 | q7_t scaleFract, 58 | int8_t shift, 59 | q7_t * pDst, 60 | uint32_t blockSize) 61 | { 62 | uint32_t i; 63 | int8_t kShift = 7 - shift; /* Shift to apply after scaling */ 64 | 65 | for(i=0;i> kShift); 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/shift.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_shift_q31( 4 | q31_t * pSrc, 5 | int8_t shiftBits, 6 | q31_t * pDst, 7 | uint32_t blockSize) 8 | { 9 | uint32_t i; 10 | 11 | if (shiftBits < 0) 12 | { 13 | for(i=0;i> -shiftBits; 23 | } 24 | } 25 | } 26 | 27 | void ref_shift_q15( 28 | q15_t * pSrc, 29 | int8_t shiftBits, 30 | q15_t * pDst, 31 | uint32_t blockSize) 32 | { 33 | uint32_t i; 34 | 35 | if (shiftBits < 0) 36 | { 37 | for(i=0;i> -shiftBits; 47 | } 48 | } 49 | } 50 | 51 | void ref_shift_q7( 52 | q7_t * pSrc, 53 | int8_t shiftBits, 54 | q7_t * pDst, 55 | uint32_t blockSize) 56 | { 57 | uint32_t i; 58 | 59 | if (shiftBits < 0) 60 | { 61 | for(i=0;i> -shiftBits; 71 | } 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/BasicMathFunctions/sub.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_sub_f32( 4 | float32_t * pSrcA, 5 | float32_t * pSrcB, 6 | float32_t * pDst, 7 | uint32_t blockSize) 8 | { 9 | uint32_t i; 10 | 11 | for(i=0;i> 33); 27 | acc1 = (q31_t)(((q63_t)pSrc[i+1] * pSrc[i+1]) >> 33); 28 | out = acc0 + acc1; 29 | *pDst++ = (q31_t)(sqrtf((float)out / 2147483648.0f) * 2147483648.0f); 30 | } 31 | } 32 | 33 | void ref_cmplx_mag_q15( 34 | q15_t * pSrc, 35 | q15_t * pDst, 36 | uint32_t numSamples) 37 | { 38 | uint32_t i; 39 | q31_t acc0,acc1; 40 | q15_t out; 41 | 42 | for(i=0;i> 17); 47 | *pDst++ = (q15_t)(sqrtf((float)out / 32768.0f) * 32768.0f); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/cmplx_mag_squared.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_cmplx_mag_squared_f32( 4 | float32_t * pSrc, 5 | float32_t * pDst, 6 | uint32_t numSamples) 7 | { 8 | uint32_t i; 9 | 10 | for(i=0;i> 33); 27 | acc1 = (q31_t)(((q63_t)pSrc[i+1] * pSrc[i+1]) >> 33); 28 | *pDst++ = acc0 + acc1; 29 | } 30 | } 31 | 32 | void ref_cmplx_mag_squared_q15( 33 | q15_t * pSrc, 34 | q15_t * pDst, 35 | uint32_t numSamples) 36 | { 37 | uint32_t i; 38 | q31_t acc0,acc1; 39 | 40 | for(i=0;i> 17); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/cmplx_mult_cmplx.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_cmplx_mult_cmplx_f32( 4 | float32_t * pSrcA, 5 | float32_t * pSrcB, 6 | float32_t * pDst, 7 | uint32_t numSamples) 8 | { 9 | uint32_t i; 10 | 11 | for(i=0;i> 33; 30 | mul2 = ((q63_t)pSrcA[i+1] * pSrcB[i+1]) >> 33; 31 | mul3 = ((q63_t)pSrcA[i] * pSrcB[i+1]) >> 33; 32 | mul4 = ((q63_t)pSrcA[i+1] * pSrcB[i]) >> 33; 33 | pDst[i] = mul1 - mul2; 34 | pDst[i+1] = mul3 + mul4; 35 | } 36 | } 37 | 38 | void ref_cmplx_mult_cmplx_q15( 39 | q15_t * pSrcA, 40 | q15_t * pSrcB, 41 | q15_t * pDst, 42 | uint32_t numSamples) 43 | { 44 | uint32_t i; 45 | q31_t mul1, mul2, mul3, mul4; 46 | 47 | for(i=0;i> 17; 50 | mul2 = ((q31_t)pSrcA[i+1] * pSrcB[i+1]) >> 17; 51 | mul3 = ((q31_t)pSrcA[i] * pSrcB[i+1]) >> 17; 52 | mul4 = ((q31_t)pSrcA[i+1] * pSrcB[i]) >> 17; 53 | pDst[i] = mul1 - mul2; 54 | pDst[i+1] = mul3 + mul4; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ComplexMathFunctions/cmplx_mult_real.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_cmplx_mult_real_f32( 4 | float32_t * pSrcCmplx, 5 | float32_t * pSrcReal, 6 | float32_t * pCmplxDst, 7 | uint32_t numSamples) 8 | { 9 | uint32_t i; 10 | 11 | for(i=0;i> 32; 30 | tempI = ((q63_t) pSrcCmplx[2*i+1] * pSrcReal[i]) >> 32; 31 | pCmplxDst[2*i+0] = ref_sat_n(tempR, 31) << 1; 32 | pCmplxDst[2*i+1] = ref_sat_n(tempI, 31) << 1; 33 | } 34 | } 35 | 36 | void ref_cmplx_mult_real_q15( 37 | q15_t * pSrcCmplx, 38 | q15_t * pSrcReal, 39 | q15_t * pCmplxDst, 40 | uint32_t numSamples) 41 | { 42 | uint32_t i; 43 | q31_t tempR, tempI; 44 | 45 | for(i=0;i> 15; 48 | tempI = ((q31_t) pSrcCmplx[2*i+1] * pSrcReal[i]) >> 15; 49 | pCmplxDst[2*i+0] = ref_sat_q15(tempR); 50 | pCmplxDst[2*i+1] = ref_sat_q15(tempI); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/ControllerFunctions/sin_cos.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_sin_cos_f32( 4 | float32_t theta, 5 | float32_t * pSinVal, 6 | float32_t * pCosVal) 7 | { 8 | //theta is given in degrees 9 | *pSinVal = sinf(theta * 6.28318530717959f / 360.0f); 10 | *pCosVal = cosf(theta * 6.28318530717959f / 360.0f); 11 | } 12 | 13 | void ref_sin_cos_q31( 14 | q31_t theta, 15 | q31_t * pSinVal, 16 | q31_t * pCosVal) 17 | { 18 | //theta is given in the range [-1,1) to represent [-pi,pi) 19 | *pSinVal = (q31_t)(sinf((float32_t)theta * 3.14159265358979f / 2147483648.0f) * 2147483648.0f); 20 | *pCosVal = (q31_t)(cosf((float32_t)theta * 3.14159265358979f / 2147483648.0f) * 2147483648.0f); 21 | } 22 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/FastMathFunctions/cos.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | q31_t ref_cos_q31(q31_t x) 4 | { 5 | return (q31_t)(cosf((float32_t)x * 6.28318530717959f / 2147483648.0f) * 2147483648.0f); 6 | } 7 | 8 | q15_t ref_cos_q15(q15_t x) 9 | { 10 | return (q15_t)(cosf((float32_t)x * 6.28318530717959f / 32768.0f) * 32768.0f); 11 | } 12 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/FastMathFunctions/sin.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | q31_t ref_sin_q31(q31_t x) 4 | { 5 | return (q31_t)(sinf((float32_t)x * 6.28318530717959f / 2147483648.0f) * 2147483648.0f); 6 | } 7 | 8 | q15_t ref_sin_q15(q15_t x) 9 | { 10 | return (q15_t)(sinf((float32_t)x * 6.28318530717959f / 32768.0f) * 32768.0f); 11 | } 12 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/FastMathFunctions/sqrt.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | arm_status ref_sqrt_q31(q31_t in, q31_t * pOut) 4 | { 5 | *pOut = (q31_t)(sqrtf((float32_t)in / 2147483648.0f) * 2147483648.0f); 6 | 7 | return ARM_MATH_SUCCESS; 8 | } 9 | 10 | arm_status ref_sqrt_q15(q15_t in, q15_t * pOut) 11 | { 12 | *pOut = (q15_t)(sqrtf((float32_t)in / 32768.0f) * 32768.0f); 13 | 14 | return ARM_MATH_SUCCESS; 15 | } 16 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/MatrixFunctions/mat_inverse.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | arm_status ref_mat_inverse_f32( 4 | const arm_matrix_instance_f32 * pSrc, 5 | arm_matrix_instance_f32 * pDst) 6 | { 7 | float32_t det; 8 | uint32_t i, size; 9 | arm_matrix_instance_f32 tmp; 10 | 11 | tmp.numCols = pSrc->numCols; 12 | tmp.numRows = pSrc->numRows; 13 | tmp.pData = scratchArray; 14 | 15 | det = ref_detrm(pSrc->pData,scratchArray,pSrc->numCols); 16 | 17 | size = pSrc->numCols * pSrc->numCols; 18 | 19 | ref_cofact(pSrc->pData,scratchArray,scratchArray + size,pSrc->numCols); 20 | 21 | ref_mat_trans_f32(&tmp,pDst); 22 | 23 | for(i=0;ipData[i] /= det; 26 | } 27 | 28 | return ARM_MATH_SUCCESS; 29 | } 30 | 31 | arm_status ref_mat_inverse_f64( 32 | const arm_matrix_instance_f64 * pSrc, 33 | arm_matrix_instance_f64 * pDst) 34 | { 35 | float64_t det; 36 | uint32_t i, size; 37 | arm_matrix_instance_f64 tmp; 38 | 39 | tmp.numCols = pSrc->numCols; 40 | tmp.numRows = pSrc->numRows; 41 | tmp.pData = (float64_t*)scratchArray; 42 | 43 | det = ref_detrm64(pSrc->pData,(float64_t*)scratchArray,pSrc->numCols); 44 | 45 | size = pSrc->numCols * pSrc->numCols; 46 | 47 | ref_cofact64(pSrc->pData,(float64_t*)scratchArray,(float64_t*)scratchArray + size,pSrc->numCols); 48 | 49 | ref_mat_trans_f64(&tmp,pDst); 50 | 51 | for(i=0;ipData[i] /= det; 54 | } 55 | 56 | return ARM_MATH_SUCCESS; 57 | } 58 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/MatrixFunctions/mat_trans.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | arm_status ref_mat_trans_f64( 4 | const arm_matrix_instance_f64 * pSrc, 5 | arm_matrix_instance_f64 * pDst) 6 | { 7 | uint64_t r,c; 8 | uint64_t numR = pSrc->numRows; 9 | uint64_t numC = pSrc->numCols; 10 | 11 | for(r=0;rpData[c*numR + r] = pSrc->pData[r*numC + c]; 16 | } 17 | } 18 | 19 | return ARM_MATH_SUCCESS; 20 | } 21 | 22 | arm_status ref_mat_trans_f32( 23 | const arm_matrix_instance_f32 * pSrc, 24 | arm_matrix_instance_f32 * pDst) 25 | { 26 | uint32_t r,c; 27 | uint32_t numR = pSrc->numRows; 28 | uint32_t numC = pSrc->numCols; 29 | 30 | for(r=0;rpData[c*numR + r] = pSrc->pData[r*numC + c]; 35 | } 36 | } 37 | 38 | return ARM_MATH_SUCCESS; 39 | } 40 | 41 | arm_status ref_mat_trans_q31( 42 | const arm_matrix_instance_q31 * pSrc, 43 | arm_matrix_instance_q31 * pDst) 44 | { 45 | uint32_t r,c; 46 | uint32_t numR = pSrc->numRows; 47 | uint32_t numC = pSrc->numCols; 48 | 49 | for(r=0;rpData[c*numR + r] = pSrc->pData[r*numC + c]; 54 | } 55 | } 56 | 57 | return ARM_MATH_SUCCESS; 58 | } 59 | 60 | arm_status ref_mat_trans_q15( 61 | const arm_matrix_instance_q15 * pSrc, 62 | arm_matrix_instance_q15 * pDst) 63 | { 64 | uint32_t r,c; 65 | uint32_t numR = pSrc->numRows; 66 | uint32_t numC = pSrc->numCols; 67 | 68 | for(r=0;rpData[c*numR + r] = pSrc->pData[r*numC + c]; 73 | } 74 | } 75 | 76 | return ARM_MATH_SUCCESS; 77 | } 78 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/StatisticsFunctions/max.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_max_f32( 4 | float32_t * pSrc, 5 | uint32_t blockSize, 6 | float32_t * pResult, 7 | uint32_t * pIndex) 8 | { 9 | uint32_t i, ind=0; 10 | float32_t max=-FLT_MAX; 11 | 12 | for(i=0;i pSrc[i]) 15 | { 16 | min = pSrc[i]; 17 | ind = i; 18 | } 19 | } 20 | *pResult = min; 21 | *pIndex = ind; 22 | } 23 | 24 | void ref_min_q31( 25 | q31_t * pSrc, 26 | uint32_t blockSize, 27 | q31_t * pResult, 28 | uint32_t * pIndex) 29 | { 30 | uint32_t i, ind=0; 31 | q31_t min=INT_MAX; 32 | 33 | for(i=0;i pSrc[i]) 36 | { 37 | min = pSrc[i]; 38 | ind = i; 39 | } 40 | } 41 | *pResult = min; 42 | *pIndex = ind; 43 | } 44 | 45 | void ref_min_q15( 46 | q15_t * pSrc, 47 | uint32_t blockSize, 48 | q15_t * pResult, 49 | uint32_t * pIndex) 50 | { 51 | uint32_t i, ind=0; 52 | q15_t min=SHRT_MAX; 53 | 54 | for(i=0;i pSrc[i]) 57 | { 58 | min = pSrc[i]; 59 | ind = i; 60 | } 61 | } 62 | *pResult = min; 63 | *pIndex = ind; 64 | } 65 | 66 | void ref_min_q7( 67 | q7_t * pSrc, 68 | uint32_t blockSize, 69 | q7_t * pResult, 70 | uint32_t * pIndex) 71 | { 72 | uint32_t i, ind=0; 73 | q7_t min=SCHAR_MAX; 74 | 75 | for(i=0;i pSrc[i]) 78 | { 79 | min = pSrc[i]; 80 | ind = i; 81 | } 82 | } 83 | *pResult = min; 84 | *pIndex = ind; 85 | } 86 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/StatisticsFunctions/power.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_power_f32( 4 | float32_t * pSrc, 5 | uint32_t blockSize, 6 | float32_t * pResult) 7 | { 8 | uint32_t i; 9 | float32_t sumsq=0; 10 | 11 | for(i=0;i> 14; 29 | } 30 | *pResult = sumsq; 31 | } 32 | 33 | void ref_power_q15( 34 | q15_t * pSrc, 35 | uint32_t blockSize, 36 | q63_t * pResult) 37 | { 38 | uint32_t i; 39 | q63_t sumsq=0; 40 | 41 | for(i=0;i> 31; 35 | tmp2 = ref_sat_q31(tmp1); 36 | 37 | /* GCC M0 problem: __aeabi_f2iz(QNAN) returns not 0 */ 38 | help_float = (sqrtf((float)tmp2 / 2147483648.0f) * 2147483648.0f); 39 | /* Checking for a NAN value in help_float */ 40 | if (((*((int *)(&help_float))) & 0x7FC00000) == 0x7FC00000) { 41 | help_float = 0; 42 | } 43 | *pResult = (q31_t)(help_float); 44 | 45 | // *pResult = (q31_t)(sqrtf((float)tmp2 / 2147483648.0f) * 2147483648.0f); 46 | } 47 | 48 | void ref_rms_q15( 49 | q15_t * pSrc, 50 | uint32_t blockSize, 51 | q15_t * pResult) 52 | { 53 | uint32_t i; 54 | q63_t sumsq=0; 55 | q31_t tmp1; 56 | q15_t tmp2; 57 | 58 | for(i=0;i> 15; 63 | tmp2 = ref_sat_q15(tmp1); 64 | *pResult = (q15_t)(sqrtf((float)tmp2 / 32768.0f) * 32768.0f); 65 | } 66 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/StatisticsFunctions/std.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_std_f32( 4 | float32_t * pSrc, 5 | uint32_t blockSize, 6 | float32_t * pResult) 7 | { 8 | uint32_t i; 9 | float32_t sum=0, sumsq=0; 10 | 11 | if (blockSize == 1) 12 | { 13 | *pResult = 0; 14 | return; 15 | } 16 | 17 | for(i=0;i> 8; 43 | sum += in; 44 | sumsq += (q63_t)in * in; 45 | } 46 | sumsq /= (q63_t)(blockSize - 1); 47 | sum = sum * sum / (q63_t)(blockSize * (blockSize - 1)); 48 | *pResult = (q31_t)(sqrtf((float)( (sumsq - sum) >> 15) / 2147483648.0f ) * 2147483648.0f); 49 | } 50 | 51 | void ref_std_q15( 52 | q15_t * pSrc, 53 | uint32_t blockSize, 54 | q15_t * pResult) 55 | { 56 | uint32_t i; 57 | q31_t sum=0; 58 | q63_t sumsq=0; 59 | 60 | if (blockSize == 1) 61 | { 62 | *pResult = 0; 63 | return; 64 | } 65 | 66 | for(i=0;i> 15) / 32768.0f ) * 32768.0f); 74 | } 75 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/StatisticsFunctions/var.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_var_f32( 4 | float32_t * pSrc, 5 | uint32_t blockSize, 6 | float32_t * pResult) 7 | { 8 | uint32_t i; 9 | float32_t sum=0, sumsq=0; 10 | 11 | if (blockSize == 1) 12 | { 13 | *pResult = 0; 14 | return; 15 | } 16 | 17 | for(i=0;i> 8; 43 | sum += in; 44 | sumsq += (q63_t)in * in; 45 | } 46 | *pResult = (sumsq - sum * sum / (q31_t)blockSize) / ((q31_t)blockSize - 1) >> 15; 47 | } 48 | 49 | void ref_var_q15( 50 | q15_t * pSrc, 51 | uint32_t blockSize, 52 | q15_t * pResult) 53 | { 54 | uint32_t i; 55 | q31_t sum=0; 56 | q63_t sumsq=0; 57 | 58 | if (blockSize == 1) 59 | { 60 | *pResult = 0; 61 | return; 62 | } 63 | 64 | for(i=0;i> 15; 70 | } 71 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/SupportFunctions/copy.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | void ref_copy_f32( 4 | float32_t * pSrc, 5 | float32_t * pDst, 6 | uint32_t blockSize) 7 | { 8 | uint32_t i; 9 | 10 | for(i=0;i> 16; 13 | } 14 | } 15 | 16 | void ref_q31_to_q7( 17 | q31_t * pSrc, 18 | q7_t * pDst, 19 | uint32_t blockSize) 20 | { 21 | uint32_t i; 22 | 23 | for(i=0;i> 24; 26 | } 27 | } 28 | 29 | void ref_q15_to_q31( 30 | q15_t * pSrc, 31 | q31_t * pDst, 32 | uint32_t blockSize) 33 | { 34 | uint32_t i; 35 | 36 | for(i=0;i> 8; 52 | } 53 | } 54 | 55 | void ref_q7_to_q31( 56 | q7_t * pSrc, 57 | q31_t * pDst, 58 | uint32_t blockSize) 59 | { 60 | uint32_t i; 61 | 62 | for(i=0;i 0.0f ? 0.5f : -0.5f; //round 16 | pDst[i] = ref_sat_q31((q63_t)in); //cast and saturate 17 | } 18 | } 19 | 20 | void ref_float_to_q15( 21 | float32_t * pSrc, 22 | q15_t * pDst, 23 | uint32_t blockSize) 24 | { 25 | uint32_t i; 26 | float32_t in; 27 | 28 | for(i=0;i 0.0f ? 0.5f : -0.5f; 33 | pDst[i] = ref_sat_q15((q31_t)in); 34 | } 35 | } 36 | 37 | void ref_float_to_q7( 38 | float32_t * pSrc, 39 | q7_t * pDst, 40 | uint32_t blockSize) 41 | { 42 | uint32_t i; 43 | float32_t in; 44 | 45 | for(i=0;i 0.0f ? 0.5f : -0.5f; 50 | pDst[i] = ref_sat_q7((q15_t)in); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /Drivers/CMSIS/DSP/DSP_Lib_TestSuite/RefLibs/src/TransformFunctions/bitreversal.c: -------------------------------------------------------------------------------- 1 | #include "ref.h" 2 | 3 | 4 | ;/* 5 | ;* @brief In-place bit reversal function. 6 | ;* @param[in, out] *pSrc points to the in-place buffer of unknown 32-bit data type. 7 | ;* @param[in] bitRevLen bit reversal table length 8 | ;* @param[in] *pBitRevTab points to bit reversal table. 9 | ;* @return none. 10 | ;*/ 11 | void arm_bitreversal_32(uint32_t *pSrc, uint32_t bitRevLen, uint32_t *pBitRevTab) 12 | { 13 | uint32_t a,b,i,tmp; 14 | 15 | for(i=0; i