Embedded C Programming: Techniques and Applications of C and PIC MCUS

Introduction

Microcontrollers are computers on a chip. When they power up they start running a program from internal program memory, also called ROM for read only memory, or Flash. Microcomputers are found in appliances, toys, automobiles, and computer peripherals, such as a keyboard or mouse, and are finding their way in as support electronics for almost everything electronic from battery chargers to RADAR systems.

The Microchip PIC® microcontrollers have become the most popular choice for new designs based on their high speed, of up to 70 million instructions per second as of this writing, low cost, some under $1; and large number of interfaces like USB, Ethernet, and analog signals.

The C programming language, originally developed by AT&T Labs by authors Brian Kernighan and Dennis Ritchie, known as K&R C, became an international standard by ANSI in 1989, known as C89. A new standard derived from C defined the C++ language and was released in 1998. C++ has some complex language elements that make it impractical for use on a microcontroller as opposed to a desktop PC. C is the most commonly used language for programming microcontrollers.

C is in a category of computer languages called high order languages. High order languages use a tool called a compiler to convert the C text files to a machine readable file.

The first part of this book emphasizes the C language. Previous experience with a programming language will help but is not required. Formal definitions of the language elements are used and all areas of the language that apply to microcontrollers are covered in detail. Starting with Chapter 15 this book covers the PIC® microcontroller, its peripherals and how to use those peripherals from C in detail. Prior knowledge of basic electronics to interface to hardware devices will help but is not required to understand this book.

There are variations in the C language extensions between compiler vendors and between microcontroller families. Throughout the book are indications where there may be compatibility issues between compilers and/or processors. Each chapter will also supply hints for good programming practices, including documentation. Exercises and quizzes are provided for each chapter to help solidify the concepts learned. This book uses examples ready to compile using the CCS C compiler. It is the most popular for the Microchip PIC® processors.

Trademarks:

PIC® MCU, dsPIC® DSC, and MPLAB® are registered trademarks of Microchip Technology, Inc., in the USA and other countries.

Chapter 1

C Overview and Program Structure

Abstract

This chapter explains the structure of C programs as it pertains to embedded microcontrollers. A short example program is used to introduce the reader to each of the basic C elements.

Compilation units (sometimes called translation units), functions, statements, compound statements, expressions, and data declarations are all introduced. The unique C preprocessor concept is covered with some simple preprocessor directive samples. This chapter shows how constants, variables, operators, and function calls make up the basic components of an expression and how they are used together in the C programming language. The basics of functions calls, including passing and returning data, are included.

Examples and exercises are for the popular PIC™ microcontroller manufactured by Microchip.

Keywords

C program structure

Compilation unit

Translation unit

C comments

Functions

Statements

Expressions

Preprocessor

C Source Code

This is what C source code looks like:

This program may look very cryptic to you now. When you have finished reading this book and doing the experiments, this program and much more complex ones will no longer seem cryptic. As you read the next few chapters, you can refer to this program to see how the topics relate to this program. For now, let’s make some observations about the overall look of the program.

Comments

Comments help anyone (including you) who reads your code understand what it does. There are two styles.

(can span multiple lines, but may not be nested)

and end of line (one line only).

The compiler ignores all comments. Both styles are shown in the sample program.

Program Structure

C programs are made up of compilation units, sometimes called translation units. A compilation unit is a set of files that are compiled together by a compiler. For most examples in this book we will be using a single compilation unit. A compilation unit is made up of global data and functions. A function is a callable group of code that in some other languages is referred to as a procedure or subroutine. Functions are made up of local data accessible only to the function and of statements within the function.

C Preprocessor Directives

and occupy the entire line. They will be covered in more detail in directive causes whatever lines are in the file (e3.h) to appear at this spot in the code for the compilation.

For example, if you created a file named delay.inc and put in the file one line:

delay_ms(500);

and the program would compile exactly the same. In the first step of compilation the compiler preprocessor would read the delay.inc file when it got to that line and replace the #include where the #include were.

The preprocessor can be a powerful feature in C that can increase program readability, maximize code reuse, and significantly help in program maintenance.

