Файл: Programming Microcontrollers in C, 2-nd edit (Ted Van Sickle, 2001).pdf

Microcontroller Memory 159

Programming EEPROM

EEPROM is read like any other memory in the microcontroller. Two different types of EEPROM can be found on a microcontroller: program memory and data storage memory. Program memory usu­ ally cannot be programmed without the aid of an externally applied programming voltage. Data storage memory can be programmed from within the program and requires no externally applied programming voltage. In the case of the M68HC805B6, there are 5888 bytes of program EEPROM and 255 bytes of data storage EEPROM. Other than the reduced size of the data storage memory, this memory is no different from the program memory. It is possible to write code to the data storage EEPROM and execute this code.

One additional byte of data storage EEPROM exists and is called the OPTION register. This register content is saved in EEPROM which is read into a latched register during the initialization of the microcontroller. The address of this register is 0x100. The bits in this register control the security option of the part and control a block protect region in the data storage EEPROM that will prevent acci­ dental writing of data into the protected memory area. A description of these bits follows:

protected. If this bit is in the erased state, (1), part 2 of the EEPROM will be protected. This memory area can be read as usual, but any attempt to write to this area will fail. The protection remains in

160 Chapter 4 Small 8-Bit Systems

effect after this bit is erased until after the next chip reset.

Control of the EEPROM programming is through the EEPROMCTL register found at address 0x07. The bits in this register are as follows:

Let us now examine a possible sequence of code that can be used to program and erase locations in EEPROM. First, several macro definitions should be used to define the various parameters used.

Microcontroller Memory 161

/* pragmas to identify EEPROM control registers */

#pragma portrw EEPROM_CTL @ 0x07; #pragma portrw OPTIONS @ 0x100;

.

.

.

/* EEPROM programming specific defines */

#define E1PGM 0 #define E1LAT 1 #define E1ERA 2 #define PROG_TIME 10

.

.

/* some function prototypes */

void delay(unsigned long); void program(int ,int); void erase(int );

.

.

.

int EEPROM[0xff] @ 0x101; /* Identify the EEPROM */ void program(int address,int value)

{

EEPROM_CTL.E1LAT=1; /* set the E1LAT bit */ EEPROM[address]=value;/* put the data and address

in place */

EEPROM_CTL.E1PGM=1; /* turn on the charge pump */ delay(PROG_TIME); /* delay programming time */ EEPROM_CTL.E1LAT=0; /* reset the E1LAT also

resets the E1PGM bit */

}/* return when done */

void erase(int x)

{

Microcontroller Memory 163

void program(int,int ); void erase(int );

The function program() requires 20 bytes and the function erase requires 22. This is a good point to explore some of the C programming practices that can lead to poor M68HC05 family com­

164 Chapter 4 Small 8-Bit Systems

piled code. The M68HC05 family is a family of 8-bit machines. There has been no discussion of the programmers’ register model of these devices. Programmer models of the larger microcontrollers will be discussed because knowledge of the programmers’ model might help in crafting good C code. For these small machines, the watchword is 8-bit. The internal structure of the system is all 8-bit. The width of the single index register is 8 bits, and the width of the accumulator is also 8 bits. The program counter is more than 8 bits in most cases, but it is wide enough to address only the range of the internal com­ puter memory. In fact, the width of the stack pointer in the M68HC05Bx family is only 6 bits. There is no luxury of spare bits in any register.

Therefore, when writing code for the M68HC05 family, keep fore­ most in your mind that you are dealing with an 8-bit device. If at all possible, avoid 16-bit operations because they will always result in larger memory and/or code usage. The following code demonstrates an ex­ ample of the careless use of 16-bit implied code in an 8-bit machine.

Consider the erase() routine from above. This function could have been written as follows:

void erase(int *x)

{

EEPROM_CTL.E1LAT=1; /* set the E1LAT bit */ EEPROM_CTL.E1ERA=1; /* set the E1ERA erase bit */ *x=0; /* select the address */ EEPROM_CTL.E1PGM=1; /* turn on the charge pump*/ delay(PROG_TIME); /* wait the appropriate time*/ EEPROM_CTL.E1LAT=0; /* reset the E1LAT bit turns

off both E1PGM and E1ERA bits */

}/* return when done */

The only change in this version is to pass the integer *x to the function by reference. Remember, since all addresses in the M68HC05 family of parts are greater than 8 bits, the compiler must handle the transfer of the pointer x as a 16-bit number. The statement *x=0; compiles into an inline function at the address range 0x81d to 0x82c in the compiled version of the code shown below. This function creates a subroutine that does an indexed store with a 16-bit offset. First, the value to be programmed is placed in the accumulator. Then the op

Microcontroller Memory 165

code, 0xd7, to do a store the accumulator indexed with a 16-bit offset is created at the location 0x56 in memory. The 16-bit offset is the address passed to the function in the combination of the x register and the accumulator. This address is placed in the memory locations 0x58 and 0x57, completing the store instruction. At the address 0x59, a re­ turn from subroutine instruction, 0x81, is placed to complete the function. The index register is cleared, and this two-instruction sub­ routine is executed to store the appropriate data prior to the program setting the latch bit.

void erase(int* x)

This code sequence requires 36 bytes, plus 4 bytes of uncommit­ ted RAM space, to accomplish what required 22 bytes in the earlier example of the same operation.

You must not avoid the use of pointers because of this one ex­ ample. There are cases when proper pointer usage will provide the best code that you can generate. When writing code for microcontrollers, use many relatively small functions that you can