Diseñe un 8 - 6 - 4 - 2 - 0 - 1 - 3 - 5 - 7 - 9... Contador

Diseñe un contador: 12-10-8-6-4-2-0-1-3-5-7-9-11 usando D Flip Flop.

Mi primer enfoque es diseñar un contador 8 - 6 - 4 - 2 - 0 - 1 - 3 - 5 - 7 - 9 - 8 - 6 ... y mostrarlos en LED de 7 segmentos.

Después de escribir el código binario de estos números de arriba, me doy cuenta de que parecen obedecer a una regla.

1 0 0 0 (8)
0 1 1 0 (6)
0 1 0 0 (4)
0 0 1 0 (2)
0 0 0 0 (0)
0 0 0 1 (1)
0 0 1 1 (3)
0 1 0 1 (5)
0 1 1 1 (7)
1 0 0 1 (9)

Se puede ver que el LSB de los números pares siempre es 0, mientras que para los impares siempre es 1. En cuanto a los 3 bits izquierdos, son simétricos. Entonces, mi idea para este problema es que después de contar de 8 a 0, el LSB cambiaría de 0 a 1 y comenzaría a contar (usando 3 o 4 D-Flip-Flop y puertas lógicas). Pero después de escribir Next State Table, me enfrento a la forma de forzar que mi número inicial sea 8.

Estado actual ---- Estado siguiente
0 0 0 0 ------------ 1 0 0 0 (el siguiente estado es 8 si el número inicial es 0)
1 0 0 0 ------- ----- 0 1 1 0 (muestra 8, el siguiente estado es 6)
0 1 1 0 ------------ 0 1 0 0 (muestra 6, el siguiente estado es 4)
0 1 0 0 ------------ 0 0 1 0 (muestra 4, el siguiente estado es 2)
0 0 1 0 ------------ 0 0 0 0 (muestra 2, el siguiente estado es 0)
0 0 0 0 ------------ 0 0 0 1 (muestra 0, cambia LSB a 1 y activa la cuenta progresiva)

El problema aquí es que el estado 0 0 0 0 se usa dos veces (una para forzar que el número inicial sea 8 y otra para cambiar LSB a 1) y creo que mi contador se confundiría. Entonces, me pregunto si hay alguna forma de implementar este tipo de contador.

Gracias de antemano por cualquiera de sus respuestas.

Mi circuito funciona, se basa en el circuito de @Trevor. Gracias a todos por sus increíbles ideas.

