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

Question

Tengo problemas para mostrar un número binario en una pantalla. No estoy seguro de cómo dividir un número en binario en sus números individuales.

Por ejemplo, si quiero mostrar 25, quiero dividirlo en "2" y "5" en binario. Tengo 8 bits entrando y me gustaría dividirlo en dos partes de 4 bits con los primeros 4 bits representando el primer dígito en binario y los segundos 4 bits representando el segundo dígito en binario.

EDIT: Para aclarar, estoy tratando de hacer esto usando puertas lógicas.

Answer 1

El Doblemente, convierte el binario en BCD mediante desplazamientos repetidos. Cada repetición reduce a la mitad el número binario restante y duplica el número BCD, tras el desplazamiento del valor binario completo se obtiene el resultado. Después de cada desplazamiento se aplica una corrección a cada columna BCD de 4 bits (o a las que tienen más de 3 bits desplazados en ese punto). Esta corrección busca los dígitos que "desbordarán el BCD" decimal 9 -> 10 en el siguiente turno y parchea el resultado con añadiendo 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 desplazamiento. Examinar el 5 b 0101 que se desplazará a b 1010 (0xA), que no es un dígito BCD. Por lo tanto, el 5 se corrige a (3+5), es decir b 1000 (0x8) que durante el desplazamiento se duplica a 16 decimal (0x10), representando un acarreo de 1 al siguiente dígito y el esperado cero.

Las implementaciones repiten este proceso, bien de forma sincrónica en el tiempo utilizando un registro de desplazamiento y 'n' ciclos para una entrada de n bits, o bien en el espacio colocando los circuitos lógicos para la corrección alimentándose unos a otros y realizando el desplazamiento con cableado. Hay un camino de acarreo a través de cada dígito, y la lógica de acarreo no se adapta a la lógica de cadena de acarreo de la FPGA (binaria), por lo que la implementación en el espacio suele dar resultados de sincronización inaceptables para entradas grandes. Una compensación típica de ingeniería.

Para una conversión paralela (asíncrona)

Para valores estrechos como los suyos Sitio del Dr. John Loomis tiene una guía de la estructura lógica necesaria para implementar en hardware. La lógica reprogramable moderna puede hacer 8 bits de ancho hasta quizás 100mhz después de una síntesis agresiva. El módulo add3 toma una entrada de 4 bits y la emite textualmente, o si son más de cuatro, añade 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

Combinando estos módulos se obtiene el resultado.

Para una variante secuencial (multiciclo, canalizada)

Para las señales anchas, una técnica en serie descrita en Xlinx App Note "XAPP 029" corre 1 bit por ciclo, probablemente a más de 300mMhz.

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

Answer 2

Lo que se quiere hacer se conoce como conversión a Decimal codificado en binario . Algunos ordenadores tienen instrucciones especiales para ayudar a la conversión a y desde BCD, y para ayudar a la suma y la resta. Sin embargo, eso no es relevante para ti.

La forma más sencilla que conozco para 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 que se encuentra allí es básicamente la implementación de 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;
}

En realidad, esto utiliza dos operaciones de división. Es muy costoso. En su lugar podemos sustituir una de las divisiones por una multiplicación y una sustracción.

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 hace que sea difícil de implementar con la lógica combinatoria. Para hacer esto en lógica pura, el mejor enfoque es probablemente tratar de implementar la primera función.

Answer 3

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

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

Answer 4

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

Tu tabla de verdad debería tener este aspecto:

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

A continuación, convierte la tabla de verdad en mapas de Karnaugh (K-maps) y resuelve para b6, b5 ... b0. Toma las ecuaciones resultantes e impleméntalas usando puertas lógicas.

Información sobre los mapas K: http://en.wikipedia.org/wiki/Karnaugh_map

Y aquí hay una solución que pasa por un ejercicio similar usando puertas Nand: http://circuitscan.homestead.com/files/digelec/bcdto7seg.htm

Edición: De los comentarios: Si tu número de 4 bits no representa estrictamente un BCD, es decir, va más allá del 9, entonces 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. La implementación de esta ecuación en puertas lógicas es sencilla.

Edit2: Muchas de estas ecuaciones se solaparán y podrás simplificarlas más después de la generación.