Remote Upgrade Design Based on IAP and Keil MDK

Preface: Three weeks ago, I suddenly wanted to write a Remote Upgrade Program. At that time, I only knew that IAP meant application programming, but I still knew nothing about how to compile it. I set a stage objective for myself to solve one problem after another by writing the most basic code. Three weeks later, I tried the experiment more than 50 times using my own design method. No upgrade failed.

In the past three weeks, I have encountered a lot of puzzles, puzzles, and even the desire to give up. But what I want to say now is that many unknown difficulties will block us, we may feel like we don't have a clue or even feel that we can't help but give up without a way out, but stick to it. Those difficulties will not only make us better, but also make progress.

This design is based on lpc2114 and Keil MDK (v4.10). However, all IAP-supported processors can use this solution for reference. The important thing is thinking, not what to use.

0
Introduction

The Application Programming (IAP) technology provides a good solution for online and remote system upgrades, as well as great flexibility for data storage and on-site firmware upgrades. Generally, the serial port of the chip can be connected to the RS232 port of the computer, and online and remote upgrade and maintenance can be easily implemented through the existing Internet, wireless network, or other communication methods.

This article uses NXP's lpc2114 ARM microprocessor as the platform and Keil MDK as the development tool, the principles of IAP, the division of flash, the distributed loading mechanism, the re- ing of interrupt, And the implementation scheme and optimization of online upgrade are described. This solution uses multiple verification technologies to ensure the correctness of the transmitted data to the maximum extent. The bootloader mechanism is used, even if the upgrade fails due to an unexpected event (power failure, programming Flash failure, etc, the program can also return to the status before the upgrade.

1
Flash planning for the lpc2114

1.1 slice description

There are a total of KB flash chips in the lpc2114, divided into 16 sectors, respectively 0 sectors ~ 15 sectors, each of which is 8 KB of storage space. 15th slice is solidified as the boot block zone at the factory, which controls the initialization operation after resetting and provides flash programming methods. Therefore, the available FLASH space is only 120kb. The IAP program is solidified in the boot block. The IAP operation is based on the slice and occupies 32 bytes of RAM in the slice. The following table lists the number of sectors and storage addresses contained in the lpc2114 device.

Table1.1 lpc2114 flashSector in the device

1.2 flash sector division

In this design, Flash is divided into four zones. The sector 0 stores the jump program and the upgraded boot loader ). Run the jump program after the sub-station powers on to jump to the user program. During the user program running, if the upgrade command is received, the user program will jump to the bootloader area, receive new program data packets, complete flash programming, and jump to the new program area to execute the program. Sector 1 ~ Sector 7 is the low storage area of the program; Sector 8 ~ Sector 13 is the high area for program storage; Sector 14 stores the current running area flag. If the current running is in the high area, the minimum four bytes of the Flag area are 0x00010000. If the current running is in the low area, the minimum four bytes of the Flag area are 0x00008000.

2
IAP principles and Software Design

2.1 IAP principles

IAP functions are some function code that is solidified on the Internal flash of the microprocessor. The final user program can directly call these functions to erase and program the Internal flash. The Internal flash block of the lpc2114 microprocessor is called the boot block and located at the top of the Flash. The IAP function that can be called is located in the block. After power-on, the boot block is mapped to the top of the internal address space. Similarly, the population address of the IAP function is mapped to the address 0x7ffffff0. You can jump to this address to call the corresponding lap function.

2.2 IAP command

For application programming, the IAP program should be called by pointing to the command code and parameters contained in the memory (RAM) through the word pointer in the register R0. The IAP command result is returned to the returned table pointed to by register R1. You can pass the same pointer in the R0 and R1 registers to reuse the command table to get the result. The parameter table should be large enough to save all results in case the number of results exceeds the number of parameters. The parameter transfer is shown in Figure 2-1. The number of parameters and results varies according to the IAP command. The maximum number of parameters is 5, which is passed by the "Copy Ram content to flash" command. The maximum number of results is 2, which is returned by the "empty sector query" command. The command handler sends the status code invalid_command when receiving an undefined command. IAP
The program is the thumb code located at address 0x7ffffff0.

Figure 2-1 IAP parameter transfer

Table 2-1 describes the IAP commands.

Table 2-1 IAP command Summary

IAP command	Command code	Description
Prepare programming sectors	50	This command must be executed before the "Copy Ram content to flash" or "erase Sector" command is executed. The successful execution of these two Commands will cause the related sectors to be protected again. This command cannot be used for the Boot Sector. To prepare a single sector, you can set the start and end sector numbers to the same value.
Copy Ram content to flash	51	This command is used to program flash memory. The affected sectors should be prepared by calling the "prepare write operation sector" command. After the Copy command is successfully executed, the slice is automatically protected. This command cannot write the Boot Sector.
Erase sector	52	This command is used to erase one or more flash memory sectors. The boot sector cannot be erased by this command. To erase a single sector, you can set the start and end sector numbers to the same value.
Empty sector Query	53	This command is used to empty one or more sectors of the flash memory. To empty a single sector, you can set the start and end sector numbers to the same value.
Read Device ID	54	This command is used to read the device ID.
Read the boot version	55	This command is used to read the version number of the boot code.
IAP comparison	56	This command is used to compare the memory content of two address units. When the source or target address contains the slave address0Before64When any one of the bytes is used, the comparison results are not necessarily correct. Before64Remap bytesFlash boot Slice.

2.3 IAP programming function interface

The IAP function can be called using the following C code.

Define the entry address of the IAP program. Because the 0th-bit IAP address is 1, the thumb Instruction Set changes when the program counter is transferred to this address.

# Define iap_location 0x7ffffff1

Define the data structure or pointer, and pass the IAP command table and result table to the IAP function.

Unsigned Long Command [5];

Unsigned long result [2];

Define the function type pointer. The function contains two parameters and no return value. Note: IAP returns the function result along with the base address of the table in R1.

Typedef void (* IAP) (unsigned int [], unsigned int []);

IAP iap_entry;

Set function pointer

Iap_entry = (IAP) iap_location;

Use the following statement to call IAP.

Iap_entry (command, result );

Flash memory cannot be accessed during write or erase operations. IAP command for executing flash write/erase operations

Uses 32 bytes of space at the top of the block ram. If IAP programming is allowed in the application, the user program should not

Use this space.

3
Implementation process of the upgrade of the lpc2114

In the software design of the Upgrade Program, the implementation of the decentralized loading mechanism, the re- ing of Interrupt vectors, and the Soft Interrupt are also closely related to the compiler used. Therefore, this article combines Keil MDK (v4.10) compile the tool to elaborate on the implementation process of the upgrade program.

3.1 Overall Thinking

After the substation is powered on, it runs at flash 0x000 ~ Jump program in 0x3ff. The jump program will read the current program running flag in 14 sectors. If the minimum four bytes of this sector are 0x00010000, it indicates that the current program is running in the high area, the jump program will jump to the Flash 0x00010000 to execute the user program. If the minimum four bytes in the flag area are 0x00008000, the current program is running in the lower area, the jump program will jump to flash 0x00002000 to execute the user program. After the user program is executed normally, the user program will be properly collected and processed and transmitted according to the design. After receiving the upgrade command, the user program will jump to the bootloader at flash 0x00000400 to perform the upgrade operations. After the upgrade is successful, the bootloader program updates the current program running zone flag, and the program jumps to the new program to run. If the upgrade fails, the pre-Upgrade Program is returned.

The flowchart is as follows:

3.2 jump Program Design

A jump program is the first program to run after the substation is powered on. Based on the current code running area, it jumps to the corresponding user program area for execution. This program occupies the minimum 1 kb of Flash space and is in the same 0th sector as bootloader.

The startup code of the jump program only initializes the stack and does not use the PLL and storage acceleration functions. Code 1 describes the main startup code of the jump program.

; Enter user mode and set its stack pointer MSR cpsr_c, # mode_usr MoV sp, R0 Sub SL, SP, # usr_stack_size ; Enter the C code Import _ main LDR r0, =__ main BX R0 Code 1: Jump program startup code

When the jump program is determined to jump to the high-end user program or the low-end user program, use the function pointer to jump to 0x00010000 (high-End User Function entry address) or 0x00002000 (lower-zone User Function entry address ).

Define function pointer:

Void (* userprogram )();

Specify the entry address:

