Licenciatura en Ciencias de la Computación.Facultad de Ciencias, UNAM.

Diseño de Sistemas Digitales.

Proyecto final.

Monorraíl de levitación magnética automático, operado mediante máquinas electrónicas digitales.

Propuesta, desarrollo e implementación de sistema porCastillo López Manuel Ignacio

308017438

Profesor:Jaime Fabian Vázquez de la Rosa.

Ayudante de profesor:Rodrigo Alfonso Martín Salas.

1

Contenido

Introducción. Monorrieles, trenes de levitación magnética y microcontroladores..............................................................................................3Objetivo....................................................................................................4Diseño.......................................................................................................4

Entradas del sistema..............................................................................5Máquina de estados para controlar entrada de datos.......................................6Diagrama de estados..............................................................................7Módulo de control de luces......................................................................8Diagrama electrónico del control de luces...................................................10Diagrama electrónico de la máquina de estados de control de datos de entrada............................................................................................14Módulo de control de electroimanes..........................................................14Diagrama electrónico del módulo de control de electroimanes..........................18Diagrama de conexión del sistema lógico con cada electroimán.........................20Consideraciones finales pre implementación................................................20Diagrama electrónico del circuito a implementar...........................................21

Conclusiones..............................................................................................22Anexo. Código fuente C del programa para el PIC 16F887 a utilizar.............................23

2

Introducción. Monorrieles, trenes de levitación magnética y micro controladores.

Un monorraíl o monorriel, es un medio de transporte terrestre que se caracteriza por el hecho de desplazarse sobre una estructura de un sólo riel. Usualmente aparecen como un sistema de trenes eléctricos elevados.

La idea de éste tipo de transporte se gestó a finales del siglo XIX en Rusia y Reino Unido. Sin embargo; la tecnología de la época no permitía una fácil (relativamente) o eficiente implementación del medio de transporte, por lo que no tuvo grandes avances si no hasta la segunda mitad del siglo XX.

El concepto contemporáneo del monorraíl, es el de un convoy que se mueve sobre una viga con el uso de ruedas neumáticas de apoyo a los costados; con el uso de extensiones en la base por los costados y de circulación por debajo de él. Su diseño le proporciona una enorme ventaja sobre otro tipo de transportes terrestres, pues puede viajar a muy altas velocidades sin correr peligro de descarrilar y con un coste energético reducido en comparación a los trenes eléctricos tradicionales.

Los trenes de levitación magnética, son una variante del monorraíl tradicional (en algunos diseños); excepto por que carecen de ruedas y mientras están en operación carecen de contacto físico de con todo excepto con la atmósfera y en algunos diseños, con una vía de alimentación. En lugar de tener las ruedas de circulación y de apoyo, tienen electroimanes que lo mantienen levitando alrededor del riel. Debido a la carencia de fricción, pueden desarrollar velocidades muy altas con un costo energético relativamente bajo y además; por su naturaleza “levitante”, son el medio de transporte más silencioso de todos.

La velocidad promedio de un maglev (contracción en inglés de magnetic levitation train ó tren de levitación magnética) es de aproximadamente 500 km/h; por encima de la velocidad del sonido. Se calcula que al vacío podrían operar a aproximadamente 1,000 km/h. Uno de éstos podría llevar pasaje de Guadalajara a Ciudad de México en apenas una hora y media; aproximadamente, y sin esperar por el retraso de la salida y/o llegada de un avión. Dada su velocidad, es competencia directa del transporte aéreo.

Uno de los principales motivos por los que no se han implementado ya éstos medios de transporte, es por el elevado costo de producción; además de que no hay un estándar en la tecnología para su operación. Cabe mencionar que aunque el costo de construcción sea mucho muy elevado, a la larga proporcionarían un ahorro superior.

En éste proyecto, presento una muy simple propuesta de implementación de un monorraíl electromagnético; el cual será controlado por una computadora diseñada para ese propósito. Se busca reducir la implementación para obtener la más simple posible; y en parte es por ello que, todas las funciones lógicas que debe realizar dicha computadora, se programarán en un PIC.

Un PIC es un microcontrolador. Un microcontrolador; ó MCU (Micro Controller Unit), es un circuito integrado programable. Principalmente se compone por: una unidad aritmético

3

lógica, un oscilador, memoria tipo ROM, memoria tipo RAM y puertos de entrada y salida. PIC es como se reduce el nombre de PICmicro: Periphal Interface Controller micro.

Los MCU surgen como una herramienta que facilita la implementación de computadores; o más específicamente, máquinas electrónicas digitales de uso específico; como puede ser: una batidora, el control de frenos ABS de un automóvil o incluso componentes internos de un celular, consola de videojuegos o de una computadora de uso general o alguno de sus periféricos.

Una de las principales diferencias entre los PIC y los MCU tradicionales; es que, la arquitectura de los PIC es tipo Harvard, por lo que el tamaño de las instrucciones grabadas en la ROM (que en la mayoría de modelos son de 8 bits) puede ser distinta a las palabras de datos almacenadas en la RAM.

Objetivo.

Diseñar y construir un modelo de monorraíl de levitación magnética, funcional y sin capacidad de carga; el cual debe ser operado mediante máquinas electrónicas digitales. La máquina de control principal realiza directamente el cambio de polaridades de los electroimanes en las vías pertinentes para mantener el monorraíl suspendido en el aire y en movimiento cuando sea solicitado por un usuario; en una dirección deseada.

El modelo cuenta con luces operables: interiores y exteriores. Es posible manipular las luces del monorraíl y la estación e iniciar o detener; exclusivamente, la levitación magnética, poner en movimiento el monorraíl en una dirección específica: adelante o atrás. No debe permitir poner el monorraíl en movimiento si primero no se ha puesto en levitación o iniciar reversa cuando es inerte a otro movimiento; debe corregir las entradas del usuario para asegurar una operación correcta.

