; generated by ARM C/C++ Compiler, 5.03 [Build 24]
; commandline ArmCC [--list --debug -c --asm --interleave -oobj\hldi_rom.o --asm_dir=.\Lst\ --list_dir=.\Lst\ --cpu=Cortex-M3 --apcs=interwork -O0 -I\DEVELOP\BIN\Keil\ARM\STARTUP\ST\STM32F10x -I\DEVELOP\BIN\Keil\ARM\RV31\INC -I\DEVELOP\BIN\Keil\ARM\CMSIS\Include -I\DEVELOP\BIN\Keil\ARM\Inc\ST\STM32F10x -D__MICROLIB -DSTM32F10X_MD hldi.c]
                          THUMB

                          AREA ||.text||, CODE, READONLY, ALIGN=2

                          REQUIRE _printf_pre_padding
                          REQUIRE _printf_percent
                          REQUIRE _printf_widthprec
                          REQUIRE _printf_d
                          REQUIRE _printf_x
                          REQUIRE _printf_int_dec
                          REQUIRE _printf_longlong_hex
                          REQUIRE _scanf_int
                          REQUIRE _scanf_string
                          REQUIRE _printf_p
                  SetSysClockTo72 PROC
;;;986      */
;;;987    static void SetSysClockTo72(void)
000000  b50c              PUSH     {r2,r3,lr}
;;;988    {
;;;989      __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
000002  2000              MOVS     r0,#0
000004  9001              STR      r0,[sp,#4]
000006  9000              STR      r0,[sp,#0]
;;;990      
;;;991      /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/    
;;;992      /* Enable HSE */    
;;;993      RCC->CR |= ((uint32_t)RCC_CR_HSEON);
000008  48f8              LDR      r0,|L1.1004|
00000a  6800              LDR      r0,[r0,#0]
00000c  f4403080          ORR      r0,r0,#0x10000
000010  49f6              LDR      r1,|L1.1004|
000012  6008              STR      r0,[r1,#0]
;;;994     
;;;995      /* Wait till HSE is ready and if Time out is reached exit */
;;;996      do
000014  bf00              NOP      
                  |L1.22|
;;;997      {
;;;998        HSEStatus = RCC->CR & RCC_CR_HSERDY;
000016  48f5              LDR      r0,|L1.1004|
000018  6800              LDR      r0,[r0,#0]
00001a  f4003000          AND      r0,r0,#0x20000
00001e  9000              STR      r0,[sp,#0]
;;;999        StartUpCounter++;  
000020  9801              LDR      r0,[sp,#4]
000022  1c40              ADDS     r0,r0,#1
000024  9001              STR      r0,[sp,#4]
;;;1000     } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
000026  9800              LDR      r0,[sp,#0]
000028  b918              CBNZ     r0,|L1.50|
00002a  9801              LDR      r0,[sp,#4]
00002c  f5b06fa0          CMP      r0,#0x500
000030  d1f1              BNE      |L1.22|
                  |L1.50|
;;;1001   
;;;1002     if ((RCC->CR & RCC_CR_HSERDY) != RESET)
000032  48ee              LDR      r0,|L1.1004|
000034  6800              LDR      r0,[r0,#0]
000036  f4103f00          TST      r0,#0x20000
00003a  d002              BEQ      |L1.66|
;;;1003     {
;;;1004       HSEStatus = (uint32_t)0x01;
00003c  2001              MOVS     r0,#1
00003e  9000              STR      r0,[sp,#0]
000040  e001              B        |L1.70|
                  |L1.66|
;;;1005     }
;;;1006     else
;;;1007     {
;;;1008       HSEStatus = (uint32_t)0x00;
000042  2000              MOVS     r0,#0
000044  9000              STR      r0,[sp,#0]
                  |L1.70|
;;;1009     }  
;;;1010   
;;;1011     if (HSEStatus == (uint32_t)0x01)
000046  9800              LDR      r0,[sp,#0]
000048  2801              CMP      r0,#1
00004a  d142              BNE      |L1.210|
;;;1012     {
;;;1013       /* Enable Prefetch Buffer */
;;;1014       FLASH->ACR |= FLASH_ACR_PRFTBE;
00004c  48e8              LDR      r0,|L1.1008|
00004e  6800              LDR      r0,[r0,#0]
000050  f0400010          ORR      r0,r0,#0x10
000054  49e6              LDR      r1,|L1.1008|
000056  6008              STR      r0,[r1,#0]
;;;1015   
;;;1016       /* Flash 2 wait state */
;;;1017       FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
000058  4608              MOV      r0,r1
00005a  6800              LDR      r0,[r0,#0]
00005c  f0200003          BIC      r0,r0,#3
000060  6008              STR      r0,[r1,#0]
;;;1018       FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;    
000062  4608              MOV      r0,r1
000064  6800              LDR      r0,[r0,#0]
000066  f0400002          ORR      r0,r0,#2
00006a  6008              STR      r0,[r1,#0]
;;;1019   
;;;1020    
;;;1021       /* HCLK = SYSCLK */
;;;1022       RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
00006c  48df              LDR      r0,|L1.1004|
00006e  6840              LDR      r0,[r0,#4]
000070  49de              LDR      r1,|L1.1004|
000072  6048              STR      r0,[r1,#4]
;;;1023         
;;;1024       /* PCLK2 = HCLK */
;;;1025       RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
000074  4608              MOV      r0,r1
000076  6840              LDR      r0,[r0,#4]
000078  6048              STR      r0,[r1,#4]
;;;1026       
;;;1027       /* PCLK1 = HCLK */
;;;1028       RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
00007a  4608              MOV      r0,r1
00007c  6840              LDR      r0,[r0,#4]
00007e  f4406080          ORR      r0,r0,#0x400
000082  6048              STR      r0,[r1,#4]
;;;1029   
;;;1030   #ifdef STM32F10X_CL
;;;1031       /* Configure PLLs ------------------------------------------------------*/
;;;1032       /* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
;;;1033       /* PREDIV1 configuration: PREDIV1CLK = PLL2 / 5 = 8 MHz */
;;;1034           
;;;1035       RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
;;;1036                                 RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
;;;1037       RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
;;;1038                                RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV5);
;;;1039     
;;;1040       /* Enable PLL2 */
;;;1041       RCC->CR |= RCC_CR_PLL2ON;
;;;1042       /* Wait till PLL2 is ready */
;;;1043       while((RCC->CR & RCC_CR_PLL2RDY) == 0)
;;;1044       {
;;;1045       }
;;;1046       
;;;1047      
;;;1048       /* PLL configuration: PLLCLK = PREDIV1 * 9 = 72 MHz */ 
;;;1049       RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
;;;1050       RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 | 
;;;1051                               RCC_CFGR_PLLMULL9); 
;;;1052   #else    
;;;1053       /*  PLL configuration: PLLCLK = HSE * 9 = 72 MHz */
;;;1054       RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |
000084  4608              MOV      r0,r1
000086  6840              LDR      r0,[r0,#4]
000088  f420107c          BIC      r0,r0,#0x3f0000
00008c  6048              STR      r0,[r1,#4]
;;;1055                                           RCC_CFGR_PLLMULL));
;;;1056       RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);
00008e  4608              MOV      r0,r1
000090  6840              LDR      r0,[r0,#4]
000092  f44010e8          ORR      r0,r0,#0x1d0000
000096  6048              STR      r0,[r1,#4]
;;;1057   #endif /* STM32F10X_CL */
;;;1058   
;;;1059       /* Enable PLL */
;;;1060       RCC->CR |= RCC_CR_PLLON;
000098  4608              MOV      r0,r1
00009a  6800              LDR      r0,[r0,#0]
00009c  f0407080          ORR      r0,r0,#0x1000000
0000a0  6008              STR      r0,[r1,#0]
;;;1061   
;;;1062       /* Wait till PLL is ready */
;;;1063       while((RCC->CR & RCC_CR_PLLRDY) == 0)
0000a2  bf00              NOP      
                  |L1.164|
0000a4  48d1              LDR      r0,|L1.1004|
0000a6  6800              LDR      r0,[r0,#0]
0000a8  f0107f00          TST      r0,#0x2000000
0000ac  d0fa              BEQ      |L1.164|
;;;1064       {
;;;1065       }
;;;1066       
;;;1067       /* Select PLL as system clock source */
;;;1068       RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
0000ae  48cf              LDR      r0,|L1.1004|
0000b0  6840              LDR      r0,[r0,#4]
0000b2  f0200003          BIC      r0,r0,#3
0000b6  49cd              LDR      r1,|L1.1004|
0000b8  6048              STR      r0,[r1,#4]
;;;1069       RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;    
0000ba  4608              MOV      r0,r1
0000bc  6840              LDR      r0,[r0,#4]
0000be  f0400002          ORR      r0,r0,#2
0000c2  6048              STR      r0,[r1,#4]
;;;1070   
;;;1071       /* Wait till PLL is used as system clock source */
;;;1072       while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
0000c4  bf00              NOP      
                  |L1.198|
0000c6  48c9              LDR      r0,|L1.1004|
0000c8  6840              LDR      r0,[r0,#4]
0000ca  f000000c          AND      r0,r0,#0xc
0000ce  2808              CMP      r0,#8
0000d0  d1f9              BNE      |L1.198|
                  |L1.210|
;;;1073       {
;;;1074       }
;;;1075     }
;;;1076     else
;;;1077     { /* If HSE fails to start-up, the application will have wrong clock 
;;;1078            configuration. User can add here some code to deal with this error */
;;;1079     }
;;;1080   }
0000d2  bd0c              POP      {r2,r3,pc}
;;;1081   #endif
                          ENDP

                  SetSysClock PROC
;;;418      */
;;;419    static void SetSysClock(void)
0000d4  b510              PUSH     {r4,lr}
;;;420    {
;;;421    #ifdef SYSCLK_FREQ_HSE
;;;422      SetSysClockToHSE();
;;;423    #elif defined SYSCLK_FREQ_24MHz
;;;424      SetSysClockTo24();
;;;425    #elif defined SYSCLK_FREQ_36MHz
;;;426      SetSysClockTo36();
;;;427    #elif defined SYSCLK_FREQ_48MHz
;;;428      SetSysClockTo48();
;;;429    #elif defined SYSCLK_FREQ_56MHz
;;;430      SetSysClockTo56();  
;;;431    #elif defined SYSCLK_FREQ_72MHz
;;;432      SetSysClockTo72();
0000d6  f7fffffe          BL       SetSysClockTo72
;;;433    #endif
;;;434     
;;;435     /* If none of the define above is enabled, the HSI is used as System clock
;;;436        source (default after reset) */ 
;;;437    }
0000da  bd10              POP      {r4,pc}
;;;438    
                          ENDP

                  SystemInit PROC
;;;211      */
;;;212    void SystemInit (void)
0000dc  b510              PUSH     {r4,lr}
;;;213    {
;;;214      /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
;;;215      /* Set HSION bit */
;;;216      RCC->CR |= (uint32_t)0x00000001;
0000de  48c3              LDR      r0,|L1.1004|
0000e0  6800              LDR      r0,[r0,#0]
0000e2  f0400001          ORR      r0,r0,#1
0000e6  49c1              LDR      r1,|L1.1004|
0000e8  6008              STR      r0,[r1,#0]
;;;217    
;;;218      /* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
;;;219    #ifndef STM32F10X_CL
;;;220      RCC->CFGR &= (uint32_t)0xF8FF0000;
0000ea  4608              MOV      r0,r1
0000ec  6840              LDR      r0,[r0,#4]
0000ee  49c1              LDR      r1,|L1.1012|
0000f0  4008              ANDS     r0,r0,r1
0000f2  49be              LDR      r1,|L1.1004|
0000f4  6048              STR      r0,[r1,#4]
;;;221    #else
;;;222      RCC->CFGR &= (uint32_t)0xF0FF0000;
;;;223    #endif /* STM32F10X_CL */   
;;;224      
;;;225      /* Reset HSEON, CSSON and PLLON bits */
;;;226      RCC->CR &= (uint32_t)0xFEF6FFFF;
0000f6  4608              MOV      r0,r1
0000f8  6800              LDR      r0,[r0,#0]
0000fa  49bf              LDR      r1,|L1.1016|
0000fc  4008              ANDS     r0,r0,r1
0000fe  49bb              LDR      r1,|L1.1004|
000100  6008              STR      r0,[r1,#0]
;;;227    
;;;228      /* Reset HSEBYP bit */
;;;229      RCC->CR &= (uint32_t)0xFFFBFFFF;
000102  4608              MOV      r0,r1
000104  6800              LDR      r0,[r0,#0]
000106  f4202080          BIC      r0,r0,#0x40000
00010a  6008              STR      r0,[r1,#0]
;;;230    
;;;231      /* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
;;;232      RCC->CFGR &= (uint32_t)0xFF80FFFF;
00010c  4608              MOV      r0,r1
00010e  6840              LDR      r0,[r0,#4]
000110  f42000fe          BIC      r0,r0,#0x7f0000
000114  6048              STR      r0,[r1,#4]
;;;233    
;;;234    #ifdef STM32F10X_CL
;;;235      /* Reset PLL2ON and PLL3ON bits */
;;;236      RCC->CR &= (uint32_t)0xEBFFFFFF;
;;;237    
;;;238      /* Disable all interrupts and clear pending bits  */
;;;239      RCC->CIR = 0x00FF0000;
;;;240    
;;;241      /* Reset CFGR2 register */
;;;242      RCC->CFGR2 = 0x00000000;
;;;243    #elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
;;;244      /* Disable all interrupts and clear pending bits  */
;;;245      RCC->CIR = 0x009F0000;
;;;246    
;;;247      /* Reset CFGR2 register */
;;;248      RCC->CFGR2 = 0x00000000;      
;;;249    #else
;;;250      /* Disable all interrupts and clear pending bits  */
;;;251      RCC->CIR = 0x009F0000;
000116  f44f001f          MOV      r0,#0x9f0000
00011a  6088              STR      r0,[r1,#8]
;;;252    #endif /* STM32F10X_CL */
;;;253        
;;;254    #if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)
;;;255      #ifdef DATA_IN_ExtSRAM
;;;256        SystemInit_ExtMemCtl(); 
;;;257      #endif /* DATA_IN_ExtSRAM */
;;;258    #endif 
;;;259    
;;;260      /* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
;;;261      /* Configure the Flash Latency cycles and enable prefetch buffer */
;;;262      SetSysClock();
00011c  f7fffffe          BL       SetSysClock
;;;263    
;;;264    #ifdef VECT_TAB_SRAM
;;;265      SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. */
;;;266    #else
;;;267      SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. */
000120  f04f6000          MOV      r0,#0x8000000
000124  49b5              LDR      r1,|L1.1020|
000126  6008              STR      r0,[r1,#0]
;;;268    #endif 
;;;269    }
000128  bd10              POP      {r4,pc}
;;;270    
                          ENDP

                  SystemCoreClockUpdate PROC
;;;305      */
;;;306    void SystemCoreClockUpdate (void)
00012a  b510              PUSH     {r4,lr}
;;;307    {
;;;308      uint32_t tmp = 0, pllmull = 0, pllsource = 0;
00012c  2100              MOVS     r1,#0
00012e  2000              MOVS     r0,#0
000130  2200              MOVS     r2,#0
;;;309    
;;;310    #ifdef  STM32F10X_CL
;;;311      uint32_t prediv1source = 0, prediv1factor = 0, prediv2factor = 0, pll2mull = 0;
;;;312    #endif /* STM32F10X_CL */
;;;313    
;;;314    #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
;;;315      uint32_t prediv1factor = 0;
;;;316    #endif /* STM32F10X_LD_VL or STM32F10X_MD_VL or STM32F10X_HD_VL */
;;;317        
;;;318      /* Get SYSCLK source -------------------------------------------------------*/
;;;319      tmp = RCC->CFGR & RCC_CFGR_SWS;
000132  4bae              LDR      r3,|L1.1004|
000134  685b              LDR      r3,[r3,#4]
000136  f003010c          AND      r1,r3,#0xc
;;;320      
;;;321      switch (tmp)
00013a  b121              CBZ      r1,|L1.326|
00013c  2904              CMP      r1,#4
00013e  d006              BEQ      |L1.334|
000140  2908              CMP      r1,#8
000142  d128              BNE      |L1.406|
000144  e007              B        |L1.342|
                  |L1.326|
;;;322      {
;;;323        case 0x00:  /* HSI used as system clock */
;;;324          SystemCoreClock = HSI_VALUE;
000146  4bae              LDR      r3,|L1.1024|
000148  4cae              LDR      r4,|L1.1028|
00014a  6023              STR      r3,[r4,#0]  ; SystemCoreClock
;;;325          break;
00014c  e027              B        |L1.414|
                  |L1.334|
;;;326        case 0x04:  /* HSE used as system clock */
;;;327          SystemCoreClock = HSE_VALUE;
00014e  4bac              LDR      r3,|L1.1024|
000150  4cac              LDR      r4,|L1.1028|
000152  6023              STR      r3,[r4,#0]  ; SystemCoreClock
;;;328          break;
000154  e023              B        |L1.414|
                  |L1.342|
;;;329        case 0x08:  /* PLL used as system clock */
;;;330    
;;;331          /* Get PLL clock source and multiplication factor ----------------------*/
;;;332          pllmull = RCC->CFGR & RCC_CFGR_PLLMULL;
000156  4ba5              LDR      r3,|L1.1004|
000158  685b              LDR      r3,[r3,#4]
00015a  f4031070          AND      r0,r3,#0x3c0000
;;;333          pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
00015e  4ba3              LDR      r3,|L1.1004|
000160  685b              LDR      r3,[r3,#4]
000162  f4033280          AND      r2,r3,#0x10000
;;;334          
;;;335    #ifndef STM32F10X_CL      
;;;336          pllmull = ( pllmull >> 18) + 2;
000166  2302              MOVS     r3,#2
000168  eb034090          ADD      r0,r3,r0,LSR #18
;;;337          
;;;338          if (pllsource == 0x00)
00016c  b922              CBNZ     r2,|L1.376|
;;;339          {
;;;340            /* HSI oscillator clock divided by 2 selected as PLL clock entry */
;;;341            SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
00016e  4ba6              LDR      r3,|L1.1032|
000170  4343              MULS     r3,r0,r3
000172  4ca4              LDR      r4,|L1.1028|
000174  6023              STR      r3,[r4,#0]  ; SystemCoreClock
000176  e00d              B        |L1.404|
                  |L1.376|
;;;342          }
;;;343          else
;;;344          {
;;;345     #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
;;;346           prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;
;;;347           /* HSE oscillator clock selected as PREDIV1 clock entry */
;;;348           SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull; 
;;;349     #else
;;;350            /* HSE selected as PLL clock entry */
;;;351            if ((RCC->CFGR & RCC_CFGR_PLLXTPRE) != (uint32_t)RESET)
000178  4b9c              LDR      r3,|L1.1004|
00017a  685b              LDR      r3,[r3,#4]
00017c  f4133f00          TST      r3,#0x20000
000180  d004              BEQ      |L1.396|
;;;352            {/* HSE oscillator clock divided by 2 */
;;;353              SystemCoreClock = (HSE_VALUE >> 1) * pllmull;
000182  4ba1              LDR      r3,|L1.1032|
000184  4343              MULS     r3,r0,r3
000186  4c9f              LDR      r4,|L1.1028|
000188  6023              STR      r3,[r4,#0]  ; SystemCoreClock
00018a  e003              B        |L1.404|
                  |L1.396|
;;;354            }
;;;355            else
;;;356            {
;;;357              SystemCoreClock = HSE_VALUE * pllmull;
00018c  4b9c              LDR      r3,|L1.1024|
00018e  4343              MULS     r3,r0,r3
000190  4c9c              LDR      r4,|L1.1028|
000192  6023              STR      r3,[r4,#0]  ; SystemCoreClock
                  |L1.404|
;;;358            }
;;;359     #endif
;;;360          }
;;;361    #else
;;;362          pllmull = pllmull >> 18;
;;;363          
;;;364          if (pllmull != 0x0D)
;;;365          {
;;;366             pllmull += 2;
;;;367          }
;;;368          else
;;;369          { /* PLL multiplication factor = PLL input clock * 6.5 */
;;;370            pllmull = 13 / 2; 
;;;371          }
;;;372                
;;;373          if (pllsource == 0x00)
;;;374          {
;;;375            /* HSI oscillator clock divided by 2 selected as PLL clock entry */
;;;376            SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
;;;377          }
;;;378          else
;;;379          {/* PREDIV1 selected as PLL clock entry */
;;;380            
;;;381            /* Get PREDIV1 clock source and division factor */
;;;382            prediv1source = RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC;
;;;383            prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;
;;;384            
;;;385            if (prediv1source == 0)
;;;386            { 
;;;387              /* HSE oscillator clock selected as PREDIV1 clock entry */
;;;388              SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull;          
;;;389            }
;;;390            else
;;;391            {/* PLL2 clock selected as PREDIV1 clock entry */
;;;392              
;;;393              /* Get PREDIV2 division factor and PLL2 multiplication factor */
;;;394              prediv2factor = ((RCC->CFGR2 & RCC_CFGR2_PREDIV2) >> 4) + 1;
;;;395              pll2mull = ((RCC->CFGR2 & RCC_CFGR2_PLL2MUL) >> 8 ) + 2; 
;;;396              SystemCoreClock = (((HSE_VALUE / prediv2factor) * pll2mull) / prediv1factor) * pllmull;                         
;;;397            }
;;;398          }
;;;399    #endif /* STM32F10X_CL */ 
;;;400          break;
000194  e003              B        |L1.414|
                  |L1.406|
;;;401    
;;;402        default:
;;;403          SystemCoreClock = HSI_VALUE;
000196  4b9a              LDR      r3,|L1.1024|
000198  4c9a              LDR      r4,|L1.1028|
00019a  6023              STR      r3,[r4,#0]  ; SystemCoreClock
;;;404          break;
00019c  bf00              NOP      
                  |L1.414|
00019e  bf00              NOP                            ;325
;;;405      }
;;;406      
;;;407      /* Compute HCLK clock frequency ----------------*/
;;;408      /* Get HCLK prescaler */
;;;409      tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
0001a0  4b92              LDR      r3,|L1.1004|
0001a2  685b              LDR      r3,[r3,#4]
0001a4  f3c31303          UBFX     r3,r3,#4,#4
0001a8  4c98              LDR      r4,|L1.1036|
0001aa  5ce1              LDRB     r1,[r4,r3]
;;;410      /* HCLK clock frequency */
;;;411      SystemCoreClock >>= tmp;  
0001ac  4b95              LDR      r3,|L1.1028|
0001ae  681b              LDR      r3,[r3,#0]  ; SystemCoreClock
0001b0  40cb              LSRS     r3,r3,r1
0001b2  4c94              LDR      r4,|L1.1028|
0001b4  6023              STR      r3,[r4,#0]  ; SystemCoreClock
;;;412    }
0001b6  bd10              POP      {r4,pc}
;;;413    
                          ENDP

                  CalcStepX PROC
;;;69     
;;;70     int CalcStepX(int pos){				//        POS.
0001b8  4601              MOV      r1,r0
;;;71     // ----------------------------------------------
;;;72     //printf("\r\n>w");
;;;73     	return((pos*2*ResolX/UnitX+1)/2);
0001ba  0048              LSLS     r0,r1,#1
0001bc  f44f7316          MOV      r3,#0x258
0001c0  4358              MULS     r0,r3,r0
0001c2  f24623fb          MOV      r3,#0x62fb
0001c6  fb90f0f3          SDIV     r0,r0,r3
0001ca  1c42              ADDS     r2,r0,#1
0001cc  eb0270d2          ADD      r0,r2,r2,LSR #31
0001d0  1040              ASRS     r0,r0,#1
;;;74     } // --------------------------------------------
0001d2  4770              BX       lr
;;;75     int CalcStepY(int pos){				//        POS.
                          ENDP

                  CalcStepY PROC
0001d4  4601              MOV      r1,r0
;;;76     // ----------------------------------------------
;;;77     //printf("\r\n>w");
;;;78     	return((pos*2*ResolY/UnitY+1)/2);
0001d6  0048              LSLS     r0,r1,#1
0001d8  f44f73c8          MOV      r3,#0x190
0001dc  4358              MULS     r0,r3,r0
0001de  f44f737a          MOV      r3,#0x3e8
0001e2  fb90f0f3          SDIV     r0,r0,r3
0001e6  1c42              ADDS     r2,r0,#1
0001e8  eb0270d2          ADD      r0,r2,r2,LSR #31
0001ec  1040              ASRS     r0,r0,#1
;;;79     } // --------------------------------------------
0001ee  4770              BX       lr
;;;11     #include "src\comport.c"
                          ENDP

                  SER_Init1 PROC
;;;10     //_______________________________________________
;;;11     void SER_Init1 (void) {
0001f0  4887              LDR      r0,|L1.1040|
;;;12     //-----------------------------------------------
;;;13       AFIO->MAPR &=~AFIO_MAPR_USART1_REMAP;		// clear USART1 remap (PA9, PA10)
0001f2  6840              LDR      r0,[r0,#4]
0001f4  f0200004          BIC      r0,r0,#4
0001f8  4985              LDR      r1,|L1.1040|
0001fa  6048              STR      r0,[r1,#4]
;;;14     
;;;15       portRS1_CR &=~(GPIO_CRH_CNF10|GPIO_CRH_MODE10
0001fc  4885              LDR      r0,|L1.1044|
0001fe  6800              LDR      r0,[r0,#0]
000200  f420607f          BIC      r0,r0,#0xff0
000204  4983              LDR      r1,|L1.1044|
000206  6008              STR      r0,[r1,#0]
;;;16     		|GPIO_CRH_CNF9 |GPIO_CRH_MODE9 );// clear PA9, PA10
;;;17       
;;;18       set_IO_CR(portRS1,pinTx1,p_a_p50);		// USART1 Tx (PA9) output push-pull
000208  4608              MOV      r0,r1
00020a  6800              LDR      r0,[r0,#0]
00020c  f04000b0          ORR      r0,r0,#0xb0
000210  6008              STR      r0,[r1,#0]
;;;19       set_IO_CR(portRS1,pinRx1,p_i_f);		// USART1 Rx (PA10) output push-pull
000212  4608              MOV      r0,r1
000214  6800              LDR      r0,[r0,#0]
000216  f4406080          ORR      r0,r0,#0x400
00021a  6008              STR      r0,[r1,#0]
;;;20     
;;;21       RCC->APB2ENR |=  RCC_APB2ENR_USART1EN;	// enable USART1 clock
00021c  4873              LDR      r0,|L1.1004|
00021e  6980              LDR      r0,[r0,#0x18]
000220  f4404080          ORR      r0,r0,#0x4000
000224  4971              LDR      r1,|L1.1004|
000226  6188              STR      r0,[r1,#0x18]
;;;22     
;;;23       USART1->CR1   = USART_CR1_RE|USART_CR1_TE;//|USART_CR1_RXNEIE;	// enable RX, TX, IRQ
000228  200c              MOVS     r0,#0xc
00022a  497b              LDR      r1,|L1.1048|
00022c  8008              STRH     r0,[r1,#0]
;;;24       USART1->CR2   = 0x0000;
00022e  2000              MOVS     r0,#0
000230  1d09              ADDS     r1,r1,#4
000232  8008              STRH     r0,[r1,#0]
;;;25       USART1->CR3   = 0x0000;			// no flow control
000234  1d09              ADDS     r1,r1,#4
000236  8008              STRH     r0,[r1,#0]
;;;26       USART1->BRR   = MCK/FREQ_RS1;			// baudrate
000238  f2402071          MOV      r0,#0x271
00023c  4976              LDR      r1,|L1.1048|
00023e  1f09              SUBS     r1,r1,#4
000240  8008              STRH     r0,[r1,#0]
;;;27     
;;;28       USART1->CR1  |= USART_CR1_UE;			// Enable USART
000242  1d08              ADDS     r0,r1,#4
000244  8800              LDRH     r0,[r0,#0]
000246  f4405000          ORR      r0,r0,#0x2000
00024a  1d09              ADDS     r1,r1,#4
00024c  8008              STRH     r0,[r1,#0]
;;;29     }//______________________________________________
00024e  4770              BX       lr
;;;30     __inline void SER_WriteChar(char c){
                          ENDP

                  SER_CheckCharRx PROC
;;;35     }//______________________________________________
;;;36     int SER_CheckCharRx (void) {
000250  4871              LDR      r0,|L1.1048|
;;;37     	return ((USART1->SR & USART_SR_RXNE)>>5);
000252  380c              SUBS     r0,r0,#0xc
000254  8800              LDRH     r0,[r0,#0]
000256  f3c01040          UBFX     r0,r0,#5,#1
;;;38     }//______________________________________________
00025a  4770              BX       lr
;;;39     int SER_CheckCharTx (void) {
                          ENDP

                  SER_CheckCharTx PROC
00025c  486e              LDR      r0,|L1.1048|
;;;40     	return ((USART1->SR & USART_SR_TXE)>>7);
00025e  380c              SUBS     r0,r0,#0xc
000260  8800              LDRH     r0,[r0,#0]
000262  f3c010c0          UBFX     r0,r0,#7,#1
;;;41     }//______________________________________________
000266  4770              BX       lr
;;;42     char SER_PutChar (char c) {
                          ENDP

                  SER_PutChar PROC
000268  b500              PUSH     {lr}
00026a  4601              MOV      r1,r0
;;;43     
;;;44     	while (!(SER_CheckCharTx()));
00026c  bf00              NOP      
                  |L1.622|
00026e  f7fffffe          BL       SER_CheckCharTx
000272  2800              CMP      r0,#0
000274  d0fb              BEQ      |L1.622|
;;;45     	SER_WriteChar(c); return (c);
000276  bf00              NOP      
000278  4867              LDR      r0,|L1.1048|
00027a  3808              SUBS     r0,r0,#8
00027c  8001              STRH     r1,[r0,#0]
00027e  bf00              NOP      
000280  4608              MOV      r0,r1
;;;46     }//______________________________________________
000282  bd00              POP      {pc}
;;;47     char SER_GetChar (void) {
                          ENDP

                  SER_GetChar PROC
000284  b500              PUSH     {lr}
;;;48     
;;;49     	while (!(SER_CheckCharRx()));
000286  bf00              NOP      
                  |L1.648|
000288  f7fffffe          BL       SER_CheckCharRx
00028c  2800              CMP      r0,#0
00028e  d0fb              BEQ      |L1.648|
;;;50     	return SER_ReadChar();
000290  bf00              NOP      
000292  4861              LDR      r0,|L1.1048|
000294  3808              SUBS     r0,r0,#8
000296  8800              LDRH     r0,[r0,#0]
000298  b2c0              UXTB     r0,r0
;;;51     }//______________________________________________
00029a  bd00              POP      {pc}
;;;52     void WRITE_TO_COM(char *ptr,uint cnt){		//    COM .
                          ENDP

                  WRITE_TO_COM PROC
00029c  b510              PUSH     {r4,lr}
00029e  4603              MOV      r3,r0
0002a0  460c              MOV      r4,r1
;;;53     int i;
;;;54      for	(i=0; i<cnt; i++)			//    .
0002a2  2200              MOVS     r2,#0
0002a4  e003              B        |L1.686|
                  |L1.678|
;;;55      {
;;;56     	SER_PutChar(ptr[i]);			// 
0002a6  5c98              LDRB     r0,[r3,r2]
0002a8  f7fffffe          BL       SER_PutChar
0002ac  1c52              ADDS     r2,r2,#1              ;54
                  |L1.686|
0002ae  42a2              CMP      r2,r4                 ;54
0002b0  d3f9              BCC      |L1.678|
;;;57      }	 
;;;58     }//______________________________________________
0002b2  bd10              POP      {r4,pc}
;;;59     void READ_FROM_COM(char *ptr,uint cnt){		//    COM .
                          ENDP

                  READ_FROM_COM PROC
0002b4  b500              PUSH     {lr}
0002b6  4602              MOV      r2,r0
0002b8  460b              MOV      r3,r1
;;;60     int i;
;;;61      for (i=0; i<cnt; i++)				//    .
0002ba  2100              MOVS     r1,#0
0002bc  e003              B        |L1.710|
                  |L1.702|
;;;62      {
;;;63     	ptr[i]=SER_GetChar();			//   .
0002be  f7fffffe          BL       SER_GetChar
0002c2  5450              STRB     r0,[r2,r1]
0002c4  1c49              ADDS     r1,r1,#1              ;61
                  |L1.710|
0002c6  4299              CMP      r1,r3                 ;61
0002c8  d3f9              BCC      |L1.702|
;;;64      }
;;;65     }//______________________________________________
0002ca  bd00              POP      {pc}
;;;66     void ASK (){					//  .   "c"
                          ENDP

                  ASK PROC
0002cc  b500              PUSH     {lr}
;;;67     // ----------------------------------------------
;;;68     	SER_PutChar(13);			//   .
0002ce  200d              MOVS     r0,#0xd
0002d0  f7fffffe          BL       SER_PutChar
;;;69     }//______________________________________________
0002d4  bd00              POP      {pc}
;;;70     #endif	// __comport_c__
                          ENDP

                  fputc PROC
;;;31     
;;;32     int fputc(int c, FILE *f) {
0002d6  b500              PUSH     {lr}
0002d8  4602              MOV      r2,r0
0002da  460b              MOV      r3,r1
;;;33       if (c == '\n')  {
0002dc  2a0a              CMP      r2,#0xa
0002de  d102              BNE      |L1.742|
;;;34         SER_PutChar('\r');
0002e0  200d              MOVS     r0,#0xd
0002e2  f7fffffe          BL       SER_PutChar
                  |L1.742|
;;;35       }
;;;36       return (SER_PutChar(c));
0002e6  b2d0              UXTB     r0,r2
0002e8  f7fffffe          BL       SER_PutChar
;;;37     }
0002ec  bd00              POP      {pc}
;;;38     
                          ENDP

                  fgetc PROC
;;;39     
;;;40     int fgetc(FILE *f) {
0002ee  b500              PUSH     {lr}
0002f0  4603              MOV      r3,r0
;;;41       return (SER_PutChar(SER_GetChar()));
0002f2  f7fffffe          BL       SER_GetChar
0002f6  4602              MOV      r2,r0
0002f8  f7fffffe          BL       SER_PutChar
;;;42     }
0002fc  bd00              POP      {pc}
;;;43     
                          ENDP

                  ferror PROC
;;;44     
;;;45     int ferror(FILE *f) {
0002fe  4601              MOV      r1,r0
;;;46       /* Your implementation of ferror */
;;;47       return EOF;
000300  f04f30ff          MOV      r0,#0xffffffff
;;;48     }
000304  4770              BX       lr
;;;49     
                          ENDP

                  _ttywrch PROC
;;;50     
;;;51     void _ttywrch(int c) {
000306  b500              PUSH     {lr}
000308  4602              MOV      r2,r0
;;;52       SER_PutChar(c);
00030a  b2d0              UXTB     r0,r2
00030c  f7fffffe          BL       SER_PutChar
;;;53     }
000310  bd00              POP      {pc}
;;;54     
                          ENDP

                  _sys_exit PROC
;;;55     
;;;56     void _sys_exit(int return_code) {
000312  bf00              NOP      
                  |L1.788|
;;;57     label:  goto label;  /* endless loop */
000314  e7fe              B        |L1.788|
;;;58     }
;;;13     #include "src\step.c"
                          ENDP

                  SetVoltageStep PROC
;;;61     };// ----------------------------------------------
;;;62     void SetVoltageStep(int pos){			//     .
000316  4601              MOV      r1,r0
;;;63     uint	temp=(portSTP->ODR);			//  .
000318  4a3e              LDR      r2,|L1.1044|
00031a  3208              ADDS     r2,r2,#8
00031c  6810              LDR      r0,[r2,#0]
;;;64     
;;;65     	temp=temp&(~mpinSTP);			//  .
00031e  f02000f0          BIC      r0,r0,#0xf0
;;;66     	temp=temp|StepTable[pos&7];		//  .
000322  f0010207          AND      r2,r1,#7
000326  4b3d              LDR      r3,|L1.1052|
000328  f8532022          LDR      r2,[r3,r2,LSL #2]
00032c  4310              ORRS     r0,r0,r2
;;;67     	portSTP->ODR=temp;			//    .
00032e  4a39              LDR      r2,|L1.1044|
000330  3208              ADDS     r2,r2,#8
000332  6010              STR      r0,[r2,#0]
;;;68     } // -------------------------------------------
000334  4770              BX       lr
;;;69     void OffVoltageStep(){				//  -   .
                          ENDP

                  OffVoltageStep PROC
000336  493a              LDR      r1,|L1.1056|
;;;70     uint	temp;
;;;71     	temp=StepTOT;
000338  6808              LDR      r0,[r1,#0]  ; StepTOT
;;;72     if	(temp)					//
00033a  b140              CBZ      r0,|L1.846|
;;;73     {
;;;74     	temp--; StepTOT=temp;			//    -.
00033c  1e40              SUBS     r0,r0,#1
00033e  6008              STR      r0,[r1,#0]  ; StepTOT
;;;75      if	(!temp)					//   0-?
000340  b928              CBNZ     r0,|L1.846|
;;;76      {
;;;77     	temp=(portSTP->ODR);
000342  4934              LDR      r1,|L1.1044|
000344  3108              ADDS     r1,r1,#8
000346  6808              LDR      r0,[r1,#0]
;;;78     	temp=temp&(~mpinSTP);
000348  f02000f0          BIC      r0,r0,#0xf0
;;;79     	portSTP->ODR=temp;			//  .
00034c  6008              STR      r0,[r1,#0]
                  |L1.846|
;;;80     //printf("\r\n voff");
;;;81      }	
;;;82     }
;;;83     } // -------------------------------------------
00034e  4770              BX       lr
;;;84     void SetTimStep(uint val){			//   .
                          ENDP

                  SetTimStep PROC
000350  f04f21e0          MOV      r1,#0xe000e000
;;;85     // ---------------------------------------------	
;;;86     	SysTick->LOAD = val;			//  .
000354  6148              STR      r0,[r1,#0x14]
;;;87     //printf("\r\nT %d",val);
;;;88     } // -------------------------------------------
000356  4770              BX       lr
;;;89     void StepBreak(){				//  .
                          ENDP

                  StepBreak PROC
000358  b500              PUSH     {lr}
;;;90     // ---------------------------------------------	
;;;91     	DirY=0; State&=~ST_MVY;			//   .
00035a  2000              MOVS     r0,#0
00035c  4931              LDR      r1,|L1.1060|
00035e  6008              STR      r0,[r1,#0]  ; DirY
000360  4831              LDR      r0,|L1.1064|
000362  7800              LDRB     r0,[r0,#0]  ; State
000364  f0200002          BIC      r0,r0,#2
000368  492f              LDR      r1,|L1.1064|
00036a  7008              STRB     r0,[r1,#0]
;;;92     	StepCNT=0;				//  =0.
00036c  2000              MOVS     r0,#0
00036e  492f              LDR      r1,|L1.1068|
000370  6008              STR      r0,[r1,#0]  ; StepCNT
;;;93     	StepTOT=STOT;				//  .
000372  f64260e0          MOV      r0,#0x2ee0
000376  492a              LDR      r1,|L1.1056|
000378  6008              STR      r0,[r1,#0]  ; StepTOT
;;;94     	SetTimStep(FT_STEP/FT_OUT);		//   .
00037a  482d              LDR      r0,|L1.1072|
00037c  f7fffffe          BL       SetTimStep
;;;95     	SysTick->VAL=FT_STEP/FT_OUT-1;		//    -.
000380  482b              LDR      r0,|L1.1072|
000382  1e40              SUBS     r0,r0,#1
000384  f04f21e0          MOV      r1,#0xe000e000
000388  6188              STR      r0,[r1,#0x18]
;;;96     //printf("\r\nbreak");
;;;97     } // -------------------------------------------
00038a  bd00              POP      {pc}
;;;98     void AccelStep (int speed){			//   (speed- ).
                          ENDP

                  AccelStep PROC
00038c  4601              MOV      r1,r0
;;;99     // ---------------------------------------------
;;;100    uint temp=AccelPos;				//    .
00038e  4a29              LDR      r2,|L1.1076|
000390  6810              LDR      r0,[r2,#0]  ; AccelPos
;;;101    //SER_PutChar ('+');
;;;102    if (temp<(sizeof(AccelTable)/sizeof(AccelTable[0])))
000392  2816              CMP      r0,#0x16
000394  d20c              BCS      |L1.944|
;;;103     {
;;;104    	temp++; AccelPos=temp;			//    .
000396  1c40              ADDS     r0,r0,#1
000398  6010              STR      r0,[r2,#0]  ; AccelPos
;;;105    	temp=AccelTable[temp];
00039a  4a27              LDR      r2,|L1.1080|
00039c  f8520020          LDR      r0,[r2,r0,LSL #2]
;;;106     if (temp<=speed) cSpeedY=speed;		// cSpeedY=SpeedY;   .
0003a0  4288              CMP      r0,r1
0003a2  d802              BHI      |L1.938|
0003a4  4a25              LDR      r2,|L1.1084|
0003a6  6011              STR      r1,[r2,#0]  ; cSpeedY
0003a8  e006              B        |L1.952|
                  |L1.938|
;;;107     else	cSpeedY=temp;
0003aa  4a24              LDR      r2,|L1.1084|
0003ac  6010              STR      r0,[r2,#0]  ; cSpeedY
0003ae  e003              B        |L1.952|
                  |L1.944|
;;;108     }
;;;109    else  SpeedY=cSpeedY;				// 
0003b0  4a22              LDR      r2,|L1.1084|
0003b2  6812              LDR      r2,[r2,#0]  ; cSpeedY
0003b4  4b22              LDR      r3,|L1.1088|
0003b6  601a              STR      r2,[r3,#0]  ; SpeedY
                  |L1.952|
;;;110    } // -------------------------------------------
0003b8  4770              BX       lr
;;;111    void DeccelStep(int speed){			//  .
                          ENDP

                  DeccelStep PROC
0003ba  b500              PUSH     {lr}
0003bc  4603              MOV      r3,r0
;;;112    // ----------------------------------------------	
;;;113    uint temp=AccelPos;				//    .
0003be  481d              LDR      r0,|L1.1076|
0003c0  6802              LDR      r2,[r0,#0]  ; AccelPos
;;;114    //SER_PutChar ('-');
;;;115    if (temp>0)
0003c2  b162              CBZ      r2,|L1.990|
;;;116     {
;;;117    	temp--; AccelPos=temp;			//    .
0003c4  1e52              SUBS     r2,r2,#1
0003c6  6002              STR      r2,[r0,#0]  ; AccelPos
;;;118    	temp=AccelTable[temp];
0003c8  481b              LDR      r0,|L1.1080|
0003ca  f8502022          LDR      r2,[r0,r2,LSL #2]
;;;119     if (temp>=speed) cSpeedY=speed;		// cSpeedY=SpeedY;   .
0003ce  429a              CMP      r2,r3
0003d0  d302              BCC      |L1.984|
0003d2  481a              LDR      r0,|L1.1084|
0003d4  6003              STR      r3,[r0,#0]  ; cSpeedY
0003d6  e008              B        |L1.1002|
                  |L1.984|
;;;120     else	cSpeedY=temp;
0003d8  4818              LDR      r0,|L1.1084|
0003da  6002              STR      r2,[r0,#0]  ; cSpeedY
0003dc  e005              B        |L1.1002|
                  |L1.990|
;;;121     }
;;;122    else { SpeedY=cSpeedY;	StepBreak(); }		//
0003de  4817              LDR      r0,|L1.1084|
0003e0  6800              LDR      r0,[r0,#0]  ; cSpeedY
0003e2  4917              LDR      r1,|L1.1088|
0003e4  6008              STR      r0,[r1,#0]  ; SpeedY
0003e6  f7fffffe          BL       StepBreak
                  |L1.1002|
;;;123    } // -------------------------------------------
0003ea  bd00              POP      {pc}
                  |L1.1004|
                          DCD      0x40021000
                  |L1.1008|
                          DCD      0x40022000
                  |L1.1012|
                          DCD      0xf8ff0000
                  |L1.1016|
                          DCD      0xfef6ffff
                  |L1.1020|
                          DCD      0xe000ed08
                  |L1.1024|
                          DCD      0x007a1200
                  |L1.1028|
                          DCD      SystemCoreClock
                  |L1.1032|
                          DCD      0x003d0900
                  |L1.1036|
                          DCD      AHBPrescTable
                  |L1.1040|
                          DCD      0x40010000
                  |L1.1044|
                          DCD      0x40010804
                  |L1.1048|
                          DCD      0x4001380c
                  |L1.1052|
                          DCD      StepTable
                  |L1.1056|
                          DCD      StepTOT
                  |L1.1060|
                          DCD      DirY
                  |L1.1064|
                          DCD      State
                  |L1.1068|
                          DCD      StepCNT
                  |L1.1072|
                          DCD      0x00011940
                  |L1.1076|
                          DCD      AccelPos
                  |L1.1080|
                          DCD      AccelTable
                  |L1.1084|
                          DCD      cSpeedY
                  |L1.1088|
                          DCD      SpeedY
                          ENDP

                  ChangePosStep PROC
;;;124    void ChangePosStep(int dir){			//      .
000444  b570              PUSH     {r4-r6,lr}
000446  4606              MOV      r6,r0
;;;125    // ----------------------------------------------
;;;126    int temp, temp1;
;;;127    //SER_PutChar ('*');
;;;128    	DirY=dir;				//  .
000448  48f7              LDR      r0,|L1.2088|
00044a  6006              STR      r6,[r0,#0]  ; DirY
;;;129    	temp1=CurrStepPos;			//   .
00044c  48f7              LDR      r0,|L1.2092|
00044e  6845              LDR      r5,[r0,#4]  ; lbufinfo
;;;130    	temp=StepCNT;				//     .
000450  48f7              LDR      r0,|L1.2096|
000452  6804              LDR      r4,[r0,#0]  ; StepCNT
;;;131    if (temp<=AccelPos) SpeedY=BREAKSPEED;		//   ,      .
000454  48f7              LDR      r0,|L1.2100|
000456  6800              LDR      r0,[r0,#0]  ; AccelPos
000458  4284              CMP      r4,r0
00045a  d802              BHI      |L1.1122|
00045c  48f6              LDR      r0,|L1.2104|
00045e  49f7              LDR      r1,|L1.2108|
000460  6008              STR      r0,[r1,#0]  ; SpeedY
                  |L1.1122|
;;;132    if (!temp) StepBreak();				//    .
000462  b914              CBNZ     r4,|L1.1130|
000464  f7fffffe          BL       StepBreak
000468  e020              B        |L1.1196|
                  |L1.1130|
;;;133    else
;;;134     {	State|=ST_MVY;				//   .
00046a  48f5              LDR      r0,|L1.2112|
00046c  7800              LDRB     r0,[r0,#0]  ; State
00046e  f0400002          ORR      r0,r0,#2
000472  49f3              LDR      r1,|L1.2112|
000474  7008              STRB     r0,[r1,#0]
;;;135    	temp1+=dir; CurrStepPos=temp1;		//  .
000476  4435              ADD      r5,r5,r6
000478  48ec              LDR      r0,|L1.2092|
00047a  6045              STR      r5,[r0,#4]  ; lbufinfo
;;;136    	temp--; StepCNT=temp;			//   .
00047c  1e64              SUBS     r4,r4,#1
00047e  48ec              LDR      r0,|L1.2096|
000480  6004              STR      r4,[r0,#0]  ; StepCNT
;;;137    	SetVoltageStep(temp1);			//    .
000482  4628              MOV      r0,r5
000484  f7fffffe          BL       SetVoltageStep
;;;138    
;;;139    	temp=SpeedY; temp1=cSpeedY;		//   .
000488  48ec              LDR      r0,|L1.2108|
00048a  6804              LDR      r4,[r0,#0]  ; SpeedY
00048c  48ed              LDR      r0,|L1.2116|
00048e  6805              LDR      r5,[r0,#0]  ; cSpeedY
;;;140     if (temp1<temp) DeccelStep(temp);		//   ( ).
000490  42a5              CMP      r5,r4
000492  da02              BGE      |L1.1178|
000494  4620              MOV      r0,r4
000496  f7fffffe          BL       DeccelStep
                  |L1.1178|
;;;141     if (temp1>temp) AccelStep(temp);		//   ( ).
00049a  42a5              CMP      r5,r4
00049c  dd02              BLE      |L1.1188|
00049e  4620              MOV      r0,r4
0004a0  f7fffffe          BL       AccelStep
                  |L1.1188|
;;;142    	SetTimStep(cSpeedY);			//  .
0004a4  48e7              LDR      r0,|L1.2116|
0004a6  6800              LDR      r0,[r0,#0]  ; cSpeedY
0004a8  f7fffffe          BL       SetTimStep
                  |L1.1196|
;;;143     }
;;;144    //intf("\r\ncp %d ps %d cs %d sp %d ap %d",CurrStepPos,StepPos,cSpeedY,SpeedY,AccelPos);
;;;145    } // --------------------------------------------
0004ac  bd70              POP      {r4-r6,pc}
;;;146    void WaitSteps(){				//    .
                          ENDP

                  WaitSteps PROC
0004ae  bf00              NOP      
                  |L1.1200|
;;;147    // ----------------------------------------------
;;;148    while	(!StepCNT);
0004b0  48df              LDR      r0,|L1.2096|
0004b2  6800              LDR      r0,[r0,#0]  ; StepCNT
0004b4  2800              CMP      r0,#0
0004b6  d0fb              BEQ      |L1.1200|
;;;149    } // --------------------------------------------
0004b8  4770              BX       lr
;;;150    void Steps(int rpos){				// .
                          ENDP

                  Steps PROC
0004ba  b510              PUSH     {r4,lr}
0004bc  4604              MOV      r4,r0
;;;151    // ----------------------------------------------
;;;152    if (rpos==0) SpeedY=BREAKSPEED;			//   ,  0.
0004be  b91c              CBNZ     r4,|L1.1224|
0004c0  48dd              LDR      r0,|L1.2104|
0004c2  49de              LDR      r1,|L1.2108|
0004c4  6008              STR      r0,[r1,#0]  ; SpeedY
0004c6  e01b              B        |L1.1280|
                  |L1.1224|
;;;153    else
;;;154     {
;;;155      if (!DirY)
0004c8  48d7              LDR      r0,|L1.2088|
0004ca  6800              LDR      r0,[r0,#0]  ; DirY
0004cc  b9c0              CBNZ     r0,|L1.1280|
;;;156      {
;;;157    //	  TSTP->CR1 =0; TSTP->CNT =0;		//  .   0-.
;;;158    	AccelPos=0;				//   .
0004ce  2000              MOVS     r0,#0
0004d0  49d8              LDR      r1,|L1.2100|
0004d2  6008              STR      r0,[r1,#0]  ; AccelPos
;;;159      	cSpeedY=FT_STEP/FSTEPMIN;		//    .
0004d4  48dc              LDR      r0,|L1.2120|
0004d6  49db              LDR      r1,|L1.2116|
0004d8  6008              STR      r0,[r1,#0]  ; cSpeedY
;;;160    	SpeedY=FT_STEP/FSTEP;			//
0004da  f64840a0          MOV      r0,#0x8ca0
0004de  49d7              LDR      r1,|L1.2108|
0004e0  6008              STR      r0,[r1,#0]  ; SpeedY
;;;161     if (rpos>0)
0004e2  2c00              CMP      r4,#0
0004e4  dd05              BLE      |L1.1266|
;;;162       { StepCNT=+rpos; ChangePosStep(+1); }
0004e6  48d2              LDR      r0,|L1.2096|
0004e8  6004              STR      r4,[r0,#0]  ; StepCNT
0004ea  2001              MOVS     r0,#1
0004ec  f7fffffe          BL       ChangePosStep
0004f0  e006              B        |L1.1280|
                  |L1.1266|
;;;163     else
;;;164       { StepCNT=-rpos; ChangePosStep(-1); }
0004f2  4260              RSBS     r0,r4,#0
0004f4  49ce              LDR      r1,|L1.2096|
0004f6  6008              STR      r0,[r1,#0]  ; StepCNT
0004f8  f04f30ff          MOV      r0,#0xffffffff
0004fc  f7fffffe          BL       ChangePosStep
                  |L1.1280|
;;;165      }
;;;166     }	 
;;;167    } // --------------------------------------------
000500  bd10              POP      {r4,pc}
;;;168    void wSteps(int rpos){				//   .
                          ENDP

                  wSteps PROC
000502  b510              PUSH     {r4,lr}
000504  4604              MOV      r4,r0
;;;169    // ----------------------------------------------
;;;170    	WaitSteps(); Steps(rpos); 
000506  f7fffffe          BL       WaitSteps
00050a  4620              MOV      r0,r4
00050c  f7fffffe          BL       Steps
;;;171    } // --------------------------------------------
000510  bd10              POP      {r4,pc}
;;;172    void StepYCMD(int rpos){			//    "myNNNN".
                          ENDP

                  StepYCMD PROC
000512  b510              PUSH     {r4,lr}
000514  4604              MOV      r4,r0
;;;173    // ----------------------------------------------
;;;174    	Steps(rpos);
000516  4620              MOV      r0,r4
000518  f7fffffe          BL       Steps
;;;175    	ASK();					//   .
00051c  f7fffffe          BL       ASK
;;;176    } // --------------------------------------------
000520  bd10              POP      {r4,pc}
;;;177    void AbsMoveY(int pos){				//    "mYNNNN".
                          ENDP

                  AbsMoveY PROC
000522  b530              PUSH     {r4,r5,lr}
000524  4604              MOV      r4,r0
;;;178    // ----------------------------------------------
;;;179    	StepYCMD(CalcStepY(pos)-CurrStepPos);	//
000526  4620              MOV      r0,r4
000528  f7fffffe          BL       CalcStepY
00052c  49bf              LDR      r1,|L1.2092|
00052e  6849              LDR      r1,[r1,#4]  ; lbufinfo
000530  1a45              SUBS     r5,r0,r1
000532  4628              MOV      r0,r5
000534  f7fffffe          BL       StepYCMD
;;;180    } // --------------------------------------------
000538  bd30              POP      {r4,r5,pc}
;;;181    
                          ENDP

                  InitTimerSteps PROC
;;;182    void InitTimerSteps (){				//    .
00053a  b510              PUSH     {r4,lr}
;;;183    // ----------------------------------------------
;;;184    	cSpeedY=FT_STEP/FSTEPMIN;		//   = .
00053c  48c2              LDR      r0,|L1.2120|
00053e  49c1              LDR      r1,|L1.2116|
000540  6008              STR      r0,[r1,#0]  ; cSpeedY
;;;185    	StepBreak();				// -   .
000542  f7fffffe          BL       StepBreak
;;;186    	NVIC_SetPriority (SysTick_IRQn, 200);  	//  .
000546  f04f30ff          MOV      r0,#0xffffffff
00054a  21c8              MOVS     r1,#0xc8
00054c  2800              CMP      r0,#0
00054e  da07              BGE      |L1.1376|
000550  070a              LSLS     r2,r1,#28
000552  0e14              LSRS     r4,r2,#24
000554  4abd              LDR      r2,|L1.2124|
000556  f000030f          AND      r3,r0,#0xf
00055a  1f1b              SUBS     r3,r3,#4
00055c  54d4              STRB     r4,[r2,r3]
00055e  e003              B        |L1.1384|
                  |L1.1376|
000560  070a              LSLS     r2,r1,#28
000562  0e13              LSRS     r3,r2,#24
000564  4aba              LDR      r2,|L1.2128|
000566  5413              STRB     r3,[r2,r0]
                  |L1.1384|
000568  bf00              NOP      
;;;187    	SysTick->CTRL=SysTick_CTRL_TICKINT_Msk|	//  .
00056a  2007              MOVS     r0,#7
00056c  f04f21e0          MOV      r1,#0xe000e000
000570  6108              STR      r0,[r1,#0x10]
;;;188    		SysTick_CTRL_CLKSOURCE_Msk |	//    (72 ).
;;;189    		SysTick_CTRL_ENABLE_Msk;	//  .
;;;190    } // -------------------------------------------
000572  bd10              POP      {r4,pc}
;;;191    void InitPinsSteps (){				//     .
                          ENDP

                  InitPinsSteps PROC
000574  b500              PUSH     {lr}
;;;192    
;;;193    	portSTP_CR &=~(
000576  48b7              LDR      r0,|L1.2132|
000578  6800              LDR      r0,[r0,#0]
00057a  b280              UXTH     r0,r0
00057c  49b5              LDR      r1,|L1.2132|
00057e  6008              STR      r0,[r1,#0]
;;;194    		(PinCR(pinSTP0,GPIOCR))|	//    .
;;;195    		(PinCR(pinSTP1,GPIOCR))|
;;;196    		(PinCR(pinSTP2,GPIOCR))|
;;;197    		(PinCR(pinSTP3,GPIOCR))
;;;198    		);
;;;199    	portSTP_CR |=(
000580  4608              MOV      r0,r1
000582  6800              LDR      r0,[r0,#0]
000584  49b4              LDR      r1,|L1.2136|
000586  4308              ORRS     r0,r0,r1
000588  49b2              LDR      r1,|L1.2132|
00058a  6008              STR      r0,[r1,#0]
;;;200    		(PinCR(pinSTP0,p_o_p10))|
;;;201    		(PinCR(pinSTP1,p_o_p10))|
;;;202    		(PinCR(pinSTP2,p_o_p10))|
;;;203    		(PinCR(pinSTP3,p_o_p10))
;;;204    		);
;;;205    	SetVoltageStep(0);			// 
00058c  2000              MOVS     r0,#0
00058e  f7fffffe          BL       SetVoltageStep
;;;206    } // -------------------------------------------
000592  bd00              POP      {pc}
;;;207    
                          ENDP

                  SysTick_Handler PROC
;;;208    void TSTP_IRQ(){				//    .
000594  b510              PUSH     {r4,lr}
;;;209    // ----------------------------------------------
;;;210    uint temp;
;;;211    //printf("\r\nI*");
;;;212    
;;;213    	temp=DirY;				//  .
000596  48a4              LDR      r0,|L1.2088|
000598  6804              LDR      r4,[r0,#0]  ; DirY
;;;214     if	(temp) ChangePosStep(temp);		//  ,  .
00059a  b11c              CBZ      r4,|L1.1444|
00059c  4620              MOV      r0,r4
00059e  f7fffffe          BL       ChangePosStep
0005a2  e001              B        |L1.1448|
                  |L1.1444|
;;;215     else	OffVoltageStep();			//   (  -).
0005a4  f7fffffe          BL       OffVoltageStep
                  |L1.1448|
;;;216    }// ---------------------------------------------
0005a8  bd10              POP      {r4,pc}
;;;14     #include "src\motor.c"
                          ENDP

                  SetDirDC PROC
;;;5      } // --------------------------------------------
;;;6      void SetDirDC (int dir){			//   .
0005aa  f44f4110          MOV      r1,#0x9000
;;;7      // ----------------------------------------------
;;;8      	portDC->BRR=(1<<pinPWRF|1<<pinPWRB);	//   .
0005ae  4aab              LDR      r2,|L1.2140|
0005b0  6011              STR      r1,[r2,#0]
;;;9       if (dir<0)	 portDC->BSRR=1<<pinPWRB;	//   .
0005b2  2800              CMP      r0,#0
0005b4  da04              BGE      |L1.1472|
0005b6  f44f4100          MOV      r1,#0x8000
0005ba  1f12              SUBS     r2,r2,#4
0005bc  6011              STR      r1,[r2,#0]
0005be  e006              B        |L1.1486|
                  |L1.1472|
;;;10      else if (dir>0) portDC->BSRR=1<<pinPWRF;	//   .
0005c0  2800              CMP      r0,#0
0005c2  dd04              BLE      |L1.1486|
0005c4  f44f5180          MOV      r1,#0x1000
0005c8  4aa4              LDR      r2,|L1.2140|
0005ca  1f12              SUBS     r2,r2,#4
0005cc  6011              STR      r1,[r2,#0]
                  |L1.1486|
;;;11     
;;;12     //printf("\r\nmotor rg %d %d", TPWM->CCR1,TPWM->CCR2);
;;;13     } // --------------------------------------------
0005ce  4770              BX       lr
;;;14     void TIM_Init_PWM(){				//    TIM1.
                          ENDP

                  TIM_Init_PWM PROC
0005d0  48a3              LDR      r0,|L1.2144|
;;;15     // ----------------------------------------------
;;;16     TIM_TypeDef *timptr=TPWM;
;;;17     
;;;18     	SET_PER_PWM				//  .
0005d2  49a4              LDR      r1,|L1.2148|
0005d4  6849              LDR      r1,[r1,#4]
0005d6  f02101c0          BIC      r1,r1,#0xc0
0005da  4aa2              LDR      r2,|L1.2148|
0005dc  6051              STR      r1,[r2,#4]
0005de  4611              MOV      r1,r2
0005e0  6849              LDR      r1,[r1,#4]
0005e2  6051              STR      r1,[r2,#4]
0005e4  49a0              LDR      r1,|L1.2152|
0005e6  6989              LDR      r1,[r1,#0x18]
0005e8  f4416100          ORR      r1,r1,#0x800
0005ec  4a9e              LDR      r2,|L1.2152|
0005ee  6191              STR      r1,[r2,#0x18]
;;;19     
;;;20     	portDC_CR &=~(
0005f0  499a              LDR      r1,|L1.2140|
0005f2  3910              SUBS     r1,r1,#0x10
0005f4  6809              LDR      r1,[r1,#0]
0005f6  4a9d              LDR      r2,|L1.2156|
0005f8  4011              ANDS     r1,r1,r2
0005fa  4a98              LDR      r2,|L1.2140|
0005fc  3a10              SUBS     r2,r2,#0x10
0005fe  6011              STR      r1,[r2,#0]
;;;21     		(PinCR(pinPWM,GPIOCR))|		//   .
;;;22     //		(PinCR(pinPWMF,GPIOCR))|	//   .
;;;23     //		(PinCR(pinPWMB,GPIOCR))|
;;;24     		(PinCR(pinPWRF,GPIOCR))|
;;;25     		(PinCR(pinPWRB,GPIOCR))
;;;26     		);
;;;27     	portDC_CR |=(
000600  4611              MOV      r1,r2
000602  6809              LDR      r1,[r1,#0]
000604  4a9a              LDR      r2,|L1.2160|
000606  4311              ORRS     r1,r1,r2
000608  4a94              LDR      r2,|L1.2140|
00060a  3a10              SUBS     r2,r2,#0x10
00060c  6011              STR      r1,[r2,#0]
;;;28     		(PinCR(pinPWM,p_a_p50))|	//  .
;;;29     		(PinCR(pinPWRF,p_o_p50))|	//  .
;;;30     		(PinCR(pinPWRB,p_o_p50))
;;;31     		);
;;;32     	timptr->PSC  = ((TPWM_CK/PWM_FREQ/PWM_RES)-1);	// set prescaler
00060e  210d              MOVS     r1,#0xd
000610  8501              STRH     r1,[r0,#0x28]
;;;33     	timptr->ARR  = (PWM_RES-1);		// set auto-reload
000612  21fe              MOVS     r1,#0xfe
000614  8581              STRH     r1,[r0,#0x2c]
;;;34     	
;;;35     	timptr->CCMR1=	
000616  f2460160          MOV      r1,#0x6060
00061a  8301              STRH     r1,[r0,#0x18]
;;;36     		TIM_CCMR1_OC2M_1|
;;;37     		TIM_CCMR1_OC2M_2|
;;;38     		TIM_CCMR1_OC1M_1|
;;;39     		TIM_CCMR1_OC1M_2;		// PWM mode 6. Channel 1&2
;;;40     
;;;41     	timptr->CCER =	TIM_CCER_CC1NE|		//  .     1  8
00061c  2144              MOVS     r1,#0x44
00061e  8401              STRH     r1,[r0,#0x20]
;;;42     			TIM_CCER_CC2NE;
;;;43     	timptr->BDTR =	TIM_BDTR_MOE;
000620  f44f4100          MOV      r1,#0x8000
000624  f8a01044          STRH     r1,[r0,#0x44]
;;;44     			
;;;45     //			TIM_CCER_CC1NP|		// .
;;;46     //			TIM_CCER_CC2NP;
;;;47     
;;;48     	timptr->CR1 |= TIM_CR1_CEN;		//  .
000628  8801              LDRH     r1,[r0,#0]
00062a  f0410101          ORR      r1,r1,#1
00062e  8001              STRH     r1,[r0,#0]
;;;49     } // --------------------------------------------
000630  4770              BX       lr
;;;50     void TIM_Init_TOT(){				//    .
                          ENDP

                  TIM_Init_TOT PROC
000632  b510              PUSH     {r4,lr}
;;;51     // ----------------------------------------------	
;;;52     TIM_TypeDef *timptr=TTOT;
000634  4c8f              LDR      r4,|L1.2164|
;;;53     	SET_PER_TOT				//  . 
000636  488c              LDR      r0,|L1.2152|
000638  69c0              LDR      r0,[r0,#0x1c]
00063a  f0400002          ORR      r0,r0,#2
00063e  498a              LDR      r1,|L1.2152|
000640  61c8              STR      r0,[r1,#0x1c]
;;;54     
;;;55     	timptr->PSC  = TTOT_CK/10000 - 1;	//   100  (10KHz).
000642  f641401f          MOV      r0,#0x1c1f
000646  8520              STRH     r0,[r4,#0x28]
;;;56     	timptr->ARR  = TOT_TIME*10-1;		//   .
000648  f242700f          MOV      r0,#0x270f
00064c  85a0              STRH     r0,[r4,#0x2c]
;;;57     
;;;58     	timptr->DIER =TIM_DIER_UIE;		//     .
00064e  2001              MOVS     r0,#1
000650  81a0              STRH     r0,[r4,#0xc]
;;;59     	NVIC_EnableIRQ(TTOT_IRQn);		//    TIM2.
000652  201d              MOVS     r0,#0x1d
000654  f7fffffe          BL       NVIC_EnableIRQ
;;;60     } // -------------------------------------------
000658  bd10              POP      {r4,pc}
;;;61     
                          ENDP

                  SetTOT PROC
;;;62     void SetTOT(uint tot){				//   -.
00065a  4601              MOV      r1,r0
;;;63     // ----------------------------------------------	
;;;64     //printf("\r\nset TOT %d",tot);
;;;65     TIM_TypeDef *timptr=TTOT;
00065c  4885              LDR      r0,|L1.2164|
;;;66     	timptr->CNT =0;			//   0-.
00065e  2200              MOVS     r2,#0
000660  8482              STRH     r2,[r0,#0x24]
;;;67     	timptr->ARR =tot;			//  .
000662  8581              STRH     r1,[r0,#0x2c]
;;;68     	timptr->CR1 |=TIM_CR1_CEN;		//  .
000664  8802              LDRH     r2,[r0,#0]
000666  f0420201          ORR      r2,r2,#1
00066a  8002              STRH     r2,[r0,#0]
;;;69     } // -------------------------------------------
00066c  4770              BX       lr
;;;70     void ResetTOT(){				//  -.
                          ENDP

                  ResetTOT PROC
00066e  4881              LDR      r0,|L1.2164|
;;;71     // ----------------------------------------------	
;;;72     //printf("\r\nreset TOT");
;;;73     TIM_TypeDef *timptr=TTOT;
;;;74     	timptr->CR1 &=~TIM_CR1_CEN;		//  .
000670  8801              LDRH     r1,[r0,#0]
000672  f0210101          BIC      r1,r1,#1
000676  8001              STRH     r1,[r0,#0]
;;;75     } // -------------------------------------------
000678  4770              BX       lr
;;;76     void MotorBreak(){				//  .
                          ENDP

                  MotorBreak PROC
00067a  b510              PUSH     {r4,lr}
;;;77     
;;;78     	SetDirDC(0);				//  .
00067c  2000              MOVS     r0,#0
00067e  f7fffffe          BL       SetDirDC
;;;79     	TCAP->DIER&=~TIM_DIER_UIE;		//     .
000682  487d              LDR      r0,|L1.2168|
000684  8800              LDRH     r0,[r0,#0]
000686  f0200001          BIC      r0,r0,#1
00068a  497b              LDR      r1,|L1.2168|
00068c  8008              STRH     r0,[r1,#0]
;;;80     	VoltageMotor=0;				// 
00068e  2000              MOVS     r0,#0
000690  497a              LDR      r1,|L1.2172|
000692  6008              STR      r0,[r1,#0]  ; VoltageMotor
;;;81     	SpeedMotor=0;				//   .
000694  497a              LDR      r1,|L1.2176|
000696  6008              STR      r0,[r1,#0]  ; SpeedMotor
;;;82     	PWM_Set(0);				//  .
000698  f7fffffe          BL       PWM_Set
;;;83     	ResetTOT();				//   .
00069c  f7fffffe          BL       ResetTOT
;;;84     	State&=~ST_MVX;				//   .
0006a0  4867              LDR      r0,|L1.2112|
0006a2  7800              LDRB     r0,[r0,#0]  ; State
0006a4  f0200001          BIC      r0,r0,#1
0006a8  4965              LDR      r1,|L1.2112|
0006aa  7008              STRB     r0,[r1,#0]
;;;85     } // --------------------------------------------
0006ac  bd10              POP      {r4,pc}
;;;86     
                          ENDP

                  TIM3_IRQHandler PROC
;;;87     void TTOT_IRQ(){				//     R  .
0006ae  b510              PUSH     {r4,lr}
;;;88     //**********************************************
;;;89     TIM_TypeDef *timptr=TTOT;
0006b0  4c70              LDR      r4,|L1.2164|
;;;90     
;;;91     	timptr->SR =0;		//   .
0006b2  2000              MOVS     r0,#0
0006b4  8220              STRH     r0,[r4,#0x10]
;;;92     
;;;93     //printf("\r\nTOT%d",SpeedMotor);
;;;94      if	(SpeedMotor) MotorBreak();		// .
0006b6  4872              LDR      r0,|L1.2176|
0006b8  6800              LDR      r0,[r0,#0]  ; SpeedMotor
0006ba  b108              CBZ      r0,|L1.1728|
0006bc  f7fffffe          BL       MotorBreak
                  |L1.1728|
;;;95     	timptr->CR1 &=~TIM_CR1_CEN;		//  .
0006c0  8820              LDRH     r0,[r4,#0]
0006c2  f0200001          BIC      r0,r0,#1
0006c6  8020              STRH     r0,[r4,#0]
;;;96     	timptr->CNT =0;				//   "0".
0006c8  2000              MOVS     r0,#0
0006ca  84a0              STRH     r0,[r4,#0x24]
;;;97     } // -------------------------------------------
0006cc  bd10              POP      {r4,pc}
;;;98     
                          ENDP

                  UpdateTOT PROC
;;;99     void UpdateTOT(){				//   -.
0006ce  2000              MOVS     r0,#0
;;;100    // ----------------------------------------------	
;;;101    //printf("\r\nupdate TOT");
;;;102    	TTOT->CNT =0;
0006d0  4968              LDR      r1,|L1.2164|
0006d2  3124              ADDS     r1,r1,#0x24
0006d4  8008              STRH     r0,[r1,#0]
;;;103    } // -------------------------------------------
0006d6  4770              BX       lr
;;;104    void MotorOn(){					//  .
                          ENDP

                  MotorOn PROC
0006d8  b510              PUSH     {r4,lr}
;;;105    // ----------------------------------------------	
;;;106    //printf("\r\nmotor on");
;;;107    	State|=ST_MVX;				//      X.
0006da  4859              LDR      r0,|L1.2112|
0006dc  7800              LDRB     r0,[r0,#0]  ; State
0006de  f0400001          ORR      r0,r0,#1
0006e2  4957              LDR      r1,|L1.2112|
0006e4  7008              STRB     r0,[r1,#0]
;;;108    	SetDirDC (DirX);			//  .
0006e6  4867              LDR      r0,|L1.2180|
0006e8  6800              LDR      r0,[r0,#0]  ; DirX
0006ea  f7fffffe          BL       SetDirDC
;;;109    	PWM_Set(VoltageMotor);			// 
0006ee  4963              LDR      r1,|L1.2172|
0006f0  8809              LDRH     r1,[r1,#0]  ; VoltageMotor
0006f2  b288              UXTH     r0,r1
0006f4  f7fffffe          BL       PWM_Set
;;;110    } // --------------------------------------------
0006f8  bd10              POP      {r4,pc}
;;;111    void WaitM(){					//   .
                          ENDP

                  WaitM PROC
0006fa  bf00              NOP      
                  |L1.1788|
;;;112    // ----------------------------------------------	
;;;113    //printf("\r\n>w");
;;;114    while (SpeedMotor);				//  ,  .
0006fc  4860              LDR      r0,|L1.2176|
0006fe  6800              LDR      r0,[r0,#0]  ; SpeedMotor
000700  2800              CMP      r0,#0
000702  d1fb              BNE      |L1.1788|
;;;115    //	MotorBreak(); ResetTOT();		//  .
;;;116    //printf("\r\nw>");
;;;117    } // --------------------------------------------
000704  4770              BX       lr
;;;118    void Motor(int speed, int pos){			//     POS   SPEED
                          ENDP

                  Motor PROC
000706  b570              PUSH     {r4-r6,lr}
000708  4605              MOV      r5,r0
00070a  460c              MOV      r4,r1
;;;119    // ----------------------------------------------	
;;;120    //printf("\r\nmotor(%d,%d\r\n)",speed,pos);
;;;121     if (CurrLaserPos!=pos)
00070c  4847              LDR      r0,|L1.2092|
00070e  6800              LDR      r0,[r0,#0]  ; lbufinfo
000710  42a0              CMP      r0,r4
000712  d028              BEQ      |L1.1894|
;;;122     {	
;;;123    	WaitM();				//    .
000714  f7fffffe          BL       WaitM
;;;124    	VoltageMotor=MAX_PWM;			//   .
000718  20ff              MOVS     r0,#0xff
00071a  4958              LDR      r1,|L1.2172|
00071c  6008              STR      r0,[r1,#0]  ; VoltageMotor
;;;125    	i_value=0; d_value=0;			//     .
00071e  2000              MOVS     r0,#0
000720  4959              LDR      r1,|L1.2184|
000722  6008              STR      r0,[r1,#0]  ; i_value
000724  4959              LDR      r1,|L1.2188|
000726  6008              STR      r0,[r1,#0]  ; d_value
;;;126      if	(CurrLaserPos>pos) DirX=-1;		//   .
000728  4840              LDR      r0,|L1.2092|
00072a  6800              LDR      r0,[r0,#0]  ; lbufinfo
00072c  42a0              CMP      r0,r4
00072e  dd04              BLE      |L1.1850|
000730  f04f30ff          MOV      r0,#0xffffffff
000734  4953              LDR      r1,|L1.2180|
000736  6008              STR      r0,[r1,#0]  ; DirX
000738  e002              B        |L1.1856|
                  |L1.1850|
;;;127      else	DirX=1;
00073a  2001              MOVS     r0,#1
00073c  4951              LDR      r1,|L1.2180|
00073e  6008              STR      r0,[r1,#0]  ; DirX
                  |L1.1856|
;;;128    	LaserPos=pos;				//   .
000740  4853              LDR      r0,|L1.2192|
000742  6004              STR      r4,[r0,#0]  ; LaserPos
;;;129    //printf ("\r\nMotor %d %d %d",speed, pos, DirX);
;;;130    	SpeedMotor=speed;			//     .
000744  484e              LDR      r0,|L1.2176|
000746  6005              STR      r5,[r0,#0]  ; SpeedMotor
;;;131    	SetTOT(TOT_TIME*10-1);			//   .
000748  f242700f          MOV      r0,#0x270f
00074c  f7fffffe          BL       SetTOT
;;;132    indxmem=0;
000750  2000              MOVS     r0,#0
000752  4950              LDR      r1,|L1.2196|
000754  6008              STR      r0,[r1,#0]  ; indxmem
;;;133    	MotorOn();				//  .
000756  f7fffffe          BL       MotorOn
;;;134    	TCAP->DIER|=TIM_DIER_UIE;		//     .
00075a  4847              LDR      r0,|L1.2168|
00075c  8800              LDRH     r0,[r0,#0]
00075e  f0400001          ORR      r0,r0,#1
000762  4945              LDR      r1,|L1.2168|
000764  8008              STRH     r0,[r1,#0]
                  |L1.1894|
;;;135    	
;;;136     }
;;;137    } // --------------------------------------------
000766  bd70              POP      {r4-r6,pc}
;;;138    void PrintStateM(){				//  .
                          ENDP

                  PrintStateM PROC
000768  b510              PUSH     {r4,lr}
;;;139    // ----------------------------------------------	
;;;140    int pos;
;;;141    	pos=CurrLaserPos;
00076a  4830              LDR      r0,|L1.2092|
00076c  6804              LDR      r4,[r0,#0]  ; lbufinfo
;;;142     if	(OldLaserPos!=pos)
00076e  484a              LDR      r0,|L1.2200|
000770  6800              LDR      r0,[r0,#0]  ; OldLaserPos
000772  42a0              CMP      r0,r4
000774  d009              BEQ      |L1.1930|
;;;143     {
;;;144    	printf("\r\n%6d %6d %8x",pos,SpeedMotor,DebCNT1);
000776  4849              LDR      r0,|L1.2204|
000778  6803              LDR      r3,[r0,#0]  ; DebCNT1
00077a  4841              LDR      r0,|L1.2176|
00077c  4621              MOV      r1,r4
00077e  6802              LDR      r2,[r0,#0]  ; SpeedMotor
000780  a047              ADR      r0,|L1.2208|
000782  f7fffffe          BL       __2printf
;;;145    	OldLaserPos=pos;
000786  4844              LDR      r0,|L1.2200|
000788  6004              STR      r4,[r0,#0]  ; OldLaserPos
                  |L1.1930|
;;;146     }
;;;147    } // --------------------------------------------
00078a  bd10              POP      {r4,pc}
;;;148    
                          ENDP

                  CaretToHome PROC
;;;150    
;;;151    void CaretToHome(){				//    .
00078c  b510              PUSH     {r4,lr}
;;;152    // ----------------------------------------------	
;;;153    //uint tmp;
;;;154    //	tmp=VoltageMotor;			// 
;;;155    //	VoltageMotor=MIN_VLT;			//    .
;;;156    	CurrLaserPos=0;				//      .
00078e  2000              MOVS     r0,#0
000790  4926              LDR      r1,|L1.2092|
000792  6008              STR      r0,[r1,#0]  ; lbufinfo
;;;157    	Motor(100,100);				//  .
000794  2164              MOVS     r1,#0x64
000796  4608              MOV      r0,r1
000798  f7fffffe          BL       Motor
;;;158    	Motor(100,-(MaxPixelLL));		//      .
00079c  4944              LDR      r1,|L1.2224|
00079e  2064              MOVS     r0,#0x64
0007a0  f7fffffe          BL       Motor
;;;159    	WaitM();				//   .
0007a4  f7fffffe          BL       WaitM
;;;160    //printf ("\r\ncaret to home");
;;;161    //printf ("\r\npos %d",CurrLaserPos);
;;;162    	ASK();					//   .
0007a8  f7fffffe          BL       ASK
;;;163    } // --------------------------------------------
0007ac  bd10              POP      {r4,pc}
;;;164    void StopMove(){				//  .
                          ENDP

                  StopMove PROC
0007ae  b510              PUSH     {r4,lr}
;;;165    // ----------------------------------------------
;;;166    	MotorBreak(); SpeedY=BREAKSPEED;
0007b0  f7fffffe          BL       MotorBreak
0007b4  4820              LDR      r0,|L1.2104|
0007b6  4921              LDR      r1,|L1.2108|
0007b8  6008              STR      r0,[r1,#0]  ; SpeedY
;;;167    //printf ("\n\rstop move");
;;;168    	ASK();					//   .
0007ba  f7fffffe          BL       ASK
;;;169    } // --------------------------------------------
0007be  bd10              POP      {r4,pc}
;;;170    void AbsMoveX(int pos){				//     POS   SPEED
                          ENDP

                  AbsMoveX PROC
0007c0  b570              PUSH     {r4-r6,lr}
0007c2  4604              MOV      r4,r0
;;;171    // ----------------------------------------------
;;;172    //printf ("\r\nMoveX %d %d",speed, pos);
;;;173    
;;;174    	Motor(SpeedX,CalcStepX(pos));	//     .
0007c4  4620              MOV      r0,r4
0007c6  f7fffffe          BL       CalcStepX
0007ca  4605              MOV      r5,r0
0007cc  4629              MOV      r1,r5
0007ce  4839              LDR      r0,|L1.2228|
0007d0  6800              LDR      r0,[r0,#0]  ; SpeedX
0007d2  f7fffffe          BL       Motor
;;;175    	ASK();					//   .
0007d6  f7fffffe          BL       ASK
;;;176    } // --------------------------------------------
0007da  bd70              POP      {r4-r6,pc}
;;;177    void StepXCMD(int steps){			//    STEPS .
                          ENDP

                  StepXCMD PROC
0007dc  b510              PUSH     {r4,lr}
0007de  4604              MOV      r4,r0
;;;178    // ----------------------------------------------
;;;179    //printf ("\r\nMoveX %d %d",speed, pos);
;;;180    	
;;;181    	Motor(SpeedX,CurrLaserPos+steps);	// 
0007e0  4812              LDR      r0,|L1.2092|
0007e2  6800              LDR      r0,[r0,#0]  ; lbufinfo
0007e4  1901              ADDS     r1,r0,r4
0007e6  4833              LDR      r0,|L1.2228|
0007e8  6800              LDR      r0,[r0,#0]  ; SpeedX
0007ea  f7fffffe          BL       Motor
;;;182    	ASK();					//   .
0007ee  f7fffffe          BL       ASK
;;;183    } // --------------------------------------------
0007f2  bd10              POP      {r4,pc}
;;;184    
                          ENDP

                  MoveCMD PROC
;;;185    void MoveCMD(char *ptr,uint cnt){		//   .
0007f4  e92d41fc          PUSH     {r2-r8,lr}
0007f8  4606              MOV      r6,r0
0007fa  460f              MOV      r7,r1
;;;186    // ----------------------------------------------	
;;;187    char cmd, chr;
;;;188    int prm,cntp;
;;;189    
;;;190    	cntp=sscanf(ptr,"%c%d",&cmd,&prm);
0007fc  466b              MOV      r3,sp
0007fe  aa01              ADD      r2,sp,#4
000800  a12d              ADR      r1,|L1.2232|
000802  4630              MOV      r0,r6
000804  f7fffffe          BL       __0sscanf
000808  4605              MOV      r5,r0
;;;191    //printf("\r\nM %d,%c,%d,%d,%d",cntp,cmd,prm1,prm2,prm3);
;;;192    	 
;;;193    	 chr=cmd;
00080a  f89d4004          LDRB     r4,[sp,#4]
;;;194    if	(cntp==1){
00080e  2d01              CMP      r5,#1
000810  d156              BNE      |L1.2240|
;;;195     if      (chr=='s') StopMove();
000812  2c73              CMP      r4,#0x73
000814  d102              BNE      |L1.2076|
000816  f7fffffe          BL       StopMove
00081a  e06a              B        |L1.2290|
                  |L1.2076|
;;;196     else if (chr=='h') CaretToHome();
00081c  2c68              CMP      r4,#0x68
00081e  d168              BNE      |L1.2290|
000820  f7fffffe          BL       CaretToHome
000824  e065              B        |L1.2290|
000826  0000              DCW      0x0000
                  |L1.2088|
                          DCD      DirY
                  |L1.2092|
                          DCD      lbufinfo
                  |L1.2096|
                          DCD      StepCNT
                  |L1.2100|
                          DCD      AccelPos
                  |L1.2104|
                          DCD      0x00057e3f
                  |L1.2108|
                          DCD      SpeedY
                  |L1.2112|
                          DCD      State
                  |L1.2116|
                          DCD      cSpeedY
                  |L1.2120|
                          DCD      0x0002bf20
                  |L1.2124|
                          DCD      0xe000ed18
                  |L1.2128|
                          DCD      0xe000e400
                  |L1.2132|
                          DCD      0x40010800
                  |L1.2136|
                          DCD      0x11110000
                  |L1.2140|
                          DCD      0x40010c14
                  |L1.2144|
                          DCD      0x40012c00
                  |L1.2148|
                          DCD      0x40010000
                  |L1.2152|
                          DCD      0x40021000
                  |L1.2156|
                          DCD      0x0f00ffff
                  |L1.2160|
                          DCD      0x30b30000
                  |L1.2164|
                          DCD      0x40000400
                  |L1.2168|
                          DCD      0x4000080c
                  |L1.2172|
                          DCD      VoltageMotor
                  |L1.2176|
                          DCD      SpeedMotor
                  |L1.2180|
                          DCD      DirX
                  |L1.2184|
                          DCD      i_value
                  |L1.2188|
                          DCD      d_value
                  |L1.2192|
                          DCD      LaserPos
                  |L1.2196|
                          DCD      indxmem
                  |L1.2200|
                          DCD      OldLaserPos
                  |L1.2204|
                          DCD      DebCNT1
                  |L1.2208|
0008a0  0d0a2536          DCB      "\r\n%6d %6d %8x",0
0008a4  64202536
0008a8  64202538
0008ac  7800    
0008ae  00                DCB      0
0008af  00                DCB      0
                  |L1.2224|
                          DCD      0xffffebb4
                  |L1.2228|
                          DCD      SpeedX
                  |L1.2232|
0008b8  25632564          DCB      "%c%d",0
0008bc  00      
0008bd  00                DCB      0
0008be  00                DCB      0
0008bf  00                DCB      0
                  |L1.2240|
;;;197     }
;;;198    else if	(cntp==2){
0008c0  2d02              CMP      r5,#2
0008c2  d116              BNE      |L1.2290|
;;;199     if      (chr=='Y') AbsMoveY(prm);
0008c4  2c59              CMP      r4,#0x59
0008c6  d103              BNE      |L1.2256|
0008c8  9800              LDR      r0,[sp,#0]
0008ca  f7fffffe          BL       AbsMoveY
0008ce  e010              B        |L1.2290|
                  |L1.2256|
;;;200     else if (chr=='X') AbsMoveX(prm);
0008d0  2c58              CMP      r4,#0x58
0008d2  d103              BNE      |L1.2268|
0008d4  9800              LDR      r0,[sp,#0]
0008d6  f7fffffe          BL       AbsMoveX
0008da  e00a              B        |L1.2290|
                  |L1.2268|
;;;201     else if (chr=='y') StepYCMD(prm);
0008dc  2c79              CMP      r4,#0x79
0008de  d103              BNE      |L1.2280|
0008e0  9800              LDR      r0,[sp,#0]
0008e2  f7fffffe          BL       StepYCMD
0008e6  e004              B        |L1.2290|
                  |L1.2280|
;;;202     else if (chr=='x') StepXCMD(prm);
0008e8  2c78              CMP      r4,#0x78
0008ea  d102              BNE      |L1.2290|
0008ec  9800              LDR      r0,[sp,#0]
0008ee  f7fffffe          BL       StepXCMD
                  |L1.2290|
;;;203     }	 
;;;204    } // --------------------------------------------
0008f2  e8bd81fc          POP      {r2-r8,pc}
;;;15     #include "src\laser.c"
                          ENDP

                  SetBuffer PROC
;;;15     }// ---------------------------------------------
;;;16     void SetBuffer(char *ptr,uint cnt){		//    ..
0008f6  b538              PUSH     {r3-r5,lr}
0008f8  4604              MOV      r4,r0
0008fa  460d              MOV      r5,r1
;;;17     // ----------------------------------------------
;;;18     uint val;
;;;19      if (sscanf(ptr,"%d",&val)==1)
0008fc  466a              MOV      r2,sp
0008fe  a1fe              ADR      r1,|L1.3320|
000900  4620              MOV      r0,r4
000902  f7fffffe          BL       __0sscanf
000906  2801              CMP      r0,#1
000908  d11b              BNE      |L1.2370|
;;;20      {
;;;21      if (val==0)		ActBuffer=lbuf0;
00090a  9800              LDR      r0,[sp,#0]
00090c  b918              CBNZ     r0,|L1.2326|
00090e  48fb              LDR      r0,|L1.3324|
000910  49fb              LDR      r1,|L1.3328|
000912  6008              STR      r0,[r1,#0]  ; ActBuffer
000914  e013              B        |L1.2366|
                  |L1.2326|
;;;22      else if (val==1)	ActBuffer=lbuf1;
000916  9800              LDR      r0,[sp,#0]
000918  2801              CMP      r0,#1
00091a  d103              BNE      |L1.2340|
00091c  48f9              LDR      r0,|L1.3332|
00091e  49f8              LDR      r1,|L1.3328|
000920  6008              STR      r0,[r1,#0]  ; ActBuffer
000922  e00c              B        |L1.2366|
                  |L1.2340|
;;;23      else if (val==2)	ActBuffer=lbuf2;
000924  9800              LDR      r0,[sp,#0]
000926  2802              CMP      r0,#2
000928  d103              BNE      |L1.2354|
00092a  48f7              LDR      r0,|L1.3336|
00092c  49f4              LDR      r1,|L1.3328|
00092e  6008              STR      r0,[r1,#0]  ; ActBuffer
000930  e005              B        |L1.2366|
                  |L1.2354|
;;;24      else if (val==3)	ActBuffer=lbuf3;
000932  9800              LDR      r0,[sp,#0]
000934  2803              CMP      r0,#3
000936  d102              BNE      |L1.2366|
000938  48f4              LDR      r0,|L1.3340|
00093a  49f1              LDR      r1,|L1.3328|
00093c  6008              STR      r0,[r1,#0]  ; ActBuffer
                  |L1.2366|
;;;25     	ASK();					//   .
00093e  f7fffffe          BL       ASK
                  |L1.2370|
;;;26      }
;;;27     } // --------------------------------------------
000942  bd38              POP      {r3-r5,pc}
;;;28     
                          ENDP

                  FlashLaser PROC
;;;29     void FlashLaser(){				//        "1".
000944  b570              PUSH     {r4-r6,lr}
;;;30     // ----------------------------------------------	
;;;31     int i=CurrLaserPos;
000946  48f2              LDR      r0,|L1.3344|
000948  6804              LDR      r4,[r0,#0]  ; lbufinfo
;;;32     char cbyte;
;;;33     // char *pbuf;
;;;34      if	((i>=0)&&(i<MaxPixelLL))		//    .
00094a  2c00              CMP      r4,#0
00094c  db1b              BLT      |L1.2438|
00094e  f241404c          MOV      r0,#0x144c
000952  4284              CMP      r4,r0
000954  da17              BGE      |L1.2438|
;;;35      {	 
;;;36     	cbyte=ActBuffer[i>>3];			//    .
000956  48ea              LDR      r0,|L1.3328|
000958  6800              LDR      r0,[r0,#0]  ; ActBuffer
00095a  eb0000e4          ADD      r0,r0,r4,ASR #3
00095e  7805              LDRB     r5,[r0,#0]
;;;37     	i=(0x80>>(i&7));			//  .
000960  f0040107          AND      r1,r4,#7
000964  2080              MOVS     r0,#0x80
000966  fa40f401          ASR      r4,r0,r1
;;;38       if	(cbyte&i) LaserOn();			// ,    "1"
00096a  4225              TST      r5,r4
00096c  d008              BEQ      |L1.2432|
00096e  bf00              NOP      
000970  2003              MOVS     r0,#3
000972  49e8              LDR      r1,|L1.3348|
000974  6008              STR      r0,[r1,#0]
000976  2001              MOVS     r0,#1
000978  49e7              LDR      r1,|L1.3352|
00097a  6008              STR      r0,[r1,#0]  ; LsrState
00097c  bf00              NOP      
00097e  e004              B        |L1.2442|
                  |L1.2432|
;;;39       else	LaserOff();
000980  f7fffffe          BL       LaserOff
000984  e001              B        |L1.2442|
                  |L1.2438|
;;;40      }
;;;41      else	LaserOff();
000986  f7fffffe          BL       LaserOff
                  |L1.2442|
;;;42     } // --------------------------------------------
00098a  bd70              POP      {r4-r6,pc}
;;;43     void LaserPWM(uint val){			//      (0.2%-100%).
                          ENDP

                  LaserPWM PROC
00098c  f04f4280          MOV      r2,#0x40000000
;;;44     // ----------------------------------------------
;;;45     		//    .
;;;46     	
;;;47     	TLSR->CCR1=val;				//  .
000990  8690              STRH     r0,[r2,#0x34]
;;;48     	TLSR->CCR2=val;				//  .
000992  8710              STRH     r0,[r2,#0x38]
;;;49     	TLSR->CCR3=val;				//  .
000994  8790              STRH     r0,[r2,#0x3c]
;;;50     	TLSR->CCR4=val;				//  .
000996  4ae1              LDR      r2,|L1.3356|
000998  8010              STRH     r0,[r2,#0]
;;;51     	
;;;52     	portLsr_CR &=~(
00099a  49e1              LDR      r1,|L1.3360|
00099c  6809              LDR      r1,[r1,#0]
00099e  f36f010f          BFC      r1,#0,#16
0009a2  4adf              LDR      r2,|L1.3360|
0009a4  6011              STR      r1,[r2,#0]
;;;53     		(PinCR(pinLsr0,GPIOCR))|	//   .
;;;54     		(PinCR(pinLsr1,GPIOCR))|
;;;55     		(PinCR(pinLsr2,GPIOCR))|
;;;56     		(PinCR(pinLsr3,GPIOCR))
;;;57     		);
;;;58     	portLsr_CR |=(
0009a6  4611              MOV      r1,r2
0009a8  6809              LDR      r1,[r1,#0]
0009aa  f64b32bb          MOV      r2,#0xbbbb
0009ae  ea410102          ORR      r1,r1,r2
0009b2  4adb              LDR      r2,|L1.3360|
0009b4  6011              STR      r1,[r2,#0]
;;;59     		(PinCR(pinLsr0,p_a_p50))|	//  .
;;;60     		(PinCR(pinLsr1,p_a_p50))|
;;;61     		(PinCR(pinLsr2,p_a_p50))|
;;;62     		(PinCR(pinLsr3,p_a_p50))
;;;63     		);
;;;64     	
;;;65     //	printf ("\r\npinl %x npinh %x m1 %x m2 %x enable %x",portLsr->CRL,portLsr->CRH, TLSR->CCMR1, TLSR->CCMR2,TLSR->CCER);
;;;66     	
;;;67     } // --------------------------------------------
0009b6  4770              BX       lr
;;;68     void LaserOffPWM(){				// /  .
                          ENDP

                  LaserOffPWM PROC
0009b8  b510              PUSH     {r4,lr}
;;;69     // ----------------------------------------------	
;;;70     	//    GPIO .
;;;71     
;;;72     	portLsr_CR &=~(
0009ba  48d9              LDR      r0,|L1.3360|
0009bc  6800              LDR      r0,[r0,#0]
0009be  f36f000f          BFC      r0,#0,#16
0009c2  49d7              LDR      r1,|L1.3360|
0009c4  6008              STR      r0,[r1,#0]
;;;73     		(PinCR(pinLsr0,GPIOCR))|	//   .
;;;74     		(PinCR(pinLsr1,GPIOCR))|
;;;75     		(PinCR(pinLsr2,GPIOCR))|
;;;76     		(PinCR(pinLsr3,GPIOCR))
;;;77     	);
;;;78     	portLsr_CR |=(
0009c6  4608              MOV      r0,r1
0009c8  6800              LDR      r0,[r0,#0]
0009ca  f2433133          MOV      r1,#0x3333
0009ce  4308              ORRS     r0,r0,r1
0009d0  49d3              LDR      r1,|L1.3360|
0009d2  6008              STR      r0,[r1,#0]
;;;79     		(PinCR(pinLsr0,p_o_p50))|	//   .
;;;80     		(PinCR(pinLsr1,p_o_p50))|
;;;81     		(PinCR(pinLsr2,p_o_p50))|
;;;82     		(PinCR(pinLsr3,p_o_p50))
;;;83     	);
;;;84     	LaserOff();
0009d4  f7fffffe          BL       LaserOff
;;;85     } // --------------------------------------------
0009d8  bd10              POP      {r4,pc}
;;;86     void LaserCTRL(uint val){			// /  .
                          ENDP

                  LaserCTRL PROC
0009da  b510              PUSH     {r4,lr}
0009dc  4604              MOV      r4,r0
;;;87     // ----------------------------------------------	
;;;88     //printf("\r\nLaserCTRL %d ",val);
;;;89     	Laser=val;
0009de  48d1              LDR      r0,|L1.3364|
0009e0  6004              STR      r4,[r0,#0]  ; Laser
;;;90      if (val<=1)		LaserOffPWM();
0009e2  2c01              CMP      r4,#1
0009e4  d802              BHI      |L1.2540|
0009e6  f7fffffe          BL       LaserOffPWM
0009ea  e008              B        |L1.2558|
                  |L1.2540|
;;;91      else if (val==2)	LaserPWM(1);
0009ec  2c02              CMP      r4,#2
0009ee  d103              BNE      |L1.2552|
0009f0  2001              MOVS     r0,#1
0009f2  f7fffffe          BL       LaserPWM
0009f6  e002              B        |L1.2558|
                  |L1.2552|
;;;92      else			LaserPWM(val);
0009f8  4620              MOV      r0,r4
0009fa  f7fffffe          BL       LaserPWM
                  |L1.2558|
;;;93     } // --------------------------------------------
0009fe  bd10              POP      {r4,pc}
;;;94     void LaserCMD (char *ptr,uint cnt){		//  .
                          ENDP

                  LaserCMD PROC
000a00  b5f8              PUSH     {r3-r7,lr}
000a02  4604              MOV      r4,r0
000a04  460e              MOV      r6,r1
;;;95     // ----------------------------------------------
;;;96     uint val=0; uint cntp;
000a06  2000              MOVS     r0,#0
000a08  9000              STR      r0,[sp,#0]
;;;97     
;;;98     	cntp=sscanf(ptr,"%d",&val);
000a0a  466a              MOV      r2,sp
000a0c  a1ba              ADR      r1,|L1.3320|
000a0e  4620              MOV      r0,r4
000a10  f7fffffe          BL       __0sscanf
000a14  4605              MOV      r5,r0
;;;99     if	(cntp) LaserCTRL(val);
000a16  b115              CBZ      r5,|L1.2590|
000a18  9800              LDR      r0,[sp,#0]
000a1a  f7fffffe          BL       LaserCTRL
                  |L1.2590|
;;;100    	ASK();					//   .
000a1e  f7fffffe          BL       ASK
;;;101    }// ---------------------------------------------
000a22  bdf8              POP      {r3-r7,pc}
;;;102    
                          ENDP

                  InitLaser PROC
;;;103    void InitLaser(){				//   .
000a24  48c0              LDR      r0,|L1.3368|
;;;104    // ----------------------------------------------
;;;105    	SET_PER_LSR				// , .
000a26  69c0              LDR      r0,[r0,#0x1c]
000a28  f0400001          ORR      r0,r0,#1
000a2c  49be              LDR      r1,|L1.3368|
000a2e  61c8              STR      r0,[r1,#0x1c]
000a30  48be              LDR      r0,|L1.3372|
000a32  6840              LDR      r0,[r0,#4]
000a34  49bd              LDR      r1,|L1.3372|
000a36  6048              STR      r0,[r1,#4]
;;;106    	
;;;107    	TLSR->PSC = (TLSR_CK/LSR_FREQ/LSR_RES-1);	// .
000a38  208f              MOVS     r0,#0x8f
000a3a  0389              LSLS     r1,r1,#14
000a3c  8508              STRH     r0,[r1,#0x28]
;;;108    	TLSR->ARR = (LSR_RES-1);		//  .
000a3e  f24030e7          MOV      r0,#0x3e7
000a42  8588              STRH     r0,[r1,#0x2c]
;;;109    	
;;;110    	TLSR->CCMR1=	(TIM_CCMR1_OC1M_1|
000a44  f2460060          MOV      r0,#0x6060
000a48  8308              STRH     r0,[r1,#0x18]
;;;111    			 TIM_CCMR1_OC1M_2|
;;;112    			 TIM_CCMR1_OC2M_1|
;;;113    			 TIM_CCMR1_OC2M_2);	//   6.  1  2
;;;114    			 
;;;115    	TLSR->CCMR2=	(TIM_CCMR2_OC3M_1|
000a4a  8388              STRH     r0,[r1,#0x1c]
;;;116    			 TIM_CCMR2_OC3M_2|
;;;117    			 TIM_CCMR2_OC4M_1|
;;;118    			 TIM_CCMR2_OC4M_2);	//   6.  3  4
;;;119    			 
;;;120    	TLSR->CCER =	(TIM_CCER_CC1E|		// CCE channel 1
000a4c  f2411011          MOV      r0,#0x1111
000a50  8408              STRH     r0,[r1,#0x20]
;;;121    			 TIM_CCER_CC2E|		// CCE channel 2
;;;122    			 TIM_CCER_CC3E|		// CCE channel 3
;;;123    			 TIM_CCER_CC4E);	// CCE channel 4
;;;124    	TLSR->CR1 |= 	TIM_CR1_CEN;		//  .
000a52  0780              LSLS     r0,r0,#30
000a54  8800              LDRH     r0,[r0,#0]
000a56  f0400001          ORR      r0,r0,#1
000a5a  8008              STRH     r0,[r1,#0]
;;;125    //------
;;;126    	TLSR->CCR1=0x0;				//  .
000a5c  2000              MOVS     r0,#0
000a5e  8688              STRH     r0,[r1,#0x34]
;;;127    	TLSR->CCR2=0x0;				//  .
000a60  8708              STRH     r0,[r1,#0x38]
;;;128    	TLSR->CCR3=0x0;				//  .
000a62  8788              STRH     r0,[r1,#0x3c]
;;;129    	TLSR->CCR4=0x0;				//  .
000a64  49ad              LDR      r1,|L1.3356|
000a66  8008              STRH     r0,[r1,#0]
;;;130    	
;;;131    //	printf ("\r\npinl %x npinh %x m1 %x m2 %x enable %x",portLsr->CRL,portLsr->CRH, TLSR->CCMR1, TLSR->CCMR2,TLSR->CCER);
;;;132    	
;;;133    } // --------------------------------------------
000a68  4770              BX       lr
;;;16     #include "src\capture.c"
                          ENDP

                  ChangeLaserPos PROC
;;;37     }; // -------------------------------------------
;;;38     void ChangeLaserPos (uint sti){			//   .
000a6a  b500              PUSH     {lr}
000a6c  4602              MOV      r2,r0
;;;39     // ----------------------------------------------	
;;;40     	sti=((sti&(TIM_SR_CC1IF|TIM_SR_CC2IF|	//   .
000a6e  f002001e          AND      r0,r2,#0x1e
000a72  0042              LSLS     r2,r0,#1
;;;41     	TIM_SR_CC3IF|TIM_SR_CC4IF))<<1);	//    00xx xx00
;;;42      if ((portENC1->IDR)&(1<<pinEnc1)) sti|=1;
000a74  48ae              LDR      r0,|L1.3376|
000a76  6800              LDR      r0,[r0,#0]
000a78  f0100f40          TST      r0,#0x40
000a7c  d001              BEQ      |L1.2690|
000a7e  f0420201          ORR      r2,r2,#1
                  |L1.2690|
;;;43      if ((portENC2->IDR)&(1<<pinEnc2)) sti|=2;	//  6  . 00iiiiPP
000a82  48ab              LDR      r0,|L1.3376|
000a84  6800              LDR      r0,[r0,#0]
000a86  f4107f80          TST      r0,#0x100
000a8a  d001              BEQ      |L1.2704|
000a8c  f0420202          ORR      r2,r2,#2
                  |L1.2704|
;;;44     	EncDir=tab_enc[sti];			//   .
000a90  48a8              LDR      r0,|L1.3380|
000a92  5680              LDRSB    r0,[r0,r2]
000a94  49a8              LDR      r1,|L1.3384|
000a96  6008              STR      r0,[r1,#0]  ; EncDir
;;;45     	CurrLaserPos+=EncDir;
000a98  489d              LDR      r0,|L1.3344|
000a9a  6800              LDR      r0,[r0,#0]  ; lbufinfo
000a9c  6809              LDR      r1,[r1,#0]  ; EncDir
000a9e  4408              ADD      r0,r0,r1
000aa0  499b              LDR      r1,|L1.3344|
000aa2  6008              STR      r0,[r1,#0]  ; lbufinfo
;;;46      if (EncDir!=0) UpdateTOT();			//   -  -.
000aa4  48a4              LDR      r0,|L1.3384|
000aa6  6800              LDR      r0,[r0,#0]  ; EncDir
000aa8  b108              CBZ      r0,|L1.2734|
000aaa  f7fffffe          BL       UpdateTOT
                  |L1.2734|
;;;47      
;;;48     if (EncDir==0) DebCNT1+=DebCNT1;	//  .	
000aae  48a2              LDR      r0,|L1.3384|
000ab0  6800              LDR      r0,[r0,#0]  ; EncDir
000ab2  b920              CBNZ     r0,|L1.2750|
000ab4  48a1              LDR      r0,|L1.3388|
000ab6  6800              LDR      r0,[r0,#0]  ; DebCNT1
000ab8  0040              LSLS     r0,r0,#1
000aba  49a0              LDR      r1,|L1.3388|
000abc  6008              STR      r0,[r1,#0]  ; DebCNT1
                  |L1.2750|
;;;49      if (fDebug)
000abe  48a0              LDR      r0,|L1.3392|
000ac0  6800              LDR      r0,[r0,#0]  ; fDebug
000ac2  b168              CBZ      r0,|L1.2784|
;;;50      {	
;;;51       if (!CurrLaserPos)
000ac4  4892              LDR      r0,|L1.3344|
000ac6  6800              LDR      r0,[r0,#0]  ; lbufinfo
000ac8  b950              CBNZ     r0,|L1.2784|
;;;52       {	
;;;53     	SpBuf[indxmem-1]=0;
000aca  2100              MOVS     r1,#0
000acc  489d              LDR      r0,|L1.3396|
000ace  6800              LDR      r0,[r0,#0]  ; indxmem
000ad0  1e40              SUBS     r0,r0,#1
000ad2  4b9d              LDR      r3,|L1.3400|
000ad4  5419              STRB     r1,[r3,r0]
;;;54     	SpBuf1[indxmem-1]=0;
000ad6  489b              LDR      r0,|L1.3396|
000ad8  6800              LDR      r0,[r0,#0]  ; indxmem
000ada  1e40              SUBS     r0,r0,#1
000adc  4b9b              LDR      r3,|L1.3404|
000ade  5419              STRB     r1,[r3,r0]
                  |L1.2784|
;;;55       }
;;;56      }
;;;57     } // --------------------------------------------
000ae0  bd00              POP      {pc}
;;;58     void SpeedRegulator(uint cspd){			//  .
                          ENDP

                  SpeedRegulator PROC
000ae2  e92d41f0          PUSH     {r4-r8,lr}
000ae6  4604              MOV      r4,r0
;;;59     
;;;60     //int	vm,serr,ival,dval;
;;;61     int	vm,serr,ival;
;;;62     
;;;63     //	CapCCR=cspd;				//   .
;;;64     	vm=VoltageMotor;			//   .
000ae8  4899              LDR      r0,|L1.3408|
000aea  6805              LDR      r5,[r0,#0]  ; VoltageMotor
;;;65     	ival=i_value;
000aec  4899              LDR      r0,|L1.3412|
000aee  6807              LDR      r7,[r0,#0]  ; i_value
;;;66     //	dval=d_value;		// 
;;;67     	
;;;68       if (!cspd) cspd=1;				//     0.
000af0  b904              CBNZ     r4,|L1.2804|
000af2  2401              MOVS     r4,#1
                  |L1.2804|
;;;69     	cspd=FTCAP/10*254*4/ResolX/cspd;	//  /.
000af4  4898              LDR      r0,|L1.3416|
000af6  fbb0f4f4          UDIV     r4,r0,r4
;;;70     // if (LsrState)	AvrgSpd=cspd;			//   .
;;;71     	AvrgSpd=cspd;				//   .
000afa  4885              LDR      r0,|L1.3344|
000afc  6084              STR      r4,[r0,#8]  ; lbufinfo
;;;72     	serr=SpeedMotor-cspd;			//   .
000afe  4897              LDR      r0,|L1.3420|
000b00  6800              LDR      r0,[r0,#0]  ; SpeedMotor
000b02  1b06              SUBS     r6,r0,r4
;;;73     //if (vm<MAX_PWM)				//  .  ?
;;;74     // {
;;;75     	ival+=serr;				//    .
000b04  4437              ADD      r7,r7,r6
;;;76     //	dval=serr-d_value;			//    .
;;;77     // }	
;;;78     //	vm = serr/2 + i_value/128 + MIN_PWM;
;;;79     //	vm = ((serr*k_prp)+(ival*k_int)-(dval*k_dif))/k_com + MIN_PWM;
;;;80     	vm = ((serr*k_prp)+(ival*k_int))/k_com+MIN_PWM;
000b06  4896              LDR      r0,|L1.3424|
000b08  6800              LDR      r0,[r0,#0]  ; k_prp
000b0a  4370              MULS     r0,r6,r0
000b0c  4995              LDR      r1,|L1.3428|
000b0e  6809              LDR      r1,[r1,#0]  ; k_int
000b10  fb070001          MLA      r0,r7,r1,r0
000b14  4994              LDR      r1,|L1.3432|
000b16  6809              LDR      r1,[r1,#0]  ; k_com
000b18  fb90f0f1          SDIV     r0,r0,r1
000b1c  f1000566          ADD      r5,r0,#0x66
;;;81     	
;;;82       if (vm>MAX_PWM) vm=MAX_PWM;			//    .
000b20  2dff              CMP      r5,#0xff
000b22  dd01              BLE      |L1.2856|
000b24  25ff              MOVS     r5,#0xff
000b26  e002              B        |L1.2862|
                  |L1.2856|
;;;83       else if (vm<(MIN_PWM)) vm=MIN_PWM;
000b28  2d66              CMP      r5,#0x66
000b2a  da00              BGE      |L1.2862|
000b2c  2566              MOVS     r5,#0x66
                  |L1.2862|
;;;84     	VoltageMotor=vm; PWM_Set(vm);
000b2e  4888              LDR      r0,|L1.3408|
000b30  6005              STR      r5,[r0,#0]  ; VoltageMotor
000b32  b2a8              UXTH     r0,r5
000b34  f7fffffe          BL       PWM_Set
;;;85     	i_value=ival;
000b38  4886              LDR      r0,|L1.3412|
000b3a  6007              STR      r7,[r0,#0]  ; i_value
;;;86     //	d_value=serr;		// 
;;;87     } // --------------------------------------------
000b3c  e8bd81f0          POP      {r4-r8,pc}
;;;88     void CheckStop(){				//    .
                          ENDP

                  CheckStop PROC
000b40  b510              PUSH     {r4,lr}
;;;89     
;;;90     if 	(TPWM->CCR1)				//    ?
000b42  488a              LDR      r0,|L1.3436|
000b44  8800              LDRH     r0,[r0,#0]
000b46  b1a0              CBZ      r0,|L1.2930|
;;;91      {
;;;92      if (DirX<0)
000b48  4889              LDR      r0,|L1.3440|
000b4a  6800              LDR      r0,[r0,#0]  ; DirX
000b4c  2800              CMP      r0,#0
000b4e  da08              BGE      |L1.2914|
;;;93       {
;;;94       if (CurrLaserPos<=LaserPos) MotorBreak();
000b50  486f              LDR      r0,|L1.3344|
000b52  6800              LDR      r0,[r0,#0]  ; lbufinfo
000b54  4987              LDR      r1,|L1.3444|
000b56  6809              LDR      r1,[r1,#0]  ; LaserPos
000b58  4288              CMP      r0,r1
000b5a  dc0a              BGT      |L1.2930|
000b5c  f7fffffe          BL       MotorBreak
000b60  e007              B        |L1.2930|
                  |L1.2914|
;;;95       }
;;;96      else if (CurrLaserPos>=LaserPos) MotorBreak();
000b62  486b              LDR      r0,|L1.3344|
000b64  6800              LDR      r0,[r0,#0]  ; lbufinfo
000b66  4983              LDR      r1,|L1.3444|
000b68  6809              LDR      r1,[r1,#0]  ; LaserPos
000b6a  4288              CMP      r0,r1
000b6c  db01              BLT      |L1.2930|
000b6e  f7fffffe          BL       MotorBreak
                  |L1.2930|
;;;97      }
;;;98     } // --------------------------------------------
000b72  bd10              POP      {r4,pc}
;;;99     void SavePID(char *ptr,uint cnt){		//    .
                          ENDP

                  SavePID PROC
000b74  b57c              PUSH     {r2-r6,lr}
000b76  4604              MOV      r4,r0
000b78  460d              MOV      r5,r1
;;;100    // ----------------------------------------------	
;;;101    char cmd;
;;;102    int prm;
;;;103    
;;;104     if (sscanf(ptr,"%c%d",&cmd,&prm)==2)
000b7a  466b              MOV      r3,sp
000b7c  aa01              ADD      r2,sp,#4
000b7e  f2af21c8          ADR      r1,|L1.2232|
000b82  4620              MOV      r0,r4
000b84  f7fffffe          BL       __0sscanf
000b88  2802              CMP      r0,#2
000b8a  d120              BNE      |L1.3022|
;;;105    //printf("\r\nM %d,%c,%d,%d,%d",cntp,cmd,prm1,prm2,prm3);
;;;106     {
;;;107      if      (cmd=='p') k_prp=prm;			//   .  .
000b8c  f89d0004          LDRB     r0,[sp,#4]
000b90  2870              CMP      r0,#0x70
000b92  d103              BNE      |L1.2972|
000b94  4972              LDR      r1,|L1.3424|
000b96  9800              LDR      r0,[sp,#0]
000b98  6008              STR      r0,[r1,#0]  ; k_prp
000b9a  e016              B        |L1.3018|
                  |L1.2972|
;;;108      else if (cmd=='i') k_int=prm;			//     .
000b9c  f89d0004          LDRB     r0,[sp,#4]
000ba0  2869              CMP      r0,#0x69
000ba2  d103              BNE      |L1.2988|
000ba4  496f              LDR      r1,|L1.3428|
000ba6  9800              LDR      r0,[sp,#0]
000ba8  6008              STR      r0,[r1,#0]  ; k_int
000baa  e00e              B        |L1.3018|
                  |L1.2988|
;;;109      else if (cmd=='d') k_dif=prm;			//     .
000bac  f89d0004          LDRB     r0,[sp,#4]
000bb0  2864              CMP      r0,#0x64
000bb2  d103              BNE      |L1.3004|
000bb4  4970              LDR      r1,|L1.3448|
000bb6  9800              LDR      r0,[sp,#0]
000bb8  6008              STR      r0,[r1,#0]  ; k_dif
000bba  e006              B        |L1.3018|
                  |L1.3004|
;;;110      else if (cmd=='c') k_com=prm;			//     .
000bbc  f89d0004          LDRB     r0,[sp,#4]
000bc0  2863              CMP      r0,#0x63
000bc2  d102              BNE      |L1.3018|
000bc4  4968              LDR      r1,|L1.3432|
000bc6  9800              LDR      r0,[sp,#0]
000bc8  6008              STR      r0,[r1,#0]  ; k_com
                  |L1.3018|
;;;111    	ASK();					//   .
000bca  f7fffffe          BL       ASK
                  |L1.3022|
;;;112     }
;;;113    } // --------------------------------------------
000bce  bd7c              POP      {r2-r6,pc}
;;;114    void TCAP_IRQ(){				//    .
                          ENDP

                  TIM4_IRQHandler PROC
000bd0  b570              PUSH     {r4-r6,lr}
;;;115    // ----------------------------------------------
;;;116    uint sti, cspd;
;;;117    TIM_TypeDef *timptr=TCAP;
000bd2  4d6a              LDR      r5,|L1.3452|
;;;118    
;;;119    	sti=timptr->SR;	timptr->SR=0;		//  .    .
000bd4  8a2c              LDRH     r4,[r5,#0x10]
000bd6  2000              MOVS     r0,#0
000bd8  8228              STRH     r0,[r5,#0x10]
;;;120    	cspd=0xFFFFFFF;				//   -   .
000bda  f06f4670          MVN      r6,#0xf0000000
;;;121     if (sti&TIM_SR_UIF) CapNCCR=0;			//   ,   .
000bde  f0140f01          TST      r4,#1
000be2  d001              BEQ      |L1.3048|
000be4  4966              LDR      r1,|L1.3456|
000be6  6008              STR      r0,[r1,#0]  ; CapNCCR
                  |L1.3048|
;;;122     if (sti&TIM_SR_CC1IF)				//      .
000be8  f0140f02          TST      r4,#2
000bec  d00e              BEQ      |L1.3084|
;;;123     {
;;;124    	CapCNT=timptr->CNT;			//      .
000bee  8ca8              LDRH     r0,[r5,#0x24]
000bf0  4964              LDR      r1,|L1.3460|
000bf2  6008              STR      r0,[r1,#0]  ; CapCNT
;;;125    	timptr->CNT=0;				//  .
000bf4  2000              MOVS     r0,#0
000bf6  84a8              STRH     r0,[r5,#0x24]
;;;126    	CapNCCR++;				//     .
000bf8  4861              LDR      r0,|L1.3456|
000bfa  6800              LDR      r0,[r0,#0]  ; CapNCCR
000bfc  1c40              ADDS     r0,r0,#1
000bfe  4960              LDR      r1,|L1.3456|
000c00  6008              STR      r0,[r1,#0]  ; CapNCCR
;;;127      if (CapNCCR>1)cspd=timptr->CCR1;		//         .
000c02  4608              MOV      r0,r1
000c04  6800              LDR      r0,[r0,#0]  ; CapNCCR
000c06  2801              CMP      r0,#1
000c08  d900              BLS      |L1.3084|
000c0a  8eae              LDRH     r6,[r5,#0x34]
                  |L1.3084|
;;;128     } 
;;;129     if (sti&(TIM_SR_CC1IF|TIM_SR_CC2IF|TIM_SR_CC3IF|TIM_SR_CC4IF))	//     .
000c0c  f0140f1e          TST      r4,#0x1e
000c10  d00a              BEQ      |L1.3112|
;;;130     {
;;;131    	ChangeLaserPos(sti);			//   .
000c12  4620              MOV      r0,r4
000c14  f7fffffe          BL       ChangeLaserPos
;;;132      if (Laser==1) FlashLaser();			//  .
000c18  4842              LDR      r0,|L1.3364|
000c1a  6800              LDR      r0,[r0,#0]  ; Laser
000c1c  2801              CMP      r0,#1
000c1e  d101              BNE      |L1.3108|
000c20  f7fffffe          BL       FlashLaser
                  |L1.3108|
;;;133    	CheckStop();				//     .
000c24  f7fffffe          BL       CheckStop
                  |L1.3112|
;;;134     }
;;;135     if (sti&(TIM_SR_CC1IF|TIM_SR_UIF))		//       .
000c28  f0140f03          TST      r4,#3
000c2c  d034              BEQ      |L1.3224|
;;;136     {
;;;137      if (SpeedMotor) SpeedRegulator(cspd);		//  .
000c2e  484b              LDR      r0,|L1.3420|
000c30  6800              LDR      r0,[r0,#0]  ; SpeedMotor
000c32  b110              CBZ      r0,|L1.3130|
000c34  4630              MOV      r0,r6
000c36  f7fffffe          BL       SpeedRegulator
                  |L1.3130|
;;;138      if (fDebug)
000c3a  4841              LDR      r0,|L1.3392|
000c3c  6800              LDR      r0,[r0,#0]  ; fDebug
000c3e  b358              CBZ      r0,|L1.3224|
;;;139      {
;;;140       if (indxmem<sizespbuf/2-1)			//  .
000c40  4840              LDR      r0,|L1.3396|
000c42  6800              LDR      r0,[r0,#0]  ; indxmem
000c44  f24031e7          MOV      r1,#0x3e7
000c48  4288              CMP      r0,r1
000c4a  d225              BCS      |L1.3224|
;;;141       {	
;;;142        if (EncDir>0)
000c4c  483a              LDR      r0,|L1.3384|
000c4e  6800              LDR      r0,[r0,#0]  ; EncDir
000c50  2800              CMP      r0,#0
000c52  dd0e              BLE      |L1.3186|
;;;143        {	   
;;;144    	SpBuf[indxmem+0]=FTCAP/10*254/ResolX/cspd;  // speed/4
000c54  484c              LDR      r0,|L1.3464|
000c56  fbb0f0f6          UDIV     r0,r0,r6
000c5a  b2c1              UXTB     r1,r0
000c5c  4a3a              LDR      r2,|L1.3400|
000c5e  4839              LDR      r0,|L1.3396|
000c60  6800              LDR      r0,[r0,#0]  ; indxmem
000c62  5411              STRB     r1,[r2,r0]
;;;145    	SpBuf[indxmem+1]=VoltageMotor;
000c64  483a              LDR      r0,|L1.3408|
000c66  7801              LDRB     r1,[r0,#0]  ; VoltageMotor
000c68  4836              LDR      r0,|L1.3396|
000c6a  6800              LDR      r0,[r0,#0]  ; indxmem
000c6c  1c40              ADDS     r0,r0,#1
000c6e  5411              STRB     r1,[r2,r0]
000c70  e00d              B        |L1.3214|
                  |L1.3186|
;;;146        }	
;;;147        else
;;;148        {
;;;149      	SpBuf1[indxmem+0]=FTCAP/10*254/ResolX/cspd; // speed/4
000c72  4845              LDR      r0,|L1.3464|
000c74  fbb0f0f6          UDIV     r0,r0,r6
000c78  b2c1              UXTB     r1,r0
000c7a  4a34              LDR      r2,|L1.3404|
000c7c  4831              LDR      r0,|L1.3396|
000c7e  6800              LDR      r0,[r0,#0]  ; indxmem
000c80  5411              STRB     r1,[r2,r0]
;;;150    	SpBuf1[indxmem+1]=VoltageMotor;
000c82  4833              LDR      r0,|L1.3408|
000c84  7801              LDRB     r1,[r0,#0]  ; VoltageMotor
000c86  482f              LDR      r0,|L1.3396|
000c88  6800              LDR      r0,[r0,#0]  ; indxmem
000c8a  1c40              ADDS     r0,r0,#1
000c8c  5411              STRB     r1,[r2,r0]
                  |L1.3214|
;;;151        }
;;;152    	indxmem+=2;
000c8e  482d              LDR      r0,|L1.3396|
000c90  6800              LDR      r0,[r0,#0]  ; indxmem
000c92  1c80              ADDS     r0,r0,#2
000c94  492b              LDR      r1,|L1.3396|
000c96  6008              STR      r0,[r1,#0]  ; indxmem
                  |L1.3224|
;;;153       }	
;;;154      }
;;;155     }
;;;156    }// ---------------------------------------------
000c98  bd70              POP      {r4-r6,pc}
;;;157    void TIM_Init_ENC(){				//
                          ENDP

                  TIM_Init_ENC PROC
000c9a  b510              PUSH     {r4,lr}
;;;158    // ----------------------------------------------
;;;159    TIM_TypeDef *timptr=TCAP;
000c9c  4c37              LDR      r4,|L1.3452|
;;;160    	SET_PER_CAP				//  ,  .
000c9e  4822              LDR      r0,|L1.3368|
000ca0  69c0              LDR      r0,[r0,#0x1c]
000ca2  f0400004          ORR      r0,r0,#4
000ca6  4920              LDR      r1,|L1.3368|
000ca8  61c8              STR      r0,[r1,#0x1c]
;;;161    	
;;;162    	portENC1->CRL &=~(PinCR(pinEnc1,GPIOCR));
000caa  4821              LDR      r0,|L1.3376|
000cac  3808              SUBS     r0,r0,#8
000cae  6800              LDR      r0,[r0,#0]
000cb0  f0206070          BIC      r0,r0,#0xf000000
000cb4  491e              LDR      r1,|L1.3376|
000cb6  3908              SUBS     r1,r1,#8
000cb8  6008              STR      r0,[r1,#0]
;;;163    	portENC1->CRL |= (PinCR(pinEnc1,p_i_p));//  1    .
000cba  4608              MOV      r0,r1
000cbc  6800              LDR      r0,[r0,#0]
000cbe  f0406000          ORR      r0,r0,#0x8000000
000cc2  6008              STR      r0,[r1,#0]
;;;164    	portENC2->CRL &=~(PinCR(pinEnc2,GPIOCR));		
000cc4  4608              MOV      r0,r1
000cc6  6800              LDR      r0,[r0,#0]
000cc8  f020000f          BIC      r0,r0,#0xf
000ccc  6008              STR      r0,[r1,#0]
;;;165    	portENC2->CRL |= (PinCR(pinEnc2,p_i_p));//  2    .
000cce  4608              MOV      r0,r1
000cd0  6800              LDR      r0,[r0,#0]
000cd2  f0400008          ORR      r0,r0,#8
000cd6  6008              STR      r0,[r1,#0]
;;;166    	
;;;167    	timptr->PSC  =(TCAP_CK/FTCAP-1);	// .
000cd8  2005              MOVS     r0,#5
000cda  8520              STRH     r0,[r4,#0x28]
;;;168    	timptr->ARR  =(0xFFFF);			//   .
000cdc  f64f70ff          MOV      r0,#0xffff
000ce0  85a0              STRH     r0,[r4,#0x2c]
;;;169    	timptr->CCMR1 =  (TIM_CCMR1_CC2S_1|
000ce2  f2442041          MOV      r0,#0x4241
000ce6  8320              STRH     r0,[r4,#0x18]
;;;170    			TIM_CCMR1_CC1S_0|
;;;171    			TIM_CCMR1_IC1F_2|
;;;172    			TIM_CCMR1_IC2F_2);	//  1 2    ,  6*Fdts/2.
;;;173    	timptr->CCMR2 =  (TIM_CCMR2_CC4S_1|
000ce8  83a0              STRH     r0,[r4,#0x1c]
;;;174    			TIM_CCMR2_CC3S_0|
;;;175    			TIM_CCMR2_IC3F_2|
;;;176    			TIM_CCMR2_IC4F_2);	//  3 4    ,  6*Fdts/2.
;;;177    	
;;;178    	timptr->DIER=  (
000cea  201e              MOVS     r0,#0x1e
000cec  81a0              STRH     r0,[r4,#0xc]
;;;179    //			TIM_DIER_UIE|		//   .
;;;180    			TIM_DIER_CC1IE|
;;;181    			TIM_DIER_CC2IE|		//   1  2 .
;;;182    			TIM_DIER_CC3IE|
;;;183    			TIM_DIER_CC4IE
;;;184    			);			//   3  4 .
;;;185    	NVIC_EnableIRQ(TCAP_IRQn);		//    TIM.
000cee  f7fffffe          BL       NVIC_EnableIRQ
;;;186    	
;;;187    	timptr->CCER |= (TIM_CCER_CC4E|
000cf2  8c20              LDRH     r0,[r4,#0x20]
000cf4  e04a              B        |L1.3468|
000cf6  0000              DCW      0x0000
                  |L1.3320|
000cf8  256400            DCB      "%d",0
000cfb  00                DCB      0
                  |L1.3324|
                          DCD      lbuf0
                  |L1.3328|
                          DCD      ActBuffer
                  |L1.3332|
                          DCD      lbuf1
                  |L1.3336|
                          DCD      lbuf2
                  |L1.3340|
                          DCD      lbuf3
                  |L1.3344|
                          DCD      lbufinfo
                  |L1.3348|
                          DCD      0x40010810
                  |L1.3352|
                          DCD      LsrState
                  |L1.3356|
                          DCD      0x40000040
                  |L1.3360|
                          DCD      0x40010800
                  |L1.3364|
                          DCD      Laser
                  |L1.3368|
                          DCD      0x40021000
                  |L1.3372|
                          DCD      0x40010000
                  |L1.3376|
                          DCD      0x40010c08
                  |L1.3380|
                          DCD      tab_enc
                  |L1.3384|
                          DCD      EncDir
                  |L1.3388|
                          DCD      DebCNT1
                  |L1.3392|
                          DCD      fDebug
                  |L1.3396|
                          DCD      indxmem
                  |L1.3400|
                          DCD      SpBuf
                  |L1.3404|
                          DCD      SpBuf1
                  |L1.3408|
                          DCD      VoltageMotor
                  |L1.3412|
                          DCD      i_value
                  |L1.3416|
                          DCD      0x001f0180
                  |L1.3420|
                          DCD      SpeedMotor
                  |L1.3424|
                          DCD      k_prp
                  |L1.3428|
                          DCD      k_int
                  |L1.3432|
                          DCD      k_com
                  |L1.3436|
                          DCD      0x40012c34
                  |L1.3440|
                          DCD      DirX
                  |L1.3444|
                          DCD      LaserPos
                  |L1.3448|
                          DCD      k_dif
                  |L1.3452|
                          DCD      0x40000800
                  |L1.3456|
                          DCD      CapNCCR
                  |L1.3460|
                          DCD      CapCNT
                  |L1.3464|
                          DCD      0x0007c060
                  |L1.3468|
000d8c  f2431131          MOV      r1,#0x3131
000d90  4308              ORRS     r0,r0,r1
000d92  8420              STRH     r0,[r4,#0x20]
;;;188    			TIM_CCER_CC4P|		// 4    .
;;;189    			TIM_CCER_CC3E|		// 3    .
;;;190    			TIM_CCER_CC2E|
;;;191    			TIM_CCER_CC2P|		// 2    .
;;;192    			TIM_CCER_CC1E);		// 1    .
;;;193    	timptr->CR1 |= TIM_CR1_CEN;		//  .
000d94  8820              LDRH     r0,[r4,#0]
000d96  f0400001          ORR      r0,r0,#1
000d9a  8020              STRH     r0,[r4,#0]
;;;194    	ActBuffer=lbuf0;			//    .
000d9c  48e3              LDR      r0,|L1.4396|
000d9e  49e4              LDR      r1,|L1.4400|
000da0  6008              STR      r0,[r1,#0]  ; ActBuffer
;;;195    }// ---------------------------------------------
000da2  bd10              POP      {r4,pc}
;;;17     #endif
                          ENDP

                  RemapToRAM PROC
;;;29     }// ---------------------------------------------
;;;30     /* __inline */ void RemapToRAM(){		//
000da4  2000              MOVS     r0,#0
;;;31     // ----------------------------------------------	
;;;32     	RCC->CIR = 0x00000000;			//  .
000da6  49e3              LDR      r1,|L1.4404|
000da8  6088              STR      r0,[r1,#8]
;;;33     	SCB->VTOR = SRAM_BASE;			//   .
000daa  0448              LSLS     r0,r1,#17
000dac  49e2              LDR      r1,|L1.4408|
000dae  6008              STR      r0,[r1,#0]
;;;34     }// ---------------------------------------------
000db0  4770              BX       lr
;;;35     #include "src\cmd.c"
                          ENDP

                  InitCMD PROC
;;;5      
;;;6      void InitCMD (){				//    .   "N"
000db2  b500              PUSH     {lr}
;;;7      // ----------------------------------------------
;;;8      	ASK();					//   .
000db4  f7fffffe          BL       ASK
;;;9      	SCB->AIRCR=(0x5FA0000+SCB_AIRCR_SYSRESETREQ);		//     .
000db8  48e0              LDR      r0,|L1.4412|
000dba  49df              LDR      r1,|L1.4408|
000dbc  1d09              ADDS     r1,r1,#4
000dbe  6008              STR      r0,[r1,#0]
;;;10     }//______________________________________________
000dc0  bd00              POP      {pc}
;;;11     void SetAXS (char *ptr,uint cnt){		//    .   "a"
                          ENDP

                  SetAXS PROC
000dc2  b57c              PUSH     {r2-r6,lr}
000dc4  4604              MOV      r4,r0
000dc6  460d              MOV      r5,r1
;;;12     // ----------------------------------------------
;;;13     char chr;
;;;14     int pos;
;;;15     
;;;16     if	(sscanf(ptr,"%c%d", &chr, &pos)==2)
000dc8  466b              MOV      r3,sp
000dca  aa01              ADD      r2,sp,#4
000dcc  f2af5118          ADR      r1,|L1.2232|
000dd0  4620              MOV      r0,r4
000dd2  f7fffffe          BL       __0sscanf
000dd6  2802              CMP      r0,#2
000dd8  d114              BNE      |L1.3588|
;;;17      {
;;;18      if      (chr=='x') CurrLaserPos=CalcStepX(pos);
000dda  f89d0004          LDRB     r0,[sp,#4]
000dde  2878              CMP      r0,#0x78
000de0  d105              BNE      |L1.3566|
000de2  9800              LDR      r0,[sp,#0]
000de4  f7fffffe          BL       CalcStepX
000de8  49d5              LDR      r1,|L1.4416|
000dea  6008              STR      r0,[r1,#0]  ; lbufinfo
000dec  e008              B        |L1.3584|
                  |L1.3566|
;;;19      else if (chr=='y') CurrStepPos =CalcStepY(pos);
000dee  f89d0004          LDRB     r0,[sp,#4]
000df2  2879              CMP      r0,#0x79
000df4  d104              BNE      |L1.3584|
000df6  9800              LDR      r0,[sp,#0]
000df8  f7fffffe          BL       CalcStepY
000dfc  49d0              LDR      r1,|L1.4416|
000dfe  6048              STR      r0,[r1,#4]  ; lbufinfo
                  |L1.3584|
;;;20     	ASK();					//   .
000e00  f7fffffe          BL       ASK
                  |L1.3588|
;;;21      }	
;;;22     }//______________________________________________
000e04  bd7c              POP      {r2-r6,pc}
;;;23     void ExecCMD(char *ptr, uint cnt){		//    .	  "G2012345"
                          ENDP

                  ExecCMD PROC
000e06  b538              PUSH     {r3-r5,lr}
000e08  4604              MOV      r4,r0
000e0a  460d              MOV      r5,r1
;;;24     // ----------------------------------------------
;;;25     uint eaddr;	
;;;26     
;;;27      if	(sscanf(ptr,"%x", &eaddr)==1)
000e0c  466a              MOV      r2,sp
000e0e  a1cd              ADR      r1,|L1.4420|
000e10  4620              MOV      r0,r4
000e12  f7fffffe          BL       __0sscanf
000e16  2801              CMP      r0,#1
000e18  d104              BNE      |L1.3620|
;;;28      {
;;;29     	ASK();					//   .
000e1a  f7fffffe          BL       ASK
;;;30     	Execute(eaddr);				//  .
000e1e  9800              LDR      r0,[sp,#0]
000e20  f7fffffe          BL       Execute
                  |L1.3620|
;;;31      }	
;;;32     }//______________________________________________
000e24  bd38              POP      {r3-r5,pc}
;;;33     void ReadState(){				//    .	  "I"
                          ENDP

                  ReadState PROC
000e26  b500              PUSH     {lr}
;;;34     // ----------------------------------------------
;;;35     	SER_PutChar(State);			//    .
000e28  48c7              LDR      r0,|L1.4424|
000e2a  7800              LDRB     r0,[r0,#0]  ; State
000e2c  f7fffffe          BL       SER_PutChar
;;;36     }//______________________________________________
000e30  bd00              POP      {pc}
;;;37     void ReadInfo(){				//    .	  "i"
                          ENDP

                  ReadInfo PROC
000e32  b500              PUSH     {lr}
000e34  b087              SUB      sp,sp,#0x1c
;;;38     // ----------------------------------------------
;;;39     	printf(" -b0 0x%p -b1 0x%p -sz %d -rx %d -ux %d -ry %d -uy %d -pi 0x%p -si %d",
000e36  202c              MOVS     r0,#0x2c
000e38  49c1              LDR      r1,|L1.4416|
000e3a  f44f727a          MOV      r2,#0x3e8
000e3e  f44f73c8          MOV      r3,#0x190
000e42  e9cd3202          STRD     r3,r2,[sp,#8]
000e46  e9cd1004          STRD     r1,r0,[sp,#0x10]
000e4a  f24620fb          MOV      r0,#0x62fb
000e4e  f44f7116          MOV      r1,#0x258
000e52  f240238a          MOV      r3,#0x28a
000e56  4abd              LDR      r2,|L1.4428|
000e58  e9cd1000          STRD     r1,r0,[sp,#0]
000e5c  49b3              LDR      r1,|L1.4396|
000e5e  48bc              LDR      r0,|L1.4432|
000e60  f7fffffe          BL       __2printf
;;;40     	lbuf0,lbuf1,SizeBufLL,ResolX,UnitX,ResolY,UnitY,&lbufinfo,sizeof lbufinfo);	//  .
;;;41     }//______________________________________________
000e64  b007              ADD      sp,sp,#0x1c
000e66  bd00              POP      {pc}
;;;42     void ReadCMD(char *ptr,uint cnt){		//    .	  "w012345,4#"
                          ENDP

                  ReadCMD PROC
000e68  b57c              PUSH     {r2-r6,lr}
000e6a  4604              MOV      r4,r0
000e6c  460d              MOV      r5,r1
;;;43     // ----------------------------------------------
;;;44     uint *raddr; uint rdata;
;;;45      if	(sscanf(ptr,"%p,%x", &raddr, &rdata)==2)
000e6e  466b              MOV      r3,sp
000e70  aa01              ADD      r2,sp,#4
000e72  a1b8              ADR      r1,|L1.4436|
000e74  4620              MOV      r0,r4
000e76  f7fffffe          BL       __0sscanf
000e7a  2802              CMP      r0,#2
000e7c  d104              BNE      |L1.3720|
;;;46      {
;;;47     	printf("0x%x",(raddr[0]));		//  .
000e7e  9801              LDR      r0,[sp,#4]
000e80  6801              LDR      r1,[r0,#0]
000e82  a0b6              ADR      r0,|L1.4444|
000e84  f7fffffe          BL       __2printf
                  |L1.3720|
;;;48      }	
;;;49     }//______________________________________________
000e88  bd7c              POP      {r2-r6,pc}
;;;50     void WriteCMD(char *ptr,uint cnt){		//    .	  ""W012345,8765#"
                          ENDP

                  WriteCMD PROC
000e8a  b57c              PUSH     {r2-r6,lr}
000e8c  4604              MOV      r4,r0
000e8e  460d              MOV      r5,r1
;;;51     // ----------------------------------------------
;;;52     uint wdata, *waddr;
;;;53     
;;;54      if	(sscanf(ptr,"%p,%x", &waddr, &wdata)==2)
000e90  ab01              ADD      r3,sp,#4
000e92  466a              MOV      r2,sp
000e94  a1af              ADR      r1,|L1.4436|
000e96  4620              MOV      r0,r4
000e98  f7fffffe          BL       __0sscanf
000e9c  2802              CMP      r0,#2
000e9e  d104              BNE      |L1.3754|
;;;55      {
;;;56     	ASK();					//   .
000ea0  f7fffffe          BL       ASK
;;;57     	waddr[0]=wdata;				//    .
000ea4  e9dd1000          LDRD     r1,r0,[sp,#0]
000ea8  6008              STR      r0,[r1,#0]
                  |L1.3754|
;;;58      }	
;;;59     }//______________________________________________
000eaa  bd7c              POP      {r2-r6,pc}
;;;60     
                          ENDP

                  SendCMD PROC
;;;61     void SendCMD(char *ptr,uint cnt){		//    .	  ""Saaa,ll,xxx...xx"
000eac  b57c              PUSH     {r2-r6,lr}
000eae  4605              MOV      r5,r0
000eb0  460e              MOV      r6,r1
;;;62     // ----------------------------------------------
;;;63     uint len,num;
;;;64     char * pbuf;
;;;65     
;;;66      if	(sscanf(ptr,"%d,%d", &num, &len)==2)
000eb2  ab01              ADD      r3,sp,#4
000eb4  466a              MOV      r2,sp
000eb6  a1ab              ADR      r1,|L1.4452|
000eb8  4628              MOV      r0,r5
000eba  f7fffffe          BL       __0sscanf
000ebe  2802              CMP      r0,#2
000ec0  d11e              BNE      |L1.3840|
;;;67      {
;;;68       if	((num<=3)&&(len<=SizeBufLL))
000ec2  9800              LDR      r0,[sp,#0]
000ec4  2803              CMP      r0,#3
000ec6  d81b              BHI      |L1.3840|
000ec8  f240218a          MOV      r1,#0x28a
000ecc  9801              LDR      r0,[sp,#4]
000ece  4288              CMP      r0,r1
000ed0  d816              BHI      |L1.3840|
;;;69       {
;;;70        if	   (num==0) pbuf=lbuf0;
000ed2  9800              LDR      r0,[sp,#0]
000ed4  b908              CBNZ     r0,|L1.3802|
000ed6  4c95              LDR      r4,|L1.4396|
000ed8  e00a              B        |L1.3824|
                  |L1.3802|
;;;71        else if (num==1) pbuf=lbuf1;
000eda  9800              LDR      r0,[sp,#0]
000edc  2801              CMP      r0,#1
000ede  d101              BNE      |L1.3812|
000ee0  4c9a              LDR      r4,|L1.4428|
000ee2  e005              B        |L1.3824|
                  |L1.3812|
;;;72        else if (num==2) pbuf=lbuf2;
000ee4  9800              LDR      r0,[sp,#0]
000ee6  2802              CMP      r0,#2
000ee8  d101              BNE      |L1.3822|
000eea  4ca0              LDR      r4,|L1.4460|
000eec  e000              B        |L1.3824|
                  |L1.3822|
;;;73        else		    pbuf=lbuf3;
000eee  4ca0              LDR      r4,|L1.4464|
                  |L1.3824|
;;;74     	ASK();					//   .
000ef0  f7fffffe          BL       ASK
;;;75     	READ_FROM_COM(pbuf,len);		// 
000ef4  4620              MOV      r0,r4
000ef6  9901              LDR      r1,[sp,#4]
000ef8  f7fffffe          BL       READ_FROM_COM
;;;76     	ASK();					//   .
000efc  f7fffffe          BL       ASK
                  |L1.3840|
;;;77       }	
;;;78      }	
;;;79     }//______________________________________________
000f00  bd7c              POP      {r2-r6,pc}
;;;80     void ReceCMD(char *ptr,uint cnt){		//    .	  ""saaa,ll"
                          ENDP

                  ReceCMD PROC
000f02  b57c              PUSH     {r2-r6,lr}
000f04  4604              MOV      r4,r0
000f06  460d              MOV      r5,r1
;;;81     
;;;82     char *rptr; uint rcnt;
;;;83     
;;;84      if	(sscanf(ptr,"%p,%d", &rptr, &rcnt)==2)
000f08  466b              MOV      r3,sp
000f0a  aa01              ADD      r2,sp,#4
000f0c  a199              ADR      r1,|L1.4468|
000f0e  4620              MOV      r0,r4
000f10  f7fffffe          BL       __0sscanf
000f14  2802              CMP      r0,#2
000f16  d103              BNE      |L1.3872|
;;;85      {
;;;86     	WRITE_TO_COM(rptr,rcnt);
000f18  e9dd1000          LDRD     r1,r0,[sp,#0]
000f1c  f7fffffe          BL       WRITE_TO_COM
                  |L1.3872|
;;;87      }	
;;;88     }//______________________________________________
000f20  bd7c              POP      {r2-r6,pc}
;;;89     void SetSpeed(char *ptr, uint cnt){		//    .	  "vx(y)1234567"
                          ENDP

                  SetSpeed PROC
000f22  b57c              PUSH     {r2-r6,lr}
000f24  4604              MOV      r4,r0
000f26  460d              MOV      r5,r1
;;;90     // ----------------------------------------------
;;;91     char chr; uint val;
;;;92      if	(sscanf(ptr,"%c%d",&chr,&val)==2)
000f28  466b              MOV      r3,sp
000f2a  aa01              ADD      r2,sp,#4
000f2c  f2af6178          ADR      r1,|L1.2232|
000f30  4620              MOV      r0,r4
000f32  f7fffffe          BL       __0sscanf
000f36  2802              CMP      r0,#2
000f38  d110              BNE      |L1.3932|
;;;93      {
;;;94       if	  (chr=='x') SpeedX=val;
000f3a  f89d0004          LDRB     r0,[sp,#4]
000f3e  2878              CMP      r0,#0x78
000f40  d103              BNE      |L1.3914|
000f42  498e              LDR      r1,|L1.4476|
000f44  9800              LDR      r0,[sp,#0]
000f46  6008              STR      r0,[r1,#0]  ; SpeedX
000f48  e006              B        |L1.3928|
                  |L1.3914|
;;;95       else if (chr=='y') SpeedY=val;
000f4a  f89d0004          LDRB     r0,[sp,#4]
000f4e  2879              CMP      r0,#0x79
000f50  d102              BNE      |L1.3928|
000f52  498b              LDR      r1,|L1.4480|
000f54  9800              LDR      r0,[sp,#0]
000f56  6008              STR      r0,[r1,#0]  ; SpeedY
                  |L1.3928|
;;;96     	ASK();					//   .
000f58  f7fffffe          BL       ASK
                  |L1.3932|
;;;97      }
;;;98     }//______________________________________________
000f5c  bd7c              POP      {r2-r6,pc}
;;;99     void DebugCMD (char *ptr,uint cnt){		//  .
                          ENDP

                  DebugCMD PROC
000f5e  b570              PUSH     {r4-r6,lr}
000f60  4604              MOV      r4,r0
000f62  460d              MOV      r5,r1
;;;100    // ----------------------------------------------
;;;101    	sscanf(ptr,"%d",&fDebug);		//     .
000f64  4a87              LDR      r2,|L1.4484|
000f66  f2af2170          ADR      r1,|L1.3320|
000f6a  4620              MOV      r0,r4
000f6c  f7fffffe          BL       __0sscanf
;;;102    	ASK();					//   .
000f70  f7fffffe          BL       ASK
;;;103    }// ---------------------------------------------
000f74  bd70              POP      {r4-r6,pc}
;;;104    
                          ENDP

                  CHECK_CMD PROC
;;;105    void CHECK_CMD(char *ptr,uint cnt){		//    .
000f76  b570              PUSH     {r4-r6,lr}
000f78  4605              MOV      r5,r0
000f7a  460e              MOV      r6,r1
;;;106    // ----------------------------------------------
;;;107    	char chr=ptr[0];
000f7c  782c              LDRB     r4,[r5,#0]
;;;108    //WRITE_TO_COM(ptr,cnt);			//   .
;;;109    	ptr++; cnt--; ptr[cnt]=0;
000f7e  1c6d              ADDS     r5,r5,#1
000f80  1e76              SUBS     r6,r6,#1
000f82  2000              MOVS     r0,#0
000f84  55a8              STRB     r0,[r5,r6]
;;;110    	
;;;111         if (chr=='I') ReadState();			//   .
000f86  2c49              CMP      r4,#0x49
000f88  d102              BNE      |L1.3984|
000f8a  f7fffffe          BL       ReadState
000f8e  e06a              B        |L1.4198|
                  |L1.3984|
;;;112    else if (chr=='m') MoveCMD(ptr,cnt);		//   .
000f90  2c6d              CMP      r4,#0x6d
000f92  d104              BNE      |L1.3998|
000f94  4631              MOV      r1,r6
000f96  4628              MOV      r0,r5
000f98  f7fffffe          BL       MoveCMD
000f9c  e063              B        |L1.4198|
                  |L1.3998|
;;;113    else if (chr=='l') LaserCMD(ptr,cnt);		//   .
000f9e  2c6c              CMP      r4,#0x6c
000fa0  d104              BNE      |L1.4012|
000fa2  4631              MOV      r1,r6
000fa4  4628              MOV      r0,r5
000fa6  f7fffffe          BL       LaserCMD
000faa  e05c              B        |L1.4198|
                  |L1.4012|
;;;114    else if (chr=='S') SendCMD(ptr,cnt);		//   .
000fac  2c53              CMP      r4,#0x53
000fae  d104              BNE      |L1.4026|
000fb0  4631              MOV      r1,r6
000fb2  4628              MOV      r0,r5
000fb4  f7fffffe          BL       SendCMD
000fb8  e055              B        |L1.4198|
                  |L1.4026|
;;;115    else if (chr=='s') ReceCMD(ptr,cnt);		//   .
000fba  2c73              CMP      r4,#0x73
000fbc  d104              BNE      |L1.4040|
000fbe  4631              MOV      r1,r6
000fc0  4628              MOV      r0,r5
000fc2  f7fffffe          BL       ReceCMD
000fc6  e04e              B        |L1.4198|
                  |L1.4040|
;;;116    else if (chr=='v') SetSpeed(ptr,cnt);		//    .
000fc8  2c76              CMP      r4,#0x76
000fca  d104              BNE      |L1.4054|
000fcc  4631              MOV      r1,r6
000fce  4628              MOV      r0,r5
000fd0  f7fffffe          BL       SetSpeed
000fd4  e047              B        |L1.4198|
                  |L1.4054|
;;;117    else if (chr=='b') SetBuffer(ptr,cnt);		//    .
000fd6  2c62              CMP      r4,#0x62
000fd8  d104              BNE      |L1.4068|
000fda  4631              MOV      r1,r6
000fdc  4628              MOV      r0,r5
000fde  f7fffffe          BL       SetBuffer
000fe2  e040              B        |L1.4198|
                  |L1.4068|
;;;118    
;;;119    else if (chr=='w') ReadCMD(ptr,cnt);		//  .
000fe4  2c77              CMP      r4,#0x77
000fe6  d104              BNE      |L1.4082|
000fe8  4631              MOV      r1,r6
000fea  4628              MOV      r0,r5
000fec  f7fffffe          BL       ReadCMD
000ff0  e039              B        |L1.4198|
                  |L1.4082|
;;;120    else if (chr=='W') WriteCMD(ptr,cnt);		//  .
000ff2  2c57              CMP      r4,#0x57
000ff4  d104              BNE      |L1.4096|
000ff6  4631              MOV      r1,r6
000ff8  4628              MOV      r0,r5
000ffa  f7fffffe          BL       WriteCMD
000ffe  e032              B        |L1.4198|
                  |L1.4096|
;;;121    else if (chr=='G') ExecCMD(ptr,cnt);		//  .
001000  2c47              CMP      r4,#0x47
001002  d104              BNE      |L1.4110|
001004  4631              MOV      r1,r6
001006  4628              MOV      r0,r5
001008  f7fffffe          BL       ExecCMD
00100c  e02b              B        |L1.4198|
                  |L1.4110|
;;;122    else if (chr=='a') SetAXS(ptr,cnt);		//  .
00100e  2c61              CMP      r4,#0x61
001010  d104              BNE      |L1.4124|
001012  4631              MOV      r1,r6
001014  4628              MOV      r0,r5
001016  f7fffffe          BL       SetAXS
00101a  e024              B        |L1.4198|
                  |L1.4124|
;;;123    else if (chr=='c') ASK();			//  .
00101c  2c63              CMP      r4,#0x63
00101e  d102              BNE      |L1.4134|
001020  f7fffffe          BL       ASK
001024  e01f              B        |L1.4198|
                  |L1.4134|
;;;124    else if (chr=='i') ReadInfo();			//   .
001026  2c69              CMP      r4,#0x69
001028  d102              BNE      |L1.4144|
00102a  f7fffffe          BL       ReadInfo
00102e  e01a              B        |L1.4198|
                  |L1.4144|
;;;125    else if (chr=='N') InitCMD();			//  .
001030  2c4e              CMP      r4,#0x4e
001032  d102              BNE      |L1.4154|
001034  f7fffffe          BL       InitCMD
001038  e015              B        |L1.4198|
                  |L1.4154|
;;;126    else if (chr=='p') SavePID(ptr,cnt);		//    .
00103a  2c70              CMP      r4,#0x70
00103c  d104              BNE      |L1.4168|
00103e  4631              MOV      r1,r6
001040  4628              MOV      r0,r5
001042  f7fffffe          BL       SavePID
001046  e00e              B        |L1.4198|
                  |L1.4168|
;;;127    else if (chr=='d') DebugCMD(ptr,cnt);		//  .
001048  2c64              CMP      r4,#0x64
00104a  d104              BNE      |L1.4182|
00104c  4631              MOV      r1,r6
00104e  4628              MOV      r0,r5
001050  f7fffffe          BL       DebugCMD
001054  e007              B        |L1.4198|
                  |L1.4182|
;;;128    else if (chr=='o') printf ("\r\npos %d %d",CurrLaserPos,CurrStepPos);		//
001056  2c6f              CMP      r4,#0x6f
001058  d105              BNE      |L1.4198|
00105a  4839              LDR      r0,|L1.4416|
00105c  6842              LDR      r2,[r0,#4]  ; lbufinfo
00105e  6801              LDR      r1,[r0,#0]  ; lbufinfo
001060  a049              ADR      r0,|L1.4488|
001062  f7fffffe          BL       __2printf
                  |L1.4198|
;;;129    //else if (chr=='x') xTempCMD();		//
;;;130    //else if (chr=='z') TempCMD(ptr,cnt);		//
;;;131    
;;;132    }//______________________________________________
001066  bd70              POP      {r4-r6,pc}
;;;36     
                          ENDP

                  CHECK_INPUT PROC
;;;37     uint CHECK_INPUT(char *ptr, uint i){		//      .
001068  b570              PUSH     {r4-r6,lr}
00106a  4606              MOV      r6,r0
00106c  460c              MOV      r4,r1
;;;38     // ----------------------------------------------
;;;39     //	ptr	   .
;;;40     //	i	   .
;;;41     char chr;					//  .
;;;42     
;;;43      while	(SER_CheckCharRx())
00106e  e015              B        |L1.4252|
                  |L1.4208|
;;;44      {	chr=SER_ReadChar();
001070  bf00              NOP      
001072  4848              LDR      r0,|L1.4500|
001074  8800              LDRH     r0,[r0,#0]
001076  b2c5              UXTB     r5,r0
001078  bf00              NOP      
;;;45       if	((i<SIZEBUFRX)&&(chr>' '))
00107a  2c1f              CMP      r4,#0x1f
00107c  d204              BCS      |L1.4232|
00107e  2d20              CMP      r5,#0x20
001080  dd02              BLE      |L1.4232|
;;;46       {
;;;47     	ptr[i]=chr; i++;
001082  5535              STRB     r5,[r6,r4]
001084  1c64              ADDS     r4,r4,#1
001086  e009              B        |L1.4252|
                  |L1.4232|
;;;48       }
;;;49       else if (((chr==13)||(chr==10))&&(i>0))
001088  2d0d              CMP      r5,#0xd
00108a  d001              BEQ      |L1.4240|
00108c  2d0a              CMP      r5,#0xa
00108e  d105              BNE      |L1.4252|
                  |L1.4240|
001090  b124              CBZ      r4,|L1.4252|
;;;50       {
;;;51     	CHECK_CMD(ptr,i); i=0;
001092  4621              MOV      r1,r4
001094  4630              MOV      r0,r6
001096  f7fffffe          BL       CHECK_CMD
00109a  2400              MOVS     r4,#0
                  |L1.4252|
00109c  f7fffffe          BL       SER_CheckCharRx
0010a0  2800              CMP      r0,#0                 ;43
0010a2  d1e5              BNE      |L1.4208|
;;;52       }
;;;53      }	 
;;;54      	return i;
0010a4  4620              MOV      r0,r4
;;;55     }//______________________________________________
0010a6  bd70              POP      {r4-r6,pc}
;;;56     int main(){					//
                          ENDP

                  main PROC
0010a8  2400              MOVS     r4,#0
;;;57     uint i=0;
;;;58     	RemapToRAM();				//     RAM.
0010aa  f7fffffe          BL       RemapToRAM
;;;59     	
;;;60     	RCC->APB2ENR|=	RCC_APB2ENR_AFIOEN|	//   .
0010ae  4821              LDR      r0,|L1.4404|
0010b0  6980              LDR      r0,[r0,#0x18]
0010b2  f040000d          ORR      r0,r0,#0xd
0010b6  491f              LDR      r1,|L1.4404|
0010b8  6188              STR      r0,[r1,#0x18]
;;;61     			RCC_APB2ENR_IOPAEN|	//   A.
;;;62     			RCC_APB2ENR_IOPBEN;     //   B.
;;;63     	SER_Init1();				//    1
0010ba  f7fffffe          BL       SER_Init1
;;;64     	TIM_Init_PWM();				//   .
0010be  f7fffffe          BL       TIM_Init_PWM
;;;65     	MotorBreak();				// -.
0010c2  f7fffffe          BL       MotorBreak
;;;66     	TIM_Init_TOT();				//   .
0010c6  f7fffffe          BL       TIM_Init_TOT
;;;67     	TIM_Init_ENC();				//  .
0010ca  f7fffffe          BL       TIM_Init_ENC
;;;68     	InitPinsSteps();			//    .
0010ce  f7fffffe          BL       InitPinsSteps
;;;69     	InitTimerSteps();			//   .
0010d2  f7fffffe          BL       InitTimerSteps
;;;70     	InitLaser();				//   .
0010d6  f7fffffe          BL       InitLaser
;;;71     	LaserCTRL(0);				//  .
0010da  2000              MOVS     r0,#0
0010dc  f7fffffe          BL       LaserCTRL
;;;72     	LEDS_Init();				//    .
0010e0  bf00              NOP      
0010e2  482d              LDR      r0,|L1.4504|
0010e4  6800              LDR      r0,[r0,#0]
0010e6  f420407f          BIC      r0,r0,#0xff00
0010ea  492b              LDR      r1,|L1.4504|
0010ec  6008              STR      r0,[r1,#0]
0010ee  4608              MOV      r0,r1
0010f0  6800              LDR      r0,[r0,#0]
0010f2  f4405008          ORR      r0,r0,#0x2200
0010f6  6008              STR      r0,[r1,#0]
0010f8  bf00              NOP      
;;;73     	VoltageMotor=MAX_PWM;			//    .
0010fa  20ff              MOVS     r0,#0xff
0010fc  4927              LDR      r1,|L1.4508|
0010fe  6008              STR      r0,[r1,#0]  ; VoltageMotor
;;;74     	printf ("\r\nHLDI RAM ready\r\n>");
001100  a027              ADR      r0,|L1.4512|
001102  f7fffffe          BL       __2printf
;;;75     //	CaretToHome();
;;;76     //	printf("\r\n0x%x", RCC->CFGR);
;;;77     //	printf("\r\n 0x%8x 0x%8x", RCC->CFGR,RCC->CR);
;;;78     //	printf("\r\n set TOT %d",tot);
;;;79     	
;;;80     
;;;81      while(1)
001106  e004              B        |L1.4370|
                  |L1.4360|
;;;82      {
;;;83     	i=CHECK_INPUT(RxBuf,i);			//   .
001108  4621              MOV      r1,r4
00110a  482a              LDR      r0,|L1.4532|
00110c  f7fffffe          BL       CHECK_INPUT
001110  4604              MOV      r4,r0
                  |L1.4370|
001112  e7f9              B        |L1.4360|
;;;84     //	PrintStateM();
;;;85      }
;;;86     }// ---------------------------------------------
                          ENDP

                  NVIC_EnableIRQ PROC
;;;1307    */
;;;1308   __STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
001114  f000021f          AND      r2,r0,#0x1f
;;;1309   {
;;;1310     NVIC->ISER[((uint32_t)(IRQn) >> 5)] = (1 << ((uint32_t)(IRQn) & 0x1F)); /* enable interrupt */
001118  2101              MOVS     r1,#1
00111a  4091              LSLS     r1,r1,r2
00111c  0942              LSRS     r2,r0,#5
00111e  f04f23e0          MOV      r3,#0xe000e000
001122  eb030282          ADD      r2,r3,r2,LSL #2
001126  f8c21100          STR      r1,[r2,#0x100]
;;;1311   }
00112a  4770              BX       lr
;;;1312   
                          ENDP

                  |L1.4396|
                          DCD      lbuf0
                  |L1.4400|
                          DCD      ActBuffer
                  |L1.4404|
                          DCD      0x40021000
                  |L1.4408|
                          DCD      0xe000ed08
                  |L1.4412|
                          DCD      0x05fa0004
                  |L1.4416|
                          DCD      lbufinfo
                  |L1.4420|
001144  257800            DCB      "%x",0
001147  00                DCB      0
                  |L1.4424|
                          DCD      State
                  |L1.4428|
                          DCD      lbuf1
                  |L1.4432|
                          DCD      ||.constdata||+0xb8
                  |L1.4436|
001154  25702c25          DCB      "%p,%x",0
001158  7800    
00115a  00                DCB      0
00115b  00                DCB      0
                  |L1.4444|
00115c  30782578          DCB      "0x%x",0
001160  00      
001161  00                DCB      0
001162  00                DCB      0
001163  00                DCB      0
                  |L1.4452|
001164  25642c25          DCB      "%d,%d",0
001168  6400    
00116a  00                DCB      0
00116b  00                DCB      0
                  |L1.4460|
                          DCD      lbuf2
                  |L1.4464|
                          DCD      lbuf3
                  |L1.4468|
001174  25702c25          DCB      "%p,%d",0
001178  6400    
00117a  00                DCB      0
00117b  00                DCB      0
                  |L1.4476|
                          DCD      SpeedX
                  |L1.4480|
                          DCD      SpeedY
                  |L1.4484|
                          DCD      fDebug
                  |L1.4488|
001188  0d0a706f          DCB      "\r\npos %d %d",0
00118c  73202564
001190  20256400
                  |L1.4500|
                          DCD      0x40013804
                  |L1.4504|
                          DCD      0x40010c04
                  |L1.4508|
                          DCD      VoltageMotor
                  |L1.4512|
0011a0  0d0a484c          DCB      "\r\nHLDI RAM ready\r\n>",0
0011a4  44492052
0011a8  414d2072
0011ac  65616479
0011b0  0d0a3e00
                  |L1.4532|
                          DCD      RxBuf

                          AREA ||.bss||, DATA, NOINIT, ALIGN=2

                  lbuf0
                          %        650
                  lbuf1
                          %        650
                  lbuf2
                          %        650
                  lbuf3
                          %        650
                  RxBuf
                          %        32
                  lbufinfo
                          %        44
                  SpBuf
                          %        2000
                  SpBuf1
                          %        2000

                          AREA ||.constdata||, DATA, READONLY, ALIGN=2

                  StepTable
                          DCD      0x00000080
                          DCD      0x00000090
                          DCD      0x00000010
                          DCD      0x00000050
                          DCD      0x00000040
                          DCD      0x00000060
                          DCD      0x00000020
                          DCD      0x000000a0
                  AccelTable
                          DCD      0x0003ec75
                          DCD      0x00028e10
                          DCD      0x0001aeb3
                          DCD      0x0001681c
                          DCD      0x00013af2
                          DCD      0x00011af1
                          DCD      0x000102f9
                          DCD      0x0000f02c
                          DCD      0x0000e0d0
                          DCD      0x0000d419
                          DCD      0x0000c92d
                          DCD      0x0000bfd8
                          DCD      0x0000b794
                          DCD      0x0000b070
                          DCD      0x0000a9ef
                          DCD      0x0000a42e
                          DCD      0x00009ee4
                          DCD      0x00009a30
                          DCD      0x000095d6
                          DCD      0x000091cc
                          DCD      0x00008e0a
                          DCD      0x00008a9c
                  tab_enc
000078  00000000          DCB      0x00,0x00,0x00,0x00
00007c  0101ffff          DCB      0x01,0x01,0xff,0xff
000080  ffff0101          DCB      0xff,0xff,0x01,0x01
000084  00000000          DCB      0x00,0x00,0x00,0x00
000088  ff01ff01          DCB      0xff,0x01,0xff,0x01
00008c  00000000          DCB      0x00,0x00,0x00,0x00
000090  00000000          DCB      0x00,0x00,0x00,0x00
000094  00000000          DCB      0x00,0x00,0x00,0x00
000098  01ff01ff          DCB      0x01,0xff,0x01,0xff
00009c  00000000          DCB      0x00,0x00,0x00,0x00
0000a0  00000000          DCB      0x00,0x00,0x00,0x00
0000a4  00000000          DCB      0x00,0x00,0x00,0x00
0000a8  00000000          DCB      0x00,0x00,0x00,0x00
0000ac  00000000          DCB      0x00,0x00,0x00,0x00
0000b0  00000000          DCB      0x00,0x00,0x00,0x00
0000b4  00000000          DCB      0x00,0x00,0x00,0x00
0000b8  202d6230          DCB      0x20,0x2d,0x62,0x30
0000bc  20307825          DCB      0x20,0x30,0x78,0x25
0000c0  70202d62          DCB      0x70,0x20,0x2d,0x62
0000c4  31203078          DCB      0x31,0x20,0x30,0x78
0000c8  2570202d          DCB      0x25,0x70,0x20,0x2d
0000cc  737a2025          DCB      0x73,0x7a,0x20,0x25
0000d0  64202d72          DCB      0x64,0x20,0x2d,0x72
0000d4  78202564          DCB      0x78,0x20,0x25,0x64
0000d8  202d7578          DCB      0x20,0x2d,0x75,0x78
0000dc  20256420          DCB      0x20,0x25,0x64,0x20
0000e0  2d727920          DCB      0x2d,0x72,0x79,0x20
0000e4  2564202d          DCB      0x25,0x64,0x20,0x2d
0000e8  75792025          DCB      0x75,0x79,0x20,0x25
0000ec  64202d70          DCB      0x64,0x20,0x2d,0x70
0000f0  69203078          DCB      0x69,0x20,0x30,0x78
0000f4  2570202d          DCB      0x25,0x70,0x20,0x2d
0000f8  73692025          DCB      0x73,0x69,0x20,0x25
0000fc  6400              DCB      0x64,0x00

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

                  SystemCoreClock
                          DCD      0x044aa200
                  AHBPrescTable
000004  00000000          DCB      0x00,0x00,0x00,0x00
000008  00000000          DCB      0x00,0x00,0x00,0x00
00000c  01020304          DCB      0x01,0x02,0x03,0x04
000010  06070809          DCB      0x06,0x07,0x08,0x09
                  DebCNT1
                          DCD      0x00000000
                  CapCNT
                          DCD      0x00000000
                  CapNCCR
                          DCD      0x00000000
                  OldLaserPos
                          DCD      0x00000000
                  indxmem
                          DCD      0x00000000
                  fDebug
                          DCD      0x00000000
                  SpeedX
                          DCD      0x000000c8
                  SpeedMotor
                          DCD      0x00000000
                  k_prp
                          DCD      0x000007d0
                  k_int
                          DCD      0x0000007d
                  k_dif
                          DCD      0x00000001
                  k_com
                          DCD      0x000003e8
                  LaserPos
                          DCD      0x00000000
                  LsrState
                          DCD      0x00000000
                  Laser
                          DCD      0x00000000
                  EncDir
                          DCD      0x00000000
                  AccelPos
                          DCD      0x00000000
                  SpeedY
                          DCD      0x00000000
                  cSpeedY
                          DCD      0x00000000
                  StepTOT
                          DCD      0x00000000
                  StepCNT
                          DCD      0x00000000
                  VoltageMotor
                          DCD      0x00000000
                  DirX
                          DCD      0x00000000
                  p_value
                          DCD      0x00000000
                  i_value
                          DCD      0x00000000
                  d_value
                          DCD      0x00000000
                  ActBuffer
                          DCD      0x00000000
                  DirY
                          DCD      0x00000000
                  State
000084  00000000          DCB      0x00,0x00,0x00,0x00
                  __stdout
                          DCD      0x00000000
                  __stdin
                          DCD      0x00000000
                  __stderr
                          DCD      0x00000000

                          AREA ||i.PWM_Set||, COMGROUP=PWM_Set, CODE, READONLY, ALIGN=2

                  PWM_Set PROC
;;;14     #include "src\motor.c"
;;;1      __inline void PWM_Set(ushort val){		//   .
000000  4901              LDR      r1,|L18.8|
;;;2      // ----------------------------------------------	
;;;3      	TPWM->CCR1=val;				//  .
000002  8008              STRH     r0,[r1,#0]
;;;4      //printf("\r\nmotor rg %d %d", TPWM->CCR1,TPWM->CCR2);
;;;5      } // --------------------------------------------
000004  4770              BX       lr
;;;6      void SetDirDC (int dir){			//   .
                          ENDP

000006  0000              DCW      0x0000
                  |L18.8|
                          DCD      0x40012c34

                          AREA ||i.LaserOff||, COMGROUP=LaserOff, CODE, READONLY, ALIGN=2

                  LaserOff PROC
;;;5      
;;;6      __inline void LaserOff(){			//  .
000000  2003              MOVS     r0,#3
;;;7      // ----------------------------------------------
;;;8      	portLsr->BRR=(1<<pinLsr0|1<<pinLsr1);
000002  4903              LDR      r1,|L24.16|
000004  6008              STR      r0,[r1,#0]
;;;9      	LsrState=0;
000006  2000              MOVS     r0,#0
000008  4902              LDR      r1,|L24.20|
00000a  6008              STR      r0,[r1,#0]  ; LsrState
;;;10     }// ---------------------------------------------
00000c  4770              BX       lr
;;;11     __inline void LaserOn(){			//  .
                          ENDP

00000e  0000              DCW      0x0000
                  |L24.16|
                          DCD      0x40010814
                  |L24.20|
                          DCD      LsrState

;*** Start embedded assembler ***

#line 1 "hldi.c"
	AREA ||.rev16_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___6_hldi_c_5d646a67____REV16|
#line 115 "\\DEVELOP\\BIN\\Keil\\ARM\\CMSIS\\Include\\core_cmInstr.h"
|__asm___6_hldi_c_5d646a67____REV16| PROC
#line 116

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___6_hldi_c_5d646a67____REVSH|
#line 130
|__asm___6_hldi_c_5d646a67____REVSH| PROC
#line 131

 revsh r0, r0
 bx lr
	ENDP
	AREA ||.emb_text||, CODE, READONLY
	THUMB
	EXPORT |Execute|
#line 1 "src\\cmd.c"
|Execute| PROC
#line 1

 
 blx r0
	ENDP

;*** End   embedded assembler ***

                  __ARM_use_no_argv EQU 0
