Notes on the use of the standardized drivers for the uP535, Keil and Dunfield compilers:

	Before using a set of standardized drivers, read through the documentation file.  This file will have 
a full list of the available functions, as well as hardware-specific notes on the function of the drivers, along 
with any other information you may need to use the drivers successfully.  You should also glance through 
the header file (file with the same name as the documentation, but with a .h extension) for constants which 
are defined, function prototypes, and other information.

	To use the drivers, you must #include the header file in each of your code files which calls any 
functions from that set of drivers (each set of drivers has its own header file.)  Keep in mind that you may 
have to specify full path information telling your compiler where to look for these files.

	You must also include the driver code in your project.  When using the Keil compiler, this is as 
simple as editing your project, adding the code file (file with the .c extension) to your project.  The 
Dunfield compiler does not support projects.  As such, the code file must be #included in much the same 
manner as the header file.  The code file should only be included once, however,  The header file must be 
#included before the code file.

	Once these steps have been accomplished, you may call the driver functions from your program.

Compiler errors:

	When using multiple sets of drivers, it is possible to generate compiler (and assembler) errors due 
to multiple definitions.  In such cases, simply comment out the lines generating the errors.  This may leave 
“undefined” errors in some files.  For these, copy the necessary definitions from the header files and paste 
them into the appropriate code files.  This can take some adjustment before everything is defined where it 
needs to be exactly once.  Later versions of these drivers may correct some of these problems.

Warnings:

	It is not uncommon for the drivers to generate warnings.  This is because they must contain 
definitions for many registers and addresses that some compilers also define, and because they must 
contain code for many different device configurations, some of which will never be executed for certain 
combinations of #defines.  These warnings should be ignored; the drivers should function normally.