; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\lps25hb.o --asm_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\lps25hb.d --cpu=Cortex-M4.fp --apcs=interwork -O0 --diag_suppress=9931,1,1293 -I..\..\..\..\Board\fire_F429 -I..\..\..\..\Demos\fire\ov2640 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -I..\..\..\..\libraries\daemons\homekit_server -I..\..\..\..\libraries\daemons\http_server -I..\..\..\..\Platform\Drivers\malloc -I..\..\..\..\Platform\Drivers\SDRAM -I..\..\..\..\Platform\Drivers\ov5640 -IG:\GIT_OSC\STM32_develop\F429-V2\develop\6-WIFI\STM32-WiFi\3.wifi_ov5640\Projects\STM32F429\demo\RVMDK\RTE -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -IC:\Keil_v5\ARM\CMSIS\Include -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__UVISION_VERSION=515 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DDEBUG -DHSE_VALUE=25000000 -DOV5640 --omf_browse=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\lps25hb.crf ..\..\..\..\Platform\Drivers\sensor\LPS25HB\lps25hb.c]
                          THUMB

                          AREA ||i.LPS25HB_GetPressure||, CODE, READONLY, ALIGN=2

                  LPS25HB_GetPressure PROC
;;;362     */
;;;363    static PRESSURE_StatusTypeDef LPS25HB_GetPressure(float* pfData)
000000  b51c              PUSH     {r2-r4,lr}
;;;364    {
000002  4604              MOV      r4,r0
;;;365        uint32_t raw_press = 0;
000004  2000              MOVS     r0,#0
000006  9001              STR      r0,[sp,#4]
;;;366        uint8_t tmp = 0x00;
000008  9000              STR      r0,[sp,#0]
;;;367        
;;;368        if(LPS25HB_IO_Read(&tmp, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG1_ADDR, 1) != PRESSURE_OK)
00000a  2301              MOVS     r3,#1
00000c  2220              MOVS     r2,#0x20
00000e  4827              LDR      r0,|L1.172|
000010  7801              LDRB     r1,[r0,#0]  ; LPS25HB_SlaveAddress
000012  4668              MOV      r0,sp
000014  f7fffffe          BL       LPS25HB_IO_Read
000018  b108              CBZ      r0,|L1.30|
;;;369        {
;;;370          return PRESSURE_ERROR;
00001a  2001              MOVS     r0,#1
                  |L1.28|
;;;371        }
;;;372    
;;;373        /* Output Data Rate selection */
;;;374        tmp &= (LPS25HB_ODR_MASK);
;;;375        
;;;376        if(tmp == 0x00)
;;;377        {
;;;378          if(LPS25HB_IO_Read(&tmp, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG2_ADDR, 1) != PRESSURE_OK)
;;;379          {
;;;380            return PRESSURE_ERROR;
;;;381          }
;;;382    
;;;383          /* Serial Interface Mode selection */
;;;384          tmp &= ~(LPS25HB_ONE_SHOT_MASK);
;;;385          tmp |= LPS25HB_ONE_SHOT_START;
;;;386    
;;;387          if(LPS25HB_IO_Write(&tmp, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG2_ADDR, 1) != PRESSURE_OK)
;;;388          {
;;;389            return PRESSURE_ERROR;
;;;390          }
;;;391        
;;;392          do{
;;;393          
;;;394            if(LPS25HB_IO_Read(&tmp, LPS25HB_SlaveAddress, LPS25HB_STATUS_REG_ADDR, 1) != PRESSURE_OK)
;;;395            {
;;;396              return PRESSURE_ERROR;
;;;397            }
;;;398           
;;;399          }while(!(tmp&&0x01));
;;;400        }    
;;;401    
;;;402        if(LPS25HB_I2C_ReadRawPressure(&raw_press) != PRESSURE_OK)
;;;403        {
;;;404          return PRESSURE_ERROR;
;;;405        }
;;;406    
;;;407        *pfData = (float)raw_press /4096.0f;
;;;408        
;;;409        return PRESSURE_OK;
;;;410    }
00001c  bd1c              POP      {r2-r4,pc}
                  |L1.30|
00001e  f89d0000          LDRB     r0,[sp,#0]            ;374
000022  f0000070          AND      r0,r0,#0x70           ;374
000026  9000              STR      r0,[sp,#0]            ;374
000028  f89d0000          LDRB     r0,[sp,#0]            ;376
00002c  bb60              CBNZ     r0,|L1.136|
00002e  2301              MOVS     r3,#1                 ;378
000030  2221              MOVS     r2,#0x21              ;378
000032  481e              LDR      r0,|L1.172|
000034  7801              LDRB     r1,[r0,#0]            ;378  ; LPS25HB_SlaveAddress
000036  4668              MOV      r0,sp                 ;378
000038  f7fffffe          BL       LPS25HB_IO_Read
00003c  b108              CBZ      r0,|L1.66|
00003e  2001              MOVS     r0,#1                 ;380
000040  e7ec              B        |L1.28|
                  |L1.66|
000042  f89d0000          LDRB     r0,[sp,#0]            ;384
000046  f0200001          BIC      r0,r0,#1              ;384
00004a  9000              STR      r0,[sp,#0]            ;384
00004c  f89d0000          LDRB     r0,[sp,#0]            ;385
000050  f0400001          ORR      r0,r0,#1              ;385
000054  9000              STR      r0,[sp,#0]            ;385
000056  2301              MOVS     r3,#1                 ;387
000058  2221              MOVS     r2,#0x21              ;387
00005a  4814              LDR      r0,|L1.172|
00005c  7801              LDRB     r1,[r0,#0]            ;387  ; LPS25HB_SlaveAddress
00005e  4668              MOV      r0,sp                 ;387
000060  f7fffffe          BL       LPS25HB_IO_Write
000064  b108              CBZ      r0,|L1.106|
000066  2001              MOVS     r0,#1                 ;389
000068  e7d8              B        |L1.28|
                  |L1.106|
00006a  bf00              NOP                            ;392
                  |L1.108|
00006c  2301              MOVS     r3,#1                 ;394
00006e  2227              MOVS     r2,#0x27              ;394
000070  480e              LDR      r0,|L1.172|
000072  7801              LDRB     r1,[r0,#0]            ;394  ; LPS25HB_SlaveAddress
000074  4668              MOV      r0,sp                 ;394
000076  f7fffffe          BL       LPS25HB_IO_Read
00007a  b108              CBZ      r0,|L1.128|
00007c  2001              MOVS     r0,#1                 ;396
00007e  e7cd              B        |L1.28|
                  |L1.128|
000080  f89d0000          LDRB     r0,[sp,#0]            ;399
000084  2800              CMP      r0,#0                 ;399
000086  d0f1              BEQ      |L1.108|
                  |L1.136|
000088  a801              ADD      r0,sp,#4              ;402
00008a  f7fffffe          BL       LPS25HB_I2C_ReadRawPressure
00008e  b108              CBZ      r0,|L1.148|
000090  2001              MOVS     r0,#1                 ;404
000092  e7c3              B        |L1.28|
                  |L1.148|
000094  ed9d0a01          VLDR     s0,[sp,#4]            ;407
000098  eeb80a40          VCVT.F32.U32 s0,s0                 ;407
00009c  eddf0a04          VLDR     s1,|L1.176|
0000a0  ee801a20          VDIV.F32 s2,s0,s1              ;407
0000a4  ed841a00          VSTR     s2,[r4,#0]            ;407
0000a8  2000              MOVS     r0,#0                 ;409
0000aa  e7b7              B        |L1.28|
;;;411    
                          ENDP

                  |L1.172|
                          DCD      LPS25HB_SlaveAddress
                  |L1.176|
0000b0  45800000          DCFS     0x45800000 ; 4096

                          AREA ||i.LPS25HB_GetTemperature||, CODE, READONLY, ALIGN=2

                  LPS25HB_GetTemperature PROC
;;;441     */
;;;442    static PRESSURE_StatusTypeDef LPS25HB_GetTemperature(float *pfData)
000000  b538              PUSH     {r3-r5,lr}
;;;443    {
000002  4604              MOV      r4,r0
;;;444        int16_t raw_data;
;;;445    
;;;446        if(LPS25HB_I2C_ReadRawTemperature(&raw_data) != PRESSURE_OK)
000004  4668              MOV      r0,sp
000006  f7fffffe          BL       LPS25HB_I2C_ReadRawTemperature
00000a  b108              CBZ      r0,|L2.16|
;;;447        {
;;;448          return PRESSURE_ERROR;
00000c  2001              MOVS     r0,#1
                  |L2.14|
;;;449        }
;;;450    
;;;451        *pfData = (float)((((float)raw_data/480.0f) + 42.5f));
;;;452        
;;;453        return PRESSURE_OK;
;;;454    }
00000e  bd38              POP      {r3-r5,pc}
                  |L2.16|
000010  f9bd0000          LDRSH    r0,[sp,#0]            ;451
000014  ee000a10          VMOV     s0,r0                 ;451
000018  eef80ac0          VCVT.F32.S32 s1,s0                 ;451
00001c  ed9f1a05          VLDR     s2,|L2.52|
000020  ee800a81          VDIV.F32 s0,s1,s2              ;451
000024  eddf0a04          VLDR     s1,|L2.56|
000028  ee300a20          VADD.F32 s0,s0,s1              ;451
00002c  ed840a00          VSTR     s0,[r4,#0]            ;451
000030  2000              MOVS     r0,#0                 ;453
000032  e7ec              B        |L2.14|
;;;455    /**
                          ENDP

                  |L2.52|
000034  43f00000          DCFS     0x43f00000 ; 480
                  |L2.56|
000038  422a0000          DCFS     0x422a0000 ; 42.5

                          AREA ||i.LPS25HB_I2C_ReadRawPressure||, CODE, READONLY, ALIGN=2

                  LPS25HB_I2C_ReadRawPressure PROC
;;;296     */
;;;297    static PRESSURE_StatusTypeDef LPS25HB_I2C_ReadRawPressure(uint32_t *raw_press)
000000  b57c              PUSH     {r2-r6,lr}
;;;298    {
000002  4606              MOV      r6,r0
;;;299        uint8_t buffer[3], i;
;;;300        uint32_t tempVal=0;
000004  2500              MOVS     r5,#0
;;;301        uint8_t tmp = 0x00;
000006  2000              MOVS     r0,#0
000008  9000              STR      r0,[sp,#0]
;;;302        
;;;303        if(LPS25HB_IO_Read(&tmp, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG1_ADDR, 1) != PRESSURE_OK)
00000a  2301              MOVS     r3,#1
00000c  2220              MOVS     r2,#0x20
00000e  482d              LDR      r0,|L3.196|
000010  7801              LDRB     r1,[r0,#0]  ; LPS25HB_SlaveAddress
000012  4668              MOV      r0,sp
000014  f7fffffe          BL       LPS25HB_IO_Read
000018  b108              CBZ      r0,|L3.30|
;;;304        {
;;;305          return PRESSURE_ERROR;
00001a  2001              MOVS     r0,#1
                  |L3.28|
;;;306        }
;;;307    
;;;308        /* Output Data Rate selection */
;;;309        tmp &= (LPS25HB_ODR_MASK);
;;;310        
;;;311        if(tmp == 0x00)
;;;312        {
;;;313          if(LPS25HB_IO_Read(&tmp, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG2_ADDR, 1) != PRESSURE_OK)
;;;314          {
;;;315            return PRESSURE_ERROR;
;;;316          }
;;;317    
;;;318          /* Serial Interface Mode selection */
;;;319          tmp &= ~(LPS25HB_ONE_SHOT_MASK);
;;;320          tmp |= LPS25HB_ONE_SHOT_START;
;;;321    
;;;322          if(LPS25HB_IO_Write(&tmp, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG2_ADDR, 1) != PRESSURE_OK)
;;;323          {
;;;324            return PRESSURE_ERROR;
;;;325          }
;;;326        
;;;327          do{
;;;328          
;;;329            if(LPS25HB_IO_Read(&tmp, LPS25HB_SlaveAddress, LPS25HB_STATUS_REG_ADDR, 1) != PRESSURE_OK)
;;;330            {
;;;331              return PRESSURE_ERROR;
;;;332            }
;;;333           
;;;334          }while(!(tmp&&0x01));
;;;335        }    
;;;336        
;;;337        /* Read the register content */
;;;338    
;;;339        if(LPS25HB_IO_Read(buffer, LPS25HB_SlaveAddress, (LPS25HB_PRESS_POUT_XL_ADDR | LPS25HB_I2C_MULTIPLEBYTE_CMD), 3) != PRESSURE_OK)
;;;340        {
;;;341          return PRESSURE_ERROR;
;;;342        }
;;;343    
;;;344        /* Build the raw data */
;;;345        for (i = 0 ; i < 3 ; i++)
;;;346            tempVal |= (((uint32_t) buffer[i]) << (8 * i));
;;;347    
;;;348        /* convert the 2's complement 24 bit to 2's complement 32 bit */
;;;349        if (tempVal & 0x00800000)
;;;350            tempVal |= 0xFF000000;
;;;351    
;;;352        /* return the built value */
;;;353        *raw_press = ((uint32_t) tempVal);
;;;354        
;;;355        return PRESSURE_OK;
;;;356    }
00001c  bd7c              POP      {r2-r6,pc}
                  |L3.30|
00001e  f89d0000          LDRB     r0,[sp,#0]            ;309
000022  f0000070          AND      r0,r0,#0x70           ;309
000026  9000              STR      r0,[sp,#0]            ;309
000028  f89d0000          LDRB     r0,[sp,#0]            ;311
00002c  bb60              CBNZ     r0,|L3.136|
00002e  2301              MOVS     r3,#1                 ;313
000030  2221              MOVS     r2,#0x21              ;313
000032  4824              LDR      r0,|L3.196|
000034  7801              LDRB     r1,[r0,#0]            ;313  ; LPS25HB_SlaveAddress
000036  4668              MOV      r0,sp                 ;313
000038  f7fffffe          BL       LPS25HB_IO_Read
00003c  b108              CBZ      r0,|L3.66|
00003e  2001              MOVS     r0,#1                 ;315
000040  e7ec              B        |L3.28|
                  |L3.66|
000042  f89d0000          LDRB     r0,[sp,#0]            ;319
000046  f0200001          BIC      r0,r0,#1              ;319
00004a  9000              STR      r0,[sp,#0]            ;319
00004c  f89d0000          LDRB     r0,[sp,#0]            ;320
000050  f0400001          ORR      r0,r0,#1              ;320
000054  9000              STR      r0,[sp,#0]            ;320
000056  2301              MOVS     r3,#1                 ;322
000058  2221              MOVS     r2,#0x21              ;322
00005a  481a              LDR      r0,|L3.196|
00005c  7801              LDRB     r1,[r0,#0]            ;322  ; LPS25HB_SlaveAddress
00005e  4668              MOV      r0,sp                 ;322
000060  f7fffffe          BL       LPS25HB_IO_Write
000064  b108              CBZ      r0,|L3.106|
000066  2001              MOVS     r0,#1                 ;324
000068  e7d8              B        |L3.28|
                  |L3.106|
00006a  bf00              NOP                            ;327
                  |L3.108|
00006c  2301              MOVS     r3,#1                 ;329
00006e  2227              MOVS     r2,#0x27              ;329
000070  4814              LDR      r0,|L3.196|
000072  7801              LDRB     r1,[r0,#0]            ;329  ; LPS25HB_SlaveAddress
000074  4668              MOV      r0,sp                 ;329
000076  f7fffffe          BL       LPS25HB_IO_Read
00007a  b108              CBZ      r0,|L3.128|
00007c  2001              MOVS     r0,#1                 ;331
00007e  e7cd              B        |L3.28|
                  |L3.128|
000080  f89d0000          LDRB     r0,[sp,#0]            ;334
000084  2800              CMP      r0,#0                 ;334
000086  d0f1              BEQ      |L3.108|
                  |L3.136|
000088  2303              MOVS     r3,#3                 ;339
00008a  22a8              MOVS     r2,#0xa8              ;339
00008c  480d              LDR      r0,|L3.196|
00008e  7801              LDRB     r1,[r0,#0]            ;339  ; LPS25HB_SlaveAddress
000090  a801              ADD      r0,sp,#4              ;339
000092  f7fffffe          BL       LPS25HB_IO_Read
000096  b108              CBZ      r0,|L3.156|
000098  2001              MOVS     r0,#1                 ;341
00009a  e7bf              B        |L3.28|
                  |L3.156|
00009c  2400              MOVS     r4,#0                 ;345
00009e  e006              B        |L3.174|
                  |L3.160|
0000a0  a801              ADD      r0,sp,#4              ;346
0000a2  5d00              LDRB     r0,[r0,r4]            ;346
0000a4  00e1              LSLS     r1,r4,#3              ;346
0000a6  4088              LSLS     r0,r0,r1              ;346
0000a8  4305              ORRS     r5,r5,r0              ;346
0000aa  1c60              ADDS     r0,r4,#1              ;345
0000ac  b2c4              UXTB     r4,r0                 ;345
                  |L3.174|
0000ae  2c03              CMP      r4,#3                 ;345
0000b0  dbf6              BLT      |L3.160|
0000b2  f4050000          AND      r0,r5,#0x800000       ;349
0000b6  b108              CBZ      r0,|L3.188|
0000b8  f045457f          ORR      r5,r5,#0xff000000     ;350
                  |L3.188|
0000bc  6035              STR      r5,[r6,#0]            ;353
0000be  2000              MOVS     r0,#0                 ;355
0000c0  e7ac              B        |L3.28|
;;;357    
                          ENDP

0000c2  0000              DCW      0x0000
                  |L3.196|
                          DCD      LPS25HB_SlaveAddress

                          AREA ||i.LPS25HB_I2C_ReadRawTemperature||, CODE, READONLY, ALIGN=2

                  LPS25HB_I2C_ReadRawTemperature PROC
;;;416     */
;;;417    static PRESSURE_StatusTypeDef LPS25HB_I2C_ReadRawTemperature(int16_t *raw_data)
000000  b538              PUSH     {r3-r5,lr}
;;;418    {
000002  4604              MOV      r4,r0
;;;419        uint8_t buffer[2];
;;;420        uint16_t tempVal=0;
000004  2500              MOVS     r5,#0
;;;421    
;;;422        /* Read the register content */
;;;423        if(LPS25HB_IO_Read(buffer, LPS25HB_SlaveAddress, (LPS25HB_TEMP_OUT_L_ADDR | LPS25HB_I2C_MULTIPLEBYTE_CMD), 2) != PRESSURE_OK)
000006  2302              MOVS     r3,#2
000008  22ab              MOVS     r2,#0xab
00000a  4809              LDR      r0,|L4.48|
00000c  7801              LDRB     r1,[r0,#0]  ; LPS25HB_SlaveAddress
00000e  4668              MOV      r0,sp
000010  f7fffffe          BL       LPS25HB_IO_Read
000014  b108              CBZ      r0,|L4.26|
;;;424        {
;;;425          return PRESSURE_ERROR;
000016  2001              MOVS     r0,#1
                  |L4.24|
;;;426        }
;;;427    
;;;428        /* Build the raw value */
;;;429        tempVal = (((uint16_t)buffer[1]) << 8)+(uint16_t)buffer[0];
;;;430    
;;;431        /* Return it */
;;;432        *raw_data = ((int16_t)tempVal);
;;;433        
;;;434        return PRESSURE_OK;
;;;435    }
000018  bd38              POP      {r3-r5,pc}
                  |L4.26|
00001a  f89d0000          LDRB     r0,[sp,#0]            ;429
00001e  f89d1001          LDRB     r1,[sp,#1]            ;429
000022  eb002001          ADD      r0,r0,r1,LSL #8       ;429
000026  b285              UXTH     r5,r0                 ;429
000028  b228              SXTH     r0,r5                 ;432
00002a  8020              STRH     r0,[r4,#0]            ;432
00002c  2000              MOVS     r0,#0                 ;434
00002e  e7f3              B        |L4.24|
;;;436    
                          ENDP

                  |L4.48|
                          DCD      LPS25HB_SlaveAddress

                          AREA ||i.LPS25HB_IO_Init||, CODE, READONLY, ALIGN=2

                          REQUIRE _printf_pre_padding
                          REQUIRE _printf_percent
                          REQUIRE _printf_widthprec
                          REQUIRE _printf_d
                          REQUIRE _printf_s
                          REQUIRE _printf_int_dec
                          REQUIRE _printf_str
                  LPS25HB_IO_Init PROC
;;;102    
;;;103    PRESSURE_StatusTypeDef LPS25HB_IO_Init(void)
000000  b538              PUSH     {r3-r5,lr}
;;;104    {
;;;105      // I2C init
;;;106      MicoI2cFinalize(&lps25hb_i2c_device);   // in case error
000002  481a              LDR      r0,|L5.108|
000004  f7fffffe          BL       MicoI2cFinalize
;;;107      MicoI2cInitialize(&lps25hb_i2c_device);
000008  4818              LDR      r0,|L5.108|
00000a  f7fffffe          BL       MicoI2cInitialize
;;;108    
;;;109      if( false == MicoI2cProbeDevice(&lps25hb_i2c_device, 5) ){
00000e  2105              MOVS     r1,#5
000010  4816              LDR      r0,|L5.108|
000012  f7fffffe          BL       MicoI2cProbeDevice
000016  2800              CMP      r0,#0
000018  d126              BNE      |L5.104|
;;;110        lps25hb_log("LPS25HB_ERROR: no i2c device found!");
00001a  bf00              NOP      
00001c  4814              LDR      r0,|L5.112|
00001e  6800              LDR      r0,[r0,#0]  ; mico_debug_enabled
000020  b900              CBNZ     r0,|L5.36|
000022  e01e              B        |L5.98|
                  |L5.36|
000024  4813              LDR      r0,|L5.116|
000026  f7fffffe          BL       mico_rtos_lock_mutex
00002a  215c              MOVS     r1,#0x5c
00002c  a012              ADR      r0,|L5.120|
00002e  f7fffffe          BL       strrchr
000032  b128              CBZ      r0,|L5.64|
000034  215c              MOVS     r1,#0x5c
000036  a010              ADR      r0,|L5.120|
000038  f7fffffe          BL       strrchr
00003c  1c40              ADDS     r0,r0,#1
00003e  e000              B        |L5.66|
                  |L5.64|
000040  a00d              ADR      r0,|L5.120|
                  |L5.66|
000042  4604              MOV      r4,r0
000044  f7fffffe          BL       mico_get_time
000048  4605              MOV      r5,r0
00004a  206e              MOVS     r0,#0x6e
00004c  4623              MOV      r3,r4
00004e  a218              ADR      r2,|L5.176|
000050  4629              MOV      r1,r5
000052  9000              STR      r0,[sp,#0]
000054  a018              ADR      r0,|L5.184|
000056  f7fffffe          BL       __2printf
00005a  4806              LDR      r0,|L5.116|
00005c  f7fffffe          BL       mico_rtos_unlock_mutex
000060  bf00              NOP      
                  |L5.98|
000062  bf00              NOP      
;;;111        return PRESSURE_ERROR;
000064  2001              MOVS     r0,#1
                  |L5.102|
;;;112      }
;;;113      return PRESSURE_OK;
;;;114    }
000066  bd38              POP      {r3-r5,pc}
                  |L5.104|
000068  2000              MOVS     r0,#0                 ;113
00006a  e7fc              B        |L5.102|
;;;115    
                          ENDP

                  |L5.108|
                          DCD      lps25hb_i2c_device
                  |L5.112|
                          DCD      mico_debug_enabled
                  |L5.116|
                          DCD      stdio_tx_mutex
                  |L5.120|
000078  2e2e5c2e          DCB      "..\\..\\..\\..\\Platform\\Drivers\\sensor\\LPS25HB\\lps"
00007c  2e5c2e2e
000080  5c2e2e5c
000084  506c6174
000088  666f726d
00008c  5c447269
000090  76657273
000094  5c73656e
000098  736f725c
00009c  4c505332
0000a0  3548425c
0000a4  6c7073  
0000a7  32356862          DCB      "25hb.c",0
0000ab  2e6300  
0000ae  00                DCB      0
0000af  00                DCB      0
                  |L5.176|
0000b0  4c505332          DCB      "LPS25HB",0
0000b4  35484200
                  |L5.184|
0000b8  5b25645d          DCB      "[%d][%s: %s:%4d] LPS25HB_ERROR: no i2c device found!\r\n"
0000bc  5b25733a
0000c0  2025733a
0000c4  2534645d
0000c8  204c5053
0000cc  32354842
0000d0  5f455252
0000d4  4f523a20
0000d8  6e6f2069
0000dc  32632064
0000e0  65766963
0000e4  6520666f
0000e8  756e6421
0000ec  0d0a    
0000ee  00                DCB      0
0000ef  00                DCB      0

                          AREA ||i.LPS25HB_IO_Read||, CODE, READONLY, ALIGN=2

                  LPS25HB_IO_Read PROC
;;;151    */
;;;152    PRESSURE_StatusTypeDef LPS25HB_IO_Read(uint8_t* pBuffer, uint8_t DeviceAddr, uint8_t RegisterAddr, uint16_t NumByteToRead)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;153    {
000004  b088              SUB      sp,sp,#0x20
000006  4605              MOV      r5,r0
000008  4688              MOV      r8,r1
00000a  4616              MOV      r6,r2
00000c  461f              MOV      r7,r3
;;;154      mico_i2c_message_t lps25hb_i2c_msg = {NULL, NULL, 0, 0, 0, false};
00000e  2000              MOVS     r0,#0
000010  9004              STR      r0,[sp,#0x10]
000012  9005              STR      r0,[sp,#0x14]
000014  9006              STR      r0,[sp,#0x18]
000016  9007              STR      r0,[sp,#0x1c]
;;;155      int iError = 0;
000018  2400              MOVS     r4,#0
;;;156      uint8_t array[8] = {0};
00001a  9002              STR      r0,[sp,#8]
00001c  9003              STR      r0,[sp,#0xc]
;;;157      array[0] = RegisterAddr;
00001e  f88d6008          STRB     r6,[sp,#8]
;;;158      
;;;159      iError = MicoI2cBuildCombinedMessage(&lps25hb_i2c_msg, array, pBuffer, 1, NumByteToRead, 3);
000022  2003              MOVS     r0,#3
000024  2301              MOVS     r3,#1
000026  462a              MOV      r2,r5
000028  a902              ADD      r1,sp,#8
00002a  e9cd7000          STRD     r7,r0,[sp,#0]
00002e  a804              ADD      r0,sp,#0x10
000030  f7fffffe          BL       MicoI2cBuildCombinedMessage
000034  4604              MOV      r4,r0
;;;160      if(0 != iError){
000036  b11c              CBZ      r4,|L6.64|
;;;161        return PRESSURE_ERROR; 
000038  2001              MOVS     r0,#1
                  |L6.58|
;;;162      }
;;;163      iError = MicoI2cTransfer(&lps25hb_i2c_device, &lps25hb_i2c_msg, 1);
;;;164      if(0 != iError){
;;;165        return PRESSURE_ERROR;
;;;166      }
;;;167      return (PRESSURE_StatusTypeDef)iError;
;;;168    }
00003a  b008              ADD      sp,sp,#0x20
00003c  e8bd81f0          POP      {r4-r8,pc}
                  |L6.64|
000040  2201              MOVS     r2,#1                 ;163
000042  a904              ADD      r1,sp,#0x10           ;163
000044  4804              LDR      r0,|L6.88|
000046  f7fffffe          BL       MicoI2cTransfer
00004a  4604              MOV      r4,r0                 ;163
00004c  b10c              CBZ      r4,|L6.82|
00004e  2001              MOVS     r0,#1                 ;165
000050  e7f3              B        |L6.58|
                  |L6.82|
000052  b2e0              UXTB     r0,r4                 ;167
000054  e7f1              B        |L6.58|
;;;169    
                          ENDP

000056  0000              DCW      0x0000
                  |L6.88|
                          DCD      lps25hb_i2c_device

                          AREA ||i.LPS25HB_IO_Write||, CODE, READONLY, ALIGN=2

                  LPS25HB_IO_Write PROC
;;;124    */
;;;125    PRESSURE_StatusTypeDef LPS25HB_IO_Write(uint8_t* pBuffer, uint8_t DeviceAddr, uint8_t RegisterAddr, uint16_t NumByteToWrite)
000000  e92d43f0          PUSH     {r4-r9,lr}
;;;126    {
000004  b087              SUB      sp,sp,#0x1c
000006  4606              MOV      r6,r0
000008  4689              MOV      r9,r1
00000a  4617              MOV      r7,r2
00000c  461d              MOV      r5,r3
;;;127      mico_i2c_message_t lps25hb_i2c_msg = {NULL, NULL, 0, 0, 0, false};
00000e  2000              MOVS     r0,#0
000010  9003              STR      r0,[sp,#0xc]
000012  9004              STR      r0,[sp,#0x10]
000014  9005              STR      r0,[sp,#0x14]
000016  9006              STR      r0,[sp,#0x18]
;;;128      int iError = 0;
000018  4680              MOV      r8,r0
;;;129      uint8_t array[8];
;;;130      uint8_t stringpos;
;;;131      array[0] = RegisterAddr;
00001a  f88d7004          STRB     r7,[sp,#4]
;;;132      for (stringpos = 0; stringpos < NumByteToWrite; stringpos++) {
00001e  2400              MOVS     r4,#0
000020  e004              B        |L7.44|
                  |L7.34|
;;;133        array[stringpos + 1] = *(pBuffer + stringpos);
000022  5d31              LDRB     r1,[r6,r4]
000024  aa01              ADD      r2,sp,#4
000026  1c60              ADDS     r0,r4,#1
000028  5411              STRB     r1,[r2,r0]
00002a  b2c4              UXTB     r4,r0                 ;132
                  |L7.44|
00002c  42ac              CMP      r4,r5                 ;132
00002e  dbf8              BLT      |L7.34|
;;;134      }
;;;135      
;;;136      iError = MicoI2cBuildTxMessage(&lps25hb_i2c_msg, array, NumByteToWrite + 1, 3);
000030  1c68              ADDS     r0,r5,#1
000032  b282              UXTH     r2,r0
000034  2303              MOVS     r3,#3
000036  a901              ADD      r1,sp,#4
000038  a803              ADD      r0,sp,#0xc
00003a  f7fffffe          BL       MicoI2cBuildTxMessage
00003e  4680              MOV      r8,r0
;;;137      iError = MicoI2cTransfer(&lps25hb_i2c_device, &lps25hb_i2c_msg, 1);
000040  2201              MOVS     r2,#1
000042  a903              ADD      r1,sp,#0xc
000044  4806              LDR      r0,|L7.96|
000046  f7fffffe          BL       MicoI2cTransfer
00004a  4680              MOV      r8,r0
;;;138      if(0 != iError){
00004c  f1b80f00          CMP      r8,#0
000050  d001              BEQ      |L7.86|
;;;139        iError = PRESSURE_ERROR;
000052  f04f0801          MOV      r8,#1
                  |L7.86|
;;;140      }
;;;141      
;;;142      return (PRESSURE_StatusTypeDef)iError;
000056  f00800ff          AND      r0,r8,#0xff
;;;143    }
00005a  b007              ADD      sp,sp,#0x1c
00005c  e8bd83f0          POP      {r4-r9,pc}
;;;144    
                          ENDP

                  |L7.96|
                          DCD      lps25hb_i2c_device

                          AREA ||i.LPS25HB_Init||, CODE, READONLY, ALIGN=2

                  LPS25HB_Init PROC
;;;186     */
;;;187    static PRESSURE_StatusTypeDef LPS25HB_Init(PRESSURE_InitTypeDef *LPS25HB_Init)
000000  b538              PUSH     {r3-r5,lr}
;;;188    {  
000002  4604              MOV      r4,r0
;;;189        uint8_t tmp1 = 0x00;
000004  2000              MOVS     r0,#0
000006  9000              STR      r0,[sp,#0]
;;;190    
;;;191        /* Configure the low level interface ---------------------------------------*/
;;;192        if(LPS25HB_IO_Init() != PRESSURE_OK)
000008  f7fffffe          BL       LPS25HB_IO_Init
00000c  b108              CBZ      r0,|L8.18|
;;;193        {
;;;194          return PRESSURE_ERROR;
00000e  2001              MOVS     r0,#1
                  |L8.16|
;;;195        }
;;;196    
;;;197        if(LPS25HB_PowerOn() != PRESSURE_OK)
;;;198        {
;;;199          return PRESSURE_ERROR;
;;;200        }
;;;201    
;;;202        if(LPS25HB_IO_Read(&tmp1, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG1_ADDR, 1) != PRESSURE_OK)
;;;203        {
;;;204          return PRESSURE_ERROR;
;;;205        }
;;;206    
;;;207        /* Output Data Rate selection */
;;;208        tmp1 &= ~(LPS25HB_ODR_MASK);
;;;209        tmp1 |= LPS25HB_Init->OutputDataRate;
;;;210    
;;;211        /* Interrupt circuit selection */
;;;212        tmp1 &= ~(LPS25HB_DIFF_EN_MASK);
;;;213        tmp1 |= LPS25HB_Init->DiffEnable;
;;;214    
;;;215        /* Block Data Update selection */
;;;216        tmp1 &= ~(LPS25HB_BDU_MASK);
;;;217        tmp1 |= LPS25HB_Init->BlockDataUpdate;
;;;218    
;;;219        /* Serial Interface Mode selection */
;;;220        tmp1 &= ~(LPS25HB_SPI_SIM_MASK);
;;;221        tmp1 |= LPS25HB_Init->SPIMode;
;;;222    
;;;223        if(LPS25HB_IO_Write(&tmp1, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG1_ADDR, 1) != PRESSURE_OK)
;;;224        {
;;;225          return PRESSURE_ERROR;
;;;226        }      
;;;227    
;;;228        if(LPS25HB_IO_Read(&tmp1, LPS25HB_SlaveAddress, LPS25HB_RES_CONF_ADDR, 1) != PRESSURE_OK)
;;;229        {
;;;230          return PRESSURE_ERROR;
;;;231        }
;;;232    
;;;233        /* Serial Interface Mode selection */
;;;234        tmp1 &= ~(LPS25HB_P_RES_MASK);
;;;235        tmp1 |= LPS25HB_Init->PressureResolution;
;;;236    
;;;237        /* Serial Interface Mode selection */
;;;238        tmp1 &= ~(LPS25HB_T_RES_MASK);
;;;239        tmp1 |= LPS25HB_Init->TemperatureResolution;
;;;240    
;;;241        if(LPS25HB_IO_Write(&tmp1, LPS25HB_SlaveAddress, LPS25HB_RES_CONF_ADDR, 1) != PRESSURE_OK)
;;;242        {
;;;243          return PRESSURE_ERROR;
;;;244        }
;;;245        
;;;246        return PRESSURE_OK;
;;;247    }
000010  bd38              POP      {r3-r5,pc}
                  |L8.18|
000012  f7fffffe          BL       LPS25HB_PowerOn
000016  b108              CBZ      r0,|L8.28|
000018  2001              MOVS     r0,#1                 ;199
00001a  e7f9              B        |L8.16|
                  |L8.28|
00001c  2301              MOVS     r3,#1                 ;202
00001e  2220              MOVS     r2,#0x20              ;202
000020  4831              LDR      r0,|L8.232|
000022  7801              LDRB     r1,[r0,#0]            ;202  ; LPS25HB_SlaveAddress
000024  4668              MOV      r0,sp                 ;202
000026  f7fffffe          BL       LPS25HB_IO_Read
00002a  b108              CBZ      r0,|L8.48|
00002c  2001              MOVS     r0,#1                 ;204
00002e  e7ef              B        |L8.16|
                  |L8.48|
000030  f89d0000          LDRB     r0,[sp,#0]            ;208
000034  f0200070          BIC      r0,r0,#0x70           ;208
000038  9000              STR      r0,[sp,#0]            ;208
00003a  7820              LDRB     r0,[r4,#0]            ;209
00003c  f89d1000          LDRB     r1,[sp,#0]            ;209
000040  4308              ORRS     r0,r0,r1              ;209
000042  9000              STR      r0,[sp,#0]            ;209
000044  f89d0000          LDRB     r0,[sp,#0]            ;212
000048  f0200008          BIC      r0,r0,#8              ;212
00004c  9000              STR      r0,[sp,#0]            ;212
00004e  78e0              LDRB     r0,[r4,#3]            ;213
000050  f89d1000          LDRB     r1,[sp,#0]            ;213
000054  4308              ORRS     r0,r0,r1              ;213
000056  9000              STR      r0,[sp,#0]            ;213
000058  f89d0000          LDRB     r0,[sp,#0]            ;216
00005c  f0200004          BIC      r0,r0,#4              ;216
000060  9000              STR      r0,[sp,#0]            ;216
000062  7920              LDRB     r0,[r4,#4]            ;217
000064  f89d1000          LDRB     r1,[sp,#0]            ;217
000068  4308              ORRS     r0,r0,r1              ;217
00006a  9000              STR      r0,[sp,#0]            ;217
00006c  f89d0000          LDRB     r0,[sp,#0]            ;220
000070  f0200001          BIC      r0,r0,#1              ;220
000074  9000              STR      r0,[sp,#0]            ;220
000076  7960              LDRB     r0,[r4,#5]            ;221
000078  f89d1000          LDRB     r1,[sp,#0]            ;221
00007c  4308              ORRS     r0,r0,r1              ;221
00007e  9000              STR      r0,[sp,#0]            ;221
000080  2301              MOVS     r3,#1                 ;223
000082  2220              MOVS     r2,#0x20              ;223
000084  4818              LDR      r0,|L8.232|
000086  7801              LDRB     r1,[r0,#0]            ;223  ; LPS25HB_SlaveAddress
000088  4668              MOV      r0,sp                 ;223
00008a  f7fffffe          BL       LPS25HB_IO_Write
00008e  b108              CBZ      r0,|L8.148|
000090  2001              MOVS     r0,#1                 ;225
000092  e7bd              B        |L8.16|
                  |L8.148|
000094  2301              MOVS     r3,#1                 ;228
000096  2210              MOVS     r2,#0x10              ;228
000098  4813              LDR      r0,|L8.232|
00009a  7801              LDRB     r1,[r0,#0]            ;228  ; LPS25HB_SlaveAddress
00009c  4668              MOV      r0,sp                 ;228
00009e  f7fffffe          BL       LPS25HB_IO_Read
0000a2  b108              CBZ      r0,|L8.168|
0000a4  2001              MOVS     r0,#1                 ;230
0000a6  e7b3              B        |L8.16|
                  |L8.168|
0000a8  f89d0000          LDRB     r0,[sp,#0]            ;234
0000ac  f0200003          BIC      r0,r0,#3              ;234
0000b0  9000              STR      r0,[sp,#0]            ;234
0000b2  7860              LDRB     r0,[r4,#1]            ;235
0000b4  f89d1000          LDRB     r1,[sp,#0]            ;235
0000b8  4308              ORRS     r0,r0,r1              ;235
0000ba  9000              STR      r0,[sp,#0]            ;235
0000bc  f89d0000          LDRB     r0,[sp,#0]            ;238
0000c0  f020000c          BIC      r0,r0,#0xc            ;238
0000c4  9000              STR      r0,[sp,#0]            ;238
0000c6  78a0              LDRB     r0,[r4,#2]            ;239
0000c8  f89d1000          LDRB     r1,[sp,#0]            ;239
0000cc  4308              ORRS     r0,r0,r1              ;239
0000ce  9000              STR      r0,[sp,#0]            ;239
0000d0  2301              MOVS     r3,#1                 ;241
0000d2  2210              MOVS     r2,#0x10              ;241
0000d4  4804              LDR      r0,|L8.232|
0000d6  7801              LDRB     r1,[r0,#0]            ;241  ; LPS25HB_SlaveAddress
0000d8  4668              MOV      r0,sp                 ;241
0000da  f7fffffe          BL       LPS25HB_IO_Write
0000de  b108              CBZ      r0,|L8.228|
0000e0  2001              MOVS     r0,#1                 ;243
0000e2  e795              B        |L8.16|
                  |L8.228|
0000e4  2000              MOVS     r0,#0                 ;246
0000e6  e793              B        |L8.16|
;;;248    
                          ENDP

                  |L8.232|
                          DCD      LPS25HB_SlaveAddress

                          AREA ||i.LPS25HB_PowerOff||, CODE, READONLY, ALIGN=2

                  LPS25HB_PowerOff PROC
;;;487     */
;;;488    static PRESSURE_StatusTypeDef LPS25HB_PowerOff(void)
000000  b508              PUSH     {r3,lr}
;;;489    {
;;;490        uint8_t tmpreg;
;;;491    
;;;492        /* Read the register content */
;;;493        if(LPS25HB_IO_Read(&tmpreg, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG1_ADDR, 1) != PRESSURE_OK)
000002  2301              MOVS     r3,#1
000004  2220              MOVS     r2,#0x20
000006  480c              LDR      r0,|L9.56|
000008  7801              LDRB     r1,[r0,#0]  ; LPS25HB_SlaveAddress
00000a  4668              MOV      r0,sp
00000c  f7fffffe          BL       LPS25HB_IO_Read
000010  b108              CBZ      r0,|L9.22|
;;;494        {
;;;495          return PRESSURE_ERROR;
000012  2001              MOVS     r0,#1
                  |L9.20|
;;;496        }
;;;497    
;;;498        /* Reset the power down bit */
;;;499        tmpreg &= ~(LPS25HB_MODE_ACTIVE);
;;;500    
;;;501        /* Write register */
;;;502        if(LPS25HB_IO_Write(&tmpreg, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG1_ADDR, 1) != PRESSURE_OK)
;;;503        {
;;;504          return PRESSURE_ERROR;
;;;505        }
;;;506        
;;;507        return PRESSURE_OK;
;;;508    }
000014  bd08              POP      {r3,pc}
                  |L9.22|
000016  f89d0000          LDRB     r0,[sp,#0]            ;499
00001a  f0200080          BIC      r0,r0,#0x80           ;499
00001e  9000              STR      r0,[sp,#0]            ;499
000020  2301              MOVS     r3,#1                 ;502
000022  2220              MOVS     r2,#0x20              ;502
000024  4804              LDR      r0,|L9.56|
000026  7801              LDRB     r1,[r0,#0]            ;502  ; LPS25HB_SlaveAddress
000028  4668              MOV      r0,sp                 ;502
00002a  f7fffffe          BL       LPS25HB_IO_Write
00002e  b108              CBZ      r0,|L9.52|
000030  2001              MOVS     r0,#1                 ;504
000032  e7ef              B        |L9.20|
                  |L9.52|
000034  2000              MOVS     r0,#0                 ;507
000036  e7ed              B        |L9.20|
;;;509    
                          ENDP

                  |L9.56|
                          DCD      LPS25HB_SlaveAddress

                          AREA ||i.LPS25HB_PowerOn||, CODE, READONLY, ALIGN=2

                  LPS25HB_PowerOn PROC
;;;459     */
;;;460    static PRESSURE_StatusTypeDef LPS25HB_PowerOn(void)
000000  b508              PUSH     {r3,lr}
;;;461    {
;;;462        uint8_t tmpreg;
;;;463    
;;;464        /* Read the register content */
;;;465        if(LPS25HB_IO_Read(&tmpreg, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG1_ADDR, 1) != PRESSURE_OK)
000002  2301              MOVS     r3,#1
000004  2220              MOVS     r2,#0x20
000006  480c              LDR      r0,|L10.56|
000008  7801              LDRB     r1,[r0,#0]  ; LPS25HB_SlaveAddress
00000a  4668              MOV      r0,sp
00000c  f7fffffe          BL       LPS25HB_IO_Read
000010  b108              CBZ      r0,|L10.22|
;;;466        {
;;;467          return PRESSURE_ERROR;
000012  2001              MOVS     r0,#1
                  |L10.20|
;;;468        }
;;;469    
;;;470        /* Set the power down bit */
;;;471        tmpreg |= LPS25HB_MODE_ACTIVE;
;;;472    
;;;473        /* Write register */
;;;474        if(LPS25HB_IO_Write(&tmpreg, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG1_ADDR, 1) != PRESSURE_OK)
;;;475        {
;;;476          return PRESSURE_ERROR;
;;;477        }
;;;478        
;;;479        return PRESSURE_OK;
;;;480    }
000014  bd08              POP      {r3,pc}
                  |L10.22|
000016  f89d0000          LDRB     r0,[sp,#0]            ;471
00001a  f0400080          ORR      r0,r0,#0x80           ;471
00001e  9000              STR      r0,[sp,#0]            ;471
000020  2301              MOVS     r3,#1                 ;474
000022  2220              MOVS     r2,#0x20              ;474
000024  4804              LDR      r0,|L10.56|
000026  7801              LDRB     r1,[r0,#0]            ;474  ; LPS25HB_SlaveAddress
000028  4668              MOV      r0,sp                 ;474
00002a  f7fffffe          BL       LPS25HB_IO_Write
00002e  b108              CBZ      r0,|L10.52|
000030  2001              MOVS     r0,#1                 ;476
000032  e7ef              B        |L10.20|
                  |L10.52|
000034  2000              MOVS     r0,#0                 ;479
000036  e7ed              B        |L10.20|
;;;481    
                          ENDP

                  |L10.56|
                          DCD      LPS25HB_SlaveAddress

                          AREA ||i.LPS25HB_ReadID||, CODE, READONLY, ALIGN=2

                  LPS25HB_ReadID PROC
;;;253     */
;;;254    static PRESSURE_StatusTypeDef LPS25HB_ReadID(uint8_t *p_id)
000000  b510              PUSH     {r4,lr}
;;;255    {
000002  4604              MOV      r4,r0
;;;256        if(!p_id)
000004  b90c              CBNZ     r4,|L11.10|
;;;257        { 
;;;258          return PRESSURE_ERROR;
000006  2001              MOVS     r0,#1
                  |L11.8|
;;;259        }
;;;260     
;;;261        return LPS25HB_IO_Read(p_id, LPS25HB_SlaveAddress, LPS25HB_WHO_AM_I_ADDR, 1);
;;;262    }
000008  bd10              POP      {r4,pc}
                  |L11.10|
00000a  2301              MOVS     r3,#1                 ;261
00000c  220f              MOVS     r2,#0xf               ;261
00000e  4803              LDR      r0,|L11.28|
000010  7801              LDRB     r1,[r0,#0]            ;261  ; LPS25HB_SlaveAddress
000012  4620              MOV      r0,r4                 ;261
000014  f7fffffe          BL       LPS25HB_IO_Read
000018  e7f6              B        |L11.8|
;;;263    
                          ENDP

00001a  0000              DCW      0x0000
                  |L11.28|
                          DCD      LPS25HB_SlaveAddress

                          AREA ||i.LPS25HB_RebootCmd||, CODE, READONLY, ALIGN=2

                  LPS25HB_RebootCmd PROC
;;;268     */
;;;269    static PRESSURE_StatusTypeDef LPS25HB_RebootCmd(void)
000000  b508              PUSH     {r3,lr}
;;;270    {
;;;271        uint8_t tmpreg;
;;;272    
;;;273        /* Read CTRL_REG5 register */
;;;274        if(LPS25HB_IO_Read(&tmpreg, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG2_ADDR, 1) != PRESSURE_OK)
000002  2301              MOVS     r3,#1
000004  2221              MOVS     r2,#0x21
000006  480c              LDR      r0,|L12.56|
000008  7801              LDRB     r1,[r0,#0]  ; LPS25HB_SlaveAddress
00000a  4668              MOV      r0,sp
00000c  f7fffffe          BL       LPS25HB_IO_Read
000010  b108              CBZ      r0,|L12.22|
;;;275        {
;;;276          return PRESSURE_ERROR;
000012  2001              MOVS     r0,#1
                  |L12.20|
;;;277        }
;;;278    
;;;279        /* Enable or Disable the reboot memory */
;;;280        tmpreg |= LPS25HB_RESET_MEMORY;
;;;281    
;;;282        /* Write value to MEMS CTRL_REG5 regsister */
;;;283        if(LPS25HB_IO_Write(&tmpreg, LPS25HB_SlaveAddress, LPS25HB_CTRL_REG2_ADDR, 1) != PRESSURE_OK)
;;;284        {
;;;285          return PRESSURE_ERROR;
;;;286        }
;;;287        
;;;288        return PRESSURE_OK;
;;;289    }
000014  bd08              POP      {r3,pc}
                  |L12.22|
000016  f89d0000          LDRB     r0,[sp,#0]            ;280
00001a  f0400080          ORR      r0,r0,#0x80           ;280
00001e  9000              STR      r0,[sp,#0]            ;280
000020  2301              MOVS     r3,#1                 ;283
000022  2221              MOVS     r2,#0x21              ;283
000024  4804              LDR      r0,|L12.56|
000026  7801              LDRB     r1,[r0,#0]            ;283  ; LPS25HB_SlaveAddress
000028  4668              MOV      r0,sp                 ;283
00002a  f7fffffe          BL       LPS25HB_IO_Write
00002e  b108              CBZ      r0,|L12.52|
000030  2001              MOVS     r0,#1                 ;285
000032  e7ef              B        |L12.20|
                  |L12.52|
000034  2000              MOVS     r0,#0                 ;288
000036  e7ed              B        |L12.20|
;;;290    
                          ENDP

                  |L12.56|
                          DCD      LPS25HB_SlaveAddress

                          AREA ||i.LPS25HB_SlaveAddrRemap||, CODE, READONLY, ALIGN=2

                  LPS25HB_SlaveAddrRemap PROC
;;;514     */
;;;515    static void LPS25HB_SlaveAddrRemap(uint8_t SA0_Bit_Status)
000000  b908              CBNZ     r0,|L13.6|
;;;516    {
;;;517        LPS25HB_SlaveAddress = (SA0_Bit_Status==LPS25HB_SA0_LOW?LPS25HB_ADDRESS_LOW:LPS25HB_ADDRESS_HIGH);
000002  21b8              MOVS     r1,#0xb8
000004  e000              B        |L13.8|
                  |L13.6|
000006  21ba              MOVS     r1,#0xba
                  |L13.8|
000008  4a01              LDR      r2,|L13.16|
00000a  7011              STRB     r1,[r2,#0]
;;;518    }
00000c  4770              BX       lr
;;;519    
                          ENDP

00000e  0000              DCW      0x0000
                  |L13.16|
                          DCD      LPS25HB_SlaveAddress

                          AREA ||i.lps25hb_Read_Data||, CODE, READONLY, ALIGN=1

                  lps25hb_Read_Data PROC
;;;539    
;;;540    OSStatus lps25hb_Read_Data(float *temperature,float *pressure)
000000  b570              PUSH     {r4-r6,lr}
;;;541    {
000002  4605              MOV      r5,r0
000004  460c              MOV      r4,r1
;;;542      if(LPS25HB_GetTemperature(temperature) != PRESSURE_OK){
000006  4628              MOV      r0,r5
000008  f7fffffe          BL       LPS25HB_GetTemperature
00000c  b110              CBZ      r0,|L14.20|
;;;543        return -1;
00000e  f04f30ff          MOV      r0,#0xffffffff
                  |L14.18|
;;;544      }
;;;545      if(LPS25HB_GetPressure(pressure) != PRESSURE_OK){
;;;546        return -1;
;;;547      }
;;;548      return 0;
;;;549    }
000012  bd70              POP      {r4-r6,pc}
                  |L14.20|
000014  4620              MOV      r0,r4                 ;545
000016  f7fffffe          BL       LPS25HB_GetPressure
00001a  b110              CBZ      r0,|L14.34|
00001c  f04f30ff          MOV      r0,#0xffffffff        ;546
000020  e7f7              B        |L14.18|
                  |L14.34|
000022  2000              MOVS     r0,#0                 ;548
000024  e7f5              B        |L14.18|
;;;550    
                          ENDP


                          AREA ||i.lps25hb_sensor_deinit||, CODE, READONLY, ALIGN=2

                  lps25hb_sensor_deinit PROC
;;;550    
;;;551    OSStatus lps25hb_sensor_deinit(void)
000000  b510              PUSH     {r4,lr}
;;;552    {
;;;553      if(LPS25HB_PowerOff() != PRESSURE_OK){
000002  f7fffffe          BL       LPS25HB_PowerOff
000006  b110              CBZ      r0,|L15.14|
;;;554        return -1;
000008  f04f30ff          MOV      r0,#0xffffffff
                  |L15.12|
;;;555      }
;;;556      if(MicoI2cFinalize(&lps25hb_i2c_device) != PRESSURE_OK){
;;;557        return -1;
;;;558      }
;;;559      return 0;
;;;560    }
00000c  bd10              POP      {r4,pc}
                  |L15.14|
00000e  4804              LDR      r0,|L15.32|
000010  f7fffffe          BL       MicoI2cFinalize
000014  b110              CBZ      r0,|L15.28|
000016  f04f30ff          MOV      r0,#0xffffffff        ;557
00001a  e7f7              B        |L15.12|
                  |L15.28|
00001c  2000              MOVS     r0,#0                 ;559
00001e  e7f5              B        |L15.12|
;;;561    
                          ENDP

                  |L15.32|
                          DCD      lps25hb_i2c_device

                          AREA ||i.lps25hb_sensor_init||, CODE, READONLY, ALIGN=1

                  lps25hb_sensor_init PROC
;;;523    
;;;524    OSStatus lps25hb_sensor_init(void)
000000  b51c              PUSH     {r2-r4,lr}
;;;525    {
;;;526      PRESSURE_InitTypeDef lps25hb;
;;;527      lps25hb.OutputDataRate = LPS25HB_ODR_ONE_SHOT;
000002  2000              MOVS     r0,#0
000004  f88d0000          STRB     r0,[sp,#0]
;;;528      lps25hb.PressureResolution = LPS25HB_P_RES_AVG_32;
000008  2001              MOVS     r0,#1
00000a  f88d0001          STRB     r0,[sp,#1]
;;;529      lps25hb.TemperatureResolution = LPS25HB_T_RES_AVG_32;
00000e  2008              MOVS     r0,#8
000010  f88d0002          STRB     r0,[sp,#2]
;;;530      lps25hb.DiffEnable = LPS25HB_DIFF_ENABLE;
000014  f88d0003          STRB     r0,[sp,#3]
;;;531      lps25hb.BlockDataUpdate = LPS25HB_BDU_READ;
000018  2004              MOVS     r0,#4
00001a  f88d0004          STRB     r0,[sp,#4]
;;;532      lps25hb.SPIMode = LPS25HB_SPI_SIM_4W;
00001e  2000              MOVS     r0,#0
000020  f88d0005          STRB     r0,[sp,#5]
;;;533         
;;;534      if(LPS25HB_Init(&lps25hb) != PRESSURE_OK){
000024  4668              MOV      r0,sp
000026  f7fffffe          BL       LPS25HB_Init
00002a  b110              CBZ      r0,|L16.50|
;;;535        return -1;
00002c  f04f30ff          MOV      r0,#0xffffffff
                  |L16.48|
;;;536      }
;;;537      return 0;
;;;538    }
000030  bd1c              POP      {r2-r4,pc}
                  |L16.50|
000032  2000              MOVS     r0,#0                 ;537
000034  e7fc              B        |L16.48|
;;;539    
                          ENDP


                          AREA ||.data||, DATA, ALIGN=2

                  LPS25HBDrv
                          DCD      LPS25HB_Init
                          DCD      LPS25HB_PowerOff
                          DCD      LPS25HB_ReadID
                          DCD      LPS25HB_RebootCmd
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      LPS25HB_GetPressure
                          DCD      LPS25HB_GetTemperature
                          DCD      LPS25HB_SlaveAddrRemap
                          DCD      0x00000000
                  LPS25HBDrv_ext
000034  02000000          DCB      0x02,0x00,0x00,0x00
                          DCD      0x00000000
                  LPS25HB_SlaveAddress
00003c  b800              DCB      0xb8,0x00
                  lps25hb_i2c_device
00003e  0200              DCB      0x02,0x00
000040  005c              DCW      0x005c
000042  0001              DCB      0x00,0x01

;*** Start embedded assembler ***

#line 1 "..\\..\\..\\..\\Platform\\Drivers\\sensor\\LPS25HB\\lps25hb.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___9_lps25hb_c_2fde7131____REV16|
#line 114 "..\\..\\..\\..\\Platform\\Cortex-M4\\CMSIS\\core_cmInstr.h"
|__asm___9_lps25hb_c_2fde7131____REV16| PROC
#line 115

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___9_lps25hb_c_2fde7131____REVSH|
#line 128
|__asm___9_lps25hb_c_2fde7131____REVSH| PROC
#line 129

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
