Telechargé par alinassim255

introduction à la programmation du 68HC11

publicité
Introduction à la
programmation du microcontrôleur
68HC11
CMC 1M
Manuel d' exercices pour les etudiants
SH5014-1L
3e édition
Auteurs : ACMC Mittweida
Lucas-Nülle Lehr- und Messgeräte GmbH
Siemensstraße 2 • D-50170 Kerpen
Introduction à la programmation du microcontrôleur
CMC 1M
Table des matières
Objectif des expériences .............................................................................................1
Aperçu des exercices ..................................................................................................1
Montage de l’expérience .............................................................................................1
Introduction..................................................................................................................3
CMC 1M-1 Premiers pas dans la programmation d’un microcontrôleur ......................6
Notions de base ........................................................................................................6
Montage de l’expérience CMC 1M-1 .........................................................................9
Exercice 1 : Création d’un propre projet .................................................................. 10
Exercice 2: Travail avec l’éditeur de texte, création d’un code de programme
chargeable .............................................................................................................. 17
Exercice 3 : Travail avec le débogueur ................................................................... 24
CMC 1M-2 Le microcontrôleur 68HC11 .................................................................... 30
Notions de base ...................................................................................................... 30
Montage de l’expérience CMC 1M-2 ....................................................................... 32
Exercice 1: Périphérie « on-chip »........................................................................... 33
Exercice 2 : Structure de programme et de données, adressage de mémoire........ 38
Exercice 3 : Travail avec la liste de commandes.....................................................42
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11E1................... 53
Notions de base ...................................................................................................... 53
Montage de l’expérience CMC 1M-3 ....................................................................... 54
Exercice 1: Techniques de programmation, analyse des problèmes, techniques
d’ébauche (ordinogrammes), liste de programme................................................... 55
Solutions des ébauches et de la liste de programme .............................................. 66
Annexe ...................................................................................................................... 71
Règles importantes relatives à l’assembleur de A. Arnold pour les dérivés 68HC1171
Listings du manuel .................................................................................................. 78
Introduction à la programmation du microcontrôleur
CMC 1M
Objectif des expériences
1. Transmission d’informations de base sur l’environnement de programmation et compre-
nant matériel et logiciel, définition des termes ainsi qu'entraînement dans la manipulation
des composants. Dans toutes les expériences qui suivent, les concepts de
l’environnement de programmation seront utilisés sans autres commentaires.
2. Les élèves/étudiants se familiarisent avec la structure du MC et de sa périphérie. Ils ap-
prennent à connaître le jeu de commandes du MC.
3. Les élèves/étudiants se familiarisent avec la programmation structurée du début à la fin
au moyen d’un exemple simple.
Aperçu des exercices
CMC 1M-1 Premiers pas dans la programmation d’un microcontrôleur
• Introduction dans l’environnement de développement
• Les composantes du logiciel et du matériel
• Explication des termes
• Configuration de l’IDE et son utilisation à l’aide d’un exemple
• Traitement des erreurs types
• Travail avec le débogueur, par ex. configuration, mode continu, mode pas à pas,
points d’interruption
CMC 1M-2 Le microcontrôleur 68HC11
• Structure et mode de fonctionnement d’un microcontrôleur (structure interne)
• La périphérie du microcontrôleur (ports, cycle, réinitialisation)
• Mode de fonctionnement d’un microcontrôleur (synchronisation, ALU, ports E/S)
• Structure de la mémoire d’un microcontrôleur
• Liste de commandes du microcontrôleur
• De brefs exemples d’application démontrent le mode de fonctionnement du microcontrôleur et sa commande via le jeu de commandes.
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11E1
Programmation d’un premier programme via les étapes suivantes :
• analyse du problème,
• recherche de solutions,
• ébauche de structures,
• programmation,
• essai,
à l’exemple de la rampe d’éclairage.
Montage de l’expérience
Pour une réalisation efficace, sans erreurs et sûre de l’expérience, on trouvera séparément :
• un tableau avec tous les modules, appareils, câbles de connexion et accessoires requis
• la configuration de l’appareil sur le poste de travail
Introduction CMC 1M
1
Introduction à la programmation du microcontrôleur
CMC 1M
PC avec
logiciel IDE
SO4001-9H
LM9040
SO4000-1K
LM6203
SO4000-1I
SO4000-1E
Fig. 01 : Configuration sur le poste de travail
Nous conseillons de placer les instructions de service auprès des différents modules lors de
l’exécution des expériences. Elles constituent un complément précieux aux différents exercices.
Les points de mesure, commutateurs et instruments de réglage sur les modules seront expliqués en détail. Dans les instructions de service, vous trouverez également des remarques
de base relatives aux applications.
Pour une préparation efficace du cours, utilisez l’offre proposée sur Internet à l'adresse suivante :
http://www.mcls-modular.de
À côté des listings, vous y trouverez également de l’aide et des instructions sur
l’environnement de développement intégré.
Composants et appareils requis
Pcs
Désignation
N° id.
1
1
1
1
1
1
1
1
1
1
Plate-forme avec module d’alimentation en courant +5V
Alimentation enfichable CA 90...230V, 45..65Hz, CC 9V, 630mA
Module PSD2-FLASH à contrôleur 68HC11
Adaptateur de 8 bits
Unité à LED
Clavier
Unité de commutation
Unité d’affichage 1
Adaptateur BNC
Unité utilisateur
SO4000-1E
SO4000-1F
SO4000-1I
SO4000-1K
SO4000-1P
SO4000-1Q
SO4000-1R
SO4000-1S
SO4000-1T
SO4000-1U
1
Logiciel IDE pour MCLS (D,GB,F,E)
SO4001-9H
1
1
Oscilloscope avec sondes
Crayon de contrôle logique
LM6203
LM8101
1
1
8
8
Câble de mesure BNC / BNC
Câble d’interface série 9/9 pôles
Câble de connexion 2mm 15cm bleu
Câble de connexion 2mm 15cm jaune
LM9034
LM9040
SO5126-5K
SO5126-5M
1
1
CMC 1M Introduction à la programmation du microcontrôleur
Valise de rangement pour MCLS
SH5014-1L
SO4000-1W
2
Introduction CMC 1M
Introduction à la programmation du microcontrôleur
CMC 1M
Introduction
Aujourd’hui, les microcontrôleurs revêtent une importance décisive que l’on ne reconnaît pas
toujours au premier abord. Ces systèmes fonctionnent généralement sans qu’on les remarque, en « arrière-plan », mais sont d’autant plus efficaces. La haute ou très haute intégration
de processeur, RAM, ROM, EEPROM, Flash et autres fonctions ouvrent des domaines
d’application impensables il y a quelques années. Les systèmes de microcontrôleur sont
utilisés aujourd’hui par ex. dans
•
•
•
•
les commandes
les instruments de régulation
les systèmes de conduite de processus
les systèmes de communication
Le système d’enseignement du microcontrôleur modulaire MCLS-modular® a été spécialement mis au point pour la formation dans le domaine de la « technique du microcontrôleur ».
Il permet l'apprentissage de la structure matérielle ainsi que la programmation assistée par
logiciel des microcontrôleurs des séries 8051 et 68HC11.
L’environnement de développement Windows IDE permet, après une courte initiation, de
créer, de tester et d'optimiser des programmes pour le microcontrôleur. Pour l’utilisation dans
le MCLS-modular, on s’oriente sur l’emploi de débogueurs de moniteur ou de simulateurs
avec fonction de chargement-amorçage ou programmeur pour le dépistage d’erreurs dans
les programmes. Les outils utilisés dépendent du système cible pour lequel les outils correspondants doivent être disponibles. Le déroulement de la programmation correspond ainsi au
quotidien de l’industrie.
Unité centrale (CPU)
Système de
commande
Registre
Système de
calcul
Système de liaison (Bus)
Mémoire de
donnéesprogramme
Composants
entrée / sortie
Fig. 02 : Structure de principe d’un ordinateur
Le microprocesseur constitue le composant central de tout micro-ordinateur. Par ordinateur,
nous entendons en général un système de traitement de données commandé par un programme. Ce sont les données à traiter, c’est-à-dire le but de l’application, qui déterminent la
structure et donc la puissance requise du microprocesseur utilisé. La comparaison d'un gros
calculateur avec une carte à puce le montre, car il s’agit bien dans les deux cas d’un ordinateur.
Introduction CMC 1M
3
Introduction à la programmation du microcontrôleur
CMC 1M
À l’origine, le microprocesseur – l’unité centrale (CPU) d’un système d’ordinateur réalisée sur
une puce – était prévu pour effectuer des calculs numériques. Aujourd’hui, les microprocesseurs sont utilisés dans un large domaine d’applications techniques. Sa fonctionnalité s’est
par conséquent étendue et spécialisée. Considérant la diversité des domaines d’utilisation,
tels que les ordinateurs de bord des véhicules modernes, des processeurs de signaux des
techniques de communication ou des puissants ordinateurs individuels, nous pouvons établir
la classification suivante :
•
•
•
•
Microprocesseurs standards
Microprocesseurs à haute performance
Microcontrôleurs
Processeurs de signaux numériques
Dans ce manuel, nous allons nous consacrer à la programmation des microcontrôleurs
communs.
Les microcontrôleurs communs sont, au sens propre du terme, une des formes les plus
compactes d’un micro-ordinateur.
Cœur
(CPU)
Système
d' interruption
Bus interne
Mémoire de
programme
Mémoire de
données
Composants
périphériques
Fig. 03 : Structure de principe d’un microcontrôleur
Un microcontrôleur est un système de micro-ordinateur complet tenant sur une puce. Le
cœur (core, en anglais) du microcontrôleur, la mémoire, les périphériques et le système
d’interruption sont regroupés sur une puce et reliés ensemble par un ou plusieurs bus. [1]
Par core, ou cœur, d’un microcontrôleur, nous entendons l’unité centrale (CPU) intégrée sur
la puce, dotée en général d’un système de commande, d’un système de calcul, d’un registre
et d’une commande de bus.
Avec les microcontrôleurs, c’est la périphérie « on-chip », et non la puissance de calcul, qui
nous intéresse. Exemples de périphéries « on-chip » :
• Oscillateur de synchronisation
• Ports d’entrée et de sortie
• Horloge
• Interfaces de communication (UART, I2C, CAN, SPI ...)
• Convertisseur analogique-numérique
• Convertisseur numérique-analogique
• Interruptions externes
• Real Time Clock (RTC)
• Aide au débogage
4
Introduction CMC 1M
Introduction à la programmation du microcontrôleur
CMC 1M
Souvent, ne suffisant pas pour une application, les composants périphériques intégrés doivent être complétés par des modules externes. Dans la plupart des cas, cela concerne la
mémoire.
Le développement de programmes pour microcontrôleurs se fait soit au niveau du processeur au moyen d’un langage d’assemblage et de l’assembleur appartenant au microcontrôleur, soit dans un langage évolué (C ou C++) et un compilateur. L’assembleur ou le compilateur traduisent le code source écrit en format texte dans un code binaire compréhensible
pour le microcontrôleur. Comme un microcontrôleur est un microordinateur à part entière,
l’assembleur utilisé ou le compilateur doivent disposer des jeux de commandes faisant partie
de ce microcontrôleur. Dans le cas contraire, le code généré sera mal interprété, voire pas
exécuté du tout.
La question de savoir lequel des deux outils de développement est utilisé dépend de
•
•
•
•
la disponibilité de ces outils pour le MC,
le besoin de compatibilité de temps réel,
la compacité du code généré,
l’étendue des activités de programmation.
Dans le cadre des travaux de développement, d’autres outils complémentaires sont utilisés.
Les éditeurs de liens intègrent les fonctions existantes des bibliothèques au code de programme. Les convertisseurs génèrent un fichier MOTOROLA-S-RECORD téléchargeable.
Les systèmes de débogage servent à la mise en service et à l’optimisation du code.
C’est en fin de compte l’application qui détermine le choix des outils de développement mis
en œuvre par la sélection du microcontrôleur et les éventuels coûts de développement.
Avec les microcontrôleurs 8 bits, il est tout à fait usuel de travailler avec un assembleur et
des débogueurs moniteur.
Avec les microcontrôleurs à plus haute intégration, en particulier les microcontrôleurs 16 bits
et 32 bits, on trouve essentiellement les plates-formes à langage évolué. Celles-ci sont alors
supportées par les systèmes de débogage « on-chip » des récents microcontrôleurs. Ces
environnements de programmation confortables requièrent toutefois l’interface nécessaire
vers le microcontrôleur.
[1] Taschenbuch Mikroprozessortechnik, Thomas Beierlein, Olaf Hagenbruch, 3e édition
2004, Fachbuchverlag Leipzig
Introduction CMC 1M
5
Introduction à la programmation du microcontrôleur
CMC 1M
CMC 1M-1 Premiers pas dans la programmation d’un microcontrôleur
Utilisation de l’environnement de développement intégré, génération
d’un code de programme, chargement du programme, utilisation du
débogueur
Notions de base
Pour qu’un microcontrôleur puisse traiter une séquence de commandes, il est nécessaire de
stocker dans sa mémoire de programmes (mémoire de codes) un programme lisible par la
machine.
Une procédure usuelle est de charger la mémoire de codes avec un fichier MOTOROLA-SRECORD (séquence définie de caractères hexadécimaux en format ASCII) qui représente le
code de programme lisible par la machine.
Un code de programme est généré par la création, dans un éditeur de texte, d'un texte
source répondant à certaines règles, puis de le convertir à l’aide d’un outil de développement
spécifique (outil logiciel). Ce code peut être un code intermédiaire ou le fichier MOTOROLAS-RECORD proprement dit. L’assembleur et le compilateur (C) sont des outils de développement qui sont en mesure d'exécuter une telle conversion. D’autres outils (par ex. convertisseurs, éditeurs de liens) continuent à traiter le code intermédiaire jusqu’à ce qu’un code de
programme chargeable soit créé.
Les programmes terminés sont stockés dans la mémoire de programmes via une programmation par masques chez le constructeur ou par des unités de programmation chez
l’utilisateur. C’est la structure physique de la mémoire de programmes qui décide du type de
programmation possible.
Pour tester des programmes pendant leur création, on utilise des émulateurs ou des systèmes de développement spéciaux (matériel et logiciel, débogueur).
Pour utiliser ces différents outils de développement et les mettre en œuvre selon les projets,
on dispose de l’environnement de développement intégré IDE. Celui-ci relie tous les outils
dans une interface utilisateur unitaire.
Pour exécuter toutes les expériences, on utilise les outils logiciels suivants :
• Éditeur de texte intégré de l’IDE
• Assembleur (as.exe, génère le code intermédiaire)
• Convertisseur (p2hex.exe, génère le fichier MOTOROLA-S-RECORD à partir du code
intermédiaire)
• Débogueur (debug11f.exe pour module PSD2Flash) (debug11.exe pour module PSD2)
• Moniteur cible (programme spécial pour le chargement et le test de programmes utilisateurs, installé de façon fixe dans le matériel du module PSD2-Flash) - voir instructions de
service du module PSD2-Flash (SO4000-1I), p.4
L'intégration des outils logiciels dans l'IDE est très aisée à l'aide d'un profil intégré. Il suffit de
décomprimer le module de projets fourni « PSD2-68HC11-FLASH-AS » via le gestionnaire
de modules de l'IDE (menu déroulant Options). Ensuite, charger le profil intégré « PSD268HC11-FLASH-AS » dans la sélection des profils.
Le chargement du code programme généré (fichier MOTOROLA-S-RECORD) dans la mémoire de codes se fait via l’interface série (RS232) de votre PC vers l’interface série du microcontrôleur. Le programme est stocké dans la mémoire de programmes par le moniteur
6
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
cible. L'exécution du programme dans le microcontrôleur (exécution en temps réel, mode
d’exécution pas à pas, exécution par routine) est assurée par des commandes du débogueur
(outil logiciel sur votre PC).
Figure 101 : IDE du MCLS-modular
®
L’IDE du MCLS-modular® regroupe dans une même surface utilisateur tous les éléments
requis pour le développement d’un programme. L’IDE comprend trois zones. À gauche se
trouve le navigateur, à droite la fenêtre avec l’éditeur de texte source. La barre de menus et
les boutons affichés permettent d’accéder aux différentes fonctions de l’environnement de
développement.
Pour faciliter l’initiation à la programmation, des profils dits « intégrés » ont été créés. Ces
profils intégrés sont des modules logiciels contenant tous les outils de programmation et
leurs paramètres de configuration adaptés au microcontrôleur. Les composants suivants
sont intégrés par exemple pour le profil intégré PSD2-68HC11-FLASH-AS :
• Assembleur
• Convertisseur
• Générateur de fichiers symbole
• Débogueur
Les parties fixes de l’environnement de développement intégré sont les suivantes :
• Éditeur de texte source
• Gestion des fichiers
Le logiciel de débogage permet de télécharger un programme d’application dans le système
cible.
Pour créer un nouveau projet, on peut appliquer la procédure suivante :
(1) Créer un nouveau projet dans l’IDE du MCLS
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
7
Introduction à la programmation du microcontrôleur
CMC 1M
(2) Créer et intégrer le fichier source principal dans le projet
(3) Éditer, assembler et convertir un texte source propre en assembleur
L’exécution du programme dans le microcontrôleur (exécution en temps réel, mode
d’exécution pas à pas, exécution par routine) est commandée depuis le débogueur (outil
logiciel de votre PC).
Après l’installation du logiciel, l’IDE peut être démarré à partir de l’icône du bureau ou du
menu Windows Démarrer Æ Programmes Æ MCLS-modular. Une courte explication de
l’installation est donnée dans le menu Aide sur Internet sous www.mcls-modular.de ou sur le
CD d’installation.
Le gestionnaire de modules est un composant très important qui permet l’intégration de mises à jour et de modules supplémentaires. Ces modules supplémentaires sont des fichiers
spécialement comprimés au format CAB. Après l’installation, ils sont placés dans le répertoire « Modules ». Les modules supplémentaires plus récents peuvent être téléchargés sur
Internet sous Téléchargements. Ces modules doivent ensuite être copiés dans le répertoire
« Modules ». Il ne faut jamais les ouvrir ni les décompresser par double-clic.
Avec le redémarrage de l’application IDE, le gestionnaire de modules détecte automatiquement la présence d’un nouveau module et vous propose l’intégration.
Remarque :
Avec le module PSD2-Flash, un nouveau profil intégré est disponible sous la forme de modules supplémentaires. Si ces modules ne sont pas disponibles dans le gestionnaire de modules (version IDE 3.07 et antérieure), ils doivent être copiés des sources mentionnées cidessus dans le répertoire « Modules ». Ceci concerne le module « PSD2-68HC11-FLASHAS » avec tous les outils et le profil intégré de même nom pour la programmation en assembleur du 68HC11E1.
Cette 3e édition du manuel CMC 1M décrit toujours l'utilisation du nouveau module PSD2Flash. Si vous employez encore le module PSD2, vous devez impérativement utiliser le profil
intégré « PSD2-68HC11-AS » et le fichier Include des définitions standards stddef11.inc pour
le module PSD2. Tenez-en compte dans les fichiers source.
Après une nouvelle installation réussie, vous devez configurer l’option d’enregistrement automatique de tous les fichiers de projet et source. Ainsi, avant un processus de traduction,
tous les fichiers modifiés du projet sont d’abord enregistrés automatiquement.
Procédez de la manière suivante :
(1) Accédez aux propriétés à partir du menu « Options »/« IDE »/« Paramètres… ».
(2) Dans la boîte de dialogue, cliquez ensuite sur « Editeur ».
(3) Activez à présent dans la liste « Enregistrer tous les fichiers avant réalisation d’outil » le
point : « Enregistrer tous les fichiers sans confirmation ».
(4) Confirmez la sélection avec « OK ».
8
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
MCLS - modular
GND
U5P
S4
S3
S2
S1
U5P
PSD1
PSD2
7
6
5
4
3
2
1
0
P1
P0
P5
P1
7
SO4000-1R
GND
U5P
7
6
5
4
6
5
4
3
2
1
LED - UNIT
RESET
0
1.5
MOTOROLA
PSD2-FLASH
SO4000-1P
UREF
GND
2.3
PE
P6
GND
U5P
SO4000-1I
RESET
1.3
BNC - ADAPTER
0
2.4
ANGND
GND
1.2
1
RESET
68HC11E1
1.4
U5P
2
2.5
PSD2
U5P
3
PA
P4
SWITCH - UNIT
GND
7
6
5
4
3
2
1
0
(TxD)
(RxD)
PD
P3
SO4000-1T
8 - BIT ADAPTER - UNIT
1.1
GND
2.2
SO4000-1K
3.1
U5P
1.0
2.1
GND
3.0
2.0
Arbeitsplattform
Working Platform
SO4000-1E
Fig.: 102 : Configuration de l’appareil pour l’expérience CMC 1M-1
Montage de l’expérience CMC 1M-1
Appareils et équipements requis
Pcs
Désignation
N° id.
1
1
1
1
1
1
Plate-forme avec module d’alimentation en courant +5V
Alimentation enfichable CA 90...230V, 45..65Hz, CC 9V, 630mA
Module PSD2-FLASH à contrôleur 68HC11
Adaptateur de 8 bits
Unité à LED
Unité de commutation
SO4000-1E
SO4000-1F
SO4000-1I
SO4000-1K
SO4000-1P
SO4000-1R
1
Logiciel IDE pour MCLS (D,GB,F,E)
SO4001-9H
1
1
8
Câble d’interface série 9/9 pôles
Câble de connexion 2mm 15cm bleu
Câble de connexion 2mm 15cm jaune
LM9040
SO5126-5K
SO5126-5M
1
CMC 1M Introduction à la programmation du microcontrôleur
SH5014-1L
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
9
Introduction à la programmation du microcontrôleur
CMC 1M
Configuration de l’appareil
Coupez l’alimentation électrique du MCLS-modular !
Reliez la plate-forme de travail avec votre PC via le câble d’interface série.
Connectez l’adaptateur de 8 bits avec le module PSD2-Flash adapté sur l’emplacement à
douilles (BF) 4.0 - 4.5 au milieu de la plate-forme. Veillez aux plots de contacts au milieu de
l’adaptateur (TxD, RxD) ! Connectez l’unité à LED à droite à côté de l’adaptateur 8 bits (par
ex. BF 2.6 – 2.7). Reliez successivement la LED 0 au port 1 douille 0 (P1.0), la LED 1 avec
P1.1, la LED 2 avec P1.2, etc., jusqu’à la LED 7 avec P1.7. Placez l’unité de commutation
sur la BF 1.6 – 1.7 de la plate-forme de travail. Reliez S1 au port A douille 0 (PA.0).
Branchez l’alimentation électrique au MCLS-modular.
Consigne de sécurité :
Veillez à la connexion correcte des potentiels de tension (gauche U5P, droite GND) !
Les points de mesure sortis ne doivent pas recevoir de tensions extérieures. Des composants dans les plaques d’enseignement risquent sinon d’être détruits !
Bibliographie :
Pour la réalisation des expériences, conservez à portée de main le manuel de
l’environnement de développement intégré (IDE) et les instructions de service du module
PSD2-Flash.
Exercice 1 :
Création d’un propre projet
Objectif :
•
•
•
•
•
•
•
•
•
Spécification / sélection d’un profil de microcontrôleur
Intégration d’un fichier de texte source
Enregistrement d’un fichier de texte source sous un autre nom
Déclarer le fichier principal
Enregistrement du projet
Impression des contenus du projet
Test du programme sur le MCLS-modular
Fermeture d’un projet
Quitter l’IDE
Exercice :
Créez le projet « CMC1-1 ».
Intégrez le fichier de texte source « cmc1m11.asm » et enregistrez-le sous le nom « myflash1.asm ».
Déclarez « myflash1.asm » comme fichier principal.
Enregistrez le projet actuel. Imprimez l’information de projet, le profil d’outil et le fichier de
texte source.
Testez le programme sur le MCLS-modular.
10
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
Procédure :
Tout d'abord, démarrez l'IDE du MCLS-modular® (Démarrer Æ Programmes Æ MCLSmodular).
•
Sélectionnez le profil du microcontrôleur
ª Cliquez sur « Microcontrôleur » dans l’arborescence du projet (ou menu Options
ÖProjet ÖMicrocontrôleur).
ª Activez la liste d’options « Profils intégrés » dans la sélection de profils Ö clic.
ª Dans le champ Sélection de profil du microcontrôleur, sélectionnez le profil intégré
PSD2-68HC11-FLASH-AS.
Figure 103 : Nouveau projet avec sélection de profil
Le projet doit ensuite être enregistré dans un répertoire de votre choix.
• Enregistrez le projet.
ª Menu Projet ÖEnregistrer projet ÖSélectionner répertoire ÖSaisir le nom de fichier
souhaité (type de fichier : MCLS-Project-File) Ö« Enregistrer »
Pour créer un programme exécutable, un fichier source principal doit être créé et intégré
dans le projet à partir du menu Fichier Æ Nouveau fichier.
• Créez et intégrez le fichier source principal.
ª Cliquez sur « Fichier » dans l’arborescence du projet
ÖBouton droit ÖInsérer fichier dans le projet ÖSélectionner fichier ÖOuvrir
(ª ou menu Fichier Ö Insérer fichier dans le projet ÖSélectionner fichier ÖOuvrir)
REMARQUE : plusieurs fichiers peuvent être intégrés dans un projet.
•
Enregistrez le fichier de texte source (marqué) actuel sous un autre nom.
ª Menu Fichier Ö Enregistrer fichier actuel sous ... ÖSélectionner répertoire ÖSaisir le
nom de fichier souhaité (type de fichier : Assembler-File) Ö « Enregistrer »
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
11
Introduction à la programmation du microcontrôleur
CMC 1M
Figure 104 : Enregistrer le fichier source principal
Ce fichier créé doit être enregistré dans le répertoire du projet avec l’extension .asm et défini
comme mainfile dans le navigateur à l’aide du bouton droit de la souris.
• Déclarez le fichier actuel (marqué) comme fichier principal (mainfile).
ª Cliquez sur le fichier souhaité dans la branche de projet « Fichier » (marquer)
Öbouton droit ÖSet mainfile
ATTENTION : Le choix d’un fichier principal est obligatoire car les outils n’éditent que le fichier de texte source défini comme tel ! Un seul fichier peut être défini comme le fichier principal.
Remarque :
Lors de l’enregistrement du fichier source, Assembler-File doit impérativement être sélectionné sous Type de fichier ! Si ce n’est pas le cas, il peut en résulter un mauvais enregistrement des extensions de fichiers, ce qui rend impossible le processus de compilation.
•
Enregistrez le projet.
Menu Projet ÖEnregistrer projet ÖSélectionner répertoire ÖSaisir le nom de fichier souhaité
(type de fichier : MCLS-Project-File) Ö« Enregistrer ».
•
Imprimez le contenu du projet.
Cliquez sur
dans la barre d’outils « Projet » de l’IDE
Ö Sélectionnez la source souhaitée Ö « OK »
•
Éditez et compilez un texte source propre en assembleur.
Dans le fichier source principal, myflash1.asm dans
l’exemple, il est possible d’éditer la séquence du programme. Après la création d’un texte source, sa traduction est nécessaire. Pour cela, cliquez sur le bouton
Make.
Après le processus de traduction, il est possible
d’afficher dans le navigateur Messages Æ Assembler,
Converter, Symbol les erreurs ou avertissements du
processus de traduction.
Après résolution des erreurs et redémarrage de la
fonction Make, un fichier *.hex exécutable est créé.
Figure 105 : Démarrage de la fonction Make
12
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
REMARQUE : assurez-vous que dans votre répertoire dans lequel vous avez enregistré le
fichier assembleur MYFLASH1.asm, le fichier stdef11F.inc est lui aussi présent. Si ce n’est
pas le cas, copiez ce fichier depuis le répertoire dans lequel se trouve l’assembleur.
•
Testez le programme sur le MCLS-modular.
ª Cliquez sur le symbole
dans la barre d’outils « Outils » de l’IDE (ou menu Démarrer ÖMake).
ª Cliquez sur le symbole
dans la barre d’outils « Outils » de l’IDE (ou menu Démarrer ÖOutils ÖDébogueur).
Lors du procédé de traduction à l’aide de l’assembleur
un fichier hex
et du convertisseur, l’outil Make crée
qui contient le code de programme exécutable et qui
peut être chargé dans la RAM externe du module
PSD2-FLASH. Pour cela, ouvrez le logiciel de débogage à l’aide du bouton Start Debugger .
Avec le lancement du logiciel, le fichier exécutable est
automatiquement transféré dans la RAM du module
PSD2-FLASH.
Figure 106 : Affichage du débogueur
ª Cliquez sur « OK » (ou sur ↵/touche Entrée) (confirmez le message dans la fenêtre d’erreur).
Figure 107: Débogueur du MCLS-IDE
Le débogage du texte source est ensuite possible. La
mise en service et le test de fonctionnement du programme peuvent maintenant être effectués à l’aide de
diverses commandes d’opération. Les commandes
suivantes doivent être utilisées :
ƒ Exécution pas à pas (Single Step) F7
ƒ Exécution par routine (Single Proc)
F8
ƒ Exécution
F9
ƒ Réinitialisation
CTRL + F3
ƒ Définir/effacer le point d’arrêt
CTRL-B/ CTRL-E
ª Démarrer le programme en mode d’exécution en temps réel
ÖAppuyer sur la touche F9
ª Arrêter l’exécution en temps réel
ÖAppuyer sur la touche RESET de l’adaptateur 8 bits
•
Terminez le débogage
ª Combinaison de touches Alt+X
•
Fermez le projet
ª Menu Projet ÖFermer le projet
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
13
Introduction à la programmation du microcontrôleur
CMC 1M
•
Fermez l’IDE
ª Cliquez sur
dans la barre d’outils « Projet » de l’IDE.
REMARQUE : s’il reste un projet ouvert, il est d’abord enregistré automatiquement.
Les messages d’erreur lors du lancement du débogueur sont décrits à l'exercice 3.
Conversion d’un profil intégré en profil utilisateur
Tous les profils prédéfinis intégrés peuvent aussi être adaptés à des besoins individuels.
Pour cela, vous devez cependant effectuer un transfert dans un profil utilisateur.
Figure 108 : Créer un profil utilisateur
Procédez de la manière suivante :
(1) Projet → Microcontrôleur → Profil intégré: sélectionnez « PSD2-68HC11-FLASH-AS ».
(2) Cliquer sur le bouton Copier
à droite et à côté du champ de sélection pour convertir le
profil en profil utilisateur.
(3) Attribuer un nouveau nom au profil et confirmer.
(4) Activer l’option « Profils utilisateur ».
(5) Sélectionner le nouveau profil défini.
Figure 109 : Boîte de dialogue « Outils » pour la configuration du profil utilisateur
Lorsque vous avez sélectionné le profil utilisateur créé, vous pouvez choisir les outils disponibles. La configuration des différents outils est ensuite effectuée dans la boîte de dialogue
« Outils » qui s’affiche.
14
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
Questions :
Indiquez une procédure usuelle pour charger dans un microcontrôleur un code de
programme lisible par la machine. Quelle structure spéciale le contenu de ce fichier
présente-t-il ?
Quels outils de développement sont-ils nécessaires pour générer un code de programme chargeable et à quoi servent-ils respectivement ?
Quels outils (désignation de l’outil, nom du fichier exécutable) sont-ils utilisés dans le
profil intégré « PSD2-68HC11-FLASH-AS » ?
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
15
Introduction à la programmation du microcontrôleur
CMC 1M
Quels outils sont-ils mentionnés dans la liste d’impression « Profil d’outil » (information de tool profile) ?
Quelles informations de chemin et de fichier exactes se trouvent-elles sous « Project »
et sous « List of sources » dans la liste d’impression « Informations projet » (information of project) ?
Quelle diode de l’unité LED clignote-t-elle à l’exécution du programme dans le microcontrôleur ?
16
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
Exercice 2:
Travail avec l’éditeur de texte, création d’un code de programme
chargeable
Objectif :
•
•
•
•
•
•
•
•
•
•
•
•
•
Ouvrir un projet existant
Créer un nouveau fichier de texte source
Éditer un fichier de texte source
Utiliser des signets dans l’éditeur
Saisies spécifiques au 68HC11E1 et nécessaires pour l’assembleur
Règles importantes de l’assembleur à la création du texte source
Assembler un fichier de texte source
Fenêtre de message pour l’assembleur
Traitement des erreurs après l’assemblage
Convertir le fichier de code intermédiaire
Fenêtre de message pour le convertisseur
Traitement des erreurs après la conversion
Test sur le MCLS-modular
Exercice :
Chargez le projet existant « CMC1M-1 ».
Insérez un nouveau fichier de texte source avec le nom « myflash2.asm » Copiez la totalité
de « myflash1.asm » vers « myflash2.asm ».
Laissez « myflash2.asm » dans l’éditeur de texte. Placez un signet sur le sous-programme
Temps de ce fichier et utilisez-le.
Remplacez, dans « myflash2 », à la ligne de commande « DELAY: MOV R7,#00H » (sousprogramme DELAY), le 2e paramètre #00H par #4FH. Enregistrez le fichier. En lançant
l’assembleur, vérifiez que vos entrées ne comportent pas d’erreur.
Dans « myflash2 », réalisez respectivement les erreurs décrites ci-dessous, procédez à
l’assemblage et lisez les messages de l’assembleur. Corrigez chaque erreur après contrôle !
(Tester toutes les erreurs individuellement !)
(1) Supprimez l’entrée « CPU
6811 ».
(2) Supprimez tous les espaces vierges devant « LDX #P1CTL ».
(3) Supprimez « DELAY: » dans „Sous-programme DELAY ».
(4) Dans la ligne de commande «
ldx #$3fff » (sous-programme DELAY), remplacez le
paramètre #$3fff par #3fff.
(5) Dans la ligne de commande «
LDX #P1CTL », remplacer le point virgule devant le
commentaire par une virgule.
(6) Faites encore une fois l’erreur 5 et démarrez immédiatement le convertisseur après
l’assemblage. Lisez le message du convertisseur. Corrigez l’erreur.
Vérifiez que le programme ne comporte pas d’erreurs. À partir des fichiers « myflash2 » et
« myflash1 », créez le fichier MOTOROLA-S-RECORD. Testez les deux programmes sur le
MCLS-modular.
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
17
Introduction à la programmation du microcontrôleur
CMC 1M
Procédure :
•
Démarrez l’environnement de développement intégré pour le MCLS-modular du menu
principal á.
•
Ouvrez un projet existant.
ª Cliquer sur le symbole
dans la barre d’outils « Projet » de l’IDE ÖSélectionner
fichier ÖOuvrir (ou menu Projet Ö Insérer projetÖ Sélectionner fichier ÖOuvrir).
REMARQUE : si un projet est déjà ouvert, il est automatiquement enregistré, puis refermé.
•
Créez un nouveau fichier de texte source.
ª Menu Fichier Ö Nouveau fichier
ATTENTION : le nouveau fichier n’a pas encore de nom, enregistrez-le sous un nom approprié.
•
Éditez un fichier de texte source.
Marquer
ª Amener le pointeur à gauche du premier caractère du texte à marquer Öappuyer
sur le bouton gauche de la et tirer le pointeur de la sur le texte à marquer Örelâcher le bouton gauche de la .
Marquer tout
ª Bouton droit de la ÖMarquer tout.
Copier
ª Marquer le texte à copier Öbouton droit de la Öcopier
Couper
ª Marquer le texte à couper Öbouton droit de la Öcouper
Coller
ª Copier ou couper le texte à coller Ö placer le pointeur de la sur la position
d’insertion Öbouton droit de la Öcoller
Annuler
ª Bouton droit de la Öannuler
18
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
Variantes :
Menu Edition
Copier
Couper
Coller
Annuler
Marquer tout
•
Symbole de la barre d'outils
Raccourcis (short key)
CTRL+Z
CTRL+X
CTRL+C
CTRL+V
CTRL+A
Placez un signet
ª Placez le pointeur sur la marge gauche de la ligne où le signet doit être placé (sur
la marge, le pointeur de la devient vert) Öbouton droit de la ÖSet Bookmark ...
Öentrez le nom de signet souhaité ÖOK
•
Supprimez un signet
ª Placez le pointeur sur la marge gauche de la ligne où le signet est placé (sur la
marge, le pointeur de la devient vert) Öbouton droit de la ÖDelete Bookmark
•
Faites sauter le curseur de texte à un signet
ª Cliquez sur le symbole
dans la barre d’outils « Editeur » de l’IDE (ou menu Affichage ÖNavigateur) Öchoisissez le fichier souhaité via l’onglet inférieur Ö sur
l’entrée de signet souhaitée
•
Veillez à ce que les textes spécifiques suivants au processeur soient bien entrés
ª CPU
6811
Lors de la saisie de ces textes, observez les règles de l’assembleur de A. Arnold (voir annexe).
Si l'entrée « CPU 6811 » manque, l’assembleur ne reconnaît aucune commande et ne sait
pas quelle liste de registres de fonctions spéciales il doit adresser. L’assembleur se désactive !
•
Assemblez un fichier de texte source
ª Cliquez sur le symbole
dans la barre d’outils « Outils » de l’IDE
(ou menu Démarrer ÖOutils ÖAssembleur)
ATTENTION : si l’assembleur a détecté des erreurs, aucun code intermédiaire ( *.p-File)
n’est généré !
•
Vérifiez les messages de l’assembleur
ª Après chaque opération d’assemblage, ils se trouvent déjà dans la fenêtre de messages
(ª OU Cliquez sur Assembleur dans la branche de projet Messages)
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
19
Introduction à la programmation du microcontrôleur
CMC 1M
Ö Fenêtre de messages supérieure
Informations générales telles que
fichiers utilisés (*.inc, *.asm), nombre de lignes du texte source global, nombre
d’erreurs, nombre d’avertissements, ainsi que quelques informations relatives à la
mémoire
Ö Fenêtre de messages inférieure
Spécifications d’erreurs avec la structure suivante :
« Nom de fichier ».asm (nombre) : Erreur/avertissement : Remarque erreur >>>
Spécification de texte
« Nom de fichier ».asm
(nombre)
Erreur/avertissement
Remarque erreur
Spécification de texte
•
Fichier où se trouve l’erreur
Numéro de la ligne où se trouve l’erreur
S’agit-il d’une erreur ou d’un avertissement?
De quelle erreur s’agit-il ?
Quel texte occasionne-t-il l’erreur ?
Évaluez l’erreur signalée par l’assembleur et éliminez-la
ª Après chaque opération d’assemblage, ils se trouvent déjà dans la fenêtre de messages
(ª OU cliquer sur Assembleur dans la branche de projet Messages)
ª Lire les messages dans la fenêtre inférieure, en particulier les remarques relatives
aux erreurs et les éventuelles spécifications de texte
ª Saut à la ligne comportant une erreur dans le texte source
ÖDouble-clic sur une spécification d’erreur
ª Corriger le texte source
•
Convertissez un fichier de code intermédiaire
(*.p-File) en un code de programme chargeable (fichier MOTOROLA-S-RECORD)
ª cliquer sur le symbole
dans la barre d’outils « Outils » de l’IDE
(ou menu Démarrer ÖOutils ÖConvertisseur)
ATTENTION : si l’assembleur, pour des raisons d’erreurs par ex., n’a pas créé de code intermédiaire (fichier *.p), le convertisseur envoie un avertissement et aucun fichier
MOTOROLA-S-RECORD n'est créé !
20
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
•
Vérifiez les messages du convertisseur
ª Après chaque opération de conversion, ils se trouvent déjà dans la fenêtre de messages
(ª OU cliquer sur Convertisseur dans la branche de projet Messages)
Messages :
•
Chemin et nom du fichier de code intermédiaire et du fichier
MOTOROLA-S-RECORD créé, taille du fichier créé, éventuellement
remarque relative à l’erreur
Évaluez les avertissements signalés par le convertisseur et éliminez-en les causes
ª Après chaque opération de conversion, ils se trouvent déjà dans la fenêtre de messages
(ª OU cliquer sur Convertisseur dans la branche de projet Messages)
ª Les avertissements se rapportent généralement à l'absence du fichier de code intermédiaire
ª Éliminez les causes (par ex. élimination des erreurs dans le texte source, puis nouvel
assemblage et conversion)
•
Dans une étape de travail, générez un code de programme chargeable (fichier
MOTOROLA-S-RECORD) à partir d’un texte source.
ª Cliquez sur le symbole
dans la barre d’outils « Outils » de l’IDE
(ou menu Démarrer Ö Make)
•
Testez le programme sur le MCLS-modular.
ª Cliquez sur le symbole
dans la barre d’outils « Outils » de l’IDE
(ou menu Démarrer ÖOutils ÖDébogueur)
ª sur « OK » (ou sur la touche ↵/Enter)
(acquittez le message dans la fenêtre d’erreur)
ª Démarrez le programme en mode temps réel
ÖAppuyez sur la touche F9
ª Arrêter le mode temps réel
Öappuyez sur la touche RESET de l’adaptateur 8 bits
ª Quittez le débogueur
Öpressez les touches ALT+X
ATTENTION :
le débogueur doit impérativement être conclu avec ALT+X ! La fermeture du débogueur avec
le bouton X du menu dans la fenêtre entraîne de graves conflits logiciels !
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
21
Introduction à la programmation du microcontrôleur
CMC 1M
Questions :
Par quel symbole un signet existant est-il représenté ?
Que se passe-t-il lorsque vous cliquez sur une entrée du tableau dans le navigateur de
l’éditeur ?
Quel numéro est affiché entre parenthèses après le nom du fichier dans la fenêtre de
messages inférieure de l’assembleur ?
Comment puis-je passer le plus rapidement possible de la fenêtre de l’assembleur à la
ligne comportant l’erreur ?
Quel outil permet de créer le fichier MOTOROLA-S-RECORD à partir du code intermédiaire ?
Quelle est la différence entre « myflash1 » et « myflash2 » lors de l’exécution des programmes dans le microcontrôleur ?
22
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
Quelle spécification d’erreur a été affichée pour chacune des erreurs 1 - 6 ? Expliquez
les causes de toutes les erreurs. Inscrivez les résultats dans le tableau suivant.
Remarque erreur
Spécification de
texte
Nom de
fichier . ?
Erreur/
avertissement
(F/W)
Numéro d’erreur
Les spécifications d’erreur suivantes ont été affichées / Causes de toutes les erreurs
Cause
-LDX
1
MYFLASH2
.asm
F
MYFLASH2
.asm
F
P1 CTL
MYFLASH2
.asm
F
DELAY
MYFLASH2
.asm
F
3fff
MYFLASH2
.asm
F
Charger
X avec
P1CTL
Néant
W
Néant
2
3
4
5
6
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
23
Introduction à la programmation du microcontrôleur
CMC 1M
Exercice 3 :
Travail avec le débogueur
Objectif :
•
•
•
•
•
•
•
•
•
•
•
•
•
Démarrer le débogueur
Apprendre à connaître les messages possibles au démarrage
Régler le port COM
Charger un fichier MOTOROLA-S-RECORD
Mode continu
Mode pas à pas
Déroulement en temps réel jusqu’à une adresse de programme définie
Déroulement en temps réel continu dans le microcontrôleur
Réinitialisation du compteur de programme (RESET)
Définir/supprimer des points d’interruption
Visionner des zones/contenus de mémoire
Modifier le contenu de mémoire et de registre, ainsi que des contenus de verrou de port
Quitter le débogueur
Exercice :
Chargez le projet existant « CMC1M-1 ». Ajoutez un autre fichier de texte source existant
appelé « cmc1m12.asm ». Enregistrez ce fichier sous le nom « myled.asm ».
Créez un code de programme chargeable à partir de ce fichier. Démarrez le débogueur. Entrez le port COM utilisé pour le MCLS-modular, enregistrez les options.
Basculer le commutateur S1 vers le bas.
Réglez le compteur de programme sur F800H (RESET). Exécutez le mode pas à pas jusqu’à
ce que vous ayez exécuté la commande plusieurs fois à cette adresse dans la boucle du
programme. Observez le contenu du registre IX dans la barre de registres.
Quittez la boucle de temps par un déroulement de programme jusqu’à l’adresse F81CH.
Définissez un point d’interruption sur l’adresse F819H. Démarrez le déroulement en temps
réel du microcontrôleur. Après le point d'interruption, poursuivez l'exécution en temps réel.
Supprimez le point d’interruption et démarrez de nouveau le déroulement en temps réel. Observez les effets sur le MCLS-modular.
Vérifiez l'influence du commutateur S1 sur l'affichage. Quittez le mode temps réel (RESET).
Simulez un signal d’entrée sur P1 en réglant le registre de direction du port P1DDR sur
AAAAAAAA et en remplaçant les données du port de P1Out par 00110011. Contrôlez
l’influence du commutateur S1 sur l’affichage.
Remplacez le contenu de la mémoire de code à l'adresse F820H (C0) par 2F et à l'adresse
F821H (00) par FF. Vérifiez les effets sur le déroulement du programme.
Quittez le débogueur.
24
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
Procédure :
•
•
Démarrez l’environnement de développement intégré pour le MCLS-modular depuis le
menu principal á.
Ouvrez le projet « CMC1M-1 ».
•
Insérez le fichier « cmc112.asm » dans le projet.
•
Enregistrez ce fichier sous « myled.asm » et déclarez-le comme Mainfile.
•
Créez le fichier chargeable MOTOROLA-S-RECORD à partir de ce fichier (assemblage +
conversion).
•
Générez un fichier de symbole ( cliquez sur le symbole
« Outils » du « Start User-Tool » de l'IDE).
•
Démarrez le débogueur.
dans la barre d'outils
ª sur le symbole
dans la barre d’outils « Outils » de l’IDE
(ou menu Démarrer Ö Outils ÖDébogueur)
•
Réagissez aux messages
ª du système d’exploitation
« Le système ne peut pas ouvrir le port COM1(2) » (par ex.)
Cause :
Ce port est déjà occupé
par la Ö sur « Ignorer »
ª du débogueur
« Erreur périphérique série : veuillez réinitialiser le système microcontrôleur ! »
Cause 1:
Le port COM sur lequel le débogueur est momentanément réglé ne
correspond pas au port COM du MCLS-modular.
Ö sur « OK » (ou touche ↵/Enter) Ö réglez le débogueur sur le port COM du
MCLS-modular
Cause 2:
Le microcontrôleur est encore en mode temps réel.
Ö Actionnez la touche RESET du module microcontrôleur
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
25
Introduction à la programmation du microcontrôleur
CMC 1M
Menu
Barre de
registres
Adresse
de commande
Nom de registre
position actuelle
de compteur
Contenu de registre
Marquage point
d'interruption
Nom de port
Code de
commande
Mnémonique
de commande
Contenu verrou
de port
Emplacement mémoire suivants
Emplacement
mémoire réglé
Adress d'emplacement
mémoire réglé
Fig.: 110 : Vue du débogueur
•
Réglez le port COM
ª Menu Options ÖDébogueur ÖChoisir port COM Ö OK
ª Menu Options ÖEnregistrer options
•
Chargez un fichier MOTOROLA-S-RECORD
ª Après le démarrage du débogueur, le fichier MOTOROLA-S-RECORD du fichier
principal a été automatiquement chargé
(ª OU menu Fichier Ö Charger MOTOROLA-S-RECORD... ÖSélectionner fichier ÖOuvrir)
•
Exécutez le mode continu
ª Touche F8 (OU menu Exécuter ÖSingle proc)
REMARQUE : l’ensemble du sous-programme appelé avec la commande indiquée par le
compteur de programme est exécuté en temps réel. Si la commande marquée n’est pas un
appel de sous-programme, le déroulement s’effectue en pas à pas.
•
Réglez le compteur de programme sur l’adresse F800H (RESET)
ª Touche CTRL+F3 (OU menu Exécuter ÖRéinitialiser programme)
ª En mode temps réel actionner la touche RESET sur l’adaptateur 8 bits
•
Exécutez le mode pas à pas
ª Touche F7 (OU menu Exécuter ÖSingle step)
REMARQUE : le programme de la commande exécuté est celui qui indiqué par le compteur
de programme.
Pour quitter la boucle de temps, utilisez la commande « Goto address ».
•
26
Exécutez le programme jusqu’à une adresse définie (Goto address)
ª Touche F4 (OU menu Exécuter ÖGoto address) ÖEntrer adresse ÖOK
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
REMARQUE : le programme entre la position de compteur actuelle et l’adresse indiquée est
exécuté en temps réel.
•
Définissez un point d’interruption
ª Double-cliquez sur la ligne (OU menu Break ÖSet breakpoint OU touche CTRL+B)
ÖEdition Öentrer adresse sous forme de nombre hexadécimal Ö actionner touche
↵/Enter ÖOK
•
Supprimez un point d’interruption
ª Double-cliquez sur la ligne (OU menu Break ÖSet breakpoint) ÖDelete Ösélectionner l'adresse
ÖOK
•
Exécutez le mode temps réel continu (RUN)
ª Touche F9 (OU menu Run ÖRun program)
REMARQUE : la totalité du programme est exécutée à partir de la position de compteur actuelle. Si des points d’interruption sont insérés, le programme s'y arrête.
Lorsqu'un point d’interruption est atteint, une poursuite immédiate du programme en temps
réel n’est pas possible ! Un test du programme doit d’abord être effectué en mode pas à pas.
Lorsqu'une adresse PC se trouvant à au moins 3 adresses au-dessus de l’adresse du point
d’interruption est atteinte, l'exécution du programme peut être également poursuivie en
temps réel.
•
Faites afficher une zone/contenu de mémoire
ª Choisir la zone de mémoire
ÖMenu View Öchoisir une zone de mémoire (RAM/ROM)
( l’affichage s’effectue depuis l’adresse 0000H)
ª Choisir l’adresse de l’emplacement de mémoire
ÖMenu View ÖView address Öentrer l'adresse ÖOK
REMARQUE : l'affichage a lieu à partir de l'adresse sélectionnée.
• Modifiez le contenu de mémoire et de registre, ainsi que les contenus de verrou de port
ª Afficher l’emplacement de mémoire souhaité
Ö sur l’emplacement de mémoire, le registre ou le port Öentrer modification
REMARQUE : la valeur entrée est immédiatement valide.
•
Quittez le débogueur
ª Presser les touches ALT+X (OU menu Fichier ÖQuitter)
REMARQUE : en mode temps réel, la saisie par le clavier ou la souris n’est pas possible.
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
27
Introduction à la programmation du microcontrôleur
CMC 1M
Questions :
Comment peut-on régler le port COM ?
Quelle est la différence essentielle entre le mode pas à pas et le mode continu et quel
est leur caractère commun ?
Quel est l'effet d'un point d’interruption lors de l’exécution d’un déroulement en temps
réel ? Que faut-il noter au démarrage d’un déroulement en temps réel à partir d’un
point d’interruption ?
Comment pouvez-vous visionner le contenu de l’emplacement de mémoire 1008H ?
Expliquez la procédure.
28
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
Introduction à la programmation du microcontrôleur
CMC 1M
Comment pouvez-vous modifier le contenu d’un emplacement de mémoire ?
Quel est l'effet du commutateur S1 sur l'affichage LED ?
Quelle modification de l'affichage engendre-t-elle des modifications quant au contenu
de la mémoire à l'adresse F820H [C0 par 2F] et à l'adresse F821H [00 par FF] ?
Quels sont les moyens permettant de quitter le débogueur ?
CMC 1M-1 Premiers pas dans la programmation d'un microcontrôleur
29
Introduction à la programmation du microcontrôleur
CMC 1M
CMC 1M-2 Le microcontrôleur 68HC11
Structures de mémoire, zones d’adresse, types d’adressage, composants « on-chip », liste de commandes
Notions de base
Les microcontrôleurs sont des systèmes de microordinateur complets montés sur une puce.
L’unité centrale (CPU), la mémoire, les périphériques et le système d’interruption sont regroupés sur une puce et reliés entre eux par un ou plusieurs systèmes de bus.
Le MC68HC11E1 est un dérivé de la gamme M68HC11 de MOTOROLA. Contrairement au
MC68HC11E9, il ne possède pas de mémoire de programme sur la puce. Sur le module
PSD2-Flash, une SRAM (dans la puce PSD) de 2 kilooctets sert de mémoire commune externe de programme et de données.
La périphérie « on-chip » suivante est intégrée dans le MC68HC11E1 :
• Système d'horloge 16 bits avec prédiviseur, fonctions de comparaison et de capture
• Interruption en temps réel
• 2 interruptions matérielles
• Interface de communication série asynchrone
• Interface SPI
• Convertisseur A/N 8 bits avec 8 entrées multiplex
• Système Watchdog
• Système de contrôle d'horloge programmable
Les principaux constituants de la CPU sont la commande de déroulement avec décodeur
d’instruction, l’UAL (unité arithmétique et logique) et des registres variés, dont certains à
fonctions de pointeur.
On trouve « on-chip » 512 octets de RAM comme mémoire de données et 512 octets d'EEPROM (mémoire de données ou de programme).
Tout l'espace d'adressage pour la mémoire interne et externe de programme et de données
présente une structure linéaire. À côté de la mémoire de programme et de données externe,
la puce comporte la mémoire de données interne. Physiquement séparés l’une de l’autre, on
y trouve une mémoire RAM de 256 octets (adresses 0000H-01FFH) et une mémoire de 128
octets pour les registres de fonctions spéciales (adresse 1000H-103FH). Par ailleurs, une
EEPROM de 512 octets (adresse B600H-B7FFH) est disponible « on-chip » comme mémoire de programme ou de données.
Les mémoires de programmes et de données utilisent un bus d’adresse et de données
commun.
Pour adresser les mémoires, on dispose de 4 modes d’adressage différents :
• Adressage inhérent (Inherent Adressing INH) - composant de la commande
• Adressage direct (Direct Adressing DIR) - adresses $0000-$00FF
• Adressage étendu (Extended Adressing EXT) - adresses $0000-$FFFF
• Adressage indexé (Indexed Adressing IND) - indirect via registres de base et d’index
(X,Y)
30
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Tous les dérivés de la famille M68HC11 ont le même jeu de commandes. Une commande
complète se compose d’un octet de code de commande en tête et, selon la commande, d’un
ou deux autres octets spécifiant les opérandes. Le jeu de commandes contient des commandes de transport, des associations arithmétiques et logiques, des commandes de manipulation binaire, des commandes de saut, ainsi que des commandes de définition, de suppression et de déplacement. Une particularité sont les commandes de multiplication et de
division.
Toutes les commandes des programmes chargés dans le microcontrôleur par le fichier Motorola-S-Record sont déposées octet par octet sur les adresses de la mémoire de programmes. Ce faisant, plusieurs octets de commande peuvent appartenir à une commande. Après
un changement de niveau défini de low à high sur la broche Reset du contrôleur, les commandes sont traitées successivement par l’unité centrale (CPU) à partir de l’adresse E800H
(pour le module PSD2-Flash, à partir de l'adresse F800H). L’unité centrale (CPU) est commandée par la fréquence d’oscillateur.
Pour un cycle de commandes (lire, décoder, exécuter commande et traiter données), un ou
plusieurs cycles de machine (CM) sont nécessaires. Pour le MC68HC11E1, la longueur du
cycle de machine est d'une cadence. La cadence résulte du ¼ fréquence du quartz
d’oscillateur. Sur le module PSD2-Flash se trouve un quartz de 8 MHz pour l’oscillateur. Il en
résulte ainsi le temps pour un cycle de machine de 0,5 µs.
La périphérie « on-chip » par contre fonctionne de manière entièrement indépendante de
l’unité centrale (CPU). Ses composants sont programmés via des registres de fonctions spéciales intégrés dans la mémoire de données. C’est par ces registres que les transferts des
données des composants s’effectuent également. Certains utilisent la fréquence
d’oscillateur.
Vous trouverez des détails sur le MC68HC11E1 au chapitre 6 des instructions de service du
module PSD2-Flash et dans l’information compacte.
CMC 1M-2 Le microcontrôleur 68HC11
31
Introduction à la programmation du microcontrôleur
CMC 1M
MCLS - modular
GND
U5P
S4
S3
S2
S1
U5P
PSD1
PSD2
7
6
5
4
3
2
1
0
P1
P0
P5
P1
7
SO4000-1R
GND
U5P
7
6
6
5
4
3
2
1
MOTOROLA
1
0
SO4000-1P
UREF
GND
2.3
PE
P6
GND
U5P
SO4000-1I
RESET
1.3
2.4
ANGND
PSD2-FLASH
GND
BNC - ADAPTER
2
RESET
68HC11E1
1.4
1.2
3
2.5
PSD2
U5P
4
LED - UNIT
RESET
0
1.5
U5P
5
PA
P4
SWITCH - UNIT
GND
7
6
5
4
3
2
1
0
PD
P3
(TxD)
SO4000-1T
8 - BIT ADAPTER - UNIT
1.1
GND
2.2
(RxD)
SO4000-1K
3.1
U5P
1.0
2.1
GND
3.0
2.0
Arbeitsplattform
Working Platform
SO4000-1E
Fig. 201 : Configuration de l’appareil pour l’expérience CMC 1M-2
Montage de l’expérience CMC 1M-2
Appareils et équipements requis
Pcs
Désignation
N° id.
1
1
SO4000-1E
SO4000-1F
1
1
1
1
1
1
1
1
1
8
8
Plate-forme avec module d’alimentation en courant +5V
Alimentation enfichable CA 90...230V, 45..65Hz, CC 9V,
630mA
Module PSD2-FLASH à contrôleur 68HC11
Adaptateur de 8 bits
Unité à LED
Unité de commutation
Adaptateur BNC
Oscilloscope
Logiciel IDE pour MCLS (D,GB,F,E)
Câble d’interface série 9/9 pôles
Câble de mesure BNC / BNC
Câble de connexion 2mm 15cm bleu
Câble de connexion 2mm 15cm jaune
1
1
CMC 1M Introduction à la programmation du microcontrôleur
Instructions de service du module PSD2-Flash
SH5014-1L
BD4000-1I
32
SO4000-1I
SO4000-1K
SO4000-1P
SO4000-1R
SO4000-1T
LM6203
SO4001-9H
LM9040
LM9034
SO5126-5K
SO5126-5M
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Configuration de l’appareil
Coupez l’alimentation électrique du MCLS-modular !
Reliez la plate-forme de travail avec votre PC via le câble d’interface série.
Connectez l’adaptateur 8 bits avec le module PSD2-Flash adapté sur l’emplacement à
douilles (BF) 4.0 - 4.5 au milieu de la plate-forme. Veillez aux plots de contacts au milieu de
l’adaptateur (TxD, RxD) ! Connectez l’unité LED à droite à côté de l’adaptateur 8 bits (par ex.
BF 2.6 – 2.7). Placez l’unité de commutation sur BF 1.6 – 1.7 et l’adaptateur BNC sur BF 2.4
de la plate-forme de travail. Reliez la LED 7 au Port A douille 4 (PA.4) et la LED 6 à PA.5.
Connectez l’oscilloscope à PA.4 (masse sur GND !). Raccordez le crayon de contrôle logique à la tension de service (plots U5P et GND).
Branchez l’alimentation électrique au MCLS-modular.
Consigne de sécurité :
Veillez à la connexion correcte des potentiels de tension (gauche U5P, droite GND) !
Les points de mesure sortis ne doivent pas recevoir de tensions extérieures. Des composants dans les plaques d’enseignement risquent sinon d’être détruits !
Pour la réalisation des expériences, conservez à portée de main le manuel de
l’environnement de développement intégré (IDE) et les instructions de service du module
PSD2-Flash. Lisez l’information compacte en annexe aux instructions de service du module
PSD2-Flash.
Exercice 1:
Périphérie « on-chip »
Objectif :
•
•
•
•
Apprendre à connaître les périphériques importants
Réinitialiser le matériel
Rapport entre la fréquence d’oscillateur externe, la fréquence d'horloge interne et les
durées de déroulement de programmes
Rapport entre la périphérie « on-chip » et l’unité centrale (CPU)
Exercice :
Créez le projet « CMC1M-2 » avec le fichier « cmc1m21.asm ».
Déterminez par le calcul la durée pour deux déroulements de programme (programme principal). Vérifiez le résultat en mesurant la durée de période d’une oscillation avec
l’oscilloscope sur le port A.4 pendant le déroulement en temps réel.
Insérez le fichier « cmc1m22.asm » dans le projet (ce programme fait clignoter une diode
LED et démarre l’horloge comme générateur de fréquence pour le port A.4). Testez les effets
des longs programmes principaux sur la durée de période de l’oscillation générée sur PA.4.
Pendant le déroulement en temps réel, vérifiez le niveau qui entraîne une réinitialisation
(RESET) à l’entrée/sortie « Reset » de l’adaptateur 8 bits.
CMC 1M-2 Le microcontrôleur 68HC11
33
Introduction à la programmation du microcontrôleur
CMC 1M
Notions de base :
•
Architecture de contrôleur – schéma des connexions
À côté de la périphérie représentée dans le schéma des connexions, la puce comporte également une commande d’interruption étendue.
•
•
34
Une réinitialisation (RESET) du matériel permet de régler le compteur de programme
(Programmcounter – PC) sur l’adresse F800H.
1 cycle de machine (CM) dure 1 cadence interne TE. Une commande peut requérir plusieurs CM.
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Procédure :
•
•
Démarrez l’IDE
Créez un nouveau projet « CMC1M-2 »
ª Chargez le projet « CMC1M-1 » et renommez-le, créez un nouveau fichier
« cmc1m21.asm », copiez toutes les conventions nécessaires pour l’assembleur
dans ce fichier, supprimez tous les autres fichiers.
ª Entrez le programme principal suivant :
Clra
out: staa $1000
; supprimer contenu d'accu
; données d'accu vers port A
coma
; inverser l'accu
bra out
; reprend le programme au départ
end
ª Calculez la durée de déroulement du programme
¹
Déterminez la fréquence d’oscillateur
TE = 4/fréquence quartz
¹
Déterminez le nombre de cycles de machine par commande (cf. liste des commandes)
¹
Déterminez la durée du cycle de machine
Tcom = TE * nombre de cycles
¹
Additionnez toutes les durées d’exécution des commandes
TDE= Σ Tcom
REMARQUE : n'utilisez que les commandes du programme principal.
ª Créez le fichier MOTOROLA-S-RECORD et chargez-le dans le contrôleur, lancez le
déroulement en temps réel, mesurez la durée de période de l’oscillation au port A.4.
•
Insérez le fichier « cmc1m22.asm » dans le projet.
ª Créez pour cela le fichier MOTOROLA-S-RECORD et chargez-le dans le contrôleur,
mesurez la durée de période au port A.4.
ª Exécutez le mode continu jusqu’à ce que le programme principal se soit plusieurs
fois déroulé Öobservez-en les effets sur les résultats de la mesure
REMARQUE : une fois les composants périphériques démarrés, ils fonctionnent indépendamment de l’unité centrale (CPU) et donc du reste du déroulement de programme.
•
Testez la réinitialisation (RESET) du matériel
CMC 1M-2 Le microcontrôleur 68HC11
35
Introduction à la programmation du microcontrôleur
CMC 1M
ª Le contrôleur est en mode temps réel.
ª Tenez la pointe du crayon de contrôle logique dans la douille « RESET » de
l’adaptateur 8 bits.
ª Appuyez sur la touche RESET de l’adaptateur 8 bits.
Questions :
Quelle périphérie « on-chip » le 68HC11E1 possède-t-il ? Nommez au moins 4 composants différents.
Quelle durée avez-vous calculée pour 2 déroulements du programme principal ? Justifiez le résultat.
Quelle durée de période avez-vous respectivement mesurée pour le programme
« cmc121.asm » et « cmc1m22.asm » au port A.4 ?
36
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Comment réagit la durée de période de l’oscillation au port A.4 à d’autres commandes
du programme principal dans le programme « cmc121.asm » ?
Quel est l’effet du programme de clignotement lent sur la sortie commandée par horloge du port A.4 (programme « cmc122.asm ») ? Justifiez votre réponse.
Quelle solution programmée doit-elle être utilisée, en particulier dans les applications
sensibles en matière de durée (par ex. comme générateur de fréquence) ? Quelle périphérie « on-chip » utilise-t-elle ?
Combien dure 1 cycle de machine lorsqu'on utilise un quartz 8 MHz ? Justifiez le résultat.
Quel niveau déclenche-t-il une réinitialisation (RESET) ? Sur quelle adresse le compteur de programme est-il alors réglé ?
CMC 1M-2 Le microcontrôleur 68HC11
37
Introduction à la programmation du microcontrôleur
CMC 1M
Exercice 2 :
Structure de programme et de données, adressage de mémoire
Objectif :
•
•
•
Apprendre à connaître le modèle de programmation
Apprendre à connaître la structure de mémoire
Adresser les différentes mémoires
Exercice :
Dans les instructions de service du module PSD2-Flash, lisez le chapitre 6, ainsi qu'en annexe, au chapitre consacré à l'architecture du contrôleur, les points dédiés au modèle de
programmation (registres CPU), aux composants de la mémoire dans l'espace d'adressage
64 kilooctets, aux adresses des vecteurs d'interruption dans la mémoire de programme et la
zone d'adresses du registre des fonctions spéciales. Familiarisez-vous avec les opérations
lors de l’adressage réduit, étendu et indexé des emplacements de mémoire en traitant pas à
pas le programme « cmc1m23 ». Examinez le contenu de l’emplacement de mémoire
source et cible avant et après chaque exécution de commande.
Notions de base :
•
Registres CPU
¹ Accumulateur A (8 bits)
¹ Accumulateur B (8 bits)
¹ Accumulateur double D (16 bits, registres A + B)
¹ Registre d'indexage X (IX) (16 bits)
¹ Registre d'indexage Y (IY) (16 bits)
¹ Stack Pointer SP (16 bits)
¹ Programm Counter PC (16 bits)
¹ Condition Code Register CCR (8 bits)
•
Architecture du contrôleur – Zone d'adressage de la mémoire
REMARQUE : toutes les mémoires de programme et de données sont disposées dans une
zone d'adressage linéaire.
•
Mémoire de données interne (« on-chip »)
¹ RAM
Adresses $0000-$01FF
¹ Bloc de registre 64 octets (registre de fonctions spéciales)
Adresses $1000-$103F
•
Mémoire de constantes interne (« on-chip »)
¹ EEPROM
Adresses $B600-$B7FF
REMARQUE : le module PSD2-Flash possède une mémoire de programme et de données
externe de 2 kilooctets.
38
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
ATTENTION : sur le module PSD2-Flash, la zone de mémoire est utilisée en commun par
les mémoires de programme et de données.
Vous devrez en tenir compte lorsque vous définirez les adresses de mémoire.
•
Adressage réduit (DIR) - Adresses $0000-$00FF
¹ Réduit le code de commande (premier octet d'adresse toujours $00 – n'est pas
mentionné)
¹ Octet d'adresse précédé par le symbole « < » (sans espace)
•
Adressage étendu (EXT) - Adresses $0000-$FFFF
¹ Adressage standard (y compris registres de fonctions spéciales)
•
Adressage indexé (IND,X / Y) - Adresses $0000-$FFFF
¹ L'adresse résulte de la somme du contenu des registres d'indication et de la valeur offset
¹ Les registres d'indication sont les registres d'index X et Y
•
Assignation de valeurs (IMM) registres CPU
¹ Uniquement pour les registres de la CPU
¹ Valeurs 8 bits et 16 bits possibles
¹ Symbole « # » précède la valeur (sans espace)
REMARQUE : les registres de fonctions spéciales de la périphérie on-chip sont activés par
des accès à l'écriture et à la lecture à l'adresse de mémoire correspondante !
CMC 1M-2 Le microcontrôleur 68HC11
39
Introduction à la programmation du microcontrôleur
CMC 1M
Procédure :
•
•
•
•
Démarrez le projet « CMC1M-2 » et insérez le fichier « cmc1m23.asm »
Imprimez ce fichier source
À partir de ce fichier, créez un fichier Motorola-S-Record et chargez-le dans le contrôleur
Familiarisez-vous avec les déroulements de commandes à l’aide du débogueur
ª Affichez l’adresse source et cible
ª Exécutez la commande
ª Comparez le contenu des adresses source et cible (voir le commentaire pour chaque
commande)
ª Notez les valeurs aux réponses du questionnaire sur l'impression du fichier source
REMARQUE : en cas de différences, vérifiez l’adresse de mémoire affichée dans le débogueur.
Questions :
De quels registres l'accumulateur double D se compose-t-il ?
Où sont localisés les registres de la CPU dans l'espace d'adressage ?
Quelles mémoires de données internes y a-t-il et dans quelles zones d’adresse se
trouvent-elles ?
Quels sont les avantages de l'adressage réduit (cf. les commandes de programme
« cmc1m23 » dans les lignes « va1: » et « ea0: » ?
40
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Quels registres peuvent être utilisés comme registres d'indication ?
De quoi faut-il se servir pour charger le registre d'indication avant l'adressage indexé
?
Que devez-vous observer lors de l'assignation de valeurs quant à la cible ?
Comment les registres de fonctions spéciales (bloc de registres 64 octets) sont-ils
activés ?
Quel est le contenu (hexadécimal) de l'accu B après l'exécution de la commande dans
la ligne « ea7: » dans le programme « cmc1m23 » ?
Quel est le contenu (hexadécimal) de l'accu A après l'exécution de la commande dans
la ligne « ia2: » dans le programme « cmc1m23 » ?
CMC 1M-2 Le microcontrôleur 68HC11
41
Introduction à la programmation du microcontrôleur
CMC 1M
Exercice 3 :
Travail avec la liste de commandes
Objectif :
•
•
•
•
•
Structure de la ligne de commande
Manipulation de la liste de commandes
Commandes avec une adresse indexée
Sauvegarde de fichiers pour des valeurs 16 bits
Types de commande
Notions de base :
•
Structure de la ligne de commande
Opérateur Opérande(s)
Opérateur
Opérande
: Code de commande
: adresse de mémoire ou valeur
(opr), masque de bits (msk),
cible (rel)
ATTENTION :
Les commandes peuvent avoir aucun opérande, mais aussi jusqu'à opérandes. Plusieurs
opérandes seront écrits dans l'ordre suivant :
(opr) (msk) (rel)
•
42
Abréviations de la liste de commande
(opr)
(msk)
(rel)
-
Adresse de mémoire ou valeur
Masque pour commandes de manipulation de bits
Cible de saut pour commandes Branch
ii
jjkk
dd
-
hhll
ff
-
rr
-
mm
-
Valeur 8 bits pour assignation de valeurs
Valeur 16 bits (octet high+low) pour assignation de valeurs
Adresse de mémoire (octet low)
(octet high = $00) pour adressage réduit
Adresse de mémoire (octet high+low) pour adressage étendu
Offset positif 8 bits pour adressage indexé
[$00 (0) - $FF (255)]
Adresse de la cible du saut
[adresse offset 8 bits relatif (de -128 à +127)]
Masque de bits 8 bits
A
-
Accumulateur A
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
B
D
IX
IY
CCR
SP
C
V
Z
N
I
X
-
Accumulateur B
Accumulateur double D (A+B)
Registre d'index X (registre d'indication)
Registre d'index Y (registre d'indication)
Registre de codes de condition (flag register)
Pointeur de pile
Indicateur d'état
Composant double indicateur de dépassement
Indicateur zéro
Indicateur négatif
Masque d'interruption I
Masque d'interruption X
M
-
Adresse de mémoire 16 bits ou valeur
Adresse de mémoire 16 bits ou valeur (octet high)
Adresse de mémoire 16 bits ou valeur (octet low)
Adresse de mémoire 16 bits ou valeur
Octet high corrélé à octet low
→
-
Transmettre vers ...
+
x
/
-
Addition
Soustraction
Multiplication
Division
•
+
⊕
/
?
-
ET logique
OU logique
OU EXCLUSIF
NON logique (un composant)
NÉGATION (deux composants)
Condition remplie ?
IMM
DIR
EXT
IND,X
(IND,Y)
REL
-
Code pour assignation de valeur
Code pour adressage réduit
Code pour adressage étendu
Code pour adressage indexé par registre d'indication X (Y)
-
Code pour adressage relatif avec offset
¦
-
L'indicateur se modifie en fonction du résultat de l'opération (0 ou 1)
M+1
M:M+1
CMC 1M-2 Le microcontrôleur 68HC11
43
Introduction à la programmation du microcontrôleur
CMC 1M
•
Représentation des nombres
¹
¹
¹
•
binaire
hexadécimal
décimal
%
$
sans
%10001000
$FA3C
464, -53
Identification des valeurs
ATTENTION : les valeurs d'adresses de mémoire sont précédées d'un # !
ATTENTION : un masque de bits représente également une valeur !
• Identification d'adresses de mémoire pour l'adressage réduit
Pour se distinguer des adresses de mémoire pour l'adressage étendu, les adresses de mémoire pour l'adressage réduit sont précédées d'un « < » !
• Occupation de la mémoire avec des données 16 bits
L'octet high du mot de données à 16 bits est sauvegardé sur l'adresse de mémoire paire (par
ex. $1000)
¹ L'octet low du mot de données à 16 bits est sauvegardé sur l'adresse de mémoire impaire qui suit (par ex. $1001)
• Syntaxe de la commande pour un adressage indexé
Opérateur
valeur offset, registre d'indexation
Opérateur :
désigne aussi la source ou la cible contenant ou recevant les données
Valeur offset : valeur 8 bits additionnée au contenu du registre d'indexation
Registre d'indexation : identifiant x ou y définissant le registre d'indexation à utiliser
L'adresse de mémoire effectivement activée résulte de l'addition de l'offset et du contenu
du registre d'indexation défini.
Ex. :
LDAA 01,x
¤ Charge l'accu A (cible) avec le contenu de l'emplacement de mémoire qui résulte de
la somme de 01 et du contenu du registre d'indexation X.
STAB $A0,y
¤ Enregistre le contenu de l'accu B (source) à l'emplacement de mémoire qui résulte de
la somme de $A0 et du contenu du registre d'indexation Y.
REMARQUE : un masque de bits (opérande) représente également une information de
« données ».
Ex. :
BSET 00,y #%00010001
¤ Règle les bits de l'emplacement de mémoire qui résulte de la somme de 00 et du
contenu du registre d'indexation Y selon le masque %00010001 (« information de données »).
REMARQUE : il existe des opérateurs qui ne désignent ni source ni cible ; dans ce cas, les
adresses indexées constituent elles-mêmes la source et la cible.
44
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Ex. :
ROL 10,x
¤ Tourne d'une position à gauche le contenu de l'emplacement de mémoire qui résulte
de la somme de 10 et du contenu du registre d'indexation X (source et cible)
ATTENTION : la valeur offset et l'identifiant du registre d'indexation doivent toujours être
séparés par une virgule (ou d'un espace) !
ATTENTION : la valeur offset doit être positive !
•
Types de commande
¹
¹
¹
¹
¹
¹
¹
¹
Commandes arithmétiques
Addition
Soustraction
Incrémentation (+1)
Décrémentation (-1)
Multiplication
Division
Correction décimale (DA)
Comparaison
¹
¹
¹
¹
¹
¹
Commandes logiques
Lien ET
Lien OU
Lien OU EXCLUSIF
INVERTIR
NÉGATION LOGIQUE
EFFACER (tous bits = 0)
¹
¹
¹
¹
¹
Commandes de transport
Commandes de chargement
Commandes d'enregistrement
Commandes d’échange
Sauvegarde de mémoire de données directement adressable (stack)
Commande vide
ª
ª
ª
ª
Commandes de traitement binaire
¹ Définis bit
¹ Supprime bit
ª
Commandes de test de bits
¹ Teste bit(s)
ª
Commandes de déplacement
¹ Rotation vers la gauche
¹ Rotation vers la droite
ª
Commandes de saut
¹ Sauts inconditionnels
¹ Sauts conditionnels (Branch)
CMC 1M-2 Le microcontrôleur 68HC11
45
Introduction à la programmation du microcontrôleur
CMC 1M
REMARQUE : les conditions de saut sont des états d’indicateur dans le registre des codes
de conditions CCR.
REMARQUE : il existe des sauts conditionnels dont la condition provient du résultat d’un
décrément ou d’une comparaison (commande de combinaison).
ª
Commandes de sous-programmes
¹ Appel du sous-programme (SP)
¹ Retour du sous-programme au programme principal
¹ Retour de la routine de service d’interruption au programme principal
Exercice :
Reliez l'unité de LED au port1 du module PSD2-Flash. Reliez les mêmes bits entre eux.
Écrivez dans le fichier « cmc1m24.asm » les lignes de commande correctes pour les instructions suivantes. Procédez à l’assemblage et créez le fichier MOTOROLA-S-RECORD.
À l’aide du débogueur (mode pas à pas), vérifiez que les commandes ont été correctement
exécutées.
•
Charge accu A avec la valeur $20, écrivez le symbole « début » (marque d’adresse) au
début de cette ligne de commande
•
Enregistre le contenu de l'accu A à l'emplacement de mémoire $0010 (adressage étendu)
•
Charge accu B avec le contenu de l'adresse $10 (adressage réduit)
•
Charge accu A avec la valeur $10
•
Charge registre d’indexation X avec la valeur $0020 (valeur d’adresse)
•
Charge accu A avec la valeur %10101010
•
Enregistre le contenu de l'accu A à l'adresse « indiquée » par le registre d’indexation X,
la valeur offset est 00 (adressage indexé)
•
Charge registre d’indexation Y avec la valeur d’adresse $1805 (Port1 – registre de sortie
de données)
•
Définis un ou des bits à l'adresse « indiquée » par le registre d’indexation Y, la valeur
offset est 02 (donne Port1 – registre de direction), le masque de bits est $FF, (adressage
indexé)
•
Définis un ou des bits à l'adresse « indiquée » par le registre d’indexation Y, la valeur
offset est 00 (donne Port1 – registre de sortie de données), le masque de bits est
%11111111, (adressage indexé)
•
Appelle la sous-routine (sous-programme) avec la marque d'adresse « sr_delay »
46
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
•
Supprime l'indicateur d'état (Clear Carry)
•
Tourne à droite le contenu de l'adresse « indiquée » par le registre d’indexation Y, la valeur offset est 00 (P1OUT), (adressage indexé),
écrivez au début de cette ligne de commande le symbole « rore » (marque d'adresse)
•
Appelle la sous-routine (sous-programme) avec la marque d’adresse « sr_delay »
•
Lorsque le bit de l'adresse « indiquée » par le registre d’indexation Y est défini, saute à la
marque d’adresse « rore », la valeur offset est 00, le masque de bits est %00010000,
(Branch if Bit(s) set),
(adressage indexé)
•
Charge accu A avec la valeur %10011001
•
Établit un lien ET du contenu de l'accu A avec le contenu de l’adresse de mémoire $1805
(le résultat est enregistré dans l'accu A)
(adressage étendu)
•
Additionne la valeur 2 au contenu de l'accu A, écrivez au début de la ligne de commande
le symbole « add » (marque d’adresse) !
•
Inverser (Complement) le contenu de l'adresse « indiquée » par le registre d’indexation
Y, la valeur offset est 00 (donne Port1 – registre de sortie de données), (adressage indexé)
•
Appelle la sous-routine (sous-programme) avec la marque d’adresse « sr_delay »
•
Saute à la marque d’adresse „begin“
•
;
Sous-routine sr_delay (sous-programme)
;************************************************************
Enregistre le contenu du registre d'indexation X dans la pile, écrivez au début de cette
ligne de commande le symbole « sr_delay » (marque d’adresse)
•
Charge le registre d’indexation X avec la valeur $0000
•
Décrémente le registre d’indexation X, écrivez au début de cette ligne de commande le
symbole « loop » (marque d’adresse)
•
Tant que le contenu de X > 0, saute à la marque d’adresse « loop » (Branch if > Zero)
•
Reprend le contenu du registre d’indexations X depuis la pile
•
Saute du SP au programme principal (Return from Subroutine)
Procédure :
CMC 1M-2 Le microcontrôleur 68HC11
47
Introduction à la programmation du microcontrôleur
CMC 1M
•
•
Ouvrez le projet « CMC1M-2 » et insérez le nouveau fichier « cmc1m24.asm ». Insérez
les conventions nécessaires pour l’assembleur.
Saisissez les commandes. Veillez aux symboles mentionnés (marques d’adresse).
ª Déterminez respectivement l’opérande cible et l’opérande source
¹ Quel registre ?
¹ Quelle adresse de mémoire ?
¹ Quelle valeur ?
¹ Quel type d’adressage ?
ª Recherchez le code de commande correspondant dans la liste de commandes
ª Entrez la ligne de commande complète
•
•
Créez un fichier MOTOROLA-S-RECORD et chargez-le dans le contrôleur.
Exécutez le programme en mode pas à pas.
REMARQUE : quittez les boucles de temps en entrant la valeur $01 01 dans le registre de
décrémentation concerné.
Questions :
Quels caractères placés devant le nombre permettent de représenter les nombres binaires, hexadécimaux et décimaux ? Nommez un exemple chacun.
Quelle différence y a-t-il entre les abréviations dd et hhll ? Quel caractère faut-il placer
devant dd ?
48
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Avec quels registres peut-on procéder à un adressage indexé ? Donnez un exemple
de commande
Dans quelle gamme de valeurs la valeur offset peut-elle être comprise et de quoi faut-il
tenir compte ?
Quel caractère permet de distinguer les valeurs des adresses ? Que se passe-t-il si on
l'oublie ?
À l’aide de quelle commande le niveau de sortie d’une broche de port peut-il être inverti ? Donnez un exemple (adresse de porte $1805).
Avec quelles commandes est-il possible de tester le niveau d’entrée à une broche de
port (adresse de porte $1800) et, suivant le résultat, de sauter à une autre adresse de
programme ? Quel type d'adressage faut-il utiliser ? Justifiez votre réponse.
CMC 1M-2 Le microcontrôleur 68HC11
49
Introduction à la programmation du microcontrôleur
CMC 1M
Expliquez la commande ROR.
Expliquez la commande DEX. Influence-t-elle les états de l'indicateur ?
Avec quelle commande peut-on déposer (sauvegarder) le contenu du registre
d’indexation X sur la pile (mémoire de pile) ? Comment peuvent-elles être répétées de
là ?
Avec quelle commande revient-on d’un sous-programme ?
Quelle valeur se trouve dans l'accu A après l'exécution de la commande avec la marque d’adresse « add » ?
50
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Quel listing de programme avez-vous écrit ?
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
*********************************************************
* Projet:
liste de commandes
*
* Date:
02.08.2005
*
* Fichier de projet: CMC 1M-2
*
* Fichier:
cmc1m24.asm
*
* Outils MC:
as, p2hex, debug11f
*
* Profil:
profil intégré PSD2-68HC11-FLASH-AS
*
* Ressource MC: Port1
*
* Auteur:
*
*********************************************************
Le programme exécute des exemples de commandes de la
liste du 68HC11, notamment des commandes de chargement et
d'enregistrement, binaires, Branch (dérivations conditionnelles), rotations et quelques commandes arithmétiques.
Comme sources et/ou cible, on utilise des registres
et/ou adresses de mémoires (registres de fonctions
spéciales, extension de port module PSD2-Flash).
L'adressage indexé est utilisé intensivement lors de
la conversion des commandes.
*****************************************************
; ----- Conventions requises pour l’assembleur----------; **********************************************************
CPU
Org
6811
$F800
; sélection CPU pour assembleur
; programme principal commence ici
;
Programme principal
; **********************************************************
begin:
CMC 1M-2 Le microcontrôleur 68HC11
51
Introduction à la programmation du microcontrôleur
CMC 1M
rore:
add:
;
Sous-routine sr_delay
;**************************************************************
sr_delay:
loop:
;**************************************************************
end
52
CMC 1M-2 Le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
CMC 1M-3 Un premier programme avec le microcontrôleur
68HC11E1
Technique de programmation, technique d’ébauche (analyse des
problèmes, ordinogrammes), liste de programmes
Notions de base
Une analyse détaillée du problème à résoudre doit avoir lieu au début de chaque programmation.
L'exercice énoncé généralement de manière orale doit d’abord être transférée dans des formes de description appropriées (par ex. ordinogrammes) Par étages intermédiaires, on élabore une suite de commande de microcontrôleur dont le traitement séquentiel permet de
solutionner l'exercice. De la série de commandes ainsi élaborée (programme), on génère un
fichier chargeable (par ex. fichier MOTOROLA-S-RECORD) et on le charge dans le contrôleur cible.
Le programme est ensuite débogué, c’est-à-dire que les erreurs dans le programme sont
recherchées, décelées et éliminées. Pour ce faire, le mode pas à pas est préférable.
À partir de l'exercice à réaliser, on élabore en premier lieu une ébauche grossière pour le
matériel requis. L’objectif sera d’utiliser le plus grand nombre possible de périphériques « onchip ».
Les ordinogrammes sont créés depuis le plan de la conception jusqu’au plan de commande
(plan de déroulement de programme-PAP). Partant du PAP, on peut écrire directement la
liste de programme. Ce faisant, toutes les commandes doivent être accompagnées d’un
commentaire bref et clair. En règle générale, on recherchera une programmation modulaire,
c’est-à-dire que le programme sera décomposé en petits éléments (sous-programmes) (par
ex. opérations entrée/sortie, opérations arithmétiques, boucles d’attente). De tels sousprogrammes sont des modules qu'on pourra utiliser plusieurs fois.
Habituellement, un microcontrôleur est démarré par un signal de réinitialisation (RESET)
externe. Une fois le signal émis, le compteur de programme se trouve à une adresse définie
(par ex. F800H) et tous les registres de fonctions spéciales ont été soumis à une initialisation
standard.
La première commande du programme doit se trouver à une adresse définie (par ex.
F800H). Les premières commandes d’un programme doivent amener les composants « onchip » du microcontrôleur (initialisation) dans l’état initial souhaité. Pendant l’initialisation, les
registres de commande de la périphérie « on-chip » (horloge, interface, ADU, etc.) peuvent
être par ex. chargés et le système d’interruption réglé. Puis suit le programme principal.
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
53
Introduction à la programmation du microcontrôleur
CMC 1M
MCLS - modular
U5P
1.7
1.6
PSD1
7
6
5
4
3
2
1
0
PSD2
P1
P0
P5
P1
GND
2.7
PA
P4
7
6
5
4
3
2
1
2.6
RESET
0
1.5
2.5
PSD2
MOTOROLA
1.4
U5P
RESET
68HC11E1
UREF
GND
2.3
PE
P6
7
1.2
U5P
SO4000-1I
RESET
1.3
2.4
ANGND
PSD2-FLASH
GND
6
5
4
3
2
1
0
PD
P3
(TxD)
8 - BIT ADAPTER - UNIT
1.1
GND
2.2
(RxD)
SO4000-1K
3.1
U5P
1.0
2.1
GND
3.0
2.0
Arbeitsplattform
Working Platform
SO4000-1E
Fig.: 301 : Configuration de l’appareil pour l’expérience CMC 1M-3
Montage de l’expérience CMC 1M-3
Appareils et équipements requis
Pcs
Désignation
N° id.
1
1
1
1
1
1
1
1
1
8
1
Plate-forme avec module d’alimentation en courant +5V
Alimentation enfichable CA 90...230V, 45..65Hz, CC 9V, 630mA
Module PSD2-FLASH à contrôleur 68HC11
Adaptateur de 8 bits
Unité à LED
Unité de commutation
Logiciel IDE pour MCLS (D,GB,F,E)
Câble d’interface série 9/9 pôles
Câble de connexion 2mm 15cm bleu
Câble de connexion 2mm 15cm jaune
CMC 1M Introduction à la programmation du microcontrôleur
SO4000-1E
SO4000-1F
SO4000-1I
SO4000-1K
SO4000-1P
SO4000-1R
SO4001-9H
LM9040
SO5126-5K
SO5126-5M
SH5014-1L
54
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Configuration de l’appareil
Coupez l’alimentation électrique du MCLS-modular !
Reliez la plate-forme de travail avec votre PC via le câble d’interface série.
Connectez l’adaptateur de 8 bits avec le module PSD2-Flash adapté sur l’emplacement à
douilles (BF) 4.0 - 4.5 au milieu de la plate-forme. Choisissez les modules d’expérimentation
requis par l’exercice et connectez-les aux ports que vous avez choisis.
Branchez l’alimentation électrique au MCLS-modular an.
Consigne de sécurité :
Veillez à la connexion correcte des potentiels de tension (gauche U5P, droite GND) !
Les points de mesure sortis ne doivent pas recevoir de tensions extérieures. Des composants dans les plaques d’enseignement risquent sinon d’être détruits !
Bibliographie
Pour la réalisation des expériences, conservez à portée de main le manuel de
l’environnement de développement intégré (IDE) et les instructions de service du module
PSD2-Flash. Utilisez l’information compacte en annexe aux instructions de service du module PSD2-Flash.
Exercice 1:
Techniques de programmation, analyse des problèmes, techniques
d’ébauche (ordinogrammes), liste de programme
Objectif :
•
•
•
•
•
•
•
•
•
•
•
Notions générales de programmation
Programmation séquentielle
Dérivations dans le programme
Technique de bouclage
Technique de sous-programmes
Analyse des problèmes relatifs à un exercice
Ébauche conceptuelle sous forme d’ordinogramme
Ébauche algorithmique sous forme d’ordinogramme
Ébauche de programme sous forme d’ordinogramme au niveau des commandes
Symboles usuels des ordinogrammes
Élaboration d’une liste de programme
Exercice :
Élaborez l’ébauche conceptuelle, algorithmique et de programme (respectivement sous
forme d’ordinogramme) pour une rampe d’éclairage. Effectuez d’abord une analyse du problème.
La rampe d’éclairage doit être affichée sur une ligne de 8 LED. Le sens de déroulement de
l’éclairage doit être modifié avec un commutateur à coulisse. La durée de changement entre
les différentes LED doit être d’env. 131 ms.
Écrivez la liste de programme (texte source) à partir de l’ébauche de programme.
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
55
Introduction à la programmation du microcontrôleur
CMC 1M
Notions de base :
•
Notions générales de programmation
ª Configuration simple, claire, sûre et d'application aisée des programmes
ª La décomposition en sous-programmes est recommandée (programmation modulaire)
ª Consignation appropriée des capacités et des interfaces des sous-programmes
ª Standardisation des interfaces
ª Rationalisation des besoins de programmation
ª Veiller à l’économie de matériel (emplacement de mémoire, ressources « on-chip »)
REMARQUE : recherchez toujours une programmation structurée pour plus de clarté et
pour faciliter la recherche des erreurs.
ATTENTION : utilisez la programmation de haut en bas, c’est-à-dire une planification de programme commençant par les propriétés principales du système (niveau
maximum) et se poursuivant par les détails (niveau inférieur).
•
Programmation séquentielle
ª Commandes se suivant de manière séquentielle
•
Dérivation de programme
ª réalisée par opération de décision
o
Condition
remplie ?
n
Exécuter algorithme
•
Technique de bouclage
ª Utilisation des boucles de programme
Ö Boucle de programme :
parcours répété d’une suite de commandes avec modification éventuelle des opérandes
Ö Composants d’une boucle de programme :
• Initialisation du critère de boucle (par ex. registre)
• Traitement de la fonction utile
• Modification du critère de boucle
• Interrogation finale
56
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
REMARQUE : les boucles de programme réduisent les besoins de programmation et de
mémoire.
Initialiser critère
de boucle
Exécuter fonction
utile
Modifier critère de
boucle
n
Fin ?
o
Fig. 302 : Boucle de programme typique
•
Technique de sous-programme
Utilisation de sous-programmes
Ö Sous-programme (SP) :
• Suite de commandes plusieurs fois requises dans le programme (sous-routine,
procédure)
• Appel depuis le programme principal
• L’adresse à laquelle le programme principal doit être poursuivi après le sousprogramme (SP) est mémorisée de manière intermédiaire dans la pile (mémoire de pile)
• Fin avec commande de retour spéciale (par ex. RET)
REMARQUE : les sous-programmes offrent une plus grande clarté dans la configuration du
programme et permettent de réduire les besoins de programmation et de mémoire.
Programme
JSR „SP“
Adresse
démarrage
SousSP:
JSR „SP“
RTS
Commande
retour
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
57
Introduction à la programmation du microcontrôleur
CMC 1M
ATTENTION : les contenus des registres utilisés dans le SP doivent être sauvegardés après
entrée dans le SP sur la pile (mémoire de pile) et repris de là avant le retour du SP.
•
Analyse des problèmes relatifs à un exercice
ª Objectif : à partir de l'exercice à résoudre émis oralement, on élabore en premier lieu
une ébauche grossière pour le matériel requis. L’objectif sera d’utiliser le plus grand
nombre possible de périphériques « on-chip ».
ª Il convient de répondre aux questions suivantes :
Ö
Ö
Ö
Ö
Ö
Ö
Ö
Ö
•
Le problème peut-il être décomposé utilement en problèmes partiels ?
Que convient-il de gérer, planifier, calculer ?
Quelle périphérie « on-chip » est requise ? Sa capacité est-elle suffisante ?
Des interruptions sont-elles nécessaires ?
Combien faut-il d’entrées/sorties ?
Faut-il s’attendre à des états critiques en matière de durée ?
Existe-t-il des solutions connues susceptibles d’être mises en œuvre ?
Quel état initial doit-il être défini ?
Ébauche conceptuelle sous forme d’ordinogramme
ª Description grossière du traitement dans son ordre chronologique
ª Le processus de traitement à exécuter est entré pour chaque bloc (que convient-il de
faire ?)
Initialisation après
RESET
Interr. commutateur S1
Si S1 =1
LED 1 clignote
Fig. 303 : Ordinogramme au niveau conceptuel
ATTENTION : l’ébauche conceptuelle doit être élaborée indépendamment du processeur !
•
Ébauche algorithmique sous forme d’ordinogramme (indépendamment du processeur)
ª Poursuite de la décomposition du niveau conceptuel jusqu’à l’obtention d’étapes de
traitement faciles à exécuter.
ª Il convient de déterminer pour chaque bloc quelles actions doivent être exécutées
dans quel ordre (sans se préoccuper des détails relatifs au processeur).
ª Il est nécessaire de savoir comment l’opération requise doit être exécutée.
ª Utilisable comme plan de déroulement de programme (PAP).
58
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
INIT : après RESET
saut au début du programme
INIT : broche de port
pour LED = sortie
INIT : niveau broche
de port pour LED = 1
(LED éteinte)
Charger comm. S1 sur
broche de port
S1=1 ?
non
oui
Invertir broche de port
pour amorçage LED
Sous-programme
attente (131ms)
Fig. 304 : Ordinogramme au niveau algorithmique
ATTENTION : l’ébauche algorithmique doit être élaborée indépendamment du processeur !
Charger registre
avec N
Décrémenter registre
Registre
différent
de 0 ?
oui
non
Fig. 305 : Sous programme Attente (ordinogramme au niveau algorithmique)
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
59
Introduction à la programmation du microcontrôleur
CMC 1M
•
Ébauche de programme sous forme d’ordinogramme au niveau des commandes (selon
le processeur)
ª Poursuite de la décomposition du niveau algorithmique avec utilisation du jeu de
commandes
ª Résolution de tous les algorithmes
ª Au maximum 3 commandes par bloc
ª Le programme peut en dériver directement
ª Plan de déroulement de programme (PAP)
INIT
P1CTL, bit 0 := 1
INIT
P1OUT, bit 0 := 1
PA.0 =1
?
non
oui
P1OUT, bit 0 := 0
Sous-programme
Attente (131ms)
P1OUT, bit 0 := 1
Sous-programme
Attente (131ms)
Fig. 306 : Ordinogramme au niveau des commandes
60
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Sauver reg. IX dans
pile
Charger reg. IX
avec const. 25
Décrémenter registre IX
IX différent de 0
oui
?
non
Reprendre reg. IX
de la pile
Retour au programme principal
Fig. 307 : Sous programme Attente (ordinogramme au niveau des commandes)
ATTENTION : l’ébauche de programme doit être élaborée en fonction du processeur !
ATTENTION : chaque bloc ne doit pas contenir plus de trois commandes !
•
Symboles usuels des ordinogrammes
Directive de travail
Sous-programme
Opération de décision suivie d'une dérivation
Opération de sortie et de saisie
Début ou fin d’un cycle de programme ou point d’entrée d’une routine
d’interruption
Ligne de déroulement
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
61
Introduction à la programmation du microcontrôleur
CMC 1M
REMARQUE : une méthode également usuelle, en plus de la méthode de ligne de déroulement présentée, est la méthode de ligne conductrice.
Init
n
j
Décision
Directive de travail
Sous-programme
Méthode de ligne conductrice
REMARQUE : la séquence d’ébauche conceptuelle, algorithmique et au niveau des commandes correspond au principe de l’ébauche « de haut en bas ».
•
Élaboration d’une liste de programme
ª Structure
Ö En-tête de programme :
• Titre du programme
• Nom du programmeur
• Numéro de version
• Date de création
Ö Brève description :
• Fonction
• Éventuelles conditions d’entrée et de sortie
Ö Conventions d’assembleur :
• Fichiers Include spéciaux
Ö Assignation de valeurs :
• Assignation de symboles
• Assignation d’adresses
Ö Programme principal
• Commandes
• Commentaires
• La dernière commande est le saut au début du programme principal ou à luimême
Ö Sous-programmes
• Éventuel en-tête de sous-programme (comme en-tête de programme)
• Sauvegarder le contenu des registres utilisés sur pile
• Commandes
• Commentaires
• Récupération sur la pile du contenu sauvegardé des registres utilisés
• Retour au programme principal
Ö Tableau des constantes
• Valeurs binaires constantes comme source de données
REMARQUE : l’utilisation systématique des assignations de valeurs au début de la liste
permet une modification rapide des constantes et adresses dans l’ensemble du programme.
ATTENTION : les commentaires doivent expliquer l’étape de travail, pas la commande !
62
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
ª Règles d’écriture
Ö Voir l'assembleur
Procédure :
•
Répondez aux questions de l’analyse de problèmes en partant de l'énoncé de l'exercice
•
Réalisez l’ordinogramme pour l’ébauche conceptuelle.
ª Subdiviser la tâche en problèmes partiels (résultat de l’analyse des problèmes)
ª Définir l’ébauche suivant la méthode de ligne conductrice
•
Réalisez l’ordinogramme pour l’ébauche algorithmique.
ª Transformer les problèmes partiels de l’ébauche conceptuelle en algorithmes généraux
ª Définition générale des composants de périphérie
Ö Déterminer les composants de périphérie pour la sortie vers ligne de LED (recommandation : Port1)
Ö Déterminer les composants de périphérie pour charger l’état de commutateur
ª Déterminer la mémoire intermédiaire en général (par ex. registre, mémoire de données)
ª Déterminer les dérivations, boucles, sous-programmes
•
ª Définir l’ébauche de programme et de sous-programme suivant la méthode de ligne
de déroulement
Créez l’ordinogramme pour l’ébauche de programme (pour 68HC11E1)
ª Décomposer tous les algorithmes de l’ébauche algorithmique en commandes
concrètes
ª Définition des composants de périphérie
Ö Désigner les composants de périphérie pour la sortie vers ligne de LED
Ö Désigner les composants de périphérie pour charger l’état de commutateur
ª Déterminer la mémoire intermédiaire (désignation de registre, adresse de mémoire
de données)
ª Décomposer les dérivations, boucles, sous-programmes dans tous les algorithmes
ª Définir l’ébauche de programme et de sous-programme suivant la méthode de ligne
de déroulement
•
Créez la liste de programme à partir de l’ordinogramme de l’ébauche de programme
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
63
Introduction à la programmation du microcontrôleur
CMC 1M
ª Créez le projet « CMC1M-3 », utilisez le même profil utilisateur que pour les essais
CMC1M-1 et CMC1M-2, intégrez un nouveau fichier de texte source „cmc1m3.asm ».
ª Entrez la liste de programme dans le fichier de texte source selon la structure générale. Observez les règles propres à l’assembleur.
ª Sauvegardez dans la pile les contenus des registres utilisés dans le sousprogramme.
•
À partir de ce fichier, créez un fichier MOTOROLA-S-RECORD et chargez-le dans le
contrôleur.
•
Testez votre programme au moyen du débogueur.
•
Corrigez les erreurs dans le programme jusqu’à ce que celui-ci fonctionne sans problèmes.
Questions :
Qu’entendez-vous par programmation « de haut en bas » ?
Quelle succession d’ébauches correspond à ce principe ?
Quelle est la dépendance vis-à-vis du processeur pour l’ébauche conceptuelle,
l’ébauche algorithmique et l’ébauche de programme ?
64
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Combien de commandes un bloc pour l’ébauche de programme peut-il contenir ?
Quelles méthodes de génération d’ordinogrammes connaissez-vous ?
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
65
Introduction à la programmation du microcontrôleur
CMC 1M
Solutions des ébauches et de la liste de programme
Ö Ébauche conceptuelle
66
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Ö Ébauche algorithmique
Démarrage
DEMARRAGE DELAY
RETURN
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
67
Introduction à la programmation du microcontrôleur
CMC 1M
Ö Ébauche de programme
Démarrage
DEMARRAGE SP
DELAY
RETURN
68
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Ö Liste de programme
;
;
;
;
;
;
;
;
;
;
;
********************************************************
* Projet pour PSD2/MC68HC11 :
*
*
Rampe d’éclairage à diodes du 27/09/2005
*
* Fichier de projet : CMC1M-3
*
* Fichiers source :
cmc1m3.asm
*
* Outils MC :
as, p2hex, debug11f
*
* Profil :
profil intégré PSD2-68HC11-FLASH-AS *
* Ressources MC : unité à LED complète à P1
*
*
commutateur à PA.0
*
* Auteur :
BB,HAG
*
********************************************************
;
;
;
;
;
;
;
;
;
;
;
;
;
*******************************************************
Description fonctionnelle :
Au port complet 1 (P1.0 - P1.7) du MC sont connectées
les diodes de l’unité LED. Un commutateur de l’unité de
commutation est relié à la broche de port PA.0.
À l’aide du niveau logique réglé par régulateur à coulisse,
on définit le sens de déroulement des LED.
L’interrogation du commutateur est réalisée via un masque de
bits dans l'accu (01), la commande de contrôle de bit 'BITA
,Adresse de port' ainsi que la commande BEQ ,Cible de saut‘.
Le modèle binaire pour la commande du port est déplacé avec
les instructions de rotation 'ROLA' ou 'RORA'.
-------------------------------------------------------
;
cpu
Conventions requises pour l’assembleur
6811
; Définir CPU
START
equ
$F800
; Adresse démarrage de programme
PORTA
equ
$1000
; Adresse données port A
PORT1
P1CTL
equ
equ
$1805
$1807
; Adresse sortie port 1
; Adresse registre de commandes port 1
org
START
; Démarrage à partir de F800H
;
Initialisation
; ------------------------------------------------------LED_LL:
;
Interroger l’état de commutateur à PA0
; ------------------------------------------------------switch:
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
69
Introduction à la programmation du microcontrôleur
CMC 1M
loop1:
;
Affichage sur LED (Port1)
; ------------------------------------------------------out:
;
Sous-programme DELAY
; ------------------------------------------------------wait:
wloop:
; -------------------------------------------------------end
70
CMC 1M-3 Un premier programme avec le microcontrôleur 68HC11
Introduction à la programmation du microcontrôleur
CMC 1M
Annexe
Règles importantes relatives à l’assembleur de A. Arnold pour les
dérivés 68HC11
Format de saisie
<Symbole (Label)> <Commande / Directive> <Paramètre [(,) Paramètre ]> ; Commentaire
Symbole
(Label)
-
-
Désignateur d’adresse de commande (marque) dans la mémoire de programme
(l’adresse exacte est assignée par
l’assembleur)
Désignateur de valeur numérique assignée
(voir Assignation de valeur, assignation
d’adresse)
Il n'existe pas de symboles définis de manière fixe et spécifiques au processeur pour
les registres, les registres de fonctions spéciales, etc.
1ère colonne de ligne
(à partir de la 2e colonne, deux points nécessaires), doit commencer par une lettre
Ces adresses doivent
être définies par l'utilisateur via assignation
d'adresses !
Exemple
DELAY
LDAA
#$10
NEXT:
TIME
LDAB
EQU
$1000
$FA86
PORTA
EQU
$1000
M02x3
Commande
; Symbole dans 1ère colonne, désignateur
; pour adresse de commande
; Symbole pas dans 1ère colonne
; Symbole dans 1ère colonne,
; désignateur pour valeur numérique
; Symbole dans 1ère colonne, désignateur
; pour l'adresse de mémoire du registre
; de fonction spéciale « PORTA »
; Symbole composé de lettres et chiffres
Commande(s) de la liste de commandes du
processeur
à partir de la 2e colonne
de la ligne ou
1 espace vide ou tabulateur derrière symbole
Exemple
LDX
START STAA
Annexe CMC1M
$1003
LDY
$1000
#$1000
; Commande dans la 2e colonne
; Écriture usuelle, après tabulateur
; Commande 1 espace après le symbole
71
Introduction à la programmation du microcontrôleur
CMC 1M
Directive
Paramètre
Instruction de commande de l’assembleur
à partir de la 2e colonne
de la ligne ou
1 espace vide ou tabulateur derrière symbole
(comme avec Commande)
Indication requise pour la commande ou directive (par ex. opérandes de la liste des
commandes)
Peut être un symbole, une valeur numérique, un caractère ASCII ou une chaîne de
caractères
1 espace ou tabulateur
après commande ou directive, plusieurs séparés par virgule, espace
ou tabulateur
Exemple
Table
BRCLR <$00, #%00000001, LOOP ; 3 paramètres séparés par une
; virgule, 1 espace derrière
STA
00,x
; 1 paramètre (valeur d’adresse indirecte),
; 1 tabulateur après commande
JSR
DELAY
; 1 paramètre ; symbole d'une adresse
; de commande
LDAA
#‘a‘
; 1 paramètre ; 1 caractère ASCII (pour a)
DC.B
$10h,$20,$30
; 3 paramètres, valeurs numériques
; séparées par virgule
DC.B
« Hello ! »
; 1 paramètre, chaîne de caractères
Commentaire
Remarques relatives au déroulement du
programme
Commence par point
virgule, se termine à la
fin de la ligne
Exemple
; LDAA #10 Chaque texte après un point virgule est considéré comme commentaire !
;ce commentaire commence au début de la ligne
LDAB $1005
; Ce commentaire commence après la
; saisie complète des commandes et
; se termine toujours à la fin de la ligne
REMARQUE : les majuscules et les minuscules (également mélangées) sont fondamentalement autorisées.
Formats des nombres
Décimal
Hexadécimal
Binaire
72
sans complément
précédé du symbole du dollar ($)
précédé du symbole du pour cent (%)
12, -1000
$11, $F0AA
%11100111
Annexe CMC1M
Introduction à la programmation du microcontrôleur
CMC 1M
Directives (instructions assembleur)
DETERMINER PROCESSEUR
•
CPU
Instruction relative à l’utilisation de la liste de commandes spécifique au processeur.
<vierge>
CPU
•
<Processeur>
Processeur :
6811
AJOUTER FICHIERS
•
INCLUDE
Insère un fichier dans le texte à cet endroit lors de l’assemblage.
<vierge>
INCLUDE
<nom de fichier>
REMARQUE : si aucune extension de fichier n’est spécifiée, l’extension « .inc » est supposée.
REMARQUE : il est nécessaire de créer un fichier Include avec les assignations d'adresse
des registres de fonctions spéciales et de l'insérer à cette instruction.
FIN DU PROGRAMME
• END
Indique la fin du programme d’assembleur.
<vierge>
END
ATTENTION : les textes sources suivants ne sont pas traduits !
Exemple
cpu
6811
include bitfuncs
.
.
.
end
ldab
#zk2
Annexe CMC1M
;Processeur 68HC11
;Insérer fichier « bitfuncs.inc »
;Fin du programme
;non traduit !
73
Introduction à la programmation du microcontrôleur
CMC 1M
ASSIGNATIONS DE VALEURS
Au cours de l’assemblage, tous les symboles apparaissant dans le programme sont remplacés par les valeurs qui leur sont assignées.
•
EQU
Instruction assignant la <valeur> mentionnée au <symbole> mentionné.
La valeur assignée ne peut pas être modifiée ultérieurement.
<symbole>
•
EQU
<valeur>
SET
Instruction assignant la <valeur> mentionnée au <symbole> mentionné.
La valeur assignée ne peut pas être modifiée ultérieurement.
<symbole>
SET
<valeur>
Exemple
zk1
zk2
equ
set
ldaa
ldab
set
ldx
zk2
$Aa
$20
zk1
#zk2
$40
#zk2
;Symbole « zk1 » = $AA
;Symbole « zk2 » = $20
;Contenu accu A : = $Aa
;Contenu accu B : = $20
;Symbole „zk2“ = $40
;Contenu registre X : = $0040
TRAITEMENT DES VALEURS 16 BITS
Instruction pour l'utilisation de la partie low (high) de la valeur 16 bits indiquée entre parenthèses.
• LO (partie low)
• HI (partie high)
<symbole>
Commande
# LO/HI (valeur)
Exemple
Constemps
equ
-5000
;assigne une valeur 16 bits au symbole
;« Constemps »
ldaa
# hi(constemps)
ldab
lo(constemps)
;charge accu A
;avec la partie high de la
;valeur 16 bits « -5000 »
;charge accu B
;avec la partie low de la
;valeur 16 bits « -5000 »
ATTENTION : pour permettre l'utilisation de cette fonction d’assembleur, le fichier
« bitfuncs.inc » doit être intégré comme fichier Include.
74
Annexe CMC1M
Introduction à la programmation du microcontrôleur
CMC 1M
ASSIGNATION DU COMPTEUR D'ADRESSES
•
ORG
Instruction permettant de définir le compteur d'adresses à l'adresse de mémoire qui
suit.
<vierge>
ORG
<adresse>
Les valeurs d'adresse suivantes sont autorisées :
$0000)
$0000 - $FFFF
(par défaut :
Exemple
var
org
ldab
$f800
#$10
;Compteur d’adresses à $F800
;Contenu adresse de code
;$F800 = commande « ldab #$10 »
org
dc.b
$10
01
;Compteur d’adresses à $10
;Symbole « var » = adresse $10 de la
;zone de mémoire
;Contenu adresse $10 = 01
DEFINITION DE DONNEES
À l’assemblage, tous les symboles apparaissant dans le programme sont remplacés par
les adresses de mémoire qui leur sont assignées.
Réservation de mémoire pour variables
• DS.B
réserve mémoire octet par octet (1 octet)
• DS.W
réserve mémoire mot par mot (2 octets)
<symbole>
DS.B(W)
n
Instruction relative à la réservation sur l’emplacement mémoire actuellement adressable n
OCTET (n MOT).
Assigne en même temps l’adresse de mémoire actuelle au <symbole> mentionné.
ATTENTION : lors de la réservation d’emplacement mémoire pour variables, éviter les zones
(adresses) avec des fonctions spéciales (code, EEPROM, registres de fonctions spéciales) !
Exemple
var
org
ds.b
$10
2
sts
ds.w
3
Annexe CMC1M
;Compteur d’adresses à $10
;Symbole « var » = adresse $10
;Adresse $10 et $11= réservé (1 octet chacun)
;Symbole « sts » = adresse $12
;Adresse $12 = réservé
;Adresse $14 = réservé (tous les 2 octets = 1 mot)
;Adresse $16 = réservé
75
Introduction à la programmation du microcontrôleur
CMC 1M
Ecriture de mémoire avec constantes
•
DC.B
écrit de la mémoire octet par octet (1 octet)
•
DC.W
écrit de la mémoire mot par mot (2 octets)
<symbole>
DC.B(W)
<valeur>
Instruction relative à la réservation sur l’emplacement de mémoire de programme actuellement adressé 1 OCTET (1 MOT) et à l’écriture simultanée avec la <valeur> mentionnée.
Assigne en outre l’adresse de mémoire actuelle au <symbole> mentionné.
<symbole>
DC.B(W)
<valeur 1, valeur 2, ...valeur n>
Instruction relative à la réservation à partir de l’emplacement de mémoire de programme
actuellement adressé n OCTETS (n MOTS) et à l’écriture successive avec la <valeur
1…n> mentionnée.
Assigne en outre l’adresse de mémoire actuelle au <symbole> mentionné.
<symbole>
DC.B
‘caractère‘
Instruction relative à la réservation sur l’emplacement de mémoire de programme actuellement adressé 1 OCTET et à l’écriture simultanée avec la valeur ASCII du <caractère>
mentionné.
Assigne en outre l’adresse de mémoire actuelle au <symbole> mentionné.
<symbole>
DC.B
‘caractère 1‘ , ‘caractère 2‘, ... ‘caractère n‘
Instruction relative à la réservation à partir de l’emplacement de mémoire de programme
actuellement adressé n OCTETS et à l’écriture successive avec les valeurs ASCII des
<caractères 1…n> mentionnés.
Assigne en outre l’adresse de mémoire actuelle au <symbole> mentionné.
<symbole>
DC.B
« chaîne de caractère »
Instruction relative à la réservation par caractère à partir de l’emplacement de mémoire de
programme actuellement adressé 1 OCTET et à l’écriture successive avec les valeurs
ASCII des caractères individuels de la de la <chaîne de caractères> mentionnée.
Assigne en outre l’adresse de mémoire actuelle au <symbole> mentionné.
76
Annexe CMC1M
Introduction à la programmation du microcontrôleur
CMC 1M
Exemple
const
org
dc.b
$50
$c9
corr
dc.b
10,11
str
org
dc.b
$100
‘o‘,‘l‘,‘a‘
;Compteur d’adresses à $100
;Symbole « str » = adresse $100 de la mémoire
;Contenu adresse $100 = $6F = code ASCII o
;Contenu adresse $101 = $6C = code ASCII l
;Contenu adresse $103 = $6C = code ASCII a
text
org
dc.b
$200
« Hallo ! »
;Compteur d’adresses à $200
;Symbole « text » = adresse $200 de la mémoire
;Contenu adresse $200 = $48 = code ASCII H
;Contenu adresse $201 = $61 = code ASCII a
;Contenu adresse $202 = $6C = code ASCII l
;Contenu adresse $203 = $6C = code ASCII l
;Contenu adresse $204 = $6F = code ASCII o
;Contenu adresse $205 = $20 = code ASCII espace
;Contenu adresse $106 = $21 = code ASCII !
Annexe CMC1M
;Compteur d’adresses à $50
;Symbol « const » = adresse $50 de la mémoire
;Contenu adresse $50 = $C9
;Symbole « corr » = adresse $51 de la mémoire
;Contenu adresse $51 = 10 (décimal)
;Contenu adresse $52 = 11 (décimal)
77
Introduction à la programmation du microcontrôleur
CMC 1M
Listings du manuel
cmc1m11.asm
;
;
;
;
;
;
;
;
;
;
;
**********************************************************
* Projet pour PSD2-Flash/MC68HC11 :
*
* Clignotement LED sur ligne de LED
*
* Fichier de projet : CMC1M-1
*
* Fichier source :
cmc1m11.asm
*
* Profil :
profil intégré PSD2-68HC11-FLASH-AS*
* Outils :
as, p2hex, debug11f
*
* Date :
02.08.2005
*
* Ressources :
LED à P1 de l'unité PSD2-Flash
*
* Auteur :
BB
*
**********************************************************
cpu
6811
START
equ
$F800
; Adresse démarrage de programme
PORT1
P1CTL
equ
equ
$1807
$1805
; Adresse sortie port 1
; Adresse registre de commandes
; port 1
org
START
LED_flash:
ldx
#P1CTL
bset $00,x #%11111111
ldy
#PORT1
; Démarrage à partir de F800H
;
;
;
;
Charger
Définir
Charger
données
x avec P1CTL
P17-P10 sur sortie
y avec adresse de
PORTA
bset
$00,y #%11111111
; Eteindre toutes les LED
loop:
bset
jsr
bclr
jsr
bra
$00,y #%10000000
DELAY
$00,y #%10000000
DELAY
loop
;
;
;
;
;
; Temporisation
DELAY:
ldx
#$c000
wloop:
dex
nop
bne
wloop
rts
Eteindre LED1
Attendre
Eteindre LED1
Attendre
Boucle sans fin
; Charger x avec C000H
; Décrémenter x
; Saut à wloop, si nombre
; différent de 0
; Commande de retour
; -------------------------------------------------------end
78
Annexe CMC1M
Introduction à la programmation du microcontrôleur
CMC 1M
cmc1m12.asm
;
;
;
;
;
;
;
;
;
;
;
***********************************************************
* Projet pour PSD2/MC68HC11 :
*
*
Rampe d’éclairage à diodes du 27.09.2005
*
* Fichier de projet : CMC1M-1
*
* Fichiers source :
cmc1m12.asm
*
* Outils MC :
as, p2hex, debug11f
*
* Profil :
profil intégré PSD2-68HC11-FLASH-AS *
* Ressources MC :
unité à LED complète à P1
*
*
commutation à PA.0
*
* Auteur :
BB,HAG
*
***********************************************************
;
;
;
;
;
;
;
;
;
;
;
;
;
;
***********************************************************
Description fonctionnelle :
Aux ports complets 1 (P1.0 - P1.7) du MC sont connectées
toutes les diodes de l’unité LED. Un commutateur de l’unité
de commutation est relié à la broche de port PA.0.
Le niveau logique réglé par régulateur à coulisse permet de
définir le sens de déroulement des diodes.
L’interrogation du commutateur est réalisée via un masque de
bits dans l'accu (01), l’instruction de contrôle de bit BEQ
'BITA ,adresse de port' ainsi que la commande qui suit
,cible du saut‘.
Le modèle binaire pour la commande du port est déplacé avec
les instructions de rotation 'ROLA' ou 'RORA'.
-------------------------------------------------------
;
cpu
Conventions requises pour l’assembleur
6811
; Définir CPU
START
equ
$F800
; Adresse démarrage de programme
PORTA
equ
$1000
; Adresse données port A
PORT1
P1CTL
equ
equ
$1805
$1807
; Adresse sortie port 1
; Adresse registre de commandes
; port 1
org
START
; Démarrage à partir de F800H
;
Initialisation
; ------------------------------------------------------LED_LL:
ldx
bset
ldaa
clc
#P1CTL
$00,x #%11111111
#%11111111
;
;
;
;
;
Charger x avec P1CTL
Définir P17-P10 sur sortie
Modèle de bit de démarrage
toutes LED éteintes
Réinitialisation CF
;
Interroger l’état de commutateur à PA0
; ------------------------------------------------------switch:
psha
; Sauvegarder accu
Annexe CMC1M
79
Introduction à la programmation du microcontrôleur
CMC 1M
ldaa
#01
; Préparer masque pour contrôle
; de bit
bita
PORTA
; PA.0=1 ? (->oui, alors Z=0)
pula
; Prendre accu
beq
loop1
; sinon PA.0=0 (-> Z=1),
; alors vers loop1
; ------------------------------------------------------rora
; Rotation de A à droite
bra
out
; Continuer vers affichage
loop1:
rola
; Rotation de A à gauche
;
Affichage sur LED (Port1)
; ------------------------------------------------------out:
staa PORT1
; Accu vers Port1
jsr
wait
; Attendre SP
jmp
switch
; Vers interrogation de commutateur
;
Sous-programme DELAY
; ------------------------------------------------------wait:
pshx
; Sauvegarder IX
ldx
#$7fec
; Charger IX avec 7fecH
wloop:
dex
; Décrémenter IX
nop
; Temps s’écoule
bne
wloop
; Saut à wloop, si nombre différent
de 0
pulx
; Reprendre IX
rts
; Retour au programme principal
; -------------------------------------------------------end
80
Annexe CMC1M
Introduction à la programmation du microcontrôleur
CMC 1M
cmc1m21.asm
;
;
;
;
;
;
;
;
;
***********************************************************
* Projet : Programme de synchronisation 02.08.2005
*
* Fichier de projet : CMC1M-2 expérience CMC 1M2
*
* Fichiers source :
cmc1m21.asm
*
* Outils MC :
as, p2hex, debug11f
*
* Profil :
profil intégré PSD2-68HC11-FLASH-AS *
* Ressource MC :
broche de port PA.4
*
* Auteur :
BB
*
***********************************************************
;
;
;
;
;
;
;
;
-------------------Description fonctionnelle-------------Une impulsion de T=9µs est sortie sur les broches de port
PA.4-PA.6 de l’unité PSD2. Une LED est reliée au port PA.4.
À l’aide de l’instruction complémentaire, le contenu de
l'accu est inversé puis édité aux broches de porte.
Le niveau 1 éteint la diode LED.
Le niveau 0 allume la diode LED.
---------------------------------------------------------cpu
6811
START
equ
$F800
; Adresse démarrage de programme
PORTA
equ
$1000
; Adresse données port A
;----------------------------------------------------------org
START
; Démarrage à partir de F800H
;
Programme principal
;----------------------------------------------------------clra
out:
; Supprimer contenu d’accu
staa
porta
coma
bra
out
;
;
;
;
Editer données d’accu à port A,
4CM
Invertir accu,2CM
Recommence au début, 3CM
;----------------------------------------------------------end
Annexe CMC1M
81
Introduction à la programmation du microcontrôleur
CMC 1M
cmc1m22.asm
;
;
;
;
;
;
;
;
;
***********************************************************
* Projet : Programme de synchronisation du 02.08.2005
*
* Fichier de projet : CMC1M-2
*
* Fichiers source :
cmc1m22.asm
*
* Outils MC :
as, p2hex, debug11f
*
* Profil :
profil intégré PSD2-68HC11-FLASH-AS *
* Ressource MC :
broche de port PA.4
*
* Auteur :
BB
*
***********************************************************
;
;
;
;
;
;
;
;
;
;
;
;
;
-------------------Description fonctionnelle----------------Une impulsion de T=65, 5ms est sortie sur la broche de port
PA.4 de l’unité PSD2, indépendamment du programme principal.
Le niveau logique à la broche de porte est inversé à la
broche PA.4 à l'événement Compare. Le système utilise le
Compare de l'horloge « on-chip » avec e prédiviseur 1. La
valeur de Compare est 0.
À la broche de port PA.5 de l'unité PSD2, une LED est amorcée
à une cadence T=env.520ms (programme principal MAIN).
Le niveau 1 éteint la diode LED.
Le niveau 0 allume la diode LED.
----------------------------------------------------------
;
Assignation CPU
; ---------------------------------------------------------cpu
6811
;
Assignation des valeurs
; ---------------------------------------------------------START
equ
$F800
; Adresse démarrage de programme
TMSK2
equ
$1024
;
;
;
;
TMSK2VAL equ %00000000
Adresse interruption d'horloge
Registre de masque
VALEUR prédiviseur pour horloge
xxxxxxPR1PR0 =0-> prédiviseur =1
TCTL1
TOC4
equ
equ
$1020
$101C
; Registre de contrôle d'horloge
; Sortie REGISTRE COMPARE 4 (PA.4)
PORTA
equ
$1000
; Adresse données port A
org
START
; Adresse de début du programme
;
Initialisation Timer-Compare
; ---------------------------------------------------------INIT:
ldx
82
#TMSK2
; Prendre adresse de TMSK2
Annexe CMC1M
Introduction à la programmation du microcontrôleur
CMC 1M
bset
0,x
#TMSK2VAL
; init TMSK2- prédiviseur =1
; xxxxxxPR1PR0
ldx
bset
#TOC4
0,x
#0
ldx
bset
#TCTL1
; Prendre adresse de TCTL1
0,x
#%00000100 ; init TCTL1- OM4=0,OL4=1
; ->inversion de niveau
; pour Compare
; Prendre adresse de TOC4
; Initialiser valeur Compare =0
;
MAIN
; ---------------------------------------------------------MAIN:
out:
clra
staa
jsr
coma
jmp
porta
wait
out
;
;
;
;
;
;
Supprimer contenu d’accu
Editer données d'accu vers
Port A
Attendre
Invertir accu
Recommence au début
;
DELAY
;----------------------------------------------------------wait:
ldx
#$0000
; Charger x avec C000H
wloop
;
;
;
;
;
wloop:
dex
nop
bne
rts
Décrémenter x, 3CM
2CM
Saut à wloop, si nombre
différent de 0,3CM
Commande de retour
; ---------------------------------------------------------end
Annexe CMC1M
83
Introduction à la programmation du microcontrôleur
CMC 1M
cmc1m23.asm
;
;
;
;
;
;
;
;
;
***********************************************************
* Projet : Adressage de mémoire du 02.08.2005
*
* Fichier de projet : CMC1M-2
*
* Fichiers source :
cmc1m23.asm
*
* Outils MC :
as, p2hex, debug11f
*
* Profil :
profil intégré PSD2-68HC11-FLASH-AS *
* Ressource MC :
sans
*
* Auteur :
BB
*
***********************************************************
;
;
;
;
;
;
;
;
;
-------------------Description fonctionnelle----------------Des exemples de programme pour apprendre à connaître les
registres de la CPU et les types d'adressage sont effectués.
Les types d’adressage suivants font partie du programme :
- Assignation des valeurs (wz)
- Adressage réduit (va)
- Adressage étendu (ea)
- Adressage indexé (ia)
----------------------------------------------------------
;
;
;
;
;
;
;
;
**********************************************************
*
ATTENTION
*
*
*
*
LES RÉSULTATS DU QUESTIONNAIRE CMC1M-2/EXERCICE 2
*
* NE SONT PAS ÉDITÉS DANS LE COMMENTAIRE ET SONT
*
*
SYMBOLISÉS PAR UN POINT D'INTERROGATION
*
*
*
**********************************************************
; -----Conventions requises pour l’assembleur--------------; **********************************************************
CPU
org
6811
$F800
; Sélection CPU pour assembleur
; Programme principal commence ici
;
Programme principal
; **********************************************************
START:
;
Assignation des valeurs
; ---------------------------------------------------------wz1:
wz2:
wz3:
wz4:
84
ldaa
adda
; Charge accu A avec la valeur $01
; Additionne au contenu d'accu A
; la valeur $01 (A:=$02)
bita #%00000001 ; Contrôle bit0,
; Indicateur Z est réglé sur =1
; **********************************
; * NOTER LE CHANGEMENT D'ÉTAT
*
; *
DES INDICATEURS ET DU
*
; *REGISTRE DU CODE DE CONDITION
*
; *
CCR
*
; **********************************
ldab
#$01
#$01
#$AC
; Charge accu B avec la valeur $AC
Annexe CMC1M
Introduction à la programmation du microcontrôleur
CMC 1M
wz5:
cpd
#$02AC
;
;
;
;
;
wz6:
subd
#684
;
;
;
;
;
wz7:
; Compare contenu de l'accu double
; avec $02AC
; Indicateur Z réglé sur =1
; Indicateur N réglé sur =0
; Contenu A+B reste constant
**********************************
* NOTER LE CHANGEMENT D'ÉTAT
*
*
DES INDICATEURS ET DU
*
* ET DU CONTENU DES REGISTRES A+B*
**********************************
ldx
; Soustrait du contenu de l'accu
; double 684 (décimal)
; Indicateur Z reste =1
; Contenu A+B devient =0
**********************************
* NOTER LE CHANGEMENT D'ÉTAT
*
*
DES INDICATEURS ET DU
*
* ET DU CONTENU DES REGISTRES A+B*
**********************************
#$ABCD
; Charge registre X avec valeur $ABCD
;
Adressage réduit
; ---------------------------------------------------------va1:
stx
<$05
ea0:
stx
$0105
;
;
;
;
;
;
;
va2:
bclr
;
;
;
;
Enregistre le contenu du registre X
à l'adresse $0005
$0005:=$AB
$0006:=$CD
; Enregistre le contenu du registre X
; à l'adresse $0105
; $0105:=$AB
; $0106:=$CD
**********************************
* ATTENTION CETTE COMMANDE
*
* UTILISE L'ADRESSAGE ÉTENDU,
*
* COMPAREZ LA LONGUEUR DU CODE
*
*
DE COMMANDE AVEC LE CODE
*
*
PRÉCÉDENT
*
**********************************
<$05
#$ff
; Supprime tous les bits de
; l'adresse $0005
; $0005:=00
;
Adressage étendu
; ---------------------------------------------------------ea1:
ldaa
$0006
; Charge accu A avec contenu
; d'adresse $0006 (A:=$CD)
ea2:
clr
$1806
; Supprime contenu d'adresse $1806
; $1806:=00 (adresse P0DDR)
ea3:
com
$1806
; Invertit contenu d'adresse $1806
; $1806:=$FF (P0DDR=AAAAAAAA)
Annexe CMC1M
85
Introduction à la programmation du microcontrôleur
CMC 1M
ea4:
staa
$1804
; Enregistre contenu d'accu A à
; adresse $1804 (P0out)
; $1804:=$CD (P0out=11001101)
ea5:
dec
$1804
; Décrémente (-1) le contenu
; de P0out
; $1804:=$CC (P0out=11001100)
ea6:
rol
$1804
; Tourne le contenu de P0out d'une
; position à gauche
; $1804:= ? (P0out= ?)
;
;
;
;
;
ea7:
ldab
**********************************
*
NOTER LES ADRESSES
*
*
DE MÉMOIRE AINSI QUE LES
*
*REGISTRES DE PORT P0DDR ET P0OUT*
**********************************
$1804
; Charge accu B avec
; contenu de P0out
; A:= ?
;
Adressage indexé
; ---------------------------------------------------------wz8:
ldx
#$0105
; Charge registre d’indexation X
; avec valeur d'adresse $0105
; X:=$0105
ia1:
ldaa
00,x
; Charge accu A avec contenu
; de mémoire ($0105 + 00) = $0105
; A:=$AB
ea8:
inx
ia2:
ldaa
; Augmente contenu de registre X d'1
; X:=$0106
00,x
;
;
;
;
;
;
;
ia3:
; Charge accu A avec contenu de
; mémoire ($0106 + 00) = $0106
; A:= ?
**********************************
*
NOTER LES RÉSULTATS
*
* DIFFÉRENTS DE L'EXÉCUTION DE *
*
LA COMMANDE DES COMMANDES
*
* IDENTIQUES DES LIGNES
*
*
ia1: ET ia2:
*
**********************************
#%01001000
START
; Saute si les bits de la mémoire
; ($0106 + 00) = $0106 sont réglés
; conformément au masque pour masque
; "START"
;Bits réglés -> saut à "START"
; ---------------------------------------------------------jmp
brset 00,x
START
; Recommence au début
; **********************************************************
end
86
Annexe CMC1M
Introduction à la programmation du microcontrôleur
CMC 1M
Nous travaillons volontiers en collaboration avec vous :
De par votre expérience et vos observations personnelles, vous êtes en mesure de nous
faire des suggestions, mais également de relever des erreurs. Vos remarques nous seront
très précieuses lors de la mise à jour de nos manuels.
Nous vous remercions de votre intérêt et de votre collaboration.
Manuel concerné :
Notes :
Date :
Copyright © 2006 LUCAS-NÜLLE GmbH. Tous droits réservés.
Le présent manuel est protégé par des droits d’auteur. Tous droits réservés. Le manuel ne doit pas
être reproduit sous quelque forme que ce soit par photocopie, microfilmage ou autres procédés, sans
autorisation écrite de LUCAS-NÜLLE GmbH, ou transmis dans un langage pour machines, en particulier pour installations de traitement de données.
Seule est autorisée la reproduction, sans modification du contenu, des fiches de travaux pratiques à
l’usage des élèves, au gré de l’utilisateur pour une utilisation en classe, au sein de l’établissement qui
a acquis le présent manuel.
Dans le cas où des modifications seraient effectuées par un service non autorisé par LUCAS-NÜLLE
GmbH, toutes les responsabilités pour le produit et les droits à la garantie perdraient leur effet.
LUCAS-NÜLLE Lehr- und Meßgeräte GmbH
Adresse de l'établissement : Siemensstraße 2 • D-50170 Kerpen (Sindorf)
Adresse postale : Postfach 11 40 • D-50140 Kerpen
Tél. : 02273 / 567-0 • Fax : 02273 / 567-30 • Courriel : vertri[email protected]
MCLS - modular® est une marque déposée de la société Lucas-Nülle GmbH
Copyright by Prof. Dr.-Ing. Olaf Hagenbruch
Hochschule Mittweida - University of Applied Sciences
Feedback
Lucas-Nülle Lehr- und Meßgeräte GmbH
Siemensstraße 2 · D-50170 Kerpen-Sindorf
Telefon +49 2273 567-0 · Fax +49 2273 567-30
®
LUCAS-NÜLLE
Ref.-Nr.: P034-EEM-12/03-1-D (Printed in Germany)
www.lucas-nuelle.de
Téléchargement
Explore flashcards