1. Instruction formats for the PIC series

2. 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.

3. byte oriented register ops when d=0 destination = W reg d=1 destination = reg[f] f= 7 bit register selector opcodedf ( reg num ) 067813

4. Bit oriented operations b = 3bit number identifying a bit in an 8 bit register f = 7 bit number identifying one of 128 possible registers opcodebf 0 1310 9 7 6

5. Literal ops These generally operate on the w register The second operand is a value specified in the instruction W:= w op k opcodeK=Literal value 0 7 8 13

6. Control transfer Used for call or goto K is a 11 bit literal that specifies an address in the program memory opcodeK 0 10 11 13

7. 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 6 101 000 0000 0110 Binary for goto Binary for 6

8. Remember about registers General registers 128 of them Working or W register Program counter or PC 0 127

9. Add 3 to W Add literal instruction Value to add = 3 11 11100000 0011

10. Add register 33 to w 00 1110010 0001 Add reg Destination Is W Register number Is 33 W := W + Reg[33]

11. Add w to register 33 00 1111010 0001 Add reg Destination Is reg 33 Register number Is 33 Reg[33] := w + reg[33] This is what Differs from Last Instruction

12. 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 )

13. 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. Assembler process

15. What assembler looks like start 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 ;

16. 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

17. 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 Special registers 0 20h 7f Register bank

18. 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. MOVLW 5 ; w:=5 ADDWF 20h,0 ; w:= w + reg[20h] MOVWF 21h ; y:=w Y:=x+5 0 indicates w is dest

20. Outline the instructions We will now look at the instructionset of the PIC processor. There are 35 instructions

21. 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. 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. 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

24. 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. Clear registers Clrf f set reg[f] to zero Eg CLRF 40 ; reg[40]:=0 Clrw set w register to zero

26. 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. NOP NOP stands for NO oPeration It is an opcode that does nothing Its binary pattern is 0000000000 This is similar to MOVWF whose pattern is 000001FFFF Destination bit Destination register Destination=w

28. subtractions This can be done by using complement or subtract operations, subtract is not strictly needed COMF f,d This 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 by COMF 33,0 ; w:=-y ADDWF 32,1 ; x:=x+w

29. Suppose we want reg[32]:=reg[33]-reg[40] Initial values 10 7 4 Binary 00001010 00000111 00000100 Code 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

30. 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. 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

32. Decrement and skip DECFSZ f,d Meaning of f, and d fields as before If the result of decrementing is zero, skip the next instruction Top: ;some instructions DECFSZ 38,1 GOTO Top ; some other instructions Reg[38] holds the number of times to go round loop

33. 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

34. Inclusive or IORWF f,d Example If w=1100 0001 and reg[40]=0001 0001 IORWF 40,0 Will set w= 1101 0001 11000001 00010001 or 11010001

35. Inclusive or Literal IORLW const Example If w=1100 0001 IORLW 7 Will set w= 1100 0111 11000001 00000111 or 11000111

36. Exclusive or XORWF f,d Example If w=1100 0001 and reg[40]=0001 0001 XORWF 40,0 Will set w= 1101 0000 11000001 00010001 xor 11010000

37. Exclusive or Literal XORLW const Example If w=1100 0001 XORLW 7 Will set w= 1100 0110 11000001 00000111 xor 11000110

38. 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. 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

40. GOTO GOTO label Eg GOTO home ….. home MOVLW 7 …. Transfers control to the label

41. CALL and RETURN Thare used for subroutines or procedures. CALL foo …. foo ; start of procedure …. ; body of procedure RETURN; end of procedure

42. 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.

43. example call source Init call increment goto Init increment incf CountL return labels

44. 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

45. 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. just before return

47. after return stack pointer is retracted