matlab and the control system toolbox

Matlab the Symbolic Editor and the Control System Toolbox

The Symbolic Editor The Matlab Symbolic Editor allows us to solve discrete time functions as symbolic equations. The following list a number of the symbolic functions and utilities: syms a b c x % define symbolic variable Fx = a*x^2+b*x+c; % define a symbolic function Fx y = int(Fx,x); % indefinite integral of function Fx y = diff(Fx,x); % derivative of the function Fx y = limit(Fx,x,x0); % limit of Fx @ x = x0 y = subs(Fx,x,x0); % value of the function Fx @ x = x0

Simplifications of Symbolic Objects: y = simplify(Fx); % perform symbolic simplification y = collect(Fx); % collect like terms y = factor(Fx); % factor a symbolic function Y = expand(Fx); % expansion of symbolic functions [nx,dx] = numden(Fx) % returns numerator and denominator terms

% of symbolic object

The Symbolic Editor [cont’d] Solution of Equations: g = solve(fx,x) % solves the eqn f(x) = 0

g = solve(f1,f2,..fn) % solves [f1,f2,..,fn] = 0

y = finverse(Fx) % returns inverse function

y = subs(fx,x,x0) % substitutes the value of x = x0 in the

% symbolic equation fx, the returned value

% y is a symbolic variable.

Display of Symbolic Functions: R = vpa(F,d) % uses variable-precision arithmetic (VPA) to

% compute each element of A to d decimal % digits of accuracy, where d is the current % setting of digits

d = digits % set number of digits used in VPA accuracy.

The Symbolic Editor [cont’d] Arithmetic Operations: + % addition

- % subtraction

* % multiplication

.* % array multiplication

/ % division

./ % array division

^ % scalar raised to a power

.^ % array raised to a power

‘ % complex conjugate transpose

Special Functions: u = heaviside(t) % the Heaviside step function

d = dirac(t) % the Dirac impulse function

The Symbolic Editor [cont’d] Conversion Functions: F = char(f) % conversion of symbolic to character format

F = double(f) % symbolic to double object conversion

F = sym2poly(f) % symbolic to polynomial conversion. E.G., % f = s^2+3*s+5 [1 3 5].

f = poly2sym(F) % polynomial to symbolic conversion. E.G., % F = [1 2 5 0] s^3+2*s^2+5*s

S = sym(A) % constructs an object S, of class 'sym', % from A. If the input argument is a string, % the result is a symbolic number or a % variable. If the input argument is a %

numeric scalar or matrix, the result is a % symbolic representation of the given % numeric values

r = findsym(S) % determines the symbolic variables in the % function S

The Symbolic Editor [cont’d] Integral Functions: L = laplace(F) % is the Laplace transform of the scalar

% symbol F with default independent variable % t. The default return is a function of s. % The Laplace transform is applied to a %

function of t and returns a function of s. F = ilaplace(L) % is the inverse Laplace transform of the

% scalar symbolic object L with default % independent variable s. The default return % is a function of t. The inverse Laplace % transform is applied to a function of s and

% returns a function of t F = ztrans(f) %is the z-transform of the scalar symbol f

% with default independent variable n. The % default return is a function of z

f = iztrans(F) % is the inverse z-transform of the scalar % symbolic object F with default independent % variable z. The default return is a %

function of n.

Symbolic Editor Example Sym1 Example 1: write an M-File program to plot the time function.

Solution: We build the time function using the Symbolic editor as a general time function. Next we use the input command to enter the data for a, f, tf, and the number of plot points between 0 and tf. The 1st subs command is used to evaluate the time function for the values of a and f. The 2nd subs function, within the for loop, is used to evaluate the time function at values of t.

The function double converts the symbolic values to double format for the purposes of plotting the data with the plot command. Note the data xt1 and t1 are stored as arrays. Notice the use of num2str in the title command to display the actual values of a and f.

Matlab Code for Example Sym1 'Damped cosine example'

syms t a f % define symbolic variables

xt = exp(-a*t)*cos(2*pi*f*t); % define symbolic time function

% specify function parameters using the keyboard

a = input('Enter the decay constant a = ');

