Lothar Miller

Möchte man eine Zahl auf einem Display ausgeben, muß die erst mal in ihre Zehnerstellen umgewandelt werden. Das BCD-Format bietet sich hier an. Man könnte jetzt z.B. durch Subtraktionen oder Divisionen die einzelnen Stellen extrahieren.
Wesentlich eleganter und schneller ist aber ein BCD-Schieberegister. Der Vektor wird von rechts in die BCD-Zahlen hineingeschoben und beim Überlauf die entsprechende BCD-Stelle mit einer Addition +6 korrigiert. Dieses Verfahren heißt Shift-Add-6, es hat aber den Nachteil, dass bei einem Übertrag evtl die nachfolgende Stelle abenfalls manipuliert (incrementiert) werden muß. Hier als Beispiel die Umwandlung der Zahl 99dez = 01100011bin in eine zweistellige BCD-Zahl:

Z    E
---- ---- 01100011 = 99dez
---- ---0 1100011
---- --01 100011
---- -011 00011
---- 0110 0011
---0 1100 011       E>9 -->
---1 0010 011       E = E+6 = 12+6 = 18 = 1 0010 --> Z=1, E=0010
--10 0100 11
-100 1001 1
1001 0011           Überlauf, weil E nach Shift E>9 -->  
1001 1001           E = E+6 = 3+6 = 9 = 1001 --> E=1001 -> 9 9

Ein findiger Kopf hat daraus das Shift-Add-3 Verfahren gemacht, bei dem zuerst kontrolliert wird, ob beim Schieben ein Überlauf entstehen könnte (Wert>=5), und dann vor dem Schieben 3 aufaddiert werden. Hier kann innerhalb der BCD-Stelle kein Überlauf anfallen, die nachfolgende Stelle muß also nicht beachtet werden.
Man sieht die Verwandtschaft der Verfahren: einmal wird nach dem Schieben 6 addiert, das andere Mal vor dem Schieben eine 3 (die ja dann durch das Schieben mit 2 multipliziert wird).

Z    E
---- ---- 01100011 = 99dez
---- ---0 1100011
---- --01 100011
---- -011 00011
---- 0110 0011      E>4 --> E = E+3 = 6+3 = 9 = 1001
---- 1001 0011
---1 0010 011
--10 0100 11
-100 1001 1         E>4 --> E = E+3 = 9+3 = 12 = 1100
-100 1100 1
1001 1001     -> 9 9

Dieses Shift-Add-3 Verfahren habe ich in folgende VHDL-Beschreibung umgesetzt:

---

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

entity Vector2BCD is
    Generic ( stellen : natural := 4;   -- Anzahl BCD-Stellen
              breite  : natural := 16); -- Breite des Eingangsvektors
    Port ( clk      : in  std_logic;
           vector   : in  std_logic_vector (breite-1 downto 0);
           start    : in  std_logic;
           busy     : out std_logic;
           overflow : out std_logic;
           bcd      : out std_logic_vector (stellen*4-1 downto 0));
end Vector2BCD;

architecture Behavioral of Vector2BCD is            -- Beispiel: Stellen=3, Breite=8
type states is (idle,calc);                          -- 2 1111   1111   11
signal state : states := idle;                       -- 0 9876   5432   1098   76543210
signal sr : unsigned (stellen*4+breite downto 0);  -- O BCDh & BCDz & BCDe & VVVVVVVV
signal bitcnt : integer range 0 to breite;
signal ovl : std_logic;
begin
   process begin
      wait until rising_edge(clk);
      busy <= '0';
      case state is
         when idle => 
            sr <= (others=>'0');
            sr(breite-1 downto 0) <= unsigned(vector);
            bitcnt <= breite;
            if (start='1') then 
               busy <= '1';
               ovl  <= '0';
               state<=calc;
            end if;
                      
         when calc => 
            if (bitcnt/=0) then 
               bitcnt <= bitcnt-1; -- bearbeitete Bits mitzählen
               busy <= '1';
               sr <= sr(stellen*4+breite-1 downto 0)&'0';         -- einmnal komplett durchschieben
               for i in 0 to stellen-1 loop 
                  if (sr(i*4+breite+3 downto i*4+breite)>4) then  -- falls nötig: BCD-Übertrag + schieben
                     sr(i*4+breite+4 downto i*4+breite+1) <= sr(i*4+breite+3 downto i*4+breite)+3;
                  end if;
               end loop;
               if (sr(sr'high)='1') then  ovl <= '1'; end if;
            else 
               state <= idle;
               bcd   <= std_logic_vector(sr(stellen*4+breite-1 downto breite));
               if(ovl='1' or sr(sr'high)='1') then overflow <= '1';
               else                                overflow <= '0';
               end if;
            end if;
            
      end case;
   end process;
end Behavioral;

---

Ein Ausschnitt aus der Testbench:

---

:
  clk <= not clk after 5 ns;

  tb : PROCESS
  BEGIN
    vector <= std_logic_vector(to_unsigned(8,16));
    wait for 25 ns;
    start <= '1';
    wait for 25 ns;
    start <= '0';
    wait until falling_edge(busy);
    wait for 25 ns;
      
    vector <= std_logic_vector(to_unsigned(33,16));
    wait for 25 ns;
    start <= '1';
    wait for 25 ns;
    start <= '0';
    wait until falling_edge(busy);
    wait for 25 ns;
:     

---

Hier das Ergebnis mit 4 Stellen und einem 16-bit Eingangsvektor:

Der vector ist die Engangs-Binärzahl (dargestellt als unsigned), bcd ist die BCD-Zahl (dargestellt als Hex-Zahl). Bei Zahlen ab 10000 wird das Overflow-Flag gesetzt und solange gehalten wie die zugehörige BCD-Zahl.

Wer das Ausgangsregister weglässt, spart sich noch ein paar Flipflops ein:

---

   :
   :
            else 
               state <= idle;
               if(ovl='1' or sr(sr'high)='1') then overflow <= '1';
               else                                overflow <= '0';
               end if;
            end if;
            
      end case;
   end process;

   bcd   <= std_logic_vector(sr(stellen*4+breite-1 downto breite));

end Behavioral;

---

Für die Klartextausgabe eines Bytes ist 0-255 auf einem Display intuitiver, als nur 00-FF anzuzeigen. 100 (dez) sagt einen Dezimalisten mehr als 64 (hex). Hier eine Methode, wie ein 8-Bit-Vektor in eine 3-stellige BCD-Zahl umgewandelt wird. In einem ROM mit 12 Bit*256 Worte werden die drei Nibbles eingetragen, und anschliessend einfach über den Index ausgegeben.

data ist der Eingangsvektor, dig100, dig10 und dig1 sind die drei BCD-Digits.

---

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

entity BCD_ROM is
    Port ( clk    : in   STD_LOGIC;
           data   : in   STD_LOGIC_VECTOR (7 downto 0);
           dig1   : out  STD_LOGIC_VECTOR (3 downto 0);
           dig10  : out  STD_LOGIC_VECTOR (3 downto 0);
           dig100 : out  STD_LOGIC_VECTOR (3 downto 0));
end BCD_ROM;

architecture Behavioral of BCD_ROM is
   subtype SLV12 is std_logic_vector (11 downto 0);
   type Rom128x8 is array (0 to 255) of SLV12;
   constant BCDRom : Rom128x8 := (
    x"000", x"001", x"002", x"003", x"004", x"005", x"006", x"007", x"008", x"009",  
    x"010", x"011", x"012", x"013", x"014", x"015", x"016", x"017", x"018", x"019",  
    x"020", x"021", x"022", x"023", x"024", x"025", x"026", x"027", x"028", x"029",  
    :
    x"220", x"221", x"222", x"223", x"224", x"225", x"226", x"227", x"228", x"229",  
    x"230", x"231", x"232", x"233", x"234", x"235", x"236", x"237", x"238", x"239",  
    x"240", x"241", x"242", x"243", x"244", x"245", x"246", x"247", x"248", x"249",  
    x"250", x"251", x"252", x"253", x"254", x"255" );
   signal digits : std_logic_vector (11 downto 0);
   signal addr : std_logic_vector (7 downto 0);
begin
   -- BROM 
   process begin
     wait until rising_edge(clk);
     addr <= data;
   end process;
   digits <= BCDRom(to_integer(unsigned(addr)));
  
   dig1   <= digits (3 downto 0);
   dig10  <= digits (7 downto 4);
   dig100 <= digits(11 downto 8);
end Behavioral;

---

Weil im obigen Beispiel die Adresse getaktet ist, wird ein BROM synthetisiert.

Sind die BRAMs schon alle verwendet, lassen wir den Takt weg:

---

begin
   -- Distributed ROM braucht 54 Slices 
   digits <= BCDRom(to_integer(unsigned(data)));
  
   dig1   <= digits (3 downto 0);
   dig10  <= digits (7 downto 4);
   dig100 <= digits(11 downto 8);
end Behavioral;

---

Statt der BRAMs wird jetzt distributed RAM verwendet, was sich im Verbrauch von 54 Slices niederschlägt.

Auch in einem CPLD lässt sich diese Umwandlung problemlos einsetzen. In einem XC9572XL CPLD werden für die Byte-nach-BCD Umwandlung gerade mal ein drittel der Ressourcen verbraucht:

Macrocells   Pterms         Registers   Pins         Function Block Inputs 
15/72 (21%)  130/360 (37%)  0/72 (0%)   20/34 (59%)  36/216 (17%) 

Hier der Code mit der kompletten Tabelle:...

"Byte nach BCD " 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?

Was passiert eigentlich mit einem mit dem when others in einem case, in dem alle Zustände verwendet sind? Frisch ans Werk und ausprobiert. Man definiere sich ein paar Zustände, mache dann eine SM, und verwende alle diese Zustände und füge zusätzlich (zur Sicherheit) noch einen when others Zweig mit einem error Flag ein. So etwa:

---

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

entity SM_ueberdefiniert is
    Port ( clk   : in  STD_LOGIC;
           leds  : out  STD_LOGIC_VECTOR (1 downto 0);
           error : out  STD_LOGIC);
end SM_ueberdefiniert;

architecture Behavioral of SM_ueberdefiniert is
type dtyp is (aa, ab, ac);
signal a : dtyp;

begin

   process begin
      wait until rising_edge(clk);
      error <= '0'; -- default
      case a is
         when aa => a<=ab; leds<="00";
         when ab => a<=ac; leds<="01";
         when ac => a<=aa; leds<="10";
         when others => a<=aa; error <= '1';
      end case;
   end process;

end Behavioral;

---

Was kommt bei der Synthese dabei heraus?
Erst mal eine Warnung:

WARNING:Xst:1710 - FF/Latch <error> has a constant value of 0 in block <SM_ueberdefiniert>.

Und das schlägt sich dann auch im Syntheseergebnis nieder:
error wird einfach fest auf GND gelegt, weil der others Zweig nicht behandelt wird.

Fazit:
bei einer vollständig auscodierten Statemachine ist der when others Zweig unnötig. Er wird von der Synthese ganz einfach ignoriert, und könnte bestenfalls im Quelltext für Verwirrung sorgen.

ISE in der Version 13 lässt sich sogar zu einer Info herunter und sagt:
INFO:HDLCompiler:679 - Case statement is complete. others clause is never selected

Aber ACHTUNG:
wenn man z.B. 4 Zustände mit einem 2 Bit breiten std_logic_vector auscodiert, dann hat man (für die Simulation) nicht nur "00", "01", "10" und "11". Sondern man hat noch 77 andere Zustände (wie z.B. "XU", "1-", "ZH", usw), weil ja std_logic eine 9-wertige Logik beschreibt, und mit 2 Stellen insgesamt 9x9=81 Zustände codierbar wären.
Deshalb macht dort für die Simulation der when others Pfad durchaus Sinn. Besser wäre es aber, Zustände einer FSM gar nicht manuell zu codieren, sondern dies (wie im obigen Beispiel) immer mit einem entsprechenden Typ erledigt, und so der Synthese Platz zur Optimierung (Gray, OneHot, Binär,...) lässt.