Bit stuffing / Bit einfügen

Also die Daten erhalte ich als Bit_vector (81 downto 0), das ganze soll 
nur ein Programmstück werden, also ohne Hardware, wird nur simuliert. 
Ich darf alles machen, also auch zwischenspeichern.

Also, unser professor möchte dass wir es mit schieberegistern machen.
Hab mir auch schon einen entwurf gezeichnet, nun muss ichs nur noch so 
programmieren, wie es aufn Blatt ist :-)

Dennoch eine Frage habe ich noch, wie mache ich aus einem Vector, dass 
alle Bits taktweise weitergeschoben werden, bzw. dann die seriellen Bits 
wieder zu einem Vector zusammengefügen werden?

Hi, hab mein Programm soweit fertig, nun habe ich aber das Problem, dass 
mein eingefügtes Bit irgendwie verloren geht. Vielleicht sieht ein Profi 
den Fehler, ich kann ihn jedenfalls nicht finden. Denke dass meine 
If-Bedingung (Temp=00,11,01) irgendwie fehlerhaft ist. sonst 
funktioniert es aber schon ganz gut.

hier mein Programm:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity bitstuffing is
    Port ( clk : in  bit;
           res : in  bit;
           datenin : in  bit_vector (98 downto 0); --Daten die ankommen
           enable : in  bit;              --wenn 1 dann beginnen, senden
           datenout : out  bit_vector (118 downto 0));
end bitstuffing;

architecture Behavioral of bitstuffing is


signal   regpar : bit_vector (98  downto 0); --Datenin werden übernommen
signal  regser : bit_vector (5   downto 0);  -- 5 Bits werden geschoben
signal  regout : bit_vector (118 downto 0);  --Datenausgang
signal   temp   :  bit_vector (1 downto 0);
begin  --temp zum festellen ob 5 gleiche bits



einlesen_senden : process(clk, res, enable)
begin
if (res = '1') then
regpar <= ('0',others => '0');

elsif (clk'event and clk = '1')Then

regser (5 downto 1) <= regser (4 downto 0);
regpar (98 downto 1) <= regpar(97 downto 0);
regout (118 downto 1) <= regout(117 downto 0);
if temp = "00" then             --hier evtl. ein Fehler
regser(0)<='1';
regser (5 downto 0) <= regpar(98 downto 93);
regout (5 downto 0) <= regser (5 downto 0);
elsif temp = "11" then
regser(0)<='0';
regser (5 downto 0) <= regpar(98 downto 93);
regout (5 downto 0) <= regser (5 downto 0);
elsif temp ="01" then
regser (5 downto 1) <= regpar(98 downto 94);
regout (5 downto 1) <= regser (5 downto 1);
end if;

if (enable ='1') then

regpar (98 downto 0) <= datenin (98 downto 0);
datenout (118 downto 0) <= regout (118 downto 0);

end if;
end if;


end process einlesen_senden;


abfrage_stuffing: process(regser)
begin

if (regser(5 downto 1) = "00000") then
temp <= "00";
elsif (regser(5 downto 1) = "11111") then
temp <= "11";
else
temp <= "01";
end if;
end process abfrage_stuffing;

end Behavioral;

Hier meine Testbench:

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;

ENTITY test_vhd IS
END test_vhd;

ARCHITECTURE behavior OF test_vhd IS

  -- Component Declaration for the Unit Under Test (UUT)
  COMPONENT bitstuffing
  PORT(
    clk : IN bit;
    res : IN bit;
    datenin : IN bit_vector (98 downto 0);
    enable : IN bit;
    datenout : OUT bit_vector (118 downto 0)
    );
  END COMPONENT;

  --Inputs
  SIGNAL clk :  bit := '0';
  SIGNAL res :  bit := '0';
  SIGNAL enable :  bit := '0';
  SIGNAL datenin :  bit_vector (98 downto 0) := 
("1111111111111000001010101010101010101010101010101010101011111111111100 
00000000000000000011111111111");
  --Outputs
  SIGNAL datenout :  bit_vector (118 downto 0);

BEGIN

  -- Instantiate the Unit Under Test (UUT)
  uut: bitstuffing PORT MAP(
    clk => clk,
    res => res,
    datenin => datenin,
    enable => enable,
    datenout => datenout
  );
process
  begin
  for i in 99 downto 0 loop
  wait for 5 ns; clk <= not clk;
  end loop;
  end process;
  tb : PROCESS
  BEGIN

    -- Wait 100 ns for global reset to finish

    wait for 5 ns;
    enable <='1'; wait for 15 ns; enable <='0';
    wait for 450 ns;
    enable <='1'; wait for 15 ns; enable <='0';



    wait; -- will wait forever
  END PROCESS;

END;