; 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 -O1 -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\ARMCC\Include -I\DEVELOP\BIN\Keil\ARM\Inc\ST\STM32F10x -D__MICROLIB -DSTM32F10X_MD hldi.c]
                          THUMB

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

                          REQUIRE _scanf_int
                          REQUIRE _scanf_string
                          REQUIRE _printf_percent
                          REQUIRE _printf_d
                          REQUIRE _printf_p
                          REQUIRE _printf_int_dec
                          REQUIRE _printf_longlong_hex
                          REQUIRE _printf_x
                  SetSysClockTo72 PROC
;;;986      */
;;;987    static void SetSysClockTo72(void)
000000  b50c              PUSH     {r2,r3,lr}
;;;988    {
;;;989      __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
000002  2200              MOVS     r2,#0
000004  9201              STR      r2,[sp,#4]
000006  9200              STR      r2,[sp,#0]
;;;990      
;;;991      /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/    
;;;992      /* Enable HSE */    
;;;993      RCC->CR |= ((uint32_t)RCC_CR_HSEON);
000008  48f6              LDR      r0,|L1.996|
00000a  6801              LDR      r1,[r0,#0]
00000c  f4413180          ORR      r1,r1,#0x10000
000010  6001              STR      r1,[r0,#0]
;;;994     
;;;995      /* Wait till HSE is ready and if Time out is reached exit */
;;;996      do
;;;997      {
;;;998        HSEStatus = RCC->CR & RCC_CR_HSERDY;
;;;999        StartUpCounter++;  
;;;1000     } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
000012  f44f63a0          MOV      r3,#0x500
                  |L1.22|
000016  6801              LDR      r1,[r0,#0]            ;998
000018  f4013100          AND      r1,r1,#0x20000        ;998
00001c  9100              STR      r1,[sp,#0]            ;998
00001e  9901              LDR      r1,[sp,#4]            ;999
000020  1c49              ADDS     r1,r1,#1              ;999
000022  9101              STR      r1,[sp,#4]            ;999
000024  9900              LDR      r1,[sp,#0]
000026  b911              CBNZ     r1,|L1.46|
000028  9901              LDR      r1,[sp,#4]
00002a  4299              CMP      r1,r3
00002c  d1f3              BNE      |L1.22|
                  |L1.46|
;;;1001   
;;;1002     if ((RCC->CR & RCC_CR_HSERDY) != RESET)
00002e  6801              LDR      r1,[r0,#0]
000030  0389              LSLS     r1,r1,#14
000032  d502              BPL      |L1.58|
;;;1003     {
;;;1004       HSEStatus = (uint32_t)0x01;
000034  2101              MOVS     r1,#1
000036  9100              STR      r1,[sp,#0]
000038  e000              B        |L1.60|
                  |L1.58|
;;;1005     }
;;;1006     else
;;;1007     {
;;;1008       HSEStatus = (uint32_t)0x00;
00003a  9200              STR      r2,[sp,#0]
                  |L1.60|
;;;1009     }  
;;;1010   
;;;1011     if (HSEStatus == (uint32_t)0x01)
00003c  9900              LDR      r1,[sp,#0]
00003e  2901              CMP      r1,#1
000040  d130              BNE      |L1.164|
;;;1012     {
;;;1013       /* Enable Prefetch Buffer */
;;;1014       FLASH->ACR |= FLASH_ACR_PRFTBE;
000042  49e9              LDR      r1,|L1.1000|
000044  680a              LDR      r2,[r1,#0]
000046  f0420210          ORR      r2,r2,#0x10
00004a  600a              STR      r2,[r1,#0]
;;;1015   
;;;1016       /* Flash 2 wait state */
;;;1017       FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
00004c  680a              LDR      r2,[r1,#0]
00004e  f0220203          BIC      r2,r2,#3
000052  600a              STR      r2,[r1,#0]
;;;1018       FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;    
000054  680a              LDR      r2,[r1,#0]
000056  f0420202          ORR      r2,r2,#2
00005a  600a              STR      r2,[r1,#0]
;;;1019   
;;;1020    
;;;1021       /* HCLK = SYSCLK */
;;;1022       RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
00005c  6841              LDR      r1,[r0,#4]
00005e  6041              STR      r1,[r0,#4]
;;;1023         
;;;1024       /* PCLK2 = HCLK */
;;;1025       RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
000060  6841              LDR      r1,[r0,#4]
000062  6041              STR      r1,[r0,#4]
;;;1026       
;;;1027       /* PCLK1 = HCLK */
;;;1028       RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
000064  6841              LDR      r1,[r0,#4]
000066  f4416180          ORR      r1,r1,#0x400
00006a  6041              STR      r1,[r0,#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 |
00006c  6841              LDR      r1,[r0,#4]
00006e  f421117c          BIC      r1,r1,#0x3f0000
000072  6041              STR      r1,[r0,#4]
;;;1055                                           RCC_CFGR_PLLMULL));
;;;1056       RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);
000074  6841              LDR      r1,[r0,#4]
000076  f44111e8          ORR      r1,r1,#0x1d0000
00007a  6041              STR      r1,[r0,#4]
;;;1057   #endif /* STM32F10X_CL */
;;;1058   
;;;1059       /* Enable PLL */
;;;1060       RCC->CR |= RCC_CR_PLLON;
00007c  6801              LDR      r1,[r0,#0]
00007e  f0417180          ORR      r1,r1,#0x1000000
000082  6001              STR      r1,[r0,#0]
                  |L1.132|
;;;1061   
;;;1062       /* Wait till PLL is ready */
;;;1063       while((RCC->CR & RCC_CR_PLLRDY) == 0)
000084  6801              LDR      r1,[r0,#0]
000086  0189              LSLS     r1,r1,#6
000088  d5fc              BPL      |L1.132|
;;;1064       {
;;;1065       }
;;;1066       
;;;1067       /* Select PLL as system clock source */
;;;1068       RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
00008a  6841              LDR      r1,[r0,#4]
00008c  f0210103          BIC      r1,r1,#3
000090  6041              STR      r1,[r0,#4]
;;;1069       RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;    
000092  6841              LDR      r1,[r0,#4]
000094  f0410102          ORR      r1,r1,#2
000098  6041              STR      r1,[r0,#4]
                  |L1.154|
;;;1070   
;;;1071       /* Wait till PLL is used as system clock source */
;;;1072       while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
00009a  6841              LDR      r1,[r0,#4]
00009c  f3c10181          UBFX     r1,r1,#2,#2
0000a0  2902              CMP      r1,#2
0000a2  d1fa              BNE      |L1.154|
                  |L1.164|
;;;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   }
0000a4  bd0c              POP      {r2,r3,pc}
;;;1081   #endif
                          ENDP

                  SetSysClock PROC
;;;418      */
;;;419    static void SetSysClock(void)
0000a6  e7fe              B        SetSysClockTo72
;;;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();
;;;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    }
;;;438    
                          ENDP

                  SystemInit PROC
;;;211      */
;;;212    void SystemInit (void)
0000a8  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;
0000aa  48ce              LDR      r0,|L1.996|
0000ac  6801              LDR      r1,[r0,#0]
0000ae  f0410101          ORR      r1,r1,#1
0000b2  6001              STR      r1,[r0,#0]
;;;217    
;;;218      /* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
;;;219    #ifndef STM32F10X_CL
;;;220      RCC->CFGR &= (uint32_t)0xF8FF0000;
0000b4  6841              LDR      r1,[r0,#4]
0000b6  4acd              LDR      r2,|L1.1004|
0000b8  4011              ANDS     r1,r1,r2
0000ba  6041              STR      r1,[r0,#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;
0000bc  6801              LDR      r1,[r0,#0]
0000be  4acc              LDR      r2,|L1.1008|
0000c0  4011              ANDS     r1,r1,r2
0000c2  6001              STR      r1,[r0,#0]
;;;227    
;;;228      /* Reset HSEBYP bit */
;;;229      RCC->CR &= (uint32_t)0xFFFBFFFF;
0000c4  6801              LDR      r1,[r0,#0]
0000c6  f4212180          BIC      r1,r1,#0x40000
0000ca  6001              STR      r1,[r0,#0]
;;;230    
;;;231      /* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
;;;232      RCC->CFGR &= (uint32_t)0xFF80FFFF;
0000cc  6841              LDR      r1,[r0,#4]
0000ce  f42101fe          BIC      r1,r1,#0x7f0000
0000d2  6041              STR      r1,[r0,#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;
0000d4  f44f011f          MOV      r1,#0x9f0000
0000d8  6081              STR      r1,[r0,#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();
0000da  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. */
0000de  49c5              LDR      r1,|L1.1012|
0000e0  f04f6000          MOV      r0,#0x8000000
0000e4  6008              STR      r0,[r1,#0]
;;;268    #endif 
;;;269    }
0000e6  bd10              POP      {r4,pc}
;;;270    
                          ENDP

                  SystemCoreClockUpdate PROC
;;;305      */
;;;306    void SystemCoreClockUpdate (void)
0000e8  b510              PUSH     {r4,lr}
;;;307    {
;;;308      uint32_t tmp = 0, pllmull = 0, pllsource = 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;
0000ea  4abe              LDR      r2,|L1.996|
0000ec  6850              LDR      r0,[r2,#4]
0000ee  f000010c          AND      r1,r0,#0xc
;;;320      
;;;321      switch (tmp)
;;;322      {
;;;323        case 0x00:  /* HSI used as system clock */
;;;324          SystemCoreClock = HSI_VALUE;
0000f2  4bc1              LDR      r3,|L1.1016|
0000f4  48c1              LDR      r0,|L1.1020|
0000f6  2900              CMP      r1,#0                 ;321
0000f8  d00e              BEQ      |L1.280|
0000fa  2904              CMP      r1,#4                 ;321
0000fc  d00e              BEQ      |L1.284|
0000fe  2908              CMP      r1,#8                 ;321
000100  d00e              BEQ      |L1.288|
;;;325          break;
;;;326        case 0x04:  /* HSE used as system clock */
;;;327          SystemCoreClock = HSE_VALUE;
;;;328          break;
;;;329        case 0x08:  /* PLL used as system clock */
;;;330    
;;;331          /* Get PLL clock source and multiplication factor ----------------------*/
;;;332          pllmull = RCC->CFGR & RCC_CFGR_PLLMULL;
;;;333          pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
;;;334          
;;;335    #ifndef STM32F10X_CL      
;;;336          pllmull = ( pllmull >> 18) + 2;
;;;337          
;;;338          if (pllsource == 0x00)
;;;339          {
;;;340            /* HSI oscillator clock divided by 2 selected as PLL clock entry */
;;;341            SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
;;;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)
;;;352            {/* HSE oscillator clock divided by 2 */
;;;353              SystemCoreClock = (HSE_VALUE >> 1) * pllmull;
;;;354            }
;;;355            else
;;;356            {
;;;357              SystemCoreClock = HSE_VALUE * pllmull;
;;;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;
;;;401    
;;;402        default:
;;;403          SystemCoreClock = HSI_VALUE;
000102  6083              STR      r3,[r0,#8]  ; SystemCoreClock
                  |L1.260|
;;;404          break;
;;;405      }
;;;406      
;;;407      /* Compute HCLK clock frequency ----------------*/
;;;408      /* Get HCLK prescaler */
;;;409      tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
000104  6851              LDR      r1,[r2,#4]
000106  4abd              LDR      r2,|L1.1020|
000108  f3c11103          UBFX     r1,r1,#4,#4
00010c  3248              ADDS     r2,r2,#0x48
00010e  5c51              LDRB     r1,[r2,r1]
;;;410      /* HCLK clock frequency */
;;;411      SystemCoreClock >>= tmp;  
000110  6882              LDR      r2,[r0,#8]  ; SystemCoreClock
000112  40ca              LSRS     r2,r2,r1
000114  6082              STR      r2,[r0,#8]  ; SystemCoreClock
000116  bd10              POP      {r4,pc}               ;325
                  |L1.280|
000118  6083              STR      r3,[r0,#8]            ;324  ; SystemCoreClock
00011a  e7f3              B        |L1.260|
                  |L1.284|
00011c  6083              STR      r3,[r0,#8]            ;327  ; SystemCoreClock
00011e  e7f1              B        |L1.260|
                  |L1.288|
000120  6851              LDR      r1,[r2,#4]            ;332
000122  f4011170          AND      r1,r1,#0x3c0000       ;332
000126  6853              LDR      r3,[r2,#4]            ;333
000128  f4033380          AND      r3,r3,#0x10000        ;333
00012c  2402              MOVS     r4,#2                 ;336
00012e  eb044191          ADD      r1,r4,r1,LSR #18      ;336
000132  b133              CBZ      r3,|L1.322|
000134  6853              LDR      r3,[r2,#4]            ;351
000136  039b              LSLS     r3,r3,#14             ;351
000138  d507              BPL      |L1.330|
00013a  4bb1              LDR      r3,|L1.1024|
00013c  4359              MULS     r1,r3,r1              ;353
00013e  6081              STR      r1,[r0,#8]            ;353  ; SystemCoreClock
000140  e7e0              B        |L1.260|
                  |L1.322|
000142  4baf              LDR      r3,|L1.1024|
000144  4359              MULS     r1,r3,r1              ;341
000146  6081              STR      r1,[r0,#8]            ;341  ; SystemCoreClock
000148  e7dc              B        |L1.260|
                  |L1.330|
00014a  4bab              LDR      r3,|L1.1016|
00014c  4359              MULS     r1,r3,r1              ;357
00014e  6081              STR      r1,[r0,#8]            ;357  ; SystemCoreClock
000150  e7d8              B        |L1.260|
;;;412    }
;;;413    
                          ENDP

                  CalcStepX PROC
;;;45     
;;;46     int CalcStepX(int pos){				//        POS.
000152  49ac              LDR      r1,|L1.1028|
;;;47     // ----------------------------------------------
;;;48     //printf("\r\n>w");
;;;49     	return((pos*ResolX*2/UnitX+1)/2);
000154  690a              LDR      r2,[r1,#0x10]  ; lcnfbuf
000156  6949              LDR      r1,[r1,#0x14]  ; lcnfbuf
000158  4342              MULS     r2,r0,r2
00015a  0050              LSLS     r0,r2,#1
00015c  fb90f0f1          SDIV     r0,r0,r1
000160  1c40              ADDS     r0,r0,#1
000162  eb0070d0          ADD      r0,r0,r0,LSR #31
000166  1040              ASRS     r0,r0,#1
;;;50     }
000168  4770              BX       lr
;;;51     int CalcStepY(int pos){				//        POS.
                          ENDP

                  CalcStepY PROC
00016a  49a6              LDR      r1,|L1.1028|
;;;52     // ----------------------------------------------
;;;53     //printf("\r\n>w");
;;;54     	return((pos*ResolY*2/UnitY+1)/2);
00016c  698a              LDR      r2,[r1,#0x18]  ; lcnfbuf
00016e  69c9              LDR      r1,[r1,#0x1c]  ; lcnfbuf
000170  4342              MULS     r2,r0,r2
000172  0050              LSLS     r0,r2,#1
000174  fb90f0f1          SDIV     r0,r0,r1
000178  1c40              ADDS     r0,r0,#1
00017a  eb0070d0          ADD      r0,r0,r0,LSR #31
00017e  1040              ASRS     r0,r0,#1
;;;55     }
000180  4770              BX       lr
;;;13     #include "src\comport.c"
                          ENDP

                  SER_Init1 PROC
;;;10     //_______________________________________________
;;;11     void SER_Init1 (void) {
000182  48a1              LDR      r0,|L1.1032|
;;;12     //-----------------------------------------------
;;;13       AFIO->MAPR &=~AFIO_MAPR_USART1_REMAP;		// clear USART1 remap (PA9, PA10)
000184  6841              LDR      r1,[r0,#4]
000186  f0210104          BIC      r1,r1,#4
00018a  6041              STR      r1,[r0,#4]
;;;14     
;;;15       portRS1_CR &=~(GPIO_CRH_CNF10|GPIO_CRH_MODE10
00018c  489f              LDR      r0,|L1.1036|
00018e  6801              LDR      r1,[r0,#0]
000190  f421617f          BIC      r1,r1,#0xff0
000194  6001              STR      r1,[r0,#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
000196  6801              LDR      r1,[r0,#0]
000198  f04101b0          ORR      r1,r1,#0xb0
00019c  6001              STR      r1,[r0,#0]
;;;19       set_IO_CR(portRS1,pinRx1,p_i_f);		// USART1 Rx (PA10) input float
00019e  6801              LDR      r1,[r0,#0]
0001a0  f4416180          ORR      r1,r1,#0x400
0001a4  6001              STR      r1,[r0,#0]
;;;20     
;;;21       RCC->APB2ENR |=  RCC_APB2ENR_USART1EN;	// enable USART1 clock
0001a6  488f              LDR      r0,|L1.996|
0001a8  6981              LDR      r1,[r0,#0x18]
0001aa  f4414180          ORR      r1,r1,#0x4000
0001ae  6181              STR      r1,[r0,#0x18]
;;;22     
;;;23       USART1->CR1   = USART_CR1_RE|USART_CR1_TE;//|USART_CR1_RXNEIE;	// enable RX, TX, IRQ
0001b0  4897              LDR      r0,|L1.1040|
0001b2  210c              MOVS     r1,#0xc
0001b4  8001              STRH     r1,[r0,#0]
;;;24       USART1->CR2   = 0x0000;
0001b6  2100              MOVS     r1,#0
0001b8  1d02              ADDS     r2,r0,#4
0001ba  8011              STRH     r1,[r2,#0]
;;;25       USART1->CR3   = 0x0000;			// no flow control
0001bc  1d12              ADDS     r2,r2,#4
0001be  8011              STRH     r1,[r2,#0]
;;;26       USART1->BRR   = MCK/FREQ_RS1;			// baudrate
0001c0  1f02              SUBS     r2,r0,#4
0001c2  f2402171          MOV      r1,#0x271
0001c6  8011              STRH     r1,[r2,#0]
;;;27     
;;;28       USART1->CR1  |= USART_CR1_UE;			// Enable USART
0001c8  8801              LDRH     r1,[r0,#0]
0001ca  f4415100          ORR      r1,r1,#0x2000
0001ce  8001              STRH     r1,[r0,#0]
;;;29     }//______________________________________________
0001d0  4770              BX       lr
;;;30     __inline void SER_WriteChar(char c){
                          ENDP

                  SER_CheckCharRx PROC
;;;35     }//______________________________________________
;;;36     int SER_CheckCharRx (void) {
0001d2  488f              LDR      r0,|L1.1040|
;;;37     	return ((USART1->SR & USART_SR_RXNE)>>5);
0001d4  380c              SUBS     r0,r0,#0xc
0001d6  8800              LDRH     r0,[r0,#0]
0001d8  f3c01040          UBFX     r0,r0,#5,#1
;;;38     }//______________________________________________
0001dc  4770              BX       lr
;;;39     int SER_CheckCharTx (void) {
                          ENDP

                  SER_CheckCharTx PROC
0001de  488c              LDR      r0,|L1.1040|
;;;40     	return ((USART1->SR & USART_SR_TXE)>>7);
0001e0  380c              SUBS     r0,r0,#0xc
0001e2  8800              LDRH     r0,[r0,#0]
0001e4  f3c010c0          UBFX     r0,r0,#7,#1
;;;41     }//______________________________________________
0001e8  4770              BX       lr
;;;42     char SER_PutChar (char c) {
                          ENDP

                  SER_PutChar PROC
0001ea  b500              PUSH     {lr}
0001ec  4601              MOV      r1,r0
                  |L1.494|
;;;43     
;;;44     	while (!(SER_CheckCharTx()));
0001ee  f7fffffe          BL       SER_CheckCharTx
0001f2  2800              CMP      r0,#0
0001f4  d0fb              BEQ      |L1.494|
0001f6  4886              LDR      r0,|L1.1040|
0001f8  3808              SUBS     r0,r0,#8
0001fa  8001              STRH     r1,[r0,#0]
;;;45     	SER_WriteChar(c); return (c);
0001fc  4608              MOV      r0,r1
;;;46     }//______________________________________________
0001fe  bd00              POP      {pc}
;;;47     char SER_GetChar (void) {
                          ENDP

                  SER_GetChar PROC
000200  b500              PUSH     {lr}
                  |L1.514|
;;;48     
;;;49     	while (!(SER_CheckCharRx()));
000202  f7fffffe          BL       SER_CheckCharRx
000206  2800              CMP      r0,#0
000208  d0fb              BEQ      |L1.514|
00020a  4881              LDR      r0,|L1.1040|
00020c  3808              SUBS     r0,r0,#8
00020e  8800              LDRH     r0,[r0,#0]
000210  b2c0              UXTB     r0,r0
;;;50     	return SER_ReadChar();
;;;51     }//______________________________________________
000212  bd00              POP      {pc}
;;;52     void WRITE_TO_COM(char *ptr,uint cnt){		//    COM .
                          ENDP

                  WRITE_TO_COM PROC
000214  b510              PUSH     {r4,lr}
000216  4603              MOV      r3,r0
000218  460c              MOV      r4,r1
;;;53     int i;
;;;54      for	(i=0; i<cnt; i++)			//    .
00021a  2200              MOVS     r2,#0
00021c  e003              B        |L1.550|
                  |L1.542|
;;;55      {
;;;56     	SER_PutChar(ptr[i]);			// 
00021e  5c98              LDRB     r0,[r3,r2]
000220  f7fffffe          BL       SER_PutChar
000224  1c52              ADDS     r2,r2,#1              ;54
                  |L1.550|
000226  42a2              CMP      r2,r4                 ;54
000228  d3f9              BCC      |L1.542|
;;;57      }	 
;;;58     }//______________________________________________
00022a  bd10              POP      {r4,pc}
;;;59     void READ_FROM_COM(uchar *ptr,uint cnt){	//    COM .
                          ENDP

                  READ_FROM_COM PROC
00022c  b500              PUSH     {lr}
00022e  4603              MOV      r3,r0
;;;60     uint i;
;;;61      for (i=0; i<cnt; i++)				//    .
000230  2200              MOVS     r2,#0
000232  e003              B        |L1.572|
                  |L1.564|
;;;62      {
;;;63     	ptr[i]=SER_GetChar();			//   .
000234  f7fffffe          BL       SER_GetChar
000238  5498              STRB     r0,[r3,r2]
00023a  1c52              ADDS     r2,r2,#1              ;61
                  |L1.572|
00023c  428a              CMP      r2,r1                 ;61
00023e  d3f9              BCC      |L1.564|
;;;64      }
;;;65     }//______________________________________________
000240  bd00              POP      {pc}
;;;66     void ACK (){					//  .   "c"
                          ENDP

                  ACK PROC
000242  200d              MOVS     r0,#0xd
;;;67     // ----------------------------------------------
;;;68     	SER_PutChar(13);			//   .
000244  e7fe              B        SER_PutChar
;;;69     }//______________________________________________
;;;70     #endif	// __comport_c__
                          ENDP

                  fputc PROC
;;;31     
;;;32     int fputc(int c, FILE *f) {
000246  b500              PUSH     {lr}
000248  4602              MOV      r2,r0
;;;33       if (c == '\n')  {
00024a  2a0a              CMP      r2,#0xa
00024c  d102              BNE      |L1.596|
;;;34         SER_PutChar('\r');
00024e  200d              MOVS     r0,#0xd
000250  f7fffffe          BL       SER_PutChar
                  |L1.596|
;;;35       }
;;;36       return (SER_PutChar(c));
000254  b2d0              UXTB     r0,r2
000256  f85deb04          POP      {lr}
00025a  e7fe              B        SER_PutChar
;;;37     }
;;;38     
                          ENDP

                  fgetc PROC
;;;39     
;;;40     int fgetc(FILE *f) {
00025c  b500              PUSH     {lr}
;;;41       return (SER_PutChar(SER_GetChar()));
00025e  f7fffffe          BL       SER_GetChar
000262  f85deb04          POP      {lr}
000266  e7fe              B        SER_PutChar
;;;42     }
;;;43     
                          ENDP

                  ferror PROC
;;;44     
;;;45     int ferror(FILE *f) {
000268  f04f30ff          MOV      r0,#0xffffffff
;;;46       /* Your implementation of ferror */
;;;47       return EOF;
;;;48     }
00026c  4770              BX       lr
;;;49     
                          ENDP

                  _ttywrch PROC
;;;50     
;;;51     void _ttywrch(int c) {
00026e  b2c0              UXTB     r0,r0
;;;52       SER_PutChar(c);
000270  e7fe              B        SER_PutChar
;;;53     }
;;;54     
                          ENDP

                  _sys_exit PROC
                  |L1.626|
;;;55     
;;;56     void _sys_exit(int return_code) {
000272  e7fe              B        |L1.626|
;;;57     label:  goto label;  /* endless loop */
;;;58     }
;;;15     #include "src\step.c"
                          ENDP

                  SetVoltageStep PROC
;;;15     
;;;16     void SetVoltageStep(int pos){			//     .
000274  4a65              LDR      r2,|L1.1036|
;;;17     uint	temp=(portSTP->ODR);			//  .
000276  3208              ADDS     r2,r2,#8
000278  6811              LDR      r1,[r2,#0]
;;;18     
;;;19     	temp=temp&(~mpinSTP);			//  .
00027a  f02101f0          BIC      r1,r1,#0xf0
;;;20     	temp=temp|StepTable[pos&7];		//  .
00027e  4b65              LDR      r3,|L1.1044|
000280  f0000007          AND      r0,r0,#7
000284  f8530020          LDR      r0,[r3,r0,LSL #2]
000288  4308              ORRS     r0,r0,r1
;;;21     	portSTP->ODR=temp;			//    .
00028a  6010              STR      r0,[r2,#0]
;;;22     } // -------------------------------------------
00028c  4770              BX       lr
;;;23     void OffVoltageStep(){				//  -   .
                          ENDP

                  OffVoltageStep PROC
00028e  495b              LDR      r1,|L1.1020|
;;;24     uint	temp;
;;;25     	temp=StepTOT;
000290  6bc8              LDR      r0,[r1,#0x3c]  ; StepTOT
;;;26      if	(temp)					//
000292  2800              CMP      r0,#0
000294  d009              BEQ      |L1.682|
;;;27      {
;;;28     	temp--; StepTOT=temp;			//    -.
000296  1e40              SUBS     r0,r0,#1
000298  63c8              STR      r0,[r1,#0x3c]  ; StepTOT
;;;29       if	(!temp)					//   0-?
00029a  2800              CMP      r0,#0
00029c  d105              BNE      |L1.682|
;;;30       {
;;;31     	temp=(portSTP->ODR);
00029e  495b              LDR      r1,|L1.1036|
0002a0  3108              ADDS     r1,r1,#8
0002a2  6808              LDR      r0,[r1,#0]
;;;32     	temp=temp&(~mpinSTP);
0002a4  f02000f0          BIC      r0,r0,#0xf0
;;;33     	portSTP->ODR=temp;			//  .
0002a8  6008              STR      r0,[r1,#0]
                  |L1.682|
;;;34       }	
;;;35      }
;;;36     } // -------------------------------------------
0002aa  4770              BX       lr
;;;37     void StepBreak(){				//  .
                          ENDP

                  StepBreak PROC
0002ac  b510              PUSH     {r4,lr}
;;;38     // ---------------------------------------------
;;;39     uint temp=0;
;;;40     SysTick_Type* ptr=SysTick;
0002ae  485a              LDR      r0,|L1.1048|
;;;41     
;;;42     	DirY=temp; State&=~ST_MVY;		//   .
0002b0  4952              LDR      r1,|L1.1020|
0002b2  2200              MOVS     r2,#0
0002b4  710a              STRB     r2,[r1,#4]
0002b6  4b53              LDR      r3,|L1.1028|
0002b8  3b14              SUBS     r3,r3,#0x14
0002ba  7b1c              LDRB     r4,[r3,#0xc]  ; lbufinfo
0002bc  f0240402          BIC      r4,r4,#2
0002c0  731c              STRB     r4,[r3,#0xc]
;;;43     	StepCNT=temp;				//  =0.
0002c2  640a              STR      r2,[r1,#0x40]  ; StepCNT
;;;44     	temp=STOT; StepTOT=temp;		//  .
0002c4  f64262e0          MOV      r2,#0x2ee0
0002c8  63ca              STR      r2,[r1,#0x3c]  ; StepTOT
;;;45     	temp=FT_STEP/FT_OUT;			//    -.
0002ca  f64841a0          MOV      r1,#0x8ca0
;;;46     	ptr->LOAD=temp;	ptr->VAL=16;		//     ( 16 ).
0002ce  6041              STR      r1,[r0,#4]
0002d0  2110              MOVS     r1,#0x10
0002d2  6081              STR      r1,[r0,#8]
;;;47     } // -------------------------------------------
0002d4  bd10              POP      {r4,pc}
;;;48     void AccelStep (int speed){			//   (speed- ).
                          ENDP

                  AccelStep PROC
0002d6  4a49              LDR      r2,|L1.1020|
;;;49     // ---------------------------------------------
;;;50     uint temp=AccelPos;				//    .
0002d8  6b11              LDR      r1,[r2,#0x30]  ; AccelPos
;;;51     if (temp<(sizeof(AccelTable)/sizeof(AccelTable[0])))
0002da  29ee              CMP      r1,#0xee
0002dc  d20b              BCS      |L1.758|
;;;52      {
;;;53     	temp++; AccelPos=temp;			//    .
0002de  1c49              ADDS     r1,r1,#1
0002e0  6311              STR      r1,[r2,#0x30]  ; AccelPos
;;;54     	temp=AccelTable[temp];
0002e2  4b4c              LDR      r3,|L1.1044|
0002e4  3320              ADDS     r3,r3,#0x20
0002e6  f8531021          LDR      r1,[r3,r1,LSL #2]
;;;55      if (temp<=speed) cSpeedY=speed;		// cSpeedY=SpeedY;   .
0002ea  4281              CMP      r1,r0
0002ec  d801              BHI      |L1.754|
0002ee  6390              STR      r0,[r2,#0x38]  ; cSpeedY
;;;56      else	cSpeedY=temp;
;;;57      }
;;;58     else  rSpeedY=cSpeedY;				// 
;;;59     } // -------------------------------------------
0002f0  4770              BX       lr
                  |L1.754|
0002f2  6391              STR      r1,[r2,#0x38]         ;56  ; cSpeedY
0002f4  4770              BX       lr
                  |L1.758|
0002f6  6b90              LDR      r0,[r2,#0x38]         ;58  ; cSpeedY
0002f8  6350              STR      r0,[r2,#0x34]         ;58  ; rSpeedY
0002fa  4770              BX       lr
;;;60     void DeccelStep(int speed){			//  .
                          ENDP

                  DeccelStep PROC
0002fc  4a3f              LDR      r2,|L1.1020|
;;;61     // ----------------------------------------------	
;;;62     uint temp=AccelPos;				//    .
0002fe  6b11              LDR      r1,[r2,#0x30]  ; AccelPos
;;;63     //SER_PutChar ('-');
;;;64     if (temp>0)
000300  2900              CMP      r1,#0
000302  d00b              BEQ      |L1.796|
;;;65      {
;;;66     	temp--; AccelPos=temp;			//    .
000304  1e49              SUBS     r1,r1,#1
000306  6311              STR      r1,[r2,#0x30]  ; AccelPos
;;;67     	temp=AccelTable[temp];
000308  4b42              LDR      r3,|L1.1044|
00030a  3320              ADDS     r3,r3,#0x20
00030c  f8531021          LDR      r1,[r3,r1,LSL #2]
;;;68      if (temp>=speed) cSpeedY=speed;		// cSpeedY=SpeedY;   .
000310  4281              CMP      r1,r0
000312  d301              BCC      |L1.792|
000314  6390              STR      r0,[r2,#0x38]  ; cSpeedY
;;;69      else	cSpeedY=temp;
;;;70      }
;;;71     else
;;;72      {
;;;73     	rSpeedY=cSpeedY; StepBreak();
;;;74      }		//
;;;75     } // -------------------------------------------
000316  4770              BX       lr
                  |L1.792|
000318  6391              STR      r1,[r2,#0x38]         ;69  ; cSpeedY
00031a  4770              BX       lr
                  |L1.796|
00031c  6b90              LDR      r0,[r2,#0x38]         ;73  ; cSpeedY
00031e  6350              STR      r0,[r2,#0x34]         ;73  ; rSpeedY
000320  e7fe              B        StepBreak
;;;76     void ChangePosStep(schar dir){			//      .
                          ENDP

                  ChangePosStep PROC
000322  b570              PUSH     {r4-r6,lr}
;;;77     // ----------------------------------------------
;;;78     int temp, temp1;
;;;79     	DirY=dir;				//  .
000324  4e35              LDR      r6,|L1.1020|
000326  7130              STRB     r0,[r6,#4]
;;;80     	temp1=CurrStepPos;			//   .
000328  4a36              LDR      r2,|L1.1028|
00032a  3a14              SUBS     r2,r2,#0x14
00032c  6853              LDR      r3,[r2,#4]  ; lbufinfo
;;;81     	temp=StepCNT;				//     .
00032e  6c31              LDR      r1,[r6,#0x40]  ; StepCNT
;;;82     if (temp<=AccelPos) rSpeedY=BREAKSPEED;		//   ,      .
000330  6b34              LDR      r4,[r6,#0x30]  ; AccelPos
000332  42a1              CMP      r1,r4
000334  d801              BHI      |L1.826|
000336  4c39              LDR      r4,|L1.1052|
000338  6374              STR      r4,[r6,#0x34]  ; rSpeedY
                  |L1.826|
;;;83     if (!temp) StepBreak();				//    .
00033a  b1f9              CBZ      r1,|L1.892|
;;;84     else
;;;85      {
;;;86     	State|=ST_MVY;				//   .
00033c  7b14              LDRB     r4,[r2,#0xc]  ; lbufinfo
00033e  f0440402          ORR      r4,r4,#2
000342  7314              STRB     r4,[r2,#0xc]
;;;87     	temp1+=dir; CurrStepPos=temp1;		//  .
000344  4418              ADD      r0,r0,r3
000346  6050              STR      r0,[r2,#4]  ; lbufinfo
;;;88     	temp--; StepCNT=temp;			//   .
000348  1e49              SUBS     r1,r1,#1
00034a  6431              STR      r1,[r6,#0x40]  ; StepCNT
;;;89     	SetVoltageStep(temp1);			//    .
00034c  f7fffffe          BL       SetVoltageStep
;;;90     	StepOn; fStep=1;			//    Step.
000350  4933              LDR      r1,|L1.1056|
000352  2001              MOVS     r0,#1
000354  6008              STR      r0,[r1,#0]
000356  7170              STRB     r0,[r6,#5]
;;;91     
;;;92     	temp=rSpeedY; temp1=cSpeedY;		//   .
000358  6b74              LDR      r4,[r6,#0x34]  ; rSpeedY
00035a  6bb5              LDR      r5,[r6,#0x38]  ; cSpeedY
;;;93      if (temp1<temp) DeccelStep(temp);		//   ( ).
00035c  42a5              CMP      r5,r4
00035e  da02              BGE      |L1.870|
000360  4620              MOV      r0,r4
000362  f7fffffe          BL       DeccelStep
                  |L1.870|
;;;94      if (temp1>temp) AccelStep(temp);		//   ( ).
000366  42a5              CMP      r5,r4
000368  dd02              BLE      |L1.880|
00036a  4620              MOV      r0,r4
00036c  f7fffffe          BL       AccelStep
                  |L1.880|
;;;95     	SysTick->LOAD=(cSpeedY>>1);		//  /2    STEP.
000370  6bb0              LDR      r0,[r6,#0x38]  ; cSpeedY
000372  f04f21e0          MOV      r1,#0xe000e000
000376  1040              ASRS     r0,r0,#1
000378  6148              STR      r0,[r1,#0x14]
;;;96      }
;;;97     } // --------------------------------------------
00037a  bd70              POP      {r4-r6,pc}
                  |L1.892|
00037c  e8bd4070          POP      {r4-r6,lr}            ;83
000380  e7fe              B        StepBreak
;;;98     void WaitSteps(){				//    .
                          ENDP

                  WaitSteps PROC
000382  481e              LDR      r0,|L1.1020|
;;;99     // ----------------------------------------------
;;;100    while	(!StepCNT);
000384  6c00              LDR      r0,[r0,#0x40]
                  |L1.902|
000386  2800              CMP      r0,#0
000388  d0fd              BEQ      |L1.902|
;;;101    } // --------------------------------------------
00038a  4770              BX       lr
;;;102    void Steps(int rpos){				// .
                          ENDP

                  Steps PROC
00038c  b410              PUSH     {r4}
;;;103    // ----------------------------------------------
;;;104    uint tmp;
;;;105    	rSpeedY=BREAKSPEED;
00038e  4c1b              LDR      r4,|L1.1020|
000390  4922              LDR      r1,|L1.1052|
000392  6361              STR      r1,[r4,#0x34]  ; rSpeedY
;;;106     if (rpos) 					//   ,  0.
000394  2800              CMP      r0,#0
000396  d023              BEQ      |L1.992|
;;;107     {
;;;108      if (!DirY)					// ?
000398  7921              LDRB     r1,[r4,#4]  ; DirY
00039a  2900              CMP      r1,#0
00039c  d120              BNE      |L1.992|
;;;109      {
;;;110    	AccelPos=0; cSpeedY=AccelTable[0];	//    .
00039e  6321              STR      r1,[r4,#0x30]  ; AccelPos
0003a0  4b20              LDR      r3,|L1.1060|
0003a2  63a3              STR      r3,[r4,#0x38]  ; cSpeedY
;;;111    	tmp=StpSpd;
0003a4  4917              LDR      r1,|L1.1028|
0003a6  6a4a              LDR      r2,[r1,#0x24]  ; lcnfbuf
;;;112       if (!tmp) tmp=1;				//     0.
0003a8  b902              CBNZ     r2,|L1.940|
0003aa  2201              MOVS     r2,#1
                  |L1.940|
;;;113    	tmp=(FT_STEP/tmp-1);			//    .
0003ac  491e              LDR      r1,|L1.1064|
0003ae  fbb1f1f2          UDIV     r1,r1,r2
0003b2  1e49              SUBS     r1,r1,#1
;;;114       if (tmp>cSpeedY) tmp=cSpeedY;		//   .
0003b4  4299              CMP      r1,r3
0003b6  d900              BLS      |L1.954|
0003b8  4619              MOV      r1,r3
                  |L1.954|
;;;115    	rSpeedY=tmp;				//   .
0003ba  6361              STR      r1,[r4,#0x34]  ; rSpeedY
;;;116       if (rpos>0)
;;;117       {
;;;118    	DirOff; StepCNT=+rpos; ChangePosStep(+1);
0003bc  2102              MOVS     r1,#2
0003be  2800              CMP      r0,#0                 ;116
0003c0  dd06              BLE      |L1.976|
0003c2  4a17              LDR      r2,|L1.1056|
0003c4  1d12              ADDS     r2,r2,#4
0003c6  6011              STR      r1,[r2,#0]
0003c8  6420              STR      r0,[r4,#0x40]  ; StepCNT
0003ca  bc10              POP      {r4}
0003cc  2001              MOVS     r0,#1
0003ce  e7fe              B        ChangePosStep
                  |L1.976|
;;;119       }
;;;120       else
;;;121       {
;;;122    	DirOn; StepCNT=-rpos; ChangePosStep(-1);
0003d0  4a13              LDR      r2,|L1.1056|
0003d2  6011              STR      r1,[r2,#0]
0003d4  4240              RSBS     r0,r0,#0
0003d6  6420              STR      r0,[r4,#0x40]  ; StepCNT
0003d8  bc10              POP      {r4}
0003da  f04f30ff          MOV      r0,#0xffffffff
0003de  e7fe              B        ChangePosStep
                  |L1.992|
;;;123       }
;;;124      }
;;;125     }	 
;;;126    } // --------------------------------------------
0003e0  bc10              POP      {r4}
0003e2  4770              BX       lr
                  |L1.996|
                          DCD      0x40021000
                  |L1.1000|
                          DCD      0x40022000
                  |L1.1004|
                          DCD      0xf8ff0000
                  |L1.1008|
                          DCD      0xfef6ffff
                  |L1.1012|
                          DCD      0xe000ed08
                  |L1.1016|
                          DCD      0x007a1200
                  |L1.1020|
                          DCD      ||.data||
                  |L1.1024|
                          DCD      0x003d0900
                  |L1.1028|
                          DCD      ||.bss||+0x14
                  |L1.1032|
                          DCD      0x40010000
                  |L1.1036|
                          DCD      0x40010804
                  |L1.1040|
                          DCD      0x4001380c
                  |L1.1044|
                          DCD      ||.constdata||
                  |L1.1048|
                          DCD      0xe000e010
                  |L1.1052|
                          DCD      0x0003f3af
                  |L1.1056|
                          DCD      0x40010c10
                  |L1.1060|
                          DCD      0x0003ec75
                  |L1.1064|
                          DCD      0x044aa200
                          ENDP

                  wSteps PROC
;;;127    void wSteps(int rpos){				//   .
00042c  b500              PUSH     {lr}
00042e  4601              MOV      r1,r0
;;;128    // ----------------------------------------------
;;;129    	WaitSteps(); Steps(rpos);
000430  f7fffffe          BL       WaitSteps
000434  4608              MOV      r0,r1
000436  f85deb04          POP      {lr}
00043a  e7fe              B        Steps
;;;130    } // --------------------------------------------
;;;131    void StepYCMD(int rpos){			//    "myNNNN".
                          ENDP

                  StepYCMD PROC
00043c  b500              PUSH     {lr}
;;;132    // ----------------------------------------------
;;;133    	Steps(rpos); ACK();			//   .
00043e  f7fffffe          BL       Steps
000442  f85deb04          POP      {lr}
000446  e7fe              B        ACK
;;;134    } // --------------------------------------------
;;;135    void AbsMoveY(int pos){				//    "mYNNNN".
                          ENDP

                  AbsMoveY PROC
000448  b500              PUSH     {lr}
;;;136    // ----------------------------------------------
;;;137    	StepYCMD(CalcStepY(pos)-CurrStepPos);	//
00044a  f7fffffe          BL       CalcStepY
00044e  49f8              LDR      r1,|L1.2096|
000450  6849              LDR      r1,[r1,#4]  ; lbufinfo
000452  f85deb04          POP      {lr}
000456  1a40              SUBS     r0,r0,r1
000458  e7fe              B        StepYCMD
;;;138    } // --------------------------------------------
;;;139    
                          ENDP

                  InitTimerSteps PROC
;;;140    void InitTimerSteps (){				//    .
00045a  b500              PUSH     {lr}
;;;141    // ----------------------------------------------
;;;142    	cSpeedY=BREAKSPEED;			//   = .
00045c  49f6              LDR      r1,|L1.2104|
00045e  48f5              LDR      r0,|L1.2100|
000460  6388              STR      r0,[r1,#0x38]  ; cSpeedY
;;;143    	StepBreak();				// -   .
000462  f7fffffe          BL       StepBreak
000466  49f5              LDR      r1,|L1.2108|
000468  2080              MOVS     r0,#0x80
00046a  7008              STRB     r0,[r1,#0]
;;;144    	NVIC_SetPriority (SysTick_IRQn, 200);  	//  .
;;;145    	SysTick->CTRL=SysTick_CTRL_TICKINT_Msk|	//  .
00046c  f04f21e0          MOV      r1,#0xe000e000
000470  2007              MOVS     r0,#7
000472  6108              STR      r0,[r1,#0x10]
;;;146    		SysTick_CTRL_CLKSOURCE_Msk |	//    (72 ).
;;;147    		SysTick_CTRL_ENABLE_Msk;	//  .
;;;148    } // -------------------------------------------
000474  bd00              POP      {pc}
;;;149    void InitPinsSteps (){				//     .
                          ENDP

                  InitPinsSteps PROC
000476  48f2              LDR      r0,|L1.2112|
;;;150    
;;;151    	portSTP_CR &=~(
000478  6801              LDR      r1,[r0,#0]
00047a  b289              UXTH     r1,r1
00047c  6001              STR      r1,[r0,#0]
;;;152    		(PinCR(pinSTP0,GPIOCR))|	//    .
;;;153    		(PinCR(pinSTP1,GPIOCR))|
;;;154    		(PinCR(pinSTP2,GPIOCR))|
;;;155    		(PinCR(pinSTP3,GPIOCR))
;;;156    		);
;;;157    	portSTP_CR |=(
00047e  6801              LDR      r1,[r0,#0]
000480  4af0              LDR      r2,|L1.2116|
000482  4311              ORRS     r1,r1,r2
000484  6001              STR      r1,[r0,#0]
;;;158    		(PinCR(pinSTP0,p_o_p10))|
;;;159    		(PinCR(pinSTP1,p_o_p10))|
;;;160    		(PinCR(pinSTP2,p_o_p10))|
;;;161    		(PinCR(pinSTP3,p_o_p10))
;;;162    		);
;;;163    	portSTPDIR_CR &=~(
000486  48f0              LDR      r0,|L1.2120|
000488  6801              LDR      r1,[r0,#0]
00048a  f02101ff          BIC      r1,r1,#0xff
00048e  6001              STR      r1,[r0,#0]
;;;164    		(PinCR(pinSTEP,GPIOCR))|
;;;165    		(PinCR(pinDIR ,GPIOCR))
;;;166    		);
;;;167    	portSTPDIR_CR |=(
000490  6801              LDR      r1,[r0,#0]
000492  f0410111          ORR      r1,r1,#0x11
000496  6001              STR      r1,[r0,#0]
;;;168    		(PinCR(pinSTEP,p_o_p10))|	//   .
;;;169    		(PinCR(pinDIR ,p_o_p10))
;;;170    		);
;;;171    	SetVoltageStep(0);			// 
000498  2000              MOVS     r0,#0
00049a  e7fe              B        SetVoltageStep
;;;172    } // -------------------------------------------
;;;173    void TSTP_IRQ(){				//    .
                          ENDP

                  SysTick_Handler PROC
00049c  48e6              LDR      r0,|L1.2104|
;;;174    // ----------------------------------------------
;;;175    schar dir;
;;;176     if (fStep) 
00049e  7941              LDRB     r1,[r0,#5]  ; fStep
0004a0  2900              CMP      r1,#0
0004a2  d006              BEQ      |L1.1202|
;;;177     {
;;;178    	fStep=0; StepOff;			//   STEP.
0004a4  2100              MOVS     r1,#0
0004a6  7141              STRB     r1,[r0,#5]
0004a8  49e7              LDR      r1,|L1.2120|
0004aa  2001              MOVS     r0,#1
0004ac  3114              ADDS     r1,r1,#0x14
0004ae  6008              STR      r0,[r1,#0]
;;;179     }
;;;180     else
;;;181     {
;;;182    	dir=DirY;
;;;183      if (dir)	ChangePosStep(dir);		//  ,  .
;;;184      else		OffVoltageStep();		//   (  -).
;;;185     }
;;;186    }// ---------------------------------------------
0004b0  4770              BX       lr
                  |L1.1202|
0004b2  f9900004          LDRSB    r0,[r0,#4]            ;182  ; DirY
0004b6  b100              CBZ      r0,|L1.1210|
0004b8  e7fe              B        ChangePosStep
                  |L1.1210|
0004ba  e7fe              B        OffVoltageStep
;;;16     #include "src\motor.c"
                          ENDP

                  PWM_Set PROC
;;;1      
;;;2      void PWM_Set(ushort val){			//   .
0004bc  49e3              LDR      r1,|L1.2124|
;;;3      // ----------------------------------------------	
;;;4      schar dir;
;;;5      TIM_TypeDef *timptr=TPWM;
;;;6      
;;;7      	dir=DirX;
0004be  4ade              LDR      r2,|L1.2104|
0004c0  f9922000          LDRSB    r2,[r2,#0]  ; DirX
;;;8      	timptr->mPWMF=0; timptr->mPWMB=0;	//   .
0004c4  2300              MOVS     r3,#0
0004c6  870b              STRH     r3,[r1,#0x38]
0004c8  868b              STRH     r3,[r1,#0x34]
;;;9        if (dir>0) timptr->mPWMF=val;
0004ca  2a00              CMP      r2,#0
0004cc  dd00              BLE      |L1.1232|
0004ce  8708              STRH     r0,[r1,#0x38]
                  |L1.1232|
;;;10       if (dir<0) timptr->mPWMB=val;
0004d0  da00              BGE      |L1.1236|
0004d2  8688              STRH     r0,[r1,#0x34]
                  |L1.1236|
;;;11     } // --------------------------------------------
0004d4  4770              BX       lr
;;;12     void SetDirDC (int dir){			//   .
                          ENDP

                  SetDirDC PROC
0004d6  4adc              LDR      r2,|L1.2120|
;;;13     // ----------------------------------------------
;;;14     	portDC->BRR=(1<<pinPWRF|1<<pinPWRB);	//   .
0004d8  f44f4110          MOV      r1,#0x9000
0004dc  3214              ADDS     r2,r2,#0x14
0004de  6011              STR      r1,[r2,#0]
;;;15      if (dir>0)	portDC->BSRR=1<<pinPWRF;	//   .
0004e0  1f11              SUBS     r1,r2,#4
0004e2  2800              CMP      r0,#0
0004e4  dd02              BLE      |L1.1260|
0004e6  f44f5080          MOV      r0,#0x1000
0004ea  6008              STR      r0,[r1,#0]
                  |L1.1260|
;;;16      if (dir<0)	portDC->BSRR=1<<pinPWRB;	//   .
0004ec  da02              BGE      |L1.1268|
0004ee  f44f4000          MOV      r0,#0x8000
0004f2  6008              STR      r0,[r1,#0]
                  |L1.1268|
;;;17     } // --------------------------------------------
0004f4  4770              BX       lr
;;;18     void Init_TIM_PWM(){				//    TIM1.
                          ENDP

                  Init_TIM_PWM PROC
0004f6  48d5              LDR      r0,|L1.2124|
;;;19     // ----------------------------------------------
;;;20     TIM_TypeDef *timptr=TPWM;
;;;21     
;;;22     	SET_PER_PWM				//  .
0004f8  49d5              LDR      r1,|L1.2128|
0004fa  684a              LDR      r2,[r1,#4]
0004fc  f02202c0          BIC      r2,r2,#0xc0
000500  604a              STR      r2,[r1,#4]
000502  684a              LDR      r2,[r1,#4]
000504  604a              STR      r2,[r1,#4]
000506  49d3              LDR      r1,|L1.2132|
000508  698a              LDR      r2,[r1,#0x18]
00050a  f4426200          ORR      r2,r2,#0x800
00050e  618a              STR      r2,[r1,#0x18]
;;;23     	portDC_CR &=~(				//   .
000510  49cd              LDR      r1,|L1.2120|
000512  1d09              ADDS     r1,r1,#4
000514  680a              LDR      r2,[r1,#0]
000516  b292              UXTH     r2,r2
000518  600a              STR      r2,[r1,#0]
;;;24     		(PinCR(pinPWM,GPIOCR))|
;;;25     		(PinCR(pinPWMN,GPIOCR))|
;;;26     		(PinCR(pinPWRF,GPIOCR))|
;;;27     		(PinCR(pinPWRB,GPIOCR))
;;;28     		);
;;;29     	portDC_CR |=(
00051a  680a              LDR      r2,[r1,#0]
00051c  4bce              LDR      r3,|L1.2136|
00051e  431a              ORRS     r2,r2,r3
000520  600a              STR      r2,[r1,#0]
;;;30     		(PinCR(pinPWM,p_a_p50))|	//  .
;;;31     		(PinCR(pinPWMN,p_a_p50))|	//  .
;;;32     		(PinCR(pinPWRF,p_o_p50))|	// GPIO.
;;;33     		(PinCR(pinPWRB,p_o_p50))	// GPIO.
;;;34     		);
;;;35     	timptr->PSC  = ((TPWM_CK/PWM_FREQ/PWM_RES)-1);	// set prescaler
000522  210d              MOVS     r1,#0xd
000524  8501              STRH     r1,[r0,#0x28]
;;;36     	timptr->ARR  = (PWM_RES-1);		// set auto-reload
000526  21ff              MOVS     r1,#0xff
000528  8581              STRH     r1,[r0,#0x2c]
;;;37     	
;;;38     	timptr->CCMR1=
00052a  f2460160          MOV      r1,#0x6060
00052e  8301              STRH     r1,[r0,#0x18]
;;;39     		TIM_CCMR1_OC2M_1|
;;;40     		TIM_CCMR1_OC2M_2|
;;;41     		TIM_CCMR1_OC1M_1|
;;;42     		TIM_CCMR1_OC1M_2;		// PWM mode 6. Channel 1&2
;;;43     
;;;44     	timptr->CCER =	TIM_CCER_CC1NE|		//  .     1  8
000530  2144              MOVS     r1,#0x44
000532  8401              STRH     r1,[r0,#0x20]
;;;45     			TIM_CCER_CC2NE;
;;;46     	timptr->BDTR =	TIM_BDTR_MOE;
000534  f44f4100          MOV      r1,#0x8000
000538  f8a01044          STRH     r1,[r0,#0x44]
;;;47     	timptr->CR1 |= TIM_CR1_CEN;		//  .
00053c  8801              LDRH     r1,[r0,#0]
00053e  f0410101          ORR      r1,r1,#1
000542  8001              STRH     r1,[r0,#0]
;;;48     } // --------------------------------------------
000544  4770              BX       lr
;;;49     void Init_TIM_TOT(){				//    .
                          ENDP

                  Init_TIM_TOT PROC
000546  48c5              LDR      r0,|L1.2140|
;;;50     // ----------------------------------------------	
;;;51     TIM_TypeDef *timptr=TTOT;
;;;52     	SET_PER_TOT				//  . 
000548  49c2              LDR      r1,|L1.2132|
00054a  69ca              LDR      r2,[r1,#0x1c]
00054c  f0420202          ORR      r2,r2,#2
000550  61ca              STR      r2,[r1,#0x1c]
;;;53     
;;;54     	timptr->PSC  = TTOT_CK/10000 - 1;	//   100  (10KHz).
000552  f641411f          MOV      r1,#0x1c1f
000556  8501              STRH     r1,[r0,#0x28]
;;;55     	timptr->ARR  = TOT_TIME*10-1;		//   .
000558  f242710f          MOV      r1,#0x270f
00055c  8581              STRH     r1,[r0,#0x2c]
;;;56     
;;;57     	timptr->DIER =TIM_DIER_UIE;		//     .
00055e  2101              MOVS     r1,#1
000560  8181              STRH     r1,[r0,#0xc]
;;;58     	NVIC_EnableIRQ(TTOT_IRQn);		//    TIM2.
000562  201d              MOVS     r0,#0x1d
000564  f7ffbffe          B.W      NVIC_EnableIRQ
;;;59     } // -------------------------------------------
;;;60     
                          ENDP

                  SetTOT PROC
;;;61     void SetTOT(uint tot){				//   -.
000568  49bc              LDR      r1,|L1.2140|
;;;62     // ----------------------------------------------	
;;;63     //printf("\r\nset TOT %d",tot);
;;;64     TIM_TypeDef *timptr=TTOT;
;;;65     	timptr->CNT =0;			//   0-.
00056a  2200              MOVS     r2,#0
00056c  848a              STRH     r2,[r1,#0x24]
;;;66     	timptr->ARR =tot;			//  .
00056e  8588              STRH     r0,[r1,#0x2c]
;;;67     	timptr->CR1 |=TIM_CR1_CEN;		//  .
000570  8808              LDRH     r0,[r1,#0]
000572  f0400001          ORR      r0,r0,#1
000576  8008              STRH     r0,[r1,#0]
;;;68     } // -------------------------------------------
000578  4770              BX       lr
;;;69     void ResetTOT(){				//  -.
                          ENDP

                  ResetTOT PROC
00057a  48b8              LDR      r0,|L1.2140|
;;;70     // ----------------------------------------------	
;;;71     //printf("\r\nreset TOT");
;;;72     TIM_TypeDef *timptr=TTOT;
;;;73     	timptr->CR1 &=~TIM_CR1_CEN;		//  .
00057c  8801              LDRH     r1,[r0,#0]
00057e  f0210101          BIC      r1,r1,#1
000582  8001              STRH     r1,[r0,#0]
;;;74     } // -------------------------------------------
000584  4770              BX       lr
;;;75     void MotorBreak(){				//  .
                          ENDP

                  MotorBreak PROC
000586  b500              PUSH     {lr}
;;;76     
;;;77     	SetDirDC(0);				//  .
000588  2000              MOVS     r0,#0
00058a  f7fffffe          BL       SetDirDC
;;;78     	TCAP->DIER&=~TIM_DIER_UIE;		//     .
00058e  48b4              LDR      r0,|L1.2144|
000590  8801              LDRH     r1,[r0,#0]
000592  f0210101          BIC      r1,r1,#1
000596  8001              STRH     r1,[r0,#0]
;;;79     	VoltageMotor=0; SpeedMotor=0;		//   .
000598  49a5              LDR      r1,|L1.2096|
00059a  2000              MOVS     r0,#0
00059c  3154              ADDS     r1,r1,#0x54
00059e  7008              STRB     r0,[r1,#0]
0005a0  49a5              LDR      r1,|L1.2104|
0005a2  6148              STR      r0,[r1,#0x14]  ; SpeedMotor
;;;80     	PWM_Set(0);				//  .
0005a4  f7fffffe          BL       PWM_Set
;;;81     	ResetTOT();				//   .
0005a8  f7fffffe          BL       ResetTOT
;;;82     	State&=~ST_MVX;				//   .
0005ac  48a0              LDR      r0,|L1.2096|
0005ae  7b01              LDRB     r1,[r0,#0xc]  ; lbufinfo
0005b0  f0210101          BIC      r1,r1,#1
0005b4  7301              STRB     r1,[r0,#0xc]
;;;83     } // --------------------------------------------
0005b6  bd00              POP      {pc}
;;;84     void TTOT_IRQ(){				//     R  .
                          ENDP

                  TIM3_IRQHandler PROC
0005b8  b530              PUSH     {r4,r5,lr}
;;;85     //**********************************************
;;;86     TIM_TypeDef *timptr=TTOT;
0005ba  4ca8              LDR      r4,|L1.2140|
;;;87     
;;;88     	timptr->SR =0;				//   .
0005bc  2500              MOVS     r5,#0
0005be  8225              STRH     r5,[r4,#0x10]
;;;89     
;;;90     //printf("\r\nTOT%d",SpeedMotor);
;;;91      if	(SpeedMotor) MotorBreak();		// .
0005c0  489d              LDR      r0,|L1.2104|
0005c2  6940              LDR      r0,[r0,#0x14]  ; SpeedMotor
0005c4  2800              CMP      r0,#0
0005c6  d001              BEQ      |L1.1484|
0005c8  f7fffffe          BL       MotorBreak
                  |L1.1484|
;;;92     	timptr->CR1 &=~TIM_CR1_CEN;		//  .
0005cc  8820              LDRH     r0,[r4,#0]
0005ce  f0200001          BIC      r0,r0,#1
0005d2  8020              STRH     r0,[r4,#0]
;;;93     	timptr->CNT =0;				//   "0".
0005d4  84a5              STRH     r5,[r4,#0x24]
;;;94     } // -------------------------------------------
0005d6  bd30              POP      {r4,r5,pc}
;;;95     
                          ENDP

                  UpdateTOT PROC
;;;96     void UpdateTOT(){				//   -.
0005d8  49a0              LDR      r1,|L1.2140|
;;;97     // ----------------------------------------------	
;;;98     //printf("\r\nupdate TOT");
;;;99     	TTOT->CNT =0;
0005da  2000              MOVS     r0,#0
0005dc  3124              ADDS     r1,r1,#0x24
0005de  8008              STRH     r0,[r1,#0]
;;;100    } // -------------------------------------------
0005e0  4770              BX       lr
;;;101    void MotorOn(){					//  .
                          ENDP

                  MotorOn PROC
0005e2  b500              PUSH     {lr}
;;;102    // ----------------------------------------------	
;;;103    //printf("\r\nmotor on");
;;;104    	State|=ST_MVX;				//      X.
0005e4  4892              LDR      r0,|L1.2096|
0005e6  7b01              LDRB     r1,[r0,#0xc]  ; lbufinfo
0005e8  f0410101          ORR      r1,r1,#1
0005ec  7301              STRB     r1,[r0,#0xc]
;;;105    	SetDirDC (DirX);			//  .
0005ee  4892              LDR      r0,|L1.2104|
0005f0  f9900000          LDRSB    r0,[r0,#0]  ; DirX
0005f4  f7fffffe          BL       SetDirDC
;;;106    	PWM_Set(VoltageMotor);			// 
0005f8  488d              LDR      r0,|L1.2096|
0005fa  3054              ADDS     r0,r0,#0x54
0005fc  7800              LDRB     r0,[r0,#0]  ; ldebinfo
0005fe  f85deb04          POP      {lr}
000602  e7fe              B        PWM_Set
;;;107    } // --------------------------------------------
;;;108    void WaitM(){					//   .
                          ENDP

                  WaitM PROC
000604  488c              LDR      r0,|L1.2104|
;;;109    // ----------------------------------------------	
;;;110    while (SpeedMotor);				//  ,  .
000606  6940              LDR      r0,[r0,#0x14]
                  |L1.1544|
000608  2800              CMP      r0,#0
00060a  d1fd              BNE      |L1.1544|
;;;111    } // --------------------------------------------
00060c  4770              BX       lr
;;;112    void Motor(int speed, int pos){			//     POS   SPEED
                          ENDP

                  Motor PROC
00060e  b530              PUSH     {r4,r5,lr}
000610  4605              MOV      r5,r0
;;;113    // ----------------------------------------------	
;;;114     if (CurrLaserPos!=pos)
000612  4a87              LDR      r2,|L1.2096|
000614  6810              LDR      r0,[r2,#0]  ; lbufinfo
000616  4288              CMP      r0,r1
000618  d022              BEQ      |L1.1632|
;;;115     {	
;;;116    	WaitM();				//    .
00061a  f7fffffe          BL       WaitM
;;;117    	VoltageMotor=pwmmax;			//   .
00061e  4884              LDR      r0,|L1.2096|
000620  4b83              LDR      r3,|L1.2096|
000622  3014              ADDS     r0,r0,#0x14
000624  3354              ADDS     r3,r3,#0x54
000626  f8900029          LDRB     r0,[r0,#0x29]  ; lcnfbuf
00062a  7018              STRB     r0,[r3,#0]
;;;118    	i_value=0; d_value=0;			//     .
00062c  4b82              LDR      r3,|L1.2104|
00062e  2400              MOVS     r4,#0
000630  619c              STR      r4,[r3,#0x18]  ; i_value
000632  61dc              STR      r4,[r3,#0x1c]  ; d_value
;;;119      if (CurrLaserPos>pos) DirX=-1;		//   .
000634  6810              LDR      r0,[r2,#0]  ; lbufinfo
000636  4288              CMP      r0,r1
000638  dd02              BLE      |L1.1600|
00063a  20ff              MOVS     r0,#0xff
00063c  7018              STRB     r0,[r3,#0]
00063e  e001              B        |L1.1604|
                  |L1.1600|
;;;120      else			DirX=+1;
000640  2001              MOVS     r0,#1
000642  7018              STRB     r0,[r3,#0]
                  |L1.1604|
;;;121    	LaserPos=pos;				//   .
000644  6299              STR      r1,[r3,#0x28]  ; LaserPos
;;;122    	SpeedMotor=speed;			//     .
000646  615d              STR      r5,[r3,#0x14]  ; SpeedMotor
;;;123    	SetTOT(TOT_TIME*10-1);			//   .
000648  f242700f          MOV      r0,#0x270f
00064c  f7fffffe          BL       SetTOT
;;;124    indxmem=0;
000650  60dc              STR      r4,[r3,#0xc]  ; indxmem
;;;125    	MotorOn();				//  .
000652  f7fffffe          BL       MotorOn
;;;126    	TCAP->DIER|=TIM_DIER_UIE;		//     .
000656  4882              LDR      r0,|L1.2144|
000658  8801              LDRH     r1,[r0,#0]
00065a  f0410101          ORR      r1,r1,#1
00065e  8001              STRH     r1,[r0,#0]
                  |L1.1632|
;;;127     }
;;;128    } // --------------------------------------------
000660  bd30              POP      {r4,r5,pc}
;;;129    //  .
                          ENDP

                  CaretToHome PROC
;;;130    void CaretToHome(){				//    .
000662  b500              PUSH     {lr}
;;;131    // ----------------------------------------------	
;;;132    	CurrLaserPos=0;				//      .
000664  4972              LDR      r1,|L1.2096|
000666  2000              MOVS     r0,#0
000668  6008              STR      r0,[r1,#0]  ; lbufinfo
;;;133    	Motor(100,100);				//  .
00066a  2164              MOVS     r1,#0x64
00066c  4608              MOV      r0,r1
00066e  f7fffffe          BL       Motor
;;;134    	Motor(100,-(MaxPosEnc));		//      .
000672  4871              LDR      r0,|L1.2104|
000674  6a40              LDR      r0,[r0,#0x24]  ; MaxPosEnc
000676  4241              RSBS     r1,r0,#0
000678  2064              MOVS     r0,#0x64
00067a  f7fffffe          BL       Motor
;;;135    	WaitM();				//   .
00067e  f7fffffe          BL       WaitM
;;;136    	ACK();					//   .
000682  f85deb04          POP      {lr}
000686  e7fe              B        ACK
;;;137    } // --------------------------------------------
;;;138    void StopMove(){				//  .
                          ENDP

                  StopMove PROC
000688  b500              PUSH     {lr}
;;;139    // ----------------------------------------------
;;;140    	MotorBreak(); rSpeedY=BREAKSPEED;
00068a  f7fffffe          BL       MotorBreak
00068e  496a              LDR      r1,|L1.2104|
000690  4868              LDR      r0,|L1.2100|
000692  6348              STR      r0,[r1,#0x34]  ; rSpeedY
;;;141    	ACK();					//   .
000694  f85deb04          POP      {lr}
000698  e7fe              B        ACK
;;;142    } // --------------------------------------------
;;;143    void AbsMoveX(int pos){				//     POS   SPEED
                          ENDP

                  AbsMoveX PROC
00069a  b500              PUSH     {lr}
;;;144    // ----------------------------------------------
;;;145    	Motor(SpeedX,CalcStepX(pos));		//     .
00069c  f7fffffe          BL       CalcStepX
0006a0  4601              MOV      r1,r0
0006a2  4863              LDR      r0,|L1.2096|
0006a4  3014              ADDS     r0,r0,#0x14
0006a6  6a00              LDR      r0,[r0,#0x20]  ; lcnfbuf
0006a8  f7fffffe          BL       Motor
;;;146    	ACK();					//   .
0006ac  f85deb04          POP      {lr}
0006b0  e7fe              B        ACK
;;;147    } // --------------------------------------------
;;;148    void StepXCMD(int steps){			//    STEPS .
                          ENDP

                  StepXCMD PROC
0006b2  b500              PUSH     {lr}
;;;149    // ----------------------------------------------
;;;150    	Motor(SpeedX,CurrLaserPos+steps);	// 
0006b4  495e              LDR      r1,|L1.2096|
0006b6  6809              LDR      r1,[r1,#0]  ; lbufinfo
0006b8  4401              ADD      r1,r1,r0
0006ba  485d              LDR      r0,|L1.2096|
0006bc  3014              ADDS     r0,r0,#0x14
0006be  6a00              LDR      r0,[r0,#0x20]  ; lcnfbuf
0006c0  f7fffffe          BL       Motor
;;;151    	ACK();					//   .
0006c4  f85deb04          POP      {lr}
0006c8  e7fe              B        ACK
;;;152    } // --------------------------------------------
;;;153    void SetSpeed(char *ptr, uint cnt){		//    .	  "vx(y)1234567"
                          ENDP

                  SetSpeed PROC
0006ca  b51c              PUSH     {r2-r4,lr}
;;;154    // ----------------------------------------------
;;;155    char chr; uint val;
;;;156     if	(sscanf(ptr,"%c%d",&chr,&val)==2)
0006cc  466b              MOV      r3,sp
0006ce  aa01              ADD      r2,sp,#4
0006d0  a164              ADR      r1,|L1.2148|
0006d2  f7fffffe          BL       __0sscanf
0006d6  2802              CMP      r0,#2
0006d8  d10f              BNE      |L1.1786|
;;;157     {
;;;158      if	  (chr=='x') SpeedX=val;
0006da  4955              LDR      r1,|L1.2096|
0006dc  f89d0004          LDRB     r0,[sp,#4]
0006e0  3114              ADDS     r1,r1,#0x14
0006e2  2878              CMP      r0,#0x78
0006e4  d002              BEQ      |L1.1772|
;;;159      else if (chr=='y') StpSpd=val;
0006e6  2879              CMP      r0,#0x79
0006e8  d003              BEQ      |L1.1778|
0006ea  e004              B        |L1.1782|
                  |L1.1772|
0006ec  9800              LDR      r0,[sp,#0]            ;158
0006ee  6208              STR      r0,[r1,#0x20]         ;158  ; lcnfbuf
0006f0  e001              B        |L1.1782|
                  |L1.1778|
0006f2  9800              LDR      r0,[sp,#0]
0006f4  6248              STR      r0,[r1,#0x24]  ; lcnfbuf
                  |L1.1782|
;;;160    	ACK();					//   .
0006f6  f7fffffe          BL       ACK
                  |L1.1786|
;;;161     }
;;;162    }//______________________________________________
0006fa  bd1c              POP      {r2-r4,pc}
;;;163    
                          ENDP

                  MoveCMD PROC
;;;164    void MoveCMD(char *ptr,uint cnt){		//   .
0006fc  b51c              PUSH     {r2-r4,lr}
;;;165    // ----------------------------------------------	
;;;166    char cmd, chr;
;;;167    int prm,cntp;
;;;168    
;;;169    	cntp=sscanf(ptr,"%c%d",&cmd,&prm);
0006fe  466b              MOV      r3,sp
000700  aa01              ADD      r2,sp,#4
000702  a158              ADR      r1,|L1.2148|
000704  f7fffffe          BL       __0sscanf
;;;170    	chr=cmd;
000708  f89d1004          LDRB     r1,[sp,#4]
;;;171    if	(cntp==1){
00070c  2801              CMP      r0,#1
00070e  d00d              BEQ      |L1.1836|
;;;172     if     (chr=='s') StopMove();
;;;173     else if(chr=='h') CaretToHome();
;;;174     }
;;;175    else if	(cntp==2){
000710  2802              CMP      r0,#2
000712  d10a              BNE      |L1.1834|
;;;176     if      (chr=='Y') AbsMoveY(prm);
000714  2959              CMP      r1,#0x59
000716  d013              BEQ      |L1.1856|
;;;177     else if (chr=='X') AbsMoveX(prm);
000718  2958              CMP      r1,#0x58
00071a  d015              BEQ      |L1.1864|
;;;178     else if (chr=='y') StepYCMD(prm);
00071c  2979              CMP      r1,#0x79
00071e  d017              BEQ      |L1.1872|
;;;179     else if (chr=='x') StepXCMD(prm);
000720  2978              CMP      r1,#0x78
000722  d102              BNE      |L1.1834|
000724  9800              LDR      r0,[sp,#0]
000726  f7fffffe          BL       StepXCMD
                  |L1.1834|
;;;180     }	 
;;;181    } // --------------------------------------------
00072a  bd1c              POP      {r2-r4,pc}
                  |L1.1836|
00072c  2973              CMP      r1,#0x73              ;172
00072e  d004              BEQ      |L1.1850|
000730  2968              CMP      r1,#0x68              ;173
000732  d1fa              BNE      |L1.1834|
000734  f7fffffe          BL       CaretToHome
000738  bd1c              POP      {r2-r4,pc}
                  |L1.1850|
00073a  f7fffffe          BL       StopMove
00073e  bd1c              POP      {r2-r4,pc}
                  |L1.1856|
000740  9800              LDR      r0,[sp,#0]            ;176
000742  f7fffffe          BL       AbsMoveY
000746  bd1c              POP      {r2-r4,pc}
                  |L1.1864|
000748  9800              LDR      r0,[sp,#0]            ;177
00074a  f7fffffe          BL       AbsMoveX
00074e  bd1c              POP      {r2-r4,pc}
                  |L1.1872|
000750  9800              LDR      r0,[sp,#0]            ;178
000752  f7fffffe          BL       StepYCMD
000756  bd1c              POP      {r2-r4,pc}
;;;17     #include "src\laser.c"
                          ENDP

                  LaserOff PROC
;;;25     */
;;;26     void LaserOff(){				//  .
000758  4939              LDR      r1,|L1.2112|
;;;27     // ----------------------------------------------
;;;28     	portLsr->BRR=MaskLasers;
00075a  200f              MOVS     r0,#0xf
00075c  3114              ADDS     r1,r1,#0x14
00075e  6008              STR      r0,[r1,#0]
;;;29     }// ---------------------------------------------
000760  4770              BX       lr
;;;30     void _LaserOn(){					//  .
                          ENDP

                  _LaserOn PROC
000762  4937              LDR      r1,|L1.2112|
;;;31     // ----------------------------------------------
;;;32     	portLsr->BSRR=MaskLasers;
000764  200f              MOVS     r0,#0xf
000766  3110              ADDS     r1,r1,#0x10
000768  6008              STR      r0,[r1,#0]
;;;33     }// ---------------------------------------------
00076a  4770              BX       lr
;;;34     void OutLasers(uint lmask, uint lbits){		//        "1".
                          ENDP

                  OutLasers PROC
00076c  4001              ANDS     r1,r1,r0
;;;35     // ----------------------------------------------
;;;36     	lbits&=lmask;				//   .
;;;37     	lbits=(lbits|((lbits^lmask)<<16));	//       16 .
00076e  4048              EORS     r0,r0,r1
000770  ea414000          ORR      r0,r1,r0,LSL #16
;;;38     	portLsr->BSRR=lbits;			//    .
000774  4932              LDR      r1,|L1.2112|
000776  3110              ADDS     r1,r1,#0x10
000778  6008              STR      r0,[r1,#0]
;;;39     	CntPix--;				//    .
00077a  492f              LDR      r1,|L1.2104|
00077c  7888              LDRB     r0,[r1,#2]  ; CntPix
00077e  1e40              SUBS     r0,r0,#1
000780  7088              STRB     r0,[r1,#2]
;;;40     } // --------------------------------------------
000782  4770              BX       lr
;;;41     
                          ENDP

                  FlashLaser_4p PROC
;;;42     void FlashLaser_4p(uint pos){			//        "1".
000784  492c              LDR      r1,|L1.2104|
;;;43     // ---------------------------------------------//  		76543210 76543210  
;;;44     uint lbits;					//  	0   1    2   3
;;;45     	lbits=ActBuffer[pos>>1];		//    .
000786  6ac9              LDR      r1,[r1,#0x2c]  ; ActBuffer
000788  eb010150          ADD      r1,r1,r0,LSR #1
00078c  7809              LDRB     r1,[r1,#0]
;;;46     	lbits=lbits>>(4-((pos<<2&4)));		//  .
00078e  2204              MOVS     r2,#4
000790  ea020080          AND      r0,r2,r0,LSL #2
000794  f1c00004          RSB      r0,r0,#4
000798  40c1              LSRS     r1,r1,r0
;;;47     	OutLasers(15,lbits);			// 
00079a  200f              MOVS     r0,#0xf
00079c  e7fe              B        OutLasers
;;;48     } // --------------------------------------------
;;;49     void FlashLaser_2p(uint pos){			//        "1".
                          ENDP

                  FlashLaser_2p PROC
00079e  4926              LDR      r1,|L1.2104|
;;;50     // ---------------------------------------------//  		76543210 76543210  
;;;51     uint lbits;					//  	0 1 2 3  4 5 6 7
;;;52     	lbits=ActBuffer[pos>>2];		//    .
0007a0  6ac9              LDR      r1,[r1,#0x2c]  ; ActBuffer
0007a2  eb010190          ADD      r1,r1,r0,LSR #2
0007a6  7809              LDRB     r1,[r1,#0]
;;;53     	lbits=lbits>>(6-((pos<<1&6)));		//  .
0007a8  2206              MOVS     r2,#6
0007aa  ea020040          AND      r0,r2,r0,LSL #1
0007ae  f1c00006          RSB      r0,r0,#6
0007b2  40c1              LSRS     r1,r1,r0
;;;54     	OutLasers(3,lbits);			// 
0007b4  2003              MOVS     r0,#3
0007b6  e7fe              B        OutLasers
;;;55     } // --------------------------------------------
;;;56     
                          ENDP

                  FlashLaser_1p PROC
;;;57     void FlashLaser_1p(uint pos){			//        "1".
0007b8  491f              LDR      r1,|L1.2104|
;;;58     // ---------------------------------------------//  		76543210 76543210  
;;;59     uint lbits;					//  	01234567 89......
;;;60     	lbits=ActBuffer[pos>>3];		//    .
0007ba  6ac9              LDR      r1,[r1,#0x2c]  ; ActBuffer
0007bc  eb0101d0          ADD      r1,r1,r0,LSR #3
0007c0  7809              LDRB     r1,[r1,#0]
;;;61     	lbits=lbits>>(7-(pos&7));		//  .
0007c2  f0000007          AND      r0,r0,#7
0007c6  f1c00007          RSB      r0,r0,#7
0007ca  40c1              LSRS     r1,r1,r0
;;;62     	OutLasers(1,lbits);			// 
0007cc  2001              MOVS     r0,#1
0007ce  e7fe              B        OutLasers
;;;63     } // --------------------------------------------
;;;64     
                          ENDP

                  FlashLaser PROC
;;;65     void FlashLaser(int pos, uint offs){		//        "1".
0007d0  b510              PUSH     {r4,lr}
;;;66     // ----------------------------------------------	
;;;67      if ((pos>=0)&&(pos<MaxPosEnc))			//    .
0007d2  4a19              LDR      r2,|L1.2104|
0007d4  2800              CMP      r0,#0
0007d6  db0d              BLT      |L1.2036|
0007d8  6a53              LDR      r3,[r2,#0x24]  ; MaxPosEnc
0007da  4298              CMP      r0,r3
0007dc  d20a              BCS      |L1.2036|
;;;68     	ExecFlash((uint)pos*qual+offs-1);	//    .
0007de  4b14              LDR      r3,|L1.2096|
0007e0  3314              ADDS     r3,r3,#0x14
0007e2  1e49              SUBS     r1,r1,#1
0007e4  f893302a          LDRB     r3,[r3,#0x2a]  ; lcnfbuf
0007e8  fb001003          MLA      r0,r0,r3,r1
0007ec  6c51              LDR      r1,[r2,#0x44]  ; ExecFlash
0007ee  e8bd4010          POP      {r4,lr}
0007f2  4708              BX       r1
                  |L1.2036|
;;;69      else	LaserOff(), CntPix=0;
0007f4  f7fffffe          BL       LaserOff
0007f8  2000              MOVS     r0,#0
0007fa  7090              STRB     r0,[r2,#2]
;;;70     } // --------------------------------------------
0007fc  bd10              POP      {r4,pc}
;;;71     void CheckFlashLaser(int pos, int dir){		//        "1".
                          ENDP

                  CheckFlashLaser PROC
0007fe  b570              PUSH     {r4-r6,lr}
000800  460d              MOV      r5,r1
;;;72     // ----------------------------------------------	
;;;73     uchar ql=Laser;
000802  4e0d              LDR      r6,|L1.2104|
000804  78f1              LDRB     r1,[r6,#3]  ; Laser
;;;74      if (ql==1)
000806  2901              CMP      r1,#1
000808  d111              BNE      |L1.2094|
;;;75      {
;;;76     	ql=0; TLSR->CNT=ql;			//    =0.
00080a  2100              MOVS     r1,#0
00080c  f04f4280          MOV      r2,#0x40000000
000810  8491              STRH     r1,[r2,#0x24]
;;;77     	ql=qual; CntPix=ql;			//    .
000812  4907              LDR      r1,|L1.2096|
000814  3114              ADDS     r1,r1,#0x14
000816  f891402a          LDRB     r4,[r1,#0x2a]  ; lcnfbuf
00081a  70b4              STRB     r4,[r6,#2]
;;;78       if (dir>0) ql=1;				//      .
00081c  2d00              CMP      r5,#0
00081e  dd00              BLE      |L1.2082|
000820  2401              MOVS     r4,#1
                  |L1.2082|
;;;79     	OffsPix=ql, FlashLaser(pos,ql);		//   c   ..
000822  7074              STRB     r4,[r6,#1]
000824  4621              MOV      r1,r4
000826  f7fffffe          BL       FlashLaser
;;;80     	OffsPix=ql+dir;				//    .
00082a  1960              ADDS     r0,r4,r5
00082c  7070              STRB     r0,[r6,#1]
                  |L1.2094|
;;;81      }
;;;82     } // --------------------------------------------
00082e  bd70              POP      {r4-r6,pc}
                  |L1.2096|
                          DCD      ||.bss||
                  |L1.2100|
                          DCD      0x0003f3af
                  |L1.2104|
                          DCD      ||.data||
                  |L1.2108|
                          DCD      0xe000ed23
                  |L1.2112|
                          DCD      0x40010800
                  |L1.2116|
                          DCD      0x11110000
                  |L1.2120|
                          DCD      0x40010c00
                  |L1.2124|
                          DCD      0x40012c00
                  |L1.2128|
                          DCD      0x40010000
                  |L1.2132|
                          DCD      0x40021000
                  |L1.2136|
                          DCD      0x3bb30000
                  |L1.2140|
                          DCD      0x40000400
                  |L1.2144|
                          DCD      0x4000080c
                  |L1.2148|
000864  25632564          DCB      "%c%d",0
000868  00      
000869  00                DCB      0
00086a  00                DCB      0
00086b  00                DCB      0
                          ENDP

                  ClearLaserPINS PROC
;;;83     
;;;84     void ClearLaserPINS(){				//    .
00086c  48f7              LDR      r0,|L1.3148|
;;;85     // ----------------------------------------------	
;;;86     	portLsr_CR &=~(
00086e  6801              LDR      r1,[r0,#0]
000870  f36f010f          BFC      r1,#0,#16
000874  6001              STR      r1,[r0,#0]
;;;87     		(PinCR(pinLsr0,GPIOCR))|	//    .
;;;88     		(PinCR(pinLsr1,GPIOCR))|
;;;89     		(PinCR(pinLsr2,GPIOCR))|
;;;90     		(PinCR(pinLsr3,GPIOCR))
;;;91     		);
;;;92     } // --------------------------------------------
000876  4770              BX       lr
;;;93     void LaserPWM(uint val){			//      (0.2%-100%).
                          ENDP

                  LaserPWM PROC
000878  b500              PUSH     {lr}
;;;94     // ----------------------------------------------
;;;95     	TLSR->CCR1=val;				//  .
00087a  f04f4180          MOV      r1,#0x40000000
00087e  8688              STRH     r0,[r1,#0x34]
;;;96     	TLSR->CCR2=val;				//  .
000880  8708              STRH     r0,[r1,#0x38]
;;;97     	TLSR->CCR3=val;				//  .
000882  8788              STRH     r0,[r1,#0x3c]
;;;98     	TLSR->CCR4=val;				//  .
000884  f8a10040          STRH     r0,[r1,#0x40]
;;;99     	
;;;100    	TLSR->PSC = (TLSR_CK/LSR_FREQ/LSR_RES-1);	// .
000888  208f              MOVS     r0,#0x8f
00088a  8508              STRH     r0,[r1,#0x28]
;;;101    	TLSR->ARR = (LSR_RES-1);		//  .
00088c  f24030e7          MOV      r0,#0x3e7
000890  8588              STRH     r0,[r1,#0x2c]
;;;102    	
;;;103    	TLSR->CCMR1=	(TIM_CCMR1_OC1M_1|
000892  f2460060          MOV      r0,#0x6060
000896  8308              STRH     r0,[r1,#0x18]
;;;104    			 TIM_CCMR1_OC1M_2|
;;;105    			 TIM_CCMR1_OC2M_1|
;;;106    			 TIM_CCMR1_OC2M_2);	//   6.  1  2
;;;107    			 
;;;108    	TLSR->CCMR2=	(TIM_CCMR2_OC3M_1|
000898  8388              STRH     r0,[r1,#0x1c]
;;;109    			 TIM_CCMR2_OC3M_2|
;;;110    			 TIM_CCMR2_OC4M_1|
;;;111    			 TIM_CCMR2_OC4M_2);	//   6.  3  4
;;;112    			 
;;;113    	TLSR->CCER =	(TIM_CCER_CC1E|		// CCE channel 1
00089a  f2411011          MOV      r0,#0x1111
00089e  8408              STRH     r0,[r1,#0x20]
;;;114    			 TIM_CCER_CC2E|		// CCE channel 2
;;;115    			 TIM_CCER_CC3E|		// CCE channel 3
;;;116    			 TIM_CCER_CC4E);	// CCE channel 4
;;;117    	TLSR->CR1 |= 	TIM_CR1_CEN;		//  .
0008a0  8808              LDRH     r0,[r1,#0]
0008a2  f0400001          ORR      r0,r0,#1
0008a6  8008              STRH     r0,[r1,#0]
;;;118    
;;;119    	//    .
;;;120    
;;;121    	ClearLaserPINS();
0008a8  f7fffffe          BL       ClearLaserPINS
;;;122    	portLsr_CR |=(
0008ac  48e7              LDR      r0,|L1.3148|
0008ae  6801              LDR      r1,[r0,#0]
0008b0  f64b32bb          MOV      r2,#0xbbbb
0008b4  4311              ORRS     r1,r1,r2
0008b6  6001              STR      r1,[r0,#0]
;;;123    		(PinCR(pinLsr0,p_a_p50))|	//  .
;;;124    		(PinCR(pinLsr1,p_a_p50))|
;;;125    		(PinCR(pinLsr2,p_a_p50))|
;;;126    		(PinCR(pinLsr3,p_a_p50))
;;;127    		);
;;;128    } // --------------------------------------------
0008b8  bd00              POP      {pc}
;;;129    void InitLaserWRK(){				//      .
                          ENDP

                  InitLaserWRK PROC
0008ba  b510              PUSH     {r4,lr}
;;;130    // ----------------------------------------------
;;;131    TIM_TypeDef *timptr=TLSR;
0008bc  f04f4480          MOV      r4,#0x40000000
;;;132    	SET_PER_LSR				// ,  .
0008c0  48e3              LDR      r0,|L1.3152|
0008c2  69c1              LDR      r1,[r0,#0x1c]
0008c4  f0410101          ORR      r1,r1,#1
0008c8  61c1              STR      r1,[r0,#0x1c]
0008ca  48e2              LDR      r0,|L1.3156|
0008cc  6841              LDR      r1,[r0,#4]
0008ce  6041              STR      r1,[r0,#4]
;;;133    	
;;;134    	timptr->PSC=(TLSR_CK/FTCAP-1);		//    .
0008d0  2005              MOVS     r0,#5
0008d2  8520              STRH     r0,[r4,#0x28]
;;;135    	timptr->ARR=(0xFFFF);			//   .
0008d4  f64f70ff          MOV      r0,#0xffff
0008d8  85a0              STRH     r0,[r4,#0x2c]
;;;136    	
;;;137    	timptr->DIER =TIM_DIER_UIE;		//     .
0008da  2001              MOVS     r0,#1
0008dc  81a0              STRH     r0,[r4,#0xc]
;;;138    	NVIC_EnableIRQ(TLSR_IRQn);		//    .
0008de  201c              MOVS     r0,#0x1c
0008e0  f7fffffe          BL       NVIC_EnableIRQ
;;;139    	TLSR->CR1 |= TIM_CR1_CEN;		//  .
0008e4  8820              LDRH     r0,[r4,#0]
0008e6  f0400001          ORR      r0,r0,#1
0008ea  8020              STRH     r0,[r4,#0]
;;;140    	
;;;141    	//    GPIO .
;;;142    	
;;;143    	ClearLaserPINS();
0008ec  f7fffffe          BL       ClearLaserPINS
;;;144    	portLsr_CR |=(
0008f0  48d6              LDR      r0,|L1.3148|
0008f2  6801              LDR      r1,[r0,#0]
0008f4  f2433233          MOV      r2,#0x3333
0008f8  4311              ORRS     r1,r1,r2
0008fa  6001              STR      r1,[r0,#0]
;;;145    		(PinCR(pinLsr0,p_o_p50))|	//   .
;;;146    		(PinCR(pinLsr1,p_o_p50))|
;;;147    		(PinCR(pinLsr2,p_o_p50))|
;;;148    		(PinCR(pinLsr3,p_o_p50))
;;;149    	);
;;;150    	LaserOff();
0008fc  e8bd4010          POP      {r4,lr}
000900  e7fe              B        LaserOff
;;;151    } // --------------------------------------------
;;;152    void LaserCTRL(uint val){			// /  .
                          ENDP

                  LaserCTRL PROC
000902  49d5              LDR      r1,|L1.3160|
;;;153    // ----------------------------------------------	
;;;154    	Laser=val;
000904  70c8              STRB     r0,[r1,#3]
;;;155     if (val<=1)		InitLaserWRK();
000906  2801              CMP      r0,#1
000908  d800              BHI      |L1.2316|
00090a  e7fe              B        InitLaserWRK
                  |L1.2316|
;;;156     else if (val==2)	LaserPWM(1);
00090c  2802              CMP      r0,#2
00090e  d000              BEQ      |L1.2322|
;;;157     else			LaserPWM(val);
000910  e7fe              B        LaserPWM
                  |L1.2322|
000912  2001              MOVS     r0,#1                 ;156
000914  e7fe              B        LaserPWM
;;;158    } // --------------------------------------------
;;;159    void LaserCMD (char *ptr,uint cnt){		//  .
                          ENDP

                  LaserCMD PROC
000916  b508              PUSH     {r3,lr}
;;;160    // ----------------------------------------------
;;;161    uint val=0; uint cntp;
000918  2100              MOVS     r1,#0
00091a  9100              STR      r1,[sp,#0]
;;;162    
;;;163    	cntp=sscanf(ptr,"%d",&val);
00091c  466a              MOV      r2,sp
00091e  a1cf              ADR      r1,|L1.3164|
000920  f7fffffe          BL       __0sscanf
;;;164     if	(cntp) LaserCTRL(val);
000924  b110              CBZ      r0,|L1.2348|
000926  9800              LDR      r0,[sp,#0]
000928  f7fffffe          BL       LaserCTRL
                  |L1.2348|
;;;165    	ACK();					//   .
00092c  f7fffffe          BL       ACK
;;;166    }// ---------------------------------------------
000930  bd08              POP      {r3,pc}
;;;167    void TLSR_IRQ(){				//    .
                          ENDP

                  TIM2_IRQHandler PROC
000932  b570              PUSH     {r4-r6,lr}
;;;168    // ----------------------------------------------
;;;169    uint offs;
;;;170    	TLSR->SR=0; 				//   .
000934  f04f4180          MOV      r1,#0x40000000
000938  2000              MOVS     r0,#0
00093a  8208              STRH     r0,[r1,#0x10]
;;;171     if ((Laser==1)&&(CntPix))
00093c  4cc6              LDR      r4,|L1.3160|
00093e  78e0              LDRB     r0,[r4,#3]  ; Laser
000940  2801              CMP      r0,#1
000942  d10b              BNE      |L1.2396|
000944  78a0              LDRB     r0,[r4,#2]  ; CntPix
000946  2800              CMP      r0,#0
000948  d008              BEQ      |L1.2396|
;;;172     {	 
;;;173    	offs=OffsPix;				//    .
00094a  7865              LDRB     r5,[r4,#1]  ; OffsPix
;;;174    	FlashLaser(CurrLaserPos,offs);		//  .
00094c  48c4              LDR      r0,|L1.3168|
00094e  4629              MOV      r1,r5
000950  6800              LDR      r0,[r0,#0]  ; lbufinfo
000952  f7fffffe          BL       FlashLaser
;;;175    	offs+=DirX, OffsPix=offs;
000956  7820              LDRB     r0,[r4,#0]  ; DirX
000958  4428              ADD      r0,r0,r5
00095a  7060              STRB     r0,[r4,#1]
                  |L1.2396|
;;;176     }
;;;177    }// ---------------------------------------------
00095c  e767              B        |L1.2094|
;;;178    
                          ENDP

                  ChangeLaserPos PROC
;;;37     }; // -------------------------------------------
;;;38     int  ChangeLaserPos(uint sti){			//   .
00095e  b510              PUSH     {r4,lr}
;;;39     // ----------------------------------------------	
;;;40     int dir, pos;
;;;41     	sti=((sti&(TIM_SR_CC1IF|TIM_SR_CC2IF|	//   .
000960  f000001e          AND      r0,r0,#0x1e
000964  0040              LSLS     r0,r0,#1
;;;42     	TIM_SR_CC3IF|TIM_SR_CC4IF))<<1);	//    00xx xx00
;;;43      if ((portENC1->IDR)&(1<<pinEnc1)) sti|=1;
000966  49bf              LDR      r1,|L1.3172|
000968  680a              LDR      r2,[r1,#0]
00096a  0652              LSLS     r2,r2,#25
00096c  2a00              CMP      r2,#0
00096e  da01              BGE      |L1.2420|
000970  f0400001          ORR      r0,r0,#1
                  |L1.2420|
;;;44      if ((portENC2->IDR)&(1<<pinEnc2)) sti|=2;	//  6  . 00iiiiPP
000974  6809              LDR      r1,[r1,#0]
000976  05c9              LSLS     r1,r1,#23
000978  d501              BPL      |L1.2430|
00097a  f0400002          ORR      r0,r0,#2
                  |L1.2430|
;;;45     	dir=tab_enc[sti];			//   .
00097e  49ba              LDR      r1,|L1.3176|
000980  560a              LDRSB    r2,[r1,r0]
;;;46     	pos=CurrLaserPos;			//  .
000982  4bb7              LDR      r3,|L1.3168|
000984  6818              LDR      r0,[r3,#0]  ; lbufinfo
;;;47     	pos+=dir;				// .
000986  1884              ADDS     r4,r0,r2
;;;48      if (dir!=0) UpdateTOT();			//   -  -.
000988  b10a              CBZ      r2,|L1.2446|
00098a  f7fffffe          BL       UpdateTOT
                  |L1.2446|
;;;49     						if (dir==0) ldebinfo.err1++;//  .  .
00098e  b922              CBNZ     r2,|L1.2458|
000990  49b3              LDR      r1,|L1.3168|
000992  3154              ADDS     r1,r1,#0x54
000994  8948              LDRH     r0,[r1,#0xa]  ; ldebinfo
000996  1c40              ADDS     r0,r0,#1
000998  8148              STRH     r0,[r1,#0xa]
                  |L1.2458|
;;;50      if (fDebug==DEB_MODE_PID)
00099a  49af              LDR      r1,|L1.3160|
00099c  6908              LDR      r0,[r1,#0x10]  ; fDebug
00099e  2801              CMP      r0,#1
0009a0  d110              BNE      |L1.2500|
;;;51      {	
;;;52       if (!CurrLaserPos)
0009a2  6818              LDR      r0,[r3,#0]  ; lbufinfo
0009a4  b970              CBNZ     r0,|L1.2500|
;;;53       {	
;;;54         if (dir>0)	lbuf0[indxmem-1]=0;		//  0- .
0009a6  2000              MOVS     r0,#0
0009a8  2a00              CMP      r2,#0
0009aa  dd06              BLE      |L1.2490|
0009ac  4aac              LDR      r2,|L1.3168|
0009ae  68c9              LDR      r1,[r1,#0xc]  ; indxmem
0009b0  328c              ADDS     r2,r2,#0x8c
0009b2  4411              ADD      r1,r1,r2
0009b4  f8010c01          STRB     r0,[r1,#-1]
0009b8  e004              B        |L1.2500|
                  |L1.2490|
;;;55         else	lbuf1[indxmem-1]=0;
0009ba  4aac              LDR      r2,|L1.3180|
0009bc  68c9              LDR      r1,[r1,#0xc]  ; indxmem
0009be  4411              ADD      r1,r1,r2
0009c0  f8010c01          STRB     r0,[r1,#-1]
                  |L1.2500|
;;;56       }
;;;57      }
;;;58     	CurrLaserPos=pos; return (pos);
0009c4  601c              STR      r4,[r3,#0]  ; lbufinfo
0009c6  4620              MOV      r0,r4
;;;59     } // --------------------------------------------
0009c8  bd10              POP      {r4,pc}
;;;60     void SpeedRegulator(uint cspd){			//  .
                          ENDP

                  SpeedRegulator PROC
0009ca  b530              PUSH     {r4,r5,lr}
;;;61     
;;;62     uint	vm;
;;;63     int	serr,ival;
;;;64     
;;;65     	ival=i_value;
0009cc  4da2              LDR      r5,|L1.3160|
0009ce  69a9              LDR      r1,[r5,#0x18]  ; i_value
;;;66     //	dval=d_value;		// 
;;;67     	
;;;68     	AvrgSpd=cspd;				//   .
0009d0  4aa3              LDR      r2,|L1.3168|
0009d2  6090              STR      r0,[r2,#8]  ; lbufinfo
;;;69     	serr=SpeedMotor-cspd;			//   .
0009d4  696a              LDR      r2,[r5,#0x14]  ; SpeedMotor
0009d6  1a10              SUBS     r0,r2,r0
;;;70     	ival+=serr;				//    .
0009d8  180c              ADDS     r4,r1,r0
;;;71     //	dval=serr-d_value;			//    .
;;;72     	
;;;73     //	vm = ((serr*k_prp)+(ival*k_int)-(dval*k_dif))/k_com + pwmmin;
;;;74     	vm = ((serr*k_prp)+(ival*k_int))/k_com + pwmmin;
0009da  49a1              LDR      r1,|L1.3168|
0009dc  3114              ADDS     r1,r1,#0x14
0009de  680a              LDR      r2,[r1,#0]  ; lcnfbuf
0009e0  4342              MULS     r2,r0,r2
0009e2  6848              LDR      r0,[r1,#4]  ; lcnfbuf
0009e4  fb042000          MLA      r0,r4,r0,r2
0009e8  68ca              LDR      r2,[r1,#0xc]  ; lcnfbuf
0009ea  fb90f0f2          SDIV     r0,r0,r2
0009ee  f8912028          LDRB     r2,[r1,#0x28]  ; lcnfbuf
0009f2  4410              ADD      r0,r0,r2
;;;75     	
;;;76       if (vm>pwmmax) vm=pwmmax;			//    .
0009f4  f8911029          LDRB     r1,[r1,#0x29]  ; lcnfbuf
0009f8  4281              CMP      r1,r0
0009fa  d200              BCS      |L1.2558|
0009fc  4608              MOV      r0,r1
                  |L1.2558|
;;;77     	VoltageMotor=vm; PWM_Set(vm);		//   .
0009fe  4998              LDR      r1,|L1.3168|
000a00  3154              ADDS     r1,r1,#0x54
000a02  7008              STRB     r0,[r1,#0]
000a04  b280              UXTH     r0,r0
000a06  f7fffffe          BL       PWM_Set
;;;78     	i_value=ival;				//   .
000a0a  61ac              STR      r4,[r5,#0x18]  ; i_value
;;;79     //	d_value=serr;				//   .
;;;80     } // --------------------------------------------
000a0c  bd30              POP      {r4,r5,pc}
;;;81     void CheckStop(int pos, int dir){		//    .
                          ENDP

                  CheckStop PROC
000a0e  b570              PUSH     {r4-r6,lr}
000a10  4604              MOV      r4,r0
000a12  460e              MOV      r6,r1
;;;82     
;;;83      if 	(SpeedMotor)				//    ?
000a14  4d90              LDR      r5,|L1.3160|
000a16  6968              LDR      r0,[r5,#0x14]  ; SpeedMotor
000a18  2800              CMP      r0,#0
000a1a  d00c              BEQ      |L1.2614|
000a1c  4628              MOV      r0,r5
;;;84      {
;;;85       if (dir<0)
000a1e  2e00              CMP      r6,#0
;;;86       {
;;;87       if (pos<=LaserPos) MotorBreak();
000a20  6a80              LDR      r0,[r0,#0x28]
000a22  da04              BGE      |L1.2606|
000a24  4284              CMP      r4,r0
000a26  dc06              BGT      |L1.2614|
000a28  f7fffffe          BL       MotorBreak
000a2c  e003              B        |L1.2614|
                  |L1.2606|
;;;88       }
;;;89       else if (pos>=LaserPos) MotorBreak();
000a2e  4284              CMP      r4,r0
000a30  db01              BLT      |L1.2614|
000a32  f7fffffe          BL       MotorBreak
                  |L1.2614|
;;;90      }
;;;91      if (fDebug==DEB_MODE_PID)
000a36  6928              LDR      r0,[r5,#0x10]  ; fDebug
000a38  2801              CMP      r0,#1
000a3a  d10b              BNE      |L1.2644|
;;;92      {	
;;;93       if (pos==LaserPos)
000a3c  6aa8              LDR      r0,[r5,#0x28]  ; LaserPos
000a3e  4284              CMP      r4,r0
000a40  d108              BNE      |L1.2644|
;;;94       {	
;;;95         if (dir>0)	lbuf0[indxmem-1]=0;		//  .
000a42  2000              MOVS     r0,#0
000a44  2e00              CMP      r6,#0
000a46  dd06              BLE      |L1.2646|
000a48  4985              LDR      r1,|L1.3168|
000a4a  68ea              LDR      r2,[r5,#0xc]  ; indxmem
000a4c  318c              ADDS     r1,r1,#0x8c
000a4e  4411              ADD      r1,r1,r2
000a50  f8010c01          STRB     r0,[r1,#-1]
                  |L1.2644|
;;;96         else	lbuf1[indxmem-1]=0;
;;;97       }
;;;98      }
;;;99     } // --------------------------------------------
000a54  e6eb              B        |L1.2094|
                  |L1.2646|
000a56  4985              LDR      r1,|L1.3180|
000a58  68ea              LDR      r2,[r5,#0xc]          ;96  ; indxmem
000a5a  4411              ADD      r1,r1,r2              ;96
000a5c  f8010c01          STRB     r0,[r1,#-1]           ;96
000a60  e6e5              B        |L1.2094|
;;;100    
                          ENDP

                  TIM4_IRQHandler PROC
;;;101    void TCAP_IRQ(){				//    .
000a62  e92d5ff0          PUSH     {r4-r12,lr}
;;;102    // ----------------------------------------------
;;;103    int lpos;
;;;104    schar dir;
;;;105    uint sti, cspd, tmp;
;;;106    TIM_TypeDef *timptr=TCAP;			//    .
000a66  4d82              LDR      r5,|L1.3184|
;;;107    						tmp=timptr->CNT;//       ( ).
000a68  f8b59024          LDRH     r9,[r5,#0x24]
;;;108    	dir=DirX,				//   .
000a6c  f8df81e8          LDR      r8,|L1.3160|
000a70  f9987000          LDRSB    r7,[r8,#0]  ; DirX
;;;109    	sti=timptr->SR,	timptr->SR=0;		//  .    .
000a74  8a2c              LDRH     r4,[r5,#0x10]
000a76  f04f0a00          MOV      r10,#0
000a7a  f8a5a010          STRH     r10,[r5,#0x10]
;;;110     if (sti&(TIM_SR_CC1IF|TIM_SR_CC2IF|TIM_SR_CC3IF|TIM_SR_CC4IF))	//     .
;;;111    // if (sti&WorkSTI)				// 
;;;112     //******************************************
;;;113     {
;;;114    	lpos=ChangeLaserPos(sti);		//   .
;;;115    	CheckFlashLaser(lpos, dir);		//     .
;;;116    						if (sti&TIM_SR_CC1IF) LaserCNT=timptr->CNT;	//     .
000a7e  4e78              LDR      r6,|L1.3168|
000a80  f0140f1e          TST      r4,#0x1e              ;110
000a84  f1060654          ADD      r6,r6,#0x54
000a88  d00f              BEQ      |L1.2730|
000a8a  4620              MOV      r0,r4                 ;114
000a8c  f7fffffe          BL       ChangeLaserPos
000a90  4683              MOV      r11,r0                ;114
000a92  4639              MOV      r1,r7                 ;115
000a94  4658              MOV      r0,r11                ;115
000a96  f7fffffe          BL       CheckFlashLaser
000a9a  07a0              LSLS     r0,r4,#30
000a9c  d501              BPL      |L1.2722|
000a9e  8ca8              LDRH     r0,[r5,#0x24]
000aa0  8130              STRH     r0,[r6,#8]
                  |L1.2722|
;;;117    	CheckStop(lpos, dir);			//     .
000aa2  4639              MOV      r1,r7
000aa4  4658              MOV      r0,r11
000aa6  f7fffffe          BL       CheckStop
                  |L1.2730|
;;;118     } //******************************************
;;;119    	cspd=timptr->CCR1;			//   .
000aaa  8eaa              LDRH     r2,[r5,#0x34]
;;;120     if (sti&TIM_SR_UIF) CapNCCR=0, cspd=0xFFFFFFF;	//  ,   .
000aac  07e0              LSLS     r0,r4,#31
000aae  f06f4170          MVN      r1,#0xf0000000
000ab2  d002              BEQ      |L1.2746|
000ab4  f8c8a020          STR      r10,[r8,#0x20]  ; CapNCCR
000ab8  460a              MOV      r2,r1
                  |L1.2746|
;;;121     if (sti&TIM_SR_CC1IF)				//      .
000aba  07a0              LSLS     r0,r4,#30
000abc  d50e              BPL      |L1.2780|
;;;122     {
;;;123    	timptr->CNT-=cspd, CapNCCR++;		//   . .  .
000abe  8ca8              LDRH     r0,[r5,#0x24]
000ac0  1a80              SUBS     r0,r0,r2
000ac2  84a8              STRH     r0,[r5,#0x24]
000ac4  f8d80020          LDR      r0,[r8,#0x20]  ; CapNCCR
000ac8  1c40              ADDS     r0,r0,#1
000aca  f8c80020          STR      r0,[r8,#0x20]  ; CapNCCR
;;;124      if    (CapNCCR<2)  cspd=0xFFFFFFF;		//  ,      .
000ace  2802              CMP      r0,#2
000ad0  d201              BCS      |L1.2774|
000ad2  460a              MOV      r2,r1
000ad4  e002              B        |L1.2780|
                  |L1.2774|
;;;125    						else EntryCNT=tmp-cspd;				//     ( ).
000ad6  eba90002          SUB      r0,r9,r2
000ada  8070              STRH     r0,[r6,#2]
                  |L1.2780|
;;;126     }
;;;127     if (sti&(TIM_SR_CC1IF|TIM_SR_UIF))		//       
000adc  07a0              LSLS     r0,r4,#30
000ade  d03b              BEQ      |L1.2904|
;;;128     { //******************************************	//  .   4  .
;;;129      if (Laser==1)	TLSR->ARR=(cspd/(qual*4));	//    .
000ae0  495f              LDR      r1,|L1.3168|
000ae2  f8980003          LDRB     r0,[r8,#3]  ; Laser
000ae6  3114              ADDS     r1,r1,#0x14
000ae8  2801              CMP      r0,#1
000aea  d107              BNE      |L1.2812|
000aec  f891002a          LDRB     r0,[r1,#0x2a]  ; lcnfbuf
000af0  f04f4380          MOV      r3,#0x40000000
000af4  0080              LSLS     r0,r0,#2
000af6  fbb2f0f0          UDIV     r0,r2,r0
000afa  8598              STRH     r0,[r3,#0x2c]
                  |L1.2812|
;;;130      //--------------------------------------------
;;;131      if (!cspd)	cspd=1;				//     0.
000afc  b902              CBNZ     r2,|L1.2816|
000afe  2201              MOVS     r2,#1
                  |L1.2816|
;;;132    	cspd=ResolX*cspd, cspd=cspd/4;
000b00  6908              LDR      r0,[r1,#0x10]  ; lcnfbuf
000b02  4350              MULS     r0,r2,r0
000b04  0880              LSRS     r0,r0,#2
;;;133    	cspd=FTCAP/1000*UnitX/cspd;		//  cspd    /.
000b06  6949              LDR      r1,[r1,#0x14]  ; lcnfbuf
000b08  f64262e0          MOV      r2,#0x2ee0
000b0c  4351              MULS     r1,r2,r1
000b0e  fbb1f9f0          UDIV     r9,r1,r0
;;;134      if (SpeedMotor) SpeedRegulator(cspd);		//  .
000b12  f8d80014          LDR      r0,[r8,#0x14]  ; SpeedMotor
000b16  b110              CBZ      r0,|L1.2846|
000b18  4648              MOV      r0,r9
000b1a  f7fffffe          BL       SpeedRegulator
                  |L1.2846|
;;;135    //***********************************************
;;;136      if (fDebug==DEB_MODE_PID)			//   .
000b1e  f8d80010          LDR      r0,[r8,#0x10]  ; fDebug
000b22  2801              CMP      r0,#1
000b24  d118              BNE      |L1.2904|
;;;137      {
;;;138    	cspd=cspd/8;				//   .
000b26  ea4f02d9          LSR      r2,r9,#3
;;;139       if (indxmem<SIZEBUFUNI/2-1)			//  .
000b2a  f8d8000c          LDR      r0,[r8,#0xc]  ; indxmem
000b2e  f24071ff          MOV      r1,#0x7ff
000b32  4288              CMP      r0,r1
000b34  d210              BCS      |L1.2904|
;;;140       {
;;;141        if (dir>0)
000b36  2f00              CMP      r7,#0
000b38  dd06              BLE      |L1.2888|
;;;142        {
;;;143    	lbuf0[indxmem+0]=(char)cspd;
000b3a  4949              LDR      r1,|L1.3168|
000b3c  318c              ADDS     r1,r1,#0x8c
000b3e  540a              STRB     r2,[r1,r0]
;;;144    	lbuf0[indxmem+1]=VoltageMotor;
000b40  4401              ADD      r1,r1,r0
000b42  7832              LDRB     r2,[r6,#0]  ; ldebinfo
000b44  704a              STRB     r2,[r1,#1]
000b46  e004              B        |L1.2898|
                  |L1.2888|
;;;145        }	
;;;146        else
;;;147        {
;;;148      	lbuf1[indxmem+0]=(char)cspd;
000b48  4948              LDR      r1,|L1.3180|
000b4a  540a              STRB     r2,[r1,r0]
;;;149    	lbuf1[indxmem+1]=VoltageMotor;
000b4c  4401              ADD      r1,r1,r0
000b4e  7832              LDRB     r2,[r6,#0]  ; ldebinfo
000b50  704a              STRB     r2,[r1,#1]
                  |L1.2898|
;;;150        }
;;;151    	indxmem+=2;
000b52  1c80              ADDS     r0,r0,#2
000b54  f8c8000c          STR      r0,[r8,#0xc]  ; indxmem
                  |L1.2904|
;;;152       }	
;;;153      }
;;;154     } //********************************************
;;;155    						if (sti&TIM_SR_CC1IF) ExitCNT=timptr->CNT;	//     ( ).
000b58  07a0              LSLS     r0,r4,#30
000b5a  d501              BPL      |L1.2912|
000b5c  8ca8              LDRH     r0,[r5,#0x24]
000b5e  80b0              STRH     r0,[r6,#4]
                  |L1.2912|
;;;156    }// ---------------------------------------------
000b60  e8bd9ff0          POP      {r4-r12,pc}
;;;157    void Init_TIM_ENC(){				//
                          ENDP

                  Init_TIM_ENC PROC
000b64  b510              PUSH     {r4,lr}
;;;158    // ----------------------------------------------
;;;159    TIM_TypeDef *timptr=TCAP;
000b66  4c42              LDR      r4,|L1.3184|
;;;160    	SET_PER_CAP				//  ,  .
000b68  4839              LDR      r0,|L1.3152|
000b6a  69c1              LDR      r1,[r0,#0x1c]
000b6c  f0410104          ORR      r1,r1,#4
000b70  61c1              STR      r1,[r0,#0x1c]
;;;161    	
;;;162    	portENC1->CRL &=~(PinCR(pinEnc1,GPIOCR));
000b72  483c              LDR      r0,|L1.3172|
000b74  3808              SUBS     r0,r0,#8
000b76  6801              LDR      r1,[r0,#0]
000b78  f0216170          BIC      r1,r1,#0xf000000
000b7c  6001              STR      r1,[r0,#0]
;;;163    	portENC1->CRL |= (PinCR(pinEnc1,p_i_p));//  1    .
000b7e  6801              LDR      r1,[r0,#0]
000b80  f0416100          ORR      r1,r1,#0x8000000
000b84  6001              STR      r1,[r0,#0]
;;;164    	portENC2->CRL &=~(PinCR(pinEnc2,GPIOCR));		
000b86  6801              LDR      r1,[r0,#0]
000b88  f021010f          BIC      r1,r1,#0xf
000b8c  6001              STR      r1,[r0,#0]
;;;165    	portENC2->CRL |= (PinCR(pinEnc2,p_i_p));//  2    .
000b8e  6801              LDR      r1,[r0,#0]
000b90  f0410108          ORR      r1,r1,#8
000b94  6001              STR      r1,[r0,#0]
;;;166    	
;;;167    	timptr->PSC  =(TCAP_CK/FTCAP-1);	// .
000b96  2005              MOVS     r0,#5
000b98  8520              STRH     r0,[r4,#0x28]
;;;168    	timptr->ARR  =(0xFFFF);			//   .
000b9a  f64f70ff          MOV      r0,#0xffff
000b9e  85a0              STRH     r0,[r4,#0x2c]
;;;169    	timptr->CCMR1 =  (TIM_CCMR1_CC2S_1|
000ba0  f2442041          MOV      r0,#0x4241
000ba4  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|
000ba6  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=  (
000ba8  201e              MOVS     r0,#0x1e
000baa  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.
000bac  f7fffffe          BL       NVIC_EnableIRQ
;;;186    	
;;;187    	timptr->CCER |= (TIM_CCER_CC4E|
000bb0  8c20              LDRH     r0,[r4,#0x20]
000bb2  f2431131          MOV      r1,#0x3131
000bb6  4308              ORRS     r0,r0,r1
000bb8  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;		//  .
000bba  8820              LDRH     r0,[r4,#0]
000bbc  f0400001          ORR      r0,r0,#1
000bc0  8020              STRH     r0,[r4,#0]
;;;194    }// ---------------------------------------------
000bc2  bd10              POP      {r4,pc}
;;;19     #endif
                          ENDP

                  RemapToRAM PROC
;;;29     }// ---------------------------------------------
;;;30     /* __inline */ void RemapToRAM(){		//
000bc4  4922              LDR      r1,|L1.3152|
;;;31     // ----------------------------------------------	
;;;32     	RCC->CIR = 0x00000000;			//  .
000bc6  2000              MOVS     r0,#0
000bc8  6088              STR      r0,[r1,#8]
;;;33     	SCB->VTOR = SRAM_BASE;			//   .
000bca  0448              LSLS     r0,r1,#17
000bcc  4929              LDR      r1,|L1.3188|
000bce  6008              STR      r0,[r1,#0]
;;;34     }// ---------------------------------------------
000bd0  4770              BX       lr
;;;35     
                          ENDP

                  InitCMD PROC
;;;11     };// ----------------------------------------------
;;;12     void InitCMD (){				//    .   "N"
000bd2  b500              PUSH     {lr}
;;;13     // ----------------------------------------------
;;;14     	ACK();					//   .
000bd4  f7fffffe          BL       ACK
;;;15     	SCB->AIRCR=(0x5FA0000+SCB_AIRCR_SYSRESETREQ);		//     .
000bd8  4926              LDR      r1,|L1.3188|
000bda  4827              LDR      r0,|L1.3192|
000bdc  1d09              ADDS     r1,r1,#4
000bde  6008              STR      r0,[r1,#0]
;;;16     }//______________________________________________
000be0  bd00              POP      {pc}
;;;17     void InitConf (){				//  "
                          ENDP

                  InitConf PROC
000be2  491f              LDR      r1,|L1.3168|
;;;18     // ----------------------------------------------
;;;19     	MaxPosEnc=(SIZEBUFUNI*UnitX/ResolX)/8;
000be4  3114              ADDS     r1,r1,#0x14
000be6  6948              LDR      r0,[r1,#0x14]  ; lcnfbuf
000be8  690a              LDR      r2,[r1,#0x10]  ; lcnfbuf
000bea  0300              LSLS     r0,r0,#12
000bec  fb90f0f2          SDIV     r0,r0,r2
000bf0  17c2              ASRS     r2,r0,#31
000bf2  eb007052          ADD      r0,r0,r2,LSR #29
000bf6  4a18              LDR      r2,|L1.3160|
000bf8  10c0              ASRS     r0,r0,#3
000bfa  6250              STR      r0,[r2,#0x24]  ; MaxPosEnc
;;;20      if (!cnlas) cnlas=1; else if (cnlas>4) cnlas=4;
000bfc  f891002b          LDRB     r0,[r1,#0x2b]  ; lcnfbuf
000c00  2800              CMP      r0,#0
000c02  d00e              BEQ      |L1.3106|
000c04  2804              CMP      r0,#4
000c06  d902              BLS      |L1.3086|
000c08  2004              MOVS     r0,#4
000c0a  f881002b          STRB     r0,[r1,#0x2b]
                  |L1.3086|
;;;21     	ExecFlash=TabExecFlash[cnlas-1];
000c0e  f891002b          LDRB     r0,[r1,#0x2b]  ; lcnfbuf
000c12  4911              LDR      r1,|L1.3160|
000c14  1e40              SUBS     r0,r0,#1
000c16  3158              ADDS     r1,r1,#0x58
000c18  f8510020          LDR      r0,[r1,r0,LSL #2]
000c1c  6450              STR      r0,[r2,#0x44]  ; ExecFlash
;;;22     	ACK();					//   .
000c1e  f7ffbffe          B.W      ACK
                  |L1.3106|
000c22  2001              MOVS     r0,#1                 ;20
000c24  f881002b          STRB     r0,[r1,#0x2b]         ;20
000c28  e7f1              B        |L1.3086|
;;;23     }//______________________________________________
;;;24     void SetAXS (char *ptr,uint cnt){		//    .   "a"
                          ENDP

                  SetAXS PROC
000c2a  b51c              PUSH     {r2-r4,lr}
;;;25     // ----------------------------------------------
;;;26     char chr;
;;;27     int pos;
;;;28     
;;;29     if	(sscanf(ptr,"%c%d", &chr, &pos)==2)
000c2c  466b              MOV      r3,sp
000c2e  aa01              ADD      r2,sp,#4
000c30  f2af31d0          ADR      r1,|L1.2148|
000c34  f7fffffe          BL       __0sscanf
000c38  2802              CMP      r0,#2
000c3a  d12a              BNE      |L1.3218|
;;;30      {
;;;31      if      (chr=='x') CurrLaserPos=CalcStepX(pos);
000c3c  f89d0004          LDRB     r0,[sp,#4]
000c40  4b07              LDR      r3,|L1.3168|
000c42  2878              CMP      r0,#0x78
000c44  d01a              BEQ      |L1.3196|
;;;32      else if (chr=='y') CurrStepPos =CalcStepY(pos);
000c46  2879              CMP      r0,#0x79
000c48  d01d              BEQ      |L1.3206|
000c4a  e020              B        |L1.3214|
                  |L1.3148|
                          DCD      0x40010800
                  |L1.3152|
                          DCD      0x40021000
                  |L1.3156|
                          DCD      0x40010000
                  |L1.3160|
                          DCD      ||.data||
                  |L1.3164|
000c5c  256400            DCB      "%d",0
000c5f  00                DCB      0
                  |L1.3168|
                          DCD      ||.bss||
                  |L1.3172|
                          DCD      0x40010c08
                  |L1.3176|
                          DCD      ||.constdata||+0x3d8
                  |L1.3180|
                          DCD      ||.bss||+0x108c
                  |L1.3184|
                          DCD      0x40000800
                  |L1.3188|
                          DCD      0xe000ed08
                  |L1.3192|
                          DCD      0x05fa0004
                  |L1.3196|
000c7c  9800              LDR      r0,[sp,#0]            ;31
000c7e  f7fffffe          BL       CalcStepX
000c82  6018              STR      r0,[r3,#0]            ;31  ; lbufinfo
000c84  e003              B        |L1.3214|
                  |L1.3206|
000c86  9800              LDR      r0,[sp,#0]
000c88  f7fffffe          BL       CalcStepY
000c8c  6058              STR      r0,[r3,#4]  ; lbufinfo
                  |L1.3214|
;;;33     	ACK();					//   .
000c8e  f7fffffe          BL       ACK
                  |L1.3218|
;;;34      }	
;;;35     }//______________________________________________
000c92  bd1c              POP      {r2-r4,pc}
;;;36     void ExecCMD(char *ptr, uint cnt){		//    .	  "G2012345"
                          ENDP

                  ExecCMD PROC
000c94  b508              PUSH     {r3,lr}
;;;37     // ----------------------------------------------
;;;38     uint eaddr;	
;;;39     
;;;40      if	(sscanf(ptr,"%x", &eaddr)==1)
000c96  466a              MOV      r2,sp
000c98  a198              ADR      r1,|L1.3836|
000c9a  f7fffffe          BL       __0sscanf
000c9e  2801              CMP      r0,#1
000ca0  d104              BNE      |L1.3244|
;;;41      {
;;;42     	ACK();					//   .
000ca2  f7fffffe          BL       ACK
;;;43     	Execute(eaddr);				//  .
000ca6  9800              LDR      r0,[sp,#0]
000ca8  f7fffffe          BL       Execute
                  |L1.3244|
;;;44      }	
;;;45     }//______________________________________________
000cac  bd08              POP      {r3,pc}
;;;46     void ReadState(){				//    .	  "I"
                          ENDP

                  ReadState PROC
000cae  4894              LDR      r0,|L1.3840|
;;;47     // ----------------------------------------------
;;;48     	SER_PutChar(State);			//    .
000cb0  7b00              LDRB     r0,[r0,#0xc]  ; lbufinfo
000cb2  f7ffbffe          B.W      SER_PutChar
;;;49     }//______________________________________________
;;;50     void ReadInfo(){				//    -.   "i"
                          ENDP

                  ReadInfo PROC
000cb6  b51c              PUSH     {r2-r4,lr}
;;;51     // ----------------------------------------------
;;;52     	printf(" -b0 0x%p -sz %d -pi 0x%p -si %d -vr %d",
000cb8  201b              MOVS     r0,#0x1b
000cba  2114              MOVS     r1,#0x14
000cbc  e9cd1000          STRD     r1,r0,[sp,#0]
000cc0  4b8f              LDR      r3,|L1.3840|
000cc2  f44f5280          MOV      r2,#0x1000
000cc6  f103018c          ADD      r1,r3,#0x8c
000cca  a08e              ADR      r0,|L1.3844|
000ccc  f7fffffe          BL       __2printf
;;;53     	lbuf0,SIZEBUFUNI,&lbufinfo,sizeof lbufinfo,_VERSION);	//  .
;;;54     }//______________________________________________
000cd0  bd1c              POP      {r2-r4,pc}
;;;55     void ReadCMD(char *ptr,uint cnt){		//    .	  "w012345,4#"
                          ENDP

                  ReadCMD PROC
000cd2  b51c              PUSH     {r2-r4,lr}
;;;56     // ----------------------------------------------
;;;57     uint *raddr; uint rdata;
;;;58      if	(sscanf(ptr,"%p,%x", &raddr, &rdata)==2)
000cd4  466b              MOV      r3,sp
000cd6  aa01              ADD      r2,sp,#4
000cd8  a194              ADR      r1,|L1.3884|
000cda  f7fffffe          BL       __0sscanf
000cde  2802              CMP      r0,#2
000ce0  d104              BNE      |L1.3308|
;;;59      {
;;;60     	printf("0x%x",(raddr[0]));		//  .
000ce2  9801              LDR      r0,[sp,#4]
000ce4  6801              LDR      r1,[r0,#0]
000ce6  a093              ADR      r0,|L1.3892|
000ce8  f7fffffe          BL       __2printf
                  |L1.3308|
;;;61      }	
;;;62     }//______________________________________________
000cec  bd1c              POP      {r2-r4,pc}
;;;63     void WriteCMD(char *ptr,uint cnt){		//    .	  ""W012345,8765#"
                          ENDP

                  WriteCMD PROC
000cee  b51c              PUSH     {r2-r4,lr}
;;;64     // ----------------------------------------------
;;;65     uint wdata, *waddr;
;;;66      if	(sscanf(ptr,"%p,%x", &waddr, &wdata)==2)
000cf0  ab01              ADD      r3,sp,#4
000cf2  466a              MOV      r2,sp
000cf4  a18d              ADR      r1,|L1.3884|
000cf6  f7fffffe          BL       __0sscanf
000cfa  2802              CMP      r0,#2
000cfc  d104              BNE      |L1.3336|
;;;67      {
;;;68     	waddr[0]=wdata;				//    .
000cfe  e9dd1000          LDRD     r1,r0,[sp,#0]
000d02  6008              STR      r0,[r1,#0]
;;;69     	ACK();					//   .
000d04  f7fffffe          BL       ACK
                  |L1.3336|
;;;70      }	
;;;71     }//______________________________________________
000d08  bd1c              POP      {r2-r4,pc}
;;;72     void SendCMD(char *ptr,uint cnt){		//    .	  "S.ptr.,.len.,......"
                          ENDP

                  SendCMD PROC
000d0a  b51c              PUSH     {r2-r4,lr}
;;;73     // ----------------------------------------------
;;;74     uint len;
;;;75     puchar pbuf;
;;;76      if	(sscanf(ptr,"%p,%d", &pbuf, &len)==2)	//  ,  .
000d0c  ab01              ADD      r3,sp,#4
000d0e  466a              MOV      r2,sp
000d10  a18a              ADR      r1,|L1.3900|
000d12  f7fffffe          BL       __0sscanf
000d16  2802              CMP      r0,#2
000d18  d10f              BNE      |L1.3386|
;;;77      {
;;;78       if ((pbuf>=(puchar)SRAM_BASE)&&(len<=(uint)MAX_LEN_READ))
000d1a  9800              LDR      r0,[sp,#0]
000d1c  f1b05f00          CMP      r0,#0x20000000
000d20  d30b              BCC      |L1.3386|
000d22  9801              LDR      r0,[sp,#4]
000d24  f5b03f80          CMP      r0,#0x10000
000d28  d807              BHI      |L1.3386|
;;;79       {
;;;80     	ACK();					//   .
000d2a  f7fffffe          BL       ACK
;;;81     	READ_FROM_COM(pbuf,len);		// 
000d2e  e9dd0100          LDRD     r0,r1,[sp,#0]
000d32  f7fffffe          BL       READ_FROM_COM
;;;82     	ACK();					//   .
000d36  f7fffffe          BL       ACK
                  |L1.3386|
;;;83       }
;;;84      }
;;;85     }//______________________________________________
000d3a  bd1c              POP      {r2-r4,pc}
;;;86     void ReceCMD(char *ptr,uint cnt){		//    .	  ""s0x....,l.."
                          ENDP

                  ReceCMD PROC
000d3c  b51c              PUSH     {r2-r4,lr}
;;;87     // ----------------------------------------------
;;;88     char *rptr; uint rcnt;
;;;89      if	(sscanf(ptr,"%p,%d", &rptr, &rcnt)==2)
000d3e  466b              MOV      r3,sp
000d40  aa01              ADD      r2,sp,#4
000d42  a17e              ADR      r1,|L1.3900|
000d44  f7fffffe          BL       __0sscanf
000d48  2802              CMP      r0,#2
000d4a  d103              BNE      |L1.3412|
;;;90      {
;;;91     	WRITE_TO_COM(rptr,rcnt);
000d4c  e9dd1000          LDRD     r1,r0,[sp,#0]
000d50  f7fffffe          BL       WRITE_TO_COM
                  |L1.3412|
;;;92      }	
;;;93     }//______________________________________________
000d54  bd1c              POP      {r2-r4,pc}
;;;94     void DebugCMD (char *ptr,uint cnt){		//  .	  ""d...."
                          ENDP

                  DebugCMD PROC
000d56  b510              PUSH     {r4,lr}
;;;95     // ----------------------------------------------
;;;96     	sscanf(ptr,"%d",&fDebug);		//     .
000d58  4a7a              LDR      r2,|L1.3908|
000d5a  f2af1100          ADR      r1,|L1.3164|
000d5e  f7fffffe          BL       __0sscanf
;;;97     	ACK();					//   .
000d62  e8bd4010          POP      {r4,lr}
000d66  f7ffbffe          B.W      ACK
;;;98     }// ---------------------------------------------
;;;99     void SetNumBuff(char *ptr,uint cnt){		//   .	  ""b."
                          ENDP

                  SetNumBuff PROC
000d6a  b508              PUSH     {r3,lr}
;;;100    //-----------------------------------------------
;;;101    uint val;
;;;102     if (sscanf(ptr,"%d",&val)==1)
000d6c  466a              MOV      r2,sp
000d6e  f2af1114          ADR      r1,|L1.3164|
000d72  f7fffffe          BL       __0sscanf
000d76  2801              CMP      r0,#1
000d78  d10e              BNE      |L1.3480|
;;;103     {
;;;104     if (val==0)		ActBuffer=lbuf0;
000d7a  4972              LDR      r1,|L1.3908|
000d7c  9800              LDR      r0,[sp,#0]
000d7e  3910              SUBS     r1,r1,#0x10
000d80  b110              CBZ      r0,|L1.3464|
;;;105     else if (val==1)	ActBuffer=lbuf1;
000d82  2801              CMP      r0,#1
000d84  d004              BEQ      |L1.3472|
000d86  e005              B        |L1.3476|
                  |L1.3464|
000d88  485d              LDR      r0,|L1.3840|
000d8a  308c              ADDS     r0,r0,#0x8c           ;104
000d8c  62c8              STR      r0,[r1,#0x2c]         ;104  ; ActBuffer
000d8e  e001              B        |L1.3476|
                  |L1.3472|
000d90  486d              LDR      r0,|L1.3912|
000d92  62c8              STR      r0,[r1,#0x2c]  ; ActBuffer
                  |L1.3476|
;;;106    	ACK();					//   .
000d94  f7fffffe          BL       ACK
                  |L1.3480|
;;;107     }
;;;108    }
000d98  bd08              POP      {r3,pc}
;;;109    void SetPtrBuff(char *ptr,uint cnt){		//   .   ""B.ptr.."
                          ENDP

                  SetPtrBuff PROC
000d9a  b510              PUSH     {r4,lr}
;;;110    //-----------------------------------------------
;;;111     if (sscanf(ptr,"%p",&ActBuffer)==1) ACK();
000d9c  4a69              LDR      r2,|L1.3908|
000d9e  a16b              ADR      r1,|L1.3916|
000da0  321c              ADDS     r2,r2,#0x1c
000da2  f7fffffe          BL       __0sscanf
000da6  2801              CMP      r0,#1
000da8  d103              BNE      |L1.3506|
000daa  e8bd4010          POP      {r4,lr}
000dae  f7ffbffe          B.W      ACK
                  |L1.3506|
;;;112    }
000db2  bd10              POP      {r4,pc}
;;;113    void CHECK_CMD(char *ptr,uint cnt){		//    .
                          ENDP

                  CHECK_CMD PROC
000db4  f8102b01          LDRB     r2,[r0],#1
;;;114    // ----------------------------------------------
;;;115    	char chr=ptr[0];
;;;116    	ptr++; cnt--; ptr[cnt]=0;
000db8  1e49              SUBS     r1,r1,#1
000dba  2300              MOVS     r3,#0
000dbc  5443              STRB     r3,[r0,r1]
;;;117    	
;;;118         if (chr=='I') ReadState();			//   .
000dbe  2a49              CMP      r2,#0x49
000dc0  d020              BEQ      |L1.3588|
;;;119    else if (chr=='m') MoveCMD(ptr,cnt);		//   .
000dc2  2a6d              CMP      r2,#0x6d
000dc4  d01f              BEQ      |L1.3590|
;;;120    else if (chr=='l') LaserCMD(ptr,cnt);		//   .
000dc6  2a6c              CMP      r2,#0x6c
000dc8  d01e              BEQ      |L1.3592|
;;;121    else if (chr=='S') SendCMD(ptr,cnt);		//   .
000dca  2a53              CMP      r2,#0x53
000dcc  d01d              BEQ      |L1.3594|
;;;122    else if (chr=='s') ReceCMD(ptr,cnt);		//   .
000dce  2a73              CMP      r2,#0x73
000dd0  d01c              BEQ      |L1.3596|
;;;123    else if (chr=='v') SetSpeed(ptr,cnt);		//    .
000dd2  2a76              CMP      r2,#0x76
000dd4  d01b              BEQ      |L1.3598|
;;;124    else if (chr=='b') SetNumBuff(ptr,cnt);		//    .
000dd6  2a62              CMP      r2,#0x62
000dd8  d01a              BEQ      |L1.3600|
;;;125    else if (chr=='B') SetPtrBuff(ptr,cnt);		//    .
000dda  2a42              CMP      r2,#0x42
000ddc  d019              BEQ      |L1.3602|
;;;126    
;;;127    else if (chr=='w') ReadCMD(ptr,cnt);		//  .
000dde  2a77              CMP      r2,#0x77
000de0  d018              BEQ      |L1.3604|
;;;128    else if (chr=='W') WriteCMD(ptr,cnt);		//  .
000de2  2a57              CMP      r2,#0x57
000de4  d017              BEQ      |L1.3606|
;;;129    else if (chr=='G') ExecCMD(ptr,cnt);		//  .
000de6  2a47              CMP      r2,#0x47
000de8  d016              BEQ      |L1.3608|
;;;130    else if (chr=='a') SetAXS(ptr,cnt);		//  .
000dea  2a61              CMP      r2,#0x61
000dec  d015              BEQ      |L1.3610|
;;;131    else if (chr=='c') ACK();			//  .
000dee  2a63              CMP      r2,#0x63
000df0  d014              BEQ      |L1.3612|
;;;132    else if (chr=='i') ReadInfo();			//   .
000df2  2a69              CMP      r2,#0x69
000df4  d014              BEQ      |L1.3616|
;;;133    else if (chr=='N') InitCMD();			//  .
000df6  2a4e              CMP      r2,#0x4e
000df8  d013              BEQ      |L1.3618|
;;;134    else if (chr=='n') InitConf();			// .
000dfa  2a6e              CMP      r2,#0x6e
000dfc  d012              BEQ      |L1.3620|
;;;135    else if (chr=='d') DebugCMD(ptr,cnt);		//  .
000dfe  2a64              CMP      r2,#0x64
000e00  d111              BNE      |L1.3622|
000e02  e7fe              B        DebugCMD
                  |L1.3588|
000e04  e7fe              B        ReadState
                  |L1.3590|
000e06  e7fe              B        MoveCMD
                  |L1.3592|
000e08  e7fe              B        LaserCMD
                  |L1.3594|
000e0a  e7fe              B        SendCMD
                  |L1.3596|
000e0c  e7fe              B        ReceCMD
                  |L1.3598|
000e0e  e7fe              B        SetSpeed
                  |L1.3600|
000e10  e7fe              B        SetNumBuff
                  |L1.3602|
000e12  e7fe              B        SetPtrBuff
                  |L1.3604|
000e14  e7fe              B        ReadCMD
                  |L1.3606|
000e16  e7fe              B        WriteCMD
                  |L1.3608|
000e18  e7fe              B        ExecCMD
                  |L1.3610|
000e1a  e7fe              B        SetAXS
                  |L1.3612|
000e1c  f7ffbffe          B.W      ACK
                  |L1.3616|
000e20  e7fe              B        ReadInfo
                  |L1.3618|
000e22  e7fe              B        InitCMD
                  |L1.3620|
000e24  e7fe              B        InitConf
                  |L1.3622|
;;;136    }//______________________________________________
000e26  4770              BX       lr
;;;37     
                          ENDP

                  CHECK_INPUT PROC
;;;61     
;;;62     uint CHECK_INPUT(char *ptr, uint i){		//      .
000e28  b570              PUSH     {r4-r6,lr}
000e2a  4604              MOV      r4,r0
000e2c  4d48              LDR      r5,|L1.3920|
000e2e  e011              B        |L1.3668|
                  |L1.3632|
000e30  8828              LDRH     r0,[r5,#0]
000e32  b2c0              UXTB     r0,r0
;;;63     // ----------------------------------------------
;;;64     //	ptr	   .
;;;65     //	i	   .
;;;66     char chr;					//  .
;;;67     
;;;68      while	(SER_CheckCharRx())
;;;69      {	chr=SER_ReadChar();
;;;70       if	((i<SIZEBUFRX)&&(chr>' '))
000e34  291f              CMP      r1,#0x1f
000e36  d204              BCS      |L1.3650|
000e38  2820              CMP      r0,#0x20
000e3a  d902              BLS      |L1.3650|
;;;71       {
;;;72     	ptr[i]=chr; i++;
000e3c  5460              STRB     r0,[r4,r1]
000e3e  1c49              ADDS     r1,r1,#1
000e40  e008              B        |L1.3668|
                  |L1.3650|
;;;73       }
;;;74       else if (((chr==13)||(chr==10))&&(i>0))
000e42  280d              CMP      r0,#0xd
000e44  d001              BEQ      |L1.3658|
000e46  280a              CMP      r0,#0xa
000e48  d104              BNE      |L1.3668|
                  |L1.3658|
000e4a  b119              CBZ      r1,|L1.3668|
;;;75       {
;;;76     	CHECK_CMD(ptr,i); i=0;
000e4c  4620              MOV      r0,r4
000e4e  f7fffffe          BL       CHECK_CMD
000e52  2100              MOVS     r1,#0
                  |L1.3668|
000e54  f7fffffe          BL       SER_CheckCharRx
000e58  2800              CMP      r0,#0                 ;68
000e5a  d1e9              BNE      |L1.3632|
;;;77       }
;;;78      }	 
;;;79      	return i;
000e5c  4608              MOV      r0,r1
;;;80     }//______________________________________________
000e5e  e4e6              B        |L1.2094|
;;;81     int main(){					//
                          ENDP

                  main PROC
000e60  f7fffffe          BL       RemapToRAM
;;;82     uint i;
;;;83     	RemapToRAM();				//     RAM.
;;;84     
;;;85     	//     .
;;;86     
;;;87     	memcpy (&lcnfbuf,&tab_cnf, sizeof (CONFIG));//   .
000e64  4826              LDR      r0,|L1.3840|
000e66  2240              MOVS     r2,#0x40
000e68  493a              LDR      r1,|L1.3924|
000e6a  3014              ADDS     r0,r0,#0x14
000e6c  f7fffffe          BL       __aeabi_memcpy4
;;;88     	lbufinfo.pcnf=&lcnfbuf;
000e70  4823              LDR      r0,|L1.3840|
000e72  4923              LDR      r1,|L1.3840|
000e74  3014              ADDS     r0,r0,#0x14
000e76  6108              STR      r0,[r1,#0x10]  ; lbufinfo
;;;89     	VoltageMotor=MAX_PWM;			//    .
000e78  20ff              MOVS     r0,#0xff
000e7a  3154              ADDS     r1,r1,#0x54
000e7c  7008              STRB     r0,[r1,#0]
;;;90     	ExecFlash=FlashLaser_1p;
000e7e  f2af61c7          ADR      r1,FlashLaser_1p + 1
000e82  4830              LDR      r0,|L1.3908|
000e84  3810              SUBS     r0,r0,#0x10
000e86  6441              STR      r1,[r0,#0x44]  ; ExecFlash
;;;91     	ActBuffer=lbuf0;			//    .
000e88  491d              LDR      r1,|L1.3840|
000e8a  318c              ADDS     r1,r1,#0x8c
000e8c  62c1              STR      r1,[r0,#0x2c]  ; ActBuffer
;;;92     
;;;93     	
;;;94     	RCC->APB2ENR|=	RCC_APB2ENR_AFIOEN|	//   .
000e8e  4832              LDR      r0,|L1.3928|
000e90  6981              LDR      r1,[r0,#0x18]
000e92  f041010d          ORR      r1,r1,#0xd
000e96  6181              STR      r1,[r0,#0x18]
;;;95     			RCC_APB2ENR_IOPAEN|	//   A.
;;;96     			RCC_APB2ENR_IOPBEN;     //   B.
;;;97     	SER_Init1();				//    1
000e98  f7fffffe          BL       SER_Init1
;;;98     	Init_TIM_PWM();				//    .
000e9c  f7fffffe          BL       Init_TIM_PWM
;;;99     	MotorBreak();				// -.
000ea0  f7fffffe          BL       MotorBreak
;;;100    	Init_TIM_TOT();				//   .
000ea4  f7fffffe          BL       Init_TIM_TOT
;;;101    	Init_TIM_ENC();				//  .
000ea8  f7fffffe          BL       Init_TIM_ENC
;;;102    	InitPinsSteps();			//    .
000eac  f7fffffe          BL       InitPinsSteps
;;;103    	InitTimerSteps();			//   .
000eb0  f7fffffe          BL       InitTimerSteps
;;;104    	InitLaserWRK();				//   .
000eb4  f7fffffe          BL       InitLaserWRK
;;;105    	LaserCTRL(0);				//  .
000eb8  2000              MOVS     r0,#0
000eba  f7fffffe          BL       LaserCTRL
000ebe  4827              LDR      r0,|L1.3932|
000ec0  6801              LDR      r1,[r0,#0]
000ec2  f421417f          BIC      r1,r1,#0xff00
000ec6  6001              STR      r1,[r0,#0]
000ec8  6801              LDR      r1,[r0,#0]
000eca  f4415108          ORR      r1,r1,#0x2200
000ece  6001              STR      r1,[r0,#0]
;;;106    	LEDS_Init();				//    .
;;;107    	
;;;108    	printf ("\r\nExposer RAM ready\r\n>");
000ed0  a023              ADR      r0,|L1.3936|
000ed2  f7fffffe          BL       __2printf
;;;109    	i=0;
000ed6  2100              MOVS     r1,#0
                  |L1.3800|
;;;110     while(1)
;;;111     {
;;;112    	i=CHECK_INPUT(RxBuf,i);			//   .
000ed8  4809              LDR      r0,|L1.3840|
000eda  306c              ADDS     r0,r0,#0x6c
000edc  f7fffffe          BL       CHECK_INPUT
000ee0  4601              MOV      r1,r0
000ee2  e7f9              B        |L1.3800|
;;;113     }
;;;114    }// ---------------------------------------------
                          ENDP

                  NVIC_EnableIRQ PROC
;;;1307    */
;;;1308   __STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
000ee4  f000021f          AND      r2,r0,#0x1f
;;;1309   {
;;;1310     NVIC->ISER[((uint32_t)(IRQn) >> 5)] = (1 << ((uint32_t)(IRQn) & 0x1F)); /* enable interrupt */
000ee8  2101              MOVS     r1,#1
000eea  4091              LSLS     r1,r1,r2
000eec  0940              LSRS     r0,r0,#5
000eee  f04f22e0          MOV      r2,#0xe000e000
000ef2  eb020080          ADD      r0,r2,r0,LSL #2
000ef6  f8c01100          STR      r1,[r0,#0x100]
;;;1311   }
000efa  4770              BX       lr
;;;1312   
                          ENDP

                  |L1.3836|
000efc  257800            DCB      "%x",0
000eff  00                DCB      0
                  |L1.3840|
                          DCD      ||.bss||
                  |L1.3844|
000f04  202d6230          DCB      " -b0 0x%p -sz %d -pi 0x%p -si %d -vr %d",0
000f08  20307825
000f0c  70202d73
000f10  7a202564
000f14  202d7069
000f18  20307825
000f1c  70202d73
000f20  69202564
000f24  202d7672
000f28  20256400
                  |L1.3884|
000f2c  25702c25          DCB      "%p,%x",0
000f30  7800    
000f32  00                DCB      0
000f33  00                DCB      0
                  |L1.3892|
000f34  30782578          DCB      "0x%x",0
000f38  00      
000f39  00                DCB      0
000f3a  00                DCB      0
000f3b  00                DCB      0
                  |L1.3900|
000f3c  25702c25          DCB      "%p,%d",0
000f40  6400    
000f42  00                DCB      0
000f43  00                DCB      0
                  |L1.3908|
                          DCD      ||.data||+0x10
                  |L1.3912|
                          DCD      ||.bss||+0x108c
                  |L1.3916|
000f4c  257000            DCB      "%p",0
000f4f  00                DCB      0
                  |L1.3920|
                          DCD      0x40013804
                  |L1.3924|
                          DCD      ||.constdata||+0x418
                  |L1.3928|
                          DCD      0x40021000
                  |L1.3932|
                          DCD      0x40010c04
                  |L1.3936|
000f60  0d0a4578          DCB      "\r\nExposer RAM ready\r\n>",0
000f64  706f7365
000f68  72205241
000f6c  4d207265
000f70  6164790d
000f74  0a3e00  
000f77  00                DCB      0

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

                  lbufinfo
                          %        20
                  lcnfbuf
                          %        64
                  ldebinfo
                          %        24
                  RxBuf
                          %        32
                  lbuf0
                          %        4096
                  lbuf1
                          %        4096

                          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      0x000270ff
                          DCD      0x0001e413
                          DCD      0x0001966d
                          DCD      0x00016475
                          DCD      0x0001410e
                          DCD      0x00012630
                          DCD      0x0001110d
                          DCD      0x0000ffe9
                          DCD      0x0000f169
                          DCD      0x0000e536
                          DCD      0x0000da87
                          DCD      0x0000d16a
                          DCD      0x0000c92d
                          DCD      0x0000c1d3
                          DCD      0x0000bb3f
                          DCD      0x0000b554
                          DCD      0x0000afe3
                          DCD      0x0000aaf7
                          DCD      0x0000a66a
                          DCD      0x0000a231
                          DCD      0x00009e44
                          DCD      0x00009a9d
                          DCD      0x00009734
                          DCD      0x00009405
                          DCD      0x000090f8
                          DCD      0x00008e2f
                          DCD      0x00008b81
                          DCD      0x000088ec
                          DCD      0x00008690
                          DCD      0x00008449
                          DCD      0x00008224
                          DCD      0x00008011
                          DCD      0x00007e1d
                          DCD      0x00007c39
                          DCD      0x00007a70
                          DCD      0x000078b4
                          DCD      0x00007704
                          DCD      0x0000757a
                          DCD      0x000073ed
                          DCD      0x00007277
                          DCD      0x00007109
                          DCD      0x00006fb1
                          DCD      0x00006e60
                          DCD      0x00006d17
                          DCD      0x00006be0
                          DCD      0x00006ab1
                          DCD      0x00006987
                          DCD      0x0000686e
                          DCD      0x0000675b
                          DCD      0x0000664e
                          DCD      0x0000654f
                          DCD      0x0000644c
                          DCD      0x00006357
                          DCD      0x00006270
                          DCD      0x00006184
                          DCD      0x000060a5
                          DCD      0x00005fca
                          DCD      0x00005ef2
                          DCD      0x00005e1f
                          DCD      0x00005d57
                          DCD      0x00005c92
                          DCD      0x00005bd1
                          DCD      0x00005b13
                          DCD      0x00005a5f
                          DCD      0x000059a6
                          DCD      0x000058f8
                          DCD      0x0000584c
                          DCD      0x000057a3
                          DCD      0x00005704
                          DCD      0x00005660
                          DCD      0x000055c4
                          DCD      0x0000552b
                          DCD      0x00005495
                          DCD      0x00005400
                          DCD      0x0000536d
                          DCD      0x000052dc
                          DCD      0x00005254
                          DCD      0x000051cd
                          DCD      0x00005148
                          DCD      0x000050c4
                          DCD      0x00005042
                          DCD      0x00004fc2
                          DCD      0x00004f49
                          DCD      0x00004ecc
                          DCD      0x00004e56
                          DCD      0x00004de2
                          DCD      0x00004d6e
                          DCD      0x00004cfc
                          DCD      0x00004c8c
                          DCD      0x00004c22
                          DCD      0x00004bb3
                          DCD      0x00004b4c
                          DCD      0x00004ae0
                          DCD      0x00004a7a
                          DCD      0x00004a16
                          DCD      0x000049b2
                          DCD      0x00004950
                          DCD      0x000048ef
                          DCD      0x00004893
                          DCD      0x00004834
                          DCD      0x000047d5
                          DCD      0x0000477c
                          DCD      0x00004725
                          DCD      0x000046cd
                          DCD      0x00004673
                          DCD      0x0000461d
                          DCD      0x000045c9
                          DCD      0x00004579
                          DCD      0x00004526
                          DCD      0x000044d4
                          DCD      0x00004486
                          DCD      0x00004436
                          DCD      0x000043e5
                          DCD      0x0000439a
                          DCD      0x00004350
                          DCD      0x00004302
                          DCD      0x000042b8
                          DCD      0x00004270
                          DCD      0x00004228
                          DCD      0x000041e0
                          DCD      0x0000419d
                          DCD      0x00004157
                          DCD      0x00004111
                          DCD      0x000040d0
                          DCD      0x0000408c
                          DCD      0x00004048
                          DCD      0x00004008
                          DCD      0x00003fc9
                          DCD      0x00003f8a
                          DCD      0x00003f48
                          DCD      0x00003f0a
                          DCD      0x00003ecd
                          DCD      0x00003e90
                          DCD      0x00003e54
                          DCD      0x00003e1c
                          DCD      0x00003de0
                          DCD      0x00003da5
                          DCD      0x00003d6a
                          DCD      0x00003d34
                          DCD      0x00003cfa
                          DCD      0x00003cc4
                          DCD      0x00003c8b
                          DCD      0x00003c56
                          DCD      0x00003c21
                          DCD      0x00003be9
                          DCD      0x00003bb5
                          DCD      0x00003b81
                          DCD      0x00003b4e
                          DCD      0x00003b1b
                          DCD      0x00003ae8
                          DCD      0x00003ab6
                          DCD      0x00003a84
                          DCD      0x00003a52
                          DCD      0x00003a21
                          DCD      0x000039f3
                          DCD      0x000039c2
                          DCD      0x00003991
                          DCD      0x00003964
                          DCD      0x00003935
                          DCD      0x00003908
                          DCD      0x000038d9
                          DCD      0x000038ad
                          DCD      0x0000387e
                          DCD      0x00003853
                          DCD      0x00003827
                          DCD      0x000037fd
                          DCD      0x000037d2
                          DCD      0x000037a5
                          DCD      0x0000377a
                          DCD      0x00003751
                          DCD      0x00003727
                          DCD      0x000036fd
                          DCD      0x000036d4
                          DCD      0x000036ab
                          DCD      0x00003685
                          DCD      0x0000365d
                          DCD      0x00003635
                          DCD      0x0000360d
                          DCD      0x000035e8
                          DCD      0x000035c0
                          DCD      0x00003599
                          DCD      0x00003574
                          DCD      0x0000354d
                          DCD      0x00003529
                          DCD      0x00003503
                          DCD      0x000034df
                          DCD      0x000034bb
                          DCD      0x00003495
                          DCD      0x00003472
                          DCD      0x0000344f
                          DCD      0x0000342d
                          DCD      0x0000340a
                          DCD      0x000033e8
                          DCD      0x000033c5
                          DCD      0x000033a3
                          DCD      0x00003381
                          DCD      0x00003360
                          DCD      0x0000333e
                          DCD      0x0000331d
                          DCD      0x000032fb
                          DCD      0x000032da
                          DCD      0x000032ba
                          DCD      0x0000329b
                          DCD      0x0000327b
                          DCD      0x0000325a
                          DCD      0x0000323c
                          DCD      0x0000321c
                          DCD      0x000031ff
                          DCD      0x000031df
                          DCD      0x000031bf
                          DCD      0x000031a2
                          DCD      0x00003183
                          DCD      0x00003166
                          DCD      0x00003147
                          DCD      0x0000312a
                          DCD      0x0000310d
                          DCD      0x000030f1
                          DCD      0x000030d3
                          DCD      0x000030b6
                          DCD      0x0000309a
                          DCD      0x0000307e
                          DCD      0x00003063
                          DCD      0x00003047
                          DCD      0x0000302b
                          DCD      0x0000300e
                          DCD      0x00002ff3
                          DCD      0x00002fd8
                          DCD      0x00002fbd
                          DCD      0x00002fa2
                          DCD      0x00002f87
                          DCD      0x00002f6e
                          DCD      0x00002f54
                          DCD      0x00002f39
                          DCD      0x00002f1f
                          DCD      0x00002f05
                          DCD      0x00002eeb
                          DCD      0x00002ed3
                  tab_enc
0003d8  00000000          DCB      0x00,0x00,0x00,0x00
0003dc  0101ffff          DCB      0x01,0x01,0xff,0xff
0003e0  ffff0101          DCB      0xff,0xff,0x01,0x01
0003e4  00000000          DCB      0x00,0x00,0x00,0x00
0003e8  ff01ff01          DCB      0xff,0x01,0xff,0x01
0003ec  00000000          DCB      0x00,0x00,0x00,0x00
0003f0  00000000          DCB      0x00,0x00,0x00,0x00
0003f4  00000000          DCB      0x00,0x00,0x00,0x00
0003f8  01ff01ff          DCB      0x01,0xff,0x01,0xff
0003fc  00000000          DCB      0x00,0x00,0x00,0x00
000400  00000000          DCB      0x00,0x00,0x00,0x00
000404  00000000          DCB      0x00,0x00,0x00,0x00
000408  00000000          DCB      0x00,0x00,0x00,0x00
00040c  00000000          DCB      0x00,0x00,0x00,0x00
000410  00000000          DCB      0x00,0x00,0x00,0x00
000414  00000000          DCB      0x00,0x00,0x00,0x00
                  tab_cnf
                          DCD      0x0000020d
                          DCD      0x00000007
                          DCD      0x00000001
                          DCD      0x000003e8
                          DCD      0x00000258
                          DCD      0x00006338
                          DCD      0x00000190
                          DCD      0x000003e8
                          DCD      0x00000190
                          DCD      0x00000bb8
000440  6cff0101          DCB      0x6c,0xff,0x01,0x01
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000

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

                  DirX
000000  00                DCB      0x00
                  OffsPix
000001  00                DCB      0x00
                  CntPix
000002  00                DCB      0x00
                  Laser
000003  00                DCB      0x00
                  DirY
000004  00                DCB      0x00
                  fStep
000005  000000            DCB      0x00,0x00,0x00
                  SystemCoreClock
                          DCD      0x044aa200
                  indxmem
                          DCD      0x00000000
                  fDebug
                          DCD      0x00000000
                  SpeedMotor
                          DCD      0x00000000
                  i_value
                          DCD      0x00000000
                  d_value
                          DCD      0x00000000
                  CapNCCR
                          DCD      0x00000000
                  MaxPosEnc
                          DCD      0x00000000
                  LaserPos
                          DCD      0x00000000
                  ActBuffer
                          DCD      0x00000000
                  AccelPos
                          DCD      0x00000000
                  rSpeedY
                          DCD      0x00000000
                  cSpeedY
                          DCD      0x00000000
                  StepTOT
                          DCD      0x00000000
                  StepCNT
                          DCD      0x00000000
                  ExecFlash
                          DCD      0x00000000
                  AHBPrescTable
000048  00000000          DCB      0x00,0x00,0x00,0x00
00004c  00000000          DCB      0x00,0x00,0x00,0x00
000050  01020304          DCB      0x01,0x02,0x03,0x04
000054  06070809          DCB      0x06,0x07,0x08,0x09
                  TabExecFlash
                          DCD      FlashLaser_1p
                          DCD      FlashLaser_2p
                          DCD      FlashLaser_4p
                          DCD      FlashLaser_4p

                          AREA ||area_number.7||, DATA, ALIGN=2

                          EXPORTAS ||area_number.7||, ||.data||
                  p_value
                          DCD      0x00000000

                          AREA ||area_number.8||, DATA, ALIGN=2

                          EXPORTAS ||area_number.8||, ||.data||
                  __stdout
                          DCD      0x00000000

                          AREA ||area_number.9||, DATA, ALIGN=2

                          EXPORTAS ||area_number.9||, ||.data||
                  __stdin
                          DCD      0x00000000

                          AREA ||area_number.10||, DATA, ALIGN=2

                          EXPORTAS ||area_number.10||, ||.data||
                  __stderr
                          DCD      0x00000000

;*** 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
