QUE SON LOS PLD?

Los PLD son dispositivos digitales que se pueden configurar por el usuario para implementar una amplia
variedad de funciones lógicas en sistemas. Estos dispositivos tienen pines de entrada,un arreglo lógico
programable y pines de entrada y salida. Muchos PLD's tienen salidas programablesque incrementan su
flexibilidad haciendolos útiles para una gran variedad de aplicaciones (fig. 1).

FIG 1. Diagrama a bloques de los PLD's.

ARQUITECTURA BASICA DE LOS PLD's

Las entradas del PLD entran al arreglo lógico los cuales son hechos de columnas y filas. La figura 2 muestra
tal arreglo. Cada par de columnas representa la entrada negada o complementada y la misma entrada sin
negar. cada fila constituye un término AND. Las conexiones lógicas se estblecen entre diferentes columnas y
filas en el arreglo para determinar cual combinación de entradas llevaran al termino AND a un nivel alto.

Mas de un término AND alimenta una compuerta OR. La salida es la suma de rpoductos.

1
 FIG 2. Arreglo AND-OR usado en la mayoría de los PLD.

PORQUÉ EL USO DE LOS PLD's?

La flexibilidad y programabilidad de los PLD's hacen que el diseño con ellos sea mucho más rápido que
diseñar con lógica discreta. Esto es, se puede utilizar el PLD para implementar la mayoría de las funciones
hechas con los cientos de dispositivos de la familia lógica "7400". Tambien cabe recalcar que se toma menos
espacio sobre el circuito impreso que con los dispositivos discretos.

Una vez tomada la decisión de cambiar de lógica discreta a PLD, la siguiente pregunta es:
"Cuál PLD?" Los más flexible de un PLD es,lo utilizable que es, ya que un diseñador puede implementar
cualquier ecuación lógica. Hay que escoger PLD's que sean compatibles con los otros dispositivos que se
estén utilizando. Hay que tomar en consideración la potencia que se requiere que se gaste, ya que hay unos
que requiren menos potencia para trabajar que otros. La estabilidad es otro factor importante.

PROCESO DE DISEÑO
Un proceso tipico para diseñar con los PLD es el siguiente:
1. La lógica a ser implentada en un PLD se expresa en un archivo fuente usando un lenguaje de diseño. Estos
incluyen ecuaciones booleanas, tablas de verdad y sintaxis de máquinas de estado.
2. El archivo se procesa por un compilador lógico para generar un archivo JEDEC del diseño. El compilador
configura los bits en le archivo JEDEC los cuales determinan las conecciones que se harán en el arreglo
lógico y configurar así las salidas. La figura 3 es una muestra de este proceso.

2
 FIG 3. Proceso típico de diseño para PLD's

PRACTICAS
PRACTICA No 1
En esta práctica el alumno analizará la estructura de los archivos fuentes y la sintaxis necesaria para la
implementación y diseño de los PLD's mediante el paquete computacional PLDshell Plus V3.0.

ARCHIVOS FUENTES.
En estos archivos es donde se realizará el diseño del circuito. Lo mínimo que contienen es la sección de
declaración y al menos uno de las siguientes secciones de diseño: Máquinas de estado, ecuaciones o tablas de
verdad. Cabe mencionar que se puede tener más de una tabla de verdad o máquinas de estado. Estos archivos
tienen la extención "PDS" editándose o formándose desde un simple procesador de palabras, en donde el que
más se utiliza es el EDIT del DOS. Para entrar al paquete debemos teclear PLDSHELL <return>. Una vez
hecho esto, entramos al editor con la opcion EDIT dando el nombre del archivo (con extensión PDS). En la
figura 4 se muestra el cuerpo del programa para un archivo fuente.

________________________________________________________________________________
SECCION DE DECLARACION (REQUERIDA)----Debe ser la primer seccion
Información de Cabecera (opcional)

Declaracion del Chip y de los pines (REQUERIDA)

CHIP DISEÑO_A 22V10

PIN 1 CLK
PIN 2 IN1
PIN 3 OUT1
***************************************************************************************S
ECCION DE DISEÑO ---Al menos una es requerida: Máquinas de estado, ecuaciones o tabla.
________________________________________________________________________________
SECCION DE MAQUINA DE ESTADO (OPCIONAL)
S1:=BUS_REQ -> S2
S2:= BUS_CONT -> S3
+ BUS_WAIT -> S2
________________________________________________________________________________
SECCION DE ECUACIONES (OPCIONAL)

3
 OUTA = IN1 * IN2
OUTB := IN1 * /IN2
+IN1 * IN3
________________________________________________________________________________
SECCION DE TABLA DE ESTADO (OPCIONAL)
T_TAB ( in1 in2 >> out1 out2 )
0 0 : 0 0
0 1 : 1 1
1 0 : 0 1
1 1 : 1 0

***************************************************************************************S
ECCION DE SIMULACION (OPCIONAL) ---debe ser la última sesión.

SETF OE /CLK IN1 IN2

PRLDF /Q2 /Q1 /Q0
SETF IN1
CLOCKF CLK
________________________________________________________________________________
FIG 4. Cuerpo del programa de un archivo fuente para PLDShell Plus

Se pueden introducir comentarios para una mejor comprensión del programa al momento de editarlos. Estos
comentarios se ponen despues de un punto y coma (;).

Los nombres de las señales pueden incluir de 1 a 14 caracteres alfanuméricos (A-Z,a-z y del 0 al 9 y el signo
_ ). el primer caracter debe ser uno alfanumérico.

Enseguida se describen las secciones que conforman el cuerpo del programa.

SECCION DE DECLARACION
Esta sección es opcional al usuario. Aqui se encuentran los datos tanto del diseñador como del diseño. Un
ejemplo sería el siguiente:

;esto es un comentario
TITLE Controlador de DRAM para una Workstation 386
PATTERN 386_DRAM
REVISION 1 ; número de veces que se ha editado
AUTHOR Carlos Valencia Soberanes ;nombre
COMPANY ITSON ;tu compañía
DATE 12/24/96 ;fecha

A continuación, y que si es obligatorio ponerlo, es el tipo de chip que se va a utilizar, como se observa en la
figura 4. Seguido por los nombres de las entradas y salidas que se utilizarán y refiriéndose a el número de PIN
donde se encontrarán en el CHIP. (véase fig. 4)

SECCION DE DISEÑO.

Al menos uno de los siguientes se requiere: Máquinas de estado, Ecuaciones o Tablas de verdad.
Véase Fig 4.

SECCION DE MAQUINA DE ESTADO.

Aqui se pueden implementar ecuaciones secuenciales por medio de tablas de estado, pudiendo así

4
implementar de una manera fácil contadores de n bits y muchos otros circuitos que con lógica discreta, el
tamaño que ocuparía fuera relativamente grande.

SECCION DE ECUACIONES.

Los circuitos combinacionales son fácilmente implementados usando ecuaciones booleanas con PLDShell
Plus. La sección de ecuaciones empieza con la palabra EQUATIONS. La salida de la ecuación es un nombre
de un PIN dado con anterioridad

Una lista completa de los operadores se muestran en la siguiente tabla.

Operador Descripción
/ NOT (Complemento)
* AND
+ OR
:+: XOR
= Salida combinacional
:= Salida con registro (flip flop)
*= Salida con latch

A continuación se muestra algunas funciones lógicas implementadas usando ecuaciones booleanas.

EQUATIONS
AND1 = IN1 * IN2 ;LOGICAL AND
/NAND1 = IN1 * IN2 ;LOGICAL NAND
OR1 = IN1 + IN2 ;LOGICAL OR
/NOR1 = IN1 + IN2 ;LOGICAL NOR
NOT1= / IN1 ;LOGICAL NOT
XOR1 = IN1 :+: IN2 ;LOGICAL XOR
XOR2 = IN1*IN2 :+: INA*INB + INC ;((IN1*IN2) :+: (INA*INB)) + INC
SUM1 = IN1 * IN2 * IN3 ;SUMA DE PRODUCTOS
+ /IN1 * ( /IN2 * IN4)
+ IN1 * IN5 * IN6

Las salidas se pueden configurar como activas bajas o activas bajas, esto en la sección de declaración de los
PINES. Se declaran como activas bajas cuando el símbolo de Slash va antes de la palabra de salida
(/out1=in1*in2).

Se cuenta también con un habilitador de salida (Output Enable) el cual permite tener una salida de tercer
estado (alta impedancia), esto es, si la ecuación a evaluar es 1 lógico, habilita la salida del CHIP, en cambio si
evalúa a 0 lógico deshabilita la salida (Tercer estado). Las ecuaciones con OE se identifican cuando el nombre
de la señal de salida tiene la extensión .TRST.
ejm:
OUT1 = IN1 * IN2 * /IN3
OUT1.TRST = IN4 ;SI IN4 ESTA EN UNO OUT1 SE VA A HABILITAR
;SI ESTA EN CERO OUT1 ESTARA EN TERCER ESTADO

SECCION DE TABLA DE VERDAD.

Las tablas de verdad proveen una efectiva manera de describir un diseño o partes de un diseño. Por ejemplo,
las tablas de verdad son muy usadas para los decodificadores. PLDShell plus soporta más de una tabla de
verdad en su diseño.

Para comenzar con esta sección es necesario poner la palabra "T_TAB". Las tablas tienen posiciones
dependientes, por ejemplo, cada entrada tiene una correspondiente columna para cada fila de la tabla. La
primer linea de la tabla lista los nombres de entrada y de salida dentro de paréntesis. Las filas siguientes son

5
los valores de cada salida para cada combinación de entrada.

Las entradas se ponen primero, seguidas por un separador (>>) y luego las salidas. Las entradas se separan
por espacios o comas. Valores legales para la tabla son:
0 =Falso
1 =Verdadero
X =No importa
Un ejemplo es el siguiente:

;Tabla de verdad combinacional

T_TAB ( in1 in2 >> out1 out2 )
0 0 : 0 0
0 1 : 1 1
1 0 : 0 1
1 1 : 1 0

SECCION DE SIMULACION
Uno de los puntos fuertes de éste Software es que permite la simulación antes de llevar a cabo la
implementación y la programación del chip, para evitar posibles fallas en el diseño.

La simulación como las secciones anteriores es un proceso muy fácil. Para empezar con ella debemos teclear
la palabra SIMULATION alntes de proseguir.

Por ejemplo, tenemos un programa donde su salida esta regida por la siguiente ecuación ubicada en la sección
de diseño:

out = in1* in2* /in3

Lo que debemos de poner en la sección de simulación es lo siguiente:

TRACE_ON out in1 in2 in3
Esto para indicarle que vamos a empezar con la simulación. Hay que poner todas las variables que toman
parte en la o las ecuaciones.

Para simular unas entradas, utilizamos la instrucción SETF seguido por los valores de las entradas que
queramos inicializar, por ejm:
SETF in1 /in2 in3
Aquí le decimos que in1=1 in2=0 in3=1 por lo que al evaluar la función el resultado va a ser cero.

Si tenemos un circuito donde un de sus entradas sea un reloj y queremos simular a éste, usamos la instrucción
:
CLOCKF entrada_clk
Así el reloj dara un pulso a la entrada, provocando una salida la cual la observaremos en el diagrama de
tiempos que el software nos ofrece. Podemos usar ciclos for de la siguiente manera:
FOR X := 0 TO 3 DO
BEGIN
CLOCKF CLK
END
Asi obtendremos cuatro pulsos seguidos.

Para obtener el diagrama de tiempos, una vez hecho y compilado el programa (Mediante la opción COMPILE
el cual genera los archivos necesarios para la programacion de el chip) se escoge la opción VIEW y
seleccionando Vector/Waveform.

Una vez hecho ésto, el programa dara el diagrama con todas las entradas y las salidas que se hayan utilizado.

6
EJEMPLO DE PROGRAMA.
Se cuenta con un GAL22V10 el cual se quiere programar con tres entradas y una salida. La caracteristica de
la ecuación de salida es que va a ser verdadara solo si las tres entradas son falsas. Para comenzar desde el
prompt del DOS teclear "PLDSHELL <enter>" para entrar al paquete. Una vez dentro, escogeremos edit para
editar nustro programa y daremos el nombre "PRACTICA1.PDS".
El programa se editará de la siguiente forma:
;**********************************************************************************TITLE
Práctica 1_
PATTERN pract1
REVISION 1 ;numero de veces que se ha editado
AUTHOR Carlos Valencia Soberanes ;nombre
COMPANY ITSON ;tu compañía
DATE 12/24/96 ;fecha

CHIP PRAC_1 22V10

;aquí le decimos el tipo de chip a utilizar

PIN 2 IN1
PIN 3 IN2
PIN 4 IN3
PIN 14 OUT1
;note que no hay necesidad de declarar todos los pines ni Vcc ni tierra. El software esta encargado ;de hacer
todas las conecciones necesarias

EQUATIONS
OUT1 = /IN1 * /IN2 * /IN3
;Es la condición para que la salida sea verdadera

SIMULATION
TRACE_ON OUT1 IN1 IN2 IN3
;Empieza la sección de simulación indicando todas las variables usadas

SETF IN1 IN2 IN3

SETF IN1 /IN2 IN3
SETF IN1 /IN2 /IN3
SETF /IN1 /IN2 /IN3 ;solo en esta la ecuación va a ser verdadera
;ya que las tres entradas son 0

TRACE_OFF
;fin de la simulación
; ******************************************************************************

Una vez tecleado nos salimos del EDIT grabando el programa. Hecho ésto, lo compilamos para crear los
archivos necesarios, principalmente el JEDEC que es el con que se programa al chip; si hay errores no va a
generar tales archivos por lo que hay que volver a editar al programa de la misma forma anterior.

Una vez compilado, lo simularemos con el menú view seleccionando vector/waveform observando el
diagrama de tiempos.

7
PRACTICA 2

El alumno diseñará un decodificador de 4 a 7 segmentos con funcion lamp test y lamp blank y un
decodificador de 3 a 8 con salida activo bajo usando el paquete computacional PLDShell Plus de Intel.

DESARROLLO
Primeramente se diseñará un decodificador de 3 a 8 (Tabla 1) en donde sus salidas serán activas bajas. De
acuerdo a las entradas, especificar las salidas por medio de ecuaciones booleanas para posteriormente realizar
el programa con el paquete PLDShell (de acuerdo a lo anteriormente visto en la prácticas anteriores).

Posteriormente se programará al chip GAL22V10 mediante el archivo JEDEC generado a traves del paquete
computacional PLDShell Plus de Intel por lo que primeramente tendrá que ser simulado para comprobar su
funcionamiento.
TABLA 1. Tabla de verdad de un Decodificador de 3 a 8

Como segundo punto se diseñará e implementará un decodificador de 4 a 7 segmentos mediante el uso del
paquete PLDShell por medio de una tabla de verdad, y con esto generar un archivo JEDEC para la
programación del chip GAL22V10.

Ademas de decodificar los cuatro datos de entrada (D0 a D3) tendrá la funcion de LP (lamp Test) el cual
estará desabilitado con un uno lógico. Con un "0" todos los leds del display deberán encender. También
contará con LB que es lo contrario del LP; estará también desactivado con un uno lógico y se habilitará con
un cero; cuando ésto suceda todos los leds del display deberán apagarse. Cuando estas dos entradas (LP y LB)
esten en cero, los leds deberan de apagarse en su totalidad.

Antes de programar el GAL22V10, deberá simularse el diseño para estar completamente seguros de que no
existe ninguna falla.

Las salidas deberan tomarse conforme al siguiente criterio:

8
PROGRAMACION DE UN DISPOSITIVO.

La programación de un PLD es independiente del paquete computacional PLDShell Plus de Intel. Para ello se
utilizará el programador universal TUP 300.

La manera en que se entra al éste software es tecleando "GAL1" <ENTER> ya que es aquí donde se encuentra
uno de los chips con que se trabajará (GAL22V10). Se cuenta con otros programas donde se encuentran una
diversidad de chips distintos los cuales son soportados por éste programador. (GAL2 Y GAL3). Si se deseara
programar un PLD del tipo PAL se entra al programa PALP1.

Una vez dentro lo primero que debemos hacer es cargar el archivo JEDEC generado por el paquete PLDShell
Plus, el cual tendrá el mismo nombre del archivo fuente donde se diseñó el circuito, solo que la extensión será
.JED (Si se desea observar el contenido de éste archivo lo podemos ver con cualquier editor, ya que es un
archivo de tipo texto; se observará el mapa de unos y ceros los cuales son necesarios para la programación de
los PLD). Para cargar éste archivo, teclearemos la opción #2 y
A: nombre_archivo.JED

El programador universal TUP 300 carga el contenido de éste archivo en el buffer, el cual puede ser editado,
claro con un previo conocimiento del mismo mapa.

Una vez hecho lo anterior, se selecciona el tipo de dispositivo a usar; Tecleando la opción M se selecciona la
marca (En nuestro caso es LATTICE) y despues el tipo (GAL22V10 NO UES) seleccionando la opción T.

Teniendo el archivo en buffer y el tipo de dispositivo, lo único que queda es la programación la cual se realiza
con los siguinetes pasos:

1. Primeramente, como es un dispositivo Programable, se debe checar si esta en blanco, ya que de lo contrario
la programación será fallida. Para esto se teclea la opción B y respondemos que sí (Y).
2. Una vez que nos aseguremos que el PLD esté en blanco, teclearemos la opción P de programar; el
programador agarrará el archivo del buffer y empezará a programar el dispositivo en u tiempo de corta
duración.
3. Por último se verifica la operación hecha mediante la opción V.

Se puede tener seguridad en el diseño de los PLD's. Si se quiere evitar una copia o inclusive una modificación
al PLD, se cuenta con la Opción S, el cual activa unos fusibles en la entrada del chip, lo cual hace imposible
una futura lectura del mismo dispositivo.

Esto es todo a lo que se refiere a la programación de un PLD.

9
PRACTICA 3
El alumno aprenderá a usar la sintaxis necesaria para poder diseñar con máquinas de estado.

Las máquinas de estado proveen una manera efectiva de describir logica secuencial. Un diseñador típicamente
sólo dibuja el diagrama de estado que representan los estados diferentes y las transiciónes para un diseño. Este
diagrama puede ser expresado en sintaxis del paquete PLDShell Plus.

Cada máquina de estado comienza con la palabra "STATE" seguida de un tipo de máquina
(MEALY_MACHINE o MOORE_MACHINE). Las salidas en MOORE_MACHINE dependen solo del
estado presente.Las salidas en este tipo de máquina siempre son las mismas para cada estado que se tenga.
Las salidas en MEALY_MACHINE dependen de el estado presente y del estado siguiente. En éste tipo de
máquina, las salidas no son las mismas para un determinado estado, sino que dependen de las entradas que se
tengan. En esta práctica veremos un diseño con MOORE_MACHINE.

Para diseñar una máquina veremos la implementación de un contador de 2 bits. (véase fig 6).

Primeramente, se pone la sección de declaración como se hizo en las prácticas anteriores (declaración del chip
y de los pines).

Después se pone la palabra STATE seguida del tipo de máquina que se va a a emplear. Si se tiene el peligro
de no poder determinar el estado en que se va a caer o el estado que sigue, el programa cuenta con una
protección que es un salto default DEFAULT_BRANCH estado y siempre caerá en el estado seleccionado.
Esto es por protección. Se cuenta también con otro tipo de protección para dar una salida determinada, esto
con DEFAULT_OUTPUT seguida de una lista de variables de salida.

Las asignaciones de estado definen cada uno de los estados en la máquina, las variables de estado y los
valores de éstas variables. Los estados se definen por un nombre de estado por ejemplo, S1, S2, etc. de la
parte izquierda del signo =. Las variables de estado y los valores de éstas variables se colocan del lado
derecho. Cada estado debe tener un único grupo de valores para las variables de estado. Cuando se definen los
valores para los estados, estos pueden ser verdaderos o falsos(con el prefijo / ).

En las transiciones de estado se define el orden de las transiciones de un estado a otro basado en las
condiciones de transición. Las transiciones de estado que no esten explicitamente definidas en ésta sección
estaran en el estado definido por DEFAULT_BRANCH.

S1 := UP ->S2
+DOWN ->S4
+-> S1
Este ejemplo significa si UP es verdadero, entonces el salto se realizará al estado 2; si DOWN es verdadero el
salto se realizará a S4. Si ninguno se cumple entonces permanecerá en el mismo estado.
Es muy importante poner el signo : = en las transiciones de estado.

La sección de transición de salida (no especificada en la figura 6 ya que no se necesita, puesto que la salida
del contador son las mismas salidas de los flip flops) especifica el estado de las señales de salida durante las
transiciones para las máquinas de estado donde las salidas no son las mismas que la de los registros (flip
flops) como en el ejemplo visto.

Para especificar una salida ésta debe llevar la extensión .OUTF al lado izquierdo del signo : = .

un ejemplo sería el siguinete:

S1.OUTF : = OUTA * OUTB * /OUTC

