51 MCU study notes: continuous reading and writing of STC89C52RC internal EEPROM memory

The internal EEPROM of the STC microcontroller is simulated by DATAFLASH, not a real EEPROM memory, and cannot be operated by ordinary methods.
Here are some points to note:
1. Before writing a byte, read the other valid data of the sector where the byte is located into RAM for temporary storage (this step is not necessary).
2. After temporary storage, erase the entire sector (512 bytes). After erasing, the data in each address of the entire sector becomes 0xFF.
3. Write the N bytes of data to be written into EEPROM using the byte write function
. 4. Write other useful EEPROM values ​​temporarily stored in RAM back to EEPROM using the byte write function.
5. The byte write function of the EEPROM simulated by STC using FLASH can only change 1 to 0, but not 0 to 1.
  The data is all 1 only after the sector is erased.
  For example: at address 0x21f0, write 11010110 for the first time, and write 111010 for the second time. The read result is the AND of these two values ​​10010.
         Therefore, it is wrong to write new data when the value at an address is not 0xff. The sector must be erased first to change it to 0xff.
         For writing a single byte, we can first check whether the data at the address is 0xff. If it is, there is no need to erase the sector.

----------------------------------------------------------------------
The reading and writing process of the internal EEPROM of the STC89C52 microcontroller 
1. Configure the ISP_CONTR register, enable the 7th bit ISPEN, make the ISP_IAP function effective, and configure the waiting time of the lower 3 bits
2. Write instructions: the 3 commands of read/write/erase sector 3. Assignment
: the address value of ISP_ADDRH and ISP_ADDRL
4. Turn off the total interrupt EA, because the 2 trigger instructions to be written below must be operated continuously and cannot be interrupted
5. Execute the common ISP_IAP trigger instruction. The read and write operations can be performed after the trigger
6. Turn on the interrupt EA, turn off the ISP_IAP function: clear the relevant registers

C Code  

1. #include "my51.h"  

2.   

3. /******************Define command bytes******************/         

4. #define read_cmd 0x01 //Byte read data command       

5. #define wirte_cmd 0x02 //byte programming data command       

6. #define erase_cmd 0x03 // sector erase data command                 

7.     

8. /****************Special function register declaration****************/    

9. sfr ISP_DATA = 0xe2;     

10. sfr ISP_ADDRH = 0xe3;       

11. sfr ISP_ADDRL = 0xe4;     

12. sfr ISP_CMD = 0xe5;     

13. sfr ISP_TRIG = 0xe6;        

14. sfr ISP_CONTR = 0xe7;  

15.   

16. /*Define Flash operation waiting time and constants to allow IAP/ISP/EEPROM operations******************/  

17. //#define enable_waitTime 0x80 //When the system operating clock is <30MHz, set this value to the IAP_CONTR register  

18. //#define enable_waitTime 0x81 //When the system operating clock is <24MHz, set this value to the IAP_CONTR register  

19. //#define enable_waitTime 0x82 //When the system operating clock is <20MHz, set this value for the IAP_CONTR register  

20. #define enable_waitTime 0x83 //When the system working clock is <12MHz, set this value to the IAP_CONTR register  

21. //#define enable_waitTime 0x84 //When the system operating clock is <6MHz, set this value for the IAP_CONTR register  

22.     

23.       

24. void ISP_IAP_disable(void) //Close ISP_IAP  

25. {     

26.     EA=1; //Resume interrupt  

27.     ISP_CONTR = 0x00;       

28.     ISP_CMD = 0x00;        

29.     ISP_TRIG = 0x00;                                               

30. }  

31.   

32. void ISP_IAP_trigger() //trigger   

33. {     

34.     EA=0; //The following two instructions must be executed continuously, so the interrupt is disabled             

35.     ISP_TRIG = 0x46; //Send trigger command word 0x46       

36.     ISP_TRIG = 0xB9; //Send trigger command word 0xB9       

37. }  

38.          

39.   

40. void ISP_IAP_readData(u16 beginAddr, u8* pBuf, u16 dataSize) //Read data  

41. {  

42.     ISP_DATA=0; //clear to zero, or not clear  

43.     ISP_CMD = read_cmd; //Command: read  

44.     ISP_CONTR = enable_waitTime; // Enable ISP_IAP and send the waiting time   

45.     while(dataSize--) //Loop reading  

46.     {  

47.         ISP_ADDRH = (u8)(beginAddr >> 8); //Send address high byte        

48.         ISP_ADDRL = (u8)(beginAddr & 0x00ff); //Send address low byte  

49.         ISP_IAP_trigger(); //Trigger  

50.         beginAddr++; //Address++  

51.         *pBuf++ = ISP_DATA; //Save data to the receiving buffer  

52.     }  

53.     ISP_IAP_disable(); //Disable ISP_IAP function  

54. }         

55.      

56. void ISP_IAP_writeData(u16 beginAddr,u8* pDat,u16 dataSize) //write data      

57. {             

58.     ISP_CONTR = enable_waitTime; // Enable ISP_IAP and send the waiting time         

59.     ISP_CMD = wirte_cmd; //Send byte programming command word  

60.     while(dataSize--)  

61.     {  

62.         ISP_ADDRH = (u8)(beginAddr >> 8); //Send address high byte         

63.         ISP_ADDRL = (u8)(beginAddr & 0x00ff); //Send address low byte             

64.         ISP_DATA = *pDat++; //Send data         

65.         beginAddr++;   

66.         ISP_IAP_trigger(); //Trigger  

67.     }            

68.     ISP_IAP_disable(); //Disable                                        

69. }      

70.           

71. void ISP_IAP_sectorErase(u16 sectorAddr) // sector erase  

72. {             

73.     ISP_CONTR = enable_waitTime; // Enable ISP_IAP; and send the waiting time         

74.     ISP_CMD = erase_cmd; //Send sector erase command word           

75.     ISP_ADDRH = (u8)(sectorAddr >> 8); //Send address high byte         

76.     ISP_ADDRL = (u8)(sectorAddr & 0X00FF); //Send address low byte             

77.     ISP_IAP_trigger(); //Trigger  

78.     ISP_IAP_disable(); //Disable ISP_IAP function           

79. }  

80.       

81. void main() //test  

82. {     

83.     u8 buf[3]={0}; //Receive data buffer  

84.     u8 dat[5]={b(111010),b(1001),b(1),b(1011),b(1110)}; //I wrote it in binary to observe the LED light     

85.     ISP_IAP_sectorErase(0x2000); // sector erase, one block of 512 bytes         

86.     ISP_IAP_writeData(0x21f0,dat,sizeof(dat)); //Write EEPROM             

87.     ISP_IAP_readData(0x21f0,buf,sizeof(buf)); //Read  

88.     P1=buf[2]; //Write 11010110 at address 0x21f0 for the first time, and 111010 for the second time. The result is the AND of these two values ​​10010  

89.     while(1); //So if the value at an address is not 0xff, it is wrong to write new data. You must first erase it to 0xff   

90. }  

C Code  

1. #ifndef _MY51_H  

2. #define _MY51_H  

3. #include   

4. //#include   

5. #include   

6. #include   

7. #include "mytype.h"  

8.   

9. /*************Binary Input Macro****************************/  

10. #ifndef _LongToBin_  

11. #define _LongToBin_  

12. #define LongToBin(n) \               

13. ( \   

14. ((n >> 21) & 0x80) | \   

15. ((n >> 18) & 0x40) | \   

16. ((n >> 15) & 0x20) | \   

17. ((n >> 12) & 0x10) | \   

18. ((n >> 9) & 0x08) | \   

19. ((n >> 6) & 0x04) | \   

20. ((n >> 3) & 0x02) | \   

21. ((n) & 0x01) \   

22. )  

23. #define bin(n) LongToBin(0x##n##l)  

24. #define BIN(n) bin(n)  

25. #define B(n) bin(n)  

26. #define b(n) bin(n)             

27. #endif  

28.   

29. /*************Setting macro for a single data bit*********************/  

30. #ifndef _BIT_  

31. #define _BIT_   

32. #define BIT(n) (1<

33. #define bit(n) BIT(n)  

34. #endif  

35.   

36. #define high 1 //High level  

37. #define low 0 //Low level  

38.   

39. #define led P1 //light bus control  

40.   

41. sbit led0=P1^0; //8 LED lights, the cathode sends a low level to light up  

42. sbit led1=P1^1;  

43. sbit led2=P1^2;  

44. sbit led3=P1^3;  

45. sbit led4=P1^4;  

46. sbit led5=P1^5;  

47. sbit led6=P1^6;  

48. sbit led7=P1^7;   

49. sbit ledLock=P2^5; //LED latch status, 0 for lock, 1 for unlock  

50.   

51. sbit beep=P2^3; //Buzzer  

52.   

53. void delayms(u16 ms);  

54. //void delayXus(u8 us); //The function executes (8+6x) machine cycles, i.e. t=(8+6x)*1.085  

55. ///////////////////////////////////////////////////// //////////////////////////////  

56.   

57.   

58. #endif