Академический Документы
Профессиональный Документы
Культура Документы
PIC microcontroller
From Wikipedia, the free encyclopedia
PIC is a family of modified Harvard architecture microcontrollers made by Microchip Technology, derived from the PIC1650[1][2][3] originally developed by General Instrument's Microelectronics Division. The name PIC initially referred to "Peripheral Interface Controller".[4][5] PICs are popular with both industrial developers and hobbyists alike due to their low cost, wide availability, large user base, extensive collection of application notes, availability of low cost or free development tools, and serial programming (and reprogramming with flash memory) capability. They are also commonly used in educational programming as they often come with the easy to use 'pic logicator' software.
PIC microcontrollers in DIP and QFN packages
Contents
1 History 2 Core architecture 2.1 Data space (RAM) 2.2 Code space 2.3 Word size 2.4 Stacks 2.5 Instruction set 2.6 Performance 2.7 Advantages 2.8 Limitations 2.9 Compiler development 3 Family core architectural differences 3.1 Baseline core devices (12 bit) 3.2 ELAN Microelectronics clones (13 bit) 3.3 Mid-range core devices (14 bit) 3.4 Enhanced mid-range core devices (14 bit) 3.5 PIC17 high end core devices (16 bit) 3.6 PIC18 high end core devices (16 bit) 3.7 PIC24 and dsPIC 16-bit microcontrollers 3.8 PIC32 32-bit microcontrollers 4 Device variants and hardware features 4.1 Variants 4.2 Trends 4.3 Part number suffixes 4.4 PIC clones 5 Development tools 6 Device programmers 6.1 PICKit 2 clones and open source 7 Debugging 7.1 Software emulation 7.2 In-circuit debugging 7.3 In-circuit emulators 8 See also
en.wikipedia.org/wiki/PIC_microcontroller
Die of a PIC12C508 8-bit, fully static, EEPROM/EPROM/ROM-based CMOS microcontroller manufactured by Microchip Technology using a 1200 nanometre process.
1/28
8/6/13
History
The original PIC was built to be used with General Instrument's new 16-bit CPU, the CP1600. While generally a good CPU, the CP1600 had poor I/O performance, and the 8-bit PIC was developed in 1975 to improve performance of the overall system by offloading I/O tasks from the CPU. The PIC used simple microcode stored in ROM to perform its tasks, and although the term was not used at the time, it shares some common features with RISC designs. In 1985, General Instrument spun off their microelectronics division and the new ownership cancelled almost everything which by this time was mostly out-of-date. The PIC, however, was upgraded with internal EPROM to produce a programmable channel controller and today a huge variety of PICs are available with various on-board peripherals (serial communication modules, UARTs, motor control kernels, etc.) and program memory from 256 words to 64k words and more (a "word" is one assembly language instruction, varying from 12, 14 or 16 bits depending on the specific PIC micro family). PIC and PICmicro are registered trademarks of Microchip Technology. It is generally thought that PIC stands for Peripheral Interface Controller, although General Instruments' original acronym for the initial PIC1640 and PIC1650 devices was "Programmable Interface Controller".[4] The acronym was quickly replaced with "Programmable Intelligent Computer".[5] The Microchip 16C84 (PIC16x84), introduced in 1993, was the first[citation needed ] Microchip CPU with on-chip EEPROM memory. This electrically erasable memory made it cost less than CPUs that required a quartz "erase window" for erasing EPROM.
Die of a PIC16C505 CMOS ROMbased 8-bit microcontroller manufactured by Microchip Technology using a 1200 nanometre process.
Core architecture
The PIC architecture is characterized by its multiple attributes: Separate code and data spaces (Harvard architecture). A small number of fixed length instructions Most instructions are single cycle execution (2 clock cycles, or 4 clock cycles in 8-bit models), with one delay cycle on branches and skips One accumulator (W0), the use of which (as source operand) is implied (i.e. is not encoded in the opcode) All RAM locations function as registers as both source and/or destination of math and other functions.[6] A hardware stack for storing return addresses A small amount of addressable data space (32, 128, or 256 bytes, depending on the family), extended through banking Data space mapped CPU, port, and peripheral registers ALU status flags are mapped into the data space The program counter is also mapped into the data space and writable (this is used to implement indirect jumps). There is no distinction between memory space and register space because the RAM serves the job of both memory and registers, and the RAM is usually just referred to as the register file or simply as the registers.
8/6/13
PICs have a set of registers that function as general purpose RAM. Special purpose control registers for on-chip hardware resources are also mapped into the data space. The addressability of memory varies depending on device series, and all PIC devices have some banking mechanism to extend addressing to additional memory. Later series of devices feature move instructions which can cover the whole addressable space, independent of the selected bank. In earlier devices, any register move had to be achieved via the accumulator. To implement indirect addressing, a "file select register" (FSR) and "indirect register" (INDF) are used. A register number is written to the FSR, after which reads from or writes to INDF will actually be to or from the register pointed to by FSR. Later devices extended this concept with post- and pre- increment/decrement for greater efficiency in accessing sequentially stored data. This also allows FSR to be treated almost like a stack pointer (SP). External data memory is not directly addressable except in some high pin count PIC18 devices.
Code space
The code space is generally implemented as ROM, EPROM or flash ROM. In general, external code memory is not directly addressable due to the lack of an external memory interface. The exceptions are PIC17 and select high pin count PIC18 devices.[7]
Word size
All PICs handle (and address) data in 8-bit chunks. However, the unit of addressability of the code space is not generally the same as the data space. For example, PICs in the baseline (PIC12) and mid-range (PIC16) families have program memory addressable in the same wordsize as the instruction width, i.e. 12 or 14 bits respectively. In contrast, in the PIC18 series, the program memory is addressed in 8-bit increments (bytes), which differs from the instruction width of 16 bits. In order to be clear, the program memory capacity is usually stated in number of (single word) instructions, rather than in bytes.
Stacks
PICs have a hardware call stack, which is used to save return addresses. The hardware stack is not software accessible on earlier devices, but this changed with the 18 series devices. Hardware support for a general purpose parameter stack was lacking in early series, but this greatly improved in the 18 series, making the 18 series architecture more friendly to high level language compilers.
Instruction set
A PIC's instructions vary from about 35 instructions for the low-end PICs to over 80 instructions for the high-end PICs. The instruction set includes instructions to perform a variety of operations on registers directly, the accumulator and a literal constant or the accumulator and a register, as well as for conditional execution, and program branching. Some operations, such as bit setting and testing, can be performed on any numbered register, but bi-operand arithmetic operations always involve W (the accumulator), writing the result back to either W or the other operand register. To load a constant, it is necessary to load it into W before it can be moved into another register. On the older cores, all register moves needed to pass through W, but this changed on the "high end" cores. PIC cores have skip instructions which are used for conditional execution and branching. The skip instructions are 'skip if bit set' and 'skip if bit not set'. Because cores before PIC18 had only unconditional branch instructions, conditional jumps are implemented by a conditional skip (with the opposite condition) followed by an unconditional branch. Skips are also of utility for conditional execution of any immediate single following instruction. It is possible to skip skip instructions. For example, the instruction sequence "skip if A; skip if B; C" will execute C if A is true or if B is false.
en.wikipedia.org/wiki/PIC_microcontroller
3/28
8/6/13
The 18 series implemented shadow registers which save several important registers during an interrupt, providing hardware support for automatically saving processor state when servicing interrupts. In general, PIC instructions fall into 5 classes: 1. Operation on working register (WREG) with 8-bit immediate ("literal") operand. E.g. m o v l w(move literal to WREG), a n d l w(AND literal with WREG). One instruction peculiar to the PIC is r e t l w , load immediate into WREG and return, which is used with computed branches to produce lookup tables. 2. Operation with WREG and indexed register. The result can be written to either the Working register (e.g. a d d w fr e g , w ). or the selected register (e.g. a d d w fr e g , f ). 3. Bit operations. These take a register number and a bit number, and perform one of 4 actions: set or clear a bit, and test and skip on set/clear. The latter are used to perform conditional branches. The usual ALU status flags are available in a numbered register so operations such as "branch on carry clear" are possible. 4. Control transfers. Other than the skip instructions previously mentioned, there are only two: g o t oand c a l l . 5. A few miscellaneous zero-operand instructions, such as return from subroutine, and s l e e pto enter low-power mode.
Performance
The architectural decisions are directed at the maximization of speed-to-cost ratio. The PIC architecture was among the first scalar CPU designs,[citation needed ] and is still among the simplest and cheapest. The Harvard architecturein which instructions and data come from separate sourcessimplifies timing and microcircuit design greatly, and this benefits clock speed, price, and power consumption. The PIC instruction set is suited to implementation of fast lookup tables in the program space. Such lookups take one instruction and two instruction cycles. Many functions can be modeled in this way. Optimization is facilitated by the relatively large program space of the PIC (e.g. 4096 14-bit words on the 16F690) and by the design of the instruction set, which allows for embedded constants. For example, a branch instruction's target may be indexed by W, and execute a "RETLW" which does as it is named return with literal in W. Interrupt latency is constant at three instruction cycles. External interrupts have to be synchronized with the four clock instruction cycle, otherwise there can be a one instruction cycle jitter. Internal interrupts are already synchronized. The constant interrupt latency allows PICs to achieve interrupt driven low jitter timing sequences. An example of this is a video sync pulse generator. This is no longer true in the newest PIC models, because they have a synchronous interrupt latency of three or four cycles.
Advantages
Small instruction set to learn RISC architecture Built in oscillator with selectable speeds Easy entry level, in circuit programming plus in circuit debugging PICKit units available for less than $50 Inexpensive microcontrollers Wide range of interfaces including IC, SPI, USB, USART, A/D, programmable comparators, PWM, LIN, CAN, PSP, and Ethernet[8] Availability of processors in DIL package make them easy to handle for hobby use.
Limitations
One accumulator Register-bank switching is required to access the entire RAM of many devices Operations and registers are not orthogonal; some instructions can address RAM and/or immediate constants, while others can only use the accumulator The following stack limitations have been addressed in the PIC18 series, but still apply to earlier cores:
en.wikipedia.org/wiki/PIC_microcontroller 4/28
8/6/13
The hardware call stack is not addressable, so preemptive task switching cannot be implemented Software-implemented stacks are not efficient, so it is difficult to generate reentrant code and support local variables With paged program memory, there are two page sizes to worry about: one for CALL and GOTO and another for computed GOTO (typically used for table lookups). For example, on PIC16, CALL and GOTO have 11 bits of addressing, so the page size is 2048 instruction words. For computed GOTOs, where you add to PCL, the page size is 256 instruction words. In both cases, the upper address bits are provided by the PCLATH register. This register must be changed every time control transfers between pages. PCLATH must also be preserved by any interrupt handler.[9]
Compiler development
While several commercial compilers are available, in 2008, Microchip released their own C compilers, C18 and C30, for the line of 18F 24F and 30/33F processors. The easy to learn RISC instruction set of the PIC assembly language code can make the overall flow difficult to comprehend. Judicious use of simple macros can increase the readability of PIC assembly language. For example, the original Parallax PIC assembler ("SPASM") has macros which hide W and make the PIC look like a two-address machine. It has macro instructions like "m o vb ,a " (move the data from address a to address b) and "a d db ,a " (add data from address a to data in address b). It also hides the skip instructions by providing three operand branch macro instructions such as "c j n ea ,b ,d e s t " (compare a with b and jump to dest if they are not equal).
8/6/13
11 10 9 8 7 6 5 4 3 2 1 0 Mnemonic C? Z? 0 0 0 0 0 0 0 opcode
Description Miscellaneous instructions No operation (MOVW 0,W) Copy W to OPTION register Go into standby mode Restart watchdog timer Copy W to tri-state register (f = 1, 2 or 3)
0 0 0 0 0 0 0 0 0 0 0 0 NOP 0 0 0 0 0 0 0 0 0 0 1 0 OPTION 0 0 0 0 0 0 0 0 0 0 1 1 SLEEP 0 0 0 0 0 0 0 0 0 1 0 0 CLRWDT 0 0 0 0 0 0 0 0 0 1 f 0 0 opcode d register f f f f f f f f f f f f f f f f register f f f f k k k k 8-bit immediate k k k IORLW k ANDLW k RETLW k CALL k GOTO k BCF f ,b BSF f ,b BTFSC f ,b BTFSS f ,b MOVWF f CLR f ,d DECF f ,d IORWF f ,d ANDWF f ,d XORWF f ,d MOVF f ,d COMF f ,d INCF f ,d DECFSZ f ,d RRF f ,d RLF f ,d SWAPF f ,d INCFSZ f ,d C C TRIS f
ALU operations: dest OP(f,W) dest W Z dest 0, usually written CLRW or CLRF f Z dest f1 Z dest f | W, logical inclusive or Z dest f & W, logical and Z dest f ^ W, logical exclusive or Z dest f Z dest ~f, bitwise complement Z dest f+1 dest f1, then skip if zero dest CARRY<<7 | f>>1, rotate right through carry dest F<<1 | CARRY, rotate left through carry dest f<<4 | f>>4, swap nibbles dest f+1, then skip if zero Bit operations Clear bit b of f Set bit b of f Skip if bit b of f is clear Skip if bit b of f is set Control transfers Set W k, then return from subroutine Call subroutine, 8-bit address k Jump to 9-bit address k[10] Operations with W and 8-bit literal: W OP(k,W) MOVLW k Wk Z W k | W, bitwise logical or Z W k & W, bitwise and
6/28
0 1 0 0 0 1 0 1 0 1 1 0 0 1 1 1 1 0 op
1 0 0 0 1 0 0 1 1 0 1 1 1 op
1 1 0 0 1 1 0 1 1 1 1 0
en.wikipedia.org/wiki/PIC_microcontroller
8/6/13
1 1 1 1
XORLW k
11 10 9 8 7 6 5 4 3 2 1 0 Mnemonic C? Z?
en.wikipedia.org/wiki/PIC_microcontroller
7/28
8/6/13
13-bit EM78 instruction set[12] 12 11 10 9 8 7 6 5 4 3 2 1 0 Mnemonic C? Z? 0 0 0 0 0 0 0 opcode C Description Miscellaneous instructions No operation (MOVW 0,W) Decimal Adjust after Addition Write CONT register (CONT W) Go into standby mode (WDT 0, stop clock) Restart watchdog timer (WDT 0) Copy W to I/O control register (f = 57, 1115) Enable interrupts Disable interrupts Return from subroutine, W unmodified Return from interrupt; return & enable interrupts Read CONT register (W CONT) Copy I/O control register to W (f = 57, 1115) C Z PCL += W. preserve PC bits 8 & 9 ALU operations same as 12- and 14-bit PIC Bit operations same as 12- and 14-bit PIC Control transfers same as 14-bit PIC Operations with W and 8-bit literal: W OP(k,W) MOV/IOR/AND/XOR, same as 12-bit PIC RETLW k SUBLW k INT k W k, then return from subroutine C Z W kW (W k+~W+1) Push PC, PC k (software interrupt, usually k=1)
0 0 0 0 0 0 0 0 0 0 0 0 0 NOP* 0 0 0 0 0 0 0 0 0 0 0 0 1 DAA 0 0 0 0 0 0 0 0 0 0 0 1 0 CONTW* 0 0 0 0 0 0 0 0 0 0 0 1 1 SLEEP* 0 0 0 0 0 0 0 0 0 0 1 0 0 CLRWDT* 0 0 0 0 0 0 0 0 0 f IOW f * 0 0 0 0 0 0 0 0 1 0 0 0 0 ENI 0 0 0 0 0 0 0 0 1 0 0 0 1 DISI 0 0 0 0 0 0 0 0 1 0 0 1 0 RET 0 0 0 0 0 0 0 0 1 0 0 1 1 RETI 0 0 0 0 0 0 0 0 1 0 1 0 0 CONTR 0 0 0 0 0 0 0 0 1 f IOR f 0 0 0 0 0 0 0 1 0 0 0 0 0 TBL 0 0 0 1 1 0 op 1 1 opcode op opcode op bit k 8-bit immediate k k k k k d register register
1 1 0
1 1 1 0 0 1 1 1 0 1 1 1 1 1 0 1 1 1 1 1
12 11 10 9 8 7 6 5 4 3 2 1 0 Mnemonic C? Z? *: Same opcode as 12-bit PIC : Instruction unique to EM78 instruction set with no PIC equivalent
Some models support multiple ROM or RAM banks, in a manner similar to other PIC microcontrollers.
en.wikipedia.org/wiki/PIC_microcontroller
8/28
8/6/13
The first 32 bytes of the register space are allocated to special-purpose registers; the remaining 96 bytes are used for generalpurpose RAM. If banked RAM is used, the high 16 registers (0x700x7F) are global, as are a few of the most important specialpurpose registers, including the STATUS register which holds the RAM bank select bits. (The other global registers are FSR and INDF, the low 8 bits of the program counter PCL, the PC high preload register PCLATH, and the master interrupt control register INTCON.) The PCLATH register supplies high-order instruction address bits when the 8 bits supplied by a write to the PCL register, or the 11 bits supplied by a G O T Oor C A L Linstruction, is not sufficient to address the available ROM space. 14-bit PIC instruction set 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Mnemonic C? Z? 0 0 0 0 0 0 0 opcode
Description
Miscellaneous instructions No operation (MOVW 0,W) Return from subroutine, W unmodified Return from interrupt Copy W to OPTION register Go into standby mode Restart watchdog timer Copy W to tri-state register (f = 1, 2 or 3) ALU operations: dest OP(f,W) MOVWF f CLR f ,d DECF f ,d IORWF f ,d ANDWF f ,d XORWF f ,d MOVF f ,d COMF f ,d INCF f ,d DECFSZ f ,d RRF f ,d RLF f ,d SWAPF f ,d INCFSZ f ,d C C f W Z dest 0, usually written CLRW or CLRF f Z dest f1 Z dest f | W, logical inclusive or Z dest f & W, logical and Z dest f ^ W, logical exclusive or Z dest f Z dest ~f, bitwise complement Z dest f+1 dest f1, then skip if zero dest CARRY<<7 | f>>1, rotate right through carry dest f<<1 | CARRY, rotate left through carry dest f<<4 | f>>4, swap nibbles dest f+1, then skip if zero Bit operations BCF f ,b BSF f ,b BTFSC f ,b Clear bit b of f Set bit b of f Skip if bit b of f is clear
9/28
0 0 0 0 0 0 0 0 0 0 0 0 0 0 NOP 0 0 0 0 0 0 0 0 0 0 1 0 0 0 RETURN 0 0 0 0 0 0 0 0 0 0 1 0 0 1 RETFIE 0 0 0 0 0 0 0 1 1 0 0 0 1 0 OPTION 0 0 0 0 0 0 0 1 1 0 0 0 1 1 SLEEP 0 0 0 0 0 0 0 1 1 0 0 1 0 0 CLRWDT 0 0 0 0 0 0 0 1 1 0 0 1 0 0 opcode d register f f f f f f f f f f f f f f f f register f f f f TRIS f
0 1 0 0 0 1 0 1 0 1 1 0
en.wikipedia.org/wiki/PIC_microcontroller
8/6/13
0 1 1 1 1 0 op 1 0 0 1 0 1 1 1 opcode
bit k k k
BTFSS f ,b
CALL k GOTO k
Call subroutine Jump to address k Operations with W and 8-bit literal: W OP(k,W)
8-bit immediate k k k k k k k k
1 1 0 0 x x 1 1 0 1 x x 1 1 1 0 0 0 1 1 1 0 0 1 1 1 1 0 1 0 1 1 1 0 1 1 1 1 1 1 0 x 1 1 1 1 1 x
Wk W k, then return from subroutine Z W k | W, bitwise logical or Z W k & W, bitwise and Z W k ^ W, bitwise exclusive or C Z W kW (dest k+~W+1) C Z W k+W Description
13 12 11 10 9 8 7 6 5 4 3 2 1 0 Mnemonic C? Z?
en.wikipedia.org/wiki/PIC_microcontroller
10/28
8/6/13
Miscellaneous instructions Software reset Push PC, then jump to PCLATH:W PC PC + W, relative jump using W Z Increment FSRn, then W INDFn Z Decrement FSRn, then W INDFn Z W INDFn, then increment FSRn Z W INDFn, then decrement FSRn INDFn W, same modes as MOVIW BSR k, move literal to bank select register ALU operations: dest OP(f,W) LSLF f ,d LSRF f ,d ASRF f ,d SUBWFB f ,d ADDWFC f ,d C Z dest f << 1, logical shift left C Z dest f >> 1, logical shift right C Z dest f >> 1, arithmetic shift right C Z dest f + ~W + C, subtract with carry C Z dest f + W + C, add with carry Operations with literal k
0 0 0 0 0 0 0 0 0 0 0 0 0 1 RESET 0 0 0 0 0 0 0 0 0 0 1 0 1 0 CALLW 0 0 0 0 0 0 0 0 0 0 1 0 1 1 BRW 0 0 0 0 0 0 0 0 0 1 0 n 0 0 MOVIW ++FSRn 0 0 0 0 0 0 0 0 0 1 0 n 0 1 MOVIW FSRn 0 0 0 0 0 0 0 0 0 1 0 n 1 0 MOVIW FSRn++ 0 0 0 0 0 0 0 0 0 1 0 n 1 1 MOVIW FSRn 0 0 0 0 0 0 0 0 0 1 1 n m 0 0 0 0 0 0 0 0 1 1 1 opcode d k register f f f f f k k k k k k ADDFSR FSRn,k MOVLP k BRA k MOVIW k [FSRn] MOVWI k [FSRn] Mnemonic C? Z? MOVWI using FSRn MOVLB k
1 1 0 1 0 1 d 1 1 0 1 1 0 d 1 1 0 1 1 1 d 1 1 1 0 1 1 d 1 1 1 1 0 1 d 1 1 opcode
1 1 0 0 0 1 0 n 1 1 0 0 0 1 1 1 1 0 0 1 1 1 1 1 1 1 0 n 1 1 1 1 1 1 1 n
FSRn FSRn + k, add 6-bit signed offset PCLATH k, move 7-bit literal to PC latch high PC PC + k, branch relative using 9-bit signed offset Z W [FSRn+k ], 6-bit signed offset [FSRn+k ] W, 6-bit signed offset Description
13 12 11 10 9 8 7 6 5 4 3 2 1 0
8/6/13
an 8-bit 8-bit hardware multiplier a second indirect register pair auto-increment/decrement addressing controlled by control bits in a status register (ALUSTA)
Miscellaneous instructions No operation Go into standby mode Restart watchdog timer Push PC on top of stack Pop (and discard) top of stack C Decimal adjust W
12/28
8/6/13
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 TBLRD* 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 TBLRD*+ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 TBLRD* 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 TBLRD+* 0 0 0 0 0 0 0 0 0 0 0 0 1 1 mod TBLWR 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 s RETFIE [, FAST] 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 s RETURN [, FAST] cleared MOVLB
Table read Table read with postincrement Table read with postdecrement Table read with pre-increment Table write, same modes as TBLRD Return from interrupt Return from subroutine Software reset Move literal k to bank select register ALU operations: dest OP(f,W)
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 RESET 0 0 0 0 0 0 0 1 0 0 0 0 0 opcode d a register f f f f f f f f f f f f f f f f f f f f f f register f f f CPFSLT f ,a CPFSEQ f ,a CPFSGT f ,a MULWF f ,a DECF f ,d,a IORWF f ,d,a ANDWF f ,d,a XORWF f ,d,a COMF f ,d,a ADDWFC f ,d,a ADDWF f ,d,a INCF f ,d,a DECFSZ f ,d,a RRCF f ,d,a RLCF f ,d,a SWAPF f ,d,a INCFSZ f ,d,a RRNCF f ,d,a RLNCF f ,d,a INFSNZ f ,d,a DCFSNZ f ,d,a MOVF f ,d,a SUBFWB f ,d,a SUBWFB f ,d,a SUBWF f ,d,a k
0 0 0 0 0 0 1 a 0 0 0 0 0 1 d a 0 0 0 1 0 0 d a 0 0 0 1 0 1 d a 0 0 0 1 1 0 d a 0 0 0 1 1 1 d a 0 0 1 0 0 0 d a 0 0 1 0 0 1 d a 0 0 0 0 1 0 d a 0 0 1 0 1 1 d a 0 0 1 1 0 0 d a 0 0 1 1 0 1 d a 0 0 1 1 1 0 d a 0 0 1 1 1 1 d a 0 1 0 0 0 0 d a 0 1 0 0 0 1 d a 0 1 0 0 1 0 d a 0 1 0 0 1 1 d a 0 1 0 1 0 0 d a 0 1 0 1 0 1 d a 0 1 0 1 1 0 d a 0 1 0 1 1 1 d a 0 1 1 0 opcode a
PRODH:PRODL W f (unsigned) C Z N dest f 1 Z N dest f | W, logical inclusive or Z N dest f & W, logical and Z N dest f ^ W, exclusive or Z N dest ~f, bitwise complement C Z N dest f + W + C C Z N dest f + W C Z N dest f + 1 dest f 1, skip if 0 C Z N dest f>>1 | C<<7, rotate right through carry dest f<<4 | f>>4, swap nibbles dest f + 1, skip if 0 Z N dest f>>1 | f<<7, rotate right (no carry) Z N dest f<<1 | f>>7, rotate left (no carry) dest f + 1, skip if not 0 dest f 1, skip if not 0 Z N dest f C Z N dest W + ~f + C (dest W f C ) C Z N dest f + ~W + C (dest f W C ) C Z N dest f W (dest f + ~W + 1) ALU operations, do not write to W skip if f < W skip if f == W skip if f > W
13/28
0 1 1 0 0 0 0 a 0 1 1 0 0 0 1 a 0 1 1 0 0 1 0 a
en.wikipedia.org/wiki/PIC_microcontroller
8/6/13
0 1 1 1 1 0 0 0 1 0 0 1 1 0 1 0 1 0 1 1 1 1 0 opc
BTG f ,b,a BSF f ,b,a BCF f ,b,a BTFSS f ,b,a BTFSC f ,b,a
Toggle bit b of f Set bit b of f Clear bit b of f Skip if bit b of f is set Skip if bit b of f is clear Large-address operations
1 1 0 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 0 0 cond
destination n n n n n n n n n n n
1 1 1 0 0 0 0 0 1 1 1 0 0 0 0 1 1 1 1 0 0 0 1 0 1 1 1 0 0 0 1 1 1 1 1 0 0 1 0 0 1 1 1 0 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 0 0 1 1 1 1 1 1 0 1 0 1 1 1 0 1 1 1 1 1 1 opc k (msbits)
Branch if PSR.Z is set Branch if PSR.Z is clear Branch if PSR.C is set Branch if PSR.C is clear Branch if PSR.V is set Branch if PSR.V is clear Branch if PSR.N is set Branch if PSR.N is clear (reserved)
1 1 1 0 1 1 0 s
1 1 1 0 1 1 1 0 0 0 f 1 1 1 1 0 0 0 0 1 1 1 0 1 1 1 1
k (lsbits) k (lsbits)
k (msbits)
1 1 1 1
GOTO k
Absolute jump, PC k
en.wikipedia.org/wiki/PIC_microcontroller
14/28
8/6/13
1 1 1 1
(No operation)
en.wikipedia.org/wiki/PIC_microcontroller
15/28
8/6/13
s operand ppp Reg 000 ssss 001 ssss 010 ssss 011 ssss 100 ssss 101 ssss 11k kkkk Syntax Ws [Ws]
PIC24 addressing modes d operand qqq Reg 000 dddd 001 dddd Syntax Wd [Wd]
Description
[Ws] 010 dddd [Wd] Indirect with postdecrement [Ws++] 011 dddd [Wd++] Indirect with postincrement [Ws] 100 dddd [Wd] Indirect with pretdecrement [++Ws] 101 dddd [++Wd] Indirect with preincrement #u5 (Unused, illegal) 5-bit unsigned immediate
11x ssss [Ws+Ww] 11x dddd [Wd+Ww] Indirect with register offset
The register offset addressing mode is only available to 2-operand instructions. 3-operand instructions use Ww as the second source operand, and use this encoding for an unsigned 5-bit immediate source. Note that the same Ww may be added to both Wd and Ws. A few instructions are 2 words long. The second word is a NOP, which includes up to 16 bits of additional immediate operand. PIC24 24-bit instruction set[17] 2 2 2 2 1 1 1 1 1 1 1 1 1 1 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 0 0 0 0 opcode 0 0 0 0 0 0 0 0 offset n NOP NOP NOP a a a Mnemonic C Z N ? ? ? Control transfers No operation (& 2nd instruction word) Second word of absolute branch (bits 22:16) Second word of DO instruction Computed control transfer (to 16-bit Wa) CALL Ra RCALL Ra Push PC, jump to Wa Push PC, jump to PC+2Wa Description
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 op 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 1 n 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0
GOTO Ra
Jump to Wa
0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0
en.wikipedia.org/wiki/PIC_microcontroller
0 n<15:1>
a 0 n<22:16> 0
BRA Ra
0 0 0 0 0 0 0 0 0 n
16/28
8/6/13
0 0 0 0 0 0 0 0 0 k 0 0 n k n k n n n B B B q q q k d d d
n<22:16> d
GOTO addr23 RETLW #k,Wd RETURN RETFIE RCALL address DO #k, addr REPEAT #k RCALL address (Reserved) BRA Oa, addr BRA Sa, addr
Jump to absolute address Wn[.B] = #u10, pop PC pop PC C Z N pop SR, PC Push PC, PC += 2*s16 Zero-overhead loop; k+1 is repeat count, PC+2n last instruction Repeat next instruction k+1 times Push PC, PC += 2*s16 If accumulator a overflowed, PC += 2*simm16 If accumulator a saturated, PC += 2*simm16
0 0 0 0 0 1 0 1 0 B 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 a 0 0 0 0 1 1 1 a 0 opcode 0 0 0 1 0 0 0 0 1 1 0 0 1 0 0 0 1 1 cond w w w
p p p
s s s d
ALU operations: Wd OP(Ww,Ws) SUBR[.B] Ww,Ws,Wd C Z N Wd Ws Ww (Wd Ws + ~Ww + 1) Wd Ws + ~Ww + C (Wd Ws Ww C ) Wd #imm16 Conditional branch to PC+2*n BRA OV,addr BRA C,addr BRA Z,addr BRA N,addr Branch if PSR.V is set Branch if PSR.C is set Branch if PSR.Z is set Branch if PSR.N is set
n n n n n n
0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 1 0 0 1 1 0 0 1 0 0 0 1 1 0 0 1 1
0 0 1 1 0 1 0 0
BRA LE,addr
en.wikipedia.org/wiki/PIC_microcontroller
17/28
8/6/13
0 0 1 1 0 1 0 1 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 1 0 0 1 1 1 0 0 0 0 0 1 1 1 0 0 1 0 0 1 1 1 0 1 0 0 0 1 1 1 0 1 1 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 1 0 0 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 opcode 0 1 0 0 0 0 1 0 0 1 0 1 0 1 0 0 1 0 1 1 0 1 1 0 0 0 1 1 0 1 0 1 1 1 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1 1 k k B B b b b b b k k w w w w w w w w w B B B B B B B B B q q q q q q q q q f f d d d d d d d d d d d
n n n n n n n n n n n p p p p p p p p p s s s s s s s s s d s k k p p p p p s s s s s s s
BRA LT,addr BRA LEU,addr BRA addr BRA NOV,addr BRA NC,addr BRA NZ,addr BRA NN,addr BRA GT,addr BRA GE,addr BRA GTU,addr (Reserved)
Branch if PSR.N PSR.V Branch if PSR.Z is set, or PSR.C is clear Branch unconditionally Branch if PSR.V is clear Branch if PSR.C is clear Branch if PSR.Z is clear Branch if PSR.N is clear Branch if PSR.Z is clear, and PSR.N = PSR.V Branch if PSR.N = PSR.V Branch if PSR.Z is clear, and PSR.C is set
ALU operations: Wd OP(Ww,Ws) ADD[.B] Ww,Ws,Wd SUB[.B] Ww,Ws,Wd SUBB[.B] Ww,Ws,Wd AND[.B] Ww,Ws,Wd XOR[.B] Ww,Ws,Wd IOR[.B] Ww,Ws,Wd MOV[.B] Ws,Wd MOV f,Wd MOV Ws,f MOV [Ws+s10],Wd MOV Ws,[Wd+s10] C Z N Wd Ww + Ws C Z N Wd Ww Ws C Z N Z N Z N Z N Z N Wd Ww + ~Ws + C (Wd Ww ~Ws C ) Wd Ww & Ws, logical and Wd Ww ^ Ws, exclusive or Wd Ww | Ws, inclusive or Wd Ws (offset mode allowed) Wd f f Ws Load with 10-bit signed offset Store with 10-bit signed offset ADDC[.B] Ww,Ws,Wd C Z N Wd Ww + Ws + C
1 0 1 0 0 opc 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 1 0 0 0 1 0 1 0 1 0 0 0 1 1
ZB 0 0 0 0 B 0 0 0 0 B 0 0 0 0 B 0 0 0 0 0 0 0 0
Bit operations on Ws BSET[.B] #b,Ws BCLR[.B] #b,Ws BTG[.B] #b,Ws BTST.C #b,Ws C Set bit b of Ws Clear bit b of Ws Toggle bit b of Ws Set PSR.C = bit b of Ws
18/28
en.wikipedia.org/wiki/PIC_microcontroller
8/6/13
1 0 1 0 0 0 1 1 1 0 1 0 0 1 0 0 1 0 1 0 0 1 0 1 Z 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 1 1 0 1 0 1 opc 1 0 1 0 1 0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 1 0 1 1 0 1 Z 1 0 1 0 1 1 1 0 1 0 1 0 1 1 1 1 1 0 1 1 0 0
b b w b b b b b b b b w b b
1 0 0 0 0 Z 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 f f f f f f 0 0 0 0 f f k k k k k k k k k f f
p p p p p
s s s s s
BTST.Z #b,Ws BTSTS.z #b,Ws BTST.z Ww,Ws BTSS #b,Ws BTSS #b,Ws
Z C/Z C/Z
Set PSR.Z to complement of bit b of Ws Bit test (into C or Z), then set Test bit (dynamic) Test bit b of Ws, skip if set Test bit b of Ws, skip if clear
Bit operations on f b BSET[.B] f, #b BCLR.B #b,f BTG.B #b,f BTST.B #b,f BTSTS.B #b,f p s BSW.z Ws,Ww BTSS #b,f BTSC #b,f d d d d d d d d d Z Z Set bit b of f Clear bit b of f Toggle bit b of f Test bit b of f Test bit b of f, then set Copy PSW bit to bit Ww of Wb Test bit b of f, skip if set Test bit b of f, skip if clear Register-immediate operations ADD[.B] #u10,Wd ADC[.B] #u10,Wd SUB[.B] #u10,Wd SUBB[.B] #u10,Wd AND[.B] #u10,Wd XOR[.B] #u10,Wd IOR[.B] #u10,Wd MOV[.B] #u10,Wd C N Z Wd Wd + imm10 C N Z Wd Wd + imm10 + C C N Z Wd Wd imm10 C N Z Wd Wd imm10 C N Z Wd Wd & imm10 N Z Wd Wd ^ imm10 N Z Wd Wd | imm10 Wd imm10
opc B
1 0 1 1 0 0 0 0 0 B 1 0 1 1 0 0 0 0 1 B 1 0 1 1 0 0 0 1 0 B 1 0 1 1 0 0 0 1 1 B 1 0 1 1 0 0 1 0 0 B 1 0 1 1 0 0 1 0 1 B 1 0 1 1 0 0 1 1 0 B 1 0 1 1 0 0 1 1 1 B 1 0 1 1 0 1 opc B D
1 0 1 1 0 1 0 0 0 B D
ADD[.B] f[,WREG]
C N Z dest f + W0
1 0 1 1 0 1 0 0 1 B D 1 0 1 1 0 1 0 1 0 B D
en.wikipedia.org/wiki/PIC_microcontroller
f f
C N Z dest f + W0 + C C N Z dest f W0
19/28
8/6/13
1 0 1 1 0 1 0 1 1 B D 1 0 1 1 0 1 1 0 0 B D 1 0 1 1 0 1 1 0 1 B D 1 0 1 1 0 1 1 1 0 B D 1 0 1 1 0 1 1 1 1 B 1 1 0 1 1 1 0 0 op 1 0 1 1 1 0 0 0 0 1 0 1 1 1 0 0 0 1 1 0 1 1 1 0 0 1 0 w w w w d d d d 0 0 0 0
f f f f f p p p p s s s s
SUBB[.B] f[,WREG] AND[.B] f[,WREG] XOR[.B] f[,WREG] IOR[.B] f[,WREG] MOV[.B] WREG,f
161632 multiplication MUL.UU Ww,Ws,Wd MUL.US Ww,Ws,Wd MUL.SU Ww,Ws,Wd Wd+1:Wd Wb * Ws (unsigned) Wd+1:Wd Wb * Ws (Ws signed) Wd+1:Wd Wb * Ws (Wb signed) Wd+1:Wd Wb * Ws (signed)
1 0 1 1 1 0 0 1 1 1 0 1 1 1 0 1 op 1 0 1 1 1 0 1 0 0 B
w w qqq
d d d
p p p
s s s
MUL.SS Ww,Ws,Wd
Program memory access TBLRDL [Ws],Wd Wd PROGRAM[TBLPAG:Ws] (bits 15:0) Wd PROGRAM[TBLPAG:Ws] (bit 23:16) PROGRAM[TBLPAG:Wd] Ws (bits 15:0) PROGRAM[TBLPAG:Wd] Ws (bit 23:16) W3:W2 f * W0 (unsigned) Move register pair (source may be memory) Move register pair (dest may be memory)
1 0 1 1 1 0 1 0 1 B 1 0 1 1 1 0 1 1 0 B 1 0 1 1 1 0 1 1 1 B
d d d f
p p p
s s s
p 000 s
j p p p p s s s s
DSP MAC (dsPIC only) Other DSP instructions (dsPIC only) Find first one from right (lsb) Find first one from left (msb) Shift/rotate W register SL[.B] Ws,Wd C N Z Wd Ws << 1, shift left (into carry)
20/28
1 1 0 1 0 0 0 0 0 B
en.wikipedia.org/wiki/PIC_microcontroller
8/6/13
1 1 0 1 0 0 0 1 0 B 1 1 0 1 0 0 0 1 1 B 1 1 0 1 0 0 1 0 0 B 1 1 0 1 0 0 1 0 1 B 1 1 0 1 0 0 1 1 0 B 1 1 0 1 0 0 1 1 1 B 1 1 0 1 0 1 opc B D
q q q q q q
d d d d d d f f f f f f f f v v
p p p p p p
s s s s s s
LSR[.B] Ws,Wd ASR[.B] Ws,Wd RLNC[.B] Ws,Wd RLC[.B] Ws,Wd RRNC[.B] Ws,Wd RRC[.B] Ws,Wd
C N Z C N Z N Z C N Z
Wd Ws >> 1, logical shift right Wd Ws >> 1, arithmetic shift right Wd Ws <<< 1, rotate left (no carry) C:Wd Ws:C << 1, rotate left through carry
Wd Ws >>> 1, rotate N Z right (no carry) C N Z Wd:C C:Ws >> 1, rotate right through carry dest f << 1, shift left (into carry) dest f >> 1, logical shift right dest f >> 1, arithmetic shift right dest f <<< 1, rotate left (no carry) C:dest f:C << 1, rotate left through carry dest f >>> 1, rotate right (no carry) dest:C C:f >> 1, rotate right through carry
Shift/rotate f SL[.B] f[,WREG] LSR[.B] f[,WREG] ASR[.B] f[,WREG] RLNC[.B] f[,WREG] RLC[.B] f[,WREG] RRNC[.B] f[,WREG] RRC[.B] f[,WREG] s s C N Z C N Z C N Z N Z C N Z N Z C N Z
1 1 0 1 0 1 0 0 0 B D 1 1 0 1 0 1 0 1 0 B D 1 1 0 1 0 1 0 1 1 B D 1 1 0 1 0 1 1 0 0 B D 1 1 0 1 0 1 1 0 1 B D 1 1 0 1 0 1 1 1 0 B D 1 1 0 1 0 1 1 1 1 B D 1 1 0 1 1 0 0 0 U 1 1 0 1 1 0 0 0 0 t 0000
W0 0 0 0 0
32/16 and 16/16 divide steps (prefix with REPEAT #17) DIV.S Wv,Ws C N Z Divide step, W0 Wv/Ws, W1 remainder
1 1 0 1 1 0 0 0 0 1 1 0 1 1 0 0 0 1 1 1 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 1 0 1
t 0000 t t
v v v
1 0 0 0 0 0 1 0 0
s s s s
0 0 0 0 0 0 0
en.wikipedia.org/wiki/PIC_microcontroller
21/28
8/6/13
1 1 0 1 1 1 0 0 1 1 0 1 1 1 0 0 0 1 1 0 1 1 1 0 0 0 1 1 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 1 1 1 0 1 1 1 1 0 1 w w w w w w d d d d d d
0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 s k s k s k
(Reserved) SL Ww,Ws,Wd SL Ww,#u4,Wd LSR Ww,Ws,Wd LSR Ww,#u4,Wd ASR Ww,Ws,Wd ASR Wv,#u4,Wd N Z Wd Wv << Ws N Z Wd Wv << imm4 N Z N Z N Z Wd Wv>> Ws, logical shift right Wd Wv>> imm4, logical shift right Wd Wv>> Ws, arithmetic shift right
Wd Wv>> imm4, N Z arithmetic shift right C Find permissible arithmetic normalization shift
1 1 0 1 1 1 1 1 0 1 1 1 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 1 1 1 0 0 0 0 1 1
0000 0000 w w
d B 0 0 0 B 0 0 0 B 0 0 0 f f f
p p p p
s s s s
FBCL Ws,Wd CP0[.B] Ws CP[.B] Ww,Ws CPB[.B] Ww,Ws CP0[.B] Ws CP[.B] f CPB[.B] f (Reserved)
Compare with borrow, Wb C N Z + ~Ws + C (Wb Ws C ) C N Z Compare with zero, f 0 C N Z Compare f, f W0 C N Z Compare f with borrow, f + ~W0 + C (f W0 C )
1 1 1 0 0 0 1 0 0 B 0 1 1 1 0 0 0 1 1 0 B 0 1 1 1 0 0 0 1 1 1 B 0 1 1 1 0 0 1 0 w 1 1 1 0 0 1 1 0 0
s B 0 0 0 0 0 0 CPSGT[.B] Ww,Ws
Compare and skip if greater than (Wb > Ws, signed) Compare and skip if less than (Wb < Ws, signed) Compare and skip if not equal (Wb Ws) Compare and skip if equal (Wb = Ws) C N Z Wd Ws+1 C N Z Wd Ws+2 C N Z Wd Ws1 C N Z Wd Ws2 C N Z Wd ~Ws+1 N Z Wd ~Ws Wd 0
22/28
1 1 1 0 0 1 1 0 1 1 1 1 0 0 1 1 1 0 1 1 1 0 0 1 1 1 1 1 1 1 0 1 0 0 0 0 B 1 1 1 0 1 0 0 0 1 B 1 1 1 0 1 0 0 1 0 B 1 1 1 0 1 0 0 1 1 B 1 1 1 0 1 0 1 0 0 B 1 1 1 0 1 0 1 0 1 B 1 1 1 0 1 0 1 1 0 B
w w w q q q q q q q
B 0 0 0 0 0 0 B 0 0 0 0 0 0 B 0 0 0 0 0 0 d d d d d d d p p p p p p 000
s s s s s s s s s 0000
CPSLT[.B] Ww,Ws CPSNE[.B] Ww,Ws CPSNE[.B] Ww,Ws INC[.B] Ws,Wd INC2[.B] Ws,Wd DEC[.B] Ws,Wd DEC2[.B] Ws,Wd NEG[.B] Ws,Wd COM[.B] Ws,Wd CLR[.B] Wd
en.wikipedia.org/wiki/PIC_microcontroller
8/6/13
1 1 1 0 1 0 1 1 1 B 1 1 1 0 1 1 0 0 0 B D 1 1 1 0 1 1 0 0 1 B D 1 1 1 0 1 1 0 1 0 B D 1 1 1 0 1 1 0 1 1 B D 1 1 1 0 1 1 1 0 0 B D 1 1 1 0 1 1 1 0 1 B D 1 1 1 0 1 1 1 1 0 B D 1 1 1 0 1 1 1 1 1 B D 1 1 1 1 0 0 m A 1 1 1 1 1 0 1 1 1 1 1 1 0 0 0 1 1 1 1 1 0 0 1 1 1 1 1 1 0 1 0 0 0 1 1 1 1 1 0 1 0 1 0 1 1 1 1 1 0 1 1 0 0 1 1 1 1 1 0 1 1 1 0 x
d f f f f f f f f y f f k i
000
0000
SETM[.B] Wd INC[.B] f[,WREG] INC2[.B] f[,WREG] DEC[.B] f[,WREG] DEC[.B] f[,WREG] NEG[.B] f[,WREG] COM[.B] f[,WREG] CLR[.B] f[,WREG] SETM[.B] f[,WREG]
Wd ~0 C N Z dest f+1 C N Z dest f+2 C N Z dest f1 C N Z dest f2 C N Z dest ~f+1 N Z dest ~f dest 0 dest ~0
opc
Push f on top of stack Pop f from top of stack Push W14, W14 W15, W15 += u14 W15 W14, pop W14 Wd sign_extend(Ws), copy bit 7 to bits 15:8 Wd zero_extend(Ws), clear bits 15:8
0 000 000 d d
1 1 1 1 1 1 0 0 0 0
DISI #u14
1 1 1 1 1 1 0 1 0 0 1 1 1 1 1 1 0 1 0 1 1 1 1 1 1 1 0 1 1 B 1 1 1 1 1 1 1 0 0 0
d 0000 0000
s s s
EXCH Ws,Wd DAW.B Ws SWAP[.B] Ws RESET k PWRSAV #u1 CLRWDT POP.S PUSH.S (Reserved) NOPR C
Swap contents of registers Ws, Wd Decimal adjust based on C, DC Swap halves of Ws Software reset Go into sleep or idle mode Clear watchdog timer Pop shadow registers (W0 3, part of PSR) Push shadow registers (W03, part of PSR) No operation (version #2)
23/28
0 0 0 0 0
1 1 1 1 1 1 1 0 0 1 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 0 1 0 0 1 1 1 1 1 1 1 0 1 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1
en.wikipedia.org/wiki/PIC_microcontroller
8/6/13
Variants
Within a series, there are still many device variants depending on what hardware resources the chip features. General purpose I/O pins. Internal clock oscillators. 8/16/32 Bit Timers. Internal EEPROM Memory. Synchronous/Asynchronous Serial Interface USART. MSSP Peripheral for IC and SPI Communications. Capture/Compare and PWM modules. Analog-to-digital converters (up to ~1.0 MHz). USB, Ethernet, CAN interfacing support. External memory interface. Integrated analog RF front ends (PIC16F639, and rfPIC). KEELOQ Rolling code encryption peripheral (encode/decode) And many more.
Trends
The first generation of PICs with EPROM storage are almost completely replaced by chips with Flash memory. Likewise, the original 12-bit instruction set of the PIC1650 and its direct descendants has been superseded by 14-bit and 16-bit instruction sets. Microchip still sells OTP (one-time-programmable) and windowed (UV-erasable) versions of some of its EPROM based
en.wikipedia.org/wiki/PIC_microcontroller 24/28
8/6/13
PICs for legacy support or volume orders. The Microchip website lists PICs that are not electrically erasable as OTP. UV erasable windowed versions of these chips can be ordered.
PIC clones
Third party manufacturers make compatible products, for example the Parallax SX.
Development tools
Microchip provides a freeware IDE package called MPLAB, which includes an assembler, linker, software simulator, and debugger. They also sell C compilers for the PIC18 and dsPIC which integrate cleanly with MPLAB. Free student versions of the C compilers are also available with all features. But for the free versions, optimizations will be disabled after 60 days.[21] Several third parties make C language compilers for PICs, many of which integrate to MPLAB and/or feature their own IDE. A fully featured compiler for the PICBASIC language to program PIC microcontrollers is available from meLabs, Inc. Mikroelektronika offers PIC compilers in C, Basic and Pascal programming languages. A graphical programming language, Flowcode, exists capable of programming 8 and 16 bit PIC devices and generating PIC compatible C code. It exists in numerous versions from a free demonstration to a more complete professional edition. The only opensource compiler for the PIC16 and PIC18 family is the SDCC. It make use of GPutils for linker and assembler tools. A plugin is needded to install them in MPLAB or MPLABX.[22] Development tools are available for the PIC family under the GPL or other free software or open source licenses.
Device programmers
Main article: PICKit Devices called "programmers" are traditionally used to get program code into the target PIC. Most PICs that Microchip currently sell feature ICSP (In Circuit Serial Programming) and/or LVP (Low Voltage Programming) capabilities, allowing the PIC to be programmed while it is sitting in the target circuit. ICSP programming is performed using two pins, clock and data, while a high voltage (12V) is present on the Vpp/MCLR pin. Low voltage programming dispenses with the high voltage, but reserves exclusive use of an I/O pin and can therefore be disabled to recover the pin for other uses (once disabled it can only be re-enabled using high voltage programming). There are many programmers for PIC microcontrollers, ranging from the extremely simple designs which rely on ICSP to allow direct download of code from a host computer, to intelligent programmers that can verify the device at several supply voltages. Many of these complex programmers use a pre-programmed PIC themselves to send the programming commands to the PIC that is to be programmed. The intelligent type of programmer is needed to program earlier PIC models (mostly EPROM type) which do not support in-circuit programming.
en.wikipedia.org/wiki/PIC_microcontroller 25/28
8/6/13
Many of the higher end flash based PICs can also self-program (write to their own program memory). Demo boards are available with a small bootloader factory programmed that can be used to load user programs over an interface such as RS-232 or USB, thus obviating the need for a programmer device. Alternatively there is bootloader firmware available that the user can load onto the PIC using ICSP. The advantages of a bootloader over ICSP is the far superior programming speeds, immediate program execution following programming, and the ability to both debug and program using the same cable. Programmers/debuggers are available directly from Microchip. Third party programmers range from plans to build your own, to self-assembly kits and fully tested ready-to-go units. Some are simple designs which require a PC to do the low-level programming signalling (these typically connect to the serial or parallel port and consist of a few simple components), while others have the programming logic built into them (these typically use a serial or USB connection, are usually faster, and are often built using PICs themselves for control). The following are the official PICkit programmer/debuggers from Microchip:
Microchip PICkit1
Microchip PICkit2
Microchip PICkit3
Debugging
en.wikipedia.org/wiki/PIC_microcontroller 26/28
8/6/13
Software emulation
Commercial and free emulators exist for the PIC family processors.
In-circuit debugging
Later model PICs feature an ICD (in-circuit debugging) interface, built into the CPU core. ICD debuggers (MPLAB ICD2 and other third party) can communicate with this interface using three lines. This cheap and simple debugging system comes at a price however, namely limited breakpoint count (1 on older pics 3 on newer PICs), loss of some IO (with the exception of some surface mount 44-pin PICs which have dedicated lines for debugging) and loss of some features of the chip. For small PICs, where the loss of IO caused by this method would be unacceptable, special headers are made which are fitted with PICs that have extra pins specifically for debugging.
In-circuit emulators
Microchip offers three full in-circuit emulators: the MPLAB ICE2000 (parallel interface, a USB converter is available); the newer MPLAB ICE4000 (USB 2.0 connection); and most recently, the REAL ICE. All of these ICE tools can be used with the MPLAB IDE for full source-level debugging of code running on the target. The ICE2000 requires emulator modules, and the test hardware must provide a socket which can take either an emulator module, or a production device. The REAL ICE connects directly to production devices which support in-circuit emulation through the PGC/PGD programming interface, or through a high speed connection which uses two more pins. According to Microchip, it supports "most" flash-based PIC, PIC24, and dsPIC processors.[23] The ICE4000 is no longer directly advertised on Microchip's website, and the purchasing page states that it is not recommended for new designs.
See also
PIC16x84 Atmel AVR Arduino BASIC Atom BASIC Stamp OOPic PICAXE TI MSP430 Maximite
References
1. ^ http://ww1.microchip.com/downloads/en/DeviceDoc/39630C.pdf 2. ^ http://www.datasheetarchive.com/dl/Databooks-1/Book241-407.pdf 3. ^ "PICmicro Family Tree", PIC16F Seminar Presentation http://www.microchip.com.tw/PDF/2004_spring/PIC16F%20seminar%20presentation.pdf 4. ^ a b "MOS DATA 1976", General Instrument 1976 Databook 5. ^ a b "1977 Data Catalog", Micro Electronics from General Instrument Corporation http://www.rhoent.com/pic16xx.pdf 6. ^ http://ww1.microchip.com/downloads/en/DeviceDoc/35007b.pdf 7. ^ "AN869: External Memory Interfacing Techniques for the PIC18F8XXX" (http://ww1.microchip.com/downloads/en/AppNotes/00869b.pdf). Retrieved 24 August 2009.
en.wikipedia.org/wiki/PIC_microcontroller 27/28