\chapter{Popis jazyka VHDL}
\label{popis_vhdl}
\section{Úvod}
Zde je uveden stručný popis tohoto jazyka, úplný popis je k dipsozici 
viz. \cite{VHDLmanual} nebo \cite{VHDLguide}. 
Jazyk {\bf VHDL}\footnote{VHDL = Very high speed integrated circuit 
Hardware Description Language }
je určen k použití ve všech fázích návrhu elektronických systému,  
podporuje vývoj, syntézu a testování hardwarových návrhů. Umožňuje popisovat 
číslicové systémy na různé úrovni abstrakce. Primární jednotkou abstrakce 
je entita. 
Každý spustitelný program ve {\bf VHDL} je tvořen alespoň ze dvou samostatných 
jednotek, entity a její architektury a má podobu modelu. Entita specifikuje 
rozhraní modelu tj. vstupní a výstupní porty  kterými může komunikovat s okolím. 
Architektura definuje vnitřní popis modelu který může být popsán buď chováním nebo 
strukturou s použitím dalších komponent z nichž každá je definovaná opět dvojicí 
entita a architektura. Samotný program může být tedy použit jako komponenta 
v jiném složitějším modelu tzn. návrh je hierarchický. Každá entita může mít 
více alternativních popisů (architektur).

Architektura nabízí dvě různá prostředí ve kterých ji můžeme popsat jedná se buď 
o prostředí sekvenční nebo prostředí paralelní. Sekvenční prostředí slouží k 
popisu chování (algoritmicky) a to lze popsat procesem, podprogramem nebo funkcí. 
Paralelní prostředí popisuje vazby mezi bloky strukturním popisem tj. hierarchie 
dílčích komponent, nebo pomocí data-flow popisu (paralelní příkazy).

{\bf VHDL} podporuje také knihovny s knihovními jednotkami. Knihovna fyzicky 
existuje jako adresář který obsahuje soubory s knihovními jednotkami. 
Každá knihovní jednotka je samostatně analyzovatelná část. Knihovní jednotku 
tvoří primární a sekundární jednotky (popis viz. níže). V každém programu jsou 
dvě předdefinované knihovny. Pracovní knihovna \verb|work| a standardní knihovna 
\verb|std|. Pokud se v programu používají jednotky z jiných 
knihoven musí být zviditelněny.

VHDL je typový jazyk obsahuje 4 základní skupiny typů: 
\begin{itemize}
\item Skalární (diskrétní , real, výčtový)
\item Složené typy (pole , záznamy)
\item Přístupový typ (ukazatel)
\item Soubor (file)
\end{itemize}
Typy existují jako předdefinované v knihovnách nebo lze deklarovat i vlastní 
typy. Také je možné definuvat různé podtypy dat: vymezení podmnožiny hodnot 
určitého předem deklarovanécho typu. Deklarace typů neobsahují pouze rozsah 
hodnot ale definují i funkce operátorů. VHDL je silně typový jazyk, konverze 
mezi typy musí být uvedeny explicitně. Základní typy mají své předdefinované 
atributy (vlastnosti).

\section{Objekty}
Nejedná se o objekty jako v klasickém objektově orientovaném jazyce, 
jejich účelem zde je reprezentovat atributy simulovaného systému. 
{\bf VHDL} obsahuje 3 třídy obejktů: {\bf constant} (nemění hodnoty, sekv. i par. 
prostředí), {\bf variable} (mění hodnoty, sekv. prostředí), 
{\bf signal} (mění hodnoty, sekv. i par. prostředí). Každý objekt 
ve {\bf VHDL} musí být nějakého datového typu. Objekty mají své 
předdefinované atributy.

\section{Atributy}
Slouží k přidání informace (vlasnosti) pojmenovaným jednotkám: entita, 
architektura, konfigurace, procedura, funkce, package, type, podtyp, 
constant, signal, variable, komponenta, label, literal, group nebo soubor. 
Atribut je tvořen dvojicí jméno + hodnota. Než bude nějakému objektu přiřazen 
atribut musí být nejdříve deklarován. Deklarace se skládá se jména atributu a  
datového typu jeho hodnoty.

\section{Rozhraní}
Popis rozhraní se vyskytuje u entity, komponenty, podprogramu (funkce ,procedura) 
nebo bloku. Je tvořeno seznamem jednotlivých objektů rozhraní. U rozhraní 
portů (entita,komponenta,blok) tvoří objekty rozhraní deklarace signálů:
\begin{verbatim}
[signal] identifier_list:[mode] subtype_indication [bus] [:= static_expression]
\end{verbatim}
U rozhraní generických parametrů (entita,komponenta,blok)  tvoří objekty rozhraní 
deklarace konstanty:
\begin{verbatim}
[constant]identifier_list:[in]subtype_indication[:=static_expression]
\end{verbatim}
Objekty rozhraní u rozhraní parametrů podprogramu tvoří deklarace signálů, 
konstant, proměnných nebo souborů.


\section{Program}
Soubor s programem může obsahovat příkazy pro zviditelnění knihoven a 
knihovních jednotek, a deklarace primárních a sekundárních jednotek. 
Sekundární jednotka musí být definována až po deklaraci jí příslušné 
primární jednotky.

\begin{verbatim}
Library IEEE;  -- Zviditelnění knihovny
Use ieee.std_logic_1164.all;  -- Zviditelnění package
\end{verbatim}

Primární jednotky:
\begin{itemize}
\item Deklarace entity (entity)
\item Deklarace konfigurace (configuration)
\item Deklarace balíčku (package)
\end{itemize}

Sekundární jednotky:
\begin{itemize}
\item	Tělo architektury (architecture)
\item	Tělo balíčku (package body)
\end{itemize}

\section{Deklarace Entity}
\begin{verbatim}
entity jmeno_entity is 
	-- generické parametry
port ( a,b : in std_logic; sum,carry: out std_logic  ) ;
-- deklarační část 
[ begin 
 -- příkazová část entity
end [ entity ] [jmeno_entity] ;
\end{verbatim}

{\bf Generické parametry: }\\
Slouží k předaní statické ( konstantní ) informace entitě zvenčí.
Generické parametry jsou nepovinné.

{\bf Porty: }\\
Každý port rozhraní má definované své jméno,  svůj mód [in, out, inout, buffer,
linkage] a datový typ. Deklarace portů je nepovinná.

{\bf Deklarační část:}\\
V této části mohou být deklarace podprogramů, typů, podtypů, konstant a atributů.

{\bf Příkazová část:}\\
V této části mohou být pouze pasivní příkazy tzn. ty které nemění hodnoty 
žádných signálů. Jedná se o příkaz assert (kontroluje zadanou podmínku a 
popř. zaloguje report o chybě), pasivní proces a pasivní volání procedury.


\section{Deklarace architektury}
Architektura popisuje vnitřní strukturu nebo funkci entity, může být 
popsána strukturou, datovými toky nebo chováním. Tyto popisy mohou být 
kombinovány i v rámci jedné architektury.  Skládá se z deklarační části 
a části příkazů.

\begin{verbatim}
architecture jmeno_arch of jmeno_entity is 
-- deklarační část architektury
    begin 
-- příkazová část architektury 
 end [ architecture ] [ architecture_simple_name ] ;
\end{verbatim}

Deklarační část může obsahovat deklarace typů, signálů, konstant, 
subprogramů (funkce a procedury), komponent a skupin (groups ).

\subsection{Paralelní prostředí}
Pořadí výpočtu je zde dáno aktivitou signálů. Paralelní příkazy v architektuře 
definují vztah mezi vstupy a výstupy. Tento vztah může být vyjádřen několika 
typy příkazů: Paralelní přiřazení signálu, vytvoření instance komponenty, 
volání procedury, příkaz generate, příkaz assert a příkaz bloku.

{\bf Data Flow popis architektury:}\\
Popis architektury datovými toky je realizován paralelním příkazem přiřazení signálu.
Každý z těchto příkazů je proveden když nastane nějaká změna na vstupním 
signálu obsaženým v tomto příkazu. Tyto příkazy mohou být podmíněné nebo nepodmíněné.
\begin{verbatim}
	Nepodmíněný příkaz: output <= input1 or input2;
	Podmíněný příkaz: output <= input1 when input2 ='0' else '1';
\end{verbatim}

{\bf Strukturní popis architektury:}\\
Tento popis vyjadřuje konkrétní vazby mezi dílčími jednotkami, 
zahrnuje jejich modely. Umožňuje vytvořit hierarchický popis tzn. 
že zapojená jednotka může mít opět strukturní architekturu 
složenou s dalších dílčích jednotek.

\begin{verbatim}
Architecture struct_arch of adder is
		signal sum_int,carry1,carry2 : std_logic;
		component half_adder 
			port( a,b : in std_logic;
			         sum,carry:out std_logic);
		end component;
begin
		--příkazová část
end;
\end{verbatim}

Strukturní popis je realizován pomocí komponent a lokálních signálů 
(propojovací vodiče). Komponenta slouží k rezervaci místa pro vnoření entit, 
lze si ji představit jako sokl na desce plošných spojů do kterého se zapojí 
konkrétní obvod (entita). Do jedné komponenty lze tedy zapojit různé entity 
(musí mít shodné rozhraní). Přiřazení entit a architektur dílčím komponentám 
se říká konfigurace a lze ji provést více způsoby. Instalace (zapojení) komponent 
do architektury se provádí v příkazové časti.

{\bf Osazení (konfigurace) komponenty:}\\
Pokud komponenta a entita mají stejné jméno a rozhraní lze explicitní konfiguraci 
vynechat komponenta bude automaticky nakonfigurována s entitou se shodným jménem. 
Jinak pomocí příkazu konfigurace komponenty v dekl. části architektury:
\begin{verbatim}
		for ha_1 : half_adder use entity work.half_adder2(arch_1);
\end{verbatim}

{\bf Mapování portů entity a komponenty:}\\
Následuje po konfiguraci komponenty. Pokud se shodují jména odpovídajících si 
portů entity a komponenty lze mapování vynechat, jinak nutno mapovat explicitně 
pomocí  port map.

{\bf Instalace komponent:}\\
Provádí se v příkazové části architektury. Každá komponenta může být v 
architektuře nainstalována vícekrát, v zapojení jsou z nich vytvořeny instance 
které jsou označeny jménem. Mapování portů komponenty se realizuje  příkazem 
\verb|port map|, který připojuje porty komponenty k portům entity nebo k lokálním 
signálům.
\begin{verbatim}
Jmenné mapování:
			ha_1 : half_adder port map (  a => x, b => y, sum => z, carry => w);
Poziční mapování na signály x,y,z,w:
			ha_1 : half_adder port map (  x, y, z, w);
\end{verbatim}

{\bf Přímá instalace komponent:}\\
Osazení entitou je provedeno přímo v příkazové části při instalaci, díky tomu 
odpadá deklarace komponenty.
\begin{verbatim}
ha_1: entity work.half_adder2(arch_1) port map(x,y,z,w);
\end{verbatim}

\subsection{Sekvenční prostředí ( popis chování )}
Příkazy jsou vykonávány sekvenčně v pořadí jakém jsou napsány. Sekvenční 
prostředí existuje pouze v příkazové části procesu, procedury nebo funkce. 
Přímo v příkazové části architektury je prostředí paralelní. 

{\bf Proces:}\\
Příkaz procesu je jeden z paralelních příkazů jehož funkce je popsána 
sekvenčním algoritmem. Deklarace procesu může obsahovat citlivostní seznam 
signálů při jejichž změně bude proces spuštěn.

\begin{verbatim}
[process_label:] process [ ( sensitivity_list ) ] [ is ]
  process_declarations 
   	 begin 
    	 sequential_statements 
  end process [ process_label ] ; 
\end{verbatim}

\section{Deklarace a tělo Knihovní jednotky (package)}
Package je jednotka která slouží k seskupování různých deklarací, které mohou 
 poté sdíleny a použity v různých návrzích. Knihovní jednotky (packages) jsou 
 ukládány do knihoven. Package se skládá s deklarace  (povinná) a těla 
 které je nepovinné.
Smyslem package je deklarovat sdílené typy,podtypy,konstanty, signály, soubory, 
aliasy, komponenty a atributy, použitelné ve větším počtu návrhů. Položky 
deklarované v jednotce se v návrhu zpřístupní pomocí klauzule use.




















