Cómo evitar pestillos durante la síntesis

Para evitar bloqueos, debe asegurarse de que todas sus salidas estén asignadas a todas las ramas posibles del código.

por ejemplo,

if a = '1' then
   b(0) <= '1';
else
   b(1 downto 0) <= "00";
end if;

generaría un latch, porque en la primera condición, el valor de b (1) no se especifica, por lo que el compilador decidió que quería mantener el valor anterior de b (1) allí. Una forma de escribir esto que no generaría un pestillo es:

if a = '1' then
   b <= prev_b;
   b(0) <= '1';
else
   b(1 downto 0) <= "00";
end if;

...

if rising_edge (clk)
    prev_b <= b;
end if;

Aquí usted declara explícitamente que b debe retener su valor anterior y luego sobrescribe b (0) con el nuevo valor.

Otra forma es dar a b un valor predeterminado, como en la respuesta de @TomiJ.

Si publica el código en el que está enganchado, podríamos ayudarlo a encontrar el motivo específico.

Si está utilizando procesos para lógica combinacional (y no lo recomiendo por esta razón), asegúrese de que cada ruta a través del proceso asigne algo a cada señal que el proceso dirija. Ninguna de las salidas puede depender de ninguna de las salidas de "la última vez" que se ejecutó el proceso.

De lo contrario, infiere un latch porque la próxima vez que se programe el proceso debe mantener el valor de la señal que no obtuvo un nuevo valor la última vez.

Prefiero mantener la lógica puramente combinatoria como asignaciones continuas, y usar procesos para la lógica sincronizada, luego no obtengo los latches.

Cuatro reglas para evitar pestillos:

• No lea las señales en las que escribe.
• Tenga una lista de sensibilidad correcta (todas las señales que lea deben estar en la lista de sensibilidad)
• Asegúrese de que todas las señales a las que se asigna su escritura estén asignadas en cada ruta. (por ejemplo: en cada rama de una sentencia if-else)
• Para los procesos que utilizan la variable, asegúrese de que cada variable esté inicializada con un valor predeterminado antes de leerla (en otra variable o señal).

Además, si tiene varios procesos combinacionales, asegúrese de no crear un bucle.

Varios estilos de codificación pueden ayudarlo a seguir estas reglas, por ejemplo, el estilo en la respuesta de @TomiJ. Como lo señala @Martin Thompson, puede ser mejor evitar la lógica combinacional en conjunto. Poner todo en un proceso cronometrado en su lugar.

Como han señalado @fbo y @Martin Thompson, debe asegurarse de que a cada señal dirigida por el proceso se le asigne algún valor en cada rama del proceso, y ese valor no debe depender del estado anterior de ninguna de los resultados del proceso.

La forma más sencilla de garantizar esto es asignar algún valor predeterminado a cada salida al comienzo del proceso, por ejemplo (cooptando el ejemplo de fbo):

COMBO: process(a)
begin
    b <= (others => '0'); -- Assign default value to b
    if a = '1' then
        b(0) <= '1';
    else
        b(1 downto 0) <= "00";
    end if;
end process COMBO;