Lothar Miller - CPLD

RS232 IO

nospam@example.com (Lothar Miller) — Mon, 28 Sep 2009 20:21:00 +0200

Ein CPLD eignet sich glänzend, um eine serielle-IO Schnittstelle zu implementieren. Hier werden über ein Xilinx XC9536 8 Ausgänge und 8 Eingänge an die RS232 Schnittstelle z.B. eines PCs angeschlossen. Über ein Terminalprogramm oder ein selbst geschriebenes Programm kann dann auf diese Ports zugegriffen werden.

Die (von mir getesteten) Übertragungsdaten sind: Baudrate 9600, 8 Datenbits, keine Parity, 1 Stopbit.
Die Takterzeugung erfolgte bei Testaufbau recht rustikal über einen CMOS-Timer ICM7555, der auf einen Takt von 8*9600 = 76800 Hz eingestellt wird.

Schreiben der Ausgänge: jedes über RS232 gesendete Bit wird sofort nach der Übertragung auf den entsprechenden Ausgang abgebildet. So werden 8 FFs gespart, die sonst für die Zwischenpufferung in einem Schieberegister nötig wären.
Lesen der Eingänge: beim Erkennen eines Startbits auf der RXD-Leitung wird die Übertragung der Eingänge angestoßen. Die 8 Eingänge können also nur über das Senden eines Zeichens über die RS232 Schnittstelle abgefragt werden.

Hier der VHDL-Code:

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

entity RS232IO is
    Port ( clk  : in  STD_LOGIC;
           TXD  : out STD_LOGIC := '1';
           RXD  : in  STD_LOGIC;
           din  : in  STD_LOGIC_VECTOR (7 downto 0);
           dout : out STD_LOGIC_VECTOR (7 downto 0) := "00000000");
end RS232IO;

architecture Behavioral of RS232IO is
signal prescaler : unsigned(2 downto 0) := "000";            -- clk = 8*Baudrate
signal txsr      : unsigned(8 downto 0) := "111111111";  
signal rxd_sr    : std_logic_vector (3 downto 0) := "1111";  -- Flankenerkennung und Eintakten
signal start     : std_logic := '0'; 
signal rxdat     : std_logic_vector (8 downto 0) := "000000000"; 
signal rxbitcnt  : integer range 0 to 9 := 9;
begin
   -- Senden
   process begin
      wait until rising_edge(clk);
      if (start = '1') then                      -- fallende Flanke Startbit erkannt
         txsr <= unsigned(din) & '0';            -- MSB zuerst: Stopbit, 8 Datenbits, Startbit
      elsif (prescaler="000") then
         txsr <= '1' & txsr(8 downto 1);         -- MSB zuerst --> nach rechts schieben
      end if;
   end process;
   TXD <= txsr(0);

   -- Empfangen
   process begin
      wait until rising_edge(CLK);
      prescaler <= prescaler+1;
      rxd_sr <= rxd_sr(2 downto 0) & RXD;
      if (rxd_sr = "1000" and rxbitcnt=9) then   -- fallende Flanke = Startbit
         start <= '1';                           -- 1 FF nötig wegen evtl. Glitches auf Kombinatorik
      end if; 
      if (rxbitcnt<9) then                       -- Empfang läuft
         if (prescaler="100") then               -- In der Bitmitte abtasten
            rxdat(rxbitcnt) <= rxd_sr(3);        -- Jedes Bit wird sofort nach Empfang ausgegeben --> kein Schieberegister nötig, MUX spart FFs
            rxbitcnt <= rxbitcnt+1;
         end if;
      else                                       -- warten auf Startbit
         if (start = '1') then                   -- fallende Flanke Startbit erkannt
            prescaler <= "001";                  -- erst mal nur halbe Bitzeit abwarten
            rxbitcnt  <= 0;
            start     <= '0';
         end if;
      end if;
   end process;
   dout <= rxdat(8 downto 1);  

end Behavioral;

Der RXD-Eingang wird zuerst über ein 4 stufiges Schieberegister rxd_sr eingetaktet. dieses Schieberegister wird auch zur Flankenerkennung für das Startbit verwendet. Der Zähler prescaler teilt den achtfachen Takt auf einen Bittakt herunter. Beim Erkennen der fallenden Flanke des Startbits am RXD-Eingang wird der prescaler zurückgesetzt und später immer die Mitte eines Bits abgetastet. Nach 9 übertragenen Bits ist der Empfang beendet, es wird die Erkennung des nächsten Startbits aktiviert.
Achtung: die Bitreihenfolge ist vertauscht, das MSB ist also in rxdat(1) und damit in dout(0). Wenn das stört, kann bei der Zuweisung an dout die Bitreihenfolge getauscht werden. Das könnte z.B. mit bitweiser Zuweisung dout(0) <= rxdat(8) ... dout(7) <= rxdat(1) oder einer for-Schleife oder einem kleinen Quick-And-Dirty-Trick passieren:

   dout : out STD_LOGIC_VECTOR (0 to 7) := "00000000");

Auf diese Art passiert das Tauschen der Bits implizit und quasi automatisch...

Das Senden wird über die fallende Flanke eines Startbits am RXD-Eingang ausgelöst. Mit start='1' wird das Sendeschieberegister txsr geladen und anschliessend mit jedem Nulldurchgang des prescaler um eine Stelle weitergeschoben und dabei von links mit Nullen aufgefüllt. Nachdem das Stopbit hinausgeschoben wurde, steht im Schieberegister der Wert "111111111". Damit ist die Übertragung beendet und es wird auf den nächsten Start gewartet.

Im erweiterten Eintrag finden sich die Sourcecodes und die verwendete ucf-Datei.

"RS232 IO" vollständig lesen

SPI-Slave im CPLD

nospam@example.com (Lothar Miller) — Mon, 09 Feb 2009 21:48:00 +0100

Möchte man seine EA-Ports erweitern, bietet sich das SPI Protokoll geradezu an, denn fast jeder uC hat eine solche Schnittstelle. Und falls keine da ist, kann sie leicht in Software gehackt werden. Auf der Empfängerseite bieten sich CPLDs an: viele IO-Pins ergeben viele Anschlussmöglichkeiten, und die Registerdichte ist ausreichend. Hier eine Implementation für 24 Ein- und Ausgänge, die in einem XC9572 CPLD realisiert wurde.

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

entity SPI_Slave is
    Generic ( breite: natural := 24);
    Port ( SCLK : in  STD_LOGIC;
           SS   : in  STD_LOGIC;
           MOSI : in  STD_LOGIC;
           MISO : out  STD_LOGIC;
           Dout : out  STD_LOGIC_VECTOR (breite-1 downto 0);
           Din  : in  STD_LOGIC_VECTOR (breite-1 downto 0));
end SPI_Slave;

architecture Behavioral of SPI_Slave is
signal dinsr  : STD_LOGIC_VECTOR (breite-1 downto 0);
signal doutsr : STD_LOGIC_VECTOR (breite-1 downto 0);
begin
  -- Parallel-Eingänge --> MISO
  process (SS, Din, SCLK)   
  begin
     if (SS='1') then
        dinsr <= Din;
     elsif falling_edge(SCLK) then                   -- nach der fallenden SCLK-Flanke 
        dinsr <= dinsr(dinsr'left-1 downto 0) & '0'; -- wird MISO aktualisiert
     end if;
  end process;
  MISO <= dinsr(dinsr'left) when SS='0' else 'Z'; 
  
  -- MOSI --> Parallel-Ausgänge
  process (SCLK)   
  begin
     if rising_edge(SCLK) then                           -- mit der steigenden SCLK-Flanke
        doutsr <= doutsr(doutsr'left-1 downto 0) & MOSI; -- wird MOSI eingelesen
     end if;
  end process;
   
  process (SS)   
  begin
     if rising_edge(SS) then  -- Device wird deselektiert
        Dout <= doutsr;       -- Ausgangssignale an die Pins durchgeben
     end if;
  end process;

end Behavioral;

Die Kommunikation findet im SPI-Modus 0 statt. Ruhezustand SCLK ist demnach LOW, die Daten werden an der steigenden Flanke eingelesen, und an der fallenden Flanke geändert.

Im weiteren Eintrag findet sich eine Testbench für das obige Design.

"SPI-Slave im CPLD" vollständig lesen

Einfacher SPI-Slave

nospam@example.com (Lothar Miller) — Mon, 09 Feb 2009 21:36:23 +0100

Sollen weniger Register verwendet werden, empfiehlt sich diese Implementierung. Für 32 Ein- und Ausgänge sind 64 Flipflops (FFs) nötig. Je zu übertragendes Bit wird 1 FF im Schieberegister und 1 FF im Ausgangslatch verwendet.

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

entity SPI_Slave is
    Generic ( breite: natural := 24);
    Port ( SCLK : in  STD_LOGIC;
           SS   : in  STD_LOGIC;
           MOSI : in  STD_LOGIC;
           MISO : out  STD_LOGIC;
           Dout : out  STD_LOGIC_VECTOR (breite-1 downto 0);
           Din  : in  STD_LOGIC_VECTOR (breite-1 downto 0));
end SPI_Slave;

architecture Behavioral of SPI_Slave is
signal dsr  : STD_LOGIC_VECTOR (breite-1 downto 0);
begin
  -- Parallel-Eingänge --> MISO
  process (SS, Din, SCLK)   
  begin
     if (SS='1') then
        dsr <= Din;
     elsif rising_edge(SCLK) then               -- mit der fallenden SCLK-Flanke 
        dsr <= dsr(dsr'left-1 downto 0) & MOSI; -- wird MOSI eingetaktet
     end if;
  end process;
  MISO <= dsr(dsr'left) when SS='0' else 'Z';   -- und MISO aktualisiert
  
  -- Parallel-Ausgänge übernehmen mit steigender SS-Flanke 
  process (SS)   
  begin
     if rising_edge(SS) then  -- Device wird deselektiert
        Dout <= dsr;          -- Ausgangssignale an die Pins durchgeben
     end if;
  end process;

end Behavioral;

Die Kommunikation findet im SPI-Modus 0 statt. Ruhezustand SCLK ist demnach LOW, die Daten werden an MOSI mit der steigenden Flanke eingelesen und sofort danach ändert sich MISO. Diese Implementierung braucht weniger FFs, weil das Schieberegister für das Eintakten und das Herausschieben zugleich verwendet wird.
Hier müssen aber vor dem Deselektieren alle Bits durchgetaktet werden, denn sonst werden Eingangsbits auf die Ausgänge ausgegeben. Wird z.B. nur SS kurz LOW und wieder HIGH, werden die Eingänge über das Schieberegister dsr auf die Ausgänge durchgegeben.