Ich habe diesen Frequenzteiler in VHDL programmiert, er funktioniert jedoch nicht. Hat jemand eine Idee was da falsch sein könnte. Ich kann mir nicht erklären was da nicht hinhaut da es ein recht einfaches Programm ist. Danke im voraus. mfg Gerhard ##################################################################### -- clk_Teiler.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_arith.all; use IEEE.std_logic_unsigned.all; entity Teiler is port( sysclk,enable: in std_logic; ds: in std_logic_vector(4 downto 0); clk: out std_logic); end Teiler; architecture strg of Teiler is signal clkDiv: std_logic_vector(5 downto 0):=(others=>'0'); signal clkTemp: std_logic:= '0'; signal LowOrHigh: std_logic:= '0'; begin Process (sysclk,enable,ds) begin if (enable='1') then clkDiv<= "111111"; elsif (sysclk='1' and sysclk'Event) then clkDiv<=clkDiv-'1'; end if; if (clkDiv="000000") then clkTemp<= LowOrHigh; clkDiv <= (others=>'1'); clkDiv(5)<=ds(4); clkDiv(4)<=ds(3); clkDiv(3)<=ds(2); clkDiv(2)<=ds(1); clkDiv(1)<=ds(0); if (LowOrHigh='0')then LowOrHigh<='1'; else LowOrHigh<='0'; end if; end if; end Process; clk<=clkTemp; end strg; ####################################################################
Hab mein Programm nun überarbeitet weil ich mir überlegt hab das vl die anderen if`s alle synchron laufen müssen. Funktioniert aber immer noch nicht. ################################################################### -- clk_Teiler.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_arith.all; use IEEE.std_logic_unsigned.all; entity Teiler is port( sysclk,enable: in std_logic; ds: in std_logic_vector(4 downto 0); -- Switches clk: out std_logic); end Teiler; architecture strg of Teiler is signal clkDiv: std_logic_vector(5 downto 0):=(others=>'0'); signal clkTemp: std_logic:= '0'; signal LowOrHigh: std_logic:= '0'; begin Process (sysclk,enable,ds) begin if (sysclk='1' and sysclk'Event) then clkDiv<=clkDiv-'1'; if (enable='1') then clkDiv<= "000011"; clkTemp<='0'; LowOrHigh<='1'; elsif (clkDiv="000000") then clkTemp<= LowOrHigh; clkDiv <= (others=>'1'); clkDiv(5)<=ds(4); clkDiv(4)<=ds(3); clkDiv(3)<=ds(2); clkDiv(2)<=ds(1); clkDiv(1)<=ds(0); if (LowOrHigh='0')then LowOrHigh<='1'; else LowOrHigh<='0'; end if; end if; end if; end Process; clk<=clkTemp; end strg; #######################################################################
Mit der ersten Variante baust du dir einen kombinatorischen schwanzbeisser. Dein enable ist in wirklichkeit ein reset! Was funktioniert denn nicht? Ich hoffe du benutzt das Konstrukt nicht um interne logik zu takten! Taktung FPGA/CPLD Du koenntest das ganze ein wenig ueberischtlicher schreiben:
1 | process(sysclk) |
2 | begin
|
3 | if rising_edge(sysclk) then |
4 | if enable = '1' then |
5 | clkDiv <= (others=>'1'); |
6 | elseif clkDiv /= 0 then |
7 | clkDiv <= clkDiv - 1; |
8 | else
|
9 | clkTemp <= not clkTemp; |
10 | clkDiv <= ds & "1"; |
11 | end if; |
12 | end if; |
13 | end process; |
Cheers, Roger
Zunächst einmal: Man benutzt NICHT die std_logic_arith und std_logic_unsigned. Anstelle derer benutzt man die numeric_std. Das Zweite: was geht denn nicht? Was macht Dein Design? Das Dritte: in einem getakteten Prozess gehört nur der Takt und evtl. ein asynchroner Reset in die Sensitivitätsliste.
Dies "clkDiv <= (others=>'1');" widerspricht doch dem hier, oder nicht ? clkDiv(5)<=ds(4); clkDiv(4)<=ds(3); ... clkDiv(1)<=ds(0);
Also wenn ich die numeric_std anstelle der arith und der unsigned benutze funktionierts gar nicht mehr. Bei der 2 Variante lässt es sich durchsimulieren. Man sieht jedoch ein undefieniertes Signal für clk, ausser enable ist High. (Enable soll quasi auch ein reset sein) Was heißt interne logik zu takten???? Danke für eure antworten.
Man kann auch nicht einfach die Bibliotheken austauschen und denken das es dann geht. Du musst Dein Design auch entsprechend umstellen. "Interne Logik takten" bedeutet das Du das clk-signal an andere Module als Takt anschließt. Das macht man nämlich nicht bei FPGA-Designs, sondern verwendet einen ClockEnable. Zieh das clkTemp<= LowOrHigh; mal vor das if.
nein ich takte nur diesen einen Process damit, also hab ich da schon mal kein probolem. Aber wenn ich clkTemp<= LowOrHigh; vor das if ziehe ändert sich auch nichts. obwohl doch wenn man logisch überlegt das funk. müsste.
Noch ein Versuch: schreibe mal
1 | LowOrHigh<='0'; |
2 | if (LowOrHigh='0')then |
3 | LowOrHigh<='1'; |
4 | end if; |
was benutzt du zur Simulation, und wie sehen die Eingangsignale aus? Zeige doch mal dein Testbench.
1 | LowOrHigh<='0'; |
2 | if (LowOrHigh='0')then |
3 | LowOrHigh<='1'; |
4 | end if; |
ein simples not wird ja wohl reichen
Gerade getestet... Funzt mit dem ändern des if(LowOrHigh.. Teils.. @Roger: wenn er es korrekt initialisiert reicht ein not... ;)
welche library würde man für ein not benötigen. Bei mir funk. das not nämlich nicht.
Das not ist in der std_logic_1164 definiert.. Sollte also gehen... Was sagt Dir der Compiler?
hab es jetzt über eine andere mögl. versucht die ich hier im forum gefunden habe. --> funktioniert aber auch nicht.
1 | -- Teiler.vhd
|
2 | |
3 | |
4 | |
5 | library IEEE; |
6 | use IEEE.std_logic_1164.all; |
7 | use IEEE.std_logic_arith.all; |
8 | use IEEE.std_logic_unsigned.all; |
9 | use IEEE.numeric_std.all; |
10 | |
11 | |
12 | entity Teiler is |
13 | port( sysclk,enable: in std_logic; |
14 | ds: in std_logic_vector(4 downto 0); -- Switches |
15 | clk: out std_logic); |
16 | end Teiler; |
17 | |
18 | |
19 | architecture strg of Teiler is |
20 | signal clkDiv: std_logic_vector(31 downto 0) := (others=>'0'); |
21 | |
22 | begin
|
23 | |
24 | Process (sysclk,enable,ds) |
25 | begin
|
26 | if (enable='1') then |
27 | clkDiv <= "00000000000000000000000000000000"; |
28 | elsif(sysclk='1' and sysclk'event) then |
29 | clkDiv <=clkDiv + '1'; |
30 | end if; |
31 | |
32 | |
33 | |
34 | case ds is |
35 | when "00000" => clk <= clkDiv(0); |
36 | when "00001" => clk <= clkDiv(1); |
37 | when "00010" => clk <= clkDiv(2); |
38 | when "00011" => clk <= clkDiv(3); |
39 | when "00100" => clk <= clkDiv(4); |
40 | when "00101" => clk <= clkDiv(5); |
41 | when "00110" => clk <= clkDiv(6); |
42 | when "00111" => clk <= clkDiv(7); |
43 | when "01000" => clk <= clkDiv(8); |
44 | when "01001" => clk <= clkDiv(9); |
45 | when "01010" => clk <= clkDiv(10); |
46 | when "01011" => clk <= clkDiv(11); |
47 | when "01100" => clk <= clkDiv(12); |
48 | when "01101" => clk <= clkDiv(13); |
49 | when "01110" => clk <= clkDiv(14); |
50 | when "01111" => clk <= clkDiv(15); |
51 | when "10000" => clk <= clkDiv(16); |
52 | when "10001" => clk <= clkDiv(17); |
53 | when "10010" => clk <= clkDiv(18); |
54 | when "10011" => clk <= clkDiv(19); |
55 | when "10100" => clk <= clkDiv(20); |
56 | when "10101" => clk <= clkDiv(21); |
57 | when "10110" => clk <= clkDiv(22); |
58 | when "10111" => clk <= clkDiv(23); |
59 | when "11000" => clk <= clkDiv(24); |
60 | when "11001" => clk <= clkDiv(25); |
61 | when "11010" => clk <= clkDiv(26); |
62 | when "11011" => clk <= clkDiv(27); |
63 | when "11100" => clk <= clkDiv(28); |
64 | when "11101" => clk <= clkDiv(29); |
65 | when "11110" => clk <= clkDiv(30); |
66 | when "11111" => clk <= clkDiv(31); |
67 | end case; |
68 | |
69 | end Process; |
70 | |
71 | end strg; |
die Variante teilt anders (in 2^n Schritten) als deine und scheint einem Schriftsteller entsprungen zu sein. Ich Staune immer wieder ueber die Ausdauer die manche Leute an den Tag legen. Diese wie auch deine zweite Variante sollte funktionieren, das Problem liegt bei dir. Du hast immer noch nicht erwaehnt welches Tool du zur Simulation einsetzt, es scheint ein Konfigurationsproblem zu sein. Cheers, Roger
@Gerhard: Wie stellst Du den fest, dass Dein Teiler nicht geht? Hast Du eine Testbench? Rick
ja hab ich. und für den clock wird immer nur 'x' angezeigt. ausser Enable = high dan funktsionirts.
Ok. Dann pack doch mal dein Modul und die Testbench in eine zip-Datei und stelle die hier ein. Rick
Dein VHDL Code ist nicht korrekt, weil Du 2 verschiedene Sachen in einen gemeinsamen Prozess steckst. Du mußt die Dinge trennen. Zuerst hast Du einen synchronen Teil, mit if (enable='1') then clkDiv <= "00000000000000000000000000000000"; elsif(sysclk='1' and sysclk'event) then clkDiv <=clkDiv + '1'; end if; Das ist ein synchroner Zähler, mit enable als Reset und sysclk als Takt. So ein Prozess benötigt nur enable und sysclk in der sensitivity list. Dann hast Du die case Anweisung, die außerhalb des elsif(sysclk='1' and sysclk'event) steht. Dies ergibt eine kombinatorische Logik für das clk Ausgangssignal, etwas das schon vom Prinzip her sehr, sehr ungünstig ist. Wenn man schon so ein Taktsignal erzeugt, dann sollte man es wenigstens vom schnellen Takt abtakten lassen. Der kombinatorische Teil hängt von den Signalen ds und clkDiv ab. Deshalb gehört das case in einen separaten Prozess mit diesen Signalen in der sensitivity list. Besser wäre es, das case in den elsif(sysclk='1' and sysclk'event) then .... end if; Zweig hineinzunehmen. Dann arbeitet der Frequenzteiler komplett synchron und es gehören nur enable und sysclk in die sensitivity list
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.