22 de noviembre de 2012

Controlabilidad y Observabilidad

Automatización y Control de Sistemas Dinámicos
Laboratorio: Entrada 7

Como última entrega de laboratorio seleccioné un problema del libro Sistemas de Control Moderno, y este pide determinar si el sistema tiene controlabilidad y observabilidad, usando las funciones del paquete control en Octave.

El problema es el siguiente:
Un motor de corriente continua tiene un modelo de variables de estado como se muestra a continuación.

$\dot x= \begin{bmatrix}{-3}&&{-2}&&{-0.5}&&{0}&&{0}\\ {2}&&{0}&&{0}&&{0}&&{0}\\ {0}&&{2}&&{0}&&{0}&&{0}\\ {0}&&{0}&&{1}&&{0}&&{0}\\ {0}&&{0}&&{0}&&{2}&&{0}\end{bmatrix}x+ \begin{bmatrix}{1}\\{0}\\{0}\\{0}\\{0}\end{bmatrix}u$

$y=\begin{bmatrix}{0}&&{0}&&{0}&&{0}&&{1.25}\end{bmatrix}x$

Determinar si el sistema es controlable y observable.

Utilizando las funciones ctrb para obtener la matriz de controlabilidad y obsv para obtener la matriz de observabilidad, podremos obtener la determinante de cada una de estas matrices.

Se sabe que cuando la determinante de la matriz de observabilidad da como resultado un valor diferente de cero, el sistema es observable y que cuando la determinante de la matriz de controlabilidad da como resultado un valor diferente de cero, el sistema es controlable.

Por lo tanto cree en octave funciones simples que hacen uso del paquete control para determinar si el sistema dado, en este caso en la forma de espacio de estados, es controlable y observable.

Este script tiene definidas las funciones "controlabilidad" y "observabilidad", y una más que hace la llamada a estas dos anteriores y yo la llamo "verificar".

Este es el código en octave.


Ahora para poder determinar si el sistema es controlable y observable pasamos las matrices del espacio de estados a matrices en octave. Esta las declaramos como se muestra a continuación.


$\begin{bmatrix}{-3}&&{-2}&&{-0.5}&&{0}&&{0}\\ {2}&&{0}&&{0}&&{0}&&{0}\\ {0}&&{2}&&{0}&&{0}&&{0}\\ {0}&&{0}&&{1}&&{0}&&{0}\\ {0}&&{0}&&{0}&&{2}&&{0}\end{bmatrix}$
A = [-3 -2 -0.5 0 0;2 0 0 0 0;0 2 0 0 0;0 0 1 0 0;0 0 0 2 0];

$\begin{bmatrix}{1}\\{0}\\{0}\\{0}\\{0}\end{bmatrix}$
B = [1; 0; 0; 0; 0];

$\begin{bmatrix}{0}&&{0}&&{0}&&{0}&&{1.25}\end{bmatrix}$
C = [0 0 0 0 1.25];

Ahora es así como cargamos el módulo con las funciones de controlabilidad y observabilidad y creamos las matrices así como se mostró anteriormente.

octave:1> source 'contr-obser.m'
octave:2> A = [-3 -2 -0.5 0 0; 2 0 0 0 0; 0 2 0 0 0; 0 0 1 0 0; 0 0 0 2 0];
octave:3> B = [1; 0; 0; 0; 0];
octave:4> C = [0 0 0 0 1.25];
octave:5> verificar(A, B, C)
------------------------
Matriz de controlabilidad
contr =

    1   -3    5   -5    1
    0    2   -6   10  -10
    0    0    4  -12   20
    0    0    0    4  -12
    0    0    0    0    8

Determinante
deter =  256
CONTROLABLE
------------------------
Matriz de observabilidad
obser =

    0.00000    0.00000    0.00000    0.00000    1.25000
    0.00000    0.00000    0.00000    2.50000    0.00000
    0.00000    0.00000    2.50000    0.00000    0.00000
    0.00000    5.00000    0.00000    0.00000    0.00000
   10.00000    0.00000    0.00000    0.00000    0.00000

Determinante
deter =  390.62
OBSERVABLE
------------------------
octave:6>
Podemos ver en las impresiones que el resultado de las determinantes es diferente de cero por lo tanto el motor de corriente continua es controlable y observable.

Referencias:
Sistemas de Control Moderno, 10ma edición, Richard C. Dorf, Robert H. Bishop, PEARSON.

20 de noviembre de 2012

Proyecto de Redes Neuronales

Redes Neuronales Artificiales
Presentación Final: Reporte y Programa

Este es el reporte final para la materia de Redes Neuronales Artificiales, en la cual estuve trabajando en el proyecto de Reconocimiento de Personas Mediante Voz, en conjunto con mis compañeros Cecilia Urbina y Roberto Martínez.

El objetivo del proyecto fue crear un sistema funcional que permita identificar si un usuario es el correcto o no, mediante su voz. Esto dentro de un sistema que muestre una ventana y que de un texto que tendrá que ser leído por la persona que intenta autentificarse, el audio es captado y analizado, y crea una entrada de datos a la red neuronal la cual se encargara de decir en su salida si el usuario fue identificado o no, y mostrar el resultado finalmente mediante una ventana.

Trabajo grupal


En la siguiente captura se muestran los commits realizados en Octubre y Noviembre desde una semana después de haber presentado el examen de medio curso, y con esto podemos crear evidencia del trabajo realizado.



Estuvimos haciendo cambios en el código que ya teníamos hasta la mitad del curso, de ahí en adelante fueron cambios que tuvieron que ver con la separación del código en clases.

Entre las clases que creamos están la de la Neurona y la de la Red, en las cuales se definen la cantidad de neuronas a utilizar y donde se hace el proceso de generación del vector de pesos, así como el aprendizaje de la Neurona.

Entre los cambios que podemos resaltar, y que se puede evidenciar mediante los últimos commits tenemos:
  • Separación del código en clases
  • Análisis con PCA
  • Creación de la clase interfaz
  • Aprendizaje con dos neuronas
  • Generación de un vector de pesos bueno
  • Reconocimiento funcional


Código


El código completo y las partes en las que yo contribuí están en el repositorio, enseguida se encuentra la liga directa.


El siguiente es el código de la clase Neurona, donde estuve haciendo algunas modificaciones para que fuera útil para el programa que inicia el aprendizaje y el programa que verifica los usuarios que necesita recibir la salida generada por la neurona.


Vídeo demostración


El siguiente vídeo muestra el funcionamiento de dos neuronas que separan cuatro clases, con datos generados con una versión más reciente el programa generador de vectores de entrada.


Presentación en equipo


Integrantes del equipo:


19 de noviembre de 2012

Proyecto de Automatización

Automatización y Control de Sistemas Dinámicos
Reporte Final

El reporte, presentación y código del proyecto final se encuentra en el siguiente enlace al blog del compañero Roberto Martínez.


15 de noviembre de 2012

Representación en el Espacio de Estados

Automatización y Control de Sistemas Dinámicos
Laboratorio: Entrada 6

Una representación de espacios de estados es un modelo matemático de un sistema físico descrito mediante un conjunto de entradas, salidas y variables de estado relacionadas por ecuaciones diferenciales de primer orden que se combinan en una ecuación diferencial matricial de primer orden. Para prescindir del número de entradas, salidas y estados, las variables son expresadas como vectores y las ecuaciones algebraicas se escriben en forma matricial. La representación de espacios de estado, también conocida como aproximación en el dominio del tiempo, provee un modo compacto y conveniente de modelar y analizar sistemas con múltiples entradas y salidas. [1]

Por lo tanto resulta conveniente utilizar la representación de espacio de estados cuando se requiere analizar sistemas de control que poseen más de una entrada y/o más de una salida, ya que se reduce la complejidad en las expresiones matemáticas utilizadas.

Para esta entrega seleccioné un problema del Capítulo 11, Análisis de Sistemas de Control en el Espacio de Estados, del libro Ingeniería de Control Moderna.

El problema es el siguiente:
Obtener con Octave una representación mediante la función de transferencia del sistema siguiente.

$\begin{bmatrix}{\dot x_1}\\{\dot x_2}\\{\dot x_3}\end{bmatrix}= \begin{bmatrix}{2}&&{1}&&{0}\\{0}&&{2}&&{0}\\{0}&&{1}&&{3}\end{bmatrix} \begin{bmatrix}{x_1}\\{x_2}\\{x_3}\end{bmatrix}+ \begin{bmatrix}{0}&&{1}\\{1}&&{0}\\{0}&&{1}\end{bmatrix} \begin{bmatrix}{u_1}\\{u_2}\end{bmatrix}$

$y=\begin{bmatrix}{1}&&{0}&&{0}\end{bmatrix} \begin{bmatrix}{x_1}\\{x_2}\\{x_3}\end{bmatrix}$

Para empezar hay que saber que es posible representar el modelo de un sistema mediante su función de transferencia o su espacio de estados. Octave provee de funciones en el paquete signal para transformar de una representación a otra, es decir, nuestra función de transferencia la podemos representar en un espacio de estados, y viceversa.

Primero me enfocaré a resolver lo que el problema pide, que es obtener la función de transferencia desde el espacio de estados.

Transformación del espacio de estados a una función de transferencia

Para obtener la función de transferencia desde el espacio de estados, usamos la siguiente orden en octave.
[num, den] = ss2tf(A, B, C, D)

Para el espacio de estados descrito anteriormente en el problema, desde octave escribimos lo siguiente.

octave:1> pkg load signal
octave:2> A = [2 1 0; 0 2 0; 0 1 3]
A =

   2   1   0
   0   2   0
   0   1   3

octave:3> B = [0 1; 1 0; 0 1]
B =

   0   1
   1   0
   0   1

octave:4> C = [1 0 0]
C =

   1   0   0

octave:5> D = [0 0]
D =

   0   0

octave:6> [num, den] = ss2tf(A, B, C, D)
num = 
{
  [1,1] =  1.00000
  [1,2] =  1.00000
}
den = 
{
  [1,1] =

     1.0000  -4.0000   4.0000

  [1,2] =

     1.0000  -2.0000

}
octave:7>

Vemos que octave nos arroja dos arreglos, uno para la variable "num" y otro para la variable "den", cada uno con dos elementos dentro. Esto significa que este espacio de estados contempla dos funciones de transferencia, así que tomamos el primer elemento de "num" con el primero de "den" para formar una función de transferencia, y el segundo elemento de "num" y el segundo elemento de "den" para la segunda función de transferencia.

Entonces nuestro resultado queda como sigue.

$\dfrac {Y(s)}{U_1(s)} = \dfrac {1}{s^2 - 4s + 4}$

$\dfrac {Y(s)}{U_2(s)} = \dfrac {1}{s - 2}$

Ahora veamos el caso contrario.

Formulación en el espacio de estados de sistemas basados en una función de transferencia

Ahora lo que queremos es obtener el espacio de estados, desde una función de transferencia.

Para esto la orden usada en octave es:
[A, B, C, D] = tf2ss(num, den)
Entonces si tenemos la siguiente función de transferencia.

$\dfrac {Y(s)}{U(s)} = \dfrac {10s+10}{s^3 + 6s^2 + 5s + 10}$

En octave escribimos el numerador y el denominador de la siguiente manera, para después mandarlos como parámetros a la orden en octave.

octave:1> pkg load signal
octave:2> num = [0 0 10 10];
octave:3> den = [1 6 5 10];
octave:4> [A, B, C, D] = tf2ss(num, den)
A =

   -0.00000   -0.00000    1.00000
    1.00000   -0.00000    0.50000
    0.00000  -10.00000   -6.00000

B =

   1.00000
   1.00000
   0.00000

C =

   0   0  -1

D = 0
octave:5>

Lo que nos arroja en este caso son matrices, que son las que forman parte del espacio de estados, y las representamos así.

$\begin{bmatrix}{\dot x_1}\\{\dot x_2}\\{\dot x_3}\end{bmatrix}= \begin{bmatrix}{0}&&{0}&&{1}\\{1}&&{0}&&{0.5}\\{0}&&{-10}&&{-6}\end{bmatrix} \begin{bmatrix}{x_1}\\{x_2}\\{x_3}\end{bmatrix}+ \begin{bmatrix}{1}\\{1}\\{0}\end{bmatrix}u$

$y=\begin{bmatrix}{0}&&{0}&&{-1}\end{bmatrix} \begin{bmatrix}{x_1}\\{x_2}\\{x_3}\end{bmatrix}+ \begin{bmatrix}{0}\end{bmatrix}u$

Cabe mencionar que la representación anterior no es la única, sino que existen muchas representaciones en el espacio de estados posibles, pero octave solo ofrece una de entre todas las opciones posibles.

Fuentes consultadas:
[1] - Espacio de Estados
Página 760, Ingeniería de Control Moderna, 4ta. Edición, Katsuhiko Ogata.

13 de noviembre de 2012

Sistema de Seguridad usando Redes Neuronales

Redes Neuronales
Lectura Científica

Lectura completa por Obaidat en el siguiente enlace:
A Multilayer Neural Network System for Computer Access Security

El uso de redes neuronales es muy amplio en sistemas computacionales, que van desde aplicaciones para clasificar datos, procesamiento de señales, reconocimiento de texto, reconocimiento de voz, encontrar personas o rostros en una imagen o fotografía cancelación de ruido, redes de telecomunicaciones, entre otros.

Uno de los usos actuales de una red neuronal es el reconocimiento de personas como sistema de seguridad en una computadora. Esto se hace con el fin de restringir acceso a personas no autorizadas para usar una computadora. Podemos imaginar el administrador de los servidores de un sistema bancario trabajando desde su computadora en un escritorio del lugar donde trabaja, luego esta persona se va por un café o al baño, y mientras el dejó sola la computadora donde trabajaba, una segunda persona llega y empieza a hacer acciones indebidas en el sistema, evidentemente esto implica un gran problema, ya que seguramente esta segunda persona lo esta haciendo con malos fines. Entonces si la computadora tuviera un sistema que pueda lograr reconocer a una persona mediante como esta escribe en el teclado, el sistema podría bloquear todo acceso a la computadora si encuentra que la persona que actualmente escribe en el teclado no es la que habitualmente hace uso de ella.

http://muyseguridad.net/wp-content/uploads/2010/11/tecleando.jpg

Un sistema como el propuesto es posible tenerlo no solo en una computadora de escritorio o portátil, es también aplicable a dispositivos móviles, con el único inconveniente que para este sistema es necesario una red neuronal que analice datos en tiempo real, y muchos dispositivos móviles seguramente no estén preparados para un análisis complejo de datos en un periodo de tiempo razonable.

¿Cómo se hace esto con una red neuronal?

EL uso que se le da a esta aplicación en una red neuronal es mejor reconocido como reconocimiento de patrones. Los datos que se dan como vectores de entrada a la red neuronal son los intervalos de tiempo entre las pulsaciones que se hacen en el teclado mientras escriben una secuencia conocida de caracteres.

Una red neuronal para la clasificación de patrones debe de tener los siguientes elementos básicos:

  • Un grupo de unidades simples para procesamiento.
  • Un estado de activación inicial por cada unidad.
  • Función de salida para cada unidad.
  • Una regla de propagación.
  • Una regla de activación.
  • Una regla de aprendizaje.
  • Cada elemento esta relacionado con un peso en el vector de pesos.
  • Cada elemento produce una activación y una propagación de error.

Ya sabemos que el vector de entrada a la red neuronal esta dado por el tiempo que la persona se tarda en presionar entre una tecla y otra. Se necesita una red neuronal que tenga varias neuronas en la capa de entrada, en donde cada neurona analizará una unidad de datos del correspondiente vector de entrada.

Una capa oculta no necesariamente con la misma cantidad de neuronas que en la capa de entrada y una capa de salida con una cantidad de neuronas proporcional a la capa oculta anterior.

http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=293498

El aprendizaje para este tipo de red neuronal es mediante un cambio en el vector de pesos, como se suele hacer normalmente, y existe una regla de propagación de errores que ayuda a obtener un vector de pesos que dará una salida cercana a lo ideal.

La salida de cada neurona de la capa de salida, nos deberá proporcionar un vector de salida diferente para cada persona, y comparado con un vector anteriormente obtenido con la persona que usualmente hace uso de cierta computadora, es posible determinar si es la misma o es una persona diferente, y así determinar si es necesario bloquear el uso de la computadora o no.

Referencia
A Multilayer Neural Network System for Computer Access Security

7 de noviembre de 2012

Reporte Grupal

Automatización y Control de Sistemas Dinámicos
Reporte Grupal

EL reporte grupal se encuentra en el blog de Roberto Martínez:
Reporte Grupal

6 de noviembre de 2012

Diseño de Control en Computadoras Personales

Automatización y Control de Sistemas Dinámicos
Lectura Científica

Documento original escrito por Thomas Knapp.

Es evidente que las computadoras personales han sido utilizadas por mucho tiempo para el análisis de sistemas de control y sistemas de control moderno, pero debido a la forma en que la mayoría de los programas para estos fines se han desarrollado, hacen que estos programas computacionales que analizan el estado del sistema, suelen no ser de tiempo real, o solo llegan a ser un aproximado a lo que pensamos es un análisis de tiempo real.

Naturalmente los que ya hemos trabajado con sistemas de control, sabemos que es posible trabajar desde nuestra computadora y ejecutar pruebas que creen entradas aleatorias de datos y ver como se comporta la salida en un sistema, pero cuando hablamos de una cantidad inmensa de información a analizar en su salida, se requiere de hardware que este creado para estos fine, es decir, hardware que sea capaz de guardar y procesar gran cantidad de información.

Y no solo se necesita grandes computadoras con hardware sofisticado, también es encesario hacer el uso de sistemas operativos en tiempo real. En nuestra travesía como estudiantes de ingeniería, ya hemos tenido que lidiar con sistemas operativos de este tipo, usados en sistemas embebidos con nuestros microcontroladores.

Ya que esta publicación no se trata de copiar información, les puedo comentar que se tienen rangos de velocidad en procesamiento de una computadora los cuales dicen si una computadora es apta o no para análisis de sistemas de control. Y desde mi punto de vista, el documento puede que este un poco obsoleto, por que fácilmente podría asegurar que cualquier computadora de nueva generación lograría soportar un análisis "bueno" de un sistema de control en tiempo real.

Actualmente la mayoría de los métodos de procesamiento que se tienen están creados en tiempos discretos, ya que resulta más adecuado para trabajar en computación digital. Algo que también hemos visto en clases de control, son los tipos de controladores, como el conocido PID e incluyen uno llamado estado de controlador, que según estudios resulta tener mejor respuesta en tiempo real.

A lo que nos lleva este documento es a la creación de un paquete que sirve para analizar sistemas de control pero tomando en cuenta los siguientes puntos:
  • Adquisición de datos en tiempo real
  • Verificación de proceso y método de control de diseño
  • Simulación de un circuito cerrado
  • Control en el proceso

El nombre del paquete que ellos crearon es CADREG-PC, es compatible con computadoras basadas en procesadores de IBM, y lo que nos ofrece en pocas palabras es crear un algoritmo para un sistema de control que puede ser fácilmente diseñado y probado sin ningún ningún retraso en cuanto a tiempo.

Enlace al documento:
Process Identification, Controller Design and Digital Control with a Personal Computer

5 de noviembre de 2012

Lógica Temporal

Verificación y Validación de Software
Entrada 11

Para esta semana seleccionamos un ejercicio del PDF mencionado al final de esta publicación, referente a lógica lineal temporal (LTL, por sus siglas en inglés).

El ejercicio seleccionado fue el 14.1.6 y la traducción literal del enunciado es el siguiente.

Si un estudiante olvida una moneda en la ranura de monedas, otro estudiante usará esta moneda para obtener una bebida antes de que cualquier profesor pueda hacerlo.

Entonces usando los operadores temporales tenemos:

$\square (eom \Rightarrow \circ(¬pum \ R \ eum))$

Donde:
eom = Estudiante Olvida Moneda
pum = Profesor Usa Moneda
eum = Estudiante Usa Moneda

Recursos consultados:
Linear Temporal Logic

4 de noviembre de 2012

Autómata Büchi No-Determinista

Verificación y Validación de Software
Entrada 10

Para esta semana se nos pidió hacer lo siguiente:
  • Inventar una expresión ω-regular con por lo menos dos símbolos y por lo menos dos operadores.
  • Dibujar el NBA que le corresponde.

Abecedario

$\sum {\left\{A, B, C\right\}}$

Expresión ω-regular

$(A^*B)(AC+C)^w$

Autómata Büchi No-Determinista

La siguiente imagen es un paso intermedio antes de llegar al autómata completo, aquí solo están las transiciones entre tres estados, donde tales transiciones son la separación por el AND de la expresión.


Y el autómata completo es el siguiente.


Entonces tenemos $L = \{Q, \sum, \delta, I, F\}$

Donde:
$Q = \{q0, q1, q2, q3\}$
$\sum = {\left\{A, B, C\right\}}$
$\delta$ son las transiciones mostradas en la imagen
$I = \{q0\}$
$F = \{q3\}$

Referencias:
Course On Principles Of Model Checking
Automata On Infinite Words

1 de noviembre de 2012

Steganography

Seguridad de la Información y Criptografía
Homework 8 - Program 4

The hidden code in the images of the last publication was in the images 1, 2 and 5

The homework was create a program to hide a text in an image file or an audio file, it is called Steganography.

Steganography is the art and science of writing hidden messages in such a way that no one, apart from the sender and intended recipient, suspects the existence of the message, a form of security through obscurity. [1]

I create two python programs, one for hide the text (in this case my own code), and other for get again the hidden text.

First of all, I read the PDF that is at the end of this publication, where they explain why is common to hide text in bitmap images, and a introduction to how to change data of the image.

A little introduction about the bitmap images, is how the bytes are arranged, the next is what information is stored in the first bytes of the file.

Header of the file:
Bytes - Description
0-1 Bitmap identifier (BM)
2-5 Bitmap file size
6-9 Reserved
10-13 Bitmap data offset

Information about the file:
Bytes - Description
14-17 Bitmap header size
18-21 Bitmap image width
22-25 Bitmap image height
28:29 Bitmap color depth
26-27 Number of color planes
28:29 Bitmap color depth
30-33 Bitmap compression method
34-37 Bitmap data size
38-41 Bitmap image horizontal rule
42-45 Bitmap image vertical resolution
46-49 Number of colors used
50-53 Number of important colors used

*Information extracted from the PDF in the references.

The rest of the bytes are the image information. In my case I used images with a extension of color of 32 bits per pixel, so are 4 bytes in each pixel, we know that colors are composed by three elemental color, and a fourth in this case that is the "transparent color", (red, green, blue, alpha).

I only made changes in the byte of color red. Per byte we have 8 bits, and I only used the last bit to hide one bit of the complete hidden code.

Example:
If the letter "i" in binary is 01101001, in the first 8 bytes where the color red is stored, I change something like that.

Original - Changed
01010011 - 01010010
01010000 - 01010001
01001101 - 01001101
01001110 - 01001110
01001011 - 01001011
01001001 - 01001000
01001010 - 01001010
01001001 - 01001001

Code



The first parameter in the program is the original bitmap file, then a file with the code and the name of the new image.

~$ python stegano.py "images/rmn-01.bmp" "code_file" "rmn-01.bmp"
Identifier  BM
File size 810054
Reserved 0
Data offset 54
Width  450
Height  450
Text file size 2315
~$

The file with the code look like this.


Then the program to find the code in the image.


In this case the program only needs the bitmap file with the hidden code, and a file name to save the text.

~$ python decode.py "rmn-01.bmp" "decoded"
Image size 810054
~$

If we open the file created, we can see the code in it. After the end of the code we have waste information, because we don't know how many bytes had the original code_file. If we don't want to have waste information at the end, we can include in an specific array of bytes in the beginning, the length of the hidden text.


