1. No category

Adaptación de Tkgate a Computadores (GNU).
ÍNDICE
1 OBJECTIVOS DEL PROYECTO.............................................2
2 ESPECIFICACIONES, DISEÑO Y DESARROLLO..............3
2.1 COMPARADOR...........................................................3
2.2 CODIFICADOR...........................................................11
2.3 CONTADOR................................................................16
2.4 MULTI­CONTADOR..................................................20
2.5 ASCENSOR.................................................................25
2.6 CALEFACCIÓN..........................................................29
2.7 PUERTA DE PARKING.............................................33
2.8 PASO A NIVEL DE UNA VIA..................................37
2.9 PASO A NIVEL DE DOS VIAS................................40
2.10 UNIDAD DE CONTROL.........................................43
3 REFERÉNCIAS......................................................................53
4 MANUAL TKGATE...............................................................54
5 INSTALAR TKGATE SOBRE CYGWIN..............................113
6 INSTALAR TKGATE SOBRE DEBIAN O KNOPPIX.........122
7 INSTALAR LOS NUEVOS MÓDULOS...............................125
8 COMO CREAR NUEVAS PUERTAS...................................131
1
índice
Adaptación de Tkgate a Computadores (GNU).
1 OBJECTIVOS DEL PROYECTO
El objetivo de este proyecto es adaptar las librerías que se utilizan en la assignatura de Computadores de la Ingeniería Informática de Sistemas y de Gestión a un programa de libre distribución como el TkGate. El problema con otros programas de simulación de circuitos, es la licencia. La mayoría de estos programas necesitan una licencia para ser usados, la Universidad cuenta con las licencias pero, si alguno de los alumnos de la asignatura quiere hacer practicas en casa o instalar estos programas en su portátil no es posible instalar el programa entero, solo una demo. Para ello, se intentará crear el mismo tipo de puertas lógicas existentes en el programa usado en la actualidad, implementadas en un proyecto anterior. Debido a que el TkGate no cuenta con ninguna puerta lógica que tenga animación, se deberá crear algun tipo de animaciones, ya que varios de los circuitos como el paso a nivel son requeridas las animaciones.
También se especificarán un tipo de ficheros de texto en los que se introducirán las transiciones y las salidas de una unidad de control, para facilitar la realización de prácticas sobre estos circuitos, como la maquina sencilla.
También se implementarán varios cicuitos básicos como el comparador, el codificador, el multi­contador, el contador.
2
índice
Adaptación de Tkgate a Computadores (GNU).
2 ESPECIFICACIONES, DISEÑO Y DESARROLLO
2.1 COMPARADOR
Descripción:
Un comparador es un circuito combinacional que se utiliza para comparar dos operandos (A y B) buscando una relacione entre ellos, como A<B, A=B, A B, etc. Una comparación entre dos operandos se requiere normalmente como parte de instrucciones de salto condicional o para determinar condiciones de salto en un microprograma o simplemente para operaciones aritméticas.
Entradas:
A y B: Las entradas A y B son señales que van de 1 bit hasta 32 bits. Estas entradas deben ser números enteros, independientemente de la codificación.
PS:
La entrada PS es una señal de un bit. Esta entrada indica si el circuito esta habilitado o no.
Salidas:
A<B, A=B, A>B: Las salidas A<B, A=B, A>B, son de solo un bit. Solo se activan si la condición entre los dos números se cumple, en caso contrario la salida será un cero lógico.
Definición de retrasos y su área:
Esta puerta tiene definidos seis tipos de retrasos, dependiendo de las entradas que cambian, y a las salidas que afectan:
3
índice
Adaptación de Tkgate a Computadores (GNU).
Para la tecnología “default” tenemos:
Desde
Hasta
Periodos
A y B
A>B
Número de bits de las entradas.
A=B
Número de bits de las entradas.
A<B
Número de bits de las entradas.
A>B
3
A=B
3
A<B
3
PS
El Área de la puerta es 3.
Para la tecnología “unit” tanto los retrasos como el área de la puerta son uno.
Errores de diseño:
La entrada PS es una entrada booleana, es decir, que solo necesitamos un bit para representarla. Si PS es 0 el circuito esta inhabilitado y si es 1 el circuito esta habilitado.
Las salidas son solo de un bit, por tanto, si intentamos modificar alguna de las salidas para poner otro tipo de circuito a la salida, obtendremos este error.
4
índice
Adaptación de Tkgate a Computadores (GNU).
Para comparar dos enteros es necesario que estos tengan el mismo ancho de bus, por eso no podremos comparar un número de 8 bits con otro de 32.
Las entradas tienen una representación interna de 32 bits por tanto, solo podremos comparar enteros de 1 a 32 bits.
Pruebas realizadas:
Primera prueba:
Se monta el siguiente circuito que realiza la comparación de dos enteros mediante dos interruptores dip:
Iniciamos la simulación, modificamos los valores de los interruptores dip y activamos la señal PS:
5
índice
Adaptación de Tkgate a Computadores (GNU).
Modificamos el valor del interruptor dip de la entrada A, haciendo que el valor de A sea mayor que el de B:
Modificamos los valores de los interruptores dip, ahora la entrada B es mayor que la entrada A:
Deshabilitando el circuito, es decir, poniendo a cero la entrada PS tendremos el siguiente resultado:
6
índice
Adaptación de Tkgate a Computadores (GNU).
Si añadimos al circuito puntas de prueba:
podremos observar la evolución de las señales en el tiempo:
7
índice
Adaptación de Tkgate a Computadores (GNU).
Segunda prueba:
El siguiente circuito es una unidad aritmético­lógica (ALU). Con este ejemplo comprobaremos el funcionamiento del comparador cuando tiene conectados como entradas y salidas otros tipos de circuitos.
La ALU tiene cuatro operaciones:
Código de operación Operación
0
A
1

