Drehrichtungserkennung

[Jack D. (jack99)]

Guten Abend,

Teil eines Schulprojektes ist es, mittels VHDL und anschließendem upload 
auf das Spartan 3A Board, ein Lauflicht mithilfe der LED0-LED7 so zu 
generieren, es via Rotary Knob punktuell hoch und runter läuft. Mit 
Betätigung des Psuh-Button wechselt das Lauflicht vom Punkt- zum 
Balkenverlauf (der South-Button dient als Reset). Der Code steht soweit 
und lässt sich auch erfolgereich benchen. Jedoch gestaltet es sich nach 
dem Upload auf's Board etwas komplizierter.

Um das Problem nachvollziehen zu können, hab ich es aufgenommen, es ist 
hier zu sehen: https://workupload.com/file/7j2zG2s

Zu sehen ist also eine leuchtende LED die mit der Rotation des Rotary 
Knob ihre Position nicht zu wechseln scheint. Hingegen funktioniert der 
Wechsel zwischen Punkt- und Balkenbetrieb und die Reset-Funktion, wie zu 
sehen ist.

Dreht man den Rotary Knob lang genug in eine Richtung (schnell oder 
langsam spielt hierbei keine Rolle) so wandert das Licht doch in die 
gewünschte Richtung, was meines erachtens für ein Clock Problem spricht.

Folgenden der Quellcode (wenn auch nicht ganz übersichtlich) zum 
besseren Verstädnis:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.numeric_std.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;


entity taster_flanken_binaer_new is

Port (     a : in  STD_LOGIC;
        b : in  STD_LOGIC;
        pb: in std_logic;
           clk : in  STD_LOGIC;
           reset : in  STD_LOGIC;          
        Ton : out  STD_LOGIC:='0';
      Led : out STD_LOGIC_VECTOR(7 downto 0));
        ----SIMULATIONSZWECKE-----
    --   stateb : out std_logic_vector (3 downto 0);
      --  a_out : inout  STD_LOGIC:='0';
      -- a_up: inout std_logic:='0';
      -- b_down:inout std_logic:='0';
      
           --zaehl : out  STD_LOGIC_VECTOR (3 downto 0):="0000"); --Ausgang Zähler 4 bit        
end taster_flanken_binaer_new;

architecture Behavioral of taster_flanken_binaer_new is
signal a_out:std_logic:='0';
signal a_up:std_logic:='0';
signal b_down:std_logic:='0';


---------------A--------------------
type zustanda is(za1,za2,za3,za4); --Deklarierung der Zustände
  signal zalta, zneua: zustanda;
  signal takt10hza: std_logic:='0';
  signal t10hza:std_logic:='0';
  signal ausgabe: std_logic:='0';  
  constant t10hz_a :integer:=5000000;         --Setzte Zähler auf wert für 100 ms  
  signal counta : integer range 0 to t10hz_a :=0; --setzte Zähler Anfang auf 0
  signal clkout: std_logic:='0';  --Setze Ausgangssignal auf 0
  signal freigabetimer : std_logic:='0'; --Setzte freigabe auf 0
  signal t10hzab : std_logic:='0';
  signal impulsa:std_logic:='0';
  signal qint: std_logic_vector(3 downto 0):="0000";
  signal za:std_logic:='0';
  signal xa:std_logic:='0';
  
--------------B------------------  
type zustandb is(zb1,zb2,zb3,zb4); --Deklarierung der Zustände
  constant t10hzb :integer:=5000000;         --Setzte Zähler auf wert für 100 ms  
  signal zaltb, zneub : zustandb;
  signal ausgabeb: std_logic:='0';
  signal countb : integer range 0 to t10hzb :=0; --setzte Zähler Anfang auf 0
  signal clkoutb: std_logic:='0';  --Setze Ausgangssignal auf 0
  signal freigabetimerb : std_logic:='0'; --Setzte freigabe auf 0
  signal takt10hzb : std_logic;
  signal b_out: std_logic;
  signal state: std_logic_vector (3 downto 0);
  signal impulsb: std_logic:='0';
  signal t10hzb1: std_logic:='0';  


-------FLANKENERKENNUNG-----------  
  type ZUSTAENDE_fl is (A_fl, B_fl, C_fl);
signal ZUSTAND_fl, FOLGEZUSTAND_fl: ZUSTAENDE_fl;

type ZUSTAENDE_fl_b is (A_fl_b, B_fl_b, C_fl_b);
signal ZUSTAND_fl_b, FOLGEZUSTAND_fl_b: ZUSTAENDE_fl_b;

--PB
  type zustand is(z1,z2,z3,z4,z5,z6,z7,z8); --Deklarierung der Zustände
  constant t10hz:integer:=25000000;         --Setzte Zähler auf wert für 500 ms  
  signal zalt, zneu: zustand;
  signal ausgabe1: std_logic:='0'; --Signale werden auf 0 gesetzt
  signal ausgabe2: std_logic:='0';
  signal ausgabe3: std_logic:='0';
  signal ausgabe4: std_logic:='0';  
  signal count : integer range 0 to t10hz :=0; --setzte Zähler Anfang auf 0
  signal clkoutpb: std_logic:='0';  --Setze Ausgangssignal auf 0  
  signal takt10hzpb : std_logic;
  signal PB_Balken :  STD_LOGIC:='0';
  signal TonF1K: std_logic;
  signal TonF05K: std_logic;
  signal blabla: std_logic_vector (3 downto 0);
  signal impulspb: std_logic:='0';
  signal t10hzpb1: std_logic:='0';
  
  
  
  --ERZEUGUN TON
  signal c : integer range 0 to 99999 := 0;  -- 500 Hz 
  signal d : integer range 0 to 49999 := 0;  -- 1000 Hz 
  signal x : std_logic := '0'; 
  signal y : std_logic := '0'; 
  signal Ton1000 : std_logic;
  signal Ton0500  : std_logic;



begin

takta:process (clk,freigabetimer) 
    begin    
if reset='1' then counta<=0;    
   elsif freigabetimer='1'  then    
            if (rising_edge(clk))then        --wenn steigene Flange von Clock dann zählen
                    if(counta < t10hz_a) then          --vergleiche zähler mit maximalen wert
                                  counta <= counta+1;          --addiere 1 auf zähler
                                  elsif counta=t10hz_a then
                                  clkout <= not clkout;            
                                  counta <=0;  
                    end if;
            end if;
end if;
  end process takta;
  
  process (takt10hza,impulsa) 
  begin  
  if impulsa='1' then t10hza<='0';
  elsif falling_edge (takt10hza) then  t10hza<=not t10hza;  end if;            
  end process;
  
    -----------------
  process(clk,reset)
  begin
  
    if reset='1' then zalta <=za1; --Setzen bei reset Zustand z1
    elsif clk='1' and clk'event then zalta<=zneua; --weiterschaltung bei clock
    end if;
  end process;
  

  process (a, zalta, t10hza)
  begin

    case zalta is
      when za1 =>  if a='0'
              then zneua <=za1;              
              else zneua <=za2;
              end if;
              ausgabe<='0';
              state<="0001";
              freigabetimer<='0';
              impulsa<='1';
              
              
              
    
      when za2 =>                                      
              if  t10hza='1'                    
              then zneua <=za3;
              else zneua <=za2;
              end if;
              ausgabe<='1';
              state<="0010";
              freigabetimer<='1';
                impulsa<='0';
              
      
      when za3 =>  if  a='1'
              then zneua <=za3;
              else zneua <=za4;
              end if;
              ausgabe<='1';
              state<="0011";
              freigabetimer<='0';
                impulsa<='1';
            
      
      when za4 =>  if t10hza='1'        
              then zneua <=za1;
              else zneua <=za4;
              end if;
              ausgabe<='0';
              state<="0100";
              freigabetimer<='1';
                impulsa<='0';
                  
  end case;
end process;  
  
  --TASTE B
    process(clk,reset)
  begin
    if reset='1' then zaltb <=zb1; --Setzen bei reset Zustandb z1
    elsif clk='1' and clk'event then zaltb<=zneub; --weiterschaltung bei clock
    end if;
  end process;  

  process (b, zaltb, t10hzb1)
  begin

    case zaltb is
      when zb1 =>  if b='0'
              then zneub <=zb1;              
              else zneub <=zb2;
              end if;
              ausgabeb<='0';
              --stateb<="0001";
              freigabetimerb<='0';
              impulsb<='1';
              
    
      when zb2 =>                                      
              if  t10hzb1='1'                      
              then zneub <=zb3;
              else zneub <=zb2;
              end if;
              ausgabeb<='1';
              --stateb<="0010";
              freigabetimerb<='1';
              impulsb<='0';
              
      
      when zb3 =>  if  b='1'
              then zneub <=zb3;
              else zneub <=zb4;
              end if;
              ausgabeb<='1';
              --stateb<="0011";
              freigabetimerb<='0';
              impulsb<='1';
              
              
      
      when zb4 =>  if t10hzb1='1'   
              then zneub <=zb1;
              else zneub <=zb4;
              end if;
              ausgabeb<='0';
              --stateb<="0100";
              freigabetimerb<='1';
              impulsb<='0';
                  
  end case;
  
end process;
  

taktb:process (clk) 
    begin  
  
   if reset='1' then countb<=0;
   
   elsif freigabetimerb='1' then    
      if (rising_edge(clk))then        --wenn steigene Flange von Clock dann zählen
        if(countb < t10hzb) then          --vergleiche zähler mit maximalen wert
        countb <= countb+1;              --addiere 1 auf zähler
      else
      clkoutb <=not clkoutb;            --
      countb <=0;                  -- setze zähler auf 0
          end if;
      end if;
    end if;  
  end process taktb;
  
    process (takt10hzb,impulsb) 
  begin  
  if impulsb='1' then t10hzb1<='0';
  elsif falling_edge (takt10hzb) then  t10hzb1<=not t10hzb1;  end if;              
  end process;
  

-------------------------

ZUSTANDSAKTUALISIERUNG_fl: process (clk,RESET)
begin
if RESET = '1' then ZUSTAND_fl <= A_fl;
elsif clk = '1' and clk'event then  ZUSTAND_fl <= FOLGEZUSTAND_fl;
end if;
end process ZUSTANDSAKTUALISIERUNG_fl;

FOLGEZUSTANDSBERECHNUNG_fl: process (a_out,ZUSTAND_fl)
begin
case ZUSTAND_fl is 
when A_fl =>   if  a_out = '1' THEN    FOLGEZUSTAND_fl <= A_fl;
else     FOLGEZUSTAND_fl <= B_fl;
end if ;
za <= '0'; 
when B_fl =>   if  a_out = '1' THEN   FOLGEZUSTAND_fl <= C_fl;
else    FOLGEZUSTAND_fl <= B_fl;
end if;
za <= '0';
when C_fl =>  if  a_out = '1' THEN   FOLGEZUSTAND_fl <= A_fl;
else    FOLGEZUSTAND_fl <= B_fl;
end if;
za <= '1';
end case;
end process FOLGEZUSTANDSBERECHNUNG_fl;

ZUSTANDSAKTUALISIERUNG_fl_b: process (clk,RESET)
begin
if RESET = '1' then ZUSTAND_fl_b <= A_fl_b;
elsif clk = '1' and clk'event then  ZUSTAND_fl_b <= FOLGEZUSTAND_fl_b;
end if;
end process ZUSTANDSAKTUALISIERUNG_fl_b;

FOLGEZUSTANDSBERECHNUNG_fl_b: process (ausgabeb,ZUSTAND_fl_b)
begin
case ZUSTAND_fl_b is 
when A_fl_b =>   if  ausgabeb = '1' THEN    FOLGEZUSTAND_fl_b <= A_fl_b;
else     FOLGEZUSTAND_fl_b <= B_fl_b;
end if ;
xa <= '0'; 
when B_fl_b =>   if  ausgabeb = '1' THEN   FOLGEZUSTAND_fl_b <= C_fl_b;
else    FOLGEZUSTAND_fl_b <= B_fl_b;
end if;
xa <= '0';
when C_fl_b =>  if  ausgabeb = '1' THEN   FOLGEZUSTAND_fl_b <= A_fl_b;
else    FOLGEZUSTAND_fl_b <= B_fl_b;
end if;
xa <= '1';
end case;
end process FOLGEZUSTANDSBERECHNUNG_fl_b;


hoch:process(reset,clk,za)
begin  
if reset='1' then qint<="0000"; -- Setze Zähler auf 0 wenn reset
  elsif clk='1' and clk'event  -- wenn Takt anliegt und weiterläuft dann
    then --qint<=qint; -- ausgabe wird gleich ausgabe gesetzt
  if za='1'--a_up='1'--Fallende Flanke von a zählt hoch
    then
      if qint="1000" then qint<="1000"; -- zählerbegrenzung auf 8
      else qint<=qint+1;      -- addition um 1 wenn 8 noch nicht erreicht
        end if;
        end if;
  if xa='1' then -- Fallende Flanke von b zählt runterthen
  if qint="0000" then qint<="1000"; -- wenn Zähler vorher 0 ist wird auf 8 gesetzt
    else qint<=qint-1;      -- subtraktion um 1 wenn 0 noch nicht erreicht ist
  end if;
  end if;
end if;
end process;

--PB
  process(clk,reset)
  begin
    if reset='1' then zalt <=z1; --Setzen bei reset Zustand z1
    elsif clk='1' and clk'event then zalt<=zneu; --weiterschaltung bei clock
    end if;
  end process;  
  
    process (takt10hzpb,impulspb) 
  begin  
  if impulspb='1' then t10hzpb1<='0';
  elsif falling_edge (takt10hzpb) then  t10hzpb1<=not t10hzpb1;  end if;              
  end process;

  process (pb, zalt, t10hzpb1)
  begin

    case zalt is
      when z1 =>  if pb='0' --Zustand 1
              then zneu <=z1;              
              else zneu <=z2;
              end if;
                  ausgabe1<='0'; -- Zuweisung der Ausgänge
                  ausgabe2<='0'; 
                  ausgabe3<='0';
                  ausgabe4<='0';
                  blabla<="0001";
                  impulspb<='1';
              
    
      when z2 =>                                      
              if  t10hzpb1  ='1'
              then zneu <=z3;
              else zneu <=z2;
              end if;
              ausgabe1<='1'; -- Zuweisung der Ausgänge
              ausgabe2<='1';
              ausgabe3<='0';
              ausgabe4<='1';
              blabla<="0010";
                impulspb<='0';
                
      when z3 =>  if  pb='1'
              then zneu <=z3;
              else zneu <=z4;
              end if;
              ausgabe1<='1';-- Zuweisung der Ausgänge
              ausgabe2<='0';
              ausgabe3<='0';
              ausgabe4<='0';
              blabla<="0011";
                impulspb<='1';
              
      
      when z4 =>  if t10hzpb1='1'     --statt a freigabe von 100ms !!!!
              then zneu <=z5;
              else zneu <=z4;
              end if;
              ausgabe1<='1';-- Zuweisung der Ausgänge
              ausgabe2<='0';
              ausgabe3<='0';
              ausgabe4<='1';
              blabla<="0100";
                impulspb<='0';
              
      when z5 =>  if pb='1'     --statt a freigabe von 100ms !!!!
              then zneu <=z6;
              else zneu <=z5;
              end if;    
              ausgabe1<='1';-- Zuweisung der Ausgänge
              ausgabe2<='0';
              ausgabe3<='0';    
              ausgabe4<='0';
              blabla<="0101";
                impulspb<='1';
                  
      when z6 =>  if t10hzpb1='1'     --statt a freigabe von 100ms !!!!
              then zneu <=z7;
              else zneu <=z6;
              end if;
              ausgabe1<='0';-- Zuweisung der Ausgänge
              ausgabe2<='0';
              ausgabe3<='1';
              ausgabe4<='1';
              blabla<="0110";
                impulspb<='0';

      when z7 =>  if pb='1'     --statt a freigabe von 100ms !!!!
              then zneu <=z7;
              else zneu <=z8;
              end if;
              ausgabe1<='0';-- Zuweisung der Ausgänge
              ausgabe2<='0';
              ausgabe3<='0';
              ausgabe4<='0';
              blabla<="0111";
                impulspb<='1';

      when z8 =>  if t10hzpb1='1'   --statt a freigabe von 100ms !!!!
              then zneu <=z1;
              else zneu <=z8;
              end if;
              ausgabe1<='0';-- Zuweisung der Ausgänge
              ausgabe2<='0';
              ausgabe3<='0';
              ausgabe4<='1';
              blabla<="1000";
                impulspb<='0';


  end case;
  end process;
