finite-state-machine problems => Synopsys 
Author Message
 finite-state-machine problems => Synopsys

Hi everyone,

I have synthesized the following finite state machine using Synopsys.
RTL and gate-level simulations don't match. Infact the gate-level simulations give undefined (X) outputs.
Is this the correct way to write a synthesisable finite state machine? The RTL and testbench are included.

Any help will be highly appreciated.

Thanks,
Michele.

--VHDL RTL model

-- define types

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

PACKAGE FSM_types IS

     subtype BIT_8 is STD_LOGIC_VECTOR ( 7 downto 0 ) ;

    subtype BIT_5 is STD_LOGIC_VECTOR ( 4 downto 0 ) ;

    subtype BIT_4 is STD_LOGIC_VECTOR ( 3 downto 0 ) ;

-- finite machine states  
   TYPE state IS ( Resetting, SetMode, State1, State2, State3, State4, State5, State6 ); --state can take
one of these values

 END FSM_types;

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
use IEEE.std_logic_arith.all ;

use WORK.FSM_types.ALL;

ENTITY RS_FSM IS
  PORT ( --INPUT LINES
        Clock : IN STD_LOGIC;          
        Reset : IN STD_LOGIC;          
        Mode_port : IN STD_LOGIC;      
        Start : IN STD_LOGIC;          
        m : in BIT_4;
        t : in BIT_5 ;

        FinishedState1 : in STD_LOGIC;
        FinishedState2 : in STD_LOGIC;
        FinishedState3 : in STD_LOGIC;

        CYCLES : in BIT_8;    

         -- OUTPUT LINES

        m_out : out BIT_4;
        t_out : out BIT_5 ;

--State1
        Reset_State1 : out STD_LOGIC;           -- reset signal
        WR : out STD_LOGIC;
                       --enables writing symbols to the stack
        ComputeState1 : out STD_LOGIC;          

--State2        
        Reset_State2 : out STD_LOGIC;           -- reset signal
        StartState2 : out STD_LOGIC;          

        CHIpmode : out STD_LOGIC;
        Exponent : out BIT_8;

        Reset_Value : out STD_LOGIC;           -- reset signal
        StartState3 : out STD_LOGIC;

        Mode_EXPONENT : out STD_LOGIC;
        Mode_INVERSE : out STD_LOGIC;

         StartCorrectErrors : out STD_LOGIC;
         RD : out STD_LOGIC    
--enables reading symbols from the stack

        );
END RS_FSM;

ARCHITECTURE synthesizable OF RS_FSM IS

        SIGNAL next_state : STATE;

    BEGIN

      fsm_function: PROCESS(clock,reset,Mode_port,Start,m,t,
FinishedState1,FinishedState2,FinishedState3,CYCLES)
   --     fsm_function: PROCESS

        BEGIN

         IF Reset = '1' THEN

               next_state <= Resetting;

         -- reset all the registers in all the RS modules

     elsif  CLOCK'EVENT AND CLOCK='1' then

      CASE next_state IS

                     WHEN Resetting => -- reset

         -- reset all the registers in all the RS modules
                         -- Reset_Encoder <= '1';  
                          Reset_State1 <= '1';  
                          Reset_State2 <= '1';  
                          Reset_Value <= '1';  

                          ComputeState1 <= '0';          
                          StartState2 <= '0';
                          StartState3 <= '0';
                          StartCorrectErrors <= '0';

                            WR <= '0';
                            RD <= '0';

                          Exponent <= "00000000";

                          m_out <= m;

                          t_out <= t;  

                      IF (Start = '1' AND reset = '0') then

                          next_state <= SetMode;

                      ELSE
                        next_state <= Resetting;
                      END IF;

                     WHEN SetMode =>

                     IF Mode_port = '0' then

                          next_state <= State1;

                     else

                          next_state <= SetMode;

                     END IF;

                     WHEN State1 =>

                           next_state <= State2;

                           Reset_State1 <= '0';  

                            ComputeState1  <= '1';
                            WR <= '1';
                            RD <= '0';

                     WHEN State2 =>

                            ComputeState1  <= '0';
                            WR <= '1';
                            RD <= '0';

                            if FinishedState1 = '1' then

                            next_state <= State3;

                              Reset_State1 <= '1';  
                              WR <= '0';

                             else

                               next_state <= State2;

                             end if;

                     WHEN State3 =>              

                          next_state <= State4;                  

                          Reset_State2 <= '0';  

                          StartState2  <= '1';

                          CHIpmode <= '0';
                          Exponent <= "11111110";  

                     WHEN State4 =>                                

                            StartState2  <= '0';

                            if FinishedState2 = '1' then

                              next_state <= State5;
                              Reset_State2 <= '1';

                             else

                               next_state <= State4;

                             end if;

                     WHEN  State5 =>          

                          next_state <= State6;

                          Reset_Value <= '0';  
                          StartState3  <= '1';

                            Mode_EXPONENT <= '1';
                            Mode_INVERSE  <= '0';
                            Exponent <= "11111111";

                     WHEN  State6 =>        

                            StartState3  <= '0';

                            if CYCLES = "00000001" then

                            StartCorrectErrors  <= '1';
                            RD <= '1';
                            WR <= '0';

                            end if;

                            if FinishedState3 = '1' then

                              Reset_Value <= '1';  
                              next_state <= SetMode;

                             else

                               next_state <= State6;

                             end if;

                  WHEN  others =>
                           next_state <= Resetting;

                END CASE;
             END IF;
    END PROCESS fsm_function;

END synthesizable;

--testbench