Userprogram = (void (*) (0x00010000 );

Userprogram = (void (*) (0x00002000 );

Achieve redirection:

(* Userprogram )();

To precisely locate the user code at 0x00010000 (high-End User Function entry address) or 0x00002000 (low-end user function entry address) in flash, the compiler's distributed loading mechanism must be used, the implementation process is described in detail in bootloader.

In addition, the jump program initializes the current program running zone flag while burning the code, that is, it writes 0x00008000 to the Flash 0x0001c000 address, indicating that the current user program is in the lower zone. Mainly uses the Compiler_Keyword: precisely locate a variable. Note that this keyword must contain the header file absacc. h.

Const uint32 X _ at (0x0001c000) = 0x00008000; // initialize the user program flag area. The default operation is low.

3.3 Upgrade Program bootloader Design

The quality of the upgraded program depends to a large extent on the quality of the bootloader design.

To upgrade bootloader to an excellent IAP, you must handle exceptions such as failures during the upgrade. Ensure that the system will not crash, even if the upgrade fails, the pre-Upgrade Program can be returned.

Execute initialization with Upgrade commands (serial port, timer, and watchdog)

Accept update data packets, and check the frame header, length, frame number, and data zone check to ensure the integrity and correctness of the update data to the maximum extent.

Ø check the receiving status in real time. If no data is received or the received data packet is incorrect within 10 s, exit the upgrade and return to the original program.

The received data is written to flash in 512 bytes. After the data is written, it is read and compared with the original data. After the verification is successful, the Flash program is successful. The Flash program can be programmed three times in a row. If the Flash program fails three times, the Upgrade Program is exited and the original program is executed.

After the upgrade is successful, update the current running zone icon, jump to the new program, and save the original program.

In this design, the bootload is located in the zero-sector storage zone starting with 0x400 of flash. The decentralized loading mechanism is used to locate the program's entry address at 0x00000400. When your program receives the upgrade command, it uses the function pointer to jump to this entrance.

3.3.1 Use IAP

Figure 3-1 describes the steps required to use IAP to program flash.

3.3.1.1 define System Parameters

Before using IAP, You need to define some system parameters, such as the system clock, IAP interrupt entry, and input/output cache.

# Define iap_clk 11059200ul # Define iap_location 0x7ffffff1 Typedef void (* IAP) (uint32 [], uint32 []); // defines the function type pointer IAP iap_entry = (IAP) iap_location; // set the function pointer Unsigned Long Command [5] = {0, 0, 0, 0 }; Unsigned long result [2] = {0, 0 }; Code 3-1: Define System Parameters

3.3.1.2 select a sector

Before erasing and programming Flash, you must select one or more sectors.

/*************************************** *************************** * Name: selsector () * Function: select the IAP operation sector and run the command code 50. * Entry parameter: Start sector of sec1 * Sec2 termination sector * Exit parameter: IAP return value (paramout buffer) pai_success, busy, invalid_sector **************************************** *****************************/ Void selsector (uint8 sec1, uint8 sec2) { Paramin [0] = iap_selsector; // set the command word Paramin [1] = sec1; // set parameters Paramin [2] = sec2; Iap_entry (paramin, paramout); // call the IAP Service Program } Code 3-2 select a sector

3.3.1.3 erase a sector

You must perform the erasure operation before programming Flash. If a sector has been erased, you do not need to erase it again. One or more sectors can be erased at a time.

/*************************************** *************************** * Name: erasesector () * Function: Slice erasure. The command code is 52. * Entry parameter: Start sector of sec1 * Sec2 termination sector * Exit parameter: IAP return value (paramout buffer) pai_success, busy, invalid_sector *************************************** *********************************/ Void erasesector (uint8 sec1, uint8 sec2) {Paramin [0] = iap_erasesector; // set the command word Paramin [1] = sec1; // set parameters Paramin [2] = sec2; Paramin [3] = fosc/1000; // when the PLL function is not used, fcclk = fosc Iap_entry (paramin, paramout); // call the IAP Service Program Code 3-3 erase a sector

3.3.1.4 programming sector

Through this process, data can be programmed from Ram to In-chip Flash.

Note:

1. data can only be programmed from in-chip SRAM to In-chip Flash.

2. The flash address must be 512 bytes aligned.

3. The on-chip RAM should be located in the local bus, that is, the USB or Ethernet SRAM cannot be used.

4. Each programming byte should be one of 512, 1024, 4096, and 8192.

/*************************************** ****************************** * Name: ramtoflash () * Function: Copy Ram data to flash with the command code 51. * Entry parameter: DST destination address, that is, the start address of flash. Dividing by 512 bytes * SRC Source Address, that is, the RAM address. The address must be word aligned. * No number of copied bytes, Which is 512/1024/4096/8192 * Exit parameter: IAP return value (paramout buffer) pai_success, src_addr_error, dst_addr_error, Src_addr_not_mapped, dst_addr_not_mapped, count_error, busy, sector not selected **************************************** ****************************/ Void ramtoflash (uint32 DST, uint32 SRC, uint32 No) {Paramin [0] = iap_ramtoflash; // set the command word Paramin [1] = DST; // set parameters Paramin [2] = SRC; Paramin [3] = no; Paramin [4] = fosc/1000; // when the PLL function is not used, fcclk = fosc Iap_entry (paramin, paramout); // call the IAP Service Program } Code 3-4 programming sector

3.3.1.5 compare data

This function can be used to check whether the data written into flash is the same as that in Ram.

Note that the source address, target address, and number of nodes must be multiples of 4. You can use the keyword _ align (n) provided by the Keil MDK to specify the n-byte align.

/*************************************** ***************************** * Name: Compare () * Function: check data. The command code is 56. * Entry parameter: DST destination address, that is, the starting address of RAM/flash. The address must be word aligned. * SRC Source Address, that is, the Flash/RAM address. The address must be word aligned. * No number of copied bytes, which must be divisible by four * Exit parameter: IAP return value (paramout buffer) pai_success, compare_error, addr_error **************************************** **************************/ Void compare (uint32 DST, uint32 SRC, uint32 No) {Paramin [0] = iap_compare; // set the command word Paramin [1] = DST; // set parameters Paramin [2] = SRC; Paramin [3] = no; Iap_entry (paramin, paramout); // call the IAP Service Program Code 3-5 compare data

3.3.2 interrupt management during IAP Programming

Flash on the lpc2114 chip must not be interrupted during erasure/programming. However, in the bootloader, the timer and serial port receive are interrupted again. Therefore, you must disable the total interruption before the erasure/programming. Bootloader runs in the user mode and does not have the right to prohibit/enable interruption. Therefore, in this design, the Soft Interrupt prohibition/enable total interruption is used. Keil MDK provides the keyword _ SVC to trigger Soft Interrupt.

Soft Interrupt function declaration:

_ SVC (0x00) void enableirq (void); // enable interrupt, Soft Interrupt 0

_ SVC (0x01) void disableirq (void); // disable interrupt, Soft Interrupt 1

Soft Interrupt function code:

/* **************************************** ***************************** * Function: Disable interruption. * Description: Soft Interrupt is used to call function disconnection in user mode. **************************************** *****************************/ Void disableirqfunc (void) { Int temp; _ ASM { Mrs temp, spsr ORR temp, temp, #0x80 MSR spsr_c, temp } } /* **************************************** **************************** * Power: Enable interruption * Description: Soft Interrupt is used to enable function interruption in user mode. **************************************** **************************** */ Void enableirqfunc (void) { Int temp; _ ASM { Mrs temp, spsr Bic temp, temp, #0x80 MSR spsr_c, temp } } Code 3-6 disable/enable total interruptions

Change the startup code and mount the Soft Interrupt entry:

; Soft Interrupt entry Export swi_handler Extern enableirq1 Extern disableirq1 Swi_handler Stmfd SP !, {R0, R12, LR}; stack entry LDR r0, [LR, #-4]; take the Soft Interrupt command, and the Soft Interrupt number contains Bic r0, R0, #0xff000000 CMP r0, #0; Determine whether Soft Interrupt is 0 Bleq enableirqfunc Blne disableirqfunc Ldmfd SP !, {R0, R12, PC} ^ Code 3-7 mount the Soft Interrupt entry

In the program, if you want to disable interruption, you only need to use disableirq (); if you can interrupt, you only need to use enableirq ().

3.3.3 use the Distributed Loading Mechanism to precisely locate the entry address

After the application receives the upgrade command, it will jump to 0x00000400 to execute the bootloader Upgrade Program. Therefore, the entry address of the bootloader must be precisely located at 0x00000400. This can be done using the distributed loading mechanism provided by the Keil MDK.

For code distribution, see code 3-8.

; **************************************** ********************* ; *** Scatter-loading description file generated by uvision *** ; **************************************** ********************* Lr_irom1 0x00000400 0x00001c00 {; load region size_region Er_irom1 0x00000400 0x00001c00 {; load address = Execution address *. O (reset, + first) * (Inroot $ sections) . Any (+ RO) } Rw_iram1 0x40000040 0x00003fa0 {; RW data . Any (+ RW + zi) } } Code 3-8 distributed code Loading

This Code shows that the bootloader program is executed from 0x00000400 and occupies a maximum of 0x1c00 bytes of Flash space. In addition, the ram of the program starts from 0x40000040 and the length is 0x3fa0 bytes. In this way, the 64-byte RAM is reserved for interrupt vector ing and the 32-byte RAM is reserved for IAP programming.

3.3.4 re- ing of Interrupt Vectors

The start address of bootloader is 0x00000400, And the interrupt vector is also stored from this address. However, when an arm exception occurs by default, the Operation will jump to the 64-byte interrupt vector area at 0x00000000, so in order to interrupt the bootloader, the 64-byte interrupt vector table, which is located at the beginning of 0x00000400, must be re-mapped to the ram lower zone. Lpc2114 writes 0x02 to the memmap register to complete this process.

Code 3-9 describes the process of re- ing an interrupt vector.

; Copy exception vectors to internal RAM --------------------------------------- ADR R8, vectors; Source Address LDR R9, = ram_base; destination address, which is 0x40000000 Ldmia R8 !, {R0-R7}; load vector table Stmia R9 !, {R0-R7}; storage vector table Ldmia R8 !, {R0-R7}; mount handler address Stmia R9 !, {R0-R7}; storage handler address ; Memory Mapping (when interrupt vectors are in Ram) Memmap equ 0xe01fc040; memory mapping Control If: Def: remap LDR r0, = memmap If: Def: extmem_mode MoV R1, #3 Elif: Def: ram_mode MoV R1, #2 Else MoV R1, #1 Endif STR R1, [R0] Endif Code 3-9 interrupt vector re- ing

Since the startup Code provided by the Keil MDK uses Conditional compilation instructions, to correctly execute the interrupt vector re- ing, you also need to find the define edit box in the ASM tag under the options for target "your project target name" in the Keil MDK compiler Project Settings, and type "remap ram_mode" in the edit box ". 3-2

Figure 3-2

Note: The PLL and memory acceleration modules should be disabled when Flash is erased/programmed.

3.4 User Program Design

The user program runs in the high area (Sector 8 ~ 13) or low (sector 1 ~ 7), used to collect, process, and upload data. In addition to the functional requirements of your programs, you must note the following:

Ø use the Distributed Loading Mechanism to precisely locate the program entry to 0x00010000 (high zone) or 0x00008000 (low zone ).

Ø re-map the interrupt vector to the bottom of RAM.

4
Communication protocol and PC software

4.1 intel hex format

An Intel HEX file is an ASCII text file that records text lines. In an Intel HEX file, each row is a hex record, a machine code or data constant consisting of hexadecimal numbers. A Data Record ends with a carriage return and a line feed.

An Intel HEX file can contain any number of hexadecimal records. Each record has five fields. The following is a record format.

: Ll aaaa tt [DD...] CC

Each group of letters is an independent domain. Each letter is a hexadecimal number. Each domain consists of at least two hexadecimal numbers. The following is a byte description.

: Colon is the start of each intel hex record

Ll is the length field of this record, which indicates the number of bytes of data (dd.

Aaaa is the address field, which indicates the starting address of the data.

TT indicates the type of the hex record. It may be the following types:

00 ---- data record

01 ---- end of File

02 ---- extended segment address record

04 ---- Extended Linear address records

Dd is a data field that represents one byte of data. A record may contain multiple data bytes. For details about the number of bytes, see the description of LL domain.

CC is an effect and field, indicating the record's effect and calculation method is to add all the letters (including the validation byte) starting with the colon of this record and then equal to 0x00.

An Intel HEX file must have a file end record. The type field of this record must be 01,

An EOF record always looks like this:

: 00000001ff

00 indicates the number of data bytes in the record.

0000 this address is meaningless for the EOF record

01 The record type is 01 (End record mark)

4.2 requirements on PC software

The host computer can parse and reorganize intel hex files.

The host computer software should be able to identify the response signals sent from the substation and make correct responses.

The host computer should be able to check the code integrity.

The upper computer can automatically determine whether the current upgrade program is in the same region as the upgrade region based on the high or low zone sign of the program issued by the substation.

5
Lab data

To verify the stability of the Upgrade Program, the sub-station is re-powered, reset, remote upgrade, and other experiments are recorded as follows.

1. Test the program jump function. After the program is powered on or reset, it should jump smoothly to the user program.

2. Test bootloader (1 ). The upper computer sends the upgrade command but does not send the upgrade data packet. The program should be able to enter the Bootloader and send the region where the current program is located (high or low zone Code). After 10 s, the program should jump to the user program.

3. Test bootloader (2 ). The upper computer sends the upgrade command to send the update data packet, but stops sending the update data packet when it is half sent. The program should be able to jump to the user program area after 10 s.

4. Test bootloader (3 ). The upper computer sends the upgrade command to send the update data packet, but sends the packet to the substation for power-off. After the power-on is restarted, the original program should be executed.

5. Test bootloader (4 ). The upper computer sends the upgrade command to send the update package. The program should be able to receive upgrade data packets and program flash, update the user program, update the user program, and jump to the new user program.

6. Summary

This upgrade scheme is based on the lpc2114, but any single-chip microcomputer and arm with IAP function can use this design scheme.

The design focuses on how to ensure the security of the upgrade. The substation has adopted some measures such as column verification, timeout processing, and watchdog. First, it ensures the correct transmission of the update data packets, second, the original upgrade procedure can be returned even if the upgrade fails. The verification measures of the upper computer must be performed by the relevant departments. According to the experiment data, dozens of remote upgrades were performed, and no failure was reported. The security performance can be guaranteed.

7. References:

1. Zhou ligong and other ARM microcontroller basics and practices (second edition) Beijing University of Aeronautics and Astronautics Press 2005

2. guide for use of lpc2114, 2124/2212, and 2214. pdf Guangzhou Zhou ligong mcu development Co., Ltd.

3. Wei Wenxiang Zhu Zhijie che linina Guo Baoquan a remote system software upgrade solution based on the lpc21 24 MCU and Embedded System Application 2006 stage 3

4. Xu Wenjie Ding Zhigang Zhang Quan IAP Design Based on ARM processor and Application computer applications and software 2009 stage 3rd

5. Jiang Xiaomei Li Xianghe Ren chaorong Yao Ming's arm-based IAP online and remote upgrade technology computer application 2008 Phase II

6. realview compilation tool-compiler reference manual arm limited 2009.3

7. realview compilation tools( arm limited 2009.3

8. realview Compilation tool-compiler user limit arm limited 2009.1

9.RealviewCompilation tool-chain reader reference manual arm limited 2008.9

10. Intel HEX file format

11. lpc2000 secondary bootloader for code update using iap nxp Semiconductors 2009.5.26

 

Postscript: scattered file loading, Soft Interrupt, interrupted vector table re- ing, variable alignment, precise positioning of variables and so on can be found in my reference materials, it is a wonderful thing to discover and solve the problem, so I have no plans or time to write them in detail.

It should be said that I took a detour during the design, and now I think it is quite ridiculous. I thought that the above things should be implemented in a project so that one can be generated. hex can burn files and write user programs and bootloader programs into the processor at one time. I want to bend it. The correct solution is to build four projects: Jump program, bootloader, user low-Zone Program, and user high-Zone Program. If you understand. the format of the Hex file can be completely generated by three projects: Jump program, bootloader, and user low-Zone Program (or jump program, bootloader, and user high-Zone Program. the Hex file is merged. It is my greatest achievement to handle problems flexibly and flexibly.

Postscript: Many people hope to get the source code after reading it. I understand this feeling. At first, I also hope to have a set of other people's source code. After all, this can be done quickly. so I will put a remote upgrade example in the following link. If you want to see it, download it. This is not used in my product, because my code contains some information about the company after all. if I have time, I will translate the English documents.

Link: http://download.csdn.net/detail/zhzht19861011/3618966

Add an implicit bug. Before jumping from bootloader to the application, the processor should enter the privileged mode. ---- 2012.12.10