Chapter 8: C Pointers and Arrays

This is a perfectly good function, but it requires that the user never ask for more bytes than the size of the pBuffer array. What if we set indexps = 50? The LoadEEPROM will fill the Name[STRLENGHT] array and the 25 bytes of RAM that follow the array. Since the second 25 bytes wasn’t allocated to this function we have no way of knowing what’s supposed to be stored there, but we overwrite it anyway and almost certainly cause havoc.

It would be good programming practice to add a line that checked the array size and the number of bytes before calling the LoadEEPROM function, and if there’s a problem generate an error.

if(NAMESIZE >= indexps){

// Load name from EEPROM

LoadEEPROM(Name, indexps, EEPROM_START + 1);

}

else

ErrorMessage(“LoadEEPROM error: number of bytes requested > array size”);

But we are smart and we’d never make such a dumb error, so why bother adding the extra code that only slows things down and increases the code size and is a pain to type? The obvious answer is that the mistakes we make will often be painfully dumb.

FIFOs and LIFOs: Stacks and Queues (Circular Buffers)

Stacks

Assembly language programmers frequently use the stack when calling subroutines and running algorithms.

Stacks are like those piles of trays in cafeterias, we take trays off the top and the dishwasher piles them back on the top. The top trays are usually wet and the bottom trays never get used. It is important to us that the we never try to use the tray below the bottom tray because it doesn’t exist, the analogy breaks down and we have a blown stack, as shown earlier when we discussed how C uses a stack when calling functions. Sometimes you’ll see ‘fifo’ to refer to these kinds of

167

Chapter 8: C Pointers and Arrays

stacks, fifo stands for ‘first in first out’. In control applications it is sometimes convenient to have fifos, private stacks, to manipulate data.

#define STACKSIZE 100

unsigned char myStack[STACKSIZE]; // create a data stack char stackCount = 0;

unsigned char myValue = 0; // create a byte variable

//Do some controlling

//push a byte on the stack

if (stackCount++ < STACKSIZE) // don’t blow your stack *myStack++ = myValue;

else

error(“You almost blew your stack! - overflow”);

//Do some more controlling

//pull a byte off the stack

if(stackCount-- > 0) //don’t blow itvin the other directon myValue = *--myStack;

else

error(“You almost blew your stack! - underflow”);

Queues (Circular Buffers)

If stacks are like lunchroom trays, then queues are like the line of students waiting to get a tray. The last one in line is the last one to get a tray. A circular buffer is more like a game of hot potato where the students form a circle and pass a hot pototo from one to the next and it keeps circulating indefinitely around. The hot potato in our analogy is actually the pointer to the next address in the queue. For real students it would probably be a joint or a bottle of cheap alcohol.

168