Image without the hidden text


Image with the hidden text


References:
[1] - Steganography - Definition
Introduction to Bitmap Steganography

31 de octubre de 2012

Steganography

Seguridad de la Información y Criptografía
Homework 8 - Images

Here are my images, three of them with the hidden code that I used.








Try to find the images with the code hidden. Good luck!

29 de octubre de 2012

Estabilidad

Automatización y Control de Sistemas Dinámicos
Programa 1

Para esta semana la tarea a realizar fue un programa que determinara si una función de transferencia, en este caso la de nuestro proyecto para la clase, se considera estable o inestable, de acuerdo a análisis mediante octave.

El proyecto para esta clase trata de modular el nivel de sonido en un altavoz, que depende del ruido en la habitación.

Uno de los métodos que use para analizar si mi función de transferencia tiene estabilidad o no fue el Criterio de Routh-Hurvitz, pero debido a que octave no cuenta con un paquete especifico para obtener la tabla de valores que resulta de este criterio, use un modulo de código libre en la siguiente página.


Simplemente lo que hace este modulo es regresar los cuantos cambios de signo hubo en la primer columna de la tabla de Routh, y la tabla en sí. La cual es de gran ayuda para el análisis de estabilidad de esta tarea.

Mi código es el que muestro enseguida. Resumiendo lo que hace, al inicio se inicia la función de transferencia predeterminada, que es la que corresponde al proyecto en el que trabajo, según lo que se entrego en los reportes anteriores, también es posible mandar una función de transferencia cualquiera para analizar otras funciones.

Luego mediante el análisis de las raíces y el criterio de Routh, se determina si es inestable o no, y se manda una impresión. Al final se crean algunas gráficas que explico al final.


Cuando le mandamos como parámetro el valor de "None", toma la función de transferencia predeterminada, podemos ver la ejecución de este código en seguida.

octave:1> estabilidad('None')
****************************
* Funcion de transferencia *
****************************

Transfer function 'funtrans' from input 'u1' to output ...

      0.001358 s^2 + 5.5 s + 11
 y1:  -------------------------
       0.0001235 s^3 + s^2 + 1 

Continuous-time model.
****************************
*         Analisis         *
****************************
Raices en el denominador:
r =

  -8.1000e+03 + 0.0000e+00i
   6.1728e-05 + 1.0000e+00i
   6.1728e-05 - 1.0000e+00i

* Analizando las RAICES *
Hay partes reales positivas en las raices.
Por lo tanto el sistema es INESTABLE
* Criterio de Routh-Hurvitz *
tabla =

   0.00012   0.00000
   1.00000   1.00000
  -0.00012   0.00000
   1.00000   0.00000

Hay 2 cambios de signo.
Por lo tanto el sistema es INESTABLE
Lo que nos arroja en una de las gráficas es la función escalón de la función de transferencia dada.


También obtenemos el diagrama de Bode, que según la segunda gráfica indica que la función llega a un punto a donde tiende a infinito, lo cual nos dice que el sistema es inestable, ya que para poder ser estable, debería de haber estado acotado entre un rango especifico de valores, en cambio si graficaramos cada vez en un rango de frecuencia mayor, solo veríamos que la línea sigue subiendo.


Por último use lsim para ingresar "ruido" a la función de transferencia en un tiempo determinado. Puse valores obtenidos con la función de seno para ver que efecto causa.


Podemos ver nuevamente una función que sigue en el infinito conforme avanza en el tiempo, igual que la deducción anterior, se puede decir que el sistema es inestable.

Justificación de por qué es inestable el sistema
El sistema modula el volumen de los altavoces dependiendo de si existe ruido en la sala o no, pensemos en que inicialmente se reproduce música a cierto volumen, entonces si el sistema detecta ruido y en base a eso aumenta el volumen, seguramente su propia salida este entrando al sistema como ruido y provoque el aumento en volumen, por eso en las gráficas podemos ver un incremento en la amplitud.

Referencias:
Guardar gráficos de octave
Funciones del paquete control en Octave

27 de octubre de 2012

Grafo de Programa

Verificación y Validación de Software
Entrada 9

Para esta semana se nos pidió que modeláramos un sistema simple y lo representáramos mediante un sistema de transiciones o un grafo de programa, y opcionalmente crear la representación en PROMELA.

El sistema que modele para esta semana es muy simple. Se trata de la máquina donde se paga el pasaje en el Transmetro.

Descripción:
En el transporte "Transmetro" cuando un pasajero aborda el camión debe de ingresar la cantidad de $4.50 en la máquina. Una vez ingresada tal cantidad, se imprime un boleto con un código de barras. Esto se hace para evitar hacer doble pago al llegar a la estación, ya que con el mismo boleto del camión es posible subir al Metro.

Tomando en cuenta la máquina que recibe el dinero e imprime lo boletos, modele el sistema, que como podemos ver es muy simple, ya que solo consiste en una máquina que espera el ingreso de monedas, este esta contando el total, y cuando se tiene ya 4.50 en la máquina, se imprime un boleto. También hay que tomar en cuenta que no regresa cambio.

Por ser algo simple de entender, me pareció más práctico dibujar el sistema directo a un grafo de programa.


De la forma en que yo lo modele, supongo que desde que la máquina es encendida inicializa una variable para contar y otra que dice de cuanto fue la moneda. Hay un bucle al que entra inmediatamente después de esto, donde se espera a ingresar una moneda y se suma a la cantidad actual, y no se sale de ahí hasta que el total sean 4.50. Después de salir se imprime el boleto y se resta 4.50 al total, para regresar de nuevo al estado donde se espera el ingreso de monedas.

Es posible que el trabajo de esta máquina no sea secuencial sino que sea algo de forma paralelizada, por un lado la parte que toma las monedas, y por otro la que imprime el boleto. Esto se puede ver cuando un grupo de personas sube al camión, y solo una persona se encarga de depositar el dinero de todos en la máquina. La máquina no necesita que el usuario deje de meter monedas para poder imprimir los boletos, sino que cada que sobrepasa la cantidad de $4.50 imprime un boleto y resta la misma cantidad del total.

Entonces podemos verlo como dos tareas independientes de la siguiente forma.

Contador de monedas
Impresión del boleto

Representación PROMELA


PROMELA (Process/Protocol Meta Language) es un lenguaje de modelado de verificación. El lenguaje permite la creación dinámica de procesos concurrentes de un modelo, por ejemplo, los sistemas distribuidos. En modelos PROMELA, la comunicación a través de canales de mensajes puede ser definido para ser sincrónico o asincrónico. Un modelo escrito en PROMELA se puede analizar con el comprobador de modelos SPIN, para verificar que el sistema modelado produce el comportamiento deseado. [1]

Instalar SPIN en Ubuntu

1. Descargar la versión más reciente y compatible con tu sistema del ejecutable Spin. En mi caso he descargado el archivo spin622_linux64 para Linux.

2. De forma opcional es posible descargar un complemento gráfico para ejecutar y depurar el código. Aquí descargue el archivo ispin.tcl, que solo requiere de tener instalado el paquete tk8.4.

3. Si no tienes instalado el paquete tk8.4, o no estas seguro de si ya lo tienes ejecuta el siguiente comando, si no esta instalado te pedirá tu aprobación para iniciar la instalación, en caso contrario te dirá que no es necesario instalar ningún paquete extra.
~$ sudo apt-get install tk8.4
4. Ahora vamos a la carpeta donde guardamos los archivos descargados y copiamos el ejecutable a la carpeta /usr/bin/ con el nombre de spin.
~$ cd Downloads/promela/
~$ sudo cp spin622_linux64 /usr/bin/spin
5. Para abrir la interfaz gráfica, estando en la carpeta donde tenemos guardado nuestro archivo ejecutamos la siguiente instrucción.
~$ wish ispin.tcl
6. Si quieres correr tus programas desde terminal solo es necesario ejecutar la siguiente instrucción, donde hello.pml es el nombre del archivo donde tienes tu código.
~$ spin -n2 hello.pml

