Файл: Kit 81 Simple PICMicro programmer (2002).pdf

DIY K81 Project - Page 10

It’s not hard to see why hex and decimal are easier to use. Imagine a 64 bit number and larger still. These are common in today’s computers and are sometimes used with PIC’s.

Lets try to see what this value equals.

First off, split the number into bytes.

Looking Easier - Now split these into nibbles.

1000 1100 1010 0000 1000 1100 1010 0000

Even easier - Now convert these into hex. This may be difficult at first, but persevere. After awhile you will be able to convert binary to hex and vice versa quite easily.

Combine the hex numbers for our result.

8CA08CA0

DIY K81 Project - Page 11

To show that we are talking in hex values we put in a little (h) after the number like this.

8CA08CA0h

If you are dealing with PIC programming and are working with a PIC assembler then hex numbers that begin with a letter should be preceded by 0x.

0xFF45AC 0xA786097

You can also use this notation if the value starts with a number.

0x8CA08CA0 0x000011

Lets convert that hex number back to decimal again.

Remember in decimal, each value in the columns increases by a power of 10 as we move to the left, and in binary they increase by a power of 2. In hex, as you may have guessed, they increase by a power of 16. Be like me if you wish to, cheat and use a calculator to convert between the three number systems, it is much easier. In fact having a calculator that does these conversions is a very good investment for a programmer.

Lets start from right to left and convert each individual hex number to decimal.

Add up the last column and we get a total of 2,359,332,000.

Therefore:

10001100101000001000110010100000 = 8CA08CA0h = 2,359,332,000.

Isn’t it lucky that we don’t have to think like computers.

DIY K81 Project - Page 12

The PIC can only deal with individual 8 bit numbers, but as your programming skills increase and depending on your software requirements, you will eventually need to know how to make it work with larger numbers.

When you combine 2 bytes together, the binary number becomes a word.

Remember:

Break large problems into many smaller ones because the overall problem will be much easier to solve. This is when planning becomes important.

Well then, just how do we create a hex file like this.

The answer is - by using an Assembler.

The Assembler

Assembler is easy - easy - easy.

An assembler is quite an ingenious piece of software because it can read a text file that we have written as our program and turn it into a data file similar to the sample above.

We can actually write our programs by collecting all the hex values that our program will use, and then create a data file ourselves. The trouble with that idea is that it is a very tedious task and it would be terribly painful to try and find errors in it especially in large projects.

The program data file that we saw earlier is just a list of hex numbers. Most of these numbers represent the program instructions and any data that these instructions need to work with.

To combine data and instructions together, the PIC uses a special binary number that is 14 bits wide. If you look at the data sheet, you will see that the PIC 16F84A has 1024 14 bit words available for program storage. In computer language 1024 means 1K, so this PIC has 1K of program space.

Assembler language enables us to write code in such a way that we can understand and write it easily.

DIY K81 Project - Page 13

Some people do not want to write code in assembler because they think it is too hard to learn, and writing code in a language such as BASIC is much easier. This can be true, but sometimes you cannot write tight and fast code with these higher level languages and this may not be the best course of action for your particular project.

This is especially so with PIC’s because there are only 35 instructions to work with. Sometimes you will get into difficulty with assembler such as solving problems with multiply and divide, but these routines are freely available from many sources including the internet. Once you have them, it is usually only a simple matter of pasting them into your code if needed. Mostly, you will not even care how they work, but it is a good exercise to learn the techniques involved because it builds up your own individual knowledge.

Saving special code routines in a directory on your PC can be very productive and this is termed a Code Library.

Writing code for an assembler is quite easy, but as with most things there are a few things to learn.

First off, the code you are writing for the assembler is calledSource Code. After the assembler has assembled the source code successfully, it generates another file that is called Object Code. This is the hex data file we saw earlier.

When you use the assembler program, there are some options that you can enable or disable such as, generating an error file, case sensitivity in your source code and a few others. Mostly you can ignore these and leave the default settings, but when you get more advanced at programming, you may like to change them to make the assembler work more suitably for your particular needs.

The assembler must be able to understand every line of source code that you write or it will generate an error. If this happens, the object code will not be created and you will not be able to program a chip.

Each line of code in the source file can contain some or all of these following types of information. The order and position of these items on each line is also important.

Labels

Mnemonics

Operands

Comments

DIY K81 Project - Page 14

Labels must start in the left most column of the text editor.

Mnemonics can start in column two and any other past this point.

Operands come after the mnemonic and are usually separated by a space.

Comments can be on any line usually after an operand, but they can also take up an entire line and are followed by the semi colon character (;).

One or more spaces must separate the labels, mnemonics and operands. Some operands are separated by a comma.

Here is a sample of the text that an assembler expects.

Title "Simple Program"

;

;-------------

;PROGRAM START

;-------------

end

You can see the label called start in column 1. Then comes a tab or space(s) to separate the label from the mnemonic movlw. Then comes another tab or space(s) to separate the mnemonic from the operand 0x04. Finally, you can see the comment which comes after the semi colon ; simple code

Lets have a look at his a bit closer.

The first line has a Title directive.

This is a predefined part of the assemblers internal language and lets you define a name for your source code listing.

The next line has a list assembler directive and tells the assembler what type of processor it is assembling for - in this case, a 16F84A chip. This feature can be helpful if you write too much code for this particular processor to use.

DIY K81 Project - Page 15

The assembler will check how much code it has assembled and let you know if it is too much to fit in that particular chip. Directives like these control how the assembler builds the final object code.

The next lines are just comments put there to help you the programmer know what is going on.

;

;-------------

;PROGRAM START

;-------------

It is vital that you get into the habit of writing comments all over your code. This will help you understand what you have written especially when you come back to read it another time. Believe me, it is very easy to get confused trying to follow the meaning of your code if there is no explanation on how it works. Notice how comments begin with a semi colon (;). Any line that begins with one of these is ignored.

Org 0h is another directive that tells the assembler to set the current memory address where the following instructions will be placed into. Remember that the

16F84A has 1024 location available for code use.Org 0h tells the assembler to start loading the instructions starting from memory address 0. In other words the movlw 0x00 instruction will occupy memory location 0 and the movwf 0x05 instruction will occupy memory location 1. goto start will occupy memory location 2.

One thing you may have missed here, is the fact that memory addresses start from location 0, not location 1. The code memory space is actually from 0 to 1023, not from 1 to 1024. Remember 0 is a valid binary number.

It is probably best to use the correct terminology now to refer to code memory locations as ROM addresses - Read Only Memory.

goto start is an instruction mnemonic followed by a label name. The assembler knows that the instruction start movlw 0x00 is at ROM address

0, so when it sees the instruction goto start, it will generate code to tell the

PIC’s processor to goto ROM address 0 to fetch the next instruction.

So what happens if there is no label called start anywhere in the source listing?

The assembler will complain that it cannot find the label, generate an error and will not complete the assembly process. Usually these errors are written to a separate error file and in a listing file as well. These files have the same name as your source file but with *.err and *.lst extensions.

DIY K81 Project - Page 16