Diseño.

El concepto para operar las luces se resuelve instalando un trole que le proporciona energía y comunicación al tren. Dicho trole contaría con cuatro cables: uno de alimentación, otros dos que envían señales para operar las luces y uno último de tierra. Una de las cabinas del tren se marcaría como principal; de manera que sea posible identificar cuando va “hacia adelante”; i.e. En dirección de la cabina principal; o la contraria, “reversa”.

Describimos el modo de mover el tren de la siguiente manera: Cuando el tren está detenido, todos los imanes bajo él tienen la misma polaridad que

los imanes abordo del tren y los que están inmediatamente delante y detrás del mismo tienen la polaridad opuesta; de manera que el tren es atraído por ambos y no se mueve de su lugar. Todos los demás imanes tienen la misma polaridad que la del tren.

Cuando se desea mover el tren en una dirección dada, el imán inmediatamente al extremo del tren en sentido opuesto al deseado de circulación, cambia de polaridad; igualándose a la que tiene el tren. De ésta manera el tren se atrae por el único imán

4

inmediato con polaridad opuesta. En apenas unos instantes, el imán que atrae al tren invierte su polaridad y el primero que sigue al que acaba de cambiar de polaridad, se debió convertir en el primer imán inmediato al otro extremo y con polaridad inversa. Dependiendo de si el tren se seguirá moviendo puede ocurrir que el nuevo imán inmediato al extremo opuesto:◦ Invierta su polaridad, para detener al tren en su nueva posición.◦ Mantenga la misma polaridad; que es igual a la del tren y continuar el

movimiento.No se permite pasar de un movimiento a un estado de reversa inmediato. Debe primero pasar por un estado de alto.

Note que el diseño del sistema de movimiento implica considerar la pista como una serie de elementos discretos que operan de la forma anterior para mover el tren por todos ellos.

Entradas del sistema

De acuerdo a la solución propuesta, se requieren de dos circuitos básicos: uno a bordo del tren para controlar las luces, y otro en la estación; que reciben datos del usuario para realizar todo cambio solicitado: levitar, aterrizar, moverse, encender luces; comunicándose con el tren para realizar cambios de luces en él y con los electroimanes en el riel para mover el tren.

Para una simple operación del monorraíl y sólo tener que diseñar y construir un sistema sencillo, se opta por codificar unívocamente cada electroimán en las pista. Si consideramos una pista con 15 imanes, se requieren 4 bits para codificar. Sin embargo; más adelante se hará notar que la codificación real de los imanes debe ser la siguiente:

5

Número del imán Código BCD (-1) Código binario del imán

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

2 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0

3 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0

4 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0

5 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0

6 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0

7 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0

8 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0

9 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0

10 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0

11 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0

12 1 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0

13 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

14 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0

15 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

La cual se da con un DEC 4:16; por lo que se puede pensar que los primeros números BCD del 0 al 14 son el código del imán (4 bits).

Representamos ciertos eventos necesarios con variables. Comencemos por las entradas para solicitar movimiento.

VariableCodifica

M V0 0 “No levita”.0 1 “Detenido pero levitando”.1 0 “Avanza al frente”.1 1 “Avanza en reversa”.

El control de las luces.

L Representa0 Apagadas1 Encendidas

Máquina de estados para el control de entrada de datos.

Continuamos con el desarrollo del sistema. Sugerimos una máquina de estados para el control del tren. Dicha máquina de estados; debe contar con cuatro estados, 2 variables de

6

entrada y 2 de salida.

Estados Codificado pore0: Modo de espera (No levita) 0 0

e1: Sólo levita. 0 1e2: Se mueve hacia adelante. 1 0

e3: Se mueve hacia atrás 1 1

Las entradas corresponden a M y V y las salidas son las siguientes:

Variable RepresentaS E0 0 Detenido0 1 Adelante1 0 Atrás1 1 No definido

La tabla de estados es la siguiente:

Estado inicial Estado siguienteSalidas

M V M V M V M V

0 0 0 1 1 0 1 1 S Ee0 e0 e0 e0 e0 e1 e1 e1 0 0 0 0 0 0 0 0e1 e1 e1 e1 e0 e1 e2 e3 0 0 0 1 0 0 1 0e2 e2 e2 e2 e1 e1 e2 e1 0 0 0 0 0 0 1 0e3 e3 e3 e3 e1 e1 e1 e3 0 0 0 1 0 0 0 0

Y se obtiene el siguiente diagrama de estados:

7

e0

00MV

0 0

e1

00

X X

0 0

0 1

e2

01

e3

10

1 0

1 1

1 0

1 1

X X

X X

Las salidas se usan para saber como deben comportarse los imanes. Como ya se mencionó anteriormente; los imanes están codificados unívocamente y el tren se mueve “continuamente” por todos ellos. Entonces, de acuerdo a las variables de salida; se da la señal a exactamente el imán que sigue o antecede. Para ello se hace una suma.

Módulo de control de luces.

Antes de continuar con el desarrollo de las salidas que se emplean al final para los imanes; demos el modelo de las luces. Necesitamos definir dos variables para codificar las salidas deseadas:

G H Representa0 0 Luces apagadas.0 1 Luces encendidas y el tren está detenido.1 0 Luces encendidas y el tren avanza hacia adelante.1 1 Luces encendidas y el tren avanza hacia atrás.

Usamos las salidas de la máquina y la señal de la luz para dar la siguiente función:

L S E G H

0 0 0 0 0

0 0 1 0 0

0 1 0 0 0

0 1 1 0 0

1 0 0 0 1

1 0 1 1 0

1 1 0 1 1

1 1 1 0 1

Desarrollamos por álgebra de Red-Müller para obtener G y H:

\ LS 0 0 0 1 11 10

E \

0 1 S SL L

1 E SE SLE LE

8

