Vous êtes sur la page 1sur 19

TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

FPGA ET GESTION DES HORLOGES


MODULE ALTERA DE2-115

Objectif : Au cours de ce TP, nous allons étudier la gestion des horloges disponibles sur la carte
électronique embarquant un FPGA de la société ALTERA DE2-115.

I. PRESENTATION DU PROJET

1. Chronomètre
Nous voulons réaliser un projet qui permet de réaliser un chronomètre :

Heures Minutes RAZ


10ème et 100èmes Start / Stop
de secondes

KEY[0] : Start / Stop HEX[2] : 100ème de secondes HEX[4], HEX[5] : Minutes


KEY[3] : RAZ HEX[3] : 10ème de secondes HEX[6], HEX[7] : Heures

2. Présentation de la fonction PLL (Phase Lock Loops)


Pour cela, il est nécessaire de mettre en œuvre une base de temps (horloge) : C’est la fonction PLL
(Phase Lock Loops). Elle permet, à
partir de l’oscillateur de 50 MHz
placé sur la carte DE2-115, d’extraire
une horloge de fréquence de son
choix et très précise.

LYCEE LA FAYETTE 1/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Comme on peut le voir à la page 38 du manuel, la carte DE2-115 délivre 3 horloges de 50 MHz au
circuit FPGA. Nous pourrons donc par exemple utiliser l’horloge CLK_50 pour notre base de temps.

II. DESIGN DU PROJET – GESTION DU COMPTAGE


1. Réalisation de la base de temps principale

Créer un nouveau projet en utilisant le Projet Wizard avec le logiciel Quartus II que vous nommerez
TP_DE115_2. Ajoutez-y un fichier de type Block Diagram /Schématic.

Depuis votre schéma, ajouter un nouveau symbole (clic droit > Insert > Symbol …). Cliquer ensuite sur
« MegaWizard Plugin Manager » afin d’utiliser les fonctions disponibles avec le logiciel Quartus II :

Les fonctions disponibles dans le « MegaWizard


Plugin Manager » sont des fonctions gratuites (ou
payantes) fournies par Altéra dans son logiciel
Quartus II. Il en existe des plus ou moins
sophistiquées (traitement du signal, des images, du
son, …)

Dans la fenêtre qui s’ouvre, nous avons la possibilité


de créer, d’éditer ou de copier ces fonctions. Nous
allons en créer une nouvelle à partir d’une
préexistante.

Sélectionner ensuite la fonction « ALTPLL » puis


la famille FPGA « Cyclone IV E », et le type de
langage VHDL. Donner également le nom « pll »
au fichier VHDL qui va être créé.

La fonction ALTPLL va nous permette de créer


une horloge de notre choix.

LYCEE LA FAYETTE 2/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Une première fenêtre de configuration de la fonction PLL apparaît. Elle nous permet de préciser la
fréquence utilisée par le FPGA.

Question : Quelle est la fréquence du quartz présent sur la carte DE2-115 qui sert de référence à la
PLL ?

Compléter les informations en précisant la fréquence adéquate.

L’information « device speed grade » donne la


performance en vitesse du circuit FPGA utilisé. Ici, nous
utilisons un circuit EP4CE115F29C7 (soit de grade 7).

Cliquer sur « Suivant » afin de valider les informations.

La fenêtre suivante nous permet, si nous le


souhaitons, d’ajouter des fonctionnalités de
remise à zéro synchrone de la PLL (broche
« areset »). Sélectionner uniquement cette
option et cliquer sur « Suivant ».

Cliquer ensuite quatre fois sur suivant afin de


laisser les autres paramètres par défaut.

Vous arrivez sur la fenêtre nous permettant de


choisir notre fréquence de sortie.

LYCEE LA FAYETTE 3/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Question : Parmi toutes les horloges nécessaires à la réalisation du chronomètre, laquelle aura la
fréquence la plus élevée (c’est-à-dire celle qui « battra » le rythme le plus rapidement) ?

Le signal qui aura la fréquence la plus élevée sera celui qui commande : (cocher la bonne réponse)
□ Les heures □ Les minutes □ Les secondes
□ Les 1/100ème de secondes □ Les 1/10ème de secondes

Question : Sachant que nous souhaitons avoir une période maximale de 1/100ème de secondes,
calculer la valeur de la période (en ns, 1 ns = 10-9 s) qu’il faut entrer :

