Chapitre 3

Chapitre 3: Programmation des
microprocesseurs
Dr - Wassim El Falou 1
Langages Machine et Langage Assembleur
Langages machine:
les instructions binaires c..d exprimes
sous forme de squences de 0 et de 1
Le langage machine n'est ainsi pas

comprhensible par l'tre humain
le langage machine qui est excutable

par le p est peu commode utiliser
Langages Assembleur:
Cest une reprsentation symbolique (mnmoniques)
des instructions binaires excutables par la machine
Trs proche du langage machine mais reste
comprhensible pour des dveloppeurs.
Dpend troitement du type de processeur utilis
(chaque type de processeur peut avoir son propre
langage machine). Ainsi, un programme dvelopp
pour une machine ne pourra pas tre port sur un
autre type de machine.
Langages haut Niveau:
peut communiquer avec la machine sans tenir
compte de leur architecture. De ce fait, ils sont dits
machine - indpendant et les programmes crits dans
ces langages sont portables dune machine une
autre.
Ces langages sont plus proches de la formulation
logique de lalgorithme, ceci permet bien entendu
une criture plus rapide du programme.
Lindpendance vis vis de la machine a permis de
disposer dinstructions plus volues possdant un
niveau smantique suprieur celui des instructions
assembleur.
Langages haut Niveau:
Lutilisation dun langage volu permet donc dlever le niveau dabstraction
dinstructions. Les notions des registres, positions mmoire et adressage
disparaissent et le programmeur peut travailler directement avec des entits
plus volues telles que des nombres en virgule flottante, des vecteurs, des
piles, etc..
Lexistence des telles structures de donnes, acclre considrablement la
programmation et minimise les risques derreur. En plus, avec la
programmation structure les notions dtiquettes (adresses dinstructions)
disparaissent ; le programmeur ne dit pas o le programme doit continuer,
mais ce quil doit faire ; il en rsulte une plus grande lisibilit des programmes
et une plus grande facilit de maintenance.
Le dsavantage essentiel reste nanmoins avec de tels langages volus, le fait
que lutilisateur ne puisse pas commander directement et efficacement toutes
les ressources de la machine. Le langage C a essay de remdier ce
problme et a eu de ce fait un grand succs surtout quil tait encore le
langage dimplantation du systme dexploitation UNIX.
Un p vu par un programmeur
Un programmeur ne se proccupe nullement de

savoir dans quelles technologies les I.C. sont
raliss, combien ils sont et comment ils sont
organiss de la machine p il ne considre quun
certain nombre dlments avec lesquels il va lui
falloir dialoguer.
Un p vu par un programmeur
Ces lments sont essentiellement :
Lensemble des registres du p accessibles au
programmeur.
Le jeu dinstructions du p.
Les diffrents modes dadressage disponibles.
Le mapping ou lorganisation mmoire, en particulier
les zones rserves.
Un ensemble dentres asynchrones (Reset, Ready, )
dont les actions peuvent influer directement sur le
squencement des instructions.
La frquence du squenceur pour calculer le temps
dexcution du programme.
Les types de donnes manipules par le p (digits,
BCD, octets, caractres).
Un exemple de programmation
Soit effectuer en dcimal lopration : 8-3+2=7.
On suppose que les oprations sont codes sur 4 bits
On suppose galement que les donnes sont codes en
complment 2 sur un octet sign.
Si on considre dans un premier temps un adressage
immdiat et quon suppose que les codes oprations des
diffrentes instructions sont les suivants:
0001 : remise zro de laccumulateur
0010 : addition dun nombre laccumulateur
0100 : complmentation 1
1000 : incrmentation
Le programme est suppos dmarr une adresse code
sur un octet par exemple 39 : 00111001. La mmoire est
organise en mots de 4 bits.
En Hex Adresse Instruction Commentaire Contenu de
Contenu du PC Opration oprande laccumulateur
39 00111001 0001 Remise zro 0000 0000

3A 00111010 0010 0000 0011 Additionner 3 0000 0011
3D 00111101 0100 Complment 1111 1100

1
3E 00111110 1000 Incrmenter 1111 1101
3F 00111111 0010 0000 1000 Additionner 8 0000 0101
42 01000010 0010 0000 0010 Additionner 2 0000 0111
43 01000101 0011 0010 0110 Stocker le

rsultat
Dans le cas dun adressage direct 00100000810
En Hex Adresse Instruction 00100100210
Contenu du PC Opration oprande 00100010310
39 00111001 0001 00100110pour
3A 00111010 0010 0010 0010
ranger le rsultat.
3D 00111101 0100
3E 00111110 1000
3F 00111111 0010 0010 0000
42 01000010 0010 0010 0100 Programme crit en assembleur

43 01000101 0011 0010 0110 Start:
RST
Adresse Instructions ADD Y
Contenu du PC Oprations Oprandes COMP
39 1
3A 2 2 2
INC
3D 4 ADD X
3E 8
3F 2 2 0
ADD Z
42 2 2 4 STO RES
45 3 2 6
END.
Classification et principales instructions des p
On peut distinguer plusieurs catgories dinstructions :

Les instructions de transfert de donnes.
Les instructions de traitement de donnes.
Les instructions dorganisation de programme.
Les instructions particulires ou spciales.
Lensemble des instructions dun p forme son jeu
dinstructions.
Dans la suite on va dtailler la programmation des

microprocesseurs 6800,68000 et PIC16FXXX
MC6800: Architecture et Brochage
Motorola 6800: Point de vue dun programmeur
MC6800: Modes dadressages
Adressages Inhrent
Adressages Immdiat
Adressages direct
Adressages tendue
Adressage indexe
Adressage relatif PC
MC6800: Adressages Inhrent
Codeop sans mot dextension
Exemple: INCA, DECA, DAA,.
MC6800: Adressages Immdiat
Exemple: LDAA #$0F (Code Instr :(@) = $86; (@+1)=$0F)

Avant Excution Aprs Excution
A= ?? A=$0F
MC6800: Adressages Direct
Exemple: ADDA $0C (Code Instr :(@) = $9B; (@+1)=$0C);

AE=$0C
A= $01 A=$0A
($0C) = $09
MC6800: Adressages Direct
Mmoire Accessible est entre $0000 et $00FF (page zro de
la mmoire).
En MC6809 on utilise une adressage page directe (Direct
page), alors AE = DP + Mot dextension
Exemple si DP = $0010 alors la mmoire Accessible est
entre $0010 et $010F
MC6800: Adressages Etendue
Exemple: ADDA $0100 (Code Instr :(@) = $BB; (@+1)=$01;

(@+2)=$00); AE = $0100
A= $0A A=$10
($0100) = $06
MC6800: Adressages Indexe
Exemple: LDAA $02,X (Code Instr :(@) = $A6; (@+1)=$02); Si

X = $00AB alors AE = $00AD
A= ??; X = $00AB A=$FF
($00AD) = $FF
MC6800: Adressages Relatif PC
Exemple:
Org $1000 $1000 $4C
Loop: $1001 $20
INCA $1002 $FD
Bra Loop
MC6800: Adressages Relatif PC
Exemple:
$1000 $4C
Org $1000
$1001 $7E
Loop:
$1002 $10
INCA
$1003 $00
Jmp Loop
Exemple:
Org $1000 $1000 $20
Bra Suite $1001 $01
INCA $1002 $4C
Suite:
..
MC6800: Jeux dinstructions
Instructions des transferts des donnes
Instructions arithmtiques
Instructions logiques
Instructions de rotation et dcalage
Instructions de comparaison
Instructions dorganisation de programme
Autres Instructions
MC6800: Instructions des transferts des donnes
LDAA, LDAB
STAA, STAB
TAB, TBA,TAP, TPA,TXS, TSX
LDX,LDS
STX,STS
PSHA, PSHB, PULA,PULB
Exemples:
LDX #$0010 (Adressage Immdiat)
X = ???? X=$0010
LDX $0010 (Adressage Etendue)
X = ???? X=$3344
($0010) = $33
($0011) = $44
Exemples:
STX $03,X (Adressage Indexe)
X = $AA00 X=$AA00
($AA03)=$?? AE=$AA03
($AA04)=$?? ($AA03)=$AA
($AA04)=$00
Exemples:
Org $0000
LDS #$03FF
LDAA #$AA
LDAB #$3F
PSHA 1
PSHB 2
PULA 3
PULB 4
MC6800: Instructions Arithmtiques
ADDA, ADDB, ABA,ADDCA,ADDCB
SUBA,SUBB,SBA,SBCA,SBCB
INC, INCA,INCB, INX,INS
DEC,DECA,DECB,DES,DEX
DAA
Exemples: ($1000 = $02)
LDX #$1000 ; X=$1000
LDAA #$FF ; A = $FF
ADDA #$33 ; A = $32, C=1,Z=0,N=0,V=0
ADDCA 0,X ; A= $35, C=0,Z=0,N=0,V=0
ADDA $1000 ; A=$37, C=0,Z=0,N=0,V=0
Exemples:
SUBA #$02
A= $03 A=$01
C=0,N=0
Z=0, V=0
03 03
- 02 + FE
-------
01
Exemples:
LDAA #$03 ;A= $03
ADDA #$09 ; A= $0C
DAA ; A= $12 (car 3+9=12 en
dcimale)
Exemples:
LDAA #$99 ;A= $99
ADDA #$99 ; A= $32, H=1, C=1
DAA ; A= $98 , C=1
(car 99+99=198 en
dcimale)
MC6800: Instructions Logiques
ANDA, ANDB (Et bit a bit)
BITA, BITB (Et bit a bit sans modifier A)
ORAA,ORAB (Ou bit a bit)
EORA, EORB (Ou exclusif bit a bit)
COM,COMA,COMB (C1)
NEG, NEGA, NEGB (C2)
Exemples: ($0000 = $33; $000F = 6B)
Org $FC00
LDX #$000F ; X = $000F
LDAA $0000 ; A = $33
ANDA #$FE ; A = $32
ORAA #$AB ; A = $BB
EORA #$CC ; A = $77
COM ,X ; ($000F)= $94
NEGA ; A= $89
END
Utilisation:
PORTA: Ports dentres dadresse $2000
Loop:
LDAA PORTA
ANDA #$08
BEQ Loop
Utilisation:
PORTA: Ports de sortie
Forage a zro du bit numro 5
LDAA PORTA
ANDA #$DF
STAA PORTA
Utilisation:
Forage a un du bit numro 2
LDAA PORTA
ORAA #$04
STAA PORTA
Utilisation:
Inversion des numro 1 et 6
LDAA PORTA
EORA #$42
STAA PORTA
MC6800: Instructions de rotation et dcalage
ASL, ASLA, ASLB (Arithmetic Shift Left)
ASR,ASRA,ASRB (Arithmetic Shift Right)
LSR,LSRA,LSRB (Logic Shift Right)
MC6800: Instructions de rotation et dcalage
ROL, ROLA,ROLB (Rotate Left)
ROR, RORA,RORB (Rotate Right)
MC6800: Instructions de Comparaison
CMPA : A (M) avec ajustement des Flags
CPX : X- (M:M+1) avec ajustement des Flags
CBA : A B avec ajustement des Flags
TSTA : A-00 avec ajustement des Flags
TSTB: B -00 avec ajustement des Flags
TST : M -00 avec ajustement des Flags
MC6800: Instructions dorganisation de programmes
(Saut)
JMP
JSR : Jump to subroutine
RTS: Return from subrotine
(Branchement)
BEQ - Branch if i equals j : Z=1

BNE - Branch if i does not equal j : Z=0
BHI - Branch if i is greater than j (unsigned) : C+Z=0
BLS - Branch if i is lower than or equal to j
(unsigned) : C+Z=1
BGT - Branch if i is greater than j (signed):
Z+(NV)=0
BGE Branch if i is greater than or equal to j
(signed) : NV=0
(Branchement)
BLT - Branch if i is less than j (signed): NV)=1

BLE - Branch if i is less than or equal to j (signed) :
Z+(NV)=1
BPL - Branch if plus (positive or zero): N=0
BMI - Branch if minus (negative) : N=1
BCC - Branch if Carry clear : C=0
BCS - Branch if Carry set : C=1
BVS - Branch if overflow set : V=1
BVC - Branch if overflow clear: V=0
BRA - Branch always
BSR Branch to subroutine
(Branchement)
Exercises: Traduire en assembleur MC6800 les

instructions en langage C suivant:
Langage C Assembleur 6800 Assembleur 6800
(G1,G2: 8 bits) (G1,G2: 16 bits)
If (G1==G2) LDAA G2 LDAA G2
{ CMPA G1 CMPA G1
. BNE Next BNE Next
} .. LDAA G2+1
Next: CMPA G1+1
BNE Next
..
Next:
(Branchement)
Exercises: Traduire en assembleur MC6800 les

instructions en langage C suivant:
Langage C Assembleur 6800 Assembleur 6800
(G1,G2: 8 bits non (G1,G2: 8 bits
signe) signe)
If (G2>G1) LDAA G2 LDAA G2
{ CMPA G1 CMPA G1
. BLS Next BLE Next
} .. ..
Next: Next:
If (G2>=G1) LDAA G1 LDAA G2
{ CMPA G2 CMPA G1
. BHI Next BLT Next
} .. ..
Next: Next:
MC6800: Autres Instructions
CLR, CLRA,CLRB
NOP: No Operation
CLC : 0C; CLI: 0 I; CLV : 0V
SEC : 1C; SEI: 1 I; SEV : 1V
SWI: Software Interrupt
WAI: Wait for Interrupt
RTI: Return from Interrupt
MC6800: Mcanisme Sous Programme
Adresse Code
Org $FC00
$FC00 LDAA #$FF
$FC02 LDAB #$AC
$FC04 LDX #$3001
$FC07 BSR SP1
$FC09 INCA
$FC0A SWI
Adresse Code
SP1 Org $FC10
$FC10 PSHA
$FC11 PSHB
$FC12 BSR SP2
$FC14 PULA
$FC15 PULB
$FC16 RTS
Adresse Code
SP2 Org $FC30
$FC30 LDX #$600B
$FC33 RTS
On suppose que SP = $00AF.

Execution instruction par instruction du programme.
A B X SP PC Pile
XX XX XXXX 00AF FC00
LDAA #$FF FF XX XXXX 00AF FC02
LDAB FF AC XXXX 00AF FC04

#$AC
LDX FF AC 3001 00AF FC07
#$3001
BSR SP1 FF AC 3001 00AD FC10 FC
09
PSHA FF AC 3001 00AC FC11 FF
FC
09
PSHB FF AC 3001 00AB FC12 AC
FF
FC
09
BSR SP2 FF AC 3001 00A9 FC30 FC
14
AC
FF
FC
09
A B X SP PC Pile
BSR SP2 FF AC 3001 00A9 FC30 FC

14
AC
FF
FC
09
LDX FF AC 600B 00A9 FC33 //

#$600B
RTS FF AC 600B 00AB FC14 //
PULA AC AC 600B 00AC FC15 //
PULB AC FF 600B 00AD FC16 //
RTS AC FF 600B 00AF FC09 //
INCA AD FF 600B 00AF FC0A //
MC68000: Architecture et Brochage
8 registres de donnes, 32 bits : D0 D7

Ces registres peuvent tre manipuls soit comme des bytes, soit comme
des word, soit comme des long.
8 registres dadresses , 32 bits : A0 A7 et A7 bis

On peut manipuler des adresses longues (long) ou des adresses courtes (word).
Notons que les adresses relles du 68000 sont cods sur 24 bits, par consquent
les 8 derniers bits dune adresse longue ne sont pas significatifs !
Notons galement le rle particulier des deux registres dadresse A7 et A7 bis,
encore appel USP (user stack pointer) et SSP (supervisor stack pointer). SP ou A7
contient ladresse du pointeur de pile relatif au mode courant, cest--dire
utilisateur ou superviseur.
PC ou program counter
Il contient ladresse de la prochaine instruction excuter.
SR ou status register, et CCR ou condition code register

Registre 16 bits : SR au format word (16 bits) ou CCR au format byte (8 bits)
Cest le registre dtat, qui comporte des bits indicateurs ou flags.
MC68000: Modes dadressages
Adressage absolue (Court, et Long)
Direct par registres des donnes : Dx
Direct par registres des dadresses: Ax
Immdiat : #constante
Indirect par registre dadresses: (Ax)
Indirect par registre dadresses post-incrment : (Ax)+
Indirect par registre dadresses pr-dcrment : - (Ax)
Indirect par registre dadresses avec dplacement : d16 (Ax)
Indirect par registre dadresses index avec dplacement :
d8 (Ax , Rx)
Indirect par PC avec dplacement : d(16)(PC)
Indirect par PC avec dplacement et index : d(8)(PC,Rx)
MC68000: Exemples
Directives DC (Define constant)
org $2000
array
dc.b $11,$22,$33,$44,$55,$66,$77,$88,$99,$AA
dc.w $11AA,255
dc.L $AABBCCDD
dc.b 'AB'
end
MC68000: Exemples
Instructions MOVE
MOVE.B source , destination

