CEG3536 – Architecture d’ordinateurs II

Professeur: Mohamed Ali Ibrahim, ing., Ph.D.

Module 3 – Le langage de programmation assembleur

1
Source: Notes du cours du professeur Gilbert Arbez
Quelles sont les valeurs contenues dans les registres
D, X, Y après l’exécution du code assembleur suivant:
D = $1000
X = $1000
Y = $4157

LDD #$4157
STD $1030
LDX #$1000
LDD #$1030
STD $1000
LDD #$1000
STD $1020
LDY [0,X]
2
Sujets de discussion
◼ Langage de programmation assembleur
 L’assembleur
 Le problème de ré adressage du code
 L’assembleur relogeable et le relieur
◼ La programmation d’assemblage du
MC9S12DG256
 L’assembleur MiniIDE
◼ Le moniteur D-Bug12
◼ Lecture: texte – Chapitre 5 et la documentation
MiniIDE
3
La programmation d’assemblage
◼ Un programme d’assemblage manipule les ressources
dans le modèle de programmation de l’UCT
 Comprend les registres de l’UCT
 Comprend les ressources matérielles (périphériques)
 Comprend aussi la mémoire utilisée pour le stockage des
données
◼ Compilateurs créent souvent du code assembleur qui est
ensuite traduit en machine code
 Un programmeur peut souvent créer des programmes plus
efficaces avec l’assembleur qu’avec un compilateur
◼ Par exemple, le compilateur stocke les valeurs intermédiaires en
mémoire
◼ Un programme assembleur peut garder des résultats dans un
registre

4
L’assembleur
◼ L’assembleur convertit un ou plusieurs fichiers de code
source en code machine
◼ Fichier source
 Contientdes mnémoniques avec opérandes qui correspondent
aux instructions machines
◼ Code Machine
 Le code binaire interprété et exécuté par l’UCT

5
Champs des instructions assembleur
◼ Chaque ligne du code source d’assembleur contient
quatre champs
 Étiquette: donne une référence symbolique d’emplacement de
mémoire et de valeurs constantes
 Code d’opération (opcode): contient soit une mnémonique de
code opérationnel ou une directive d’assembleur
 Opérande: contient une spécification pour les opérandes
d’instructions
 Commentaire: Pour faire des commentaires

Étiquette Op_code Operande Commentaire

EXEMPLE mov src,dest ; Sauvegarder dans dest
6
Champs de code d’opération
◼ Mnémonique
 Représentation d’une opération machine
 Exemple: JMP (saut)
 L’assembleur traduit les mnémoniques (et opérandes) en code
binaire
 Dans l’exemple suivant, BUT représente une adresse en
mémoire
◼ Directive d’assembleur
 Instruction pour l’assembleur
 Exemple: ORG (origination)
 ORG change un compteur d’emplacement interne donné par
l’opérande ($1000 dans l’exemple)
 Lors de la traduction de chaque ligne de code source, le
compteur d’emplacement interne est mise à jour
 Lorsque la ligne avec l’étiquette BUT est atteinte, la valeur de
BUT est assignée selon le compteur d’emplacement interne

7
Champs de code d’opération
Étiquette Op_code Opérande
ORG $1000
op_code opérande
op_code opérande
JMP BUT
op_code opérande
op_code opérande
….
BUT op_code opérande
op_code opérande
8
Champ d’opérande
◼ Pour définir les opérandes d’une instruction. Peut être:
 Nom d’un registre
 Constantes symboliques ou numériques
 Étiquettes (tel que déjà vue).
 Expressions algébriques évaluées par l’assembleur
 Exemples:
◼ MOV A,DATA1 ; Registre A, nom symbolique DATA1
◼ MOV A,DATA1+1 ; expression DATA1+1

9
Le macro-assembleur
◼ Un assembleur qui représente plusieurs
instructions souvent utilisées par un nom
symbolique
 Définition du macro: dans le code source, deux
directives utilisées à indiquer le début et la fin du
macro, par exemple DEF_MACRO et END_MACRO
 Invocation du macro: Dans le code source, l’étiquette
du macro est utilisé dans le champ du code
d’opération
 Expansion du macro: L’assembleur remplace le nom
du macro par le code complet spécifié dans la
définition du macro.
10
Définition du macro
Add_B_Et_C DEF_MACRO
MOV A,C
ADD A,B
MOV C,A
END_MACRO

11
Invocation du macro
op_code opérande
op_code opérande
Add_B_Et_C
op_code opérande
op_code opérande

12
L’expansion du macro
op_code opérande
op_code opérande
Add_B_Et_C
MOV A,C ; L’assembler insère
ADD A,B ; ces trois
MOV C,A ; lignes
op_code opérande
op_code opérande

13
Le macro versus le sous-programme
◼ Semblable puisque les deux réutilisent du code
 Mais avec le sous-programme, le code est présent
une fois seulement
 Les macros sont agrandis “enligne” à chaque
invocation de macro – ce qui allonge le programme.
◼ Le sous-programme demande un appel au saut
au sous-programme (le macro non)
 Donc les sous-programmes sont légèrement plus lent
◼ Les macros et sous-programmes tous deux
rendent la lecture d’un programme plus facile
 Changements se font à un endroit
 Cache les détails du code de segment - besoin de
savoir ce que fait le macro/sous-programme, pas
comment il le fait
14
Assembleurs à deux passages
◼ La majorité des assembleurs offre “des
références vers l’avant”
 Possible d’utiliser des symboles avant qu’ils soient
définis, rappeler vous de l’utilisation de BUT
◼ L’assembleur fait deux passages durant la
traduction du code source
 Premier passage permet la création du tableau de
symboles
 Ce tableau offre des valeurs pour les symboles
 Le deuxième passage génère le code machine avec
les valeurs retrouvées dans le tableau de symboles

15
Assembleur croisé et local
◼ L’assembleur croisé
 Assembleur roulant sur un ordinateur qui produit du
code pour un processeur différent
 Par exemple, l’assembleur sur un PC avec un
processeur Intel permet d’assembler du code pour le
MC68HCS12
◼ Assembleur local
 L’assembleur créant du code pour le processeur local
 Souvent partie de compilateurs

16
Le problème d’emplacement du code
◼ Rappelez-vous du topogramme pour le MC9S12DG256
 EEPROM
 RAM
◼ Les diverses parties se retrouvent dans différentes
parties de la mémoire
 Données demandant des modifications doivent se retrouver en
RAM
 Code (programme) peut être stocké en ROM ou EEPROM
 Les données constantes (qui ne sont pas modifiées) sont aussi
stockées en ROM ou EEPROM, normalement après le code
◼ Comment placer le code et les données à la création
d’un programme assembleur

17
Assembleurs absolus
◼ Rappelez vous de l’acétate 7
 Compiler par l’assembleur absolu
 Doit savoir où le programme est stocké en mémoire
◼ Doit avoir tout le code source pour la création du
programme exécutable
◼ Rappelez vous de la directive ORG
◼ Utilisons l’assembleur absolu dans ce cour (MiniIDE)
◼ Assembleur permet la définition des « sections » de
programme pour faciliter la conception modulaire
 Donc différents morceaux des sections (e.g. données, code,
etc.) peuvent se retrouver dans des différents modules (fichiers
source assembleurs)

18
Assembleurs relogeables
◼ Crée des fichiers objets dont les adresses ne
sont pas résolues
◼ Relieur: Combine les fichiers objets pour créer
un seul fichier exécutable (adresses résolues au
temps de liaison)
◼ Adresses peuvent aussi être résolues au
moment du chargement du programme ou au
moment de l’exécution (traduit adresse logique à
l’adresse physiques)
 Les systèmes d’exploitations utilisent ces approches
pour charger le programme n’importe où en mémoire
19
Assembleur
relogeable et relieur

20
Sujets de discussion
◼ Langage de programmation assembleur
 L’assembleur
 Le problème de relocalisation du code
 L’assembleur relogeable et le relieur
◼ La programmation d’assemblage du
MC68HC12
 L’assembleur MiniIDE
◼ Le débogage du programme
◼ Le moniteur D-Bug12
21
Assembleur HCS12 MiniIDE
◼ Assembleur disponible dans le domaine
publique
 Disponible au http://www.mgtek.com/miniide/
 Application Windows

◼ Génère deux fichiers

 Fichiers S19 – Machine code en format ASCII
qui peut être chargé dans la carte Dragon-12
 Fichier LST – donne le code source avec le
code machine
22
Exemple – Bonjour1.asm
◼ Considérez le code source dans le fichier Bonjour1.asm
 Reconnaissez vous les champs: étiquette, opcode, opérande et
commentaires
 Notez les lignes qui ne contiennent que des commentaires
◼ Considérez le fichier Bonjour1.lst avec les champs
suivants:
 Numéro de ligne source
 Adresse de la mémoire
 Instructions machine ou octets de données
 Ligne source
◼ Considérez le fichier Bonjour1.S19
 Voyez vous le code machine
 Ce fichier peut être chargé dans la carte Dragon-12
◼ La logique du programme assembleur peut aussi être
représenté dans un langage de plus haut niveau tel que
le C – voyez Bonjour1.c
23
Bonjour1.c
/* Programme Bonjour tout le monde en C */
#define BONJOUR “Bonjour tout le monde!”
void main()
{
putstr(BONJOUR);
}
/*------------------------------
Fonction: putstr
Paramètres: char *chn – chaîne à afficher
Description: Afficher chaîne en invoquant putchar()
-------------------------------*/
void putstr(char *chn)
{
while(* chn!= ‘\0’)
putchar(*chn++);
}
24
Champs d’étiquette du MiniIDE
◼ Une étiquette est un symbole composé de caractères
alphanumérique, de soulignement (_), points (.), symbole du dollar
($) ou points d’interrogations (?).
◼ Le premier caractère ne doit pas être un caractère numérique
◼ La longueur de l’étiquette est limitée à 128 caractères, des
étiquettes plus longues sont tronquées.
◼ Un deux-points (:) optionnel peut être ajouté à la fin d’une étiquette.
◼ Le code assembleur est insensible à la casse des caractères
(majuscules-minuscules)
◼ Les symboles sont représentés par des valeurs de 32-bits avec
signes
◼ Les lignes sans étiquettes doivent toujours commencer avec un
caractère d’espace blanc (espace ou tab)
◼ Ne peut pas utiliser des mots réservés comme étiquettes.

25
Exemples d’étiquettes (symboles)
TEST: ; étiquette légale
TEST$: ; étiquette légale
TEST$DATA: ; Légale. Quelques fois le $ est utilisé
; comme séparateur pour rendre
; l’étiquette plus lisible
TestData: ; Légale, plus lisible
Test_Data: ; Légale, encore plus lisible
Label ; Légale. Une étiquette n’a pas besoin
; de (:)

26
Opcode et opérandes du MiniIDE
◼ Champ OpCode
 Mnémonique M68HC12 ou directive d’assembleur ou nom de
macro
◼ Opérandes
 Symbole, constante, ou expression à convertir en opérande
d’instruction
 Symboles: Représente valeurs de nombre entier long de 8 ou 16
bits (voir printf dans exemple “Bonjour tout le monde”)
 Constantes: Valeurs numériques dans un des formats suivante:
décimale, hexadécimal, octal, binaire et ASCII
◼ Préfix ou suffixe indique le format (voir prochaine acétate)
 Expressions
◼ Combinaison des symboles, constantes et opérateurs

27
Indicateurs pour les constantes
Base Préfixe Suffixe
Binaire % B
Décimal D
Octal @ O,Q
Hexadécimal $ H
ASCII ‘
◼ Notez que le format décimal est le format par défaut lorsque le
préfixe n’est pas présent (CASM1 dans le texte utilise le ! Comme
préfixe pour les constantes décimales)

28
Exemples de constantes
; Constantes décimales
0000 8664 1 ldaa #100 ; 100 -> A
0002 8664 2 ldaa #100D ; 100 -> A
0004 CE04D2 3 ldx #1234 ; 1234 -> X

; Constantes Hexadécimales
0000 8664 1 ldaa #$64 ; $64 = 100 -> A
0002 869C 2 ldaa #$9C ; $9c = -100 -> A
0004 CE1234 3 ldx #$1234 ; $1234 -> X

; Constantes binaires
0000 8664 1 ldaa #%01100100 ; 100 -> A
0002 8664 2 ldaa #01100100b ; 100 -> A
0004 8664 3 ldaa #01100100B ; 100 -> A
0006 869C 4 ldaa #%10011100 ; -100 -> A
0008 CE091A 5 ldx #%0001001000110100 ; $1234 -> X
000B 86F0 6 ldaa #%11110000 ; MS nibble mask 29
Opérateurs pour expressions
◼ Arithmétique:
* (multiplication) / (division) + (addition)
– (soustraction) % (modulo)
◼ Opérateurs bits
~ (complément à 1), << (décalage à gauche),
>> (décalage à droite), & (opération ET),
^ (opération OUX), | (opération OU)
◼ Voir la documentation MiniIDE pour une
liste complète des opérateurs logique et
de comparaisons
30
Exemples d’expressions
1 ; Un test de tous opérateurs
0000 2 ONE: EQU 1
0000 3 TWO: EQU 2
0000 4 SMALL: EQU $FF
5 ;
0000 03 6 ADD: DC.B {ONE+TWO} ; Addition
0001 01 7 SUB: DC.B {TWO-ONE} ; Soustraction
0002 02 8 ASL: DC.B {ONE<<1} ; Décalage gauche
0003 7F 9 LSR: DC.B {SMALL>>1} ; Décalage droite
0004 3F 10 DC.B {SMALL>>2} ; Décalage droite
0005 00 11 AND: DC.B {ONE&TWO} ; ET
0006 03 12 OR: DC.B {ONE|TWO} ; OU
0007 03 13 XOR: DC.B {ONE^TWO} ; OUX
0008 04 14 MULT: DC.B {TWO*TWO} ; Multiplication
0009 01 15 DIV: DC.B {TWO/TWO} ; Division

31
Champ commentaire
◼ Commence avec le caractère “;” et fini à la fin de la ligne
◼ Une ligne complète peut être un commentaire
 La ligne débute avec “;” ou “*”
◼ Les lignes blanches peuvent être présentes dans le code
sources

32
Directives d’assembleur
◼ ORG – donne la valeur au compteur d’emplacement
◼ EQU – donne la valeur d’une expression à un symbole
 Peut utiliser SET. avec SET, peut redéfinir la valeur du symbole
◼ Directives de définitions de données
 DC – définir donnée constante (.B, .W, .L)
 DCB – définir bloc de données constantes (.B, .W, .L)
 DS – définir région de stockage (.B, .W, .L) (i.e. variables)
 OFFSET - pour définir décalage de structure de données
◼ Directives de contrôle de macro
 MACRO – débuter macro
 ENDM – finir macro
 EXITM – sortir du macro
◼ Directives pour supporter modules:
 Définition de sections SECTION, SWITCH
 Inclure fichiers (i.e. modules): INCLUDE
◼ Directives conditionnelles d’assembleur (voir MiniIDE)
◼ Directive de contrôle de listage de programme (voir MiniIDE)

33
 Les sections de programme
Topogramme MCU
Module 1 (module1.asm) Module 2 (module2.asm)
0000 Registres E/S SWITCH code
0400 Instructions mod1 4 ;---Instructions assembleurs
code SECTION
Instructions mod2 ORG $0400 SWITCH donneeEE
EEPROM Instructions mod3 1 ;--Instructions assembleurs 5 ;---Données globales constantes
Données glob. mod1
Données glob. mod2 donneeEE SECTION SWITCH donneeRAM
Données glob. mod3 2 ORG ENDCODE ;---Variables globales (modifiables)
;--Données globales constantes 6
0FFF
donneeRAM SECTION
1000 Module 3 (module3.asm)
ORG $2500
;--Variables globales (modifiables) 7 SWITCH code
;---Instructions assembleurs
Pile 3 ;--------Ajouter autres modules
RAM
INCLUDE module2.asm SWITCH donneeEE
INCLUDE module3.asm
8 ;---Données globales constantes
;--définie début de donneeEE
2500 Vars globales mod1 SWITCH donneeRAM
SWITCH code
Vars globales mod2
Vars globales mod3
FINCODE 9 ;---Variables globales (modifiables)

3FFF

Notez: Les adresses absolues sont définies à la deuxième passe

- La valeur de FINCODE change lorsque le code change
34
OFFSET
◼ OFFSET <valeur>
 L’assembleur change à une section « spéciale » et y affecte
valeur à son compteur d’emplacement
 Sort de la section à la première instruction qui génère du code
 Peut ainsi définir des décalages de structures de données
◼ Exemple structure C
OFFSET 0
struct varStr n1 DS.W 1
{ n2 DS.W 1
int n1; n3 DS.L 1
int n2; VAR_STR_LNG EQU *
long n3; …
} var; ldx #var
… ldaa n1,x
va = var.n1; …
var ds.b VAR_STR_LNG
35
Définir l’usage de la pile
◼ Utilisez OFFSET pour définir étiquettes de décalage dans la pile
◼ Exemple:
OFFSET 0
RTN_VAR1 DS.B 1 ; var. d’un octet.
RTN_VAR2 DS.W 1 ; variable de deux octets
RTN_TBL DS.B 10 ; tableau de 10 octets
RTN_PR_B DS.B 1 ; préserve B
RTN_PR_X DS.W 1 ; préserve X
RTN_RA DS.W 1 ; adresse de retour
RTN_ARG1 DS.W 1 ; argument de 2 octets
RTN_ARG2 DS.B 1 ; argument d’un octet

routine pshx ; étiquette de routine avec code

pshb
ldd RTN_ARG1,SP ; charger ARG1
…
stab RTN_VAR1,SP ; affecte valeur à VAR1
36
Le processus du développement de logiciel
◼ Définition de problème: Identifier ce qui devrait
être fait
◼ Conception: développer des modules et des
algorithmes:
◼ Programmation: traduire la conception
(modules/algorithmes) à un programme
◼ Le testing du programme
◼ L’entretien du programme
◼ La documentation

37
Conception de logiciel
◼ Développement des modules
 Les modules partage le problèmes en tâches gérables
 Chaque module contient des sous-tâches pour définir un sous-
programme
 Quels sont les avantages des modules?
◼ Développement des algorithmes
 Un algorithme est développé pour chaque sous-programme
 Options
◼ Organigrammes
◼ Pseudo-code
 Pour la première moitié du cours, utilise le C comme pseudo-
code
◼ Traduit MANUELLEMENT le programme C en Assembleur

38
Exemple simple du développement de
logiciel
◼ Problème:
 Faire le calcule suivant:
◼ z=a+b–c
◼ Algorithme
 EnC:
int z, a=5, b=6, c=8;
z = a + b – c;

39
Exemple simple du développement de logiciel
(suite)
; Définir les adresses de variables
ORG $2500
◼ Le var_a DC.W 5 ; a
programme var_b DC.W 6 ; b
var_c DC.W 8 ; c
◼ Reste à var_z DS.W 1 ; z
; Programme z = a + b - c
 Assembler org $1000
 Tester ldaa var_a ; charge a
adda var_b ; additionner b
suba var_c ; soustraire c
staa var_z ; résultat dans z

40
Sujets de discussion
◼ Langage de programmation assembleur
 L’assembleur
 Le problème de relocalisation du code
 L’assembleur relogeable et le relieur

◼ La programmation d’assemblage du
MC68HC12
 L’assembleur MiniIDE
◼ Le moniteur D-Bug12
41
D-Bug12
◼ Le moniteur D-Bug12 version 4.xxx dans la carte Dragon-
12 (utilise le MC9S12DG256)
 Comprend un programme stocké dans le EEPROM qui permet
le chargement et le contrôle de programmes assembleurs
 Offre des fonctions de débogage
 Programme à commandes

42
Rappelez vous du topogramme du
MC9S12DG256
$0000
$1000
$2000
RAM 0000
$3000
Registres E/S
$4000
$5000 0400
$6000
$7000
$8000
FLASH EEPROM
$9000
D-Bug 12
$A000
$B000
$C000
0FFF
$D000
$E000
$F000
43
Rappelez vous du modèle de
programmation du CPU12

44
Commandes du moniteur D-Bug12
◼ ASM: Assembler/Disassembler - Assembleur
◼ BF: Block fill memory - Remplir bloc de mémoire
◼ BR: Set Breakpoint - Établir point d’arrêt
◼ CALL: Call and execute subroutine – Exécuter sous-programme
◼ G: Go (run) to a user program – Démarrer un programme
◼ GT: Go till an address – Exécuté jusqu’à l’adresse
◼ HELP: Prints command summary – Aide (sommaire des commandes
◼ LOAD: Download program – Télécharger programme
◼ MD: Memory display – Afficher mémoire
◼ MM: Memory modify. – Modifier mémoire
◼ MOVE: Copy block of memory – Copier bloc de mémoire
◼ NOBR: Remove breakpoints – Enlever points d’arrêts
◼ RD: Display register contents – Afficher contenu des registres
◼ RM: Register modify – Modifier registres
◼ T: Trace program. – Tracer programme
◼ UPLOAD: Upload memory to PC – Télécharger programme au PC
◼ USEHDB: Use EVB/Target hardware breakpoints – points d’arrêt matériel.
◼ VERIF: Compare memory to downloaded file. – Comparer mémoire à un
fichier téléchargé
45
Commande ASM
◼ ASM <adresse>
 Assemble et désassemble
 Paramètre “adresse” donne l’adresse de départ
 Taper l’instruction assembleur pour entrer code machine
 Taper <Retour de chariot> pour accepter voir code machine
 Type d’opérande par défaut est décimal
 Utiliser le préfixe $ pour spécifier des valeurs hexadécimales

46
Sous-programmes utilitaires du D-Bug12
◼ Offre une série de sous-programmes disponibles pour
utilisation par programmes d’usager (avec JSR)
 D-Bug12 contient un tableau de vecteurs au sous-programmes
 Utilise le JSR avec adressage indirect indexé (ou adressage
relative au PC)
 Voir l’annexe C du Manuel d’Utilisateur du D-Bug12
◼ Sous-programmes sont des fonctions C et utilise un
mécanisme C pour passer les paramètres
 Premier paramètre est passé dans le registre D
 Les autres paramètres sont poussés sur la pile dans l’ordre de
droit à gauche (notez que le code appelant doit nettoyer la pile
après avoir appelé le sous-programme)
 Le sous-programme retourne sa valeur dans D
◼ Considérer un appel à la fonction (au sous-programme)
suivant:
int function_call(int param1, char param2, int parm3) 47
Exemple d’un utilitaire D-Bug12
1: =0000FE0A VECTOR EQU $FE0A ; Vecteur du sous-prog.
2: 0000 DC 13 ldd param3 ; Chercher param 3 de la mémoire
3: 0002 3B pshd ; Placer sur la pile
4: 0003 D6 12 ldab param2 ; Chercher param 2 de la mém.
5: 0005 B7 14 sex b,d ; Convertir à 16 bits
6: 0007 3B pshd ; Placer sur la pile
7: 0008 DC 10 ldd param1 ; Chercher param 1 de la mémoire
8: 000A 15 FB FDFC jsr [VECTOR,PCR] ; Appel sous-programme
9: 000E 1B 84 leas 4,sp ; Nettoyer la pile
10: ; À ce point le registre D contient la valeur int
11: ; retournée par le sous-programme .
12: ; ---
13: 0010 +0002 param1: DS 2 ; Mémoire pour paramètre 1
14: 0012 +0001 param2: DS 1 ; Mémoire pour paramètre 2
15: 0013 +0002 param3: DS 2 ; Mémoire pour paramètre 3

48
Sous-programmes D-Bug12 pour manipulation de
caractères
Function Vector Description
int getchar(void) $EE84 B contains character fetched from the serial
I/O port. Waits until char is available.
int putchar(char c) $EE86 Sends the single char in B to the serial port
(SCI). Returns the character sent.
int isalpha(int c) $EE96 Returns non-zero value in D, if the char c (in
D) is an alphabetic char, and zero in D
otherwise.
int isxdigit(int c) $EE92 Returns non-zero value in D, if the char c (in
D) is a hexadecimal digit, and zero in D
otherwise.
int toupper(int c) $EE94 Converts char in B to upper case.
void out2hex(unsigned int num) $EE9C Displays the byte in the B register as two
hexadecimal characters.
void out4hex(unsigned int num) $EEA0 Displays the 2 bytes in the D register as four
hexadecimal characters.

49
 Sous-programmes D-Bug12 pour
manipulation de chaînes de caractères
Function Vector Returns
int printf(char *format, arg1,…) $EE88 Implements the C printf function that
prints a formatted string (does not
support floating type). Returns
number of char’s printed in D.
int getCmdLine(char *strpt, int len) $EE8A Always returns D=0. Obtains a line
from the user (with editing), and
stores at address found in D.
char *sscanhex(char *hexStr, $EE8E Converts the ASCII Hexadecimal
unsigned int *binN) string at address “hexStr” to a binary
integer (stored at address “binN”). D
returns NULL if error occurred,
otherwise points to the terminating
character of the hex string.
char *strcpy(char *s1, char *s2) $EE9A Copies the null-terminated string
addressed by s1 to memory address
s2. D returns pointer to S2
int strlen(char *s) $EE98 Returns in D the number of
characters in the string addressed by
s. 50
Sous-programmes D-Bug12 divers
Function Vector Description
void main(void) $EE80 Starts the D-Bug12 monitor. Allows some
initialization before starting the monitor.
setUserVector(int vectN, $EEA4 Sets the interrupt vector address “UsrAdr”
address UsrAdr) for the interrupt associated to vectN.
Returns D=-1 if vector number is invalid,
and 0 otherwise.
int eraseEE(void) $EEAA Bulk erase EEPROM. If not erased, D=0
and Z bit is set, otherwise, D non-zero and
Z=0.
int WriteEEByte(address $EEA6 Program a byte in to on-chip EEPROM.
EEAdr,
byte EEData)

51
Références
◼ Reference Guide for D-Bug12 Version 4.x.x, Gordon Dougham
◼ Fredrick M. Cady, James M. Sibigtroth; “Software and Hardware
Engineering: Assembly and C Programming for the FreeScale
HCS12 Microcontroller”
◼ Les textes ci-dessus sont les sources pour la majorité des
illustrations, tableaux, et exemples dans ce module.

52