1 𝑠𝑒𝑐𝑜𝑛𝑑𝑒
1/100ème de seconde = 100
= ……….. s = …………. 10-3 s = ……….10-6 s = ………. 10-9 s

Question : Lorsque vous essayez d’entrer cette valeur dans le logiciel, pour quelle raison celui-ci ne
veut pas la prendre en compte ?

Paramétrer la PLL avec une fréquence de 10 KHz (0.01 MHz) et appuyer sur le bouton « Finish »
deux fois.

Si une fenêtre vous demande si vous souhaitez ajouter


automatiquement les fichiers créés par le « MegaFunction
Wizard », cliquer sur « OUI ».

Placer ensuite le composant sur votre schéma.

Le composant possède deux entrées et une sortie :


. L’entrée « inclk0 » devra être reliée à l’horloge de 50Mhz de
la carte DE2-115 ;
. L’entrée « areset » permet de faire une remise à zéro de
l’horloge ;
. La sortie « c0 » est l’horloge de 10 KHz.

Ajouter sur votre schéma une broche d’entrée (primitive de type input) que vous relierez à la broche
« inclk0 » de la PLL. Editer son nom et la nommer
« CLK ». Faire de même en ajoutant une broche
d’entrée sur l’entrée « areset » de la PLL que vous
nommerez « RESET ».

LYCEE LA FAYETTE 4/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

2. Réalisation de la base de temps pour les 1/100ème de secondes

La fréquence du signal « c0 » étant de 10 KHz, nous allons utiliser un composant permettant de


diviser la fréquence de ce signal afin d’obtenir la période de 1/100ème de secondes voulue. Ce
composant est une fonction logique de l’électronique : Le compteur.

Question : Nous souhaitons obtenir une période de signal de 1/100ème de secondes. A quelle
fréquence correspond cette période ?

1
T= avec T : Période (en s) ; f : Fréquence (en Hz)
𝑓

1
f= …………… = ………. Hz

Question : Sachant que la fréquence de la broche « c0 » est de 10 KHz, par quelle valeur doit-on la
diviser afin d’obtenir le signal de 1/100ème de secondes ?

𝐹𝑟é𝑞𝑢𝑒𝑛𝑐𝑒 𝑑𝑢 𝑠𝑖𝑔𝑛𝑎𝑙 𝑐0 ………………….


Valeur de la division = 𝐹𝑟é𝑞𝑢𝑒𝑛𝑐𝑒 𝑞𝑢𝑒 𝑙′ 𝑜𝑛 𝑠𝑜𝑢ℎ𝑎𝑖𝑡𝑒 𝑜𝑏𝑡𝑒𝑛𝑖𝑟 = …………………. = ………………

Question : Combien de bits faut-il pour coder cette valeur de division ?

Il faut 1 bit pour aller de 0 à 1 ;


Il faut 2 bits pour aller de 0 à 4 ;
Il faut 3 bits pour aller de 0 à 8 ;
……
Il faut n bits pour aller de 0 à 2n ;

Il faudra donc ………….. bits pour coder la valeur de la division

Créer un nouveau composant avec le « MegaWizard


Function » de type LPM_COUNTER (librairie
Arithmetics) au format VHDL, que vous nommerez
« counter ».

Renseigner ensuite le nombre de bits utiles que vous


souhaitez et choisir l’option de comptage vers le haut
(up counter) :

LYCEE LA FAYETTE 5/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Dans la fenêtre suivante, indiquer la valeur par laquelle vous souhaitez diviser le signal d’entrée :

Le compteur va compter « modulo 100 », c’est-à-dire


s’arrêter à 100 et recommencer. Ainsi, le signal
d’horloge sera divisé par 100.

Si nous avions laissé « plain binary », il aurait compté


jusqu’à 27 = 128. Le signal aurait donc été divisé par
128.

Dans la fenêtre suivante, activer la broche de


remise à zéro asynchrone, ce qui permettra de
remettre le compteur à 0. Pour cela, cocher la
case « Clear » de la partie « Asynchronous input ».

Laisser les autres options par défaut et cliquer sur


« Finish ».

Relier la sortie de la pll (broche « c0 ») à l’entrée du compteur (broche « clock »). Ajouter ensuite un
fil sur la sortie du diviseur. Editer les propriétés du fil (clic droit > properties) afin de lui donner le
nom CLK_100[6..0].

La sortie du compteur q[6..0] est ce qu’on appelle un bus. C’est un ensemble comprenant 7 fils (Q0,
Q1, Q2, …, Q6). Chaque fil possède un coefficient de division spécifique. Le fil sur lequel le signal est
divisé par 100 est le fil Q6. Le signal permettant de commander les 1/100ème de secondes est donc le
signal CLK_100[6], qui appartient au bus CLK_100[6..0].

Afin d’extraire le signal dédié aux 1/100ème de secondes, ajouter un fil fin sur le bus CLK_100[6] et
nommer ce fil « CLK_100[6] » :

La base de temps pour les 1/100ème de secondes est maintenant créée (signal CLK_100[6]).

LYCEE LA FAYETTE 6/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

3. Comptage des 1/100ème de secondes

Le signal d’horloge pour les 1/100ème de secondes va être utilisé pour compter et afficher les 1/100ème
de secondes sur l’afficheur adéquate. Il faut afficher, alternativement, les chiffres 0,1,2,…,7,8,9 et
recommencer à 0.

Pour cela nous allons créer un compteur modulo 10 (car il y a 10 valeurs de 0 à 9).

Question : Combien de bits faut-il pour coder la valeur 9 ?

Il faut 1 bit pour aller de 0 à 1 ;


Il faut 2 bits pour aller de 0 à 4 ;
Il faut 3 bits pour aller de 0 à 8 ;
……
Il faut n bits pour aller de 0 à 2n ;

Il faudra donc ………….. bits pour coder la valeur de la division

Ajouter sur votre schéma un nouveau compteur modulo 10, que vous nommerez counter2, et
ajoutez-lui (en plus de la fonction de remise à zéro asynchrone), la fonction « Carry-out » :

La fonction « Carry-out » permet d’avoir un


signal de sortie indiquant que le compteur a
terminé de compter jusqu’à 9.

Ce signal sera utile pour synchroniser le


compteur qui gérera les 1/10ème de secondes.

Relier ensuite la sortie CLK_100[6] à l’entrée du compteur n°2 :

LYCEE LA FAYETTE 7/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

En sortie du compteur n°2, nous avons maintenant une valeur, variant de 0 à 9, au rythme de
1/100ème de secondes. Il reste à afficher cette valeur sur l’afficheur adéquate.

4. Affichage des 1/100ème de secondes

La valeur en sortie du compteur n°2 est une valeur binaire allant de 0 à 9. Cette valeur
doit être convertie afin de pouvoir afficher les informations sur l’afficheur 7 segments.

Pour cela, on utilisera le fichier VHDL créé lors du précédent TP.

Valeur à afficher
Segments 0 1 2 3 4 5 6 7 8 9
0 0 1 0 0 1 0 1 0 0 0
1 0 0 0 0 0 1 1 0 0 0
2 0 0 1 0 0 0 0 0 0 0
3 0 1 0 0 1 0 0 1 0 1
4 0 1 0 1 1 1 0 1 0 1
5 0 1 1 1 0 0 0 1 0 0
6 1 1 0 0 0 0 0 0 1 0

A partir de ce tableau, on peut créer un algorithme qui permettra d’afficher les bons segments en
fonction de la valeur à afficher :

Valeur à afficher : Allumage des


AFF0[3..0] bons segments

Pour cela, on utilise le fichier VHDL créé lors du précédent TP :

LYCEE LA FAYETTE 8/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Afin de créer un nouveau programme VHDL, cliquer sur « File > New » et choisir « VHDL File » :

Un fichier vide apparaît à l’écran. Sauvegarder le fichier sous le nom


« Decodeur7Segments » :

Dans l’éditeur, entrer le programme VHDL donné à la page précédente et sauvegarder.

Le programme VHDL étant entré dans le logiciel, créer un composant à partir de celui-ci en procédant
de la manière suivante : Aller dans « File > Create / Update > Create Symbol File from Current File ».

Pour ajouter le décodeur 7 segments créé, faire un clic droit sur le schéma puis « Insert > Symbol… ».
Le composant apparaît sur la gauche ; il suffit de l’insérer sur le schéma :

Le bus VALEUR[3..0] contient à la valeur à


afficher.

Le bus SEGMENTS[6..0] contient les états


logiques nécessaires à appliquer sur chaque
segment de l’afficheur pour afficher la valeur
présente sur le bus VALEUR[3..0].

Relier le décodeur 7 segments sur votre schéma de la manière suivante :

Ajouter enfin les broches correspondants à l’afficheur sur lequel on va afficher les 1/100ème de
secondes :

LYCEE LA FAYETTE 9/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

5. Assignation des broches


Nous allons tester notre première étape à savoir le comptage des 1/100ème de secondes. Il nous reste
à attribuer les broches du FPGA à notre schéma.

Question : En vous aidant du manuel en page 37, indiquer le numéro des broches du circuit FPGA
connectés au segments 0 à 6 de l’afficheur 2 (HEX2[0] à HEX2[6]) de la carte DE2-115.

FPGA Pin No. (du segment HEX2[0]) = …………………………..


FPGA Pin No. (du segment HEX2[1]) = …………………………..
FPGA Pin No. (du segment HEX2[2]) = …………………………..
FPGA Pin No. (du segment HEX2[3]) = …………………………..
FPGA Pin No. (du segment HEX2[4]) = …………………………..
FPGA Pin No. (du segment HEX2[5]) = …………………………..
FPGA Pin No. (du segment HEX2[6]) = …………………………..

Question : En vous aidant du manuel en page 38, indiquer le nom de la broche correspondant au
signal CLOCK_50.

FPGA Pin No. (CLOCK_50) = …………………..

Question : On veut que le RESET soit obtenu par appui sur le bouton poussoir KEY[3]. A l’aide du
manuel en page 33, indiquer le nom de la broche où est relié le signal identifiant un appui sur le
bouton poussoir KEY[3].

FPGA Pin No. (KEY3) = …………………..

Effectuer la synthèse du projet (Processing > Start > Analysis & Elaboration) puis assigner les broches
en allant dans la fonction « Assigment > Pin Planner ». Compiler et programmer le FPGA puis vérifier
que l’afficheur n°2 affiche des chiffres qui semblent défiler.

 Appeler le professeur pour lui montrer les résultats


Question : Que se passe-t-il lorsque vous appuyez sur le bouton poussoir KEY3 destiné à remettre le
chronomètre à zéro ?

Question : La fonction RESET fonctionne-t-elle comme elle le devrait ? Expliquer ce qui est différent
de ce qui devrait se passer.

LYCEE LA FAYETTE 10/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Question : Quel composant peut-on utiliser pour inverser le signal RESET du bouton poussoir KEY[3]
afin que la fonction Remise à Zéro soit correctement réalisée ?

Ajouter ce composant et tester de nouveau le projet afin de vérifier que la fonction RESET
fonctionne :

Question : La fonction RESET fonctionne-t-elle comme elle le devrait ? Expliquer ce qui est différent
de ce qui devrait se passer.

Question : A quelles broches des composants « Counter1 » et « Counter2 » peut-on relier la sortie de
l’inverseur du RESET afin que les compteurs se réinitialisent à zéro en cas d’appui sur le bouton
poussoir KEY3 ?

Effectuer cette modification et tester le projet.

6. Affichage des 1/10ème de secondes


L’affichage des 1/10ème de secondes doit s’incrémenter à chaque fois que le compteur des 1/100ème
de seconde repasse à la valeur 0 après avoir atteint la valeur 9. Nous allons donc utiliser un compteur
modulo 10 pour gérer l’affichage des 1/10ème de secondes. Son comptage sera synchronisé avec
signal « Carry Out » du compteur des 1/100ème de secondes.

Créer ce compteur nommé « counter3 » et placez-le sur votre schéma. Vous y ajouterez la fonction
« Carry-out », « Carry-in » ainsi qu’une entrée de remise à zéro asynchrone :

LYCEE LA FAYETTE 11/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Ajouter ensuite le décodeur 7 segments permettant de gérer l’afficheur numéro 3 ainsi que les
broches de sorties :

Question : En vous aidant du manuel en page 37, indiquer le numéro des broches du circuit FPGA
connectés au segments 0 à 6 de l’afficheur 2 (HEX3[0] à HEX3[6]) de la carte DE2-115.

FPGA Pin No. (du segment HEX3[0]) = …………………………..


