Lothar Miller - BCD Umwandlung

BCD nach ASCII

nospam@example.com (Lothar Miller) — Thu, 25 Nov 2010 15:43:53 +0100

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.
Hier werden mehrere Lösungsmöglichkeiten für die Umwandlung einer BCD-Zahl in ein ASCII-Format 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;

-- Dierekte 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!

Vektor nach BCD (kombinatorisch)

nospam@example.com (Lothar Miller) — Mon, 14 Dec 2009 06:31:00 +0100

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:

Ein kleiner Ausschnitt aus dem RTL-Schaltplan

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

Vektor nach BCD

nospam@example.com (Lothar Miller) — Fri, 27 Feb 2009 15:13:10 +0100

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;

Byte nach BCD

nospam@example.com (Lothar Miller) — Mon, 16 Feb 2009 15:32:56 +0100

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