Beste mensen,
Ik ben op dit moment bezig met een compressie algoritme. Maar ik stuit op een probleem waar ik al dagen aan werk.
Ik heb in VHDL namelijk 16 buffers van 12 bits waar ik eens in de 16 klokslagen een (variabel) aantal bits in plaats:
x -> 0/1, echt data bit
- -> rotzooi
Dus mijn buffers kunnen er als volgt uitzien:
----xxxxxxxx -------xxxxx xxxxxxxxxxxx -----------x etc.
Afhankelijk van hoeveel bits ik telkens gebruik.
Maar nu wil ik deze bussen achter elkaar uitsturen in een 8 bits bus, maar natuurlijk alleen de benodigde 'x'jes en niet de andere "rotzooi" bits ertussen in (anders krijg ik geen compressie 
). Dus elke klokslag wil ik 8 'x'jes uitsturen en de klokslag erna de volgende 8 'x'jes totdat ik alle 'x'jes in alle buffers verstuurd heb. Zoals jullie zien zijn deze buffers telkens weer variabel wat een probleem is met het plaatsen in de output.
Heeft iemand een idee hoe ik dit zou kunnen oplossen?
Thnx!
free_electron
Silicon Member
Professioneel ElectronenTemmer - siliconvalleygarage.com - De voltooid verleden tijd van 'halfgeleider' is 'zand' ... US 8,032,693 / US 7,714,746 / US 7,355,303 / US 7,098,557 / US 6,762,632 / EP 1804159 - Real programmers write Hex into ROM
hoe weet je waar er echte data zit ? er moet ergens een aanduiding zijn daarvoor ...
grote multiplexer maken....
flipflop
"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
TS, hoe hou je bij welke bits geldig zijn? In een extra bit "naast" de databits?
Wat je zou kunnen doen: maak een multiplexer met elk bit van het buffer als ingang. Met een selectiesignaal kun je kiezen welk bit je wilt. In een loopje loop je alle standen af, en alleen als het bit geldig is (vandaar m'n vraag), shift je het databit in een 8-bits register. Als dat register vol is, verstuur je het. Doorgaan totdat je het hele buffer langs bent geweest. Komt het over zo in woorden?
ps, als je het handig opschrijft is die mux hierboven niet meer dan een rijtje AND poorten met een grote OR erachter (read-or tree).
[Bericht gewijzigd door flipflop op (12%)]
Ja flipflop, ik heb dat geprobeer d.m.v. een loopje. Ik had twee registers gemaakt. een register (data_temp) waarbij ik alle registers "geconcatenate" heb (dus met de ongeldige bits ertussen) en een tweede register (data_indicator) gevuld met 0/1 om te zeggen waar een geldig bit zit (1) en waar niet (0).
Het volgende for-loopje had ik gemaakt:
for i in 0 to 191 loop
if(data_indicator(i)='1') then --dus geldige data
output_temp(j)<=data_temp(i);
end if;
end loop;
Maar ik heb nog geen manier gevonden dat als j 8 bereikt dat hij gereset wordt en de data in een nieuw byte geschreven wordt. Daarbij kun je in een for-lus ook niet beide register met een andere integer vullen. Hier krijg je een error op van de synthesizer.
Volgens mij is dit de manier wat jij bedoelde he?
flipflop
"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
Oh, je bent beginner in HDL denk ik? Wat jij daar opschrijft is hetzelfde als
if(data_indicator(0)='1') then output_temp(j)<=data_temp(0);
if(data_indicator(1)='1') then output_temp(j)<=data_temp(1);
if(data_indicator(2)='1') then output_temp(j)<=data_temp(2);
if(data_indicator(3)='1') then output_temp(j)<=data_temp(3);
if(data_indicator(4)='1') then output_temp(j)<=data_temp(4);
..voor de eerste 5, maar het gaat zo door tot 191. Ik weet niet wat j is in jou geval, maar ik hoop dat je snapt wat die for/next doet. In het kort, het bespaart je wat typewerk. De loop schrijft de loop-inhoud voor je uit met telkens een nieuwe i. En omdat j niet veranderd, is dat telkens naar dezelfde output. Gaat niet werken.
Wat je moet (kunt) doen is een echt schuifregister maken waarin je telkens een nieuw bit schuift. Dat bitje wordt geselecteerd vanuit een multiplexer 1-uit-192. Maak een teller 0..191 die de selector is voor je multiplexer. Met een if statement check je dan of je geselecteerde bit geldig is. Zo ja, dan schuif je het in het schuifregister.
Dit moet je in een geklokt proces doen, elke klokslag bekijk je het volgende bit. Dat gaat dus wel wat tijd kosten, ik weet niet of dat een probleem is.
Ja flipflop, ik weet dat het zo werkte en die teller van j heb ik er ook niet bij gezet. In mijn vorig bericht stond ook het volgende: "Maar ik heb nog geen manier gevonden dat als j 8 bereikt dat hij gereset wordt" .
Maar het probleem is inderdaad dat ik wil dat elke klokslag een byte (met alleen echte data) naar buiten wordt geschoven, en niet elke klokslag maar bit, dan was het niet moeilijk geweest.
P.S: als ik het goed begrijp ben ik met jouw manier ook een klokslag kwijt als er helemaal geen geldig bit is. Dat zou dus betekenen dat ik na 209 klokslagen mijn data pas alle geldige data netjes naar buiten kan sturen.
flipflop
"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
Je moet alle bitjes langs, dus na 192 klokslagen heb je alle bytes eruit. Afhankelijk hoeveel geldige data erin zit heb je 0 tot 192/8 bytes uitgestuurd. Je zult in de praktijk dus niet elke 8 klokslagen een byte krijgen omdat er ook ongeldige data is die je overslaat.
Ik denk dat het een grote uitdaging is om elke klokslag een byte uit te sturen. Probeer je maar eens de logica voor te stellen die zo'n functie kan uitvoeren. Ik zie dat nog niet.
Ok, maar ja een oplossing met elke keer maar 1 bit naar buiten sturen is een te lage through-put voor dit design (streaming video). Ik weet dus geen manier om deze buffers achter elkaar te plakken zonder de "niet-geldige" bits ertussen. Er moet toch een manier voor zijn...
Ik moet deze stream namelijk naar een ontvanger sturen en die stream moet zo min mogelijk "niet-geldige" bits bevatten, anders haal ik de bepaalde compressie rate niet.
Er zijn toch wel eens vaker compressie algoritmen in hardware gemaakt neem ik aan? Ik vraag mij dan af hoe deze algoritmen hen data naar buiten spuwen.