# Maquinas de estado en WINCUPL



## jaimepsantos

Hola a todos!!

Quisiera saber como implementar una maquina de estados en un GAL22V10 tengo el wincupl de atmel esta constaria de 1 bit de control (ascendente y descendente) y 4 estados de 4 bits cada uno

Es lo q llevo



		Código:
	

Name     MACH_STATE ;
PartNo   00 ;
Date     21/03/2010 ;
Revision 01 ;
Designer Engineer ;
Company  ceti ;
Assembly None ;
Location  ;
Device   g22v10 ;

/* *************** INPUT PINS *********************/
PIN   1  = CLK                        ; /*                                 */ 
PIN   2  = AD                         ; /*                                 */ 


/* *************** OUTPUT PINS *********************/
PIN  20   =         S0                ; /*                                 */ 
PIN  21   =         S1                ; /*                                 */ 
PIN  22   =         S2                ; /*                                 */ 
PIN  23   =         S3                ; /*                                 */ 

....


----------



## Elvic

Saludos, lo primero que deberás hacer es, crear las ecuaciones que describen la maquina de estados, lo básico  con compuertas , o flip flop's y si requieres simplificar puedes usar mapas de _Karnaugh o algún otro método, es decir, necesitas esa ecuación y la escribes y debería funcionar esa es la parte clave  , aunque si ya las tiene solo es cuestión de implementarlas.._

Solo algo de trabajo, pero ya cuentas con las entrada y salidas  del sistema y eso ya es algo significativo_.

PD: recién comienzo a aprender un poco de estos dispositivos.

Suerte._


----------



## jaimepsantos

Gracias Elvic, pero es lo que me quiero ahorrar, existe una manera de hacerla con if, next, entre otras funciones. Solo pongo los estados con condicionantes pero no encontre en ningun lado un ejemplo que me explicara realmente como hacerlo.

=/

Muchas gracias por la ayuda pero ya consegui por otros medios como lograrlo


Aqui les dejo la maquina que ocupe para el control de motores a pasos.



		Código:
	

Name     FULL_STEP ;
PartNo   00 ;
Date     23/03/2010 ;
Revision 01 ;
Designer Jaime ;
Company  CETI ;
Assembly None ;
Location  ;
Device   g22v10 ;


/* *************** INPUT PINS *********************/
PIN   1  = CLK                        ; /*                                 */ 
PIN   2  = AD                         ; /*        ASCENCENTE                         */ 

/* *************** OUTPUT PINS *********************/
PIN  20   =         S0                ; /*   bobina 1                              */ 
PIN  21   =         S1                ; /*   bobina 1                              */ 
PIN  22   =         S2                ; /*   bobina 2                              */ 
PIN  23   =         S3                ; /*   bobina 2                              */ 

field maquina=[S0,S1,S2,S3];

$define SA 'b' 0000
$define S0 'b' 0101
$define S1 'b' 1001
$define S2 'b' 1010
$define S3 'b' 0110

sequence maquina{
present SA
next S0;
present S0
if AD  next S1;
if !AD next S3;
present S1
if AD  next S2;
if !AD next S0; 
present S2 
if AD  next S3;
if !AD next S1;
present S3 
if AD  next S0;
if !AD next S2;
}


----------



## betodj

