Master M2 SET

Année universitaire 2010-2011

 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Sommaire :

I. Introduction…………………………………………………......................... 2
1. Le processeur Nios II :……………………………………………………. 2
2. Le but du TP………………………………………................................... 2

II. Manipulation………………………………………………………………….3
1. Utilisation de ports d’entrée/sortie……………………………….. 3
2. Calcul de la tension maximale à la sortie du filtre………………... 4
3. Calcul de la tension par programmation………………………….. 4
a. Pour une seule valeur de fréquence……………………………4
b. Pour 50 valeurs de fréquence…………………………………. 6
4. La fonction de transfert du filtre…………………………………... 7

III. Conclusion…………………………………………………………………….9
IV. Liste des figures……………………………………………………………... 10
V. Liste des programmes……………………………………………………... 10
VI. Annexe……………………………………………………………………….. 10
VII. Références………………………………………………………………….. 10

1
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

I. Introduction :

1. Le processeur Nios II :

Nios II est un processeur 32-bit embarqué conçu spécialement pour la famille des FPGA
Altera. Nios II incorpore de nombreuses améliorations sur l'architecture d'origine Nios, le
rendant plus adapté pour une large gamme d'applications d'électronique embarqué et systèmes
de contrôle.

L'architecture Nios II est une architecture RISC soft-core qui est mis en œuvre
entièrement dans une FPGA. La nature embarquée de ce type de processeur permet au
concepteur de spécifier et générer un processeur sur mesure pour des besoins d'applications
spécifiques. Les concepteurs peuvent étendre les fonctionnalités de base en y ajoutant une
unité de gestion de mémoire prédéfini, définir des instructions personnalisées ou des
périphériques personnalisés [1] :

 Jusqu'à 256 instructions personnalisées.

 Jusqu'à 4 mémoires couplés (TCM).
 Débogage configurables.
 Compilateur C2H (pour convertir un programme en C en accélérateurs matériels).
 Supporte plus de 60 périphériques, ce qui offre un choix de configurations sans
équivalent, où l’on trouve l'Ethernet, l'USB, Temporisateur, UART, accès direct à
la mémoire (DMA), ...

Le développement sur Nios II se compose de deux étapes distinctes: la phase de

conception logicielle et la phase de production matérielle :

Figure I.1 Phases de développement sur Nios II [1].

2
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Altera propose un logiciel appelé "Embedded Development Suite" (EDS) qui contient un
environnement de développement intégré complet pour gérer le matériel et le programme en
deux étapes distinctes:

 Processus de génération de matériel :

les concepteurs de matériel Nios II utilise le "SOPC Builder" (System-on-a-

Programmable-Chip), un composant de l'environnement Quartus II, qui permet de configurer
et de générer un système Nios. L'interface utilisateur de configuration graphique (GUI)
permet aux utilisateurs de choisir le Nios II et l'ensemble de ses fonctionnalités et d'ajouter
des périphériques, des blocs d'entrées/sorties, interface série... pour le système embarqué.
Lorsque la spécification du matériel est terminée, Quartus II effectue la synthèse pour mettre
en œuvre l'ensemble du système sur l'FPGA cible sélectionnée.

 Processus de création logicielle :

Une partie distincte du logiciel "Embedded Development Suite (EDS)", gère le

développement du programme. Elle comprend un compilateur C / C + +, un débogueur et un
simulateur de jeu d'instructions. EDS permet aux programmeurs de tester leurs applications
dans la simulation, ou télécharger et exécuter leur application compilée directement sur
l'FPGA.

2. Le but du TP:

L’objectif de ce TP est la mise en œuvre et la configuration d’un processeur

embarqué : le processeur Nios II de Altera, puis la programmation de ce processeur afin
d’exécuter les différents tâches demandées, à savoir :

 La gestion des entrées sorties.

 L’utilisation du Timer.
 L’utilisation des mémoires SDRAM et DRAM.
 Evaluation de temps d’exécution pour les différentes versions du processeur.
 La gestion d’interruptions…

Notons que le programme C complet écrit pendant ce TP est donné sur l’ANNEXE.

II. Manipulation :

1. Mise en œuvre du processeur :

L’architecture complète du processeur est donnée par la figure II-1. Dans les paragraphes à
suivre on va la décrire partie par partie selon l’application demandée.

3
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Figure II.1 : l’Architecture du processeur NiosII utilisé.

Pour une première analyse de l’architecture, notons que l’entrée clk du processeur est
reliée à la patte CLOCK_50, ce qui garantie que la fréquence du système est bien de 50 MHz.

