Lab 2: Designing a Low Pass Filter

Transcription

1 Lab 2: Designing a Low Pass Filter In this lab we will be using a low pass filter to filter the signal from an Infra Red (IR) sensor. The IR sensor will be connected to the Arduino and Matlab will be used to view and filter the signal. We use Matlab because it allows us to graph the data. This is very useful for optimizing the filter coefficients and for determining whether the filter is working properly. For your final project, you will likely not be using Matlab. However, using Matlab filters to optimize your Arduino filters during the design stage could be very helpful as you can see and compare the output easily. The purpose of a filter is to remove some unwanted component from a signal. In this lab, it will be used to remove high frequency noise from the IR signal we wish to analyze. The cut- off frequency is the boundary in a filter's response. Any frequencies outside the cut- off frequency range will be attenuated. Ideally the filter would completely eliminate any frequencies outside the cut- off frequency range. However, in reality, the attenuation depends on the order of the filter. Higher order filters attenuate the unwanted frequencies more effectively, but increase the lag (phase delay) between the input and output. The figure below shows various orders of low pass filters (order 1 to 5). Notice that the steepest attenuation is associated with the highest order filter. Figure 1- Low Pass Filters of various Orders You can either have an analog filter or a digital filter. As you might expect, analog filters are used for analog signals (continuous waveforms) and digital filters are used for digital (discrete) signals.

2 Analog filters are created from hardware components such as resistors, capacitors and inductors whereas digital filters are software based. You are likely more familiar with analog filters because of your Controls class. The steps for designing a digital filter are very similar to those for an analog filter. First, the desired filter response must be characterised and then the parameters calculated. For analog filters the parameters calculated are the resistor, capacitor and inductor values required to build the filter. For digital filters the parameters calculated are the coefficients used in the software implementation of the filter. Classes of Digital Filters Digital filters can be classified as follows: (a) Linear filters versus nonlinear filters. (b) Time- invariant filters versus time- varying filters. (c) Adaptive filters versus non- adaptive filters. (d) Recursive versus non- recursive filters. (e) Direct- form, cascade- form, parallel- form and lattice structures In this lab we will be using a recursive, linear time invariant (LTI) filter. This is a filter whose output is a linear combination of the input signals and the previous output signals. The filter coefficients do not vary with time. The formula below describes the most basic time domain input- output relationship for a first order, LTI, recursive filter. y(i)=α* y(i 1) + x(i) Where x(i) is the filter input (raw data), y(i) is the filter output(filtered signal), α is the filter coefficient, i is the current time step and y(i- 1) is the previous filter output. Characterising the Filter There are many methods used for characterizing a filter, but the most commonly used is the transfer function. Transfer functions are usually used to describe single- input single- output filters. The input signal goes through the transfer function and is converted into the desired output signal. See below. Input x(t), X(z) H(z) Output y(t), Y(z)

3 x(t) and y(t), usually denoted with lowercase x and y, are the time domain signals and X(z) and Y(z), usually denoted with uppercase X and Y, are the frequency domain signals. To define the transfer function, you must first convert the time domain signals into frequency domain using the Z- transform. The Z- transform is the equivalent of the Laplace Transform, but for digital instead of analog signals. Once the relationship between the input and output signals is defined in frequency domain, the transfer function, H(z), is simply the output, Y(z), over the input, X(z). The transfer function for a linear, time invariant, digital filter is defined as follows. H z = Y X = B(z) A(z) = b + + b - z.- + b 0 z b 2 z a - z.- + a 0 z a 5 z.5 Where H(z) is the transfer function in frequency domain (z) and the parameters to be determined are B(z) and A(z). B is a 1xN matrix of the numerator coefficients and A is a 1xM matrix of the denominator coefficients. So B = [b 0 b 1 b 2... b N ] and A = [ 1 a 1 a 2... a M ]. For the 1st order filter above the transfer function is as follows. This was derived using the Z- transform. 1 H(z) = 1 + αz.- Low Pass Filter The type of filter you require depends on which frequencies you want to attenuate. For example, a low pass filter passes low frequencies and attenuates the high frequencies (frequencies higher than the cutoff frequency). The time domain representation of a low pass, LTI, first order, recursive filter can be seen below: y 8 = αx 8 + (1 α)y 8.- Where x is the unfiltered data, y is the filtered data and α is the filter (smoothing) coefficient. The smoothing coefficient can be modified depending on the desired system response. For an in- depth explanation of low pass filters and the derivation of this equation, visit the low pass filter Wikipedia page: pass_filter Once the time domain equation is known, the Z- transform is used to get the equation in frequency domain so the transfer function can be determined. The Z- transformation is shown below.

4 y 8 = αx α y 8.- y 8 1 α y 8.- = αx 8 Y 1 α Y(z)z.- = αx Y 1 z.- + αz.- = αx Y X = α 1 z.- + αz.- The Transfer function can be written as: Therefore, the B and A matrices are: H z = B z A z = α 1 + (α 1)z.- B = α A = [ 1 (α- 1)] Just a few notes on how to do the Z- transformation (in case you were interested): constants stay the same y i = y(z) x i = x(z) y i- 1 = y(z)*z - 1 y i- 2 = y(z)*z Since digital filters are implemented in code, there are various ways you can program them. One is to use the filter functions built into Matlab. These functions require inputs of either the sampling frequency or the coefficients, A and B. Although you will likely not be using Matlab for your final project, it may be useful to use the Matlab filters to compare and optimize your Arduino filtering. This is why we will go over using the filter functions in Matlab Another way to implement the filter in code, is simply to use the time domain formula. This is the simplest way and is good for programming languages where there are no filter functions built in, like the Arduino. Time Domain Formula in Software In order to implement the low pass, LTI, first order filter in the code, you simply use the time domain function for the low pass filter from above. The formula below is the implementation of this filter in Matlab code. y(i) = a*x(i)+(1-a)*y(i-1);

5 Where y is an array of the filtered values and x is an array of the raw data. y(i) is the filtered data output and y(i- 1) is the previous filtered data output value. We will now use this formula to filter the input from an IR sensor. The Arduino code in Appendix A will read the IR sensor values and output the raw values to Matlab. Once we have the raw values we will filter and plot them in Matlab. The sample code to do this filtering is shown in Appendix B. This function reads the IR output from the Arduino and plots the raw and filtered data with respect to time. The time array is created using the 'tic' and 'toc' functions in Matlab. If a more precise counter is required, it should be done on the Arduino. The plots below show the un- filtered and filtered IR data for α =0.1 and α=0.01. Note that the smaller the α value, the smoother the data, but the larger the phase delay. Figure 2- Filtered Voltage(red) and Unfiltered voltage(blue) from IR sensor with alpha = 0.1

6 Figure 3- Filtered Voltage(red) and Unfiltered Voltage(blue) from IR sensor with alpha = 0.01 Notice that a value of α = 0.01, causes too much filtering and the output curve is excessively smoothed. You will need to find the optimal combination between eliminating noise, but still having a function that responds quickly to changes. This is done by trial and error. This is the most basic implementation of the low pass filter and is very useful if you do not have any built in filtering functions. However, Matlab does have built in filter functions. These functions require the coefficients (A and B), that were calculated above, as inputs to define the type of filter. We will only look at the filtfilt function in this lab, but there are lots of other types you can use. Matlab FiltFilt function If you notice, the filtered voltage above is shifted from the original voltage in both of the above graphs. This is due to the time required to process the filtering equation on the fly. In order to avoid this shift we can use the filtfilt function in matlab. The filtfilt function performs zero- phase shift digital filtering by processing the data in both the forward and reverse direction. However, since filtfilt needs to process the data both backwards and forwards, it needs to know all the data, meaning it cannot be used on the fly. You must first create an array of all the collected data, raw values, and then filter that array instead

