aukštyn / žemyn pilka skaitliukas

H

heastone

Guest
Kaip aš galiu įgyvendinti aukštyn / žemyn pilka counter by VHDL?
išskyrus dvejetainis kovos su pilka counnter

 
Peržiūrėti šį (po Verilog, galite konvertuoti į VHDL X-HDL):
http://klabs.org/richcontent/software_content/ip/ip.htm

Galite naudoti State Machine požiūris jei skaitiklis plotis yra mažas

 
Verilog failą:
http://klabs.org/richcontent/software_content/ip/dane/gray_updown.v

***
"laikotarpį 1ns/100ps
modulis gray_updown (CLK, aclr, vienas, aukštyn, gray_code);
parametras SIZE = 22;
įvesties CLK, aclr, vienas, aukštyn;
išvesties [SIZE-1: 0] gray_code;
reg [SIZE-1: 0] gray_code, tog;
integer i, j, k;
visada @ (posedge CLK ar negedge aclr)
jei (aclr == 1'b0) prasideda
gray_code <= 0;
pabaiga
kitas prasideda / / nuoseklaus atnaujinimo
if (ena == 1'b1) prasideda / / įjungta
Rengia = 0;
for (i = 0; i <= DYDIS-1, i = i 1) prasideda / / i kilpa
/ /
/ / Toggle bit jei bitų skaičius, nustatytas [SIZE-1 i] dar
/ / XNOR naujausių bitų iki TPĮ bitus Count Up, ir
/ / XOR už Count Down
/ /
for (j = i; j <= DYDIS-1, j = j 1) tog = tog ^ gray_code [j];
jei (ne == 1'b1) tog =! tog ;
/ /
/ / Išjungti tog jei žemesnio KALTAI yra sveriame
/ /
for (k = 0, k <= i-1, k = k 1) tog = tog & &! tog [k];
end / / i kilpa
/ /
/ / Toggle TPĮ jei ne mažesnį bitų rinkinys (apima kodas wrap atveju)
/ /
jei (tog [SIZE-2: 0] == 0) Rengia [SIZE-1] = 1;
/ /
/ / Taikyti przełączać kaukė
/ /
gray_code <= gray_code ^ tog;
end / / įjungta
end / / nuoseklaus atnaujinimo
endmodule
***

Transleted į VHDL su bibliotekos papildymo ir SIZE = 4

***
biblioteka IEEE;
naudoti IEEE.std_logic_1164.all;
naudoti IEEE.std_logic_unsigned.all;
naudoti IEEE.std_logic_arith.all;

SUBJEKTAS gray_updown YRA
GENERIC (
DYDIS: integer: = 4);
UOSTO (
CLK: Į std_logic;
aclr: Į std_logic;
vienas: TAI std_logic;
Į viršų: Į std_logic;
gray_code: OUT std_logic_vector (SIZE - 1 DOWNTO 0));
Pabaiga SUBJEKTAS gray_updown;

ARCHITEKTŪRA išverstas iš gray_updown YRASIGNALINIAMS Rengia: std_logic_vector (SIZE - 1 DOWNTO 0);
SIGNALINIAMS i: integer;
SIGNALINIAMS j: integer;
SIGNALINIAMS k: integer;
SIGNALINIAMS gray_code_xhdl1: std_logic_vector (SIZE - 1 DOWNTO 0);

BEGIN
gray_code <= gray_code_xhdl1;

PROCESAS (CLK, aclr)
KINTAMO tog_xhdl2: std_logic_vector (SIZE - 1 DOWNTO 0);
BEGIN
IF (aclr ='0 ') THEN
gray_code_xhdl1 <= (Kita =>'0 ');
ELSIF (clk'EVENT IR CLK ='1 ') THEN
IP (vienas ='1 ') THEN
tog_xhdl2: = (Kita =>'0 ');
For i in 0 Į DYDIS - 1 LOOP
DĖL j I Į DYDIS - 1 LOOP
tog_xhdl2 (i): = tog_xhdl2 (i) XOR gray_code_xhdl1 (j);
END LOOP;
IF (iki ='1 ') THEN
tog_xhdl2 (i) = ne tog_xhdl2 (i);
END IF;
DĖL K 0 Į i - 1 LOOP
tog_xhdl2 (i): = tog_xhdl2 (i),
o ne tog_xhdl2 (k);
END LOOP;
END LOOP;
IF (tog_xhdl2 (SIZE - 2 DOWNTO 0) = "000000000000000000000) THEN
tog_xhdl2 (SIZE - 1): ='1 ';
END IF;
gray_code_xhdl1 <= gray_code_xhdl1 XOR tog_xhdl2;
END IF;
END IF;
Rengia <= tog_xhdl2;
Galutinio proceso;

Pabaiga ARCHITEKTŪRA verčiami;
***

VHDL -> Edif (Synplify Pro) -> Compiling, įrengimas, Simuliuoti (MAX PLUS II)

Fclk = 158 MHz (EPM3032ALC44-4)

It `s really work

<img src="http://www.edaboard.com/images/smiles/icon_cool.gif" alt="Vėsus" border="0" />
 
VHDL File
----------
Nuoroda: http://www.vhdl-online.de/model_lib_patras/vhdl_sources/counters/counters.htm

- ################################################ ############################
- # Projektas: Leonardo CBT-Branduolio #
- # #
- # Failo vardas: counters.vhd #
- # #
- # Komponentas: gudNlr: N bitų pilka aukštyn / žemyn skaitiklis #
- # Su sinchroninio apkrovos ir asinchroninius naujo #
- # #
- # Modelis: rtl #
- # #
- # Dailininkas S. Theoharis N.Zervas #
- # Institutas: VLSI Design Lab. Universiteto Patrai #
- # Data: 01/05/1999 #
- ################################################ ############################

biblioteka IEEE;
naudoti IEEE.std_logic_1164.all;
naudoti IEEE.std_logic_arith.ALL;
naudoti work.useful_functions.ALL;

- GudNlr subjektas Aprašymas
subjektas gudNlr yra
generic (N: INTEGER: = 8);
uostų (
DIN: į nepasirašytas (N-1 downto 0);
DOUT: iš nepasirašytas (N-1 downto 0);
CLK, DOWN, APKROVOS R, UP: į std_ulogic;
TEISMAS: iš std_ulogic
);
pabaigos gudNlr;

- GudNlr Architektūra Aprašymas
Architektūra rtl ir gudNlr yra
signalo istate: nepasirašytas (N-1 downto 0);
signalų skaičius: nepasirašytas (N downto 0);
signalo load_value: nepasirašytas (N-1 downto 0);
signalo binary_out: nepasirašytas (N downto 0);
pradėti
- Konvertuoti indėlį dvejetainius atstovavimas
Grey2Bin (DIN, load_value);
count <= ('0 '& istate) "01", kai ((UP ='1') ir (DOWN ='0 ')) kitur
('0 '& Istate) - "01", kai ((DOWN ='1') ir (UP ='0 ')) kitur
('0 '& Istate);

Count_Process: procesas (CLK R)
pradėti
if (R ='1 '), tada
- Naujo įvykio
istate <= (Kita =>'0 ');
elsif (CLK'event ir (CLK ='1 ') ir (CLK'last_value ='0')), tada
jei (APKROVOS ='1 '), tada
- Clocked apkrovos atveju
istate <= load_value;
elsif (UP ='1 ') arba (DOWN ='1'), tada
- Clocked skaičius aukštyn / žemyn atveju
istate <= count (N-1 downto 0);
end if;
end if;
galutinio proceso Count_Process;

- Konvertuoti indėlį dvejetainius atstovavimas
Bin2Grey (istate, binary_out);

- Susieti produkcijos vertės
DOUT <= binary_out (N-1 downto 0);
TEISINGUMO <='0 ', kai (DOWN ='0' ir UP ='0 ')
else "1", kai (DOWN ='1 'ir UP ='1')
dar ne skaičių (N), kai (DOWN ='1 'ir UP ='0')
kitas skaičius (N);
pabaigos rtl;

 
Labas,

I tyrimas FERI (http://www.feri.uni-mb.si/) elektroninių univirsity.

Man reikia sukurti kovos su PAL, kurie skaičiumi Gray kodas nuo 0 iki 9.Skaitiklis turi du inputes, krovinių skaičių (įvedimo APKROVOS) ir "start" arba "ON" (įvesties LT).Kai skaitiklis vyksta neleidžiama valstybės (9 15), skaitiklis turi būti atkurti.

Aš naudojate programą Abel ir aš imituoti programą su duomenimis *. jed ...

Aš šį: http://www.asic-world.com/examples/verilog/gray.html bet jo neveikia mano programa ...

I made a normaliai kovoti, bet nežinau, kaip jį odbudowujesz Gray kodas.Mano programa:

MODULIS Pereinamojo nacionalinė taryba
pavadinimas "stevec Horizontaliai / dol"
D3 .. d0, Valio, RST, cnten, ld, u_d pin;
D = [D3, D2, D1, d0];
Q3 .. Q0 pin istype'reg ";

Q = [Q3, Q2, Q1, Q0];
X =. X.;
MODE = [cnten, ld, u_d, RST];
APKROVOS = (MODE == [X 1, x, x]);
HOLD = (MODE == [0,0, X, 0]);
UP = (MODE == [1,0,1,0]);
PŪKAI = (MODE == [1,0,0,0]);
RESET = (MODE == [X 0, X 1]);
lygtis
Q.clk = Valio;
KADA (APKROVOS) THEN (KADA (D> 9) THEN K: = 9 ELSE B: = D;)
DAR KADA (HOLD) THEN K: = K;
DAR KADA (UP) THEN (KADA (Q == 9) THEN K: = 0;
ELSE B: = (K 1);)
DAR KADA (DOWN) THEN (KADA (Q == 0) THEN K: = 9;
ELSE B: = (K-1);)
DAR KADA (RESET) THEN K: = 0;

TEST_VECTORS
([u_d, RST, ld, cnten, Valio, D3, D2
, D1, d0] -> [Q3, Q2, Q1, Q0])
[X 0,1, X,. C., 0,1,1,1] -> [0,1,1,1]; / / nalo aš 7
[1,0,0,1. C., X X X X] -> [1,0,0,0]; / / tej GOR 7NA 8
[1,0,0,1. C., X X X X] -> [1,0,0,1]; / / tej GOR 8NA 9
[1,0,0,1. C., X X X X] -> [0,0,0,0]; / / tej GOR 9NA 0
[1,0,0,1. C., X X X X] -> [0,0,0,1]; / / tej GOR 0NA 1
[X 1,0, X,. C., X X X X] -> [0,0,0,0]; / / RESET
[X 0,1, X,. C., 1,1,1,1] -> [1,0,0,1]; / / nalo aš 15 spremeni V 9
[X 0,1, X,. C., 0,1,1,0] -> [0,1,1,0]; / / nalo I 6
[0,0,0,1. C., X X X X] -> [0,1,0,1]; / / tej Dol IŠ 6
N. 5
[X 0,1, X,. C., 0,0,0,0] -> [0,0,0,0]; / / nalo I 0
[0,0,0,1. C., X X X X] -> [1,0,0,1]; / / tej Dol IŠ 0 NS 9
[X 0,0,0,. C., X X X X] -> [1,0,0,1]; / / HOLD
PABAIGA

* stevec Horizontaliai / dol = skaitiklis aukštyn / žemyn
* Tej GOR 7 į 8 = skaičiuoti nuo 7 iki 8
* Tej DOL IŠ 6 į 5 = skaičiuoti nuo 6 iki 5

Aš tiesiog reikia kovoti į Gray ir tik skaičiavimo viršų ...Dėkojame už pagalbą!

Simonas

 
Nėra VHDL kodą čia - o tai suteiks jums principą.
I dalis:
http://asicdigitaldesign.wordpress.com/2007/05/10/counting-in-gray/

II dalis:
http://asicdigitaldesign.wordpress.com/2007/05/13/counting-in-gray-part-ii-observations/

III dalis:
http://asicdigitaldesign.wordpress.com/2007/05/14/counting-in-gray-part-iii-putting-everything-together/

hope this helps:

ŠD.
http://asicdigitaldesign.wordpress.com/

 

Welcome to EDABoard.com

Sponsor

Back
Top