10
Esto significa que cuando se caiga en el estado S1, OUTA y OUTB se llevaran a un estado alto mientras que
OUTC se llevará a uno bajo.

Las salidas se pueden especificar también de la siguinete manera: (P1 y P2 son estados)
P1.OUTF : = CONDICION1 -> /SIGA * SIGB
+CONDICION2 -> SIGA * /SIGB
+CONDICION3 -> SIGA * SIGB
P2.OUTF : = CONDICION1 -> SIGA * SIGB
+CONDICION2 -> /SIGA * /SIGB
+CONDICION3 -> /SIGA * SIGB
Nótese que estando en diferentes estados y sucediendo la misma condición se pueden obtener salidas
diferentes.

Este tipo de salidas se utiliza más generalmente sobre máquinas de tipo MOORE_MACHINE donde para
cada determinado estado se pueden tener diferentes salidas dependiendo de las entradas que se tengan.

Por último se tienen las condiciones de transición que comienza con la palabra CONDITIONS y especifica la
combinación de las señales de entrada que determinan las condiciones de transición. Por ejemplo,UP (en el
ejemplo de la figura 6) es una condición que será verdadera si UPDOWN esta en alto y CLEAR en cero.

El orden de las distintas condiciones es muy importante para el funcionamiento tanto del chip como del
programa.

A continuación se presenta un contador de 2 bits, el cual se implementará y verificará su funcionamiento con

la ayuda de 2 leds.

***********************************************************************************
fig 6. Programa fuente para la implementación de un contador de 2 bits.
CHIP 2_BIT 22V10
; pines
PIN 1 CLK
PIN 2 UPDOWN
PIN3 CLEAR
PIN 15 Q1
PIN 16 Q0

STATE
MOORE_MACHINE
DEFAULT_BRANCH S0 ;indicando por default que salte a S0 si no se determina
;correctamente un salto

;asignaciones de estado
S0 = /Q1 * /Q0 ;0 0
S1 = /Q1 * Q0 ;0 1
S2 = Q1 * /Q0 ;1 0
S3 = Q1 * Q0 ;1 1

;transiciones de estado
S0 := UP ->S1
+DOWN ->S3

S1 := UP ->S2
+DOWN ->S0

11
 S2 := UP ->S3
+DOWN ->S1

S3 := UP ->S0
+DOWN ->S2

;Condiciones de transición de entrada

CONDITIONS

UP = UPDOWN * /CLEAR ;si UPDOWN esta en 1 se contará hacia arriba

DOWN = /UPDOWN * /CLEAR ;si CLEAR esta en alto se reseteará la cuenta poniendo a
;ceros(S1) la salida
;Fin de diseño

SIMULATION

VECTOR CUENTA := [Q1 Q0]

;con esto formamos un vector dentro de los diagramas de simulacion para una mejor
;visualización de la salida
; por ejemplo si la cuenta va en Q1=1 y Q0=0 el vector cuenta presentara el número 2

TRACE_ON UPDOWN CLEAR CLK Q1 Q0

SETF UPDOWN /CLEAR /CLK ;inicializa variables para que empieze a contar hacia arriba
PRLDF /Q1 /Q0 ;inicializa los registros

; Se utiliza un ciclo FOR para contar seis pulsos de reloj hacia arriba

FOR j := 0 TO 5 DO
BEGIN
CLOCKF CLK
END

; Borramos al contador o la cuenta

SETF CLEAR
CLOCKF CLK
SETF /CLEAR

; Cuenta hacia abajo 6 ciclos

SETF /UPDOWN
FOR j := 0 TO 5 DO
BEGIN
CLOCKF CLK
END

; borramos al contador

SETF CLEAR
CLOCKF CLK
SETF /CLEAR

TRACE_OFF

12
; fin de la simulacion
***************************************************************************************

La siguiente figura muestra el diagrama de estados para el ejemplo anterior:

Se puede observar que en el diagrama anterior no se tienen salidas externas, ya que sus salidas son los mismo
estados con que se cuentan.

Como último ejemplo se implementará un programa fuente para el siguiente diagrama de estados el cuál
ahora si tendrá salidas externas:

El programa fuente se muestra a continuación:

CHIP ESTADOS_BIT 22V10
; pines
PIN 1 CLK
PIN 2 IN1 ;entradas
PIN 3 IN2

13
PIN 15 STATE1 ;son las variables de estado
PIN 16 STATE0

PIN 17 OUT1 ;son las salidas externas de la maquina

PIN 18 OUT2

STATE
MEALY_MACHINE
DEFAULT_OUTPUT /OUT1 /OUT2 ;inicializamos las salidas en cero
DEFAULT_BRANCH E0 ;indicando por default que salte a E0 si no se determina
;correctamente un salto

;asignaciones de estado
E0 = /STATE1 * /STATE0 ;0 0
E1 = /STATE1 * STATE0 ;0 1
E2 = STATE1 * /STATE0 ;1 0
E3 = STATE1 * STATE0 ;1 1

;transiciones de estado
E0 := COND0 ->E0 ;solo pasara a el estado 1 si sucede la condicion 1
+COND1 ->E1 ;sino ocurre esto se quedara en el estado 0
+COND2 ->E0
+COND3 ->E0

E1 := COND0 ->E0
+COND1 ->E0
+COND2 ->E2
+COND3 ->E0

E2 := COND0 ->E0
+COND1 ->E0
+COND2 ->E0
+COND3 ->E3

E3 := COND0 ->E3
+COND1 ->E3
+COND2 ->E3
+COND3 ->E3

;transiciones de salida
;lo que deben de ser en realidad la salida
E0.OUTF = COND0 ->/OUT1 * /OUT2
+COND1 ->/OUT1 * OUT2 ;la salida sera 1solo con la condicion 1
+COND2 ->/OUT1 * /OUT2 ;sino la salida sera cero
+COND3 ->/OUT1 * /OUT2

E1.OUTF = COND0 ->/OUT1 * OUT2

+COND1 ->/OUT1 * OUT2
+COND2 -> OUT1* OUT2
+COND3 ->/OUT1 * OUT2

E2.OUTF = COND0 -> OUT1 * /OUT2

+COND1 -> OUT1 * /OUT2

14
 +COND2 -> OUT1 * /OUT2
+COND3 -> OUT1 * OUT2

E3.OUTF = COND0 ->/OUT1 * /OUT2

+COND1 ->/OUT1 * OUT2
+COND2 ->OUT1 * /OUT2
+COND3 ->OUT1 * OUT2
;Condiciones de transición de entrada
CONDITIONS
COND0 = /IN1 * /IN2
COND1 = /IN1 * IN2
COND2 = IN1 * /IN2
COND3 = IN1 * IN2
EQUATIONS
STATE1.CLKF = CLK
STATE2.CLKF = CLK

SIMULATION

VECTOR MOUT := [OUT1,OUT2]

VECTOR STATES := [STATE1, STATE0]
;con esto logramos simular un vector en los diagramas de tiempo indicándonos la salida y el estado por
ejemplo
;si OUT1 es 1 y tambien lo es OUT0 el vector de salida MOUT sera 3
;lo mismo es para states que representara los estados
;esto es para una visualizacion mejor

SETF /IN1 /IN2 /CLK

TRACE_ON CLK IN1 IN2 MOUT STATES
PRLDF /STATE1 /STATE0 ;Esto es para cargar (inicializar) los registros determinados con
;niveles bajos (sus salidas)
CLOCKF CLK
;con este pulso de reloj permanecera en el estado cero ya que las entradas
;estan en 0 0 (IN1 IN2 respectivamente) por lo que la salida deber ser cero

SETF IN1 /IN2

CLOCKF CLK
;pasar lo mismo con este otro pulso

SETF /IN1 IN2

CLOCKF CLK
;segun el diagrama con las entradas 0 1 el estado al que se ira sera al estado
; uno teniendo en la salidas 0 1

SETF IN1 /IN2

CLOCKF CLK
; con esto se pasara al estado dos con la salida 1 1
; hay que tomar en cuenta que si se realiza otro pulso de reloj el sistema
; se debe de ir al estado inicial cero

SETF IN1 IN2

CLOCKF CLK
;con esto se pasara al estado 3 con salida 1 1 (3)

15
 CLOCKF CLK

SETF /IN1 /IN2

CLOCKF CLK
;se permanece en el estado 3 pero la salida cambia a 0 0 (0)

SETF IN1 /IN2

CLOCKF CLK
;se permanece en el estado 3 pero la salida cambia a 1 0 (2)

TRACE_OFF

; end of simulation

16