7 of using the function on every data point individually as we did in the previous example. To learn more about the filtfilt function, type "help filtfilt" into the Matlab command line. The following line shows how to properly call the filtfilt function. Y = filtfilt(b,a,x); Where X and Y are the unfiltered and filtered data arrays respectively and B and A are the transfer function coefficients calculated above. The Matlab code below uses the filtfilt function to filter the IR data from above. %This function using filtfilt to low pass filter data(an array of values from the IR sensor). It then plots the filtered and unfiltered data. function IR_SENSOR_FILTFILT(obj) tic; i= 1; while toc < 10 time(i) = toc; voltage(i) = (obj.ard.analogread(2))*(5/1024); i = i+1; end a = 0.1; %sets the value of alpha filtered_data = filtfilt(a,[1 a-1],voltage); %uses filtfilt to filter the voltage data figure; plot(time,voltage,'b'); hold on; plot(time,filtered_data,'r'); xlabel('time'); ylabel('voltage'); end See the plot below for the output of the unfiltered (blue) and filtered data (red), found using the filtfilt function.

8 Figure 4- FiltFilt Filtered and Unfiltered voltage plot with alpha of 0.1 Note that in the plot, the filtered voltage is not offset from the original. Sometimes, depending on the type of filter, the offset will be linear so a formula can be used to shift all the data backwards. Unfortunatley, this is not the case for the simple low pass filter formula we used. This is why the zero phase shift of the filtfilt function is so useful however, since it can only be used after all the signal data has been read, it would not be useful for a balancing robot application. In order to balance, the signal needs to be read and filtered in real time.

9 Butterworth The Butterworth filter is another type of linear, time invariant filter. However, it will have different B and A transform function coefficients than the basic LTI, low pass filter. There is a Butterworth filter function builder in Matlab so it is very easy to use. If you want to implement a Butterworth filter in the Arduino you should first use Matlab to determine the A and B coefficients. In order to determine these coefficients we use the 'butter' function in Matlab. Using butter Function to Find the Coefficients: The butter function will create a butterworth filter and give us the coefficients (B and A). The syntax to call the function is shown below. [B, A] = butter(n,wn,'low') Where B and A are transfer function coefficients, N is the order of Butterworth filter you wish to design (remember the higher the order the more accurate, but the more lag)and Wn is the normalized cut- off frequency. By default, the Butterworth filter is a low pass filter i.e. butter(n,wn) will design a low pass filter, but you can design all types of filters (see help butter in Matlab for more details). The cut- off frequency for a digital filter can be given by the following formula: f = = 1 2π T 1 α α This formula comes from substituting the RC formula for digital filters into the cut- off frequency formula for analog filters(see Wikipedia low pass filter page). T is the sampling period. For operations in Matlab, you can calculate an approximate value of T by creating a time array using the 'tic' and 'toc' functions. The sampling period is then the maximum value in the time array and divided by the number of entries. This is not the most accurate method since 'tic' and 'toc' are just counters, but provided you don't do too many time intensive processes (graphing, printing, complex math etc) in between the counting you should get a good result. The use of tic and toc are shown in in the IR_SENSOR_FILTFILT function above. The normalized cut- off frequency is then: W C = f = 2f D Where f s is the sampling frequency (1/sampling period). If you are using the Arduino, you could set a timer interrupt and sample everytime the interrrupt goes off. That way you know your exact sampling frequency.

10 Once we have the coefficients, we can implement the filter. We will go over how to implement it in both Matlab and Arduino. Matlab Butterworth Filter Implementation To implement the filter in Matlab, we will use the filtfilt function due to the zero phase shift, but you could also use Y = filter(b,a,x). The following function outlines how to create and use a butterworth filter in Matlab to filter the raw IR data. function [B,A] = BUTTERWORTH(obj,N) T = max(time)/length(time); %Calculates Sampling Period fc = 1/(2*pi()*T*(1-a)/a); %Calculates the cutoff frequency Wn = fc/(2*1/t); %Normalized Cutoff frequency(0 < Wn < 1) [B,A] = butter(n,wn,'low'); %Generates coefficients of lowpass Butterworth filter, order N Butterworth = filtfilt(b,a,ir); %IR is the array of raw data figure; %Creates a new figure plot(time,ir,'r'); hold on plot(time,butterworth,'b')%butterworth = array of filtered values end The plot below shows the filtered and unfiltered data when 'butter' is used to determine the B and A matrices.

11 Figure 5- Filtered and Unfiltered Voltage plots using Butterworth filter design and alpha of 0.1 Arduino Butterworth Filter Implementation To implement this filter on the Arduino you will need to manually write out the equation using the coefficients. Recall from above that the transfer function in frequency domain can be defined as follows: Y X = b + + b - z.- + b 0 z b 2 z a - z.- + a 0 z a 5 z.5 Assume that the B and A matrices for the low pass, LTI, first order, recursive filter, defined above, are as follows: B = [ b 0 b 1 ] and A = [ 1 a 1 ] The Butterworth filter can be determined using the following relation.

12 Ay = Bx Plugging in the matrices and solving for Y gives the following. Remember this example is for a 1st order Butterworth. y 8 = b + x 8 + b - x 8.- a - y 8.- If you want a higher order, you will get larger matrices. A second order Butterworth filter would yield 1x3 matrices and would give you the following equation: Note: y*a 1 yields y i- 1 and y*a 2 would yield y i- 2 etc. y 8 = b + x 8 + b - x b 0 x 8.0 a - y 8.- a 0 y 8.0 Since we used the butter() function in Matlab to determine the A and B coefficients, we are implementing a Butterworth filter. If you would like to use another type of filter, you can use a different function in Matlab to determine the coefficients. For example, to obtain the A and B coefficients for a Chebyshev filter you could use the chebyl function in Matlab. Lab Requirements This lab showed a few different ways to do filtering. For this lab you will need to do the following: Connect an IR sensor to the Arduino Read the raw IR data and output it to Matlab Choose three filtering methods from above and use them on the IR data Create one graph per filtering method showing the raw and filtered data as well as what filtering coefficient was used You do not need to implement the butter filter on the Arduino for this lab, but it may be useful for your final project so you may want to try it. If you choose to use it as one of your three filtering methods, you will need to import the filtered data and graph it in Matlab. Remember the filtfilt function is not defined on the Arduino so it can only be used in Matlab. Also for your project you will want to measure and evaluate the data in real time so the filtfilt function wouldn't really be useful anyway. A write- up is not required for this lab.

13 Appendix A

14 Appendix B clc; clear all; numsec=10; IR=[]; IR_filt = []; a = 0.5; %smoothing coefficient (to be optimized) s1 = serial('com8'); % define serial port s1.baudrate=9600; % define baud rate set(s1, 'terminator', 'LF'); % define the terminator for println fopen(s1); try % use try catch to ensure fclose % signal the arduino to start collection w=fscanf(s1,'%s'); % must define the input % d or %s, etc. if (w=='a') display(['collecting data']); fprintf(s1,'%s\n','a'); % establishcontact just wants % something in the buffer end i=0; t0=tic; while (toc(t0)<=numsec) i=i+1; t(i) = toc(t0); t(i) = t(i)-t(1); IR(i)=fscanf(s1,'%f'); % must define the input % d, %f, %s, etc. if(i==1) IR_filt(i) = IR(i); else IR_filt(i) = a*ir(i)+(1-a)*ir_filt(i-1); end plot(t,ir); %plots the raw IR output hold on; plot(t,ir_filt,'r'); %plots the filtered IR output drawnow; end fclose(s1); catch exception fclose(s1); throw (exception); end % always, always want to close s1