Vector teilen und verzögert ausgeben

[Frank L. (franky83)]

Hallo,
ich hänge gerade etwas und benötige eure Hilfe.

Einfache Situation:
data_in : std_logic_vector(7 downto 0);
data_out : std_logic_vector(7 downto 0);
clk : std_logic;
rst : std_logic;

Nun werden die Daten von data_in modifiziert und zu einem 16bit Vector 
kombiniert. Dieser soll nun aber wieder über den 8bit data_out Port 
geschickt werden. Ich komme hierbei nicht weiter. Habe es mit einem 
Shiftregister probiert, was jedoch zu einem multiple drivers führte.

Ich wäre euch sehr dankbar für einen neuen Ansatz.

Gruß

[Harry (Gast)]

zeig doch mal deinen bisherigen ansatz

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank L. schrieb:
> zu einem 16bit Vector kombiniert.
> Dieser soll nun aber wieder über den 8bit data_out Port geschickt werden.
Da wäre dann noch ein Signal nicht ohne, das anzeigt, ob da gerade das 
High- oder Low-Byte ausgegeben wird...

Alternativ kannst du ja auch 4 Nibbles ausgeben oder 3*6 Bit, und mit 
den restlichen Leitungen die Position im 16-Bit-Wort anzeigen...

[Frank L. (franky83)]

Harry schrieb:
> zeig doch mal deinen bisherigen ansatz

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;


entity rep_entity is

  generic (
        data_width : integer := 8
        );

    port (
        clk: in std_logic;
        rst: in std_logic;
        data_in  : in  std_logic_vector(data_width-1 downto 0);
        data_out : out std_logic_vector(data_width-1 downto 0)
        );

end rep_entity;

architecture Behavioral of rep_entity is

  component rep_comp
    port (  
        data_in  : in  std_logic_vector(data_width/2-1 downto 0);
        data_out : out std_logic_vector(data_width-1 downto 0)
        );
  end component;

  signal tmp_out  : std_logic_vector(data_width-1 downto 0);
  signal x_in_r   : std_logic_vector(data_width-1 downto 0);
  
  type myarray is array (0 to 5) of std_logic_vector((data_width/2)-1 downto 0);
  signal shifter : myarray;
  
begin
  
  rep1: rep_comp
  port map(
    data_in => shifter(5),
    data_out => tmp_out
  );
  
    rep:process(clk,rst)
    begin

      if rst = '0' then

          shifter <= (others =>(others => '0'));
          x_in_r <= (others => '0');

      elsif rising_edge(clk) then

          x_in_r <= data_in;

          shifter(0) <= x_in_r(data_width-1 downto data_width/2);
          shifter(5) <= x_in_r(data_width/2-1 downto 0);

          shifter(1) <= shifter(0);
          shifter(2) <= shifter(1);
          shifter(3) <= shifter(2);
          shifter(4) <= shifter(3);
          shifter(5) <= shifter(4);

      end if;

    end process;

    data_out <= tmp_out;
  
end Behavioral;

Es ist nicht so, dass ich nicht weiss warum mein Ansatz nicht 
funktioniert aber ich weiß leider auch nicht wie ich es machen könnte.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank L. schrieb:

     shifter(5) <= x_in_r(data_width/2-1 downto 0);
     :
     shifter(5) <= shifter(4);

Merk dir: die letzte Zuweisung in einem Prozess gewinnt.

Frank L. schrieb:
> was jedoch zu einem multiple drivers führte.
Ich kann hier keine multiplen Treiber sehen...
Was ist (abgesehen von der obern angesprochenen Ungereimtheit) das 
Problem bei diesem Code?

[Frank L. (franky83)]

Lothar Miller schrieb:
> Ich kann hier keine multiplen Treiber sehen...

rep1: rep_comp
  port map(
    data_in => shifter(5), -- hier einmal
    data_out => tmp_out
  );

----------

shifter(5) <= x_in_r(data_width/2-1 downto 0); -- und hier

Ja ich weiß, Signale erhalten erst ihre Werte nach dem Prozess.
Wie kann ich nun am besten das zweite Byte erst im darauffolgenden Takt 
ausgeben? Tipp?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank L. schrieb:
> data_in => shifter(5), -- hier einmal
Ich würde fast behaupten, data_in wäre ein IN PORT...
Der treibt nichts.

Frank L. schrieb:
> Wie kann ich nun am besten das zweite Byte erst im darauffolgenden Takt
> ausgeben? Tipp?
Nimm einen Multiplexer:

  signal toggle : std_logic := '0';


    rep:process(clk,rst)
    begin

      if rst = '0' then   -- Naja. Wofür?
          shifter <= (others =>(others => '0'));
          x_in_r <= (others => '0');
      elsif rising_edge(clk) then
          if (toggle='1') then  -- high Byte
             data_out <= x_in_r(15 downto 8);
          else                  -- low Byte
             data_out <= x_in_r(7 downto 0);
             x_in_r <= data_in; -- und dann wieder ein neues Wort einlesen
          end if;
          toggle <= not toggle;
      end if;
    end process;

Aber wie gesagt: du siehst nicht, wo du gerade bist (High- oder 
Low-Byte)... :-/

Ach so, das mit dem "verzögert ausgeben"...
Um wieviel verzögert?
Kommen da zwischenzeitlich neue Daten?

[Frank L. (franky83)]

Vielen Dank Lothar,

mit dem Treiber hast du natürlich recht. Mit irgendeiner Kombo hatte ich 
es aber. Nun aber egal. Dein Ansatz läuft. Vielen Vielen Dank

Nun ist es ja so, dass jeden Takt neue Daten rein kommen, verarbeitet 
werden und wieder byteweise ausgegeben werden müssen. Natürlich dauert 
die Verarbeitung länger als nur einen Takt und somit gehen Daten 
verloren.

[Frank L. (franky83)]

Es soll eigentlich ein Wiederholungscode werden aber irgendwie lauf ich 
damit gegen den Baum gerade wenn ich eine ungerade Anzahl an 
Bit-Wiederholungen habe.

Weißt du vielleicht Rat? Ich würde mich sehr freuen über etwas 
Unterstützung.