f = input('Enter the sinusoidal frequency f = ');

tf = input('Enter the time period tf = ');

Npts = input('Enter the number of time samples Npts = ');

xt = subs(xt);

t1 = linspace(0,tf,Npts); % plot time period

xt1 = double(subs(xt,t,t1)); % convert to double from sym with t = t1

plot(t1,xt1); grid; % plot function

xlabel('time(sec)'); % add plot labels

ylabel('Amplitude');

% add fancy title using greek characters and num2str

title(['x(t)=e^{',num2str(a),'t}cos(2\pi',num2str(f),'t)'])

Matlab Output for Example Sym1

Symbolic Editor Example Sym2 Example 2: write an M-File program to plot the Magnitude and Phase for the function.

Solution: 1st we build the H(s) function using the Symbolic editor as a general function of s. 2nd we build the frequency log vector ω of 1028 values. The 3rd step is to use the double and subs functions to calculate H(jω). 4th we use the log function to determine the magnitude function |H(jω)| in dB and convert radians to degrees to get the phase function.

The last step is to plot the magnitude and phase functions using the subplot and semilogx plot options.

Matlab code Example Sym2 'Matlab Script'

syms s % define s as symbolic

hs = 26/(s^2+2*s+26); % define symbolic function

% generate log frequency vector 10^0.01 to 10^2 using 1928 points

Omega = logspace(0.01,2,1028);

NOmega = length(Omega); % get length of frequency vector

Hjw = double(subs(hs,s,Omega*i));

HMag = 20*log10(abs(Hjw)); % convert to dB

HPhase = 180*angle(Hjw)/pi; % get phase angle

% Using subplot and semilogx to plot Magnitude and Phase

subplot(2,1,1); semilogx(Omega,HMag);

xlabel('Frequency (radians/sec)')

ylabel('Magnitude (dB)');grid

title('Magnitude Plot |H(j\omega)|')

subplot(2,1,2); semilogx(Omega,HPhase);


ylabel('Phase (degrees)')

title('Phase Plot P(j\omega)'); grid

Matlab Code Example Sym2 title('Magnitude Plot |H(j\omega)|')

subplot(2,1,2); semilogx(w,HPhase);


ylabel('Phase (degrees)')

title('Phase Plot P(j\omega)')

grid on

Matlab Plot Example Sym2

Laplace Transform Examples Example 1: write an M-File program to determine the Laplace Transform of the function

'Laplace Transform Example' syms a w t s % define symbolic variables xt = exp(-a*t)*cos(w*t-pi/6); % evaluate Laplace Transform XS = laplace(xt); % simplify and pretty print XS = simplify(XS); pretty(XS) pause % now print results using vpa disp('Pretty Print with VPA') pretty(vpa(XS,4))

Laplace Transform Example 2 Example 2: write an M-File program to determine the Inverse Laplace Transform of the function

syms s t % define symbolic variables XS = (s+1)/(s*(s^2+2*s+10)); % evaluate Inverse Laplace Transform xt = ilaplace(XS); % simplify and pretty print xt = simplify(xt); pretty(xt) pause % now print results using vpa disp('Pretty Print with VPA') pretty(vpa(xt,4))

Laplace Transform Example 3 Example 3: Use the subs function to plot the inverse Laplace Transform of the function of example 2 for 0 <t < 10

syms s t % symbolic variables XS = (s+1)/(s*(s^2+2*s+10)); % Get Inverse Laplace Transform xt = ilaplace(XS); % simplify xt = simplify(xt); % define time vector 0 to 10

t = 0:0.1:10; % using subs to get time response x = double(subs(xt)); % plot time response plot(t,x) xlabel('Time (sec)');ylabel('Amplitude') grid; title('Time Plot for Example 3')

The Control System Toolbox

The Control System Toolbox provides functions designed for control engineering. The Control System Toolbox is a collection of algorithms, that implements common control system design, analysis, and modeling techniques. Control systems can be modeled as transfer functions, in zero-pole-gain or state-space form. Representation in both continuous-time and discrete-time systems is possible. Conversions between various model representations such as transfer functions and zero, pole, gain frorm are provided. Time responses, frequency responses, and root loci can be computed and graphed. Conversion functions provide the capability to convert transfer function objects to symbolic function objects or symbolic function objects to transfer function objects.

Useful Control System Toolbox Functions

The following list the Control System Toolbox functions most often used in this course: Fz = filt(num,den,Ts) % specify discrete transfer functions

% in DSP format. I.E., Fz = num(z^- % 1)/den(z^-1), with sample time Ts.

Fs = tf(num,den) % specify a continuous time transfer % function. I.E., Fs = num(s)/den(s).

Fz = tf(num,den,Ts) % specify a discrete time transfer % function Fz = num(z)/den(z) with % sample time Ts.

[num,den] = tfdata(Fz,’z’) % get numerator and denominator terms % of a discrete time transfer function.

[num,den] = tfdata(Fs,’s’) % get numerator and denominator terms % of a continuous time transfer % function.

F = minreal(F) % returns the minimum realization of a % continuous or discrete time transfer % function.


Fz = filt(num,den,Ts) % specify discrete transfer functions % in DSP format. I.E., Fz =

num(z^- % 1)/den(z^-1), with sample time Ts. % The output Fz is a tf object.

Fs = tf(num,den) % specify a continuous time transfer % function. I.E., Fs = num(s)/den(s). % The output Fs is a tf object

Fz = tf(num,den,Ts) % specify a discrete time transfer % function Fz = num(z)/den(z) with % sample time Ts. Fz is a tf object.

Fs = zpk(z,p,k) % creates a continuous-time zero-pole- % gain model with zeros z, poles p, and % gain(s) k. The output Fs is a ZPK % object

[num,den] = tfdata(Fz,’z’) % get numerator and denominator terms % of a discrete time transfer function.

[num,den] = tfdata(Fs,’s’) % get numerator and denominator terms % of a continuous time transfer FF % function.


[Z,P,K] = zpkdata(Fs,’s’) % returns the zeros, poles, and gain of % a continuous time transfer function % F(s).

[Z,P,K] = zpkdata(Fz,’z’) % returns the zeros, poles, and gain of % a discrete time transfer function

% F(z).

Fz = c2d(Fs,Ts) % convert a continuous time system to a % discrete time system. The default is % a ZOH system, see help for other %

methods.

sys = series(sys1,sys2,..) % returns a cascade system LTI % model of sys = sys1*sys2*···*sysn.

sys = feedback(sys1,sys2) % returns an LTI model sys for the % negative feedback interconnection % sys = minreal(sys1/(1+sys1*sys2)).

sys = parallel(sys1,sys2) % forms the basic parallel connection % sys = sys1 + sys2.


Time and Frequency Analysis of continuous time LTI systems ltiview % opens the LTI viewer for time and % frequency domain analysis of LTI % systems bode(sys) % display the bode response of an LTI

% system sys. margin(sys) % displays the gain and phase margin % plots for the LTI system, sys. step(sys) % computes the step response of a % continuous time LTI system, sys. impulse(sys) % computes the impulse response of the

% continuous time LTI system, sys.

[R,P,K]=residue(b,a) % finds the residues, poles, and direct % term of a partial fraction expansion % the polynomial h(s)=b(s)/a(s).

rltool % opens root locus window sisotool % opens single input/single output % design tool window. Displays both % root locus and gain/phase margin.

Discrete Time Systems

Discrete time filter functions y = filter(b,a,X) % filters the data in vector X with the

% filter described by numerator % coefficient vector b and denominator % coefficient vector a.

y = filter(hd,X) % filters the data in vector X with the % filter object hd.

freqz(b,a,...) % plots the magnitude and unwrapped % phase of the frequency response of % the filter. The plot is displayed in % the current figure window.

freqz(Hd) % plots the magnitude and unwrapped % phase of the frequency response of % the filter. The plot is displayed in % fvtool. The input Hd is a dfilt % filter object. See help for more % options

impz(b,a) % plots the impulse response of the % filter hd = b(z)/a(z). See help for % more options.

Discrete Time Systems

Discrete time filter functions fvtool(b,a) % opens FVTool and computes the % magnitude response of the digital % filter defined with numerator, b and % denominator, a. Using FVTool you can

% display the phase response, group % delay, impulse response, step % response,

pole-zero plot, and % coefficients of the filter.

fvtool(hd1,hd2,..,hdn) % computes and displays the magnitude % response of the digital filter % objects hd1,

hd2,..,hdn.

Control System Toolbox Ex1 Example 1: write an M-File program to plot the Magnitude and Phase for the function.

Solution: We 1st build the H(s) function using the Control System Toolbox function Hs = tf(ns,ds), where ns = 26, and ds = [1 2 26]. Next we use the bode function to plot the magnitude and phase responses of H(s).

For comparisons, compare the results here with those obtained using the symbolic editor and the subs function.

Ex1 Matlab script and Bode Plot b = 26; % b(s) = 26 numerator polynomial

a = [1 2 26]; % a(s) = s^2+2s+26, denominator polynomial

hs = tf(b,a); % build and echo back H(s)=b(s)/a(s)

bode(hs); % display bode mag/phase plot

Laplace Transforms and residue Example: Build the transfer function H(s) as a zpk object and use the residue program to determine the residues and poles of H(s). From the residues and poles write the time solution h(t)=L-1{H(s)}

Solution:

See Matlab script next slide

Laplace Transforms and residue 'Matlab Script' % define poles, zeros, and gain of H(s) p = [0 -2 -4 -100]; z = [-1 -3]; k = 600; HS = zpk(z,p,k) % build transfer function % using tfdata to get a(s), and b(s) [b,a,] = tfdata(HS,'s'); % using residue to get residues and poles [R,P,K] =residue(b,a); % Display poles and residues disp(' Residues Poles') disp([R,P])

Laplace Transforms via residue

The system residues and poles are shown above. From the residues and poles we write the time solution as:

Sym2Poly_tfs M-File Problem: develop an M-File program Gs = Sym2Poly_tfs(gs) whose input is gs a symbolic object function of the variable ‘s’ and return is the transfer function object Gs Solution: see code listing below function Gs = Sym2Poly_tf(gs) % function definition

% Inputs:

% gs = symbolic function of s

% Outputs:

% Gs = transfer function object in minimum form

syms s % define symbolic variable s

[nums_sym,dens_sym] = numden(gs); % get numerator and denominator terms

nums_tf = sym2poly(nums_sym); % convert numerator to tf object format

dens_tf = sym2poly(dens_sym); % convert denominator to tf object format

Gs = tf(nums_tf,dens_tf); % get transfer function as polynomial

Gs = minreal(Gs); % get minimum form

Sym2Poly_tfs Example Example : Use the symbolic editor to build the function

as a symbolic object and use the final value theorem

To show that h(∞) = 1. Next use Sym2Poly_tfs to convert the symbolic function to a polynomial function and use the impulse function to display the results and verify that h(∞) = 1.

Solution: see the Matlab code and results on the following pages.

Sym2Poly_tfs Example: Code and Results syms s % define s as symbolic

hs = 17/(s*(s^2+2*s+17)); % define symbolic transfer function

Hs = sym2poly_tfs(hs); % convert to polynomial transfer function

h_inf = limit(s*hs,s,0); % get h(t = inf) using final value theorem

% print h(t = inf) results using fprintf

fprintf('\n h(inf)= %6.2f \n',double(h_inf))

impulse(Hs,5); % Display impulse response

Poly2Sym_tfs M-File Problem: develop an M-File program gs = Poly2Sym_tfs(Gs) whose input is Gs a transfer function object (tf object) function of the variable ‘s’ and return is the transfer function symbolic object (sym object) gs Solution: see code listing below function gs = Poly2Sym_tf(Gs) % function definition

% Inputs: % Gs = tf object transfer function of s

% Outputs: % gs = sym object function gs = n(s)/d(s)

syms s % define 's' as symbolic % check class of GS it must be tf or zpk format

hclass = class(GS); if strcmp(hclass,'tf')==1 |strcmp(hclass,'zpk')==1

[b,a] =tfdata(GS,'s'); else error('unknown function type')

end bsym = poly2sym(b,'s'); % symbolic numerator

