Hallo Alle! ich will ein Fre.Teiler in vhdl programmieren.Aber er muss mit ungeraden zahlen arbeiten Z.B:F/1,F/3,F/5.... Eine gerade frequenzteiler kann ich schon programmiern. Für jede Hinweis bin ich sehr Dankbar. Gruß,
:
Gesperrt durch Moderator
ja gut! bei gerade frequenzteiler ist einfach ein counter der inkrementiert wird.aber bei einem ungeraden frequenzteiler,ich weiss net wie kann man so was programmieren.ich bin noch neuling in vhdl Welt
Hallo nimm einfach einen Synchrodzähler 74'163. Vom Ausgang RCO mit einem Inverter auf Load. Beim Ladeeingang kannst Du jedes Teilerverhältnis einstellen. z.B. Ladewert 11 Der Zähler zählt dann 11, 12. 13. 14, 15, 11, 12, .... Also ist das ein Teiler 1:5 Gruß Franz
> bei gerade frequenzteiler ist einfach ein counter der inkrementiert > wird. Bei einem ungeraden genauso: Entweder du lässt den Zähler bis zu einer vorgegebenen Grenze hoch- oder von dieser Grenze bis 0 herunterzählen. Ob diese Grenze eine gerade oder eine ungerade Zahl ist, ist doch der VHDL und dem FPGA egal.
yalu wrote: >> bei gerade frequenzteiler ist einfach ein counter der inkrementiert >> wird. > > Bei einem ungeraden genauso: Entweder du lässt den Zähler bis zu einer > vorgegebenen Grenze hoch- oder von dieser Grenze bis 0 herunterzählen. > Ob diese Grenze eine gerade oder eine ungerade Zahl ist, ist doch der > VHDL und dem FPGA egal. Bei ungeraden Verhältnissen bekommst du so aber kein symmetrisches Rechteck, weil du z.B. bei einem Teiler durch 3 nach 1.5 Taktzyklen wechseln müsstest. Mit einem kleinen Trick geht's trotzdem: Beitrag "Re: Frequenzteiler durch gerade Zahlen"
-- Die nachfolgenden Zeilen realisieren einen Frequenzteiler. -- Das clock-Signal wird durch einen beliebigen ungeraden Faktor geteilt. -- Während gerade Teilerverhältnisse sich einfach realisieren lassen, -- können ungerade Teilerverhältnisse nur durch einen Trick realisiert werden. -- Da Flip-Flops nur auf eine Taktflanke reagieren können, kann cout nicht -- direkt mit einem Flip-Flop, das mit clock getaktet wird, erzeugt werden. -- Es sind daher zwei Signale notwendig aus denen das Ausgangssignal abgeleitet wird. library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity frequenzteiler is generic (teiler : integer := 5); port (clock : in std_logic; reset : in std_logic; enable : in std_logic; cout : out std_logic ); end frequenzteiler; architecture frequenzteiler_rtl of frequenzteiler is signal positive_counter : natural range 0 to (teiler-1); signal negative_counter : natural range 0 to (teiler-1); signal hilf1 : bit; signal hilf2 : bit; begin -- Zählt die positiven Taktflanken process (clock, reset) begin if (reset = '1') then positive_counter <= 0; elsif (rising_edge(clock)) then if positive_counter < (teiler-1) then positive_counter <= positive_counter + 1; else positive_counter <= 0; end if; end if; end process; -- Zählt die negativen Taktflanken process (clock, reset) begin if (reset = '1') then negative_counter <= 0; elsif (falling_edge(clock)) then if negative_counter < (teiler-1) then negative_counter <= negative_counter + 1; else negative_counter <= 0; end if; end if; end process; -- Generisches ungerades Teilerverhältnis hilf1 <= '1' when (negative_counter < ((teiler-1)/2)) else '0'; hilf2 <= '1' when (positive_counter < ((teiler-1)/2)) else '0'; cout <= '1' when ((hilf1 = '1') or (hilf2 = '1')) else '0'; end frequenzteiler_rtl; Programmiert mit ISE Webpack 10.1. Simuliert mit dem ISE Simulator. Einziges Manko: ISE meckert noch da bisher das Enable-Signal nicht verwendet wurde.
ich hab mal sowas ähnliches in der art programmiert aber mit einem etwas anderen ansatz. library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity Modulo_M is Port ( clk_in : in STD_LOGIC; RST : in STD_LOGIC; L : out STD_LOGIC; N : in STD_LOGIC_VECTOR(9 downto 0)); end Modulo_M; architecture Behavioral of Modulo_M is signal m : std_logic_vector (10 downto 0) := "01111111111"; signal n_int : std_logic_vector (9 downto 0) := "0000000000"; signal n_m : std_logic_vector (10 downto 0) := "00000000000"; signal akku : std_logic_vector (11 downto 0) := "011111111110"; signal L_int : std_logic; begin n_int(9 downto 0) <= N; n_m <= m - n_int; L <= L_int; process(clk_in, RST) is begin if RST = '0' then akku <= "011111111110"; L_int <= '0'; else if rising_edge(clk_in) then if akku > "011111111110" then L_int <= '1'; akku <= akku - n_m; else L_int <= '0'; akku <= akku + n_int; end if; end if; end if; end process; end Behavioral; m - stellt einen vordefinierten grenzwert ein, ähnlich der auflösung n - der von aussen übergeben wird beschreibt die schrittweite innhalb der rechnung l - ist dann der ungerade geteilte clock n_m - ist der interne stellwert, wenn der akku übergelaufen ist, also einen definierten grenzwert überschritten hat hat eigentlich ganz gut funktioniert das teil. die berechnung basiert auf der Modulo-arithmetik daher auch die namensgebung. achtung, der clock is natürlich unsymmetrisch. muss man dann selber beurteilen, ob das in der eigenen anwendung kritische auswirkungen hat.
Es gibt auch ein kurzes aber nicht uninteressantes Xilinx Paper, einfach mal nach "Xilinx unusual clock dividers" suchen.
Vorgehensweise: Sei 2m-1 die bekannte, ungerade Zahl. Nimm einen Frequenzteiler 2m:1 und ein XOR-Gatter. Das Ausgangssignal des Frequenzteilers sollte einen Duty-Cycle zwischen 30% und 70% haben. Beschalte die beiden Eingänge und den Ausgang des XOR-Gatters: Eingang1 = zu teilende Takt-Frequenz Eingang2 = Ausgang des 2m:1-Teilers Ausgang = Takt-Eingang des 2m:1-Teilers. Das Ausgangssignal des 2m:1-Teilers wird zum Gesamt-Ausgangssignal. Funktionsweise: Nach einer aktiven Flanke des Taktsignals am 2m:1-Teiler (also nach etwa m Takten) kippt das Ausgangssignal in den entgegengesetzten Zustand. Dieses Kippen wird über das XOR-Gatter auf den Takteingang rückgekoppelt und erzeugt eine inaktive Flanke - die verändert nichts am Zustand. Die nächste Flanke am Takteingang wäre eigentlich eine inaktive Flanke gewesen, sie wird aber durch die Invertierung durch das XOR-Gatter zu einer aktive Flanke. Und weitere etwa m Takte später passiert das Ganze noch einmal. Unterm Strich bleibt also, dass durch das XOR-Gatter dem Eingangs-Signal pro 2m-1 Takte 2 Taktflanken (= 1 Takt) hinzugefügt werden. Der 2m:1-Teiler "sieht" also 2m Takte, obwohl am Eingang nur 2m-1 Takte angekommen sind. ...und ausserdem verbessert sich der Duty-Cycle in Richtung auf 50%.
Wenn ich das rauchige hier drüber lese, dann verstehe ich viele designs, die mir täglich begegnen. Das kann man in PLDs machen. In FPGAs braucht man richtige Takte aus PLLs und nicht aus Logik.
VHDL-Polizei schrieb im Beitrag #4479395: > Wenn ich das rauchige hier drüber lese, Hast Du auch gelesen,das der Thread seit fast 8 Jahren tot ist?