Logical Operators

Logical Operators are assembly language commands that act on two input values and give one output value. Let’s take a look at a generic black box with the input values of A and B and the output value of F. To understand how the Logical Operators work, we engage the use of truth tables. Truth tables show, in tabular form, the inputs on the left side columns, A and B, and the output, F, on the right side column of the table (Fig. 9.1).

There are three basic functions: AND, OR (IOR), XOR. We will take a look at the AND function, for ANDWF and ANDLW; the inclusive OR function, for IORWF and IORLW; and the XOR exclusive OR function for XORWF and XORLW (see Fig. 9.2).

AND/NAND gates

The AND gate is represented by a D shaped object. The AND gate requires that both A and B must be true (1) before the output F can be true (1). All other input combinations result in a false (0) output F (Fig. 9.3).

The NAND, or not AND, gate, is represented by an AND gate with a bubble on the output indicating the NOT of the output. All input combinations result in a true (1) except for the one state where both A and B are true; this state is a false (0) (see Fig. 9.4). The NAND is a very special function in that multiples of it can be used to create any of the other gates. We will look at this special relationship at the end of this chapter.

The AND Microchip assembly language logical operators are ANDWF and ANDLW (see Fig. 9.5). The logical operators are bit wise functions. The first operator, ANDWF, ands the working register, W, and the value contained in f. The destination, d, will be 0 if the solution is placed in the W register. The destination, d, will be 1 if the solution is placed in the memory location f. The second operator, ANDLW, ands the literal k with the working register W. The solution is placed in the W register.

IOR/NOR gates

The OR gate is represented by a gate with a concave side where the inputs are located (Figs. 9.6 and 9.7). The basic OR gate may also be called the IOR gate, for inclusive OR. This means that the output will be true if both A and B are true; also, inclusive of the states where only one input is true.

As with the NAND function, NOR negates the output values for the gate. This negation is indicated by the bubble on the output of the gate. If any of the inputs are true, the output will be false. The output will be true when both inputs are false.

The inclusive OR, IOR, Microchip assembly language logical operators are IORWF and IORLW (see Fig. 9.8). The logical operators are bit wise functions. The first operator, IORWF, ors the working register, W, and the value contained in f. The destination, d, will be 0 if the solution is to be placed in the W register. The destination, d, will be 1 if the solution is to be placed in the memory location f. The second operator, IORLW, inclusive ors the literal k with the working register, W. The solution is placed in the W register.

XOR/XNOR gates

The exclusive or, XOR, is illustrated similar to the OR, or IOR, gate with a concave input side (Figs. 9.9 and 9.10). The exclusive part of XOR is illustrated with a double concave shape on the input side. The XOR gate gives a true, 1, output if one or the other of the inputs are true, 1. When both inputs, A and B, are true, the XOR gate yields a false (0).

The XNOR yields a NOT of the XOR gate and truth table. When both inputs are false, 0, or when both inputs are true, 1, then the XNOR is true (1). When one of the inputs is true and the other input is false, the XNOR yields a false (0).

The Exclusive OR, XOR, Microchip assembly language logical operators are XORWF and XORLW (Fig. 9.11). The logical operators are bit wise functions. The first operator, XORWF, exclusive ors the working register, W, and the value contained in f. The destination, d, will be 0 if the solution is to be placed in the W register. The destination, d, will be 1 if the solution is to be placed in the memory location f. The second operator, XORLW, exclusive ors the literal k with the working register W. The solution is placed in the W register.

NAND, the universal operation

The NAND is a very special function; multiples of it can be used to create any of the other gates. We can implement various functions by using one or more NAND operators.

If we tie both inputs together, the output will be a simple NOT function.

The decimal system is an example of a polynomial number system. The reason for the name is that the value of any numeral d is given by a polynomial. For example, the value of 2437 is given by the expression:

$2\times {10}^3+4\times {10}^2+3\times {10}^1+7\times {10}^0$

Or more simply

$\left(2\times 1000\right)+\left(4\times 100\right)+\left(3\times 10\right)+\left(7\times 1\right)$

In the example, the polynomial in 10 is represented, whose coefficients are the digits 2437. In general, any integer can be used as the base or radix. Some important bases, used in assembly language programming, are as follows:

• • Base 2—binary number system;
• • Base 8—octal number system;
• • Base 10—decimal number system;
• • Base 16—hexadecimal number system.

The context usually makes it clear which base is being used, the standard default being 10. If working with multiple bases, or radices, the base is subscripted to the right of the value, as 2437₁₀, or indicated, as with PIC®, by the alphabetic character d: 2437d, for decimal number system.

Binary, Octal, Hexadecimal, Decimal

This chapter begins with the familiar standard numbering system of decimal. There are observations one can make on the decimal numbering system. These observations allow us to then make parallel comparisons with other mathematical systems. In this context, one can, by comparison, introduce additional systems of binary, octal, and hexadecimal. Unless otherwise noted, numbers presented in this textbook shall by default be decimal numbers.

Let’s take a look at decimal numbers. Here presented is a random 8-digit number: 53,756,598. In the decimal numbering system, one works with base 10 numbers, with numerals 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. So, herein, we use this random number as a base 10 number example: 53,756,598.

Note that, in decimal, base 10, the right-most first digit is the ones, as it is base 10 to the zeroth power. The second digit is base 10, 10 to the first power, or 10. The third digit is the hundreds digit, 10 to the second power, or 100. The fourth digit is 10 to the third power, or 1000. The fifth digit is 10 to the fourth power, or 10,000. And so on, until the eighth digit as 10 to the seventh power.

Binary System

Binary is the name of the numbering system that is base 2. This system, therefore, has numerals 0 and 1. That means that numerals 2, 3, 4, 5, 6, 7, 8, and 9 do not exist in this numbering system. Row 1 is the decimal (base 10) equivalent value.

As an example, use the decimal example value: 214. (This is a totally arbitrary value.) Look at the highest decimal value represented here: 128. Divide the value that we wish to represent, 214, by the value 128: 1.671875. Truncate (or “chop off”) the decimal section 0.671875. The 1 indicates that 1 × 128 is the highest value that can be placed in the 2⁷ position.

Now we subtract (1 × 128) from the original value, 214, to reveal what can be represented by the rest of the value. So subtracting 128 from 214, this leaves 86 to be represented by the rest of the binary number.

To find the 2⁶ value, divide 86 by (2⁶ or) 64: 1.34375. Truncate the decimal value to 1. The remainder is 86 − (1 × 64): 22.

Continue to calculate the next value. How many 32s are in 22? Zero. Place the 0 in the 32 column.

Continuing with the next value, 16. How many 16s are there in 22? One. Place a 1 in the 16 column. Subtracting 16 from 22 gives the remainder of 6.

How many 8s are there in 6? Zero. Place a 0 in column 8. Since we are to subtract (0 * 8), or 0, the value we seek is still 6.

How many 4s are there in 6? One. Place a one in the 4s column. Subtract (1 * 4) or 4 from 6: 2.

How many 2s are in 2? One. Subtract 2 from 2 for zero remaining ones. Place a 1 in the 2s column. Place a 0 in the 1s column.

That’s it! Representing the value 214 is our binary number 11010110b.

Octal System

Octal is the name of the numbering system that is base 8. This system, therefore, has numerals 0, 1, 2, 3, 4, 5, 6, and 7. That means that numerals 8 and 9 do not exist in this numbering system. Row 1 is, again, the decimal (base 10) equivalent value.

Hexadecimal System

Hexadecimal is the name of the numbering system that is base 16. This system, therefore, has numerals 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, and 15. That means that two-digit decimal numbers 10, 11, 12, 13, 14, and 15 must be represented by a single numeral to exist in this numbering system. To address the two-digit decimal values, the alphabetic characters A, B, C, D, E, and F are used to represent these values in hexadecimal and are treated as valid numerals. Row 1 is, again, the decimal (base 10) equivalent value.

Using an example value of 538, what is the base 16 equivalent value. First place zeros in all columns that are known to be too big. 256 is the start of values below 538, so put a 0 in all columns to the left of 256.

538 − (2 × 256) = 26.

26 − (1 × 16) = 10

10 − (10 * 1) = 0. Recall, 10 decimal is represented by Ah hexadecimal. The complete value is then 21 Ah

This will come to you with practice and memorization of typical values. Rarely do we work with numbers greater than 4096 in hexadecimal.

Mixed Radix Systems

Mixed Radix Systems are rarely used in assembly language programming. Two examples, however, are of note: time and distance measurements.

Time is usually expressed as hours-minutes-seconds, with an example of hour 12, minutes 23, and seconds 47. The numeral would be 122,347 with the radices 10, 10, 6, 10, 6, and 10. The first digit, 1, is base 10, and second numeral is 2, base 10; with the 2 digit value, 12, in base 6. The third and fourth digits being 23. This is, again, first base 10 (numeral 2), then base 10 (numeral 3), then base 6 (numerals 23). The number of seconds is then base 10 (numeral 4), and base 10 (numeral 7). The total number of seconds may be obtained from the following calculation:

$\left(1\times 36,000\right)+\left(2\times 3600\right)+\left(2\times 600\right)+\left(3\times 60\right)+\left(4\times 10\right)+\left(6\times 1\right)=44,626$

This number is then the total number of seconds since midnight. To return the value back to hours-minutes-seconds format, complete successive divisions, in the reverse order, by 10, 6, 10, 6, 10, and 10.

Measuring length in yards, feet, and inches may also be treated similarly, however falsely, as a mixed radix system. The last numerals, in number of inches, fail to mathematically work.

There are three applications in computing: representation of n-dimensional arrays, the ordering of blocks on a disk, and the factorial number system. These examples are left as an exercise for the interested reader.

In the last example, we obtained the hexadecimal value of 021 Ah. Note that each numeric value is a two-byte number, with a half byte for each value. The half byte is 4 bits in binary.

The hexadecimal value is 021 Ah and the binary equivalent is 0000 0010 0001 1010, as shown in the above table.

Little-Endian vs. Big-Endian

When you go to store this two-byte value in memory, you arrive at a conundrum: do you store the little-end of the number (least significant byte or “little-endian”) or the big-end of the number (most significant byte or big endian?) There is no “right” or “best” way to store the bytes in multibyte quantities. The most important takeaway is that you should make your selection wisely and be completely consistent through your code.

For a historical note on these terms:

Endian refers to the order in which bytes are stored. The term is taken from a story in Gulliver’s Travels by Jonathan Swift about wars fought between those who thought eggs should be cracked on the Big End and those who insisted on the Little End. With chips, as with eggs, it doesn’t really matter as long as you know which end is up.

The processor hardware dictates whether little-endian or big-endian standards are followed. Endian-related operations native to the architecture are dictated by the architecture. For microchip processors, you can use either standard. There are a few situations when little-endian would be preferred, thus some favor using little-endian throughout.

There are three computing methods used to represent signed and unsigned integers. They are as follows:

• • Sign and magnitude
• • One’s complement
• • Two’s complement

Each method has its own caveats. Once each method is understood, one should weigh the options, select carefully, and, upon selecting one method, be consistent throughout the code.

As we assess each method, we use x + (− x) = 0 as our test case.

Binary Coded Decimal, BCD, provides an alternative means of representing decimal numbers. The premise is that you can use a hexadecimal encoding for the decimal digits by simply using 0–9 and ignoring numbers A through F. This may, at first blush, appear attractive as it is simple and easy to understand, as compared with one’s complement and two’s complement. However, in exchange, the programmer must monitor all arithmetic functions carefully so that overflow does not occur, which would not be inherently caught, as the hardware is not “aware” of the truncation of the hexadecimal system at A.

For example, in BCD, we may represent a decimal value of 403 as three bytes of “4” then “0,” and “3.” A second value of 528 would be represented as decimal value of “5” then “2” and “8.” If the arithmetic function Add were used, “3” would be added to “8” and create a value of “11” in decimal. The computer will represent this in the lowest byte as numeral “B,” which must then be converted to “11” and then correctly allocate the digits “1” and “1,” with the first “1” correctly added to “0” and “2” for a decimal “tens” position of “3,” and so on.

The approach to this issue is to simply run a conversion routine on either side of the arithmetic function. The programmer must create the “BCD to hex” routine on all values prior to the arithmetic operation, such as Add. Then, after the computation, the programmer must reverse the conversion, creating a “hex to BCD” function, on all values. The ultimate use of this method must, in some way, be of more value than simply holding the value for a display, as the arithmetic functions do not work in your favor.

Single-byte character data, such as ASCII, is not affected by Endianness. If you store any ASCII character string in memory, it always looks the same, no matter what the Endianness of the hardware. Each character is one byte long and the start character of the string is always stored at the lowest memory location. The single-byte character order resembles Big-Endian type order. The left-most byte leads first. It also reads correctly left-to-right in the memory dump. For the string “ABCD”, the “A” is stored “first.”

Four-Character String: “ABCD.”

• If you dump character data from memory, it reads correctly left to right in the dump, too:

• ----- MEMORY BYTES ----------     --- ASCII CHARACTERS ---
•       00 65 66 67 68 00 00 00 00 00….ABCD….

The most convenient method of using alphabetical characters is to simply memorize the first character of the alphabet, in lowercase and uppercase values. Uppercase “A” is 65. Lowercase “a” is 97.

None of the Endian-independence holds for multibyte characters, e.g., Unicode, where each character takes more than one byte to represent. To correctly read multibyte characters you need to know the Endianness used to store them.