The LAB-XUSB Experimenter board (see Figure 5.1), manufactured by microEngineering Labs Inc., can be used in 40-pin PIC18-based project development. The board is available either assembled or as a bare board.

Figure 5.1. LAB-XUSB Experimenter board

The board contains:

Th PICDEM 2 Plus kit (see Figure 5.2), manufactured by Microchip Inc., can be used in the development of PIC18 microcontroller-based projects.

Figure 5.2. PICDEM 2 Plus development board

The board contains:

The PICDEM 4 kit (see Figure 5.3), manufactured by Microchip Inc., can be used in the development of PIC18 microcontroller-based projects.

Figure 5.3. PICDEM 4 development board

The board contains:

The PICDEM HPC Explorer development board (see Figure 5.4), manufactured by Microchip Inc., can be used in the development of high pin count PIC18-series microcontroller-based projects.

The main features of this board are:

The MK-1 Universal PIC development board (see Figure 5.5), manufactured by Baji Labs, can be used for developing PIC microcontroller-based projects with up to 40 pins. The board has a key mechanism which allows any peripheral device to be mapped to any pin of the processor, making the board very flexible. A small breadboard area is also provided, enabling users to design and test their own circuits.

Figure 5.5. MK-1 Universal PIC development board

The board has the following features:

The SSE452 development board (see Figure 5.6), manufactured by Shuan Shizu Electronic Laboratory, can be used for developing PIC18-based microcontroller projects, especially the PIC18FXX2 series of microcontrollers, and also for programming the microcontrollers.

Figure 5.6. SSE452 development board

The main features of this board are:

The SSE8720 development board (see Figure 5.7), manufactured by Shuan Shizu Electronic Laboratory, can be used for the development of PIC18-based microcontroller projects. A large amount of memory and I/O interface is provided, and the board can also be used to program microcontrollers.

Figure 5.7. SSE8720 development board

The main features of this board are:

The SSE8680 development board (see Figure 5.8), manufactured by Shuan Shizu Electronic Laboratory, can be used for developing PIC18-based microcontroller projects. The board supports CAN network, and a large amount of memory and I/O interface is provided. The board can also be used to program microcontrollers.

Figure 5.8. SSE8680 development board

The main features of this board are:

The PIC18F4520 development kit (see Figure 5.9), manufactured by Custom Computer Services Inc., includes a C compiler (PCWH), a prototyping board with PIC18F4520 microcontroller, an in-circuit debugger, and a programmer.

Figure 5.9. PIC18F4520 development kit

The main features of this development kit are:

Custom Computer Services manufactures a number of other PIC18 microcontroller-based development kits and prototyping boards, such as development kits for CAN, Ethernet, Internet, USB, and serial buses. More information is available on the company’s web site.

The BIGPIC4 is a sophisticated development kit (Figure 5.10) that supports the latest 80-pin PIC18 microcontrollers. The kit comes already assembled, with a PIC18F8520 microcontroller installed and working at 10MHz. It includes an on-board USB port, an on-board programmer, and an in-circuit debugger. The microcontroller on the board can be replaced easily.

Figure 5.10. BIGPIC4 development kit

The main features of this development kit are:

The BIGPIC4 is used in some of the projects in this book.

The FUTURLEC PIC18F458 training board is a very powerful development kit (see Figure 5.11) based on the PIC18F458 microcontroller and developed by Futurlec (www.futurlec.com). The kit comes already assembled and tested. One of its biggest advantages is its low cost, at under $45.

Figure 5.11. FUTURLEC PIC18F458 training board

Its main features are:

The USB programmer, manufactured by Forest Electronics (see Figure 5.12), can be used to program most PIC microcontrollers with up to 40 pins, including the PIC18 series. The device is connected to the USB port of a PC and takes its power from this port.

Figure 5.12. Forest Electronics USB programmer

The Mach X programmer (Figure 5.13), manufactured by Custom Computer Services Inc., can program microcontrollers of the PIC12, PIC14, PIC16, and PIC18 series ranging from 8 to 40 pins. It can also read the program inside a microcontroller and then generate a HEX file. In-circuit debugging is also supported by this programmer.

Figure 5.13. Mach X programmer

The Melabs U2 device programmer (see Figure 5.14), manufactured by microEngineering Labs Inc., can be used to program most PIC microcontroller chips having from 8 to 40 pins. The device is USB-based and receives its power from the USB port of a PC.

Figure 5.14. Melabs U2 programmer

The EasyProg PIC is a low-cost programmer (Figure 5.15) used with microcontrollers of the PIC16 and PIC18 series having up to 40 pins. It connects to a PC via a 9-pin serial cable.

Figure 5.15. EasyProg programmer

The PIC Prog Plus is another low-cost programmer (Figure 5.16) that can be used to program most PIC microcontrollers. The device is powered from an external 12V DC supply.

Figure 5.16. PIC Prog Plus programmer

The ICD2, a low-cost in-circuit debugger (see Figure 5.17) manufactured by Microchip Inc., can debug most PIC microcontroller-based systems. With the ICD2, programs are downloaded to the target microcontroller chip and executed in real time. This debugger supports both assembly language and C language programs.

Figure 5.17. ICD2 in-circuit debugger

The ICD2 connects to a PC through either a serial RS232 or a USB interface. The device acts like an intelligent interface between the PC and the test system, allowing the programmer to set breakpoints, look into the test system, view registers and variables at breakpoints, and single-step through the user program. It can also be used to program the target PIC microcontroller.

The ICD-U40 is an in-circuit debugger (see Figure 5.18) manufactured by Custom Computer Services Inc. to debug programs developed with their CCS C compiler. The device operates with a 40MHz clock frequency, is connected to a PC via the USB interface, and is powered from the USB port. The company also manufactures a serial-port version of this debugger called ICD-S40, which is powered from the target test system.

Figure 5.18. ICD-U40 in-circuit debugger

The PICFlash 2 in-circuit debugger (see Figure 5.19) is manufactured by mikroElektronika and can be used to debug programs developed in mikroBasic, mikroC, or mikroPascal languages. The device is connected to a PC through its USB interface. Power is drawn from the USB port so the debugger requires no external power supply. The PICFlash 2 is included in the BIGPIC4 development kit. Details on the use of this in-circuit debugger are discussed later in this chapter.

Figure 5.19. PICFlash 2 in-circuit debugger

The MPLAB ICE 4000 in-circuit emulator (Figure 5.20), manufactured by Microchip Inc., can be used to emulate microcontrollers in the PIC18 series. It consists of an emulator pod connected with a flex cable to device adapters for the specific microcontroller. The pod is connected to the PC via its parallel port or USB port. Users can insert an unlimited number of breakpoints in order to examine register values.

Figure 5.20. MPLAB ICE 4000

The RICE3000 is a powerful in-circuit emulator (Figure 5.21), manufactured by Smart Communications Ltd, for the PIC16 and PIC18 series of microcontrollers.

Figure 5.21. RICE3000 in-circuit emulator

The device consists of a base unit with different probe cards for the various members of the PIC microcontroller family. It provides full-speed real-time emulation up to 40MHz, supports observation of floating point variables and complex variables such as arrays and structures, and provides source level and symbolic debugging in both assembly and high-level languages.

The ICEPIC 3 is a modular in-circuit emulator (see Figure 5.22), manufactured by RF Solutions, for the PIC12/16 and PIC18 series of microcontrollers. It connects to the PC via its USB port and consists of a mother board with additional daughter boards for each microcontroller type. The daughter boards are connected to the target system with device adapters. A trace board can be added to capture and analyze execution addresses, opcodes, and external memory read/writes.

Figure 5.22. ICEPIC 3 in-circuit emulator

The PICE-MC, a highly sophisticated emulator (see Figure 5.23) manufactured by Phyton Inc., supports most PIC microcontrollers and consists of a main board, pod, and adapters. The main board contains the emulator logic, memory, and an interface to the PC. The pod contains a slave processor that emulates the target microcontroller. The adapters are the mechanical parts that physically connect to the microcontroller sockets of the target system. The PICE-MC provides source-level debugging of programs written in both assembly and high-level languages. A large memory is provided to capture target system data. The user can set up a large number of breakpoints and can access the program and data memories to display or change their contents.

Figure 5.23. PICE-MC in-circuit emulator

The top left, the Code Explorer section, displays every declared item in the source code. In the example in Figure 5.28, main is listed under Functions and variables Sum and i are listed under main.

Figure 5.28. Code Explorer form

There are two additional tabs in the Code Explorer. As shown in Figure 5.29, the QHelp tab lists all the available built-in functions and library functions for a quick reference.

Figure 5.29. QHelp form

The Keyboard tab lists all the available keyboard shortcuts in mikroC IDE (see Figure 5.30).

Figure 5.30. Keyboard form

In the bottom-left section, called Project Setup (see Figure 5.31), the microcontroller device type, clock rate, and build type are specified. The build type can be either Release, which is the normal compiler operating mode, or ICD debug, if the program is to be debugged using the in-circuit debugger.

Figure 5.31. Project setup form

The Project Setup section has a tab called Project Summary which lists all the types of files used in the project, as shown in Figure 5.32.

Figure 5.32. Project summary form

The middle section is the Code Editor, an advanced text editor. Programs are written in this section of the screen. The Code Editor supports:

The Code Assistant is useful when writing a program. Type the first few letters of an identifier and then press the CTRL+SPACE keys to list all valid identifiers beginning with those letters. In Figure 5.33, for example, to locate identifier strlen, the letters str are typed and CTRL+SPACE is pressed. strlen can be selected from the displayed list of matching valid words by using keyboard arrows and pressing ENTER.

Figure 5.33. Using the Code Assistant

The Parameter Assistant is invoked when a parenthesis is opened after a function or a procedure name. The expected parameters are listed in a small window just above the parenthesis. In Figure 5.34, function strlen has been entered, and unsigned char *s appears in a small window when a parenthesis is opened.

Figure 5.34. Using the Parameter Assistant

Code Template is used to generate code in the program. For example, as shown in Figure 5.35, typing switch and pressing CTRL+J automatically generates code for the switch statement. We can add our own templates by selecting Tools -> Options -> Auto Complete. Some of the available templates are array, switch, for, and if.

Figure 5.35. Using the Code Template

Auto Correct corrects typing mistakes automatically. A new list of recognized words can be added by selecting Tools -> Options -> Auto Correct Tab.

Bookmarks make the navigation easier in large code. We can set bookmarks by entering CTRL+SHIFT+number, and can then jump to the bookmark by pressing CTRL+number, where number is the bookmark number.

The bottom section of the screen, also called the Message Window, consists of three tabs: Messages, Find, and QConverter. Compilation errors and warnings are reported under the Messages tab. Double-clicking on a message line highlights the line where the error occurred. A HEX file can be generated only if the source file contains no errors. Figure 5.36 shows the results of a successful compilation listed in the Message Window. The QConverter tab can be used to convert decimal numbers into binary or hexadecimal, and vice versa.

Figure 5.36. Display of a successful compilation

Write a C program to calculate the sum of the integer numbers 1 to 10 and then send the result to PORTC of a PIC18F452-type microcontroller. Assume that eight LEDs are connected to the microcontroller’s PORTC via current limiting resistors. Draw the circuit diagram and show the steps involved in creating and compiling the program.

Solution 5.1

Figure 5.37 shows the circuit diagram of the project. The LEDs are connected to PORTC using 390 ohm current limiting resistors. The microcontroller is operated from a 4MHz resonator.

Figure 5.37. Circuit diagram of the project

The program is created and compiled as follows:

1. Double-click the mikroC icon to start the IDE.

2. Create a new project called EXAMPLE. Click Project -> New Project and fill in the form, as shown in Figure 5.38, by selecting the device type, the clock, and the configuration fuse.

   

   Figure 5.38. Creating a new project

3. Enter the following program into the Code Editor section of the IDE:

   /**********************************************************************                                                       EXAMPLE PROGRAM        8 LEDs are connected to a PIC18F452 type microcontroller.        This program calculates the sum of integer numbers from 1 to 10        And then displays the sum on PORTC of the microcontroller.        Author: Dogan Ibrahim        File:      EXAMPLE.C**********************************************************************/

   void main()
   {
   
        unsigned int Sum,i;
        TRISC = 0;
   
        Sum = 0;
        for(i=1; i<= 10; i++)
        {
                 Sum = Sum + i;
        }
   
        PORTC = Sum;
   }

4. Save the program with the name EXAMPLE by clicking File -> Save As. The program will be saved with the name EXAMPLE.C.

5. Compile the project by pressing CTRL+F9 or by clicking the Build Project button (see Figure 5.39).

   

   Figure 5.39. Build Project button

6. If the compilation is successful, a Success message will appear in the Message Window as shown in Figure 5.36. Any program errors will appear in the Message Window and should be corrected before the project proceeds further.

The compiler generates a number of output files, which can be selected by clicking Tools -> Options -> Output. The various output files include:

.ASM file. This is the assembly file of the program. Figure 5.40 shows the EXAMPLE. ASM file.

Table 5.40. EXAMPLE.ASM

; ASM code generated by mikroVirtualMachine for PIC - V. 6.2.1.0 ; Date/Time: 07/07/2007 16:46:12 ; Info: http://www.mikroelektronika.co.yu ; ADDRESS OPCODE ASM ; ---------------------------------------------- $0000 $EF04 F000 GOTO _main $0008 $ _main: ;EXAMPLE.c,14 :: void main() ;EXAMPLE.c,18 :: TRISC = 0; $0008 $6A94 CLRF TRISC, 0 ;EXAMPLES.c,20 :: Sum = 0; $000A $6A15 CLRF main_Sum_L0, 0 $000C $6A16 CLRF main_Sum_L0+1, 0 ;EXAMPLE.c,21 :: for(i=1; i<= 10; i++) $000E $0E01 MOVLW 1 $0010 $6E17 MOVWF main_i_L0, 0 $0012 $0E00 MOVLW 0 $0014 $6E18 MOVWF main_i_L0+1, 0 $0016 $ L_main_0: $0016 $0E00 MOVLW 0 $0018 $6E00 MOVWF STACK_0, 0 $001A $5018 MOVF main_i_L0+1, 0, 0 $001C $5C00 SUBWF STACK_0, 0, 0 $001E $E102 BNZ L_main_3 $0020 $5017 MOVF main_i_L0, 0, 0 $0022 $080A SUBLW 10 $0024 $ L_main_3: $0024 $E307 BNC L_main_1 ;EXAMPLE.c,23 :: SUM = Sum + i; $0026 $5017 MOVF main_i_L0, 0, 0 $0028 $2615 ADDWF main_Sum_L0, 1, 0 $002A $5018 MOVF main_i_L0+1, 0, 0 $002C $2216 ADDWFC main_Sum_L0+1, 1, 0 ;EXAMPLE.c,24 :: } $002E $ L_main_2: ;EXAMPLE.c,21 :: for(i=1; i<= 10; i++) $002E $4A17 INFSNZ main_i_L0, 1, 0 $0030 $2A18 INCF main_i_L0+1, 1, 0 ;EXAMPLE.c,24 :: } $0032 $D7F1 BRA L_main_0 $0034 $ L_main_1: ;EXAMPLE.c,26 :: PORTC = Sum; $0034 $C015 FF82 MOVFF main_Sum_L0, PORTC ;EXAMPLE.c,27 :: } $0038 $D7FF BRA $

.LST file. This is the listing file of the program. Figure 5.41 shows the EXAMPLE.LST file.

Table 5.41. EXAMPLE.LST

; ASM code generated by mikroVirtualMachine for PIC - V. 6.2.1.0 ; Date/Time: 07/07/2007 17:07:12 ; Info: http://www.mikroelektronika.co.yu ; ADDRESS OPCODE ASM ; ---------------------------------------------- $0000 $EF04 F000 GOTO _main $0008 $ _main: ;EXAMPLE.c,14 :: void main() ;EXAMPLE.c,18 :: TRISC = 0; $0008 $6A94 CLRF TRISC, 0 ;EXAMPLE.c,20 :: Sum = 0; $000A $6A15 CLRF main_Sum_L0, 0 $000C $6A16 CLRF main_Sum_L0+1, 0 ;EXAMPLE.c,21 :: for(i=1; i<= 10; i++) $000E $0E01 MOVLW 1 $0010 $6E17 MOVWF main_i_L0, 0 $0012 $0E00 MOVLW 0 $0014 $6E18 MOVWF main_i_L0+1, 0 $0016 $ L_main_0: $0016 $0E00 MOVLW 0 $0018 $6E00 MOVWF STACK_0, 0 $001A $5018 MOVF main_i_L0+1, 0, 0 $001C $5C00 SUBWF STACK_0, 0, 0 $001E $E102 BNZ L_main_3 $0020 $5017 MOVF main_i_L0, 0, 0 $0022 $080A SUBLW 10 $0024 $ L_main_3: $0024 $E307 BNC L_main_1 ;EXAMPLE.c,23 :: SUM = Sum + i; $0026 $5017 MOVF main_i_L0, 0, 0 $0028 $2615 ADDWF main_Sum_L0, 1, 0 $002A $5018 MOVF main_i_L0+1, 0, 0 $002C $2216 ADDWFC main_Sum_L0+1, 1, 0 ;EXAMPLE.c,24 :: } $002E $ L_main_2: ;EXAMPLE.c,21 :: for(i=1; i<= 10; i++) $002E $4A17 INFSNZ main_i_L0, 1, 0 $0030 $2A18 INCF main_i_L0+1, 1, 0 ;EXAMPLE.c,24 :: } $0032 $D7F1 BRA L_main_0 $0034 $ L_main_1: ;EXAMPLE.c,26 :: PORTC = Sum; $0034 $C015 FF82 MOVFF main_Sum_L0, PORTC ;EXAMPLE.c,27 :: } $0038 $D7FF BRA $ //** Procedures locations ** //ADDRESS PROCEDURE //---------------------------------------------- $0008 main //** Labels locations ** //ADDRESS LABEL //---------------------------------------------- $0008 _main: $0016 L_main_0: $0024 L_main_3: $002E L_main_2: $0034 L_main_1: //** Variables locations ** //ADDRESS VARIABLE //---------------------------------------------- $0000 STACK_0 $0001 STACK_1 $0002 STACK_2 $0003 STACK_3 $0004 STACK_4 $0005 STACK_5 $0006 STACK_6 $0007 STACK_7 $0008 STACK_8 $0009 STACK_9 $000A STACK_10 $000B STACK_11 $000C STACK_12 $000D STACK_13 $000E STACK_14 $000F STACK_15 $0010 STACK_16 $0011 STACK_17 $0012 STACK_18 $0013 STACK_19 $0014 STACK_20 $0015 main_Sum_L0 $0017 main_i_L0 $0F82 PORTC $0F94 TRISC $0FD8 STATUS $0FD9 FSR2L $0FDA FSR2H $0FDB PLUSW2 $0FDC PREINC2 $0FDD POSTDEC2 $0FDE POSTINC2 $0FDF INDF2 $0FE0 BSR $0FE1 FSR1L $0FE2 FSR1H $0FE3 PLUSW1 $0FE4 PREINC1 $0FE5 POSTDEC1 $0FE6 POSTINC1 $0FE7 INDF1 $0FE8 WREG $0FE9 FSR0L $0FEA FSR0H $0FEB PLUSW0 $0FEC PREINC0 $0FED POSTDEC0 $0FEE POSTINC0 $0FEF INDF0 $0FF3 PRODL $0FF4 PRODH $0FF5 TABLAT $0FF6 TBLPTRL $0FF7 TBLPTRH $0FF8 TBLPTRU $0FF9 PCL $0FFA PCLATH $0FFB PCLATU $0FFD TOSL $0FFE TOSH $0FFF TOSU

.HEX file. This is the most important output file as it is the one sent to the programming device to program the microcontroller. Figure 5.42 shows the EXAMPLE.HEX file.

Table 5.42. EXAMPLE.HEX

:1000000004EF00F0FFFFFFFF946A156A166A010E05 :10001000176E000E186E000E006E1850005C02E1A4 :1000200017500A0807E31750152618501622174ACA :10003000182AF1D715C082FFFFD7FFFFFFFFFFFF90 :020000040030CA :0E000000FFF9FFFEFFFFFBFFFFFFFFFFFFFF0B :00000001FF

Describe the steps for simulating the program developed in Example 5.1. Display the values of various variables and PORTC during the simulation while single-stepping the program. What is the final value displayed on PORTC?

Describe the steps involved in simulating the program developed in Example 5.1. Set a breakpoint at the end of the program and run the debugger up to this breakpoint. Display the values of various variables and PORTC at this point. What is the final value displayed on PORTC?

The project’s circuit diagram is shown in Figure 5.50. The mikroICD in-circuit debugger is connected to the development circuit using the following pins of the microcontroller:

Figure 5.50. Circuit diagram of the project

The mikroICD has two modes of operation. In inactive mode all lines from the microcontroller used by the debugger device are connected to the development system. In active mode the MCLR, RB6, and RB7 pins are disconnected from the development system and used to program the microcontroller. After the programming, these lines are restored.

The mikroICD debugger device has a 10-way IDC connector and can be connected to the target system with a 10-way IDC header. Once the development is finished and the mikroICD debugger is removed, opposite pairs of the IDC header can be connected with jumpers. Figure 5.51 shows the system built on a breadboard.

Figure 5.51. System built on a breadboard

After building the hardware we are ready to program the microcontroller and test the system’s operation with the in-circuit debugger. The steps are as follows:

Figure 5.57 shows the BIGPIC4 development board with the functions of various devices identified with arrows. The board can be powered either from an external power supply (8- to 16-C AC/DC) or from the USB port of a computer, using a jumper. In this application, the board is powered from a USB port.

Figure 5.57. BIGPIC4 development board

A 2-row by 16-column LCD can be connected in the board’s upper left corner. The contrast of the LCD can be adjusted with a small potentiometer.

The forty-six LEDs on the board can be connected to the output ports of the microcontroller, selected by switch S2. Figure 5.58 shows how to select the LEDs, using PORTC as an example. 1K resistors are used in series with the LEDs to limit the current. For example, to connect eight LEDs to PORTC we have to set the switch arm marked PORTC of switch S2 to the ON position.

Figure 5.58. LED and push-button switch connections

The forty-six push-button switches on the board can be used to program digital inputs to the microcontroller. There is also a push-button switch that acts as the RESET. Jumper J12 determines whether a button press will bring logical 0 or logical 1 to the microcontroller. When the button is not pressed, the pin state is determined by jumper J5.

At the bottom central position, a 128 × 64 pixel graphics LCD can be connected to the board. The contrast of the LCD can be adjusted by a small potentiometer.

The MMC/SD card slot at the bottom right-hand corner of the board supports cards up to 2GB storage capacity.

The RESET button is located just above the MMC/SD card slot.

Above the RESET button are two potentiometers for analog-to-digital converter applications.

All of the microcontroller port pins are available at the connectors situated along the right-hand side of the board. In the top middle portion of the board are two RS232 ports and a connection to a PC keyboard.

The board supports both 64-pin and 80-pin microcontrollers. The board comes with a PIC18F8520 microcontroller connected to the board, operating with a 10MHz crystal.

Further details about the operation of the board can be found in the BIGPIC4 user’s manual.

The steps in developing an application using the BIGPIC4 board are as follows:

The mikroICD EEPROM window is invoked from the mikroC IDE drop-down menu when the mikroICD debug mode is selected and started, and it displays contents of the PIC internal EEPROM memory. To view the memory, click View -> Debug Windows -> View EEPROM. Figure 5.60 shows an example EEPROM window display.

Figure 5.60. Display of EEPROM memory

The mikroICD RAM window is invoked from the mikroC IDE drop-down menu when the mikroICD debug mode is selected and started, and it displays contents of the PIC internal RAM memory. To view the memory, click View -> Debug Windows -> View RAM. Figure 5.61 shows an example RAM window display.

Figure 5.61. Display of RAM memory

The mikroICD Code window is invoked from the mikroC IDE drop-down menu when the mikroICD debug mode is selected and started, and it displays the contents of the PIC internal code memory. To view the memory, click View -> Debug Windows -> View Code. Figure 5.62 shows an example Code window display.

Figure 5.62. Display of Code memory

The Statistics window is invoked from the mikroC IDE drop-down menu and it displays various statistical data about our program. To view the statistics window, click View -> View Statistics. Figure 5.63 shows an example Statistics window, which consists of several tabs. The Memory Usage tab displays the amount of RAM (data memory) and ROM (code memory) used. The Procedures tabs display information about the size and locations of the procedures. The RAM and ROM tabs display memory usage in detail.

Figure 5.63. Display of Statistics window