Mini Projet Microcontrôleur ST7

Transcription

Mini projet Microcontrôleur ST7
Mini Projet
Microcontrôleur ST7
Eric RICHARD
Février 2006
-1-
-2-
SOMMAIRE
Chapitre 1 Introduction ........................................................................................................... 5
Chapitre 2 Découverte du µC et de l'IDE................................................................................ 6
Chapitre 3 Premiers pas ......................................................................................................... 17
Chapitre 4 La maquette de développement............................................................................ 25
Chapitre 5 Les LEDs .............................................................................................................. 27
Chapitre 6 Les afficheurs 7 segments.................................................................................... 29
Chapitre 7 Les interruptions .................................................................................................. 31
Chapitre 8 Le timer ................................................................................................................ 33
Chapitre 9 Le convertisseur analogique-numérique ............................................................ 36
Annexe 1
Annexe 2
Annexe 3
Annexe 4
ST7LITE2.ASM
SQUELET.ASM
Créer un projet ST7 en 10 leçons
Résumé du jeu d'instructions du ST7
-3-
-4-
Chapitre 1 Introduction
Les objectifs de ce mini-projet sont les suivants :
étudier le fonctionnement d'un microcontrôleur 8 bits, le ST7FLITE20 (référence
complète ST7FLITE20F2B6) de la famille ST7 de ST Microelectronics,
étudier un environnement de développement de programmes écrits en assembleur.
Cet environnement est un IDE (Integrated Development Environment) et intègre tous
les outils de développement d'un logiciel embarqué (gestionnaire de projet, éditeur
avec coloriage syntaxique, assembleur, éditeur de lien, débogueur symbolique, carte
de développement du ST7),
étudier une carte d'apprentissage (Training board) comportant différents modules
(LED, afficheur 7 segments, bouton poussoir, moteur, …), gérés par le
microcontrôleur.
Au cours de ce mini-projet , vous développerez tout d'abord des petits programmes mettant
en œuvre les différents constituants de la carte. Cela vous familiarisera avec le ST7, sa
programmation et son environnement de développement.
Ensuite, vous réaliserez un projet complet mettant en œuvre les différents programmes que
vous aurez développés dans la première partie.
-5-
Chapitre 2
Découverte du µC et de l'IDE
1) Présentation du microcontrôleur
Un microcontrôleur est un microprocesseur autour duquel ont été rajoutés des périphériques
et de la mémoire.
Pour le ST7FLITE20, la mémoire présente est de type :
Flash (8 ko) pour la mémoire programme,
RAM (384 octets) dont 256 octets pour les données et 128 octets pour la pile.
Les périphériques sont :
Un watchdog,
Un timer "auto-reload" 12 bits,
Un timer 8 bits (Lite Timer 2),
Un port d'entrées/sorties 8 bits (PORT A),
Un port d'entrées/sorties 7 bits (PORT B),
Un port série synchrone (SPI),
Un convertisseur analogique-numérique 10 bits, 7 voies.
Les différentes entrées/sorties des périphériques du µcontrôleur sont multiplexées (Cf
synoptique ci-dessus). Avec ces ports, il est capable de recevoir des interruptions externes.
-6-
Le CPU est architecturé autour d'un bus interne de données de 8 bits et d'un bus interne
d'adresse de 16 bits. II contient 6 registres :
un compteur ordinal PC (16 bits),
un accumulateur A (8 bits),
deux registres d'index X et Y (8 bits),
un registre d'état CCR (8 bits),
un pointeur de pile SP (16 bits).
L'utilisation de ces registres est expliquée dans la documentation technique du composant.
La mémoire contient à la fois le programme, qui définit ce que le CPU doit faire, et les
données, qui sont stockées temporairement comme des résultats intermédiaires de calcul ou
qui contiennent 1'état général du système.
Dans les systèmes à µcontrôleur, contrairement aux ordinateurs qui utilisent uniquement de
la RAM, différents types de mémoires sont utilisés selon leur fonction : la mémoire non
volatile à lecture seule pour le programme (ROM ou Flash), la mémoire volatile à lecture
et écriture pour les données temporaires (RAM). Cependant vue du programmeur, la
mémoire forme un unique espace adressable selon la théorie de Von Neumann, comme le
montre la figure suivante :
On peut voir dans cette structure trois espaces RAM différents. Le premier (Short
Addressing RAM) est appelé également page 0 et peut s'adresser uniquement avec 8 bits, ce
qui améliore les temps d'accès à cette zone mémoire. Le second (16-bit Addressing RAM)
nécessite des adresses sur 16 bits. Le troisième correspond à la pile (Stack).
-7-
La pile se trouve aux adresses mémoire de $0180 à $01FF. L'instruction RSP, au début du
programme (voir fichier SQUELET.ASM en annexe 2), permet de remettre le pointeur de
pile sur 1'adresse $01FF. II ne faut pas enlever cette instruction.
Les périphériques sont désignés par un nom et correspondent en réalité à 1'accès à des
registres particuliers se trouvant dans les adresses mémoire de $0000 à $007F. Le fichier
ST7Lite2.ASM, fourni pour la réalisation de vos programmes (cf Annexe 1), contient la
déclaration des noms des registres, ce qui facilite la programmation.
Les vecteurs d'interruption se trouvent à la fin de la mémoire programme. Ils définissent
les adresses des sous-programmes à exécuter lorsqu'une interruption arrive. Par exemple
1'interruption due au Reset du µcontrôleur est liée à 1'adresse du début du programme à
exécuter. Ainsi, dès que le µcontrôleur est mis sous tension, 1'interruption du reset est
générée, et cela force le CPU à sauter à 1'adresse du début du programme pour 1'exécuter.
2) Développement
2.1
Squelette de programme
La programmation du µcontrôleur se fait en langage assembleur ST7. L'assembleur comporte
un jeu d'instruction complet et de nombreux modes d'adressage.
Le squelette du programme qui vous est fourni (fichier SQUELET.ASM) a pour but de bien
définir la structure d'un programme et les différentes zones mémoires nécessaires pour la
construction du code exécutable. II servira de base pour 1'écriture de vos programmes et
comporte :
Une zone de description
Cette zone est constituée de commentaires et permet de décrire ce que fait le
programme. II est très important de commenter les programmes, quel que soit le
langage de programmation, mais c'est particulièrement vrai en langage assembleur, car
c'est un langage peu lisible.
La syntaxe des commentaires est la suivante :
; ceci est un commentaire en début de ligne
INST ; commentaire d'une instruction
Une zone de déclaration des symboles
Cette zone permet de déclarer des symboles pour simplifier la lecture du code source. Ils
sont désignes par un nom (on dit également label) et ne prennent pas de place en mémoire
(contrairement aux constantes).
La syntaxe est la suivante :
nom
EQU
valeur
par exemple :
TEMPO
EQU
$50
-8-
Remarques :
- Pensez à donner des noms clairs afin de simplifier la lecture du code. Cette remarque est
valable pour tous les types de noms que vous définirez : symboles, variables, constantes,
sous-programmes.
- Pour la lisibilité de votre code, utilisez la convention suivante :
label[TAB]INST [TAB]opérande[TAB] ; commentaire
où [TAB] désigne la touche de tabulation.
Une zone de déclaration des variables
Cette zone se trouve dans la RAM0 ou page 0 de la mémoire.
Chaque variable est déclarée par un nom (ou label) et une taille en nombre d'octets. On
peut ainsi déclarer également des tableaux. La syntaxe est la suivante :
var1
var2
var3
var4
DS.B
DS.W
DS.B
DS.W
1
1
10
5
;
;
;
;
variable d'un octet
variable d'un mot (c'est à dire 2 octets)
tableau de 10 octets
tableau de 5 mots
Une zone de déclaration des constantes
Cette zone se trouve dans la zone mémoire programme. Chaque constante est déclarée
par un nom (ou label) et une taille en nombre d 'octets. On peut ainsi déclarer également
des tableaux de constantes. La syntaxe est la suivante :
cst1
cst2
cst3
DC.B
DC.W
DC.B
7
$1234
10,4,13,7,90
; constante 7
; constante hexadécimale 1234h
; tableau de 5 constantes (10, 4, 13, 7 et 90)
Une zone de déclaration des sous-programmes
Cette zone se trouve également dans la mémoire programme. Elle contiendra tous les
sous-programmes que vous définirez. La syntaxe d'un sous-programme est la suivante :
nom :
; nom du sous –programme
INST1
INST2
…
RET
; instruction de fin de sous-programme
-9-
Un programme principal
Ce programme principal se trouve dans la mémoire programme. C'est le point de
départ du programme. Sa syntaxe est la suivante :
main :
boucl
RSP
…
…
…
JP
; initialisation du pointeur de pile
boucl ; boucle sur une partie du programme
L'instruction RSP ne doit pas être enlevée et doit être la première instruction du
programme principal. Elle sert à initialiser le pointeur de pile.
L'instruction JP boucl effectue un saut dans le programme principal. Celui-ci boucle donc
à 1'infini. Ceci doit toujours être le cas. En effet un µcontrôleur est en général embarqué
dans un système qui fonctionne en permanence tant qu'il est sous tension. Le programme
principal doit donc faire en sorte qu'il ne s'arrête jamais, par une boucle infinie.
Deux cas de figure se rencontrent :
- soit un saut au début du programme,
- soit un saut vers une position qui se trouve après la phase d'initialisation.
Une zone de déclaration des sous-programmes d'interruption
Cette zone se trouve dans la mémoire programme. Elle contiendra tous les sousprogrammes d'interruption que vous définirez.
Ces sous-programmes d'interruption sont les sous-programmes à exécuter lorsqu'une
interruption provenant d'un périphérique ou d'un port du µcontrôleur survient.
La syntaxe d'un sous-programme d'interruption est la suivante :
nom :
; nom du sous-programme d'IT
INST1
INST2
…
IRET
; instruction de fin de sous-programme d' IT
Une zone de déclaration des vecteurs d'interruption
Cette zone se trouve dans la mémoire programme. Les vecteurs d'interruption sont en fait
les liens entre 1'interruption elle-même et le sous-programme d'interruption correspondant.
Par défaut, dans le fichier SQUELET.ASM, toutes les interruptions sont liées avec le sousprogramme d'interruption "dummy_rt" qui ne fait rien, sauf 1'interruption de reset qui
est liée au programme principal "main", afin que le µcontrôleur démarre au début du
programme lorsqu'on fait un reset ou une mise sous tension.
- 10 -
2.2
Instructions du ST7
Cette section ne sera pas développée car 1'environnement de développement du ST7 contient
une très bonne aide en ligne sur les instructions du langage assembleur pour ST7. Ouvrez
cette page d'aide et laissez-la en permanence ouverte, cela vous fera gagner du temps.
L'annexe 4 contient le résumé des instructions du ST7.
2.3
Modes d'adressage du ST7
La famille ST7 possède de nombreux modes d'adressage, classiques ou plus spécifiques.
Toutes les instructions n'acceptent pas forcément tous les modes d'adressage, il faut donc
vérifier dans 1'aide quel mode convient.
Le mode immédiat
Pour charger un registre avec une valeur fixe, cette valeur peut être incorporée à
1'instruction. Dans ce cas, la valeur suit immédiatement le code opération dans la
mémoire et il n'y a pas besoin de donner l'adresse de la donnée à lire.
Par exemple :
Ndoigts
Hexa
Mask
EQU
EQU
EQU
10
$10
%10100011
…
LD
LD
LD
A,#Ndoigts
A,#Hexa
A,#Mask
; A est chargé avec la valeur 10
; A est chargé avec la valeur hexadécimale 10h
; A est chargé avec la valeur binaire 1010 0011 soit
; A3h
Le mode direct court
II y a deux modes directs : court et long (ou étendu). Ils sont presque identiques, seul
diffère le nombre d'octets servant à donner 1'adresse de 1'opérande. Dans le mode direct
court, 1'adresse est codée sur 1 octet afin d'accéder à la page 0 (adresse comprise entre 0
et 255).
Par exemple :
LD
A,$10
; A est chargé avec la valeur de l'octet situé à
; l'adresse 10h
Le mode direct long
II est identique au précédent, sauf que l'adresse de 1'opérande est codée sur 2 octets. Cette
adresse permet d'accéder à la totalité de 1'espace adressable.
- 11 -
Par exemple :
LD
A,$123
; A est chargé avec la valeur de l'octet situé à
; l'adresse 0123h
ATTENTION : ne pas confondre l'adressage immédiat et l'adressage direct. C'est souvent
une cause d'erreur dans vos programmes.
Le mode indexé
Dans ce mode, I'adresse de 1'opérande est fournie par le registre d'index X ou Y selon le
préfixe. Cette adresse ne permet d'accéder qu'à la page 0, puisque les registres X et Y
n'ont que 8 bits.
Par exemple :
LD
A,(X)
; A est chargé avec la valeur de l'octet
; dont l'adresse est dans X.
Ce mode est utilisé lorsque l'adresse de 1'opérande n'est pas connu au moment de
l'écriture du programme et est donc calculée pendant 1'exécution.
Le mode indexé avec décalage court
Ce mode est semblable au mode indexé, mais le code opération est suivi d'un octet
contenant un déplacement, qui est ajouté à la valeur de l'index avant de faire l'accès à la
mémoire. Cette adresse permet d'accéder seulement à l'intervalle 0 à 1FEh (0FFh + 0FFh).
Par exemple, pour accéder au caractère n°4 d'une chaîne de caractères (nota : c'est le
cinquième caractère !), on exécute 1es instructions suivantes :
Phrase
DS.B 50
…
LD
LD
; réservation de 50 caractères à l'adresse logique Phrase
X,#4
; on charge la valeur 4 dans X
A,(Phrase,X) ; A est chargé avec la valeur de l'octet situé à l'adresse
; qui est la somme de Phrase et de la valeur contenue
; dans X
Ce mode est utilisé pour les accès à des éléments de tableaux ou de chaînes de caractères.
Attention : Les espaces ne sont pas autorisés de part et d'autre de la virgule.
Le mode indexé avec décalage long
Ce mode est semblable au mode indexé avec décalage court, mais le code opération est
suivi d'un déplacement sur 2 octets, qui est ajouté à la valeur de 1'index avant de faire
1'accès à la mémoire. Cette adresse permet d'accéder à tout l'espace adressable.
- 12 -
Par exemple, on désire transférer dans l'accumulateur le caractère n° 64h d'une chaîne de
caractères située à l'adresse 4523h. Pour cela, on charge d'abord 64h dans X puis on
exécute 1'instruction suivante :
LD
A,($4523,X)
; A est chargé avec la valeur de l'octet situé à l'adresse
; qui est la somme de 4523h et de la valeur contenue
; dans X
Remarque : Si la somme de X et du décalage dépasse 65535, le résultat est donné modulo
65536. Par exemple, si X contient 83h et que le décalage est FFC2h, l'adresse résultante
est 45h.
Le mode indirect court
Dans ce mode, l'adresse qui suit le code opération est celle d'un octet en mémoire qui
contient l'adresse de la variable à laquelle on désire accéder. Cet emplacement qui
contient une adresse s'appelle un pointeur. Ce pointeur est toujours placé en page 0.
Par exemple, si le pointeur à l'adresse 23h contient la valeur 79h et que 1'octet à l'adresse
79h contient la valeur 12h, 1'instruction suivante charge 12h dans A :
LD
A,[$23]
Le mode indirect long
Ce mode est similaire au mode indirect court, mais le pointeur, toujours placé en page 0,
est une valeur sur 2 octets successifs.
Par exemple, si le pointeur à l'adresse 23h contient la valeur 7954h et que 1'octet à
l'adresse 7954h contient la valeur 12h, 1'instruction suivante charge 12h dans A :
LD
A,[$23.w]
C'est 1'utilisation du ".w" qui spécifie que le pointeur est sur 16 bits.
Le mode indexé avec décalage indirect court
Ce mode est semblable au mode indexé avec décalage, cependant 1'octet qui suit le
code opération n'est pas le décalage lui-même, mais 1'adresse d'un octet en
mémoire qui contient ce décalage.
Par exemple, si le pointeur à 1'adresse 23h contient 79h, que le registre X contient 5,
et que 1'octet à 1'adresse 7Eh (79h + 05h) contient 22h, 1'instruction suivante
charge 22h dans A :
LD
A,([$23],X)
- 13 -
Le mode indexé avec décalage indirect long
Ce mode est semblable au mode indexé avec décalage indirect court, mais le
pointeur est une adresse sur 2 octets successifs.
Par exemple, si le pointeur à 1'adresse 23h contient 7945h, que le registre X
contient 5, et que 1'octet à 1'adresse 794Ah (7945h + 0005h) contient 22h,
1'instruction suivante charge 22h dans A :
LD
A,([$23.w],X)
Exemples d'utilisation
1. Lecture d'une variable
ma_variable
ds.b
…
LD
1
A,ma_variable
; direct court
2. Ecriture d'une valeur dans une variable
ma_valeur
ma_variable
dc.b
…
ds.b
…
LD
LD
$56
1
A,#ma_valeur
ma_variable,A
; immédiat
; direct court
3. Lecture d'une valeur d'un tableau de variables (ou de constantes)
mon_tableau
ds.b
…
LD
LD
10
X,#5
; immédiat
A,(mon-tableau,X) ; indexé avec décalage court
- 14 -
2.4
Création d'un projet
Un document d'aide à la création d'un projet ST7 a été rédigé. Référez-vous à ce document
pour chaque nouveau programme. Vous le trouverez en annexe 3.
Vous trouverez, en ligne, dans le campus numérique, sous N3/Electronique numérique, tous les
documents utiles pour votre mini-projet.
2.5
Ensemble de développement
La carte "ST5-ST7 Training board", développée par l'ISEN Toulon, est destinée à
l'apprentissage de la programmation des µcontrôleurs ST Microelectronics des familles ST5
et ST7. Elle inclut un µcontrôleur ST7 référence ST7Lite20 et un µcontrôleur ST5 référence
ST52F513.
Le kit, qui vous est fourni, comprend :
Une carte "ST5-ST7 Training board",
Un bloc d'alimentation se branchant sur le secteur (220V-50Hz ).
Vous devez également disposer de :
Une carte inDart STX, vendue par Softec (cf site www.softecmicro.com). Cette carte
est fournie avec un cordon USB et un câble plat ISP,
Un PC muni d'un port USB dans lequel vous avez installé les logiciels de
développement fournis gratuitement par ST (téléchargeables sur le site
www.stmcu.com) et Softec (téléchargeables sur le site www.softecmicro.com).
Attention : les utilisations en mode ST7 et ST5 sont exclusives.
La mise en service s'effectue comme suit :
Relier le bloc d'alimentation à la carte "ST5-ST7 Training board" et brancher le au
secteur,
Relier votre PC à la carte InDart par le cordon USB puis celle-ci à la carte "ST5-ST7
Training board" par le câble plat ISP. Selon que vous voulez travailler avec le ST7 ou
le ST5, vous brancherez le câble ISP sur le connecteur en haut à gauche (ST7) ou à
droite (ST5) et vous positionnerez correctement l'interrupteur d'alimentation (sur le
bord gauche de la carte). Pour le mini-projet, vous travaillerez avec le ST7.
Vous obtenez le montage suivant :
- 15 -
PC de développement
Câble ISP
Cordon USB
ST5-ST7 Training board
Carte InDart
L'écriture du code assembleur se fait sur le PC avec un éditeur à coloriage syntaxique. La
compilation et l'édition de lien se font dans le même environnement ainsi que la simulation et
le debug.
2.6
Utilisation du débogueur
Cette section ne sera pas développée car l'environnement de développement du ST7 contient
une aide en ligne très détaillée sur 1'utilisation du débogueur qui est par ailleurs très facile à
utiliser. L'enseignant présent avec vous est également là pour vous aider à prendre en main
cet environnement, donc n'hésitez pas à poser des questions.
- 16 -
Chapitre 3
Premiers pas
1) Introduction
Dans tous les exercices qui vont suivre, pensez à créer un sous-répertoire correspondant à
1'exercice, à y copier les fichiers nécessaires à la compilation, c'est à dire ST7Lite2.asm,
ST7Lite2.inc, MAX7219.asm, MAX7219.inc, et SQUELET.asm puis à travailler dans ce
sous-répertoire.
Vous trouverez en ligne, dans le campus numérique, tous ces fichiers.
- 17 -
2) Réalisation d'un compteur modulo 10
Cet exercice consiste à réaliser un programme qui compte de 0 à 9 puis recommence à 0. Ce
programme boucle indéfiniment.
Le compteur sera mémorisé dans une variable nommée "compte" que vous devrez définir
dans la zone des variables.
Tester le programme avec le débogueur en mode pas à pas afin de vérifier son bon
fonctionnement.
L'organigramme suivant illustre l'architecture de ce programme :
Début
compte = 0
OUI
compte > 9 ?
NON
compte =
compte + 1
3) Comment faire une boucle "for" ?
Cet exercice consiste à réaliser, en assembleur, une boucle "for", connue dans les langages
évolués. Pour cela, on vous demande de calculer la somme des 20 premiers entiers.
La somme sera mémorisée dans une variable nommée "somme" que vous devrez définir dans la
zone des variables. Par contre, 1'indice de la boucle "i" ne sera pas déclaré comme une variable :
on utilisera le registre X du µcontrôleur.
fonctionnement.
L'organigramme suivant illustre l'architecture de ce programme :
- 18 -
Début
somme = 0
X=20
OUI
X=0?
NON
somme = somme + X
X=X-1
4) Créer et appeler des sous-programmes
Comme dans les langages évolués, l'assembleur permet de faire des appels à des sousprogrammes (procédures ou fonctions), permettant de rendre plus lisible et plus efficace un
programme.
Cet exercice consiste à reprendre 1'exercice précédent de calcul de la somme des 20 premiers
entiers (dans un nouveau répertoire), et de créer le sous-programme "calcule_somme", qui
prendra en entrée, dans le registre A, le nombre d'entiers à ajouter (on ne se limite plus à 20)
et calculera la somme qu'il retournera dans la variable "somme".
Le programme principal effectuera les opérations suivantes :
- mettre un nombre dans A (nombre d'entiers que l'on veut ajouter),
- appeler ucalcule_somme" avec 1'instruction CALL.
fonctionnement.
Remarque : un retour de sous-programme se fait avec 1'instruction RET. L'organigramme
suivant illustre 1'architecture de ce programme :
- 19 -
Début
Début
calcule_somme
A = 23
somme = 0
X=A
OUI
Appel
calcule_somme
X=0?
NON
somme = somme + X
X=X-1
Fin
calcule_somme
5) A quoi sert la pile ?
Cet exercice consiste à reprendre l'exercice précédent pour illustrer l'utilisation de la pile
(en anglais stack). Pour cela, dans le programme principal, ajouter la ligne suivante avant
1'appel de "calcule_somme":
LD
X,#$88
Cela met la valeur hexadécimale 88h dans le registre X.
Avec le débogueur, vérifier la valeur de X avant et après 1'appel de "calcule_somme".
Que faut-il faire pour conserver la valeur de X lors de 1'appel d'un sous-programme qui
modifie X?
Remarque : les modifications apportées pour sauvegarder les registres désirés ne doivent
toucher que les sous-programmes appelés et pas le programme appelant.
Tester le programme modifié avec le débogueur en mode pas à pas afin de vérifier son bon
fonctionnement. Regarder l'évolution des contenus de PC, SP et de la mémoire RAM des
adresses $1F0 à $1FF.
Dans la suite, dans chaque sous-programme, vous veillerez à sauvegarder tous les registres
utilisés.
- 20 -
6) Utilisation des tableaux
Dans les langages évolués, les tableaux sont très utilisés pour résoudre de nombreux
problèmes. Nous allons donc voir comment utiliser les tableaux en assembleur avec la famille
ST7.
Cet exercice consiste à réaliser un programme d'extraction de minimum et maximum sur un
tableau. Pour cela, vous allez déclarer un tableau de 8 octets, que vous nommerez "tableau",
dans la zone de déclaration des variables.
Remarque : déclarer un tableau de 8 octets en assembleur signifie juste réserver un
emplacement de 8 octets successifs pour une variable. C'est le programmeur qui utilisera
cette variable en tant que tableau.
Vous créerez ensuite un sous-programme "initialise_tableau" qui initialise le tableau avec
les valeurs suivantes :
tableau[0]
25
tableau[l]
4
tableau[2]
2
tableau[3]
15
tableau[4]
16
tableau[5]
101
tableau[6]
33
tableau[7]
3
Vous créerez alors un sous-programme "min-max" qui effectue la recherche des valeurs
minimales et maximales dans le tableau, et met les résultats dans les variables "minimum" et
"maximum" à déclarer.
Le programme principal devra alors appeler la procédure "initialise_ST7" puis
"initialise_tableau" et la procédure "min_max".
L'organigramme suivant illustre l'architecture du programme principal :
Début
Appel
initialise_tableau
Appel
min_max
- 21 -
Détailler l'organigramme du sous-programme "min_max" puis écrire et tester le programme
avec le débogueur en mode pas à pas afin de vérifier son bon fonctionnement.
Remarque : tester un programme implique de tester toutes les branches du programme et des
sous-programmes. A cet effet, après le test avec le tableau précédent de 8 octets, vous retesterez le programme avec un tableau de 11 octets, les valeurs étant : 25, 4, 55, 222, 15, 2,
131, 99, 45, 9, 2.
7) Ports d'entrées/sorties
Comme cela a déjà été dit auparavant, un µcontrôleur possède des ports d'entrées/sorties afin
de dialoguer avec le monde extérieur.
Cet exercice consiste à comprendre comment utiliser ces ports, c'est à dire comment lire sur
un port d'entrée et comment écrire sur un port de sortie.
Nous allons ici utiliser le port A qui est un port 8 bits. Dans la famille ST7, le port A (comme
les autres ports d'entrées/sorties) est contrôlé par 3 registres :
le registre de direction
PADDR
le registre d'options
PAOR
le registre de données
PADR
Le registre de direction PADDR contrôle la direction de chaque bit du port : soit en entrée
(bit correspondant à 0), soit en sortie (bit correspondant à 1).
Par exemple, on veut que les bits 0, 3 et 6 du port A soient en sortie et les bits 1, 2, 4, 5 et 7
en entrée. II faut alors mettre la valeur suivante dans le registre PADDR :
Port A
bit 7
bit 6
bit 5
bit 4
bit 3
bit 2
bit 1
bit 0
Direction
entrée
sortie
entrée
entrée
sortie
entrée
entrée
sortie
1
0
0
1
0
0
1
Registre PADDR 0
Cela se fera par les instructions suivantes :
Init_PADDR
EQU
…
LD
LD
%01001001
A,#Init_PADDR
PADDR,A
car on ne peut pas charger directement un registre autre que A, X et Y (voir détail des
instructions).
- 22 -
Cela peut également se faire par 1'ensemble des instructions suivantes (beaucoup moins lisible
et moins rapide) :
BSET
BRES
BRES
BSET
BRES
BRES
BSET
BRES
PADDR,#0
PADDR,#1
PADDR,#2
PADDR,#3
PADDR,#4
PADDR,#5
PADDR,#6
PADDR,#7
Le registre d'options PAOR contrôle le mode de fonctionnement en entrée ou sortie de
chaque bit du port. Le tableau suivant donne la signification de ce registre pour le port A :
Entrée
OR= 0
PA7:0
Flottant
Sortie
OR= 1
OR= 0
OR= 1
Pull-up
Open drain
Push-pull
avec ou sans IT
Les détails sur les modes de fonctionnement des entrées/sorties sont donnés dans le manuel
technique du ST7Lite2.
Le registre de donnée PADR est le registre dans lequel :
- il faut écrire pour envoyer des données en sortie,
- il faut lire pour recevoir des données en entrée.
Remarque : Tous les programmes qui utilisent les ports d'entrées/sorties doivent comporter
un sous-programme d'initialisation des registres contrôlant les ports du µcontrôleur.
Votre travail :
Vous réaliserez un programme qui va :
- paramétrer le port A en entrées flottantes sur les bits 0 à 3 et en sorties symétriques sur les bits
4 à 7,
- écrire une valeur dans la variable "portA_TX" que vous aurez préalablement déclarée,
- écrire la valeur de "portA_TX" sur le port A.
- lire le port A et mettre la valeur lue dans une variable "portA_RX" que vous aurez déclarée,
Pour cela, vous allez écrire le sous-programme "initialise_ST7" qui réalise
l'initialisation du port A dans le mode demandé.
Vous créerez ensuite deux sous-programmes, un qui s'appelle "lit_portA", qui doit lire la
valeur du port A puis 1'écrire dans la variable "portA_RX" et un qui s'appelle
"ecrit_portA", qui doit écrire sur le port A la valeur qui est dans la variable "portA_TX".
Le programme principal appellera "initialise_ST7". Vous vérifierez la configuration du
port avec le débogueur en mode pas à pas et en affichant la fenêtre "Peripheral registers"
(du menu "View").
- 23 -
Puis il positionnera la valeur $55 dans la variable "portA_TX" et appellera "ecrit_portA".
Vous vérifierez la valeur de PADR avec le débogueur.
Enfin le programme principal appellera "lit_portA". Vous vérifierez la valeur de "portA__RX"
avec le débogueur toujours en mode pas à pas, en ouvrant la fenêtre "Watch" (du menu
"View").
Remarque : lorsque vous ne voulez modifier qu'un seul bit du port A en écriture ou ne lire
qu'un seul bit du port A, vous devez manipuler les registres avec des OU et des ET logiques
pour ne conserver que les informations voulues. Par exemple, pour envoyer un 1 uniquement
sur le bit 3 du port A configuré en sortie sur tous les bits, il faut écrire :
LD
OR
LD
A,PADR
A,#$08
PADR,A
; lecture du port A et mémorisation dans le registre A
; on force à 1 le bit 3 du registre A
; on écrit la valeur à envoyer sur le port A
En faisant cela, on a juste modifié le bit 3 du port PADR.
- 24 -
Chapitre 4 La maquette de développement
Maintenant que vous avez réalisé les exercices précédents, vous avez acquis les bases de la
programmation en assembleur sur la famille ST7, et vous êtes capables de créer un
programme et de le déboguer avec 1'environnement de développement de chez ST
Microelectronics.
Nous allons à présent vous présenter la maquette de développement de 1'ISEN qui vous
servira pour les exercices suivants et pour le projet. Elle permet d'utiliser les différents
composants et fonctionnalités du µcontrôleur.
Les périphériques, disponibles sur la carte, sont :
8 LEDs,
un moteur pilotable par PWM,
un buzzer pilotable par PWM,
un potentiomètre, permettant de générer une tension continue entre 0 et 5V, pour
acquisition par un port ADC,
4 afficheurs 7 segments, gérés par le composant MAX 7219, relié aux ST5 et ST7 par
une liaison SPI et un signal de LOAD,
2 poussoirs, mettant à 0V, les entrées correspondantes quand ils sont activés,
2 boutons poussoirs de Reset (un par µcontrôleur),
un picot de masse et 2 picots In1 et In2 pour connecter 2 signaux analogiques
externes. Remarque : l'entrée In2 n'est pas utilisable avec le ST5.
Le tableau ci-dessous précise les connections entre les ports du µcontrôleur ST7, les
périphériques et le connecteur JP2.
ST7Lite20
Nom de la pin
Périphérique connecté
PA0/LTIC
PA1/ATIC
PA2/ATPWM0
PA3/ATPWM1
PA4/ATPWM2
PA5/ATPWM3/ICCDATA
PA6/MCO/ICCCLK/BREAK
PA7
PB0/SS'/AIN0
PB1/SCK/AIN1
PB2/MISO/AIN2
PB3/MOSI/AIN3
PB4/CLKIN/AIN4
PB5/AIN5
PB6/AIN6
RESET
LED1
LED2
Moteur
LED3/Buzzer/Poussoir1
LED4
Réservé ISP
Réservé ISP
LED5
Potentiomètre/Poussoir2/In1
Gestion Afficheurs :CK SPI
Gestion Afficheurs : Load Max
Gestion Afficheurs :MOSI
LED6/In2
LED7
LED8
Poussoir RESET
- 25 -
N° pin
ST7
13
12
11
10
9
8
7
6
19
20
1
2
3
4
5
18
N° pin JP2
6
7
4
13
14
15
16
17
5
3
1
2
10
11
12
Les configurations possibles de la carte sont les suivantes (la photo ci-après permet de
préciser la position des éléments cités) :
choix ST5/ST7 : positionner l'interrupteur d'alimentation (IA1), connecter le câble
ISP sur le connecteur J0 (ST7) ou J1 (ST5),
Tension d'alimentation du ST5 : 5V ou 3.3V (cavaliers W1 et W2). Avec le
composant livré, connecter W1, ne pas connecter W2,
Activation des 8 LEDs par barrette de 8 interrupteurs (B1),
Activation du moteur (cavalier W3),
Activation du buzzer (cavalier W4),
Activation du poussoir 1 référencé S4 (cavalier W5),
Activation du poussoir 2 référencé S5 (cavalier W7),
Activation du potentiomètre (cavalier W6),
Reset du ST7,
Reset du ST5.
Remarques importantes :
1. ne jamais positionner simultanément les cavaliers W1 et W2 d'alimentation du ST5,
2. si vous positionnez le cavalier W5 (poussoir 1), désactiver la LED n°3,
3. si vous utilisez l'entrée analogique In1, déconnectez le potentiomètre (cavalier W6) et
le poussoir 2 (cavalier W7),
4. si vous utilisez l'entrée analogique In2, désactiver la LED n°6.
ISP ST7 (J0)
B1
ISP ST5 (J1)
Reset ST5
Reset ST7
IA1
JP2
W7
Poussoir 2
W1 W2
W3
W4
- 26 -
W5
Poussoir 1
W6
Chapitre 5 Les LEDs
Dans ce chapitre, nous allons utiliser les ports d'entrées/sorties du µcontrôleur ST7Lite2 pour
commander 1'allumage ou 1'extinction de LEDs.
Remarque : comme dans le chapitre Premiers pas, vous partirez, pour chaque exercice, du
fichier SQUELET.ASM.
1) Allumage d'une LED
Cet exercice consiste à allumer la LED n°1. Elle est commandée par le bit 0 du port A (PA0).
Vous devrez donc écrire un sous-programme "init_ports" afin d'initialiser le port A comme
il faut (bit 0 en sortie push-pull).
La figure suivante indique le câblage de la sortie en push-pull :
S=0 -> éteint,
S=l -> allumé
Puis vous écrirez un sous-programme "allume_LED" qui allume la LED voulue sans
allumer les autres.
Votre programme principal devra donc appeler "init_ports" puis "allume__LED" et boucler à
1'infini pour ne pas s'arrêter (s'il s'arrête, l'état des ports n'est plus garanti et la LED peut
s'éteindre).
L'organigramme suivant illustre 1'architecture de ce programme :
Début
Début
In it_ports
Appel
In it_ports
In itial isation des
re gistres D DR et OR
du port
Appel
allume_ LE D
Fin
In it_ports
- 27 -
2) Allumage de plusieurs LEDs
Cet exercice consiste à allumer une LED sur deux (LEDs de n° impair). Vous allumerez donc
celles qui sont commandées par les bits 0, 3 et 7 du port A (sorties push-pull) et par le bit 5
du port B (sortie push-pull).
Vous devrez donc compléter le sous-programme "init_ports" pour initialiser les ports A et
B comme il faut (bits correspondants en sorties push-pull).
Puis vous écrirez un sous-programme "allume_impair" qui allume l'ensemble des LEDs
impaires.
Votre programme principal devra donc appeler "init_ports ", puis "allume__impair" et
boucler à l'infini pour ne pas s'arrêter.
L'organigramme de ce programme est sensiblement identique à celui de 1'exercice sur
l'allumage d'une LED.
2) Clignotement des LEDs
Cet exercice consiste à allumer les LEDs impaires (les LEDs paires étant éteintes), à attendre
0,5 secondes, puis à 1es éteindre et à allumer les LEDs paires, à attendre à nouveau 0,5
secondes et à recommencer.
Vous devrez donc compléter le sous-programme "init_ports" pour initialiser les ports A et
B comme il faut .
Puis vous écrirez deux sous-programmes "allume_impair" et "allume_pair" qui allument
les LEDs voulues sans allumer les autres et un sous-programme "attend_500ms" qui
effectue une temporisation de 0,5 secondes.
Votre programme principal devra donc appeler "init_ports", puis successivement
"allume_impair", "attend_500ms", " allume_pair ", "attend_500ms" et boucler sur
"allume_impair" pour recommencer.
Remarque : Un sous-programme de temporisation est un sous-programme qui exécute des
opérations "inutiles" pendant le temps désiré, soit par des boucles (parfois imbriquées) soit
par d'autres méthodes. La durée de temporisation se trouve en calculant le nombre de cycles du
sous-programme (la documentation des instructions donne le nombre de cycles de chaque
instruction), sachant que le µcontrôleur ST7Lite2 effectue 1.000.000 cycles par seconde
lorsqu'il est cadencé par son oscillateur RC interne. A noter qu'en programmant les bits
d'options, cette fréquence peut être multipliée par 4 ou 8 par une PLL interne.
Dans votre rapport, vous indiquerez le calcul du nombre de cycles de votre sous-programme
de temporisation.
- 28 -
Chapitre 6 Les afficheurs 7 segments
Dans ce chapitre, nous allons utiliser les ports d'entrées/sorties du µcontrôleur ST7Lite2
pour commander l'affichage de chiffres et de lettres sur les afficheurs 7 segments.
Nous utiliserons pour cela une bibliothèque de fonctions permettant de commander le
composant MAX7219 de la maquette, qui permet de gérer 4 afficheurs simultanément
(mémorisation et affichage des valeurs).
Dans chacun des exercices suivants, il faudra donc inclure au projet les fichiers
MAX7219.ASM et MAX7219. INC qui définissent cette bibliothèque.
L'utilisation de la bibliothèque d'affichage se fait de la façon suivante :
1. Modification du sous-programme "init_ports" :
- configuration du port SPI (liaison série synchrone) pour le dialogue avec le
MAX7219. La configuration de ce port se fait par les registres SPI Control/Status
Register (SPISR) et SPI Control Register (SPICR). Leur signification est expliquée en
détail dans la documentation technique du ST7.
Le registre SPISR est un registre de 8 bits à initialiser à la valeur $03.
Le registre SPICR est un registre de 8 bits défini comme suit :
bit 7
bit 6
bit 5
bit 4
bit 3
bit 2
bit 1
bit 0
SPIE
SPE
SPR2
MSTR
CPOL
CPHA
SPR1
SPRO
- SPIE indique le mode de fonctionnement avec ou sans interruption du SPI; ce bit doit
être positionné à 0 (interrupt disabled).
- SPE indique 1'utilisation ou non du port SPI sur les sorties correspondantes du ST7, ce
bit doit être positionné à 1 (SPI connected to external pins).
- SPR[2 :0] indique la fréquence utilisée pour la liaison SPI; la fréquence doit être fcpu/8.
Ces bits doivent être positionnés à 0.
- MSTR indique le mode maître / esclave; ce bit doit être positionné à 1 (mode maître).
- CPOL indique la polarité de 1'horloge utilisée; ce bit doit être positionné à 1.
- CHPA indique la phase de 1'horloge utilisée; ce bit doit être positionné à 1.
Il faut aussi configurer le port PB2 en mode sortie Push-pull.
2. Appel du sous-programme "MAX7219_Init" pour initialiser le MAX7219.
3. Appel du sous-programme "MAX7219_Clear" pour effacer les 4 afficheurs.
- 29 -
4. Appel du sous-programme "MAX7219_DisplayChar" pour afficher une valeur :
- 1'afficheur sélectionné (de 1 à 4) doit être précisé dans la variable "DisplayChar_Digit",
- la valeur à afficher doit être précisée dans la variable "DisplayChar_Character",
- ces deux variables doivent être positionnées avant 1'appel du sous-programme.
1) Affichage d'une valeur sur un afficheur
Cet exercice consiste à afficher une valeur tenant sur un chiffre sur l'afficheur de droite. La
valeur à afficher sera positionnée dans une variable "valeurAffiche" à déclarer dans la zone
des variables et à initialiser au début du programme principal.
2) Réalisation d'un compteur modulo 100 (en décimal)
Cet exercice consiste à réaliser un compteur de 0 à 99 en base 10, avec affichage de la valeur
sur deux afficheurs et temporisation de 500 ms entre chaque incrémentation. La valeur du
compteur sera mémorisée dans une variable "compteur" à déclarer dans la zone des variables.
Arrivé à 99, le compteur repart à 0.
- 30 -
Chapitre 7 Les interruptions
1) Compteur modulo 100 avec arrêt
Cet exercice consiste à reprendre 1'exercice 2 du chapitre 6 et à y ajouter la gestion de
1'appui sur les boutons poussoirs 1 et 2 avec les interruptions :
- lorsque le compteur est arrêté, 1'appui sur le bouton 1 démarre le compteur,
- lorsque le compteur tourne, 1'appui sur le bouton 2 arrête le compteur.
L'appui sur un bouton poussoir provoque un état bas (0V) sur 1'entrée du ST7 correspondante.
Sinon, cette entrée est à l'état haut (5V).
Le bouton poussoir 1 est connecté à PA3 et le bouton poussoir 2 à PB0 mais n'oubliez pas de
configurer correctement les cavaliers (cf. chapitre 4).
Le ST7 admet 4 interruptions externes différentes, dénommées ei3, ei2, ei1 et ei0. Au niveau
logiciel, la prise en compte de ces interruptions est gérée par 2 registres : External Interrupt
Control Register (EICR) et External Interrupt Selection Register (EISR).
Le EICR est un registre de 8 bits, défini comme suit :
bit 7
bit 6
bit 5
bit 4
bit 3
bit 2
bit 1
bit 0
IS31
IS30
IS21
IS20
IS11
IS10
IS01
IS00
Les bits ISx1 et ISx0 définissent la sensibilité de l'interruption eix (cf tableau ci-dessous) :
ISx1
0
0
1
1
ISx0
0
1
0
1
Sensibilité
Front descendant et état bas
Front montant seul
Front descendant seul
Front montant et descendant
Le EISR est un registre de 8 bits, défini comme suit :
bit 7
bit 6
bit 5
bit 4
bit 3
bit 2
bit 1
bit 0
ei31
ei30
ei21
ei20
ei11
ei10
ei01
ei00
Les bits eix1 et eix0 définissent la pin du ST7 utilisée pour générer l'interruption (cf. les 4
tableaux suivants) :
ei31
0
0
1
1
ei30
0
1
0
1
I/O pin
PB0
PB1
PB2
Not used
- 31 -
ei21
0
0
1
1
ei20
0
1
0
1
I/O pin
PB3
PB4
PB5
PB6
ei11
0
0
1
1
ei10
0
1
0
1
I/O pin
PA4
PA5
PA6
PA7
ei01
0
0
1
1
ei00
0
1
0
1
I/O pin
PA0
PA1
PA2
PA3
Vous devez donc :
initialiser le ST7 avec autorisation des interruptions externes correspondant aux
ports reliés aux boutons poussoirs. Pour cela, il faut modifier le sous-programme
"init_ports" de la façon suivante :
(a) programmation correcte des registres EICR et EISR,
(b) exécution de 1'instruction RIM qui autorise les interruptions.
initialiser les ports du ST7 correspondant aux boutons poussoirs en entrées pull-up
avec interruption.
créer, dans la zone de déclaration des sous-programmes d'interruption, les 2 sousprogrammes de gestion des interruptions. Ces sous-programmes seront appelés à
chaque nouvelle interruption, c'est à dire à chaque nouvel appui sur un des deux
boutons poussoirs. Ces sous-programmes doivent :
(a) modifier 1'état du compteur (arrêt ou marche, selon le sous-programme).
Pour cela, le mieux est de définir une variable qui va indiquer 1'état du
compteur : marche ou arrêt et qui est mise à jour dans le sous-programme,
(b) revenir au programme avec l'instruction IRET.
modifier la zone de déclaration des vecteurs d'interruption pour associer les sousprogrammes créés avec les vecteurs d'interruption "extx_it". Par défaut, ces derniers
(comme la plupart des autres vecteurs d'interruption) sont associés au sousprogramme "dummy_rt" qui ne fait rien.
modifier le programme principal pour prendre en compte 1'état du compteur :
- si le compteur est en marche, on compte, on temporise et on affiche,
- si le compteur est arrêté, on temporise et on affiche uniquement.
- 32 -
Chapitre 8 Le timer
1) Compteur modulo 100 avec timer
Cet exercice consiste à reprendre 1'exercice 2 du chapitre 6 sur la réalisation d'un
compteur modulo 100 avec affichage sur 2 afficheurs 7 segments, en remplaçant le sousprogramme de temporisation par 1'utilisation du timer "Lite Timer 2" du ST7.
Le Lite Timer 2 est un timer 8 bits, dont le synoptique est donné ci-dessous. Il permet :
De compter en permanence, à la fréquence Fosc/32, de 0 à 249 (counter 1). Une
interruption peut être générée à chaque transition de 249 à 0,
De compter en permanence, à la fréquence Fosc/32, de la valeur contenue dans le
registre LTCARR à 255 (counter 2). Une interruption peut être générée à chaque
transition de 255 à (LTCARR),
De mesurer l'intervalle de temps entre 2 fronts (montants ou descendant) d'un signal
externe connecté au port PA0/LTIC (fonction dénommée : Input Capture).
LTCNTR
8 bits
LTARR
FOSC
8 bit Autoreload
Register
8 bit TIME
BASE
Counter2
MSB
0
0
0
0
0
When LTCNTR reach LTARR
0
TB2IE
TB2F
LSB
Flag Interrupt
To 12- Bit Auto reload
Timer
Div. = 32
Div by 2
1
8-Bit UP- Counter 1
LTIC
LTTB2
Interrupt request
LTCSR2
0
8-Bit
Input Capture Register = LTICR
LTCSR1
MSB
ICE
ICF
TB
TB1IE
LSB
TB1F
0
0
0
LTTB Interrupt Req
LTIC Interrupt Request
Pour votre besoin, vous allez utiliser le "counter 1" avec génération d'interruption. La
fréquence CPU (Fosc) étant de 1 MHz, le compteur effectue une transition de 249 à 0 toutes
les 8 ms. Pour cela, il faut initialiser correctement le registre LTCSR1 :
- 33 -
ICE = ICF = 0 (fonction "Input capture" non utilisée),
TB = 0 (une IT toutes les 8 ms),
TB1IE = 1 (IT autorisée),
TB1F = x (bit en lecture seule),
Bits 2-0 = 000
Pour attendre 500 ms, vous devez donc compter environ 62 interruptions. Vous réécrirez
donc, comme suit, le sous-programme "attend_500ms" :
Initialiser à 0 une variable "compte_IT",
Lancer le timer 2 (autorisation de l'IT : TB1IE = 1),
Attendre que compte_IT = 62,
Arrêter le timer (inhibition de l'IT : TB1IE = 0),
Sortir du sous-programme.
Le sous-programme d'interruption doit incrémenter compte_IT.
2) Pilotage d'un moteur
Le moteur de la carte se commande via un signal PWM (Pulse Width Modulation). Ce signal
est un créneau périodique, dont le rapport cyclique (Durée état haut/Période) donne la valeur
de contrôle.
Pour cela, il faut utiliser le timer 12 bits Autoreload et sa sortie PA2/ATPWM0 à relier par
cavalier au moteur (cf chapitre 4).
Ce timer permet de générer 4 sorties PWM et a également une fonction d'Input Capture. Ces
registres internes sont sur 12 bits. Son synoptique est le suivant :
Interrupt
Input Capture
OVF
Interrupt
Request
ATCSR
O
ICF
-
ICIE
CK1
CKO
OVF
OVFIE
CMPIE
F Ltimer
CNTR
F Counter
DCRO
Preload
32 MHz
DCRO
F CPU
Preload
CMPFO
CMP
Interrupt
Request
12-Bit UP Counter
12-Bit AUTO Reload
Counter
On OVF Event IF OE0=1
ATR
12-Bit Duty Cycle Value
CMPF0 bit
OP0 Bit
OE0 Bit
Polarity
Output
Control
Compare
To ICF bit
“ATCSR”
PWM
Generation
F PWM
12-bit Input Capture
- 34 -
PWM
Le signal généré dépend de l'initialisation des registres DCRx et ATR :
Counter
4096
DCR
ATR
PWM
OE =1
OPx=0
OE =1
OPx=1
Vous devez programmer comme suit les registres du timer :
ATCSR = $10 (horloge timer = horloge CPU),
ATRH : 4 MSB de la valeur de ATR,
ATRL : 8 LSB de la valeur de ATR,
PWMCR = $01 (sortie PWM0 sélectionnée),
PWM0CSR = $00 (si OP0 = 0) ou $02 (si OP0 = 1),
DCR0H : 4 MSB de la valeur de DCR,
DCR0L : 8 LSB de la valeur de DCR.
Pour plus de détails, vous pouvez consulter la data sheet du ST7Lite2.
Sachant que FCPU = 1 MHz, vous génèrerez :
1. un signal PWM de période 4 ms et de rapport cyclique 50%,
2. puis un signal PWM de fréquence 20 kHz et de rapport cyclique 25 %.
Vous vérifierez vos signaux PWM à l'oscilloscope.
- 35 -
Chapitre 9 Le convertisseur analogique-numérique
Pilotage du moteur par le potentiomètre
Vous reliez le potentiomètre à l'entrée analogique PB0/SS'/AIN0 du ST7, en positionnant
convenablement les cavaliers (cf. chapitre 4).
Ce potentiomètre permet de délivrer une tension continue, comprise entre 0V et 5V, à l'entrée
du CAN, canal 0.
Le CAN du ST7 peut acquérir jusqu'à 7 canaux multiplexés (AIN0 à AIN6) et réalise la
conversion analogique-numérique sur 10 bits. Son synoptique est donné ci-dessous :
EOC
SPEED
ADON
O
0
CH2 CH1 CH0
(ADC Control Status Register) ADCCSR
AIN
AIN
ANALOG
MUX
AIN
SAMPLE
&
HOLD
ANALOG TO DIGITAL
CONVERTER
AIN
(Data Register High) ADC DRH
D9 D8 D7 D6 D5 D4 D3 D2
(Data Register Low) ADC DRL
0
0
0
0
0
0
D0 D1
Pour utiliser le CAN, il faut :
choisir le canal d'acquisition (programmation des bits CH2-CH1-CH0 du registre
ADCCSR),
lancer la conversion (mise à 1 du bit ADON du registre ADCCSR),
attendre que la conversion soit achevée (le bit EOC du registre ADCCSR passe à 1),
lire le résultat de la conversion. Les 8 MSB sont lus dans le registre ADCDRH et les 2
LSB dans le registre ADCDRL. Remarque : l'action de lire le registre ADCDRH
remet à 0 le bit EOC.
Vous devez écrire un programme qui acquiert, continûment, sur 8 bits, la tension délivrée par
le potentiomètre et génère un signal PWM de rapport cyclique proportionnel à celle-ci (0V
=> 0%, 5V=> 100%). Vous déterminerez, en conséquence, la fréquence du signal PWM.
Puis vous complèterez l'exercice ci-dessus, en affichant sur les 7segments, la valeur de la
tension acquise avec une précision d'environ 0,3 V.
- 36 -
ANNEXE 1
ST7LITE2.ASM
st7/
;************************************************************************
; TITLE:
ST7FLite2.ASM
; AUTHOR:
CMG Microcontroller Application Team
; DESCRIPTION:
ST7FLite2 Registers and memory mapping
;
; Define here the micro ROM Size according to the sales type:
;
#define ST7FLite20
1
;=> no Data EEPROM
; #define ST7FLite25
1
;=> no Data EEPROM
; #define ST7FLite29
1
;=> Data EEPROM
;
;************************************************************************
;+------------------------------------------------------------------------+
;|
HARDAWRE REGISTERS
|
;+------------------------------------------------------------------------+
BYTES
; following addresses are 8 bit length
;********************************************************************
segment byte at 0-7F 'periph'
;********************************************************************
;**********************************************************************
;
I/O Ports Registers
;**********************************************************************
.PADR
.PADDR
.PAOR
DS.B
DS.B
DS.B
1
1
1
; port A data register
; port A data direction register
; port A option register
.PBDR
.PBDDR
.PBOR
DS.B
DS.B
DS.B
1
1
1
; port B data register
; port B data direction register
; port B option register
reserved0
DS.B
2
; unused
;**********************************************************************
;
Lite Timer Registers
;**********************************************************************
.LTCSR2
.LTCARR
.LTCNTR
.LTCSR1
.LTICR
DS.B
DS.B
DS.B
DS.B
DS.B
1
1
1
1
1
;
;
;
;
;
lite
lite
lite
lite
lite
timer
timer
timer
timer
timer
control/status register 2
auto reload register
counter register
control/status register 1
input capture register
;**********************************************************************
;
Auto reload timer registers
;**********************************************************************
.ATCSR
.CNTRH
.CNTRL
.ATRH
.ATRL
.PWMCR
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
1
1
1
1
1
1
;
;
;
;
;
;
Timer Control/Status register 1
Counter Register High
Counter Register Low
Auto-Reload Register High
Auto-Reload Register Low
PWM Output Control Register
.PWM0CSR
.PWM1CSR
.PWM2CSR
.PWM3CSR
.DCR0H
.DCR0L
.DCR1H
.DCR1L
.DCR2H
.DCR2L
.DCR3H
.DCR3L
.ATICRH
.ATICRL
.TRANCR
.BREAKCR
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
PWM 0 Control/Status Register
PWM 0 Duty Cycle Register High
PWM 0 Duty Cycle Register Low
Input Capture Register High
Input Capture Register Low
Transfer Control Register
Break Control Register
reserved1
DS.B
11
;
unused
;**********************************************************************
;
Watchdog Control register
;**********************************************************************
.WDGCR
DS.B
1
; Watchdog Control Register
;**********************************************************************
;
Flash Register
;**********************************************************************
.FCSR
DS.B
1
; flash control/satus register
;**********************************************************************
;
EEPROM Register
;**********************************************************************
.EECSR
DS.B
1
; data EEPROM control status register
;**********************************************************************
;
SPI Registers
;**********************************************************************
.SPIDR
.SPICR
.SPISR
DS.B
DS.B
DS.B
1
1
1
; SPI data I/O register
; SPI control register
; SPI status register
;**********************************************************************
;
ADC Registers
;**********************************************************************
.ADCCSR
.ADCDRH
.ADCDRL
Register
DS.B
DS.B
DS.B
1
1
1
; A/D control/status register
; ADC Data register
; ADC Amplifier Control register and Data Low
;**********************************************************************
;
ITC Registers
;**********************************************************************
.EICR
DS.B
1
; external interrupt control register
;**********************************************************************
;
MCC Registers
;**********************************************************************
.MCCSR
DS.B
1
; main clock control/status register
;**********************************************************************
;
Clock & Reset Registers
;**********************************************************************
.RCCR
.SICSR
DS.B
DS.B
1
1
; RC oscillator control register
; system integrity control/status register
reserved2
DS.B
.EISR
DS.B
1
1
;
unused
;
External Interrupt Selection Register
reserved3
DS.B
3
; 3 bytes unused
3Dh to 3Fh
;**********************************************************************
;
Dali Registers
;**********************************************************************
.DCMCLK
.DCMFA
.DCMFD
.DCMBD
.DCMCR
.DCMCSR
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
1
1
1
1
1
1
;
;
;
;
;
;
DALI
DALI
DALI
DALI
DALI
DALI
Clock Register
Forward Address Register
Forward Data Register
Backward Data Register
Control Register
Control/Status Register
reserved4
DS.B
3
; 3 bytes unused 46h to 48h
;**********************************************************************
;
AWU Registers
;**********************************************************************
.AWUPR
.AWUCSR
DS.B
DS.B
1
1
; AWU Prescaler Register
; AWU Control/Status Register
;**********************************************************************
;
DM Registers
;**********************************************************************
.DMCR
.DMSR
.DMBK1H
.DMBK1L
.DMBK2H
.DMBK2L
DS.B
DS.B
DS.B
DS.B
DS.B
DS.B
1
1
1
1
1
1
;
;
;
;
;
;
DM
DM
DM
DM
DM
DM
Control Register
Status Register
Breakpoint Register
Breakpoint Register
Breakpoint Register
Breakpoint Register
1
1
2
2
High
Low
High
Low
;**********************************************************************
segment byte at 80-17F 'ram0' ;Zero Page
;**********************************************************************
WORDS
; following addresses are 16 bit length
;**********************************************************************
segment byte at 180-1FF 'stack'
;**********************************************************************
;**********************************************************************
#ifdef ST7FLite29
segment byte at 1000-107F 'data eeprom'
#endif
;**********************************************************************
;**********************************************************************
segment byte at E000-FFDF 'rom'
;**********************************************************************
;**********************************************************************
segment byte at FFE0-FFFF 'vectit'
;**********************************************************************
end
ANNEXE 2
SQUELET.ASM
ST7/
;************************************************************************
; TITLE:
; AUTHOR:
; DESCRIPTION:
;************************************************************************
TITLE "SQUELET.ASM"
MOTOROLA
#include "ST7Lite2.INC"
;
; Enlever le commentaire si vous utilisez les afficheurs
#include "MAX7219.INC"
;************************************************************************
;
; ZONE DE DECLARATION DES SYMBOLES
;
;************************************************************************
;************************************************************************
;
; FIN DE LA ZONE DE DECLARATION DES SYMBOLES
;
;************************************************************************
BYTES
segment byte 'ram0'
;************************************************************************
;
; ZONE DE DECLARATION DES VARIABLES
;
;************************************************************************
;************************************************************************
;
; FIN DE LA ZONE DE DECLARATION DES VARIABLES
;
;************************************************************************
WORDS
segment byte 'rom'
;************************************************************************
;
; ZONE DE DECLARATION DES CONSTANTES
;
;************************************************************************
;************************************************************************
;
; FIN DE LA ZONE DE DECLARATION DES CONSTANTES
;
;************************************************************************
;************************************************************************
;
; ZONE DE DECLARATION DES SOUS-PROGRAMMES
;
;************************************************************************
;************************************************************************
;
; FIN DE LA ZONE DE DECLARATION DES SOUS-PROGRAMMES
;
;************************************************************************
;************************************************************************
;
; PROGRAMME PRINCIPAL
;
;************************************************************************
main:
boucl
JP
boucl
;************************************************************************
;
; ZONE DE DECLARATION DES SOUS-PROGRAMMES D'INTERRUPTION
;
;************************************************************************
dummy_rt:
IRET
; Procédure vide : retour au programme principal.
;************************************************************************
;
; ZONE DE DECLARATION DES VECTEURS D'INTERRUPTION
;
;************************************************************************
segment 'vectit'
SPI_it
lt_RTC1_it
lt_IC_it
at_timerover_it
at_timerOC_it
AVD_it
lt_RTC2_it
ext3_it
ext2_it
ext1_it
ext0_it
AWU_it
softit
reset
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
DC.W
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
dummy_rt
main
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
Adresse
FFE0-FFE1h
FFE2-FFE3h
FFE4-FFE5h
FFE6-FFE7h
FFE8-FFE9h
FFEA-FFEBh
FFEC-FFEDh
FFEE-FFEFh
FFF0-FFF1h
FFF2-FFF3h
FFF4-FFF5h
FFF6-FFF7h
FFF8-FFF9h
FFFA-FFFBh
FFFC-FFFDh
FFFE-FFFFh
END
;************************************************************************
ANNEXE 3
Créer un projet ST7 en 10 leçons
Introduction
Le kit de développement de ST Microelectronics dédié aux microcontrôleurs de la
famille ST7, permet de créer très simplement des projets avec un environnement
graphique du même style que Microsoft Visual Basic.
Ce livret vous guidera pas à pas dans la création d’un tel projet.
Chaque étape sera détaillée et illustrée de captures d’écran afin de faciliter votre
lecture.
Après avoir lu ce petit guide, vous serez capable de créer votre premier projet.
Etape 1 : Préliminaires
La première étape consiste à créer le répertoire dans lequel se trouvera votre projet.
Dans le cadre du mini-projet de microcontrôleur, on pourrait par exemple créer
l’arborescence de répertoires suivante :
Z:\Microcontroleur\ Exo_1\
Exo_2\
…
Exo_N\
Projet\
où chaque sous-répertoire Exo_i du répertoire Microcontroleur contient la
réalisation d’un exercice du mini-projet, et le sous-répertoire Projet contient le
projet final.
Remarque :
ceci est bien entendu un exemple ; vous avez libre choix dans la
création de votre arborescence de fichiers. Cependant, essayez de
donner des noms de moins de 8 caractères.
Chaque fois que vous commencerez un nouveau projet ou un nouvel exercice, il
faudra donc créer le répertoire associé.
Puis, il faudra copier dans ce répertoire les fichiers constituant le point de départ de
votre projet ; vous ne partirez pas de zéro à chaque nouveau projet (il est inutile de
réinventer la roue).
Ces fichiers sont les suivants :
ST7Lite2.asm
ST7Lite2.inc
MAX7219.asm
MAX7219.inc
Squelet.asm
définit le modèle de microcontrôleur
fichier à inclure dans votre programme (si votre projet
concerne un modèle ST7Lite2)
définit ce qui concerne le gestionnaire d’afficheurs 7
segments
fichier à inclure dans votre programme (si votre projet
doit faire de l’affichage sur les afficheurs 7 segments)
point de départ de votre programme. Il faudra
renommer ce fichier avec le nom de votre projet.
Etape 2 : Démarrage du logiciel
Le logiciel se lance à partir du menu suivant de Windows :
Démarrer
Programmes
Softec Microsystems
InDART-STX ST7
STVD7 for InDART-STX
La fenêtre principale de l’environnement de développement est la suivante :
zone
de
projet
zone d’affichage des fichiers sources
zone d’affichage des messages d’information
Les trois zones principales de ce logiciel sont les suivantes :
Zone de projet
C’est la fenêtre où se trouve l’arborescence du projet.
C’est également la zone qui affiche la liste des fichiers
sources du projet.
Zone des sources
C’est la fenêtre dans laquelle sont visualisés et édités les
fichiers sources.
Zone d’information C’est la fenêtre dans laquelle sont affichés les messages
d’information concernant la compilation, le debug …
Etape 3 : Création du Workspace
Pour créer un nouveau projet, il faut créer ce qui s’appelle un Workspace. Pour cela,
cliquer dans le menu File / New workspace… puis choisir Create workspace and
project, ce qui ouvre la fenêtre suivante :
Saisissez alors le nom que vous voulez donner au Workspace dans le champ
Workspace filename, par exemple Exo_1, puis le répertoire de destination du projet
dans le champ Workspace location (soit en le tapant, soit avec le bouton parcourir ),
par exemple Z:\Microcontroleur\Exo_1.
Remarque :
le répertoire est celui que vous avez normalement créé lors de la première
étape. (Si vous indiquez un nom de répertoire qui n’existe pas, il vous sera
proposé de le créer.)
Cliquez sur le bouton OK. La fenêtre suivante est affichée :
- Dans Project filename, entrez par défaut le même nom que celui donné au
Workspace. (Un Workspace peut contenir plusieurs Projects, dans ce cas les noms
pourraient être différents.)
- Dans Project location, laissez le répertoire proposé, qui est celui que vous avez
indiqué dans la fenêtre précédente.
- Dans Toolchain et Toolchain root, ne modifiez rien.
Cliquez sur le bouton OK. Dans la fenêtre suivante, indiquez la référence du
microcontrôleur que vous allez utiliser (ST7FLITE20).
Vous devez alors obtenir ceci (mis à part les noms du Workspace et du Project qui
dépendent bien sûr de ce que vous avez indiqué précédemment):
Etape 4 : Ajout des fichiers sources
Faire apparaître sous le nom du Projet, les répertoires Source Files, Include Files, et
External Dependencies :
1 – clic gauche
2 – clic droit puis
Add Files to Folder…
Par un clic droit suivi de Add Files to Folder, ajouter dans Source Files les fichiers
Exo_1.asm (par exemple, si c’est le nom que vous avez choisi), max7219.asm (si vous
devez utiliser l’afficheur 7 segments), et st7lite2.asm, puis ajouter dans Include
Files les fichiers max7219.inc (même remarque que précédemment), et st7lite2.inc.
La liste des fichiers du projet apparaît alors comme dans la fenêtre suivante :
Il suffit dès lors de double cliquer sur le nom d’un fichier pour l’éditer dans la fenêtre
d’affichage des fichiers sources.
Etape 5 : Création du programme
C’est l’étape où il y a le plus de travail à fournir mais où il y a peu d’aide dans ce
document.
En effet, il s’agit de construire le programme à partir du fichier Squelet.asm que vous
aurez bien entendu renommé (par exemple en Exo_1.asm).
Etape 6 : Utilisation de l’aide
Pour le développement de vos programmes, vous aurez besoin de connaître le
langage assembleur des microcontrôleurs ST7 avec ses mots clés et ses modes
d’adressage. Vous avez bien entendu à votre disposition la documentation papier,
mais aussi l’aide en ligne. Cette dernière est accessible à partir du menu :
Help / ST7 Instruction Set Contents …
Cette documentation est assez complète, avec des exemples, et permet de trouver à
coup sûr la réponse à sa question.
Etape 7 : Compilation du projet
Une fois que vous pensez avoir fini votre programme, ou juste une partie que vous
voulez tester, il faut passer à l’étape de compilation. C’est une étape que vous
connaissez pour l’avoir pratiquée dans d’autres langages de programmation comme
le C.
En assembleur comme en C, la compilation sert à transformer les fichiers sources
en fichiers objets. Elle est immédiatement suivie d’une phase d’édition de lien pour
créer le fichier exécutable.
Compiler votre projet (en fait le terme plus approprié est « construire » car il s’agit
de compiler puis de faire l’édition de liens) se fait très simplement à partir du menu
Build / Build.
Le résultat de la compilation est affiché dans la fenêtre d’information, dans la partie
basse du logiciel, sous l’onglet Build.
Attention :
Pensez systématiquement à vérifier les messages d’erreur avant de
passer à l’étape suivante, afin de corriger les éventuelles erreurs de
programmation.
Etape 8 : Configuration du debug
Si aucune erreur ne s’est produite lors de la compilation du projet, vous allez pouvoir
passer à l’étape suivante : le test ou debug du programme.
Remarque :
Pour effectuer l'étape suivante, le câble USB doit être branché entre le
PC et la carte InDART ainsi que le câble ISP entre la carte inDART et
la carte d'apprentissage. Cette dernière doit également être alimentée.
Pour lancer le debuggeur, cliquez sur le bouton "Start Debugging" (bouton circulaire
bleu avec D à l'intérieur). Vous pouvez également effectuer cette opération par le menu
Debug / Start Debugging. Ceci ouvre la fenêtre suivante :
Après confirmation, la fenêtre ci-dessous s’affiche :
Cliquer sur le bouton Set Option Bytes pour configurer le mode de fonctionnement
du microcontrôleur (type d’oscillateur utilisé, utilisation ou non de la PLL, utilisation
ou non du chien de garde, etc…).
Remarque :
cette étape de configuration n’est à effectuer qu’une seule fois par
projet, lors de la première simulation.
Dans la fenêtre qui s’ouvre alors, certains champs sont à modifier avant de poursuivre.
Vous devez avoir la configuration indiquée ci-dessous :
à modifier
(impératif)
à modifier
(facultatif)
• Les champs 32MHz PLL et PLL doivent être modifiés. (Sinon, la fréquence de
l’horloge est multipliée en interne. Ceci n’est pas préjudiciable au bon
fonctionnement du micro-contrôleur, mais va seulement modifier la vitesse
d’enchaînement des instructions.)
• Le champ Watchdog Activation doit impérativement être positionné sur
Software. (Ceci permet de désactiver le chien de garde. Si ce n’est pas fait, vous
ne pourrez pas tester vos programmes.)
Etape 9 : Debug du programme
A présent, vous êtes dans le debuggeur intégré à l’environnement de développement.
Vous pouvez alors placer des points d’arrêt (ou breakpoint, 2 au maximum) où vous
voulez, exécuter votre programme en mode pas à pas, visualiser les registres du ST7 ou
des variables…, comme dans tout bon debuggeur.
Remarque :
ce document n’est pas un manuel du debuggeur donc si vous voulez
plus d’information, référez-vous au manuel intégré au logiciel.
Cette étape permet de vérifier que le programme marche comme prévu. Si ce n’est pas
le cas, il faut revenir à l’étape 5 pour effectuer les modifications nécessaires avant de
retester…
Etape 10 : C’est fini !
Vous avez créé votre projet. Il reste maintenant à le faire fonctionner correctement, en
répétant les étapes 5, 7 et 9 jusqu’à obtenir le résultat demandé.
Bon courage … et de la persévérance !
ANNEXE 4
Résumé du jeu d'instructions du ST7
Clear and Load Instructions:
Arithmetic Instructions:
CLR
Clear
ADC Addition with Carry
LD
Load
ADD Addition
MUL Multiply
Stack Operations:
SBC
Subtraction with Carry
POP
SUB
Subtraction
from Stack
PUSH Push into the Stack
RSP
Reset Stack Pointer
Shift and Rotate Instructions:
RLC
Rotate Left Through Carry
Increment/Decrement Instructions:
RRC Rotate Right Through Carry
DEC Decrement
SLA/SLL Shift Left Arithmetic
INC
SRA
Shift Right Arithmetic
SRL
Shift Right Logical
Increment
Compare and Test Instructions:
SWAP Nibbles
BCP
Logical Bit Compare
CP
Compare
Unconditional Jump or Call Instructions:
TNZ
Test for Negative or Zero
CALL Subroutine Absolute
CALLR Subroutine Relative
Logical Operations:
JP
Jump Absolute
AND
Logical And
JRA
Jump Relative Always
CPL
Logical 1-Complement
NOP No Operation
NEG Negate
OR
Logical Or
XOR Logical Exclusive Or
RET
Return from Subroutine
Conditional Jump Instructions:
JRC
Jump Relative if Carry
Bit Operations:
JREQ Jump Relative if Equal
BRES Bit Reset
JRF
Jump Relative if False
BSET Bit Set
JRH
Jump Relative if Half-Carry
BTJF Bit Test and Jump if False
JRIH Jump Relative if Interrupt High
BTJT Bit Test and Jump if True
JRIL Jump Relative if Interrupt Low
JRM Jump Relative if Interrupt Mask
Interrupt Management:
JRMI Jump Relative if Negative
HALT
JRNC Jump Relative if No Carry
IRET Interrupt Return
JRNE Jump Relative if Not Equal
TRAP Software Interrupt
JRNH Jump Relative if No Half-Carry
WFI
JRNM Jump Relative if No Interrupt Mask
Wait for Interrupt
JRPL Jump Relative if Positive or Zero
Condition Code Register Management:
JRT
Jump Relative if True
RCF
Reset Carry Flag
JRUGE Jump Relative if Unsigned Greater or Equal
RIM
Reset Interrupt Mask
JRUGT Jump Relative if Greater Than
SCF
Set Carry Flag
JRULE Jump Relative if Lower or Equal
SIM
Set Interrupt Mask
JRULT Jump Relative if Lower Than

Mini Projet Microcontrôleur ST7

Transcription

Documents pareils

Demande de droit de réponse auprès du journal Le

l`éditorial de Michèle TABAROT du mois d`octobre 2015

Pilotage du moteur pas à pas du pousse

Réalisation de l`Interopérabilité au sein du Gouvernement

Télécharger

Menu d`activités pour l`utilisation de clips chanson en classe de FLE

Liaison série RS232 entre le Pic et un PC

Loi SRU : instauration d`un droit de rétractation ou de réflexion de 7

Fiche technique DVBS-28060 PARALLAX INTERFACE