Post on 14-Apr-2018
7/30/2019 Instruction Formats
1/47
Instruction formats
for the PIC series
7/30/2019 Instruction Formats
2/47
ROM encoding
Instructions are encoded in binary in
ROM.
The instructions are fixed format, eachoccupying 14 bits.
The division of the bits into fields is
flexible.
7/30/2019 Instruction Formats
3/47
byte oriented register ops
when d=0 destination = W reg
d=1 destination = reg[f]
f= 7 bit register selector
opcode d f ( reg num )
067813
7/30/2019 Instruction Formats
4/47
Bit oriented operations
b = 3bit number identifying a bit in an 8
bit register
f = 7 bit number identifying one of 128
possible registers
opcode b f
013 10 9 7 6
7/30/2019 Instruction Formats
5/47
Literal ops
These generally operate on the w register
The second operand is a value specified in
the instruction W:= w op k
opcode K=Literal value
07813
7/30/2019 Instruction Formats
6/47
Control transfer
Used for call or goto
K is a 11 bit literal that specifies an address
in the program memory
opcode K
0101113
7/30/2019 Instruction Formats
7/47
Example binary instructions
We will look at the binary layout of some
of the instructions in the instructionset
before going on to look at the way theseare accessed in assembler
Goto 6101 000 0000 0110
Binary for
goto
Binary for 6
7/30/2019 Instruction Formats
8/47
Remember about registers
General registers 128 of them
Working or W register
Program counter or PC
0
127
7/30/2019 Instruction Formats
9/47
Add 3 to W
Add literal instruction
Value to add = 3
11 1110 0000 0011
7/30/2019 Instruction Formats
10/47
Add register 33 to w
00 111 0 010 0001
Add reg
DestinationIs W
Register number
Is 33
W := W + Reg[33]
7/30/2019 Instruction Formats
11/47
Add w to register 3300 111 1 010 0001
Add reg
DestinationIs reg 33
Register number
Is 33
Reg[33] := w + reg[33]
This is what
Differs from
Last
Instruction
7/30/2019 Instruction Formats
12/47
Disadvantages of binary
Hard to remember
Very hard to remember for complex
instructionsetsAllows no variation in word lengths
between different processor models (
PICs come with 12, 14 and 16 bitinstructions )
7/30/2019 Instruction Formats
13/47
Assembler
Replaces each binary instruction with a
line of text
Opcodes replaced by mnemonic names Operands specified as symbolic labels or
decimal or hex numbers
Software package translates to binary
7/30/2019 Instruction Formats
14/47
Assembler process
7/30/2019 Instruction Formats
15/47
What assembler looks like
start clrw
main movlw 0x35
movwf mulplr ; test 0x35 times 0x2D
movlw 0x2Dmovwf mulcnd
call_m call mpy_S ; The result is in file
; registers H_byte &L_byte
; and should equal 0x0951
labels
opcodes
Operands
comments
Comments start with ;
7/30/2019 Instruction Formats
16/47
A simple example
What we want to compute is
Y:= x+5
We must associate these variables x,y withregisters.
We must select machine instructions that
will perform the calculation
7/30/2019 Instruction Formats
17/47
Assign variables
X assume it is 8 bit
integer
We will put it inregister 20h
We will put Y in
register 21h
General
registers
Specialregisters
0
20h
7f
Register bank
7/30/2019 Instruction Formats
18/47
Analyse possible data flows
1. W := x
2. W:=w+5
3. Y:=w
YES
1. W:=5
2. W:=w+x
3. Y:=w
YES
W:=x
Y:=w
Y:=y+5
NO, cant add
5 to y
7/30/2019 Instruction Formats
19/47
MOVLW 5 ; w:=5
ADDWF 20h,0 ; w:= w + reg[20h]
MOVWF 21h ; y:=w
Y:=x+5
0 indicates w is dest
7/30/2019 Instruction Formats
20/47
Outline the instructions
We will now look at the instructionset of
the PIC processor.
There are 35 instructions
7/30/2019 Instruction Formats
21/47
Register addition
ADDWF f,d
Add reg[f] to w and store in either w or
reg[f] depending on d,if d=0 then store in w, else in reg[f]
If reg[24h] =6 and w=4 then
ADDWF 24h,1
Sets reg[24h] to 10
7/30/2019 Instruction Formats
22/47
Addition of a constant
ADDLW const
Add const to w and store in w
If w=4 then
ADDLW 24h
Sets w to 28h
7/30/2019 Instruction Formats
23/47
andwf
ANDWF f,d
And reg[f] with w and store in either w or
reg[f] depending on d,if d=0 then store in w, else in reg[f]
If W = 0001 1111 and reg[20h]= 1111
0100ANDWF 20h,0
will set w to 0001 0100
7/30/2019 Instruction Formats
24/47
ANDLW
ANDLW const
And const with w and store in w
If W = 0001 1111 and const= 6=0000 0110
ANDLW 6
will set w to 0000 0110
7/30/2019 Instruction Formats
25/47
Clear registers
Clrf f set reg[f] to zero
Eg CLRF 40 ; reg[40]:=0
Clrw set w register to zero
7/30/2019 Instruction Formats
26/47
MOVE OPERATIONS
MOVFW f
Moves contents of register f to the W register
MOVWF f Moves the W reg to register f
MOVLW const
Moves the literal constant to the W register
Last two letters are memonics FW,WF,LW
7/30/2019 Instruction Formats
27/47
NOP
NOP stands for NO oPeration
It is an opcode that does nothing
Its binary pattern is
00000 0 0000 0000
This is similar to MOVWF whose pattern is
00000 1 FFFF FFFF
Destination bit
Destination register
Destination=w
7/30/2019 Instruction Formats
28/47
subtractions
This can be done by using complement orsubtract operations, subtract is not strictlyneeded
COMF f,dThis sets either reg[f] or w to reg[f]
For example if x is in reg[32] and y in
reg[33] then x:=x-y would be done byCOMF 33,0 ; w:=-y
ADDWF 32,1 ; x:=x+w
7/30/2019 Instruction Formats
29/47
Suppose we want reg[32]:=reg[33]-reg[40]Initial values 10 7 4
Binary00001010 00000111 00000100
Code Values manipulatedComf 40, 0 ; 00000100 11111011+1 11111100 w
Addwf 33,0 ; 00000111
11111100 +w
Movwf 32 ; reg[32]
Complement continued
000000111
Carry bit
00000011
7/30/2019 Instruction Formats
30/47
SUBWF
Subtract w from f
SUBWF f,d
This has two forms
SUBWF f,0 ; w:= reg[f]-w
SUBWF f,1 ; reg[f]:= reg[f]-w
Comf 33,0 ; w:=-y
Addwf 32,1 ; x:=x+w
MOVFW 33 ;w:=y
SUBWF 32,1;x:=x-w
Instead
of
7/30/2019 Instruction Formats
31/47
Decrement register
Decf f, d
Decrements reg[f] and stores result in
either reg[f] or w depending on dDECF 50,1
Subtracts 1 from register 50
DECF 50,0
Sets w := reg[50] -1
7/30/2019 Instruction Formats
32/47
Decrement and skip
DECFSZ f,d
Meaning of f, and d fields as before
If the result of decrementing is zero, skip the next
instructionTop:
;some instructions
DECFSZ 38,1
GOTO Top
; some other instructions
Reg[38] holds the number of times to go roundloop
7/30/2019 Instruction Formats
33/47
Incrementing
INCF and INCFSZ work like DECF and DECFSZ except that
they increment
In this case you would load a negative number into your
count register and count up towards zero.Alternatively, count up, and skip when the result would have
been 256.
Incfsz 50,1; means
reg[50] := reg[50]+1if reg[50] is 0 then skip next instruction
7/30/2019 Instruction Formats
34/47
Inclusive or
IORWF f,d
Example
If w=1100 0001 and reg[40]=0001 0001IORWF 40,0
Will set w= 1101 0001 1100000100010001 or11010001
7/30/2019 Instruction Formats
35/47
Inclusive or Literal
IORLW const
Example
If w=1100 0001IORLW 7
Will set w= 1100 0111 1100000100000111 or11000111
7/30/2019 Instruction Formats
36/47
Exclusive or
XORWF f,d
Example
If w=1100 0001 and reg[40]=0001 0001XORWF 40,0
Will set w= 1101 0000 1100000100010001 xor11010000
7/30/2019 Instruction Formats
37/47
Exclusive or Literal
XORLW const
Example
If w=1100 0001XORLW 7
Will set w= 1100 0110 1100000100000111 xor11000110
7/30/2019 Instruction Formats
38/47
Bit operations
BCF f,b set bit b of register f to 0
BSF f,b set bit b of register f to 1
Eg
BCF 34,1
Clears bit 1 of register 34
7/30/2019 Instruction Formats
39/47
Test instructions
BTFSC f,b ; bit test skip on clear
BTFSS f,b ; bit test skip on set
EgINCF 33
BTFSC 33,4
GOTO OVERFLOW ; goto overflow when
; reg 33 >7
7/30/2019 Instruction Formats
40/47
GOTO
GOTO label
E.g.,
GOTO home..
home
MOVLW 7.
Transfers control to the label
7/30/2019 Instruction Formats
41/47
CALL and RETURN
Thare used for subroutines or procedures.
CALL foo
.
foo ; start of procedure
. ; body of procedure
RETURN; end of procedure
7/30/2019 Instruction Formats
42/47
CALL continued
When a call occurs the PC+1 is pushed
onto the stackand then the PC is loaded
with the address of the label When return occurs the stack is popped
into the PC transferring control to the
instruction after the original call.
7/30/2019 Instruction Formats
43/47
example call source
Init
call increment
goto Init
increment
incf CountL
return
labels
7/30/2019 Instruction Formats
44/47
Example call and return
Address opcode assembler
5 2007 CALL 0x7
6 2805 GOTO 0x5
7 0AA2 INCF 0x22, F ; increment reg0x22
8 0008 RETURN
at start we have
state of the stack
7/30/2019 Instruction Formats
45/47
Next step
Address opcode assembler
5 2007 CALL 0x7
6 2805 GOTO 0x5
7 0AA2 INCF 0x22, F
8 0008 RETURN
stack holds address
to return to
7/30/2019 Instruction Formats
46/47
just before return
7/30/2019 Instruction Formats
47/47
after return
stack pointer is
retracted