Programming Exercises 2

(You are not required to submit your solutions, however solving these exercises will be sufficient to answer the 10 minute quiz that you will be given in class.)
Go to http://codepad.org and try out the following simple C Programs and their suggested modifications.

As we mentioned in the syllabus you should read the later parts of Dr. Patt's EE306 textbook for help with the basics of C. If you do not have the text or you are looking for more information. We have a C Primer for you that is specifically towards Embedded Systems (using Metrowerks) at the following URL:
http://users.ece.utexas.edu/~ryerraballi/CPrimer/

The concepts covered there apply to C programming in general but with a few exceptions like, the lack of input/output library support for functions like printf, scanf and no support for floating point types.

In this set we will look at simple sub-routines and flow control using conditionals (if-then-else statements which we saw in the last set) and loops. We will also look at basics of arrays. If you are referring to Yale Patt's book, you may want to read chapters 13, 14 and 16. If you are referring to the C Primer, you should read chapters 6, 7, 8 and 10.

Exercise 1: A simple count down using a while loop and the same concept implemented using a for loop

void main(void)
{
unsigned char count;

count = 10; // Initialize the loop control variable, (count)
while (count > 0)
{
printf("%d ",count);
count = count - 1; //update count and repeat
}
printf("Lift Off\n"); // When count becomes zero we get out of the loop

for (count=10; count > 0; count--) //count-- is short for count = count-1
{
printf("%d ",count);
}
printf("Lift Off\n");

}

Write C code to do the following:

Count down from 100 to 0 but print every other number out: 100, 98, 96, ... 4, 2, 1 ---- Lift Off
Print all numbers between 1 and 50 that are divisible by 3 or 5 (you will have to use a conditional statement in the body of the for loop)

Nested Loops: The body of a for or while loop may itself contain a for or while loop.

Exercise 2: Say we want to print the multiplication table for numbers between 2 and 9:

void main(void)
{
unsigned char number, count, result;

for (number = 2; number <= 9; number++)
{
printf("\nMultiplication Table for %d\n", number);
for (count = 1; count <= 10; count++) {
result = number*count;
printf("%d X %d = %d\n", number, count, result);
}
}
}

Write C code to do the following:

Print the factorials of numbers 1 to 15. The factorial of a number N is the N*(N-1)*(N-2) ... 1.
You could have loops nested any number of times. Print all Pythogorean triples less than 15. Refer to Figure 14.11 from Yale Patt's book

Arrays
To declare an array of a particular type of size N we use the declaration:
        type arrayname[N]; // type indicates what each value in the array can be (for example unsigned char).
// arrayname is the variable name the array will be referred to as
Examples:
    unsigned char anums[5]; // array of 5 8-bit unsigned numbers
    signed char bnums[8]; // array of 8 8-bit singed numbers
    unsigned short scores[25]; // array of 25 16-bit unsigned numbers

To access individual elements of the array you use the square brackets with the index of the element you wish to access. Note that
indexes start from 0. So, the first element's index is 0 and the last element's index is (Size-1).

Exercise 3: Lets say Sum(n) refers to the sum of the numbers n down to 1. For example (Sum(5) is 5+4+3+2+1 which equals 15). We wish to compute theses sums for the first 25 numbers and store them in an array Sum. We have another array FSum that computes these same sums by using a formula instead. We will check if the formula is correct by comparing elements of Sum against elements of FSum.

#define true 1
#define false 0
#define N 25 // The Size of the Array
void main(void)
{
   unsigned short num, partialsum, count;
   unsigned short Sum[N], FSum[N]; //Declared arrays to store 16-bit values
   unsigned char correct;

   for (num = 0; num < N; num++)
   {
      partialsum = 0; // partialsum will hold the running sum as we compute it
      for (count = num+1; count >= 1; count--)
      {
         partialsum += count;
      }
      Sum[num] = partialsum; //Note Sum[0] holds Sum(1); Sum[1] holds Sum(2) and so on
   }

   for (num = 1; num <= N; num++)
   {
      FSum[num-1] = (num * (num + 1))/2;
           //Note FSum[0] holds FSum(1); FSum[1] holds FSum(2) and so on
           // The formula is Sum(n) = (n * (n+1))/2
   }

   // Check if the formula and computation agree
   correct = true; // Assume that they match and change it to false if
                   // there is a mismatch
   for (num = 0; num < N; num++)
   {
     if (Sum[num] != FSum[num]) {
        correct = false;
     }
   }
   if (correct) {
       printf("Formula Works");
   } else {
       printf("Formula Wrong");
   }

}

Write C code to do the following:

Declare 3 arrays called bases, opposites and hypotenuses all of the same size N. Populate theses arrays by computing the N Pythogorean triples that you wrote the code for in the previous exercise.
Write a program that searches an array of N 16-bit numbers (call it haystack) to see if a particular value (call it needle) is present in it.
You can declare an array and initialize it in one step like so:
unsigned char foos[5] = {12, 4 , 13, 2, 15}; // foos[0] has 12, ... foos[4] has 15

Sub-routines (aka Functions)

Sub-routines work in C very much like in assembly except they are called functions in C.

The key elements to note about functions are:

Functions must be declared using function prototypes. This is used by the compiler when checking to see if you are calling a function correctly.
For example the following function prototype says foofunc is a function that expects one unsigned short as input parameter and returns a signed char are output:
signed char foofunc(unsigned short); // Note only types need to the specified for checking
Calls to functions. A function call (like bsr or jsr in 9S12) must follow the calling convention specified by the prototype. So calls to foofunc for example have to be as follows:
result = foofunc(input); // input must be declared as an unsigned short and result as a signed char
Function implementations provide the code that will be executed when the function is called. The code captures the purpose of the function. Say foofunc simply returned the higher byte of the passed input as a signed number then the code would be as follows:
signed char foofunc(unsigned short input)
{
signed char result;

result = input>>8;
return result;
}

Exercise 4: Lets rewrite the code from Exercise 3 by modularizing it using sub-routines:

#define true 1
#define false 0
#define N 25     // The Size of the Array

unsigned short Sum[N], FSum[N]; //Declared arrays to store 16-bit values
                                // These are now Global so all sub-routines including
                                // main can manipulate them

//Declare function prototypes here so compiler can check if we are
// caling them correctly
unsigned short hardway(unsigned char);
unsigned short formula(unsigned char);
void Check(void);

// The main program uses a modular decomposition of the problem into
// sub-problems that are implemented as functions that are called
int main(void)
{
   unsigned char num;

   for (num = 0; num < N; num++)
   {
      Sum[num] = hardway(num); //Call the hardway function by passing it num
// put the returned sum in the corresponding location
// in the array Sum
   }

   for (num = 1; num <= N; num++)
   {
      FSum[num-1] = formula(num);
   }
   Check();
}

unsigned short hardway(unsigned char number )
{
   unsigned short sum = 0; // partialsum will hold the
                                  // running sum as we compute it
   unsigned char num, count;

   for (count = number+1; count >= 1; count--)
   {
      sum += count;
   }
   return sum;   // sum holds the result so return it
}

unsigned short formula(unsigned char number )
{

   return (number * (number+1))/2;   // formula

}

void Check(void)
{
   unsigned char correct, num;

   // Check if the formula and computation agree
   correct = true; // Assume that they match and change it to false if
                   // there is a mismatch
   for (num = 0; num < N; num++)
   {
     if (Sum[num] != FSum[num]) {
        correct = false;
     }
   }
   if (correct) {
       printf("Formula Works");
   } else {
       printf("Formula Wrong");
   }

}

Write code to do the following:

Rewrite the Pythogorean Triples exercise with a function that takes three input paramters base, height and hypotenuse and returns true or false to indicate if they form a triple. Call this function in your main function to repeatedly check if a given triple is a valid Pythogorean triple.
Write a C function that reverses the bits of an 8-bit signed number has an odd (indicate by returning 0) or even number (indicate by returning 1) of ones in its binary representation. Call it from your main function with different test values to see if the function is working correctly.