A
2
A+B
3
A XOR B
Seleccionando el módulo y con la combinación de teclas “Shift+<” podremos ver el interior del módulo:
8
índice
Adaptación de Tkgate a Computadores (GNU).
Iniciamos la simulación dejando pasar el valor que hay en la entrada A:
Modificamos el valor del interruptor de la entrada A y hacemos que la ALU devuelva el valor negado:
Modificamos los valores de los interruptores dip de las entradas de datos y modificamos también el código de operación, indicando que queremos la suma de los dos operandos:
9
índice
Adaptación de Tkgate a Computadores (GNU).
Por último, seleccionamos la salida XOR, modificando también los valores de las entradas para que tengan el mismo valor:
10
índice
Adaptación de Tkgate a Computadores (GNU).
2.2 CODIFICADOR
Descripción:
Un codificador es un circuito combinacional con 2 n entradas y n salidas que se utiliza para presentar en la salida el código binario correspondiente a la entrada activada. Existen dos tipos de codificadores. Codificadores sin prioridad y codificadores con prioridad. Los primeros solo admiten una entrada activa, codificando en la salida el valor binario de la misma y cero cuando no existe ninguna activa. En los segundos puede haber más de una entrada activada, existiendo prioridad en aquella cuyo valor decimal es más alto. En este caso el codificador es con prioridad, la entrada de menor peso es la que hay más hacia la derecha y el número de entradas esta fijado a cuatro.
Entradas:
A,B,C,D: Las entradas A,B,C, y D son señales de un bit.
PE:
La entrada PE es una señal de un bit. Esta entrada indica si el circuito esta habilitado o no.
Salidas:
RES: La salida RES es de dos bits. Representará el código binario correspondiente a la entrada activada de mayor peso.
AE:
La salida AE es una señal de un bit. Esta entrada indica si en el circuito hay alguna entrada activa (A,B,C,D).
Definición de retrasos y su área:
Esta puerta tiene definidos cuatro tipos de retrasos fijos:
11
índice
Adaptación de Tkgate a Computadores (GNU).
Para la tecnología “default” tenemos:
Desde
Hasta
Periodos
A,B,C,D
RES
8
AE
4
RES
2
AE
1
PE
El Área de la puerta es 1.
Para la tecnología “unit” tanto los retrasos como el área de la puerta son uno.
Errores de diseño:
Las entradas A, B, C, y D son de tipo booleano, es decir, solo pueden tener los valores 0 o 1. Si tienen un 0 indicará que la entrada no está activa y si tienen un 1 indicará que esta activa.
Para representar si hay alguna entrada activa solo necesitamos un bit.
12
índice
Adaptación de Tkgate a Computadores (GNU).
La entrada PE es una entrada booleana, es decir, que solo necesitamos un bit para representarla. Si PS es 0 el circuito esta inhabilitado y si es 1 el circuito esta habilitado.
La salida representa el código binario de la entrada de mayor peso. Para representar este número la salida debe ser de tantos bits como indica el exponente del logaritmo en base dos del numero de entradas.
Pruebas realizadas:
Se monta el siguiente circuito que realiza la codificación de las entradas mediante cuatro conmutadores:
Iniciamos el circuito y lo habilitamos:
13
índice
Adaptación de Tkgate a Computadores (GNU).
Activamos la primera entrada, y se activa la señal AE:
Activamos la segunda entrada, y se modifica el valor de la salida:
14
índice
Adaptación de Tkgate a Computadores (GNU).
La entrada de la izquierda es más prioritaria que las demás que estan activas, su valor es codificado:
Deshabilitamos el circuito, y las señales de salida pasan a tener valor cero:
15
índice
Adaptación de Tkgate a Computadores (GNU).
2.3 CONTADOR
Descripción:
Un contador es un circuito secuencial capaz de realizar el cómputo de los impulsos que recibe en la entrada de reloj. Son circuitos lógicos secuenciales, normalmente construidos a partir de biestables D y puertas lógicas. Se pueden utilizar para contar pulsos de reloj, para almacenar datos, como divisores de frecuencia, direccionamiento secuencial y en algunos circuitos aritméticos. Entradas:
R: La entrada R es una señal de un bit. Cuando esta entrada este a nivel alto se reinicializa el contador, no hace nada en caso contrario.
PE:
La entrada PE es una señal de un bit. Esta entrada indica si el circuito esta habilitado o no.
CK: La entrada CK es una señal de un bit. Esta es la entrada de reloj, podremos conectar tanto relojes como otro tipo de circuitos como conmutadores.
Salidas:
OUT: La salida OUT, puede ser de 1 a 32 bits. Representará el valor interno del contador que se incrementará a cada flanco ascendente de reloj.
Definición de retrasos y su área:
16
índice
Adaptación de Tkgate a Computadores (GNU).
Esta puerta tiene definidos tres tipos de retrasos, dependiendo de las entradas que cambian, y a las salidas que afectan:
Para la tecnología “default” tenemos:
Desde
Hasta
Periodos
R
OUT
Número de bits de la salida.
PE
OUT
Número de bits de la salida.
CK
OUT
Número de bits de la salida.
El Área de la puerta es 16 por el número de bits de la salida.
Para la tecnología “unit” tanto los retrasos como el área de la puerta son uno.
Errores de diseño:
Las entradas PE y R son entradas booleanas, es decir, que solo necesitamos un bit para representarlas. La entrada CK es una entrada de reloj que siempre debe tener un bit.
El valor del contador tiene una representación interna de 32 bits, por tanto solo podremos hacer que la salida tenga como mucho 32 bits.
17
índice
Adaptación de Tkgate a Computadores (GNU).
Pruebas realizadas:
Montamos el siguiente circuito que implementa un cronómetro digital.
Mediante contadores de módulo 100 y contadores de módulo 60 anidados creamos el siguiente circuito:
18
índice
Adaptación de Tkgate a Computadores (GNU).
Iniciamos el simulador activando la señal de “start”, el circuito empieza a contar.
Activamos la señal de “reset” para reinicializar el circuito:
19
índice
Adaptación de Tkgate a Computadores (GNU).
2.4 MULTI­CONTADOR
Descripción:
Un multi­contador es un circuito secuencial. Es una extensión del contador ya que además de poder contar los impulsos, puede decrementar su valor interno a cada ciclo de reloj o cargar el valor de la entrada. Son circuitos lógicos secuenciales, normalmente construidos a partir de biestables D y puertas lógicas. Se suelen utilizar como contadores de programa al implementar las unidades de control.
Entradas:
R: La entrada R es una señal de un bit. Cuando esta entrada este a nivel alto se reinicializa el contador, no hace nada en caso contrario.
OP:
La entrada OP es una señal de dos bits. Esta entrada indica al multi­contador el código de operación. Las diferentes posibilidades son:
0 ­> El circuito no hace nada.
1 ­> Se incrementa el valor interno del multi­contador.
2 ­> Se decrementa el valor interno del multi­contador.
3 ­> Se carga el valor de la entrada.
CK: La entrada CK es una señal de un bit. Esta entrada indica si el circuito esta habilitado o no.
IN: La entrada IN, puede ser de 1 a 32 bits. Mediante esta entrada estableceremos el valor interno del multi­contador, desde donde empezar a contar.
Salidas:
OUT: Las salidas OUT, puede ser de 1 a 32 bits. Representará el valor interno del contador.
20
índice
Adaptación de Tkgate a Computadores (GNU).
Definición de retrasos y su área:
Esta puerta tiene definidos cuatro tipos de retrasos, dependiendo de las entradas que cambian, y a las salidas que afectan:
Para la tecnología “default” tenemos:
Desde
Hasta
Periodos
R
OUT
Número de bits de la salida.
PE
OUT
Número de bits de la salida.
CK
OUT
Número de bits de la salida.
IN
OUT
Número de bits de la salida.
El Área de la puerta es 32 por el número de bits de la salida.
Para la tecnología “unit” tanto los retrasos como el área de la puerta son uno.
Errores de diseño:
Las entradas CK y R son entradas booleanas, es decir, que solo necesitamos un bit para representarlas, solo pueden tomar el valor 0 o el 1 lógico.
21
índice
Adaptación de Tkgate a Computadores (GNU).
Como solo tenemos cuatro operaciones, necesitaremos solo 2 bits para representar los cuatro números.
El valor del multi­contador tiene una representación interna de 32 bits, por tanto solo podremos hacer que la entrada y salida tengan como mucho 32 bits.
Pruebas realizadas:
Para probar el funcionamiento del multi­contador, montamos un circuito simple con dos interruptores, dos conmutadores y un display:
22
índice
Adaptación de Tkgate a Computadores (GNU).
Modificamos el valor de la entrada, el código de operación, y generamos un flanco ascendente en la entrada del reloj. Se carga el valor de la entrada y se muestra en el display.
Cambiamos el código de operación para decrementar el valor del multi­contador, y generamos un flanco ascendente:
Cambiamos el código de operación para incrementar el valor del multi­contador, y generamos varios flancos ascendentes, el resultado será el siguiente:
23
índice
Adaptación de Tkgate a Computadores (GNU).
Cambiamos el código de operación a 0 para que el multi­contador no haga nada aunque reciba flancos ascendentes en la entrada de reloj, simplemente se mostrará el valor del contador en la salida:
Activamos la señal de “reset” para reinicializar el contador:
24
índice
Adaptación de Tkgate a Computadores (GNU).
2.5 ASCENSOR
Descripción:
El ascensor puede ser un circuito combinacional o secuencial dependiendo de una variable que podremos modificar en el modo de simulación. El ascensor dispone de un motor que nos permitirá hacerlo subir o bajar. Haciendo clic sobre el ascensor en modo simulación aparecerá un cuadro de dialogo como el siguiente:
En el caso de que queramos un circuito combinacional seleccionaremos los detectores. Si estamos subiendo, cuando la parte de arriba del ascensor pase por uno de los detectores, este se activará, y cuando el final del ascensor pase por el mismo detector, se apagará. Si estamos bajando, se encenderá cuando pase la parte de abajo del ascensor y se encenderá cuando pase la parte de arriba.
Si queremos un circuito secuencial seleccionaremos los indicadores. Los indicadores provocarán un flanco ascendente en la salida, cuando la parte de arriba pase por uno de los indicadores, tanto si estamos subiendo como bajando.
25
índice
Adaptación de Tkgate a Computadores (GNU).
Entradas:
UP: La entrada UP es una señal de un bit. Cuando la señal UP esta a nivel alto y la señal DOWN no esta a nivel alto hace que el ascensor suba.
DOWN: La entrada DOWN es una señal de un bit. Cuando la señal DOWN esta a nivel alto y la señal UP no esta a nivel alto hace que el ascensor suba.
Salidas:
PB, FIRST, SECOND, THIRD, FOURTH: Estas señales son todas de un bit. Nos serviran para controlar la posición del ascensor.
Definición de retrasos y su área:
A diferencia de las otras puertas, el ascensor no tiene definida el área ni los retrasos.
Para poder controlar la velocidad del ascensor para que a los circuitos de control les de tiempo de calcular las nuevas entradas del circuito, utilizaremos la variable “Velocidad”, que tenemos en el cuadro de dialogo que hemos visto antes. Cuanto más grande el número, menor velocidad tendra el ascensor y más tiempo tendremos para analizar las salidas.
Errores de diseño:
Las salidas indican cuando el ascensor pasa por alguna de ellas, por tanto, solo necesitaremos un bit para representarlas.
26
índice
Adaptación de Tkgate a Computadores (GNU).
Las entradas UP y DOWN son entradas booleanas, es decir, que solo necesitamos un bit para representarlas. Pruebas realizadas:
Iniciamos la simulación, se mostrará el ascensor parado:
Activamos la señal UP, y dejamos que el ascensor suba, a su paso va activando las salidas:
Si no paramos el ascensor, cuando llegue al limite superior, parará mostrando el siguiente mensaje de error:
27
índice
Adaptación de Tkgate a Computadores (GNU).
Desactivamos la señal UP, y activamos la señal DOWN. El ascensor empieza a bajar, activando a su paso los detectores:
Si intentamos hacer que el ascensor suba y baje al mismo tiempo, tendremos este error:
28
índice
Adaptación de Tkgate a Computadores (GNU).
2.6 CALEFACCIÓN
Descripción:
Este circuito simula el un recinto en el que se le aplica una fuente de calor. Este circuito depende de tres variables a parte de si la fuente esta activa o no. Estas variables las podremos modificar en el modo de simulación haciendo clic sobre la puerta. Aparecerá un cuadro de dialogo como el siguiente:
La Calefacción se iniciará con la temperatura exterior, cuando la encendamos, ira subiendo de temperatura hasta que llegue al limite. Este limite depende de el aislamiento térmico, por ejemplo si el aislamiento térmico es cero, la temperatura del recinto nunca llegará a la temperatura de la fuente, sin embargo si el aislamiento térmico es del cien por cien el circuito parará cuando la temperatura actual sea igual a la temperatura de la fuente.
Cuando apaguemos la calefacción la temperatura ira disminuyendo hasta llegar a un cierto limite. Este limite depende también del aislamiento térmico. Cuanto mayor aislamiento tengamos menor sera la disipación de calor. En el peor de los casos, en el que el aislamiento sea cero, la temperatura bajará hasta alcanzar la temperatura exterior.
29
índice
Adaptación de Tkgate a Computadores (GNU).
La temperatura de la fuente de calor puede variar entre 60 y 120 grados, si intentamos asignar un valor fuera de este rango obtendremos un mensaje de error como el siguiente:
La temperatura exterior puede variar entre ­60 y 40 grados, si intentamos asignar un valor fuera de este rango obtendremos un mensaje de error como el siguiente:
El porcentaje de aislamiento puede variar entre 0% y 100% , si intentamos asignar un valor fuera de este rango obtendremos un mensaje de error como el siguiente:
Entradas:
IN: 30
La entrada IN es una señal de un bit. Cuando la señal esta a nivel alto se enciende la calefacción y cuando esta a nivel bajo se apaga.
índice
Adaptación de Tkgate a Computadores (GNU).
Salidas:
OUT: Esta señales es de ocho bits. La codificación de los números será complemento a dos (CA2) ya que puede tomar valores entre ­60 y 120.
Definición de retrasos y su área:
A diferencia de las otras puertas, la calefacción no tiene definida el área ni los retrasos.
Para poder controlar la velocidad de la calefacción para que a los circuitos de control les de tiempo de calcular las nuevas entradas del circuito, utilizaremos la variable “Retraso”, que tenemos en el cuadro de dialogo que hemos visto antes. Cuanto más grande el número, menor velocidad tendra el ascensor y más tiempo tendremos para analizar las salidas.
Errores de diseño:
Para controlar si la fuente de calor esta encendida o apagada solamente nos hace falta un bit.
Debido a los rangos que hemos elegido para las temperaturas, la salida solo podrá tener ocho bits.
31
índice
Adaptación de Tkgate a Computadores (GNU).
Pruebas realizadas:
Por ahora no hay ningun circuito en el TkGate que pueda representar los números negativos, por tanto, usaremos un led decimal normal. En la calefacción los valores por defecto de las temperaturas son: Temperatura fuente 120º
Temperatura exterior ­10º
Aislamiento 50%
Iniciamos la simulación con la calefacción parada:
Al encender la calefacción, la temperatura del recinto ira subiendo progresivamente, como refleja el termómetro.
Cuando apaguemos la calefacción, la temperatura bajará dependiendo de el aislamiento:
32
índice
Adaptación de Tkgate a Computadores (GNU).
2.7 PUERTA DE PARKING
Descripción:
El circuito simula el comportamiento de una puerta automática por donde entra los coches a un parking. La puerta tiene un motor que nos permite abrir y cerrar la barrera. El sensor de la parte superior de la puerta indica si la puerta esta cerrada del todo o abierta del todo. El sensor del medio indica cuando un coche esta pasando por él. Y el sensor de la parte inferior simula un lector de tarjetas donde cada coche pasa una tarjeta que le valida para entrar en el parking. Hay cuatro diferentes tipos de coches dependiendo de su velocidad, que iran apareciendo aleatoriamente. Podemos hacer que aparezca un tipo determinado de coches mientras simulamos utilizando el cuadro de dialogo siguiente:
Si la barrera se esta cerrando o se esta abriendo los coches no podran pasar. Un coche podrá avanzar cuando la barrera este abierta por completo.
Entradas:
OPEN, CLOSE: Estas entradas deben ser de un bit. Cuando la señal OPEN esta a nivel alto y la señal CLOSE no esta a nivel alto hace que la barrera se abra. Cuando la señal CLOSE esta a nivel alto y la señal OPEN no esta a nivel alto hace que la barrera se cierre.
33
índice
Adaptación de Tkgate a Computadores (GNU).
Salidas:
S, C, P: Esta señales son de un bit. Definición de retrasos y su área:
A diferencia de las otras puertas, la puerta del parking no tiene definida el área ni los retrasos.
Para poder controlar la velocidad de la puerta del parking para que a los circuitos de control les de tiempo de calcular las nuevas entradas del circuito, utilizaremos la variable “Retraso”, que tenemos en el cuadro de dialogo que hemos visto antes. Cuanto más grande el número, menor velocidad tendra el ascensor y más tiempo tendremos para analizar las salidas.
Errores de diseño:
Las entradas OPEN y CLOSE son entradas booleanas, es decir, que solo necesitamos un bit para representarlas. Las salidas indican cuando el coche pasa por alguna de ellas o si la barrera esta abierta o cerrada, por tanto, solo necesitaremos un bit para representarlas.
34
índice
Adaptación de Tkgate a Computadores (GNU).
Pruebas realizadas:
Al iniciar la simulación la barrera estará cerrada, como indica el led superior. El primer coche entrara en la puerta “validándose para entrar en el parking”:
Abrimos la barrera:
Hasta que la barrera no esta completamente abierta el coche no empieza a avanzar. Se enciende el led central indicando que el coche esta pasando:
Si no paramos la barrera, tendremos el siguiente error:
35
índice
Adaptación de Tkgate a Computadores (GNU).
Al cerrar la puerta más de lo debido, tendremos el siguiente error:
Si intentamos abrir y cerrar la barrera al mismo tiempo tendremos el siguiente error:
36
índice
Adaptación de Tkgate a Computadores (GNU).
2.8 PASO A NIVEL DE UNA VIA
Descripción:
Este circuito simula el comportamiento de un tren y dos coches en un paso a nivel. Dispone de un motor que permite cerrar las barreras y dos sensores que indicaran la proximidad de un tren. El tren puede circular solo en una dirección o en las dos, según lo especifiquemos. Para modificar este parámetro deberemos entrar en modo simulación y hacer un clic sobre el circuito, así aparecerá el siguiente cuadro de dialogo:
Entradas:
BAR: Esta entrada debe ser de un bit. Cuando la señal esta a nivel bajo las barreras permanecerán cerradas y cuando este a nivel alto se abrirán.
Salidas:
S1, S2: Esta señales son de un bit. Se activan cuando la cabeza del tren pasa por encima y se desactivan cuando acaba de pasar todo el tren.
37
índice
Adaptación de Tkgate a Computadores (GNU).
Definición de retrasos y su área:
A diferencia de las otras puertas, el paso a nivel de una via no tiene definida el área ni los retrasos.
Para poder controlar la velocidad del tren y de los coches para que a los circuitos de control les de tiempo de calcular las nuevas entradas del circuito, utilizaremos las variables “Tren”, “Coche izquierdo” y “Coche derecho”, que tenemos en el cuadro de dialogo que hemos visto antes. Cuanto más grande el número, menor velocidad.
Errores de diseño:
Tanto las entradas como las salidas del circuito deben tener un bit, ya que para indicar si pasa o no pasa el tren o indicar si abrimos o cerramos las barreras solo es necesario un bit.
Pruebas realizadas:
Para probar el paso a nivel de una via montamos el siguiente circuito:
38
índice
Adaptación de Tkgate a Computadores (GNU).
Iniciamos la simulación, los dos coches entrarán y pararan cerca de las barreras, el tren ira avanzando encendiendo los leds a su paso:
Cuando no existe peligro de choque, podemos abrir las barreras para que pasen los coches:
En el caso de que abramos las barreras en el momento que pasa un tren, chocaran y finalizará la simulación:
39
índice
Adaptación de Tkgate a Computadores (GNU).
2.9 PASO A NIVEL DE DOS VIAS
Descripción:
Este circuito simula el comportamiento de dos trenes y dos coches en un paso a nivel. Dispone de un motor que permite cerrar las barreras y cuatro sensores que indicaran la proximidad de un tren. Los trenes pueden circular solo en una dirección o en las dos, según lo especifiquemos. Para modificar este parámetro deberemos entrar en modo simulación y hacer un clic sobre el circuito, así aparecerá el siguiente cuadro de dialogo:
Entradas:
BAR: Esta entrada debe ser de un bit. Cuando la señal esta a nivel bajo las barreras permanecerán cerradas y cuando este a nivel alto se abrirán.
40
índice
Adaptación de Tkgate a Computadores (GNU).
Salidas:
S1, S2, S3, S4: Esta señales son de un bit. Se activan cuando la cabeza del tren pasa por encima y se desactivan cuando acaba de pasar todo el tren.
Definición de retrasos y su área:
A diferencia de las otras puertas, el paso a nivel de dos vías no tiene definida el área ni los retrasos.
Para poder controlar la velocidad de los trenes y de los coches para que a los circuitos de control les de tiempo de calcular las nuevas entradas del circuito, utilizaremos las variables “Tren superior”, “Tren inferior”, “Coche izquierdo” y “Coche derecho”, que tenemos en el cuadro de dialogo que hemos visto antes. Cuanto más grande el número, menor velocidad.
Errores de diseño:
Tanto las entradas como las salidas del circuito deben tener un bit, ya que para indicar si pasa o no pasa el tren o indicar si abrimos o cerramos las barreras solo es necesario un bit.
41
índice
Adaptación de Tkgate a Computadores (GNU).
Pruebas realizadas:
Para probar el paso a nivel de una via montamos el siguiente circuito:
Iniciamos la simulación, los dos coches entrarán y pararan cerca de las barreras, los trenes iran avanzando encendiendo los leds a su paso:
Cuando no existe peligro de choque, podemos abrir las barreras para que pasen los coches:
En el caso de que abramos las barreras en el momento que pasa uno de los trenes, chocaran y finalizará la simulación:
42
índice
Adaptación de Tkgate a Computadores (GNU).
2.10 UNIDAD DE CONTROL
Descripción:
La unidad de control es un circuito secuencial. Es el cerebro de un circuito. Se encarga de activar o desactivar los diversos componentes del circuito en función de las entradas que tenga y en función también del estado en que se encuentre. Existen dos tipos de unidades de control, las cableadas, usadas generalmente en máquinas sencillas, y las microprogramadas, usadas generalmente en máquinas complejas. A esta unidad de control podemos añadirle entradas y salidas. Podemos tener múltiples entradas y salidas pero no pueden superar los 32 bits en la entrada o en la salida. Para añadir entradas pulse sobre la puerta con el boton derecho del ratón y seleccione la opción “Añadir entrada...” del menú emergente. Para añadir salidas entre en las propiedades de la puerta haciendo doble clic sobre la puerta y seleccione la página “Patilla”, y use el boton “Añadir”.
La unidad de control necesita saber en cada momento, según el estado en el que esta, y las entradas actuales, a que estado debe pasar. Estas transiciones se le asignaran mediante un fichero con el siguiente formato:
Estado_actual
Entrada
Estado_siguiente
Podemos tener lineas en blanco o comentarios, ya que se ignorarán. Podemos usar valores desconocidos en las entradas que denotaremos por el carácter “x”. El número de bits de la entrada de la unidad de control dependerá del tamaño de las entradas en el fichero de transiciones. Si el número de bits de la entrada requerido es, por ejemplo 3, no importa si utilizamos tres entradas de un bit o una entrada de tres bits. No importa el orden de las transiciones, ya que se ordenarán antes de mostrarlas. Si hubiera alguna entrada a la que le faltaran bits, se rellenaran con caracteres “x”. En una misma linea no importa el número de espacios entre el estado actual y la entrada o la entrada y el estado siguiente. Los números del fichero pueden estar en codificación hexadecimal. Si en el fichero hubieran transiciones repetidas, solo será valida la primera transición encontrada, las demás se eliminaran. Si en alguna de las transiciones, en la entrada, hay algun carácter que no es un digito o un carácter hexadecimal, este se sustituirá por un valor desconocido (“x”). Si en alguna de las transiciones, en alguno de los estados, hay algun carácter que no es un digito o un carácter hexadecimal, esta transición se ignorará. La unidad de control no es capaz de rellenar las transiciones incompletas o que se haya olvidado de introducir en el fichero.
43
índice
Adaptación de Tkgate a Computadores (GNU).
Para cargar estos fichero en la unidad de control, seleccione las propiedades de la puerta donde quiera cargar el fichero, y seleccione la página “Entradas”:
Puede buscar el fichero de transiciones con el boton “Visualizar...”.
También necesita saber según el estado en el que esta, cuales son las salidas. Estas salidas y los estados correspondientes se le asignaran mediante un fichero con el siguiente formato:
Estado
Salida
Podemos tener lineas en blanco o comentarios, ya que la unidad de control las ignorará. Podemos usar valores desconocidos en las salidas, pero no en los números de estado, que denotaremos por el carácter “x”. El número de bits de la salida de la unidad de control dependerá del tamaño de las salidas en el fichero de transiciones. Si el número de bits de la salida requerido es, por ejemplo 3, no importa si utilizamos tres salidas de un bit o una salida de tres bits. No importa el orden de los estados y sus salidas, ya que la unidad de control los ordenará antes de mostrarlos. Si hubiera alguna salida a la que le faltaran bits, se rellenarán con caracteres “x” a la izquierda. En una misma linea no importa el número de espacios entre el estado y la salida. Los números del fichero pueden estar en codificación hexadecimal. Si en el fichero hubieran estados repetidos, se interpretarán como un estado nuevo poniendo como salida un valor desconocido. Si en alguna de las salidas, hay algun carácter que no es un digito o un carácter hexadecimal, este se sustituirá por un valor desconocido (“x”). Si faltará alguno de los estados, o en alguna linea hay un estado que tiene 44
índice
Adaptación de Tkgate a Computadores (GNU).
algun carácter que no es un digito o un carácter hexadecimal, añadirá el estado a la lista poniendo como salida el valor desconocido. Para cargar estos fichero en la unidad de control, seleccione las propiedades de la puerta donde quiera cargar el fichero, y seleccione la página “Salidas”:
Puede buscar el fichero de salidas con el boton “Visualizar...”.
Definición de retrasos y su área:
Esta puerta tiene definidos seis tipos de retrasos, dependiendo de las entradas que cambian, y a las salidas que afectan:
Para la tecnología “default” tenemos:
45
Desde
Hasta
Periodos
IN
OUT
Número de bits de OUT + Número de bits de la entrada IN.
R
OUT
Número de bits de OUT+ 1.
índice
Adaptación de Tkgate a Computadores (GNU).
CK
OUT
Número de bits de OUT + 1.
IN
S
Número de bits de IN + 1.
R
S
Número de bits de S + 1.
CK
S
Número de bits de S + 1.
El Área de la puerta es
2 + Número de bits de S + Número de bits de IN + Número de bits de OUT.
Para la tecnología “unit” tanto los retrasos como el área de la puerta son uno.
Errores de diseño:
Dependiendo del número de estados que especifiquemos en el fichero, el numero de bits de la salida de estado es el exponente del logaritmo en base dos del número máximo a representar.
El número de bits de la salida vendrá especificado por el fichero de salidas.
46
índice
Adaptación de Tkgate a Computadores (GNU).
Las entradas CK y R son entradas booleanas, es decir, que solo necesitamos un bit para representarlas. El número de bits de la entrada vendrá especificado por el fichero de transiciones.
Pruebas realizadas:
Primera prueba:
Mediante la unidad de control queremos diseñar un semáforo con el siguiente grafo de estados:
No cam bio
VERD E
No cam bio
AM BAR
RO JO O FF
AM BAR O FF
VERDE O N
C am bio
No c am bio
C am b io
C am bio
RO JO
RO JO O N
AM BAR O FF
VERDE O FF
RO JO O FF
A M BAR O N
VERDE O FF
ERRO R
C am bio
N o cam b io
RO JO O FF
AM BA R ON
VERD E OFF
47
índice
Adaptación de Tkgate a Computadores (GNU).
Codificamos las entradas ,salidas y el estado, y obtenemos la siguiente tabla de transiciones:
ESTADO ENTRADAS
ESTADO
ACTUAL
C
SIGUIENTE
00
0
00
00
1
10
01
0
01
01
1
00
10
0
10
10
1
01
11
0
00
11
1
00
ESTADO SALIDA
ACTUAL
R V A
00
1 0 0
01
0 0 1
10
0 1 0
11
0 0 1
Montaremos el siguiente circuito:
Iniciamos la simulación:
48
índice
Adaptación de Tkgate a Computadores (GNU).
Avanzamos varias transiciones solicitando el cambio de color:
Segunda prueba:
Ampliamos la maquina sencilla para que tenga dos nuevas instrucciones para la implementación de bucles:
Nuevas instrucciones:
INIC n: Inicia un contador con el valor n.
LOOP d: Esta instrucción resta 1 al valor del contador. Si el resultado es diferente de 0, salta a ejecutar la instrucción que se encuentra en la dirección d. Sino la ejecución del programa continua en la siguiente instrucción.
Montaremos el siguiente circuito:
49
índice
Adaptación de Tkgate a Computadores (GNU).
Si seleccionamos el módulo “mem” y pulsamos la combinación de teclas “Shift+<” entraremos en el interior del módulo:
O en el módulo “ps_simp”:
Donde podemos ver el contenido del módulo ALU:
50
índice
Adaptación de Tkgate a Computadores (GNU).
Para volver al módulo principal podemos pulsar “<”.
Para el nuevo conjunto de instrucciones tendremos la siguiente tabla de transiciones:
0 XXX 1
1 0XX 2
1 1XX 3
1 2XX 2
1 302 9
1
310
6
1 3X1 7
1 X0X 0
2 0XX 4
2 2XX 5
3 XXX 0
4 XXX 0
5 XXX 0
6 XXX 0
7 XXX 8
8 XXX 0
9 3X2 A
A XXX B
B X0X 6
51
índice
Adaptación de Tkgate a Computadores (GNU).
B X1X 0
Y la siguiente tabla de salidas:
SPC
OPC
MUX
LIR
LA
LB
ALU
LFZ
L/E
0
0
X
0
1
0
0
X
0
0
1
1
1
4
0
1
0
X
0
0
2
0
X
6
0
0
1
X
0
0
3
0
X
6
0
0
0
2
1
1
4
0
X
6
0
0
0
0
1
1
5
0
X
X
0
0
0
1
1
0
6
1
3
X
0
0
0
X
0
0
7
0
X
3
0
0
1
X
0
0
8
0
X
2
0
0
0
4
1
1
9
0
X
2
0
0
1
X
0
0
A
0
X
2
0
0
0
3
1
1
B
0
X
X
0
0
0
X
0
0
En la memoria cargaremos el siguiente programa:
52
Dirección
Contenido
Descripción
0
D001
Ejecuta la instrucción INIC (M[127]:=1)
1
048A
Suma el valor de las posiciones 9 y 10 (ADD [9],[10])
2
E001
Ejecuta la instrucción LOOP.
3
860C
Ejecuta un CMP de la posición 12 de la memoria.
4
C003
Ejecuta la instrucción BEQ y vuelve a la posición 3.
5
0
...
0
9
1
10
1
...
0
12
0
20
0
40
0
índice
Adaptación de Tkgate a Computadores (GNU).
3 REFERÉNCIAS
•
TKGate User Documention
http://www.tkgate.org/1.8/index.html
•
Tcl/Tk 8.4 Manual
http://www.tcl.tk/man/tcl8.4/
•
Tutorial de Tcl/Tk
http://www.etsimo.uniovi.es/tcl/tutorial/
•
The Tcler's Wiki
http://wiki.tcl.tk/
•
Linux Docs
http://www.die.net/doc/linux/
•
A First Guide to PostScript
http://www.cs.indiana.edu/docproject/programming/postscript/postscript.html
•
PostScript Language Tutorial & Cookbook
http://www­cdf.fnal.gov/offline/PostScript/BLUEBOOK.PDF
53
índice
Adaptación de Tkgate a Computadores (GNU).
4 MANUAL TKGATE
Copyright © 1987­2003 por Jeffery P. Hansen.
Este programa es software libre; puede distribuirlo y/o modificarlo bajo los términos de la G.P.L. (GNU General Public License) como publica la Fundación para el Software Libre (F.S.F.); en cualquier versión 2 de la licencia, o (en su caso) alguna versión posterior.
Este programa es distribuido con el deseo que será útil, pero SIN NINGUNA GARANTIA; sin ni siquiera la aplicada garantía COMERCIAL o LA DISPOSICIÓN PARA UN PROPOSITO PARTICULAR. Mire la G.P.L. para más detalles.
Debe haber recibido una copia de la G.P.L. (General Public License) con este programa; sino, escriba a la Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Tkgate es un editor gráfico y simulador de eventos para circuitos digitales basado en una interfaz Tcl/Tk. Los elementos del circuitos aportados incluyen puertas básicas (Y, O, etc.), puertas de triple estado, sumadores, multiplicadores, registros, memorias y transistores mos. Permite también el diseño jerárquico con soporte para los módulos diseñados por el usuario. El modo de guardar los ficheros esta basado en las listas de conexiones del formato Verilog.
CONTENIDOS:
1 Prefacio e introducción.
1.1 Introducción al TkGate.
1.2 Opciones de la linea de comandos.
1.3 Historia del TkGate.
2 Usando el editor.
2.1 La interfaz del TkGate.
2.2 Cargando y guardando circuitos.
2.3 Opciones del TkGate.
2.4 Herramientas básicas de edición.
2.5 Creación de puertas.
2.5.1 Crear una puerta usando la barra de menús.
2.5.2 Crear una puerta usando los atajos de teclado.
54
índice
Adaptación de Tkgate a Computadores (GNU).
2.5.3 Crear una puerta usando los menús emergentes.
2.6 Conectar las puertas.
2.7 Mover las puertas y los cables.
2.8 Editando las propiedades de las puertas.
2.8.1 Propiedades Generales.
2.8.2 Propiedades de los puertos.
2.8.3 Propiedades detalladas.
2.8.4 Propiedades de los retrasos.
2.9 Editando la propiedades de los cables.
2.10 Usando los módulos.
2.10.1 Editando las implementaciones de los módulos.
2.10.2 Editando las interfaces de los módulos
2.11 Buscando puertas y cables.
2.12 Hiperenlaces.
2.13 Imprimir un esquema.
2.14 Opciones del circuito.
2.15 Menús emergentes.
2.16 Tipos de puertas.
2.17 Resumen del menú.
2.18 Resumen de la barra de herramientas (Modo edición).
3 Usando el Simulador/Analizador.
3.1 Iniciando el simulador.
3.2 Opciones del simulador.
3.3 Observando la salida.
3.4 Controlando la entrada.
3.4.1 Conmutadores e interruptores dip.
3.4.2 Terminales (ttys).
3.5 Establecer puntos de interrupción.
3.6 Inicializar memorias.
3.7 Guiones de simulación.
3.8 Usando el informe de errores.
3.9 Fichero de retrasos de una puerta.
3.10 Análisis del camino critico.
55
índice
Adaptación de Tkgate a Computadores (GNU).
1 Prefacio e introducción.
1.1 Introducción al TkGate.
TkGate es un editor y simulador de circuitos digitales con una interfaz basada en Tcl/Tk. TkGate incluye un extenso número de dispositivos incorporados, incluyendo puertas básicas, memorias, ttys, y módulos para el diseño jerarquico. El simulador puede ser controlado interactivamente o mediante un guión de simulación. Los contenidos de la memorias se pueden cargar desde ficheros, y se incluye un compilador de macrocódigo y microcódigo (gmac) para crear ficheros de memoria TkGate con un alto nivel de descripción. El simulador soporta la simulación continua, simulación paso a paso (por tiempo o por ciclos), y puntos de interrupción. Guarda los ficheros en un formato parecido al Verilog.
Un circuito TkGate esta dividido en uno o más módulos, con uno de los módulos siendo designado como el de más alto nivel o módulo “administrador”. Un módulo esta compuesto por cero o más “puertas” y cables conectados a las puertas. Utilizamos el termino “puerta” para referirnos a algún elemento del circuito. Las puertas especiales “comentario” se usan para poner texto en el circuito.
Crear una puerta en TkGate es simplemente cuestión de hacer clic con el cursor para establecer una posición, y seleccionar el tipo de puerta del menú. Desde que la mayoría de tipos de puerta tienen uno o dos caracteres de atajo, una vez ha aprendido los atajos puede realizar la edición con una mano en el teclado y la otra en el ratón. Mover las puertas es casi tan fácil como crearlas, simplemente seleccione una puerta (o puertas) y arrastrelas hasta la nueva posición, algunos cables conectados a las puertas se moverán y ajustarán para asegurarse que solo contienen elementos horizontales y verticales.
1.2 Opciones de la linea de comandos.
Uso: tkgate [­xqs][­X guión][­l fichero][­L lenguaje]
[­P impresora] [­p fichero] [ficheros ...]
TkGate soporta las siguientes opciones: ­X guión
Inicia automáticamente el simulador y ejecuta el guión de simulación especificado.
­l fichero Lee el fichero especificado como una librería. ­x Inicia automáticamente el simulador.
­q Suprime los mensajes de inicio.
56
índice
Adaptación de Tkgate a Computadores (GNU).
­s Se ejecuta con una conexión síncrona a un servidor X. Esta opción es básicamente para la depuración.
­P impresora Imprime el circuito especificado en una impresora sin iniciar la G.U.I. (Interfaz gráfica de usuario).
­p fichero
Imprime el circuito especificado en un fichero sin iniciar la G.U.I. (Interfaz gráfica de usuario).
­L lenguaje Especifica el lenguaje a utilitzar ("en" para Ingles, "es" para español). El TkGate tiene que haber sido compilado con soporte para múltiples lenguajes para poder usar esta opción.
1.3 Historia del TkGate.
TkGate nace como el proyecto de un estudiante de la Universidad Carnegie Mellon en 1987. En ese tiempo se llamaba simplemente “gate” y se ejecutaba bajo el gestor de ventanas “wm”, un sistema de ventanas desarrollado en la Universidad Carnegie Mellon antes que el X11 fuese el más utilizado. Esta versión fue utilizada por los estudiantes de la asignatura de arquitectura de computadores en la C.M.U. para desarrollar un microprocesador sencillo (traducido “The Bat Computer”). Después de mantenerlo inactivo durante varios años, en 1991 resucito y migro para correr bajo X11 con la API Xlib. Esta versión fue utilizada varias veces por los estudiantes de la asignatura de introducción a la lógica digital, pero después que el autor se graduara y dejara la C.M.U., se volvió a hivernar otra vez. Esta versión en Tcl/Tk empezo en 1998. Aunque hay ciertamente código obsoleto en algunos lugares de la implementación debido a las múltiples reencarnaciones, muchas de las nuevas características se han añadido desde las versiones anteriores de “wm” y X11, y la interfaz se ha hecho de un uso más fácil.
2 Usando el editor.
2.1 La interfaz del TkGate.
Los componentes principales de la ventana de edición del TkGate consisten en una barra de menús y una barra de botones en la parte de arriba, las listas de módulos, conexiones y puertos a la izquierda, una barra de estado en la parte de abajo, y el área de edición en el centro. Las barras de desplazamiento se utilizan para desplazar el circuito, la lista de módulos o la lista de conexiones. La lista de “Módulos” en la parte superior izquierda de la ventana, lista los módulos que forman parte del circuito que esta siendo editado. El módulo “administrador” se indica con un símbolo '+' después de su nombre.
57
índice
Adaptación de Tkgate a Computadores (GNU).
Por debajo de la lista de módulos esta la lista de conexiones del módulo actual. Las conexiones con múltiples bits se denotan con un rango de bits después del nombre. Los nombres de las conexiones pueden estar “ocultos” o “visibles” dependiendo si se visualizan en el circuito. Las conexiones ocultas se denotan en la lista de conexiones con un símbolo '@'. El símbolo 'X' en la ventana de edición es la marca actual. La marca se utiliza para indicar la posición de las nuevas puertas.
Puede acceder a los comandos más utilizados mediante la barra de botones. Está incluye comandos para abrir, guardar e imprimir ficheros de circuito, cambiar la herramienta de edición, abrir y cerrar módulos y controlar el simulador. Desde la barra de botones podemos seleccionar la tecnología por defecto para las nuevas puertas. Mire en “Editando las propiedades de las puertas” para más información sobre las tecnologías de las puertas.
La barra de estado en la parte de abajo indica el fichero que se esta editando, y el módulo actual que se esta visualizando.
Un símbolo '*' después del nombre del fichero indica que el buffer ha sido modificado desde la ultima vez que se salvo el fichero. Por debajo del nombre del fichero y del módulo hay una barra de mensajes donde el TkGate nos da información. Estos mensajes incluyen confirmaciones para circuitos guardados o cargados, o información sobre el cable o la puerta 58
índice
Adaptación de Tkgate a Computadores (GNU).
seleccionados.
En la parte inferior derecha de la interfaz esta el icono de modo. Los posibles iconos de modo son:
Modo Edición
Modo Simulación (simulador parado)
Modo Simulación (simulador activo)
Modo Análisis
Las “burbujas de ayuda” estan disponibles para muchos de los elementos de la interfaz. Para usar las burbujas de ayuda, simplemente mueva el ratón por encima de un elemento de la interfaz. Después de un segundo, se mostrará un mensaje de información hasta que el ratón se vuelva a mover. Por ejemplo, moviendo el cursor por encima de la etiqueta “Conexiones” en la ventana principal producirá una burbuja de ayuda como la mostrada abajo:
Las burbujas de ayuda estan también disponibles en la mayoría de los cuadros de dialogo, pasando el cursor sobre el texto en el cuadro de dialogo para una descripción más detallada.
59
índice
Adaptación de Tkgate a Computadores (GNU).
2.2 Cargando y guardando circuitos.
Abrir y guardar circuitos, como las operaciones de impresión de circuitos se hacen desde el menú “Fichero” en la ventana principal.
Para cargar el fichero en el TkGate, puede especificar un nombre de fichero en la linea de comandos o seleccionar “Abrir...” del menú “Fichero”. También puede utilizar los atajos de teclado Ctrl­X Ctrl­F. Cuando abrimos un nuevo fichero, todos los módulos existentes serán eliminados del buffer, y se cargarán los módulos existentes en el nuevo fichero.
TkGate guardara los ficheros con la extensión “.v” y con un formato parecido al Verilog. La mayor diferencia es que añaden comentarios de información como elementos del circuito y posiciones de cables. Las librerías se cargan usando la opción “Abrir librería...”. Los módulos de la librería se añadirán al circuito actual y se marcarán como módulos de librería. Sin embargo, algunos de los módulos que no estén vacíos y que no pertenezcan a la librería no se sobrecargaran. Además, algunos módulos marcados como módulos de librería no se guardarán cuando guardemos el circuito. Los módulos de librería se denotan en la lista de módulos con paréntesis, y se pueden convertir en módulos de usuario utilizando el comando “Módulo librería ­> Módulo usuario...” en el menú “Módulo”. Para guardar el circuito, selecciona “Salvar” para guardarlo en el fichero actual o “Salvar como...” para especificar un nombre de fichero donde guardarlo.
Todas las operaciones que abran o guarden un fichero utilizan un cuadro de dialogo como el siguiente:
para seleccionar los ficheros. Introduzca el nombre del fichero y pulse el boton de “Abrir” (o “Guardar”), o haga doble clic en el nombre del fichero. Solamente verá los ficheros con el tipo apropiado. Puede cambiar de directorio haciendo doble clic en un directorio para abrirlo, o usando el boton de la esquina superior derecha para subir a un nivel superior.
60
índice
Adaptación de Tkgate a Computadores (GNU).
2.3 Opciones del TkGate.
TkGate tiene varios parámetros configurables por el usuario que pueden ser establecidos seleccionando “Opciones...” del menú “Fichero”. Las opciones estan divididas en cuatro categorías principales. Estos parámetros se guardan en el fichero “.tkgate­preferences” en el directorio base del usuario, que se lee cada vez que se inicia el TkGate. Las opciones generales, las de impresión y las de color se describen abajo. Las opciones de simulación se describen en la sección “Opciones del simulador”.
Las opciones básicas son:
61
●
Nombre de la empresa: Indica el nombre de la organización donde esta la copia del TkGate instalada. Este string se utilizará en todos los informes generados por el TkGate.
●
Desplazamiento suave: Si esta opción esta activa, el desplazamiento en la ventana principal se realizará usando copias de mapas de bits más que refrescos de pantalla, mejorando significativamente la realización del desplazamiento. Si su servidor X tiene problemas con las copias de mapas de bits, puede desactivar esta característica.
●
Actualizar región: Controla el algoritmo de refresco de pantalla. Activando esta opción, los eventos de refresco solo refrescarán la parte de la pantalla que cambia mejor que la pantalla entera. Normalmente esta opción se deja activa, pero en servidores con implementaciones clipping (recorte de pantalla para que sea actualizada) pobres, activar esta característica dará como resultado un refresco de pantalla más lento.
●
Recuadro en desplazamiento de módulos: Esta opción se usa para reducir el tiempo de refresco en servidores muy lentos. Activando esta opción desactivaremos el refresco dinámico de las instancias de los módulos (y los cables conectados a ellas) mientras se índice
Adaptación de Tkgate a Computadores (GNU).
mueven. En lugar de mover solo el contorno de la instancia y mover los cables cuando la instancia este situada.
●
Habilitar globos de ayuda: Activando esta opción se mostrarán ciertos mensajes de ayuda cuando pasemos el ratón por ciertos elementos de la interfaz de usuario.
●
Habilitar depuración: Activa ciertas características útiles para depurar el TkGate.
●
Modo novato: Esta opción provoca que se cargue el circuito tutorial cuando se inicia el TkGate. El tutorial solo aparecerá solo si no se especifica un circuito en la linea de comandos. Deseleccionando esta opción desactivaremos la carga del circuito tutorial.
●
Realizar chequeo de puntos/frecuencia: Esta opción activa el chequeo periódico de ficheros no guardados. El fichero de chequeo tendra el mismo nombre que el fichero que se esta editando pero entre caracteres '#'. Se guardará en el directorio actual. La frecuencia especifica el intervalo de tiempo en segundos entre chequeos.
●
Nivel máximo deshacer: Esta opción especifica el número máximo de operaciones que se pueden deshacer con la característica deshacer/rehacer.
Las opciones de impresión son:
●
62
Comando de impresión: Si seleccionamos la impresión en una impresora, este campo indica el comando utilizado para imprimir el fichero. El comando se abre como una tubería y se escribe código postscript en su entrada estándar. índice
Adaptación de Tkgate a Computadores (GNU).
●
Tamaño del papel: Indica el tamaño del papel del documento. Si su impresora tiene varias bandejas, se selecciona la apropiada. Podemos elegir entre varias medidas de papel de E.U, Europeas y Asiáticas.
●
Orientación: Indica la orientación del diagrama en la página. Si selecciona “Vertical” la imagen se imprimira de modo que el lado largo del papel esta en vertical. Si selecciona “Apaisada” la imagen se imprimirá de modo que el lado corto del papel esta en vertical.
●
Imprimir a doble cara: Indica que las imágenes se imprimiran en las dos caras del papel. Esta opción solamente es valida en impresoras con capacidad para imprimir a doble cara.
●
Escalar los módulos hasta completar la página: Los módulos que no puedan ajustarse a una página, serán reducidos para que puedan ajustarse.
●
Dividir módulos grandes en varias páginas: Los módulos que no se ajusten en una página, se dividirán en múltiples páginas. En la esquina inferior derecha de la página se imprimira una clave indicando que porción de página representa.
●
Incluye índice: Imprime una página donde se listan todos los módulos ordenados por orden alfabético y las páginas donde estan.
●
Incluye gráfico de jerarquia: Imprime un gráfico de jerarquia, tomando como raíz el módulo de más alto nivel, mostrando las relaciones entre módulos padre e hijos.
●
Imprimir cuatro módulos pequeños por página: Se imprimen en la misma página los módulos que puedan ser ajustados en un cuadrante.
Las opciones de color son:
63
índice
Adaptación de Tkgate a Computadores (GNU).
●
Instancias: Establece el color usado para las puertas primitivas y sus etiquetas.
●
Módulos: Establece el color usado para los módulos, excepto para los nombres de los puertos.
●
Puertos de módulos: Establece el color usado para los nombres de los puertos en los módulos.
●
Marcos: Establece el color usado para los marcos.
●
Comentarios: Establece el color para los comentarios normales.
●
Hiperenlaces: Establece el color para los comentarios de tipo hiperenlace.
●
Cables simples (1 bit): Establece el color para los cables de un solo bit y sus etiquetas.
●
Buses: Establece el color usado para los cables de más de un bit y sus etiquetas.
●
Herramientas de puerta: Establece el color para los objetos que no sean cursores usados por el TkGate (ej. puntas de prueba).
●
Rejilla de ámbito: Establece el color para la rejilla en la ventana de ámbito.
●
Lógica '1': Establece el color para los valores lógicos deterministas, que no sean cero, en el ámbito lógico.
●
Lógica '0': Establece el color para los valores lógicos cero en el ámbito lógico.
●
Conflicto desconocido: Establece el color para los valores lógicos desconocidos, incluyendo el nivel “bajo” y el nivel “alto”, en el ámbito lógico.
●
LED apagado: Establece el color para los LEDs que estan apagados.
●
LED encendido: Establece el color para los LEDs que estan encendidos.
●
LED flotante: Establece el color para los LEDs para los cuales la entrada no es ni un 0 ni un 1, en el ámbito lógico.
2.4 Herramientas básicas de edición.
Cursor Atajo de teclado
F1
(F1)
64
Descripción
Esta herramienta se utiliza para la mayor parte de la edición, como crear puertas, conectar cables, mover puertas y cables, abrir instancias de módulos, abrir cuadros de propiedades de cables y puertas, y eliminar elementos del circuito (con la tecla “suprimir”).
Para utilizar esta herramienta primero seleccione la herramienta para mover/conectar, pulse y mantenga el boton derecho del ratón en el índice
Adaptación de Tkgate a Computadores (GNU).
Cursor Atajo de teclado
Descripción
punto final de un cable. El cursor cambiara al soldador mientras mantenga pulsado el boton.
F2
Utilice esta herramienta para eliminar puertas. Las puertas se pueden eliminar también usando la herramienta de mover/conectar y la tecla “suprimir”.
F3
Utilice esta herramienta para cortar cables, pulsando con el ratón en el punto del cable que quiera cortar. Si corta un cable que no tiene conectada ninguna puerta en uno de sus extremos, se eliminará automáticamente el segmento de cable entre el final del cable y el punto de corte.
F4
Utilice esta herramienta para añadir o eliminar burbujas inversoras en las entradas y salidas de las puertas. Haga clic con el cursor cerca de una entrada o salida para convertir el puerto no inversor en inversor y viceversa.
F5
Utilice esta herramienta para cambiar el ancho de banda de un cable. Cuando seleccionemos este modo de edición, aparecerá un cuadro de dialogo en la esquina inferior derecha de la ventana principal donde podremos introducir el ancho de banda. Haciendo clic a los cables cambiaremos el tamaño de los cables. También puede cambiar el ancho de banda usando los cuadros de dialogo de cables o puertas.
2.5 Creación de puertas.
Hay tres formas para crear puertas en TkGate: usando la barra de menús, usando los menús emergentes, y usando los atajos de teclado. Una vez ha memorizado los atajos de teclado, esta es la forma preferida de crear puertas. Estos tres métodos se describen en las siguientes secciones:
65
índice
Adaptación de Tkgate a Computadores (GNU).
2.5.1 Crear una puerta usando la barra de menús.
Para crear una puerta, como una puerta NAND primero seleccione la herramienta para mover/conectar y pulse el boton izquierdo del ratón donde quiera crearla. El cursor cambiará a una flecha mientras mantenga pulsado el botón, indicando la orientación actual. En el caso mostrado la orientación actual es de 0 grados, indicando la orientación estándar.
Cuando suelte el boton del ratón desaparecerá la flecha permaneciendo la marca de posición. La marca especifica el punto central del nuevo circuito. Si pulsamos el boton del ratón en otra posición cambiaremos la marca de lugar y seleccionando una puerta o un cable haremos que desaparezca la marca.
Seleccione el tipo de puerta abriendo el menú “Insertar”. Los elementos de circuito estan organizados en cinco tipos básicos. El tipo “Entrada/salida” incluye conmutadores, interruptores dip, fuentes de alimentación, relojes, etc. El tipo “Puerta” incluye las puertas lógicas básicas como puertas AND y OR. El tipo “Reducción” incluye versiones reducidas de las puertas básicas que combinan señales de múltiples bits en un único bit, el tipo “MSI” incluye registros, sumadores, multiplicadores, desplazadores, etc. Finalmente el tipo “Módulo” incluye módulos definidos por el usuario y los puertos de los módulos.
66
índice
Adaptación de Tkgate a Computadores (GNU).
Después de seleccionar la opción del menú o de teclear el atajo se creará y se mostrará el circuito resaltado para indicar que esta seleccionado.
2.5.2 Crear una puerta usando los atajos de teclado.
Para crear una puerta usando los atajos de teclado primero establezca la marca de edición de la misma forma que cuando creamos una puerta usando la barra de menús (sección 2.5.1). Entonces simplemente teclee el atajo de la puerta que quiera crear. La mayoría de los tipos de puerta tiene un carácter simple para crearlos. Por ejemplo, puede pulsar 'a' para crear una puerta AND, y una 'A' para crear una puerta NAND. En la sección 2.10 se muestra una lista de tipos de puerta y sus atajos.
2.5.3 Crear una puerta usando los menús emergentes.
Para crear una puerta usando el menú emergente, haga clic con el boton derecho del ratón en la posición donde quiera crear la puerta. Esto creará la marca de posición y desplegara el menú emergente. Entonces seleccione “Insertar” y muévase por las categorías de puertas para seleccionar el tipo apropiado.
67
índice
Adaptación de Tkgate a Computadores (GNU).
2.6 Conectar las puertas.
Conectar un cable a otro
Para conectar los puertos de dos puertas, primero seleccione la herramienta de mover/conectar del menú de herramientas. Pulse el boton izquierdo del ratón en el final de uno de los cables. El cursor cambiara al soldador para indicar que el modo de conexión esta activo.
Arrastre el ratón hacia el otro cable donde quiera conectarlo, el TkGate introducirá automáticamente segmentos horizontales y verticales para mantener las conexiones.
Finalmente, suelte el boton del ratón cerca del punto final del cable donde quiere conectarlo.
El TkGate conectará los cables.
Conectar tres o más cables en una misma conexión
Para conectar un cable a un segmento ya conectado, seleccione el cable que quiere conectar para poder cambiar al modo de conexión.
68
índice
Adaptación de Tkgate a Computadores (GNU).
Arrastre el cable cerca de donde quiera conectarlo.
Cuando suelte el cable, este se conectará al segmento cercano y creará un punto de soldadura.
Puede continuar el proceso conectando todos los puertos necesarios.
2.7 Mover las puertas y los cables.
Mover una sola puerta
Para mover una sola puerta, pulse y mantenga el boton izquierdo del ratón en la puerta que quiera mover. La puerta seleccionada se resaltará.
Manteniendo pulsado el boton del ratón, arrastre la puerta hasta la nueva posición. Algunos de los cables se moverán con la puerta. También puede mover la puerta seleccionada usando las teclas de cursor.
69
índice
Adaptación de Tkgate a Computadores (GNU).
Mover un grupo de puertas
Para mover un grupo de puertas seleccione la herramienta de mover/conectar. Pulse y mantenga el boton izquierdo del ratón en algun punto cercano, per no directamente, del grupo que quiere mover. La marca de posición debe aparecer como si fuese a crear una puerta. Después, manteniendo el boton pulsado, arrastre el cursor hasta encerrar el grupo de puertas. Después de mover unos pocos milímetros aparecerá el cuadro. Suelte el boton para seleccionar los elementos del circuito encerrados en el cuadro. Las puertas se mantendran seleccionadas hasta que haga clic en otra puerta que no este en la selección o en una parte vacía del área de edición. Si hace esta operación mientras mantiene pulsada la tecla de control, podrá añadir puertas a la selección, más que crear una nueva selección.
Después de seleccionar el grupo de puertas, haga clic y mantenga el cursor en uno de los elementos relacionados.
Ahora puede mover el grupo entero a la nueva posición.
2.8 Editando las propiedades de las puertas.
Los parámetros de una puerta se pueden editar haciendo doble clic en la puerta, o seleccionando la puerta y ejecutando el comando “Propiedades...” del menú “Puerta”. El cuadro de dialogo de propiedades contiene cuatro páginas que se pueden seleccionar con las pestañas de la parte superior.
70
índice
Adaptación de Tkgate a Computadores (GNU).
La página “General” contiene las propiedades básicas que son comunes a todas las puertas, la página “Puerto” permite la edición de los puertos de la puerta, la página opcional “Detalles” contiene propiedades adicionales que son especiales en tipos particulares de puertas, y la página opcional “Retraso” permite la edición de los retrasos de las puertas.
2.8.1 Propiedades Generales.
Las propiedades que se pueden editar en la página General son:
71
●
Tipo de puerta: El tipo de puerta. Esta propiedad no se puede modificar.
●
Nombre de la puerta: El nombre de la puerta. Debe ser un identificador único para la puerta dentro del módulo. Los nombres de las puertas deben empezar por una letra o por el carácter '_' y deben contener solo letras, números y el carácter '_'. Si intenta usar un nombre que esta siendo utilizado por otro elemento del circuito, o intenta usar caracteres ilegales, se ajustará automáticamente el nombre eliminando los caracteres ilegales o añadiendo caracteres.
●
Nombre oculto: Este campo indica si debe o no mostrar el nombre de la puerta. Por defecto no se mostrarán los nombres de las puertas.
índice
Adaptación de Tkgate a Computadores (GNU).
●
Anclada: Este campo indica si la puerta se puede mover usando el ratón. Una selección de puertas que contengan alguna puerta que tenga esta opción activa no se podrá mover.
●
X/Y: Posición de la puerta en la pantalla. Los valores pueden ser editados si la puerta esta anclada.
●
Ruptura del camino crítico: Hace que el circuito sea un punto de ruptura para el análisis de caminos críticos. Los caminos por los cuales pasen elementos que tengan esta propiedad no serán considerados al analizar los caminos críticos.
2.8.2 Propiedades de los puertos.
La página de “Puerto” contiene una lista de puertos en la puerta seleccionada. Para editar los puertos de la puerta haga doble clic en el puerto que desea modificar, o seleccione un puerto y pulse el boton “Editar...”. Aparecerá un cuadro de dialogo con los parámetros del puerto. Puede cambiar el nombre de la señal o el ancho de banda pero el nombre del puerto y el tipo no se podran editar.
También puede usar los botones “Añadir...” y “Borrar” para añadir puertos o borrar puertos, pero solo en algunos tipos de puertas.
72
índice
Adaptación de Tkgate a Computadores (GNU).
Las propiedades de los puertos son:
●
Nombre de la señal: El nombre debe ser único dentro del módulo y tiene las mismas restricciones que los nombres de las puertas.
●
Nombre del puerto: Nombre del puerto donde la señal esta conectada. El nombre del puerto solo se puede cambiar en las instancias de los módulos.
●
Tipo: La dirección (entrada, salida, bidireccional) del puerto. El tipo solo se puede cambiar en las instancias de los módulos.
●
Anchura bus: Número de bits en la señal.
2.8.3 Propiedades detalladas.
73
índice
Adaptación de Tkgate a Computadores (GNU).
La página de detalles de los parámetros de la puerta se utiliza para establecer propiedades especiales para ciertos tipos de puertas. El ejemplo mostrado a la derecha es el “reloj”. Puede establecer la anchura del ciclo, la fase y la función, editando los campos o moviendo la forma de onda con el ratón. La anchura del ciclo es el número de periodos en un ciclo de reloj, la fase es el porcentaje del ciclo de reloj en el que la simulación empezará, y la función es el porcentaje de tiempo en el ciclo de reloj que el reloj esta a nivel alto.
Otros tipos de puertas que tiene parámetros detallados son los módulos, que requieren un nombre de función, las memorias, donde podemos especificar un fichero de inicialización, y los conmutadores para los que podemos especificar el valor inicial.
Pocos tipos de puerta tienen los cuadros de propiedades que sean únicos para el tipo de puerta. Por ejemplo, los puertos de los módulos tienen un cuadro de dialogo similar al cuadro de dialogo para las conexiones, descritas en la próxima sección, y los comentarios tienen cuadros de dialogo consistentes en una entrada de texto para actualizar el texto del comentario.
2.8.4 Propiedades de los retrasos.
Podemos fijar los retrasos de las puertas especificando una tecnología estándar o 74
índice
Adaptación de Tkgate a Computadores (GNU).
personalizando los retrasos para cada puerta individual. Para usar una tecnología estándar, seleccione de la opción “Retraso Normal” una de las tecnologías usando el boton selector. Puede elegir una de las tecnologías que incorpora el TkGate, “default” o “unit” o añadir definiciones adicionales de tecnologías (mire Fichero de retrasos de una puerta para más detalles). La tecnología “default” esta basada en los retrasos CMOS, y la tecnología “unit” simplemente asigna como retraso un periodo único para todo. Tenga en cuenta que los valores de los retrasos mostrados pueden verse afectados por el ancho de bus de los puertos, el número de puertos y la existencia o ausencia de inversores en los puertos de las puertas. En algunos casos, añadiendo un inversor puede decrementar el valor del retraso (ej. añadiendo un inversor para cambiar una puerta AND a una NAND).
Para establecer los valores de los retrasos para una puerta individual, seleccione “Retraso personalizado” e introduzca los valores para cada uno de los parámetros en periodos. Los valores de los retrasos deben ser valores enteros entre 1 y 4095.
2.9 Editando la propiedades de los cables.
Las propiedades de los cables se pueden editar haciendo doble clic en un cable o haciendo doble clic en el nombre de la conexión de la lista de “Conexiones” y ejecutando el comando “Propiedades...” del menú “Puerta”.
Las propiedades de las conexiones son:
75
●
Nombre Conexión: El nombre de la señal de la conexión. Los nombres de las señales deben empezar con una letra o con el carácter '_' y deben contener letras, dígitos y el carácter '_'. Si intentamos reusar un nombre dentro de un módulo, o usar un carácter ilegal, se ajustara el nombre eliminando los caracteres ilegales, o añadiendo caracteres. Los nombres de las señales que empiezan por '_' se mostrarán con una barra por encima, indicando una señal activa a nivel bajo. en este caso el carácter '_' por si solo no se mostrará.
●
Nombre oculto: Esta campo indica se se muestra o no el nombre de la señal. Por defecto no se mostrarán los nombres de las señales.
●
Anchura Bus: Número de bits de la señal.
índice
Adaptación de Tkgate a Computadores (GNU).
●
Tipo: La dirección (entrada, salida, bidireccional) si esta señal es un puerto de un módulo. Si la señal no es un puerto de un módulo, no se mostrará este campo.
2.10 Usando los módulos.
La definición de un módulo consta de dos puertos, una implementación y de una interfaz. La implementación es el contenido del módulo, y la interfaz define la apariencia de las instancias de los módulos incluyendo el tamaño de las instancias de los módulos, las posiciones de los puertos y las direcciones de los puertos alrededor del módulo. Las definiciones de los módulos se pueden manipular usando las opciones “Nuevo...”, “Borra...”, “Copia...”, “Renombra...” y “Módulo librería­>Módulo usuario...” del menú “Módulo”. Los módulos se pueden usar para diseños jerárquicos. Para crear un módulo, establezca la marca de posición y seleccione “Inserta módulo” del submenú “Módulo” del menú “Insertar”. Aparecerá un cuadro de dialogo como el anterior donde introduciremos el nombre de la función. La función especifica el tipo de módulo. Puede usar alguno de los nombres de función listados en la lista de “Módulos” en la parte izquierda de la pantalla, o crear un nuevo tipo de módulo introduciendo un nuevo nombre. Cuando establezcamos el nombre para uno nuevo se creará la interfaz estándar del módulo. Mire en la sección Interfaces de módulos para más detalles.
76
índice
Adaptación de Tkgate a Computadores (GNU).
2.10.1 Editando las implementaciones de los módulos.
Para editar el contenido de un módulo, haga doble clic en el nombre del módulo en la lista de “Módulos” en la parte izquierda de la ventana principal. Otra alternativa es seleccionar la opción “Abrir” del menú “Módulo”.
Dentro del módulo podemos usar algunas de las puertas que usaríamos a un nivel más alto incluyendo instancias de módulo. Las puertas especiales “Entrada módulo”, “Salida módulo” y “Bidireccional módulo” del submenú “Módulo” del menú “Insertar” se utilizan para indicar conexiones internas para los puertos. Para cada nombre de puerto, solo podemos crear un solo puerto. Cuando creamos un puerto, aparecerá un cuadro de dialogo permitiéndonos establecer el nombre del puerto.
2.10.2 Editando las interfaces de los módulos.
Para añadir puertos a un módulo haga clic con el boton derecho del ratón cerca del borde del módulo y seleccione una de las opciones “Añade” del menú emergente. Aparecerá un cuadro de dialogo permitiéndole editar el nombre del puerto.
Puede ajustar la posición del puerto arrastrándolo por todo el borde, seleccionándolo cerca del borde de la instancia del módulo.
Para eliminar un puerto, use el cortador de cables y haga clic sobre el borde de la instancia del módulo. Los módulos pueden ser re­dimensionados arrastrando uno de los bordes o esquinas. También puede cambiar el tipo (entrada, salida, bidireccional) de un puerto, haciendo clic con el boton derecho del ratón sobre el puerto y seleccionando la opción “Cambiar Tipo”, o haciendo doble clic en él y seleccionar el tipo mediante un cuadro de dialogo.
Para cada instancia de módulo, hay una medida “estándar”, que se usa cuando creamos instancias de nuevos módulos. Puede hacer que la instancia de un módulo existente sea la implementación estándar para ese tipo de módulos seleccionándolo y eligiendo la opción “Ajustar Interfaz” del menú “Módulo”. También puede seleccionar la opción “Editar interfaces...” de menú “Módulo” donde cambiará a una pantalla especial que muestra las instancias de todos los tipos de módulos definidos. Puede editar los tamaños, añadir o eliminar puertos, o modificar las posiciones de los puertos de los módulos mostrados. Para salir de la ventana de interfaces, seleccione la opción “Cerrar” del menú “Módulo”, o haga doble clic en alguno de los módulos de la lista de “Módulos”.
77
índice
Adaptación de Tkgate a Computadores (GNU).
2.11 Buscando puertas y cables.
Puede buscar cables y puertas en algun sitio de su circuito usando la opción “Buscar...” del menú “Editar”. Introduzca texto en el cuadro de dialogo y pulse “Buscar” para encontrar las ocurrencias de puertas o cables que contengan el texto especificado como parte de sus nombres. Cada vez que pulse el boton “Buscar”, TkGate avanzará al siguiente resultado, seleccionará la puerta o cable y la marcará con una aspa. También puede elegir limitar la búsqueda solo a puertas o solo a cables. La búsqueda se reiniciará cuando cambie el texto que esta buscando, cuando cambie el modo de búsqueda o cuando realicemos modificaciones en el circuito.
2.12 Hiperenlaces.
El 78
índice
Adaptación de Tkgate a Computadores (GNU).
Tkgate tiene una capacidad de hiperenlace limitada mediante la puerta “Comentario”. Cuando hacemos clic en un hiperenlace, se realizará alguna acción como abrir un fichero nuevo o buscar una puerta o cable.
Tenga en cuenta que haciendo clic en un hiperenlace causará que alguna acción deba ser realizada, por tanto, es necesario pulsar y mantener una tecla de modificación para poder moverlo o seleccionarlo (Shift, Control, o Alt).
Para crear un hiperenlace, crear o editar un comentario, establezca el campo “El Texto es un Hiperenlace” e introduzca la dirección del enlace en el campo “Enlace a Fichero”. Cuando especifique un fichero, debe usar los siguientes códigos que se reemplazarán de acuerdo con la siguiente tabla:
Código
Reemplazo
@T
Directorio del tutorial del TkGate
@E
Directorio de ejemplos del TkGate
@H
Directorio raíz del TkGate
@C
Directorio del circuito actual
Si el fichero especificado es un circuito, se descartará el fichero actual y se cargará el nuevo fichero. Si hay cambios en el fichero actual que no se han guardado y el circuito no esta marcado con la opción “Descartar Cambios”, aparecerá un cuadro de confirmación antes de seguir el enlace. Si el fichero especificado no es un circuito, se mostrará el texto contenido en el fichero en una ventana aparte. Puede forzar que un fichero sea tratado como un fichero Verilog, anteponiendo el string “tkgate:”, y forzar que sea tratado como texto anteponiendo “text:”. Si un enlace contiene el carácter '#', el texto que hay detrás se trata como el nombre de una puerta o un cable. Cuando TkGate siga este enlace, buscará la puerta especificada y lo marcará con una aspa. En el caso especial en el que el enlace empiece por un '#', la búsqueda se realiza en el circuito actual. La puerta o cable especificado debe tener la ruta completa. Por ejemplo, tenemos el cable “w4” en una instancia de un módulo con nombre “m1” (no el nombre de la función), lo especificaríamos con el enlace “#m1.w4”.
2.13 Imprimir un esquema.
Para imprimir un circuito selecciona la opción “Imprimir...” del menú “Fichero”. Puede imprimirlo en una impresora, especificando el comando de impresión, o imprimirlo en un fichero. Cuando imprima una única página en un fichero, también puede elegir guardar el circuito en postscript encapsulado. Esto suprimirá la impresión del marco de la página y del titulo.
79
índice
Adaptación de Tkgate a Computadores (GNU).
Las opciones de impresión son:
80
●
Salida a: Indica si la salida generada se escribirá en un fichero o se enviará directamente a una impresora.
●
Comando de impresión: Si seleccionamos la salida hacia la impresora, este campo indica el comando utilizado para imprimir el fichero. El comando se abre como una tubería y se escribe postscript en su entrada estándar.
●
Nombre del fichero: si seleccionamos la salida hacia un fichero, este campo indica el nombre del fichero de salida. El nombre por defecto es el nombre del circuito actual renombrando la extensión a “.ps”. Puede usar el boton “Visualizar” para abrir un cuadro de dialogo para seleccionar el nombre del fichero.
●
Salvar como postscript encapsulado: Si esta opción esta activa, se salvará el circuito como un fichero postscript encapsulado útil para la inclusión en documentos. Se suprimirá la impresión de la barra de titulo y el marco. Solo es posible utilizar esta opción en documentos de una sola página.
●
Tamaño del papel: Indica el tamaño del papel del documento. Si su impresora tiene varias bandejas se seleccionará la apropiada. Se proporcionan varias medidas de papel de E.U., Europa y Asia.
●
Orientación: Indica la orientación del diagrama en la página. Si selecciona “Vertical” la imagen se imprimirá de modo que el lado largo del papel este en vertical. Si selecciona “Apaisada” la imagen se imprimirá de modo que el lado corto del papel esta en vertical.
●
Imprimir a doble cara: Indica que las imágenes se imprimirán en las dos caras del papel. Esta opción solamente es valida en impresoras con capacidad para imprimir a doble cara.
●
Titulo del documento: Este string se imprimirá en cada una de las páginas. Por defecto es el nombre del fichero del circuito.
●
Escalar módulos hasta completar página: Los módulos que no puedan ajustarse a una página, serán reducidos para que puedan ajustarse.
●
Dividir módulos grandes en varias páginas: Los módulos que no se ajusten a una pagina se dividirán en múltiples páginas. En la esquina inferior derecha de la página se imprimirá una clave indicando que porción de página representa.
●
Incluye índice: Imprime una página donde se listan todos los módulos ordenados por orden alfabético y las páginas donde estan.
●
Incluye gráfico de jerarquía: Imprime un gráfico de jerarquía, tomando como raíz el módulo de más alto nivel, mostrando las relaciones entre los módulos padre e hijos.
●
Imprimir cuatro módulos pequeños por página: Se imprimen en la misma página los módulos que se puedan ajustar en un cuadrante.
●
Imprimir módulos: Indica los módulos deben ser imprimidos:
■
Todo: Se imprimirán todos los módulos.
■
Actual: Solo se imprimirá el módulo que se muestra en la ventana de edición.
índice
Adaptación de Tkgate a Computadores (GNU).
●
■
Usados: Se imprimirán el módulo raíz y sus submódulos.
■
Seleccionados: Solo se imprimirán los circuitos seleccionados en el cuadro de abajo.
Incluye módulos de librería: Normalmente los módulos marcados como módulos de librería no se imprimen. Activando esta opción imprimirá estos módulos.
2.14 Opciones del circuito.
Los circuitos tienen varias propiedades globales que se pueden establecer seleccionando la opción “Propiedades del circuito...” del menú “Circuito”. Las opciones de los circuitos son:
81
●
Módulo principal: El módulo principal es el módulo de más alto nivel en el circuito. Seleccione un módulo de la lista para hacerlo el módulo raíz. El módulo principal no debe contener instancias de puertos.
●
Guiones de inicialización: Indica la lista de guiones de simulación que ejecutará automáticamente cuando inicie el simulador. Si un nombre de fichero no empieza por '/', el índice
Adaptación de Tkgate a Computadores (GNU).
directorio actual, se buscará en el directorio donde se encuentra el fichero del circuito y en el directorio del usuario.
●
Versión del fichero: Esta es la versión del TkGate bajo la que el fichero fue editado y guardado.
●
Descartar cambios: Activando esta opción desactivaremos los mensajes de aviso cuando se descartan las modificaciones realizadas en el circuito.
●
Usar barras extensoras: Esto determina si se deben usar las barras extensoras al crear nuevas puertas. Esto no afecta a las puertas existentes y un circuito puede estar formado con puertas con los dos estilos.
2.15 Menús emergentes.
A muchas de las características descritas en este manual puede acceder usando los menús emergentes. Los menús emergentes se abren pulsando el boton derecho del ratón, y los contenidos del menú dependen del objeto seleccionado. Los contextos en los que TkGate podrá abrir los menús emergentes se muestran en la siguiente tabla:
82
Contexto
Descripción
Cable
Los menús emergentes para los cables permiten abrir los cuadros de propiedades o añadir un segmento de cable para permitirle conectar otra puerta o cable.
índice
Adaptación de Tkgate a Computadores (GNU).
Contexto
Descripción
Puerta
Los menús emergentes comunes para las puertas permiten abrir el cuadro de propiedades, anclar la puerta o eliminar la puerta.
Puertas con múltiples entradas
Para puertas con múltiples entradas como la AND y la OR, también puede añadir entradas además de las funciones estándar de las puertas
Selección de múltiples puertas
Cuando seleccionemos varias puertas, podremos anclar todas las puertas o eliminar todo el grupo.
Junta de soldadura con 4 cables
El menú emergente para juntas con cuatro cables conectados contiene solo el campo anclada.
Junta de soldadura con 3 cables
Para juntas con tres cables conectados tenemos la opción de añadir un segmento de cable.
Módulo
Además de las funciones estándar para las puertas, el menú emergente para los módulos también permite abrir el bloque, marcar el bloque como la interfaz estándar para el tipo de módulo y añadir/cambiar puertos en el módulo.
Área de edición
Haciendo clic con el boton derecho del ratón en una zona del área de edición sin objetos aparecerá un menú emergente con las opciones para cerrar el módulo actual, crear una puerta o cambiar de herramienta.
Modo Borrar puerta
Modo Cortar cable
Modo Invertir
Modo Anchura del Bus
Simulación
83
Cuando TkGate esta en uno de estos modos, solo esta activa la opción de cerrar el módulo y cambiar la herramienta.
Si estamos en modo simulación, el menú emergente permitirá usar alguna de las funciones del menú “Simulación”.
índice
Adaptación de Tkgate a Computadores (GNU).
2.16 Tipos de puertas.
Nombre
Y
O
O
exclusiva
Búfer
Clave(s)
and, nand
or, nor
xor, xnor
buf, not
Búfer
bufif1, bufif0
Triestado notif1, notif0
84
Atajo(s)
Símbolo
Descripción
a
A
Su salida es la Y lógica de las señales de la entrada. Todas las entradas deben tener el mismo número de bits que la salida, o ser de un solo bit. En el caso de una puerta con entradas de múltiples bits y entradas de un bit, asumiremos que las entradas de un solo bit estan conectadas a todos los bits de las entradas con múltiples bits.
o
O
Su salida es la O lógica de las señales de entrada. Todas las entradas deben tener el mismo número de bits que la salida o ser de un solo bit. En el caso que la puerta tenga entradas de un solo bit y entradas de múltiples bits, se replicarán las entradas de un solo bit para todos los otros bits.
x
X
Su salida es la O exclusiva de las señales de entrada. Todas las entradas deben tener el mismo número de bits que la salida o ser de un solo bit. En el caso que la puerta tenga entradas de un solo bit y entradas de múltiples bits, se replicarán las entradas de un solo bit para todos los otros bits.
b
I
Guarda la señal de entrada. Si la entrada no es el valor lógico 0 o el 1 lógico (ej. flotante) la salida será la señal desconocida. Las entradas y las salidas deben tener el mismo número de bits.
t
Deja pasar la entrada cuando la señal de arriba es un uno lógico. Tenga en cuenta que un inversor puesto en la salida de un búfer triestado no es lo mismo que conectar la salida a un circuito inversor. Con una salida invertida, un cero lógico en la linea de arriba dará como resultado una salida flotante.
índice
Adaptación de Tkgate a Computadores (GNU).
Nombre
Clave(s)
Atajo(s)
Puertas
Reducidas
and, nand,
or, nor,
xor, xnor
Ctrl­r a,
Ctrl­r A,
Ctrl­r o,
Ctrl­r O,
Ctrl­r x,
Ctrl­r X
Constantes
supply1,
supply0
g
v
La salida es un uno lógico o un cero lógico. No hay restricciones en el ancho de bus.
s
La salida es un único bit lógico según el estado del conmutador. Haciendo clic en el conmutador durante la simulación cambiaremos su estado. La salida debe ser de un solo bit.
d
La salida es una señal de múltiples bits según el valor del interruptor. Haciendo clic en el interruptor en el modo simulación podremos modificar el valor del interruptor en formato hexadecimal. T
Las puertas TTY se utilizan para modelar un terminal interactivo. Su circuito puede enviar caracteres para que se visualicen en el TTY, o recibir caracteres que se tecleen en el TTY.
c
La salida es una señal de reloj, con un ancho de pulso especificado, una fase y una función. La salida debe ser de un solo bit.
w
Combina múltiples cables en un solo cable de múltiples bits. La suma de los bits de las entradas debe ser igual a los bits de la salida.
Conmutador
Interruptor
DIP
TTY
Reloj
Lineas<­>Bus
85
switch
dip
tty
clock
concat
Símbolo
Descripción
La salida es la Y lógica de todos los bits de la entrada. También tiene puertas reducidas para las funciones O y O exclusiva. La salida debe ser de un solo bit.
índice
Adaptación de Tkgate a Computadores (GNU).
Nombre
TRAN
Sumador
Divisor
Multiplicador
Multiplexor
86
Clave(s)
no
aplicable
add
div
mult
mux
Atajo(s)
no
aplicable
Símbolo
Descripción
La salida es un subrango de los bits de un cable de múltiples bits. Esta puerta no se puede crear mediante los menús como las otras puertas. Para crearlo suelte el extremo del cable cerca del cable del que queremos extraer el rango de bits. Puede usar la opción “Propiedades...” del menú “Puerta” para seleccionar el rango de bits.
+
La salida es la suma de las entradas. Las entradas deben tener el mismo número de bits que la salida, y la entrada y salida de acarreo deben ser de un bit. La entrada de acarreo esta marcada con un punto.
/
Las salidas son el cociente y el resto de las entradas. La entrada de la izquierda es el dividendo y la de la derecha el divisor. No hay restricciones en el número de bits pero, si el resultado no se ajusta al número de bits se debe partir.
*
La salida es el producto de las dos entradas. No hay restricciones en el número de bits pero, si el resultado no se ajusta al número de bits se debe partir.
m
La salida es la entrada que indica la linea de selección. El número de bits de las entradas debe coincidir con el de la salida y el número de bits de la linea de selección debe ser el exponente del logaritmo en base dos del número de entradas.
índice
Adaptación de Tkgate a Computadores (GNU).
Nombre
Decodificador
Desplazador
izquierda
Desplazador
derecha
Desplazador
Aritmético
derecha
Desplazador
Cíclico
87
Clave(s)
demux
lshift
rshift
arshift
roll
Atajo(s)
Símbolo
Descripción
D 2
La salida es la entrada que indica la linea de selección. El número de bits de las entradas debe coincidir con el de la salida y el número de bits de la linea de selección debe ser el exponente del logaritmo en base dos del número de entradas.
S L
Realiza un desplazamiento hacia la izquierda de los bits de la entrada. La entrada y la salida deben tener los mismos bits y la linea de selección de desplazamiento debe ser el exponente del logaritmo en base dos de la entrada/salida.
S R
Realiza un desplazamiento hacia la derecha de los bits de la entrada. La entrada y la salida deben tener los mismos bits y la linea de selección de desplazamiento debe ser el exponente del logaritmo en base dos de la entrada/salida.
S A
Realiza un desplazamiento aritmético hacia la derecha de los bits de la entrada. La entrada y la salida deben tener los mismos bits y la linea de selección de desplazamiento debe ser el exponente del logaritmo en base dos de la entrada/salida.
S O
Rota los bits de la entrada hacia la izquierda. La entrada y la salida deben tener los mismos bits y la linea de selección de desplazamiento debe ser el exponente del logaritmo en base dos de la entrada/salida.
índice
Adaptación de Tkgate a Computadores (GNU).
Nombre
Registro
Biestable D
RAM
88
Clave(s)
register
ff
ram
Atajo(s)
Símbolo
Descripción
r
La salida es el valor actual del registro. Guarda el valor de la entrada cuando la linea de reloj esta a nivel alto. El valor se guarda si la señal EN esta a nivel bajo. Podemos borrar el contenido del registro haciendo que en la linea CLR haya un nivel bajo. La entrada y la salida deben tener el mismo número de bits, y las señales de reloj, EN y CLR deben ser de un bit.
f
La salida es el contenido actual del biestable y el contenido negado. Guarda el valor de la entrada cuando la señal de reloj esta a nivel alto y la señal E esta a nivel bajo. El biestable se puede borrar asíncronamente haciendo que la entrada C este a nivel bajo. La entrada y la salida deben tener los mismos bits y las señales de reloj, la linea C y la linea E deben tener un solo bit.
R
Cuando la linea CS (selector de chip) y la linea OE (permiso de salida) estan a nivel bajo, la salida será el valor de la memoria, indicado por la linea de dirección (A). Cuando la linea CS y la linea WE (permiso de escritura) esta a nivel bajo, el valor que hay en la linea de datos se guarda en la posición indicada por la linea A. Las señales CS, OE y WE deben ser de un bit. La linea de dirección no puede tener más de 32 bits. Las RAM se pueden inicializar mediante un fichero mientras simulamos.
índice
Adaptación de Tkgate a Computadores (GNU).
Nombre
ROM
Transistor
NMOS
Transistor
PMOS
LED
89
Clave(s)
rom
nmos
pmos
led
Atajo(s)
Símbolo
Descripción
u
Cuando la señal OE (permiso de salida) esta a nivel bajo, la salida D será el valor de la posición de memoria indicada por la linea de dirección A. La señal OE debe tener un solo bit, y la linea de dirección no puede tener más de 32 bits. Las ROM se pueden inicializar mediante un fichero mientras simulamos.
Ctrl­t n
Implementa un elemento NMOS al estilo Verilog. Todas las señales deben tener el mismo número de bits. Los elementos NMOS con entradas múltiples se tratarán como transistores paralelos.
Ctrl­t p
Implementa un elemento PMOS al estilo Verilog. Todas las señales deben tener el mismo número de bits. Los elementos PMOS con entradas múltiples se tratarán como transistores paralelos.
l
L 8
L s
L h
L d
Un led puede mostrar los valores de las señales en un circuito. Tiene una propiedad que nos permite seleccionar entre los diferentes tipos de LED. Los diferentes tipos son: el bit, la barra gráfica, 7 segmentos directo, hexadecimal, y decimal. El número de dígitos o barras viene determinado automáticamente por el tamaño de la entrada. En los leds directos cada siete bits de la entrada controlan un segmento del led numerados de arriba a abajo y de izquierda a derecha. Para los hexadecimales, cada cuatro bits controlan un digito. Para los decimales, el valor de la entrada se mostrará como un valor decimal sin signo.
índice
Adaptación de Tkgate a Computadores (GNU).
Nombre
Módulo
Comentario
Marco
Clave(s)
Atajo(s)
block
comment
frame
Símbolo
Descripción
B
Implementa un módulo definido por el usuario. Podemos utilizar un número arbitrario de entradas, salidas y bidireccionales sin restricciones en el número de bits. El nombre del módulo se usa para guardarlo en un fichero y no puede tener el mismo nombre que otra puerta.
C
Se usan para poner texto en el circuito. Los comentarios no tiene efecto en el circuito.
F
Los marcos se usan para hacer una separación visual de un circuito. Los marcos no tienen ningun efecto en el comportamiento de los circuitos.
2.17 Resumen del menú.
Menú
Opción
Atajo
Descripción
Nuevo
Ctrl­x k
Borra de la pantalla el circuito actual y empieza uno nuevo. Aparecerá un cuadro de dialogo donde podemos poner el nombre del fichero y el nombre del módulo principal.
Abrir...
Ctrl­x Ctrl­f
Abrir Libreria
Lee y carga los módulos de un fichero. Marca estos módulos como módulos de Ctrl­x Ctrl­l
librería. Solo se cargarán los módulos que no reemplacen los módulos actuales.
Salvar
Guarda el circuito actual en el fichero. Si Ctrl­x Ctrl­s no se ha especificado un fichero, TkGate preguntará el nombre del fichero.
Fichero
Salvar...
90
Borra de la pantalla el circuito actual y lee el nuevo circuito de un fichero.
Ctrl­x Pregunta el nombre del fichero y guarda índice
Adaptación de Tkgate a Computadores (GNU).
Menú
Opción
Atajo
Ctrl­w
Herramientas
91
el circuito. Con el nombre del fichero creará un fichero nuevo.
Imprimir...
Ctrl­x Ctrl­p
Imprime un esquema. Se puede imprimir en una impresora o en un fichero.
Opciones...
Ctrl­x o
Permite establecer opciones del TkGate mediante un cuadro de dialogo.
Salir
Editar
Descripción
Ctrl­x Ctrl­c Sale del TkGate.
Cortar
Ctrl­w
Corta las puertas seleccionadas y las guarda en un búfer.
Copiar
Ctrl­x x
Copia las puertas y las guarda en un búfer.
Pega el contenido del búfer. Si hemos especificado una marca de posición, las puertas se pegarán alli, sino se usará la posición original de las puertas.
Pegar
Ctrl­y
Seleccionar todo
Ctrl­x a
Buscar...
Ctrl­f
Situar en columna
|
Coloca las puertas seleccionadas de manera que queden alineadas verticalmente.
Situar en fila
­
Coloca las puertas de manera que queden alineadas horizontalmente.
Mover/Conectar
F1
Activa el modo de mover/conectar.
Borrar puerta
F2
Activa el modo de borrado de puertas.
Cortar cable
F3
Activa el modo de cortado de cables.
Invertir
F4
Activa el modo de inversor de puertos.
Anchura de bus
F5
Activa el modo de asignación de ancho de bus
Orientación 0º
Ctrl­F1
Establece la orientación para nuevas puertas a 0º
Orientación 90º
Ctrl­F2
Establece la orientación para nuevas puertas a 90º
Orientación 180º
Ctrl­F3
Establece la orientación para nuevas Selecciona todas las puertas.
Busca puertas y cables que contengan una subcadena de texto.
índice
Adaptación de Tkgate a Computadores (GNU).
Menú
Opción
Atajo
Descripción
puertas a 180º
Circuito
Orientación 270º
Ctrl­F4
Establece la orientación para nuevas puertas a 270º
Propiedades del circuito...
Ctrl­x E
Establece las propiedades globales de un circuito.
Camino crítico...
Ctrl­x r
Lista los caminos críticos del circuito.
Empezar Simulación
Ctrl­s b
Inicia la simulación.
Modo Continuo
Ctrl­s g
Pone el simulador en modo continuo.
Pausa
Ctrl­s s
Pone el simulador en modo paso a paso.
espacio
Hace que el simulador avance un número de periodos. Podemos modificar el número de periodos en las opciones del TkGate.
Paso a paso (nº ciclos)
tab
Hace que el simulador avance un número de ciclos de reloj. Podemos modificar el número de ciclos en las opciones del TkGate.
Punto de ruptura
Ctrl­s k
Crea una condición donde el simulador pasara a modo paso a paso.
Ejecutar guión...
Ctrl­s x
Ejecuta comandos de simulación desde un fichero.
Fichero­>memoria
Ctrl­s l
Carga una memoria con el contenido de un fichero.
Memoria­>fichero
Ctrl­s d
Guarda el contenido de una memoria en un fichero.
Abrir
>
Abre el módulo seleccionado.
Cerrar
<
Cierra el módulo actual.
Paso a paso (tiempo)
Simular
Ajustar interfaz
Ctrl­b s
Hace que la interfaz del módulo actual sea por defecto para los nuevos módulos de ese tipo.
Editar interfaces...
Ctrl­b e
Entra en un modo que permite editar las interfaces de todos los tipos de módulos.
Nuevo...
Ctrl­b n
Crea un nuevo módulo.
Borra...
Ctrl­b d
Elimina un módulo.
Módulo
92
índice
Adaptación de Tkgate a Computadores (GNU).
Menú
Puerta
Insertar
93
Opción
Atajo
Copia...
Ctrl­b c
Copia la definición del módulo a otro módulo.
Renombra...
Ctrl­b r
Renombra la definición del módulo.
Modo librería­> Modo usuario
Ctrl­b l
Convierte un módulo librería en un módulo de usuario.
Añade entrada
[
Añade una entrada a la puerta seleccionada.
Añade salida
]
Añade una salida a la puerta seleccionada.
Añade bidireccional
­
Añade un puerto bidireccional en la puerta seleccionada.
Cambiar tipo
@
Cambia el tipo (entrada, salida, bidireccional) de un puerto de módulo.
Anclar selección
Ctrl­x f
Ancla las puertas seleccionadas. Las puertas no se podran mover con el ratón.
Liberar selección
Ctrl­x u
Desancla las puertas seleccionadas.
Propiedades...
E
Edita las propiedades de la puerta seleccionada.
Réplica
Ctrl­v
Hace una replica de la puerta seleccionada.
Borrar
supr.
Borra las puertas seleccionadas.
Entrada / Salida
Descripción
Conmutador
s
Crea un conmutador.
Interruptor Dip
d
Masa
g
Crea una constante con lógica 0
Vdd
v
Crea una constante con lógica 1
Lineas
<­>bus
w
led
l
barra de leds
l [n]
Crea una barra gráfica.
Led 7 seg. (hexadecimal) L h
Crea un led de 7 segmentos con codificación hexadecimal.
Led 7 seg. L d
Crea un led de 7 segmentos con Crea un interruptor dip.
Crea una unión de lineas.
Crea un led de 1 bit.
índice
Adaptación de Tkgate a Computadores (GNU).
Menú
Opción
Atajo
(decimal) Puerta
Insertar
Reducción
94
Descripción
codificación decimal.
Led 7 seg. (directo) L d
Crea un led de 7 segmentos con codificación directa.
Señal de reloj
c
TTY (Terminal)
T
AND (Y)
a
NAND (NO­Y)
A
OR (O)
o
Crea una puerta O.
NOR (NO­O)
O
Crea una puerta O negada.
XOR (O­EX)
x
Crea una puerta O exclusiva.
XNOR (NO­O­EX)
X
Búfer
b
Crea un búfer.
Inversor
i
Crea un inversor.
Búfer Triestado
t
PMOS
Ctrl­t p
Crea un transistor PMOS.
NMOS
Ctrl­t n
Crea un transistor NMOS.
AND
Ctrl­r a
Crea una puerta Y reducida.
NAND
Ctrl­r A
Crea una puerta Y negada reducida.
OR
Ctrl­r o
Crea una puerta O reducida.
NOR
Ctrl­r O
Crea una puerta O negada reducida.
XOR
Ctrl­r x
Crea una puerta O exclusiva reducida.
XNOR
Ctrl­r X
Crea una puerta O exclusiva negada reducida.
2­1 Multiplexor
m
4­1
Multiplexor
M 4
Crea un reloj.
Crea un terminal
Crea una puerta Y.
Crea una puerta Y negada.
Crea una puerta O exclusiva negada.
Crea un búfer triestado.
Crea un multiplexor de 2 a 1.
Crea un multiplexor de 4 a 1.
índice
Adaptación de Tkgate a Computadores (GNU).
Menú
Opción
MSI
ALU
Insertar
Memoria
Módulo
Descripción
8­1
Multiplexor
M 8
1­2
Decodificador
D 2
1­4
Decodificador
D 4
1­8
Decodificador
D 8
Sumador
+
Crea un sumador.
Multiplicador
*
Crea un multiplicador.
Divisor
/
Crea un divisor.
Desplazador
izquierda
S L
Desplazador
derecha
S R
Desplazador
Aritmético
derecha
S A
Desplazador
Cíclico
S O
Biestable D
f
Crea un biestable D.
Registro
r
Crea un registro.
RAM
R
Crea una memoria de acceso aleatorio (RAM).
ROM
u
Crea una memoria de solo lectura.
Inserta módulo
B
Entrada módulo
}
Salida módulo
{
Bidireccional módulo
=
Comentario
95
Atajo
C
Crea un multiplexor de 8 a 1.
Crea un decodificador de 1 a 2.
Crea un decodificador de 1 a 4.
Crea un decodificador de 1 a 8.
Crea un desplazador hacia la izquierda.
Crea un desplazador hacia la derecha.
Crea un desplazador aritmético hacia la derecha.
Crea un desplazador cíclico.
Crea una instancia de módulo.
Crea un puerto de entrada.
Crea un puerto de salida.
Crea un puerto bidireccional.
Crea un comentario.
índice
Adaptación de Tkgate a Computadores (GNU).
Menú
Opción
Atajo
Marco
F
Descripción
Crea un marco.
2.18 Resumen de la barra de herramientas (Modo edición).
Descarta el circuito existente y crea uno nuevo preguntando el nombre del fichero.
Descarta el circuito existente y permite cargar un circuito desde un fichero.
Guarda los cambios en el fichero actual.
Imprime el fichero actual.
Usar la herramienta para mover/conectar.
Usar la herramienta para borrar puertas.
Usar la herramienta para cortar cables.
Usar la herramienta para invertir puertos.
Usar la herramienta para cambiar el ancho de los buses.
Deshacer la última acción.
96
índice
Adaptación de Tkgate a Computadores (GNU).
Rehacer la última acción deshecha.
Abrir la instancia de módulo seleccionada. Cierra la instancia de módulo actual.
Acercar.
Alejar.
Iniciar la simulación.
Hacer un análisis de los caminos críticos del circuito.
3 Usando el Simulador/Analizador.
3.1 Iniciando el simulador.
Podemos acceder a los comandos de simulación mediante la barra de botones o desde el menú “Simular”. Inicie la simulación seleccionando “Empezar Simulación” o pulsando el boton “play” en la barra de botones. Aparecerá una ventana donde podremos ver los trazos de las señales, como las ventanas de texto para los terminales TTY. Si existe algun guión de simulación, también se ejecutara (mire la sección Guiones de Simulación para más detalles).
Se realizará la simulación del módulo de más alto nivel. Internamente el simulador expandirá las instancias de los módulos en el circuito. No se puede acceder directamente a los submódulos pero puede ir accediendo a los submódulos seleccionando un módulo del nivel actual y abriéndolo desde el menú o con la tecla '>'. Puede salir del módulo actual hacia el módulo de nivel superior con la tecla '<'.
Los nombres de las puertas y los cables en los submódulos se referéncian anteponiendo el nombre del módulo seguido de un punto. Supongamos que tenemos dos instancias de un 97
índice
Adaptación de Tkgate a Computadores (GNU).
módulo llamado “foo” en el módulo principal y los nombres de instancia son “g1” y “g2”. Ahora suponga que el módulo “foo” contiene un cable llamado “w1”. Para distinguir las dos instancias de los cables estos serán referenciados por el simulador como “g1.w1” y “g2.w1”.
El TkGate es un simulador de eventos guiados. El tiempo se mide en unidades discretas llamadas épocas. Cada puerta tiene un retraso de un cierto número de épocas. Algunas puertas complejas tienen múltiples retrasos. Además, algunas puertas como los registros y las memorias tienen retrasos que afectan a los cambios de estado interno.
Los comandos básicos de simulación son:
Función
Iniciar Simulación
Pausa
Descripción
Entra el modo de simulación continua. La simulación seguirá mientras queden eventos en la cola. Si hay algun reloj en el circuito, la simulación continuará indefinidamente. Si el circuito es combinacional, la simulación continuará hasta que el circuito se quede parado.
Hace que se pare la simulación continua.
Avanzar épocas
Hace que la simulación avance un número fijado de épocas. El número de épocas se puede fijar en el menú “Fichero” en la sección “Simular” de las opciones. También puede usar este comando pulsando la barra espaciadora.
Avanzar ciclos
Hace que la simulación avance un número de ciclos de reloj. El número de ciclos se puede fijar en las opciones del simulador. También se puede cambiar el número de épocas que avanzará el simulador más allá de los ciclos indicados (esto dará un plazo de tiempo a los registros para que puedan cambiar de valor). También puede invocar este comando con el tabulador.
Finalizar simulación
98
Boton
Hace que finalice la simulación y que se eliminen todas las puntas de prueba.
índice
Adaptación de Tkgate a Computadores (GNU).
3.2 Opciones del simulador.
Podemos establecer varias opciones del simulador mediante el cuadro de dialogo de opciones en el menú “Fichero”, seleccionando la página “Simular”.
Las opciones del simulador son:
99
●
Ajuste Tiempo: Especificará el número de épocas que avanzará el simulador cada vez que pulsemos la barra espaciadora o el boton.
●
Ajuste nº ciclos: Especifica el número de ciclos de reloj que avanzará el simulador cada vez que pulsemos el tabulador o el boton.
●
Exceder reloj: Especifica el número de épocas a simular cuando se han simulado los ciclos de reloj. Se puede usar para que los registros tengan tiempo de cambiar su valor.
índice
Adaptación de Tkgate a Computadores (GNU).
●
Ordenar alfabéticamente los trazos.
●
Recuerda la posición de las puntas de prueba.
●
Guión de inicialización: Especifica un guión de simulación que se ejecutará automáticamente cuando se inicie la simulación. El guión especificado aplica alguna característica a algun circuito cargado en el TkGate. ●
El reloj para después de todos los flancos: Indica que todos los relojes se accionaran en los flancos ascendentes en el modo de simulación paso a paso.
●
El reloj para en punto: Indica que el reloj especificado se accionará en los flancos ascendentes. Es útil para circuitos con múltiples relojes.
●
Ficheros de retraso: Especifica ficheros que especificarán retrasos de puertas adicionales. Para más información sobre los ficheros de retraso mire en la sección Ficheros de retraso de una puerta.
3.3 Observando la salida.
Mientras que no se indique otra cosa, se usa la sintaxis Verilog para especificar y visualizar los valores. Un número con formato Verilog contienen un prefijo para indicar el ancho de bus, una comilla simple, un carácter del radio y los dígitos del número. Los caracteres de radio usados en TkGate son: “b” para binario, y “h” para hexadecimal. Por ejemplo, “8'h3e” es el número hexadecimal de ocho bits “3e”. El simulador soporta los siguientes valores lógicos:
Símbolo
100
Ámbito
Descripción
0
Lógica cero
1
Lógica uno
x
Desconocido
z
Flotante
L
Nivel bajo (la señal es flotante o cero)
índice
Adaptación de Tkgate a Computadores (GNU).
Símbolo
H
Ámbito
Descripción
Nivel alto (la señal es flotante o uno)
Para visualizar el valor de una señal en el circuito, seleccione y mantenga pulsado el boton izquierdo del ratón en un cable. Se mostrará el valor actual en formato Verilog. El valor desparecerá cuando suelte el boton del ratón. Esta característica se puede usar tanto cuando el simulador esta en modo pausa como cuando esta en modo de simulación continua. Cuando el simulador esta en simulación continua, el valor mostrado será el valor en el momento en el que se pulsó el ratón.
Para crear una punta de prueba que nos permita ver la evolución de la señal en el tiempo, haga doble clic en uno de los cables. Esto creará o eliminara una punta de prueba. Podremos ver la evolución de los valores de la señal en la ventana de ámbito de las señales. Las señales con múltiples bits se mostrarán como números hexadecimales.
101
índice
Adaptación de Tkgate a Computadores (GNU).
Para cambiar el rango de los valores mostrados y la escala de la pantalla, puede usar la barra de desplazamiento, el ratón o los atajos de teclado. Moviendo la barra de desplazamiento, estableceremos el rango relativo a toda la simulación. Puede obtener un control más apurado haciendo clic con el boton izquierdo del ratón sobre la ventana de trazos y arrastrando el trazo hacia la izquierda o hacia la derecha. Para acercarse, puede pulsar el boton izquierdo del ratón apretando la tecla Shift o pulsar la tecla '>'. Para alejarse, puede pulsar el boton derecho del ratón apretando la tecla Shift, o pulsando la tecla '<'.
Para imprimir los trazos de las señales elija la opción “Visualizando Señal...” del menú “Fichero” en la ventana de ámbito, o use el atajo “Ctrl­s p”. Veremos el cuadro de dialogo mostrado aquí. La parte izquierda del cuadro es igual que en el cuadro de dialogo usado para imprimir circuitos. En la parte derecha tenemos opciones para seleccionar el rango de tiempo a imprimir y la escala que queremos usar. Tenga en cuenta que los trazos de simulación pueden ser muy extensos y las transiciones muy rápidas, especialmente en el modo de simulación continua. Tenemos una estimación de las páginas necesarias para imprimir los trazos, esto nos ayudará a ajustar los parámetros.
102
índice
Adaptación de Tkgate a Computadores (GNU).
3.4 Controlando la entrada.
Hay tres tipos de elementos de circuito que pueden ser usados para controlar un circuito: el conmutador, el interruptor dip y el terminal tty.
3.4.1 Conmutadores e interruptores dip.
El valor de los interruptores y conmutadores se puede modificar haciendo un simple clic sobre ellos. Para cambiar el valor de un interruptor dip haga clic en el interruptor, se mostrará un cuadro de dialogo donde podrá modificar el valor del interruptor. Introduzca el valor en el cuadro de texto y pulse aplicar para establecer el nuevo valor. El cuadro de dialogo no se cerrará hasta que pulse “Cerrar”.
3.4.2 Terminales (ttys).
El terminal es un dispositivo tanto de entrada como de salida, modelando un terminal interactivo. Cuando iniciamos el simulador aparecerá una ventana de tty para cada instancia de tty en el circuito. Nuestro circuito puede tanto enviar caracteres al terminal como recibir caracteres del terminal. Para enviar un carácter a un terminal, debemos poner en la entrada RD del terminal el código ASCII del carácter que queremos enviar y esperar que la señal DTR este a nivel alto. El siguiente paso es poner la señal DSR a nivel alto, el carácter se transmitirá cuando esta señal este a nivel alto. Después debemos poner la señal a nivel bajo para poder enviar otro carácter.
Para recibir un carácter. primero ponga a nivel bajo la señal CTS y espere que la señal RTS pase a nivel alto. Ahora puede leer el valor del carácter enviado por el terminal en la salida TD del terminal. Una vez ha leído el carácter, ponga la señal CTS a nivel bajo para indicar que hemos recibido el carácter.
3.5 Establecer puntos de interrupción.
Los puntos de interrupción se usan para parar la simulación continua cuando se da alguna condición predefinida. Para ver el cuadro de dialogo de Puntos de interrupción elija la opción “Punto de ruptura...” del menú “Simular”. 103
índice
Adaptación de Tkgate a Computadores (GNU).
Actualmente solo podemos utilizar un número limitado de puntos de ruptura. Solo se puede comparar una única señal con una constante usando operadores relacionales simples. Los operadores relacionales son los operadores relacionales estándar usados en C. La constante debe estar en formato Verilog. Otra alternativa es escribir el nombre de la señal para parar la simulación cuando el valor sea un valor diferente de cero, o anteponiendo el operador '!' para parar cuando el valor de la señal sea cero.
3.6 Inicializar memorias.
Un circuito puede contener una o más memorias (puertas ROM y RAM). Puede inicializar las memorias desde un fichero, o guardar los contenidos de la memoria en un fichero. Use las opciones de la siguiente tabla para cargar o guardar el contenido de las memorias:
104
índice
Adaptación de Tkgate a Computadores (GNU).
Función
Boton
Descripción
Cargar la memoria...
Carga el contenido de las memorias desde el fichero seleccionado. Si una memoria esta seleccionada, solo se cargará esta memoria. Si el fichero contiene una o más palabras claves, se cargarán las memorias especificadas con el contenido del fichero. Cuando abrimos un circuito que tiene memorias, si estas memorias tenían algun fichero de memoria cargado, este fichero se buscará en el directorio actual, en el directorio del circuito o en el directorio del usuario.
Guardar la memoria...
Guarda el contenido de la memoria seleccionada en un fichero.
Por defecto, los ficheros de memoria tiene la extensión “.mem”. En estos ficheros las lineas en blanco y las lineas que empiecen con el carácter “#” serán ignoradas. Otro tipo de lineas pueden ser declaraciones de memoria, o una dirección en hexadecimal seguida de una barra '/' y una lista de los valores de la memoria en hexadecimal. Un fichero de memoria deberia parecerse a esto:
100/ e1 f0 0 0 e1 e0 0 0
108/ 81 0 0 0 12 1 bd 0
110/ e 1 e1 d0 dc 7 85 0
118/ 6f 6 81 0 0 0 4e 4
120/ 69 f0 2 0 85 0 64 0
128/ 81 0 0 0 26 4 69 f0
130/ 2 0 ed 0 60 6 62 6
138/ ed 0 5e 6 1 0 85 0
La dirección al principio de la linea especifica la dirección donde se empiezan a guardar los valores. Los valores se guardan secuencialmente desde la dirección especificada una en cada palabra para el resto de cada linea.
Si no hay palabra clave en el fichero, se cargará la memoria seleccionada. La palabra clave de la memoria consiste en una linea especificando el nombre de la memoria. Por ejemplo:
memory memory.m1
100/ e1 f0 0 0 e1 e0 0 0
108/ 81 0 0 0 12 1 bd 0
105
índice
Adaptación de Tkgate a Computadores (GNU).
Esto cargará la memoria “m1” en la instancia llamada “memory” que es un submódulo del módulo principal. Para crear Ficheros de memoria de un nivel alto de descripción puede utilizar el gmac un compilador de macrocódico y microcódigo. Para más información consulte los manuales en www.tkgate.org.
Para las memorias RAM, los contenidos cargados en la memoria estan inactivos hasta la primera vez que haya una transición en la linea de escritura a nivel alto (de lógica 0 a 1). Esto previene que los datos cargados desde el principio sean destruidos debido a señales desconocidas.
3.7 Guiones de simulación.
Los guiones de simulación se usan para realizar tareas que se podrían realizar de manera manual. Puede crear o eliminar puntas de prueba, cambiar el valor de los conmutadores, cargar memorias, crear puntos de ruptura y parar/iniciar el simulador. Los guiones de simulación son útiles para organizar la simulación antes de empezar, o para ejecutar una simulación en modo batch. Puede cargar un guión desde el boton en la barra de botones o seleccionar la opción “Ejecutar Guión...” del menú “Simular”. La extensión por defecto para los guiones de simulación es “.gss”. Cuando abrimos un circuito que tiene guiones, se buscará este fichero en el directorio actual, en el directorio del circuito o en el directorio del usuario.
También puede programar que los guiones de simulación se ejecuten automáticamente cuando se inicie el simulador especificando un guión en el cuadro de dialogo de las opciones del simulador, o añadiendo guiones de simulación como opciones de circuito. Reconoce los siguientes comandos de simulación. Los argumentos rodeados de caracteres '?' son argumentos opcionales.
Comando
Descripción
include “fichero”
Incluye el fichero especificado como si el contenido del fichero formará parte del guión de simulación.
step n
Avanza el numero especificado de épocas.
clock(+/­) ?[nombre]? n ?+m? Avanza n ciclos de reloj. Si el carácter que hay después de “clock” es un '+', avanzará en los flancos ascendentes. Si el carácter que hay después de “clock” es un '­', avanzará en los flancos descendentes. Si se especifica un nombre, solo se avanzará en ese reloj. Si se especifica m el simulador avanzará ese número de épocas después del último flanco.
run
106
Pone el simulador en modo continuo. índice
Adaptación de Tkgate a Computadores (GNU).
Comando
Descripción
break ?[nombre]? cond
Establece un punto de ruptura cuando se de la condición, con la sintaxis que se describe en la sección “Establecer puntos de interrupción”. Si el nombre se especifica entre “[ ]”, se le asignará un nombre simbólico a la interrupción para poder ser eliminado más tarde. Si no se especifica ningun nombre, no se podrá eliminar el punto de ruptura desde el guión de simulación.
delete [nombre]
Elimina el punto de ruptura especificado. Solo los puntos de ruptura creados mediante un guión de simulación y a los que se les ha asignado un nombre podrán ser eliminados.
set nombre valor
Establece el valor para un conmutador o un interruptor dip. El nombre debe incluir la ruta completa del interruptor y el valor debe tener formato de constante Verilog.
probe nombre
Establece una punta de prueba en la señal “nombre”. Debemos especificar la rutan completa.
unprobe nombre
Elimina la punta de prueba de la señal “nombre”. Debemos especificar la rutan completa.
load ?nombre? “fichero”
Carga las memorias con un fichero. Si especificamos un nombre de memoria, solo esta se cargará.
dump nombre “fichero”
Guarda el contenido de la memoria especificada en el fichero.
zoom n
Establece el factor de zoom para la ventana de ámbito. Los números positivos incrementan el rango de pantalla y los negativos lo decrementan.
3.8 Usando el informe de errores.
Si hay algun error en el circuito, al iniciar el simulador aparecerá una lista con los errores y los módulos donde ocurrieron estos errores. Puede explorar la lista de errores usando los atajos “Ctrl­p” y “Ctrl­n”. TkGate irá al módulo donde ocurrió el error y resaltará la posición del error con una aspa.
107
índice
Adaptación de Tkgate a Computadores (GNU).
3.9 Fichero de retrasos de una puerta.
Los retrasos, el área y la potencia de la puerta (las especificaciones de potencia no se utilizan) se pueden establecer mediante una colección de ficheros de especificación (gdf). El fichero por defecto es el “/gdf/default.gdf” el directorio base del TkGate, que se carga siempre, pero podemos reemplazar las definiciones mediante ficheros adicionales que indicaremos en las opciones del TkGate.
Cada fichero debe contener una o más tecnologías con la forma:
technology cmos {
...
}
Las tecnologías implementa un conjunto nuevo de parámetros de retraso de las puertas. El nombre de la tecnología se podrá seleccionar en las propiedades de la puerta. La implementación de la tecnología consiste en un conjunto de definiciones que describen todos los posibles retrasos y el área de las puertas primitivas, dependiendo del número de entradas, del numero de inversores o del ancho de bus de las señales. Por ejemplo, el bloque para el multiplexor sería como el siguiente:
primitive mux {
delay<I­Z> = (2*(num(S)+1) + 2*num(I)) + 2*(inv(I) || inv(Z)); delay<S­Z> = (2*(num(S)+1) + 2*num(I));
area = bits(Z)*((2*(num(S)+1) + 2*num(I)) + 2*inv(I)); } Las dos lineas de retraso definen el retraso desde la entrada a la salida (I­Z) y desde la linea de selección a la salida (S­Z). Las expresiones puede incluir operadores de tipo C: “+”, “­”, “*”, “/”, “&&”, “||”, “==”, “!=”, “>”, “>=”, “<”, “<=”, y “!”, el operador “elevado a” “**” y las funciones en la siguiente lista:
Función
Descripción
num(p)
Normalmente “p” especifica un grupo de puertos relacionados, en este caso la función devuelve el número de puertos en el grupo. Por ejemplo, para una puerta AND con múltiples entradas, la expresión num(I) devolvería el numero de entradas
bits(p)
Devuelve el número de bits el puerto “p”. Si “p” representa un grupo de puertos, se devuelve el número de bits mayor de todos los puertos.
inv(p)
Si “p” es un grupo de puertos, devuelve el número de inversores en los puertos, si es un puerto simple devuelve un 1 si hay un inversor y 0 si no hay.
108
índice
Adaptación de Tkgate a Computadores (GNU).
Función
log(expr)
Descripción
Devuelve el exponente del logaritmo en base dos de la expresión.
También es posible escribir definiciones con funciones. Por ejemplo, consideramos la especificación de la puerta and:
primitive and {
delay<I­Z> = {
if ((inv(I) == num(I))) // Determine if an inverter is necessary. An
d = inv(Z); // inverter is not required if the output is
else if ((inv(I) == 0)) // inverting and all inputs are non­inverting
d = !inv(Z); // (i.e., it is a NAND gate), or if all inputs
else // are inverting and the output is non­inverting
d = 1; // (i.e., it is a NOR gate). if (num(I) == 1) { // If one input, treat this as a reduction gate return 2*bits(I0) + 2*d; // one Tr. delay per bit plus inverter delay. } else { // If multiple inputs, treat this as a normal gate return 2*num(I) + 2*d; // one Tr. delay per input plus inverter delay. }
}
area = {
if ((inv(I) == num(I))) // Estimate number of inverters required. If all
d = inv(Z); // inputs are inverted, an inverter is required
else if ((inv(I) == 0)) // iff the output is inverted. If all inputs
d = !inv(Z); // are non­inverted, an inverter is required iff
else // the output is non­inverted. Otherwise we need
d = inv(I); // an inverter for each inverted input.
if (num(I) == 1) { // If one input, treat this as a reduction gate a = 2*bits(I0) + 2*d;
109
// one Tr. per bit plus inverter Trs. índice
Adaptación de Tkgate a Computadores (GNU).
} else {
// If multiple inputs, treat this as a normal gate a = 2*num(I) + 2*d;
// one Tr. per input plus inverter Trs. }
return bits(Z)*a; // Multiply by number of bit slices.
}
}
En una especificación con funciones, las sentencias se ejecutan secuencialmente hasta que la sentencia “return” establece el valor para el parámetro. Podemos usar los operadores de C “if” y “switch”, pero no los bucles.
Cuando creamos una tecnología no es necesario definir el retraso para cada puerta. Por ejemplo, supongamos que tenemos la definición de la tecnología CMOS que incluye una definición para un búfer:
technology CMOS {
primitive buf {
delay<I­Z> = 2 + 2* (inv(I) == inv(Z));
area = bits(Z)*(2 + 2* (inv(I) == inv(Z)));
}
...resto de la definición de la tecnología CMOS
}
Podríamos crear una tecnología especial que contenga las versiones de alta tensión de un grupo de puertas de la tecnología CMOS, por ejemplo:
technology HP_CMOS {
primitive buf {
delay<I­Z> = 1 + (inv(I) == inv(Z));
area = 2*bits(Z)*(2 + 2* (inv(I) == inv(Z)));
}
}
Si seleccionamos la tecnología HP_CMOS para algunas puertas de las que no tengamos definiciones para la tecnología HP_CMOS, se usarán los valores de la tecnología “default”.
110
índice
Adaptación de Tkgate a Computadores (GNU).
3.10 Análisis del camino critico.
El simulador del TkGate incorpora un analizador de circuitos para el análisis de los caminos críticos. Tenga en cuenta que el analizador usa un algoritmo de análisis de caminos estaticos y no puede detectar caminos falsos. El analizador buscará y mostrará una lista con un tamaño especifico de caminos en el circuito. Solo se listan los caminos formados encontrando los peores casos de los retrasos hacia una salida y los peores casos de retrasos desde una entrada hasta algun nodo interno. Para entrar en el modo de análisis pulse el boton en la parte izquierda de la barra de botones o seleccione la opción “Camino crítico...” del menú “Circuito”. Puede ver alguno de los caminos críticos seleccionándolo de la lista. El camino se mostrará en el editor resaltado como se muestra en la siguiente figura:
111
índice
Adaptación de Tkgate a Computadores (GNU).
La parte inferior del cuadro de dialogo contiene la lista de conexiones que forman parte del camino actual. Seleccionando el nombre de alguna de las conexiones, el editor ira al módulo donde se encuentra la conexión y la resaltará con una aspa. Podemos seleccionar el número de caminos mostrados en la parte inferior derecha del cuadro de dialogo.
Si hace clic en una conexión mientras esta analizando los caminos críticos, cerca del cursor aparecerá una pequeña ventana con un mensaje como “10­>w3­>50”. Esto significa que en el peor de los casos la conexión llamada “w3” tendra como retraso 10 épocas entre la entrada y w3, y en el peor de los casos tendra 50 épocas entre w3 y la salida. Para imprimir un camino crítico, simplemente imprima el circuito mientras el camino esta resaltado.
112
índice
Adaptación de Tkgate a Computadores (GNU).
5 INSTALAR TKGATE SOBRE CYGWIN
Definiciones previas:
CYGWIN es una colección de herramientas desarrollada por Cygnus Solutions para proporcionar un comportamiento similar a los sistemas Unix en Windows. CYGWIN/X es una implementación del protocolo X11 usado por el entorno gráfico que ejecuta sobre Cygwin.
Instalación
Descargamos el fichero de instalación desde la Web de cygwin:
www.cygwin.com/setup.exe
Al ejecutar el fichero setup.exe, veremos la siguiente pantalla de bienvenida:
Haga clic en Next para pasar a la siguiente pantalla.
Seleccione la Instalación desde Internet
113
índice
Adaptación de Tkgate a Computadores (GNU).
Haga clic en Next para pasar a la siguiente pantalla.
El directorio por defecto donde se instalara es c:\cygwin, este debería estar bien para la mayoría de instalaciones. Si tiene varios usuarios en su maquina NT, y se ha validado con privilegios administrativos en la maquina, debería seleccionar la opción “Install For” a All. La opción Just Me funcionara bien para maquinas con un solo usuario.
Haga clic en Next para pasar a la siguiente pantalla.
Aquí seleccionaremos el directorio donde se descargaran los ficheros de instalación.
114
índice
Adaptación de Tkgate a Computadores (GNU).
Haga clic en Next para pasar a la siguiente pantalla.
Seleccione el tipo de conexión a Internet:
Haga clic en Next para pasar a la siguiente pantalla.
Seleccione los servidores desde los que descargara los ficheros necesarios. En este caso tendremos dos servidores. Uno lo seleccionaremos de la lista y el otro lo añadiremos:
115
índice
Adaptación de Tkgate a Computadores (GNU).
http://cs.ubc.ca/local/software/cygwin
Estos servidores son de la Universidad de British Columbia en Vancouver (Canadá) y de la Universidad de Calgary (Canadá).
Los paquetes que necesitamos para ejecutar el TKGate solo los podemos encontrar en uno de estos dos servidores. Los dos servidores tienen copias idénticas de los ficheros pero los seleccionaremos los dos por si alguno de ellos no estuviera activo.
Haga clic en Next para pasar a la siguiente pantalla.
Una vez descargada la lista de paquetes de cada uno de los servidores, nos aparecerá una lista con todos los paquetes divididos en categorías.
116
índice
Adaptación de Tkgate a Computadores (GNU).
Para la instalación del TkGate solo necesitaremos seleccionar el paquete X­desktop­icons del menú X11 que automáticamente seleccionara todos los paquetes necesarios. 117
índice
Adaptación de Tkgate a Computadores (GNU).
En el paquete tkgate, seleccionaremos también la opción Source, para que descargue el código fuente para poder recompilarlo después.
Para poder recompilar el código del TKGate serán necesarios también los siguientes paquetes:
Menú Devel:
bison: A parser generator that is compatible with YACC.
flex: A fast lexical analyzer generator.
gcc­core: C compiler.
make: The GNU version of the ‘make’ utility.
Menú X11: xorg­x11­devel: Cygwin/X headers and import libraries.
Necesitaremos también un editor de texto.
Menú Editors:
vim: Vi IMproved – enhanced vi editor.
Una vez seleccionados todos los paquetes haga clic en Next para empezar la descarga e instalación.
118
índice
Adaptación de Tkgate a Computadores (GNU).
Automáticamente se descargaran e instalaran los paquetes seleccionados.
Seleccione estas casillas si quiere añadir un acceso rápido al menú de inicio y en el Escritorio.
119
índice
Adaptación de Tkgate a Computadores (GNU).
Debería recibir un mensaje que la instalación se ha completado.
Una vez instalado el Cygwin aparecerán en el escritorio dos nuevos accesos directos:
El xterm es un emulador de terminal para el sistema de ventanas X. 120
índice
Adaptación de Tkgate a Computadores (GNU).
Cambio de Idioma del TKGate
El tkgate por defecto tiene como idioma ingles. Para poder cambiar esta característica es necesario establecer la variable del sistema LANG. Para hacer esto abriremos un xterm.
Con el vim o con el editor que hayamos elegido tendremos que modificar el fichero .bash_profile que se encuentra en el directorio base de cada usuario.
Insertamos las dos últimas líneas al fichero y lo guardamos.
Para que los cambios hagan efecto, tendremos que cerrar el xterm.
Ahora ya podremos ejecutar el TKGate en español.
121
índice
Adaptación de Tkgate a Computadores (GNU).
6 INSTALAR TKGATE SOBRE DEBIAN O KNOPPIX
Para instalar el TkGate en Debian o Knoppix necesitaremos descargar algunos paquetes que por defecto no estan instalados. Por tanto, el primer paso será configurar alguno de los programas como “apt­get”, “dselect”, “aptitude”, “synaptic”, ..., etc.
Aquí utilizaremos el apt­get. Para configurar el apt­get primero deberemos editar el fichero “/etc/apt/sources.list”. Deberemos entrar en modo superusuario. En caso que no exista ningun servidor de donde descargar los paquetes podemos añadir los siguientes:
deb http://ftp.rediris.es/debian sarge main contrib non­free
deb http://ftp.es.debian.org/debian testing main contrib non­free
Una vez hecho esto deberemos actualizar la lista de paquetes de los servidores, haciendo: apt­get update
Para instalar el TkGate necesitaremos los siguientes paquetes:
gcc ­ The GNU C compiler
bison ­ A parser generator that is compatible with YACC
flex ­ A fast lexical analyzer generator.
tcl8.4 ­ Tcl (the Tool Command Language) v8.4 ­ run­time files
tcl8.4­dev ­ Tcl (the Tool Command Language) v8.4 ­ development files
tk8.4 ­ Tk toolkit for Tcl and X11, v8.4 ­ run­time files
tk8.4­dev ­ Tk toolkit for Tcl and X11, v8.4 ­ development files
Instalaremos estos paquetes haciendo:
apt­get install gcc bison flex tcl8.4 tcl8.4­dev tk8.4 tk8.4­dev
Si no pudiéramos instalar alguno de los paquetes, podemos descargarlos desde :
http://www.es.debian.org/distrib/packages
122
índice
Adaptación de Tkgate a Computadores (GNU).
Y para instalarlos utilizaremos el comando:
“dpkg ­i nombre_del_paquete”
Una vez hecho esto, descargaremos los ficheros fuentes del TkGate desde: ftp://gadoid.ices.cmu.edu/pub/tkgate/tkgate­1.8.6.tgz
Los podemos descomprimir con cualquier gestor de archivos como el “ark” o con el comando:
tar ­xvf tkgate­1.8.6.tgz
situándonos en el directorio donde se encuentra el fichero.
Esto descomprimirá el fichero. Entramos en el directorio descomprimido y ejecutamos el script:
./configure
que configurará los ficheros para la instalación del TkGate. Una vez hecho esto lo compilamos y lo instalamos con los comandos:
make; make install
Después de compilar e instalar el TkGate podemos eliminar los ficheros objecto creados al compilar el programa haciendo:
make clean
Para cambiar el idioma del sistema operativo podemos ejecutar el comando:
dpkg­reconfigure locales
123
índice
Adaptación de Tkgate a Computadores (GNU).
Seleccionamos el idioma que queremos y aceptamos, esto cambiará el idioma del sistema operativo, pero necesitaremos reiniciar para ver los cambios.
Aunque también podemos utilizar las opciones del TkGate para ejecutarlo en otros idiomas. Ejecutando el Tkgate con la opción “­L idioma”, usando “es” para español, “ca” para catalán, ..., etc.
124
índice
Adaptación de Tkgate a Computadores (GNU).
7 INSTALAR LOS NUEVOS MÓDULOS
Para instalar las nuevas puertas de una forma automática he creado el siguiente script, los formatos de los ficheros que se deben incluir en los ficheros del TkGate se explican al final del apartado:
#!/bin/bash
echo "Donde esta el directorio con los ficheros fuentes? (ej: /tkgate):"
read tkgate_home
if [ ­d $tkgate_home ]
then
tkp=""
gsp=""
inst=0
for i in `ls .` do
if [ ­d $i ]
then
inst=0
echo ­e "\nMoviendo imagen a tkgate/bitmaps\n"
cp `ls ./$i/*.xbm` $tkgate_home/bitmaps/
echo ­e "Moviendo el fichero fuente del editor\n"
file=`ls ./$i/tkgate_*.c | cut ­d'_' ­f2`
if [ ! ­f $tkgate_home/src/tkgate/$file ]
then
tkp="$tkp `echo $file | cut ­d'.' ­f1`"
else echo ­e "El fichero ya esta instalado. Se actualiza.\n"
inst=1
fi
125
cp ./$i/tkgate_$file $tkgate_home/src/tkgate/$file
echo ­e "Moviendo el fichero fuente del simulador\n"
índice
Adaptación de Tkgate a Computadores (GNU).
file=`ls ./$i/gsim_*.c | cut ­d'_' ­f2`
if [ ! ­f $tkgate_home/src/gsim/$file ]
then
gsp="$gsp `echo $file | cut ­d'.' ­f1`"
else echo ­e "El fichero ya esta instalado. Se actualiza.\n"
inst=1
fi
cp ./$i/gsim_$file $tkgate_home/src/gsim/$file
if [ $inst ­eq 0 ]
then
file=`ls ./$i/*.gdf 2> /dev/null`
if [ ! ­z $file ]
then
echo ­e "Modifica $tkgate_home/gdf/default.gdf\n"
./moddelay $tkgate_home `ls ./$i/*.gdf`
fi
echo ­e "Modificando los mensajes de la puerta\n"
for j in `ls ./$i/*.msg`
do
l=`echo $j | cut ­d'_' ­f2 | cut ­d'.' ­f1`
./modmessage $tkgate_home $l $j
done
fi
file=`ls ./$i/sim*.tcl 2> /dev/null`
if [ ! ­z $file ]
then
echo ­e "Copia los scripts de Tcl/Tk\n"
if [ $inst ­eq 0 ]
then
./addsimsrc $tkgate_home `echo $file | cut ­d'/' ­f3`
126
índice
Adaptación de Tkgate a Computadores (GNU).
fi
cp $file $tkgate_home/scripts/
fi
if [ $inst ­eq 0 ]
then
if [ ­f ./$i/simulate.c ]
then
echo ­e "Modificando $tkgate_home/src/tkgate/simulate.c\n"
./modsimulate $tkgate_home ./$i/simulate.c
fi
if [ ­f ./$i/scripts_simulator.tcl ]
then
echo ­e "Modificando $tkgate_home/scripts/simulator.tcl\n"
./addsimulator $tkgate_home ./$i/scripts_simulator.tcl
fi
if [ ­f ./$i/module.c ]
then
echo ­e "Modificando $tkgate_home/src/gsim/module.c\n"
./modmodule $tkgate_home ./$i/module.c
fi
if [ ­f ./$i/elements.h ]
then
echo ­e "Modificando $tkgate_home/src/tkgate/elements.h\n"
./modelements $tkgate_home ./$i/elements.h
fi
if [ ­f ./$i/editgate.tcl ]
then
echo ­e "Modificando $tkgate_home/scripts/editgate.tcl\n"
./modeditgate $tkgate_home ./$i/editgate.tcl
fi
fi
127
índice
Adaptación de Tkgate a Computadores (GNU).
fi
done
l=`echo "$(grep gmcomput ./../nn/tkgate­1.8.6/locale/es/messages)"`
if [ ­z $l ]
then
for j in `ls ./*.msg`
do
l=`echo $j | cut ­d'_' ­f2 | cut ­d'.' ­f1`
./modmessage $tkgate_home $l $j
done
fi
if [ ­f ./comput.c ]
then
if [ ! ­f $tkgate_home/src/tkgate/comput.c ]
then
./modImake $tkgate_home/src/tkgate "comput"
./modtkgatewin $tkgate_home fi
echo ­e "Copiando $tkgate_home/src/tkgate/comput.c\n"
cp ./comput.c $tkgate_home/src/tkgate/
fi
if [ ! ­z $tkp ]
then
echo ­e "Modificando $tkgate_home/src/tkgate/Imakefile\n"
./modImake $tkgate_home/src/tkgate $tkp
echo ­e "Modificando $tkgate_home/src/tkgate/generic.c\n"
./modgeneric $tkgate_home/src/tkgate $tkp
fi
if [ ! ­z $gsp ]
then
128
índice
Adaptación de Tkgate a Computadores (GNU).
echo ­e "Modificando $tkgate_home/src/gsim/Imakefile\n"
./modImake $tkgate_home/src/gsim $gsp
echo ­e "Modificando $tkgate_home/src/gsim/generic.c\n"
./modgeneric $tkgate_home/src/gsim $gsp
fi
cd $tkgate_home
./configure
make make install
make clean
else
echo "Error: No existe el directorio del TkGate especificado."
fi
El fichero de retrasos se modifica mediante el programa moddelay, el formato del fichero que le pasamos por parámetro debe ser el siguiente:
technology default {
estructura de retraso para la puerta
} technology init {
estructura de retraso para la puerta
} El fichero debe tener extensión “.gdf”.
Los ficheros de mensajes se modifican mediante el programa modmessage. En cada linea del fichero que le pasamos por parámetro tendremos una etiqueta y su correspondiente texto. En cada linea solo puede haber un mensaje. El fichero debe tener extensión “.msg”.
nombre_etiqueta
129
texto
índice
Adaptación de Tkgate a Computadores (GNU).
Para modificar el fichero de simulación simulate.c usaremos el programa modsimulate. El fichero que le pasamos por parámetro debe estar dentro del directorio de la puerta y debe llamarse también simulate.c. Para añadir una nueva función a este fichero, el fichero debe contener lo siguiente:
La implementación de la función {
}
int SimInterface_command(SimInterface *si,const char *C)
} else if (sscanf(C," comando_del_simulador %s %d %d",buf,&a1,&a2) == 3) {
SimInterface_setComando(si,buf,a1,a2);
Modificamos el fichero “/scripts/simulator.tcl para poder iniciar o parar las simulaciones de los circuitos. Para modificarlo usaremos el comando addsimulator pasándole como parámetro un fichero con el siguiente formato:
end
funcion_que_finaliza_la_simulación
run
funcion_que_inicia_la_simulación
stop
funcion_que_para_la_simulación
step
funcion_que_avanza_una _época_en_la_simulación
Todas las funciones de este fichero estan escritas en algun fichero en formato Tcl/Tk.
130
índice
Adaptación de Tkgate a Computadores (GNU).
8 COMO CREAR NUEVAS PUERTAS
Este anexo contiene la explicación básica de como añadir puertas primitivas, describiendo todas sus características y su simulación para poderlas añadir al TkGate.
En primer lugar necesitaremos la imagen del circuito. Esta imagen es un mapa de bits. Podemos crear esta imagen con varios programas, como por ejemplo “Bitmap” o “KIconEdit”. Para crear estas imágenes he utilizado dos tipos de formatos el “bitmap” (.b) y el “X BitMap Image” (.xbm).
Los mapas de bits de las puertas se encuentran en el directorio /bitmaps del directorio fuente del TkGate. Como ejemplo tenemos la puerta and:
Para cada tipo de puerta tendremos que dibujar cada una de las diferentes rotaciones: 0º, 90º, 180º y 270º. Después en la parte inferior deberemos dibujar también las cuatro puertas a la misma distancia entre ellas que las anteriores pero esta vez resaltando los limites de la puerta, ya que estas seran las que veremos cuando seleccionemos la puerta. La distancia entre los dos grupos de puertas no es importante, siempre que no se superpongan, ya que modificaremos este parámetro más tarde.
Existen también puertas para las que solo existe una posición, es decir, que para todas las rotaciones posibles siempre es el mismo dibujo, como es el caso de la ram:
131
índice
Adaptación de Tkgate a Computadores (GNU).
Una vez creada la imagen la copiaremos en el directorio /bitmaps donde se encuentran todas las demás.
El segundo paso para poder crear una puerta primitiva es definir las funciones y características básicas de la puerta. Para definir estas funciones y características debemos escribir un fichero en C donde pondremos las estructuras básicas de la puerta que el editor del TkGate utilizará para inicializar las puerta, moverla, añadir cables, duplicarla,...,etc. A continuación, se describen las características generales de este fichero, pero que pueden cambiar dependiendo de el tipo de puerta. El fichero debe empezar con la siguiente linea:
#include "tkgate.h"
que nos servira para poder utilizar una serie de funciones y estructuras básicas que necesitaremos para crear la puerta. Estas estructuras estan definidas en varios ficheros del directorio /src/tkgate, como elements.h, gates.h, ..., etc.
La primera estructura que utilizaremos es la siguiente:
static iconDimensions and_iconDims[] = {
{0, 0, 20, 15, 10, 7},
{21, 0, 15, 20, 7, 9},
{16, 21, 20, 15, 9, 7},
{0, 16, 15, 20, 7, 10},
};
Esta estructura define las dimensiones para cada una de las orientaciones (0º, 90º, 180º i 270º, por este orden) de la puerta que estamos definiendo. Sustituiremos el nombre de la estructura por un nombre que haga referencia a la nueva puerta. Las lineas tienen la siguiente forma general:
{x, y, w, h, xc, yc}
Donde :
x e y son las coordenadas de la esquina superior izquierda del dibujo de la puerta respecto la esquina superior izquierda de la imagen.
w y h son el ancho y alto de la puerta en la rotación actual. xc e yc son las coordenadas del punto central de la puerta en la rotación actual.
132
índice
Adaptación de Tkgate a Computadores (GNU).
La linea:
static int and_iconBoldOffset = 37;
especifica el desplazamiento de la coordenada y (en pixels) desde la parte superior de dibujo al inicio de los iconos resaltados.
Una vez definidas todas las características de los iconos de la nuevas puerta, indicaremos al TkGate en que posiciones de las puertas queremos los diferentes puertos, ya sean de entrada, salida o bidireccional. Tomaremos como ejemplo la siguiente estructura:
struct locate and_out_loc[] ={ {10,0,10,0,D_RIGHT},
{0,­10,0,­10,D_UP},
{­10,0,­10,0,D_LEFT},
{0,10,0,10,D_DOWN}};
Para cada uno de los puertos necesitaremos una estructura como esta, donde se indican las posiciones del puerto para cada una de las rotaciones y la dirección. El formato de cada linea es:
{x1,y1,x2,y2,dir}
Donde:
x1, y1: son las coordenadas del puerto respecto del punto central de la rotación.
x2, y2: En puertas en las que no tengamos la posibilidad de añadir más puertos de este tipo, x2 será igual a x1 y y2 será igual a y1.
En puertas en las que queramos poder añadir más puertos de este tipo, x2 y2 especificarán el punto final de una linea por la que se distribuiran los puertos de este tipo. La linea debe ser horizontal o vertical.
dir: 133
Representa la dirección hacia donde debe salir el cable desde el puerto. Las diferentes posibilidades son: D_RIGHT, D_UP, D_LEFT o D_DOWN.
índice
Adaptación de Tkgate a Computadores (GNU).
El siguiente paso es definir una estructura para poder imprimir la puerta. Esta estructura es una descripción del símbolo de la puerta en postscript. Como ejemplo tenemos la definición para la puerta and:
static char *psAnd[] = {
"%",
"% An AND gate",
"%",
"/psand {",
" startgate",
" 2.5 7 moveto",
" ­10.5 7 lineto",
" ­10.5 ­7 lineto",
" 2.5 ­7 lineto",
" 2.5 0 7 ­90 90 arc",
" closepath",
" stroke",
" grestore",
"} bind def",
0
};
Debe empezar siempre con un “startgate” y acabar con “stroke”, “grestore”. El origen es el punto central del icono de la puerta, las unidades son pixels. En este caso el código postscript situa el cursor en (2.5, 7), dibuja una linea hasta (­10.5, 7), otra hasta (­10.5, ­7) y hasta (2.5, ­7). En el caso que movamos el cursor o dibujemos lineas o arcos, cambiará la posición del cursor, por tanto, para dibujar nuevas lineas deberemos considerar la nueva posición del cursor y no el centro del icono que consideraremos solo al inicio del dibujo.
Después dibuja un arco empezando en la posición actual y centrado en (2.5, 0). El arco tiene de radio 7 y empieza en ­90 grados y acaba en +90 grados. El comando “closepath” provoca que el último punto se conecte con el primero y el comando “stroke” hace que se redibuje el camino.
134
índice
Adaptación de Tkgate a Computadores (GNU).
La siguiente estructura contiene la información básica de la puerta, como ejemplo tomaremos la puerta nmos:
GGateInfo gate_nmos_info = {
0,
El código de la puerta. Es utilizado por el TkGate para distinguir algunos tipos de puertas. No es necesario poner ningun código en las puertas que creemos, simplemente poniendo un cero bastará.
"NMOS",
El nombre de la puerta. Es el nombre que utiliza el editor cuando seleccionamos una puerta del tipo, o miramos las características de la puerta.
"nmos",0x0,
El primer campo es el nombre de la puerta que utilizara el TkGate para crear las puertas. El segundo campo es una mascara que indicará el número de número de puerto en el que si añadimos un inversor la puerta cambiará. Por ejemplo tenemos la puerta “or”, donde "or:nor",0x2, indica que por defecto la puerta se llamará “or”, pero si añadimos un inversor en la salida, la puerta será una puerta “nor”.
"psnmos",psNmos,
Indican el nombre interno de la definición de postscript (“/psand {“) y el nombre de la estructura que hemos definido anteriormente.
{{"Ctl­t n", {"gmgate",0},
{"gmnmos",0,"tr"},
"gat_make nmos"},
{0}},
Esta estructura define los nombres de las entrada en los menús, la tecla de atajo y el comando a ejecutar cuando seleccionemos la entrada del menú o el atajo.
135
índice
Adaptación de Tkgate a Computadores (GNU).
El primer string es la secuencia de teclas de atajo. La estructura siguiente especifica en que submenú del menú “Insertar” aparecerá nuestra puerta. Si queremos crear un nuevo submenú simplemente asignaremos el nombre y el TkGate creará el menú y añadirá las puertas al nuevo submenú. La siguiente estructura define la entrada del menú, el primer campo es la etiqueta del nombre que aparecerá en el menú. Esta etiqueta será traducida por el TkGate según el idioma en el que lo ejecutemos. Más adelante se explica como crear estas etiquetas. Por último se especifica el comando a utilizar para crear la puerta. Siempre se utiliza la función “gat_make” junto con el nombre de la puerta, definido anteriormente.
Esta estructura siempre debe acabar con un {0}. Podríamos crear diferentes entradas para una misma puerta, dependiendo por ejemplo del número de puertos o de los inversores en los puertos. Por ejemplo la and tiene esta estructura:
{{"a", {"gmgate",0},
{"gmand",0,0,100}, "gat_make and"},
{"A", {"gmgate",0},
{"gmnand",3,0,101}, "gat_make and ­invert Z"},
{"Ctl­r a", {"gmredgate",0}, {"gmrand",0,0,100}, "gat_make and ­pins I=1"},
{"Ctl­r A",{"gmredgate",0}, {"gmrnand",3,0,101}, "gat_make and ­pins I=1 ­invert Z"},
{0}},
nmos_iconDims,
Estructura definida anteriormente. Especifica los tamaños de la puerta.
3,
Indica el número de tipos de puerto.
{ {"Z",OUT,1,1,nmos_drain_loc,0},
{"S",IN,1,1,nmos_source_loc,1},
{"G",IN,1,1,nmos_gate_loc,1}},
Estas estructuras definen cada uno de los tipos de puerto. El primer campo es el nombre del puerto. El segundo especifica el tipo (entrada IN, salida OUT, bidireccional INOUT). El tercer campo es el número de bits por defecto que tendrá el puerto. El cuarto indica el número de puertos de este tipo que tendrá la puerta cuando la creemos. El siguiente campo indica el nombre de la estructura definida anteriormente donde se especifican las 136
índice
Adaptación de Tkgate a Computadores (GNU).
coordenadas del puerto. Y el último campo indica si podremos añadir puertos de ese tipo a la puerta. Con un 0 no podremos añadir puertos y con un 1 si.
{{10,4,LJ},{0,­12,CT},{­10,4,RJ},{0,18,CT}},
Para cada una de las cuatro rotaciones deberemos especificar la posición de la etiqueta del nombre de la puerta. Tomando como origen el centro de la puerta en cada rotación. El último campo de cada estructura indica la justificación del texto (centrado CT, a la izquierda LJ, a la derecha RJ).
{1},
Esta estructura define varias características de la puerta. En caso de que queramos establecer la característica pondremos un 1 en caso contrario un 0. Las características de la puerta son:
Puede Rotar, No se pueden poner inversores, Es una conexión de entrada salida,
Se ve afectada la pantalla de la puerta por los cambios en las propiedades de los cables,
Tiene una función de movimiento especial,
El icono de la puerta es único.
{"I­Z","G­Z",0},
Define una cadena donde indicaremos el nombre de todos los retrasos de la puerta. Esta estructura siempre tiene que acabar en 0.
Generic_Make,
Generic_Init,
Generic_Delete,
Generic_GetExtents,
Generic_HitDistance,
Generic_Draw,
Generic_Move,
137
índice
Adaptación de Tkgate a Computadores (GNU).
Generic_Replicate,
Generic_AddInput,
Err_AddOutput,
Err_AddInOut,
Err_ChangePin,
Nop_SimStateFunc,
Nop_SimHitFunc,
Generic_PSWrite,
Generic_EditProps,
Generic_VerSave,
};
Aquí estan todas las funciones que necesitará el editor del TkGate para manipular la puerta. Podemos utilizar funciones genéricas que encontraremos en el fichero “/src/tkgate/generic.c” o crear nuestras propias funciones. Por ejemplo, necesitaremos crear una función de dibujo especial para una puerta cuando tengamos alguna animación controlada desde Tcl/Tk y necesitemos consultar una variable de posición para repintar la puerta. Si incluimos una función especifica para nuestra puerta deberemos añadir la cabecera de la función el la parte superior del fichero. El orden de estas funciones debe ser siempre el mismo, como se indica en la definición de la estructura en el fichero “/src/tkgate/elements.h”.
Por último crearemos una función de inicialización para la puerta. Esta función debe ser como la siguiente:
void init_nmos()
{
Pixmap P;
P = Pixmap_registerFromFile("nmos","nmos.b");
gateinfo_iconInit(&gate_nmos_info,P,nmos_iconDims,nmos_iconBoldOffset);
RegisterGate(&gate_nmos_info);
}
El siguiente paso para crear la puerta es copiar el fichero que hemos creado en el directorio “/src/tkgate”. Una vez copiado, tenemos que incluir el fichero en la lista de ficheros que se compilaran para formar parte del TkGate. Este fichero es el “Imakefile” en el directorio 138
índice
Adaptación de Tkgate a Computadores (GNU).
“/src/tkgate”. Deberemos añadir una entrada con el nombre del fichero objeto de nuestra puerta, el la declaración de la variable GOBJS:
GOBJS=joint.o block.o in.o out.o tri.o ground.o vdd.o tap.o \
clock.o dip.o switch.o and.o or.o xor.o buffer.o adder.o mux.o demux.o \
register.o flipflop.o lshift.o rshift.o arshift.o roll.o concat.o tribuffer.o \
ram.o rom.o mult.o divide.o tty.o nmos.o pmos.o comment.o frame.o led.o \
nuestra_puerta.o
Y una entrada con el nombre del fichero fuente en la declaración de la variable GSRCS:
GSRCS=joint.c block.c in.c out.c tri.c ground.c vdd.c tap.c \
clock.c dip.c switch.c and.c or.c xor.c buffer.c adder.c mux.c demux.c \
register.c flipflop.c lshift.c rshift.c arshift.c roll.c concat.c tribuffer.c \
ram.c rom.c mult.c divide.c tty.c nmos.c pmos.c comment.c frame.c led.c \
nuestra_puerta.c
Después deberemos indicar al TkGate que inicie la puerta al arrancar. Esto se modifica en el fichero “generic.c” en el directorio “/src/tkgate/. Al principio del fichero añadiremos la cabecera de la función de inicialización definida anteriormente:
...
void init_nmos();
void init_pmos();
void init_comment();
void init_frame();
void init_led();
void init_nuestra_puerta();
...
139
índice
Adaptación de Tkgate a Computadores (GNU).
Y al final del fichero, en la función “init_gates()” añadiremos nuestra función:
void init_gates()
{
init_and();
/* */
init_or();
/* */
init_xor();
/* */
...
init_comment();
/* */
init_frame();
/* */
init_led();
/* */
init_nuestra_puerta();
buildMakeMenuData();
#if 0
dumpIconData();
#endif
}
Para crear las etiquetas de texto de los menús o los mensajes, tendremos que modificar el fichero “messages” de los directorios del directorio “/locale/” que vayamos a utilizar, por ejemplo el directorio “es” tiene los mensajes en español, “ca” en catalán, ..., etc.
Para crear una etiqueta de texto simplemente crearemos una entrada como la siguiente:
nombreEtiqueta
Texto
Si el texto ocupa más de una linea usaremos las clausulas “­begin­” y “­end­”.
Estas etiquetas se pueden usar tanto en la parte del editor como en el simulador y en los programas en Tcl/Tk. Por ejemplo, podemos utilizar estas etiquetas para crear las entradas de los menús como hemos visto antes o para crear mensajes de error como el siguiente:
errorGate(g­>g_name,"[m nuestra_etiqueta]");
Donde el TkGate sustituirá nuestra_etiqueta por el texto, dependiendo del idioma en el que estemos ejecutando el TkGate.
140
índice
Adaptación de Tkgate a Computadores (GNU).
El siguiente paso es definir los retrasos de la puerta. Para esto modificaremos el fichero “/gdf/default.gdf”. En este fichero existen dos tipos de tecnologías “default” y “init”, deberemos añadir una entrada de nuestra puerta en cada una de las dos. Siguiendo con el ejemplo del transistor NMOS, habíamos definido las etiquetas de los retrasos como “{"I­
Z","G­Z",0}”. Para cada tecnología añadiremos una estructura como la siguiente:
primitive nmos {
delay<I­Z> = 2;
delay<G­Z> = 1;
area = bits(Z);
}
Donde para cada etiqueta definiremos una entrada delay<etiqueta_retraso> = valor; , y por último definiremos el área de la puerta. Podemos utilizar cualquier función aritmética y las funciones:
bits(puerto) = número de bits del puerto.
num(puerto) = número de pins en el puerto.
inv(puerto) = Indica si el puerto tiene inversores o devuelve el número de inversores si el puerto es un grupo de puertos.
log(expr) = devuelve el exponente del logaritmo en base dos de la expresión.
En la tecnología “unit” el valor de los retrasos debe ser uno.
Después de definir toda la parte del editor, deberemos definir la parte del simulador, donde indicaremos el funcionamiento de la puerta en si, la función para chequear la puerta,..., etc. Estas funciones se definiran en un fichero en C, que guardaremos en el directorio “/src/gsim/”. El fichero tiene la siguiente estructura:
Debe empezar con las siguientes lineas:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "gsim.h"
141
índice
Adaptación de Tkgate a Computadores (GNU).
que nos serviran para poder utilizar una serie de funciones y estructuras básicas que necesitaremos para simular la puerta. Estas estructuras estan definidas en varios ficheros del directorio /src/gsim, como gateinfo.h, module.h, ..., etc.
Podemos definir una serie de etiquetas que nos ayudaran a simular la puerta, para hacer que el código sea más fácil de leer. Como ejemplo tenemos las etiquetas del biestable D:
Estas etiquetas definen el número de puerto:
#define FF_Q
0
#define FF_NQ
1
#define FF_D
2
#define FF_EN
3
#define FF_CLR
4
#define FF_CK
5
Estas etiquetas definen el número de retrasos en la tabla de retrasos:
#define FF_DELAY_SETUP
0
#define FF_DELAY_HOLD
1
#define FF_DELAY_OUT
2
Si el tipo de puerta que estamos implementando es secuencial necesitaremos crear una estructura donde guardaremos el valor temporal de la puerta. En el biestable D tenemos la siguiente estructura:
struct ff_data {
int
last_change; /* Time of last data change */ int
hold_wait;
/* Hold wait until this time */
SState
state;
/* Flipflop state */
};
Si la puerta es combinacional no será necesaria, ya que la salida solo dependerá del valor de las entradas.
142
índice
Adaptación de Tkgate a Computadores (GNU).
A continuación añadiremos las cabeceras de las funciones que definiran el comportamiento de la puerta:
static void Flipflop_processEvent(SGate*,EvQueue*,SEvent*);
static int Flipflop_checkGate(SGate*);
static void Flipflop_initGate(EvQueue*,SGate*);
La función processEvent indicará el comportamiento de la puerta cuando se cambie el valor de una entrada.
La función checkGate describirá la comprobación del estado de las entradas y las salidas de la puerta y otras posibles características de la puerta. Por ejemplo podemos exigir que una entrada tenga un solo bit, entonces esta función se encargaría de comprobar que la entrada tuviera un solo bit, en caso contrario mostraría un mensaje de error y pararia el inicio de la simulación.
La función initGate se utiliza para iniciar las estructuras en el caso de las puertas secuenciales o para establecer el valor de las salidas cuando iniciamos la simulación.
El siguiente paso es, como en el editor, rellenar la estructura que indica las características de la puerta: static SGateInfo ff_info = {
0,
El código de la puerta. Es utilizado por el TkGate para distinguir algunos tipos de puertas. No es necesario poner ningun código en las puertas que creemos, simplemente poniendo un cero bastará.
"ff",0x0,
Como en el editor, el primer campo es el nombre de la puerta que utilizara el TkGate para crear las puertas. El segundo campo es una mascara que indicará el número de número de puerto en el que si añadimos un inversor la puerta cambiará. Por ejemplo tenemos la puerta “or”, donde "or:nor",0x1, indica que por defecto la puerta se llamará “or”, pero si añadimos un inversor en la salida, la puerta será una puerta “nor”. A diferencia del editor la máscara esta vez es 0x1 ya que el orden de los puertos ha cambiado en la parte del simulador.
143
índice
Adaptación de Tkgate a Computadores (GNU).
6,
Indica el número de tipos de puerto.
{{"Q",GIO_OUT,PF_CUT},
{"_Q",GIO_OUT,PF_CUT},
{"D",GIO_IN,PF_CUT},
{"EN",GIO_IN,PF_CUT},
{"CLR",GIO_IN,PF_CUT},
{"CK",GIO_IN,PF_CLOCK|PF_CUT}},
Estas estructuras definen cada uno de los tipos de puerto. El primer campo es el nombre del puerto. El segundo especifica el tipo (entrada GIO_IN, salida GIO_OUT, bidireccional GIO_INOUT). El tercer campo define varias características de los puertos, por ejemplo, para un puerto normal, pondríamos la etiqueta PF_CUT, para un puerto en el que tenemos la posibilidad de añadir pins podríamos la etiqueta PF_MULTI, para un puerto de reloj pondríamos la etiqueta PF_CLOCK y para un puerto constante pondríamos la etiqueta PF_CONST. Como en el caso de la señal CK del biestable D podemos establecer mas de una característica haciendo una “o” entre las etiquetas. Esto indica que a la entrada podemos tener tanto un reloj como un conmutador o cualquier otro circuito que realice las transiciones.
El orden de estas estructuras debe coincidir con las etiquetas que hemos definido anteriormente.
{{"setup",bit(1),­1},
{"hold",0,­1},
{"CK­Q",0,1},
{0}},
Estas estructuras definen cada uno de los retrasos. El primer campo es el nombre del retraso que debe coincidir con el nombre que hemos puesto en la parte del editor. El segundo campo es una máscara que indica el conjunto de los puertos de entrada. El tercer campo es el número de puerto de salida. Esta estructura debe acabar siempre con un {0}.
144
índice
Adaptación de Tkgate a Computadores (GNU).
Generic_copyGate,
Flipflop_processEvent,
Flipflop_checkGate,
Flipflop_initGate,
Generic_setProp,
};
Aquí estan todas las funciones que necesitará el simulador del TkGate para manipular la puerta. Podemos utilizar funciones genéricas que encontraremos en el fichero “/src/gsim/generic.c” o crear nuestras propias funciones. El orden de estas funciones debe ser siempre el mismo, como se indica en la definición de la estructura en el fichero “/src/gsim/gateinfo.h”.
Definiremos ahora la función de Inicialización. static void Flipflop_initGate(EvQueue *Q,SGate *g)
{
struct ff_data *rd = (struct ff_data*) malloc(sizeof(struct ff_data));
g­>g_data = rd;
rd­>last_change = 0;
rd­>hold_wait = 0;
SState_init(&rd­>state,g­>g_ports.port[FF_Q]­>p_net­>n_nbits);
SState_unknown(&rd­>state);
}
Esta función crea e inicia la estructura o la variable que guardará la información de la puerta y guarda el puntero a la estructura en la definición de la puerta (g­>g_data = rd) para poder ser utilizada más tarde.
145
índice
Adaptación de Tkgate a Computadores (GNU).
Definimos ahora la función que chequeará la puerta antes de ser simulada, en el caso del sumador es la siguiente:
static int Add_checkGate(SGate *g)
{
Mediante las estructuras SPort definidas en el fichero “/src/gsim/gateinfo.h”, la estructura de la puerta y las etiquetas definidas anteriormente, comprobaremos por ejemplo el número de bits de cada uno de los puertos.
SPort *Z = g­>g_ports.port[ADD_Z];
SPort *CO = g­>g_ports.port[ADD_CO];
SPort *A = g­>g_ports.port[ADD_A];
SPort *B = g­>g_ports.port[ADD_B];
SPort *CI = g­>g_ports.port[ADD_CI];
int n;
if (CI­>p_net­>n_nbits != 1 || CO­>p_net­>n_nbits != 1) {
errorGate(g­>g_name,"Carry inputs/outputs must be single bit.");
return ­1;
}
Si el número de bits es erroneo, podemos mostrar un mensaje de error con la función errorGate y parar el inicio de la simulación devolviendo ­1.
n = Z­>p_net­>n_nbits;
if (A­>p_net­>n_nbits != n || B­>p_net­>n_nbits != n) {
errorGate(g­>g_name,"Inputs and output must be same bit width.");
return ­1;
}
return 0;
}
146
índice
Adaptación de Tkgate a Computadores (GNU).
La siguiente función especifica el funcionamiento de la puerta, según el valor de las entradas o también en el caso que sea secuencial del valor guardado. En el caso de la puerta “or” tenemos la siguiente función:
static void Or_processEvent(SGate *g,EvQueue *Q,SEvent *E)
{
Necesitaremos una variable de tipo SPort para cada salida, y una variable SState para cada puerto, ya sean entradas como salidas. La estructura SPort contiene todas las características del puerto y la estructura SState contiene el valor de un puerto.
SPort *Z = g­>g_ports.port[OR_Z];
SState *S = alloc_SState();
SState *cS = alloc_SState();
int i;
SState_reinit(S,Z­>p_state.nbits);
if (g­>g_ports.num == 2) {
/* Reduction gate */
SState *I = SGate_allocPortState(g,OR_I);
Con esta función guardaremos en la variable I el estado del puerto indicado por OR_I, es decir de la entrada, para poder ser evaluado posteriormente.
int n0 = 0;
int n1 = 0;
for (i = 0;i < I­>nbits;i++) {
int sy = SState_getBitSym(I,i);
Con esta función guardaremos en sy el bit i del valor de la entrada.
147
índice
Adaptación de Tkgate a Computadores (GNU).
if (sy == SYM_ONE) n1++;
if (sy == SYM_ZERO) n0++;
}
if (n1 > 0)
SState_one(S);
Con esta función establecemos que el valor del estado de salida es un uno lógico.
else if (n0 == I­>nbits)
SState_zero(S);
Con esta función establecemos que el valor del estado de salida es un cero lógico.
else
SState_unknown(S);
Con esta función establecemos que el valor del estado de salida es un valor desconocido.
free_SState(I);
} else {
/* Standard gate */
SState_zero(S);
for (i = OR_I;i < g­>g_ports.num;i++) {
SState *istate = SGate_allocPortState(g,i);
SState_expandExtend(istate,S­>nbits);
SState_or(S,S,istate,0);
free_SState(istate);
}
}
148
índice
Adaptación de Tkgate a Computadores (GNU).
Encolamos en la cola de eventos del simulador (Q) un evento en el que el puerto Z pasará a tener el estado S con un retraso especificado por el retraso OR_DELAY definido en la puerta.
EvQueue_setPort(Q,Z,S,g­>g_delayParms[OR_DELAY]);
Liberamos de memoria los estados creados.
free_SState(S);
free_SState(cS);
}
Muchas de las funciones utilizadas en esta función las podemos encontrar en el fichero “/src/gsim/state.c”.
Por último crearemos una función de inicialización para la puerta. Esta función debe ser como la siguiente:
void init_flipflop()
{
SGateInfo_register(&ff_info,0);
}
Esta función se ejecuta cuando iniciamos el TkGate, no cuando iniciamos la simulación.
El siguiente paso para crear la puerta es copiar el fichero que hemos creado en el directorio “/src/gsim”. Una vez copiado, tenemos que incluir el fichero en la lista de ficheros que se compilaran para formar parte del TkGate. Este fichero es el “Imakefile” en el directorio “/src/gsim”. Deberemos añadir una entrada con el nombre del fichero objeto de nuestra puerta, el la declaración de la variable OBJS:
OBJS=gsim.o verilog.o thyme.o process.o module.o generic.o state.o cpath.o \
memory.o and.o or.o xor.o buf.o switch.o bufif.o nmos.o pmos.o add.o \
supply.o clock.o register.o flipflop.o mux.o demux.o concat.o mult.o div.o ram.o \
149
índice
Adaptación de Tkgate a Computadores (GNU).
rom.o tty.o lshift.o rshift.o arshift.o roll.o tap.o led.o nuestra_puerta.o
Y una entrada con el nombre del fichero fuente en la declaración de la variable SRCS:
SRCS=gsim.c verilog.c thyme.c process.c module.c generic.c state.c cpath.c \
memory.c and.c or.c xor.c buf.c switch.c bufif.c nmos.c pmos.c add.c \
supply.c clock.c register.c flipflop.c mux.c demux.c concat.c mult.c div.c ram.c \
rom.c tty.c lshift.c rshift.c arshift.c roll.c tap.c led.c nuestra_puerta.c
Después deberemos indicar al TkGate que inicie la puerta al arrancar. Esto se modifica en el fichero “generic.c” en el directorio “/src/gsim/. Al principio del fichero añadiremos la cabecera de la función de inicialización definida anteriormente:
...
void init_arshift();
void init_roll();
void init_tty();
void init_tap();
void init_led();
void init_nuestra_puerta();
...
Y al final del fichero, en la función “init_gates()” añadiremos nuestra función:
void init_gates()
{
SHash_init(&gate_types);
init_ignored();
init_process();
...
init_rshift();
init_arshift();
150
índice
Adaptación de Tkgate a Computadores (GNU).
init_roll();
init_tty();
init_tap();
init_led();
init_nuestra_puerta();
}
Con todo esto ya tendríamos la definición de la puerta completa. Ahora solo tendríamos que compilar el código y sino hemos cometido ningun error, podremos ejecutar el TkGate con la puerta creada incluida.
Ahora bien, si necesitamos crear alguna animación o crear ventanas especiales para las puertas, necesitaremos la crear la definición de esta ventana o las funciones de la animación en un fichero con funciones de Tcl/Tk. Por ejemplo, para el interruptor dip necesitamos un cuadro de dialogo en el que podamos cambiar el valor del interruptor mientras simulamos. Esta función esta definida en el fichero “/scripts/simulator.tcl”:
proc tkg_dipEntry {g v x y} {
global dip_set
if { [catch { set e $dip_set($g) } ] } { set e "" }
if { $e != "" } { raise $e
return
}
for {set i 0} { [catch { set w [toplevel .dipe$i] }] } { incr i } { }
set dip_set($g) $w
wm resizable $w 0 0
wm title $w "TkGate: Dip Value"
wm geometry $w [offsetgeometry . $x $y]
151
índice
Adaptación de Tkgate a Computadores (GNU).
wm transient $w .
bind .scope <Destroy> "+ set dip_set($g) \"\"; destroy $w"
label $w.t ­text "$g:"
entry $w.entr ­width 10
$w.entr insert 0 $v
button $w.apply ­text [m b.apply] ­command " set q \[ gat_setDip $g \[ $w.entr get \] \]; $w.entr delete 0 end; $w.entr insert 0 \$q"
button $w.close ­text [m b.close] ­command " set dip_set($g) \"\"; destroy $w"
bindtags $w.entr [concat [list HexEntry] [bindtags $w.entr]]
bind $w.entr <Return> "$w.apply configure ­state active; after 500 \"$w.apply configure ­state normal\"; $w.apply invoke"
pack $w.t ­side top ­fill both
pack $w.close ­side bottom ­fill both ­pady 3
pack $w.entr $w.apply ­side left ­pady 5 ­padx 5 }
El fichero donde definimos estas funciones debe estar en el directorio “/scripts” y debemos incluir el en fichero “/scripts/tkgate.tcl” una entrada como la siguiente:
source $sd/nombre_del _fichero.tcl
Después, para poder usar esta función necesitaremos utilizar la función DoTcl, como en el interruptor dip:
void Dip_SimHitFunc(EditState *es,GCElement *g)
{
GSimSwitch *ss = SHash_find(es­>smod­>switches,g­>ename);
DoTcl("tkg_dipEntry %s %x %d %d",ss­>gname,g­>u.sw.dipval,ctow_x(g­>xpos),ctow_y(g­>ypos));
}
152
índice
Adaptación de Tkgate a Computadores (GNU).
Si necesitamos consultar alguna variable en Tcl utilizaremos la función, Tcl_GetVar, como en el siguiente ejemplo:
void Dip_EditProps(GCElement *g,int isLoadDialog)
{
Tcl_Interp *tcl = XGate.tcl;
Generic_EditProps(g,isLoadDialog);
if (isLoadDialog) {
DoTcl("set edgat_dip %x",g­>u.sw.dipval);
} else {
const char *p;
if ((p = Tcl_GetVar(tcl,"edgat_dip",TCL_GLOBAL_ONLY)))
if (sscanf(p,"%x",&g­>u.sw.dipval) != 1)
message(1,msgLookup("err.badhex"),p);
/* "Illegal hex value '%s' ignored." */
g­>u.sw.perm_dipval = g­>u.sw.dipval;
}
}
A las funciones de Tcl no podemos acceder desde el simulador, ya que no son accesibles algunas estructuras como el “Xgate” donde tenemos el interprete de Tcl. Para solucionar este problema debemos crear una función en C que llame a las funciones de Tcl/Tk necesarias. Este tipo de funciones se debe crear dentro del fichero “/src/tkgate/simulate.c”, como ejemplo la función que controla el ascensor:
void SimInterface_setElev(SimInterface *si,char *gname,int value)
{
GCElement *g;
g = sim_findGate(gname);
if (!g) return;
switch(value){
case 0: DoTcl("tkg_initelev %s",gname);break;
case 1: DoTcl("tkg_elevup %s",gname);break;
case 2: DoTcl("tkg_elevdown %s",gname);break;
153
índice
Adaptación de Tkgate a Computadores (GNU).
case 3: DoTcl("tkg_elevpause %s",gname);break;
case 4: DoTcl("tkg_elevpause %s",gname);DoTcl("errmsg \"[m gmelev.updown]\""); break;
}
}
También deberemos añadir una entrada como la siguiente en la función SimInterface_command, esta función recibe los comandos de simulación y ejecuta las funciones asociadas: int SimInterface_command(SimInterface *si,const char *C)
{
...
} else if (sscanf(C," simerror %[^\n]",buf) == 1) {
/* A run­time error */
message(1,buf);
DoTcl("tkg_simStop");
} else if (sscanf(C," elevatorf %s %d",buf,&a1) == 2) {
/* Set value of an elevator */
SimInterface_setElev(si,buf,a1);
}
#if 0
if (has_errors)
ob_end_frame();
#endif
return 0;
}
Para utilizar este tipo de funciones desde el simulador, es decir, utilizarlas en la definición de la puerta en la parte del simulador, podemos crear una función como la siguiente:
154
índice
Adaptación de Tkgate a Computadores (GNU).
void Elev_reportValue(SGate *g, int pbe)
{
char buf[STRMAX],*p;
p = buf;
p += sprintf(p,"elevatorf %s %d",g­>g_name,pbe);
*p = 0;
sendMsg("%s",buf);
}
Donde la función sendMsg() llamará a la función que hemos creado mediante la función SimInterface_command que modificamos antes.
Por otra parte si queremos llamar a funciones de C desde Tcl/Tk deberemos crear un enlace a la función en C. Si miramos en el fichero “/src/tkgate/tkgatewin.c” tenemos varios ejemplos de como hacerlo. Para crear el enlace a la función en C, utilizaremos el comando Tcl_CreateCommand como en el siguiente ejemplo:
Tcl_CreateCommand(tcl,"nombre _de_la_funcion_para_tcl"
,nombre_de_la_funcion_en_C
,(ClientData)root
,0);
Después, desde las funciones de Tcl/Tk simplemente tendremos que llamar a la función con el nombre que le hemos puesto al enlace, pasándole los parámetros correspondientes.
155
índice