Chapter 1: The Basics
Introduction
Simplicity and ease which higher programming languages bring in, as well as broad application of microcontrollers today, were reasons to incite some companies to adjust and upgrade BASIC programming language to better suit needs of microcontroller programming. What did we thereby get? First of all, developing applications is faster and easier with all the predefined routines which BASIC brings in, whose programming in assembly would take the largest amount of time. This allows programmer to concentrate on solving the important tasks without wasting his time on, say, code for printing on LCD display.
To avoid any confusion in the further text, we need to clarify several terms we will be using frequently throughout the book:
Programming language is a set of commands and rules according to which we write the program. There are various programming languages such as BASIC, C, Pascal, etc. There is plenty of resources on BASIC programming language out there, so we will focus our attention particularly to programming of microcontrollers.
Program consists of a sequence of commands written in programming language that microcontroller executes one after another. Chapter 2 deals with the structure of BASIC program in details.
Compiler is a program run on computer and its task is to translate the original BASIC code into language of zeros and ones that can be fed to microcontroller. The process of translation of BASIC program into executive HEX code is shown in the figure below. The program written in BASIC and saved as file program.pbas is converted by compiler into assembly code (program.asm). The generated assembly code is further translated into executive HEX code which can be written to microcontroller memory.
Programmer is a device which we use to transfer our HEX files from computer to microcontroller memory.
1.1 Why BASIC?
Originally devised as an easy-to-use tool, BASIC became widespread on home microcomputers in the 1980s, and remains popular to this day in a handful of heavily evolved dialects. BASIC’s name, coined in classic, computer science tradition to produce a nice acronym, stands for Beginner’s All-purpose Symbolic Instruction Code.
BASIC is still considered by many PC users to be the easiest programming language to use. Nowadays, this reputation is being shifted to the world of microcontrollers. BASIC allows faster and much easier development of applications for PIC compared to the Microchip’s assembly language MPASM. When writing the code for MCUs, programmers frequently deal with the same issues, such as serial communication, printing on LCD display, generating PWM signals, etc. For the purpose of facilitating programming, BASIC provides a number of built-in and library routines intended for solving these problems.
As far as the execution and program size are in question, MPASM has a small advantage in respect with BASIC. This is why there is an option of combining BASIC and assembly code — assembly is commonly used for parts of program in which execution time is critical or same commands are executed great number of times. Modern microcontrollers, such as PIC, execute instructions in a single cycle. If microcontroller clock is 4MHz, then one assembly instruction requires 250ns x 4 = 1us. As each BASIC command is technically a sequence of assembly instructions, the exact time necessary for its execution can be calculated by simply summing up the execution times of constituent assembly instructions.
1.2 Choosing the right PIC for the task
Currently, the best choice for application development using BASIC are: the famous PIC16F84, PIC16F87x, PIC16F62x, PIC18Fxxx. These controllers have program memory built on FLASH technology which provides fast erasing and reprogramming, thus allowing fast debugging. By a single mouse click in the programming software, microcontroller program can be instantly erased and then reloaded without removing chip from device. Also, program loaded in FLASH memory can be stored after the power is off. Beside FLASH memory, microcontrollers of PIC16F87x and PIC16F84 series also contain 64-256 bytes of internal EEPROM memory, which can be used for storing program data and other parameters when power is off. BASIC features built-in EEPROM_Read and EEPROM_Write instructions that can be used for loading and saving data to EEPROM.
Older PIC microcontroller families (12C67x, 14C000, 16C55x, 16C6xx, 16C7xx, and 16C92x) have program memory built on EPROM/ROM technology, so they can either be programmed only once (OTP version with ROM memory) or have a glass window (JW version with EPROM memory) which allows erasing by few minutes exposure to UV light. OTP versions are usually cheaper and are a natural choice for manufacturing large series of products.
In order to have complete information about specific microcontroller in the application, you should get the appropriate Data Sheet or Microchip CD-ROM.
 |
The program examples worked out throughout the book are mostly to be run on the microcontrollers PIC16F84 or PIC6F877, but with minor adjustments, can be run on any other PIC microcontroller. |
1.3 A word about code writing
Technically, any text editor that can save program file as pure ASCII text (without special symbols for formatting) can be used for writing your BASIC code. Still, there is no need to do it “by hand” — there are specialized environments that take care of the code syntax, free the memory and provide all the necessary tools for writing a program.
mikroBasic IDE includes highly adaptable Code Editor, fashioned to satisfy needs of both novice users and experienced programmers. Syntax Highlighting, Code Templates, Code & Parameter Assistant, Auto Correct for common typos, and other features provide comfortable environment for writing a program.
If you had no previous experience with advanced IDEs, you may wonder what Code and Parameter Assistants do. These are utilities which facilitate the code writing. For example, if you type first few letter of a word in Code Editor and then press CTRL+SPACE, all valid identifiers matching the letters you typed will be prompted to you in a floating panel. Now you can keep typing to narrow the choice, or you can select one from the list using keyboard arrows and Enter.
In combination with comprehensive help, integrated tools, extensive libraries, and Code Explorer which allows you to easily monitor program items, all the necessary tools are at hand.
1.4 Writing and compiling your program
The first step is to write our code. Every source file is saved in a single text file with extension .pbas. Here is an example of one simple BASIC program, blink.pbas.
program LED_Blink
main:
TRISB = 0 ' Configure pins of PORTB as output
eloop:
PORTB = $FF ' Turn on diodes on PORTB
Delay_ms(1000) ' Wait 1 second
PORTB = 0 ' Turn off diodes on PORTB
Delay_ms(1000) ' Wait 1 second
goto eloop ' Stay in loop
end.
When the program is completed and saved as .pbas file, it can be compiled by clicking on Compile Icon (or just hit CTRL+F9) in mikroBasic IDE. The compiling procedure takes place in two consecutive steps:
- Compiler will convert
.pbasfile to assembly code and save it asblink.asmfile. - Then, compiler automatically calls assembly, which converts
.asmfile into executable HEX code ready for feeding to microcontroller.
You cannot actually make the difference between the two steps, as the process is completely automated and indivisible. In case of syntax error in program code, program will not be compiled and HEX file will not be generated. Errors need to be corrected in the original .pbas file and then the source file may be compiled again. The best approach is to write and test small, logical parts of the program to make debugging easier.
1.5 Loading program to microcontroller
As a result of successful compiling of our previous code, mikroBasic will generate following files:
- blink.asm - assembly file
- blink.lst - program listing
- blink.mcl - mikro compile library
- blink.hex - executable file which is written into the programming memory
MCL file (mikro compile library) is created for each module you have included in the project. In the process of compiling, .mcl files will be linked together to output asm, lst and hex files. If you want to distribute your module without disclosing the source code, you can send your compiled library (file extension .mcl). User will be able to use your library as if he had the source code. Although the compiler is able to determine which routines are implemented in the library, it is a common practice to provide routine prototypes in a separate text file.
HEX file is the one you need to program the microcontroller. Commonly, generated HEX will be standard 8-bit Merged Intel HEX format, accepted by the vast majority of the programming software. The programming device (programmer) with accessory software installed on PC is in charge of writing the physical contents of HEX file into the internal memory of a microcontroller. The contents of a file blink.hex is given below:
:100000000428FF3FFF3FFF3F031383168601FF30A5 :10001000831286000630F000FF30F100FF30F2005E :10002000F00B13281A28F10B16281928F20B1628A2 :10003000132810281A30F000FF30F100F00B2128AF :100040002428F10B21281E284230F000F00B26282E :1000500086010630F000FF30F100FF30F200F00BB7 :1000600032283928F10B35283828F20B3528322868 :100070002F281A30F000FF30F100F00B4028432801 :10008000F10B40283D284230F000F00B45280428B1 :100090004828FF3FFF3FFF3FFF3FFF3FFF3FFF3F3E :02400E007A3FF7 :00000001FF
Beside loading a program code into programming memory, programmer also configures the target microcontroller, including the type of oscillator, protection of memory against reading, watchdog timer, etc. The following figure shows the connection between PC, programming device and the MCU.
Note that the programming software should be used only for the communication with the programming device — it is not suitable for code writing.
1.6 Running the program
For proper functioning of microcontroller, it is necessary to provide power supply, oscillator, and a reset circuit. The supply can be set with the simple rectifier with Gretz junction and LM7805 circuit as shown in the figure below.
Oscillator can be 4MHz crystal and either two 22pF capacitors or the ceramic resonator of the same frequency (ceramic resonator already contains the mentioned capacitors, but unlike oscillator has three termination instead of only two). The rate at which the microcontroller operates, i.e. the speed at which the program runs, depends heavily on the oscillator frequency. During the application development, the easiest thing to do is to use the internal reset circuit — MCLR pin is connected to +5V through a 10K resistor. Below is the scheme of a rectifier with LM7805 circuit which gives the output of stable +5V, and the minimal configuration relevant for the operation of a PIC microcontroller.
After the supply is brought to the circuit previously shown, PIC microcontroller should look animated, and the LED diode should blink once every second. If the signal is completely missing (LED diode does not blink), then check if +5V is present at all the relevant pins of PIC.
1.7 Troubleshooting
There are several commonly encountered problems of bringing PIC microcontroller to working conditions. You need to check a few external components and test whether their values correspond to the desired ones, and finally to see whether all the connections are done right. We will present a few notes you may find useful.
- Check whether the MCLR pin is connected to +5V, over reset circuit, or simply with 10K resistor. If the pin remains disconnected, its level will be “floating” and it may work sometimes, but it usually won’t. Chip has power-on-reset circuit, so the appropriate external pull-up resistor on MCLR pin should be sufficient.
- Check whether the connection with the resonator is stable. For most PIC microcontrollers to begin with 4MHz resonator is well enough.
- Check the supply. PIC microcontroller consumes very little energy but the supply needs to be well filtrated. At the rectifier output, the current is direct but pulsating, and as such is not suitable for the supply of microcontroller. To avoid the pulsating, the electrolytic capacitor of high capacitance (e.g. 470 mF) is placed at the rectifier output.
- If PIC microcontroller supervises devices that pull a lot of energy, they may provoke enough malfunctioning on the supply lines to cause the microcontroller start behaving somewhat strangely. Even seven-segmented LED display may well induce tension drops (the worst scenario is when all the digits are 8, when LED display needs the most power), if the source itself is not capable to procure enough current (e.g. 9V battery).
- Some PIC microcontrollers feature multi-functional I/O pins, for example PIC16C62x family (PIC16C620, 621 and 622). Controllers of this family are provided with analog comparators on port A. After putting those chips to work, port A is set to analog mode, which brings about the unexpected behavior of the pin functions on the port. Upon reset, any PIC with analog inputs will show itself in analog mode (if the same pins are used as digital lines they need to be set to digital mode). One possible source of troubles is that the fourth pin of port A exhibits singular behavior when it is used as output, because the pin has open collectors output instead of usual bipolar state. This implies that clearing this pin will nevertheless set it to low level, while setting the pin will let it float somewhere in between, instead of setting it to high level. To make the pin behave as expected, the pull-up resistor was placed between RA4 and 5V. Its magnitude is between 4.7K and 10K, depending on the current necessary for the input. In this way, the pin functions as any other input pin (all pins are output after reset).
More problems are to be expected if you plan to be seriously working with PIC. Sometimes the thing seems like it is going to work, but it just won’t, regardless of the effort. Just remember that there is always more than one way to solve the problem, and that a different approach may bring solution.