Actividad 7 : Laboratorio Automatización

Ejercicio:
Este problema lo elegí de un libro que llevo una compañera de clase el cual se llama Sistemas de Control Moderno.

Determínise la función de Transferencia $\mathbf{X_{1}(s)/U(s)}$ y $\mathbf{X_{1}(s)/F(s)}$ para el sistema acomplado resorte-masa:

Este problema ya habia hecho uno parecido en el cual me base en unos videos, por ese motivo lo escogí para que no se me complicara mucho :P.

$Funcion de Transferencia=\mathbf{G\left ( s \right )}=\frac{L[salida]}{L [entrada]}|\textrm{condiciones iniciales cero}$

• $\mathbf{k_{1}}$,$\mathbf{k_{2}}$: constante elástica
• $\mathbf{b}$:constante de biscuocidad.
• $\mathbf{V_{1}}$,$\mathbf{V_{2}}$:Velocidad.
• derivada del desplazamiento es $\mathbf{\frac{dy}{dt} }$ y se utilizara de la siguiente manera $\mathbf{\dot{y}}$

Como sabemos la Ley fundamental que controla los sistemas mecaánicos es la Segunda Ley de Newton

$\mathbf{\sum F_{externas}=ma}$

Ahora tomando lo anterior y utilizando la Segunda Ley de Newton pasaremos a  la solución del problema:


Solución:

Primero que nada vamos a sacar las fuerzas que actúan sobre cada cuerpo, que en este caso tenemos dos.

$\mathbf{M_{1}}$:  

$\mathbf{M_{2}}$:  

Ya que terminamos de sacar las fuerzas que actúan obre cada cuerpo aplicamos la segunda Ley de Newton a cada uno de ellos:


Tomamos el sentido de la fuerza u como el sentido positivo (derecha=sentido positivo), lo que quiere decir que las fuerzas que actúen de lado izquierdo seran negativas:

$\mathbf{\sum F_{externas}=ma}$

Tomando en cuenta que:

$\mathbf{a=\frac{d^{2x}}{dt^{2}}=\ddot{x}}$


masa 1:      $\mathbf{F-k_{1}x_{1}-k_{2}\left ( x_{1}-x_{2} \right )=m_{1}\ddot{x}_{1}}$

masa 2:      $\mathbf{-b_{1}\dot{x}_{2}-k_{2}\left ( x_{1}-x_{2} \right )=m_{2}\ddot{x}_{2}}$

=

  $\mathbf{M_{1}\ddot{x}_{1}+k_{1}X_{1}+k_{2}x_{1}= u+k_{2}X_{2}}$

 $\mathbf{M_{2}\ddot{x}_{2}+b_{1}\dot{x}_{2}+k_{2}X_{2}=k_{2}X_{1}}$

Suponiendo que las condiciones iniciales son cero, pasamos las ecuaciones anteriores al dominio de Laplace



$\mathbf{[M_{1}s^{2}+k_{1}+k_{2}]X_{1}(s)= F(s)+k_{2}X_{2}(s)}$                 (1)

$\mathbf{[M_{2}s^{2}+b_{2}s+k_{2}]X_{2}(s)=k_{2}X_{1}(s)}$                          (2)

Ahora obtendremos las funciones de transferencias $\mathbf{X_{1}(s)/U(s)}$ 

$\mathbf{[M_{2}s^{2}++b_{1}s+k_{2}]X_{2}(s)=k_{2}X_{1}(s)}$

$\mathbf{X_{2}(s)=\frac{k_{2}X_{1}(s)}{M_{2}s^{2}+b_{1}s+k_{2}}}$


Sustituimos en la primer ecuación:
$\mathbf{[M_{1}s^{2}+k_{1}+k_{2}]X_{1}(s)= F(s)+k_{2}X_{2}(s)}$

$\mathbf{[M_{1}s^{2}+k_{1}+k_{2}]X_{1}(s)= F(s)+k_{2}[\frac{k_{2}X_{1}(s)}{M_{2}s^{2}+b_{1}s+k_{2}}]}$


$\mathbf{[M_{1}s^{2}+k_{1}+k_{2}]X_{1}(s)-k_{2}-\frac{k_{2}X_{1}(s)}{M_{2}s^{2}+b_{1}s+k_{2}}= F(s)}$

$\mathbf{X_{1}(s)[(M_{1}s^{2}+k_{1}+k_{2})-k_{2}[\frac{k_{2}X_{1}(s)}{M_{2}s^{2}+b_{1}s+k_{2}}]]= F(s)}$

$\mathbf{X_{1}(s)[\frac{(M_{1}s^{2}+k_{1}+k_{2})(M_{2}s^{2}+k_{2})-k_{2}^{2}}{M_{2}s^{2}+k_{2}}]= F(s)}$


Así ya encontramos la función de transferencia $\mathbf{X_{1}(s)/F(s)}$:


$\mathbf{ \frac{X_{1}(s)}{F(s)}=\frac{M_{2}s^{2}+k_{2}}{(M_{1}s^{2}+k_{1}+k_{2})(M_{2}s^{2}+k_{2})-k_{2}^{2}} }$

Reporte Final

¿Cuál es nuestro proyecto?

Nuestro proyecto consiste en un elevador de niveles, manejado por un motor de corriente directa, avanza según el desplazamiento ascendente o descendente.

Materiales Utilizados

Para poder saber los materiales que utilizariamos desarrollamos una estructura que en este caso es nuestrao elevador la cual se compone de lo siguiente:

A partir de esto los materiales utilizados son los siuientes:


Aluminio: Para la elaboración de la estructura

Tornillo sin fin: Para ayudar al movimiento de arriba hacia bajo.

Motor: Para mover el tornillo sin fin

Base de madera: Para el soporte del elevador


Circuito utilizado

Para poder realizar la programación utilizamos el software IDE de arduino y la placa arduino uno.

Circuito

Código:

	14:54
	int motor = 13; // choose the pin for the motor
	int inPin = 7; // choose the input pin (for a pushbutton)
	int val = 0; // variable for reading the pin status
	void setup() {
	pinMode(motor, OUTPUT); // declare motor as output
	pinMode(inPin, INPUT); // declare pushbutton as input
	}
	void loop(){
	val = digitalRead(inPin); // read input value
	if (val == HIGH) { // check if the input is HIGH (button released)
	digitalWrite(motor, LOW); // turn motor off
	} else {
	digitalWrite(motor, HIGH); // turn motor ON
	}
	}

view raw programa.ino hosted with ❤ by GitHub

Presentacion:


Demo del proyecto:
Link

Reporte Grupal

