Laboratoires Prog

Laboratoires
Numéro du cours Pondération Unités

247-236 2-4-2 2.66
Titre du cours Département
H 21 Lier l'architecture et la
programmation d'un
microcontrôleur
TGE
Programme Enseignants ou enseignantes

Technologie de systèmes ordinés Francois Bouchard
INDEX
LABORATOIRE #1 Première fonction et simulation avec Keil .................................................................3

LABORATOIRE #2 Limite des variables, le Cast, la boucle FOR .............................................................9
LABORATOIRE #3 Délai avec l'utilisation des Timers ...........................................................................13
LABORATOIRE #4 Interrupteurs, Anti-rebond, Front et Dimmer avec Timer .......................................17
LABORATOIRE #5 Les Tableaux, Jeu de DÉ et Cohérence cardiaque ...................................................21
LABORATOIRE #6 Clavier matrice, décodeur de clavier et "Switch case" ............................................25
LABORATOIRE #7 Mémoires, Latch, Décodeurs et les Pointeurs..........................................................32
LABORATOIRE #8 Test de la Mémoires Externes et pointeurs ..............................................................40
LABORATOIRE #9 Convertisseur ADC, Historique et Mémoires Externes ...........................................44
P.C. / D.C. / F.B. Cours 247-236 Programme de TSO

06-04-2020 2 Laboratoires236.docx
LABORATOIRE #1 Première fonction et simulation avec Keil
But : Comprendre le principe de fonctionnement, les possibilités et les limites d’un simulateur et utiliser
le celui de l’environnement de travail µVision de Keil.
Matériel :
 PC avec l’environnement de travail Keil.
 Carte Dallas.
 Module BARGRAPH pour Dallas (magasin).
1 Étape: Compilation
Créez un répertoire de travail et copiez-y le fichier "Bonjour.c" présent sur le réseau.
Utiliser l’environnement uVision pour le compiler. Voir Annexe 1 (page 7).
2 Étape: Simulation
Une fois le programme "Bonjour.c" compilés, vous allez le simuler. Dans l’environnement de uVision,
cliquer sur le bouton (ou dans menu Debug -> Start/Stop Debug Session ou encore Ctrl+F5).
L’environnement devrait se modifier légèrement (observez la barre d’outils du bas).
Tableau des principales fonctions de simulation (dépannage)

Icône Raccourci Description
Ctrl+F5 Démarrage ou fin d’une session de dépannage.
--- Installe ou enlève un point d’arrêt (Breakpoint) à la ligne où se trouve le
curseur.
F11 Exécution d’une ligne de code seulement (Step).
F10 Exécution d’une ligne de code sans visualisation du code contenu dans une
fonction (Step Over).
Ctrl+F10 Exécute le code et arrête à la ligne correspondant au curseur. Point d’arrêt
temporaire (Run To Cursor Line).
Ctrl+F11 Finit l’exécution de la fonction en cours de dépannage en abandonnant
temporairement le mode pas à pas (Step Out).
--- Indique où est rendu l’exécution du programme en cours de dépannage.
--- Cette fonction a le même effet que de faire un reset au CPU.
F5 Démarre le programme (Run) et arrête si atteint une des conditions suivante:
1. L’atteinte d’un point d’arrêt.
2. L’atteinte d’un point d’arrêt temporaire.
3. La fin du programme.
Nous allons ouvrir une nouvelle fenêtre : menu View  Serial Window  UART #1.
Cette fenêtre nous permettra de voir la communication série (déplacée là au besoin).
Simulation : Cliquer sur le bouton Reset CPU , pour reseter les éléments du programme, puis
cliquer sur le bouton Run pour faire rouler le programme. Observez la fenêtre UART #1.
Q1 : Que signifie UART ?
P.C. / D.C. / F.B. Laboratoire 1 Cours 247-236 Programme de TSO

3 Étape: Pas à pas
Vous pouvez aussi utiliser le bouton Step pour exécuter le programme pas à pas. Faite Halt pour
arrêter le programme en cours de route et Reset pour pouvoir recommencer au début.
Avec le bouton Step que vous cliquez plusieurs fois observez le déroulement du programme.
Q2 : Pourquoi après avoir exécuté le "printf", la dernière lettre ne s’est pas afficher ?
Rép: Le simulateur réagit comme dans la vrai vie, ainsi après avoir transmis un caractère, ce caractère n'est pas
transmis instantanément mais après un certain délai qui correspond à la vitesse de transmission (baud rate)
fois le nombre de bits à transmettre (8 data + 1 start + 1 stop). C’est pour cette raison qu’il faut attendre.
Faites plusieurs Step into et vous allez finir par voir le !.
4 Étape: Les Fonctions

Retournez dans l’environnement de compilation : cliquer sur le bouton Start/Stop Debug et
modifiez votre programme pour que les instructions d’initialisation du port série se retrouve dans une
fonction. Ça devrait ressembler au programme suivant :
void vInitPortSerie(void); // Predeclaration de la fonction vInitPortSerie.
void main(void)
{
vInitPortSerie(); // Initialise le port série a 57600 bds, N, 8, 1.
printf("\nBonjour!"); // Affiche le message 'Bonjour' sur le port serie.
while(1)
{ // Attend et ne fait plus rien.
}
} // Fin du main().
// Un entête de fonction devrait se trouver ici !!!!!
void vInitPortSerie(void) // Definition de la fonction vInitPortSerie

{
SCON0 = 0x50; // Selectione mode 1, 8-bit UART avec reception.
TMOD = TMOD | 0x20; // TMOD: Timer 1, mode 2, 8-bit auto reload.
TH1 = 0xFF; // TH1: Reload value for 57600 baud @ 11.059MHz.
// 0xFA = 9600, 0xFD = 19200, 0xFE = 28800.
PCON = PCON | 0x80; // SMOD_0 = 1 (doubleur de baud).
TR1 = 1; // TR1: Part le timer 1.
TI_0 = 1; // TI a 1 pour permettre transmission du 1er caractere.
}
Compilez le et retournez dans l’environnement de simulation (bouton ) et exécutez entièrement le

programme pas à pas avec Step et une fois terminé, recommencer avec Step Over .
Q3 : Expliquez la différence entre Step et Step Over:

Rép: En simulation, lors de l'exécution d'une fonction, le Step entre dans la fonction et l'exécute instruction
par instruction. Mais lors de l'exécution d'une fonction le Step Over exécute la fonction tout d'un bloc,
sans nous présenter la démarche ligne par ligne de cette fonction.

5 Étape:
Refaite la création de projet, la compilation et la simulation, avec le programme "FlashLed.c" présent
sur le réseau (Ce programme pourra servir de Template de base pour d’autre programme). Pour la
simulation, en plus d’ouvrir la fenêtre UART #1 vous devrez aussi ouvrir la fenêtre du Port 3, dans le
menu : Peripherals  I/O-Ports  Port 3. Cette fenêtre vous permettra de visualiser ce qui ce passe sur
le port 3. Faite la simulation et notez vos commentaires.
Q4 : Que représentent les 16 cases de la fenêtre du Port 3?
P3: représente l'état du Latch interne et Pins représente l'état des broches.
On peut changer l'état des pins en cliquant sur les crochets de Pins
ou encore dans la fenêtre Commande. Pin 3.x
On écrit : >PORT3 = 0xZZ où ZZ est une valeur hexadécimale. P3.x
Note : Pour que ça fonctionne il faut que les broches soient en
entrées (Latch à 0xFF)
Sortir de la simulation et ajoutez dans votre programme, la fonction de délai suivante:

(prototype, appel et définition)
Les définitions de fonctions seront placées en ordre alphabétique (préfixe exclu).
void vDelai(unsigned int uiDelai)
{
while (uiDelai != 0)
{
uiDelai = uiDelai - 1;
}
}
Placez l'appel de la fonction "vDelai(10);", juste après "LED = !LED;" dans la boucle "while(1) ".
Testez la fonction vDelai avec la simulation (Utilisez Step, Step Over et Run).
Je vérifie la simulation ___________
6 Étape:
Remplacez l'instruction LED = !LED; par l'instruction: LED = SW2 & SW3;
Simulez et exécuter le programme.
Modifiez l’entrée Sw2 en cliquant sur le bit 2 du port 3.
Vérifiez l'état de la Led en simulation.
Je vérifie la simulation et l'exécution sur le Dallas ___________
7 Étape:
Sur le réseau, vous trouverez le programme "Etape7.c". Ce programme devrait faire un chenillard de 8
bits sur le port 1 du DS89C450, mais il y a une petite erreur de logique dans le programme. Vous devez
comprendre le programme, le commenter, créer un projet, ajouter ce qui manque pour le compiler, le
simuler, le corriger, le re-simuler et finalement, l’exécuter sur la carte Dallas avec un module de LED
que vous prendrez au magasin.
Je vérifie la simulation et le fonctionnement sur LED___________________

8 Étape (vous devez remettre le listing de cette étape) :
Créez un nouveau projet.
Écrivez, compilez et simulez le programme de jeu de dés (un seul Dé) vu en classe
(En utilisant une fonction pour changer la valeur du Dé. Notes de cours section 2.3.3).
Résumé : Si la valeur du Dé est égale à 0x0E mettre le Dé égale à 1,

Sinon : faire le test du bit 0, Si égale 1 faire : Dé décaler 1 bit vers la gauche (ou fois 2),
Sinon faire : Dé +1.
Je vérifie la simulation et l’exécution avec le Bargraph sur le Dallas ___________
9 Étape: (Bonus)
Simuler le programme de votre projet final de la session dernière (Dé ou Chronomètre).
Je vérifie la simulation ___________
Évaluation :
 Simulation de l'étape 5 (LED = !LED) : _______ / 1
 Simulation et exécution de l'étape 6 (LED = SW2 & SW3) : _______ / 1
 Fonctionnement de l'étape 7 (Chenillard) : _______ / 1
 Fonctionnement de l'étape 8 (Simulation du Dé) _______ / 2
 Listing du programme de l'étape 8 : _______ / 5
(Je corrige les entêtes, l'indentation et les commentaires).
 Fonctionnement de l'étape 9 (Bonus): _______ / 1
Total: _______ /10
Lors de la remise du rapport, vous devez remettre le listing du programme de l'étape 8 avec:
- Entête de fichier,
- Entête de fonction,
- Commentaires.
 Les caractères utilisés dans le listing doivent être de format Courier New, 10 points.
 80 caractères maximum par ligne.
 Les commentaires ne doivent pas déborder (sinon jusqu'à -2).

ANNEXE 1
Rappel de la Création d’un Projet avec Keil

Création d’un projet :
Avant d’ouvrir Keil :

Créez un répertoire de travail pour chacun de vos programmes.
Exemple. : C:\247-236\Lab1\Bonjour pour le premier programme du lab 1 et mettez y votre
fichier.c ou un template de base (Frame.c) que vous renommerez avec le même nom que le
répertoire (ici : Bonjour.c).
Ouvrir le logiciel Keil et créez un projet : menu Project  New uVision Projet…
Sélectionnez votre répertoire et entrez le même nom que votre fichier source sans extension, et faites
‘Enregistrer’
Dans la fenêtre ‘ Select Device for Target ‘Target 1’ et l’onglet CPU :

Dans la zone Search, entrez "ds89" puis sélectionnez le DS89C450 et terminez avec OK.
À la question 'Copy Start4xx.A51' to Project Folder and Add File to Project? Répondez NON
Dans la fenêtre ‘Project’, faite un clic sur le signe + devant ‘Target 1’ puis un double clic sur ‘Source
Group 1’ pour inclure votre fichier source (.C) à votre projet. Sélectionner le, faites 'Add' et 'Close'.
Refaite un double clic sur ‘Source Group 1’ pour visualiser le ou les fichiers inclus dans votre projet et
faite un double clic sur votre fichier source pour pouvoir l’éditer.
Configuration de base de la compilation :
Dans la fenêtre ‘Project’, sélectionner ‘Target 1’ puis clic-droite et Option for Target 'Target1',
sélectionnez l’onglet Output et cocher la case Create HEX File. Puis faite OK. Ceci vous permettra de
générer le fichier Intel-HEX qui sera transféré sur le microcontrôleur DS89C450.
Configuration de base de la simulation :
Dans la fenêtre ‘Project’, sélectionner ‘Target 1’ puis clic-droite et Option for Target 'Target1',
sélectionnez l’onglet Target. Dans le champ Xtal (MHz) entrez 11.0592 , terminer avec OK.
RAPPEL : Les programmes doivent être édités avec :

- police "Courier New"
- 10 points
- 80 colonnes maximums
- les tabulations doivent être remplacés par des espaces.
Il est possible de configurer l’éditeur de Keil, pour que les tabulations soit fait avec 2
espaces : en allant dans le menu Edit  Configuration ; l’onglet Editor et cocher les cinq
cases du groupe "C/C++ Files" et mettre 2 dans "Tab size" :

LABORATOIRE #2
Limite des variables, le Cast, la boucle FOR
But: Comprendre le principe et les limites des variables et des boucle for.
Continuer l’exploration du simulateur de l’environnement de travail uVision de Keil pour visualiser
des variables et calculer des temps de délais.
Matériel :
 Sonde Oscilloscope.
 Carte Dallas
1 Étape : Calcul factoriel ! (le listing est à remettre)

Vous devez écrire, créer un projet (Factoriel), compiler et simuler le programme de calcul factoriel
dont l'algorithme est à l'annexe 1. Utilisez le fichier "Frame.c" comme fichier de départ.
Vous devrez "débugger" votre programme avec la simulation. Dans la simulation vous devrez
observer l’évolution des valeurs de vos variables en exécutant le programme pas à pas.
En simulation il est possible de voir les valeurs de toutes les variables que vous utilisez. Lorsque vous
êtes dans la session debug, si la fenêtre Call Stack + Locals n'est pas visible en bas à droite, cliquez
sur le menu ‘View’ et sélectionnez « Call Stack Window » une fenêtre apparaîtra dans le coin
inférieure droit. Cette fenêtre vous permettra de voir la valeur de vos variables tout au long de votre
simulation. Les variables locales apparaissent automatiquement lorsque vous êtes dans la fonction qui
l’utilise. Pour afficher en décimal, clic droit sur le nom des variables et enlevez le crochet à
"Hexadecimal Display".
 À l'aide de la calculatrice de Windows en mode scientifique (touche n!) placez dans le tableau
plus bas, le factoriel de i pour les valeurs de 0 à 6.
 Exécutez le programme pas à pas. Prendre en note les valeurs de ucProduit pour chaque passage
dans la boucle ‘for’ avec ucChiffre = 6. (voir algo annexe 1)
Pour entrer une valeur au clavier en simulation, il faut cliquez dans la fenêtre UART #1 lors de
l'exécution du getkey( ) et peser sur la touche voulue.
i 0 1 2 3 4 5 6
i! 1
ucProduit
Q1: Expliquez d’où vient la valeur affichée de ucProduit pour i = 6 (vérifiez les valeurs en hexa).
Q2: Quelles sont les valeurs maximums (pas limité à 9) que l’on peut entrer dans la variable
‘ucChiffre’ pour avoir un résultat cohérant (utilisez la calculatrice de Windows),
si Produit était de type unsigned char: _________________
unsigned int: _________________
unsigned long: _________________
float: _________________
Voir Annexe 1 pour la valeur maximum des différents types de variables.
 Modifiez votre programme pour qu'il fonctionne avec des nombres de 0 à 9.
Je vérifie (Simulation, Exécution sur la carte Dallas et Réponses 4 pts )________________
P.C. / D.C. / F.B, Laboratoire 2 Cours 247-236 Programme de TSO

2 Étape : Fonction de délai en milliseconde
Vous devez écrire, créer un projet (FlashLed), compiler et simuler le programme qui permet de faire
clignoter une DEL (LED = !LED) à une vitesse quelconque.
Vous devrez, d'abord, créez une fonction qui fait un délai de X milliSecondes, que vous appellerez
vDelaiMs(UI). La fonction recevra le nombre de milliseconde du délai.
Cependant, au lieu d’utiliser l’instruction ‘while’ vous utiliserez l’instruction ‘for’ (le corps de la
fonction tient sur deux lignes).
Algo de la fonction avec des while (à faire avec des "for"):

uiDelaiOut = 0;
TANT QUE (uiDelaiOut < uiDelai) // Boucle de uiDelai millisecondes.
uiDelaiOut++;
uiDelaiIn = 0;
TANT QUE(uiDelaiIn < 613) // 613: Valeur pour un delai de 1 ms
uiDelaiIn++; // avec un DS89C450 a 11.0592 mHz.
FIN TANT QUE.
FIN TANT QUE.
Écrire ensuite le programme principal qui va faire clignoter une LED (P3_5) sans fin avec un délai
entre chaque clignotement en utilisant votre fonction vDelaiMs(100). Compilez votre programme,
simulez-le et exécutez-le sur la cible (votre kit Dallas).
Je vérifie (Simulation et Exécution sur le Dallas 2 pts) ______________
3 Étape : Mesure du temps d’exécution, 'Step over', 'Breakpoint' et 'Run'
En simulation, évaluer le temps de la fonction délai de l’étape 2. Pour évaluer le temps d’une partie de
code, il est important d’entrer la vitesse du cristal qui sera relié à votre microcontrôleur. Pour faire
cette configuration, dans la fenêtre ‘Project’, sélectionner ‘Target 1’ puis clic-droite et ‘Options for
Target 'Target 1' ’, sélectionnez l’onglet Target. Dans le champ Xtal entrez 11.0592 (valeur en MHz),
terminer avec Ok.
Par la suite après avoir compilé votre programme, allez dans la

session de débogage. Simulez votre programme et observez la
fenêtre à gauche de votre programme, au bas de cette fenêtre se
trouve deux valeurs qui s’incrémente à chaque fois que vous faites
un pas. Ces valeurs ‘states‘ et ‘sec‘ représentent respectivement le
nombre de cycle machine fait depuis le début du programme et le
temps écoulé en seconde, selon la fréquence du cristal enregistré
précédemment.

Il est donc possible de noter le temps (valeur de sec) avant d’exécuter une fonction, d’exécuter la
fonction avec le bouton Step over , de noter la nouvelle valeur de temps et de faire la différence
entre ces deux valeurs pour avoir le temps d’exécution de la fonction.
Pour réaliser facilement le calcul du temps d'exécution d'une fonction, placer un 'Breakpoint' sur la
ligne qui appelle la fonction. Après être entré en mode Debug cliquez sur Run
Ceci devrait vous placer à la ligne qui va appeler la fonction. Prenez le temps indiqué par 'sec', et
cliquer sur Step over . Vous avez maintenant le nouveau temps disponible dans 'sec'. Si vous
désirer faire une autre lecture, vous faites à nouveau Run et Step over.
Avec des boucles "for" et la valeur 613 :

Mesurez le temps (oscilloscope) de votre fonction de délai et
Calculez le temps (en simulation) pour une valeur de vDelaiMs(100):
vDélaiMs (100) : Mesuré (ms) (oscil) = ______________

Calculé (ms) (simul) = ______________
Q3: Trouver la bonne valeur à mettre dans votre fonction pour que le paramètre d’entré donne
exactement un délai en ms (ex. : vDelaiMs(100), doit donner un délai de 100 ms) :
Valeur de la boucle ? = __________
Calculez à l’aide du simulateur (4 chiffres après le point) et mesurez à l’oscilloscope (1 ou 2 chiffres

après le point) quelques valeurs de délai (il faut recompiler entre chaque).
vDelaiMs(X) X 10 25 100 200
Simulé (ms)
Délai(ms)
Mesuré (ms)
Vous pouvez ajouter votre fonction de délai dans votre fichier Frame.c.
Je vérifie _(Simulation et Réponses 3 pts)_____________
Évaluation :
 Fonctionnement de l'étape 1 (Factoriel 0 à 9) : _______ / 4
 Fonctionnement de l'étape 2 (FlashLed) : _______ / 2
 Fonctionnement de l'étape 3 (Temps exécution) : _______ / 3
(Je corrige l'entête, les indentations et les commentaires).
Total: _______ /14
Lors de la remise du rapport vous devez remettre le listing du programme de l'étape 1 (pas page titre).
Les caractères utilisés dans le listing doivent être de format Courier New, 10 points, 80 car max /ligne
et les commentaires ne doivent pas déborder (sinon jusqu'à -2).

ANNEXE 1
Algorithme de l’Étape 1:
DEBUT // Calcul le Factoriel !
vInitPortSerie( ). // Initialise le port serie a 57600 Bauds.
ECRIRE "\nProgramme du calcul Factoriel !\n".
TANT QUE(VRAI)
ECRIRE "\nEntrez un chiffre: ".
ucChiffre = ucLireChiffre( ).
ucProduit = 1.
POUR(i = 1; i <= ucChiffre ; i++ )
ucProduit = ucProduit * i.
FIN POUR.
ECRIRE ucChiffre, "! = ", ucProduit.
FIN TANT QUE.
FIN
Notes: La fonction ucLireChiffre est une fonction que vous devez créer. Elle est constituée d’un
‘getkey( )’ qui lit une touche au clavier sans en faire l'écho à l'écran.
Si le caractère lu est entre '0' et '9' on soustrait 0x30 à la valeur lue et on retourne le résultat en
sortant. Si le caractère lu n'était pas un chiffre on retourne 0.
Pour afficher la valeur numérique d'une variable à 8 bits il faut utiliser le CAST (int)
devant le nom de la variable dans le printf ou encore utiliser un des formats: %bu ou %bd.
Pour afficher la valeur d'une variable unsigned long, il faut utiliser le format %Lu.

LABORATOIRE #3
Délai avec l'utilisation des Timers
But: Comprendre le fonctionnement des Timers et les utiliser dans nos programmes en C.
Continuer l’exploration du simulateur de l’environnement de travail uVision de Keil.
Matériel :
 Carte Dallas.
 Carte BARGRAPH (magasin).
1 Étape : Délai avec Timer

Créez un nouveau projet FlashLedTimer.
Partez du programme FlashLed (LED = !LED) du laboratoire précédent.
Vous devez écrire la fonction vInitTimer0(void) dont voici le code.
- Vous devez trouver les valeurs à mettre dans TL0 et TH0 pour avoir un débordement après 1ms.
- Vous devez aussi écrire les commentaires.
void vInitTimer0(void) //
{ //
TMOD = TMOD & 0xF0; //
TMOD = TMOD | 0x01; //
TL0 = 0x??; //
TH0 = 0x??; //
TF0 = 0; //
TR0 = 0; //
} //
Q1: Donnez le mode d’opération du Timer 0, _________________

Vous allez maintenant, écrire une fonction de délai qui utilise le Timer0. Nous l'appellerons
vDelaiMsTimer0(UI). Voici l'algorithme (n'oubliez pas de modifier les commentaires):
DEBUT vDelaiMsTimer(UI uiDelai)
Part le Timer0. // Modifier le bon bit du bon registre.
POUR(i = 0; i < uiDelai; i++) //
TANT QUE(Pas de debordement) // Trouvez le bon bit a tester.
FIN TANT QUE.
Charger Timer0 pour OverFlow a 1ms.
Remet Flag de debordement a 0.
FIN POUR
Arrete Timer0. // Modifier le bon bit du bon registre.
FIN vDelaiMsTimer(UI uiDelai)
Maintenant, modifier le programme principal pour appeler la nouvelle fonction de Délai.

Par simulation, vérifiez le temps d'exécution de la fonction vDelaiMsTimer0( ).
Note: Lors de la simulation, le délai sera erroné. Pour remédier au problème il faut allez dans le
menu "PeripheralsClock Control" et faire un crochet sur CTM avant d'exécuter la fonction
de délai.
Je vérifie (Commentaires, Question et Simulation 3 pts) ______________

2 Étape : Programme de chronomètre sur 8 bits avec Timers
Vous devez créer un chronomètre de 0 à 15.9 secondes de grande précision, utilisant le TIMER0.
Le temps sera affiché, en binaire, sur un bargraph branché sur le Port1.
Les secondes seront affichées sur les bits 7-4 et les dixièmes de seconde le seront sur les bits 3-0.
Secondes | Dixièmes Secondes | Dixièmes
Exemples:
Temps = 15.1 secondes: Temps = 12.8 sec:
 À chaque 100ms, vous devez incrémenter les dixièmes de seconde qui seront affichés sur les bits
3 à 0 du Port 1.
 Lorsque l’on passe de 9 à 10 sur les dixièmes de seconde, les dixièmes de seconde reviennent à
zéro et on incrémente les secondes (affichés sur les bits 7 à 4 du Port 1).
Si les secondes sont à 16, ont les remets à zéro.
Ainsi le chronomètre comptera de 0.0 sec à 15.9 secondes sur le Port 1 (en binaire).
 Les trois boutons auront les fonctions suivantes (lorsque pesés (front descente, pas anti-rebond)):
(utilisez des constantes (#define) pour identifier les différents boutons)
SW2 (P3_2): Démarre le chronomètre (START).
SW3 (P3_3): Remise à zéro du temps (RAZ).
SW4 (P3_4): Arrêt du chronomètre (STOP).
 Votre programme devra utiliser le Timer0 pour compter un intervalle de 100 ms.
 Le Timer ne sera pas utilisé pour faire un délai comme dans le problème précédant.
Le programme ne doit pas bloquer.
 Il vous faudra vérifier le drapeau de débordement du Timer0 pour incrémenter le temps.
 Une seule lecture du Port 3 et une seule écriture sur le Port 1 sont permises.
 Attention, avec le bargraph, on allume les leds sur un 0. Il faudra donc inverser les bits
(opérateur: ~ ) avant d'écrire sur le Port 1. Exemple: P1 = ~(ucCompte);
Q2: Quel sera le mode d’opération du Timer 0: _____________________
Q3: Si TH0 = 0 et TL0 = 0 (compte maximum), quel est le temps de débordement? ____________
Q4: Comment allez-vous procéder pour compter au 100ms? = ___________
Voici en gros les principales tâches à faire dans la boucle:

TANT QUE(VRAI)
Traitement des interrupteurs. // Verifier si changement et traiter.
Traitement debordement au X ms. // Compter le nombre de debordement
// pour 100ms et incrementer dixieme.
Affichage du Chrono. // Affichage Seconde.Dixieme sur P1
FIN TANT QUE.
Regardons plus en détail chaque étape:

Traitement des interrupteurs:
Voici en gros les étapes à faire:
Lire le Port 3 et masquer pour avoir seulement les trois interrupteurs.
SI(Changement sur les interrupteurs)
Vérifier le bouton qui a été pesé. (On test seulement 3 cas sur 8).
FIN SI.
Note:
Pour les boutons Start et Stop, c'est facile. On part ou on arrête le Timer0.
Pour le bouton RAZ, on remet nos variables à 0 et on remet le Timer0 à son compte de X ms.
Traitement débordement au X ms: (X = votre nombre de ms pour le débordement).

Voici en gros les étapes à faire:
SI(Débordement du Timer0)
Remet Flag inactif.
Remet Timer0 au compte pour X ms.
Compte le nombre de débordement.
Si(Rendu à 100ms)
Incrémente les variables.
FIN SI.
FIN SI.
Affichage du Chrono:
Affiche sur P1 (Secondes.Dixièmes). // Utilisation: Décalage,Masque,etc.
Faites le programme en commençant par l'algorithme plus détaillé de chacune des principales tâches
Algorithme détaillé: (utilisez d'autres feuilles si nécessaire)

Traitement interrupteurs Traitement Débordement Affichage
Je vérifie (Algo + Questions 4 pts) ______________

3 Étape: Codez votre programme et faites la simulation avant de l'exécuter sur la cible.
Pour améliorer la simulation des programmes relativement longs, il est conseillé d'utiliser les
"BREAKPOINT" ou Point d'arrêt. On place un ou plusieurs "BREAKPOINT" dans un programme en
faisant simplement un double-clic gauche sur la ligne ou l'on désire avoir un point d'arrêt (un rond
rouge va apparaitre). Par la suite, si on simule le programme en mode "RUN", ce dernier s'arrêtera
juste avant l'exécution d'une ligne marquer d'un "BREAKPOINT". Il est ainsi facile de se rendre à un
point précis d'un programme sans avoir à l'exécuter ligne à ligne. Pour retirer un "BREAKPOINT" on
refait un double-clic gauche.
Je vérifie (Simulation et Fonctionnement sur la carte Dallas 3 pts) ______________
4 Étape (Bonus): Chronomètre de précision, de 0,00 à 1,99 seconde.
Faites un chronomètre de précision, de 0,00 à 1,99 seconde avec P1_3 à P1_0 = 0 à 9 centièmes de
seconde, P1_7 à P1_4 = 0 à 9 dixièmes de seconde et le 1 seconde se fera sur la DEL de P3_5.
Je vérifie (Simulation et Fonctionnement sur la carte Dallas 2 pts) ______________
Évaluation :
 Étape 1 (DélaiTimer Commentaires et Simulation) : _______ / 3
 Étape 2 (Algo Chrono) : _______ / 4
 Étape 3 (Simulation et Fonctionnement Programme) : _______ / 3
Total: _______ /15
 Étape (Bonus) (Simulation et Fonctionnement Programme) : _______ / 2
Lors de la remise du rapport vous devez remettre le listing du programme de l'étape 3 (pas page titre).
Les caractères utilisés dans le listing doivent être de format Courier New, 10 points, 80 car max /ligne
et les commentaires ne doivent pas déborder (sinon jusqu'à -2).

LABORATOIRE #4
Interrupteurs, Anti-rebond, Front et Dimmer avec Timer
But: Comprendre le principe de la lecture des interrupteurs avec anti rebond sans délai, ainsi que le
contrôle d’intensité avec Timer sans délai.
Matériel :
 Carte Dallas.
 Ensemble Carte BARGRAPH et Carte Dipswitch (magasin).
1 Étape : Chenillard manuel (sans délai et anti-rebond logiciel avec compteur)

Vous devez faire un programme qui lira un interrupteur (SW2) pour incrémenter un chenillard sur
8 LED. La lecture de SW2 devra se faire sans délai et il devra y avoir un anti-rebond avec compteur.
Ainsi à chaque pression de l'interrupteur, les LED décale de 1 vers la droite.
(Voir l’algorithme plus bas).
Appuyer Appuyer Appuyer Appuyer
début
............ ....
Chenillard manuel:
ucCompteurSw2 = 0.
ucPort1 = 10000000b. // Valeur binaire à mettre en Hexa.
TANT QUE(VRAI)
SI(SW2 est pesé)
SI(ucCompteurSw2 < 101)
ucCompteurSw2 ++.
SI(ucCompteurSw2 == 100) // Anti-rebond.
Décale ucPort1 vers la Droite de 1 bit.
SI(ucPort1 == 00000000b)
ucPort1 = 10000000b.
FIN SI.
FIN SI.
FIN SI.
SINON // SW2 pas pesé.
ucCompteurSw2 = 0.
FIN SI.
P1 = ~ucPort1. // ~ Inverse car Led actives a 0.
FIN TANT QUE.
Q1: Par simulation trouvez le temps de l'Anti-rebond (activez SW2): ______________
Q2: Placer le programme dans le Dallas et testez-le.

L'anti-rebond fonctionne-t-il à tout coup (soyez attentif)? ____________
Si non, modifiez le programme pour régler le problème (Anti-rebond de 10ms).
Je vérifie (Questions, Simulation et Fonctionnement sur la carte Dallas 4 pts) ____________

2 Étape : Chronomètre à 2 boutons (algo)
Vous devez modifier le programme du chronomètre de la semaine dernière pour avoir le START et le
STOP sur un seul bouton (P3_2), avec anti-rebond par compteur. N'oubliez pas de traiter le RAZ.
On veut encore une seule lecture du port 3 et une seule écriture sur P1.
Écrivez l'algorithme modifié de la partie "Traitement des interrupteurs du lab3":

(Reprenez l'algo de la page précédente et placer le traitement des interrupteurs du lab3 au centre).
Je vérifie (Algo 3 pts) ______________
3 Étape : Chronomètre à 2 boutons (programme)

Écrivez le programme et faites-le exécuter sur la carte Dallas.
Je vérifie (Exécution sur la carte Dallas 2 pts) ______________

4 Étape : Contrôle d'intensité d'une DEL (Intensite.c).
 Vous devez écrire un programme qui vous permettra d’augmenter et de diminuer l’intensité d’une
LED (P3_5) avec 2 boutons, SW2 diminue l'intensité et SW4 l'augmente.
 Il devra y avoir 21 niveaux d’intensité (0%, 5%, 10%, 15%, 20%, …. 95% et 100%)
(ucDimmer (0 à 20) indique le niveau d'intensité recherché).
 Vous devrez activer une LED avec une onde carrée à 100 Hz et de 0% à 100% de cycle de
service. Le signal se répétera 100 fois par seconde et ainsi nous ne verrons pas la LED scintiller.
 L’interrupteur SW3 fixera l’intensité à 50% (ucDimmer = 10).
 Utilisez l’anti-rebond par compteur pour lire les interrupteurs (une seule lecture de P3).
 Nous allons découper la période du signal en 20 (1/100Hz = 10ms). Donc 10ms / 20 = 0.5 ms.
Le Timer0 devra donc faire un débordement à tous les 0.5 ms.
 À chaque débordement on vérifie si on doit allumer ou éteindre la LED. Utilisez une variable qui
sera incrémentée à chaque débordement et qui indique la position où nous en somme sur la
période du signal. Si la Position <= Dimmer on allume, sinon on éteint.
Exemple: Dimmer = 1 (5%), Position = 1 on allume, Position de 2 à 20 on éteint.
Période
1 20
Position Position
Exemple: Dimmer = 19 (95%), Position = 1 à 19 on allume, Position 20 on éteint.
Période
1 19 20 1
Position Position
Q3: Valeur du Timer0 pour débordement au 0.5ms: ______________________________
Écrivez le programme en vous basant sur l'algorithme de la page suivante.
Vérifiez par simulation, que les boutons modifient bien Dimmer.

Pour y arriver, placez-vous sur les lignes qui modifient Dimmer et faites "Run to Cursor line".
Modifiez le Port3 et refaites "Run to Cursor line" plusieurs fois en jouant avec le Port3.
Vérifiez par simulation, que Position augmente bien jusqu'à 20 et retourne à 1.

Pour y arriver, placez-vous sur la ligne "SI(Position <= Dimmer)" et faites "Run to Cursor line"
plusieurs fois.
Je vérifie (Q3, Commentaires, Simulation et Exécution sur la carte Dallas 6 pts) _____________

Algorithme du programme Intensite.c (étape 4):
Note: Dans votre programme, vous devrez ajouter des commentaires pertinents.
vInitTimer0( ).
TR0 = 1. // Partir le Timer0.
TANT QUE(VRAI)
// Gestion des boutons.

LIRE Switch au Port3 et masquer.
SI(Switch pese)
// Faire anti-rebond avec compteur.
SI(Switch == UP) // SW2

SI(Dimmer < 20)
Dimmer++.
FIN SI.
FIN SI.
SI(Switch == DOWN) // SW4
SI(Dimmer > 0)
Dimmer--.
FIN SI.
FIN SI.
SI(Switch == MIDDLE) // SW3
Dimmer = 50%.
FIN SI.
SINON // Switch pas pese.
Desactive Antirebond.
FIN SI.
// Gestion du debordement du Timer0.

SI(TF0 == 1) // Débordement?
TF0 = 0.
Reload Timer0 pour 0.5ms.
Position++.
SI(Position == 21)
Position = 1.
FIN SI.
SI(Position <= Dimmer)

LED = ON.
SINON
LED = OFF.
FIN SI.
FIN SI. // Fin SI Debordement.
FIN TANT QUE.
Évaluation :
 Étape 1 (Chenillard Questions, Simulation et Fonctionnement) : _______ / 4
 Étape 2 (Algo Chrono 2 boutons) : _______ / 3
 Étape 3 (Chrono 2 boutons Fonctionnement Programme) : _______ / 2
 Étape 4 (Intensité Commentaires, Simulation et Fonctionnement) _______ / 6
Total: _______ /15

LABORATOIRE #5
Les Tableaux, Jeu de DÉ et Cohérence cardiaque
But: Comprendre le principe et les limites d’un tableau et continuer l’exploration du simulateur de
l’environnement de travail uVision de Keil pour visualiser des variables et les tableaux.
Matériel :
 Carte Dallas
 Carte BARGRAPH (magasin) ou votre module de Leds.
 Carte DÉ électronique (magasin).
Préparations :
 Écrire les commentaires (à la main) sur le programme de l'Étape 1 (page suivante).
 Dessinez les quatre premières valeurs à s'afficher dans l'étape 1.
 Écrire l’algorithme du programme de l'Étape 3 utilisant 1 tableau et le Timer0.
1 Étape : Chenillard spécial avec tableau (sans délai et anti-rebond logiciel avec compteur)
Dans un premier temps: Vous devez commenter le programme de chenillard de la page suivante
(vérification au début du laboratoire).
Ensuite: Dessinez sur le bargraph suivants, les quatre premiers

affichages du programme ( Led active à 0 ):
(vérification au début du laboratoire).
Je vérifie au début du lab (Affichage 2 pts) ______________
Finalement: Vous devez copier, ajouter des commentaires, compiler, comprendre, simuler et
exécuter (sur la carte Dallas avec un "Bar Graph"), le programme de chenillard
(à faire au laboratoire).
Je vérifie (Simulation et Fonctionnement sur le Dallas 3 pts) ______________

Programme de l'étape #1 (commentaires pertinents à ajouter ici, avant l'arrivé au laboratoire).
void main (void)

{
UC ucComptDelai = 0; //
UC ucCompt = 0; //
//
UC code ucTab[32]={0x81,0x42,0x24,0x18,0x24,0x42,0x81,0x00,
0x81,0x42,0x24,0x18,0x24,0x42,0x81,0x00,
0x80,0xC0,0xE0,0xF0,0xF8,0xFC,0xFE,0xFF,
0x7F,0x3F,0x1F,0x0F,0x07,0x03,0x01,0x00};
vInitTimer0(); // Initialise Timer0 pour overflow au _____ms.
while(TRUE)
{
if(TF0 == 1 ) //
{ //
TL0 = 0x00; //
TH0 = 0x4C; //
TF0 = 0; //
ucComptDelai++; //
if(ucComptDelai >= 2) //
{ //
ucComptDelai = 0; //
P1 = ~ucTab[ucCompt]; //
//
ucCompt++; //
if(ucCompt >= 32) //
{ //
ucCompt = 0; //
}
}
} // Fin du if OverFlow.
} // Fin du while(TRUE).
} // Fin du main.
void vInitTimer0(void)
{
TMOD = TMOD & 0xF0; //
TMOD = TMOD | 0x01; //
TL0 = 0x00; //
TH0 = 0x4C; //
TR0 = 1; //
}
Je vérifie au début du laboratoire (Commentaires Algo 2 pts) ______________

2 Étape : Jeu de dés avec tableau.
En classe on a vue qu'en branchant les LED de manière adéquate, on pouvait trouver une relation
logique entre les différents états. S'il n'est pas possible de trouver une relation logique, l'utilisation
d'un tableau peut nous sauver la vie!
- Branchez le module DÉ pour Dallas sur le Port 1.

- Compilez et simuler un programme de jeu de dés (un seul dé) et tester le module de DÉ.
Fonctionnement: Sur un reset, toutes les LED s’allument (pour vérifier si des leds sont brulés).
Si on appuie sur l’interrupteur SW4 (P3_4), la valeur affichée change au 150ms.
Quand on relâche SW4, une valeur aléatoire (1 à 6) reste affichée sur les LED.
Les valeurs pour activer les LED du dé, seront dans un tableau local.
Dans le simulateur, observez les variables dans la fenêtre:
Call Stack + Locals ou avec: View  Watch Windows  Watch 1
Algorithme: (Timer pas indiqué mais utilisé)
DEBUT Jeu de Dés

ucDe[7] = {0x0F,0x01,0x02,0x03,0x06,0x07,0x0E}.
ucValDe = 0.
P1 = ucDe[ucValDe]. // Test toutes les LED.
TANT QUE(VRAI)
ucValDe++. // Changement de valeur.
SI(ucValDe > 6) // Fin du tableau?
ucValDe = 1.
FIN SI.
SI(l’interrupteur est pesé)
Affiche la valeur du Dé sur les LED. // Affiche au 150ms.
FIN SI.
FIN TANT QUE.
FIN.
Branchement (comme en théorie).
P1_0 Attention: Contrairement au branchement vu en

P1_1 théorie, les LED de la carte DÉ
P1_2 électronique sont active à '0'.
P1_3 Vous devrez inverser la valeur ( ~ ) au
moment de l'écriture.
P1_ 3 2 1 0 ucValDe P1
P1_ 3 2 1 0 0 0 0 1 1 0x01
0 0 0 1 << 1 0 0 1 0 2 0x02
0 0 1 0 +1 0 0 1 1 3 0x03
0 0 1 1 << 1 0 1 1 0 4 0x06
0 1 1 0 +1 0 1 1 1 5 0x07
0 1 1 1 << 1 1 1 1 0 6 0x0E
1 1 1 0 =0 0 0 1

3 Étape : Cohérence cardiaque.
Vous devez faire l’algorithme et écrire le programme d’un appareil de relaxation qui simule la
respiration (4,5 sec inspiration, 4,5 sec expiration) et l’afficher sur 8 LED.
Pour faire simple, on change l'affichage à toutes les 0.5 secondes (de 0 à 8 et de 8 à 0 (18 valeurs)).
Le cycle devra se répéter pour une durée de 45 secondes, après quoi il est arrêté et la valeur 0xAA est
affichée sur les LED. Vous devez faire le programme en utilisant le Timer0 ainsi qu’un tableau pour
les valeurs qui seront affiché sur les LED.
Pour les plus rapides: Utilisez un tableau de 9 éléments seulement.
Algorithme (ordinogramme ou pseudo-code)
(Explication de ce que vous allez faire et comment vous allez le faire)
Je vérifie au début du laboratoire (Algo 2 pts) ______________

Évaluation :
 Étape 1 (Préparation: Affichage) : _______ / 2
 Étape 1 (Préparation: Commentaires Algo)) : _______ / 2
 Étape 1 (Chenillard spécial, Simulation et Fonctionnement) : _______ / 3
 Étape 2 (Jeux dé, Simulation et Fonctionnement) : _______ / 3
 Étape 3 (Préparation: Algo) : _______ / 2
 Étape 3 (Cohérence cardiaque, Simulation et Fonctionnement) _______ / 3
Total: _______ /20

LABORATOIRE #6
Clavier matrice, décodeur de clavier et "Switch case"
Durée: 2 semaines.
But:
 Utiliser la structure de programmation "switch".
 Comprendre le fonctionnement de base d’un clavier type téléphone.
 Comprendre le fonctionnement d’un décodeur de clavier (74C922).
 Utilisation du logiciel Keil pour faire de la programmation en ‘C’ pour le DS89C450.
 Créer des fonctions en ‘C’, pour lire différents types de clavier sur la carte DALLAS.
 Faire des montages qui seront reliés à la carte DALLAS.
Matériel :
 Carte Dallas avec vos câbles (pour les ports 1 et 3) de la première session.
 Carte Bargraph ou votre module de Led.
 Clavier à matrice.
 "Protoboard" avec décodeur de clavier (74C922), condensateurs 1uF et 0.1uF.
Préparations :
 Lire l'énoncé du laboratoire.
 Remplir le tableau des broches de l'étape 2 pour le début de la semaine #1.
 Compléter le schéma de l'étape 4 pour le début de la semaine #1.
 Faire le montage de l'étape 4 pour le début de la semaine #2.
1 Étape : Chenillard spécial avec tableau et switch

 Vous devez écrire un programme (ChenillardSwitch.c) qui génèrera divers affichages sur un
bargraph branché sur le port 1. Il y aura en tout 5 tâches différentes.
 Les changements sur le bargraph doivent se faire au 150ms (utilisation du débordement du
Timer0).
 Au démarrage le bargraph est éteint.
 Le choix de l'affichage sera sélectionné avec les touches du clavier du PC.
Il faut gérer les majuscules et les minuscules.
Touche 'A': Tâche FLIP: On inverse l'état du port 1 (une seule fois).
Touche 'B': Tâche DECALE_D: On décale en continu les bits vers la droite.
Si on est rendu à 0, on recommence à 0x80.
Touche 'C': Tâche DECALE_G: On décale en continu les bits vers la gauche.
Si on est rendu à 0, on recommence à 0x01.
Touche 'D': Tâche BIZARRE: On génère un patron bizarre. Les données à afficher sont dans
un tableau d'au moins 16 valeurs (à vous de l'inventer).
Touche 'E': Tâche ETEINT: On éteint le bargraph.
 Le programme ne doit pas bloquer donc, utilisation de la fonction ucKbHit( ).
 Il y aura une seule écriture sur P1.
Voir l'algorithme sur la page suivante.

Algorithme simplifié du programme:
DÉBUT
ucTache = ETEINT.
ucPort1 = 0.
TANT QUE(VRAI)
SI(Touche pesé) Donc c'est ici que vous devez utiliser la ftnc KbHit
LIRE ucTouche.
// Utilisation du switch pour déterminer la tâche (ucTache) à faire
// en fonction de ucTouche. Vous devez faire 2 switch case , un pour
déterminer l'action à faire selon la touche pesée .
FIN SI.
SI(Débordement)
SI(150 ms)
// Utilisation du switch pour déterminer le prochain état de ucPort1
// en fonction de ucTache. Puis le 2ième switch pour déterminer la valeur à
placer sur P1
FIN SI.
FIN SI.
P1 = ucPort1.
FIN TANT QUE.
FIN
Note: La tâche FLIP sera effectuée une seul fois, lorsqu'on pèse sur la lettre 'A'. Cette tâche ne sera
donc pas gérée au 150ms.
2 Étape : Déterminer les broches du clavier à matrice.
Touche Ligne Colonne

1
2
3
4
5
6
7
8
9
0
A
B
C
D
Votre clavier à matrice comporte 4 lignes et 4 colonnes. Pour faire le *
décodage, vous devrez premièrement déterminer quelle broche #
correspond à quelle ligne ou colonne. Pour faire cette vérification vous
pouvez utiliser un multimètre en mode conductivité. Il est aussi possible de brancher le clavier sur le
Port 1 (clavier vers extérieur du PCB) et utiliser les options du "Bootloader" (W et R). Exemple:
mettre P1_0 à 0: W P1 FE ensuite, faire des tests en forçant une broche à la fois à 0 et de lire les Ports
( R ). Si en pressant sur une touche vous avez 2 bits à 0; un des 0 correspond à la ligne, l’autre à la
colonne. Vous devez prendre en note vos résultats et remplir les tableaux suivants:
C0 C1 C2 C3
L0 Pin
Colonne 0
L1 Colonne 1
Colonne 2
L2 Colonne 3
Ligne 0
L3 Ligne 1
Ligne 2
Ligne 3
PIN: 01234567
Je vérifie au début du laboratoire (Tableau Broches 2 pts)________

3 Étape : Lecture de clavier de manière logiciel.
Vous devez écrire une fonction qui permet de lire le clavier à matrice: "ucLireClavier(UC ucMode)".
- La fonction doit scanner toutes les colonnes (une à la fois) et vérifier si une ligne est à 0.
- Les valeurs à sortir sur le port pour mettre une colonne à 0 doivent être dans un tableau.
- Les codes ASCII doivent être dans un tableau.
UC ucLireClavier(UC ucMode ): (Voir l'algo Annexe 1)

 Retourne le code ASCII de la touche si ucMode == ASCII.
 Retourne une valeur entre 0 et 15 si ucMode == NOMBRE (0 étant 1 et 15 étant D).
 Si aucune touche n'est pesée, la fonction retourne 0x20 (SPACE).
 Si deux touches de la même colonne sont pesées, la fonction retourne SPACE.
 Si deux touches de la même ligne sont pesées, la fonction retourne le code de la première trouvée.
 Si on a une touche de pesée, l'anti-rebond sera un simple délai de 10ms (pas avec Timer).
Indiquez les numéros de colonne (C0 à C3) et de lignes (L0 à L3) sur le Port 1:
Testez votre fonction avec un programme (ClavierLogiciel.c) qui affiche sur le PC le caractère pesé
(mode ASCII) ou la valeur numérique (mode NOMBRE). UC ucCheckMode(void)
{
static UC ucMode = ASCII;
Voici à quoi pourrait ressembler la boucle principale du main( ): if(ucKbHit()
{
ucTouche = getkey();
while(TRUE) switch(ucTouche)
{
{ Case 'A':
ucMode = ucCheckMode(); case 'a':
ucTouche = ucLireClavier(ucMode); ucMode = ASCII;
if(ucTouche != SPACE) break;
case 'N':
{ case 'n':
if(ucMode==ASCII) printf("%c",ucTouche); ucMode = NOMBRE;
else printf("%bd",ucTouche); break;
} default:
ucMode = ASCII;
} // Fin while(TRUE). break;
}
}
return ucMode;
}
Étant donné la vitesse du processeur, vous devriez voir plusieurs caractères apparaitre à l'écran si vous
pesez sur une touche. Pour régler ce problème, il suffit, dans la fonction ucLireClavier, de retourner le
caractère seulement s'il a changé, sinon on retourne un SPACE (voir à la fin de l'algo annexe 1).
Vous devrez utiliser une variable "static" pour garder l'état de l'ancien caractère.
Je vérifie (Fonctionnement sur Dallas 5 pts)) __

4 Étape : Montage du 922.
A. Complété, à la main, le schéma suivant:
11 17
10 X1 DOA 16
8 X2 DOB 15
7 X3 DOC 14
X4 DOD
1 2 3 A
1 12
4 5 6 B 2 Y1 DA
3 Y2
7 8 9 C
4 Y3
Y4
* 0 # D
5
6 OSC
KBM
C1 C2 C3 13
OE
0u1 0u1 1u0
Je vérifie au début du laboratoire semaine #1 (Schéma 2 pts) ______________
B. Effectué, sur protoboard, le montage du circuit précédent:
Je vérifie au début du laboratoire semaine #2 (Montage 3 pts) ______________
5 Étape : Lecture de clavier à l'aide du 922.

Vous devez écrire la fonction "ucLireClavier922(UC ucMode)", qui permet de lire le clavier à matrice
en utilisant le circuit 74C922.
UC ucLireClavier922(UC ucMode ):
 Retourne le code ASCII de la touche si ucMode == ASCII.
 Retourne une valeur entre 0 et 15 si ucMode == NOMBRE (0 étant le 1 du clavier et 15 étant D).
 Si aucune touche n'est pesée, la fonction retourne 0x20 (espace).
 On n'a pas besoin d'anti-rebond. Il faut par compte, détecter un front de monté quand une touche
est pesée (utilisation d'une variable "static" pour garder l'ancien état du signal DA.
 De plus, il faut faire un petit délai après avoir activé OE. ( for(j=0; j<1; j++); )
Testez votre fonction avec un programme (Clavier922.c) qui affiche sur le PC le caractère pesé (mode
ASCII) ou la valeur numérique (mode NOMBRE).
Voici à quoi pourrait ressembler la boucle principale du main( ):
while(TRUE)
{
ucMode = ucCheckMode();
ucTouche = ucLireClavier922(ucMode);
if(ucTouche != SPACE)
{
if(ucMode==ASCII) printf("%c",ucTouche);
else printf("%bd",ucTouche);
}
} // Fin while(TRUE).
Je vérifie (Fonctionnement sur le Dallas 4 pts) ______________

Réflexion 1: Est-il possible de lire plusieurs touches à la fois avec le décodeur 74C922 ?
Non, le 74C922 ne le permet pas.
Réflexion 2: Quel type d’anti-rebond est utilisé avec le 74C922 ?
Anti-rebond matériel.
Réflexion 3: Avec le 74C922, à quoi servent les 3 condensateurs ?

C1 = 0u1, C2 = 0u1 et C3 = 1u0
C1 = 0u1 : Condensateur de découplage
C2 = 0u1 : La fréquence de "scan" des colonnes
C3 = 1u0 : Pour le délai d'anti-rebond
Réflexion 4: Selon vous, avec la lecture du clavier par une méthode logiciel sur le port1 est-il possible de
lire plusieurs touches à la fois et Pourquoi ?
OUI: Chaque combinaison de touches aura un code diffèrent sur le port P1.
Il s'agira de bien l'interpréter pour pouvoir lire plusieurs touches à la fois.
Réflexion 5: Donnez des avantages et des inconvénients d'utiliser la lecture du clavier par la méthode
logiciel par rapport à la méthode avec décodeur 74C922 ?
Avantages: Pas besoin d'acheter de pièces supplémentaires.

Montage plus simple.
Peut lire plus d'une touche à la fois.
Inconvénients: Demande plus de ligne d'I/O sur le microcontrôleur.

Le programme est un peu plus complexe.
Gestion de l'anti-rebond plus difficile.
Évaluation :
 Étape 1 (Switch Simulation et Fonctionnement) : _______ / 4
 Étape 2 (Broches du clavier préparation semaine#1)) : _______ / 2
 Étape 3 (Clavier logiciel Fonctionnement) : _______ / 3
Mode NOMBRE : _______ / 2
 Étape 4 (Schéma du circuit 922 début semaine #1) : _______ / 2
 Étape 4 (Montage du circuit 922 début semaine #2) : _______ / 3
 Étape 5 (Clavier avec 922 Fonctionnement) : _______ / 4
 Total: _______ /20

Annexe 1
Algo de la Fonction ucLireClavier (ucMode )
Tableau pour les codes ASCII des touches (ucTableauTouche).
Tableau de codes pour mettre les colonnes a 0.
ucCaractere = SPACE; // Valeur par defaut.
POUR(i=0; i<4; i++)
P1 = Code pour mettre une colonne à 0 (en fonction de i) (Tableau).
ucLigne = Lire le Port 1 et masquer les colonnes.
SI(On a une ligne a 0)
vDelaiMs(10). // Anti-Rebond.
ucCol = i.
i= 4; // Pour sortir du POUR, si code invalide.
CAS DE(ucLigne)
case LIGNE0: // LIGNE0 constante ou le bit de la Ligne0 = 0
ucLigne = 0.
i = 5. // Pour sortir du POUR, code valide.
break;
case LIGNE1: // Ligne 1.
ucLigne = 1.
break;
ucLigne = 2.
break;
ucLigne = 3.
break;
default: // Pas de ligne ou plus d'une ligne.
ucLigne = 4.
i = 4. // Pour sortir du POUR, code invalide.
break;
FIN CAS DE.
SI(i == 5) // Code valide?
SI(ucMode == ASCII)
ucCaractere = ucTableauTouche[ucLigne][ucCol]. // Mode ASCII.
SINON
ucCaractere = (ucLigne * 4) + ucCol. // Mode NOMBRE.
FIN SI
SINON // Code non valide.
ucCaractere = SPACE.
FIN SI.
FIN SI. // Fin SI(On a une Ligne a 0).
FIN POUR.
SI(ucOldCaractere != ucCaractere) // Changement de caractere?
ucOldCaractere = ucCaractere. // ucOldCaractere doit etre static.
ucRetour = ucCaractere.
SINON
ucRetour = SPACE.
FIN SI.
Retourne ucRetour.

LABORATOIRE #7
Mémoires, Latch, Décodeurs et les Pointeurs
Durée: 2 semaines.
But:
 Comprendre le principe des BUS pour l’accès aux mémoires et aux I/O.
 Utilisation de latch (loquet-verrou-bascule).
 Utilisation des pointeurs.
 Développer des méthodes de travail et de débogage.
 Faire des montages qui seront reliés à la carte DALLAS.
Matériel :
 "Protoboard" avec deux 74HCT573, un 74LS04, un 74LS02, un 74LS00, deux Bargraph.
 Carte Adaptateur 40 TSO pour Proto avec câble (ADAP 40 TSO)
 Carte Simulateur Binaire V2 + Bloc alimentation.
Préparations :
 Lire l'énoncé du laboratoire.
 Comprendre le fonctionnement des "Latch" comme I/O et Mémoire.
 Comprendre les signaux READ et WRITE et les décodeurs d'adresses.
 Faites le montage de l'annexe 1 du laboratoire.
Je vérifie au début du laboratoire (Montage 3 pts)________
1 Étape : Mémoire 1 octet avec 74HCT573 (Sans décodeur d'adresses).

Avec ce circuit, que vous
écriviez ou lisiez à n'importe
quelle adresse externe (xdata
de 0x0000 à 0xFFFF),
c'est toujours le circuit U1
74HCT573 qui sera sollicité
(on ne décode pas les
adresses).
Les sorties de U2 sont en
Hi-Z (OC à VCC)
Attention : Vous avez déjà
une mémoire de 32K aux
adresses 0x0000 à 0x7FFF.
Il faudra configurer Keil
pour mettre la mémoire
externe à 0x8000.
Ainsi la RAM du Kit ne sera
pas activée.
Voir page suivante.
À partir du montage de la préparation, branchez les fils en gras.
Note: Pour relier ce montage avec la carte Dallas, utilisez un câble plat 40F-40F relié
entre JP3-1 de la carte Dallas et l'adaptateur Câble plat 40.
Configuration pour avoir la mémoire externe à 0x8000:
Option for Target 'Target1'
2 Étape : Programme pour tester la mémoire.

Écrire le programme suivant pour tester votre montage :
UC xdata ucTouche; // Declaree xdata, donc Keil va la placer dans la
// memoire externe (votre 74LS573),
// a une adresse >= 0x8000.
while(1)
{
ucTouche = getkey(); // Lit une touche au clavier.
printf("%c", ucTouche); // Affiche contenu de votre case memoire.
}
Pour forcer Keil à accéder à notre variable externe, nous devrons

baisser le niveau d'optimisation. Dans les options de notre target,
sous l'onglet C51, mettez le "Level" à 0.
Si le programme est fonctionnel, vous devriez voir un caractère apparaitre à l'écran à chaque fois
qu'on pèse sur une touche du clavier. Comme l'adresse n'est pas décodée, peu importe l'adresse où le
compilateur placera votre variable (de 0x8000 à 0xFFFF), nous y auront toujours accès.
Pour vous assurer que c'est vraiment votre mémoire qui est utilisée, débrancher l'un des fils (RD ou
WR). Vous ne devriez plus afficher vos caractères.
3 Étape : Programme pour tester la mémoire avec un pointeur

(La mémoire externe de Keil n'a pas besoin d'être configuré).
Modifiez votre programme pour répondre à l'algorithme suivant :
// ucTouche sera declaree data (donc placee dans la memoire interne).
// ucpData sera declaree UC xdata *ucpData = 0x8000; (Pointe sur le 74HCT573).
DEBUT
TANT QUE(VRAI)
LIRE ucTouche. // getkey (pas d'echo).
Placez ucTouche dans la memoire externe avec le pointeur (ucpData).
ECRIRE (la valeur pointee par ucpData). // printf avec ucpData.
FIN TANT QUE.
FIN
Si le programme est fonctionnel, vous devriez voir la touche pesé apparaitre à l'écran.
Comme l'adresse n'est pas décodée, peu importe la valeur du pointeur (de 0x8000 à 0xFFFF)
il pointera toujours dans votre 74HCT573.
Pour vous assurer que c'est vraiment votre mémoire qui est utilisée, débrancher le fil WR.
Vous ne devriez plus afficher vos caractères.

4 Étape : Mémoire 2 octets avec 74HCT573 (Avec décodeur d'adresses).
Pour le circuit suivant, débranchez les fils mis à l'étape 1 et ajoutez les fils en gras du schéma suivant :
Branchez les fils en gras

/CS4 A0 /WR /RD CU1 /OCU1 CU2 /OCU2 Fonction
Table de vérité: 1 x x x 0 1 0 1 rien
0 0 0 1 1 1 0 1 Write U1
0 0 1 0 0 0 0 1 Read U1
0 1 0 1 0 1 1 1 Write U2
0 1 1 0 0 1 0 0 Read U2
Q1- Quel est l'adresse de base du 74HCT573 U1?

Q2- Quel est l'adresse de base du 74HCT573 U2?
Q3- À quoi sert A0?
5 Étape : Programme pour tester la Mémoire 2 octets avec 74HCT573 (Avec décodeur d'adresses).
Écrire un programme qui va tester les deux circuits 74HCT573. Vous devez écrire 0x55 dans une des
cases mémoires et 0x00 dans l'autre case pour modifier la donnée sur le bus. Ensuite vous devez lire la
première case mémoire et vérifier que la donnée lue est la même. Affichez un message pour dire si
OK ou Fail. Ensuite essayer avec 0xAA. Faites l'autre 573.
Algo: *U1 = 0x55; // U1 est un pointeur initialisé à l'adresse du 573 U1.
*U2 = 0x00; // Pour s'assurer que le bus de donnée soit changé.
SI(*U1 == 0x55) ECRIRE "Avec 0x55 sur U1: OK";
SINON ECRIRE "Avec 0x55 sur U1: FAIL";
Voir l'exemple d'affichage à la page suivante.

Exemple d'affichage du programme (avec petit problème matériel !):
Avec 0x55 sur U1: OK
Avec 0xAA sur U1: OK
Avec 0x55 sur U2: Fail // D0 de U2 était defectueux.
Avec 0xAA sur U2: OK
Pour vérifier le fonctionnement : - Débrancher *CS4 (4 fails)

- Ensuite remettre *CS4 et débrancher l'entrée C de U2 (2 fails)
Je vérifie (Réponses et Fonctionnement de l'étape 5 sur le Dallas 7 pts) ______________
6 Étape : Utilisation du 74HCT573 comme Latch (Avec décodeur d'adresses).

Nous allons utiliser le 74HCT573 comme un périphérique d'affichage. Il faudra donc lui transmettre
une donnée en activant le signal WR (écriture dans un xdata).
Modifier le circuit de l'étape précédente en retirant le lien entre les sorties des "Latch" et le bus de
donnée. Brancher le signal /OC des "Latch" sur le GND pour garder les sorties toujours actives.
Brancher les sorties des "Latch" sur des "Bargraph" (vous pouvez utiliser les cartes BARGRAPH du
magasin, branché directement sur les 573).
7 Étape : Programme utilisant les 74HCT573 comme Latch.
Écrivez un programme qui fera un chenillard sur 16 bits sur les deux Bargraph.
Utilisez des pointeurs pour accéder aux 573.

8 Étape : Branchement de la carte Simulateur Binaire.
Vous devez brancher la carte Simulateur Binaire, que vous avez réalisée la session dernière, sur la
carte Dallas par l'entremise d'un câble plat et d'un bloc d'alimentation 12 volts.
La carte binaire contient 4 "Latch" 74HCT573 qui fonctionne en sortie, comme dans l'étape 6.
De plus il y a 2 "Buffer" 74HCT245 pour les entrées (dip switch).
P0
Les sorties sont soit deux "Bargraph" aux adresses 0x8200 et 0x8300, et 2 sept segments aux adresses
0x8400 et 0x8500.
En sortie on se sert du signal WRITE sur le "Latch Enable".
Les entrées sont deux blocs de 8 "Dip switch" aux adresses 0x8200 et 0x8300.
En entrée on se sert du signal READ sur le "Buffer".
Ex: Le programme suivant vous permettra de lire les "Dip switch" à l'adresse 0x8200 et de les
reporter sur le "Bargraph" de la même adresse.
void main (void)

{
UC xdata *ucp8200 = 0x8200; // Adresse 0x8200 du simulateur binaire.
UC ucVal;
while(1)
{
ucVal = *ucp8200; // Lit Dip-switch.
*ucp8200 = ucVal; // Affiche sur Bargraph.
}
}

9 Étape : I/O (Input/Output, Dip Switch sur Bargraph).
Modifier le programme précédant pour faite afficher les "Dip switch" de l'adresse 0x8200 sur le
"Bargraph de l'adresse 0x8300 et inversement les "Dip switch" de l'adresse 0x8300 sur le "Bargraph
de l'adresse 0x8200
10 Étape : Dip Switch sur 7-segments.
Affichez en continu, l'état des Dip switch de l'adresse 0x8300 sur les deux 7-segments (00 à FF).
Code pour les caractères en 7-Segments (Si actif a 0 il faudra inverser les codes ~):
                
0x3F 0x06 0x5B 0x4F 0x66 0x6D 0x7D 0x07 0x7F 0x6F 0x77 0x7C 0x39 0x5E 0x79 0x71
Indice: Mettez les codes dans un tableau de 16 octets.

Récupérez le bon code avec la valeur de deux fois 4 bits des Dip switch.
11 Étape : Horloge sur la carte simulateur binaire.
Faite l'algorithme (je ne vérifie pas l'algo, mais vous pouvez me le montrez) et le programme qui fera
une horloge binaire. Les seconde serons affichées (en BCD) sur les deux sept segments (00 à 59), les
minutes seront affiché sur le "bargraph" 0x8300 en BCD (0x00 à 0x59) et les heures sur le "bargraph"
0x8200 en BCD aussi (0x00 à 0x23). Pour les secondes, utilisez le Timer 0 (100 * 10ms).
Évaluation :
 Étape 1 (Montage de l'annexe 1.) : _______ / 3
 Étape 2 (Fonctionnement Mémoire 1 octet avec xdata.) : _______ / 3
 Étape 3 (Fonctionnement Mémoire 1 octet avec pointeur.) : _______ / 3
 Étape 5 (Questions+ Fonctionnement Mémoire 2 octets) : _______ / 7
 Étape 7 (Fonctionnement Chenillard 16 bits) : _______ / 4
 Étape 9 (Fonctionnement Dip switch Bargraph) : _______ / 2
 Étape 10 (Fonctionnement Dip switch  7-Segments) : _______ / 3
 Étape 11 (Fonctionnement Horloge) : _______ / 5
 Total: _______ /30

ANNEXE 1
Préparation Laboratoire 7
Monter sur proto le circuit suivant :
Pour simplifier le montage : Placer U2 sur U1 en prenant soin de déplier les pattes 1 et 11 de U2.
Voir démo du prof.
Note: Pour relier ce montage avec la carte Dallas, utilisez un câble plat 40F-40F relié entre JP3-1 de la
carte Dallas et l'adaptateur Câble plat 40.

LABORATOIRE #8
Test de la Mémoires Externes et pointeurs
But:
 Comprendre le fonctionnement des mémoires externes et des pointeurs.
 Utilisation du logiciel Keil pour faire de la programmation en ‘C’ pour le DS89C450.
 Réaliser des programmes de tests de mémoire RAM.
Matériel:
 Carte Dallas (soudée au complet).
Préparations:
 Vous devez comprendre et transcrire le programme TestMem1.C de l’ANNEXE 1 (page 41).
 Quel est l'étendu de mémoire RAM disponible sur votre kit Dallas ?
De___________ à ___________
 Faire l'algorithme, très clair et précis, de l’Étape 2.
Je ne vérifie rien, à vous de vous prendre en main
1Étape : Test de base de la RAM sur votre kit Dallas.
Vous devez faire un premier test de votre mémoire avec le programme que vous avez transcrit en
préparation. Ce programme ne teste pas toute la mémoire. S’il y a des erreurs, vous devez identifier si
le problème est logiciel ou matériel et faire les corrections nécessaires.
Q1 : Lors de l’exécution de votre programme, il devrait y avoir au moins une erreur.

Quelle est-elle, pourquoi se produit-elle et comment pouvez-vous modifier le programme pour
corriger le problème ? (Aidez-vous avec la question en préparation).
Je vérifie (Q1 et Fonctionnement sur le Dallas 4 pts) ______________

2Étape : Test complet de la RAM de votre mémoire (TestMem2.C).
Vous devez écrire un programme, qui vous permettra de tester la RAM utilisable sur votre carte
Dallas. Tester de 0x0000 à 0x8000 (0x8000 inclus). Le programme écrira les 256 valeurs de 0x00 à
0xFF dans chaque case mémoire et vérifiera à chaque écriture l'intégralité des informations. Bien
documenter votre programme car je corrige la liste imprimée du programme de l'étape 2.
- À la différence du programme précédant, n'affichez pas les cases mémoires testées mais seulement
le total des erreurs (Attention il peut y en avoir beaucoup "unsigned long").
Servez-vous de TestMem1.C comme base.
- Indiquer l'évolution du test en affichant un message à toutes les fois que vous êtes rendu à une
adresse qui est un multiple de 0x1000 (utilisation du modulo).
- Faite l'algorithme pour la préparation.
Exemple d'affichage : Programme de test complet de la mémoire externe.
Rendu a 0x0000
Rendu a 0x1000
Rendu a 0x2000
Rendu a 0x3000
Rendu a 0x4000
Rendu a 0x5000
Rendu a 0x6000
Rendu a 0x7000
Rendu a 0x8000
Il y a 255 erreur(s)
Il y a 255 erreurs car l'adresse 0x8000 n'est pas dans la RAM. Pourquoi manque-t-il une erreur ?
Bonus : Localisation de la mémoire RAM externe utilisable sur la carte mémoire.

Faites un algorithme lisible et précis (votre voisin doit être capable de le lire et de le comprendre), et
le programme qui permettra d'indiquer les blocs de "RAM externe" et "I/O ou ROM" disponible sur le
Kit Dallas. Indice: le programme devra vérifier les adresses de 0x0000 jusqu'à 0xFFFF. S’il est
possible d’écrire et de relire la même valeur, c’est de la RAM, sinon c’est autre chose.
Faire 2 tests consécutifs à la même adresse avec 2 valeurs différentes. Si au moins une erreur, on est
en "I/O ou ROM".
Lorsque terminé, le programme indique: "Fin du Test!".
Affichage si tout va bien:
Programme de recherche du type de memoire.
Debut zone de RAM Externe: 0x0000

Debut zone de I/O ou ROM : 0x8000
Fin du test!
Je vérifie (Bonus Fonctionnement sur le Dallas 2 pts) ______________
Évaluation :
 Étape 1 (Test Mem de base + Q1.) : _______ / 4
 Étape 2 (Test Mémoire.) : _______ / 6
 Listing documenté de l'étape 2 : _______ / 5
 Bonus (Recherche de zone de mémoire.) : _______ / 2
 Total: _______ /15
ANNEXE 1
Programme TestMem1.C :
//***** P R O G R A M M E P R I N C I P A L E T A P E # 1 *****************
void main(void)
{
UC ucErreur = 0; // Pour compter les erreurs
vInitPortSerie(); // Initialise le port série a 57600 bds, N, 8, 1
printf("\n\nProgramme de test de memoire externe.\n");
ucErreur = ucErreur + ucVerifRAM(0xCC,0x0000); // Compte les erreurs en

ucErreur = ucErreur + ucVerifRAM(0xAA,0x1111); // verifiant si les valeurs
ucErreur = ucErreur + ucVerifRAM(0x33,0x5555); // lues, correspondent
ucErreur = ucErreur + ucVerifRAM(0x55,0x5AAA); // aux valeurs ecrites.
ucErreur = ucErreur + ucVerifRAM(0xC3,0x7FFF); //
ucErreur = ucErreur + ucVerifRAM(0x22,0x8000); //
printf("\n\n Il y a %bd erreur(s)", ucErreur ); // Affiche nombre d'erreur
while(1);
} // ******** F I N D U P R O G R A M M E P R I N C I P A L **************
//****** L E S F O N C T I O N S ********************************************
//*****************************************************************************
// Nom de la fct: ucVerifRAM par: Pierre Chouinard
// Date: 15 mars 2009 Revision : B
// Prototype: unsigned char ucVerifRAM (UC ucVal, UI uiAdd);
// Description: Cette fonction ecrit en RAM externe et verifie si la valeur
// a ete ecrite convenablement.
// Si oui retourne 0, sinon retourne 1.
//
// Entree: ucVal: Valeur 8 bits pour le test entre 0x00 et 0xFF
// uiAdd: Adresse de la case mémoire à tester.
// Sortie: ucVal, vaut 0 si le test est OK, ou 1 si le test a echoue.
//
// Revisions: 24/03/14: Formate, change commentaires et met un seul return. DC.
//
// Exemple d'appel: uErreur = ucVerifRAM(0x11,0x3456); // Test 0x11 a 0x3456.
//*****************************************************************************
UC ucVerifRAM(UC ucVal, UI uiAdd)
{
UC xdata *ucpExt; // Pointeur vers RAM externe.
ucpExt = (UC xdata *)uiAdd; // Initialise le pointeur a l'adresse externe.

*ucpExt = ucVal; // Ecrit la valeur a cette adresse.
// Affiche les valeurs ecrites et relues.

printf("\nEcrit 0x%02bX a l'adresse 0x%04X", ucVal, uiAdd);
printf(" et lit 0x%02bX", *ucpExt);
if(*ucpExt == ucVal) ucVal = 0; // Valeurs identiques, pas d'erreur.

else ucVal = 1; // Valeurs différentes, erreur.
return(ucVal);
} // Fin ucVerifRAM(UC ucVal, UI uiAdd).
void vInitPortSerie(void)
{
...
...
} // Fin

LABORATOIRE #9
Convertisseur ADC, Historique et Mémoires Externes
But:
 Brancher un convertisseur ADC et comprendre l’acquisition de données avec un microcontrôleur.
 Utiliser la configuration des mémoires externes avec Keil.
 Comprendre l’utilisation des fichier.OBJ et l’importance des commentaires dans un programme
 Faire du transfert de données d'un microcontrôleur vers un PC
Matériel:
 PC avec l’environnement de travail Keil, Carte Dallas.
 Convertisseur Analogue/numérique ADC0804, Photo Cell, Résist. 1k et 10k, Cond. 150pF.
 Câble Header 40F-40F (CABLE0053) + Adaptateur Câble plat 40 (ADAP040).
Préparations:
 Vous devez mettre en forme, comprendre et commenter les programmes Historique.c et
ConvADC.c disponible sur le réseau (Voir ANNEXE II et III).
P:\243-Technologie du Genie Electrique\Daniel.Cote\Documents\Cours 247-236\Laboratoires\Lab09
 Trouver le "PinOut" du schéma suivant et faites en le montage Branchez les sorties D0 à D7

du convertisseur ADC0804 sur des DEL (carte DEL ou Barre graph) pour en tester le
fonctionnement.
Vérification du montage de Test du convertisseur ADC0804.

Vérifier votre montage pour être certain que tous les composants fonctionnent bien. Lorsque la
conversion se fait bien, vous devriez voir les DEL s'allumer et s'éteindre en passant la main
devant la Photo Cell. Si ça ne fonctionne pas comme il se doit, la réussite du laboratoire est
compromise.

1Étape : Test du programme ConvADC.c.
Modifier un peu le montage de l’étape 1 pour relier D0 à D7, /RD, /WR, /CS et /Intr du ADC0804
aux lignes D0 à D7, /RD, /WR, /CS4 et P3_2 du connecteur 40 pins de votre carte Dallas.
Compiler le programme ConvADC.c que vous avez mis en forme en préparation.

Vérifier que le programme permet d’afficher correctement la valeur de conversion sur le PC.
Je ne vérifie rien, à vous de vous prendre en main

2Étape : Test du programme Historique.c.
Compiler le programme HISTORIQUE.c que vous avez mis en forme en préparation.
IMPORTANT: Lorsque vous allez compilez votre programme n’oubliez pas de configurer
l’emplacement de la RAM externe de 0x0000 à 0x7FFF = 32k = 0x8000 octets.
Dans "Option for Target ‘Target 1’"  Onglet "Target"
Vous devez tester le programme HISTORIQUE.c et faire un fichier EXCEL
Je vérifie (Fonctionnement et fichier Excel) ____________________________
3Étape : Programme d’acquisition de données.

Vous devez éditer, corriger, compiler et tester le programme ACQUISITION.c (disponible sur le
réseau) qui vous permettra de faire l’acquisition en RAM externe d’un signal analogique à toutes les
0.2 secondes, d’en faire le transfert vers le PC lorsque désiré et de réaliser le graphique de cette
acquisition dans Excel.
Vous devez corriger les partie notées « ????? » dans le programme Acquisition.c
Question 1: Comprendre le programme et calculez pendant combien de temps vous pourrez

enregistrer des données sans dépasser la mémoire disponible.
Je vérifie (Fonctionnement et graphique) ____________________________

ANNEXE I
Fichier: Fonction236.h
//*********************************************************************************
// Fonction236.h : Prototypes de trois fonctions de base du cours de 247-236
// A utiliser avec Fonction236.obj
//
// vInitVitessePortSerie: permet de configurer la vitesse du port serie en
// fonction du 'Baud Rate' desire et de la fréquence du cristal
// utilise. Pour utiliser cette fonction on doit donner la vitesse
// désire du port serie ( ex.: 300, 1200, 2400, 4800, 9600, 19200,
// 28800 ou 57600 ) et la frequence du cristal en Hz (sur la
// carte Dallas de TSO = 11059200)
//
// Exemple: vInitVitessePortSerie(57600, 11059200);
//
// ATTENTION: si vous faites une erreur le port serie ne
// fonctionnera pas
//
// vEcrire8BitsExt et
// ucLire8BitsExt: Deux fonctions qui permettent d'aller lire ou ecrire
// n'importe ou en RAM externe ou I/O.
// La fonction vEcrire8bitsExt a besoin de l'adresse ou ecrire
// et de la valeur (de type UC) a ecrire.
//
// Exemples: vEcrire8bitsExt(0x1234, 0x55);
// vEcrire8bitsExt(uiAdresse, ucVal);
//
// La fonction ucLire8bitsExt a besoin de l'adresse ou lire, pour
// parametre d'entre et elle retourne la valeur lue de type UC.
//
// Exemples: ucVal1 = ucLire8bitsExt(0x39AB);
// ucVal2 = ucLire8bitsExt(uiAdresse);
//*********************************************************************************
void vInitVitessePortSerie(unsigned long lVitesse, unsigned long lFreq);

void vEcrire8BitsExt(unsigned int adresse, unsigned char donnee);
unsigned char ucLire8BitsExt(unsigned int adresse);// Fichier : Fonction236.h

ANNEXE II
Fichier: ConvADC.c
//*****************************************************************************
// Fichier: ConvADC.C
// Auteur:
// Date:
// Revision :
// Compilateur:
// Description:
//*****************************************************************************
#include <stdio.h>
#include "_DeclarationGenerale.h"
#include "Fonction236.h"
#define LED P3_5; void main(void) { UC ucADC;
vInitVitessePortSerie(57600,11059200);
printf("\nProgramme ADC0804 sur chip select, lecture avec HyperTerminal. ");
printf("Par: PC\n"); printf("\nSchema de branchement du ADC0804:");
printf("\n 40 Pins ADC0804");
printf("\n ------- ----------");
printf("\n 1|D0 Vcc|2 (pin 2) Vcc--20|Vcc |");
printf("\n 3|D1 Vcc|4 (pin 1) D0---18|D0 /CS|1---/CS4 (pin 26)");
printf("\n 5|D2 | (Pin 3) D1---17|D1 /RD|2---/RD (pin 31)");
printf("\n 7|D3 | (Pin 5) D2---16|D2 /WR|3---/WR (pin 29)");
printf("\n 9|D4 | (Pin 7) D3---15|D3 /Intr|5---P3_2 (pin 33)");
printf("\n 11|D5 | (Pin 9) D4---14|D4 |");
printf("\n 13|D6 | (Pin 11) D5---13|D5 Vin+|6---Vin");
printf("\n 15|D7 | (Pin 13) D6---12|D6 Vin-|7---GND");
printf("\n | | (Pin 15) D7---11|D7 |");
printf("\n | | | ClkR|19-10k-+ ");
printf("\n | | GND----8|AGND ClkC|4------+-150pF-GND");
printf("\n | | | |");
printf("\n | /CS4|26 GND---10|GND Vref/2|9--x");
printf("\n | | ----------");
printf("\n 29|/WR |");printf("\n 31|/RD |");printf("\n 33|P3_2 |");
printf("\n 35| |");printf("\n 37| GND|39");
printf("\n 39| GND|40");printf("\n ---------");printf("\n");
vEcrire8BitsExt(0x8400,0xFF);while(1){if(P3_2 == 0){ucADC = ucLire8BitsExt(0x8400);
printf("\rADC = %bd ", ucADC); vEcrire8BitsExt(0x8400,0xFF);LED = !LED;}}}

ANNEXE III
Fichier: Historique.c
//*****************************************************************************
// Fichier: Historique.C
// Auteur:
// Date:
// Revision :
// Compilateur:
// Description: Ce programme permet de ......
//
// Avant de compiler vous devez configurer Keil pour avoir la RAM externe
// de 0x0000 a 0x7FFF:
//
// Dans: -> Option for Target 'Target 1'
// -> TARGET
// -> Off-chip Xdata Memory
// Start: Size:
// RAM 0x0000 0x8000 = (32k)
//
//*****************************************************************************
#include <stdio.h>
#include "_DeclarationGenerale.h"
#include "Fonction236.h"
#define LED P3_5 void main(void)
{ UI uiNbTouches; UI uiCompte; UC ucTouche; UC ucVal;
UC xdata ucRamExt[0x8000];vInitVitessePortSerie(57600,11059200);
printf("\nProgramme Historique avec Tableau, par: PC\n");
while(1) { LED = 0;
printf("\n\n Dans hyperterminal, commencer la capture en faisant:");
printf("\n 'Transfert'->'Capturer le texte...'->'Parcourir'");
printf("\n et entrez un NomDeFichier.XLS dans un repertoire ");
printf("\n ou vous le retrouverez facilement, puis faite");
printf("\n 'Demarrer' pour debuter le transfert.");
printf("\n\n Ensuite, dans hyperterminal, entrez des Touches au clavier.");
printf("\n Lorsque vous avez termine, faite 'ESC'");
printf("\n Maintenant, fermer le fichier d'enregistrement: ");
printf("\n 'Transfert'->'Capturer le texte...'->'Arreter'");
printf("\n Entrez dans Excel, ouvrez et visualisez votre");
printf("\n fichier de l'historique des touches.\n\n");uiNbTouches = 0;
ucTouche = getchar();while (ucTouche != 27){
ucRamExt[uiNbTouches] = ucTouche; uiNbTouches++;if(uiNbTouches >= 32700) {
printf("\n\nPreparez-vous a sauvegarder vos donnees et faites 'ESC'");
printf("\n sinon vous allez ecrire dans une zone interdite");}
ucTouche = getchar();} printf("\nIl y a %d touches.\n", uiNbTouches);
// Transfert de la memoire vers le fichier si capture demarree.
for (uiCompte = 0; uiCompte < uiNbTouches; uiCompte++){
ucVal = ucRamExt[uiCompte]; printf("\n%d\t%bd\t%c",uiCompte+1, ucVal, ucVal);
} LED = 1; printf("\n\nFin des donnees. Arretez la capture.");
printf("\nEntrez une touche pour continuer\n"); getchar(); }}


Laboratoires Prog

Transféré par

Droits d'auteur :

Formats disponibles

Laboratoires Prog

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Laboratoires Prog

Transféré par

Droits d'auteur :

Formats disponibles

Laboratoires

Numéro du cours Pondération Unités

Titre du cours Département

Programme Enseignants ou enseignantes

LABORATOIRE #1 Première fonction et simulation avec Keil .................................................................3

P.C. / D.C. / F.B. Cours 247-236 Programme de TSO

Tableau des principales fonctions de simulation (dépannage)

Q1 : Que signifie UART ?

P.C. / D.C. / F.B. Laboratoire 1 Cours 247-236 Programme de TSO

4 Étape: Les Fonctions

void vInitPortSerie(void); // Predeclaration de la fonction vInitPortSerie.

printf("\nBonjour!"); // Affiche le message 'Bonjour' sur le port serie.

// Un entête de fonction devrait se trouver ici !!!!!

void vInitPortSerie(void) // Definition de la fonction vInitPortSerie

Compilez le et retournez dans l’environnement de simulation (bouton ) et exécutez entièrement le

Q3 : Expliquez la différence entre Step et Step Over:

P.C. / D.C. / F.B. Laboratoire 1 Cours 247-236 Programme de TSO

Q4 : Que représentent les 16 cases de la fenêtre du Port 3?

Sortir de la simulation et ajoutez dans votre programme, la fonction de délai suivante:

Je vérifie la simulation ___________

Je vérifie la simulation et l'exécution sur le Dallas ___________

Je vérifie la simulation et le fonctionnement sur LED___________________

P.C. / D.C. / F.B. Laboratoire 1 Cours 247-236 Programme de TSO

Résumé : Si la valeur du Dé est égale à 0x0E mettre le Dé égale à 1,

Je vérifie la simulation et l’exécution avec le Bargraph sur le Dallas ___________

Simuler le programme de votre projet final de la session dernière (Dé ou Chronomètre).

Je vérifie la simulation ___________

P.C. / D.C. / F.B. Laboratoire 1 Cours 247-236 Programme de TSO

Rappel de la Création d’un Projet avec Keil

Avant d’ouvrir Keil :

Dans la fenêtre ‘ Select Device for Target ‘Target 1’ et l’onglet CPU :

Configuration de base de la compilation :

Configuration de base de la simulation :

RAPPEL : Les programmes doivent être édités avec :

P.C. / D.C. / F.B. Laboratoire 1 Cours 247-236 Programme de TSO

1 Étape : Calcul factoriel ! (le listing est à remettre)

P.C. / D.C. / F.B, Laboratoire 2 Cours 247-236 Programme de TSO

Algo de la fonction avec des while (à faire avec des "for"):

Je vérifie (Simulation et Exécution sur le Dallas 2 pts) ______________

3 Étape : Mesure du temps d’exécution, 'Step over', 'Breakpoint' et 'Run'

Par la suite après avoir compilé votre programme, allez dans la

P.C. / D.C. / F.B, Laboratoire 2 Cours 247-236 Programme de TSO

Avec des boucles "for" et la valeur 613 :

vDélaiMs (100) : Mesuré (ms) (oscil) = ______________

Valeur de la boucle ? = __________

Calculez à l’aide du simulateur (4 chiffres après le point) et mesurez à l’oscilloscope (1 ou 2 chiffres

Je vérifie _(Simulation et Réponses 3 pts)_____________

P.C. / D.C. / F.B, Laboratoire 2 Cours 247-236 Programme de TSO

P.C. / D.C. / F.B, Laboratoire 2 Cours 247-236 Programme de TSO

1 Étape : Délai avec Timer

Q1: Donnez le mode d’opération du Timer 0, _________________

Maintenant, modifier le programme principal pour appeler la nouvelle fonction de Délai.

Je vérifie (Commentaires, Question et Simulation 3 pts) ______________

P.C. / D.C. / F.B, Laboratoire 3 Cours 247-236 Programme de TSO

Q2: Quel sera le mode d’opération du Timer 0: _____________________

Q4: Comment allez-vous procéder pour compter au 100ms? = ___________

Voici en gros les principales tâches à faire dans la boucle:

Regardons plus en détail chaque étape:

P.C. / D.C. / F.B, Laboratoire 3 Cours 247-236 Programme de TSO