Quel formalisme utiliser ? Et d'autres questions de débutant.
Hello,
Je débute en VHDL, et plusieurs trucs me posent problèmes, notament quel formalisme utiliser dans quelle situation. Pour citer l'introduction au VHDL de Developpez
Citation:
Trois grands formalismes coexistent pour décrire les architectures :
flot de données : on écrit explicitement les fonctions booléennes que l'on veut voir implémentées (à réserver aux plus petits circuits pour des raisons de lisibilité) ; c'est lui qu'on a utilisé pour implémenter le demi-additionneur ;
structurel : on décrit le circuit comme une série de boîtes noires interconnectées au moyen de signaux (utilisé pour des circuits moyens ou grands) ; on procèdera de cette manière pour synthétiser un additionneur complet à l'aide de deux demi-additionneurs ;
comportemental : de manière très semblable à un langage de programmation informatique, on précise le fonctionnement voulu à l'aide d'une suite d'instructions de contrôles plus ou moins évoluées (conditions, boucles, etc.), dans un process.
Par exemple l'article prend l'exemple d'un additionneur sur 1 bit, on pourrait aussi le définir comme ça (pas vraiment sur de la syntaxe - code non testé - mais vous voyez l'idée)
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
entity adder is
generic(REG_SIZE : integer);
port(clk : in std_logic;
i0 : in unsigned(REG_SIZE-1 downto 0);
i1 : in unsigned(REG_SIZE-1 downto 0);
o : out unsigned(REG_SIZE-1 downto 0); -- = i0 + i1
c : out std_logic); -- retenue
end adder;
architecture adder_bhv of adder is
begin
P0: process(clk)
variable tmp : unsigned(REG_SIZE downto 0);
begin
if(rising_edge(clk)) then
tmp := ('0' & i0) + ('0' & i1);
o <= tmp(REG_SIZE-1 downto 0);
c <= tmp(REG_SIZE);
end if;
end process;
end adder_bhv; |
C'est beaucoup plus simple (pas forcément pour 1 bit, mais pour 8+ bits ça simplifie grandement les choses).
Qu'est ce que ça change exactement ? Le circuit généré sera-t-il le même ?
Peut-on voir ça comme l'inline assembly dans un programme C ou C++ : permettre d'implémenter certaines choses d'une manière plus optimisé que ce que le compilo est capable de faire ?
Il est possible de vérifier la logique d'un circuit avec des test benchs, mais est-il possible de vérifier que les timings soient correct ? Ça dépend du matériel sur lequel est implémenté le circuit je suppose, mais est-il possible de simuler ça ?
(J'utilise actuellement GHDL + GTKWave)
Question différente, y à t'il de bonnes références sur Internet, ou de bons bouquins pour se lancer la dedans ?
Apparemment ce livre est bon, quelqu'un peut confirmer / infirmer ?
Et dernière question : le VHDL permet de définir des choses qu'on peut simuler mais pas implémenter sur un FPGA ou un ASIC, comment savoir si du code est implémentable ou pas ?
