Ibrahim Dogan - Advanced PIC Microcontroller Projects in C

const First_Alpha = 'A';

String constants are fixed sequences of characters stored in the flash memory of the microcontroller. The string must both begin and terminate with a double quote character (“). The compiler automatically inserts a null character as a terminator. An example string constant is:

"This is an example string constant"

A string constant can be extended across a line boundary by using a backslash character (“\”):

"This is first part of the string \

and this is the continuation of the string"

This string constant declaration is the same as:

"This is first part of the string and this is the continuation of the string"

Enumerated constants are integer type and are used to make a program easier to follow. In the following example, constant colors stores the names of colors. The first element is given the value 0:

enum colors {black, brown, red, orange, yellow, green, blue, gray, white};

Escape sequences are used to represent nonprintable ASCII characters. Table 3.3 shows some commonly used escape sequences and their representation in C language. For example, the character combination “\n” represents the newline character.

Table 3.3: Some commonly used escape sequences

An ASCII character can also be represented by specifying its hexadecimal code after a backslash. For example, the newline character can also be represented as “\x0A”.

Static variables are local variables used in functions (see Chapter 4) when the last value of a variable between successive calls to the function must be preserved. As the following example shows, static variables are declared using the keyword static :

static unsigned int count;

Using the keyword extern before a variable name declares that variable as external. It tells the compiler that the variable is declared elsewhere in a separate source code module. In the following example, variables sum1 and sum2 are declared as external unsigned integers:

extern int sum1, sum2;

Volatile variables are especially important in interrupt-based programs and input-output routines. Using the keyword volatile indicates that the value of the variable may change during the lifetime of the program independent of the normal flow of the program. Variables declared as volatile are not optimized by the compiler, since their values can change unexpectedly. In the following example, variable Led is declared as a volatile unsigned char:

volatile unsigned char Led;

Enumerated variables are used to make a program more readable. In an enumerated variable, a list of items is specified and the value of the first item is set to 0, the next item is set to 1, and so on. In the following example, type Week is declared as an enumerated list and MON = 0, TUE = 1, WED = 2, and so on):

enum Week {MON, TUE, WED, THU, FRI, SAT, SUN};

It is possible to imply the values of the elements in an enumerated list. In the following example, black = 2, blue = 3, red = 4, and so on.

enum colors {black = 2, blue, red, white, gray};

Similarly, in the following example, black = 2, blue = 3, red = 8, and gray = 9:

enum colors {black = 2, blue, red = 8, gray};

Variables of type enumeration can be declared by specifying them after the list of items. For example, to declare variable My_Week of enumerated type Week, use the following statement:

enum Week {MON, TUE, WED, THU, FRI, SAT, SUN} My_Week;

Now we can use variable My_Week in a program:

My_Week = WED // assign 2 to My_Week

or

My_Week = 2 // same as above

After defining the enumerated type Week , we can declare variables This_Week and Next_Week of type Week as:

enum Week This_Week, Next_Week;

Arrays are used to store related items in the same block of memory and under a specified name. An array is declared by specifying its type, name, and the number of elements it will store. For example:

unsigned int Total[5];

This array of type unsigned int has the name Total and has five elements. The first element of an array is indexed with 0. Thus, in this example, Total[0] refers to the first element of the array and Total[4] refers to the last element. The array Total is stored in memory in five consecutive locations as follows:

Data can be stored in the array by specifying the array name and index. For example, to store 25 in the second element of the array we have to write:

Total[1] = 25;

Similarly, the contents of an array can be read by specifying the array name and its index. For example, to copy the third array element to a variable called Temp we have to write:

Temp = Total[2];

The contents of an array can be initialized during the declaration of the array by assigning a sequence of comma-delimited values to the array. An example follows where array months has twelve elements and months[0] = 31, months[1] = 28, and so on:

unsigned char months[12] = {31,28,31,30,31,30,31,31,30,31,30,31};

The same array can also be declared without specifying its size:

unsigned char months[] = {31,28,31,30,31,30,31,31,30,31,30,31};

Character arrays can be declared similarly. In the following example, a character array named Hex_Letters is declared with 6 elements:

unsigned char Hex_Letters[] = {'A', 'B', 'C', 'D', 'E', 'F'};

Strings are character arrays with a null terminator. Strings can be declared either by enclosing the string in double quotes, or by specifying each character of the array within single quotes and then terminating the string with a null character. The two string declarations in the following example are identical, and both occupy five locations in memory:

unsigned char Mystring[] = "COMP";

and

unsigned char Mystring[] = {'C', 'O', 'M', 'P', '\0'};

In C programming language, we can also declare arrays with multiple dimensions. One-dimensional arrays are usually called vectors, and two-dimensional arrays are called matrices. A two-dimensional array is declared by specifying the data type of the array, the array name, and the size of each dimension. In the following example, a two-dimensional array named P is created having three rows and four columns. Altogether, the array has twelve elements. The first element of the array is P[0][0], and the last element is P[2][3]. The structure of this array is shown below:

Elements of a multidimensional array can be specified during the declaration of the array. In the following example, two-dimensional array Q has two rows and two columns, its diagonal elements are set to 1, and its nondiagonal elements are cleared to 0: