IAP The contents of the remote update series are as follows ：

  1. IAP Description of remote update mechanism

  2. Bootload and App Code implementation of inter jump

  3. STM32 Inside Flash Operation function of
 

1. Bootload Jump to App

  jump_to_app.c

#include "stm32f10x.h"
#include "jump_to_app.h"

/*  work   can :  Turn off global interrupt  */
void BoardDisableIrq(void)
{
    
    __disable_interrupt();
}

/*  work   can :  Enable global interrupt  */
void BoardEnableIrq(void)
{
    
    __enable_interrupt();
}

/*  Initialize stack pointer  */
void MSR_MSP(uint32_t addr) 
{
    
  __ASM("msr msp, r0");  // set Main Stack value  Save the main stack address to MSP register (R13) in 
  __ASM("bx lr");        //  Jump to lr At the address stored in .bx Is a forced jump instruction  lr Is the connection register , yes STM32 Single chip microcomputer R14
}

typedef void (*IapFun)(void); //  Declare a function pointer , Used to jump to the absolute address to execute the program 
IapFun JumpToApp; 

/*! *  work   can :  Jump to application  * param1:  User code start address  * retval:  No return value  */
void IapLoadApp(uint32_t AppAddr)
{
    
    /*  Applications APP Middle set handle   Interrupt vector table   Put in 0x08003000  Starting position ; The first place in the interrupt vector table is the value of the stack top address   in other words , This sentence is to judge whether the address value at the top of the stack is correct （ Whether in 0x2000 0000 - 0x 2000 2000 Between ）  To determine whether the application   It has been downloaded , Because the startup file of the application just begins to initialize the stack space , If the stack top value is right , Say that the application has downloaded the startup file , Initialization is also performed ; */
        
        
	  if( ((*(uint32_t*)AppAddr) & 0x2FFE0000) == 0x20000000 )//  Check if the top of stack address is legal , Check the memory section of the reference manual SRAM Section 
	  {
     
        BoardDisableIrq();  //  No interruptions 
		    JumpToApp = (IapFun)*(uint32_t*)(AppAddr+4);    //  The second word in the user code area is the program start address ( New program reset address ) 
		    MSR_MSP(*(uint32_t*)AppAddr);		                //  initialization APP Stack pointer ( The first word in the user code area is used to store the top address of the stack )
		                                 
        JumpToApp();	                                  //  Set up PC Pointer for bootload Reset the address of the interrupt function , To perform the 
	  }
}

2. App Jump to Bootload

  jumo_to_bootload.c

#include "stm32f10x.h"
#include "jump_to_boot.h"

#define INFLASH_ADDR_BOOTLOAD ((uint32_t)0x08000000) // bootload From 

/*  Initialize stack pointer  */
void MSR_MSP(uint32_t addr) 
{
    
  __ASM("msr msp, r0");  // set Main Stack value  Save the main stack address to MSP register (R13) in 
  __ASM("bx lr");        //  Jump to lr At the address stored in .bx Is a forced jump instruction  lr Is the connection register , yes STM32 Single chip microcomputer R14
}

typedef void (*IapFun)(void); //  Declare a function pointer , Used to jump to the absolute address to execute the program 
IapFun JumpToBootload; 

/*! *  work   can :  Jump to application  * param1:  User code start address  * retval:  No return value  */
void IapLoadBootload(void)
{
    
    /*  Applications APP Middle set handle   Interrupt vector table   Put in 0x08003000  Starting position ; The first place in the interrupt vector table is the value of the stack top address   in other words , This sentence is to judge whether the address value at the top of the stack is correct （ Whether in 0x2000 0000 - 0x 2000 2000 Between ）  To determine whether the application   It has been downloaded , Because the startup file of the application just begins to initialize the stack space , If the stack top value is right , Say that the application has downloaded the startup file , Initialization is also performed ; */
        
        
	  if( ((*(uint32_t*)INFLASH_ADDR_BOOTLOAD) & 0x2FFE0000) == 0x20000000 )//  Check if the top of stack address is legal , Check the memory section of the reference manual SRAM Section 
	  {
     
        BoardDisableIrq();   //  No interruptions 
		    JumpToBootload = (IapFun)*(uint32_t*)(INFLASH_ADDR_BOOTLOAD+4);        //  The second word in the user code area is the program start address ( New program reset address ) 
		    MSR_MSP(*(uint32_t*)INFLASH_ADDR_BOOTLOAD);		                //  initialization APP Stack pointer ( The first word in the user code area is used to store the top address of the stack )
		                                 
        JumpToBootload();	                                    //  Set up PC Pointer for bootload Reset the address of the interrupt function , To perform the 
	  }
}

3. App Set the offset of interrupt vector table in

   stay APP In the program ,main The function should first modify the starting address of the interrupt vector table , It can be modified by VTOR Vector table offset register to relocate vector table . Reference resources 《Cortex-M3 Authoritative guide 》7.3 Section “ The starting address of the vector table is required ： We must first find out how many vectors there are in the system , Then put this number up “ Roundness ” To 2 The whole power of , The starting address must be aligned to the boundary of the latter . for example , If there is 32 A break , Then there is 32+16（ System exception ）=48 Vector , Round up to 2 The value after the entire power of is 64, Therefore, the address of vector table relocation must be able to be 64*4=256 to be divisible by , Thus, the legal starting address can be ：0x0, 0x100, 0x200 etc. ”

  STM32F103 Series have 59 A break +16 A system exception , altogether 65 Vector , Round up to 2 The value after the entire power of is 128, The legal address is 0x0, 0x400, 0x800 … stay main Function can set the value of the register to reposition the vector table , The specific implementation is as follows , among FLASH_VTOR_OFFSET Need to be based on your own APP Modify the starting address of .

#define INFLASH_START_ADDR ((uint32_t)0x08000000) // STM32  Inside FLASH From 
#define INFLASH_VTOR_OFFSET ((uint32_t)0x00004000) // APP Offset address of vector table , And APP The starting address of is consistent 

int main()
{
    
    SCB->VTOR = INFLASH_START_ADDR | INFLASH_VTOR_OFFSET;     //  Set the starting address of the vector table 

	  /*  Other code  */
}