BENNANI Mohamed NAUDOT François

Liaison série RS232 en émission

Année universitaire : 2022 - 2023 TP CNP

1
BENNANI Mohamed NAUDOT François

Sommaire

I. Présentations du projet 3

II. Principe de fonctionnement de la liaison série en émission 3

III. Création du code VHDL pour configurer la FPGA : 5

III.1 Processus d’envoi du message : 5
III.2 Création de l’Horloge de 9600 Hz : 8
III.3 Regroupement des deux process : 9

IV. Test de notre programme et correction : 11

V. Conclusion 16

2
BENNANI Mohamed NAUDOT François

I. Présentations du projet

Notre projet lors de ce TP de Circuits Numériques Programmables, est de réaliser

l’interface d’une liaison série RS232 en émission. Nous utiliserons pour réaliser ce projet, le
logiciel Altium, une nanoboard muni d’une FPGA et d’un port série RS232. Pour visualiser
les données envoyées depuis la nanoboard, nous utiliserons le logiciel Hyperterminal qui
jouera le rôle de de récepteur dans la liaison série.
La configuration du port série du pc seront:
- un débit de 9600 bauds/seconde
- un nombre de bits de donnée de 8
- aucun bits de parité
- 1 bit d’arrêt
- pas de contrôle de flux
Il faudra donc configurer le port série de la nanoboard de manière similaire pour que le PC
et la nanoboard puissent “se comprendre” lors de l’échange de données.

Pour ce faire, nous avons tout d’abord compris le principe de fonctionnement de ce type de
liaison. Puis nous avons créé un code en langage VHDL sur le logiciel Altium à implémenter
sur la FPGA de la nanoboard. Par la suite, nous avons créé une fiche schematic sur le
logiciel Altium afin de relier la FPGA à d’autres éléments de la nanoboard. Pour finir nous
avons essayé cette configuration sur le logiciel Hyperterminal et testé des valeurs de notre
programme avec l’analyseur de signaux logiques pour essayer de corriger notre code.

II. Principe de fonctionnement de la liaison

série en émission

Le principe de fonctionnement comme son nom l’indique est d’envoyer des bits en
série, c'est-à-dire les un après les autres, à la différence de liaisons en parallèle ou plusieurs
bits sont envoyés simultanément. Bien que la liaison en parallèle permet d’envoyer plusieurs
bits simultanément et donc d’envoyer plus d’information à fréquence de fonctionnement égal
à celle d'une liaison série, la liaison série compense cela par de nombreux avantages tel que
la fiabilité sur de plus grandes distance de communication (car les signaux envoyés en
parallèle sur de longues distance subissent des interférences provoqué par les autres
signaux envoyé en parallèle), de plus il est possible de faire fonctionner les liaisons en série
à des fréquences bien plus élevés que pour les liaisons en parallèles. Il est donc intéressant
de travailler sur ce type de liaisons que nous pouvons rencontrer fréquemment.

3
BENNANI Mohamed NAUDOT François

Pour envoyer les bits de l’information à envoyer, il est important de respecter la trame
suivante :

Sur cette trame est donc indiqué plusieurs informations qui nous permettront de créer
l’architecture de notre code :
-Lorsque aucune donnée n’est envoyée, un état haut ( bit =1) est envoyé à chaque
impulsion de la clock.
-Lorsqu'une donnée est envoyée, un bit “start” qui est un bit = 0 est envoyé. Cela
permet lors de la réception de détecter le début d’un message.
-Après l’envoi du bit “start”, les bits constituant le message sont transmis du bit de
poids faible jusqu’au bit de poids fort.
-Une fois le message émis, un bit “stop” est envoyé (bit = 1), puis la liaison se remet
un envoyer constamment un bit = 1, c'est-à-dire se remettre dans la configuration initiale.

C’est dans l’idée de respecter cette trame que nous avons créé notre code VHDL pour
configurer la FPGA.

Fiche Schematic de la configuration de la nanoboard

Avant d’écrire le code VHDL qui utilisera la FPGA, nous avons établi la structure de
notre circuit et observé les éléments qui en faisaient partie pour savoir quelle fonctionnalité
nous avions besoin de créer dans notre code VHDL.
Notre circuit est constitué de :
-L’horloge de la FPGA réglée sur 50 MHz.
-Un bouton de la nanoboard qui nous servira de signal d’envoi de la donnée à
transmettre.
-Un instrument virtuel nous permettant de choisir le message à transmettre.
-Un port série RS232, qui sera donc la sortie de ce circuit.
-Un Bloc FPGA correspondant à la partie de la FPGA programmé grâce à notre code
VHDL.

A défaut d’avoir de véritables images de notre schematic que Altium voici une représentation
de notre circuit ressemblant fortement à ce que nous pouvions voir sur Altium.

4
BENNANI Mohamed NAUDOT François

On peut donc observer sur cette représentation du circuit plusieurs informations importantes
pour la réalisation du code VHDL.
Tout d’abord on observe que le bloc FPGA est relié à 3 entrées et à une sortie. Tous ces
signaux électriques sont des signaux logiques hormis le signal “data_in” qui est un bus de 8
signaux logiques. De plus, on s'aperçoit que l’horloge de ce circuit est une horloge de 50
MHz, or nous voulons une transmission en série à la vitesse de 9600 bauds. Il faudra donc
prévoir dans le code VHDL un moyen de passer d’une horloge de 50 MHz à une horloge de
9,6 kHz.

Voyons maintenant qu’elle est le code VHDL que nous avons créé pour ce bloc FPGA
central à notre circuit.

III. Création du code VHDL pour configurer la

FPGA :

Notre code VHDL doit comporter deux parties lors de sa réalisation au vu de ce que
nous avons pu observer sur la configuration de notre circuit. Il doit comporter tout d’abord
une fonction permettant d’envoyer le message en liaison série en suivant le protocole de la
trame de transmission en série; puis il doit comporter une gestion de l’horloge afin d’avoir
une transmission à la vitesse convenue de 9600 bauds.

III.1 Processus d’envoi du message :

Pour l'envoi du message, nous avons choisis de créer une machine à état. Nous
avons donc créé un type VHDL nous permettant de représenter l’état dans lequel la liaison
se trouve. En étudiant la trame nous avons donc dégagé 5 états différents pour la liaison. Un
état “reset” permettant d’initialiser la liaison au démarrage et après la fin de l’envoie d’un
message. Un deuxième état “pas_de_transmission” correspondant à lorsqu’il ne faudra pas

5
BENNANI Mohamed NAUDOT François

envoyer de message. Un troisième état “bit_start” correspondant au début de la

transmission de donné et donc à l’envoi du premier bit, le bit de start. Nous avons ensuite un
état “envoyer_les_donnes” qui correspond à l’envoi des bits constituant le message en
commençant par le bit de poids faible. Et pour finir un état “bit_stop” correspondant à la fin
de la transmission est donc à l’envoi du bit stop.

Voici donc la création de ce type en VHDL et l’initialisation de deux signaux de ce types:

type etat_transmission is (reset, pas_de_transmission, bit_start,
envoyer_les_donnés, bit_stop);
signal etat_actuel,etat_suivant:etat_transmission :=
pas_de_transmission;
Ces commandes seront écrites dans la section “ architecture” avec la création des autres
signaux du code VHDL.

Cette machine passera d’un état à un autre en suivant certaines conditions en fonction de
l’état actuel dans lequel elle se trouve. Pour contrôler ces différents transition d’état et les
conditions de passage d’un état à un autre, nous avons créé un process nommé “control_tx”
dont les signaux d’activations seront “activation”, “etat_actuel”, “bouton”et “compteur_bit”, de
cette manière à chaque changement de valeurs de ces signaux ce process s’activera. le
signal “activation” correspond à l’horloge créé par le deuxième process de notre code VHDL
que nous ferons par la suite, qui nous permet d’avoir une fréquence de transmission de
9600 bauds, et en effet lors du changement de valeur de “activation”, “control_tx” s’activera
et l’état de la liaison et ce que cela implique sera actualisé.

