LFSR usando D Flip Flops

Navega tus respuestas
1

Soy bastante nuevo en el lenguaje VHDL y admitiré que lo uso principalmente con fines educativos. He estado intentando diseñar un circuito de cifrado de datos utilizando D flip flops. Obviamente, un componente importante en el diseño del cifrado es la clave.

Mi objetivo general es crear una clave única para cada entrada utilizando un LFSR (registro de desplazamiento de retroalimentación lineal). Por lo tanto, recibiría un valor inicial (8 bits) como mi entrada y luego se generaría una nueva clave cada vez que se envíe una señal "push".

El problema que tengo es que cada clave subsiguiente será una versión modificada del contenido actual de los flip flops. Me preguntaba si hay alguna forma de acceder al contenido actual de las chanclas D? He definido mi flip flop D de la siguiente manera: 

    library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity DFlipFlop is
    Port ( D : in  STD_LOGIC;
           EN : in  STD_LOGIC;
              CLK : in STD_LOGIC;
           Q : out  STD_LOGIC);
end DFlipFlop;

architecture Behavioral of DFlipFlop is

begin

process (EN, CLK)

begin
    if CLK = '1' and CLK'event and EN = '1' then
        Q <= D;
    end if;
end process;


end Behavioral;

Espero mantener la entrada habilitada porque será útil en otros módulos que se basarán en el LFSR. Cualquier ayuda en esto sería apreciada.

Actualización # 1

Aquí hay algo para que todos tengan una mejor idea de lo que estoy tratando de lograr. Por favor refiérase a la imagen de abajo:

Lo que espero lograr con mi entrada de habilitación es que los datos de entrada se ingresen en el LFSR y también realicen la función en la imagen de arriba. De lo contrario, realice la función utilizando solo los datos actuales en los FF, ignorando cualesquiera que sean los datos de entrada. He creado un banco de pruebas de mi FF y parece funcionar bien. También he creado un LFSR potencial: 

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity LFSR_NoPush is
    Port ( KeySet : in  STD_LOGIC;
              EN_FF : in STD_LOGIC;
           DataIn : in  STD_LOGIC_VECTOR (7 downto 0);
              CLK : in STD_LOGIC;
           DataOut : out  STD_LOGIC_VECTOR (7 downto 0));
end LFSR_NoPush;

architecture Behavioral of LFSR_NoPush is

component DFlipFlop is
    Port ( D : in  STD_LOGIC;
           EN : in  STD_LOGIC;
              CLK : in STD_LOGIC;
           Q : out  STD_LOGIC);
end component;

signal Key5, Key4, Key3 : STD_LOGIC;
signal LFSRData : STD_LOGIC_VECTOR(7 downto 0);

begin

process (DataIn, LFSRData)
begin
    if KeySet = '1' then
        LFSRData <= DataIn;
    end if;
end process;

    Key5 <= LFSRData(6) xnor LFSRData(0);
    Key4 <= LFSRData(5) xnor LFSRData(0);
    Key3 <= LFSRData(4) xnor LFSRData(0);

    LFSR7 : DFlipFlop
    port map (LFSRData(0), EN_FF, CLK, DataOut(7));

    LFSR6 : DFlipFlop
    port map (LFSRData(7), EN_FF, CLK, DataOut(6)); 

    LFSR5 : DFlipFlop
    port map (Key5, EN_FF, CLK, DataOut(5)); 

    LFSR4 : DFlipFlop
    port map (Key4, EN_FF, CLK, DataOut(4)); 

    LFSR3 : DFlipFlop
    port map (Key3, EN_FF, CLK, DataOut(3)); 

    LFSR2 : DFlipFlop
    port map (LFSRData(3), EN_FF, CLK, DataOut(2)); 

    LFSR1 : DFlipFlop
    port map (LFSRData(2), EN_FF, CLK, DataOut(1));

    LFSR0 : DFlipFlop
    port map (LFSRData(1), EN_FF, CLK, DataOut(0));     

end Behavioral;

Sin embargo, por el motivo que sea, mis datos de entrada nunca se ingresan a las FF según mi banco de pruebas. Una vez más, cualquier ayuda en esto sería apreciada.

Actualización # 2

El módulo superior de mi circuito tendrá las siguientes entradas / salidas:

Entradas:

  1. Entrada de datos
  2. conjunto de claves
  3. Empujar

Salidas:

  1. texto cifrado

El proceso que espero que tenga mi circuito es el siguiente:

  1. Si el conjunto de claves es alto, los datos son el valor de clave inicial. Si no, es el texto a cifrar.
  2. Si los datos son el valor clave inicial, se enviarán a las FF. Si no, los datos serán XOR por la clave para crear el texto cifrado.
  3. Una vez que los datos lleguen a las FF, permanecerán inalterados hasta que el empuje sea alto. Una vez que la presión es alta, se producirá el procedimiento en la imagen para generar la clave.
  4. El conjunto de teclas solo se debe establecer en alto una vez. Luego, las claves subsiguientes se crearán en base al valor de clave anterior. Por lo tanto, cada vez que la presión es alta, el DataOut (basado en mi código) de la clave anterior debe ser la entrada de los FF para la siguiente clave y luego se debe seguir el proceso en la imagen.

El paso 4 es donde más estoy luchando.

¿Es esto posible con DFFs?

    
pregunta coolDude

1 respuesta

1

Creo que las cosas que realmente faltan en su diseño son señales, existen señales dentro de la arquitectura y pueden asignarse de la misma manera que un puerto, pero sin una interfaz con el mundo exterior, se puede escribir una señal y puede leer y puede ser del tipo que desee y a una salida se le puede asignar una señal del mismo tipo, por lo que para su diseño considere utilizar un registro interno y luego asignarlo a su salida.

Aquí hay un ejemplo de lo que quiero decir: 

library IEEE;
use IEEE.Std_logic_1164.all;
use IEEE.Numeric_std.all;

entity lfsr is

    port (

        -- Clocks
        clkin                                   :in  STD_LOGIC; 

        -- Initialisation data
        first_key                               :in  STD_LOGIC_VECTOR(3 downto 0);

        -- Control Signals
        key_set                                 :in  STD_LOGIC;
        push                                    :in  STD_LOGIC;

        -- Outputs
        data_out                                :out STD_LOGIC_VECTOR(3 downto 0);              
        );

end lfsr;   

architecture RTL1 of lfsr is    

    signal key                      :STD_LOGIC_VECTOR(3 downto 0);

begin                                                                                                               

    -- Generate a key every time the push signal is asserted
    process(clkin)
    begin

        if rising_edge(clkin) then

            if key_set = '1' then -- Initialises the key

                key <=  first_key; 

            elsif push = '1' then -- Generate a new key

                key(2 downto 0) <=  key(3 downto 1);
                key(3)          <=  key(1) XOR key(0);

            end if;

        end if;

    end process;

    -- Send internal key to output port
    data_out    <=  key;

end RTL1;

así que la señal que he creado es clave, es interna a la arquitectura y lo que realmente representa es un bloque de memoria de 4 bits de ancho. Este código realmente hace lo que usted desea, es un LFSR que generará datos pseudoaleatorios, pero lo he hecho de 4 bits de ancho en lugar de 8 porque no quería simplemente darle una respuesta y si puede entender lo que hace este código , podrá comprender cómo expandirlo a 8 bits y será un excelente comienzo para comprender VHDL.

Si tiene alguna pregunta sobre mi código, pregunte,

Gipsy

    
respondido por el Gipsy Danger

Lea otras preguntas en las etiquetas

¿Cómo puedo calcular si un cable puede tener un pico de corriente momentáneo? Mapa de Karnaugh: duplicando tablas