State space to transfer function [ Zeros at infinity ]
Transfer function to state space
State space to zero/pole and transfer function to zero/pole
Pole/zero to state space and pole/zero to transfer function

A dynamic system is most commonly described in one of three ways: by a set of state-space equations and the corresponding matrices, by a transfer function with the numerator and denominator polynomials, or by a list of poles and zeros and the associated gain. From time to time, it is useful to convert between these various representations. Matlab can do these conversions quickly and easily.

State space to transfer function:

To begin with, suppose you have a set of state-space equations and you would like to convert them to the equivalent transfer function. This is done using the command

     

[num,den] = ss2tf(A,B,C,D,iu)

• m=1000
• b=50
• u=500

If you want to change this to a transfer function, just run the following m-file:

	A = [0   1 
             0   -0.05];
     	
     	B = [0; 
             0.001];
     	
     	C = [0   1];
     
     	
     	D = 0;     
     	
     	[num,den]=ss2tf(A,B,C,D)

 	num =              
		
	0    0.0010         0
	
	 den =         
	 
	1.0000    0.0500     0

          0.001s + 0
       ------------------
	 s^2 + 0.05s + 0 

You now have the transfer function that describes the system. As you can see this command is pretty easy to use. Here are some notes about ss2tf:

• The numerator, num, will have as many rows as there are outputs (or rows in the matrix C).
  
• The numerator and denominator are returned in descending powers of s
  
• Care must be taken to check the numerator and denominator, as zeros at infinity may produce erroneous transfer functions.

Zeros at infinity

This last point needs some further explanation. We say that a system has zeros at infinity if the limit as s->infinity of the value of the transfer function is equal to zero; this happens whenever you have more poles than zeros. You will see this in the root locus plot as asymptotes which go to infinity (the number of asymptotes is equal to the number of zeros at infinity). Matlab sometimes computes these zeros at infinity as being large finite numbers.When this happens, some of the coefficients in the numerator that are supposed to be zero end up being very small numbers. It may not seem like a big deal, but it can cause errors when trying to use the transfer function later on. You should always check your transfer function, and if numbers that are 0.0000 show up that are supposed to be zero, rewrite the numerator into Matlab to compensate.

A good example of this is given by the following set of state equations:

If you enter this into Matlab using the following m-file:

     	  A = [0    1    0      0
               0 -0.1818 2.6727 0
               0    0    0      1          
               0 -4.545 31.1818 0];
          
          B = [0
               1.8182	  
               0
               4.5455];     
	  
	  C = [1 0 0 0	  
	       0 0 1 0];     
	  
	  D = [0 0];     
	  
	  [num,den]=ss2tf(A,B,C,D)

You should get the following transfer function:

    	num =
              
              0    0.0000    1.8182   -0.0000  -44.5460              
              0    0.0000    4.5455    0.0000         0     
              
        den =         
	      
	      1.0000    0.1818  -31.1818   -4.4541         0

If you look at the numerator, the first and last element of each row are 0, while the second and fourth element in each row are 0.0000. If you look closer at each of these elements, you will find that they are not zero, but in fact some very small number. To see this, enter any of the following commands into the Matlab command window: num(1,2), num(1,4), num(2,2) or num(2,4). You should get something similar to the following as an answer: 7.1054e-15, -6.2172e-15, 1.2434e-14, or 4.4409e-15. Look at the roots of the numerator polynomials using roots(num(1,:)) and you will see the roots of the numerator which are almost at infinity but not quite.

This numerical inconsistency can be eliminated by adding the following line after the ss2tf command to get rid of the numbers that are not supposed to be there:

     num = [num(1,3) 0 num(1,5)
            num(2,3) 0 num(2,5)];

Now all of the small numbers have been replaced with zeros. Always make sure to look at your transfer function and understand what it means before you use it in the design process.

Transfer function to state space:

The reverse of the command ss2tf is the tf2ss command, which converts a transfer function of a system into state-space form. The command is issued like this:

     [A,B,C,D] = tf2ss(num,den)

One important fact to note is that although there is only one transfer function that describes a system, you can have multiple state-space equations that describe a system. The tf2ss command returns the state-space matrices in control canonical form. Therefore, if you take a set of state-space equations, convert them into a transfer function, and then convert it back, you will not have the same set of state-space equations you started with unless you started with matrices in control canonical form.

As an example, take the numerator and denominator created above and convert it back to state-space. This can be done with the following Matlab code:

     [A,B,C,D] = tf2ss(num,den)

     		 A =       
			-0.1818   31.1818    4.4541         0
		         1.0000         0         0         0              
			 0         1.0000         0         0              
			 0         0         1.0000         0
			 
	         B =        
 			 1        
 			 0        
 			 0              
 			 0
 	
                 
                 C =
                         0         1.8182         0       -44.5460
                         0         4.5455         0         0
                         
                 D=      0          
                 	 0

State space to zero/pole and transfer function to zero/pole:

There is also a third way to represent a dynamic system, and that is the pole-zero model. This model is basically the same as the transfer function model, except that the polynomials have been factored so the poles are all in the denominator and the zeros are in the numerator. The basic format looks like the following:

Remember that for a proper transfer function, the number of poles n is greater than or equal to the number of zeros m. Matlab can make the transformations from either state-space or transfer function to the pole-zero representation. The commands to get the system into zero-pole form are:

	[z,p,k] = tf2zp(num,den)

     
	[z,p,k] = ss2zp(A,B,C,D,iu)

Both of these commands should return three variables: z, p, k. The variable z returns all of the zeros in columns. There should be one column for every row in the transfer function numerator or every output, y (rows in the C matrix). The variable p returns all of the poles in a column. The variable k returns a column of gain values. The column should have as many rows as numerator rows or outputs, y. For example, using t he state space model and transfer function above, enter either of the following m-files:

          num = [1.8182    0       -44.5460; 
	 	 4.5455   -7.4373   0];
	 	      
          den = [1 0.1818 -31.1818 6.4786 0];
 	  
 	  [z,p,k] = tf2zp(num,den)

     
 	  A = [0      1      	0      		0
 	       0     -0.1818    2.6727          0
 	       0      0         0               1
               0     -4.545     31.1818         0];
 
          B = [0
               1.8182 
               0 	  
               4.5455];
               
          C = [1 0 0 0
               0 0 1 0];
               
          D = [0	  
               0];
               
          [z,p,k]=ss2zp(A,B,C,D,1)

and you should get the following output:

     	     z =

         	4.9498    1.6362
               -4.9498         0
               
             p =
                0         
                0.2083
               -5.7753
                5.3851
                
             k =         
                1.8182
                4.5455

Pole/zero to state space and pole/zero to transfer function

As you may have already guessed, if you have a system described by the pole-zero method, you can convert that to either the state-space model or the transfer function. To get the state-space model, enter the following command:

     [A,B,C,D] = zp2tf(z,p,k)

Again, it is important to note that more than one set of state-space matrices can describe a system. The state-space matrices returned from this command are also in control canonical form. For example, take the z, p, and k matrices you just created and convert them back to state-space:

    [A,B,C,D] = zp2tf(z,p,k)

             A =        -0.1818   31.1818        -6.4786         0
           		 1.0000         0              0         0             
           		      0    1.0000              0         0
                              0         0         1.0000         0
                              
             B =         1
                         0
                         0          
                         0     
                         
             C =         0         1.8182              0           -44.5460
                         0         4.5455        -7.4373                  0     
  
             D =         0
                         0

To get a system described by a pole-zero model into a transfer function model, use the following command:

     [num,den] = zp2tf(z,p,k)

     num =              0         0    1.8182         0  -44.5460              
                        0         0    4.5455   -7.4373         0     
                        
     den =             1.0000    0.1818  -31.1818    6.4786         0

User feedback