Mini Projet Microcontrôleur ST7 - lionel.goub.free.frlionel.goub.free.fr/==COURS==/N3/Electronique/TP%20microcontr%F4... · Au cours de ce mini-projet , vous développerez tout d'abord

Mini projet Microcontrôleur ST7

- 1 -

�

�

�

�

�

Mini Projet

Microcontrôleur ST7 �

Eric RICHARD Février 2006


- 2 -


- 3 -

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 ST7LITE2.ASM Annexe 2 SQUELET.ASM Annexe 3 Créer un projet ST7 en 10 leçons Annexe 4 Résumé du jeu d'instructions du ST7


- 4 -


- 5 -

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.


- 6 -

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.


- 7 -

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).


- 8 -

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�


- 9 -

�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� DS.B� � 1� ;� variable�d'un�octet�var2� DS.W�� 1� ;� variable�d'un�mot�(c'est�à�dire�2�octets)�var3� DS.B� � 10� ;� tableau�de�10�octets�var4� DS.W�� 5� ;� 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� DC.B��7�� ;��constante�7�cst2� DC.W��$1234� � ;��constante�hexadécimale�1234h�cst3� DC.B��10,4,13,7,90� ;��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��


- 10 -

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�:�� RSP� � ;�initialisation�du�pointeur�de�pile�� …�boucl� …�� …�� JP� 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 sous-programmes 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 sous-programme 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. �


- 11 -

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� EQU� 10�Hexa� EQU� $10�Mask� EQU� %10100011�� …�� LD� A,#Ndoigts� ;�A�est�chargé�avec�la�valeur�10�� LD� A,#Hexa� ;�A�est�chargé�avec�la�valeur�hexadécimale�10h�� LD� A,#Mask� ;�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.


- 12 -

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� � ;�réservation�de�50�caractères�à�l'adresse�logique�Phrase�� …�� LD� X,#4� � ;�on�charge�la�valeur�4�dans�X�� LD� 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.


- 13 -

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)��


- 14 -

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� 1�� …�� LD� A,ma_variable� ;�direct�court��2. Ecriture d'une valeur dans une variable ma_valeur� dc.b� $56�� …�ma_variable� ds.b� 1�� …�� LD� A,#ma_valeur� ;�immédiat�� LD� ma_variable,A� ;�direct�court 3. Lecture d'une valeur d'un tableau de variables (ou de constantes)

mon_tableau� ds.b� 10�� …�� LD� X,#5� � � ;�immédiat�� LD� A,(mon-tableau,X)�;�indexé�avec�décalage�court


- 15 -

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 :


- 16 -

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.

PC�de�développement

Câble�ISP

ST5-ST7�Training�board

Carte�InDart

Cordon�USB


- 17 -

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.


- 18 -

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 :

compte > 9 ?

Début

compte = 0

compte = compte + 1

OUI NON

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. 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 :


- 19 -

X = 0 ?

Début

somme = 0X=20

somme = somme + XX = X - 1

OUI NON

4) Créer et appeler des sous-programmes Comme dans les langages évolués, l'assembleur permet de faire des appels à des sous-programmes (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. Tester le programme avec le débogueur en mode pas à pas afin de vérifier son bon fonctionnement. Remarque : un retour de sous-programme se fait avec 1'instruction RET. L'organigramme suivant illustre 1'architecture de ce programme :


- 20 -

X = 0 ?

Débutcalcule_somme

somme = 0X=A

somme = somme + XX = X - 1

OUI NON

Fincalcule_somme

Début

A = 23

Appelcalcule_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.


- 21 -

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


- 22 -

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 re-testerez 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

Registre PADDR 0 1 0 0 1 0 0 1

Cela se fera par les instructions suivantes : Init_PADDR� EQU� %01001001�� …�� LD� A,#Init_PADDR�� LD� PADDR,A� car on ne peut pas charger directement un registre autre que A, X et Y (voir détail des instructions).


- 23 -

Cela peut également se faire par 1'ensemble des instructions suivantes (beaucoup moins lisible et moins rapide) : � � BSET� PADDR,#0�� BRES�PADDR,#1�� BRES�PADDR,#2�� BSET� PADDR,#3�� BRES�PADDR,#4�� BRES�PADDR,#5�� BSET� PADDR,#6�� BRES�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 Sortie

OR= 0 OR= 1 OR= 0 OR= 1

PA7:0

Flottant

Pull-up avec ou sans IT

Open drain

Push-pull

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").


- 24 -

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� A,PADR� ;�lecture�du�port�A�et�mémorisation�dans�le�registre�A�� OR� A,#$08�� ;�on�force�à�1�le�bit�3�du�registre�A�� LD� PADR,A� ;�on�écrit�la�valeur�à�envoyer�sur�le�port�A� En faisant cela, on a juste modifié le bit 3 du port PADR.


- 25 -

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é� N°�pin� N°�pin�JP2�� ST7� ��

PA0/LTIC� LED1� 13� 6�PA1/ATIC� LED2� 12� 7�

PA2/ATPWM0� Moteur� 11� 4�PA3/ATPWM1� LED3/Buzzer/Poussoir1� 10� 13�PA4/ATPWM2� LED4� 9� 14�

PA5/ATPWM3/ICCDATA� Réservé�ISP� 8� 15�PA6/MCO/ICCCLK/BREAK� Réservé�ISP� 7� 16�

PA7� LED5� 6� 17�PB0/SS'/AIN0� Potentiomètre/Poussoir2/In1� 19� 5�PB1/SCK/AIN1� Gestion�Afficheurs�:CK�SPI� 20� 3�PB2/MISO/AIN2� Gestion�Afficheurs�:�Load�Max� 1� 1�PB3/MOSI/AIN3� Gestion�Afficheurs�:MOSI� 2� 2�PB4/CLKIN/AIN4� LED6/In2� 3� 10�

PB5/AIN5� LED7� 4� 11�PB6/AIN6� LED8� 5� 12�RESET� Poussoir�RESET� 18� ��


- 26 -

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) ISP�ST5�(J1)�

IA1�

Reset�ST7�Reset�ST5�

W1 W2 W3 W4 W5 W6

W7

B1�

JP2

Poussoir�1

Poussoir�2�


- 27 -

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

Appelallume_ LE D

DébutIn it_ports

In itial isation desregistres DDR et OR

du port

FinIn it_ports

AppelIn it_ports


- 28 -

�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.


- 29 -

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 :

- 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.

bit 7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 bit 0 SPIE SPE SPR2 MSTR CPOL CPHA SPR1 SPRO


- 30 -

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.


- 31 -

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 : Les bits ISx1 et ISx0 définissent la sensibilité de l'interruption eix (cf tableau ci-dessous) :

ISx1 ISx0 Sensibilité 0 0 Front descendant et état bas 0 1 Front montant seul 1 0 Front descendant seul 1 1 Front montant et descendant

Le EISR est un registre de 8 bits, défini comme suit : 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 ei30 I/O pin 0 0 PB0 0 1 PB1 1 0 PB2 1 1 Not used

bit 7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 bit 0 IS31 IS30 IS21 IS20 IS11 IS10 IS01 IS00

bit 7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 bit 0 ei31 ei30 ei21 ei20 ei11 ei10 ei01 ei00

isen

Texte souligné

isen

Texte souligné


- 32 -

ei21 ei20 I/O pin

0 0 PB3 0 1 PB4 1 0 PB5 1 1 PB6

ei11 ei10 I/O pin

0 0 PA4 0 1 PA5 1 0 PA6 1 1 PA7

ei01 ei00 I/O pin

0 0 PA0 0 1 PA1 1 0 PA2 1 1 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 sous-programmes 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 sous-programmes 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 sous-programme "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.

isen

Texte souligné

isen

Texte souligné

isen

Texte souligné

isen

Texte souligné


- 33 -

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 sous-programme 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). 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 :

MSB� LSB�

FOSC�

LTIC� 8-Bit��Input�Capture�Register�=�LTICR�

8-Bit�UP-�Counter�1�0�

1�Div�by��2�

To�12-�Bit�Auto�reload�Timer�

LTTB�Interrupt�Req

LTIC�Interrupt�Request�

8�bit��Auto-reload�

Register�

LTARR�

8�bit��TIME�BASE�

Counter2�

8�bits� MSB� LSB�TB2IE��0� �0� �0� �0� �0� �0� TB2F�

When�LTCNTR�reach�LTARR� �Flag�Interrupt�

LTTB2�Interrupt�request�

��0��ICE� ��ICF� ��TB� ��TB1IE� �TB1F� ��0� ��0�

LTCNTR�LTCSR2�

LTCSR1�

Div.�=�32�


- 34 -

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 :

ATR�

CK1��O� CMPIE�OVFIE�OVF�-� ICIE� CKO��ICF�

ATCSR�

PWM

OVF��Interrupt�Request�

CMPFO�

�CMP��Interrupt�Request�

��F�Ltimer�

F�CPU�

F�Counter�12-Bit�UP�Counter�

CNTR�

12-Bit�AUTO�Reload�Counter�Preload� Preload�

DCRO DCRO

12-Bit�Duty�Cycle�Value�On�OVF�Event�IF�OE0=1�

Compare�CMPF0�bit�PWM��

Generation� F�PWM� Polarity�

OP0�Bit�

Output��Control�

OE0�Bit�

�12-bit�Input�Capture�

�

32�MHz�

To�ICF�bit�“ATCSR”�

��Interrupt��Input�Capture�


- 35 -

Le signal généré dépend de l'initialisation des registres DCRx et ATR : 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.

4096DCR

ATR

Counter

PWM

OE =1OPx=0OE =1OPx=1


- 36 -

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 :

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.

��

ANALOG�TO�DIGITAL�CONVERTER

��SAMPLE�

&��HOLD�

ANALOG�

MUX�

AIN(ADC�Control�Status�Register)�ADCCSR�

AIN

AIN

AIN

SPEED��

EOC� ADON��O� ��0� CH2� CH1� CH0�

(Data�Register�High)�ADC�DRH�

(Data�Register�Low)�ADC�DRL�

��D2��D3��D4��D5��D6��D7��D8��D9�

��D1��D0��0��0��0��0��0��0�


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� � � DS.B� � � � 1� � � � � � � ;� port� A� data� register�.PADDR� � DS.B� � � � 1� � � � � � � ;� port� A� data� direction� register�.PAOR� � � DS.B� � � � 1� � � � � � � ;� port� A� option� register��.PBDR� � � DS.B� � � � 1� � � � � � � ;� port� B� data� register�.PBDDR� � DS.B� � � � 1� � � � � � � ;� port� B� data� direction� register�.PBOR� � � DS.B� � � � 1� � � � � � � ;� port� B� option� register��reserved0� � � � �� DS.B� � � � 2� � � ;� unused��;**********************************************************************�;� � Lite� Timer� Registers�;**********************************************************************�� .LTCSR2� DS.B� 1� ;� lite� timer� control/status� register� 2�.LTCARR� DS.B� 1� ;� lite� timer� auto� reload� register�.LTCNTR� DS.B� 1� ;� lite� timer� counter� register�.LTCSR1� DS.B� 1� ;� lite� timer� control/status� register� 1�.LTICR� DS.B� 1� ;� lite� timer� input� capture� register��;**********************************************************************�;� � Auto� reload� timer� registers�;**********************************************************************��.ATCSR� � DS.B� � 1� � � � ;� Timer� Control/Status� register� 1�.CNTRH� DS.B� 1� ;� Counter� Register� High�.CNTRL� DS.B� 1� ;� Counter� Register� Low� �.ATRH� � DS.B� 1� � � � � ;� Auto-Reload� Register� High�.ATRL� � DS.B� 1� ;� Auto-Reload� Register� Low�.PWMCR� DS.B� 1� ;� PWM� Output� Control� Register�


.PWM0CSR� � DS.B� 1� ;� PWM� 0� Control/Status� Register� � �




.DCR0H� DS.B� 1� ;� PWM� 0� Duty� Cycle� Register� High�

.DCR0L� DS.B� 1� ;� PWM� 0� Duty� Cycle� Register� Low� � � �







.ATICRH� DS.B� 1� ;� Input� Capture� Register� High� �

.ATICRL� DS.B� 1� ;� Input� Capture� Register� Low�

.TRANCR� DS.B� 1� ;� Transfer� Control� Register�

.BREAKCR� � DS.B� 1� ;� 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� DS.B� 1� � ;� SPI� data� I/O� register�.SPICR� DS.B� 1� � � � � � � ;� SPI� control� register�.SPISR� DS.B� 1� � � � � � � ;� SPI� status� register��;**********************************************************************�;� � ADC� Registers�;**********************************************************************�� .ADCCSR� DS.B� 1� ;� A/D� control/status� register�.ADCDRH� DS.B� 1� ;� ADC� Data� register�.ADCDRL� DS.B� 1� ;� ADC� Amplifier� Control� register� and� Data� Low�Register��


;**********************************************************************�;� � 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� � DS.B� 1� ;� RC� oscillator� control� register�.SICSR� DS.B� 1� ;� system� integrity� control/status� register��reserved2� �� DS.B� � � � 1� � � ;� � unused��.EISR� � DS.B� 1� ;� � External� Interrupt� Selection� Register��reserved3� � � � �� DS.B� � � � 3� � � � � � ;� 3� bytes� unused� 3Dh� to� 3Fh��;**********************************************************************�;� � � � � � � � � � � � � � � � � � � � � � � � Dali� Registers� �;**********************************************************************��.DCMCLK� DS.B� 1� ;� DALI� Clock� Register�.DCMFA� DS.B� 1� ;� DALI� Forward� Address� Register�.DCMFD� DS.B� 1� ;� DALI� Forward� Data� Register�.DCMBD� DS.B� 1� ;� DALI� Backward� Data� Register�.DCMCR� DS.B� 1� ;� DALI� Control� Register�.DCMCSR� DS.B� 1� ;� DALI� Control/Status� Register��reserved4�� DS.B� � � � 3� � � ;� 3� bytes� unused� 46h� to� 48h��;**********************************************************************�;� � � � � � � � � � � � � � � � � � � � � � � � AWU� Registers� �;**********************************************************************��.AWUPR� DS.B� 1� ;� AWU� Prescaler� Register�.AWUCSR� DS.B� 1� ;� AWU� Control/Status� Register��;**********************************************************************�;� � � � � � � � � � � � � � � � � � � � � � � � DM� Registers� �;**********************************************************************��.DMCR� � DS.B� 1� ;� DM� Control� Register�.DMSR� � DS.B� 1� ;� DM� Status� Register�.DMBK1H� DS.B� 1� ;� DM� Breakpoint� Register� 1� High�.DMBK1L� DS.B� 1� ;� DM� Breakpoint� Register� 1� Low�.DMBK2H� DS.B� 1� ;� DM� Breakpoint� Register� 2� High�.DMBK2L� DS.B� 1� ;� DM� Breakpoint� Register� 2� 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'�� DC.W� dummy_rt� ;� Adresse� FFE0-FFE1h�SPI_it� � DC.W� dummy_rt� ;� Adresse� FFE2-FFE3h�lt_RTC1_it� � DC.W� dummy_rt� ;� Adresse� FFE4-FFE5h�lt_IC_it� � DC.W� dummy_rt� ;� Adresse� FFE6-FFE7h�at_timerover_it� DC.W� dummy_rt� ;� Adresse� FFE8-FFE9h�at_timerOC_it� DC.W� dummy_rt� ;� Adresse� FFEA-FFEBh�AVD_it� � DC.W� dummy_rt� ;� Adresse� FFEC-FFEDh�� DC.W� dummy_rt� ;� Adresse� FFEE-FFEFh�lt_RTC2_it� � DC.W� dummy_rt� ;� Adresse� FFF0-FFF1h�ext3_it� � DC.W� dummy_rt� ;� Adresse� FFF2-FFF3h�ext2_it� � DC.W� dummy_rt� ;� Adresse� FFF4-FFF5h�ext1_it� � DC.W� dummy_rt� ;� Adresse� FFF6-FFF7h�ext0_it� � DC.W� dummy_rt� ;� Adresse� FFF8-FFF9h�AWU_it� � DC.W� dummy_rt� ;� Adresse� FFFA-FFFBh�softit� � DC.W� dummy_rt� ;� Adresse� FFFC-FFFDh�reset� � � DC.W� main� � ;� Adresse� FFFE-FFFFh�� END��;************************************************************************�

ANNEXE 3

Créer un projet ST7 en 10 leçons

IInnttrroodduuccttiioonn��

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.

EEttaappee��11��::��PPrréélliimmiinnaaiirreess��

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 définit le modèle de microcontrôleur ST7Lite2.inc fichier à inclure dans votre programme (si votre projet

concerne un modèle ST7Lite2) MAX7219.asm définit ce qui concerne le gestionnaire d’afficheurs 7

segments MAX7219.inc fichier à inclure dans votre programme (si votre projet

doit faire de l’affichage sur les afficheurs 7 segments) Squelet.asm point de départ de votre programme. Il faudra

renommer ce fichier avec le nom de votre projet.

EEttaappee��22��::��DDéémmaarrrraaggee��dduu��llooggiicciieell��

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 :

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 …

zone�d’affichage�des�fichiers�sources�zone�de�

projet

zone�d’affichage�des�messages�d’information�

EEttaappee��33��::��CCrrééaattiioonn��dduu��WWoorrkkssppaaccee��

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):

EEttaappee��44��::��AAjjoouutt��ddeess��ffiicchhiieerrss��ssoouurrcceess��

Faire apparaître sous le nom du Projet, les répertoires Source Files, Include Files, et External Dependencies :

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.

1�–�clic�gauche�

2�–�clic�droit�puis��Add�Files�to�Folder…

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.

EEttaappee��55��::��CCrrééaattiioonn��dduu��pprrooggrraammmmee��

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).

EEttaappee��66��::��UUttiilliissaattiioonn��ddee��ll’’aaiiddee��

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.

EEttaappee��77��::��CCoommppiillaattiioonn��dduu��pprroojjeett��

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.

EEttaappee��88��::��CCoonnffiigguurraattiioonn��dduu��ddeebbuugg��

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 :

• 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.)

à�modifier�(facultatif)

à�modifier�(impératif)

EEttaappee��99��::��DDeebbuugg��dduu��pprrooggrraammmmee��

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…

EEttaappee��1100��::��CC’’eesstt��ffiinnii��!!��

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 from Stack SUB Subtraction

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 Increment SRA Shift Right Arithmetic

SRL Shift Right Logical

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 RET Return from Subroutine

OR Logical Or

XOR Logical Exclusive Or

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 Wait for Interrupt JRNM Jump Relative if No Interrupt Mask

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

Documents

Mini Projet Microcontrôleur ST7 - lionel.goub.free.frlionel.goub.free.fr/==COURS==/N3/Electronique/TP%20microcontr%F4... · Au cours de ce mini-projet , vous développerez tout d'abord