SIMULINK Tutorial Completo - Mach PDF

10.
SIMULINK
10.1 INTRODUCCION
Simulink es un software que funciona bajo la plataforma de Matlab y es una

herramienta muy útil para modelar, simular y analizar sistemas, tanto lineales como
no lineales. Permite al usuario realizar sus estudios tanto en el dominio del tiempo
como el de Laplace, expresar las funciones de transferencia en las diferentes formas
incluyendo la del espacio de los estados y otras opciones. En una interfaz gráfica
(GUI) como la que se observa en la Figura 10.1, el usuario construye un diagrama
de bloques que desarrollan procedimientos que realizan las operaciones matemáticas
requeridas para la solución de un modelo.
Figura 10.1. Librerias (Izquierda) y Espacio de trabajo de Simulink (Derecha)
10.2 ACCESO A SIMULINK
Para acceder a Simulink se requiere abrir el espacio de trabajo de Matlab y presionar

el icono “Simulink” o también mediante la digitación de dicha palabra clave con
letras minúsculas en el editor de comandos. Con lo anterior se despliega, solamente,
la ventana de título “Simulink Library Browser” que se observa a la izquierda de la
Figura 10.1. El espacio de trabajo de Simulink es la ventana que se observa a la
derecha y se despliega presionando el icono “Create a new model” que se encuentra
178
en la barra estándar o desplegando el menú “File” y seleccionando sucesivamente

“New” y “Model” (Ctrl + N)
10.3 LIBRERIAS DE SIMULINK
Al desplegar el árbol de Simulink y haciendo clic izquierdo sobre su nombre se

despliegan las librerías que contienen los bloques operacionales agrupados de
acuerdo a diferentes propósitos comunes. Los nombres de las librerías son:
Continuous, Discontinuities, Discrete, Look-Up Tables, Math Operations, Model
Verification, Model-Wide Utilities, Ports & Subsystems, Signal Attributes, Signal
Routing, Sinks, Sources y User-Defined Functions.
Instalación y Conexión de un bloque operacional
Para la instalación de un bloque en el espacio de trabajo de Simulink se selecciona

de la librería con un clic izquierdo del mouse y en forma sostenida se arrastra hasta
el espacio de trabajo de Simulink. Las conexiones entre dos bloques se realizan
acercando el puntero del mouse a uno de los topes (entrada o salida) hasta que este
cambie en forma de cruz, se presiona el botón izquierdo del mouse y en forma
sostenida se arrastra hasta el otro tope. La conexión es correcta cuando el puntero
del mouse tome la forma de una cruz de doble trazo. Se debe observar una línea con
una saeta en el tope del bloque de entrada.
Especificación de un bloque operacional
Las especificaciones mínimas requeridas en un bloque se relacionan con la

operación que realizan dentro del diagrama que representa el proceso de solución del
modelo matemático del sistema.
10.4 LIBRERÍA “CONTINUOUS” (CONTINUO)
La Figura 10.2a muestra la ventana que se despliega al hacer doble clic sobre la
librería “Continuous” y la Figura 10.2b muestra los íconos que simbolizan a cada
uno de los bloques que incluye esta librería. Los nombres de los bloques son:
Derivative (Derivada), Integrator (Integrador), State-Space (Espacio de los Estados),
Transfer Fcn (Función de Transferencia como numerador/denominador), Transport
Delay (Tiempo Muerto), Variable Transport Delay (Tiempo Muerto Variable), Zero-
Pole (Transferencia Muerto en la forma de zeros y polos)
Mach
179
(a) (b)
Figura 10.2. Librería (a) Continuous y (b) Bloques operacionales
Los bloques de la librería “Continuous” representan unidades que se alimentan de

una información de entrada y que al desarrollar sobre esta un proceso matemático
transmite el resultado como una información de salida. En la librería “Continuous”
se incluyen los bloques para realizar operaciones matemáticas continuas en el
tiempo.
Bloque Derivada (“Derivative”)
El bloque “Derivative” desarrolla la derivada con respecto al tiempo de la variable

de entrada para lo cual no se necesita especificación. La Figura 10.3 muestra la
ventana que se despliega al hacer doble clic sobre el icono Derivative
Figura 10.3 Especificaciones del bloque Derivative
Mach
180
Bloque Integrador (“Integrator”)
El bloque “Integrator” desarrolla la operación de integrar la información de entrada

desde un tiempo inicial hasta un tiempo final que se especifica como uno de los
parámetros de la simulación. Se observa en la ventana de especificaciones del
bloque integrador mostrada en la Figura 10.4a que se requiere la especificación de la
condición inicial de la variable que se suma (integra)
(a) (b)
Figura 10.4 Especificaciones del bloque (a) Integrator (b) State-Space
Bloque Espacio de los Estados (“State-Space”)
La Figura 10.4b muestra la ventana de especificaciones para el bloque que desarrolla

un modelo lineal en la forma del Espacio de los Estados. Se observan los cuadros
para especificar las matrices A, B, C y D y las condiciones iniciales.
Bloques Funciones de Transferencia (“Transfer Fcn” y “Zero-Pole”)
La Figura 10.5 muestra las ventanas de especificaciones para las funciones de

transferencia en la forma de numerador/denominador y en la de zeros y polos.
Mach
181
(a) (b)
Figura 10.5 Especificaciones de bloques (a) Transfer Fcn y (b) Zero-Pole
En la Figura 10.5a, se observan los cuadros donde se especifican en forma matricial

el numerador y el denominador de la función de transferencia mientras que en la
Figura 10.5b los cuadros donde se incluyen en forma matricial los zeros, los polos y
las ganancias de la función de transferencia
Es común a todas las ventanas de especificaciones de bloques operacionales, la

inclusión de la barra de título seguido de un pequeño cuadro con el nombre del
bloque y una breve descripción de la función de éste. De igual manera, en la parte
inferior se incluyen los botones “OK”, “Cancel”, “Help” y “Apply”
Bloque Tiempo Muerto (“Transport Delay”)
La Figura 10.6 muestra las ventanas de especificaciones para los bloques que
incluyen un atraso por tiempo muerto dentro de la dinámica de un sistema. Simulink
incluye un bloque “Transport Delay” y otro titulado “Variable Transport Delay”
El bloque “Transport Delay” aplica el tiempo muerto a la señal de entrada que se

especifica en el cuadro de nombre “Time Delay”, mientras que el bloque “Variable
Transport Delay” aplica el tiempo muerto a la primera señal de entrada y en la
segunda entrada se especifica el tiempo muerto. Las otras especificaciones,
usualmente, se dejan como aparecen por defecto
Mach
182
(a) (b)
Figura 10.6 Especificaciones de los bloques Transport Delay
10.5 LIBRERÍA “MATH OPERATIONS” (OPERADORES)
La Figura 10.7 muestra la ventana que se despliega al hacer doble clic sobre la
librería “Math Operations” y la Figura 10.8 los botones incluidos en dicha librería.
Figura 10.7 Librería Math Operations
Mach
183
Figura 10.8 Bloques de la librería Math Operations
Los bloques de la librería “Math Operations” se utilizan en la simulación de la

dinámica de un sistema para aplicar operadores matemáticos sobre su información
de entrada. A continuación se describe la especificación de algunos de ellos
Bloque Suma (“Sum”)
El bloque “Sum” realiza la suma algebraica de las informaciones de entradas

alimentadas al bloque. La Figura 10.9 muestra la ventana de especificaciones de este
bloque y se observa el cuadro desplegable donde se selecciona la forma del icono
Figura 10.9 Especificaciones del bloque Sum
Mach
184
El bloque “Sum” se especifica introduciendo en el cuadro “List of signs” los signos

de cada uno de las informaciones de entrada o el número de ellas. En el primer caso
los signos de suma o resta se despliegan a un lado de los topes de entrada del icono
que representa al bloque
Bloques Ganancia (“Gain” y “Slider Gain”)
El bloque “Gain” aplica un factor multiplicador constante a la información de

entrada y el producto lo transmite como la información de salida. El factor
multiplicador es la ganancia. La Figura 10.10a muestra la ventana de
especificaciones del bloque Gain. En el cuadro Gain se introduce la ganancia como
un valor constante
El bloque “Slider Gain” realiza la misma operación del bloque “Gain” permitiendo
la variación del valor de la ganancia asignada, mediante el botón deslizable, desde
un valor mínimo hasta un máximo. La Figura 10.10b muestra la ventana de
especificaciones del bloque “Slider Gain”
(a) (b)
Figura 10.10 Especificaciones de los bloques (a) Gain y (b) Slider Gain
Bloque Producto (“Product”)
El bloque “Product” realiza el producto o la división entre las informaciones de

entrada. Esto se especifica introduciendo, ya sea, el número de corrientes a
multiplicar o los signos producto o división para cada una de las informaciones de
entrada en el cuadro “Number of inputs” de la ventana de especificaciones que se
muestra en la Figura 10.11
Mach
185
Figura 10.11 Especificaciones del bloque Product
Al especificar los signos, estos se despliegan con los símbolos de producto o

división a un lado de los topes de entrada del icono que representa al bloque
Bloque Funcion (“Math Function” y “Trigonometric Function”)
El bloque “Math Function” aplica a la información de entrada una función

matemática que se selecciona en el cuadro desplegable “Function”, mientras que el
bloque “Trigonometric Function” solo aplica funciones trigonométricas como se
observa en la Figura 10.12
(a) (b)
Figura 10.12 Especificaciones del bloque (a) Math Function, (b) Trigonometric
Function
Mach
186
Bloque Minimo y Maximo (“MinMax”)
El bloque “MinMax” selecciona el valor mínimo o el máximo entre los

correspondientes a las informaciones de entrada. En su ventana de especificaciones
se encuentra el cuadro donde se elige la función del bloque, es decir, “min” o “max”
y un cuadro adicional donde se especifica el número de entradas al bloque. Después
de introducir lo anterior, se observa en el icono del bloque un número de topes de
entrada igual al especificado
10.6 LIBRERÍA “SOURCES” (ENTRADAS)
La Figura 10.13 muestra la ventana que se despliega al hacer doble clic sobre la
librería “Sources” y la Figura 10.14 los íconos de los bloques incluidos en dicha
librería
Figura 10.13. Librería Sources
Mach
187
Figura 10.14 Bloques de la librería Sources
La librería “Sources” contiene un conjunto de bloques de donde emergen señales

que representan los cambios en las variables de entrada. Estos bloques solo tienen
puertos de salida, es decir, no tienen puertos de entrada. A continuación se describen
los bloques Step, Ramp, Sine Wave, Constant, Clock, Digital Clock, Signal
Generator
Bloques Paso y Rampa (“Step” y “Ramp”)
La Figura 10.15a muestra la ventana de especificaciones del bloque “Step”. En el

cuadro “Step Time” se introduce el tiempo transcurrido para que la variable de
entrada cambie desde un valor inicial que se introduce en el cuadro “Initial value”
hasta un valor final que se introduce en el cuadro “Final value”.
(a) (b)
Figura 10.15 Especificaciones de los bloques (a) Step y (b) Ramp
Mach
188
La Figura 1.15b muestra la ventana de especificaciones del bloque “Ramp”. En el

cuadro “Slope” se introduce la pendiente de la rampa y en el cuadro “Start time” se
introduce el tiempo de iniciación del cambio rampa. Los cuadros de especificaciones
se dejan con sus valores por defecto
Bloques Seno y Generador de Señal (“Sine Wave” - “Signal Generator”)
La Figura 10.16a muestra la ventana de especificaciones del bloque “Sine Wave”.

La Amplitud, el umbral, la frecuencia y la fase de la onda sinusoidal se introducen
en los cuadros de nombres “Amplitude”, “Bias”, “Frequency” y “Phase”,
respectivamente.
(a) (b)
Figura 10.16 Especificaciones del bloque (a) Sine Wave y (b) Signal Generator
La Figura 10.16b muestra la ventana de especificaciones del bloque “Signal

Generator”. En el cuadro “Wave from” se especifica si la onda periódica de entrada
es sinusoidal, cuadrada, diente de sierra o al azar. La amplitud y la frecuencia se
introducen en los cuadros de nombres “Amplitude” y “Frequency”, respectivamente.
Bloques Reloj y Constante (“Clock” y “Constant”)
La Figura 10.17a muestra la ventana de especificaciones para el bloque “Clock” que

se utiliza para mostrar el tiempo de simulación. Si se verifica el cuadro “Display
Mach
189
time” se despliega el tiempo sobre el icono. El bloque “Display Clock” se puede

utilizar como otra opción.
(a) (b)
Figura 10.17 Especificaciones del bloque (a) Clock (b) Constante
La Figura 10.17b muestra la ventana de especificaciones para el bloque “Constante”

que se utiliza para entrar un valor constante en el diagrama de bloques que simula la
dinámica de un sistema.
10.7 LIBRERÍA “SINKS” (SALIDAS)
La librería “Sinks” contiene un conjunto de bloques receptores de señales de salida

y, por lo tanto, solo tienen puertos de entrada. Mediante estos bloques se observan
los resultados de las simulaciones en diferentes formas, por ejemplo, gráfica o
numérica. La Figura 10.18a muestra la ventana que se despliega al hacer doble clic
sobre la librería “Sinks” y la Figura 6.18b muestra los botones que se incluyen en
dicha librería.
Los botones “Scope”, “Floating Scope” y “XY Graph” despliegan la información de

salida en función del tiempo, en forma gráfica. El botón “Scope” no requiere
especificaciones y “Floating Scope” se utiliza para representar en gráficos separados
los perfiles de cada una de las informaciones de salida, para lo cual se hace doble
clic sobre el icono, se presiona el cuadro “Parameters” y se introducen el número de
gráficos en el cuadro “Number of axes”. El botón “XY Graph” requiere de las
especificaciones de los valores límites en los ejes de representación de las variables
“X” e “Y”. La Figura 10.19 muestra la ventana de especificaciones de los botones
“Floating Scope” y “XY Graph”.
Mach
190
(a) (b)
Figura 10.18 Librería Sinks
(a) (b)
Figura 10.19 Especificaciones del bloque (a) XY Graph y (b) Floating Scope
Los botones “Display” y “To Workspace” despliegan la información de salida en

forma numérica. El primero lo muestra en forma digital sobre el mismo icono
mientras que el segundo lo hace sobre el espacio de trabajo de Matlab asignándole
Mach
191
un símbolo a las variables que se quieren desplegar. El botón “Display” permite la

selección del formato numérico para el despliegue de la información de salida. La
Figura 10.20 muestra las ventanas de especificaciones de estos botones
(a) (b)
Figura 10.20 Especificaciones del bloque (a) “Display” y (b) “To Workspace”
Figura 10.21 Especificaciones del bloque “To File”
10.8 LIBRERÍAS “SIGNAL ROUTING” Y “PORTS & SUBSYSTEMS”
Las Figuras 10.22 muestran las ventanas que se despliegan al abrir las librerías
“Signal Routing” y “Ports & Subsystems” que contienen bloques de enrutamiento de
señales y definición de puertos y subsistemas.
Mach
192
(a) (b)
Figura 10.22. Librería (a) Signal Routing (a) y (b) Ports & Subsystems
La librería “Signal Routing” contiene un conjunto de bloques de enrutamiento de

señales como interruptores, mezcladores, divisores, etc. Estos bloques tienen puertos
de entrada y de salida
La librería “Ports & Subsystems” contiene un conjunto de bloques que definen

puertos de entradas y de salidas o subsistemas con los que desarrollan lazos de
control de flujo como if, switch, while, for, etc.
10.9 SIMULACION DE UN SISTEMA CON SIMULINK
10.9.1 Sistema de Primer Orden Lineal – Dominio Tiempo
En la Figura 10.23 se muestra un diagrama de bloques para la simulación del

sistema de primer orden lineal en el dominio del tiempo, planteado en la Práctica
No. 1.
Mach
193
Figura 10.23. Diagrama de bloques del sistema de la Práctica 1
Mach
194
Los parámetros físicos incluidos son los correspondientes al volumen en el tanque,

el flujo volumétrico a través del mismo y la constante de velocidad de reacción.
El botón “Multiport Switch” es un interruptor múltiple que se encuentra en la

librería “Signal Routing”. Su funcionamiento está acoplado con el botón constante
denominado “Entrada” cuya función es indicar al interruptor la función que debe
dejar pasar a través de él. Esto se hace asignando los números 1, 2 y 3 a los cambios
Step, Ramp y Sine Wave, respectivamente. El botón “Mux” de la librería “Routing
Signal” simula la circulación de la señal rampa de entrada separada de la señal de
salida del sistema pero conjuntas de tal manera que el “Scope” que se alimenta con
la descarga del botón “Mux” muestra en una misma ventana ambos perfiles. El
botón “Manual Switch” se incluye para interrumpir el flujo de la información de
salida a través de él cuando se haga la simulación de la respuesta rampa. Su
operación es manual
Al hacer la simulación con la ecuación diferencial estándar de un sistema de primer

orden lineal en términos de sus variables desviación, la condición inicial en el
integrador es cero. Para la fijación de los parámetros de la simulación en cuanto a la
fijación del tiempo y a la selección del método para la solución de la ecuación
diferencial despliegue el menú “Simulation” y llénela como se observa en la Figura
10.24.
Figura 10.24 Especificación de los Parámetros de la Simulación
En el cuadro “Simulation Time” se ha fijado como tiempo de simulación 50

unidades de tiempo y en el cuadro “Solver options” se ha seleccionado el método
Mach
195
ode23s (stiff/Mod. Rosenbrock). Estos métodos rigurosos se seleccionan,

especialmente, cuando se observa que las respuestas se ven a trazos lineales muy
notorios, lo que puede deberse a la aplicación de un método menos riguroso
10.9.2 Sistema de Primer Orden Lineal – Dominio Laplace

sistema de primer orden lineal en el dominio del tiempo, planteado en la Práctica
No. 3.
La función de transferencia se procesa con el botón “Transfer Fcn” de la librería

“Continuous”. Se especificó con un numerador de [0.875] y un denominador de
[4.375 1], es decir, con los parámetros correspondientes a la ganancia y constante de
tiempo determinados para dicho sistema. El botón “Gain” se coloca para alimentar
el “Scope” con la información correspondiente a la variable de salida dividida por la
ganancia del sistema, con lo que se observa claramente el perfil lineal de la
respuesta después de un cierto tiempo. Nuevamente, para la solución del modelo se
utiliza el método ode23s (stiff/Mod. Rosenbrock) y se sugiere fijar un tiempo de 50
unidades de tiempo
Una función de transferencia se puede simular con el bloque “LTI System” que se
encuentra en la herramienta “Control System Toolbox” y que se observa al hacer
doble clic sobre dicha herramienta. Con el bloque “LTI System” se puede introducir
la función de transferencia ya sea en la forma estándar, o zero-pole o espacio de los
estados, utilizando los comandos correspondientes para cada una de ellas, es decir,
tf, zpk o ss
10.9.3 Sistema de Segundo Orden Lineal – Dominio Tiempo

sistema de segundo orden lineal en el dominio del tiempo, planteado en la Práctica
No. 4.
Se utiliza el bloque “Math Function” de la librería “Math Operations” para realizar

raíces cuadradas y potencias al cuadrado. Se incluye el botón “Display” de la librería
“Sinks” para desplegar el valor del coeficiente de amortiguamiento. Se observa la
necesidad de dos bloques “Integrator” debido a que la ecuación diferencial que se
simula es de segundo orden
Mach
196
Figura 10.25 Diagrama de bloques del sistema de la Práctica 2
Mach
197
Mach
198
Las leyendas que aparecen sobre algunas corrientes se digitan haciendo un clic sobre
el lugar sobre el cual se quiere introducir. Las letras griegas se colocan con el estilo
“Symbol”
10.9.4 Sistema de Segundo Orden Lineal – Dominio Laplace

sistema de segundo orden lineal en el dominio de Laplace, planteado en la Práctica
No. 5.
En esta simulación, se construye un archivo con Matlab, es decir, con extensión

punto m, que solicite al usuario los parámetros físicos del sistema (Masa del bloque,
constante de elasticidad, coeficiente de amortiguamiento, aceleración de la gravedad
y área del diafragma, calcule los parámetros dinámicos (Ganancia, constante de
tiempo y coeficiente de amortiguamiento) y defina el numerador (num) y el
denominador (den) de la función de transferencia que se introducen como los
parámetros que especifican al bloque Función de Transferencia. Desde dicho
archivo se llama el archivo punto mdl construido en Simulink para que se despliegue
y que corresponde al diagrama de bloques que se observa en la Figura 10.27. Los
parámetros de la simulación se introducen desde la ventana de Simulink
10.9.5 Sistemas con Tiempo Muerto – Dominio Laplace
En la Figura 10.28 se muestra el diagrama de bloques que simula la dinámica de un

sistema con tiempo muerto en el dominio de Laplace e incluye los modelos de
primero y segundo orden desarrollados en las Prácticas No. 3 y 5.
Para esta simulación, se construye un archivo tipo “Script” en Matlab con nombre
“Sistemas.m” y un diagrama de bloques en Simulink denominado
“Primer_Segundo_Orden.mdl”. En el primero se capturan o calculan todos los
parámetros requeridos y en el segundo se desarrolla la simulación. De esta forma,
los bloques del diagrama en Simulink se especifican con los símbolos asignados en
el archivo “Sistemas.m”. Se observa, además, que el tiempo de simulación se
captura con el nombre “Rango” y se introduce dentro de la ventana de
especificaciones de los parámetros de simulación que se despliega dentro de la
ventana de Simulink. La simulación se inicia con la apertura del archivo
“Sistemas.m”, y desde aquí se ordena la corrida y posterior apertura del diagrama de
bloques en Simulink. La solución gráfica resultante se observa desplegando los
registradores respectivos. Algunos comandos de matlab utilizados en el primero de
los archivos se explican al final de esta lección.
Mach
199
Mach
200
Figura 10.28 Simulación de la dinámica de un sistema con Tiempo Muerto
Mach
201
En la Figura 10.28 se incluye el botón “Transport Delay” de la librería “Continuous”

para especificar el tiempo muerto y se simplifica el diagrama definiendo dos
subsistemas, el “Subsystem1” incluye los elementos que seleccionan el sistema de
primer o de segundo orden que se quiere simular y el denominado “Subsystem”
incluye los elementos con los cuales se desarrolla la respuesta que se quiere
desarrollar o simular. Las Figuras 10.29 y 10.30 muestran los diagramas
correspondientes para cada uno de los subsistemas observados
Figura 10.29 Subsistema para seleccionar el orden del sistema
Figura 10.30 Subsistema para seleccionar la respuesta del sistema
Mach
202
El botón “Subsystem” se selecciona en la librería “Ports&Subsystems” y el

subsistema se puede construir dentro del bloque seleccionado pero también se
pueden escoger los elementos previamente y seleccionar la opción “Create
Subsystem” del menú “Edit” del espacio de trabajo de Simulink,
En la Figura 10.29 se emplea el botón “Switch Case” de la librería

“Ports&Subsystems” y que desarrolla la operación switch-case sobre el valor de la
variable de entrada que en el programa codificado en Matlab corresponde a la
asignación para seleccionar el sistema de primero o segundo orden. El caso 1
(Primer Orden) se conecta con un botón “Switch Case Action Subsystem”, de la
misma librería, denominado “Primer Orden” que requiere de la alimentación de la
acción (1), para lo cual se instala la función de transferencia para un sistema de
primer orden (En el esquema se colocó afuera para ilustración del lector) entre su
puerto de entrada y salida. La entrada a este bloque es el cambio en la variable de
entrada (Paso, Rampa o Seno). Para el caso 2 (Segundo Orden) se construye un
esquema similar. El interruptor multipuerto utiliza como indicador de salida el que
se asigna para el orden del sistema.
En la Figura 10.30, un botón “Switch Case” desarrolla la operación switch-case

sobre el valor que se asigna para seleccionar el tipo de cambio en la variable de
entrada. Se incluyen un caso para la respuesta rampa y otro caso (2, 3), que
desarrolla los cambios paso y seno. Los botones “Switch Case Action Subsystem” se
alimentan de las acciones y entradas correspondientes a rampa y paso y seno,
respectivamente. El botón “Merge” de la librería “Ports&Subsystems” emerge las
señales de entrada en una sola señal de salida. En este caso, solo emerge la
información alimentada
10.9.6 Sistema de Tres Tanques de Flujo No Interactuantes

sistema de tres tanques en serie no interactuantes planteado en la Práctica No. 7. Se
observa que los parámetros que se introducen a través de un programa codificado
con Matlab son el dominio de solución del modelo y el tipo de respuesta que se
quiere simular. De igual manera, se introducen los parámetros que especifican cada
uno de los cambios que se incluyen, dentro del diagrama de bloque, para la variable
de entrada. El archivo se incluye al final de este capítulo y se denomina
“ordenmayorsimulink.m”
Las Figuras 10.32 muestra el diagrama interior al bloque denominado “Tiempo-

Laplace”; es la aplicación de un lazo “Switch…Case” para desarrollar la solución de
la respuesta seleccionada en el dominio del tiempo o de Laplace. Además, incluye
Mach
203
un bloque donde se selecciona el tipo de respuesta a simular, es decir, paso, rampa o

seno.
Figura 10.31 Sistema de Orden Mayor – Tanques No Interactuantes
Figura 10.32 Selección del dominio de Solución
La Figura 10.33 muestra el diagrama de bloques que representa la solución del

modelo en el dominio del tiempo. Al observar este diagrama, se deduce que los
Mach
204
parámetros dinámicos correspondientes a cada uno de los tanques se introducen al

correr el programa codificado en Matlab, es decir, las constantes de tiempo y las
ganancias estacionarias. La Figura 10.34 es el diagrama de bloques que representa la
solución del modelo en el dominio de Laplace
Figura 10.33 Solución del modelo en el dominio del tiempo
Figura 10.34 Solución del modelo en el dominio de Laplace
La Figura 10.35 es el diagrama de bloques correspondiente al subsistema

denominado “Salida” incluido en la Figura 10.32. Se observa, que mediante un lazo
Mach
205
de control “Switch…Case” se selecciona la salida de acuerdo al dominio, tiempo o

Laplace, en que se hace la simulación.
Figura 10.35 Selección del dominio de Salida
La Figura 10.36 es el diagrama de bloques en donde se selecciona si la respuesta a

simular es paso, rampa o seno para los respectivos gráficos de salida
Figura 10.36 Selecciona del tipo de respuesta
Mach
206
10.9.7 Sistema de Dos Tanques de Flujo Interactuantes

sistema de dos tanques de flujo interactuantes planteado en la Práctica No. 7. Se
observa que los parámetros que se introducen a través de un programa codificado
con Matlab son el dominio de solución del modelo y el tanque cuya respuesta se
quiere simular. De igual manera, se introducen los parámetros que especifican cada
uno de los cambios que se incluyen, dentro del diagrama de bloque, para la variable
de entrada. El código se incluye en el archivo “ordenmayorsimulink.m”
Figura 10.37 Tanques en serie interactuantes
Las Figuras 10.38 a 10.42 muestran los diagramas de bloques de cada uno de los
sucesivos subsistemas introducidos en el diagrama de bloque de la Figura 10.37. La
estructura de los subsistemas es similar a la construida para el modelo de tres
tanques de flujo en serie no interactuantes.
Mach
207
Figura 10.38 Subsistema “Tiempo – Laplace”
Figura 10.39 Subsistema “Dominio del Tiempo”
Mach
208
Figura 10.40 Subsistema “Dominio Laplace”
Figura 10.41 Subsistema “Salida”
Mach
209
Figura 10.42 Subsistema “Salida1”
10.9.8 Espacio de los Estados con Simulink
En la Figura 10.43 se muestra el diagrama de bloques para la simulación del modelo

de los tres tanques de flujo en serie no interactuantes planteado en la Practica No. 7;
Figura 10.43 Tanques no interactuantes – Espacio de los Estados
Figura 10.44 Tanques Interactuantes – Espacio de los Estados
Mach
210
Y la Figura 10.44 muestra el diagrama de bloques para el sistema de dos tanques de

flujo interactuantes simulado en la misma práctica. Las matrices son introducidas en
el archivo “ordenmayorsimulink”
10.9.9 Sistemas No Lineales – Reacciones de Van de Vusse
En la Práctica No. 8 se plantea la simulación del sistema de reacciones de Van de

Vusse cuyo modelo matemático es no lineal y sus características permiten un
análisis en estado estacionario o dinámico
Análisis en Estado Estacionario
En la Figura 10.45 se muestra el botón con el cual se determina el perfil de cambio

de las concentraciones de A y B en estado estacionario del sistema de reacciones de
Van de Vusse mediante las ecuaciones (8.8) y (8.9). Como se trata de un
procedimiento para calcular dichas concentraciones para diferentes valores de la
velocidad espacio se utiliza el bloque “For Iterator Subsystem” que se encuentra en
la librería “Ports&Subsystems”. La entrada a dicho subsistema es el número de
iteraciones y la salida ha sido anulada para mostrar los resultados en el interior del
blorque “For Iterator Subsystem”.
Figura 10.45 Bloque For Iterator Subsystem
Al hacer doble clic sobre el bloque se despliega el subsistema que muestra el bloque
“For Iterator”, y un puerto de entrada unido a un puerto de salida como se observa
en la Figura 10.46
El bloque “For Iterator” se especificó para que la entrada del número de cálculos se
alimente externamente seleccionando la opción “External” en el cuadro “Source of
number of iterations”
Mach
211
Figura 10.46
El diagrama de bloques para el cálculo de las concentraciones de A y B en estado

estacionario se muestra en la Figura 10.48. Para la asignación de los sucesivos
valores de la velocidad espacio se emplea el bloque “Memory” de la librería
“Discrete” cuya función y especificaciones se observan en la Figura 10.47. Se asigna
como valor inicial el valor de -0.1 para que los cálculos se inicien para un valor de
cero ya que esta salida se ha de sumar con el valor constante de 0.1 alimentado. La
salida de este botón es el valor de entrada anterior. Con este lazo, el valor de la
velocidad espacio cambia de 0.1 en 0.1 desde cero y un número de veces dado por el
número de iteraciones especificado. Se requiere la verificación del cuadro de
nombre “Inherit sample time”.
Figura 10.47 Especificaciones del botón “Memory”
Tratándose de una solución en estado estacionario se fijan tanto el tiempo inicial

como el final con un valor de cero. Al fijar un tiempo final diferente, los cálculos se
repiten tantas veces como el tiempo permita repetir el número de cálculos.
Mach
212
Figura 10.48 Subsistema para calcular el perfil de las concentraciones de A y B
El número de iteraciones se multiplica por el valor de 0.1 para fijar la escala en el

eje de las abscisa de 0 a 10 en las representaciones gráficas. Para la observación de
los perfiles se sugiere el intervalo de 0 a 10 en el eje de las abscisas y los intervalos
de 0 a 9 para la concentración de A y de 0 a 1.5 para la concentración de B.
10.10 MATLAB: COMANDOS UTILIZADOS
En los archivos codificados con Matlab para ejecutar algunas simulaciones en esta
lección se utilizan algunos comandos como el msgbox, errordlg y sim. A
continuación se explican en cuanto a la sintaxis empleada en algunos de ellos:
Comando msgbox
Al ejecutar este comando se despliega un cuadro de mensaje escrito por el usuario.

La sintaxis es:
Mach
213
msgbox(Mensaje, Título,Icono)
Los argumentos “Mensaje” y “Titulo” se escriben entre comillas simples y son el

mensaje y el nombre o titulo, que aparecen en el cuadro. El argumento “Icono” es el
dibujo que aparece en el lado izquierdo y que puede ser “none”, “error”, “help” o
“warn”. El icono por defecto es el primero y los otros representan dibujos de error,
ayuda o intejeccion, respectivamente. Estos cuadros incluyen un botón “OK” para
aceptar el mensaje. La minimización o cancelación se consigue presionado los
correspondientes en el extremo superior derecho de la barra de titulo. Algunas
alternativas para el despliegue de cuadros de mensajes son los comandos “errordlg”,
“helpdlg” y “warndlg”. Con ellos se tiene especificado, por defecto, el icono de
error, ayuda o interjección y solo requieren de la especificación del mensaje y el
titulo. Es decir, que su sintaxis es por ejemplo para el comando errordlg:
errordlg(Mensaje, Título)
El comando “questdlg” despliega un cuadro de mensaje con un icono de

interrogación e incluye tres botones para presionar que, por defecto, aparecen con
los nombres de “Yes”, “No” y “Cancel”. La sintaxis para el comando “questdlg” es:
questdlg(Mensaje, Título,Botón1,Boton2,Boton3,BotonPorDefecto)
A los botones pueden asignárseles nombres diferentes a los que muestran por
defecto. La presión de uno de ellos acepta como respuesta el nombre
correspondiente
Comando sim
Este comando ejecuta la simulación de un modelo representado mediante un

diagrama de bloques en Simulink. Su sintaxis es una de las siguientes:
sim(‘Model’)
[t,x,y] = sim(‘Model’, Intervalo de Tiempo)
Mach
214
‘Model’ es el nombre del archivo que contiene el diagrama de bloques construido en

Simulink y debe escribirse entre comillas simples. La primera sintaxis despliega la
respuesta del sistema de acuerdo a los receptores instalados en el diagrama. Por
ejemplo, si se trata de observar la respuesta gráfica es necesario abrir el diagrama de
bloques y desplegar los botones correspondientes. En el caso de respuestas
numéricas receptadas en un botón “To Workspace”, estas se observan sobre el
espacio de trabajo en Matlab.
La segunda sintaxis despliega los valores de tiempo, variables de entrada y variables

de salida en el espacio de trabajo de Matlab. Los argumentos incluyen, además del
nombre del modelo, el intervalo del tiempo de simulación [to ∆t tf]
Comando beep
Este comando, simplemente, produce un sonido al ejecutarse
10.11 MATLAB: PROGRAMAS CODIFICADOS
Archivo Sistemas.m
% Simulacion de Sistemas con Tiempo Muerto

clc
close all
msgbox('Pulse "OK" Para Entrar Al Ambiente De Simulacion En El Dominio De
Laplace Con y Sin Tiempo Muerto','Bienvenido');
beep
global R K tau X r A w num den z p Rango Inicio sigma atraso Frecuencia Fase
Sobrepaso Decaimiento fin
disp(' :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
disp(' SIMULACION DE SISTEMAS LINEALES DE PRIMER Y SEGUNDO
ORDEN CON TIEMPO MUERTO');
disp(' ')
disp(' :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
disp(' ')
disp(' ')
disp(':::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
disp(' TIPO DE RESPUESTA DEL SISTEMA')
disp(' ')
Mach
215
disp(':::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
disp(' ')
disp('1. PASO')
disp('2. RAMPA')
disp('3. SENO')
disp(' ')
R = input('Escriba La Respuesta a Simular: ');
if (R < 1)|(R > 3)
errordlg('Selecione 1, 2 o 3')
beep
R = input('Escriba La Respuesta a Simular: ');
end
clc
disp(' ')
disp(' ')
switch R
case 1
clc
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' CAMBIO PASO EN LA VARIABLE DE ENTRADA')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
X = input('Introduzca El Valor Del Cambio Paso En La Variable De Entrada
= ');
disp(' ')
r=0;
A=0;
w=0;
case 2
clc
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' CAMBIO RAMPA EN LA VARIABLE DE ENTRADA')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
r = input('Introduzca El Valor De La Pendiente De La Rampa De Entrada = ');
Mach
216
disp(' ')
X=0;
A=0;
w=0;
case 3
clc
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' CAMBIO SENO EN LA VARIABLE DE ENTRADA')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
A = input('Amplitud De La Entrada Seno = ');
w = input('Frecuencia De La Entrada Seno = ');
disp(' ')
X=0;
r=0;
end
disp(':::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
disp(' PARAMETROS DE LA SIMULACION DINAMICA')
disp(' ')
disp(':::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
helpdlg('Si Desea Ver La Respuesta Sin Tiempo Muerto Digite "Cero" De Lo
Contrario Otro Valor','Tiempo Muerto')
beep
To = input('* Escriba El Valor Del Tiempo Muerto, s = ');
Rango = input('* Tiempo de simulación, s = ');
disp(' ')
clc
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' SISTEMAS')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' ')
disp('1. SISTEMA LINEAL DE PRIMER ORDEN: TANQUE CALENTADOR')
disp('2. SISTEMA LINEAL DE SEGUNDO ORDEN: VALVULA DE
CONTROL')
disp(' ')
Mach
217
S = input('¿ Que Sistema Desea Simular ?: ');

if (S < 1)|(S > 2)
errordlg('Selecione 1 o 2')
beep
S = input('¿ Que Sistema Desea Simular ?: ');
end
disp(' ')
disp(' ')
switch S
case 1
clc
disp(':::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
disp('¡USTED ESCOGIO SIMULAR EL SISTEMA LINEAL DE PRIMER
ORDEN: TANQUE CALENTADOR!')
disp(' ')
disp(':::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
disp(' ')
clc
disp(' ')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' PARAMETROS FISICOS DEL SISTEMA')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
F = input('* Flujo Volumetrico, m^3/s = ');
V = input('* Volumen Del Liquido En El Tanque, m^3 = ');
A = input('* Area De Transferencia De Calor, m^2 = ');
U = input('* Coeficiente Global De Transferencia De Calor, KW/m^2-ºC = ');
T = input('* Temperatura De Entrada Del Agua En Estado Estacionario, ºC =
');
C = input('* Calor Específico, KJ/Kg-ºC = ');
RHO = input('* Densidad Del Agua, Kg/m^3 = ');
disp(' ')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
Mach
218
disp(' PARAMETROS DINAMICOS DEL SISTEMA')

disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
tau = RHO*V*C/(F*RHO*C + U*A)
K = F*RHO*C/(F*RHO*C + U*A)
disp(' ')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' RESULTADOS')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
switch R
case 2
disp('Atraso De La Respuesta Lineal')
tau
case 3
disp('Amplitud Del Perfil Sinusoidal De La Respuesta');
K*A/sqrt(1+(w*tau)^2)
disp('Fase de la respuesta con respecto a la entrada');
atan(-w*tau)
end
STOP=input('Presione ENTER para ver la simulacion en Simulink');
clc
case 2
clc
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp('!USTED ESCOGIO SIMULAR EL SISTEMA LINEAL DE SEGUNDO
ORDEN: VALVULA DE CONTROL!')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' ')
Mach
219
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' PARAMETROS FISICOS DEL SISTEMA')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
M = input('* Masa Del Bloque, lbm = ');
C = input('* Coeficiente De Amortiguamiento Viscoso, lbf/pie/s = ');
K = input('* Constante De Hooke Del Resorte, lbf/pie = ');
A = input('* Area Del Diafragma, pie^2 = ');
disp(' ')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' PARAMETROS DINAMICOS DEL SISTEMA')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
tau = sqrt(M/(32.2*K))
K = A/K
sigma = sqrt((32.2*C^2)/(4*M*K))
disp(' ')
disp(' ')
disp(':::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
disp(' RAICES DE LA ECUACION CARACTERISTICA')
disp(' ')
disp(':::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::')
disp(' ')
p = [tau^2 2*sigma*tau 1];
z = roots(p)
disp(' ')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
disp(' RESULTADOS')
disp(' ')
disp('::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: ')
disp(' ')
switch R
case 1
if sigma > 1
Mach
220
disp('Respuesta Sobreamortiguada Estable')

disp('Atrasos Dinámicos')
atraso = -1./z
elseif sigma == 1
disp('Respuesta Amortiguada Crítica')
disp('Atrasos Dinámicos')
atraso = -1./z
elseif (sigma < 1)&(sigma > 0)
disp('Respuesta Subamortiguada Estable')
Frecuencia = sqrt(1-sigma^2)/tau
Fase = atan(sqrt(1-sigma^2)/sigma)
Sobrepaso = 100*exp(-pi*sigma/sqrt(1-sigma^2))
Decaimiento = (Sobrepaso/100)^2
elseif sigma == 0
disp('Respuesta Oscilatoria Sostenida')
else
disp('Respuesta Inestable')
end
case 2
if sigma > 1
disp('Respuesta Sobreamortiguada')
disp('Atrasos dinámicos')
atraso = -1./z
elseif sigma == 1
atraso = -1./z
disp('Respuesta Subamortiguada')
Frecuencia = (sqrt(1-sigma^2))/tau
Fase = atan(2*sigma*(sqrt(1-sigma^2))/(2*sigma^2-1))
elseif sigma == 0
else
end
case 3
if sigma > 1
disp('Respuesta Sobreamortiguada')
atraso = -1./z
Mach
221
Fase = atan(-w*atraso(1)) + atan(-w*atraso(2))

Amplitud = K*A/((sqrt(1+(w*atraso(1))^2))*(sqrt(1+(w*atraso(2))^2)))
elseif sigma == 1
atraso = -1./z
disp('Respuesta Subamortiguada')
elseif sigma == 0
else
end
end
STOP=input('Presione ENTER para ver la simulacion en Simulink');
clc
end
sim('Primer_Segundo_Orden')
Primer_Segundo_Orden
Archivo “ordenmayorsimulink”
clc
close all
global Ti Inicio K1 K2 K3 rho V Cv Cp w t0 tau1 tau2 tau3 h n m g11 g12 g13 g21
g22 g23 g31 g32 g33 G h11 h21 h31 H GH a11 a12 a13 a21 a22 a23 a31 a32 a33 A
b11 b21 b31 B C D f1 f2 T10 T20 K10 K20 V1 V2 r r2 P P2 Am wf Am2 wf2 NT
disp('
|******************************************************************|'
)
disp(' RESPUESTAS: PAS0, RAMPA Y SENO PARA SISTEMAS DE
ORDEN MAYOR')
disp('
|*******************************************************************
********|')
disp(' ')
disp(' |*********|')
disp(' SISTEMAS')
disp(' |*********|')
disp(' ')
Mach
222
disp('1. SISTEMA NO INTERACTUANTE')

disp('2. SISTEMA INTERACTUANTE')
disp(' ');
% CAPTURA DEL MODELO

S = [1 2];
S = input('Digite el numero del sistema que desee SIMULAR = ');
if S>2 | S<1
errordlg('El numero del sistema tiene que ser 1 o 2')
disp(' ')
S = input('Digite el numero del sistema que desee SIMULAR = ');
end
disp(' ');
disp(' |*************************************************|')
disp(' TIPO DE RESPUESTA DEL SISTEMA')
disp(' |*************************************************|')
disp(' ')
disp(' ')
disp('1. PASO')
disp('2. RAMPA')
disp('3. SENO')
disp(' ')
% CAPTURA DE LA RESPUESTA
R = [1 2 3];
R = input('Digite el numero de la respuesta a simular = ');
if R>3 | R<1
errordlg('El numero de la respuesta tiene que ser 1,2 o 3')
disp(' ')
R = input('Digite el numero de la respuesta que desee simular = ');
end
disp(' ')
disp(' |**********|')
disp(' DOMINIOS')
disp(' |**********|')
disp(' ')
disp('1. TIEMPO')
disp('2. LAPLACE')
disp('3. TIEMPO - ESPACIO DE LOS ESTADOS')
disp(' ')
% CAPTURA DEL DOMINIO

D = [1 2 3];
Mach
223
D = input('Digite el numero del dominio con que se va a hacer la simulacion = ');

if D>3 | D<1
errordlg('El numero del Dominio tiene que ser 1, 2 o 3')
disp(' ')
D = input('Digite el numero del dominio con que se va a hacer la simulacion = ');
end
disp(' ')
switch S
case 1
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' PARÁMETROS FÍSICOS DEL SISTEMA NO
INTERACTUANTE')
disp('
|*******************************************************************
**************|')
disp(' ')
% ENTRADAS
rho = input('Valor de la densidad, lb/pie3 = ');
V = input('Volumen de los tanques, pie3 = ');
Cv = input('Calor especifico a volumen constante, Btu/lb-°F = ');
Cp = Cv;
w = input('Flujo masico, lb/min = ');
Ti = input('Valor de Ti, °F = ');
t0 = input('Tiempo de simulación, min = ');
Inicio = input('Condiciones iniciales = ');
% PROCESO
tau1 = rho*V*Cv/(w*Cp);
tau2 = tau1;
tau3 = tau2;
K1 = w*Cp/(w*Cv);
K2 = K1;
K3 = K2;
switch R
case 1
disp(' ')
disp('
|*******************************************************************
**************|')
Mach
224
disp(' CAMBIO PASO DE UN SISTEMA NO INTERACTUANTE')

disp('
|*******************************************************************
**************|')
disp(' ')
% ENTRADAS
P = input('Cambio paso = ');
r=0;Am=0;wf=0;
switch D
case 1
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA PASO DE UN SISTEMA NO INTERACTUANTE EN
EL DOMINIO DEL TIEMPO')
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp('LAS CONSTANTES DE TIEMPO SON :')
disp(' ')
disp('tau1 = tau2 = tau3 = '), disp(tau1)
disp(' ')
disp('LAS GANANCIAS SON :')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
sim('nointerordenmayor')
nointerordenmayor
case 2
disp(' ')
Mach
225
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA PASO DE UN SISTEMA NO INTERACTUANTE EN
EL DOMINIO DE LAPLACE ')
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
nointerordenmayor
case 3
disp(' ')
disp('
|*******************************************************************
*****************************|')
disp(' RESPUESTA PASO DE UN SISTEMA NO INTERACTUANTE EN EL
DOMINIO DEL TIEMPO - ESPACIO DE LOS ESTADOS')
disp('
|*******************************************************************
*****************************|')
disp(' ')
% PROCESO
a11 = -1/tau1;
a12 = 0;
a13 = 0;
Mach
226
a21 = K1/tau2;
a22 = -1/tau2;
a23 = 0;
a31 = 0;
a32 = K2/tau3;
a33 = -1/tau3;
A = [a11 a12 a13; a21 a22 a23; a31 a32 a33]
b11 = K1/tau1;
b21 = 0;
b31 = 0;
B = [b11; b21; b31]
C = [1 0 0; 0 1 0; 0 0 1]
D = [0;0;0];
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
sim('nointerss')
nointerss
end
case 2
disp('
|*******************************************************************
**************|')
disp(' CAMBIO RAMPA DE UN SISTEMA NO
INTERACTUANTE')
disp('
|*******************************************************************
**************|')
disp(' ')
% ENTRADAS
r = input('Pendiente = ');
Mach
227
P=0;Am=0;wf=0;
switch D
case 1
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA RAMPA DE UN SISTEMA NO INTERACTUANTE EN
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
case 2
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA RAMPA DE UN SISTEMA NO INTERACTUANTE EN
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
Mach
228
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
case 3
msgbox('En el espacio de los estados solo se puede simular la respuesta paso')
disp(' ')
input(' Pulse ENTER para terminar y realizar una nueva Simulacion')
clc
close all
ordenmayorsimulink
end
nointerordenmayor
case 3
disp('
|*******************************************************************
**************|')
disp(' CAMBIO SENO DE UN SISTEMA NO INTERACTUANTE')
disp('
|*******************************************************************
**************|')
disp(' ')
% ENTRADAS
Am = input('Amplitud = ');
wf = input('Frecuencia (rad/seg) = ');
P=0;r=0;
switch D
case 1
disp(' ')
disp('
|*******************************************************************
**************|')
Mach
229
disp(' RESPUESTA SENO DE UN SISTEMA NO INTERACTUANTE EN

disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
case 2
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA SENO DE UN SISTEMA NO INTERACTUANTE EN
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
Mach
230
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
case 3
disp(' ')
clc
close all
ordenmayorsimulink
end
nointerordenmayor
end
case 2
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' PARÁMETROS FÍSICOS DEL SISTEMA
INTERACTUANTE')
disp('
|*******************************************************************
**************|')
disp(' ')
% ENTRADAS
rho = input('Valor de la densidad, lb/pie3 = ');
V1 = input('Volumen del primer tanque, pie3 = ');
V2 = input('Volumen del segundo tanque, pie3 = ');
f1 = input('Flujo volumetrico de entrada al primer tanque, pie3/min= ');
f2 = input('Flujo volumetrico de entrada al segundo tanque, pie3/min= ');
Cv = input('Calor especifico a volumen constante, Btu/lb-°F = ');
Cp = Cv;
T10 = input('Temperatura Inicial del Tanque 1, °F = ');
T10 = T20;
t0 = input('Tiempo de simulación, min = ');
Inicio = input('Condiciones iniciales = ');
% PROCESO
Cp = Cv;
Mach
231
tau1 = rho*V1*Cv/(rho*Cp*(f1 + 0.2*(f1 + f2)))

tau2 = rho*V2*Cv/(1.2*rho*Cp*(f1 + f2))
K10 = f1/(f1 + 0.2*(f1 + f2))
K20 = f2/(1.2*(f1 + f2))
K1 = 0.2*(f1 + f2)/(f1 + 0.2*(f1 + f2))
K2 = (f1 + 0.2*(f1 + f2))/(1.2*(f1 + f2))
switch R
case 1
disp('
|*******************************************************************
**************|')
disp(' CAMBIO PASO DE UN SISTEMA INTERACTUANTE')
disp('
|*******************************************************************
**************|')
disp(' ')
% ENTRADAS
NT = [1 2];
NT = input('Número del tanque a cambiar = ');
switch NT
case 1
P = input('Cambio paso en el Primer Tanque = ');
P2 =0;
case 2
P =0;
P2 = input('Cambio paso en el Segundo Tanque = ');
end
r=0;Am=0;wf=0;r2=0;Am2=0;wf2=0;
switch D
case 1
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA PASO DE UN SISTEMA INTERACTUANTE EN EL
DOMINIO DEL TIEMPO')
disp('
|*******************************************************************
**************|')
disp(' ')
Mach
232
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
sim('interordenmayor')
interordenmayor
case 2
disp(' ')
disp('
|*******************************************************************
**************|')
DOMINIO DE LAPLACE ')
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
interordenmayor
Mach
233
case 3
disp(' ')
disp('
|*******************************************************************
*****************************|')
DOMINIO DEL TIEMPO - ESPACIO DE LOS ESTADOS')
disp('
|*******************************************************************
*****************************|')
disp(' ')
% PROCESO
a11 = -1/tau1;
a12 = K1/tau1;
a21 = K2/tau2;
a22 = -1/tau2;
A = [a11 a12; a21 a22]
b11 = K10/tau1;
b12 = 0;
b21 = 0;
b22 = K20/tau2;
B = [b11 b12; b21 b22]
C = [1 0; 0 1]
D = [0 0;0 0]
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
sim('interss')
interss
end
Mach
234
case 2
disp('
|*******************************************************************
**************|')
disp(' CAMBIO RAMPA DE UN SISTEMA INTERACTUANTE')
disp('
|*******************************************************************
**************|')
disp(' ')
NT = [1 2];
switch NT
case 1
r = input('Pendiente en el Primer Tanque = ');
r2 =0;
case 2
r =0;
r2 = input('Pendiente en el Segundo Tanque = ');
end
P=0;Am=0;wf=0;P2=0;Am2=0;wf2=0;
switch D
case 1
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA RAMPA DE UN SISTEMA INTERACTUANTE EN EL
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
Mach
235

disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
case 2
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA RAMPA DE UN SISTEMA INTERACTUANTE EN EL
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
case 3
disp(' ')
clc
close all
ordenmayorsimulink
end
interordenmayor
case 3
Mach
236
disp('
|*******************************************************************
**************|')
disp(' CAMBIO SENO DE UN SISTEMA INTERACTUANTE')
disp('
|*******************************************************************
**************|')
disp(' ')
NT = [1 2];
switch NT
case 1
Am = input('Amplitud, Am = ');
wf = input('Frecuencia, wf (rad/seg) = ');
Am2 = 0;
wf2 = 0;
case 2
Am = 0;
wf = 0;
Am2 = input('Amplitud, Am2 = ');
wf2 = input('Frecuencia, wf2 (rad/seg) = ');
end
P=0;r=0;P2=0;r2=0;
switch D
case 1
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA SENO DE UN SISTEMA INTERACTUANTE EN EL
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
Mach
237

disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
case 2
disp(' ')
disp('
|*******************************************************************
**************|')
disp(' RESPUESTA SENO DE UN SISTEMA INTERACTUANTE EN EL
disp('
|*******************************************************************
**************|')
disp(' ')
% RESULTADOS
disp(' ')
disp(' |***********|')
disp(' RESULTADOS')
disp(' |***********|')
disp(' ')
disp(' ')
disp(' ')
disp('K1 = K2 = K3 ='), disp(K1)
disp(' ')
case 3
disp(' ')
clc
close all
ordenmayorsimulink
end
interordenmayor
Mach
238
end
end
disp(' ')
disp('===============================================
========================================= ')
disp(' ')
disp('1. NUEVA SIMULACION')
disp('2. TERMINAR LA SIMULACION')
disp(' ')
Sim=input('Escoger la opcion a realizar = ');
if Sim == 1
clc
close all
ordenmayorsimulink
else
if Sim ==2
clc
close all
end
end
Mach
Departamento de Electrónica
Universidad de Alcalá
“Introducción a MATLAB, Toolbox de

Control y Simulink”
Ingeniería Técnica de Telecomunicación

Especialidad Sistemas Electrónicos
“Introducción a MATLAB, Toolbox de Control y Simulink”
1. ¿QUÉ ES MATLAB?.
• Paquete software orientado al cálculo numérico, matrices,

procesamiento y análisis de la señal y gráficas
• Distintos campos de acción (aplicaciones):
Teoría de control
Tratamiento de señales
Inteligencia artificial
Diseño de sistemas de potencia
Control de procesos mecánicos, de aviación, automoción, etc.
Financiero
Mapeo y tratamiento de imágenes
Instrumentación y adquisición de datos
Identificación de sistemas
...
• Varios programas incluidos
MATLAB: Núcleo operativo de la herramienta matemática

Toolboxes: Librerías de funciones MATLAB asociadas a las
diferentes aplicaciones (Stateflow y Sisotool, interfaz gráfico,
control neuronal y borroso)
Simulink: Interfaz gráfico para el modelado y simulación de
sistemas
Blocksets: Bloques Simulink para aplicaciones específicas
Real Time Workshop, xPC Tarjet y desarrollo sobre DSPs y
FPGAs
Pág 2 Laboratorio de Sistemas Electrónicos de Control Continuo

I.T.T Sistemas Electrónicos
• Diferentes tipos de archivos:
*.M Ficheros por lotes (*.bat) sobre S.O. MATLAB

*.MAT Fichero de datos de MATLAB
*.DLL Ficheros ejecutables sobre Windows diseñados con
MATLAB
*.MDL Modelos de Simulink
Otros *.fis, *.tbl, etc. para toolboxes de control borroso, stateflow
y otros paquetes
ENTORNO DE TRABAJO
• Varias ventanas de trabajo dentro de MATLAB
Ventana de comandos:
Directamente sobre S.O. MATLAB
Entorno de trabajo (Workspace):
Visualiza las variables definidas en
cada instante
Editor de ficheros *.m: Editor
inteligente (colores e indentado)
con depurador paso a paso y
visualización de variables internas
Editor de ficheros *.mdl: Editor
gráfico para diseñar modelos de
Simulink
Elección del directorio de
trabajo: Explorador de Windows
Figuras: Potente editor de figuras
con posibilidad de incluir textos,
cambiar el formato, etc.


2. EL USO DE MATLAB
MANIPULACIÓN Y FORMATO DE DATOS
• Se trabaja con matrices de números reales o/y complejos.
• Los números complejos se definen gracias a los operadores i y j de

MATLAB. Así se puede escribir en MATLAB x=3+2j, que se definirá
como una matriz de tamaño 1x1
• Un escalar es una matriz de tamaño 1x1
• Una variable fila o columna es un vector, o un array
• Existen distintos formatos de datos con los que puede trabajar

MATLAB:
Short: 5 dígitos, punto fijo

Short e: 5 dígitos, punto flotante
Long: 15 dígitos, punto fijo
Long e: 15 dígitos, punto flotante
Hex: Hexadecimal
• Para indicar que se va a trabajar con uno u otro formato de datos

se utiliza la función de MATLAB “format”
GENERACIÓN DE MATRICES
• ¿Cómo generar una fila?
A=[a b c d e] ó A=[a, b, c, d, e]

• ¿Cómo generar una columna?

a 
b
 
B=[a; b; c; d; e] ó B = c 
 
d 
 e 
• ¿Cómo generar una matriz?
A= [a, b, c; d, e, f; g, h, i] ó
a b c 
A = d e f 
g h i 
• ¿Cómo generar un serie de datos?
A(punto inicial: incremento: punto final)
Ejemplo:
B=[1:1:8]
Con lo que se define un array B con el siguiente contenido:
B=[1 2 3 4 5 6 7 8 ]
SUBMATRICES Y ELEMENTOS DE UNA MATRIZ
• Para identificar un elemento de una matriz se usa la notación A(i,j)

dónde i es la i-ésima fila y j es la j-ésima columna.

Ejemplo:
Sea A la siguiente matriz:
1 2 3 
A = 4 5 6 
7 8 9 
Para identificar al nº 4 dentro de la matriz A se puede indicar como

A(2,1)
• Se puede identificar una parte de una matriz (submatriz) con la

siguiente notación:
A(fila_inicial:fila_final, col_inicial:col_final)
Ejemplo:
A partir de la matriz A definida en el ejemplo anterior, se define la

matriz B de la siguiente forma:
B=A(1:3,1:2)
Entonces B será una nueva matriz de valor:
1 2 
B = 4 5 
7 8 
Truco: El operador : puede utilizarse para identificar a todos los

elementos en una serie de datos. Así en el ejemplo anterior
B=A(1:3,1:2) es lo mismo que B=A(:,1:2)

VARIABLES
• A la hora de definir una variable (matriz, submatriz, array o escalar)

se distingue entre mayúsculas y minúsculas.
• Cuando se llama a una función de MATLAB sin especificar variable

de salida, se vuelca el resultado en la variable por defecto ans. La
notación ; omite la presentación del resultado en pantalla al final de
un comando
COMANDOS Y FUNCIONES DE MATLAB
• MATLAB posee gran número de funciones provenientes de:
MATLAB: Juego de funciones y operadores básico

Toolbox: Dependiendo del tipo añadirá funciones especiales
Generadas por el usuario: funciones o scripts
• Operadores de uso general (help general)
help Comando de ayuda

who (s) Lista de variables (con s indica info sobre variable)
what (o dir) Lista de ficheros .M y .MAT
clear Borrar variables
load Carga de variables desde un fichero
save Guardar variables a un fichero *.mat
cd Cambiar de directorio de trabajo
! Ejecutar funciones DOS
... Continúa en la línea siguiente
% Comentario en una función
demo Llamada a los ejemplos de uso de MATLAB
mex Compilar ficheros de MATLAB
Truco: Es muy recomendable el uso de la help de MATLAB

• Operadores para matrices y arrays y variables especiales (help

ops)
ans Most recent answer.

eps Floating point relative accuracy.
realmax Largest positive floating point number.
realmin Smallest positive floating point number.
pi 3.1415926535897....
i, j Imaginary unit.
inf Infinity.
NaN Not a number
isnan True for Not a number
isinf True for infinite elements.
isfinite True for finite elements.
why Succinct answer.
Nota: Es importantísimo tener en cuenta la propiedad conmutativa en

algunas operaciones aritméticas de matrices.
A/B ≠ B/A
ya que A/B= A*B-1 y B/A= B*A-1

• Otras funciones especiales, que se organizan en diferentes

categorías. Las que no pertenecen a ninguna toolbox ni blockset
específico se muestran en la siguiente tabla:
MATLAB\lang Programming language constructs.

MATLAB\elmat Elementary matrices & matrix manipulation.
MATLAB\elfun Elementary math functions.
MATLAB\specfun Specialized math functions.
MATLAB\matfun Matrix functions
MATLAB\datafun Data analysis and Fourier transforms.
MATLAB\audio Audio support.
MATLAB\polyfun Interpolation and polynomials.
MATLAB\funfun Function functions and ODE solvers.
MATLAB\sparfun Sparse matrices.
MATLAB\graph2d Two dimensional graphs.
MATLAB\graph3d Three dimensional graphs.
MATLAB\specgraph Specialized graphs.
MATLAB\graphics Handle Graphics.
MATLAB\uitools Graphical user interface tools.
MATLAB\strfun Character strings.
MATLAB\iofun File input/output.
MATLAB\timefun Time and dates.
MATLAB\datatypes Data types and structures.
MATLAB\verctrl Version control.
MATLAB\demos Examples and demonstrations.
De entre ellas se pueden remarcar algunas más interesantes:
• Polinomios (help polyfun)
roots Find polynomial roots.

poly Convert roots to polynomial.
polyval Evaluate polynomial.
polyvalm Evaluate polynomial with matrix argument.

residue Partial fraction expansion (residues).

polyfit Fit polynomial to data.
polyder Differentiate polynomial.
polyint Integrate polynomial analytically.
conv Multiply polynomials.
deconv Divide polynomials.
Además de éstas, en esta categoría, hay funciones específicas para

análisis geométrico y de interpolación.
• Estructuras del lenguaje MATLAB (help lang) (solo las más

representativas)
if Conditionally execute statements.

else IF statement condition.
elseif IF statement condition.
end Terminate scope of FOR, WHILE, SWITCH, TRY and IF
for Repeat statements a specific number of times.
while Repeat statements an indefinite number of times.
break Terminate execution of WHILE or FOR loop.
continue Pass control to the next iteration of FOR or WHILE loop.
switch Switch among several cases based on expression.
case SWITCH statement case.
otherwise Default SWITCH statement case.
try Begin TRY block.
catch Begin CATCH block.
return Return to invoking function.
error Display error message and abort function.
warning Display warning message.
lasterr Last error message.
lastwarn Last warning message.
disp Display an array.
display Overloaded function to display an array.
fprintf Display formatted message.

sprintf Write formatted data to a string.

input Prompt for user input.
keyboard Invoke keyboard from M file
pause Wait for user response.
uimenu Create user interface menu.
uicontrol Create user interface control.
• Generación de matrices (help elmat)
zeros Zeros array.

ones Ones array.
eye Identity matrix.
repmat Replicate and tile array.
rand Uniformly distributed random numbers.
randn Normally distributed random numbers.
linspace Linearly spaced vector.
logspace Logarithmically spaced vector.
freqspace Frequency spacing for frequency response.
meshgrid X and Y arrays for 3 D plots.

• Funciones Elementales.
sin Sine.
sinh Hyperbolic sine.
asin Inverse sine.
asinh Inverse hyperbolic sine.
cos Cosine.
cosh Hyperbolic cosine.
acos Inverse cosine.
acosh Inverse hyperbolic cosine.
tan Tangent.
tanh Hyperbolic tangent.
atan Inverse tangent.
atan2 Four quadrant inverse tangent.
atanh Inverse hyperbolic tangent.
sec Secant.
sech Hyperbolic secant.
asec Inverse secant.
asech Inverse hyperbolic secant.
csc Cosecant.
csch Hyperbolic cosecant.
acsc Inverse cosecant.
acsch Inverse hyperbolic cosecant.
cot Cotangent.
coth Hyperbolic cotangent.
acot Inverse cotangent.
acoth Inverse hyperbolic cotangent.
exp Exponential.
log Natural logarithm.
log10 Common (base 10) logarithm.
log2 Base 2 logarithm and dissect floating point number.
pow2 Base 2 power and scale floating point number.
sqrt Square root.
nextpow2 Next higher power of 2.
abs Absolute value.

angle Phase angle.

complex Construct complex data from real & imaginary parts.
conj Complex conjugate.
imag Complex imaginary part.
real Complex real part.
unwrap Unwrap phase angle.
isreal True for real array.
cplxpair Sort numbers into complex conjugate pairs.
fix Round towards zero.
floor Round towards minus infinity.
ceil Round towards plus infinity.
round Round towards nearest integer.
mod Modulus (signed remainder after division).
rem Remainder after division.
sign Signum.
• Análisis de datos
max Largest component.

min Smallest component.
mean Average or mean value.
median Median value.
std Standard deviation.
var Variance.
sort Sort in ascending order.
sum Sum of elements.
prod Product of elements.
hist Histogram.
histc Histogram count.
trapz Trapezoidal numerical integration.
diff Difference and approximate derivative.
gradient Approximate gradient.
cov Covariance matrix.
filter One dimensional digital filter.

filter2 Two dimensional digital filter

conv Convolution and polynomial multiplication.
convn N dimensional convolution
deconv Deconvolution and polynomial division.
fft Discrete Fourier transform.
fftn N dimensional discrete Fourier Transform.
ifft Inverse discrete Fourier transform.
ifftn N dimensional inverse discrete Fourier Transform.
• Manipulación de matrices
norm Matrix or vector norm.

normest Estimate the matrix 2 norm
rank Matrix rank.
det Determinant.
trace Sum of diagonal elements.
null Null space.
orth Orthogonalization.
inv Matrix inverse.
pinv Pseudoinverse.
lscov Least squares with known covariance.
eig Eigenvalues and eigenvectors.
svd Singular value decomposition.
gsvd Generalized singular value decomposition.
eigs A few eigenvalues.
svds A few singular values.
polyeig Polynomial eigenvalue problem.
expm Matrix exponential.
logm Matrix logarithm.
sqrtm Matrix square root.

FUNCIONES DE REPRESENTACIÓN GRÁFICA
• La función más importante es “plot”, que abre una ventana de figura

y representa en ella (en general) los datos que le son pasados
como parámetros. Para representar x=f(t) se hará la llamada
plot (t,x)
• Se puede incluir información sobre el formato del gráfico (color, tipo

de línea, etc). Las opciones posibles son las que se muestran a
continuación (help plot):
Tipo de línea
* star
Color + plus
y yellow -- dashed
m magenta x x-mark
c cyan -. dashdot
r red o circle
g green : dotted
b blue . point
w white - solid
k black ^ triangle (up)
< triangle (left)
> triangle (right)
v triangle (down)
d diamond
s square
p pentagram
h hexagram
• Permite realizar representaciones de varias señales en una misma

figura. Para ello simplemente se incluyen todas las variables en una
misma llamada a plot.

• Funciones asociadas a plot:
loglog Log log scale plot.

semilogx Semi log scale plot.
semilogy Semi log scale plot.
polar Polar coordinate plot.
zoom Zoom in and out on a 2 D plot.
grid Grid lines.
subplot Create axes in tiled positions.
plotedit Tools for editing and annotating plots.
legend Graph legend.
title Graph title.
xlabel X axis label.
ylabel Y axis label.
text Text annotation.
gtext Place text with mouse.
Merece la pena especial atención a la función “subplot” que divide la

pantalla gráfica (ventana de figura) en N filas y M columnas. El formato
función es subplot (N, M, J), donde J es la sub-figura sobre la que se
quiere dibujar.
• Funciones asociadas a las figuras en general
figure Create figure window.

clf Clear current figure.
close Close figure.
subplot Create axes in tiled positions.
cla Clear current axes.
axis Control axis scaling and appearance.
hold Hold current graph.
ishold Return hold state.
line Create line.
text Create text.

surface Create surface.

image Create image.
set Set object properties.
get Get object properties.
drawnow Flush pending graphics events.
Ejemplo:
Representar una señal senoidal y otra cosenoidal en la misma figura

entre 0 y 6π (3 periodos de la señal senoidal). Se haría de la siguiente
forma:
t=(0:0.1:6*pi) % el incremento de punto a punto de la

gráfica será de 0.1
x=sin(t) % se crea el vector x, será la salida senoidal
y=cos(t) % se crea el vector y, será salida cosenoidal
plot(t,x,’b’,t,y,’c+’) % se dibujan en la misma gráfica y con
distintos formatos de ploteado (color y
punteado)
Además, con las siguientes líneas de MATLAB se han incorporado los

textos a la figura:
grid
title(‘Ejemplo funcion seno y coseno’)
xlabel(‘tiempo’)
ylabel(‘seno/coseno’)
gtext(‘valor nulo’) % y se coloca el texto en el punto deseado
gtext(‘valor máximo’) % y se coloca el texto en el punto deseado
gtext(‘valor mínimo’) % y se coloca el texto en el punto deseado
El resultado es una ventana figura como la que se muestra a

continuación:

Ejemplo:
Se desea representar ahora las señales senoidal y cosenoidal en la

misma ventana de figuras pero por separado, por lo que se usa
subplot, de este modo:
subplot(2,1,1) % se elige la subfigura primera o superior: fila

1ª, columna 1ª
plot(t,x,'b')
grid
title(‘Ejemplo funcion seno’)
ylabel(‘seno’)
subplot(2,1,2) % se elige la subfigura segunda o inferior: fila
2ª, columna 1ª
plot(t,y,'c+')
grid
title(‘Ejemplo funcion coseno’)
ylabel(‘coseno’)
Tal y como se observa todas las funciones de dibujo se refieren a la

sub-figura elegida con la función subplot. El resultado es el que se
muestra a continuación:
Ejemplo funcion seno

1
0.5
seno
-0.5
-1
0 2 4 6 8 10 12 14 16 18 20
tiempo
Ejemplo funcion coseno
1
0.5
coseno
-0.5
-1
0 2 4 6 8 10 12 14 16 18 20
tiempo
FICHEROS *.M: SCRIPTS Y FUNCIONES.
• Son archivos tipo ASCII (se realizan en cualquier editor ASCII,

aunque conviene usar el que tiene MATLAB para ello, pues incluye
un depurador) que contienen una serie de órdenes incluso
llamadas a otros ficheros *. M
• Ambas se pueden llamar desde la línea de comandos de MATLAB

o desde otra estructura similar

• Los ficheros tipo scripts:
Están compuestos por llamadas a otras funciones de MATLAB

(parecido a las llamadas realizadas por DOS en los ficheros
*.BAT)
Puede utilizar las variables del entorno de trabajo (Workspace) y
devuelve los resultados a este mismo entorno. Se trata por tanto
de trabajo con variables globales
Se suelen utilizar para tareas de inicialización o de definición de
un gran número de variables en el entorno de trabajo
• Por su parte, las funciones:
Comienzan con la palabra clave function en la primera línea del

fichero
Es una aplicación (función) definida por el usuario a la que se le
pasan parámetros y que permite devolver parámetros, de forma
similar a funciones en ‘C’. La sintaxis para el paso de
parámetros es la siguiente:
function [salida1, salida2,...] = nom_función(param1, param2,...)
Las variables que utiliza son, por tanto, locales a la función

(principal diferencia con los scripts)
La función definida por el usuario se podrá invocar desde la
línea de comandos o desde cualquier script
Deben de coincidir el nombre del fichero y el nombre de la
función a implementar
Tras la primera línea (function... ) se inctroducen líneas de
comentario (comienzan por %), que serán la ayuda de la función
que se presente en la ventana de comandos de MATLAB
cuando se invoque a la ayuda de dicha función. Por ejemplo si
se define la función prueba de este modo:
function prueba()
%esta función no tiene parámetros de entrada ni de salida

Cuando se invoque a la ayuda de la función en la ventana de

órdenes de MATLAB aparecerá lo siguiente:
>> help prueba

>> esta función no tiene parámetros de entrada ni de salida
• Suele ser habitual utilizar sentencias de control (ver help lang) en la

escritura de las funciones y los scrips
• Algunas de las funciones más habituales en las funciones y los

scrips
Input: Asigna un valor introducido por teclado a una variable.

Muestra una cadena de caracteres.
Keyboard: Introduce un punto de ruptura en la secuencia de
ejecución de la función. En ese momento se le permite acceder
al usuario a las variables locales y globales del sistema. Se sale
de este modo tecleando RETURN
Pause: Introduce una pausa en la ejecución de la función. Se
continua con la ejecución pulsando cualquier tecla
Ejemplo:
Crear una función llamada MEDIA que calcule el valor medio de un

array.
function y=media(x)
[m,n]=size(x);
if m==1 %es por tanto un vector
y=sum(x)/n;
else
error ('Debes de introducir un vector');
end

Ejemplo:
Realizar una función en MATLAB que permita resolver un sistema

lineal de ‘n’ ecuaciones con ‘n’ incógnitas (siendo ‘n’ un valor
cualquiera). El formato de llamada a la función debe ser el siguiente:
[sol,n_sol]=sistema(S)
donde:
• sol= vector que contiene las soluciones al sistema
• N_sol= número de soluciones del sistema
• S=matriz que contiene los coeficientes y términos independientes de
las n ecuaciones en el siguiente formato:
3 − 1 1 - 2 
3a − b + c − 2 = 0
S = 5 2 3 - 1
5a + 2b + 3c − 1 = 0
- 1 5 - 2 - 5
− a + 5b − 2c − 5 = 0
function [sol,n_sol]=prac2_1(S)
%FUNCION QUE RESUELVE UN SISTEMA DE ECUACIONES
[filas,columnas]=size(S);
if (filas>columnas)
error('Sistema de ecuaciones no correcto')
else
%vector formado por la ultima col
Aux_1=S(:,columnas);
%Se convierten los términos independientes a valor

% positivo ya que el usuario los introduce como valor negativo
Aux_1=Aux_1*(-1);
columnas=columnas-1;
%matriz cuadrada formada por los coeficientes de las variables

Aux=S(:,1:columnas);
Aux_inv=inv(Aux); %Aux_inv=Aux-1
sol=Aux_inv*Aux_1; %matriz solucion

[n_sol, a]=size(sol); %retorno del resultado

end
Ejemplo:
Crear una función llamada MAXIMO que devuelva el mayor de los

elementos de un vector.
N=maximo(A)
• N= número mayor de A;
• A= vector enviado;
function x=maximo(A)
% Se introduce un vector y se obtiene el valor maximo de él
[m,n]=size(A); %Se saca el numero de columnas y filas

if m==1 %Se trata de un vector
long=length(A);
i=2;
sol=A(1);
while (i<=long)
if A(i)>=sol %Se compara si el valor actual es
%mayor que el anterior. Si lo es
sol=A(i); %se acumula
end %fin del if
i=i+1;
end %fin del while
x=sol;
else
error ('Introduce un vector y no una matriz');
end %fin del if principal

3. EL USO DE SIMULINK
• Herramienta gráfica incorporada a Matlab, que permite de forma

más fácil definir el modelo de sistemas de muy diferentes tipos (no
solo LTI) y aplicaciones
• Los elementos de trabajo de un modelo de Simulink son objetos o

iconos, agrupados en librerías que proporciona el paquete
integrado de Matlab para las distintas aplicaciones
• El fichero asociado a cada modelo es un *.MDL, que puede ser

abierto como un fichero *.M cualquiera (tiene una estructura
especial pero el funcionamiento es el mismo)
• Se puede llamar a la librería de bloques de Simulink (ventana

Simulink) desde la ventana de comandos tecleando “Simulink”, o
abrir directamente un fichero *.MDL
• Pasos a seguir para trabajar con Simulink:
1. Definición gráfica del modelo a simular con las librerías de

Matlab para Simulink
2. Simulación del modelo y análisis de resultados, que se pueden
mostrar directamente en Simulink o a través de Matlab enviando
los resultados al entorno de trabajo
• Librerías de Simulink Posee librerías distribuidas en función de la

aplicación. Tiene una librería básica, llamada Simulink, con el
siguiente contenido:
Sources (fuentes de señal)

Sinks (sumideros o almacén de resultados)
Continuous
Discrete
No linear

Signals&Systems (buses, multiplexores y demultiplexores,

puertos para enviar señales de un modelo a otro, etc.)
Math (trigonométricas, aritméticas, etc.)
Funciones y tablas (llamadas a funciones de Matlab o de usuario
y tablas de look-up)
...
• Hay librerías específicas para cada aplicación (Blocksets y

Toolboxes):
Control (controladores ya diseñados)

Control Borroso
Control Neuronal
Identificación
Power
DSP
Fixed Point
Comunicaciones
RTW y xPC Tarjet
Stateflow
User Interface
...
• El usuario puede definir nuevas librerías a partir de algún modelo

realizado, mediante los bloques S-function

OBJETOS BÁSICOS DE SIMULINK
• Fuentes: Emisores de información (Generadores de señales, señal

rampa, impulso, ...)
• Procesos: Bloques de E/S de todos los tipos antes mencionados
• Destinos: Receptores de información

• Conexiones: Son unidireccionales. Hipotéticos cables.
CREACIÓN DE UN MODELO SIMULINK
• Para generar un diagrama de bloques, una vez abierto un fichero

*.MDL nuevo y con ventana de Simulink, se sigue el siguiente
proceso:
1. Se abre la librería donde se encuentra el elemento necesario.

2. Para copiar un objeto de la sesión de trabajo, basta con
seleccionar el objeto y arrastrarlo
3. Para hacer una conexión entre una salida y una entrada, se
posiciona el cursor sobre la salida de la fuente o la entrada, se
pulsa el botón izquierdo del ratón y sin soltarlo se desplaza el
cursor hasta el otro punto que se desea unir
4. Haciendo doble click sobre los elementos copiados se modifican
los parámetros de éste. (Admiten parámetros que sean variables
de Workspace)
Ejemplo
Realizar el diagrama de bloques de la figura:
1. Se entra en Simulink y se abre una ventana nueva.

2. Se abre la librería continuous y se copian los bloques sumador y

F.T.
3. Se abre la librería sources y se copia el bloque escalón (step
input)
4. Se abre la librería sinks y se copia el bloque scope
5. Se unen mediante el ratón los bloques.
6. Se editan los bloques para que aparezcan como en la figura (en
el bloque “Trasnfer Fcn” Numerator y Denominator han de
contener los coeficientes del polinomio correspondiente en
potencias decrecientes de ‘s’). En el ejemplo:
Numerator [1 2]
Denominator [1 2 5]
7. Se salva el fichero (*.MDL).
Truco: Probar a definir los parámetros de configuración de los bloques

mediante variables definidas previamente en el entorno de trabajo de
MATLAB. De este modo se facilita el diseño de sistemas en base a un
modo de funcionamiento prueba-error
CONFIGURACIÓN DE LA SIMULACIÓN
• Es importante configurar la simulación antes de realizarla. Para

ello, en el menú principal de la ventana del modelo (*.MDL) creado
con Simulink ir a Simulation Parameters
• Permite configurar diferentes características sobre la simulación, a

saber:
La forma de resolver el sistema de ecuaciones diferenciales que

componen el modelo diseñado en Simulink y al tiempo de
simulación

Las variables de salida que ha de generar la simulación en el

entorno de trabajo de MATLAB
Otros parámetros avanzados de simulación, como la

configuración de los avisos y errores que ha de generar la
simulación por conexiones incorrectas, o la configuración de la
compilación del modelo con la herramienta RTW

• Con respecto al paso de SIMULACIÓN, es necesario tener en

cuenta ciertos aspectos básicos
El paso de simulación es el intervalo de integración de los

algoritmos de resolución del modelo
Se puede definir variable (lo fija Simulink en función del modelo
concreto a simular) en todos los casos excepto en la generación
de código RTW
Si el paso de simulación es muy bajo el tiempo de ejecución
elevado (puntos excesivos), y si es muy bajo la resolución es
peor (se pierde definición del sistema), pudiendo incluso llegar a
no representar correctamente le comportamiento del sistema al
no cumplir la teoría de sistemas muestreados (al fin y al cabo la
simulación de sistemas continuos con Simulink pretende
representar su comportamiento real en el tiempo)
Una regla práctica es hacer que el paso de simulación sea al
menos de la décima parte del tiempo de subida de la respuesta
del sistema
• Con respecto a las variables de salida de Simulink, es necesario

comentar también un punto:
Se pueden pasar las respuestas de las simulación al Workspace

de MATLAB a través de los bloques “to Workspace” de Simulink
Convendrá también tener en el entorno de trabajo el array de
tiempo con el que se ha generado la simulación
Éste se puede generar con un bloque “Clock” de Simulink y
pasarlo a MATLAB del mismo modo, pero también se puede
usar la variable tout que se genera automáticamente si así se
indica en la configuración de la simulación
La variable yout que se genera del mismo modo contiene el
resultado de las señales conectadas a puertos de salida del
modelo de Simulink

Ejemplo:
Visualizar el resultado de la simulación del modelo del ejemplo anterior
Nota: Prestar atención a que la respuesta coincida exactamente con

la aquí mostrada y modificar la configuración de los bloques de
Simulink correspondientes para que así sea
Ejemplo:
Variar el modelo anterior para implementar el siguiente sistema.

Visualizar desde MATLAB y desde Simulink los resultados (variable
Salida frente al tiempo)
Desde Simulink: con el bloque Scope:

Desde MATLAB:
>>plot(tout, Salida);
>>plot(tiempo, Salida);

Truco: Se puede arrancar la simulación de un modelo preexistente

(fichero *.MDL) con la función sim de MATLAB, con la siguiente
sintaxis:
[T,X,Y] = sim('modelo', [TInicio TFin] ,OPTIONS,UT)
Donde los parámetros 2º al 4º de la llamada a sim son opcionales
Ejemplo:
Realizar el siguiente diagrama de bloques y representar desde

MATLAB la señal de salida
¿Para qué sirve el multiplexor?

4. LA TOOLBOX DE CONTROL DE MATLAB
• Funciones de aplicación específica para ingeniería de control de

sistemas. Son ficheros *.M
• Sirve tanto para control continuo como para control discreto,

clásico (en espacios transformados sobre sistemas LTI) y de otros
tipos (variables de estado, borroso, neuronal, robusto, no lineal,
etc.)
• En los dos campos permite realizar tareas de: modelado,

conversión de modelos y análisis de respuesta temporal,
frecuencial y en espacios transformados
• Las herramientas para obtención de los modelos de los sistemas

se encuentran en otra Toolbox: la de identificación
• Todas las funciones de control se encuentran en la demo de

control que se ejecuta con el comando MATLAB: ctrldemo
MODELADO DE SISTEMAS DE CONTROL CONTINUO
• Las funciones de la toolbox en MATLAB permiten trabajar solo

sobre sistemas lineales e invariantes continuos y discretos en el
tiempo, y en espacio transformado
• Permiten representar los sistemas LTI mediante 4 modelos

diferentes en los espacios transformados (‘s’ para sistemas
continuos y ‘z’ para sistemas discretos):
Función de transferencia
Función Polo-Cero
Descomposición en fracciones simples
Variables de Estado

FUNCIÓN DE TRANSFERENCIA
• El formato Función de Transferencia (FT) corresponde con

representaciones del siguiente tipo:
num(s) a1 * sm -1 + a 2 * s m - 2 + ... + a ns m -n
H(s) = =
den(s) b1 * s j−1 + b 2 * s j- 2 + ... + b t * s j- t
• ¿Cómo se introduce en MATLAB una FT?: creando dos vectores

que contengan el valor de los coeficientes del numerador y
denominador del sistema en el espacio transformado
correspondiente
Ejemplo:
Obtenga el modelo MATLAB del siguiente sistema en formato FT:

3s 2 + 2s + 1
H(s) = 2
(s + 4s + 1)(s + 5)
A través de un fichero script, o de comandos de MATLAB:
num=[3 2 1]; %numerador

den1=[1 4 1]; %primer polinomio del denominador
den2=[1 5]; %segundo polinomio del denominador
den=conv(den1,den2); %multiplicación de dos polinomios
FORMATO POLO–CERO
• El formato polo–cero corresponde con representaciones del

siguiente tipo:
(s - z1 )(s - z 2 )(s - z 3 )...(s - z n )
H(s) = k
(s - p1 )(s - p 2 )(s - p 3 )...(s - p n )

• ¿Cómo se introduce en MATLAB un sistema en este formato?: en

este caso se crean dos vectores que contengan el valor de los
polos y los ceros (raíces del denominador y del numerador
respectivamente) de la función de transferencia del sistema a
representar
Ejemplo:
Obtenga el modelo MATLAB del siguiente sistema en formato cero-

polo:
(s + 1)(s + 2)
H(s) = 4
(s + 3)(s + 4)(s + 5)
Mediante un fichero script:
K=4; %constante del sistema

Z=[-1 –2]; %ceros del sistema
P=[-3 –4 –5]; %polos del sistema
CONVERSIÓN ENTRE FORMATOS
• Las siguientes funciones permiten realizar conversiones entre los

distintos formatos de representación de sistemas
residue Expansión en fracciones parciales

roots Obtiene las raíces de un polinomio
poly Obtiene un polinomio desde sus raíces
conv Permite multiplicar polinomios
tf2zp De FT a formato polo–cero
zp2tf De formato polo–cero a FT
c2dm, d2c Conversión entre el mundo discreto y el continuo
printsys Imprime la función de transferencia de un sistema

Ejemplo:
Transformar de formato función de transferencia a formato polo cero la

siguiente función:
N (s) 20( s + 10)( s 3 + 1)

G( s) = =
D( s ) s ( s + 2) 2 ( s 2 + 10 s + 100)( s 4 + 2 s 3 − 10)
En MATLAB:
num1=10;
num2=[1 10]; %(s+10)
num3=[1 0 0 1]; % (s^3+1)
NUM=conv(num1,(conv(num2,num3)));
den1=[1 0]; % (s)

den2=[1 2]; % (s+2)
den2=conv(den2,den2); %Generando (s+2)^2
den3=[1 10 100]; %(s^2+10s+100)
den4=[1 2 0 0 -10]; %(s^4+2s^3-10)
DEN=conv(den1,conv(den2,conv(den3,den4)));
[Z,P,K]=tf2zp(NUM,DEN); %CONVERSIÓN A CERO POLO
Ejemplo:
Transformar de formato polo-cero a formato función de transferencia la

siguiente función:
( s + 1)3
H ( s) =
( s + 4)( s + 3) 2 ( s 4 + s 3 + s 2 + 2)

En MATLAB:
Z=[-1; -1; -1 ]; %(s+1)^3

D1=roots([1 5 2]); %Obtención de las raíces de (s^2+5s+2)
B=[1 3];
D2=roots(conv(B,B)); %(s+3)^2
P=[4; D2; D1];
k=1;
[NUM,DEN]=zp2tf(Z,P,k);
Si una vez hecho esto, se hace desde la ventana de comandos una

llamada a printsys(NUM,DEN), el resultado es el siguiente:
s^3 + 3 s^2 + 3 s + 1
----------------------------------------------------
s^5 + 7 s^4 - 3 s^3 - 107 s^2 - 210 s - 72
GENERACIÓN DE DIAGRAMA DE BLOQUES, CONEXIÓN DE

SISTEMAS
• La toolbox de MATLAB para control incluye también funciones

para resolver las funciones de transferencia expresadas
mediante diagrama de bloques
• Las siguientes funciones permiten realizar conexiones entre los

distintos bloques que conforman un sistema de control
cloop Cierra el lazo realimentación unitaria

feedback Conexión mediante realimentación
series Conexión en serie de modelos
parallel Conexión en paralelo de sistemas

Ejemplo:
Obtener la función de transferencia total del sistema que se muestra a

continuación, suponiendo que se parte del conocimiento del
numerador y el denominador de cada bloque del diagrama
+ (s-1)(s-2)(s-3)
- +
Step Input - (s+1)(s+3)(s-4)
Sum Sum1
Zero-Pole Auto-Scale
Graph
25
s+10
Transfer Fcn
en MATLAB, de la siguiente forma:
[NUM,DEN]=feedback(NUMZP, DENZP, NUMTF,DENTF,-1);

[NUM,DEN]=cloop(NUM, DEN,-1);

5. FUNCIONES DE ANÁLISIS DE SISTEMAS CONTINUOS DE LA

TOOLBOX DE CONTROL (I)
• Conjunto de instrucciones que facilitan el análisis de la respuesta

temporal, frecuencial y lugar de las raíces de un sistema de control.
• En este punto solo se van a presentar las funciones relacionadas

con el análisis temporal
RESPUESTA TEMPORAL
• Se usa para obtener características temporales del régimen

transitorio y del permanente o estacionario, de la respuesta de un
sistema a entradas diversas
• Las funciones de la toolbox de MATLAB utilizadas para generar

respuestas temporales ante entradas variadas, son las siguientes
step Respuesta a un escalón

impulse Respuesta a un impulso
lsim Entrada aleatoria
ginput Averiguar valores de un determinado punto de la gráfica
damp Permite obtener ωn y ξ
dcgain Permite obtener la ganancia estática de una FT
Nota: Las funciones step e impulse generan automáticamente una

gráfica de la respuesta temporal, en caso de no pedir ningún valor de
salida

Ejemplo:
Dado el siguiente sistema determinar su respuesta al impulso y al

escalón:
1
H ( s) =
s +1
La respuesta al impulso se obtendrá mediante el siguiente comando:
>>impulse([1],[1 1]);
Impulse Response
1
0.9
0.8
0.7
0.6
Amplitude
0.5
0.4
0.3
0.2
0.1
0
0 1 2 3 4 5 6
Time (sec)

Posteriormente se llama a la función step, obteniéndose el resultado

gráfico que se muestra a continuación:
>>step([1],[1 1]);
Step Response
1
0.9
0.8
0.7
0.6
Amplitude
0.5
0.4
0.3
0.2
0.1
0
0 1 2 3 4 5 6
Time (sec)

6. FUNCIONES DE ANÁLISIS DE SISTEMAS CONTINUOS DE LA

TOOLBOX DE CONTROL (II)
• La toolbox de control de MATLAB posee un conjunto de funciones

que permiten realizar fácilmente trazados del Lugar de las Raíces
de un sistema realimentado, así como sacar información a partir de
éste
• Las funciones relacionadas con el trazado del Lugar de las Raíces

se muestran en la siguiente tabla
rlocus Trazado del Lugar de las Raíces (para ss. continuos y

discretos)
rlocfind Identificación concreta de un punto del lugar
pzmap Representación del diagrama de polos y ceros
sgrid Red de obtener ωn y ξ en el plano ‘s’
Nota: la función rlocus abre directamente una ventana de figura nueva

y dibuja en ella el Lugar de las Raíces del sistema cuya F(s) (o F(z))se
pasa como parámetro. Sin embargo, la función rlocfind necesita de la
ejecución previa de la anterior para operar
Ejemplo:
Se desea conocer el trazado del Lugar de las Raíces del sistema

siguiente:
s+13
K
s+10
Gain Transfer Fcn
1
s2 +1.5s+8
Transfer Fcn1

Para resolverlo se ejecuta desde MATLAB el siguiente conjunto de

comandos:
NUMG=[1 13] %Numerador de G(s)

DENG=[1 10] %Denominador de G(s)
NUMH=[1] %Numerador de H(s)
DENH=[1 1.5 8] %Denominador de H(s)
N=conv(NUMG,NUMH) %Numerador de G(s)H(s)
D=conv(DENG,DENH) %Denominador de G(s)H(s)
rlocus(N,D)
sgrid
Root Locus
40
40 0.28 0.19 0.135 0.095 0.06 0.03
35
30
30 0.4
25
20
20
15
0.7
10
10
5
Imag Axis
5
-10
10
0.7
15
-20
20
25
-30 0.4
30
35
-40 0.28 0.19 0.135 0.095 0.06 0.03
40
-12 -10 -8 -6 -4 -2 0
Real Axis

Ejemplo:
Obtenga para el sistema del ejemplo anterior cuál es el valor de K que

hace al sistema inestable
Dicho valor será aquél que haga que las raíces del lugar representado
anteriormente tengan parte real positiva. Para poder obtener dicho
valor se utiliza la función rlocfind, de esta forma:
>> rlocfind(N,D)
Obteniéndose el siguiente resultado en la ventana de comandos de

MATLAB:
>>Select a point in the graphics window

>>selected_point =
0.0482 +12.6479i
>>ans =
136.2106
Truco: Si se desea conocer además el valor que tienen todas las

raíces del sistema en lazo cerrado para esa K se deberá recoger como
parámetro de salida de rlocfind un vector que contendrá el dichos
valores de este modo:
>>[K,raices]= rlocfind(N,D)

Ejemplo:
Si se desea que el sistema tenga una respuesta con coeficiente de

amortiguación de valor 0.1, indique cuál sería el valor de K necesario y
compruebe el resultado con la función step
Para conocer el valor de K con ξ=0.1 se redibuja el Lugar de las

Raíces son rejilla y se invoca a la función sgrid de este modo
>> sgrid(0.1,2)
Donde el valor de ωn se ha fijado sin ningún criterio concreto
Después se llama vuelve a llamar a la función rlocfind, y se obtiene el

valor de K que será el fijado en el diagrama de bloques de Simulink
que permite obtener la espuesta al escalón del sistema en lazo
cerrado. El resultado se muestra en la figura siguiente:
20
15
10
-5
0 2 4 6 8 10 12 14 16 18 20

Para comprobar si la respuesta coincide con la de un sistema de

segundo orden típico, se obtiene el valor de Mp correspondiente al
coeficiente de amortiguación comentado. Calculando dicho valor el
resultado es de 72.9%
Como se observa, el Mp es mayor. Esto se debe a que el sistema en

lazo cerrado tiene además un cero y otro polo que no es del todo
dominante

Universidad Pontificia Comillas
E.T.S.I – I.C.A.I
Departamento de Electrónica y Automática
Manual de referencia de
MATLAB & SIMULINK
Febrero 2000
Adolfo Anta Martínez

Juan Luis Zamora Macho
Ramón Rodríguez Pecharromán
UPCo MATLAB & SIMULINK
ICAI - DEA Manual de referencia
Tabla de Contenidos
1. INTRODUCCIÓN................................................................................................................... 3
2. FUNCIONES MATEMÁTICAS COMUNES .......................................................................... 4
3. CARACTERÍSTICAS DE LA VENTANA DE COMANDOS ................................................. 6
3.1. CÓMO UTILIZAR EL WORKSPACE ....................................................................................... 6

3.2. FORMATOS DE NÚMEROS ................................................................................................. 6
3.3. GESTIÓN DE DIRECTORIOS ............................................................................................... 6
4. M-FILES ................................................................................................................................ 7
5. OPERACIONES CON VECTORES ...................................................................................... 9
6. REPRESENTACIONES GRÁFICAS .................................................................................. 11
6.1 LA FUNCIÓN PLOT .............................................................................................................. 11

6.2 ESTILOS DE LÍNEA, MARCAS Y COLORES .............................................................................. 12
6.3 FIJAR REJILLAS, EJES, Y ETIQUETAS.................................................................................... 13
7. TOOLBOX DE CONTROL ................................................................................................. 16
7.1 REPRESENTACIÓN DE UN SISTEMA ...................................................................................... 16

7.2 FUNCIONES ESPECÍFICAS ................................................................................................... 17
7.3 LTIVIEW .......................................................................................................................... 20
8. AYUDA................................................................................................................................ 22
8.1. EL COMANDO HELP ........................................................................................................ 22

8.2. LA VENTANA DE AYUDA................................................................................................... 22
9. SIMULINK ........................................................................................................................... 23
9.1 INTRODUCCIÓN .................................................................................................................. 23

9.2 CONSTRUCCIÓN DEL MODELO............................................................................................. 24
9.3 SIMULACIÓN ...................................................................................................................... 27
9.4 MODELADO DE UN SISTEMA FÍSICO ...................................................................................... 28
2
1. Introducción
MATLAB es una aplicación destinada a cálculos matemáticos, si bien dispone de
ciertas funciones destinadas a temas más específicos, como por ejemplo la ToolBox
de control, que facilita el estudio de sistemas dinámicos y su regulación.
Además, existe un complemento de MATLAB llamado SIMULINK, que nos permite un
enfoque más gráfico de los sistemas de control.
Al ejecutar MATLAB, aparecerá una ventana en blanco, llamada ventana de
comandos. La forma de trabajar con MATLAB es como con cualquier calculadora:
» 4*2 [ pulsamos enter]
ans =
8
A su vez, podemos usar variables para realizar nuestros cálculos:
» precio = 17;
» iva =0.16;
» precio_total =17 * (1+iva)
precio_total =
19.7200
Acabamos de crear tres variables, cuyo valor se guardará en memoria. En las dos
primeras sentencias se incluye un punto y coma al final, con lo que el resultado no
aparecerá por pantalla. El nombre que elijamos para nuestras variables tiene algunas
restricciones: no pueden tener un espacio intermedio, se distinguen mayúsculas de
minúsculas, y deben empezar por una letra.
Si queremos ver las variables que tenemos definidas, teclearemos el comando who:
» who
Your variables are:
iva precio precio_total
Por supuesto, se puede sobreescribir el nombre de una variable:

» iva =0.13;
(el programa no nos avisará de que esa variable ya existe) .
Para borrar todas las variables, existe el comando clear: tecleando clear iva borraría
esta variable , pero si escribimos sólo clear, borrará todo lo que hay en memoria; por
desgracia, una vez eliminadas, las variables no se pueden recuperar.
Podemos recuperar cualquier instrucción escrita previamente pulsando la tecla del
cursor . Para detener la ejecución de cualquier instrucción, hay que pulsar la
combinación de teclas Ctrl+C.
3
2. Funciones matemáticas comunes

MATLAB incluye ciertas funciones que nos permiten realizar cálculos más
complejos que sumar y restar. Para usar estas funciones, se procede de igual manera
que en una calculadora programable; por ejemplo, para realizar una operación que
incluya una raíz cuadrada escribimos:
» x = 3 - sqrt (5/6) * 2
x=
1.1743
Una lista breve de las funciones de MATLAB sería:
FUNCIONES HABITUALES
abs(x) Valor absoluto de x. Si x es un número complejo, abs(x) nos da

su módulo
acos(x)1 arco coseno de x
asin (x) arco seno de x
atan (x) arco tangente de x. Devuelve un ángulo entre -90º y 90º
atan2(x,y) arco tangente de x entre y. Devuelve un ángulo entre 0º y 360º
cos (x) coseno de x
sin (x) seno de x
tan (x) tangente de x
exp (x) exponencial ex
log(x) logaritmo neperiano de x
log10 (x) logaritmo en base 10 de x
rem(x,y) resto de la división x / y
unwrap(x) sitúa el ángulo x entre pi y -pi
roots(x) halla las raíces del polinomio x
fzero('f(x)',n) encuentra la solución de la ecuación f(x)=0; n es el valor por
donde empieza a iterar para hallar la solución.
(ej.- f(x)= 'x^2+x+3' )
sqrt(x) raíz cuadrada de x
angle (x) ángulo de x
real(x) parte real de x
imag(x) parte imaginaria de x
1
MATLAB trabaja únicamente en radianes.
4
Es recomendable trabajar con atan2 en vez de atan, pues si la parte real del número
complejo es negativa, el ángulo quedará en el segundo o tercer cuadrante. Por
ejemplo:
» 180/pi*atan(-2/3)
ans =
-33.6901
» 180/pi*atan(2/-3)
ans =
-33.6901
» 180/pi*atan2(-2,3)
ans =
-33.6901
» 180/pi*atan2(2,-3)
ans =
146.3099
Para la función atan los números complejos -2+3j y 2-3j tienen la misma fase; atan2,
sin embargo, nos da el ángulo correcto. Se ha multiplicado por 180/pi para obtener el
resultado en grados2.
Para definir un número complejo, se puede usar i o j como unidad imaginaria
indistintamente:
» c1=-1+2j
c1 =
-1.0000 + 2.0000i
» c1=-1+2i
c1 =
-1.0000 + 2.0000i
2
La constante pi viene definida por defecto en MATLAB
5
3. Características de la ventana de comandos
3.1. Cómo utilizar el Workspace

Todas las variables que hemos definido se guardan en el Workspace, que no es
más que el espacio de memoria que utiliza MATLAB.
Aparte de crear y borrar variables, resulta útil guardar sesiones de trabajo, es decir,
todas las instrucciones que hemos tecleado en la ventana de instrucciones. Para ello,
al inicio de la sesión tecleamos diary <nombre del fichero>. Podemos elegir el tipo de
archivo, si bien es recomendable que éste sea de texto (por ejemplo, diary
c:\regulación\resumen.txt). Para que deje de grabar la sesión teclearíamos diary off.
También podemos guardar únicamente el valor de algunas variables:
» save c:\regulación\datos x y
Aquí no es necesario añadir la extensión, y MATLAB creará el fichero con extensión
.mat. Las variables x e y han de estar previamente definidas.
Para recuperar las variables guardadas teclearemos:
» load datos
3.2. Formatos de números

Se habrá observado que por defecto todos los números nos aparecen con cuatro
decimales. Se puede cambiar el formato de salida seleccionando el menú
File\Preferences. Cabe destacar que, con el formato que aparece por defecto, algunos
números pueden aparecer por pantalla como 0.0000, aunque realmente no son 0 (sino
3.5·10-7, por ejemplo).
3.3. Gestión de directorios

Por defecto, al arrancar MATLAB empezamos en el directorio matlab\bin,
mientras que nuestros ficheros (M-files o modelos de SIMULINK) suelen estar en otras
carpetas.
Para "movernos" en MATLAB, usaremos los comandos típicos de MS-DOS: cd
para acceder a un directorio, dir para ver el contenido de un directorio, cd.. para salir
de una directorio.
6
4. M-files
Cuando realizamos cálculos simples, es habitual escribir las instrucciones en la
ventana de comandos. Sin embargo, cuando se van a realizar una serie de
operaciones más complicadas y de forma repetitiva, se utilizan los llamados M-Files;
son ficheros de texto donde tecleamos las instrucciones de MATLAB. Para crear un
nuevo archivo M, hacemos clic en File\New\M-File; nos aparecerá una ventana en
blanco para editar el archivo. Por ejemplo:
% Mi primer programa en MATLAB3

comp1=-2+3i;
comp2=-10+5i;
comp=comp1+comp2;
modulo=abs(comp)
fase=unwrap(180/pi*phase(comp))
Una vez guardado el archivo (con el nombre trabajo.m, por ejemplo), nos bastará
teclear su nombre en MATLAB, y se ejecutará directamente:
» trabajo
modulo =
14.4222
fase =
140.0267
Supongamos que queremos que este programa sirva no sólo para los complejos
comp1 y comp2. Para ello, bastará con borrar las dos primeras líneas del programa
anterior. Ahora tendremos que definir antes el valor de comp1 y comp2 (si no,
MATLAB nos dará un error diciendo que las variables comp1 y comp2 no están
definidas):
» comp1=-3+2i;
» comp2=-10+j;
» trabajo
modulo =
13.3417
fase =
160.7222
3
El símbolo % indica que esa línea es comentario.
7
También podíamos hacer que el programa pidiese los números complejos al usuario
(pues éste no tiene por qué saber qué es comp1 y comp2):
comp1=input('Introduzca el primer número complejo -> ');

comp2=input('Introduzca el segundo número complejo -> ');
comp=comp1+comp2;
modulo=abs(comp)
fase=unwrap(180/pi*phase(comp))
8
5. Operaciones con vectores

Hasta ahora, todas las variables utilizadas eran escalares. Por supuesto, también se
pueden definir vectores. Por ejemplo, queremos hallar el valor de seno (x) para
0 < x < p. Como es imposible hallar todos los valores (hay infinitos puntos), debemos
definir una serie de valores de x. Si tomamos 11 puntos, definiremos x de la forma:
» x=[0 0.1*pi 0.2*pi 0.3*pi 0.4*pi 0.5*pi 0.6*pi 0.7*pi 0.8*pi 0.9*pi pi]
x=
Columns 1 through 7
0 0.3142 0.6283 0.9425 1.2566 1.5708 1.8850
Columns 8 through 11
2.1991 2.5133 2.8274 3.1416
Tal como hemos visto, para crear un vector fila es necesario escribir entre corchetes
los elementos, separados por un espacio o una coma
Si ahora escribimos sin (x), hallaremos el seno de todos los valores de x:
» y=sin(x)
y=
Columns 1 through 7
0 0.3090 0.5878 0.8090 0.9511 1.0000 0.9511
0.8090 0.5878 0.3090 0.0000
Para manejar un único elemento del vector, por ejemplo seno(0.5*pi), nos referiremos
a él como el elemento 6 del vector y:
» y(6)
ans =
1
Si queremos utilizar los 5 primeros elementos, escribiremos y(1:5), y para tomar del
elemento 7 al último teclearemos y(7:end)
En caso de querer representar la función seno(x), necesitaríamos bastantes más de 11
elementos para obtener una gráfica aceptable. Escribir 1000 elementos resultaría
bastante tedioso. Como era de suponer, existe una forma “automática” de crear un
vector. La instrucción es: x= (valor_inicial:incremento:valor_final). Por ejemplo:
X=(0:0.01:pi); %Esta instrucción nos crea un vector x con valor inicial x, valor
%final pi, y la diferencia entre elementos consecutivos es 0.01*pi
9
Es muy recomendable escribir el "; " al final de la sentencia, pues si no aparecerán

cada uno de los elementos del vector por pantalla: 0, 0.01pi, 0.02pi , y así hasta pi.
Las diferentes formas de crear un vector aparecen resumidas en la siguiente tabla:
Construcciones básicas de vectores

X = [2 2*pi sqrt(2) 2-3j] Crea un vector con los elementos espeficados
X = primero : ultimo Crea un vector empezando en primero,
incrementando una unidad en cada elemento,
acabando en el elemento ultimo
X=primero:incremento:ultimo En este caso, el incremento no es 1 sino que es
fijado por nosotros
X=linspace(primero, ultimo,n) Crea un vector empezando en primero, acabando
en ultimo, con n elementos
X=logspace(primero, ultimo,n) Crea un vector logarítmico
De igual manera, se pueden crear matrices, escribiendo un "; " para indicar que es una
fila distinta:
» x= [ 2 3 ; 2 5 ]
x=
2 3
2 5
10
6. Representaciones gráficas
6.1 La función plot

Para representar gráficos en dos dimensiones, es habitual utilizar el comando
plot(eje x, eje y). Por ejemplo, si quisiésemos representar la función seno:
» x = (0:0.01:2*pi);
» y = sin(x);
» plot (x,y)
Debería aparecernos una ventana del tipo Figure:
Fig 1. Representacion gráfica de funciones con el comando plot
Esta gráfica se puede ampliar, reducir , cambiar su color y copiar para utilizarla en otro
documento.
Si ya teníamos abierta una ventana Figure, al usar plot, desaparecerá la gráfica
anterior sin previo aviso. Para evitarlo, añadiremos una nueva ventana tecleando
figure en MATLAB. Es posible dibujar más de una gráfica en una ventana, escribiendo
plot(eje x1, eje y1, eje x2, eje y2,...); por ejemplo:
11
» z = cos(x);
» plot(x,y,x,z)
También podemos dividir la ventana en varias partes con el comando subplot (m,n,i).
La ventana Figure se dividirá en una matriz de m por n pequeñas ventanas, y se
seleccionará la ventana i-ésima. Por ejemplo:
subplot(2,1,1); %La ventana Figure se dividirá en dos; selecionamos la primera

plot(x,y) %Representamos y=sin(x)
subplot(2,1,2); %Ahora selecionamos la segunda
plot(x,z) %Representamos z=cos(x)
0.5
-0.5
-1
0 1 2 3 4 5 6 7
0.5
-0.5
-1
0 1 2 3 4 5 6 7
Fig 2. Representación de varias gráficas con subplot
12
6.2 Estilos de línea, marcas y colores

Es posible modificar el color y estilo de las gráficas. Para ello, existen ciertos
parámetros que admite la función plot, y han de introducirse como un tercer
argumento, después de cada par de variables.
Símbolo Color Símbolo Marca Símbolo Estilo de línea

b Azul . Puntos - línea continua
g Verde O Círculos : línea punteada
r Rojo x cruces -. puntos y rayas
c Cyan + más -- discontinua
m Magenta * estrellas
y Amarillo s cuadrados
k Negro d diamantes
w Blanco p pentagramas
Por ejemplo:
» plot( x, y, 'rx', x, z, 'o--')
Fig 3. Estilos de línea y colores con la función plot
13
6.3 Fijar rejillas, ejes, y etiquetas

– Para fijar una cuadrícula en la ventana Figure, basta con teclear grid on. Para
quitarla, escribimos grid off.
– Podemos escribir los nombres de los ejes y de la gráfica:
» title('Representación de las funciones seno y coseno’'), xlabel ('variable
independiente'), ylabel ('variables dependientes')
– Podemos escribir en el gráfico con la función gtext:
» gtext('cos(x)')
Al pulsar enter nos aparecerá la ventana Figure; con el ratón podemos decidir
dónde situar el texto
– Existe también el comando legend, cuya función es similar a la de gtext:
» legend (‘variable Y’, ‘variable Z’)
El cuadro de la leyenda se puede situar donde queramos, arrastrandolo con el
ratón.
– También se puede cambiar los ejes, con el comando axis:
La estructura a escribir es: axis ([xmin xmax ymin ymax])
» axis([0 2*pi -1.5 1.5])
Para volver al autoescalado, teclearemos axis auto. Otra forma de ampliar o
reducir las gráficas es usando la función zoom. Los comandos zoom y legend no
pueden estar activos a la vez, pues los dos responden al clic del ratón.
– Se puede tomar valores de una gráfica con la instrucción ginput. Una vez
tecleado ginput, nos aparecerá la ventana Figure, y con el ratón haremos clic en
el punto que queramos conocer. Después pulsaremos enter y el valor de las
coordenadas del punto aparecerán en la ventana de comandos de MATLAB.
Después de todas estas operaciones, la gráfica resultante es:
14
Representación de las funciones seno y coseno

1.5
s 0.5 sen(x)
et cos(x)
n
ei
d
n
e
p 0
e
d
s
el
b -0.5
ai
r
a
v
-1 variable Z
variable Y
-1.5
0 1 2 3 4 5 6
variable independiente
Fig 4. Edición de figuras en MATLAB
15
7. Toolbox de control 4
7.1 Representación de un sistema

El primer problema que se nos plantea es la definición de un sistema. Los
sistemas se suelen expresar en forma de función de transferencia. Ésta se puede
expresar como cociente de polinomios, con la instrucción tf : escribiremos entre
corchetes los coeficientes de numerador y denominador (en sentido descendente de
las potencias de la variable s).
» planta = tf ( [ 1 1] , [3 2 5] );
1+ S
nos definiría F ( s) = 2
3× S + 2× S + 5
De esta representación, podemos quedarnos únicamente con el numerador y/o
denominador:
» [num,den] = tfdata (planta , ' v ' )5
num = 0 1 1
den =
3 2 5
u obtener los polos y ceros del sistema:
» [z,p,k] = tf2zp (num,den);

z=
-1
p=
-0.3333 + 1.2472i
-0.3333 - 1.2472i
k=
0.3333
, donde k no es la ganancia estática, sino la que se obtiene al expresar la función de

transferencia en forma de polos y ceros.
También podemos obtener la descomposición en fracciones simples:
» [r, p, k] = residue (num,den)

r=
0.1667 - 0.0891i
0.1667 + 0.0891i
4
Teclear ctrldemo para ver una demostración de las posibilidades que ofrece esta Toolbox
5
El argumento 'v' se incluye para obtener numerador y denominador en forma de vectores
16
p=
-0.3333 + 1.2472i
-0.3333 - 1.2472i
k=
[]
El coeficiente k representa el término independiente, que valdrá 0 siempre que el

orden del numerador sea inferior al del denominador.
Es decir, F(s) también se puede expresar como:
0.1667 - j 0.0891 0.1667 + j 0.0891

F ( s) = +
S + 0.3333 - j 1.2472 S + 0.3333 + j 1.2472
7.2 Funciones específicas

Existen diversos comandos en MATLAB para dibujar gráficos de respuesta en
frecuencia:
» bode (planta) % Diagrama de Bode
» pause
» nichols (planta) % Diagrama de Black
» pause
» nyquist (planta) % Diagrama de Nyquist desde w = -¥ hasta w = +¥
Si no incluyesemos la instrucción pause, nos aparecerá únicamente la última gráfica

(el diagrama de nyquist en nuestro ejemplo); de esta manera, nos mostrará el primer
diagrama, y no pasará al siguiente hasta pulsar cualquier tecla.
Si queremos dibujar un diagrama para unas pulsaciones determinadas, es necesario
definirse previamente el vector de pulsaciones w:
» w = logspace (-2, 3, 1001); % Creamos vector w, con valor inicial en 10-2, valor
% final = 103, con 1001 puntos
» bode (planta,w)
Podemos hallar también los márgenes de ganancia y/o fase y pulsaciones asociadas:
» [ganancia, fase] =bode (planta);

» [Mg,Mf,wu,wo]=margin (ganancia,fase,w)
Mg =
7.3343
17
Mf =
Inf
wu =
1.8258
wo =
NaN
En este caso, no tenemos margen de fase, y por tanto no existe la pulsación de cruce
(el término NaN significa Not-A-Number).
Existen también funciones para dibujar el lugar de las raíces:
» rlocus(planta)
1.5
0.5
si
x 0
A
g
a
mI
-0.5
-1
-1.5
-4 -3 -2 -1 0 1
Real Axis
Fig 5. Lugar de las raíces de la función de transferencia "planta"
Con este gráfico, es posible diseñar para obtener unos polos determinados. Para
obtener mayor precisión, es conveniente dibujar una rejilla radial:
» zeta=0:0.1:1; % Definimos x y wn
» wn=1:10;
» sgrid(zeta,wn) % Nos muestra rectas de pendiente zeta y
% circunferencias de radio wn
» zoom
18
Y ahora hallamos la ganancia necesaria para obtener los polos
» [gan,polos]=rlocfind(planta) % Aparece un cursor en la ventana del

% lugar de las raíces
Select a point in the graphics window
selected_point =
-1.0554 + 1.4078i
gan =
4.3339
polos =
-1.0557 + 1.4131i
-1.0557 - 1.4131i
Otras funciones útiles de esta Toolbox son:
dcgain(sistema) Halla la ganancia estática del sistema

[num,den]=pade(T, n) Devuelve el numerador y denominador de una
aproximación de Pade de e-TS, de orden n
minreal(sistema) Simplifica la función de transferencia de sistema
Para empezar a simular con nuestra función de transferencia, existen numerosas

funciones en MATLAB(step, impulse), si bien lo más sencillo es utilizar SIMULINK o
LTIVIEW.
19
7.3 LTIVIEW
Todo lo que hemos visto hasta ahora se puede hacer con un único comando de
forma más intuitiva. Para ello, tecleamos ltiview. Nos aparecerá la siguiente pantalla:
Funciones de Fig 6. Pantalla del LTIVIEW

transferencia Tipo de gráfica
En el recuadro Workspace nos aparecen todas las funciones de transferencia

que hemos definido. Para seleccionar una de ellas, hacemos doble clic. En Plot Type,
podemos elegir el tipo de gráfica: ante un escalón, diagrama de Bode, Nyquist, lugar
de las raíces, etc; además, al seleccionar uno de ellos, nos aparecerá en Plot Options
varias posibilidades; por ejemplo, para un escalón, nos muestra el tiempo de
establecimiento, pico ,etc.; y para cualquier diagrama de respuesta en frecuencia,
podemos ver el margen de fase y ganancia de nuestra planta.
20
Al seleccionar una de estas opciones, nos aparecerá un punto en la gráfica; para ver
cuál es el valor en concreto, es necesario mantener pulsado el ratón en ese punto.
Fig 7. Análisis de sistemas con LTIVIEW
21
8. Ayuda
Existen demasiados comandos en MATLAB para poder recordarlos. Para
facilitarnos la labor, se ha creado un archivo de ayuda al cual podemos recurrir en todo
momento.
8.1. El comando help

Para recurrir a la ayuda, basta con teclear help nombre_de_función. Si escribimos help
a secas, nos aparecerá una lista de categorías de las funciones disponibles. Por
ejemplo:
» help sqrt
SQRT Square root.
SQRT(X) is the square root of the elements of X. Complex
results are produced if X is not positive.
See also SQRTM
El comando help nos muestra una pequeña descripción de la función, y también una
serie de comandos relacionados (en este caso sqrtm, que nos permite hacer raíces
cuadradas de matrices).
Aunque en la ayuda aparezca la función en mayúsculas, al usarla hemos de escribirla
en minúscula (pues SQRT daría error).
Si no conocemos en concreto el nombre de la función, podemos usar el comando
lookfor:
»lookfor complex
nos mostrará todas las funciones relacionadas con números complejos.
También es útil el comando demo , que nos mostrará una pantalla con demostraciones
de todas las posibilidades que ofrece MATLAB.
8.2. La ventana de ayuda

Existe una ventana específica para la ayuda de MATLAB. Para que aparezca,
escribimos helpwin o hacemos clic en el icono , en la barra de herramientas.
La ventana contiene un listado de todas las categorías de MATLAB. Haciendo clic en
cualquiera de ellas, pasaremos a una pantalla donde aparecen todas las funciones de
esa categoría. El botón Tips nos describe brevemente cómo usar la ayuda.
22
9. Simulink
9.1 Introducción
Simulink es una extensión de MATLAB para la simulación de sistemas dinámicos.
Al ser un entorno gráfico, resulta bastante sencillo de emplear. Para ejecutar Simulink,
podemos teclear simulink desde MATLAB, o bien hacer clic en el icono , en la barra
de herramientas de MATLAB.
Nos aparecerán dos ventanas: una con las librerías de Simulink, y otra en blanco
donde construiremos nuestro nuevo modelo.
Fig 8. Librerías de Simulink
En cada uno de los grupos que aparecen en la fig. 3, estarán los bloques necesarios
para simular nuestro sistema de control. Por ejemplo, haciendo doble clic en Linear
aparecerá la siguiente ventana:
23
Fig 9. Contenido de la librería Linear
9.2. Construcción del modelo
Supongamos que se tiene el siguiente sistema de control:
ref Salida
10 S +1
_ S + 3·S + 5
Fig 10. Diagrama de bloques del sistema de control
24
Para construirlo en Simulink, seguiremos los siguientes pasos:

En el grupo Linear, elegimos el bloque Sum, y lo arrastramos hasta nuestra ventana
vacía.
Del mismo grupo, elegimos Transfer Fcn y Gain.
Para introducir los valores que tendrán los bloques, hacemos doble clic en cada uno
de ellos. Nos aparecerá el cuadro de diálogo correspondiente:
Fig 11. Introducción de valores para cada bloque
Se hará de igual manera para la constante (Gain) y el punto de suma (Sum), en el que
pondremos +-
Cada bloque tiene en sus extremos una o varias flechas. Al situarnos con el ratón en
esas flechas, el puntero pasa a ser una cruz. Para conectar los bloques, arrastramos
hasta la flecha del siguiente bloque.
Ahora necesitamos poner la referencia. Para ello, hacemos doble clic en el grupo
Sources, y elegimos Step. Lo arrastramos hasta la ventana donde tenemos el modelo.
Para cambiar los valores del escalón, y el tiempo en que éste se produce, hacemos
doble clic en el bloque. Por defecto, el escalón es unitario y se da en t=1.
Por último, para ver la salida (o cualquier otra señal) hay varias posibilidades. Las dos
más utilizadas son los bloques Scope y To Workspace (en el grupo Sinks).
El bloque Scope nos permite ver el comportamiento de una señal mientras se simula.
Por el contrario, To Workspace guarda la señal en memoria, para poder dibujarla
después de la simulación (con el comando plot) o guardarla en un fichero de datos
.mat.
25
El modelo en Simulink quedará como en la figura siguiente:
Fig 12. Modelo de Simulink del sistema de control
La orientación por defecto de los bloques es "a derechas" (la entrada está en la
izquierda, la salida en la derecha). Esto se puede cambiar seleccionando el bloque y
pulsando Ctrl+R o en el menú Format/Rotate Block.
Después de construir el modelo, resulta conveniente guardarlo antes de empezar a

simular (Menú File/Save as..). Los modelos de Simulink se guardan con extensión .mdl
26
9.3. Simulación
Para simular el sistema ya construido, elegimos Start del menú Simulation. En
este menú también hay otras opciones; la única que usaremos es Parameters:
Fig 13. Introducción de los parámetros de la simulación
En este recuadro elegimos las características de la simulación. Las más importantes

es Start time (que suele ser 0.0) y Stop time. Ésta última se tendrá que ajustar a
nuestro sistema, pues por ejemplo un sistema mecánico es mucho más rápido que
uno térmico, y necesitará menos tiempo para llegar al régimen permanente.
Una vez empezada la simulación, ésta se puede parar o hacer una pausa (en el
mismo menú Simulation/Stop y Simulation/Pause)
Si queremos ver la salida, hacemos doble clic en el bloque Scope. Nos aparecerá la
siguiente pantalla:
27
Fig 14. Visualización de la respuesta mediante el bloque Scope
En la barra de herramientas existen varios iconos: los tres primeros fijan el tipo de
zoom (ampliar eje x y eje y, sólo eje x o solo eje y ). El cuarto icono (con el símbolo de
los prismáticos) hará que aparezca en pantalla la gráfica completa. El quinto nos
guarda la configuración de los ejes para posteriores simulaciones, y el último nos
permite fijar los ejes, y la cantidad de datos que queremos guardar.
9.4 Modelado de un sistema físico

No siempre disponemos de una función de transferencia, sino que tenemos un
conjunto de ecuaciones que nos describe el comportamiento de un sistema real.
Esta función de transferencia se podría obtener resolviendo el sistema de ecuaciones,
pero resulta más sencillo utilizar Simulink. Para ello, nos construimos cada una de las
ecuaciones con bloques. Después hemos de definir una entrada y una salida,
mediante los bloques In y Out, que aparecen en el gupo Connections, pues la función
Y ( s) salida
de transferencia se representa como F ( s ) = = .
U ( s ) entrada
Guardamos el modelo, y después, desde MATLAB, escribimos las siguientes
instrucciones:
>> [A,B,C,D]=linmod ('mi_planta'); %Donde 'mi_planta' es el nombre del archivo
28
>> [num,den]=ss2tf (A,B,C,D);
Ejemplo:Intentaremos modelar el siguiente sistema térmico:
Datos:
Potencia inyectada en bloque 3
Temperatura controlada en bloque 3
C1= 2 min kW / ºC C2= 2.5 min kW / ºC C3= 3.5 min kW / ºC
R13 = 7.5 ºC / kW R23 = 10 ºC / kW R30 = 15 ºC / kW
6
Las ecuaciones que nos describen este sistema son:
1 1 1
Pg ( s ) = C3 ·T3 ( s )·s + ·(T3 ( s ) - T2 ( s )) + ·(T3 ( s ) - T1 ( s )) + ·(T3 ( s ) - T0 ( s ))
R32 R31 R30
1
·(T3 ( s ) - T1 ( s )) = C1·T1 ( s )·s
R31
1
·(T3 ( s ) - T2 ( s )) = C2 ·T2 ( s )·s
R32
Representando estas ecuaciones en un modelo de Simulink, nos queda:
6
No se ha considerado el efecto de una posible perturbación, pues hemos de definir una única entrada y salida
29
[T3]
1
1/15 1/60 [T1]
s
[T1]
[T3]
1
1/25 1/60 [T2]
s
[T2]
[T3]
1/7.5
[T1]
[T3]
1/10 1
Out
[T2]
1
1/3. 1/60 [T3]
[T3] 1/15 s
1
In
Fig 15. Modelo de Simulink que representa el sistema térmico
Para construir el modelo de una forma más clara, se han utilizado Tags o etiquetas
(que se encuentran en Connections)
El término 1/60 corresponde al cambio de unidades de minutos a segundos
Ahora escribimos en MATLAB:
>> [A,B,C,D]=linmod ('mi_planta');

>> [num,den]=ss2tf (A,B,C,D);
>> planta =tf(num,den)
La función de transferencia entre la potencia aportada al sistema y la temperatura a

controlar queda:
T3 ( s ) 0.004762·S 2 + 8.466·10 -6 ·S + 3.527·10-9

= 3 (en segundos)
Pg ( s ) S + 0.0032·S 2 + 2.257310 - 6 ·S + 2.352·10-10
30
Una vez modelado el sistema, resulta conveniente crear un bloque que agrupe
nuestro sistema real. Para ello, seleccionamos todos los bloques, pulsando en una
esquina y arrastrando hasta englobar a todos los elementos (no con la opción
Edit/Select all). Después hacemos clic en Edit/Create subsystem, que debería
aparecer habilitada. Debería quedarnos una ventana así:
En este diagrama de bloques sí se ha incluido la perturbación.
31
Introducción a Matlab y Simulink
Regulación Automática
Ingeniero en Electrónica. Curso 2006/2007.
Javier Aracil y Fabio Gómez–Estern
1. Introducción
Matlab es un programa de gran aceptación en ingenierı́a destinado realizar cálculos

técnicos cientı́ficos y de propósito general. En él se integran operaciones de cálculo,
visualización y programación, donde la interacción con el usuario emplea una notación
matemática clásica.
Los usos y aplicaciones tı́picos de Matlab son:
Matemáticas y cálculo.
Desarrollo de algoritmos.
Adquisición de datos.
Modelado, simulación y prototipado.
Análisis y procesado de datos.
Gráficos cientı́ficos y de ingenierı́a.
Desarrollo de aplicaciones.
El tipo básico de variable con el que trabaja Matlab es una matriz que no requiere
ser dimensionada previamente en la declaración. Una de las caracterı́sticas más intere-
santes consiste en que el álgebra vectorial y matricial se expresa con la misma sintaxis
que las operaciones aritméticas escalares. Por ejemplo, en lenguaje C, para realizar la
suma de dos variables enteras o reales b y c, escribiremos:
a=b+c;
Mientras que en Matlab, emplearemos la misma sentencia tanto si b y c son enteros,

reales, vectores o matrices.
1
2. Componentes de Matlab
Matlab consta de cinco partes fundamentales:
1. Entorno de desarrollo. Se trata de un conjunto de utilidades que permiten el

uso de funciones Matlab y ficheros en general. Muchas de estas utilidades son
interfaces gráficas de usuario. Incluye el espacio de trabajo Matlab y la ventana
de comandos.
2. La librerı́a de funciones matemáticas Matlab. Se trata de un amplio con-

junto de algoritmos de cálculo, comprendiendo las funciones más elementales
como la suma, senos y cosenos o la aritmética compleja, hasta funciones más
sofisticadas como la inversión de matrices, el cálculo de autovalores, funciones de
Bessel y transformadas rápidas de Fourier.
3. Gráficos. Matlab dispone de un conjunto de utilidades destinadas a visualizar

vectores y matrices en forma de gráficos. Existe una gran cantidad de posibili-
dades para ajustar el aspecto de los gráficos, destacando la visualización tridi-
mensional con opciones de iluminación y sombreado, y la posibilidad de crear
animaciones.
4. El interfaz de aplicación de Matlab (API). Consiste en una librerı́a que

permite escribir programas ejecutables independientes en C y otros lenguajes,
accediendo, mediante DLLs, a las utilidades de cálculo matricial de Matlab.
De estos cuatro puntos, en este capı́tulo trataremos, de forma somera, los dos
primeros.
Los ejemplos que se presentan en este texto, se han desarrollado para la versión de
Matlab 7.0. ellos no impide que puedan funcionar con otras versiones del programa.
Concretamente, para la versión 6.5 y posteriores está prácticamente garantizado el
funcionamiento.
Sin embargo, hay que señalar que algunos complementos de Matlab no aparecen
incluidos en la instalación básica del mismo, por tanto un programa que funciona en
un ordenador con la versión 7.0 instalada, puede fallar en otro ordenador con la misma
versión.
La gestión de complementos de Matlab se realiza mediante lo que se denominan

toolboxes (paquetes de herramientas). Un Toolbox de Matlab es un conjunto de fun-
ciones y algoritmos de cálculo especializados en un área de conocimiento: finanzas,
tratamiento de señales, teorı́a de sistemas, etc. Para el desarrollo del curso es necesario
2
tener instalado, aparte del sistema básico de Matlab, el denominado Control System
Toolbox.
3. Simulink
Simulink es una aplicación que permite construir y simular modelos de sistemas

fı́sicos y sistemas de control mediante diagramas de bloques. El comportamiento de
dichos sistemas se define mediante funciones de transferencia, operaciones matemáticas,
elementos de Matlab y señales predefinidas de todo tipo.
Simulink dispone de una serie de utilidades que facilitan la visualización, análi-

sis y guardado de los resultados de simulación. Simulink se emplea profusamente en
ingenierı́a de control.
En el presente curso trabajaremos con la versión 6.0, que viene incluida en el paquete
de Matlab 7.0. Su instalación es opcional, por tanto debemos seleccionar la opción
correspondiente al instalar el programa
4. El entorno de trabajo de Matlab
4.1. Ayuda en lı́nea
Si se ha seleccionado la la opción correspondiente en la instalación de Matlab, po-

dremos acceder a la ayuda en lı́nea en todo momento pulsando la tecla F1. Dicha
documentación está organizada con un ı́ndice en forma de árbol y mediante herramien-
tas de navegación como hipervı́nculos. Es sumamente recomendable su uso, tanto a
modo de introducción como de referencia para temas especı́ficos. Si se desea conocer
la documentación especı́fica asociada a un comando de Matlab, entonces se tecleará
>> doc nombre_comando
en la lı́nea de comandos de Matlab.
3
4.2. Organización de ventanas
La figura 1 muestra la organización por defecto de ventanas que nos encontramos

cuando arrancamos Matlab por primera vez. Las ventanas que en ella aparecen, de
arriba a abajo son: en la parte izquierda, la estructura del directorio donde nos encon-
tramos, y debajo de ella la historia de los comandos que se han tecleado en el pasado; en
la mitad derecha nos encontramos, arriba, la ventana de edición de programas Matlab
(que se escriben en un lenguaje propio de Matlab y se almacenan en ficheros .m), y
debajo la lı́nea de comandos, donde se sitúa el cursor para teclear comandos de Matlab.
Figura 1: Entorno de trabajo Matlab.
Inicialmente trabajaremos con la lı́nea de comandos de Matlab.
4.3. Operaciones básicas en lı́nea de comandos
Como se ha dicho previamente, en Matlab todos los objetos son matrices. Un escalar
no es más que una matriz 1 × 1. En la lı́nea de comandos, podemos asignar un nombre
simbólico para identificar una matriz.
>> a=[10; 20; -15]; % Asignacion
Esto es una asignación de un vector de columna que llevará el nombre a. A su

derecha aparece un comentario, que tiene su utilidad cuando redactemos programas en
4
Matlab.
Los objetos pueden crearse en cualquier momento. Para ello basta con asignarles
un valor mediante una asignación, como en el ejemplo previo. Los identificadores em-
pleados para designar matrices son de libre elección, con la salvedad de que no pueden
comenzar por un número, ni contener espacios en blanco.
Una vez creado un objeto de Matlab, éste pasa a formar parte del espacio de
trabajo ocupando una porción la memoria. Por tanto, a veces, tras horas de trabajo
con Matlab, necesitaremos eliminar los objetos que ya no se utilicen. Para ello se emplea
el comando clear.
>> clear a; % Borra a de la memoria

>> clear; % Borra todos los objetos del espacio de trabajo
En las sentencias previas, aparece el signo ‘;’ al final de cada comando. Este sı́mbo-
lo sirve para separar unos comandos de otros. Por ejemplo, cuando escribimos var-
ios comandos en una sola lı́nea, estos deben aparecer separados por punto y coma.
Además, si escribimos un comando aislado (sin ‘;’) y pulsamos ENTER, Matlab pro-
porcionará siempre una salida en respuesta al comando:
>> a=[10;20;-15]
a =
10
20
-15
Sin embargo, si escribimos el comando seguido de ‘;’, no se mostrará en pantalla la

respuesta. Cuando los comandos forman parte de un programa es conveniente emplear
‘;’ para evitar desbordar la pantalla con información innecesaria.
4.4. Sintaxis de vectores y matrices
Las matrices (y vectores como caso particular de las mismas) se expresan en Matlab
empleando corchetes ([ ]); separando las filas por espacios o comas (,) y las columnas
por ‘;’. De este modo, se puede crear un objeto matriz del siguiente modo:
>> mat=[1 2 3; 4 5 6; 7 8 9]
5
mat =
1 2 3
4 5 6
7 8 9
Cuando se trata de un escalar, podemos prescindir de los corchetes
>> rad=3.1415;
Los elementos de las matrices pueden ser√reales o complejos. En este último caso se
emplea la letra i para representar el valor −1. Como ejemplo crearemos el vector fila
v = [2 + 3i, −5i, 3].
>> v=[2+3i, -5i, 3]

v =
2.0000 + 3.0000i 0 - 5.0000i 3.0000
El acceso a elementos de una matriz previamente definida puede realizarse especif-

icando la fila y columna del elemento que nos interesa entre paréntesis
>> mat(2,3)
ans =
6
Además, dentro de estos paréntesis podemos indicar variables u operaciones más com-
plejas, lo que da una gran potencia al desarrollo de algoritmos.
Una vez definidos los objetos con sus identificadores, podemos realizar operaciones
aritméticas entre ello con total simplicidad. Para las operaciones vectoriales y matri-
ciales, Matlab verificará la coherencia de las dimensiones de los operandos y si no hay
producirá error producirá un resultado con las dimensiones adecuadas.
>> v1=[2+3i, -5i, 3];

>> v2=[0, 1, 7];
>> v3=v1+2*v2+[1, 1, 1]
v3=
3.0000 + 3.0000i 3.0000 - 5.0000i 18.0000
6
4.5. Operaciones básicas con Matlab
La siguiente tabla ilustra las básicas aritméticas y lógicas que podemos realizar con
Matlab.
Expresión en Matlab Operación
+ Suma aritmética
- Resta aritmética o cambio de signo
* Multiplicación aritmética
/ División
^ Elevar un número a una potencia
< Relación "menor que"
> Relación "mayor que"
<= Relación "menor o igual que"
>= Relación "mayor o igual que"
== Relación "igual que"
~= Relación "distinto que"
& producto lógico (operación ‘‘y’’)
| suma lógica (operación .o")
~ negación (operación "no")
Cuadro 1: Operaciones aritméticas y lógicas de en Matlab.
Todas estas operaciones se aplican indistintamente a escalares, vectores y matrices,

y se pueden emplear de dos modos diferentes: en primer lugar, Matlab funciona directa-
mente como una calculadora, para lo cual tecleamos expresiones en lı́nea de comandos
para obtener inmediatamente el resultado de las mismas:
>> 12*24.8
ans =
297.6000
Ası́ mismo se pueden emplear las operaciones dentro de otras expresiones más amplias,
logrando ası́ escribir expresiones matemáticas de cualquier complejidad.
>> x1=-b+sqrt(b^2-4*a*c)/(2*a);
4.6. Funciones en Matlab
Buena parte de las operaciones que se realizan con Matlab, son llamadas a funciones.
Las funciones procesan información, por lo que poseen datos de entrada y de salida,
7
que pueden ser matriciales. Los datos de entrada se especifican entre paréntesis, y si son
varios separados por comas. Por ejemplo, la siguiente función calcula la raı́z cuadrada
de su único valor de entrada, que es el vector fila [4, 2].
>> sqrt([4 2])

ans =
2.0000 1.4142
Las funciones son programas escritos por el usuario o incorporados en el paquete básico
de Matlab. Entre estas últimas destacan las siguientes funciones:
Nombre Función
sin Seno
sinh Seno hiperbólico
cos Coseno
cosh Coseno hiperbólico
tan Tangente
tanh Tangente hiperbólica
cot Cotangente
coth Cotangente hiperbólica
sec Secante
sech Secante hiperbólica
csc Cosecante
csch Cosecante hiperbólica
asin Arcoseno (inversa del seno)
asinh Inversa del seno hiperbólico
acos Arcocoseno (inversa del coseno)
acosh Inversa del coseno hiperbólico
atan Arcotangente (inversa de la tangente)
atan2 Arcotangente de cuatro cuadrantes
Cuadro 2: Funciones elementales de Matlab: Trigonometrı́a.
Nombre Función
exp Exponencial
log Logaritmo natural (base e)
log2 Logaritmo en base 2
log10 Logaritmo en base 10
sqrt Raı́z cuadrada
Cuadro 3: Funciones elementales de Matlab: Exponenciales.
8
Nombre Función
fix Redondear hacia cero
floor Redondear hacia menos infinito
ceil Redondear hacia más infinito
round Redondear hacia el entero más cercano
mod Módulo de la división entera
rem Resto de la división entera
Cuadro 4: Funciones elementales de Matlab: Ajuste y redondeo.
Nombre Función
inv Matriz inversa
det Determinante
eig Autovalores
’ Matriz traspuesta
eye Crear una matriz identidad dado el número de filas/columnas
zeros Crear una matriz de ceros dado el número de filas/columnas
ones Crear una matriz de unos dado el número de filas/columnas
length Longitud de un vector
size Dimensiones de una matriz
Cuadro 5: Funciones elementales de Matlab: Operaciones matriciales.
4.7. Operaciones lógicas
Algunas de las operaciones y funciones presentadas no devuelven un valor numérico

o matricial como resultado. En su lugar, evalúan si cierta condición es verdadera o
falsa. En estos casos, el valor devuelto por la función equivaldrá a 1 si la condición se
cumple, y 0 si no.
A modo de ejemplo comprobaremos si una variable x se encuentra en un intervalo

determinado
>> x=5
>> (x>=0)&(x<=10) % Intervalo [0,10]
ans =
1
>> (x>7)&(x<10) % Intervalo (7,10)
ans =
0
Las operaciones lógicas se emplearán sobre todo para implementar bifuraciones y bucles
en los programas Matlab.
9
Nombre Función
clear Elimina todas las variables del espacio de trabajo
clear x Elimina la variable x del espacio de trabajo
who Lista las variables del espacio de trabajo
Cuadro 6: Funciones elementales de Matlab: Espacio de trabajo.
4.8. Operaciones de rango
En Matlab existe un operador de gran utilidad que no tiene parangón en otros

lenguajes de programación: el operador de rango (:). Para ilustrar su utilidad, baste
indicar que si se desea crear un vector con todos los números enteros entre 1 y 10,
podemos emplear la expresión 1:10.
>> a=1:10
a =
1 2 3 4 5 6 7 8 9 10
En general, para secuencias no enteras o no crecientes la sintaxis del operador de rango

es
valor_minimo : incremento : valor_maximo
Por ejemplo, para generar todos los números entre 1 y 2 en incrementos de 0.2 es-
cribiremos
>> a=1:0.2:2
a =
1.0000 1.2000 1.4000 1.6000 1.8000 2.0000
Una segunda aplicación del operador de rango es el acceso a submatrices o subvec-

tores. Supongamos que hemos definido la matriz mat anteriormente mencionada:
>> mat=[1 2 3; 4 5 6; 7 8 9];
Para acceder a la submatriz comprendida entre los elementos (2, 1) y (3, 2) bastará con
escribir
10
>> mat(2:3,1:2)
ans =
4 5
7 8
Además, se puede prescindir de alguno de los extremos de este operador cuando se

emplea en el acceso a vectores y matrices. Por ejemplo, si se desea mostrar todos los
elementos menos los 3 primeros de un vector:
>> a(4:)
>> a(4:end)
Por otro lado, si lo que deseamos es obtener los 3 últimos elementos del vector a,
escribiremos
>> a((length(a)-2):end)
4.9. Almacenamiento en archivos
Matlab permite almacenar en el disco las variables del espacio de trabajo. De este
modo es posible parar una sesión de trabajo y continuar en otro momento sin volver a
repetir cálculos. La orden más común para almacenar datos es save, que puede usarse
de varias maneras. En la tabla siguiente se presenta un resumen.
Orden Operación realizada.

save Crea el archivo de nombre matlab.mat en la
carpeta actual. Dicho archivo contiene todas
las variables que existen en ese momento en
entorno Matlab.
save nombrearchivo Crea el archivo de nombre en nombrearchi-
vo.mat en la carpeta actual. Dicho archivo
contiene todas las variables que existen en
ese momento en el entorno Matlab.
save nombrearchivo x y z Crea el archivo de nombre nombrearchi-
vo.mat en la carpeta actual. Dicho archivo
contiene únicamente las variables x, y y z.
Para recuperar las variables almacenadas en un fichero previamente creado em-

plearemos principalmente la función load. La siguiente tabla ilustra tres operaciones
tı́picas de recuperación de datos.
11
Orden Operación realizada.
load Lee toda las variables del archivo de nombre
matlab.mat de la carpeta actual. Si alguna
de las variables del disco tiene nombre co-
incidente con otra que previamente existe en
Matlab se producirá la destrucción de la vari-
able existente para dejar su sitio a la variable
del disco.
load nombrearchivo Igual que en el caso anterior, pero leyendo
del archivo nombrearchivo.mat de la carpeta
actual.
load nombrearchivo x y z Igual que el anterior pero leyendo únicamente
las variables x, y y z.
4.10. Gráficas en Matlab
Las posibilidades de Matlab a la hora de crear gráficos de todo tipo son vastı́simas.
Para tener una visión general de ellas se recomienda al lector un recorrido por la ayuda
en lı́nea partir del comando
>> doc plot
En este punto veremos los pasos básicos para crear una gráfica a partir de una tabla
de valores (x, y). Concretamente, trazaremos la parábola de ecuación
y = 2x2 + 3x − 1
en el intervalo [−3, 3].
Toda gráfica de Matlab ha de ser creada a partir de una nube de puntos, que en el
caso bidimensional consiste en una serie de valores de las coordenadas x y otra serie
del mismo tamaño de valores de y. Cada pareja (x,y) formada a partir de ambas series
será un punto de la gráfica. Para ello crearemos dos vectores de igual tamaño n. El
primer vector será x, para las coordenadas de los puntos, a partir de una división
suficientemente fina del eje de abcisas:
>> x=-3:0.1:3;
y a continuación creamos el vector y, sabiendo que en el gráfico el elemento i-ésimo del

dicho vector formará un punto (x, y) con el elemento i-ésimo del vector x. Por tanto,
12
se ha de crear un vector y de n componentes, según la fórmula
yi = 2x2i + 3xi − 1 i = 1...n
Esto se obtiene en Matlab con un sólo comando, sin necesidad de bucles:
>> y=2x.^2+3x-1;
Obsérvese el ‘.’ antes de la exponenciación. Esto evita que el término x^2, al ser x un
vector, se calcule como el producto escalar de x por sı́ mismo. Finalmente, creados los
vectores, creamos la gráfica y la etiquetamos con los siguientes comandos:
>> plot(x,y); % El orden de los parametros es importante

>> grid; % Visualizar una malla
>> xlabel(’Eje x’); % Etiqueta eje x
>> ylabel(’Eje y’); % Etiqueta eje y
Obteniendo el gráfico de la figura:
30
25
20
15
Eje y
10
−5
−3 −2 −1 0 1 2 3
Eje x
Figura 2: Gráfico resultante.
Es muy recomendable consultar la ayuda para conocer las opciones en cuanto a

tipos y colores de lı́nea, tratamiento de ejes (comando axis), etiquetado (comandos
xlabel, legend, text), etc.
13
5. Control System Toolbox
El Control System Toolbox es un componente opcional en la instalación de Matlab

que consta de una serie de funciones, objetos, bloques Simulink y herramientas destina-
dos a la asistencia en el análisis y diseño de sistemas de control. El objeto fundamental
con el que trabajaremos es la función de transferencia. Para ilustrar sus propiedades
y el álgebra asociada, estudiaremos un ejemplo sencillo de control.
Considérese el sistema realimentado de la figura 3. Dicho sistema está formado por

tres bloques independientes: G1 (s), que representa el controlador, G2 (s), que corre-
sponde a la planta a controlar, y G3 (s), la función de transferencia del sensor con el
que se mide la salida del sistema. Los valores de las tres funciones son:
1
G1 (s) =
s + 0,5
3
G2 (s) = 2
s + 2s + 1
40
G3 (s) = 2
s + 5s + 40
Supongamos que deseamos calcular la función de transferencia en bucle cerrado de
dicho sistema, y a continuación trazar su diagrama de Bode. Lo primero que debemos
conocer es cómo definir una función de transferencia en el entorno Matlab.
Un polinomio en s se representa en Matlab como un vector cuyos elementos son los

coeficientes del polinomio por orden de exponente descendente: por ejemplo, s2 − 2s + 1
se define en Matlab como el vector [1 − 2 1]. Por tanto, para definir una función de
transferencia en Matlab necesitamos dos vectores. A partir de ellos, con la función tf
construiremos las función de transferencia del ejemplo:
>> G1=tf([1],[1 0.5]);

>> G2=tf([3],[1 2 1]);
>> G3=tf([40],[1 5 40]);
Lo más interesante de esos objetos es la posibilidad de realizar operaciones matemáticas

entre ellos. Para ilustrar esto, calcularemos la función de transferencia del sistema
realimentado en bucle cerrado, desde la referencia hasta la salida. Sabiendo que dicha
función tiene la forma
Y (s) G1 (s)G2 (s)
Gbc (s) = = ,
R(s) 1 + G1 (s)G2 (s)G3 (s)
teclearemos en Matlab simplemente
14
>> Gbc=G1*G2/(1+G1*G2*G3)
Transfer function:
3s^5+22.5s^4+163.5s^3+331.5s^2+247.5s+60
----------------------------------------------------------------
s^8+10s^7+75.25s^6+262.3s^5+471.5s^4+594.5s^3+570.3s^2+321.3s+70
lo que nos muestra la estructura de la función de transferencia en bucle cerrado Gbc (s),
que podrá ser utilizada a partir de ahora en llamadas a funciones, como las que trazan
los diagramas de Bode (función bode) y Nyquist (función nyquist).
r(t) +
e u y(t)
-@
@ - G1 (s) - G2 (s) -
@
@
− 6m
G3 (s)
Figura 3: Sistema de Control realimentado
5.1. Operaciones con polinomios
El Control System Toolbox permite, además de lo explicado, realizar ciertas op-

eraciones con polinomios almacenados en forma de vector, que son muy interesantes
dentro de la teorı́a del control automático. Por ejemplo, podemos calcular el producto
de dos polinomios en s mediante la función conv y a partir de ellos calcular el producto
(cascada) de dos funciones de transferencia:
>> num1=[1]; den1=[1 0 0.5];

>> num2=[3]; den2=[1 2 1];
>> num_producto=conv(num1,num2);
>> den_producto=conv(den1,den2);
>> G12=tf(num_producto,den_producto)
en este caso el resultado del cálculo serı́a igual al producto de las funciones G1 (s) y
G2 (s), que como sabemos, también se obtendrı́a, a partir de las definiciones anteriores,
15
escribiendo
>> G12=G1*G2
Por otra parte, para obtener las raı́ces de un polinomio definido en Matlab como un
vector, se emplea la función roots:
>> roots([1 2 -1 ])
ans =
-2.4142
0.4142
5.2. Herramientas numéricas y gráficas
Dada una función de transferencia, ya sea de bucle abierto o cerrado, existen en el

Control System Toolbox operaciones numéricas y gráficas de gran utilidad a la hora de
analizar la estabilidad y otras propiedades. Algunas de ellas aparecen en la siguiente
tabla
Comando Operación realizada.

evalfr Evalúa la magnitud y fase de una función de transferencia en la
frecuencia especificada.
bode Traza el diagrama logarı́tmico de Bode de una función de transfer-
encia dada. Además presenta interesantes opciones de visualización
como son los márgenes de ganancia y fase.
nyquist Traza el diagrama de Nyquist de una función de transferencia dada.
rlocus Traza el lugar de las raı́ces al realimentar negativamente con una
ganancia K (variable) la función de transferencia dada.
margin Calcula, sobre el diagram de Bode, los márgenes de fase y ganancia
de una función de transferencia y las frecuencias de corte.
pzmap Muestra en una gráfica del plano complejo la ubicación de los polos
y los ceros de una función de transferencia dada.
Como ejemplo, se obtendrá el diagrama de Bode de la función de transferencia

(estable)
1
G(s) = 2
s + 0,1s + 0,5
y se calcularán los márgenes de fase y ganancia. Para ello tecleamos
16
>> G1=tf([1],[1 0.1 0.5])
>> bode(G1);
>> margin(G1);
y el resultado aparece representado en la figura 4.
Bode Diagram
Gm = Inf dB (at Inf rad/sec) , Pm = 7.02 deg (at 1.22 rad/sec)
40
30
20
Magnitude (dB)
10
−10
−20
−30
−40
0
−45
Phase (deg)
−90
−135
−180
−1 0 1
10 10 10
Frequency (rad/sec)
Figura 4: Diagrama logarı́tmico de Bode.
Por último, volveremos a la función Gb c(s) calculada para analizar su estabilidad.

Para ello extraemos su denominador tecleando
>> pol=Gbc.den{1}
pol =
1.0000 10.0000 75.2500 262.2500 471.5000 594.5000 570.2500 321.2500 70.0000
y a partir de ahı́ evaluamos sus raı́ces mediante
>> roots(pol)
ans =
-2.5301 + 5.8437i
-2.5301 - 5.8437i
-2.3763
17
-0.0317 + 1.2049i
-0.0317 - 1.2049i
-1.0000 + 0.0000i
-1.0000 - 0.0000i
-0.5000
Al estar todas las raı́ces en el semiplano izquierdo, deducimos que el sistema en bucle
cerrado es estable. Otro modo de verificar esto es trazando el diagrama polo–cero de
Gbc , mediante la instrucción pzmap(Gbc). El resultado se muestra en la figura 5.
Pole−Zero Map 6
6
0.4 0.28 0.2 0.14 0.09 0.04
5
0.56 4
4
0.8 2
2
1
Imaginary Axis
−2
0.8 2
−4
0.56 4
5
0.4 0.28 0.2 0.14 0.09 0.04
−6
−3 −2.5 −2 −1.5 −1 −0.5 60
Real Axis
Figura 5: Diagrama polo–cero de la función de transferencia en bucle cerrado Gbc (s).
6. El entorno de trabajo de Simulink
Simulink es una herramienta de gran utilidad para la simulación de sistemas dinámi-

cos. Principalmente, se trata de un entorno de trabajo gráfico, en el que se especifican
las partes de un sistema y su interconexión en forma de diagrama de bloques. De nuevo,
se trata de una herramienta amplı́sima que además se complementa con numerosos el-
ementos opcionales. Por tanto, nos limitaremos a dar unas pinceladas de los elementos
más útiles en Regulación Automática.
Además de las capacidades de simulación de las que está dotado Simulink, con-
viene destacar que contiene cómodas utilidades de visualización y almacenamiento de
resultados de simulación.
18
6.1. Uso de Simulink
En primer lugar, lanzaremos la aplicación escribiendo simulink en la lı́nea de co-

mandos de Matlab, o abriendo desde el Explorador de Windows cualquier fichero con
extensión .mdl. En el primero de los casos se abrirá la ventana de la figura 6. Esta
Figura 6: Ventana navegación de bloques de Simulink (Simulink Library Browser).
ventana inicial no está destinada a crear modelos de simulación; su función principal

consiste en navegar por la enorme librerı́a de bloques disponibles para el modelado.
En ella distinguimos dos partes: la izquierda contiene una visión en forma de árbol
de todos los Toolboxes instalados que contienen bloques Simulink. La amplitud de
este árbol dependerá de las opciones que hayamos activado al seleccionar Matlab.
De todos los nodos del árbol nos interesan, de momento, los denominados Simulink y
Control System Toolbox. Cabe mencionar además, por su interés, los bloques Real Time
Workshop destinados a generar automáticamente código de control para determinadas
plataformas Hardware comerciales.
La parte derecha de la ventana de la figura 6 muestra los bloques Simulink con-

tenidos en el Toolbox o nodo de la parte izquierda de la ventana. Estos bloques se
deben arrastrar sobre el espacio de trabajo de Simulink para la creación de modelo a
simular.
Por último, cabe indicar que en la parte superior de la ventana de inicio de Simulink
hay varias herramientas como la búsqueda de un bloque determinado a partir de su
nombre, que nos pueden resultar bastante útiles.
19
6.2. El espacio de trabajo de Simulink
Si pulsamos en el icono superior izquierdo de la ventana de la figura 6 (página en

blanco), se abre una ventana blanca sobre la que iniciaremos la creación de un modelo
de simulación. Dicha ventana se muestra en la figura 7.
Figura 7: Espacio de trabajo de Simulink.
En el espacio de trabajo de Simulink crearemos un modelo insertando los bloques

correspondientes. Concretamente realizaremos la simulación del sistema de control rep-
resentado en la figura 3. En lugar de emplear las definiciones en Matlab de las funciones
de transferencia presentadas en el apartado anterior (empleando la función tf), creare-
mos las funciones de transferencia directamente sobre el diagrama de bloques.
En primer lugar, hemos de insertar tres bloques de tipo Función de Transferencia

en el modelo. Para ello tecleamos la palabra transfer en el campo de búsquedas en la
parte superior de la ventana de navegación y el buscador localizará el bloque llamado
Transfer Fcn, que cuelga del nodo Simulink, como se muestra en la figura 8.
Una vez localizado el bloque Transfer Fcn arrastraremos dicho bloque hacia el
espacio de trabajo de Simulink. El arrastre de bloques se realiza seleccionando el icono
del bloque con el botón izquierdo del ratón, y manteniendo éste pulsado se desplazará el
cursor hasta la ventana del modelo.
Repetiremos la operación tres veces, para reproducir la estructura de la figura 3,

dando lugar a la ventana mostrada en la figura 9.
Una vez insertados los bloques de las funciones de transferencia, les asignamos
nombres especı́ficos (G1,G2 y G3) editando el texto al pie de cada icono, y les damos
valores a dichas funciones, para que coincidan con los parámetros de las funciones
G1 (s), G2 (s) y G3 (s) definidas anteriormente.
Con este fin, haremos doble click sobre cada bloque de función de transferencia, y
20
Figura 8: Ubicación del bloque Transfer Fcn.
en la ventana que se abre en cada caso, introduciremos los vectores de coeficientes de

los polinomios numerador y denominador de cada función de transferencia. La figura 10
muestra la ventana donde se introducen los parámetros de G1 (s).
Una vez configuradas las tres funciones de transferencia las conectaremos entre
sı́ con arreglo a la estructura de interconexión de bloques de la figura 3. Para ello
empleamos las siguientes operaciones:
21
Figura 9: Bloques de función de transferencia en Simulink.
Figura 10: Introducción de los parámetros de G1 (s) = 1/(s + 0,5).
Operación Procedimiento.
Conectar bloques (I) Para conectar las salidas de un bloque a la entrada de
otro, hacer click con el botón izqdo. del ratón en el
bloque origen. Pulsar y mantener la tecla CTRL y hacer
de nuevo click sobre el bloque destino.
Conectar bloques (II) También se puede extraer un cable de señal haciendo
click en el saliente derecho del bloque origen y prolon-
gar la señal (pulsando y manteniendo el botón izquierdo
del ratón) hasta llegar a la parte izquierda del bloque
destino.
Bifurcar cables Un cable de señal (que lleva la salida de un bloque
hacia otro bloque), puede bifurcarse para distribuir la
señal a varios bloques pulsando con el botón derecho en
cualquier punto del cable.
Sumar o restar señales Las señales procedentes de salidas de los bloques se
pueden sumar o restar entre sı́ mediante el bloque
sumador, que se ubica fácilmente tecleando Sum en la
ventana de navegación de Simuink.
22
Tras una serie de operaciones de los tipos indicados en la tabla anterior, logramos
construir la estructura de realimentación de la figura 11. En esta figura hemos añadido
dos bloques nuevos: Step y Scope. Ambos pertenecen, respectivamente, a los nodos
Simulink/Sources y Simulink/Sinks que serán comentados en el siguiente apartado.
Figura 11: Modelo completo.
6.3. Fuentes y sumideros de señal
Los bloques de suma y resta de señales y los de funciones de transferencia, funcionan

como procesadores de señal. Sin embargo, en las simulaciones han de existir fuentes de
señal externas, pues lo que se pretende en general es ver cómo responden determinados
sistemas a estı́mulos exteriores.
En nuestro ejemplo necesitamos una señal externa para generar una referencia a
seguir por el sistema controlado. Esta referencia debe ser, lógicamente, cambiante con
el tiempo. En nuestro caso emplearemos una señal de tipo escalón, que se implementa,
con sus parámetros especı́ficos, mediante el bloque Step. Bloques como éste, que sólo
tienen salidas y ninguna entrada, se localizan en el árbol de navegación de Simulink en
el nodo Simulink/Sources.
Por otro lado, existen bloques con entradas y sin ninguna salida: nodos sumidero.
Uno de ellos es el empleado en nuestro modelo para visualizar la salida del sistema:
Scope. Los bloques de este tipo se ubican en el árbol de navegación de Simulink en el
nodo Simulink/Sinks.
A modo de referencia, la tabla 7 muestra algunas fuentes de señal de uso común (no-
do Simulink/Sources), mientras que la tabla 8 muestra algunos de los bloques sumidero
(Simulink/Sinks) más comunes.
23
Elemento Función
Clock Marcas de tiempo de la simulación. Útil para trazar gráficas
con los resultados.
Sin Señal senoidal parametrizable.
Step Señal en escalón
Constant Señal de valor constante.
Signal generator Permite elegir entre un conjunto de señales predefinidas.
Random Number Generación de ruido blanco configurable.
From Workspace Señal generada a partir de una variable del espacio de trabajo
de Matlab.
Cuadro 7: Fuentes de señal en Simulink.
Elemento Función
Scope Gráfica 2D para visualizar las señales frente al tiempo durante
la simulación.
XY Graph Gráfica 2D para visualizar un gráfico X-Y creado a partir de
dos señales de entrada.
To Workspace Almacena las muestras de la señal de entrada en una variable
(vector) del espacio de trabajo de Matlab.
Cuadro 8: Sumideros de señal en Simulink.
24
Manual de Introducción
a
SIMULINK
Autor: José Ángel Acosta Rodríguez
© 2004
Capı́tulo 1
Ejemplo
1.1. Modelado de un sistema dinámico

En este ejemplo se realizará el modelado de un sistema dinámico muy
sencillo. Se modelará el movimiento de una masa sobre una superficie rugosa,
sobre la que se le aplica una fuerza. El sistema a modelar posee una entrada u,
que se corresponde con la fuerza aplicada, y una salida x que será la posición
de la masa. El modelo del sistema dinámico se puede expresar mediante las
ecuaciones de Newton:
mẍ + cẋ = F (1.1)
m : Masa del cuerpo (Kg)

c : Coeficiente de fricción del cuerpo sobre la superficie
F : Fuerza aplicada (N)
Queremos hacer un modelo en con la herramienta “Simulink”para el sis-

tema propuesto. Primero ejecutamos la herramienta “Simulink”desde la ven-
tana de comandos de Matlab haciendo ‘click’ en el icono correspondiente
1
2 CAPÍTULO 1. EJEMPLO
Saldrá por pantalla una ventana gráfica, como la de la Fig. 1.1, que con-
tiene todas las librerı́as que el entorno de “Simulink”bajo Matlab soporta.
Figura 1.1: Librerı́as del entorno Simulink

1.1. MODELADO DE UN SISTEMA DINÁMICO 3
Para este sencillo ejemplo sólo necesitaremos la librerı́a básica de “Simulink”,

por tanto expandimos el menu simulink en la ventana anterior, quedando co-
mo aparece en la Fig. 1.2
Figura 1.2: Librerı́a base de Simulink
Esta ventana está dividida en dos partes. La de la derecha es la corres-

pondiente a las librerı́as y la de la derecha es el contenido de la librerı́a
seleccionada.
Elegimos un nuevo fichero donde guardaremos el modelo: seleccionamos

en el menu File → New → Model. Tendremos la situación de la Fig. 1.3
Figura 1.3: Apertura de un nuevo fichero modelo

Se abrirá una ventana en blanco donde crearemos el modelo. La situación

debe ser ahora la de la Fig. 1.4
Figura 1.4: Apertura de un nuevo fichero modelo
En esta nueva ventana que aún no hemos dado nombre (‘untitled’) desar-
rollaremos el ejemplo. Lo primero que hacemos es darle un nombre adecuado.
Para ello, en el menu File de la nueva ventana elegimos File → Save. Nos
situamos en el directorio adecuado a través del menu desplegable, ponemos
un nombre al archivo, por ejemplo “masa guardamos el modelo. Ya tenemos
2
un archivo donde crear el modelo. La extensión por defecto de los archivos

de modelo es *.mdl.
Empezamos a crear el modelo dado por la ecuación (1.2). Para ello es
necesario hacer alguna modificación en la ecuación (1.2). Despejando de la
ecuación (1.2) la aceleración del cuerpo se obtiene:
c F
ẍ = − ẋ + (1.2)
m m
Como puede verse necesitaremos varios tipos de bloques. Elegimos estos
bloques de la ventana de la derecha de la librerı́a (Fig. 1.2). El primero que
seleccionamos el que definirá la fuerza aplicada a la masa, lo haremos me-
diante una constante. Seleccionamos ‘Sources’ y en la derecha seleccionamos
el bloque de ‘Constant’. Ahora lo arrastramos hacia la ventana de nuestro

modelo con el botón izquierdo del ratón pulsado. Hacemos ‘click’ en el la eti-
queta del nombre del bloque de constante y le damos su nombre, por ejemplo
F. La situación debe ser la de la Fig. 1.5
Figura 1.5: Construyendo el modelo
Observando la ecuación (1.2), puede verse que se necesita hacer las op-
eraciones de sumar y dividir. Para ello seleccionamos ‘Math Operations’ en
la ventana de la librerı́a y escogemos del mismo modo que antes los bloques
de ‘Sum’ y ‘Gain’. Para describir la ecuación diferencial se necesitará además
el bloque integrador ‘Integrator’ en la librerı́a ‘Continuous’. Ya se está en
disposición de describir la ecuación (1.2) utilizando bloques. Debemos unir
los bloques de forma adecuada para describir dicha ecuación (1.2). Haremos
el esquema como describe la Fig. 1.6. Para unir los bloques debemos pinchar
con el botón izquierdo del ratón en el bloque de origen y soltar en el bloque
de destino.
Como puede verse en la Fig. 1.6, se han editado los nombres de los blo-
ques poniéndoles nombres distintos a los originales. También se ha editado el
valor de algunos de los bloques. Daremos valores concretos a las constantes.
Supongamos que la masa es de un kg m = 1, que la constante de fricción
vale c = 0,8 y que la fuerza aplicada es 0.1 N (F = 0,1). Ası́ por ejemplo el
bloque ‘Gain’ denominado ‘c/m’ posee en su interior el valor correspondiente
a mc = 0,8, y el denominado ‘1/m’ tendrá valor 1. Estos valores se introducen
haciendo doble ‘click’ en los bloques y editando el campo correspondiente.
Por otro lado se ha escrito texto para hacer más fácil la lectura del modelo.
Estas cajas de texto se crean simplemente haciendo doble ‘click’ en el lugar
que se desee y editando el recuadro que aparece.
.. .
F/m x x x
1 1
1 1
s s
F
1/m
Integrador Integrador
.
c*x /m
0.8
c/m
Figura 1.6: Modelo
Para poder ver los resultados ponemos un bloque que nos muestre la
posición de la masa frente al tiempo. Seleccionamos dentro de la librerı́a
‘Sinks’ el bloque ‘Scope’. Lo añadimos al modelo de la forma habitual. Ya
tenemos el modelo completo. Los bloques deben estar como se muestra en la
Fig. 1.7.
.. .
F/m x x x
1 1 1 1
s s
F
1/m
Integrador Integrador Scope
.
c*x /m
0.8
c/m
Figura 1.7: Modelo con ‘Scope’
En la Fig. 1.7 debe notarse que las variables de estado están perfecta-
mente definidas y accesibles en el diagrama de bloques. Ahora se está en
disposición de hacer una simulación del proceso. Para ello debemos definir
algunos parámetros esenciales. Los más importantes son las condiciones ini-
ciales de las variables de estado y el tiempo de simulación. Las condiciones
iniciales deben ponerse en los bloques integradores. Se hace doble ‘click’ en el-
los y se definen las mismas en la zona de edición correspondiente. Por ejemplo
ponemos el valor inicial de la velocidad a -1. En la Fig. 1.8 puede verse dónde
se define el parámetro después de haber hecho doble ‘click’ en el integrador
que nos da la velocidad.
Figura 1.8: Condición inicial en velocidad
Para definir el tiempo de simulación accedemos al menu de la ventana del

modelo Simulation → Simulation parameters. Se abre una ventana dónde es
posible definir entre otros parámetros el tiempo de simulación, el método de
resolución y el paso fijo o variable. Dejamos los dos últimos como están y
ponemos el tiempo de simulación a 10 segundos. La situación será como la
mostrada en la Fig. 1.9
Por último definimos la fuerza aplicada que deseamos. Hacemos doble
‘click’ en el bloque donde está definida la fuerza y ponemos el valor deseado
que era 0.1.
Para ver el resultado en el Scope debemos hacer doble ‘click’ sobre el
mismo y se abrirá la ventana gráfica que nos dará la posición del cuerpo.
Ahora pulsamos el botón de inicio de simulación I . Una vez acabada la
simulación tendremos el resultado que puede verse en la Fig. 1.10.
Si deseamos ver también la velocidad tenemos acceso a la variable en el
diagrama. Podemos poner otro Scope para la velocidad. El resultado puede
verse en la Fig. 1.11
Se podrı́an ver las dos variables de estado en una sola ventana gráfica
Scope. Se necesita para ello el bloque ‘Mux’ dentro de la librerı́a ‘Signal
routing’. Este bloque hace las veces de un multiplexor y anida vectores. Se
Figura 1.9: Parámetros de simulación
Figura 1.10: Simulación

Figura 1.11: Simulación. Utilización del bloque Scope

modifica el diagrama como se ve en la Fig. 1.12 y ya se tienen las dos variables

en una sóla ventana gráfica.
Figura 1.12: Simulación. Utilización del bloque Mux
Supongamos que no sólo queremos ver el resultado sino que también quer-
emos guardar las variables en memoria para poder acceder a ellas. Buscamos
dentro de la librerı́a ‘Sinks’ el bloque ‘To Workspace’. Lo añadimos al dia-
grama anterior y le damos un nombre a la matriz donde queremos guardar
el valor de las variables, por ejemplo X. El resultado es el de la Fig. 1.13
.. .
F/m x x x
1 1
0.1 1
s s
F
1/m
Integrador Integrador
.
c*x /m Posición
0.8 y
velocidad
c/m X
To Workspace
Figura 1.13: Simulación. Utilización del bloque To Workspace
Si ahora queremos ver el valor de las variable desde la linea de comandos

de Matlab, hacemos ‘plot(tout, X)’. En la matriz X se encuentran la posición
y la velocidad por columnas en el orden que se han puesto en el diagrama de

bloques Fig. 1.13. El tiempo de simulación se guarda por defecto en la variable
‘tout’ dada en el menu Simulation → Simulation parameters → Workspace
I/O. El resultado se muestra en la Fig. 1.14.
0.4
0.2
−0.2
−0.4
−0.6
−0.8
−1
0 1 2 3 4 5 6 7 8 9 10
Figura 1.14: Resultado de ejecutar el comando plot(tout,X)
Todo este modelo se ha creado a través de las variables temporales y sus

derivadas. Simulink permite hacer los modelos untilizando la transformada
de Laplace. Para ello necesitamos transformar la ecuación del modelo (1.2)
en el dominio de Laplace. Suponemos las condiciones iniciales iguales a cero.
Por tanto, la ecuación (1.2) quedará en el dominio de Laplace
ms2 X(s) + csX(s) = F (1.3)
Podemos transformarla en una función de transferencia si tomamos como

salida la posición (X(s)) y como entrada la fuerza aplicada (F (s)) del modo
siguiente
1
X(s) c
= m
F (s) s( c s + 1)
K
= , (1.4)
s(τ s + 1)
1 m
donde K = c
yτ= c
. Para el ejemplo anterior K = τ = 1,25.
Ahora ya podemos construir el modelo utilizando Laplace. De la librerı́a

‘Continuous’ elegimos los bloques ‘Integrator’ y ‘Transfer Fcn’. Editamos este
último bloque con los valores de K y τ anteriores haciendo doble ‘click’. El
modelo quedará como se muestra en la Fig. 1.15
.
F x x
1.25 1
0.1
1.25s+1 s
F
Transfer Fcn Integrador
Posición
y
velocidad
X
To Workspace
Figura 1.15: Modelo en el dominio de Laplace
Debe notarse que en este último esquema Fig. 1.15, la condición inicial
de la velocidad no está accesible. Si se desea tener en cuenta hay que hacerlo
a la hora de pasar las ecuaciones al dominio de Laplace.
Ya sabemos hacer un modelo de un sistema dinámico, tanto en el do-
minio del tiempo como en el de la frecuencia (Laplace). Ahora se describe
como hacer subsistemas. La idea de estos subsistemas es agrupar bloques con
algún criterio predefinido. Como ejemplo agruparemos los bloques del primer
ejemplo como un sólo bloque que sea el modelo del sistema. Tendrá como
entrada la fuerza aplicada y como salidas la posición y la velocidad del sis-
tema. Para conseguir esto debemos seleccionar todo aquello que queremos
que pertenezca al subsistema. La selección se hace con el botón izquierdo del
ratón, como en Windows, haciendo un recuadro con todo aquello que quer-
emos seleccionar. Todo esto con el botón pulsado. Después se suelta y nos
vamos al menu ‘Edit’ → ‘Create subsystem’, como en la Fig. 1.16
Una vez hecho esto tendremos la situación de la Fig. 1.17, donde todo lo
seleccionado anteriormente se ha metido dentro de un bloque.
Haciendo doble ‘click’ en el bloque se puede ver su contenido en otra
ventana como se muestra en la Fig. 1.17.
Figura 1.16: Creando subsistemas
Figura 1.17: Creando subsistemas

Universidad de Chile
Facultad de Ciencias Fı́sicas y Matemáticas
Departamento de Ingenierı́a Eléctrica
Introducción a Matlab y Simulink
Preparado por Diego Sepúlveda J.
Version 1.0, 6 de agosto de 2002

Introducci¶
on
Matlab es un poderoso sistema el cual permite el tratamiento num¶erico

de una gran cantidad de aplicaciones en ingenier¶‡a, tales como: procesamiento
de señales, an¶alisis estad¶‡sticos, interpolaci¶on de curvas, series de tiempo, si-
mulaci¶on y control de sistemas, l¶ogica difusa, redes neuronales, identiflcaci¶on
de par¶ametros, etc.
El nombre Matlab se debe a que en realidad consiste en un laboratorio
de matrices (Matrix laboratory), raz¶on por la cual es excelente para el
c¶alculo num¶erico de vectores y valores propios, descomposiciones de matrices
y cualquier aplicaci¶on que involucre matrices.
Adem¶as de lo mencionado anteriormente, Matlab tambi¶en incluye un
subprograma llamado Simulink, el cual permite la simulaci¶on de todo sis-
tema din¶amico lineal y casi cualquier sistema no lineal.
A pesar de la gran cantidad de aplicaciones mencionadas anteriormente,
este apunte est¶a enfocado hacia las aplicaciones orientadas hacia el control
de sistemas.
Si el lector desea ahondar m¶as sobre los aspectos generales de Matlab en-
tonces deber¶a referirse a [1]
i
II
¶Indice general
1. Lo b¶asico 1
1.1. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1. Deflnici¶on y asignaci¶on de variables . . . . . . . . . . . 1
1.1.2. Operando con matrices . . . . . . . . . . . . . . . . . . 2
1.1.3. Matrices especiales . . . . . . . . . . . . . . . . . . . . 3
1.1.4. Manipulaci¶on de matrices . . . . . . . . . . . . . . . . 5
1.1.5. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2. Variables y Funciones . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.1. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.2. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2.3. Algunas Variables y Funciones de utilidad . . . . . . . 9
1.3. Gr¶aflcos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.1. Figuras . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.2. Gr¶aflcos en 2D . . . . . . . . . . . . . . . . . . . . . . 12
2. Simulink 17
2.1. Diagramas de Bloques . . . . . . . . . . . . . . . . . . . . . . 17
2.2. Usando Simulink . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1. Librer¶‡a “Continuos” . . . . . . . . . . . . . . . . . . . 19
2.2.2. Librer¶‡a “Discrete” . . . . . . . . . . . . . . . . . . . . 19
2.2.3. Librer¶‡as “Sources” y “Sinks” . . . . . . . . . . . . . . 20
2.2.4. Otras Librer¶‡as . . . . . . . . . . . . . . . . . . . . . . 21
A. Funciones Comunes 25
iii
IV ¶INDICE GENERAL
Cap¶ıtulo 1
Lo b¶
asico
Dado que todas las aplicaciones de Matlab se basan en el uso de matrices,

lo primordial en este capı́tulo es mostrar cómo utilizarlas, posteriormente se verán
los distintos tipos de variables y funciones que existen, para finalmente aprender
el manejo de gráficos.
1.1. Matrices
1.1.1. Definición y asignación de variables
Para introducir una matriz en Matlab s¶olo se debe introducir los n¶ ume-
ros de la matriz entre par¶entesis cuadrados ([ ]), las columnas se separan por
espacios y las fllas por punto y coma (;)1 . Por ejemplo:
>> A=[3 4 5 ; 3 2 7]
A =
3 4 5
3 2 7
Como se puede ver en el ejemplo anterior las variables se asignan mediante

un signo igual (=) de la misma manera que en lenguajes como JAVA o C.
1
; también se utiliza para suprimir la visualización del resultado
1
2 Matrices
1.1.2. Operando con matrices

Para transponer2 matrices s¶olo hay que poner despu¶es de la matriz o de
la variable un ap¶ostrofe (’), siguiendo con el ejemplo anterior quedar¶‡a:
>> A’
ans =
3 3
4 2
5 7
En la variable ans mostrada en el ejemplo anterior, Matlab guarda el re-
sultado de la u¶ltima operaci¶on ejecutada.
Las operaciones aritm¶eticas son igual que ne la mayor¶‡a de los lenguajes,
as¶‡ para sumar (o restar) s¶olo hay utilizar el signo + (o -), para multiplicar
se utiliza el asterisco (*) y para dividir por la derecha (izquierda) se utiliza
(/ (\)). 3 Por ejemplo:
>> B=[1 2 3; 4 5 6];
>> C=A+B
C =
4 6 8
7 7 13
>> D=C*A’
D =
76 80
114 126
Para potenciar una matriz se utiliza el s¶‡mbolo (ˆ), seguido del exponente
que se desea. Si se desea invertir una matriz se puede hacer de dos maneras:
elevando la matriz a -1 o utilizando la funci¶on inv:
2
En el caso de que se utilicen números complejos se obtiene la conjugada transpuesta
3
Obviamente para poder realizar estas operaciones es necesario que las dimensiones de
las matrices sean consistentes.
1.1.3 Matrices especiales 3
>> A=[2 2 ; 0 1]
A =
2 2
0 1
>> inv(A)
ans =
0.5000 -1.0000
0 1.0000
En el cuadro 1.1 se muestra un resumen de los operadores matriciales.
Operaci¶on S¶ımbolo
Multiplicaci¶on *
Divisi¶on por la derecha /
Divisi¶on por la izquierda \
Potenciaci¶on ˆ
Transposici¶on conjugada ’
Cuadro 1.1: Operadores para a¶lgebra matricial
1.1.3. Matrices especiales

Dado que existen matrices que son muy utilizadas en la pr¶actica Mat-
lab incluye funciones espec¶‡flcas para crearlas:
ones crea una matriz de unos
zeros crea una matriz de ceros
eye crea la matriz identidad
La utilizaci¶on de las tres es muy similar, se introduce primero el n¶

umero
de fllas y posteriormente el n¶umero de columnas; como muestra el siguiente
ejemplo:
4 Matrices
>> A=ones(3,2)
A =
1 1
1 1
1 1
>> B=zeros(3,5)
B =
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
>> C=eye(3)
C =
1 0 0
0 1 0
0 0 1
>> C=eye(3,4)
C =
1 0 0 0
0 1 0 0
0 0 1 0
N¶otese que si se desea la matriz identidad de orden n s¶olo hay que introducir
n, pero si se desea una rectangular se utiliza igual que las funciones anteriores.
Otro tipo de matrices com¶ unmente utilizadas son los vectores, los cuales se
pueden deflnir como cualquier matriz. La importancia radica en que muchas
veces se utilizan para indexar alguna serie de elementos, para deflnirlos de
esta manera se utiliza (:), de la siguiente manera:
1.1.4 Manipulaci¶
on de matrices 5
n¶
umero inicial:paso:cota superior
Por ejemplo:
>> 1:4:19
ans =
1 5 9 13 17
1.1.4. Manipulación de matrices

Una aplicaci¶on de uso frecuente consiste en seleccionar algunas columnas,
fllas o simplemente elementos de alguna matriz; esto se logra con la utilizaci¶on
de par¶entesis despu¶es del nombre del nombre de la variable y de dos puntos
(:). A continuaci¶on se muestran algunos ejemplos para la matriz deflnida
anteriormente:
>> A(1,1)
ans =
>> A(:,1)
ans =
2
0
>> A(2,:)
ans =
0 1
>> A(4)
6 Matrices
ans =
En el primer ejemplo se obtiene el elemento a11 de la matriz, en el segundo

ejemplo la primera columna, el tercer ejemplo se obtiene la segunda flla,
y para el u ¶ltimo ejemplo se obtiene el cuarto elemento de la matriz. La
numeraci¶on del u ¶ltimo ejemplo es por columnas (as¶‡ a11 es 1◦ , a21 es 2◦ , a12
es 3◦ , a22 es 4◦ ).
Adem¶as de seleccionar elementos, muchas veces es u ¶til eliminar alg¶
un(os)
elemento(s) de la matriz4 , para lograr lo anterior se utilizan un par de par¶ente-
sis cuadrados. As¶‡, por ejemplo, si se desea borrar la segunda columna de una
matriz dada:
>> A=[1 2 6; 3 4 8; 5 7 9; 3 4 9];

>> A(:,2)=[ ]
A =
1 6
3 8
5 9
3 9
Es importante notar que tanto la selecci¶on como la eliminaci¶on de elementos

de una matriz se puede realizar utilizando un vector como conjunto ¶‡ndices
a utilizar. Por ejemplo:
>> A=0:1:10
A =
0 1 2 3 4 5 6 7 8 9 10
>> indice=1:2:11
indice =
4
Sin embargo, sólo se puede hacer si la estructura resultante sigue siendo una matriz
1.1.5 Arreglos 7
1 3 5 7 9 11
>> B=A(indice)
B =
0 2 4 6 8 10
obtiene los n¶
umeros que est¶an en las posiciones impares del vector A.
Muchas veces es u ¶til concatenar matrices, lo cual se puede utilizar utili-
zando los par¶entesis cuadrados ([ ]). Por ejemplo para concatenar horizontal-
mente:
>> B=[1 2 3; 4 5 6];
>> C=[1 ; 2];
>> [B C]
ans =
1 2 3 1
4 5 6 2
y para concatenar verticalmente:
>> B=1:1:4;
>> C=4:-1:1;
>> [B ; C]
ans =
1 2 3 4
4 3 2 1
Obviamente las dimensiones de las matrices deben ser consistentes con la
concatenaci¶on.
1.1.5. Arreglos
Los arreglos son matrices, pero poseen una aritm¶etica distinta en cuan-
to a la multiplicaci¶on y divisi¶on. Estas operaciones se ejecutan elemento a
8 Variables y Funciones
elemento, y para que sean consistentes los arreglos deben ser de las mismas
dimensiones.
Para diferenciar las operaciones matriciales de las operaciones de arreglos
los operadores van precedidos por un punto (.), como se muestra en el cuadro
1.2.
Operaci¶on S¶ımbolo
Multiplicaci¶on .*
Divisi¶on por la derecha ./
Divisi¶on por la izquierda .\
Potenciaci¶on .ˆ
Transposici¶on no conjugada .’
Cuadro 1.2: Operadores para a¶lgebra de arreglos
Por ejemplo:
>> A=[1 3 4; 4 2 6];

>> B=[3 4 8; 7 8 0];
>> A.\B
ans =
3.0000 1.3333 2.0000

1.7500 4.0000 0
bij
corresponde a la divisi¶on de arreglos por la izquierda de A por B, i.e. aij
∀ i, j.
1.2. Variables y Funciones

1.2.1. Variables
Existen varios tipos de variables en Matlab, las m¶as comunes son:
double corresponden a las matrices y arreglos num¶ericos.
char son los arreglos de caracteres, se deflnen entre ap¶ostrofes (’’):

1.2.2 Funciones 9
>> Z=’hola’
Z =
hola
1.2.2. Funciones
Las funciones son, al igual que en la mayor¶‡a de los lenguajes, subrutinas
que facilitan el trabajo, por ejemplo la funci¶on mean calcula el promedio o
media de un set de datos:
>> A=1:1:4;
>> mean(A)
ans =
2.5000
Lo importante con respecto a las funciones en Matlab es que vienen algu-

nas incluidas en el programa (built-in functions) y otras viene dentro de los
distintos toolboxes que trae Matlab (por ejemplo mean).
Generalmente las funciones vienen con alguna ayuda de su utilizaci¶on, la
cual se puede visualizar a trav¶es de la funci¶on help.
1.2.3. Algunas Variables y Funciones de utilidad

Matlab trae muchas variables y funciones predeflnidas, algunas de estas
variables se muestran en el cuadro 1.3, mientras que algunas funciones m¶as
utilizadas aparecen en el cuadro 1.4.
Si se aplica alguna de las funciones matem¶aticas a alguna matriz se ob-
tiene una matriz en la que los elementos han sido evaluados por la funci¶on.
Por ejemplo:
>> X=0:0.1:1;
>> exp(-X)
ans =
10 Variables y Funciones
Nombre Descripci¶on
pi El n¶ umero m¶as famoso del mundo
i Unidad imaginaria
j Lo mismo que i, pero para los el¶ectricos
Inf Inflnito
NaN No es un n¶ umero
eps Precisi¶on relativa de punto flotante, 2−52
Cuadro 1.3: Variables Predeflnidas
Nombre Descripci¶on
sin(X) Funci¶on seno de X
cos(X) Funci¶on coseno de X
tan(X) Funci¶on tangente de X
exp(X) Funci¶on exponencial de X
log(X) Funci¶on logaritmo natural de X
plot(X,Y) Gr¶aflca Y versus X
clear(A) Borra la variable A
det(A) Calcula el determinante de la matriz A
eig(A) Calcula los valores y vectores propios de la matriz
A
poly(A) Calcula los coeflcientes del polinomio caracter¶‡stico
de la matriz A
roots(coef) Calcula los ra¶‡ces del polinomio cuyos coeflcientes
vienen en coef
sum(X) Suma los elementos del vector X
length(X) Retorna el largo del vector X
size(A) Retorna las dimensiones de la matriz A
help funcion Entrega ayuda sobre la funci¶on funcion
lookfor palabra Retorna las funciones en las que aparece el string
palabra
Cuadro 1.4: Funciones B¶asicas m¶as comunes
Columns 1 through 7
1.0000 0.9048 0.8187 0.7408 0.6703 0.6065 0.5488

1.2.3 Algunas Variables y Funciones de utilidad 11
0.4966 0.4493 0.4066 0.3679

12 Gr¶
aflcos
1.3. Gráficos
Para graflcar en Matlab fundamentalmente se utiliza la funci¶on plot
mencionada anteriormente, sin embargo tambi¶en es posible graflcar en forma
escalonada, utilizando s¶olo l¶‡neas verticales, utilzando n¶
umeros complejos o
en 3D, entre muchas maneras de graflcar. A continuaci¶on se detallan las m¶as
utilizadas y los comandos m¶as u ¶tiles relacionados.
1.3.1. Figuras
Una flgura es una ventana en la cual se desplegan los gr¶aflcos obtenidos
mediante Matlab. Esto presenta varias ventajas las cuales se mostrar¶an m¶as
adelante.
Aunque, generalmente, las flguras se generan por defecto al crear un gr¶afl-
co, a veces es necesario pedir otra flgura a Matlab, para esto se utiliza el
comando figure, el cual genera otra flgura en la pantalla. El modo de utili-
zarlo es:
>> figure
Si se desea cerrar alguna flgura se utiliza la funci¶on close, seguida del
n¶
umero de la flgura. Si se quiere cerrar todas las flguras entonces se ejecuta:
>> close all
lo cual cierra todas las flguras existentes5 .
1.3.2. Gráficos en 2D
Como se menciona anteriormente se utiliza la funci¶on plot, tal como se
muestra en el siguiente ejemplo:
>> t=0:0.1:5;
>> plot(t,exp(-t))
lo cual produce como resultado la flg. 1.1.
Para que plot funcione ambos vectores deben tener el mismo largo. Si X
o Y es una matriz entonces el vector es graflcado versus las fllas o columnas
de la matriz, dependiendo de con cual se alinee.
5
De manera análoga clear all borra todas las variables
1.3.2 Gr¶
aflcos en 2D 13
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5
Figura 1.1: Ejemplo de plot
Adem¶as plot tiene m¶as opciones las cuales se pueden ver en la ayuda de
la funci¶on.
Una forma de graflcar com¶unmente usada es aquella en la cual se encuen-
tran dos gr¶aflcas en la misma flgura . Lo anterior se puede lograr de varias
maneras, dos de ellas son:
>> plot(t,exp(-t),t,sin(t))
>> plot(t,[exp(-t); sin(t)])
las cuales producen el mismo resultado (flg. 1.2). Sin embargo, hay otra
opci¶on la cual consiste en utilizar la funci¶on hold que retiene el gr¶aflco actual
y agrega el gr¶aflco deseado a la flgura actual. Para el ejemplo anterior:
>> plot(t,exp(-t))
>> hold on
>> plot(t,sin(t))
>> hold off
cuyo resultado se muestra en la flg. 1.3. La utilizaci¶on de hold off es para
soltar la flgura.
14 Gr¶
aflcos
0.8
0.6
0.4
0.2
−0.2
−0.4
−0.6
−0.8
−1
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5
Figura 1.2: Dos gr¶aflcas en la misma flgura
Para crear una leyenda de las gr¶aflcas se utiliza la funci¶onlegend(string1,

string2, ...), donde los string i son los textos de cada gr¶aflco para la
leyenda, as¶‡ para el ejemplo anterior, la instrucci¶on:
>> legend(’exponencial’, ’seno’)
produce la flg. 1.4.
Tambi¶en es posible graflcar en escalonada utilizando la funci¶on stairs(X,Y)
de manera an¶aloga al uso de la funci¶on plot, con la diferencia que los ele-
mentos del vector X deben ser equiespaciados.
Si se quiere graflcar señales de tiempo discreto se puede utilizar la funci¶on
stem(X,Y), cuyo uso es an¶alogo a las funciones anteriores.
Muchas veces es muy u ¶til agrupar varios gr¶aflcos en una misma flgura, lo
cual se consigue f¶acilmente con la funci¶on subplot(m,n,i), la cual divide la
flgura en una matriz de m£n y el gr¶aflco se agrega en el elemento i-¶esimo.
Adem¶as, tiene la ventaja de agregar gr¶aflcas que ocupen distinto tamaño en
la flgura resultante. Por ejemplo, las siguientes instrucciones:
>> X=-pi:0.1:pi;
>> subplot(3,2,1)
1.3.2 Gr¶
aflcos en 2D 15
0.8
0.6
0.4
0.2
−0.2
−0.4
−0.6
−0.8
−1
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5
Figura 1.3: Ejemplo de hold
>> plot(X,sin(X));
>> subplot(3,2,2)
>> plot(X,cos(X));
>> subplot(3,1,2)
>> plot(X,cos(X)+sin(X));
>> subplot(3,1,3)
>> plot(X,[cos(X);sin(X)]);
generan como resultado la flg. 1.5.

Tambi¶en hay funciones para poner t¶‡tulos, formatear los ejes, poner textos
en cualquier parte de la flgura, nombrar el eje x y el eje y, utilizar grilla, etc.
La mayor¶‡a de las funciones anteriores aparece en la ayuda de la funci¶on
plot.
No hay que olvidar que todas las instrucciones anteriores pueden combi-
narse, para producir las flguras que uno desea.
16 Gr¶
aflcos
1
exponencial
seno
0.8
0.6
0.4
0.2
−0.2
−0.4
−0.6
−0.8
−1
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5
Figura 1.4: Ejemplo de legend
1 1
0.5 0.5
0 0
−0.5 −0.5
−1 −1
−4 −2 0 2 4 −4 −2 0 2 4
−1
−2
−4 −3 −2 −1 0 1 2 3 4
0.5
−0.5
−1
−4 −3 −2 −1 0 1 2 3 4
Figura 1.5: Ejemplo de subplot

Cap¶ıtulo 2
Simulink
Simulink es un sistema interactivo para simular sistemas dinámicos no-

lineales. La gran ventaja de Simulink es su interfaz gráfica, mediante la cual se
pueden implementar complicados modelos y obtener simulaciones en un tiempo
extremadamente rápido a través de los diagramas de bloques.
2.1. Diagramas de Bloques

En pocas palabras para utilizar Simulink s¶olo hay que saber c¶omo tra-
ducir una ecuaci¶on diferencial o de diferencias a un diagrama de bloques. Por
ejemplo si se desea simular la respuesta de la siguiente ecuaci¶on diferencial
ẏ(t) + 3y(t) = 1
(2.1)
y(0) = 0
primero hay que generar el diagrama de bloques del modelo, el cual se observa
en la flg. 2.1. La implementaci¶on en Simulink se muestra la flg. 2.2, y a
Figura 2.1: Diagrama de Bloques
17
18 Usando Simulink
Figura 2.2: Implementaci¶on en Simulink
trav¶es de ¶esta se obtiene la respuesta del sistema descrito por (2.1), la cual
se aprecia en la flg. 2.3.
0.35
0.3
0.25
0.2
0.15
0.1
0.05
0
0 1 2 3 4 5 6 7 8 9 10
Figura 2.3: Respuesta del sistema din¶amico
2.2. Usando Simulink

Para utilizar Simulink s¶olo es necesario construir el diagrama de bloques
mediante los bloques predeflnidos que vienen en la librer¶‡a.
El uso de los bloques es bastante sencillo, s¶olo hay que arrastrar el icono
del bloque al modelo que se est¶a construyendo. Si se desean cambiar los
par¶ametros de los bloques s¶olo hay que hacer un doble click sobre su icono.
2.2.1 Librer¶‡a “Continuos” 19
Para conectar los bloques hay que situar el puntero del mouse sobre el
puerto de salida del primer bloque, con lo que el puntero deber¶‡a cambiar a
una cruz, y arrastrar el mouse hacia el puerto de entrada del siguiente bloque.
A continuaci¶on se detallan los bloques m¶as utilizados.
2.2.1. Librerı́a “Continuos”

En esta librer¶‡a se encuentran todos los bloques de tiempo continuo para
sistemas lineales, los cuales son:
Derivative: Derivada num¶erica de la señal de entrada.
Integrator: Integra la señal de entrada.
Memory: Retrasa la señal en un tiempo de integraci¶on.
State-Space: Representaci¶on en variables de estado.
Transfer-Fcn: Representaci¶on en funci¶on de transferencia. Expresi¶on ma-

tricial para el numerador, expresi¶on vectorial para el denominador. El
ancho de la salida debe ser igual al n¶
umero de fllas del numerador. Los
coeflcientes son potencias descendentes de s.
Transport Delay: Aplica el retraso especiflcado a la señal de entrada.
Variable Transport Delay: Aplica un retraso a la primera señal de entra-

da. La segunda entrada especiflca el retardo.
Zero-Pole: Representaci¶on en polos y ceros. Expresi¶on matricial para los

ceros. Expresi¶on vectorial para los polos y la ganancia. El ancho de la
salida debe igualar el n¶
umero de columnas de la matriz de ceros, o uno
si los ceros son un vector.
2.2.2. Librerı́a “Discrete”

Esencialmente es id¶entica a la anterior, pero para sistemas lineales de
tiempo discreto, i.e. para ecuaciones de diferencias. Los bloques son:
Discrete Transfer-Fcn: Funci¶on de transferencia discreta, an¶alogo al caso

continuo.
20 Usando Simulink
Discrete Zero-Pole: Representaci¶on discreta en polos y ceros. ¶Idem al caso

continuo.
Discrete Filter: Filtro discreto. Expresi¶on vectorial para el numerador y el

denominador. Los coeflcientes son para potencias ascendentes de z−1 .
Discrete State-Space: Representaci¶on en variables de estado de tiempo

discreto.
Discrete-Time Integrator: Integraci¶on en tiempo discreto de la señal de

entrada.
First-Order Hold: Retenedor de primer orden.
Unit Delay: Muestrea y retiene con un per¶‡odo de muestreo de retraso.
Zero-Order Hold: Retenedor de orden cero.
2.2.3. Librerı́as “Sources” y “Sinks”

Estas librer¶‡as son aquellas que proveen las fuentes y los sumideros de los
diagramas de bloques. Algunos de ¶estos son:
Clock: Librer¶ıa “Sources”. Genera el tiempo de simulaci¶on actual.
Constant: Librer¶ıa “Sources”. Genera una constante especiflcada en el par¶ame-

tro ‘Constant value’ . Si ’Constant value’ es un vector y ’Interpret vector
parameters as 1-D’ est¶a arriba (on), el valor constante es tratado como
un arreglo 1-D. Sino, la salida es una matriz con las mismas dimensiones
que el valor constante.
Signal Generator: Librer¶ıa “Sources”. Genera varias formas de onda.
Sine Wave: Librer¶ıa “Sources”. Genera una onda sinusoidal.
Step: Librer¶ıa “Sources”. Genera un escal¶on.
Display: Librer¶ıa “Sinks”. Representaci¶on num¶erica de los valores de en-

trada.
Scope: Librer¶ıa “Sinks”. Representaci¶on gr¶aflca de los valores de entrada

versus el tiempo de simulaci¶on.
2.2.4 Otras Librer¶‡as 21
Stop Simulation: Librer¶ıa “Sinks”. Detiene la simulaci¶on cuando la en-

trada es distinta de cero.
To File: Librer¶ıa “Sinks”. Escribe el tiempo y la entrada al archivo MAT

especiflcado en formato flla. El tiempo est¶a en la primera flla.
To Workspace: Librer¶ıa “Sinks”. Escribe la salida al arreglo o estructura

especiflcado en el workspace principal de Matlab. Los datos no est¶an
disponibles hasta que la simulaci¶on se detiene.
XY Graph : Librer¶ıa “Sinks”. XY scope usando la ventana gr¶aflca de

Matlab. la primera entrada es usada como base temporal. Se ingresan
los rangos del gr¶aflco.
2.2.4. Otras Librerı́as

Adem¶as de las librer¶‡as anteriormente detalladas, existen otras que pro-
veen los siguientes bloques que son extremadamente u ¶tiles:
Fcn: Librer¶ıa “Functions & Tables”. Bloque para una expresi¶on general.
Usa “u” como el nombre de la variable de entrada. Ejemplo: sin(u[1]
* exp(2.3 * -u[2]))
MATLAB Fcn: Librer¶ıa “Functions & Tables”. Pasa los valores de entra-
da a una funci¶on de Matlab para evaluarla. La funci¶on debe retornar
un s¶olo argumento vectorial del largo de ‘Output width’. Ejemplos:
sin, sin(u), foo(u(1), u(2))
Polynomial: Librer¶ıa “Functions & Tables”. Evaluaci¶on polinomial. Cal-

cula P(u) dado por el arreglo de coeflcientes polinomiales P. P est¶a or-
denado del mayor al menor orden, la forma aceptada por la funci¶on
polyval de Matlab.
S-Function: Librer¶ıa “Functions & Tables”. Bloque deflnible por el usua-

rio. Los bloques pueden estar escritos en M, C, Fortran o Ada y deben
cumplir los est¶andares de S-function. t,x,u y flag son autom¶aticamente
entregados a la S-function por Simulink. Par¶ametros “Extra” pueden
ser especiflcados en el campo ‘S-function parameters’.
Abs: Librer¶ıa “Math”. Valor absoluto, i.e. y = |u|.

22 Usando Simulink
Dot Product: Librer¶ıa “Math”. Producto interno (punto). y = sum(conj(

u1).*u2)
Gain: Librer¶ıa “Math”. Ganancia elemento a elemento (y = K.*u) o ga-

nancia matricial (y = K*u o y = u*K).
Math Function: Librer¶ıa “Math”. Funciones matem¶aticas incluyendo fun-

ciones logar¶‡tmicas, exponencial, potenciaci¶on, y m¶odulo.
Matrix Gain: Librer¶ıa “Math”. Ganancia elemento a elemento (y = K.*u)

o ganancia matricial (y = K*u o y = u*K).
MinMax: Librer¶ıa “Math”. La salida es el m¶‡nimo o m¶aximo de la entrada.

Para una sola entrada, los operadores se aplican a trav¶es del vector de
entrada. Para m¶ultiples entradas, los operadores se aplican a trav¶es de
las entradas.
Product: Librer¶ıa “Math”. Multiplica o divide las entradas. Especiflcar

una de las dos opciones siguientes:
1. * o / para cada puerto de entrada (ej., **/*)

2. Un escalar especiflcando el n¶umero de puertos de entrada a ser
multiplicados.
El valor escalar ‘1’ para producto elemento a elemento causa que
todos los elementos de un solo vector de entrada sean multiplica-
dos.
Sum: Librer¶ıa “Math”. Suma o substrae las entradas. Especiflcar una de

las dos opciones siguientes:
1. Un string conteniendo + o - para cada puerto de entrada, | para

espacio entre los puertos (ej. ++|-|++)
2. Un escalar ≥ 1. Un valor ¿1 suma todas las entradas; 1 suma los
elementos de una solo vector de entrada.
Trigonometric Function: Librer¶ıa “Math”. Funciones trigonom¶etricas e

hiperb¶olicas.
Demux: Librer¶ıa “Signals & Systems”. Divide:

2.2.4 Otras Librer¶‡as 23
1. señales vectoriales a escalares o vectores m¶as pequeños, o

2. señales tipo bus producidas por el bloques Mux en sus valores
escalares, vectoriales o matriciales constituyentes. Chequear ‘Bus
Selection Mode’ para dividir señales tipo bus.
Mux: Librer¶ıa “Signals & Systems”. Multiplexa señales escalares, vectoria-

les, o matriciales a un bus.
Terminator: Librer¶ıa “Signals & Systems”. Usado para “terminar”señales

de salida. (Previene advertencias acerca puertos de salida no conecta-
dos.)
24 Usando Simulink
Ap¶
endice A
Funciones Comunes
A continuaci¶on se incluyen las funciones m¶as utilizadas de Matlab con

una pequeña descripci¶on de lo que hacen.
acos: Funci¶on. Sintaxis acos(X). Funci¶on arcocoseno de X.
asin: Funci¶on. Sintaxis asin(X). Funci¶on arcoseno de X.
atan: Funci¶on. Sintaxis atan(X). Funci¶on arcotangente de X.
atan2: Funci¶on. Sintaxis atan(Y,X). Funci¶on arcotangente de Y/X. La salida

se encuentra entre ¡π y π.
clear: Funci¶on. Sintaxis clear(A). Borra la variable A.
cos: Funci¶on. Sintaxis cos(X). Funci¶on coseno de X.
ctrb: Funci¶on. Sintaxis ctrb(A,B). Retorna la matriz de controlabilidad del

sistema formado por A y B.
det: Funci¶on. Sintaxis det(A). Calcula el determinante de la matriz A.
eig: Funci¶on. Sintaxis eig(A). Calcula los valores y vectores propios de la

matriz A.
eps: Variable. Precisi¶on relativa de punto flotante, 2−52 .
exp: Funci¶on. Sintaxis exp(X). Funci¶on exponencial de X.
expm: Funci¶on. Sintaxis expm(A). Calcula la matriz exponencial de A.
25
26 ¶
APENDICE A. FUNCIONES COMUNES
help: Funci¶on. Sintaxis help function. Entrega ayuda sobre la funci¶on

function.
i: Variable. Unidad imaginaria.
inv: Funci¶on. Sintaxis inv(A). Retorna la matriz inversa de A.
Inf: Variable. Inflnito.
j: Variable. Lo mismo que i, pero para los el¶ectricos.
length: Funci¶on. Sintaxis length(X). Retorna el largo del vector X.
log: Funci¶on. Sintaxis log(X). Funci¶on logaritmo natural de X.
logm: Funci¶on. Sintaxis logm(A). Logaritmo natural matricial de A. Es la

funci¶on inversa de expm(A).
log10: Funci¶on. Sintaxis log10(X). Funci¶on logaritmo ordinario (en base

10) de X.
log2: Funci¶on. Sintaxis log2(X). Funci¶on logaritmo en base 2 de X.
lookfor: Funci¶on. Sintaxis lookfor(string). Retorna las funciones en las

que aparece la palabra string en la ayuda de dicha funci¶on.
max: Funci¶on. Sintaxis [Y,I]=max(X). Retorna el elemento m¶as grande de

X en Y, y el ¶‡ndice en que se encuentra en I.
mean: Funci¶on. Sintaxis mean(X). Retorna el valor medio o promedio de los

elementos de X.
min: Funci¶on. Sintaxis [Y,I]=max(X). Retorna el elemento m¶as pequeño de

X en Y, y el ¶‡ndice en que se encuentra en I.
NaN: Variable. No es un n¶
umero, usualmente aparece cuando hay una di-
visi¶on del tipo 0/0.
obsv: Funci¶on. Sintaxis obsv(A,C). Retorna la matriz de observabilidad del

sistema formado por A y C.
pi: Variable. El n¶
umero m¶as famoso del mundo.
27
plot: Funci¶on. Sintaxis plot(X,Y). Gr¶aflca Y versus X.
poly: Funci¶on. Sintaxis poly(A). Calcula los coeflcientes del polinomio ca-
racter¶‡stico de la matriz A.
roots: Funci¶on. Sintaxis roots(coef). Calcula los ra¶‡ces del polinomio cu-
yos coeflcientes vienen en coef.
sin: Funci¶on. Sintaxis sin(X). Funci¶on seno de X.
size: Funci¶on. Sintaxis size(A). Retorna las dimensiones de la matriz A.
sum: Funci¶on. Sintaxis sum(X). Suma los elementos del vector X.
subplot: Funci¶on. Sintaxis subplot(m,n,i). Genera una separaci¶on en una

flgura, dada por un arreglo de m fllas y n columnas, y graflca en la
posici¶on i-¶esima del arreglo.
ss: Funci¶on. Sintaxis ss(A,B,C,D). Genera un modelo formulado en varia-

bles de estado.
ss2tf: Funci¶on. Sintaxis [num,den]=tf2ss(A,B,C,D). Convierte una repre-

sentaci¶on en variables de estado a un modelo dado por la funci¶on de
transferencia.
ss2zp: Funci¶on. Sintaxis [Z,P,K]=zp2ss(A,B,C,D). Convierte una repre-

sentaci¶on en variables de estado a un modelo en formato zpk.
std: Funci¶on. Sintaxis std(X). Retorna la desviaci¶on est¶andar de los ele-

mentos de X.
tan: Funci¶on. Sintaxis tan(X). Funci¶on tangente de X.
tf: Funci¶on. Sintaxis tf(num,den). Crea una funci¶on de transferencia. num

son los coeflcientes del numerador, que van listados en potencias decre-
cientes de s o z, den es an¶alogo.
tf2ss: Funci¶on. Sintaxis [A,B,C,D]=tf2ss(num,den). Convierte una fun-

ci¶on de transferencia a una representaci¶on en variables de estado. num
son los coeflcientes del numerador, que van listados en potencias decre-
cientes de s o z, den es an¶alogo.
28 ¶
APENDICE A. FUNCIONES COMUNES
tf2zp: Funci¶on. Sintaxis [Z,P,K]=tf2zp(num,den). Convierte una funci¶on

de transferencia a una representaci¶on zpk. num son los coeflcientes del
numerador, que van listados en potencias decrecientes de s o z, den es
an¶alogo.
var: Funci¶on. Sintaxis var(X). Retorna la varianza de los elementos de X.
zpk: Funci¶on. Sintaxis zpk(Z,P,K). Genera un modelo en el formato ceros-

polos-ganancia (zpk).
zp2ss: Funci¶on. Sintaxis [A,B,C,D]=zp2ss(Z,P,K). Convierte un modelo

en formato zpk a una representaci¶on en variables de estado.
zp2tf: Funci¶on. Sintaxis [num,den]=zp2tf(Z,P,K). Convierte una repre-

sentaci¶on zpk a una funci¶on de transferencia.
Bibliograf¶ıa
[1] The Mathworks, “Getting Started with Matlab”
29
30 BIBLIOGRAF¶IA
¶Indice alfab¶
etico
\, 2 double, 8
’, 2
”, 8 eig, 10, 25
(), 5 eliminar elementos, 6
*, 2 eps, 10, 25
+, 2 exp, 10, 25
-, 2 expm, 25
., 8 eye, 3
/, 2
:, 4, 5 figure, 12
;, 1 funciones, 1
=, 1
help, 9, 10, 26
[], 1, 7
hold, 13
ˆ, 2
acos, 25 i, 10, 26
ans, 2 Inf, 10, 26
arreglos, 8 inv, 2, 26
asin, 25
j, 10, 26
atan, 25
atan2, 25 legend, 14
char, 8 length, 10, 26
clear, 10, 12, 25 librer¶‡a, 18
close, 12 continuos, 19
concatenar, 7 Derivative, 19
cos, 10, 25 Integrator, 19
ctrb, 25 Memory, 19
obsv, 26 State-Space, 19
Transfer-Fcn, 19
det, 10, 25 Transport Delay, 19
31
32 ¶INDICE ALFABETICO
¶
Variable Transport Delay, XY Graph, 21

19 sources, 20
Zero-Pole, 19 Clock, 20
discrete, 19 Constant, 20
Discrete Filter, 20 Signal Generator, 20
Discrete State-Space, 20 Sine Wave, 20
Discrete Transfer-Fcn, 19 Step, 20
Discrete Zero-Pole, 20 log, 10, 26
Discrete-Time Integrator, log10, 26
20 log2, 26
First-Order Hold, 20 logm, 26
Unit Delay, 20 lookfor, 10, 26
Zero-Order Hold, 20
functions & tables, 21 matrices, 1, 8
Fcn, 21 max, 26
MATLAB Fcn, 21 mean, 9, 26
Polynomial, 21 min, 26
S-Function, 21
math, 21 NaN, 10, 26
Abs, 21
ones, 3
Dot Product, 22
Gain, 22 pi, 10, 26
Math Function, 22 plot, 10, 12, 27
Matrix Gain, 22 poly, 10, 27
MinMax, 22
Product, 22 roots, 10, 27
Sum, 22
Trigonometric Function, 22 seleccionar elementos, 5
signals & systems, 22 sin, 10, 27
Demux, 22 size, 10, 27
Mux, 23 ss, 27
Terminator, 23 ss2tf, 27
sinks, 20 ss2zp, 27
Display, 20 stairs, 14
Scope, 20 std, 27
Stop Simulation, 21 stem, 14
To File, 21 subplot, 14, 27
To Workspace, 21 sum, 10, 27
¶INDICE ALFABETICO
¶ 33
tan, 10, 27
tf, 27
tf2ss, 27
tf2zp, 28
var, 28
variables, 1
variables, 1
vectores, 4
zeros, 3
zp2ss, 28
zp2tf, 28
zpk, 28
Complementos de Procesado de Señal y Comunicaciones
Máster en Sistemas Multimedia
Introducción a
Matlab y Simulink
Javier Ramírez Pérez de Inestrosa
Dpto. Teoría de la Señal, Telemática y Comunicaciones
Universidad de Granada
Email: javierrp@ugr.es
Este tutorial se puede obtener en:

http://www.ugr.es/~javierrp
¿Qué es Matlab?
 MATLAB es un lenguaje de alto nivel para

realizar cálculos cientifico-técnicos.
 Integra las herramientas de cálculo

necesarias con otras de visualización así
como, un entorno de programación de fácil
uso.
Introducción a Matlab y Simulink

Javier Ramírez 2
Aplicaciones típicas
 Cálculo matemático
 Desarrollo de algoritmos
 Adquisición de datos
 Modelado, simulación y prototipado
 Análisis de datos y visualización
 Gráficos
 Desarrollo de aplicaciones e interfaces
gráficas de usuario (GUI)
Javier Ramírez 3
Más sobre MatLab
 MatLab significa “MATrix LABoratory”
 El tipo básico de datos es el vector que no

requiere ser dimensionado.
 Proporciona unos paquetes de extensión

(“toolboxes”) para aplicaciones específicas
 Estos paquetes incluyen librerías de funciones

MatLab (M-files) que extienden las posibilidades
de MatLab para resolver problemas específicos
Javier Ramírez 4
El entorno de Matlab

Javier Ramírez 5
Sintaxis
 Algunos ejemplos sencillos

Entrada Salida Comentarios
2+3 ans = 5
7-5 ans = 2
Los resultados son los esperados.
34*212 ans = 7208
1234/5786 ans = 0.2173 Nótese que al resultado se le da el nombre ans.
2^5 ans = 32
a = sqrt(2) a = 1.4142 Se puede escoger el nombre de la variable.

Javier Ramírez 6
b = 1.4142
Se pueden introducir varios
ans = 3.1416
b = a, pi, 2 + 3i comandos en una sola línea. Pi, i,
ans = 2.0000 +
y j son constantes.
3.0000i
"eps" es el limite actual de
c = sin(pi) c = 1.2246e-016
precisión. No se puede operar con
eps ans = 2.2204e-016
números inferiores a eps.
d= Definición de vectores. "d", "e",
[1 2 3 4 5 6 7 8 9 d = 1 2 3 4 5 6 7 8 9 son "f" vectores. Son iguales. El
] e=123456789 operador “:” se utiliza para formar
e = [1:9] f=123456789 vectores; cuenta desde el número
f = 1:9 inicial al final de uno en uno.
g = 0:2:10 g = 0 2 4 6 8 10
Otros usos de “:”. Se utiliza para
f(3) ans = 3
acceder a parte o la totalidad de
f(2:7) ans = 2 3 4 5 6 7
los datos de un vector o matriz.
f(:) 123456789

Javier Ramírez 7
Un punto y coma ";" evita que se
h = [1 2 3]; (nada) visualice la salida.
h' ans = 1 Una coma simple " ' " calcula la
2 traspuesta de una matriz, o en el caso
3 de vectores, intercambia entre vectores
fila y columna.
Operaciones con vectores. * es la
h * h' ans = 14 multiplicación matricial. Las
h .* h ans = 1 4 9 dimensiones deben ser las apropiadas.
h + h ans = 2 4 6 " .* " es la multiplicación componente a
componente.
g = 1 2 3
g = [ 1 2 3;
4 5 6 Construcción de matrices.
4 5 6; 7 8 9]
7 8 9
g(2,3) ans = 6
Accediendo a los elementos de la
g(3,:) ans = 7 8 9
matriz.
g(2,3) = 4 g = 1 2 3
":" se utiliza para acceder a una fila
4 5 4
completa.
7 8 9

Javier Ramírez 8
ans = 30 36 42
g^2
66 81 96
Multiplica la matriz por ella misma.
102 126 150
ans = 1 4 9
g .^ 2 Eleva al cuadrado cada elemento de la
16 25 36
matriz.
49 64 81

Javier Ramírez 9
Control de la salida
 El comando format
 format compact
 Controla el espaciado de líneas.
 format long
 Muestra los 15 dígitos que se utilizan en el cálculo.
 format short
 Muestra únicamente cinco dígitos.
 “;” al final del comando.
 No visualizar salida:
 help format
 Más información.

Javier Ramírez 10
Más sobre matrices
 Funciones incluidas en MatLab

rand(2) ans = 0.9501 0.6068
0.2311 0.4860 Genera una matriz de
rand(2,3) ans = 0.8913 0.4565 0.8214 números aleatorios entre 0 y 1
0.7621 0.0185 0.4447
zeros(2) ans = 0 0
0 0 Genera una matriz 2x2 de
ones(2) ans = 1 1 ceros o unos.
1 1
eye(2) ans = 1 0
0 1 Matriz identidad I.
hilb(3) ans = 1.0000 0.5000 0.3333
0.5000 0.3333 0.2500 Matriz de Hilbert 3x3.
0.3333 0.2500 0.2000

Javier Ramírez 11
Más sobre matrices
 Concatenación
 Generar nuevas matrices a partir de otras
creadas previamente
 Por ejemplo:
 Sea la matriz a:
>> a = [1 2; 3 4]
a =
1 2
3 4

Javier Ramírez 12
Más sobre matrices - concatenación
Entrada Salida
[a, a, a] ans = 1 2 1 2 1 2
3 4 3 4 3 4
[a; a; a] ans = 1 2
3 4
1 2
3 4
1 2
3 4
[a, zeros(2); zeros(2), a'] ans = 1 2 0 0
3 4 0 0
0 0 1 3
0 0 2 4

Javier Ramírez 13
Más sobre matrices
 Programación
 Se pueden construir matrices mediante programación
for i=1:10,
for j=1:10,
t(i,j) = i/j;
end
end
 No se produciría salida puesto que la única línea que

podría generar salida (t(i,j) =i/j;) termina en “;”
 Sin el “;”, Matlab escribiría la matriz t 100 veces!!

Javier Ramírez 14
Operaciones con matrices
 +, -, *, y /
 Definen operaciones con matrices.
 Debemos distinguir:
 “.*”:
Multiplicación componente a componente.
 “*”
Multiplicación matricial.

Javier Ramírez 15
Escalares
 Un escalar es un número.
 Matlab los almacena como matrices 1x1
 Todas las operaciones entre escalares y

matrices se realizan componente a
componente salvo:
 La potencia (“^”).

Javier Ramírez 16
Escalares
a = 1 2
3 4
 Ejemplos
b=2 b=2 Define b como un escalar.

ans = 3 4 La suma se hace componente a
a + b
5 6 componente.
ans = 2 4
a * b Igual que la multiplicación.
6 8
ans = 7 10
a ^ b Potencia matricial - a*a
15 22
ans = 1 4 Potencia componente a
a .^ b
9 16 componente.

Javier Ramírez 17
Vectores
 Un vector es una matriz de una sola fila o

columna
v = [1 2 3] v = 1 2 3
Define 2 vectores.
u = [3 2 1] u = 3 2 1
v * u Error Las dimensiones no coinciden.
Al tomar la traspuesta se corrige el

v * u' ans = 10
error.
Producto escalar (idéntico al
dot(v,u) ans = 10
anterior).
El producto vectorial sólo se emplea
cross(v,u) ans = -4 8 -4
con vectores en 3 dimensiones.
Javier Ramírez 18
Matrices
 Matlab tiene numerosas funciones

predefinidas (help matfun).
k = [16 2 3; k = 16 2 3
Define una
5 11 10; 5 11 10
matriz.
9 7 6] 9 7 6
Traza de una
trace(k) ans = 33
matriz
Rango de una
rank(k) ans = 3
matriz.
Determinante de
det(k) ans = -136
una matriz

Javier Ramírez 19
Matrices
ans = 0.0294 -0.0662 0.0956
Inversa de una
inv(k) -0.4412 -0.5074 1.0662
matriz
0.4706 0.6912 -1.2206
Vectores propios
y autovalores de
vec = -0.4712 -0.4975 -0.0621 una matriz.
-0.6884 0.8282 -0.6379 Las columnas de
-0.5514 0.2581 0.7676 "vec" contienen
[vec,val] =
los vectores
eig(k)
val = 22.4319 0 0 propios;
0 11.1136 0 las entradas de
0 0 -0.5455 la diagonal de
"val" son los
autovalores.

Javier Ramírez 20
Variables en el espacio de trabajo
 whos
 Lista las variables definidas en el entorno.
>> whos
Name Size Bytes Class
a 100x1 800 double array

b 100x100 80000 double array
c 1x1 8 double array
Grand total is 10101 elements using 80808 bytes
 clear
 Borra variables del entorno.

Javier Ramírez 21
Resolución de sistemas de ecuaciones
 Una de las principales aplicaciones de las matrices

es la representación de sistemas de ecuaciones
lineales.
 Si a es una matriz de coeficientes, x es un vector
columna que contiene las incógnitas y b los
términos constantes, la ecuación
a x =b
representa el correspondiente sistema de

ecuaciones.

Javier Ramírez 22
Resolviendo ecuaciones
 Para resolver el sistema en MatLab

 x = a \ b
 x es igual a la inversa de a por b
 Ejemplo
 a = [1 2 3; 4 5 6; 7 8 10]; b = [1 1 1]';
 Solución:
x =
-1
1
0

Javier Ramírez 23
Salvar y recuperar datos
 Los datos de la sesión se pierden al salir de

MatLab.
 Para salvar la sesión (entrada y salida)

 Diary(‘session.txt’);
 Guarda los comandos introducidos en la sesión.
 Diary <ON/OFF> ;
 Para salvar una o varias matrices
 save datos.mat (guarda todas las variables)
 save datos.mat x (sólo guarda x)

Javier Ramírez 24
Salvar y recuperar matrices
 save sesion
 Salva todas las variables en el archivo binario “sesion.mat”.
 save fichero X
 Salva sólo la variable X
 load sesion
 Recupera los datos previamente salvados
 Si los ficheros se pueden salvar en formato texto (-

ascii). Pueden verse con un editor de textos.
Javier Ramírez 25
Gráficos
 El comando básico es: plot

 plot(y);
 plot(x,y);
 plot(x,y,’b+’,x,z,’gx’);
 color (b,g) blue,green
 Marcador (+,x)
 Personalización del gráfico:
 title, xlabel, ylabel, legend, grid.

Javier Ramírez 26
Ejemplo
 Mes = 1:12;
 T_Gr = [-2 0 2 4 8 12 14 14 12 8 4 0];
 T_Ma = [-4 -2 0 2 6 14 18 18 16 8 2 -2];
 plot(Mes, T_Gr, 'bo', Mes, T_Ma, 'rv');
 xlabel('Mes');
 ylabel('Temperatura (°C)');
 title('Temperaturas minimas en Granada y
Madrid');
 legend('Granada','Madrid');
 grid;

Javier Ramírez 27
Resultado:

Javier Ramírez 28
subplot
 Mes = 1:12
 T_Gr = [-2 0 2 4 8 12 14 14 12 8 4 0];
 T_Ma = [-4 -2 0 2 6 14 18 18 16 8 2 -2];
 subplot(2,1,1);
 plot(Mes, T_Gr, 'bo-');
 xlabel('Mes');
 title('Temperaturas minimas en Granada');
 grid;
 subplot(2,1,2);
 plot(Mes, T_Ma, 'rv-');
 xlabel('Mes');
 title('Temperaturas minimas en Madrid');
 grid;

Javier Ramírez 29
Resultado

Javier Ramírez 30
Gráficos tridimensionales
 [x,y] = meshgrid(-2:.2:2, -2:.2:2);
 z = x .* exp(-x.^2 - y.^2);
 mesh(z);

Javier Ramírez 31
Gráficos tridimensionales
 Z = X.*exp(-X.^2-Y.^2);
 contour3(X,Y,Z,30)
 surface(X,Y,Z,'EdgeColor',[.8 .8.8],'FaceColor','none')
 grid off 0.5
 view(-15,25) 0.4
 colormap cool 0.3
0.2
0.1
-0.1
-0.2
-0.3
-0.4
-0.5
2
-1
1.5 2
0.5 1
-0.5 0
-2 -1.5 -1
-2

Javier Ramírez 32
Programación
 Ficheros de comandos (scripts)

 Secuencias de comandos.
 Al invocarlos se ejecutan en el entorno.
 Las variables creadas son globales.
 Ficheros de función
 Permiten definir funciones propias.
 Variables locales.
 La información se pasa como parámetros.
 Se pueden definir subfunciones.
Javier Ramírez 33
Un ejemplo de función
function y = media (x)
% Valor medio de x.
% Para vectores, media(x) devuelve el valor medio.
% Para matrices, media(x) es un vector fila
% que contiene el valor medio de cada columna.
[m,n] = size(x);
if m == 1
m = n;
end
y = sum(x)/m;

Javier Ramírez 34
Argumentos de funciones
 nargin y nargout
 Número de argumentos de entrada y salida con
los que se llama a la función.
 Ejemplo:
function c = testarg1(a,b)
if (nargin == 1)
c = a.^2;
elseif (nargin == 2)
c = a + b;
end
Javier Ramírez 35
Subfunciones
function [media,mediana] = estadistica(u) % Función principal
% ESTADISTICA Calcula la media y la
% mediana utilizando funciones internas.
n = length(u);
media = mean(u,n);
mediana = median(u,n);
function a = mean(v,n) % Subfunción

% Calcula la media.
a = sum(v)/n;
function m = median(v,n) % Subfunción

% Calcula la mediana.
w = sort(v);
if rem(n,2) == 1
m = w((n+1)/2);
else
m = (w(n/2)+w(n/2+1))/2;
end

Javier Ramírez 36
Bifurcaciones
true
Condición 1
Bloque 1
false false false
Condición Condición
true
Condición 2
true true
Sentencias Bloque 1 Bloque 2 Bloque 2
false
Bloque 3

Javier Ramírez 37
if
Sentencia if Bifurcación multiple
if condición if condición1
sentencias bloque1
end elseif condición2
bloque2
elseif condición3
Ejemplo bloque3
else
if rem(a,2) == 0 bloque4
disp('a is par') end
b = a/2;
end

Javier Ramírez 38
switch
switch expresion
case case1,
bloque1
case {case2, case3, ...}
bloque2
...
otherwise,
bloque3 switch valor
end case -1
disp('negativo');
case 0
disp('cero');
case 1
disp('positivo');
otherwise
disp('otro');
end

Javier Ramírez 39
Bucles
false
Condición Sentencias
true
Sentencias Condición true
false

Javier Ramírez 40
for
for i = 1:n for i = vector

sentencias sentencias
end end
for i = n:-0.2:1 for i = 1:m

sentencias for j = 1:n
end sentencias
end
end

Javier Ramírez 41
while {continue, break}
while condición Sentencia break

sentencias
end Hace que termine
la ejecución
Sentencia continue
n = 1;
Hace que se pase
while prod(1:n) < 1e100
inmediatamente a la
n = n + 1;
siguiente iteración
end
del bucle for o while

Javier Ramírez 42
Toolboxes
 Toolboxes para DSP y comunicaciones:

 Communications Toolbox
 Filter Design Toolbox
 Image Processing Toolbox
 Signal Processing Toolbox
 Statistics Toolbox
 System Identification Toolbox
 Wavelet Toolbox

Javier Ramírez 43
Procesamiento de señales y comunicaciones
 Matlab dispone de unas librerías para

tratamiento digital de señales.
 Signal Processing Toolbox
 Communications Toolbox

Javier Ramírez 44
Filtrado de señales
 y= filter(b,a,x);
 Filtra la secuencia x con el filtro descrito por b y a.

Javier Ramírez 45
Respuesta en frecuencia
 [H,w] = freqz(b,a,N);
20
 Calcula N puntos de la
Magnitude (dB)
respuesta en frecuencia del 10
filtro definido por b y a. 0
-10
0 0.2 0.4 0.6 0.8 1
Normalized Frequency ( rad/sample)
 Para el filtro: 0
Phase (degrees)
y(n)= 0.8·y(n-1) + x(n) -20
-40
 freqz(1,[1 -0.8],256); -60

0 0.2 0.4 0.6 0.8 1
Normalized Frequency ( rad/sample)

Javier Ramírez 46
Diseño de filtros
 B = FIR1(N,Wn);
 Filtro FIR paso baja de orden N.
 Wn es la frecuencia de corte normalizada (0<Wn<1).
 B = FIR1(N,Wn,'high');
 Filtro paso alta.
 Wn = [W1 W2]; B = FIR1(N,Wn,'bandpass');

 Filtro paso banda.
 Wn = [W1 W2]; B = FIR1(N,Wn,'stop');

 Filtro rechaza banda (notch).

Javier Ramírez 47
Ejemplo: Filtros FIR paso banda
% Parametros.
N= [8 16 32 64]; % Coeficientes del filtro 0
Wn = [0.4 0.6]; % Frecuencias de corte. N=8
-20 N=16
NFFT= 256; % Respuesta en frecuencia
N=32
L = length(N);
|H|
-40 N=64
H = zeros(NFFT,L);
-60
for i=1:L
B = FIR1(N(i),Wn,'bandpass'); % Diseño.
[H1,W]= freqz(B,1,NFFT); % Respuesta. -80
0 0.2 0.4 0.6 0.8 1
H(:,i)= H1;
w en unidades de 
end
10
N=8
Fase de H (rads)
% Visualizacion de la respuesta en frecuencia.
subplot(2,1,1); 0 N=16
plot(W/pi,20*log10(abs(H))); N=32
xlabel('w en unidades de \pi'); -10 N=64
ylabel('|H|');
legend('N=8','N=16','N=32','N=64'); -20
grid;
subplot(2,1,2);
-30
0 0.2 0.4 0.6 0.8 1
plot(W/pi,unwrap(angle(H))); w en unidades de 
xlabel('w en unidades de \pi');
ylabel('Fase de H (rads)');
legend('N=8','N=16','N=32','N=64');
grid;

Javier Ramírez 48
Diseño y análisis de filtros (fdatool)

Javier Ramírez 49
Signal Processing Tool (SPTool)

Javier Ramírez 50

Javier Ramírez 51

Javier Ramírez 52

Javier Ramírez 53
Diezmado e interpolación
Señal original
2
1.5
 Y = DECIMATE(X,R) 0.5
-0.5
Ejemplo: Decimación en un factor 4.
-1
t = 0:.00025:1; % Vector de tiempos
-1.5
x = sin(2*pi*30*t) + sin(2*pi*60*t);
-2
0 20 40 60 80 100 120
y = decimate(x,4);
Señal decimada
2
1.5
stem(x(1:120)); %Original
1
axis([0 120 -2 2])
0.5
title('Señal original')
0
figure -0.5
stem(y(1:30)); %Decimada -1
title('Señal decimada') -1.5
-2
0 5 10 15 20 25 30

Javier Ramírez 54
Diezmado e interpolación
Señal original
2
1.5
 Y = INTERP(X,R) 1
0.5
-0.5
t = 0:0.001:1; % Time vector -1
x = sin(2*pi*30*t) + sin(2*pi*60*t); -1.5
y = interp(x,4); -2
0 5 10 15 20 25 30
stem(x(1:30)); Señal interpolada

2
title('Señal original'); 1.5
figure 1
stem(y(1:120)); 0.5
title('Señal interpolada'); 0
-0.5
-1
-1.5
-2
0 20 40 60 80 100 120

Javier Ramírez 55
Densidad de potencia espectral
 periodogram
Fs = 1000; t = 0:1/Fs:.3;
% Una señal coseno de 200Hz más ruido
x = cos(2*pi*t*200)+randn(size(t));
periodogram(x,[],'twosided',512,Fs);
% Se usa la ventana por defecto
 pwelch
Fs = 1000; t = 0:1/Fs:.296;
% Una señal coseno de 200 Hz más ruido
x = cos(2*pi*t*200)+randn(size(t));
pwelch(x,[],[],[],Fs,'twosided');
% Ventana por defecto, solapamiento y NFFT.

Javier Ramírez 56
Ejemplos
Periodogram PSD Estimate Welch PSD Estimate
-10 -16
-15 -18
-20
Power Spectral Density (dB/Hz)
-20

-22
-25
-24
-30
-26
-35
-28
-40
-30
-45
-32
-50 -34
0 100 200 300 400 500 600 700 800 900 0 100 200 300 400 500 600 700 800 900
Frequency (Hz) Frequency (Hz)

Javier Ramírez 57
Estimación espectral paramétrica
 Método de covarianza
pcov(X,ORDER,NFFT,Fs)
randn('state',1);
x = randn(100,1);
y = filter(1,[1 1/2 1/3 1/4 1/5],x);
pcov(y,4,[],1000);
 Método de covarianza modificado
pmcov(X,ORDER,NFFT,Fs)
randn('state',1);
x = randn(100,1);
y = filter(1,[1 1/2 1/3 1/4 1/5],x);
pmcov(y,4,[],1000);

Javier Ramírez 58
Ejemplos
Covariance PSD Estimate Modified Covariance PSD Estimate
-24 -24
-26 -26

-28 -28
-30 -30
-32 -32
-34 -34
-36 -36
-38 -38
0 100 200 300 400 500 0 100 200 300 400 500
Burg PSD Estimate Yule-Walker PSD Estimate

-24 -24
-26 -26

-28 -28
-30 -30
-32 -32
-34 -34
-36 -36
-38 -38
0 100 200 300 400 500 0 100 200 300 400 500

Javier Ramírez 59
Modelado. Predicción lineal
 Predictor lineal:
 Estima la muestra siguiente utilizando N muestras
anteriores.
xˆ (n) e(n)  x(n)  xˆ(n)
x(n) Predictor
lineal

N
xˆ (n)   A(i  1) x(n  i)
i 1
 [A,E] = LPC(X,N)
 Calcula:
Minimizando J= E{|e(n)|2}
 Los coeficientes del predictor, A.
 La varianza del error, E.

Javier Ramírez 60
Comunicaciones
 Funciones principales:
 Generación de señales aleatorias
 Análisis de errores
 Codificación de la fuente (escalar, diferencial)
 Codificación para el control de errores
(convolucional, codificación lineal de bloques)
 Modulación y demodulación (analógica y digital)
 Filtrado mediante filtros especiales
 Aritmética en cuerpos de Galois

Javier Ramírez 61
Modulación analógica y digital

Javier Ramírez 62
Funciones utilizadas frecuentemente
 randint
 Genera una matriz de números aleatorios enteros
uniformemente distribuidos.
 out = randint; % Un solo valor [0,1]
 out = randint(N); % Matriz cuadrada NN
 out = randint(M,N); % Matriz MN
 out = randint(M,N,rg); % Se especifica el rango.

Javier Ramírez 63
Modulación/demodulación digital

Javier Ramírez 64
Modulación/demodulación digital
 “Mapping”+modulación/demodulación
 dmodce/ddemodce
y = dmodce(x,Fd,Fs,'method/nomap'...);
y = dmodce(x,Fd,Fs,'ask',M);
y = dmodce(x,Fd,Fs,'fsk',M,tone);
y = dmodce(x,Fd,Fs,'msk');
y = dmodce(x,Fd,Fs,'psk',M);
y = dmodce(x,Fd,Fs,'qask',M);
y = dmodce(x,Fd,Fs,'qask/arb',inphase,quadr);
y = dmodce(x,Fd,Fs,'qask/cir',numsig,amp,phs);
y = dmodce(x,Fd,[Fs initphase],...);
 Sólo “mapping”
 modmap/demodmap
modmap('method',...);
y = modmap(x,Fd,Fs,'ask',M);
y = modmap(x,Fd,Fs,'fsk',M,tone);
y = modmap(x,Fd,Fs,'msk');
y = modmap(x,Fd,Fs,'psk',M);
y = modmap(x,Fd,Fs,'qask',M);
y = modmap(x,Fd,Fs,'qask/arb',inphase,quadr);
y = modmap(x,Fd,Fs,'qask/cir',numsig,amp,phs);

Javier Ramírez 65
Ejemplo
M = 16; % Modulación M-aria.
Fd = 1; % Se muestrea el mensaje original
% a una muestra por segundo.
Fs = 3; % La señal modulada se muestrea
% a una frecuencia de 3 muestras por segundo.
x = randint(100,1,M); % Mensaje digital aleatorio.
% Modulación M-ary PSK

y = dmodce(x,Fd,Fs,'psk',M);
% Adición de ruido Gaussiano.

ynoisy = y + .04*randn(300,1) + .04*j*randn(300,1);
% Diagrama de dispersión a partir de las observaciones ruidosas.

scatterplot(ynoisy,1,0,'b.');
% Demodulación para recuperar el mensaje

z = ddemodce(ynoisy,Fd,Fs,'psk',M);
s = symerr(x,z) % Comprobar la tasa de error de los símbolos.

Javier Ramírez 66
Gráfico de dispersión (ruido)
Scatter plot
0.8
0.6
0.4
0.2
Quadrature
-0.2
-0.4
-0.6
-0.8
-1
-1 -0.5 0 0.5 1
In-Phase

Javier Ramírez 67
Análisis de errores
 biterr
 Calcula el número de bits erróneos y la tasa de error.
[number,ratio] = biterr(x,y);
[number,ratio] = biterr(x,y,k);
[number,ratio] = biterr(...,flg);
[number,ratio,individual] = biterr(...)

Javier Ramírez 68
Ejemplo
x = randint(100,100,4); % Señal original
% Introducción de errores.
% Los errores pueden ser 1, 2, o 3 (no 0).
% Colocación de los errores
errorplace = (rand(100,100) > .9);
errorvalue = randint(100,100,[1,3]); % Valor error
errors = errorplace.*errorvalue;
y = rem(x+errors,4); % Señal y error sumadas mod 4
% Análisis de errores
format short
[num_bit,ratio_bit] = biterr(x,y,2)
[num_sym,ratio_sym] = symerr(x,y)

Javier Ramírez 69
Ejercicio:
 Estudiar mediante Matlab/Simulink el efecto

del ruido en los sistemas de comunicación
digital.
 Construir el diagrama de bloques de simulación.
 Simular el sistema:
 Diferentes esquemas de modulación (ASK, PSK, FSK,
MSK).
 Obtener las curvas de error en función de la SNR.
 Adicionalmente, considérese PSK con M= 4 y 8
símbolos y compárese las curvas de error frente a la
SNR.

Javier Ramírez 70
Introducción a Simulink
 Simulink es una herramienta para modelado,

simulación y análisis de sistemas dinámicos.
 Soporta tanto sistemas lineales como no
lineales:
 en tiempo continuo,
 muestreados,
 híbridos y
 sistemas multifrecuencia (contienen sistemas
muestreados a diferente frecuencia).

Javier Ramírez 71
Entorno de trabajo

Javier Ramírez 72
Construcción del diagrama de bloques

Javier Ramírez 73
Resultado de la simulación
1
0.5
-0.5
-1
0 500 1000 1500 2000 2500 3000
0.5
-0.5
-1
0 0.5 1 1.5 2 2.5 3
4
x 10

Javier Ramírez 74
Ejemplo

Javier Ramírez 75
Simulación

Javier Ramírez 76
Análisis/síntesis LPC de la señal de voz

Javier Ramírez 77
Estimación espectral

Javier Ramírez 78
Resultado de la simulación

Javier Ramírez 79
Sistema de comunicación digital
8-PSK (Gray)

Javier Ramírez 80
Procesado de imágenes
 Lectura de imágenes:
 A = imread(filename, fmt)
 Lee una imagen en escala de grises o en color
 fmt especifica el formato de imagen (BMP, JPEG, PNG, TIFF, etc)
 [X, map] = imread(...)
 map Mapa de color
 Visualización de la imagen imshow

 imshow(I)
 imshow(I,[low high])
 imshow(RGB)
 imshow(BW)
 imshow(X,map)

Javier Ramírez 81
Lectura de imágenes
 A= imread('texto.tif');  [B map]=
 imshow(A); imread('flor.tif');
 size(A); size(A);  imshow(B); size(A);
500500 5005003

Javier Ramírez 82
Transformaciones espaciales
 Modificación del tamaño

 B = imresize(A, scale)
 B = imresize(A, [mrows ncols])
 Rotar una imagen

 B = imrotate(A,angle)
 B = imrotate(A,angle,method)
 method -> Interpolación {‘nearest’}, ‘bilinear’, ‘bicubic’
 B = imrotate(A,angle,method,bbox)
 bbox -> Bounding box {‘crop’} ‘loose’
 Recortar una imagen

 B= imcrop(A); Herramienta interactiva
 B= imcrop(A,rect);

Javier Ramírez 83
Filtrado 2D
 B= imfilter(A,h)  N= 5;
 h = ones(N,N) / (N*N);
 Af = imfilter(A,h);
Original Filtrada N= 5 Filtrada N= 20

Javier Ramírez 84
Respuesta en frecuencia de filtros 2D
 [H, f1, f2] = freqz2(h, n1, n2)
 [H, f1, f2] = freqz2(h, [n2 n1])
 [H, f1, f2] = freqz2(h)
 [H, f1, f2] = freqz2(h, f1, f2)
1
1
0.8
0.8
0.6
Magnitude
0.6
Magnitude
0.4
0.4
0.2
0.2
0
0
1
1
0.5 1
0.5 1
0 0.5
0 0.5
0
0 -0.5
-0.5 -0.5
-0.5
-1 -1
Fy -1 -1
Fx Filtro 55 Fy Fx Filtro 2020

Javier Ramírez 85
Diseño de filtros 2D 1
0.8
0.6
 h = fwind1(Hd, win) 0.4
 h = fwind1(Hd, win1, win2) 0.2
 h = fwind1(f1, f2, Hd,...) 0

1
0.5 1
0 0.5
 Ejemplo: -0.5
0
-0.5
 [f1,f2] = freqspace(21,'meshgrid'); 1.5 -1 -1
 Hd = ones(21);
 r = sqrt(f1.^2 + f2.^2);
 Hd((r<0.1)|(r>0.5)) = 0; 1
Magnitude
 colormap(jet(64));
 mesh(f1,f2,Hd);
0.5
 h = fwind1(Hd,hamming(21));
0
 freqz2(h); 1
0.5 1
0 0.5
0
-0.5 -0.5
Fy -1 -1
Fx

Javier Ramírez 86
Ajuste del nivel de intensidad
6000 15000 4000
3000
4000 10000
2000
2000 5000
1000
0 0 0
0 100 200 0 100 200 0 100 200

Javier Ramírez 87
Ecualización del histograma
250 250 250
200 200 200
150 150 150
100 100 100
50 50 50
0 0 0
0 100 200 0 100 200 0 100 200

Javier Ramírez 88
Ecualización del histograma
6000 15000 4000
4000 10000
2000
2000 5000
0 0 0
0 50 100 150 200 250 0 50 100 150 200 0 50 100 150 200 250
200 200 200
100 100 100
0 0 0
0 50 100 150 200 250 0 50 100 150 200 250 0 50 100 150 200 250
15000
2000 2000
10000
1000 1000
5000
0 0 0
0 50 100 150 200 250 0 50 100 150 200 250 0 50 100 150 200 250

Javier Ramírez 89
Filtrado de ruido (Filtro de Wiener)
 J = wiener2(I, [m n], noise)
 [J, noise] = wiener2(I, [m n])
 Wiener2 estima la media y la varianza entorno a cada pixel
 A continuación crea un filtro pixel a pixel basado en estas estimaciones
v2 es la varianza del ruido

Javier Ramírez 90
Matlab para reconocimiento de patrones
 Asignación de una clase a un vector de

características x del objeto a clasificar:
 Ejemplo: Fisher Iris dataset:
 http://en.wikipedia.org/wiki/Iris_flower_data_set
 503 = 150 muestras de flores Iris de tres especies
 Iris setosa, Iris virginica, Iris versicolor
 4 características de cada ejemplo:
 Longitud y anchura de los pétalos y sépalos

Javier Ramírez 91
Matlab para reconocimiento de patrones
 Análisis discriminante:
 class = classify(sample,training,group)
 class = classify(sample,training,group,type)
 class = classify(sample,training,group,type,prior)
 knn:
 Class = knnclassify(Sample, Training, Group)
 Class = knnclassify(Sample, Training, Group, k)
 Class = knnclassify(Sample, Training, Group, k, distance)
 Class = knnclassify(Sample, Training, Group, k, distance, rule)
 Máquinas de vectores de soporte:

 Group = svmclassify(SVMStruct, Sample)
 Group = svmclassify(SVMStruct, Sample, 'Showplot‘,ShowplotValue)
 SVMStruct = svmtrain(Training, Group)
 SVMStruct =svmtrain(..., 'Kernel_Function', Kernel_FunctionValue)

Javier Ramírez 92
Análisis discriminante: Ejemplo 3.8
Fisher versicolor
3.6 Fisher virginica
 load fisheriris 3.4
 SL = meas(51:end,1); 3.2
 SW = meas(51:end,2);
3
 group = species(51:end);
SW
2.8
2.6
2.4
2.2
2
4.5 5 5.5 6 6.5 7 7.5 8
SL
 h1 = gscatter(SL,SW,group,'rb','v^',[],'off');
 set(h1,'LineWidth',2)
 legend('Fisher versicolor','Fisher virginica','Location','NW')

Javier Ramírez 93
Análisis discriminante: Ejemplo
 Clasificamos una  Visualizar la

matriz de datos 2-D: clasificación:
hold on;
[X,Y] = gscatter(X,Y,C,'rb','.',1,'off');
meshgrid(linspace(4.5,8) K = coeff(1,2).const;
,linspace(2,4)); L = coeff(1,2).linear;
Q = coeff(1,2).quadratic;
X = X(:); Y = Y(:); f = sprintf('0 =
%g+%g*x+%g*y+%g*x^2+%g*x.*y+%g*y.^2',
[C,err,P,logp,coeff] = ...
classify([X Y],[SL SW], K,L,Q(1,1),Q(1,2)+Q(2,1),Q(2,2));
h2 = ezplot(f,[4.5 8 2 4]);
group,'quadratic'); set(h2,'Color','m','LineWidth',2)
axis([4.5 8 2 4])
xlabel('Sepal Length')
ylabel('Sepal Width')
title('{\bf Classification with Fisher
Training Data}')

Javier Ramírez 94
Análisis discriminante: Ejemplo
Classification with Fisher Training Data
4
Fisher versicolor
Fisher virginica
3.8
3.6
3.4
3.2
SW
2.8
2.6
2.4
2.2
2
4.5 5 5.5 6 6.5 7 7.5 8
SL

Javier Ramírez 95
Selección de características
 [IDX, Z]= rankfeatures(X, Group)
 [IDX, Z]= rankfeatures(X, Group,'Criterion', CriterionValue)
load fisheriris;
X= meas(1:100,:);
Group= species(1:100);
[IDX, Z] = rankfeatures(X',Group);
% Selecionamos las variables más discriminativas

data= X(:,[IDX(1) IDX(2)]);
% Selección aleatoria de subconjuntos de entrenamiento y test

[train, test] = crossvalind('holdOut',Group);
cp = classperf(Group);
% Entrenamiento de una máquina de vectores de soporte
svmStruct = svmtrain(data(train,:),Group(train),'showplot',true);
% Añadimos título.
title(sprintf('Kernel Function: %s',...
func2str(svmStruct.KernelFunction)),...
'interpreter','none');
% Clasificación del conjunto de test
classes = svmclassify(svmStruct,data(test,:),'showplot',true);
% Evaluación a partir de la tasa de correctas.
classperf(cp,classes,test);
cp.CorrectRate

Javier Ramírez 96
Selección de características
Kernel Function: linear_kernel Kernel Function: linear_kernel
1.8 4.5
setosa (training)
setosa (training) setosa (classified)
1.6 versicolor (training)
setosa (classified)
versicolor (training) versicolor (classified)
versicolor (classified) 4 Support Vectors
1.4
Support Vectors
1.2
3.5
1
0.8
3
0.6
0.4
2.5
0.2
0 2
1 1.5 2 2.5 3 3.5 4 4.5 5 5.5 4 4.5 5 5.5 6 6.5 7
data= X(:,[IDX(1) IDX(2)]); data= X(:,[IDX(3) IDX(4)]);

Javier Ramírez 97
Estas transparencias se pueden obtener en:
http://www.ugr.es/~javierrp
Para cualquier consulta:
Javier Ramírez (javierrp@ugr.es)

Dpto. Teoría de la Señal, Telemática y Comunicaciones
Despacho 22
ETSII

Javier Ramírez 98
! "
#
$ %
!" "# $% "
!
" #
$ #
& '" $
%
% $ &
' $
$
(
)
(( ) * (( * , +
(( ) + )
(( ) , -
)
-
* + #
& )
(( ((
) )
- -
%
./ ./ , %
" /
- $ / ./ . /
0 1 -" $ 0 1 #
.
$
)
(( 2 ) 3! * + (( % ; ) 3! * +9
4-5 (( % ; ) 3!$*$+9
6 7 89 (( % ) 3!$*$+9< -< .
(( 2 ) 3!$*$+:4$-$5:6$7$89 (( % ) 3!:*:+9
*" # = "
(( ) * , +>= ?( *$+ * +
(( ) @ A ?(
(( ) @ A ?(
(( ) > !7B C ?(
& ' 2 2 2$2 2 2 2 2 2 2 2 2
3 # # 4
+" D "
(( ) 3! ?5 B ?*69 56 758 959:

(( ) @ A 56 &
(( ) @ A 56
% ) - .; - .< - .= - .> - .; - .? - .> - .
(( ) 3! * +9 56 9?9 ?7
(( ) 34 - 59 56 @ 9?A ?8
(( ) %@ $ A
)
4 !+ *7 *6 !7 56 ; @ @?B7 7?9C 9?9: ?BC
(( 30$ 9 ) %@ $ A 56 -. -.
0)
4-5 56 - .
)
BBBBB 56 - .
,
' %
/ - $ / %.
4" ; *E +E"
( ) ( 7D)
(( ) 3B'!'!BB9 56 (( ) 3B'!'!BB9 56
(( 1 ) 56 $ (( 1 ) 56 $
(( ) @B"!> A 56 $ (( ) @B"!> A 56 $
(( @1$ A (( 2 ) @B"*> A 56 $
(( +@1$ $2A
( )
(( ) 3B'!'!BB9
(( 1 )
(( ) 3 @B"!> A : @B"!> A9
(( @1$ A
-" F ; "
/ $
)
(( ) 3! *9 56 ?9
(( ) 3! + -9 56 9?7 ?A
(( @ $ A 56
@ ,*AC@ G*,+ ,-A
(( 2 @ $ A 56
(( 3 $29 ) 2 @ $ A 56 * + * +
(( 2 @ $2A 56
/ )
(( . ) +B 56
(( 1 ) B"+ 56
(( 3 *$ *9 ) *@. $1 A 56
(( @ *$ *A 56
!C@ G*,!7 ,8BBA
" ! G
AE $ $ )
F
H 66 ) ;@I IA 56 $ *+
(( ) @ ,*AC@ G*,+> ,-A
(( ) ;@3! *9$ 3! + -9A 56 * + @ ,*AC@ G*,+ ,-A
@ ,*AC@ G*,+ ,-A (( * ) >
" $ F
& ' > )
(( ) 3! *9 56 ?9 " )
(( ) 3! + -9 56 9?7 ?A (( ) ;@3! *9$ 3! + -9A 56 ;@ ,*AC@ G*,+ ,-A
(( 2 @ $ A (( 2 @ A
H I > J I J I J I > J)
(( ) ;@ $ A K )
(( 3 $29 ) 2 @ A (( ) ;@ $ A
(( ) @ > ;@ @ A$ @2AAA> @2A (( ) @ " J'KA
(( ) @ A (( ) @ " J'KA
(( ); L@ $!$?!A 56
*B+ 25B2
5" "
(( @ A 56
(( @ A 56
L
(( 3 $1$ 9 ) @ A 56 2 2 2 2
22
(( 1 ) 1@ A 56
6" ; "
(( @ A 56 $
(( 3 $; 9 ) @ $+A 56 - .
- . ;7
(( 3 $; $.9 ) @ A 56
$ )
(( 1 ) 1@ A 56
(( ) *B> !B@ 1 A 56
(( 3M $D $. $. 9 ) @ A 56 MMM ( N OOO
M ) P
D )
. )Q Q -Q Q ; Q Q .
. )Q Q
(( ! ) !BC@@ ,!A>@ ,*A>@ ,+AA 56 F * +

(( 3M !$D !$. !$. !9 ) @ !A
M !) 56 - .
D !) 56
. !) 56 - >.
. !) 56 - >.
(( @ !A 56
(( / @ A 56 5
(( @I .IA 56 Q
(( / 56
(( ; 56 - 2 2.
(( / 56
(( / ;; 56
(( 0 @ A 56 Q "
6E *D / +
(( % .@ A 56 $
7" N "
(( @ A 56 &
(( ) @ $ $+A 56 2R;72
(( / 56 $ $
(( @ $ $3+ 49A 56 $ & - .
2R;72 2R;@2
(( 56 N (
(( 56 N ' * +
& ' - . #
O
!" L"
% R
N - .
$
/ $
&
" $ $ % R
N
"
" % R 2% R ! 1 2 -!
% R . &
)
66 R
L $
.) $
$
%
' '
&
' #
% (
% R- .)
) $
"
$ /
& % R
% R
% R)
' 0 0 1) / $ N
; " # & - .
E % % ) $ / )
#
)
E 1) /
& &
& / ) #
; F )/ E ) D
$ % $
# $
E ) E )
$ D %
P ?D )F E S ),
'
D %
/' 0 0 2 L' R "

" E )( '
), )(
M )
/ F ) " S L )S N
& $ %
' N
D ) , L F )S 2 2
# N
) D
) , ?B 5B E
E
) , L 'F R "
# / S N
"$ )
2??5?2 & @ L)
)/ N
F ) " F S L ) /
' & $
' 0 " N N
E P )P F F )/ 2 2
" $
' D M ) S
) ;B
;E -
$ " & .
) N )S N
) S #
. /) L #
M ) % N
Q ' = R "
)/ $ S % )S
)S N
; ) S #
!) / / #
N
& !) / /
N
*" "
/
% )
+ '
' -
1
% *
' ,
0
/ ! &#
' #
) '
B. % )/
2 2
9. 0 )%
# "
2 2- .
7. 0 ) /
$
@. 0 )"
2T62
26T2 %
&
A. ; )%
/
&
8. ; 0 )% & #
> '
' #
2F 2 # -2F UF ! R2 2F U(
! R2 . ' #
:. 1 ) %
'
'
/
2 2 2 2 #
, -2F U% 2.
$
L $ & ) 2% RU% U%
0 2 2% RU% R U% 2 2% R ! 1 2
$ " $
N
+ ) % !
1
- 0
2%
+" % 2 "
$
@!A D #) 2% U/ 2
-K
'
> > $ .
# @*A
/ #
2% R 2 % R D # 2% 2
' @+A /
@4A
- .
N $ 2V2
$ 2H2
" 2% 2 '
2% 2 @-A D # #
@5A 2Q 2- ' #
.
# @6A 2 1 2 ( #
2 2
% N )
. #
!. L 2 2 N
OTO D & !
%
N % R )
V- . H- .
C
-. - . 9
@X W -.
D
)
(( ) ;@379$ 3! 4 89A
)7C@ G*,4 ,8A
(( @ A
(( @ A
, % R
& $
L $
*% +
OTO D & *
% $
% R
) -. ,
-.
- .; - .? - . F ( -. (
- .;(X 9- . ,
- .;,X - .> -.
-. -.
- .;- - .5 - ..>(
% R
- * +. $
-
# # . $
$
) Y Y
* +, +,* - . *
/
!) 0
* #) '
+ '!
'!
8 9
0 ! '#
8 8 *
* : 7
23 1
!)! ) 0 +
! " 4 5 6
# $ %$ & '(# (
! (#) '& (
# - 1
'
% R $ *F +- F .
)
Z - .;Z - .?Z - .
Z - .;9X(XP XP- .
Z - .;,X X - .
Z - .;- - .5 - ..>(
) Y
* +, +,* - . *
/
)!) )
+ #) )
* + '!
!
:
;!;
#
*
* : : 9
23 1
!)! ) 0 +
! " 4
# $ %$ & '(# ( 5 6
! (#) '& (
# - 1
3+5
3+4.5 ++5
6.5 6.5
OTO D & +
L N
% R ! N
N
/
, ,
% ? %
Y
) Y Y Y
7 5
* +, +,* - . *
/
)!) )
+ #) )
+ '!
# !
! 7 5
!
/ / / ; = ;!;
/1 #
=) / / ' ) /1 23 1
= > !)! ) 0 +
! " 4
1 9 # $ %$ & '(# ( 5 6
! (#) '& (
# - 1
! <
%
/ $
" $
&
-. BE " $
*% +
) Y Y Y Y
7 5
* +, +,* - . *
/
!) 0
#) '
+ '!
'!
> #
! 7 5
/ / / ;
= 0 ! '#
/1
*
=) / / ' ) /1 23 1 >
= > !)! ) 0 +
! "
# $ %$ & '(# 4 5 6
1 9 (
! (#) '&
(
# - 1
! <
- .
++5
*
OTO & !' # 2
, & !,D"FS[ #
DQP $ )
!"# $
%"&'
$ ( ) * " # (!" # )!"# *
/ $ )
!"#
%"&'
$ ( ) * "# !" # !"#
P )
-P 0 L 2
U =
2 ; A
B Q DQP
9 S- .
7 S- .
@ ( - .
@B D $
@9
@7 \ ('
A ( - % R.
AB D $
A9
A7 \ ('
OTO & *'
!
@
?
=
5
A
B
" )
5L ,, -.
-. ]
5L ,, )( ]
]
5 " $ 5 $ D ^
!- . " $ -.
) " )
- . ; ]X - . L - . ; ]XL - .
- . ; ( X - . ? X - .> ? - . L - . ; ( XP - . ? X XP - . ? L - .
- . ; ] X1- . L - . ; ] X0- .
-.;] X -. / - . ; ] XP - .
- . ; - . ? ^X 1- .> ? !X1- . / - . ; / - . ? ^X X0- . ? !X0- .
K &
DQP )
9: 43;:
$ ( ) * $ ( ) *
+' # +' # '

+' , -.,"/ 012 +' , ' -.,"/ 012
+3' # , - ,4/ 2 +3' # , ' - ,4/ 2
5' - 2 5' ' - 2
6' # ,% # & -*2 6' # ,% # &' -*2
7' # -+8,4 2 7' # ' -+8,4 2
' % , & -+8,4 /"2 ' % , &' -+8,4 /"2
, % R -. -.
1- .
P )
-D $ 0 L 2
U = 2 ;
A
B Q DQP
9 D $
7 \ , -] ] .
@ % L -.
@B K '
@9 D
A N
@ '
AB D $
A9 K '
8 % L -. 1;B >
A -( A.
8B D $ '
89 K '
87 K '
OTO & +' O ;
, & !,D"FS[ #
DQP $ )
!"# $
%"&'
$ ( ) * " # (!" # )!"# *
/ $ )
!"#
%"&'
$ ( ) * "# !" # !"#
P )
-P 2
U = 2 ; A
B Q DQP
9 P S- .
7 K S- .
@ D $ ! - . - .
;A > S- .
A K - .
S- . -4 "Q,PKQ3 /
! P .
8 M, * +O
: K -. S- .
];B
-.
V- . ? H- .
] S- .
Y
C K -. ]; A
W K
S- . -" .
OTO & 4' E R
% N $ 9
B EEE $
;E B
% ) -K $ 9.
/- .
Y
L-. ]X] X ?( 0- .
?
SB- .; S9- .;
X ?( ^X X 9?-!X ?^X( .X ?-( X!?] X] .
" )
) _E@ % ) _ A`
'
" -. '
% )
/- .
Y
\- . ? L- . ]X] X ?( 0- .
?
(- . SB- .; S9- .;
X ?( ^X X 9?-!X ?^X( .X ?-( X!?] X] .
Y
]
[- .;
X ?B
P )
-D $ 0 L 2
U = 2 ;
A
B Q DQP
9 \ , -] ] .
7 ( N L
N )
_E9 WEa
_B %
@ D $ % R
A % -.
AB K
A9 K
A7 K 1- . '
8 % 9 EEE -.
' $
SIMULINK – MATLAB
CONTENIDO
1. ELEMENTOS BÁSICOS
2. EL MOTOR DC
3. SUBSISTEMAS
4. ECUACIONES DIFERENCIALES
5. SIMULACIÓN DE SISTEMAS
INTRODUCCIÓN
Simulink es una extensión de Matlab utilizado en el modelamiento y simulación de

sistemas. Para arrancar Simulink se puede hacer desde el prompt de Matlab
digitando el comando >>Simulink o utilizando el icono . Se abre la ventana

Simulink Library Browser como se indica abajo y se puede diagramar un nuevo
modelo activando el botón New Model , o sea el icono o de
1
Un modelo es un conjunto de bloques que representa un sistema y como archivo
tiene extensión *.mdl
1. ELEMENTOS BÁSICOS
Los elementos básicos son líneas y bloques. Los bloques están agrupados en:
Sources, Links, Discrete, Continuos, Math, etc., tal como aparecen en la ventana
anterior. Cada bloque tiene entradas y salida para realizar su interconexión. Por
ejemplo, haga clic en Discrete y luego clic en Discrete Transfer Fcn y arrastre el
bloque a la ventana en blanco. Si quiere modificar la función de transferencia del
bloque haga doble clic en él y digite los coeficientes del numerador y denominador
en la nueva ventana que aparece. Para la función 1/(z 2 +2z +4) con tiempo de
muestreo de 1 seg, quedaría:
Para realizar el diagrama en bloques de un sistema se hace lo siguiente:
2
Lo primero es arrastrar los bloques a la página en blanco de forma que, Step es
la función paso o escalón que se obtiene de Sources, Scope es el osciloscopio
que se obtiene de Sinks, Transfer Fcn se obtiene de Continuos, Sum y Gain se
obtienen de Math. Modifique los bloques dando doble clic sobre cada uno de ellos
para cambiar sus parámetros o valores e interconéctelos.
Lo segundo es cambiar los nombres a los bloques y asignar las variables o

señales haciendo doble clic en el lugar en que se van a colocar y salvar el modelo
especificándole un nombre, por ejemplo ejem1.mdl
Por último se debe simular el sistema. Para ello se configura la señal de entrada,
en este caso la función paso. Dar doble clic y asignar los siguientes parámetros:
Step time=0, Inicial value=0, Final value=1, Sample time=0. Para simular el
sistema de control se escoge del menú o el icono .y luego

se hace doble clic en Scope para ver su respuesta o salida del sistema. Para
observar además la entrada se puede colocar otro Scope a la salida de Step y se
puede probar para varios pasos variando su amplitud, tiempo de inicio y tiempo de
3
iniciación del paso. Para observar mejor la respuesta se usa el botón Autoscale
(binoculares ) de la ventana del Scope. Si quiere observar mejor la

respuesta o parte de ella se pueden cambiar los parámetros de simulación,
Simulation Simulation parameters. Por ejemplo cambiar el Start time y el Stop
time y correr nuevamente la simulación.
2. EJEMPLO: MODELAR UN MOTOR DC
Un actuador común en sistemas de control es el motor DC. Provee directamente

movimiento rotatorio y acoplado con poleas o correas puede proveer movimiento
transnacional.
2.1 ECUACIONES DINÁMICAS
El circuito eléctrico de la armadura y el diagrama de cuerpo libre del rotor es

mostrado en la figura con sus ecuaciones dinámicas.
4
(1) Leyes de Newton
(2) Leyes de Kirchhoffs
Los parámetros físicos tienen los siguiente valores :
Momento de inercia del rotor : J = 0.01kg.m2/sg2

Rata de amortiguamiento del sistema mecánico: b = 0.1 N.m.sg
Constante de la fuerza electromotriz: Ke = Kt = 0.01 Nm/Amp
Resistencia eléctrica: R = 1 ohm
Inductancia eléctrica: L =0.5H
Fuente de voltaje de entrada: V
Posición angular: θ
Se asume que el rotor y el eje son rígidos
5
2.2 MODELADO DEL MOTOR EN VELOCIDAD
2.3 EXTRAER MODELO LINEAL
Para obtener la función de transferencia del motor primero se trasladan los

parámetros del motor al modelo creando un archivo en Matlab (*.m) de la siguiente
forma:
% VALORES DE LOS PARÁMETROS DEL MOTOR

J = 0.01;
b = 0.1;
Ke = 0.01;
6
Kt = 0.01;
R = 1;
L = 0.5;
Se ejecuta este archivo y se simula el modelo para una entrada de paso unitario
de valor V = 0.01, con los siguientes parámetros de simulación: Stop time = 3 sg.
Arranque la simulación y observe la salida (velocidad del motor).
Como segundo paso se debe obtener el modelo lineal de Matlab del motor. Para
esto, borre el bloque Scope y cámbielo por Out obtenido de la librería de
Signals&Systems. Haga lo mismo para Step cambiándolo por In de esta misma
librería. Los bloques In y Out definen la entrada y salida del sistema que le
gustaría extraer. Salve este modelo. El sistema quedará así:
Como tercero y último paso, después de desarrollado el modelo y salvarlo por

ejemplo con el nombre MotorDcVel.mdl se ejecutan los siguientes comandos:
7
% OBTENER EL MODELO LINEAL DEL SISTEMA
[num, den] = linmod('MotorDcVel')
Gps = tf(num, den)
La respuesta es :
3. SUBSISTEMAS
Abra una nueva ventana y arrastre de la librería Signals&Systems el bloque

SubSystem , haga doble clic en este bloque, abra el modelo MotorDcVel.mdl (el
que tiene In y Out como terminales) cópielo y péguelo en la nueva ventana de
subsistema anterior. Cierre ventanas y aparece una nueva con el bloque con los
terminales del subsistema creado. Déle el nombre MotorDcVel. Si a este bloque
de subsistema se le da doble clic aparece el modelo completo diseñado
anteriormente. Otra forma es señalar los bloques de interés, ir a menú Edit -->
create Subsytem
3.1 SISTEMA EN LAZO ABIERTO
Al subsistema creado que constituye la planta de un sistema de control se le va a

adicionar un controlador y obtendremos la función de transferencia en lazo abierto
y lazo cerrado.
8
% CONTROL DE UN MOTOR DC
[num, den]=linmod('ControlMotor')
Glazo_abierto = tf(num, den)
Respuesta:
3.2 SISTEMA EN LAZO CERRADO
% CONTROL DE UN MOTOR DC
[num, den]=linmod('ControlMotor')
Glazo_cerrado= tf(num, den)
Respuesta:
9
3.3 SISTEMA DISCRETO
DIAGRAMA EN SIMULINK
PROGRAMA MATLAB
% SISTEMA DISCRETO DISCRETO

T=0.1;
[num,den]=dlinmod('MotorDigital',T)
Glazo_cerradoz=tf(num,den,T)
Respuesta:
10
4. SOLUCIÓN DE ECUACIONES DIFERENCIALES
Ejemplo:
Resolver la siguiente ecuación diferencial:
d2y dy
2
 3  6 y  4t  y' '3 y'6 y  4t  y' '  4t  3 y '6 y
dt dt
Diagrama Simulink:
Respuestas:
11
Ejemplo:
Comprobar la integración por Simulink.
12
5. SIMULACIÓN DE SISTEMAS
5.1 INTERCAMBIO DE MATLAB A SIMULINK
Para utilizar señale de Matlab a Simulink de la librerís Sources se utiliza el bloque

From Workspace.
13
Ejemplo: Resolver la ecuación y’’ + y = e t, y’(0) = 0, y(0) =3
El vector [ t x ] se ejecuta en Matlab en el workspace de la siguiente forma:
>> t = 0:0.001:0.999;
>> t = t’;
>> x = exp(t)
Al ejecutarse Simulink toma los datos entregados por Matlab. No olvidar colocar
condición inicial y(0) = 3 en el integrador.
5.2 INTERCAMBIO DE SIMULINK A MATLAB
Para enviar datos de Simulink a Matlab se utiliza de la librería Sinks el bloque To

Workspace.
Ejemplo:
Resolver la ecuación: f(t) = Mx’’ + Bx’ + Kx, M=1, B=1, K= 10, F(t) = 5
14
Diagrama Simulink:
En Matlab:
>> plot(t,y)
5.3 EJERCICIOS
Ejercicio1:
15
Si la entrada es una señal senoidal, encontrar las salidas referidas a vC y iL.
Ejercicio2:
Para el siguiente problema hallar la variación de h si el caudal normal Q es de 10

lit/min y en t=5 seg se aplica una perturbación de 2 lit/min. El valor de K=10, A= 2
m2.
dh
A  q(t )  K h
dt
Diagrama Simulink:
16
EJERCICIO3: LA BOLA MAGNÉTICA
Ecuaciones:
d 2h i 2 di
(1) m  mg  (2) L  V  iR
dt 2 h dt
Valores:
m=0.1 Kg; g=9.81; R=2 Ohm; L=0.02 H; =0.001
Diagrama simulink:
17
Controlador:
zeros=[-11.5+7.9i, -11.5-7.9i]
polos=[0 -1000]
ganancia=-3.3057e+004
Planta:
i(0) = 0; h(0)=0.05; h’(0)=0
18
19
EJERCICIO4: TANQUE DE AGUA
Ecuación del modelo:
dVol dh
A  bV  a h
dt dt
Diagrama simulink:
20
Controlador:
Planta:
EJERCICIO5: MOVIMIENTO PARABÓLICO
21
Ecuaciones:
x' '  0 Movimiento unforme

y ' '   g Movimiento acelerado
Condiciones iniciales:
Vo=100 m/sg;  = 30º
22
23
EJERCICIO6: PÉNDULO SIMPLE
Ecuación:
mL ' ' BL 'wsen  0
Valores:
w (peso) = 2; L (longitud) = 0.6; B (amortiguación) = 0.08;
Condiciones iniciales: ’(0) = -2 rad/sg; (0) =  /2
24
Diagrama simulink:
25
EJEMPLO: SISTEMA MECANICO
Parámetros:
m1=40; m2=60; k1=400; k2=400; b1=180; b2=220;
Ecuaciones dinámicas:
dv1
f (t )  m1  k1 (v1  v2)dt  (v1  v2)b1
dt
dv2
0  m2  k1 (v2  v1)dt  (v2  v1)b1  k 2 v2dt  b2v2
dt
Ecuaciones de Laplace:
K1
F ( s)  m1sV1  (V 1  V 2)  (V 1  V 2)b1
s
k1 k2
0  m2sV 2  (V 2  V 1)  (V 2  V 1)b1  V 2  b2V 2
s s
26
Diagrama simulink:
EJEMPLO: SISTEMA TERMOQUÍMICO
Se desarrolla una reacción termoquímica en donde el reaccionante A se convierte

en un producto B.
Velocidad de reacción: r(t)= k c(t)

Constante de velocidad de reacción: k = 0,2 min -1
27
Concentración de la entrada: ci(t)
Para t= 0; ci(0)=1.25 lbmol/pie3
Volumen de la masa reaccionante: V= 5 litros
Flujo de entrada: F= 1 lt/min
Ecuación dinámica:
dc(t )
V  Fci (t )  Fc (t )  KVc (t )
dt
dc(t )
V  Fci (t )  ( F  KV )c(t )
dt
V dc(t ) F
 c(t )  ci (t )
F  KV dt F  KV
Constante de tiempo:
V
 
F  KV
Ganancia de estado estacionario:
F
Ke 
F  KV
Reemplazando valores:  = 2.5 min; Ke = 0.5;

Condición inicial de la concentración: c(0)
0 = Fci(0) - Fc(0) - KVc(0)
Reemplazando valores: c(0) = 0.625 lbmol/pie 3
28
Programa en Matlab:
%Entrada al paso. Programa pplineal.m

function dy=pplineal(t,y)
global K X tau
dy=(K*X-y)/tau;
% Entrada rampa. Programa rplineal.m

function dy=rplineal(t,y)
global K r tau
dy=(K*r*t-y)/tau;
% Entrada senoidal. Programa splineal.m

function dy=splineal(t,y)
global K tau A w
dy=(K*A*sin(w*t)-y)/tau;
% Programa principal
F=1;
V=5;
K=0.2;
ci0=1.25;
c0=solve('F*ci0-F*c0-K*V*c0=0');
c0=eval(c0)
%Constante de tiempo
tau=V/(F+K*V)
% tau=2.5 minutos
%Ganancia en estado estacionario
Ke=F/(F+K*V)
% Ke=0.5
29
global R K tau X r A w Rango Inicio
Rango=input('Tiempo de simulacion=');
Inicio=input('Condiciones iniciales=');
N=input('ESCRIBA 1=PASO, 2=RAMPA, 3=SENO: ');
disp(' ')
switch N
case 1
X=input('Valor del paso=');
[t,y]=ode45('pplineal',Rango,Inicio);
plot(t,y)
case 2
r=input('valor pendiente de la rampa=');
[t,y]=ode45('rplineal',Rango,Inicio);
plot(t,r*t,t,y/K,'r')
case 3
A=input('Amplitud del seno=');
w=input('Frecuencia del seno=');
[t,y]=ode45('splineal',Rango,Inicio);
disp('Amplitud del perfil de la respuesta')
K*A/sqrt(1+(w*tau)^2)
disp('Fase de la respuesta respecto a la entrada')
atan(-w*tau)
plot(t,A*sin(w*t),t,y,'r')
end
30
Programa en Simulink:
EJEMPLO: SISTEMA HIDRAULICO
% HIDRAULICO UNA ETAPA

C1=3; R1=1; C2=10; R2=2;
qi=2;
keyboard
plot(t,qo)
title('HIDRAULICO')
grid
31
pause
n=1;
while n==1
T=input('Entre tiempo: ')
delta=input('Entre valor delta: ')
i=find(t<=(T+delta)&t>=(T-delta));
tiempo=t(i)
caudal_salida=qo(i)
n=input('Entre 1 para seguir y 0 para parar: ')
end
EJEMPLO: SISTEMA ELÉCTRICO
% CIRCUITO RC DE DOS ETAPAS

R1=10e3; R2=20e3; C1=1e-6; C2=10e-6;
ei=10;
keyboard
plot(t,eo)
title('CIRCUITO RC')
grid
32
pause
n=1;
while n==1
T=input('Entre tiempo: ')
delta=input('Entre valor de delta: ')
i=find(t<=(T+delta)&t>=(T-delta));
tiempo=t(i)
voltaje_salida=eo(i)
n=input('Entre 1 para seguir y 0 para parar: ')
end
33
INTRODUCCION A SIMULINK
Matlab (Matrix Laboratory) es un sistema basado en matrices para realizar cálculos

matemáticos y de ingeniería. Entre las múltiples herramientas que presenta este programa se encuentra
Simulink que es una librería de MATLAB que permite la simulación de procesos mediante diagramas de
bloques.
1. Acceso a la librería de bloques de Simulink:
Para acceder a la librería de Simulink se debe abrir inicialmente la ventana principal de Matlab
(Matlab Command Window). En esta se puede ejecutar el comando “simulink” o hacer clic en
el símbolo correspondiente en la barra de herramientas en la parte superior de esta ventana.
Al hacer esto aparecerá el listado de las librerías correspondientes a simulink, donde se podrá
tener acceso a todos los bloques que brinda esta herramienta. Para abrir una nueva hoja de
trabajo se deberá acceder a través de: File à New à Model, o hacer clic en el símbolo de “hoja
nueva”.
Figura 1. Simulink Library Browser
La librería “Simulink” contiene los bloques necesarios para simular un sistema mediante técnicas
convencionales, las demás librerías son herramientas adicionales que se utilizan para aplicaciones
específicas de control avanzado. En la Figura 2 se muestra el contenido de la librería Simulink.
Figura 2. Librería Simulink.
En la figura 3 se pueden observar los bloques mas utilizados en la simulación de procesos. Estos
se encuentran en hacer clic en el signo (+) de cada librería. Pueden ser utilizados al hacer clic sobre ellos
y arrastrándolos sobre la hoja de trabajo. Igualmente en la tabla 1 se pueden observar una descripción
mas detalladas de algunas de estas funciones.
Figura 3. Bloques mas utilizados en la librería Simulink

Tabla 1. Detalles de algunos bloques de la librería Simulink.
Bloque Función Librería Parámetros requeridos
Constante Asigna un valor constante a la Sources Valor de la constante.

entrada.
Entrada escalón Introduce un escalón de magnitud Sources Tiempo del escalón

específica en un tiempo dado. Valor inicial del escalón,
Valor Final del Escalón
Entrada Rampa Introduce una rampa en un tiempo Sources Tiempo de la rampa,

especificado. pendiente
Entrada Senoidal Introduce una señal senoidal Sources Amplitud de la onda,

específicada por el usuario. Fase.
Workspace Almacena datos de la señal que llega Sinks Nombre y tipo de la

al bloque y la convierte en vector. Si variable (Save format:
se conecta al reloj se almacena el Matrix)
vector tiempo.
Entradas
Scope Grafica la señal que se introduzca Sinks
con respecto al tiempo.
Sinks
XYgraph Grafica la entrada superior en el eje Rango de los ejes
x y la inferior en el eje y
Función de Representa la función de Contin. Numerador y

Transferencia transferencia a lazo abierto. Denominador de la FT
Integrador Integra una señal en función del Contin. Valor inicial desde el
tiempo cual se va a integrar
Retardo de transporte Introduce un retardo en el tiempo en Contin. Valor del retardo (Debe
el cual aparece la señal. ser un número positivo)
Ganancia Multiplica la señal por cualquier Math Valor de la ganancia

valor de ganancia que se introduzca.
Sumador Suma dos señales. Math Número de entradas a

sumar
Multiplicador Multiplica dos señales. Math Número de entradas a

multiplicar
Matlab-Function Aplica cualquier función matemática Functions and Función a utilizar

conocida por Matlab a la señal. Tables
PID Es un controlador donde se puede Blocksets & Proporcional: K, Integral:

introducir una parte proporcional, Toolbox.: K/Ti, Derivativo: K.Td
una integral y una derivativa
Simulink-extras:
Aditional linear
Mux Permite representar dos señales Signals &System. Número de entradas

distintas en una misma gráfica.
Obs. Colocando el nombre del bloque de interés en el buscador (Simulink library browser), se puede
ubicar directamente en la librería de bloques.
Notas sobre el uso de Matlab.
- Los bloques pueden ser movidos al arrastrase con el botón izquierdo del mouse y pueden ser
copiados al hacer clic sobre ellos con el botón izquierdo del mouse y arrastrando la copia creada.
- Los bloques se deben unir mediante flechas. Esto se logra haciendo clic en la flecha de salida
del bloque deseado y conectándola (sin soltar el botón), a la flecha del bloque que se desea unir.
- Para que las modificaciones en el programa hagan efecto este deberá ser grabado después de
realizar los cambios.
- Al hacer clic con el botón derecho sobre una señal, se podrá obtener una “línea” de esta señal
para llevarla o conectarla a un bloque deseado.
- Al barrer el mouse sobre un grupo de bloques se podrán mover estos a la vez y copiarlos en
grupo.
- El “save format” de los “workspace” debe ser colocado en “array” para poder “graficar” las
variables deseadas posteriormente.
2. Ejemplos de Uso de Simulink
Modelos Matemáticos no Linealizados.
a) Simular la siguiente ecuación diferencial y encontrar su respuesta ante una entrada escalón.
d ( x)  − 60 
+ 5 exp  * X (t ) = 1 Donde, X0 = 0 en T=500
dt  T 
Solución:
- Seleccionar los bloques necesarios para representar el modelo y llevarlos a la hoja de

trabajo. Para ello debe buscar los bloques en las librerías correspondientes (Ver tabla 1 y
figuras 2 y 3), seleccionar cada uno haciendo "click" sobre él para marcarlo y arrastrarlo con
el "mouse" hasta la ventana.
Figura 4. Bloques necesarios para la representación de la ecuación.

- Armar el modelo. Las ecuaciones diferenciales pueden representarse en bloques de
"Simulink" como función del tiempo sin linealizarlas ni llevarlas al dominio de Laplace. En
primer lugar, se debe despejar la derivada temporal para expresarla en función de los demás
términos de la ecuación:
d ( x)  − 60 
= 1 − 5 exp  * X (t ) (1)
dt  T 
Luego, se debe establecer qué valores en la ecuación son constantes y cuáles son función del
tiempo, en este caso, la conversión X depende del tiempo, pero la temperatura T es constante.
El primer término del lado derecho de la ecuación (1) se puede representar como un escalón
unitario o como una entrada constante.
En el segundo término [5exp(-60/T).X(t)], la temperatura se representa, igualmente, como una

entrada escalón o como una entrada constante, luego se invierte con un bloque Matlab Function, donde se
especifica la función 1/u, se multiplica por una ganancia de –60 con un bloque Gain, y se introduce
nuevamente en una Matlab Función para obtener la exponencial, que va a ser multiplicada por 5 con otro
bloque Gain, como se muestra en la figura 5.
La variable X(t) no se conoce porque es el resultado de integrar el lado derecho de la ecuación,

esta variable debe multiplicarse con la exponencial con un bloque producto para formar el segundo
término de la ecuación diferencial, luego ambos términos se combinan con un bloque Sum para obtener la
ecuación (dX(t)/dt) completa que pasa por un integrador para obtener la variable X(t), que se realimenta
al bloque producto.
Se debe colocar igualmente un bloque de reloj para que el simulador contabilice el tiempo.
Todas las señales que se deseen guardar o ser posteriormente llamadas para graficar, deben ser
alimentadas a un bloque workspace (Save format : Array)
Figura 5. Diagrama de bloques de la simulación de la ecuación diferencial.
Haciendo clic en cada bloque se pueden cambiar sus parámetros y sus nombres. En este caso se
colocan los siguientes:
Matlab Function
Entrada Escalón (T) Integrador Matlab Function (1/T)
Exp(E/KT)
Step Time = 0
Valor Inicial = 500 Inicial Value = 0 Fuction = 1/u Fuction = exp
Valor Final = 500
De esta forma tenemos:
Figura 6. Diagrama de Bloques con sus parámetros.

- A continuación se abre el menú Simulation à Simulation Parameters y se modifica el
tiempo de parada. En este caso se pondrá 8 seg. Posteriormente se simula la ecuación
diferencial apretando el botón o símbolo de “play” en la parte superior de la pantalla y se
espera a que la maquina realice el calculo (indicado en la parte inferior derecha de la
ventana)
- Después de realizar la simulación se regresa a la ventana principal de Matlab y se grafican

los resultados colocando el comando: plot(T,X) y se obtiene:
Figura 7. Simulación de la respuesta de la ecuación diferencial.
Para observar la respuesta del sistema ante una perturbación se coloca:
Entrada Escalón (T)
Step Time = 4
Valor Inicial = 500
Valor Final = 1000
Para que el simulador acepte el cambio, el archivo debe ser guardado (no debe aparecer un
“asterisco” al lado del nombre del programa en la parte superior de la ventana). Después de simular
y graficar, se obtiene:
Figura 8. Respuesta del sistema de la ecuación diferencial ante entrada escalón.
Se observa la perturbación del sistema en el tiempo = 4 seg.
Ecuaciones Diferenciales Acopladas
b) Simular el siguiente sistema de ecuaciones diferenciales.
dT
= A(T − To1) * Fo − B(T − Ta) A = 0.08 B = 0.05
dt
dTa
= C (Ta − To 2) * Fp + D(Ta − T ) C = 0.5 D = 0.01
dt
Donde Fo, To1 y To son posibles perturbaciones cuyos valores son:
Fo = 0.01 m3/min, To1 = 280K, To2 = 350K
Solución:
- Los Bloques seleccionados son:
Figura 9. Bloques usados para la representación del sistema.

- Armar el modelo. Las ecuaciones diferenciales se "escriben en bloques de Simulink" como
función del tiempo sin realizar ninguna modificación de las mismas para linealizarlas o
llevarlas al dominio de Laplace.
Figura 10. Diagrama de bloques del proceso con sus parámetros.
Los parámetros iniciales de los bloques y simulación serán:
Entrada Escalón Entrada Escalón Integrador Stop

Entrada Escalón (Fo) Integrador (T)
(T01) (T02) (Ta) Time
Step Time = 0 Step Time = 0 Step Time = 0

Initial Value = Initial Value =
Valor Inicial = 280 Valor Inicial = 350 Valor Inicial = 0.01 200
280 350
Valor Final = 280 Valor Final = 350 Valor Final = 0.01
- Después de Simular y Graficar usando: Plot(t,[T,Ta]) se obtiene,
Figura 11. Simulación del sistema de ecuaciones diferenciales

Funciones de transferencia a lazo abierto y lazo cerrado
c) Dada la siguiente función de trasferencia obtenga la respuesta del sistema a lazo abierto ante
una entrada escalón.
1
FT =
s + 4s + 2
2
Solución:
- Armar el modelo.
Los parámetros iniciales de los bloques y simulación serán:
Función de Parámetros
Entrada Escalón
Trasferencia Simulación
Step Time = 0
Numerador = [1]
Valor Inicial = 0 Stop Time = 20
Denominador = [1 4 2]
Valor Final = 1
- Después de Simular y Graficar usando: Plot(T,X) se obtiene,
Figura 14. Respuesta temporal de la función de transferencia.
d) Compare la respuesta a lazo cerrado obtenida para la función de transferencia del ejemplo
anterior con la respuesta obtenida al aumentar 5 veces la ganancia y con la respuesta obtenida al
usar un controlador de función de transferencia:
 1
Gc1 = K 1 +  Donde, K = 1 y Ti = 0.5
 Ti 
Solución:

- Armar el modelo.
Los parámetros de los bloques son:
Entrada Escalón Ganancia Mux PID Stop Time
Step Time = 0 Proporcional = 1

Number of inputs
Valor Inicial = 0 Gain = 5 Integral = 1/0.5 20
=3
Valor Final = 1 Derivative = 0
- Después de Simular y Graficar usando: Plot(T,s) se obtiene,
Figura 17. Respuesta temporal de la función de transferencia.

Introducción a M ATLAB y S IMULINK para
Control
Virginia Mazzone
Regulador centrı́fugo de Watt
Control Automático 1
http://iaci.unq.edu.ar/caut1
Automatización y Control Industrial
Universidad Nacional de Quilmes
Marzo 2002
Índice General Introducción a M ATLAB y S IMULINK - 1
Índice General
1 Introducción a M ATLAB 1
1.1 Conversión de una función transferencia . . . . . . . . . . . . . . . . . . . . . 1
1.2 Raı́ces de un polinomio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Desarrollo en fracciones simples . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4 Función transferencia a lazo cerrado . . . . . . . . . . . . . . . . . . . . . . . . 6
1.5 Respuesta al impulso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.6 Respuesta al escalón . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.7 Gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Introducción a S IMULINK 14
2.1 Acceso y descripción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Función transferencia a lazo cerrado . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 Respuesta al Escalón . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 Utilización de parámetros ya definidos . . . . . . . . . . . . . . . . . . . . . . . 19
1 Introducción a M ATLAB
Este apunte es una introducción elemental a M ATLAB, destinado a conocer y practicar al-
gunas de las operaciones básicas con funciones de transferencia. Los comandos que uti-
lizaremos son los que figuran en la Tabla 1. Para mayor información sobre un comando
en particular puede ejecutarse help topic o simplemente help ’comando’, desde la
ventana de comando de M ATLAB.
1.1 Conversión de una función transferencia

Una función transferencia puede describirse en M ATLAB utilizando dos vectores filas: uno
para los coeficientes del numerador y otro para los coeficientes del denominador. A menudo
se requiere para analizar o diseñar un sistema conocer la ubicación de sus polos y ceros;
dicha información está contenida en la función transferencia del sistema. Cuando la fun-
ción de transferencia está especificada como razón de polinomios, podemos conocer sus
polos, ceros y ganancia, o viceversa. Los comandos que nos permiten ésto son: tf2zp, que
de un cociente de polinomios nos devuelve los ceros, polos y una ganancia, y zp2tf, que
de conocer los polos, ceros y la ganancia de un sistema nos da el numerador y denominador
de su función de transferencia.
Ejemplo 1. Supongamos la función transferencia
5s + 20
G (s) = ,
s2 + 4s + 20
si sacamos el 5 factor común del numerador y factorizamos el denominador utilizando sus
raı́ces, nos queda de la forma
5(s + 4)
G (s) = .
(s + 2 − 4 j)(s + 2 + 4 j)
Comando Breve explicación

exp Exponencial.
sin Seno.
cos Coseno.
sinh Seno Hiperbólico.
cosh Coseno Hiperbólico.
clf Elimina la figura actual.
plot Crea gráficas.
subplot Crea múltiples gráficos en la misma figura.
hold Mantiene la gráfica anterior.
title Agrega tı́tulo del gráfico.
xlabel Agrega nombre del eje-X.
ylabel Agrega nombre del eje-Y.
text Agrega texto al gráfico.
print Imprime el gráfico o lo guarda en un archivo
figure Crea figuras (ventana para gráficos).
impulse Respuesta al Impulso.
step Respuesta al escalón unitario.
tf Crea un modelo en función de transferencia.
zpk Crea un modelo de cero-polo-ganancia.
ss2tf Conversión de modelo en espacio de estados a función de transferencia.
tf2zp Conversión de modelo en función de transferencia a polos y ceros.
ss2zp Conversión de modelo en espacio de estados a polos y ceros.
zp2tf Conversión de modelo en polos y ceros a función de transferencia.
tf2ss Conversión de modelo en función de transferencia a espacio de estados.
zp2ss Conversión de modelo en polos y ceros a espacio de estados.
Tabla 1: Comandos que utilizaremos

Para llevar a cabo lo mismo con M ATLAB, debemos ingresar los polinomios numerador
y denominador, en forma de vectores de la siguiente manera:
num=[5 20];
den=[1 4 20];
Observemos que para definir el vector lo hacemos colocando entre corchetes los coefi-
cientes de cada término, ordenados de mayor orden al menor. Para separar las columnas
del vector lo hacemos con un espacio, o también podrı́amos utilizar coma. El punto y coma
final es para que el resultado de lo ejecutado por M ATLAB no salga por pantalla.
Si ahora ingresamos:
[z,p,k]=tf2zp(num,den)
Obtenemos:
z=-4
p=[-2+4j -2-4j]
k=5
Dado que toda función transferencia dada por un cociente de polinomios se puede escribir
de la forma
∏ m ( s − zi )
G (s) = k ni=1 con m ≤ n,
∏i =1 ( s − pi )
podemos armar fácilmente nuestra función transferencia, haciendo
5(s + 4)
G (s) = .
(s + 2 + 4 j)(s + 2 − 4 j)
Si queremos realizar el procedimiento inverso, necesitamos ingresar las variables k, z y

p. Con la instrucción:
[num,den]=zp2tf(z,p,k);
obtenemos el numerador y denominador de la función transferencia:
num=[5 20]
den=[1 4 20]
El hecho de tener el numerador y el denominador de la función de transferencia en

dos variables, no significa que M ATLAB la identifique como tal. Para ello se utiliza el co-
mando tf, que describe en una sola variable la transferencia dada por su numerador y al
denominador. Lo utilizamos de la siguiente forma:
G=tf(num,den);
Si queremos que M ATLAB arme la función transferencia como cociente de productos de

los ceros y los polos, para ello utilizamos zpk, de la siguiente forma:
G=zpk(z,p,k);
1.2 Raı́ces de un polinomio

En el Ejemplo 1 vimos que el polinomio denominador de la función transferencia venı́a
dado por: s2 + 4s + 20, y pudimos hallar sus raı́ces dado que se trata de una ecuación de
segundo orden.
En polinomios de orden superior, la tarea de encontrar sus raı́ces no siempre es tan fácil.
Con la función de M ATLAB roots podemos calcular las raı́ces de cualquier polinomio.
Para ejecutar dicha función tenemos que ingresar el polinomio, como vector, recordando
que los polinomios se ingresan en la primer componente el término de mayor orden y luego
en forma descendente separados por coma o un espacio.
Ejemplo 2. Consideremos el siguiente polinomio:
P = s4 + 4s3 + 4s2 + s + 20
Ingresamos el polinomio p=[1 4 4 1 20] y luego:
r=roots(p);
En lugar de hacer la operación en dos pasos, podemos hacerlo solo en uno; si tipeamos
r=roots([1 4 4 1 20]) obtenemos el mismo resultado Las cuatro raı́ces del polinomio
anterior que surgen de M ATLAB son: −2.6445 ± 1.2595 j y 0.6545 ± 1.3742 j.
Si el caso es al revés, es decir, tengo las raı́ces y quiero conocer el polinomio, el comando
poly es el que se utilizaremos. Siguiendo con el mismo ejemplo, supongamos que lo que
tenemos son las raı́ces p1,2 = −2.6445 ± 1.2595 j y p3,4 = 0.6545 ± 1.3742 j. Entonces el
polinomio al que le corresponden esas raı́ces es:
P=poly([p1,p2,p3,p4]);
Notemos que el polinomio P que obtuvimos es mónico; si quisiéramos cualquier otro,

deberı́amos multiplicar a P por el coeficiente principal. Otra cosa a tener en cuenta es que
siempre que pongamos una raı́z compleja debemos poner su conjugada.
1.3 Desarrollo en fracciones simples

Cuando analizamos un sistema de control, por lo general disponemos de su función trans-
ferencia a lazo cerrado G (s), donde G (s) = YR((ss)) . Con lo que podemos escribir la salida en
función de la transferencia y la entrada: Y (s) = G (s) × R(s).
Si deseáramos conocer la respuesta temporal g(t) del sistema cuando lo excitamos con
una señal de entrada r(t), debemos calcular la transformada inversa de Laplace, es decir
g(t) = L−1 {Y (s)} = L−1 { G (s) × R(s)}. Como sabemos, es más sencillo de antitransformar
cuando se trata de un cociente de polinomios, dado que si lo expresamos en fracciones
simples podemos utilizar una tabla de transformadas de Laplace.
Ejemplo 3. Supongamos que tenemos la siguiente función transferencia:
16s + 16 1
G (s) = y que R(s) =
(s + 2)(s + 4) s
Como las raı́ces del denominador sor reales y distintas, el método de desarrollo en frac-
ciones simples nos permite escribir a G (s) × R(s) de la siguiente manera:
16s + 16 A B C
= + +
s(s + 2)(s + 4) s s+2 s+4
Ahora podemos calcular c(t) se la siguiente forma:

−1 A B C
c(t) = L + +
s s+2 s+4

−1 A −1 B −1 C
= L +L +L
s s+2 s+4
−2t −4t
= A + Be + Ce
Para calcular los valores de A, B y C lo hacemos mediante la fórmula de residuos, dado

que en este ejemplo los polos son de primer orden, resulta que
Res{ p} = lim(s − p) F (s)

s→ p
donde p es el polo para el cual se está calculado el residuo. Veamos como serı́a en este
ejemplo:
16s + 16 16(0) + 16
A = lim(s) = =2
s→0 s(s + 2)(s + 4) (0 + 2)(0 + 4)
16s + 16 16(−2) + 16
B = lim (s + 2) = =4
s→−2 s(s + 2)(s + 4) (−2)(−2 + 4)
16s + 16 16(−4) + 16
C = lim (s + 4) = = −6
s→−4 s(s + 2)(s + 4) (−4)(−4 + 2)
Con estos residuos, queda determinada la salida como: c(t) = 2 + 4e−2t − 6e−4t
En general, estos cálculos pueden tornarse muy complicados de realizar ’a mano’. Veamos
como se simplifican utilizando la función M ATLAB residue. Ingresemos nuevamente los
polinomios numerador y denominador de la misma forma como lo venimos haciendo hasta
ahora. Ingresemos ahora la sentencia:
[res,p]=residue(num,den);
Esta función nos devuelve dos parámetros vectoriales: en la variable res aparecen los
residuos correspondientes a los polos que figuran en la variable p, es decir, el primer resid-
uo corresponde al primer polo y ası́ sucesivamente.
Si la función transferencia resulta ser propia, es decir que el grado del numerador es igual
al del denominador, podemos añadir una parámetro más al argumento del lado izquierdo,
que lo podemos llamar k. Veamos como serı́a esto mediante otro ejemplo:
Ejemplo 4. Supongamos que queremos hallar f (t) siendo:
2s3 + 5s2 + 3s + 6
F (s) = ⇒ f (t) = L−1 { F (s)}
s3 + 6s2 + 11s + 6
Si aplicamos el comando:
[res,p,k]=residue(num,den);
y si armamos, como lo hicimos anteriormente, la función desarrollada en fracciones sim-

ples, el término independiente es el que aparece el la variable k. Por lo tanto F (s) =
−6
s+3
+ s−+42 + s+3 1 + 2, de donde ahora calcular la f (t) resulta muy sencillo.
Si ahora nuestro interés es el inverso, es decir que tenemos una función escrita en frac-
ciones simples y quisiéramos obtener la función como cociente de polinomios, analı́ticamente
deberı́amos sacar común denominador y hacer todas las cuentas correspondientes. Esto re-
sulta inmediato con el comando de M ATLAB:
[num,den]=residue(res,p,k);
1.4 Función transferencia a lazo cerrado

Ejemplo 5. Supongamos que disponemos del sistema de la Figura 1 donde G1 (s) = 0.4;
G2 (s) = s(100
s+2)
; H2 (s) = s+s20 y H1 (s) = 1; y pretendemos hallar la función transferencia a
Y (s)
lazo cerrado G (s) = R(s)
. Si aplicamos reducción de bloques, o resolviendo el diagrama de
R(-
s) lE(s) - V (s) Y (s)-
G1 (s) - l - G2 (s)
− 6 −6
H2 (s)
H1 (s)
Figura 1: Diagrama de bloques
flujo y aplicando Mason, obtenemos:
40s + 800
G (s) =
s3 + 22s2 + 180s + 800
En M ATLAB la función transferencia a lazo cerrado se puede calcular de dos formas:
• Utilizando S IMULINK (lo veremos más adelante).
• Utilizando las funciones de M ATLAB series, parallel, feedback y cloop.
Para calcular la función transferencia a lazo cerrado G (s) sigamos los siguientes pasos:
1. Definimos los numeradores y denominadores de las funciones transferencia de cada

bloque de la siguiente forma:
numg1=0.4; deng1=1;
numg2=100; deng2=[1 2 0];
numh2=[1 0]; denh2=[1 20];
2. Calculamos la función transferencia de V (s) a Y (s):
[numvc,denvc]=feedback(numg2,deng2,numh2,denh2,-1);
3. Ahora calculamos la función transferencia de E(s) a Y (s) con:
[numec,denec]=series(numg1,deng1,numvc,denvc);
4. Por último calculamos el lazo cerrado:
[num, den]=cloop(numec,denec,-1);
Lo que obtuvimos son los vectores numerador y denominador de la función transferen-

cia por separado. Recordemos que para ingresarla como función de transferencia a M AT-
LAB, debemos utilizar tf.
1.5 Respuesta al impulso

Ahora que ya sabemos como pasar de la respuesta temporal a Laplace, verifiquemos que
la respuesta al impulso de la transformada de Laplace coincide con la respuesta temporal.
Para ello utilizaremos el comando de M ATLAB impulse.
Ejemplo 6. Supongamos que tenemos una función transferencia de la siguiente forma:
1
Y (s) = ; donde a = 1, b = 2
(s + a)(s + b)
Si calculamos ahora la antitransformada, desarrollando en fracciones simples como en la
sección 1.3, resulta que y(t) = e−t − e−2t . Ingresemos los vectores numerador y denomi-
nador y luego ejecutemos el comando:
impulse(num,den);
Veremos que este comando devuelve el gráfico de la Figura 2 Como podemos ver, solo
nos muestra los primeros 6 segundos de la respuesta. Si quisiéramos que nos mostrara 12
segundos, debemos definir un vector de tiempo. Para ello ingresemos, por ejemplo,
t=0:0.1:12;
El vector t tendrá como primer elemento el 0 y como último al 12. Cada elemento estará a
una distancia de 0.1 de su consecutivo. Si ahora introducimos este parámetro en el coman-
do impulse(num,den,t), el gráfico mostrará los primeros 12 segundos de la respuesta
al impulso.
Notemos que este comando no fue asignado a ninguna variable; podrı́amos asignarle
un vector, es decir y=impulse(num,den,t), y ası́ tendrı́amos los valores de la salida
de la respuesta al impulso en dicho vector. Podrı́amos también graficar este vector con el
comando plot(t,y), comando que veremos en la sección 1.7.
Impulse Response
From: U(1)
0.25
0.2
0.15
Amplitude
To: Y(1)
0.1
0.05
0
0 1 2 3 4 5 6
Time (sec.)
Figura 2: Respuesta al impulso
Dado que la función transferencia de un sistema lineal invariante en el tiempo se de-

fine como la transformada de Laplace de la respuesta al impulso cuando todas las condi-
ciones iniciales son nulas, comparemos el resultado obtenido con el que resultarı́a si cal-
culáramos la respuesta temporal. Para ello utilizaremos el mismo vector temporal t, y
la instrucción f=exp(-t)+exp(-2*t). Ahora podemos comparar los valores obtenidos
desde la respuesta al impulso con los obtenidos desde la respuesta temporal (por ejemplo,
restándolos).
1.6 Respuesta al escalón

De la misma forma que en la sección anterior, podrı́amos querer graficar la respuesta al es-
calón unitario. M ATLAB posee un comando, llamado step, para calcular la salida temporal
cuando la entrada se trata de un escalón unitario. Lo único que necesita este comando es el
numerador y el denominador de la función transferencia.
step(num,den);
y=step(num,den);
Si utilizamos el comando sin asignarle la salida a ninguna variable, M ATLAB abre una
ventana gráfica mostrando el gráfico de la salida a la excitación escalón unitario, de la
misma forma que antes. Sin embargo,al igual que vimos en el comando impulse, cuando
éste es asignado a una variable, los valores obtenidos se guardan en el vector y.
Ejemplo 7. Calculemos la respuesta al escalón unitario de la función transferencia:
Y (s) 4
G (s) = = 2
R(s) s + 0.8s + 4
Si ingresamos el comando step(num,den), veremos un gráfico similar al que podemos
observar en la Figura 3.
Step Response
From: U(1)
1.6
1.4
1.2
1
Amplitude
To: Y(1)
0.8
0.6
0.4
0.2
0
0 5 10 15
Time (sec.)
Figura 3: Respuesta al escalón unitario
Si ahora queremos la respuesta a una entrada rampa unitaria, M ATLAB no posee ningún
comando que lo resuelva. Por lo que veremos cómo con el comando step podemos obtener
una rampa. Si seguimos con el ejemplo anterior y excitamos al sistema con r(t) = t, es decir
que R(s) = s12 , tenemos lo siguiente:

4 1 4 1
Y (s) = ⇒ Y ( s ) =
s2 + 0.8s + 4 s2 s3 + 0.8S2 + 4s s
Por lo que utilizando como denominador de la función transferencia al polinomio s3 +

0.8s2 + 4s, es decir den=[1 0.8 4 0], y calculando la respuesta al escalón unitario con
step(num,den), obtenemos la respuesta a la rampa unitaria que se muestra en la Figura
4.
1.7 Gráficos
Como vimos en secciones anteriores los comandos step e impulse grafican las respuestas
al escalón y al impulso respectivamente, pero ahora vamos a introducir algo más general.
Para graficar cualquier función en general utilizaremos el comando plot, que sólo necesita
definir el vector a graficar en la forma básica
plot(vector);
Se obtiene un gráfico donde el eje de abscisas será la posición del elemento del vector y la
ordenada el valor que tiene el vector en dicha posición. En el ejemplo 6, guardamos en el
vector y los valores de la salida de la respuesta al impulso. Si ahora ingresamos plot(y),
en lugar de tener segundos en el eje de abscisas tendremos la cantidad de elementos de ese
vector. Si ingresamos plot(t,y), ahora el eje de abscisas corresponderá al vector tempo-
ral ya definido e irá desde t = 0 a t = 12, que es como lo tenı́amos definido. Grafiquemos
Step Response
From: U(1)
25
20
15
Amplitude
To: Y(1)
10
0
0 5 10 15 20 25
Time (sec.)
Figura 4: Respuesta a la rampa unitaria
entonces los valores guardados en el vector f . Estos valores corresponden a la respuesta

temporal, por lo que el gráfico deberá ser el mismo. Si ingresamos plot(t,f), obten-
dremos el gráfico de la Figura 5
Como podemos ver, no hay casi diferencias con la figura 2, excepto por el tı́tulo y los
nombres de los ejes que el comando impulse(num,den) pone automáticamente. Veamos
que no es difı́cil si se lo queremos agregar a un gráfico, para ello utilizaremos las sentencias
title, xlabel y ylabel. Estos comandos se utilizan luego de ingresar el comando
plot, ya que tanto el tı́tulo, como los nombres de los ejes, se escribirán el la figura que se
encuentre abierta:
title(’Respuesta al Impulso’);
xlabel(’Tiempo(seg.)’);
ylabel(’Salida c(t)’);
Notemos que el texto que queremos que aparezca está escrito entre comillas simples.
Los comandos anteriores, pueden ser también utilizados con step y impulse, aunque
cuando son utilizados en estos comandos, el tı́tulo y el nombre de los ejes que trae la fun-
ción por defecto también aparecen. Otros comandos que pueden ser útiles a la hora de
trabajar con gráficos son grid y text, que se utilizan para agregar una grilla y agregar
texto respectivamente. El comando text se utiliza de la misma forma que que title, es
decir, el texto que aparecerá será el que se encuentra escrito entre las comillas simples , pero
antes debemos ingresar las coordenadas ( x, y) donde queremos que aparezca el texto. El
comando grid, se usa sin parámetros. Veamos el siguiente ejemplo:
Ejemplo 8. Supongamos que tenemos la función transferencia de la Figura 1, que ya la cal-
culamos con M ATLAB en el Ejemplo 2.2. Abramos un archivo nuevo e ingresemos lo sigu-
iente:
0.25
0.2
0.15
0.1
0.05
0
0 2 4 6 8 10 12
Figura 5: Respuesta temporal del ejemplo 6
num=[40 800];
den[1 22 180 800];
t=0:0.01:2;
y=step(num,den,t);
plot(t,y);
title(’Respuesta al escalon unitario’);
xlabel(’Tiempo (seg.)’);
ylabel(’Salida del sistema’);
text(0.5,1.1,’maximo valor’);
grid;
Si ejecutamos el programa vamos a obtener el gráfico de la Figura 6.

Supongamos ahora que queremos graficar en la misma figura dos o más gráficos para
poder compararlas. Esto es posible utilizando el comando hold on - hold off, que
mantiene la figura y superpone el siguiente gráfico sobre la misma figura, como veremos
en el siguiente ejemplo.
Ejemplo 9. Supongamos que queremos graficar tres sinusoides con frecuencias diferentes,
ingresemos en un archivo nuevo:
t=0:pi/20:2*pi;
y1=sin(t);
y2=sin(t-pi/2);
y3=sin(t-pi);
plot(t,y1);
hold on;
plot(t,y2);
plot(t,y3);
hold off;
Respuesta al escalón
1.4
1.2
maximo valor
1
Salida del sistema
0.8
0.6
0.4
0.2
0
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
Tiempo (seg.)
Figura 6: Respuesta al escalón del ejemplo
Luego de ejecutar estas lı́neas veremos que en la figura que resulta, aparecen 3 gráficas
en el mismo color, e imposible de identificar cual corresponde a cada una porque ambas se
encuentran graficadas con el mismo tipo de linea y el mismo color. Para ello veamos un
parámetro del tipo string que podemos agregar al comando plot para especificaciones del
estilo del gráfico. Los parámetros que figuran en la Tabla 2 son para elegir el color de la
lı́nea, los que se encuentran en la Tabla 3 son para elegir el estilo de la lı́nea y los que se
encuentran el la Tabla 4 son para elegir el tipo de marca que aparecerá sobre los puntos del
vector graficado.
Espec. Color
r rojo
b azul (por defecto)
w blanco
g verde
c cian
m magneto
y amarillos
k negro
Tabla 2: Especificadores de color
Ahora especifiquemos cada uno de los plot con un estilo diferente, por ejemplo, en
lugar del comando plot(t,y) escribamos:
plot(t,y1,’-.rx’);
plot(t,y2,’--mo’);
plot(t,y3,’:bs’);
Espec. Estilo de linea

- linea sólida (por defecto)
– linea rayada
: linea punteada
-. linea punto-raya
Tabla 3: Especificadores de linea
Espec. Estilo de marca

+ signo màs
o cı́rculo
· punto
∗ asterisco
s cuadrado
d diamante
x cruz
p estrella de 5 puntas
h estrella de 6 puntas
Tabla 4: Especificadores de marca
Si corremos nuevamente el archivo veremos que hay diferencia entre una función y
la otra, pero seguimos sin saber cuál corresponde a qué función. Para ello utilicemos el
comando legend, que pone la leyenda que queramos a cada gráfico. Es decir, escribamos
como última linea:
legend(’sin(t)’, ’sin(t-pi/2)’,’sin(t-pi)’);
Ahora si observamos el gráfico deberı́a ser como el de la Figura 7.
También podrı́amos querer cada gráfico en una figura diferente. Para ello debemos
ejecutar el comando figure(2) antes de graficar por segunda vez y figure(3) antes
del último gráfico. Estas sentencias se usan sin el comando de hold on - hold off y
lo que hacen es abrir una nueva figura para cada gráfico. Otra opción válida para M ATLAB,
por ejemplo, es que las tres funciones aparezcan en una sola figura pero las tres graficadas
en forma independiente. Para ello utilicemos subplot(m,n,p), que dividirá a la figura
en m filas y n columnas, pero crea una figura en la posición p. Ingresemos lo siguiente para
ver como funciona:
clf; %borra el grafico actual

subplot(3,1,1);
plot(t,y1,’.-r’);
title(’sin(t)’);
subplot(3,1,2);
plot(t,y2,’--m’);
title(’sin(t-pi/2)’);
subplot(3,1,3);
plot(t,y3,’:b’);
1
sin(t)
sin(t−pi/2)
0.8 sin(t−pi)
0.6
0.4
0.2
−0.2
−0.4
−0.6
−0.8
−1
0 1 2 3 4 5 6 7
Figura 7: Tres gráficos en una misma figura
title(’sin(t-pi)’);
Notemos que con el sı́mbolo %, comentamos texto dentro del archivo. Si ejecutamos
nuevamente el programa, obtenemos lo que se observa en la Figura 8
Con respecto a gráficos, M ATLAB posee muchas otras opciones, como graficar en es-
cala logarı́tmica, con loglog, semilogx y semilogy, gráficos en tres dimensiones,
plot3, gráficos de barras, bar, etc. También permite con el comando print, guardar
el gráfico en un archivo de extensión, por ejemplopostscript o .jpg, o también lo podemos
imprimir con el mismo comando indicando el nombre de la impresora.
No nos olvidemos que M ATLAB cuenta con una ayuda a la cual podemos recurrir en ca-
so de no recordar como se utiliza un comando. Si investigamos un poco el help, podemos
encontrar funciones que resuelven muchas otras cosas interesantes. Invito a que se metan
a conocerlas, como ası́ también a que conozcan las distintas demostraciones que pueden
encontrar si tipean: demo.
2 Introducción a S IMULINK
Hasta ahora vimos que M ATLAB dispone de un entorno de programación con lı́neas de
órdenes, ahora veremos como se puede suplementar utilizando un interfaz de usuario
gráfica llamada S IMULINK. Este entorno nos permite describir gráficamente un sistema
dibujando su diagrama en bloques, que resulta muy conveniente para la simulación y
análisis de sistemas dinámicos.
2.1 Acceso y descripción

Para acceder a S IMULINK, desde la ventana de comandos de M ATLAB, tenemos varias op-
ciones: una es escribiendo el comando simulink, de esta forma se abrirá solo una ventana
sin(t)
1
0.5
−0.5
−1
0 1 2 3 4 5 6 7
sin(t−pi/2)
1
0.5
−0.5
−1
0 1 2 3 4 5 6 7
sin(t−pi)
1
0.5
−0.5
−1
0 1 2 3 4 5 6 7
Figura 8: Tres gráficos diferentes en la misma figura
con las librerı́as disponibles; otra es desde la barra de menú File elegir la opción New Model,
de esta forma se abren no sólo las librerı́as sino también el entorno donde vamos a trabajar;
por último, existe un botón de acceso directo a las librerı́as tanto en el entorno de trabajo
de M ATLAB como en el de S IMULINK.
Una vez abiertas las librerı́as, lo que encontraremos depende de la versión de MATLAB
que se encuentre instalada. Nos vamos a referir a la versión 5.3. Dentro de la librerı́a
Simulink se encuentran los elementos que vamos a utilizar organizados en sublibrerı́as de
acuerdo con su comportamiento. Las sublibrerı́as que aparecen son:
• Continous (Bloques para sistemas en tiempo continuo)
• Discrete: (Bloques para sistemas en tiempo discretos)
• Functions & Tables
• Math (Sumadores, Ganancias matriciales o constantes, etc.)
• Nonlinear
• Signals & Sistems(multeplexores, demultexores, etc.)
• Sinks (Graficadores, etc.)
• Sources (Varias fuentes de entradas)
Con un doble click sobre la librerı́a podemos visualizar los elementos que posee. Por
ejemplo si ingresamos a Continous, entre los elementos disponibles utilizaremos los sigu-
ientes:
du
Derivative: bloque derivador, es decir dt
.
Integrator: bloque integrador, función transferencia 1s .
State-Space: bloque para expresar al sistema en modelo de estados.
Transfer Fnc: bloque para expresar al sistema como cociente de polinomios.
Zero-pole: bloque para expresar al sistema con ceros, polos y una ganancia.
2.2 Función transferencia a lazo cerrado

En la Sección 2.2 vimos como podemos calcular la función transferencia a lazo cerrado
desde la ventana de comandos. Tomemos el mismo ejemplo para ver como lo hacemos con
S IMULINK, ingresemos el diagrama en bloques como se puede ver en la Figura 9.
100
1 .4 1
s2+2s
In1 Out1
Gain Transfer Fcn
s
s+20
Transfer Fcn1
Figura 9: Diagrama en bloques con S IMULINK
Para poder implementar dicho gráfico se procedió de la siguiente forma:

1. Para insertar un bloque de función transferencia, ya sabemos que se encuentra en
Continous, lo tomamos y lo arrastramos hasta la ventana de trabajo de SIMULINK. Si
hacemos doble click sobre el bloque se despliega una ventana de propiedades del
bloque, donde tenemos que ingresar el numerador y el denominador de la misma
forma que lo hacemos desde el entorno de trabajo de MATLAB, es decir entre corchetes
y separado por espacios. Si en lugar de seleccionar el bloque de función transferencia
elegimos el bloque de polos y ceros, los parámetros a definir serán los polos, los ceros
y la ganancia.
2. Para insertar otro bloque igual no es necesario realizar el ı́tem anterior nuevamente,
podemos seleccionar el bloque anterior, haciendo un click con el botón derecho del
mouse, copiar el bloque y pegarlo donde queramos. Esto mismo se puede hacer sim-
plemente arrastrando el objeto seleccionado con el botón derecho del mouse. De la
misma forma que antes, ingresamos los parámetros de esta función de transferencia.
Para girar el bloque, para que quede mejor orientado para hacer la realimentación,
tenemos que seleccionar el objeto, ir a Format de la barra de menú, y seleccionar Flip
Block o simplemente con las teclas ctr-f.
3. El bloque de ganancia lo encontramos en Math, lo mismo que los sumadores. Para

ingresarlos a la figura procedemos de la misma manera, arrastrando el objeto hasta
donde queremos ubicarlo. El sumador, por defecto, viene con dos entradas sumadas,
si hacemos doble click sobre él, podemos no solo cambiar el signo que queramos sino
también agregarle las entradas que queramos, en este caso solo modificamos ++ por
+−. Otra propiedad que podemos modificar es la forma del icono. Notemos que
cuando hacemos un doble click en cualquier objeto, encontramos una pequeña ayuda
en la parte superior de la ventana, ésto nos es útil para saber con que datos hay que
completar cada campo. Para el bloque de la ganancia, solo ingresamos el valor que
corresponde 0.4.
4. Para unir los bloques solo tenemos que hacer un click en la salida de un bloque y
arrastra el mouse hasta la entrada de otro, cuando soltamos, si la conección está
bien hecha, marcará una flecha negra, en caso de estar uniendo con un nodo, de-
beremos ver un cuadradito negro. Para borrar cualquier elemento, simplemente lo
seleccionamos y con la tecla DEL se elimina.
5. Por último nos falta solo indicar cuál es la entrada y cual es la salida, esto lo hacemos
para poder sacar la transferencia a lazo cerrado, de otra forma no lo pondrı́amos. La
necesidad de marcar la entrada y la salida es para que MATLAB sepa desde donde has-
ta donde vamos a querer la transferencia. Estos bloques los encontramos en Signals &
Systems, se llaman ”In1” e ”Out1”.
6. Salvemos el archivo, por ejemplo con el nombre “FuncTrans”, si ingresamos desde la

ventana de comando de MATLAB las sentencias
[A,B,C,D]=linmod(’Functtrans’);
[num,den]=ss2tf(A,B,C,D);
obtenemos la función transferencia. La primer orden produce un modelo de estado

del sistema de bloques, tomando la entrada y la salida que seleccionamos; y la segun-
da sentencia convierte ese modelo de estados en el numerador y el denominador de
la función transferencia. En este caso el resultado es
num=[40 800]
den=[1 22 180 800]
que si los comparamos con los obtenidos antes son idénticos.
2.3 Respuesta al Escalón

Siguiendo con el sistema de la Figura 9, nos interesa saber ahora cómo responde a una
entrada escalón unitario. Como tenemos la función transferencia a lazo cerrado, podrı́amos
utilizar el comando step(num,den) desde la ventana de comandos para obtener la salida.
Pero veamos cómo lo podemos hacer desde SIMULINK. Para ello cambiemos el bloque
de entrada por un bloque de entrada escalón, que lo encontramos el la librerı́a Sources
bajo el nombre “Step”. A dicho bloque podemos modificarle algunos parámetros como el
tiempo en que se realizará el escalón, el valor inicial y final de escalón y en caso de que lo
necesitemos discreto, el tiempo de muestreo. Para nuestro ejemplo, elegimos como valor
inicial 0, valor final 1 y tiempo de realización del escalón 0seg.. Para poder visualizar la
salida, debemos conectar a la salida un osciloscopio. Este bloque lo encontramos en Sinks
bajo el nombre “Scope”. Luego de agregados estos bloques, el sistema resultante es el que
observamos en la Figura 10.
100
.4
s2+2s
Step Gain Transfer Fcn Scope
s
s+20
Transfer Fcn1
Figura 10: Sistema excitado con un escalón
1.4
1.2
0.8
0.6
0.4
0.2
0
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
Figura 11: Señal que muestra el osciloscopio

Si hacemos doble click sobre el bloque “Scope”, veremos la salida del sistema como
en la Figura 11. Este bloque también posee algunas propiedades que podemos modificar,
entre ellas están los valores de los ejes, el tı́tulo y la escala. Cuenta también con Zoom
para visualizar alguna zona en detalle. Otra propiedad es la posibilidad de asignarle los
datos que posee a una variable. Luego desde la ventana de comandos podemos visualizar
los valores o graficarlos dado que SIMULINK guarda también en una variable el vector
temporal que utiliza en la simulación, dicha variable se llama tout.
Si en lugar de la respuesta al escalón unitario queremos la respuesta al impulso, dado
que SIMULINK no posee un bloque generador de impulsos, debemos generarlo nosotros
como resta de dos escalones.
2.4 Utilización de parámetros ya definidos

SIMULINK nos permite utilizar variables definidas ya sea en la ventana de comando de
MATLAB , como también en archivos del editor. Para ello debemos definir las variables con
anticipación y luego utilizarlas dentro de los bloques con el mismo nombre. De esta forma,
SIMULINK identifica el valor de dicho parámetro y es el que utiliza en los cálculos. Esto
resulta apropiado cuando queremos utilizar un mismo diseño para distintos valores de
parámetros, o nos permitirá utilizar el mismo sistema cada vez que nos encontremos con
problemas similares.
Curso de Programación en Matlab y Simulink
Alberto Herreros (albher@eis.uva.es)

Enrique Baeyens (enrbae@eis.uva.es)
Departamento de Ingenierı́a de Sistemas y Automática (DISA)

Escuela de Ingenierı́as Industriales (EII)
Universidad de Valladolid (UVa)
Curso 2010/2011
A. Herreros, E. Baeyens, DISA/EII (UVa) Curso de Programación en Matlab y Simulink Curso 2010/2011 1/215
Contenidos
1 Introducción
2 Programación con Matlab
3 Optimización del código de programación
4 Gráficas en dos y tres dimensiones
5 Programación orientada a objetos
6 Simulación en Matlab y Simulink
7 GUIDE: Interface gráfico de matlab
8 Funciones para tratamiento de datos
9 Funciones para álgebra de matrices
10 Filtros y análisis en frecuencia
11 Funciones para polinomios e interpolación de datos
12 Funciones de funciones: Optimización e integración
13 Bibliografı́a
Contenidos
1 Introducción
13 Bibliografı́a
¿Qué es MATLAB?
Es un lenguaje de alto nivel para computación e ingenierı́a. Integra

computación, visualización y programación.
Aplicaciones tı́picas de MATLAB son:
Matemáticas y computación
Desarrollo de algoritmos
Modelado, simulación y prototipado
Análisis de datos, exploración y visualización
Gráficos cientı́ficos y de ingenierı́a.
Desarrollo de aplicaciones
Matlab es un sistema interactivo cuyo elemento básico son las matrices y

no requiere dimensionamiento.
El nombre proviene de ”laboratorio de matrices”.
Originalmente fue escrito en FORTRAN y hacı́a uso de las librerı́as
LINPACK y EISPACK
Las últimas versiones están desarrolladas en C y utilizan las librerı́as
LAPACK y BLAS.
Sobre la base de MATLAB se han construido conjuntos de funciones
especı́ficas para diferentes problemas, denominadas ”toolboxes”.
Formas de introducir matrices en MATLAB
Lista explı́cita de elementos.

Desde un fichero de datos externo.
Utilizando funciones propias.
Creando un fichero .m
Comenzaremos introduciendo manualmente la matriz de Dürer.

Para ello utilizamos las siguientes reglas:
Separar elementos de una fila con espacios o comas.
Usar ”punto y coma”; para indicar final de fila.
Incluir la lista completa de elementos dentro de corchetes, [ ].
Trabajando con matrices
Para introducir la matriz de Dürer hacemos:

A = [ 1 6 3 2 1 3 ; 5 10 11 8 ; 9 6 7 1 2 ; 4 15 14 1 ]
Como resultado se obtiene

A =
16 3 2 13
5 10 11 8
9 6 7 12
4 15 14 1
Una vez introducida una matriz, queda guardada en el entorno de

trabajo de MATLAB.
La matriz A es un cuadrado mágico: Todas sus filas, columnas y
diagonales suman lo mismo. Para comprobarlo hacemos
sum (A)
ans =
34 34 34 34
El comando sum(A) calcula la suma de las columnas de la matriz

A, obteniéndose un vector de dimensión el número de columnas.
Para calcular la suma de las filas, podemos calcular la transpuesta

de la matriz.
A’
obteniendo
ans =
16 5 9 4
3 10 6 15
2 11 7 14
13 8 12 1
la suma de las filas, en formato vector columna es

sum (A ’ ) ’
ans =
34
34
34
34
La función diag permite obtener un vector con los elementos de la

diagonal principal.
d i a g (A)
Se obtiene
ans =
16
10
7
1
y la suma de los elementos de la diagonal principal es

sum ( d i a g (A) )
obteniéndose
ans =
34
La antidiagonal de una matriz no suele ser muy importante, por lo

que no hay ninguna función para extraerla. No obstante, puede
invertirse la disposición de las columnas de la matriz con la función
fliplr, ası́ la suma de la antidiagonal es
sum ( d i a g ( f l i p l r (A) ) )
ans =
34
Otra forma de obtener la suma de los elemento de la antidiagonal

es sumando elemento a elemento.
Un elemento de la matriz A se referencia como A(i,j), siendo i la

fila y j la columna. La suma de la antidiagonal podrı́a haberse
obtenido también como sigue:
A ( 1 , 4 )+A ( 2 , 3 )+A ( 3 , 2 )+A ( 4 , 1 )
ans =
34
También es posible acceder a cada elemento de una matriz con un

solo ı́ndice, ası́ A(k) corresponde al elemento k de un vector
ficticio que se formara colocando las columnas de la matrix A una
debajo de otra: Comprobar que A(4,2) y A(8) corresponden al
mismo elemento de la matriz A.
Si se intenta acceder a un elemento que excede las dimensiones de

la matriz, se obtiene un error
t = A( 4 , 5 )
Index exceeds matrix dimensions .
Si se inicializa un elemento que excede las dimensiones de la

matriz, la matriz se acomoda en dimensión al nuevo elemento, con
el resto de nuevos elementos inicializados a cero.
X = A;
X ( 4 , 5 ) = 17
X =
16 3 2 13 0
5 10 11 8 0
9 6 7 12 0
4 15 14 1 17
El operador :
El operador : es uno de los más importantes de MATLAB. Tiene

diferentes utilidades. La expresión
1:10
indica un vector que contiene los números enteros desde 1 hasta

10.
1 2 3 4 5 6 7 8 9 10
Para obtener un espaciado no unitario, se utiliza un incremento.

100: −7:50
es
100 93 86 79 72 65 58 51
y
0: pi /4: pi
es
0 0.7854 1.5708 2.3562 3.1416
El operador :
Cuando el operador : aparece en los subı́ndices de una matriz se

refiere a las filas o columnas y permite extraer submatrices. Por
ejemplo, A(1:k,j) es el vector formado por los primeros k
elementos de la columna j de la matriz A y
sum (A ( 1 : 4 , 4 ) )
calcula la suma de todos los elementos de la cuarta columna. Otra

forma más compacta y elegante de hacer lo mismo es
sum (A ( : , end ) )
los dos puntos : (sin otros números) significan todas las filas y end
se refier a la última columna.
Pregunta: ¿Qué esta calculando la siguiente expresión?
sum (A( end , : ) )
La función magic
Matlab dispone de una función magic que permite calcular

cuadrados mágicos
Haciendo
B = magic ( 4 )
B =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
La matriz obtenida es casi la misma que la matriz de Dürer, solo se

diferencia en que las columnas 2 y 3 están intercambiadas. Se pude
obtener de nuevo la matriz de Dürer haciendo la siguiente
operación
A = B(: ,[1 3 2 4])
A =
16 3 2 13
5 10 11 8
9 6 7 12
4 15 14 1
Expresiones
Al igual que muchos otros lenguajes de programación, MATLAB

dispone de expresiones matemáticas, pero al contrario que en la
mayorı́a de los lenguajes de programación, estas expresiones hacen
referencia a matrices.
Los bloques constructivos de las expresiones son
Variables
Números
Operadores
Funciones
Variables
MATLAB no requiere ningún tipo de declaración o indicación de la

dimensión. Cuando MATLAB encuentra un nuevo nombre de variable la
crea automáticamente y reserva la cantidad de memoria necesaria. Si la
variable ya existe, MATLAB cambia su contenido y si es necesario
modifica la reserva de memoria.
Por ejemplo, la expresión
n u m e s t = 15
crea una matriz 1 por 1 llamada num_est y almacena el valor 25 en su

único elemento.
Los nombres de variables deben comenzar siempre por una letra y pueden
incluir otras letras, números y el sı́mbolo de subrayado, hasta un total de
31 caracteres.
Se distingue entre mayúsculas y minúsculas. A y a no son la misma
variable.
Para ver el contenido de una variable, simplemente escribir el nombre de
la variable.
Números
MATLAB utiliza notación decimal convencional, con punto decimal

opcional y signo + ó -
Es posible utilizar notación cientı́fica. La letra e especifica un factor de
escala de potencia de 10.
Los números imaginarios puros se especifican con la letra i ó j
Los siguientes ejemplos son todos números válidos en MATLAB
3 −99 0.0001
9.6397238 1 . 6 0 2 1 0 e −20 6 . 0 2 2 5 2 e23
1i −3.14159 j 3 e5i
Internamente, los números se almacenan en formato largo utilizando la

norma IEEE de punto flotante. La precisión es aproximadamente de 16
cifras decimales significativas y el rango está entre 10−308 y 10+308 .
Operadores
Las expresiones de MATLAB utilizan los operadores aritméticos

usuales, ası́ como sus reglas de precedencia
+ Suma
- Resta
* Producto
/ División
\ División por la izquierda
(se explicará)
^ Potencia
’ Transposición y conjugación compleja
( ) Orden de evaluación
Funciones
MATLAB proporciona un gran número de funciones matemáticas

elementales, por ejemplo, abs, sqrt, exp, sin, cos, etc.
Por defecto, MATLAB utiliza números complejos:
La raı́z cuadrada o el logaritmo de un número negativo no producen error,
sino que dan como resultado u número complejo.
Los argumentos de las funciones pueden ser números complejos
MATLAB proporciona también funciones avanzadas: Funciones de Bessel
o funciones gamma.
Una lista de todas las funciones elementales puede obtenerse con el
comando
help elfun
Funciones más avanzadas y funciones de matrices se obtienen con

help specfun
help elmat
Funciones
Algunas funciones están compiladas con el núcleo de MATLAB y son muy

rápidas y eficientes. Ej. sqrt, sin
Otras funciones están programadas en lenguaje de MATLAB (ficheros
m). Pueden verse y modificarse
Algunas funciones proporcionan el valor de ciertas constantes útiles.
pi 3.14159265
√
i √−1
j −1
eps Precisión relativa de punto flotante 2−52
realmin Número en punto flotante más pequeño 2−1022
realmax Número en punto flotante más grande (2 − )2+1023
Inf Infinito
NaN Not-a-Number (no es un número)
Infinito se obtiene al dividir un número no nulo por cero, o como
resultado de evaluar expresiones matemáticas bien definidas.
NaN se obtiene al tratar de evaluar expresiones como 0/0 ó Inf-Inf que no
tienen valores bien definidos
Los nombres de las funciones no están reservados. Puede definirse una
variable eps=1e-6 y utilizarla. Para restaurar su valor original
c l e a r eps
Expresiones
Ya se han visto varios ejemplos de expresiones. Algunos otros

ejemplos son los siguientes:
r h o = (1+ s q r t ( 5 ) ) /2
rho =
1.6180
a = a b s (3+4 i )
a =
5
z = s q r t ( b e s s e l k ( 4 / 3 , rho−i ) )
z =
0.3730+ 0 . 3 2 1 4 i
huge = e x p ( l o g ( r e a l m a x ) )
huge =
1 . 7 9 7 7 e +308
t o o b i g = p i ∗ huge
toobig =
Inf
Funciones para crear matrices
MATLAB proporciona cuatro funciones para generar matrices
zeros Matriz de ceros

ones Matriz de unos
rand Matriz de elementos uniformemente distribuidos
randn Matriz de elementos normalmente distribuidos
Funciones para crear matrices
Ejemplos
Z = zeros (2 ,4)
Z =
0 0 0 0
0 0 0 0
F = 5∗ o n e s ( 3 , 3 )
F =
5 5 5
5 5 5
5 5 5
N = f i x (10∗ rand (1 ,10) )

N =
4 9 4 4 8 5 2 6
8 0
R = randn (4 ,4)
R =
1.0668 0.2944 −0.6918 −1.4410
0.0593 −1.3362 0.8580 0.5711
−0.0956 0.7143 1.2540 −0.3999
−0.8323 1.6236 −1.5937 0.6900
El comando load
El comando load permite leer ficheros binarios que contienen matrices

generadas en sesiones anteriores de MATLAB
También permite leer ficheros de texto que contienen datos.
El fichero debe estar organizado como una tabla de numeros separados
por espacios, una lı́nea por cada fila, e igual número de elementos en
cada fila.
Ejemplo: Crear utilizando un editor de texto un fichero llamado
magik.dat que contenga los siguientes datos
16.0 3.0 2.0 13.0

5.0 10.0 11.0 8.0
9.0 6.0 7.0 12.0
4.0 15.0 14.0 1.0
El comando
l o a d magik . d a t
crea una variable llamada magik conteniendo la matriz.
Ficheros m
Los ficheros m son ficheros de texto que contienen código de MATLAB.

Para crear una matriz haciendo uso de un fichero m, editar un fichero
llamado magik.m con el siguiente texto
A = [ ...
16.0 3.0 2.0 13.0
5.0 10.0 11.0 8.0
9.0 6.0 7.0 12.0
4.0 15.0 14.0 1.0 ] ;
Ejecutar ahora el comando

magik
Comprobar que se ha creado la matriz A.
Concatenación
Es el proceso de unir dos o más matrices para formar otra matriz de

mayor dimensión
El operador concatenación es []
Ejemplo:
B = [A A+32; A+48 A+16]
B =
16 3 2 13 48 35 34 45
5 10 11 8 37 42 43 40
9 6 7 12 41 38 39 44
4 15 14 1 36 47 46 33
64 51 50 61 32 19 18 29
53 58 59 56 21 26 27 24
57 54 55 60 25 22 23 28
52 63 62 49 20 31 30 17
Comprobar que las columnas de esta matriz suman todas lo mismo, pero
no ocurre lo mismo con sus filas.
Borrado de filas y columnas
Se pueden borrar filas y columnas utilizando el operador [].

es la matriz vacı́a (concatenación de nada).
El proceso es sustituir una fila o una columna por la matriz vacı́a [].
Ejemplo: Borrado de la segunda columna de una matriz
X = A;
X(: ,2) = [ ]
X =
16 2 13
5 11 8
9 7 12
4 14 1
No se pueden borrar elementos, por que el resultado ya no serı́a una

matriz
X( 1 , 2 ) = [ ]
producirı́a un error.
Sin embargo, utilizando un único subı́ndice es posible borrar elementos,
aunque el resultado ya no serı́a una matriz, sino un vector.
X(2:2:10) = [ ]
X =
16 9 2 7 13 12 1
El comando format
Este comando controla el formato numérico de los resultados que muestra

MATLAB.
Afecta sólo a la presentación en pantalla, no al formato interno ni a los
cálculos.
Ejemplos:
x = [ 4 / 3 1 . 2 3 4 5 e −6]
format short
1.3333 0.0000
format short e
1 . 3 3 3 3 e +000 1 . 2 3 4 5 e −006
format short g
1.3333 1 . 2 3 4 5 e −006
format long
1.33333333333333 0.00000123450000
format long e
1 . 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 e +000 1.234500000000000 e
−006
format long g
1.33333333333333 1 . 2 3 4 5 e −006
El comando format
f o r m a t bank
1.33 0.00
format r a t
4/3 1/810045
format hex
3 ff5555555555555 3 eb4b6231abfd271
Además format compact suprime espacios y lı́neas en blanco. Para

obtener más control sobre la presentaciı́n en pantalla se pueden utilizar
las funciones sprintf y fprintf.
Para que no aparezca el resultado de un cálculo en la pantalla, se utiliza ;
A = magic ( 1 0 0 ) ;
Para dividir expresiones que no caben en una única lı́nea, se usan tres
puntos ...
s = 1 −1/2 + 1/3 −1/4 + 1/5 − 1/6 + 1/7 . . .
− 1/8 + 1/9 − 1/10 + 1/11 − 1 / 1 2 ;
Comandos de edición en pantalla
↑ ctrl-p Comando anterior

↓ ctrl-n Comando siguiente
← ctrl-b Carácter atrás
→ ctrl-f Carácter adelante
ctrl-→ ctrl-r Palabra adelante
ctrl-← ctrl-l Patabra atrás
home ctrl-a Ir a comienzo de lı́nea
end ctrl-e Ir a fin de lı́nea
esc ctrl-u Borrar lı́nea
del ctrl-d Borrar carácter actual
backspace ctrl-h Borrar carácter anterior
ctrl-k Borrar hasta fin de lı́nea
Gráficos
MATLAB dispone de recursos para mostrar vectores y matrices en

gráficos, ası́ como para incluir texto en los gráficos e imprimirlos.
La función básica de creación de gráficos es plot.
Si y es un vector, plot(y) dibuja un gráfico de los valores de los
elementos de y frente a sus ı́ndices.
Si x e y son dos vectores de igual tamaño, plot(x,y) dibuja un gráfico
de los valores de los elementos de y frente a los de x.
Ejemplo:
t = 0: pi /100:2∗ pi ;
y = sin ( t ) ;
plot (t , y)
Gráficos
Se pueden crear gráficos múltiples con una única llamada a plot.

MATLAB elige los colores automáticamente siguiendo una tabla
predefinida.
Ejemplo:
y2 = s i n ( t −.25) ;
y3 = s i n ( t −.5) ;
p l o t ( t , y , t , y2 , t , y3 )
Gráficos
Se puede especificar el color, tipo de lı́nea, y marcas con el comando

plot (x , y , ’ color style marker ’ )
color_style_marker es una cadena de tres caracteres, que indican

respectivamente el color, tipo de lı́nea y marca.
La letra que indica el color puede ser: ’c’, ’m’, ’y’, ’r’, ’g’, ’b’, ’w’,
’k’, que indican cyan, magenta, amarillo, rojo, verde, azul, blanco y
negro.
La letra que indica el tipo de lı́nea puede ser: ’-’ para lı́nea continua,
’--’ para lı́nea de trazos, ’:’ para lı́nea de puntos, ’-.’ para punto y
raya, ’none’ sin lı́nea.
Las marcas más comunes son ’+’, ’o’, ’*’ y ’x’.
Ejemplo: El comando
p l o t ( x , y , ’ y :+ ’ )
dibuja el gráfico en lı́nea continua amarilla y situa marcas ’+’ en cada

punto.
Ayuda en MATLAB
Existen varias formas de obtener ayuda en lı́nea de MATLAB.

El comando help
La ventana de ayuda
El escritorio de ayuda (MATLAB help desk)
Páginas de referencia en lı́nea
Página Web de The Mathworks, Inc. (www.mathworks.com)
El comando help
Es el comando más básico para obtener información de la sintaxis y

actuación de una función.
La información aparece directamente sobre la ventana de comandos.
Ejemplo:
h e l p magic
MAGIC Magic s q u a r e .
MAGIC(N) i s an N−by−N m a t r i x c o n s t r u c t e d from
t h e i n t e g e r s 1 t h r o u g h Nˆ2 w i t h e q u a l row ,
column , and d i a g o n a l sums .
P r o d u c e s v a l i d magic s q u a r e s f o r N =
1 ,3 ,4 ,5....
El nombre de la función siempre aparece en mayúsculas, pero en realidad

debe escribirse en minúsculas al llamar a la función
Las funciones están organizadas en grupos lógicos, ası́ como la estructura

de directorios de MATLAB.
Las funciones de álgebra lineal están en el directorio matfun. Para listar
todas las funciones de este grupo
h e l p matfun
Matrix f u n c t i o n s − numerical l i n e a r algebra .
Matrix a n a l y s i s .
norm − M a t r i x o r v e c t o r norm .
normest − E s t i m a t e t h e m a t r i x 2−norm
...
El comando help lista todos los grupos de funciones

help
matlab / g e n e r a l
matlab / ops
...
La ventana de ayuda
Disponible seleccionando la opción Help Window del menú Help o bien

pulsando la interrogación de la barra de menú.
Puede invocarse desde la ventana de comandos con helpwin
Para obtener ayuda sobre un comando helpwin comando
La información obtenida es la misma que con el comando help pero
permite hipertexto y navegación
El comando lookfor
Conveniente cuando buscamos una función pero no recordamos su

nombre.
Busca todas las funciones que en la primera lı́nea de texto de la ayuda
(lı́nea H1) contienen la palabra clave.
Ejemplo: Estamos buscando una función para invertir matrices, hacemos
help inverse
i n v e r s e .m n o t f o u n d .
entonces bucamos con lookfor

lookfor inverse
INVHILB I n v e r s e H i l b e r t m a t r i x .
ACOSH Inverse hyperbolic cosine .
ERFINV I n v e r s e o f t h e e r r o r f u n c t i o n .
INV Matrix i n v e r s e .
PINV Pseudoinverse .
IFFT Inverse d i s c r e t e Fourier transform .
IFFT2 Two−d i m e n s i o n a l i n v e r s e d i s c r e t e F o u r i e r
transform .
ICCEPS I n v e r s e c o m p l e x c e p s t r u m .
IDCT Inverse d i s c r e t e cosine transform .
Con la opción -all busca en todo el texto de la ayuda, no solo en H1.
El escritorio de ayuda (help desk)
El escritorio de ayuda de MATLAB permite acceder a mucha información

de referencia almacenada en el disco duro o en el CD-ROM en formato
HTML mediante un navegador.
Se accede a través de la opción Help Desk del menú Help.
También se accede escribiendo helpdesk en la ventana de comandos.
Para acceder a la página de referencia en formato HTML de un comando
especı́fico, se utiliza el comando doc. Ejemplo: doc eval.
Las páginas de referencia se encuentran también disponibles en formato
PDF y pueden ser consultadas e impresas con Acrobat Reader.
Finalmente, desde el escritorio de ayuda se puede acceder a la Página
Web the The MathWorks, Inc.
El Entorno de MATLAB
El entorno de MATLAB incluye el conjunto de variables definidas durante

una sesión de MATLAB y el conjunto de ficheros del disco que contienen
programas y datos y que permanecen entre sesiones.
El espacio de trabajo (workspace) es el área de memoria accesible desde
la lı́nea de comandos de MATLAB.
Los comandos who y whos muestran el contenido del espacio de trabajo,
who proporciona una lista reducida, whos incluye además información
sobre tamaño y almacenamiento.
whos
Name Size Bytes Class

A 4 x4 128 double array
D 5 x3 120 double array
M 10 x1 3816 c e l l array
S 1 x3 442 struct array
h 1 x11 22 char array
n 1 x1 8 double array
s 1 x5 10 char array
v 2 x5 20 char array
Grand t o t a l i s 471 e l e m e n t s u s i n g 4566 b y t e s .
Para borrar variables del espacio de trabajo, usar el comando clear.

c l e a r n o m bCurso
A. Herreros, E. Baeyens, DISA/EII (UVa) r e dev aProgramación
r i a b l e en Matlab y Simulink Curso 2010/2011 40/215
El comando save
Permite almacenar los contenidos del espacio de trabajo en un fichero

MAT (binario).
s a v e 15 o c t 0 2
salva el espacio de trabajo en el fichero 15oct02.mat. Para salvar

únicamente ciertas variables
s a v e 15 o c t 0 2 n o m b r e s v a r i a b l e s
Para recuperar el espacio de trabajo se utiliza el comando load.

l o a d 15 o c t 0 2
El formato MAT es binario y no puede leerse, si se desea un fichero que

pueda leerse pueden utilizarse las siguientes alternativas
-ascii Formato de texto de 8 bits.
-ascii -double Use Formato de texto de 16 bits.
-ascii -double -tabs Delimita los elementos de una matriz con tabuladores
-v4 Crea un fichero MAT de la versión 4
-append Añade datos a un fichero MAT ya existente
En formato texto no puede salvarse todo el espacio de trabajo de una vez,
y debe hacerse indicando el nombre de las variables.
La trayectoria de búsqueda
La trayectoria de búsqueda (search path) es la lista ordenada de

directorios en los que MATLAB va buscando las funciones.
El comando path muestra la trayectoria de búsqueda.
Si hubiera varios ficheros con el mismo nombre de función en diferentes
directorios, MATLAB ejecuta el primero que encuentra al seguir la
trayectoria de búsqueda.
Para modificar la trayectoria de búsqueda, ir a Set Path en el
menú File.
Manipulación de Ficheros
MATLAB dispone de los comandos dir, type, delete, cd, para

realizar las operaciones usuales de manipulación de ficheros de un
sistema operativo.
MATLAB MS-DOS UNIX VAX/VMS
dir dir ls dir
type type cat type
delete del ó erase rm delete
cd chdir cd set default
El comando diary
Crea un diario de la sesión MATLAB en un fichero de texto.

El fichero puede editarse con cualquier editor o procesador de textos.
Para crear un fichero llamado midiario.txt que contenga todos los
comandos de la sesión y sus resultados en la ventana de comandos, hacer
diary midiario . txt
si no se incluye ningún nombre de fichero, el diario de la sesión se

almacena por defecto en el fichero diary.
Para parar la grabación del diario
diary off
Para volver a activar/desactivar la grabación del diario

d i a r y on / o f f
Ejecución de programas externos
Para ejecutar programas externos a MATLAB desde la lı́nea de

comandos, se antepone el carácter de escape !. Por ejemplo, en
UNIX
! vi
Ejecuta el editor de texto visual.
Ejercicios 1
Fichero Aejer1.m : Las siguientes expresiones describen las
tensiones principales de contacto en las direcciones x, y y z que
aparecen entre dos esferas que se presionan entre sı́ con una fuerza
F.
" #
2 −1

z a z
σx = σy = −pmáx 1 − tan−1 (1 − v1 ) − 0,5 1 + 2
a z a
−pmáx
σz =
1 + z 2 /a2
siendo
1/3
3F (1 − v12 )/E1 + (1 − v22 )/E2

a =
8 1/d1 + 1/d2
3F
pmáx =
2πa2
vj son los coeficientes de Poisson, Ej los módulos de Young de
cada esfera y dj son los diámetros de las dos esferas.
Escribir las ecuaciones en notación de MATLAB y evaluarlas para
los siguientes valores: v1 = v2 = 0,3, E1 = E2 = 3 · 107 , d1 = 1,5,
d2 = 2,75, F = 100 lb. y z = 0,01 in.
Ejercicio 2
Fichero Aejer2.m : El número de carga de un rodamiento

hidrodinámico esta dado por la siguiente expresión:
p
π π 2 (1 − 2 ) + 162
NL =
(1 − 2 )2
siendo el coeficiente de excentricidad. Escribir la ecuación en

notación de Matlab y evaluarla para = 0,8.
Ejercicio 3
Fichero Aejer3.m : Un tubo largo con radio interior a y radio

exterior b y diferentes temperaturas en la superficie interior Ta y
en la exterior Tb está sometido a tensiones.
Las tensiones radial y tangencial se obtienen mediante las
siguientes ecuaciones:
a2
2
αE (Ta − Tb ) b b b
σr = − 1 ln − ln
2(1 − v ) ln(b/a) b − a
2 2 r 2 a r
a2 b2

αE (Ta − Tb ) b b
σt = 1− 2 + 1 ln − ln
2(1 − v ) ln(b/a) b −a 2 r 2 a r
siendo r la coordenada radial del tubo, E el módulo de Young del

material del tubo y α el coeficiente de dilatación. La distribución
de temperaturas a lo largo de la pared del tubo en la dirección
radial es:
(Ta − Tb ) ln(b/r )
T = Tb +
ln(b/a)
Escribir las ecuaciones en notación de Matlab y evaluarlas para
los siguientes valores: α = 1,2 · 10−5 , E = 3 · 107 , v = 0,3, Ta = 500,
Tb = 300, a = 0,25, b = 0,5, r = 0,375.
Ejercicio 4
Fichero Aejer4.m : La fórmula siguiente, propuesta por el

matemático S. Ramanujan permite aproximar el valor de π.
√ N→∞
1 8 X (4n)!(1103 + 26390n)
=
π 9801 (n!)4 3964n
n=0
Evaluar la formula anterior para N = 0, 1, 2, 3 y comparar el

resultado obtenido con el valor de π que proporciona Matlab.
Para calcular el factorial, utilizar la función gamma que satisface
gamma(n+1)=n!.
Ejercicio 5
Fichero Aejer5.m : Introducir en el espacio de trabajo de

Matlab dos vectores a y b siendo aj = 2j − 1 y bj = 2j + 1,
j = 1, . . . , 7. Se pide:
1 Calcular la suma de a y b
2 Calcular la diferencia de a y b.
3 Calcular el producto aT b y el valor de su traza y determinante.
4 Calcular el producto ab T .
Ejercicio 6
Fichero Aejer6.m : Sea z=magic(5). Realizar las siguientes

operaciones ordenadamente y mostrar los resultados:
√
1 Dividir todos los elementos de la segunda columna por 3.
2 Sustituir la última fila por el resultado de sumarle los elementos de la
tercera fila.
3 Sustituir la primera columna por el resultado de multiplicarle los
elementos de la cuarta columna.
4 Hacer que todos los elementos de la diagonal principal sean 2.
5 Asignar el resultado obtenido a la variable q y mostrarla por pantalla.
6 Mostrar la diagonal principal de qq T .
7 Mostar el cuadrado de todos los elementos de la matriz q.
Ejercicio 7
Fichero Aejer7.m : En análisis de regresión lineal multivariante

aparece la siguiente cantidad:
H = X (X T X )−1 X T
Sea  
17 31 5
 6 5 4 
X =
 19 28 9 

12 11 10
Calcular la diagonal de H.
Ejercicio 8
Fichero Aejer8.m : Dibujar el resultado de la suma de las

siguientes series para los rangos indicados de valores de τ . Utilizar
200 puntos para realizar la gráfica.
1 Onda cuadrada
∞
4X1 1 1
f (τ ) = sin(2(2k − 1)πτ ), − ≤τ ≤
π n 2 2
k=1
2 Diente de sierra
∞
1 1X1
f (τ ) = + sin(2kπτ ), −1 ≤ τ ≤ 1
2 π n
k=1
3 Diente de sierra
∞
1 1X1
f (τ ) = − sin(2kπτ ), −1 ≤ τ ≤ 1
2 π n
k=1
4 Onda triangular
∞
π 4X 1
f (τ ) = − cos((2k − 1)πτ ), −1 ≤ τ ≤ 1
2 π (2k − 1)2
k=1
Ejercicio 9
Fichero Aejer9.m : Dibujar las siguientes curvas. Utilizar axis

equal para una correcta visualización.
1 Cicloide (−π ≤ φ ≤ 3π, r = 0,5, 1, 1,5)
x = r φ − sin φ
y = r − cos φ
2 Lemniscata (−π/4 ≤ φ ≤ π/4)
p
x = cos φ 2 cos(2φ)
p
y = sin φ 2 cos(2φ)
3 Espiral (0 ≤ φ ≤ 6π)
de Arquı́medes
x = φ cos φ
y = φ sin φ
Logarı́tmica (k = 0,1)
x = e kφ cos φ
y = e kφ sin φ
Ejercicio 10
Fichero Aejer10.m : Dibujar las siguientes curvas. Utilizar axis

equal para una correcta visualización.
1 Cardioide (0 ≤ φ ≤ 2π)
x = 2 cos φ − cos 2φ
y = 2 sin φ − sin 2φ
2 Astroide (0 ≤ φ ≤ 2π)
x = 4 cos3 φ
y = 4 sin3 φ
3 Epicicloide (R = 3, a = 0,5, 1ó2, y 0 ≤ φ ≤ 2π)

x = (R + 1) cos φ − a cos(φ(R + 1))
y = (R + 1) sin φ − a sin(φ(R + 1))
4 Epicicloide (R = 2,5, a = 2, y 0 ≤ φ ≤ 6π)

x = (R + 1) cos φ − a cos(φ(R + 1))
y = (R + 1) sin φ − a sin(φ(R + 1))
Ejercicio 11
Fichero Aejer11.m : Dibujar las siguientes curvas

tridimensionales. Utilizar axis equal para visualizar
correctamente.
1 Hélice esférica (c = 5,0, 3 Senoide sobre esfera (a = 10,0,
0 ≤ t ≤ 10π) b = 1,0, c = 0,3, 0 ≤ t ≤ 2π)
p
x = sin(t/2c) cos(t) x = cos(t) b 2 − c 2 cos2 (at)
p
y = sin(t/2c) sin(t) y = sin(t) b 2 − c 2 cos2 (at)
z = cos(t/2c) z = c cos(at)
2 Senoide sobre cilindro (a = 10,0, 4 Espiral toroidal (a = 0,2, b = 0,8,

b = 1,0, c = 0,3, 0 ≤ t ≤ 2π) c = 20,0, 0 ≤ t ≤ 2π)
x = b cos(t) x = [b + a sin(ct)] cos(t)
y = b sin(t) y = [b + a sin(ct)] sin(t)
z = c cos(at) z = a cos(ct)
Contenidos
1 Introducción
13 Bibliografı́a
Introducción a entornos de trabajo (I)
Entornos de trabajo con Matlab:

Espacio de trabajo workspace.
Ficheros de escritura scripts (*.m).
Ficheros de funciones de Matlab (*.m) y compiladas.
Objetos desarrollados en Matlab y en Java.
Workspace en Matlab.
Uso de variables globales, scripts, funciones y objetos.
Ejemplo:
>> a = [ 1 , 2 ; 3 , 4 ] ;
>> whos
>> i n v ( a ) ;
Ficheros de escritura scripts:

Ficheros (*.m) con ordenes iguales a las dadas en el workspace.
Las variables que utiliza son las globales del workspace.
Útiles para repetir la misma operación varias veces.
Introducción a entornos de trabajo (II)
Ficheros (*.m) de funciones:

Son ficheros en lenguaje interpretado de Matlab.
Sus variables son locales por defecto.
Paso a la función del valor de las variables.
Funciones propias de Matlab y Toolbox.
Ejemplo:
function c = myfile1 (a , b)
c = s q r t ( ( a . ˆ 2 ) +(b . ˆ 2 ) )
Uso desde el workspace:
>> x = 7.5
>> y = 3.342
>> z = myfile (x , y)
>> whos
...
Ficheros de funciones compilador en C/C++ o FORTRAN. Contienen

cabecera especial para conexión con Matlab.
Clases y objetos definidos en Matlab y Java. Una clase es un tipo de dato
al que se puede asociar funciones propias y redefinir operadores.
>> s = t f ( ’ s ’ ) ; g e t ( s )
>> P= 1 / ( s +1) ; bode (P) ;
Tipos de datos (I)
Tipos de variables:
Clase Ejemplo Descripción
array [1,2;3,4]; 5+6i Datos virtual ordenado por ı́ndices
cuyos componentes son datos del
mismo tipo.
char ’Hola’ Array de caracteres (cada carácter
tiene 16 bits).
celda {17, ’hola’, eye(2)} Dato virtual ordenado por ı́ndices
cuyos componentes son arrays de dis-
tinto tipo.
struct a.dia=1; a.mes=’julio’ Dato virtual para almacenar datos
por campos (estructura). Cada cam-
po es un array o celda.
objeto tf(1,[1,1]) Datos definido por el usuario con base
a una estructura y con funciones aso-
ciadas.
Tipos de datos (II)
Operadores:
Oper. aritméticos Oper. de relación
+ Suma. > Menor que
- Resta. > Mayor que
.* Multiplicación. <= Menor que o igual a
./ División derecha. >= Mayor que o igual a
.\ División izquierda. == Igual a
: Operador dos puntos. = No igual a
.^ Potencia.
.’ Transpuesta.
’ Conjugada transpuesta.
* Multiplicación de matrices. Operadores lógicos.
/ División derecha de matrices. & Y
\ División izquierda de matrices. | OR
^ Potencia de matrices. ~ NO
Tipos de datos (III)
Operaciones aritméticas en el workspace o Ascript1.m:

>> a = [ 1 , 2 ; 3 , 4 ] ; b = [ 4 , 5 ; 6 , 7 ] ; >> c= a ∗b
>> c= 3∗ a ...
... >> c= a . ∗ b
>> a ( 1 , : ) ∗b ( : , 1 )
...
Operaciones de relación en el workspace o Ascript1.m:

>> a = [ 1 , 2 , 3 ] ; b=[1 ,3 ,2]; >> a > b
>> a==b ...
... >> a = [ ] ; i s e m p t y ( a )
...
Operaciones lógicas en el workspace o Ascript1.m:
>> a = [ 1 , 2 , 3 ] ; b = [ 1 , 0 , 3 ] ; >> a&b
>> a==b ...
... >> ˜ a
>> a | b ...
...
Tipo de datos (IV): Valores especiales
Funciones del directorio elmat que devuelven valores importantes,

ans Variable a la que se asigna el resultado de una ex-
presión que no ha sido asignada.
eps Tolerancia con la que trabaja Matlab en sus cálculos.
realmax Mayor número en coma flotante que puede represen-
tar el computador.
realmin Menor número en coma flotante que puede repre-
sentar el computador.
pi 3.1415926535897...
i, j Números imaginarios puros.
Inf Infinito. Se obtiene de divisiones entre cero.
NaN Indeterminación. Se obtiene de divisiones 0/0,
inf/inf o n/0 cuando n es imaginario.
flop Cuenta las operaciones en coma flotante realizadas.
version Indica la versión de Matlab usada.
Tipo de datos (V): Valores especiales
En el workspace:
>> 3+2 >> a= 5+3∗ i >> a= 0/0
... ... ...
>> p i ∗3 >> a= i ∗(4+3∗ i ) >> a= NaN∗3
... ... ...
>> r e a l m a x >> a= 3/0 >> a= 3∗ I n f
... ... ...
Sentencias de control.
Sentencias de control en Matlab:

if, else y elseif: Ejecuta un grupo de sentencias basándose en
condiciones lógicas.
switch, case y otherwise: Ejecuta diferentes grupos de sentencias en
función de condiciones lógicas.
while: Ejecuta un número de sentencias de forma indefinida en función de
una sentencia lógica.
for: Ejecuta un número de sentencias un número determinado de veces.
try...catch: Cambia el control de flujo en función de los posibles errores
producidos.
break: Termina de forma directa la realización de un bucle for o while.
return: Sale de la función.
Nota: Los bucles for y while pueden ser modificados por código
vectorizado para aumentar la velocidad de ejecución.
Sentencia de control if, else y elseif.
Forma general Asript2.m,
if n < 0
% Si n negativo error .
if s e n t l ó g 1 ,
d i s p ( ’ Entrada debe se p o s i t i v a ’ ) ;
% bloque 1
e l s e i f rem ( n , 2 ) == 0
e l s e i f s e n t l ó g 2
% Si es par se d i v i d e entre 2.
,
A = n /2;
% bloque 2
else
else
% Si es impar se incrementa y d i v i d e
% bloque 3
.
end
A = ( n+1) / 2 ;
end
Sentencia de control switch, case y otherwise.
Formulación general Ascript3.m,
s w i t c h input num
switch expression
c a s e { −1 , −2, −3}
case value1
d i s p ( ’−1 ó −2 ó −3 ’ ) ;
% bloque 1
case 0
case value2
disp ( ’ cero ’ ) ;
% b l o q u e −2
c a s e { 1 , 2 , 3}
. . .
d i s p ( ’ 1 ó 2 ó 3 ’ ) ;
otherwise
otherwise
% b l o q u e −n
disp ( ’ otro valor ’ ) ;
end
end
Sentencia de control while y for.
n = 1;
w h i l e e x p r e s i ó n
w h i l e p r o d ( 1 : n ) < 1 e100 ,
% bloque
n = n + 1;
end
end
f o r ı́ n d i c e= i n i c i o : p a s o : f i n , for i i = 2:6 ,
% bloque x ( i i ) = 2∗ x ( i i −1) ;
end end
Sentencia de control: break, try-catch y return
Sentencia break:
Sirve para salir de forma automática del último bucle while o for abierto
sin tener en cuenta la condición o ı́ndice de salida.
Sentencia de control try, catch:
Formulación general,
try bloque-1 catch bloque-2 end
Ejecuta el bloque-1 mientras no haya un error. Si se produce un error en
bloque-1 se ejecuta bloque-2.
Sentencia return:
Se sale de la función en la que se trabaja.
Si se llega al final de la función (*.m), Matlab sale de ella
automáticamente.
Funciones en matlab (I): Cabecera
Se define el nombre y las variables de entrada y salida:

function c = myfile (a , b)
Las lı́neas de comentario se inician con el carácter %.

Las lı́neas de comentario posteriores a la función son de ayuda.
function c = myfile (a , b)
% Output : c . I n p u t : a y b
Usando la función help.

>> h e l p m y f i l e
Output : c . I n p u t : a y b
Funciones en matlab (II): Variables de entrada
Variables de entrada-salida:
Libertad en su número. La variable nargin y nargout indican su número.
Variables locales por defecto sin tipo determinado.
Ejemplo: a, b y c pueden ser double o array myfile2.m.
function c = myfile2 (a , b , c)
% Output : c . I n p u t : a , b y c
i f n a r g i n <2 ,
error ( ’c = myfile (a , b , [ c ]) ’ ) ;
e l s e i f n a r g i n ==2,
c= s q r t ( a .ˆ2+ b . ˆ 2 ) ;
else
c= s q r t ( a .ˆ2+ b .ˆ2+ c . ˆ 2 ) ;
end
Funciones en matlab (III): Celdas como Variables de entrada
Una celda varargin como variable de entrada y otra varargout como

salida. Ejemplo myfile3.m:
function c = myfile3 ( varargin )
% Output : c . I n p u t : a , b y c
i f n a r g i n <2 ,
error ( ’c = myfile (a , b , [ c ]) ’ ) ;
e l s e i f n a r g i n ==2,
c= s q r t ( v a r a r g i n {1}.ˆ2+ v a r a r g i n { 2 } . ˆ 2 ) ;
else
c= s q r t ( v a r a r g i n {1}.ˆ2+ v a r a r g i n {2}.ˆ2+ v a r a r g i n
{3}.ˆ2) ;
end
Funciones en matlab (IV): Variables globales y estáticas
Variable estática: No se pierde su valor y sólo se puede usar en la función

definida.
Variable global: No se pierde su valor y se puede usar en todas las
funciones donde esté definida. Debe estar definida en el workspace.
Ejemplo función myfile4.m:
function c = myfile4 (a)
% Output : c . I n p u t : a
global P;
i f i s e m p t y (P) , P=1; end
c= P∗ a ; P= P+1;
Variable estática:
>> P= 1 0 ; z= m y f i l e ( 3 ) ; % r e p e t i r
Variable global:
>> g l o b a l P ; P=10; z= m y f i l e ( 3 ) ; % r e p e t i r
Funciones en matlab (V): Sub-funciones y funciones privadas
Varias funciones contenidas en un mismo fichero.

La función principal es la primera. Equivalente a la función main del
lenguaje C.
Ejemplo myfile5.m:
function c = myfile5 (a , b)
% Output : c . I n p u t : a y b
c= f u n ( a , b ) ;
f u n c t i o n z= f u n ( x , y )
z=s q r t ( x .ˆ2+ y . ˆ 2 ) ;
Funciones privadas: Están en sub-carpeta private y sólo se pueden usar

por las funciones de la carpeta.
Prioridades en la llamada a funciones: Sub-función, función en misma
carpeta, función en carpeta private,función en las carpetas del path.
Funciones en matlab (VI):Evaluación de cadenas eval() y feval()
Son el equivalente a los punteros a funciones de lenguaje C.

eval(): Una cadena de caracteres es interpretada como orden,
>> cad= ’ m y f i l e ’ ; a= 1 ;
>> c= e v a l ( [ cad , ’ ( a , ’ , i n t 2 s t r ( 2 ) , ’ ) ’ ] ) ;
feval: Se llama a una función por su nombre o comodı́n Ascript6.m,

>> cad= ’ m y f i l e ’ ; a= 1 , b =2;
>> c= f e v a l ( cad , a , b) ;
>> cad= @ m y f i l e ; a =1 , b =1;
>> c= f e v a l ( cad , a , b) ;
>> cad= @( x , y ) s q r t ( x .ˆ2+ y . ˆ 2 ) ;
>> c= f e v a l ( cad , a , b) ;
Entrada de datos, pausas y llamadas a la shell.
input(): Introducción de datos Ascript7.m,

n= i n p u t ( ’ I n t r . d a t o : ’ ) ; % Do ub le .
n= i n p u t ( ’ I n t r . d a t o : ’ , ’ s ’ ) ; % Cadena de c a r a c t e r e s .
ginput(): Localizar puntos en una gráfica con el ratón,

figure ; plot (1:1000) ;
[ x , y ]= g i n p u t ( 1 ) % l o c a l i z a r un p u n t o x , y en g r á f i c a .
[ x , y , t e c l a ]= g i n p u t ( 1 ) % t e c l a da l a t e c l a d e l r a t ó n
usada .
pause(): La función para el programa durante un periodo de tiempo,

p a u s e ( n ) ; % Para e l p r o g ra m a d u r a n t e n s e g u n d o s .
p a u s e ; % Para e l p r o gram a h a s t a que s e p u l s e una t e c l a .
Llamada a la shell (MS-DOS o LINUX): Iniciar sentencia con !,

! c o p y f i c h 1 . c f i c h 2 c . % S i e l s i s t e m a f u e r a msdos
Funciones save y load.
save: Grabar datos en ficheros Ascript8.m,

-mat: Código binario (por defecto).
-ascii: Código ASCII.
-append: Graba al final del fichero.
>> s a v e d a t o s . d a t a b c % Graba ’ d a t o s . dat ’ l a s

variables a b c
>> a= r a n d ( 1 0 , 5 ) ;
>> s a v e − a s c i i −append d a t o s . d a t a %Graba a l f i n a l del
f i c h e r o en c ó d i g o A S C I I .
load: Recupera las variables guardadas con la sentencia save.

>> l o a d d a t o s . d a t % R e c u p e r a l a s v a r i a b l e s de d a t o s . d a t
Funciones de librerı́a entrada/salida de lenguaje C (I)
Algunas de las funciones de entrada/salida:
Clase Función Descripción

Abrir/Cerrar fopen() Abrir fichero.
fclose() Cerrar fichero.
Binarios I/O fread() Lectura binaria de fichero (defecto enteros).
fwrite() Escritura binaria en fichero (defecto enteros).
Con formato fscanf() Lectura con formato de fichero.
fprintf() Escritura con formato en fichero.
Conversión cadenas sscanf() Lee de cadena con un determinado formato.
sprintf() Escribe en cadena con formato.
Funciones de librerı́a entrada/salida de lenguaje C (II)
Ejemplos de apertura y cierre. Permisos:

’r’: Lectura. Puntero al inicio del fichero.
’w’: Escritura. Se borra el fichero si existe.
’a’: Añadir. Puntero al final del fichero.
’r+’: Lectura/escritura. Puntero al inicio.
>> f i c = f o p e n ( ’ f i c h . d a t ’ , ’ r ’ ) ; % Abre f i c h e r o p a r a
lectura .
>> f c l o s e ( f i c ) ; % C i e r r a f i c h e r o ’ f i c h . dat ’ .
>> f c l o s e ( ’ a l l ’ ) ; % C i e r r a t o d o s l o s f i c h e r o s .
Principales usos:
Ficheros de texto con formato
Ficheros binarios para guardar o extraer matrices en su forma vectorial.
Funciones de librerı́a entrada/salida de lenguaje C (III)
Ejemplo Ascript9.m:
>> a= r a n d ( 3 , 3 )
>> f i c h= f o p e n ( ’ d a t o s . t x t ’ , ’w ’ ) ; % G u a r d a r en t e x t o
>> f p r i n t f ( f i c h , ’ %.2 f %.2 f %.2 f \n ’ , a ) ;
>> fclose ( fich ) ;
>> f i c h= f o p e n ( ’ d a t o s . t x t ’ , ’ r ’ ) ; % R e c u p e r a r de f i c h e r o
texto
>> b= f s c a n f ( f i c h , ’ %f ’ )
>> f c l o s e ( f i c h ) ;
>> f i c h= f o p e n ( ’ d a t o s . t x t ’ , ’w ’ ) ; % G u a r d a r en b i n á r i o ,
f o r m a t o r e a l ∗4
>> f w r i t e ( f i c h , a , ’ r e a l ∗4 ’ ) ;
>> f c l o s e ( f i c h ) ;
>> f i c h= f o p e n ( ’ d a t o s . t x t ’ , ’ r ’ ) ; % R e c u p e r a r en b i n á r i o
>> b= f r e a d ( f i c h , i n f , ’ r e a l ∗4 ’ )
>> f c l o s e ( f i c h ) ;
Prácticas de funciones y sentencias de control (I).
Fichero Bejer1.m : Generar una función (*.m) para obtener las

siguientes series matemáticas. Los argumentos son tres: El primero es el
nombre de la serie deseada (obligatorio). El segundo es el número de
datos de τ , por defecto 200 (opcional). El tercero es lı́mite superior de
sumatorio, por defecto 1000 (opcional). Si el número de argumentos de
salida es uno se devuelve los datos, si es cero se dibuja la gráfica
correspondiente.
Señal cuadrada:
4 X 1 1 1
f (τ ) = sin(2nπτ ) − ≤τ ≤
π n=1,3,5,...
n 2 2
.
Dientes de sierra:
1 1X1
f (τ ) = + sin(2nπτ ) −1≤τ ≤1
2 π n=1 n
.
Señal triangular:
π 4X 1
f (τ ) = − cos((2n − 1)πτ ) −1≤τ ≤1
2 π n=1 (2n − 1)2
.
Prácticas de funciones y sentencias de control (II)
Fichero Bejer2.m : El desplazamiento de una onda propagada a lo

largo de una cuerda tiene una velocidad inicial cero y un deplazamiento
inicial,
{u(η, 0) = ηa | 0 ≤ η ≤ a} {u(η, 0) = 1−η 1−a
| a ≤ η ≤ 1},
siendo su ecuación,PN→∞ sin nπa
2
u(η, τ ) = aπ(1−a) n=1 n3
sin(nπτ ) cos(nπη).
Crear una función *.m para mostrar en gráfico u(η, τ ). La entrada de la
función será el valor de a, opcional defecto a = 0,25, el de N, opcional
defecto N = 50, y el de ∆τ , opcional defecto ∆τ = 0,05, donde
0 ≤ τ ≤ 2. La función dibuja la gráfica si el usuario no pide variables de
salida y devuelve el valor de u(η, τ ) sin dibujar la gráfica en caso
contrario.
Contenidos
1 Introducción
13 Bibliografı́a
Optimización de programas: Indexado de arrays y celdas (I)
Para la optimización de un programa con matlab se debe reducir el

número de bucles y cambiarlo por álgebra matricial.
Formato externo: Filas y columnas. Formato interno: vector de columnas,
Ascript10.m.
>> a= [ 1 , 2 , 3 ; 4 , 5 , 6 ] ;
>> a ( 2 , 1 ) , a ( 2 ) ,
Llamada parcial a un array, end cuenta el número de filas o columnas,

>> i i = 1 : 2 : 3 ; % v e c t o r de 1 a 3 con p a s o 2 .
>> a (1 , i i ) % primera f i l a , columnas i i
>> a ( 1 , 2 : end ) % p r i m e r a f i l a , c o l u m n a s de 2 a l final
>> a ( 1 , : ) % primera f i l a , todas l a s columnas
Composición de arrays,
>> b= [ a ( : , 1 ) , [ 5 , 7 ] ’ ] % P r i m e r a columna de a y [ 5 , 7 ]
v e c t o r columna .
Optimización de programas: Indexado de arrays y celdas (II)
Borrado de matrices,
>> b ( : , 1 ) = [ ] ; % B o r r a d o de l a p r i m e r a columna .
Matrices ceros, unos y aleatorias,

>> a= z e r o s ( 2 , 3 ) ; b= o n e s ( 3 , 2 ) ; c= r a n d ( 2 , 3 ) ;
Espacios lineales y logarı́tmicos,

>> a= l i n s p a c e ( 1 , 1 0 , 1 0 0 ) ; % De 1 a 1 0 , 100 p u n t o s , p a s o
lineal
>> a= l o g s p a c e ( 1 , 5 , 1 0 0 ) ; % De 1 e1 a 1 e5 , 100 p u n t o s ,
paso l o g .
Funciones de tamaño y repetición.

>> [ n f i l , n c o l ]= s i z e ( a ) ; % Tamaño f i l a columna ,
>> n f i l = s i z e ( a , 1 ) ; % Tamaño f i l a .
>> ncomp= s i z e ( a ( : ) , 1 ) ; % Número de componentes ,
formato i n t e r n o .
>> b= re p m a t ( a , [ 3 , 1 ] ) ; % R e p e t i r m a t r i z ’ a ’ t r e s v e c e s
en columna .
Optimización del código de programas (I)
Inicialización de matrices como matrices cero.

Sustitución de bucles por productos matriciales, Ascript11.m
Función en diferentes puntos, y (n) = sin(n) ∗ n, 0 < n < 10, 100 puntos:
>> n=l i n s p a c e ( 0 , 1 0 , 1 0 0 ) ; y= s i n ( n ) . ∗ n ;
Sumatorio de función, y = 10
P
n=0 sin(n) ∗ n.
>> n= [ 0 : 1 0 ] ’ ; y= sum ( s i n ( n ) . ∗ n ) ;
Función de dos dimensiones en varios puntos,
y (i, j) = i 2 + j 2 + i ∗ j, i ∈ [0, 5], j ∈ [0, 7],
>> i i =0:5; j j = [ 0 : 7 ] ’ ;
>> s i i= s i z e ( i i ,2) ; s j j= s i z e ( jj ,1) ;
>> i i = r ep ma t ( i i , [ s j j , 1 ] ) ; j j = r e p m a t ( j j , [ 1 , s i i ] ) ;
>> [ i i , j j ]= m e s h g r i d ( i i , j j ) ; % e q u i v a l e n t e
>> y= i i .ˆ2+ j j .ˆ2+ i i . ∗ j j ;
Optimización del código de programas (II)
Sustitución de bucles por productos matriciales, Ascript11.m

FunciónPde una dimensiones con sumatorio,
y (i) = 10 2
n=1 n ∗ i + i, i ∈ [0, 5],
>> i i = 0 : 5 ; n = [ 1 : 1 0 ] ;
>> y= n∗ o n e s ( s i z e ( n ) ) ’ ∗ i i .ˆ2+ i i ;
Práctica de optimización de programas: Volver a escribir el código

de las práctica de generación de señales sin usar bucles, Ficheros
Bejer1bis.m, Bejer2bis.m.
Matrices tri-dimensionales (I)
Se componen de filas, columnas y páginas.

Generación de matrices tridimensionales, Ascript12.m
>> a =[1 ,2;3 ,4]; % M a t r i z de d o s d i m e n s i o n e s .
>> a ( : , : , 2 )= [ 5 , 6 ; 7 , 8 ] ; % M a t r i z de t r e s d i m e n s i o n e s .
>> a= c a t ( 3 , [ 2 , 3 ; 4 , 5 ] , [ 5 , 6 ; 7 , 8 ] ) ; % e n c a d e n a en dim 3
>> a= re pm a t ( [ 2 , 3 ; 4 , 5 ] , [ 1 , 1 , 2 ] ) ; % r e p i t e en p á g i n a s
Re-dimensión: El array es tomado como vector y re-dimesionado,

>> a= r e s h a p e ( a , [ 2 , 4 ] ) ; % C o n v i e r t e d o s p á g i n a s a
c u a t r o columnas .
Borrado de parte de la matriz,

>> a ( : , : , 2 ) = [ ] ; % B o r r a d o de l a p á g i n a 3 .
Matrices tri-dimensionales (II)
Eliminación de dimensiones,
>> b= s q u e e z e ( a ( : , 1 , 1 ) ) ; % Se o b t i e n e un v e c t o r dim
(2∗1)
>> b= s q u e e z e ( a ( 1 , : , 1 ) ) ; % Se o b t i e n e un v e c t o r dim
(1∗2)
>> b= s q u e e z e ( a ( 1 , 1 , : ) ) ; % Se o b t i e n e un v e c t o r dim
(2∗1)
Cambio de ı́ndices en dimensiones,

>> b= p e r m u t e ( a , [ 2 , 1 , 3 ] ) ; % L a s f i l a s p a s a n a s e r
columnas .
>> a= i p e r m u t e ( b , [ 2 , 1 , 3 ] ) ; % Es l a i n v e r s a de p e r m u t e .
Matrices multidimensionales (III)
Celdas multidimensionales: Se puede trabajar con ellas de forma similar a

como se trabaja con las matrices.
>> A= { [ 1 , 2 ; 3 , 4 ] , ’ h o l a ’ ; [ 1 , 2 , 3 ] , ’ 2 ’ } ; % c e l d a de dim
(2∗2)
>> B= { ’ h o l a ’ , [ 1 , 2 , 3 ] ; ’ 2 ’ , 2 } ; % c e l d a de dim ( 2 ∗ 2 )
>> C= c a t ( 3 , A , B) ; % c e l d a de dim ( 2 ∗ 2 ∗ 2 )
Estructuras multidimensionales: Se puede trabajar con ellas de la forma

similar a como se trabaja con matrices.
>> c l a s e ( 1 , 1 , 1 ) . alum= ’ p e p e ’ ; c l a s e ( 1 , 1 , 1 ) . n o t a =10;
>> c l a s e ( 1 , 1 , 2 ) . alum= ’ j u a n ’ ; c l a s e ( 1 , 1 , 2 ) . n o t a =10;
>> c l a s e= s q u e e z e ( c l a s e ) ; % Se r e d u c e a d o s d i m e n s i o n e s
.
>> c l a s e . alum % M u e s t r a l o s nombres de t o d o s l o s
alumnos .
Funciones para estructuras y celdas (I)
Funciones especificas para structuras.
Función Descripción
getfield() Muestra los campos de la estructura.
isfield() Verdadero si un campo de la estructura.
isstruct() Verdadero si es una estructura.
rmfield() Borra el campo marcado de la estructura.
setfield() Cambia los contenidos de campo.
struct() Crea o convierte en una matriz de estructuras.
struct2cell() Convierte una matriz de estructuras en celdas.
Funciones para estructuras y celdas (II)
Ejemplos de funciones para estructuras,

>> c l a s e ( 1 ) . alum= ’ p e p e ’ ; c l a s e ( 1 ) . n o t a =10;
>> c l a s e ( 2 ) . alum= ’ j u a n ’ ; c l a s e ( 2 ) . n o t a =10;
>> c l a s e ( 3 )= s t r u c t ( ’ alum ’ , ’ j o s é ’ , ’ n o t a ’ , 7 ) % O t r a
f o r m a de d e f i n i r
>> g e t f i e l d ( c l a s e ) % M u e s t r a l o s campos de c l a s e
>> i s s t r u c t ( c l a s e ) % A f i r m a t i v o
>> i s f i e l d ( c l a s e , ’ n o t a ’ ) % A f i r m a t i v o
>> r m f i e l d ( c l a s e , ’ n o t a ’ ) % E l i m i n a campo n o t a .
>> s e t f i e l d ( c l a s e , ’ alum ’ , ’ p e p e ’ ) ; % I n t r o d u c e ’ pepe ’
en campo alum
>> p= s t r u c 2 c e l l ( c l a s e )
>> % Pone un e l e m e n t o de s t r u c t en una columna de l a
celda .
>> % De un v e c t o r e s t r u c t u r a s a l e una m a t r i z de c e l d a s
Funciones para estructuras y celdas (III)
Funciones especificas de celdas.
Función Descripción
cell() Crea una matriz de celda.
cell2struct() Convierte celdas en estructuras.
celldisp() Muestra el contenido de la celda.
cellfun() Aplica una celda función a matriz.
cellplot() Muestra una gráfica de la celda.
iscell() Verdadero en caso de que sea celda.
num2cell() Conversión de matriz numérica en celda.
Funciones para estructuras y celdas (IV)
Ejemplos de funciones de estructuras.

>> a= c e l l ( 2 , 2 ) % Se c r e a una c e l d a v a cı́ a .
>> a={ ’ p e p e ’ , ’ j u a n ’ ; 1 0 , 1 0 } ; %Se l l e n a c e l d a
>> i s c e l l (a) % Afirmativo
>> c e l l d i s p ( a ) % M u e s t r a e l c o n t e n i d o de l a c e l d a
>> c e l l p l o t ( a ) % M u e s t r a e l c o n t e n i d o en v e n t a n a .
>> cellfun ( ’ i s r e a l ’ , a) % Diferentes funciones
aplicadas a celdas .
>> c e l l 2 s t r u c ( a , { ’ alum ’ , ’ n o t a ’ } ) % Pasa de c e l d a a
estructura .
>> % Toma l o s campos p o r f i l a s .
>> n u m 2 c e l l ( [ 1 , 2 ; 3 , 4 ] ) % C o n v i e r t e m a t r i z en c e l d a .
Prácticas con matrices, celdas, estructuras y ficheros
Escribir un fichero Fichero Bejer3.m las siguientes operaciones:

Generar una matriz aleatoria de dimensiones {10 × 5 × 20}.
Obtener la matriz correspondiente a la segunda página.
Obtener el vector correspondiente a la fila 2, columna 3.
Obtener una celda cuyos componentes sean los elementos de la matriz.
Agregar dicha celda al campo datos de una estructura. Introducir otro
campo llamado nombre que corresponda a una cadena de caracteres.
Salvar la matriz, celda y estructura en un fichero de nombre datos.dat.
Salvar los elementos de la matriz en un fichero binario usando fwrite().
Recuperar dichos datos e introducirlos en una matriz de dimensión
{5 × 10 × 20}.
Meter la primera página de esta matriz en un fichero de texto con formato
5 datos por lı́nea.
Recoger estos datos lı́nea a lı́nea y reconstruir la matriz.
Contenidos
1 Introducción
13 Bibliografı́a
Funciones para gráficas en dos dimensiones (I)
Función Comentario
figure Crea una figura
subplot Crea varios ejes en la misma figura
hold Superpone diferentes plots
plot Plot lineal
loglog Plot logarı́tmico
semilogx, semilogy Plot semilogarı́tmico en eje x e y
xlim, ylim , zlim Márgenes en cada uno de los ejes
tit, xlabel, ylabel Texto en tı́tulo y ejes
legend, text, gtext Añadir texto en figura
ginput Marcar posición en figura
grid, box Mallado y caja en figura
Funciones para gráficas en dos dimensiones (II)
bar, bar3, bar3h Gráficas de barras
errorbar Gráficas con barras que marcan el error
compass Gráficas en forma de compás
ezplot, ezpolar Gráfica sencillas de funciones
fplot Gráficas de funciones
hist, pareto Histograma y carta de pareto
pie, pie3 Pastel de dos o tres dimensiones
stem, stairts Gráficas con impulsos y escaleras
scatter, plotmatrix Gráficas de dispersión de datos y matrices
Ejemplos con gráficos de dos dimensiones, Escript1.m (I)
Barras:
>> x= − 2 . 9 : 0 . 2 : 2 . 9 ; b a r ( x , e x p (−x . ∗ x ) ) ;
>> b a r h ( x , e x p (−x . ∗ x ) ) ;
>> y= r o u n d ( r a n d ( 5 , 3 ) ∗ 1 0 ) ;
>> bar ( y , ’ group ’ ) ; bar ( y , ’ s t a c k ’ ) ;
Histogramas:
>> y= r a n d n ( 1 e4 , 1 ) ; hist (y) ; hist (y ,20) ;
Pasteles:
>> x = [ 1 , 3 , 0 . 5 , 2 . 5 , 2 ] ; p i e ( x ) ;
Escaleras:
>> x= − 3 : 0 . 1 : 3 ; s t a i r s ( x , e x p (−x . ˆ 2 ) ) ;
Barras con error:

>> x= − 4 : . 2 : 4 ; y= ( 1 / s q r t ( 2 ∗ p i ) ) ∗ e xp ( −( x . ˆ 2 ) / 2 ) ;
>> e=r a n d ( s i z e ( x ) ) / 1 0 ;
>> e r r o r b a r ( x , y , e ) ;
Ejemplos con gráficos de dos dimensiones, Escript1.m (II)
Puntos:
>> y=r a n d n ( 5 0 , 1 ) ; stem ( y ) ;
Histograma de los ángulos.

>> y= r a n d n ( 1 0 0 0 , 1 ) ∗ p i ; r o s e ( y ) ;
Representación de números complejos:

>> z= e i g ( r a n d n ( 2 0 , 2 0 ) ) ; compass ( z ) ;
>> f e a t h e r ( z ) ;
Gráficas para funciones y complementos (I), Escript2.m.
Gráficas funciones: plot() para números, ezplot(), fplot() para

funciones:
>> x= 0 : 0 . 0 5 : 1 0 ; y= s i n ( x ) . ∗ e x p ( −0.4∗ x ) ;
>> figure ;
>> subplot (3 ,1 ,1) ; plot (x , y) ; t i t l e ( ’ plot ’ ) ;
>> subplot (3 ,1 ,2) ;
>> e z p l o t ( ’ s i n ( x ) . ∗ e x p ( −0.4∗ x ) ’ , [ 0 , 1 0 ] ) ; t i t l e ( ’ e z p l o t
’);
>> s u b p l o t ( 3 , 1 , 3 ) ;
>> f p l o t ( ’ s i n ( x ) . ∗ e x p ( −0.4∗ x ) ’ , [ 0 , 1 0 ] ) ; t i t l e ( ’ f p l o t ’ )
;
subplot(n,m,p) divide la gráfica en n × m partes y va a la p.
Texto y ejes en las gráficas: Tı́tulos, legendas, cajas, mallado:
>> d i s p ( ’ Texto y e j e s en g r á f i c a s : ’ )
>> t= 0 : 0 . 1 : 2 ∗ p i ; r=s i n ( 2 ∗ t ) . ∗ c o s ( 2 ∗ t ) ;
>> f i g u r e ; subplot (2 ,1 ,1) ; polar ( t , r ) ;
>> t i t l e ( ’ polar ’ )
>> subplot (2 ,1 ,2) ;
>> f p l o t ( ’ [ s i n ( x ) , s i n ( 2 ∗ x ) , s i n ( 3 ∗ x ) ] ’ , [ 0 , 2 ∗ p i ] , ’− ’ , ’
o ’ , ’∗ ’ ) ;
>> t i t l e ( ’ f p l o t ’ )
>> l e g e n d ( ’ s i n ( x ) ’ , ’ s i n ( 2 ∗ x ) ’ , ’ s i n ( 3 ∗ x ) ’ ) ;
Gráficas para funciones y complementos (II), Escript2.m.
>> d i s p ( ’ Tı́ t u l o , nombre en e j e s , l e g e n d a : ’ )

>> x= l i n s p a c e ( 0 , 2 , 3 0 ) ; y= s i n ( x . ˆ 2 ) ; f i g u r e ; p l o t ( x , y ) ;
>> t e x t ( 1 , . 8 , ’ y=s i n ( x ˆ 2 ) ’ ) ; x l a b e l ( ’ E j e X ’ ) ; y l a b e l ( ’ E j e Y ’ )
;
>> t i t l e ( ’ G r á f i c o s e n o i d a l ’ ) ;
>> d i s p ( ’ S u b p l o t , tamaño de l e t r a , tamaño e j e s , c a j a , g r i d : ’

)
>> x = 0 : . 1 : 4 ∗ p i ; y= s i n ( x ) ; z=c o s ( x ) ;
>> f i g u r e ; s u b p l o t ( 1 , 2 , 1 ) ; p l o t ( x , y ) ;
>> a x i s ( [ 0 , 2 ∗ p i , − 1 , 1 ] ) ;
>> s e t ( gca , ’ F o n t S i z e ’ , 1 2 ) ;
>> g r i d on ; box on ;
>> t i t l e ( ’ s i n ( x ) ’ , ’ F o n t W e i g h t ’ , ’ b o l d ’ , ’ F o n t S i z e ’ , 1 2 ) ;
>> s u b p l o t ( 1 , 2 , 2 ) ; p l o t ( x , z ) ;
>> a x i s ( [ 0 , 2 ∗ p i , − 1 , 1 ] ) ; g r i d on ; box on
>> s e t ( gca , ’ F o n t S i z e ’ , 1 2 ) ;
>> t i t l e ( ’ c o s ( x ) ’ , ’ F o n t W e i g h t ’ , ’ b o l d ’ , ’ F o n t S i z e ’ , 1 2 ) ;
Funciones para gráficas en tres dimensiones.
plot3 Plot lineal en tres dimensiones
mesh, meshc, meshz Plot de mallados en tres dimensiones
surf, surfc, surfl Plot de superfiecie en tres dimensiones
meshgrid, ndgrid Preparación de datos para gráficas de superficie
hidden Ocultar lı́neas y superficies ocultas
contour, contour3 Curvas de nivel
trimesh, trisurf Plot de mallado triangular
scatter3, stem3 Diagramas de dispersión y impulsos en 3 dimensiones
slice Gráficos de volumen
surfnorm Normales de las superficies
quiver3 Puntos y normales en vectores
patch Parches de superficies
Ejemplos de gráficas en tres dimensiones, Escript3.m (I)
Gráfica de tres dimensiones por puntos:

>> t= 0 : p i / 5 0 : 1 0 ∗ p i ;
>> f i g u r e ; p l o t 3 ( s i n ( t ) , c o s ( t ) , t ) ; g r i d on ; a x i s s q u a r e
>> f i g u r e ; p l o t 3 ( s i n ( t ) , c o s ( t ) , t , ’− ’ , c o s ( t ) , s i n ( t ) , t , ’ ∗
’);
Gráfica de tres dimensiones por polı́gonos:

>> z = 0 : 0 . 0 1 : 8 ; x=c o s ( z ) ; y=s i n ( z ) ;
>> f i g u r e ; f i l l 3 ( x , y , z , ’ r ’ ) ;
Gráficas de tres dimensiones con barras:

>> figure ; y= c o o l ( 7 ) ;
>> subplot (1 ,3 ,1) ; bar3 ( y , 0 . 2 , ’ detached ’ ) ;
>> subplot (1 ,3 ,2) ; bar3 ( y , ’ grouped ’ ) ;
>> subplot (1 ,3 ,3) ; bar3 ( y , 0 . 1 , ’ stacked ’ ) ;
Gráficas de tres dimensiones con puntos con base:

>> f i g u r e ; x= l i n s p a c e ( 0 , 1 , 1 0 ) ;
>> y=x . / 2 ; z=s i n ( x )+s i n ( y ) ;
>> stem3 ( x , y , z , ’ f i l l ’ ) ;
Ejemplos de gráficas en tres dimensiones, Escript3.m (II)
Superficies tres dimensiones y contornos en dos y tres:

>> [ X , Y]= m e s h g r i d ( − 7 . 5 : . 5 : 7 . 5 ) ;
>> Z= s i n ( s q r t (X.ˆ2+Y . ˆ 2 ) ) . / s q r t (X.ˆ2+Y . ˆ 2 ) ;
>> s u r f (X , Y , Z ) ; f i g u r e ; s u r f c (X , Y , Z ) ;
>> f i g u r e ; s u r f l (X , Y , Z ) ;
>> contour (Z) ; contour3 (Z , 5 0 ) ;
Superficie con velocidad:

>> f i g u r e ; [ U , V ,W]= s u r f n o r m (X , Y , Z ) ;
>> q u i v e r 3 (X , Y , Z , U , V ,W, 0 . 5 ) ;
Contornos:
>> [ X , Y]= m e s h g r i d ( − 2 : . 2 : 2 , − 2 : . 2 : 3 ) ; Z= X . ∗ e x p (−X.ˆ2 −Y
.ˆ2) ;
>> c o n t o u r (X , Y , Z ) ; f i g u r e ; c o n t o u r (X , Y , Z , 5 0 ) ;
>> f i g u r e ; c o n t o u r f (X , Y , Z ) ;
Cambio de color y perspectiva:

>> f i g u r e ; s p h e r e ( 1 6 ) ; a x i s s q u a r e ; s h a d i n g f l a t ;
>> s e t ( gca , ’ Z l i m ’ , [ − 0 . 6 , 0 . 6 ] ) ; s e t ( g c f , ’ C o l o r ’ , ’w ’ ) ;
Ejemplos de gráficas en tres dimensiones, Escript3.m (III)
Rotación de la figura:
>> h= s u r f ( p e a k s ( 2 0 ) ) ; r o t a t e ( h , [ 1 , 0 , 0 ] , 1 5 ) ;
>> v i e w ( [ 1 0 , 1 0 ] ) ;
Mallado triangular de la base, no homogéneo. Superficie en función de

ese mallado:
>> f i g u r e ; x= r a n d ( 1 , 5 0 ) ; y= r a n d ( 1 , 5 0 ) ;
>> z= p e a k s ( 6 ∗ x −3 , 6∗ x −3) ;
>> t r i= delaunay (x , y ) ; trimesh ( t r i , x , y , z ) ;
>> figure ; trisurf ( tri ,x ,y , z) ;
Representación en cuatro dimensiones, la cuarta es el color:

>> f i g u r e ; l o a d wind ; c a v= c u r l ( x , y , z , u , v , w) ;
>> s l i c e ( x , y , z , cav , [ 9 0 , 1 3 4 ] , [ 5 9 ] , [ 0 ] ) ;
Prácticas funciones para gráficas
Escribir en un fichero Fichero Cejer1.m el código para obtener las

siguientes gráficas,
2 2 2
Visualizar sobre el rango −2 a 2 la función v = e −x −y −z .
3
Representar en el intervalo [−8, 8] la función f (x) = x 2x−4 .
Graficar sobre los mismos ejes las funciones bessel(1, x), bessel(2, x) y
bessel(3, x) para valores entre 0 y 12, separados uniformemente entre
sı́ dos décimas. Colocar tres leyendas y tres tipos de trazo diferentes
(normal, asteriscos y cı́rculos) respectivamente para las tres funciones.
Representar la curva en polares r = 4(1 + cos(a)) para a entre 0 y 2π
(cardiode). Representar también la curva en polares r = 3a para a entre
−4π y 4π (espiral).
Representar la curva alabeada de coordenadas paramétricas x = cos2 (t),
y = sin(t) cos(t) y z = sin(t) para t entre −4π y 4π.
Escribir en un fichero Fichero Cejer2.m el código para obtener las
siguientes gráficas,
Representar la superficie, su gráfico de malla y su gráfico de contorno
cuya ecuación es la siguiente:
2
−y 2
x = xe −x − 2 < x, y < 2
Representar en un gráfico de curvas de nivel con 20 lı́neas la superficie de

la ecuación z = sin(x) sin(y ) con −2 < x, y < 2.
Representar el paraboloide x 2 + y 2 seccionado por el plano z = 2.
Contenidos
1 Introducción
13 Bibliografı́a
Definición de clase y objeto
Una clase es un nuevo tipo de dato, a una estructura, para el que se

pueden definir funciones especificas y redefinir los operadores.
Un objeto es un caso particular de una clase.
Los campos de la estructura asociada a una clase se llamarán propiedades
de la clase, y las funciones asociadas a una clase funciones método.
>> s= t f ( ’ s ’ ) ; % C l a s e ’ t f ’ , o b j e t o ’ s ’ .
>> P= 1 / ( s +1) ; % O p e r a d o r ’+ ’ y ’ / ’ r e d e f i n i d o s p a r a P
>> K= zpk ( [ ] , [ − 1 , − 2 ] , 1 ) ; % C l a s e ’ zpk ’ , o b j e t o K
>> bode (P) ; %’ bode ’ método de l a c l a s e ’ t f ’
Caracterı́sticas de la programación a objeto:

Redefinición de operadores especı́ficos para la clase.
Datos encapsulados: Las propiedades de un objeto no son visibles y sólo
se puede acceder a ellas desde las funciones método de la clase.
Herencia: Una clase se puede crear a partir de otra, heredando todas sus
funciones método. Las clases tf, zpk y ss derivan de la clase lti.
Agregación: Un objeto puede contener otros objetos.
Toda la información de una clase, tf, está en el directorio asociado @tf.
Las propiedades de clase usada quedan en memoria. Se deben limpiar
para poder modificarlas,
>> c l e a r tf
Funciones método principales (I)
Constructor: Genera un objeto a partir de datos.

>> P= t f ( 1 , [ 1 , 2 , 3 ] ) ; % C o n s t r u c t o r ’ t f ’ , o b j e t o P .
>> K= zpk ( [ ] , [ − 1 , − 2 ] , 1 ) ; % C o n s t r u c t o r ’ zpk ’ , o b j e t o K
>> Pzpk= zpk (P) ; % P o b j e t o ’ t f ’ , Pzpk o b j e t o ’ zpk ’
>> i s a (P , ’ t f ’ ) % a f i r m a t i v o
>> i s a (P , ’ zpk ’ ) % n e g a t i v o
>> P % Llama a f u n c i ó n ’ d i s p l a y ’
Visualizador: Método display que muestra la información del objeto.

>> P % Llama a f u n c i ó n ’ d i s p l a y ’ de ’ t f ’
>> Pzpk % Llama a f u n c i ó n ’ d i s p l a y ’ de ’ zpk ’
Funciones método principales (II)
Obtención de información:
General: Método get(), muestra propiedades del objeto.
>> g e t (P)
Por ı́ndices: Método B=subref(A,S)
>> P . num{1} % A=P , S ( 1 ) . t y p e = ’ . ’ , S ( 1 ) . t y p e = ’ { } ’ ,
>> %S ( 1 ) . s u b s ={ ’num ’ } , S ( 2 ) . s u b s ={1}
Introducción de información:
General: Método set(), cambia propiedades del objeto.
>> s e t (P , ’ num ’ , [ 1 , 2 ] )
Por ı́ndices: Método A= subsasign(A,S,B)
>> P . num{1}= 1 % A=P , S ( 1 ) . t y p e = ’ . ’ , S ( 2 ) . t y p e = ’{} ’
>> %S ( 1 ) . s u b s ={ ’num ’ } , S ( 2 ) . s u b s ={1} , B=1
Redefinición de operadores (I)
Operación M-fichero Descripción

a + b plus(a,b) Suma
a - b minus(a,b) Resta
-a uminus(a) Menos unitario
+a uplus(a) Más unitario
a.*b times(a,b) Multiplicación por elemento
a*b mtimes(a,b) Multiplicación matricial
a./b rdivide(a,b) División derecha por elemento
a.\b ldivide(a,b) División izquierda por elemento
a/b mrdivide(a,b) División matricial derecha
Redefinición de operadores (II)

a\b mldivide(a,b) División matricial izquierda
a.^b power(a,b) Potencia por elemento
a^b mpower(a,b) Potencia matricial
a < b lt(a,b) Menor que
a > b gt(a,b) Mayor que
a <= b le(a,b) Menor que o igual a
a >= b ge(a,b) Mayor que o igual a
a ~= b ne(a,b) Distinto de
a == b eq(a,b) Igual a
a & b and(a,b) Y lógico
a | b or(a,b) O lógico
Redefinición de operadores (III)

~a not(a) NO lógico
a:d:b colon(a,d,b) Operador dos puntos
a:b colon(a,b)
a’ ctranspose(a) Traspuesta conjugada compleja
a.’ transpose(a) Matriz transpuesta
display(a) Visualización pantalla
[a b] horzcat(a,b,...) Concatenación horizontal
[a; b] vertcat(a,b,...) Concatenación vertical
a(s1,s2,...sn) subsref(a,s) Referencia por subı́ndices
a(s1,...,sn) = b subsasgn(a,s,b) Asignamiento por subı́ndices
(a) subsindex(a) Conversión al ser ı́ndice
Prioridades y ejemplos
Prioridades entre objetos ante métodos y operadores:

Un objeto creado tiene prioridad sobre una variable de Matlab,
>> P= 1 / ( s +1) ; % o p e r a d o r ’ / ’ y ’+ ’ de c l a s e ’ tf ’ .
Entre dos objetos creados hay que asignar prioridades,
>> i n f e r i o r t o ( ’ c l a s s 1 ’ , ’ c l a s s 2 ’ , ...)
>> s u p e r i o r t o ( ’ c l a s s 1 ’ , ’ c l a s s 2 ’ , ...)
Ejemplo de objetos, métodos y operadores:

>> s= t f ( ’ s ’ ) % C o n s t r u c t o r
>> P ( 1 )= 1 / ( s +1) ; % O p e r a d o r e s ’ / ’ , ’ + ’ , método ’
subsasign ’
>> P ( 2 )= 1 / ( s +2) ;
>> K= P ( 1 ) % método ’ s u b s r e f ’
Ejemplo: Una clase de polinomios (I)
Objetivos: Se pretende realizar una clase para trabajar con polinomios.

Para ello se definen las siguientes funciones método:
Método constructor polynom: Se crea un objeto a partir de los
coeficientes del polinomio.
Método double: El polinomio se podrá convertir a un vector.
Método display: El objeto se verá en la pantalla en forma de cadena de
caracteres.
Sobrecarga de operadores: Los operadores suma (+), resta (-) y
multiplicación (*) son redefinidos para polinomios.
Ejemplo: Una clase de polinomios (II)
Método constructor,
f u n c t i o n p = polynom ( a )
% polynom C o n s t r u c t o r de l a c l a s e polynom .
% p = polynom ( v ) c r e a un p o l i n o m i o de un v e c t o r .
% Los c o e f i c i e n t e e s t á n en o r d e n d e c r e c i e n t e
% de l a s p o t e n c i a s de x .
if n a r g i n == 0
p.c = [];
p = c l a s s ( p , ’ polynom ’ ) ;
e l s e i f i s a ( a , ’ polynom ’ )
p = a;
else
p.c = a (:) . ’;
p = c l a s s ( p , ’ polynom ’ ) ;
end
Ejemplo: Una clase de polinomios (III)
Método display:
function display (p)
% polynom \ d i s p l a y . Comando v e n t a n a p a r a v e r e l o b j e t o .
disp ( int2str (p . c) ) ;
Método double:
function c = double (p)
% polynom \ d o u b l e . C o n v i e r t e polynom a un v e c t o r d o u b l e .
% c = d o u b l e ( p ) . C o n v i e r t e un p o l i n o m i o en v e c t o r .
c = p.c;
Operador +:
function r = plus (p , q)
% polynom \ p l u s . D e f i n e p + q p a r a p o l i n o m i o s .
p = polynom ( p ) ; q = polynom ( q ) ;
k = length (q . c) − length (p . c) ;
r = polynom ( [ z e r o s ( 1 , k ) p . c ] + [ z e r o s (1 , − k ) q . c ] ) ;
Ejemplo: Una clase de polinomios (IV)
Operador -:
f u n c t i o n r = minus ( p , q )
% polynom \ minus . I m p l e m e n t a p − q e n t r e p o l i n o m i o s .
p = polynom ( p ) ; q = polynom ( q ) ;
k = length (q . c) − length (p . c) ;
r = polynom ( [ z e r o s ( 1 , k ) p . c ] − [ z e r o s (1 , − k ) q . c ] ) ;
Operador *:
f u n c t i o n r = mtimes ( p , q )
% polynom \ mtimes . I m p l e m e n t a p ∗ q e n t r e p o l i n o m i o s .
p = polynom ( p ) ;
q = polynom ( q ) ;
r = polynom ( c o n v ( p . c , q . c ) ) ;
Ejemplo de su uso en workspace:

>> p= polynom % C r e a un o b j e t o v a c i o
>> p= polynom ( p ) % D e v u e l v e e l o b j e t o que s e manda
>> p= polynom ( [ 1 , 2 , 3 ] ) % C r e a un o b j e t o p l l e n o
>> q= p+p
>> t= q−p
>> a= double (p)
Clases derivadas: Herencia (I)
Muchas veces se desea crear una nueva clase con las mismas propiedades
y funciones métodos que otra ya existente a la que se añaden nuevas
propiedades y funciones método.
Esto se puede conseguir añadiendo un objeto de la clase existente
ClasePadre en la definición de la nueva clase.
Los objetos de la nueva clase serán ObjetoHijo, y los de la clase
existente ObjetoPadre.
Un ObjetoHijo puede acceder a todos las funciones método de la
ClasePadre que no estén definidos en su clase.
La forma de definir un objeto hijo es la siguiente:
O b j e t o H i j o= c l a s s ( O b j e t o H i j o , ’ C l a s e H i j o ’ , O b j e t o P a d r e ) ;
Con esta definición Matlab crea un componente

ObjetoHijo.ClasePadre donde se guardará la información de la parte
del ObjetoHijo con las mismas propiedades que el ObjetoPadre.
Clases derivadas: Herencia (II)
Un objeto hijo puede recibir herencia de varios objetos padres,

O b j e t o H i j o= c l a s s ( O b j e t o H i j o , ’ C l a s e H i j o ’ , O b j e t o P a d r e 1 ,
ObjetoPadre2 ) ;
Una función método que no posea la ClaseHijo será buscada en las

funciones de la clase ClasePadre1 y de no ser encontrada entre las de la
clase ClasePadre2.
Un ejemplo muy sencillo de una clase derivada es el de una clase de
funciones, cuyas propiedades son:
Nombre de la función.
Polinomio caracterı́stico.
Está claro que esta clase funcion puede ser propuesta como derivada de
la clase polinomio polymon, añadiendo a la misma una propiedad donde
se escriba el nombre de la función.
Todas las funciones método de la clase polynom pueden ser usadas en la
clase funcion excepto el método constructor, el método display y el
subsref, que van a ser redefinidos.
Cuando los objetos funcion use funciones método de la clase polynom,
se está trabajando con la parte del objeto funcion heredada, y el
resultado de la operación podrá ser un objeto polynom o de otra clase ya
definida, pero nunca de la clase funcion.
Clases derivadas: Herencia (III)
Función método constructor de funcion. Código.

function p = funcion ( varargin )
% FUNCION C o n s t r u t o r de l a c l a s e f u n c i o n .
switch nargin
case 0
p o l y= polynom ;
p . nombre = ’ ’ ;
p = c l a s s (p , ’ funcion ’ , poly ) ;
case 1
i f i s a ( v a r a r g i n {1} , ’ f u n c i o n ’ )
p = varargin {1};
else
e r r o r ( ’ Tipo de a r g u m e n t o e r r ó n e o ’ ) ; end
case 2
i f i s c h a r ( v a r a r g i n {1}) ,
p . nombre= v a r a r g i n { 1 } ;
else
e r r o r ( ’ Arg : nombre , p o l i n o m i o ’ ) ; end
p o l y = polynom ( v a r a r g i n { 2 } ) ;
p = c l a s s (p , ’ funcion ’ , poly ) ;
otherwise
e r r o r ( ’ Número de a r g u m e n t o s e r r ó n e o ’ ) ; end
Clases derivadas: Herencia (IV)
Función método display. Código.

% POLYNOM/DISPLAY Comando v e n t a n a p a r a v e r e l o b j e t o .
disp ( ’ ’ ) ;
d i s p ( [ ’ F u n c i ó n ’ , p . nombre , ’ = ’ ] )
disp ( ’ ’ ) ;
disp ( [ ’ ’ char (p) ] ) ;
Ejemplos en el workspace:
>> p= f u n c i o n % O b j e t o f u n c i o n n u l o
>> p1= f u n c i o n ( ’ z e t a ’ , [ 1 , 2 , 3 ] )
>> % O b j e t o f u n c i o n con nombre y p a r á m e t r o s .
>> p2= f u n c i o n ( ’ e t a ’ , [ 2 , 3 , 4 ] )
>> p3= p1+p2
>> % Se u s a un método d e l p a d r e . E l r e s u l t a d o en un
o b j e t o polynom .
Clases derivadas: Herencia (V)
Función método subsref: Muestra por campos el nombre y polinomio de

la función, y por ı́ndice el valor de la función en un punto. Código.
function b = subsref (a , s )
% SUBSREF Muestra , p o r campos e l c o n t e n i d o d e l
% o b j e t o , p o r ı́ n d i c e s e l v a l o r en un c i e r t o p u n t o .
s w i t c h s . type ,
case ’ . ’ ,
switch s . subs
c a s e ’ nombre ’ ,
b= a . nombre ;
case ’ poly ’ ,
b= c h a r ( a . polynom ) ;
otherwise
e r r o r ( ’ Campos : nombre , p o l y . ’ ) ;
end
case ’ () ’ ,
i n d= s . s u b s { : } ;
b= a . polynom ( i n d ) ;
otherwise
e r r o r ( ’ Campo o ı́ n d i c e e r r ó n e o . ’ ) ;
end
Clases agregadas (I)
Una clase puede tener de componentes objetos de otras clases ya

definidas.
Con ello, no se heredan directamente sus funciones método, pero estas
funciones podrán ser usadas en la definición de las nuevas funciones
método.
Ejemplo: La clase transfer tiene las siguientes propiedades:
Polinomio del numerador.
Polinomio del denominador.
Está claro que se puede aprovechar la clase polynom para crear esta
nueva clase ya que sus dos componentes son polinomios.
Las funciones método de la nueva clase no tienen nada que ver con las de
polynom, pero en su construcción serán empleadas.
Las funciones método de la nueva clase son la función constructora,
display, subsref, plus, minus, mtimes y mrdivide.
Clases agregadas (II)
Función método constructor. Código.

function p = transfer ( varargin )
% FUNCION C o n s t r u t o r de l a c l a s e t r a n s f e r
% C r e a una f u n c i ó n de t r a n s f e r e n c i a c o m p u e s t a de
% d o s p o l i n o m i o s , uno en n u m e r a d o r y o t r o en
denominador .
switch nargin
case 0
p . num= polynom ; p . den= polynom ;
p = c l a s s (p , ’ t r a n s f e r ’ ) ; % Objeto nulo
case 1
i f i s a ( v a r a r g i n {1} , ’ t r a n s f e r ’ )
p = varargin {1}; % Objeto f u n c i o n
else
p . num= polynom ( v a r a r g i n { 1 } ) ; p . den= polynom ( 1 ) ;
p= c l a s s ( p , ’ t r a n s f e r ’ ) ; % O b j e t o s ó l o n u m e r ad o r
end
case 2
p . num= polynom ( v a r a r g i n { 1 } ) ; p . den= polynom ( v a r a r g i n
{2}) ;
p = c l a s s (p , ’ t r a n s f e r ’ ) ; % Objeto numerador y
denominador
otherwise
e r r o r ( ’ Número de a r g u m e n t o s e r r ó n e o ’ ) ;
end
Clases agregadas (III)
Función método display. Código:

% t r a n s f e r \ d i s p l a y . Comando v e n t a n a p a r a v e r e l o b j e t o .
num= c h a r ( p . num ) ;
den= c h a r ( p . den ) ;
disp ( ’ ’ ) ;
d i s p ( [ inputname (1) , ’ = ’ ] )
disp ( ’ ’ ) ;
d i s p ( [ num ] ) ;
d i s p ( r ep m a t ( ’− ’ , [ 1 , max ( [ s i z e ( num , 2 ) , s i z e ( den , 2 ) ] ) ] ) ) ;
d i s p ( den ) ;
>> g= t r a n s f e r ; % Objeto nulo
>> g= t r a n s f e r ( [ 1 , 2 , 3 ] ) % O b j e t o con num y den= 1 .
>> p= polynom ( [ 1 , 2 , 3 ] ) % O b j e t o polynom
>> g= t r a n s f e r ( [ 1 , 2 , 3 ] , [ 3 , 4 , 5 ] ) ; % O b j e t o con num y den
>> g= t r a n s f e r ( p , [ 1 , 2 , 3 ] ) ; % O b j e t o con num y den
Clases agregadas (IV)
Función método subsref. Código:

function b = subsref (a , s )
% t r a n s f e r \ s u b s r e f . Por campos , l a r e p r e s e n t a c i ó n d e l
objeto .
% Por ı́ n d i c e s , e l v a l o r de l a f u n c i ó n en un p u n t o .
s w i t c h s . type ,
case ’ . ’ ,
s w i t c h s . subs ,
c a s e ’ num ’ ,
b= c h a r ( a . num ) ; % p o l i n o m i o num
c a s e ’ den ’ ,
b= c h a r ( a . den ) ; % p o l i n o m i o den
otherwise
e r r o r ( ’ Campos : num , den ’ ) ;
end
case ’ () ’ ,
ind = s . subs { : } ;
b= a . num ( i n d ) . / a . den ( i n d ) ; % V a l o r en x
otherwise
e r r o r ( ’ Dar campo o v a l o r de x en p ( x ) ’ )
end
Clases agregadas (V)
Sobrecarga de operadores. Código:

function r = plus (p , q)
% t r a n s f e r \ plus . Define p + q para t r a n s f e r .
p = transfer (p) ;
q = transfer (q) ;
r . num= p . num∗q . den + p . den ∗q . num ;
r . den= p . den ∗q . den ;
r= c l a s s ( r , ’ t r a n s f e r ’ ) ;
f u n c t i o n r = minus ( p , q )
% t r a n s f e r \ minus . D e f i n e p − q p a r a t r a n s f e r .
p = transfer (p) ;
q = transfer (q) ;
r . num= p . num∗q . den − p . den ∗q . num ;
% t r a n s f e r \ mtime . D e f i n e p ∗ q p a r a t r a n s f e r .
p = transfer (p) ;
q = transfer (q) ;
r . num= p . num∗q . num ;
Clases agregadas (VI)
Sobrecarga de operadores. Código:

% t r a n s f e r \ mrdivide Define p / q para t r a n s f e r .
p = transfer (p) ;
q = transfer (q) ;
r . num= p . num∗q . den ;
r . den= p . den ∗q . num ;
>> g1= t r a n s f e r ( [ 1 , 2 , 3 ] , [ 2 , 3 , 4 ] )
>> g2= t r a n s f e r ( [ 1 , 4 , 3 ] ) % den=1
>> g3= g1+g2 ; % O b j e t o t r a n s f e r
>> g3= g1 / g2 % O b j e t o t r a n s f e r
>> g3 . num % Cadena de c a r a c t e r e s
>> g3 ( 1 0 ) % V a l o r de c o c i e n t e en x=10
Prácticas de la programación orientada a objeto
Modificar la función método subsref, Fichero Dejer1.m de la clase

funcion, de forma que los ı́ndices sirva para devolver el valor del
coeficiente correspondiente. Por ejemplo, p(3) debe devolver el tercer
coeficiente.
Modificar la función método subsref, Fichero Dejer2.m, de la clase
transfer de forma que devuelva los ı́ndices de numerador y denominador
correspondientes. Por ejemplo, g(1,2) debe devolver el primer coeficiente
del numerador, y segundo del denominador.
Definir una función método subasgn, de las clases funcion y transfer,
Fichero Dejer3.m y Dejer4.m con un criterio similar a los empleados
en los dos apartados anteriores. Ejemplo en la clase funcion, p(3)=5,
introduce un 5 en la posición tercera del polinomio. Ejemplo en la clase
transfer, g(2,3)=[1,2], introduce un 1 en la posición segunda del
numerador, y un 2 en la posición tercera de denominador.
Contenidos
1 Introducción
13 Bibliografı́a
Definición de sistema continuos.
Un sistema es la relación entre una señal de entrada y una de salida,
y (t) = F (u(t)).
Todo sistema fı́sico es causal, es decir, la señal de salida depende en el

tiempo de la señal de entrada.
Un sistema continuo en el tiempo puede ser representado
matemáticamente mediante una ecuación diferencial ordinaria (ODE),
y (n) = f (t, y , y 0 , . . . , y (n−1) ).
Nota: La entrada es una función del tiempo u(t).
Definición de sistemas continuos lineales
Sistema lineal:
Si u(t) → y (t), entonces αu(t) → αy (t).
Si {u1 (t), u2 (t)} → {y1 (t), y2 (t)}, entonces
{u1 (t) + u2 (t)} → {y1 (t) + y2 (t)}.
Un sistema lineal se rige por una ecuación diferencial lineal,
y (n) + an−1 y (n−1) + . . . + a0 y = bn u (n) + bn−1 u (n−1) + . . . + b0 u.
Nota: Ver que de esta forma se cumple con su definición.

Función de transferencia de un sistema lineal es la transformada de
Laplace de su ecuación diferencial,
Y (s) s n + an−1 s n−1 + . . . + a0

= .
U(s) bn s n + bn−1 s n−1 + . . . + b0
Definición de sistema muestreados.
Un sistema muestreado puede ser representado por una ecuación en

diferencias,
y (k) = f (k, y (k), y (k − 1), . . . , y (k − n)).

Un sistema muestreado lineal puede ser representado por un una ecuación
en diferencias lineal,
y (k+n)+a1 y (k+n−1)+. . .+a0 y (k) = bn u(k+n)+bn−1 u(k+n−1)+. . .+b0 u(k).
Función de transferencia de un sistema muestreado lineal es la

transformada Z de su ecuación en diferencias,
Y (z) z n + a1 z n−1 + . . . + a0
= .
U(z) bn z n + bn−1 z n−1 + . . . + b0
Un sistema, en general puede estar compuesto por partes continuas,
muestreadas, lineales y no lineales.
Simulación en Matlab y Simulink: Comparación
La simulación de un sistema consiste en predecir los datos de salida del

mismo frente a los datos de entrada.
Simulación desde Matlab:
Creación de un fichero con la ecuación diferencial del sistema en forma de
derivadas de primer orden.
Resolución del ODE por métodos similares a los de Runge-Kutta.
Simulación desde Simulink (interface gráfico):
Dibujo del sistema en un entorno gráfico, donde se dispone de iconos para
sus partes lineales, no lineales, continuas y discretas.
Creación de un fichero con la información de la planta y uso de las
funciones de simulación de matlab.
Simulación con Matlab
La ecuación ODE del sistema y (n) = f (t, y , y 0 , . . . , y (n−1) ) se debe

transformar a una ecuación ODE vectorial de primer orden y 0 = F (t, y ).
Una forma sencilla de conseguirlo es mediante el cambio,
y1 = y , y2 = y 0 , . . . , yn = y (n−1) ,
y por tanto
y10
   
y2
 y20   y3 
= .
   
 .. ..
 .   . 
yn0 f (t, y1 , y2 , . . . , yn )
Condiciones iniciales: Valores iniciales de
T
y1 (t0 ), . . . , yn (t0 ) .
ODE de la función de Val der Pol
Ejemplo: Función de Val der Pol, (dinámica no lineal

masa-muelle-amortiguador)
y100 − µ(1 − y12 )y10 + y1 = 0,

en ecuaciones de estado,
0
y1 y2
= .
y20 µ(1 − y12 )y2 − y1
Fichero con la relación de las ecuaciones de estado,

f u n c t i o n dy= p o l ( t , y )
% t es e l tiempo
% y e s e l v a l o r d e l v e c t o r p a r a un t .
% dy e s l a d e r i v a d a de y p a r a un t dado .
% y ( 3 ) p a r á m e t r o m o d i f i c a b l e con c o n d i c i o n e s i n i c i a l e s
dy = [ y ( 2 ) ; y ( 3 ) ∗(1− y ( 1 ) ˆ 2 ) ∗ y ( 2 )−y ( 1 ) ; 0 ] ; % Columna
Esta función será llamada por el programa ODE en los sucesivo puntos t
para obtener la derivada.
La entrada se debe poner en función de t.
Clasificación de ODEs y formulación
Funciones ODE para sistema suaves basados en métodos de Ruge-Kutta:

ode45, ode23 y ode113.
Funciones ODE para problema con cambios de alta frecuencia:
ode15s, ode23s y ode23t.
Formato de la llamada a la función ODE:
>> [ t , y ]= s o l v e r ( @F , t s p a n , y0 , o p t i o n )
@F: Nombre o puntero del fichero .m donde se guarda la función.

tspan:
[ti,tf]: Lı́mite inferior y superior. Paso y número de valores de
salida variables.
linspace(ti,tf,Npuntos): Se fija el número de puntos y tiempo
cuya salida se desea conocer. El programa internamente tiene paso
variable.
y0: Valores iniciales deseados (vector columna).
option: Especificaciones del algoritmo. Si se pone [] se toman por
defecto.
Opciones de las funciones ODE
Consultar con la ayuda:

>> help odeset
>> o p t i o n= o d e s e t ; % d a t o s p o r d e f e c t o .
>> x0= [ 0 . 1 , 1 . 1 , 0 . 1 ] ; % d o s e s t a d o s , un p a r á m e t r o
>> s o l= ode45 ( @pol , x0 ) ; % V e r s i ó n 7
>> y= d e v a l ( s o l , l i n s p a c e ( 0 , 1 0 , 1 0 0 ) ) ; % s o l . en p u n t o s
Ejemplos:
Número de datos de salida:
>> o p t i o n= o d e s e t ( ’ R e f i n e ’ , 4 ) ; % p o r d e f e c t o .
Jacobiano del ODE en función jacpol.m:
>> o p t i o n= o d e s e t ( ’ J a c o b i a n ’ , @ j a c p o l ) ;
Se precisa una función de la forma,
f u n c t i o n j a c= j a c p o l ( t , y )
jac = [0 , 1 , 0;
−2∗y ( 1 ) ∗ y ( 2 ) , 1−y ( 1 ) ˆ 2 , (1− y ( 1 ) ˆ 2 ) ∗ y ( 2 ) ;
0, 0, 0];
Ecuaciones diferenciales con valores de frontera (I)
El problema puede ser planteado por las ecuaciones como para a < t < b,
y 0 = f (t, y , p)
g (y (a), y (b), p) = 0
Se resuelve con la función:

>> s o l= bv p4c ( @F , @bc , s o l i n i t , o p t i o n , p1 , p2 , ...)
@F nombre o puntero a función que define el problema.

@bc nombre o puntero a función que define los valores frontera.
solinit: Fijar el mallado en t y puntos iniciales para y .
option opciones de resolucion bvpset, bvpget.
pi parámetros extras.
Ecuaciones diferenciales con valores de frontera (II)
Ejemplo: Solución de la ecuación y 00 + |y | = 0, sabiendo que y (0) = 0 e

y (4) = −2.
Función diferencial:
f u n c t i o n dydx= F ( t , y )
dydx= [ y ( 2 ) ; −a b s ( y ( 1 ) ) ] ;
Función frontera:
f u n c t i o n r e s= bc ( ya , yb )
r e c= [ ya ( 1 ) ; yb ( 1 ) + 2 ] ;
Operaciones a realizar:
>> s o l i n i t= b v p i n i t ( l i n s p a c e (0 ,4 ,5) , [ 1 , 0 ] ) ;
>> s o l= b v p4 c ( @F , @bc , s o l i n i t ) ;
>> t=l i n s p a c e ( 0 , 4 ) ; y= d e v a l ( s o l , t ) ;
>> plot (t , y) ;
Ecuaciones diferenciales en derivadas parciales (I)
Una ecuación en derivadas parciales puede formularse como:

∂u ∂u −m ∂ m ∂u ∂u
c x, t, u, =x x f x, t, u, + s x, t, u,
∂x ∂t ∂x ∂x ∂x
donde a ≤ x ≤ b, t0 ≤ t ≤ tf .
Condiciones iniciales: Para t = T0 ,
u(x, t0 ) = u0 (x).
Condiciones frontera: Para x = a o x = b,

∂u
p(x, t, u) + q(x, t)f x, t, u, = 0.
∂x
Ecuaciones diferenciales en derivadas parciales (II)
Se resuelve con la función:

>> s o l= pd ep e (m, @F , @ i n i t , @ f r o n t , xmesh , t s p a n ,
o p t i o n s , p1 , p2 , . . . )
m: Simetrı́a de la ec. diferencial, bloques (m=1), cilı́ndrica (m=2) y esférica

(m=3).
F Nombre o puntero a la definición de función.
>> [ c , f , s ]= F ( x , t , u , dudx )
init: Nombre o puntero a las condiciones iniciales.
>> u= i n i t ( x )
front: Nombre o puntero a las condiciones frontera.
>> [ p l , q l , pr , p r ]= f r o n t ( x l , u l , x r , ur , t )
xmesh: Mallado de los valores de x.
tspan: Mallado de los valores de t.
Ecuaciones diferenciales en derivadas parciales (III)
Ejemplo: Resolver la ecuación diferencial

2 ∂u ∂ ∂u
π = ,
∂t ∂x ∂x
sujeto a las condiciones iniciales u(x, 0) = sin(πx) y condiciones frontera
u(0, t) = 0, πe −t + ∂u
∂x
(1, t) =0
f u n c t i o n [ c , f , s ]= F ( x , t , u , dxdu )
c= p i ˆ 2 ; f= dxdu ; s =0;
f u n c t i o n u0= i n i t ( x )
u0= s i n ( p i ∗ x ) ;
f u n c t i o n [ p l , q l , pr , q r ]= f r o n t ( x l , u l , x r , ur , t )
p l=u l ; q l =0; p r= p i ∗ e x p (− t ) ; q r= 1 ;
>> m= 0 ; x= l i n s p a c e ( 0 , 1 , 2 0 ) ; t= l i n s p a c e ( 0 , 2 , 5 ) ;
>> s o l= pd ep e (m, @F , @ i n i t , @ f r o n t , x , t ) ;
>> u= s o l ( : , : , 1 ) ;
>> figure ; surf (x , t , u) ;
>> f i g u r e ; p l o t ( x , u ( end , : ) ) ;
Prácticas de simulación con matlab
Resolver la ecuación de Van del Pol y 00 + µ(1 − y 2 )y 0 + y = 0 para

µ = 1, con valores iniciales y (0) = 2 e y 0 (0) = 0, en el intervalo
t = [0, 20] (usando su Jacobiano) por el ode45 y ode23. Generalizar el
resultado para una µ cualquiera. El fichero “script” con la resolución del
problema se llamará Eejer1.m.
Resolver la ecuación de Lorenz, usadas en la descripción de sistemas
caóticos, para los puntos iniciales y valores de σ , r y b que el usuario
desee, por ejemplo σ = 10, r = 28 y b = 8/3. El fichero “script” con la
resolución del problema se llamará Eejer2.m.
x 0 = σ(y − x)
y 0 = x(r − z) − y
z 0 = xy − bz
Dada la ecuación y 00 + (λ − 2q cos(2t))y = 0, con condiciones de frontera

y (0) = 1, y 0 (0) + y 0 (π) = 0 encontrar una solución para q = 15 y
λ = 15, basándose en una solución inicial para diez puntos de t en el
intervalo [0, π]. Dibujar la gráfica de la primera componente en 100
puntos igualmente espaciados entre [0, π]. El fichero “script” con la
resolución del problema se llamará Eejer3.m.
Simulink: Tabla de bloques propios
Bloques especı́ficos de Simulink:

Continuous: Bloques de sistemas continuos escritos en base a su
funciones de transferencia; sus polos, ceros y ganancias; y sus ecuaciones
en espacio de estado.
Discrete: Bloques de sistemas discretos escritos en base a su funciones
de transferencia; sus polos, ceros y ganancias; y sus ecuaciones en espacio
de estado.
Function & Tables: Funciones y tablas de Matlab. Especial importancia
las S-Function.
Math: Bloque de operaciones matemáticas entre señales.
Nonlinear: Bloque de no linealidades.
Signal & Systems: Entradas y salidas de datos hacia el espacio de
trabajo de Matlab (bloques in y out), y hacia ficheros. Bloque subsystem
que permite generar un diagrama de bloque dentro de otro.
Sinks: Bloques que muestran los datos simulados en pantallas o los
guardan en ficheros.
Sources: Bloques que generan diferentes tipos de señales.
Simulink: Tabla de bloques pertenecientes a toolbox
Bloques pertenecientes a toolbox de Matlab:

Control System Toolbox: Bloques de sistemas continuos y discretos en
la formulación orientada a objeto LTI especı́fica de esa toolbox.
Real-Time: Bloques de comunicación entre el sistema y una tarjeta de
adquisición de datos.
En general, todas las toolbox de matlab han desarrollado funciones de
simulink en la versión 7 o posterior.
Simulink: Simulación de sistemas desde matlab
Interface gráfico para modelar un sistema.

Simulación desde Matlab: Entradas bloques in y salidas bloques out.
>> [ t , x , y ]= s i m ( ’FUN ’ , t s p a n , o p t i o n , [ t , u ] )
’FUN’: Nombre del fichero .mdl del fichero Simulink.

tspan:
[ti,tf]: Lı́mite inferior y superior. Paso y número de valores de
salida variables.
linspace(ti,tf,Npuntos): Se fija el número de puntos y tiempo
cuya salida se desea conocer. El programa internamente tiene paso
variable.
x0: Valores iniciales de las variables de estado (vector columna).
option: Especificaciones del algoritmo. Si se pone [] se toman por
defecto.
[t,u]: Tiempo y entradas al modelo Simulink desde el espacio de trabajo.
Ejercicios de simulación con matlab y simulink
Formular en un fichero *.m los dos modelos planteados en Simulink y

demostrar que la simulación con la función ode45 y con Simulink es
equivalente. El nombre del fichero “script” será Eejer4.m.
s+1 1 1
1 1
1/100s+1 s s
In1 Out1
Transfer Fcn Saturation Integrator1 Integrator
1 1 1
1 1
s+1 s s
In1 Relay Out1
Transfer Fcn Integrator1 Integrator
Contenidos
1 Introducción
13 Bibliografı́a
GUIDE: Interface gráfico de matlab (I)
Definición: Es una herramienta para construir interfaces gráficos con

botoneras, figuras, texto, y más elementos.
Construcción de gráficos: Se realiza con un interface del programa
que permite colocar cada elemento donde se desee. Tras ello se exporta la
información a un fichero .m.
Programación de funciones: Cada elemento del gráfico tiene asociado
en el fichero .m una función donde el programador escribe las
instrucciones de cada elemento.
Ejemplo: La siguiente gráfica muestra un inteface para el análisis de las
señales cardı́acas. Se compone de,
Pantalla: para visualizar los datos.
Botones: para marcar las operaciones que se desean realizar.
Pantallas de texto: Para mandar mensajes al programa.
2500
2000
1500
1000
500
-500
0.97 0.98 0.99 1 1.01 1.02 1.03 1.04
5
x 10
GUIDE: Interface gráfico de matlab (II)
Entorno gráfico: El comando GUIDE abre una pantalla con la que se

puede dibujar el esquema gráfico del interface,
Cada elemento añadido es un objeto con un nombre y propiedades que se
pueden modificar en la pantalla.
Los elementos se pueden alinear, formar bloques y otra serie de
operaciones para conseguir una gráfica bonita.
Cuando la figura se haya terminado se procede a exportar la información a
un fichero .m.
Pantalla GUIDE y paleta de trabajo:
GUIDE: Interface gráfico de matlab (III)
Programación de los objetos: En el fichero .m generado con el

interface cada objeto tiene asociado dos funciones, una de inicialización y
otra de llamada.
Variables de las funciones: Son dos objetos, hObject para los
gráficos y handles para la información.
Ejemplo: Barra para mandar datos (“slider”),
Función creación de un “slider”:
f u n c t i o n S Dim CreateFcn ( hObject , eventdata , h a n d l e s )
% I n t r o d u c e en e l o b j e t o g r á f i c o l o s v a l o r e s i n i c i a l e s
s e t ( h O b j e c t , ’ V a l u e ’ , 5 ) ; s e t ( h O b j e c t , ’ Min ’ , 0 ) ;
s e t ( h O b j e c t , ’ Max ’ , 1 0 ) ;
Función de llamada de un “slider”:

f u n c t i o n S Dim Callback ( hObject , eventdata , h a n d l e s )
% E x t r a e d e l o b j e t o g r á f i c o e l v a l o r
N= g e t ( h O b j e c t , ’ V a l u e ’ ) ;
% I n t r o d u c e d i c h o v a l o r en o t r o o b j e t o
% E Dim , c a s i l l a de t e x t o
s e t ( h a n d l e s . E Dim , ’ S t r i n g ’ , n u m 2 s t r ( f l o o r (N) ) ) ;
GUIDE: Ejercicios propuestos
Ejercicio: Realizar un interface de usuario con la herramienta GUIDE

que consiga mostrar en una pantalla gráficas elegidas por el usuario en
diferentes formatos, superficie, mallado o contorno. La función donde
debe ser guardado el programa se llamará Fejer1.m
Ver las explicaciones del manual de matlab del interface de usuario,
builgui.pdf, donde se explica este ejemplo con detalle.
Contenidos
1 Introducción
13 Bibliografı́a
Funciones matemáticas básicas (I)
abs Valor absoluto
acos, acosh Arco coseno y arco coseno hiperbólico
acot, acoth Arco cotangente y arco cotangente hiperbólico
acsc, acsch Arco cosecante y arco cosecante hiperbólico
angle Argumento
asec, asech Arco secante y arco secante hiperbólico
asin, asinh Arco seno y arco seno hiperbólico
atan, atanh Arco tangente y arco tangente hiperbólico
atan2 Arco tangente en el cuarto cuadrante
ceil Redondeo al entero más próximo
complex Forma un número complejo
Funciones matemáticas básicas (II)
conj Complejo conjugado
cos,cosh Coseno y coseno hiperbólico
cot,coth Cotangente y cotangente hiperbólica
csc,csch Cosecante y cosecante hiperbólica
exp Exponencial
fix Elimina la parte decimal
floor Mayor entero menor o igual que un real dado
gcd Máximo común divisor
imag Parte imaginaria de un número complejo
lcm Máximo común múltiplo
log Logaritmo neperiano
log2 Logaritmo base 2
log10 Logaritmo base 10
mod Módulo
Funciones matemáticas básicas (III)
nchoosek Coeficiente binomial
real Parte real de un número complejo
rem Resto de la división
round Redondeo al entero más cercano
sec,sech Secante y secante hiperbólica
sign Signo
sin,sinh Seno y seno hiperbólico
sqrt Raı́z cuadrada
tan,tanh Tangente y tangente hiperbólica
Pueden consultarse con

>> h e l p e l f u n
MATLAB tiene también funciones matemáticas especiales

>> h e l p s p e c f u n
Ejemplo de funciones matemáticas básicas DElfun1.m

10
Combinaciones de 10 elementos tomadas de 4 en 4 :
4
>> n c h o o s e k ( 1 0 , 4 )
Seno y coseno de los ángulos entre 0 y 2π, incrementando de π/2 en π/2.

>> s i n ( 0 : p i / 2 : 2 ∗ p i )
>> c o s ( 0 : p i / 2 : 2 ∗ p i )
Algunas propiedades de las funciones exponencial y logarı́tmica

>> exp (2∗ p i ∗ i )
>> exp ( l o g ( 2 ) )
>> 2∗ e x p ( i ∗ p i )
>> 2 ∗ ( c o s ( p i )+i ∗ s i n ( p i ) )
>> l o g (3+2∗ i )
Algunas propiedades de las funciones trigonométricas

>> s i n ( p i / 4 ) ˆ2+ c o s ( p i / 4 ) ˆ2
>> ( e x p ( 5 )+ex p ( −5) ) /2
>> cosh (5)
>> c o s h ( p i ) ˆ2− s i n h ( p i ) ˆ2
>> 1+t a n ( p i / 4 ) ˆ2
>> s e c ( p i / 4 ) ˆ2
Funciones de transformación de coordenadas
cart2pol,pol2cart Transforma cartesianas a polares (cilı́ndricas 3D)
cart2sph,sph2cart Transforma cartesianas a esféricas
Ejemplo de transformación de coordenadas DCoor1.m

Transforma el punto (3, 2, 5) de cilı́ndricas a cartesianas:
>> [ x , y , z ]= p o l 2 c a r t ( 3 , 2 , 5 )
Transforma el punto (1, 1, 1) de cartesianas a cilı́ndricas y a esféricas:
>> [ c1 , c2 , c3 ]= c a r t 2 p o l ( 1 , 1 , 1 )
>> [ c1 , c2 , c3 ]= c a r t 2 s p h ( 1 , 1 , 1 )
Transforma el punto (5, π/3) de cilı́ndricas a cartesianas:
>> [ x , y ]= p o l 2 c a r t ( 5 , p i / 3 )
Funciones estadı́sticas básicas (I)
max Máximo de vector
mean Media
median Mediana
min Máximo
perms Permuta las filas de una matriz
sort Datos ordenados
sortrows Ordena filas de una matriz
std Desviación estandar.
var Varianza
Funciones estadı́sticas básicas (II)
corr Correlación entre variables
cov Matriz de covarianzas
corrcoef Matriz de correlaciones
xcorr Correlación cruzada entre variables
xcov Covarianzas cruzadas entre variables
cumprod Producto acumulativo
cumsum Suma acumulativa
cumtrapz Integración acumulativa trapezoidal
diff Función diferencial y aproximación acumulativa
find Busca datos en vectores
hist,histc Histograma y contaje de histograma
Ejemplo funciones básicas estadı́stica DStat1.m (I)
Generamos dos series de 1000 números cada una que se almacenan en los
vectores x e y. Estos vectores representan un conjunto de medidas
obtenidas de muestrear dos variables aleatorias X e Y.
>> r a n d n ( ’ s e e d ’ , 1 ) ;
>> x = r a n d n ( 1 0 0 0 , 1 ) ;
>> y = r a n d n ( 1 0 0 0 , 1 ) ;
El valor medio de x se calcula con el comando:

>> mean ( x )
Si hubiera algún valor NaN en el vector x, el comando mean(x) devuelve

NaN como media, para descontar estos valores se utiliza el comando NaN
>> xn=x ;
>> xn ( 2 0 0 )=NaN ;
>> mean ( xn )
>> nanmean ( xn )
La mediana se calcula con el comando:

>> median ( x )
Ejemplo funciones básicas estadı́stica DStat1.m (II)
La desviación tı́pica se calcula con el comando

>> s t d ( x )
La varianza se calcula con el comando

>> v a r ( x )
El valor más grande de la serie se obtiene con el comando

>> max ( x )
El valor más pequeño de la serie se obtiene con el comando

>> min ( x )
El rango de valores de la serie se obtiene con el comando

>> r a n g e ( x )
Ejemplo funciones básicas estadı́stica DStat1.m (III)
La matriz de covarianza cruzada entre las dos variables aleatorias X e Y

se obtiene con el comando:
>> c o v ( x , y )
La matriz de correlación cruzada entre las dos variables aleatorias X e Y

se obtiene con el comando:
>> c o r r c o e f ( x , y )
Para obtener la posición o ı́ndice del mayor o menor valor dentro del
vector x, se puede utilizar el comando max o min con argumentos de
salida.
>> [ a i ] = max ( x )
El mayor valor es a, y su posición dentro del vector x queda almacenado

en la posición i.
Ejemplo funciones básicas estadı́stica DStat1.m (IV)
Los valores del vector x pueden ordenarse con el comando sort

>> x s = s o r t ( x ) ;
Se puede obtener el ı́ndice de ordenación utilizando sort con un segundo

argumento de salida
>> [ x s i ] = s o r t ( x ) ;
Tanto xs, como x(i) contienen los valores ordenados de menor a mayor,
para ver los que van de la posición 201 a 210 se hace:
>> [ x s ( 2 0 1 : 2 1 0 ) x ( i ( 2 0 1 : 2 1 0 ) ) ]
El histograma de los datos se calcula con el comando

>> h i s t ( x )
Por defecto el comando hist utiliza 10 intervalos. Para utilizar un número

diferente de intervalos, por ejemplo 50, hacer
>> h i s t ( x , 5 0 )
La cuenta de elementos h por intervalo i se obtiene con el comando

>> [ h i ] = h i s t ( x , 5 0 ) ;
i contiene el valor medio del intervalo y h la cuenta de elementos

Ejercicios de tratamiento de datos
En un fichero script de nombre Gejer1.m realizar las siguientes

operaciones:
Generar una variable aleatoria x con distribución normal y otra y con
distribución uniforme, ambas con 1000 elementos.
Hallar la media, varianza y mediana de ambas variables.
Hallar el histograma de ambas variables.
Representar la función de distribución acumulada de ambas variables a
partir de los datos ordenados.
Representar la función de distribución de ambas variables a partir de la
diferencia de los datos obtenidos en el apartado anterior.
Hallar el diagrama Q-Q entre ambas variables, es decir, el diagrama de los
datos ordenados de una variable con respecto a la otra.
Hallar la correlación y convarianza entre ambas variables.
Hallar la correlación y covarianza cruzadas de las variables consigo mismas
y entre ellas para un tiempo de [−τ, τ ].
Contenidos
1 Introducción
13 Bibliografı́a
Funciones básicas de álgebra matricial (I)
expm Exponencial de una matriz e A
logm Logaritmo neperiano de una matriz
sqrtm Raı́z cuadrada de una matriz
funm Cualquier función matemática aplicada a una matriz
transpose, ()’ Transpuesta de una matriz
inv Inversa de una matriz
det Determinante de una matriz
rank Rango de una matriz
trace Traza de una matriz
Funciones básicas de álgebra matricial (II)
eig Valores propios de una matriz
svd Valores singulares de una matriz
cond Número de condición de una matriz
rcond Recı́proco del número de condición (estimado)
norm Norma de una matriz
null Base ortonormal del núcleo de una matriz
orth Base ortonormal de la imagen de una matriz
subspace Ángulo entre los subespacios de dos matrices
Ejemplo de Matlab de funciones de álgebra de matrices DAlg1.m (I)
Formamos una matriz cuadrada aletoria de dimensión 3

>> A=r a n d n ( 3 )
Calculamos su traspuesta
>> A ’
Calculamos su rango con rank

>> r a n k (A)
Calculamos su determinante con det

>> d e t (A)
Calculamos sus autovalores con eig

>> e i g (A)
Calculamos su traza con eig

>> e i g (A)
Comprobamos que la traza es la suma de los autovalores

>> [ sum ( e i g (A) ) t r a c e (A) ]
Ejemplo de Matlab de funciones de álgebra de matrices DAlg1.m (II)
Comprobamos que el determinante es el producto de los autovalores

>> [ p r o d ( e i g (A) ) d e t (A) ]
Calculamos el número de condición

>> cond (A)
Comprobamos que el número de condición es el cociente entre el máximo

y el mı́nimo autovalor
>> s q r t ( max ( e i g (A ’ ∗ A) ) / min ( e i g (A ’ ∗ A) ) )
>> max ( s v d (A) ) / min ( s v d (A) )
Estimamos el recı́proco del número de condición con rcond

>> r c o n d (A)
Obtenemos el error relativo de estimación obtenido con rcond’)

>> a b s ( cond (A) −1/ r c o n d (A) ) / cond (A)
Ejemplo de Matlab de funciones de álgebra de matrices DAlg2.m (I)
Formamos una matriz cuadrada compleja aleatoria de dimensión 3

>> B=r a n d n ( 3 )+j ∗ r a n d n ( 3 )
Calculamos B elevada al cubo

>> Bˆ3
Calculamos 2 elevado a B
>> 2ˆB
Calculamos la exponencial de B por dos métodos

>> expm (B)
>> e x p ( 1 ) ˆB
Ejemplo de Matlab de funciones de álgebra de matrices DAlg2.m (II)
Calculamos el logaritmo neperiano de B por dos métodos

>> logm (B)
>> funm (B , ’ l o g ’ )
Calculamos la raı́z cuadrada de B por tres métodos

>> s q r t m (B)
>> funm (B , ’ s q r t ’ )
>> B ˆ . 5
Calculamos el seno y coseno de B

>> funm (B , ’ s i n ’ )
>> funm (B , ’ c o s ’ )
Descomposición de matrices
[V,D]=eig(A) AV = VD, D diagonal
[T,B]=balance(A) TB = AT , eig(A) ≈ eig(B)
[U,T]=schur(A) UT = AU, U 0 U = I , T triangular superior
[L,U,P]=lu(A) PA = LU, P permutación, L triangular inferior,
U triangular superior
R=chol(A) R 0 R = A para A definida positiva, R triangular superior
[Q,R,P]=qr(A) AP = QR, P permutación, Q ortogonal,
R triangular superior
[V,J]=jordan(A) AV = VJ, J matriz de Jordan
pinv Pseudoinversa de una matriz
poly Polinomio caracterı́stico de una matriz
Ejemplo de descomposición de matrices DAlg3.m (I)
Formamos una matriz cuadrada aletoria de dimensión 3

>> A=r a n d n ( 3 )
Calculamos su descomposición en valores propios con svd

>> [ V , D]= s v d (A)
Comprobamos la descomposición:
>> A∗V−V∗D
Calculamos la matriz balanceada de A

>> [ T , B]= b a l a n c e (A)
Comprobamos la descomposición
>> [ B T\A∗T ]
>> e i g (A)
>> e i g (B)
Ejemplo de descomposición de matrices DAlg3.m (II)
Calculamos la descomposición de Schur de A

>> [ U , T]= s c h u r (A)
>> [ U∗T∗U ’ A ]
>> U∗U ’
Calculamos la descomposición QR de A
>> [ Q, R , E]= q r (A)
>> [Q∗R A∗E ]
>> Q∗Q’
Calculamos la descomposición LU de A
>> [ L , U , P]= l u (A)
>> [ L∗U P∗A ]
Ejemplo de descomposición de matrices DAlg3.m (III)
Calculamos la descomposición SVD de A

>> [ U , S , V]= s v d (A)
>> [ U∗S∗V ’ A ]
>> U’ ∗ U
>> V∗V ’
Para calcular el factor de Choleski necesitamos una matriz definida

positiva que calculamos premultiplicando A por su transpuesta
>> AA=A ’ ∗ A
>> R=c h o l (AA)
>> [ R ’ ∗ R AA ]
Comprobamos que si la matriz no es definida positiva no tiene factor de

Choleski y se obtiene un error
>> R=c h o l (A)
Solución de sistemas de ecuaciones
X=A/B Resuelve XA = B
X=A\B Resuelve AX = B por mı́nimos cuadrados
X=lsqnonneg(A,b) Solución de mı́nimos cuadrados de Ax = b, x ≥ 0
X=linsolve(A,B) Resuelve AX = B, A matriz cuadrada, B matriz
r=roots(p) Raı́ces de un polinomio p
p=poly(r) Polinomio de raı́ces v
x=fzero(fun,x0) Calcula un cero de la función fun próximo a x0
Ejemplo solución de sistemas DAlg4.m (I)
Obtenemos las raı́ces del polinomio p(x) = x 3 + 2x 2 − 3x + 1

>> v = r o o t s ( [ 1 2 −3 1 ] )
Obtenemos el polinomio que tiene raı́ces −1, +2, +j y −j

>> p = p o l y ([ −1 2 j − j ] )
Sea el sistema de ecuaciones lineales
x + 2y + 3z = 3
2x + 3y + z = 1
x + y + 5z = 5
Para resolverlo se forman las matrices A y b

>> A = [ 1 2 3 ; 2 3 1 ; 1 1 5 ]
>> b = [ 3 1 5 ] ’
La solución es:
>> X=A\b
Ejemplo solución de sistemas DAlg4.m (II)
La solución de mı́nimos cuadrados no negativa es:

>> Xn=n l s q n o n e g (A , b )
La ecuación x sin(x) = 1/2 puede resolverse con fzero en el entorno de

los puntos 2, 4 y 6:
>> [ f z e r o ( ’ x ∗ s i n ( x ) −.5 ’ , 2 ) f z e r o ( ’ x ∗ s i n ( x ) −.5 ’ , 4 ) ...
>> f z e r o ( ’ x ∗ s i n ( x ) −.5 ’ , 6 ) ]
Ejercicios de álgebra de matrices
En un fichero “script” de nombre Gejer1.m realizar el siguiente ejercicio.

Dada la siguiente matriz:
2/3 2/5 2/7 2/9 2/11
 
 2/5 2/7 2/9 2/11 2/13 
A= 2/7 2/9 2/11 2/13 1/15
 

 2/9 2/11 2/13 2/15 2/17 
2/11 2/13 2/15 2/17 1/19
Autovalores, autovectores, polinomio caracterı́stico y número de la
condición.
Hallar al inversa de la matriz.
Hallar la descomposición por los siguientes métodos: Jordan, Schur, LU,
QR, Choleski y SVD. Comprobar si es posible la descomposicióny si los
valores obtenidos son ciertos.
Si b = [1, 3, 5, 7, 9]0 resolver el valor de debe tener x para que se cumpla
la ecuación Ax = b.
En un fichero “script” de nombre Gejer2.m realizar el siguiente ejercicio.
Sea x y n dos vectores aleatorios de distribución uniforme entre [0, 1] de
100 elementos.
Fijar un valor para los parámetros [a, b, c].
Obtener el valor de y de la formula y = a ∗ x + b ∗ x 2 + c ∗ x 3 + 0,1 ∗ n.
Estimar el valor de los parámetros [a, b, c] a partir del valor de x e y
usando mı́nimos cuadrados. Se considera que n es un ruido.
Contenidos
1 Introducción
13 Bibliografı́a
Funciones de relación y filtros.
cov Varianza de un vector
corrcoef Coeficientes de correlación (normalizados)
conv Convolución de datos, producto de polinomios
diff Diferencias entre elementos de un vector
gradient Derivadas parciales numéricas de una matriz
del2 Laplaciano discreto de una matriz
filter Filtro FIR y IIR de datos
ltitr Respuesta lineal
Prácticas con funciones de relación y filtros, Bscript2.m (I)
Varianza de un vector
>> l o a d c o u n t . d a t
>> a= c o v ( c o u n t ( : , 1 ) ) ;
Coeficiente de correlación:
>> b= c o r r c o e f ( c o u n t ) ;
Convolución entre dos vectores:

>> c= c o n v ( [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ) ;
>> d= c o n v ( c o u n t ( : , 1 ) , c o u n t ( : , 2 ) ) ;
Diferencial., Derivada aproximada:

>> a= d i f f ( c o u n t ) ;
>> s i z e ( a ) , s i z e ( c o u n t )
Prácticas con funciones de relación y filtros, Bscript2.m (II)
Gradientes, derivada parcial aproximada:

>> [ px , py ]= g r a d i e n t ( c o u n t ) ;
Laplaciano discreto de un vector del 2 u = (d 2 u/dx 2 + d 2 /dy 2 ):

>> l p= d e l 2 ( c o u n t )
Filtro FIR y IIR de vectores:

>> b = [ 1 , 1 , 1 ] / 3 ; a =1;
>> f= f i l t e r ( b , a , c o u n t ) ;
Simulación de un sistema lineal en ecuaciones de estado:

>> A= [ 0 . 9 , 0 ; 0 , 0 . 9 ] ; B = [ 0 , 1 ] ’ ;
>> x= l t i t r (A , B , o n e s ( 1 0 0 , 1 ) ) ;
Análisis en frecuencia
fft Transformada de Fourier discreta
fft2 Transformada de Fourier en dos dimensiones
ifft Inversa transformada de Fourier
ifft2 Inversa transformada de Fourier en dos dimensiones
abs Magnitud
angle Ángulo
fftshift Mueve el retraso cero al centro del espectro
Prácticas de análisis en frecuencia,Bscript3.m
Toma de datos:
>> l o a d s u n s p o t . d a t ;
>> y e a r= s u n s p o t ( : , 1 ) ; w o l f e r= s u n s p o t ( : , 2 ) ;
Transformada de Fourier, se le quita el primer dato:

>> y= f f t ( w o l f e r ) ; y ( 1 ) = [ ] ;
Gráficas con eje frecuencia [0, ±ı́nf, 0] y [−ı́nf, 0,ı́nf]:

>> f i g u r e ; s u b p l o t ( 2 , 1 , 1 ) ; p l o t ( a b s ( y ) )
>> s u b p l o t ( 2 , 1 , 2 ) ; p l o t ( f f t s h i f t ( a b s ( y ) ) ) ;
Gráficas en función de la frecuencia de Nyquist:

>> N= l e n g h t ( y ) ; power = a b s (Y ( 1 : N/ 2 ) ) . ˆ 2 ;
>> n y q u i s t = 1 / 2 ; f r e q = ( 1 : N/ 2 ) / (N/ 2 ) ∗ n y q u i s t ;
>> f i g u r e ; s u b p l o t ( 2 , 1 , 1 ) ; p l o t ( f r e q , power ) ;
>> s u b p l o t ( 2 , 1 , 2 ) ; p l o t ( f r e q , unwrap ( a n g l e ( y ( 1 : N/ 2 ) ) ) ) ;
Ejercicios de filtro y transformada de Fourier
En un fichero “script” de nombre Hejer1.m responder a las siguientes

preguntas.
Obtener una señal de [0, 3] segundos con periodo de muestreo 0,001 s.
y = sin(2 ∗ π ∗ 2 ∗ t) + 0,5 ∗ sin(2 ∗ π ∗ 5 ∗ t + π/3) + 0,1 ∗ sin(2 ∗ π ∗ 50 ∗ t)
Filtrar la señal para eliminar el componente de alta frecuencia, producto
del acoplamiento con la red a 50 Hz. Proponer para ello diferentes tipos
de filtros.
Obtener la transformada de Fourier de la señal filtrada y sin filtrar viendo
las diferencias. Se precisa que la frecuencia cero esté en el centro de la
gráfica.
Contenidos
1 Introducción
13 Bibliografı́a
Funciones para polinomios
conv Producto de polinomios
deconv División de polinomios
poly Definición de polinomios por raı́ces
polyder Derivada de polinomios
polyfit Interpola por mı́nimos cuadrados
polyval Valor polinomio en un punto
polyvalm Valor polinomio con matrices
residue Fracciones parciales
roots Raı́ces de un polinomio
Prácticas con funciones de polinomios, Cscript1.m (I)
Polinomio y sus raı́ces. Coeficientes a partir de raı́ces:

>> p = [ 1 0 −2 −5]; r= r o o t s ( p ) ;
>> p o l y ( r )
Polinomio caracterı́stico:
>> A = [ 1 . 2 3 − 0 . 9 ; 5 1 . 7 5 6 ; 9 0 1 ] ;
>> p o l y (A)
Valor del polinomio en un número o matriz:

>> p o l y v a l ( p , 5 )
>> p o l y v a l m ( p , A) % p (A)= Aˆ3−2∗A−5∗ I
Convolución (producto) y deconvolución:

>> a= [ 1 , 2 , 3 ] ; b= o n e s ( 1 , 5 ) ; c= c o n v ( a , b ) ;
>> [ q , r ]= d e c o n v ( c , a ) ;
Prácticas con funciones de polinomios, Cscript1.m (II)
Derivada de un polinomio, del producto y de la división:

>> q = p o l y d e r ( p )
>> c = p o l y d e r ( a , b ) % d e r i v a d a d e l p r o d u c t o
>> [ q , d ] = p o l y d e r ( a , b ) % d e r i v a d a s de l a d i v i s i ó n
Residuos de un polinomio:
>> b = [−4 8 ] ; a = [ 1 6 8 ] ;
>> [ r , p , k ] = r e s i d u e ( b , a )
Prácticas regresiones basadas mı́nimos cuadrados, Cscript2.m (I)
Datos para la regresión:

>> t = [ 0 . 3 . 8 1 . 1 1 . 6 2 . 3 ] ’ ; y = [ 0 . 5 0 . 8 2 1 . 1 4 1 . 2 5
1.35 1 . 4 0 ] ’ ;
>> p l o t ( t , y , ’ o ’ ) , g r i d on ;
Regresión, y = a(0) + a(1) ∗ t + a(2) ∗ t 2 :

>> X= [ o n e s ( s i z e ( t ) ) , t , t . ˆ 2 ] ; a= X\ y ;
>> t h a t = ( 0 : 0 . 1 : 2 . 5 ) ’ ; y h a t = [ o n e s ( s i z e ( t h a t ) ) t h a t
that .ˆ2]∗ a ;
>> p l o t ( t h a t , y h a t , ’− ’ , t , y , ’ o ’ ) , g r i d on ;
Solución: a = inv (X 0 ∗ X ) ∗ X 0 ∗ y
Regresión exponencial: y = a(0) + a(1) ∗ exp(−t) + a(2) ∗ t ∗ exp(−t):
>> X = [ o n e s ( s i z e ( t ) ) e xp (− t ) t . ∗ e x p (− t ) ] ; a = X\ y ;
>> t h a t = ( 0 : 0 . 1 : 2 . 5 ) ’ ;
>> y h a t = [ o n e s ( s i z e ( t h a t ) ) e x p (− t h a t ) t h a t . ∗ e x p (− t h a t )
]∗ a ;
>> f i g u r e ; p l o t ( t h a t , y h a t , ’− ’ , t , y , ’ o ’ ) , g r i d on ;
Prácticas regresiones basadas mı́nimos cuadrados, Cscript2.m (II)
Regresiones multiples: y = a(0) + a(1) ∗ x1 + a2 ∗ x2:

>> x1 = [ . 2 . 5 . 6 . 8 1 . 0 1 . 1 ] ’ ; x2 = [ . 1 . 3 . 4 . 9 1 . 1
1.4] ’;
>> y = [ . 1 7 . 2 6 . 2 8 . 2 3 . 2 7 . 2 4 ] ’ ;
>> X = [ o n e s ( s i z e ( x1 ) ) x1 x2 ] ; a = X\ y ;
y estimada y error máximo:

>> y h a t = X∗ a ; MaxErr = max ( a b s ( y h a t − y ) )
Obtención de los coeficientes de un polinomio que se aproxime:

>> x = [ 1 2 3 4 5 ] ; y = [ 5 . 5 4 3 . 1 128 2 9 0 . 7 4 9 8 . 4 ] ;
>> p = polyfit (x , y ,3)
>> x2 = 1 : . 1 : 5 ; y2 = p o l y v a l ( p , x2 ) ;
>> p l o t ( x , y , ’ o ’ , x2 , y2 ) ; g r i d on
Ejercicios de polinómios y regresión
Sea x un vector aleatorio uniforme de 1000 componentes. Comprobar en

un fichero “script” de nombre Iejer1.m que la convolución de ese vector
con el polinomio [1, 1, 1]/3 da el mismo resultado que la señal obtenida
con y= filter([1,1,1]/3,1,x). Dar una explicación a este hecho.
En un fichero “script” de nombre Iejer2.m realizar el siguiente ejercicio.
Sea t un intervalo de tiempo entre [0, 3] con un periodo de muestreo de
0,1 s y n un vector aleatorio de distribución uniforme entre [0, 1] del
mismo número de elementos.
Fijar un valor para los parámetros [a, b, c].
Obtener el valor de y de la formula y = a + b ∗ x + c ∗ x 2 + 0,1 ∗ n.
Estimar el valor de los parámetros [a, b, c] a partir de la función polyfit
y con mı́nimos cuadrados.
Funciones para interpolar datos, splines
interp1 Interpolación en una dimensión
inter2, inter3 Interpolación en dos y tres dimensiones
interpft Interpolación una dimensión fft.
mkpp Compone un spline a partir de propiedades
spline Genera splines cubicos
pchip Genera splines cúbico de Hermite
ppval Valor de un spline en puntos
unmkpp Propiedades de un spline
mmppint, mmppder Spline integral y derivada
Prácticas con funciones para interpolar datos
Interpolación de datos en una dimensión por distintos métodos:

>> x = [ 1 2 3 4 5 ] ; y = [ 5 . 5 4 3 . 1 128 2 9 0 . 7 4 9 8 . 4 ] ;
>> s= i n t e r p 1 ( x , y , 2 . 5 , ’ l i n e a r ’ )
>> s= i n t e r p 1 ( x , y , 2 . 5 , ’ c u b i c ’ )
>> s= i n t e r p 1 ( x , y , 2 . 5 , ’ s p l i n e ’ )
>> s= i n t e r p 1 ( x , y , 2 . 5 , ’ n e a r e s t ’ )
>> x h a t= l i n s p a c e ( 1 , 5 , 1 0 0 ) ’ ;
>> y h a t= i n t e r p 1 ( x , y , x h a t , ’ s p l i n e ’ ) ;
>> p l o t ( x h a t , y h a t , ’− ’ , x , y , ’ o ’ ) ;
Interpolación de datos en dos dimensiones por distintos métodos:

>> [ x , y ] = meshgrid ( −3:1:3) ;
>> z = peaks ( x , y ) ; s u r f ( x , y , z )
>> [ xi , y i ] = meshgrid ( −3:0.25:3) ;
>> zi1 = interp2 (x , y , z , xi , yi , ’ nearest ’ ) ;
>> s u r f ( xi , yi , zi1 ) ;
>> zi2 = interp2 (x , y , z , xi , yi , ’ bilinear ’) ;
>> s u r f ( xi , yi , zi2 ) ;
>> zi3 = interp2 (x , y , z , xi , yi , ’ bicubic ’ ) ;
>> s u r f ( xi , yi , zi1 ) ;
Prácticas splines, Cscript3.m (I)
Datos:
>> x= 0 : 1 2 ; y= t a n ( p i ∗ x / 2 5 ) ;
>> x i= l i n s p a c e ( 0 , 1 2 , 1 0 0 ) ;
Interpola datos:
>> yp= s p l i n e ( x , y , x i ) ;
>> p l o t ( x , y , ’ o ’ , x i , yp ) ;
Genera los coeficientes de spline, interpola y propiedades:

>> pp= s p l i n e ( x , y )
>> yp= p p v a l ( pp , x i ) ;
>> [ b r e a k , c o e f s , n p o l y s , n c o e f s , dim ]= unmkpp ( pp )
>> pp= mkpp ( b r e a k s , c o e f s ) % c o m p o s i c i ó n
Spline con el método de Hermite:

>> x = [ 0 , 2 , 4 , 5 , 7 . 5 , 1 0 ] ; y= e xp (−x / 6 ) . ∗ c o s ( x ) ;
>> ch= p c h i p ( x , y ) ; y c h= p p v a l ( ch , x i ) ;
>> p l o t ( x , y , ’ o ’ , x i , yp , ’ : ’ , x i , y c h ) ;
Prácticas splines, Cscript3.m (II)
Spline integral y derivada de otro:

>> p p i= mmppint ( pp ) ; ppd= mmppder ( pp ) ;
>> y i= p p v a l ( p p i , x i ) ; yd= p p v a l ( ppd , x i ) ;
>> p l o t ( x , y , ’ o ’ , x i , yp , ’− ’ , x i , y i , ’−− ’ , x i , yd , ’
−. ’ ) ;
Splines para dos dimensiones:

>> t= l i n s p a c e ( 0 , 3 ∗ p i , 1 5 ) ;
>> x= s q r t ( t ) . ∗ c o s ( t ) ; y= s q r t ( t ) . ∗ s i n ( t ) ;
>> ppxy= s p l i n e ( t , [ x ; y ] )
>> t i = l i n s p a c e ( 0 , 3∗ p i , 1 0 0 0 ) ;
>> xy= p p v a l ( ppxy , t i ) ;
>> p l o t ( x , y , ’ d ’ , xy ( 1 , : ) , xy ( 2 , : ) ) ;
Funciones para interpolar superficies e hiperplanos
meshgrid Mallado de dos o tres dimensiones
ndgrid Mallado de dimensión n
surf, mesh Dibuja superficies y mallados
slide Dibuja cortes dentro de un volumen
griddata Interpolación una superficie
griddata3 Interpolación una hipersuperficie, datos orden 3
griddatan Interpolación una hipersuperficie, datos orden n
interpn Interpolación en n dimensiones
Prácticas para interpolar superficies e hiperplanos, Cscript5.m
Datos X , Y reales e interpolados:

>> x1 = − 2 : 0 . 2 : 2 ; x2 = − 2 : 0 . 2 5 : 2 ;
>> [ X1 , X2 ] = n d g r i d ( x1 , x2 ) ;
>> xi1 = −2:0.1:2; xi2 = −2:0.1:2;
>> [ Xi1 , X i 2 ] = n d g r i d ( x i 1 , x i 2 ) ;
Z real e interpolada:
>> Z = X2 . ∗ e x p (−X1 . ˆ 2 −X2 . ˆ 2 ) ;
>> Z i = g r i d d a t a ( X1 , X2 , Z , Xi1 , X i 2 )
>> s u b p l o t ( 2 , 1 , 1 ) ; mesh ( X1 , X2 , Z ) ;
>> s u b p l o t ( 2 , 1 , 2 ) ; mesh ( Xi1 , Xi2 , Z i ) ;
Prácticas de interpolación de datos.
Representar en un “script” de nombre Iejer3.m la diferencia entre el

polinomio interpolador cúbico hermitiano a trozos y el polinomio
interpolador spline cuando x y t varı́an entre −3 y 3 (t varia entre décima
y décima) y x = [−1, −1, −1, 0, 1, 1].
Se considera un conjunto de temperaturas medidas sobre las cabezas de
los cilindros de un motor que se encuentra en perı́odo de pruebas para
utilizar en coches de carreras. Los tiempos de funcionamiento del motor
en segundos y las temperaturas en grados Fahrenheit son las siguientes:
Tiempo = [0, 1, 2, 3, 4, 5]
Temperaturas = [0, 20, 60, 68, 77, 110]
Realizar una regresión lineal en un fichero Iejer4.m que ajuste las

temperaturas en función de los tiempos. Realizar también el ajuste
mediante regresiones polinómicas de grados 2, 3 y 4 representando los
resultados.
Contenidos
1 Introducción
13 Bibliografı́a
Funciones de optimización e integración
fplot Dibuja la función
fminbnd Minimiza función con una variable con restricciones
fminsearch Minimiza función con varias variables
fzero Encuentra el cero en función con una variable
optimset, optimget Parámetros de resolución
quad Integración numérica, Simpson
quadl Integración numérica, Lobatto
dblquad Integración numérica, doble integral
triplequad integración numérica, triple integral
Prácticas funciones de optimización, Dscript1.m (I)
Parámetros de la optimización:
>> h e l p o p t i m s e t
Función definida como anónima (versión 7):

>> humps= @( x ) 1 . / ( ( x − 0 . 3 ) . ˆ 2 + 0 . 0 1 ) + 1 . / ( ( x −0.9)
. ˆ 2 + 0 . 0 4 ) −6;
Función definida como anónima (versiones anteriores):

>> humps= i n l i n e ( ’ 1 . / ( ( x − 0 . 3 ) . ˆ 2 + 0 . 0 1 ) + 1 . / ( ( x −0.9)
. ˆ 2 + 0 . 0 4 )−6 ’ ) ;
Entradas y salida de la función, representación:

>> x= l i n s p a c e ( − . 5 , 1 . 5 , 1 0 0 ) ; y= humps ( x ) ;
>> f p l o t ( humps ,[ −5 5 ] ) ; g r i d on ;
Ejemplo de modificación de parámetros (ver valor en cada iteración):

>> o p t i o n= o p t i m s e t ( ’ D i s p l a y ’ , ’ i t e r ’ ) ; o p t i m g e t
Prácticas funciones de optimización, Dscript1.m (II)
Algorithmo: Nelder-Mead simplex, x ∈ [0,3 < x < 1], espacio de

búsqueda de una dimensión:
>> x = f m i n b n d ( humps , 0 . 3 , 1 , o p t i o n ) ;
Espacio de búsqueda de varias dimensiones:

>> t v a r= @( x ) x ( 1 ) . ˆ 2 + 2 . 5 ∗ s i n ( x ( 2 ) ) − x ( 3 ) ˆ2∗ x ( 1 ) ˆ2∗
x (2) ˆ2;
Mı́nimo cercano a v , valor desde donde se empieza a buscar:

>> v = [ −0.6 −1.2 0 . 1 3 5 ] ;
>> [ vmin , v a l u e s , f l a g , o u t p u t ] = f m i n s e a r c h ( t v a r , v )
Punto f (x) = sin(3 ∗ x) = 0 cercano a x = 2, donde se empieza a buscar:

>> x = f z e r o (@( x ) s i n ( 3 ∗ x ) , 2 )
Prácticas funciones de optimización, Dscript1.m (III)
Función de control del algoritmo:

>> o p t i o n s = o p t i m s e t ( ’ OutputFcn ’ , @ o u t f u n ) ;
Forma de la función de control, saca gráficos en cada iteración:

function stop = outfun (x , optval , state )
% o p t v a l campos : f u n c o u n t , f v a l , i n t e r a t i o n , p r o c e d u r e
% s t a t e : ’ i n i t ’ , ’ i n t e r r u p t ’ , ’ i t e r ’ , ’ done ’
% stop : false , true
s t o p = [ ] ; h o l d on ;
plot ( x (1) , x (2) , ’ . ’ ) ;
drawnow
Prueba con la minimización anterior:

>> v = [ −0.6 −1.2 0 . 1 3 5 ] ; % Empieza a b u s c a r en v
>> [ vmin , v a l u e s , f l a g , o u t p u t ] = f m i n s e a r c h ( t v a r , v ,
options )
Prácticas funciones de integración, Dscript1.m
Integral simple:
>> quad ( humps , −1, 2 ) %I n t e g r a c i ó n s i m p l e
>> q u a d l ( humps , −1, 2 ) %I n t e g r a c i ó n , mayor e x a c t i t u d
Integral doble:
>> o u t= @( x , y ) y ∗ s i n ( x ) + x ∗ c o s ( y ) ;
>> xmin= p i ; xmax= 2∗ p i ; ymin= 0 ; ymax= p i ;
>> r e s u l t = d b l q u a d ( out , xmin , xmax , ymin , ymax )
Optimización con restricciones: Funciones peso
Restricción del problema: mı́nx {f (x)}, g (x) > 0,
if g (x) < 0, cost = f (x),

else cost = f (x) ∗ P(g (x)), P(g (x)) > 0.
Problema minimax: mı́nx {máxf {[f1 (x), . . . , fn (x)]}},
cost = máx([f1 (x), . . . , fn (x)]).
Sistema de ecuaciones no lineales: {f1 (x) = 0, . . . , fn (x) = 0}:
cost = máx(abs([f1 (x), . . . , fn (x)])).
Problema multiobjetivo: mı́nx [f1 (x), . . . , fn (x)].

P
cost = i pi ∗ fi (x).
La solución depende de los pi elegidos.
Prácticas con funciones de optimización (I)
Minimizar la función f (x) = (x − 3)2 − 1 en el intervalo (0, 5).

Encontrar el valor de x que minimiza el valor máximo de [f1 (x), . . . , f5 (x)],
f1 (x) = 2x12 + x22 − 48 ∗ x1 − 40x2 + 304

f2 (x) = −x22 − 3x22
f3 (x) = x1 + 2x2 − 18
f4 (x) = −x1 − x2
f5 (x) = x1 + x2 − 8
Minimizar la función siguiente f (x) = 3x12 + 2x1 ∗ x22 .
Prácticas con funciones de optimización (II)
Encontrar en un fichero “script” de nombre Jejer1.m los valores de x

que minimizan la función f (x) sujeta a las restricciones k1 (x, w1 ) y
k2 (x, w2 con w1 y w2 en [1, 100]. La función y las restricciones se definen
en el problema y el punto inicial es (0,5, 0,2, 0,3),
f (x) = (x1 − 0,5)2 + (x2 − 0,5)2 + (x2 − 0,5)2

k(x, w1 ) = sin(w1 x1 ) cos(w2 x2 ) − 1/100(w1 − 50)2 − sin(w1 x3 ) − x3 ≤ 1
k(x, w2 ) = sin(w2 x2 ) cos(w2 x1 ) − 1/100(w2 − 50)2 − sin(w2 x3 ) − x3 ≤ 1
Dado el conjunto de datos:
xdata = [3,6, 7,7, 9,3, 4,1, 8,6, 2,8, 1,3, 7,9, 10,0, 5,4]
ydata = [16,5, 150,6, 263,1, 24,7, 208,5, 9,9, 2,7, 163,9, 325,0, 54,3]
se trata de encontrar los coeficientes x que minimizan la función ydata(i)

del tipo,
ydata(i) = x(1)xdata(i)2 + x(2) sin(xdata(i)) + x(3)xdata(i)2
Los resultados se escribirán en un fichero “script” de nombre Jejer2.m.
Contenidos
1 Introducción
13 Bibliografı́a
Bibliografı́a
Matlab y sus aplicaciones en la ciencia y la ingenierı́a, (César Pérez).

Prentice Hall.
Mastering Matlab 7, (Duane Hanselman, Bruce Littlefield). Prentice Hall,
Internaltional Edition.

SIMULINK Tutorial Completo - Mach 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

SIMULINK Tutorial Completo - Mach PDF

Încărcat de

Drepturi de autor:

Formate disponibile

10.

Simulink es un software que funciona bajo la plataforma de Matlab y es una

Figura 10.1. Librerias (Izquierda) y Espacio de trabajo de Simulink (Derecha)

10.2 ACCESO A SIMULINK

Para acceder a Simulink se requiere abrir el espacio de trabajo de Matlab y presionar

en la barra estándar o desplegando el menú “File” y seleccionando sucesivamente

10.3 LIBRERIAS DE SIMULINK

Al desplegar el árbol de Simulink y haciendo clic izquierdo sobre su nombre se

Instalación y Conexión de un bloque operacional

Para la instalación de un bloque en el espacio de trabajo de Simulink se selecciona

Especificación de un bloque operacional

Las especificaciones mínimas requeridas en un bloque se relacionan con la

10.4 LIBRERÍA “CONTINUOUS” (CONTINUO)

Figura 10.2. Librería (a) Continuous y (b) Bloques operacionales

Los bloques de la librería “Continuous” representan unidades que se alimentan de

Bloque Derivada (“Derivative”)

El bloque “Derivative” desarrolla la derivada con respecto al tiempo de la variable

Figura 10.3 Especificaciones del bloque Derivative

Bloque Integrador (“Integrator”)

El bloque “Integrator” desarrolla la operación de integrar la información de entrada

Figura 10.4 Especificaciones del bloque (a) Integrator (b) State-Space

Bloque Espacio de los Estados (“State-Space”)

La Figura 10.4b muestra la ventana de especificaciones para el bloque que desarrolla

Bloques Funciones de Transferencia (“Transfer Fcn” y “Zero-Pole”)

La Figura 10.5 muestra las ventanas de especificaciones para las funciones de

Figura 10.5 Especificaciones de bloques (a) Transfer Fcn y (b) Zero-Pole

En la Figura 10.5a, se observan los cuadros donde se especifican en forma matricial

Es común a todas las ventanas de especificaciones de bloques operacionales, la

Bloque Tiempo Muerto (“Transport Delay”)

El bloque “Transport Delay” aplica el tiempo muerto a la señal de entrada que se

Figura 10.6 Especificaciones de los bloques Transport Delay

10.5 LIBRERÍA “MATH OPERATIONS” (OPERADORES)

Figura 10.7 Librería Math Operations

Figura 10.8 Bloques de la librería Math Operations

Los bloques de la librería “Math Operations” se utilizan en la simulación de la

Bloque Suma (“Sum”)

El bloque “Sum” realiza la suma algebraica de las informaciones de entradas

Figura 10.9 Especificaciones del bloque Sum

El bloque “Sum” se especifica introduciendo en el cuadro “List of signs” los signos

Bloques Ganancia (“Gain” y “Slider Gain”)

El bloque “Gain” aplica un factor multiplicador constante a la información de

Bloque Producto (“Product”)

El bloque “Product” realiza el producto o la división entre las informaciones de

Figura 10.11 Especificaciones del bloque Product

Al especificar los signos, estos se despliegan con los símbolos de producto o

Bloque Funcion (“Math Function” y “Trigonometric Function”)

El bloque “Math Function” aplica a la información de entrada una función

Bloque Minimo y Maximo (“MinMax”)

El bloque “MinMax” selecciona el valor mínimo o el máximo entre los

10.6 LIBRERÍA “SOURCES” (ENTRADAS)

Figura 10.13. Librería Sources

Figura 10.14 Bloques de la librería Sources

La librería “Sources” contiene un conjunto de bloques de donde emergen señales

Bloques Paso y Rampa (“Step” y “Ramp”)

La Figura 10.15a muestra la ventana de especificaciones del bloque “Step”. En el

Figura 10.15 Especificaciones de los bloques (a) Step y (b) Ramp

La Figura 1.15b muestra la ventana de especificaciones del bloque “Ramp”. En el

Bloques Seno y Generador de Señal (“Sine Wave” - “Signal Generator”)

La Figura 10.16a muestra la ventana de especificaciones del bloque “Sine Wave”.

La Figura 10.16b muestra la ventana de especificaciones del bloque “Signal

Bloques Reloj y Constante (“Clock” y “Constant”)

La Figura 10.17a muestra la ventana de especificaciones para el bloque “Clock” que

time” se despliega el tiempo sobre el icono. El bloque “Display Clock” se puede