Visualización de un entero de 2 dígitos en dos pantallas de 7 segmentos

La técnica Double-dabble convierte el binario en BCD mediante cambios repetidos. Cada repetición reduce a la mitad el número binario restante y duplica el número BCD, una vez que se desplaza el valor binario completo, se obtiene el resultado. Después de cada cambio, se aplica una corrección a cada columna BCD de 4 bits (o aquellas que tienen más de 3 bits desplazados en ese punto). Esta corrección busca los dígitos que serán 'BCD overflow' decimal 9 - > 10 en el siguiente turno y parchea el resultado agregando tres .

¿Por qué tres? Los dígitos BCD en el rango de cero a cuatro (0,1,2,4) se duplicarán naturalmente a 0,2,4,8 después del cambio. Al examinar 5 b 0101 , se cambiará a b 1010 (0xA), que no es un dígito BCD. 5, por lo tanto, se corrige a (3 + 5), es decir, b 1000 (0x8), que durante el turno se duplica al 16 decimal (0x10), lo que representa un mantenimiento de 1 al siguiente dígito y el cero esperado.

Las implementaciones repiten este proceso, ya sea de forma sincrónica en el tiempo utilizando un registro de desplazamiento y 'n' ciclos para una entrada de n bits, o en el espacio colocando los circuitos lógicos para la corrección de alimentación entre sí y haciendo el cambio con el cableado. Existe una ruta de acceso directo a través de cada dígito, y la lógica de transporte no es adecuada para la lógica de cadena de transporte FPGA (binario), por lo que la implementación del espacio generalmente da resultados de temporización inaceptables para entradas grandes. Un típico compromiso de ingeniería.

Para una conversión paralela (asíncrona)

Para valores limitados como el suyo Dr. El sitio de John Loomis tiene una guía de la estructura lógica necesaria para implementar en hardware. La lógica reprogramable moderna puede hacer de 8 bits de ancho a quizás 100 mhz después de una síntesis agresiva. El módulo add3 toma una entrada de 4 bits y la genera en forma literal, o si más de cuatro agrega tres:

module add3(in,out);
input [3:0] in;
output [3:0] out;
reg [3:0] out;

always @ (in)
    case (in)
    4'b0000: out <= 4'b0000;  // 0 -> 0
    4'b0001: out <= 4'b0001;
    4'b0010: out <= 4'b0010;
    4'b0011: out <= 4'b0011; 
    4'b0100: out <= 4'b0100;  // 4 -> 4
    4'b0101: out <= 4'b1000;  // 5 -> 8
    4'b0110: out <= 4'b1001;  
    4'b0111: out <= 4'b1010;
    4'b1000: out <= 4'b1011;
    4'b1001: out <= 4'b1100;  // 9 -> 12
    default: out <= 4'b0000;
    endcase
endmodule

La combinación de estos módulos juntos da el resultado.

Paraunavariantesecuencial(multiciclo,segmentada)

Paraseñalesanchas,unatécnicaenseriedescritaen Nota de aplicación de Xlinx "XAPP 029" se ejecuta 1 -bit por ciclo, probablemente a 300 mMhz +.

Si alguien conoce una buena técnica híbrida, me gustaría conocerla. Modelé ambos en Verilog con bancos de pruebas en mi colección verilog-utils .

Lo que quiere hacer, se conoce como conversión a Decimal codificado en binario . Algunas computadoras tienen instrucciones especiales para ayudar con la conversión hacia y desde BCD, y para ayudar con la suma y la resta. Sin embargo, eso no tiene importancia para usted.

La forma más sencilla que conozco de convertir tu número de 8 bits en dos números de 4 bits es manejarlo en potencias de 10.

unsigned char eight_bit_to_two_four_bit(unsigned char value)
{
    unsigned char result = 0;

    while (value >= 10)        // First, count how many 10s fit into value
    {
        value -= 10;
        result += 0x10;        // and count them in the top 4-bits of result
    }

    result += value;           // The remainder is the number of 1s in value
                               // These end up stored in the bottom 4-bits of result

    return result;
}

El bucle while está básicamente implementando una operación de división. Otra forma de implementar esta función es:

unsigned char eight_bit_to_two_four_bit(unsigned char value)
{
    unsigned char result = 0;

    result  = (value / 10) << 4;
    result += (value % 10);

    return result;
}

Esto en realidad utiliza dos operaciones de división. ¡Costoso! En su lugar, podemos reemplazar una de las divisiones con una multiplicación y una resta.

unsigned char eight_bit_to_two_four_bit(unsigned char value)
{
    unsigned char result = 0;

    result  = (value / 10) << 4;
    result += (value - result*10);

    return result;
}

El hecho de que esta función se implemente con divisiones probablemente dificulte su implementación con lógica combinatoria. Para hacer esto en lógica pura, el mejor enfoque es probablemente intentar implementar la primera función.

¿Está buscando un convertidor de binario a BCD como el 74185 ?

Si no, hay una lista de chips lógicos de la serie 7400 en Wikipedia que puede buscar y encontrar lo que necesita.

Una solución de puerta lógica es sencilla utilizando una tabla de verdad y mapas de Karnaugh. La tabla de verdad tendrá el valor binario como su entrada y el valor BCD deseado para la salida.

Tu tabla de verdad debería verse así:

a0 a1 a2 a3 | b6 b5 b4 b3 b2 b1 b0 <br>
0  0  0  0  | 0  0  0  0  0  0  0
0  0  0  1  | 7-seg output for 1
0  0  1  0  | 7-seg output for 2
and so on

Luego convierta la tabla de verdad en mapas de Karnaugh (mapas K) y resuelva para b6, b5 ... b0. Tome las ecuaciones resultantes e impleméntelas utilizando puertas lógicas.

Información sobre mapas K: enlace

Y aquí hay una solución que está pasando por una ejecución similar usando Nand gates: enlace

Editar: De los comentarios: si su número de 4 bits no representa estrictamente un BCD, es decir, va más allá de 9, derivaría la ecuación directamente de la tabla de verdad. Así, por ejemplo, para esta entrada en la tabla de verdad:

a0 a1 a2 a3   | output
0   1  0  1   | 0 1 1 0 1 1 0

su ecuación para el primer bit (0) es a0 + a1 (barra) + a2 + a3 (barra), el segundo bit (1) es a0 (barra) + a1 + a2 (barra) + a3 y así sucesivamente. Implementar estas ecuaciones en puertas lógicas es sencillo.

Edit2: muchas de estas ecuaciones se superpondrán y podrás simplificar aún más después de la generación.

Si desea que el circuito sea lo más simple posible, le recomendaría que en lugar de mostrar en decimal use hexadecimal. En ese caso, cada pantalla de 7 segmentos muestra un valor de 0 a 15, donde los números 10, 11, 12, 13, 14 y 15 se muestran como A, B, C, D, E y F. Entonces solo necesita dos MC14495 IC para convertir cada valor de 4 bits en sus salidas de visualización de 7 segmentos.