TP1 de Codesign:

Conception avec Nios II et

SOPC Builder
Objectifs:

- Familiarisation avec l’outil SOPC Builder.

- Création d’un système complet à base du NIOS II.
- Compiler et exécuter du code sur le Nios II.

Dans la première partie de ce TP, vous allez apprendre à utiliser les outils (Quartus II et SOPC
Builder) qui vont vous permettre de créer votre plate-forme hardware en implémentant le processeur
Nios II et un ensemble de périphériques de base. Dans une deuxième partie, vous allez utiliser l’outil
NiosII Embedded Design Suite (basé sur Eclipse) qui permet d’écrire et compiler des programmes en
C (software) qui vont être exécutés sur cette plate-forme.

Pour tous les TPs, vous allez utiliser la carte d’expérimentation DE2 qui comprend un FPGA
Cyclone 2 de chez Altera et plusieurs composants externes listés ci-dessous :

I/O Devices
 Built-in USB-BlasterTM cable for FPGA configuration
 10/100 Ethernet
 RS232
 Video Out (VGA 10-bit DAC)
 Video In (NTSC/PAL/Multi-format)
 USB 2.0 (type A and type B)
 PS/2 mouse or keyboard port
 Line In/Out, Microphone In (24-bit Audio CODEC)
 Expansion headers (76 signal pins)
 Infrared port
Memory
 8-MBytes SDRAM, 512K SRAM, 4-MBytes Flash
 SD memory card slot
Displays
 16 x 2 LCD display
 Eight 7-segment displays
Switches and LEDs
 18 toggle switches
 18 red LEDs
 9 green LEDs
 Four debounced pushbutton switches
Clocks
 50 MHz crystal for FPGA clock input
 27 MHz crystal for video applications
 External SMA clock input

2
Partie 1 : Hardware (45 minutes)

Le processeur Nios II est un soft processeur, définit avec un langage de description matérielle, qui
peut être implémenté sur les FPGA Altera en utilisant la suite logicielle Quartus II. Pour implémenter
un système complet, il est nécessaire d’ajouter d’autres éléments au processeur, tel que des mémoires,
des interfaces d’entrées/sorties, des temporisateurs (timers) et des interfaces de communications.
Un système complet à base de Nios II peut être implémenté sur la carte DE2 comme le montre la
figure ci-dessous.

Host Computer

USB-Blaster
Interface

Cyclone II Timer NIOS II JTAG Debug JTAG UART

FPGA Chip Module
Processor Interface

Avalon Switch Fabric

On-Chip SRAM SDRAM Flash Parallel I/O Serial I/O

Memory Interface Interface Interface Interface Interface

SRAM SDRAM Flash Parallel I/O Serial I/O

Chip Chip Chip port lines port lines

Pour ce premier TP, vous allez uniquement implémenter les périphériques de base qui permettent de
réaliser des applications simples telles que :
- allumer des LEDs séquentiellement,
- lire les valeurs des interrupteurs et des boutons poussoirs.
- afficher des valeurs sur les afficheurs 7 segments
- communiquer avec le PC via une liaison série de type RS232

3
 Au niveau hardware, pour réaliser ces applications, vous avez besoin d’implémenter les périphériques
suivants (comme le montre la figure ci-dessous) :
- Un µP et une mémoire pour exécuter le programme.
- Des entrées/sorties d’usages général (GPIO) pour les LEDs, les interrupteurs, les boutons poussoirs et
les afficheurs 7 segments.
- D’un temporisateur pour l’affichage séquentiel sur les LEDs
- D’un UART pour les transmissions séries.

Host Computer

USB-Blaster
Interface

Cyclone II Timer NIOS II JTAG Debug JTAG UART

FPGA Chip Processor Module Interface

Avalon Switch Fabric

SRAM Switches and Key Red and Green 7 segments parallel

Interface parallel input LEDs parallel output interface
interface output interface

……….. ………… ………….....

SRAM
Chip [SW17..SW0] [LEDR17…LEDR0] HEX7 HEX0
[KEY3..KEY0] [LEDG7…LEDG0]

4
 Vous allez découvrir à travers cet exercice la suite logicielle d’Altera qui permet de faire du
Codesign Hard/Soft. Le sujet de cet exercice contient des instructions très précises qu’il faut suivre
rigoureusement pour construire votre système.

1. Aller sur le lien suivant : https://www.polytech.upmc.fr/~douze/E2i3/CoD/TP/TP1_SOPC_Builder/ et copier le

fichier E2i3_TP1_SOPCBuilder.zip sur votre ordinateur. Dézipper ce fichier dans un répertoire CoD que vous
aurez créer au préalable sur votre disque réseau (H:\CoD\).

2. Lancer QuartusII : Demarrer  Programmes Programmation  ALTERA  Quartus II 10.1 

Quartus II 10.1 (32 bit). Sur la page d’accueil, Cliquez sur « Create a New Project » afin de créer un nouveau
projet. Dans cette première page, cliquez sur Next, sur la seconde page, vous devez choisir le nom de votre
projet et son répertoire de travail. A la première ligne, sélectionnez le répertoire précédemment copié sur le
disque H (H:\CoD\E2i3_TP1_CoD_SOPCBuilder). Pour le nom, choisissez TP1.

