Simulation funktioniert, im CPLD werden Signale ignoriert!

[Roman D. (smarties)]

Hallo,

ich arbeite mit einem Coolrunner2 CPLD und möchte mir zwei 
Phasenverschobene Signale erzeugen wobei die Phasenverschiebung in 
90Grad Schritten einstellbar sein soll. Gelöst habe ich das mit vier 
2-bit Countern mit verschiedenen preload Werten. Die Ausgangssignale mit 
1/4 der CLK Frequenz werden über einen MUX ausgeben.
In der Simulation funktioniert das auch perfekt, nur im CPLD eben nicht. 
Ich kann an den beiden Pins zur Phasenauswahl beliebige Signale anlegen, 
die Phasenverschiebung bleibt immer auf 0Grad.
Wenn ich mir im Xilinx WebPack die RTL Schematic ansehe, ist der Port 
PHSEL nicht verbunden (siehe Anhang).
Vielleicht kann mir in dieser Angelegenheit jemand helfen. Ich bin schon 
etwas verzweifelt!

Danke, Roman

Hier der Code:
count.vhd

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

entity count is
    Port ( CLK : in  STD_LOGIC;
           RST : in  STD_LOGIC;
           PH0 : out  STD_LOGIC;
           PH1 : out  STD_LOGIC;
           PH2 : out  STD_LOGIC;
           PH3 : out  STD_LOGIC
    );
end count;

architecture Behavioral of count is
   signal sCNT0 : STD_LOGIC_VECTOR(1 downto 0);
   signal sCNT1 : STD_LOGIC_VECTOR(1 downto 0);
   signal sCNT2 : STD_LOGIC_VECTOR(1 downto 0);
   signal sCNT3 : STD_LOGIC_VECTOR(1 downto 0);
begin

   count : process (CLK, RST)
   begin
      if RST = '0' then
         sCNT0 <= "00";
         sCNT1 <= "11";
         sCNT2 <= "10";
         sCNT3 <= "01";
      elsif rising_edge(CLK) then
         PH0 <= NOT(sCNT0(1));
         PH1 <= NOT(sCNT1(1));
         PH2 <= NOT(sCNT2(1));
         PH3 <= NOT(sCNT3(1));
         sCNT0 <= STD_LOGIC_VECTOR(unsigned(sCNT0) + 1);
         sCNT1 <= STD_LOGIC_VECTOR(unsigned(sCNT1) + 1);
         sCNT2 <= STD_LOGIC_VECTOR(unsigned(sCNT2) + 1);
         sCNT3 <= STD_LOGIC_VECTOR(unsigned(sCNT3) + 1);
      end if;
   end process count;
      
end Behavioral;

comb.vhd

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity comb is
    Port ( PH0 : in  STD_LOGIC;
           PH1 : in  STD_LOGIC;
           PH2 : in  STD_LOGIC;
           PH3 : in  STD_LOGIC;
           PHSEL : in  STD_LOGIC_VECTOR (1 downto 0);
           LEDEN : in  STD_LOGIC_VECTOR (1 downto 0);
           TOFO : out  STD_LOGIC;
           LEDOA : out  STD_LOGIC;
           LEDOB : out  STD_LOGIC);
end comb;

architecture Behavioral of comb is
   signal sEN   : STD_LOGIC;
   signal sINT0 : STD_LOGIC;
   signal sINT1 : STD_LOGIC;
   signal sINT2 : STD_LOGIC;
   signal sINT3 : STD_LOGIC;
   signal sLEDO : STD_LOGIC;
begin

   sEN   <= LEDEN(1) OR LEDEN(0);
   TOFO  <= sEN AND PH0;
   sINT0 <= NOT(PHSEL(1)) AND NOT(PHSEL(0)) AND PH0;
   sINT1 <= NOT(PHSEL(1)) AND PHSEL(0) AND PH1;
   sINT2 <= PHSEL(1) AND NOT(PHSEL(0)) AND PH2;
   sINT3 <= PHSEL(1) AND PHSEL(0) AND PH3;
   sLEDO <= sINT0 OR sINT1 OR sINT2 OR sINT3;
   LEDOA <= sLEDO;
   LEDOB <= sLEDO;

end Behavioral;

clkgen.vhd

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity clkgen is
    Port ( CLK   : in   STD_LOGIC;
           RST   : in   STD_LOGIC;
           PHSEL : in   STD_LOGIC_VECTOR (1 downto 0);
           LEDEN : in   STD_LOGIC_VECTOR (1 downto 0);
           TOFO  : out  STD_LOGIC;
           LEDOA : out  STD_LOGIC;
           LEDOB : out  STD_LOGIC);
end clkgen;

architecture Behavioral of clkgen is

   component comb is
       Port ( PH0 : in  STD_LOGIC;
              PH1 : in  STD_LOGIC;
              PH2 : in  STD_LOGIC;
              PH3 : in  STD_LOGIC;
              PHSEL : in  STD_LOGIC_VECTOR (1 downto 0);
              LEDEN : in  STD_LOGIC_VECTOR (1 downto 0);
              TOFO : out  STD_LOGIC;
              LEDOA : out  STD_LOGIC;
              LEDOB : out  STD_LOGIC);
   end component comb;
   
   component count is
    Port ( CLK : in  STD_LOGIC;
           RST : in  STD_LOGIC;
           PH0 : out  STD_LOGIC;
           PH1 : out  STD_LOGIC;
           PH2 : out  STD_LOGIC;
           PH3 : out  STD_LOGIC);
   end component count;

   signal sPH0 : STD_LOGIC;
   signal sPH1 : STD_LOGIC;
   signal sPH2 : STD_LOGIC;
   signal sPH3 : STD_LOGIC;
