Published on

  • Be the first to comment

  • Be the first to like this

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide


  1. 1. BAHÇEŞEHİR UNIVERSITY INTERNSHIP TUTORIAL Programming PIC MCUs with PIC BASIC PRO Compiler PIC Microcontrollers Currently, the best choice for application development, using PIC BASIC PRO are microcontrollers from the family : PIC16F87x, PIC16F62X and of course the famous PIC16F84. With this family of PIC microcontrollers, program memory is created using FLASH technology which provides fast erasing and reprogramming, thus allowing faster debugging. By a single mouse click in the programming software, microcontroller program can be instantly erased and then reloaded without removing chip from device. Also, program loaded in FLASH memory can be stored after power supply has been turned off. The older PIC microcontroller series (12C67x, 14C000, 16C55x, 16C6xx, 16C7xx and 16C92x) have program memory created using EPROM/ROM technology, so they can either be programmed only once (OTP version with ROM memory) or have glass window (JW version with EPROM memory), which allows erasing by few minutes exposure to UV light. OTP versions are usually cheaper and are used for manufacturing large series of products. Besides FLASH memory, microcontrollers of PIC16F87x and PIC16F84 series also contain 64-256 bytes of internal EEPROM memory, which can be used for storing program data and other parameters when power is off. PIC BASIC PRO has built-in READ and WRITE instructions that can be used for loading and saving data to EEPROM. Brief Introduction to PIC16F84 MCU The PIC 16F84 microcontroller is shown in Figure 1 It is a versatile microcontroller with flash memory. Flash memory is the terminology used to describe “rewriteable” memory. The 1K x 14bit onboard flash memory can endure a minimum of 1000 erase/write cycles. Figure 1: PIC16F84 Pin Diagram General features: RISC CPU 35 singleword instructions; operating speed dc, 10MHz clock input; 1K program memory; 14bitwide instructions; 8bitwide data path; direct, indirect, and relative addressing; 1000 erase/write cycles. Peripheral features: 13 I/O pins with individual direction control; highcurrent sink/source for direct LED drive (25mA sink max. per pin, 20mA source max. per pin); TMRO—8bit timer/counter with 8bit programmable prescaler.
  2. 2. So you can reprogram and reuse the PIC chip at least 1000 times. The program retention time between erase/write cycles is approximately 40 years. The 18pin chip devotes 13 pins to I/O. Each pin may be programmed individually for input or output. The pin status (I/O direction control) may be changed on the fly via programming. Other features include power on reset, power saving sleep mode, power up timer, and code protection. Additional features and architectural details of the PIC 16F84 will be given as we continue. Figure 2: PIC16F84 Features RA0-RA3 and RB0-RB7 pins are I/O (input/output) ports. You can access MCU by sending digital signals to these ports and MCU process that commands then it sends digital signals from I/O ports. PIC 16F84 is produced with CMOS Technology (complementary metal-oxide-semiconductor). CMOS chips include microprocessor, microcontroller, static RAM, and other digital logic circuits. The central characteristic of the technology is that it only uses significant power when its transistors are switching between on and off states. Consequently, CMOS devices use little power and do not produce as much heat as other forms of logic. CMOS also allows a high density of logic functions on a chip. Pin Descriptions PIC16F84 has a 13 I/O ports. 5 of the I/O ports are RA0 to RA5 and 8 of them are RB0 to RB7. You can use these 13 ports input or output. It has a special TRIS register is used for ports I/O directions. You can find pin descriptions in Figure 3.
  3. 3. Figure 3: PIC16F84 Pin Descriptions Memory Organization There are two memory blocks in the PIC16F8X. These are the program memory and the data memory. Each block has its own bus, so that access to each block can occur during the same oscillator cycle. The data memory can further be broken down into the general purpose RAM and the Special Function Registers (SFRs). The SFRs used to control the peripheral modules. The data memory area also contains the data EEPROM memory. Program Memory Organization PIC16F84 has 1 Kbytes program memory. Memory cells are between 000h and 3FFF. In each of the cell, 14 bit program instructions are stored. Program memory has a Flash technology so it can be erased or written electrically but while program is working it can just read. Program memory in a PIC is actually 14 bits wide even though PICs are considered 8-bit microcontrollers. The 8-bit terminology comes from the data memory buss, which is 8 bits wide.
  4. 4. Figure 3: PIC16F84 Program Memory Organization Data Memory Organization Data memory is where all your variables are stored. This is RAM (Random Access Memory), which means when the PIC is disconnected from power all the data memory is lost. The data memory is 8 bits wide, which is why the PICs are considered 8-bit microcontrollers. The PIC data memory is also banked just like the program memory. The first section of data memory is reserved for special function registers. These registers are the key locations that control most of functions within the PIC. Some of the registers are located in Bank 0 while some are located in Bank 1. Some are even repeated so they are available in both banks. To select which bank to control, a bit is set or cleared in the STATUS register. Because you need access to the STATUS register from both banks, it is located in both banks. Figure 4 shows PIC16F84’s data memory organization and register file map.
  5. 5. Figure 4: PIC16F84 Register File Map
  6. 6. PIC Programming Overview Programming PIC microcontrollers is a simple three step process: Write the code, compile the code, and upload the code into a microcontroller. The PicBasic Pro compiler both function is, saved program code (text file) is run through a PicBasic Pro compiler. The compiler reads through the text file and creates (compiles) an equivalent machine code instruction listing (.hex file) of the program. The machine code (.hex file) is a list of hexadecimal numbers that represent the PicBasic Pro program. The list of hexadecimal numbers (.hex file) is uploaded (programmed) into the microcontroller. When the microcontroller is started, its CPU will run through the programmed list of hexadecimal numbers, running the PicBasic Pro program. Uploading the machine code (.hex file) into the microcontroller is the job of the Programmer board and software. The PicBasic Pro version offers enhanced and richer basic command syntax. The compiler program may be run manually in DOS or in an “MSDOS Prompt” window but I offer Microchip’s MPLAB IDE program in my graduation project I used Pic Basic Pro and MPLAB together. Figure 5: PIC programming overview. The PicBasic Pro Compiler Micro Engineering Lab’s Pic Basic Pro Compiler gives us powerful and flexible features. You can write your PIC code very fast instead of assembly programming. Additionally, that is easy to learn PBP’s commands and properties because it is very similar to basic programming language if you are familiar with high level language programming, especially basic programming you can learn PBP in a short time period. The PicBasic Pro Compiler makes it even quicker and easier for you to program Microchip Technology’s powerful PICmicro microcontrollers (MCUs). The English-like BASIC language is much easier to read and write than the quirky Microchip assembly language. Decisions were made that we hope improve the language overall. One of these was to add a real IF..THEN..ELSE..ENDIF instead of the IF..THEN(GOTO).
  7. 7. Here is a list of the current PBPro commands: @: Insert one line of assembly language code. ASM..ENDASM: Insert assembly language code section. ADCIN: Read on-chip analog to digital converter. BRANCH: Computed GOTO (equivalent to ON..GOTO). BRANCHL: BRANCH out of page (long BRANCH). BUTTON: Debounce and auto-repeat input on specified pin. CALL: Call assembly language subroutine. CLEAR: Zero all variables. CLEARWDT: Clear Watchdog Timer. COUNT: Count number of pulses on a pin. DATA: Define initial contents of on-chip EEPROM. DEBUG: Asynchronous serial output to fixed pin and baud. DEBUGIN: Asynchronous serial input from fixed pin and baud. DISABLE: Disable ON INTERRUPT processing. DISABLE DEBUG: Disable ON DEBUG processing. DISABLE INTERRUPT: Disable ON INTERRUPT processing. DTMFOUT: Produce touch-tones on a pin. EEPROM: Define initial contents of on-chip EEPROM. ENABLE: Enable ON INTERRUPT processing. ENABLE DEBUG: Enable ON DEBUG processing. ENABLE INTERRUPT: Enable ON INTERRUPT processing. END: Stop execution and enter low power mode. FOR..NEXT: Repeatedly execute statements. FREQOUT: Produce up to 2 frequencies on a pin. GOSUB: Call BASIC subroutine at specified label. GOTO: Continue execution at specified label. HIGH: Make pin output high. HSERIN: Hardware asynchronous serial input. HSEROUT: Hardware asynchronous serial output. I2CREAD: Read bytes from I2C device. I2CWRITE: Write bytes to I2C device. IF..THEN..ELSE..ENDIF: Conditionally execute statements. INPUT: Make pin an input. {LET}: Assign result of an expression to a variable. LCDIN: Read RAM on LCD. LCDOUT: Display characters on LCD. LOOKDOWN: Search constant table for value. LOOKDOWN2: Search constant/variable table for value. LOOKUP: Fetch constant value from table. LOOKUP2: Fetch constant/variable value from table. LOW: Make pin output low. NAP: Power down processor for short period of time. ON INTERRUPT: Execute BASIC subroutine on an interrupt. OUTPUT: Make pin an output. PAUSE: Delay (1 millisecond (msec) resolution). PAUSEUS: Delay (1 microsecond (_sec) resolution). PEEK: Read byte from register. POKE: Write byte to register. POT: Read potentiometer on specified pin. PULSIN: Measure pulse width on a pin.
  8. 8. PULSOUT: Generate pulse to a pin. PWM: Output pulse width modulated pulse train to pin. RANDOM: Generate pseudo-random number. RCTIME: Measure pulse width on a pin. READ: Read byte from on-chip EEPROM. READCODE: Read word from code memory. RESUME: Continue execution after interrupt handling. RETURN: Continue execution at statement following last executed GOSUB. REVERSE: Make output pin an input or an input pin an output. SERIN: Asynchronous serial input (8N1) (BS1 style with timeout.) SERIN2: Asynchronous serial input (BS2 style.) SEROUT: Asynchronous serial output (8N1) (BS1 style.) SEROUT2: Asynchronous serial output (BS2 style.) SHIFTIN: Synchronous serial input. SHIFTOUT: Synchronous serial output. SLEEP: Power down processor for a period of time. SOUND: Generate tone or white noise on specified pin. STOP: Stop program execution. SWAP: Exchange the values of two variables. TOGGLE: Make pin output and toggle state. WHILE..WEND: Execute code while condition is true. WRITE: Write byte to on-chip EEPROM. WRITECODE: Write word to code memory. XIN: X-10 input. XOUT: X-10 output. Note: In PicBasic Pro Compiler Manual, you can find extensive information about PicBasic Pro, Microchips MPLAB IDE What is MPLAB IDE? MPLAB Integrated Development Environment (IDE) is a free, integrated toolset for the development of embedded applications employing Microchip's PICmicro® and dsPIC® microcontrollers. MPLAB IDE runs as a 32-bit application on MS Windows®, is easy to use and includes a host of free software components for fast application development and super-charged debugging. MPLAB IDE also serves as a single, unified graphical user interface for additional Microchip and third party software and hardware development tools. You can use PicBasic Pro compiler with MPLAB IDE.
  9. 9. Figure 6: MPLAB user interface Using MPLAB IDE with PicBasic Pro Compiler I will explain to setting up MPLAB and PBP step by step, please follow up these steps respectively. 1) First, Install MPLAB and its components. Please use default directory. In the following examples, the default installation directory (C:Program FilesMicrochip...) will be used. 2) Install the PICBASIC or PICBASIC PRO Compiler. Please just copy and paste PBP folder into your dirve C. Some versions will have problems if installed in C:Program FilesPBP. In the following examples, we assume that PICBASIC PRO has been installed in C:PBP. 3) In "C:PBP", run the file "PBregister.bat" (Start - Run - C:PBPPBregister.bat). Restart MPLAB for the changes to take effect. (Note: In C:PBP folder there are two PBP plug-in, if you run "PBregister.bat", these plug-ins will be activated.) 4) For Windows 2000/XP; The path (C:PBP;C:Program FilesMicrochipMPASM Suite) statement is found in the Environment Variables dialog box. 1- To get there, right-click the My Computer icon on your desktop and select Properties. 2- Click the Advanced tab, then the button labeled Environment Variables....
  10. 10. 3- Find the Path variable in the System Variables window, highlight the line, and click Edit. 4- Add the paths to MPLAB and PICBASIC PRO to the end of the line in the Variable Values text box, separating each path with a semicolon. For example path statement is: %SystemRoot%System32;C:PBP;C:Program FilesMicrochipMPASM Suite 5- If necessary, restart your computer after making changes to the path variable. 6- After, all steps just run P245A1.EXE Selecting PICBASIC as the language tool within MPLAB Start MPLAB and select Set Language Tool Locations under the Project menu. Select the appropriate Toolsuite Name (PICBASIC or PICBASIC PRO Compiler). Use the browse button to select PBC.EXE or PBPW.EXE within the subdirectory where it was installed.
  11. 11. Creating a BASIC project within MPLAB Run the Project Wizard to create a project in MPLAB. Select the desired processor. Select appropriate microEngineering Labs, Inc. Tool Suite. Name the project. Choose the directory where the source file exists. Add the source file to the project.
  12. 12. Click Next, then Finish. You should be able to edit the source and build the project. Sample PicBasic Pro programs 1) Blinking a Led Task: Connect a led to PIC16F84’s port B (any of the pin you can select). You will try to accomplish blinking your led (turn on, then turn off, then turn on….). Your pause time will be 1sec. Program your MCU with PBP. After all steps will be done, your led must blink. Schematic:
  13. 13. PBP Program: '----------------------Simple Blinking Program--------------------- OUTPUT PORTB.7 ' Our output is Led. (or you can write like this --> "TRISB.7 = 0") Loop: ' Generally all PBP programs started with a loop. HIGH PORTB.7 ' We make portb's 7. pin high, so portb's 7. pin's voltage level is 5V. PAUSE 1000 ' Wait 1000ms (1 sec) LOW PORTB.7 ' We make portb's 7. pin low, so portb's 7. pin's voltage level is 0V. PAUSE 1000 ' Wait 1000ms (1 sec) GOTO Loop ' Go to loop and do it forever. END ' End of our blinking program. (-: I think our first program is so easy.
  14. 14. 2) Led Show Task: Connect leds to PIC16F84’s port Bs all ports. Initially our leds are off state then firstly, turn on the leds from right to left respectively then turn on the leds left to right respectively after that turn on two middle leds, then turn on the leds from inside to outside, then turn on them outside to inside. For transitions, turn on the all leds 3 seconds. Schematic:
  15. 15. PBP Program: '------------------------------LED SHOW---------------------------- TRISB = %00000000 ' Make Port B all pins output PORTB = 0 ' Make Port B all pins 0 Volt Left_Counter VAR BYTE Right_Counter VAR BYTE Middle_Counter VAR BYTE Left_Counter = 0 ' Left_Counter holds how many times left transitions occured. Right_Counter = 0 ' Right_Counter holds how many times right transitions occured. Middle_Counter = 0 ' Right_Counter holds how many times middle transitions occured. loop: ' Main Subroutine left: ' Left transition subroutine PORTB = %00000001 ' Initially Port B's first pin voltage is 5 Volt and led that connected this pin turns on. leftcontinue: ' Inner left transition Subroutine PAUSE 300 ' Wait 300 ms PORTB=PORTB<<1 ' LEFT SHIFTING IF PORTB = %10000000 THEN PORTB = %00000001 ' Initial State for left transition Left_Counter = Left_Counter + 1 ' Increase left transition counter IF Left_Counter = 3 THEN PORTB = %11111111 ' Turn on port B's all leds. PAUSE 3000 ' Wait 3 seconds. GOTO right ' Go to right subroutine ENDIF ENDIF GOTO leftcontinue ' Go to left continue subroutine right: ' Right transition subroutine PORTB = %10000000 ' Initially Port B's last pin voltage is 5 Volt and led that connected this pin turns on. rightcontinue: ' Inner right transition Subroutine PAUSE 300 ' Wait 300 ms PORTB=PORTB>>1 ' RIGHT SHIFTING IF PORTB = %00000001 THEN PORTB = %10000000 ' Initial State for right transition Right_Counter = Right_Counter + 1 ' Increase right transition counter IF Right_Counter = 3 THEN PORTB = %11111111 ' Turn on port B's all leds. PAUSE 3000 ' Wait 3 seconds. GOTO middle ' Go to middle subroutine ENDIF ENDIF GOTO rightcontinue ' Go to right continue subroutine
  16. 16. middle: ' Right transition subroutine PORTB = %00011000 ' Port B's middle 4. and 5. pins are turns on. PAUSE 300 ' Wait 300 ms PORTB = %00100100 ' Port B's middle 3. and 6. pins are turns on. PAUSE 300 ' Wait 300 ms PORTB = %01000010 ' Port B's middle 2. and 7. pins are turns on. PAUSE 300 ' Wait 300 ms PORTB = %10000001 ' Port B's middle 1. and 8. pins are turns on. PAUSE 300 ' Wait 300 ms PORTB = %01000010 ' Port B's middle 2. and 7. pins are turns on. PAUSE 300 ' Wait 300 ms PORTB = %00100100 ' Port B's middle 3. and 6. pins are turns on. PAUSE 300 ' Wait 300 ms PORTB = %00011000 ' Port B's middle 4. and 5. pins are turns on. PAUSE 300 ' Wait 300 ms IF PORTB = %00011000 THEN Middle_Counter = Middle_Counter + 1 ' Increase middle transition counter IF Middle_Counter=3 THEN PORTB = %11111111 ' Turn on port B's all leds. PAUSE 3000 ' Wait 3 seconds. GOTO left ' Go to left subroutine ENDIF ENDIF GOTO middle ' Go to middle continue subroutine END ' End of program.
  17. 17. 2) Generating Sound Task: Buttons are connected to pins RA0, RA1 and RA2. Pressing any of these executes part of the code for generating impulse sequence on RA3 pin, which can be heard as different sounds or a melody on buzzer. Use FOR NEXT loop for generating different sounds. In the following program, pressing buttons T0, T1 and T2 generate different sounds on a buzzer.
  18. 18. PBP Program: '-------------------------------SOUND PROGRAM---------------------------- INPUT PORTA.0 'Set PORTA pin 0 to an input. For button T0.(or -> TRISA.0 = 1) INPUT PORTA.1 'Set PORTA pin 1 to an input. For button T1.(or -> TRISA.1 = 1) INPUT PORTA.2 'Set PORTA pin 2 to an input. For button T2.(or -> TRISA.2 = 1) OUTPUT PORTA.3 'Set PORTA pin 3 to an output. For BUZZER.(or -> TRISA.2 = 1) counter VAR BYTE ' Counter for different sounds. 'Or you can define I/O port like this; TRISA = %00000111 which means first three pins are inputs. loop: 'Our main loop 'For Button T0 IF PORTA.0 = 0 THEN ' If button T0 is pressed then generate different sounds. Counter increment rate is 1. FOR counter=10 to 130 SOUND PORTA.3, [counter,10,60,10] ' Generate Sound NEXT counter ENDIF 'For Button T1 IF PORTA.1 = 0 THEN ' If button T1 is pressed then generate different sounds. Counter increment rate is 10. FOR counter=10 to 130 STEP 10 SOUND PORTA.3, [counter,10,60,10] ' Generate Sound NEXT counter ENDIF 'For Button T2 IF PORTA.2 = 0 THEN ' If button T2 is pressed then generate different sounds. Counter increment rate is 20. FOR counter=10 to 130 STEP 20 SOUND PORTA.3, [counter,10,60,10] ' Generate Sound NEXT counter ENDIF GOTO loop ' Do it forever END ' End of our program.