Introduction :

DebugHC11 est un logiciel qui permet de créer un programme assembleur 68HC11, de le compiler, de le transférer sur une maquette de test et de tester son fonctionnement. Ce logiciel a été développé pour permettre une initiation au langage assembleur. De ce fait certaines fonctionnalités risquent de gêner ceux qui voudrait l'utiliser comme outils de développement (notamment lors de l'utilisation d'interruption).

  • Présentation de DebugHC11

  • Les boites de saisies de valeur ou d'adresse


Introduction :

DebugHC11 est un logiciel qui permet de créer un programme assembleur 68HC11, de le compiler, de le transférer sur une maquette de test et de tester son fonctionnement. Ce logiciel a été développé pour permettre une initiation au langage assembleur. De ce fait certaines fonctionnalités risquent de gêner ceux qui voudrait l'utiliser comme outils de développement (notamment lors de l'utilisation d'interruption).

  • Présentation de DebugHC11

DebugHC11 se présente sous la forme suivante :

La fenêtte , est la fenêtre d'édition du code assembleur. Une fois votre programme assemblé et transféré dans le 68HC11, vous pouvez suivre l'évolution de votre programme lors d'exécution pas à pas grâce à la rétroannotation (mise en surbrillance de la prochaine instruction à exécuter).

La fenêtre ‚, permet de piloter l'exécution du programme dans le 68HC11.

La fenêtre ƒ, permet de visualiser des plages mémoires internes au 68HC11 sous différents formats (binaire, octal, décimal, hexadécimal)

La fenêtre „, permet de visualiser des plages mémoires internes au 68HC11 au format ASCII

La fenêtre …, permet d'éditer une mémoire 8 ou 16 bits du 68HC11.

  • Les boites de saisies de valeur ou d'adresse


Introduction :

DebugHC11 est un logiciel qui permet de créer un programme assembleur 68HC11, de le compiler, de le transférer sur une maquette de test et de tester son fonctionnement. Ce logiciel a été développé pour permettre une initiation au langage assembleur. De ce fait certaines fonctionnalités risquent de gêner ceux qui voudrait l'utiliser comme outils de développement (notamment lors de l'utilisation d'interruption).

  • Présentation de DebugHC11

  • Les boites de saisies de valeur ou d'adresse

Dans DebugHC11, vous trouverez différentes boites de dialogue permettant de saisir une adresse ou une valeur. La plupart de ces boites de dialogues peuvent afficher la valeur, sous différents format, binaire, octal, hexadécimal et décimal. Pour changer le mode d'affichage, il suffit de cliquer sur la boite de dialogue avec le bouton droit et dans le menu contextuel qui apparaît de choisir le format d'affichage, ou de rentrer 1 de ces 4 caractère : % pour binaire, @ pour l'octal, n pour le décimal et $ pour l'hexadécimal. Lors de l'édition d'une de ces boites, il est théoriquement impossible de rentrer une valeur non autorisée. Ainsi si le mode d'affichage est binaire, vous ne pourrait rentrer que les caractères 0 ou 1. De même lors de l'édition d'une valeur 8 bits affichée en hexadécimal, vous ne pourrez pas rentrer plus de 2 digits.

Un inconvenient de cette technique est qu'il faut d'abord effacer les caractères d'une boite de dialogue avant de pouvoir en ajouter d'autre, et que le remplacement de la partie sélectionnée ne se fait pas.


Installation & desintallation :

  • Installation

  • Desintallation


Installation & desintallation :

  • Installation

Si vous suivez la procédure d'installation par défaut deux répertoires sont crées.

« C:\Program Files\Debug68HC11 » : contenant le programme, des fichiers de configuration, les fichiers de desinstallation et deux répertoires « Outils » et « Help » permettant le bon fonctionnement de DebugHC11

« C:\WINDOWS\Menu Démarrer\Programmes\DebugHC11 » : contenant les raccourcis vers le programme et son fichier d'aide.

Note : pour une installation sous Windows 2000 ou XP, si vous utilisez des comptes, il faut que tous les utilisateurs aient accès en écriture aux fichiers :
« \Program Files\Debug68HC11\Debug68HC11.INI »
« \Program Files\Debug68HC11\Processors.def »
« \Program Files\Debug68HC11\Outils\Ref.id »

Note : L'installation associe les fichiers avec l'extension « .asc » à Debug68HC11 ce qui vous permettra de lancer l'exécution de ce programme lorsque vous double cliquez sur un fichier théoriquement créer par Debug68HC11.

  • Desintallation


Installation & desintallation :

  • Installation

  • Desintallation

Pour desinstaller le logiciel, il suffit d'aller dans « Démarrer », « Paramètres », « Panneau de configuration », « Ajout/Suppression de programmes », sélectionner « Debug 68HC11 version 1.0 », puis cliquer sur le bouton « Ajouter/Supprimer »puis valider par le bouton « Oui ».

Si vous avez suivi la phase d'installation par défaut vous pouvez vérifier que les deux répertoires : « c:\Program Files\Debug68HC11 » et « C:\WINDOWS\Menu Démarrer\Programmes\Debug68HC11 » ont été supprimés.

Vous supprimer association de fichier avec Debug68HC11, manuellement. Dans « Demarrer », « Paramêtres », « Options des dosiiers », rechercher l'extension « .asc » et supprimer son association.

Pour affiner la desinstallation, vous pouvez dans la base de registre rechercher les clefs « Debug68HC11 » et théoriquement vous devez pouvoir les supprimer ( A vos risques et périls ).


Configuration :

Pour pouvoir travailler avec DebugHC11 et une maquette de test, il faut :

  • Configurer la liaison série.

  • Configurer la version du processeur présent sur la maquette.


Configuration :

Pour pouvoir travailler avec DebugHC11 et une maquette de test, il faut :

  • Configurer la liaison série.

Cliquer dans le menu « Configuration Liaison », une fenêtre s'ouvre :

Compléter les différent champs, puis cliquer sur « OK ».

Les champs :

Port du PC : C'est le port série du PC que vous utilisé afin de relier votre carte maquette 68HC11 avec le PC.

Fréquence du quartz : C'est la fréquence du quartz qui permet le fonctionnement du 68HC11. Cette fréquence permet de déterminer la vitesse de transfert du Talker lorsque le 68HC11 est en mode Bootstrap.

Talker utilisé : C'est le programme de communication entre le 68HC11 et DebugHC11. Vous pouvez créer votre propre Talker (Voir la partie « Créer un Talker »).

