Post on 05-Jul-2022
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
Control Lógico Industrial 3
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.
Control Lógico Industrial 4
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:
Control Lógico Industrial 5
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:
Control Lógico Industrial 6
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.
Control Lógico Industrial 7
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.
Control Lógico Industrial 8
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.
Control Lógico Industrial 9
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:
Control Lógico Industrial 10
Siguiente estado
Salida Estado Presente
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
Asignación de grupos
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
Control Lógico Industrial 11
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
Siguiente estado de acuerdo al grupo
Estado Presente
x =0 x =1
Asignación de grupos
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:
Control Lógico Industrial 12
Siguiente
estado Siguiente estado de
acuerdo al grupo Estado
Presente x =0 x =1
Asignación de grupos
x =0 x =1
Nueva asignación de grupos
E0 E1 E2 S0 S0 S0 S0 E1 E3 E4 S0 S1 S2 S1 E2 E5 E6 S0 S1 S2 S1 E3 E7 E8 S1 S0 S3 S2 E4 E9 E10 S2 S3 S3 S3 E5 E11 E12 S1 S0 S3 S2 E6 E13 E14 S2 S3 S3 S3 E7 E0 E0 S0 S0 S0 S0 E8 E0 E0 S3 S0 S0 S4
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
Siguiente estado de acuerdo al grupo
Estado Presente
x =0 x =1
Asignación de grupos
x =0 x =1
Nueva asignación de grupos
E0 E1 E2 S0 S1 S1 S0 E1 E3 E4 S1 S2 S3 S1 E2 E5 E6 S1 S2 S3 S1 E3 E7 E8 S2 S4 S5 S2 E4 E9 E10 S3 S5 S5 S3 E5 E11 E12 S2 S4 S5 S2 E6 E13 E14 S3 S5 S5 S3 E7 E0 E0 S4 S0 S0 S4 E8 E0 E0 S5 S0 S0 S5
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
Control Lógico Industrial 13
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
Salida Estado Presente
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.
Control Lógico Industrial 14
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
Control Lógico Industrial 15
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’
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
testado[noedo*tem+k]=0 testado[noedo*tem+k]=temp+testado[noedo*tem+k]
break
break
break
break
break
break
break
break
break
Control Lógico Industrial 16
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
Control Lógico Industrial 17
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
Control Lógico Industrial 18
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
Control Lógico Industrial 19
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
Control Lógico Industrial 20
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.
Diagrama 7. Función para la asignación del siguiente estado de acuerdo al
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
Control Lógico Industrial 21
Diagrama 9. Función para la asignación del siguiente estado de acuerdo al
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
Control Lógico Industrial 22
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]
Control Lógico Industrial 23
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.
Control Lógico Industrial 24
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?
Se busca menor asignación disponible
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
¿ El estado ya se encuentra asignado?
¿ Existe otro estado por leer?
Lectura del siguiente Estado
1
2
SI
SI
NO
SI
SI
NO
SI
NO
Control Lógico Industrial 25
Diagrama 11b. Diagrama del flujo del algoritmo
Se busca menor asignación disponible
¿ El estado ya se encuentra asignado?
3
2
1 Se llama rutina de
Impresión al archivo etapa2.cli
¿Fueron necesarios 3 bits para las asignaciones?
¿Fueron necesarios 4 bits para las asignaciones?
Salida a Archivo con 2 bits
Salida a Archivo con 3 bits
Salida Archivo con 4 bits
¿Fueron necesarios 5 bits para las asignaciones?
Salida Archivo con 5 bits
Fin de Programa
SI
NO NO
NO
SI SI
SI
SI
NO
¿Fueron necesarios 2 bits para las asignaciones?
NO
Control Lógico Industrial 26
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)
Control Lógico Industrial 27
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
Control Lógico Industrial 28
Diagrama 13
Diagrama 14
Reset de Contador de Y’s=1
Inicio de Apuntador de Renglón a la Izq
Leer Renglón de tabla.txt
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
Leer Char de Renglón
Si Char txt ≠ Char
Binario
N
N
Leer Char de Renglón Arreglo Binario
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
Control Lógico Industrial 29
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
Vete a checar unos y No
Importa de cada Set y Reset
Leer Renglón de Arreglo Binario
Leer Renglón de tabla.txt hasta “;”
Leer Char de Renglón Arreglo Binario
Leer Char de Renglón
Si Char txt ≠ Char
Binario No
No
Leer Char de Renglón Arreglo Binario
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
Vete a checar unos y No
Importa de cada Set y Reset
Control Lógico Industrial 30
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 Renglón de tabla.txt
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
Control Lógico Industrial 31
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