Mi tarea es escribir un ALU de 16 bits en verilog. He encontrado dificultades al hacer la pieza que necesita para girar el operando y haciendo el complemento a 2 de la adición y la sustracción. Sé cómo trabajar en eso por el papel y el lápiz, pero no puedo averiguar maneras de hacerlo en Verilog.
por ejemplo:
Una se denota como a15 a14 a13 a12 a11 a10 a9 a8 a7 a6 a5 a4 a3 a2 a1 a0
si voy a rotar 4 bits,
la respuesta sería
a11 a10 a9 a8 a7 a6 a5 a4 a3 a2 a1 a0 a15 a14 a13 a12

traté de concatenación pero resulta ser incorrecta.
necesito toda la ayuda…

InformationsquelleAutor Ruka Tsoi | 2014-01-17

4 Comentarios

  1. 2

    ¿Por qué es la concatenación incorrecta? Esto debe hacer lo que le pida.

     assign A_out[15:0] = {A_in[11:0], A_in[15:12]};
    
    • en realidad eso es un ejemplo. en el laboratorio, el número de bits a ser rotado es aleatorio y traté de escribir algo así como asignar A_out[15:0] = {A_in[15-n:0], A_in[15:15-n+1]}; el compilador dice que es de fuera de juego. y no sé cómo resolver
    • Sí, la parte variable seleccione no es legal en ese camino.
  2. 4

    La siguiente funcionará mediante una palanca de cambios:

    assign A_out = {A_in,A_in} >> (16-shift[3:0]);
    

    Cuando shift es un 0 a la izquierda A_in es seleccionado. Como shift aumentar la izquierda A_in desplaza a la izquierda y el Msb del derecho A_in llena.

    Si sintetizar, entonces puede que desee utilizar la une, como dinámica lógica de cambio tiende a requerir más puertas. Una de 16 bits barril de la palanca de cambios se requieren de 4 niveles de 2-a-1 une.

    wire [15:0] tmp [3:1];
    assign tmp[3] = shift[3] ? {  A_in[ 7:0],  A_in[15: 8]} : A_in;
    assign tmp[2] = shift[2] ? {tmp[3][11:0],tmp[3][15:12]} : tmp[3];
    assign tmp[1] = shift[1] ? {tmp[2][13:0],tmp[2][15:14]} : tmp[2];
    assign A_out  = shift[0] ? {tmp[1][14:0],tmp[1][15   ]} : tmp[1];
    
    • ¿Ese no es al revés? A mí me parece que el cambio de operador se une a la derecha A_in que reduce su longitud. Si shift es 0, entonces el desplazamiento de la derecha A_in por regsize - shift bits de turno regsize bits, lo que deja un 0 poco largo de expresión que el operador de concatenación se llena con un implícitamente truncada a la izquierda A_in dejándonos A_in. Si shift es de 1 a regsize, el desplazamiento de la derecha A_in by regsize – shift` bits dejará shift bits de la derecha para la izquierda A_in sólo llena regsize - shift bits, resultando en un total de rotación de izquierda por shift bits.
  3. 2
    assign A_out = A_in << bits_to_rotate;
    

    Donde bits_to_rotate puede ser un valor de la variable (ya sea una señal o un reg).
    Esto va a inferir un genérico de la palanca de cambios utilizando multiplexores, o un barril de la palanca de cambios, lo que se adapte mejor al hardware de destino. El sintetizador cuidado que.


    Oh, bien. Si desea girar el cambio de turno, la cosa es un poco más complicado:

    assign A_out = (A_in << bits_to_rotate) | (A_in >> ~bits_to_rotate);
    
    • «<<» o «>>» es el cambio, ¿no? si voy a usar esto, va a duplicar el desplazamiento a la derecha o mayús izquierda de la función?
    • Sí, son exactamente para ese propósito. Cuando el uso de estos operadores, con una constante en el lado derecho de la expresión, se comportan de la misma como el operador de concatenación de enfoque (y de hecho, son sinthesized como si el operador de concatenación sería utilizado). La cosa buena acerca de estos operadores es que usted puede poner una variable de la expresión en el lado derecho, y luego, el sintetizador de inferir una adecuada (generalmente barril) de la palanca de cambios.
    • Esto está cerca, pero no creo que el ~ hay a la derecha del operador. Si desea girar a la izquierda por 1, usted necesita a <<1 y >>15. ~4'b0001 = 4'b1110 (14). Debe ser >>(16-bits_to_rotate)?
    • o (~bits_to_rotate +1)
  4. 0

    La mejor manera que he encontrado para hacer esto es encontrar un patrón. Cuando quieres girar a la izquierda de 8 bits de la señal de posición 1 (8'b00001111 << 1) el resultado es 8'b00011110), también cuando se quiere girar a la izquierda 9 posiciones (8'b00001111 << 9) el resultado es el mismo, 8'b00011110, y también la rotación de 17 posiciones, esto reduce sus posibilidades a la siguiente tabla:

    Girar a la izquierda verilog caso

    Así que si nos fijamos, los tres primeros bits de todos los números en cuento equivalente a rotar a la posición 1 (1,9,17,25…249) son iguales al 001 (1).

    Los tres primeros bits de todos los números en la tabla equivalente a rotar 6 posiciones (6,14,22,30…254) son iguales a 110 (6).

    Así que usted puede aplicar una máscara (8'b00000111) para determinar el correcto desplazamiento al hacer cero todas las demás bits:

    reg_out_temp <= reg_in_1 << (reg_in_2 & 8'h07);
    

    reg_out_temp se ser el doble de reg_in_1, en este caso reg_out_temp se ser de 16 bits y reg_in_1 de 8 bits, así que usted puede conseguir la llevó a los bits del byte otro cuando cambias de datos para que puedas combinarlos con una O expresión:

    reg_out <= reg_out_temp[15:8] | reg_out_temp[7:0];
    

    Por dos ciclos de reloj tienes el resultado. Para un joven de 16 bits de rotación, su máscara será 8'b00011111 (8'h1F) debido a que los cambios que va de 0 a 16 años, y su registro temporal deberá ser de 32 bits.

Dejar respuesta

Please enter your comment!
Please enter your name here