L01-Guia Laboratorio - 1 2019 PDF

PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ
FACULTAD DE CIENCIAS E INGENIERÍA
DEPARTAMENTO DE INGENIERÍA MECÁNICA
ÁREA DE AUTOMATIZACIÓN
CONTROL AUTOMÁTICO
LABORATORIO Nº 1
INTRODUCCIÓN AL MATLAB Y SU TOOLBOX DE ANÁLISIS Y DISEÑO DE

SISTEMAS DE CONTROL
LIMA, 2019
--------------------------------------------------------------------------------------------------------------------
LABORATORIO No1
INTRODUCCIÓN AL MATLAB Y SU USO EN EL ANÁLISIS Y DISEÑO

DE SISTEMAS DE CONTROL
OBJETIVOS
Al finalizar el laboratorio, el alumno estará familiarizado con el uso del MATLAB

realizando simulaciones orientadas al análisis y/o diseño de sistemas de control
automático. Para esto se usará el toolbox de diseño y análisis de sistemas de control del
MATLAB.
INTRODUCCIÓN AL MATLAB
MATLAB es un software interactivo orientado para el cálculo científico y de ingeniería,

que facilita la exploración iterativa, diseño y resolución de problemas. MATLAB
integra análisis numérico, visualización, y programación en un entorno amigable, en el
que los problemas y soluciones se pueden expresar en notación matemática.
MATLAB es un sistema interactivo cuyo elemento básico de datos es un arreglo que no

requiere dimensionamiento. Esto nos permite resolver muchos problemas técnicos de
cálculo, especialmente aquellos que usan composición de matrices y vectores, en una
fracción de tiempo de lo que tomaría escribir un programa en un lenguaje no interactivo
como C o Fortran.
1. Usos del Matlab.-
 Funcionalidades básicas:
- Cálculo matemático.
- Cálculo matricial.
- Programación y desarrollo de algoritmos.
- Desarrollo e implementación de aplicaciones.
- Gráficos científicos y de ingeniería.
- Modelamiento, simulación y diseño de prototipos.
- Análisis de datos, exploración y visualización.
 Librerías específicas: toolboxes. A lo largo del curso se utilizarán las siguientes:

- Control System Design and Analysis: análisis de sistemas y diseño de
controladores.
- Simulink: simulación de sistema dinámicos y diseño basado en modelos.
 Otros toolboxes:
- Math, Statistics and Optimization.
- Signal Processing and Communications.
- Image Processing and Computer Vision.
- Computational Finance.
- Parallel Computing, otros.
2
----------------------------------------------------------------------------------------------------------
LABORATORIO DE CONTROL AUTOMÁTICO
--------------------------------------------------------------------------------------------------------------------
2. El aspecto de Matlab 8 (R2012a).-
Matlab 8 ofrece un aspecto configurable en función de la información que se desee

mostrar en la pantalla. En la Figura 1.1 se muestra un posible aspecto.
Figura 1.1 Escritorio del Matlab
Existen cuatro elementos fundamentales, tal y como puede apreciarse en la imagen:

• Ventana de comandos (Command window): es un interfaz en modo texto sobre la que
se introducen por teclado instrucciones de Matlab. Será el elemento fundamental a
utilizar en esta práctica.
• Ventana de variables (Workspace): en ella aparece un listado de todas las variables
que se han empleado durante la sesión, también pueden visualizarse sus tamaños y
tipos.
• Historial de comandos (Command history): ofrece un listado de todas las
instrucciones tecleadas durante la sesión.
• Navegador o (Current folder): indica los contenidos del directorio actual y permite
navegar por la estructura de directorios del PC.
3. Cómo encontrar ayuda en Matlab.-
Existen distintas formas de localizar ayuda en el entorno de Matlab:

 Ayuda en línea.- Se accede a través de la ventana de comandos tecleando help
‘nombre de función’. La ayuda se obtiene en modo texto. Como
ejemplo, se visualizará la ayuda de la función que permite invertir matrices
tecleando:
>> help inv
3
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
 Navegador de funciones.- Se accede desde el menú Help, seleccionando la

opción Function Browser, o seleccionando el icono fx a la izquierda de la línea
de comandos. Constituye una manera más ordenada de localizar la misma
información: las funciones aparecen agrupadas en bloques y se proporciona un
interfaz para navegar. Además ofrece información adicional como ejemplos e
instrucciones de uso.
 Navegador de ayuda.- Se accede desde el menú Help, seleccionando la opción

Product Help, o dando click en el botón con signo de interrogación en la barra
de herramientas. Constituye una manera más sencilla de localizar la información
anterior, en adición a presentar documentación adicional (guías, etc.). Presenta
dos ventanas, una para navegar y otro para visualizar, lo cual facilita su uso.
También se puede accesar a la información de una función en el navegador de
ayuda tecleando en la ventana de comandos doc ‘nombre de función’.
 Comando lookfor (búsqueda de palabras clave).- Aunque más complicado

de utilizar, proporciona en ocasiones información extra. El comando lookfor
permite buscar entre las descripciones de todas las funciones de Matlab, aquellas
que contienen la palabra clave que indiquemos. Como ejemplo, buscaremos
todas las funciones de Matlab relacionadas con la transformada de Fourier
tecleando:
>> lookfor Fourier
4. Variables y matrices en Matlab.-
Matlab soporta nombres de variable de hasta 19 caracteres, y distingue entre

mayúsculas y minúsculas.
El tipo de la variable es asignado automáticamente y puede ser:
 Entero
 Real
 Complejo
 Carácter
Una sentencia de creación de variable es, por ejemplo:
>> pepe = 7
pepe =
7
Esta sentencia crea la variable entera pepe y le asigna el valor 7. Matlab muestra en
pantalla el resultado de cada operación. Si no se quiere visualizar el resultado, basta
poner un punto y coma después de cada sentencia:
>> pepe = 7;
4
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Todas las variables en Matlab son consideradas matrices. Las posibilidades que
utilizaremos son:
 Matriz n x m: matriz bidimensional

 Matriz n x 1 ó 1 x n: vector (se maneja exactamente igual que una matriz)
 Matriz 1 x 1: escalar (también se maneja exactamente igual que una matriz).
Empecemos ingresando una matriz como una lista de sus elementos. Se sigue las
siguientes reglas:
 Separar los elementos de una fila con espacios o comas.

 Usar un punto y coma “;” para indicar el final de cada fila.
 Encerrar la lista de elementos con corchetes, [ ].
>> A = [1 2 3; 4 5 6; 7 8 9]
A =
1 2 3
4 5 6
7 8 9
Como puede apreciarse en el ejemplo, los distintos elementos de una fila se separan
mediante espacios (o comas) y las distintas filas se separan mediante puntos y coma.
Algunas posibilidades de manejo de variables que ofrece Matlab:
 Comprobar el contenido de alguna variable: basta con teclear su nombre en la

ventana de comandos:
>> pepe
pepe =
7
 Listar todas las variables existentes en un determinado momento: comando who.

>> who
Your variables are:
A pepe
Nota: la versión 8 de Matlab permite visualizar las variables existentes en la ventana

Workspace.
 Eliminar alguna variable de memoria: comando clear.

» clear pepe
» who
Your variables are:
A
Podemos observar cómo la variable pepe ha desaparecido de la memoria.
5
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
5. Gestión de una sesión de trabajo.-
La Tabla 1 resume los comandos y símbolos especiales para gestionar una sesión de
trabajo.
Tabla 1 Comandos para gestionar una sesión de trabajo
Comando Descripción
clc Limpia la ventana de comandos
close all Cierra todas las ventanas que muestren gráficos.
clear Remueve todas las variables de memoria
clear var1 var2 Remueve las variables var1 y var2 de memoria
exist(‘name’) Determina si existe una variable con el nombre name
quit Detiene la ejecución del Matlab
who Lista las variables en memoria
whos Lista las variables y tamaños e indica si tienen parte
imaginaria
: Dos puntos, genera un arreglo con elementos
igualmente especiados
, Coma, separa elementos de un arreglo
; Punto y coma, suprime la impresión en pantalla;
también denota una nueva fila en un arreglo
… Tres puntos, permite continuar una línea
Si se necesita escribir una línea larga, se pueden usar tres puntos, por ejemplo:
>>NumerodeManzanas = 10; NumerodeNaranjas = 25;

>>NumerodePeras = 12;
>>FrutasCompradas = NumerodeManzanas + NumerodeNaranjas ...
+NumberodePeras
FrutasCompradas =
47
Usar las teclas de desplazamiento (flechas), teclas Tab y Ctrl para rellamar, editar y
reusar funciones y variables tipeadas previamente. Por ejemplo, si se escribe la siguiente
línea erróneamente:
>>volumen = 1+sqr(5)
Matlab responde con un mensaje de error porque se escribió mal sqrt. En lugar de
teclear toda la línea, presionar la tecla de desplazamiento hacia arriba (↑) una vez para
mostrar la línea tecleada previamente. Presionar la tecla de desplazamiento hacia la
izquierda (←) varias veces para mover el cursor y agregar la letra t faltante, luego
presionar Enter. El uso repetido de la tecla de desplazamiento hacia arriba permite
visualizar las líneas tecleadas con anterioridad.
6
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
6. Manejo de matrices.-
Matlab ofrece bastantes facilidades para el manejo de matrices. Volviendo al ejemplo

