How to use SPM to load applications from EEPROM – (Part 34/46)

The BLS section is typically used to store the microcontroller bootloader code. Boot-Loader code can be used to initialize the peripherals on the microcontroller, initialize the devices connected to the microcontroller, select the application to load and run from a storage medium, load the selected application to the applications section, jump to the applications section and run the application. Code running in the BLS section can be executed in Self-Programming Mode (SPM) modes that are blocked for code running in the Application section. Using SPM instructions, the BLS code can rewrite the code in the application section or the code in the BLS itself.

Fig. 2: Block diagram of the SPM function with BLS on the AVR

The task of writing BLS code with SPM has been simplified by the APIs available in the header file . Following are the important APIs available in the header file that help in SPM.

Figure 3: Important APIs for the AVR SPM function

Using the above APIs, one can write code for SPM on an AVR microcontroller, as long as the code follows certain steps in order.

· Step: 1 Delete the flash page you are about to write

{W · Step:2 Store binaries in a temporary buffer before writing to a flash page

{W} · Step:3 Program the temporary buffer filled into the already erased flash page

The above three steps are explained in detail in a previous project article on AVR SPM. In this particular project, the data required to fill the temporary page buffer, as discussed in step: 2, is taken from the AVR microcontroller's integrated EEPROM, where a simple code has already been entered. The internal EEPROM of the AVR microcontroller has a capacity of 512 bytes. It can be easily read and written with the help of APIs available in the header file . Following are the important APIs available in the header file that help in accessing the EEPROM memory.

Figure 4: APIs for accessing EEPROM memory

The data to fill the temporary buffer as discussed in step: 2 is read from the AVR microcontroller's onboard EEPROM memory using the library function;

uint8_t eeprom_read_byte (const uint8_t *p)

The above function can return the data byte that is stored in the EEPROM address referred to by the pointer argument. The code is written so that the pointer first points to ^the 0th location of the EEPROM and then increments the address as it reads each byte for storage in the temporary buffer. Thus, the steps with which the binary code is read from the EEPROM memory and flashed in the flash memory are represented pictorially below;

Step: 1 Delete the flash page you are about to write

The first step is to erase the flash page that is about to be written with the new values. The API that helps in executing this step is;

Boot_page_erase (address)

This API can delete an entire page in flash that the parameter addresses. In the code, the address of the erased page is 256. The following image shows the status of the temporary page buffer and flash memory in step 1. The temporary page buffer is a buffer in which an entire page can be stored before it is flashed on a page in flash memory.

Fig. 5: PageErase block diagram in the SPM function

Step:2 Store the values ​​in a temporary buffer before writing to a flash page

This is the second step in which you must store the required binary in a temporary buffer before writing to any flash memory page. The API that can be used for this purpose is;

boot_page_fill (address, data)

This API fills the Boot-Loader's temporary page buffer byte by byte before updating the data in the temporary page buffer into a page as such. The parameter data represents each byte in the buffer and the parameter address represents the page address + offset of the buffer location where the data byte needs to be stored. The parameter data in the boot_page_fill API (address, data) is actually read from the first EEPROM memory location with the help of an API that is available in the header file .

uint8_t eeprom_read_byte (const uint8_t *p)

Fig. 6: Block diagram loading temporary buffer for AVR SPM

Step:3 Program the temporary buffer filled into the already erased flash page

This is the final step in which the filled temporary buffer is updated using an API on the already erased page from flash memory. The API that helps in this step is;

boot_page_write (address)

Fig. 7: Page write block diagram in flash memory

The code in this project that was written for BLS can copy 300 bytes from EEPROM memory to the temporary buffer starting at address 0x00. These bytes are then transferred to the flash memory page starting at address 0x0000. After doing this, the BLS code will jump to address 0x0000 so that the rewritten binary can be executed next. With this boot loader code, any program updated in the EEPROM will be rewritten into the Flash section of the AVR application and run. A simple blinking LED test application can be written to the EEPROM memory starting to test operation.b Update first the BLS code and then the LED application code to the EEPROM memory using the steps explained in the previous project on BLS blinking LED from AVR . When the LED flashes, it means that the code has been loaded from a section of EEPROM memory to flash memory and is running. With this, the code in the BLS can load any application that is programmed in the EEPROM on reboot and therefore acts as a Boot-Load

Fig. 8: LED blinking using the SPM function of the AVR circuit on the breadboard

Project source code

 ###


 #define F_CPU 8000000