3. Cliquez sur Next, dans cette page vous pouvez ajouter des fichiers (vhdl ou verilog) à votre projet. Dans cet
exercice, vous allez partir de zéro (from scratch) pour construire votre système donc vous n’avez aucun fichier à
rajouter.

4. Cliquez sur Next, sur cette page, vous devez choisir le composant programmable (FPGA, CPLD) sur lequel
vous allez implémenter votre circuit numérique. La carte DE2 est munie d’un FPGA Cyclone II
EP2C35F672C6, choisissez ce composant dans la liste des composants proposés comme le montre la figure ci-
dessous. Ce numéro est toujours écrit sur la partie visible des composants programmable.

5
5. Cliquez sur Next, dans cette page vous avez la possibilité de spécifier l’utilisation d’autres outils logiciels (que
ceux d’Altera) pour réaliser la simulation ou la synthèse. Il est par exemple possible d’utiliser Modelsim
(Mentor Graphics) pour faire les simulations à la place de l’outil de simulation proposé par Altera. Pour cet
exercice, laissez la page tel quel et cliquez sur Next.

6. Dans la dernière page, vous avez une synthèse des choix que vous avez faits dans les pages précédentes,
vérifiez que vous vous n’êtes pas trompé et cliquez sur Finish.

7. La synthèse des circuits numériques demande beaucoup de calculs et de ressources processeur et peuvent
prendre beaucoup de temps. Pour diminuer au maximum les temps de synthèse, allé dans le menu
Assignements  Settings, sélectionnez la section Compilation Process Settings dans la fenêtre Category,
ensuite vérifier que la case Use Smart Compilation est cochée. Validé et terminé en cliquant sur OK.

6
8. Une fois que ceci est bien vérifié, vous allez commencer à construire votre système. Démarrer SOPC
Builder en allant sur Tools  SOPC Builder… ou en cliquant sur l’icône suivante :
La fenêtre Create New System s’ouvre, remplissez le champ System Name avec le nom de votre
système (utilisez impérativement le nom niosII). Vous pouvez aussi choisir le langage HDL de votre
choix, VHDL dans votre cas. Valider en cliquant sur OK. Renommez l’horloge clk en clk_in et fixer la
valeur à 50 MHz.

9. Vous allez commencer par ajouter le

processeur Nios II à votre système.

Dans la fenêtre de gauche, sélectionnez le

Processors  Nios II processor et cliquez
sur le bouton Add…

Vous avez la possibilité de sélectionnez la

version du cœur : économique (Nios II/e),
standard (Nios II/s) ou rapide (Nios II/f, f
comme fast).

En fonction de ce choix, vous avez un

processeur plus ou moins puissant mais qui
prend aussi plus ou moins de place sur le
FPGA.

Sélectionnez la version fast du cœur : Nios

II/f (f comme Fast)
7
E2i3 : UE Codesign Y. DOUZE
 Dans l’onglet JTAG Debug Module, vous avez la possibilité de choisir les capacités de débogage du
processeur à travers la liaison JTAG. Sélectionnez l’option Level 1. Comme indiqué, le Level 1 vous permet
de vous connecter avec la cible à travers la liaison JTAG (JTAG Target Connection) de télécharger le code
sur la cible (Download Software), d’avoir des points d’arrêts software (Software Breakpoints). Comme pour
le choix de la version du processeur, plus vous choisissez de capacité de mise au point (débogage), plus cela
prendra beaucoup de place sur la matrice FPGA. Cliquez sur le bouton Finish et renommez le périphérique
en cpu (bouton droit sur le nom du périphérique et choisir Rename).

10. Ensuite vous allez rajouter l’interface pour la mémoire SRAM à votre système. Ce périphérique a été réalisé
sur mesure pour la carte DE2, on parle alors de Custom peripheral. Cette mémoire externe permet de stocker
le code et les données pour le processeur. Dans la catégorie University_ProgramMemory sélectionnez
l’élément SRAM/SSRAM Controller et cliquez sur le bouton Add… Cliquez sur Finish et renommez le
périphérique en ext_SRAM.

11. Ensuite, vous allez rajouter l’interface série qui permet de télécharger et débugger le code sur la cible, cette
interface permet également de communiquer avec le PC. Dans la catégorie Interface Protocol et ensuite
Serial, sélectionnez l’élément JTAG UART et cliquez sur le bouton Add… Cliquez sur Finish et
renommez le périphérique en jtag_uart.

8
12. Ensuite vous allez rajouter l’interface pour les afficheurs 7 segments. Ce périphérique est également un
Custom Peripheral. Dans la catégorie Project, sélectionnez l’élément Display DE2 Seven Segs Driver et
cliquez sur Add… Cliquez sur Finish et renommez le périphérique en seven_seg.

