Dans ce didacticiel, nous apprendrons à concevoir un système embarqué sur une carte

FPGA à l'aide du processeur Nios-II, souvent appelé « Système sur puce programmable
(SoPC)». Avant de commencer la conception du SoPC, comprenons la différence entre
« système informatique », « système embarqué » et « système SoPC ». Systèmes
informatiques, par ex. ordinateurs personnels (PC), prennent en charge diverses
applications d'utilisateur final. Sélection de ces systèmes informatiques pour quelques
applications spécifiques, par ex. les réglages des minuteries, les affichages et les buzzers
dans les fours à micro-ondes ou les machines à laver, etc., n'est pas un choix rentable. Les
systèmes embarqués sont une solution rentable pour de tels cas, où seules quelques
fonctionnalités sont requises dans le système. Étant donné que les systèmes embarqués
sont conçus pour des tâches spécifiques, les conceptions peuvent donc être optimisées en
fonction des applications. De plus, les systèmes SoPC sont les systèmes embarqués
programmables, c'est-à-dire que nous pouvons concevoir les systèmes embarqués à l'aide
de codes Verilog/VHDL et les implémenter sur la carte FPGA.

Nios II est une architecture de processeur embarqué 32 bits conçue pour la carte Altera-
FPGA. Dans la Fig. 12.1, différentes étapes sont illustrées pour concevoir le système SoPC
sur la carte FPGA à l'aide du processeur Nios-II. Dans ce chapitre, ces étapes sont décrites
et un système est conçu qui affiche le message sur l'ordinateur et fait clignoter une LED à
l'aide de la carte FPGA. De plus, les sorties de ce système sont vérifiées à l'aide de
Modelsim. Il est recommandé de lire les deux premiers chapitres avant de pratiquer les
codes, car divers problèmes liés à l'utilisation du logiciel Nios sont abordés dans ces
chapitres.
Création d'un projet Quartus
Tout d'abord, nous devons créer le projet à l'emplacement souhaité, avec les étapes
suivantes,

Le chemin d'accès au répertoire du projet ne doit contenir aucun espace dans les noms de
dossier, comme illustré à la Fig. 12.2, car le chemin ne sera pas détecté par le logiciel Nios-
II dans la partie ultérieure du didacticiel.
Choisissez le bon périphérique FPGA, comme illustré à la Fig. 12.3. Si vous n'en avez pas,
sélectionnez la bonne famille d'appareils et utilisez-la pour le reste du didacticiel. Notez
que la «simulation» est le processus le plus important de la conception et que la carte
FPGA n'est pas nécessaire pour créer et simuler la conception intégrée. Par conséquent,
si vous n'avez pas de carte FPGA, vous pouvez toujours utiliser le didacticiel. La mise en
œuvre de la conception sur la carte FPGA nécessite le chargement des fichiers ".sof" et
".elf" sur la carte, ce qui n'est pas un gros problème.

Enfin, choisissez le bon logiciel de simulation et le bon langage, c'est-à-dire Modelsim-

Altera et VHDL respectivement, comme illustré à la Fig. 12.4.

Créer des périphériques personnalisés

Nous pouvons créer des périphériques, par ex. additionneur, diviseur ou générateur
d'horloge utilisant VHDL. Ensuite, ces appareils peuvent être utilisés pour créer le SoPC à
l'aide du logiciel Nios-II, comme indiqué à la section 12.4. Pour simplifier le didacticiel,
seuls des périphériques prédéfinis sont utilisés dans les conceptions, qui sont disponibles
dans le logiciel Nios-II. La création et l'utilisation des périphériques personnalisés seront
abordées dans les chapitres suivants.

Créer et générer un SoPC à l'aide de Qsys

Le SoPC peut être créé à l'aide de deux outils du logiciel Quartus, à savoir les outils "SOPC
builder" et "Qsys". Puisque Qsys est l'outil recommandé par Altera, nous utiliserons donc
cet outil pour générer le système SoPC. Pour ouvrir l'outil Qsys, accédez à Outils -> Qsys
dans le logiciel Quartus. Ensuite, suivez les étapes ci-dessous pour créer le système SoPC,

Renommez « clk_0 » en « clk » en cliquant avec le bouton droit sur le nom (étape
facultative). Notez que les étapes de renommage sont facultatives ; mais attribuer des
noms appropriés aux composants est une bonne pratique car nous devons identifier ces
composants dans un didacticiel ultérieur.
Dans la bibliothèque de composants, recherchez le processeur Nios comme indiqué sur la
Fig. 12.5 et sélectionnez le Nios II/e (c'est-à-dire la version économique) pour ce
didacticiel. Notez que diverses erreurs sont affichées dans la figure, qui seront supprimées
dans une partie ultérieure de cette section. Ensuite, renommez le processeur en
«nios_blinkingLED» et connectez l'horloge et le port de réinitialisation au périphérique
«clk», en cliquant sur les cercles comme indiqué sur la Fig. 12.6.
Créer et générer un SoPC à l'aide de Qsys
Ajoutez ensuite la «mémoire sur puce» au système avec 20480 (c'est-à-dire 20k) octets
comme indiqué sur la Fig. 12.7 et renommez-la en RAM. Pour différentes cartes FPGA,
nous devrons peut-être réduire la taille de la mémoire, si l'erreur "débordement de
mémoire" s'affiche pendant le processus de "génération" de la Fig. 12.14.
Après cela, recherchez "JTAG UART" et ajoutez-le avec les paramètres par défaut. Il est
utilisé pour la communication du dispositif FPGA au logiciel Nios. Plus précisément, il est
nécessaire d'afficher les sorties des commandes 'printf' sur le logiciel Nios.
Ensuite, ajoutez un périphérique PIO pour faire clignoter la LED. Recherchez le
périphérique PIO et ajoutez-le en tant que périphérique PIO "1 bit" (voir Fig. 12.8), car
nous n'utiliserons qu'une seule LED clignotante. Étant donné que le périphérique PIO,
c'est-à-dire la « LED », est disponible en tant que port externe, le nom de la «
connexion_externe » doit donc être défini comme indiqué sur la Fig. 12.9.
Ensuite, ajoutez toutes les connexions comme indiqué dans la Fig. 12.9. Ajoutez également
l'esclave JTAG au maître de données des processeurs Nios, c'est-à-dire IRQ dans la Fig.
12.10
Ensuite, double-cliquez sur le processeur Nios, c'est-à-dire 'nios_blinkingLED' dans la Fig.
12.9 ; et définissez la RAM comme vecteurs de réinitialisation et d'exception, comme
illustré à la Fig. 12.11.

Ensuite, allez dans Systèmes -> Attribuer une adresse de base. Cela attribuera les adresses
uniques pour tous les appareils. A l'aide de ces adresses, les appareils sont accessibles par
des codes C/C++ dans le logiciel Nios-II. Si tout est correct jusqu'à ce point, nous
obtiendrons le message "0 Erreurs, 0 Avertissements" comme indiqué sur la Fig. 12.12.
Enfin, pour permettre la simulation des conceptions, allez dans l'onglet "génération" et
définissez l'onglet comme indiqué sur la Fig. 12.13. Notez que VHDL ne peut pas être
utilisé comme langage de simulation, car cette version de Quartus ne le prend pas en
charge. Étant donné que les fichiers verilog générés sont utilisés uniquement pour les
paramètres de simulation, nous n'avons donc pas besoin de consulter ces fichiers. Par
conséquent, peu importe que ces fichiers soient créés à l'aide de VHDL ou de Verilog.

Enregistrez le système avec le nom souhaité, par ex. ‘nios_blinkingLED.qsys’ et cliquez sur
le bouton générer. Si le système est généré avec succès, nous recevrons le message comme
indiqué dans la Fig. 12.14
Après ce processus, un fichier 'nios_blinkingLED.sopcinfo' sera généré, qui est utilisé par
le logiciel Nios-II pour créer la conception intégrée. Ce fichier contient toutes les
informations sur les composants ainsi que leurs adresses de base, etc. De plus, deux autres
dossiers seront créés dans le dossier "nios_blinkingLED", c'est-à-dire "synthèse" et
"testbench". Ces dossiers sont générés lorsque nous sélectionnons les options « synthèse
» et « simulation » dans la Fig. 12.13, et contiennent diverses informations sur la synthèse
(par exemple, le fichier « nios_blinkingLED.qip ») et la simulation (par exemple, le fichier
« nios_blinkingLED_tb.qsys »). Le fichier 'nios_blinkingLED.qip' sera utilisé pour la
création du module supérieur pour la conception, c'est-à-dire que les LED seront
connectées à la carte FPGA à l'aide de ce fichier ; tandis que 'nios_blinkingLED_tb.qsys'
contient les informations sur les formes d'onde de simulation pour les bancs de test. Enfin,
"nios_blinkingLED_tb.spd" est généré et utilisé par le logiciel Nios pour démarrer le
processus de simulation.
De cette manière, le système SoPC peut être généré. Enfin, fermez l'outil Qsys. Dans la
section suivante, le logiciel Nios sera utilisé pour créer le système de LED clignotantes à
l'aide du fichier "nios_blinkingLED.sopcinfo".
Créer un système Nios
Dans la section précédente, nous avons créé le système SoPC et le fichier .sopcinfo
correspondant a été généré. Dans cette section, nous utiliserons le fichier .sopcinfo pour
créer un système avec une fonctionnalité de voyant clignotant.

Pour ouvrir le logiciel Nios à partir du logiciel Quarturs, cliquez sur Tools->Nios II
software Build Tools for Eclipse. Si vous l'utilisez pour la première fois, il vous demandera
l'emplacement de l'espace de travail ; vous pouvez sélectionner n'importe quel
emplacement pour cela.
12.6. Ajouter et modifier BSP

Pour utiliser le fichier .sopcinfo, nous devons créer un "board support package (BSP)". En outre, BSP
doit être modifié à des fins de simulation, comme indiqué dans cette section.

12.6.1. Ajouter BSP

Pour ajouter BSP, allez dans File->New->Nios II Board Support Package. Remplissez le champ du nom
du projet et sélectionnez le fichier .sopcinfo comme illustré à la Fig. 12.15. Le reste du champ sera
rempli automatiquement.
Après avoir cliqué sur Terminer, le dossier BSP_blinkingLED sera créé et contient divers
fichiers, par ex. system.h, io.h et drivers etc. Ces fichiers sont générés sur la base des
informations contenues dans le fichier .sopc, par ex. dans la Fig. 12.16, qui montre la vue
partielle du fichier system.h, contient les informations sur la LED ainsi que l'adresse de
base (notez que cette LED a été ajoutée avec l'adresse de base dans la section 12.4). Notez
que l'emplacement de l'adresse est défini comme "LED_BASE" dans le fichier system.h ; et
nous utiliserons ce nom dans le didacticiel au lieu d'utiliser l'adresse de base réelle. De
cette façon, nous n'avons pas besoin de modifier les codes 'C/C++', lorsque l'adresse de
base de la LED est modifiée pendant le processus de modification de Qsys.

Noter

Certaines modifications sont nécessaires dans le fichier BSP pour l'utilisation de la

mémoire sur puce (en raison de sa taille plus petite). De plus, en raison de la taille réduite
de la mémoire sur puce, les codes C++ ne peuvent pas être utilisés pour la conception
NIOS. De plus, ces paramètres ne sont pas requis dans les cas où la RAM externe est
utilisée pour la mémoire, par ex. SDRAM (discuté au chapitre 14); et après avoir ajouté de
la RAM externe, nous pouvons également utiliser le code C++ pour la conception NIOS.
Pour modifier le BSP, faites un clic droit sur ‘BSP_blinkingLED’ puis cliquez sur Nios II–
>BSP Editor. Sélectionnez ensuite 'enable_reduce_device_drivers' et
'enable_small_c_library' comme indiqué sur la Fig. 12.17 ; puis cliquez sur le bouton
‘générer’ pour appliquer les modifications.
Créer une application en C/C++
Dans la section précédente, diverses informations sont générées par BSP en fonction du
fichier .sopcinfo. Dans cette section, nous allons écrire l'application "C" pour faire
clignoter la LED. De plus, nous pouvons également écrire le code en utilisant C++.

Pour créer l'application, allez dans File->New->Nios II Application. Remplissez le nom de

l'application, c'est-à-dire « Application_clignotant LED » et sélectionnez l'emplacement du
BSP comme indiqué dans la Fig. 12.18.

Pour créer l'application C, cliquez avec le bouton droit de la souris sur

'Application_blinkingLED' et allez dans Nouveau -> Fichier source. Écrivez le nom du
fichier source en tant que "main.c" et sélectionnez le "Modèle de source C par défaut".
Ensuite, écrivez le code dans le fichier 'main.c' comme indiqué dans le Listing 12.1. Après
avoir écrit le code, faites un clic droit sur « Application_blinkingLED » et cliquez sur « build
project ».
//main.c
#include "io.h" // required for IOWR
#include "alt_types.h" // required for alt_u8
#include "system.h" // contains address of LED_BASE

int main(){
alt_u8 led_pattern = 0x01; // on the LED

//uncomment below line for visual verification of blinking LED

//int i, itr=250000;

printf("Blinking LED\n");
while(1){
led_pattern = ~led_pattern; // not the led_pattern
IOWR(LED_BASE, 0, led_pattern); // write the led_pattern on LED

//uncomment 'for loop' in below line for visual verification of blinking

LED
// dummy for loop to add delay in blinking, so that we can see the
bliking.
//for (i=0; i<itr; i ++){}
}
}
Dans la section précédente, nous avons construit l'application Nios. Pour simuler ce
système, faites un clic droit sur 'Application_blinkingLED' et allez dans Run as->NOIS II
Modelsim. Sélectionnez ensuite l'emplacement du logiciel Modelsim, c'est-à-dire le
dossier "win32aloem" ou "win64aloem", comme illustré à la Fig. 12.19 ; cela peut être
trouvé dans les dossiers où le logiciel Altera est installé.
Simuler l'application Nios
Dans la section précédente, nous avons construit l'application Nios. Pour simuler ce
système, faites un clic droit sur 'Application_blinkingLED' et allez dans Run as->NOIS II
Modelsim. Sélectionnez ensuite l'emplacement du logiciel Modelsim, c'est-à-dire le
dossier "win32aloem" ou "win64aloem", comme illustré à la Fig. 12.19 ; cela peut être
trouvé dans les dossiers où le logiciel Altera est installé.
Ensuite, cliquez sur le bouton d'avance dans la Fig. 12.19 et une nouvelle fenêtre
apparaîtra. Remplissez l'emplacement du projet comme indiqué sur la Fig. 12.20 et
fermez la fenêtre contextuelle. Cet emplacement contient le fichier '.spd', qui est
nécessaire pour la simulation.
Après l'étape ci-dessus, la colonne « Nom du fichier du descripteur du package de
simulation Qsys testbench » sera automatiquement remplie avec le fichier « .spd »,
comme illustré à la Fig. 12.21. Sinon, faites-le manuellement en recherchant le fichier, qui
est disponible dans le dossier du projet. Si tout est correct, les boutons Appliquer et
Exécuter seront activés. Cliquez sur appliquer puis sur le bouton exécuter pour démarrer
la simulation.