op / ned grå counter

[heastone]

Hvordan kan jeg gennemføre den op / ned grå disken af VHDL?
undtagen binær counter med grå counnter

 

[Black Jack]

Se dette (i Verilog, kan du konvertere til VHDL med X-HDL):
http://klabs.org/richcontent/software_content/ip/ip.htm

Du kan bruge State Machine fremgangsmåde, hvis counter bredde er lille

 

[Black Jack]

Verilog-fil fra:
http://klabs.org/richcontent/software_content/ip/dane/gray_updown.v

***
`tidshorisont 1ns/100ps
modul gray_updown (CLK, aclr, ena, op, gray_code);
parameter SIZE = 22;
input CLK, aclr, ena, op;
output [SIZE-1: 0] gray_code;
reg [SIZE-1: 0] gray_code, tog;
heltal i, j, k;
altid @ (posedge CLK eller negedge aclr)
if (aclr == 1'b0) begynder
gray_code <= 0;
ende
ellers begynder / / sekventiel update
if (ena == 1'b1) begynder / / aktiveret
sm = 0;
for (i = 0; i <= SIZE-1; i = i 1) begynder / / i loop
/ /
/ / Toggle bit, hvis antallet af bits, der i [SIZE-1: I] er endnu
/ / XNOR aktuelle smule op til MSB smule for tælle op, og
/ / XOR for Count Down
/ /
for (j = i j <= SIZE-1, j = j 1) sm = sm ^ gray_code [j];
if (op == 1'b1) tog =! tog ;
/ /
/ / Disable sm , hvis en lavere bit er at skifte
/ /
for (k = 0; k <= i-1, k = k 1) sm = sm & &! sm [k];
ende / / i loop
/ /
/ / Slå MSB hvis ingen nedre bits (dækker kode wrap-sagen)
/ /
if (tog [SIZE-2: 0] == 0) tog [SIZE-1] = 1;
/ /
/ / Anvend skifte maske
/ /
gray_code <= gray_code ^ tog;
ende / / aktiveret
ende / / sekventiel update
endmodule
***

Transleted til VHDL med biblioteket at tilføje og size = 4

***
library IEEE;
brug IEEE.std_logic_1164.all;
brug IEEE.std_logic_unsigned.all;
brug IEEE.std_logic_arith.all;

ENTITY gray_updown IS
Generic (
STØRRELSE: integer: = 4);
PORT (
CLK: IN std_logic;
aclr: IN std_logic;
ena: IN std_logic;
op: IN std_logic;
gray_code: OUT std_logic_vector (Size - 1 downto 0));
SLUT ENTITY gray_updown;

ARKITEKTUR oversat AF gray_updown ISSIGNAL tog: std_logic_vector (Size - 1 downto 0);
SIGNAL i: integer;
SIGNAL j: integer;
SIGNAL k: integer;
SIGNAL gray_code_xhdl1: std_logic_vector (Size - 1 downto 0);

BEGIN
gray_code <= gray_code_xhdl1;

PROCESS (CLK, aclr)
VARIABLE tog_xhdl2: std_logic_vector (Size - 1 downto 0);
BEGIN
HVIS (aclr = '0 ') THEN
gray_code_xhdl1 <= (OTHERS => '0 ');
Elsif (clk'EVENT og CLK = '1 ') THEN
HVIS (ena = '1 ') THEN
tog_xhdl2: = (OTHERS => '0 ');
For i in 0 størrelse - 1 LOOP
For j I i størrelse - 1 LOOP
tog_xhdl2 (i): = tog_xhdl2 (i) XOR gray_code_xhdl1 (j);
END LOOP;
HVIS (op = '1 ') THEN
tog_xhdl2 (i): = IKKE tog_xhdl2 (i);
END IF;
For k i 0 til i - 1 LOOP
tog_xhdl2 (i): = tog_xhdl2 (I) og ikke 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;
sm <= tog_xhdl2;
END PROCESS;

SLUT ARKITEKTUR oversat;
***

VHDL -> Edif (Synplify Pro) -> Compiling, Fitting, Simuler (MAX PLUS II)

Fclk = 158 MHz (EPM3032ALC44-4)

It `s really work

<img src="http://www.edaboard.com/images/smiles/icon_cool.gif" alt="Kølig" border="0" />

 

[Vonn]

VHDL File
----------
Ref: http://www.vhdl-online.de/model_lib_patras/vhdl_sources/counters/counters.htm

- ################################################ ############################
- # Projekt: Leonardo CBT-kerne #
- # #
- # Filnavn: counters.vhd #
- # #
- # Component: gudNlr: N-bit grå op / ned counter #
- # Med synkrone belastning og asynkron reset #
- # #
- # Model: RTL #
- # #
- # Designer: S. Theoharis, N.Zervas #
- # Institute: VLSI Design Lab., University of Patras #
- # Dato: 01.05.1999 #
- ################################################ ############################

library IEEE;
brug IEEE.std_logic_1164.all;
brug IEEE.std_logic_arith.ALL;
brug work.useful_functions.ALL;

- GudNlr enhed Beskrivelse
enhed gudNlr er
generisk (N: INTEGER: = 8);
port (
DIN: i unsigned (N-1 downto 0);
DOUT: out unsigned (N-1 downto 0);
CLK, NED, LOAD, R, UP: i std_ulogic;
RET: out std_ulogic
);
ende gudNlr;

- GudNlr Arkitektur Beskrivelse
arkitektur RTL af gudNlr er
signal istate: unsigned (N-1 downto 0);
signal count: unsigned (N downto 0);
signal load_value: unsigned (N-1 downto 0);
signal binary_out: unsigned (N downto 0);
begynd
- Konverter input til binær repræsentation
Grey2Bin (DIN, load_value);
count <= ('0 '& istate) "01", når ((OP = '1') og (NED = '0 ')) else
('0 '& Istate) - "01", når ((NED = '1') og (UP = '0 ')) else
('0 '& Istate);

Count_Process: proces (CLK, R)
begynd
if (R = '1 ') then
- Reset begivenhed
istate <= (OTHERS => '0 ');
elsif (CLK'event og (CLK = '1 ') og (CLK'last_value = '0')) then
if (LOAD = '1 ') then
- Stueur indlæse begivenhed
istate <= load_value;
elsif (OP = '1 ') eller (NED = '1') then
- Clocket tælle op / ned begivenhed
istate <= count (N-1 downto 0);
end if;
end if;
ende proces Count_Process;

- Konverter input til binær repræsentation
Bin2Grey (istate, binary_out);

- Tildel output værdier
DOUT <= binary_out (N-1 downto 0);
RET <= '0 ', når (NED = '0' og OP = '0 ')
else '1 ', når (NED = '1' og OP = '1 ')
else ikke regne (N), når (NED = '1 'og OP = '0')
else count (N);
ende RTL;

 

[omahens]

Hej,

Jeg studerer på Feri (http://www.feri.uni-mb.si/) elektroniske univirsity.

Jeg skal bygge en tæller med PAL, der vil tælle i Gray kode fra 0 til 9.Counter skal have to inputes, indlæse tal (input belastning) og "start" eller "ON" (input EN).Når tælleren går i ikke tilladt tilstand (9 til 15), skal tællernulstilling.

Jeg bruger et program Abel og jeg simulere programmet med jed data *. ...

Jeg fandt dette: http://www.asic-world.com/examples/verilog/gray.html men hans arbejder ikke i mit program ...

Jeg lavede en normal tæller, men jeg ved ikke, hvordan man kan bygge det i Gray-kode.Mit program:

MODUL CNT
title 'stevec gor / dol «
D3 .. D0, URA, 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];
BELASTNING = (MODE == [X, 1, X, X]);
HOLD = (mode == [0,0, X, 0]);
OP = (MODE == [1,0,1,0]);
NED = (MODE == [1,0,0,0]);
RESET = (MODE == [X, 0, X, 1]);
ligninger
Q.clk = URA;
NÅR (belastning) THEN (NÅR (D> 9) THEN Q: = 9 ELSE Q: = D
ELSE NÅR (HOLD) THEN Q: = Q;
ELSE NÅR (UP) THEN (NÅR (Q == 9) THEN Q: = 0;
ELSE Q: = (Q 1)
ELSE NÅR (NED) THEN (NÅR (Q == 0) THEN Q: = 9;
ELSE Q: = (Q-1)
ELSE NÅR (RESET) THEN Q: = 0;

TEST_VECTORS
([u_d, RST, LD, cnten, URA, D3, D2
, D1, D0] -> [Q3, Q2, Q1, Q0])
[X, 0,1, X,. C., 0,1,1,1] -> [0,1,1,1]; / / NALO I 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 I 15 I 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 IZ 6 NA 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 IZ 0 NA 9
[X, 0,0,0,. C., X, X, X, X] -> [1,0,0,1]; / / HOLD
SLUT

* stevec gor / dol = counter op / ned
* Tej GOR 7 na 8 = tælle op fra 7 til 8
* Tej DOL IZ 6 na 5 = tælle ned fra 6 til 5

Jeg skal bare skranken i Gray og kun for at tælle op ...Tak for din hjælp!

Simon

 

[NIR Dahan]

Der er ingen VHDL-kode her - men det vil give dig det princip.
del I:
http://asicdigitaldesign.wordpress.com/2007/05/10/counting-in-gray/

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

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

håber det hjælper:

ND.
http://asicdigitaldesign.wordpress.com/