13. Ensuite, vous allez rajouter l’interface pour les LEDs. Dans la catégorie Peripherals et ensuite
Microcontroller Peripherals, sélectionnez l’élément PIO (Parallel I/O) et cliquez sur le bouton Add…
Choisissez une taille de 18 bit avec le mode Output. Cliquez sur Finish et renommez le périphérique en
LEDR. Refaites la même opération pour les LEDs Vertes. En choisissant 8 bit au lieu de 18 bit et en le
renommant LEDG.

14. Ensuite, vous allez rajouter les interfaces pour les boutons poussoirs (KEY) et pour les interrupteurs
(Switch). Dans la même catégorie Peripherals et ensuite Microcontroller Peripherals, sélectionnez encore
l’élément PIO (Parallel I/O) et cliquez sur le bouton Add… Choisissez une taille de 3 bit avec le mode
Input. Cliquez sur Finish et renommez le périphérique KEY.

15. Refaites la même opération pour les interrupteurs (Switch). En choisissant 18 bit au lieu de 3 bit et en le
renommant Switch.

16. Ensuite, vous allez rajoutez les temporisateurs qui vont vous permettre de faire des opérations séquentielles
sur les LEDs. Dans la catégorie Peripherals et ensuite Microcontroller Peripherals, sélectionnez
l’élément Interval Timer et cliquez sur le bouton Add… Laissez les paramètres par défaut et cliquez sur
Finish. Renommez le périphérique en sys_clk_timer. Refaites la même opération pour un deuxième timer
de plus grande précision. Modifiez l’unité de la période en µsec et cliquez sur Finish. Renommez le
périphérique en high_res_timer (il sera utilisé dans les prochains exercices pour mesurer le temps
d’exécution de certaines fonctions).

17. Ensuite, vous allez rajoutez l’interface série (UART) qui va vous permettre de communiquer avec un
PC ou une autre cible. Dans la catégorie Interface Protocols et ensuite Serial, sélectionnez l’élément
UART et cliquez sur le bouton Add… Laissez les paramètres par défaut et cliquez sur Finish.
Renommez le périphérique en uart.

18. Pour s’assurer que toutes les adresses de base sont valides et bien aligné, allez dans le menu System et
cliquez sur Auto-Assign Base Addresses.

19. Pour s’assurer que les IRQ (interruptions) ne sont pas en conflit, allez dans le menu System et cliquez
sur Auto-Assign IRQs.

20. Dans la colonne Module Name Double cliquez sur le cpu (Nios II) déjà rajouté à votre système. En bas
de cette page, vous allez sélectionner les adresses de reset et d’exception. Sélectionnez ext_SRAM pour
Reset Vector et ext_SRAM pour Exception Vector. Ensuite cliquez sur le bouton Finish.

9
Après toutes ces opérations, votre système devrait ressembler à ceci :

21. Vous pouvez maintenant cliquez sur le bouton Generate. SOPC Builder va vous demander si vous
voulez sauvegarder le système. Ensuite le logiciel va générer votre système Nios II fait sur mesure.
Cette opération consiste a généré tout le code HDL des IP que vous avez instancié dans SOPC Builder.
Cette opération prend un certain temps, pour éviter de perdre du temps, passé à la suite avant d’attendre
la fin de la génération.

22. Retournez dans Quartus II. Dans la suite, vous allez instancier le composant créé avec SOPC Builder
avec les entrées/sorties du FPGA. Pour cela, vous allez utiliser l’outil graphique de Quartus II. Créez un
nouveau fichier graphique en allant sur File  New, choisissez Design Files  Block
DIagram/SChematic File comme type de fichier. Enregistrez le sous le nom TP1.bdf dans le même
répertoire que le projet.

23. Quand SOPC Builder aura terminé, vous allez instanciez le système dans le fichier TP1.bdf. Dans ce
schéma, double cliquez n’importe où. Ceci ouvre la fenêtre de Symbol. Développer le répertoire
Project et sélectionner le symbole niosII.

10
24. Cliquez sur le bouton OK et placez le symbole dans le schéma comme indiqué ci-dessous.

25. Maintenant il faut connecter les entrées/sorties du composant niosII avec les entrées/sorties du FPGA.
Pour cela, vous allez utiliser les noms attribués dans le fichier d’assignement. Double cliquez n’importe
où. Ceci ouvre la fenêtre de Symbol. Développer le répertoire c:/altera/10.1/quartus/libraries ensuite
primitives et puis pin, sélectionnez input.

11
E2i3 : UE Codesign Y. DOUZE
26. Cliquez sur OK et placez ce port d’entrée à gauche du composant niosII, en face de la clk_in. Double
cliquez sur le port et renommer le CLOCK_50 (nom utilisé pour l’entrée de l’horloge de 50 MHz dans
le DE2_pin_assignement.csv).
27. Ensuite il faut faire la connexion en cliquant sur l’icône et relier le port d’entrée CLOCK_50 avec
l’entrée clk_in du niosII.

28. Pour les ports de plusieurs bits, il faut faire différemment. Par exemple pour l’entrée Switch qui est sur
18 bits. Il faut faire la même manipulation que les étapes 28 et 29 mais pour la nomination du port, il
faut écrire SW[17..0] pour préciser qu’il s’agit d’un vecteur de 18 bits. Pour la connexion il faut choisir
l’icône suivante : .