package CONSTANTS is

   constant PERIOD : time := 20 ns ; --50 MHz Clock

   constant HALF_PERIOD : time := PERIOD / 2 ;

end CONSTANTS ;

library STD ;

library IEEE ;

use STD.textio.all ;

use IEEE.std_logic_1164.all ;

use IEEE.std_logic_textio.all ;

use WORK.constants.all ;

use WORK.FSM_types.ALL;

use WORK.all ;

entity TOP is

end TOP;

architecture TF1 of TOP is

signal  Clock : STD_LOGIC := '0';          
signal  Reset :  STD_LOGIC;           -- reset signal
signal  Mode_port :  STD_LOGIC;          
signal  Start : STD_LOGIC;        
signal  m :  BIT_4;
signal  t :  BIT_5;

signal  FinishedState1 :  STD_LOGIC;
signal  FinishedState2 :  STD_LOGIC;
signal  FinishedState3 :  STD_LOGIC;

         -- OUTPUT LINES

--State1
signal  WR :  STD_LOGIC;
                       --enables writing symbols to the stack
signal  ComputeState1 :  STD_LOGIC;          

--State2-Massey  
   signal Reset_State2  : STD_LOGIC;
   signal       StartState2 : STD_LOGIC;          
signal  CHIpmode :  STD_LOGIC;
signal  Exponent :  BIT_8;

signal   StartCorrectErrors :  STD_LOGIC;
signal   RD :  STD_LOGIC;      
--enables reading symbols from the stack

   signal StartState3 :  STD_LOGIC;

   signal Mode_port_INVERSE : STD_LOGIC ; --:= '0';    -- mode for the
inverse/exponent CHIP
   signal Mode_port_EXPONENT : STD_LOGIC ; --:= '1';
    signal Cycles : BIT_8;

--FSM

signal m_out : BIT_4;
signal t_out : BIT_5;

signal Reset_State1  : STD_LOGIC;

signal ERROR_IN : STD_LOGIC := '0';
signal Reset_Value : STD_LOGIC;

component RS_FSM  
  PORT ( --INPUT LINES
        Clock : IN STD_LOGIC;          
        Reset : IN STD_LOGIC;          
        Mode_port : IN STD_LOGIC;          
       Start : IN STD_LOGIC;          
        m : in BIT_4;
        t : in BIT_5 ;

        FinishedState1 : in STD_LOGIC;
        FinishedState2 : in STD_LOGIC;
        FinishedState3 : in STD_LOGIC;

         CYCLES : in BIT_8;              

         -- OUTPUT LINES

        m_out : out BIT_4;
        t_out : out BIT_5 ;

--State1
        Reset_State1 : out STD_LOGIC;        
        WR : out STD_LOGIC;
                       --enables writing symbols to the stack
        ComputeState1 : out STD_LOGIC;          

--State2
        Reset_State2 : out STD_LOGIC;           -- reset signal
        StartState2 : out STD_LOGIC;            

        CHIpmode : out STD_LOGIC;
        Exponent : out BIT_8;

        Reset_Value : out STD_LOGIC;           -- reset signal
        StartState3 : out STD_LOGIC;
        Mode_EXPONENT : out STD_LOGIC;
        Mode_INVERSE : out STD_LOGIC;

         StartCorrectErrors : out STD_LOGIC;
         RD : out STD_LOGIC      
--enables reading symbols from the stack

        );
end component;  

begin

   UUT : RS_FSM
 PORT MAP( --INPUT LINES
        Clock => Clock,          
        Reset => reset,           -- reset signal
        Mode_port => Mode_port,          
        Start => Start,          
        m => m,
        t => t,
        FinishedState1 => FinishedState1,
        FinishedState2 => FinishedState2,
        FinishedState3 => FinishedState3,
        CYCLES => Cycles,  

        m_out => m_out,
        t_out => t_out,

--State1
        Reset_State1 => Reset_State1,              
        WR => WR,                      
        ComputeState1 => ComputeState1,      

--State2        
        Reset_State2 => Reset_State2,              
        StartState2 => StartState2,          

        CHIpmode => CHIpmode,
        Exponent => Exponent,

        Reset_Value => Reset_Value,
        StartState3 => StartState3,
        Mode_EXPONENT => Mode_port_EXPONENT,
        Mode_INVERSE => Mode_port_INVERSE,

         StartCorrectErrors => StartCorrectErrors,
         RD => RD  
--enables reading symbols from the stack

        );

Reset <= '1','0' AFTER 20 ns;
Clock <=  NOT Clock AFTER HALF_PERIOD when now < 500 ns else Clock; --
Mode_port <= '0';
Start <= '1' ;
t <= "10001";
m <= "1000";
CYCLES <= "00000001";

FinishedState1 <= '1' AFTER 100 ns;
FinishedState2 <= '1' AFTER 200 ns;
FinishedState3 <= '1' AFTER 300 ns;

end TF1 ;

configuration testFixture1 of TOP is

  for TF1

  end for ;

end testFixture1 ;



Fri, 25 Aug 2000 03:00:00 GMT  
 
 [ 1 post ] 

 Relevant Pages 

1. finite state machines, state cad

2. Finite State Machine and Forth

3. Finite State Machines

4. ESTEREL, Forth and finite state machines

5. finite state machines

6. Finite state machine compiler

7. Finite State Machines

8. OO Finite State Machine Language

9. Finite State Machine inherent support

10. cisco_fsm (finite state machine) free tool: pre-announcement

11. Use of a Finite State Machine in testbench code

12. FSMedit - The Finite State Machines Editor - Version 2.0

 

 
Powered by phpBB® Forum Software