Menu

Project Gimu

Software research and development

yrCommerce v.10.0 Release

The newest version has been deployed on the main update server.

VHDL Snippets

Entity

entity ENTITY_NAME is
port(
    i_a : in std_logic;
    i_b : in std_logic;
    i_c : in std_logic;
    o_c : out std_logic
);
end entity;

Architecture

Processes run concurrent to each other.

architecture ARCHITECTURE_NAME of ENTITY_NAME is
type states is (q0, q1, q2, q3);
signal state : states; -- end internal signals

begin
-- concurrent code
PROCESS_NAME : process(i_c) -- sensitivity list
begin
    if rising_edge(i_c) then
        -- sequential code
    elsif falling_edge(i_c) then
        -- sequential code
    end if;
end process;
-- concurrent code
end architecture;

Process

process(c_in) is
begin
    if (c_in='1') then
        -- do something
    end if;
end process; 

Process (rising edge)

process(c_in) is
begin
    if (c_in'event and c_in='1') then
        -- do something
    end if;
end process; 
process(c_in) is
begin
    if (rising_edge(c_in)) then
        -- do something
    end if;
end process; 

Component

architecture ARCHITECTURE_NAME of ENTITY_NAME is
component HALF_ADDER
    port (i_x, i_y, i_enable : in std_logic;
    o_result, o_carry : out std_logic );
end component;

begin
HA1 : half_adder port map (i_x => a, i_y => b, i_enable => i_enable, o_result => s1, o_carry => c1);
HA2 : half_adder port map (s1, cin, i_enable, sum, c2); -- defining through order of ports
end architecture;

Using a Component

HA1 : half_adder port map (i_x => a, i_y => b, i_enable => i_enable, o_result => s1, o_carry => c1);
HA2 : half_adder port map (s1, cin, i_enable, sum, c2); -- defining through order of ports

Variables

Sequential, repeated assignments allowed (e.g. in loops).

variable test : std_logic;
variable := '1';

Signals

Concurrent, no repeated assignments allowed within a segment.

signal test : std_logic;
signal <= '1';

Bit Vector

bit_vector : std_logic_vector(1 downto 0);
bit_vector <= "00";
bit_vector'range -- to get the length

Enumeration

type state_type is (state1, state2, state3);
signal state : state_type;

Initial Values

constant value_one : std_logic_vector(5 downto 0) := “100000”; -- not ignored in actual hardware
signal value_two : std_logic_vector(5 downto 0) := “100000”; -- will be ignored outside simulations

Solution: initialize values in reset segment!

if reset = '1' then
    value_one <= "1000000";
end if;

Case

case expression is
    when choice =>
        -- sequence of statements
    when choice2 =>
        -- sequence of statements
    when others =>
        -- optional default case
end case;

Functions

function FUNCTION_NAME (parameter : parameter_type) return type is
    -- declarations
begin
    -- sequential code
end function;

Windows Boot

bootrec /fixmbr
bootrec /fixboot
bootrec /scanos
bootrec /rebuildbcd

Zahlendarstellung im IEEEE Standard 754

32-Bit IEEE Gleitkommadarstellung in Dezimalzahl

Berechnung einer Gleitkommazahl: Z = (-1)^{(V)} * (1 + M) * 2^{(E-BIAS)}

Vorzeichenbit (V): 0 für positiv, 1 für negativ
Mantisse (M): 1,M Darstellung
Charakteristik (E)
Bias (BIAS): B = 2^{(n-1)} - 1 mit n Bits der Charakteristik
Realer Exponent: e_r = E - BIAS

Beispiel:

V E M Zahl
31 30-23 22-0 0 1001 1001 1001 1001 1001 0000 0000 000_2

Dadurch erhalten wir die Aufteilung:
Vorzeichenbit: 0_2
Charakteristik: 1001 1001_2
Mantisse: 1001 1001 1001 0000 0000 000_2

Wir verwenden nun die Formel zur Berechnung einer Gleitkommazahl, dazu werden Mantisse in das Dezimalsystem und der BIAS berechnet.

Trick zur Umwandlung der Basis der Mantisse:
1. letzte 1 suchen und abschneiden
2. vorderer Teil in Dezimalsystem umwandeln und durch 2^{Anzahl \, Bits} teilen

Mantisse:
Vorderer Teil: 1001 1001 1001_2 = 2457_{10}
Anzahl der Bits des vorderen Teils: 2^{12} = 4096
M = 2457/4096

Charakteristik: E = 1001 1001_2 = 153_{10}
Bias: BIAS = 2^{8-1} - 1 = 127

Formel anwenden:
Z = (-1)^{(V)} * (1 + M) * 2^{(E-BIAS)} = (-1)^0 * (1 + 2457/4096) * 2^{(153-127)} = 107364352_{10}

Dezimalzahl in 32-Bit IEEE Gleitkommadarstellung

V E M Zahl
31 30-23 22-0 - 6,25 \cdot 10^{-3}_{10} = - 0,00000\overline{0011}_2

Vorzeichenbit: 1 (da negativ)
Mantisse: Auf (1,M)_2 \cdot 2^e normalisieren und auf 23-Bit (siehe Tabelle) Nachkommastellen runden.

Hier: Links-Shift (8-mal): 0,00000\overline{0011}_2 = 1,1\overline{0011} \cdot 2^{-8}
Daraus erkennbar: Mantisse: 1\overline{0011} und realer Exponent: -8
Mantisse: 1 0011 0011 0011 0011 0011 01 (23-Bit, mit letztem Bit gerundet)
Charakteristik: e_r = E-BIAS \rightarrow E = e_r + 2^{n-1} mit n = 8 (siehe Tabelle).
E = - 8_{10} + 127_{10} = 119_{10} = 01110111_2

Zusammenstellen von Vorzeichenbit, Charakteristik und Mantisse:
1 \, 01110111 \, 1 0011 0011 0011 0011 0011 01_2