Upload
dwivedi89
View
230
Download
0
Embed Size (px)
Citation preview
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
1/14
Designing Multirate Filter Systems in FPGAs Using
Synthesizable MATLAB
Multirate filters provide a practical approach to designing and implementing finite response
(FIR) filters with narrow spectral constraints. By changing the input data rate at one or more
intermediate points the filter lengths and computational rates can be greatly reduced when
compared to a standard single-rate filter implementation. With this technique, the sampling
frequency is first decreased and the actual FIR filter is implemented at the lower sampling
frequency, which considerably reduces the complexity of the filter.
Multirate filter designs can be easily modeled and analyzed using MATLAB and the Filter
Design Toolbox. Once an acceptable response has been designed the behavioral model can
be quickly converted into a synthesizable model and implemented on an FPGA usingAccelChip DSP Synthesis and AccelWare IP Cores. This design flow marries the efficiency
and ease-of-use offered by MATLAB with the processing power of a DSP-savvy FPGA, such as
a Xilinx Virtex 4 or an Altera Stratix II device.
Designing Multirate Filter Systems using Filter Design Toolbox
The Filter Design Toolbox provides an easy method to design and analyze behavioral
multirate filter models. It includes the following functions for designing: Polyphase
interpolators, Polyphase decimators, Polyphase sample-rate converters, CIC multirate filters,
and multistage-multirate filters. A list of the most common functions, referred to as the
"mfilt" functions, is provided below:
MultirateFilter
Description of Resulting MultirateFilter
mfilt.cicdecim Cascaded integrator-comb decimator
mfilt.cicinterp Cascaded integrator-comb interpolator
mfilt.firdecim Direct-form FIR polyphase decimator
mfilt.firinterp Direct-form FIR polyphase interpolator
mfilt.cascadeCascade one or more dfilt and mfilt
objects into a filter
fvtoolFilter Verification tool - displays
plots
polyphaseAnalyzes the response of a polyphase
filter
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
2/14
The following example shows how two simple polyphase decimation filters can be created and
analyzed using the "fvtool()" function. The first filter is a low-pass FIR filter.
% Create coefficients for a 21 tap low-pass FIR filter using "firceqrip"
Fs = 1.083332e6; % Sampling frequency
N = 20; % 21 taps
Apass = 5.7565e-4; % 0.01 dB
Astop = 0.01; % 40 dB
Fpass = 80e3/(Fs/2); % 80 kHz passband-edge frequency
cfir = firceqrip(N,Fpass,[Apass,Astop]);
% Use the "cfir" coefficients to create a polyphase decimation by 2 filter
h1 = mfilt.firdecim(2,cfir);
The second filter, an equiripple FIR filter, is created in a similar manner.
% Create coefficients for a 63 tap lowpass filter using "firgr
N = 62; % 63 taps
Fs = 541666; % 541.666 kHz
F = [0 80e3 100e3 Fs/2]/(Fs/2);
A = [1 1 0 0];
pfir = firgr(N,F,A);
% Use the "pfir" coefficients to create a polyphase decimation by 2 filter
h2 = mfilt.firdecim(2,pfir)
We can analyze both filters simultaneously using the "fvtool" function from MATLAB. Figure
1 shows the magnitude for each filter superimposed onto a single plot.
fvtool(h1,h2)
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
3/14
Figure 1 - fvtool plot of the polyphase filters
The filter design toolbox provides an easy means to cascade multiple decimation filters into a
multirate filter system as shown in Figure 2.
Figure 2 - Block Diagram of Cascaded Decimation FIR Filters
This can be accomplished using the "mfilt.cascade" function as shown below:
h3 = mfilt.cascade(h1,h2);
fvtool(h3);
The new magnitude response, which represents the combined effect of the two decimation
filters is shown in Figure 3.
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
4/14
Figure 3 - Plot of cascaded system of polyphase filters
This simple example highlights the ease-of-use from which a multirate filter system can be
modeled and refined using MATLAB. These concepts can be easily extended to include CIC
filters and re-sampling data rates.
Creating a Synthesizable MATLAB Model of a Multirate Filter System
Converting a behavioral model of a multirate filter system into a synthesizable model is a 3
step process:
1. Replace the analysis performed by the "fvtool" function with use- defined input datathat is filtered and analyzed explicitly.
2. Create a streaming loop and design function call.3. Create a synthesizable design function using AccelWare.
In our previous example, the filter analysis function "fvtool()" performs an ideal analysis of
the filter based on a predetermined set of filter input data such as impulse or random data.
When targeting hardware a set of actual input test vectors will need to be generated and
processed through the filter. MATLAB provides a function called "filter()" that can be used to
run these user-defined input vectors through a filter object created using the Filter Design
Toolbox "mfilt" functions.
The following example shows how analysis performed with the "fvtool" function can besubstituted with analysis performed using a generated data set. The input data is generated
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
5/14
using the "rand" function, filtered using the "filter" function and analyzed by plotting the
power spectral density of the filtered output.
% Create coefficients for a 21 tap low-pass FIR filter using "firceqrip"
Fs = 1.083332e6; % Sampling frequency
N = 20; % 21 taps
Apass = 5.7565e-4; % 0.01 dB
Astop = 0.01; % 40 dB
Fpass = 80e3/(Fs/2); % 80 kHz passband-edge frequency
cfir = firceqrip(N,Fpass,[Apass,Astop]);
% Use the "cfir" coefficients to create a polyphase decimation by 2 filter
h1 = mfilt.firdecim(2,cfir);
% Create coefficients for a 63 tap lowpass filter using "firgr"N = 62; % 63 taps
Fs = 541666; % 541.666 kHz
F = [0 80e3 100e3 Fs/2]/(Fs/2);
A = [1 1 0 0];
pfir = firgr(N,F,A);
% Use the "pfir" coefficients to create a polyphase decimation by 2 filter
h2 = mfilt.firdecim(2,pfir);
% Combine the two polyphase decimation filters into a multirate filter
system
h3 = mfilt.cascade(h1,h2);
% Analyze the combined filter response using "fvtool"
fvtool(h3)
% Generate the input samples using "rand".
rand('seed',0);
FilterIn = (rand(1,1024)-0.5)*2*sqrt(12);
% Filter the input data
FilterOut = filter(h3,FilterIn);
% Calculate the power spectral density of the filtered outputs
[Pout,Wout]=aw_psd(FilterOut,256,0.5);
% Superimpose the magnitude response onto the "fvtool" plot
hold on
plot(Wout,10*log10(Pout),'r',);
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
6/14
The plot below shows the magnitude response of the filtered data superimposed onto the plot
generated by "fvtool." Because the filter system has a total decimation of 4, only 1/4th of the
power spectrum is displayed.
Figure 4 - Filtered data superimposed on ideal magnitude response
Creating the Design Function Call and Streaming Loop
The synthesizable MATLAB coding style dictates that code, to be implemented in hardware, is
separated into a function called the "design function." This function is then placed inside a
loop called the "streaming loop."
Filters implemented on an FPGA or ASIC are generally implemented in a streaming fashion
where the input samples are applied to the filter one at a time. This behavior needs to be
defined in the streaming loop as shown in the example below. Decimation multirate systems
are accomplished in AccelChip by running the hardware at the highest clock rate and
selectively ignoring output samples. Likewise interpolation multirate systems are
accomplished by again running the hardware at the highest clock frequency and selectively
ignoring input samples. In the example below the streaming loop represents the highest
frequency of the multirate system prior to decimation.
Note that the original use of the "filter" function is now being used to generate golden data
that can be used as a reference. This is a useful technique for monitoring the functionality and
quantization error as we convert the synthesizable filter model to fixed-point.
% Save the behavioral filter results for reference
GoldenData = filter(h3,FilterInput);
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
7/14
% Create a streaming loop for the filter
for I = 1:length(FilterInput)
Data(i) = synth_multrate_filter(FilterInput(i));
end
% Compare to the reference data
plot(GoldenData-Data);
Creating a Synthesizable Multirate Filter System Model
When creating the design function, the simplest approach is to use synthesizable
AccelWare MATLAB models for the decimation filters. AccelWare offers over 50
parameterizable IP cores that are functionally equivalent replacements for MATLAB toolbox
and built-in functions. The table below summarizes the AccelWare multirate filters and their
functionally equivalent MATLAB counterpart.
Filter ToolboxFunction
AccelWareFunction Description
mfilt.cicdecim cicdecimateCascaded integrator-comb
decimator
mfilt.cicinterp cicinterpolateCascaded integrator-comb
interpolator
mfilt.firdecim firdecimDirect-form FIR polyphase
decimator
mfilt.firinterp firinterpolDirect-form FIR polyphase
interpolator
filter filter Direct-form FIR filter
In our previous example, AccelWare "firdecim" functions will need to be generated for the
"cfir" and "pfir" decimation by two filters.
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
8/14
Figure 5 - AccelWare Generation of Polyphase Decimation Filters
Once generated these functions must then be instantiated into the design function. To
simplify the process of modeling hardware a "valid" signal is provided, as part of the
AccelWare decimation filter, to indicate when a valid "downsampled" output is available. The
following MATLAB example shows how these models are instantiated.
Design Function
function [Fout2,Fvalid2] = synth_multrate_filter(y)
% Decimation by 2
[FOut1, Fvalid1] = firdecim_001( y );
% Only clock in valid new data from firdecim_001 into firdecim_002
if Fvalid1 == 1
% Decimation by 2
[Fout2, Fvalid2] = firdecim_002( FOut1 );else
Fout2 = 0;
Fvalid2 = 0;
end
By outputting the second valid signal "Fvalid2" from the design function we can simplify the
capture of output samples in the top-level script file by adding some simple conditional
controls and an index counter to the streaming loop.
Top-Level Script File Fragment
% Save the behavioral filter results for reference
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
9/14
GoldenData = filter(h3,FilterInput);
% Create a streaming loop for the filter
index = 1;
for I = 1:length(FilterInput)
[Databuf,Fvalid2] = synth_multrate_filter(FilterInput(i));
if Fvalid2 == 1
Data(index) = Databuf;
index = index+1;
end
end
% Calculate the power spectral density of the filter output
[Pout,Wout]=aw_psd(FilterOut,256,0.5);
If we simulate this model we see that the magnitude response of the synthesizable filter is
similar. The AccelWare polyphase decimation filter modeled in fixed-point results in a small
amount of quantization error.
Figure 6 - Synthesizable Filter Magnitude Response
Summary
The Filter Design Toolbox "mfilt" function provides a straightforward method for designing a
multirate filter response. AccelChip provides functionally equivalent AccelWare IP cores that
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
10/14
can be used to quickly create a version of the multirate filter system MATLAB model suitable
for hardware. Adopting a MATLAB-based hardware design flow is efficient, minimizes design
environments and facilitates the use of the behavioral models as a golden reference.
References
[1] Ricardo A. Losada, "Practical FIR Filter Design in MATLAB"
[2] Jerry Purcell, "Multirate Filter Design"
[3] Ray Andraka, "High Performance Digital Down Converters", Xilinx XCELL
Appendix A - Multirate Decimation Filter System Design Example
Top-Level Script File
% Create a 21 tap low-pass FIR filter using "firceqrip"
Fs = 1.083332e6; % Sampling frequencyN = 20; % 21 taps
Apass = 5.7565e-4; % 0.01 dB
Astop = 0.01; % 40 dB
Fpass = 80e3/(Fs/2); % 80 kHz passband-edge frequency
cfir = firceqrip(N,Fpass,[Apass,Astop]);
save cfir.txt -ascii -double cfir
%Decimate the filter by 2
h1 = mfilt.firdecim(2,cfir);
% Create a 63 simple equiripple lowpass filter using "firgr"
N = 62; % 63 taps
Fs = 541666; % 541.666 kHz
F = [0 80e3 100e3 Fs/2]/(Fs/2);
A = [1 1 0 0];
pfir = firgr(N,F,A);
save pfir.txt -ascii -double pfir
% Decimate the filter by 2
h2 = mfilt.firdecim(2,pfir);
% Combine the two previous decimation filters in series using "cascade"
h3 = mfilt.cascade(h1,h2);
% Analyze the filter response using "fvtool"
fvtool(h3)
% Generate the input samples using "rand".
rand('seed',0);FilterIn = (rand(1,1024)-0.5)*2*sqrt(12);
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
11/14
% Filter the input data
FilterOut_reference = filter(h3,FilterIn);
index = 1;
for i = 1:length(FilterIn)
[outbuf,valid] = synth_multrate_filter(FilterIn(i));
if valid == 1
FilterOut(index) = outbuf;
index = index+1;
end
end
% Analyze the magnitude response of the results and add to fvtool plot
hold on[Pout,Wout]=aw_psd(FilterOut,256,0.5);
plot(Wout,10*log10(Pout),'r');
Design Function
function [Fout2,Fvalid2] = synth_multrate_filter(y)
% Decimation by 2
[FOut1, Fvalid1] = firdecim_001( y );
% Only clock in valid new data from firdecim_001 into firdecim_002
if Fvalid1 == 1
% Decimation by 2
[Fout2, Fvalid2] = firdecim_002( FOut1 );
else
Fout2 = 0;
Fvalid2 = 0;
end
Appendix B - Digital Down Converter Example
This second design example provides a MATLAB example of a three-stage decimator that is
used in a digital down converter.
Figure 7 - 3-stage DDC Decimation Filter
Behavioral MATLAB Model
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
12/14
% Design CIC Decimation by 64 filter
Hcic = mfilt.cicdecim(64,1,5);
% Normalize the gain of the CIC filter
Hscalar = dfilt.scalar(1/gain(Hcic));
Hcicnorm = cascade(Hscalar,Hcic);
% Design decimation by 2 polyphase filter
Fs = 1.083332e6; % Sampling frequency
N = 20; % 21 taps
Npow = 5; % Sinc power
w = 0.5; % Sinc frequency factor
Apass = 5.7565e-4; % 0.01 dB
Astop = 0.01; % 40 dB
Aslope = 60; % 60 dB slopeFpass = 80e3/(Fs/2); % 80 kHz passband-edge frequency
cfir = firceqrip(N,Fpass,[Apass,Astop],'passedge','slope',Aslope,
cfirq = fi(cfir,true,16);
Hcfir = mfilt.firdecim(2,double(cfirq));
% Design decimation by 2 polyphase filter
N = 62; % 63 taps
Fs = 541666; % 541.666 kHz
F = [0 80e3 100e3 Fs/2]/(Fs/2);
A = [1 1 0 0];
W = [5 1]; % Weight the passband 5 times more than the stopband
pfir = firgr(N,F,A,W);
pfirq = fi(pfir,true,16);
Hpfir = mfilt.firdecim(2,double(pfirq));
% Cascade the 3 filters to create the multirate filter system
H3stage = cascade(Hcicnorm,Hcfir,Hpfir);
% Plot the Response[Hf3stage,f] = freqz(H3stage,0:200:1e6,69.333248e6);
plot(f*1e-3,20*log10(abs(Hf3stage)))
grid on; title('Magnitude Response');
xlabel('Frequency (kHz)'); ylabel('Magnitude (dB)');
drawgsmmask
legend('Response of all three stages','GSM spectral mask requirement');
set(gcf, 'Color', [1 1 1]);
% Saving filter coefficients to a text file to use with AccelWare IP core
save coeff_pfir.txt -ascii -double pfir;
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
13/14
save coeffs_cfir.txt -ascii -double cfir;
Synthesizable MATLAB Top-Level Script File
This model shows the design function "gsm_ddc" was created and instantiated in a streaming
loop. Also shown is an input data vector that is created using random numbers, filtered and
analyzed. The analysis function "aw_psd" will return the power spectral density. This file is
provided by AccelChip. A similar function is available from The MathWorks called
'dspdata.dsp."
NUM_OUTPUT_SAMPLES = 1024; %Set number of input sample to simulate
rand('seed',0);
DecRate = 64*2*2;
Fs = 69.333248;
% create random, uniformly distributed input
CICDecimInput = (rand(1,NUM_OUTPUT_SAMPLES*DecRate)-0.5);
data_out = zeros(1,256);
count = 1;
for n = 1:(NUM_OUTPUT_SAMPLES*DecRate)
[data_outb,Data_Valid]=gsm_ddc(CICDecimInput(n));
if Data_Valid == 1data_out(count) = data_outb;
count = count + 1;
end
end
% plot input power spectrum
[Pin,Win] = aw_psd(CICDecimInput*sqrt(12),1024,Fs);
figure;subplot(2,1,1);plot(Win,10*log10(Pin));grid on; hold; title('Input
PSD');
xlabel('MHz');ylabel('dB');axis([Win(1) Win(end) -60 10]);
% plot output power spectrum
[Pout,Hout]=aw_psd(data_out*sqrt(12*DecRate),256,Fs/DecRate);
subplot(2,1,2);plot(Hout,10*log10(Pout), 'r'); grid on; title(
xlabel('MHz');ylabel('dB');axis([Hout(1) Hout(end) -60 10]);
Synthesizable MATLAB Design Function
7/27/2019 Designing Multirate Filter Systems in FPGAs Using Synthesizable MATLAB
14/14
This synthesizable design function uses a CIC decimation filter and two polyphase decimation
filters generated using the AccelWare IP core generator. Generating these filters required, as
an input, the coefficients text files saved as part of the behavioral simulation.
function [data_out, pfir_Valid] = gsm_ddc(data_in)
% Normalize the input data into the CIC
data_in_integer = data_in*2^10;
% Perform the CIC Integration Filter
[cic_out,cic_Valid] = cicdecimate_001(data_in_integer);
% Normalize the CIC filter output to compensate for the gain
cic_out_norm = cic_out * 1/(2^40);
% Second Stageif cic_Valid == 1
[cfir_out, cfir_Valid] = firdecim_001(cic_out_norm);
else
cfir_Valid = 0;
end
% Third Stage
if cfir_Valid == 1
[pfir_out, pfir_Valid] = firdecim_002(cfir_out);
else
pfir_Valid = 0;
end
% Mux the output for valid samples
if pfir_Valid == 1
data_out = pfir_out;
else
data_out = 0;
end