-----------------------------------------------------------------------------------------------  
  
  takt:process (clk)  --Erzeugung des Taktes für die Entprellung
    begin
      if reset='1' then count<=0;
      
      elsif ausgabe4 ='1' then      
        if (rising_edge(clk))then        --wenn steigene Flange von Clock dann zählen
          if(count  < t10hz ) then          --vergleiche zähler mit maximalen wert
          count  <= count+1;              --addiere 1 auf zähler
          else
          clkoutpb  <=not clkoutpb ;            --
        count  <=0;                  -- setze zähler auf 0
          end if;
        end if;
      end if;    
end process takt;

--ERZEUGUNG TON
process begin 
wait until rising_edge(clk);  -- kommenden Takt abwarten 
if(c < 99999)then
c <= c + 1;    -- solange 99999 nicht erreicht, weiter zählen 
else          -- wenn Zählerende erreicht: 
c <= 0;      -- Zähler zurücksetzen 
x <= not x;      -- Signal x togglen 
end if; 
if( d < 49999) then
d <= d + 1;    -- solange 49999 nicht erreicht, weiter zählen 
else          -- wenn Zählerende erreicht: 
d <= 0;      -- Zähler zurücksetzen 
y <= not y;      -- Signal y togglen 
end if; 
end process; 

  
--VERKNÜPFUNG
process (TonF1K,TonF05K,Ton1000,Ton0500 )
  begin
  
    if 
    TonF1K='1' and TonF05k='0'  then
    Ton <= Ton1000  after 1 ns, '0' after 1000 ms;
   elsif
    TonF1K='0' and TonF05k='1'  then
    Ton <= Ton0500 after 1 ns, '0' after 1000 ms;
   else
    Ton <='0';
   end if;

   
  end process;
  
--DEKODER
process (qint, PB_Balken) 
begin 
Led <= "00000000"; 
if(PB_Balken = '1')then          -- Punkt-Betrieb 
case qint is 
when "0000" => Led <= "00000001";  -- Nur erste Led an 
when "0001" => Led <= "00000010";  -- Nur zweite Led an 
when "0010" => Led <= "00000100";  -- Nur dritte Led an 
when "0011" => Led <= "00001000";  -- Nur vierte Led an 
when "0100" => Led <= "00010000";  -- Nur fünfte Led an 
when "0101" => Led <= "00100000";  -- Nur sechste Led an 
when "0110" => Led <= "01000000";  -- Nur siebte Led an 
when "0111" => Led <= "10000000";  -- Nur achte Led an 
when others => Led <= "00000000";  -- Alle Led's aus 
end case; 

else                -- Balken-Betrieb 
case qint is 
when "0000" => Led <= "00000001";  -- Erste Led an 
when "0001" => Led <= "00000011";  -- Zweite Led an 
when "0010" => Led <= "00000111";  -- Dritte Led an 
when "0011" => Led <= "00001111";  -- Vierte Led an
when "0100" => Led <= "00011111";  -- Fünfte Led an 
when "0101" => Led <= "00111111";  -- Sechste Led an 
when "0110" => Led <= "01111111";  -- Siebte Led an 
when "0111" => Led <= "11111111";  -- Achte Led an
when others => Led <= "00000000";  -- Alle Led's aus 
end case; 

end if; 
end process; 



  
takt10hzb <= clkoutb;  
a_out    <=  ausgabe;
takt10hza <= clkout;
PB_Balken  <=  ausgabe1 ;
TonF1k    <=  ausgabe2 ;
TonF05k    <=  ausgabe3 ;
takt10hzpb   <= clkoutpb ;  
Ton0500 <= x;        -- Signal x an Ton0500 übergeben 
Ton1000 <= y;        -- Signal y an Ton1000 übergeben 
end Behavioral;

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Jack D. schrieb:
> was meines erachtens für ein Clock Problem spricht.
Ich tippe auf den beliebtesten aller Anfängerfehler: asynchrone 
Eingänge.
Probier mal,  die Eingänge einzutakten...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Nochmal drauf geschaut...
Dazu ein asynchroner kombinatorischer Reset. Und zudem irgendein 
asynchroner abgeleiteter Takt. Das läuft in der Praxis niemals stabil:
 if impulspb='1' then t10hzpb1<='0';
elsif falling_edge (takt10hzpb) then
     t10hzpb1<=not t10hzpb1;
end if;

Such mal nach "Postulate" hier im Forum. Eines davon ist: nur 1 Takt im 
ganzen Design.
Und jede Missachtung eines der anderen Postulate führt ebenfalls zu 
Fehlern,  die eine Simulation nicht findet...

[Falk B. (falk)]

@Jack D. (jack99)

"Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang"

Taktung FPGA/CPLD

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Noch 2 Worte dazu:

if reset='1' then counta<=0;    
   elsif freigabetimer='1'  then    
            if (rising_edge(clk))then        --wenn steigene Flange von Clock dann zählen
                    if(counta < t10hz_a) then          --vergleiche zähler mit maximalen wert
                                  counta <= counta+1;          --addiere 1 auf zähler
                                  elsif counta=t10hz_a then
                                  clkout <= not clkout;            
                                  counta <=0;  
                    end if;
            end if;
end if;

1. so werden in FPGAs keine Takte erzeugt. Das ist "bad design 
practice"...
2. Wo hast du diese Art der Beschreibung eines Clock-Enables gefunden?

Zum Them "Reset" speziell auf dem Spartan3 sieh dir mal den 
Beitrag "Xilinx und die Resets" und sieh dir auch die darin 
enthaltenen Links einmal genauer an.

Und dann noch diese recht gefährliche Stelle hier:

use ieee.numeric_std.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;

Dazu z.B. der Beitrag "IEEE.STD_LOGIC_ARITH.ALL obsolete"
Die numeric_std hat alles was du zum Rechnen und zum Wandeln zwischen 
den Datentypen brauchst:
http://www.lothar-miller.de/s9y/categories/16-Numeric_Std

Sieh dir einfach mal an, wie ich einen Drehgeber auswerte:
http://www.lothar-miller.de/s9y/categories/46-Encoder
Dort siehst du auch im ersten Beispiel, dass man Vieles simulieren kann, 
was letztlich aber der Synthesizer nicht auf Hardware abgebildet 
bekommt.

[René D. (Firma: www.dossmatik.de) (dose)]

Ich habe aucham Rotary Knob meine experimente gemacht.
Da gibt es zwei Knackpunkte. Auf meiner PCB fehlten Pull-up Widerstände.
Da musste ich die internen Widerstände im UCF file aktivieren.

Und das zweite sind Glitches beim Schalter durch den Schaltvorgang.
Da hilft ein gray-Code Coder.
Sehr schön von Ken Chapman erklärt.

http://www.eng.utah.edu/~cs3710/xilinx-docs/examples/s3esk_rotary_encoder_interface.pdf

[Falk B. (falk)]

@  René D. (Firma: www.dossmatik.de) (dose)

>Und das zweite sind Glitches beim Schalter durch den Schaltvorgang.
>Da hilft ein gray-Code Coder.

Den braucht man IMMER! Siehe Drehgeber.
Außerdem ist ein ein Gray-DEcoder, denn der Drehgeber geibt schon 
Gray-Code aus.