A microcontroller is a single-chip computer. Micro suggests that the device is small, and controller suggests that it is used in control applications. Another term for microcontroller is embedded controller, since most of the microcontrollers are built into (or embedded in) the devices they control.
   A microprocessor differs from a microcontroller in a number of ways. The main distinction is that a microprocessor requires several other components for its operation, such as program memory and data memory, input-output devices, and an external clock circuit. A microcontroller, on the other hand, has all the support chips incorporated inside its single chip. All microcontrollers operate on a set of instructions (or the user program) stored in their memory. A microcontroller fetches the instructions from its program memory one by one, decodes these instructions, and then carries out the required operations.
   Microcontrollers have traditionally been programmed using the assembly language of the target device. Although the assembly language is fast, it has several disadvantages. An assembly program consists of mnemonics, which makes learning and maintaining a program written using the assembly language difficult. Also, microcontrollers manufactured by different firms have different assembly languages, so the user must learn a new language with every new microcontroller he or she uses.
   Microcontrollers can also be programmed using a high-level language, such as BASIC, PASCAL, or C. High-level languages are much easier to learn than assembly languages. They also facilitate the development of large and complex programs. In this book we shall be learning the programming of PIC microcontrollers using the popular C language known as mikroC, developed by mikroElektronika.
   In theory, a single chip is sufficient to have a running microcontroller system. In practical applications, however, additional components may be required so the microcomputer can interface with its environment. With the advent of the PIC family of microcontrollers the development time of an electronic project has been reduced to several hours.
   Basically, a microcomputer executes a user program which is loaded in its program memory. Under the control of this program, data is received from external devices (inputs), manipulated, and then sent to external devices (outputs). For example, in a microcontroller-based oven temperature control system the microcomputer reads the temperature using a temperature sensor and then operates a heater or a fan to keep the temperature at the required value. Figure 1.1 shows a block diagram of a simple oven temperature control system.
   The system shown in Figure 1.1 is very simple. A more sophisticated system may include a keypad to set the temperature and an LCD to display it. Figure 1.2 shows a block diagram of this more sophisticated temperature control system.
   Figure 1.1: Microcontroller-based oven temperature control system LCD
   Figure 1.2: Temperature control system with a keypad and LCD
   We can make the design even more sophisticated (see Figure 1.3) by adding an alarm that activates if the temperature goes outside the desired range. Also, the temperature readings can be sent to a PC every second for archiving and further processing. For example, a graph of the daily temperature can be plotted on the PC. As you can see, because microcontrollers are programmable the final system can be as simple or as complicated as we like.
   Figure 1.3: A more sophisticated temperature controller
   A microcontroller is a very powerful tool that allows a designer to create sophisticated input-output data manipulation under program control. Microcontrollers are classified by the number of bits they process. Microcontrollers with 8 bits are the most popular and are used in most microcontroller-based applications. Microcontrollers with 16 and 32 bits are much more powerful, but are usually more expensive and not required in most small-or medium-size general purpose applications that call for microcontrollers. The simplest microcontroller architecture consists of a microprocessor, memory, and input-output. The microprocessor consists of a central processing unit (CPU) and a LCD control unit (CU). The CPU is the brain of the microcontroller; this is where all the arithmetic and logic operations are performed. The CU controls the internal operations of the microprocessor and sends signals to other parts of the microcontroller to carry out the required instructions.
   Memory, an important part of a microcontroller system, can be classified into two types: program memory and data memory. Program memory stores the program written by the programmer and is usually nonvolatile (i.e., data is not lost after the power is turned off). Data memory stores the temporary data used in a program and is usually volatile (i.e., data is lost after the power is turned off).
   There are basically six types of memories, summarized as follows:

   RAM, random access memory, is a general purpose memory that usually stores the user data in a program. RAM memory is volatile in the sense that it cannot retain data in the absence of power (i.e., data is lost after the power is turned off). Most microcontrollers have some amount of internal RAM, 256 bytes being a common amount, although some microcontrollers have more, some less. The PIC18F452 microcontroller, for example, has 1536 bytes of RAM. Memory can usually be extended by adding external memory chips.

   ROM, read only memory, usually holds program or fixed user data. ROM is nonvolatile. If power is removed from ROM and then reapplied, the original data will still be there. ROM memory is programmed during the manufacturing process, and the user cannot change its contents. ROM memory is only useful if you have developed a program and wish to create several thousand copies of it.

   PROM, programmable read only memory, is a type of ROM that can be programmed in the field, often by the end user, using a device called a PROM programmer. Once a PROM has been programmed, its contents cannot be changed. PROMs are usually used in low production applications where only a few such memories are required.

   EPROM, erasable programmable read only memory, is similar to ROM, but EPROM can be programmed using a suitable programming device. An EPROM memory has a small clear-glass window on top of the chip where the data can be erased under strong ultraviolet light. Once the memory is programmed, the window can be covered with dark tape to prevent accidental erasure of the data. An EPROM memory must be erased before it can be reprogrammed. Many developmental versions of microcontrollers are manufactured with EPROM memories where the user program can be stored. These memories are erased and reprogrammed until the user is satisfied with the program. Some versions of EPROMs, known as OTP (one time programmable), can be programmed using a suitable programmer device but cannot be erased. OTP memories cost much less than EPROMs. OTP is useful after a project has been developed completely and many copies of the program memory must be made.

   EEPROM, electrically erasable programmable read only memory, is a nonvolatile memory that can be erased and reprogrammed using a suitable programming device. EEPROMs are used to save configuration information, maximum and minimum values, identification data, etc. Some microcontrollers have built-in EEPROM memories. For instance, the PIC18F452 contains a 256-byte EEPROM memory where each byte can be programmed and erased directly by applications software. EEPROM memories are usually very slow. An EEPROM chip is much costlier than an EPROM chip.

   Flash EEPROM, a version of EEPROM memory, has become popular in microcontroller applications and is used to store the user program. Flash EEPROM is nonvolatile and usually very fast. The data can be erased and then reprogrammed using a suitable programming device. Some microcontrollers have only 1K flash EEPROM while others have 32K or more. The PIC18F452 microcontroller has 32K bytes of flash memory.

   Microcontrollers from different manufacturers have different architectures and different capabilities. Some may suit a particular application while others may be totally unsuitable for the same application. The hardware features common to most microcontrollers are described in this section.

   Most microcontrollers operate with the standard logic voltage of +5V. Some microcontrollers can operate at as low as +2.7V, and some will tolerate +6V without any problem. The manufacturer’s data sheet will have information about the allowed limits of the power supply voltage. PIC18F452 microcontrollers can operate with a power supply of +2V to +5.5V.
   Usually, a voltage regulator circuit is used to obtain the required power supply voltage when the device is operated from a mains adapter or batteries. For example, a 5V regulator is required if the microcontroller is operated from a 5V supply using a 9V battery.

   All microcontrollers require a clock (or an oscillator) to operate, usually provided by external timing devices connected to the microcontroller. In most cases, these external timing devices are a crystal plus two small capacitors. In some cases they are resonators or an external resistor-capacitor pair. Some microcontrollers have built-in timing circuits and do not require external timing components. If an application is not time-sensitive, external or internal (if available) resistor-capacitor timing components are the best option for their simplicity and low cost.
   An instruction is executed by fetching it from the memory and then decoding it. This usually takes several clock cycles and is known as the instruction cycle. In PIC microcontrollers, an instruction cycle takes four clock periods. Thus the microcontroller operates at a clock rate that is one-quarter of the actual oscillator frequency. The PIC18F series of microcontrollers can operate with clock frequencies up to 40MHz.

   Timers are important parts of any microcontroller. A timer is basically a counter which is driven from either an external clock pulse or the microcontroller’s internal oscillator. A timer can be 8 bits or 16 bits wide. Data can be loaded into a timer under program control, and the timer can be stopped or started by program control. Most timers can be configured to generate an interrupt when they reach a certain count (usually when they overflow). The user program can use an interrupt to carry out accurate timing-related operations inside the microcontroller. Microcontrollers in the PIC18F series have at least three timers. For example, the PIC18F452 microcontroller has three built-in timers.
   Some microcontrollers offer capture and compare facilities, where a timer value can be read when an external event occurs, or the timer value can be compared to a preset value, and an interrupt is generated when this value is reached. Most PIC18F microcontrollers have at least two capture and compare modules.

   Most microcontrollers have at least one watchdog facility. The watchdog is basically a timer that is refreshed by the user program. Whenever the program fails to refresh the watchdog, a reset occurs. The watchdog timer is used to detect a system problem, such as the program being in an endless loop. This safety feature prevents runaway software and stops the microcontroller from executing meaningless and unwanted code. Watchdog facilities are commonly used in real-time systems where the successful termination of one or more activities must be checked regularly.

   A reset input is used to reset a microcontroller externally. Resetting puts the microcontroller into a known state such that the program execution starts from address 0 of the program memory. An external reset action is usually achieved by connecting a push-button switch to the reset input. When the switch is pressed, the microcontroller is reset.

   Interrupts are an important concept in microcontrollers. An interrupt causes the microcontroller to respond to external and internal (e.g., a timer) events very quickly. When an interrupt occurs, the microcontroller leaves its normal flow of program execution and jumps to a special part of the program known as the interrupt service routine (ISR). The program code inside the ISR is executed, and upon return from the ISR the program resumes its normal flow of execution.
   The ISR starts from a fixed address of the program memory sometimes known as the interrupt vector address. Some microcontrollers with multi-interrupt features have just one interrupt vector address, while others have unique interrupt vector addresses, one for each interrupt source. Interrupts can be nested such that a new interrupt can suspend the execution of another interrupt. Another important feature of multi-interrupt capability is that different interrupt sources can be assigned different levels of priority. For example, the PIC18F series of microcontrollers has both low-priority and high-priority interrupt levels.

   Brown-out detectors, which are common in many microcontrollers, reset the microcontroller if the supply voltage falls below a nominal value. These safety features can be employed to prevent unpredictable operation at low voltages, especially to protect the contents of EEPROM-type memories.

   An analog-to-digital converter (A/D) is used to convert an analog signal, such as voltage, to digital form so a microcontroller can read and process it. Some microcontrollers have built-in A/D converters. External A/D converter can also be connected to any type of microcontroller. A/D converters are usually 8 to 10 bits, having 256 to 1024 quantization levels. Most PIC microcontrollers with A/D features have multiplexed A/D converters which provide more than one analog input channel. For example, the PIC18F452 microcontroller has 10-bit 8-channel A/D converters. The A/D conversion process must be started by the user program and may take several hundred microseconds to complete. A/D converters usually generate interrupts when a conversion is complete so the user program can read the converted data quickly. A/D converters are especially useful in control and monitoring applications, since most sensors (e.g., temperature sensors, pressure sensors, force sensors, etc.) produce analog output voltages.

   Serial communication (also called RS232 communication) enables a microcontroller to be connected to another microcontroller or to a PC using a serial cable. Some microcontrollers have built-in hardware called USART (universal synchronous-asynchronous receiver-transmitter) to implement a serial communication interface. The user program can usually select the baud rate and data format. If no serial input-output hardware is provided, it is easy to develop software to implement serial data communication using any I/O pin of a microcontroller. The PIC18F series of microcontrollers has built-in USART modules. We shall see in Chapter 6 how to write mikroC programs to implement serial communication with and without a USART module. Some microcontrollers (e.g., the PIC18F series) incorporate SPI (serial peripheral interface) or I²C (integrated interconnect) hardware bus interfaces. These enable a microcontroller to interface with other compatible devices easily.

   EEPROM-type data memory is also very common in many microcontrollers. The advantage of an EEPROM memory is that the programmer can store nonvolatile data there and change this data whenever required. For example, in a temperature monitoring application, the maximum and minimum temperature readings can be stored in an EEPROM memory. If the power supply is removed for any reason, the values of the latest readings are available in the EEPROM memory. The PIC18F452 microcontroller has 256 bytes of EEPROM memory. Other members of the PIC18F family have more EEPROM memory (e.g., the PIC18F6680 has 1024 bytes). The mikroC language provides special instructions for reading and writing to the EEPROM memory of a PIC microcontroller.

   LCD drivers enable a microcontroller to be connected to an external LCD display directly. These drivers are not common since most of the functions they provide can be implemented in software. For example, the PIC18F6490 microcontroller has a built-in LCD driver module.

   Analog comparators are used where two analog voltages need to be compared. Although these circuits are implemented in most high-end PIC microcontrollers, they are not common in other microcontrollers. The PIC18F series of microcontrollers has built-in analog comparator modules.

   A real-time clock enables a microcontroller to receive absolute date and time information continuously. Built-in real-time clocks are not common in most microcontrollers, since the same function can easily be implemented by either a dedicated real-time clock chip or a program written for this purpose.

   Some microcontrollers (e.g., PICs) offer built-in sleep modes, where executing this instruction stops the internal oscillator and reduces power consumption to an extremely low level. The sleep mode’s main purpose is to conserve battery power when the microcontroller is not doing anything useful. The microcontroller is usually woken up from sleep mode by an external reset or a watchdog time-out.

   Some microcontrollers (e.g., PICs) have built-in power-on reset circuits which keep the microcontroller in the reset state until all the internal circuitry has been initialized. This feature is very useful, as it starts the microcontroller from a known state on power-up. An external reset can also be provided, where the microcontroller is reset when an external button is pressed.

   Low-power operation is especially important in portable applications where microcontroller-based equipment is operated from batteries. Some microcontrollers (e.g., PICs) can operate with less than 2mA with a 5V supply, and around 15mA at a 3V supply. Other microcontrollers, especially microprocessor-based systems with several chips, may consume several hundred milliamperes or even more.

   Current sink/source capability is important if the microcontroller is to be connected to an external device that might draw a large amount of current to operate. PIC microcontrollers can source and sink 25mA of current from each output port pin. This current is usually sufficient to drive LEDs, small lamps, buzzers, small relays, etc. The current capability can be increased by connecting external transistor switching circuits or relays to the output port pins.

   USB is currently a very popular computer interface specification used to connect various peripheral devices to computers and microcontrollers. Some PIC microcontrollers provide built-in USB modules. The PIC18F2x50, for example, has built-in USB interface capabilities.

   Some PIC microcontrollers, for example the PIC18F2x31, provide motor control interface capability.

   CAN bus is a very popular bus system used mainly in automation applications. Some PIC18F-series microcontrollers (e.g., the PIC18F4680) provide CAN interface capability.

   Some PIC microcontrollers (e.g., the PIC18F97J60) provide Ethernet interface capabilities and thus are easily used in network-based applications.

   ZigBee, an interface similar to Bluetooth, is used in low-cost wireless home automation applications. Some PIC18F-series microcontrollers provide ZigBee interface capabilities, making the design of such wireless systems very easy.

   Two types of architectures are conventional in microcontrollers (see Figure 1.4). Von Neumann architecture, used by a large percentage of microcontrollers, places all memory space on the same bus; instruction and data also use the same bus.
   Figure 1.4: Von Neumann and Harvard architectures
   In Harvard architecture (used by PIC microcontrollers), code and data are on separate buses, which allows them to be fetched simultaneously, resulting in an improved performance.

   RISC (reduced instruction set computer) and CISC (complex instruction computer) refer to the instruction set of a microcontroller. In an 8-bit RISC microcontroller, data is 8 bits wide but the instruction words are more than 8 bits wide (usually 12, 14, or 16 bits) and the instructions occupy one word in the program memory. Thus the instructions are fetched and executed in one cycle, which improves performance.
   In a CISC microcontroller, both data and instructions are 8 bits wide. CISC microcontrollers usually have over two hundred instructions. Data and code are on the same bus and cannot be fetched simultaneously.

   To use a microprocessor or microcontroller efficiently requires a working knowledge of binary, decimal, and hexadecimal numbering systems. This section provides background information about these numbering systems for readers who are unfamiliar with them or do not know how to convert from one number system to another. Number systems are classified according to their bases. The numbering system used in everyday life is base 10, or the decimal number system. The numbering system most commonly used in microprocessor and microcontroller applications is base 16, or hexadecimal. Base 2, or binary, and base 8, or octal, number systems are also used.

   The numbers in the decimal number system, of course, are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. The subscript 10 indicates that a number is in decimal format. For example, the decimal number 235 is shown as 235₁₀.
   In general, a decimal number is represented as follows:
   a_n × 10ⁿ + a_n–1 × 10^n–1 + a_n-2 × 10^n-2 + ……… + a₀ × 10⁰
   For example, decimal number 825₁₀ can be shown as:
   825₁₀ = 8 × 10² + 2 × 10¹ + 5 × 10⁰
   Similarly, decimal number 26₁₀ can be shown as:
   26₁₀ = 2 × 10¹ + 6 × 10⁰
   or
   3359₁₀ = 3 × 10³ + 3 × 10² + 5 × 10¹ + 9 × 10⁰

   The binary number system consists of two numbers: 0 and 1. A subscript 2 indicates that a number is in binary format. For example, the binary number 1011 would be 10112. In general, a binary number is represented as follows:
   a_n × 2ⁿ + a_n–1 × 2^n–1 + a_n–2 × 2^n–2 + ……… + a₀ × 2⁰
   For example, binary number 11102 can be shown as:
   1110₂ = 1 × 2³ + 1 × 2² + 1 × 2¹ + 0 × 2⁰
   Similarly, binary number 100011102 can be shown as:
   10001110₂ = 1 × 2⁷ + 0 × 2⁶ + 0 × 2⁵ + 0 × 2⁴ + 1 × 2³ + 1 × 2² + 1 × 2¹ + 0 × 2⁰

   In the octal number system, the valid numbers are 0, 1, 2, 3, 4, 5, 6, 7. A subscript 8 indicates that a number is in octal format. For example, the octal number 23 appears as 23₈.
   In general, an octal number is represented as:
   a_n × 8ⁿ + a_n–1 × 8^n–1 + a_n–2 × 8^n–2 + ……… + a₀ × 8⁰
   For example, octal number 237₈ can be shown as:
   237₈ = 2 × 8² + 3 × 8¹ + 7 × 8⁰
   Similarly, octal number 1777₈ can be shown as:
   1777₈ = 1 × 8³ + 7 × 8² + 7 × 8¹ + 7 × 8⁰

   In the hexadecimal number system, the valid numbers are: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. A subscript 16 or subscript H indicates that a number is in hexadecimal format. For example, hexadecimal number 1F can be written as 1F₁₆ or as 1F_H. In general, a hexadecimal number is represented as:
   a_n × 16ⁿ + a_n–1 × 16^n–1 + a_n–2 × 16^n–2 + ……… + a₀ × 16⁰
   For example, hexadecimal number 2AC₁₆ can be shown as:
   2AC₁₆ = 2 × 16² + 10 × 16¹ + 12 × 16⁰
   Similarly, hexadecimal number 3FFE₁₆ can be shown as:
   3FFE₁₆ = 3 × 16³ + 15 × 16² + 15 × 16¹ + 14 × 16⁰

   To convert a given floating point number into decimal, we have to find the mantissa and the exponent of the number and then convert into decimal as just shown. Some examples are given here.

Example 1.30

   Find the decimal equivalent of the floating point number: 0 10000001 10000000000000000000000

Solution 1.30

   Here
   sign = positive
   exponent = 129 – 127 = 2
   mantissa = 2^-1 = 0.5
   The decimal equivalent of this number is +1.5 × 2² = +6.0.

Example 1.31

   Find the decimal equivalent of the floating point number: 0 10000010 11000000000000000000

Solution 1.31

   In this example,
   sign = positive
   exponent = 130 – 127 = 3
   mantissa = 2^-1 + 2^-2 = 0.75
   The decimal equivalent of the number is +1.75 × 2³ = 14.0.

   Floating point numbers are usually shown in normalized form. A normalized number has only one digit before the decimal point (a hidden number 1 is assumed before the decimal point).
   To normalize a given floating point number, we have to move the decimal point repeatedly one digit to the left and increase the exponent after each move.
   Some examples follow.

Example 1.32

   Normalize the floating point number 123.56

Solution 1.32

   If we write the number with a single digit before the decimal point we get:
   1.2356 × 10²

Example 1.33

   Normalize the binary number 1011.1₂

Solution 1.33

   If we write the number with a single digit before the decimal point we get:
   1.0111 × 2³

   To convert a given decimal number into floating point, carry out the following steps:
   • Write the number in binary.
   • Normalize the number.
   • Find the mantissa and the exponent.
   • Write the number as a floating point number.
   Some examples follow:

Example 1.34

   Convert decimal number 2.25₁₀ into floating point.

Solution 1.34

   Write the number in binary:
   2.25₁₀ = 10.01₂
   Normalize the number:
   10.01₂ = 1.001₂ × 2¹
   Here, s = 0, e – 127 = 1 or e = 128, and f = 00100000000000000000000.
   (Remember that a number 1 is assumed on the left side, even though it is not shown in the calculation). The required floating point number can be written as:
   s     e                 f
   0 10000000 (1)001 0000 0000 0000 0000 0000
   or, the required 32-bit floating point number is:
   01000000000100000000000000000000

Example 1.35

   Convert the decimal number 134.0625₁₀ into floating point.

Solution 1.35

   Write the number in binary:
   134.0625₁₀ = 10000110.0001
   Normalize the number:
   10000110.0001 = 1.00001100001 × 2⁷
   Here, s = 0, e – 127 = 7 or e = 134, and f = 00001100001000000000000.
   The required floating point number can be written as:
   s     e                f
   0 10000110 (1)00001100001000000000000
   or, the required 32-bit floating point number is:
   01000011000001100001000000000000

   Multiplication and division of floating point numbers are rather easy. Here are the steps:
   • Add (or subtract) the exponents of the numbers.
   • Multiply (or divide) the mantissa of the numbers.
   • Correct the exponent.
   • Normalize the number.
   • The sign of the result is the EXOR of the signs of the two numbers.
   Since the exponent is processed twice in the calculations, we have to subtract 127 from the exponent.
   An example showing the multiplication of two floating point numbers follows.

Example 1.36

   Show the decimal numbers 0.5₁₀ and 0.75₁₀ in floating point and then calculate their multiplication.

Solution 1.36

   Convert the numbers into floating point as:
   0.5₁₀ = 1.0000 × 2^-1
   here, s = 0, e – 127 = -1 or e = 126 and f = 0000
   or,
   0.5₁₀ = 0 01110110 (1)000 0000 0000 0000 0000 0000
   Similarly,
   0.75₁₀ = 1.1000 × 2^-1
   here, s = 0, e = 126 and f = 1000
   or,
   0.75₁₀ = 0 01110110 (1)100 0000 0000 0000 0000 0000
   Multiplying the mantissas results in “(1)100 0000 0000 0000 0000 0000.” The sum of the exponents is 126+126=252. Subtracting 127 from the mantissa, we obtain 252–127=125. The EXOR of the signs of the numbers is 0. Thus, the result can be shown in floating point as:
   0 01111101 (1)100 0000 0000 0000 0000 0000
   This number is equivalent to decimal 0.375 (0.5×0.75=0.375), which is the correct result.

   The exponents of floating point numbers must be the same before they can be added or subtracted. The steps to add or subtract floating point numbers are:
   • Shift the smaller number to the right until the exponents of both numbers are the same. Increment the exponent of the smaller number after each shift.
   • Add (or subtract) the mantissa of each number as an integer calculation, without considering the decimal points.
   • Normalize the result.
   An example follows.

Example 1.37

   Show decimal numbers 0.5₁₀ and 0.75₁₀ in floating point and then calculate the sum of these numbers.

Solution 1.37

   As shown in Example 1.36, we can convert the numbers into floating point as:
   0.5₁₀ = 0 01110110 (1)000 0000 0000 0000 0000 0000
   Similarly,
   0.75₁₀ = 0 01110110 (1)100 0000 0000 0000 0000 0000
   Since the exponents of both numbers are the same, there is no need to shift the smaller number. If we add the mantissa of the numbers without considering the decimal points, we get:
     (1)000 0000 0000 0000 0000 0000
   + (1)100 0000 0000 0000 0000 0000
    --------------------------------
    (10)100 0000 0000 0000 0000 0000
   To normalize the number, shift it right by one digit and then increment its exponent. The resulting number is:
   0 01111111 (1)010 0000 0000 0000 0000 0000
   This floating point number is equal to decimal number 1.25, which is the sum of decimal numbers 0.5 and 0.75.
   A program for converting floating point numbers into decimal, and decimal numbers into floating point, is available for free on the following web site:
   http://babbage.cs.qc.edu/courses/cs341/IEEE-754.html

   As shown in Table 2.1, the PIC18FXX2 series consists of four devices. PIC18F2X2 microcontrollers are 28-pin devices, while PIC18F4X2 microcontrollers are 40-pin devices. The architectures of the two groups are almost identical except that the larger devices have more input-output ports and more A/D converter channels. In this section we shall be looking at the architecture of the PIC18F452 microcontroller in detail. The architectures of other standard PIC18F-series microcontrollers are similar, and the knowledge gained in this section should be enough to understand the operation of other PIC18F-series microcontrollers.
   The pin configuration of the PIC18F452 microcontroller (DIP package) is shown in Figure 2.1. This is a 40-pin microcontroller housed in a DIL package, with a pin configuration similar to the popular PIC16F877.
   Figure 2.1: PIC18F452 microcontroller DIP pin configuration
   Figure 2.2 shows the internal block diagram of the PIC18F452 microcontroller. The CPU is at the center of the diagram and consists of an 8-bit ALU, an 8-bit working accumulator register (WREG), and an 8×8 hardware multiplier. The higher byte and the lower byte of a multiplication are stored in two 8-bit registers called PRODH and PRODL respectively.
   Figure 2.2: Block diagram of the PIC18F452 microcontroller
   The program counter and program memory are shown in the upper left portion of the diagram. Program memory addresses consist of 21 bits, capable of accessing 2Mbytes of program memory locations. The PIC18F452 has only 32Kbytes of program memory, which requires only 15 bits. The remaining 6 address bits are redundant and not used. A table pointer provides access to tables and to the data stored in program memory. The program memory contains a 31-level stack which is normally used to store the interrupt and subroutine return addresses.
   The data memory can be seen at the top center of the diagram. The data memory bus is 12 bits wide, capable of accessing 4Kbytes of data memory locations. As we shall see later, the data memory consists of special function registers (SFR) and general purpose registers, all organized in banks.
   The bottom portion of the diagram shows the timers/counters, capture/compare/PWM registers, USART, A/D converter, and EEPROM data memory. The PIC18F452 consists of:
   • 4 timers/counters
   • 2 capture/compare/PWM modules
   • 2 serial communication modules
   • 8 10-bit A/D converter channels
   • 256 bytes EEPROM
   The oscillator circuit, located at the left side of the diagram, consists of:
   • Power-up timer
   • Oscillator start-up timer
   • Power-on reset
   • Watchdog timer
   • Brown-out reset
   • Low-voltage programming
   • In-circuit debugger
   • PLL circuit
   • Timing generation circuit
   The PLL circuit is new to the PIC18F series and provides the option of multiplying up the oscillator frequency to speed up the overall operation. The watchdog timer can be used to force a restart of the microcontroller in the event of a program crash. The in-circuit debugger is useful during program development and can be used to return diagnostic data, including the register values, as the microcontroller is executing a program.
   The input-output ports are located at the right side of the diagram. The PIC18F452 has five parallel ports named PORTA, PORTB, PORTC, PORTD, and PORTE. Most port pins have multiple functions. For example, PORTA pins can be used as parallel inputs-outputs or analog inputs. PORTB pins can be used as parallel inputs-outputs or as interrupt inputs.

   The program memory map is shown in Figure 2.3. All PIC18F devices have a 21-bit program counter and hence are capable of addressing 2Mbytes of memory space. User memory space on the PIC18F452 microcontroller is 00000H to 7FFFH. Accessing a nonexistent memory location (8000H to 1FFFFFH) will cause a read of all 0s. The reset vector, where the program starts after a reset, is at address 0000. Addresses 0008H and 0018H are reserved for the vectors of high-priority and low-priority interrupts respectively, and interrupt service routines must be written to start at one of these locations.
   Figure 2.3: Program memory map of PIC18F452
   The PIC18F microcontroller has a 31-entry stack that is used to hold the return addresses for subroutine calls and interrupt processing. The stack is not part of the program or the data memory space. The stack is controlled by a 5-bit stack pointer which is initialized to 00000 after a reset. During a subroutine call (or interrupt) the stack pointer is first incremented, and the memory location it points to is written with the contents of the program counter. During the return from a subroutine call (or interrupt), the memory location the stack pointer has pointed to is decremented. The projects in this book are based on using the C language. Since subroutine and interrupt call/return operations are handled automatically by the C language compiler, their operation is not described here in more detail.
   Program memory is addressed in bytes, and instructions are stored as two bytes or four bytes in program memory. The least significant byte of an instruction word is always stored in an even address of the program memory.
   An instruction cycle consists of four cycles: A fetch cycle begins with the program counter incrementing in Q1. In the execution cycle, the fetched instruction is latched into the instruction register in cycle Q1. This instruction is decoded and executed during cycles Q2, Q3, and Q4. A data memory location is read during the Q2 cycle and written during the Q4 cycle.

   The data memory map of the PIC18F452 microcontroller is shown in Figure 2.4. The data memory address bus is 12 bits with the capability to address up to 4Mbytes. The memory in general consists of sixteen banks, each of 256 bytes, where only 6 banks are used. The PIC18F452 has 1536 bytes of data memory (6 banks × 256 bytes each) occupying the lower end of the data memory. Bank switching happens automatically when a high-level language compiler is used, and thus the user need not worry about selecting memory banks during programming.
   Figure 2.4: The PIC18F452 data memory map
   The special function register (SFR) occupies the upper half of the top memory bank. SFR contains registers which control operations such as peripheral devices, timers/counters, A/D converter, interrupts, and USART. Figure 2.5 shows the SFR registers of the PIC18F452 microcontroller.
   Figure 2.5: The PIC18F452 SFR registers

   PIC18F452 microcontrollers have a set of configuration registers (PIC16-series microcontrollers had only one configuration register). Configuration registers are programmed during the programming of the flash program memory by the programming device. These registers are shown in Table 2.2. these registers are given in Table 2.3. Some of the more important configuration registers are described in this section in detail.
 
   Table 2.2: PIC18F452 configuration registers

File Name		Bit 7	Bit 6	Bit 5	Bit 4	Bit 3	Bit 2	Bit 1	Bit 0	Default/Unprogrammed Value
300001h	CONFIG1H	—	—	OSCSEN#	—	—	FOSC2	FOSC1	FOSC0	--1--111
300002h	CONFIG2L	—	—	—	—	BORV1	BORV0	BOREN	PWRTEN#	---- 1111
300003h	CONFIG2H	—	—	—	—	WDTPS2	WDTPS1	WDTPS0	WDTEN	---- 1111
300005h	CONFIG3H	—	—	—	—	—	—	—	CCP2MX	---- ---1
300006h	CONFIG4L	DEBUG	—	—	—	—	LVP	—	STVREN1	--- -1-1
300008h	CONFIG5L	—	—	—	—	CP3	CP2	CP1	CP0	---- 1111
300009h	CONFIG5H	CPD	CPB	—	—	—	—	—	—	11-- ----
30000Ah	CONFIG6L	—	—	—	—	WRT3	WRT2	WRT1	WRT0	---- 1111
30000Bh	CONFIG6H	WRTD	WRTB	WRTC	—	—	—	—	—	111- ----
30000Ch	CONFIG7L	—	—	—	—	EBTR3	EBTR2	EBTR1	EBTR0	---- 1111
30000Dh	CONFIG7H	—	EBTRB	—	—	—	—	—	—	-1-----
3FFFFEh	DEVID1	DEV2	DEV1	DEV0	REV4	REV3	REV2	REV1	REV0	(1)
3FFFFFh	DEVID2	DEV10	DEV9	DEV8	DEV7	DEV6	DEV5	DEV4	DEV3	0000 0100

   Legend: x = unknown, u = unchanged, – = unimplemented, q = value depends on condition. Shaded cells are unimplemented, read as ‘0’.
 
   Table 2.3: PIC18F452 configuration register descriptions

Configuration bits	Description
OSCSEN	Clock source switching enable
FOSC2:FOSC0	Oscillator modes
BORV1:BORV0	Brown-out reset voltage
BOREN	Brown-out reset enable
PWRTEN	Power-up timer enable
WDTPS2:WDTPS0	Watchdog timer postscale bits
WDTEN	Watchdog timer enable
CCP2MX	CCP2 multiplex
DEBUG	Debug enable
LVP	Low-voltage program enable
STVREN	Stack full/underflow reset enable
CP3:CP0	Code protection
CPD	EEPROM code protection
CPB	Boot block code protection
WRT3:WRT0	Program memory write protection
WRTD	EPROM write protection
WRTB	Boot block write protection
WRTC	Configuration register write protection
EBTR3:EBTR0	Table read protection
EBTRB	Boot block table read protection
DEV2:DEV0	Device ID bits (001 = 18F452)
REV4:REV0	Revision ID bits
DEV10:DEV3	Device ID bits

CONFIG1H

   The CONFIG1H configuration register is at address 300001H and is used to select the microcontroller clock sources. The bit patterns are shown in Figure 2.6.
   Figure 2.6: CONFIG1H register bits 

CONFIG2L

   The CONFIG2L configuration register is at address 300002H and is used to select the brown-out voltage bits. The bit patterns are shown in Figure 2.7.
   Figure 2.7: CONFIG2L register bits

CONFIG2H

   The CONFIG2H configuration register is at address 300003H and is used to select the watchdog operations. The bit patterns are shown in Figure 2.8.
   Figure 2.8: CONFIG2H register bits

   The power supply requirements of the PIC18F452 microcontroller are shown in Figure 2.9. As shown in Figure 2.10, PIC18F452 can operate with a supply voltage of 4.2V to 5.5V at the full speed of 40MHz. The lower power version, PIC18LF452, can operate from 2.0 to 5.5 volts. At lower voltages the maximum clock frequency is 4MHz, which rises to 40MHz at 4.2V. The RAM data retention voltage is specified as 1.5V and will be lost if the power supply voltage is lowered below this value. In practice, most microcontroller-based systems are operated with a single +5V supply derived from a suitable voltage regulator.
   Figure 2.9: The PIC8F452 power supply parameters
   Figure 2.10: Operation of PIC18LF452 at different voltages

   The reset action puts the microcontroller into a known state. Resetting a PIC18F microcontroller starts execution of the program from address 0000H of the program memory. The microcontroller can be reset during one of the following operations:
   • Power-on reset (POR)
   • MCLR reset
   • Watchdog timer (WDT) reset
   • Brown-out reset (BOR)
   • Reset instruction
   • Stack full reset
   • Stack underflow reset
   Two types of resets are commonly used: power-on reset and external reset using the MCLR pin.

Power-on Reset

   The power-on reset is generated automatically when power supply voltage is applied to the chip. The MCLR pin should be tied to the supply voltage directly or, preferably, through a 10K resistor. Figure 2.11 shows a typical reset circuit.
   Figure 2.11: Typical reset circuit
   For applications where the rise time of the voltage is slow, it is recommended to use a diode, a capacitor, and a series resistor as shown in Figure 2.12.
   Figure 2.12: Reset circuit for slow-rising voltages
   In some applications the microcontroller may have to be reset externally by pressing a button. Figure 2.13 shows the circuit that can be used to reset the microcontroller externally. Normally the MCLR input is at logic 1. When the RESET button is pressed, this pin goes to logic 0 and resets the microcontroller.
   Figure 2.13: External reset circuit

   The PIC18F452 microcontroller can be operated from an external crystal or ceramic resonator connected to the microcontroller’s OSC1 and OSC2 pins. In addition, an external resistor and capacitor, an external clock source, and in some models internal oscillators can be used to provide clock pulses to the microcontroller. There are eight clock sources on the PIC18F452 microcontroller, selected by the configuration register CONFIG1H. These are:
   • Low-power crystal (LP)
   • Crystal or ceramic resonator (XT)
   • High-speed crystal or ceramic resonator (HS)
   • High-speed crystal or ceramic resonator with PLL (HSPLL)
   • External clock with F_OSC/4 on OSC2 (EC)
   • External clock with I/O on OSC2 (port RA6) (ECIO)
   • External resistor/capacitor with F_OSC/4 output on OSC2 (RC)
   • External resistor/capacitor with I/O on OSC2 (port RA6) (RCIO)

Crystal or Ceramic Resonator Operation

   The first several clock sources listed use an external crystal or ceramic resonator that is connected to the OSC1 and OSC2 pins. For applications where accuracy of timing is important, a crystal should be used. And if a crystal is used, a parallel resonant crystal must be chosen, since series resonant crystals do not oscillate when the system is first powered.
   Figure 2.14 shows how a crystal is connected to the microcontroller. The capacitor values depend on the mode of the crystal and the selected frequency. Table 2.4 gives the recommended values. For example, for a 4MHz crystal frequency, use 15pF capacitors. Higher capacitance increases the oscillator stability but also increases the start-up time.
   Figure 2.14: Using a crystal as the clock input
 
   Table 2.4: Capacitor values

Mode	Frequency	C1,C2 (pF)
LP	32 KHz	33
	200 KHz	15
XT	200 KHz	22–68
	1.0 MHz	15
	4.0 MHz	15
HS	4.0 MHz	15
	8.0 MHz	15–33
	20.0 MHz	15–33
	25.0 MHz	15–33

   Resonators should be used in low-cost applications where high accuracy in timing is not required. Figure 2.15 shows how a resonator is connected to the microcontroller.
   Figure 2.15: Using a resonator as the clock input
   The LP (low-power) oscillator mode is advised in applications to up to 200KHz clock. The XT mode is advised to up to 4MHz, and the HS (high-speed) mode is advised in applications where the clock frequency is between 4MHz to 25MHz.
   An external clock source may also be connected to the OSC1 pin in the LP, XT, or HS modes as shown in Figure 2.16.
   Figure 2.16: Connecting an external clock in LP, XT, or HS modes

External Clock Operation

   An external clock source can be connected to the OSC1 input of the microcontroller in EC and ECIO modes. No oscillator start-up time is required after a power-on reset. Figure 2.17 shows the operation with the external clock in EC mode. Timing pulses at the frequency FOSC/4 are available on the OSC2 pin. These pulses can be used for test purposes or to provide pulses to external devices.
   Figure 2.17: External clock in EC mode
   The ECIO mode is similar to the EC mode, except that the OSC2 pin can be used as a general purpose digital I/O pin. As shown in Figure 2.18, this pin becomes bit 6 of PORTA (i.e., pin RA6).
   Figure 2.18: External clock in ECIO mode

Resistor/Capacitor Operation

   In the many applications where accurate timing is not required we can use an external resistor and a capacitor to provide clock pulses. The clock frequency is a function of the resistor, the capacitor, the power supply voltage, and the temperature. The clock frequency is not accurate and can vary from unit to unit due to manufacturing and component tolerances. Table 2.5 gives the approximate clock frequency with various resistor and capacitor combinations. A close approximation of the clock frequency is 1/(4.2RC), where R should be between 3K and 100K and C should be greater than 20pF.
 
   Table 2.5: Clock frequency with RC

C (pF)	R (K)	Frequency (MHz)
22	3.3	3.3
	4.7	2.3
	10	1.08
30	3.3	2.4
	4.7	1.7
	10	0.793

   In RC mode, the oscillator frequency divided by 4 (FOSC/4) is available on pin OSC2 of the microcontroller. Figure 2.19 shows the operation at a clock frequency of approximately 2MHz, where R=3.9K and C=30pF. In this application the clock frequency at the output of OSC2 is 2MHz/4=500KHz.
   Figure 2.19: 2MHz clock in RC mode
   RCIO mode is similar to RC mode, except that the OSC2 pin can be used as a general purpose digital I/O pin. As shown in Figure 2.20, this pin becomes bit 6 of PORTA (i.e., pin RA6).
   Figure 2.20: 2MHz clock in RCIO mode

Crystal or Resonator with PLL

   One of the problems with using high-frequency crystals or resonators is electromagnetic interference. A Phase Locked Loop (PLL) circuit is provided that can be enabled to multiply the clock frequency by 4. Thus, for a crystal clock frequency of 10MHz, the internal operation frequency will be multiplied to 40MHz. The PLL mode is enabled when the oscillator configuration bits are programmed for HS mode.

Internal Clock

   Some devices in the PIC18F family have internal clock modes (although the PIC18F452 does not). In this mode, OSC1 and OSC2 pins are available for general purpose I/O (RA6 and RA7) or as FOSC/4 and RA7. An internal clock can be from 31KHz to 8MHz and is selected by registers OSCCON and OSCTUNE. Figure 2.21 shows the bits of internal clock control registers.
   Figure 2.21: Internal clock control registers

Clock Switching

   It is possible to switch the clock from the main oscillator to a low-frequency clock source. For example, the clock can be allowed to run fast in periods of intense activity and slower when there is less activity. In the PIC18F452 microcontroller this is controlled by bit SCS of the OSCCON register. In microcontrollers of the PIC18F family that do support an internal clock, clock switching is controlled by bits SCS0 and SCS1 of OSCCON. It is important to ensure that during clock switching unwanted glitches do not occur in the clock signal. PIC18F microcontrollers contain circuitry to ensure error-free switching from one frequency to another.

   In PIC18F-series microcontrollers family members the watchdog timer (WDT) is a free-running on-chip RC-based oscillator and does not require any external components. When the WDT times out, a device RESET is generated. If the device is in SLEEP mode, the WDT time-out will wake it up and continue with normal operation.
   The watchdog is enabled/disabled by bit SWDTEN of register WDTCON. Setting SWDTEN = 1 enables the WDT, and clearing this bit turns off the WDT. On the PIC18F452 microcontroller an 8-bit postscaler is used to multiply the basic time-out period from 1 to 128 in powers of 2. This postscaler is controlled from configuration register CONFIG2H. The typical basic WDT time-out period is 18ms for a postscaler value of 1.

   The parallel ports in PIC18F microcontrollers are very similar to those of the PIC16 series. The number of I/O ports and port pins varies depending on which PIC18F microcontroller is used, but all of them have at least PORTA and PORTB. The pins of a port are labeled as RPn, where P is the port letter and n is the port bit number. For example, PORTA pins are labeled RA0 to RA7, PORTB pins are labeled RB0 to RB7, and so on.
   When working with a port we may want to:
   • Set port direction
   • Set an output value
   • Read an input value
   • Set an output value and then read back the output value
   The first three operations are the same in the PIC16 and the PIC18F series. In some applications we may want to send a value to the port and then read back the value just sent. The PIC16 series has a weakness in the port design such that the value read from a port may be different from the value just written to it. This is because the reading is the actual port bit pin value, and this value can be changed by external devices connected to the port pin. In the PIC18F series, a latch register (e.g., LATA for PORTA) is introduced to the I/O ports to hold the actual value sent to a port pin. Reading from the port reads the latched value, which is not affected by any external device.
   In this section we shall be looking at the general structure of I/O ports.

PORTA

   In the PIC18F452 microcontroller PORTA is 7 bits wide and port pins are shared with other functions. Table 2.6 shows the PORTA pin functions.
 
   Table 2.6: PIC18F452 PORTA pin functions

Pin	Description
RA0/AN0
RA0	Digital I/O
AN0	Analog input 0
RA1/AN1
RA1	Digital I/O
AN1	Analog input 1
RA2/AN2/VREF–
RA2	Digital I/O
AN2	Analog input 2
VREF–	A/D reference voltage (low) input
RA3/AN3/VREF+
RA3	Digital I/O
AN3	Analog input 3
VREF+	A/D reference voltage (high) input
RA4/T0CKI
RA4	Digital I/O
T0CKI	Timer 0 external clock input
RA5/AN4/SS/LVDIN
RA5	Digital I/O
AN4	Analog input 4
SS	SPI Slave Select input
RA6	Digital I/O

   The architecture of PORTA is shown in Figure 2.22. There are three registers associated with PORTA:
   • Port data register — PORTA
   • Port direction register — TRISA
   • Port latch register — LATA
   Figure 2.22: PIC18F452 PORTA RA0–RA3 and RA5 pins
   PORTA is the name of the port data register. The TRISA register defines the direction of PORTA pins, where a logic 1 in a bit position defines the pin as an input pin, and a 0 in a bit position defines it as an output pin. LATA is the output latch register which shares the same data latch as PORTA. Writing to one is equivalent to writing to the other. But reading from LATA activates the buffer at the top of the diagram, and the value held in the PORTA/LATA data latch is transferred to the data bus independent of the state of the actual output pin of the microcontroller.
   Bits 0 through 3 and 5 of PORTA are also used as analog inputs. After a device reset, these pins are programmed as analog inputs and RA4 and RA6 are configured as digital inputs. To program the analog inputs as digital I/O, the ADCON1 register (A/D register) must be programmed accordingly. Writing 7 to ADCON1 configures all PORTA pins as digital I/O.
   The RA4 pin is multiplexed with the Timer 0 clock input (T0CKI). This is a Schmitt trigger input and an open drain output.
   RA6 can be used as a general purpose I/O pin, as the OSC2 clock input, or as a clock output providing F_OSC/4 clock pulses.

PORTB

   In PIC18F452 microcontroller PORTB is an 8-bit bidirectional port shared with interrupt pins and serial device programming pins. Table 2.7 gives the PORTB bit functions.
 
   Table 2.7: PIC18F452 PORTB pin functions

Pin	Description
RB0/INT0
RB0	Digital I/O
INT0	External interrupt 0
RB1/INT1
RB1	Digital I/O
INT1	External interrupt 1
RB2/INT2
RB2	Digital I/O
INT2	External interrupt 2
RB3/CCP2
RB3	Digital I/O
CCP2	Capture 2 input, compare 2, and PWM2 output
RB4	Digital I/O, interrupt on change pin
RB5/PGM
RB5	Digital I/O, interrupt on change pin
PGM	Low-voltage ICSP programming pin
RB6/PGC
RB6	Digital I/O, interrupt on change pin
PGC	In-circuit debugger and ICSP programming pin
RB7/PGD
RB7	Digital I/O, interrupt on change pin
PGD	In-circuit debugger and ICSP programming pin

   PORTB is controlled by three registers:
   • Port data register — PORTB
   • Port direction register — TRISB
   • Port latch register — LATB
   The general operation of PORTB is similar to that of PORTA. Figure 2.23 shows the architecture of PORTB. Each port pin has a weak internal pull-up which can be enabled by clearing bit RBPU of register INTCON2. These pull-ups are disabled on a power-on reset and when the port pin is configured as an output. On a power-on reset, PORTB pins are configured as digital inputs. Internal pull-ups allow input devices such as switches to be connected to PORTB pins without the use of external pull-up resistors. This saves costs because the component count and wiring requirements are reduced.
   Figure 2.23: PIC18F452 PORTB RB4–RB7 pins
   Port pins RB4–RB7 can be used as interrupt-on-change inputs, whereby a change on any of pins 4 through 7 causes an interrupt flag to be set. The interrupt enable and flag bits RBIE and RBIF are in register INTCON.

PORTC, PORTD, PORTE, and Beyond

   In addition to PORTA and PORTB, the PIC18F452 has 8-bit bidirectional ports PORTC and PORTD, and 3-bit PORTE. Each port has its own data register (e.g., PORTC), data direction register (e.g., TRISC), and data latch register (e.g., LATC). The general operation of these ports is similar to that of PORTA.2.1.
   In the PIC18F452 microcontroller PORTC is multiplexed with several peripheral functions as shown in Table 2.8. On a power-on reset, PORTC pins are configured as digital inputs.
 
   Table 2.8: PIC18F452 PORTC pin functions

Pin	Description
RC0/T1OSO/T1CKI
RC0	Digital I/O
T1OSO	Timer 1 oscillator output
T1CKI	Timer 1/Timer 3 external clock input
RC1/T1OSI/CCP2
RC1	Digital I/O
T1OSI	Timer 1 oscillator input
CCP2	Capture 2 input, Compare 2 and PWM2 output
RC2/CCP1
RC2	Digital I/O
CCP1	Capture 1 input, Compare 1 and PWM1 output
RC3/SCK/SCL
RC3	Digital I/O
SCK	Synchronous serial clock input/output for SPI
SCL	Synchronous serial clock input/output for I²C
RC4/SDI/SDA
RC4	Digital I/O
SDI	SPI data in
SDA	I²C data I/O
RC5/SDO
RC5	Digital I/O
SDO	SPI data output
RC6/TX/CK
RC6	Digital I/O
TX	USART transmit pin
CK	USART synchronous clock pin
RC7/RX/DT
RC7	Digital I/O
RX	USART receive pin
DT	USART synchronous data pin

   In the PIC18F452 microcontroller, PORTD has Schmitt trigger input buffers. On a power-on reset, PORTD is configured as digital input. PORTD can be configured as an 8-bit parallel slave port (i.e., a microprocessor port) by setting bit 4 of the TRISE register. Table 2.9 shows functions of PORTD pins.
 
   Table 2.9: PIC18F452 PORTD pin functions

Pin	Description
RD0/PSP0
RD0	Digital I/O
PSP0	Parallel slave port bit 0
RD1/PSP1
RD1	Digital I/O
PSP1	Parallel slave port bit 1
RD2/PSP2
RD2	Digital I/O
PSP2	Parallel slave port bit 2
RD3/PSP3
RD3	Digital I/O
PSP3	Parallel slave port bit 3
RD4/PSP4
RD4	Digital I/O
PSP4	Parallel slave port bit 4
RD5/PSP5
RD5	Digital I/O
PSP5	Parallel slave port bit 5
RD6/PSP6
RD6	Digital I/O
PSP6	Parallel slave port bit 6
RD7/PSP7
RD7	Digital I/O
PSP7	Parallel slave port bit 7

   In the PIC18F452 microcontroller, PORTE is only 3 bits wide. As shown in Table 2.10, port pins are shared with analog inputs and with parallel slave port read/write control bits. On a power-on reset, PORTE pins are configured as analog inputs and register ADCON1 must be programmed to change these pins to digital I/O.
 
   Table 2.10: PIC18F452 PORTE pin functions

