[VHDL] FSM springt in states ohne trigger

[Steffen Kern (Gast)]

Einen guten Morgen miteinander,

ich habe eine FSM in VHDL, die nacheinander states abarbeiten soll.

Die Ports start, reset und push_button2 sind jeweils push_buttons mit 
debounce.
Nachdem ein Reset ausgeführt wurde, sollte die State-Machine eigentlich 
in den IDLE-state springen und im ready_state "00" verweilen, bis 
entweder start <= '1' gesetzt wird durch einen Pushbutton oder ein Reset 
kommt per Pushbutton.

Nach dem Reset springt die FSM direkt in den SENDING_ADDRESS_BITS-state.

Irgendjemand eine Idee warum?

Wenn ich den SENDING_ADDRESS_BITS-state auskommentiere und nur im 
IDLE-state verweile, funktioniert alles wunderbar.

Gruß,
Steffen

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity spi_transceiver is
    Port (
        SCLK_IN             : in  STD_LOGIC;                            -- Base frequency clock. 
    
        SCLK                : out STD_LOGIC;                           -- Master Clock for SPI-Slave.
        CSB                 : out STD_LOGIC;                            -- Chip select to enable/disable data transfers.
        SDI                 : out STD_LOGIC;                            -- Serial data stream to DAC SPI-Interface.
        SDO                 : in  STD_LOGIC;                            -- Serial data stream from DAC SPI-Interface

        start               : in  STD_LOGIC;                            -- Start tx/rx process.
        reset               : in  STD_LOGIC;                            -- Reset to default state.
        done                : out STD_LOGIC;                            -- Status bit to indicate end of tx/rx process.

        tx_address_vector   : in  STD_LOGIC_VECTOR (11 downto 0);       -- Address vector inluding R/W-Bit.
        tx_data_vector      : in  STD_LOGIC_VECTOR (7 downto 0);        -- Data vector to send to DAC-SPI.
        rx_data_vector      : out STD_LOGIC_VECTOR (7 downto 0);        -- Received data from SPI-slave.
        
        test_led0               : out STD_LOGIC;        -- LED for indicating successfull write and read operation.
        test_led1               : out STD_LOGIC;
        test_led2               : out STD_LOGIC;
        test_led3               : out STD_LOGIC;
        push_button2            : in  STD_LOGIC
        
    );
end spi_transceiver;

architecture Behavioral of spi_transceiver is

    signal SPI_counter  : integer range 0 to 43 := 0;
    signal SPI_enable   : std_logic := '0';
    
    type state is (IDLE, SENDING_ADDRESS_BITS);
    signal sig_state    : state := IDLE;
    
    -- Debug-signals
    signal tmp_test_led0        : std_logic := '0';
    signal tmp_test_led1        : std_logic := '0';
    signal tmp_test_led2        : std_logic := '0';
    signal tmp_test_led3        : std_logic := '0';
    signal ready_state          : std_logic_vector(1 downto 0) := (others => '0');

