Black Box with a View, Part 2
Pages: 1, 2, 3, 4, 5, 6
Further Reading
Overall, the objectoriented approach used here is similar to the one described in the article Objectoriented programming in C.
Of course, more elaborate techniques are available, such as those discussed in the book ObjectOriented Programming with ANSIC (PDF). They may not always be appropriate to the microcontroller environment, however.
Microcontroller manufacturers usually provide lots of highly detailed, free documentation. For the MSP430, the MSP430x1xx Family User's Guide (PDF) is a very important resource. The guide describes all the features of the MSP430 in detail. To supplement it, read TI's code examples in C and in assembly language. The examples clearly illustrate the various facilities of this microcontroller, making the information in the user's guide much more meaningful.
In order to compile the TI's C examples with MSPGCC, you will need to make two minor changes. First, #include <signal.h>
. Then, you will need to alter the ISR routine declarations to match MSPGCC conventions. Use Example 7b in this article as a guide. There are also MSPGCCspecific examples at www.mikrocontroller.net.
You will occasionally need to refer to the GCC manual and possibly the GCC C99 standards compliance page (if you use the new ANSI 1999 C standard). Note that these links are relevant to the 3.2.3 version of GCC, which is the basis for MSPGCC at the time of this writing. Another necessary reference is the MSPGCC manual.
Finally, make sure to read the classic software design book Design Patterns if you have not done so already. The ideas presented there will help you improve the structure of your own software, which is particularly important in complex embedded systems.
Appendix A: Arithmetic on a Microcontroller
This appendix describes the nature of arithmetic on a microcontroller.
Arithmetic operations are a major concern in embedded programming. Microcontrollers such as the MSP430 do not have a floatingpoint unit (FPU), so any floatingpoint calculations require a lot of support in software. The resulting code is large, and the processing cost is high. When designing programs to run on a microcontroller, you should carefully analyze any floatingpoint operations, and try to avoid them if possible.
Even integer operations, however, can carry a heavy penalty. The MSP430 is a 16bit device, which is a definite advantage over 8bit microcontrollers that are the norm. Nevertheless, there is still no native support for 32bit integers, with which many programmers are familiar. In embedded development, it is often wise to restrict most numbers to a maximum of 16 bits. Addition and subtraction of such quantities are very fast on the MSP430, but they also remain reasonable on 8bit architectures. It is, of course, possible to use 8bit integers, but often this is too restrictive.
Multiplication and division of integers is also problematic on microcontrollers, which typically have no dedicated circuitry for these operations. In the MSP430 family, for example, some variants actually include a hardware multiplier, but others do not. Without hardware support, multiplication and especially division require the CPU to execute a large number of instructionsa fact that you must take into account right at the design phase of your embedded project.
The exception to this rule is multiplication or division by a power of 2. Microcontrollers (like almost all digital circuits) count in binary, so you can replace a multiplication or division by a power of 2 with much more efficient shift operations. While an optimizing compiler will likely make such replacements automatically, you should consider coding the shift explicitly if your application relies on the enhanced performance. Here are a few examples.
Multiplication  Left Shift Equivalent 

num * 2

num << 1

num * 4

num << 2

num * 8

num << 3

Division  Right Shift Equivalent 
num / 2

num >> 1

num / 4

num >> 2

num / 8

num >> 3

Table 1. Multiplication and division with shift operations
Here is a table of powers of 2 (up to 2^16). Use this table to calculate the shift equivalents to multiplication and division operations.
Power of 2  Decimal  Hex  Octal 

0  1  0x1  01 
1  2  0x2  02 
2  4  0x4  04 
3  8  0x8  010 
4  16  0x10  020 
5  32  0x20  040 
6  64  0x40  0100 
7  128  0x80  0200 
8  256  0x100  0400 
9  512  0x200  01000 
10  1024  0x400  02000 
11  2048  0x800  04000 
12  4096  0x1000  010000 
13  8192  0x2000  020000 
14  16384  0x4000  040000 
15  32768  0x8000  0100000 
16  65536  0x10000  0200000 
Note that the largest unsigned quantity expressible in any given number of bits b is 2^b1. For an 8bit unsigned number, this is 2561, and for a 16bit unsigned number it is 65,5361 (see the table).
Here is a summary of the guidelines for arithmetic operations in microcontroller software:
 Avoid floatingpoint operations of any kind, if at all possible.
 Avoid multiplication and division.
 Try to use numbers that do not require more bits than the machine's native architecture can accommodate. For example, a 16bit microcontroller will typically handle both 8bit and 16bit quantities efficiently but will be less efficient with 32bit numbers. An 8bit microcontroller will incur an even greater penalty when using 32bit numbers.
 16bit integers are usually a good compromise for embedded applications; they are large enough for most purposes, while remaining reasonably efficient even on 8bit architectures.
 Use unsigned arithmetic if you do not need to express negative quantitiesit doubles the magnitude of the largest number that can be represented. For example, the largest signed 16bit number is 32,767, while an unsigned 16bit number can be as large as 65,535.