MOVE.W source , destination
MOVE.L source , destination
MC68000: Exemples
MC68000: Exemples
org $2000
array
dc.b $11,$22,$33,$44,$55,$66,$77,$88,$99,$AA
org $1000
move.l #$2000,A1 ;A1=$00002000
move.l #2,D5 ; D5=$00000002
move.w 0(A1,D5),D0 ; AE = $2000 + 2 + 0
; D0=$00003344
move.l #6,D5 ; D5=$0000006
move.l -2(A1,D5),D1 ; AE = $2000 + 6- 2
; D1=$55667788
rts
end $1000
MC68000: Codage des Instructions
Par exemple le code de:
- move.l #$12345678,D0 est 203C 1234 5678
-move.w (A0)+,D0 est 3018
- move.l #table,D0 est 203C 0000 2000
- move.w $02(A0),D1 est 3228 0002
- moveq #1,D1 est 7201
Assembler Directives
An assembler directive is simply a message to the assembler
that tells it how to go about translating instructions into
machine code. Assembly directives are not translated into
machine code because they are not instructions. Typical
assembler directives tell the assembler where to put a
program in memory, what space to allocate to variables, and
allow you to preset memory with data. When code is
assembled, a location counter in the assembler keeps track of
where the code and data is to go in memory.
Assembler Directives
We are going to use the following directives in this course:
<label> EQU <value> Equate
ORG <value> Origin
<label> DC <value> Define constant
<label> DS <value> Define storage
END <value> End of assembly language
program and "starting address" for execution
Assembler Directives: EQU
Equate
The EQU assembler directive simply equates a symbolic name
to a numeric value. Consider:
Sunday EQU 1
Monday EQU 2
The assembler substitutes the equated value for the symbolic
name; for example, if you write the instruction ADD.B
#Sunday,D2, the assembler treats it as if it were ADD.B #1,D2.
You could also write
Sunday EQU 1
Monday EQU Sunday + 1
In this case, the assembler evaluates "Sunday + 1" as 1 + 1
and assigns the value 2 to the symbolic name "Monday".
Assembler Directives: EQU
Do not think that the EQU directive creates variables or
constant. It doesn't and it has no effect on the code
generated by the program. This directive simply allows you to
make a name equivalent to its value (i.e., it's a form of short
hand).
Assembler Directives: ORG
Origin
The origin directive tells the assembler where to load
instructions and data into memory. The 68000 reserves the
first 1024 bytes of memory for exception vectors. Your
programs will start at location 1024; that is, you should begin
your program with ORG 1024 or ORG $400 (remember that
1024 = $400).
Assembler Directives: DC
Define Constant
The define constant assembler directive allows you to put a
data value in memory at the time that the program is first
loaded. The DC directive takes the suffix .B, .W, or .L. You can
put several values on one line (each value is separated by a
comma). The optional label field is given the address of the
first location in memory allocated to the DC function.
Consider the example:
ORG $2000
Val1 DC.B 20,34
Val2 DC.L 20
Me DC.B Alan Clements
Assembler Directives: DC
The effect of this code is to store the value $14 in location
$2000, $22 in location $2001, $00000014 in locations $2002,
$2003, $2004, $2005. Remember that a 32-bit long word
takes four bytes of memory. The ASCII string Alan Clements
is stored in bytes $2006 to $2012.
If you write MOVE.B Val2,D2, the assembler translates it as
MOVE.B $2002,D2. When this instruction is executed, data
register D2 is loaded with the contents of memory location
$2002. The value loaded into D2 might be 20. Might be?? Yes,
might be, because another instruction might modify the
contents of Val2. By the way, if you execute MOVE.B Me,D0,
data register D0 would be loaded with $41 (the ASCII code for
A). However, if you execute MOVE.W Me,D0, data register D0
would be loaded with $416C (the ASCII code for Al).
Assembler Directives: DS
Define Storage
The define storage directive is used to reserve one or more
memory locations. This directive is similar to the Pascal type
declaration. Consider:
Result DS.B 1
Table DS.W 10
Point DS.L 1
We will put these two fragments of assembly language

together and assemble them. The second column contains
memory addresses and the third column contains the data
loaded into these addresses.
Assembler Directives: DS
ORG $2000 ;Locate data here
VAL1: DC.B 20,34
VAL2: DC.L 20
ME: DC.B 'Alan Clements'
RESULT: DS.B 1 ;Save a byte for Result
TABLE: DS.W 10 ;Save 10 words (20 bytes) for Table
POINT: DS.L 1 ;Save 1 long word (4 bytes) for Point
END
Assembler Directives: Examples
68000 Assembly Language Program Structure
Assembler
Assembler

Assembler

Assembler

How Assembler Work

Assembler Pass

Assembler Pass

MC68000: Instructions des Transferts








MC68000: Instructions arithmtiques







MC68000: Instructions logiques

MC68000: Instructions de dcalage et rotation





MC68000: Instructions de comparaison

MC68000: Instructions de Comparaison

MC68000: Instructions de Saut et Branchement





Somme des nombres de 1 a 100

MC68000: Instructions de manipulation des bits
BCHG, BCLR, BSET: test a bit and change/clear/set ; BTST: test a bit
the specified bit location is tested, and Z flag is updated accordingly (if
the tested bit is 0, Z=1, otherwise, Z=0) then the test bit is complemented
(BCHG), or cleared to 0 (BCLR), or set to 1 (BSET)
if the bit location is 0-7, an immediate value can be used,
otherwise, a data register is used to specify the bit location
Assembler syntax: Bxxx #<data>, <ea>
Bxxx Dn, <ea>
Size ={Byte, Long} where, xxx is CHG, CLR, SET, or TST
Examples: D2 = $FF007A4B
BCHG #3, D2 ;D2= $FF007A43, Z=0
MOVE #15, D1
BSET D1, D2 ;D2= $FF00FA43,Z=1
MC68000: Instructions de manipulation des bits

MC68000: Instructions contrle systme






Assembler Directives: Exercices
Draw a memory map to demonstrate the effect of the following
sequence of 68000 assembly language directives?

What value would the following 68000 assembly language fragment
store at address $1002?

What value would the following 68000 assembly language fragment
store at address <$2004:$2005>?

Examine the following code:
a.What hexadecimal value does the assembler assign to the
symbolic name XY1?
b.What hexadecimal value does the assembler assign to the
symbolic name XYZ?
c.What hexadecimal value is placed in location XYZ?

MC68000: Exercices
Voici le programme 68000 suivants:
ORG $1000
MOVE.B D0,D1
MOVE.W #$44FF,D1
ADD.W $00002000,D2
MOVE.B (a0)+,D0
MOVE.L -2(a0),$0000300F
END
Calculer les nombres des octets occups par ce programme?
Solution:
2+4+6+2+8 = 22 octets

MC68000: Exercices

MC68000: Exercices

MC68000: Exercices

MC68000: Exercices
Ecrire un programme qui fait le tri de N nombres 8 bits
Ecrire un programme qui fait le tri de N nombres 16 bits
signe qui commence l'adresse ARRAY.
non signe qui commence l'adresse ARRAY.
Solution:
Solution:
N EQU 10
N EQU 10
ARRAY EQU $00002000
ARRAY EQU $00002000
PROG
PROG
LEA ARRAY,A0
LEA ARRAY,A0
CLR D2
CLR D2
MOVEQ #N-1,D3
MOVEQ #N-1,D3
LOOP1
LOOP1
MOVE.B (A0),D0
MOVE.W (A0),D0
MOVE.B 1(A0),D1
MOVE.W 2(A0),D1
CMP.B D0,D1
CMP.W D0,D1
BGE.S NOSWAP
BCC NOSWAP
MOVE.B D0,1(A0)
MOVE.W D0,2(A0)
MOVE.B D1,(A0)
MOVE.W D1,(A0)
MOVEQ #1,D2
MOVEQ #1,D2
NOSWAP
NOSWAP
ADDQ.L #1,A0
ADDQ.L #2,A0
SUBQ #1,D3
SUBQ #1,D3
BNE LOOP1
BNE LOOP1
TST D2
TST D2
BNE PROG
BNE PROG
END
END

MC68000: Exercices
Traduire en assembleur MC68000 le code C suivante:
Short T[100];
Short i;
Int S=0;
For (i=0;i<=98;i++)
S=S+T(i)*T(i+1);
Rappel: le type Short en C est un nombre sign code sur 16 bits, et le type Int est signe code sur 32 bits.
Solution:
ORG $1000
CLR.L D2
MOVE.B #N-1,D0
LEA T,A0
LOOP
MOVE.W (A0)+,D1
MULS (A0),D1
ADD.L D1,D2
DBRA D0,LOOP
MOVE.L D2,S
RTS
END $1000

MC68000: Exercices

MC68000: Exercices

MC68000: Exercices

MC68000: Exercices

MC68000: Exercices
ORG $1000 ; MAIN PROGRAM

MOVEA.L #S1,A0
MOVE.W A0,STATEPT
FSM
MOVEA.W STATEPT,A0
MOVE.B OUT(A0),$E003
OUT EQU 0 MOVE.B WAIT(A0),D0
WAIT EQU 1 BSR DELAY
NEXT EQU 2 MOVE.B $E001,D1
ORG $2000 ANDI.W #$03,D1
S1 DC.B $01 ; OUTPUT LSL.W #$01,D1
DC.B $05 ; WAIT TIME ADD.W D1,A0
DC.W S2,S1,S2,S3 MOVE.W NEXT(A0),STATEPT
BRA FSM
S2 DC.B $02 ; OUTPUT
DC.B $0A ; WAIT TIME DELAY ; TIME = D0 SECOND
DC.W S3,S1,S2,S3
MOVE.L #$FFD00000,D2
S3 DC.B $03 ; OUTPUT LOOP
DC.B $14 ; WAIT TIME ADD.L #$01,D2
DC.W S1,S1,S2,S1 BNE LOOP
ADD.L #$FFFFFFFF,D0
STATEPT DS.W 1 ; STATE POINTER BNE DELAY
RTS
END $1000

MC68000: Exercices
Voici le code C suivant :
short t[20]={2,7,15,17,18,200,44,97,100,14,3,12,13,14,22,17,150,11,14,15};
void main(void)
{
short i,j,n,count,premier;
count=0;
for (i=0;i<=19;i++)
{
n=t[i]/2;
premier=1;
for (j=2;j<=n;j++)
if ((t[i] %j) ==0)
{
premier=0;
break;
} ; end if
if (premier ==1)
count++;
} ; end for
} ; end main
Ce programme compte les nombres premiers qui existent dans le tableau t. Il se traduit en assembleur par le compilateur comme suit:

MC68000: Exercices
ORG $2000 MOVE.L #_T,A0
_T: DC.W MOVE.W -2(A6),D0
2,7,15,17,18,200,44,97,100,14,3,12 MULS #2,D0
DC.W ADD.W D0,A0
13,14,22,17,150,11,14,17 MOVE.W (A0),D0
ORG $1000 EXT.L D0
_MAIN: LINK A6,#-10 DIVS -4(A6),D0
MOVE.W #0,-8(A6) SWAP D0
MOVE.W #0,-2(A6) CMP.W #0,D0
MAIN_1: BNE MAIN_5
CMP.W #19,-2(A6) MOVE.W #0,-10(A6)
BGT MAIN_2 BRA MAIN_4
MOVE.L #_T,A0 MAIN_5:
MOVE.W -2(A6),D0 ADD.W #1,-4(A6)
MULS #2,D0 BRA MAIN_3
ADD.W D0,A0 MAIN_4:
MOVE.W (A0),D0 CMP.W #1,-10(A6)
EXT.L D0 BNE MAIN_7
DIVS #2,D0 ADD.W #1,-8(A6)
MOVE.W D0,-6(A6) MAIN_7:
MOVE.W #1,-10(A6) ADD.W #1,-2(A6)
MOVE.W #2,-4(A6) BRA MAIN_1
MAIN_3: MAIN_2:
MOVE.W -4(A6),D0 UNLK A6
CMP.W -6(A6),D0 RTS
BGT MAIN_4 END $1000

MC68000: Exercices

MC68000: Exercices
short t[20]={2,7,15,17,18,200,44,97,100,14,3,12,13,14,22,17,150,11,14,15};
_t: dc.w 2,7,15,17,18,200,44,97,100,14,3,12
dc.w 13,14,22,17,150,11,14,17
n=t[i]/2;
move.l #_t,A0
move.w -2(A6),D0
muls #2,D0
add.w D0,A0
move.w (A0),D0
ext.l D0
divs #2,D0
move.w D0,-6(A6)
premier=1;
move.w #1,-10(A6)

MC68000: Exercices
if ((t[i] %j) ==0)
move.l #_t,A0
move.w -2(A6),D0
muls #2,D0
add.w D0,A0
move.w (A0),D0
ext.l D0
divs -4(A6),D0
swap D0
cmp.w #0,D0
bne main_5
break;
bra main_4
if (premier ==1) count++;

cmp.w #1,-10(A6)
bne main_7
add.w #1,-8(A6)

Autre Micro
-Voir Cours

Chapitre 3

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 3

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 3: Programmation des

Le langage machine n'est ainsi pas

le langage machine qui est excutable

Un programmeur ne se proccupe nullement de

39 00111001 0001 Remise zro 0000 0000

3D 00111101 0100 Complment 1111 1100

42 01000010 0010 0000 0010 Additionner 2 0000 0111

43 01000101 0011 0010 0110 Stocker le

42 01000010 0010 0010 0100 Programme crit en assembleur

On peut distinguer plusieurs catgories dinstructions :

Dans la suite on va dtailler la programmation des

Exemple: INCA, DECA, DAA,.

Exemple: LDAA #$0F (Code Instr :(@) = $86; (@+1)=$0F)

Exemple: ADDA $0C (Code Instr :(@) = $9B; (@+1)=$0C);

Exemple: ADDA $0100 (Code Instr :(@) = $BB; (@+1)=$01;

Exemple: LDAA $02,X (Code Instr :(@) = $A6; (@+1)=$02); Si

ASL, ASLA, ASLB (Arithmetic Shift Left)

ASR,ASRA,ASRB (Arithmetic Shift Right)

LSR,LSRA,LSRB (Logic Shift Right)

ROL, ROLA,ROLB (Rotate Left)

ROR, RORA,RORB (Rotate Right)

BEQ - Branch if i equals j : Z=1

BLT - Branch if i is less than j (signed): NV)=1

Exercises: Traduire en assembleur MC6800 les

Exercises: Traduire en assembleur MC6800 les

On suppose que SP = $00AF.

XX XX XXXX 00AF FC00

LDAA #$FF FF XX XXXX 00AF FC02

LDAB FF AC XXXX 00AF FC04

BSR SP2 FF AC 3001 00A9 FC30 FC

LDX FF AC 600B 00A9 FC33 //

PULA AC AC 600B 00AC FC15 //

PULB AC FF 600B 00AD FC16 //

RTS AC FF 600B 00AF FC09 //

INCA AD FF 600B 00AF FC0A //

8 registres de donnes, 32 bits : D0 D7

8 registres dadresses , 32 bits : A0 A7 et A7 bis

SR ou status register, et CCR ou condition code register

MOVE.B source , destination

We will put these two fragments of assembly language

Dr - Wassim El Falou 100

Dr - Wassim El Falou 101

Dr - Wassim El Falou 102

Dr - Wassim El Falou 103

Dr - Wassim El Falou 104

Dr - Wassim El Falou 105

Dr - Wassim El Falou 106

Dr - Wassim El Falou 107

Dr - Wassim El Falou 108

Dr - Wassim El Falou 109

Dr - Wassim El Falou 110

Dr - Wassim El Falou 111

Dr - Wassim El Falou 112

Dr - Wassim El Falou 113

Dr - Wassim El Falou 114

Dr - Wassim El Falou 115

Dr - Wassim El Falou 116

Dr - Wassim El Falou 117

Dr - Wassim El Falou 118

Dr - Wassim El Falou 119

Dr - Wassim El Falou 120

Dr - Wassim El Falou 121

Dr - Wassim El Falou 122

Dr - Wassim El Falou 123