Sx Assembler Directives

Front 1

#

Back 1

denotes constant

Front 2

What is the size of a word instruction?

Back 2

12 bits

Front 3

What is the size of a data word?

Back 3

8 bits

Front 4

register W

Back 4

accumulator

Front 5

STATUS register

Back 5

a

Front 6

PC (Program Counter)

Back 6

a

Front 7

FSR (File Select Register)

Back 7

a

Front 8

IREAD

Back 8

a

Front 9

MODE register

Back 9

a

Front 10

How do you access a port's directional register?

Back 10

!rportname
ex: !rb
Note: each bit in the 8-bit port register represents the respective i/o pin on that port

Front 11

How do you set a port to be input or output?

Back 11

mov !rportname, #constant
A 1 in binary represents an input; 0 an output
ex: mov !rb, #%11111111; set all of port b to input

Front 12

How do you change logic levels of a port?

Back 12

mov rportname, #constant
A 1 in binary represents high; 0 low
ex: mov rb, #00000000; set all of port b to logic level 0 (low)

Front 13

nop

Back 13

No Operation Performed

Front 14

jmp

Back 14

jump
used to jump to labels or different memory adresses
ex: jmp start; jumps to label start

Front 15

clr

Back 15

clear
clears a byte, or a bit of a byte
ex: clr rb; sets rb to 0

Front 16

What can't clr be used with?

Back 16

clearing a port directional register
ex: clr !rb; this won't work!

Front 17

inc

Back 17

increment
increments a register by 1
ex: inc w; w+1

Front 18

What is compatability mode?

Back 18

A directive in the device preprocessor statement; slows everything down so that the SX can run code written for other microcontrollers

Front 19

add

Back 19

Adds two registers together and stores them in the former
ex: add w,#3; w=w+3

Front 20

What are local labels?

Back 20

labels within labels
ex: label1
:label2; label2 is only visible within label1

Front 21

How to you increment/decrement a register without modifying it?

Back 21

You use mov w,++register or mov w,--register
ex: mov w,++reg; w=reg+1 reg==reg
mov w,--reg; w=reg-1 reg==reg

Front 22

What are the watchdog prescaler values?

Back 22

a

Front 23

What must you do to keep the watchdog from resetting the SX unexpectedly?

Back 23

Clear the watchdog periodically within it's time value
ex: clr !wdt; clears watchdog timer

Front 24

setb

Back 24

Set Bit
sets one bit in a register
ex: setb

Front 25

What happens when you reset the SX while it's running?

Back 25

All ports change back to inputs

Front 26

xor

Back 26

exclusive-or
XOR's one register with another, then stores the result in the former register
ex: xor reg,w; xor reg with w

Front 27

#

Back 27

constant

Front 28

!

Back 28

directional register

Front 29

registers $00-$07

Back 29

special

Front 30

registers $08-$1F

Back 30

general purpose

Front 31

mov with anything other than w

Back 31

w gets destroyed

Front 32

jmp $+3

Back 32

jump 3 instructions ahead

Front 33

add pc,w

Back 33

skip w steps

Front 34

:

Back 34

local label

Front 35

dec 8

Back 35

8-1==8

Front 36

mov w,--8

Back 36

8-1==w
8==8

Front 37

equ
=

Back 37

equate
ex: var1 equ 8
var1 points to register 8
ex: var1 equ $8
var1 holds the hex value $8

Front 38

ds

Back 38

reserve bytes for a variable
ex: var1 ds 2
var1 is now two bytes long
(put an org statement beforehand to use specific registers)

Front 39

what's confusing about org?

Back 39

Can refer to either data space or program space

Front 40

What's wrong with this?

var1 ds 2
mov w,var2

Back 40

Only the first byte of var1 is stored into w; use var1+1 to access the second byte of var1 (note: w is a one byte accumulator)

Front 41

What's the difference between equ and = ?

Back 41

when equ is used, the value of var1 cannot be changed

when = is used, the value of var1 can be changed

Front 42

var.0

Back 42

first bit of var

Front 43

What's wrong with this?

mov var2,var1
mov var3,var1

Back 43

Since there's no instruction to move one variable into another, var1 is moved into w, and then into the destination variable. Here, var1 is loaded into w twice, which is wasteful

Front 44

mov var1-w

Back 44

var1=var1-w

Front 45

clc

Back 45

clear carry bit of status register

Front 46

clz

Back 46

clear zero bit of status register

Front 47

stc

Back 47

set carry bit of status register

Front 48

stz

Back 48

set zero bit of status register

Front 49

jb

Back 49

jump if bit is set

ex: jb rb.0,test
will jump to label test when bit 0 of rb is 1

Front 50

jc

Back 50

jump if carry flag is set

ex: jc test
will jump to label test if the carry flag is set; else the program will continue as normal

Front 51

jz

Back 51

jump if zero flag is set

ex: jz test
will jump to label test if the zero flag is set; else the program will continue as normal

Front 52

jnb

Back 52

jump if bit is 0 (cleared)

ex: jnb rb.0,test
will jump to label test if bit 0 of rb is 0

Front 53

jnz

Back 53

jump if zero flag is 0 (cleared)

ex: jnz test
will jump to label test only if the z flag is 0

Front 54

jnc

Back 54

jump if carry flag is 0

ex: jnc test

Front 55

test

Back 55

tests for equality between two registers

ex: test var1,var2
basically it does var2-var1 and checks if the zero flag is set

Front 56

djnz

Back 56

decrements a register by 1 and stores the result back into the register, and if it's zero, jumps to the specified label

Front 57

ijnz

Back 57

increments a register by 1 and stores the result back into the register, and if it's zero, jumps to the specified label

Front 58

and

Back 58

and's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: and w,var2

Front 59

or

Back 59

or's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: or w,var2

Front 60

xor

Back 60

xor's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: xor w,var2

Front 61

rl

Back 61

rotate bits left (bit 7 shifts to carry flag, carry flag shifts to bit 0)

Front 62

rr

Back 62

rotate bits right (bit 0 shifts to carry flag, carry flag shifts to bit 7)

Front 63

How do you multiply a register by 2?

Back 63

shift the bits left 1

Front 64

How do you divide a register by 2?

Back 64

shift the bits right 1

Front 65

jnb

Back 65

jump if bit is 0 (cleared)

ex: jnb rb.0,test
will jump to label test if bit 0 of rb is 0

Front 66

jnz

Back 66

jump if zero flag is 0 (cleared)

ex: jnz test
will jump to label test only if the z flag is 0

Front 67

jnc

Back 67

jump if carry flag is 0

ex: jnc test

Front 68

test

Back 68

tests for equality between two registers

ex: test var1,var2
basically it does var2-var1 and checks if the zero flag is set

Front 69

djnz

Back 69

decrements a register by 1 and stores the result back into the register, and if it's zero, jumps to the specified label

Front 70

ijnz

Back 70

increments a register by 1 and stores the result back into the register, and if it's zero, jumps to the specified label

Front 71

and

Back 71

and's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: and w,var2

Front 72

or

Back 72

or's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: or w,var2

Front 73

xor

Back 73

xor's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: xor w,var2

Front 74

rl

Back 74

rotate bits left (bit 7 shifts to carry flag, carry flag shifts to bit 0)

Front 75

rr

Back 75

rotate bits right (bit 0 shifts to carry flag, carry flag shifts to bit 7)

Front 76

How do you multiply a register by 2?

Back 76

shift the bits left 1

Front 77

How do you divide a register by 2?

Back 77

shift the bits right 1

Front 78

jnb

Back 78

jump if bit is 0 (cleared)

ex: jnb rb.0,test
will jump to label test if bit 0 of rb is 0

Front 79

jnz

Back 79

jump if zero flag is 0 (cleared)

ex: jnz test
will jump to label test only if the z flag is 0

Front 80

jnc

Back 80

jump if carry flag is 0

ex: jnc test

Front 81

test

Back 81

tests for equality between two registers

ex: test var1,var2
basically it does var2-var1 and checks if the zero flag is set

Front 82

djnz

Back 82

decrements a register by 1 and stores the result back into the register, and if it's zero, jumps to the specified label

Front 83

ijnz

Back 83

increments a register by 1 and stores the result back into the register, and if it's zero, jumps to the specified label

Front 84

and

Back 84

and's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: and w,var2

Front 85

or

Back 85

or's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: or w,var2

Front 86

xor

Back 86

xor's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: xor w,var2

Front 87

rl

Back 87

rotate bits left (bit 7 shifts to carry flag, carry flag shifts to bit 0)

Front 88

rr

Back 88

rotate bits right (bit 0 shifts to carry flag, carry flag shifts to bit 7)

Front 89

How do you multiply a register by 2?

Back 89

shift the bits left 1

Front 90

How do you divide a register by 2?

Back 90

shift the bits right 1

Front 91

jnb

Back 91

jump if bit is 0 (cleared)

ex: jnb rb.0,test
will jump to label test if bit 0 of rb is 0

Front 92

jnz

Back 92

jump if zero flag is 0 (cleared)

ex: jnz test
will jump to label test only if the z flag is 0

Front 93

jnc

Back 93

jump if carry flag is 0

ex: jnc test

Front 94

test

Back 94

tests for equality between two registers

ex: test var1,var2
basically it does var2-var1 and checks if the zero flag is set

Front 95

djnz

Back 95

decrements a register by 1 and stores the result back into the register, and if it's zero, jumps to the specified label

Front 96

ijnz

Back 96

increments a register by 1 and stores the result back into the register, and if it's zero, jumps to the specified label

Front 97

and

Back 97

and's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: and w,var2

Front 98

or

Back 98

or's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: or w,var2

Front 99

xor

Back 99

xor's var2 with var1 (or w), and stores it into var1 (or w). var2 can be replaced by a constant

uasge: xor w,var2

Front 100

rl

Back 100

rotate bits left (bit 7 shifts to carry flag, carry flag shifts to bit 0)

Front 101

rr

Back 101

rotate bits right (bit 0 shifts to carry flag, carry flag shifts to bit 7)

Front 102

How do you multiply a register by 2?

Back 102

shift the bits left 1

Front 103

How do you divide a register by 2?

Back 103

shift the bits right 1