Run Length Decoding

[Lars H. (larsh)]

Hallo zusammen,
ich habe ein kleines Problem mit einem VHDL-Code.

Vor einer SPI-Schnittstelle bekomme ich Daten angeliefert ins LCA. Der 
Dateninhalt ist RunLength-codiert. Das erste Bit ist die Run_Value und 
die nächsten Bits sind die Lauflänge (RunCount).

Diese Werte will ich in einer Vektor der Länge 420 (Din) schreiben. Wenn 
also eine RunValue='1' ist und RunLength ='127' dann sollen von Position 
0..126 der Wert '1' in den Vektor Din geschrieben werden.

Die letzte RunLength merke ich mir und beim nächsten Durchlauf wird ab 
dieser Position mit der neuen RunLength der Wert von RunValue in den 
Vektor geschrieben, solange bis 420 Bits geschrieben wurden.

Vom Prinzip her also so:

Wortbreite := 420;
run_count <= to_integer(unsigned(Data_In(6 downto 0)));
run_value <= to_integer(unsigned(Data_In(7)));
                                     
if (Wortbreite - index) >= 0 then
  for i in (run_count + index) downto index loop
      Din (i) <= run_value; 
      end loop;
      index <= run_count + 1;
  end loop;
end if;

Das Problem ist jetzt, das es so nicht Synthesefähig ist, da run_count + 
index nicht konstant ist.

Mir fehlt einfach die Idee, wie ich einen Variablen Vektor in VHDL 
erzeugen kann.

Gruß
Lars

[O_o (Gast)]

Wieviele Takte hast du dafür Zeit?

[Lars H. (larsh)]

Wie viele Takte ich Zeit habe, hab ich mir noch nicht überlegt. Mir geht 
es eher darum das Problem zu verstehen wie ich aus so einem 
"Software-Algorithmus" eine Synthese erstelle.

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

Lars Harms schrieb:
> Vor einer SPI-Schnittstelle bekomme ich Daten angeliefert ins LCA.
Ein LCA, echt? Ja, wo gibts denn sowas noch? Das ist ja ein Begriff aus 
dem letzten Jahrtausend...

> Mir fehlt einfach die Idee, wie ich einen Variablen Vektor in VHDL
> erzeugen kann.
Kannst du auch nicht. Denn das ist ja Hardware, und die ist nicht 
variabel...

> Vor einer SPI-Schnittstelle bekomme ich Daten angeliefert ins LCA. Der
> Dateninhalt ist RunLength-codiert. Das erste Bit ist die Run_Value und
> die nächsten Bits sind die Lauflänge (RunCount).
Wieviel Zeit hast du bis das nächste Byte "hereinkommt"? Hast du da 128 
"Systemtakte" Zeit? Denn dann baust du einfach ein großes 
Schieberegister und liest das nach 420 Schritten parallel aus. Das sind 
ca. 15-25 VHDL-Zeilen...

> run_value <= to_integer(unsigned(Data_In(7)));
Das ist jetzt aber nicht dein Ernst, oder?
Ein Bit kann sowieso nur 0 oder 1 sein, was willst du da nach integer 
umrechnen?

> Diese Werte will ich in einer Vektor der Länge 420 (Din) schreiben. Wenn
> also eine RunValue='1' ist und RunLength ='127' dann sollen von Position
> 0..126 der Wert '1' in den Vektor Din geschrieben werden.
> Die letzte RunLength merke ich mir und beim nächsten Durchlauf wird ab
> dieser Position mit der neuen RunLength der Wert von RunValue in den
> Vektor geschrieben
Als Tipp: wenn du das kombinatorisch machen willst (mit der 
for-Schleife), gibt das einen Riesenmonstermultiplexer, 
Sowashatdieweltnochnichtgesehenaberauch... :-o

[Lars (Gast)]

Bei der Run value hab ich die Konvertierung aus Versehen mit 
reinkopiert...... klar das macht keinen Sinn.

Ich werde das dann wohl mit dem Schieberegister lösen.

Das mit dem Multiplexer war mir jetzt tatsächlich nicht klar.

Besten Dank für die Antwort.

[René D. (Firma: www.dossmatik.de) (dose)]

Du mußt noch was einbauen.

In Hardware würde die Schleife ganz schnell mehrmals durch laufen 
werden.

An Anfang muss geprüft werden ob der Wert aktuell ist.

So in der Art

process(clk,write)
  begin
    if rising_edge( clk) then
      if write_active='1' then

           ....die Bearbeitung


     end if;
    end if;
end process;