Iap, the full name is in applacation programming, that is, in application programming, corresponding to it is called isp, in system programming, in system programming, the difference between the two is that isp needs to rely on the programmer to program when the microcontroller resets offline. Manual intervention is required, and IAP is a program written by the user's own program during the running process. The purpose is to facilitate the firmware program in the product through the reserved communication port after the product is released. Update the upgrade. In engineering applications, our products are often installed in a specific mechanical structure. It is very inconvenient to disassemble the program when updating the program. The use of iap technology can reduce the workload.
There are two important prerequisites for implementing IAP. First, the MCU program can erase its internal flash. Second, the MCU must have a way to communicate with the outside, whether it is a network or another way, as long as it can transmit data. On the line
Usually when implementing the IAP function, that is, the user program is running its own update operation, you need to write two project codes when designing the firmware program. The first project program does not perform normal function operations, but only through some communication method (such as USB, USART) receives the program or data, and performs the update of the second part of the code; the second item code is the real function code. Both parts of the project code are burned in User Flash at the same time. When the chip is powered on, the first project code starts running first. It does the following:
1) Check if the second part of the code needs to be updated 2) If there is no need to update, go to 4) 3) Perform the update operation 4) Jump to the second part of the code execution
The first part of the code must be burned in by other means, such as JTAG or ISP; the second part of the code can call the function of the first part
In other words, Iap and app into two programs, this is one of the strategies, there is a strategy, you can put the IAP program and app in a code, but the coupling is a bit high, we first The first attempt.
To do iap, we must first know the startup process of stm32, the process is as follows
1. The MCU starts from 0x80000000 and treats the address as the top address of the system stack.
2, run to the interrupt vector table, the default interrupt vector table is 0x80000004, this location stores the reset interrupt
3, jump to the reset interrupt handler, perform system initialization, and then run the main function
When we are ready to use IAP, there are two sets of programs inside the microcontroller. At this time we need to be in the IAP.
Two sets of interrupt vector tables are placed in the app and the app. After the app is burned into the flash in the iap code, it jumps to the app's interrupt vector table, and the program can be executed normally. Of course, some system settings need to be modified. There is only one set of interrupt vector tables visible in the app and iap stage. (Please check the startup code of the stm32 chip for details.)
When you need to jump from the app to the IAP, you only need to change the app's interrupt vector table to the IAP interrupt vector table, and actively jump to the IAP reset interrupt handler, so that you can start the IAP process again.
In this way, we need to determine a few things in the system, the first is the interrupt vector table of the IAP program, which is 0x80000004 (80000000 stores the initial value of msp), and the second is the interrupt vector table of the app program. The location needs to be calculated according to the length of the IAP program. For example, iap occupies 64K, then 512K chip, there is 448K space to store the app program, 448K initially puts the interrupt vector table, the position should be 0x08000000+0x10004 .
The Cortex-m3 interrupt vector is not fixed in the program. We can modify the interrupt vector table position for the current application by modifying some registers.
The register that determines the interrupt vector table is as follows
By modifying the value of this register, we can control the position of the vector table visible to the current microcontroller application (that is, logically we have two vector tables, but only one at the same time)
The above is the operation of the kernel phase. In addition, we need to program the flash of stm32, then it involves the program and erase operations of the deletion. This requires reference to the flash programming manual of stm32.
First, when the MCU is reset, the flash memory is locked, and it needs to be actively unlocked. Write two specified consecutive key values ​​to FLASH_KEYR for unlocking.
Then erase the flash that needs to be written, write after the erase, write complete, lock again
The corresponding code is as follows
U16 STMFLASH_BUF[STM_SECTOR_SIZE/2];//Up to 2K bytes
Void STMFLASH_Write(u32 WriteAddr, u16 *pBuffer, u16 NumToWrite)
{
U32 secpos; //sector address
U16 secoff; //Intra-sector offset address (16-bit word calculation)
U16 secremain; //Remaining address in the sector (16-bit word calculation)
U16 i;
U32 offaddr; // remove the address after 0X08000000
If(WriteAddr
FLASH_Unlock(); //Unlock
Offaddr=WriteAddr-STM32_FLASH_BASE; //The actual offset address.
Secpos=offaddr/STM_SECTOR_SIZE; //sector address 0~127 for STM32F103RBT6
Secoff=(offaddr%STM_SECTOR_SIZE)/2; //Offset within the sector (2 bytes is the base unit.)
Secremain=STM_SECTOR_SIZE/2-secoff; // sector remaining space size
If(NumToWrite<=secremain)secremain=NumToWrite;//not greater than the sector range
While(1)
{
STMFLASH_Read (secpos * STM_SECTOR_SIZE + STM32_FLASH_BASE, STMFLASH_BUF, STM_SECTOR_SIZE / 2); / / read the contents of the entire sector
For(i=0;i { If(STMFLASH_BUF[secoff+i]!=0XFFFF) break;//requires erasure } If(i { FLASH_ErasePage (secpos * STM_SECTOR_SIZE + STM32_FLASH_BASE); / / erase this sector For(i=0;i { STMFLASH_BUF[i+secoff]=pBuffer[i]; } STMFLASH_Write_NoCheck (secpos * STM_SECTOR_SIZE + STM32_FLASH_BASE, STMFLASH_BUF, STM_SECTOR_SIZE / 2); / / write the entire sector }else STMFLASH_Write_NoCheck (WriteAddr, pBuffer, secremain); / / write has been erased, directly write to the remaining sector of the sector. If(NumToWrite==secremain)break;//Write ends Else / / write is not over { Secpos++; // Sector address increased by 1 Secoff=0; //offset position is 0 pBuffer+=secremain; //Pointer offset WriteAddr+=secremain; //Write address offset NumToWrite-=secremain; //byte (16-bit) number is decremented If(NumToWrite>(STM_SECTOR_SIZE/2))secremain=STM_SECTOR_SIZE/2;//The next sector is still incomplete Else secremain=NumToWrite;//The next sector can be written } }; FLASH_Lock();//locked This function can implement flash write operation, then we need to define a set of communication protocol for serial data transmission. // serial port receive buffer U8 serial_Buffer[SERIAL_MAX_LENGTH] = {0}; / / Serial port receiving data length U16 serial_Buffer_Length = 0; U8 receiveMode = 0; / / Receive parameter interrupt processing model, when it is 0 is the command mode, when it is 1 is the download mode U8 receiveExpectCount = 0; / / serial port expected reception length / / Serial port interrupt processing Static void SerialRecv(u8 ch) { If(receiveMode == 0) { If((serial_Buffer_Length&0x8000) == 0x8000) / / has been received, the system has not processed { serial_Buffer_Length |= 0x8000;//Exit } Else if((serial_Buffer_Length&0x4000) == 0x4000)//Received carriage return has not received a newline { If(ch == '')serial_Buffer_Length |= 0x8000; Else { //One frame accepts failure serial_Buffer_Length = 0; } } Else { If((serial_Buffer_Length&0xff) < SERIAL_MAX_LENGTH) { If(ch == '')serial_Buffer_Length |= 0x4000; Else { serial_Buffer[(serial_Buffer_Length&0xff)] = ch; serial_Buffer_Length++; } } Else { //One frame accepts failure serial_Buffer_Length = 0; } } } Else { / / Download mode, only control the amount of the string, the first bit of the data is the length of the packet, received so many lengths, the receiving completion location / / Note that in this mode, the value of receiveExpectCount should be cleared before clearing serial_Buffer_Length If(receiveExpectCount == 0)//The download is expected to be 0, the first number is the expected number of downloads { receiveExpectCount = ch; } Else { If((serial_Buffer_Length&0x8000) == 0x8000) / / has been received, the system has not processed, do not receive data at this time { serial_Buffer_Length |= 0x8000;//Exit } Else { serial_Buffer[(serial_Buffer_Length&0xff)] = ch;//Receive data and save serial_Buffer_Length++; If((serial_Buffer_Length&0xff) == receiveExpectCount) / / received the expected length of data { serial_Buffer_Length |= 0x8000;//One packet receiving completion flag } } } } } So that the system can receive the data, then define five commands "iap_down" "iap_jump_app" "iap_over" "iap_set_flag" "iap_clear_flag" The first command starts the download for the system. After this command, the host computer can send the program data down. The second command is a jump instruction for iap to jump to the app. The third command is an instruction that instructs iap to complete and clear the system buffer. The fourth instruction is to set the app flag. When iap detects the flag, it jumps directly to the app. The fifth command is to clear the app flag, so that the iap program does not automatically jump to the app, we look at it separately. The first is iap_set_flag, and its response function is as follows #define APP_CONFIG_ADDR 0X08001FFC //Configure the address #define APP_CONFIG_SET_VALUE 0X5555 //Set the value #define APP_CONFIG_CLEAR_VALUE 0XFFFF //Clear the value / / Set the app curing configuration Void iap_set_flag_s(void) { Test_Write(APP_CONFIG_ADDR, APP_CONFIG_SET_VALUE); Printf("ok"); } We use 0x08000000-0x08003000 to store the iap code, and use 0X08001FFC as the place to store the app curing mark. / / Clear the app curing configuration Void iap_clear_flag(void) { Test_Write(APP_CONFIG_ADDR, APP_CONFIG_CLEAR_VALUE); Printf("ok"); } The response to the iap_jump2app command is as follows / / Jump to the application section //appxaddr: User code start address. Void iap_load_app(u32 appxaddr) { If((*(vu32*)appxaddr)&0x2FFE0000)==0x20000000) //Check if the top address of the stack is legal. 0x20000000 is the starting address of sram and the top address of the program. { Printf("ok"); Delay_Ms(10); Jump2app=(iapfun)*(vu32*)(appxaddr+4); //The second word in the user code area is the program start address (reset address) MSR_MSP(*(vu32*)appxaddr); //Initialize the APP stack pointer (the first word in the user code area is used to store the top address of the stack) Jump2app(); // Jump to APP. } Else { Printf("program in flash is error"); } } / / Jump to the app area to run Void iap_jump_app_s(void) { Iap_load_app(FLASH_APP1_ADDR); / / jump to the app's reset vector address } Next is iap_down, the core algorithm for downloading #define FLASH_APP1_ADDR 0x08002000 //The first application start address (stored in FLASH) / / Reserved space for IAP use U16 iapbuf[1024] = {0}; //Array for caching data U16 receiveDataCur = 0; //The length of the data that has been filled in the current iapbuffer, write to flash and clear after one fill is full U32 addrCur = FLASH_APP1_ADDR; //current system write address, address increased by 2048 after each write //start download Void iap_down_s(void) { U16 i = 0; U16 temp = 0; U16 receiveCount; Printf("begin,wait data download"); receiveMode = 1; / / serial port enters the download and receive data mode While(1) { / / cyclically receive data, each time must send 128 data down, if there is no 128, this is the last packet of data / / After receiving a packet of data, return a decimal point, send completed, return to an iap_over after system programming is completed If(serial_Buffer_Length & 0x8000) { receiveCount = (u8)(serial_Buffer_Length&0x00ff); If (receiveCount == 128) / / meet a package, fill and see if there is 1024 bytes, with write to flash { For(i = 0; i < receiveCount; i+=2) { / / Data eight bits merge into 16 bits Temp = (((u16)serial_Buffer[i+1])<<8) + ((u16)serial_Buffer[i]); Iapbuf[receiveDataCur] = temp; receiveDataCur++; / / receiveDataCur++ after completion; } receiveExpectCount = 0; / / clear the desired receive mode serial_Buffer_Length = 0; / / clear the serial port full flag Printf(".");//After accepting data once, make a point / / At this time need to detect the value of receiveDataCur, if it is full, you need to write If(receiveDataCur == 1024) { / / Write to flash STMFLASH_Write(addrCur, iapbuf, 1024); //printf("write addr %x,length 1024",addrCur); addrCur += 2048; / / address + 2048 / / After the completion of the reportDataCur to clear the next transmission receiveDataCur = 0; } Else // It is possible that the last packet has 128 data but eventually there is no 2048 data. At this point, an instruction is extended to complete the last write. { } //Not yet full, waiting for the next data coming over } Else / / does not satisfy a package, indicating data transfer, this is the last package, write to flash { / / No package is also transferred to the cache For(i = 0; i < receiveCount; i+=2) { / / Data eight bits merge into 16 bits Temp = (((u16)serial_Buffer[i+1])<<8) + ((u16)serial_Buffer[i]); Iapbuf[receiveDataCur] = temp; receiveDataCur++; / / receiveDataCur++ after completion; } receiveExpectCount = 0; / / clear the desired receive mode serial_Buffer_Length = 0; / / clear the serial port full flag Printf(".");//After accepting data once, make a point / / After that, this data will be written to the flash memory STMFLASH_Write (addrCur, iapbuf, receiveDataCur); / / write the last content bytes into. //printf("write addr %x,length %d",addrCur,receiveDataCur); //Restore the address to its original location after writing addrCur = FLASH_APP1_ADDR; receiveDataCur = 0; / / After writing, you must exit the download loop and tell the host computer that it has been downloaded. Printf("download over"); //At the same time, also exit the download loop mode receiveMode = 0; Return; } The core idea of ​​this code is that the upper computer sends 128 data each time, and it fills 2048 write flashes. When the last packet data is not 128, the data transmission is completed. At this time, the download mode is exited, but when What to do when the last packet of data is 128, so I defined this command. Iap_over, the upper computer detects that the last packet of data is also 128 when the command is sent, the lower computer will write and exit the cache. //The last package has 128 data but eventually there are no 2048 data. / / Receive this command to detect the value of receiveDataCur and addrCur, / / Complete the last write Void iap_over_s(void) { / / This time, still in the serial download mode If(receiveDataCur != 0) { STMFLASH_Write (addrCur, iapbuf, receiveDataCur); / / write the last content bytes into. //printf("write addr %x,length %d",addrCur,receiveDataCur); addrCur = FLASH_APP1_ADDR; receiveDataCur = 0; //At the same time, also exit the download mode receiveMode = 0; } Printf("ok"); } This is the core code of iap. Next we check the app firmware flag in the main function. If the flag is set, then jump to the app. If(STMFLASH_ReadHalfWord(APP_CONFIG_ADDR) == 0x5555) { / / Jump directly to the APP Iap_jump_app_s(); } Basically I have completed the work of IAP, but think about it, we also need to set a place, we have to set the flash space used in the target, can not exceed the scope, as follows If you need flash download, you also need to set the jlink flash download settings as follows. This can directly use jlink to download the code to the microcontroller, and will not affect the original app program. Note that to select the erase sector used, you cannot erase the flash all. Bridge bucket, we forgot one thing, let's say we set the app logo, then the app can jump to the IAP, IAP will not immediately jump back to the app, can not wait to download? The solution is to remove the app firmware flag from the app that jumps to the iap in the app, and add an instruction to the app code. Iap, the response method is __asm ​​void MSR_MSP(u32 addr) { MSR MSP, r0 //set Main Stack value BX r14 } Void iap_jump(u32 iapxaddr) { If((*(vu32*)iapxaddr)&0x2FFE0000)==0x20000000) //Check if the top address of the stack is legal. 0x20000000 is the starting address of sram and the top address of the program. { Printf("ok"); Delay_Ms(10); Jump2iap=(iapfun)*(vu32*)(iapxaddr+4); //The second word in the user code area is the program start address (reset address) MSR_MSP(*(vu32*)iapxaddr); //Initialize the APP stack pointer (the first word in the user code area is used to store the top address of the stack) Jump2iap (); / / jump to APP. } Else { Printf("iap program loss,please check"); } } #define APP_CONFIG_ADDR 0X08001FFC //Configure the address #define APP_CONFIG_SET_VALUE 0X5555 //Set the value #define APP_CONFIG_CLEAR_VALUE 0XFFFF //Clear the value Void iap_Func(void) { Test_Write(APP_CONFIG_ADDR, APP_CONFIG_CLEAR_VALUE); Iap_jump(FLASH_IAP_ADDR);// Jump to the reset vector address of iap } Can be seen, we first clear the app flag, and then jump to the iAP program, it will not affect the iAP process, and the app code is also in the microcontroller, in addition, the app project must also set two things Because the starting address of flash is 0x08000000, and we used the space of 2000 before as the iap code space, then the starting space of the app code becomes 0x8002000, and there is a download interface to be set. The red frame part should also be modified. Is there a problem with the interrupt vector table? In the IAP we don't need to consider the interrupt vector table, because the default is at 0x8000000, but the start position of the code in the app has changed, the interrupt vector table must be reset. There is a system_init function in system_stm32f10x.c, which is called by the startup code to configure the system clock. The last sentence in the function is #ifdef VECT_TAB_SRAM SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. */ #else SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. */ #endif Where VECT_TAB_OFFSET is the offset we want to define, which is the starting address offset of the app program. We know that it is 2000, then the macro of the value needs to be modified, at about 128 lines. //This is the flash offset address, the app should modify this address #define VECT_TAB_OFFSET 0x2000 /*!< Vector Table base offset field. This value must be a multiple of 0x200. */ Well, the complete process is like this. In addition, the project is divided into three parts, an IAP, an app, and one of course the download program. The download program is like this. I will package and upload the three code projects to csdn. If you want to know more about it, you can download it and see if the software is written in mfc. Modular Plug,modular jack rj45,modular jack cat6,mod plugs NINGBO UONICORE ELECTRONICS CO., LTD , https://www.uniconmelectronics.com
