BCD Umwandlung

Sollen Werte z.B. an ein Display oder über eine serielle Schnittstelle ausgegeben werden, dann kann eine hexadezimale Darstellung dieser Werte vorteilhaft sein. Bei der Hexadezimaldarstellung wird nämlich die Position der einzelnen Bits nicht verändert, byteorientierte Werte bleiben in Zweiergruppen beisammen und brauchen immer nur 2 ASCII Zeichen zur Darstellung.
Wenn man einen Binärwert wie "01100011" und "01100100" vergleicht, dann sieht man leicht, dass hier nicht so arg viel anders ist. Die zugehörigen Dezimalwerte 99 und 100 sind da augenscheinlich wesentlich unterschiedlicher: alle Zeichen haben sich geändert und es wird sogar eine zusätzliche Stelle benötigt. In der Hexadezimaldarstellung sieht es dagegen mit x"63" und x"64" wieder wesentlich entspannter aus: es ändert sich nicht die ganze Zahlendarstellung, sondern nur das niederwertigste Nibble.

Hier werden mehrere Lösungsmöglichkeiten für die Umwandlung einer 4 Bit breiten (Binär)zahl in einen ASCII-Wert aufgezeigt.

Der Lösungsansatz bei der Addiererlösung ist folgender:

Wenn di eine Zahl von 0..9 ist, dann addiere eine ASCII-0 dazu.
Wenn di eine Zahl von 10..15 ist, dann subtrahiere 10 und addiere ein ASCII-A dazu.

---

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

entity BCD2ASCII is
    Port ( di : in  STD_LOGIC_VECTOR (3 downto 0);
           do : out STD_LOGIC_VECTOR (7 downto 0));
end BCD2ASCII;