Pour comprendre notre code VHDL il est intéressant de détailler les conditions de passages
d’un état à un autre:
-Lorsque la liaison est dans un état de “reset” le bit envoyé est un 1 et l’
”état_suivant” est sans condition l’état “pas_de_transmission”.
- Lorsque la liaison est dans l’état “pas_de_transmission”, si l’on appuie sur le bouton
de la nanoboard et donc que le signal “bouton” passe à 0 ( les boutons de la nanoboard sont
inversés il envoie un signal à l’état bas lorsque l’on appuie dessus), l’état suivant sera celui
de début de transmission, “bit_start”. Tant que personne n’appuie sur le bouton d’envoie du
message il n’y a pas de transmission et donc l’état reste “pas_de_transmission” et continue
à envoyer constamment la valeur 1 sur le port série.
-Lorsque la liaison est dans l’état “bit_start”, on evoie un bit de départ égal à 0 et on
passe sans conditions à l’état “envoyer_les_donnes”.
-Lorsque la liaison est à l’état “envoyer_les_donnes”, on envoi les bits constituant le
message. Si on a envoyé tous les bit du message, donc 8 bits la valeurs de “compteur_bit”
se trouve à 7 et alors la liaison passe à l’état “bit_stop”. Si nous “compteur_bit” ne vaut
toujours pas 7, alors tous les bits de données n’ont pas été envoyés, la liaison reste alors à
l’état “envoyer_les_donnes”.

6
BENNANI Mohamed NAUDOT François

-Lorsque la liaison est à l’état “bit_stop”, le bit de fin de message égal à 1 est envoyé,
et la liaison passe sans conditions à l’état “reset”.

Cette fonction réalise donc des boucles pour l’envoi du message puis s’arrête lorsque l’envoi
de celui-ci est terminé pour stagner à l’état “pas_de_transmission”, jusqu’à ce que quelqu’un
appuie sur le bouton 0 de la nanoboard.
L’un des avantages de ce code est qu’il ne peut pas y avoir d’envoi superposé par un appui
prolongé sur le bouton 0, car la valeur de celui-ci n’est pris en compte que dans un seul état
de la liaison, et que l’on passe à un autre état dès que l’on appuie sur le bouton.

control_tx : process (activation, etat_actuel, bouton,

compteur_bit)
begin
case etat_actuel is
when reset =>
data_out <= '1';
etat_suivant <= pas_de_transmission;
when pas_de_transmission =>
data_out <= '1';
if (bouton = '0') then
etat_suivant <= bit_start;
else
etat_suivant <= pas_de_transmission;
end if;
when bit_start =>
data_out <= '0';
etat_suivant <= envoyer_les_donnés;
when envoyer_les_données =>
data_out <= data_in(compteur_bit);
if (compteur_bit = 7) then
etat_suivant <= bit_stop;
else
etat_suivant <= envoyer_les_donnés;
end if;
when bit_stop =>
data_out <= '1';
etat_suivant <= reset;
when others =>
data_out <= '1';
etat_suivant <= reset;
end case;
end process control_tx;

7
BENNANI Mohamed NAUDOT François

III.2 Création de l’Horloge de 9600 Hz :

Pour obtenir l’horloge de 9600 Hz que nous désirons, nous avons créé un process
“nouvelle_clk” qui s’active avec les fronts montant de l’horloge de la FPGA. Nous avons
introduit un signal compteur_clk qui est un entier entre 0 et 5207, initialisé à 0.

signal compteur_clk : integer range 0 to clk_par_bit-1 := 0;

“clk_par_bit” est une constante de valeur de 5208. cette valeur est trouvé en divisant
50 000 000 par 9600. Ce qui représente donc le nombre de d’impulsion de l’horloge de la
FPGA que nous avons besoin pour créer une impulsion de notre horloge à 9600 Hz.
generic (
clk_par_bit : integer := 5208 );

En plus de créer la nouvelle Horloge, ce process actualise l’ensemble des signaux du

système. Lorsque “compteur_clk” atteint sa valeur maximum, ce signal est réinitialisé,
“etat_actuel” prend la valeur de “etat_suivant” ce qui correspond à l’actualisation de l’état de
la liaisonet en même temps le signal activation change d’état ce qui activera le deuxième
process. De plus, si la liaison est en train d'envoyer un message, le bit de la donnée à
envoyer est actualisé par l’incrémentation de “compteur_bit”, et lorsque la valeur de
“compteur_bit” est à 7, elle est réinitialiser. Si “compteur_clk” n’a pas atteint sa valeur finale,
ce signal est incrémenté.

