I TECNOLÓGICO Y DE ESTUDIOS SUPERIORES DE M

INSTITUTO TECNOLÓGICO Y DE ESTUDIOS SUPERIORES DE MONTERREY

PROYECTO FINAL

AUTOMATIZACIÓN DEL PROCESO DE SÍNTESIS DE MÁQUINA DE ESTADOS SECUENCIALES POR MEDIO DE ALGORITMOS

PROGRAMABLES

CONTROL LÓGICO INDUSTRIAL DR. JOSÉ DE JESÚS RODRÍGUEZ ORTIZ

SAÚL MONTES DE OCA ARMEAGA 744916 ABEL ÁNGEL TELLO SOLARES 787505 GILBERTO REYNOSO MEZA 768288

10 de Mayo de 2004

Control Lógico Industrial 2

ÍNDICE

ÍNDICE _______________________________________________________________________2 INTRODUCCIÓN ______________________________________________________________3 OBJETIVO ____________________________________________________________________4 METODOLOGÍA_______________________________________________________________4 MANUAL DEL PROGRAMA INTEGRADO _______________________________________6 DESCRIPCIÓN DE LA SOLUCIÓN_______________________________________________9 1. ELIMINACIÓN DE ESTADOS REDUNDANTES ________________________________________ 9 2. ASIGNACIÓN DE LOS CÓDIGOS BINARIOS A CADA ESTADO _____________________________ Y ECUACIONES PARA MEMORIAS _______________________________________________ 23 3. DETERMINACIÓN DE LAS ECUACIONES DE SALIDA PARA ______________________________ MEMORIAS SRFF Y TFF ______________________________________________________ 26 CONCLUSIONES _____________________________________________________________31


INTRODUCCIÓN

Un diagrama a bloques de un circuito secuencial consta de un circuito combinacional al que se conectan elementos de memoria para formar una trayectoria de retroalimentación. Los elementos de memoria son dispositivos capaces de almacenar dentro de ellos información binaria. La información binaria almacenada en los elementos de memoria en cualquier dado se define como el estado del circuito secuencial.

El circuito secuencial recibe información binaria de entradas externas.

Estas entradas, junto con el estado presente de los elementos de memoria, determinan el valor binario en las terminales de salida. También determinan las condiciones para cambiar el estado en los elementos de memoria.

La sincronización en los circuitos lógicos sincrónicos se logra a través de un

dispositivo llamado reloj, el cual genera un tren periódico de pulsos de reloj. Los pulsos de reloj se distribuyen a través del sistema de tal forma que los elementos de memoria están afectados solo por la llegada del pulso de sincronización.

Los elementos de memoria que se utilizan en los circuitos secuenciales de

reloj se llaman flip-flops estos circuitos son celdas binarias capaces de almacenar un bit de información. Un circuito flip-flop tiene dos salidas, una para el valor normal y otra para el valor complementario del bit almacenado en el. La información binaria puede entrar a un flip-flop es una gran variedad de formas, hecho que da lugar a diferentes tipos de flip-flops.

El comportamiento de un circuito secuencial se determina mediante las

entradas, las salidas y los estados de sus flip-flops. Tanto las salidas como el estado siguiente son función de las entradas y del estado presente. El análisis de los circuitos secuenciales consiste en obtener una tabla o un diagrama de estados para proceder a la asignación de los códigos binarios de cada estado y de esta manera poder determinar las ecuaciones para los diferentes tipos de flip-flops.


OBJETIVO El objetivo de este proyecto es generar una herramienta computacional que asista al diseño en la programación de máquinas de estado secuenciales de una sola entrada – una sola salida, de manera que desempeñe las tareas de: • Eliminación de estados redundantes • Asignación de los códigos binarios a cada estado • Determinación de las ecuaciones de salida para memorias del tipo SRFF y TFF.

METODOLOGÍA El proceso de análisis de la una máquina de estados secuenciales se describe de acuerdo a la figura 1 que se muestra a continuación:

Figura 1. Proceso de síntesis para una máquina de estados secuenciales

Como se describieron en los objetivos el proyecto sólo se centrará en crear una herramienta computacional para los pasos más difíciles del proceso de síntesis, el lenguaje que se empleará para la programación de esta tarea es C. Con objeto de cumplir adecuadamente con los requerimientos del curso de asignar tanto un trabajo colectivo como individual, se llevará a cabo la siguiente división de trabajo:


1. Eliminación de estados redundantes Ingeniero responsable: Saúl Montes de Oca Armeaga Alcances y Descripción: Este bloque de programación recibirá como dato de entrada una tabla preeliminar de estados propuesta por el usuario. A partir de ella, determinará y eliminará cualquier estado redundante y dará como salida la tabla mínima de representación de estados para la aplicación secuencial. Con tal finalidad, se apegará al método iterativo que se describe en [1]: • Particionar el conjunto de estados en subconjuntos de forma que los miembros en cada uno de ellos tengan las mismas salidas. • Determinar, para cada estado, su salida, de acuerdo a la partición generada anteriormente. Este proceso continúa hasta que no es posible efectuar una nueva partición en ninguno de los subconjuntos. Asignación de los códigos binarios a cada estado y ecuaciones para memorias. Ingeniero Responsable: Gilberto Reynoso Meza Alcances y Descripción: Este bloque de programación recibirá como parámetro de entrada una tabla de representación de estados (que será la mínima, una vez que sea integrado con el bloque anterior) a la cual asignará códigos binarios siendo congruente con las recomendaciones que se exponen en [1]: • Usar el mínimo números de códigos de estado. • Asignar códigos adyacentes a un estado y al que le sigue. • Si un par de estados anteceden a un mismo estado, deben asignárseles códigos adyacentes a los mismos. Adicionalmente, esta sección determinará las ecuaciones tanto de salida como de representación de estados para la aplicación. Determinación de las ecuaciones de salida para memo rias SRFF y TFF. Ingeniero responsable: Abel Angel Tello Solares Alcances y Descripción:


Este último bloque de programación tiene como objeto el derivar las ecuaciones para memorias tipo SRFF y DFF (a fin de comparación)a partir de una tabla de estado y de una asignación de códigos binarios a los mismos (que recibirá de las dos secciones anteriores al ser integrado). Esto implica determinar bajo que circunstancias los estados representan condiciones NI, una condición Set o una condición Reset para las memorias. En esta sección se utilizará un algoritmo de extracción ya existente.

MANUAL DEL PROGRAMA INTEGRADO El programa que contiene el algoritmo que une los tres programas se encuentra en la carpeta de Integración\ bajo el nombre de union.c; este programa se tiene que correr desde ms-dos debido a la naturaleza del programa. Para correo el programa es necesario correo el archivo llamado union.exe que se encuentra en la carpeta de Programas\ el cual se deberá copiar al disco duro para poder ejecutarlo y en el mismo directorio donde se encuentre el archivo se tendrá que colocar un archivo que contenga la tabla de estados original siguiendo el formato de la figura 2.

Figura 2. Formato para el archivo que contenga

la tabla de estados original Cada uno de los estados se escribirá con una “E” al inicio seguida de un carácter numérico, como por ejemplo “E1” y se presentaran en cinco columnas: 1ª Columna: Hace referencia al Estado Actual 2ª Columna: Hace referencia al Siguiente Estado cuando X =0. 3ª Columna: Hace referencia al Siguiente Estado cuando X =1. 4ª Columna: Hace referencia a la Salida cuando X =0.


5ª Columna: Hace referencia a la Salida cuando X =1. Una vez ingresados dichos datos, en un renglón aparte se colocarán las literales que representan el estado de las literales, por ejemplo X =0 se representa como X’ y X =1 se representa como X. Y por último para indicar el fin del archivo se colocará un asterisco (*). Para ejecutarlo en la ventada de ms-dos es necesario colocar la instrucción: union.exe como se muestra en la figura 3.

Figura 3. Instrucción para ejecutar el programa

La pregunta que realiza el programa es el nombre del archivo donde se encuentra la tabla de estados originales, la cual debe incluir la extensión del mismo, este archivo debe ser realizado en block de notas, por lo que la instrucción que se colocará es: ejemplo.txt; tal como lo muestra la figura 4.

Figura 4. Ingresar el archivo que contiene la tabla de estados original

Cuando termina de ejecutarse aparece una pantalla la cual indica el nombre de los archivos en los que se encuentran los arreglos de ON’s y DN’s (ver figura 5) para los diferentes tipos de flip-flops, para el caso de este proyecto SRFF, JKFF y TFF.


Figura 5. Pantalla final donde imprime el nombre de los archivos donde se encuentran

los Flip-Flops. Se crean más archivos en la carpeta donde se encuentra el archivo ejecutable a parte de los mostrados en la figura 5. El archivo Estados.html muestra los resultados de la minimización. Los archivos resul.txt, result1.txt y result2.txt se emplearon para la tercera fase del programa con el fin de evitar tener arreglos muy grandes los cuales fueran difíciles de procesar. Los archivos con extensión *.cli se emplearon para integrar los programas, los cuales son Etapa1.cli y Etapa2.cli.

Por lo tanto los archivos para iniciar la ejecución de cada programa por separado son:

Fase del programa Archivo necesario

Eliminación de estados redundantes ejemplo.txt (En este caso el nombre

que se le ingrese al inicio del programa)

Asignación de los códigos binarios a cada estado

etapa1.cli

Determinación de las ecuaciones de salida para memorias del tipo SRFF, JKFF y TFF

etapa2.cli

Tabla 0. Archivos necesarios para cada uno de los programas que forman la integración Estos programas se encuentran en la carpeta de ejecutables\ y cada uno se puede ejecutar por separado con el archivo indicado en la tabla 0.


DESCRIPCIÓN DE LA SOLUCIÓN

1. ELIMINACIÓN DE ESTADOS REDUNDANTES A menos de que se posea una gran experiencia en el diseño de ecuaciones secuenciales y en la primera descripción de la máquina se tendrán estados equivalentes, algunos de ellos serán posibles distinguirlos a simple vista, pero muchos de ellos no serán tan explícitos por lo que es necesario eliminar dichos estados redundantes, para cumplir dicho objetivo se empleo el método que se describe a continuación que se ejemplifica con uno de los ejemplos que se describe en [1].

Siguiente estado

Salida Estado Presente

x=0 x=1 x=0 x=1 E0 E1 E2 0 0 E1 E3 E4 0 0 E2 E5 E6 0 0 E3 E7 E8 0 0 E4 E9 E10 0 0 E5 E11 E12 0 0 E6 E13 E14 0 0 E7 E0 E0 0 0 E8 E0 E0 0 1 E9 E0 E0 0 1

E10 E0 E0 0 1 E11 E0 E0 0 0 E12 E0 E0 0 1 E13 E0 E0 0 1 E14 E0 E0 0 1

Tabla 1. Tabla de estados del ejemplo de [1] a. Partición de los estados de acuerdo a las salida s de cada uno de los estados presentes. A cada una de estas particiones se les denominara como S0, S1, …, Sn. para poder ir definiendo cuales será la tabla de estados reducida, dando como resultados la siguiente tabla:


Siguiente estado


x=0 x=1 x=0 x=1

Asignación de grupos

E0 E1 E2 0 0 S0 E1 E3 E4 0 0 S0 E2 E5 E6 0 0 S0 E3 E7 E8 0 0 S0 E4 E9 E10 0 0 S0 E5 E11 E12 0 0 S0 E6 E13 E14 0 0 S0 E7 E0 E0 0 0 S0 E8 E0 E0 0 1 S1 E9 E0 E0 0 1 S1

E10 E0 E0 0 1 S1 E11 E0 E0 0 0 S0 E12 E0 E0 0 1 S1 E13 E0 E0 0 1 S1 E14 E0 E0 0 1 S1 Tabla 2. Asignación de grupos de acuerdo a las salidas

b. Asignación del siguiente estado de acuerdo al gr upo al que pertenece cada uno de ellos. Consiste en realizar una nueva asignación de acuerdo al siguiente estado que presenta cada estado actual, esta asignación dependerá de cada uno de los grupos que se formaron en el inciso a).

Siguiente estado

Siguiente estado de acuerdo al grupo

Estado Presente

x=0 x=1


