# Fiche VHDL

###### tags: `TSA` `S2` `Fiche`

Les entrées sorties s’appellent des **ports**, les paramètres des **generics**.

**Entity declaration**

entity entity_name is 
    generic(...);
    port(...);
end;

**architecture declaration**

architecture architecture_name of entity_name is
-- ici  des  déclarations (typiquement  de  signaux)
begin
-- ici  des  assignations  simples  ou  instructions  concurrente
send;

### Bibliothèques

Il existe 3 bibliothèques principales

- std, qui contient notamment le package **standard**;
- ieee, qui contient par exemple le package **std_logic_1164**;
- work, qui contient les **design units** et packages du projet

### Types de signaux

Les entrées/sorties sont des signaux par exemple


### Les assignations

**Assignation simple**

target  <= expression;

**Assignation concurrente conditionnelle**

target <=
    value_1 when condition_1 else 
    value_2 when condition_2 else 
    default_value;

**Assignation sélective**

with expression select
    target  <=
        value_1 when choice_1,
        value_2 when choice_2,
        default_value when others;

### Les process

Un process est une partie de code séquentiel dans une architecture.
Bien que le process contienne des instructions séquentielles, il est lui même une instruction concurrente, dans la mesure où il s’exécute en parallèle avec les autres process ou instructions concurrentes de l’architecture.

Un process peut être dans deux états : **suspendu** ou **en train de s’exécuter**.
La condition qui permetà un process de passer du premier au second état peut être écrite de deux manières :
- à l’aide d’une **liste de sensibilité**
- à l’aide d’une **instruction wait**.

**Exemple de process**

process(clock)
begin
    if rising_edge(clock) then 
        q <= not(q);
    end if;
end  process

**NB:** Ce process utilise une liste de sensibilité, elle est optionnelle mais si on en a pas on doit forcément utiliser un wait.

**Meme exemple avec un wait**

process  begin
    wait until rising_edge(clock );
    q <= not(q);
end  process;

## Instruction generate

Permet de modifier la structure hardware à la compilation en fonction d'une condition (typiquement sur une constante de config).

**Structure**

if condition_1 generate
    --instructions  concurrentes;
elsif condition_2 generate
    --instructions  concurrentes;
else  generate
    --instructions  concurrentes;
end  generate

**Structure avec un for**

for generate_parameter in generate_range generate 
    --instructions  concurrentes;
end  generate;

### Opérateurs et opérandes

**Opérateurs classiques logiques arithmétiques et relationnels**

`and` `or` `nand` `nor` `not`

`+` `-` `*` `/`

`=` `/=` `>` `<` `<=` `>=`

**Opérateurs de décalage et de rotation de mots binaires**

`sll` slide left
`srl` slide right
`rol` roll left
`ror` roll right

### Constantes signaux et variables

**Constantes**

constant  CONSTANT_NAME : type_or_subtype_name  := value;

Pour définir des paramètres de manière lisible et généralisées dans le code

**Signal**

signal  signal_name : type_or_subtype_name;

:warning: Un signal ne se modifie **qu'a la fin** de l'éxécution d'un process ! Il est plus loud en mémoire à la simulation qu'une variable mais à une portée globale dans le programme

**Variable**

variable  variable_name : type_or_subtype_name;

Ne peut etre utilisée qu'a l'interieur d'un process

Tableau des différences entre les 2

Suite et fin du tuto résumé du TD plus tard ^^