SPI Master 1. Übertragung wird verschluckt

[Benjamin (Gast)]

Hallo zusammen,

ich lerne seit ein paar Wochen intensiv VHDL und bin grad dran, ein DAC 
über SPI mittels Spartan3 anzusteuern. Der DAC besitzt 2 Kanäle und die 
Reihenfolge der zu übertragenden Daten sollte so sein (der DAC verlangt 
16 Bits):

1. Übertragung: 0x9002 (Referenzspannung wählen)
2. Übertragung: 0x1XX0 (Wert Kanal A)
3. Übertragung: 0x8XX0 (Wert Kanal B)

Es sind also 3x je 16 Bits zu übertragen. Als SPI Master hab ich den von 
Lothar Miller so ziemlich exakt übernommen (paar Änderungen musst ich 
machen).

Hier mal der SPI Code:

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

entity spi is
  Generic ( crystal_frequency  : integer; -- in Hz
         spi_frequency      : integer; -- in Hz
         data_length      : integer -- Anzahl der zu übertragenden Bits
        );
  PORT ( TX_Data    : in  STD_LOGIC_VECTOR (data_length-1 downto 0); -- Sendedaten
       Data_out  : out STD_LOGIC;
       CS      : out STD_LOGIC;
       SCLK      : out STD_LOGIC;
       TX_Start  : in  STD_LOGIC;
       TX_Done    : out STD_LOGIC;
       clk      : in  STD_LOGIC
      );
end spi;

architecture Behavioral of spi is
  constant frequency_counter_upper_limit : integer := (crystal_frequency/(2*spi_frequency))-1;
  signal frequency_counter : integer range 0 to (crystal_frequency/(2*spi_frequency))  := frequency_counter_upper_limit;

  type states is (idle, active, finished); -- FSM Zustände
  signal spi_state   : states  := idle;
  
  signal spi_clk    : STD_LOGIC;
  signal spi_clk_old  : STD_LOGIC;
  
  signal bit_counter  : integer range 0 to data_length; -- Counter, der die schon rausgeschobenen Bits zählt
  
  signal tx_reg  : STD_LOGIC_VECTOR (data_length-1 downto 0)  := (others=>'0');
begin
  ------ FSM ------
  process (clk)
  begin -- SPI Mode 1: CLK Ruhe Pegel 1, Daten werden bei steigender Flanke ausgegeben und bei fallender eingelesen
    if clk'event and clk = '1' then
      
      if frequency_counter > 0 then -- Clock Enable für den SPI Takt erzeugen, doppelt so schneller Trigger, weil spi_clk jedes Mal nur invertiert wird
        frequency_counter <= frequency_counter - 1;
      else
        frequency_counter <= frequency_counter_upper_limit;
      end if;
      
      spi_clk_old <= spi_clk;
      
      case spi_state is
        when idle =>
          CS       <= '1'; -- inaktiv
          TX_Done     <= '0';
          bit_counter <= data_length;
          spi_clk     <= '1';
          if TX_Start = '1' then
            spi_state   <= active; -- Zustandsübergang
            CS        <= '0';
            frequency_counter <= frequency_counter_upper_limit;
          end if;
          
        when active =>
          if frequency_counter = 0 then
            spi_clk <= not spi_clk;
            if bit_counter = 0 then -- alle Daten rausgeschoben
              spi_clk <= '1';
              spi_state <= finished; -- Zustandsübergang
            end if;
            if spi_clk = '0' then
              bit_counter <= bit_counter - 1;
            end if;
          end if;
          
        when finished =>
          CS      <= '1'; -- inaktiv
          TX_Done  <= '1';
          if TX_Start = '0' then -- warten bis Eingangsflag gelöscht wurde
            spi_state  <= idle; -- Zustandsübergang
          end if;
      end case;
      
    end if;
  end process;
  ------ Sendeschieberegister ------
  process (clk)
  begin
    if clk'event and clk = '1' then
    
      if spi_state = idle then -- im IDLE Zustand die angelegten Daten übernehmen
        tx_reg <= TX_Data;
      end if;
      if spi_state = active and spi_clk = '1' and spi_clk_old = '0' then -- zur steigenden Flanke die Daten rausschieben
        tx_reg <= tx_reg(tx_reg'left-1 downto 0) & tx_reg(0); -- & Operator hängt STD_LOGIC_VECTOR und STD_LOGIC einfach hintereinander, linksschieben
      end if;
      
    end if;
  end process;
  
  SCLK     <= spi_clk;
  Data_out <= tx_reg(tx_reg'left);
  
end Behavioral;

Und der Code der FSM, die die 3 Übertragungen abarbeiten soll:

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

entity threshold is
    Port ( ValueA : in  STD_LOGIC_VECTOR (7 downto 0);
        ValueB : in  STD_LOGIC_VECTOR (7 downto 0);
           WR : in  STD_LOGIC;
        WR_Done  : out STD_LOGIC  := '0';
        Data_out  : out STD_LOGIC;
        CS  : out STD_LOGIC;
        SCLK  : out STD_LOGIC;
           clk : in  STD_LOGIC);
end threshold;

architecture Behavioral of threshold is
  -- Component SPI Deklaration
  component spi is
    Generic ( crystal_frequency  : integer; -- in Hz
           spi_frequency      : integer; -- in Hz
           data_length      : integer -- Anzahl der zu übertragenden Bits
           );
    PORT ( TX_Data    : in  STD_LOGIC_VECTOR (data_length-1 downto 0); -- Sendedaten
         Data_out  : out STD_LOGIC;
         CS      : out STD_LOGIC;
         SCLK      : out STD_LOGIC;
         TX_Start  : in  STD_LOGIC;
         TX_Done    : out STD_LOGIC;
         clk      : in  STD_LOGIC
         );
  end component spi;
  
  signal TX_Data    : STD_LOGIC_VECTOR (15 downto 0)  := (others => '0');
  signal TX_Start  : STD_LOGIC;
  signal TX_Done    : STD_LOGIC;
  
  signal state  : integer range 0 to 10  := 0;
  signal init_state  : integer range 0 to 5  := 0;
  
  signal delay_counter  : integer range 0 to 4095  := 4095;

begin
  -- Component SPI Instanziierung
  spi_instance: component spi
      Generic MAP (crystal_frequency => 50000000, spi_frequency => 1000000, data_length => 16)
      PORT MAP ( TX_Data => TX_Data,
             Data_out => Data_out,
             CS => CS,
             SCLK => SCLK,
             TX_Start => TX_Start,
             TX_Done => TX_Done,
             clk => clk
            );
  -- FSM für die Initialisierung der Referenz-Spannung des DAC + 2 Bytes, die nacheinander über SPI rausgeschickt werden müssen
  process (clk)
  begin
    if clk'event and clk = '1' then
        case state is -- Initialisierungs-FSM
          when 0 =>
            case init_state is
              when 0 =>
                if delay_counter > 0 then
                  delay_counter <= delay_counter - 1;
                else
                  delay_counter <= 100;
                  init_state <= 1;
                end if;
        
              when 1 =>
                if WR = '1' then
                  TX_Data <= x"9002";
                  init_state <= 2;
                end if;
                
              when 2 =>
                if delay_counter > 0 then
                  delay_counter <= delay_counter - 1;
                else
                  delay_counter <= 100;
                  init_state <= 3;
                end if;
                
              when 3 =>
                TX_Start <= '1';
                init_state <= 4;
                
              when 4 =>
                if TX_Done = '1' then
                  TX_Start <= '0';
                  init_state <= 5;
                end if;
            
              when 5 =>
                if delay_counter > 0 then
                  delay_counter <= delay_counter - 1;
                else
                  delay_counter <= 100;
                  init_state <= 0;
                  state <= 1;
                end if;
                
            end case;
                
          when 1 =>
            -- if WR = '1' then
              -- TX_Data <= x"9002";
              TX_Data <= x"1" & ValueA & x"0"; 
              state <= 2;
            -- end if;
            
          when 2 =>
            if delay_counter > 0 then
              delay_counter <= delay_counter - 1;
            else
              delay_counter <= 100;
              state <= 3;
            end if;
            
          when 3 =>
            TX_Start <= '1';
            state <= 4;
            
          when 4 =>
            if TX_Done = '1' then
              TX_Start <= '0';
              state <= 5;
            end if;
            
          when 5 =>
            if delay_counter > 0 then
              delay_counter <= delay_counter - 1;
            else
              delay_counter <= 100;
              state <= 6;
            end if;
            
          when 6 =>
            TX_Data <= x"8" & ValueB & x"0"; -- 2. Byte mit ValueB
            state <= 7;
                        
          when 7 =>
            if delay_counter > 0 then
              delay_counter <= delay_counter - 1;
            else
              delay_counter <= 100;
              state <= 8;
            end if;
            
          when 8 =>
            TX_Start <= '1';
            state <= 9;
            
          when 9 =>
            if TX_Done = '1' then
              TX_Start <= '0';
              state <= 10;
            end if;
            
          when 10 =>
            if delay_counter > 0 then
              delay_counter <= delay_counter - 1;
            else
              WR_Done <= '1';
              if WR = '0' then
                delay_counter <= 100;
                WR_Done <= '0';
                state <= 0;
              end if;
            end if;
        
        end case;
    end if;
  end process;

end Behavioral;

Getriggert wird der Ablauf durch das WR-Signal. Die zu schickenden Werte 
für den DAC sind ValueA und ValueB. Die ersten 16. Bit haben eine eigene 
FSM, da ich diese mal als Initialiserung später ausgliedern will (muss 
nicht jedes Mal geschickt werden, wenn getriggert wird).

Kommen wir nur zum eigentlichen Problem:

Wird nach dem Anschließen der Versorgungsspannung die FSM das erste Mal 
getriggert, scheint der die Übertragung der ersten 16 Bits einfach zu 
übergehen. Die Referenzspannung wird nicht eingestellt beim DAC. Man 
kann auf dem DSO schön die Übertragung der anderen zwei 16 Bit Folgen 
sehen, die erste Übertragung wird jedoch einfach nicht gesendet. Trigger 
ich die FSM ein zweites oder drittes Mal, dann werden jeweils alle 3 
Übertragungen durchgeführt und funktioniert auch.

Bei Bedarf kann ich auch mal Oszi Bilder von den Übertragungen anhängen.


Ich weiß einfach nicht mehr weiter. Ich hoffe, ihr könnt mir helfen.

Viele Grüße,
Benjamin

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

Benjamin schrieb:
> Wird nach dem Anschließen der Versorgungsspannung die FSM das erste Mal
> getriggert, scheint der die Übertragung der ersten 16 Bits einfach zu
> übergehen.
Und was sagt die Simulation/Testbench zu diesem Thema?

Benjamin schrieb:

  signal state  : integer range 0 to 10  := 0;
:
  case state is -- Initialisierungs-FSM
     when 0 =>

Warum lässt du nicht den Synhtesizer die States abhandeln? Wenn du 
symbolische Namen vergibst, hat er eine Chance zum Optimieren und du 
kannst deinen Code wesentlich besser lesen...
So wie z.B. bei meinen SPI-Mastern:
http://www.lothar-miller.de/s9y/categories/45-SPI-Master


Dir ist schon klar, dass du im realen Leben mit asynchronen Eingängen 
nicht direkt in einer FSM herumfroschen sollt:

entity threshold is
    Port ( ValueA : in  STD_LOGIC_VECTOR (7 downto 0);
           ValueB : in  STD_LOGIC_VECTOR (7 downto 0);
           WR : in  STD_LOGIC;
:
    if clk'event and clk = '1' then
        case state is -- Initialisierungs-FSM
          when 0 =>
            case init_state is
              when 1 =>
                if WR = '1' then  -- aber Holla: ein asynchroner Eingang tief in einer FSM

Du wirst dir damit diesen Effekt einfangen:
http://www.lothar-miller.de/s9y/archives/64-State-Machine-mit-asynchronem-Eingang.html
Im Überblick:
http://www.lothar-miller.de/s9y/categories/35-Einsynchronisieren

[Benjamin (Gast)]

Danke für deine Antwort. Die Simulation zeigt genau das, was ich auch 
aufgrund des VHDL Codes erwarten würde und was passieren soll. Ich habe 
ein Screenshot der Simulation angehängt.

Wegen den States werd ich mir angewöhnen, diese als type zu deklarieren. 
Ich dachte nur in diesem Falle, dass ich für so viele Zustände keine 
Wirklichen aussagekräftigen Namen/Bezeichnungen finden würde.

Tut mir leid für die fehlende Information, aber WR ist ein synchrones 
Signal, was von einer Empfangs FSM (FTDI Chip auslesen) erzeugt wird. 
Sollte also auch kein Problem geben.

Im Prinzip sollte es ja auch funktionieren. Was ist das schon für ein 
Unterschied, ob ich die FSM das erste Mal trigger oder ein zweites? Beim 
Übergehen der ersten 16 Bits wird übrigens auch kein SPI Takt 
ausgegeben.

Noch ein komisches Phenomen:
Lasse ich die eingeliederte erste FSM für die Initialisierung selber 
anlaufen nach paar µs, dann läuft zwar der Takt an, aber die geshifteten 
Daten sind alle "0". Ich werde morgen mal ein paar Bilder vom Oszi 
anhängen.

Ich weiß echt nicht mehr weiter. Welche Phenomene kann es denn geben, 
die den Übergang von Simulation zu Realität erschweren?

[Benjamin (Gast)]

Ich hab nun ein globalen Power On Reset eingebaut und jetzt wird die 
erste Übertragung nicht mehr übersprungen. Jetzt tuts, was es soll!

[Duke Scarring (Gast)]

Benjamin schrieb:
> Ich hab nun ein globalen Power On Reset eingebaut und jetzt wird die
> erste Übertragung nicht mehr übersprungen.
Kannst Du das kurz skizzieren?
Die Xilinx-FPGAs haben ja eignetlich schon einen GSR.

Duke

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

Würde mich auch interessieren...  :-/

Bestenfalls hier könnte der Synthesizer noch was herumtricksen:

  signal TX_Start  : STD_LOGIC;
  signal TX_Done    : STD_LOGIC;

Werden diese beiden Signale mit dem zusätzlichen Reset auch 
zurückgesetzt?

Was passiert im Originalprojekt, wenn du da schreibst:
... STD_LOGIC :='0';