uso octave-matlab control

Manual de inicio rápido en Octave/MatLAB, con aplicaciones en control continuo

Ing. Julián Alfonso Tristancho Ortiz Msc., PhD.

Manual de inicio rápido en Octave/MatLAB orientado al curso de Automatización (171) del proyecto curricular de Ingeniería Industrial

Universidad Distrital Francisco José de Caldas. Facultad de Ingeniería

Plan curricular Ingeniería Industrial Bogotá 2014

Tabla de Contenido

Tabla de Contenido ........................................................................................................................ 3

Lista de Figuras .............................................................................................................................. 4

Lista de Tablas ............................................................................................................................... 4

INTRODUCCIÓN MATLAB / OCTAVE ........................................................................................... 6

INSTALACIÓN OCTAVE ................................................................................................................ 7

INTERFAZ DE USUARIO OCTAVE ............................................................................................... 9

Ayuda del sistema .................................................................................................................... 10

MANEJO DE VARIABLES Y MATRICES ..................................................................................... 11

Cálculos y funciones matemáticas básicas .............................................................................. 13

Generación de matrices ........................................................................................................... 13

Manipulación de matrices ......................................................................................................... 14

Ejemplo 1. Uso de comandos básicos ................................................................................. 17

Ejemplo 2. Solución de un sistema lineal de ecuaciones ..................................................... 18

Manipulación de polinomios ..................................................................................................... 18

PROCESOS BÁSICOS PARA GRÁFICOS .................................................................................. 20

Ejemplo 3. Ajuste de datos a una línea recta (Regresión lineal) .......................................... 24

Ejemplo 4. Uso de gráficas múltiples (Funciones paramétricas) .......................................... 25

PROGRAMACIÓN EN OCTAVE .................................................................................................. 27

Ejemplo 5. Dibujo de funciones con parámetros variables ................................................... 30

PACKAGE DE CONTROL ............................................................................................................ 32

Ejemplo 6. Modelamiento matemático de un sistema masa resorte .................................... 34

Ejemplo 7. Uso package de control en Octave .................................................................... 37

Lista de Figuras

Figura 1 Ventanas de instalación Octave. Izq. Ventana inicial y Der. Selección de packages adicionales (toolbox) ................................................................................................................... 7

Figura 2 Ventana de comandos Octave. Izq. Inicio normal y Der. Inicio anormal en Win8 .................. 7

Figura 3 Configuración de la ventana de propiedades de acceso de directo en escritorio para Octave .................................................................................................................................................... 8

Figura 4 Ventana de comandos en Octave .......................................................................................... 9

Figura 5 Funciones de edición en la ventana de comandos. ............................................................. 10

Figura 6 Ejecución comando “help plot” (arriba) y despliegue de ayuda resultante (abajo). .............. 11

Figura 7 Diferentes resultados del mismo comando ante el mismo comando. .................................. 12

Figura 8 Creación de variables del tipo matriz. .................................................................................. 13

Figura 9 Ejemplo de edición matriz .................................................................................................... 14

Figura 10 Ejemplo por vectores de una matriz ................................................................................... 15

Figura 11 Ejemplos de algunos tipos de gráficas que se pueden obtener con Octave ...................... 21

Figura 12 Resultado de dibujar función seno, con fltk (izq) y gnuplot (der) ........................................ 22

Figura 13 Gráfica de salida Ejemplo 3 ............................................................................................... 25


Figura 15 Resultado uso comando path ............................................................................................ 27

Figura 16 Llamado a ejecución de scripts almacenados en un directorio de trabajo ......................... 28

Figura 17 Edición de scripts en Notepad++ ....................................................................................... 29


Figura 19 Sistema masa amortiguador resorte .................................................................................. 34

Figura 20 Gráfica resultado Ejemplo 6 ............................................................................................... 36

Figura 21 Marts rover. a) vista exterior, b) compensador en lazo abierto y c) control en lazo cerrador .................................................................................................................................................. 37

Figura 22 Figuras de resultado control Marts Rover .......................................................................... 40

Figura 23 Linea de comandos código Ejemplo7.m ............................................................................ 41

Lista de Tablas

Tabla 1 Comandos para manejo de memoria .................................................................................... 11

Tabla 2 Comandos de funciones matemáticas básicas ..................................................................... 13

Tabla 3 Comandos de creación de matrices ...................................................................................... 14

Tabla 4 Comandos y funciones asociadas con matrices ................................................................... 16

Tabla 5 Comandos y funciones asociadas con matrices ................................................................... 19

Tabla 6 Comandos y funciones asociadas el dibujo de funciones en 2D .......................................... 23

Tabla 7 Comandos y funciones asociadas a la escritura de scripts ................................................... 29

Tabla 8 Comandos y funciones asociadas el dibujo de funciones en 2D .......................................... 33

Msc. Ing. Julián Alfonso Tristancho Ortiz PhD.

AUTOMATIZACIÓN INDUSTRIAL. Plan curricular Ingeniería Industrial

INTRODUCCIÓN MATLAB / OCTAVE

MatLAB es una herramienta desarrollada por la empresa MathWorks y es el nombre abreviado de “MATrix LABoratory”. MatLAB es un programa para realizar cálculos numéricos con vectores y matrices. Como caso particular puede también trabajar con números escalares −tanto reales como complejos−, con cadenas de caracteres y con otras estructuras de información más complejas. Una de las capacidades más atractivas es la de realizar una amplia variedad de gráficos en dos y tres dimensiones. MatLAB tiene también un lenguaje de programación propio basado en la generación scripts (archivo de órdenes, archivo de procesamiento por lotes o guion es un programa usualmente simple, que por lo regular se almacena en un archivo de texto plano). MatLAB es un gran programa de cálculo técnico y científico. MatLAB dispone de un código básico y de varias librerías especializadas (toolboxes), orientadas a diferentes ramas de la ingeniería, economía, computación y matemática entre otras. Octave o GNU Octave es un programa libre para realizar cálculos numéricos. Es considerado el equivalente libre de MatLAB. Entre varias características que comparten se puede destacar que ambos ofrecen un intérprete permitiendo ejecutar órdenes en modo interactivo. Al igual que MatLAB posee librerías especializadas que se conocen como Packages. A continuación se hace una muy breve introducción al proceso de instalación de Octave, los principales comandos y funciones de cálculo y comandos del toolbox de control. Todo el contenido está orientado a Octave pero es fácilmente extensible a MatLAB.



