Lothar Miller - SPI Master

Einfacher SPI-Master / Mode 0

nospam@example.com (Lothar Miller) — Mon, 13 Jul 2009 20:34:00 +0200

Hier ist eine einfache SPI-Master-Implementierung in VHDL z.B. für FPGAs. Die Übertragung findet im Mode 0 statt (CPOL=0, CPHA=0). Die Protokolllänge und die Baudrate sind generisch einstellbar. An den Port TX_Data werden die 8 zu übertragenden Bits angelegt. Danach wird mit TX_Start die Übertragung gestartet. Erst wird SS aktiviert und dann die 8 Datenbits über das Schieberegister tx_reg an MOSI ausgegeben und gleichzietig der Datenstrom von MISO in das Schieberegister rx_reg eingelesen.
Nach der Übertragung wird SS deaktivert, und danach TX_Done solange aktiviert, bis TX_Start inaktiv wird. Die empfangenen Daten sind jetzt am Port RX_Data abholbereit.

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


entity SPI_Master is  -- SPI-Modus 0: CPOL=0, CPHA=0
    Generic ( Quarz_Taktfrequenz : integer   := 50000000;  -- Hertz 
              SPI_Taktfrequenz   : integer   :=  1000000;  -- Hertz / zur Berechnung des Reload-Werts für Taktteiler
              Laenge             : integer   :=   8        -- Anzahl der zu übertragenden Bits
             ); 
    Port ( TX_Data  : in  STD_LOGIC_VECTOR (Laenge-1 downto 0); -- Sendedaten
           RX_Data  : out STD_LOGIC_VECTOR (Laenge-1 downto 0); -- Empfangsdaten
           MOSI     : out STD_LOGIC;                           
           MISO     : in  STD_LOGIC;
           SCLK     : out STD_LOGIC;
           SS       : out STD_LOGIC;
           TX_Start : in  STD_LOGIC;
           TX_Done  : out STD_LOGIC;
           clk      : in  STD_LOGIC
         );
end SPI_Master;

architecture Behavioral of SPI_Master is
  signal   delay       : integer range 0 to (Quarz_Taktfrequenz/(2*SPI_Taktfrequenz));
  constant clock_delay : integer := (Quarz_Taktfrequenz/(2*SPI_Taktfrequenz))-1;
  
  type   spitx_states is (spi_stx,spi_txactive,spi_etx);
  signal spitxstate    : spitx_states := spi_stx;

  signal spiclk    : std_logic;
  signal spiclklast: std_logic;

  signal bitcounter    : integer range 0 to Laenge; -- wenn bitcounter = Laenge --> alle Bits uebertragen
  signal tx_reg        : std_logic_vector(Laenge-1 downto 0) := (others=>'0');
  signal rx_reg        : std_logic_vector(Laenge-1 downto 0) := (others=>'0');

begin
  ------ Verwaltung --------
  process begin 
     wait until rising_edge(CLK);
     if(delay>0) then delay <= delay-1;
     else             delay <= clock_delay;  
     end if;
     spiclklast <= spiclk;
     case spitxstate is
       when spi_stx =>
             SS          <= '1'; -- slave select disabled
             TX_Done     <= '0';
             bitcounter  <= Laenge;
             spiclk      <= '0'; -- SPI-Modus 0
             if(TX_Start = '1') then 
                spitxstate <= spi_txactive; 
                SS         <= '0';
                delay      <= clock_delay; 
             end if;

       when spi_txactive =>  -- Daten aus tx_reg uebertragen
             if (delay=0) then -- shift
                spiclk <= not spiclk;
                if (bitcounter=0) then -- alle Bits uebertragen -> deselektieren
                   spiclk     <= '0';  -- SPI-Modus 0
                   spitxstate <= spi_etx;
                end if;
                if(spiclk='1') then    -- SPI-Modus 0
                   bitcounter <= bitcounter-1;  
                end if;  
             end if;

       when spi_etx =>
             SS      <= '1'; -- disable Slave Select 
             TX_Done <= '1';
             if(TX_Start = '0') then -- Handshake: warten, bis Start-Flag geloescht
               spitxstate <= spi_stx;
             end if;
     end case;
  end process;   
  
  ---- Empfangsschieberegister -----
  process begin 
     wait until rising_edge(CLK);
     if (spiclk='1' and  spiclklast='0') then -- SPI-Modus 0
        rx_reg <= rx_reg(rx_reg'left-1 downto 0) & MISO;
     end if;
  end process;   
     
  ---- Sendeschieberegister -------
  process begin 
     wait until rising_edge(CLK);
     if (spitxstate=spi_stx) then   -- Zurücksetzen, wenn SS inaktiv
        tx_reg <= TX_Data;
     end if;
     if (spiclk='0' and  spiclklast='1') then -- SPI-Modus 0
        tx_reg <= tx_reg(tx_reg'left-1 downto 0) & tx_reg(0);
     end if;
  end process;   

  SCLK    <= spiclk;
  MOSI    <= tx_reg(tx_reg'left);
  RX_Data <= rx_reg;
  
end Behavioral;

Die Testbench simuliert einen SPI-Slave. Sie empfängt die Daten im Schieberegister rxsrslave,
und gibt sie bei inaktiven SS an das txsrslave.
Von dort werden die Daten bei der nächsten Übertragung wieder an den Master zurückgeschickt.

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;

ENTITY tb_SPI_Master_vhd IS
END tb_SPI_Master_vhd;

ARCHITECTURE behavior OF tb_SPI_Master_vhd IS 

  -- Component Declaration for the Unit Under Test (UUT)
  COMPONENT SPI_Master
    Port ( TX_Data  : in  STD_LOGIC_VECTOR (7 downto 0); -- Sendedaten
           RX_Data  : out STD_LOGIC_VECTOR (7 downto 0); -- Empfangsdaten
           MOSI     : out STD_LOGIC;
           MISO     : in  STD_LOGIC;
           SCLK     : out STD_LOGIC;
           SS       : out STD_LOGIC;
           TX_Start : in  STD_LOGIC;
           TX_Done  : out STD_LOGIC;
           clk      : in  STD_LOGIC
         );
  END COMPONENT;

  --Inputs
  SIGNAL MISO :  std_logic := '0';
  SIGNAL TX_Start :  std_logic := '0';
  SIGNAL clk :  std_logic := '0';
  SIGNAL TX_Data :  std_logic_vector(7 downto 0) := (others=>'0');

  --Outputs
  SIGNAL RX_Data :  std_logic_vector(7 downto 0);
  SIGNAL MOSI :  std_logic;
  SIGNAL SCLK :  std_logic;
  SIGNAL SS :  std_logic;
  SIGNAL TX_Done :  std_logic;
   
  SIGNAL rxsrslave :  std_logic_vector(7 downto 0) := x"00";
  SIGNAL txsrslave :  std_logic_vector(7 downto 0) := x"00";

BEGIN
  -- Instantiate the Unit Under Test (UUT)
  uut: SPI_Master PORT MAP(
    TX_Data => TX_Data,
    RX_Data => RX_Data,
    MOSI => MOSI,
    MISO => MISO,
    SCLK => SCLK,
    SS => SS,
    TX_Start => TX_Start,
    TX_Done => TX_Done,
    clk => clk
  );

   clk <= not clk after 10 ns; -- 50 MHz
   
   -- Senden
   process (sclk, ss) begin
     if (falling_edge(SCLK)) then    -- SPI Mode 0
        txsrslave <= txsrslave(6 downto 0) & '0';
     end if;
     if (ss='1') then
        txsrslave <= rxsrslave; -- x"80000001" after 3 ns;
     end if;
   end process;
   MISO <= txsrslave(7) after 3 ns;
   
   -- Empfangen
   process (sclk, mosi) begin
     if (rising_edge(SCLK)) then   -- SPI Mode 0
        rxsrslave <= rxsrslave(6 downto 0) & MOSI;
     end if;
   end process;

   tb : PROCESS BEGIN 
      TX_Data <= x"7E";
      wait for 3 us;
      TX_Start <= '1';
      
      wait until TX_Done='1';
      TX_Start <= '0';
      wait for 100 ns;

      TX_Data <= x"5a";
      wait for 3 us;
      TX_Start <= '1';
      
      wait until TX_Done='1';
      TX_Start <= '0';
      wait for 100 ns;

      
      TX_Data <= x"C3";
      wait for 3 us;
      TX_Start <= '1';
      
      wait until TX_Done='1';
      TX_Start <= '0';
      wait;
   END PROCESS;

END;

Daraus resultiert diese Waveform

Waveform des SPI-Masters, Mode 0, 8 Bit

Wer eine wesentlich umfangreichere universelle SPI-Master-Implementierung sucht, findet hier eine, die weitestgehend parametrierbar ist.

Konfigurierbarer SPI-Master

nospam@example.com (Lothar Miller) — Sun, 12 Jul 2009 19:35:00 +0200

Bei diesem SPI-Master ist alles konfigurierbar, was das Herz begehrt. Die Taktfrequenz, ein Pre_Delay, ein Post_Delay und die Protokolllänge sind über Generics einstellbar. Eine Änderung der Taktfrequenz, der Protokolllänge und der Delays könnte problemlos auch zur Laufzeit implementiert werden.

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


entity SPI_Master is
    Generic ( Quarz_Taktfrequenz : integer   := 50000000;  -- Hertz 
              SPI_Taktfrequenz   : integer   :=  1000000;  -- Hertz / zur Berechnung des Reload-Werts für Taktteiler
              Pre_Delay          : integer   :=   50;      -- us / Zeit nach Aktivieren von CS bis Beginn der Übertragung
              Post_Delay         : integer   :=   10;      -- us / Zeit nach Beenden der Übertragung bis Deaktivieren CS 
              Laenge             : integer   :=   32       -- Anzahl der zu übertragenden Bits
             ); 
    Port ( TX_Data  : in  STD_LOGIC_VECTOR (Laenge-1 downto 0); -- Sendedaten
           RX_Data  : out STD_LOGIC_VECTOR (Laenge-1 downto 0); -- Empfangsdaten
           CPHA     : STD_LOGIC;                                -- Clock Phase
           CPOL     : STD_LOGIC;                                -- Clock Polarity
           MOSI     : out STD_LOGIC;
           MISO     : in  STD_LOGIC;
           SCLK     : out STD_LOGIC;
           SS       : out STD_LOGIC;
           Start_TX : in  STD_LOGIC;
           TX_Done  : out STD_LOGIC;
           clk      : in  STD_LOGIC
         );
end SPI_Master;

architecture Behavioral of SPI_Master is
  signal   delay       : integer range 0 to (Quarz_Taktfrequenz/(2*SPI_Taktfrequenz));
  signal   delay_pre   : integer range 0 to (Pre_Delay*(Quarz_Taktfrequenz/1000))/1000;
  signal   delay_post  : integer range 0 to (Post_Delay*(Quarz_Taktfrequenz/1000))/1000;
  constant clock_delay : integer := (Quarz_Taktfrequenz/(2*SPI_Taktfrequenz))-1;
  
  type   spitx_states is (spi_stx,del_pre,spi_txactive,del_post,spi_etx);
  signal spitxstate    : spitx_states := spi_stx;

  type   spi_clkstates is (shift,sample);
  signal spiclkstate   : spi_clkstates;
  
  signal bitcounter    : integer range 0 to Laenge; -- wenn bitcounter = Laenge --> alle Bits uebertragen
  signal tx_reg        : std_logic_vector(Laenge-1 downto 0) := (others=>'0');
  signal rx_reg        : std_logic_vector(Laenge-1 downto 0) := (others=>'0');

begin
  ------ Verwaltung --------
  process begin 
     wait until rising_edge(CLK);
     MOSI <= tx_reg(tx_reg'left);
     delay_post  <= (Post_Delay*(Quarz_Taktfrequenz/1000))/1000; -- POST-Delay wg OPTO-Koppler 
     delay_pre   <= (Pre_Delay *(Quarz_Taktfrequenz/1000))/1000; -- Initial-Delay wg OPTO-Koppler 
     if(delay>0) then delay <= delay-1;
     else             delay <= clock_delay;  
     end if;
     case spitxstate is
       when spi_stx =>
             SS          <= '1'; -- slave select disabled
             TX_Done     <= '0';
             bitcounter  <= Laenge;
             SCLK        <= CPOL;
             if(Start_TX = '1') then spitxstate <= del_pre; end if;

       when del_pre =>                       -- SS aktivieren und Zeit fuer Optokoppler abwarten 
             SS          <= '0';
             SCLK        <= CPOL;
             if (CPHA='0') then spiclkstate <= sample;  -- sample at odd SCLK-edge  (1st, 3rd, 5th...)
             else               spiclkstate <= shift; -- sample at even SCLK-edge (2nd, 4th, 6th...)
             end if;
             delay       <= 0;
             if (delay_pre>0) then 
                delay_pre  <= delay_pre-1;
             else
                spitxstate <= spi_txactive;
             end if;

       when spi_txactive =>  -- Daten aus tx_reg uebertragen
---------------------------------------- SPI-Takt generieren -----------------------------
             case spiclkstate is
               when sample =>
                       SCLK <= (CPOL xor CPHA); 
                       if (delay=0) then -- sample                     
                         spiclkstate <= shift;
                         if(CPHA='1') then bitcounter <= bitcounter-1;  end if;
                       end if;
                       
               when shift =>
                       SCLK <= not (CPOL xor CPHA); 
                       if (delay=0) then -- shift
                         spiclkstate <= sample; 
                         if(CPHA='0') then  bitcounter <= bitcounter-1;  end if;
                       end if;         
               end case;
               if (delay=0 and bitcounter=0) then -- alle Bits uebertragen -> deselektieren
                 SCLK       <= CPOL;
                 spitxstate <= del_post;
               end if;
---------------------------------------- SPI-Takt fertig  -----------------------------
       when del_post =>
             SS <= '1'; -- disable Slave Select 
             if (delay_post>0) then
               delay_post <= delay_post-1;
             else 
               spitxstate <= spi_etx;
             end if;

       when spi_etx =>
             TX_Done <= '1';
             if(Start_TX = '0') then -- Handshake: warten, bis Start-Flag geloescht
               spitxstate <= spi_stx;
             end if;
     end case;
  end process;   
  
  ---- Schieberegister in eigenem Prozess ist ressourcensparend -------
  process begin
     wait until rising_edge(clk);
--     if (spitxstate=del_pre) then  -- Initialisierung weglassen spart Ressourcen: 1 Mux = 10 Slices
--        rx_reg <= (others=>'0');
--     end if;
     if(spitxstate=spi_txactive and spiclkstate=sample and delay=0 and bitcounter/=0) then
        rx_reg <= rx_reg(rx_reg'left-1 downto 0) & MISO;
     end if;
     
     if (spitxstate=spi_stx) then
        tx_reg <= TX_Data;
     end if;
     if(spitxstate=spi_txactive and spiclkstate=shift and delay=0 and (cpha='0' or bitcounter/=Laenge)) then
        tx_reg <= tx_reg(tx_reg'left-1 downto 0) & tx_reg(0);
     end if;
  end process;   
  
  RX_Data    <= rx_reg;
  
end Behavioral;

Eines der Merkmale dieses Masters ist die einstellbare Zeit, die nach dem Aktivieren des SS vergeht, bevor die eigentliche SPI-Übertragung startet. Damit können für die SS-Signale z.B. langsame Optokoppler zur Potentialtrennung verwendet werden. Nur das Taktsignal und die MISO und MOSI Leitungen müssen über schnelle und teure Optokoppler geführt werden.

Hier ein Auszug aus der Simulation:

Waveform, Mode 3, 32 Bit