%------------------------------------------------------------------------------
% $Id: document-morpheo-vhdl_generation-fr.tex 93 2008-12-14 22:58:28Z rosiere $
%------------------------------------------------------------------------------

\SEction{Introduction}

Ce document est une aide pour les développeur des générateurs de modèles VHDL de \cpu.
Il est décomposé en 5 sections :
\begin{itemize}
\item Dans la section \ref{tree}, nous présentons l'arborescence des répertoires.
\item Dans la section \ref{files}, nous détailerons les fichiers ainsi que leurs contenus.
\item Dans la section \ref{vhdl_declaration}, nous expliciterons l'API ({\it Application Programming Interface}) pour la déclaration des signaux et des types du VHDL.
\item Dans la section \ref{vhdl_body}, nous présenterons l'API pour générer le comportement des composants.
\item Dans la section \ref{vhdl_structural}, nous expliquerons la manière de créer des sous composants.
\end{itemize}

\Section{Arborescence}\label{tree}

Dans le répertoire contenant le projet, nous avons les répertoires suivant :
\begin{description}
\item[IPs/systemC/processor/Morpheo/Documentation/ :] Contient différent document décrivant certain point du projet, dont ce présent document.
\item[IPs/systemC/processor/Morpheo/Behavioural/ :]
\end{description}

\Section{Fichiers}\label{files}

\Section{VHDL : déclaration}\label{vhdl_declaration}

Les déclarations ce font dans le fichier {\it COMPONENT\_vhdl\_declaration.cpp}.

\subSection{Types}

Le type de base utilisé est le {\it std\_logic\_vector} (ou std\_logic si le vecteur est sur un seul bit). Pour cela on utilise la fonction suivante :

\begin{verbatim}
std::string std_logic (uint32_t size);
\end{verbatim}

Pour accéder à une partie du vecteur on utilise la fonction {\it std\_logic\_range}. Elle a les prototypes suivant :
\begin{verbatim}
std::string std_logic_range (uint32_t size,
                             uint32_t max ,
                             uint32_t min );
std::string std_logic_range (uint32_t max ,
                             uint32_t min );
std::string std_logic_range (uint32_t size);
\end{verbatim}

La première fonction fais un test sur la taille que la seconde ne fait pas. L'argument de la troisième définit la taille ce qui implique que la borne minimum est 0.

\begin{verbatim}
std::string std_logic_others (uint32_t size,
                              uint32_t cst  );
\end{verbatim}


Pour les types plus complexe, la classe {\it Vhdl} possède une méthode générique. Le premier argument est le nom du type le second est le type.

\begin{verbatim}
void set_type (std::string name,
               std::string type);
\end{verbatim}

L'exemple suivant définit un type représentat un tableau de {\it nb\_word} mots de {\it size\_word} bit chacun :
\begin{verbatim}
vhdl->set_type ("Tregfile", 
                "array "+std_logic_range(nb_word)+" of "+std_logic(size_word));
\end{verbatim}

\subSection{Constantes}

La déclaration de constante, ce fait avec la méthode {\it set\_constant} de la classe {\it Vhdl}. Les différentes surcharges de cette méthode est le type des arguments {\it type} et {\it init}. 

\begin{verbatim}
void set_constant (std::string name,
                   std::string type,
                   std::string init);
void set_constant (std::string name,
                   uint32_t    size,
                   std::string init);
void set_constant (std::string name,
                   uint32_t    size,
                   uint32_t    init);
\end{verbatim}

Par exemple pour coder les états d'un automate à 5 états en One Hot :
\begin{verbatim}
vhdl->set_constant ("State_idle",5,1);
\end{verbatim}

\subSection{Signaux internes}

Les signaux internes sont définit grâce au méthode {\it set\_signal}. Le premier argument est le nom du signal. Le second est soit un type soit une taille (dans le cas où le type est un  {\it std\_logic\_vector}).
\begin{verbatim}
void set_signal (std::string name,
                 std::string type);
void set_signal (std::string name,
                 uint32_t    size);
\end{verbatim}

La méthode est également surchargé si le signal à besoin d'une initialisation.

\begin{verbatim}
void set_signal (std::string name,
                 std::string type,
                 std::string init);
void set_signal (std::string name,
                 uint32_t    size,
                 std::string init);
void set_signal (std::string name,
                 uint32_t    size,
                 uint32_t    init);
\end{verbatim}



%\begin{verbatim}
%void set_alias (std::string name1 ,
%                std::string type1 ,
%                std::string name2 ,
%                std::string range2);
%void set_alias (std::string name1 ,
%                uint32_t    size1 ,
%                std::string name2 ,
%                std::string range2);
%\end{verbatim}


\Section{VHDL : comportement}\label{vhdl_body}

\Section{VHDL : structurelle}\label{vhdl_structural}
