16 Bit Arithmetic

I find that in most of my applications, I have to use 16 bit numbers. I use the code snippets below for the various required functions.

1. Defining 16 Bit Numbers 5. Comparisons with 16 Bit Variables
2. Increments and Decrements 6. Multiplication
3. Addition/Subtraction 7. Division
4. Other Operations on Constants and Variables

Defining 16 Bit Numbers

I define 16 bit numbers in a manner similar to that of an 8-bit number and just give them to bytes in the RAM Register Space. The example below shows how to define an eight bit Variable, followed by two 16 bit Variables:

Incrementing a 16 Bit value is very simple:

If a PIC17Cxx or a PIC18Cxx is used, the "infsnz" instruction to simplify the sixteen bit increment by one instruction:

The Decrement of a 16 Bit value isn't quite so simple:

--------------------------------------------------------------------------------

Addition/Subtraction

Addition and Subtraction of 16 Bit Variables to Constants follows the same format with the most significant byte processed first. Addition follows the format:

For the PIC17Cxx and PIC18Cxx, the "addwfc" instructions can be used to simplify the operations and eliminate the need for checking the status of the carry flag. For the addition above, the PIC17Cxx or PIC18Cxx code would be:

The corresponding subtraction, ie:

Reg = Reg - 0x01234

Looks like:

Again, the enhanced instructions in the PIC17Cxx and PIC18Cxx can used for the sixteen bit subtraction operation. Using the "subwfb" instruction, the sixteen bit subtraction can be simplified to:

The general case 16 Bit addition,

Destination = Source + 0x05678

Will look like:

If the Destination is different from both values to be added, ie:

c = a + b

the code is changed to save the sums in "w" and then store it in "c" like:

Subtraction is carried out in the same way, but care must be taken to ensure that the subtracting Register is kept straight (something that is less of an issue with addition). If you want to do the following statement:

c = a - b

You would use the code:

--------------------------------------------------------------------------------

Other Operations on Constants and Variables

Doing other operations (bitwise or whatever) on 16 bit values can use the code shown above as a base.


For example, ANDing a 16 Bit Variable with 0x0A5A5 would be done like:

There is one difference, however and that is to do with rotating 16 Bit values. Rotating must be carried out in such a way that the carry flag is always correct for the shift.


To shift left:

and to shift right:

--------------------------------------------------------------------------------

Comparisons with 16 Bit Variables

Comparisons involving 16 Bit Variables require that the comparison value (or Register) is subtracted from the Register to be checked. The results of this will then tell you what is going on with the condition. I use the same code as is shown above and save the result in temporary values and then look at the result. The subtraction code used for comparing a 16 Bit Variable to another 16 Bit variable is:

At the end of this series of instructions, "w" contains Reg2 - Reg1 and "_2" contains Reg2HI - Reg1HI with the borrow result of Reg2 - Reg1.


If the Variable is to be compared against an immediate value, then the "movf" Instructions would be replaced with "movlw" and the two bytes of the immediate value.


There are six basic conditions that you can look for: Equals, Not Equals, Greater Than, Greater Than or Equal, Less Than, Less Than or Equals. So, to discover whether or not I have any of these conditions, I add the following code:


For Equals and not equals, the value in "w" is ORed with "_2" to see if the Result is equal to zero.

for Equals add the lines:

for Not Equals, append:

If a Greater than (The 16 Bit Variable is Greater than the Comparison Value), then the result will not be less than Zero. Actually, the same code (just with a different Bit Skip) can be used to test.


For Greater Than:

Note that just the most significant bit of the 16 but difference is checked. If this bit is set (= 1), then the 16 Bit Variable is less than the Comparison. If it is reset (= 0), then it is greater than and you should check to see if the result is not equal to zero (or else it is equal).


For Less Than:

To check for Greater or Equal To, the last three lines of the code checking for Greater Than are simply erased. To check for Less or Equal To, the three lines from Not Equal to are added before the check for less than.


Here is the complete code for compare and skip on Reg1 less than or equal to Reg2:

--------------------------------------------------------------------------------

Multiplication

For both multiplication and division, repeated addition could be used, but I find that using a scaling routine works much better and faster. These algorithms test bits and only operate if it is appropriate.


Here is a Sixteen Bit Multiplication with a Sixteen Bit Result:

The code given below is the most efficient way of doing a sixteen bit multiply with a 32 bit result. It is not immediately obvious, but it's very clever. Rather than use a 32 bit add each time the shifted data is detected, it provides a sixteen bit (with valid carry) add and then shifts the data down. This Code does not change "Multiplicand", but does change "Multiplier". Note that in the code, I use a thirty two bit value for "Product" (using a "Product:4" line in the "CBLOCK" variable declare statement).

For the PICmicros that have built in eight by eight multipliers, the code for sixteen bit multiplication uses the techniques taught in high school mathematics for multiplying together to variable factors. Instead of thinking of a sixteen bit number as just a contiguous set of sixteen bits, the number is broken up as two sets of numbers that are eight bits in size. The PIC18CXXX sixteen bit multiplication with a thirty two bit result is:

--------------------------------------------------------------------------------

Division

The division routine provided here first finds how far the divisor can be shifted up before comparing to the quotient. The "Count" variable in this routine is a 16 Bit variable that is used to both count the bits as well as add to the quotient. "Temp" is an 8 Bit temporary Storage Variable. At the end of the division routine, "Dividend" will contain the remainder of the operation.


As was pointed out on the PICList, the original 16 Bit division routine only really produced random numbers. This code is the corrected version of it and should work without any problems.