Haz una pregunta
  Foros de Electrónica » Diseño digital » Circuitos lógicos combinacionales y secuenciales
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

20/02/2014 #21


Vincent:
Un poco confuso con lo que quieres.
- en el principio tu querias: " El contador contará cada vez que se cumpla la siguiente secuencia completa correspondiente al encendido y apagado de las luces en ambos semáforos:"
No especificabas que va ver un operador ajustando 6 switches ....
- El archivo para el Boole-desuto semaforo.aut ... hace lo que querias excepto que no va de regreso.
El nuevo archivo semaforo_R.aut adjunto (recuerda editar el nombre para quitarle la extension .txt, para poder usarlo) ... si va de regreso y solo activa la salida (Cont = Cuenta) cuando se regresa al estado de Rojo-- (donde - indica que no estan prendida la luz para el amarillo y el verde)
La entrada Rst (Reset), se usa para regresar al estado inicial (Rojo--) si se desea ..no importando el estado donde se encuentre.
Usamos la entrada del reloj (del GAL o para los Flip-flops D) para cambiar el estado. aqui aplicamos un pulso el cual podemos programar su frecuencia. ... La salida de un 555 con frequencia variable ó fija se puede usar aqui, lo cual da flexibilidad para que no se adivine cuando se cambia el estado. Pero tambien un switch (acuerdate solo de agregarle un de-bounce, para obtener solo 1 pulso limpio x cambio de estado del switch).
Las salidas de los Flip-Flops (Q0,Q1 y Q2) se usan para formar las salidas a las luces (cuando abras el Boole-desuto como Sequencial, y bajo el menu de ver circuito con D's ), las ecuaciones de las salidas estan alli.
Rojo = (!Q1 * !Q2) + (Q1 * Q2) + ( Q0 * !Q1)
amarillo = (Q0 * !Q1) + (!Q0 * Q1 * !Q2) + ( !Q1 + Q2)
verde = (!Q0 * !Q1 * Q2) + ( Q1 + !Q2)
Se pueden agregar a la GAL facilmente .... aprende a usar Wincupl que es gratis
20/02/2014 #22


Mr. Carlos:

En realidad, tienes razón, lo que habías simulado anteriormente no cumple con el requerimiento final, sólo cumple con la secuencia 4 5 3 2 3 5 4.

Como te decía, si en alguna parte del proceso el operador se devolviera en la secuencia, pero después avanzara nuevamente hasta finalizar el proceso( desde 5 a 4) el contador debe marcar +1.
Los casos de la situación anterior son bien particulares y jamás deben estarán las 3 luces encendidas por ejemplo.

entonces, las posibilidades ,en que por error, el operador se devolviera en la secuencia son por ejemplo:

1) 4-5-4-5-3-2-3-5-4
2) 4-5-3-5-3-2-3-5-4

etc....

Cómo se puede ver no aparecen otras combinaciones distintas a la de la secuencia, y en el fondo, la situación consiste en contar cuando se complete el ciclo,aunque el operador se equivoque y se devuelva alguna vez en alguna parte de la secuencia....sin embargo me imagino que en tu última idea el hecho de considerar cualquier combinación incluye las situaciones particulares que te describía.

revisaré bien tu circuito.

como última cosa, Cómo es que es la lógica de los FF D-octal?? (para entender su funcionamiento)

Muchísimas gracias por tus aportes.
Saludos!
21/02/2014 #23


Hola Vincent14

Bueno, el diseño desarrollado con el simulador ISIS de Proteus que te adjunté en mi mensaje #20, cumple con lo planteado por Ti hasta ahora.
Pero te recuerdo que solo es para la primera mitad de la secuencia. del 4 al 2 (4, 5, 3, 2). Así que faltaría del 3 al 4 (3, 5, 4).

Por lo que mencionas:
como última cosa, Cómo es que es la lógica de los FF D-octal?? (para entender su funcionamiento)

Supongo que te refieres al IC que se mira en aquel circuito que no funcionó como queríamos. Ver Mensaje #17.
Su número de identificación es 74LS273 y efectivamente trae en su interior 8 Flip-Flip’s Tipo D, así que es OCTAL.
Las entradas D y las salidas Q son independientes para cada uno de los 8 Flip-Flop.
Mientras que todas las 8 entradas Clock están juntas y salen por un solo PIN.
Así como tambien las 8 entradas Reset, están juntas y salen por un solo PIN.

