laboratorio 7: Automatización

Para ésta entrada escogí el problema P 9.2, el cuál consiste en sacar los diagramas de nyquist y sus margenes.

Funciones:

Para realizar éste problema utilicé la las funciones que nos proporciona octave las cuales son la de nyquist que nos devuelve su diagrama y margin.

Reporte Proyecto Final: Control de velocidad de un motor de corriente directa

Proyecto:

"Control de velocidad de un motor de corriente directa"

Introducción:

Existen diversas situaciones donde el control de la velocidad de un motor es crítica, por ejemplo, cuando un robot es movido por 2 motores y se quiere avanzar en cierta dirección, controlar la velocidad de ambos es importante. La velocidad de rotación de un disco duro o un lector de CD/DVD es otro caso. Para ello es necesario adaptar el motor a diversas situaciones de funcionamiento que puedan suceder, por ejemplo, si un móvil va cuesta arriba o cuesta abajo, o cuando existe fricción entre las partes.

Funcionamiento General:
Principalmente el proyecto esta constituido por 3 partes:

• Sensor: Que consta de un optointerruptor ITR8102 y un disco horadado como encoder.
• Microcontrolador: El cual es un Arduino UNO que procesa la salida del sensor para adaptar la velocidad.
• Planta: Será el motor eléctrico el cual será controlado.

Reporte Final Redes Neuronales

Introducción
La idea del proyecto es realizar una red neuronal que pudiera hacer pronósticos basándose en un historial o una serie de datos proporcionados por el usuario, la idea es integrar éste proyecto junto a otro(plusreports) y éste sirve como historial para predecir sucesos.

Para la arquitectura de la red neuronal, se piden 6 valores, que estos pueden ser días, semanas meses o años y la red neuronal te regresara el séptimo valor.

Aportaciones:
Mis aportaciones principalmente fueron de la entrada y procesamiento de datos:

• Neurona simple 
• Interfaz
• Lectura del archivo CSV
• Escalamiento de éste
• Gráficas
• Interpretación de post-procesamiento

Aprendizaje:
Para el aprendizaje de la red neuronal, se utiliza el algoritmo de back-propagation junto con la función sigmoidal y el proceso feedforward con aprendizaje persistente.

Seuencia:
La secuencia que sigue el programa empieza en la interfaz, donde el usuario podrá subir un archivo csv (acomodado por fecha, valor), teniendo éste archivo el programa lo separa por fechas y valores acomodandolos en dos archivos uno que es valores.txt y fecha.txt, que esto servirá para su representación, una vez obtenido ésto, el programa lo normaliza en escala de 0 a 1 y corre un python donde será devuelto valores una vez que se haya terminado, se retroalimenta el csv y se muestran en la gráfica.

Código
El código que hace todo ésto se encuentra en la siguiente carpeta:
https://github.com/rafaellopezgtz/neurored/tree/master/entrada

Repositorio:El repositorio se encuentra en el siguiente link, donde mi usuario es jsp
https://github.com/rafaellopezgtz/neurored/commits/master

Demo:
http://neurored.rafaellopezgtz.com/pagina/

Laboratorio 6 de Automatización

Para ésta entrada, me toco obtener la controlabilidad y observabiliad del sistema dado:

Respuesta:

Desarrollo:
Para obtener la observabilidad y controlabilidad del sistema se empleo octave usando la librería de control, con la función de ctrb, obsv y una vez tenidas éstas, emplear la función det, que te de su determinante.

Nota:
Otra de las formas para obtener ésto, es empleando la fórmula respectiva de cada una:

Donde la primera es la de controlabilidad y la segunda de observabilidad.

Cñódigo en Octave

Salidas:

Conclusiones
Donde podemos observar que la salida proporcionada de control y observabilidad da como salida 14 y 5, siendo el sistema completamente controlable ya que mensiona el teorema que este tiene un rango máximo y nuestra salida es dirente a cero, siendo ésto aceptable y el sistema es del todo observable ya que su salida es 5 y en el teorema mensiona que debe de ser diferente a cero.

Referencias:
http://es.wikipedia.org/wiki/Controlabilidad
http://es.wikipedia.org/wiki/Observabilidad

Reporte grupal Automatización

El reporte grupal de esta semana se encuentra en el blog de mi compañero Juan Carlos

El equipo esta conformado por:
Juan Carlos
Rafael

Lógica Temporal

Para ésta semana se seleccionó un ejercicio, el cuál me tocó realizar el siguiente:

14.1.9:

"If a professor is currently at the machine, there will be no student at the machine for at least the next three transitions."

Donde lo podemos traducir como:

"Si un profesor se encuentra actualmente en la máquina, no habrá ningún estudiante en la máquina durante al menos los próximos tres transiciones."

 (pam→(¬eam º tt))

pam = profesor esta en la máquina
eam = estudiante esta en la maquina
t t = tres transiciones

Referencias:
http://www.voronkov.com/lics_doc.cgi?what=chapter&n=14

Lectura Científica

Titulo:

"Optimal Estimation of Position and Heading for Mobile RobotsUsing Ultrasonic Beacons and Dead-reckoning".

Descripción:

Este tipo de control es utilizado para el posicionamiento y determinación en ángulo de un robot, cuando se encuentra que las ruedas del robot son imperfectas o se deslizan mucho, causando que se genere errores en la determinación de su posición.

Respuesta:
El artículo mensiona una solución al problema, usando guías ultrasónicos para saber su posición correcta, mejorando lo adaptativo del robot y sus actividades autónomas.

La estructura usada, para la resolución del problema fue usar 6 balizas(emisor de señal) ultrasónicos conectados a un control de transmisión, un receptor compuesto por 8 sensores ultrasónicos (receptores), tomando las señales de las balizas para sacar la estimación de posición  y orientación usando el filtro de Kalman, donde éste estima el estado de n dimensional de un sistema denotado por x, dado un conjunto de m dimensiones del vector y. El estado para localizarlo contiene la posición, orientación y velocidad del robot.
El filtro de Kalman ayuda a éste a encontrar el estado oculto de un sistema dinámico lineal, cuando se tiene diferentes valores de señal en tiempos diferentes (siendo éstos las emisiones y  recepciones de las balizas).

Donde aplica el control:
El control aplica, al momento de su retroalimentación, ya que las balizas mandan una señal y los receptores calculan los errores de posición, obteniendo así la retroalimentacón que será utilizada, ya sea para emitir su posición correcta actual, corregir su posición, o entre otras que éste destinada a ralizar

Ejemplos de posibles usos:
Principalmente en los carros  autónomos manejando ésto en zonas más grandes, como el prototipo del carro de google, carritos exploradores, etc.

Opinión:
Este tipo de control en lo personal me podría ayudar, ya que en proyectos anteriores buscaba controlar un carrito, pequeños robots o drones en una determinada zona, mejorando la transición que seguiria el robot, como pasar algunos obstáculos.

Desventajas:
Algunas de las  desventajas que encontré fue que no muchas veces se buscará una zona determinada, así que depende mucho de las balizas y que éstas al ponerlas en zonas mas grandes el tiempo de transmisión o recepción aumentaría, otra de ellas fue que hoy en día varios sistemas o robots móviles emplean sensores lasers para  su correcta calibración o como guía de posicionamiento, siendo esto más exacto y más rapido.

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

Expresión w-regular

Para ésta entrada se busco hacer hacer una expresión w-regular y una vez tenida sacar el NBA, mi ejemplo a expresar es cuando se intenta entrar a una casa con las llaves

La expresión es la siguiente:

Donde:

• A es indicado (llave indicada)
• B es cambiar (cambiamos llaves)
• C es intento (intentamos con la llave actual)

Expresando que: si no es la indicada en cantidad finitas, cambiamos e intentamos infinitamente.

El NBA es el siguiente:

Referencias:
http://goo.gl/izfGR
http://goo.gl/BS4IJ
http://goo.gl/5m2Tz
http://goo.gl/Yf8dL

Tarea 5: Dibujar el diagrama de Bode

Para ésta entrada, me tocó realizar el diagrama de bode de la siguiente función:

Desarrollo:

Así que lo buscado será primero simplificar, para hacerlo más fácil.

 Una vez tenido el polinonio es multiplicado por 30.3215

Ahora tenemos el num. y den.

Una vez que se obtiene ésto es mas fácil graficarlo con octave ya que tiene una función propia

Código:

num = [30.3215 39.41795 12.81083];
den = [0 1 0];
s1 = tf(den, num)
bode(s1)

Salida:

Result Steganography

The images that have information are:

code

letter 

url

The content of each one are: a letter, an url and the code of my program.

code:

from sys import argv
from PIL import Image

def openFile(fileName):
    f = open(fileName, 'r')
    mensaje = list()
    for line in f:
        mensaje.append(line)
    f.close()
    return "".join(mensaje)

def setMsn(mensaje):
    m2 = list()
    mensaje = list(mensaje)
    
    for i in mensaje:
        u = bin(ord(i))[2:].zfill(8)
        for j in u:
            m2.append(j)
    return m2

def getMsn(mensaje):
    m2 = list()
    a = 1
    b = ''
    for i in mensaje:
        b = b+i
        if(a%8 == 0):
            m2.append(chr(int(b,2)))
            b = ''
                       
        a = a + 1
    return "".join(m2)

def pixelF(m2, v, count):
    if(v[7:8] != m2[count]):
        v = v[:7]+m2[count]
    else:
        v = v
    return int(v, 2)
            
def openImage(fileName, m2):
    im = Image.open(fileName)
    rgb = im.convert('RGB')
    c = 0

    while c != len(m2)-1:
        for i in range(0, im.size[0], 3):
            for j in range(im.size[1]):
                b = rgb.getpixel((i, j))[2]
                v = bin(b)[2:].zfill(8)

                w = pixelF(m2, v, c)

                r = rgb.getpixel((i, j))[0]
                g = rgb.getpixel((i, j))[1]

                d = tuple([r,g,w])
                im.putpixel((i,j),d)
                if(c == len(m2)-1): break
                c = c+1
    im.save(str(2)+fileName, "PNG")

def decodeM(fileName):
    im = Image.open(fileName)
    rgb = im.convert('RGB')
    arrayRGB = list()

    for i in range(0, im.size[0], 3):
        for j in range(im.size[1]):
            b = rgb.getpixel((i, j))[2]
            v = bin(b)[2:].zfill(8)
            arrayRGB.append(v[7:8])
    return arrayRGB

def main():

    mensaje = openFile(argv[1])
    mensaje = setMsn(mensaje)
   
    imagen = argv[2]
    print imagen
    w = openImage(imagen, mensaje)

    m2 = decodeM(str(2)+imagen)
    print getMsn(m2)
    
main()

The code take 2 parameters, the name of the file that contains the information and the name of the image to save.
> criptoImage.py fileInformation.txt image.png > dInformation.txt

To decrypt we can use the next code:
 

from sys import argv
from PIL import Image

def getMsn(mensaje):
    m2 = list()
    a = 1
    b = ''
    for i in mensaje:
        b = b+i
        if(a%8 == 0):
            m2.append(chr(int(b,2)))
            b = ''
                       
        a = a + 1
    return "".join(m2)

def decodeM(fileName):
    im = Image.open(fileName)
    rgb = im.convert('RGB')
    arrayRGB = list()

    for i in range(0, im.size[0], 3):
        for j in range(im.size[1]):
            b = rgb.getpixel((i, j))[2]
            v = bin(b)[2:].zfill(8)
            arrayRGB.append(v[7:8])
    return arrayRGB

def main():

    m2 = decodeM(str(1)+imagen)
    print getMsn(m2)
    
main()

This code only takes the name of the image

Steganography

Images:

Download images:
https://www.dropbox.com/sh/o46may3he6bjurt/knajzgXLqD/cripto/blog.zip

Estabilidad de nuestro programa

Para ésta entrada, se nos pidió, hacer pruebas en nuestra función de transferencia y determinar si ésta es o no es estable.

Función de transferencia:

Diagrama de bode & nyquist:
El diagrama de bode y nyquist, nos servirá para determinar en forma gráfica que tan estable o inestable es, como se menciono con anterioridad, si en nuestro plano, observamos que va a la derecha, nuestro sistema es inestable, caso contrario si tiende a la izquierda.

Imagen diagrama de impulso:
El impulso, nos sirve de otra forma gráfica para determinar que tan estable o inestable es nuestro sistema, ya que dependiendo del impulso que se le de nos mostrará como se va comportando en forma de onda.

Código:

function estabilidad%(num, den)
k = 1;
v = 2.5;
num = [k v];
den = [3 4 1 434]; #Este ultimo es la constante de distancia del sensor determ.objeto
sys = tf(num, den)
figure (1)
nyquist (sys)
figure (2)
rlocus (sys)
figure (3)
impulse (sys)
raices = roots (den)

contador = 0
for i = 1:length(raices)
if real(raices(i)) > 0
contador + 1; 
endif
endfor

if contador > 0
printf("Sistema Inestable")
else printf("Sistema Estable \n")
endif

endfunction

Salidas:

duda

duda

duda

Conclusiones:
En las salidas mostradas, se puede ver en las gráficas de nyquist es semi-estable, ya que hasta cierto punto la gráfica se queda en el semiplano de la izquierda.


Notas:
La función de transferencia empleada, fue convertida a ecuación lineal, para pasarla a numerador y denominador, aunque se necesitan otras pruebas para verificar su correcta converción.


Referencia:
http://octave-online.blogspot.mx/2010/05/impulse.html
http://es.wikipedia.org/wiki/Teorema_de_Routh-Hurwitz
http://www.slideshare.net/tonivi99/sistemas-de-control

Sistema de Transiciones

Para ésta entrada se nos pidió realizar un sistema de transiciones, el sistema que modelaré, será lago básico del llenado y vaciado de una cisterna.

Componentes:

• Contenedor: Es donde se almacena el agua.
• Sensor: Es el que nos indica si ya esta lleno o vacío el contenedor.
• Válvula: Es el que abre o cierra la llave, para llenar o vaciar el contenedor.

Descripción de los componentes con estados y acciones:

• Contenedor:
• Estados:
• Vacío
• Llenando
• Lleno
• Vaciando
• Acciones
• get_agua
• set_agua

• Sensor:
• Estados:
• Activo, indicando el sensor que aún se puede ir llenando
• Inactivo, indicando el sensor que ya no puede estar llenando
• Acciones
• get_agua
• set_agua

• Válvula:
• Estados:
• Activo, es cuando abrimos la válvula
• Inactivo, es cuando abrimos la válvula
• Acciones
• Abrir
• Cerrar

Diagrama de transiciones:

Estados:

• Vacío, llenando, lleno, viciando (0,1,2,3)
• Activo, Inactivo (0,1)
• Activo, Inactivo (0,1)

Transiciones:

• get_agua, set_agua, abriendo, cerrando (1,2,3,4)

Referencias:

http://is.ifmo.ru/books/_principles_of_model_checking.pdf

Stream Cipher - SOBER-128

Introduction:
The sober-128 stream cipher, was develop for Philip Hawkes, Michael Paddon and Gregory G. Rose, in Gladesville Australia for Qualcomm Autralia. (Curiosity, this same people develop Turing Cipher).

Why?
The reason by the article is have a stream cipher primitive constructor that having a some characteristics by:

• quickly
• easy
• open source
• secure

"SOBER-128 is based on simple 32 bit operations*. Keys and optional nonces of arbitrary length are supported. Enumeration of keys is thought to be the most efficient attack for key lengths of 128 bits or less. SOBER-128 may be configured to calculate an arbitrary length Message AuthenticationCode (MAC) as part of the encryption or decryption process." 

*(such as 32-bit XOR and addition modulo 232), and references to small fixed arrays.

Implementations
SOBER-128 is use in many computing environments (smart cards to large computers), but principally in mobile systems.

Description:
SOBER-128 is constructed from a linear feedback shift register (LFSR), a non-linear filter (NLF)* and a nonlinear plaintext feed back function (PFF)**.

* Is used to generate the keystream.
** Is used to perturb the LFSR when a MAC is desired.

Sober-128 operate in two modes:

• Synchronous mode:
• MAC (Message authentication mode:)

The first is use to when a MAC isn't required, where in the keystream generation is independent of the plaintext. And the second utilizes the PFF to perturb the LFSR with plaintext during encryption or decryption. After the message has been processed, the keystream generator is used to produce a MAC (MAC is required).

LFSR
This consists of 17 words of state, designated R[0] through R[16].

pseudocode:

Step(R):
              x = R[15] ^ R[4] ^ (R[0] << 8)
                  ^ Multab[(R[0] >> 24) & 0xff];
              for (i = 0 to 15):
                  R[i] = R[i + 1];
              R[16] = x;

Where Multab is a table of 256 constants.

NLF

pseudocode:

NLF(R, Konst) = f((((f(R[0] + R[16]) >>> 8) + R[1]) ^ Konst)
                          + R[6]) + R[13];

where "f" is a substitution box function and "Konst" is a constant that is calculated during cipher initialization. The function f is defined by:

f(x) = SBox[x >> 24] ^ x;

Where SBox is a table of 256 constants.

PFF
pseudocode:

PFF(R, Konst, x) = f((f(R[4] + x) >>> 8) + Konst);

Encryption and Decryption:
Encryption is achieved by producing a keystream, which is then combined with the plaintext. The keystream is generated in groups of 4 octets.
pseudocode:

        Step(R);
          x = NLF(R, Konst);
          for (i = 0 to 3):
              v[i] = x & 0xff;
              x = x >> 8;

Encryption:

        for (i = 0 to p.length - 1):
              c[i] = p[i] ^ v[i];

