www.mikrocontroller.net

Forum: FPGA, VHDL & Co. Custom IP-Core hängt sich auf.


Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo VHDL-Gemeinde,

schon wieder habe ich - wer hätte das gedacht - ein Problem. Ein 
selbstgebastelter IP-Core, der in der Simulation einwandfrei 
funktioniert, scheint sich auf dem FPGA immer wieder aufzuhängen.

Zentraler Teil ist eine FSM. Die variable r wird durch Triggerimpulse 
gezählt und eine weitere Zählvariable gemäß einem Bitmuster mitgezählt. 
Nach einigen Triggerimpulsen bleibt alles stehen, hier mal der Code:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

--------------------------------------------------------------------
entity CALC is
--------------------------------------------------------------------
  Port ( ETrigger_C       : in  STD_LOGIC;
       SWDTTrigger_C      : in  STD_LOGIC;
       clk_C          : in  STD_LOGIC;
       Dir_C          : in  STD_LOGIC;
       Resetr_C        : in  STD_LOGIC;
       ResetN_C        : in  STD_LOGIC;
       ResetMOD_C        : in  STD_LOGIC;
       EnableMOD_C      : in  STD_LOGIC;
       EnableAdapt_C      : in  STD_LOGIC;
       AzimuthType_C      : in  STD_LOGIC;
       CounterValue_C    : in  STD_LOGIC_VECTOR (16 downto 0);
       rmax_C          : in  UNSIGNED(15 downto 0);
       MODref_C        : in  UNSIGNED(31 downto 0);
       NT_C            : in  SIGNED(19 downto 0);
       h_times_g_C      : in  UNSIGNED(19 downto 0);
       
       Reset_C          : out STD_LOGIC;
       Busy_C          : out STD_LOGIC;
       DirOut_C        : out STD_LOGIC;
       N_C            : out SIGNED(19 downto 0);
       dN_C            : out UNSIGNED(15 downto 0);
       ND_C            : out UNSIGNED(15 downto 0);
       r_C            : out UNSIGNED(15 downto 0);
       MOD_C          : out UNSIGNED(31 downto 0));
  end CALC;
--------------------------------------------------------------------

--------------------------------------------------------------------
architecture Behavioral of CALC is
--------------------------------------------------------------------

  constant PSTable : STD_LOGIC_VECTOR (1023 downto 0):="00100001000010000100000100001000010000100001000010000100001000001000010"
                                    & "00010000100001000010000100001000010000010000100001000010000100001000010"
                                    & "00010000010000100001000010000100001000010000100001000001000010000100001"
                                    & "00001000010000100001000001000010000100001000010000100001000010000010000"
                                    & "10000100001000010000100001000010000100000100001000010000100001000010000"
                                    & "10000100000100001000010000100001000010000100001000001000010000100001000"
                                    & "01000010000100001000001000010000100001000010000100001000010000100000100"
                                    & "00100001000010000100001000010000100000100001000010000100001000010000100"
                                    & "00100000100001000010000100001000010000100001000010000010000100001000010"
                                    & "00010000100001000010000010000100001000010000100001000010000100000100001"
                                    & "00001000010000100001000010000100001000001000010000100001000010000100001"
                                    & "00001000001000010000100001000010000100001000010000100000100001000010000"
                                    & "10000100001000010000100000100001000010000100001000010000100001000001000"
                                    & "01000010000100001000010000100001000001000010000100001000010000100001000"
                                    & "010000100000100001000010000100";
  
  --type MODTable is array (0 to 50) of INTEGER RANGE 0 TO 255 ;
  --constant MODFactorRed : MODTable:=(128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,98,96,94,92,90,88,86,84,82,80,78,76,74,72,70,68,66,64,62,60,58,56);
  --constant MODFActorEnl : MODTable:=(128,129,130,131,132,133,134,135,136,137,138,139,140,142,144,146,148,150,152,154,156,158,160,164,168,172,176,180,184,188,192,196,200,204,208,212,216,220,224,228,232,236,240,244,248,252,255,255,255,255,255);
  
---------------------------------------------------------------------                                    
  component Divider is
    Generic ( b  : natural range 4 to 32 := 32 ); 
      Port ( start     : in   STD_LOGIC;
           divisor   : in   STD_LOGIC_VECTOR (b-1 downto 0);
           dividend  : in   STD_LOGIC_VECTOR (b-1 downto 0);
           quotient  : out  STD_LOGIC_VECTOR (b-1 downto 0);
           remainder : out  STD_LOGIC_VECTOR (b-1 downto 0);
           busy      : out  STD_LOGIC;
           clk       : in   STD_LOGIC);
  end component;
---------------------------------------------------------------------
  type state is (Init, Idle, Calc_N, Calc_dN, Calc_MOD, Calc_ND, WaitOneClk, Done);
  signal s         : state;
  signal countervalue   : STD_LOGIC_VECTOR(16 downto 0);
  signal startDIV      : STD_LOGIC:='0';
  signal divisorDIV    : STD_LOGIC_VECTOR (16 downto 0);
  signal quotientDIV   : STD_LOGIC_VECTOR (16 downto 0);
  signal busyDIV       : STD_LOGIC:='0';
  signal EFlag      : STD_LOGIC;
  signal EFlagReset    : STD_LOGIC;
  signal SWDTFlag    : STD_LOGIC;
  signal SWDTFlagReset : STD_LOGIC;
---------------------------------------------------------------------  
  begin
  
    instDivider : Divider
      Generic Map ( b => 17 )
      Port Map    ( start     => startDIV,
                divisor   => divisorDIV,
                dividend  => std_logic_vector(to_unsigned(97656,17)),
                quotient  => quotientDIV,
                remainder => open,
                busy      => busyDIV,
                clk       => clk_C);

---------------------------------------------------------------------  
    FSM : process 
---------------------------------------------------------------------
    type NTArray is array (3 downto 0) of SIGNED(19 downto 0);
    variable NT        : NTArray;
    variable dNsquare    : UNSIGNED(31 downto 0);
    variable ND64bitfp  : UNSIGNED(63 downto 0);
    variable r         : UNSIGNED(15 downto 0):=to_unsigned(1,16);
    variable N         : SIGNED(19 downto 0):=to_signed(0,20);
    variable dN        : UNSIGNED(15 downto 0):=to_unsigned(0,16);
    variable ND        : UNSIGNED(15 downto 0):=to_unsigned(0,16);
    variable dir      : STD_LOGIC_VECTOR(3 downto 0):="0000";
    variable Modifier    : UNSIGNED(31 downto 0);
    variable Modifier40b  : UNSIGNED(39 downto 0); 
    variable absDeltaN  : UNSIGNED(19 downto 0);
    variable factor    : UNSIGNED(7 downto 0);
    
    begin
    
      wait until rising_edge(clk_c);
      
      If Resetr_C = '1'   then r := to_unsigned(1,16); else r := r;            end if;
      If ResetN_C = '1'   then N := to_signed(0,20);   else N := N;             end if;
      If ResetMOD_C = '1' then Modifier := MODref_C;   else Modifier := Modifier; end if;
      
      -------------------------------------------------------
      case s is 
      -------------------------------------------------------
        ----------------------------------------------------
        when Init    =>
        ----------------------------------------------------
          Modifier := MODref_C;
          s <= Idle;
        
         ----------------------------------------------------
        when Idle    =>
         ----------------------------------------------------  
          Reset_C <= '0';
          if EFlag='1' then
            Busy_C <= '1';
            EFlagReset <= '1';
            If Dir_C='1' then r := r + 1; else r := r - 1; end if;
            If r = 0 then r := rmax_C; elsif r > rmax_C then r := r - rmax_C; end if;
            If PSTable(to_integer(r)-1)='1' then
              countervalue <= CounterValue_C;
              Reset_C <= '1';
              dir := to_stdlogicvector(to_bitvector(dir) sll 1);
              dir(0) := Dir_C;
              NT(3 downto 1):=NT(2 downto 0);
              NT(0) := NT_C;
              s <= Calc_N; 
            else 
              s <= Done; 
            end if;
          elsif SWDTFlag='1' then
            Busy_C <= '1';
            SWDTFlagReset <='1';
            dN := to_unsigned(0,16);
            ND := to_unsigned(0,16);
            s  <= Done;
          else
            EFlagReset <= '0';
            SWDTFlagReset <= '0';
            Busy_C <= '0';
            s <= Idle;
          end if;
          
         ------------------------------------------------------  
        when Calc_N    =>
         ------------------------------------------------------
          If dir(0)='1' then N := N + 1; else N := N - 1; end if;
          If AzimuthType_C = '1' then
            If   N < 0                then N := N + signed(h_times_g_C); 
            elsif N > signed(h_times_g_C-1) then N := N - signed(h_times_g_C);
            else                               N := N;                 
            end if;
          else
            N := N;
          end if;
          s <= Calc_dN;
  
         ------------------------------------------------------  
        when Calc_dN  =>
        ------------------------------------------------------
          if dir(0)=dir(1) then
            If busyDIV='0' and startDIV='0' then
              divisorDIV  <= countervalue;
              startDIV <= '1';
              s <= WaitOneClk;
            elsif busyDIV='0' and startDIV='1' then
              dN := unsigned(quotientDIV(15 downto 0));
              startDIV <= '0';
              If EnableAdapt_C = '1' and NT(3)=NT(2) and NT(2)=NT(1) and NT(1)=NT(0) then
                s <= Calc_MOD;
              else
                s <= Calc_ND;
              end if;
            else
              s <= Calc_dN;
            end if;
          else
            dN := to_unsigned(0,16);
            ND := to_unsigned(0,16);
            s  <= Done;
          end if;
          
        -------------------------------------------------------
        when Calc_MOD =>
        -------------------------------------------------------
          absDeltaN := unsigned(abs(NT_C - N));
            If    (dir(3)=dir(2) and dir(2)/=dir(1) and dir(1)/=dir(0)) then  -- reduce  Modifier
              If absDeltaN > to_unsigned(64,20) then 
                factor := to_unsigned(64,8);
              else
                factor := 128 - absDeltaN(7 downto 0);--to_unsigned(MODFactorRed(to_integer(absDeltaN)),8);
              end if;  
            elsif (dir(3)=dir(2) and dir(2)/=dir(1) and dir(1) =dir(0)) then  -- enlarge Modifier
              If absDeltaN > to_unsigned(64,20) then
                factor := to_unsigned(255,8);
              else
                factor := 128 + absDeltaN(7 downto 0);--to_unsigned(MODFactorEnl(to_integer(absDeltaN)),8);
              end if;
            else
              factor := to_unsigned(128,8);
            end if;
          Modifier40b := Modifier * "000000000000000000000000"&factor / 128;
          Modifier := Modifier40b(31 downto 0);
          s <= Calc_ND;
              
        -------------------------------------------------------
        when Calc_ND  =>
        -------------------------------------------------------
          dNsquare := dN * dN;
          If EnableMOD_C = '0' then
            ND64bitfp := MODref_C * dNsquare;
          else
            ND64bitfp := Modifier * dNsquare;
          end if;
          ND := ND64bitfp(47 downto 32);
          s <= Done;
          
        -------------------------------------------------------
        when WaitOneClk  =>
        -------------------------------------------------------
          s <= Calc_dN;
          
        -------------------------------------------------------
        when Done    =>
        -------------------------------------------------------
          Busy_C <= '0';
          s <= Idle;
      
      ----------------------------------------------------------
      end case;
      ----------------------------------------------------------
    
      r_C <= r;
      N_C <= N;
      dN_C <= dN;
      ND_C <= ND;
      DirOut_C <= dir(0);
      MOD_C  <= Modifier;
    
    end process;
    
-------------------------------------------------------------------        
    EFlipFlop : process(ETrigger_C, EFlagReset)
-------------------------------------------------------------------
    begin
      If EFlagReset='1' then
        EFlag <='0';
      elsif rising_edge(ETrigger_C) then
        EFlag <='1';
      end if;
    end process;
    
-------------------------------------------------------------------        
    SWDTFlipFlop : process(SWDTTrigger_C, SWDTFlagReset)
-------------------------------------------------------------------
    begin
      If SWDTFlagReset='1' then
        SWDTFlag <='0';
      elsif rising_edge(SWDTTrigger_C) then
        SWDTFlag <='1';
      end if;
    end process;
  end Behavioral; 

Ich hab ich anderen Beiträgen was über "Eintakten" gelesen. Kann hier 
der Fehler liegen?
Der daranhängende MicroBlaze bleibt nicht hängen, nur der IPCore.
Wie gesagt, stelle ich das Szenario im Simulator nach, dann funktioniert 
alles. Allerdings ist das natürlich das VHDL Modell ohne 
Schnittstellenanbindung, aber daran kanns ja eigentlich nicht liegen.