As we examine the sample program shown, you see the first line is a preprocessor directive to include the e3.h file. It is very common for the first non-comment line in a program to include a file with various project- and/or hardware-specific definitions. The .h extension (for header) is frequently used for this kind of file. In our case all the declarations needed for the E3 hardware are in this include file.

Functions

Next we find a function definition for main. All programs must have exactly one function named main()so it is clear that it is a function name. The void before the name indicates this function returns nothing and the void are grouping symbols. All functions start and end with these symbols.

Functions will be dealt with in detail in Chapter 7; however, to lay a foundation for what they are, consider some examples of a function being used:

x=sin(y);        sin is a function with one argument and a return value

x=sin(y*3.1415/180);   the argument may be any expression

x=180*sin(y)/3.1415;   the return value may be used in an expression.

Declarations

The int i is a data declaration for the variable named with the identifier i. int indicates the variable is an integer. In this case i may only be used inside the main() function. If this line was above the start of the function (outside the function) then i could be accessed by other functions. The range that a variable is accessible from is referred to as the variable scope. Scope will be covered in more detail in Chapter 4.

Statements and Expressions

line is a statement. Statements are executed at run time. This particular statement has three expressions within. Expressions will be covered in statement is:

It executes the first expression once       i=1

Repeats the following:

    Tests the second expression and exits the loop if false i<=10

    The third expression is executed.        i=i+1

In this example the four lines are executed 10 times with the variable i going from 1 to 10 and then, when 11, the loop stops because 11 <= 10 is false.

.

function would be called in the loop 10 times. Then the other three lines would execute once afterwards.

of a function call is the data passed into a function. These are called arguments in the call and parameters in the function.

. Note that just because it is valid does not mean it makes sense. For example, this is a valid C statement:

1+2;

However, it does not do anything. Some compilers might do the addition and that may take some time but nothing more is done. A good compiler will throw a warning on this line because the programmer might have made a typo.

with no expression before it is a special case of a statement called the null statement. It does nothing.

. Consider:

x=3;

This is an expression x = 3 it makes a statement. It always assigns the value on the right side (rvalue) to the variable on the left side (lvalue).

Time

The ms in delay_ms is milliseconds. Time units frequently used in programs are:

ns  nanosecond  0.000,000,001 seconds

us  microsecond  0.000,001 seconds

ms  millisecond   0.001 seconds

For example, there are 1 million microseconds in 1 second.

Typing Accuracy

what you type.

line four lines down from where the actual error was.

. Missing or extra ; or { can create confusing error messages. A good C editor will highlight matching { } and () and as well as highlight syntactical elements to prevent errors as you type.

Text Formatting

Formatting white spaces such as spaces, tabs, carriage returns, etc., are ignored by the compiler. Formatting makes code readable to us. White space, resulting from laying out a program so it appears better organized, is a good thing. This comes from using spaces, tabs, and blank lines. Use tabs for indentation instead of several spaces. The number of spaces per tab is usually adjustable. Three spaces per tab work well. Notice the lines inside the above function are indented and the lines inside the loop are further indented. Indentation and other white space are optional, but highly recommended. There is no right or wrong as far as the compiler is concerned. Some companies will have companywide coding standards that will specify indentation, comments, maximum function size, and other readability items.

Compatibility Notes

comment is a C++ construct not supported by all C compilers.

Most C Compilers are sensitive to case. For example, Output_High() would not be recognized but output_high() is. By default, the CCS C compiler is not case sensitive. To make it case sensitive, you must use a #case preprocessor directive.

Built-in functions like output_high() and delay_ms() are not in the C standard. These are unique to the CCS C compiler.

Summary

• Programs are made up of one or more compilation (or translation) units.

• Compilation units have preprocessor directives that are resolved before anything else.

• Comments and most white space are ignored.

• A compilation unit is a file with some number functions and global data declarations in any order.

.

• Functions may return data and the caller may pass data known as arguments to the caller and parameters to the function.

to make a compound statement.

• Some statements have expressions within them.

.

• Expressions are made up of constants, variables, operators, and function calls and always evaluate to some value.

Exercise 1-1

Objective: Gain a basic understanding of how to use the compiler and prototyping board.

Requires: E3 Module, USB Cable, PC.

Exercise 1-2

Objective: Better understand the use of the tools.

Requires: E3 module, USB cable, PC.

Quiz

(1) As an attempt to reduce white space, which of the following programs is valid?

(a) 

   #include void main(void){inti;for(i=1;i<=10;i=i+1){

output_high(PIN_C6);

delay_ms(500);output_low (PIN_C6);delay_ms(500);}}

(b) 

   #include void main(void){int i;for(i=1;i<=10;i=i+1){

output_high(PIN_C6);

delay_ms(500); output_low(PIN_C6);delay_ms(500);}}

(c) 

   #include void main(void){int i;for(i=1;i<=10;i=i+1){

output_high(PIN_C6);

delay_ms(500);output_low (PIN_C6);delay_ms(500);}}

(d) All are valid

(e) None are valid

(2) Which of the following statements is valid?

(a) 

5;

(b) 

1 + 2;

(c) 

{1;2;3;4}

(d) All are valid C

(e) None are valid C

(3) How many times will this statement loop?

for(i=1; i>=10; i=i+1)

(a) 11

(b) 9

(c) 1

(d) 0

(e) Infinite

(4) How many times will this statement loop?

for(i=1; i<=10; i=i+3)

(a) 0

(b) 2

(c) 3

(d) 4

(e) Infinite

(5) What C elements can be found in this line of code?

delay_ms(50*n);

(a) Function declaration

(b) Expression

(c) Statement

(d) Argument

(e) All of the above

(f) b, c, d

(g) c, d

(6) Of the following comments, which ones are valid C?

(a) int x // holds current x position;

(b) process(data); /* removes symbols +-*/ in the data */

(c) // temporary>> // int dummy;

(d) All are valid

(e) None are valid

(7) What should the compiler do with this line?

for(1;2;3)

(a) Generate an error

(b) Generate a warning

(c) Both a and b

(d) Neither a nor b

(8) A single expression may also be:

(a) A statement

(b) A declaration

(c) A parameter

(d) Functions

(e) A translation unit

(9) A file q1.inc has the following lines:

output_high(PIN_C6);

delay_ms(500);

output_low(PIN_C6);

delay_ms(500);

With the following code, how many times will the LED blink?

for(i=1; i<=3; i=i+1)

#include

(a) 1

(b) 2

(c) 3

(d) 4

(e) None

(10) A file qq1.inc is created with just four characters being void. When an attempt is made to compile the following, how many errors are generated?

#include

main(

#include

) { }

(a) None

(b) Three, two void with nothing after and one ( with no )

(c) Two, only the void lines

(d) One, only the main line

(e) Four, the three from b and missing statements between { and }

Chapter 2

Constants

Abstract

This chapter covers C constants in detail. The syntax and common use for the decimal, binary, hexadecimal, and octal radix in C is fully explained. Both signed and unsigned constant examples are shown for whole numbers, along with their advantages and disadvantages with a RISC processor.

The reader will learn the uses and implementation of floating-point numbers in C for embedded applications. Fixed-point number formats and their advantages are covered as an alternative to floating point.

Constant characters, constant strings, and the special C method to deal with non-printable characters are all a part of this chapter.

Examples and exercises are for the popular PIC®; microcontroller manufactured by Microchip.

Keywords

C constants

Signed

Unsigned

Binary

Hexadecimal

Octal

Decimal

Floating point

Fixed point

ASCII

Constants have already been briefly introduced. C allows for constants to be expressed in a number of different ways. In some cases there are different ways to express the exact same number, and in other cases the way a constant is expressed indicates the constant’s type. Types will be covered in more detail in the next chapter. Types dictate the organization of an item in memory. For example, how many bytes the item takes.

Bits, Bytes, Etc.

Bits

One bit in memory or a register can represent one of two possible states, 0 or 1.

In the world of digital electronics, it is convenient to build circuit elements that have two states: off/on, active/inactive, or low/high. These states can be represented by 0 or 1 (see Figure 2.1).

Figure 2.1 Positive logic.

The exact voltage ranges that represent 0 and 1 vary depending on the logic supply voltage and the integrated circuit logic chip family used (TTL, CMOS, etc.). The choice of using binary 0 to represent 0 V is arbitrary. Positive logic is shown above. It can be done the opposite way, which is called negative logic.

