Inicializar correctamente un registro de desplazamiento (Verilog)

He estado luchando con un programa Verilog muy simple. Es un registro de desplazamiento de 4 bits que gira en cada ciclo de reloj y controla cuatro LED. (Como puede ver, soy nuevo en FPAG y HDL).

El problema : el código siguiente se sintetiza sin advertencias y se programa con éxito en la FPGA. Luego, al iniciar, no pasa nada, los LED permanecen oscuros. La i_Switch_1entrada se agregó para hacer que suceda algo y, de hecho, cuando presiono el interruptor, los LED comienzan a girar.

Aquí está el código de Verilog:

Versión 1 (error)

module top
   (input i_Clk, 
    input i_Switch_1,
    output o_LED_1,
    output o_LED_2,
    output o_LED_3,
    output o_LED_4
   );

     reg [3:0]shift_reg;

     initial
         shift_reg = 4'b0001;   // has no effect

     always @(posedge i_Clk)
     begin
         shift_reg <= i_Switch_1 ? 4'b0001 : {shift_reg[2:0], shift_reg[3]};
     end

     assign o_LED_1 = shift_reg[0];
     assign o_LED_2 = shift_reg[1];
     assign o_LED_3 = shift_reg[2];
     assign o_LED_4 = shift_reg[3];

 endmodule

Evaluación : mi conclusión hasta ahora es que shift_regno se inicializa a 1. La vista RTL a continuación muestra que no se sintetiza ninguna inicialización.

Leí en muchos lugares que el bloque inicial es sintetizable, así que ahora estoy realmente desconcertado.

Pregunta 1 : ¿Es correcta mi evaluación?

Pregunta 2 : Suponiendo que mi evaluación sea correcta, ¿cuál es el remedio? He probado varias cosas y ninguna funciona:

• Ruta en el pin de reinicio, pero eso no parece estar permitido.
• Utilice una shift_reg==0comparación (versión 2 a continuación)
• Usar una is_initbandera (versión 3 a continuación)

Estoy empezando a creer que estoy haciendo algo fundamentalmente mal. ¿¿Qué está pasando??

Versión 2 (falla)

shift_reg <= (shift_reg==0 || i_Switch_1) ? 1 : {shift_reg[2:0], shift_reg[3]}

Versión 3 (falla)

reg is_init; 
initial
    is_init = 0;   // Must have this or else the is_init gets optimized out!

always @(posedge i_Clk)
begin
    if(~is_init || i_Switch_1) begin
        is_init <= 1;
        shift_reg <= 4'b0001;
    end
    else begin
        is_init <= 1;
        shift_reg <= {shift_reg[2:0], shift_reg[3]};
    end
end

Configuración : LatticeSemi iCE40HX1K (placa nandland go) usando iCEcube2, la herramienta de síntesis es Synplify Pro.

--

Actualizar

Esto aquí funciona:

Versión 4 (éxito)

reg [3:0]shift_reg = 0;

always @(posedge i_Clk)
begin
    case(shift_reg)
    1: shift_reg <= 2;
    2: shift_reg <= 4;
    4: shift_reg <= 8;
    8: shift_reg <= 1;
    default: 
        shift_reg <= 1;
    endcase
end

Pero el resultado de la síntesis es algo inflado: