Instruction Formats

7/30/2019 Instruction Formats

1/47

Instruction formats

for the PIC series


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.


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


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


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


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/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


8/47

Remember about registers

General registers 128 of them

Working or W register

Program counter or PC

0

127


9/47

Add 3 to W

Add literal instruction

Value to add = 3

11 1110 0000 0011


10/47

Add register 33 to w

00 111 0 010 0001

Add reg

DestinationIs W

Register number

Is 33

W := W + Reg[33]


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


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 )


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


14/47

Assembler process


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 ;


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


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


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


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


20/47

Outline the instructions

We will now look at the instructionset of

the PIC processor.

There are 35 instructions


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


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


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


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


25/47

Clear registers

Clrf f set reg[f] to zero

Eg CLRF 40 ; reg[40]:=0

Clrw set w register to zero


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


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


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


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


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


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


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


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


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


35/47

Inclusive or Literal

IORLW const

Example

If w=1100 0001IORLW 7

Will set w= 1100 0111 1100000100000111 or11000111


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


37/47

Exclusive or Literal

XORLW const

Example

If w=1100 0001XORLW 7

Will set w= 1100 0110 1100000100000111 xor11000110


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


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


40/47

GOTO

GOTO label

E.g.,

GOTO home..

home

MOVLW 7.

Transfers control to the label


41/47

CALL and RETURN

Thare used for subroutines or procedures.

CALL foo

.

foo ; start of procedure

. ; body of procedure

RETURN; end of procedure


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.


43/47

example call source

Init

call increment

goto Init

increment

incf CountL

return

labels


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


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


46/47

just before return


47/47

after return

stack pointer is

retracted

Instruction Formats

Documents

Transcript of Instruction Formats