Essentially, we've moved the for loop which implements the delay to within the function. The for loop itself is very similar to that used by helloBlinky_c2v1, except that the compare instruction used to terminate the loop now references the input argument d rather than a literal value (that is, 1000000).

for (i=0; i < d; i++) {
  ;
}

This is advantageous because it parameterizes the delay function, thereby allowing it to be used to implement different length delays, determined by the value of input argument d. An important feature of all programming languages is the mechanism they use to pass arguments to a function when it is called. There are two general models, called pass-by-value and pass-by-reference. The delay function call we've used here:

delay (num_ticks);

adopts a pass-by-value model. In this case, a copy of the variable num_ticks is passed to the delay function, and this copy can be referenced through the variable d. The statements inside the function can only access the variables declared within the function (that is, local to the function) and the input arguments. The function may change the value of the copy, but when the function terminates the copy (and the so-called automatic variables declared inside the function cease to exist). This model works fine in this case, because the function doesn't need to change the value of the variable num_ticks declared in main() (that is, the calling function).

All identifiers in C need to be declared before they are used. This is true of functions as well as variables (you may be catching onto the idea that C compilers don't tolerate surprises!), so functions should be declared before they are defined or called. A function declaration (also called a function prototype) includes the type of variable returned by the function, and the types of all the input args. C compilers accept the function definition as an implicit declaration and lazy programmers sometimes take advantage of this and omit the function prototype. But in this case, it must occur before the function is called. Nevertheless, it is considered good practice to include prototypes for all functions used. Function prototypes are usually placed at the beginning of the program or in a separate #include file. The prototype for our delay function looks like this:

void delay (unsigned integer);

If the delay function did need access to main functions variable, num_ticks, then it would need to access the memory location where num_ticks was stored. In this case, rather than passing a copy, we need to pass a reference (or so-called pointer) to the variable. C includes two special operators (* and &) for handling memory references. The ability to manipulate pointers as well as variables makes C a very powerful language, and it is a feature that is particularly useful for embedded systems programming. Consider the declaration:

unsigned int *ptr;

Here, ptr is the name of our variable, but in this case, it is preceded by the dereferencing operator * which tells the compiler it's a pointer variable, and so, the compiler must reserve enough memory to store an address. It also says the address will reference (that is, point to) an unsigned integer. When the pointer is declared and hasn't been assigned, we say the pointer is NULL (that is, its value cannot be guaranteed). To assign the pointer, we need to find the address of the variable num_ticks; the & operator achieves this. For example:

ptr = &num_ticks;

Let's consider another version of the delay function that doesn't declare the local variable i, but instead, employs a while loop that decrements the variable num_ticks declared in main. To do this, the function call to delay (within main) will need to pass a reference (or pointer) to num_ticks, and the delay() function will need to be told to expect a pointer to an unsigned integer as an input arg. Therefore, the function prototype will need to be changed to

void delay (unsigned int *);

and the function declaration itself becomes:

void delay (unsigned int *ptr) {
    
    while (*ptr > 0 ) 
    *ptr = (*ptr)-1;       /* Wait */  
}

The delay function uses the dereferencing operator * whenever it needs to access the value pointed to by ptr. The following recipe (helloBlinky_c2v3) represents a version of helloBlinky that uses pointers:

void delay (unsigned int *);      /* Func Prototype */

int main (void) {
  const unsigned int max_LEDs = 8;
  const unsigned int wait_period = 500000;
  unsigned int *ptr;
  unsigned int num_ticks;
  unsigned int num = 0;

  HAL_Init ( );   /* Init Hardware Abstraction Layer */
  SystemClock_Config ( );           /* Config Clocks */
  LED_Initialize();                      /* LED Init */

  for (;;) {                         /* Loop forever */
    LED_On (num);                          /* LED on */
    num_ticks = wait_period;        /* (re)set delay */
    ptr = &num_ticks;              /* assign pointer */
    delay (ptr);              /* call delay function */
    LED_Off (num);                        /* LED off */
    num_ticks = wait_period;        /* (re)set delay */
    delay (ptr);              /* call delay function */
    num = (num+1)%max_LEDs;	/* increment num (mod-8) */
  } /* end for */
} /* end main ( ) */

void delay (unsigned int *p){        /* Function Def */
  
  while (*p > 0 ) 
    *p = *p-1;                              /* Wait */
  
} /* end delay ( ) */

The preceding version of helloBlinky is just a vehicle for illustrating pointers, and the earlier recipe is preferable and easier to understand. So why are pointers used? Well, if our delay function needed access to many values, making the copies needed for pass-by-value would be time-consuming and impractical. This is particularly true when we come to consider passing arrays of data, strings (arrays of characters), and so on.