El facil lenguaje de programacion del Wincup, es la ventaja sobre otros como el ABEL ,VHDL, pero cada quien se acomoda a lo que ha trabajado.
Amigo Jaimepsantos  ¿Puedes subir información gráfica, tabla de verdad, diagrama de estados, objetivo, etc., de tu proyecto?. Ya que me interesa a fin de reforzar algunos conocimientos sobre PLD`s, hacerlos como práctica en mi universidad.
Recibe un saludo y felicidades por encontrar solución a tu problema.


----------



## jaimepsantos

Que tal beto DJ aqui te incluyo alguna informacion sobre el proyecto:

Trata de un control sencillo de un motor a paso donde con un bit este gira hacia un lado o hacia otro (AD) cambiando la secuencia, el programa consiste en la maquina de estado que se programa en un GAL22V10 de Latice.

El objetivo es sencillo lograr el control de un motor a paso mediante una maquina de estado.

La maquina se inicializa en cero para que comienze a funcionar despues de esto solo interviene el bit de control y la secuencia es ciclica.


----------



## betodj

Gracias amigo jaimepsantos por compartir tu informacion con el foro.


----------



## Elvic

Saludos, muy bien, que bueno que hayas solucionado el problema que tenías con la programación de la máquina de estados, ya que no te puede ayudar en mucho....

Me he puesto a simular tu código en el Proteus y si, realmente si funciona, tal como lo comentas.

Les dejo una captura de pantalla de tu codigo simulado y por supuesto el archivo creado en Proteus... para que puedan ver.. y por supuesto la imagen no hay manera de ver la dirección de giro, pero he puesto las dos condiciones en el pin2.

Suerte


----------



## Earl

No habia visto el tema, yo les muestro mis tres máquinas de estado para control de motores a pasos en distintas configuraciones con bit de control de giro y bit de control para avanzar o mantenerse fijo.



		Código:
	

Name     FULL_STEP ;
PartNo   00 ;
Date     06/04/2010 ;
Revision 01 ;
Designer EARL ;
Company  CETI Colomos ;
Assembly None ;
Location  ;
Device   G22V10 ;

/* *************** INPUT PINS *********************/
PIN   1  = CLK                        ; /*                                 */ 
PIN   2  = STOP                       ; /*                                 */ 
PIN   3  = AVANZA                     ; /*                                 */ 

/* *************** OUTPUT PINS *********************/
PIN  14   =         S0                ; /*                                 */ 
PIN  15   =         S1                ; /*                                 */ 
PIN  16   =         S2                ; /*                                 */ 
PIN  17   =         S3                ; /*                                 */ 


field cont=[S0,S1,S2,S3];

$define S0 'b'0000
$define S1 'b'0101
$define S2 'b'1001
$define S3 'b'1010
$define S4 'b'0110

sequence cont{
present S0 next S1;

present S1
if STOP&AVANZA next S1;
if STOP&!AVANZA next S1;
if !STOP&AVANZA next S2;
if !STOP&!AVANZA next S4;

present S2
if STOP&AVANZA next S2;
if STOP&!AVANZA next S2;
if !STOP&AVANZA next S3;
if !STOP&!AVANZA next S1;

present S3
if STOP&AVANZA next S3;
if STOP&!AVANZA next S3;
if !STOP&AVANZA next S4;
if !STOP&!AVANZA next S2;

present S4
if STOP&AVANZA next S4;
if STOP&!AVANZA next S4;
if !STOP&AVANZA next S1;
if !STOP&!AVANZA next S3;
}




		Código:
	

Name     HALF_STEP ;
PartNo   00 ;
Date     06/04/2010 ;
Revision 01 ;
Designer EARL ;
Company  CETI Colomos ;
Assembly None ;
Location  ;
Device   G22V10 ;

/* *************** INPUT PINS *********************/
PIN   1  = CLK                        ; /*                                 */ 
PIN   2  = STOP                       ; /*                                 */ 
PIN   3  = AVANZA                     ; /*                                 */ 

/* *************** OUTPUT PINS *********************/
PIN  14   =         S0                ; /*                                 */ 
PIN  15   =         S1                ; /*                                 */ 
PIN  16   =         S2                ; /*                                 */ 
PIN  17   =         S3                ; /*                                 */ 

field cont=[S0,S1,S2,S3];

$define S0 'b'0000
$define S1 'b'1010
$define S2 'b'0010
$define S3 'b'0110
$define S4 'b'0100
$define S5 'b'0101
$define S6 'b'0001
$define S7 'b'1001
$define S8 'b'1000

sequence cont{
present S0 next S1;

present S1
if STOP&AVANZA next S1;
if STOP&!AVANZA next S1;
if !STOP&AVANZA next S2;
if !STOP&!AVANZA next S8;

present S2
if STOP&AVANZA next S2;
if STOP&!AVANZA next S2;
if !STOP&AVANZA next S3;
if !STOP&!AVANZA next S1;

present S3
if STOP&AVANZA next S3;
if STOP&!AVANZA next S3;
if !STOP&AVANZA next S4;
if !STOP&!AVANZA next S2;

present S4
if STOP&AVANZA next S4;
if STOP&!AVANZA next S4;
if !STOP&AVANZA next S1;
if !STOP&!AVANZA next S3;

present S5
if STOP&AVANZA next S5;
if STOP&!AVANZA next S5;
if !STOP&AVANZA next S6;
if !STOP&!AVANZA next S4;

present S6
if STOP&AVANZA next S6;
if STOP&!AVANZA next S6;
if !STOP&AVANZA next S5;
if !STOP&!AVANZA next S7;

present S7
if STOP&AVANZA next S7;
if STOP&!AVANZA next S7;
if !STOP&AVANZA next S8;
if !STOP&!AVANZA next S6;

present S8
if STOP&AVANZA next S8;
if STOP&!AVANZA next S8;
if !STOP&AVANZA next S7;
if !STOP&!AVANZA next S1;
}




		Código:
	

Name     WAVE_STEP ;
PartNo   00 ;
Date     06/04/2010 ;
Revision 01 ;
Designer EARL ;
Company  CETI Colomos ;
Assembly None ;
Location  ;
Device   G22V10 ;

/* *************** INPUT PINS *********************/
PIN   1  = CLK                        ; /*                                 */ 
PIN   2  = STOP                       ; /*                                 */ 
PIN   3  = AVANZA                     ; /*                                 */ 

/* *************** OUTPUT PINS *********************/
PIN  14   =         S0                ; /*                                 */ 
PIN  15   =         S1                ; /*                                 */ 
PIN  16   =         S2                ; /*                                 */ 
PIN  17   =         S3                ; /*                                 */ 

field cont=[S0,S1,S2,S3];

$define S0 'b'0000
$define S1 'b'0001
$define S2 'b'1000
$define S3 'b'0100
$define S4 'b'0010

sequence cont{
present S0 next S1;

present S1
if STOP&AVANZA next S1;
if STOP&!AVANZA next S1;
if !STOP&AVANZA next S2;
if !STOP&!AVANZA next S4;

present S2
if STOP&AVANZA next S2;
if STOP&!AVANZA next S2;
if !STOP&AVANZA next S3;
if !STOP&!AVANZA next S1;

present S3
if STOP&AVANZA next S3;
if STOP&!AVANZA next S3;
if !STOP&AVANZA next S4;
if !STOP&!AVANZA next S2;

present S4
if STOP&AVANZA next S4;
if STOP&!AVANZA next S4;
if !STOP&AVANZA next S1;
if !STOP&!AVANZA next S3;
}


Espero sirvan de algo!


----------



## jaimepsantos

Earl, te digo que mas sencillo apagar el motor ponle el clock a una or + un uno o cero, así se mantiene el estado Y NO HAY TRANSICIÓN
IN-------OUT
CLK--0--CLK
CLK--1---1


----------



## Earl

Con esto me evito tener que cablear esa AND y es lo mismo en cuanto a funcionalidad. Pero buena opcion!


----------



## jaimepsantos

> Earl te digo que mas sencillo apagar el motor ponle el clock a una or





Earl dijo:


> Con esto me evito tener que cablear esa AND y es lo mismo en cuando a funcionalidad. Pero buena opcion!



Hahaha, dije or no and, pero igual sirve .


----------



## Earl

Hahaha disculpa, quise decir la compuerta  pero si funciona igual


----------



## Hiroshi92

Jajajaja, muchas gracias Earl y Jaimepsantos, mi práctica con motores a pasos funcionó muy bien. Gracias por el código...


----------



## Earl

Hahahah ¬¬' mínimo cambiale nombre a las variables.


----------



## Hiroshi92

Aunque tuve un problemita, el motor a pasos solo giraba hacia un lado y hacia el otro no giraba bien, creo que se debe a la secuencia de las maquinas de estados en reversa, intentare arreglarlo y te aviso. Saludos !


----------



## jaimepsantos

Estas en lo correcto Hiroshi92 (Polo, hahaha) la máquina tiene mal asignados los estados.
Checale bien.

Saludos !


----------



## kekoss

Hola, pues aprovechando que saben mas sobre Wincupl que yo (realmente no se casi nada), quise implementar las compuertas not, and, or, etc. en una gal22v10 pero no se si el programa que hice tenga un error de sintaxis, pero a la hora de compilarlo no me marca ningún error ni warnings, el problema viene cuando abro el archivo .jed en el software del programador que estoy usando pues dice que el archivo esta corrupto o que no lo reconoce, el programador que uso es el Bk Presision 848 y su software pg4uw si no mal recuerdo.




		Código:
	

Name     compuertas ;
PartNo   00 ;
Date     4/21/2010 ;
Revision 01 ;
Designer Engineer ;
Company  keko ;
Assembly None ;
Location  ;
Device   g22v10 ;

/* *************** INPUT PINS *********************/
PIN     1=a; /*                                 */
PIN     2=b; /*                                 */

/* *************** OUTPUT PINS *********************/
PIN     20=nota; /*                                 */
PIN     19=and; /*                                 */
PIN     18=nand; /*                                 */
PIN     17=or; /*                                 */
PIN     16=nor; /*                                 */
PIN     15=xor; /*                                 */
PIN     14=xnor; /*                                 */

nota=!a;
and=a&b;
nand=!(a&b);
or=a#b;
nor=!(a#b);
xor=a$b;
xnor=!(a$b);


----------



## jaimepsantos

Que tal foro les dejo este decodificador binario a hexadecimal en siete segmentos, lo dejo por que no venden estos decos.



		Código:
	

Name     BIN_TO_HEX ;
PartNo   00 ;
Date     28/05/2010 ;
Revision 01 ;
Designer Jaime ;
Company  CETI ;
Assembly None ;
Location  ;
Device   g16v8 ;

/* *************** INPUT PINS *********************/
PIN [1..4]    =    A, B, C, D         ; /*                                 */ 

/* *************** OUTPUT PINS *********************/
PIN  13   =       Sa                  ; /*                                 */ 
PIN  14   =       Sb                  ; /*                                 */ 
PIN  15   =       Sc                  ; /*                                 */ 
PIN  16   =       Sd                  ; /*                                 */ 
PIN  17   =       Se                  ; /*                                 */ 
PIN  18   =       Sf                  ; /*                                 */ 
PIN  19   =       Sg                  ; /*                                 */ 


Sa = !A&!B&!C&D#!A&B&!C&!D#A&B&!C&D#A&!B&C&D;
Sb = !A&B&!C&D#B&C&!D#A&B&!D#A&C&D;
Sc = !A&!B&C&!D#A&B&!D#A&B&C;
Sd = !A&!B&!C&D#!A&B&!C&!D#A&!B&C&!D#B&C&D;
Se = !B&!C&D#!A&B&!C#!A&D;
Sf = A&B&!C&D#!A&!B&D#!A&!B&C#!A&C&D;
Sg = !A&B&C&D#A&B&!C&!D#!A&!B&!C;


----------



## tezcat

Hola que tal estoy siguiendo el codigo pero lo ocupo un poco diferente pero no se que pasa me da varios error y no se como repararlo, les enseño el codigo ke ando tratando de hacer.

PD: No se programar solo intento seguir el codigo 



		Código:
	

Name     Name ;
PartNo   00 ;
Date     08/12/2010 ;
Revision 01 ;
Designer Engineer ;
Company  Tez ;
Assembly None ;
Location  ;
Device   g22v10 ;

/* *************** INPUT PINS *********************/
PIN     1=CLK                         ; /*                                 */ 
PIN     2=A                         ; /*                                 */ 
PIN     3=B                        ; /*                                 */ 
PIN     4=C                         ; /*                                 */ 

/* *************** OUTPUT PINS *********************/
PIN     20= Q0                        ; /*                                 */ 
PIN     21= Q1                        ; /*                                 */ 
PIN     22= Q2                        ; /*                                 */ 
PIN     23= Q3                        ; /*                                 */ 

FIELD PUSH1=[Q3,Q2,Q1,Q0];
FIELD PUSH2=[Q3,Q2,Q1,Q0];
FIELD PUSH3=[Q3,Q2,Q1,Q0];

$DEFINE QA 'b' 0000
$DEFINE QB 'b' 0000 
$DEFINE Q0 'b' 1010 
$DEFINE Q1 'b' 1001 
$DEFINE Q2 'b' 0101  
$DEFINE Q3 'b' 0110

SEQUENCE PUSH1{ 
	PRESENT QA 
		NEXT Q0;
	PRESENT Q0
		IF A NEXT Q1;
	PRESENT Q1
		IF A NEXT Q2;
	PRESENT Q2
		IF A NEXT Q3;
	PRESENT Q3
		NEXT QA;	} /* Aqui lo que quiero hacer es que solamente de 3 ciclos */

SEQUENCE PUSH2{ 
	PRESENT QA 
		NEXT Q3;
	PRESENT Q3
		IF B NEXT Q2;
	PRESENT Q2
		IF B NEXT Q1;
	PRESENT Q1
		IF B NEXT Q0;
	PRESENT Q0
		NEXT QB; 	 

	PRESENT QB 
		NEXT Q0;
	PRESENT Q0
		IF A NEXT Q1;
	PRESENT Q1
		IF A NEXT Q2;
	PRESENT Q2
		IF A NEXT Q3;
	PRESENT Q3
		NEXT QA;        }   /* Aqui que de 2 ciclos hacia la izq y 2 ciclos a la der. */


SEQUENCE PUSH3{ 
	PRESENT QA 
		NEXT Q3;
	PRESENT Q3
		IF B NEXT Q2;
	PRESENT Q2
		IF B NEXT Q1;
	PRESENT Q1
		IF B NEXT Q0;
	PRESENT Q0
		NEXT QB; 	 

	PRESENT QB 
		NEXT Q0;
	PRESENT Q0
		IF A NEXT Q1;
	PRESENT Q1
		IF A NEXT Q2;
	PRESENT Q2
		IF A NEXT Q3;
	PRESENT Q3
		NEXT QA; 	

	PRESENT QA 
		NEXT Q3;
	PRESENT Q3
		IF B NEXT Q2;
	PRESENT Q2
		IF B NEXT Q1;
	PRESENT Q1
		IF B NEXT Q0;
	PRESENT Q0
		NEXT QB;	/* y por ultimo que de 2 ciclos a la izq, 2 ciclos a la der y 1 ciclo a la izq.*/
}


----------



## jaimepsantos

Tez, el programa que tenia originalmente igual es para un motor a pasos lo que hace es que dependiendo las entradas declaradas, y también las salidas, donde el campo ( FIELD ), es donde indicamos que es un solo dato en nuestro caso de 4 bits, lo que tu quieres hacer es que con un push boton cambie, poes asi con esta base no se puede, es combinacional, no es activada con interrupciones, a menos que le pongas unos FF a la entrada para que te guarden el dato ,, a volviendo al programa, donde dice DEFINE, estamos declarando los estados de la maquina, la cual la de debemos inicializar en cero y luego ya tu diras lo que hace segun tus entradas, poniendo sintaxis parecida a esta

...
sequence cont{
present S0 next S1;

present S1
if STOP&AVANZA next S1;
if STOP&!AVANZA next S1;
if !STOP&AVANZA next S2;
if !STOP&!AVANZA next S4;

present S2
if STOP&AVANZA next S2;
...


lo que hacemos aqui es decir que si el estado es S0 pase al S1 asi, ya en el S1 si la entrada declarada como stop Y(and) avanza son 1 el siguiente es el estado S1, se enclava ,, y asi le vas poniendo tus combinaciones.


----------



## savad

Para los que tienen problemas con sequenciales, El programa BOOLE-DEUSTO les puede ayudar, ya que:
1. Es gratis
2. Te permite hacer tu maquina de estados graficamente
3. Te da el codigo para las gal 22V10

El link para descarga es:

http://paginaspersonales.deusto.es/zubia/


----------



## savad

Les dejo la siguiente aportación de como definir una máquina de estados finita en WinCUPL
si no quieres copiar el código, les dejo un archivo de txt que lo incluye
Máquinas de estado con WincuPL

Empezamos por definir los estados con #DEFINE

$DEFINE S0 'b'000  // En este caso llamamos a este estado SO para no tener que estar
                    /* escribiendo su representacion binaria 000 en este caso       */
$DEFINE S1 'b'110    // nota que no necesariamente sigue un orden binario
                    // ya que #DEFINE solo le dice a Winucpl que sustituya S1 por 110

Una vez definidos los estados, definimos la máquina de estados finita(FSM).
Para ello utilizamos la siguiente estructura
SEQUENCE nombre
 {
La definición completa de la máquina de estado esta comprendido entre estos curly braces
 }

Para declarar los estados usamos la palabra PRESENT, debe haber un PRESENT por cada estado
que deseamos

PRESENT S0           /* Define estado S0 */
PRESENT S1           /* Define estado S1 */

Ahora viene lo interesante:
ya que dependiendo del tipo de máquina que deseamos (Syncronica ó asincrónica) 
usamos diferentes definiciones de las transiciones.
/* TABLA 1.   Transiciones posibles en CUPL .
Statement                  Description 
IF       NEXT            Transición condicional al siguiente estado
IF       NEXT  OUT       Transición condicional al siguiente estado con salida Sincrónica
         NEXT            Transición Incondicional al siguiente estado
         NEXT  OUT       Transición Incondicional al siguiente estado con salida Asincrónica
               OUT       salida asyncronica Incondicional
IF             OUT       salida asincrónica condicional
  usamos DEFAULT después de un IF como sustituto de ELSE
DEFAULT  NEXT            Transición condicional al siguiente estado si el IF no se cumplió
DEFAULT        OUT       Transición condicional al siguiente estado con salida Asyncronica
DEFAULT  NEXT  OUT       Transición condicional al siguiente estado con salida sincrónica
*/
 Un ejemplo aclara un poco

/* Uso Field para agrupar salidas o entradas a una palabra en este caso estados*/
/* me agrupa las salidas Q3,Q2,Q1,Q0  */

FIELD estados = [Q3, Q2, Q1, Q0] ;

/* Defino los estados  por comodidad sigo el binario */
$DEFINE S0 'b' 0000  /* Rojo   -        -       -    */
$DEFINE S1 'b' 0001  /* Rojo Naranja    -       -    */
$DEFINE S2 'b' 0010  /*  -   Naranja    -       -    */
$DEFINE S3 'b' 0011  /*  -   Naranja  Verde     -    */
$DEFINE S4 'b' 0100  /*  -      -     Verde     -    */
$DEFINE S5 'b' 0101  /*  -   Naranja  Verde     -    Ahora en reversa */
$DEFINE S6 'b' 0110  /*  -   Naranja    -       -    Ahora en reversa*/
$DEFINE S7 'b' 0111  /* Rojo Naranja    -       -    Ahora en reversa */
$DEFINE S8 'b' 1000  /* Rojo   -        -    Cuenta  Ahora en reversa */

/* y defino la máquina de estados por medio de las transiciones entre estados
/* máquina Asyncronica  no entradas solo el reloj el cúal cambia los estados
// Nota: Solo el GAL22V10 tiene Reset asincrónico (.AR), la 16V8 o la 20v8 solo
// puede ser usada con Reset Sincrónico. 
 Nota: aunque no esta documentado, se puede usar // para hacer un comentario de linea
        como lo hace c++.
       También aunque no esta documentado, WinCUPL no acepta acentos o guiones, ni 
       siquiera en los comentarios       */
SEQUENCE estados 
    {
      PRESENT S0 
            OUT Rojo ;           // Forzo la Salida Rojo mientras este en el estado
            IF Rst NEXT S1;    // Entrada Rst= 1 lleva la transición al estado S1  
            DEFAULT NEXT S0 ;  // Entrada Rst = 0 me mantiene en el mismo estado
     PRESENT S1
            OUT Rojo, Naranja ; //  Dos salidas, se tienen que separar con una coma
            IF Rst NEXT S2;    // Entrada Rst= 1 lleva la transición al estado S1  
            DEFAULT NEXT S0 ;  // Entrada Rst = 0 me lleva al estado de restauración S0
     PRESENT S2
            OUT Naranja ;      // No olviden el ; 
            IF Rst NEXT S3;    // Si hay mas variables usar un operador lógico ej.
            DEFAULT NEXT S0 ;  //         Rst & Q3                           
     PRESENT S3
            OUT Naranja, Verde ; // y continuamos con los demás estados
            IF Rst NEXT S4;
            DEFAULT NEXT S0 ;
     PRESENT S4
           OUT Verde ;         // observa que la salida solo depende del estado
            IF Rst NEXT S5;    // y no de las entradas.
            DEFAULT NEXT S0 ;
     PRESENT S5
           OUT Naranja, Verde ; // Pero la transicion depende de las entradas y
            IF Rst NEXT S6;     // y tambien puede de los estados anteriores.
            DEFAULT NEXT S0 ;
     PRESENT S6
           OUT Naranja ;        /* Forzo la Salida Naranja    */
            IF Rst NEXT S7;
            DEFAULT NEXT S0 ;
     PRESENT S7
            OUT Rojo, Naranja ;    /* Forzo la Salidas Rojo y Naranja    */ 
            IF Rst NEXT S8;
            DEFAULT NEXT S0 ;
     PRESENT S8
            OUT Rojo, Cuenta;      /* Forzo la Salidas Rojo y Cuenta    */
            IF Rst NEXT S1;
            DEFAULT NEXT S0 ;
    }

Ahora veamos el otro caso, la declaración de los estados es el mismo
pero las transiciones no lo son

SEQUENCE estados 
    {
      PRESENT S0 
                                       // Entrada Rst= 1 lleva la transición al estado S1
            IF Rst NEXT S1 OUT Rojo ;  //  y la salida cambia con la transición
                                       // como cuando definimos entrada /salida 
            DEFAULT NEXT S0 ;  // Entrada Rst = 0 me mantiene en el mismo estado
     PRESENT S1
            IF Rst NEXT S2 OUT Rojo, Naranja ;
            DEFAULT NEXT S0 ;  // Entrada Rst = 0 me lleva al estado de restauración S0
     PRESENT S2
            IF Rst NEXT S3 OUT Naranja ; // Si hay mas variables usar un operador lógico ej.
            DEFAULT NEXT S0 ;            //         Rst & Q3                           
       // y continuamos con los demás estados
     PRESENT S3
               IF Rst NEXT S4 OUT Naranja, Verde;
            DEFAULT NEXT S0 ;
     PRESENT S4
                    // observa que la salida depende del estado anterior y la(s) entrada(s)
            IF Rst NEXT S5 OUT Verde ;;    // que causan la transición.
            DEFAULT NEXT S0 ;
     PRESENT S5
            IF Rst NEXT S6 OUT Naranja, Verde ;   // También que se usa DEFAULT como si
            DEFAULT NEXT S0 ;              // fuera el "ELSE" del condicional "IF"
     PRESENT S6
            IF Rst NEXT S7 OUT Naranja ;
            DEFAULT NEXT S0 ;
     PRESENT S7
            IF Rst NEXT S8 OUT Rojo, Naranja ;
            DEFAULT NEXT S0 ;
     PRESENT S8
             IF Rst NEXT S1 OUT Rojo, Cuenta;  // fácil verdad?
            DEFAULT NEXT S0 ;
    }


----------



## EDGAR KAMI

Seguí los ejemplos anteriores para hacer un circuito secuencial sincrono "contador ascendente y descendente "
0-15 15-0, pero al compilarlo en wincupl y poner 9 estados, aparecen ciertas advertencias y al usar los 15 estados, aparecen errores.
Les agradecería su ayuda. El circuito usa 9 salidas y 3 entradas incluyendo el reloj, las 9 salidas son para 2 display de 7 segmentos (7 para un display y los otros 2 para hacer el 1 en el otro display) las entradas son reloj y para realizar adelante y atras en el conteo. Uso pld 22v10c



		Código:
	

Name     Contador AD ;
PartNo   10 ;
Date     12/12/2014 ;
Revision 01 ;
Designer Engineer ;
Company  Kami ;
Assembly None ;
Location  ;
Device   p22v10 ;

/* EDGAR ENRIQUE TEK TORRES */

/* *************** INPUT PINS *********************/
PIN 1=CLK; /* */ 
PIN 2=DER; /* */
PIN 3=IZQ; /* */

/* *************** OUTPUT PINS *********************/
PIN 14=S0; /* */
PIN 15=S1; /* */
PIN 16=S2; /* */
PIN 17=S3; /* */
PIN 18=S4; /* */
PIN 19=S5; /* */
PIN 20=S6; /* */
PIN 21=S7; /* */
PIN 22=S8; /* */
PIN 23=S9; /* */

FIELD CONT=[S0,S1,S2,S3,S4,S5,S6,S7,S8,S9];

$define S0 'b'111111000
$define S1 'b'011000000
$define S2 'b'110110100
$define S3 'b'111100100
$define S4 'b'011001100
$define S5 'b'101101100
$define S6 'b'101111100
$define S7 'b'111000000
$define S8 'b'111111100
$define S9 'b'111101100
$define S10 'b'111111011
$define S11 'b'011000011
$define S12 'b'110110111
$define S13 'b'111100111
$define S14 'b'011001111
$define S15 'b'101101111

SEQUENCE CONT{
present S0 next S1;

present S1
if IZQ&DER next S1;
if !IZQ&DER next S2;
if IZQ&!DER next S9;

present S2
if IZQ&DER next S2;
if !IZQ&DER next S3;
if IZQ&!DER next S1;

present S3
if IZQ&DER  next S3;
if !IZQ&DER next S4;
if IZQ&!DER next S2;

present S4
if IZQ&DER  next S4;
if !IZQ&DER next S5;
if IZQ&!DER next S3;

present S5
if IZQ&DER  next S5;
if !IZQ&DER next S6;
if IZQ&!DER next S4;

present S6
if IZQ&DER  next S6;
if !IZQ&DER next S7;
if IZQ&!DER next S5;

present S7
if IZQ&DER  next S7;
if !IZQ&DER next S8;
if IZQ&!DER next S6;

present S8
if IZQ&DER  next S8;
if !IZQ&DER next S9;
if IZQ&!DER next S7;

present S9
if IZQ&DER  next S9;
if !IZQ&DER next S0;
if IZQ&!DER next S8;

present S10
if IZQ&DER  next S10;
if !IZQ&DER next S11;
if IZQ&!DER next S9;

present S11
if IZQ&DER  next S11;
if !IZQ&DER next S12;
if IZQ&!DER next S10;

present S12
if IZQ&DER  next S12;
if !IZQ&DER next S13;
if IZQ&!DER next S11;

present S13
if IZQ&DER  next S13;
if !IZQ&DER next S14;
if IZQ&!DER next S12;

present S14
if IZQ&DER  next S14;
if !IZQ&DER next S15;
if IZQ&!DER next S13;

present S15
if IZQ&DER  next S15;
if !IZQ&DER next S0;
if IZQ&!DER next S14;

}


----------

