The First Assembly Program - Part 5 Simple Microcontroller (PIC10F200)

Hi there! This is an auspicious moment. In this microcontroller tutorial, we start applying what we’ve learned and make things happen. This is our first tutorial devoted to writing code using Assembly language. Not just pure theory anymore, I’m going to give a description of the task or device, give the code that performs it and the code’s explanation. At first, I’ll have to explain a lot of stuff but the further in we go and the more samples we do, the less explanations you’ll need and the more confident you’ll be. Let's jump into some PIC microcontroller programming and see what happens!

I’ll organize this article as follows: First, I’ll give you what we need to do. Second, I’ll write the entire code that accomplishes the given task. Third, I’ll explain the code line by line as needed. So let’s go!

Today’s goal will be very easy – to light up LED1. Yeah, just light it up, not even blink. Assembly language is different from any other programming language, so be warned that some things may look very weird at first glance. Once you’ve prepared yourself mentally, then have a look at the Assembly program that does the given task:

This code should be written into the main.asm file that we created in the previous tutorial and then saved. I recommend typing this code in manually as it’ll force you to look at it more closely but copy and pasting won’t be the end of the world either. But let’s discuss what this code is doing before we execute.

Before we go line by line, let’s go over some basic formatting and organization with the Assembly language.

In general, each line of code will contain one of the following elements:

• Labels
• Mnemonics
• Opcodes and Operands
• Comments

Let’s consider each element briefly.

Labels simplify navigation in the program, they’re, in a way, the signposts of the program. Or perhaps GPS coordinates. You could use them in every line but you would be lost quickly if you did so due to information overload. So it’s better to put them only where needed - usually where they are used to perform branches or GOTO commands.

Labels always start in column 1, i.e. at the beginning of the line. So everything written in column 1 is considered a label other than comments.

Labels are case sensitive by default unlike mnemonics and operands which are case insensitive.

Labels must begin with a letter of the alphabet or an underscore, the max length is 32 characters.

Labels can be followed by a colon (:) or a whitespace.

In the code above there are two labels – INIT (for initiation/initiate) at line 6 and LOOP at line 10.

Mnemonics are Assembly instructions written as understandable text. These can also be called opcodes, operational codes, and more intuitively, are also called instructions. The instructions are code that tell the microcontroller to do something specific. They are given in the data sheet of the microcontroller.

Mnemonics must not start in column 1, and must be separated from a label by a colon or whitespace. Mnemonics are case insensitive by default.

Operands are the data, or parameters, used by mnemonics/opcodes/instructions. Some instructions may have no operands, or they could have 1 or 2 operands. They must be separated from mnemonics with whitespace, and from each other by a comma (,). In the code above, MOVLW ~(1 << GP1) has “MOVLW” as the opcode and “~(1 << GP1)” as the operand.

Comments are, as expected, comments. You can write anything you want; this text will be ignored by the compiler and is used to help remind you (and explain to others) what the code is doing. Comments can start anywhere with the semicolon (;) and lasts until the end of the line. So everything behind a semicolon is considered a comment. In most Integrated Development Environments, comments are highlighted with green.

Now that we know what the four main elements of Assembly are, let’s review the code. The first line is a directive - very similar to other, higher level languages.

Line 1 contains the Assembly directive #include.

Assembly directives are instructions in the code that tell the assembler how to assemble the file. They are not included in the final file that will be loaded into the PIC microcontroller. They just help us to make the program more readable and allows you to use pre-defined libraries, making our lives easier. We will consider them as found in the text.

So, the #include directive. If you are familiar with the C language you may exclaim “Hey! I know this one, it allows me to include another file in the current one” And you would be right. This directive works the same as in C. Moreover, the Assembly language supports conditional directives, e.g. #if, #ifdef, #define and others. So if you know how those work, feel free to use them.

With this particular directive, we include the “pic10f200.inc” file which is located in the folder with the Assembler. This file contains some definitions that will be helpful for us and specific to our microcontroller. I’ll name them when we meet them in the code.

Line 2 contains just a comment which tells us that the following line will set the processor configuration bits.

Line 3 as line 2 mentioned, this line sets the configuration bits with another Assembly directive __CONFIG followed by the bit values.