anterior:
>> A = [1 2 3; 4 5 6; 7 8 9]
A =
1 2 3
4 5 6
7 8 9
 Podemos acceder a cualquier elemento de la matriz especificando fila y
columna:
» A (1,3)
ans =
3
Nota: ans es la variable por defecto donde Matlab guarda cualquier resultado; si
hubiéramos deseado utilizar otra variable deberíamos haberlo especificado:
» k = A(1,3)
k =
3
 También se puede acceder a toda una fila o toda una columna, utilizando el
operador dos puntos. Este primer comando muestra todos los elementos de la
fila 2:
» A(2,:)
ans =
4 5 6
Este segundo comando muestra todos los elementos de la columna 3:

» A (:,3)
ans =
3
6
9
 O bien a grupos de filas y/o columnas: Este comando muestra los elementos de
las filas 1 hasta la 2 y de las columnas 2 hasta la 3:
» A(1:2,2:3)
ans =
2 3
5 6
 También es posible modificar cualquier elemento de una matriz:

» A(1,1) = 9
A =
9 2 3
4 5 6
7 8 9
7
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
 E incluso añadir elementos a una matriz dada:

» A(4,4) = 1
A =
9 2 3 0
4 5 6 0
7 8 9 0
0 0 0 1
Podemos ver cómo los elementos no especificados se rellenan con ceros.
7. Principales operadores aritméticos.-
Matlab ofrece una serie de operadores aritméticos válidos tanto para cálculo matricial
como para cálculo escalar:
 Suma: +
 Resta: -
 Producto: *
 División: /
 Transpuesta: ‘
 Potencia: ^
En algunas ocasiones podrán presentarse ambigüedades. Por ejemplo, al multiplicar dos

matrices caben dos posibilidades: producto matricial o producto elemento a elemento.
» A = [1 2; 3 4]
A =
1 2
3 4
» B = [2 4; 6 8]
B =
2 4
6 8
» C = A*B % producto matricial
C =
14 20
30 44
» D = A.*B % el punto indica operación elemento a elemento
D =
2 8
18 32
La información sobre operadores puede ser encontrada en la ayuda de Matlab 8,

dentro de: Product Help -> Getting started -> Language Fundamentals -> Expressions
-> Matrix/Array Operators.
Además de los operadores comentados, existen una serie de funciones muy útiles en
cálculo y generación de matrices:
8
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Generación de matrices:
eye matriz identidad.

zeros matriz de ceros.
ones matriz de unos.
diag matriz diagonal.
rand matriz uniformemente distribuida generada aleatoriamente.
randn matriz normalmente distribuida generada aleatoriamente.
Manejo de matrices:
rank rango de una matriz.

eig autovalores y autovectores.
inv inversa de una matriz.
expm matriz exponencial.
poly polinomio característico.
det determinante.
size tamaño.
length longitud de un vector.
Ejemplos.-
 Obtención de la matriz inversa: función inv:
» A = [1 2; 3 4]
A =
1 2
3 4
» B = inv(A)
B =
-2.0000 1.0000
1.5000 -0.5000
 Creación de una matriz de ceros o unos: funciones zeros y ones:
» A = zeros(1,4)
A =
0 0 0 0
» B = ones(2,3)
B =
1 1 1
1 1 1
La información sobre operaciones matriciales puede ser encontrada en la ayuda de

Matlab 8 en: Product Help -> Getting started ->Language Fundamentals -> Matrices
and Magic Squares -> About Matrices
9
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
8. Operaciones con vectores.-
Podemos crear cualquier vector creciente o decreciente que deseemos. Esta operación
será bastante útil para formar bases de tiempo sobre las que se evaluará el valor de
funciones.
Los dos puntos “:” es un carácter importante en Matlab. La declaración:

>>x =1:5
genera un vector línea conteniendo los números del 1 al 5 con incremento unitario.
Resultando:
x =
1 2 3 4 5
Otros incrementos, diferentes de uno, pueden ser usados.

>>y=0:pi/4:pi
que resulta en:
y=
0.0000 0.7854 1.5708 2.3562 3.1416
Incrementos negativos también son posibles.

>>z=6:-1:1
z=
6 5 4 3 2 1
También se puede generar vectores utilizando la función linspace. Por ejemplo:

>>k=linspace(0,1,6)
k=
0 0.2000 0.4000 0.6000 0.8000 1.0000
genera un vector linealmente espaciado de 0 a 1, conteniendo 6 elementos.
9. Manejo de polinomios.-
Matlab puede manejar muy bien los polinomios al representarlos mediante vectores.
Los coeficientes de un polinomio son los elementos del vector, en orden descendente de
potencias. Si queremos calcular las raíces del polinomio a continuación:
simplemente ingresamos:
>>p=[3 0 5 3 2 10];
>>roots(p)
Similarmente, si queremos evaluar el mismo polinomio en s =π, ingresamos:

>>polyval(p,pi)
Si queremos multiplicar dos polinomios, la función conv lo puede hacer. La

convolución es una operación matemática que opera sobre sucesiones hechas a base de
polinomios ordenados por orden de potencias, la sucesión resultante representa los
10
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
coeficientes del polinomio que se obtienen cuando se multiplican los polinomios

originales; por eso el nombre “conv”. Ejecute los siguientes comandos:
>>roots(p)
>>q=[ 1 6 11 6];
>>roots(q)
>>pq=conv(p,q)
>>roots(pq)
10. Funciones incorporadas del Matlab
Muchas funciones que hasta ahora se han usado, tales como sqrt y sin son
funciones incorporadas del Matlab. La Tabla 2 lista algunas de las funciones más
usadas. La creaciones funciones definidas por el usuario es vista al detalle en el ítem 16.
Tabla 2 Funciones matemáticas comúnmente usadas en el Matlab

Función Sintaxis del Matlab
x
e exp(x)
√x sqrt(x)
ln x log(x)
log10 x log10(x)
cos x cos(x)
sin x sin(x)
tan x tan(x)
cos-1 x acos(x)
sin -1 x asin(x)
tan-1 x atan(x)
11. Guardando y recuperando las variables del workspace.-
Si se desea guardar una sesión de Matlab para uso posterior, se deben usar los
comandos save y load. Teclear save hace que el Matlab guarde las variables de la
ventana de variables, esto es los nombres de las variables, sus tamaños, y sus valores, en
un archivo binario llamado matlab.mat, que el Matlab puede leer. Para recuperar las
variables de la ventana de variables, teclear load. Luego se puede continuar la sesión
como anteriormente.
Para guardar las variables de la ventana de variables con otro nombre, teclear save
‘nombre de archivo’. Si el archivo guardado contiene las variables A, B y C,
luego cargando el archivo con load ‘nombre de archivo’ se posicionan
dichas variables en la ventana de comandos, y de existir algunas variables con nombres
similares, éstas son reemplazadas.
Para guardar solo unas cuantas variables, digamos var1 y var2, teclear save
‘nombre de archivo’ var1 var2. Para recuperar var1 y var2 solo es
necesario teclear load ‘nombre de archivo’.
11
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
12. Modos de trabajo.-
Matlab permite trabajar de dos maneras distintas:

 Mediante la introducción directa de comandos.- Tecleando comandos desde la
ventana principal de Matlab podemos realizar operaciones paso a paso. Será el
método de trabajo a emplear para hacer pruebas o bien para operaciones
sencillas no repetitivas.
 Mediante la creación de programas (*.m) guardados en un archivo script.- La
misma secuencia de comandos que podríamos introducir desde la ventana
principal puede escribirse en un archivo, que debe tener terminación ‘.m’ y debe
ser ejecutado posteriormente desde la ventana de comandos sencillamente
tecleando el nombre del archivo.
Matlab usa dos tipos de archivos *.m; archivos script o archivos función.
13. Creando y usando un script.-
El símbolo % designa un comentario, que no es ejecutado en Matlab. Los comentarios

son usados con el propósito de documentar el archivo. Matlab ignora todo lo que está a
la derecha del símbolo %.
Por ejemplo:
>>%Este es un comentario
>>x=2+3 % Luego es
x=5
Nótese que la porción de la línea antes del % es ejecutada.
A continuación se muestra un ejemplo simple de cómo crear, guardar y correr un

archivo script usando el Editor/Depurador del Matlab.
Con la opción File->New->Script o bien con el icono New script (Ctrl+N) abrir el
Editor/Depurador de código Matlab, ver Figura 2. Tipear en el archivo abierto lo
siguiente:
% Program Example_1.m
% This program computes the cosine of
% the square root and displays the result.
x = sqrt(13:3:25);
y = cos(x)
Una vez concluida la edición, seleccionar File->Save. Reemplazar el nombre por