begin

    test_led0   <= tmp_test_led0;
    test_led1   <= tmp_test_led1;
    test_led2   <= tmp_test_led2;
    test_led3   <= tmp_test_led3;
    ready_state <= start & SPI_enable;

    process(SCLK_IN)
    begin
    
        -- Connect output SCLK synchronously to SCLK_IN
        SCLK <= SCLK_IN;
        
        -- Reset logic
        if(reset = '1') then
            CSB             <= '1';                     -- Make SPI closed to communication.
            done            <= '0';
            SDI             <= '0';
            
            SPI_counter     <= 0;
            SPI_enable      <= '0';
            sig_state       <= IDLE;
            
            tmp_test_led0 <= '1';
            tmp_test_led1 <= '0';
            tmp_test_led2 <= '0';
            tmp_test_led3 <= '0';

        else
        
            case sig_state is
                when IDLE =>
                        -- ready_state <= start & SPI_enable;
                        case ready_state is
                            when "00" =>    -- NOT RESET, NOT STARTED YET = IDLE - DEBUG-LEDs: 0010
                                    tmp_test_led0 <= '0';
                                    tmp_test_led1 <= '0';
                                    tmp_test_led2 <= '1';
                                    tmp_test_led3 <= '0';
                            when "01" =>    -- ERROR-STATE - DEBUG-LEDs: 1010
                                    tmp_test_led0 <= '1';
                                    tmp_test_led1 <= '0';
                                    tmp_test_led2 <= '1';
                                    tmp_test_led3 <= '0';
                                    
                            when "10" =>    -- Enable tx/rx-process - DEBUG-LEDs: 0100
                                    SPI_counter     <= 0;
                                    SPI_enable      <= '1';                     -- Start the tx/rx-process.
                                    sig_state       <= SENDING_ADDRESS_BITS;    -- Address-Bits-Transmission is always the first thing to do.

                                    tmp_test_led0 <= '0';
                                    tmp_test_led1 <= '1';
                                    tmp_test_led2 <= '0';
                                    tmp_test_led3 <= '0';
                                                        
                            when "11" =>    -- ERROR-STATE - DEBUG-LEDs: 1100
                                    tmp_test_led0 <= '1';
                                    tmp_test_led1 <= '1';
                                    tmp_test_led2 <= '0';
                                    tmp_test_led3 <= '0';
                                    
                            when others =>  -- ERROR-STATE

                        end case; -- ready_state

                when SENDING_ADDRESS_BITS =>
                
                        if(push_button2 = '1') then
                            sig_state <= IDLE;
                        end if;
                        -- DEBUG: 0110
                        tmp_test_led0 <= '0';
                        tmp_test_led1 <= '1';
                        tmp_test_led2 <= '1';
                        tmp_test_led3 <= '0';
                
                when others =>
                        -- It should not occur to come into this state here.
                        sig_state   <= IDLE;
                        SDI         <= '0';
                        SPI_enable  <= '0';
                        
                        -- DEBUG: 0101
                        tmp_test_led0 <= '0';
                        tmp_test_led1 <= '1';
                        tmp_test_led2 <= '0';
                        tmp_test_led3 <= '1';
            end case;
            
        end if; --RESET
    
    end process;

end Behavioral;

[Alexander F. (alexf91)]

Hast du das Design simuliert oder direkt in der Hardware getestet?

Mir fällt nämlich auf, dass du keinen Takt im Design hast.
Es reicht nicht, SCLK_IN in die Sensitivity-List zu schreiben, das ist 
nur für die Simulation relevant.

[Steffen Kern (Gast)]

Beides.
Kannst du das mit dem Takt etwas genuer erklären, oder Referenzen dazu 
aufführen?

[Steffen Kern (Gast)]

Hmm... meinst du vielleicht, dass ich innerhalb meines processes noch 
ein rising_edge(clk_SCLK) bräuchte oder clk_SCLK'event AND clk_SCLK = 
'1', je nachdem was man präferiert.

[Steffen Kern (Gast)]

Ich habe im Internet noch etwas rumgesucht und bin selbst auf die Lösung 
gekommen.
Die Sensitivity List ist wirklich rein für Simulation gedacht.
D.h. mein process wurde kombinatorisch synthetisiert.
Wenn man einen process taktsynchron haben will, brauch man immer die 
rising/falling_edge außerhalb seiner Verarbeitungslogik.

[Bronco (Gast)]

Wenn Du planst, dies in einem FPGA zu realisieren, solltest Du unbedingt 
einen Takt verwenden. Idealerweise einen einzigen Takt für die gesamte 
Logik.
Mit Takt meine ich nicht so etwas wie das SCKL-Signal des SPI, sondern 
einen "Systemtakt", der idealerweise deutlich schneller ist, als alle 
vom FPGA zu verarbeitenden I/O-Signale.
Der SPI-Takt würde dann zu einem weiteren I/O-Signal "degradiert".

Die Taktung ist notwendig, um die unterschiedlichen Laufzeiten der 
internen Signale zu synchronisieren.