These configuration bits are used to set the global microcontroller operations. If you are familiar with AVR, these bits are like fuse bits. They can be loaded only while programming the chip and can’t be changed by the user code.

• _WDT_OFF disables the watchdog timer. This timer resets the microcontroller if the program hangs but we won’t need it.
• _CP_OFF disables code protection. I’m pretty sure intellectual property for lighting up an LED is open source, so we won’t worry about protecting our code.
• _MCLRE_OFF disables the reset function on pin GP3/MCLR/VPP and allows this pin to act as a typical input pin, GP3. For the current program it doesn’t matter but in the future this bit might be vital.

All three of these values are defined in the pic10f200.inc file, so that the program knows what the otherwise gibberish characters such as _CP_OFF actually means. Once we set these bits they will be loaded into the microcontroller during programming automatically.

Note that the bits are separated with an ampersand (&) not a comma. An ampersand in this case means a logical AND, like in C language.

I should note here that Assembly language can recognize a lot of the mathematical and logical operations from the C language. So if you are not familiar with them, please spend some time to learn them. Another important thing to understand is that these mathematical operations are performed by the Assembler and only the result is included into the microcontroller. I’ll repeat this again when we run into this again (spoiler: very soon).

Line 4 contains another Assembly directive, this time “ORG”, which sets the program origin.

As you can see, the argument of this directive is 0x0000 which means that the following code line will be started at address 0x0000 of the program memory. And this address is loaded into the PC (program counter) after reset.

Line 5, as mentioned, contains just a label INIT. This label has no important role as there are no links to it in the code, it just informs us that here the initialization part of the code is started (like setup() function in the Arduino).

The lines from 1 to 5 will be the same (or with minimal differences) in future programs, so you can just copy/paste this later.

Line 6 is the start of the real Assembly program with the first Assembly instruction MOVLW.

This mnemonic roughly stands for “MOVe Literal to W”. This instruction allows loading the “literal” into the W register. Literal is a formal way to refer to any byte of information (value from 0 to 255) represented in any convenient form. By default all numbers in the Assembly are represented as hexadecimal, so if you write MOVLW 14, that means in fact MOVLW 0x14, not decimal 14.

So care should be taken not to make a mistake. If you want to specify a decimal number you should write D’14’. I highly recommend you get comfortable with hexadecimal if you’re not already - it will help some commands become considerably more intuitive.

I didn’t talk about the W register when explaining the PIC10F200 structure but I’ll correct that now. W is a special register, called the “Working register” which doesn’t have a specific address you can access but it helps perform certain arithmetical, logical, or move operations. Some Assembly instructions can only be with the W register, while other instructions can only be applied to file registers.

As I mentioned earlier, the MOVLW instructions has one operand which is the literal we want to load into the W register. In line 6, it is written as ~(1 << GP1). This is another arithmetical expression solved by the Assembler, not the microcontroller - I told you this would be soon! But, if you’re not familiar with this notation, this could be extremely confusing.

Let’s look at this more in-depth. If you remember, our goal is to light up LED1, and to do this, we need to set GP1 as an output. Checking our datasheet, you can see that we need to clear the corresponding bit of the TRISGPIO register to 0, leaving all other bits as 1.

In the pic10f200.inc file, there is a mnemonic of sorts for each GPIO pin so that you don’t have to memorize the address or bit location for everything. In this case, GP1 acts as the “address” or location of the appropriate TRIS bit, and for GP1, the value happens to be “1”.

The expression ~(1 << GP1) has three parts. It means the value of “1” left shifted to the location of the GP1 bit, which, again, happens to be “1” in this case. “<<” is the left shift command. “1” is the number that is to be shifted. From the include file, “GP1” is the location of the TRIS bit in TRISGPIO, or 1.

The operation “~” performs a bitwise inversion of the value. It basically takes all the “0”s and makes them “1”s and all the “1”s and makes them “0”s. This will make more sense as we look at it step by step.

I will represent the value in binary for better understanding.

As you can see now, we got the value that we needed, it has only one 0 at bit position 1 while all other bits are 1s.

Again, while this may seem convoluted at first glance, as you get more comfortable and used to it, you’ll find it is significantly better in other ways. For example, you could write the same thing in the following ways:

• MOVLW 0xFD
• MOVLW D’253’
• MOVLW B’11111101’
  

All these lines are identical to the microcontroller itself. But these forms are not informative (why 253? What does it mean?) while the first form tells us directly what we are doing and why. Again, it might look complex at first but you will get used to it and it’s quite common for all microcontroller development.

We’ve spent a lot of time on Line 6 but have learned quite a bit! Let’s move on.

Line 7 contains another TRIS related instruction.

This is the special instruction; its only application is to copy the contents of the W register into the TRISGPIO register. Also, its only operand is the GPIO register.

So the TRIS instruction has a form that can’t be changed, otherwise it will not make any sense. So, just TRIS GPIO. Of course, if you don’t load the value you want into the W register first, this will copy whatever random values happen to be in the W register at the moment.

After implementation of this line the GP1 pin will be switched to the output direction, but to actually turn on the LED we need to set the corresponding bit of the GPIO register to 1. This takes us to line 8.

Line 8 has another instruction - BSF. I believe this mnemonic stands for “Bit Set F” which, is most useful if you remember that “setting” a bit is changing it to a “1”.

Fortunately, it’s a very simple instruction with only two operands. The first operand is an address and the second operand is bit within that address. BSF will set the specific bit defined at that address as a “1”. This instruction is only applicable to the file registers, and can’t work with the W register.

So BSF GPIO, GP1 sets the bit GP1 of the register GPIO as 1. After implementation of this line, LED1 will finally light up.

If we wanted, we could stop the program there but it’s good practice to loop the program instead of making the microcontroller restart code execution from the very beginning every time. So we’ll add another two lines before we end the program.

Line 9 contains just a label LOOP. We already know what labels are, so nothing interesting here.

Line 10 is more interesting. It contains the GOTO instruction. People who already are familiar with high-level programming might be shocked at this moment – “What? GOTO? This is terrible - it should never be used!” Calm down, please. In high level languages, GOTO is the operator and truly should be strictly avoided. But here, we’re using assembly, and it’s a unique situation.

GOTO is an unconditional branch instruction. It allows us to load the PC with the address where we want to continue the execution of our program. But it would be difficult and inconvenient to load the physical address because we don’t actually know it, and it can change if we modify the program. Fortunately, we don’t need to do this; we can use the label as the operand of this instruction. Thus, code execution will continue from the line at the specified label (or below it, as in our case). So GOTO LOOP instruction will move the PC to the line at the LOOP label which is… GOTO LOOP. So the program execution will loop forever in this instruction until we reset the microcontroller.

Line 11 contains the Assembly directive END. This directive is mandatory, and it specifies the end of the program. Everything else after this directive is ignored. Absence of this directive will cause an error.

And that’s it’s about the program itself! Now, we can compile it and load it into the microcontroller.

Again, I’ll show how to do it in MPLAB 8.76 and in MPLAB X.

In MPLAB 8.76 you need to execute main menu command Project -> Make or use the toolbar button Make

If everything is correct in your program then the IDE will show something like this:

Then you need to connect your programmer/debugger to the attached circuit and load the program into the microcontroller with the command Programmer -> Program or with the toolbar button Program

If everything is connected properly, you will see the following notification:

Also you will see that the LED1 is now lit up which proves that we’ve done everything correctly! You did it!

In MPLAB X, you need to execute main menu command Production -> Build Main Project or use the toolbar button Build Main Project

If everything is correct in your program, then the IDE will show something like this:

Then you need to connect your programmer/debugger to the attached circuit and load the program into the microcontroller with the toolbar button Run Main Project

If everything is connected properly, you will see the following notification:

Also, you will see that the LED1 is now lit up which proves that we’ve done everything correctly! We have just begun where we can do some really cool stuff!

Now, at the end of the tutorial, I’ll provide some interesting information. The produced code size for our program is just 4 words! If you are familiar with Arduino programming, try to write the LED light up program and see how much code it will produce (another spoiler: 710 bytes!).

OK, we’re finally done. The first and very simple program turned out to have a lot of theory and new knowledge required. But it’s a good start. We learned an important Assembly directive. Also, we now know four important Assembly instructions: MOVLW, TRIS, BSF, and GOTO.

As a review, see if you can repeat these steps and get them to light up! In the next tutorial, we’re going to make this LED blink and learn a couple more important instructions.