FPGA Pin No. (du segment HEX3[1]) = …………………………..
FPGA Pin No. (du segment HEX3[2]) = …………………………..
FPGA Pin No. (du segment HEX3[3]) = …………………………..
FPGA Pin No. (du segment HEX3[4]) = …………………………..
FPGA Pin No. (du segment HEX3[5]) = …………………………..
FPGA Pin No. (du segment HEX3[6]) = …………………………..

Effectuer la synthèse du projet (Processing > Start > Analysis & Elaboration) puis assigner les broches
en allant dans la fonction « Assigment > Pin Planner ». Compiler et programmer le FPGA puis vérifier
que l’afficheur n°2 affiche les 1/100ème de secondes et l’afficheur n° 3 les 1/10ème de secondes.

7. Affichage des secondes


En procédant de la même manière que précédemment, effectuer les modifications nécessaires afin
que les secondes s’affichent sur l’afficheur n°4.

 Appeler le professeur pour lui montrer les résultats


8. Affichage des 10ènes de secondes, des minutes et des heures
Cette partie est optionnelle.

LYCEE LA FAYETTE 12/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

III. REALISATION DU PROJET – GESTION DU START / STOP


Notre compteur démarre immédiatement une fois alimenté. Il faut donc faire en sorte de placer un
bouton poussoir permettant de le lancer et de l’arrêter. Un premier appui sur le bouton START/STOP
doit arrêter le chronomètre, un second appui doit le relancer, etc…

Question : En vous aidant du manuel en page 32 et 33, indiquer l’état logique du signal KEY0 présent
sur l’entrée du FPGA (signal START/STOP) lorsqu’il est appuyé et relâché.

Si le bouton poussoir KEY0 est appuyé, alors START/STOP = ……….


Si le bouton poussoir KEY0 est relâché, alors START/STOP = ……….

On peut alors représenter le mode du chronomètre sous forme de chronogramme :


START/STOP
Relâché

Appuyé

MODE DU CHRONOMETRE

ARRET MARCHE ARRET

On remarque que le mode du chronomètre change d’état à chaque front descendant du signal issu
du bouton START/STOP.

Pour réaliser cette fonction, modifier le schéma comme indiqué ci-dessous.

Question : Réaliser la compilation du projet et tester la solution sur votre carte. Quels sont les
problèmes que vous remarquez ?

LYCEE LA FAYETTE 13/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Les problèmes que vous rencontrez sont dus au fait que lors de l’appui sur le bouton KEY0, il se
produit des « rebonds » (le bouton rebondi pendant quelques millisecondes). Le signal ainsi généré
n’est pas net mais oscille entre plusieurs valeurs :

Signal idéal Appui Relâchement


START/STOP

Signal réel Appui Relâchement


START/STOP

10 ms 10 ms

Pour corriger ce problème, nous allons créer un nouveau composant appelé « AntiRebond ». Pour
cela, créer un nouveau composant en allant dans « File > New > Block Diagram / Schematic File ».
Dans l’éditeur, entrer le schéma suivant :

- Les composants inst1 et inst2 sont des bascules D, vous les trouverez dans « Insert > Symbol
> Primitive > Storage > DFF » ;
- Le composant inst42 est une porte logique XNOR, il se trouve dans « Insert > Symbol >
Primitive > Logic > XNOR » ;
- Le composant inst8 (à droite) est une bascule D avec entrée de validation (ENA = ENABLE), il
se trouve dans « Insert > Symbol > Primitive > Storage > DFFE » ;
- Le composant « CTRANTIREBOND » est un compteur 19 bits, avec sortie carry out et entrée
de validation de comptage Count Enable et entrée synchrone de mise à zéro (Synchronous
Input Clear).

Lorsque le schéma est créé, sauvegarder le fichier puis créer un composant en allant dans le menu
« File > Create / Update > Create Symbol File From current File ». Le composant créé sera
automatiquement ajouté à votre projet.

LYCEE LA FAYETTE 14/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

Ajouter maintenant le composant créé précédemment « AntiRebond » et placez-le sur votre


schéma :

Compiler le projet et vérifier le bon fonctionnement.

 Appeler le professeur pour lui montrer les résultats

********************** written by
Bilalmalikuet@gmail.com**********************************
sbit LCD_D7 at RB2_bit;
sbit LCD_D6 at RB3_bit;
sbit LCD_D5 at RB4_bit;
sbit LCD_D4 at RB5_bit;
sbit LCD_EN at RB6_bit;
sbit LCD_RS at RB7_bit;

sbit LCD_D7_Direction at TRISB2_bit;


sbit LCD_D6_Direction at TRISB3_bit;
sbit LCD_D5_Direction at TRISB4_bit;
sbit LCD_D4_Direction at TRISB5_bit;
sbit LCD_EN_Direction at TRISB6_bit;
sbit LCD_RS_Direction at TRISB7_bit;
//************************temperature variables****************
int temp;
char temper[7];
//**************************************************************

void READ_temp(void)
{
temp = ADC_Read(0);
temp = temp * 5/1023;
temp = temp * 100;

LYCEE LA FAYETTE 15/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

void data_converstion(void)
{

inttostr(temp,temper);
}
void display1(void)
{
lcd_out(1,1,"TEMPERATURE=");
lcd_out(1,13, Ltrim(temper));
Lcd_Chr_Cp(0xdf);
Lcd_Chr_Cp('C');
Lcd_Chr_Cp(' ');

void main()
{
ADC_Init();
Lcd_Init(); // Initialize LCD
Lcd_Cmd(_LCD_CLEAR); // Clear display
lcd_cmd(_LCD_CURSOR_OFF);
lcd_out(1,4,"DIGITAL TEMPERATURE");
lcd_out(2,6,"SENSOR");
delay_ms(1000);
Lcd_Cmd(_LCD_CLEAR); // Clear display

while(1)
{

READ_temp();
data_converstion();
display1();
}
}

LYCEE LA FAYETTE 16/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

//************************* LCD module


connections****************************************
//********************** written by
Bilalmalikuet@gmail.com**********************************
sbit LCD_D7 at RB2_bit;
sbit LCD_D6 at RB3_bit;
sbit LCD_D5 at RB4_bit;
sbit LCD_D4 at RB5_bit;
sbit LCD_EN at RB6_bit;
sbit LCD_RS at RB7_bit;

sbit LCD_D7_Direction at TRISB2_bit;


sbit LCD_D6_Direction at TRISB3_bit;
sbit LCD_D5_Direction at TRISB4_bit;
sbit LCD_D4_Direction at TRISB5_bit;
sbit LCD_EN_Direction at TRISB6_bit;
sbit LCD_RS_Direction at TRISB7_bit;
//************************temperature variables****************
int temp;
char temper[7];
//**************************************************************

void READ_temp(void)
{
temp = ADC_Read(0);
temp = temp *
5/1023;
temp = temp * 100;

}
void data_converstion(void)
{

inttostr(temp,temper);

LYCEE LA FAYETTE 17/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

}
void display1(void)
{
lcd_out(1,1,"TEMPERATURE=");
lcd_out(1,13, Ltrim(temper));
Lcd_Chr_Cp(0xdf);
Lcd_Chr_Cp('C');
Lcd_Chr_Cp(' ');

void main()
{
ADC_Init();
Lcd_Init(); // Initialize LCD
Lcd_Cmd(_LCD_CLEAR); // Clear display
lcd_cmd(_LCD_CURSOR_OFF);
lcd_out(1,4,"DIGITAL TEMPERATURE");
lcd_out(2,6,"SENSOR");
delay_ms(1000);
Lcd_Cmd(_LCD_CLEAR); // Clear display

while(1)
{

READ_temp();
data_converstion();
display1();
}
}

/*c1++; //increment c1 after getting first data


if(c1==1) //this will be entered since c1 now incrementd by 1
{
data_1=save_data; //so get fisrt byte
}
if(c1==2) //this will be entered because c1 now incremented by 1 again to be 2
{
done=1; //set done flag
data_2=save_data; //get second byte
if(done==1) //if done is set
{

LYCEE LA FAYETTE 18/19


TP : FPGA ET GESTION DES HORLOGES – MODULE DE2-115

value=data_1; //put the first byte in value


value<<=8;
value+=data_2; //put the second byte in value, now value combines the two bytes
byteTostr(value, txt); //convert value to string
lcd_out(1,1, txt); //display value on lcd

done=0; //reset below variables for next usage


c1=0;
data_1=0;
data_2=0;
value=0;
}
}*/

/*unsigned value=0;
unsigned short data_1=0, data_2=0, c1=0, done=0;*/

LYCEE LA FAYETTE 19/19