pkg_xilinx.vhd

使用ＩＤＥＬＡＹ实现８倍过采样异步串行信号恢复信号

    --  Wrap around unsigned substractor
    --
    function sub_wrap( inpA, inpB, ceiling : integer ) return integer is
        variable result : integer;
    begin
        if inpA - inpB >= 0 then
            result := inpA - inpB;
        else
            result := inpA - inpB + (ceiling+1);
        end if;

        return result;
    end;

    --  Bus inversion.  Invert din when inv = '1'
    --
    function busInv( din : std_logic_vector; inv : std_logic ) return std_logic_vector is
        constant W      : integer := din'length;

        variable dout   : std_logic_vector( W-1 downto 0);
    begin
        if inv = '0' then
            dout := din;
        else
            for i in 0 to W-1 loop
                dout(i) := din(W-1-i);
            end loop;
        end if;

        return dout;
    end;

    --  Making 1 bit into a bus with the value of that bit
    --
    function bitToBus( din : std_logic; width : integer ) return std_logic_vector is
        constant W      : integer := width;
        variable dout   : std_logic_vector(W-1 downto 0);
    begin
        for i in 0 to W-1 loop
            dout(i) := din;
        end loop;

        return dout;
    end;

    --  Integer to Hex for 1 char
    --
    function int_to_h_1( inp : integer range 0 to 15 ) return string is
        type TABLE is array (0 to 15) of string (1 to 1);
        constant conv_table : TABLE := ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F");
    begin
        if inp < 0 or inp > 15 then
            return "0";
        end if;
        return conv_table(inp);
    end;

    --  Vector to hex for 1 char
    --
    function lv_to_h_1( inp : std_logic_vector(3 downto 0) ) return string is
        variable int    : integer;
    begin
        int := lv_to_int( inp, UNUM );
        return int_to_h_1(int);
    end;

    --  Vector to hex for multiple char
    --
    function lv_to_h(inp : std_logic_vector; N_CHAR : integer) return string is
        constant W      : integer := N_CHAR*4;
        variable inp_i  : std_logic_vector(W-1 downto 0);
        variable lv4    : std_logic_vector(3 downto 0);
        variable str    : string( N_CHAR downto 1);
    begin
        if inp'length /= W then
            inp_i := std_logic_vector(resize( unsigned(inp), W ));
        else
            inp_i := inp;
        end if;

        for i in 1 to N_CHAR loop
            lv4     := inp_i( (i-1)*4+3 downto (i-1)*4 );
            str     := lv_to_h_1(lv4) & str(N_CHAR downto 2);
        end loop;

        return str;
    end;

    --  Integer to Hex for multiple char
    --
    function int_to_h( inp : integer range 0 to 9999; N_CHAR : integer ) return string is
        constant W      : integer := N_CHAR*4;
        variable lv     : std_logic_vector(W-1 downto 0);
    begin
        lv  := int_to_lv(inp, W, UNUM);
        return lv_to_h(lv, N_CHAR);
    end;

    -- sub-function for int_to_a. convert 1-digit integer to string
    --
    function int_to_a_1 (inp : integer range 0 to 9) return string is
        type TABLE is array (0 to 9) of string (1 to 1);
        constant conv_table : TABLE := ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");
    begin
        if inp < 0 or inp > 9 then
            return "0";
        end if;
        return conv_table(inp);
    end int_to_a_1;

    -- convert integer value to string
    function int_to_a (inp : integer range -9999 to 9999) return string is
        variable str1   : string(1 downto 1);
        variable str2   : string(2 downto 1);
        variable str3   : string(3 downto 1);
        variable str4   : string(4 downto 1);
        variable str5   : string(5 downto 1);

        variable abs_i  : natural;
        variable sign   : integer;
        variable dig1   : integer;
        variable dig2   : integer;
        variable dig3   : integer;
        variable dig4   : integer;
    begin

        if inp < 0 then sign := -1;
        else sign :=  1;
        end if;

        abs_i := abs(inp);

        if abs_i > 9999 then
            return "0";
        end if;

        dig4 := abs_i / 1000;
        dig3 := (abs_i - dig4*1000) / 100;
        dig2 := (abs_i - dig4*1000 - dig3*100) / 10;
        dig1 := (abs_i - dig4*1000 - dig3*100 - dig2*10);

        if sign > 0 then
            if dig4 > 0 then
                str4 := int_to_a_1(dig4) & int_to_a_1(dig3) & int_to_a_1(dig2) & int_to_a_1(dig1);
                return str4;
            elsif dig3 > 0 then
                str3 := int_to_a_1(dig3) & int_to_a_1(dig2) & int_to_a_1(dig1);
                return str3;
            elsif dig2 > 0 then
                str2 := int_to_a_1(dig2) & int_to_a_1(dig1);
                return str2;
            else
                str1 := int_to_a_1(dig1);
                return str1;
            end if;
        else
            if dig4 > 0 then
                str5 := "-" & int_to_a_1(dig4) & int_to_a_1(dig3) & int_to_a_1(dig2) & int_to_a_1(dig1);
                return str5;
            elsif dig3 > 0 then
                str4 := "-" & int_to_a_1(dig3) & int_to_a_1(dig2) & int_to_a_1(dig1);
                return str4;
            elsif dig2 > 0 then
                str3 := "-" & int_to_a_1(dig2) & int_to_a_1(dig1);
                return str3;
            else
                str2 := "-" & int_to_a_1(dig1);
                return str2;
            end if;
        end if;
    end function int_to_a;

    -- Create an RLOC string with offset
    function GET_RLOC( x : integer; y : integer; orig_x : integer := 0; orig_y : integer := 0)
    return string is
        variable Col    : integer;
        variable Row    : integer;
    begin
        Col := x + orig_x;
        Row := y + orig_y;

        return "X" & int_to_a(Col) & "Y" & int_to_a(Row);
    end function GET_RLOC;

    -- Get_RLOC32
    -- place d-ff within 4 CLBs. Virtex2 only.
    function GET_RLOC32 ( inp   : integer; orig_x : integer := 0; orig_y : integer := 0 )
    return string is
        variable Row    : integer;
        variable Col    : integer;
    begin
        Row := (inp mod 32) / 2 + orig_y;
        Col := inp / 32 + orig_x;
        return "X" & int_to_a(Col) & "Y" & int_to_a(Row);
    end function GET_RLOC32;

    -- GET_RLOC16
    -- place d-ff within 2 CLBs. Virtex2 only.
    function GET_RLOC16 ( inp   : integer; orig_x : integer := 0; orig_y : integer := 0  )
    return string is
        variable Row    : integer;
        variable Col    : integer;
    begin
        Row := (inp mod 16) / 2 + orig_y;
        Col := inp / 16 + orig_x;
        return "X" & int_to_a(Col) & "Y" & int_to_a(Row);
    end function GET_RLOC16;

    -- GET_RLOC16_GRID
    -- place d-ff within 2 CLBs. Virtex2 only. RPM_GRID system
    function GET_RLOC16_GRID ( inp : integer; orig_x : integer := 0; orig_y : integer := 0  )
    return string is
        variable Row    : integer;
        variable Col    : integer;
    begin
        Row := (inp mod 16) + orig_y;
        Col := (inp / 16)*3 + orig_x;
        return "X" & int_to_a(Col) & "Y" & int_to_a(Row);
    end function GET_RLOC16_GRID;

    -- GET_RLOC16_PACK1
    -- place one d-ff in one slice. Virtex2 only.
    function GET_RLOC16_PACK1 ( inp : integer; orig_x : integer := 0; orig_y : integer := 0  )
    return string is
        variable Row    : integer;
        variable Col    : integer;
    begin
        Row := (inp mod 16) + orig_y;
        Col := inp / 16 + orig_x;
        return "X" & int_to_a(Col) & "Y" & int_to_a(Row);
    end function GET_RLOC16_PACK1;


    -- GET_RLOC8
    -- place d-ff within 1 CLBs. Virtex2 only.
    function GET_RLOC8 ( inp    : integer; orig_x : integer := 0; orig_y : integer := 0  )
    return string is
        variable Row    : integer;
        variable Col    : integer;
    begin
        Row := (inp mod 8) / 2 + orig_y;
        Col := inp / 8 + orig_x;
        return "X" & int_to_a(Col) & "Y" & int_to_a(Row);
    end function GET_RLOC8;

    -- GET_RLOC8_PACK1
    -- place one d-ff in one slice. Virtex2 only.
    function GET_RLOC8_PACK1 ( inp  : integer; orig_x : integer := 0; orig_y : integer := 0  )
    return string is
        variable Row    : integer;
        variable Col    : integer;
    begin
        Row := (inp mod 8) + orig_y;
        Col := inp / 8 + orig_x;
        return "X" & int_to_a(Col) & "Y" & int_to_a(Row);
    end function GET_RLOC8_PACK1;

end PKG_XILINX;