Para ejemplificar esto vamos a tomar el Flip-Flip tipo D 74LS74. Este trae, además, una entrada llamada Set la cual no consideraremos para nuestra explicación.
Como queremos que no nos afecte la tenemos que conectar al Vcc para que esa entrada sea falsa.
Nota el pequeño circulo en su entrada Set, éste quiere decir que el Set es cierto cuando es nivel bajo (0).

Qué hace un Flip-Flip tipo D ??
Todo lo que hace es pasar, el estado de su D, a su Q, después de aplicar un pulso a su entrada Clock.
Esto hay que tenerlo bien grabado en nuestra mente.

Pero sucede que nuestro Flip-Flip tipo D octal, tiene una entrada de control llamada RReset-.
Entonces:
Si R se lo permite, todo lo que hace es pasar, el estado de su D, a su Q, después de aplicar un pulso a su entrada Clock.

Por lo tanto el 74LS273 todo lo que hace es pasar, los estados de sus D’s, a sus correspondientes Q’s, después de aplicar un pulso a su entrada Clock. Si MR se lo permite.

Qué ocurre si conectamos nuestro 74LS273 como se mira en la Cuarta imagen ??. . . .
Pues el estado de 4 D’s Pasan a sus correspondientes 4 Q’s después de aplicar un pulso a su entrada Clock. Si MR se lo permite.
Fácil No ??. . .

Así que:
MR Lo Hacemos cierto, nivel bajo*, por un instante.
Todas las Q’s pasan a nivel bajo como resultado de esa acción.
Estado Inicial de las D’s en U8:
D0=1, D1=0, D2=0, D3=1, D4=0, D5=0, D6=0, D7=0.
Aplicamos un pulso a su entrada Clock.
Las Q’s adquieren los niveles:
Q0=1, Q1=0, Q2=0, Q3=1, Q4=0, Q5=0, Q6=0, Q7=0.

Preguntas:
Por Qué el estado inicial de D4, D5, D6 y D7 en U8 es 0 ??.

Si no cambiamos el nivel lógico de D0 en U8, qué nivel lógico tendrá Q4 en U7 después de 4 Pulsos en la entrada Clock ??

* MR Es Cierto Cuando Es Bajo por el pequeño circulo en su entrada MR.

saludos
a sus ordenes
Imágenes Adjuntas
Tipo de Archivo: jpg Primera.jpg (34,3 KB (Kilobytes), 3 visitas)
Tipo de Archivo: jpg Segunda.jpg (46,4 KB (Kilobytes), 2 visitas)
Tipo de Archivo: jpg Tercera.jpg (48,9 KB (Kilobytes), 2 visitas)
Tipo de Archivo: jpg Cuarta.jpg (70,6 KB (Kilobytes), 4 visitas)
Archivos Adjuntos
Tipo de Archivo: zip 74LS273.zip (13,3 KB (Kilobytes), 1 visitas)
21/02/2014 #24


Adjunto el file semaforo-R1.aut.txt (hay que editar el nombre a solo semaforo-R1.aut , para usarlo con el Boole-Desuto), que toma en consideracion la salida solo amarillo no considerada en el anterior.

Tambien la descripcion para Winucpl
Código:
Name            SemaforoR1;
Partno          ;
Revision        01;
Date            2/19/2014;
Designer        David Sanchez;
Company         David Sanchez;
Location        None;
Assembly        None;
Device          G16V8;
/* WinCupl semaforo */
/* Secuencia (RNVc): R---, RN--, -N--, -NV-, --V-, -NV-, -N--, RN--, R--1*/
/* Una entrada para hacer Reset, entrada de pulso en entrada CLK    */

/* PROPERTY SAVAD {preassign TRY}; */

/*** INPUT PINS ***/
/* Todos los pins no usados conectarlos a GND                       */
PIN   1  = Reloj-CLK             ; /* Clk o pulso activo en transicion HL */
PIN   2  = RRst             ; /* Reset asyncronico                   */
/* PIN   3  =              ; /* No usado                            */
/* PIN   4  =              ; /* No usado                            */
/* PIN   5  =              ; /* No usado                            */
/* PIN   6  =              ; /* No usado                            */
/* PIN   7  =              ; /* No usado                            */
/* PIN   8  =              ; /* No usado                            */
/* PIN   9  =              ; /* No usado                            */
/* PIN   11 =              ; /* No usado                            */