Wäre für jeden Tipp sehr dankbar. Vielleicht hat schon mal jemand 
ähnliche Erfahrungen gemacht.

Vielen Dank.

Gruß
Flo

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Du hast 3 Taktdomänen:
> rising_edge(clk_c)
> rising_edge(ETrigger_C)
> rising_edge(SWDTTrigger_C)
Und du fragst in der ersten Domäne (clk_c) Signale ab, die von den 
beiden anderen asynchron gesetzt werden (EFlag und SWDTFlag). Das wird 
garantiert Probleme geben (Hintergrund: Laufzeiten im FPGA, siehe 
http://www.lothar-miller.de/s9y/categories/35-Eins...)


> EFlag
> SWDTFlag
Sieh dir mal an, wie man einen Spike in einen synchronen Puls umwandelt: 
http://www.lothar-miller.de/s9y/categories/19-SpikePuls


> Wie gesagt, stelle ich das Szenario im Simulator nach,
> dann funktioniert alles.
Solche Fehler findest du in der Verhaltenssimulation niemals, in einer 
Post-Route-Simulation evtl. zufällig. Du mußt diese Fehler per Design 
ausschliessen (= Lernen, Üben, Wissen)...  :-o

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für die Tipps.
Nach genauerer Überlegung können gar keine Spikes auftreten. Habe das 
Ganze also so abgewandelt:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

--------------------------------------------------------------------
entity CALC is
--------------------------------------------------------------------
  Port ( ETrigger_C       : in  STD_LOGIC;
       SWDTTrigger_C      : in  STD_LOGIC;
       clk_C          : in  STD_LOGIC;
       Dir_C          : in  STD_LOGIC;
       Resetr_C        : in  STD_LOGIC;
       ResetN_C        : in  STD_LOGIC;
       ResetMOD_C        : in  STD_LOGIC;
       EnableMOD_C      : in  STD_LOGIC;
       EnableAdapt_C      : in  STD_LOGIC;
       AzimuthType_C      : in  STD_LOGIC;
       CounterValue_C    : in  STD_LOGIC_VECTOR (16 downto 0);
       rmax_C          : in  UNSIGNED(15 downto 0);
       MODref_C        : in  UNSIGNED(31 downto 0);
       NT_C            : in  SIGNED(19 downto 0);
       h_times_g_C      : in  UNSIGNED(19 downto 0);
       
       Reset_C          : out STD_LOGIC;
       Busy_C          : out STD_LOGIC;
       DirOut_C        : out STD_LOGIC;
       N_C            : out SIGNED(19 downto 0);
       dN_C            : out UNSIGNED(15 downto 0);
       ND_C            : out UNSIGNED(15 downto 0);
       r_C            : out UNSIGNED(15 downto 0);
       MOD_C          : out UNSIGNED(31 downto 0));
  end CALC;
--------------------------------------------------------------------

--------------------------------------------------------------------
architecture Behavioral of CALC is
--------------------------------------------------------------------

  constant PSTable : STD_LOGIC_VECTOR (1023 downto 0):="00100001000010000100000100001000010000100001000010000100001000001000010"
                                    & "00010000100001000010000100001000010000010000100001000010000100001000010"
                                    & "00010000010000100001000010000100001000010000100001000001000010000100001"
                                    & "00001000010000100001000001000010000100001000010000100001000010000010000"
                                    & "10000100001000010000100001000010000100000100001000010000100001000010000"
                                    & "10000100000100001000010000100001000010000100001000001000010000100001000"
                                    & "01000010000100001000001000010000100001000010000100001000010000100000100"
                                    & "00100001000010000100001000010000100000100001000010000100001000010000100"
                                    & "00100000100001000010000100001000010000100001000010000010000100001000010"
                                    & "00010000100001000010000010000100001000010000100001000010000100000100001"
                                    & "00001000010000100001000010000100001000001000010000100001000010000100001"
                                    & "00001000001000010000100001000010000100001000010000100000100001000010000"
                                    & "10000100001000010000100000100001000010000100001000010000100001000001000"
                                    & "01000010000100001000010000100001000001000010000100001000010000100001000"
                                    & "010000100000100001000010000100";
  
---------------------------------------------------------------------                                    
  component Divider is
    Generic ( b  : natural range 4 to 32 := 32 ); 
      Port ( start     : in   STD_LOGIC;
           divisor   : in   STD_LOGIC_VECTOR (b-1 downto 0);
           dividend  : in   STD_LOGIC_VECTOR (b-1 downto 0);
           quotient  : out  STD_LOGIC_VECTOR (b-1 downto 0);
           remainder : out  STD_LOGIC_VECTOR (b-1 downto 0);
           busy      : out  STD_LOGIC;
           clk       : in   STD_LOGIC);
  end component;
---------------------------------------------------------------------
  type state is (Init, Idle, Calc_N, Calc_dN, Calc_MOD, Calc_ND, WaitOneClk, Done);
  signal s         : state;
  signal countervalue   : STD_LOGIC_VECTOR(16 downto 0);
  signal startDIV      : STD_LOGIC:='0';
  signal divisorDIV    : STD_LOGIC_VECTOR (16 downto 0);
  signal quotientDIV   : STD_LOGIC_VECTOR (16 downto 0);
  signal busyDIV       : STD_LOGIC:='0';
  signal Esr        : STD_LOGIC_VECTOR(2 downto 0);
  signal SWDTsr      : STD_LOGIC_VECTOR(2 downto 0);
---------------------------------------------------------------------  
  begin
  
    instDivider : Divider
      Generic Map ( b => 17 )
      Port Map    ( start     => startDIV,
                divisor   => divisorDIV,
                dividend  => std_logic_vector(to_unsigned(97656,17)),
                quotient  => quotientDIV,
                remainder => open,
                busy      => busyDIV,
                clk       => clk_C);

---------------------------------------------------------------------  
    FSM : process 
---------------------------------------------------------------------
    type NTArray is array (3 downto 0) of SIGNED(19 downto 0);
    variable NT        : NTArray;
    variable dNsquare    : UNSIGNED(31 downto 0);
    variable ND64bitfp  : UNSIGNED(63 downto 0);
    variable r         : UNSIGNED(15 downto 0):=to_unsigned(1,16);
    variable N         : SIGNED(19 downto 0):=to_signed(0,20);
    variable dN        : UNSIGNED(15 downto 0):=to_unsigned(0,16);
    variable ND        : UNSIGNED(15 downto 0):=to_unsigned(0,16);
    variable dir      : STD_LOGIC_VECTOR(3 downto 0):="0000";
    variable Modifier    : UNSIGNED(31 downto 0);
    variable Modifier40b  : UNSIGNED(39 downto 0); 
    variable absDeltaN  : UNSIGNED(19 downto 0);
    variable factor    : UNSIGNED(7 downto 0);
    
    begin
    
      wait until rising_edge(clk_c);
      
      If Resetr_C = '1'   then r := to_unsigned(1,16); else r := r;            end if;
      If ResetN_C = '1'   then N := to_signed(0,20);   else N := N;             end if;
      If ResetMOD_C = '1' then Modifier := MODref_C;   else Modifier := Modifier; end if;
      
      -------------------------------------------------------
      case s is 
      -------------------------------------------------------
        ----------------------------------------------------
        when Init    =>
        ----------------------------------------------------
          Modifier := MODref_C;
          s <= Idle;
        
         ----------------------------------------------------
        when Idle    =>
         ----------------------------------------------------  
          Reset_C <= '0';
          if Esr(2 downto 1)="01" then
            Busy_C <= '1';
            If Dir_C='1' then r := r + 1; else r := r - 1; end if;
            If r = 0 then r := rmax_C; elsif r > rmax_C then r := r - rmax_C; end if;
            If PSTable(to_integer(r)-1)='1' then
              countervalue <= CounterValue_C;
              Reset_C <= '1';
              dir := to_stdlogicvector(to_bitvector(dir) sll 1);
              dir(0) := Dir_C;
              NT(3 downto 1):=NT(2 downto 0);
              NT(0) := NT_C;
              s <= Calc_N; 
            else 
              s <= Done; 
            end if;
          elsif SWDTsr(2 downto 1)="01" then
            Busy_C <= '1';
            dN := to_unsigned(0,16);
            ND := to_unsigned(0,16);
            s  <= Done;
          else
            Busy_C <= '0';
            s <= Idle;
          end if;
          
         ------------------------------------------------------  
        when Calc_N    =>
         ------------------------------------------------------
          If dir(0)='1' then N := N + 1; else N := N - 1; end if;
          If AzimuthType_C = '1' then
            If   N < 0                then N := N + signed(h_times_g_C); 
            elsif N > signed(h_times_g_C-1) then N := N - signed(h_times_g_C);
            else                               N := N;                 
            end if;
          else
            N := N;
          end if;
          s <= Calc_dN;
  
         ------------------------------------------------------  
        when Calc_dN  =>
        ------------------------------------------------------
          if dir(0)=dir(1) then
            If busyDIV='0' and startDIV='0' then
              divisorDIV  <= countervalue;
              startDIV <= '1';
              s <= WaitOneClk;
            elsif busyDIV='0' and startDIV='1' then
              dN := unsigned(quotientDIV(15 downto 0));
              startDIV <= '0';
              If EnableAdapt_C = '1' and NT(3)=NT(2) and NT(2)=NT(1) and NT(1)=NT(0) then
                s <= Calc_MOD;
              else
                s <= Calc_ND;
              end if;
            else
              s <= Calc_dN;
            end if;
          else
            dN := to_unsigned(0,16);
            ND := to_unsigned(0,16);
            s  <= Done;
          end if;
          
        -------------------------------------------------------
        when Calc_MOD =>
        -------------------------------------------------------
          absDeltaN := unsigned(abs(NT_C - N));
            If    (dir(3)=dir(2) and dir(2)/=dir(1) and dir(1)/=dir(0)) then  -- reduce  Modifier
              If absDeltaN > to_unsigned(64,20) then 
                factor := to_unsigned(64,8);
              else
                factor := 128 - absDeltaN(7 downto 0);
              end if;  
            elsif (dir(3)=dir(2) and dir(2)/=dir(1) and dir(1) =dir(0)) then  -- enlarge Modifier
              If absDeltaN > to_unsigned(64,20) then
                factor := to_unsigned(255,8);
              else
                factor := 128 + absDeltaN(7 downto 0);
              end if;
            else
              factor := to_unsigned(128,8);
            end if;
          Modifier40b := Modifier * "000000000000000000000000"&factor / 128;
          Modifier := Modifier40b(31 downto 0);
          s <= Calc_ND;
              
        -------------------------------------------------------
        when Calc_ND  =>
        -------------------------------------------------------
          dNsquare := dN * dN;
          If EnableMOD_C = '0' then
            ND64bitfp := MODref_C * dNsquare;
          else
            ND64bitfp := Modifier * dNsquare;
          end if;
          ND := ND64bitfp(47 downto 32);
          s <= Done;
          
        -------------------------------------------------------
        when WaitOneClk  =>
        -------------------------------------------------------
          s <= Calc_dN;
          
        -------------------------------------------------------
        when Done    =>
        -------------------------------------------------------
          Busy_C <= '0';
          s <= Idle;
      
      ----------------------------------------------------------
      end case;
      ----------------------------------------------------------
    
      r_C <= r;
      N_C <= N;
      dN_C <= dN;
      ND_C <= ND;
      DirOut_C <= dir(0);
      MOD_C  <= Modifier;
    
    end process;
    
-------------------------------------------------------------------        
    SyncETrigger : process
-------------------------------------------------------------------
    begin
      wait until rising_edge(clk_C);
      Esr <= Esr(1 downto 0) & ETrigger_C;
    end process;
    
-------------------------------------------------------------------        
    SyncSWDTTrigger : process
-------------------------------------------------------------------
    begin
      wait until rising_edge(clk_C);
      SWDTsr <= SWDTsr(1 downto 0) & SWDTTrigger_C;
    end process;
    
  end Behavioral;

Das hat das Problem aber leider nicht gelöst. Wäre für jeden weiteren 
Einfall dankbar.

Gruß
Flo

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Nach einigen Triggerimpulsen bleibt alles stehen...
In welchem Zustand?

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
In welchem Zustand, habe ich noch nicht rausgefunden. Dazu muss ich erst 
wohl das Zustandssignal nach außen führen ?!

Allerdings konnte ich feststellen, dass sich das VHDL Modul im 
stand-alone Betrieb, also nicht als IP-Core + Microblaze, nicht 
aufhängt.

Bin ein wenig ratlos.

Schönen Pfingstmontag an alle Leser.

Gruß
Flo

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Dazu muss ich erst wohl das Zustandssignal nach außen führen ?!
Ja, z.B. auf LEDs auf diese Art:
http://www.lothar-miller.de/s9y/archives/49-FSM-de...

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bevor ich das probier, noch eine Frage: Mal angenommen, die FSM bleibt 
im Zustand Calc_dN hängen bzw. wackelt zwischen Cald_dN und WaitOneClk. 
Könnte da irgendwas mit dem Handshake mit der Divisions-Komponente nicht 
stimmen? Weise ich da vielleicht Signale falsch zu, sodass Synthese und 
Simulation sich unterscheiden?
Hat z.B. eine Bedingung wie
If busyDIV='0' and startDIV='0' then
  divisorDIV  <= countervalue;
  startDIV <= '1';
  s <= WaitOneClk;
elsif busyDIV='0' and startDIV='1' then
  dN := unsigned(quotientDIV(15 downto 0));
  startDIV <= '0';
  If EnableAdapt_C = '1' and NT(3)=NT(2) and NT(2)=NT(1) and NT(1)=NT(0) then
    s <= Calc_MOD;
  else
    s <= Calc_ND;
  end if;
else
  s <= Calc_dN;
end if; 

in der ein Signal abgefragt und dann davon abhängig gesetzt wird 
irgendwelche für den Anfänger unvorhergesehene Folgen? Wird z.B. 
startDIV gleichzeitig gesetzt und abgefragt und führt daher zu irgendwas 
"Verrücktem"?

Vielen Dank für die Hilfe.

Gruß
Flo

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Wird z.B. startDIV gleichzeitig gesetzt und abgefragt ...
... ist das eine ganz übliche Vorgehensweise. Absolut jede State-Machine 
arbeitet so.
If busyDIV='0' and startDIV='0' then
  startDIV <= '1';
elsif busyDIV='0' and startDIV='1' then
  startDIV <= '0';
Das startDIV ist in der brutalen Realität ein Flipflop, das am Eingang 
eine Kombinatorik hat, mit der der Zustand berechnet wird, der mit dem 
nächsten Takt übernommen wird. Und danach ist dieses startDIV mindestens 
einen Takt lang stabil.

Dein Problem liegt irgendwo anders...

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also, zunächst habe ich noch ein paar kleine Änderungen vorgenommen, die 
mit dem Problem nichts zu tun haben. Der Vollständigkeit halber hier der 
Code:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

--------------------------------------------------------------------
entity CALC is
--------------------------------------------------------------------
  Port ( ETrigger_C       : in  STD_LOGIC;
       SWDTTrigger_C      : in  STD_LOGIC;
       clk_C          : in  STD_LOGIC;
       Dir_C          : in  STD_LOGIC;
       Resetr_C        : in  STD_LOGIC;
       ResetN_C        : in  STD_LOGIC;
       ResetMOD_C        : in  STD_LOGIC;
       EnableMOD_C      : in  STD_LOGIC;
       EnableAdapt_C      : in  STD_LOGIC;
       AzimuthType_C      : in  STD_LOGIC;
       CounterValue_C    : in  STD_LOGIC_VECTOR (16 downto 0);
       rmax_C          : in  UNSIGNED(15 downto 0);
       MODref_C        : in  UNSIGNED(31 downto 0);
       NT_C            : in  SIGNED(19 downto 0);
       h_times_g_C      : in  UNSIGNED(19 downto 0);
       
       Reset_C          : out STD_LOGIC;
       Busy_C          : out STD_LOGIC;
       DirOut_C        : out STD_LOGIC;
       N_C            : out SIGNED(19 downto 0);
       dN_C            : out UNSIGNED(15 downto 0);
       ND_C            : out UNSIGNED(15 downto 0);
       r_C            : out UNSIGNED(15 downto 0);
       MOD_C          : out UNSIGNED(31 downto 0);
       state_as_vector    : out STD_LOGIC_VECTOR(3 downto 0));
  end CALC;
--------------------------------------------------------------------

--------------------------------------------------------------------
architecture Behavioral of CALC is
--------------------------------------------------------------------

  constant PSTable : STD_LOGIC_VECTOR (1023 downto 0):="00100001000010000100000100001000010000100001000010000100001000001000010"
                                    & "00010000100001000010000100001000010000010000100001000010000100001000010"
                                    & "00010000010000100001000010000100001000010000100001000001000010000100001"
                                    & "00001000010000100001000001000010000100001000010000100001000010000010000"
                                    & "10000100001000010000100001000010000100000100001000010000100001000010000"
                                    & "10000100000100001000010000100001000010000100001000001000010000100001000"
                                    & "01000010000100001000001000010000100001000010000100001000010000100000100"
                                    & "00100001000010000100001000010000100000100001000010000100001000010000100"
                                    & "00100000100001000010000100001000010000100001000010000010000100001000010"
                                    & "00010000100001000010000010000100001000010000100001000010000100000100001"
                                    & "00001000010000100001000010000100001000001000010000100001000010000100001"
                                    & "00001000001000010000100001000010000100001000010000100000100001000010000"
                                    & "10000100001000010000100000100001000010000100001000010000100001000001000"
                                    & "01000010000100001000010000100001000001000010000100001000010000100001000"
                                    & "010000100000100001000010000100";
  
---------------------------------------------------------------------                                    
  component Divider is
    Generic ( b  : natural range 4 to 32 := 32 ); 
      Port ( start     : in   STD_LOGIC;
           divisor   : in   STD_LOGIC_VECTOR (b-1 downto 0);
           dividend  : in   STD_LOGIC_VECTOR (b-1 downto 0);
           quotient  : out  STD_LOGIC_VECTOR (b-1 downto 0);
           remainder : out  STD_LOGIC_VECTOR (b-1 downto 0);
           busy      : out  STD_LOGIC;
           clk       : in   STD_LOGIC);
  end component;
---------------------------------------------------------------------
  type state is (Init, Idle, Calc_N, Calc_dN, Calc_MOD, Calc_ND, WaitOneClk);--, Done);
  signal s         : state;
  signal countervalue   : STD_LOGIC_VECTOR(16 downto 0);
  signal startDIV      : STD_LOGIC:='0';
  signal divisorDIV    : STD_LOGIC_VECTOR (16 downto 0);
  signal quotientDIV   : STD_LOGIC_VECTOR (16 downto 0);
  signal busyDIV       : STD_LOGIC:='0';
  signal Esr        : STD_LOGIC_VECTOR(2 downto 0);
  signal SWDTsr      : STD_LOGIC_VECTOR(2 downto 0);