begin

   inst_comb : comb
   port map (
      PH0      => sPH0,
      PH1      => sPH1,
      PH2      => sPH2,
      PH3      => sPH3,
      PHSEL    => PHSEL,
      LEDEN    => LEDEN,
      TOFO     => TOFO,
      LEDOA    => LEDOA,
      LEDOB    => LEDOB
      );
      
   inst_count : count
   port map (
      CLK      => CLK,
      RST      => RST,
      PH0      => sPH0,
      PH1      => sPH1,
      PH2      => sPH2,
      PH3      => sPH3
      );

end Behavioral;

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

Offenbar  hast du Probleme mit der Initialisierung der Zähler. Die 
Synthese geht davon aus, dass alle vier mit Null starten und so immer 
das selbe ausgeben. Ergo ist der Wahleingamg nutzlos. Merke: Resetwert 
/= Initialwert.
Dein Reset hier ist (wie üblich) nutzlos und unnötig.


Ich mache einen Schritt zurück und frage mich: warum eigentlich so 
umständlich?
Warum nimmst du nicht ein einziges 4-Bit-Schieberegister, initialisierst 
das mit "1100" und lässt über den Mux ein Bit davon ausgeben?
20 Zeilen Code in einem Modul und fertig....

[Roman D. (smarties)]

Vielen Dank für die Info, an die Initialisierung habe ich nicht gedacht! 
Ich habe den Code umgebaut und mit einem Schieberegister realisiert, das 
funktioniert, jedoch habe ich ein ganz komisches Phänomen.
Ich gebe dem CPLD folgenden Ablauf vor:
100us Phase 0
1,5ms Pause (sEN = '0')
100us Phase 90
1,5ms Pause (sEN = '0')
100us Phase 180
1,5ms Pause (sEN = '0')
100us Phase 270
1,5ms Pause (sEN = '0')
20ms Pause
Das ganze wird in einer Endlosschleife wiederholt. Wenn ich mir den 
Output am Oszi ansehe, habe ich manchmal (jeder 10. - 20. Durchlauf) ein 
fehlerhaftes Signal.
11100110011... oder
10110011001... oder
00011001100... oder
10001000100... oder ähnliche

wie kann das passieren?
der CPLD läuft mit 80MHz

Vielen Dank für die Hilfe!
Roman

entity clkgen is
  port (
    CLKI    : in  STD_LOGIC;
    RST     : in  STD_LOGIC;
    LEDEN  : in  STD_LOGIC_VECTOR(1 downto 0);
    PHSEL   : in  STD_LOGIC_VECTOR(1 downto 0);
    TOFO    : out STD_LOGIC;
    LEDOA   : out STD_LOGIC;
    LEDOB   : out STD_LOGIC
    );
end clkgen;

architecture behavioural of clkgen is
    signal sPH0    : STD_LOGIC;
    signal sPH1    : STD_LOGIC;
    signal sPH2    : STD_LOGIC;
    signal sPH3    : STD_LOGIC;
    signal sINT0   : STD_LOGIC;
    signal sINT1   : STD_LOGIC;
    signal sINT2   : STD_LOGIC;
    signal sINT3   : STD_LOGIC;
    signal sEN     : STD_LOGIC;
    signal sLEDO   : STD_LOGIC;
    signal sREG    : STD_LOGIC_VECTOR(3 downto 0);
    constant cINIT : STD_LOGIC_VECTOR(3 downto 0) := "1100";
begin
  generate: process (CLKI, RST)
  begin
    if RST = '0' then
      sREG <= cINIT;
      sPH0 <= sREG(3);
      sPH1 <= sREG(0);
      sPH2 <= sREG(1);
      sPH3 <= sREG(2);
    else 
      if rising_edge(CLKI) then
        if sEN = '1' then
          sPH0 <= sREG(3);
          sPH1 <= sREG(0);
          sPH2 <= sREG(1);
          sPH3 <= sREG(2);
          sREG <= sREG(2 downto 0) & sREG(3); -- rotate left
        else
          sREG  <= cINIT;
        end if;
      end if;
    end if;
  end process;
  
  sEN   <= LEDEN(1) OR LEDEN(0);
  TOFO  <= sPH0 AND sEN;
  sINT0 <= NOT(PHSEL(1)) AND NOT(PHSEL(0)) AND sPH0;
  sINT1 <= NOT(PHSEL(1)) AND PHSEL(0) AND sPH1;
  sINT2 <= PHSEL(1) AND NOT(PHSEL(0)) AND sPH2;
  sINT3 <= PHSEL(1) AND PHSEL(0) AND sPH3;
  sLEDO <= sINT0 OR sINT1 OR sINT2 OR sINT3;
  LEDOA <= sLEDO AND sEN;
  LEDOB <= sLEDO AND sEN;
  
end behavioural;

[bko (Gast)]

Evtl. kommt es daher das "sEN" nicht einsyncronisiert ist.

Mindestens mit einem Flipflop z.b. so in etwa:

 (...)
> if rising_edge(CLKI) then
>    sEN_reg <= sEN
>    if sENreg = '1' then
 (...0

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

Falls das so ist, dann hast du folgenden Effekt:
 http://www.lothar-miller.de/s9y/archives/64-State-Machine-mit-asynchronem-Eingang.html
Denn (d)ein Schieberegister ist nichts anderes wie eine FSM...