1 | %------------------------------------------------------------------------------ |
---|
2 | % $Id: document-morpheo-vhdl_generation-fr.tex 93 2008-12-14 22:58:28Z rosiere $ |
---|
3 | %------------------------------------------------------------------------------ |
---|
4 | |
---|
5 | \SEction{Introduction} |
---|
6 | |
---|
7 | Ce document est une aide pour les développeur des générateurs de modèles VHDL de \cpu. |
---|
8 | Il est décomposé en 5 sections : |
---|
9 | \begin{itemize} |
---|
10 | \item Dans la section \ref{tree}, nous présentons l'arborescence des répertoires. |
---|
11 | \item Dans la section \ref{files}, nous détailerons les fichiers ainsi que leurs contenus. |
---|
12 | \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. |
---|
13 | \item Dans la section \ref{vhdl_body}, nous présenterons l'API pour générer le comportement des composants. |
---|
14 | \item Dans la section \ref{vhdl_structural}, nous expliquerons la manière de créer des sous composants. |
---|
15 | \end{itemize} |
---|
16 | |
---|
17 | \Section{Arborescence}\label{tree} |
---|
18 | |
---|
19 | Dans le répertoire contenant le projet, nous avons les répertoires suivant : |
---|
20 | \begin{description} |
---|
21 | \item[IPs/systemC/processor/Morpheo/Documentation/ :] Contient différent document décrivant certain point du projet, dont ce présent document. |
---|
22 | \item[IPs/systemC/processor/Morpheo/Behavioural/ :] |
---|
23 | \end{description} |
---|
24 | |
---|
25 | \Section{Fichiers}\label{files} |
---|
26 | |
---|
27 | \Section{VHDL : déclaration}\label{vhdl_declaration} |
---|
28 | |
---|
29 | Les déclarations ce font dans le fichier {\it COMPONENT\_vhdl\_declaration.cpp}. |
---|
30 | |
---|
31 | \subSection{Types} |
---|
32 | |
---|
33 | 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 : |
---|
34 | |
---|
35 | \begin{verbatim} |
---|
36 | std::string std_logic (uint32_t size); |
---|
37 | \end{verbatim} |
---|
38 | |
---|
39 | Pour accéder à une partie du vecteur on utilise la fonction {\it std\_logic\_range}. Elle a les prototypes suivant : |
---|
40 | \begin{verbatim} |
---|
41 | std::string std_logic_range (uint32_t size, |
---|
42 | uint32_t max , |
---|
43 | uint32_t min ); |
---|
44 | std::string std_logic_range (uint32_t max , |
---|
45 | uint32_t min ); |
---|
46 | std::string std_logic_range (uint32_t size); |
---|
47 | \end{verbatim} |
---|
48 | |
---|
49 | 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. |
---|
50 | |
---|
51 | \begin{verbatim} |
---|
52 | std::string std_logic_others (uint32_t size, |
---|
53 | uint32_t cst ); |
---|
54 | \end{verbatim} |
---|
55 | |
---|
56 | |
---|
57 | 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. |
---|
58 | |
---|
59 | \begin{verbatim} |
---|
60 | void set_type (std::string name, |
---|
61 | std::string type); |
---|
62 | \end{verbatim} |
---|
63 | |
---|
64 | L'exemple suivant définit un type représentat un tableau de {\it nb\_word} mots de {\it size\_word} bit chacun : |
---|
65 | \begin{verbatim} |
---|
66 | vhdl->set_type ("Tregfile", |
---|
67 | "array "+std_logic_range(nb_word)+" of "+std_logic(size_word)); |
---|
68 | \end{verbatim} |
---|
69 | |
---|
70 | \subSection{Constantes} |
---|
71 | |
---|
72 | 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}. |
---|
73 | |
---|
74 | \begin{verbatim} |
---|
75 | void set_constant (std::string name, |
---|
76 | std::string type, |
---|
77 | std::string init); |
---|
78 | void set_constant (std::string name, |
---|
79 | uint32_t size, |
---|
80 | std::string init); |
---|
81 | void set_constant (std::string name, |
---|
82 | uint32_t size, |
---|
83 | uint32_t init); |
---|
84 | \end{verbatim} |
---|
85 | |
---|
86 | Par exemple pour coder les états d'un automate à 5 états en One Hot : |
---|
87 | \begin{verbatim} |
---|
88 | vhdl->set_constant ("State_idle",5,1); |
---|
89 | \end{verbatim} |
---|
90 | |
---|
91 | \subSection{Signaux internes} |
---|
92 | |
---|
93 | 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}). |
---|
94 | \begin{verbatim} |
---|
95 | void set_signal (std::string name, |
---|
96 | std::string type); |
---|
97 | void set_signal (std::string name, |
---|
98 | uint32_t size); |
---|
99 | \end{verbatim} |
---|
100 | |
---|
101 | La méthode est également surchargé si le signal à besoin d'une initialisation. |
---|
102 | |
---|
103 | \begin{verbatim} |
---|
104 | void set_signal (std::string name, |
---|
105 | std::string type, |
---|
106 | std::string init); |
---|
107 | void set_signal (std::string name, |
---|
108 | uint32_t size, |
---|
109 | std::string init); |
---|
110 | void set_signal (std::string name, |
---|
111 | uint32_t size, |
---|
112 | uint32_t init); |
---|
113 | \end{verbatim} |
---|
114 | |
---|
115 | |
---|
116 | |
---|
117 | %\begin{verbatim} |
---|
118 | %void set_alias (std::string name1 , |
---|
119 | % std::string type1 , |
---|
120 | % std::string name2 , |
---|
121 | % std::string range2); |
---|
122 | %void set_alias (std::string name1 , |
---|
123 | % uint32_t size1 , |
---|
124 | % std::string name2 , |
---|
125 | % std::string range2); |
---|
126 | %\end{verbatim} |
---|
127 | |
---|
128 | |
---|
129 | \Section{VHDL : comportement}\label{vhdl_body} |
---|
130 | |
---|
131 | \Section{VHDL : structurelle}\label{vhdl_structural} |
---|