Nibbles

A nibble consists of 4 bits and can represent 16 possible states. A nibble is typically the upper or lower half of a byte (most significant or least significant nibble).

Bytes

A byte consists of 8 bits and is said to be 8 bits wide. An 8-bit microcontroller moves bytes around on an 8-bit data bus (8 conductors wide).

Memory Sizes

Memory size is most frequently expressed in terms of the number of bytes. Sometimes it will be expressed in terms of the number of words, where the word size is specific to the way memory is organized in the machine. For a PIC® MCU, frequently RAM is expressed in bytes and program memory as words because the program memory may be 12, 14, 16, or 24 bits wide.

Because addressing is done in binary, large memory sizes are also expressed as a power of 2. For example, instead of 1000 bytes it will be expressed in terms of 1024 bytes (2¹⁰). Here are the common abbreviations that apply ONLY to memory:

1K = 1 kilobyte = 1024 bytes

1M = 1 megabyte = 1024 × 1024 or 1,048,576 bytes

1G = 1 gigabyte = 1024 × 1024 × 1024 or 1,073,741,824 bytes.

Syntax of C Constants

Binary

A binary number with more than one bit can represent numbers larger than 1. How much larger depends on the number of bits or digits. An 8-bit binary number (byte) can represent 256 possible numbers (0–255).

A 16-bit binary number can represent numbers from 0 to 65,535. If we use a byte to transmit information, we can transmit 256 possible combinations, enough to represent the 10 decimal digits, upper- and one word letters, and more. A commonly used code used to represent these characters is called ASCII (American Standard for Information Interchange).

Binary numbers are based on powers of 2. The value of bit 0 is 2⁰ = 1 if it contains a 1, or 0 if it contains 0. The value of bit 1 is 2¹ = 2 if it contains a 1, or 0 if it contains 0. The value of bit 3 is 2³ = 8 if it contains a 1, or 0 if it contains 0, and so on.

For a 16-bit binary number, bit 0 is the least significant bit, and bit 15 is the most significant bit. Figure 2.2 shows the value of each bit position if it contains a 1: All PIC- related documentation numbers the least significant bit as bit 0. This is a frequent but not universal convention for microprocessors.

Figure 2.2 Binary bit value in decimals.

The value of a number contained in a 16-bit variable would be determined by multiplying the contents of each bit by the value of each bit (see Figure 2.3).

Figure 2.3 Binary-to-decimal conversion example.

Counting up in binary goes like this:

0000

0001

0010

0011

0100

0101

etc.

Think of this number system in terms of a car odometer where each digit only has a 0 and 1. When the 1 flips over to 0 the next digit up flips. The way a number is represented is called the radix.

In C a binary constant starts with a 0b followed by each binary digit. For example, to assign a decimal 6, or binary 00000110, to the variable x do this:

x=0b00000110;

Decimal

Decimal numbers are the way most people think of numbers. There are 10 digits in each decimal position 0–9. In C we express decimal simply like this:

x=123;

Types will be dealt with later in this book; however, we will note here that the compiler will treat the above 123 as a 1-byte constant since 123 fits into a byte. If for some reason the programmer wants it to be treated as a 2-byte number then an L (for long) is appended to the number, like this:

x=123L;

is not required for numbers that are already too large to fit in a byte (like 1000).

after it to indicate it is unsigned.

Signed Integers

The binary numbers shown above are unsigned numbers. An 8-bit memory cell can have a number from 0 to 255. It is sometimes helpful to represent negative numbers in C. When doing so, one binary position is used for the sign. 0 is positive and 1 is negative. The rest of the binary positions are in what is referred to as a 2’s complement format. The 2’s complement format has an arithmetic advantage over what might seem to be a simpler scheme. A −2 in 2’s complement form at looks like this:

1 1 1 1 1 1 1 0

When adding 1 to this, the result is:

1 1 1 1 1 1 1 1

And this is the 2’s complement representation for a −1. That is the preferred way it should work. Add 1 to −2 and get −1. If adding another 1 (think of the odometer) the result is:

0 0 0 0 0 0 0 0

Just as any mathematician would expect.

Think of the odometer starting out at all 0s. If wanting to represent a −1, then move it backwards 1 to result in all