Regresando al grafo de programa que mostré anteriormente, y basado en él, escribí un código sencillo de como debería trabajar este pequeño sistema, para luego probar desde interfaz gráfica. Para probar tome en cuenta que se ingresan siempre monedas de un peso y que la tarifa de la máquina es de 5 pesos.


Usando Spin desde interfaz gráfica es posible generar un diagrama desde el código escrito y su ejecución.


Ahora lo mismo, pero modelado como dos tareas independientes, incluyendo las líneas de skip, para uso de exclusión mutua, donde se accede a la variable "x".


Si corremos directo en terminal, podemos observar lo siguiente, que no es más que la ejecución de los dos procesos. Esto es solo una sección, ya que al correr el programa los procesos están en ejecución de forma infinita.
One coin introduced
One coin introduced
One coin introduced
One coin introduced
One coin introduced
    Ticket printed
One coin introduced
One coin introduced
One coin introduced
One coin introduced
One coin introduced
    Ticket printed
Podemos verificar el programa desde interfaz gráfica, y nos dará información acerca de nuestro programa. Nos da información acerca de cuantos estados y transiciones se crearon, si existe error alguno en la ejecución, la cantidad de memoria y procesos creados, etcétera.


Referencias:
[1] - Promela - Definición
Spin on Linux
Promela Model
Model Checking

25 de octubre de 2012

Stream Ciphers: Edon80

Seguridad de la Información y Criptografía
Homework 7 - Report 3

Edon80 is a stream cypher algorithm designed by Danilo Gligoroski, Smile Markovski, Ljupco Kocarev, and Marjan Gusev. [1]

Has some strengths: [2]
  1. If the needs for security bits have to be increased to arbitrary value, the speed of the cipher would not be affected at all (except initialization phases).
  2. If the size of IV change, it would not affect the speed of the cipher.
  3. It is easily paralelizable.
  4. For achieving high speeds, it is appropriate only for a hardware realization to utilize its more then 80 pipeline and parallel operations.

Edon80 is a hardware binary additive synchronous stream cipher. It belongs to a family of stream ciphers that in hardware can have a constant speed of one bit per clock cycle, but in software implementation on popular modern CPUs can be made as slow as needed.

Since its first description in 2005, it has been analyzed by several cryptographers, have been implemented in a more compact way and a MAC functionality have been added. [3]

How it works?


Edon80 is a binary stream cipher. The keystream in Edon80 is generated as a row of a certain in fnite matrix whose elements are defi ned iteratively using quasigroup operations.

The stream cipher Edon80 uses four fixed quasigroups of order 4. The four quasigroups are the next:

But, why use only that quasigroups or are the unique. In fact, we can generate a different quasigroup if we want, but a quasigroup has a special way to be created, and there are some that are not good for generate a random stream in our case.

In Edon80 we use a quasigroup with a dimension of 4x4, so every row and col need to have a 0, 1, 2 and 3, filled in a table like when we play sudoku. We only need four quasigroups, so the crucial part of this method, was select that quasigroups of a set of 576 options. There are 192 quasigroups and are called fractal quasigroups, since they produce highly regular strings.

Some of the rest 384 after every application of an e-transformation increase the period of the transformed string with smaller coefficient, and other by higher coefficient, and those was discarded. We give a list of 64 quasigroups that increase the period of the transformed string at least 2 times, after every application of an e-transformation by them. For select the four quasigroups of the set of the 64 remaining, each one of them was tested and was found the best four options.

Now we have the general model of the stream cipher Edon80. A key and a Input Vector are required for generate a output stream.


For its proper work Edon80 has the following additional inputs:
  1. One register key of 80 bits to store the actual secret key.
  2. One register IV of 80 bits to store padded initialization vector.
  3. One internal 2-bit counter as a feeder of Edon80 Core in keystream mode.
  4. One 7 bit SetupCounter that is used in IVSetup mode.
  5. One 4 × 4 = 16 bytes ROM bank where 4 quasigroups of order 4 are stored.

In the first row of that table we placed a periodic string that has shape: 01230123[...]0123. The next 80 rows in the table describe 80 e-transformations of that string by using the obtained values of $a_i$ in input vector mode and by the quasigroups $∗i$. The recurrence equations for this transformations are:


The output of the stream cipher is every second value of the last e-transformation so the keystream can be described as:


Using the source code of the official web page of Edon80, I executed a simple example, but I reduced the length of the keystreams:
Generated Key = 04000000000000000000
Generated IV = 0000000000000000
Keystreams generated (3x20 bytes)
s[1]=4E3E5646183CDB17561B8536812775D95D713E69
s[2]=8C67697FD96A249D5E794242413EBEA6B552CC08
s[3]=C61DABCB6AA8E0E50FC5B6392B8549C2F7CBF07B

Encryption of 20 bytes
Plaintext = F4604512C52C03158686A84DF32139B143755F04
Ciphertext = 4E3E5646183CDB17561B8536812775D95D713E69

Decryption of 20 bytes
Ciphertext = 4E3E5646183CDB17561B8536812775D95D713E69
Plaintext = F4604512C52C03158686A84DF32139B143755F04

Attacks and vulnerabilities


Is difficult to attack this kind of stream cipher. Experts found that the complexity of the attack is around 2^69 simple operations for a keystream of similar length. So if we want to attack we have a possibility to found the keystream, but with a brutal force algorithm it will take a very long time.

Another attack and a vulnerability is founded like in others types of encryption and is about the base of explore some periodicy inside the generator.

Using the fact that some elements will repeat with large probability, we can build a kind of test to find out the correct value of the key bits used at the end of the concatenation. We can use it to find a part of the keystream, and is why this kind of stream cipher has a vulnerability.

References:
[1] - Edon80 - Wikipedia
[2] - The eSTREAM Project
[3] - Edon80 Properties
A Key Recovery Attack Of Edon80

21 de octubre de 2012

Redes Petri: Sistema Concurrente

Verificación y Validación de Software
Entrada 8

La entrega para esta semana consistió en lo siguiente:
  • Investigar sobre las redes Petri.
  • Inventar un pequeño sistema concurrente.
  • Modelar un sistema con una red Petri y correrlo en Python.

¿Qué es una red de Petri?


Las redes de Petri son una herramienta gráfica para modelar sistemas formales que pueden ser descritos en términos de pasos en una actividad: como los procedimientos legales, procesos industriales, recetas y algoritmos. Los diseñadores industriales pueden usarlos, ya que son lo suficientemente generales como para la mayoría de los problemas y proporcionan un modelo para la programación. [1]

Una red de Petri es una representación matemática o gráfica de un sistema a eventos discretos en el cual se puede describir la topología de un sistema distribuido, paralelo o concurrente. La red de Petri esencial fue definida en la década de los años 1960 por Carl Adam Petri. Son una generalización de la teoría de autómatas que permite expresar un sistema a eventos concurrentes. [2]

Una red de Petri está formada por lugares, transiciones, arcos dirigidos y marcas o fichas que ocupan posiciones dentro de los lugares. [3]

Las reglas son:
  • Los arcos conectan un lugar a una transición así como una transición a un lugar.
  • No puede haber arcos entre lugares ni entre transiciones.
  • Los lugares contienen un número finito o infinito contable de marcas.
  • Las transiciones se disparan, es decir consumen marcas de una posición de inicio y producen marcas en una posición de llegada.
  • Una transición está habilitada si tiene marcas en todas sus posiciones de entrada.

Modelar un sistema


El sistema que decidí modelar fue el de las máquinas que hay en las gasolineras, en mi caso hice una versión simple, ya que el sistema completo requiere de más estados y transiciones que las que yo usé.

Lo que tome en cuenta para el sistema fue lo siguiente:
  • La máquina se encuentra en reposo hasta que es accionada.
  • El personal indica cual es la cantidad de gasolina a expedir.
  • Se selecciona el tipo de gasolina, que puede ser la premium o magna.
  • La máquina verifica si hay disponible el tipo deseado.
  • Si no hay disponibilidad, muestra un mensaje de agotado.
  • Si hay disponibilidad, empieza el llenado.
  • Al final vuelve al estado de espera nuevamente.