29. Il faut connecter l’entrée reset_n avec un des boutons poussoir de la carte. On doit relié KEY[0..0] avec
reset_n et KEY[3..1] avec l’entrée KEY du composant niosII. Comme le montre l’image ci-dessous.

30. Pour l’entrée de l’UART, il faut choisir le nom UART_RXD.

31. Pour les sorties, choisir output au lieu de input. Il y a un seul port bidirectionnel qui est le bus de
données de la mémoire SRAM (sram_dq). Pour celle-ci il faut choisir un port de type bidir. Pour toutes
les autres sorties, voir ci-dessous les noms qu’il faut choisir en conformité avec l’assignement des pins.
Pour les afficheurs 7 segments, il faut intercaler un inverseur logique. Pour cela, cliquez sur l’icône
et allez dans primitives  logic  not.
32. Une fois que vous avez connecté toutes les entrées/sorties de votre FPGA dans le composant
schématique TP1.bdf, il faut ajouter ce composant à votre projet et le choisir comme top-level de votre
design. Pour cela, allez dans l’onglet Files du Project Navigator. Click droit sur le répertoire Files et
sélectionnez Add/Remove Files in your project…, ajoutez le TP1.bdf et cliquez sur Add puis OK.
Ensuite click droit sur le TP1.bdf et choisir Set as top-level entity.

33. Maintenant il va falloir connecter les entrées/sorties du composant créée avec SOPC Builder avec les
entrées/sorties du FPGA. Pour faciliter cette tache, nous vous fournissons un fichier de configuration
(DE2_pin_assignements.csv) qui attribut un nom explicite à chaque numéro de pin du FPGA
conformément à l’implémentation du FPGA sur la carte DE2. Pour importer cette configuration dans
votre projet, allez sur Assignements  Import Assignements et choisissez le fichier
DE2_pin_assignements.csv. Pour vérifier que l’importation a bien été effectuée, allez dans
Assignements  Pin Planner.

34. Maintenant, vous pouvez faire la synthèse de votre design. Depuis le menu Processing, sélectionnez
Start Compilation ou alors, cliquez directement sur l’icône . Après quelques minutes, la fenêtre
Compilation Report - Flow summary apparait et vous donne les résultats de la synthèse et du
placement routage. Cette page vous renseigne sur la place occupée par votre design dans le FPGA :
 Le nombre d’éléments logiques utilisés (Total Logic element)
 Le nombre de registres (Total Registers)
 Le nombre de pins (Total Pins)
 L’espace mémoire utilisés (Total Memory bits)
 Le nombre de multiplieur utilisés (Embedded multiplier 9-bit)
 Le nombre de PLL
35. Assurez-vous que la carte est alimentée. Connectez la carte à votre PC avec le câble USB (connecteur
BLASTER de la carte DE2 et pas DEVICE). Lancez le programmateur depuis le menu Tools 
Programmer ou l’icône . Une fenêtre apparait, cliquez sur OK. Le nom du type de câble (USB-
Blaster) doit apparaitre à cotés de Hardware Setup…
Ci ce n’est pas le cas, cliquez sur le bouton Hardware Setup. Ensuite sélectionnez votre type de câble dans
le menu Currently selected hardware. Une fois que votre câble est sélectionné, fermer la fenêtre en
cliquant sur Close.

36. Le fichier TP1.sof devrait déjà être sélectionné dans la fenêtre de programmation. Ci ce n’est pas le cas,
cliquez sur le bouton Add File… afin de le sélectionner. Cochez la case Program/configure qui
correspond à votre fichier .sof et ensuite cliquez sur le bouton Start afin de programmer le FPGA.

37. Si tout va bien, le FPGA est maintenant configuré. Si vous avez une version limité de la licence une
fenêtre OpenCore Plus Status doit apparaitre, surtout ne pas appuyer sur Cancel.

38. Vous avez maintenant terminé la partie Hardware et vous allez passer à la partie Software avec l’outil
Nios II Software Buil Tool for Eclipse qui est un environnement de développement basé sur Eclipse.
Partie 2 : Software (30 minutes)

1. Dans les étapes suivantes, vous allez compiler un programme pour votre système SOPC, le télécharger
dans la carte et l’exécuter. Pour cela, retournez dans SOPC Builder, ouvrir l’outil NiosII SBT à partir
du menu Nios II  Nios II Software Build Tool. Au démarrage on vous demande de sélectionner le
répertoire de travail. Choisissez le répertoire /E2i3_TP1_CoD_SOPC_Builder/software.

