Here are lots of helpful hints to get you started in programming. Programming is easy if you follow our suggestion of taking a program from the list of projects and modifying it slightly by changing one or two instructions at a time.
It's a lot more tricky writing a program from the start. And we don't advise this AT ALL.
But if you want to find out about some of the "tricky things" in a program, here is a list of 100 Helpful Hints.
Don't forget to see our Library of routines:   A-E   E-P    P-Z   It covers lots of things.

BINARY, DECIMAL AND HEX
The numbers in your program can be written in binary, decimal or hex.
Here is how to write them:
;Binary numbers are shown as b'00000000' or b'11110001'
;Decimal number are shown as: .10 .255 or d'10' - note the decimal point.
;Hex numbers are shown as: 0Ch, 0ffh, 0x2F, 0x20, 0x0ff  - "0" must be placed before any letter as 0xff will not be read correctly.

You can use a mixture of all three providing you keep to the correct formatting.

Or you can specify the way numbers are to be interpreted by the compiler by adding:
radix binary
radix dec    (a number such as 20 will be treated as a decimal).
radix hex


cblock
A simpler way to list all the names for the files is to use cblock.   A program inside the compiler takes each name and allocates a file, starting at 20h:

           cblock    0x20 (block of constants)
delA     
loops   
display  
jump  
tLOW
tHIGH
tREC  
          endc

cblock is very easy to use. You can add or remove names without having to allocate file numbers.


CALL AND GOTO
The  CALL instruction for a PIC12F629 accesses ALL MEMORY.
Using the:
     call  sub-routine
instruction will send the micro to another address such as a sub-routine and if the sub-routine contains the instruction:
    retlw   00
the micro will go to the next instruction after the call instruction.
If you use
    goto   sub-routine
the micro will go to the sub-routine but when it sees the
  retlw   00
instruction, it will go to a previous call.

 

DEFINING THINGS
When writing a program, the layout must be in columns so that the assembler will know how to interpret each item. This layout is called a TEMPLATE and the program is saved as .asm  (assembly program)
The first column contains Labels.
The second column contains Directives (such as equ, end) and Mnemonics (instructions)
The third column contains Operands, and
The fourth column contains Comments (such as ;output HIGH  ;test zero bit)

del1     equ     0x20     ;store del1 in file 20 hex

During the running of a program you may want to decrement a file to create a delay.
The file is called a temporary storage and a set of files from 20h to 5Fh is available in the PIC chips we are promoting.
At the beginning of a program, each file that you want to decrement, or store a number of loops, or hold a value for displaying later, or hold the jump value for a table, is given a name such as: delA, loops, display, jump. These files are sometimes called Variables.
Each name is then allocated a  file, starting at 20h, 21h, 22h, etc.
delA       equ   20h
loops      equ   21h
display    equ   22h
jump      equ   23h
 

goto  $+1     goto  $-1       goto  $
The instruction:
     goto   $+1
sends the micro to the next instruction but takes 2uS.  (A nop instruction takes 1uS)

The instruction:
     goto   $-1  
sends the micro to the previous instruction.  This can create an endless loop!

The instruction:
     goto   $  
creates a halt as $ represents the current address.

You can also use this terminology to go to an instruction before a sub-routine, such as:
     goto   delay-1
This sends the micro to the line before the delay sub-routine. This allows you to use the delay sub-routine for different timings. The line before the label: "delay" has a load-value of 3Fh and this can be used in the sub-routine. Or you can preload a value into w and go to the sub-routine at the actual label: delay.
This is how the delay sub-routine is structured:

            movlw     3Fh
delay    movwf     temp
            decfsz    temp,w      ;the decremented value of temp is placed in w
            goto       delay
            retlw       00

Normally we use the instruction decfsz temp,f   where the temp file holds the decremented value. But to create a multiple input delay sub-routine we need to use: decfsz temp,w and the previous instruction: movwf     temp  to put the decremented value into temp.  
To use the load value 3Fh, use the instruction: call    delay-1
To load temp with any other value, use the instructions:
         movlw      xxh
         call          delay

DsPIC
Some of the latest PIC chips have part numbers such as  dsPIC30F1010. These are classified as Digital Signal Controller chips as they have the capability of  processing digital signals and contain a fully implemented digital signal processor (DSP). 

IN/OUT PORT
The IN/OUT port on a PIC12F629 is file 05h. This port corresponds to pins 7, 6, 5, 4, 3, and 2 for GP0, GP1, GP2, GP3 GP4 and GP5.
Remember: GPIO,3 (GP3) (pin 4) is an INPUT-ONLY pin.
When writing a program, use GPIO,0 GPIO,1 GPIO,2 GPIO,3 GPIO,4 GPIO,5 in your program and the compiler will do the rest. (GPIO = General Purpose Input/Output).
For instance, If you want to SET (make HIGH) pin 7, you must do two things:
1. Make sure GPIO,0 is an OUTPUT bit by making the corresponding bit in the TRISIO register "0."  This is done via the following instructions: Remember: "0" = output,  "1" = input

    bsf         status, rp0      ;bank 1
    movlw     b'xxxxxxx0'    ;(x= don't care = does not matter)
    movwf    TRISIO           ;the lowest bit will be an OUTPUT
    bcf         status, rp0     ;bank 0

2. Make the lowest bit of the output port = 1 (HIGH). This is done via the following instruction:

    bsf      GPIO,0


SETTING MORE THAN ONE BIT AT A TIME
Do not set more than one bit at a time in the GPIO (in/out) port. The actual setting of a bit is very complex. The micro reads the value of the bit, modifies it, then writes the new value and the pin may be connected to a capacitor that take time to charge or allow the voltage on the pin to change and somewhere along the line, the result is not transferred to the result and the state of the pin does not change. To avoid this problem, do not create two instructions such as:

      bsf      GPIO,0
      bsf      GPIO,2

If you need to clear or set two or more output lines, perform the operation via a single instruction:

    movlw   b'xxxxx1x1'
    movwf   GPIO

or perform:  bsf      GPIO,0        bsf      GPIO,2    with other instructions between.

If you must perform the two operation in quick succession, you need to know the state of all the outputs and include this in the value you are going to load into GPIO via movlw b'xxxxxxxx' etc. 

As can be seen from the above, the six lower bits of file 05 are connected to 6 pins of the chip and these connect the microprocessor to the outside world.  This file is like all the other files (from 20h to 5F - 64 files) as it can be operated-upon (incremented, decremented, shifted left or right, plus other operations). The only difference is the contents of file 05 can be exported to the outside world and the outside world can influence the file. When any of the bits of file 05 are configured as "out," the value of the bit will make the corresponding pin of the chip either HIGH or LOW. When it is "set" (=1), the pin will be HIGH. When it is "clear" (=0), the pin will be LOW.   
If you only want to change 2 or more bits and do not know the state of the other bits, you can use the following instructions. Only bits 0 and 4 will be toggled:

      movlw   b'0001 0001    ;only bits 0 and 4 will be toggled
      xorwf    gpio,f

To set 2 or more bits:

      movlw  b'0001 0001    ;only bits 0 and 4 will be set
      iorwf    gpio,f


MACRO'S
A MACRO is a piece of code that "gets inserted" into your program, by a program called an assembler, during the time when the program is ASSEMBLED. You only have to write a particular macro once, and it may be inserted 6 times into your program. Each macro must have an specific name (called a LABEL), so the assembler can find it.

I do not use Macros. They involve extra thinking and can take up extra space in your program.
But you will find some programmers use them and you need to know how they work.

A macro is like a sub-routine. It is written once and can be used many times in a program.
A macro has a LABEL just like any sub-routine. When you want to use a macro, the name of the macro is written on a new line in your program and the assembler adds the instruction(s) in the macro at the location where you have written the name of the macro.  If the macro consists of 5 lines and it is used 6 times, a total of 30 instructions will be added to your program.
The macro will be deleted from the assembled program and only the contents of the macro will appear 6 times.
The advantage of a macro is the slightly faster execution of the program as the microcontroller does not have to execute a call and return. The disadvantage is the extra lines of code. 

The reason for this article is to explain how a MACRO is prepared and the terms used.

The first line of a macro contains three terms:

LABEL       macro       PARAMETERS

LABEL can be any set of letters or numbers (some words cannot be used as they are used by the assembler and a label cannot begin with a number. Use "_"  or "." if numbers are required.

macro   tells the assembler that a macro is the next item in the program.

PARAMETERS   - a list of the files to be used with a comma between each.

Any number of lines of code can now be written. These will be any of the 33 PIC instructions.

The macro ends with:

endm      ;end of macro 

MCLR PIN
Pin 4 can be configured as an "Input line" (GP3) OR "Master Clear."
To configure Pin 4 as MCLR   (also written as /MCLR  or /MCLRE ) the configuration bit setting is: _MCLRE_ON
When this pin is configured as /MCLRE, the pin resets the chip when it is taken LOW. But why waste a pin? Use the pin as an INPUT!
To configure Pin 4 as GP3, the configuration bit setting is: _MCLRE_OFF
This instruction tells the PIC to use its internal MCLR circuitry (to keep /MCLRE high), and leaves pin 4 free as an Input line. Note: MCLR pin (GP3) is INPUT ONLY.

MICROCHIP ICD PROGRAMMER
Microchip ICD programmer is sold in a round plastic case. If you have one of these and use long leads between the programmer and the chip you are "burning," add a 2k2 resistor to the clock line and 0v rail and a 2k2 to the data line and 0v rail to makes these lines LOW IMPEDANCE. We had enormous trouble programming a chip due to cross-talk between these two lines.

MPLAB IDE 
IDE stands for Integrated Development Environment and is part of MPLAB. MPLAB has two parts and the section we use is MPASM. The other section allows you to load your program into a window and look at how each register (file) is loaded or is currently holding bits (0's and 1's). It also has a single-stepping feature that increments thorough your program and lets you see what is happening. But this program is very complex and will cause lots of headaches, to get it up-and-running. We have kept things simple by showing you routines that work and you simple copy-and-paste.
  


MULTIPLYING AND DIVIDING
Numbers can be multiplied by 2 by shifting the file left with the instruction rlf  total,f  Before this instruction it is wise to clear the carry bit:  clrc
Numbers can be divided by 2 by shifting the file right with the instruction rrf  total,f  Before this instruction you must clear the carry bit:  clrc
You can also create a value of 0.75 by using the following instructions.
Suppose you have a file called loops and you want to reduce it to 75%:

OSCILLATOR CALIBRATION VALUE
Calibration of the oscillator is only necessary when you need precise timing, as for serial communication. In most cases you will not have to worry about this.
To use the factory calibration value:

OTHER PROGRAMMER'S CODE
You will find some of the instructions and code in other people's programs very difficult to understand. You will need to know "high-level languages" to interpret the meaning of some of them.  We do not intend to teach any of these "complex sentences" or Pseudo Instructions. We will be showing you how to produce a program using just the 32 - 35 instructions needed to perform all the functions the microcontrollers are capable of.
Of course you can go one step higher and one step better by including extra complexity in your code but our intention is to start everyone at "level-zero" to "level-one" where you can produce a program to perform a reasonably simple task using the mnemonics of the instruction-set. 
Never use any instructions you do not fully understand.
However here is some explanations of instructions you will find in other people's programs:

ARITHMETIC OPERATORS AND  PRECEDENCE: