1 /* ----------------------------------------------------------------------
2 * Copyright (C) 2010-2012 ARM Limited. All rights reserved.
3 *
4 * $Date: 17. January 2013
5 * $Revision: V1.4.0
6 *
7 * Project: CMSIS DSP Library
8 * Title: arm_convolution_example_f32.c
9 *
10 * Description: Example code demonstrating Convolution of two input signals using fft.
11 *
12 * Target Processor: Cortex-M4/Cortex-M3
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 * - Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * - Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in
21 * the documentation and/or other materials provided with the
22 * distribution.
23 * - Neither the name of ARM LIMITED nor the names of its contributors
24 * may be used to endorse or promote products derived from this
25 * software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
30 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
31 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
32 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
33 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
34 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
35 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
37 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38 * POSSIBILITY OF SUCH DAMAGE.
39 * -------------------------------------------------------------------- */
40
41 /**
42 * @addtogroup groupExamples
43 * @{
44 *
45 * @defgroup ConvolutionExample Convolution Example
46 *
47 * \par Description:
48 * \par
49 * Demonstrates the convolution theorem with the use of the Complex FFT, Complex-by-Complex
50 * Multiplication, and Support Functions.
51 *
52 * \par Algorithm:
53 * \par
54 * The convolution theorem states that convolution in the time domain corresponds to
55 * multiplication in the frequency domain. Therefore, the Fourier transform of the convoution of
56 * two signals is equal to the product of their individual Fourier transforms.
57 * The Fourier transform of a signal can be evaluated efficiently using the Fast Fourier Transform (FFT).
58 * \par
59 * Two input signals, <code>a[n]</code> and <code>b[n]</code>, with lengths \c n1 and \c n2 respectively,
60 * are zero padded so that their lengths become \c N, which is greater than or equal to <code>(n1+n2-1)</code>
61 * and is a power of 4 as FFT implementation is radix-4.
62 * The convolution of <code>a[n]</code> and <code>b[n]</code> is obtained by taking the FFT of the input
63 * signals, multiplying the Fourier transforms of the two signals, and taking the inverse FFT of
64 * the multiplied result.
65 * \par
66 * This is denoted by the following equations:
67 * <pre> A[k] = FFT(a[n],N)
68 * B[k] = FFT(b[n],N)
69 * conv(a[n], b[n]) = IFFT(A[k] * B[k], N)</pre>
70 * where <code>A[k]</code> and <code>B[k]</code> are the N-point FFTs of the signals <code>a[n]</code>
71 * and <code>b[n]</code> respectively.
72 * The length of the convolved signal is <code>(n1+n2-1)</code>.
73 *
74 * \par Block Diagram:
75 * \par
76 * \image html Convolution.gif
77 *
78 * \par Variables Description:
79 * \par
80 * \li \c testInputA_f32 points to the first input sequence
81 * \li \c srcALen length of the first input sequence
82 * \li \c testInputB_f32 points to the second input sequence
83 * \li \c srcBLen length of the second input sequence
84 * \li \c outLen length of convolution output sequence, <code>(srcALen + srcBLen - 1)</code>
85 * \li \c AxB points to the output array where the product of individual FFTs of inputs is stored.
86 *
87 * \par CMSIS DSP Software Library Functions Used:
88 * \par
89 * - arm_fill_f32()
90 * - arm_copy_f32()
91 * - arm_cfft_radix4_init_f32()
92 * - arm_cfft_radix4_f32()
93 * - arm_cmplx_mult_cmplx_f32()
94 *
95 * <b> Refer </b>
96 * \link arm_convolution_example_f32.c \endlink
97 *
98 * \example arm_convolution_example_f32.c
99 *
100 * @} */
101
102 #include "arm_math.h"
103 #include "math_helper.h"
104
105 #if defined(SEMIHOSTING)
106 #include <stdio.h>
107 #endif
108
109 /* ----------------------------------------------------------------------
110 * Defines each of the tests performed
111 * ------------------------------------------------------------------- */
112 #define MAX_BLOCKSIZE 128
113 #define DELTA (0.000001f)
114 #define SNR_THRESHOLD 90
115
116 /* ----------------------------------------------------------------------
117 * Declare I/O buffers
118 * ------------------------------------------------------------------- */
119 float32_t Ak[MAX_BLOCKSIZE]; /* Input A */
120 float32_t Bk[MAX_BLOCKSIZE]; /* Input B */
121 float32_t AxB[MAX_BLOCKSIZE * 2]; /* Output */
122
123 /* ----------------------------------------------------------------------
124 * Test input data for Floating point Convolution example for 32-blockSize
125 * Generated by the MATLAB randn() function
126 * ------------------------------------------------------------------- */
127 float32_t testInputA_f32[64] =
128 {
129 -0.808920, 1.357369, 1.180861, -0.504544, 1.762637, -0.703285,
130 1.696966, 0.620571, -0.151093, -0.100235, -0.872382, -0.403579,
131 -0.860749, -0.382648, -1.052338, 0.128113, -0.646269, 1.093377,
132 -2.209198, 0.471706, 0.408901, 1.266242, 0.598252, 1.176827,
133 -0.203421, 0.213596, -0.851964, -0.466958, 0.021841, -0.698938,
134 -0.604107, 0.461778, -0.318219, 0.942520, 0.577585, 0.417619,
135 0.614665, 0.563679, -1.295073, -0.764437, 0.952194, -0.859222,
136 -0.618554, -2.268542, -1.210592, 1.655853, -2.627219, -0.994249,
137 -1.374704, 0.343799, 0.025619, 1.227481, -0.708031, 0.069355,
138 -1.845228, -1.570886, 1.010668, -1.802084, 1.630088, 1.286090,
139 -0.161050, -0.940794, 0.367961, 0.291907
140
141 };
142
143 float32_t testInputB_f32[64] =
144 {
145 0.933724, 0.046881, 1.316470, 0.438345, 0.332682, 2.094885,
146 0.512081, 0.035546, 0.050894, -2.320371, 0.168711, -1.830493,
147 -0.444834, -1.003242, -0.531494, -1.365600, -0.155420, -0.757692,
148 -0.431880, -0.380021, 0.096243, -0.695835, 0.558850, -1.648962,
149 0.020369, -0.363630, 0.887146, 0.845503, -0.252864, -0.330397,
150 1.269131, -1.109295, -1.027876, 0.135940, 0.116721, -0.293399,
151 -1.349799, 0.166078, -0.802201, 0.369367, -0.964568, -2.266011,
152 0.465178, 0.651222, -0.325426, 0.320245, -0.784178, -0.579456,
153 0.093374, 0.604778, -0.048225, 0.376297, -0.394412, 0.578182,
154 -1.218141, -1.387326, 0.692462, -0.631297, 0.153137, -0.638952,
155 0.635474, -0.970468, 1.334057, -0.111370
156 };
157
158 const float testRefOutput_f32[127] =
159 {
160 -0.818943, 1.229484, -0.533664, 1.016604, 0.341875, -1.963656,
161 5.171476, 3.478033, 7.616361, 6.648384, 0.479069, 1.792012,
162 -1.295591, -7.447818, 0.315830, -10.657445, -2.483469, -6.524236,
163 -7.380591, -3.739005, -8.388957, 0.184147, -1.554888, 3.786508,
164 -1.684421, 5.400610, -1.578126, 7.403361, 8.315999, 2.080267,
165 11.077776, 2.749673, 7.138962, 2.748762, 0.660363, 0.981552,
166 1.442275, 0.552721, -2.576892, 4.703989, 0.989156, 8.759344,
167 -0.564825, -3.994680, 0.954710, -5.014144, 6.592329, 1.599488,
168 -13.979146, -0.391891, -4.453369, -2.311242, -2.948764, 1.761415,
169 -0.138322, 10.433007, -2.309103, 4.297153, 8.535523, 3.209462,
170 8.695819, 5.569919, 2.514304, 5.582029, 2.060199, 0.642280,
171 7.024616, 1.686615, -6.481756, 1.343084, -3.526451, 1.099073,
172 -2.965764, -0.173723, -4.111484, 6.528384, -6.965658, 1.726291,
173 1.535172, 11.023435, 2.338401, -4.690188, 1.298210, 3.943885,
174 8.407885, 5.168365, 0.684131, 1.559181, 1.859998, 2.852417,
175 8.574070, -6.369078, 6.023458, 11.837963, -6.027632, 4.469678,
176 -6.799093, -2.674048, 6.250367, -6.809971, -3.459360, 9.112410,
177 -2.711621, -1.336678, 1.564249, -1.564297, -1.296760, 8.904013,
178 -3.230109, 6.878013, -7.819823, 3.369909, -1.657410, -2.007358,
179 -4.112825, 1.370685, -3.420525, -6.276605, 3.244873, -3.352638,
180 1.545372, 0.902211, 0.197489, -1.408732, 0.523390, 0.348440, 0
181 };
182
183
184 /* ----------------------------------------------------------------------
185 * Declare Global variables
186 * ------------------------------------------------------------------- */
187 uint32_t srcALen = 64; /* Length of Input A */
188 uint32_t srcBLen = 64; /* Length of Input B */
189 uint32_t outLen; /* Length of convolution output */
190 float32_t snr; /* output SNR */
191
main(void)192 int32_t main(void)
193 {
194 arm_status status; /* Status of the example */
195 arm_cfft_radix4_instance_f32 cfft_instance; /* CFFT Structure instance */
196
197 #if defined(SEMIHOSTING)
198 printf("START\n");
199 #endif
200
201 /* CFFT Structure instance pointer */
202 arm_cfft_radix4_instance_f32 *cfft_instance_ptr =
203 (arm_cfft_radix4_instance_f32*) &cfft_instance;
204
205 /* output length of convolution */
206 outLen = srcALen + srcBLen - 1;
207
208 /* Initialise the fft input buffers with all zeros */
209 arm_fill_f32(0.0, Ak, MAX_BLOCKSIZE);
210 arm_fill_f32(0.0, Bk, MAX_BLOCKSIZE);
211
212 /* Copy the input values to the fft input buffers */
213 arm_copy_f32(testInputA_f32, Ak, MAX_BLOCKSIZE/2);
214 arm_copy_f32(testInputB_f32, Bk, MAX_BLOCKSIZE/2);
215
216 /* Initialize the CFFT function to compute 64 point fft */
217 status = arm_cfft_radix4_init_f32(cfft_instance_ptr, 64, 0, 1);
218
219 /* Transform input a[n] from time domain to frequency domain A[k] */
220 arm_cfft_radix4_f32(cfft_instance_ptr, Ak);
221 /* Transform input b[n] from time domain to frequency domain B[k] */
222 arm_cfft_radix4_f32(cfft_instance_ptr, Bk);
223
224 /* Complex Multiplication of the two input buffers in frequency domain */
225 arm_cmplx_mult_cmplx_f32(Ak, Bk, AxB, MAX_BLOCKSIZE/2);
226
227 /* Initialize the CIFFT function to compute 64 point ifft */
228 status = arm_cfft_radix4_init_f32(cfft_instance_ptr, 64, 1, 1);
229
230 /* Transform the multiplication output from frequency domain to time domain,
231 that gives the convolved output. */
232 arm_cfft_radix4_f32(cfft_instance_ptr, AxB);
233
234 /* SNR Calculation */
235 snr = arm_snr_f32((float32_t *)testRefOutput_f32, AxB, srcALen + srcBLen - 1);
236
237 /* Compare the SNR with threshold to test whether the
238 computed output is matched with the reference output values. */
239 status = (snr <= SNR_THRESHOLD) ? ARM_MATH_TEST_FAILURE : ARM_MATH_SUCCESS;
240
241 if (status != ARM_MATH_SUCCESS)
242 {
243 #if defined (SEMIHOSTING)
244 printf("FAILURE\n");
245 #else
246 while (1); /* main function does not return */
247 #endif
248 }
249 else
250 {
251 #if defined (SEMIHOSTING)
252 printf("SUCCESS\n");
253 #else
254 while (1); /* main function does not return */
255 #endif
256 }
257
258 }
259
260 /** \endlink */
261