Attente de l'echo : Cette option permet d'envoyer le Talker octet par octet (attente de l'echo) ou en rafale. Il est fortement recommandé de ne pas cocher cette case car la version E1 du 68HC11 s'arrete de charger le Talker si un temps trop important sépare deux octets.

Fichier rapport : Cette option permet d'afficher une nouvelle fenêtre à la fin de la transmission du Talker présentant les différentes valeurs envoyées au 68HC11 et reçues du 68HC11. Ceci permet de déceler les problèmes de communication lors d'une phase de conception d'une nouvelle carte, ou de diagnostiquer un problème de fonctionnement.

Vitesse de communication du Talker : C'est la vitesse de communication entre le 68HC11, une fois le Talker chargé en mémoire, et DebugHC11. Ce paramètre dépand du quartz de la maquette et du Talker utilisé.

Programme permettant d'envoyer le Talker : Le Talker est envoyé dans le 68HC11 à l'aide d'un programme qui est un module de DebugHC11. Le module par défaut doit être le programme « SendTK.exe » dans le répertoire « Outils ». Il est possible d'avoir à changer ce programme si vous écrivez un Talker très spécial.

Il est conseillé dans la plupart des cas d'utiliser la configuration par défaut qui est donnée au dessus. Remplacer juste les chemins « E:\projet\Debug68HC11\Delphi4 » par le répertoire d'installation de DebugHC11.

  • Configurer la version du processeur présent sur la maquette.


Configuration :

Pour pouvoir travailler avec DebugHC11 et une maquette de test, il faut :

  • Configurer la liaison série.

  • Configurer la version du processeur présent sur la maquette.

Chaque 68HC11 possède un identifiant de version. Cependant deux versions peuvent avoir le même identifiant. En interne le MC68HC811E2FN à l'identifiant « E2E2 », alors que les version MC68HC11A8 et MC68HC11E1 ont l'identifiant « E9E9 ». DebugHC11 lors du transfert du Talker vérifie cet identifiant et s'il a changé depuis la dernière utilisation, DebugHC11 essaie de vous proposer une configuration (voir fenêtre ci-dessous).

Si les plages adresses présentent dans cette fenêtre correspondent au processeur que vous avez sur votre maquette valider par « OK » sinon éditer ou créer un nouveau modèle de processeur en sélectionnant un des deux boutons. Une nouvelle fenêtre apparaît (voir ci-dessous), compléter les différents champs, puis valider.

Il est conseillé de n'effectuer une configuration du processeur, qu'après avoir tenter de transférer un programme, de manière à connaître l'identifiant du processeur utilisé.


Edition d'un programme :

DebugHC11 permet l'édition de programme en assembleur 68HC11.

  • Interface MDI.

  • Jeux d'instructions 68HC11.

  • Directives de compilation.


Edition d'un programme :

DebugHC11 permet l'édition de programme en assembleur 68HC11.

  • Interface MDI.

DebugHC11 est constitué d'une interface MDI (Multiple Document Interface), ce qui lui permet d'éditer et de visualiser plusieurs documents simultanément. Grâce à cette interface, vous avez la possibilité de faire des « Copier Coller » entre différents programmes assembleurs. Bien sur, vous retrouvez dans le menu « Fichier » l'ensemble des commande permettant d'ouvrir, enregistrer, créer de nouveaux fichiers.

DebugHC11 permet d'éditer seulement des fichier dont l'extension est « .asc ». Tous les autres types de fichiers sont visibles en texte ASCII, mais ne peuvent pas être modifiés.

Ce logiciel gère normalement les noms longs de fichier.

  • Jeux d'instructions 68HC11.

  • Directives de compilation.


Edition d'un programme :

DebugHC11 permet l'édition de programme en assembleur 68HC11.

  • Interface MDI.

  • Jeux d'instructions 68HC11.

ABA

ABX

ABY

ADCA

ADCB

ADDA

ADDB

ADDD

ANDA

ANDB

ASL

ASLA

ASLB

ASLD

ASR

ASRA

ASRB

BCC

BCLR

BCS

BEQ

BGE

BGT

BHI

BHS

BITA

BITB

BLE

BLO

BLS

BLT

BMI

BNE

BPL

BRA

BRCLR

BRN

BRSET

BSET

BSR

BVC

BVS

CBA

CLC

CLI

CLR

CLRA

CLRB

CLV

CMPA

CMPB

COM

COMA

COMB

CPD

CPX

CPY

DAA

DEC

DECA

DECB

DES

DEX

DEY

EORA

EORB

FDIV

IDIV

INC

INCA

INCB

INS

INX

INY

JMP

JSR

LDAA

LDAB

LDD

LDS

LDX

LDY

LSL

LSLA

LSLB

LSLD

LSR

LSRA

LSRB

LSRD

MUL

NEG

NEGA

NEGB

NOP

ORAA

ORAB

PSHA

PSHB

PSHX

PSHY

PULA

PULB

PULX

PULY

ROL

ROLA

ROLB

ROR

RORA

RORB

RTI

RTS

SBA

SBCA

SBCB

SEC

SEI

SEV

STAA

STAB

STD

STOP

STS

STX

STY

SUBA

SUBB

SUBD

SWI

TAB

TAP

TBA

TEST

TPA

TST

TSTA

TSTB

TSX

TSY

TXS

TYS

WAI

XGDX

XGDY

  • Directives de compilation.


Edition d'un programme :

DebugHC11 permet l'édition de programme en assembleur 68HC11.

  • Interface MDI.

  • Jeux d'instructions 68HC11.

  • Directives de compilation et macro instruction.

CLRD

DCB

END

ENDC

ENDM

EQU

FCB

FCC

FDB

IFC

IFEQ

IFGT

IFLT

IFNC

IFNE

IFNEQ

INCL

LIB

MACR

MACRO

NAM

NEXTA

NEXTB

NEXTX

OPT

ORG

PAGE

RMB

RCVR

SET

SQRA

SQRB

SPC

Et voici quelques explications sur certaines directives de compilations ou macro instructions qui pourraient paraître suspectes

* Help file for:

* MC68HC11 Assembler Version 2.00 Motorola Copyright 5th May 1986

* Written by Richard Soja, Motorola EKB.

---> N.B. Refer to bottom of file for ammendments to:Version 2.10

Version 2.20 3/9/86

Version 2.30 24/11/86

Version 2.40 1/4/87

Version 2.60 21/4/88

Version 2.62 11/7/88

*

* Key features:

1. Supports Macro processing.

2. Supports conditional assembly.

3. Allows the use of nested Include files.

4. Permits symbols and their values to be passed from the

command line to the source file at assembly time.

5. Instruction set has been extended to include loop

primitives and other useful assembler-generated opcodes.

6. Unrestricted label size. (Only 1st 8 characters significant)

7. I/O buffer extended to considerably reduce assembly time.

8. Mnemonic table held in ASCII file for easy modification.

*

*

1. Macros:

See users manual for general syntax and format.

N.B. Macro definition is limited to 5000 characters.

An attempt to exceed this will generate Error 322.

N.B. There are two departures from standard Motorola format.

a. When it is necessary to delimit pass parameters by brackets,

only one set of brackets is ever required, as they are left

intact during parameter replacement.

b. Parameter numbers in macro definition can be any decimal,hex

or binary number, or any pre-declared symbol.

i.e.

PARAM1 EQU 0

PARAM2 EQU 1

M1 MACRO

LDAA \PARAM1

STAA \PARAM2

ENDM

2. Conditional assembly:

The following directives are supported.

IFEQ,IFNE (IFNEQ),IFGT,IFLT,IFC,IFNC

---> N.B. Conditional directives can be nested to 31 levels maximum.

Arguments for IFC & IFNC are separated only by a single comma: single

quotes must not be used as argument delimiters.

i.e.

IFC \0,TEST Is correct, but

IFC '\0','TEST' will generate an error.

3. Include files:

This allows a library of source files to be accessed at

assembly time, and overcomes, to some extent, the lack

of relocation and linking.

The syntax is:

INCL DRIVE:FILE.EXTENTION

or LIB DRIVE:FILE.EXTENTION

---> N.B. No extention is assumed, but DRIVE defaults to C.

---> N.B. Include files may be nested to 3 levels.

Error 323 occurs if more levels attempted.

---> N.B. Include operand is restricted to 10 characters maximum.

---> N.B. If I/O error F3 occurs, then make sure the MS-DOS system file

CONFIG.SYS contains the statement: files=15

4. Command line parameters:

The general syntax is ASMHC11 FILENAME;[OPTION[,OPTION]]

where OPTION is:

-O to disable S record creation

-L to disable listing file creation

H to halt assembly on detection of 1st error

L=LISTFILE to change name of the list file

SSSSS=NNNN to insert symbol SSSSS with value NNNN

into the symbol table. Any number of

symbols may be inserted.

---> N.B. No option is available for redirecting the listing directly to

---> the terminal or printer.

---> N.B. Ensure symbols, if passed, are in upper case.

---> N.B. Source files must have extention .ASC

---> Listing files will get extention .LST

---> S record files will get extention .REC

---> S record file is generated even if errors

are detected in source file.

---> The default drive name is C: but can be changed if required.

The insert symbol facility is useful for:

a. Relocating code: e.g. if the source file TEST.ASC contains

ORG ROMBASE

LDS #$FF

etc....

END

Then the command line can be used to force the base address

i.e. ASMHC11 TEST;ROMBASE=$E000

b. Conditional assembly: e.g. if file TEST1.ASC contains

ORG $C000

IFEQ TESTTYPE-1

LDAA #$AA

ENDC

IFEQ TESTTYPE-2

LDAA #$55

ENDC

etc...

END

Then the command line can be used to generate alternate codes,

depending on the value for TESTTYPE passed. i.e.

ASMHC11 TEST1;TESTTYPE=1 will generate LDAA #$AA

ASMHC11 TEST1;TESTTYPE=2 will generate LDAA #$55

5. Loop primitives: NEXTX LABEL equivalent to DEX\BNE LABEL

NEXTA LABEL " DECA\BNE LABEL

NEXTB LABEL " DECB\BNE LABEL

Other mnemonics: CLRD " CLRA\CLRB

SQRA " TAB\MUL

SQRB " TBA\MUL

RCVR LABEL " PULX\BRA LABEL

8. Mnemonic table: Two external Ascii files are loaded prior to assembly of

the users source code. These are called CODES.ASC and OFFSETS.ASC, and

must reside on the same disc as ASMHC11.COM

If you have any queries or problems relating to the use of this assembler

please contact:

Systems Engineering Dept.

Motorola Semiconductors Ltd.

East Kilbride

Scotland

or your local FAE.

==============================================================================

Version 2.10 28 MAY 1986

1. Spurious listing of conditional directives has

been fixed.

2. Square brackets can now also be used to delimit pass

parameters, but they are stripped off during expansion.

This permits mnemonics and directives to be passed

as parameters.

3. Unmatched number of pass parameters no longer generates

an error (# 262). Of course NARG can be used to

determine the number of actual parameters passed.

3. Operand for INCL directive is now unrestricted in size.

4. Listing of OPT L directive is now suppressed to tidy

up listings file.

Version 2.20 3 OCT 1986

1. Lower case and upper case characters can now be freely mixed

in both the source file and on the command line.

2. A new command line option has been added to support the

68HC11 bootstrap mode. Selecting the B option switch creates

a binary file which can be directly loaded into a 68HC11

operating in bootstrap mode. The opening character ($FF) is

also included in the binary file. The default size of the

file is 256 bytes (+opening char), but this can be redefined

in the command line option.

e.g. asmhc11 test;b will attempt to create a bootable

file of 256 bytes.

asmhc11 test;b=512 will attempt to create a bootable

file of 512 bytes.

The boot file name will be TEST.BOO

If the user code is less than the specified size, then the

boot file is padded with nulls ($00), otherwise an error

message is generated (but the file is still created).

3. A bug associated with the DCB directive has been fixed.

4. A bug associated with literal operators (' and ") has been

fixed.

Version 2.30 24 Nov 86

1. All non-printable characters are now converted into spaces

during assembly, to allow programmers to use editors which

embed control codes in the source file, usually used to

control the format. e.g. TAB and FORM FEED characters.

2. A bug associated with the bootstrap option (;b) has been

fixed. This caused an incorrect boot file to be created if

there was a discontinuity in the load address of the S-

record file. Discontinuities can occur only when RMB or ORG

directives are specified in the source file.

Version 2.40 1 Apr 87

1. Fixed bug which disallowed lower case X and Y in certain

index addressed instructions.

2. Fixed bugs generated only when conditional directives

preceded EQU and DCB directives.

3. Numeric conditional directive logic fixed.

4. SET directive now supported.

5. Files CODES.ASC and OFFSETS.ASC can now be optionally placed

in the root directory or the current working directory.

Version 2.60 21 Apr 88 (Version 2.50 was never released)

----------> N.B. ASMHC11 Version 2.60 is a .EXE file.

1. Fixed bug in divide operation. e.g. $B61D/256 produced $B7!

2. Fixed bug which prevented multiple literals operands in

FCB, FDB directives.

3. Improved trap to detect conditional nesting limit. (31)

4. Added command line option x which allows assembly of source

code with different syntax in BRSET/CLR and BSET/CLR.

This gives compatibility with AS11 - and allows assembly of

Buffalo source code - except for CMPD instruction which

should be replaced by a MACRO or changed to CPD.

5. Files CODES.ASC and OFFSETS.ASC must now be placed in the

same directory path as ASMHC11.EXE - This path must be

specified in the PATH environment string of MSDOS.

This means you don't need a copy of any of these files in

your current working directory or root.

6. The command line option h now halts on pass 1 errors as well

as pass 2 errors, and displays the offending line on the

screen. Errors can thus be trapped very quickly, without the

need for a listing file.

Version 2.61 Jun 88

1. Failure of command line option ;b in Version 2.60 was fixed.

Bug was caused by conversion of Version 2.5 to 2.6

Version 2.62 11 July 88

1. Maximum symbol table size increased from 800 to 1000 entries

at the expense of a 30% reduction in macro definition space.

================================END OF FILE===================================


Compilation d'un programme :

DebugHC11 vous permet de compiler un programme en assembleur 68HC11, ainsi que de créer un fichier Talker.

  • Compilation.

  • Fichiers crées.

  • En cas d'erreur.

  • Créer un Talker.


Compilation d'un programme :

DebugHC11 vous permet de compiler un programme en assembleur 68HC11, ainsi que de créer un fichier Talker.

  • Compilation.

Pour compiler votre programme, sélectionner la fenêtre d'édition puis cliquer dans le menu « Programme Assembler » ou sur le bouton : . Le compilateur sous DOS se lance, puis une fois la compilation terminée une fenêtre vous indique le nombre d'erreurs de compilation contenu dans votre fichier. Cliquer sur le bouton « OK » pour faire disparaître cette fenêtre.

  • Fichiers crées.

  • En cas d'erreur.

  • Créer un Talker.


Compilation d'un programme :

DebugHC11 vous permet de compiler un programme en assembleur 68HC11, ainsi que de créer un fichier Talker.

  • Compilation.

  • Fichiers crées.

Si vous n'avez aucune erreur de compilation, le compilateur a aussi crée deux autres fichiers ayant le même nom que votre fichier, avec les extensions, « .lst » et « .s19 ».

Le fichier « .lst » est un fichier montrant la correspondance entre le code assembleur et le code machine.

Le fichier « .s19 » ne contient que le code machine, il sera envoyer au 68HC11.

  • En cas d'erreur.

  • Créer un Talker.


Compilation d'un programme :

DebugHC11 vous permet de compiler un programme en assembleur 68HC11, ainsi que de créer un fichier Talker.

  • Compilation.

  • Fichiers crées.

  • En cas d'erreur.

Si lors de la compilation, votre fichier assembleur contient des erreurs, le fichier « .lst » est généré et contient au moins une ligne contenant le terme « ERROR » et un numéro d'erreur. Vous pouvez voir ce fichier en cliquant dans le menu « Programme Voir code source ».

Cependant, lors d'une erreur de compilation, DebugHC11 met en surbrillance la partie de la ligne où se trouve la première erreur. Avec un peu d'habitude et de chance, on n'a plus à ouvrir le fichier « .lst ».

Note : Le compilateur peut annocer un nombre d'erreurs important et il suffit d'une petite modification pour que toutes les erreurs disparaissent. Donc corriger une erreur après l'autre et entre chaque correction, refaite une compilation.

  • Créer un Talker.


Compilation d'un programme :

DebugHC11 vous permet de compiler un programme en assembleur 68HC11, ainsi que de créer un fichier Talker.

  • Compilation.

  • Fichiers crées.

  • En cas d'erreur.

  • Créer un Talker.

Vous pouvez créer un nouveau Talker (ceci est parfois nécessaire dans des applications spécifiques). Editer votre programme, assembler le. Lorsqu'il n'y a plus d'errreur d'assemblage, cliquer « Programme Créer un Talker ». Vous trouverez un fichier avec l'extension « .boo » que vous pourrez utiliser comme Talker.

Note : Si vous réaliser un Talker qui doivent fonctionner avec DebugHC11, ce Talker devra répondre aux différents ordres de DebugHC11. Voici donc le code source d'un des Talker qui fonctionne avec DebugHC11.

Code source de TKA1

* TKA1 the basic one for 68hc11A1

*****************************************************************

* c'est taklerA2.ASC avec COMA absent (cdes inversees)

* pas de test errors flags en INSCI

***

* modif GZ vecteur SWI

* cde $B1 rajout‚e

*

*Le pt arret rebouclait sur IDLE et non SWIIDLE

*

*

*************************** TALKERA2.ASC 12/7/88 *************************

* Written by R.Soja, Motorola, East Kilbride *

* Motorola Copyright 1988 *

* MCU resident, Interrupt driven Communication routines for 68HC11 *

* monitor. Provides low level memory and stack read/write operations. *

* Works with Host user interface program PCBUG11.EXE. *

* N.B. TALKERA2.ASC is designed to be downloaded through 68HC11A8 type *

* bootloader, and communicate with host through SCI. *

* This bootloader loads 256 bytes of user code before terminating. *

* It's identical to TALKERA8, except that PCBUG11 will detect that *

* it's the A2 version and use byte erasure on CONFIG reg. *

*

* CONSTANTS

TALKBASE equ $0000

BOOTVECT equ $00C4 Start of bootstrap vector jump table.

STACK equ $00EB

REGBASE equ $1000

*

JSCI equ $00C4

JXIRQ equ $00F1

JSWI equ $00F4

JILLOP equ $00F7

JCOP equ $00FA

uS500 equ 5000/35 500uS delay with DEY/BNE loop

JMPEXT equ $7E Mnemonic for jump extended instruction

BRKCODE equ $4A Break point signal code to host.

BRKACK equ $B5 Break point acknowledge code from host.

*

* REGISTERS

BAUD equ $2B

SCCR1 equ $2C

SCCR2 equ $2D

SCSR equ $2E

SCDR equ $2F

*

RDRF equ $20

TDRE equ $80

*

* PROGRAM

org TALKBASE

TLKRSTART EQU *

LDS #STACK

LDX #REGBASE

CLR SCCR1,X

LDD #$302C

STAA BAUD,X Initialise SCI to 9600 baud, no parity

STAB SCCR2,X and enable SCI tx & rx.

LDAA #$40 Enable STOP, and I bit interrupts, disable XIRQ.

TAP

*

IDLE JMP IDLE Now hang around for SCI interrupt from host.

* A RESET from host changes above jump destination to start of user code.

*

SCISRV EQU * On detecting interrupt,

LDAA SCSR+REGBASE assume receiver caused it.

ANDA #RDRF

BEQ SCISRV otherwise program will hang up

*

RXSRV EQU * Talker code processes received data.

LDAA SCDR+REGBASE Read command byte, & echo it as acknowledge

BSR OUTSCI to host.

BMI INH1 If command bit 7 set, then process inherent command

BSR INSCI else read byte count from host into ACCB.(0=256)

XGDX Save command and byte count.

BSR INSCI Read high address byte

TBA into ACCA

BSR INSCI then low address byte into ACCB

XGDX Restore command in ACCA,count in ACCB,address in X

CMPA #$01

BNE RXSRV1 If command is memory read, then

*

TREADMEM EQU * REPEAT

LDAA ,X read required address

BSR OUTSCI send it to host

TBA (save byte count)

BSR INSCI and wait for acknowledge

TAB (restore byte count)

INX Increment address

DECB Decrement byte count

BNE TREADMEM UNTIL all done

RTI and return to idle loop or user code.

*

RXSRV1 EQU *

CMPA #$41

BNE RXSRVEX If command is memory write then

*

TBA move byte count to ACCA

TWRITMEM EQU * REPEAT

BSR INSCI Read next byte from host into ACCB,

STAB ,X and store at required address.

LDY #$0001 Set up wait loop to allow for 28C64 prog time, where

WAITPOLL DEY Y operand must be manually set to $0359 (3mS)

BNE WAITPOLL

LDAB ,X Read stored byte and

STAB SCDR+REGBASE echo it back to host,

INX

DECA Decrement byte count

BNE TWRITMEM UNTIL all done

RXSRVEX EQU * and return

NULLSRV RTI

*

INSCI EQU *

LDAB SCSR+REGBASE Wait for RDRF=1

ANDB #RDRF

BEQ INSCI

LDAB SCDR+REGBASE then read data received from host

RTS and return with data in ACCB

*

OUTSCI EQU * Only register Y modified.

XGDY Enter with data to send in ACCA.

OUTSCI1 LDAA SCSR+REGBASE

BPL OUTSCI1 MS bit is TDRE flag

XGDY

STAA SCDR+REGBASE Important - Updates CCR!

RTS

*

INH1 EQU *

CMPA #$81 If command is read MCU registers then

BNE INH2

*

INH1A TSX Move stack pointer to X

XGDX then to ACCD

BSR OUTSCI send stack pointer to host (high byte first)

TBA

BSR OUTSCI then low byte

TSX Restore X (=stack pointer)

LDAB #9 then return 9 bytes on stack

BRA TREADMEM i.e. CCR,ACCB,ACCA,IXH,IXL,IYH,IYL,PCH,PCL

*

INH2 EQU *

CMPA #$C1 If command is write MCU registers then

BNE SWISRV1

*

BSR INSCI get stack pointer from host (High byte first)

TBA

BSR INSCI

XGDX Move to X reg

TXS and copy to stack pointer

LDAA #9 Then put next 9 bytes from host on to stack

BRA TWRITMEM

*

SWISRV EQU * Breakpoints generated by host-placed SWI instruction.

LDAA #BRKCODE Force host to process breakpoints

BSR OUTSCI by sending it the break signal

ILLOPSRV CLI Re-enable SCI receiver interrupts! (Also illop trap)

SWIIDLE BRA SWIIDLE then wait for response from host. (Ibit=0,Xbit=1)

*

SWISRV1 EQU *

CMPA #BRKACK If host has acknowledged breakpoint state then

bne STOP

TSX move stack pointer to SWI stack frame and

LDAB #9

ABX

TXS

LDD 7,X Send user code breakpoint return address to host

BSR OUTSCI (high byte first)

TBA

BSR OUTSCI (low byte next)

LDD #SWIIDLE force idle loop on return from breakpoint processing

STD 7,X

BRA INH1A but first return all MCU registers to host

STOP cmpa #$B1 **** pour arreter un prog qui tourne ***

BNE RXSRVEX EXIT par RTI

bra SWISRV ss passer par SWI car deja empile (inter SCI)

* et on ne ressort pas par rti

ORG BOOTVECT Boot vector jump table set up only during bootstrap.

FCB JMPEXT SCI

FDB SCISRV

FCB JMPEXT SPI (Unused vectors point to RTI)

FDB NULLSRV

FCB JMPEXT Pulse acc. Input Edge

FDB NULLSRV

FCB JMPEXT Pulse acc. Overflow

FDB NULLSRV

FCB JMPEXT Timer Overflow

FDB NULLSRV

FCB JMPEXT OC5

FDB NULLSRV

FCB JMPEXT OC4

FDB NULLSRV

FCB JMPEXT OC3

FDB NULLSRV

FCB JMPEXT OC2

FDB NULLSRV

FCB JMPEXT OC1

FDB NULLSRV

FCB JMPEXT IC3

FDB NULLSRV

FCB JMPEXT IC2

FDB NULLSRV

FCB JMPEXT IC1

FDB NULLSRV

FCB JMPEXT Real Time Intr

FDB NULLSRV

FCB JMPEXT IRQ

FDB NULLSRV

FCB JMPEXT XIRQ SCI RX line may be connected to XIRQ input, to

FDB NULLSRV allow exit from STOP in bootstrap mode.

FCB JMPEXT SWI N.B. Changed by monitor Break point and Trace !

FDB SWISRV change par GZ

FCB JMPEXT ILLOP

FDB ILLOPSRV

FCB JMPEXT COP Fail

FDB NULLSRV

FCB JMPEXT Clock Monitor N.B. Changed by monitor Reset operation !

FDB NULLSRV

*

END


Transfert d'un programme :

Lorsque vous avez compiler un programme assembleur, vous pouvez l'éxecuter sur une maquette de développement.

  • Ce qu'il faut faire.

  • Comment le réaliser avec DebugHC11

  • En cas d'erreur

  • Annuler un transfert.

  • Optimiser le temps d'un transfert.


Transfert d'un programme :

Lorsque vous avez compiler un programme assembleur, vous pouvez l'éxecuter sur une maquette de développement.

  • Ce qu'il faut faire.

Pour pouvoir exécuter votre programme sur une maquette cible, vous devez dans un premier temps transférer un programme TALKER dans le 68HC11 cible. Ce programme permet de gérer différentes commandes pour pouvoir communiquer avec le PC. Puis vous devez transférer votre programme dans le 68HC11. Enfin il suffit de placer le compteur ordinal à l'origine du programme, puis tester le programme.

  • Comment le réaliser avec DebugHC11.

  • En cas d'erreur.

  • Annuler un transfert.

  • Optimiser le temps d'un transfert.


Transfert d'un programme :

Lorsque vous avez compiler un programme assembleur, vous pouvez l'exécuter sur une maquette de développement.

  • Ce qu'il faut faire.

  • Comment le réaliser avec DebugHC11.

L'ensemble des commandes décrite dans « Ce qu'il faut faire », ont été enchaînées de manière à rendre tout ce processus transparent. L'ensemble des paramètres nécessaires au lancement du Talker, peuvent se configurer (voir la partie « Configuration de la liaison série »). Grâce à l'interface MDI, on connaît le programme à transférer. Enfin l'origine du programme vous est demandée lors du premier transfert, ensuite elle est mémorisée.

Une fois votre programme compilé et exempt d'erreur, sélectionner le fenêtre d'édition de votre programme, puis cliquer sur « Programme Programme vers cible » ou sur le bouton [image]. 3 nouvelles fenêtres s'ouvrent, dont une vous demande de faire un RESET en mode BootStrap du 68HC11. Appuyer sur le bouton RESET de votre maquette, puis valider le bouton « OK » de cette dernière fenêtre. Le TALKER est transféré.

Si le type de processeur cible a été modifié une nouvelle fenêtre apparaît vous permettant de configurer votre processeur cible.

Votre programme est ensuite transféré dans le 68HC11. Lors du premier transfert de votre nouveau programme, une fenêtre apparaît pour vous demander l'origine de ce programme.

Enfin DebugHC11, lit dans le processeur cible, les valeurs des registres et les différentes cases mémoires à afficher, puis place le compteur ordinal au début de votre programme.

Il ne vous rste plus qu'à exécuter votre programme sur le processeur cible.

  • En cas d'erreur.

  • Annuler un transfert.

  • Optimiser le temps d'un transfert.


Transfert d'un programme :

Lorsque vous avez compiler un programme assembleur, vous pouvez l'exécuter sur une maquette de développement.

  • Ce qu'il faut faire.

  • Comment le réaliser avec DebugHC11

  • En cas d'erreur.

Si la fenêtre « Transfert du TALKER » ne se ferme pas au bout de 10 secondes, c'est que le transfert a échoué, cliquer sur le bouton « Annuler » puis vérifier votre « Configuration de la liaison série », l'alimentation de votre maquette de test et la liaison entre le PC et la maquette.

Si la mise à jour des différentes fenêtres se bloque, cliquer « Cible Annuler communication » ou sur le bouton [image]. Puis recommencer le transfert.

Si un message « Impossible d'écrire aux adresses : ... » apparaît, c'est que le programme que vous essayez de transférer n'est pas écrit pour le type de processeur que vous avez sur la maquette. Adapter votre programme au type de processeur ou vérifier la configuration de votre processeur et notamment ces plages d'adresse.

  • Annuler un transfert.

  • Optimiser le temps d'un transfert.


Transfert d'un programme :

Lorsque vous avez compiler un programme assembleur, vous pouvez l'éxecuter sur une maquette de développement.

  • Ce qu'il faut faire..

  • Comment le réaliser avec DebugHC11.

  • En cas d'erreur.

  • Annuler un transfert.

A tout moment vous pouvez Annuler un transfert en cliquant « Cible Annuler communication » ou sur le bouton [image]. Si lors d'un plantage ou l'annulation d'un transfert, la fenêtre « Commande debugger est toujours présente, fermez cette fenêtre avant de relancer un transfert.

  • Optimiser le temps d'un transfert.


Transfert d'un programme :

Lorsque vous avez compiler un programme assembleur, vous pouvez l'éxecuter sur une maquette de développement.

  • Ce qu'il faut faire.

  • Comment le réaliser avec DebugHC11

  • En cas d'erreur

  • Annuler un transfert.

  • Optimiser le temps d'un transfert.

Le transfert d'un gros programme peut prendre de une à deux minutes. En fait l'écriture d'un octet en EEPROM prend plus de 20ms. DebugHC11, vas lire les valeurs contenue dans la EEPROM et n'écrit que les valeurs qui doivent être modifiées. Donc, je ne saurais trop vous conseiller lors du développement d'organiser votre programme de manière a avoir le moins d'octets qui changent entre les différentes versions au cours de l'évolution du programme.

De plus comme l'origine du programme est mémorisée, pour vous éviter d'avoir à changer cette origine à chaque évolution, utiliser à une adresse fixe une instruction « JUMP Debut » par exemple.

A cause de ces deux points de détails, voici une organisation de vos programmes qui devrait vous faire gagner du temps.

*Mon programme

 | org | $B600 | *Pour un 68HC11E1FN
 | jmp | Debut |
SP1 | ..... |  | *Sous programme 1 testé et vérifié ne devant plus être modifié
 | rts |  |
SPN | ..... |  | *Sous programme N testé et vérifié ne devant plus être modifié
 | rts |  |
TestSP | ... |  | *Sous programme en cours de développement.
 | rts |  |
Debut | .... |  | * Mon programme principal
 | .... |  |
 | end |  |


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

  • STOP.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

Vous trouvez dans cette fenêtre un barre de bouton permettant de réaliser les exécutions temps réel. Puis l'ensemble des registres internes du 68HC11. En bas de la fenêtre se trouve la valeur de la prochaine instruction qui sera exécutée lors de la prochaine exécution pas à pas.

Lorsque le 68HC11 n'est pas en cours d'exécution, il est possible de changer à tout moment les valeurs des registres. Ces modifications seront prises en compte lors de la prochaine action. Il est possible de changer la base de chaque registre (dans l'exemple le registre CCR est affiché en Octal) en cliquant avec le bouton droit sur l'affichage du registre, un menu contextuel apparaît permettant de choisir la base d'affichage.

Les différentes commandes possibles sont :

  • RUN.

  • STOP.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :9

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

Pour avoir accès à cette commande la fenêtre « Commande debugger » doit être active.

Pour lancer cette commande cliquer sur « Cible Run », appuyer sur « F9 » ou cliquer sur ce bouton : . Cette action lance l'exécution du programme contenu dans le 68HC11 à partir de l'adresse contenu dans le registre PC. Pour arrêter cette exécution, il faut cliquer sur le bouton STOP

  • STOP.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

  • STOP.

Pour avoir accès à cette commande la fenêtre « Commande debugger » doit être active.

Pour lancer cette commande cliquer sur « Cible Stop », appuyer sur « F10 » ou cliquer sur ce bouton : . Cette commande permet d'arrêter toutes les exécutions sur le 68HC11.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

  • STOP.

  • Exécution Pas à Pas.

Pour avoir accès à cette commande la fenêtre « Commande debugger » doit être active.

Pour lancer cette commande cliquer sur « Cible Pas à pas », appuyer sur « F8 » ou cliquer sur ce bouton : . Cette commande permet d'exécuter la prochaine instruction, puis le 68HC11 s'arrête. La différence avec « Exécution Approfondi » c'est que les sous programmes sont exécutés en entier.

Exemple :

jsr Tempo
ldaa #10
........
Tempo ldx #$FA12
T1 dex
bne T1
rts

Dans cet exemple de programme, si on demande à exécuter pas à pas sur l'instruction « jsr Tempo », la prochaine instruction sera ldaa #10. Le sous programme Tempo sera bien exécuté, mais l'exécution du programme sera arrêté après avoir complètement exécuter le sous programme Tempo.

Note : Lorsque vous exécuter un sous programme très long avec cette commande, DebugHC11 ne vous rendra la main que lorsque le sous programme sera terminé. Ceci peut prendre beaucoup de temps. Cependant vous pouvait à tout moment interrompre l'exécution du sous programme avec la commande STOP, pour voir l'avancement du traitement. Ensuite utiliser les « Points d'arret » pour revenir à votre instruction.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

  • STOP.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

Pour avoir accès à cette commande la fenêtre « Commande debugger » doit être active.

Pour lancer cette commande cliquer sur « Cible Pas Approfondi », appuyer sur « F7 » ou cliquer sur ce bouton : . Cette commande permet d'exécuter la prochaine instruction, puis le 68HC11 s'arrête. La différence avec « Exécution Pas à pas » c'est que le processeur s'arrête à chaque instruction.

Exemple :

jsr Tempo
ldaa #10
........
Tempo ldx #$FA12
T1 dex
bne T1
rts

Dans cet exemple de programme, si on demande à exécuter en pas approfondi sur l'instruction « jsr Tempo », la prochaine instruction sera « ldx #$FA12 ». Le 68HC11 s'arrète après avoir exécuté 1 et 1 seule instruction.

Note : Dans ce mode d'exécution DebugHC11 doit vous rendre la main presque instantanément. Si l'exécution de cette commande dure plus d'une seconde c'est qu'il y a un problème dans votre programme ou un problème de communication.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

  • STOP.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Pour avoir accès à cette commande la fenètre « Commande debugger » doit être active.

Pour lancer cette commande cliquer sur « Cible Prochain Point d'Arrêt », appuyer sur « F4 » ou cliquer sur ce bouton : . Avant de pouvoir utiliser cette commande, il faut « Ajouter (au moins) un point d'arrêt ». Lorsque vous utilisez cette commande le programme s'exécute sur le 68HC11, jusqu'à ce qu'il trouve un points d'arrêt. Ci votre programme ne passe pas sur un point d'arrêt, il ne s'arrêtera pas. Cependant il est toujours possible d'arrêter l'exécution du programme à l'aide de la commande STOP pour voir le déroulement du programme, puis relancer une commande. Cette commande est intéressante dans les boucles, pour voir l'évolution d'une variable, ou pour passer une phase d'initialisation longue.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

  • STOP.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arrêt.

Pour ajouter un point d'arrêt dans votre programme, placer le curseur dans la fenêtre d'édition du programme sur la ligne où vous désirez ajouter le point d'arrêt, puis appuyer sur « Ctrl B ». Une fenêtre de confirmation apparaît.

Pour pouvoir ajouter ou supprimer un point d'arrêt, activer la fenêtre « Commande debugger » puis cliquer dans le menu « Cible Points d'arrêt ». Une fenêtre apparaît :

où vous pouvez ajouter ou supprimer des points d'arrêt.

Note : Pour DebugHC11, il est tout à fait possible de placer un point d'arrêt sur une variable. Bien sur le programme ne pourra pas s'arrêter puisqu'il s'agit d'une variable. De plus cette variable sera écrasée, ce qui peut, peut être, engendrer des fonctionnements complètement erratiques de votre programme. De ce fait faites bien attention à l'endroit où vous placez vos points d'arrêt.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

  • STOP.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

Pour avoir accès à cette commande la fenêtre « Commande debugger » doit être active.

Après un transfert de programme dans le 68HC11, le registre PC est initialisé à la valeur mémorisée pour l'origine de votre programme. Si en cours d'évolution de votre programme, son origine évolue, il faut penser à modifier en cliquant dans le menu « Cible Origine du programme ». Cette origine programme permet à DebugHC11 de placer directement lors du transfert, la bonne valeur dans le registre PC du 68HC11.

  • Avoir les instructions mise en surbrillance.

  • Visualiser et modifier la mémoire un 68HC11.


Exécution sur le processeur cible :

DebugHC11, vous permet aussi de tester vos programme sur une maquette de test. Une fois votre programme compilé, transféré,

  • une fenêtre Commande debugger apparaît;

vous permettant de lancer différentes commandes d'exécution sur le 68HC11 :

  • RUN.

  • STOP.

  • Exécution Pas à Pas.

  • Exécution Approfondi.

  • Exécution jusqu'au prochain point d'arrêt.

Vous pourrez aussi grâce à DebugHC11.

  • Ajouter un point d'arret.

  • Modifier l'origine du programme.

  • Avoir les instructions mise en surbrillance.

Le gros avantage de DebugHC11 est qu'il a un rétroaffichage. C'est a dire que lorsque l'exécution d'un programme s'arrète, la prochaine instruction que doit exécuter le 68HC11 est mise en surbrillance dans la fenêtre d'édition. Ainsi on peut suivre l'évolution du programme en voyant exactement la position dans la globalité du programme.

Cette option disparaît par contre dès que le programme source dans la fenêtre d'édition est modifié. Cette option réapparaît à chaque transfert du programme.

  • Visualiser et modifier la mémoire un 68HC11.


Visualiser, modifier des variables.

Attention DebugHC11, utilise une technique d' « Optimisation des transferts »

Lors de l'exécution du programme sur votre maquette, DebugHC11, vous permet :

  • de visualiser des plages mémoires (dans différents formats)

  • de visualiser des plages mémoires au format ASCII

  • de modifier une variable.

L'ensemble de ces commandes se trouvent dans le menu « Cible » « Voir ... », lorsque la fenêtre « Commande debugger » est active.


Visualiser, modifier des variables.

Attention DebugHC11, utilise une technique d' « Optimisation des transferts »

Pour éviter bon nombre de transferts inutiles entre la maquette 68HC11 et le PC, toutes les valeurs lues dans le 68HC11 sont enregistrées dans le PC. Lorsque vous utilisez la commande « Ecrire » d'une fenêtre modification de variable, vous écrivez seulement dans la mémoire du PC. Les valeurs ne seront transférées dans le 68HC11 que lors d'une prochaine commande d'exécution de programme. Seules les valeurs écrites dans les registres sont transférées immédiatement dans le 68HC11.

Cette technique a été mise au points pour éviter les lourdes mises à jours (avec énormément de communications entre PC et 68HC11) lorsque vous visualiserez de nombreuses plages adresses tout en ayant la possibilité de modifier les registres du 68HC11 avec une action immédiate.
Un autre avantage et que si vous faites une erreur lors d'une écriture dans une mémoire du 68HC11, vous pouvez réécrire la bonne valeur. Seule la dernière valeur sera écrite dans la 68HC11.

Lors de l'exécution du programme sur votre maquette, DebugHC11, vous permet :

  • de visualiser des plages mémoires (dans différents formats)

  • de visualiser des plages mémoires au format ASCII

  • de modifier une variable.

L'ensemble de ces commandes se trouvent dans le menu « Cible » « Voir ... », lorsque la fenètre « Commande debugger » est active.


Visualiser, modifier des variables.

Attention DebugHC11, utilise une technique d' « Optimisation des transferts »

Lors de l'exécution du programme sur votre maquette, DebugHC11, vous permet :

  • de visualiser des plages mémoires (dans différents formats)

En sélectionnant la commande « Cible », « Voir ... » « Mémoire », lorsque la fenêtre « Commande debugger » est active, vous obtiendrez une nouvelle fenêtre ayant cet aspect.

Les nombres valeurs des cases mémoires sont représentés ainsi : le signe @ suivi de l'adresse de la case mémoire entre parenthèse, le signe =, le signe représentant la base et la valeur de la case mémoire.

Vous devez placer dans le champ « Adresse », la première adresse et dans le champ « Nombre d'octets », le nombre d'octets que vous désirez visualiser.
Le bouton [image] permet d'avoir un affichage en binaire, le bouton [image] permet d'avoir un affichage en octal, le bouton [image] permet d'avoir un affichage en décimal et le bouton [image] permet d'avoir un affichage en hexadécimal.
Le bouton permet [image] d'augmenter le nombre de colonnes d'affichage et le bouton [image] permet de diminuer le nombre de colonnes d'affichage.

Ainsi dans les deux exemples donnés ci dessus, la première fenêtre affiche 9 octets à partir de @0037 sur 3 colonnes avec un affichage en octal, alors que la seconde fenêtre affiche 4 octets à partir de l'adresse @$B600 sur 4 colonnes en hexadécimal.

  • de visualiser des plages mémoires au format ASCII

  • de modifier une variable.

L'ensemble de ces commandes se trouvent dans le menu « Cible » « Voir ... », lorsque la fenêtre « Commande debugger » est active.


Visualiser, modifier des variables.

Attention DebugHC11, utilise une technique d' « Optimisation des transferts »

Lors de l'exécution du programme sur votre maquette, DebugHC11, vous permet :

  • de visualiser des plages mémoires (dans différents formats)

  • de visualiser des plages mémoires au format ASCII

En sélectionnant la commande « Cible », « Voir ... » « ASCII », lorsque la fenêtre « Commande debugger » est active, vous obtiendrez une nouvelle fenêtre ayant cet aspect.

Vous devez placer dans le champ « Adresse », la première adresse et dans le champ « Nombre d'octets », le nombre d'octets que vous désirez visualiser.

Lorsque dans la mémoire des valeurs comprises entre 32 et 128 sont trouvées, les codes ASCII sont écrits l'un derrière l'autre en gras. Dans le cas où les nombres n'appartiennent pas au code ASCII standard, le signe @ suivi de l'adresse de la case mémoire entre parenthèse, le signe =, le signe # et la valeur de la case mémoire sont affichées en italique.

Dans l'impression d'écran au dessus on peut voir que à @B608, il y a le caractère 'B', @B609 il y a 'o', @B60A on trouve 'n',... , @B60E il y a 'r', en @B60F il y a la valeur 241, en @B610 on trouve le caractère « Espace », en @B611 la valeur 247, etc...

  • de modifier une variable.

L'ensemble de ces commandes se trouvent dans le menu « Cible » « Voir ... », lorsque la fenètre « Commande debugger » est active.


Visualiser, modifier des variables.

Attention DebugHC11, utilise une technique d' « Optimisation des transferts »

Lors de l'exécution du programme sur votre maquette, DebugHC11, vous permet :

  • de visualiser des plages mémoires (dans différents formats)

  • de visualiser des plages mémoires au format ASCII

  • de modifier une variable.

En sélectionnant la commande « Cible », « Voir ... » « Variable », lorsque la fenêtre « Commande debugger » est active, vous obtiendrez une nouvelle fenêtre ayant cet aspect.

La première partie de cette fenêtre présente deux boutons de choix permettent d'éditer une variable 8 bits (à l'adresse de base) ou 16 bits (poids fort à l'adresse de base, poids faible à l'adresse de base plus 1) .

La deuxième partie permet de sélectionner l'adresse de base. Soit directement dans la première boite d'édition, soit en choisissant dans la boite Combo un nom d'étiquette définit dans le fichier source.

La troisième partie affiche la dernière valeur lue dans le 68HC11 (lors d'un STOP, après une commande Pas à Pas, etc...). Le bouton «Actualiser» fait une nouvelle lecture dans le 68HC11. (En fait, seul les registres du 68HC11 sont actualisés, les autres valeurs ne devant pas varier. Voir Optimisation des transferts.

La quatrième partie se compose d'une boite d'édition et d'un bouton «Ecrire». Lorsque vous cliquez sur ce bouton la valeur de la boite d'édition est écrite à l'adresse de base dans le 68HC11 (En fait, seul les registres du 68HC11 sont écrits immédiatement, les autres valeurs ne seront transférées que lors de la prochaine commande d'éxécution. Voir Optimisation des transferts.

Danger cette boite de dialogue permet d'editer n'importe quelle valleur dans la mémoire du 68HC11. Faites attention lorsque cette fenêttre pointe sur une parti du programme, les dégâts pourraient être violents.