El reporte esta en el blog de mi compañero Rene: Link 

Actividad 5: Laboratorio

Para esta actividad seleccione el problema 8.22 del libro el cual trata de lo siguiente:

Considere el sistema de control que se muestra en la siguiente figura:

Dibuje los diagramas de Nyquist de G(s), donde:

para k=0.3, 0.5 y 0.7

Para poder solucionar este problema me base en como se resolvían los del libro :P, para poder sacar los diagramas de Nyquist usaremos Octave.

Primero que nada sustituiremos lo que es el valor de k, mejor dicho de las 3ks en lo que es la función de transferencia  y sacamos su diagrama de Nyquist correspondiente:

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+(5+10k)s}}$

k=0.3

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+(5+10(0.3))s}}$

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+(5+3)s}}$

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+8s}}$

Código para obtener el diagrama:

	octave:1> s=tf("s");
	octave:2> G=tf(10/(s*s*s+6*s*s+8*s))
	Transfer function 'G' from input 'u1' to output ...
	10
	y1: -----------------
	s^3 + 6 s^2 + 8 s
	Continuous-time model.
	octave:3> nyquist(G)

view raw gistfile1.txt hosted with ❤ by GitHub

diagrama:

k=0.5

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+(5+10(0.5))s}}$

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+(5+5)s}}$

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+10s}}$

Código para obtener el diagrama:

	octave:1> s=tf("s");
	octave:2> G=10/(s*s*s+6*s*s+10*s)
	Transfer function 'G' from input 'u1' to output ...
	10
	y1: ------------------
	s^3 + 6 s^2 + 10 s
	Continuous-time model.
	octave:3> nyquist(G)

view raw gistfile1.txt hosted with ❤ by GitHub

diagrama:

k=0.7

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+(5+10(0.7))s}}$

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+(5+7)s}}$

$\mathbf{G(s)=\frac{10}{s^{3}+6s^{2}+12s}}$

Código para obtener el diagrama:

	octave:1> s=tf("s");
	octave:2> G=10/(s*s*s+6*s*s+12*s)
	Transfer function 'G' from input 'u1' to output ...
	10
	y1: ------------------
	s^3 + 6 s^2 + 12 s
	Continuous-time model.
	octave:3> nyquist(G)

view raw gistfile1.txt hosted with ❤ by GitHub

diagrama:

Bibliografía:

Libro

Programa 1 Auto
Para comenzar anteriormente teniamos nuestra función de Transferencia la cual es:

$\mathbf{F\left ( t \right )=\tfrac{\frac{R_{e}}{K\Phi }}{T_{m}S}\left [ l_{e}S-l_{c}(S) \right ]}$

Nuestro programa en octave para la función de transferencia es el siguiente:

octave:1> den = [2 2];
octave:2> num = [3];
octave:3> sys = tf(num,den);
octave:4> step(sys)
octave:5> bode(sys)


Diagrama de bode:

También intente con otro código pero el cual no me graficaba nada :(

Report 3

Para esta semana teniamos que seleccionar un cifrado de flujo para investigar sobre el y más que nada investigar más a fondo acerca de estos temas:

• Origenes
• ¿Cuál fue la razon por la que se propuso?
• Como trabaja
• ¿Cuál es la matemática que se usa?
• Ejemplo 
• Ataques y vulnerabilidades

En mi caso seleccione el cifrado Turing.

Stream cipher: Turing

Origenes de Turing 

El cifrado de Turing fue desarrollado por Gregory G. Rose and Philip Hawkes  de Qualcomm para CDMA. El año en que fue creado fue entre el 2000 y 20003.

¿Cuál fue la razon por la que se propuso?

Fue diseñado para que fuera uno de los software más rapidos y para alcanzar alrededor de 5,5 ciclos / byte en algunos procesadores x86.  

También para ser al mismo tiempo:

• El software es muy rápido en los ordenadores de productos básicos
• Utilizán en muy poca RAM en procesadores embebidos
• Explotán el paralelismo para permitir la implementación hardware rápido.

Está diseñado para satisfacer las necesidades de aplicaciones integradas tales como encriptación de voz en los teléfonos inalámbricos que ponen severas restricciones en la cantidad de potencia de procesamiento, espacios de programa y la memoria disponible para los algoritmos de cifrado de software.

Acerca de  Turing

Se compone principalmente del Registro de desplzamiento lineal con realimentación lo cual se originó con el diseño de Sober.

Turing utiliza una caja S se deriva principalmente de la utilizada en  Sober-t32.

Structur

El cifrado de flujo Turing se integra de cuatro componentes claves los cuales son:

• carga
• descarga vector de inicialización
• un LFSR
• una llave de filtro no lineal (NLF)

A continuación se muestra una imagen en donde se muestra un diagrama de bloques de las dos últimas:

Matemáticas usada

Consideraciones Byte Orden
El cifrado de Turing utiliza operaciones nativas de procesador en los elementos de datos del tamaño de palabr, pero se espera que acepten claves que son simplemente cadenas de bytes y para producir un flujo de bytes como salida para el cifrado.

Los estándares de Internet se definen utilizando "big-endian" orden de bytes, en el que el byte más significativo de una cantidad multi-byte aparece primero en la memoria, esto es lo que se elige para Turing.
Link].

Matemáticas usada

Consideraciones Byte Orden
El cifrado de Turing utiliza operaciones nativas de procesador en los elementos de datos del tamaño de palabr, pero se espera que acepten claves que son simplemente cadenas de bytes y para producir un flujo de bytes como salida para el cifrado.

Los estándares de Internet se definen utilizando "big-endian" orden de bytes, en el que el byte más significativo de una cantidad multi-byte aparece primero en la memoria, esto es lo que se elige para Turing.

El "little-endian" máquinas, los bytes de la clave y el vector debe ser ensamblado en palabras, y las palabras de la corriente de salida debe ser revertido antes de ser byte XOR en el búfer.
LFSR de Turing

LFSR puede operar sobre cualquier campo finito, y puede ser más eficiente en software mediante la utilización de un campo finito más adecuado pcon elementos 2W $\mathbf{(GF(2^{w}))}$, donde w está relacionada con el tamaño de los elementos en el procesador subyacente, por lo general bytes o palabras de 32-bit. ara el procesador. Una  opcion buena que encontramos para el campo de Galois  con elementos 2W $\mathbf{(GF(2^{w}))}$  w es el tamaño de los elementos  en el procesador subyacente, generalmente bytes o palabras de 32-bit. 

El campo GF (2 w) puede ser representado como el operador de módulo 2 coeficientes de todos los polinomios con grado menor que w. Esto es, un elemento de un campo está representado por una palabra w bits con bits $\mathbf{a_{w-1},a_{w-2},...a_{1},a_{0}}$ lo que representa el polinomio:

$\mathbf{a_{w-1}x^{w-1}+a_{w-2}x^{w-2}+...+a_{1}x+a_{0}}$

Turing usa 8-nit bytes para representan los elementos de GF(28) y 32-bit que representan a 3 grados polinomios de bytes. El LFSR consiste en 17 palabras de información de estado w=32.


The Nonlinear Filter

Las cajas-S es el unico componente de Turing que es explícitaente no lineal. El filtro no lineal en Turing consta de:

•  Intensificación de la LFSR y la selección de los 5 canales de entrada 
• Mezcla las palabras utilizando el Transform1 Pseudo-Hadamard
• La transformación de los bytes con transformaciones por clave, y mezclando las palabras utilizando cuatro 8 → 32 bits lineales S-boxes
• Una vez más mezclando las palabras usando la Transformada de Pseudo-Hadamard
• Intensificación de la LFSR de nuevo y añadir (mod 232) más las palabras de entrada

La Clave-dependiente Transformación de caja S


El cifrado de Turing transforma cada palabra usando logicmente de 8 a 32 cajas-S se aplica a cada byte de la palabra de entrada y XOR.
Las cajas-S se basan al mismo tiempo en un fijo del 8 → 8 bits permutación S-box y un fijo no lineal 8 → 32 Qbox.


Las palabras B, C y D son girados dejados por 8, 16 y 24 bits, respectivamente, antes de la transformación de caja S.

Obtención de la Sbox

Es una permutación de los bytes de entrada y tiene un no linealidad mínimo de 104:

Obtención de la Qbox

El Qbox es un fijo no lineal 8 → 32-bit. Ha sido desarrollado por la Universidad de Tecnología de Queensland en nuestra petición. Se ve mejor como 32 funciones booleanas independientes de los 8 bits de entrada. Los criterios para su desarrollo fueron:
• Las funciones deben ser altamente no lineal (cada uno tiene no linealidad de 114)
• Las funciones deben ser equilibrados
• Las funciones deben ser pares correlacionados

Las  claves dependientes Sboxes


Ventajas y Desventajas

Ventajas:

• Turing supera la ineficiencia de LFSRs binarios de una manera similar a la de SNOW 2,0 mediante la utilización de un LFSR definido sobre GF ((28) 4) y un número de técnicas para grandemente 
• aumentar la velocidad de generación de la secuencia pseudo-aleatoria en el software de un general 
• procesador.
• Turing permite un equilibrio entre el uso de la aplicación de memoria pequeña o  muy alta velocidad utilizando pre-calculados tablas.

Referencia
Link1
LInk2
Link3
LInk4
LInk5

Actividad 4: Laboratorio de Automatización


En esta ocasión seleccione el problema 3 del capítulo 5 el cual trata de lo siguiente:

Considere el sistema en lazo cerrado dado por:


$\mathbf{\frac{C\left ( s \right )}{R\left ( s \right )}=\frac{w^{2}_{n}}{s^{2}+2\zeta w_{n}s+w^{2}_{n}}}$

Determine los valores de $\mathbf{\zeta }$ y $\mathbf{w_{n}}$ para que el sistema responda a una entrada escalon con una sobreelongación de aproximadamente el 5% y con un tiempo de asentamiento de 2 seg  (Utilize el criterio del 2%).

Para comenzar tenemos que observar que la soobrelongacion $\mathbf{M_{p}}$  es:

$\mathbf{M_{p}=e^{-\zeta \pi /\sqrt{ 1-\zeta ^{2}}}}$

Se especifica como el 5%. Por tanto:

$\mathbf{e^{-\zeta \pi /\sqrt{ 1-\zeta ^{2}}}=0.05}$

Sacamos el valor de: $\mathbf{-\zeta \pi /\sqrt{ 1-\zeta ^{2}}}$

$\mathbf{-\zeta \pi /\sqrt{ 1-\zeta ^{2}}=x}$

$\mathbf{e^{x}=0.05}$

Para poder despejar tenemos que usar Ln: $\mathbf{Ln(e^{x})=Ln(0.05)}$

$\mathbf{x=Ln(0.05)}$

$\mathbf{Ln(0.05)=−2.995732274}$

Entonces obtenemos que:

$\mathbf{x=−2.995732274}$


$\mathbf{-\zeta \pi /\sqrt{ 1-\zeta ^{2}}=−2.995732274}$

Aplicamos una multiplicación negativa:

$\left (\mathbf{-\zeta \pi /\sqrt{ 1-\zeta ^{2}}=−2.995732274}  \right )-1$

$\mathbf{\zeta \pi /\sqrt{ 1-\zeta ^{2}}=2.995732274}$

Ahora que ya tenemos ese valor podemos despejar y  obtener el valor de  $\mathbf{\zeta }$ que es la que nos piden en este problema:

Dato: $\mathbf{\pi = 3.14}$:
$\mathbf{\frac{\zeta \pi }{\sqrt{1-\zeta^{2} }}=2.995732274 }$

$\mathbf{\zeta \pi =2.995732274\left ( \sqrt{1-\zeta^{2}} \right ) }$

$\mathbf{\left (\zeta \pi =2.995732274\left ( \sqrt{1-\zeta^{2}} \right )  \right )^{2} }$

$\mathbf{\zeta^{2} \pi^{2} =8.974411857 ( 1-\zeta^{2})}$

Sustituimos valor de  $\mathbf{\pi = 3.14}$

$\mathbf{\zeta^{2}(3.14^{2}) =8.974411857 ( 1-\zeta^{2})}$

$\mathbf{9.8596\zeta^{2} =8.974411857 ( 1-\zeta^{2})}$

Continuamos con el despeje:

$\mathbf{9.8596\zeta^{2} =8.974411857-8.974411857\zeta^{2}}$

$\mathbf{9.8596\zeta^{2}+ 8.974411857\zeta^{2}=8.974411857}$

$\mathbf{18.834011857\zeta^{2}=8.974411857}$

$\mathbf{\zeta^{2}=\frac{8.974411857}{18.834011857}}$

$\mathbf{\zeta^{2}=0.476500276}$

$\mathbf{\zeta=\sqrt{0.476500276}}$

y el resultado es: $\mathbf{\zeta=0.690289994}$

Después se obtiene el valor de $\mathbf{w_{d}}$ basandonos en lo  siguientes:

$\mathbf{t_{p}= \frac{\pi }{w_{d}}}$

$\mathbf{t_{p}= \frac{\pi }{w_{d}}=2}$

$\boldsymbol{\pi=2w_{d}}$

$\boldsymbol{3.14=2w_{d}}$

$\boldsymbol{3.14/2=w_{d}}$

$\boldsymbol{w_{d}=1.57}$

Ahora obtenemos el valor de lo otro que nos pide el problema que es $\mathbf{w_{n}}$:

$\boldsymbol{w_{n}=\frac{_{w_{d}}}{\sqrt{1-\zeta ^{2}}}}$

$w_{n}=\frac{1.57}{\sqrt{1-0.690289994 ^{2}}}$

$w_{n}=\frac{1.57}{\sqrt{0.523499724}}$

$w_{n}=\frac{1.57}{0.723532808}$

$\boldsymbol{w_{n}=2.169908514}$

Bibliografía:
Libro

Reporte 2: Diagrama de Bloques

Función de Transferencia anteriormente obtenida:

$\mathbf{F\left ( t \right )=\tfrac{\frac{R_{e}}{K\Phi }}{T_{m}S}\left [ l_{e}S-l_{c}(S) \right ]}$

En nuestra Función de Transferencia  como entrada al sistema tenemos lo que es:
El voltaje aplicado al motor: $V_{e}\left ( t \right )$

Y la salida del sistema es la velocidad de rotación del motor:  $\Omega \left ( t \right )$

Después pasamos a realizar el Diagrama de Bloque de nuestra función de transferencia:

Pasos:

1.-

2.-

3.-

4.-

5.-

Referencia:

Link1
Link2

Tarea 5

En esta semana se trabajo realizando un webservice, para esto utilice PHP y mysql


 El siguiente es el código para la conexión de la base de datos, en donde use mi contraseña.

	<?php
	$host="localhost";
	$user="root";
	$password="blanka";
	$conn= mysql_connect ($host, $user,$password) or die ("<b>No se puede conectar con la base de datos\n</b>\n");
	$db="validacion";
	if(!(mysql_select_db($db,$conn))){
	echo "No se puede conectar a la base de datos";
	}
	?>

view raw conn.php hosted with ❤ by GitHub

Después tenemos lo que es el programa en si, por un lado el usuario podemos generar un challege que seria en este caso un numero random asignado a una variable x, el programa me da la opción de descargar el script, que correremos para poder generar el response. También tenemos que seleccionar el usuario antes de picarle submit.

	<?php
	require("conn.php");
	?>
	<html>
	<head>
	<script>
	function generar(inf,sup){
	numP = sup - inf;
	rnd = Math.random() * numP;
	rnd = Math.round(rnd);
	document.formulario.challengen.value=parseInt(inf) + rnd;
	}
	</script>
	</head>
	<a href="script.py">Descargar script</a>
	<form name="formulario" method="POST" action="validar.php" >
	<b>Challenge:</b><input type="text" name="challengen"><input type="button" value="Generate" onclick="generar(0,100)">
	<br><b>User:</b><select name="user">
	<?php
	$query="SELECT user FROM users";
	$result=mysql_query($query,$conn);
	while($row=mysql_fetch_array($result)){
	echo "<option value='".$row["user"]."'>".$row["user"]."</option>";
	}
	?>
	</select>
	<br><b>Response:</b><input type="text" name="response">
	<br><input type="submit" value="submit">
	<?php
	function f($x){
	return ($x*7*$x);
	}
	function fastmodexp($x,$y, $mod){
	$p = 1;
	$aux =$x;
	while($y > 0){
	if ($y % 2 == 1){
	$p = ($p * $aux) %$mod;
	}
	$aux = ($aux * $aux) %$mod;
	$y =$y >> 1;
	}
	return ($p);
	}
	if(isset($_POST['response']) and isset($_POST['user']) and isset($_POST['challengen'])){
	$usuario =$_POST['user'];
	$x =$_POST['challengen'];
	$r =$_POST['response'];
	$query="SELECT E,N From users WHERE user = '".$usuario."'";
	$result=mysql_query($query,$conn);
	$publica = mysql_fetch_array($result);
	$e =$publica["E"];
	$n =$publica["N"];
	$y = f($x);
	$num = fastmodexp($r, $e,$n);
	if ($y ==$num){
	echo "<strong><h2>Yes, it was ". $usuario ." :)</h2></strong>";
	} else {
	echo "<strong><h2>No, it wasn't ". $usuario ." :(</h2></strong>";
	}
	} ?>
	</form>
	</html>

view raw val.php hosted with ❤ by GitHub

Ahora el codigo del script:

	def function(x):
	return x*3*11*7
	def fastmodexp(x, y, mod):
	p = 1
	aux = x
	while y > 0:
	if y % 2 == 1:
	p = (p * aux) % mod
	aux = (aux * aux) % mod
	y = y >> 1
	return p
	def main():
	x = int(raw_input("Dame x: "))
	d = int(raw_input("Dame d: "))
	n = int(raw_input("Dame n: "))
	y = function(x)
	r = fastmodexp(y, d, n)
	print " r = ",r
	main()

view raw script.py hosted with ❤ by GitHub

Código de la base de datos:

	-- Database: `validacion`
	--
	-- --------------------------------------------------------
	--
	-- Table structure for table `users`
	--
	CREATE TABLE IF NOT EXISTS `users` (
	`user` varchar(50) NOT NULL,
	`E` bigint(20) NOT NULL,
	`N` bigint(20) NOT NULL
	) ENGINE=InnoDB DEFAULT CHARSET=latin1;
	--
	-- Dumping data for table `users`
	--
	INSERT INTO `users` (`user`, `E`, `N`) VALUES
	('abraham', 1307909, 14287901),
	('pepe', 17, 3233),
	('cecy', 59, 5767),
	('blanka', 79, 1067);

view raw db.sql hosted with ❤ by GitHub

Capturas de imagenes:

Primero que nada tenemos la interfaz :P, en donde nos da la opción de descargar el script, para poder correrlo.

Ya descargado le picamos en Generate para generar nuestra x que nos salio 38:

Ahora vamos a correr el script y nos pide x, en este caso ponemos la que se nos genero arriba, la d y la n son de la clave privada que esa nos la dieron al momento de crear un usuario en mi caso blanka.

Nos arroja un resultado que es r=response, lo pondremos donde viene la R que significa response.

 Le damos a submit y si soy yo :D

Y por ejemplo si pongo un usuario q no es correcto ya que no tengo sus claves privadas me sale q no soy :P

En esta semana trabajamos con rsa,

	from Crypto.Util.number import getPrime
	from random import uniform
	from sys import argv
	def test_prime(num):
	for i in range(2,num):
	if num % i == 0:
	return False
	return True
	def generate_prime():
	while True:
	num = int(uniform(10,100))
	if test_prime(num):
	break
	return num
	#where gcd means greatest common denominator)
	def gcd(phi,e):
	if phi % e == 0:
	return e
	else:
	return gcd(e, phi%e)
	def generate_e(phi):
	while True:
	e=generate_prime()
	if gcd(phi,e)==1:
	return e
	break
	def gcde(a,b):
	x, X = 0, 1
	y, Y = 1, 0
	while(b != 0):
	q = a / b
	(a, b) = (b, a%b)
	(x, X) = (X - q * x, x)
	(y, Y) = (Y - q * y, y)
	return(X, Y, a)
	def inverse_modulo(e,phi):
	d,q,gcd =gcde(e,phi)
	if gcd == 1:
	return (d + phi) % phi
	else:
	return 0
	def keys(username,e,d,n):
	r1=open('public_key.txt','w')
	r2=open(str(username)+'.txt','w')
	r1.write(username + ' ' + str(e) + ' ' + str(n) + '\n')
	r2.write(username + ' ' + str(d) + ' ' + str(n) + '\n')
	r1.close()
	r2.close()
	def main():
	try:
	username=argv[1]
	except:
	username=raw_input("Username: ")
	print 'username', username
	#p and q are prime numbers
	p=generate_prime()
	q=generate_prime()
	print 'p', p
	print 'q', q
	#calculate n
	n=p*q
	print 'n', n
	#calculate the Euler function OB=phi
	phi = (p-1)*(q-1)
	print 'phi', phi
	#We choose a positive integer less than phi
	#e must be relatively prime to phi
	e = generate_e(phi)
	print 'e', e
	d=inverse_modulo(e, phi)
	print 'd', d
	if d<0:
	d = d+phi
	keys(username,e,d,n)
	main()

view raw rsa.py hosted with ❤ by GitHub

Codigo del server:

	from random import randint
	import socket,sys,pickle
	from math import sqrt
	def get_password(usuario):
	file = open('public_key.txt','r')
	for line in archivo.readlines():
	if len(line)==0:
	continue
	lin = line.split()
	if lin[0] == usuario:
	dates=[int(lin[1]),int(lin[2])]
	return dates
	else:
	line +=1
	file.close()
	return False
	def function(x):
	return (x*(xsqrt(4))+2)
	def main():
	#Function socket.socket creates a socket and returns a socket descripto
	#Propierties:
	#Address Family: AF_INET(this is IP version 4)
	#Type: SOCK_STREAM(this means connection oriented TCP protocol)
	socket_s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	print 'Socket Created'
	host = 'localhost'
	port = 8005
	socket_s.bind((host,port)) #Se crea la conexion al IP y puerto
	print 'Socket bind complete'
	socket_s.listen(1)
	print 'Socket now listening'
	print 'Esperando cliente'
	while 1:#loop to serve customers
	#wait to accept a connection - blocking call
	socket_client, address_client = socket_s.accept()
	print 'Connection established...'
	print 'La direccion del cliente es: ', address_client
	#send the public key over
	x = str(randint(1,100))
	print 'x' ,x
	usuario=socket_client.recv(512)
	print 'usuario', usuario
	socket_client.send(x)
	#socket_client.send(pickle.dumps(rsapublickey))
	entrada=True
	while entrada:
	request = socket_client.recv(512)
	dates=get_password(request)
	if dates==False:
	print 'No eres '
	socket_s.close()
	client_socket.close()
	e=dates[0]
	n=dates[1]
	y = (int(request)**e)%n
	if function(x)==y:
	socket_client.send('Welcome...')
	else:
	socket_client.send('Failure...')
	socket_client.close()
	main()

view raw server.py hosted with ❤ by GitHub

Código dle client:

	import socket
	from math import sqrt
	def get_password(usuario):
	file = open(usuario+'txt','r')
	line=file.readlines()
	usuario = line[0].split()
	file.close()
	return usuario
	def function(x):
	return (x*(xsqrt(4))+2)
	def main():
	host = 'localhost'
	port = 8005
	#Function socket.socket creates a socket and returns a socket descriptor
	#Propierties:
	#Address Family: AF_INET(this is IP version 4)
	#Type: SOCK_STREAM(this means connection oriented TCP protocol)
	socket_c = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
	socket_c.connect((host,port))
	print 'Client.'
	x=socket_c.recv(512)
	print 'x'
	rx=int(x)
	y=function(rx)
	usuario = raw_input("Usuario: ")
	dates=get_password(usuario)
	if dates==False:
	print 'No eres '
	socket_c.close()
	client_socket.close()
	d=dates[0]
	n=dates[1]
	r =str(pow(y,d) % n)
	socket_c.send(usuario)
	socket_c.send(r)
	s.close()
	main()

view raw client.py hosted with ❤ by GitHub

Reporte 1_


Modelen lo que se controlará en su proyecto grupal y calculen la función de transferencia para la planta.

Descripción:

El proyecto sera controlado por medio de arduino, ya que tenemos un conocimiento más amplio acerca de este, lo que se hara es controlar un motor para que la rueda o el estacionamiento gire, lo que quiere decir que nuestro sistema sera un istema  mecánico de rotación.

El arduino enviara un impulso al motor para que este gire y al momento de que se mueva se movera la rueda, la rueda sufrira un desplazamiento, la fuerza aplicada a la rueda dependera del peso que se concentra en la rueda, que dependera del peso de la cantidad de los autos .

Al mometo  de que el primer coche se estaciona la rueda calcula el peso y lo manda como parametro para saber cual va a hacer la fuerza que el motor aplica sobre ella, para poder hacerla girar.

Función de Transferencia

La función de transferencia de un sistema descrito mediante una ecuación diferencial lineal e invariante con el tiempo se define como el cociente entre la transformada de Laplace de la salida (función de respuesta) y la transformada de Laplace de la entrada (función de excitación) bajo la suposición de que todas las condiciones iniciales son cero.[Texto sacado del libro ]
Link2
$Funcion de Transferencia=\mathbf{G\left ( s \right )}=\frac{L[salida]}{L [entrada]}|\textrm{condiciones iniciales cero}$

Salida del sistema:

La salida del sistema en este caso es es desplazamiento angular que sufre la rueda del estacionamiento.

Entrada del sistema:

La entrada del sistema seria el impulso enviado por el arduino.


Como la 2da ley de Newtón controla a los sistemas mecánicos, utilizaremos esta formula:

$\mathbf{\sum F_{externas}=ma}$

pero como es rotacional cambia a:

$\mathbf{ F_{t}=ma_{t}=m(r\alpha )}$
$\mathbf{ F_{r}=ma_{r}=m(\omega ^{2}r)}$

Datos:
$\omega ^{2}$ : velocidad angular

$\alpha$: aceleración angular

Se aplica la primera ley de Newton.

Sistema mecánico:

En este caso x1 = $\theta$

Función de trasferencia:

$Funcion de Transferencia=\mathbf{G\left ( s \right )}=\frac{L[salida]}{L [entrada]}|\textrm{condiciones iniciales cero}$

Y nuestra función de transferencia seria:

$\mathbf{G\left ( s \right )}=\frac{\theta (s)}{V(t)}$


V(t)= voltaje recibido por el motor

Ahora aplicado a todo el sistema:

 En este caso y2 y x1 = $\theta _{1}$ y $\theta _{2}$

Aquí sacariamos las fuerzas q actuan sobre cada uno de los cuerpos para poder aplicarles la segunda ley de Newton.

Y para el sistema completo nuestra función de transferencia seria:

$\mathbf{G\left ( s \right )}=\frac{\theta _{2} (s)}{U_{2}(s)}$


Referencias:

Link1
Link2
Link3

Actividad 2: Laboratorio

Transformada inversa de Laplace

Problema B.2.15

Obtenga el desarrollo en fracciones simples de la siguiente función utilizando MATLAB.


$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}$


En mi caso yo no utilizare MATLAB sino el programa Octave ya que es con uno de los que estamos trabajando.

Utilizaremos la siguiente función:

$\left [ r,p,k,e \right ]= residue\left ( num,den \right )$

La cual nos sirve para poder calcular la descomposición de factores simples del cociente del polinomion num(numerador) entre el den(denominador):

r = Son los residuos (numeradores)
p = Son los polos (denominadores)
k = Es el cociente
e = Son los exponentes para cada denominador

Lo que quiere decir:

$\frac{num\left ( s \right )}{den\left ( s \right )}= k\left ( s \right )+{\frac{r\left ( 1 \right )}{\left ( s-p\left ( 1 \right ) \right )^{e\left ( 1 \right )}}}+{\frac{r\left ( 2 \right )}{\left ( s-p\left ( 2 \right ) \right )^{e\left ( 2 \right )}}}$

Ahora vamonos a octave en nuestra términal, para entrar tecleamos lo siguiente:

blanka@blanka:~$ octave

view raw octave1 hosted with ❤ by GitHub

Ya que estamos dentro de Octave capturamos dos vectores con los coeficientes del numerados y denominador en mi caso yo le llame num(numerados) y den(denominador):

Para poder hacer esto nosotros tenemos que tener la función expresada en un solo polinomio no en varios, pero para no hacerlo tan dificil y tener que estando multiplicando mucho lo que aremos sera usar otra función de octave que realiza esto por nosotros:

$conv\left ( p,s \right )$

Lo malo es que solo puede realizarse sobre dos polinomios entonces ajustaremos nuestra función dada para que solo sean dos en el caso del numerador y el denominador:

Recuerden que la función es:

$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}$

Convertir numerador y denominador, los pasos son los siguientes

Paso 1:

En la parte del numerador juntamos el diez con alguno de los dos binomios para solo tener dos, yo lo hice con el primero binomio $\left ( s+2 \right )$.



$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}=F\left ( s \right )= \frac{\left ( 10s+20 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}$
Paso 2:

Ahora con el denominador, multiplicamos los binomios $\left ( s+1 \right )\left ( s+3 \right )$ y realizamos el binomio cuadrado perfecto $\left ( s+5 \right )^{2}$:


$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}=F\left ( s \right )= \frac{\left ( 10s+20 \right )\left (s+4 \right )}{\left ( s^{2}+4s+3 \right )\left ( s{^{2}+10s+25} \right )}$

Términando lo anterior pondremos los vectores en la términal, recuerden que solo se ponen los constantes:

	octave:1> num = conv([10 20],[1 4]);
	octave:2> den = conv([1 4 3],[1 10 25]);

view raw octave 2 hosted with ❤ by GitHub

Utilizamos la función residue para sacar lo que se nos pidio:

octave:3> [r,p,k,e] = residue(num,den)

view raw octave3 hosted with ❤ by GitHub

Nos arrojara lo siguiente en la términal:

Como vimos es muy fácil obtener el desarrollo de fracciones simples con octave y lo obtenido fue:

$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}={\frac{.9375}{\left ( s+1 \right )}}+{\frac{1.25}{\left ( s+3 \right )}}+\frac{3.75}{\left ( s+5 \right )^{2}}+{\frac{-2.1875}{\left ( s+5 \right )}}$

Después obtenga la transformada inversa de Laplace de $F\left ( s \right )$

Para poder obtener la transformada podemos usar lo que obtuvimos en lo anterior de fracciones simples con octave, primero lo aremos de esta manera y después de la manera larga en donde nosotros tenemos que obtenerlo por fracciones parciales:

Para calcular la transformada inversa necesitaremos la tabla de parejas de transformadas de laplace que viene en el libro que estamos utilizando: Link  (Libro 4ta edición-no vienen algunas páginas):

Tranformada inversa con los datos que nos arrojo octave

$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}={\frac{.9375}{\left ( s+1 \right )}}+{\frac{1.25}{\left ( s+3 \right )}}+\frac{3.75}{\left ( s+5 \right )^{2}}+{\frac{-2.1875}{\left ( s+5 \right )}}$

Esto solo se hace en un paso ya teniendo los valores de las fracciones simples lo unico que hacemos es buscar en la tabla el denominador que tienen estas fracciones.

De la tabla las que utilizaremos serán:

Función f(t)	Transformada F(s)
$e^{-at}$	$\frac{1}{s+a}$
$te^{-at}$	$\frac{1}{\left ( s+a \right )^{2}}$

Como se dan cuenta las fracciones simples que tenemos son como lo que tenemos en la parte de Transformada F(s) en nuestra tabla:

${\frac{.9375}{\left ( s+1 \right )}}-->{\frac{1}{\left ( s+a \right )}}$

${\frac{1.25}{\left ( s+3 \right )}}-->{\frac{1}{\left ( s+a \right )}}$

${\frac{3.75}{\left ( s+5 \right )^{2}}}-->{\frac{1}{\left ( s+a \right )^{2}}}$

${\frac{-2.1875}{\left ( s+5 \right )}}-->{\frac{1}{\left ( s+a \right )}}$

Lo unico que hacemos es tomar la Función f(t) que le pertenece a esa Transformada F(s) con sus valores de a indicados.

Ahora sacamos la transformada inversa directamente:

$L^{-1}[F\left ( s \right )]=.9375e^{-t}+1.25e^{-5t}+3.75te^{-5t}-2.1875e^{-5t}$

Ya terminado lo haremos por la parte larga que ya menciones, donde para ello utilizaremos las fracciones parciales.

Lo primero que haremos sera expresar la función que nos dieron en fracciones parciales:
Recurden que cuando tenemos factores de primer grado repetidos en el denoominador como en nuestro caso $\left ( s+5 \right )^{2}$ , lo que haremos es poner una constante sobre cada raiz disminuyendo en uno el exponente.
La función queda de la siguiente manera:
$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}={\frac{A}{\left ( s+1 \right )}}+{\frac{B}{\left ( s+3 \right )}}+\frac{C}{\left ( s+5 \right )^{2}}+{\frac{D}{\left ( s+5 \right )}}$

Pasos para Resolver:

Paso 1

Multiplicamos los miembros de las fracciones parciales por el denominador de la función que se nos dio:

$\frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}=\left [ {\frac{A}{\left ( s+1 \right )}}+{\frac{B}{\left ( s+3 \right )}}+\frac{C}{\left ( s+5 \right )^{2}}+{\frac{D}{\left ( s+5 \right )}} \right ]{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}$

Paso 2

La multiplicación anterior nos da como resultado:

${10\left ( s+2 \right )\left (s+4 \right )}=A\left ( s+3 \right )\left (s+5 \right )^{2}+B\left ( s+1 \right )\left ( s+5\right )^{2}+C\left ( s+1 \right )\left ( s+3 \right )+D\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )$
${10\left ( s+2 \right )\left (s+4 \right )}=A\left ( s+3 \right )\left (s^{2}+10s+25 \right )+B\left ( s+1 \right )\left ( s^{2}+10s+25\right )^{2}+C\left ( s ^{2}+4s+3\right )+D\left ( s+1 \right )\left ( s^{2}+8s+15 \right )\left ( s+5 \right )$
${10\left ( s+2 \right )\left (s+4 \right )}=A\left ( s^{3}+13^{2}+55s+75s \right )+B\left ( s^{3}+11s^{2}+35s+25 \right )+C\left ( s ^{2}+4s+3\right )+D\left ( s^{3}+9s^{2}+23s+15 \right )$
${10\left ( s+2 \right )\left (s+4 \right )}=As^{3}+13A^{2}+55As+75As + Bs^{3}+11Bs^{2}+35Bs+25B+Cs^{2}+4Cs+3C + Ds^{3}+9Ds^{2}+23Ds+15D$
Asosiamos:

${10\left ( s+2 \right )\left (s+4 \right )}=(A+B+D)s^{3}+(13A+11B+C+9D)s^{2}+(55A+35B+4C+23D)s+(75A+25B+3C+15D)$

Formamos ecuaciones semejantes y queda:

1- $A+B+D=0$
2- $13A+11B+C+9D=10$
3- $55A+35B+4C+23D=60$
4- $75A+25B+3C+15D=80$

Paso 3
Resolvemos el siguiente sistema de ecuaciones anterior.

Seleccionamos la primera ecuación y despejamos A.

$A+B+D=0$
$A= -B -D$

Ya que tenemos lo que vale A sustituimos  en las otras ecuaciones:

1-. $13A+11B+C+9D=10$ $13(-B-D)+11B+C+9D=10$  $-13B-13D+11B+C+9D=10$  $-2B+C-4D=10$ <--1

2-. $55A+35B+4C+23D=60$ $55(-B-D)+35B+4C+23D=60$ $-55B-55D+35B+4C+23D=60$ $-20B+4C-32D=60$ <--2

3-. $75A+25B+3C+15D=80$ $75(-B-D)+25B+3C+15D=80$ $75B+75D+25B+3C+15D=80$ $-50B-60D+3C=80$ <--3

Ya reducidas las ecuaciones y con la primer ecuación trabajaremos con ellas para encontrar los resultados de A,B, C y D:

Paso1

Ecuaciones 1 y 2:

     $-2B+C-4D= 10$           (4)
     $-20B+4C-32D= 60$      (-1)
=
     $-8B+4C-16D= 40$
     $20B+32D-4C= -60$
  _____________________

     $12B+  0 +16D= -20$

-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.


Ecuaciones 1 y 3:

     $-2B+C-4D= 10$            (3)
     $-50B-+3C+60D=80$      (-1)
=
     $-6B+3C-12D=  30$
     $50B-3C+60D= -80$
  _____________________

     $44B+ 0 +48D= -50$


-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.

Paso 2

Trabajamos con los dos resultados anteriores

$12B+16D= -20$
$44B+48D= -50$

Para no trabajar con numeros tan grandes lo que haremos sera dividir entre dos las ecuaciones anteriores:

$6B+8D= -10$
$22B+24D= -25$



     $6B+8D= -10$            (-24)
     $22B+24D= -25$         (8)
=
     $-144B-192D= 240$
     $176B+192D= -200$
  _____________________

     $32B+ 0 = 40$

     $32B= 40$
     $B= 40/32$

     $B= 1.25$ <--Valor de B encontrado

-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

Paso 3

En contramos los demás valores sustituyendo en las ecuaciones.


$22B+24D= -25$ <-- Fue la ecuación que obtuvimos en el paso anterior, aquí sustutuimos la B ya encontrada para sacar D.

$22(1.25)+24D= -25$
$27.5+24D=-25$
$24D=-25-27.5$
$24D= -52.5$
$D=-52.5/24$

$D=-2.1875$

Obtenemos el valor de A:

$A=-B -D$
$A=-(1.25) -(-2.1875)$
$A=-1.25+2.1875$

$A= .9375$

Y para finalizar sacamos el valor de C usando la siguiente ecuación:

$-2B+C-4D=10$
$-2(1.25)+C-4(-2.1875)=10$
$-2.5+C+8.75=10$
$C=10-8.75+2.5$

$C=-3.75$

Ya obtuvimos todos los valores, ahora sustituimos ese valor en sus lugares respectivos:
$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}={\frac{A}{\left ( s+1 \right )}}+{\frac{B}{\left ( s+3 \right )}}+\frac{C}{\left ( s+5 \right )^{2}}+{\frac{D}{\left ( s+5 \right )}}$

=

$F\left ( s \right )= \frac{10\left ( s+2 \right )\left (s+4 \right )}{\left ( s+1 \right )\left ( s+3 \right )\left ( s+5 \right )^2}={\frac{.9375}{\left ( s+1 \right )}}+{\frac{1.25}{\left ( s+3 \right )}}+\frac{3.75}{\left ( s+5 \right )^{2}}+{\frac{-2.1875}{\left ( s+5 \right )}}$

Si se fijan obtuvimos los mismos valores que nos arrojo octave, entonces solo es de sustituir como anteriormente con l función de f(t) que le pertenece a la transformada de F(s) y da el mismo resultado.


$L^{-1}F\left ( s \right )= .9375e^{-t}+1.25e^{-5t}+3.75te^{-5t}-2.1875e^{-5t}$


Referencias:
Información de residue y conv: octave

Tarea2:

 La tarea 2 es checar si las claves que genera nuestro otp (one time pad) realmente es aleatoria.

 La clave evaluada fue la siguiente:


Esta clave es generada del programa anterior con el siguiente código:

	def generar_claves():
	k=''
	for m in range(10):
	s = binary(randint(0,255))
	k += s
	return k

view raw g.py hosted with ❤ by GitHub

Funciona leyendo las claves del archivo llamado key.txt pasandoselo a cada uno de los test.

	def leer_archivo(archivo,test):
	archivo = open(archivo, 'r')
	numero=''
	for i in archivo.readline().strip():
	numero+=i
	# print numero
	#print (len(numero))
	if test==3:
	print numero
	return numero
	else:
	numero = map(int,numero)
	numero = array(numero)
	return numero

view raw leer.py hosted with ❤ by GitHub

Primero yo realice un test sencillo que se llama Monobit:

Monobit

Detecta los ceros y los unos que se encuentran en la cadena binaria, sustituyendo los ceros que encuentre por -1, asi realizando una suma. La aparición de ceros y unos en la secuencia global deberan de ser igualmente probables

Datos a tener:

n = tamaño de la clave binaria
ε =La secuencia de bits que se esta probando

Procedimiento:

1. Como mencione se buscan los ceros y se sustituyen por -1y se realiza una suma, ejemplo:
   lista=[1,1,0,0,1,0,1]
   quedaría:
   lista=[11,-1-1,1-11]
 y se realiza la suma de la lista

2-Se calcula la prueba estadística:

3. Se calcula p_value ( erfc es la función error complementaria.)

4.Si P - value > 0.01, la secuencia  es aleatoria.

Código:

	def monobit(lista):
	print 'Test Monobit'
	n=len(lista)#tam de lalista
	for m in range(n):# recorre la lista
	if lista[m]==0:
	lista[m]= -1 # Si encuentra un 0 en la lista lo hace -1
	sn=sum(lista) # realiza la suma
	s_obs=abs(sn)/math.sqrt(n) #calcula prueba estadistica
	p_value= math.erfc(s_obs/math.sqrt(2)) #calcula p_value
	if p_value > 0.01:
	print ">> Frequency Test: PASSED -->", p_value
	else:
	print ">> Frequency Test: NOT PASSED --> ", p_value

view raw monobit.py hosted with ❤ by GitHub

Captura de pantalla de la prueba:

También utilice otras dos pruebas que es la de Poker y la de frecuencia de Bloques

Frecuencia de Bloques

En la prueba de bloques los ceros y unos deberan de ser igualmente probables.
 Datos:

n - largo de la secuencia
m - el largo de cada bloque
ε - secuencia de bits generada

Recomendaciones:

Procedimiento:

1. Se parte la prueba e bloques de un cierto tamaño se calcula de la siguiente manera:
  

2. Se determina la proporción de unos:

3. Se calcula la chi2=X2

4.  Se calcula la p_value:

Código

	def frequency_block(list):
	print 'Test Block'
	n = len(list)
	M = 0.01*n
	N =int( n/M)
	blocks = []
	X2 = 0
	print type(blocks)
	i=0
	while(len(blocks) != N):
	blocks.append(list[i:(i+M)])
	i = i + M
	sumas = []
	for i in range(len(blocks)):
	sumas.append(0)
	for j in range(len(blocks[i])):
	sumas[i] = sumas[i] + blocks[i][j]/float(M)
	for i in range(N):
	X2 = X2 + math.pow((sumas[i] - .5), 2)
	X2 = X2 * 4*M
	df = M - 1
	p_value = chi2.cdf(X2, df)
	if p_value < 0.01:
	print "Frequency Test with Blocks: NOT PASSED"
	else:
	print "Frequency Test with Blocks: PASSED"

view raw bloques.py hosted with ❤ by GitHub

Captura de pantalla

Prueba de Póker

Lo que hace la prueba de póker es dividir la clave en numeros de 4 bist, por ejemplo si yo tengo esta:

0101000001100011

se divide de la siguiente manera :
0101 0000 0110 0011

entonces como se divide en 4 hay 16 posibles resulados que pueden salir y esos 16 resultados son contados las veces que estan o el número de frecuencias de cada uno.

La formula que se realiza es la siuiente:

en donde:
m = es el tamaño de la división de la secuencia en este caso 4
n = lóngitud o tamaño de la secuencia binaria
k = es la división de m entre n

Pasos:

1. Se divide la serie de número binarios en secciones de 4 numeros (0000).
2. Se buscan las frecuencias de los 16 diferentes numeros que se pueden encontrar
3. La frecuencia se eleva al cuadrado
4. Se realiza lo que es la ecuación anterior:

         x2=(16/k)(frecuencias al cuadrado)-k

La prueba se pasa cuando 1.03 < x < 57.4

	def poker(arch):
	n=len(arch) # Tam de la cadena binaria
	m=4 #longitud de los bloques
	numeros=list()#lista de separaciones de numeros de 4
	frecuencia=list() #lista para guardar las frecuencias
	y = n/m #cantidad de grupo de 4
	for i in range(y): # recorre la cantidad de grupos de 4
	numeros.append(arch[4*i:4+(4*i)]) #los agrega a la lista numeros
	for i in range(16): #realiza la lista de los 16 posibles numeros
	z=bin(i)[2:].zfill(4)
	frecuencia.append((numeros.count(z))**2) #cuenta las frecuencias de los numeros
	print frecuencia
	x = 0
	a= 16.0/y
	x = (a)*(sum(frecuencia)-y) #realiza la operacion
	print 'x---->', x
	if 1.03 < x < 57.4:
	print 'Poker Test: PASSED'
	else:
	print 'Poker Test: NOT PASSED'

view raw poker.py hosted with ❤ by GitHub

Captura de pantalla

Con otra cantidad de claves:

Monobit

Frecuencia de Bloques

Poker test

La clave pasa las pruebas eso quiere decir que es segura.

Referencias:

Link1
Link2
LInk3