[27] STM32F4 - Emulacja pamięci EEPROM, biblioteki STD

Ten post chciałbym poświęcić na przygotowanie programu umożliwiającego wykonanie emulacji pamięci EEPROM.

Informacje odnoście metody jaką należy zastosować można znaleźć w nocie aplikacyjnej AN3969.

[Źródłó: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

Opis:

Do zapisu danych dostępne są dwa bloki o numerach 2 i 3, każdy o wielkości 16kByte. Pozwala to na uzyskanie pamięci w której można przechowywać ustawienia konfiguracyjne itp. 

Adresy startowe bloków to odpowiednio 0x08008000 oraz 0x800C0000. Rozmiar sektora wynosi 0x4000.

Zapis danych musi być poprzedzony ich wyczyszczeniem.

Program:

Do przygotowania poniższych kodów wykorzystałem przykłady od firmy ST.

Funkcja inicjalizująca całą pamięć, oraz sprawdzająca poprawność jej uruchomienia:

1. uint8_t Internal_FLASH_Init(void)
2. {
3.   uint16_t PageStatus0;
4.   uint16_t PageStatus1;
5.   uint16_t indexLoop;
6.   int16_t x = -1;
7.   int32_t read_value;
8.   uint16_t dat;
10.     /* Unlocks the FLASH control register access */
11.   FLASH_Unlock();
13.     /* Write page adress */
14.   PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);
15.   PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS);
17.     /* Check status */
18.     if(PageStatus0 == MEMORY_ERASED)
19.     {
20.         if (PageStatus1 == MEMORY_VALID_PAGE)
21.         {  
22. 
    

    
    

     /* First sector to erase, set voltage level */

23.             if(FLASH_EraseSector(PAGE0_ID,(uint8_t)VoltageRange_3) != FLASH_COMPLETE) {
24.                 return 0; /* Error */
25.             }
26.     }
27.         else if (PageStatus1 == MEMORY_RECEIVE_DATA)
28.         {
29.             if(FLASH_EraseSector(PAGE0_ID, (uint8_t)VoltageRange_3) != FLASH_COMPLETE){
30.                 return 0; /* Error */
31.             }
32.             if(FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, MEMORY_VALID_PAGE) != FLASH_COMPLETE){
33.                 return 0; /* Error */
34.             }
35.     }
36.     else
37.         {
38.             if (Internal_Flash_Format() != FLASH_COMPLETE) {
39.                 return 0; /* Error */
40.             }
41.     }
42.     }
43.     else if(PageStatus0 == MEMORY_RECEIVE_DATA)
44.     {
45.         if (PageStatus1 == MEMORY_VALID_PAGE)
46.         {
47.             x=-1;
48.             for (indexLoop = 0; indexLoop < FLASH_MAX_ADDRESS; indexLoop++)
49.       {
50.                 if (( *(__IO uint16_t*)(PAGE0_BASE_ADDRESS + 6)) == indexLoop) { x = indexLoop; }
51.         if (indexLoop != x)
52.                 {
53.                     read_value = Internal_FLASH_Read(indexLoop);
54.                     if (read_value >= 0)
55.                     {
56.                         dat=(uint16_t)(read_value);
57.                        
58.                         if (Internal_Flash_VerifyPage(indexLoop, dat) != FLASH_COMPLETE) {
59.                             return 0; /* Error */
60.                         }
61.           }
62.         }
63.       }
64.                        
65.             if(FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, MEMORY_VALID_PAGE) != FLASH_COMPLETE) {
66.                     return 0; /* Error */
67.             }
68.            
69.             if(FLASH_EraseSector(PAGE1_ID, (uint8_t)VoltageRange_3) != FLASH_COMPLETE) {
70.                     return 0; /* Error */
71.             }
72.     }
73.         else if (PageStatus1 == MEMORY_ERASED)
74.         {
75.             if(FLASH_EraseSector(PAGE1_ID, (uint8_t)VoltageRange_3) != FLASH_COMPLETE) {
76.                     return 0; /* Error */
77.             }
78.             if(FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, MEMORY_VALID_PAGE) != FLASH_COMPLETE) {
79.                     return 0; /* Error */
80.             }  
81.     }
82.         else
83.         {
84.             if(Internal_Flash_Format() != FLASH_COMPLETE) {
85.                     return 0; /* Error */
86.             }  
87.     }
88.     }
89.     else if(PageStatus0 == MEMORY_VALID_PAGE)
90.     {
91.         if (PageStatus1 == MEMORY_VALID_PAGE)
92.         {
93.             if(Internal_Flash_Format() != FLASH_COMPLETE) {
94.                     return 0; /* Error */
95.             }  
96.     }
97.         else if (PageStatus1 == MEMORY_ERASED)
98.         {
99.             if(FLASH_EraseSector(PAGE1_ID, (uint8_t)VoltageRange_3) != FLASH_COMPLETE) {
100.                     return 0; /* Error */
101.             }  
102.     }
103.     else
104.         {
105.             x=-1;
106.             for (indexLoop = 0; indexLoop < FLASH_MAX_ADDRESS; indexLoop++)
107.             {
108.                 if ((*(__IO uint16_t*)(PAGE1_BASE_ADDRESS + 6)) == indexLoop)
109.                 {
110.                     x = indexLoop;
111.         }
112.                 if (indexLoop != x)
113.                 {
114.                     read_value = Internal_FLASH_Read(indexLoop);
115.                     if (read_value >= 0)
116.                     {
117.                         dat=(uint16_t)(read_value);
118.                        
119.                         if(Internal_Flash_VerifyPage(indexLoop, dat) != FLASH_COMPLETE) {
120.                             return 0; /* Error */
121.                         }  
122.           }
123.         }
124.       }
125.             if(FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, MEMORY_VALID_PAGE)!= FLASH_COMPLETE) {
126.                 return 0; /* Error */
127.             }  
128.             if(FLASH_EraseSector(PAGE0_ID, (uint8_t)VoltageRange_3)!= FLASH_COMPLETE) {
129.                 return 0; /* Error */
130.             }  
131.         }
132.     }
133.     else
134.     {          
135.         if(Internal_Flash_Format()!= FLASH_COMPLETE) {
136.                 return 0; /* Error */
137.         }
138.     }
139.    
140.   return 1;
141. }

Odczyt z pamięci Flash.

1. uint16_t Internal_FLASH_Read(uint16_t readAddress)
2. {
3.   uint16_t return_value=0;
4.   uint16_t value = 0;
5.   uint16_t checkPage = 0;
6.   uint16_t AddressValue = 0;
7.   uint32_t Address = 0;
8.   uint32_t PageStartAddress = 0;
10.   if(readAddress>=FLASH_MAX_ADDRESS){ return 0; /* Error*/ }
12.   checkPage=Internal_Flash_CheckValidPage(READ_FROM_PAGE);
14.   if(checkPage==MEMORY_PAGE0)
15.   {
16.     PageStartAddress = (uint32_t)PAGE0_BASE_ADDRESS;
17.     Address = (uint32_t)(PAGE0_END_ADDRESS-1);
18.   }
19.   else if(checkPage==MEMORY_PAGE1)
20.   {
21.     PageStartAddress = (uint32_t)PAGE1_BASE_ADDRESS;
22.     Address = (uint32_t)(PAGE1_END_ADDRESS-1);
23.   }
24.   else
25.   {
26.     return  0; /* Error*/
27.   }    
29.   while (Address > (PageStartAddress + 2))
30.   {
31.     AddressValue = (*(volatile uint16_t*)Address);
33.     if (AddressValue == readAddress)
34.     {
35.       value = (*(volatile uint16_t*)(Address - 2));
36.       return_value=0;
37.       break;
38.     }
39.     else
40.     {
41.       Address = Address - 4;
42.     }
43.   }
45.   if(return_value==0) {
46.         return (uint16_t)value;
47.   }
48.    
49.   return return_value;
50. }

Zapis danych do pamięci:

1. uint8_t Internal_FLASH_Write(uint16_t Address, uint16_t Data)
2. {
3.   uint16_t Status = MEMORY_NO_ERROR;
4.    
5.   if(Address>=FLASH_MAX_ADDRESS) { return 1; }
6.    
7.   if(Internal_Flash_VerifyPage(Address, Data) == MEMORY_PAGE_FULL) {
8.           if(Internal_Flash_TranferPage(Address, Data) != FLASH_COMPLETE) {
9.                 return 2;
10.             }
11.     }
12.    
13.   return 0;
14. }

Pozostałe funkcje są funkcjami statycznymi. Zostały one zdefiniowane bezpośrednio w bibliotece.

Cały kod można pobrać z dysku Google pod tym linkiem.