4
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Ainsi que le reset du processeur est relié à la patte KEY[0] ce qui signifie que l’initialisation
du système est faite par le bouton poussoir le plus faible de la carte DE2 d’Altera.

2. Utilisation de ports d’entrée/sortie :

a. Commande des leds par les interrupteurs :

L’objectif de cette partie est d’afficher par le processeur les valeurs des 8 interrupteurs
SW[7..0] sur les leds vertes LEDG[7..0].Pour cela il faudra prévoir au niveau du processeur,
en plus des éléments décrits précédemment, deux ports d’entrées/sorties (PIO), un configuré
en entrée, l’autre en sortie. Figure II.2 :

Figure II.2 : Entrée/sortie, contrôl des leds par les interrupteurs.

Plus la configuration matérielle sur le SOPC Builder il faut aussi générer le programme
C/C++ sous l’environnement "Embedded Development Suite (EDS)" qui va permettre de
contrôler les leds à l’aide des interrupteurs.

Les instructions sont données par le programme 1 :

#include <stdio.h>
#include "system.h"
#include "altera_avalon_pio_regs.h"

int var;
int main(){

while(1){

/*****contrôle des LED par les interrupteurs*****/

var = IORD_ALTERA_AVALON_PIO_DATA(INTERUPT_BASE);

IOWR_ALTERA_AVALON_PIO_DATA(LED_BASE,var);

Programme 1 : Contrôl des leds par les interrupteurs.

La fonction IORD_ALTERA_AVALON_PIO_DATA()est décrite dans la bibliothèque

"altera_avalon_pio_regs.h", elle permet de lire la valeur de l’interrupteur donnée
par INTERUPT_BASE, cette dernière représente l’adresse de base de l’interrupteur donnée
par le fichier system.h.

La fonction IOWR_ALTERA_AVALON_PIO_DATA()est décrite aussi dans la

bibliothèque "altera_avalon_pio_regs.h", elle a deux arguments : LED_BASE c'est-

5
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

à-dire la led destination, et var qui représente la valeur de l’interrupteur (0 ou 1). Cette
fonction permet de contrôler la led selon l’état de l’interrupteur.

b. Clignoter une led :

Le but de cette partie est de créer une procédure de temporisation logicielle pour faire
clignoter une led. Le teste est fait sur la led LEDG8.

Pour cela il faut prévoir une autre sortie au système. Figure II.3 :

Figure II.3 : Sortie pour contrôler la LEDG8.

Le sous programme qui assure cette application est donné par Programme 2 :

void Clignoter_Led(){
int i,permut;
if (i>=100000){
i=0;
if (permut){
permut = 0;
}
else {
permut = 1;
}
IOWR_ALTERA_AVALON_PIO_DATA(LEDG8_BASE, permut);
}
else{
i++;
}
}

Programme 2 : Sous programme pour clignoter la LEDG8.

Ce programme est donné par un compteur qui contrôle la fréquence de clignotement, il permet
de varier la valeur du variable permut de 0 à 1 (ou inversement) si la condition
(i>=100000) est vérifiée. La fonction IOWR_ALTERA_AVALON_PIO_DATA() permet
d’allumer ou éteindre la led LEDG8 selon la valeur de permut ( 0 ou 1).

c. Control de l’afficheur 7 segments:

Dans cette partie on va afficher des nombres sur les afficheurs 7 segments (HEX 7 à HEX 0),
lus en binaire à partir des interrupteurs de la carte.
Pour cela il faut rajouter une entrée sur 15bits qui représente les 15 interrupteurs, et 8 sorties
sur 7 bits chacune pour commander les 8 afficheurs.
Le schéma qui permet de faire cette application est donné par la figure II.4 :

6
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Figure II.4 : Les entrées/sorties pour contrôler les afficheurs 7 segments.

Pour faire la conversion BCD (4bits)/7 segment il faut décrire en VHDL le bloc de
conversion. Le code VHDL est donné par le programme 3.

Entity 7_segment is
port(
E:in bit_vector (3 downto 0);
S:out bit_vector (6 downto 0)
);
end 7_segment;

architecture Archi of 7_segment is

begin
with E select
S<= "1000000" when "0000",
"1111001" when "0001",
"0100100" when "0010",
"0110000" when "0011",
"0011001" when "0100",
"0010010" when "0101",
"0000010" when "0110",
"1111000" when "0111",
"0000000" when "1000",
"0010000" when "1001",
"1111111" when others;
end behavior;

Programme 3 : Code VHDL pour la converssion BCD/7segments.

Maintenant il ne reste qu’à écrire le programme C, à implémenter sur le processeur, pour faire
le traitement.
Le code est donné par le programme 4 :

7
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

int main(){
int modulo[8],i;
int val;//nombre décimale de 8 chiffres maximal.
while(1){
val = IORD_ALTERA_AVALON_PIO_DATA(INTERUPT_BASE);
for(i=0;i<=7;i++){
modulo[i]= val%10;//calcul du modulo
val=val/10;
}
/****chaque afficheur reçoit un chiffre ****/

IOWR_ALTERA_AVALON_PIO_DATA(BCD0_BASE,modulo[0]);
IOWR_ALTERA_AVALON_PIO_DATA(BCD1_BASE,modulo[1]);
IOWR_ALTERA_AVALON_PIO_DATA(BCD2_BASE,modulo[2]);
IOWR_ALTERA_AVALON_PIO_DATA(BCD3_BASE,modulo[3]);
IOWR_ALTERA_AVALON_PIO_DATA(BCD4_BASE,modulo[4]);
IOWR_ALTERA_AVALON_PIO_DATA(BCD5_BASE,modulo[5]);
IOWR_ALTERA_AVALON_PIO_DATA(BCD6_BASE,modulo[6]);
IOWR_ALTERA_AVALON_PIO_DATA(BCD7_BASE,modulo[7]);
}
}

Programme 4 : Contrôl des afficheurs 7 segments par les interrupteurs.

Le programme est donné par une boucle while pour qu’il s’exécute d’une manière
continue.
La variable val reçoit la valeur décimale représentée par les interrupteurs, en utilisant la
fonction IORD_ALTERA_AVALON_PIO_DATA().
La boucle for de 8 itérations, permet pour une première itération de calculer le modulo de
(val/10) puis pour chaque itération on divise le résulta sur 10 et on calcule à nouveau le
modulo, les résulta sont stockées sur le tableau modulo[].
Pour envoyer la valeur donnés par les interrupteurs aux afficheurs, on utilise la fonction
IOWR_ALTERA_AVALON_PIO_DATA(),qui se compose de deux arguments : l’adresse de
base de l’afficheur BCDi_BASE, et la valeur à afficher donner par les valeurs modulo[i]
avec i varie de 0 à 7.

3. Utilisation d’un timer :

L’objectif de cette partie, est d’utiliser le timer pour calculer les temps d’exécution des
programmes afin d’évaluer les performances des 3 versions des processeurs disponibles.
Figure II.5

8
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Figure II.5 : les 3 processeurs NIOSII.

A la fin de ce paragraphe on a mis un tableau qui résume les temps d’exécution des
différents programmes selon le processeur utilisé.

a. Valeur maximale d’un tableau non trié:

On rajoute au programme précédent une sous fonction qui permet de remplir un

tableau de 100 valeurs et d’afficher la valeur maximale du tableau et le temps nécessaire à
cette opération.

La sous fonction est donnée par le programme 5 :

void Remplir_Tableau(int tab[], int n){

int Max1,time1,i;
for(i=0;i<n;i++){
tab[i]=rand(); //remplissage du tableau par des nombre
} aléatoires

alt_timestamp_start(); //démarrer le timer

Max1=tab[0];
for(i=0;i<n;i++){
if(tab[i]>Max1)
Max1=tab[i];
}
time1=alt_timestamp(); //arrêter le timer
printf("le Max est :%d\n",Max1);
printf("le temps de calcule du max avant tri est:%d\n", time1);
}
Programme 5 : tableau non trié (valeur max et temps d’execution).

9
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

b. Valeur maximale d’un tableau trié :

La sous fonction est donnée par le programme 6 :

void Tableau_tri(int tab[], int n) {

int permut,var,Max2,time2,i;

permut = 1;

while (permut == 1) {

permut = 0;

for (i=0; i<n-1; i++){

if (tab[i] > tab[i+1]){

var = tab[i];

tab[i] = tab[i+1];
Programme 6 : tableau trié (valeur max et temps d’execution).

c. Calcule de la racine carrée :

La sous fonction est donnée par le programme 7 :

void racine_carre(int tab[],int n){

int i,j,N=16;

int x;

unsigned int z,v;

for(i=0;i<n;i++){

x=tab[i];

z=0;

v= 1 << 30;

for(j=N-1;j>=0;j--){
Programme 7 : calcul de la racine carré.

d. Résultats est interprétations :

10
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

4. Utilisation d’instructions spécifiques :

a. Valeur maximale d’un tableau non trié:

b. Valeur maximale d’un tableau trié :

c. Calcule de la racine carrée :

5. Utilisation des interruptions :

III. conclusion :
Le but de ce TP était d’évaluer la qualité du bus GPIB à contrôler les différents
instruments connectés au bus, en étudiant bien sur la caractéristique d’un filtre passe bande.

11
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Afin de tracer la caractéristique du filtre, on a essayé durant ce TP de calculer, par

programmation, la tension à la sortie du filtre pour différents valeurs de fréquence. En fin
pour tracer la tension de sortie en fonction de la fréquence on a utilisé l’outil Matlab, et
l’allure obtenu correspond plus au mois à celle d’un filtre passe bande

On a trouvé ce TP très intéressant, car il nous à permis d’une part de mettre en œuvre ce
qu’on a étudié durant les séances de cours, et d’autre par de se familiariser avec la
programmation et le contrôle des différents instruments connecté au bus GPIB, en utilisant un
langage de haut niveau.

IV. liste des figures :

Figure II.1 schéma électronique d’un filtre passe bande………………………………………2

Figure III.1 : Interconnexion des différents instruments via le bus GPIB……………………..3

12
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Figure III.2 : Les descripteurs du multimètre et du GBF sur le BUS GPIB…………………...4

Figure III.3 : la fonction de transfert du filtre étudié…………………………………………..8

V. Annexe:
Cette annexe présent une description des différentes instructions de langage C utiliser
dans ce TP.

1. La fonction ibwrt:

La fonction “ibwrt“ envoi une commande à un instrument connecté sur le bus

GPIB, donc il permet de commander l’instrument d’une manière logiciel.

Après l’exécution du programme nous avons constaté que le bus ne donne pas la main à
l’utilisateur de changer les valeurs de l’instrument.

 Syntaxe :

 Exemples:

a- ibwrt(gene,"*cls",4);

Dans ce TP, cette instruction permet d’initialiser le générateur en envoyant la commande

« *cls » qui est sur 4 octets.

b- ibwrt(gene,"freq 18 KHZ",11);

Cette instruction permet de fixer la fréquence du générateur à 18 KHz, la commande envoyée

est sur 11 octets.

c- ibwrt(gene,"volt 4V",7);

Cette instruction permet de fixer la tension du générateur à 4V, la commande est sur 7 octets.

d- ibwrt(gene,buff2,11);

Dans le paragraphe III-2.3.b, on a utilisé une boucle For pour varier la fréquence du
générateur de 0 à 50. Dans chaque itération la valeur de la fréquence est stockée dans un
deuxième buffer en utilisant l’instruction :

sprintf(buff2,"freq %d KHZ",i);

13
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

Par la suite la fonction «ibwrt » envoi au générateur la valeur stockée dans buff2.

Notons que la valeur 11 correspond à la taille de l’expression "freq %d KHZ".

e- ibwrt(multi,"R0V1",4);

Cette instruction envoie au multimètre la commande R0V1, cette commande est sur 4 octets et
elle permet d’une part de faire un réglage automatique de gamme du multimètre (le message
R0), et d’autre part d’activer un cycle de mesure rapide (le message V1).

f- ibwrt(multi,"X1",2);

La fonction «ibwrt» envoie au multimètre la commande X1, qui est sur 2 octets, pour qu’il
face une seule mesure de tension.

g- ibwrt(multi,"?",1);

De même La fonction «ibwrt» envoie la commande « ? », pour commander le multimètre

de telle sorte à effectuer des mesure en suivant l’horloge interne de la carte GPIB.

h- ibwrt(multi,"R0S1T1F2",8);

Dans cet exemple la fonction «ibwrt» envoie au multimètre le message "R0S1T1F2"ce

dernier est composé de 4 commandes sur 8 octets :

 R0 : pour faire un réglage automatique de gamme.

 S1 : permet de choisir un taux de lecture moyen et une résolution digitale de 6½.
 T1 : permet de choisir l’horloge externe de la carte et d’activé le délai automatique et
aussi le Rear panel trigger.
 F2 : permet de choisir le voltage VAC variable en entrée du filtre. Pour VDC il faut
mettre F1.

2. La fonction ibrd:

La fonction «ibrd » permet de lire les données en provenance de l’instrument et les stocker
dans un buffer.

 Syntaxe :

14
 Mise en œuvre d'un processeur embarqué processeur NIOSII de Altera

 Exemples:

ibrd(multi,buff,18);

Rappelons que l’objectif de ce TP est de calculer la tension en sortie du filtre afin de tracer ca
fonction de transfert, cette tension est donnée par le multimètre.

Donc dans cet exemple, la fonction « ibrd » permet de stocker la valeur calculée par le
multimètre, dans un buffer de 18 octets.

Pour afficher la valeur de la tension obtenue on utilise l’instruction suivante :

printf("results: %s \n",buff);

15