Comments are used to clarify the operation of the program or a programming statement. Comment lines are ignored and not compiled by the compiler. In mikroC programs comments can be of two types: long comments, extending several lines, and short comments, occupying only a single line. Comment lines at the beginning of a program can describe briefly the program’s operation and provide the author’s name, the program filename, the date the program was written, and a list of version numbers, together with the modifications in each version. As shown in Figure 3.1, comments can also be added after statements to describe the operations that the statements perform. Clear and succinct comment lines are important for the maintenance and thus the lifetime of a program, as a program with good comments is easier to modify and/or update.

As shown in Figure 3.1, long comments start with the character “/*” and terminate with the character “*/”. Similarly, short comments start with the character “//” and do not need a terminating character.

In C language, a program begins with the keywords:

void main ()

After this, a curly opening bracket is used to indicate the beginning of the program body. The program is terminated with a closing curly bracket. Thus, as shown in Figure 3.1, the program has the following structure:

void main()
{
        program body
}

In C language, all program statements must be terminated with the semicolon (“;”) character; otherwise a compiler error will be generated:

j = 5;            // correct
j = 5             // error

White spaces are spaces, blanks, tabs, and newline characters. The C compiler ignores all white spaces. Thus, the following three sequences are identical:

int i;    char j;
or
int i;
char j;
or
int i;
          char j;

Similarly, the following sequences are identical:

i = j + 2;
or
i = j
      + 2;

In general, C language is case sensitive and variables with lowercase names are different from those with uppercase names. Currently, however, mikroC variables are not case sensitive (although future releases of mikroC may offer case sensitivity) so the following variables are equivalent:

total    TOTAL    Total    ToTal    total    totaL

The only exception is the identifiers main and interrupt, which must be written in lowercase in mikroC. In this book we are assuming that the variables are case sensitive, for the sake of compatibility with other C compilers, and variables with the same name but different cases are not used.

In C language, variable names can begin with an alphabetical character or with the underscore character. In essence, variable names can include any of the characters a to z and A to Z, the digits 0 to 9, and the underscore character “_”. Each variable name should be unique within the first 31 characters of its name. Variable names can contain uppercase and lowercase characters (see Section 3.1.5), and numeric characters can be used inside a variable name. Examples of valid variable names are:

Sum    count    sum100    counter    i1    UserName
_myName

Some names are reserved for the compiler itself and cannot be used as variable names in a program. Table 3.1 gives a list of these reserved names.

The mikroC language supports the variable types shown in Table 3.2. Examples of variables are given in this section.

unsigned char total, sum;
sum = 150;

char total, sum;
sum = 150;

char total, sum = 150;

signed char counter = –50;

short counter = –50;

short int counter = –50;

int Big;

unsigned int count = 12000;

signed long LargeNumber;

unsigned long VeryLargeNumber;

float area;
area = 12.235;

Constants represent fixed values (numeric or character) in programs that cannot be changed. Constants are stored in the flash program memory of the PIC microcontroller, thus not wasting valuable and limited RAM memory. In mikroC, constants can be integers, floating points, characters, strings, or enumerated types.

const MAX = 100;

const TOTAL = 0xFF;

const CNT = 017;

const Min = 0b11110000

const TEMP = 37.50

const TEMP = 3.750E1

const First_Alpha = 'A';

"This is an example string constant"

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

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

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 “ ” represents the newline character.

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', ''};

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:

unsigned char Q[2][2] = { {1,0}, {0,1} };

Pointers are an important part of the C language, as they hold the memory addresses of variables. Pointers are declared in the same way as other variables, but with the character (“*”) in front of the variable name. In general, pointers can be created to point to (or hold the addresses of) character variables, integer variables, long variables, floating point variables, or functions (although mikroC currently does not support pointers to functions).

In the following example, an unsigned character pointer named pnt is declared:

unsigned char *pnt;

When a new pointer is created, its content is initially unspecified and it does not hold the address of any variable. We can assign the address of a variable to a pointer using the (“&”) character:

