Electrical – bootloader jump to application address problem

armbootloadercortex-m3keilstm32

I have written a bootloader for my board, but it generates a hard fault when it jumps to the application code.

My error is like this question:

Bootloader jump to main application problem using STM32 with Keil Uvision

microcontroller: stm32f103zet
software: keil
BOOT pins: BOOT1 and BOOT2 are 0 (FLASH boot mode)
FLASH_WRITE_ADDRESS: 0x8030000

I did this steps:
in application code:

I changed ROM address to 0x8030000.
I changed VECT_TAB_OFFSET to 0x30000
I used of fromelf for creating .bin file

then I wrote a simple code (blinky)

in bootloader code:
i receive .bin file with USART and then i write it to address 0x8030000 of FLASH
and The following code:

USART_DeInit(USART1);
RCC_DeInit();

__set_CONTROL(ENABLE_PRIVILEGE_MODE);

NVIC->ICER[ 0 ] = 0xFFFFFFFF ;
NVIC->ICER[ 1 ] = 0xFFFFFFFF ;
NVIC->ICER[ 2 ] = 0xFFFFFFFF ;

NVIC->ICPR[ 0 ] = 0xFFFFFFFF ;
NVIC->ICPR[ 1 ] = 0xFFFFFFFF ;
NVIC->ICPR[ 2 ] = 0xFFFFFFFF ;

SysTick->CTRL = 0 ;
SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk ;

SCB->SHCSR &= ~( SCB_SHCSR_USGFAULTENA_Msk |
                                SCB_SHCSR_BUSFAULTENA_Msk | 
                                SCB_SHCSR_MEMFAULTENA_Msk );

__disable_irq();

if( CONTROL_SPSEL_Msk & __get_CONTROL( ) )
{  /* MSP is not active */
    __set_MSP( __get_PSP( ) ) ;
    __set_CONTROL( __get_CONTROL( ) & ~CONTROL_SPSEL_Msk ) ;
}

JumpAddress=(FLASH_WRITE_ADDRESS+4);
JumpToApplication =(void(*)(void))(*((uint32_t*)JumpAddress));
__set_MSP(*(__IO uint32_t*)FLASH_WRITE_ADDRESS);
JumpToApplication();

But it goes to hardfault.
So now I use this part of the code:

/* Jump to user application */
JumpAddress = *(volatile uint32_t*)(FLASH_WRITE_ADDRESS+4);
JumpToApplication = (pFunction) JumpAddress;
__set_MSP((*(volatile uint32_t*) FLASH_WRITE_ADDRESS));
now_pointer=__get_MSP();
JumpToApplication();

but it is the same as before.
What is problem?

This is one second before jump to application code:

And this is result of jump to application code:

okey.now,i find and solve problem:
i put my writing in FLASH mistake picture:

Best Answer

Most likely you use the standard start-up code from the STM in the user application. Is sets VTOR to the begining of the FLASH memory. Remove this line and it should work

Related Solutions

Electronic – Bootloader jump to main application problem using STM32 with Keil Uvision

I had the same problem: I solved it with commented this lines:

__disable_irq();
__set_MSP(*(__IO uint32_t*) APPLICATION_ADDRESS);

Some advice for anyone writing a bootloader for first time:

Turn your code into small sections:

In the first write a simple blinky code without any interrupt.
use of sector erase ability and and write your put your bootloader and application code together in flash. Now you just,must try to jump from bootloader in application code. If it works, this means your jumping is correct.
Now try receive your application code with USART (or with any other peripheral) and write in flash. It must work, if not, it means write it flash is wrong (open hex code file and compare flash data,flash address and other thing with hex file) (attention to little_endian writing)
Now write a blinky code with timer and interrupt. It must work, if not, it mean is mistake is in jumping vector table

Electronic – bootloader application on arm controller

The way we do it in one of our products is like this (code is based on IAR compiler, so pragmas might differ for you):

We defined a structure which contains important information of the application part (which is called mainpart in our projects):

#pragma pack(push,1)
    struct softwareRevision_t {
        uint8_t VersionSystem;
        uint8_t VersionFunction;
        uint8_t VersionError;
        uint8_t VersionCustomer;
        uint8_t BuildNumber;
    };
#pragma pack(pop)

#pragma pack(push,1)
    struct mainInfoStruct_t {
        softwareRevision_t softwareRevision;
        uint32_t startFunctionAddress;
        uint8_t reserve[27];
        uint32_t bootControl;
    };
#pragma pack(pop)

This contains among other things the uint32_t startFunctionAddress. Now for this structure to be useful, you have to do several things:

Initialize it with meaningful values in the application
Make it const so it can be placed in flash
Tell the linker to place the structure always on the exact same location every time you compile your project
share the location and structure between application and boot part

In the application part:

To share the location, we created a header-file which is included in both parts with a simple define:

#define MAIN_INFO_MEMORY_POSITION (0x0807FFD4)

In a .cpp file of our application we create an instance of the structure which is placed accordingly:

#pragma location = MAIN_INFO_MEMORY_POSITION
extern __root const mainInfoStruct_t mainInfoStruct =
{
    {
            1U,     // mainInfo.softwareRevision.VersionSystem
            0U,     // mainInfo.softwareRevision.VersionFunction
            0U,     // mainInfo.softwareRevision.VersionError
            0U,     // mainInfo.softwareRevision.VersionCustomer
            0U      // mainInfo.softwareRevision.BuildNumber
    },

    reinterpret_cast<uint32_t>((&_start)),  // mainInfo.startFunctionAddress
    {0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U},     // reserve

    0xF0F0FFFFU     // mainInfo.bootControl
};

Several things happen here: #pragma location = MAIN_INFO_MEMORY_POSITION tells the linker where to place the next structure.

The __root tells our linker that this symbol must be kept, even if it is not referenced by the application code (which it isn't). It has to be const otherwise it would not get placed in flash (if it doesn't end up in flash try adding a static).

So with this we have done everything in the application.

In the boot part:

The boot part needs access to the application part info structure. We wrapped a class around this whole thing, but basically a pointer will be enough:

volatile mainInfoStruct_t* pMainInfo = reinterpret_cast<mainInfoStruct_t*>(MAIN_INFO_MEMORY_POSITION);

We use volatile here to make sure, that the compiler will not optimize the access to the flash away. With this you can now jump into the application code with an ugly cast:

(reinterpret_cast<void (*)(void)>(pMainInfo->startFunctionAddress))();

Notes:

In our application we do a CRC check over the whole application part which includes the mainInfoStruct, so we don't jump into nirvana is something went wrong with the update.

The first thing we do in our application is to set the stackpointer to the value it is expected to start with (you can get that from the linker configuration file or your interrupt vector table). Otherwise you might end up with a stack overflow and corrupting your other data.

This is not a minimal example, but might give some hint on what might be useful in a shared structure as well.

We use C++, sorry for the reinterpret_casts.

Best Answer

Related Solutions

Electronic – Bootloader jump to main application problem using STM32 with Keil Uvision

Electronic – bootloader application on arm controller

Related Topic