-- Direkte Beschreibung als Distributed BROM
-- Maximum combinational path delay: 7.276ns
-- Number of Slices         3
-- Number of 4 input LUTs   6
architecture Behavioral of BCD2ASCII is
   type Rom16x8 is array (0 to 15) of std_logic_vector (7 downto 0);
   constant BCDRom : Rom16x8 := ( 
       std_logic_vector(to_unsigned(character'pos('0'),8)),
       std_logic_vector(to_unsigned(character'pos('1'),8)),
       std_logic_vector(to_unsigned(character'pos('2'),8)),
       std_logic_vector(to_unsigned(character'pos('3'),8)),
       std_logic_vector(to_unsigned(character'pos('4'),8)),
       std_logic_vector(to_unsigned(character'pos('5'),8)),
       std_logic_vector(to_unsigned(character'pos('6'),8)),
       std_logic_vector(to_unsigned(character'pos('7'),8)),
       std_logic_vector(to_unsigned(character'pos('8'),8)),
       std_logic_vector(to_unsigned(character'pos('9'),8)),
       std_logic_vector(to_unsigned(character'pos('A'),8)),
       std_logic_vector(to_unsigned(character'pos('B'),8)),
       std_logic_vector(to_unsigned(character'pos('C'),8)),
       std_logic_vector(to_unsigned(character'pos('D'),8)),
       std_logic_vector(to_unsigned(character'pos('E'),8)),
       std_logic_vector(to_unsigned(character'pos('F'),8)));
begin
   do <= BCDRom(to_integer(unsigned(di)));
end Behavioral;

-- Über eine when-else Anweisung --> es wird ein Distributed BROM instatiiert
-- Maximum combinational path delay: 7.276ns
-- Number of Slices         3
-- Number of 4 input LUTs   6
architecture Behavioral of BCD2ASCII is
begin
     do <= x"30" when di=x"0"  else  
           x"31" when di=x"1"  else  
           x"32" when di=x"2"  else  
           x"33" when di=x"3"  else  
           x"34" when di=x"4"  else  
           x"35" when di=x"5"  else  
           x"36" when di=x"6"  else  
           x"37" when di=x"7"  else  
           x"38" when di=x"8"  else  
           x"39" when di=x"9"  else  
           x"41" when di=x"A"  else  
           x"42" when di=x"B"  else  
           x"43" when di=x"C"  else  
           x"44" when di=x"D"  else  
           x"45" when di=x"E"  else  
           x"46";
end Behavioral;

-- Mit Addierer, die Konstate 10 wird direkt vom ASCII-Wert 'A' abgezogen (selbe Klammerebene)
-- Maximum combinational path delay: 7.276ns
-- Number of Slices         3
-- Number of 4 input LUTs   6
architecture Behavioral of BCD2ASCII is
begin
     do <= std_logic_vector(resize(unsigned(di),8)+to_unsigned(character'pos('A')-10,8))  when unsigned(di)>9  else  
           std_logic_vector(resize(unsigned(di),8)+to_unsigned(character'pos('0'),8));
end Behavioral;

-- Wie vorher, die Konstate 10 wird aber auf einer anderen Klammerebene abgezogen --> ein Subtrahierer wird instatiiert!
-- Maximum combinational path delay: 10.471ns
-- Number of Slices         6
-- Number of 4 input LUTs   10
--architecture Behavioral of BCD2ASCII is
begin
     do <= std_logic_vector(resize(unsigned(di),8)+to_unsigned(character'pos('A'),8)-10)  when unsigned(di)>9  else  
           std_logic_vector(resize(unsigned(di),8)+to_unsigned(character'pos('0'),8));
end Behavioral;

---

Die ersten 3 Lösungen resultieren in gleichem Ressourcenverbrauch und in der selben Geschwindigkeit.

Sehr interessant ist aber der Unterschied zwischen der (optisch fast gleichen) 3. und 4. Lösung. Dort wurde nur die Subtraktion der Konstante 10 etwas verlegt, und XST fügt dann in die Hardware einen Subtrahierer ein. Dadurch wird das Design größer und langsamer!

Eine Umwandlung von BCD nach Binär ist eigentlich recht einfach: man multipliziert jede BCD-Stelle mit ihrem dezimalen Stellenwert und summiert das Ganze dann auf. So ergibt sich z.B. folgende Rechnung:

2173(bcd) = 2*1000 + 1*100 + 7*10 + 3*1 = 2173(dez) = 00001000_01111101(bin) = 087d(hex)

Kurzer Einwurf: hier dürfte jedem auffallen, dass 2073(bcd) = 2073(dez) ist. Und das ist ja auch logisch, weil "BCD" ausgeschrieben "Binär codiertes Dezimalsystem" heißt.

Soll nun die obige Rechnung aber in ein FPGA, dann ist es ziemlich ressourcenfressend, wenn die komplette Rechnung kombinatorisch erledigt werden muss. In diesem einfachen Fall oben wären schon 4 Multiplizierer und 4 Addierer nötig.

Sinnvoller ist daher, die Wandlung schrittweise durchzuführen und pro BCD-Stelle einen Takt aufzuwenden. Dazu kann man die obige Rechnung so umstellen:

2173(bcd) = (((2)*10 + 1)*10 + 7)*10) + 3 = 2173(dez) = 00001000_01111101(bin) = 087d(hex)

Man sieht hier, dass pro Schritt immer nur die selbe und vor allem nur eine einzige Multiplikation nötig ist. Zusammen mit einer FSM basierend auf dem Index der Dezimalstelle könnte das dann so umgesetzt werden:

---

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

entity BCD2BIN is
    Generic ( width : integer := 4 );
    Port ( BCD   : in   STD_LOGIC_VECTOR (width*4-1 downto 0);
           BIN   : out  STD_LOGIC_VECTOR (width*4-1 downto 0);
           Start : in   STD_LOGIC;
           Idle  : out   STD_LOGIC;
           Clk   : in   STD_LOGIC);
end BCD2BIN;

architecture Behavioral of BCD2BIN is
signal idx : integer range 0 to width-1 := 0; -- 0 = idle
signal tmp : unsigned (width*4-1 downto 0);
begin
   process 
   begin
      wait until rising_edge(Clk);
      if (idx = 0) then 
         if (start='1') then 
            tmp <= (others=>'0');
            tmp(3 downto 0) <= unsigned(BCD(width*4-1 downto width*4-4));
            idx <= width-1;
         end if;
      else
         tmp <= resize(tmp*10 + unsigned(BCD(idx*4-1 downto idx*4-4)),tmp'length);
         idx <= idx-1;
      end if;
   end process;

   BIN <= std_logic_vector(tmp);
   Idle <= '1' when idx=0 else '0';
   
end Behavioral;

---

Und hier eine kleine Testbench mit der passenden Waveform:

---

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
 
ENTITY tb_BCD2BIN IS
END tb_BCD2BIN;
 
ARCHITECTURE behavior OF tb_BCD2BIN IS 
 
    COMPONENT BCD2BIN
    PORT(
         BCD : IN  std_logic_vector(15 downto 0);
         BIN : OUT  std_logic_vector(15 downto 0);
         Start : IN  std_logic;
         Idle : OUT  std_logic;
         Clk : IN  std_logic
        );
    END COMPONENT;
    

   --Inputs
   signal BCD : std_logic_vector(15 downto 0) := (others => '0');
   signal Start : std_logic := '0';
   signal Clk : std_logic := '0';

   --Outputs
   signal BIN : std_logic_vector(15 downto 0);
   signal Idle : std_logic;

   -- Clock period definitions
   constant Clk_period : time := 10 ns;
 
BEGIN
 
  -- Instantiate the Unit Under Test (UUT)
   uut: BCD2BIN PORT MAP (
          BCD => BCD,
          BIN => BIN,
          Start => Start,
          Idle => Idle,
          Clk => Clk
        );

   -- Clock process definitions
   Clk_process :process
   begin
    Clk <= '0';
    wait for Clk_period/2;
    Clk <= '1';
    wait for Clk_period/2;
   end process;
 

   -- Stimulus process
   stim_proc: process
   begin    
      BCD <= x"2173";
      wait for 30 ns;  
      start <= '1';
      wait for 30 ns;  
      start <= '0';
      wait until Idle='1';
      wait for 130 ns;  

      BCD <= x"1023";
      start <= '1';
      wait for 30 ns;  
      start <= '0';
      wait until Idle='1';
      wait for 130 ns;  

      BCD <= x"1024";
      wait for 30 ns;  
      start <= '1';
      wait for 30 ns;  
      start <= '0';
      wait until Idle='1';
      wait for 130 ns;  

      BCD <= x"9999";
      wait for 30 ns;  
      start <= '1';
      wait for 30 ns;  
      start <= '0';
      wait until Idle='1';
      wait for 130 ns;  

      BCD <= x"0000";
      wait for 30 ns;  
      start <= '1';
      wait for 30 ns;  
      start <= '0';
      wait until Idle='1';
      wait for 130 ns;  

      wait;
   end process;

END;

---

Aber es gibt immer noch Verbesserungspotential. Basierend auf der Formel

10x + y = 8x + 2x + y

kann diese Multiplikation

tmp <= resize(tmp*10        + unsigned(BCD(idx*4-1 downto idx*4-4)),tmp'length);

durch eine Formelumstellung mit einer zusätzlichen Addition ersetzt werden:

tmp <= resize(tmp*8 + tmp*2 + unsigned(BCD(idx*4-1 downto idx*4-4)),tmp'length);

Der Trick dabei: der Synthesizer erkennt, dass tmp*8 und tmp*2 keine wirklichen Multiplikationen sind, und kann diese Operationen durch ein simples Umverdrahten erledigen. Kurz: es ist kein Multiplizierer nötig, das Design kann schneller getaktet werden...

Üblicherweise geht man beim Umwandeln von Binär nach BCD so vor, dass die Einerstelle gewandelt wird, danach der Rest durch 10 geteilt wird, dann die Zehnerstelle gewandelt wird und so fort.
Die bei diesem Verfahren nötige Division kann umgangen werden, wenn die Wandlung auf der höchsten BCD-Stelle druchgeführt und danach der Rest mit 10 multipliziert wird.

Der Quellcode macht wahrscheinlich gleich klar, wie das gemeint ist:

---

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

entity Vector2BCD is
    Port ( clk      : in  std_logic;
           vector   : in  std_logic_vector (15 downto 0);
           start    : in  std_logic;
           busy     : out std_logic;
           bcd      : out std_logic_vector (19 downto 0));
end Vector2BCD;

architecture Behavioral of Vector2BCD is             
type states is (idle,calc);                          
signal state : states := idle;                       
signal stelle : integer range 0 to 4;
signal wert : integer range 0 to 100000;
begin
   process
   variable x : integer range 0 to 100000;
   begin
      wait until rising_edge(clk);
      busy <= '0';
      case state is
         when idle => 
            wert <= to_integer(unsigned(vector));            
            if (start='1') then 
               stelle <= 4;
               busy <= '1';
               state<=calc;
            end if;
                      
         when calc => 
            x := wert;
            if    (x>=90000) then x:=x-90000; bcd(stelle*4+3 downto stelle*4) <= x"9";
            elsif (x>=80000) then x:=x-80000; bcd(stelle*4+3 downto stelle*4) <= x"8";
            elsif (x>=70000) then x:=x-70000; bcd(stelle*4+3 downto stelle*4) <= x"7";
            elsif (x>=60000) then x:=x-60000; bcd(stelle*4+3 downto stelle*4) <= x"6";
            elsif (x>=50000) then x:=x-50000; bcd(stelle*4+3 downto stelle*4) <= x"5";
            elsif (x>=40000) then x:=x-40000; bcd(stelle*4+3 downto stelle*4) <= x"4";
            elsif (x>=30000) then x:=x-30000; bcd(stelle*4+3 downto stelle*4) <= x"3";
            elsif (x>=20000) then x:=x-20000; bcd(stelle*4+3 downto stelle*4) <= x"2";
            elsif (x>=10000) then x:=x-10000; bcd(stelle*4+3 downto stelle*4) <= x"1";
            else                              bcd(stelle*4+3 downto stelle*4) <= x"0";
            end if;
            wert <= x*10;
                    
            if stelle=0 then
               busy <= '0';
               state <= idle;
            else
               busy <= '1';
               stelle <= stelle-1;
            end if;
            
      end case;
   end process;
end Behavioral;

---

Der Ressourcenverbrauch bei dieser Wandlung hält sich auf einem Spartan3 noch in erträglichen Grenzen: 78 Slices sind wegen der 146 verwendeten LUTs nötig.

Hier noch ein Screenshot der Waveform (weil Bilder immer mehr sagen als Worte):

Sollen Zahlen z.B. an ein Display oder über eine serielle Schnittstelle ausgegeben werden, dann ist es naheliegend, sie zuerst in ein BCD-Format und anschliessend in ASCII umzuwandeln. Das geht ganz einfach: zu jeder der 4-Bit Gruppen der BCD-Zahl wird der ASCII-Wert '0' dazuaddiert. Fertig.
Durch die dafür nötige Hin- und Zurückkonvertiererei wird das aber recht sperrig. Man kann die Sache vereinfachen, wenn man sich die ASCII-Tabelle ansieht und feststellt, dass die relevanten ASCII-Werte einfach für den Wert bei x"30" beginnen und mit dem Wert 9 bei x"39" aufhören. Man muss also nur die x"3" vor die 4-Bit Binärzahl bringen und fertig ist der ASCII Wert.

---

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

entity BCD2ASCII is
    Port ( di : in  STD_LOGIC_VECTOR (3 downto 0);
           do : out STD_LOGIC_VECTOR (7 downto 0));
end BCD2ASCII;

-- Entweder die ASCII-'0' dazuaddieren ...
architecture Behavioral of BCD2ASCII is
begin
     do <= std_logic_vector(to_unsigned(character'pos('0')+to_integer(unsigned(di)),8));
end Behavioral;

-- ... oder einfach den Wert "0011" anhängen.
architecture Behavioral of BCD2ASCII is
begin
     do <= x"3" & di;
end Behavioral;

---

Hier eine rein kombinatorische Umwandlung eines Eingangsvektors nach BCD. Auch diese Umwandlung basiert wie die Lösung Vektor nach BCD auf einem BCD-Schieberegister.

---

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

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

architecture behave of Vector2BCD is
begin
  bcdproc: process(vector)
  variable z : unsigned(stellen*4+breite downto 0) := (others=>'0');
  begin
    z := resize(unsigned(vector),z'length);
    for i in 0 to breite-1 loop
       for s in 0 to stellen-1 loop
          if (unsigned(z(vector'length+s*4+3 downto vector'length+s*4+0))>4) then
             z(z'left downto vector'length+s*4+0) := z(z'left downto vector'length+s*4+0)+3;
          end if;
       end loop;
       z := z(z'left-1 downto 0) & '0';
    end loop;
    bcd <= std_logic_vector(unsigned(z(z'left downto breite)));
  end process bcdproc;
end behave;

---

So schön sich das Ganze liest, ist doch ein gehöriger Aufwand zur Realisierung nötig: 581 Slices bzw. 1080 LUTs werden auf einem Spartan3 verwendet, um die Logik zur Umwandlung eines 16-bit Vektors in eine 5-stellige BCD-Zahl abzubilden. Dass das Ergebnis aufwendig ist, sieht man an der Durchlaufzeit, die ca. 100ns beträgt und am RTL-Schaltplan. Hier ein kleiner Auszug davon:


Dieser Ansatz ist also nur geeignet, wenn Ressourcen keine Rolle spielen.