oreilly.comSafari Books Online.Conferences.


Black Box with a View, Part 2
Pages: 1, 2, 3, 4, 5, 6

Further Reading

Overall, the object-oriented approach used here is similar to the one described in the article Object-oriented programming in C.

Of course, more elaborate techniques are available, such as those discussed in the book Object-Oriented Programming with ANSI-C (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 MSPGCC-specific examples at

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 floating-point unit (FPU), so any floating-point 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 floating-point operations, and try to avoid them if possible.

Even integer operations, however, can carry a heavy penalty. The MSP430 is a 16-bit device, which is a definite advantage over 8-bit microcontrollers that are the norm. Nevertheless, there is still no native support for 32-bit 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 8-bit architectures. It is, of course, possible to use 8-bit 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 instructions--a 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

Table 2. Powers of 2

Note that the largest unsigned quantity expressible in any given number of bits b is 2^b-1. For an 8-bit unsigned number, this is 256-1, and for a 16-bit unsigned number it is 65,536-1 (see the table).

Here is a summary of the guidelines for arithmetic operations in microcontroller software:

  • Avoid floating-point 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 16-bit microcontroller will typically handle both 8-bit and 16-bit quantities efficiently but will be less efficient with 32-bit numbers. An 8-bit microcontroller will incur an even greater penalty when using 32-bit numbers.
  • 16-bit integers are usually a good compromise for embedded applications; they are large enough for most purposes, while remaining reasonably efficient even on 8-bit architectures.
  • Use unsigned arithmetic if you do not need to express negative quantities--it doubles the magnitude of the largest number that can be represented. For example, the largest signed 16-bit number is 32,767, while an unsigned 16-bit number can be as large as 65,535.

Pages: 1, 2, 3, 4, 5, 6

Next Pagearrow

Sponsored by: