1 / 85

PIC - 2

PIC - 2. How to pick your PIC. Overview of a PIC Project. 1. Think carefully about what you really want to do. 2. Select which PIC you’re going to use. 3. Read the data sheet! 4. Use the editor in MPLAB to write the code. 5. Use the MPLAB assembler (MPASM) to assemble the code.

bona
Download Presentation

PIC - 2

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. PIC - 2 How to pick your PIC

  2. Overview of a PIC Project 1. Think carefully about what you really want to do. 2. Select which PIC you’re going to use. 3. Read the data sheet! 4. Use the editor in MPLAB to write the code. 5. Use the MPLAB assembler (MPASM) to assemble the code. 6. Fix the billions of assembly errors. 7. Simulate your code in the MPLAB PIC simulator (MPSIM). 8. Fix more errors (usually logical and initialization errors). 9. Load the program on your PIC with the programmer. 10. Test the PIC in circuit. Attempt to identify bugs. 11. Fix the errors (usually timing, interrupt and peripheral errors) and re-test. 12. Brag to your friends about how you’re on the cutting edge of embedded control. (Yellow Letters = what we’ll talk about today)

  3. PIC Architecture: Background Microprocessor: • Requires ‘external’ support hardware • E.g., External RAM, ROM, Peripherals. Microcontroller: • Very little external support hardware. • Most RAM, ROM and peripherals on chip. • “Computer on a chip”, or “System on chip” (SOC) • E.g., PIC = Peripheral Interface Controller

  4. Memory (Program & Data) CPU 8 PIC Architecture: Background We’re used to the Von-Neuman Architecture • Used in: 80X86 (PCs), 8051, 68HC11, etc.) • Only one bus between CPU and memory • RAM and program memory share the same bus and the same memory, and so must have the same bit width • Bottleneck: Getting instructions interferes with accessing RAM

  5. Memory (Program) Memory (Data) CPU 8 12 14 16 PIC Architecture: Background PICs use the Harvard Architecture • Used mostly in RISC CPUs (we’ll get there) • Separate program bus and data bus: can be different widths! • For example, PICs use: • Data memory (RAM): a small number of 8bit registers • Program memory (ROM): 12bit, 14bit or 16bit wide (in EPROM, FLASH, or ROM)

  6. MC68HC05: LDAA 0x55 1000 1100 2 bytes, 2 cycles 01010101 PIC Architecture: Background Traditionally, CPUs are “CISC” • Complex Instruction Set Computer (CISC) • Used in: 80X86, 8051, 68HC11, etc. • Many instructions (usually > 100) • Many, many addressing modes • Usually takes more than 1 internal clock cycle (Tcyc) to execute • Example:

  7. 1100XX 01010101 PIC16CXXX: MOVLW 0x55 1 word, 1 cycle PIC Architecture: Background PICs and most Harvard chips are “RISC” • Reduced Instruction Set Computer (RISC) • Used in: SPARC, ALPHA, Atmel AVR, etc. • Few instructions (usually < 50) • Only a few addressing modes • Executes 1 instruction in 1 internal clock cycle (Tcyc) • Example:

  8. PIC Architecture: Convergence Many Microcontrollers and DSP chips are “converging” • Heading towards some mean between RISC and CISC • Large CPUs (DSPs) are adding microcontroller like options(the 32bit, 100MHz StrongARM draws only 70mA) • Small microcontrollers are getting more powerful, now able to do some DSP • General trend: Smaller packages, less power consumption, faster • Future possibility: “Sea of gates” reconfigurable processor

  9. Example PIC: 12C508 Block Diagram

  10. The PIC Family: Cores PICs come with 1 of 4 CPU ‘cores’: • 12bit cores with 33 instructions: 12C50x, 16C5x • 14bit cores with 35 instructions: 12C67x,16Cxxx • 16bit cores with 58 instructions: 17C4x,17C7xx • ‘Enhanced’ 16bit cores with 77 instructions: 18Cxxx

  11. The PIC Family: Packages PICs come in a huge variety of packages: 8 pin DIPs, SOICs: 12C50x (12bit) and 12C67x (14bit) 18pin DIPs, SOICs: 16C5X (12bit), 16Cxxx (14bit) 28pin DIPs, SOICs: 16C5X (12bit), 16Cxxx (14bit) 40pin DIPs, SOICs: 16Cxxx (14bit), 17C4x (16bit) 44 - 68pin PLCCs*: 16Cxxx (14bit), 17C4x / 17Cxxx (16bit) * also TQFPs, etc.

  12. The PIC Family: Speed PICs require a clock to work. • Can use crystals, clock oscillators, or even an RC circuit. • Some PICs have a built in 4MHz RC clock • Not very accurate, but requires no external components! • Instruction speed = 1/4 clock speed (Tcyc = 4 * Tclk) • All PICs can be run from DC to their maximum spec’d speed: 12C50x 4MHz 12C67x 10MHz 16Cxxx 20MHz 17C4x / 17C7xxx 33MHz 18Cxxx 40MHz

  13. The PIC Family: Program Memory PIC program space is different for each chip. Some examples are: 12C508 512 12bit instructions 16C71C 1024 (1k) 14bit instructions 16F877 8192 (8k) 14bit instructions 17C766 16384 (16k) 16bit instructions

  14. The PIC Family: Program Memory PICs have two different types of program storage: 1. EPROM (Erasable Programmable Read Only Memory) • Needs high voltage from a programmer to program (~13V) • Needs windowed chips and UV light to erase • Note: One Time Programmable (OTP) chips are EPROM chips,but with no window! • PIC Examples: Any ‘C’ part: 12C50x, 17C7xx, etc.

  15. The PIC Family: Program Memory PICs have two different types of program storage: 2. FLASH • Re-writable (even by chip itself) • Much faster to develop on! • Finite number of writes (~100k Writes) • PIC Examples: Any ‘F’ part: 16F84, 16F87x, 18Fxxx (future)

  16. The PIC Family: Data Memory PICs use general purpose “file registers” for RAM (each register is 8bits for all PICs) Some examples are: 12C508 25 Bytes RAM 16C71C 36 Bytes RAM 16F877 368 Bytes (plus 256 Bytes of nonvolatile EEPROM) 17C766 902 Bytes RAM • Don’t forget, programs are stored in program space (not in data space), so low RAM values are OK.

  17. The PIC Family: Control Registers PICs use a series of “special function registers” for controlling peripherals and PIC behaviors. Some examples are: STATUS Bank select bits, ALU bits (zero, borrow, carry) INTCON Interrupt control: interrupt enables, flags, etc. TRIS Tristate control for digital I/O: which pins are ‘floating’ TXREG UART transmit register: the next byte to transmit

  18. The PIC Family: Peripherals Different PICs have different on-board peripherals Some common peripherals are: • Tri-state (“floatable”) digital I/O pins • Analog to Digital Converters (ADC) (8, 10 and 12bit, 50ksps) • Serial communications: UART (RS-232C), SPI, I2C, CAN • Pulse Width Modulation (PWM) (10bit) • Timers and counters (8 and 16bit) • Watchdog timers, Brown out detect, LCD drivers

  19. PIC Peripherals: Ports (Digital I/O) • All PICs have digital I/O pins, called ‘Ports’ • the 8pin 12C508 has 1 Port with 4 digital I/O pins • the 68pin 17C766 has 9 Ports with 66 digital I/O pins • Ports have 2 control registers • TRISx sets whether each pin is an input or output • PORTx sets their output bit levels • Most pins have 25mA source/sink (directly drives LEDs) • WARNING: Other peripherals SHARE pins!

  20. PIC Peripherals: ADCs • Only available in 14bit and 16bit cores • Fs (sample rate) < 54KHz • Most 8bits, newer PICs have 10 or 12bits • All are +/- 1LSB and are monotonic • Theoretically higher accuracy when PIC is in sleep mode (less digital noise) • Can generate an interrupt on ADC conversion done • Multiplexed 3 (12C671) - 12 (17C7xxx) channel input • Must wait Tacq to charge up sampling capacitor(see datasheets)

  21. PIC Peripherals: USART: UART • Serial Communications Peripheral: Universal Synchronous/Asynchronous Receiver/Transmitter • Only available in 14bit and 16bit cores • Interrupt on TX buffer empty and RX buffer full • Asynchronous communication: UART (RS-232C serial) • Can do 300bps - 115kbps • 8 or 9 bits, parity, start and stop bits, etc. • Outputs 5V so you need a RS232 level converter (e.g., MAX232)

  22. PIC Peripherals: USART: USRT • Synchronous communication: i.e., with clock signal • SPI = Serial Peripheral Interface • 3 wire: Data in, Data out, Clock • Master/Slave (can have multiple masters) • Very high speed (1.6Mbps) • Full speed simultaneous send and receive (Full duplex) • I2C = Inter IC • 2 wire: Data and Clock • Master/Slave (Single master only; multiple masters clumsy) • Lots of cheap I2C chips available; typically < 100kbps(For example, 8pin EEPROM chips, ADC, DACs, etc.)

  23. PIC Peripherals: Timers • Available in all PICs. • 14+bit cores may generate interrupts on timer overflow. • Some 8bits, some 16bits, some have prescalers • Can use external pins as clock in/clock out(ie, for counting events or using a different Fosc) • Warning: some peripherals share Timer resources

  24. PIC Peripherals: CCP Modules • Capture/Compare/PWM (CCP) • 10bit PWM width within 8bit PWM period (frequency) • Enhanced 16bit cores have better bit widths • Frequency/Duty cycle resolution tradeoff • 19.5KHz has 10bit resolution • 40KHz has 8bit resolution • 1MHz has 1bit resolution (makes a 1MHz clock!) • Can use PWM to do DAC - See AN655 • Capture counts external pin changes • Compare will interrupt on when the timer equals the value in a compare register

  25. PIC Peripherals: Misc. • Sleep Mode: PIC shuts down until external interrupt (or internal timer) wakes it up. • Interrupt on pin change: Generate an interrupt when a digital input pin changes state (for example, interrupt on keypress). • Watchdog timer: Resets chip if not cleared before overflow • Brown out detect: Resets chip at a known voltage level • LCD drivers: Drives simple LCD displays • Future: CAN bus, 12bit ADC, better analog functions • VIRTUAL PERIPHERALS: • Peripherals programmed in software. UARTS, timers, and more can be done in software (but it takes most of the resources of the machine)

  26. Selecting your PIC • See Microchip Line card for the entire list of PICs : http://www.microchip.com/10/Lit/rLit/00148d1/index.htm • See the Digikey catalog for pricing information. http://www.digikey.com

  27. Low End: 12C508 • 8pin package (DIP, SO) • 12bit core - 33 instructions • 1us instruction time (Tclk = 4MHz) • 512 12bit program memory • 25 8bit data memory or registers (“File registers”) • 2 level hardware stack (no interrupts) • 5 GPIO pins, 1 input only (25mA source/sink) • Features: Internal pullups, wake up on pin change, internal oscillator • Peripherals: Timer, Watch Dog Timer • $1.88(1), $1.25(100), $9.65(W)

  28. Mid Range: 16F876 • 28pin package (DIP, SO) • 14bit core - 35 instructions • 200ns instruction time (Tclk = 20MHz) • 8,092 14bit FLASHprogram memory • 368 8bit data memory or registers (“File registers”) • 256 8bit EEPROM (nonvolatile) data registers • 8 level hardware stack (interrupts enabled) • 22 GPIO (20mA source / 25mA 7sink) • Peripherals: 5ch 10bit ADC, USART/I2C/SPI, 16bit & 8bit timers • Features: Brown out detect, In-Circuit Debugger (ICD) • $11.00(1), $5.89(100)

  29. High End: 17C766 • 84pin PLCC package • 16bit core - 58 instructions • 121ns instruction time (Tclk = 33MHz) • 16,384 16bit program memory • 902 8bit data memory or registers • 16 level hardware stack (priority interrupts) • 66 GPIO (20mA source / 35mA sink) • Features: 8x8 multiply, BOD, microprocessor mode • Peripherals: • 2x 16bit + 2x 8bit timer, WDT, 2x USART, 4x CCP, • 12ch 10bit ADC, • $20.25(1), $10.53(100), $18.38(W)

  30. 12C508, 16F876, 17C766 Uses • 12C508 • Inexpensive controllers, glue logic, simple tasks • E.g., quadrature decoding, digital interfacing • 16F876 • Multitasking programs, serial communication • E.g., Cheap data acquisition system and digital I/O system for PC off COM ports, data logging • 17C766 • RTOS, low end DSP, communications, big moosey applications • E.g., FEC converter, Rocket Flight Computer, cheap FFT chip

  31. For Comparison: The 68HC11 • 48pin DIP, 52pin PLCC packages • 145 instructions & 6 addressing modes • 333ns instruction time (Tclk = 12MHz) • 12k 8bit ROM or EPROM program memory • 512 8bit general RAM memory • 512 8bit EEPROM • Software stack (uses general RAM) • 16 I/O, 11 inputs, 11 outputs • Peripherals: • USART, SPI, 8ch 8bit ADC, 4x 16bit capture timers, 4x PWM, Pulse accumulator, WDT, 16bit GP clock • ~$7.00(1), ?(100), ?(W)

  32. Getting ready to code! • ALWAYS have the data sheet for your PIC: http://www.microchip.com/There are just too many details you have to know! • Example: See PIC12C508 data sheet

  33. PART II Writing PIC Code

  34. Software: Introduction • In this course, we’ll only talk about PIC assembly language as used in the MPLAB assembler. • MPLAB is FREE (score): see http://www.microchip.com/ • Assembly is a bit harder to code, but faster and more compact. • BASIC and C compilers exist but are spendy. • Easier to use for mathematically intensive programs(E.g., floating point, really complicated logic) • Small, simple programs may be better done in assembly. • Excursion: Brief introduction to MPLAB

  35. Software: Instruction Set • Let’s see what makes PICs tick!See handout: “PIC 16CXX Instruction Set Summary” • Program counter increments once each Tcyc to “grab” the next instruction • Remember, instructions are stored in program memory and are completely separate from RAM (“File registers”).

  36. Hardware Stack Stores addresses for subroutines <- 12/14/16 bits -> Program Memory “Burned” in by programmer (can’t change during execution). Stored instructions, addresses and “literals” (numbers). (PCH) Program Counter-PCL <- 8 bits -> Status Special Purpose Registers I/O pin states, peripheral registers, etc. W “Register” General Purpose Registers RAM or “data memory”. Variables are stored here. Software: Programmers Model

  37. Software: Instruction Examples movlw 0xFF Move (“mov”) the number (“l” for “literal”) 0xFF - that’s 256 in decimal- into the working register (“w”). In other words, load W with the value 0xFF.

  38. Hardware Stack <- 12/14/16 -> Program Memory (PCH) Program Counter-PCL <- 8 bits -> Status Special Purpose Registers W “Register” General Purpose Registers Software: Programmers Model 0xFF

  39. Software: Instruction Examples movwf PORTA Move (“mov”) the working register (“w”) into the file register (“f”) named PORTA. In other words, load the register called PORTA with whatever number is in the W register.

  40. Hardware Stack <- 12/14/16 -> Program Memory (PCH) Program Counter-PCL <- 8 bits -> Status Special Purpose Registers PORTA W “Register” General Purpose Registers Software: Programmers Model Value in W

  41. Software: Instruction Examples movf PORTA, W Move (“mov”) the the value of the file register (“f”) named PORTA into the working register (“w”) . In other words, load W with the whatever number is in PORTA.

  42. Hardware Stack <- 12/14/16 -> Program Memory (PCH) Program Counter-PCL <- 8 bits -> Status Special Purpose Registers PORTA W “Register” General Purpose Registers Software: Programmers Model Value in PORTA

  43. Software: Assembly Format • First column: Labels • Second column: opcodes and assembler directives • Third Columns & more: operands ; This is a comments since it starts with a “;” ; This program puts out a square wave on PORTA Pin 0 clrf PORTA ; Clear PORTA register clrf TRISA ; Make PORTA all outputs Loop bsf PORTA,0 ; Turn on PORTA Pin 0 nop ; Match ‘goto’ delay nop ; “ “ “ bcf PORTA,0 ; Turn off PORTA Pin 0 goto Loop ; If not zero, loop back

  44. Software: Branches • All branches are “Bit Tests” • All branches only skip one instruction ; Set EqualFlag if PORTA = PORTB bcf EqualFlag, 7 ; First, clear the flag movf PORTA, W ; Move PORTA -> W subwf PORTB, W ; W - PORTB -> W btfsc STATUS, Z ; Check Z bit (see STATUS) bsf EqualFlag, 7 ; Ports equal; set flag

  45. STATUS Register

  46. Software: Direct Addressing • All file registers (RAM) are accessed by an address. This is called direct addressing. • For example,movlw 0xFF movwf 0x06loads W with FF, and then loads W into GPIO (address 0x06). • Thankfully, we can use labels instead of addresses: GPIO equ 0x06 movwf GPIO

  47. Software: Relative Addressing • PCL = Low byte of the Program Counter • Can be read and written. • Writing to it sets the address of the next instruction to be executed. 14bit core 12bit core

  48. Software: Relative Addressing • Example of Relative Addressing (using a table): • ; Here’s a simple lookup table which is called as a • ; subroutine. Expects the table offset to be loaded in W. • ; An example call looks like this: • ; movlw 0x04 ; Load W with 4 • ; call Table ; Call the table subroutine • ; movwf Result ; Store the result from the table • Table addwf PCL, W ; Jump to (current PCL) + W • retlw 0x00 ; Return with 0x00 in W • retlw 0x23 ; Return with 0x23 in W • retlw 0x33 ; etc. • retlw 0x88

  49. Software: Indirect Addressing • Load indirect address into FSR • Reading/Writing to INDF acts on address stored in FSR • Example code to clear 0x20 - 7F: movlw 0x20 movwf FSR loop clrf INDF incf FSR,F btfss FSR,7 goto loop INDF 00h FSR 04h 7Fh Register File

  50. Software:Banking RAM in the PICs is banked, especially special function registers. Use the bank select commands to choose the bank. Either: bsf STATUS, RP0 bcf STATUS, RPO Or use the assembler directive: Banksel <registername>

More Related