nouvelle_clk : process(clk)
begin
if (clk ='1' and clk'event) then
if (compteur_clk = clk_par_bit-1) then
compteur_clk <= 0;
etat_actuel <= etat_suivant;
activation <= not activation;
if (etat_actuel = envoyer_les_donnés) then
compteur_bit <= compteur_bit + 1;
else
compteur_bit <= 0;
end if;
else
compteur_clk <= compteur_clk + 1;
end if;
end if;
end process nouvelle_clk;

8
BENNANI Mohamed NAUDOT François

III.3 Regroupement des deux process :

Une fois les deux processus créés, il suffit d’ajouter les initialisations de signaux ou
autres valeurs nécessaires au code et surtout de rajouter la syntaxe VHDL pour obtenir le
code complet de la liaison série.

library ieee;
use ieee.std_logic_1164.all;
use iee.std_logic_unsigned.all;
use ieee.numeric_std.all;

entity liaison_serie_tx is

generic (
clk_par_bit : integer := 5208 );

port (
clk : in std_logic;
data_in : in std_logic_vector(7 downto 0);
bouton : in std_logic;
data_out : out std_logic);
end entity liaison_serie_tx;

architecture behavioural of liaison_serie_tx is

type etat_transmission is (reset, pas_de_transmission,
bit_start, envoyer_les_donnés, bit_stop);
signal etat_actuel, etat_suivant : etat_transmission := pas
de transmission;
signal compteur_clk : integer range 0 to clk_par_bit-1 := 0;
signal compteur_bit : integer range 0 to 7 := 0;
signal activation : std_logic:='0';

begin
nouvelle_clk : process(clk)
begin
if (clk ='1' and clk'event) then
if (compteur_clk = clk_par_bit-1) then
compteur_clk <= 0;
etat_actuel <= etat_suivant;
activation <= not activation;
if (etat_actuel = envoyer_les_donnés) then
compteur_bit <= compteur_bit + 1;
else

9
BENNANI Mohamed NAUDOT François

compteur_bit <= 0;
end if;
else
compteur_clk <= compteur_clk + 1;
end if;
end if;
end process nouvelle_clk;

control_tx : process (activation, etat_actuel, bouton,

compteur_bit)
begin
case etat_actuel is
when reset =>
data_out <= '1';
etat_suivant <= pas_de_transmission;
when pas_de_transmission =>
data_out <= '1';
if (bouton = '0') then
etat_suivant <= bit_start;
else
etat_suivant <= pas_de_transmission;
end if;
when bit_start =>
data_out <= '0';
etat_suivant <= envoyer_les_donnés;
when envoyer_les_données =>
data_out <= data_in(compteur_bit);
if (compteur_bit = 7) then
etat_suivant <= bit_stop;
else
etat_suivant <= envoyer_les_donnés;
end if;
when bit_stop =>
data_out <= '1';
etat_suivant <= reset;
when others =>
data_out <= '1';
etat_suivant <= reset;
end case;
end process control_tx;
end architecture behavioural;

10
BENNANI Mohamed NAUDOT François

IV. Test de notre programme et correction :

Après avoir réalisé le code VHDL, la fiche schematic et introduit les contraintes de
bases de la FPGA, nous avons essayé de faire une transmission en liaison série de la
nanoboard à notre ordinateur en visualisant le message reçu grâce à Hyperterminal.
Seulement après plusieurs tentatives d’émission d’un message, nous ne recevions rien sur
l’ordinateur.

Nous avons donc utilisé l’analyseur de signaux logiques afin d’observer la sortie de notre
programme “data_out”. Pour observer ce signal grâce à l'analyseur de signaux, nous avons
utilisé une des broches présente sur la nanoboard prévu à cet effet. Pour cela, nous avons
rajouté une contrainte sur notre fichier de contrainte afin d’associer une broche de la
nanoboard à notre signal logique de sortie, et nous avons rajouté un point d’observation
nommé “signal_sortie” directement relié à la sortie “data_out”.

Record=Constraint | TargetKind=Port | TargetId=signal_sortie | FPGA_PINNUM=AF17

Nous avons ainsi pu observer que le signal “data_out” est à l’état bas constamment. Cela
est très problématique pour nous car le signal “data_out” ne peut, dans notre code, être qu’à
l’état bas lorsque nous envoyons un message. Cependant nous n’avions pas appuyé sur le
bouton de la nanoboard et de plus cet envoi est très rapide ce qui ne peut expliquer un état
constamment bas. Nous nous sommes donc interrogés sur le bon fonctionnement du bouton
de la nanoboard et sur l’état dans lequel notre liaison pouvait être.
Pour comprendre un peu mieux à quel endroit de notre code nous étions, nous avons ajouté
des signaux de sorties au code et des contraintes pour observer ces signaux sur les broches
de la nanoboard comme nous l’avons fait pour le signal “data_out” au préalable.
Nous avons donc le schematic suivant ainsi que ce fichier de contrainte :

;...............................................................................
Record=FileHeader | Id=DXP Constraints v1.0
;...............................................................................

11
BENNANI Mohamed NAUDOT François

Record=Constraint | TargetKind=Port | TargetId=test_ac | FPGA_PINNUM=AF16

Record=Constraint | TargetKind=Port | TargetId=signal_sortie | FPGA_PINNUM=AF17
Record=Constraint | TargetKind=Port | TargetId=bouton1 | FPGA_PINNUM=AE18
Record=Constraint | TargetKind=Port | TargetId=etat | FPGA_PINNUM=AF4
Record=Constraint | TargetKind=Port | TargetId=etat1 | FPGA_PINNUM=AF5
Record=Constraint | TargetKind=Port | TargetId=etat2 | FPGA_PINNUM=AF6
Record=Constraint | TargetKind=Port | TargetId=etat3 | FPGA_PINNUM=AB4

Chacun des signaux nous permet de comprendre l’erreur dans le code:

-le signal “bouton1”, nous permet de visualiser le bon fonctionnement du bouton.
-le signal “test_ac” relié à la sortie “test_activation”, nous permet de visualiser si
l’horloge créé dans le code fonctionne correctement.
-les signaux de test d’état “test_etat(i)” servent à identifier si nous sommes dans l’un
des 5 états de la liaison et si oui dans lequel. Lorsque le signal “test_etat” est à 1, nous
savons que la liaison est dans un des différents états de la liaison. Nous ne savons pas
lequel mais cela permet de détecter une erreur d’initialisation des états dans le code.
Les trois autres signaux de test d’état focntionne ensemble, le bit de poid faible correspond
au signal “test_etat3” et le bit de poid faible correspond à “test_etat1”. Ainsi nous obtenions
une correspondance entre ce triplet de bits et les états de la liaison:
- “100” => “reset”
- “010” => “pas_de_transmission”
- “001” => “bit_start”
- “110” => “envoyer_les_donnes”
- “011” => “bit_stop”
- “111” => “others”

Pour cela nous avons donc modifié les valeurs de ces sorties directement dans le code
VHDL.
Ainsi avec toutes les modification pour les tests de signaux nous obtenons ce nouveaux
code vhdl:

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;

entity liaison_serie is
generic (
clk_par_bit : integer :=5208
);
port(
clk : in std_logic ;
bouton: in std_logic;
data_in : in std_logic_vector(7 downto 0);
data_out : out std_logic;
test_etat1 : out std_logic;
test_etat2 : out std_logic;
test_etat3 : out std_logic;

12
BENNANI Mohamed NAUDOT François

test_est_un_etat : out std_logic;

test_activation : out std_logic
); end entity liaison_serie;

architecture behavioural of liaison_serie is

type etat_transmission is (reset ,
pas_de_transmission,bit_start,envoyer_les_donnes,bit_stop);
signal etat_actuel,etat_suivant:etat_transmission :=
pas_de_transmission;
signal compteur_clk : integer range 0 to clk_par_bit-1:=0;
signal compteur_bit:integer range 0 to 7:=0;
signal activation : std_logic:='0';
begin

nouvelle_clk : process(clk)
begin
if (clk ='1' and clk'event) then
if (compteur_clk = clk_par_bit-1 or
(etat_actuel=pas_de_transmission and etat_suivant=pas_de_transmission))
then
compteur_clk<=0;
etat_actuel<=etat_suivant;
activation<=not activation;
test_activation <= activation;
if (etat_actuel = envoyer_les_donnes) then
compteur_bit <= compteur_bit + 1;
else
compteur_bit <= 0;
end if;
else
compteur_clk <= compteur_clk +1;
end if;
end if;
end process nouvelle_clk ;

control_tx : process (activation,bouton, compteur_bit, etat_actuel)

begin

case etat_actuel is
when reset =>
test_etat1 <= '1';
test_etat2 <= '0';
test_etat3 <= '0';
test_est_un_etat <= '1';
data_out<='1';
etat_suivant <= pas_de_transmission;
when pas_de_transmission =>
test_etat1 <= '0';
test_etat2 <= '1';
test_etat3 <= '0';
test_est_un_etat <= '1';

13
BENNANI Mohamed NAUDOT François

data_out <='1';
if (bouton='0') then
etat_suivant <= bit_start;
else
etat_suivant <= pas_de_transmission;
end if;
when bit_start =>
test_etat1 <= '0';
test_etat2 <= '0';
test_etat3 <= '1';
test_est_un_etat <= '1';
data_out <= '0';
etat_suivant <= envoyer_les_donnes;
when envoyer_les_donnes =>
test_etat1 <= '1';
test_etat2 <= '1';
test_etat3 <= '0';
test_est_un_etat <= '1';
data_out <= data_in(compteur_bit);
if(compteur_bit = 7) then
etat_suivant <= bit_stop;
else
etat_suivant <= envoyer_les_donnes;
end if;

when bit_stop =>

test_etat1 <= '0';
test_etat2 <= '1';
test_etat3 <= '1';
test_est_un_etat <= '1';
data_out <= '1';
etat_suivant <= reset;
when others =>
test_etat1 <= '1';
test_etat2 <= '1';
test_etat3 <= '1';
test_est_un_etat <= '1';
data_out <= '1';
etat_suivant <= reset;
end case;
end process control_tx;
end architecture behavioural;

Avec toutes ses modifications nous avons donc visualiser les signaux de test avec
l’analyseur de signaux logique et nous avons obtenu ce chronogramme:

14
BENNANI Mohamed NAUDOT François

Figure 1 :chronogramme des signaux de test

Sur ce chronogramme nous pouvons observer notre Horloge de 9600 Hz sur la voie D1 qui
fonctionne correctement, le problème de notre programme ne se trouve pas là. Sur la voie
D2 nous observons le signal “data_out” qui affiche un état bas constant comme observé
précédemment. Sur la voie D3 nous observons la valeur du bouton et celle-ci est à l’état
haut ce qui est normal puisque personne n’appuie dessus. Le problème ne vient pas non
plus d’un dysfonctionnement du bouton.
Cependant nous observons quelque chose de très intrigant, sur la voie D4 nous observons
le signal “test_etat” qui se trouve à l’état haut ainsi nous sommes bien dans un état de la
liaison. De plus grâce au voies D5 à D7 nous récupérons la valeur “010”, celle-ci correspond
à l’état “pas_de_transmission”. La liaison est donc bien initialisée seulement l’état
“pas_de_transmission” n’effectue pas les commandes que nous désirons, puisque dans
cette état, la liaison devrait mettre “data_out” constamment à l’état haut, ce qui n’est pas le
cas. De plus, le système ne change pas d’état lorsque nous appuyons sur le bouton de la
nanoboard.

Grâce à ce test nous pouvons cibler la source du problème dans le code:

when pas_de_transmission =>

test_etat1 <= '0';
test_etat2 <= '1';
test_etat3 <= '0';
test_est_un_etat <= '1';
data_out <='1';
if (bouton='0') then
etat_suivant <= bit_start;
else
etat_suivant <= pas_de_transmission;
end if;

15
BENNANI Mohamed NAUDOT François

Le Problème ici est donc que la valeur ‘1’ n’est pas attribuée à “data_out”. Ce qui est
troublant c’est que les test d’état voient leur valeur leur être attribuée alors que ce sont des
sorties du même type que “data_out”.

Nous n’avons finalement pas réussi à résoudre ce problème qui nous a empêché de mener
à bien ce projet.

V. Conclusion

Bien que nous n’ayons pas réussi à aboutir dans ce projet à un résultat viable, nous avons
compris beaucoup de choses sur la conception d’un circuit électronique avec une FPGA. De
plus, la manipulation du logiciel Altium nous a permis de nous familiariser avec les moyens
de concevoir ce type de systèmes et de comprendre comment écrire un code VHDL en
prenant en compte les autres appareils du système qui impose certaines contraintes lors de
la réalisation du code.

16