El siguiente es un dibujo creado previo a modelar el sistema en python, y muestra una idea general de como fluye el sistema.


Modelar la Red Petri con Python


Para modelar el sistema en python, fue necesario hacer uso de la librería python-snakes, que es posible descargar desde el siguiente sitio.


Snakes es una librería de python que nos proporciona todo lo necesario para definir y ejecutar muchos tipos de redes Petri. Su objetivo es tener al alcance una herramienta para crear prototipos rápidamente para nuevas ideas.

Unos de los puntos a resaltar de esta librería es la extensión de plugins, que permite ampliar funciones básicas y trabajar con clases especializadas en redes Petri. Por ejemplo, están los plugins usados para dibujar las redes de Petri en sus diferentes formas y exportarlos como imágenes.

El modelo de la imagen mostrada anteriormente fue escrito con las funciones que python-snakes proporciona, y el código fue el siguiente.


Este código al final crea las diferentes representaciones posibles de la red Petri, aquí deje solo dos de las cinco generadas, que son las que en este caso muestran de una forma más organizada la red.


La siguiente parece más ordenada y es más parecida al modelo del sistema que cree con la herramienta de dibujo.


Recursos consultados:
[1] - Petri Nets
[2] y [3] - Definición de Redes Petri
Python Snakes - Google Code
Python Snakes - API
Franck Pommereau's Blog

18 de octubre de 2012

Bloque Ciphers: OFB - Output Feedback

Seguridad de la Información y Criptografía
Homework 6 - Report 2

The Output Feedback (OFB) mode is a confidentiality mode that requires a unique initialization vector for every message that is ever encrypted under the given key. [1]

The Federal Data Encryption Standard (DES) specifies a crypto-graphic algorithm to be used for the cryptographic protection of sensitive, but unclassified, computer data. This FIPS defines four modes of operation for the DES which may be used in a wide variety of applications. The modes specify how data will be encrypted and decrypted. The modes included in this standard are the Electronic Codebook (ECB) mode, the Cipher Block Chaining (CBC) mode, the Cipher Feedback (CFB) mode, and the Output Feedback (OFB) mode. [2]

This standard is based on the DES and provides the next level of detail necessary for providing compatibility among DES equipment. This standard anticipates the development of a set of application standards which reference it such as communication security standards, data storage standards, password protection standards and key management standards. Cryptographic system designers or security application designers must select one or more of the possible modes of operation for implementing and using the DES in a cryptographic system or security application. [3]

The Output Feedback mode was created by Computer Systems Laboratory and the standard was registered by the National Institute of Standards and Technology.

Difference between the others


The Output feedback has some similarities to the ciphertext feedback mode in that it permits encryption of differing block sizes, but has the key difference that the output of the encryption block function is the feedback, instead of the ciphertext. The XOR value of each plaintext block is created independently of both the plaintext and ciphertext. It is this mode that is used when there can be no tolerance for error propagation, as there are no chaining dependencies. Like the ciphertext feedback mode, it uses an initialization vector. Changing the IV in the same plaintext block results in different ciphertext.

How it works?


The kind of mathematics that this method use is XOR operation, and is the reason why we use the same operation to encrypt and decrypt.

$C_j = P_j \oplus O_j$
$P_j = C_j \oplus O_j$
$O_j = E_k(I_j)$
$I_j = O_{j-1}$
$I_0 = IV$

How to encrypt:

http://upload.wikimedia.org/wikipedia/commons/a/a9/Ofb_encryption.png

How to decrypt:

http://upload.wikimedia.org/wikipedia/commons/8/82/Ofb_decryption.png

We can see in the images that each output feedback block cipher operation depends on all previous ones.

Example


This is a simple example of the output feedback implemented in a python script.
ramon@pavilion:~/Documents$ python outputfeedback.py 
Text: me gusta la clase de cripto
Key: abcdefgh
IV: 12345678
Block size: 8

