Xmega Application Note


eeprom_example.c

Go to the documentation of this file.
00001 /* This file has been prepared for Doxygen automatic documentation generation.*/
00052 #include "avr_compiler.h"
00053 #include "eeprom_driver.h"
00054 
00055 #define TEST_BYTE_1 0x55
00056 #define TEST_BYTE_2 0xAA
00057 
00058 #define TEST_BYTE_ADDR_1 0x00
00059 #define TEST_BYTE_ADDR_2 0x08
00060 
00061 #define TEST_PAGE_ADDR_1    0  /* Page address always on a page boundary. */
00062 #define TEST_PAGE_ADDR_2    2  /* Page address always on a page boundary. */
00063 #define TEST_PAGE_ADDR_3    5  /* Page address always on a page boundary. */
00064 
00066 uint8_t testBuffer[EEPROM_PAGESIZE] = {"Accessing Atmel AVR XMEGA EEPROM"};
00067 
00074 int main( void )
00075 {
00076         /* Assume OK from the start. Set to 0 on first error.*/
00077         bool test_ok = true;
00078 
00079         /* Flush buffer just to be sure when we start.*/
00080         EEPROM_FlushBuffer();
00081 
00082 
00083         /* ***
00084          * Write and read two bytes using IO-mapped access.
00085          * ***/
00086 
00087         EEPROM_DisableMapping();
00088 
00089         /* Write bytes. */
00090         EEPROM_WriteByte(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1, TEST_BYTE_1);
00091         EEPROM_WriteByte(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_2, TEST_BYTE_2);
00092 
00093         /* Read back and check bytes.*/
00094         if (EEPROM_ReadByte(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1) != TEST_BYTE_1) {
00095                 test_ok = false;
00096         }
00097 
00098         if (EEPROM_ReadByte(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_2) != TEST_BYTE_2) {
00099                 test_ok = false;
00100         }
00101 
00102         /* Now write the other way round.*/
00103         EEPROM_WriteByte(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1, TEST_BYTE_2);
00104         EEPROM_WriteByte(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_2, TEST_BYTE_1);
00105 
00106         /* Again, read back and check bytes. */
00107         if (EEPROM_ReadByte(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1) != TEST_BYTE_2) {
00108                 test_ok = false;
00109         }
00110 
00111         if (EEPROM_ReadByte(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_2) != TEST_BYTE_1) {
00112                 test_ok = false;
00113         }
00114 
00115         /* ***
00116          * Do a full page with split operations.
00117          * ***/
00118 
00119         /* Load, erase and write. */
00120         EEPROM_LoadPage(testBuffer);
00121         EEPROM_ErasePage(TEST_PAGE_ADDR_2);
00122         EEPROM_SplitWritePage(TEST_PAGE_ADDR_2);
00123 
00124         /* Read back and check. */
00125         for (uint8_t i = 0; i < EEPROM_PAGESIZE; ++i) {
00126                 if (EEPROM_ReadByte(TEST_PAGE_ADDR_2, i ) != testBuffer[i] ) {
00127                         test_ok = false;
00128                         break;
00129                 }
00130         }
00131 
00132         /* ***
00133          * Now write and read two bytes using memory mapped access.
00134          * ***/
00135 
00136         EEPROM_EnableMapping();
00137 
00138         /* Write bytes.*/
00139         EEPROM_WaitForNVM();
00140         EEPROM(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1) = TEST_BYTE_1;
00141         EEPROM_AtomicWritePage(TEST_PAGE_ADDR_1);
00142         EEPROM_WaitForNVM();
00143         EEPROM(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_2) = TEST_BYTE_2;
00144         EEPROM_AtomicWritePage(TEST_PAGE_ADDR_1);
00145 
00146         /* Read back and check. */
00147         EEPROM_WaitForNVM();
00148         if (EEPROM(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1) != TEST_BYTE_1) {
00149                 test_ok = false;
00150         }
00151         if (EEPROM(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_2) != TEST_BYTE_2) {
00152                 test_ok = false;
00153         }
00154 
00155 
00156         /* ***
00157          * Test the other way round with memory mapped access too.
00158          * ***/
00159 
00160         /* Write bytes. */
00161         EEPROM_WaitForNVM();
00162         EEPROM(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1) = TEST_BYTE_2;
00163         EEPROM_AtomicWritePage(TEST_PAGE_ADDR_1);
00164         EEPROM_WaitForNVM();
00165         EEPROM(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_2) = TEST_BYTE_1;
00166         EEPROM_AtomicWritePage(TEST_PAGE_ADDR_1);
00167 
00168         /* Read back and check. */
00169         EEPROM_WaitForNVM();
00170         if (EEPROM(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1) != TEST_BYTE_2) {
00171                 test_ok = false;
00172         }
00173 
00174         if (EEPROM(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_2) != TEST_BYTE_1) {
00175                 test_ok = false;
00176         }
00177 
00178         /* ***
00179          * Do a full page write with split operations and memory mapped access.
00180          * ***/
00181 
00182         /* Load buffer, erase and write. */
00183         EEPROM_WaitForNVM();
00184         for (uint8_t i = 0; i < EEPROM_PAGESIZE; ++i) {
00185                 EEPROM(TEST_PAGE_ADDR_3, i) = testBuffer[i];
00186         }
00187 
00188         /*  Erase bytes in eeprom page corresponding to page buffer. The page
00189          *  buffer will not be flushed.
00190          */
00191         EEPROM_ErasePage(TEST_PAGE_ADDR_3);
00192 
00193         /*  Split write page buffer to eeprom page. Buffer will be flushed after
00194          *  write operation.
00195          */
00196         EEPROM_SplitWritePage(TEST_PAGE_ADDR_3);
00197 
00198         /* Read back and check. */
00199         EEPROM_WaitForNVM();
00200         for (uint8_t i = 0; i < EEPROM_PAGESIZE; ++i) {
00201                 if (EEPROM(TEST_PAGE_ADDR_3, i) != testBuffer[i] ) {
00202                         test_ok = false;
00203                         break;
00204                 }
00205         }
00206 
00207         /* ***
00208          * Now, check if everything went well.
00209          * ***/
00210         if (true == test_ok) {
00211                 while(1) {
00212                         /* Success. */
00213                         nop();
00214                 }
00215         } else {
00216                 while(1) {
00217                         /* Failure. */
00218                         nop();
00219                 }
00220         }
00221 }
@DOC_TITLE@
Generated on Wed Apr 23 08:27:37 2008 for AVR1315 Accessing the XMEGA EEPROM by doxygen 1.5.5