pnt = &Count;

Now pnt holds the address of variable Count. Variable Count can be set to a value by using the character (“*”) in front of its pointer. For example, Count can be set to 10 using its pointer:

*pnt = 10;      // Count = 10

which is the same as

Count = 10;     // Count = 10

Or, the value of Count can be copied to variable Cnt using its pointer:

Cnt = *pnt;     // Cnt = Count

unsigned int Total[10];

Total[2] = 0;

*(Total + 2) = 0;

&Total[j] = Total + j

P = &Z[2];

*P = 0;                       // Z[2] = 0
P = P + 1;                    // P now points to element 3 of Z
*P = 0;                       // Z[3] = 0

*P = 0;                       // Z[2] = 0
*(P + 1) = 0;                 // Z[3] = 0

unsigned int *i, *j;          // declare 2 pointers
unsigned int Cnt, Tot;        // declare two variables
i = &Cnt;    // i points to Cnt
*i = 10;     // Cnt = 10
j = i;       // copy pointer i to pointer j
Tot = *j;    // Tot = 10

A structure can be used to collect related items that are then treated as a single object. Unlike an array, a structure can contain a mixture of data types. For example, a structure can store the personal details (name, surname, age, date of birth, etc.) of a student.

A structure is created by using the keyword struct, followed by a structure name and a list of member declarations. Optionally, variables of the same type as the structure can be declared at the end of the structure.

The following example declares a structure named Person:

struct Person
{
     unsigned char name[20];
     unsigned char surname[20];
     unsigned char nationality[20];
     unsigned char age;
}

Declaring a structure does not occupy any space in memory; rather, the compiler creates a template describing the names and types of the data objects or member elements that will eventually be stored within such a structure variable. Only when variables of the same type as the structure are created do these variables occupy space in memory. We can declare variables of the same type as the structure by giving the name of the structure and the name of the variable. For example, two variables Me and You of type Person can be created by the statement:

struct Person Me, You;

Variables of type Person can also be created during the declaration of the structure as follows:

struct Person
{
      unsigned char name[20];
      unsigned char surname[20];
      unsigned char nationality[20];
      unsigned char age;
} Me, You;

We can assign values to members of a structure by specifying the name of the structure, followed by a dot (“.”) and the name of the member. In the following example, the age of structure variable Me is set to 25, and variable M is assigned to the value of age in structure variable You:

Me.age = 25;
M = You.age;

Structure members can be initialized during the declaration of the structure. In the following example, the radius and height of structure Cylinder are initialized to 1.2 and 2.5 respectively:

struct Cylinder
{
      float radius;
      float height;
} MyCylinder = {1.2, 2.5};

Values can also be set to members of a structure using pointers by defining the variable types as pointers. For example, if TheCylinder is defined as a pointer to structure Cylinder, then we can write:

struct Cylinder
{
      float radius;
      float height;
} *TheCylinder;

TheCylinder −> radius = 1.2;
TheCylinder −> height = 2.5;

The size of a structure is the number of bytes contained within the structure. We can use the sizeof operator to get the size of a structure. Considering the above example,

sizeof(MyCylinder)

returns 8, since each float variable occupies 4 bytes in memory.

Bit fields can be defined using structures. With bit fields we can assign identifiers to bits of a variable. For example, to identify bits 0, 1, 2, and 3 of a variable as LowNibble and to identify the remaining 4 bits as HighNibble we can write:

struct
{
      LowNibble   : 4;
      HighNibble  : 4;
} MyVariable;

We can then access the nibbles of variable MyVariable as:

MyVariable.LowNibble = 12;
MyVariable.HighNibble = 8;

In C language we can use the typedef statements to create new types of variables. For example, a new structure data type named Reg can be created as follows:

typedef struct
{
      unsigned char name[20];
      unsigned char surname[20];
      unsigned age;
} Reg;

Variables of type Reg can then be created in the same way other types of variables are created. In the following example, variables MyReg, Reg1, and Reg2 are created from data type Reg:

Reg MyReg, Reg1, Reg2;

The contents of one structure can be copied to another structure, provided that both structures are derived from the same template. In the following example, structure variables of the same type, P1 and P2, are created, and P2 is copied to P1:

struct Person
{
      unsigned char name[20];
      unsigned char surname[20];
      unsigned int age;
      unsigned int height;
      unsigned weight;
}
struct Person P1, P2;
........................
........................
P2 = P1;

Unions are used to overlay variables. A union is similar to a structure and is even defined in a similar manner. Both are based on templates, and the members of both are accessed using the “.” or “->” operators. A union differs from a structure in that all variables in a union occupy the same memory area, that is, they share the same storage. An example of a union declaration is:

union flags
{
      unsigned char x;
      unsigned int y;
} P;

In this example, variables x and y occupy the same memory area, and the size of this union is 2 bytes long, which is the size of the biggest member of the union. When variable y is loaded with a 2-byte value, variable x will have the same value as the low byte of y. In the following example, y is loaded with 16-bit hexadecimal value 0xAEFA, and x is loaded with 0xFA:

P.y = 0xAEFA;

The size of a union is the size (number of bytes) of its largest member. Thus, the statement:

sizeof(P)

returns 2.

This union can also be declared as:

union flags
{
      unsigned char x;
      unsigned int y;
}
union flags P;

Operators are applied to variables and other objects in expressions to cause certain conditions or computations to occur.

mikroC language supports the following operators:

/* Adding two integers */
5 + 12                                  // equals 17

/* Subtracting two integers */

120 – 5                                 // equals 115
10 – 15                                 // equals –5

/* Dividing two integers */
5 / 3                                   // equals 1
12 / 3                                  // equals 4

/* Multiplying two integers */

3 * 12                                  // equals 36

/* Adding two floating point numbers */
3.1 + 2.4                               // equals 5.5
/* Multiplying two floating point numbers */
2.5 * 5.0                               // equals 12.5
/* Dividing two floating point numbers */
25.0 / 4.0                              // equals 6.25
/* Remainder (not for float) */
7 % 3                                   // equals 1
/* Post-increment operator */
j = 4;
k = j++;                                // k = 4, j = 5
/* Pre-increment operator */
j = 4;
k = ++j;                                // k = 5, j = 5
/* Post-decrement operator */
j = 12;
k = j−−;                               // k = 12, j = 11
/* Pre-decrement operator */
j = 12;
k = −−j;                                // k = 11, j = 11

x = 10
x > 8     // returns 1
x = = 10  // returns 1
x < 100   // returns 1
x > 20    // returns 0
x != 10   // returns 0
x >= 10   // returns 1
x <= 10   // returns 1

/* Logical AND */
x = 7;

x > 0 && x < 10      // returns 1
x > 0 || x < 10      // returns 1
x >=0 && x <=10      // returns 1
x >=0 && x < 5       // returns 0

a = 10; b = 20; c = 30; d = 40;
a > b && c > d       // returns 0
b > a && d > c       // returns 1
a > b || d > c       // returns 1

Expression1 = Expression2

Result = Expression1 operation Expression2

Temp = 10;
Cnt = Cnt + Temp;

Result operation = Expression1

j += k;   is same as:   j = j + k;

p *= m;    is same as    p = p * m;

+=    −=    *=    /=   %=
&=    |=    ^=    >>=  <<=

Result = Expression1 ? Expression2 : Expression3

#define    #undef
#if        #elif      #endif
#ifdef     #ifndef
#error
#line

#define MAX 100

#undef MAX

#ifndef MAX
      #define MAX 100
#endif

#define ADD(a, b)    (a + b)

p = ADD(x, y)    will be transformed into p = (x + y)

#define SQUARE(a)    (a * a)

p = SQUARE(x)    will be transformed into p = (x * x)

#include <file>

#include "file"

#include "C:	emplast.h"

#if M
      A = 0;
      B = 0;
#else
      A = 1;
      B = 1;
#endif

#if M
      A = 0;
      B = 0;
#elif N
      A = 1;
      B = 1;
#else
      A = 2;
      B = 2;

#endif

Statements are normally executed sequentially from the beginning to the end of a program. We can use control statements to modify this normal sequential flow in a C program. The following control statements are available in mikroC programs:

if(expression)
      Statement1;
else
      Statement2;

if(expression)Statement1; else Statement2;

if(x > MAX)
       P++;
else
       P−−;

if(x > MAX)
{
       P++;
       Cnt = P;
       Sum = Sum + Cnt;
}
else
       P−−;

if(x > 0 && x < 10)
{
       Total += Sum;
       Sum++;
}
else
{
       Total = 0;
       Sum = 0;
}

switch (condition)
{
      case condition1:
                 Statements;
                 break;
      case condition2:
                 Statements;
                 break;
      .....................
      .....................
      case condition:
                 Statements;
                 break;
      default:
                 Statements;
}

switch (Cnt)
{
      case 1:
                A = 1;
                break;
      case 10:
                B = 1;
                break;
      case 100:
                C = 1;
                break;
      default:
                D = 1;
}

switch (Cnt)
{
      case 1:      A = 1;    break;
      case 10:     B = 1;    break;
      case 100:    C = 1;    break;
      default:     D = 1;
}

X    Y
1    3.2
2    2.5
3    8.9
4    1.2
5    12.9

switch (X)
{
      case 1:
                 Y = 3.2;
                 break;
      case 2:
                 Y = 2.5;
                 break;
      case 3:
                 Y = 8.9;
                 break;
      case 4:
                 Y = 1.2;
                 break;
      case 5:
                 Y = 12.9;
}

for(initial expression; condition expression; increment expression)
{
      Statements;
}

for(i = 0; i < 10; i ++)
{
      statements;
}

for(i = 1; i <= 10; i++)
{
      Statements;
}

/* Endless loop with incrementing i */
for(i=0; ; i++)
{
      Statements;
}

/* Example of endless loop */
for(; ;)
{
      Statements;
}

/* Endless loop with i = 1 */
for(i=1; ;)
{
      Statements;
}

for(k = 0; k < 10; k++)Total = Total + Sum;

/* Example of nested for loops */
for(i = 0; i < 10; i++)
{
      for(j = 0; j < 5; j++)
      {
            Statements;
      }
}

/* Add all elements of a 3x4 matrix */
Sum = 0;
for(i = 0; i < 3; i++)
{
      for(j = 0; j < 4; j++)
      {
          Sum = Sum + M [i][j];
      }
}

/* Add all elements of a 3x4 matrix */
Sum = 0;
for(i = 0; i < 3; i++)
{
      for(j = 0; j < 4; j++) Sum = Sum + M [i][j];
}

while (condition)
{
      Statements;
}

/* A loop that executes 10 times */
k = 0;
while (k < 10)
{
      Statements;
      k++;
}

/* An endless loop */
k = 0;
while (k < 10)
{
      Statements;
}

/* An endless loop */
while (k = k)
{
      Statements;
}

/* Calculate the sum of numbers from 1 to 10 */
unsigned int k, sum;
k = 1;
sum = 0;
while(k <= 10)
{
     sum = sum + k;
     k++;
}

while(PORTB.0 == 0);     // Wait until PORTB.0 becomes 1

while(PORTB.0);

do
{
      Statements;
} while (condition);

/* Execute 10 times */
k = 0;
do
{
      Statements;
      k++;
} while (k < 10);

/* An endless loop */
k = 0;
do
{
      Statements;
} while (k < 10);

/* An endless loop */
do
{
      Statements;
} while (k = k);

/* Execute 10 times */
k = 0;
Loop:
      Statements;
      k++;
if(k < 10)goto Loop;

/* Calculate sum of numbers 1,2,3,4,6,7,8,9,10 */
Sum = 0;
i = 1;
for(i = 1; i <= 10; i++)
{
      if(i == 5) continue;    // Skip number 5
      Sum = Sum + i;
}

/* Calculate sum of numbers 1,2,3,4,5 */
Sum = 0;
i = 1;
for(i = 1; i <= 10; i++)
{
      if(i > 5) break;    // Stop loop if i > 5
      Sum = Sum + i;
}

It sometimes becomes necessary to mix PIC microcontroller assembly language statements with the mikroC language. For example, very accurate program delays can be generated by using assembly language statements. The topic of assembly language is beyond the scope of this book, but techniques for including assembly language instructions in mikroC programs are discussed in this section for readers who are familiar with the PIC microcontroller assembly languages.

Assembly language instructions can be included in a mikroC program by using the keyword asm (or _asm, or __asm). A group of assembly instructions or a single such instruction can be included within a pair of curly brackets. The syntax is:

asm
{
      assembly instructions
}

Assembly language style comments (a line starting with a semicolon character) are not allowed, but mikroC does allow both types of C style comments to be used with assembly language programs:

asm
{
      /* This assembly code introduces delay to the program*/
      MOVLW 6             // Load W with 6
      ...............
      ...............
}

User-declared C variables can be used in assembly language routines, but they must be declared and initialized before use. For example, C variable Temp can be initialized and then loaded to the W register as:

unsigned char Temp = 10;
asm
{
      MOVLW Temp                  // W = Temp = 10
      ..................
      ..................
}

Global symbols such as predefined port names and register names can be used in assembly language routines without having to initialize them:

asm
{
      MOVWF PORTB
      .....................
      .....................
}

Write a program to set all eight port pins of PORTB to logic 1.

void main()
{
      TRISB = 0;           // Configure PORTB as output
      PORTB = 0xFF;        // Set all port pins to logic a
}

Write a program to set the odd-numbered PORTB pins (bits 1, 3, 5, and 7) to logic 1.

void main()
{
      TRISB = 0;           // Configure PORTB as output
      PORTB = 0xAA;        // Turn on odd numbered port pins
}

Write a program to continuously count up in binary and send this data to PORTB. Thus PORTB requires the binary data:

00000000
00000001
00000010
00000011
............
............
11111110
11111111
00000000
............

void main()
{
      unsigned char Cnt = 0;
      for(;;)                  // Endless loop
      {
           PORTB = Cnt;       // Send Cnt to PORTB
           Cnt++;             // Increment Cnt
      }
}

Write a program to set all bits of PORTB to logic 1 and then to logic 0, and to repeat this process ten times.

void main()
{
      unsigned char j;
      for(j = 0; j < 10; j++)   // Repeat 10 times
      {
      PORTB = 0xFF;             // Set PORTB pins to 1

      PORTB = 0;                // Clear PORTB pins
      }
}

The radius and height of a cylinder are 2.5cm and 10cm respectively. Write a program to calculate the volume of this cylinder.

void main()
{
      float Radius = 2.5, Height = 10;
      float Volume;
      Volume = PI *Radius*Radius*Height;
}

Write a program to find the largest element of an integer array having ten elements.

void main()
{
      unsigned char j;
      int m, A[10];
      m = A[0];    // First element of array
      for(j = 1; j < 10; j++)
      {
           if(A[j]> m)m = A[j];
      }
}

Write a program using a while statement to clear all ten elements of an integer array M.

#define NUM 10
void main()
{
      int M[NUM];
      unsigned char j = 0;
      while (j < NUM)
      {
           M[j] = 0;
           j++;
      }
}

Write a program to convert the temperature from °C to °F starting from 0°C, in steps of 1°C up to and including 100°C, and store the results in an array called F.

void main()
{
      float F[100];
      unsigned char C;
      for(C = 0; C <= 100; C++)
      {
           F[C] = (C – 32.0) / 1.8;
      }
}