" Estoy enfrentando un problema que requiere diseñar un 8 - 6 - 4 - 2 - 0 - 1 - 3 - 5 - 7 - 9 - 8 - 6...", me encantaría saber más sobre este problema para ver si este es el enfoque correcto . ¿No sería una vergüenza si resolviéramos este extraño problema y resultara ser solo un problema XY ?
En realidad, es mi tarea la que requiere diseñar un contador: 12-10-8-6-4-2-0-1-3-5-7-9-11. Pero para simplificar, solo pregunto por 8 - 6 - 4 - 2 - 0... bla, bla.
¿Por qué crees que el estado de reinicio debe ser cero?
¿Contar hasta? Solo veo un mostrador de bajada. Tienes que mirar la tabla de verdad un poco más.
@WhatRoughBeast Intenté simular este contador en Proteus y la salida inicial de D Flip Flop siempre es 0. Así que elijo 0000. Si Q3Q2Q1Q0 (salida de D Flip Flop) = 0000, entonces fuerce que sea 1000 (8).
@Trevor Me refiero a que después de contar de 8 a 0, el LSB cambiará de 0 a 1 y contará 000 1 -> 001 1 -> 010 1 -> 011 1 -> 100 1 y luego cambiará el LSB a 0, y cuenta atrás de nuevo (100 0 -> 011 0 -> 010 0 -> 001 0 -> 000 0). esa es mi idea
Como dije... mira más de cerca. El bit 0 es realmente el bit más significativo. El bit 1 es el bit 0 del contador. Cuenta regresivamente de 4 a cero, luego el siguiente conteo va a F, momento en el que, debido a que el bit 0 desplazado ahora es uno, los bits de salida del contador presentados se invierten. Luego sigue la cuenta regresiva
O puede usar un contador ascendente de manera similar.
@DanielNguyen no nos simplifique demasiado el problema; es posible que no sepa que lo está haciendo más difícil de resolver
Y, en realidad, podría estar eliminando la parte difícil, por lo que obtiene una solución a un problema diferente, tal vez más fácil. Por ejemplo, su secuencia reducida tiene 10 elementos, es un número par. Está haciendo que la parte de los números impares sea más larga que la parte de los números pares distintos de cero. Entonces, esto podría hacer que el problema 8…0…9 sea más difícil de resolver que el problema 12…0…11. O, dado que la longitud de la secuencia correcta es 13 y, como tal, un número primo, generar una secuencia de esa longitud con un registro de desplazamiento es mucho más difícil, por lo que la solución de su simplificación le dará algo que no le ayudará mucho.
(Sé que ya ha agregado el problema original a su pregunta, es solo para ilustrar por qué simplificar un problema sin saber cómo llegar a su solución es una mala idea).
Diséñelo como un contador precargado a partir de 1000.
@Trevor Eso es exactamente lo que esperaba ("Cuenta", me refiero a invertir los 3 bits de la izquierda). Pero no sé la forma específica de implementar este circuito. Cuando cuenta hasta 0, implementé un Z = ~ (Q3 + Q2 + Q1) para generar 1 para invertir bits (usando puertas XOR). Pero la salida de Z cambia (de 1 a 0) tan pronto como cuenta hasta el siguiente número (por ejemplo, 0000, salida 1 -> 1100, salida 0). Gracias por tu comentario.
@MarcusMüller Gracias por su contribución. Esta es la primera vez que publico una pregunta. Lo evitaré en próximas ocasiones.
Este contador se puede dividir en un contador de 3 bits para los bits 3..1 contando 4->3->2->1->0->0->1->2->3->4 y un bit de estado que comienza en 0 invirtiendo si el contador de 3 bits llega a 0 y se invierte de nuevo cuando el contador de 3 bits llega a 4. El bit de estado representa el bit 0 en su contador de 4 bits.
Una vez más, puede hacer esto con un simple contador. Vea esto... simulator.io/board/NGdEpJSRM2/1 establecer los puntos de inicio y final debería ser bastante fácil.
@DanielNguyen: esperaba hacerte pensar de manera más general. El hecho de que un Proteus FF tenga un estado de encendido predeterminado no significa que todos los simuladores, o incluso cualquier FF real, se comporten de esta manera. Y la respuesta general a su pregunta es que necesita agregar un bit adicional a su sistema para identificar el estado de encendido.

Respuestas (6)

Parece que se espera que resuelva esto con un circuito de tipo máquina de estado, sin embargo, también se puede hacer usando un circuito contador clásico.

La clave de este problema es reconocer que para la mitad de la cuenta está invirtiendo los bits de salida del contador. Además, su bit de salida 0 es en realidad el bit más significativo del contador, solo se presenta como el LSB.

Como tal, no necesita contar hacia abajo y luego hacia arriba. Un contador tipo D síncrono clásico con algunos inversores XOR será suficiente para la secuencia de conteo.

ingrese la descripción de la imagen aquí simulador.io

Las puertas adicionales en la salida detectan la condición de acarreo que obliga a las entradas de D-Type a volver al número de inicio.

Tenga en cuenta también que he invertido el flip-flop inferior. Como resulta que su condición inicial para su secuencia 12....11 es en realidad 1 en el contador, no 0, esto efectivamente le da la condición de inicio que desea, al menos en el simulador. También agregué una línea de pulso de reinicio solo por si acaso.

Por supuesto, otra columna de D-Type enganchada en el otro borde del reloj en la salida lo haría aún mejor.

Gracias por tu increíble circuito. Pero en cuanto a mi secuencia (12-10-8-6-4-2-0-1-3-5-7-9-11), mi circuito tiene que contar así: 6-5-4-3-2 -1-0-15-14-13-12-11-10). Para la implementación de este circuito, hasta donde yo sé, tendría que escribir la Tabla de estados para 13 estados (el mismo número de estados que mi secuencia de conteo original, y eso no es lo que quiero). Sería genial si por favor sugiere alguna otra forma de resolver esto.
@DanielNguyen No tengo idea de lo que dices...
Este sitio es mi canal de comedia #1.

Dado que es una tarea, no voy a trabajar con la lógica. Sin embargo, en todas esas preguntas, puede reducirlo a un circuito con dos pasos:

  1. Tiene un binario 0para n-1contrarrestar, donde nestá el número de estados requeridos (13 en su caso). Este puede ser un contador binario síncrono estándar que comienza en 0000 y luego, cuando llega, nse restablece a 0000.

  2. Un circuito lógico combinacional que asigna los valores del contador a los valores de salida. La estructura de esto puede ser puertas lógicas discretas, cuyo circuito se puede derivar utilizando Karnaugh Maps: un mapa por bit en la salida. Alternativamente, podría ser una ROM simple con el mapeo almacenado en ella, donde las líneas de dirección van al mostrador y las líneas de datos son su salida.

Este enfoque será mucho más simple y mucho más genérico (piense flexible) que usar cientos de bits de registro de desplazamiento.

:D Voto a favor instantáneo por proponer lo obviamente sensato que hacer en lugar de molestar a quien dio la tarea. (Tenga en cuenta que no estoy de acuerdo con el aspecto "más simple", veo mi "solución" como más simple, pero es muy probable que su solución sea lo que querían enseñar).
@MarcusMüller Por más simple quiero decir en términos de uso de recursos en el circuito, en lugar de más simple de implementar.
Gracias por su respuesta. En realidad, este fue mi primer enfoque para este problema. Escribiendo la tabla de estados con 13 estados y usando Kmap para minimizar D3 D2 D1 D0 (utilicé 4 D Flip Flop). Pero luego, me di cuenta de que obedece a una regla.
@DanielNguyen Esa "regla" es una propiedad emergente. Es como tratar de modelar la gravedad en un plano usando $-x^2+10$ y luego notar la regla emergente de que la cantidad que sube aumenta en dos cada vez; ambas son válidas pero una es más concisa (la que no t exhibir el patrón).

La solución más aburrida, y la que realmente recomendaría, es simplemente construir un registro de desplazamiento circular de 8 bits de ancho y 13 etapas de profundidad, donde siete bits representan cada uno el estado de encendido/apagado de uno de sus 1er siete Los segmentos LED y un segmento representan los dos segmentos que necesita encender para mostrar un 1 en 10ers.

En efecto, serían solo ocho registros de desplazamiento de 13 etapas en paralelo. Los registros de desplazamiento son triviales de implementar usando D FF, así que aquí tienes:

esquemático

simular este circuito : esquema creado con CircuitLab

El problema sería obtener los valores iniciales en ese registro de desplazamiento, pero podría simplemente declarar que el registro tiene los valores de reinicio correctos y terminar con eso. Nada dice que no puedas.

Por supuesto, 8·13 = 104 registros de desplazamiento pueden no ser bellos , pero nada en la tarea dice que bello es mejor que flexible , rápido o fácil .

  • Flexible : con este circuito, puede implementar cualquier secuencia de 13 pasos en un registro de desplazamiento.
  • Fácil: dado que trabaja directamente con el estado de encendido/apagado de las pantallas de 7 segmentos, evita la sobrecarga de tener que convertir cualquier cosa de una representación de un número a otra.
  • Rápido: la velocidad de reloj de esto está limitada solo por el tiempo de un solo flip flop, y eso significa que esta implementación es probablemente la más rápida de todas las implementaciones que involucran al menos un D-flip flop. No es que la velocidad del reloj importe para el problema en cuestión, pero nuevamente, entiendes la esencia, la declaración de tu problema no define los objetivos de diseño.