/*** OUTPUT PINS all of them active LOW ***/
PIN  19   = Rojo          ; /* Semaforo luz Roja                */ 
PIN  18   = Naranja      ; /* Semaforo luz naranja           */ 
PIN  17   = Verde         ; /* Semaforo luz verde              */ 
PIN  16   = Cuenta       ; /* Al contador                         */ 
PIN  15   = Q3             ; /* Salida del Flip-Flop 'Q3'        */
PIN  14   = Q2             ; /* Salida del Flip-Flop 'Q2'        */
PIN  13   = Q1             ; /* Salida del Flip-Flop 'Q1'        */
PIN  12   = Q0             ; /* Salida del Flip-Flop 'Q0'        */


/***             Equaciones Logicas Intermedias                  ***/


/* Maquina de estado - Reset asincronico                 */ 
$DEFINE state0 'b' 0000  /* Rojo   -        -         -       */
$DEFINE state1 'b' 0001  /* Rojo Naranja    -      -      */
$DEFINE state2 'b' 0010  /*  -   Naranja    -        -      */
$DEFINE state3 'b' 0011  /*  -   Naranja  Verde    -     */
$DEFINE state4 'b' 0100  /*  -      -         Verde   -       */
$DEFINE state5 'b' 0101  /*  -   Naranja  Verde    -       Ahora en reversa */
$DEFINE state6 'b' 0110  /*  -   Naranja     -       -        Ahora en reversa*/
$DEFINE state7 'b' 0111  /* Rojo Naranja    -       -       Ahora en reversa */
$DEFINE state8 'b' 1000  /* Rojo   -           -    Cuenta  Ahora en reversa */

/* Usamos Flip-Flops D */
SEQUENCE[Q3,Q2,Q1,Q0]
    {
     PRESENT state0 IF  RRst NEXT state0;
                            IF !RRst NEXT state1 OUT Rojo ;            
     PRESENT state1 IF  RRst NEXT state0;
                            IF !RRst NEXT state2 OUT Rojo OUT Naranja ;
     PRESENT state2 IF  RRst NEXT state0;
                            IF !RRst NEXT state3 OUT Naranja ;
     PRESENT state3 IF  RRst NEXT state0;
                            IF !RRst NEXT state4 OUT Naranja OUT Verde ;
     PRESENT state4 IF  RRst NEXT state0;
                            IF !RRst NEXT state5 OUT Verde ;
     PRESENT state5 IF  RRst NEXT state0;
                            IF !RRst NEXT state6 OUT Naranja OUT Verde ; 
     PRESENT state6 IF  RRst NEXT state0;
                            IF !RRst NEXT state7 OUT Naranja ;
     PRESENT state7 IF  RRst NEXT state0;
                            IF !RRst NEXT state8 OUT Rojo OUT Naranja ;
     PRESENT state8 IF  RRst NEXT state0;
                            IF !RRst NEXT state1 OUT Rojo OUT Cuenta;
      }
     
     
/*                        Logic Equations                         */


/* File que compila y produce buenos chips = ver final ver        */
Archivos Adjuntos
Tipo de Archivo: txt Semaforo-R1.aut.txt (2,0 KB (Kilobytes), 3 visitas)
25/02/2014 #25


Adjunto file semaforo.jed que puedes usar para quemar una GAL16v8 o para simular en Proteus ... yo no tengo proteus asi que un link de donde bajar el programa gratis seria bienvenida ... Yo programe la GAL y la monte en mi potoboard y trabaja bastante bien. El codigo para wincupl es el siguiente. y si simulas el programa en wincupl veras que devido a que la GAL no tiene un reset asincronico, cuando se hace reset con un pulso menor al tiempo de un ciclo de reloj, la señal de reset no es capturada. (Nota: Fisicamente con un reloj de 0.25 seg o mayor, se captura muy bien el reset) .

Código:
/* WinCupl semaforo */

/* Secuencia (RNVc): R---, RN--, -N--, -NV-, --V-, -NV-, -N--, RN--, R--c*/
/* Una entrada para hacer Reset, entrada de pulso en entrada CLK    */
/*** INPUT PINS ***/
/* Todos los pins no usados conectarlos a GND                       */
PIN 1  = CLK               ; /* Entrada del pulso de reloj          */
PIN 2  = Rst               ; /* Reset                               */
/* PIN   3  =              ; /* No usado                            */
/* PIN   4  =              ; /* No usado                            */
/* PIN   5  =              ; /* No usado                            */
/* PIN   6  =              ; /* No usado                            */
/* PIN   7  =              ; /* No usado                            */
/* PIN   8  =              ; /* No usado                            */
/* PIN   9  =              ; /* No usado                            */
PIN   11 = !OE             ; /* Puesto a Gnd                        */

/*** OUTPUT PINS all of them active LOW ***/
PIN  19   =  Rojo          ; /* Semaforo luz Roja                   */ 
PIN  18   =  Naranja       ; /* Semaforo luz naranja                */ 
PIN  17   =  Verde         ; /* Semaforo luz verde                  */ 
PIN  16   =  Cuenta        ; /* Al contador                         */ 
PIN  15   = Q3             ; /* Q3                                  */
PIN  14   = Q2             ; /* Q2                                  */
PIN  13   = Q1             ; /* Q1                                  */
PIN  12   = Q0             ; /* Q0                                  */


/***              Equaciones Logicas Intermedias                  ***/

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

$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 */


SEQUENCE estados 
    {
     PRESENT S0
                 OUT Rojo ;
                 IF Rst NEXT S0  ;
                 IF !Rst NEXT S1 ;
     PRESENT S1 
                 OUT Rojo, Naranja ;
                 IF Rst NEXT S0;
                 IF !Rst NEXT S2;
     PRESENT S2
                 OUT Naranja ;
                 IF Rst NEXT S0;
                 IF !Rst NEXT S3 ;
     PRESENT S3 
                 OUT Naranja, Verde ;
                 IF Rst NEXT S0 ;
                 IF !Rst NEXT S4 ;
     PRESENT S4 
                 OUT Verde ;
                 IF Rst NEXT S0 ;
                 IF !Rst NEXT S5 ;
     PRESENT S5 
                 OUT Naranja, Verde ;
                 IF Rst NEXT S0 ;
                 IF !Rst NEXT S6 ; 
     PRESENT S6 
                 OUT Naranja ;
                 IF Rst NEXT S0 ;
                 IF !Rst NEXT S7; 
     PRESENT S7 
                 OUT Rojo, Naranja ;
                 IF Rst NEXT S0 ;
                 IF !Rst NEXT S8 ;
     PRESENT S8 
                 OUT Rojo, Cuenta;
                 IF Rst NEXT S0;
                 IF !Rst NEXT S1 ;
     }

Adjunto file para la simulación Semaforo.si 

Name     Semaforo;
PartNo   ;
Date     2/19/2014;
Revision 01;
Designer David Sanchez;
Company  David Sanchez;
Assembly None;
Location None;
Device   G16V8;


ORDER: Cuenta, Rojo, Naranja, Verde, Q2, Q3, Q1, Rst, CLK; 

VECTORS:
*******00
*******01
*******00
*******01
*******00
*******01
*******00
*******11
*******00
*******01
*******00
*******01
*******10
*******01
*******00
*******01
*******00
*******01
*******00
*******01
*******00
*******01
*******00
*******11
*******00
*******01
*******00
*******01
*******00
*******01
*******00
*******01
*******00
Como no se pueden subuir files *.jed tienes que cambiar el nombre del file semaforo.jed.txt
a solo semaforo.jed para poder usarlo en tu programador o simulador proteus
Lo mismo para semaforo.si.txt y semaforo.pld.txt
Archivos Adjuntos
Tipo de Archivo: txt Semaforo.jed.txt (2,3 KB (Kilobytes), 2 visitas)
Tipo de Archivo: txt Semaforo.pld.txt (3,6 KB (Kilobytes), 2 visitas)
Tipo de Archivo: txt SEMAFORO.si.txt (608 Bytes, 2 visitas)
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Circuitos lógicos combinacionales y secuenciales

Compuertas, flips flops, registros, PLDs, codificadores, contadores, multiplexores, ...

Cerrar
Foros de Electrónica » Diseño digital » Circuitos lógicos combinacionales y secuenciales

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.