Decryption:

        for (i = 0 to p.length - 1):
              p[i] = c[i] ^ v[i];

*p is the plaintext
*c is the ciphertext
*v is the keystream

Security:

Searching in the web I found this comment in a forum, about the security:

"The base attack on SOBER-128 is an exhaustive key search, (complexity of 2^128).In all attacks, it is assumed that the attacker observes a certain amount of keystream produced by one or more secret keys, and the attacker knows the corresponding plaintext and nonces. This is considered to resist an attack if either the attack requires the owner of the secret key(s) to generate more than 2^80 key stream words, or the computational complexity of the attack is equivalent to the attacker rekeying the cipher 2^128 times and generating at least 5 words of output each time."

Code example:
c
java

Tables:
http://tools.ietf.org/html/draft-paddon-sober128-01#appendix-A
http://tools.ietf.org/html/draft-paddon-sober128-01#appendix-B

Referencias:
http://en.wikipedia.org/wiki/SOBER-128
http://tools.ietf.org/html/draft-paddon-sober128-01
https://opensource.qualcomm.com/index.php?sober128
https://opensource.qualcomm.com/assets/pdf/SOBER-128-v2.pdf
http://www.ietf.org/mail-archive/web/cfrg/current/msg00293.html
http://www.ietf.org/mail-archive/web/cfrg/current/msg00280.html

Red Petri

Red Petri:
Es una representación de un sistema a eventos, en la que se describe el flujo de la información, ésta a su vez sirve como herramienta para modelar los sistemas.

Actividad:
Para esta entrada se nos encargo modelar un sistema concurrente, para el modelado de éste se empleo snakes de python, donde pueden descargarlo del siguiente link.

Mi sistema a modelar, será sobre las peticiones a un servidor y será algo básico, donde éste se encuentra esperando alguna entrada, una vez que tiene recibe algún dato, ésta la procesa para determinar si arroja un error, de lo contrario manda la información solicitada.

http://www.muycomputer.com/files/HIDDEN_264_12366_FOTO_Servidores_Google_0.jpg

Codigo:

Diagrama:

Referencias:
http://code.google.com/p/python-snakes/source/browse/doc/tutorial.txt?spec=svn.abcd.b7e58afd5c1b845899816065fff49d782e02a56b&repo=abcd&r=b7e58afd5c1b845899816065fff49d782e02a56b
http://www.uhu.es/diego.lopez/AI/auto_trans-tema3.PDF
http://es.wikipedia.org/wiki/Red_de_Petri
http://pommereau.blogspot.mx/2010/01/first-steps-with-snakes.html

Tarea 4: Laboratorio Automatización

Para ésta entrada se nos encargo realizar el problema 6.1, en la cuál me piden dibuar el siguiente sistema:

Teniendo la función de transferencia, ponemos nuestro angulo de condición:

Donde (K(s+1))-s^2 puede ser sustituido por la siguiente ecuación:

Una vez obtenido éste sustituimos todas las s, por δ + jw.

El libro nos mensiona que δ + jw, puede ser sustituido por tan^-1, asi que sustituyendo lo anterior y quitando el 2, para reordenarlo obtenemos:

Podemos reducir la ecuación anterior agregando tan a ambos lados, para despues quitar y asi tener w/δ, reducido .

Igualamos a cero la ecuación, para poder llegar a w/δ y así simplificar valores iguales:

Apoyandome con el libro, mensionan que podemos sustituir por lo siguiente:

donde obtenemos:

Teniendo ésta ecuacion, podemos igualar a cero teniendo lo siguiente:

Teniendo ésta ecuación seguimos a graficarla, donde w = 0, es nuetro eje de los reales de s = - 1 a s = infinito, nuestra segunda ecuación es la ecuación de nuestro circulo donde el centro es δ = -1, w = 0 y el radio es igual a 1 

Referencias:
http://autoycontrolave.blogspot.mx/ 
 Libro de Modern Control Engineering, Fourth Edition, de Katsuhiko Ogata
http://www.google.com.mx/url?sa=t&rct=j&q=&esrc=s&source=web&cd=7&ved=0CD4QFjAG&url=http%3A%2F%2Fes.scribd.com%2Fdoc%2F19150402%2FLazo-Abierto-y-Cerrado&ei=I26AUIrVPKSC4gSEx4CYAQ&usg=AFQjCNEc8ICl6bn7EJuJRZDLTmFOUA6a2Q&sig2=PmbObgDAPms1dbXhN9xlJA&cad=rja