Block #1
Input block: 12345678
Output block: rtvxz| "
Plaintext: me gusta
Ciphertext: a[vaqqtc
Decrypted: me gusta

Block # 2
Input block: rtvxz| "
Output block: UX[^adgj
Plaintext:  la clas
Ciphertext: UF>^FRJ_
Decrypted:  la clas

Block # 3
Input block: UX[^adgj
Output block: 8<@DHLPT
Plaintext: e de cri
Ciphertext: }<&+H1D?
Decrypted: e de cri

Block # 4
Input block: 8<@DHLPT
Output block: y %*/49>
Plaintext: pto
Ciphertext: +05:?&//
Decrypted: pto

Text: me gusta la clase de cripto

What I did in my program?
  • First my program divide the text in blocks.
  • Then, I use the Input Vector only for the first iteration to get the output block using the key.
  • Using the output block, I encrypt the text block.
  • I get the encrypted text block.
  • In this case, I used the encrypted block text to decrypted at the same time, but it must be separately.
  • Then I use the last output block, for the new input block, and repeat the last steps, until we don't have more text blocks.
  • At the end, I print all the decrypted text block together.

Vulnerabilities


In terms of error correction, output feedback can tolerate ciphertext bit errors, but is incapable of self-synchronization after losing ciphertext bits, as it disturbs the synchronization of the aligning keystream. A problem with output feedback is that the plaintext can be easily altered, but using a digital signature scheme can overcome this problem.

References:
[1] - Block Cipher Modes of Operations
[2] [3] - Standard for DES - Modes of Operation
Definition - Output Feedback
OFB - Examples

16 de octubre de 2012

Aplicación de la Lógica Predicativa

Verificación y Validación de Software
Entrada 7

La lógica predicativa tiene un amplio rango de aplicaciones, y yo he seleccionado para esta publicación el tema de procesamiento del lenguaje natural.

El procesamiento del lenguaje natural, es un campo que se ha venido desarrollando prácticamente desde los inicios de la informática. Lo que se busca en este campo es hacer preguntas al ordenador y recibir respuestas útiles, o dándole órdenes que la computadora actúe de forma razonable. Por ser una aplicación que hace un tiempo era tal vez muy difícil de imaginar en la realidad, ha aparecido en la ciencia ficción muchas veces.

Actualmente los sistemas encargados del procesamiento del lenguaje natural, han hecho uso de lenguajes de programación con amplia experiencia en este ámbito, como lo es el reconocido uso de Prolog, como un lenguaje lógico que puede llegar a una respuesta al darle una serie de predicados que son ciertos o falsos, en ciertas circunstancias.

¿Cómo es el procesamiento del lenguaje?


Lo que se necesita primeramente para lograr el procesamiento del lenguaje natural es romper el texto capturado como una estructura de oraciones, mediante estructuras lógicas, con el fin de un posterior análisis.

Suele ser difícil la parte del procesamiento, debido a que se tratará con una cantidad grande de información, y esta en base al contexto en que se este hablando, es posible entrar en una serie de ambigüedades que hagan difícil llegar a una solución o resultado.

También el procesamiento depende mucho del lenguaje en el que se aplique, por lo que se suelen utilizar una serie de diccionarios, de los cuáles podamos hacer uso para dar significado lógico a una oración procesada por el sistema.

Pueden ser utilizados para proporcionar retroalimentación auditiva en un sistema automatizado de comprobación de precios en un supermercado o para leer en voz alta una previsión del tiempo que cambia frecuentemente.

El proceso por el que pasa un texto requiere de un análisis que ha de descomponerse en estructuras que el sistema pueda procesar, y luego diferenciarlo en cierto tipo de unidades específicas de información.


La forma de entender como se estructura la entrada de información, es tal y como se hace en la lógica de predicados, de ahí que esta aplicación surge de este tema, ya que se realiza un árbol en el que se estructuran los predicados, hasta llegar a unidades lógicas pequeñas que sea posible evaluar como si fuesen funciones.


La siguiente imagen muestra el procesamiento que hace el sistema al que hace mención el PDF anexado al final de esta publicación como recursos consultados, donde los creadores de el sistema de procesamiento de lenguaje natural utilizan esta misma metodología para analizar la información.


Y ahora es necesario trasladar esas unidades elementales al sistema como si fuesen parámetros a evaluar, una forma de visualizar como se mandaría la entrada de datos al sistema computacional encargado de evaluar la información o texto, se vería de la siguiente manera.


La respuesta de salida, puede determinar si una oración o texto tiene coherencia en cuanto al contexto en el que se estaba hablando, o determinar una serie de acciones a realizar por un sistema.

Recursos consultados:
A Natural Language Interface Using First-Order Logic, Andrews, Itz and Meyer
Logic Predicate - Chapter 4

15 de octubre de 2012

Diagrama de Bode

Automatización y Control de Sistemas Dinámicos
Laboratorio: Entrada 5

Para esta entrega seleccioné un problema del Capítulo 8, Análisis de la Respuesta en Frecuencia, y es el siguiente.

Dibuje el diagrama de Bode de

$G(s) = \dfrac {10(s^2+0.4s+1)}{s(s^2+0.8s+9)}$

Veamos la definición de un diagrama de Bode.

¿Qué es un diagrama de Bode?


Un Diagrama de Bode es una representación gráfica que sirve para caracterizar la respuesta en frecuencia de un sistema. Normalmente consta de dos gráficas separadas, una que corresponde con la magnitud de dicha función y otra que corresponde con la fase. Recibe su nombre del científico que lo desarrolló, Hendrik Wade Bode. [1]

El diagrama de magnitud de Bode dibuja el módulo de la función de transferencia (ganancia) en decibelios en función de la frecuencia en escala logarítmica. [2]

El diagrama de fase de Bode representa la fase de la función de transferencia en función de la frecuencia en escala logarítmica. Se puede dar en grados o en radianes. Permite evaluar el desplazamiento en fase de una señal a la salida del sistema respecto a la entrada para una frecuencia determinada. [3]

Diagrama de Bode en Octave


Octave ya tiene una función para dibujar los diagramas de Bode con unas cuantas líneas de código, solo es necesario tener instalado el paquete control, y tomar los datos de la función de transferencia del problema.

$G(s)$ es una función de transferencia, y se define de la siguiente forma:

$G(s) = \dfrac {num(s)}{den(s)}$

Para poder trabajar con esa función en octave, necesitamos multiplicar los factores en el numerador y el denominador.

$G(s) = \dfrac {10(s^2+0.4s+1)}{s(s^2+0.8s+9)}$

$G(s) = \dfrac {10s^2+4s+10} {s^3+0.8s^2+9s}$

En Octave podemos escribir los coeficientes del numerador y denominador como vectores, y después usarlos en la función bode.
octave:1> num = [0 10 4 10];
octave:2> den = [1 0.8 9 0];
Necesitamos pasar el numerador y denominador a una función de transferencia.
octave:3> sys = tf(num, den)
Utilizando la orden bode(sys), obtendremos los diagramas de Bode.
octave:4> bode(sys)

Como podemos observar en la gráfica generada, tenemos dos trazos diferentes, el primero es el diagrama logarítmico del módulo de una función de transferencia, y el segundo es un diagrama del ángulo de fase.

Ambos diagramas en la gráfica están representados en función de la frecuencia dada en radianes y esta en escala logarítmica.

En el primer diagrama podemos observar que la magnitud esta también en una escala logarítmica, debido a que la medición se hace en decibeles, y se sabe que los decibeles ya están en una escala a logarítmica.

Programa completo:
octave:1> num = [0 10 4 10];
octave:2> den = [1 0.8 9 0];
octave:3> sys = tf(num, den)

Transfer function 'sys' from input 'u1' to output ...

       10 s^2 + 4 s + 10 
 y1:  -------------------
      s^3 + 0.8 s^2 + 9 s

Continuous-time model.
octave:4> bode(sys)
octave:5>

Podemos cambiar el rango de frecuencia para el diagrama de Bode.
octave:5> w = logspace(-2, 4);
octave:6> bode(sys, w)

Como vemos en la imagen, podemos notar que el rango de la frecuencia dada en radianes fue cambiada de $[10^{-1} : 10^2]$ a $[10^{-2} : 10^4]$, y nos permite analizar de otra forma la función de transferencia.

Fuentes consultadas:
Página 592, Ingeniería de Control Moderna, 4ta. Edición, Katsuhiko Ogata.
[1:3] - Definición de Diagrama de Bode
Funciones Bode y Nyquist - Octave Control
Dibujar el Diagrama de Bode

14 de octubre de 2012

Criterio de Estabilidad de Routh

Automatización y Control de Sistemas Dinámicos
Laboratorio: Entrada 4

Para esta cuarta entrega del laboratorio, seleccioné un problema del Capítulo 5, Análisis de la Respuesta Transitoria y Estacionaria, y es el siguiente:

Considere el sistema en lazo cerrado que se muestra en la Figura 5.88. Determine el rango de estabilidad para K. Suponga que K > 0.

Figura 5.88. Sistema de lazo cerrado.

Para resolver esto es necesario utilizar el Criterio de estabilidad de Routh, el cual dice si existen o no raíces inestables en una ecuación polinomial, sin tener que obtenerlas en realidad. Este criterio de estabilidad sólo se aplica a los polinomios con una cantidad finita de términos. [1]

Cuando se aplica el criterio a un sistema de control, la información sobre la estabilidad absoluta se obtiene directamente de los coeficientes de la ecuación característica. [2]

Debemos simplificar el diagrama de bloques del sistema, para poder obtener después la ecuación característica.

Primero simplificamos los bloques en serie.


Luego quitamos la retroalimentación en el sistema mediante álgebra de bloques, que ya se ha aplicado en tareas anteriores. Nota: Aunque el punto de suma tenga un signo negativo, no significa que la suma en el denominador tenga que ser negativa, esto esta dado por las reglas de álgebra de bloques.


Con esto obtenemos nuestra función de transferencia para el sistema de lazo cerrado.

$\dfrac {C(s)}{R(s)} = \dfrac {K(s - 2)}{(s + 1)(s^2 + 6s + 25) + K(s - 2)}$

Multiplicamos los factores del denominador.

$\dfrac {C(s)}{R(s)} = \dfrac {K(s - 2)}{s^3 + 7s^2 + 31s + 25 + Ks - 2K}$

Agrupamos los coeficientes que tienen "s".

$\dfrac {C(s)}{R(s)} = \dfrac {K(s - 2)}{s^3 + 7s^2 + (31 + K)s + 25 - 2K}$

Para estabilidad, el denominador de la ecuación anterior es un polinomio estable, al tener todos los coeficientes de la variable "s" con signo positivo y entonces tenemos nuestra Ecuación característica.

$s^3 + 7s^2 + (31 + K)s + (25 - 2K) = 0$

La condición necesaria, pero no suficiente, para la estabilidad es que todos los coeficientes de la ecuación estén presentes y tengan signo positivo. [3]

Ahora, si todos los coeficientes son positivos, ordenar los coeficientes del polinomio en renglones y columnas de acuerdo con el arreglo siguiente.

Si:
$a_0s^3 + a_1s^2 + a_2s + a_3 = 0$

La tabla queda como sigue:

$s^3$ $a_0$ $a_2$
$s^2$ $a_1$ $a_3$
$s^1$ $\dfrac {a_1a_2-a_0a_3}{a_1}$ $0$
$s^0$ $a_3$  

Para nuestro caso particular el arreglo de coeficientes de Routh es el siguiente:

$s^3$ $1$ $31+K$
$s^2$ $7$ $25-2K$
$s^1$ $\dfrac {192+9K}{7}$ $0$
$s^0$ $25-2K$  

Paso intermedio para $s^1$:

$\dfrac {(217+7K) - (25-2K)}{7} = \dfrac {192+9K}{7}$

Como no tuvimos cambio de signo en la segunda columna, significa que no hay raíces con partes reales positivas. En caso contrario el sistema sería inestable.

Entonces se deberán cumplir las siguientes condiciones:

$\dfrac {192+9K}{7} > 0$
$25-2K > 0$

Veamos con la primera:

$\dfrac {192+9K}{7} > 0$
$192+9K > 0$
$9K > -192$
$K > -21.33$

Como el enunciado del problema da una condición inicial de que $K > 0$, se ignora este resultado.

Veamos con el siguiente:

$25-2K > 0$
$-2K > -25$
$K < 12.5$

Tenemos que K es un valor positivo, pero encontramos una restricción a no ser mayor a 12.5, de lo contrario provocaríamos un sistema inestable.

Asumiendo que $K > 0$, tenemos que el rango de estabilidad para el sistema es:

$12.5 > K > 0$

Y lo que quiere decir es que, para que el sistema sea estable, el valor de K debe encontrarse entre 0 y 12.5.

Fuentes consultadas:
[1] y [2] - Página 275, Ingeniería de Control Moderna, 4ta. Edición, Katsuhiko Ogata.
[3] - Criterios de Estabilidad

9 de octubre de 2012

Diagrama de Bloques

Automatización y Control de Sistemas Dinámicos
Reporte 2

Representen el sistema que buscan controlar en el proyecto grupal a través de un diagrama de bloque.

En el Reporte 1 de hace algunas semanas, habíamos obtenido la función de trasferencia de nuestro sistema, en mi caso, estoy trabajando en el proyecto de modulación nivel de sonido en un altavoz, que depende del ruido de la sala en que te encuentres.

Antes de llegar a función de transferencia había partido del circuito creado suponiendo que se decide hacer el uso de Arduino como controlador de la planta.


Ya había mencionado en tal reporte que las dos funciones principales eran las del micrófono y la bocina que daban parte a la siguiente función de transferencia.

$\dfrac {Cs}{Rs} =\dfrac {Ri+L}{\dfrac {\dfrac {s^{2}}{w^{2}}} {\dfrac {s^{2}}{w^{2}}+\dfrac {s}{wQ_{TSA}}+1}}$

Y esta la podemos simplificar un poco para poder trabajar con ella y nos queda de la siguiente forma.

$\dfrac {Cs}{Rs} =\dfrac {(Ri+L) \left( \dfrac {s^{2}}{w^{2}} + \dfrac {s}{wQ_{TSA}} + 1 \right)}{\dfrac {s^{2}}{w^{2}}}$

La función de transferencia mostrada puede ser representada como un diagrama de bloque, el cual de una entrada se produce una salida, pero vamos a hacer el proceso inverso de la simplificación de diagrama de bloques, en el cual vamos a desarrollar todos los componentes de la planta.


Lo primero que se hace es quitar la división grande del único bloque, y según las reglas del álgebra de bloques, tenemos que una división resulta de una suma de la salida a la entrada del sistema, que se representa como sigue.


El siguiente paso es separar la multiplicación del bloque superior, y para esto se sabe que cuando es una multiplicación, los bloques se quedan en serie, por lo que esta parte es fácil de entender el resultado.


Ahora la sumas que tenemos en los bloques resultantes, es posible cambiarlos por puntos de suma, como bloques separados, pero sin perder el orden que se tenia de los elementos.


Falta tomar en cuenta que la entrada y la salida generada por la planta esta en función del tiempo, como se describió en el reporte anterior.

Y esta última imagen representa el diagrama de bloques de la función de transferencia.

Recursos consultados:
Simplificar Diagrama de Bloques
Álgebra de Bloques

8 de octubre de 2012

Proyecto de Redes Neuronales

Redes Neuronales Artificiales
Presentación Intermedia: Reporte y Programa

Este es el reporte de medio curso para la materia de Redes Neuronales Artificiales, en la cual estoy trabajando en el proyecto de Reconocimiento de Personas Mediante Voz, en conjunto con mis compañeros Cecilia Urbina y Roberto Martínez.

El objetivo del proyecto es que al final del semestre tengamos un sistema funcional que permita identificar si un usuario es el correcto o no, mediante su voz. Esto dentro de un sistema que muestre una ventana y que de un texto que tendrá que ser leído por la persona que intenta autentificarse, el audio es captado y analizado, y crea una entrada de datos a la red neuronal la cual se encargara de decir en su salida si el usuario fue identificado o no, y mostrar el resultado finalmente mediante una ventana.

Trabajo grupal


En la siguiente captura se muestran los commits realizados desde la semana en que conformamos el equipo, y con esto podemos crear evidencia del trabajo realizado. En base a esto explicaré que fue lo que se ha hecho en conjunto y lo que yo he hecho.



En las primeras semanas se trabajo conforme a lo que íbamos viendo en clase, que trataba de crear el programa que recibía desde línea de comandos entradas binarias, para el vector de entradas y creábamos el vector de pesos aleatorio. La modificación del primer código fue en base a lo que Cecilia trabajo en hacer una clase especial para lo que en un futuro sería la neurona simple.

Luego tuvimos algunas sesiones en las que trabajamos en conjunto en cuanto al aprendizaje de la neurona, hasta este momento no teníamos alguna forma de comprobar si lo que estábamos haciendo estaba bien o no. El código modificado fue subido en un commit mostrado con el nombre Equipo, para mostrar que ahí trabajamos todos.

En las semanas pasadas dividimos el trabajo para poder avanzar un poco más, entonces Cecilia se encargó de empezar con la interfaz de entrada y el pre-procesamiento del audio, yo me encargué de continuar con el código de la neurona, hacer que aprendiera y verificar que estaba funcionando como debería, Roberto se encargó de agregar el uso de Tkinter para poder visualizar el aprendizaje de la neurona, y la ventana que arrojará el sistema cuando lo demás este completo.

Código relevante


Los siguientes códigos son solo una fracción del código completo, para mostrar algunas partes elementales.

En la siguiente sección mostrada, es parte del código del programa generador, en este caso ya que nos enfocamos un poco para solo dos dimensiones, cuando se pide al programa que genere un numero de muestras para un vector de entrada de dos dimensiones con su salida esperada, este las crea y guarda en un archivo. Para poder determinar la salida se hace una comparación, pero para evitar que sea algo que siempre de el mismo resultado coloque dos variables de ruido esto con el fin de que la salida esperada de los vectores de entrada no siempre cree la misma gráfica dividida transversalmente.


La siguiente parte es solo la muestra resumida de lo que hace el código al mandarle los datos de entrada a la neurona y las operaciones que hace, para cuando modifique el código que habíamos trabajado en equipo esta parte sufrió grandes cambios ya que anteriormente no se había tomado en cuenta el umbral dentro del vector de pesos.


Aportes


En seguida concretizo el trabajo que realicé, en unas cuantas líneas:
  • Reestructurar el código de la clase Neurona.
  • Cambiar la entrada de datos a números flotantes.
  • Modificar la entrada manual de datos a la lectura de un archivo.
  • Corrección del método de aprendizaje.
  • Conteo de errores cuando se mantiene esta activo el método de aprendizaje.
  • Graficar la salida correcta de los datos creados por el generador con Gnuplot.
  • Graficar los datos obtenidos después del aprendizaje con la neurona.
  • Mejora del código después del agregado de visualización con Tkinter.
  • Corrección de bugs después del agregado de visualización.

Gráficas generadas con Gnuplot


Gráfica generada con los datos tal y como los crea el generador, esto sirve de referencia para saber si lo que la neurona hará tiene una salida semejante que divida las dos clases tal y como en la imagen.


Tomando los datos generados desde la neurona, podemos ver los puntos con salida esperada 0 y los puntos con salida esperada 1, y estos con un contorno de color verde cuando al momento de comparar la activación con cero, el resultado no dío igual que el esperado, y al final se pinta la línea creada con los datos arrojados por el vector de pesos.


Vídeo demostración


El siguiente vídeo muestra el funcionamiento de la neurona ya con interfaz gráfica con Tkinter y después de las correcciones aplicadas.

En el vídeo se muestra una terminal donde se ejecuta el programa generador de los vectores de entrada y su salida esperada, y luego se usan los archivos generados para correr el programa de la neurona, que inicia un proceso de aprendizaje, modificando el vector de pesos, para llegar a separar en dos clases los puntos con salida esperada 0 y los puntos con salida esperada 1.


Presentación en equipo


Integrantes del equipo: