CPLD

Da gab es früher doch mal den legendären Dreiklanggong SAB0600 von Siemens, der allerdings schon lange obsolete ist, und dessen Nachfolger SAE800 auch nicht mehr produziert wird.
So ein Baustein ist ein schönes Objekt für eine CPLD-Implementierung, weil nur ein paar Zähler und keine allzu komplizierte Ablauflogik nötig sind.

Für den Gong müssen erst mal 3 Frequenzen von "normal" 660Hz, 550Hz und 440Hz erzeugt werden. Nach dem Drücken einer Taste wird zuerst der höchste Ton (660Hz) ausgegeben und dessen Ampiltude über einen 4-Bit-Wandler schrittweise linear von Maximal nach Null reduziert. Nach kurzer Zeit kommt dann der nächst tiefere Ton (550Hz), der ebenfalls linear ausklingt, gefolgt vom tiefsten Ton (440Hz). Für kurze Zeit erklingen alle drei Töne und ergeben einen A-Dur Akkord.
Nach dieser Sequenz kann der Ablauf neu gestartet werden.

Weil einem CPLD alles Analoge fremd ist, wird die unterschiedliche Amplitude statt mit einem 4-Bit-DA-Wandler mit einer 16 stufigen PWM nachgebildet.
Der Mischer am Ausgang ist eine Exclusiv-Veroderung der 3 Signale.

---

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

entity SAB0600 is
    Port ( clk     : in  STD_LOGIC;
           start   : in  STD_LOGIC;
           speaker : out  STD_LOGIC := '0');
end SAB0600;

architecture Behavioral of SAB0600 is

constant fclk : integer := 50_000_000;
signal cnt13200 : integer range 0 to fclk/13200 := 0;
signal ena13200 : std_logic := '0';

constant m660 : integer := (13200/660)/2-1;
constant m550 : integer := (13200/550)/2-1;
constant m440 : integer := (13200/440)/2-1;
signal cnt660 : integer range 0 to m660 := 0;
signal cnt550 : integer range 0 to m550 := 0;
signal cnt440 : integer range 0 to m440 := 0;
signal hz660 : std_logic := '0';
signal hz550 : std_logic := '0';
signal hz440 : std_logic := '0';
signal en440 : std_logic := '0';

signal adsrpre : unsigned (6 downto 0) := (others=>'0'); 
signal adsr660 : integer range 0 to 15 := 15;
signal adsr550 : integer range 0 to 15 := 15;
signal adsr440 : integer range 0 to 15 := 15;

signal pwmpresc: integer range 0 to fclk/500000 := 0; -- pwmfrequenz 500kHz
signal pwmcnt : integer range 0 to 14 := 0;

begin

   Vorteiler: process begin
      wait until rising_edge(clk);
      if cnt13200<fclk/13200 then 
         cnt13200 <= cnt13200+1;
         ena13200 <= '0';
      else
         cnt13200 <= 0;
         ena13200 <= '1';
      end if;
   end process;
      
   Frequenzen: process begin
      wait until rising_edge(clk);
      en440 <= '0';
      if ena13200='1' then
         if cnt660<m660 then   
            cnt660 <= cnt660+1;
         else                  
            cnt660 <= 0; 
            hz660  <= not hz660;
         end if;
         if cnt550<m550 then   
            cnt550 <= cnt550+1;
         else                  
            cnt550 <= 0; 
            hz550  <= not hz550;
         end if;
         if cnt440<m440 then   
            cnt440 <= cnt440+1;
         else                  
            cnt440 <= 0; 
            hz440  <= not hz440;
            en440  <= '1';
         end if;
      end if;
   end process;      

   Huellkurve: process begin             
--    wait until rising_edge(hz440); -- direkt getaktet: 50 Flipflops 
      wait until rising_edge(clk);
      if en440='1' then              -- über Enable: 51 Flipflops
         adsrpre <= adsrpre+1;
         if to_integer(adsrpre)=0 then
            if start='1' 
               and adsr660=0 
               and adsr550=0 
               and adsr440=0 then   adsr660 <= 15;         end if;
            if adsr660>0  then      adsr660 <= adsr660-1;  end if;
            if adsr660=10 then      adsr550 <= 15;         end if;
            if adsr550>0  then      adsr550 <= adsr550-1;  end if;
            if adsr550=10 then      adsr440 <= 15;         end if;
            if adsr440>0  then      adsr440 <= adsr440-1;  end if;
         end if;
      end if;
   end process;      

   Mischer: process 
   variable mix : std_logic;
   begin
      wait until rising_edge(clk);
      if pwmpresc<fclk/500000 then
        pwmpresc <= pwmpresc+1;
      else
        pwmpresc <= 0;
        if pwmcnt<14 then
           pwmcnt<=pwmcnt+1;
        else 
           pwmcnt<=0;
        end if;
      end if;
      
      mix := '0';
      if adsr660>pwmcnt and hz660= '1' then  mix := not mix;
      end if;
      if adsr550>pwmcnt and hz550= '1' then  mix := not mix;
      end if;
      if adsr440>pwmcnt and hz440= '1' then  mix := not mix;
      end if;
      speaker <= mix;
   end process;

end Behavioral;

---

Der Ressourcenverbrauch hält sich trotz einer Eingangsfrequenz von 50MHz, die auf entsprechende verwendete Frequenzen heruntergeteilt wird, mit 50 Flipflops in Grenzen, so dass das Design problemlos in ein 72er CPLD hineinpasst. Wird die Taktfrequenz auf 500kHz (das ist die verwendetete PWM-Frequenz) reduziert, dann lassen sich schnell noch mindestens 7 Flipflops einsparen.

Um den neueren SAE800 genau nachzubilden, müsste ein nichtlinearer DA-Wandler mit einer nichtlinearen Hüllkurve und einer höher auflösenden PWM nachgebildet werden. Dieser Verlauf ist schön im Datenblatt des Bausteins zu sehen.

Hier ein Link zu einem (nicht meinem) Youtube Video, auf dem der Gong in Aktion zu hören ist:
Youtube-Video SAB0600 im FPGA

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 »

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.

Diese Implementation ist darauf optimiert, so wenig Register wie möglich zu verwenden. Sie eignet sich deshalb nur für CPLDs! Für FPGAs ist die Umsetzung mit asynchronem Reset und zusätzlichen Taktdomänen äusserst ungünstig. Hier sollte eher der Ansatz mit einer Überabtaktung des SCLK mit anschliessender Flankenerkennung gewählt werden. Etwa so wie dort auf dem uC.net im Beitrag Erfahrung mit SPI Slave und Spartan 6 FPGA?

Im weiteren Eintrag findet sich eine Testbench für das obige Design. Diese Testbench kann natürlich auch für FPGAs verwendet werden, weil sie ja keine Struktur, sondern nur das Verhalten des SPI Interfaces beschreibt.

"SPI-Slave im CPLD" vollständig lesen »

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 steigenden 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.

Auch hier gilt:
Diese Implementation ist für CPLDs ausgelegt! Für FPGAs ist die Umsetzung mit asynchronem Reset und zusätzlichen Taktdomänen (SS, SCLK) äusserst ungünstig. Hier sollte eher der Ansatz mit einer Überabtaktung des SCLK mit anschliessender Flankenerkennung gewählt werden. Etwa so wie dort auf dem uC.net im Beitrag Erfahrung mit SPI Slave und Spartan 6 FPGA?