2. Créer un nouveau projet en sélectionnant File  New  Nios II Application and BSP from
Template dans la barre des menus.
Dans la partie Target Hardware Information, vous devez spécifiez par un fichier .sopcinfo
qu’elle est la cible sur laquelle vous allez développer. Il s’agit de la cible que nous venons de
créer avec SOPC Builder précédemment. Naviguez vers le chemin de votre projet afin de
sélectionner le fichier niosII.sopcinfo. Ensuite choisissez le nom de votre projet
(niosII_training_project par exemple). Dans la partie Select Project Template, choisissez
Blank Project. Cliquez sur Finish.
3. Vous avez maintenant créez deux nouveaux répertoires, un projet C/C++
(nios_training_project) et un projet qui contient les librairies pour votre système
(niosII_training_project_bsp). Cependant, le projet C/C++ est vide et nous devons y ajouter
des codes sources.
Pour ajouter le fichier simple.c à votre projet, d’abord développer le répertoire
niosII_training_project. Ensuite naviguer sur votre disque réseau H: et trouver le fichier
simple.c (voir dans le répertoire software). « drag and drop » le fichier simple.c dans le
répertoire niosII_training_project dans l’IDE Nios II comme le montre la figure ci-dessous.
4. Maintenant, sélectionnez le répertoire niosII_training_project_bsp, faites un click droit et
choisissez NiosII BSP Editor. Dans cette page, vous pouvez choisir toutes les propriétés de
votre système.
Assurez-vous que stdout, stderr et stdin soit configuré sur jtag_uart. Ce choix de
configuration signifie que le JTAG est la sortie standard de votre système. Dans ce cas, les
fonctions printf() ou scanf() permettent d’écrire ou de lire des données sur le bus série du
JTAG.
Vérifiez que sys_clk-timer soit configuré avec sys_clk_timer et que Timestamp_timer soit
configuré avec high_res_timer.
Cliquez sur Generate et ensuite Exit.
5. Maintenant vous allez compiler le code, pour cela, sélectionnez le répertoire
niosII_training_project, ensuite avec le clic droit sélectionnez Build Project ou alors cliquez
sur l’icône suivante :
Note : Vous pouvez faire en sorte que la compilation soit faite en arrière plan (background),
ou alors laisser l’exécution de cette tache en premier plan (forground). Lorsque la
compilation s’exécute en arrière plan, vous avez la possibilité d’utiliser l’outil pour faire
d’autres opérations.

6. Après que la compilation soit terminée, il faut télécharger le programme sur la cible. Pour cela
sélectionner le répertoire niosII_training_project, avec le clic droit sélectionnez Run As 
Nios II Hardware.
Note 1 : Si une fenêtre s’ouvre, allez dans l’onglet Target Connection et cliquez sur Refresh
Connections et dans System ID Check cochez les deux cases Ignore Mismatched System ID
et Ignore Mismatched System TimeStamp et enfin cliquez sur Run

Cette commande va télécharger le programme vers la cible et l’exécuter. Vous devriez

observer sur la console le message Hello World ! Vous devriez également voir les LEDs
vertes clignoter. Maintenant modifiez la valeur sur les interrupteurs et vérifiez que le résultat
est recopié sur les LEDs rouges.

Dans le programme simple.c, vous avez des fonctions qui permettent de lire ou d’écrire sur les
interfaces d’entrées sorties.
Pour la lecture des switch: sw=IORD_ALTERA_AVALON_PIO_DATA(SWITCH_BASE);
Pour l’écriture sur les LEDR : IOWR_ALTERA_AVALON_PIO_DATA (LEDR_BASE,sw);
Dans les 2 cas le paramètre NOM_DU_PERIPHERIQUE_BASE correspond à l’adresse du
périphérique dans l’espace adressable du Nios II. Vous pouvez retrouver la valeur de cette
adresse dans le fichier system.h. Ce fichier renseigne sur les paramètres de votre système.
Pour l’ouvrir, allez sur le répertoire NiosII_training_project_bsp  System.h
Par exemple, relevez l’adresse de SWITCH_BASE et vérifiez que c’est bien la même que celle
spécifié dans SOPC Builder.
Le périphérique SEVEN_SEG est composé de plusieurs registres d’écriture pour cette raison il
faut rajouter un offset dans l’adresse pour écrire sur les différents registres du périphérique.
Pour avoir plus de détail sur ce périphérique, vous pouvez examiner le code VHDL de ce
 périphérique (voir le fichier de2_sevensegs.vhd dans le répertoire de2sevensegs). En effet, ce
périphérique n’est pas fourni par Altera, il a été fait sur mesure pour la carte DE2.

7. Maintenant, vous allez tester le debugger. Lancer le debugger en sélectionnant le répertoire

niosII_training_project. Ensuite avec le clic droit sélectionnez Debug As  Nios II
Hardware. Le debugger va se lancer, se connecter et télécharger le code sur la cible. (Choisir
Yes lorsqu’on va vous demander de changer de perspective pour le debug).

8. Activer l’affichage des numéros de ligne. Pour cela, allez sur Window dans le menu et ensuite
Préférences. Ouvrir le répertoire General et ensuite sélectionnez Editors  Text Editors.
Activer le carré Show line numbers et puis appuyer sur OK.

9. Positionnez des points d’arrêts sur les lignes 27 e 31. Pour positionner un point d’arrêt, il suffit
de placer le curseur dans la partie grise à gauche des numéros de ligne et faire un double click.
Un petit rond bleu doit normalement apparaitre à cotés du numéro de ligne indiquant qu’un
point d’arrêt a été positionné. Cliquez sur le bouton resume . Le programme s’arrête sur le
premier point d’arrêt à la ligne 27.
10. Maintenant, sélectionnez la fenêtre Variables et visualiser la valeur de la variable sw. Pour
afficher la valeur en hexadécimal, sélectionnez la variable sw, avec un clic droit choisissez
 Format et ensuite Hexadécimal. Vérifiez que la valeur de sw correspond à la position des