Buscamos la polaridad de menor costo.

0 1 3 2 6 7 5 4P000 P001 P011 P010 P110 P111 P101 P1000 0 0 0 1 0 1 00 0 0 0 1 1 1 10 0 0 0 1 1 1 10 0 0 0 0 0 0 00 1 0 1 1 0 1 01 1 1 1 1 1 1 11 1 1 1 1 1 1 10 0 0 0 0 0 0 0

G001: L+LE'+SL = L+L(1+E)+SL = L+L+EL+SL = G000G010: L+LE+S'L = L+LE+(1+S)L = L+LE+L+SL = G000G011: L'E'+S'L = L(1+E)+(1+S)L = L+LE+L+LS = G000G100: E+S+L'E+SL' = E+S+(1+L)E+S(1+L) = E+S+E+LE+S+SL = G000G101: 1+E'+S+L'+L'E+SL' = 1+1+E+S+1+L+(1+L)(1+E)+S(1+L) = E+S+1+L+1+E+L+LE+S+SL = G000G110: 1+E+S'+L'+L'E+S'E = 1+E+1+S+1+L+(1+L)E+(1+S)(1+E) = E+S+1+L+E+LE+1+E+S+SE = E+L+LE+SEG111: E'+S'+L'E'+S'L' = 1+E+1+S+(1+L)(1+E)+(1+S)(1+L) = E+S+1+E+L+LE+1+L+S+SL = G000

0 1 3 2 6 7 5 4P000 P001 P011 P010 P110 P111 P101 P1000 0 0 0 1 1 0 10 0 0 0 0 0 1 10 0 0 0 0 1 1 00 0 0 0 1 1 1 11 0 1 1 1 1 0 11 1 0 0 0 0 1 10 1 1 0 0 1 1 01 1 1 1 1 1 1 1

H001: LE'+SL+SLE' = L(1+E)+SL+SL(1+E) = L+LE+SL+SL+SLE = H000H010: L+LS'E = L+L(1+S)E = L+LE+LSE = H000H011: L+S'L+S'LE' = L+(1+S)L+(1+S)L(1+E) = L+L+LS+(L+SL)(1+E) = LS+L+LE+SL+SLE = H000H100: 1+E+SE+L'+L'E+SL'E = 1+E+SE+1+L+(L+1)E+S(1+L)E = E+SE+L+LE+1+(S+SL)E = E+SE+L+LE+1+SE+SLE = E+L+LE+1+SLEH101: E'+S+SE'+L'E'+SL'+SL'E' = 1+E+S+S(1+E)+(1+L)(1+E)+S(1+L)+S(1+L)(1+E) = 1+E+S+S+SE+E+1+L+LE+S+SL+(S+SL)(1+E) = SE+L+LE+S+SL+S+SE+SL+SLE = H000H110: 1+S'E+L'+S'L'E = 1+(1+S)E+1+L+(1+S)(1+L)E = E+SE+L+(1+L+S+SL)E = E+SE+LE+E+SE+SLE = H000H111: 1+S'+S'E'+L'+S'L'+S'L'E' = 1+1+S+(1+S)(1+E)+1+L+(1+S)(1+L)+(1+S)(1+L)(1+E) = S+1+E+S+SE+1+L+1+L+S+SL+(1+L+S+SL)(1+E) = E+SE+1+S+SL+1+E+L+LE+S+SE+SL+SLE = H000

Tomamos:

9

G = LE+SL H = L+LE+SLE

Note que todas las sumas anteriores son bajo el modelo de Red-Müller; por lo que son X-OR.

El siguiente diagrama nos muestra la implementación de las funciones anteriores:

Las funciones del control de luces se implementan a bordo del tren; recibiendo datos del trole. Observemos una tabla de verdad donde se aprecie la relación entre G, H y la salida final de las luces. Sea I la función que rige las luces interiores, EAP la de las luces exteriores frontales de la cabina principal, ERP las luces exteriores de reversa de la cabina principal, EAR las luces exteriores frontales de la otra cabina, y ERR las luces exteriores de reversa de la otra cabina:

G H I EAP ERP EAR ERR

0 0 0 0 0 0 0

0 1 1 1 0 1 0

1 0 1 1 0 0 1

1 1 1 0 1 1 0Claramente:

10

I = G+H EAP = G XOR H ERP = GH EAR = H ERR = (G H)' = (G'+H)' = GH'→

El siguiente diagrama nos da la implementación de éstas funciones. Al final, quedarán en una ALU abordo del tren:

Volviendo a la máquina de estados, vamos a implementarla con flips – flops J K. Sabemos que Q* = JQ' + K'Q. Tenemos la siguiente tabla de excitación:

11

mi Edo. Actual Entradas Edo. Sig. Entradas flips – flops Salidas

# Q0 Q1 M V Q0* Q1* J0 K0 J1 K1 S E

0 0 0 0 0 0 0 0 XX 0 X 0 0

1 0 0 0 1 0 1 0 X 1 X 0 0

2 0 0 1 0 0 1 0 X 1 X 0 0

3 0 0 1 1 0 1 0 X 1 X 0 0

4 0 1 0 0 0 0 0 X X 1 0 0

5 0 1 0 1 0 1 0 X X 0 0 0

6 0 1 1 0 1 0 1 X X 1 0 0

7 0 1 1 1 1 1 1 X X 0 0 0

8 1 0 0 0 0 1 X 1 1 X 0 1

9 1 0 0 1 0 1 X 1 1 X 0 1

10 1 0 1 0 1 0 X 0 0 X 0 1

11 1 0 1 1 0 1 X 1 1 X 0 1

12 1 1 0 0 0 1 X 1 X 0 1 0

13 1 1 0 1 0 1 X 1 X 0 1 0

14 1 1 1 0 0 1 X 1 X 0 1 0

15 1 1 1 1 1 1 X 0 X 0 1 0

Obtenemos las entradas por mapas de Karnaugh.

\ Q0Q1 0 0 0 1 1 1 1 0

M V \

0 0 0 0 X X

0 1 0 0 X X

1 1 0 J0 X X

1 0 0 J0 X X

J0 = Q0'Q1M

12

\ Q0Q1 0 0 0 1 1 1 1 0

M V \

0 0 X X K0 K0

0 1 X X K0 K0

1 1 X X 0 K0

1 0 X X K0 0

K0 = M'+Q0Q1'V+Q1MV'

\ Q0 Q1 0 0 0 1 1 1 1 0

M V \

0 0 0 X X J1

0 1 J1 X X J1

1 1 J1 X X J1

1 0 J1 X X 0

J1 = V+Q0'M+Q0M' = V+ Q0 XOR M

\ Q0 Q1 0 0 0 1 1 1 1 0

M V \

0 0 X K1 0 X

0 1 X 0 0 X

1 1 X 0 0 X

1 0 X K1 0 X

K1 = Q0'M'V'+Q0'MV' = Q'V'(M'+M) = Q0'V'

\ Q0 Q1 0 0 0 1 1 1 1 0

M V \

0 0 0 0 S E

0 1 0 0 S E

1 1 0 0 S E

1 0 0 0 S E

S = Q0Q1 E = Q0Q1'

13

Con toda la información anterior, damos el diagrama del circuito electrónico que implementa:

Módulo de control de electroimanes.

La maquina a implementar es una máquina tipo Moore. Las salidas de la máquina se toman como una de las entradas de dos Sumadores Completos de 4 bits. La otra entrada de 4 bits de los sumadores viene de una memoria RAM que inicialmente contiene 0000. Dicha RAM tiene como función recordar el identificador del último imán sobre el que estuvo el monorraíl; siendo éste el que se ubica al extremo de la cabina principal.

Una de las entradas al primer FA, es la cadena de bits " P'P'P'P "; y un acarreo de entrada CEA y de la otra es la cadena "QQ00" y un acarreo de entrada CEB. Más adelante veremos quienes son las nuevas variables P, Q, CEA y CEB.

Estas entradas debido a que; sólo uno de los sumadores va a sumar algo mientras el otro suma 0 (más el acarreo) a lo que hay en la RAM. Cuando el tren avanza hacia adelante, uno suma 1 de manera que se puede obtener el identificador del siguiente imán y hacer que ese sea el nuevo único con un campo magnético diferente; atrayendo el tren. Ese es el número que se almacena en la RAM, el resultado del otro sumador es ignorado (el que haya sumado 0).

O bien por otro lado, cuando retrocede; resta 3. 3 es el número de imanes bajo el

14

monorraíl (contando el que sabemos sobre el cual está la cabina principal; i.e. El que tiene un identificador igual al dato almacenado en la RAM) y se le resta uno más para el anterior a la segunda cabina, para obtener el identificador del imán al otro extremo del tren; pero dado que el diseño sólo contempla 15 imanes, puede haber un pequeño inconveniente a restar desde el identificador 0010 al 0000; observemos la siguiente tabla de verdad; donde sean Ei la entrada al FA no constante (la que viene de la RAM) y Si la salida esperada del FA:

Imán mi E0 E1 E2 E3 S0 S1 S2 S3 CEB

1 0 0 0 0 0 1 1 0 0 0

2 1 0 0 0 1 1 1 0 1 0

3 2 0 0 1 0 1 1 1 0 0

4 3 0 0 1 1 0 0 0 0 1

5 4 0 1 0 0 0 0 0 1 1

6 5 0 1 0 1 0 0 1 0 1

7 6 0 1 1 0 0 0 1 1 1

8 7 0 1 1 1 0 1 0 0 1

9 8 1 0 0 0 0 1 0 1 1

10 9 1 0 0 1 0 1 1 0 1

11 10 1 0 1 0 0 1 1 1 1

12 11 1 0 1 1 1 0 0 0 1

13 12 1 1 0 0 1 0 0 1 1

14 13 1 1 0 1 1 0 1 0 1

15 14 1 1 1 0 1 0 1 1 1

ND 15 1 1 1 1 X X X X X

ND ::= No definido.

Observemos que E0E1E2E3 + QQ00 + CEB = S0S1S2S3 (suma aritmética); lo cual es bastante conveniente; pues el problema se resuelve con el mismo FA, sólo controlando a CEB. De la tabla de verdad, se observa que:

CEB = E1+E0+E2E3.

Además, cuando el tren retrocede, el imán que queda debajo de la cabina principal es el anterior al que tiene la RAM. Para ello, el primer FA, debe restar 1 a lo que hay en la RAM. De aquí se observa que las entradas de la RAM son las salidas del FA con otra entrada P'P'P'P y acarreo CEA. Por la observación anterior, CEA = (E0+E1+E3)P', pues debe ser 0 siempre que el tren avanza hacia adelante (P) y cuando retrocede (P') y se tiene el identificador de imán 0000 (pues el anterior es 1110 y no 1111 como se observa en la tabla).

15

Hace falta notara quienes son P y Q. S = P, la salida S de la máquina de estados. Pues así cuando avanza hacia el frente (S = 1), el FA correspondiente suma 0001 +CEA = 1. Y cuando retrocede (S = 0), suma 1110 +CEA; lo que resulta en el identificador del imán actual menos 1 y se obtiene el nuevo imán en todo caso que está bajo la cabina principal. Sin embargo, Q tiene un valor un poco más especial como veremos más adelante; además de que no hemos contemplado la salida S = E = 0 de la máquina de estados, que indica que el tren está detenido, y los dos imanes a los extremos tienen las polaridades opuestas. Esto va a resultar en que P sea igual a S OR algo más.

Las dos palabras de 4 bits resultantes de ambos FA, se llevan bit a bit a 4 multiplexores 2:1 (además de que la salida del primero a la RAM), donde la primer entrada es el i-ésimo bit de salida del FA que suma P y la segunda el i-ésimo bit de salida del FA que suma Q y el bit de selección es Q. Con ello se obtiene una sola palabra de 4 bit que corresponde a la de salida del FA que sumo algo.

Esta salida se usa en 15 funciones distintas que corresponden a los primeros 15 de los 16 minitérminos mi mostrados en la tabla de verdad que involucra a E0E1E2E3 y S0S1S2S3. Así conocemos el último imán sobre el cual se encuentra la cabina principal. El mintérmino que valga 1, indica al imán identificado por mi +1 que debe invertir su polaridad. Para esto se ocupará un circuito de cambio de giro de motor eléctrico, sólo que conectando un electroimán en lugar de un motor.

Ahora, cuando el tren está detenido; ambos FA deben sumar algo y dos imanes simultáneamente han cambiado su polaridad. Para indicar dicha señal, entonces el segundo FA debe hacer su suma correspondiente. Entonces, necesitamos que Q; su entrada, cambie de acuerdo a ésta situación considerando los casos donde debe hacerse una corrección. (0, 1 y 2).

Notemos por comenzar que como CEB sólo depende de la salida de la RAM, la palabra E0E1E2E3, no hay cambios en CEB. Sin embargo, Q = E+E'S'; pues queremos un resultado cuando E = S = 0 y del análisis anterior, se tiene que para que cumpla la función de devolver un identificador de un imán cuando el tren va “de revesa”, Q = 1 cuando E = 1. Luego, también queremos que produzca una salida cuando E = S = 0 (el tren está detenido).

Por otro lado, queremos que el primer FA sume algo. Pero como el tren está detenido, su salida no pasará en éste caso a la RAM, pues la posición del tren es la misma siempre que E = S = 0. De aquí se observa que podemos ocupar 4 MUX 2:1 para la entrada de la RAM, de manera que podemos elegir entre cada bit de las palabras de 4; de entre lo que tenía originalmente la RAM y la salida del FA, usando a S+E como bit de selección y así cuando el tren esta en movimiento (ó S ó E valen 1), entra a la memoria lo que resulta del FA y cuando está detenido (S = E = 0), entra a la memoria lo que ya existía en ella misma.

Y se observa que, P = S +E'S'; pues así suma 1 cuando está detenido. Notemos que CEA recibe un ligero cambio; pues originalmente: CEA = (E0+E1+E3)P' y como P va a valer 1, pero queremos sumar sólo 1, queremos que CEA = 0. Por ello y sabiendo que para lo anterior se consideraba P = S; entonces CEA = (E0 +E1 +E3)S'.

16

Ya tenemos las entradas de los FA y de la RAM propiamente diseñados. Ahora sólo queda afrontar el problema de que nuevamente, cuando el tren está detenido; se debe enviar una señal a dos electroimanes y hasta ahora, sólo se puede enviar una señal a uno de ellos. Y como está diseñado; con los MUX, cuando el tren está detenido se obtiene la salida del primer FA, pues E = 0. Necesitamos obtener la salida del segundo FA cuando S = E = 0.

Para ello, se va a requerir de otras 15 funciones; equivalentes a las 15 mencionadas, donde cada una equivale a alguna de los 16 mintérminos de la tabla de verdad donde aparece E0E1E2E3 y S0S1S2S3. La entrada de todas éstas funciones es directamente la salida del FA que tiene a Q como entrada. Sin embargo, esto puede generar más problemas. Pues si E es distinto de S, distinto de 0; entonces el FA está generando un resultado y al ir a las funciones de los minitérminos, pueden generar que se excite un imán que no debe excitarse, y puede ocurrir que dichos imanes excitados causen problemas en el desplazamiento del tren.

Para evitar esto, podemos sacar provecho de que un imán con identificador 1111; no existe en el diseño. Entonces podemos manipular la salida del FA; de manera que antes de entrar a cualquiera de las funciones, si E y S no son 0, valgan todas 1 y ninguno de los mintérminos entonces va a disparar 1 como resultado.

Esto lo podemos solucionar simplemente creando una nueva variable C = S +E, las salidas de la máquina de estados. Así, para cada salida del FA que opera con Q, se hace Si1 = Si +C; con Si una de las 4 salidas del FA, y se lleva cada Si1 como entrada de las 15 funciones. Notemos que si S es distinto de 0 y también E es distinto de 0 entonces C = 1 y Si1 = 1; por lo que ningún mintérmino responde y se obtiene la salida deseada. Y si S = E = 0 entonces C = 0 y Si1 = Si.

Al final, sólo queda la necesidad de llevar los identificadores obtenidos a una compuerta OR. Note que debe haber un OR por cada compuerta, pues nos sirve para tener en una sola línea de comunicación ambos identificadores. Así se excita el o los imanes pertinentes.

Tenemos los siguientes diagramas. Uno para P, Q y C:

17

Otro para el circuito de FA; con las entradas a las funciones de los mintérminos:

Y uno último para indicar las funciones de los minitérminos:

18

Recordemos que el código de los imanes lo tomamos como la salida del multiplexor; aunque podemos interpretarlo como los primeros 15 números BCD que son entradas de los Decodificadores. La señales Imi con valor 1, indican a su imán correspondiente que debe cambiar de polaridad. Esto se logra con relés; utilizando un circuito de cambio de giro de motor, pero ocupando un electroimán en lugar de un motor eléctrico.

En el siguiente diagrama podemos observar el circuito de cada imán en la pista:

19

Notemos que junto al control de cada imán, en el diagrama se ha indicado también el circuito maestro de control de levitación. Para que el tren aterrice se apagan los imanes de la pista; y conforme al diseño, esto sucede si S = E = 0.

Ahora; para satisfacer las necesidades del proyecto y obtener la implementación más simple posible; excepto por los circuitos de cambio de luces, todos los circuitos y operaciones lógicas, se hace con el uso de un PIC16F887 que tendrá escrito en su ROM un programa que es equivalente a tener todos los circuitos anteriores: tiene como datos de entrada M, V y L y devuelve 15 identificadores de imanes en la pista; además de 2 bits para la señal de las luces y la señal maestra de encendido de imanes.

El PIC tiene 4 puertos de 1 byte y otro de 5 bits; cada uno de entrada y salida configurable. Conforme a lo anterior, notamos que basta con ocupar 3 bits de los 8 de uno de los puertos como bits de entrada y podemos ocupar los 5 restantes de ese puerto como bits de salida, otro puerto completo de salida y cinco más de otro para tener 18 bits de salida. Conforme al data sheet del PIC, se usarán los puertos B, C y D; donde los tres primeros pines del puerto B se configurarán como pines de entrada para M, V y L y los otros 5 como salida. Se usan los 8 pines del puerto C como salida, para acumular 13 bits de salida y se usan los primeros cinco pines del puerto D como salida para finalmente tener los 18 bits de salida necesarios.

Al final de este reporte, encontrará un código fuente en lenguaje C (mikroC); el cual es el

20

programa para el PIC que sentencia todas las operaciones mencionadas anteriormente.

El siguiente diagrama muestra el circuito a implementar:

21

Note que la fuente de alimentación de éste circuito y la de los imanes no son necesariamente la misma. Además, el trole es una extensión por la pista de los pines RB3 y RB4 por la pista.

Sólo falta mencionar de donde se van a obtener los valores de M, V y L ingresados por el usuario y que son los que indican como debe comportarse el tren. Primero hagamos la observación de que puede parecer innecesario usarlos como variables de entrada de una máquina de estados que devuelve prácticamente lo mismo. Sin embargo, si permitimos que el usuario manipule directamente las entradas de los FA que nos dan los identificadores de los imanes próximos al monorraíl, puede provocar un comportamiento errático.

Si el tren se estuviera moviendo hacia delante y en una operación el usuario solicita realizar movimiento en reversa; no es seguro que el monorraíl siga el campo de reversa. Los datos que maneja la máquina son discretos, pero la mayoría de los fenómenos “del mundo real” (lo que sea que eso sea) son continuos. La aceleración y velocidad no son la excepción.

Para que un objeto en movimiento pase de moverse en una dirección a la opuesta; debe pasar por todas las velocidades entre la que lleva, el 0 y nuevamente incrementar su velocidad hasta moverse en la dirección deseada. Claro que puede realizarse en un tiempo mínimo, pero eso suele implicar el aplicar una fuerza que produce fricción. Y nuestro monorraíl; por su naturaleza de tren de levitación magnética, carece de fricción a excepción de con la atmósfera o con el riel cuando está apagado. Note que los campos electromagnéticos también son continuos.

Entonces, la máquina de estados y las entradas del usuario M y V son útiles para controlar dichas situaciones y evitar errores en el sistema. Así si el usuario está solicitando que el monorraíl corra en una dirección y en una operación solicita que se mueva en la dirección opuesta, el sistema se encarga de primero detener el monorraíl y después reanudar el movimiento. De manera que lo que hace la máquina de estados es en pocas palabras, modelar el movimiento, que es continuo; con datos digitales, que son discretos. Note que por lo anterior es importante utilizar esperas (retrasos) en las operaciones de la máquina, para que funcione a una velocidad que permita hacer eficiente dicho modelo.

Conclusiones.

Aunque la construcción de un modelo funcional que opere bajo las condiciones anteriores queda fuera del alcance y propósito de la asignatura, el diseño del monorraíl muestra una simple propuesta para la construcción de un tren de levitación magnética simple. Pues en éste diseño se tienen las siguientes ventajas:

Es fácil de modificar. Contando con la tecnología de la que se dispone, es fácil alterar el programa de control y hacer que opere con n imánes. Así como si se agregara cambios de vías, bastaría con conocer los códigos unívocos de todos los imanes y saber que cuanto un cambio de vías está activo, el ID del siguiente imán no es el que sigue sumando 1, si no alguno otro cuyo código se conoce al saltar de un imán previo al cambio. Si se ponen más trenes en el mismo riel, puede haber tantas instancias del programa coordinados que operen cada una a uno de los trenes y

22

puede aumentarse un sistema de control maestro que vigilara el comportamiento de todos los trenes y evitar choques y otro tipo de anomalías o dificultades que pudiera representar la instalación de varios trenes en un mismo carríl.

De lo anterior, cabe mencionar que bajo un lenguaje de programación de alto nivel; hacer culalquier cambio al programa resulta muy sencillo de mantener, pues si se manejara con un paradigma de orientación a objetos; por decir algo, podrían modelarse segmentos de vía como objetos y saber cuando uno va despues de otro y donde se presentan los cambios de vía. Además, ésto podría ofrecer la facilidad de guardar los datos hechos en ejecución y hacer persistente los cambios, de manera que no sea necesario reprogramar cada vez que ocurran cambios en el sistema (aunque se esperaría que practicamente no ocurran).

La velocidad del tren sólo depende de la velocidad de reloj de la computadora que lo opera y/o de los retrasos en las operaciones que ejecuta. Pueden aumentarse las variables de entrada para indicar distintas velocidades a las que el ususario desea a las que se mueva el monoraíl y adaptando la máquina de estados de control de entradas, se puede soliciar que tan rápido se va a mover el tren en una dirección dada y con la máquina de control se puede limitar una aceleración máxima para evitar que el campo magnético deje atrás al monoraíl. Y para alterar la velocidad del monoraíl, basta con disminuir o aumentar los retrasos en las operaciones; o bien, alterar la velocidad del reloj del procesador. Así las instrucciones se ejcutarán más rápida o lentamente y el monorraíl se moverá más rápido o más despacio. Y como no es limitado por otra cosa, la velocidad máxima del monorraíl sería determinada únicamente por la velocidad a la que pueden viajar las señales lógicas hasta el más remoto de los electroimánes en la pista y el tiempo que le toma a un campo magnético debilitarse para permitir el movimiento del tren.

La dificultad para trabajar con campos magnéticos fue la razón de no poder concretar la implementación de un modelo que trabajara con las especificaciones anteriores. Sin embargo; la máquina electrónica hecha con el PIC, cuyo funcionamiento se comprovó con el uso de LEDs en lugar de relés, mostró un comportamiento correcto y la capacidad de sustituir los LED por circuitos de cambio de giro (con electroimánes) para hacer funcionar un modelo, por lo que la propuesta queda abierta para la implementación de un tren de levitación magnética bajo principios o bien ideas que puedan refinarse de éste proyecto.

Anexo. Código fuente C del programa para el PIC 16F887 a utilizar.

/* * Project name: * Proyecto final diseño de sistemas digitales. * Monorraíl de levitación magnétca operado mediante máquinas electrónicas * digitales. * * Author: * Manuel Ignacio Castillo Lopez <<nachintoch>> manuel_castillo_cc@ciencias.unam.mx * * Version:

23

* 1.0, november 2012. * * Description: * Éste programa modela todas las funciones lógicas desarrolladas para el * proyecto; excepto por las que respectan al sistema de cambio de luces, las * cuales se implementan por medio de compuertas abordo del tren. * * Propicia y controla el movimiento del manorraíl a partir de los datos de * entrada que envía el usuario, indicando que imanes deben cambiar su * polaridad para así mover el tren. * * Test Configuration: * MCU: PIC16F887 * Dev. Board: Unknown model * Oscillator: HS, 08.0000 MHz, PIC internal. * Ext. Modules: - * SW: mikroC v5.6.1 * Notes: * Ninguna. * */

/* * Declaramos e inicializamos las variables del sistema. Usaremos variables tipo * enteros de 8 bits para manejar los datos. Ésto debido a que manejar variables * de tipo <<bit>> es algo engorroso; por lo que resulta de utilidad que * <<mikroc>> nos permite acceder y manipular de manera individual a los bits de * una variable de 8 bits; usándolos como si fuesen arreglos de bits de longitud * 8. * * La siguiente variable contiene los bits de entrada y salida en su estructura * en la siguiente distribución: * 0 - m. * 1 - v. * 2 - l. * 3 - s. * 4 - e. * 5 - g. * 6 - h. * La localidad que sobra puede emplearse como una variable auxiliar. */unsigned short int datos = 0x00;

/* * La siguiente variable contiene en sus primeras dos localidades, variables * para el manejo de la máquina de estados. También pueden ocuparse las entradas * no utilizadas como bits auxiliares.

24

*/unsigned short int estados = 0x00;

//identificador del imán sobre el cual se encuentra la cabina principalunsigned short int im = 0x00;

//identificadores de salida.unsigned short int imP = 0x00;unsigned short int imR = 0x00;

/* * Variables a usar como cadenas de bits para las salidas de los mux * desarrollados en el diseño a la salida del sistema. */unsigned short int mux00 = 0x00;unsigned short int mux0F = 0x00;unsigned short int mux10 = 0x00;unsigned short int mux1F = 0x00;//mux00 y mux0F se usarán para la salida del sistema implementado también.

/* * Realiza la operación del programa; i.e, realiza las operaciones propias de la * máquina electrónica digital que opera el monorraíl. */void main() { //Configuraciones iniciales //Configura el puerto B: 3 pines para entrada y el resto para salida TRISB = 0b00000111; //Los puertos C y D se congfiguran como salidas TRISC = 0; TRISD = 0; // Se configuran los pines analógicos para señales digitales ANSEL = 0; //Se configura el resto de los pines como digitales. ANSELH = 0; //Incializamos los puertos PORTB = 0x00; PORTC = 0x00; PORTD = 0x00; /* * A continuación aparecen las sentencias que modelan toda la operación de * las funciones que controlan el tren. */ while(1){ //toma las entradas datos.F0 = PORTB.F0; datos.F1 = PORTB.F1;

25

datos.F2 = PORTB.F2; //Operaciones de la máquina de estados switch(estados.F0){ case 0: switch(estados.F1){ case 0://estado e0 00 if(datos.F0 == 0 &datos.F1 == 0){ estados.F0 = 0; estados.F1 = 0; }else{ estados.F0 = 0; estados.F1 = 1; }//evalua las entradas datos.F3 = 0; datos.F4 = 0; break; case 1://estado e1 01 estados.F0 = datos.F0; estados.F1 = datos.F1; datos.F3 = 0; datos.F4 = 0; }//verifica los casos de e0, e1 (00 y 01) break; case 1: switch(estados.F1){ case 0://estado e2 10 if(datos.F0 == 1 &datos.F1 == 0){ estados.F0 = 1; estados.F1 = 0; datos.F3 = 0; datos.F4 = 1; }else{ estados.F0 = 0; estados.F1 = 1; datos.F3 = 0; datos.F4 = 0; }//evalua las entradas break; case 1://estado e3 11 if(datos.F0 == 1 &datos.F1 == 1){ estados.F0 = 1; estados.F1 = 1; datos.F3 = 1; datos.F4 = 0; }else{ estados.F0 = 0; estados.F1 = 1;

26

datos.F3 = 0; datos.F4 = 0; }//evalua las entradas }//verifica los casos de e2, e3 (10 y 11) }//máquina de estados para el control de entradas datos.F7 = datos.F2 &datos.F4;//l &e datos.F5 = datos.F7 ^(datos.F2 &datos.F3);//le XOR ls datos.F6 = (datos.F7 ^datos.F2) ^(datos.F3 &datos.F4 &datos.F2); //(le XOR l) XOR (e &s &l) //da por omision identificadores invalidos imP = 0xFF; imR = 0xFF; /* * Genera los identifcadores de los imanes; de los cuales se va a * invertir su polaridad. */ switch(datos.F3){ case 0: if(datos.F4 == 1){ if(im < 0b00001110){ im++; }else{ im = 0x00; }//avanza hacia adelante if(im < 0b00001110){ imP = im +1; }else{ imP = 0x00; }//da el identificador al siguiente }else{ if(im < 0b00001110){ imP = im +1; }else{ imP = 0x00; }//da el identificador al siguiente if(im > 0b00000010){ imR = im -0b00000011; }else if(im == 0b00000010){ imR = 0b00001110; }else if(im == 1){ imR = 0b00001101; }else{ imR = 0b00001100; }//da el identificador al anterior }//casos para s = 0 (avanza hacia adelante o está detenido) break; case 1:

27

if(datos.F4 == 0){ if(im > 0x00){ im--; }else{ im = 0x0E; }//retrocede if(im > 0b00000010){ imR = im -0b00000011; }else if(im == 0b00000010){ imR = 0b00001110; }else if(im == 1){ imR = 0b00001101; }else{ imR = 0b00001100; }//resta 1 al identificador recordando que de 0 sigue 14 }//el tren avanza hacia atrás }//realiza operaciones del modulo para los id de los imánes a exitar switch(imP){ case 0x00: mux0F = 0x00; mux00 = 0b00000001; break; case 0x01: mux0F = 0x00; mux00 = 0b00000010; break; case 0x02: mux0F = 0x00; mux00 = 0b00000100; break; case 0x03: mux0F = 0x00; mux00 = 0b00001000; break; case 0x04: mux0F = 0x00; mux00 = 0b00010000; break; case 0x05: mux0F = 0x00; mux00 = 0b00100000; break; case 0x06: mux0F = 0x00; mux00 = 0b01000000; break; case 0x07:

28

mux0F = 0x00; mux00 = 0b10000000; break; case 0x08: mux0F = 0b00000001; mux00 = 0x00; break; case 0x09: mux0F = 0b00000010; mux00 = 0x00; break; case 0x0A: mux0F = 0b00000100; mux00 = 0x00; break; case 0x0B: mux0F = 0b00001000; mux00 = 0x00; break; case 0x0C: mux0F = 0b00010000; mux00 = 0x00; break; case 0x0D: mux0F = 0b00100000; mux00 = 0x00; break; case 0x0E: mux0F = 0b01000000; mux00 = 0x00; break; default: mux0F = 0x00; mux00 = 0x00; }//realiza las operaciones del MUX que recibe em0i (imP) switch(imR){ case 0x00: mux1F = 0x00; mux10 = 0b00000001; break; case 0x01: mux1F = 0x00; mux10 = 0b00000010; break; case 0x02: mux1F = 0x00; mux10 = 0b00000100;

29

break; case 0x03: mux1F = 0x00; mux10 = 0b00001000; break; case 0x04: mux1F = 0x00; mux10 = 0b00010000; break; case 0x05: mux1F = 0x00; mux10 = 0b00100000; break; case 0x06: mux1F = 0x00; mux10 = 0b01000000; break; case 0x07: mux1F = 0x00; mux10 = 0b10000000; break; case 0x08: mux1F = 0b00000001; mux10 = 0x00; break; case 0x09: mux1F = 0b00000010; mux10 = 0x00; break; case 0x0A: mux1F = 0b00000100; mux10 = 0x00; break; case 0x0B: mux1F = 0b00001000; mux10 = 0x00; break; case 0x0C: mux1F = 0b00010000; mux10 = 0x00; break; case 0x0D: mux1F = 0b00100000; mux10 = 0x00; break; case 0x0E: mux1F = 0b01000000;

30

mux10 = 0x00; break; default: mux1F = 0x00; mux10 = 0x00; }//realiza las operaciones del MUX que recibe em1i (imR) mux00.F0 = mux00.F0 |mux10.F0; mux00.F1 = mux00.F1 |mux10.F1; mux00.F2 = mux00.F2 |mux10.F2; mux00.F3 = mux00.F3 |mux10.F3; mux00.F4 = mux00.F4 |mux10.F4; mux00.F5 = mux00.F5 |mux10.F5; mux00.F6 = mux00.F6 |mux10.F6; mux00.F7 = mux00.F7 |mux10.F7; mux0F.F0 = mux0F.F0 |mux1F.F0; mux0F.F1 = mux0F.F1 |mux1F.F1; mux0F.F2 = mux0F.F2 |mux1F.F2; mux0F.F3 = mux0F.F3 |mux1F.F3; mux0F.F4 = mux0F.F4 |mux1F.F4; mux0F.F5 = mux0F.F5 |mux1F.F5; mux0F.F6 = mux0F.F6 |mux1F.F6; Delay_ms(125); PORTB.F3 = datos.F5; PORTB.F4 = datos.F6; PORTB.F5 = estados.F0 |estados.F1; PORTB.F6 = mux00.F0; PORTB.F7 = mux00.F1; PORTC.F0 = mux00.F2; PORTC.F1 = mux00.F3; PORTC.F2 = mux00.F4; PORTC.F3 = mux00.F5; PORTC.F4 = mux00.F6; PORTC.F5 = mux00.F7; PORTC.F6 = mux0F.F0; PORTC.F7 = mux0F.F1; PORTD.F0 = mux0F.F2; PORTD.F1 = mux0F.F3; PORTD.F2 = mux0F.F4; PORTD.F3 = mux0F.F5; PORTD.F4 = mux0F.F6; }//ciclo del sistema}//main

31