= Contents =
  - [[#VHDL|VHDL]]
    - [[#VHDL#Generell struktur|Generell struktur]]
    - [[#VHDL#Exempelkrets|Exempelkrets]]
    - [[#VHDL#Datatytper|Datatytper]]
      - [[#VHDL#Datatytper#std_logic|std_logic]]
      - [[#VHDL#Datatytper#std_logic_vector|std_logic_vector]]
    - [[#VHDL#Typer av satser|Typer av satser]]
      - [[#VHDL#Typer av satser#process|process]]
        - [[#VHDL#Typer av satser#process#if-then-else|if-then-else]]
      - [[#VHDL#Typer av satser#with-select-when|with-select-when]]
      - [[#VHDL#Typer av satser#when-else|when-else]]
    - [[#VHDL#Operatorer|Operatorer]]
    - [[#VHDL#Bibliotek|Bibliotek]]
      - [[#VHDL#Bibliotek#Numeric_std|Numeric_std]]

= VHDL =

- VHDL :: VHSIC HDL
- VHSIC :: Very High Speed Integrated Circuits
- HDL :: Hardware Description Language

Verilog mer hacker-vänligt, vanligare i USA

VHDL vanligare i Europa

Mycket av de här anteckningarna basserar sig på ISY's föreläsning om
grunderna i VHDL.
[[http://www.isy.liu.se/edu/kurs/TSEA22/forelasning/bilder10.pdf|Bilder kanske finns här]]

== Generell struktur ==

Gränssnitt mot omvärlden
{{{vhdl
entity namen1 is
  -- Beskrivning av in och utgångar
end entity namn1;
}}}

Intern implementation.
{{{vhdl
architecture namn2 of namn1 is
  -- beskrivning av interna signaler
begin
  -- Beskrivning av funktion
end architecture namn2;
}}}

== Exempelkrets ==

Uttrycket

{{$
\begin{aligned}
c             &= \neg (x \vee y) \\
\text{där } x &= a \wedge b \\
            y &= a \vee b
\end{aligned}
}}$

kan i VHDL realiseras som:

{{{vhdl
entity knet is
    port (a, b : in std_logic;
          c: out std_logic);
end entity knet;
  
architecture fisttry of knet is
  signal x, y : std_logic;
begin
  c <= not (x or y);
  x <= a and b;
  y <= a or b;
end architecture fisttry;
}}}
.


== Datatytper ==
Mycket hårt typat, men nästan inga datatyper. Så nästintill allting
måste deffinieras upp själv. Standardbibliotek lägger dock till
allting man behöver.

Konstiga fulhak undanbedes.

Standardbiblioteket importeras enkalst genom
{{{VHDL
library ieee;                     -- Berätta att biblioteket finns.
use ieee.std_logic_1164.all; -- Importera det vi vill ha (allt)
}}}

=== std_logic ===
"bit" typ (Namnet bit var tydligen redan upptaget).

Kan ha värdena `01uxz-wlh`.

- `U` Uninitialized
- `X` Forceing unkwon (i simulering när flera utgångar försöker driva signalen)
- `0` tvingad låg
- `1` tvingad hög
- `Z` High impedance (högohmig) (Tri state, stäng av komponenent)
- `-` Don't care 

=== std_logic_vector ===
Vektor av bitar.

Storlek skrivs antingen med `to` eller `downto`. Notera att de är
sepparat implementerade, och man ska hålla sig till den ena om man
inte vet vad man gör.

{{{VHDL
std_logic_vector (0 to 2);
std_logic_vector (5 downto 2);
}}}

== Typer av satser ==

Allting i VHDL är paralellt by default, dock finns:

=== process ===
`process` låter ett block köra i sekventiell ordning. Dock kör alla
`process`-block paralellt gämte varandra. 

{{{VHDL
entity de is
  port ( d, clk : in  STD_LOGIC;
         q      : out STD_LOGIC);
end de;

architecture d_vippa of de is
begin
  -- processer kan namnges (frivilligt)
  name: process(clk) -- processen körs när när någon av signalerna i
               -- "känslighetslistan" ändras. I det här fallet clk.
  begin
    if rising_edge(clk) then -- Kolla efter positiv flak. 
      q <= d;
    end if;
    -- q ligger kvar om inget annat anges.
  end process;
  -- först här har q sitt nya värde.
end d_vippa;
}}}

==== if-then-else ====
I [[#process|process-satser]] kan if-satser finnas.

{{{VHDL
if <expr 1> then
    <statement 1>; 
elsif <expr 2> then -- notera felstavning
    <statement 2>
else
    <statement n>
end if
}}}

=== with-select-when ===
För det här stycket, samt [[#when-else]] används följande `entity`:

{{{VHDL
entity mux is
    port (d : in std_logic_vector (0 to 3);
          s : in std_logic_vector (1 downto 0);
          y : out std_logic_vector);
end entity mux;
}}}

Är begränsad till att högerledet måste vara ett "simpelt" uttryck.

Är en mux.

{{{VHDL
architecture behavior1 of mux is
begin
    with s select
        y <= d(0) when "00",
             d(1) when "01",
             d(2) when "10",
             d(3) when others;
end architecture behavior1;
}}}

=== when-else ===
Tillåter "krångliga" uttryck i högerledet.

Första sanna villkoret bestämmer. Allting körs parallellt?

Är en generaliserad mux.

{{{VHDL
architecture behavior2 of mux is
begin
  y <= d(0) when s = "00" else
       d(1) when s = "01" else
       d(2) when s = "10" else
       d(3);
end architecture behavior2;
}}}

== Operatorer ==
- `&` :: konkattenerirng, (`'0' & '1' = "01"`).

== Bibliotek ==
=== Numeric_std ===
{{{VHDL
use ieee.numeric_std.all
}}}

Låter oss även hantera en bitvektor som ett tal. 

{{{VHDL
signal q : unsigned (3 downto 0);

q <= q + 1;
if q = 10 ...
   q <= "0011";
   q(0) <= '1';
}}}