interrupteurs sur la carte DE2. Afficher également la valeur de GreenLed en hexadécimal.

11. Vous pouvez également faire du pas à pas avec le debugger. Pour cela appuyer sur l’icône
suivante :

12. En faisant du pas à pas, vous devriez voir la valeur de GreenLed être inversé et les LEDs vertes
s’éteindre sur la carte.

13. Changez la position des interrupteurs et en cliquant sur l’icône , vérifiez que la valeur de sw
change en conséquence.

14. Pour arrêter le debugger. Allez dans le sous-menu Debug, ensuite faire un clic droit sur le
nom du projet logiciel qui est en train d’être debugger et sélectionnez Terminate and Remove.

15. Pour revenir à la fenêtre de l’IDE, cliquez sur la double flèche en haut à droite de l’écran

et sélectionnez Nios II
Partie 3 : Exercices (45 minutes)

Après avoir testé le programme donné en exemple simple.c qui envoie un message sur la liaison série, qui
recopie les valeurs des interrupteurs sur les LEDs rouges, qui fait clignoter les LEDs vertes et qui affiche des
valeurs quelconques sur les afficheurs 7 segments, modifier ce code pour répondre aux questions suivantes :

1. Envoyez de manière continu la valeur des interrupteurs (sw) sur la console (avec la fonction printf()) et
générez un chenillard sur les LEDs vertes.

2. Ecrire un programme qui permet de commander la valeur des LEDs vertes, des LEDs rouges et les valeurs à
afficher sur les afficheurs 7 segments à partir de la console de l’IDE. Pour cela il faut utiliser la fonction
scanf(). Pour que les commandes soient décodées correctement par la cible, il faut inventer un codage
explicite. Par exemple :
 pour afficher la valeur 100 sur les LEDs vertes, envoyer la commande g 100 (g comme green)
 pour afficher la valeur 100 sur les LEDs rouges, envoyer la commande r 100 (r comme red)
 pour afficher la valeur 3 sur l’afficheur HEX0, envoyer la commande h0 3.
 pour afficher la valeur 9 sur l’afficheur HEX5, envoyer la commande h5 9.
 Etc…

3. Faire un chenillard sur les LEDs vertes commandé en vitesse par les boutons poussoirs (KEY). Par exemple,
le défilement du chenillard s’accélère si vous appuyez sur le bouton poussoir KEY [3], et le défilement
ralentit si vous appuyez sur le bouton poussoir KEY [2]. Attention ! les boutons poussoir sont à l’état haut
au repos et KEY [0] est utilisé comme reset du système.
Custom Peripherals
Cette partie consiste à reprendre l’architecture matérielle créée pendant la première partie et y
rajouter un périphérique personnalisé (Custom Peripheral) qui va permettre de commander les LEDs
vertes en intensité.
Pour apprendre à créer un périphérique personnalisé avec la suite logicielle d’Altera, vous allez
fabriquer un périphérique PWM qui va permettre de commander les LEDs vertes en intensité. Au lieu
de les commander en tout ou rien, vous allez pouvoir commander l’intensité lumineuse des LEDG en
modifiant le rapport cyclique du périphérique PWM.

Pour réaliser ce périphérique, on vous fournit le code VHDL du composant. Avant de commencer,
examiner le code VHDL de ce périphérique (avalon_pwm.vhd) afin de comprendre comment il
fonctionne.
Dans les étapes suivantes, vous apprendrez comment insérer ce périphérique dans SOPC Builder,
comment l’ajouter à votre système et comment doit être écrit le code C qui permet d’utiliser ce
périphérique.
Dans une deuxième partie vous allez écrire un programme qui permet de générer un battement de
cœur (HeartBeat) sur les LEDs vertes.
Partie 4 : Création d’un périphérique personnalisé : Custom Peripheral (30
minutes)

1. Dans SOPC Builder sur la colonne Use de la liste des périphériques de votre système. Désélectionnez la
case correspondant aux LEDs vertes (LEDG). Nous désélectionnons ce périphériques car nous allons
maintenant piloter les LEDs à partir du périphérique PWM que vous allez créer dans cette partie.

2. Vous allez maintenant créez un composant pour SOPC Builder à partir du code VHDL. Dans le menu File,
sélectionnez New Component et allez vers l’onglet HDL Files.

3. Cliquez sur Add et naviguer vers le fichier “avalon_pwm.vhd”. Cliquez sur Open.

4. SOPC Builder exécute l’analyseur de Quartus II pour vérifier qu’il n’y a pas d’erreur de syntaxe dans le
code. Cliquez sur Close.

5. Assurez-vous que le Top Level Module pointe bien sur avalon_pwm.

6. Allez sur l’onglet Interfaces, dans la section Avalon Slave Settings, positionnez les valeurs de Read Wait
et Write Wait à 0.

7. Allez sur l’onglet Signals, pour le signal nommé out_port de la colonne Name, dans la colonne Interface,
en face de out_port, sélectionnez new Conduit…

8. Positionnez la colonne Interface et la colonne Signal Types comme dans la figure ci-dessous :

L’onglet Interface permet de définir les interfaces de votre composant, dans votre cas, vous avez 2
interfaces :
- Une interface “export_0”(Conduit Output) qui correspond à la sortie de votre module PWM et qui
sera connecté avec les LEDs
- Une interface “avalon_slave_0”(Avalon Slave) qui correspond à l’interface connecté avec le bus
avalon. Le paramètre slave est mentionné car votre périphérique ce comporte en temps qu’esclave de
votre système. Il ne fait qu’exécuter des ordres, il n’en donne pas.

L’onglet Signals permet de définir les connexions entre les ports d’entrées/sorties de l’entité de votre
composant avalon_pwm et les signaux du bus avalon.
9. Allez sur l’onglet Library Info, et observez les paramètres par défauts. Positionnez le champ Group sur
Peripherals/Microcontroller Peripherals. Ce paramètre représente la catégorie dans laquelle sera rangé
votre composant dans SOPC Builder. Ce sera l’endroit ou vous devrez aller chercher votre composant pour
l’incorporer à votre système.
Dans cet onglet vous pouvez également rajouter des renseignements sur ce périphérique, comme l’auteur ou
une url vers la documentation technique, etc…
Cliquez sur Finish et ensuite sur Yes, Save

10. Maintenant, dans SOPC Builder allez dans le menu File et sélectionnez Refresh Component List.

11. Localisez le composant avalon_pwm que vous venez de créer et ajoutez le à votre système (Si vous avez
bien suivit les instructions, il devrait être dans la catégorie Peripherals Microcontroller Peripherals).
Renommer le en avalon_pwm_inst.

12. Avant de générer le système, il est préférable de réaligner les adresses. Pour cela, allez dans System 
Auto Assign Base Adress.

13. Cliquez sur le bouton Generate pour régénérer votre système.

14. Une fois que le système a été régénéré, allez sur l’éditeur schématique de Quartus II. Sélectionnez le
composant niosII et avec le clic droit sélectionnez Update Symbol or Block.
Vous devriez observer que les ports sur le symbole ont changé en relation avec les changements que vous
avez faits dans SOPC Builder. Il est possible que certaine connexion soient incorrectes après la mise à jour
du symbole, modifier le schéma afin de rétablir ces connexions.

15. Sauvegardé le schéma mis à jour (File  Save), et faites la synthèse du nouveau design en cliquant sur .
Cliquez sur Ok quand la synthèse est terminé avec succès.

16. Ouvrez le programmateur en cliquant sur . Cochez la case Program/Configure, et cliquez sur le bouton
Start pour implémenter le circuit dans le FPGA.

17. Dans SOPC Builder, ouvrez Nios II SBT (Nios II  Nios II Software Build Tool), créer un nouveau
projet en allant dans le menu File et sélectionnez New NiosII Application and BSP Template.

18. Sélectionnez le bon fichier niosII.sopcinfo. Choisissez niosII_pwm_project comme nom pour votre projet.
Dans la partie Select Project Template, sélectionnez Blank Project et cliquez sur Finish.

Pour la suite, on vous a fournit les programmes qui permettent d’utiliser votre nouveau périphérique
avalon_pwm. Ouvrez et examinez le fichier pwm.c et le fichier altera_avalon_pwm_regs.h qui se trouve
dans le répertoire source_pwm.
Vous remarquerez que l’on vous a fournit un fichier .h qui définit quatre fonctions qui permettent de venir
lire ou écrire dans les registres duty et divider. Ces fonctions permettent de venir modifier les paramètres
de votre périphérique. En l’occurrence, ici cela permet de venir modifier la période et le rapport cyclique
de votre signal PWM de sortie.

19. Utilisez l’explorateur Windows et naviguer vers le répertoire source_pwm. Glisser et déposer le fichier
pwm.c et le header qui l’accompagne altera_avalon_pwm_regs.h vers le répertoire niosII_pwm_project
dans l’EDS Nios II.

20. Avant de compiler il faut régénérer le BSP qui a été légèrement modifié par l’ajout du Custom Peripheral.
Pour cela, clic droit sur le dossier du BSP et sélectionnez NiosII  Generate BSP
21. Sélectionnez le répertoire niosII_pwm_project et avec le clic droit sélectionnez Build Project et ensuite
cliquez sur Run in Background.

22. Après que la compilation soit terminée, sélectionnez Run As  Nios II Hardware.

23. Le message “Application - PWM” devrait apparaitre dans la console de l’IDE. Suivit par la question
“Please enter an LED intensity between 1 to 4 (0 to exit)”.

24. Cliquez avec la souris sous le texte afin d’y placer le curseur. Ajuster l’intensité des LEDs en tapant 1, 2, 3
ou 4 suivit par la touche Entrée.