---------------------------------------------------------------------  
  begin
  
    instDivider : Divider
      Generic Map ( b => 17 )
      Port Map    ( start     => startDIV,
                divisor   => divisorDIV,
                dividend  => std_logic_vector(to_unsigned(97656,17)),
                quotient  => quotientDIV,
                remainder => open,
                busy      => busyDIV,
                clk       => clk_C);

---------------------------------------------------------------------  
    FSM : process 
---------------------------------------------------------------------
    type NTArray is array (3 downto 0) of SIGNED(19 downto 0);
    variable NT        : NTArray;
    variable dNsquare    : UNSIGNED(31 downto 0);
    variable ND64bitfp  : UNSIGNED(63 downto 0);
    variable r         : UNSIGNED(15 downto 0):=to_unsigned(1,16);
    variable N         : SIGNED(19 downto 0):=to_signed(0,20);
    variable dN        : UNSIGNED(15 downto 0):=to_unsigned(0,16);
    variable ND        : UNSIGNED(15 downto 0):=to_unsigned(0,16);
    variable dir      : STD_LOGIC_VECTOR(3 downto 0):="0000";
    variable Modifier    : UNSIGNED(31 downto 0);
    variable Modifier40b  : UNSIGNED(39 downto 0); 
    variable absDeltaN  : UNSIGNED(19 downto 0);
    variable factor    : UNSIGNED(7 downto 0);
    
    begin
    
      wait until rising_edge(clk_c);
      
      If Resetr_C = '1'   then r := to_unsigned(1,16); else r := r;            end if;
      If ResetN_C = '1'   then N := to_signed(0,20);   else N := N;             end if;
      If ResetMOD_C = '1' then Modifier := MODref_C;   else Modifier := Modifier; end if;
      
      -------------------------------------------------------
      case s is 
      -------------------------------------------------------
        ----------------------------------------------------
        when Init    =>
        ----------------------------------------------------
          Modifier := MODref_C;
          s <= Idle;
        
         ----------------------------------------------------
        when Idle    =>
         ----------------------------------------------------  
          if Esr(2 downto 1)="01" then
            Busy_C  <= '1';
            Reset_C <= '0';
            If Dir_C='1' then r := r + 1; else r := r - 1; end if;
            If r = 0 then r := rmax_C; elsif r > rmax_C then r := r - rmax_C; end if;
            If PSTable(to_integer(r)-1)='1' then
              countervalue <= CounterValue_C;
              dir := to_stdlogicvector(to_bitvector(dir) sll 1);
              dir(0) := Dir_C;
              NT(3 downto 1):=NT(2 downto 0);
              NT(0) := NT_C;
              s <= Calc_N; 
            else 
              s <= Idle; 
            end if;
          elsif SWDTsr(2 downto 1)="01" then
            Busy_C <= '1';
            Reset_C <= '1';
            dN := to_unsigned(0,16);
            ND := to_unsigned(0,16);
            s  <= Idle;
          else
            Busy_C <= '0';
            Reset_C <= '0';
            s <= Idle;
          end if;
          
         ------------------------------------------------------  
        when Calc_N    =>
         ------------------------------------------------------
          If dir(0)='1' then N := N + 1; else N := N - 1; end if;
          If AzimuthType_C = '1' then
            If   N < 0                then N := N + signed(h_times_g_C); 
            elsif N > signed(h_times_g_C-1) then N := N - signed(h_times_g_C);
            else                               N := N;                 
            end if;
          else
            N := N;
          end if;
          Busy_C  <= '1';
          Reset_C <= '1';
          s <= Calc_dN;
  
         ------------------------------------------------------  
        when Calc_dN  =>
        ------------------------------------------------------
          if dir(0)=dir(1) then
            If busyDIV='0' and startDIV='0' then
              divisorDIV  <= countervalue;
              startDIV <= '1';
              s <= WaitOneClk;
            elsif busyDIV='0' and startDIV='1' then
              dN := unsigned(quotientDIV(15 downto 0));
              startDIV <= '0';
              If EnableAdapt_C = '1' and NT(3)=NT(2) and NT(2)=NT(1) and NT(1)=NT(0) then
                s <= Calc_MOD;
              else
                s <= Calc_ND;
              end if;
            else
              s <= Calc_dN;
            end if;
          else
            dN := to_unsigned(0,16);
            ND := to_unsigned(0,16);
            s  <= Idle;
          end if;
          Busy_C  <= '1';
          Reset_C <= '1';
          
        -------------------------------------------------------
        when Calc_MOD =>
        -------------------------------------------------------
          absDeltaN := unsigned(abs(NT_C - N));
            If    (dir(3)=dir(2) and dir(2)/=dir(1) and dir(1)/=dir(0)) then  -- reduce  Modifier
              If absDeltaN > to_unsigned(64,20) then 
                factor := to_unsigned(64,8);
              else
                factor := 128 - absDeltaN(7 downto 0);
              end if;  
            elsif (dir(3)=dir(2) and dir(2)/=dir(1) and dir(1) =dir(0)) then  -- enlarge Modifier
              If absDeltaN > to_unsigned(64,20) then
                factor := to_unsigned(255,8);
              else
                factor := 128 + absDeltaN(7 downto 0);
              end if;
            else
              factor := to_unsigned(128,8);
            end if;
          Modifier40b := Modifier * "000000000000000000000000"&factor / 128;
          Modifier := Modifier40b(31 downto 0);
          Busy_C  <= '1';
          Reset_C <= '1';
          s <= Calc_ND;
              
        -------------------------------------------------------
        when Calc_ND  =>
        -------------------------------------------------------
          dNsquare := dN * dN;
          If EnableMOD_C = '0' then
            ND64bitfp := MODref_C * dNsquare;
          else
            ND64bitfp := Modifier * dNsquare;
          end if;
          ND := ND64bitfp(47 downto 32);
          Busy_C  <= '1';
          Reset_C <= '1';
          s <= Idle;
          
        -------------------------------------------------------
        when WaitOneClk  =>
        -------------------------------------------------------
          Busy_C  <= '1';
          Reset_C <= '1';
          s <= Calc_dN;
          
        -------------------------------------------------------
--        when Done    =>
        -------------------------------------------------------
--          Busy_C  <= '0';
--          Reset_C <= '0';
--          s <= Idle;
      
      ----------------------------------------------------------
      end case;
      ----------------------------------------------------------
    
      r_C <= r;
      N_C <= N;
      dN_C <= dN;
      ND_C <= ND;
      DirOut_C <= dir(0);
      MOD_C  <= Modifier;
    
    end process;
    
    state_as_vector <= std_logic_vector(to_unsigned(state'pos(s),4));
    
-------------------------------------------------------------------        
    SyncETrigger : process
-------------------------------------------------------------------
    begin
      wait until rising_edge(clk_C);
      Esr <= Esr(1 downto 0) & ETrigger_C;
    end process;
    
-------------------------------------------------------------------        
    SyncSWDTTrigger : process
-------------------------------------------------------------------
    begin
      wait until rising_edge(clk_C);
      SWDTsr <= SWDTsr(1 downto 0) & SWDTTrigger_C;
    end process;
    
  end Behavioral;

Die FSM bleibt bei einem state_as_vector = "0011" hängen. Ich nehme an, 
das ist der Zustand Calc_dN (wie vermutet).

Gruß
Flo

Autor: Rick Dangerus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Florian Rems schrieb:
> when Calc_dN  =>
>         ------------------------------------------------------
>           if dir(0)=dir(1) then
>             If    busyDIV='0' and startDIV='0' then
...
>             elsif busyDIV='0' and startDIV='1' then
...
>             else
>               s <= Calc_dN;
>             end if;
>           else
...
>           end if;

Damit s = calc_dN bleibt, müssen folgende Bedingungen erfüllt sein: 
dir(0)=dir(1) und busyDIV=1. Und genau das ist offenbar der Fall...
Kannst Du Dir dir(0), dir(1), busyDIV und startDIV auch noch mit 
ausgeben lassen?

Rick
busyDIV startDIV gehe in else-Zweig
0       0        false
0       1        false
1       0        true 
1       1        true

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für den Hinweis. Seh ich auch so. Der "Divider" ist auch eine FSM, 
mal sehen, ob die vielleicht auch hängen bleibt, eben mit busyDIV='1'.

Was mich allerdings irritiert ist, dass mein Konstrukt stand-alone auf 
dem FPGA NICHT hängen bleibt. In Verbindung mit dem MicroBlaze, wenn der 
FPGA also nahezu voll ist, tritt dieses Problem auf. Dann kann es 
eigentlich kein systematischer Fehler im Code sein?!

Gruß
Flo

Autor: Rick Dangerus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Florian Rems schrieb:
> systematischer Fehler

Hmm. Jetzt wo Du es sagst: Wieviele Clocks verwendest Du? Ist da 
eventuell ein unsauberes Clock-Domain-Crossing verbaut?

Rick

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also der IP-Core arbeitet mit einem Takt, den hole ich mir direkt vom 
Takt des PLB-Buses vom Microblaze. Könnte da vielleicht ein Problem 
bestehen?

>Wieviele Clocks verwendest du?
Ich denke, nur eine. Aber woran erkenne ich das?

Was versteht man unter einem Clock-Domain-Crossing?

Danke für die Hilfe.

Gruß
Flo

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Ich denke, nur eine. Aber woran erkenne ich das?
Am 'event oder rising_edge() bzw. falling_edge().
Aber das hatten wir schon im 
Beitrag "Re: Custom IP-Core hängt sich auf."

> Was versteht man unter einem Clock-Domain-Crossing?
Den Übergang von Signalen von einer Taktdomäne in die andere...
Sitchworte: Eintakten, Synchronisieren, Fifo

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bzgl. Eintakten etc. dürften ja wohl alle "Missetaten" beseitigt sein.
Selbst wenn ich jetzt weiß, dass BusyDIV='1' bleibt, vielleicht weil die 
Divisions-FSM hängen bleibt, nutzt mir das auch nix, weil es ja im 
stand-alone Betrieb funktioniert. Kann es denn an der Anbindung als 
IP-Core liegen? Da werden eigentlich nur den Signalen Register 
zugewiesen und umgekehrt.
Frustrierend ...

Gruß
Flo

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Noch eine Idee: Sind denn Timing-Probleme denkbar. Der Report im Xilinx 
EDK für den IP-Core schreibt:

Clock Information:
------------------
-----------------------------------------------+------------------------ 
---------------------------------------------------------------+-------+
Clock Signal                                   | Clock buffer(FF name) 
| Load  |
-----------------------------------------------+------------------------ 
---------------------------------------------------------------+-------+
SPLB_Clk                                       | 
NONE(motor_controller_ip_0/PLBV46_SLAVE_SINGLE_I/I_SLAVE_ATTACHMENT/I_DE 
CODER/rnw_s_h)|  886   |
motor_controller_ip_0/USER_LOGIC_I/CON/C/Busy_C| 
NONE(motor_controller_ip_0/USER_LOGIC_I/CON/LOG/Mode_LOG_0) 
| 3     |
-----------------------------------------------+------------------------ 
---------------------------------------------------------------+-------+
INFO:Xst:2169 - HDL ADVISOR - Some clock signals were not automatically 
buffered by XST with BUFG/BUFR resources. Please use the buffer_type 
constraint in order to insert these buffers to the clock signals to help 
prevent skew problems.

Asynchronous Control Signals Information:
----------------------------------------
------------------------------------------------------------------------ 
----------------------------+------------------------------------------- 
--------------------+-------+
Control Signal 
| Buffer(FF name)                                               | Load 
|
------------------------------------------------------------------------ 
----------------------------+------------------------------------------- 
--------------------+-------+
motor_controller_ip_0/USER_LOGIC_I/CON/C/Reset_C(motor_controller_ip_0/U 
SER_LOGIC_I/CON/C/Reset_C:Q)| 
NONE(motor_controller_ip_0/USER_LOGIC_I/CON/instSWDT/count_21)| 24    |
------------------------------------------------------------------------ 
----------------------------+------------------------------------------- 
--------------------+-------+

Timing Summary:
---------------
Speed Grade: -4

   Minimum period: 18.272ns (Maximum Frequency: 54.729MHz)
   Minimum input arrival time before clock: 15.577ns
   Maximum output required time after clock: 5.833ns
   Maximum combinational path delay: No path found

Clock ist 50 MHz. Ist das vielleicht zu knapp? Weiß jemand, wie man 
probeweise den Takt verringert?

Vielen Dank für jeglichen Tipp.

Gruß
Flo

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Clock ist 50 MHz. Ist das vielleicht zu knapp?
Nein, das würde reichen.

Aber du hast offenbar doch noch ein paar weitere Takte in deinem Design, 
erkennbar (wie gesagt) an 'event oder rising_edge() bzw. falling_edge().
Sieh dir die mal genauer an.

Autor: Rick Dangerus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das sieht komisch aus: motor_controller_ip_0/USER_LOGIC_I/CON/C/Busy_C
Sind da doch ausversehen mehrere Clockdomains drin?!

Mit der Taktfrequenz das passt schon, solange Du keine Timing-Errors 
(Timingscore > 0) hast.

Rick

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jetzt sieht das Ganze so aus.

======================================================================== 
=
TIMING REPORT

NOTE: THESE TIMING NUMBERS ARE ONLY A SYNTHESIS ESTIMATE.
      FOR ACCURATE TIMING INFORMATION PLEASE REFER TO THE TRACE REPORT
      GENERATED AFTER PLACE-and-ROUTE.

Clock Information:
------------------
-----------------------------------+------------------------------------ 
---------------------------------------------------+-------+
Clock Signal                       | Clock buffer(FF name) 
| Load  |
-----------------------------------+------------------------------------ 
---------------------------------------------------+-------+
SPLB_Clk                           | 
NONE(motor_controller_ip_0/PLBV46_SLAVE_SINGLE_I/I_SLAVE_ATTACHMENT/I_DE 
CODER/rnw_s_h)|  887   |
-----------------------------------+------------------------------------ 
---------------------------------------------------+-------+
INFO:Xst:2169 - HDL ADVISOR - Some clock signals were not automatically 
buffered by XST with BUFG/BUFR resources. Please use the buffer_type 
constraint in order to insert these buffers to the clock signals to help 
prevent skew problems.

Asynchronous Control Signals Information:
----------------------------------------
------------------------------------------------------------------------ 
----------------------------+------------------------------------------- 
--------------------+-------+
Control Signal 
| Buffer(FF name)                                               | Load 
|
------------------------------------------------------------------------ 
----------------------------+------------------------------------------- 
--------------------+-------+
motor_controller_ip_0/USER_LOGIC_I/CON/C/Reset_C(motor_controller_ip_0/U 
SER_LOGIC_I/CON/C/Reset_C:Q)| 
NONE(motor_controller_ip_0/USER_LOGIC_I/CON/instSWDT/count_14)| 24    |
------------------------------------------------------------------------ 
----------------------------+------------------------------------------- 
--------------------+-------+

Timing Summary:
---------------
Speed Grade: -4

   Minimum period: 21.721ns (Maximum Frequency: 46.038MHz)
   Minimum input arrival time before clock: 16.085ns
   Maximum output required time after clock: 4.772ns
   Maximum combinational path delay: No path found

Dazu muss ich sagen, dass jetzt zwei der IP-Cores dabei sind, so wie es 
am Schluss auch funktionieren soll.
Ist das mit dem Timing immer noch in Ordnung? jetzt hätten wir ja 
weniger als 50 Mhz.
Es bleibt leider immer noch hängen, genau wie oben.

Gruß
Flo

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Device utilization summary:
---------------------------

Selected Device : 3s500efg320-4

 Number of Slices:                     5142  out of   4656   110% (*)
 Number of Slice Flip Flops:           5037  out of   9312    54%
 Number of 4 input LUTs:               7757  out of   9312    83%
    Number used as logic:              7206
    Number used as Shift registers:     295
    Number used as RAMs:                256
 Number of IOs:                          54
 Number of bonded IOBs:                  54  out of    232    23%
    IOB Flip Flops:                      16
 Number of BRAMs:                        16  out of     20    80%
 Number of MULT18X18SIOs:                17  out of     20    85%
 Number of GCLKs:                         4  out of     24    16%
 Number of DCMs:                          1  out of      4    25%

WARNING:Xst:1336 -  (*) More than 100% of Device resources are used

Wie kann es sein, dass ich den Bitstream trotz (*) auf den FPGA laden 
kann?

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Device utilization summary: 110%
Sagt wer?
Die Synthese?
Oder P&R?

> Wie kann es sein, dass ich den Bitstream trotz (*) auf den FPGA laden
> kann?
Jetzt muß P&R endlich mal was tun und etwas optimieren...

>    Minimum period: 21.721ns (Maximum Frequency: 46.038MHz)
Das ist nach der Synthese...
> Ist das mit dem Timing immer noch in Ordnung?
... da kann bei richtigen constaints schon noch was verbessert werden.
> jetzt hätten wir ja weniger als 50 Mhz.
Also die Frage: du hast den Takt korrekt constrained?

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
110% sagt der Synthese-Report in Xilinx EDK.

Ich habe gar nichts constrained :-).

Gruß
Flo

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Habe gerade versucht, die Divisionskomponente quasi auszuschalten und 
einen festen Wert für dN vorgegeben. Damit tritt das Aufhängen nicht 
mehr auf. Es muss also was mit der Divisions-FSM zu tun haben. Das ist 
allerdings keine Lösung, denn irgendwie muss ich diese Division 
durchführen.

Gruß
Flo

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Es muss also was mit der Divisions-FSM zu tun haben.
Woher hast du die?

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Von Dir: Beitrag FPGA/VHDL Timing

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habs geahnt...  :-o
Der läuft eigentlich recht gut.
Du solltest dir die Geschichte mit dem Takt nochmal anschauen.

> Ich habe gar nichts constrained :-)
Gib doch mal einen constraint auf den Takt vor.

Autor: Florian Rems (flo0815)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Folgendes stand tatsächlich im UCF File:

TIMESPEC TS_sys_clk_pin = PERIOD sys_clk_pin 20000 ps;

Das hat das EDK reingeschrieben. Was wäre denn eine sinnvolle Änderung?

Gruß
Flo

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [vhdl]VHDL-Code[/vhdl]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.