Verilog y declaraciones de ruptura, ¿existe una alternativa posible?

Question

Verilog y declaraciones de ruptura, ¿existe una alternativa posible?

#1 de Tom Carpenter (6 votos)

3

Por lo tanto, actualmente estoy enfrentando un problema en el que romper; ¿Las declaraciones no están permitidas en verilog? ¿Hay alguna alternativa a esto? He intentado deshabilitar block_to_disable, pero eso no resolvió nada. ¿Es posible que haya una solución fácil o Verilog no pueda hacer esto? Solo pregunto porque Verilog es una derivación de C. Gracias por su tiempo y ayuda.

module prj2(input [2:0] usr, input button, output reg [6:0] stage);

//input button 

reg currentState = 0; 
reg tracker = 0;
reg stage_0 = 0;
reg stage_1 = 1;
reg stage_2 = 2;
reg stage_3 = 3;
reg stage_4 = 4; 
reg winner = 5; 

/*stage is read in binary 
  stage 0  = 1 
  stage 1 = 2
  stage 2 = 4
  stage 3 = 8
  stage 4 = 16
  stage win[5] = 32  NO STAGE WIN
*/

/*r/p/s is read in binary
0: rock = 1
1: scissors = 2
2: paper = 4
*/

always @ (button) //start of the action section
begin
case(currentState)//draw and loss are the same
/*=======================================================================================*/
  0://using scissors 
    if(usr == 1) 
        begin //beat scissors so use rock 
      tracker <=  stage_1; 
      currentState <= stage_1; //moved to state 1
      stage <= 2; //stage_1
        //disable block_to_disable; 
    end
    else begin//don't move 
        tracker <=  stage_0;
        currentState <= stage_0; //stay in same state
        stage <= 1; //stage_0
        //disable block_to_disable; 
    end
/*=======================================================================================*/
  1://using rock 
    if(usr == 4) begin//beat rock so use paper
        tracker <= stage_2; 
        currentState <= stage_2; //moved to state 2
        stage <= 4; //stage_2
            //disable block_to_disable; 
    end
    else begin //move back to state 1 
         tracker <=  stage_0;
        currentState <= stage_0; //go back to previous state
        stage <= 1; //stage_0 
            //disable block_to_disable; 
    end
    //break;  
/*=======================================================================================*/
     endcase //end case
  end //end begin that comes after always()
endmodule //end the actual module

verilog cases

pregunta ExchangeChri

1 respuesta

Lea otras preguntas en las etiquetas verilog cases

¿Por qué cambiar el potenciómetro afecta todo el circuito? Eagle - Oval pad

score 6 · Accepted Answer

Verilog es un HDL, no un lenguaje de procedimiento. No es en modo alguno una derivación de C, solo tiene una sintaxis vagamente similar, pero también lo tiene Java.

Los lenguajes de descripción de hardware son solo eso, se usan para describir hardware (qué circuito lógico, registros, RAM, etc.), por ejemplo, las declaraciones if-else representan multiplexores en lógica digital. Esto es completamente diferente de un lenguaje de procedimiento donde las líneas de código se ejecutan en una CPU a su vez, donde puede saltar de un bit de código a otro (break, goto, if-else).

Las declaraciones de "descanso" no tienen sentido en HDL, porque no hay nada de qué salir: ¿cómo saltarías de un flip-flop? A menos que quieras decir 'break' como al pedirle al FPGA que se incendie o algo (¡lo que definitivamente lo rompería!).

Me da la impresión de que está acostumbrado a la programación en un lenguaje de procedimiento y es nuevo en HDL. Le sugiero que vaya a investigar / aprender las implicaciones de una HDL; hay muchos tutoriales por ejemplo, por ejemplo. Google "Verilog en un día". Debe comprender que el código no se ejecuta, sino que infiere puertas lógicas y chanclas (entre otras cosas). Comprender cómo se sintetiza HDL en un circuito RTL es muy importante para poder programar con idiomas HDL.

Para una declaración de caso, no necesita una declaración de ruptura, simplemente haría:

case (something)
    value: begin
        //do something while "something==value"
    end
    othervalue: begin
        //do something while "something==othervalue"
    end
    default: begin
        //do something while "something" is none of the above
    end
endcase

Además, su código no tiene ningún sentido, ni tampoco algunos de sus comentarios.

always @ (button) //start of the action section

Eso básicamente dice implementar el siguiente bloque como lógica combinacional donde la única entrada es una señal llamada "botón". Sin embargo, tienes muchas otras entradas, por lo que no tiene sentido.

Ahora si tuvieras:

always @ (posedge button)

inferiría un flip-flop cuyo reloj es la señal del "botón". El hardware inferido por la declaración del caso se activaría en el flanco ascendente de la señal del botón. En realidad, esto sería una lógica combinacional (que siempre se calcularía como un conjunto de tablas de búsqueda), cuya salida se engancha a uno o más flip flops en el borde ascendente de la señal del botón

Este es otro ejemplo de un problema XY : nos está diciendo cuál cree que es la solución (Y) en lugar de decirnos qué en realidad estás tratando de hacer (X).

Verilog y declaraciones de ruptura, ¿existe una alternativa posible?

Publicaciones recientes del blog

1 respuesta