25. Si vous tapez 0 sur votre clavier, cela terminera le programme.

Partie 5 : Battement de cœur : HeartBeat (30 minutes)

Dans cette cinquième partie, le but est d'afficher sur les vertes LEDs de la carte DE2 un « coeur qui bat»
(HeartBeat en anglais). Pour cela, il faut moduler l'intensité perçue par les diodes luminescente par une fonction
triangulaire comme ci-contre. Il n'est pas demandé une période très précise, mais une variation « autour » de 1
hertz (entre 0.5 et 2 Hz par exemple).

~ 1 second Ton
100%
Intensity

Toff
0%

Remarque : dans la pratique, l'intensité lumineuse perçue n'est pas une fonction linéaire, mais nous négligerons
ceci pour cette application simple.

Pour que l’œil ne voit pas les allumages et extinctions de la LED, il faut que la période Ton+Toff soit
suffisamment faible. Une fréquence d'au moins 50 Hz (Ton+Toff < 20 ms) suffit. D'un autre côté, on évitera
également les périodes trop courtes peu compatibles avec les temps de commutation de l'électronique de
commande, et génératrices d'interférences. Un bon choix se situe entre 60 Hz (16.7 ms) et 400 Hz (2.5 ms).

Pour générer des tempos, il est conseillé d’utiliser la fonction usleep() que vous avez déjà utilisé dans le TP1. Si
vous utilisez usleep(), ne pas oublier de rajouter la librairie unistd.h (#include ″unistd.h″).

Ecrivez le programme HeartBeat.c qui permet de répondre à ce cahier des charges.

Partie 6 : Périphérique personnalisé et paramétrable (30 minutes)

Dans cette partie du TP, on désire rendre le périphérique avalon_pwm paramétrable afin de pouvoir
choisir le nombre de bits de sortie lors de l’instanciation du périphérique dans SOPC_Builder.

1. Pour cela, il faut modifiez le code VHDL du composant avalon_pwm afin de le rendre générique. Dans
un premier temps, faites une copie du fichier avalon_pwm.vhd et renommer le en
avalon_pwm_generic.vhd (renommer également l’entité du composant en avalon_pwm_generic).
Ensuite modifier le code de ce composant en rendant la taille du vecteur de sortie out_port modifiable
grâce à un paramètre générique N.
 2. Créez un nouveau composant dans SOPC Builder en suivant les mêmes étapes que dans la partie 4 du
TP. Vous devriez remarquer que dans ce nouveau composant il est possible de paramétrer la taille du
vecteur de sortie.

3. Dans SOPC Builder, sélectionnez Files  Refresh Component List

4. Ensuite, remplacez le périphérique LEDR par votre nouveau composant avalon_pwm_generic et

choisissez 18 pour la taille du vecteur de sortie (N).

5. Générer votre système dans SOPC Builder, mettez à jour le composant niosII dans le schéma de
Quartus II et réparer les connexions qui ont été cassé, faites la synthèse dans Quartus II et chargez le
circuit sur le FPGA.

6. Dans l’IDE Nios II, modifiez le code C afin de générer un cœur qui bat sur les LEDs rouges.

7. Compilez et testez votre code sur la cible.

Partie 7 : Configuration individuelle de chaque sortie PWM (30 minutes)

Dans cette partie, on désire créer un composant sur lequel il y a plusieurs sorties PWM (8 par exemples)
mais sur lequel on puisse configurer chaque canal individuellement. Au lieu que toutes les sorties PWM aient le
même rapport cyclique, on désire pouvoir configuré le rapport cyclique de chaque sortie individuellement.

1. Pour cela, il faut modifiez le code VHDL du composant avalon_pwm. Dans un premier temps, faites
une copie du fichier avalon_pwm.vhd et renommer le en avalon_pwm_8_channels.vhd.
Ensuite il faut modifier le code de ce composant afin de pouvoir configurer la période et le rapport
cyclique de chaque sortie individuellement. Pour cela, il faut changer la taille du bus d’adresse car les
deux registres DIV et DUTY ne suffisent plus pour configurer individuellement chaque sortie PWM.
Pour configurer individuellement chaque sortie PWM il faut autant de registre DIV et DUTY que de
sorties PWM. Si on choisit 8 sorties PWM, il faut alors 16 registres internes.
Ensuite, il faut choisir une adresse pour chaque registre. On choisit par exemple que les 8 adresses
basses (0 à 7) soient réservé pour les registres DIV et les 8 adresses hautes (8 à 15) pour les registres
DUTY.

2. Créez un nouveau composant dans SOPC Builder en suivant les mêmes étapes que dans la partie 1 du
TP.

3. Ensuite, remplacez le périphérique LEDG par votre nouveau composant avalon_pwm_8_channels.

4. Générer votre système dans SOPC Builder, mettez à jour le composant niosII dans le schéma de
Quartus II et réparer les connexions qui ont été cassé, faites la synthèse dans Quartus II et chargez le
circuit sur le FPGA.

5. Dans l’IDE Nios II, modifiez le code C afin de générer un cœur qui bat sur les LEDs vertes.

6. Compilez et testez votre code sur la cible.