Pin	Description
RE0/RD/AN5
RE0	Digital I/O
RD	Parallel slave port read control pin
AN5	Analog input 5
RE1/WR/AN6
RE1	Digital I/O
WR	Parallel slave port write control pin
AN6	Analog input 6
RE2/CS/AN7
RE2	Digital I/O
CS	Parallel slave port CS
AN7	Analog input 7

   The PIC18F452 microcontroller has four programmable timers which can be used in many tasks, such as generating timing signals, causing interrupts to be generated at specific time intervals, measuring frequency and time intervals, and so on.
   This section introduces the timers available in the PIC18F452 microcontroller.

Timer 0

   Timer 0 is similar to the PIC16 series Timer 0, except that it can operate either in 8-bit or in 16-bit mode. Timer 0 has the following basic features:
   • 8-bit or 16-bit operation
   • 8-bit programmable prescaler
   • External or internal clock source
   • Interrupt generation on overflow
   Timer 0 control register is T0CON, shown in Figure 2.24. The lower 6 bits of this register have similar functions to the PIC16-series OPTION register. The top two bits are used to select the 8-bit or 16-bit mode of operation and to enable/disable the timer.
   Figure 2.24: Timer 0 control register, T0CON
   Timer 0 can be operated either as a timer or as a counter. Timer mode is selected by clearing the T0CS bit, and in this mode the clock to the timer is derived from F_OSC/4. Counter mode is selected by setting the T0CS bit, and in this mode Timer 0 is incremented on the rising or falling edge of input RA4/T0CKI. Bit T0SE of T0CON selects the edge triggering mode.
   An 8-bit prescaler can be used to change the timer clock rate by a factor of up to 256. The prescaler is selected by bits PSA and T0PS2:T0PS0 of register T0CON.
   8-Bit Mode Figure 2.25 shows Timer 0 in 8-bit mode. The following operations are normally carried out in a timer application:
   • Clear T0CS to select clock _FOSC/4
   • Use bits T0PS2:T0PS0 to select a suitable prescaler value
   • Clear PSA to select the prescaler
   • Load timer register TMR0L
   • Optionally enable Timer 0 interrupts
   • The timer counts up and an interrupt is generated when the timer value overflows from FFH to 00H in 8-bit mode (or from FFFFH to 0000H in 16-bit mode)
   Figure 2.25: Timer 0 in 8-bit mode
   By loading a value into the TMR0 register we can control the count until an overflow occurs. The formula that follows can be used to calculate the time it will take for the timer to overflow (or to generate an interrupt) given the oscillator period, the value loaded into the timer, and the prescaler value:
   Overflow time = 4 × T_OSC × Prescaler × (256–TMR0)    (2.1)
   where
    Overflow time is in ms
    T_OSC is the oscillator period in μs
    Prescaler is the prescaler value
    TMR0 is the value loaded into TMR0 register
   For example, assume that we are using a 4MHz crystal, and the prescaler is chosen as 1:8 by setting bits PS2:PS0 to 010. Also assume that the value loaded into the timer register TMR0 is decimal 100. The overflow time is then given by:
   4MHZ clock has a period; T = 1/f = 0.25 μs
   using the above formula
   Overflow time = 4 × 0.25 × 8 × (256 – 100) = 1248 μs
   Thus, the timer will overflow after 1.248 msec, and a timer interrupt will be generated if the timer interrupt and global interrupts are enabled.
   What we normally want is to know what value to load into the TMR0 register for a required overflow time. This can be calculated by modifying Equation (2.1) as follows:
   TMR0 = 256 – (Overflow time)/(4 × T_OSC × Prescaler)    (2.2)
   For example, suppose we want an interrupt to be generated after 500ms and the clock and the prescaler values are as before. The value to be loaded into the TMR0 register can be calculated using Equation (2.2) as follows:
   TMR0 = 256 – 500/(4 × 0.25 × 8) = 193.5
   The closest number we can load into TMR0 register is 193.
   16-Bit Mode The Timer 0 in 16-bit mode is shown in Figure 2.26. Here, two timer registers named TMR0L and TMR0 are used to store the 16-bit timer value. The low byte TMR0L is directly loadable from the data bus. The high byte TMR0 can be loaded through a buffer called TMR0H. During a read of TMR0L, the high byte of the timer (TMR0) is also loaded into TMR0H, and thus all 16 bits of the timer value can be read. To read the 16-bit timer value, first we have to read TMR0L, and then read TMR0H in a later instruction. Similarly, during a write to TMR0L, the high byte of the timer is also updated with the contents of TMR0H, allowing all 16 bits to be written to the timer. Thus, to write to the timer the program should first write the required high byte to TMR0H. When the low byte is written to TMR0L, then the value stored in TMR0H is automatically transferred to TMR0, thus causing all 16 bits to be written to the timer.
   Figure 2.26: Timer 0 in 16-bit mode

Timer 1

   PIC18F452 Timer 1 is a 16-bit timer controlled by register T1CON, as shown in Figure 2.27. Figure 2.28 shows the internal structure of Timer 1.
   Figure 2.27: Timer 1 control register, T1CON
   Figure 2.28: Internal structure of Timer 1
   Timer 1 can be operated as either a timer or a counter. When bit TMR1CS of register T1CON is low, clock FOSC/4 is selected for the timer. When TMR1CS is high, the module operates as a counter clocked from input T1OSI. A crystal oscillator circuit, enabled from bit T1OSCEN of T1CON, is built between pins T1OSI and T1OSO where a crystal up to 200KHz can be connected between these pins. This oscillator is primarily intended for a 32KHz crystal operation in real-time clock applications. A prescaler is used in Timer 1 that can change the timing rate as a factor of 1, 2, 4, or 8.
   Timer 1 can be configured so that read/write can be performed either in 16-bit mode or in two 8-bit modes. Bit RD16 of register T1CON controls the mode. When RD16 is low, timer read and write operations are performed as two 8-bit operations. When RD16 is high, the timer read and write operations are as in Timer 0 16-bit mode (i.e., a buffer is used between the timer register and the data bus) (see Figure 2.29).
   Figure 2.29: Timer 1 in 16-bit mode
   If the Timer 1 interrupts are enabled, an interrupt will be generated when the timer value rolls over from FFFFH to 0000H.

Timer 2

   Timer 2 is an 8-bit timer with the following features:
   • 8-bit timer (TMR2)
   • 8-bit period register (PR2)
   • Programmable prescaler
   • Programmable postscaler
   • Interrupt when TM2 matches PR2
   Timer 2 is controlled from register T2CON, as shown in Figure 2.30. Bits T2CKPS1:T2CKPS0 set the prescaler for a scaling of 1, 4, and 16. Bits TOUTPS3:TOUTPS0 set the postscaler for a scaling of 1:1 to 1:16. The timer can be turned on or off by setting or clearing bit TMR2ON.
   Figure 2.30: Timer 2 control register, T2CON
   The block diagram of Timer 2 is shown in Figure 2.31. Timer 2 can be used for the PWM mode of the CCP module. The output of Timer 2 can be software selected by the SSP module as a baud clock. Timer 2 increments from 00H until it matches PR2 and sets the interrupt flag. It then resets to 00H on the next cycle.
   Figure 2.31: Timer 2 block diagram

Timer 3

   The structure and operation of Timer 3 is the same as for Timer 1, having registers TMR3H and TMR3L. This timer is controlled from register T3CON as shown in Figure 2.32.
   Figure 2.32: Timer 3 control register, T3CON
   The block diagram of Timer 3 is shown in Figure 2.33.
   Figure 2.33: Block diagram of Timer 3

   The PIC18F452 microcontroller has two capture/compare/PWM (CCP) modules, and they work with Timers 1, 2, and 3 to provide capture, compare, and pulse width modulation (PWM) operations. Each module has two 8-bit registers. Module 1 registers are CCPR1L and CCPR1H, and module 2 registers are CCPR2L and CCPR2H. Together, each register pair forms a 16-bit register and can be used to capture, compare, or generate waveforms with a specified duty cycle. Module 1 is controlled by register CCP1CON, and module 2 is controlled by CCP2CON. Figure 2.34 shows the bit allocations of the CCP control registers.
   Figure 2.34: CCPxCON register bit allocations

Capture Mode

   In capture mode, the registers operate like a stopwatch. When an event occurs, the time of the event is recorded, although the clock continues running (a stopwatch, on the other hand, stops when the event time is recorded).
   Figure 2.35 shows the capture mode of operation. Here, CCP1 will be considered, but the operation of CCP2 is identical with the register and port names changed accordingly. In this mode CCPR1H:CCPR1L captures the 16-bit value of the TMR1 or TMR3 registers when an event occurs on pin RC2/CCP1 (pin RC2/CCP1 must be configured as an input pin using TRISC). An external signal can be prescaled by 4 or 16. The event is selected by control bits CCP1M3:CCP1M0, and any of the following events can be selected:
   • Every falling edge
   • Every rising edge
   • Every fourth rising edge
   • Every sixteenth rising edge
   Figure 2.35: Capture mode of operation
   If the capture interrupt is enabled, the occurrence of an event causes an interrupt to be generated in software. If another capture occurs before the value in register CCPR1 is read, the old captured value is overwritten by the new captured value.
   Either Timer 1 or Timer 3 can be used in capture mode. They must be running in timer mode, or in synchronized counter mode, selected by register T3CON.

Compare Mode

   In compare mode, a digital comparator is used to compare the value of Timer 1 or Timer 3 to the value in a 16-bit register pair. When a match occurs, the output state of a pin is changed. Figure 2.36 shows the block diagram of compare mode in operation.
   Figure 2.36: Compare mode of operation
   Here only module CCP1 is considered, but the operation of module CCP2 is identical.
   The value of the 16-bit register pair CCPR1H:CCPR1L is continuously compared against the Timer 1 or Timer 3 value. When a match occurs, the state of the RC2/CCP1 pin is changed depending on the programming of bits CCP1M2:CCP1M0 of register CCP1CON. The following changes can be programmed:
   • Force RC2/CCP1 high
   • Force RC2/CCP1 low
   • Toggle RC2/CCP1 pin (low to high or high to low)
   • Generate interrupt when a match occurs
   • No change
   Timer 1 or Timer 3 must be running in timer mode or in synchronized counter mode, selected by register T3CON.

PWM Module

   The pulse width modulation (PWM) mode produces a PWM output at 10-bit resolution. A PWM output is basically a square waveform with a specified period and duty cycle. Figure 2.37 shows a typical PWM waveform.
   Figure 2.37: Typical PWM waveform
   Figure 2.38 shows the PWM module block diagram. The module is controlled by Timer 2. The PWM period is given by:
   PWM period = (PR2 + 1) * TMR2PS * 4 * T_OSC    (2.3)
   or
        (2.4)
   where
    PR2 is the value loaded into Timer 2 register
    TMR2PS is the Timer 2 prescaler value
    T_OSC is the clock oscillator period (seconds)
    The PWM frequency is defined as 1/(PWM period).
   Figure 2.38: PWM module block diagram
   The resolution of the PWM duty cycle is 10 bits. The PWM duty cycle is selected by writing the eight most significant bits into the CCPR1L register and the two least significant bits into bits 4 and 5 of CCP1CON register. The duty cycle (in seconds) is given by:
   PWM duty cycle = (CCPR1L:CCP1CON<5:4>) * TMR2PS * T_OSC    (2.5)
   or
        (2.6)
   The steps to configure the PWM are as follows:
   • Specify the required period and duty cycle.
   • Choose a value for the Timer 2 prescaler (TMR2PS).
   • Calculate the value to be written into the PR2 register using Equation (2.2).
   • Calculate the value to be loaded into the CCPR1L and CCP1CON registers using Equation (2.6).
   • Clear bit 2 of TRISC to make CCP1 pin an output pin.
   • Configure the CCP1 module for PWM operation using register CCP1CON.
   The following example shows how the PWM can be set up.

Example 2.1

   PWM pulses must be generated from pin CCP1 of a PIC18F452 microcontroller. The required pulse period is 44ms and the required duty cycle is 50%. Assuming that the microcontroller operates with a 4MHz crystal, calculate the values to be loaded into the various registers.

Solution 2.1

   Using a 4MHz crystal; T_OSC = 1/4 = 0.25 × 10^–6
   The required PWM duty cycle is 44/2 = 22μs.
   From Equation (2.4), assuming a timer prescaler factor of 4, we have:
    
   or
        i.e., 0AH
   and from Equation (2.6)
    
   or
    
   But the equivalent of number 22 in 10-bit binary is:
   “00 00010110”
   Therefore, the value to be loaded into bits 4 and 5 of CCP1CON is “00.” Bits 2 and 3 of CCP1CON must be set to high for PWM operation. Therefore, CCP1CON must be set to bit pattern (“X” is “don’t care”):
   XX001100
   Taking the don’t-care entries as 0, we can set CCP1CON to hexadecimal 0CH.
   The value to be loaded into CCPR1L is “00010110” (i.e., hexadecimal number 16H). The required steps are summarized as follows:
   • Load Timer 2 with prescaler of 4 (i.e., load T2CON) with 00000101 (i.e., 05H).
   • Load 0AH into PR2.
   • Load 16H into CCPR1L.
   • Load 0 into TRISC (make CCP1 pin output).
   • Load 0CH into CCP1CON.
   One period of the generated PWM waveform is shown in Figure 2.39.
   Figure 2.39: Generated PWM waveform

   An analog-to-digital converter (A/D) is another important peripheral component of a microcontroller. The A/D converts an analog input voltage into a digital number so it can be processed by a microcontroller or any other digital system. There are many analog-to-digital converter chips available on the market, and an embedded systems designer should understand the characteristics of such chips so they can be used efficiently.
   As far as the input and output voltage are concerned A/D converters can be classified as either unipolar and bipolar. Unipolar A/D converters accept unipolar input voltages in the range 0 to +0V, and bipolar A/D converters accept bipolar input voltages in the range ±V. Bipolar converters are frequently used in signal processing applications, where the signals by nature are bipolar. Unipolar converters are usually cheaper, and they are used in many control and instrumentation applications.
   Figure 2.40 shows the typical steps involved in reading and converting an analog signal into digital form, a process also known as signal conditioning. Signals received from sensors usually need to be processed before being fed to an A/D converter. This processing usually begins with scaling the signal to the correct value. Unwanted signal components are then removed by filtering the signal using classical filters (e.g., a low-pass filter). Finally, before feeding the signal to an A/D converter, the signal is passed through a sample-and-hold device. This is particularly important with fast real-time signals whose value may be changing between the sampling instants. A sample-and-hold device ensures that the signal stays at a constant value during the actual conversion process. Many applications required more than one A/D, which normally involves using an analog multiplexer at the input of the A/D. The multiplexer selects only one signal at any time and presents this signal to the A/D converter. An A/D converter usually has a single analog input and a digital parallel output. The conversion process is as follows:
   • Apply the processed signal to the A/D input
   • Start the conversion
   • Wait until conversion is complete
   • Read the converted digital data
   Figure 2.40: Signal conditioning and A/D conversion process
   The A/D conversion starts by triggering the converter. Depending on the speed of the converter, the conversion process itself can take several microseconds. At the end of the conversion, the converter either raises a flag or generates an interrupt to indicate that the conversion is complete. The converted parallel output data can then be read by the digital device connected to the A/D converter.
   Most members of the PIC18F family contain a 10-bit A/D converter. If the chosen voltage reference is +5V, the voltage step value is:
     
   Therefore, for example, if the input voltage is 1.0V, the converter will generate a digital output of 1.0/0.00489 = 205 decimal. Similarly, if the input voltage is 3.0V, the converter will generate 3.0/0.00489 = 613.
   The A/D converter used by the PIC18F452 microcontroller has eight channels, named AN0–AN7, which are shared by the PORTA and PORTE pins. Figure 2.41 shows the block diagram of the A/D converter.
   Figure 2.41: Block diagram of the PIC18F452 A/D converter
   The A/D converter has four registers. Registers ADRESH and ADRESL store the higher and lower results of the conversion respectively. Register ADCON0, shown in Figure 2.42, controls the operation of the A/D module, such as selecting the conversion clock together with register ADCON1, selecting an input channel, starting a conversion, and powering up and shutting down the A/D converter.
   Figure 2.42: ADCON0 register
   Register ADCON1 (see Figure 2.43) is used for selecting the conversion format, configuring the A/D channels for analog input, selecting the reference voltage, and selecting the conversion clock together with register ADCON0.
   Figure 2.43: ADCON1 register
   A/D conversion starts by setting the GO/DONE bit of ADCON0. When the conversion is complete, the 2 bits of the converted data is written into register ADRESH, and the remaining 8 bits are written into register ADRESL. At the same time the GO/DONE bit is cleared to indicate the end of conversion. If required, interrupts can be enabled so that a software interrupt is generated when the conversion is complete.
   The steps in carrying out an A/D conversion are as follows:
   • Use ADCON1 to configure required channels as analog and configure the reference voltage.
   • Set the TRISA or TRISE bits so the required channel is an input port.
   • Use ADCON0 to select the required analog input channel.
   • Use ADCON0 and ADCON1 to select the conversion clock.
   • Use ADCON0 to turn on the A/D module.
   • Configure the A/D interrupt (if desired).
   • Set the GO/DONE bit to start conversion.
   • Wait until the GO/DONE bit is cleared, or until a conversion complete interrupt is generated.
   • Read the converted data from ADRESH and ADRESL.
   • Repeat these steps as required.
   For correct A/D conversion, the A/D conversion clock must be selected to ensure a minimum bit conversion time of 1.6μs. Table 2.11 gives the recommended A/D clock sources for various microcontroller operating frequencies. For example, if the microcontroller is operated from a 10MHz clock, the A/D clock source should be F_OSC/16 or higher (e.g., F_OSC/32).
 
   Table 2.11: A/D conversion clock selection

A/D clock source
Operation	ADCS2:ADCS0	Maximum microcontroller frequency
2 TOSC	000	1.25 MHz
4 TOSC	100	2.50 MHz
8 TOSC	001	5.0 MHz
16 TOSC	101	10.0 MHz
32 TOSC	010	20.0 MHz
64 TOSC	110	40.0 MHz
RC	011	–

   Bit ADFM of register ADCON1 controls the format of a conversion. When ADFM is cleared, the 10-bit result is left justified (see Figure 2.44) and lower 6 bits of ADRESL are cleared to 0. When ADFM is set to 1 the result is right justified and the upper 6 bits of ADRESH are cleared to 0. This is the mode most commonly used, in which ADRESL contains the lower 8 bits, and bits 0 and 1 of ADRESH contain the upper 2 bits of the 10-bit result.
   Figure 2.44: Formatting the A/D conversion result

Analog Input Model and Acquisition Time

   An understanding of the A/D analog input model is necessary to interface the A/D to external devices. Figure 2.45 shows the analog input model of the A/D. The analog input voltage V_AIN and the source resistance R_S are shown on the left side of the diagram. It is recommended that the source resistance be no greater than 2.5K. The analog signal is applied to the pin labeled ANx. There is a small capacitance (5pF) and a leakage current to the ground of approximately 500nA. R_IC is the interconnect resistance, which has a value of less than 1K. The sampling process is shown with switch SS having a resistance R_SS whose value depends on the voltage as shown in the small graph at the bottom of Figure 2.45. The value of R_SS is approximately 7K at 5V supply voltage.
   Figure 2.45: Analog input model of the A/D converter
   The A/D converter is based on a switched capacitor principle, and capacitor C_HOLD shown in Figure 2.45 must be charged fully before the start of a conversion. This is a 120pF capacitor which is disconnected from the input pin once the conversion is started.
   The acquisition time can be calculated by using Equation (2.7), provided by Microchip Inc:
   T_ACQ = Amplifier settling time + Holding capacitor charging time + temperature coefficient    (2.7)
   The amplifier settling time is specified as a fixed 2μs. The temperature coefficient, which is only applicable if the temperature is above 25°C, is specified as:
   Temperature coefficient = (Temperature – 25°C)(0.05μs/°C)    (2.8)
   Equation (2.8) shows that the effect of the temperature is very small, creating about 0.5μs delay for every 10°C above 25°C. Thus, assuming a working environment between 25°C and 35°C, the maximum delay due to temperature will be 0.5μs, which can be ignored for most practical applications.
   The holding capacitor charging time as specified by Microchip Inc is:
   Holding capacitor charging time = –(120pF)(1K + R_SS + R_S)Ln(1/2048)    (2.9)
   Assuming that R_SS = 7K, R_S = 2.5K, Equation (2.9) gives the holding capacitor charging time as 9.6μs.
   The acquisition time is then calculated as:
   T_ACQ = 2 + 9.6 + 0.5 = 12.1μs
   A full 10-bit conversion takes 12 A/D cycles, and each A/D cycle is specified at a minimum of 1.6μs. Thus, the fastest conversion time is 19.2μs. Adding this to the best possible acquisition time gives a total time to complete a conversion of 19.2+12.1=31.3μs.
   When a conversion is complete, it is specified that the converter should wait for two conversion periods before starting a new conversion. This corresponds to 2×1.6=3.2μs. Adding this to the best possible conversion time of 31.3μs gives a complete conversion time of 34.5μs. Assuming the A/D converter is used successively, and ignoring the software overheads, this implies a maximum sampling frequency of about 29KHz.

   An interrupt is an event that requires the CPU to stop normal program execution and then execute a program code related to the event causing the interrupt. Interrupts can be generated internally (by some event inside the chip) or externally (by some external event). An example of an internal interrupt is a timer overflowing or the A/D completing a conversion. An example of an external interrupt is an I/O pin changing state.
   Interrupts can be useful in many applications such as:
   • Time critical applications. Applications which require the immediate attention of the CPU can use interrupts. For example, in an emergency such as a power failure or fire in a plant the CPU may have to shut down the system immediately in an orderly manner. In such applications an external interrupt can force the CPU to stop whatever it is doing and take immediate action.
   • Performing routine tasks. Many applications require the CPU to perform routine work at precise times, such as checking the state of a peripheral device exactly every millisecond. A timer interrupt scheduled with the required timing can divert the CPU from normal program execution to accomplish the task at the precise time required.
   • Task switching in multi-tasking applications. In multi-tasking applications, each task may have a finite time to execute its code. Interrupt mechanisms can be used to stop a task should it consume more than its allocated time.
   • To service peripheral devices quickly. Some applications may need to know when a task, such as an A/D conversion, is completed. This can be accomplished by continuously checking the completion flag of the A/D converter. A more elegant solution would be to enable the A/D completion interrupt so the CPU is forced to read the converted data as soon as it becomes available.
   The PIC18F452 microcontroller has both core and peripheral interrupt sources. The core interrupt sources are:
   • External edge-triggered interrupt on INT0, INT1, and INT2 pins.
   • PORTB pins change interrupts (any one of the RB4–RB7 pins changing state)
   • Timer 0 overflow interrupt
   The peripheral interrupt sources are:
   • Parallel slave port read/write interrupt
   • A/D conversion complete interrupt
   • USART receive interrupt
   • USART transmit interrupt
   • Synchronous serial port interrupt
   • CCP1 interrupt
   • TMR1 overflow interrupt
   • TMR2 overflow interrupt
   • Comparator interrupt
   • EEPROM/FLASH write interrupt
   • Bus collision interrupt
   • Low-voltage detect interrupt
   • Timer 3 overflow interrupt
   • CCP2 interrupt
   Interrupts in the PIC18F family can be divided into two groups: high priority and low priority. Applications that require more attention can be placed in the higher priority group. A high-priority interrupt can stop a low-priority interrupt that is in progress and gain access to the CPU. However, high-priority interrupts cannot be stopped by low-priority interrupts. If the application does not need to set priorities for interrupts, the user can choose to disable the priority scheme so all interrupts are at the same priority level. High-priority interrupts are vectored to address 00008H and low-priority ones to address 000018H of the program memory. Normally, a user program code (interrupt service routine, ISR) should be at the interrupt vector address to service the interrupting device.
   In the PIC18F452 microcontroller there are ten registers that control interrupt operations. These are:
   • RCON
   • INTCON
   • INTCON2
   • INTCON3
   • PIR1, PIR2
   • PIE1, PIE2
   • IPR1, IPR2
   Every interrupt source (except INT0) has three bits to control its operation. These bits are:
   • A flag bit to indicate whether an interrupt has occurred. This bit has a name ending in …IF
   • An interrupt enable bit to enable or disable the interrupt source. This bit has the name ending in …IE
   • A priority bit to select high or low priority. This bit has a name ending in …IP

RCON Register

   The top bit of the RCON register, called IPEN, is used to enable the interrupt priority scheme. When IPEN = 0, interrupt priority levels are disabled and the microcontroller interrupt structure is similar to that of the PIC16 series. When IPEN = 1, interrupt priority levels are enabled. Figure 2.46 shows the bits of register RCON.
   Figure 2.46: RCON register bits

Enabling/Disabling Interrupts — No Priority Structure

   When the IPEN bit is cleared, the priority feature is disabled. All interrupts branch to address 00008H of the program memory. In this mode, bit PEIE of register INTCON enables/disables all peripheral interrupt sources. Similarly, bit GIE of INTCON enables/disables all interrupt sources. Figure 2.47 shows the bits of register INTCON.
   Figure 2.47: INTCON register bits
   For an interrupt to be accepted by the CPU the following conditions must be satisfied:
   • The interrupt enable bit of the interrupt source must be enabled. For example, if the interrupt source is external interrupt pin INT0, then bit INT0IE of register INTCON must be set to 1.
   • The interrupt flag of the interrupt source must be cleared. For example, if the interrupt source is external interrupt pin INT0, then bit INT0IF of register INTCON must be cleared to 0.
   • The peripheral interrupt enable/disable bit PEIE of INTCON must be set to 1 if the interrupt source is a peripheral.
   • The global interrupt enable/disable bit GIE of INTCON must be set to 1.
   With an external interrupt source we normally have to define whether the interrupt should occur on the low-to-high or high-to-low transition of the interrupt source. With INT0 interrupts, for example, this is done by setting/clearing bit INTEDG0 of register INTCON2.
   When an interrupt occurs, the CPU stops its normal flow of execution, pushes the return address onto the stack, and jumps to address 00008H in the program memory where the user interrupt service routine program resides. Once the CPU is in the interrupt service routine, the global interrupt enable bit (GIE) is cleared to disable further interrupts. When multiple interrupt sources are enabled, the source of the interrupt can be determined by polling the interrupt flag bits. The interrupt flag bits must be cleared in the software before reenabling interrupts to avoid recursive interrupts. When the CPU has returned from the interrupt service routine, the global interrupt bit GIE is automatically set by the software.

Enabling/Disabling Interrupts — Priority Structure

   When the IPEN bit is set to 1, the priority feature is enabled and the interrupts are grouped into two: low priority and high priority. Low-priority interrupts branch to address 00008H and high-priority interrupts branch to address 000018H of the program memory. Setting the priority bit makes the interrupt source a high-priority interrupt, and clearing this bit makes the interrupt source a low-priority interrupt.
   Setting the GIEH bit of INTCON enables all high-priority interrupts that have the priority bit set. Similarly, setting the GIEL bit of INTCON enables all low-priority interrupts (the priority is bit cleared).
   For a high-priority interrupt to be accepted by the CPU, the following conditions must be satisfied:
   • The interrupt enable bit of the interrupt source must be enabled. For example, if the interrupt source is external interrupt pin INT1, then bit INT1IE of register INTCON3 must be set to 1.
   • The interrupt flag of the interrupt source must be cleared. For example, if the interrupt source is external interrupt pin INT1, then bit INT1IF of register INTCON3 must be cleared to 0.
   • The priority bit must be set to 1. For example, if the interrupt source is external interrupt INT1, then bit INT1P of register INTCON3 must be set to 1.
   • The global interrupt enable/disable bit GIEH of INTCON must be set to 1.
   For a low-priority interrupt to be accepted by the CPU, the following conditions must be satisfied:
   • The interrupt enable bit of the interrupt source must be enabled. For example, if the interrupt source is external interrupt pin INT1, then bit INT1IE of register INTCON3 must be set to 1.
   • The interrupt flag of the interrupt source must be cleared. For example, if the interrupt source is external interrupt pin INT1, then bit INT1IF of register INTCON3 must be cleared to 0.
   • The priority bit must be cleared to 0. For example, if the interrupt source is external interrupt INT1, then bit INT1P of register INTCON3 must be cleared to 0.
   • Low-priority interrupts must be enabled by setting bit GIEL of INTCON to 1.
   • The global interrupt enable/disable bit GIEH of INTCON must be set to 1.
   Table 2.12 gives a listing of the PIC18F452 microcontroller interrupt bit names and register names for every interrupt source.
 
   Table 2.12: PIC18F452 interrupt bits and registers

Interrupt source	Flag bit	Enable bit	Priority bit
INT0 external	INT0IF	INT0IE	–
INT1 external	INT1IF	INT1IE	INT1IP
INT2 external	INT2IF	INT2IE	INT2IP
RB port change	RBIF	RBIE	RBIP
TMR0 overflow	TMR0IF	TMR0IE	TMR0IP
TMR1 overflow	TMR1IF	TMR1IE	TMR1IP
TMR2 match PR2	TMR2IF	TMR2IE	TMR2IP
TMR3 overflow	TMR3IF	TMR3IE	TMR3IP
A/D complete	ADIF	ADIE	ADIP
CCP1	CCP1IF	CCP1IE	CCP1IP
CCP2	CCP2IF	CCP2IE	CCP2IP
USART RCV	RCIF	RCIE	RCIP
USART TX	TXIF	TXIE	TXIP
Parallel slave port	PSPIF	PSPIE	PSPIP
Sync serial port	SSPIF	SSPIE	SSPIP
Low-voltage detect	LVDIF	LVDIE	LVDIP
Bus collision	BCLIF	BCLIE	BCLIP
EEPROM/FLASH write	EEIF	EEIE	EEIP

   Figures 2.48 to 2.55 show the bit definitions of interrupt registers INTCON2, INTCON3, PIR1, PIR2, PIE1, PIE2, IPR1, and IPR2.
   Figure 2.48: INTCON2 bit definitions
   Figure 2.49: INTCON3 bit definitions
   Figure 2.50: PIR1 bit definitions
   Figure 2.51: PIR2 bit definitions
   Figure 2.52: PIE1 bit definitions
   Figure 2.53: PIE2 bit definitions
   Figure 2.54: IPR1 bit definitions
   Figure 2.55: IPR2 bit definitions
   Examples are given in this section to illustrate how the CPU can be programmed for an interrupt.

Example 2.2

   Set up INT1 as a falling-edge triggered interrupt input having low priority.

Solution 2.2

   The following bits should be set up before the INT1 falling-edge triggered interrupts can be accepted by the CPU in low-priority mode:
   • Enable the priority structure. Set IPEN = 1
   • Make INT1 an input pin. Set TRISB = 1
   • Set INT1 interrupts for falling edge. SET INTEDG1 = 0
   • Enable INT1 interrupts. Set INT1IE = 1
   • Enable low priority. Set INT1IP = 0
   • Clear INT1 flag. Set INT1IF = 0
   • Enable low-priority interrupts. Set GIEL = 1
   • Enable all interrupts. Set GIEH = 1
   When an interrupt occurs, the CPU jumps to address 00008H in the program memory to execute the user program at the interrupt service routine.

Example 2.3

   Set up INT1 as a rising-edge triggered interrupt input having high priority.

Solution 2.3

   The following bits should be set up before the INT1 rising-edge triggered interrupts can be accepted by the CPU in high-priority mode:
   • Enable the priority structure. Set IPEN = 1
   • Make INT1 an input pin. Set TRISB = 1
   • Set INT1 interrupts for rising edge. SET INTEDG1 = 1
   • Enable INT1 interrupts. Set INT1IE = 1
   • Enable high priority. Set INT1IP = 1
   • Clear INT1 flag. Set INT1IF = 0
   • Enable all interrupts. Set GIEH = 1
   When an interrupt occurs, the CPU jumps to address 000018H of the program memory to execute the user program at the interrupt service routine.

   Figure 3.1 shows the simplest structure of a mikroC program. This program flashes an LED connected to port RB0 (bit 0 of PORTB) of a PIC microcontroller in one-second intervals. Do not worry if you don’t understand the operation of the program at this stage, as all will come clear as this chapter progresses. Some of the programming elements in Figure 3.1 are described in detail here.
   /********************************************************************
                           LED FLASHING PROGRAM
                    *********************************
   This program flashes an LED connected to port pin RB0 of PORTB with
    one second intervals.
   Programmer : D. Ibrahim
   File       : LED.C
   Date       : May, 2007
   Micro      : PIC18F452
   **********************************************************************/
   void main() {
    for(;;) // Endless loop
    {
     TRISB = 0; // Configure PORTB as output
     PORTB.0 = 0; // RB0 = 0
     Delay_Ms(1000); // Wait 1 second
     PORTB.0 = 1; // RB0 = 1
     Delay_Ms(1000); // Wait 1 second
    } // End of loop
   }
   Figure 3.1: Structure of a simple C program

   Comments are used to clarify the operation of the program or a programming statement. Comment lines are ignored and not compiled by the compiler. In mikroC programs comments can be of two types: long comments, extending several lines, and short comments, occupying only a single line. Comment lines at the beginning of a program can describe briefly the program’s operation and provide the author’s name, the program filename, the date the program was written, and a list of version numbers, together with the modifications in each version. As shown in Figure 3.1, comments can also be added after statements to describe the operations that the statements perform. Clear and succinct comment lines are important for the maintenance and thus the lifetime of a program, as a program with good comments is easier to modify and/or update.
   As shown in Figure 3.1, long comments start with the character “/*” and terminate with the character “*/”. Similarly, short comments start with the character “//” and do not need a terminating character.

   In C language, a program begins with the keywords:
   void main()
   After this, a curly opening bracket is used to indicate the beginning of the program body. The program is terminated with a closing curly bracket. Thus, as shown in Figure 3.1, the program has the following structure:
   void main() {
    program body
   }

   In C language, all program statements must be terminated with the semicolon (“;”) character; otherwise a compiler error will be generated:
   j = 5; // correct
   j = 5 // error

   White spaces are spaces, blanks, tabs, and newline characters. The C compiler ignores all white spaces. Thus, the following three sequences are identical:
   int i;  char j;
   or
   int i;
   char j;
   or
   int i;
         char j;
   Similarly, the following sequences are identical:
   i = j + 2;
   or
   i = j
        + 2;

   In general, C language is case sensitive and variables with lowercase names are different from those with uppercase names. Currently, however, mikroC variables are not case sensitive (although future releases of mikroC may offer case sensitivity) so the following variables are equivalent:
   total TOTAL Total ToTal total totaL
   The only exception is the identifiers main and interrupt, which must be written in lowercase in mikroC. In this book we are assuming that the variables are case sensitive, for the sake of compatibility with other C compilers, and variables with the same name but different cases are not used.

   In C language, variable names can begin with an alphabetical character or with the underscore character. In essence, variable names can include any of the characters a to z and A to Z, the digits 0 to 9, and the underscore character “_”. Each variable name should be unique within the first 31 characters of its name. Variable names can contain uppercase and lowercase characters (see Section 3.1.5), and numeric characters can be used inside a variable name. Examples of valid variable names are:
   Sum count sum100 counter i1 UserName
   _myName
   Some names are reserved for the compiler itself and cannot be used as variable names in a program. Table 3.1 gives a list of these reserved names.
 
   Table 3.1: mikroC reserved names

asm	enum	signed
auto	extern	sizeof
break	float	static
case	for	struct
char	goto	switch
const	if	typedef
continue	int	union
default	long	unsigned
do	register	void
double	return	volatile
else	short	while

   The mikroC language supports the variable types shown in Table 3.2. Examples of variables are given in this section.
 
   Table 3.2: mikroC variable types

Type	Size (bits)	Range
unsigned char	8	0 to 255
unsigned short int	8	0 to 255
unsigned int	16	0 to 65535
unsigned long int	32	0 to 4294967295
signed char	8	–128 to 127
signed short int	8	–128 to 127
signed int	16	–32768 to 32767
signed long int	32	–2147483648 to 2147483647
float	32	±1.17549435082E-38 to ±6.80564774407E38
double	32	±1.17549435082E-38 to ±6.80564774407E38
long double	32	±1.17549435082E-38 to ±6.80564774407E38

(unsigned) char or unsigned short (int)

   The variables (unsigned) char, or unsigned short (int), are 8-bit unsigned variables with a range of 0 to 255. In the following example two 8-bit variables named total and sum are created, and sum is assigned decimal value 150:
   unsigned char total, sum;
   sum = 150;
   or
   char total, sum;
   sum = 150;
   Variables can be assigned values during their declaration. Thus, the above statements can also be written as:
   char total, sum = 150;

signed char or (signed) short (int)

   The variables signed char, or (signed) short (int), are 8-bit signed character variables with a range of –128 to +127. In the following example a signed 8-bit variable named counter is created with a value of –50:
   signed char counter = -50;
   or
   short counter = -50;
   or
   short int counter = -50;

(signed) int

   Variables called (signed) int are 16-bit variables with a range –32768 to +32767. In the following example a signed integer named Big is created:
   int Big;

unsigned (int)

   Variables called (unsigned) int are 16-bit unsigned variables with a range 0 to 65535. In the following example an unsigned 16-bit variable named count is created and is assigned value 12000:
   unsigned int count = 12000;

(signed) long (int)

   Variables called (signed) long (int) are 32 bits long with a range –2147483648 to +2147483647. An example is:
   signed long LargeNumber;

unsigned long (int)

   Variables called (unsigned) long (int) are 32-bit unsigned variables having the range 0 to 4294967295. An example is:
   unsigned long VeryLargeNumber;

float or double or long double

   The variables called float or double or long double, are floating point variables implemented in mikroC using the Microchip AN575 32-bit format, which is IEEE 754 compliant. Floating point numbers range from ±1.17549435082E-38 to ±6.80564774407E38. In the following example, a floating point variable named area is created and assigned the value 12.235:
   float area;
   area = 12.235;
   To avoid confusion during program development, specifying the sign of the variable (signed or unsigned) as well as the type of variable is recommended. For example, use unsigned char instead of char only, and unsigned int instead of unsigned only.
   In this book we are using the following mikroC data types, which are easy to remember and also compatible with most other C compilers:

unsigned char	0 to 255
signed char	–128 to 127
unsigned int	0 to 65535
signed int	–32768 to 32767
unsigned long	0 to 4294967295
signed long	–2147483648 to 2147483647
float	±1.17549435082E-38 to ±6.80564774407E38

   Constants represent fixed values (numeric or character) in programs that cannot be changed. Constants are stored in the flash program memory of the PIC microcontroller, thus not wasting valuable and limited RAM memory. In mikroC, constants can be integers, floating points, characters, strings, or enumerated types.

Integer Constants

   Integer constants can be decimal, hexadecimal, octal, or binary. The data type of a constant is derived by the compiler from its value. But suffixes can be used to change the type of a constant.
   In Table 3.2 we saw that decimal constants can have values from –2147483648 to +4294967295. For example, constant number 210 is stored as an unsigned char (or unsigned short int). Similarly, constant number –200 is stored as a signed int.
   Using the suffix u or U forces the constant to be unsigned. Using the suffix L or l forces the constant to be long. Using both U (or u) and L (or l) forces the constant to be unsigned long.
   Constants are declared using the keyword const and are stored in the flash program memory of the PIC microcontroller, thus not wasting valuable RAM space. In the following example, constant MAX is declared as 100 and is stored in the flash program memory of the PIC microcontroller:
   const MAX = 100;
   Hexadecimal constants start with characters 0x or 0X and may contain numeric data 0 to 9 and hexadecimal characters A to F. In the following example, constant TOTAL is given the hexadecimal value FF:
   const TOTAL = 0xFF;
   Octal constants have a zero at the beginning of the number and may contain numeric data 0 to 7. In the following example, constant CNT is given octal value 17:
   const CNT = 017;
   Binary constant numbers start with 0b or 0B and may contain only 0 or 1. In the following example a constant named Min is declared as having the binary value 11110000:
   const Min = 0b11110000

Floating Point Constants

   Floating point constant numbers have integer parts, a dot, a fractional part, and an optional e or E followed by a signed integer exponent. In the following example, a constant named TEMP is declared as having the fractional value 37.50:
   const TEMP = 37.50
   or
   const TEMP = 3.750E1

Character Constants

   A character constant is a character enclosed within single quote marks. In the following example, a constant named First_Alpha is declared as having the character value “A”:
   const First_Alpha = 'A';

String Constants

   String constants are fixed sequences of characters stored in the flash memory of the microcontroller. The string must both begin and terminate with a double quote character (“). The compiler automatically inserts a null character as a terminator. An example string constant is:
   "This is an example string constant"
   A string constant can be extended across a line boundary by using a backslash character (“\”):
   "This is first part of the string \
   and this is the continuation of the string"
   This string constant declaration is the same as:
   "This is first part of the string and this is the continuation of the string"

Enumerated Constants

   Enumerated constants are integer type and are used to make a program easier to follow. In the following example, constant colors stores the names of colors. The first element is given the value 0:
   enum colors {black, brown, red, orange, yellow, green, blue, gray, white};

   Escape sequences are used to represent nonprintable ASCII characters. Table 3.3 shows some commonly used escape sequences and their representation in C language. For example, the character combination “\n” represents the newline character.
 
   Table 3.3: Some commonly used escape sequences

Escape sequence	Hex value	Character
\a	0x07	BEL (bell)
\b	0x08	BS (backspace)
\t	0x09	HT (horizontal tab)
\n	0x0A	LF (linefeed)
\v	0x0B	VT (vertical feed)
\f	0x0C	FF (formfeed)
\r	0x0D	CR (carriage return)
\xH		String of hex digits

   An ASCII character can also be represented by specifying its hexadecimal code after a backslash. For example, the newline character can also be represented as “\x0A”.

   Static variables are local variables used in functions (see Chapter 4) when the last value of a variable between successive calls to the function must be preserved. As the following example shows, static variables are declared using the keyword static:
   static unsigned int count;

   Using the keyword extern before a variable name declares that variable as external. It tells the compiler that the variable is declared elsewhere in a separate source code module. In the following example, variables sum1 and sum2 are declared as external unsigned integers:
   extern int sum1, sum2;

   Volatile variables are especially important in interrupt-based programs and input-output routines. Using the keyword volatile indicates that the value of the variable may change during the lifetime of the program independent of the normal flow of the program. Variables declared as volatile are not optimized by the compiler, since their values can change unexpectedly. In the following example, variable Led is declared as a volatile unsigned char:
   volatile unsigned char Led;

   Enumerated variables are used to make a program more readable. In an enumerated variable, a list of items is specified and the value of the first item is set to 0, the next item is set to 1, and so on. In the following example, type Week is declared as an enumerated list and MON = 0, TUE = 1, WED = 2, and so on):
   enum Week {MON, TUE, WED, THU, FRI, SAT, SUN};
   It is possible to imply the values of the elements in an enumerated list. In the following example, black = 2, blue = 3, red = 4, and so on.
   enum colors {black = 2, blue, red, white, gray};
   Similarly, in the following example, black = 2, blue = 3, red = 8, and gray = 9:
   enum colors {black = 2, blue, red = 8, gray};
   Variables of type enumeration can be declared by specifying them after the list of items. For example, to declare variable My_Week of enumerated type Week, use the following statement:
   enum Week {MON, TUE, WED, THU, FRI, SAT, SUN} My_Week;
   Now we can use variable My_Week in a program:
   My_Week = WED // assign 2 to My_Week
   or
   My_Week = 2 // same as above
   After defining the enumerated type Week, we can declare variables This_Week and Next_Week of type Week as:
   enum Week This_Week, Next_Week;

   Arrays are used to store related items in the same block of memory and under a specified name. An array is declared by specifying its type, name, and the number of elements it will store. For example:
   unsigned int Total[5];
   This array of type unsigned int has the name Total and has five elements. The first element of an array is indexed with 0. Thus, in this example, Total[0] refers to the first element of the array and Total[4] refers to the last element. The array Total is stored in memory in five consecutive locations as follows:

Total[0]

Total[1]

Total[2]

Total[3]

Total[4]

   Data can be stored in the array by specifying the array name and index. For example, to store 25 in the second element of the array we have to write:
   Total[1] = 25;
   Similarly, the contents of an array can be read by specifying the array name and its index. For example, to copy the third array element to a variable called Temp we have to write:
   Temp = Total[2];
   The contents of an array can be initialized during the declaration of the array by assigning a sequence of comma-delimited values to the array. An example follows where array months has twelve elements and months[0] = 31, months[1] = 28, and so on:
   unsigned char months[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
   The same array can also be declared without specifying its size:
   unsigned char months[] = {31,28,31,30,31,30,31,31,30,31,30,31};
   Character arrays can be declared similarly. In the following example, a character array named Hex_Letters is declared with 6 elements:
   unsigned char Hex_Letters[] = {'A', 'B', 'C', 'D', 'E', 'F'};
   Strings are character arrays with a null terminator. Strings can be declared either by enclosing the string in double quotes, or by specifying each character of the array within single quotes and then terminating the string with a null character. The two string declarations in the following example are identical, and both occupy five locations in memory:
   unsigned char Mystring[] = "COMP";
   and
   unsigned char Mystring[] = {'C', 'O', 'M', 'P', '\0'};
   In C programming language, we can also declare arrays with multiple dimensions. One-dimensional arrays are usually called vectors, and two-dimensional arrays are called matrices. A two-dimensional array is declared by specifying the data type of the array, the array name, and the size of each dimension. In the following example, a two-dimensional array named P is created having three rows and four columns. Altogether, the array has twelve elements. The first element of the array is P[0][0], and the last element is P[2][3]. The structure of this array is shown below:

P[0][0]	P[0][1]	P[0][2]	P[0][3]
P[1][0]	P[1][1]	P[1][2]	P[1][3]
P[2][0]	P[2][1]	P[2][2]	P[2][3]

   Elements of a multidimensional array can be specified during the declaration of the array. In the following example, two-dimensional array Q has two rows and two columns, its diagonal elements are set to 1, and its nondiagonal elements are cleared to 0:
   unsigned char Q[2][2] = { {1,0}, {0,1} };

   Pointers are an important part of the C language, as they hold the memory addresses of variables. Pointers are declared in the same way as other variables, but with the character (“*”) in front of the variable name. In general, pointers can be created to point to (or hold the addresses of) character variables, integer variables, long variables, floating point variables, or functions (although mikroC currently does not support pointers to functions).
   In the following example, an unsigned character pointer named pnt is declared:
   unsigned char *pnt;
   When a new pointer is created, its content is initially unspecified and it does not hold the address of any variable. We can assign the address of a variable to a pointer using the (“&”) character:
   pnt = &Count;
   Now pnt holds the address of variable Count. Variable Count can be set to a value by using the character (“*”) in front of its pointer. For example, Count can be set to 10 using its pointer:
   *pnt = 10; // Count = 10
   which is the same as
   Count = 10; // Count = 10
   Or, the value of Count can be copied to variable Cnt using its pointer:
   Cnt = *pnt; // Cnt = Count

Array Pointers

   In C language the name of an array is also a pointer to the array. Thus, for the array:
   unsigned int Total[10];
   The name Total is also a pointer to this array, and it holds the address of the first element of the array. Thus the following two statements are equal:
   Total[2] = 0;
   and
   *(Total + 2) = 0;
   Also, the following statement is true:
   &Total[j] = Total + j
   In C language we can perform pointer arithmetic which may involve:
   • Comparing two pointers
   • Adding or subtracting a pointer and an integer value
   • Subtracting two pointers
   • Assigning one pointer to another
   • Comparing a pointer to null
   For example, let’s assume that pointer P is set to hold the address of array element Z[2]:
   P = &Z[2];
   We can now clear elements 2 and 3 of array Z, as in the two examples that follow. The two examples are identical except that in the first example pointer P holds the address of Z[3] at the end of the statements, and it holds the address of Z[2] at the end of the second set of statements:
   *P = 0;    // Z[2] = 0
   P = P + 1; // P now points to element 3 of Z
   *P = 0;    // Z[3] = 0
   or
   *P = 0;       // Z[2] = 0
   *(P + 1) = 0; // Z[3] = 0
   A pointer can be assigned to another pointer. In the following example, variables Cnt and Tot are both set to 10 using two different pointers:
   unsigned int *i, *j;   // declare 2 pointers
   unsigned int Cnt, Tot; // declare two variables
   i = Cnt;               // i points to Cnt
   *i = 10;               // Cnt = 10
   j = i;                 // copy pointer i to pointer j
   Tot = *j;              // Tot = 10

   A structure can be used to collect related items that are then treated as a single object. Unlike an array, a structure can contain a mixture of data types. For example, a structure can store the personal details (name, surname, age, date of birth, etc.) of a student.
   A structure is created by using the keyword struct, followed by a structure name and a list of member declarations. Optionally, variables of the same type as the structure can be declared at the end of the structure.
   The following example declares a structure named Person:
   struct Person {
    unsigned char name[20];
    unsigned char surname[20];
    unsigned char nationality[20];
    unsigned char age;
   }
   Declaring a structure does not occupy any space in memory; rather, the compiler creates a template describing the names and types of the data objects or member elements that will eventually be stored within such a structure variable. Only when variables of the same type as the structure are created do these variables occupy space in memory. We can declare variables of the same type as the structure by giving the name of the structure and the name of the variable. For example, two variables Me and You of type Person can be created by the statement:
   struct Person Me, You;
   Variables of type Person can also be created during the declaration of the structure as follows:
   struct Person {
   unsigned char name[20];
   unsigned char surname[20];
   unsigned char nationality[20];
   unsigned char age;
   } Me, You;
   We can assign values to members of a structure by specifying the name of the structure, followed by a dot (“.”) and the name of the member. In the following example, the age of structure variable Me is set to 25, and variable M is assigned to the value of age in structure variable You:
   Me.age = 25;
   M = You.age;
   Structure members can be initialized during the declaration of the structure. In the following example, the radius and height of structure Cylinder are initialized to 1.2 and 2.5 respectively:
   struct Cylinder {
    float radius;
    float height;
   } MyCylinder = {1.2, 2.5};
   Values can also be set to members of a structure using pointers by defining the variable types as pointers. For example, if TheCylinder is defined as a pointer to structure Cylinder, then we can write:
   struct Cylinder {
    float radius;
    float height;
   } *TheCylinder;
 
   TheCylinder->radius = 1.2;
   TheCylinder->height = 2.5;
   The size of a structure is the number of bytes contained within the structure. We can use the sizeof operator to get the size of a structure. Considering the above example,
   sizeof(MyCylinder)
   returns 8, since each float variable occupies 4 bytes in memory.
   Bit fields can be defined using structures. With bit fields we can assign identifiers to bits of a variable. For example, to identify bits 0, 1, 2, and 3 of a variable as LowNibble and to identify the remaining 4 bits as HighNibble we can write:
   struct {
    LowNibble  : 4;
    HighNibble : 4;
   } MyVariable;
   We can then access the nibbles of variable MyVariable as:
   MyVariable.LowNibble = 12;
   MyVariable.HighNibble = 8;
   In C language we can use the typedef statements to create new types of variables. For example, a new structure data type named Reg can be created as follows:
   typedef struct {
    unsigned char name[20];
    unsigned char surname[20];
    unsigned age;
   } Reg;
   Variables of type Reg can then be created in the same way other types of variables are created. In the following example, variables MyReg, Reg1, and Reg2 are created from data type Reg:
   Reg MyReg, Reg1, Reg2;
   The contents of one structure can be copied to another structure, provided that both structures are derived from the same template. In the following example, structure variables of the same type, P1 and P2, are created, and P2 is copied to P1:
   struct Person {
    unsigned char name[20];
    unsigned char surname[20];
    unsigned int age;
    unsigned int height;
    unsigned weight;
   }
   struct Person P1, P2;
   ........................
   ........................
   P2 = P1;

   Unions are used to overlay variables. A union is similar to a structure and is even defined in a similar manner. Both are based on templates, and the members of both are accessed using the “.” or “->” operators. A union differs from a structure in that all variables in a union occupy the same memory area, that is, they share the same storage. An example of a union declaration is:
   union flags {
    unsigned char x;
    unsigned int y;
   } P;
   In this example, variables x and y occupy the same memory area, and the size of this union is 2 bytes long, which is the size of the biggest member of the union. When variable y is loaded with a 2-byte value, variable x will have the same value as the low byte of y. In the following example, y is loaded with 16-bit hexadecimal value 0xAEFA, and x is loaded with 0xFA:
   P.y = 0xAEFA;
   The size of a union is the size (number of bytes) of its largest member. Thus, the statement:
   sizeof(P)
   returns 2.
   This union can also be declared as:
   union flags {
    unsigned char x;
    unsigned int y;
   }
   union flags P;

   Operators are applied to variables and other objects in expressions to cause certain conditions or computations to occur.
   mikroC language supports the following operators:
   • Arithmetic operators
   • Relational operators
   • Logical operators
   • Bitwise operators
   • Assignment operators
   • Conditional operators
   • Preprocessor operators
   • Arithmetic Operators
   Arithmetic operators are used in arithmetic computations. Arithmetic operators associate from left to right, and they return numerical results. The mikroC arithmetic operators are listed in Table 3.4.
 
   Table 3.4: mikroC arithmetic operators

Operator	Operation
+	Addition
-	Subtraction
*	Multiplication
/	Division
%	Remainder (integer division)
++	Auto increment
-	Auto decrement

   The following example illustrates the use of arithmetic operators:
   /* Adding two integers */
   5 + 12 // equals 17
 
   /* Subtracting two integers */
   120 – 5 // equals 115
   10 – 15 // equals -5
 
   /* Dividing two integers */
   5 / 3  // equals 1
   12 / 3 // equals 4
 
   /* Multiplying two integers */
   3 * 12 // equals 36
 
   /* Adding two floating point numbers */
   3.1 + 2.4 // equals 5.5
 
   /* Multiplying two floating point numbers */
   2.5 * 5.0 // equals 12.5
 
   /* Dividing two floating point numbers */
   25.0 / 4.0 // equals 6.25
 
   /* Remainder (not for float) */
   7 % 3 // equals 1
 
   /* Post-increment operator */
   j = 4;
   k = j++; // k = 4, j = 5
 
   /* Pre-increment operator */
   j = 4;
   k = ++j; // k = 5, j = 5
 
   /* Post-decrement operator */
   j = 12;
   k = j--; // k = 12, j = 11
 
   /* Pre-decrement operator */
   j = 12;
   k = --j; // k = 11, j = 11

Relational Operators

   Relational operators are used in comparisons. If the expression evaluates to TRUE, a 1 is returned; otherwise a 0 is returned.
   All relational operators associate from left to right. A list of mikroC relational operators is given in Table 3.5.
 
   Table 3.5: mikroC relational operators

Operator	Operation
==	Equal to
!=	Not equal to
>	Greater than
<	Less than
>=	Greater than or equal to
<=	Less than or equal to

   The following example illustrates the use of relational operators:
   x = 10
   x > 8   // returns 1
   x == 10 // returns 1
   x < 100 // returns 1
   x > 20  // returns 0
   x != 10 // returns 0
   x >= 10 // returns 1
   x <= 10 // returns 1

Logical Operators

   Logical operators are used in logical and arithmetic comparisons, and they return TRUE (i.e., logical 1) if the expression evaluates to nonzero, and FALSE (i.e., logical 0) if the expression evaluates to zero. If more than one logical operator is used in a statement, and if the first condition evaluates to FALSE, the second expression is not evaluated. The mikroC logical operators are listed in Table 3.6.
 
   Table 3.6: mikroC logical operators

Operator	Operation
&&	AND
||	OR
!	NOT

   The following example illustrates the use of logical operators:
   /* Logical AND */
   x = 7;
 
   x > 0 && x < 10   // returns 1
   x > 0 || x < 10   // returns 1
   x >= 0 && x <= 10 // returns 1
   x >= 0 && x < 5   // returns 0
 
   a = 10; b = 20; c = 30; d = 40;
   a > b && c > d // returns 0
   b > a && d > c // returns 1
   a > b || d > c // returns 1

Bitwise Operators

   Bitwise operators are used to modify the bits of a variable. The mikroC bitwise operators are listed in Table 3.7.
 
   Table 3.7: mikroC bitwise operators

Operator	Operation
&	Bitwise AND
|	Bitwise OR
^	Bitwise EXOR
$	Bitwise complement
<<	Shift left
>>	Shift right

   Bitwise AND returns 1 if both bits are 1, otherwise it returns 0.
   Bitwise OR returns 0 if both bits are 0, otherwise it returns 1.
   Bitwise XOR returns 1 if both bits are complementary, otherwise it returns 0.
   Bitwise complement inverts each bit.
   Bitwise shift left and shift right move the bits to the left or right respectively.
   The following example illustrates the use of bitwise operators:
      i. 0xFA 0xEE returns 0xEA
         0xFA: 1111 1010
         0xEE: 1110 1110
         - - - - - - - -
         0xEA: 1110 1010
     ii. 0x01 | 0xFE returns 0xFF
         0x01: 0000 0001
         0xFE: 1111 1110
         - - - - - - - -
         0xFE: 1111 1111
    iii. 0xAA ^ 0x1F returns
         0xAA: 1010 1010
         0x1F: 0001 1111
         - - - - - - - -
         0xB5: 1011 0101
     iv. ~0xAA returns 0x55
         0xAA: 1010 1010
         ~ :   0101 0101
         - - - - - - - -
         0x55: 0101 0101
      v. 0x14 >> 1 returns 0x0A (shift 0x14 right by 1 digit)
         0x14: 0001 0100
         >> 1: 0000 1010
         - - - - - - - -
         0x0A: 0000 1010
     vi. 0x14 >> 2 returns 0x05 (shift 0x14 right by 2 digits)
         0x14: 0001 0100
         >> 2: 0000 0101
         - - - - - - - -
         0x05: 0000 0101
    vii. 0x235A << 1 returns 0x46B4 (shift left 0x235A left by 1 digit)
         0x235A: 0010 0011 0101 1010
         << 1 :  0100 0110 1011 0100
         - - - - - - - - - - - - - -
         0x46B4: 0100 0110 1011 0100
   viii. 0x1A << 3 returns 0xD0 (shift left 0x1A by 3 digits)
         0x1A: 0001 1010
         << 3: 1101 0000
         - - - - - - - -
         0xD0: 1101 0000

Assignment Operators

   In C language there are two types of assignments: simple and compound. In simple assignments an expression is simply assigned to another expression, or an operation is performed using an expression and the result is assigned to another expression:
   Expression1 = Expression2
   or
   Result = Expression1 operation Expression2
   Examples of simple assignments are:
   Temp = 10;
   Cnt = Cnt + Temp;
   Compound assignments have the general format:
   Result operation = Expression1
   Here the specified operation is performed on Expression1 and the result is stored in Result. For example:
   j += k;
   is same as:
   j = j + k;
   also
   p *= m;
   is same as
   p = p * m;
   The following compound operators can be used in mikroC programs:
   += -= *= /=  %=
   &= |= ^= >>= <<=

Conditional Operators

   The syntax of a conditional operator is:
   Result = Expression1 ? Expression2 : Expression3
   Expression1 is evaluated first, and if its value is true, Expression2 is assigned to Result, otherwise Expression3 is assigned to Result. In the following example, the maximum of x and y is found where x is compared with y and if x y then max = x, otherwise max = y:
   max = (x > y) ? x : y;
   In the following example, lowercase characters are converted to uppercase. If the character is lowercase (between a and z), then by subtracting 32 from the character we obtain the equivalent uppercase character:
   c = (c >= a && c <= z) ? (c - 32) : c;

Preprocessor Operators

   The preprocessor allows a programmer to:
   • Compile a program conditionally, such that parts of the code are not compiled
   • Replace symbols with other symbols or values
   • Insert text files into a program
   The preprocessor operator is the (“#”) character, and any line of code leading with a (“#”) is assumed to be a preprocessor command. The semicolon character (“;”) is not needed to terminate a preprocessor command.
   mikroC compiler supports the following preprocessor commands:
   #define #undef
   #if     #elif  #endif
   #ifdef  #ifndef
   #error
   #line
   #define, #undef, #ifdef, #ifndef  The #define preprocessor command provides macro expansion where every occurrence of an identifier in the program is replaced with the value of that identifier. For example, to replace every occurrence of MAX with value 100 we can write:
   #define MAX 100
   An identifier that has already been defined cannot be defined again unless both definitions have the same value. One way to get around this problem is to remove the macro definition:
   #undef MAX
   Alternatively, the existence of a macro definition can be checked. In the following example, if MAX has not already been defined, it is given value 100, otherwise the #define line is skipped:
   #ifndef MAX
    #define MAX 100
   #endif
   Note that the #define preprocessor command does not occupy any space in memory. We can pass parameters to a macro definition by specifying the parameters in a parenthesis after the macro name. For example, consider the macro definition:
   #define ADD(a, b) (a + b)
   When this macro is used in a program, ADD(a, b) will be replaced with (a + b) as shown:
   p = ADD(x, y)
   will be transformed into
   p = (x + y)
   Similarly, we can define a macro to calculate the square of two numbers:
   #define SQUARE(a) (a * a)
   We can now use this macro in a program:
   p = SQUARE(x)
   will be transformed into
   p = (x * x)
   #include  The preprocessor directive #include is used to include a source file in our program. Usually header files with extension “.h” are used with #include. There are two formats for using #include:
   #include <file>
   and
   #include "file"
   In first option the file is searched in the mikroC installation directory first and then in user search paths. In second option the specified file is searched in the mikroC project folder, then in the mikroC installation folder, and then in user search paths. It is also possible to specify a complete directory path as:
   #include "C:\temp\last.h"
   The file is then searched only in the specified directory path.
   #if, #elif, #else, #endif  The preprocessor commands #if, #elif, #else, and #endif are used for conditional compilations, where parts of the source code can be compiled only if certain conditions are met. In the following example, the code section where variables A and B are cleared to zero is compiled if M has a nonzero value, otherwise the code section where A and B are both set to 1 is compiled. Notice that the #if must be terminated with #endif:
   #if M
    A = 0;
    B = 0;
   #else
    A = 1;
    B = 1;
   #endif
   We can also use the #elif condition, which tests for a new condition if the previous condition was false:
   #if M
    A = 0;
    B = 0;
   #elif N
    A = 1;
    B = 1;
   #else
    A = 2;
    B = 2;
   #endif
   In the above example, if M has a nonzero value code section, A = 0; B = 0; are compiled. Otherwise, if N has a nonzero value, then code section A = 1; B = 1; is compiled. Finally, if both M and N are zero, then code section A = 2; B = 2; is compiled. Notice that only one code section is compiled between #if and #endif and that a code section can contain any number of statements.

   Statements are normally executed sequentially from the beginning to the end of a program. We can use control statements to modify this normal sequential flow in a C program. The following control statements are available in mikroC programs:
   • Selection statements
   • Unconditional modifications of flow
   • Iteration statements

Selection Statements

   There are two selection statements: if and switch.
   if Statement The general format of the if statement is:
   if (expression)
    Statement1;
   else
    Statement2;
   or
   if (expression) Statement1; else Statement2;
   If the expression evaluates to TRUE, Statement1 is executed, otherwise Statement2 is executed. The else keyword is optional and may be omitted. In the following example, if the value of x is greater than MAX then variable P is incremented by 1, otherwise it is decremented by 1:
   if (x > MAX) P++;
   else P--;
   We can have more than one statement by enclosing the statements within curly brackets. For example:
   if (x > MAX) {
    P++;
    Cnt = P;
    Sum = Sum + Cnt;
   } else P--;
   In this example, if x is greater than MAX then the three statements within the curly brackets are executed, otherwise the statement P-- is executed. Another example using the if statement is:
   if (x > 0 && x < 10) {
    Total += Sum;
    Sum++;
   } else {
    Total = 0;
    Sum = 0;
   }
   switch Statement  The switch statement is used when a number of conditions and different operations are performed if a condition is true. The syntax of the switch statement is:
   switch (condition) {
   case condition1:
    Statements;
   break;
   case condition2:
    Statements;
    break;
   .....................
   .....................
   case condition:
    Statements;
    break;
   default:
    Statements;
   }
   The switch statement functions as follows: First the condition is evaluated. The condition is then compared to condition1 and if a match is found, statements in that case block are evaluated and control jumps outside the switch statement when the break keyword is encountered. If a match is not found, condition is compared to condition2 and if a match is found, statements in that case block are evaluated and control jumps outside the switch statements, and so on. The default is optional, and statements following default are evaluated if the condition does not match any of the conditions specified after the case keywords.
   In the following example, the value of variable Cnt is evaluated. If Cnt = 1, A is set to 1. If Cnt = 10, B is set to 1, and if Cnt = 100, C is set to 1. If Cnt is not equal to 1, 10, or 100 then D is set to 1:
   switch (Cnt) {
   case 1:
    A = 1;
    break;
   case 10:
    B = 1;
    break;
   case 100:
    C = 1;
    break;
   default:
    D = 1;
   }
   Because white spaces are ignored in C language we can also write the preceding code as:
   switch (Cnt) {
   case 1:
    A = 1;
    break;
   case 10:
    B = 1;
    break;
   case 100:
    C = 1;
    break;
   default:
    D = 1;
   }

Example 3.1

   In an experiment the relationship between X and Y values are found to be:
   X Y
   1 3.2
   2 2.5
   3 8.9
   4 1.2
   5 12.9
   Write a switch statement that will return the Y value, given the X value.

Solution 3.1

   The required switch statement is:
   switch (X) {
   case 1:
    Y = 3.2;
    break;
   case 2:
    Y = 2.5;
    break;
   case 3:
    Y = 8.9;
    break;
   case 4:
    Y = 1.2;
    break;
   case 5:
    Y = 12.9;
   }

Iteration Statements

   Iteration statements enable us to perform loops in a program, where part of a code must be repeated a number of times. In mikroC iteration can be performed in four ways. We will look at each one with examples:
   • Using for statement
   • Using while statement
   • Using do statement
   • Using goto statement
   for Statement  The syntax of a for statement is:
   for(initial expression; condition expression; increment expression) {
    Statements;
   }
   The initial expression sets the starting variable of the loop, and this variable is compared against the condition expression before entry into the loop. Statements inside the loop are executed repeatedly, and after each iteration the value of the increment expression is incremented. The iteration continues until the condition expression becomes false. An endless loop is formed if the condition expression is always true.
   The following example shows how a loop can be set up to execute 10 times. In this example, variable i starts from 0 and increments by 1 at the end of each iteration. The loop terminates when i=10, in which case the condition i<10 becomes false. On exit from the loop, the value of i is 10:
   for(i = 0; i < 10; i++) {
    statements;
   }
   This loop could also be started by an initial expression with a nonzero value. Here, i starts with 1 and the loop terminates when i = 11. Thus, on exit from the loop, the value of i is 11:
   for(i = 1; i <= 10; i++) {
    Statements;
   }
   The parameters of a for loop are all optional and can be omitted. If the condition expression is left out, it is assumed to be true. In the following example, an endless loop is formed where the condition expression is always true and the value of i starts with 0 and is incremented after each iteration:
   /* Endless loop with incrementing i */
   for(i=0; ; i++) {
    Statements;
   }
   In the following example of an endless loop all the parameters are omitted:
   /* Example of endless loop */
   for(; ;) {
    Statements;
   }
   In the following endless loop, i starts with 1 and is not incremented inside the loop:
   /* Endless loop with i = 1 */
   for(i=1; ;) {
    Statements;
   }
   If there is only one statement inside the for loop, he curly brackets can be omitted as shown in the following example:
   for(k = 0; k < 10; k++)Total  = Total + Sum;
   Nested for loops can also be used. In a nested for loop, the inner loop is executed for each iteration of the outer loop. In the following example the inner loop is executed five times and the outer loop is executed ten times. The total iteration count is fifty:
   /* Example of nested for loops */
   for(i = 0; i < 10; i++) {
    for(j = 0; j < 5; j++) {
     Statements;
    }
   }
   In the following example, the sum of all the elements of a 3×4 matrix M is calculated and stored in a variable called Sum:
   /* Add all elements of a 3x4 matrix */
   Sum = 0;
   for(i = 0; i < 3; i++) {
    for(j = 0; j < 4; j++) {
     Sum = Sum + M[i][j];
    }
   }
   Since there is only one statement to be executed, the preceding example could also be written as:
   /* Add all elements of a 3x4 matrix */
   Sum = 0;
   for(i = 0; i < 3; i++) {
    for(j = 0; j < 4; j++) Sum = Sum + M[i][j];
   }
   while Statement  The syntax of a while statement is:
   while (condition) {
    Statements;
   }
   Here, the statements are executed repeatedly until the condition becomes false, or the statements are executed repeatedly as long as the condition is true. If the condition is false on entry to the loop, then the loop will not be executed and the program will continue from the end of the while loop. It is important that the condition is changed inside the loop, otherwise an endless loop will be formed.
   The following code shows how to set up a loop to execute 10 times, using the while statement:
   /* A loop that executes 10 times */
   k = 0;
   while (k < 10) {
    Statements;
    k++;
   }
   At the beginning of the code, variable k is 0. Since k is less than 10, the while loop starts. Inside the loop the value of k is incremented by 1 after each iteration. The loop repeats as long as k 10 and is terminated when k = 10. At the end of the loop the value of k is 10.
   Notice that an endless loop will be formed if k is not incremented inside the loop:
   /* An endless loop */
   k = 0;
   while (k < 10) {
    Statements;
   }
   An endless loop can also be formed by setting the condition to be always true:
   /* An endless loop */
   while (k == k) {
    Statements;
   }
   Here is an example of calculating the sum of numbers from 1 to 10 and storing the result in a variable called sum:
   /* Calculate the sum of numbers from 1 to 10 */
   unsigned int k, sum;
   k = 1;
   sum = 0;
   while(k <= 10) {
    sum = sum + k;
    k++;
   }
   It is possible to have a while statement with no body. Such a statement is useful, for example, if we are waiting for an input port to change its value. An example follows where the program will wait as long as bit 0 of PORTB (PORTB.0) is at logic 0. The program will continue when the port pin changes to logic 1:
   while(PORTB.0 == 0); // Wait until PORTB.0 becomes 1
   or
   while(PORTB.0);
   It is also possible to have nested while statements.
   do Statement  A do statement is similar to a while statement except that the loop executes until the condition becomes false, or, the loop executes as long as the condition is true. The condition is tested at the end of the loop. The syntax of a do statement is:
   do {
    Statements;
   } while (condition);
   The first iteration is always performed whether the condition is true or false. This is the main difference between a while statement and a do statement. The following code shows how to set up a loop to execute 10 times using the do statement:
   /* Execute 10 times */
   k = 0;
   do {
    Statements;
    k++;
   } while (k < 10);
   The loop starts with k = 0, and the value of k is incremented inside the loop after each iteration. At the end of the loop k is tested, and if k is not less than 10, the loop terminates. In this example because k = 0 is at the beginning of the loop, the value of k is 10 at the end of the loop.
   An endless loop will be formed if the condition is not modified inside the loop, as shown in the following example. Here k is always less than 10:
   /* An endless loop */
   k = 0;
   do {
    Statements;
   } while (k < 10);
   An endless loop can also be created if the condition is set to be true all the time:
   /* An endless loop */
   do {
    Statements;
   } while (k == k);
   It is also possible to have nested do statements.

Unconditional Modifications of Flow

   goto Statement  A goto statement can be used to alter the normal flow of control in a program. It causes the program to jump to a specified label. A label can be any alphanumeric character set starting with a letter and terminating with the colon (“:”) character.
   Although not recommended, a goto statement can be used together with an if statement to create iterations in a program. The following example shows how to set up a loop to execute 10 times using goto and if statements:
   /* Execute 10 times */
   k = 0;
   Loop:
    Statements;
    k++;
   if (k < 10) goto Loop;
   The loop starts with label Loop and variable k = 0 at the beginning of the loop. Inside the loop the statements are executed and k is incremented by 1. The value of k is then compared with 10 and the program jumps back to label Loop if k 10. Thus, the loop is executed 10 times until the condition at the end becomes false. At the end of the loop the value of k is 10.
   continue and break Statements  continue and break statements can be used inside iterations to modify the flow of control. A continue statement is usually used with an if statement and causes the loop to skip an iteration. An example follows that calculates the sum of numbers from 1 to 10 except number 5:
   /* Calculate sum of numbers 1,2,3,4,6,7,8,9,10 */
   Sum = 0;
   i = 1;
   for(i = 1; i <= 10; i++) {
    if (i == 5) continue; // Skip number 5
    Sum = Sum + i;
   }
   Similarly, a break statement can be used to terminate a loop from inside the loop. In the following example, the sum of numbers from 1 to 5 is calculated even though the loop parameters are set to iterate 10 times:
   /* Calculate sum of numbers 1,2,3,4,5 */
   Sum = 0;
   i = 1;
   for(i = 1; i <= 10; i++) {
    if (i > 5) break; // Stop loop if i > 5
    Sum = Sum + i;
   }

   It sometimes becomes necessary to mix PIC microcontroller assembly language statements with the mikroC language. For example, very accurate program delays can be generated by using assembly language statements. The topic of assembly language is beyond the scope of this book, but techniques for including assembly language instructions in mikroC programs are discussed in this section for readers who are familiar with the PIC microcontroller assembly languages.
   Assembly language instructions can be included in a mikroC program by using the keyword asm (or _asm, or __asm). A group of assembly instructions or a single such instruction can be included within a pair of curly brackets. The syntax is:
   asm {
    assembly instructions
   }
   Assembly language style comments (a line starting with a semicolon character) are not allowed, but mikroC does allow both types of C style comments to be used with assembly language programs:
   asm {
    /* This assembly code introduces delay to the program*/
    MOVLW 6 // Load W with 6
    ................
    ................
   }
   User-declared C variables can be used in assembly language routines, but they must be declared and initialized before use. For example, C variable Temp can be initialized and then loaded to the W register as:
   unsigned char Temp = 10;
   asm {
    MOVLW Temp // W = Temp = 10
   ..................
   ..................
   }
   Global symbols such as predefined port names and register names can be used in assembly language routines without having to initialize them:
   asm {
    MOVWF PORTB
    .....................
    .....................
   }

   A function is a self-contained section of code written to perform a specifically defined action. Functions are usually created when a single operation must be performed in different parts of the main program. It is, moreover, good programming practice to divide a large program into a number of smaller, independent functions. The statements within a function are executed by calling (or invoking) the function.
   The general syntax of a function definition is shown in Figure 4.1. The data type indicates the type of data returned by the function. This is followed by the name of the function and then a set of parentheses, within which the arguments, separated by commas, are declared. The body of the function, which includes the function’s operational code, is written inside a set of curly brackets.
   type name (parameter1, parameter2, ……) {
    ……………
    function body
    ……………
   }
   Figure 4.1: General syntax of a function definition
   In the sample function definition that follows, the function, named Mult, receives two integer arguments, a and b, and returns their product. Note that using parentheses in a return statement is optional:
   int Mult(int a, int b) {
    return (a*b);
   }
   When a function is called, it generally expects to be given the number of arguments expressed in the function’s argument list. For example, the preceding function can be called as:
   z = Mult(x, y);
   where variable z has the data type int. Note that the arguments declared in the function definition and the arguments passed when the function is called are independent of each other, even if they have the same name. In the preceding example, when the function is called, variable x is copied to a and variable y is copied to b on entry into function Mult.
   Some functions do not return any data. The data type of such functions must be declared as void. For example:
   void LED(unsigned char D) {
    PORTB = D;
   }
   void functions can be called without any assignment statements, but the parentheses are needed to tell the compiler that a function call is made:
   LED();
   Also, some functions do not have any arguments. In the following example, the function, named Compl, complements PORTC of the microcontroller. It returns no data and has no arguments:
   void Compl() {
    PORTC = ~PORTC;
   }
   This function can be called as:
   Compl();
   Functions are normally defined before the start of the main program.
   Some function definitions and their use in main programs are illustrated in the following examples:

Example 4.1

   Write a function called Circle_Area to calculate the area of a circle where the radius is to be used as an argument. Use this function in a main program to calculate the area of a circle whose radius is 2.5cm. Store the area in a variable called Circ.

Solution 4.1

   The data type of the function is declared as float. The area of a circle is calculated by the formula:
   Area = πr²
   where r is the radius of the circle. The area is calculated and stored in a local variable called s, which is then returned from the function:
   float Circle_Area(float radius) {
    float s;
    s = PI * radius * radius;
    return s;
   }
   Figure 4.2 shows how the function Circle_Area can be used in a main program to calculate the area of a circle whose radius is 2.5cm. The function is defined before the main program. Inside the main program the function is called to calculate and store the area in variable Circ.
   /******************************************************************
                            AREA OF A CIRCLE
                            ================
   This program calls to function Circle_Area to calculate the area of a circle.
   Programmer: Dogan Ibrahim
   File:       CIRCLE.C
   Date:       May, 2007
   ********************************************************************
 
   /* This function calculates the area of a circle given the radius */
   float Circle_Area(float radius) {
    float s;
    s = PI * radius * radius;
    return s;
   }
 
   /* Start of main program. Calculate the area of a circle where radius = 2.5 */
   void main() {
    float r, Circ;
    r = 2.5;
    Circ = Circle_Area(r);
   }
   Figure 4.2: Program to calculate the area of a circle

Example 4.2

   Write a function called Area and a function called Volume to calculate the area and volume of a cylinder respectively. Then write a main program to calculate the area and the volume of cylinder whose radius is 2.0cm and height is 5.0cm. Store the area in variable cyl_area and the volume in variable cyl_volume.

Solution 4.2

   The area of a cylinder is calculated by the formula:
   Area = 2πrh
   where r and h are the radius and height of the cylinder. The volume of a cylinder is calculated by the formula:
   Volume = πr²h
   Figure 4.3 shows the functions that calculate the area and volume of a cylinder. The main program that calculates the area and volume of a cylinder whose radius=2.0cm and height=5.0cm is shown in Figure 4.4.
   float Area(float radius, float height) {
    float s;
    s = 2.0*PI * radius*height;
    return s;
   }
 
   float Volume(float radius, float height) {
    float s;
    s = PI *radius*radius*height;
    return s;
   }
   Figure 4.3: Functions to calculate cylinder area and volume
   /*************************************************************************
                         AREA AND VOLUME OF A CYLINDER
                        ===============================
   This program calculates the area and volume of a cylinder whose radius is
   2.0cm and height is 5.0cm.
   Programmer: Dogan Ibrahim
   File:       CYLINDER.C
   Date:       May, 2007
   **************************************************************************/
 
   /* Function to calculate the area of a cylinder */
   float Area(float radius, float height) {
    float s;
    s = 2.0*PI * radius*height;
    return s;
   }
 
   /* Function to calculate the volume of a cylinder */
   float Volume(float radius, float height) {
    float s;
    s = PI *radius*radius*height;
    return s;
   }
 
   /* Start of the main program */
   void main() {
    float r = 2.0, h = 5.0;
    float cyl_area, cyl_volume;
    cyl_area = Area(r, h);
    cyl_volume(r, h);
   }
   Figure 4.4: Program that calculates the area and volume of a cylinder

Example 4.3

   Write a function called LowerToUpper to convert a lowercase character to uppercase.

Solution 4.3

   The ASCII value of the first uppercase character (‘A’) is 0x41. Similarly, the ASCII value of the first lowercase character (‘a’) is 0x61. An uppercase character can be converted to its equivalent lowercase by subtracting 0x20 from the character. The required function listing is shown in Figure 4.5.
   unsigned char LowerToUpper(unsigned char c) {
    if (c >= 'a' && c <= 'z') return (c - 0x20);
    else return c;
   }
   Figure 4.5: Function to convert lowercase to uppercase

Example 4.4

   Use the function you created in Example 4.3 in a main program to convert letter ‘r’ to uppercase.

Solution 4.4

   The required program is shown in Figure 4.6. Function LowerToUpper is called to convert the lowercase character in variable Lc to uppercase and store in Uc.
   /********************************************************************
                          LOWERCASE TO UPPERCASE
                        ==========================
   This program converts the lowercase character in variable Lc to uppercase
   and stores in variable Uc.
   Programmer: Dogan Ibrahim
   File:       LTOUPPER.C
   Date:       May, 2007
   *********************************************************************/
 
   /* Function to convert a lower case character to upper case */
   unsigned char LowerToUpper(unsigned char c) {
    if (c >= 'a' && c <= 'z') return (c - 0x20);
    else return c;
   }
 
   /* Start of main program */
   void main() {
    unsigned char Lc, Uc;
    Lc = 'r';
    Uc = LowerToUpper(Lc);
   }
   Figure 4.6: Program calling function LowerToUpper

   If a function is not defined before it is called, the compiler will generate an error message. One way around this problem is to create a function prototype. A function prototype is easily constructed by making a copy of the function’s header and appending a semicolon to it. If the function has parameters, giving names to these parameters is not compulsory, but the data type of the parameters must be defined. An example follows in which a function prototype called Area is declared and the function is expected to have a floating point type parameter:
   float Area(float radius);
   This function prototype could also be declared as:
   float Area(float);
   Function prototypes should be declared at the beginning of a program. Function definitions and function calls can then be made at any point in the program.

Example 4.5

   Repeat Example 4.4 but declare LowerToUpper as a function prototype.

Solution 4.5

   Figure 4.7 shows the program where function LowerToUpper is declared as a function prototype at the beginning of the program. In this example, the actual function definition is written after the main program.
   /**********************************************************************
                             LOWERCASE TO UPPERCASE
                           =========================
   This program converts the lowercase character in variable Lc to uppercase
   and stores in variable Uc.
   Programmer: Dogan Ibrahim
   File:       LTOUPPER2.C
   Date:       May, 2007
   ************************************************************************/
 
   unsigned char LowerToUpper(unsigned char);
 
   /* Start of main program */
   void main() {
    unsigned char Lc, Uc;
    Lc = 'r';
    Uc = LowerToUpper(Lc);
   }
 
   /* Function to convert a lower case character to upper case */
   unsigned char LowerToUpper(unsigned char c) {
    if (c >= 'a' && c <= 'z') return (c - 0x20);
    else return c;
   }
   Figure 4.7: Program using function prototype
   One important advantage of using function prototypes is that if the function prototype does not match the actual function definition, mikroC will detect this and modify the data types in the function call to match the data types declared in the function prototype. Suppose we have the following code:
   unsigned char c = 'A';
   unsigned int x = 100;
   long Tmp;
   long MyFunc(long a, long b); // function prototype
 
   void main() {
    ...............
    ...............
    Tmp = MyFunc(c, x);
    ...............
    ...............
   }
   In this example, because the function prototype declares the two arguments as long, variables c and x are converted to long before they are used inside function MyFunc.

   There are many applications where we may want to pass arrays to functions. Passing a single array element is straightforward, as we simply specify the index of the array element to be passed, as in the following function call which passes the second element (index = 1) of array A to function Calc. It is important to realize that an individual array element is passed by value (i.e., a copy of the array element is passed to the function):
   x = Calc(A[1]);
   In some applications we may want to pass complete arrays to functions. An array name can be used as an argument to a function, thus permitting the entire array to be passed. To pass a complete array to a function, the array name must appear by itself within the brackets. The size of the array is not specified within the formal argument declaration. In the function header the array name must be specified with a pair of empty brackets. It is important to realize that when a complete array is passed to a function, what is actually passed is not a copy of the array but the address of the first element of the array (i.e., the array elements are passed by reference, which means that the original array elements can be modified inside the function).
   Some examples follow that illustrate the passing of a complete array to a function.

Example 4.6

   Write a program to store the numbers 1 to 10 in an array called Numbers. Then call a function named Average to calculate the average of these numbers.

Solution 4.6

   The required program listing is shown in Figure 4.8. Function Average receives the elements of array Numbers and calculates the average of the array elements.
   /********************************************************************
                       PASSING AN ARRAY TO A FUNCTION
                       ==============================
   This program stores numbers 1 to 10 in an array called Numbers. Function
   Average is then called to calculate the average of these numbers.
   Programmer: Dogan Ibrahim
   File:       AVERAGE.C
   Date:       May, 2007
   *********************************************************************/
 
   /* Function to calculate the average */
   float Average(int A[]) {
    float Sum = 0.0, k;
    unsigned char j;
    for (j=0; j<10; j++) {
     Sum = Sum + A[j];
    }
    k = Sum / 10.0;
    return k;
   }
 
   /* Start of the main program */
   void main() {
    unsigned char j;
    float Avrg;
    int Numbers[10];
    for (j=0; j<10; j++) Numbers[j] = j+1;
    Avrg = Average(Numbers);
   }
   Figure 4.8: Program passing an array to a function

Example 4.7

   Repeat Example 4.6, but this time define the array size at the beginning of the program and then pass the array size to the function.

Solution 4.7

   The required program listing is shown in Figure 4.9.
   /*********************************************************************
                       PASSING AN ARRAY TO A FUNCTION
                       ==============================
   This program stores numbers 1 to N in an array called Numbers where N is
   defined at the beginning of the program. Function Average is then called to
   calculate the average of these numbers.
   Programmer: Dogan Ibrahim
   File: AVERAGE2.C
   Date: May, 2007
   ***********************************************************************/
 
   #define Array_Size 20
 
   /* Function to calculate the average */
   float Average(int A[], int N) {
    float Sum = 0.0, k;
    unsigned char j;
    for (j=0; j<N; j++) {
     Sum = Sum + A[j];
    }
    k = Sum / N;
    return k;
   }
 
   /* Start of the main program */
   void main() {
    unsigned char j;
    float Avrg;
    int Numbers[Array_Size];
    for (j=0; j<Array_Size; j++) Numbers[j] = j+1;
    Avrg = Average(Numbers, Array_Size);
   }
   Figure 4.9: Another program passing an array to a function
   It is also possible to pass a complete array to a function using pointers. The address of the first element of the array is passed to the function, and the function can then manipulate the array as required using pointer operations. An example follows.

Example 4.8

   Repeat Example 4.6, but this time use a pointer to pass the array elements to the function.

Solution 4.8

   The required program listing is given in Figure 4.10. An integer pointer is used to pass the array elements to the function, and the function elements are manipulated using pointer operations. Notice that the address of the first element of the array is passed as an integer with the statement: &Numbers[0].
   /********************************************************************
                      PASSING AN ARRAY TO A FUNCTION
                      ==============================
   This program stores numbers 1 to 10 in an array called Numbers. Function
   Average is then called to calculate the average of these numbers.
   Programmer: Dogan Ibrahim
   File:       AVERAGE3.C
   Date:       May, 2007
   *********************************************************************/
 
   /* Function to calculate the average */
   float Average(int *A) {
    float Sum = 0.0, k;
    unsigned char j;
    for (j=0; j<10; j++) {
     Sum = Sum + *(A + j);
    }
    k = Sum / 10.0;
    return k;
   }
 
   /* Start of the main program */
   void main() {
    unsigned char j;
    float Avrg;
    int Numbers[10];
    for(j=0; j<10; j++) Numbers[j] = j+1;
    Avrg = Average(&Numbers[0]);
   }
   Figure 4.10: Program passing an array using pointers

   By default, arguments to functions are passed by value. Although this method has many distinct advantages, there are occasions when it is more appropriate and also more efficient to pass the address of the arguments instead, that is, to pass the argument by reference. When the address of an argument is passed, the original value of that argument can be modified by the function; thus the function does not have to return any variables. An example follows which illustrates how the address of arguments can be passed to a function and how the values of these arguments can be modified inside the function.

Example 4.9

   Write a function named Swap to accept two integer arguments and then to swap the values of these arguments. Use this function in a main program to swap the values of two variables.

Solution 4.9

   The required program listing is shown in Figure 4.11. Function Swap is defined as void since it does not return any value. It has two arguments, a and b, and in the function header two integer pointers are used to pass the addresses of these variables. Inside the function body, the value of an argument is accessed by inserting the “*” character in front of the argument. Inside the main program, the addresses of the variables are passed to the function using the “&” character in front of the variable names. At the end of the program, variables p and q are set to 20 and 10 respectively.
   /*************************************************************
                   PASSING VARIABLES BY REFERENCE
                   ==============================
   This program shows how the address of variables can be passed to functions.
   The function in this program swaps the values of two integer variables.
   Programmer: Dogan Ibrahim
   File:       SWAP.C
   Date:       May, 2007
   ***************************************************************/
 
   /* Function to swap two integers */
   void Swap(int *a, int *b) {
    int temp;
    temp = *a; // Store a in temp
    *a = *b;   // Copy b to a
    *b = temp; // Copy temp to b
   }
 
   /* Start of the main program */
   void main() {
    int p, q;
    p = 10;     // Set p = 10
    q = 20;     // Set q = 20
    swap(p, q); // Swap p and q (p=20, q=10)
   }
   Figure 4.11: Passing variables by reference to a function

   The ellipsis character (“...”) consists of three successive periods with no spaces between them. An ellipsis can be used in the argument lists of function prototypes to indicate a variable number of arguments or arguments with varying types. An example of a declaration of a function prototype with ellipsis follows. In this declaration, when the function is called we must supply at least two integer type arguments, and we can also supply any number of additional arguments:
   unsigned char MyFunc(int a, int b, ...);
   The header file stdarg.h must be included at the beginning of a program that uses a variable number of arguments. This header file defines a new data type called va_list, which is essentially a character pointer. In addition, macro va_start() initializes an object of type va_list to point to the address of the first additional argument presented to the function. To extract the arguments, successive calls to the macro va_arg() must be made, with the character pointer and the type of the parameter as the arguments of va_arg().
   An example program is given in Figure 4.12. In this program the function header declares only one parameter of type int, and an ellipsis is used to declare a variable number of parameters. Variable num is the argument count passed by the calling program. The arguments are read by using the macro va_arg(ap, int) and then summed using variable temp and returned by the function.
   /*********************************************************************
                   PASSING VARIABLE NUMBER OF ARGUMENTS
                  ======================================
   This program shows how variable number of arguments can be passed to a
   function. The function header declares one integer variable and an ellipsis is
   used to declare variable number of parameters. The function adds all the
   arguments and returns the sum as an integer. The number of arguments is
   supplied by the calling program as the first argument to the function.
   Programmer: Dogan Ibrahim
   File:       VARIABLE.C
   Date:       May, 2007
   ***********************************************************************/
 
   #include <stdarg.h>
 
   /* Function with variable number of parameters */
   int Sum(int num, ...) {
    unsigned char j;
    va_list ap;
    int temp = 0;
    va_start(ap, num);
    for (j = 0; j < num; j++) {
     temp = temp + va_arg(ap, int);
    }
    va_end(ap);
    return temp;
   }
 
   /* Start of the main program */
   void main() {
    int p;
    p = Sum(2, 3, 5);    // 2 arguments. p=3+5=8
    p = Sum(3, 2, 5, 6); // 3 arguments, p=2+5+6=13
   }
   Figure 4.12: Passing variable number of arguments to a function

   The mikroC compiler supports only a limited function reentrancy. Functions that have no arguments and local variables can be called both from the interrupt service routines and from the main program. Functions that have arguments and/or local variables can only be called from the interrupt service routines or from the main program.

   Normally, variables declared at the beginning of a program, before the main program, are global, and their values can be accessed and modified by all parts of the program. Declaring a variable used in a function as global ensures that its value is retained from one call of the function to another, but this also undermines the variable’s privacy and reduces the portability of the function to other applications. A better approach is to declare such variables as static. Static variables are mainly used in function definitions. When a variable is declared as static, its value is retained from one call of the function to another. In the example code that follows, variable k is declared as static and initialized to zero. This variable is then incremented before exiting from the function, and the value of k remains in existence and holds its last value on the next call to the function (i.e., on the second call to the function the value of k will be 1):
   void Cnt(void) {
    static int k = 0; // Declare k as static
    ..................
    ..................
    k++; // increment k
   }

   A large set of library functions is available with the mikroC compiler. These library functions can be called from anywhere in a program, and they do not require that header files are included in the program. The mikroC user manual gives a detailed description of each library function, with examples. In this section, the available library functions are identified, and the important and commonly used library functions are described in detail, with examples.
   Table 4.2 gives a list of the mikroC library functions, organized in functional order.
 
   Table 4.2: mikroC library functions

Library	Description
ADC	Analog-to-digital conversion functions
CAN	CAN bus functions
CANSPI	SPI-based CAN bus functions
Compact Flash	Compact flash memory functions
EEPROM	EEPROM memory read/write functions
Ethernet	Ethernet functions
SPI Ethernet	SPI-based Ethernet functions
Flash Memory	Flash memory functions
Graphics LCD	Standard graphics LCD functions
T6963C Graphics LCD	T6963-based graphics LCD functions
I²C	I²C bus functions
Keypad	Keypad functions
LCD	Standard LCD functions
Manchester Code	Manchester code functions
Multi Media	Multimedia functions
One Wire	One wire functions
PS/2	PS/2 functions
PWM	PWM functions
RS-485	RS-485 communication functions
Sound	Sound functions
SPI	SPI bus functions
USART	USART serial communication functions
Util	Utilities functions
SPI Graphics LCD	SPI-based graphics LCD functions
Port Expander	Port expander functions
SPI LCD	SPI-based LCD functions
ANSI C Ctype	C Ctype functions
ANSI C Math	C Math functions
ANSI C Stdlib	C Stdlib functions
ANSI C String	C String functions
Conversion	Conversion functions
Trigonometry	Trigonometry functions
Time	Time functions

   Some of the frequently used library functions are:
   • EEPROM library
   • LCD library
   • Software UART library
   • Hardware USART library
   • Sound library
   • ANSI C library
   • Miscellaneous library

   The EEPROM library includes functions to read data from the on-chip PIC microcontroller nonvolatile EEPROM memory, or to write data to this memory. Two functions are provided:
   • Eeprom_Read
   • Eeprom_Write
   The Eeprom_Read function reads a byte from a specified address of the EEPROM. The address is of type integer, and thus the function supports PIC microcontrollers with more than 256 bytes. A 20ms delay should be used between successive reads from the EEPROM to guarantee the return of correct data. In the following example, the byte at address 0x1F of the EEPROM is read and stored in variable Temp:
   Temp = Eeprom_Read(0x1F);
   The Eeprom_Write function writes a byte to a specified address of the EEPROM. The address is of type integer and thus the function supports PIC microcontrollers with more than 256 bytes. A 20ms delay should be used between successive reads or writes to the EEPROM to guarantee the correct transfer of data to the EEPROM. In the following example, number 0x05 is written to address 0x2F of the EEPROM:
   Eeprom_Write(0x2F, 0x05);

Example 4.11

   Write a program to read the contents of EEPROM from address 0 to 0x2F and then send this data to PORTB of a PIC microcontroller.

Solution 4.11

   The required program is given in Figure 4.18. A for loop is used to read data from the EEPROM and then send it to PORT B of the microcontroller. Notice that a 20ms delay is used between each successive read.
   /***********************************************************************
                         READING FROM THE EEPROM
                         =========================
   This program reads data from addresses 0 to 0x2F of the EEPROM and then
   sends this data to PORTB of the microcontroller.
   Programmer: Dogan Ibrahim
   File:       EEPROM.C
   Date:       May, 2007
   ************************************************************************/
 
   void main() {
    unsigned int j;
    unsigned char Temp;
    TRISB = 0; // Configure PORTB as output
    for (j=0; j <= 0x2F; j++) {
     Temp = Eeprom_Read(j);
     PORTB = Temp;
     Delay_ms(20);
    }
   }
   Figure 4.18: Program to read from the EEPROM

   One thing all microcontrollers lack is some kind of video display. A video display would make a microcontroller much more user-friendly, enabling text messages, graphics, and numeric values to be output in a more versatile manner than with 7-segment displays, LEDs, or alphanumeric displays. Standard video displays require complex interfaces and their cost is relatively high. LCDs are alphanumeric (or graphic) displays which are frequently used in microcontroller-based applications. These display devices come in different shapes and sizes. Some LCDs have forty or more character lengths with the capability to display several lines. Others can be programmed to display graphic images. Some modules offer color displays, while others incorporate backlighting so they can be viewed in dimly lit conditions.
   There are basically two types of LCDs as far as the interfacing technique is concerned: parallel and serial. Parallel LCDs (e.g., the Hitachi HD44780 series) are connected to the microcontroller circuitry such that data is transferred to the LCD using more than one line, usually four or eight data lines. Serial LCDs are connected to a microcontroller using one data line only, and data is transferred using the RS232 asynchronous data communications protocol. Serial LCDs are generally much easier to work with but more costly than parallel ones. In this book only parallel LCDs are discussed, as they are used more often in microcontroller-based projects.
   Low-level programming of a parallel LCD is usually a complex task and requires a good understanding of the internal operation of the LCD, including the timing diagrams. Fortunately, mikroC language provides functions for both text-based and graphic LCDs, simplifying the use of LCDs in PIC-microcontroller-based projects. The HD44780 controller is a common choice in LCD-based microcontroller applications. A brief description of this controller and information on some commercially available LCD modules follows.

The HD44780 LCD Controller

   The HD44780 is one of the most popular LCD controllers, being used both in industrial and commercial applications and also by hobbyists. The module is monochrome and comes in different shapes and sizes. Modules with 8, 16, 20, 24, 32, and 40 characters are available. Depending on the model, the display provides a 14-pin or 16-pin connector for interfacing. Table 4.3 shows the pin configuration and pin functions of a typical 14-pin LCD.
 
   Table 4.3: Pin configuration of the HD44780 LCD module

Pin no.	Name	Function
1	VSS	Ground
2	VDD	+ve supply
3	VEE	Contrast
4	RS	Register select
5	R/W	Read/write
6	EN	Enable
7	D0	Data bit 0
8	D1	Data bit 1
9	D2	Data bit 2
10	D3	Data bit 3
11	D4	Data bit 4
12	D5	Data bit 5
13	D6	Data bit 6
14	D7	Data bit 7

   V_SS is the 0V supply or ground. The V_DD pin should be connected to the positive supply. Although the manufacturers specify a 5V DC supply, the modules usually work with as low as 3V or as high as 6V.
   Pin 3 is named as V_EE and is the contrast control pin. It is used to adjust the contrast of the display and should be connected to a DC supply. A potentiometer is usually connected to the power supply with its wiper arm connected to this pin and the other leg of the potentiometer connected to the ground. This way the voltage at the V_EE pin, and hence the contrast of the display, can be adjusted as desired.
   Pin 4 is the register select (RS) and when this pin is LOW, data transferred to the LCD is treated as commands. When RS is HIGH, character data can be transferred to and from the module.
   Pin 5 is the read/write (R/W) pin. This pin is pulled LOW in order to write commands or character data to the LCD module. When this pin is HIGH, character data or status information can be read from the module.
   Pin 6 is the enable (EN) pin, which is used to initiate the transfer of commands or data between the module and the microcontroller. When writing to the display, data is transferred only on the HIGH to LOW transition of this pin. When reading from the display, data becomes available after the LOW to HIGH transition of the enable pin, and this data remains valid as long as the enable pin is at logic HIGH.
   Pins 7 to 14 are the eight data bus lines (D0 to D7). Data can be transferred between the microcontroller and the LCD module using either a single 8-bit byte or two 4-bit nibbles. In the latter case, only the upper four data lines (D4 to D7) are used. The 4-bit mode has the advantage of requiring fewer I/O lines to communicate with the LCD.
   The mikroC LCD library provides a large number of functions to control text-based LCDs with 4-bit and 8-bit data interfaces, and for graphics LCDs. The most common are the 4-bit-interface text-based LCDs. This section describes the available mikroC functions for these LCDs. Further information on other text-or graphics-based LCD functions are available in the mikroC manual.
   The following are the LCD functions available for 4-bit-interface text-based LCDs:
   • Lcd_Config
   • Lcd_Init
   • Lcd_Out
   • Lcd_Out_Cp
   • Lcd_Chr
   • Lcd_Chr_Cp
   • Lcd_Cmd
   Lcd_Config  The Lcd_Config function is used to configure the LCD interface. The default connection between the LCD and the microcontroller is:
   LCD Microcontroller port pin
   RS           2
   EN           3
   D4           4
   D5           5
   D6           6
   D7           7
   The R/W pin of the LCD is not used and should be connected to the ground. This function should be used to change the default connection. It should be called with the parameters in the following order:
   port name, RS pin, EN pin, R/W pin, D7 pin, D6 pin, D5 pin, D4 pin
   The port name should be specified by passing its address. For example, if the RS pin is connected to RB0, EN pin to RB1, D7 pin to RB2, D6 pin to RB3, D5 pin to RB4, and the D4 pin to RB5, then the function should be called as follows:
   Lcd_Config(&PORTB, 0, 1, 2, 3, 4, 5);
   Lcd_Init  The Lcd_Init function is called to configure the interface between the microcontroller and the LCD when the default connections are made as just illustrated. The port name should be specified by passing its address. For example, assuming that the LCD is connected to PORTB and the preceding default connections are used, the function should be called as:
   Lcd_Init(&PORTB);
   Lcd_Out  The Lcd_Out function displays text at the specified row and column position of the LCD. The function should be called with the parameters in the following order:
   row, column, text
   For example, to display text “Computer” at row 1 and column 2 of the LCD we should call the function as:
   Lcd_Out(1, 2, "Computer");
   Lcd_Out_Cp  The Lcd_Out_Cp function displays text at the current cursor position. For example, to display text “Computer” at the current cursor position the function should be called as:
   Lcd_Out_Cp("Computer");
   Lcd_Chr  The Lcd_Chr function displays a character at the specified row and column position of the cursor. The function should be called with the parameters in the following order:
   row, column, character
   For example, to display character “K” at row 2 and column 4 of the LCD we should call the function as:
   LCD_Chr(2, 4, 'K');
   Lcd_Chr_Cp  The Lcd_Chr_Cp function displays a character at the current cursor position. For example, to display character “M” at the current cursor position the function should be called as:
   Lcd_Chr_Cp('M');
   Lcd_Cmd  The Lcd_Cmd function is used to send a command to the LCD. With the commands we can move the cursor to any required row, clear the LCD, blink the cursor, shift display, etc. A list of the most commonly used LCD commands is given in Table 4.4. For example, to clear the LCD we should call the function as:
   Lcd_Cmd(Lcd_Clear);
 
   Table 4.4: LCD commands

LCD command	Description
LCD_CLEAR	Clear display
LCD_RETURN_HOME	Return cursor to home position
LCD_FIRST_ROW	Move cursor to first row
LCD_SECOND_ROW	Move cursor to second row
LCD_THIRD_ROW	Move cursor to third row
LCD_FOURTH_ROW	Move cursor to fourth row
LCD_BLINK_CURSOR_ON	Blink cursor
LCD_TURN_ON	Turn display on
LCD_TURN_OFF	Turn display off
LCD_MOVE_CURSOR_LEFT	Move cursor left
LCD_MOVE_CURSOR_RIGHT	Move cursor right
LCD_SHIFT_LEFT	Shift display left
LCD_SHIFT_RIGHT	Shift display right

   An example illustrates initialization and use of the LCD.

Example 4.12

   A text-based LCD is connected to a PIC18F452 microcontroller in the default mode as shown in Figure 4.19. Write a program to send the text “My Computer” to row 1, column 4 of the LCD.
   Figure 4.19: Connecting an LCD to a PIC microcontroller

Solution 4.12

   The required program listing is given in Figure 4.20 (program LCD.C). At the beginning of the program PORTB is configured as output with the TRISB = 0 statement. The LCD is then initialized, the display is cleared, and the text message “My Computer” is displayed on the LCD.
   /*********************************************************************
                        WRITING TEXT TO AN LCD
                        ======================
   A text based LCD is connected to a PIC microcontroller in the default mode.
   This program displays the text "My Computer" on the LCD.
   Programmer: Dogan Ibrahim
   File:       LCD.C
   Date:       May, 2007
   ***********************************************************************/
 
   void main() {
    TRISB = 0;                    // Configure PORTB as output
    Lcd_Init(PORTB);              // Initialize the LCD
    Lcd_Cmd(LCD_CLEAR);           // Clear the LCD
    Lcd_Out(1, 4, "My Computer"); // Display text on LCD
   }
   Figure 4.20: LCD program listing

   Universal asynchronous receiver transmitter (UART) software library is used for RS232-based serial communication between two electronic devices. In serial communication, only two cables (plus a ground cable) are required to transfer data in either direction. Data is sent in serial format over the cable bit by bit. Normally, the receiving device is in idle mode with its transmit (TX) pin at logic 1, also known as MARK. Data transmission starts when this pin goes to logic 0, also known as SPACE. The first bit sent is the start bit at logic 0. Following this bit, 7 or 8 data bits are sent, followed by an optional parity bit. The last bit sent is the stop bit at logic 1. Serial data is usually sent as a 10-bit frame consisting of a start bit, 8 data bits, and a stop bit, and no parity bits. Figure 4.21 shows how character “A” can be sent using serial communication. Character “A” has the ASCII bit pattern 01000001. As shown in the figure, first the start bit is sent, this is followed by 8 data bits 01000001, and finally the stop bit is sent.
   Figure 4.21: Sending character “A” in serial communication
   The bit timing is very important in serial communication, and the transmitting (TX) and receiving (RX) devices must have the same bit timings. The bit timing is measured by the baud rate, which specifies the number of bits transmitted or received each second. Typical baud rates are 4800, 9600, 19200, 38400, and so on. For example, when operating at 9600 baud rate with a frame size of 10 bits, 960 characters are transmitted or received each second. The timing between bits is then about 104ms.
   In RS232-based serial communication the two devices are connected to each other (see Figure 4.22) using either a 25-way connector or a 9-way connector. Normally only the TX, RX, and GND pins are required for communication. The required pins for both types of connectors are given in Table 4.5.
   Figure 4.22: 25-way and 9-way RS232 connectors
 
   Table 4.5: Pins required for serial communication

Pin	9-way connector	25-way connector
TX	2	2
RX	3	3
GND	5	7

   The voltage levels specified by the RS232 protocol are ±12V. A logic HIGH signal is at –12V and a logic LOW signal is at +12V. PIC microcontrollers, on the other hand, normally operate at 0 to 5V voltage levels, the RS232 signals must be converted to 0 to 5V when input to a microcontroller. Similarly, the output of the microcontroller must be converted to ±12V before sending to the receiving RS232 device. The voltage conversion is usually carried out with RS232 converter chips, such as the MAX232, manufactured by Maxim Inc.
   Serial communication may be implemented in hardware using a specific pin of a microcontroller, or the required signals can be generated in software from any required pin of a microcontroller. Hardware implementation requires either an on-chip UART (or USART) circuit or an external UART chip that is connected to the microcontroller. Software-based UART is more commonly used and does not require any special circuits. Serial data is generated by delay loops in software-based UART applications. In this section only the software-based UART functions are described.
   The mikroC compiler supports the following software UART functions:
   • Soft_Uart_Init
   • Soft_Uart_Read
   • Soft_Uart_Write

Soft_Uart_Init

   The Soft_Uart_Init function specifies the serial communications parameters and does so in the following order:
   port, rx pin, tx pin, baud rate, mode
   port is the port used as the software UART (e.g., PORTB), rx is the receive pin number, tx is the transmit pin number, baud rate is the chosen baud rate where the maximum value depends on the clock rate of the microcontroller, and mode specifies whether or not the data should be inverted at the output of the port. A 0 indicates that it should not be inverted, and a 1 indicates that it should be inverted. When an RS232 voltage level converter chip is used (e.g., MAX232) then the mode must be set to 0. Soft_Uart_Init must be the first function called before software-based serial communication is established.
   The following example configures the software UART to use PORTB as the serial port, with RB0 as the RX pin and RB1 as the TX pin. The baud rate is set to 9600 with the mode noninverted:
   Soft_Uart_Init(PORTB, 0, 1, 9600, 0);

Soft_Uart_Read

   The Soft_Uart_Read function receives a byte from a specified serial port pin. The function returns an error condition and the data is read from the serial port. The function does not wait for data to be available at the port, and therefore the error parameter must be tested if a byte is expected. The error is normally 1 and becomes 0 when a byte is read from the port.
   The following example illustrates reading a byte from the serial port configured by calling the function Soft_Uart_Init. The received byte is stored in variable Temp:
   do Temp = Soft_Uart_Read(Rx_Error);
   while (Rx_Error);

Soft_Uart_Write

   The Soft_Uart_Write function transmits a byte to a configured serial port pin. The data to be sent must be specified as a parameter in the call to the function.
   For example, to send character “A” to the serial port pin:
   char MyData = 'A';
   Soft_Uart_Write(MyData);
   The following example illustrates the use of software UART functions.

Example 4.13

   The serial port of a PC (e.g., COM1) is connected to a PIC18F452 microcontroller, and terminal emulation software (e.g., HyperTerminal) is operated on the PC to use the serial port. Pins RB0 and RB1 of the microcontroller are the RX and TX pins respectively. The required baud rate is 9600.
   Write a program to read data from the terminal, then increase this data by one and send it back to the terminal. For example, if the user enters character “A,” then character “B” should be displayed on the terminal. Assume that a MAX232-type voltage level converter chip is converting the microcontroller signals to RS232 levels. Figure 4.23 shows the circuit diagram of this example.
   Figure 4.23: Circuit diagram of Example 4.13

Solution 4.13

   The MAX232 chip receives the TX signal from pin RB1 of the microcontroller and converts it to RS232 levels. Comparably, the serial data received by the MAX232 chip is converted into microcontroller voltage levels and then sent to pin RB0. Note that correct operation of the MAX232 chip requires four capacitors to be connected to the chip.
   The required program listing is shown in Figure 4.24 (program SERIAL.C). At the beginning of the program, function Soft_Uart_Init is called to configure the serial port. Then an endless loop is formed using a for statement. The Soft_Uart_Read function is called to read a character from the terminal. After reading a character, the data byte is incremented by one and then sent back to the terminal by calling function Soft_Uart_Write.
   /********************************************************************
                   READING AND WRITING TO SERIAL PORT
                   ==================================
   In this program PORTB pins RB0 and RB1 are configured as serial RX and
   TX pins respectively. The baud rate is set to 9600. A character is received
   from a serial terminal, incremented by one and then sent back to the
   terminal. Thus, if character "A" is entered on the keyboard, character "B"
   will be displayed.
   Programmer: Dogan Ibrahim
   File:       SERIAL.C
   Date:       May, 2007
   **********************************************************************/
 
   void main() {
    unsigned char MyError, Temp;
    Soft_Uart_Init(PORTB, 0, 1, 9600, 0); // Configure serial port
    for (;;) // Endless loop
    {
    do {
     Temp = Soft_Uart_Read(MyError);      // Read a byte
    } while (MyError);
    Temp++;                               // Increment byte
    Soft_Uart_Write(Temp);                // Send the byte
   }
   Figure 4.24: Program listing of Example 4.13

   The universal synchronous asynchronous receiver transmitter (USART) hardware library contains a number of functions to transmit and receive serial data using the USART circuits built on the PIC microcontroller chips. Some PIC18F-series microcontrollers have only one USART (e.g., PIC18F452), while others have two USART circuits (e.g., PIC18F8520). Hardware USART has an advantage over software-implemented USART, in that higher baud rates are generally available and the microcontroller can perform other operations while data is sent to the USART.
   The hardware USART library provides the following functions:
   • Usart_Init
   • Usart_Data_Ready
   • Usart_Read
   • Usart_Write

Usart_Init

   The Usart_Init function initializes the hardware USART with the specified baud rate. This function should be called first, before any other USART functions. The only parameter required by this function is the baud rate. The following example call sets the baud rate to 9600:
   Usart_Init(9600);

Usart_Data_Ready

   The Usart_Data_Ready function can be called to check whether or not a data byte has been received by the USART. The function returns a 1 if data has been received and a 0 if no data has been received. The function has no parameters. The following code checks if a data byte has been received or not:
   if (Usart_Data_Ready())

Usart_Read

   The Usart_Read function is called to read a data byte from the USART. If data has not been received, a 0 is returned. Note that reading data from the USART is nonblocking (i.e., the function always returns whether or not the USART has received a data byte). The Usart_Read function should be called after calling the function Usart_Data_Ready to make sure that data is available at the USART. Usart_Read has no parameters. In the following example, USART is checked and if a data byte has been received it is copied to variable MyData:
   char MyData;
   if (Usart_Data_Read()) MyData = Usart_Read();

Usart_Write

   The Usart_Write function sends a data byte to the USART, and thus a serial data is sent out of the USART. The data byte to be sent must be supplied as a parameter to the function. In the following example, character “A” is sent to the USART:
   char Temp = 'A';
   Usart_Write(Temp);
   The following example illustrates how the hardware USART functions can be used in a program.

Example 4.14

   The serial port of a PC (e.g., COM1) is connected to a PIC18F452 microcontroller, and terminal emulation software (e.g., HyperTerminal) is operated on the PC to use the serial port. The microcontroller’s hardware USART pins RC7 (USART receive pin, RX) and RC6 (USART transmit pin, TX) are connected to the PC via a MAX232-type RS232 voltage level converter chip. The required baud rate is 9600. Write a program to read data from the terminal, then increase this data by one and send it back to the terminal. For example, if the user enters character “A,” then character “B” should be displayed on the terminal. Figure 4.25 shows the circuit diagram of this example.
   Figure 4.25: Circuit diagram of Example 4.14

Solution 4.14

   The required program listing is shown in Figure 4.26 (program SERIAL2.C). At the beginning of the program, function Usart_Init is called to set the baud rate to 9600. Then an endless loop is formed using a for statement. The Usart_Data_Ready function is called to check whether a character is ready, and the character is read by calling function Usart_Read. After reading a character, the data byte is incremented by one and then sent back to the terminal by calling function Usart_Write.
   /*******************************************************************
             READING AND WRITING TO SERIAL PORT VIA USART
             ============================================
   In this program a PIC18F452 microcontroller is used and USART I/O pins are
   connected to a terminal through a MAX232 voltage converter chip. The baud
   rate is set to 9600. A character is received from a serial terminal,
   incremented by one and then sent back to the terminal. Thus, if character “A”
   is entered on the keyboard, character “B” will be displayed.
   Programmer: Dogan Ibrahim
   File:       SERIAL2.C
   Date:       May, 2007
   *********************************************************************/
 
   void main() {
    unsigned char MyError, Temp;
    Usart_Init(9600); // Set baud rate
    for (;;) // Endless loop
    {
     while(!User_Data_Ready()); // Wait for data byte
     Temp = Usart_Read();       // Read data byte
     Temp++;                    // Increment data byte
     Usart_Write(Temp);         // Send the byte byte
    }
   }
   Figure 4.26: Program listing of Example 4.14
   In PIC microcontrollers that have more than one USART, the second USART is accessed by appending a “2” to the end of the function (e.g., Usart_Write2, Usart_Read2, etc.).

   Functions in the sound library make it possible to generate sounds in our applications. A speaker (e.g., a piezo speaker) should be connected to the required microcontroller port. The following functions are offered by the sound library:
   • Sound_Init
   • Sound_Play

Sound_Init

   The Sound_Init function initializes the sound library and requires two parameters: the name and the bit number of the port where the speaker is connected. The address of the port name should be passed to the function. For example, if the speaker is connected to bit 3 of PORTB, then the function should be called as:
   Sount_Init(&PORTB, 3);

Sound_Play

   The Sound_Play function plays a sound at a specified port pin. The function receives two arguments: the period divided by 10 (TDIV) and the number of periods (N). The first parameter is the period in microcontroller cycles divided by 10. The second parameter specifies the duration (number of clock periods) of the sound.
   The following formula calculates the value used as the first parameter:
    
   where
    TDIV is the number to be used as the first parameter
    F is the required sound frequency (Hz)
    f is the microcontroller clock frequency (Hz)

Example 4.15

   Write a program to play a sound at 1KHz, assuming the clock frequency is 4MHz. The required duration of the sound is 250 periods.

Solution 4.15

   The first parameter is calculated as follows:
    
   Since the required duration is 250 periods, the function is called with the parameters:
   Sound_Play(100, 250);

   The ANSI C library consists of the following libraries (further details on these libraries are available in the mikroC user manual):
   • Ctype library
   • Math library
   • Stdlib library
   • String library

Ctype Library

   The functions in the Ctype library are mainly used for testing or data conversion. Table 4.6 lists the commonly used functions in this library.
 
   Table 4.6: Commonly used Ctype library functions

Function	Description
isalnum	Returns 1 if the specified character is alphanumeric (a–z, A–Z, 0–9)
isalpha	Returns 1 if the specified character is alphabetic (a–z, A–Z)
iscntrl	Returns 1 if the specified character is a control character (decimal 0–31 and 127)
isdigit	Returns 1 if the specified character is a digit (0–9)
islower	Returns 1 if the specified character is lowercase
isprint	Returns 1 if the specified character is printable (decimal 32–126)
isupper	Returns 1 if the specified character is uppercase
toupper	Convert a character to uppercase
tolower	Convert a character to lowercase

Math Library

   The functions in the Math library are used for floating point mathematical operations. Table 4.7 lists the commonly used functions in this library.
 
   Table 4.7: Commonly used Math library functions

Function	Description
acos	Returns in radians the arc cosine of its parameter
asin	Returns in radians the arc sine of its parameter
atan	Returns in radians the arc tangent of its parameter
atan2	Returns in radians the arc tangent of its parameter where the signs of both parameters are used to determine the quadrant of the result
cos	Returns the cosine of its parameter in radians
cosh	Returns the hyperbolic cosine of its parameter
exp	Returns the exponential of its parameter
fabs	Returns the absolute value of its parameter
log	Returns the natural logarithm of its parameter
log10	Returns the logarithm to base 10 of its parameter
pow	Returns the power of a number
sin	Returns the sine of its parameter in radians
sinh	Returns the hyperbolic sine of its parameter
sqrt	Returns the square root of its parameter
tan	Returns the tangent of its parameter in radians
tanh	Returns the hyperbolic sine of its parameter

Stdlib Library

   The Stdlib library contains standard library functions. Table 4.8 lists the commonly used functions in this library.
 
   Table 4.8: Commonly used Stdlib library functions

Function	Description
abs	Returns the absolute value
atof	Converts ASCII character into floating point number
atoi	Converts ASCII character into integer number
atol	Converts ASCII character into long integer
max	Returns the greater of two integers
min	Returns the lesser of two integers
rand	Returns a random number between 0 and 32767; function srand must be called to obtain a different sequence of numbers
srand	Generates a seed for function rand so a new sequence of numbers is generated
xtoi	Convert input string consisting of hexadecimal digits into integer

Example 4.16

   Write a program to calculate the trigonometric sine of the angles from 0° to 90° in steps of 1° and store the result in an array called Trig_Sine.

Solution 4.16

   The required program listing is shown in Figure 4.27 (program SINE.C). A loop is created using a for statement, and inside this loop the sine of the angles are calculated and stored in array Trig_Sine. Note that the angles must be converted into radians before they are used in function sin.
   /******************************************************************
              TRIGONOMETRIC SINE OF ANGLES 0 to 90 DEGREES
               ==========================================
   This program calculates the trigonometric sine of angles from 0 degrees to
   90 degrees in steps of 1 degree. The results are stored in an array called
   Trig_Sine.
   Programmer: Dogan Ibrahim
   File:       SINE.C
   Date:       May, 2007
   ********************************************************************/
 
   void main() {
    unsigned char j;
    double PI = 3.14159, rads;
    for(j = 0; j <= 90; j++) {
     rads = j * PI /180.0;
     angle = sin(rad);
     Trig_Sine[j] = angle;
    }
   }
   Figure 4.27: Calculating the sine of angles 0 to 90

String Library

   The functions in the String library are used to perform string and memory manipulation operations. Table 4.9 lists the commonly used functions in this library.
 
   Table 4.9: Commonly used String library functions

Function	Description
strcat, strncat	Append two strings
strchr, strpbrk	Locate the first occurrence of a character in a string
strcmp, strncmp	Compare two strings
strcpy, strncpy	Copy one string into another one
strlen	Return the length of a string

Example 4.17

   Write a program to illustrate how the two strings “MY POWERFUL” and “COMPUTER” can be joined into a new string using String library functions.

Solution 4.17

   The required program listing is shown in Figure 4.28 (program JOIN.C). The mikroC String library function strcat is used to join the two strings pointed to by p1 and p2 into a new string stored in a character array called New_String.
   /******************************************************************
                          JOINING TWO STRINGS
                          ===================
   This program shows how two strings can be joined to obtain a new string.
   mikroC library function strcat is used to join the two strings pointed to by
   p1 and p2 into a new string stored in character array New_String.
   Programmer: Dogan Ibrahim
   File:       JOIN.C
   Date:       May, 2007
   *******************************************************************/
 
   void main() {
    const char *p1 = "MY POWERFUL ";    // First string
    const char *p2 = "COMPUTER";        // Second string
    char New_String[80];
    strcat(strcat(New_String, p1), p2); // join the two strings
   }
   Figure 4.28: Joining two strings using function strcat

   The functions in the Miscellaneous library include routines to convert data from one type to another type, as well as to perform some trigonometric functions. Table 4.10 lists the commonly used functions in this library.
 
   Table 4.10: Commonly used Miscellaneous library functions

Function	Description
ByteToStr	Convert a byte into string
ShortToStr	Convert a short into string
WordToStr	Convert an unsigned word into string
IntToStr	Convert an integer into string
LongToStr	Convert a long into string
FloatToStr	Convert a float into string
Bcd2Dec	Convert a BCD number into decimal
Dec2Bcd	Convert a decimal number into BCD

   The following general programs illustrate the use of various library routines available with the mikroC language.

Example 4.18

   Write a function to convert the string pointed to by p into lowercase or uppercase, depending on the value of a mode parameter passed to the function. If the mode parameter is nonzero, then convert to lowercase, otherwise convert it to uppercase. The function should return a pointer to the converted string.

Solution 4.18

   The required program listing is given in Figure 4.29 (program CASE.C). The program checks the value of the mode parameter, and if this parameter is nonzero the string is converted to lowercase by calling function ToLower, otherwise the function ToUpper is called to convert the string to uppercase. The program returns a pointer to the converted string.
   /*********************************************************************
                   CONVERT A STRING TO LOWER/UPPERCASE
                  =====================================
   This program receives a string pointer and a mode parameter. If the mode is 1
   then the string is converted to lowercase, otherwise the string is converted
   to uppercase.
   Programmer: Dogan Ibrahim
   File:       CASE.C
   Date:       May, 2007
   ***********************************************************************/
 
   unsigned char *Str_Convert(unsigned char *p, unsigned char mode) {
    unsigned char *ptr = p;
    if (mode != 0) {
     while (*p != '\0') *p++ = ToLower(*p);
    } else {
     while (*p != '\0') *p++ = ToUpper(*p);
    }
    return ptr;
   }
   Figure 4.29: Program for Example 4.18

Example 4.19

   Write a program to define a complex number structure, then write functions to add and subtract two complex numbers. Show how you can use these functions in a main program.

Solution 4.19

   Figure 4.30 shows the required program listing (program COMPLEX.C). At the beginning of the program, a data type called complex is created as a structure having a real part and an imaginary part. A function called Add is then defined to add two complex numbers and return the sum as a complex number. Similarly, the function Subtract is defined to subtract two complex numbers and return the result as a complex number. The main program uses two complex numbers, a and b, where,
   a = 2.0 – 3.0j
   b = 2.5 + 2.0j
   /*************************************************************
              COMPLEX NUMBER ADDITION AND SUBTRACTION
            ===========================================
   This program creates a data structure called complex having a real part and
   an imaginary part. Then, functions are defined to add or subtract two complex
   numbers and store the result in another complex number.
   The first complex number is,  a = 2.0 – 2.0j
   The second complex number is, b = 2.5 + 2.0j
   The program calculates, c = a + b
   and,                    d = a − b
   Programmer: Dogan Ibrahim
   File:       COMPLEX.C
   Date:       May, 2007
   ***************************************************************/
 
   /* Define a new data type called complex */
   typedef struct {
    float real;
    float imag;
   } complex;
 
   /* Define a function to add two complex numbers and return the result as
    a complex number */
   complex Add(complex i, complex j) {
    complex z;
    z.real = i.real + j.real;
    z.imag = i.imag + j.imag;
    return z;
   }
 
   /* Define a function to subtract two complex numbers and return the result as
    a complex number */
   complex Subtract(complex i, complex j) {
    complex z;
    z.real = i.real - j.real;
    z.imag = i.imag - j.imag;
    return z;
   }
 
   /* Main program */
   void main() {
    complex a, b, c, d;
    a.real = 2.0; a.imag =−3.0; // First complex number
    b.real = 2.5; b.imag = 2.0; // second complex number
    c = Add(a, b);              // Add numbers
    d = Subtract(a, b);         // Subtract numbers
   }
   Figure 4.30: Program for Example 4.19
   Two other complex numbers, c and d, are also declared, and the following complex number operations are performed:
   The program calculates, c = a + b and, d = a – b

Example 4.20

   A projectile is fired at an angle of y degrees at an initial velocity of v meters per second. The distance traveled by the projectile (d), the flight time (t), and the maximum height reached (h) are given by the following formulas:
    
   Write functions to calculate the height, flight time, and distance traveled. Assuming that g=9.81m/s², v=12 m/s, and θ=45°, call the functions to calculate the three variables. Figure 4.31 shows the projectile pattern.
   Figure 4.31: Projectile pattern

Solution 4.20

   The required program is given in Figure 4.32 (program PROJECTILE.C). Three functions are defined: Height calculates the maximum height of the projectile, Flight_time calculates the flight time, and Distance calculates the distance traveled. In addition, a function called Radians converts degrees into radians to use in the trigonometric function sine. The height, distance traveled, and flight time are calculated and stored in floating point variables h, d, and t respectively.
   /**********************************************************************
                               PROJECTILE CALCULATION
                              ========================
   This program calculates the maximum height, distance traveled, and the flight
   time of a projectile. Theta is the firing angle, and v is the initial
   velocity of the projectile respectively.
   Programmer: Dogan Ibrahim
   File:       PROJECTILE.C
   Date:       May, 2007
   ***********************************************************************/
 
   #define gravity 9.81
 
   /* This function converts degrees to radians */
   float Radians(float y) {
    float rad;
    rad = y * 3.14159 / 180.0;
    return rad;
   }
 
   /* Flight time of the projectile */
   float Flight_time(float theta, float v) {
    float t, rad;
    rad = Radians(theta);
    t = (2.0*v*sin(rad)) / gravity;
    return t;
   }
 
   float Height(float theta, float v) {
    float h, rad;
    rad = Radians(theta);
    h = (v*v*sin(rad)) / gravity;
    return h;
   }
 
   float Distance(float theta, float v) {
    float d, rad;
    rad = radians(theta);
    d = (v*v*sin(2*rad)) / gravity;
    return d;
   }
 
   /* Main program */
   void main() {
    float theta, v, h, d, t;
    theta = 45.0;
    v = 12.0;
    h = Height(theta, v);
    d = Distance(theta, v);
    t = Flight_time(theta, v);
   }
   Figure 4.32: Program for Example 4.20

   Software development tools are computer programs, usually run on personal computers, that allow the programmer (or system developer) to create, modify, and test applications programs. Some common software development tools are:
   • Text editors
   • Assemblers/compilers
   • Simulators
   • High-level language simulators
   • Integrated development environments (IDEs)

   A text editor is used to create or edit programs and text files. The Windows operating system comes with a text editor program called Notepad. Using Notepad, we can create a new program file, modify an existing file, or display or print the contents of a file. It is important to realize that programs used for word processing, such as Microsoft Word, cannot be used for this purpose, since they embed word formatting characters such as bold, italic, and underline within the text.
   Most assemblers and compilers come with built-in text editors, making it possible to create a program and then assemble or compile it without having to exit from the editor. These editors provide additional features as well, such as automatic keyword highlighting, syntax checking, parenthesis matching, and comment line identification. Different parts of a program can be shown in different colors to make the program more readable (e.g., comments in one color and keywords in another). Such features help to eliminate syntax errors during the programming stage, thus speeding up the development process.

   Assemblers generate executable code from assembly language programs, and that generated code can then be loaded into the flash program memory of a PIC18-based microcontroller. Compilers generate executable code from high-level language programs. The compilers used most often for PIC18 microcontrollers are BASIC, C, and PASCAL.
   Assembly language is used in applications where processing speed is critical and the microcontroller must respond to external and internal events in the shortest possible time. However, it is difficult to develop complex programs using assembly language, and assembly language programs are not easy to maintain.
   High-level languages, on the other hand, are easier to learn, and complex programs can be developed and tested in a much shorter time. High-level programs are also maintained more easily than assembly language programs.
   Discussions of programming in this book are limited to the C language. Many different C language compilers are available for developing PIC18 microcontroller-based programs. Some of the popular ones are:
   • CCS C (http://www.ccsinfo.com)
   • Hi-Tech C (http://htsoft.com)
   • C18 C (http://www.microchip.com)
   • mikroC C (http://www.mikroe.com)
   • Wiz-C C (http://www.fored.co.uk)
   Although most C compilers are essentially the same, each one has its own additions or modifications to the standard language. The C compiler used in this book is mikroC, developed by mikroElektronika.

   A simulator is a computer program that runs on a PC without the microcontroller hardware. It simulates the behavior of the target microcontroller by interpreting the user program instructions using the microcontroller instruction set. Simulators can display the contents of registers, memory, and the status of input-output ports as the user program is interpreted. Breakpoints can be set to stop the program and check the contents of various registers at desired locations. In addition, the user program can be executed in a single-step mode, so the memory and registers can be examined as the program executes one instruction at a time as a key is pressed.
   Some assembler programs contain built-in simulators. Three popular PIC18 microcontroller assemblers with built-in simulators are:
   • MPLAB IDE (http://www.microchip.com)
   • Oshon Software PIC18 simulator (http://www.oshonsoft.com)
   • Forest Electronics PIC18 assembler (http://www.fored.co.uk)

   High-level language simulators, also known as source-level debuggers, are programs that run on a PC and locate errors in high-level programs. The programmer can set breakpoints in high-level statements, execute the program up to a breakpoint, and then view the values of program variables, the contents of registers, and memory locations at that breakpoint.
   A source-level debugger can also invoke hardware-based debugging using a hardware debugger device. For example, the user program on the target microcontroller can be stopped and the values of various variables and registers can be examined.
   Some high-level language compilers, including the following three, have built-in source-level debuggers:
   • C18 C
   • Hi-Tech PIC18 C
   • mikroC C

   Integrated development environments (IDEs) are powerful PC-based programs which include everything to edit, assemble, compile, link, simulate, and source-level debug a program, and then download the generated executable code to the physical microcontroller chip using a programmer device. These programs are in graphical user interface (GUI), where the user can select various options from the program without having to exit it. IDEs can be extremely useful when developing microcontroller-based systems. Most PIC18 high-level language compilers are IDEs, thus enabling the programmer to do most tasks within a single software development tool.

   Numerous hardware development tools are available for the PIC18 microcontrollers. Some of these products are manufactured by Microchip Inc., and some by third-party companies. The most ones are:
   • Development boards
   • Device programmers
   • In-circuit debuggers
   • In-circuit emulators
   • Breadboards

   Development boards are invaluable microcontroller development tools. Simple development boards contain just a microcontroller and the necessary clock circuitry. Some sophisticated development boards contain LEDs, LCD, push buttons, serial ports, USB port, power supply circuit, device programming hardware, and so on. This section is a survey of various commercially available PIC18 microcontroller development boards and their specifications.

LAB-XUSB Experimenter Board

   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:
   • 40-pin ZIF socket for PIC microcontroller
   • 5-volt regulator
   • 20MHz oscillator
   • Reset button
   • 16-switch keypad
   • Two potentiometers
   • Four LEDs
   • 2-line by 20-character LCD module
   • Speaker
   • RC servo connector
   • RS232 interface
   • USB connector
   • Socket for digital-to-analog converter (device not included)
   • Socket for I²C serial EEPROM (device not included)
   • Socket for Dallas DS1307 real-time clock (device not included)
   • Pads for Dallas DS18S20 temperature sensors (device not included)
   • In-circuit programming connector
   • Prototyping area for additional circuits

PICDEM 2 Plus

   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:
   • 2×16 LCD display
   • Piezo sounder driven by PWM signal
   • Active RS-232 port
   • On-board temperature sensor
   • Four LEDs
   • Two push-button switches and master reset
   • Sample PIC18F4520 and PIC16F877A flash microcontrollers
   • MPLAB REAL ICE/MPLAB ICD 2 connector
   • Source code for all programs
   • Demonstration program displaying a real-time clock and ambient temperature
   • Generous prototyping area
   • Works off of a 9V battery or DC power pack

PICDEM 4

   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:
   • Three different sockets supporting 8-, 14-, and 18-pin DIP devices
   • On-board +5V regulator for direct input from 9V, 100 mA AC/DC wall adapter
   • Active RS-232 port
   • Eight LEDs
   • 2×16 LCD display
   • Three push-button switches and master reset
   • Generous prototyping area
   • I/O expander
   • Supercapacitor circuitry
   • Area for an LIN transceiver
   • Area for a motor driver
   • MPLAB ICD 2 connector

PICDEM HPC Explorer Board

   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.
   Figure 5.4: PICDEM HPC Explorer development board
   The main features of this board are:
   • PIC18F8722, 128K flash, 80-pin TQFP microcontroller
   • Supports PIC18 J-series devices with plug-in modules
   • 10 MHz crystal oscillator (to be used with internal PLL to provide 40 MHz operation)
   • Power supply connector and programmable voltage regulator, capable of operation from 2.0 to 5.5 V
   • Potentiometer (connected to 10-bit A/D, analog input channel)
   • Temperature sensor demo included
   • Eight LEDs (connected to PORTD with jumper disable)
   • RS-232 port (9-pin D-type connector, UART1)
   • Reset button
   • 32 KHz crystal for real-time clock demonstration

MK-1 Universal PIC Development Board

   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:
   • On-board selectable 3.3V or 5V
   • 16×2 LCD character display (8-or 4-bit mode supported)
   • 4-digit multiplexed 7-segment display
   • Ten LED bar graph (can be used as individual LEDs)
   • Eight-position dip switch
   • Socketed oscillator for easy change of oscillators
   • Stepper motor driver with integrated driver
   • I²C real-time clock with crystal and battery backup support
   • I²C temperature sensor with 0.5 degree C precision
   • Three potentiometers for direct A/D development
   • 16-button telephone keypad wired as 4×4 matrix
   • RS232 driver with standard DB9 connector
   • Socketed SPI and I²C EEPROM
   • RF Xmit and receive sockets
   • IR Xmit and receive
   • External drive buzzer
   • Easy access to pull up resistors
   • AC adapter included

SSE452 Development Board

   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:
   • One PCB suitable for any 28-or 40-pin PIC18 devices
   • Three external interrupt pins
   • Two input-capture/output-compare/pulse-width modulation modules (CCP)
   • Support SPI, I²C functions
   • 10-bit analog-to-digital converter
   • RS-232 connector
   • Two debounced push-button switches
   • An 8-bit DIP-switch for digital input
   • 4×4 keypad connector
   • Rotary encoder with push button
   • TC77 SPI temperature sensor
   • EEPROM (24LC04B)
   • 2×20 bus expansion port
   • ICD2 connector
   • On-board multiple digital signals from 1Hz to 8MHz
   • Optional devices are 2×20 character LCD, 48/28-pin ZIF socket

SSE8720 Development Board

   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:
   • 20MHz oscillator with socket
   • One DB9 connector provides EIA232 interface
   • In-circuit debugger (ICD) connector
   • Four debounced switches, and one reset switch
   • 4×4 keypad connector
   • One potentiometer for analog-to-digital conversion
   • Eight red LEDs
   • 8-bit DIP switch for digital inputs
   • 2×20 character LCD module
   • Twenty-four different digital signals, from 1Hz to 16MHz
   • On-board 5V regulator
   • One I²C EEPROM with socket
   • SPI-compatible digital temperature sensor
   • SPI-compatible real-time clock
   • CCP1 output via an NPN transistor

SSE8680 Development Board

   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:
   • 20MHz oscillator with socket
   • One DB9 connector provides EIA232 interface
   • In-circuit debugger (ICD) connector
   • Four debounced switches, and one reset switch
   • 4×4 keypad connector
   • One potentiometer for analog-to-digital conversion
   • 8 red LEDs
   • 8-bit DIP switch for digital inputs
   • 2×20 character LCD module
   • Twenty-four different digital signals, from 1Hz to 16MHz
   • On-board 5V regulator
   • One I²C EPROM with socket
   • SPI-compatible digital temperature sensor
   • SPI-compatible real-time clock
   • CCP1 output via an NPN transistor
   • Rotary encoder
   • CAN transceiver

PIC18F4520 Development Kit

   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:
   • PCWH compiler
   • PIC18F4520 prototyping board
   • Breadboard area
   • 93LC56 serial EEPROM chip
   • DS1631 digital thermometer chip
   • NJU6355 real-time clock IC with attached 32.768KHz crystal
   • Two-digit 7-segment LED module
   • In-circuit debugger/programmer
   • DC adapter and cables
   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.

BIGPIC4 Development Kit

   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:
   • Forty-six buttons
   • Forty-six LEDs
   • USB connector
   • External or USB power supply
   • Two potentiometers
   • Graphics LCD
   • 2×16 text LCD
   • MMC/SD memory card slot
   • Two serial RS232 ports
   • In-circuit debugger
   • Programmer
   • PS2 connector
   • Digital thermometer chip (DS1820)
   • Analog inputs
   • Reset button
   The BIGPIC4 is used in some of the projects in this book.

FUTURLEC PIC18F458 Training Board

   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:
   • PIC18F458 microcontroller with 10MHz crystal
   • RS232 communication
   • Test LED
   • Optional real-time clock chip with battery backup
   • LCD connection
   • Optional RS485/RS422 with optional chip
   • CAN and SPI controller
   • I²C expansion
   • In-circuit programming
   • Reset button
   • Speaker
   • Relay socket
   • All port pins are available at connectors

   After the program is written and translated into executable code, the resulting HEX file is loaded to the target microcontroller’s program memory with the help of a device programmer. The type of device programmer depends on the type of microcontroller to be programmed. For example, some device programmers can only program PIC16 series, some can program both PIC16 and PIC18 series, while some are designed to program other microcontroller models (e.g., the Intel 8051 series).
   Some microcontroller development kits include on-board device programmers, so the microcontroller chip does not need to be removed and inserted into a separate programming device. This section describes some of the popular device programmers used to program PIC18 series of microcontrollers.

Forest Electronics USB Programmer

   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

Mach X 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

Melabs U2 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

EasyProg PIC 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

PIC Prog Plus 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

   An in-circuit debugger is hardware connected between a PC and the target microcontroller test system used to debug real-time applications quickly and easily. With in-circuit debugging, a monitor program runs in the PIC microcontroller in the test circuit. The programmer can set breakpoints on the PIC, run code, single-step the program, and examine variables and registers on the real device and, if required, change their values. An in-circuit debugger uses some memory and I/O pins of the target PIC microcontroller during debugging operations. Some in-circuit debuggers only debug assembly language programs. Other, more powerful debuggers can debug high-level language programs.
   This section discusses some of the popular in-circuit debuggers used in PIC18 microcontroller-based system applications.

ICD2

   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.

ICD-U40

   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

PICFlash 2

   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 in-circuit emulator (ICE) is one of the oldest and the most powerful devices for debugging a microcontroller system. It is also the only tool that substitutes its own internal processor for the one in the target system. Like all in-circuit debuggers, the emulator’s primary function is target access—the ability to examine and change the contents of registers, memory, and I/O. Since the emulator replaces the CPU, it does not require a working CPU in the target system. This makes the in-circuit emulator by far the best tool for troubleshooting new or defective systems.
   In general, each microcontroller family has its own set of in-circuit emulators. For example, an in-circuit emulator designed for the PIC16 microcontrollers cannot be used for PIC18 microcontrollers. Moreover, the cost of in-circuit emulators is usually quite high. To keep costs down, emulator manufacturers provide a base board which can be used with most microcontrollers in a given family, for example, with all PIC microcontrollers, and also make available probe cards for individual microcontrollers. To emulate a new microcontroller in the same family, then, only the specific probe card has to be purchased.
   Several models of in-circuit emulators are available on the market. The following four are some of the more popular ones.

MPLAB ICE 4000

   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

RICE3000

   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.

ICEPIC 3

   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

PICE-MC

   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

   Building an electronic circuit requires connecting the components as shown in the relevant circuit diagram, usually by soldering the components together on a strip board or a printed circuit board (PCB). This approach is appropriate for circuits that have been tested and are functioning as desired, and also when the circuit is being made permanent. However, making a PCB design for just a few applications — for instance, while still developing the circuit — is not economical.
   Instead, while the circuit is still under development, the components are usually assembled on a solderless breadboard. A typical breadboard (see Figure 5.24) consists of rows and columns of holes spaced so that integrated circuits and other components can be fitted inside them. The holes have spring actions so the component leads are held tightly in place. There are various types and sizes of breadboards, suitable for circuits of different complexities. Breadboards can also be stacked together to make larger boards for very complex circuits. Figure 5.25 shows the internal connection layout of the breadboard in Figure 5.24.
   Figure 5.24: A typical breadboard layout
   Figure 5.25: Internal wiring of the breadboard in Figure 5.24
   The top and bottom halves of the breadboard are entirely separate. Columns 1 to 20 in rows A to F are connected to each other on a column basis. Rows G to L in columns 1 to 20 are likewise connected to each other on a column basis. Integrated circuits are placed such that the legs on one side are on the top half of the breadboard, and the legs on the other side are on the bottom half. The two columns on the far left of the board are usually reserved for the power and ground connections. Connections between components are usually made with stranded (or solid) wires plugged into the holes to be connected.
   Figure 5.26 shows a breadboard holding two integrated circuits and a number of resistors and capacitors.
   Figure 5.26: Picture of a breadboard with some components
   The nice thing about breadboard design is that the circuit can be modified easily and quickly, and ideas can be tested without having to solder the components. Once a circuit has been tested and is working satisfactorily, the components are easily removed and the breadboard can be used for other projects.

   In this book we are using the mikroC compiler developed by mikroElektronika. Before using this compiler, we need to know how the mikroC integrated development environment (IDE) is organized and how to write, compile, and simulate a program in the mikroC language. In this section we will look at the operation of the mikroC IDE in detail.
   A free 2K program size limited version of the mikroC IDE, available on the mikroElektronika web site (www.mikroe.com), is adequate for most small or medium-sized applications. Alternatively, you can purchase a license and turn the limited version into a fully working, unlimited IDE to use for projects of any size and complexity.
   After installing the mikroC IDE, a new icon should appear by default on your desktop. Double-click this icon to start the IDE.

   After the mikroC icon is double-clicked to start the IDE, the screen shown in Figure 5.27 is displayed by default.
   Figure 5.27: mikroC IDE screen
   The screen is divided into four areas: the top-left section, the bottom-left section, the middle section, and the bottom section.

Top-Left Section

   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

Bottom-Left Section

   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

Middle Section

   The middle section is the Code Editor, an advanced text editor. Programs are written in this section of the screen. The Code Editor supports:
   • Code Assistant
   • Parameter Assistant
   • Code Template
   • Auto Correct
   • Bookmarks
   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.

Bottom Section

   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

   mikroC files are organized into projects, and all files for a single project are stored in the same folder. By default, a project file has the extension “.ppc”. A project file contains the project name, the target microcontroller device, device configuration flags, the device clock, and list of source files with their paths. C source files have the extension “.c”.
   The following example illustrates step-by-step how to create and compile a program source file.

Example 5.1

   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:
   Step 1  Double-click the mikroC icon to start the IDE.
   Step 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
   Step 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;
   }
   Step 4  Save the program with the name EXAMPLE by clicking File→Save As. The program will be saved with the name EXAMPLE.C.
   Step 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
   Step 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.
   ; 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 $
   Figure 5.40: EXAMPLE.ASM
   .LST file  This is the listing file of the program. Figure 5.41 shows the EXAMPLE.LST file.
   ; 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 $
 
   //** 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
   Figure 5.41: EXAMPLE.LST
   .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.
   :1000000004EF00F0FFFFFFFF946A156A166A010E05
   :10001000176E000E186E000E006E1850005C02E1A4
   :1000200017500A0807E31750152618501622174ACA
   :10003000182AF1D715C082FFFFD7FFFFFFFFFFFF90
   :020000040030CA
   :0E000000FFF9FFFEFFFFFBFFFFFFFFFFFFFF0B
   :00000001FF
   Figure 5.42: EXAMPLE.HEX

   The program developed in Section 5.3.2 is simulated following the steps given here, using the simulator in software (release mode). That is, no hardware is used in this simulation.

Example 5.2

   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?

Solution 5.2

   The steps are as follows:
   Step 1  Start the mikroC IDE, making sure the program developed in Example 5.1 is displayed in the Code Editor window.
   Step 2  From the drop-down menu select Debugger→Select Debugger→Software PIC Simulator, as shown in Figure 5.43.
   Figure 5.43: Selecting the debugger
   Step 3  From the drop-down menu select Run→Start Debugger. The debugger form shown in Figure 5.44 will appear.
   Figure 5.44: Starting the debugger
   Step 4  Select the variables we want to see during the simulation. Assuming we want to display the values of variables Sum, i, and PORTC:
    • Click on Select from variable list and then find and click on the variable name Sum
    • Click Add to add this variable to the Watch list
    • Repeat these steps for variable i and PORTC
   The debugger window should now look like Figure 5.45.
   Figure 5.45: Selecting variables to be displayed
   Step 5  We can now single-step the program and see the variables changing.
   Press the F8 key on the keyboard. You should see a blue line to move down. This shows the line where the program is currently executing. Keep pressing F8 until you are inside the loop and you will see that variables Sum and i have become 1, as shown in Figure 5.46. Recently changed items appear in red. Double-clicking an item in the Watch window opens the Edit Value window, where you can change the value of a variable or register, or display the value in other bases such as decimal, hexadecimal, binary, or as a floating point or character.
   Figure 5.46: Single-stepping through the program
   Step 6  Keep pressing F8 until the program comes out of the for loop and executes the line that sends data to PORTC. A this point, as shown in Figure 5.47, i = 11 and Sum = 55.
   Figure 5.47: Single-stepping through the program
   Step 7  Press F8 again to send the value of variable Sum to PORTC. As shown in Figure 5.48, in this case PORTC will have the decimal value 55, which is the sum of numbers from 1 to 10.
   Figure 5.48: PORTC has the value 55
   This is the end of the simulation. Select from drop-down menu Run→Stop Debugger.
   In the above simulation example, we single-stepped through the program to the end and then we could see the final value of PORTC. The next example shows how to set breakpoints in the program and then execute up to a breakpoint.

Example 5.3

   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?

Solution 5.3

   The steps are as follows:
   Step 1  Start the mikroC IDE, making sure the program developed in Example 5.1 is displayed in the Code Editor window.
   Step 2  From the drop-down menu select Debugger→Select Debugger→Software PIC Simulator.
   Step 3  From the drop-down menu select Run→Start Debugger.
   Step 4  Select variables Sum, i, and PORTC from the Watch window as described in Example 5.2.
   Step 5  To set a breakpoint at the end of the program, click the mouse at the last closing bracket of the program, which is at line 27, and press F5. As shown in Figure 5.49, you should see a red line at the breakpoint and a little marker in the left column of the Code Editor window.
   Figure 5.49: Setting a breakpoint at line 27
   Step 6  Now, start the debugger, and press F6 key to run the program. The program will stop at the breakpoint, displaying variables as shown in Figure 5.48.
   This is the end of the simulation. Select from drop-down menu Run→Stop Debugger.
   To clear a breakpoint, move the cursor over the line where the breakpoint is and then press F5. To clear all breakpoints in a program, press the SHIFT+CTRL+F5 keys. To display the breakpoints in a program, press the SHIFT+F4 keys.
   The following are some other useful debugger commands:
   Step Into [F7]  Executes the current instruction and then halts. If the instruction is a call to a routine, the program enters the routine and halts at the first instruction.
   Step Over [F8]  Executes the current instruction and then halts. If the instruction is a call to a routine, it skips it and halts at the first instruction following the call.
   Step Out [CTRL+F8]  Executes the current instruction and then halts. If the instruction is within a routine, it executes the instruction and halts at the first instruction following the call.
   Run to Cursor [F4]  Executes all instructions between the current instruction and the cursor position.
   Jump to Interrupt [F2]  Jumps to the interrupt service routine address (address 0x08 for PIC18 microcontrollers) and executes the procedure located at that address.

   This section discusses how to use the mikroICD in-circuit debugger (also called the PICFlash 2 programmer) to debug the program developed in Example 5.1. First of all, we have to build the hardware and then connect the in-circuit debugger device. In this example, the hardware is built on a breadboard, and a PICFlash 2 mikroICD in-circuit debugger is used to debug the system. Note that pins RB6 and RB7 are used by the mikroICD and are not available for I/O while mikroICD is active.

The Circuit Diagram

   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:
   • MCLR
   • RB6
   • RB7
   • +5V
   • GND
   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

Debugging

   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:
   Step 1  Start the mikroC IDE, making sure the program developed in Example 5.1 is displayed in the Code Editor window.
   Step 2  Click the Edit Project button (Figure 5.52) and set DEBUG_ON as shown in Figure 5.53.
   Figure 5.52: Edit Project button
   Figure 5.53: Set the DEBUG_ON
   Step 3  Select ICD Debug in the Project Setup window as shown in Figure 5.54.
   Figure 5.54: Select the ICD Debug
   Step 4  Click the Build Project icon to compile the program with the debugger. After a successful compilation you should see the message Success (ICD Build) in the Message Window.
   Step 5  Make sure the mikroICD debugger device is connected as in Figure 5.50, and select Tools→PicFlash Programmer from the drop-down menu to program the microcontroller.
   Step 6  From the drop-down menu select Debugger→Select Debugger→mikroICD Debugger as shown in Figure 5.55.
   Figure 5.55: Selecting the mikroICD debugger
   Step 7  From the drop-down menu select Run→Start Debugger. The debugger form will pop up and select variables Sum, i, and PORTC as described in Example 5.2.
   Step 8  Single-step through the program by pressing the F8 key. You should see the values of variables changing. At the end of the program, decimal value 55 will be sent to PORTC, and LEDs 0,1,2,4, and 5 should be turned ON, as shown in Figure 5.56, corresponding to this number.
   Figure 5.56: Decimal number 55 shown in LEDs
   Step 9  Stop the debugger.
   In routines that contain delays, the Step Into [F7] and Step Over [F8] commands can take a long time. Run to Cursor [F4] and breakpoints should be used instead.