defecto (Untitled) con el nombre Example_1, y dar click en Save. El archivo será
guardado con la extensión *.m en la carpeta actual del navegador de Matlab.
Una vez guardado el archivo teclear Example_1 en la ventana de comandos para
ejecutar el programa.
>>Example_1
La Figura 2 muestra una pantalla que contiene el resultado de lo que se muestra en la

ventana de comandos y el editor/depurador de Matlab abierto para el script del ejemplo.
12
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Figura 2. La ventana de comandos del Matlab con el Editor/Depurador del script

abierto
Recordar que un script (o variable) no puede tener el mismo nombre de un comando o

función de Matlab. Usar el comando exist para verificar que el nombre que se le
quiere dar al script o variable no existe ya como función, comando o archivo; por
ejemplo al teclear exist(‘example_1’), el resultado será 1 de existir la variable,
2 de existir el script y 5 de existir la función de Matlab, y 0 de no existir. Teclear help
exist para más información.
Recordar también que un script no puede tener un nombre con espacios ni guiones
medios.
Ejemplo:
El siguiente ejemplo muestra un archivo script para el cálculo de la velocidad de un

objeto en caída libre, con velocidad inicial igual a cero.
% Programa Velocidad_CaidaLibre.m: grafica la velocidad de

% un objeto en caida libre.
% Creado el 01/03/2009 por W. Palm III
%
% Variables de entrada:
% tfinal = tiempo final (en segundos)
%
% Variables de salida:
13
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
% t = arreglo de tiempos en los que la velocidad es

% calculada (segundos)
% v = arreglo de velocidades (metros/segundo)
%
% Valor del parámetro:
g = 9.81; % Aceleración in SI units
%
% Sección de entrada:
tfinal = input(‘Introducir el tiempo final en segundos:’);
%
% Calculation section:
dt = tfinal/500;
t = 0:dt:tfinal; % Crea un arreglo de 501 valores de tiempo.
v = g*t;
%
% Sección de salida:
disp(‘La velocidad final es:’)
disp(v(lenght(t))
plot(t,v),xlabel(‘Tiempo (segundos)’),ylabel(‘Velocidad …
metros/segundo)’
Después de crear el script, se guarda con el nombre Velocidad_CaidaLibre.m.

Para ejecutarlo, escribir Velocidad_CaidaLibre en la línea de comandos. A
continuación se pedirá introducir el valor de tfinal. Una vez introducido el valor presionar
Enter, el resultado es la velocidad final mostrada en la línea de comandos y el gráfico
de la velocidad vs tiempo mostrado en una nueva ventana.
Si analizamos al detalle el programa Velocidad_CaidaLibre, encontraremos la

estructura sugerida para un script, como es:
 Sección de comentarios (nombre del programa, fecha de creación, nombre de los

creadores, definiciones de nombres de variables, etc.).
 Sección de entrada: en esta sección se colocan los datos de entradas o las
funciones de entrada que facilitan el ingreso de datos. Incluir comentarios como
sea necesario.
 Sección de cálculos: poner los cálculos en esta sección. Incluir comentarios de
ser necesario.
 Sección de salida: en esta sección poner las funciones necesarias para entregar
las salidas en la forma requerida.
La creación de una función de Matlab se verá con detalle en el ítem 16, Creación de
funciones definidas por el usuario.
14
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
14. Facilidades para la programación en Matlab.-
En comparación con otros lenguajes de programación, Matlab ofrece muchas

facilidades para el usuario. Básicamente, cabe destacar:
 Elección automática del tipo de las variables

 Dimensionamiento automático de las matrices
 Posibilidad de manejar números complejos de modo intuitivo
 Posibilidad de funcionamiento en modo interpretado (chequeo de sentencias)
 Entorno de depuración integrado
15. Sentencias de control en Matlab.-
Se muestra a continuación la sintaxis de las principales sentencias de control de Matlab:
 Bucles:
for variable = expresion

sentencias
end
while expresión
sentencias
end
 Sentencia condicional if/else/elseif:
if expresión
sentencias
elseif expresión
sentencias
elseif expresión
sentencias
else
sentencias
end
Nota: las claúsulas else y elseif no son necesarias.
16. Creación de funciones definidas por el usuario.-
Deseamos crear una función de Matlab que, a partir de una matriz dada, genere una
matriz cuadrada añadiendo filas o columnas de ceros, según sea necesario. La función
se llamará cuadra y se guardará en el archivo cuadra.m (mismo nombre que el nombre
de la función creada). Con la opción File->New->Function se abre el editor/depurador
de código Matlab, similar a la Figura 2, pero que ya trae embebida la notación
correspondiente, con las palabras claves: function y end.
15
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
El código de nuestra función será el siguiente:
%convierte una matriz en cuadrada añadiendo ceros

function b=cuadra(a)
b=a; %copia matriz entrada
[x,y]=size(b);
if x>y
b(:,y+1:x)=0; %añade columnas
elseif y>x
b(x+1:y,:) =0; %añade filas
end
Si analizamos un poco en detalle este código, encontraremos elementos que

necesariamente deberemos incluir en cualquier función que deseemos crear:
 Línea de comentario: es importante que la primera línea de una función contenga

un texto explicativo, será la línea que se muestre al solicitar ayuda. Debe
comenzar con el símbolo %.
 Declaración de la función: es obligatoria en cualquier función, especifica los
parámetros de entrada y salida. En el ejemplo:
function b = inversa(a)
Palabra clave Parámetros de Nombre de la Parámetros de

salida función entrada
o Si hubiera habido más de un parámetro de entrada, se habrían separado

por comas en la declaración; por ejemplo:
function b = inversa (a1, a2)
o Y si hubiera habido más de un parámetro de salida, se habrían

introducido entre corchetes en la declaración; por ejemplo:
function [b1, b2] = inversa (a1, a2)
 Cuerpo de la función: contiene todas las operaciones que deseemos realizar.
Si hemos incluido la primera línea de comentario en nuestra función, al solicitar la

ayuda de la función que acabamos de crear debemos obtener un resultado como el
siguiente:
>> help cuadra

convierte una matriz en cuadrada añadiendo ceros
16
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
A continuación probaremos la función con una matriz cualquiera:

» a = [1 2; 3 4; 5 6]
a =
1 2
3 4
5 6
» b = cuadra(a)
b =
1 2 0
3 4 0
5 6 0
Vemos cómo se obtiene el resultado que esperábamos.
17. Representación gráfica de curvas.-
La construcción de gráficos en MATLAB es una más de las facilidades del sistema. A

través de comandos simples se puede obtener gráficos bidimensionales o
tridimensionales con cualquier tipo de escala y coordenada. Existe en MATLAB una
vasta biblioteca de comandos gráficos.
Algunos de los comandos para dibujar gráficos bidimensionales son los siguientes:
Dibujo de gráficas:
plot Dibujo lineal.

loglog Dibujar en escala loglog.
semilogx Dibujar en semilog.
semilogy Dibujar en semilog.
fill Diseñar polígono 2D.
polar Dibujar en coordenadas polares.
bar Gráfico de barras.
stem Secuencia discreta.
stairs Dibujar en grados.
hist Dibujar un histograma.
rose Dibujar un histograma en ángulos.
compass Dibujar en forma de flechas.
feather Dibujar en forma de pluma
fplot Dibujar una función.
comet Plotear con trayectoria de cometa.
ezplot Plotear una curva paramétrica
hold on/off Mantener los objetos existentes
Por ejemplo, escriba el siguiente archivo de instrucciones y muestre el gráfico

resultante:
close all
17
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
clear all
clc
%Definiendo los vectores de tiempo y las
%funciones de seno y coseno.
t=0:0.05:10;
y=sin(t);
z=cos(t);
%Graficando en una sola grafica ambas %curvas
figure(1)
plot(t,y,'o',t,z,'x')
grid
title('Graficas del seno y
coseno')
xlabel('Seg')
legend('y=seno(t)','z=coseno(t)')
%Graficando en una sola ventana las 2 %curvas
pero en diferentes
graficas
figure(2)
subplot(211)
plot(t,y)
title('Grafica del seno')
xlabel('seg')
ylabel('y=sin(t)')
Observe que el vector t es una partición del dominio 0≤ t ≤ 10 con paso 0.05, mientras
que y, z son vectores que dan los valores del seno y coseno en los puntos de partición.
El programa anterior nos manda a graficar dos funciones trigonométricas, las cuales
podemos verlas en las gráficas de la Figura 3.
La Tabla 3 resume los comandos de representación gráfica.
Tabla 3 Algunos comandos para ploteo en Matlab

Comando Descripción
[x,y]=ginput(n) Facilita que usando el mouse se obtengan n puntos de una
gráfica, y luego retorna las coordenadas x y y en el vector
x y y, que tienen longitud n
grid Pone mallado en el gráfico
gtext(‘texto’) Facilita la ubicación de texto con el mouse
plot(x,y) Genera una gráfico del arreglo y versus el arreglo x en
ejes rectilíneos
title(‘texto’) Pone texto en el título ubicado en la parte superior central
del gráfico
xlabel(‘texto’) Adiciona una etiqueta de texto al eje horizontal (abscisa)
ylabel(‘texto’) Adiciona una etiqueta de texto al eje vertical (ordenada)
18
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Figura 3. Graficas del seno y coseno
19
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Ploteando Gráficos Tridimensionales y Contornos
Estos son algunos comandos para realizar gráficos tridimensionales y contornos.
plot3 Dibujar en espacio 3D.

fill3 Diseñar polígono 3D.
comet3 Dibujar en 3D con trayectoria de cometa.
contour Dibujar contorno 2D.
contour3 Dibujar contorno 3D.
clabel Dibujar contorno con valores.
quiver Dibujar gradiente.
mesh Dibujar malla 3D.
meshc Combinación mesh/contour.
surf Dibujar una superficie 3D.
surfc Combinación surf/contour.
surfil Dibujar una superficie 3D con iluminación.
slice Dibujar visualización volumétrica.
cylinder Generar cilindro.
sphere Generar esfera.
Si escribimos las siguientes instrucciones podremos ver el siguiente gráfico resultante:
close all
clear all
clc
[X,Y] = meshgrid(-2:.1:2, -2:.1:2);
Z = X.* exp(-X.^2 - Y.^2);
mesh(X, Y, Z)
Figura 4. Grafica usando función meshgrid
20
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Respuesta en frecuencia pasa-baja y pasa-alta
A continuación se muestra un ejemplo que da como resultado la Figura 5. En este caso

muestra la respuesta en frecuencia de un filtro pasa-baja y un filtro pasa-alta, ambos de
primer orden. La variable de Laplace s en el dominio de la frecuencia es . La
frecuencia de corte en cada caso es 1/T = 20 rad s-1 = 3.18 Hz.
El script correspondiente se presenta a continuación.
close all
clear all
clc
T = 0.05; %constante de tiempo [s]
omega = logspace(0,8,100); %vector de frecuencias [rad/s]
H_LP = (T*j*omega+1).^(-1); %filtro pasa-baja
H_HP = 1-H_LP; %filtro pasa-alta
figure(1) % nombre de la figura

clf %limpia la figura actual
subplot(121) % subplot: Amplitud

loglog(omega,abs(H_LP),'-') %Amplitud, filtro pasa-baja
hold on
loglog(omega,abs(H_HP),'--') %Amplitud, filtro pasa-alta
loglog([1 1]/T, [0.01 10], ':') %línea constante de tiempo
text(1.1/T,0.02,'Constante de tiempo') %texto constante de
%tiempo
title('Respuesta en frecuencia') %título del subplot
xlabel('\omega [rad s^-1]') % etiqueta del eje-x
ylabel ('Amplitude [dB]') %etiqueta del eje-y
legend ('Pasa-baja', 'Pasa-alta') %leyenda en posición
%estándar
axis ([1 1e3 0.01 10]) %área visible
escala = -40:20:40;
set(gca,'ytick',10.^(escala/20)) %establecer
set(gca,'yticklabel',escala) %establecer
subplot(122) %subplot: Fase

semilogx(omega,angle(H_LP)*180/pi,'-') %Fase, filtro pasa-
%baja
hold on
semilogx(omega,angle(H_HP)*180/pi,'--') %Fase, filtro pasa-
%alta
grid on
xlabel('\omega [rad s^-1]') % etiqueta del eje-x
ylabel ('Fase [Grad]') % etiqueta del eje-y
axis ([1 1e3 -90 90]) %área visible
escala = -90:30:90;
set(gca,'ytick',escala) %establecer
set(gca,'yticklabel',escala) %establecer
21
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Figura 5. Respuesta en frecuencia, filtros pasa-baja y pasa-alta
Usando la función bode también se puede graficar respuestas en frecuencia. El script a

continuación muestra el uso de la función bode.
pasa_baja=tf([1],[0.05 1]);
pasa_alta=1-pasa_baja;
bode(pasa_baja,'b-',pasa_alta,'r--');
grid on;
Figura 6. Respuesta en frecuencia usando la función bode, filtros pasa-baja y pasa-alta

22
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
LOS PROCESOS DE DISEÑO DE INGENIERÍA Y RESOLUCIÓN DE

PROBLEMAS, Y SU RELACIÓN CON MATLAB
El proceso de diseño de ingeniería es el proceso creativo de identificar necesidades y

concebir una solución para satisfacer esas necesidades. Esta solución puede ser un
producto, una técnica, una estructura, un proyecto, un método, o alguna otra cosa
dependiendo del problema.
La resolución de problemas es el proceso de determinar la mejor acción posible a seguir
en una situación dada. La naturaleza de los problemas que los ingenieros deben resolver
varía dependiendo de las ramas de la ingeniería. Debido a la diversidad de problemas,
no hay una lista de procedimientos universal que pueda servir para todos los problemas.
Sin embargo, la Tabla 4 resume de manera simple la mayoría de los pasos del método
de diseño que los ingenieros usan. Cabe destacar también que el proceso de diseño es un
proceso iterativo.
23
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Tabla 4. Pasos para resolver problemas y su relación con el proceso de diseño de

ingeniería
PROCESO DE RESOLUCIÓN DE DESCRIPCION
DISEÑO DE PROBLEMAS
INGENIERÌA
1. Identificar el problema
FORMULACIÓN DEL claramente y en
PROBLEMA
términos generales.
2. Colectar la información
necesaria y datos
necesarios para resolver
el problema.
3. Buscar soluciones Superar obstáculos para pensamiento
DISEÑO creativas. creativo.
CONCEPTUAL
4. Elegir un criterio para Incluir aspectos financieros.
evaluar alternativas.
5. Moverse de ideas a Los diseños preliminares evolucionan a
DISEÑO diseños preliminares través del análisis y síntesis.
PRELIMINAR
(incluyendo modelado). Los modelos facilitan el proceso de diseño.
6. Descartar las Un modelo simplifica un sistema o proceso
soluciones (diseños) tal que pueda ser mejor estudiado, entendido,
menos prometedores y usado en un diseño.
usando evaluaciones Modelos matemáticos: Una o más
simples. ecuaciones que describen un sistema físico.
Modelos de simulación por computadora:
Permiten a los ingenieros examinar sistemas
complejos. Tales modelos pueden incorporar
modelos matemáticos. Tales modelos pueden
estar sujetos a diferentes condiciones de
7. Descartar operación.
DISEÑO progresivamente,
DETALLADO Modelos físicos: Representan el método más
usando evaluaciones antiguo de diseño. Tienen la ventaja que
detalladas. permiten a l ingeniero estudiar un sistema
con poca o casi nada de conocimiento previo
de su comportamiento. Usualmente son
hechos a escala.
Se pueden modelar sistemas existentes o
propuestos.
8. Evaluar y seleccionar la Uso de prototipos para probar la operación
opción preferida luego del diseño. Modelos escala pueden también
de una evaluación ser usados. Modelos matemáticos y
detallada de la lista simulaciones por computadora no son
corta. exactos para entender las complejidades
inherentes.
9. Preparar reportes, Dibujos de ingeniería (planos).
planes y Comunicaciones escritas (memorándums).
especificaciones Comunicación oral.
(planificación de Programación y planificaciones de un
proyectos). proyecto de diseño.
10. Implementar el diseño Proceso de producir o construir un

IMPLEMENTACIÓN (implementación de dispositivo físico, producto o sistema.
proyectos).
24
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
En el caso del diseño de sistemas de control automático basados en modelos, se pueden

usar los pasos del proceso de diseño en ingeniería antes destacados en la Tabla 4.
Siendo que este diseño depende estrictamente del modelamiento del sistema a controlar,
la Tabla 5 muestra un resumen del proceso de modelado.
Tabla 5. Pasos para el proceso de modelado
1. Formular el modelo. ¿Qué preguntas se desean responder?

2. Construir las ecuaciones. Dibujar un bosquejo (DCL) y etiquetar las
variables necesarias.
Determinar qué principios fundamentales son
aplicables
3. Simplificar las ecuaciones. Lo suficiente como para obtener la información
requerida. Enunciar las suposiciones hechas.
4. Resolver las ecuaciones Simulación computacional vía cálculo numérico
– uso de Matlab (u otros)
Si se resuelve el problema con un programa, chequear
a mano los primero resultados de una versión simple
del problema. Verificar las dimensiones y unidades e
imprimir los resultados de pasos intermedios.
5. Evaluar e interpretar Verificación del modelo (análisis) – uso de
Matlab (u otros)
Llevar a cabo una “verificación de la realidad” de la
respuesta obtenida. ¿Tiene sentido? Estimar los rangos
del resultado esperado y compararlo con la respuesta.
No enunciar la respuesta con gran precisión a menos
que se justifique por lo siguiente:
• La precisión de la información dada.
• Las supuestos simplificadores-
• Los requerimientos del problema.
Interpretar la matemática. Si la matemática produce
múltiples respuestas, no descarte algunas sin
considerar lo que significan. Las matemáticas tratan de
decir algo, y muchas veces se pierde la oportunidad de
descubrir más sobre el problema.
6. Si la validación del modelo no
llega a resultados esperados,
retornar al paso 3.
7. Diseñar el controlador Uso de Matlab (u otros)
25
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
HERRAMIENTAS DE MATLAB PARA ANÁLISIS Y DISEÑO DE SISTEMAS

DE CONTROL
Matlab cuenta con un amplio grupo de funciones que resultan muy útiles tanto para el
análisis de sistemas lineales (y no lineales) como para el diseño de sistemas de control.
Muchas de las tareas de análisis y diseño asociadas a dichos sistemas implican
operaciones de matrices, aritmética de números complejos, determinación de raíces,
conversiones de modelos y ploteo de funciones complicadas. Matlab fue diseñado para
facilitar la realización de muchas de estas operaciones.
Esta parte del laboratorio se ha de dividir en dos partes:

 fundamentos: que comprende el modelado de sistemas lineales y representación
de modelos en Matlab, y
 procedimiento: que comprende la creación/conversión/operaciones de modelos
en Matlab, herramientas de análisis de modelos en Matlab (funciones para
análisis y para simulaciones de respuesta en el tiempo y la frecuencia), y otras
herramientas de análisis y diseño (ltiview y sisotool).
1. Fundamentos.-
1.1. Modelado de Sistemas.-
El diseño de sistemas de control empieza con el modelamiento de sistemas reales. Estos

modelos, que son representaciones matemáticas de cosas tales como procesos químicos,
maquinaria y circuitos eléctricos, entre otros, sirven para estudiar la respuesta dinámica
de los sistemas reales. Algunas técnicas matemáticas empleadas por Matlab para
analizar estos sistemas suponen, procesos que son físicamente realizables, lineales e
invariantes en el tiempo (LTI, linear time invariant). Así los modelos que los
representan están sujetos a restricciones similares. En algunos casos los sistemas no
lineales pueden bien aproximarse con funciones LTI; ya en los casos de gran no
linealidad, Matlab también brinda funciones apropiadas. En el desarrollo de los
laboratorios nos restringiremos a trabajar con sistemas LTI.
Dado que los sistemas LTI pueden ser representados usando modelos en la forma de
funciones de transferencia o ecuaciones de espacio de estados, Matlab trabaja con
dichos modelos, haciendo posible el empleo de técnicas tanto clásicas como modernas
en el análisis y diseño de sistemas de control. Cualquiera de estas formas de modelos se
puede expresar en forma de tiempo continuo (analógicas) o de tiempo discreto
(digitales). Las funciones de transferencia se pueden expresar como un cociente de
polinomios o una de sus dos formas factorizadas: cero-polo-ganancia o fracciones
parciales. Los modelos de sistemas de la forma espacio estados son idóneos para Matlab
porque son una expresión basada en matrices.
Para ilustrar las diversas formas en las que podemos formular modelos, usaremos el
ejemplo clásico de un sistema resorte-masa-amortiguador, el cual se muestra en la
Figura 7. En este sistema tres fuerzas actúan sobre una masa m: una fuerza de entrada
que depende del tiempo u(t), un resorte con constante de rigidez k y un amortiguador
viscoso con constante de amortiguación b. La posición de la masa en función del tiempo
26
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
está representada por x(t). Conectamos a la masa un potenciómetro de medición que

proporciona un voltaje de salida y(t) proporcional a x(t), con constante de
proporcionalidad p. La ecuación de movimiento de la masa m está dada por la ecuación
diferencial de segundo orden:
y la ecuación para el potenciómetro es:
La ecuación para el potenciómetro es un ejemplo de situación en la que la variable que

representa la dinámica del sistema (x en este caso) no es variable de salida (y en este
caso). Juntas estas dos ecuaciones proporcionan un modelo matemático del
comportamiento dinámico del sistema. Si integramos la ecuación de movimiento
podremos determinar el movimiento de la masa en función del tiempo. Es por ello que
un análisis así se denomina análisis en el dominio del tiempo.
Figura 7. Sistema resorte-masa-amortiguador
1.2. Representación de Modelos usando Funciones de Transferencia.-
El análisis de los sistemas LTI con frecuencia implica determinar ciertas propiedades
dinámicas como estabilidad y respuesta en frecuencia, que no son fáciles de determinar
usando análisis en el dominio del tiempo. Para estos análisis, muchas veces hacemos
uso de la transformada de Laplace, así se aplica la transformada de Laplace a la
ecuación en el dominio de tiempo para luego poder analizar el sistema en el dominio de
la frecuencia.
La transformada de Laplace de nuestra ecuación diferencial del resorte-masa-

amortiguador anterior es:
donde s es un variable compleja (σ + jω ) llamada variable de Laplace. Esta ecuación se

debe reacomodar para dar una función de transferencia H(s), que relaciona el
movimiento de salida del sistema X(s) con la fuerza de entrada U(s):
la función de transferencia del potenciómetro es simplemente:
27
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Con frecuencia se usan diagramas de bloques para mostrar la relación entre las
funciones de transferencia y las variables de entrada y salida de un sistema.
Suponiendo para nuestro ejemplo de resorte-masa-amortiguador que m=1, b=4, k=3 y

p=10, el diagrama de bloques de la Figura 8 representa el sistema. El primer bloque
representa el modelo de la planta, que es parte del sistema que se controla, y el segundo
bloque representa el modelo de medición.
Figura 8. Diagrama de bloques: modelo de la planta y modelo de medición
También podemos combinar los bloques en un solo bloque de modelo del sistema como
se muestra en la Figura 9.
Figura 9. Diagrama de bloques
Esta función de transferencia se expresa como un cociente de dos polinomios, donde el

polinomio del numerador es simplemente un escalar. En el caso de sistemas que tienen
una sola entrada y una sola salida (SISO, single-input single-output), la forma de
escribir funciones de transferencia es:
1.3. Representación de Modelos usando la Forma Cero-Polo-Ganancia.-
Muchas veces el numerador y el denominador de una función de transferencia se

factorizan para obtener la forma cero-polo-ganancia, que es:
Por ejemplo, la forma cero-polo-ganancia de la función de transferencia:
28
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
es:
Esta forma es de especial utilidad, pues muestra directamente las raíces de los
polinomios del numerador y del denominador (los ceros y los polos de sistema
respectivamente).
Por último, las funciones de transferencia también pueden escribirse en la forma de
expansión de fracciones parciales, o residuo, que es:
Esta forma es útil para determinar la transformada inversa de Laplace y para diseñar
ciertos tipos de filtros.
1.4. Representación de Modelos usando la Forma Espacio de Estados.-
Básicamente consiste en expresar una ecuación diferencial de orden superior como un

conjunto de ecuaciones diferenciales de primer orden acopladas. Usando nuestro
ejemplo anterior de resorte- masa-amortiguador cuya ecuación de movimiento era:
Podemos definir:
A continuación rescribimos la ecuación diferencial de segundo orden como un conjunto

de ecuaciones diferenciales acopladas:
y la ecuación de medición como:
Usando notación de matrices, este modelo de sistema puede escribirse como un modelo
de espacio de estados:
donde representa el vector de estados, el vector de entradas y el vector de salidas.

Las matrices y son definidas apropiadamente. Para el ejemplo resulta:
29
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
2. Procedimiento.-
2.1. Creación de Modelos en Matlab
2.1.1. Funciones de Transferencia en Tiempo Continuo.-

La función tf crea funciones de transferencia. La función tf necesita dos vectores,
uno conteniendo los coeficientes del polinomio numerador tomados en orden
descendente y otro conteniendo similar información para el polinomio denominador.
Como ejemplo creemos la siguiente función de transferencia.
En el script:
K0=2; T0=4;
num0=[K0 0]; den0=[T0 1];
H0=tf(num0,den0);
En la línea de comandos, para mostrar :

>>H0
H0 =
2s
-----
4s + 1
Continuous-time transfer function.
Un modelo LTI puede contener un retardo de tiempo, como en el siguiente modelo:
Este sistema es creado por:
K0=2; T0=4;
num0=[K0 0]; den0=[T0 1];
H0=tf(num0,den0);
Td=1;
Hd=tf(num0,den0,'InputDelay',Td)
Excepto por el término de retardo de tiempo, Hd es igual a H0 definido anteriormente.

>>Hd
Hd =
2s
exp(-s) * -----
4s + 1
30
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Supongamos que se ha creado una función de transferencia y se desea obtener

información detallada acerca del modelo. La función tfdata muestra la información,
que está almacenada en los arreglos.
Como ejemplo, las siguientes expresiones muestran los polinomios conteniendo los
coeficientes correspondientes al numerador y el denominador de la función de
transferencia Hd(s) creada anteriormente:
En el script:
[numHd,denHd,Ts]=tfdata(Hd,'v')
Aqui, Ts es el periodo de muestreo, el cual es cero para modelos en tiempo continuo

pero diferente de cero para modelos en tiempo discreto.
>> [numHd,denHd,Ts]=tfdata(Hd,'v')
numHd =
0 1
denHd =
1 1
Ts =
0
Otra forma de crear funciones de transferencia es definiendo la variable s usando la

función tf, y escribiendo la función de transferencia directamente como un cociente de
polinomios de s; así en el script:
s = tf('s');
H = exp(-s)*(2*s)/(4*s+1);
>> H
H =
2 s
exp(-1*s) * -------
4 s + 1
Para más información sobre funciones de transferencia, en la línea de comandos,

teclear:
>> help tf
2.1.2. Forma Cero-Polo-Ganancia en Tiempo Continuo.-

La función zpk crea modelos cero-polo-ganancia, se deben dar como entradas el vector
de ceros, polos y la ganancia.
En el script:
H=zpk([-6 1 1],[-5 1],3);
31
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
>> H
H =
3 (s+6) (s-1)^2
---------------
(s+5) (s-1)
Continuous-time zero/pole/gain model.
También se puede usar la variable s para definir el modelo como una función racional
en s.
En el script:
s=zpk('s')
H=2*1/(s-1)*(s+2)
>> s =
s
H =
2 (s+2)
-------
(s-1)
2.1.3. Modelo en Espacio Estado Continuo.-

La función ss crea modelos en espacio estado lineal de la forma:
como se ilustra en el siguiente ejemplo. Dado el siguiente modelo en espacio estado

lineal:
Este modelo es creado por:
A=[0,1;-4,-2]; B=[0;2]; C=[1,0]; D=[0];

ss1=ss(A,B,C,D);

>> ss1
ss1 =
32
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
a =
x1 x2
x1 0 1
x2 -4 -2
b =
u1
x1 0
x2 2
c =
x1 x2
y1 1 0
d =
u1
y1 0
Continuous-time state-space model.
a, b, c, y d, son nombres por defecto, son usados únicamente con el objetivo de mostrar
los datos, ellos no existen en el workspace de Matlab. Para obtener los parámetros del
sistema y darles nombres específicos, en el script:
[A1,B1,C1,D1,Ts]=ssdata(ss1)
La respuesta de Matlab será:
>> [A1,B1,C1,D1,Ts]=ssdata(ss1)
A1 =
0 1
-4 -2
B1 =
0
2
C1 =
1 0
D1 =
0
Ts =
0
33
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
2.2. Conversiones entre Modelos en Matlab
2.2.1. Conversión de Modelos de Espacio Estados a Función de Transferencia.-
La función tf también convierte modelos en espacio estado a la correspondiente

función de transferencia de acuerdo a la fórmula:
En el siguiente ejemplo un modelo continuo en espacio estado es transformado en

la correspondiente función de transferencia continua:
A=-1; B=2; C=3; D=4;

sscont1=ss(A,B,C,D);
Hcont1=tf(sscont1)
La respuesta de Matlab es:
Hcont1 =
4 s + 10
--------
s + 1
Ver también ss2tf.
2.2.2. Conversión de Función de Transferencia a Modelo de Espacio Estados.-
La función ss convierte una función de transferencia a un modelo en espacio estado.

Pero esta conversión no es única, dado que hay un infinito número de modelos en
espacio estado, los cuales tienen la misma función de transferencia. Entonces, ss
escoge una de esas realizaciones, llamada forma canónica controlable.
Ver también tf2ss.
2.2.3. Conversión de la Función de Transferencia Polinómica a Fracciones

Parciales.
La función residue determina los valores de los vectores r, p, k que contienen

los valores de residuo, los polos y los términos directos de la expansión de fracciones
parciales. Las entradas son los coeficientes de los polinomios B, A del numerador y
denominador de la función de transferencia, respectivamente.
Como ejemplo realicemos la expansión de fracciones parciales de esta función de
transferencia de sistema:
34
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
se puede calcular con estas instrucciones:
B=[10];
A=[1,4,3];
[r,p,k]=residue(B,A);
La respuesta de Matlab estará dada por:
>> [r,p,k]=residue(B,A)
r =
-5
5
p =
-3
-1
k =
[]
Por tanto, la expansión en fracciones parciales de nuestra función de transferencia

del sistema es:
2.2.4. Conversión de la Función de Transferencia Polinómica a Función de

Transferencia Cero-Polo-Ganancia.-
La función tf2zp determina los ceros(z), polos (p) y la ganancia correspondiente

(k) de la función de transferencia cero-polo-ganancia usando los coeficientes en orden
descendente de potencias de s, del numerador y denominador de la función de
transferencia polinómica que se va a convertir.
La función de transferencia polinómica:
puede convertirse en una función de transferencia cero-polo-ganancia usando

estas instrucciones:
num=[10];
den=[1,4,3];
[z,p,k]=tf2zp(num,den);
z =
Empty matrix: 0-by-1
p =
-3
35
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
-1
k =
10
Por tanto, la función de transferencia cero-polo-ganancia es: sistema es:
2.2.5. Conversión de la Función de Transferencia Cero-Polo-Ganancia a Función

de Transferencia Polinómica.-
La función zp2tf determina los vectores num y den que contienen los coeficientes,
en orden descendente de potencias de s, del numerador y denominador de la función de
transferencia polinómica, p es un vector columna que contiene las posiciones de polos
de la función de transferencia cero-polo-ganancia, z es una matriz que contiene las
posiciones de ceros correspondientes, con una columna para cada salida de un sistema
de múltiples salida, k es la ganancia de la función de transferencia cero-polo-ganancia.
La función de transferencia cero-polo-ganancia:
puede convertirse en una función de transferencia polinómica usando estas

instrucciones:
z=[]
p=[-3 -1]’;
k=10;
[num,den]=zp2tf(z,p,k);
num =
0 0 10
den =
1 4 3
Por tanto, la función de transferencia polinómica del sistema es:
En resumen Matlab ofrece las siguientes funciones de conversión:
TF → ZPK → SS →
TF:[num,den]= zp2tf(z,p,k) ss2tf(A,B,C,D,iu)
ZPK:[z,p,k]= tf2zp(num,den) ss2zp(A,B,C,D,iu)
SS:[A,B,C,D]= tf2ss(num,den) zp2ss(z,p,k)
36
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
2.3. Operaciones con Modelos (en serie, paralelo o realimentados).-
Un modelo puede ser representado por un bloque con entradas y salidas ya sea
conteniendo una función de transferencia o un modelo en espacio estado dentro de él.
Las funciones series, parallel, y feedback pueden ser usadas para realizar
manipulaciones básicas de bloques como se mostrara a continuación.
Como ejemplo asuma dadas las siguientes funciones de transferencia:
Primero creemos los dos sistemas anteriores:
k1=1; k2=2; k3=3; k4=4;

Ha=tf(k1,[1,k2]);
Hb=tf(k3,[1,k4]);
a. Conexión en Serie (Producto).-
Conectemos Ha(s) y Hb(s) en serie, eso significa que Hser(s) es Ha(s)*Hb(s):
Hser=series(Ha,Hb)
La respuesta de Matlab:
Hser =
3
-------------
s^2 + 6 s + 8
b. Conexión en Paralelo (Suma).-
37
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
A continuación, Ha(s) y Hb(s) son conectados en paralelo, lo cual significa que

Hpar(s) es Ha(s) + Hb(s):
Hpar=parallel(Ha,Hb)
La respuesta en Matlab es:
Hpar=
4 s + 10
-------------
s^2 + 6 s + 8
c. Conexión usando Lazo de realimentación.-
Finalmente, Ha(s) y Hb(s) son conectados en un lazo realimentado negativo con Ha(s) en
el lazo directo y Hb(s) en el lazo de realimentación:
feedbsign=-1; Hfeedb=feedback(Ha,Hb,feedbsign)
Feedbsign es el signo de la realimentación, y lo establecemos como -1 o 1. La función

de transferencia Hfeedb(s) está dada por:
La respuesta de Matlab está dada por:
Hfeedb =
s + 4
--------------
s^2 + 6 s + 11
38
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
2.4. Herramientas de Análisis de Modelos LTI.-
Como punto de partida de esta sección definamos una función de transferencia continua,
H1c(s). Tomaremos H1c(s) como:
Y creamos H1c(s) con:
n1=[1,0.5]; d1=[1,2,4];
H1c=tf(n1,d1);
>> H1c
H1c =
s + 0.5
-------------
s^2 + 2 s + 4
2.4.1. Análisis de la dinámica del modelo. –
Aún sin conocer las respuestas a diversas señales de prueba es posible analizar diversas
propiedades de un sistema dinámico, tales como estabilidad, frecuencias de resonancia,
y características del estado estacionario y transitorio.
a. Amplificación del estado estacionario.-
El comando dcgain permite determinar la ganancia de un sistema cuando s=0. Los

sistemas con comportamiento integral dominante tienen una ganancia infinita.
ganancia_dc=dcgain(H1c);
>> ganancia_dc
ganancia_dc =
0.1250
b. Ancho de banda.-
Otro valor interesante de un sistema dinámico es su ancho de banda, que se define como
la primera frecuencia (en rad/s) en la que la ganancia cae por debajo del 70.79% (-3 dB)
de su valor en estado estacionario (ganancia DC). El comando en Matlab es
bandwidth.
ancho_banda=bandwidth(H1c);
39
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
>> ancho_banda
ancho_banda =
11.4812
c. Polos, Autovalores y Ceros.-
Podemos calcular los polos de un modelo LTI con el siguiente comando:
p=pole(H1c)
La respuesta Matlab es:
p=
-1.0000 + 1.7321i
-1.0000 - 1.7321i
Para un modelo en espacio estado análogamente podemos calcular los autovalores

con eig.
[A,B,C,D]=ssdata(H1c);
p0=eig(A);
La respuesta Matlab es:
p0 =
-1.0000 + 1.7321i
-1.0000 - 1.7321i
tzero calcula ceros. Aquí se muestra un ejemplo basado en H1c(s):
z=tzero(H1c)

z=
-0.5000
d. Distribución de polos y ceros.-
Con pzmap podemos calcular y graficar tanto los polos y los ceros. Omitiendo los
parámetros de retorno solamente grafica los polos y los ceros en el plano complejo:
[pol,zer]=pzmap(H1c); %retorna los polos y ceros de H1c

figure(1)
pzmap(H1c); %grafica los polos y ceros de H1c
40
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Figura 10. Grafica de ubicación de polos y ceros en el plano complejo generada usando
la función pzmap
Los polos y autovalores siempre son números reales y/o complejos conjugados.
e. Frecuencias naturales y amortiguamiento.-
El comando damp calcula el factor de amortiguamiento relativo ζ, y la frecuencia

natural no amortiguada, ω0, para los polos del sistema. Se sabe que dichos polos están
dados por las raíces de la ecuación característica (sistema de 2do orden).
α(s)=s2 + 2ζω0s + ω02
Aquí tenemos un ejemplo:
damp(H1c)
Eigenvalue Damping Freq. (rad/s)

-1.00e+000 + 1.73e+000i 5.00e-001 2.00e+000
-1.00e+000 - 1.73e+000i 5.00e-001 2.00e+000
2.4.2. Respuesta en el dominio del tiempo.-
Como regla general estamos particularmente interesados en las respuestas a ciertas

señales de entrada, tales como impulso unitario o escalón unitario. El toolbox de diseño
y análisis de sistemas de control del Matlab ofrece, entre otras, las siguientes funciones:
respuesta a las condiciones iniciales (initial), respuesta impulsiva (impulse),
respuesta al escalón unitario (step). Ciertas señales de entrada se pueden generar con
gensig, y lsim es una función más general que calcula la respuesta en el tiempo para
señales arbitrarias.
41
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
a. Respuesta a las condiciones iniciales.-
La respuesta a las condiciones iniciales describe el comportamiento del sistema para

determinados valores iniciales del vector de estados xo y se conoce como respuesta libre.
Se calcula usando el comando initial:
H1c_ss=ss(H1c);
Xo=[0 1];
figure(1)
initial(H1c_ss,Xo); %grafica la respuesta en el tiempo a las
%condiciones iniciales Xo
[y,t,x]= initial(H1c_ss,Xo); %permite obtener los vectores
%correspondientes a la respuesta libre del sistema
Figura 11. Grafica de la respuesta a las condiciones iniciales usando la función

initial
b. Respuesta al impulso unitario.-
La respuesta al impulso de un sistema se define como la respuesta a la excitación del

sistema con una entrada Dirac δ(t ). El comando impulse simula la respuesta al mpulso
unitario en Matlab:
Tf=10;
figure(1)
impulse(H1c,Tf); %grafica la respuesta al impulso unitario
[y,t,x]= impulse(H1c); %permite obtener los vectores
%correspondientes a la respuesta impulsiva del sistema
42
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Figura 12. Grafica de la respuesta al impulso unitario usando la función impulse
c. Respuesta al escalón unitario.-
Podemos simular la respuesta escalón de uno o varios modelos LTI con step. La
entrada escalón es entonces unitaria (la altura del escalón es uno). Simulemos H1c desde
t=0 hasta Tf=10 segundos:
Tf=10;
step(H1c,Tf)
Figura 13. Grafica de la respuesta al escalón unitario usando la función step
También podemos almacenar la respuesta simulada, y, i el vector de tiempo, t, mediante

el uso de argumentos de retorno (izquierda):
43
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Tf=10;
[y,t]=step(H1d,Tf);
En este caso no se muestra ningún grafico en pantalla.
d. Respuesta a cualquier señal de entrada.-
lsim es una función mas general de simulación ya que acepta una señal de entrada
cualquiera, no necesariamente un salto o un impulso. Para generar la señal de entrada
podemos usar gensig, que produce una onda senoidal, o una onda cuadrada, o pulsos
periódicos.
Como ejemplo simulemos H1c con una entrada sinusoidal, u, con un periodo Tp=0.5,
tiempo final Tf=10, y un paso Tstep=0.01:
Tp=0.5; Tf=10; Tstep=0.01;

[u,t]=gensig('sin',Tp,Tf,Tstep);
figure(1)
lsim(H1c,u,t);
Figura 14. Grafica de la respuesta a una entrada sinusoidal usando las funciones
gensig y lsim
Otros generadores de señal son square, sawtooth, and stepfun.
En resumen Matlab ofrece los siguientes comandos para simular la respuesta de un

sistema en el dominio del tiempo:
initial(sys,xo,t) Respuesta a las condiciones iniciales

impulse(sys,t) Respuesta al impulso unitario
step(sys,t) Respuesta al escalón unitario
lsim(sys,u,t,xo) Respuesta a una entrada arbitraria
gensig(typ,tau) Generador de señales
44
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
2.4.3. Respuesta en el dominio de la frecuencia.-
Es importante para el ingeniero de control entender el comportamiento del sistema en el

dominio de la frecuencia: a menudo las señales de testeo son sinusoidales o se
desconocen los parámetros del sistema. Analizando la respuesta en frecuencia se puede
determinar diversas propiedades del sistema dependientes de la frecuencia: condiciones
estacionarias, ancho de banda, márgenes de amplitud y fase, estabilidad en lazo cerrado.
a. Cálculo de la respuesta en frecuencia.-
Para cálculo rápido de las respuestas en frecuencias se pueden usar los comandos
evalfr y freqresp. Para calcular la respuesta en frecuencia de un sistema para una
única frecuencia se usa evalfr. El comando freqresp permite calcular la respuesta
en frecuencia para varias frecuencias.
Del siguiente script:
sys=tf([3,-1],[-2 1 1])
w=[-j, -2-j,-2+j]
H1=[evalfr(sys,w(1));evalfr(sys,w(2));evalfr(sys,w(3))]
H2=freqresp(sys,w)
En Matlab se obtiene:
>>
sys =
-3 s + 1
-------------
2 s^2 - s - 1
w =
0 - 1.0000i -2.0000 - 1.0000i -2.0000 + 1.0000i
H1 =
0 - 1.0000i
0.5846 - 0.3231i
0.5846 + 0.3231i
H2(:,:,1) =
0 - 1.0000i
H2(:,:,2) =
0.5846 - 0.3231i
H2(:,:,3) =
0.5846.3231i
45
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
b. Diagrama de Bode.-
El diagrama de Bode presenta la respuesta en frecuencia de un sistema . Esta

respuesta consta de dos gráficas, una la ganancia (dB=20 ) y otra la fase
(grados decimales) de . El eje horizontal presenta las frecuencias en escala
logarítmica.
En siguiente script muestra el uso de la función bode:
sys=tf([3,-1],[-2 1 1])
figure(1)
bode(sys); %grafica diagrama de Bode
grid on;
[mag, fase, w]=bode(sys); %no grafica, solo entrega los
%datos de magnitude, fase y frecuencia
Figura 15. Grafica de la respuesta en frecuencia usando las función bode
c. Diagrama de Nyquist.-
Otra forma de representar la respuesta en frecuencia es el diagrama de Nyquist. Se

calculan las partes real e imaginaria de la función de transferencia en lazo abierto
para valores de y y se grafican los puntos en el plano complejo.
La curva resultante es el diagram de Nyquist.
sys=zpk([],[-1 -1 -1],4);
figure(1)
nyquist(sys,'r-');
46
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Figura 16. Grafica de la respuesta en frecuencia en el plano complejo (diagrama de

Nyquist), curva obtenida usando la función nyquist
También podemos almacenar los valores reales e imaginarios, dado un vector de

frecuencias, y valores reales e imaginarios (y frecuencias usadas por Matlab en el
cálculo), mediante el uso de argumentos de retorno (izquierda):
[re,im]=nyquist(sys,w)
[re,im,w]=nyquist(sys)
d. Gráficos de respuesta en frecuencia.-
A continuación se presenta una lista de funciones de Matlab que permiten

generar/calcular respuestas en frecuencia.
bode, bodeplot Gráfico Bode de respuesta en frecuencia, magnitud y

fase de la respuesta en frecuencia
nichols, nicholsplot Nichols chart de la respuesta en frecuencia
nyquist, nyquistplot Nyquist plot de la respuesta en frecuencia
Sigma, sigmaplot Gráfico de los valores singulares de un sistema
dinámico
evalfr Evalúa la respuesta en frecuencia en una frecuencia
dada
freqresp Calcula la respuesta en frecuencia dado un vector de
frecuencias
47
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
2.4.4. Análisis interactivo de modelos usando el Visor LTI.-
El visor LTI (LTI-viewer) hace muy simple realizar simulaciones, graficas de respuesta
en el tiempo y en la frecuencia, para uno o muchos modelos LTI que existan en el
directorio de trabajo. El visor LTI es fácil de ejecutar, por ejemplo:
[num,den]=ord2(10,0.2);
sys=tf(num,den);
h=ltiview({'step';'pzmap'},sys);
ltiview('current',tf(dcgain(sys),[0.3 1]),h)
Figura 17. Ventana que permite visualizar diversas respuestas (tiempo y frecuencia) de
un sistema, función ltiview
2.5. Herramienta para diseño de controladores SISO: SISO Tool.-
Matlab cuenta con un GUI para diseño interactivo de compensadores para el caso de
plantas SISO. Este GUI permite diseñar compensadores SISO usando el lugar
geométrico de las raíces, diagrama de Bode, técnicas de Nyquist y Nichols.
Para usar esta herramiento de diseño de compensadores, basta escribir sisotool en el

script, por ejemplo:
[num,den]=ord2(10,0.2);
sys=tf(num,den);
sisotool(sys);
48
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Figura 18. Ventanas que permiten (a) modificar parámetros para diseño de
compensadores, y (b) visualizar diversas respuestas (tiempo y frecuencia) del sistema en
lazo abierto y lazo cerrado
49
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
EJEMPLO 1
Sea el sistema descrito por la siguiente función de transferencia, simular la respuesta en

el tiempo ante diversas entradas.
Respuesta a las condiciones iniciales usando la función initial:
clc
clear all
close all
s=tf('s');
G=1/(s^2+4*s+9);
Gss=ss(G);
Xo=[0 1];
[y,t,x]=initial(Gss,Xo); %respuesta libre
figure(1)
subplot(223)
plot(t,x(:,1),'r-',t,x(:,2),'g--');
title('Estados x(t)');
xlabel('t');
ylabel('x(t)');
legend('x_1(t)','x_2(t)');
subplot(221)
plot(t,y);
title('Salida y(t)');
xlabel('t');
ylabel('y(t)')
subplot(122)
plot(x(:,1),x(:,2));
title('Phase Potrait');
xlabel('x_1(t)');
ylabel('x_2(t)')
50
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Figura 19. Respuesta a las condiciones iniciales
Respuesta al escalón unitario y al impulso unitario usando las funciones step e

impulse:
figure(2)
subplot(121)
step(G);
subplot(122)
impulse(G);
Figura 20. Respuesta al escalón e impulso unitario

51
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Respuesta a una entrada arbitraria usando las funciones gensig y lsim:
[u,t]=gensig('square',3,10,0.01);
[y,t]=lsim(G,u,t);
figure(3)
plot(t,y,'r-',t,u,'b--');
legend('y(t)','u(t)')
title('Respuesta a una entrada arbitraria');
xlabel('t');
Figura 21. Respuesta a una entrada arbitraria
EJEMPLO 2
Sea el sistema descrito por la siguiente función de transferencia, presentar la respuesta

en frecuencia.
Sea el sistema descrito por la siguiente función de transferencia, presentar la respuesta

en la frecuencia para diversos factores de amortiguamiento.
52
----------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------
Respuesta en frecuencia usando la función bode:
clc
clear all
close all
sysPT1=tf(1,[0.05 1]);
figure(1)
subplot(121)
bode(sysPT1,'r-');
sysPT2=tf(10,[1 0.05 10]);
d=[sqrt(2)/2 1.6 3];
for n=1:1:length(d)
sysPT2=[sysPT2; tf(10,[1 d(n) 10])];
grid on;
end;
subplot(122)
hold on
stil={'r-' 'b-' 'k-' 'g--'};
for n=1:1:length(d)+1
bode(sysPT2(n),stil{n});
grid on;
end
Figura 22. Respuesta en frecuencia
53
----------------------------------------------------------------------------------------------------------

L01-Guia Laboratorio - 1 2019 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

L01-Guia Laboratorio - 1 2019 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ

FACULTAD DE CIENCIAS E INGENIERÍA

DEPARTAMENTO DE INGENIERÍA MECÁNICA

INTRODUCCIÓN AL MATLAB Y SU TOOLBOX DE ANÁLISIS Y DISEÑO DE

INTRODUCCIÓN AL MATLAB Y SU USO EN EL ANÁLISIS Y DISEÑO

Al finalizar el laboratorio, el alumno estará familiarizado con el uso del MATLAB

MATLAB es un software interactivo orientado para el cálculo científico y de ingeniería,

MATLAB es un sistema interactivo cuyo elemento básico de datos es un arreglo que no

1. Usos del Matlab.-

 Librerías específicas: toolboxes. A lo largo del curso se utilizarán las siguientes:

2. El aspecto de Matlab 8 (R2012a).-

Matlab 8 ofrece un aspecto configurable en función de la información que se desee

Figura 1.1 Escritorio del Matlab

Existen cuatro elementos fundamentales, tal y como puede apreciarse en la imagen:

3. Cómo encontrar ayuda en Matlab.-

Existen distintas formas de localizar ayuda en el entorno de Matlab:

>> help inv

 Navegador de funciones.- Se accede desde el menú Help, seleccionando la

 Navegador de ayuda.- Se accede desde el menú Help, seleccionando la opción

 Comando lookfor (búsqueda de palabras clave).- Aunque más complicado

4. Variables y matrices en Matlab.-

Matlab soporta nombres de variable de hasta 19 caracteres, y distingue entre

Una sentencia de creación de variable es, por ejemplo:

 Matriz n x m: matriz bidimensional

 Separar los elementos de una fila con espacios o comas.

Algunas posibilidades de manejo de variables que ofrece Matlab:

 Comprobar el contenido de alguna variable: basta con teclear su nombre en la

 Listar todas las variables existentes en un determinado momento: comando who.

Nota: la versión 8 de Matlab permite visualizar las variables existentes en la ventana

 Eliminar alguna variable de memoria: comando clear.

5. Gestión de una sesión de trabajo.-

Tabla 1 Comandos para gestionar una sesión de trabajo

>>NumerodeManzanas = 10; NumerodeNaranjas = 25;

Matlab ofrece bastantes facilidades para el manejo de matrices. Volviendo al ejemplo

Este segundo comando muestra todos los elementos de la columna 3:

 También es posible modificar cualquier elemento de una matriz:

 E incluso añadir elementos a una matriz dada:

7. Principales operadores aritméticos.-

En algunas ocasiones podrán presentarse ambigüedades. Por ejemplo, al multiplicar dos

La información sobre operadores puede ser encontrada en la ayuda de Matlab 8,

eye matriz identidad.

rank rango de una matriz.

 Obtención de la matriz inversa: función inv:

 Creación de una matriz de ceros o unos: funciones zeros y ones:

La información sobre operaciones matriciales puede ser encontrada en la ayuda de

8. Operaciones con vectores.-

Los dos puntos “:” es un carácter importante en Matlab. La declaración:

Otros incrementos, diferentes de uno, pueden ser usados.

Incrementos negativos también son posibles.

También se puede generar vectores utilizando la función linspace. Por ejemplo:

Similarmente, si queremos evaluar el mismo polinomio en s =π, ingresamos:

Si queremos multiplicar dos polinomios, la función conv lo puede hacer. La

coeficientes del polinomio que se obtienen cuando se multiplican los polinomios

10. Funciones incorporadas del Matlab

Tabla 2 Funciones matemáticas comúnmente usadas en el Matlab

11. Guardando y recuperando las variables del workspace.-

12. Modos de trabajo.-

Matlab permite trabajar de dos maneras distintas:

13. Creando y usando un script.-

El símbolo % designa un comentario, que no es ejecutado en Matlab. Los comentarios

A continuación se muestra un ejemplo simple de cómo crear, guardar y correr un

Una vez concluida la edición, seleccionar File->Save. Reemplazar el nombre por

La Figura 2 muestra una pantalla que contiene el resultado de lo que se muestra en la