x=0 x=1 E0 E1 E2 S0 S0 S0 E1 E3 E4 S0 S0 S0 E2 E5 E6 S0 S0 S0 E3 E7 E8 S0 S0 S1 E4 E9 E10 S0 S1 S1 E5 E11 E12 S0 S0 S1 E6 E13 E14 S0 S1 S1 E7 E0 E0 S0 S0 S0 E8 E0 E0 S1 S0 S0 E9 E0 E0 S1 S0 S0

E10 E0 E0 S1 S0 S0 E11 E0 E0 S0 S0 S0 E12 E0 E0 S1 S0 S0


E13 E0 E0 S1 S0 S0 E14 E0 E0 S1 S0 S0

Tabla 3. Asignación del siguiente estado de acuerdo al grupo al que pertenecen

c. Partición de los estados a partir del grupo al q ue pertenecen y de los estados siguientes. En este paso lo que se hace es analizar las tres columnas que se crearon en los incisos anteriores para dividir nuevamente los estados en grupos para distinguir algunos de los estados equivalentes.

Siguiente estado


Estado Presente

x =0 x =1


x =0 x =1

Nueva asignación de grupos

E0 E1 E2 S0 S0 S0 S0 E1 E3 E4 S0 S0 S0 S0 E2 E5 E6 S0 S0 S0 S0 E3 E7 E8 S0 S0 S1 S1 E4 E9 E10 S0 S1 S1 S2 E5 E11 E12 S0 S0 S1 S1 E6 E13 E14 S0 S1 S1 S2 E7 E0 E0 S0 S0 S0 S0 E8 E0 E0 S1 S0 S0 S3

E9 E0 E0 S1 S0 S0 S3

E10 E0 E0 S1 S0 S0 S3

E11 E0 E0 S0 S0 S0 S0 E12 E0 E0 S1 S0 S0 S3

E13 E0 E0 S1 S0 S0 S3

E14 E0 E0 S1 S0 S0 S3 Tabla 4. Asignación de los grupos de acuerdo al grupo al que pertenecen

d. Repetición de los incisos b y c para dividir nue vamente a los grupos ya existentes.

Se realiza nuevamente la práctica de los incisos b y c para establecer una nueva partición de los grupos con los que se cuenta actualmente, dando como resultado la tabla que se muestra a continuación:


Siguiente

estado Siguiente estado de

acuerdo al grupo Estado

Presente x =0 x =1


x =0 x =1



E9 E0 E0 S3 S0 S0 S4

E10 E0 E0 S3 S0 S0 S4

E11 E0 E0 S0 S0 S0 S0 E12 E0 E0 S3 S0 S0 S4

E13 E0 E0 S3 S0 S0 S4

E14 E0 E0 S3 S0 S0 S4 Tabla 5. Asignación de nuevos grupos

e. Repetición del inciso d hasta que ya no se pueda realizar otra división

Se realiza nuevamente la práctica de los incisos b y c hasta que la columna de asignación de grupos y la nueva asignación de grupos sea la misma.

Siguiente estado


Estado Presente

x =0 x =1


x =0 x =1



E9 E0 E0 S5 S0 S0 S5

E10 E0 E0 S5 S0 S0 S5

E11 E0 E0 S4 S0 S0 S4 E12 E0 E0 S5 S0 S0 S5


E13 E0 E0 S5 S0 S0 S5

E14 E0 E0 S5 S0 S0 S5 Tabla 6. Tabla final de la división de grupos

f. Reducción de la tabla de estados original

A partir de la tabla 6 se puede obtener la representación mínima de estados eliminando los estados redundantes.

Siguiente estado


x=0 x=1 x=0 x=1 E0 E2 E2 0 0 E1 E0 E0 0 0 E2 E3 E4 0 0 E3 E1 E5 0 0 E4 E5 E5 0 0 E5 E0 E0 0 1

Tabla 7. Tabla de estados reducida

Explicación del algoritmo computacional Como se menciono anteriormente el algoritmo se realizo en Visual C++ en el lenguaje de C. Se irán mostrando los diagramas de flujo para explicar el procedimiento que se describió con anterioridad.

El diagrama 1 muestra el inicio del programa que es donde se pide el nombre del archivo y se colocan los datos de la tabla de estados en los apuntadores para poder efectuar la minimización de los estados.


Diagrama 1. Inicio del programa

Leer archivo de la tabla de estados

Inicio

tem=0 tem1=0

i<temp1

k=0

k=k+1

i=i+1

palabra[i]==’E’

b

a

T

F

F

T F

a

i=0

k<noedo

let=69 i=i+1 testado[noedo*tem+k]=k temp=0

T

s0

palabra[i]==’0’ || palabra[i]==’1’ || palabra[i]==’X’

palabra[i]==’\n’

salida[noedo*tem1+k]=palabra[i] tem1=tem1+1

tem1=i+1

b

m


El diagrama 2 muestra la función if que ayuda a leer los estados y transformarlos de caracteres a enteros.

Diagrama 2. Instrucción del If del diagrama 1

testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]

temp=testado[noedo*tem+k]*pow(10,1)

s0

i!=j

palabra[j]>=48&& palabra[j]<=57

palabra[j]==’0’

palabra[j]==’1’

palabra[j]==’2’

palabra[j]==’3’

palabra[j]==’4’

palabra[j]==’5’

palabra[j]==’6’

palabra[j]==’7’

palabra[j]==’8’

palabra[j]==’9’










break

break

break

break

break

break

break

break

break


El diagrama 3 muestra la ejecución de la explicación de los incisos a hasta el f, hace invocación a funciones las cuales se explicarán más adelante, por último regresa un archivo que es Estados.html donde se pueden ver los resultados de la minimización y así mismo creo un archivo llamado Etapa1.cli, el cuál sirve para realizar la segunda fase del proyecto final.

Diagrama 3. Fin del programa


En el diagrama 4 se muestra la primera función cuyo procedimiento se explica en el inciso a (Partición de los estados de acuerdo a las salidas de cada uno de los estados presentes).

Diagrama 4. Función para la partición de los estados de acuerdo a las

*(salida+pun1)== *(salida+pun2)

i<=memte

j=0

j<noedo

k<noedo

k=k+1

testuno[k]=-1

i=0

i<=pow(2,var)-1

i=i+1

pun1=j+i*noedo pun2=k+i*noedo

testuno[k]=-1

break

testuno[k]=gpo

b

c

a

b

b

b

c

F

F

F

F

T

T

T

T

i=0

testuno[i]=-1

i=i+1

j=j+1

testuno[j]=-1

gpo=gpo+1 testuno[j]=gpo

k=j+1

a

a

T

T

F

F

F

T


salidas de cada uno de los estados presentes El diagrama 5 se muestra la segunda función y su procedimiento es explicado en el inciso b (Asignación del siguiente estado de acuerdo al grupo al que pertenece cada uno de ellos).

Diagrama 5. Función para la asignación del siguiente estado de acuerdo al

grupo al que pertenece cada uno de ellos El diagrama 6 se muestra la función que efectúa el procedimiento descrito en el inciso c (Partición de los estados a partir del grupo al que pertenecen y de los estados siguientes).

i<=noedo j=noedo

j<memte

i=0

i=i+1

j=j+1

testado[i]==testado[j] testuno[j]= testuno[i]

b

a

T

F

F

T

s2

F

a

b


Diagrama 6. Partición de los estados a partir del grupo al que pertenecen

y de los estados siguientes.

testuno[j+(i*noedo]== testuno[k+(i*noedo]

i<=memuno

j=0

j<noedo

k<noedo

k=k+1

testuno[memte+k]=-1

i=0

i<=pow(2,var)-1

i=i+1

testuno[memte+k]=-1

break

testuno[memte+k]=gpo

b

c

a

b

b

b

c

F

F

F

F

T

T

T

T

i=memte

testuno[i]=-1

i=i+1

j=j+1

testuno[memte+j]=-1

gpo=gpo+1

testuno[memte+j]=gpo

k=j+1

a

a

T

T

F

F

F

T


Los diagramas 7 y 8 son los mismos que el 5 y 6, sólo que estas dos funciones van a servir para comparar si la solución que se tiene es la optima o es necesario realizar otra partición de estados.


grupo al que pertenece cada uno de ellos

i<=noedo j=noedo

j<memte

i=0

i=i+1

j=j+1

testuno[i]==testuno[j] testdos[j]= testdos[i]

b

a

T

F

F

T

s4

F

a

b

b



grupo al que pertenece cada uno de ellos

testdos[j+(i*noedo]== testdos[k+(i*noedo]

i<=memuno

j=0

j<noedo

k<noedo

k=k+1

testdos[memte+k]=-1

i=0

i<=pow(2,var)-1

i=i+1

testdos[memte+k]=-1

break

testdos[memte+k]=gpo

b

c

b

b

b

c

F

F

F

F

T

T

T

T

i=memte

testdos[i]=-1

i=i+1

j=j+1

testdos[memte+j]=-1

gpo=gpo+1

testdos[memte+j]=gpo

k=j+1

a

a

T

T

F

F

F

T

s5


Por último en el diagrama 10 se muestra la función para reducir la tabla, que lo único que realiza es que a partir de las particiones que se hicieron se crea la nueva tabla de estados, para reducir los estados redundantes.

Diagrama 10. Función para reducir los estados de la tabla original a partir de las particiones

Una vez generada la solución esta se imprime en el archivo de Estados.html, en el cual se tiene la interfase con el usuario para ver la solución de la minimización y se crea otro archivo que es la de etapa1.cli, el cual servirá para continuar con la siguiente etapa. Al final se logro que el programa resolviera minimizar n estados para n salidas, por lo que se lograron y mejoraron los objetivos que se esperaban del programa.

i<=mgpo testfin[i]=i

j<noedo

i=0

i=i+1

j=j+1

testfin[i]==testdos[j]

b

a

T

F

F

T

s6

F

a

b

j=0

j<pow(2,var)

k=k+1

k=0

testfin[i+(k+1)*(mgpo+1)]=testdos[j+(k+1)*noedo] salfin[i+k*(mgpo+1)]=salida[j+k*noedo]


2. ASIGNACIÓN DE LOS CÓDIGOS BINARIOS A CADA ESTADO Y E CUACIONES PARA

MEMORIAS Descripción del algoritmo El Algoritmo no integrado requiere de un archivo llamado etapa1.cli que contenga una propuesta de minimización de estados (si se trata del programa integrado, este archivo será la minimización óptima). El formato que tiene el archivo es como sigue: 5; 0;2;3;0;0; 1;2;2;1;0; … El primer número que se lee en el archivo hace referencia al número de estados. Las líneas subsecuentes contienen la información de cada estado separadas por puntos y comas: • El primer número es el estado base. • El segundo número es el estado que se genera con la entrada X0 • El tercer número es el estado que se genera con la entrada X1 • El cuarto número es la salida que se genera con X0 • El quinto número es la salida que se genera con X1. El archivo de salida se denomina etapa2.cli, el cual devuelve la siguiente información: 3;5; 000;001;100 001;011;101 … En la primer línea se leen el número de bits utilizados en la asignación de códigos y el número de estados. En las líneas subsecuentes se leen el estado base, el estado que se genera a partir de la entrada X0 y el estado que se genera a partir de la salida X1 en su designación binaria, respectivamente. La solución implementada para esta aplicación es heurística, de forma que no garantiza la solución óptima en la asignación de códigos binarios, pero busca respetar las primeras dos reglas que se exponen en [1] en la medida de lo posible. Se garantiza el funcionamiento del algoritmo hasta un máximo de 32 estados. El diagrama de flujo del algoritmo se aprecia en la figura 2.1.


Diagrama 11a. Diagrama de flujo del algoritmo

Se busca menor asignación disponible

siguiente

¿El estado origen y el estado destino

difieren en un solo dígito?


siguiente

¿El estado origen y el estado destino

difieren en un solo dígito?

3

NO

NO

Inicio

Lectura y captura de estados desde el archivo etapa1.cli

Determinación del Número de Dígitos Binarios necesarios para la

asignación de códigos

Asignación de Código 0 al estado inicial antes leído

Lectura del Estado que se genera A partir de la entrada X0

¿ El estado ya se encuentra asignado?

Lectura del Estado que se genera A partir de la entrada X1


¿ Existe otro estado por leer?

Lectura del siguiente Estado

1

2

SI

SI

NO

SI

SI

NO

SI

NO


Diagrama 11b. Diagrama del flujo del algoritmo



3

2

1 Se llama rutina de

Impresión al archivo etapa2.cli

¿Fueron necesarios 3 bits para las asignaciones?


Salida a Archivo con 2 bits

Salida a Archivo con 3 bits

Salida Archivo con 4 bits


Salida Archivo con 5 bits

Fin de Programa

SI

NO NO

NO

SI SI

SI

SI

NO


NO


Los pasos a seguir en el algoritmo son: 1) Lectura de la minimización de estados en el archivo etapa1.cli generada en

la sección anterior. 2) Determinar el número de bits necesarios para la asignación de códigos. 3) Lectura del primer estado y asignación de código 0 4) Lectura del estado que se genera con la entrada X0. 5) Se verifica si el estado ha sido asignado con anterioridad. De no ser así, se

busca la primera designación binaria disponible de manera que el valor absoluto de la resta del estado con el de la asignación resulte en una potencia de 2 (de esta forma se asegura que solo exista un cambio de dígito entre los estados).

6) Lectura del Estado que se genera con la entrada X1. 7) Se verifica si el estado ha sido asignado con anterioridad. De no ser así, se

busca la primera designación binaria disponible de manera que el valor absoluto de la resta del estado con el de la asignación resulte en una potencia de 2 (de esta forma se asegura que solo exista un cambio de dígito entre los estados).

8) Lectura del Estado siguiente. Los pasos 5 al 8 se repiten hasta que se termine la lectura de todos los estados existentes en el archivo etapa1.cli. Una vez generado el resultado, este se imprime en el archivo etapa2.cli.

3. DETERMINACIÓN DE LAS ECUACIONES DE SALIDA PARA MEMOR IAS SRFF Y TFF

Se captura la tabla de los estados con si estado siguiente con entrada X = 0 y X = 1, el siguiente paso es comprobar si la tabla esta completa y tiene los suficientes argumentos para trabajar y poder encontrar y generar una tabla de ON’s y de DC’s (No Importa) de cada una de las memorias mínimas a ocupar, para poder meterlas al algoritmo de extracción o al algoritmo de consenso generalizado y poder obtener la ecuación mínima de cada una de las memorias SRFF, JKFF y TFF. Para cuestiones prácticas y no sobrecargar el diagrama de flujo, solo se muestra como obtener el arreglo de ON’s y de DC’s para todas las memorias Set y Reset. (Diagrama 12)


Diagrama 12. Arreglo de ON´s y DC’s

El siguiente paso es reiniciar la lectura de los renglones para ubicar la lectura hasta el principio del archivo y comenzar a leer nuevamente los renglones para determinar el numero de estados y poder determinar si hay No importa Comunes o no, de aquí se vuelven a reiniciar la lectura de los renglones, se inicia el contador de Y’s en 1, (Diagrama 13) se ubica el apuntador a la izquierda de el renglón, para comenzar a leer carácter por carácter, de izquierda a derecha, y se va incrementando el contador de Y’s hasta llegar a un “;”. Teniendo esto se genera un Arreglo Binario de dimensiones Contador de Y’s + 1, teniendo esto podemos verificar los No Importa Comunes de los numero faltantes a este arreglo original de etapa2.cli, (Diagramas 14, 15 y 16).

Inicio

Leer tabla.txt

Leer Renglón de tabla.txt

Si Renglón < char

Error: Falta de Argumentos

Fin Reset de lectura de Renglones

Leer Renglón

ContadorEdos ++

Si Renglón ≠ EOF

S

N

Reset de lectura de Renglones

N


Diagrama 13

Diagrama 14

Reset de Contador de Y’s=1

Inicio de Apuntador de Renglón a la Izq


Leer Char de Renglón

Si Char ≠ ;

N

S Reset de lectura de Char y Renglón

Contador Y’s ++ Genera Arreglo Binario de dimensiones

Contador Y’s + 1

Leer Renglón de Arreglo Binario

Leer Renglón de tabla.txt hasta “;”

Leer Char de Renglón Arreglo Binario

Sigue checando Si hay NI comunes


Si Char txt ≠ Char

Binario

N

N


Si Char txt ≠ ;

S

S

N

Si Renglón de tabla.txt

≠ EOF

S

Cuenta EOF

Sigue checando Si hay NI comunes

Genera Arreglo NIComunes.txt

Agrega 0 + Renglón de Arreglo Binario en NIComunes.txt

Imprime No hay NI comunes

Si Cuenta EOF ≥ N

S

Vete a checar unos y No

Importa de cada Set y Reset


Diagrama 15

Diagrama 16

Por último se reinician la lectura de renglones nuevamente, y ahora se

compara carácter por carácter de cada cadena de caracteres entre si, (Estado Actual, Estado Siguiente con X = 0 y Estado Siguiente con X = 0) de cada renglón, y se compara si las condiciones de Y’s de estado Actual con estado siguiente, con los valores de las tablas de verdad del tipo de memoria FF deseada, y se genera

Si

No Si

Renglón de tabla.txt ≠ EOF

Si

Cuenta EOF

Ya estan los No Importa Comunes

Si Cuenta EOF ≥ 2

No

Si



Leer Renglón de Arreglo Binario

Leer Renglón de tabla.txt hasta “;”



Si Char txt ≠ Char

Binario No

No


Si Char txt ≠ ;

Si

Si

Si

Abre Arreglo NIComunes.txt

Agrega 1 + Renglón de Arreglo Binario en NIComunes.txt

Ya estan los No Importa Comunes




un archivo texto con los arreglos de los ON y DC de cada una de las entradas de las memorias FF, reiniciando las lecturas y incrementando el contador de generación de archivos txt según el tipo de memoria deseada. (Diagramas 17, 18 y 19)

Diagrama 17

Diagrama 18

Reset de lectura de Renglones

Leer Char Estado (cadena 1) hasta ;


Leer Char X0 (cadena 2) hasta ;

Leer Char X1 (cadena 3) hasta ;

S

NChar Edo = 0 y Char X0 =1

Pon un 0 a la izq de CharEdo

Genera 1-OnSet.txt

Guarda

NRenglón tabla.txt ≠ EOF

S

Pasa al Siguiente Renglón


Diagrama 19

CONCLUSIONES Como resultado de este trabajo, se tiene una plataforma computacional capaz de asistir al diseño de circuitos secuenciales sincrónicos en las etapas de minimización de estados, asignación de códigos binarios y extracción de tablas ON y DC para determinar las ecuaciones booleanas de memorias tipo DFF, JKFF, RSFF. La primera etapa, la eliminación de estados redundantes, se ha logrado implementar para sistemas MIMO, convirtiéndose en una herramienta flexible para el diseño en control. La tercera etapa, la determinación de tablas ON y DC para las memorias ha mostrado ser robusta y ofrece una excelente plataforma para adaptarse a este tipo de sistemas. La etapa dos, la asignación de códigos binarios (siguiendo las recomendaciones que se exponen en [1] ) utiliza un modelo heurístico, de manera que no garantiza la solución óptima aunque si una solución que respeta en la mayor medida de las posibilidades tales recomendaciones. Para lograr un algoritmo eficiente que garantize la solución óptima será necesaria una mayor inversión de tiempo e investigación. Como trabajo posterior, se recomienda el optimizar la segunda etapa de este proyecto y completar el proyecto con el algoritmo de extracción de manera que se tenga una sola aplicación. Así mismo, se recomienda crear una interfaz que permita introducir la tabla preliminar de estados en ambiente Windows vía internet. De esta manera, se puede dar a conocer la aplicación instalándose en el servidor del departamento. Bibliografía: [1] Dietmeyer, Donald. Logic Design of Digital Systems, 3rd. Edition. Allyn and Bacon.

Contador de Y’s - -

Si Contador de Y’s = 0

N

Si

Fin

I TECNOLÓGICO Y DE ESTUDIOS SUPERIORES DE M

Documents

Transcript of I TECNOLÓGICO Y DE ESTUDIOS SUPERIORES DE M