Dado que este es un problema puramente académico, siéntase libre de optimizarlo al máximo.

Gracias de verdad por esta respuesta. Pero usar el registro de desplazamiento 104 puede no ser lo que espera mi profesor. Estoy aprendiendo sobre Diagrama de estado, Tabla de estado y Uso de Kmap para implementar funciones booleanas. Gracias de todos modos por tu respuesta realmente detallada.
puede crear una solución para números BCD con un contador ascendente/descendente de 3 bits y un bit de estado que invierte en 0 y 4.

Puedes buscar simplificaciones.

Por ejemplo, puede encontrar que parte del contador simplemente cuenta hacia arriba y hacia abajo en una secuencia sencilla; hay patrones (incluso chips lógicos TTL) que puede usar como contadores ascendentes y descendentes directos.

Para esa parte del contador, simplemente necesita detectar las dos condiciones finales y establecer un bit que controle la función de cuenta ascendente/descendente.

Para el bit restante, ¿puede identificar un patrón o regularidad en su salida? ¿Se deriva fácilmente del contador ascendente/descendente y/o de su lógica de control?

A menudo, esto es más trabajo que un simple contador que controla una tabla de búsqueda, pero probablemente produzca una solución más pequeña.

Para ampliar la excelente respuesta de Tom :

Si el problema es construir un circuito con la menor cantidad posible de elementos lógicos, es posible que desee evitar ese contador 0…12 (que deberá ser un contador de cuatro bits), y en su lugar, use un registro de desplazamiento de retroalimentación lineal para generar los diferentes estados, y lidiar con el hecho de que no son secuenciales en la lógica combinatoria.

Este era un truco común que hacías cuando estabas haciendo cosas como tomar muestras de sonido de una ROM para generar una señal periódica en una época en la que el estado real de la oblea de unos pocos medios sumadores te perjudicaría económicamente. Es muy posible que aún encuentre ese truco en los circuitos integrados modernos que necesitan realizar una tarea similar (es decir, generar una secuencia de salida periódica) a una velocidad muy alta o con un presupuesto de energía muy ajustado.

Sinceramente, no creo que tu escuela espere que diseñes algo así en este momento, pero creo que realmente vale la pena saber que puedes, con un registro de desplazamiento de norte etapas, encuentre una configuración de registro de desplazamiento de retroalimentación lineal que produzca un ciclo de 2 norte − 1 diferentes estados Esto realmente tiene muchas aplicaciones (especialmente en la comunicación digital), y es muy probable que las encuentre más adelante en sus estudios.

No veo dónde se hace referencia a la segunda nota al pie en el texto...
No veo donde se hace referencia en el texto a la 1ra nota al pie de página, ni a la 2da... tal vez esté escondida en el 2 norte .
Ups, sí, tenía una respuesta mucho más larga lista cuando me di cuenta de que la teoría de anillos no beneficia a nadie en esta pregunta (se trataba de por qué no puedes generar una secuencia de longitud 12 con un registro de desplazamiento que es más corto que 12).

UTILIZANDO D FLIP FLOP... Diseñar este contador es muy fácil... Necesita comprender algunos conceptos básicos de las máquinas de estado antes de resolverlo (NOTA: puede usar la tabla de verdad para simplificar la lógica, y perdón por no dibujar la lógica) aquí está el solucióningrese la descripción de la imagen aquí

Y aquí está el diagrama de bloques básico de la máquina de estado/contador de secuencia arbitrariaingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

Diseñe un 8 - 6 - 4 - 2 - 0 - 1 - 3 - 5 - 7 - 9... Contador
RespuestasAquíPolítica de privacidad1y, 3v