Transferencia de datos de Latch a PIPO

Question

Este programa está en Verilog y se está simulando en Modelsim. Estoy tratando de transferir datos de 48 bits desde una retención de 192 bits hacia una salida en paralelo en paralelo (registro) en 4 ranuras.

No estoy recibiendo salida en PIPO. Los datos no se están transfiriendo en la salida de PIPO. Por simplicidad, he utilizado para la transferencia 96 bits. Los datos deben venir en cada 48 sclk y sclk es contado por cnt(contador). El tamaño de PIPO es de 48 bits y el tamaño de la retención es de 192 bits.

/* RETENCION PARA 192 BITS */

Parámetro N = 192;

  always@(xlat,dcsel,sipo_out_gs,rst)

    begin
   if(rst)
 gs_latch <= gs_latch;
   else
 if(xlat == 1)
   gs_latch <= sipo_out_gs;
 else
   gs_latch <= gs_latch;
end
/* 48 BITS DE DATOS DE LA RETENCION A PIPO */

 always@(posedge sclk,posedge rst,cnt)

     begin

     if(rst)
   pipo_lat <= pipo_lat;
 else
   if(cnt >= 47 & cnt <= 94)
   pipo_lat <= gs_latch[47:0];
 end

 always@(posedge sclk,posedge rst,cnt)
    begin
       if(rst)
         pipo_lat <= pipo_lat;
     else
        if(cnt >= 95 && cnt <=142)
          pipo_lat  <= gs_latch[95:48];
     else
       pipo_lat  <= gs_latch[95:48];

   end

 /* contador para escala de grises para contar hasta 192 bits  */ 

   always@(posedge sclk,posedge rst) 
 begin
if(rst) 
  cnt <= 0;
else
  if(cnt != N)
    cnt <= cnt + 1;
  else
    cnt <= 0;
 end

Answer 1

Cualquier señal (net/register) para código sintetizable debe asignarse en exactamente un bloque always. En el código pipo_lat está definido en dos bloques always separados. cnt también debe eliminarse de la lista de sensibilidad para lógica síncrona. El reset activo debe asignar valores a una constante. Para bloques de combinación y lógica de latch, es mejor usar always @* en lugar de poner la lista completa de sensibilidad, a menos que se vea obligado a seguir IEEE Std 1364-1995 y nada más nuevo.

module latch_to_pipo #(N=192, M=48, RSTVAL = 1'b0) (
    input wire sclk, rst, xlat,
    input wire [191:0] sipo_out_gs,
    output reg [47:0] pipo_lat );

  reg [7:0]   cnt;
  reg [N-1:0] gs_latch;

  always @* begin // latch
    if(rst)
      gs_latch <= {N{RSTVAL}};
    else if(xlat == 1)
      gs_latch <= sipo_out_gs;
  end

  /* 48 BITS DATA FROM LATCH TO PIPO */
  /* counter for grayscale to count upto 192 bits */
  always @(posedge sclk, posedge rst) begin
    if(rst) begin
      pipo_lat <= {M{RSTVAL}};
      cnt <= 0;
    end
    else begin
      case (cnt)
        8'd47  : pipo_lat <= gs_latch[47:0];
        8'd95  : pipo_lat <= gs_latch[95:48];
        8'd143 : pipo_lat <= gs_latch[143:96];
        8'd191 : pipo_lat <= gs_latch[191:144];
        default: pipo_lat <= pipo_lat;
      endcase
      if(cnt < N-1)
        cnt <= cnt + 1;
      else
        cnt <= 0;
    end
  end
endmodule

Si tu herramienta admite SystemVerilog, te recomiendo que utilices las palabras clave de SV always_comb, always_ff, always_latch, unique, priority, y otras palabras clave de diseño de SystemVerilog donde sea aplicable. Un buen simulador/linter/sintetizador moderno dará errores y advertencias cuando se cometan errores comunes, lo cual es especialmente útil para la depuración. Si es necesario, uno siempre puede degradar fácilmente a una sintaxis más antigua (y aún limpia) con unos simples reemplazos de texto.

la última SystemVerilog LRM disponible de forma gratuita desde IEEE

Answer 2

¿Algo así? (no probado y no 100% confirmado)
Ten en cuenta que no reinicias tu contador al cargar (xlat) la entrada. Esto significa que no sabes en qué momento se enviará cada parte de los datos.
Ten en cuenta que la herramienta de síntesis inferirá un latch para la variable 'gs_latch_reg'

module cnt
  #(
    parameter N = 192
    )
   (
    input wire rst,
    input wire sclk,
    input wire xlat,
    input wire [191:0] sipo_out_gs,
    output reg [47:0] pipo_lat
    );

   reg [7:0]   cnt;
   reg [191:0] gs_latch;

   always@(xlat,sipo_out_gs,rst, gs_latch)

    begin
       if(rst)
     gs_latch <= gs_latch;
       else
     if(xlat == 1)
       gs_latch <= sipo_out_gs;
     else
       gs_latch <= gs_latch;
    end // always@ (xlat,dcsel,sipo_out_gs,rst)

   /* 48 BITS DE LATCH A PIPO*/

   always@(posedge sclk,posedge rst)

     begin

    if(rst)
      pipo_lat <= pipo_lat;
    else
      if(cnt == 47)
        pipo_lat <= gs_latch[47:0];
          else if(cnt == 95)
            pipo_lat  <= gs_latch[95:48];
          else if(cnt == 143)
            pipo_lat  <= gs_latch[143:96];
          else if(cnt == 191)
            pipo_lat  <= gs_latch[191:144];
      else
        pipo_lat  <= pipo_lat;
     end

   /* contador para escala de grises para contar hasta 192 bits */ 

   always @(posedge sclk,posedge rst) 
     begin
    if(rst) 
       cnt <= 0;
    else
      if(cnt != N)
        cnt <= cnt + 1;
      else
        cnt <= 0;
     end

endmodule