Atlantis <m...@w...pl> wrote:
> W ramach poznawania podstaw VHDL-a na CPLD pracuj? obecnie nad pewnym
> projektem.

O VHDL nie ma pojecia wiec sie wypowiem :)

> O ile bez wi?kszego problemu uda?o mi si? napisa? wi?kszo??
> potrzebnych komponent?w (dzielnik cz?stotliwo?ci, licznik binarny,
> sterownik wy?wietlacza siedmiosegmentowego).
> Niestety - wygl?da na to, ?e utkn??em na zagadnieniu konwersji liczby
> zakodowanej binarnie na kod BCD. Na wej?ciu komponentu mam siedmiobitowy
> STD_LOGIC_VECTOR, przez ktory przekazuj? warto?? mieszcz?c? si? mi?dzy 0
> i 99. Na wyj?ciu znajduje si? o?miobitowy STD_LOGIC_VECTOR. Jego starszy
> p??bajt ma mie?ci? liczb? dziesi?tek, m?odszy liczb? jedno?ci.
>
> Wydawa?o mi si?, ?e mog? to zrobi? prosto, tak samo jak na
> mikrokontrolerach - dziesi?tki uzyskuj?c za pomoc? dzielenia przez 10, a
> jednostki za spraw? operacji modulo 10.

No, wszytkie mikrokontolery ktore mam dzielenie robia programowo.
W wiekszych mmozenie jest sprzetowe, w mniejszych nawet mnozenie
jest programowe.

> Napisa?em wi?c co? nast?puj?cego:
>
> bcdval(7 DOWNTO 4) <= binval/10;
> bcdval(7 DOWNTO 0) <= binval MOD 10;
>
> Niestety, synteza kodu wywala si? w?a?nie w tym miejscu, zwracaj?c b??d:
> "Operator <DIVIDE> must have constnt operands or first operand must be
> power of 2".
>
> Wygl?da wi?c na to, ?e nie mog? w prosty spos?b wykona? dzielenia
> dowolnej liczby przez inn? dowoln? liczb?.
>
> Jak w takim razie powinien by? zrealizowany taki konwerter?

Zgaduje ze VHDL z tego kodu chce zrobic siec logiczna ktora
w "jednym kroku" produkuje wynik. Wszystkie procesory ktore
znam majace sprzetowe dzielenie maja dzielenie wielotaktowe.
Ogolnie jednotaktowa siec dzielaca jest skomplikowan i duza.
Ty masz bardzo maly rozmiar danych, wiec jak sie upierasz
to pewnie mozesz to zrobic "na sile": dla kazdego bitu
wyniku napisac formule boolowska dajaca wartosc tego bitu, tzn
cos w stylu

out0 <= in0 /* Latwe */
out1 <= (
/* in = 2 lub in = 3 lub in = 6 lub in = 7 */
in1 and not in3 ... and not in7
/* in = 12 lub in = 13 */
or not in1 and in2 and in3 and not in4 ...
....

Przetlumaczone naiwnie da pewnie kilka tysiecy bramek.
Optymalizator moze to troche uproscic, ale nie liczylbym
na dramatyczne uproszczenia.

Rozsadniej zrobic wielotaktowa konwersje, tzn operacje "krok
dzielenia". Dokladniej, na wejsciu kroku dzielenia masz
dwie liczby 7-bitowe. Wyjscie to 1 bit wyniku dzielenia
i liczba 7-bitowa (reszta z dzielenia). Ten bit wyniku
to po prostu resultat porownania. Reszta to albo
dzielna (jesli bit wyniku to 0) albo dzielna minus
dzielnik (jesli bit wyniku to 1). Po kroku dzielnia
oba argumenty dzielisz przez 2 (przesuwasz) i jesli
trzeba robisz nastepny krok. W twoim przypadku
krok dzielenia trzeba powtorzyc 4 razy. Teoretycznie
mozesz po prostu uzyc kaskade 4 krokow, ale wtedy
powielisz 4 razy glowna czesc.

W twojej konwersji masz maly zakres i pewnie szybkosc
jest malo istotna. W takim przypadku mozesz uzyc 3
liczniki. Jeden zliczajacy az do argumetu. Drugi
liczacy do 10 (daje reszte). Trzeci zliczajacy
przeniesienia drugiego (daje wynik).

Jesli w projekcie masz pamiec to chyba najrozsadniejsze
jest przechowywanie tabeli konwersji w pamieci.

Jeszcze jedno: bit 0 wyniku jest taki sam jak bit 0 wejscia,
wiec problem redukuje sie do dzielnia liczby szesciobitowej
przez 5. To pozwala na troche oszczednosci, ale nie
zmienia zasady.

--
Waldek Hebisch