Instruction formats for the PIC series. ROM encoding Instructions are encoded in binary in ROM. The instructions are fixed format, each occupying 14 bits.

Instruction formats

for the PIC series

ROM encoding

Instructions are encoded in binary in ROM.

The instructions are fixed format, each occupying 14 bits.

The division of the bits into fields is flexible.

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

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

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

Control transfer

Used for call or goto K is a 11 bit literal that specifies an address

in the program memory

opcode K

0101113

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 these are accessed in assembler

Goto 6101 000 0000 0110

Binary forgoto

Binary for 6

Remember about registersGeneral registers 128 of them

Working or W register

Program counter or PC

0

127

Add 3 to W

Add literal instruction Value to add = 3

11 1110 0000 0011

Add register 33 to w

00 111 0 010 0001

Add regDestinationIs W

Register numberIs 33

W := W + Reg[33]

Add w to register 3300 111 1 010 0001

Add regDestinationIs reg 33

Register numberIs 33

Reg[33] := w + reg[33]

This is what Differs fromLast Instruction

Disadvantages of binary

Hard to remember Very hard to remember for complex

instructionsets Allows no variation in word lengths

between different processor models ( PICs come with 12, 14 and 16 bit instructions )

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

Assembler process

What assembler looks likestart clrw main movlw 0x35 movwf mulplr ; test 0x35 times 0x2D movlw 0x2D movwf 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 ;

A simple example

What we want to compute is

Y:= x+5

We must associate these variables x,y with registers.

We must select machine instructions that will perform the calculation

Assign variables X assume it is 8 bit

integer We will put it in

register 20h We will put Y in

register 21h

General registers

Specialregisters

0

20h

7f

Register bank

Analyse possible data flows

1. W := x2. W:=w+53. Y:=w

YES

1. W:=52. W:=w+x3. Y:=w

YES

W:=xY:=wY:=y+5

NO, cant add5 to y

MOVLW 5 ; w:=5

ADDWF 20h,0 ; w:= w + reg[20h]

MOVWF 21h ; y:=w

Y:=x+5

0 indicates w is dest

Outline the instructions

We will now look at the instructionset of the PIC processor.

There are 35 instructions

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

Addition of a constant

ADDLW const

Add const to w and store in w

If w=4 then

ADDLW 24h

Sets w to 28h

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 0100

ANDWF 20h,0

will set w to 0001 0100

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

Clear registers

Clrf f set reg[f] to zero• Eg CLRF 40 ; reg[40]:=0

Clrw set w register to zero

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

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

subtractions

This can be done by using complement or subtract operations, subtract is not strictly needed

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:=-yADDWF 32,1 ; x:=x+w

Suppose we want reg[32]:=reg[33]-reg[40]Initial values 10 7 4Binary 00001010 00000111 00000100Code Values manipulated

Comf 40, 0 ; 00000100 →11111011+1 →11111100 →w

Addwf 33,0 ; 00000111 11111100 +

→w

Movwf 32 ; → reg[32]

Complement continued

000000111

Carry bit

00000011

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:=-yAddwf 32,1 ; x:=x+w

MOVFW 33 ;w:=y

SUBWF 32,1;x:=x-w

Insteadof

Decrement register

Decf f, d

Decrements reg[f] and stores result in either reg[f] or w depending on d

DECF 50,1

Subtracts 1 from register 50

DECF 50,0

Sets w := reg[50] -1

Decrement and skip

DECFSZ f,dMeaning of f, and d fields as beforeIf 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 round loop

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]+1

if reg[50] is 0 then skip next instruction

Inclusive or

IORWF f,d

Example

If w=1100 0001 and reg[40]=0001 0001

IORWF 40,0

Will set w= 1101 0001 1100000100010001 or 11010001

Inclusive or Literal

IORLW const

Example

If w=1100 0001

IORLW 7

Will set w= 1100 0111 1100000100000111 or 11000111

Exclusive or

XORWF f,d

Example

If w=1100 0001 and reg[40]=0001 0001

XORWF 40,0

Will set w= 1101 0000 1100000100010001 xor 11010000

Exclusive or Literal

XORLW const

Example

If w=1100 0001

XORLW 7

Will set w= 1100 0110 1100000100000111 xor 11000110

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

Test instructions

BTFSC f,b ; bit test skip on clear

BTFSS f,b ; bit test skip on set

Eg

INCF 33

BTFSC 33,4

GOTO OVERFLOW ; goto overflow when

; reg 33 >7

GOTO

GOTO labelEg GOTO home….. home MOVLW 7….Transfers control to the label

CALL and RETURN

Thare used for subroutines or procedures.

CALL foo

….

foo ; start of procedure

…. ; body of procedure

RETURN; end of procedure

CALL continued

When a call occurs the PC+1 is pushed onto the stack and 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.

example call source

Init

call increment

goto Init

increment

incf CountL

return

labels

Example call and return

Address opcode assembler 5 2007 CALL 0x7 6 2805 GOTO 0x5

7 0AA2 INCF 0x22, F ; increment reg

0x22 8 0008 RETURN

at start we have

state of the stack

Next step

Address opcode assembler 5 2007 CALL 0x7 6 2805 GOTO 0x5

7 0AA2 INCF 0x22, F 8 0008 RETURN

stack holds addressto return to

just before return

after return

stack pointer is retracted