Topics to Cover

EE 342 Microprocessors

ASSEMBLY PROGRAMMING

MSP430 Assembler
High Level vs. Assembly
Assembly Code
Assembly Process
Code Examples

Operators
Control Structures
Functions
Arrays and Pointers

Disclaimer: Most of the following slides are adopted from Prof. Paul Ropers course notes
with his kind permission.
1

Reading List

Where are We?

Problems

MSP 430 Microcontroller Basics by Davies

Chapter 3: Development
Chapter 5: Architecture of the MSP430 Processor
Assembly Program Examples in Other Chapters

Algorithms
Language (Program)

Programmable

Machine (ISA) Architecture

Computer Specific

Micro-architecture

Manufacturer Specific

Circuits
Devices
3

Assembler
An assembler
translates a program
into machine code

High Level vs. Assembly

An assembler outputs
an object file as input
to a linker program

An assembly program
is a text file

High Level Languages

More programmer friendly
More ISA independent
Each high-level statement translates to several
instructions in the ISA of the computer
Assembly Languages
Lower level, closer to ISA
Very ISA-dependent
Each instruction specifies a single ISA instruction
Makes low level programming more user friendly
More efficient code

Why Assembly Code?

Assembler Syntax

Allows us to work at a slightly higher level than machine

language.
Allows us to use symbolic names for opcodes
Allows us to use symbolic names for memory locations SUM, PRODUCT
Dont need to know every address of every storage
location.
Calculates addresses for us really a big deal!
Helps to allocate memory locations.
Provides additional error checking

A line can have four fields

label, mnemonic, operand list, and comment
The general syntax is:
{label[:]} mnemonic {operand list} {;comment}

Some line examples are:

.sect ".sysmem
.word 2
.text
Label1: mov r4,r5
.end
var1

;
;
;
;

Data Space
variable var1 declaration
Program Space
move R4 contents to R5

Assembly List File

Assembly Code Example

;*******************************************************************************
;
CS/ECEn 124 Lab 4 - morse.asm: Student Code
;*******************************************************************************
.cdecls C,LIST, "msp430x22x4.h
; include C header

A line in a listing file has four

fields:

Field 1: contains the

source code line counter

Field 2: contains the

section program counter

Field 3: contains the

object code

Field 4: contains the

original source statement.

COUNT

Labels

;
;
WDT_ISR:

Field 1 Field 2 Field 3

Field 4

.equ

Instructions

2000

;-----------------------------------------------------------------------------.data
; data
.bss
cnt,2
; ISR counter
;-----------------------------------------------------------------------------.text
; Program reset
RESET:
mov.w
#0x0280,SP
; Initialize stack pointer
mov.w
#WDT_MDLY_0_5,&WDTCTL
; Set Watchdog interval to ~0.5ms
mov.b
#WDTIE,&IE1
; Enable WDT interrupt
bis.b
#0x01,&P1DIR
; P1.0 output
bis.b
#0x20,&P4DIR
; P4.0 output
mov.w
#COUNT,&cnt
; initialize counter
bis.w
#LPM0+GIE,SR
; Enter LPM0 w/ interrupt
jmp
$
; Loop forever; interrupts do all

WDT_exit:

Directives

Watchdog Timer interrupt service routine

xor.b
dec.w
jne
mov.w
xor.b

Comments

#0x20,&P4OUT
&cnt
WDT_exit
#COUNT,&cnt
#0x01,&P1OUT

; pulse buzzer
; decrement counter

.sect
.word

".int10"
WDT_ISR

; MSP430 RESET Vector

; Watchdog ISR

.sect
.word
.end

".reset"
RESET

; MSP430 RESET Vector

; Power Up ISR

reti

; initialize counter
; toggle P1.0
; return from interrupt

Assembler Directives

Example: Operators

Assembly directives are used to specify:

Starting addresses for programs
Starting values for memory locations
Specify the end of program text.

variable = expression
int x = 9;
sub.w #2,sp
mov.w #9,0(sp)

;*******************************************************************************
;
CS/ECEn 124 Example Code
;*******************************************************************************
.cdecls C,LIST, "msp430x22x4.h
; include C header
COUNT

Directives

.equ

Stack

2000

x = x + 4;

;-----------------------------------------------------------------------------.data
; data
.bss
cnt,2
; ISR counter
;-----------------------------------------------------------------------------.text
; Program reset
RESET:
mov.w
#0x0280,SP
; Initialize stack pointer
mov.w
#WDT_MDLY_0_5,&WDTCTL
; Set Watchdog interval to ~0.5ms
bis.w
#LPM0+GIE,SR
; Enter LPM0 w/ interrupt
jmp
$
; Loop forever; interrupts do all
.sect
.word
.end

10

".reset"
RESET

sp

add.w #4,0(sp)

; MSP430 RESET Vector

; Power Up ISR

11

0x05fa
0x05fc
0x05fe
0x05f0
...
0x0600
12

Example: Operators
{
int
int
int
x =
y =

x
y
z
x
x

=
=
=
+
+

0x8696:
0x869a:
0x86a0:
0x86a6:
0x86ac:
0x86b0:
0x86b4:
0x86b6:
0x86ba:

10;
20;
30;
4;
y - z;

SP

x
y
z
ret adr
Stack

8031
40B1
40B1
40B1
52A1
411F
512F
811F
4F81

Example: Operators

0006
000A 0000
0014 0002
001E 0004
0000
0002
0004
0002

SUB.W
MOV.W
MOV.W
MOV.W
ADD.W
MOV.W
ADD.W
SUB.W
MOV.W

int main(int argc, char* argv[])

{
unsigned int x = 7;
unsigned int y = 5;
unsigned int z;

#0x0006,SP
#0x000a,0x0000(SP)
#0x0014,0x0002(SP)
#0x001e,0x0004(SP)
#4,0x0000(SP)
0x0002(SP),R15
@SP,R15
0x0004(SP),R15
R15,0x0002(SP)

z = x * y;
return 0;
}

x05f4
x05f6
x05f8
x05fa
x05fc
x05fe
x0600

x05f4
argc (r12) x05f6
argv (r13) x05f8
x
x05fa
y
x05fc
z
x05fe
ret adr x0600
Stack

SP

0x8040:
0x8044:
0x8048:
0x804c:
0x8052:
0x8058:
0x805c:
0x8060:
0x8064:
0x8068:
0x806a:
0x806e:

main:
8031 000A
4D81 0002
4C81 0000
40B1 0007 0004
40B1 0005 0006
411C 0004
411D 0006
12B0 80DA
4C81 0008
430C
5031 000A
4130

__mpyi:
0x80da: 430E
mpyi_add_loop:
0x80dc: C312
0x80de: 100C
0x80e0: 2801
0x80e2: 5D0E
shift_test_mpyi:
0x80e4: 5D0D
0x80e6: 930C
0x80e8: 23F9
0x80ea: 4E0C
0x80ec: 4130

SUB.W
MOV.W
MOV.W
MOV.W
MOV.W
MOV.W
MOV.W
CALL
MOV.W
CLR.W
ADD.W
RET

#0x000a,SP
R13,0x0002(SP)
R12,0x0000(SP)
#0x0007,0x0004(SP)
#0x0005,0x0006(SP)
0x0004(SP),R12
0x0006(SP),R13
#__mpyi
R12,0x0008(SP)
R12
#0x000a,SP

CLR.W

R14

CLRC
RRC
JLO
ADD.W

R12
(shift_test_mpyi)
R13,R14

RLA.W
TST.W
JNE
MOV.W
RET

R13
R12
(mpyi_add_loop)
R14,R12

13

Example: Operators
int inGlobal;
void main(void)
{
int outLocal;
int inLocalA;
int inLocalB;
outLocal = inGobal+inLocalA+inLocalB;
return;
}

Symbol
Table

14

Example: Control Structures

main:
SUB.W
MOV.W
ADD.W
ADD.W
MOV.W
ADD.W
RET

void main(void)
{
int c, a, b, r;
switch (c)
{
case '+':
r = a + b;
break;

#0x0006,SP
0x0002(SP),R15
&inGlobal,R15
0x0004(SP),R15
R15,0x0000(SP)
#0x0006,SP

case '-':
r = a - b;
break;

Identifier

Type

Storage Class Offset

Scope

inGlobal

int

Static

absolute

global

inLocalA

int

Auto

2(SP)

main

inLocalB

int

Auto

4(SP)

main

outLocal

int

Auto

0(SP)

main

case '*':
r = a * b;
break;
default:
printf("\nInvalid!");
break;
}
}
15

main:
0x9614: 8031
0x9618: 3C1D
C$L1:
0x961a: 411F
0x961e: 511F
0x9622: 4F81
0x9626: 3C20
C$L2:
0x9628: 411F
0x962c: 811F
0x9630: 4F81
0x9634: 3C19
C$L3:
0x9636: 411C
0x963a: 411D
0x963e: 12B0
0x9642: 4C81
0x9646: 3C10
C$L4:
0x9648: 40B1
0x964e: 12B0
0x9652: 3C0A
C$L5:
0x9654: 411F
0x9658: 803F
0x965c: 27EC
0x965e: 831F
0x9660: 27DC
0x9662: 832F
0x9664: 27E1
0x9666: 3FF0
C$L6:
0x9668: 5031
0x966c: 4130

000A

SUB.W
JMP

#0x000a,SP
(C$L5)

0006
0004
0008

MOV.W
ADD.W
MOV.W
JMP

0x0006(SP),R15
0x0004(SP),R15
R15,0x0008(SP)
(C$L6)

0004
0006
0008

MOV.W
SUB.W
MOV.W
JMP

0x0004(SP),R15
0x0006(SP),R15
R15,0x0008(SP)
(C$L6)

0004
0006
9C98
0008

MOV.W
MOV.W
CALL
MOV.W
JMP

0x0004(SP),R12
0x0006(SP),R13
#__mpyi
R12,0x0008(SP)
(C$L6)

A016 0000
97C0

MOV.W
CALL
JMP

#0xa016,0x0000(SP)
#lcd_printf
(C$L6)

0002
002A

MOV.W
SUB.W
JEQ
DEC.W
JEQ
DECD.W
JEQ
JMP

0x0002(SP),R15
#0x002a,R15
(C$L3)
R15
(C$L1)
R15
(C$L2)
(C$L4)

000A

ADD.W
RET

#0x000a,SP
16

Example: Control Structures

LOOP:

DONE:

MSG:

sub #2,sp
mov #7,0(sp)

; int a = 7;

cmp #0,0(sp)
jeq DONE
mov 0(sp),r12
add #'0',r12
call #PUTC
mov #10,r12
call #PUTC
sub #1,0(sp)
jmp LOOP

; while (a)
; {
;
printf("%c\n", a + '0');

mov #MSG,r12
call #PUTS
...

Example: Control Structures

sub #2,sp
mov #7,0(sp)
LOOP:

False

Test
True

Body
;
a--;
; }

DONE:

; printf("All done...\n");
MSG:

.string "All done...\n"

.byte 0

mov 0(sp),r12
add #'0',r12
call #PUTC
mov #10,r12
call #PUTC
sub #1,0(sp)
jne LOOP
mov #MSG,r12
call #PUTS
...

; int a = 7;
; do {
;
printf("%c\n", a + '0');

Body
;
a--;
; } while (a);

True

; printf("All done...\n");

False

.string "All done...\n"

.byte 0

17

Example: Control Structures

LOOP:

DONE:

MSG:

sub #2,sp

; int a;

mov #0,0(sp)

; for (a=0; a<10; a++)

bit #-1,0(sp)
jeq DONE
mov 0(sp),r12
add #'0',r12
call #PUTC
mov #10,r12
call #PUTC
add #1,0(sp)
cmp #10,0(sp)
jl LOOP

; {

mov #MSG,r12
call #PUTS
...

Test

.string "All done...\n"

.byte 0

Example:

int func(a, b, c, d, e, f)
{
int x, y, z;
x = 1;
y = 2;
z = 3;
return a+b+c+d+e+f+x+y+z;
}
int main()
{
func(10, 20, 30, 40, 50, 60);
return 0;
}

Init

; printf("All done...\n");

18

Example: Functions

printf("%c\n", a + '0');

; }

Test

False

f
e

True

z
y
x
d
c
b
SP a

Body
Re-init

19

60
50
Return adr
3
2
1
40
30
20
10

0x0012(SP)
0x0010(SP)
0x000c(SP)
0x000a(SP)
0x0008(SP)
0x0006(SP)
0x0004(SP)
0x0002(SP)
0x0000(SP)

main:
0x8762:
0x8764:
0x876a:
0x8770:
0x8774:
0x8778:
0x877c:
0x8780:
0x8784:
0x8786:
0x8788:
0x853c:
0x8540:
0x8544:
0x8548:
0x854c:
0x8550:
0x8554:
0x8558:
0x855e:
0x8562:
0x8564:
0x8568:
0x856c:
0x8570:
0x8574:
0x8578:
0x857c:
0x8580:
0x8584:

8221
40B1 0032 0000
40B1 003C 0002
403C 000A
403D 0014
403E 001E
403F 0028
12B0 853C
430C
5221
4130
func:
8031 000E
4F81 0006
4E81 0004
4D81 0002
4C81 0000
4391 0008
43A1 000A
40B1 0003 000C
411C 0002
512C
511C 0004
511C 0006
511C 0010
511C 0012
511C 0008
511C 000A
511C 000C
5031 000E
4130

SUB.W
MOV.W
MOV.W
MOV.W
MOV.W
MOV.W
MOV.W
CALL
CLR.W
ADD.W
RET

#4,SP
#0x0032,0x0000(SP)
#0x003c,0x0002(SP)
#0x000a,R12
#0x0014,R13
#0x001e,R14
#0x0028,R15
#func
R12
#4,SP

SUB.W
MOV.W
MOV.W
MOV.W
MOV.W
MOV.W
MOV.W
MOV.W
MOV.W
ADD.W
ADD.W
ADD.W
ADD.W
ADD.W
ADD.W
ADD.W
ADD.W
ADD.W
RET

#0x000e,SP
R15,0x0006(SP)
R14,0x0004(SP)
R13,0x0002(SP)
R12,0x0000(SP)
#1,0x0008(SP)
#2,0x000a(SP)
#0x0003,0x000c(SP)
0x0002(SP),R12
@SP,R12
0x0004(SP),R12
0x0006(SP),R12
0x0010(SP),R12
0x0012(SP),R12
0x0008(SP),R12
0x000a(SP),R12
0x000c(SP),R12
#0x000e,SP
20

Example: Arrays and Pointers

Example: Arrays and Pointers

SP

int main()
{
int array[10];
int x;
x = array[3] + 1;
array[6] = 5;
return 0;

array[0]
array[1]
array[2]
array[3]
array[4]
array[5]
array[6]
array[7]
array[8]
array[9]
x

SP

0x0000(SP)
0x0002(SP)
0x0004(SP)
0x0006(SP)
0x0008(SP)
0x000a(SP)
0x000c(SP)
0x000e(SP)
0x0010(SP)
0x0012(SP)
0x0014(SP)

int main()
{
int array[10];
int x;
for (x = 0; x < 10; x++)
{
array[x] = x;
main:
}
0x8040: 8031
0x8044: 4381
return 0;
0x8048: 90B1
}
0x804e: 340D

}
main:
0x87a2:
0x87a6:
0x87a8:
0x87ac:
0x87b0:
0x87b6:
0x87b8:
0x87bc:

8031
431F
511F
4F81
40B1
430C
5031
4130

0016
0006
0014
0005 000C
0016

SUB.W
MOV.W
ADD.W
MOV.W
MOV.W
CLR.W
ADD.W
RET

0x8050:
0x8054:
0x8056:
0x8058:
0x805e:
0x8062:
0x8068:

#0x0016,SP
#1,R15
0x0006(SP),R15
R15,0x0014(SP)
#0x0005,0x000c(SP)
R12
#0x0016,SP

21

Example: Arrays and Pointers

SP

int array[10];
int x;
grid[x+1] = grid[x] + 2;

0x86aa:
0x86ae:
0x86b0:
0x86b2:
0x86b4:
0x86b6:
0x86ba:
0x86bc:
0x86be:
0x86c0:

411F 0014
5F0F
510F
432E
5F2E
411F 0014
5F0F
532F
510F
4E8F 0000

MOV.W
RLA.W
ADD.W
MOV.W
ADD.W
MOV.W
RLA.W
INCD.W
ADD.W
MOV.W

array[0]
array[1]
array[2]
array[3]
array[4]
array[5]
array[6]
array[7]
array[8]
array[9]
x

0x806a:
0x806c:
0x8070:

0016
0014
000A 0014

SUB.W
CLR.W
CMP.W
JGE
C$DW$L$main$2$B, C$L1:
411F 0014
MOV.W
5F0F
RLA.W
510F
ADD.W
419F 0014 0000
MOV.W
5391 0014
INC.W
90B1 000A 0014
CMP.W
3BF3
JL
C$L2, C$DW$L$main$2$E:
430C
CLR.W
5031 0016
ADD.W
4130
RET

array[0]
array[1]
array[2]
array[3]
array[4]
array[5]
array[6]
array[7]
array[8]
array[9]
x

0x0000(SP)
0x0002(SP)
0x0004(SP)
0x0006(SP)
0x0008(SP)
0x000a(SP)
0x000c(SP)
0x000e(SP)
0x0010(SP)
0x0012(SP)
0x0014(SP)

#0x0016,SP
0x0014(SP)
#0x000a,0x0014(SP)
(C$DW$L$main$2$E)
0x0014(SP),R15
R15
SP,R15
0x0014(SP),0x0000(R15)
0x0014(SP)
#0x000a,0x0014(SP)
(C$L1)
R12
#0x0016,SP
22

Example: Arrays and Pointers

0x0000(SP)
0x0002(SP)
0x0004(SP)
0x0006(SP)
0x0008(SP)
0x000a(SP)
0x000c(SP)
0x000e(SP)
0x0010(SP)
0x0012(SP)
0x0014(SP)

int array[10];
int x;
int main()
{
for (x = 0; x < 10; x++)
{
array[x] = x;
main:
}
0x806a: 4382
return 0;
0x806e: 90B2
0x8074: 340C
}

0x0014(SP),R15
R15
SP,R15
#2,R14
@R15,R14
0x0014(SP),R15
R15
R15
SP,R15
R14,0x0000(R15)

0x8076:
0x807a:
0x807c:
0x8082:
0x8086:
0x808c:
0x808e:
0x8090:
23

0214
000A 0214

CLR.W
CMP.W
JGE
C$DW$L$main$2$B, C$L1:
421F 0214
MOV.W
5F0F
RLA.W
429F 0214 0200
MOV.W
5392 0214
INC.W
90B2 000A 0214
CMP.W
3BF4
JL
C$L2, C$DW$L$main$2$E:
430C
CLR.W
4130
RET

&x
#0x000a,&x
(C$DW$L$main$2$E)
&x,R15
R15
&x,0x0200(R15)
&x
#0x000a,&x
(C$L1)
R12
24