<< Chapter < Page | Chapter >> Page > |
Does the output match your expectations based on the theory? Does this application illustrate any limitations of the FFT implementation?(Hint: note that most of the values in the FFT input are zero.) The previously-given C implementation uses a similar algorithm as theTI FFT; take a look at the C code for help. What are the limitation(s) of the FFT that show up in this application?
In
lab4b.h
M
sets the number of
autocorrelation points that are calculated. What is the maximum valueof
M
that allows the reference routines to run in real
time? In determining this value you may find it useful to connect awave-function generator to the input and copy
inputs
into
display_inputs
. You may limit
M
to
powers of
2
minus
1
.
From your prelab experiments, you should be able to describe
the effect of windowing and zero-padding on FFT spectralanalysis. In your DSP system, experiment with different
inputs, changing
$N$ and the type of window. Can you explain what happens
as the input frequency is increased beyond the Nyquist rate? Does the
$\left|X(k)\right|^{2}$ coincide with what you expect from Matlab? What is
the relationship between the observed spectrum and the DTFT?What would happen if the FFT calculation takes longer than it
takes to fill
inputs
with
$N$ samples? How long does it take to compute each FFT?
What are the tradeoffs between writing code in C versus assembly?
1 /* v:/ece420/54x/dspclib/lab4main.c */
2 /* dgs - 9/14/2001 */
3 /* mdk - 2/10/2004 C FFT update */
4
5 #include "v:/ece420/54x/dspclib/core.h"
6
7 /* comment the next line to use assembly fft */
8 #define C_FFT
9
10 #ifdef C_FFT /* Use C FFT */
11
12 #include "window.h"
13 #include "lab4.h" /* Number of C FFT points defined here */
14
15 /* function defined in lab4fft.c */
16 void fft(void);
17
18 /* FFT data buffers */
19 int real[N]; /* Real part of data */
20 int imag[N]; /* Imaginary part of data */
21
22 #else /* Use assembly FFT */
23
24 #define N 1024 /* Number of assembly FFT points */
25
26 /* Function defined by c_fft_given.asm */
27 void bit_rev_fft(void);
28
29 /* FFT data buffers (declared in c_fft_given.asm) */
30 extern int bit_rev_data[N*2]; /* Data input for bit-reverse function */
31 extern int fft_data[N*2]; /* In-place FFT & Output array */
32 extern int window[N]; /* The Hamming window */
33
34 #endif /* C_FFT */
35
36
37 /* Our input/output buffers */
38 int inputs[N];
39 int outputs[N];
40
41 volatile int input_full = 0; /* volatile means interrupt changes it */
42 int count = 0;
43
44
45 interrupt void irq(void)
46 {
47 int *Xmitptr,*Rcvptr; /* pointers to Xmit & Rcv Bufs */
48 int i;
49
50 static int in_irq = 0; /* Flag to prevent reentrance */
51
52 /* Make sure we're not in the interrupt (should never happen) */
53 if( in_irq )
54 return;
55
56 /* Mark we're processing, and enable interrupts */
57 in_irq = 1;
58 enable_irq();
59
60 /* The following waitaudio call is guaranteed not to
61 actually wait; it will simply return the pointers. */
62 WaitAudio(&Rcvptr,&Xmitptr);
63
64 /* input_full should never be true... */
65 if( !input_full )
66 {
67 for (i=0; i<BlockLen; i++)
68 {
69 /* Save input, and echo to channel 1 */
70 inputs[count] = Xmitptr[6*i] = Rcvptr[4*i];
71
72 /* Send FFT output to channel 2 */
73 Xmitptr[6*i+1] = outputs[count];
74
75 count++;
76 }
77 }
78
79 /* Have we collected enough data yet? */
80 if( count >= N )
81 input_full = 1;
82
83 /* We're not in the interrupt anymore... */
84 disable_irq();
85 in_irq = 0;
86 }
87
88
89 main()
90 {
91 /* Initialize IRQ stuff */
92 count = 0;
93 input_full = 0;
94 SetAudioInterrupt(irq); /* Set up interrupts */
95
96 while (1)
97 {
98 while( !input_full ); /* Wait for a data buffer to collect */
99
100 /* From here until we clear input_full can only take *
101 * BlockLen sample times, so don't do too much here. */
102
103 /* First, transfer inputs and outputs */
104
105 #ifdef C_FFT /* Use C FFT */
106 /* I n s e r t c o d e t o f i l l */
107 /* C F F T b u f f e r s */
108
109 #else /* Use assembly FFT */
110 /* I n s e r t c o d e t o f i l l */
111 /* a s s e m b l y F F T b u f f e r s */
112
113 #endif /* C_FFT */
114
115 /* Done with that... ready for new data collection */
116 count = 0; /* Need to reset the count */
117 input_full = 0; /* Mark we're ready to collect more data */
118
119 /**********************************************************/
120 /* Now that we've gotten the data moved, we can do the */
121 /* more lengthy processing. */
122
123 #ifdef C_FFT /* Use C FFT */
124
125 /* Multiply the input signal by the Hamming window. */
126 /* . . . i n s e r t C / a s m code . . . */
127
128 /* Bit-reverse and compute FFT in C */
129 fft();
130
131 /* Now, take absolute value squared of FFT */
132 /* . . . i n s e r t C / a s m code . . . */
133
134 /* Last, set the DC coefficient to -1 for a trigger pulse */
135 /* . . . i n s e r t C / a s m code . . . */
136
137 /* done, wait for next time around! */
138
139
140 #else /* Use assembly FFT */
141
142 /* Multiply the input signal by the Hamming window. */
143 /* . . . i n s e r t C / a s m code . . . */
144
145 /* Bit-reverse and compute FFT in assembly */
146 bit_rev_fft();
147
148 /* Now, take absolute value squared of FFT */
149 /* . . . i n s e r t C / a s m code . . . */
150
151 /* Last, set the DC coefficient to -1 for a trigger pulse */
152 /* . . . i n s e r t C / a s m code . . . */
153
154 /* done, wait for next time around! */
155
156
157 #endif /* C_FFT */
158
159 }
160 }
Notification Switch
Would you like to follow the 'Digital signal processing laboratory (ece 420)' conversation and receive update notifications?