Microcontroller based applied digital control (D. Ibrahim, 2006)

4.6 VOLATILE VARIABLES

A variable should be declared volatile whenever its value can be changed by something beyond the control of the program in which it appears, such as an interrupt service routine. The volatile qualifier tells the compiler that the value of the variable may change at any time without any action being taken by the code the compiler finds nearby. All I/O based variables and variables shared by the main code and interrupt service routines should be declared volatile. In the following example, the variable count is declared volatile:

volatile int count;

4.7 PERSISTENT VARIABLES

Normally, the initial values of variables are cleared to zero when the program starts up (i.e. whenever reset is applied to the microcontroller). The persistent qualifier prevents a variable from being cleared at start-up. In the following example, the variable max is declared persistent and as a result its value is not cleared after a reset:

persistent int max

4.8 ABSOLUTE ADDRESS VARIABLES

It is possible to declare a variable such that it holds the address of an absolute location in the microcontroller memory. This is done by typing the character ‘@’ after the name of the variable. For example,

unsigned char Portbit @ 0×06

In this code, the variable Portbit is assigned the absolute hexadecimal address 0 × 06. It is important to realize that the compiler does not create a location for the variable Portbit, it simply assigns the variable to the specified absolute address.

The bit data type and absolute address variables can be used together to access individual bits of a register. For example, the PORTA register is at absolute address 5. We can declare a variable called PA1 to access bit 1 of PORTA as follows:

unsigned char PORTA @ 0×05; bit PA1 @ (unsigned)&PORTA*8+1;

4.9 BANK1 QUALIFIER

The bank1 type qualifier is used to store static variables in RAM bank 1 of the microcontroller. By default, variables are stored in bank 0 of the RAM. In the following example, the static integer variable temp is stored in bank 1:

static bank1 int temp;

ARRAYS 85

In this example, the size of array device is set to 8 and the elements of this array are:

device[0] = ’C’ device[1] = ’O’ device[2] = ’M’ device[3] = ’P’ device[4] = ’U’ device[5] = ’T’ device[6] = ’E’ device[7] = ’R’

Another way of storing characters in an array is as string variables. Strings are a collection of characters stored in an array and terminated with the null character (ASCII 0). For example, the characters COMPUTER can be stored as a string in array device as:

unsigned char device[] = ’COMPUTER’;

In this example, the array size is set to 9 and the last element of the array is the null character, i.e. the elements of array device are:

device[0] = ’C’ device[1] = ’O’ device[2] = ’M’ device[3] = ’P’ device[4] = ’U’ device[5] = ’T’ device[6] = ’E’ device[7] = ’R’ device[8] = 0

Arrays can have multiple dimensions. For example, a two-dimensional array is declared by specifying the size of its rows followed by the size of its columns. In the example below, a two-dimensional integer array having three rows and five columns is declared. The array is given the name temp:

int temp[3][5];

This array has a total of 15 elements as shown in Figure 4.2. The first element (top left-hand) is indexed as temp[0][0] and the last element (bottom-right) is indexed as temp[2][4]. Values can be loaded into the array elements by specifying the row and the column index of the location to be loaded. For example, integer number 50 is loaded into the first row and third column of array temp:

temp[0][2] = 50;

Figure 4.2 A two dimensional array

86 PROGRAMMING PIC MICROCONTROLLERS IN C

4.11 ASCII CONSTANTS

The PICC Lite compiler supports a number of ASCII constants which can be used in programs instead of their numeric values. The following are constants the frequently used:

\n newline character \t tab character

\\backslash character

\’ single quote character \0 null character

Character constants are used by enclosing them in single quotes. For example, the variable temp can be assigned the null character by writing:

temp = ’\0’;

4.12 ARITHMETIC AND LOGIC OPERATORS

The PICC Lite compiler supports a large number of arithmetic and logical operators. The most commonly used operators are summarized below:

()[] parenthesis

!logical NOT

bit complement

+ - * / arithmetic add, subtract, multiply, divide

% arithmetic modulo (remainder from integer division) ++ increment by 1

-- decrement by 1 & address of

<< shift left

>>shift right

≥ greater than or equal

>greater than

≤ less than or equal

<less than

==logical equals

&&logical AND

Some of the operators are unique to the C language and need further clarification. The preincrement and post-increment operators and their equivalents are:

It is important to realize that if the operator occurs after a variable name in an expression, the value of the variable is used in the expression, and then the variable is changed afterwards. Similarly, if the operator occurs before the variable name, the value of the variable is changed before evaluating the expression and then the expression is evaluated:

x = a*b++; is equivalent to x = a*b; b = b + 1;

but

x = ++b*a; is equivalent to b = b + 1; x = b*a;

Similarly,

x = a*b--; is equivalent to x = a*b; b = b -- 1;

but

x = --b*a; is equivalent to b = b -- 1; x = b*a;

The following short-hand mathematical operations and their equivalents can be used:

A given number can be shifted left or right using the shift operators. ‘<<’ (operator shifts left a number) and ‘>>’ (operator shifts right a number). Assuming that the value of variable sum = 8, the shift operations produce the following results:

Logical complement, AND, and OR operations apply on all bits of a variable. Assuming a and b are 8-bit unsigned character type variables, and a = 6 (bit pattern 00000110) and b = 2 (bit pattern 00000010), the logical operators produce the following results:

x = a; x is assigned complement of a. i.e. x

= 11111001 i.e. x = 249

x= a & b; x is assigned logical bitwise AND of a and b.

00000110

00000010

--------

00000010 i.e. the value of x is 2

90 PROGRAMMING PIC MICROCONTROLLERS IN C

A structure does not store any location in the memory when it is declared. We can now declare variables of type person with the following statement:

struct person my details;

The elements of a structure can be accessed by writing the structure name, followed by a dot, and the element name. For example, the age of structure my details can be assigned number 20 as:

my details.age = 20;

The typedef statement can also be used to declare a structure. For example, the above structure can be defined as:

typedef struct {

unsigned char name[80]; unsigned char surname[80]; unsigned int age;

unsigned char address[80]; } person;

A new variable of type person can now be declared as follows:

person my details;

The variable name is my details, it has members called name, surname, age, and address. Another example of a structure is a complex number consisting of a real number and an

imaginary number:

typedef struct { double real part;

double imaginary part; } complex;

PICC Lite also supports bit fields in structures. Bit fields are allocated starting with the least significant bit of the word in which they will be stored. The first bit allocated is the least significant bit of the byte, and bit fields are always allocated in 8-bit units. In the following example, the structure flags consists of a byte where the first bit is named x, the second bit is named y, and the remaining six bits are named z:

struct flags

{

unsigned char x:1; unsigned char y:1; unsigned char z:6;

};

stcruct flags temp;

In this example, the second bit of temp can be cleared as follows:

temp.y = 0;