asym = poly2sym(a,'s'); % symbolic denominator gs = bsym/asym; % symbolic transfer function

gs = simplify(gs); % simplify transfer function

Poly2Sym_tfs Example Example : write an M-File program that uses the poly2sym_tfs function to plot the impulse response of the function:

Solution: We 1st build the H(s) function as a polynomial function (tf_object) and use Poly2Sym_tfs to convert it to a sym_object function, h(s). Next we take the inverse Laplace Transform of the function h(s) and plot its time function.

For comparison purposes, we take the inverse Laplace Transform of the function h(s) and plot its time function. We use the subplot option to display the two plots.

Poly2Sym_tfs Example Code clear % clear workspace

d1s = [1 0]; % d1(s) = s

d2s = [1 2 17]; % d2(s) = s^2+2s+17

ds = conv(d1s,d2s); % d(s) = d1(s)*d2(s)

ns = 17*[1 1]; % n(s) = 17*(s+1)

Hs = tf(ns,ds); % H(s) = ns/ds

tf = 5; % plot time secs

subplot(2,1,1);

impulse(Hs,tf); % display impulse response

title('Impulse Response via Control System Toolbox function impulse')

% convert to symbolic transfer function

syms s t

hs = poly2sym_tfs(Hs);

ht = ilaplace(hs); % get inverse LT

ht = simplify(ht); % simplify and display time response

pretty(ht)

tk = linspace(0,5,500); % build time vector

%

Poly2Sym_tfs Example Code % for loop builds impulse response time vector

for k = 1:length(tk)

htk(k) = double(subs(ht,t,tk(k)));

end

% plot results

subplot(2,1,2);

plot(tk,htk);

xlabel('Time (sec)')


title('Impulse Response via Symbolic Editor')

Poly2Sym Example Plots

Complex Poles and residue Complex Pole Example: Given the function H(s) below determine the

following:

1.  Build the function as a zpk object

2.  Determine the residues and poles of the tf object

3.  From the residues and poles write the inverse Laplace Transform of H(s).

4.  Convert the tf object transfer function to a symbolic transfer function.

5.  Determine the inverse Laplace Transform of the symbolic transfer function and compare it to the results of part 3.

Complex Poles and residue Example Solution: The Matlab code and results are shown below. To determine the time solution for the complex part we use the equation

Complex Poles and residue Example z = [-4]; % define zeros of H(s)

% determine poles of H(s)using roots

pcmpx = roots([1 2 10]); % poles of s^2+2s+10

p = [-1 pcmpx(1) pcmpx(2)];

k = 50;

%Build and display transfer function

HS = zpk(z,p,k)

% determine residues and poles of H(s)

[b,a] = tfdata(HS,'s');

[R,P,K] = residue(b,a);

disp(' Residues Poles')

disp([R,P])

% convert to symbolic transfer function

syms s t

hs = poly2sym_tfs(HS); % build symbolic transfer function

ht = ilaplace(hs);

ht = simplify(ht);

disp('This is the symbolic solution')

pretty(ht)

Complex Poles and residue Example Matlab Solution: The Matlab solution is shown below. Note that the symbolic and solution via residues using the equation on the previous page are identical.

A 2nd Complex Pole and residue Example

Problem: Build and test a M-File program that uses the residues and poles of the function H(s) to print the closed form solution of it’s inverse Laplace Transform.

A 2nd Complex Pole and residue Example-Matlab M-File

function f_residue(R,P) % Function f_residue % Purpose: determine closed form solution of L^-1{H(s)} % Method: Use the method of residues to determine soln as % fk(t) = Rk*exp(pk*t) for real poles % fk(t) = 2exp(Re(pk*t)[Re(Rk*)cos(IM(pk*t))+IM(Rk*)sin(IM(pk*t))] for % cmplx poles % Inputs: % R = residues of the function H(s) % P = Poles of the function H(s) % Output: % Printed values of the functions fk(t) NPoles = length(P); k = 0; for n = 1:NPoles if (abs(imag(P(n))) == 0) k = k + 1; fprintf(['\n f',num2str(k),'= %6.3fexp(%6.3f t)\n'],R(n),P(n))

A 2nd Complex Pole and residue Example-Matlab M-File

else if(imag(P(n)) < 0); k = k + 1; % increment k and check next pole Alpha = real(P(n)); A = 2*real(R(n)); B = 2*imag(R(n)); w = abs(imag(P(n))); if (B < 0); fprintf(['\n f',num2str(k),'= exp(%6.3f t)[%6.3fcos(%6.2f t)…

- %6.3fsin(%6.2f t)]\n'],... Alpha,A,w,abs(B),w) else fprintf(['\n f',num2str(k),'= exp(%6.3f t)[%6.3fcos(%6.2f t)…

+ %6.3fsin(%6.2f t)]\n'],... Alpha,A,w,abs(B),w) end else end end end

A 2nd Complex Pole and residue Example Problem

A 2nd Complex Pole and residue Example Problem

'f_residue example' Z = -4; P = [-1 -1+3i -1-3i]; K = 1; Hs = zpk(Z,P,K) [b,a] = tfdata(Hs,'s'); [R,P,K] = residue(b,a); f_residue(R,P)

Series RLC Circuit Problem Problem: develop an M-File program to solve for the voltage across the capacitor in a RLC series circuit in terms of the transfer function H(s)=Vout(s)/Vin(s) in terms of the circuit parameters R, L, and C as a symbolic transfer function. Given R = 1 ohm, C = 1/16 F and L = ½ H enter the data from the keyboard and use the subs function to determine the symbolic function H(s). Finally use the function Sym2Poly_tfs to convert the symbolic transfer function to a tf object and use the Matlab step function to determine the capacitor voltage due to a unit step function. Solution: see Matlab code listing below. We develop the code in a new M-File window and copy and paste it into the workspace to execute it. Note that the the symbolic variable are s, R, Cx, and L. We use Cx instead of C as Matlab tries to invoke the c compiler if we use C. Note also the use of the input command to input the data for R, L, and C from the keyboard.

Matlab Script for RLC Example syms R Cx L s zC = 1/(s*Cx); % capacitive impedance zR = R; % resistor impedance

zL = s*L; % inductor impedance zT = zR + zC + zL; % total series impedance hs = zC/zT; % ratio of impedances % simplify and collect like terms hs = simplify(hs); hs = collect(hs); pretty(hs) % pretty print symbolic transfer function pause % wait for input from keyboard R = input('Enter circuit resistor R = '); Cx = input('Enter circuit capacitor Cx = ');

L = input('Enter circuit inductor L = ') hs = subs(hs); % substitute values for R, L, and C disp('updated symbolic tansfer function') hs = simplify(hs); pretty(hs) pause % convert from sym to tf object form HS = sym2poly_tfs(hs) step(HS)

Matlab Output for RLC Circuit

Sym2Poly_tfz M-File Problem: develop an M-File program Gz = Sym2Poly_tfz(gz,Ts) whose input is gz a symbolic object function of the variable ‘z^-1’ and return is the transfer function object Gz Solution: see code listing below function Gz = Sym2Poly_tfz(gz,Ts) % function definition

% Inputs:

% gz = symbolic function of z in DSP format

% Ts = sampling time (secs)

% Outputs:

% Gz = transfer function object in minimum form

syms z % define symbolic variable s

[numz_sym,denz_sym] = numden(gz); % get numerator and denominator terms

numz_tf = sym2poly(numz_sym,’z’); % convert numerator to tf object format

denz_tf = sym2poly(denz_sym,’z’); % convert denominator to tf object format

Gz = filt(numz_tf,denz_tf,Ts); % get transfer function as DSP polynomial

Poly2Sym_tfz M-File Problem: develop an M-File program gz = Poly2Sym_tfz(Gz) whose input is Gz a tf object function of the variable ‘z^-1’ and return is the sym object transfer function gz. Solution: see code listing on next page. Note the comment that the terms b1(z) and a1(z) may not be the true numerator and denominator of the symbolic transfer function. I.E., they may, in fact, be polynomial terms with numerators and denominators. To accommodate this condition the function numden is used to return the true numerator and denominator terms of the symbolic transfer function. Note, also, that the sampling time is not required to determine the symbolic transfer function. This is because the function Gz includes the sampling time.

Poly2Sym_tfz M-File function gz = Poly2Sym_tfz(Gz) % function definition

% FUNCTION Poly2Sym_tfz converts a polynomial transfer

% function to a symbolic transfer function

% Input:

% GZ = tf or zpk discret time transfer function

% Output:

% gz = sym object transfer function

syms z

% check class of GS it must be tf or zpk format

hclass = class(GZ);

if strcmp(hclass,'tf')==1 |strcmp(hclass,'zpk')==1

[b,a] =tfdata(GZ,'z');

else

error('unknown function type')

end

b1= poly2sym(b,'z'); % convert to sym numerator

a1 = poly2sym(a,'z'); % convert to sym denominator

gz = b1/a1; % form gz = b(z)/a(z)

% get numerator and denominator terms of gz, they may

% not be the same as b1 and a1

[bz,az] = numden(gz);

gz = bz/az; % sym transfer function

gz = simplify(gz); % simplify final sym transfer function

Discrete Filter Example Example : write an M-File program to build the filter function

As a symbolic function and plot the 1st 500 samples of its step response.

Solution: We 1st build the filter function hz and then multiply it by the z-transform of the step function to form the a-transform of its step response. Next we take the inverse z-transform to get the sample time response and then plot its step response.

See Matlab code and display results.

Discrete Filter Example syms z n M

hz = 0.8*z^-M/(1 + 0.8*z^-M);

M = 11;

% subs for M and display filter function

hz = subs(hz); hz = simplify(hz); pretty(hz)

uz = 1/(1 - z^-1); % build step function

hz_step = hz*uz; % this is the step response

hn_step = iztrans(hz_step); % take inverse z-transform

nk = 0:500; % define # of samples

hn_step = subs(hn_step,n,nk); % replace n with nk

hn_step = double(hn_step); % convert to double

stem(nk,hn_step,'fill'); % plot response

xlabel('n samples');


title('Step Response')

Discrete Filter Example


As a polynomial function and plot the 1st 500 samples of its step response.

Solution: We 1st build the filter function hz and then use the function stepz to plot its step response.

See Matlab code and display results.

Discrete Filter Example 'Discrete Filter Example using tf object'

M = 11;

b = [zeros(1,M) 0.8]; % numerator function b(z)

a = [1 zeros(1,M-1) 0.8]; % denominator a(z)

hz = filt(b,a,1) % build filter function

stepz(b,a,500) % plot step response


As a symbolic function and use the function Sym2Poly_tfz to convert the symbolic filter function to a polynomial filter function. Use fvtool to display the filter magnitude response.

Solution: See Matlab code and display results.

Discrete Filter Example1 Matlab code syms z r n % define z,r, and n as symbolic

bz =0.5*(1 + r^n)*(1 - z^-n); % define symbolic numerator

az = (1 - r^n*z^-n); % define symbolic denominator

hz = bz/az;

n = 11, r = 0.98; % define filter parameters

hz = subs(hz); % evaluate filter function

HZ = sym2poly_tfz(hz,1);

[b,a]=tfdata(HZ,'z'); % get nums and dens of tf_object

fvtool(b,a) % plot magnitude response of filter

Discrete Filter Example1 Magnitude Response

Discrete Filter Example 2 Example : write an M-File program to build the filter function

As a polynomial function and use the function Poly2Sym_tfz to convert the tf_object filter function to a symbolic filter function. Use fvtool to display the filter magnitude response of the polynomial filter function. Also display the filters impulse response using the Matlab function impz.

Solution: See Matlab code and fvtool, and impz display results.

Discrete Filter Ex 2: Matlab code

r = 0.98; n =11; % define filter parameters

b = (1+r^n)*[1 zeros(1,n-1) -1]; % define poly numerator

a = 2*[1 zeros(1,n-1) -r^n]; % define poly denominator

HZ = filt(b,a,1) % Filter function

hz = poly2sym_tfz(HZ) % display symbolic filter function

fvtool(b,a) % display magnitude response

impz(b,a) % display impulse response

Discrete Filter Ex 2: Filter Plots

matlab and the control system toolbox

Documents