Subversion Repositories sincos

--------------------------------------------------------------------------------

-- (c) 2011.. Hoffmann RF & DSP  opencores@hoffmann-hochfrequenz.de

-- V1.0 published under BSD license

--------------------------------------------------------------------------------

-- file name:      un_signed_sprt.vhd

-- tool version:   Modelsim 6.1, 6.5

-- description:    additional support routines for signed/unsigned

--                 conversions between real and signed / unsigned

--                 the frac_xxx routines assume the decimal point to the left

--                 so that the range is -0.999999 or 0.0   to +0.9999999

--                 Note that the bits have different weights for unsigned vs. signed

-- calls libs:     ieee standard

--------------------------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

use ieee.math_real.all;

package un_signed_sprt is

  function signed2string       (s:   signed) return string;

  function unsigned2string     (u: unsigned) return string;

  function to_unsigned         (x: std_logic; proto: unsigned) return unsigned;

  function to_signed           (x: std_logic; proto:   signed) return   signed;

  function unsigned2real       (u: unsigned)  return real;

  function signed2real         (s: signed)    return real;

  function fract_unsigned2real (u: unsigned)  return real;

  function fract_signed2real   (s: signed)    return real;

  function fits_into_unsigned  (r: real; proto: unsigned) return boolean;

  function fits_into_signed    (r: real; proto:   signed) return boolean;

  function real2unsigned       (r: real; proto: unsigned) return unsigned;

  function real2signed         (r: real; proto:   signed) return signed;

  function fract_real2unsigned (r: real; proto: unsigned) return unsigned;

  function fract_real2signed   (r: real; proto:   signed) return signed;

end un_signed_sprt;

package body un_signed_sprt is

function signed2string(s: signed) return string is

  variable x: string(1 to s'length);

begin

  for i in s'range loop

    if s(i) = '1' -- damn strong typing

    then

      x(i+1) := '1';

    elsif s(i) = '0'

    then

      x(i+1) := '0';

    else

      x(i+1) := 'X';  -- FIXME includes Z, weak values...

    end if;

  end loop;

  return x;

end;

function unsigned2string(u: unsigned) return string is

  variable x: string(1 to u'length);

begin

  for i in u'range loop

    if u(i) = '1'

    then

      x(i+1) := '1';

    elsif u(i) = '0'

    then

      x(i+1) := '0';

    else

      x(i+1) := 'X';

    end if;

  end loop;

  return x;

end;

-----------------------------------------------------------------------------------------------------------

-- blow up a standard_logic value to an entire singned or unsigned vector

-- proto is the variable that the function return value will be assigned to.

-- It is r/o and delivers only its bounds to the function.

-- (easier than extracting and passing two bounds)

-- Overloads functions of the same name but with different parameters.

function to_unsigned(x: std_logic; proto: unsigned) return unsigned is

  variable u: unsigned(proto'range);

begin

  for n in proto'range loop

    u(n) := x;

  end loop;

  return u;

end function;

function to_signed(x: std_logic; proto: signed) return signed is

  variable s: signed(proto'range);

begin

  for n in proto'range loop

    s(n) := x;

  end loop;

  return s;

end function;

-----------------------------------------------------------------------------------------------------------

-- unsigned-integer conversions are nice but limited to 32 bits in VHDL,

-- without the value 0x8000 0000

-- use reals instead for larger vectors. 

-- Beware that it might be impossible to be bit-accurate

-- but sometimes we only need bigger pseudo-analog vectors.

function unsigned2real (u: unsigned) return real is

        variable r, bit_value: real;

begin

   if u'length < 1 then

      assert false

          report "unsigned2real: input vector has null size, returning 0.0"

          severity WARNING;

      return 0.0;

    end if;

        r := 0.0;

        bit_value := 1.0 ** u'low;

        for i in u'low to u'high loop

                if u(i) = '1'

                then

                        r := r + bit_value;

                elsif u(i) = '0'

                then

                  null;

                else

                  assert false

                  report "unsigned2real(): input vector contains non-01-bits, returning 0.0"

                  severity WARNING;

                  return 0.0;

                end if;

                bit_value := 2.0 * bit_value;

        end loop;

        return r;

end unsigned2real;

function signed2real (s: signed) return real is

        variable result, bit_value: real;

begin

   if s'length < 2 then   -- may be unneccessary

      assert false

          report "signed2real: input vector too short, returning 0.0"

          severity WARNING;

      return 0.0;

    end if;

        result := 0.0;

        bit_value := 1.0 ** s'low;

        for i in s'low to s'high-1 loop

                if s(i) = '1'

                then

                        result := result + bit_value;

                elsif s(i) = '0'

                then

                  null;

                else

                  assert false

                  report "signed2real(): input vector contains non-01-bits, returning 0.0"

                  severity WARNING;

                  return 0.0;

                end if;

                bit_value := 2.0 * bit_value;

        end loop;

  if s(s'high) = '1'

  then

    result := result - bit_value;  -- subtract sign bit again

    return result;

  elsif s(s'high) = '0'

  then

    return result;

  else

    assert false

                  report "signed2real(): sign bit is neither 0 nor 1, returning 0.0"

                  severity WARNING;

                  return 0.0;

  end if;

end signed2real;

-----------------------------------------------------------------------------------------------------------

function fract_signed2real(s: signed) return real is

begin

  return signed2real(s) / (2.0 ** (s'length-1));

end function fract_signed2real;

function fract_unsigned2real(u: unsigned) return real is

begin

  return unsigned2real(u) / (2.0 ** u'length);

end function fract_unsigned2real;

-----------------------------------------------------------------------------------------------------------

function fits_into_unsigned(r: real; proto: unsigned) return boolean is

begin

  return (r >=0.0) and (r < 2.0 ** proto'length);

end;

-- for 8 bits, -128 to +127 would fit

function fits_into_signed(r: real; proto: signed) return boolean is

begin

  return (r >= -(2.0 ** (proto'length-1))) and (r < 2.0 ** (proto'length-1));

end;

------------------------------------------------------------------------------------------------------------

function real2unsigned(r: real; proto: unsigned) return unsigned is

  variable u: unsigned(proto'range);

  variable e: integer;

  variable rr: real := r;   -- r is constant;

begin

  if not fits_into_unsigned(r, proto)

  then

    assert false

    report "real2unsigned(): value does not fit into supplied unsigned "

         & real'image(r)

         & " vs. capacity: 0 to "

         & real'image((2.0 ** proto'length) -1.0)

    severity warning;

    u := to_unsigned('X', u);

  else

    -- extract the bits starting from the highest. 

    e := proto'length -1;

    for n in proto'range loop

      if rr >= 2.0 ** e

      then

        u(n) := '1';

        rr   := rr - 2.0 ** e;

      else

        u(n) := '0';

      end if;

      e := e - 1;

    end loop;

  end if;

  return u;

end function real2unsigned;

function real2signed(r: real; proto: signed) return signed is

  variable s: signed(proto'range);

  variable e: integer;

  variable rr: real := r;   -- r is constant;

  variable neg: boolean;

begin

  neg := r < 0.0;

  rr  := abs(r);

  if not fits_into_signed(r, proto)

  then

    assert false

    report "real2signed(): value does not fit into supplied signed "

         & real'image(rr)

         & " vs. capacity  -"

         & real'image(2.0 ** (proto'length-1))

         & " to +"

         & real'image((2.0 ** (proto'length-1)) -1.0)

    severity warning;

    s := to_signed('X', s);

  else

    -- extract the bits starting from the highest.

    s(proto'high) := '0';

    e := proto'length -1;

    for n in proto'high downto proto'low loop

      if rr >= 2.0 ** e

      then

        s(n) := '1';

        rr   := rr - 2.0 ** e;

      else

        s(n) := '0';

      end if;

      e := e - 1;

    end loop;

  end if;

  if neg

    then s := -s;

  end if;

  return s;

end function real2signed;

-----------------------------------------------------------------------------------------------------------

-- may produce internal overflows for very long vectors

function fract_real2unsigned (r: real; proto: unsigned) return unsigned is

  variable rr: real;

  variable upper_bound: real;

begin

  upper_bound := (1.0 - 2.0** (-proto'length));

  if (r < 0.0 or r > upper_bound )

  then

    assert false

      report "fract_real2unsigned(): arg must be 0.0 .. "

           & real'image(upper_bound)

           & " but it is "

           & real'image(r)

      severity warning;

    return to_unsigned('X', proto);

  end if;

  rr := r * 2.0**proto'length;      -- use the non-fractional routine

  return real2unsigned(rr, proto);

end function fract_real2unsigned;

function fract_real2signed   (r: real; proto:   signed) return signed is

  variable rr: real;

begin

  if (r< -1.0) or (r> 1.0 - (2.0**(-proto'length)))

  then

    assert false

      report "fract_real2unsigned(): arg must be in interval -1.0 to "

           & real'image(1.0 - (2.0**(-proto'length)))  -- FIXME hi bound maybe off by epsilon??

           & " but it is "

           & real'image(r)

      severity warning;

    return to_signed('X', proto);

  end if;

  rr := r * 2.0**(proto'length-1); -- use the non-fractional routine

  return real2signed(rr, proto);

end function fract_real2signed;

end package body un_signed_sprt;