Ungerade Frequenzteiler

Was ist an f/3 (ungerade) schwieriger als bei f/6 (gerade)?

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.

-- 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.

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.