INSTALACIÓN OCTAVE

Octave es un programa de uso libre, bajo licencia GNU y se encuentra disponible para su instalación en la dirección de internet: http://octave.sourceforge.net/. Es recomendable descargar la versión compatible con Microsoft Studio, la cual está disponible en: http://sourceforge.net/projects/octave/files/Octave%20Windows%20binaries/ La versión es actualizada continuamente, este documento usa la versión 3.6.4. Una vez descargada la última versión se debe proceder con la instalación. El instalador de manera predeterminada no instala todos los Forges disponibles (lo que corresponde a los toolbox en MatLAB), por ello se debe asegurar que este activa el checkbox activado como aparece en Figura 1 derecha.

Figura 1 Ventanas de instalación Octave. Izq. Ventana inicial y Der. Selección de packages adicionales (toolbox)

Si la instalación se realiza sobre un sistema operativo Windows 8 al iniciar la aplicación se va a presentar un problema el cual consiste en la desaparición de la línea de información de comandos, como se puede ver la Figura 2. Esto origina que cada vez que se ingresa un comando o parámetro y se oprime Enter, no se va a mostrar si el proceso ya término, ni el resultado del proceso.

Figura 2 Ventana de comandos Octave. Izq. Inicio normal y Der. Inicio anormal en Win8

http://octave.sourceforge.net/

http://sourceforge.net/projects/octave/files/Octave%20Windows%20binaries/



Para corregir el problema mostrado Figura 2 en la se debe incluir un parámetro adicional a la línea de comandos. Este parámetro consiste en agregar el texto “-i”, con lo cual se fuerza un comportamiento interactivo. La forma más fácil de incluir este parámetro es ir al escritorio de Windows, seleccionar el icono de Octave ( ), hacer click con el botón derecho del mouse y seleccionar la opción Propiedades, con lo cual se despliega la ventana mostrada en la Figura 3. En el campo Destino se debe incluir el parámetro “-i” como se muestra en la misma figura, para finalmente hacer click sobre Aceptar o Aplicar. Cada vez que se desee usar Octave se debe iniciar Octave desde este acceso directo.

Figura 3 Configuración de la ventana de propiedades de acceso de directo en escritorio para Octave



INTERFAZ DE USUARIO OCTAVE

Octave no cuenta con una interfaz de usuario como tal, en cambio usa una línea de comandos al estilo DOS. Una vez se inicia la aplicación se muestra una ventana como la mostrada en la Figura 4. Al iniciarse la aplicación Octave muestra algunos datos sobre la versión, configuración y motor de gráficas instalado. Las funciones y comandos que Octave dispone para realizar los procesos de cálculo deben ser escritos a continuación del carácter “>”. Cada vez que se ingresa un comando o se llama una función se incrementa un contador el cual aparece al lado del nombre y versión del ejecutable de Octave antes del carácter “>”.

Figura 4 Ventana de comandos en Octave

Una vez se escribe y se ejecuta un comando es posible repetir un comando anterior si se usan las flechas de navegación del teclado (↑ Comando Anterior, ↓ Comando Siguiente), una vez se llama el comando anterior es posible ejecutarlo si se hace oprime Enter. La interfaz del tipo línea de comandos presenta algunas dificultades para usar las herramientas básicas de edición como copiar y pegar, pues los comandos Crtl+V (Pegar), Crtl+X (Cortar) y Crtl+C (Copiar), están deshabilitados. El proceso de selección también no se usa de manera directa con el mouse como en las aplicaciones Windows normales. Para usar todos los procesos de selección y copiar/pegar, se debe seleccionar la herramienta desde el menú de la ventana de comandos, como se ve en la Figura 5. Para activar el menú de ventana se debe hacer click con el botón derecho del mouse sobre el icono de Octave ( ).

Información de versión y origen

Información de sistema instalado y graficador

Línea de comandos

Resultado de la operación

Identificador de línea



Figura 5 Funciones de edición en la ventana de comandos.

Para finalizar la aplicación se puede hacer click sobre el icono de Cerrar, pero esto generalmente produce un error. La mejor forma de finalizar la aplicación es usando el comando exit.

Ayuda del sistema Cada función o comando de Octave posee una ayuda que muestra la definición de parámetros o resultados obtenidos. Para obtener en pantalla este texto asociado para cada función se debe usar el comando “help” y luego escribir el nombre del comando y dar “Enter” (como se puede ver en la Figura 6), con lo cual se despliega toda la información asociada. Generalmente la información es extensa y se muestra en pantallazos en la línea de comandos, esto se ve reflejado en que el cursor del sistema queda antecedido por “:”, con lo cual para ver la siguiente línea de información aparece cada vez oprime “Enter”. Cuando se finaliza por completo la presentación de la ayuda se muestra el mensaje “END”, resaltado con sombreado. Si se desea salir del texto de ayuda en cualquier momento (incluyendo el final de la ayuda) se debe oprimir la letra “q”, con lo cual se retorna a la línea de comandos.



Figura 6 Ejecución comando “help plot” (arriba) y despliegue de ayuda resultante (abajo).

MANEJO DE VARIABLES Y MATRICES

Octave almacena en memoria del sistema valores calculados o escritos, mediante el uso del operador “=”, es así como si se quiere almacenar en disco el valor de 1 en la variable a, se debe escribir a = 1 y dar Enter. Si se desea usar una variable del tipo string o cadena de texto se debe iniciar con el carácter comillas dobles y finalizar con el carácter comillas dobles. Por ejemplo a = 1, almacena el número 1.0 en a, mientras que a = “1” almacena el carácter “1”. Octave maneja de manera indiferente los números entreros y decimales, por los cual no es necesario hacer conversión entre ellos. Entre las condiciones que deben cumplir el nombre de las variables están:

Debe iniciar siempre por un carácter alfabético, después de un carácter alfabético se pueden usar caracteres numéricos.

No debe contener caracteres especiales como *, +, ñ, -, /, ?, etc o espacios.

Octave es sensible a las mayúsculas y minúsculas en el nombre de las variables, es así como el programa Fuerza = 1, es diferente a fuerza = 1, con este ejemplo se generan dos variables Fuerza y fuerza

No pude tener un nombre igual a una función o comando interno del sistema. Por ejemplo no puede llamarse: who, ans, clear, sin, cos, etc.

Tabla 1 Comandos para manejo de memoria

Comando Descripción Ejemplo de uso

clc Borra la línea de comandos sin eliminar o cambiar ninguna variable del sistema

clc

clear

Borrar variable name de la memoria. Se puede usar all en lugar de name para indicar que se debe borrar completamente las variables

clear name clear all



whos Muestra en pantalla una lista con las variables del sistema

Whos

save

Guarda las variables del sistema en un archivo binario o de texto. Si se omite el parámetro variable, se almacena toda la memoria

save ‘-ascii‘‘nombre_archivo‘ variable

load Carga en memoria un archivo en disco en la memoria del sistema

variable = load(‘-ascii‘‘nombre_archivo‘)

Los comandos save y load son fundamentales para realizar procesos de importación y exportación de otros programas. Es común por ejemplo usar el poder cálculo de Octave para realizar tareas de number-crunching (calculo numérico de alta complejidad), mientras que el proceso de gráficación usar programas especializados del ámbito científico como: Voxler, Grapher, Surfer, etc.. u hojas de cálculo como Microsoft Excel. Cada vez que se introduzca un comando o función que arroje como resultado un número o matriz se reproduce el resultado en pantalla mediante al variable del sistema ans o una visualización del resultado obtenido, fenómeno que se conoce como eco. Si el usuario desea anular el eco de las operaciones se debe terminar todo función con el carácter “;”, como se ve en el siguiente ejemplo:

Figura 7 Diferentes resultados del mismo comando ante el mismo comando.

Octave maneja todos los valores numéricos en formato de matrices. Entonces para Octave los valores escalares son matrices de 1 x 1. Para definir las matrices de orden superior se debe usar los caracteres de corchete cuadrado ([ ]), separando cada componente de una misma fila por medio de espacio (“ “) o coma (“,”), para generar una nueva fila se debe usar el carácter punto y coma (“;”). En el siguiente ejemplo se muestra como se introducen matrices en Octave:



Figura 8 Creación de variables del tipo matriz.

El eco es importante anularlo cuando se realizan operaciones con matrices de gran tamaño, pues Octave consume mucho tiempo y recursos cada vez que necesita imprimir los resultados en pantalla, lo que hace que la operación de la aplicación se vuelva muy complicada.

Cálculos y funciones matemáticas básicas Octave tiene implementadas la mayoría de las funciones matemáticas básicas, las cuales se muestran en la Tabla 2

Tabla 2 Comandos de funciones matemáticas básicas

Operador Función matemática Ejemplo de uso

pi Constante geométrica pi pi 3.1416

* Multiplicación 5*3 ans = 15

/ División 15/3 ans = 3

+ Suma 5+3 ans = 8

- Resta 5-3 ans = 2

**, ^ Potenciación 5**3 5^3

ans = 125

sin Seno sin(0.1) ans = 0.099

cos Coseno cos(0.1) ans = 0.995

tan Tangente tan(0.1) ans = 0.100

exp Exponente en base neperiana exp(1) ans = 2.718

log Logaritmo en base neperiana log(10) ans = 2.302

Generación de matrices Octave posee varias funciones para la generación de matrices de manera automática. En la tabla siguiente se muestra los principales y su uso:



Tabla 3 Comandos de creación de matrices


zeros(n,m) Matriz de ceros con n filas y m columnas

ones(n,m) Matriz de unos con n filas y m columnas

eye(n) Matriz de identidad de n x n filas

rand(n,m) Matriz de números aleatorios con n filas y m columnas

[i:p:f] Vector fila con valor inicial i, paso de incrementos p y valor final f

Manipulación de matrices Las matrices en Octave pueden ser manipuladas valor por valor, al igual que cualquier lenguaje de programación de alto nivel. Para llamar o cambiar un valor se debe usar los paréntesis redondos de la forma variable(i,j), donde i es el número de la fila y j el número de la columna del elemento que se desea leer o editar. Es importante anotar que la numeración de las filas y columnas inicia desde 1. En la Figura 9 se muestra un ejemplo de la edición de matrices.

Figura 9 Ejemplo de edición matriz



Si se desea retomar o alterar toda una fila o columna de una matriz se puede usar el carácter “:”. Un ejemplo de su uso se muestra en la figura siguiente:

Figura 10 Ejemplo por vectores de una matriz

En la tabla siguiente se muestran algunas de las funciones básicas usadas para el cálculo en matrices.



Tabla 4 Comandos y funciones asociadas con matrices


size(matriz) Devuelve un vector que contiene el tamaño de filas, columnas de la matriz

find(matriz, oper, val)

Busca en la matriz los valores que cumplan la condición dada por el operador. La función devuelve un arreglo con los índices que cumplen la condición, numerados de arriba abajo y de izquierda a derecha iniciando en 1. Los operadores pueden ser: > Mayor, < Menor, == Igual y ~= diferente

sum(matriz) Calcula la suma de cada vector columna de una matriz

Inv(matriz) Calcula la inversa de la matriz pasada como parámetro

matriz‘ Genera la transpuesta de la matriz

.* (Multiplicar) ./ (Dividir)

.** (Exponencial)

Operadores matemáticos para cálculo celda a celda de una matriz. Son los mismo operadores básicos precedidos por el carácter “.”



Ejemplo 1. Uso de comandos básicos La serie de Leibniz es una serie infinita la cual converge hacia el valor de π/4 y por ello se puede considerar como una forma de aproximar el valor π (3.1415926535897932384626433832795). La serie de Leibniz se puede escribir como:

Mediante el uso de Octave calcular el valor de π si se aproxima con 20 términos. Determine el error con el valor de π usado por Octave. SOLUCIÓN: % Arreglo con los valores necesarios del indice n

n = [0:1:20];

% Matriz de unos negativos con el mismo tamaÃ±o de n

unos = -ones(1,21);

% Calcular el numerador de la ecuacion

num = unos.^n;

% Calcular el denominador de la ecuacion

den = (2.*n + 1);

% Calcular cada uno de los terminos de la serie

aproxpi = num./den;

% Calcular la sumatoria de la serie y multiplicador por 4

% dejar en pantalla el valor resultante

aproxpi = 4*sum(aproxpi)

% Calcular el error respecto del valor aproximado y el valor

% de pi almacenado en Octave

% dejar en pantalla el valor resultante

error = 100*(pi - aproxpi)/pi

RESULTADO:



Ejemplo 2. Solución de un sistema lineal de ecuaciones Encontrar la solución para el siguiente sistema lineal de ecuaciones.

x + 4y – 8z = -8 4x + 8y – z = 76 8x –y – 4z = 110

SOLUCIÓN:

%Crear la matriz A con los coeficientes de la ecuación

A = [[1 4 -8];[4 8 -1];[8 -1 -4]];

%Crear vector con los valores de términos independientes

b = [-8 76 110];

%Convertir el vector fila de b, en vector columna

b = b';

% Calcular el vector resultado x = A^-1*b

% dejar en pantalla los valore resultantes

x = inv(A)*b

RESULTADO

Manipulación de polinomios Octave utiliza la representación mediante vectores filas para manipular polinomios. Cada término del vector representa el coeficiente que multiplica a la variable independiente y su posición de derecha a izquierda su exponente creciente de uno en uno iniciando en cero. Es así que un vector [3 0 1 2] equivale a un polinomio: 3x3+x+2, o el polinomio 2x3-x2+5x+2 se representaría en Octave con el vector fila [2 -1 5 2]. Algunas de las funciones disponibles en Octave para la creación o manipulación de polinomios se encuentran descritas en la siguiente tabla



Tabla 5 Comandos y funciones asociadas con matrices


roots(vector) Calcula las raíces de un polinomio

conv(vector1, vector2)

Multiplica dos vectores, vector1 y vector2

polyval(vector, valores)

Evalúa el polinomio con todos los valores pasados como parámetros

polyfit(vectorx, vectory, orden)

Ajusta una serie de puntos (vectorx, vectory) al polinomio de orden indicado por el método de los mínimos cuadrados. Retorna el polinomio de mejor ajuste



PROCESOS BÁSICOS PARA GRÁFICOS

Una de las funcionalidades más importantes que posee Octave es la capacidad de dibujar datos o funciones en 2D y 3D, como las que se pueden ver en la Figura 11. En esta sección solo se trataran los temas relacionados con dibujo de funciones 2D, dado que son las más usadas en el ámbito de ingeniería de control.



Figura 11 Ejemplos de algunos tipos de gráficas que se pueden obtener con Octave

Octave maneja dos diferentes Graphics backend o librerías de dibujo (gnuplot y fltk), las cuales cuando es instalada la aplicación, se permite seleccionar cual desea usar por defecto. Es posible cambiar la librería si se usa la función graphics_toolkit(‘nombre_libreria‘). En esencia la diferencia radica en el consumo de memoria, mientras fltk tiene unos requerimientos de memoria



muy bajos, gnuplot al poseer una interfaz de usuario más completa requiere menos recursos del sistema (ver Figura 12).

Figura 12 Resultado de dibujar función seno, con fltk (izq) y gnuplot (der)

En la siguiente tabla se hace un breve resumen de los comandos básicos de dibujo y sus parámetros de configuración



Tabla 6 Comandos y funciones asociadas el dibujo de funciones en 2D

Comando Descripción

h = plot(vectorx, vectory, param)

Función que crea una nueva gráfica en 2D, usando como datos en x vectorx y datos en y vectory. Si vectory tiene varias columnas se dibujara una curva por cada una. Se dibuja según los parámetros param. La función plot devuelve un identificador único que puede ser usado para configurar individualmente sin tener que ser la figura actual (h). El termino param es un texto que configura la forma como Octave dibuja la gráfica. Entre los parámetros de dibujo están:

Color línea: y (amarillo), m (magenta), c(cian), r(rojo), g(verde), w(blanco) y k (negro) Carácter de punto: ‘.’ Puntos, ‘o’ círculos, ‘x’ cruces, ‘+’ cruces, ‘*’ asteriscos, ‘s’ cuadrados, ‘d’ diamantes. Tipo de línea: ‘-’continua, ‘:’ puntos, ‘-.’ punto, ‘--’ trazos. Ancho de línea: se debe introducir la palabra clave ‘linewidth’ y luego el ancho deseado. Tamaño de marcas: se debe introducir la palabra clave ‘markersize’ y luego el tamaño deseado.

title(nombre) Ubica el texto nombre como título de la figura que se esta dibujando

xlabel(nombre) Ubica el texto nombre bajo el eje de las x en la gráfica actual

ylabel(nombre) Ubica el texto nombre al lado izquierda del eje de las y de la gráfica actual

legend(‘nombre1’, ‘nombre2’, …)

Crea un cuadro en el cual se define la leyenda de lectura para la gráfica actual, usando nombre1 en la curva1, nombre 2 en la curva 2, etc..

grid param Controla la visualización de la grilla de la gráfica. Si param es on la enciende, si param es off la apaga.

axis[xmin, xmax, ymin, ymax]

Configura el área de dibujo que se desea obtener, al limitar los valores de mínimos y máximos de cada eje de la gráfica

figure Abre una nueva ventana para gráficar, con lo cual una gráfica anterior queda independiente de la actual

hold param Mantiene como activa la gráfica actual (param = ‘on’), con lo cual no se borra el dibujo anterior, cuando se procesa a dibujar una nueva gráfica.

close param Cierra la figura actual o todas si param = ‘all’

subplot(filas, columnas, índice)

Crea una figura de filas x columnas que está conformada por varias gráficas normales independientes. Para su uso se debe iniciar siempre con la función subplot, indicar la gráfica (índice) que se va a cambiar y luego usar de manera normal cada una de las funciones de gráficación escritas a continuación de la función subplot (sin hacer Enter, solo separado por un espacio)

print(h, ‘archivo’) Guarda en disco la figura actual (si no se suministra h) o la figura identificada con h, en el directorio y nombre, pasado en ‘archivo’



Existen de igual manera funciones de dibujo que usan la misma estructura de generación que la función plot, pero que generan diferentes resultados, como lo son:

semilogx: Dibujo con el eje en x logarítmico

semilogy: Dibujo con el eje en y logarítmico

loglog: Dibujo con el eje en x e y logarítmico

polar: Dibujo polar

bar: Dibujo de barras

Ejemplo 3. Ajuste de datos a una línea recta (Regresión lineal) Se desea construir un centro comercial, cerca de un centro urbano. Para ello se hizo un estudio de los centros ya existentes y se encontró que en promedio la asistencia de clientes diarios con respecto a la distancia de la ciudad es:

Nº de clientes 800 700 600 400 200 100

Distancia (Km) 15 19 25 23 34 40

Determine un modelo lineal que pueda predecir el comportamiento de los números de clientes con respecto a la distancia. SOLUCIÓN:

%Almacenar los datos de numero de clientes

C = [800 700 600 400 200 100];

%Crear vector con los valores Distancias

D = [15 19 25 23 34 40];

%Cerrar todas las Gráficas

close all;

%Calcular la regresiÃ³n lineal que se ajustan al modelo

ajus=polyfit(D,C,1);

%Crear vectores de dibujo del modelo calculado

x = 0:10:40;

y = polyval(ajus,x);

%Dibujar la distribucion de puntos, distancia vs clientes

plot(D,C,'ob');

%Mantener la Gráfica activa

hold on;

%Dibujar los puntos del modelo distancia clientes

plot(x,y,'r','linewidth',4);

%Configurar etiquetas

title('Modelo de clientes en funcion de la distancia');

xlabel('Distancia en Km');

ylabel('Clientes promedio');

legend('Datos', 'Modelo lineal');

grid on;

ajus

RESULTADO:



Figura 13 Gráfica de salida Ejemplo 3

Ejemplo 4. Uso de gráficas múltiples (Funciones paramétricas) Si se toma el conjunto de funciones paramétricas definida de la siguiente manera:

Estas figuras tienen un gran conjunto de curvas diferentes dependientes de los parámetros a y b. Dibuje en una misma ventana 4 Gráficas independientes donde se muestre el resultado de cuatro pares de valores a y b. SOLUCIÓN:

%Borrar la linea de comandos y cerrar las Gráficas

clc;

close all;

%Iniciar la variable parametrica t

t = 0:0.05:10*pi;

%Calcular cada una de las funciones que se van a dibujar

a = 1;

b = 3;

x1 = (a-b)*cos(t)+b*cos(t*((a/b)-1));

y1 = (a-b)*sin(t)-b*sin(t*((a/b)-1));

a = 20;

b = 1;

x2 = (a-b)*cos(t)+b*cos(t*((a/b)-1));

y2 = (a-b)*sin(t)-b*sin(t*((a/b)-1));

a = 1;

b = 20;

x3 = (a-b)*cos(t)+b*cos(t*((a/b)-1));

y3 = (a-b)*sin(t)-b*sin(t*((a/b)-1));

a = 11;

b = 30;

x4 = (a-b)*cos(t)+b*cos(t*((a/b)-1));



y4 = (a-b)*sin(t)-b*sin(t*((a/b)-1));

%Crear la ventana con 4 figuras

subplot(2,2,1);

hold on;

%Dibujar cada una de las figuras

subplot(2,2,1); plot(x1,y1);

subplot(2,2,1); title('a = 1 y b = 10');







RESULTADO:




PROGRAMACIÓN EN OCTAVE

Octave tiene un lenguaje de programación el cual está basado en el concepto de Script (ejecución sucesiva de comandos y funciones almacenadas en un archivo de texto). Estos script deben ser almacenados en archivos de texto plano con extensión *.m. Para llamar un script se debe escribir el nombre del archivo con path incluido, teniendo en cuenta que los paths de archivos en Octave se debe usar “/”, en lugar de “\”. Por ejemplo el archivo “C:\windows\System32\xwizard.m”, debería ser llamado escribiendo: “C:/Windows/System32/xwizard.m”. El comando que se debe usar para Octave ejecute un script es run(“path/archivo.m”), entonces para el ejemplo anterior se debería escribir run(“C:/Windows/System32/xwizard.m”). Para evitar conflictos por el nombre del path o archivos se recomienda nunca utilizar nombres con acentuación, ñ o espacios. Octave también maneja el concepto de directorios de trabajo, con lo cual cada vez que se llame un script sin path de búsqueda, se procederá a buscar en cada uno de estos directorios de trabajo, si no se encuentra, se generara un error. El comando path despliega la lista de directorios de trabajo como se muestra a continuación:

Figura 15 Resultado uso comando path

Es posible agregar un nuevo path de trabajo con el comando addpath(“directorio”). Es necesario agregar cada vez que se inicie una nueva sesión de Octave, pues cuando se finaliza la aplicación la información de directorios de trabajo se reinicia. Para los scripts se presenta el mismo fenómeno de sensibilidad a las letras minúsculas y mayúsculas, por lo tanto se recomienda nombrar los archivos con todas las letras en minúsculas o mayúsculas. Para ejecutar un script cuando se ha usado el comando addpath, solo es necesario escribir el nombre del archivo *.m en la línea de comandos, sin la extensión, ni comillas y respetando las minúsculas y mayúsculas que se hayan usado en el nombre del archivo. A continuación se muestra un ejemplo de cómo ejecutar un script de los ejemplos descritos en este documento, todo los archivos *.m están almacenados en la carpeta “C:\EjmOct”.



Figura 16 Llamado a ejecución de scripts almacenados en un directorio de trabajo

Alguno de los comandos más utilizados en programación con Octave se encuentran descritos a continuación:



Tabla 7 Comandos y funciones asociadas a la escritura de scripts

Comando Descripción

% Comentario. Si una línea del script inicia con ese carácter la línea se omitirá

disp(“texto”) Muestra un texto en la línea de comandos, es útil para mostrar avances o posiciones de cálculo dentro de un script

a = input(“texto”) Detiene la ejecución de un script y espera que el usuario ingrese un valor

if (condición) código_si else código_sino end

Ejecuta una parte de código (código_si) cuando la condición es verdadera. Si la condición no es verdadera se ejecuta el código puesto entre el else y end (código_sino). Las condiciones de verificación son:

(x < y) Verdadero si x es menor que y (x <= y) Verdadero si x es menor o igual que y (x == y) Verdadero si x es igual a y (x >= y) Verdadero si x es mayor o igual que y (x != y) o (x ~= y) Verdadero si x no es igual a y !x Niega x (el valor de verdad) x | y x o y (Función lógica or) x & y x e y (Función lógica and)

while (condición) código end

Ciclo de repetición para el código escrito entre las sentencias while y end. El ciclo se repite hasta que la condición sea falsa.

Para generar los scripts se puede usar cualquier editor de texto plano como el Bloc de Notas de Windows ( ), pero se recomienda el editor Notepad++, que es un editor de uso libre disponible en http://notepad-plus-plus.org/. Esta aplicación tiene como principal ventaja la tabulación automática, numeración de líneas y reconocimiento de funciones básicas de Octave. En la figura siguiente se puede observar como es la visualización y edición de un script en Notepad++.

Figura 17 Edición de scripts en Notepad++

http://notepad-plus-plus.org/



Ejemplo 5. Dibujo de funciones con parámetros variables De la función y(t) = Sin(2πft) + Cos(Aπf t) se desea obtener una gráfica en la cual se dibujen 5 curvas basadas en un rango de A determinado por el usuario y una frecuencia angular también dada por el usuario, pero constante. Genere un script en Octave que realice esta tarea. SOLUCIÓN: %Borrar la linea de comandos y cerrar las Gráficas clc; close all; %Pedir datos del problema al usuario Amin = input('Valor minimo de A: '); Amax = input('Valor maximo de A: '); NumGraf = 3; %Verificar integridad de los datos if(Amax > Amin) %Pedir datos del problema al usuario f = input('Frecuencia de la funcion (Hz): '); %Calcular el paso de incremento paso = (Amax - Amin)/NumGraf; %Iniciar la variable A = Amin; %Iniciar el vector de tiempo t = [0:0.01:5]; %Iniciar contador de Gráfica i = 1; %Iniciar matriz de datos y = zeros(NumGraf,501); %Crear las diferenes Gráficas disp('Calculando Gráficas'); while(A < Amax) %llenar los valores de la matriz de dibujo y(i,:) = sin(2*pi*f*t) + sin(A*pi*f*t); A = A + paso; i = i + 1; end %Dibujar las Gráficas resultantes plot(t,y,'linewidth',2); %Configurar la Gráfica legend('C1', 'C2', 'C3', 'C4'); legend('boxon'); grid on; disp('Dibujo de Gráficas terminado'); else %Error en los parametros de etrada disp('Los valores ingresados no son validos!!') end

RESULTADO:



PACKAGE DE CONTROL

Los toolbox o package de Octave, son colecciones de funciones especializadas agrupadas por tema y que pueden ser llamadas desde la ventana de comandos de igual forma que las funciones básicas. Los package deben ser seleccionados e instalados como se explica en la sección INSTALACIÓN OCTAVE. Para poder utilizar las funciones implementadas dentro del package, se debe cargar la librería antes de llamar las funciones instaladas. Para ello se debe llamar la función pkg load “nombre”, por lo tanto para cargar las funcionalidades de la librería de control se debe escribir en la línea de comandos pkg load “control”. Si al ejecutar el comando no se recibe ningún mensaje en la línea de comandos, esto indica que el proceso se realizó de manera satisfactoria. Los sistemas de control continuo son representados mediante el uso de ecuaciones diferenciales, las cuales usando la transformada Laplace, se convierten en sistemas del tipo polinomial y es así como Octave maneja estos sistemas. El manejo de polinomios se explicó en la sección Manipulación de polinomios. Las funciones principales del package de control se encuentran descritas en la tabla siguiente:



Tabla 8 Comandos y funciones asociadas el dibujo de funciones en 2D


tf(num, den)

Genera una función de transferencia a partir de los parámetros num (numerador) y den (denominador). Tanto num y den deben estar escritos en formato de polinomios y representan las ecuaciones diferenciales en transformada de Laplace

+ / *

Operaciones básicas entre funciones de transferencia

pole(tf) zero(tf)

pzmap(tf)

Devuelve un vector con los polos (función pole) o ceros (función zero) de la función de transferencia tf. En una función de transferencia los polos son las raíces del denominador y los ceros son las raíces del numerador. La función pzmap, dibuja los polos y ceros en una nueva gráfica.

feedback(G,H,±1)

Calcula la función de transferencia total para un sistema realimentado con la siguiente estructura. El termino ±1 asigna el signo de realimentación.

minreal(tf) Realiza la simplificación de ceros y polos de una función de transferencia.

step(tf) [y t] = step(tf)

Aplica una señal de entrada tipo paso a la función de transferencia tf. Si no se almacenan el vector tiempo t ni el vector de respuesta en el tiempo y, se genera una gráfica donde se muestra la respuesta

lsim(tf,u,T) [y t] = lsim(tf,u,T)

Aplica una señal de entrada definida por el usuario a la función de transferencia tf, vector de entrada u y vector tiempo T. Si no se almacenan el vector tiempo t ni el vector de respuesta en el tiempo y, se genera una gráfica donde se muestra la respuesta



Ejemplo 6. Modelamiento matemático de un sistema masa resorte Realizar el modelamiento matemático (función de transferencia) del sistema mostrado en la Figura 19. Simular el sistema ante diferentes entradas sinusoidal con frecuencia variable para encontrar la frecuencia de resonancia del sistema. k = 100 KN/m, c = 500 Ns/m, m = 10 Kg y f(t) = 1000*cos(120*t) N

Figura 19 Sistema masa amortiguador resorte

SOLUCIÓN:

1. Se hace el análisis dinámico de fuerzas del sistema

∑

( ) ( ) ( ) ( )

( ) ( ) ( ) ( )

2. Se aplica la transformada de Laplace asumiendo condiciones iguales a cero y se calcula la función de transferencia.

( ) ( ) ( ) ( )

( )( ) ( )

( )

( )

( )

( )

3. Se procede implementar el siguiente script %Asegurar la carga del toolbox de control,

%OJO ELIMINAR SI ESTA USANDO MATLAB

pkg load control;

%Borrar la linea de comandos y cerrar las Gráficas

clc;

close all;

%Parametros del modelo



k = 100000; %Resorte

c = 500; %Amortiguador

m = 10; % Masa

%Crear la función de transferencia

num = 1;

den = [m c k];

disp('Funcion de transferencia:')

fun = tf(num,den)

%Simular la respuesta de la planta a paso

[y t] = step(fun);

subplot(2,2,1); plot(t,y);

subplot(2,2,1); title('Respuesta entrada paso');

subplot(2,2,1); xlabel('tiempo (s)');

subplot(2,2,1); ylabel('Desplazamiento (m)');

%Simular la respuesta ante entrada f(t)

t = 0:0.001:1;

f = 1000*cos(120*t);

[y t] = lsim(fun,f,t);

%Gráficar los resultados

subplot(2,2,2); plotyy(t,y,t,f);

subplot(2,2,2); title('Entrada/Salida planta');

subplot(2,2,2); xlabel('Tiempo(s)');

%Generar variación de frecuencia en la señal de entrada

disp('Calculando la respuesta a frecuencia variable')

%Variable que cambia la frecuencia de la entrada

frec = 2*pi;

i = 1;

A = zeros(5000);

x = A;

%Calcular las amplitudes de la señales de salida

while (frec <= 400)

f = 1000*cos(frec*t);

[y t] = lsim(fun,f,t);

Amp = (max(y)-min(y))/2;

A(i) = Amp;

x(i) = frec/(2*pi);

i = i + 1;

frec = frec + 0.5;

end

%Dimensionar el arreglo de datos

A = A(1:i-1);

x = x(1:i-1);

%Dibujar las diferentes Gráficas de analisis

subplot(2,2,3); semilogx(x,A);

subplot(2,2,3); title('Respuesta a la frecuencia');

subplot(2,2,3); xlabel('Frecuencia(Hz)');

subplot(2,2,3); ylabel('Amplitud(m)');

subplot(2,2,3); grid on;

disp('Proceso terminado..')



RESULTADO:

Figura 20 Gráfica resultado Ejemplo 6



Ejemplo 7. Uso package de control en Octave Los exploradores de energía solar enviados a Marte son vehículos autónomos semi-guiados de manera remota. Equipados con equipos de telecomunicación, cámaras y computadores. Para el control del Rover se han planteado dos soluciones, una con un compensador en lazo abierto y otro con un sistema en lazo cerrado. En la siguiente figura se muestra las dos estrategias de control y una fotografía del Marts Rover.

Figura 21 Marts rover. a) vista exterior, b) compensador en lazo abierto y c) control en lazo cerrador

Determine el comportamiento del rover en lazo abierto, con el compensador en lazo abierto y cree un lazo cerrado con un controlador PID, sintonizándolo según el criterio de Ziegler y Nichols. SOLUCIÓN: %Asegurar la carga del toolbox de control,

%OJO ELIMINAR SI ESTA USANDO MATLAB

pkg load control;

%Borrar las variables, gráficas y pantalla anteriores

clear all;

close all;

clc;

%Crear la funcion de transferencia del rover y controlador en lazo abierto

%Funciones de transferencias

num = [1];

den = conv([1 1],[1 3]); %Calculo el producto de las dos raices independientes

rover = tf(num, den)

num = conv([1 1],[1 3]); %Calculo el producto de las dos raices independientes

den = [1 4 5];

conopen = tf(num, den)

[yo to] = step(conopen*rover, 5);

[y t] = step(rover, 5);

%Crear la grafica de respuesta de la planta con control de lazo abierto y sin

control

figure();

plot(to,yo,t,y,t,ones(size(t)));

a)

b)

c)



axis([0 5 0 1.1]); %Configurar los ejes de la grafica

%Establecer las leyendas de la grafica.. esto solo funciona en Octave

legend('{\fontsize{8} Lazo Abierto}', '{\fontsize{8} Sin Control}',

'{\fontsize{8} Entrada}');

legend('boxon');

grid on;

xlabel('Tiempo(s)');

ylabel('Posicion');

title('Respuesta de la planta');

disp('');

input('Respuesta del rover en lazo abierto y sin control (PRESS ENTER)');

%Establecer comportamiento de la planta con control Proporcional

figure();

subplot(2,1,1);

%Solo valido en Octave y con la funcion rlocus2.m en la carpeta de trabajo

[Rdata Ks] = rlocus2(rover); %Guardar los valores de ubicación de los

polos y las Ks

rlocus(rover);

%Visualizar el comportamiento ante diferentes Ks

subplot(2,1,2);

%Calcular la respuesta en para diferentes Ks

[yo to] = step(feedback(1*rover), 5);

[y1 t1] = step(feedback(50*rover), 5);



plot(to,yo,t1,y1,t2,y2,t3,y3,t,ones(size(t)));

legend('{\fontsize{8} Kp=1}', '{\fontsize{8} Kp=50}', '{\fontsize{8} Kp=200}',

'{\fontsize{8} Kp=500}', '{\fontsize{8} Entrada}');

legend('boxon');

grid on;


ylabel('Posicion');

title('Respuesta de la planta controlador P');

disp('');

input('Respuesta del rover en lazo cerrado con control P (PRESS ENTER)');

disp('');

disp('*************************************************');

disp('Proceso de sintonizacion de controlador PID Ziegler & Nichols');

disp('');

%Sintonizar el control PID

%Calcular la respuesta en para diferentes Ks

step(rover, 8);

grid on;


ylabel('Posicion');

title('Respuesta de la planta sin controlador paso unitario');

T = input('Introduzca la constante de tiempo (T): ');

L = input('Introduzca el retraso de respuesta (L): ');

K = yo(size(yo,1));

%Ganancia de un contrador tipo P

Kp = T/(K*L);

%Calcular la funcion de transferencia en lazo cerrado

GscontKp = tf(Kp,1);

%Ganancia de un contrador tipo PI



Kpi_p = 0.9*T/(K*L);

Kpi_i = Kpi_p / (L/0.3);

%Calcular la funcion de transferencia del contraldor I

GscontKpi = tf(Kpi_p,1)+tf([Kpi_i], [1 0]);

%Ganancia de un contrador tipo PID

Kpid_p = 1.2*T/(K*L);

Kpid_i = Kpid_p / (2*L);

Kpid_d = Kpid_p * (0.5*L);

%Calcular la funcion de transferencia del contraldor I

GscontKpid_i = tf([Kpid_i], [1 0]);

%Calcular la funcion de transferencia del contraldor D

GscontKpid_d = tf([Kpid_d 0], [0 1]);

%Calcular la funcion de transferencia en lazo cerrado

GscontKpid = tf(Kpid_p,1) + GscontKpid_i + GscontKpid_d;

%Calcular la respuesta en para diferentes controladores

[yo to] = step(rover, 10, 0.01);

[y1 t1] = step(feedback(GscontKp*rover), 10, 0.01);

[y2 t2] = step(feedback(GscontKpi*rover), 10, 0.01);

[y3 t3] = step(feedback(GscontKpid*rover), 10, 0.01);

%Dibujar las respuestas de la planta ante los diferentes controladores

figure();

plot(to,yo,t1,y1,t2,y2,t3,y3,t,ones(size(t)));

legend('{\fontsize{8} Sin control}', '{\fontsize{8} Control P}', '{\fontsize{8}

Control PI}', '{\fontsize{8} Control PID}', '{\fontsize{8} Entrada}');

legend('boxon');

grid on;


ylabel('Posicion');

title('Respuesta de la planta controladores P, PI y PID');

%Calcular las señales de control para cada controlador

figure();

e1 = ones(size(t1)) - y1;



[y1 t1] = lsim(GscontKp, e1, t1);

[y2 t2] = lsim(GscontKpi, e2, t2);

%Es necesario hacer un truco, pues el numerador es de mayor orden que el

denominador

%se le aplica un integrador

[y3 t3] = lsim(GscontKpid*tf(1,[1 0]), e3, t3);

%ahora se deriva para obtener la señal original

y3 = diff(y3);

y3(size(y3)+1) = 0;

y3 = y3 ./ t3(2);

plot(t1,y1,t2,y2,t3,y3);

legend('{\fontsize{8} Control P}', '{\fontsize{8} Control PI}', '{\fontsize{8}

Control PID}');

legend('boxon');

grid on;


ylabel('Posicion');

title('Magnitud de actuación de la planta controladores P, PI y PID');

%Escribir un pequeño resumen de las ganancias calculadas

disp('');



disp('Resumen de ganancias del controlador');

disp('');

disp('Controlador P');

Kp

disp('');

disp('Controlador PI');

Kpi_p

Kpi_i

disp('');

disp('Controlador PID');

Kpid_p

Kpid_i

Kpid_d

disp('');

disp('Proceso de calculo terminado');

RESULTADO:

Figura 22 Figuras de resultado control Marts Rover



Figura 23 Linea de comandos código Ejemplo7.m

uso octave-matlab control

Documents