Problema de laboratorio

P2.16.  Obténgase un grafo de flujo de señal para representar el siguiente conjunto de ecuaciones algebraicas donde yse consideran las variables dependientes y 6 y 11 son las

entradas:

Determínese el valor de cada variable dependiente usando la fórmula de la ganancia. Después, resuélvase para  mediante mediante la fórmula de ganancia del flujo de señal de Mason y verifíquese la solución usando la regla de Cramer.

Grafo de flujo de señal:

Ganancia del flujo de señal:

Regla de Cramer:

Reporte de Proyecto

Introducción

Para el reporte de la entrega final de proyecto explicaré denuevo de que trata mi proyecto, la idea del proyecto fue hacer una red neuronal que por medio de unos electrodos en el antebrazo de una persona determine los movimientos que quiere realizar en el brazo, esto se puede por medio de frecuencias que manda el cerebro hacia el brazo, y lo que se busca es interceptar esas frecuencias en el antebrazo para poder controlar un brazo robótico.

Al final se optó por usar un EEG debido a problemas con la Aduana al creer que los eléctrodos del sensor de músculo se podían tomar.

Donde podemos ver en la imagen de lado derecho separado por comas lo siguiente: "Intensidad de señal, atención, meditación, delta, theta, low alpha, high alpha, low beta, high beta, low gamma, high gamma".

Componentes

Los componentes que se usaron en el proyecto son los siguientes:

Arduino

EEG

Brazo robótico

MotorShield

¿ Cómo funciona?

Primero se toman las entradas del EEG para que luego sean preprocesadas, en el preprocesamiento se limpian los valores que nos importan donde mala intensidad de señal se ignora.

Al final obtenemos los valores que nos importan que son 10 entradas ignorando la intesidad de señal del EEG, estos valores irán dentro de una lista que entrarán a nuestra red neuronal la cual nos devolverá una salida binaria (1 ó 0) donde 1 hará que el brazo se mueva hacía la derecha y 0 que el brazo se mueva hacía la izquierda, esto ocurre gracias a que se establece una comunicación por medio del puerto serial y cuando se establece la comunicación este podrá recibir los valores antes mencionados, según los datos procesados.

Movimiento del brazo

El motor DC del brazo a controlar se mueve de 0 a 180 grados y de 180 a 0 grados osea derecha o izquierda. Para tomar el valor de la posición del brazo se utilizaron potenciómetros que fueron colocados a lado del motor DC para que nos digan por medio de ellos en que posición se encuentran.

Código del arduino:

	// Se usa para almacenar el valor tomado en el puerto serial
	char val;
	//Puerto analogico que obtendra la posicion del potenciometro
	int potPin = 1;
	//SALIDAS para motores DC E1,E2, M1 y M2
	int E1 = 10;
	int M1 = 12;
	int E2 = 11;
	int M2 = 13;
	//Se almacena el valor del potenciometro
	int potLectura = 0;
	void setup()
	{
	//Se configuran como salidas los puertos que dan corriente a los motores DC
	pinMode(M1, OUTPUT);
	pinMode(M2, OUTPUT);
	pinMode(E1, OUTPUT);
	pinMode(E2, OUTPUT);
	// Comenzar comunicacion serial en 115200bps
	Serial.begin(115200);
	}
	void loop() {
	//Almacena el valor del potenciometro del puerto A1
	potLectura = analogRead(potPin);
	//Imprime en el puerto serial el valor del potenciometro
	Serial.println(potLectura);
	//Almacena el valor que recibe en el puerto serial
	val = Serial.read();
	//Imprime el valor que recibe en el puerto serial
	Serial.println(val);
	// Si se recibe 1 hara un giro a la derecha
	if(val == '1'){
	//bandera que sirve para identificar
	Serial.println("entre der");
	//Se coloca un umbral para no mover el brazo mas de lo debido para no lastimarlo
	if(potLectura >= 600){
	//Motores van de 0 a 180 grados
	digitalWrite(M1,HIGH);
	digitalWrite(M2,HIGH);
	digitalWrite(E1, HIGH);
	digitalWrite(E2, HIGH);
	//Bandera para saber que entro
	Serial.println("Derecha");
	//Una espera de 2 segundos
	delay(2000);
	//Detiene motores
	digitalWrite(M1,LOW);
	digitalWrite(M2,LOW);
	digitalWrite(E1, LOW);
	digitalWrite(E2, LOW);
	//Bandera para saber que esta apagado
	Serial.println("Apagado");
	}
	}
	// Si se recibe 0 hara un giro a la izquierda
	if(val == '0'){
	//Bandera que sirve para identificar
	Serial.println("entre izq");
	//Se coloca un umbral para no mover el brazo mas de lo debido para no lastimarlo
	if(potLectura <= 1000){
	//Motores van de 180 a 0 grados
	digitalWrite(M1,LOW);
	digitalWrite(M2,LOW);
	digitalWrite(E1, HIGH);
	digitalWrite(E2, HIGH);
	//Imprime bandera
	Serial.println("Izquierda");
	//Una espera de 2 segundos
	delay(2000);
	//Detiene motores
	digitalWrite(M1,LOW);
	digitalWrite(M2,LOW);
	digitalWrite(E1, LOW);
	digitalWrite(E2, LOW);
	//Bandera para saber que esta apagado
	Serial.println("Apagado");
	}
	}
	//Espera medio segundo
	delay(500);
	}

view raw brazo_neuronal.ino hosted with ❤ by GitHub

Código del preprocesamiento:

	from sys import argv
	def preprocesamiento(archivo):
	file = open(archivo,'r')
	datos = list()
	a = list()
	fileLines = file.readlines()
	file.close()
	for i in fileLines:
	i = i.strip()
	a = i.split(',')
	datos.append(a)
	#print datos
	newFile = open('%s.prc' % archivo ,'w')
	bandera = True
	goodData = list()
	for d in datos:
	for n in xrange(len(datos[0])):
	#print d[n]
	if int(d[0]) >= 100:
	# print "Mori"
	bandera = False
	break
	bandera = True
	if bandera:
	goodData.append(d)
	data = ''
	for l in goodData:
	for n in xrange(len(datos[0])):
	if n == 0:
	continue
	data+= '%s ' %l[n]
	print >>newFile, data
	data = ''
	newFile.close()
	return
	def generatesEntries(archivo):
	file = open(archivo,'r')
	lista = list()
	fileLines = file.readlines()
	file.close()
	for i in fileLines:
	i = i.strip()
	lista = i
	print lista
	def main():
	archivo = argv[1]
	print "Preprocesando ..."
	preprocesamiento(archivo)
	print "Preprocesamiento listo ..."
	print "Generando entradas"
	generatesEntries('%s.prc'%archivo)
	print "Entradas generadas..."
	main()

view raw preprocesamiento.py hosted with ❤ by GitHub

Código de prueba de comunicación con arduino:

	import serial,time,csv
	ser = serial.Serial('/dev/tty.usbmodem12341',9600)
	while(True):
	for row in csv.reader(iter(ser.readline, None)):
	#print row[5],row[3]
	print row

view raw arduino_test.py hosted with ❤ by GitHub

Control de versiones

http://github.com/SaulG/redesNeuronales

Reporte de laboratorio 6

B.12.2. Sea el sistema definido por

donde

Transforme las ecuaciones del sistema en la forma canónica observable.

1. Se tiene el planteamiento del problema original (1.1) y (1.2).

2. Se crea la función de transferencia del sistema de control (2).

3. Se crea la forma normal controlable apartir de su función de transferencia (3.1) y (3.2).

4. Se hace la transpuesta de la forma normal controlable y cambio de variables de B a C 

y de C a B, esto se hace para obtener la forma normal observable (4.1) y (4.2).

5. Al final verificamos que haya sido la misma función de transferencia(5).

Código en Octave:

	% planteamiento de problema original
	A = [-1 0 1; 1 -2 0; 0 0 -3];
	B = [0; 1; 1];
	C = [1 1 1];
	% funcion de transferencia correspondiente
	[num, den] = ss2tf(A, B, C);
	% sistema de control representado por la funcion de transferencia
	% omitimos el punto y coma para que se vea en la pantalla
	sys = tf(num, den)
	% forma normal controlable
	[AC, BC, CC, DC] = tf2ss(num, den);
	% con transpuestas, se obtiene la observable
	AO = AC';
	% los vectores B y C intercambian papeles
	BO = CC';
	CO = BC';
	% el sistema descrito por AO, BO y CO es la respuesta del problema
	% para comprobar, obtenemos la funcion de transferencia para este sistema
	[numch, dench] = ss2tf(AO, BO, CO);
	% convertimos este tambien a un sistema para poder compararlos
	% omitimos el punto y coma para que se vea en la pantalla
	sys2 = tf(numch, dench)

view raw lab6.m hosted with ❤ by GitHub

El uso del código en octave y la verificación de que sean equivalente las funciones de tranferencia de cada forma usada:

	octave:1> lab6
	Transfer function 'sys' from input 'u1' to output ...
	2 s + 4
	y1: -------------
	s^2 + 4 s + 3
	Continuous-time model.
	Transfer function 'sys2' from input 'u1' to output ...
	2 s + 4
	y1: -------------
	s^2 + 4 s + 3
	Continuous-time model.
	octave:2>

view raw gistfile1.txt hosted with ❤ by GitHub

Fuentes de ayuda:
http://www.engr.mun.ca/~millan/6825/canonicals.pdf

Reporte grupal sobre propiedades estructurales

Introducción

El sistema que se pretende controlar es el mismo que se tiene como proyecto final de esta materia. Para ello daré una breve explicación, mi proyecto trata de mover una pelota a cierta altura en el aire dentro de un tubo donde este será movido por un ventilador con un motor DC, gracias a un sensor ultrasonico este sabría hacia que altura moverse, osea que tanta potencia le daríamos al motor DC para que la pelota se eleve. Para ello reciclaremos el juguete que vemos abajo, conectando el motor DC y el sensor ultrasonico a un arduino que por medio de este haremos el control.

Reporte
Esta es su representación en la forma normal controlable.
Código en Octave:

	J = 0.01;
	b = 0.1;
	K = 0.01;
	num = [K];
	den = [J b 0];
	%Funcion de transferencia
	sys = tf(num,den)
	%Funcion de transferencia a espacios de estados
	[a, b, c, d] = tf2ss(num, den)
	/*
	a = 0 0
	1 -10
	b = -1
	0
	c = 0 -1
	d = 0
	*/

view raw gistfile1.c hosted with ❤ by GitHub

Esta es su representación en la forma normal observable.
Código en Octave:

	j = 0.01;
	b = 0.1;
	k = 0.01;
	num = [k];
	den = [j b 0];
	[A,B,C,D] = tf2ss(num,den);
	ob = obsv(A,C)

view raw gistfile1.c hosted with ❤ by GitHub

Esta es su representación en la forma de Jordan.
Código en Octave:

	[a, b, c, d] = tf2ss(num, den);
	eig(a); % se buscan los eigenvalues de los estados de transicion de la matrix a
	roots(den); % busca los polos de la funcion de transferencia
	abs(roots(den)); % checa la estabilidad de los polos de la funcion de transferencia
	[E,L] = eig(a); % obtenemos los eigenvectors
	/*
	E =
	0.00000 0.99504
	1.00000 0.09950
	L =
	Diagonal Matrix
	-10 0
	0 0
	*/
	Ei = inv(E); % matriz inversa
	Ab = Ei * a *E % diagonalizacion
	/*
	Ab =
	-10 0
	0 0
	*/
	Bb = Ei * b;
	/*
	Bb =
	0.10000
	-1.00499
	*/
	Cb = c * E;
	/*
	Cb =
	-1.000000 -0.099504
	*/
	Db = d;
	%Db = 0

view raw gistfile1.c hosted with ❤ by GitHub

Código en Latex del documento:

	\documentclass[letterpaper,12pt]{article}
	\usepackage{pst-sigsys}
	\usepackage[utf8]{inputenc}
	\begin{document}
	\setlength{\parindent}{0pt}En esta ocasión se usara la función:
	\[ H(s) = \frac{k}{js^2 + bs} \]
	\setlength{\parindent}{0pt} Donde $k = 0.01$, $j = 0.01$, $b = 0.1$.\\
	La cual representa la función de transferencia de un motor de corriente directa. El cual se pretende usar para controlar el flujo de aire en un pequeño tunel de manera que se pueda sostener una esfera en cierta posición. \linebreak El respectivo diagrma de bloques es el siguiente:
	%Aqui va el diagrama de bloques
	\begin{center}
	\begin{pspicture}[showgrid=false](0.5,-2.5)(9, 1.55)
	\rput(1,0){\rnode{s}{$R(s)$}}
	\cput[doubleline=false, scale = .5](3.5, -1){$-$}
	\pscircleop(3, 0){ominus}
	\dotnode[dotstyle=square*,dotscale=0.001](9,0){dot1}
	\dotnode[dotstyle=square*,dotscale=0.001](2.7,0){dot2}
	\dotnode[dotstyle=square*,dotscale=0.001](2.5,0){dot3}
	\dotnode[dotstyle=square*,dotscale=0.001](3.5,-1.3){dot4}
	\dotnode[dotstyle=square*,dotscale=0.001](3.5,-.7){dot5}
	\dotnode[dotstyle=square*,dotscale=0.001](3.5,0){dot6}
	\psblock(5.5, 0){H1}{$\frac{k}{js^{2} + bs}$}
	\psblock(7, -2){H2}{$k$}
	\psblock(5, -2){H3}{$F(k)$}
	\rput(10,0){\rnode{e}{$C(s)$}}
	\psset{style=Arrow}
	\ncangle[angleA = 0, angleB= 180]{s}{ominus}
	\ncline[nodesepB=0]{H1}{e}
	\ncangle[angleA=90, angleB= -90]{dot5}{dot6}
	\ncangle[angleA=-90,angleB=0]{dot1}{H2}
	\ncangle[angleA=180,angleB=0]{H2}{H3}
	\ncangle[angleA=-180,angleB=-90]{H3}{dot4}
	\ncangle[angleA=0,angleB=180]{ominus}{H1}
	\end{pspicture}
	\end{center}
	\setlength{\parindent}{0pt} Esta función de transferencia puede ser representada de diversas maneras en el espacio de estados.
	\begin{itemize}
	\item Forma Canonica Controlable: Para obtener esta representación basta con definir el numerador y denominador de la función de transferencia y usarlo con la función \emph{tf2ss(numerador,denominador)}
	\begin{equation}
	\begin{array}{rcl}
	\left [
	\begin{array}{r}
	\dot{x}_1(t) \\
	\dot{x}_2(t)
	\end{array}
	\right ]
	&=&
	\left [
	\begin{array}{rr}
	0 & 0 \\
	1 & -10
	\end{array}
	\right ]
	\left [
	\begin{array}{r}
	x_{1}(t) \\
	x_{2}(t)
	\end{array}
	\right ]
	+
	\left [
	\begin{array}{r}
	-1 \\
	0
	\end{array}
	\right ]
	u(t) \\
	& \phantom{=} &
	\\
	y(t) &=& [
	\begin{array}{rr}
	0 & -1
	\end{array}
	]
	\left [
	\begin{array}{r}
	x_{1}(t) \\
	x_{2}(t)
	\end{array}
	\right ]
	\end{array}
	\end{equation}
	\item Forma Canonica Observable: Para la obtención de la forma canónica observable partiendo de la forma canónica controlable y usando los valores obtenidos en la \emph{función obsv(A,C)} \\
	$j = 0.01;$\\
	$b = 0.1;$\\
	$k = 0.01;$\\
	$num = [k];$
	$den = [j\, b\, 0];$\\
	$[A,B,C,D] = tf2ss(num,den);$\\
	$ob = obsv(A,C)$
	\item Forma Canonica de Jordan:
	\begin{equation}
	\begin{array}{rcl}
	\left [
	\begin{array}{r}
	\dot{x}_1(t) \\
	\dot{x}_2(t)
	\end{array}
	\right ]
	&=&
	\left [
	\begin{array}{rr}
	-10 & 0 \\
	0 & 0
	\end{array}
	\right ]
	\left [
	\begin{array}{r}
	x_{1}(t) \\
	x_{2}(t)
	\end{array}
	\right ]
	+
	\left [
	\begin{array}{r}
	0.1 \\
	-1.00499
	\end{array}
	\right ]
	u(t) \\
	& \phantom{=} &
	\\
	y(t) &=& [
	\begin{array}{rr}
	-1 & -0.099504
	\end{array}
	]
	\left [
	\begin{array}{r}
	x_{1}(t) \\
	x_{2}(t)
	\end{array}
	\right ]
	\end{array}
	\end{equation}
	\end{itemize}
	\end{document}

view raw gistfile1.tex hosted with ❤ by GitHub

Personas del equipo:

Saúl Gausin
Raúl Gonzalez
Isaías Garza

Problema 14.1 y 14.1.1

14.1 If a professor forgets coins or drink at the machine, there inmediately will be a student who will come to the machine.

Where P equivale a maestro, fcoin equivale si el maestro olvida monedas y fdrink si el maestro olvida bebida y SC equivale a que el estudiante vendrá.

14.1.1 If the beer storage becomes empty, it gets rechanged inmediately.

Donde BE equivale a almacenamiento vacío de cerveza y R es rechanged.

Problema de laboratorio

B.5.20. Obtenga la respuesta a una rampa unitaria del sistema definido por

donde u es una entrada rampa unitaria. Utilice el comando lsim para obtener la respuesta.

Código:

	//Se crea la matriz
	A = [0 1;-1 -1];
	B = [0;1];
	C = [1 0];
	D = [0];
	//Se crea el sistema
	sys = ss(A,B,C,D);
	//Se colocan los rangos en el eje x y y
	x = [0:0.05:1];
	y = [0:0.05:1];
	//Se dibujan en la grafica
	plot(x, y);
	//La cual damos como parametros el sistema y los rangos donde obtendremos la respuesta a una
	//entrada exponencial
	[xo, yo, to] = lsim(sys, x, y);

view raw unitario.c hosted with ❤ by GitHub

Gráfica: