Arrays

In C, an array is a type of data structure that can store several items, known as elements, of the same array. Arrays are very useful in C and embedded programming. The use of an array is fundamental when working with PIC® microcontrollers. An array can be declared with or without a specified size.

Example:

int temperatures[5] = {29, 25, 26, 25, 28};

The same sequence can be written as follows:

int temperatures[] = {29, 25, 26, 25, 28};

Elements of an array are accessed with the first element having an index of 0. These elements are accessed as follows:

int monday = temperature[0]; // monday will have value 29

You may also assign a value to a single element of an array using the following:

temperatures[2] = 27; // element 2 now has the value of 27

Pointers

The pointer. Many people have difficulty grasping the simple proposition. Pointers are powerful. Although I sparingly use pointers in this book, they are one of the most important C concepts.

Most people are confused as to what a pointer is and its purpose. A pointer is just another variable. Think of pointers like an int, char, or float. We know that an int stores numbers, char stores individual characters, and float stores decimal numbers. However, don’t let the asterisk and ampersand scare you.

A pointer simply is a variable that stores the memory address of another variable. It is quite simple to understand. Listing 2-7 shows an example of how to declare a pointer and common assignment.

Listing 2-7 Declaring a Pointer

// an integer declaration
int num;

// a pointer to an integer
int *num_pointer;

// the pointer now has memory address of the integer 'num'
num_pointer = #

See how simple pointers are to use? If you still have difficulty understanding them, then do some further research. There are entire books dedicated to the use of pointers.

Structures

You can get by with most simple C programming just by using arrays. However, when you want to store several data types, you must use a structure.

The struct keyword is used to declare structures. Listing 2-8 shows how you declare a structure.

Listing 2-8 Declaring a Structure

struct Speed{
byte slow;
byte normal;
byte fast;
};

To use a struct, you declare a type of the struct (see Listing 2-9).

Listing 2-9 Declaring a Type of Structure

// Declare MotorSpeed of type speed
struct Speed Motorspeed;

You then access a member of a structure with a dot (.) as the member access operator as follows:

MotorSpeed.slow = 10;

structs are very useful when programming microcontrollers.

if Statement

The if statement is used to make decisions within a program (see Listing 2-13).

Listing 2-13 Example of an if Statement

if (speed == 200)
{
turnLightOn();
}

else Statement

The else statement allows the programmer to perform another action and is a complement to the if statement (see Listing 2-14).

Listing 2-14 Example of an else Statement

if(speed == 200)
{
turnLightOn();
}

else                    
{
keepLightOff();
}

else if Statement

Sometimes we need to test for more than two conditions of the program and that is when we use an else if statement (see Listing 2-15).

Listing 2-15 Example of an else if Statement

if(speed == 200)
{
turnRedLightOn();
}

else if (speed == 150)
{
turnYellowLightOn();
}

else                    
{

}

switch statement

The switch statement is used when we need to compare a variable against different values (see Listing 2-16). It is used in situations where excessive if and else if statements would have been used. You must remember to include break statements within the cases; otherwise, the flow would fall to subsequent cases until a break statement. The default case is used when none of the other cases is true.

Listing 2-16 Example of a switch Statement

switch (speed)
{
case 100:
beepOneTime();
break;

case 150:
beepTwoTimes();
break;

case 200:

case 250:
turnOffEngine();
break;

break:
keepEngineRunning();
}

for Loop

The for loop is used when you need to execute a sequence of statements a number of times (see Listing 2-17).

Listing 2-17 Example of a for Loop

for(int x = 0; x<= 10; x++)
{
spi_send(0x01);

delay_ms(1000);
}

while Loop

The while loop repeats a group of statements while the condition specified is true (see Listing 2-18). while loops are very important in embedded systems and are typically used to create an infinite loop since there is usually no operating system to keep the program running. All the programs in this book utilize an infinite while loop.

Listing 2-18 Example of a while Loop

while(1)
{
readSensor();
checkBattery();
updateDisplay();
}

do Loop

The do loop works just like the while loop, except that it checks the conditions of the loop after execution and it will execute at least once. See Listing 2-19.

Listing 2-19 Example of do Loop

do
{
temp = readTemperature();
} while(temp < 40);

break Statement

The break statement is used to terminate a loop and, when it’s used, the statement immediately following the loop is executed (see Listing 2-20).

Listing 2-20 Example of a break Statement

if (temperature > 35)
{
break;
}

continue Statement

The continue statement causes a skip in the rest of the current iteration of the loop to take place (see Listing 2-21).

Listing 2-21 Example of a continue Statement

for (i = 0; i < 1023; i++)
{
if (i > 100 && i < 400)
{
continue;
}

spi_send(0x02);
}

goto Statement

The goto statement is looked upon with shame. However, there are instances when an unconditional jump is useful. Although using the goto statement often leads to spaghetti code, it is useful to understand how it operates.

The goto statement simply transfers the program flow to a point in the program that has a label (see Listing 2-22). The one time it may be necessary to use a goto loop is when there are deeply nested for loops or if statements.

Listing 2-22 Example of a goto Statement

myLabel:
turnOnSomething();

goto myLabel;

#define

The #define directive is the first we will look at. The #define statement in C defines macros. This statement is used a lot in embedded programming and is very useful. Instead of having to keep typing some constant, it is easier to use the #define directive. This is also useful in instances where constants may need to be changed.

For example, if we are writing a driver for an LCD that comes in two compatible variants—128x64 and 128x32—then instead of having to constantly write those numbers, since the dimensions of the LCD would remain the same, it is easier to write it as shown in Listing 2-23.

Listing 2-23 Define Macros Using #define

#define LCD_HEIGHT 128
#define LCD_WIDTH 64

A little warning though: Remember to omit the semicolon after the macro as it will generate compiler errors. Another important use of the #define directive is in the creation of function-like macros. These are macros that can be used to create a small “function” and are useful for the creation of small functions that may appear many times in your code. See Listing 2-24.

Listing 2-24 Example of #define Statement

#define MAX(x, y) ((X) > (Y) ? (X) : (Y))

The most important use of such functions I have found in practice is that they do not require a specific type and can use any generic type. In the example in Listing 2-24, it doesn’t matter if the parameters are int, float, or double, the maximum would still be returned. Learning to use the #define directive as it is very important. Sometimes you may see this referred to as a lambda function.

#if, #ifdef, #ifndef, #elif, and #else

These preprocessor directives are used for conditional compilation in the program. These directives are important. These directives are commonly used for debugging and to develop libraries that target multiple chips. They are straightforward. Listing 2-25 shows how the directives are used.

Listing 2-25 Examples of Preprocessor Directives in Use

#ifdef PIC16F1717
#define SPEED 200
#elif defined (__PIC24F__)
#define SPEED 300
#else
#define SPEED 100
#endif

Note that the conditional directives must end with an #endif statement.

#pragma

This is a C directive that in general-purpose programming is used for machine- or operating system-specific directives. This directive is most commonly encountered to set the configuration bits of the PIC® microcontroller (see Listing 2-26).

Listing 2-26 Example of #pragma

#pragma config PLLDIV = 2