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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                  SetVoltageStep PROC
;;;13     
;;;14     void SetVoltageStep(int pos){			//     .
000316  4601              MOV      r1,r0
;;;15     uint	temp=(portSTP->ODR);			//  .
000318  4a43              LDR      r2,|L1.1064|
00031a  3208              ADDS     r2,r2,#8
00031c  6810              LDR      r0,[r2,#0]
;;;16     
;;;17     	temp=temp&(~mpinSTP);			//  .
00031e  f02000f0          BIC      r0,r0,#0xf0
;;;18     	temp=temp|StepTable[pos&7];		//  .
000322  f0010207          AND      r2,r1,#7
000326  4b42              LDR      r3,|L1.1072|
000328  f8532022          LDR      r2,[r3,r2,LSL #2]
00032c  4310              ORRS     r0,r0,r2
;;;19     	portSTP->ODR=temp;			//    .
00032e  4a3e              LDR      r2,|L1.1064|
000330  3208              ADDS     r2,r2,#8
000332  6010              STR      r0,[r2,#0]
;;;20     } // -------------------------------------------
000334  4770              BX       lr
;;;21     void OffVoltageStep(){				//  -   .
                          ENDP

                  OffVoltageStep PROC
000336  493f              LDR      r1,|L1.1076|
;;;22     uint	temp;
;;;23     	temp=StepTOT;
000338  6808              LDR      r0,[r1,#0]  ; StepTOT
;;;24     if	(temp)					//
00033a  b140              CBZ      r0,|L1.846|
;;;25     {
;;;26     	temp--; StepTOT=temp;			//    -.
00033c  1e40              SUBS     r0,r0,#1
00033e  6008              STR      r0,[r1,#0]  ; StepTOT
;;;27      if	(!temp)					//   0-?
000340  b928              CBNZ     r0,|L1.846|
;;;28      {
;;;29     	temp=(portSTP->ODR);
000342  4939              LDR      r1,|L1.1064|
000344  3108              ADDS     r1,r1,#8
000346  6808              LDR      r0,[r1,#0]
;;;30     	temp=temp&(~mpinSTP);
000348  f02000f0          BIC      r0,r0,#0xf0
;;;31     	portSTP->ODR=temp;			//  .
00034c  6008              STR      r0,[r1,#0]
                  |L1.846|
;;;32     //printf("\r\n voff");
;;;33      }	
;;;34     }
;;;35     } // -------------------------------------------
00034e  4770              BX       lr
;;;36     void StepBreak(){				//  .
                          ENDP

                  StepBreak PROC
000350  2000              MOVS     r0,#0
;;;37     // ---------------------------------------------
;;;38     uint temp=0;
;;;39     SysTick_Type* ptr=SysTick;
000352  4939              LDR      r1,|L1.1080|
;;;40     
;;;41     	DirY=temp; State&=~ST_MVY;		//   .
000354  4a39              LDR      r2,|L1.1084|
000356  6010              STR      r0,[r2,#0]  ; DirY
000358  4a39              LDR      r2,|L1.1088|
00035a  7812              LDRB     r2,[r2,#0]  ; State
00035c  f0220202          BIC      r2,r2,#2
000360  4b37              LDR      r3,|L1.1088|
000362  701a              STRB     r2,[r3,#0]
;;;42     	StepCNT=temp;				//  =0.
000364  4a37              LDR      r2,|L1.1092|
000366  6010              STR      r0,[r2,#0]  ; StepCNT
;;;43     	temp=STOT; StepTOT=temp;		//  .
000368  f64260e0          MOV      r0,#0x2ee0
00036c  4a31              LDR      r2,|L1.1076|
00036e  6010              STR      r0,[r2,#0]  ; StepTOT
;;;44     	temp=FT_STEP/FT_OUT; ptr->LOAD=temp;	//    -.
000370  4835              LDR      r0,|L1.1096|
000372  6048              STR      r0,[r1,#4]
;;;45     	ptr->VAL=temp-1;			//    .
000374  1e42              SUBS     r2,r0,#1
000376  608a              STR      r2,[r1,#8]
;;;46     //printf("\r\nbreak");
;;;47     } // -------------------------------------------
000378  4770              BX       lr
;;;48     void AccelStep (int speed){			//   (speed- ).
                          ENDP

                  AccelStep PROC
00037a  4601              MOV      r1,r0
;;;49     // ---------------------------------------------
;;;50     uint temp=AccelPos;				//    .
00037c  4a33              LDR      r2,|L1.1100|
00037e  6810              LDR      r0,[r2,#0]  ; AccelPos
;;;51     //SER_PutChar ('+');
;;;52     if (temp<(sizeof(AccelTable)/sizeof(AccelTable[0])))
000380  28ee              CMP      r0,#0xee
000382  d20c              BCS      |L1.926|
;;;53      {
;;;54     	temp++; AccelPos=temp;			//    .
000384  1c40              ADDS     r0,r0,#1
000386  6010              STR      r0,[r2,#0]  ; AccelPos
;;;55     	temp=AccelTable[temp];
000388  4a31              LDR      r2,|L1.1104|
00038a  f8520020          LDR      r0,[r2,r0,LSL #2]
;;;56      if (temp<=speed) cSpeedY=speed;		// cSpeedY=SpeedY;   .
00038e  4288              CMP      r0,r1
000390  d802              BHI      |L1.920|
000392  4a30              LDR      r2,|L1.1108|
000394  6011              STR      r1,[r2,#0]  ; cSpeedY
000396  e006              B        |L1.934|
                  |L1.920|
;;;57      else	cSpeedY=temp;
000398  4a2e              LDR      r2,|L1.1108|
00039a  6010              STR      r0,[r2,#0]  ; cSpeedY
00039c  e003              B        |L1.934|
                  |L1.926|
;;;58      }
;;;59     else  rSpeedY=cSpeedY;				// 
00039e  4a2d              LDR      r2,|L1.1108|
0003a0  6812              LDR      r2,[r2,#0]  ; cSpeedY
0003a2  4b2d              LDR      r3,|L1.1112|
0003a4  601a              STR      r2,[r3,#0]  ; rSpeedY
                  |L1.934|
;;;60     } // -------------------------------------------
0003a6  4770              BX       lr
;;;61     void DeccelStep(int speed){			//  .
                          ENDP

                  DeccelStep PROC
0003a8  b530              PUSH     {r4,r5,lr}
0003aa  4605              MOV      r5,r0
;;;62     // ----------------------------------------------	
;;;63     uint temp=AccelPos;				//    .
0003ac  4827              LDR      r0,|L1.1100|
0003ae  6804              LDR      r4,[r0,#0]  ; AccelPos
;;;64     //SER_PutChar ('-');
;;;65     if (temp>0)
0003b0  b164              CBZ      r4,|L1.972|
;;;66      {
;;;67     	temp--; AccelPos=temp;			//    .
0003b2  1e64              SUBS     r4,r4,#1
0003b4  6004              STR      r4,[r0,#0]  ; AccelPos
;;;68     	temp=AccelTable[temp];
0003b6  4826              LDR      r0,|L1.1104|
0003b8  f8504024          LDR      r4,[r0,r4,LSL #2]
;;;69      if (temp>=speed) cSpeedY=speed;		// cSpeedY=SpeedY;   .
0003bc  42ac              CMP      r4,r5
0003be  d302              BCC      |L1.966|
0003c0  4824              LDR      r0,|L1.1108|
0003c2  6005              STR      r5,[r0,#0]  ; cSpeedY
0003c4  e008              B        |L1.984|
                  |L1.966|
;;;70      else	cSpeedY=temp;
0003c6  4823              LDR      r0,|L1.1108|
0003c8  6004              STR      r4,[r0,#0]  ; cSpeedY
0003ca  e005              B        |L1.984|
                  |L1.972|
;;;71      }
;;;72     else { rSpeedY=cSpeedY;	StepBreak(); }		//
0003cc  4821              LDR      r0,|L1.1108|
0003ce  6800              LDR      r0,[r0,#0]  ; cSpeedY
0003d0  4921              LDR      r1,|L1.1112|
0003d2  6008              STR      r0,[r1,#0]  ; rSpeedY
0003d4  f7fffffe          BL       StepBreak
                  |L1.984|
;;;73     } // -------------------------------------------
0003d8  bd30              POP      {r4,r5,pc}
;;;74     void ChangePosStep(int dir){			//      .
                          ENDP

                  ChangePosStep PROC
0003da  b570              PUSH     {r4-r6,lr}
0003dc  4606              MOV      r6,r0
;;;75     // ----------------------------------------------
;;;76     int temp, temp1;
;;;77     //SER_PutChar ('*');
;;;78     	DirY=dir;				//  .
0003de  4817              LDR      r0,|L1.1084|
0003e0  6006              STR      r6,[r0,#0]  ; DirY
;;;79     	temp1=CurrStepPos;			//   .
0003e2  481e              LDR      r0,|L1.1116|
0003e4  6845              LDR      r5,[r0,#4]  ; lbufinfo
;;;80     	temp=StepCNT;				//     .
0003e6  4817              LDR      r0,|L1.1092|
0003e8  6804              LDR      r4,[r0,#0]  ; StepCNT
;;;81     if (temp<=AccelPos) rSpeedY=BREAKSPEED;		//   ,      .
0003ea  4818              LDR      r0,|L1.1100|
0003ec  6800              LDR      r0,[r0,#0]  ; AccelPos
0003ee  4284              CMP      r4,r0
0003f0  d802              BHI      |L1.1016|
0003f2  481b              LDR      r0,|L1.1120|
0003f4  4918              LDR      r1,|L1.1112|
0003f6  6008              STR      r0,[r1,#0]  ; rSpeedY
                  |L1.1016|
;;;82     if (!temp) StepBreak();				//    .
0003f8  bba4              CBNZ     r4,|L1.1124|
0003fa  f7fffffe          BL       StepBreak
0003fe  e05a              B        |L1.1206|
                  |L1.1024|
                          DCD      0x40021000
                  |L1.1028|
                          DCD      0x40022000
                  |L1.1032|
                          DCD      0xf8ff0000
                  |L1.1036|
                          DCD      0xfef6ffff
                  |L1.1040|
                          DCD      0xe000ed08
                  |L1.1044|
                          DCD      0x007a1200
                  |L1.1048|
                          DCD      SystemCoreClock
                  |L1.1052|
                          DCD      0x003d0900
                  |L1.1056|
                          DCD      AHBPrescTable
                  |L1.1060|
                          DCD      0x40010000
                  |L1.1064|
                          DCD      0x40010804
                  |L1.1068|
                          DCD      0x4001380c
                  |L1.1072|
                          DCD      StepTable
                  |L1.1076|
                          DCD      StepTOT
                  |L1.1080|
                          DCD      0xe000e010
                  |L1.1084|
                          DCD      DirY
                  |L1.1088|
                          DCD      State
                  |L1.1092|
                          DCD      StepCNT
                  |L1.1096|
                          DCD      0x00011940
                  |L1.1100|
                          DCD      AccelPos
                  |L1.1104|
                          DCD      AccelTable
                  |L1.1108|
                          DCD      cSpeedY
                  |L1.1112|
                          DCD      rSpeedY
                  |L1.1116|
                          DCD      lbufinfo
                  |L1.1120|
                          DCD      0x00057e3f
                  |L1.1124|
000464  e7ff              B        |L1.1126|
                  |L1.1126|
;;;83     else
;;;84      {	State|=ST_MVY;				//   .
000466  48f7              LDR      r0,|L1.2116|
000468  7800              LDRB     r0,[r0,#0]  ; State
00046a  f0400002          ORR      r0,r0,#2
00046e  49f5              LDR      r1,|L1.2116|
000470  7008              STRB     r0,[r1,#0]
;;;85     	temp1+=dir; CurrStepPos=temp1;		//  .
000472  4435              ADD      r5,r5,r6
000474  48f4              LDR      r0,|L1.2120|
000476  6045              STR      r5,[r0,#4]  ; lbufinfo
;;;86     	temp--; StepCNT=temp;			//   .
000478  1e64              SUBS     r4,r4,#1
00047a  48f4              LDR      r0,|L1.2124|
00047c  6004              STR      r4,[r0,#0]  ; StepCNT
;;;87     	SetVoltageStep(temp1);			//    .
00047e  4628              MOV      r0,r5
000480  f7fffffe          BL       SetVoltageStep
;;;88     	StepOn; fStep=1;			//    Step.
000484  2001              MOVS     r0,#1
000486  49f2              LDR      r1,|L1.2128|
000488  6008              STR      r0,[r1,#0]
00048a  49f2              LDR      r1,|L1.2132|
00048c  6008              STR      r0,[r1,#0]  ; fStep
;;;89     
;;;90     	temp=rSpeedY; temp1=cSpeedY;		//   .
00048e  48f2              LDR      r0,|L1.2136|
000490  6804              LDR      r4,[r0,#0]  ; rSpeedY
000492  48f2              LDR      r0,|L1.2140|
000494  6805              LDR      r5,[r0,#0]  ; cSpeedY
;;;91      if (temp1<temp) DeccelStep(temp);		//   ( ).
000496  42a5              CMP      r5,r4
000498  da02              BGE      |L1.1184|
00049a  4620              MOV      r0,r4
00049c  f7fffffe          BL       DeccelStep
                  |L1.1184|
;;;92      if (temp1>temp) AccelStep(temp);		//   ( ).
0004a0  42a5              CMP      r5,r4
0004a2  dd02              BLE      |L1.1194|
0004a4  4620              MOV      r0,r4
0004a6  f7fffffe          BL       AccelStep
                  |L1.1194|
;;;93     	SysTick->LOAD=(cSpeedY>>1);		//  /2    STEP.
0004aa  48ec              LDR      r0,|L1.2140|
0004ac  6800              LDR      r0,[r0,#0]  ; cSpeedY
0004ae  1040              ASRS     r0,r0,#1
0004b0  f04f21e0          MOV      r1,#0xe000e000
0004b4  6148              STR      r0,[r1,#0x14]
                  |L1.1206|
;;;94      }
;;;95     //intf("\r\ncp %d ps %d cs %d sp %d ap %d",CurrStepPos,StepPos,cSpeedY,SpeedY,AccelPos);
;;;96     } // --------------------------------------------
0004b6  bd70              POP      {r4-r6,pc}
;;;97     void WaitSteps(){				//    .
                          ENDP

                  WaitSteps PROC
0004b8  bf00              NOP      
                  |L1.1210|
;;;98     // ----------------------------------------------
;;;99     while	(!StepCNT);
0004ba  48e4              LDR      r0,|L1.2124|
0004bc  6800              LDR      r0,[r0,#0]  ; StepCNT
0004be  2800              CMP      r0,#0
0004c0  d0fb              BEQ      |L1.1210|
;;;100    } // --------------------------------------------
0004c2  4770              BX       lr
;;;101    void Steps(int rpos){				// .
                          ENDP

                  Steps PROC
0004c4  b510              PUSH     {r4,lr}
0004c6  4604              MOV      r4,r0
;;;102    // ----------------------------------------------
;;;103    if (rpos==0) rSpeedY=BREAKSPEED;		//   ,  0.
0004c8  b91c              CBNZ     r4,|L1.1234|
0004ca  48e5              LDR      r0,|L1.2144|
0004cc  49e2              LDR      r1,|L1.2136|
0004ce  6008              STR      r0,[r1,#0]  ; rSpeedY
0004d0  e026              B        |L1.1312|
                  |L1.1234|
;;;104    else
;;;105     {
;;;106      if (!DirY)
0004d2  48e4              LDR      r0,|L1.2148|
0004d4  6800              LDR      r0,[r0,#0]  ; DirY
0004d6  bb18              CBNZ     r0,|L1.1312|
;;;107      {
;;;108    //	  TSTP->CR1 =0; TSTP->CNT =0;		//  .   0-.
;;;109    	AccelPos=0;				//   .
0004d8  2000              MOVS     r0,#0
0004da  49e3              LDR      r1,|L1.2152|
0004dc  6008              STR      r0,[r1,#0]  ; AccelPos
;;;110      	cSpeedY=FT_STEP/FSTEPMIN;		//    .
0004de  48e3              LDR      r0,|L1.2156|
0004e0  49de              LDR      r1,|L1.2140|
0004e2  6008              STR      r0,[r1,#0]  ; cSpeedY
;;;111    	rSpeedY=FT_STEP/SpeedY-1;		//
0004e4  48e2              LDR      r0,|L1.2160|
0004e6  6800              LDR      r0,[r0,#0]  ; SpeedY
0004e8  49e2              LDR      r1,|L1.2164|
0004ea  fbb1f0f0          UDIV     r0,r1,r0
0004ee  1e40              SUBS     r0,r0,#1
0004f0  49d9              LDR      r1,|L1.2136|
0004f2  6008              STR      r0,[r1,#0]  ; rSpeedY
;;;112     if (rpos>0)
0004f4  2c00              CMP      r4,#0
0004f6  dd09              BLE      |L1.1292|
;;;113       {
;;;114    	DirOff; StepCNT=+rpos; ChangePosStep(+1);
0004f8  2002              MOVS     r0,#2
0004fa  49d5              LDR      r1,|L1.2128|
0004fc  1d09              ADDS     r1,r1,#4
0004fe  6008              STR      r0,[r1,#0]
000500  48d2              LDR      r0,|L1.2124|
000502  6004              STR      r4,[r0,#0]  ; StepCNT
000504  2001              MOVS     r0,#1
000506  f7fffffe          BL       ChangePosStep
00050a  e009              B        |L1.1312|
                  |L1.1292|
;;;115       }
;;;116     else
;;;117       {
;;;118    	DirOn; StepCNT=-rpos; ChangePosStep(-1);
00050c  2002              MOVS     r0,#2
00050e  49d0              LDR      r1,|L1.2128|
000510  6008              STR      r0,[r1,#0]
000512  4260              RSBS     r0,r4,#0
000514  49cd              LDR      r1,|L1.2124|
000516  6008              STR      r0,[r1,#0]  ; StepCNT
000518  f04f30ff          MOV      r0,#0xffffffff
00051c  f7fffffe          BL       ChangePosStep
                  |L1.1312|
;;;119       }
;;;120      }
;;;121     }	 
;;;122    } // --------------------------------------------
000520  bd10              POP      {r4,pc}
;;;123    void wSteps(int rpos){				//   .
                          ENDP

                  wSteps PROC
000522  b510              PUSH     {r4,lr}
000524  4604              MOV      r4,r0
;;;124    // ----------------------------------------------
;;;125    	WaitSteps(); Steps(rpos); 
000526  f7fffffe          BL       WaitSteps
00052a  4620              MOV      r0,r4
00052c  f7fffffe          BL       Steps
;;;126    } // --------------------------------------------
000530  bd10              POP      {r4,pc}
;;;127    void StepYCMD(int rpos){			//    "myNNNN".
                          ENDP

                  StepYCMD PROC
000532  b510              PUSH     {r4,lr}
000534  4604              MOV      r4,r0
;;;128    // ----------------------------------------------
;;;129    	Steps(rpos);
000536  4620              MOV      r0,r4
000538  f7fffffe          BL       Steps
;;;130    	ASK();					//   .
00053c  f7fffffe          BL       ASK
;;;131    } // --------------------------------------------
000540  bd10              POP      {r4,pc}
;;;132    void AbsMoveY(int pos){				//    "mYNNNN".
                          ENDP

                  AbsMoveY PROC
000542  b530              PUSH     {r4,r5,lr}
000544  4604              MOV      r4,r0
;;;133    // ----------------------------------------------
;;;134    	StepYCMD(CalcStepY(pos)-CurrStepPos);	//
000546  4620              MOV      r0,r4
000548  f7fffffe          BL       CalcStepY
00054c  49be              LDR      r1,|L1.2120|
00054e  6849              LDR      r1,[r1,#4]  ; lbufinfo
000550  1a45              SUBS     r5,r0,r1
000552  4628              MOV      r0,r5
000554  f7fffffe          BL       StepYCMD
;;;135    } // --------------------------------------------
000558  bd30              POP      {r4,r5,pc}
;;;136    
                          ENDP

                  InitTimerSteps PROC
;;;137    void InitTimerSteps (){				//    .
00055a  b510              PUSH     {r4,lr}
;;;138    // ----------------------------------------------
;;;139    	cSpeedY=FT_STEP/FSTEPMIN;		//   = .
00055c  48c3              LDR      r0,|L1.2156|
00055e  49bf              LDR      r1,|L1.2140|
000560  6008              STR      r0,[r1,#0]  ; cSpeedY
;;;140    	StepBreak();				// -   .
000562  f7fffffe          BL       StepBreak
;;;141    	NVIC_SetPriority (SysTick_IRQn, 200);  	//  .
000566  f04f30ff          MOV      r0,#0xffffffff
00056a  21c8              MOVS     r1,#0xc8
00056c  2800              CMP      r0,#0
00056e  da07              BGE      |L1.1408|
000570  070a              LSLS     r2,r1,#28
000572  0e14              LSRS     r4,r2,#24
000574  4ac0              LDR      r2,|L1.2168|
000576  f000030f          AND      r3,r0,#0xf
00057a  1f1b              SUBS     r3,r3,#4
00057c  54d4              STRB     r4,[r2,r3]
00057e  e003              B        |L1.1416|
                  |L1.1408|
000580  070a              LSLS     r2,r1,#28
000582  0e13              LSRS     r3,r2,#24
000584  4abd              LDR      r2,|L1.2172|
000586  5413              STRB     r3,[r2,r0]
                  |L1.1416|
000588  bf00              NOP      
;;;142    	SysTick->CTRL=SysTick_CTRL_TICKINT_Msk|	//  .
00058a  2007              MOVS     r0,#7
00058c  f04f21e0          MOV      r1,#0xe000e000
000590  6108              STR      r0,[r1,#0x10]
;;;143    		SysTick_CTRL_CLKSOURCE_Msk |	//    (72 ).
;;;144    		SysTick_CTRL_ENABLE_Msk;	//  .
;;;145    } // -------------------------------------------
000592  bd10              POP      {r4,pc}
;;;146    void InitPinsSteps (){				//     .
                          ENDP

                  InitPinsSteps PROC
000594  b500              PUSH     {lr}
;;;147    
;;;148    	portSTP_CR &=~(
000596  48ba              LDR      r0,|L1.2176|
000598  6800              LDR      r0,[r0,#0]
00059a  b280              UXTH     r0,r0
00059c  49b8              LDR      r1,|L1.2176|
00059e  6008              STR      r0,[r1,#0]
;;;149    		(PinCR(pinSTP0,GPIOCR))|	//    .
;;;150    		(PinCR(pinSTP1,GPIOCR))|
;;;151    		(PinCR(pinSTP2,GPIOCR))|
;;;152    		(PinCR(pinSTP3,GPIOCR))
;;;153    		);
;;;154    	portSTP_CR |=(
0005a0  4608              MOV      r0,r1
0005a2  6800              LDR      r0,[r0,#0]
0005a4  49b7              LDR      r1,|L1.2180|
0005a6  4308              ORRS     r0,r0,r1
0005a8  49b5              LDR      r1,|L1.2176|
0005aa  6008              STR      r0,[r1,#0]
;;;155    		(PinCR(pinSTP0,p_o_p10))|
;;;156    		(PinCR(pinSTP1,p_o_p10))|
;;;157    		(PinCR(pinSTP2,p_o_p10))|
;;;158    		(PinCR(pinSTP3,p_o_p10))
;;;159    		);
;;;160    
;;;161    	portSTPDIR_CR &=~(
0005ac  48a8              LDR      r0,|L1.2128|
0005ae  3810              SUBS     r0,r0,#0x10
0005b0  6800              LDR      r0,[r0,#0]
0005b2  f02000ff          BIC      r0,r0,#0xff
0005b6  49a6              LDR      r1,|L1.2128|
0005b8  3910              SUBS     r1,r1,#0x10
0005ba  6008              STR      r0,[r1,#0]
;;;162    		(PinCR(pinSTEP,GPIOCR))|
;;;163    		(PinCR(pinDIR ,GPIOCR))
;;;164    		);
;;;165    	portSTPDIR_CR |=(
0005bc  4608              MOV      r0,r1
0005be  6800              LDR      r0,[r0,#0]
0005c0  f0400011          ORR      r0,r0,#0x11
0005c4  6008              STR      r0,[r1,#0]
;;;166    		(PinCR(pinSTEP,p_o_p10))|	//   .
;;;167    		(PinCR(pinDIR ,p_o_p10))
;;;168    		);
;;;169    
;;;170    	SetVoltageStep(0);			// 
0005c6  2000              MOVS     r0,#0
0005c8  f7fffffe          BL       SetVoltageStep
;;;171    } // -------------------------------------------
0005cc  bd00              POP      {pc}
;;;172    
                          ENDP

                  SysTick_Handler PROC
;;;173    void TSTP_IRQ(){				//    .
0005ce  b510              PUSH     {r4,lr}
;;;174    // ----------------------------------------------
;;;175    int dir;	
;;;176     if (fStep) 
0005d0  48a0              LDR      r0,|L1.2132|
0005d2  6800              LDR      r0,[r0,#0]  ; fStep
0005d4  b138              CBZ      r0,|L1.1510|
;;;177     {
;;;178    	fStep=0; StepOff;			//   STEP.
0005d6  2000              MOVS     r0,#0
0005d8  499e              LDR      r1,|L1.2132|
0005da  6008              STR      r0,[r1,#0]  ; fStep
0005dc  2001              MOVS     r0,#1
0005de  499c              LDR      r1,|L1.2128|
0005e0  1d09              ADDS     r1,r1,#4
0005e2  6008              STR      r0,[r1,#0]
0005e4  e008              B        |L1.1528|
                  |L1.1510|
;;;179     }
;;;180     else
;;;181     {
;;;182    	dir=DirY;
0005e6  489f              LDR      r0,|L1.2148|
0005e8  6804              LDR      r4,[r0,#0]  ; DirY
;;;183      if (dir)	ChangePosStep(dir);		//  ,  .
0005ea  b11c              CBZ      r4,|L1.1524|
0005ec  4620              MOV      r0,r4
0005ee  f7fffffe          BL       ChangePosStep
0005f2  e001              B        |L1.1528|
                  |L1.1524|
;;;184      else		OffVoltageStep();		//   (  -).
0005f4  f7fffffe          BL       OffVoltageStep
                  |L1.1528|
;;;185     }
;;;186    }// ---------------------------------------------
0005f8  bd10              POP      {r4,pc}
;;;14     #include "src\motor.c"
                          ENDP

                  SetDirDC PROC
;;;5      } // --------------------------------------------
;;;6      void SetDirDC (int dir){			//   .
0005fa  f44f4110          MOV      r1,#0x9000
;;;7      // ----------------------------------------------
;;;8      	portDC->BRR=(1<<pinPWRF|1<<pinPWRB);	//   .
0005fe  4a94              LDR      r2,|L1.2128|
000600  1d12              ADDS     r2,r2,#4
000602  6011              STR      r1,[r2,#0]
;;;9       if (dir<0)	 portDC->BSRR=1<<pinPWRB;	//   .
000604  2800              CMP      r0,#0
000606  da04              BGE      |L1.1554|
000608  f44f4100          MOV      r1,#0x8000
00060c  1f12              SUBS     r2,r2,#4
00060e  6011              STR      r1,[r2,#0]
000610  e005              B        |L1.1566|
                  |L1.1554|
;;;10      else if (dir>0) portDC->BSRR=1<<pinPWRF;	//   .
000612  2800              CMP      r0,#0
000614  dd03              BLE      |L1.1566|
000616  f44f5180          MOV      r1,#0x1000
00061a  4a8d              LDR      r2,|L1.2128|
00061c  6011              STR      r1,[r2,#0]
                  |L1.1566|
;;;11     
;;;12     //printf("\r\nmotor rg %d %d", TPWM->CCR1,TPWM->CCR2);
;;;13     } // --------------------------------------------
00061e  4770              BX       lr
;;;14     void TIM_Init_PWM(){				//    TIM1.
                          ENDP

                  TIM_Init_PWM PROC
000620  4899              LDR      r0,|L1.2184|
;;;15     // ----------------------------------------------
;;;16     TIM_TypeDef *timptr=TPWM;
;;;17     
;;;18     	SET_PER_PWM				//  .
000622  499a              LDR      r1,|L1.2188|
000624  6849              LDR      r1,[r1,#4]
000626  f02101c0          BIC      r1,r1,#0xc0
00062a  4a98              LDR      r2,|L1.2188|
00062c  6051              STR      r1,[r2,#4]
00062e  4611              MOV      r1,r2
000630  6849              LDR      r1,[r1,#4]
000632  6051              STR      r1,[r2,#4]
000634  4996              LDR      r1,|L1.2192|
000636  6989              LDR      r1,[r1,#0x18]
000638  f4416100          ORR      r1,r1,#0x800
00063c  4a94              LDR      r2,|L1.2192|
00063e  6191              STR      r1,[r2,#0x18]
;;;19     
;;;20     	portDC_CR &=~(
000640  4983              LDR      r1,|L1.2128|
000642  390c              SUBS     r1,r1,#0xc
000644  6809              LDR      r1,[r1,#0]
000646  4a93              LDR      r2,|L1.2196|
000648  4011              ANDS     r1,r1,r2
00064a  4a81              LDR      r2,|L1.2128|
00064c  3a0c              SUBS     r2,r2,#0xc
00064e  6011              STR      r1,[r2,#0]
;;;21     		(PinCR(pinPWM,GPIOCR))|		//   .
;;;22     //		(PinCR(pinPWMF,GPIOCR))|	//   .
;;;23     //		(PinCR(pinPWMB,GPIOCR))|
;;;24     		(PinCR(pinPWRF,GPIOCR))|
;;;25     		(PinCR(pinPWRB,GPIOCR))
;;;26     		);
;;;27     	portDC_CR |=(
000650  4611              MOV      r1,r2
000652  6809              LDR      r1,[r1,#0]
000654  4a90              LDR      r2,|L1.2200|
000656  4311              ORRS     r1,r1,r2
000658  4a7d              LDR      r2,|L1.2128|
00065a  3a0c              SUBS     r2,r2,#0xc
00065c  6011              STR      r1,[r2,#0]
;;;28     		(PinCR(pinPWM,p_a_p50))|	//  .
;;;29     		(PinCR(pinPWRF,p_o_p50))|	//  .
;;;30     		(PinCR(pinPWRB,p_o_p50))
;;;31     		);
;;;32     	timptr->PSC  = ((TPWM_CK/PWM_FREQ/PWM_RES)-1);	// set prescaler
00065e  210d              MOVS     r1,#0xd
000660  8501              STRH     r1,[r0,#0x28]
;;;33     	timptr->ARR  = (PWM_RES-1);		// set auto-reload
000662  21fe              MOVS     r1,#0xfe
000664  8581              STRH     r1,[r0,#0x2c]
;;;34     	
;;;35     	timptr->CCMR1=	
000666  f2460160          MOV      r1,#0x6060
00066a  8301              STRH     r1,[r0,#0x18]
;;;36     		TIM_CCMR1_OC2M_1|
;;;37     		TIM_CCMR1_OC2M_2|
;;;38     		TIM_CCMR1_OC1M_1|
;;;39     		TIM_CCMR1_OC1M_2;		// PWM mode 6. Channel 1&2
;;;40     
;;;41     	timptr->CCER =	TIM_CCER_CC1NE|		//  .     1  8
00066c  2144              MOVS     r1,#0x44
00066e  8401              STRH     r1,[r0,#0x20]
;;;42     			TIM_CCER_CC2NE;
;;;43     	timptr->BDTR =	TIM_BDTR_MOE;
000670  f44f4100          MOV      r1,#0x8000
000674  f8a01044          STRH     r1,[r0,#0x44]
;;;44     			
;;;45     //			TIM_CCER_CC1NP|		// .
;;;46     //			TIM_CCER_CC2NP;
;;;47     
;;;48     	timptr->CR1 |= TIM_CR1_CEN;		//  .
000678  8801              LDRH     r1,[r0,#0]
00067a  f0410101          ORR      r1,r1,#1
00067e  8001              STRH     r1,[r0,#0]
;;;49     } // --------------------------------------------
000680  4770              BX       lr
;;;50     void TIM_Init_TOT(){				//    .
                          ENDP

                  TIM_Init_TOT PROC
000682  b510              PUSH     {r4,lr}
;;;51     // ----------------------------------------------	
;;;52     TIM_TypeDef *timptr=TTOT;
000684  4c85              LDR      r4,|L1.2204|
;;;53     	SET_PER_TOT				//  . 
000686  4882              LDR      r0,|L1.2192|
000688  69c0              LDR      r0,[r0,#0x1c]
00068a  f0400002          ORR      r0,r0,#2
00068e  4980              LDR      r1,|L1.2192|
000690  61c8              STR      r0,[r1,#0x1c]
;;;54     
;;;55     	timptr->PSC  = TTOT_CK/10000 - 1;	//   100  (10KHz).
000692  f641401f          MOV      r0,#0x1c1f
000696  8520              STRH     r0,[r4,#0x28]
;;;56     	timptr->ARR  = TOT_TIME*10-1;		//   .
000698  f242700f          MOV      r0,#0x270f
00069c  85a0              STRH     r0,[r4,#0x2c]
;;;57     
;;;58     	timptr->DIER =TIM_DIER_UIE;		//     .
00069e  2001              MOVS     r0,#1
0006a0  81a0              STRH     r0,[r4,#0xc]
;;;59     	NVIC_EnableIRQ(TTOT_IRQn);		//    TIM2.
0006a2  201d              MOVS     r0,#0x1d
0006a4  f7fffffe          BL       NVIC_EnableIRQ
;;;60     } // -------------------------------------------
0006a8  bd10              POP      {r4,pc}
;;;61     
                          ENDP

                  SetTOT PROC
;;;62     void SetTOT(uint tot){				//   -.
0006aa  4601              MOV      r1,r0
;;;63     // ----------------------------------------------	
;;;64     //printf("\r\nset TOT %d",tot);
;;;65     TIM_TypeDef *timptr=TTOT;
0006ac  487b              LDR      r0,|L1.2204|
;;;66     	timptr->CNT =0;			//   0-.
0006ae  2200              MOVS     r2,#0
0006b0  8482              STRH     r2,[r0,#0x24]
;;;67     	timptr->ARR =tot;			//  .
0006b2  8581              STRH     r1,[r0,#0x2c]
;;;68     	timptr->CR1 |=TIM_CR1_CEN;		//  .
0006b4  8802              LDRH     r2,[r0,#0]
0006b6  f0420201          ORR      r2,r2,#1
0006ba  8002              STRH     r2,[r0,#0]
;;;69     } // -------------------------------------------
0006bc  4770              BX       lr
;;;70     void ResetTOT(){				//  -.
                          ENDP

                  ResetTOT PROC
0006be  4877              LDR      r0,|L1.2204|
;;;71     // ----------------------------------------------	
;;;72     //printf("\r\nreset TOT");
;;;73     TIM_TypeDef *timptr=TTOT;
;;;74     	timptr->CR1 &=~TIM_CR1_CEN;		//  .
0006c0  8801              LDRH     r1,[r0,#0]
0006c2  f0210101          BIC      r1,r1,#1
0006c6  8001              STRH     r1,[r0,#0]
;;;75     } // -------------------------------------------
0006c8  4770              BX       lr
;;;76     void MotorBreak(){				//  .
                          ENDP

                  MotorBreak PROC
0006ca  b510              PUSH     {r4,lr}
;;;77     
;;;78     	SetDirDC(0);				//  .
0006cc  2000              MOVS     r0,#0
0006ce  f7fffffe          BL       SetDirDC
;;;79     	TCAP->DIER&=~TIM_DIER_UIE;		//     .
0006d2  4873              LDR      r0,|L1.2208|
0006d4  8800              LDRH     r0,[r0,#0]
0006d6  f0200001          BIC      r0,r0,#1
0006da  4971              LDR      r1,|L1.2208|
0006dc  8008              STRH     r0,[r1,#0]
;;;80     	VoltageMotor=0;				// 
0006de  2000              MOVS     r0,#0
0006e0  4970              LDR      r1,|L1.2212|
0006e2  6008              STR      r0,[r1,#0]  ; VoltageMotor
;;;81     	SpeedMotor=0;				//   .
0006e4  4970              LDR      r1,|L1.2216|
0006e6  6008              STR      r0,[r1,#0]  ; SpeedMotor
;;;82     	PWM_Set(0);				//  .
0006e8  f7fffffe          BL       PWM_Set
;;;83     	ResetTOT();				//   .
0006ec  f7fffffe          BL       ResetTOT
;;;84     	State&=~ST_MVX;				//   .
0006f0  4854              LDR      r0,|L1.2116|
0006f2  7800              LDRB     r0,[r0,#0]  ; State
0006f4  f0200001          BIC      r0,r0,#1
0006f8  4952              LDR      r1,|L1.2116|
0006fa  7008              STRB     r0,[r1,#0]
;;;85     } // --------------------------------------------
0006fc  bd10              POP      {r4,pc}
;;;86     
                          ENDP

                  TIM3_IRQHandler PROC
;;;87     void TTOT_IRQ(){				//     R  .
0006fe  b510              PUSH     {r4,lr}
;;;88     //**********************************************
;;;89     TIM_TypeDef *timptr=TTOT;
000700  4c66              LDR      r4,|L1.2204|
;;;90     
;;;91     	timptr->SR =0;		//   .
000702  2000              MOVS     r0,#0
000704  8220              STRH     r0,[r4,#0x10]
;;;92     
;;;93     //printf("\r\nTOT%d",SpeedMotor);
;;;94      if	(SpeedMotor) MotorBreak();		// .
000706  4868              LDR      r0,|L1.2216|
000708  6800              LDR      r0,[r0,#0]  ; SpeedMotor
00070a  b108              CBZ      r0,|L1.1808|
00070c  f7fffffe          BL       MotorBreak
                  |L1.1808|
;;;95     	timptr->CR1 &=~TIM_CR1_CEN;		//  .
000710  8820              LDRH     r0,[r4,#0]
000712  f0200001          BIC      r0,r0,#1
000716  8020              STRH     r0,[r4,#0]
;;;96     	timptr->CNT =0;				//   "0".
000718  2000              MOVS     r0,#0
00071a  84a0              STRH     r0,[r4,#0x24]
;;;97     } // -------------------------------------------
00071c  bd10              POP      {r4,pc}
;;;98     
                          ENDP

                  UpdateTOT PROC
;;;99     void UpdateTOT(){				//   -.
00071e  2000              MOVS     r0,#0
;;;100    // ----------------------------------------------	
;;;101    //printf("\r\nupdate TOT");
;;;102    	TTOT->CNT =0;
000720  495e              LDR      r1,|L1.2204|
000722  3124              ADDS     r1,r1,#0x24
000724  8008              STRH     r0,[r1,#0]
;;;103    } // -------------------------------------------
000726  4770              BX       lr
;;;104    void MotorOn(){					//  .
                          ENDP

                  MotorOn PROC
000728  b510              PUSH     {r4,lr}
;;;105    // ----------------------------------------------	
;;;106    //printf("\r\nmotor on");
;;;107    	State|=ST_MVX;				//      X.
00072a  4846              LDR      r0,|L1.2116|
00072c  7800              LDRB     r0,[r0,#0]  ; State
00072e  f0400001          ORR      r0,r0,#1
000732  4944              LDR      r1,|L1.2116|
000734  7008              STRB     r0,[r1,#0]
;;;108    	SetDirDC (DirX);			//  .
000736  485d              LDR      r0,|L1.2220|
000738  6800              LDR      r0,[r0,#0]  ; DirX
00073a  f7fffffe          BL       SetDirDC
;;;109    	PWM_Set(VoltageMotor);			// 
00073e  4959              LDR      r1,|L1.2212|
000740  8809              LDRH     r1,[r1,#0]  ; VoltageMotor
000742  b288              UXTH     r0,r1
000744  f7fffffe          BL       PWM_Set
;;;110    } // --------------------------------------------
000748  bd10              POP      {r4,pc}
;;;111    void WaitM(){					//   .
                          ENDP

                  WaitM PROC
00074a  bf00              NOP      
                  |L1.1868|
;;;112    // ----------------------------------------------	
;;;113    //printf("\r\n>w");
;;;114    while (SpeedMotor);				//  ,  .
00074c  4856              LDR      r0,|L1.2216|
00074e  6800              LDR      r0,[r0,#0]  ; SpeedMotor
000750  2800              CMP      r0,#0
000752  d1fb              BNE      |L1.1868|
;;;115    //	MotorBreak(); ResetTOT();		//  .
;;;116    //printf("\r\nw>");
;;;117    } // --------------------------------------------
000754  4770              BX       lr
;;;118    void Motor(int speed, int pos){			//     POS   SPEED
                          ENDP

                  Motor PROC
000756  b570              PUSH     {r4-r6,lr}
000758  4605              MOV      r5,r0
00075a  460c              MOV      r4,r1
;;;119    // ----------------------------------------------	
;;;120    //printf("\r\nmotor(%d,%d\r\n)",speed,pos);
;;;121     if (CurrLaserPos!=pos)
00075c  483a              LDR      r0,|L1.2120|
00075e  6800              LDR      r0,[r0,#0]  ; lbufinfo
000760  42a0              CMP      r0,r4
000762  d028              BEQ      |L1.1974|
;;;122     {	
;;;123    	WaitM();				//    .
000764  f7fffffe          BL       WaitM
;;;124    	VoltageMotor=MAX_PWM;			//   .
000768  20ff              MOVS     r0,#0xff
00076a  494e              LDR      r1,|L1.2212|
00076c  6008              STR      r0,[r1,#0]  ; VoltageMotor
;;;125    	i_value=0; d_value=0;			//     .
00076e  2000              MOVS     r0,#0
000770  494f              LDR      r1,|L1.2224|
000772  6008              STR      r0,[r1,#0]  ; i_value
000774  494f              LDR      r1,|L1.2228|
000776  6008              STR      r0,[r1,#0]  ; d_value
;;;126      if	(CurrLaserPos>pos) DirX=-1;		//   .
000778  4833              LDR      r0,|L1.2120|
00077a  6800              LDR      r0,[r0,#0]  ; lbufinfo
00077c  42a0              CMP      r0,r4
00077e  dd04              BLE      |L1.1930|
000780  f04f30ff          MOV      r0,#0xffffffff
000784  4949              LDR      r1,|L1.2220|
000786  6008              STR      r0,[r1,#0]  ; DirX
000788  e002              B        |L1.1936|
                  |L1.1930|
;;;127      else	DirX=1;
00078a  2001              MOVS     r0,#1
00078c  4947              LDR      r1,|L1.2220|
00078e  6008              STR      r0,[r1,#0]  ; DirX
                  |L1.1936|
;;;128    	LaserPos=pos;				//   .
000790  4849              LDR      r0,|L1.2232|
000792  6004              STR      r4,[r0,#0]  ; LaserPos
;;;129    //printf ("\r\nMotor %d %d %d",speed, pos, DirX);
;;;130    	SpeedMotor=speed;			//     .
000794  4844              LDR      r0,|L1.2216|
000796  6005              STR      r5,[r0,#0]  ; SpeedMotor
;;;131    	SetTOT(TOT_TIME*10-1);			//   .
000798  f242700f          MOV      r0,#0x270f
00079c  f7fffffe          BL       SetTOT
;;;132    indxmem=0;
0007a0  2000              MOVS     r0,#0
0007a2  4946              LDR      r1,|L1.2236|
0007a4  6008              STR      r0,[r1,#0]  ; indxmem
;;;133    	MotorOn();				//  .
0007a6  f7fffffe          BL       MotorOn
;;;134    	TCAP->DIER|=TIM_DIER_UIE;		//     .
0007aa  483d              LDR      r0,|L1.2208|
0007ac  8800              LDRH     r0,[r0,#0]
0007ae  f0400001          ORR      r0,r0,#1
0007b2  493b              LDR      r1,|L1.2208|
0007b4  8008              STRH     r0,[r1,#0]
                  |L1.1974|
;;;135    	
;;;136     }
;;;137    } // --------------------------------------------
0007b6  bd70              POP      {r4-r6,pc}
;;;138    void PrintStateM(){				//  .
                          ENDP

                  PrintStateM PROC
0007b8  b510              PUSH     {r4,lr}
;;;139    // ----------------------------------------------	
;;;140    int pos;
;;;141    	pos=CurrLaserPos;
0007ba  4823              LDR      r0,|L1.2120|
0007bc  6804              LDR      r4,[r0,#0]  ; lbufinfo
;;;142     if	(OldLaserPos!=pos)
0007be  4840              LDR      r0,|L1.2240|
0007c0  6800              LDR      r0,[r0,#0]  ; OldLaserPos
0007c2  42a0              CMP      r0,r4
0007c4  d009              BEQ      |L1.2010|
;;;143     {
;;;144    	printf("\r\n%6d %6d %8x",pos,SpeedMotor,DebCNT1);
0007c6  483f              LDR      r0,|L1.2244|
0007c8  6803              LDR      r3,[r0,#0]  ; DebCNT1
0007ca  4837              LDR      r0,|L1.2216|
0007cc  4621              MOV      r1,r4
0007ce  6802              LDR      r2,[r0,#0]  ; SpeedMotor
0007d0  a03d              ADR      r0,|L1.2248|
0007d2  f7fffffe          BL       __2printf
;;;145    	OldLaserPos=pos;
0007d6  483a              LDR      r0,|L1.2240|
0007d8  6004              STR      r4,[r0,#0]  ; OldLaserPos
                  |L1.2010|
;;;146     }
;;;147    } // --------------------------------------------
0007da  bd10              POP      {r4,pc}
;;;148    
                          ENDP

                  CaretToHome PROC
;;;150    
;;;151    void CaretToHome(){				//    .
0007dc  b510              PUSH     {r4,lr}
;;;152    // ----------------------------------------------	
;;;153    //uint tmp;
;;;154    //	tmp=VoltageMotor;			// 
;;;155    //	VoltageMotor=MIN_VLT;			//    .
;;;156    	CurrLaserPos=0;				//      .
0007de  2000              MOVS     r0,#0
0007e0  4919              LDR      r1,|L1.2120|
0007e2  6008              STR      r0,[r1,#0]  ; lbufinfo
;;;157    	Motor(100,100);				//  .
0007e4  2164              MOVS     r1,#0x64
0007e6  4608              MOV      r0,r1
0007e8  f7fffffe          BL       Motor
;;;158    	Motor(100,-(MaxPixelLL));		//      .
0007ec  493a              LDR      r1,|L1.2264|
0007ee  2064              MOVS     r0,#0x64
0007f0  f7fffffe          BL       Motor
;;;159    	WaitM();				//   .
0007f4  f7fffffe          BL       WaitM
;;;160    //printf ("\r\ncaret to home");
;;;161    //printf ("\r\npos %d",CurrLaserPos);
;;;162    	ASK();					//   .
0007f8  f7fffffe          BL       ASK
;;;163    } // --------------------------------------------
0007fc  bd10              POP      {r4,pc}
;;;164    void StopMove(){				//  .
                          ENDP

                  StopMove PROC
0007fe  b510              PUSH     {r4,lr}
;;;165    // ----------------------------------------------
;;;166    	MotorBreak(); rSpeedY=BREAKSPEED;
000800  f7fffffe          BL       MotorBreak
000804  4816              LDR      r0,|L1.2144|
000806  4914              LDR      r1,|L1.2136|
000808  6008              STR      r0,[r1,#0]  ; rSpeedY
;;;167    //printf ("\n\rstop move");
;;;168    	ASK();					//   .
00080a  f7fffffe          BL       ASK
;;;169    } // --------------------------------------------
00080e  bd10              POP      {r4,pc}
;;;170    void AbsMoveX(int pos){				//     POS   SPEED
                          ENDP

                  AbsMoveX PROC
000810  b570              PUSH     {r4-r6,lr}
000812  4604              MOV      r4,r0
;;;171    // ----------------------------------------------
;;;172    //printf ("\r\nMoveX %d %d",speed, pos);
;;;173    
;;;174    	Motor(SpeedX,CalcStepX(pos));	//     .
000814  4620              MOV      r0,r4
000816  f7fffffe          BL       CalcStepX
00081a  4605              MOV      r5,r0
00081c  4629              MOV      r1,r5
00081e  482f              LDR      r0,|L1.2268|
000820  6800              LDR      r0,[r0,#0]  ; SpeedX
000822  f7fffffe          BL       Motor
;;;175    	ASK();					//   .
000826  f7fffffe          BL       ASK
;;;176    } // --------------------------------------------
00082a  bd70              POP      {r4-r6,pc}
;;;177    void StepXCMD(int steps){			//    STEPS .
                          ENDP

                  StepXCMD PROC
00082c  b510              PUSH     {r4,lr}
00082e  4604              MOV      r4,r0
;;;178    // ----------------------------------------------
;;;179    //printf ("\r\nMoveX %d %d",speed, pos);
;;;180    	
;;;181    	Motor(SpeedX,CurrLaserPos+steps);	// 
000830  4805              LDR      r0,|L1.2120|
000832  6800              LDR      r0,[r0,#0]  ; lbufinfo
000834  1901              ADDS     r1,r0,r4
000836  4829              LDR      r0,|L1.2268|
000838  6800              LDR      r0,[r0,#0]  ; SpeedX
00083a  f7fffffe          BL       Motor
;;;182    	ASK();					//   .
00083e  f7fffffe          BL       ASK
;;;183    } // --------------------------------------------
000842  bd10              POP      {r4,pc}
                  |L1.2116|
                          DCD      State
                  |L1.2120|
                          DCD      lbufinfo
                  |L1.2124|
                          DCD      StepCNT
                  |L1.2128|
                          DCD      0x40010c10
                  |L1.2132|
                          DCD      fStep
                  |L1.2136|
                          DCD      rSpeedY
                  |L1.2140|
                          DCD      cSpeedY
                  |L1.2144|
                          DCD      0x00057e3f
                  |L1.2148|
                          DCD      DirY
                  |L1.2152|
                          DCD      AccelPos
                  |L1.2156|
                          DCD      0x0002bf20
                  |L1.2160|
                          DCD      SpeedY
                  |L1.2164|
                          DCD      0x044aa200
                  |L1.2168|
                          DCD      0xe000ed18
                  |L1.2172|
                          DCD      0xe000e400
                  |L1.2176|
                          DCD      0x40010800
                  |L1.2180|
                          DCD      0x11110000
                  |L1.2184|
                          DCD      0x40012c00
                  |L1.2188|
                          DCD      0x40010000
                  |L1.2192|
                          DCD      0x40021000
                  |L1.2196|
                          DCD      0x0f00ffff
                  |L1.2200|
                          DCD      0x30b30000
                  |L1.2204|
                          DCD      0x40000400
                  |L1.2208|
                          DCD      0x4000080c
                  |L1.2212|
                          DCD      VoltageMotor
                  |L1.2216|
                          DCD      SpeedMotor
                  |L1.2220|
                          DCD      DirX
                  |L1.2224|
                          DCD      i_value
                  |L1.2228|
                          DCD      d_value
                  |L1.2232|
                          DCD      LaserPos
                  |L1.2236|
                          DCD      indxmem
                  |L1.2240|
                          DCD      OldLaserPos
                  |L1.2244|
                          DCD      DebCNT1
                  |L1.2248|
0008c8  0d0a2536          DCB      "\r\n%6d %6d %8x",0
0008cc  64202536
0008d0  64202538
0008d4  7800    
0008d6  00                DCB      0
0008d7  00                DCB      0
                  |L1.2264|
                          DCD      0xffffebb4
                  |L1.2268|
                          DCD      SpeedX
                          ENDP

                  MoveCMD PROC
;;;184    
;;;185    void MoveCMD(char *ptr,uint cnt){		//   .
0008e0  e92d41fc          PUSH     {r2-r8,lr}
0008e4  4606              MOV      r6,r0
0008e6  460f              MOV      r7,r1
;;;186    // ----------------------------------------------	
;;;187    char cmd, chr;
;;;188    int prm,cntp;
;;;189    
;;;190    	cntp=sscanf(ptr,"%c%d",&cmd,&prm);
0008e8  466b              MOV      r3,sp
0008ea  aa01              ADD      r2,sp,#4
0008ec  a1fe              ADR      r1,|L1.3304|
0008ee  4630              MOV      r0,r6
0008f0  f7fffffe          BL       __0sscanf
0008f4  4605              MOV      r5,r0
;;;191    //printf("\r\nM %d,%c,%d,%d,%d",cntp,cmd,prm1,prm2,prm3);
;;;192    	 
;;;193    	 chr=cmd;
0008f6  f89d4004          LDRB     r4,[sp,#4]
;;;194    if	(cntp==1){
0008fa  2d01              CMP      r5,#1
0008fc  d109              BNE      |L1.2322|
;;;195     if      (chr=='s') StopMove();
0008fe  2c73              CMP      r4,#0x73
000900  d102              BNE      |L1.2312|
000902  f7fffffe          BL       StopMove
000906  e01d              B        |L1.2372|
                  |L1.2312|
;;;196     else if (chr=='h') CaretToHome();
000908  2c68              CMP      r4,#0x68
00090a  d11b              BNE      |L1.2372|
00090c  f7fffffe          BL       CaretToHome
000910  e018              B        |L1.2372|
                  |L1.2322|
;;;197     }
;;;198    else if	(cntp==2){
000912  2d02              CMP      r5,#2
000914  d116              BNE      |L1.2372|
;;;199     if      (chr=='Y') AbsMoveY(prm);
000916  2c59              CMP      r4,#0x59
000918  d103              BNE      |L1.2338|
00091a  9800              LDR      r0,[sp,#0]
00091c  f7fffffe          BL       AbsMoveY
000920  e010              B        |L1.2372|
                  |L1.2338|
;;;200     else if (chr=='X') AbsMoveX(prm);
000922  2c58              CMP      r4,#0x58
000924  d103              BNE      |L1.2350|
000926  9800              LDR      r0,[sp,#0]
000928  f7fffffe          BL       AbsMoveX
00092c  e00a              B        |L1.2372|
                  |L1.2350|
;;;201     else if (chr=='y') StepYCMD(prm);
00092e  2c79              CMP      r4,#0x79
000930  d103              BNE      |L1.2362|
000932  9800              LDR      r0,[sp,#0]
000934  f7fffffe          BL       StepYCMD
000938  e004              B        |L1.2372|
                  |L1.2362|
;;;202     else if (chr=='x') StepXCMD(prm);
00093a  2c78              CMP      r4,#0x78
00093c  d102              BNE      |L1.2372|
00093e  9800              LDR      r0,[sp,#0]
000940  f7fffffe          BL       StepXCMD
                  |L1.2372|
;;;203     }	 
;;;204    } // --------------------------------------------
000944  e8bd81fc          POP      {r2-r8,pc}
;;;15     #include "src\laser.c"
                          ENDP

                  SetBuffer PROC
;;;15     }// ---------------------------------------------
;;;16     void SetBuffer(char *ptr,uint cnt){		//    ..
000948  b538              PUSH     {r3-r5,lr}
00094a  4604              MOV      r4,r0
00094c  460d              MOV      r5,r1
;;;17     // ----------------------------------------------
;;;18     uint val;
;;;19      if (sscanf(ptr,"%d",&val)==1)
00094e  466a              MOV      r2,sp
000950  a1e7              ADR      r1,|L1.3312|
000952  4620              MOV      r0,r4
000954  f7fffffe          BL       __0sscanf
000958  2801              CMP      r0,#1
00095a  d11b              BNE      |L1.2452|
;;;20      {
;;;21      if (val==0)		ActBuffer=lbuf0;
00095c  9800              LDR      r0,[sp,#0]
00095e  b918              CBNZ     r0,|L1.2408|
000960  48e4              LDR      r0,|L1.3316|
000962  49e5              LDR      r1,|L1.3320|
000964  6008              STR      r0,[r1,#0]  ; ActBuffer
000966  e013              B        |L1.2448|
                  |L1.2408|
;;;22      else if (val==1)	ActBuffer=lbuf1;
000968  9800              LDR      r0,[sp,#0]
00096a  2801              CMP      r0,#1
00096c  d103              BNE      |L1.2422|
00096e  48e3              LDR      r0,|L1.3324|
000970  49e1              LDR      r1,|L1.3320|
000972  6008              STR      r0,[r1,#0]  ; ActBuffer
000974  e00c              B        |L1.2448|
                  |L1.2422|
;;;23      else if (val==2)	ActBuffer=lbuf2;
000976  9800              LDR      r0,[sp,#0]
000978  2802              CMP      r0,#2
00097a  d103              BNE      |L1.2436|
00097c  48e0              LDR      r0,|L1.3328|
00097e  49de              LDR      r1,|L1.3320|
000980  6008              STR      r0,[r1,#0]  ; ActBuffer
000982  e005              B        |L1.2448|
                  |L1.2436|
;;;24      else if (val==3)	ActBuffer=lbuf3;
000984  9800              LDR      r0,[sp,#0]
000986  2803              CMP      r0,#3
000988  d102              BNE      |L1.2448|
00098a  48de              LDR      r0,|L1.3332|
00098c  49da              LDR      r1,|L1.3320|
00098e  6008              STR      r0,[r1,#0]  ; ActBuffer
                  |L1.2448|
;;;25     	ASK();					//   .
000990  f7fffffe          BL       ASK
                  |L1.2452|
;;;26      }
;;;27     } // --------------------------------------------
000994  bd38              POP      {r3-r5,pc}
;;;28     
                          ENDP

                  FlashLaser PROC
;;;29     void FlashLaser(){				//        "1".
000996  b570              PUSH     {r4-r6,lr}
;;;30     // ----------------------------------------------	
;;;31     int i=CurrLaserPos;
000998  48db              LDR      r0,|L1.3336|
00099a  6804              LDR      r4,[r0,#0]  ; lbufinfo
;;;32     char cbyte;
;;;33     // char *pbuf;
;;;34      if	((i>=0)&&(i<MaxPixelLL))		//    .
00099c  2c00              CMP      r4,#0
00099e  db1b              BLT      |L1.2520|
0009a0  f241404c          MOV      r0,#0x144c
0009a4  4284              CMP      r4,r0
0009a6  da17              BGE      |L1.2520|
;;;35      {	 
;;;36     	cbyte=ActBuffer[i>>3];			//    .
0009a8  48d3              LDR      r0,|L1.3320|
0009aa  6800              LDR      r0,[r0,#0]  ; ActBuffer
0009ac  eb0000e4          ADD      r0,r0,r4,ASR #3
0009b0  7805              LDRB     r5,[r0,#0]
;;;37     	i=(0x80>>(i&7));			//  .
0009b2  f0040107          AND      r1,r4,#7
0009b6  2080              MOVS     r0,#0x80
0009b8  fa40f401          ASR      r4,r0,r1
;;;38       if	(cbyte&i) LaserOn();			// ,    "1"
0009bc  4225              TST      r5,r4
0009be  d008              BEQ      |L1.2514|
0009c0  bf00              NOP      
0009c2  2003              MOVS     r0,#3
0009c4  49d1              LDR      r1,|L1.3340|
0009c6  6008              STR      r0,[r1,#0]
0009c8  2001              MOVS     r0,#1
0009ca  49d1              LDR      r1,|L1.3344|
0009cc  6008              STR      r0,[r1,#0]  ; LsrState
0009ce  bf00              NOP      
0009d0  e004              B        |L1.2524|
                  |L1.2514|
;;;39       else	LaserOff();
0009d2  f7fffffe          BL       LaserOff
0009d6  e001              B        |L1.2524|
                  |L1.2520|
;;;40      }
;;;41      else	LaserOff();
0009d8  f7fffffe          BL       LaserOff
                  |L1.2524|
;;;42     } // --------------------------------------------
0009dc  bd70              POP      {r4-r6,pc}
;;;43     void LaserPWM(uint val){			//      (0.2%-100%).
                          ENDP

                  LaserPWM PROC
0009de  f04f4280          MOV      r2,#0x40000000
;;;44     // ----------------------------------------------
;;;45     		//    .
;;;46     	
;;;47     	TLSR->CCR1=val;				//  .
0009e2  8690              STRH     r0,[r2,#0x34]
;;;48     	TLSR->CCR2=val;				//  .
0009e4  8710              STRH     r0,[r2,#0x38]
;;;49     	TLSR->CCR3=val;				//  .
0009e6  8790              STRH     r0,[r2,#0x3c]
;;;50     	TLSR->CCR4=val;				//  .
0009e8  4aca              LDR      r2,|L1.3348|
0009ea  8010              STRH     r0,[r2,#0]
;;;51     	
;;;52     	portLsr_CR &=~(
0009ec  49ca              LDR      r1,|L1.3352|
0009ee  6809              LDR      r1,[r1,#0]
0009f0  f36f010f          BFC      r1,#0,#16
0009f4  4ac8              LDR      r2,|L1.3352|
0009f6  6011              STR      r1,[r2,#0]
;;;53     		(PinCR(pinLsr0,GPIOCR))|	//   .
;;;54     		(PinCR(pinLsr1,GPIOCR))|
;;;55     		(PinCR(pinLsr2,GPIOCR))|
;;;56     		(PinCR(pinLsr3,GPIOCR))
;;;57     		);
;;;58     	portLsr_CR |=(
0009f8  4611              MOV      r1,r2
0009fa  6809              LDR      r1,[r1,#0]
0009fc  f64b32bb          MOV      r2,#0xbbbb
000a00  ea410102          ORR      r1,r1,r2
000a04  4ac4              LDR      r2,|L1.3352|
000a06  6011              STR      r1,[r2,#0]
;;;59     		(PinCR(pinLsr0,p_a_p50))|	//  .
;;;60     		(PinCR(pinLsr1,p_a_p50))|
;;;61     		(PinCR(pinLsr2,p_a_p50))|
;;;62     		(PinCR(pinLsr3,p_a_p50))
;;;63     		);
;;;64     	
;;;65     //	printf ("\r\npinl %x npinh %x m1 %x m2 %x enable %x",portLsr->CRL,portLsr->CRH, TLSR->CCMR1, TLSR->CCMR2,TLSR->CCER);
;;;66     	
;;;67     } // --------------------------------------------
000a08  4770              BX       lr
;;;68     void LaserOffPWM(){				// /  .
                          ENDP

                  LaserOffPWM PROC
000a0a  b510              PUSH     {r4,lr}
;;;69     // ----------------------------------------------	
;;;70     	//    GPIO .
;;;71     
;;;72     	portLsr_CR &=~(
000a0c  48c2              LDR      r0,|L1.3352|
000a0e  6800              LDR      r0,[r0,#0]
000a10  f36f000f          BFC      r0,#0,#16
000a14  49c0              LDR      r1,|L1.3352|
000a16  6008              STR      r0,[r1,#0]
;;;73     		(PinCR(pinLsr0,GPIOCR))|	//   .
;;;74     		(PinCR(pinLsr1,GPIOCR))|
;;;75     		(PinCR(pinLsr2,GPIOCR))|
;;;76     		(PinCR(pinLsr3,GPIOCR))
;;;77     	);
;;;78     	portLsr_CR |=(
000a18  4608              MOV      r0,r1
000a1a  6800              LDR      r0,[r0,#0]
000a1c  f2433133          MOV      r1,#0x3333
000a20  4308              ORRS     r0,r0,r1
000a22  49bd              LDR      r1,|L1.3352|
000a24  6008              STR      r0,[r1,#0]
;;;79     		(PinCR(pinLsr0,p_o_p50))|	//   .
;;;80     		(PinCR(pinLsr1,p_o_p50))|
;;;81     		(PinCR(pinLsr2,p_o_p50))|
;;;82     		(PinCR(pinLsr3,p_o_p50))
;;;83     	);
;;;84     	LaserOff();
000a26  f7fffffe          BL       LaserOff
;;;85     } // --------------------------------------------
000a2a  bd10              POP      {r4,pc}
;;;86     void LaserCTRL(uint val){			// /  .
                          ENDP

                  LaserCTRL PROC
000a2c  b510              PUSH     {r4,lr}
000a2e  4604              MOV      r4,r0
;;;87     // ----------------------------------------------	
;;;88     //printf("\r\nLaserCTRL %d ",val);
;;;89     	Laser=val;
000a30  48ba              LDR      r0,|L1.3356|
000a32  6004              STR      r4,[r0,#0]  ; Laser
;;;90      if (val<=1)		LaserOffPWM();
000a34  2c01              CMP      r4,#1
000a36  d802              BHI      |L1.2622|
000a38  f7fffffe          BL       LaserOffPWM
000a3c  e008              B        |L1.2640|
                  |L1.2622|
;;;91      else if (val==2)	LaserPWM(1);
000a3e  2c02              CMP      r4,#2
000a40  d103              BNE      |L1.2634|
000a42  2001              MOVS     r0,#1
000a44  f7fffffe          BL       LaserPWM
000a48  e002              B        |L1.2640|
                  |L1.2634|
;;;92      else			LaserPWM(val);
000a4a  4620              MOV      r0,r4
000a4c  f7fffffe          BL       LaserPWM
                  |L1.2640|
;;;93     } // --------------------------------------------
000a50  bd10              POP      {r4,pc}
;;;94     void LaserCMD (char *ptr,uint cnt){		//  .
                          ENDP

                  LaserCMD PROC
000a52  b5f8              PUSH     {r3-r7,lr}
000a54  4604              MOV      r4,r0
000a56  460e              MOV      r6,r1
;;;95     // ----------------------------------------------
;;;96     uint val=0; uint cntp;
000a58  2000              MOVS     r0,#0
000a5a  9000              STR      r0,[sp,#0]
;;;97     
;;;98     	cntp=sscanf(ptr,"%d",&val);
000a5c  466a              MOV      r2,sp
000a5e  a1a4              ADR      r1,|L1.3312|
000a60  4620              MOV      r0,r4
000a62  f7fffffe          BL       __0sscanf
000a66  4605              MOV      r5,r0
;;;99     if	(cntp) LaserCTRL(val);
000a68  b115              CBZ      r5,|L1.2672|
000a6a  9800              LDR      r0,[sp,#0]
000a6c  f7fffffe          BL       LaserCTRL
                  |L1.2672|
;;;100    	ASK();					//   .
000a70  f7fffffe          BL       ASK
;;;101    }// ---------------------------------------------
000a74  bdf8              POP      {r3-r7,pc}
;;;102    
                          ENDP

                  InitLaser PROC
;;;103    void InitLaser(){				//   .
000a76  48aa              LDR      r0,|L1.3360|
;;;104    // ----------------------------------------------
;;;105    	SET_PER_LSR				// , .
000a78  69c0              LDR      r0,[r0,#0x1c]
000a7a  f0400001          ORR      r0,r0,#1
000a7e  49a8              LDR      r1,|L1.3360|
000a80  61c8              STR      r0,[r1,#0x1c]
000a82  48a8              LDR      r0,|L1.3364|
000a84  6840              LDR      r0,[r0,#4]
000a86  49a7              LDR      r1,|L1.3364|
000a88  6048              STR      r0,[r1,#4]
;;;106    	
;;;107    	TLSR->PSC = (TLSR_CK/LSR_FREQ/LSR_RES-1);	// .
000a8a  208f              MOVS     r0,#0x8f
000a8c  0389              LSLS     r1,r1,#14
000a8e  8508              STRH     r0,[r1,#0x28]
;;;108    	TLSR->ARR = (LSR_RES-1);		//  .
000a90  f24030e7          MOV      r0,#0x3e7
000a94  8588              STRH     r0,[r1,#0x2c]
;;;109    	
;;;110    	TLSR->CCMR1=	(TIM_CCMR1_OC1M_1|
000a96  f2460060          MOV      r0,#0x6060
000a9a  8308              STRH     r0,[r1,#0x18]
;;;111    			 TIM_CCMR1_OC1M_2|
;;;112    			 TIM_CCMR1_OC2M_1|
;;;113    			 TIM_CCMR1_OC2M_2);	//   6.  1  2
;;;114    			 
;;;115    	TLSR->CCMR2=	(TIM_CCMR2_OC3M_1|
000a9c  8388              STRH     r0,[r1,#0x1c]
;;;116    			 TIM_CCMR2_OC3M_2|
;;;117    			 TIM_CCMR2_OC4M_1|
;;;118    			 TIM_CCMR2_OC4M_2);	//   6.  3  4
;;;119    			 
;;;120    	TLSR->CCER =	(TIM_CCER_CC1E|		// CCE channel 1
000a9e  f2411011          MOV      r0,#0x1111
000aa2  8408              STRH     r0,[r1,#0x20]
;;;121    			 TIM_CCER_CC2E|		// CCE channel 2
;;;122    			 TIM_CCER_CC3E|		// CCE channel 3
;;;123    			 TIM_CCER_CC4E);	// CCE channel 4
;;;124    	TLSR->CR1 |= 	TIM_CR1_CEN;		//  .
000aa4  0780              LSLS     r0,r0,#30
000aa6  8800              LDRH     r0,[r0,#0]
000aa8  f0400001          ORR      r0,r0,#1
000aac  8008              STRH     r0,[r1,#0]
;;;125    //------
;;;126    	TLSR->CCR1=0x0;				//  .
000aae  2000              MOVS     r0,#0
000ab0  8688              STRH     r0,[r1,#0x34]
;;;127    	TLSR->CCR2=0x0;				//  .
000ab2  8708              STRH     r0,[r1,#0x38]
;;;128    	TLSR->CCR3=0x0;				//  .
000ab4  8788              STRH     r0,[r1,#0x3c]
;;;129    	TLSR->CCR4=0x0;				//  .
000ab6  4997              LDR      r1,|L1.3348|
000ab8  8008              STRH     r0,[r1,#0]
;;;130    	
;;;131    //	printf ("\r\npinl %x npinh %x m1 %x m2 %x enable %x",portLsr->CRL,portLsr->CRH, TLSR->CCMR1, TLSR->CCMR2,TLSR->CCER);
;;;132    	
;;;133    } // --------------------------------------------
000aba  4770              BX       lr
;;;16     #include "src\capture.c"
                          ENDP

                  ChangeLaserPos PROC
;;;37     }; // -------------------------------------------
;;;38     void ChangeLaserPos (uint sti){			//   .
000abc  b500              PUSH     {lr}
000abe  4602              MOV      r2,r0
;;;39     // ----------------------------------------------	
;;;40     	sti=((sti&(TIM_SR_CC1IF|TIM_SR_CC2IF|	//   .
000ac0  f002001e          AND      r0,r2,#0x1e
000ac4  0042              LSLS     r2,r0,#1
;;;41     	TIM_SR_CC3IF|TIM_SR_CC4IF))<<1);	//    00xx xx00
;;;42      if ((portENC1->IDR)&(1<<pinEnc1)) sti|=1;
000ac6  4898              LDR      r0,|L1.3368|
000ac8  6800              LDR      r0,[r0,#0]
000aca  f0100f40          TST      r0,#0x40
000ace  d001              BEQ      |L1.2772|
000ad0  f0420201          ORR      r2,r2,#1
                  |L1.2772|
;;;43      if ((portENC2->IDR)&(1<<pinEnc2)) sti|=2;	//  6  . 00iiiiPP
000ad4  4894              LDR      r0,|L1.3368|
000ad6  6800              LDR      r0,[r0,#0]
000ad8  f4107f80          TST      r0,#0x100
000adc  d001              BEQ      |L1.2786|
000ade  f0420202          ORR      r2,r2,#2
                  |L1.2786|
;;;44     	EncDir=tab_enc[sti];			//   .
000ae2  4892              LDR      r0,|L1.3372|
000ae4  5680              LDRSB    r0,[r0,r2]
000ae6  4992              LDR      r1,|L1.3376|
000ae8  6008              STR      r0,[r1,#0]  ; EncDir
;;;45     	CurrLaserPos+=EncDir;
000aea  4887              LDR      r0,|L1.3336|
000aec  6800              LDR      r0,[r0,#0]  ; lbufinfo
000aee  6809              LDR      r1,[r1,#0]  ; EncDir
000af0  4408              ADD      r0,r0,r1
000af2  4985              LDR      r1,|L1.3336|
000af4  6008              STR      r0,[r1,#0]  ; lbufinfo
;;;46      if (EncDir!=0) UpdateTOT();			//   -  -.
000af6  488e              LDR      r0,|L1.3376|
000af8  6800              LDR      r0,[r0,#0]  ; EncDir
000afa  b108              CBZ      r0,|L1.2816|
000afc  f7fffffe          BL       UpdateTOT
                  |L1.2816|
;;;47      
;;;48     if (EncDir==0) DebCNT1+=DebCNT1;	//  .	
000b00  488b              LDR      r0,|L1.3376|
000b02  6800              LDR      r0,[r0,#0]  ; EncDir
000b04  b920              CBNZ     r0,|L1.2832|
000b06  488b              LDR      r0,|L1.3380|
000b08  6800              LDR      r0,[r0,#0]  ; DebCNT1
000b0a  0040              LSLS     r0,r0,#1
000b0c  4989              LDR      r1,|L1.3380|
000b0e  6008              STR      r0,[r1,#0]  ; DebCNT1
                  |L1.2832|
;;;49      if (fDebug)
000b10  4889              LDR      r0,|L1.3384|
000b12  6800              LDR      r0,[r0,#0]  ; fDebug
000b14  b168              CBZ      r0,|L1.2866|
;;;50      {	
;;;51       if (!CurrLaserPos)
000b16  487c              LDR      r0,|L1.3336|
000b18  6800              LDR      r0,[r0,#0]  ; lbufinfo
000b1a  b950              CBNZ     r0,|L1.2866|
;;;52       {	
;;;53     	SpBuf[indxmem-1]=0;
000b1c  2100              MOVS     r1,#0
000b1e  4887              LDR      r0,|L1.3388|
000b20  6800              LDR      r0,[r0,#0]  ; indxmem
000b22  1e40              SUBS     r0,r0,#1
000b24  4b86              LDR      r3,|L1.3392|
000b26  5419              STRB     r1,[r3,r0]
;;;54     	SpBuf1[indxmem-1]=0;
000b28  4884              LDR      r0,|L1.3388|
000b2a  6800              LDR      r0,[r0,#0]  ; indxmem
000b2c  1e40              SUBS     r0,r0,#1
000b2e  4b85              LDR      r3,|L1.3396|
000b30  5419              STRB     r1,[r3,r0]
                  |L1.2866|
;;;55       }
;;;56      }
;;;57     } // --------------------------------------------
000b32  bd00              POP      {pc}
;;;58     void SpeedRegulator(uint cspd){			//  .
                          ENDP

                  SpeedRegulator PROC
000b34  e92d41f0          PUSH     {r4-r8,lr}
000b38  4604              MOV      r4,r0
;;;59     
;;;60     //int	vm,serr,ival,dval;
;;;61     int	vm,serr,ival;
;;;62     
;;;63     //	CapCCR=cspd;				//   .
;;;64     	vm=VoltageMotor;			//   .
000b3a  4883              LDR      r0,|L1.3400|
000b3c  6805              LDR      r5,[r0,#0]  ; VoltageMotor
;;;65     	ival=i_value;
000b3e  4883              LDR      r0,|L1.3404|
000b40  6807              LDR      r7,[r0,#0]  ; i_value
;;;66     //	dval=d_value;		// 
;;;67     	
;;;68       if (!cspd) cspd=1;				//     0.
000b42  b904              CBNZ     r4,|L1.2886|
000b44  2401              MOVS     r4,#1
                  |L1.2886|
;;;69     	cspd=FTCAP/10*254*4/ResolX/cspd;	//  /.
000b46  4882              LDR      r0,|L1.3408|
000b48  fbb0f4f4          UDIV     r4,r0,r4
;;;70     // if (LsrState)	AvrgSpd=cspd;			//   .
;;;71     	AvrgSpd=cspd;				//   .
000b4c  486e              LDR      r0,|L1.3336|
000b4e  6084              STR      r4,[r0,#8]  ; lbufinfo
;;;72     	serr=SpeedMotor-cspd;			//   .
000b50  4880              LDR      r0,|L1.3412|
000b52  6800              LDR      r0,[r0,#0]  ; SpeedMotor
000b54  1b06              SUBS     r6,r0,r4
;;;73     //if (vm<MAX_PWM)				//  .  ?
;;;74     // {
;;;75     	ival+=serr;				//    .
000b56  4437              ADD      r7,r7,r6
;;;76     //	dval=serr-d_value;			//    .
;;;77     // }	
;;;78     //	vm = serr/2 + i_value/128 + MIN_PWM;
;;;79     //	vm = ((serr*k_prp)+(ival*k_int)-(dval*k_dif))/k_com + MIN_PWM;
;;;80     	vm = ((serr*k_prp)+(ival*k_int))/k_com+MIN_PWM;
000b58  487f              LDR      r0,|L1.3416|
000b5a  6800              LDR      r0,[r0,#0]  ; k_prp
000b5c  4370              MULS     r0,r6,r0
000b5e  497f              LDR      r1,|L1.3420|
000b60  6809              LDR      r1,[r1,#0]  ; k_int
000b62  fb070001          MLA      r0,r7,r1,r0
000b66  497e              LDR      r1,|L1.3424|
000b68  6809              LDR      r1,[r1,#0]  ; k_com
000b6a  fb90f0f1          SDIV     r0,r0,r1
000b6e  f1000566          ADD      r5,r0,#0x66
;;;81     	
;;;82       if (vm>MAX_PWM) vm=MAX_PWM;			//    .
000b72  2dff              CMP      r5,#0xff
000b74  dd01              BLE      |L1.2938|
000b76  25ff              MOVS     r5,#0xff
000b78  e002              B        |L1.2944|
                  |L1.2938|
;;;83       else if (vm<(MIN_PWM)) vm=MIN_PWM;
000b7a  2d66              CMP      r5,#0x66
000b7c  da00              BGE      |L1.2944|
000b7e  2566              MOVS     r5,#0x66
                  |L1.2944|
;;;84     	VoltageMotor=vm; PWM_Set(vm);
000b80  4871              LDR      r0,|L1.3400|
000b82  6005              STR      r5,[r0,#0]  ; VoltageMotor
000b84  b2a8              UXTH     r0,r5
000b86  f7fffffe          BL       PWM_Set
;;;85     	i_value=ival;
000b8a  4870              LDR      r0,|L1.3404|
000b8c  6007              STR      r7,[r0,#0]  ; i_value
;;;86     //	d_value=serr;		// 
;;;87     } // --------------------------------------------
000b8e  e8bd81f0          POP      {r4-r8,pc}
;;;88     void CheckStop(){				//    .
                          ENDP

                  CheckStop PROC
000b92  b510              PUSH     {r4,lr}
;;;89     
;;;90     if 	(TPWM->CCR1)				//    ?
000b94  4873              LDR      r0,|L1.3428|
000b96  8800              LDRH     r0,[r0,#0]
000b98  b1a0              CBZ      r0,|L1.3012|
;;;91      {
;;;92      if (DirX<0)
000b9a  4873              LDR      r0,|L1.3432|
000b9c  6800              LDR      r0,[r0,#0]  ; DirX
000b9e  2800              CMP      r0,#0
000ba0  da08              BGE      |L1.2996|
;;;93       {
;;;94       if (CurrLaserPos<=LaserPos) MotorBreak();
000ba2  4859              LDR      r0,|L1.3336|
000ba4  6800              LDR      r0,[r0,#0]  ; lbufinfo
000ba6  4971              LDR      r1,|L1.3436|
000ba8  6809              LDR      r1,[r1,#0]  ; LaserPos
000baa  4288              CMP      r0,r1
000bac  dc0a              BGT      |L1.3012|
000bae  f7fffffe          BL       MotorBreak
000bb2  e007              B        |L1.3012|
                  |L1.2996|
;;;95       }
;;;96      else if (CurrLaserPos>=LaserPos) MotorBreak();
000bb4  4854              LDR      r0,|L1.3336|
000bb6  6800              LDR      r0,[r0,#0]  ; lbufinfo
000bb8  496c              LDR      r1,|L1.3436|
000bba  6809              LDR      r1,[r1,#0]  ; LaserPos
000bbc  4288              CMP      r0,r1
000bbe  db01              BLT      |L1.3012|
000bc0  f7fffffe          BL       MotorBreak
                  |L1.3012|
;;;97      }
;;;98     } // --------------------------------------------
000bc4  bd10              POP      {r4,pc}
;;;99     void SavePID(char *ptr,uint cnt){		//    .
                          ENDP

                  SavePID PROC
000bc6  b57c              PUSH     {r2-r6,lr}
000bc8  4604              MOV      r4,r0
000bca  460d              MOV      r5,r1
;;;100    // ----------------------------------------------	
;;;101    char cmd;
;;;102    int prm;
;;;103    
;;;104     if (sscanf(ptr,"%c%d",&cmd,&prm)==2)
000bcc  466b              MOV      r3,sp
000bce  aa01              ADD      r2,sp,#4
000bd0  a145              ADR      r1,|L1.3304|
000bd2  4620              MOV      r0,r4
000bd4  f7fffffe          BL       __0sscanf
000bd8  2802              CMP      r0,#2
000bda  d120              BNE      |L1.3102|
;;;105    //printf("\r\nM %d,%c,%d,%d,%d",cntp,cmd,prm1,prm2,prm3);
;;;106     {
;;;107      if      (cmd=='p') k_prp=prm;			//   .  .
000bdc  f89d0004          LDRB     r0,[sp,#4]
000be0  2870              CMP      r0,#0x70
000be2  d103              BNE      |L1.3052|
000be4  495c              LDR      r1,|L1.3416|
000be6  9800              LDR      r0,[sp,#0]
000be8  6008              STR      r0,[r1,#0]  ; k_prp
000bea  e016              B        |L1.3098|
                  |L1.3052|
;;;108      else if (cmd=='i') k_int=prm;			//     .
000bec  f89d0004          LDRB     r0,[sp,#4]
000bf0  2869              CMP      r0,#0x69
000bf2  d103              BNE      |L1.3068|
000bf4  4959              LDR      r1,|L1.3420|
000bf6  9800              LDR      r0,[sp,#0]
000bf8  6008              STR      r0,[r1,#0]  ; k_int
000bfa  e00e              B        |L1.3098|
                  |L1.3068|
;;;109      else if (cmd=='d') k_dif=prm;			//     .
000bfc  f89d0004          LDRB     r0,[sp,#4]
000c00  2864              CMP      r0,#0x64
000c02  d103              BNE      |L1.3084|
000c04  495a              LDR      r1,|L1.3440|
000c06  9800              LDR      r0,[sp,#0]
000c08  6008              STR      r0,[r1,#0]  ; k_dif
000c0a  e006              B        |L1.3098|
                  |L1.3084|
;;;110      else if (cmd=='c') k_com=prm;			//     .
000c0c  f89d0004          LDRB     r0,[sp,#4]
000c10  2863              CMP      r0,#0x63
000c12  d102              BNE      |L1.3098|
000c14  4952              LDR      r1,|L1.3424|
000c16  9800              LDR      r0,[sp,#0]
000c18  6008              STR      r0,[r1,#0]  ; k_com
                  |L1.3098|
;;;111    	ASK();					//   .
000c1a  f7fffffe          BL       ASK
                  |L1.3102|
;;;112     }
;;;113    } // --------------------------------------------
000c1e  bd7c              POP      {r2-r6,pc}
;;;114    void TCAP_IRQ(){				//    .
                          ENDP

                  TIM4_IRQHandler PROC
000c20  b570              PUSH     {r4-r6,lr}
;;;115    // ----------------------------------------------
;;;116    uint sti, cspd;
;;;117    TIM_TypeDef *timptr=TCAP;
000c22  4d54              LDR      r5,|L1.3444|
;;;118    
;;;119    	sti=timptr->SR;	timptr->SR=0;		//  .    .
000c24  8a2c              LDRH     r4,[r5,#0x10]
000c26  2000              MOVS     r0,#0
000c28  8228              STRH     r0,[r5,#0x10]
;;;120    	cspd=0xFFFFFFF;				//   -   .
000c2a  f06f4670          MVN      r6,#0xf0000000
;;;121     if (sti&TIM_SR_UIF) CapNCCR=0;			//   ,   .
000c2e  f0140f01          TST      r4,#1
000c32  d001              BEQ      |L1.3128|
000c34  4950              LDR      r1,|L1.3448|
000c36  6008              STR      r0,[r1,#0]  ; CapNCCR
                  |L1.3128|
;;;122     if (sti&TIM_SR_CC1IF)				//      .
000c38  f0140f02          TST      r4,#2
000c3c  d00e              BEQ      |L1.3164|
;;;123     {
;;;124    	CapCNT=timptr->CNT;			//      .
000c3e  8ca8              LDRH     r0,[r5,#0x24]
000c40  494e              LDR      r1,|L1.3452|
000c42  6008              STR      r0,[r1,#0]  ; CapCNT
;;;125    	timptr->CNT=0;				//  .
000c44  2000              MOVS     r0,#0
000c46  84a8              STRH     r0,[r5,#0x24]
;;;126    	CapNCCR++;				//     .
000c48  484b              LDR      r0,|L1.3448|
000c4a  6800              LDR      r0,[r0,#0]  ; CapNCCR
000c4c  1c40              ADDS     r0,r0,#1
000c4e  494a              LDR      r1,|L1.3448|
000c50  6008              STR      r0,[r1,#0]  ; CapNCCR
;;;127      if (CapNCCR>1)cspd=timptr->CCR1;		//         .
000c52  4608              MOV      r0,r1
000c54  6800              LDR      r0,[r0,#0]  ; CapNCCR
000c56  2801              CMP      r0,#1
000c58  d900              BLS      |L1.3164|
000c5a  8eae              LDRH     r6,[r5,#0x34]
                  |L1.3164|
;;;128     } 
;;;129     if (sti&(TIM_SR_CC1IF|TIM_SR_CC2IF|TIM_SR_CC3IF|TIM_SR_CC4IF))	//     .
000c5c  f0140f1e          TST      r4,#0x1e
000c60  d00a              BEQ      |L1.3192|
;;;130     {
;;;131    	ChangeLaserPos(sti);			//   .
000c62  4620              MOV      r0,r4
000c64  f7fffffe          BL       ChangeLaserPos
;;;132      if (Laser==1) FlashLaser();			//  .
000c68  482c              LDR      r0,|L1.3356|
000c6a  6800              LDR      r0,[r0,#0]  ; Laser
000c6c  2801              CMP      r0,#1
000c6e  d101              BNE      |L1.3188|
000c70  f7fffffe          BL       FlashLaser
                  |L1.3188|
;;;133    	CheckStop();				//     .
000c74  f7fffffe          BL       CheckStop
                  |L1.3192|
;;;134     }
;;;135     if (sti&(TIM_SR_CC1IF|TIM_SR_UIF))		//       .
000c78  f0140f03          TST      r4,#3
000c7c  d032              BEQ      |L1.3300|
;;;136     {
;;;137      if (SpeedMotor) SpeedRegulator(cspd);		//  .
000c7e  4835              LDR      r0,|L1.3412|
000c80  6800              LDR      r0,[r0,#0]  ; SpeedMotor
000c82  b110              CBZ      r0,|L1.3210|
000c84  4630              MOV      r0,r6
000c86  f7fffffe          BL       SpeedRegulator
                  |L1.3210|
;;;138      if (fDebug)
000c8a  482b              LDR      r0,|L1.3384|
000c8c  6800              LDR      r0,[r0,#0]  ; fDebug
000c8e  b348              CBZ      r0,|L1.3300|
;;;139      {
;;;140       if (indxmem<sizespbuf/2-1)			//  .
000c90  482a              LDR      r0,|L1.3388|
000c92  6800              LDR      r0,[r0,#0]  ; indxmem
000c94  f24031e7          MOV      r1,#0x3e7
000c98  4288              CMP      r0,r1
000c9a  d276              BCS      |L1.3466|
;;;141       {	
;;;142        if (EncDir>0)
000c9c  4824              LDR      r0,|L1.3376|
000c9e  6800              LDR      r0,[r0,#0]  ; EncDir
000ca0  2800              CMP      r0,#0
000ca2  dd0e              BLE      |L1.3266|
;;;143        {	   
;;;144    	SpBuf[indxmem+0]=FTCAP/10*254/ResolX/cspd;  // speed/4
000ca4  4836              LDR      r0,|L1.3456|
000ca6  fbb0f0f6          UDIV     r0,r0,r6
000caa  b2c1              UXTB     r1,r0
000cac  4a24              LDR      r2,|L1.3392|
000cae  4823              LDR      r0,|L1.3388|
000cb0  6800              LDR      r0,[r0,#0]  ; indxmem
000cb2  5411              STRB     r1,[r2,r0]
;;;145    	SpBuf[indxmem+1]=VoltageMotor;
000cb4  4824              LDR      r0,|L1.3400|
000cb6  7801              LDRB     r1,[r0,#0]  ; VoltageMotor
000cb8  4820              LDR      r0,|L1.3388|
000cba  6800              LDR      r0,[r0,#0]  ; indxmem
000cbc  1c40              ADDS     r0,r0,#1
000cbe  5411              STRB     r1,[r2,r0]
000cc0  e00d              B        |L1.3294|
                  |L1.3266|
;;;146        }	
;;;147        else
;;;148        {
;;;149      	SpBuf1[indxmem+0]=FTCAP/10*254/ResolX/cspd; // speed/4
000cc2  482f              LDR      r0,|L1.3456|
000cc4  fbb0f0f6          UDIV     r0,r0,r6
000cc8  b2c1              UXTB     r1,r0
000cca  4a1e              LDR      r2,|L1.3396|
000ccc  481b              LDR      r0,|L1.3388|
000cce  6800              LDR      r0,[r0,#0]  ; indxmem
000cd0  5411              STRB     r1,[r2,r0]
;;;150    	SpBuf1[indxmem+1]=VoltageMotor;
000cd2  481d              LDR      r0,|L1.3400|
000cd4  7801              LDRB     r1,[r0,#0]  ; VoltageMotor
000cd6  4819              LDR      r0,|L1.3388|
000cd8  6800              LDR      r0,[r0,#0]  ; indxmem
000cda  1c40              ADDS     r0,r0,#1
000cdc  5411              STRB     r1,[r2,r0]
                  |L1.3294|
;;;151        }
;;;152    	indxmem+=2;
000cde  4817              LDR      r0,|L1.3388|
000ce0  6800              LDR      r0,[r0,#0]  ; indxmem
000ce2  e04f              B        |L1.3460|
                  |L1.3300|
000ce4  e051              B        |L1.3466|
000ce6  0000              DCW      0x0000
                  |L1.3304|
000ce8  25632564          DCB      "%c%d",0
000cec  00      
000ced  00                DCB      0
000cee  00                DCB      0
000cef  00                DCB      0
                  |L1.3312|
000cf0  256400            DCB      "%d",0
000cf3  00                DCB      0
                  |L1.3316|
                          DCD      lbuf0
                  |L1.3320|
                          DCD      ActBuffer
                  |L1.3324|
                          DCD      lbuf1
                  |L1.3328|
                          DCD      lbuf2
                  |L1.3332|
                          DCD      lbuf3
                  |L1.3336|
                          DCD      lbufinfo
                  |L1.3340|
                          DCD      0x40010810
                  |L1.3344|
                          DCD      LsrState
                  |L1.3348|
                          DCD      0x40000040
                  |L1.3352|
                          DCD      0x40010800
                  |L1.3356|
                          DCD      Laser
                  |L1.3360|
                          DCD      0x40021000
                  |L1.3364|
                          DCD      0x40010000
                  |L1.3368|
                          DCD      0x40010c08
                  |L1.3372|
                          DCD      tab_enc
                  |L1.3376|
                          DCD      EncDir
                  |L1.3380|
                          DCD      DebCNT1
                  |L1.3384|
                          DCD      fDebug
                  |L1.3388|
                          DCD      indxmem
                  |L1.3392|
                          DCD      SpBuf
                  |L1.3396|
                          DCD      SpBuf1
                  |L1.3400|
                          DCD      VoltageMotor
                  |L1.3404|
                          DCD      i_value
                  |L1.3408|
                          DCD      0x001f0180
                  |L1.3412|
                          DCD      SpeedMotor
                  |L1.3416|
                          DCD      k_prp
                  |L1.3420|
                          DCD      k_int
                  |L1.3424|
                          DCD      k_com
                  |L1.3428|
                          DCD      0x40012c34
                  |L1.3432|
                          DCD      DirX
                  |L1.3436|
                          DCD      LaserPos
                  |L1.3440|
                          DCD      k_dif
                  |L1.3444|
                          DCD      0x40000800
                  |L1.3448|
                          DCD      CapNCCR
                  |L1.3452|
                          DCD      CapCNT
                  |L1.3456|
                          DCD      0x0007c060
                  |L1.3460|
000d84  1c80              ADDS     r0,r0,#2
000d86  49f7              LDR      r1,|L1.4452|
000d88  6008              STR      r0,[r1,#0]  ; indxmem
                  |L1.3466|
;;;153       }	
;;;154      }
;;;155     }
;;;156    }// ---------------------------------------------
000d8a  bd70              POP      {r4-r6,pc}
;;;157    void TIM_Init_ENC(){				//
                          ENDP

                  TIM_Init_ENC PROC
000d8c  b510              PUSH     {r4,lr}
;;;158    // ----------------------------------------------
;;;159    TIM_TypeDef *timptr=TCAP;
000d8e  4cf6              LDR      r4,|L1.4456|
;;;160    	SET_PER_CAP				//  ,  .
000d90  48f6              LDR      r0,|L1.4460|
000d92  69c0              LDR      r0,[r0,#0x1c]
000d94  f0400004          ORR      r0,r0,#4
000d98  49f4              LDR      r1,|L1.4460|
000d9a  61c8              STR      r0,[r1,#0x1c]
;;;161    	
;;;162    	portENC1->CRL &=~(PinCR(pinEnc1,GPIOCR));
000d9c  48f4              LDR      r0,|L1.4464|
000d9e  6800              LDR      r0,[r0,#0]
000da0  f0206070          BIC      r0,r0,#0xf000000
000da4  49f2              LDR      r1,|L1.4464|
000da6  6008              STR      r0,[r1,#0]
;;;163    	portENC1->CRL |= (PinCR(pinEnc1,p_i_p));//  1    .
000da8  4608              MOV      r0,r1
000daa  6800              LDR      r0,[r0,#0]
000dac  f0406000          ORR      r0,r0,#0x8000000
000db0  6008              STR      r0,[r1,#0]
;;;164    	portENC2->CRL &=~(PinCR(pinEnc2,GPIOCR));		
000db2  4608              MOV      r0,r1
000db4  6800              LDR      r0,[r0,#0]
000db6  f020000f          BIC      r0,r0,#0xf
000dba  6008              STR      r0,[r1,#0]
;;;165    	portENC2->CRL |= (PinCR(pinEnc2,p_i_p));//  2    .
000dbc  4608              MOV      r0,r1
000dbe  6800              LDR      r0,[r0,#0]
000dc0  f0400008          ORR      r0,r0,#8
000dc4  6008              STR      r0,[r1,#0]
;;;166    	
;;;167    	timptr->PSC  =(TCAP_CK/FTCAP-1);	// .
000dc6  2005              MOVS     r0,#5
000dc8  8520              STRH     r0,[r4,#0x28]
;;;168    	timptr->ARR  =(0xFFFF);			//   .
000dca  f64f70ff          MOV      r0,#0xffff
000dce  85a0              STRH     r0,[r4,#0x2c]
;;;169    	timptr->CCMR1 =  (TIM_CCMR1_CC2S_1|
000dd0  f2442041          MOV      r0,#0x4241
000dd4  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|
000dd6  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=  (
000dd8  201e              MOVS     r0,#0x1e
000dda  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.
000ddc  f7fffffe          BL       NVIC_EnableIRQ
;;;186    	
;;;187    	timptr->CCER |= (TIM_CCER_CC4E|
000de0  8c20              LDRH     r0,[r4,#0x20]
000de2  f2431131          MOV      r1,#0x3131
000de6  4308              ORRS     r0,r0,r1
000de8  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;		//  .
000dea  8820              LDRH     r0,[r4,#0]
000dec  f0400001          ORR      r0,r0,#1
000df0  8020              STRH     r0,[r4,#0]
;;;194    	ActBuffer=lbuf0;			//    .
000df2  48e0              LDR      r0,|L1.4468|
000df4  49e0              LDR      r1,|L1.4472|
000df6  6008              STR      r0,[r1,#0]  ; ActBuffer
;;;195    }// ---------------------------------------------
000df8  bd10              POP      {r4,pc}
;;;17     #endif
                          ENDP

                  RemapToRAM PROC
;;;29     }// ---------------------------------------------
;;;30     /* __inline */ void RemapToRAM(){		//
000dfa  2000              MOVS     r0,#0
;;;31     // ----------------------------------------------	
;;;32     	RCC->CIR = 0x00000000;			//  .
000dfc  49db              LDR      r1,|L1.4460|
000dfe  6088              STR      r0,[r1,#8]
;;;33     	SCB->VTOR = SRAM_BASE;			//   .
000e00  0448              LSLS     r0,r1,#17
000e02  49de              LDR      r1,|L1.4476|
000e04  6008              STR      r0,[r1,#0]
;;;34     }// ---------------------------------------------
000e06  4770              BX       lr
;;;35     #include "src\cmd.c"
                          ENDP

                  InitCMD PROC
;;;5      
;;;6      void InitCMD (){				//    .   "N"
000e08  b500              PUSH     {lr}
;;;7      // ----------------------------------------------
;;;8      	ASK();					//   .
000e0a  f7fffffe          BL       ASK
;;;9      	SCB->AIRCR=(0x5FA0000+SCB_AIRCR_SYSRESETREQ);		//     .
000e0e  48dc              LDR      r0,|L1.4480|
000e10  49da              LDR      r1,|L1.4476|
000e12  1d09              ADDS     r1,r1,#4
000e14  6008              STR      r0,[r1,#0]
;;;10     }//______________________________________________
000e16  bd00              POP      {pc}
;;;11     void SetAXS (char *ptr,uint cnt){		//    .   "a"
                          ENDP

                  SetAXS PROC
000e18  b57c              PUSH     {r2-r6,lr}
000e1a  4604              MOV      r4,r0
000e1c  460d              MOV      r5,r1
;;;12     // ----------------------------------------------
;;;13     char chr;
;;;14     int pos;
;;;15     
;;;16     if	(sscanf(ptr,"%c%d", &chr, &pos)==2)
000e1e  466b              MOV      r3,sp
000e20  aa01              ADD      r2,sp,#4
000e22  f2af113c          ADR      r1,|L1.3304|
000e26  4620              MOV      r0,r4
000e28  f7fffffe          BL       __0sscanf
000e2c  2802              CMP      r0,#2
000e2e  d114              BNE      |L1.3674|
;;;17      {
;;;18      if      (chr=='x') CurrLaserPos=CalcStepX(pos);
000e30  f89d0004          LDRB     r0,[sp,#4]
000e34  2878              CMP      r0,#0x78
000e36  d105              BNE      |L1.3652|
000e38  9800              LDR      r0,[sp,#0]
000e3a  f7fffffe          BL       CalcStepX
000e3e  49d1              LDR      r1,|L1.4484|
000e40  6008              STR      r0,[r1,#0]  ; lbufinfo
000e42  e008              B        |L1.3670|
                  |L1.3652|
;;;19      else if (chr=='y') CurrStepPos =CalcStepY(pos);
000e44  f89d0004          LDRB     r0,[sp,#4]
000e48  2879              CMP      r0,#0x79
000e4a  d104              BNE      |L1.3670|
000e4c  9800              LDR      r0,[sp,#0]
000e4e  f7fffffe          BL       CalcStepY
000e52  49cc              LDR      r1,|L1.4484|
000e54  6048              STR      r0,[r1,#4]  ; lbufinfo
                  |L1.3670|
;;;20     	ASK();					//   .
000e56  f7fffffe          BL       ASK
                  |L1.3674|
;;;21      }	
;;;22     }//______________________________________________
000e5a  bd7c              POP      {r2-r6,pc}
;;;23     void ExecCMD(char *ptr, uint cnt){		//    .	  "G2012345"
                          ENDP

                  ExecCMD PROC
000e5c  b538              PUSH     {r3-r5,lr}
000e5e  4604              MOV      r4,r0
000e60  460d              MOV      r5,r1
;;;24     // ----------------------------------------------
;;;25     uint eaddr;	
;;;26     
;;;27      if	(sscanf(ptr,"%x", &eaddr)==1)
000e62  466a              MOV      r2,sp
000e64  a1c8              ADR      r1,|L1.4488|
000e66  4620              MOV      r0,r4
000e68  f7fffffe          BL       __0sscanf
000e6c  2801              CMP      r0,#1
000e6e  d104              BNE      |L1.3706|
;;;28      {
;;;29     	ASK();					//   .
000e70  f7fffffe          BL       ASK
;;;30     	Execute(eaddr);				//  .
000e74  9800              LDR      r0,[sp,#0]
000e76  f7fffffe          BL       Execute
                  |L1.3706|
;;;31      }	
;;;32     }//______________________________________________
000e7a  bd38              POP      {r3-r5,pc}
;;;33     void ReadState(){				//    .	  "I"
                          ENDP

                  ReadState PROC
000e7c  b500              PUSH     {lr}
;;;34     // ----------------------------------------------
;;;35     	SER_PutChar(State);			//    .
000e7e  48c3              LDR      r0,|L1.4492|
000e80  7800              LDRB     r0,[r0,#0]  ; State
000e82  f7fffffe          BL       SER_PutChar
;;;36     }//______________________________________________
000e86  bd00              POP      {pc}
;;;37     void ReadInfo(){				//    .	  "i"
                          ENDP

                  ReadInfo PROC
000e88  b500              PUSH     {lr}
000e8a  b087              SUB      sp,sp,#0x1c
;;;38     // ----------------------------------------------
;;;39     	printf(" -b0 0x%p -b1 0x%p -sz %d -rx %d -ux %d -ry %d -uy %d -pi 0x%p -si %d",
000e8c  202c              MOVS     r0,#0x2c
000e8e  49bd              LDR      r1,|L1.4484|
000e90  f44f727a          MOV      r2,#0x3e8
000e94  f44f73c8          MOV      r3,#0x190
000e98  e9cd3202          STRD     r3,r2,[sp,#8]
000e9c  e9cd1004          STRD     r1,r0,[sp,#0x10]
000ea0  f24620fb          MOV      r0,#0x62fb
000ea4  f44f7116          MOV      r1,#0x258
000ea8  f240238a          MOV      r3,#0x28a
000eac  4ab8              LDR      r2,|L1.4496|
000eae  e9cd1000          STRD     r1,r0,[sp,#0]
000eb2  49b0              LDR      r1,|L1.4468|
000eb4  48b7              LDR      r0,|L1.4500|
000eb6  f7fffffe          BL       __2printf
;;;40     	lbuf0,lbuf1,SizeBufLL,ResolX,UnitX,ResolY,UnitY,&lbufinfo,sizeof lbufinfo);	//  .
;;;41     }//______________________________________________
000eba  b007              ADD      sp,sp,#0x1c
000ebc  bd00              POP      {pc}
;;;42     void ReadCMD(char *ptr,uint cnt){		//    .	  "w012345,4#"
                          ENDP

                  ReadCMD PROC
000ebe  b57c              PUSH     {r2-r6,lr}
000ec0  4604              MOV      r4,r0
000ec2  460d              MOV      r5,r1
;;;43     // ----------------------------------------------
;;;44     uint *raddr; uint rdata;
;;;45      if	(sscanf(ptr,"%p,%x", &raddr, &rdata)==2)
000ec4  466b              MOV      r3,sp
000ec6  aa01              ADD      r2,sp,#4
000ec8  a1b3              ADR      r1,|L1.4504|
000eca  4620              MOV      r0,r4
000ecc  f7fffffe          BL       __0sscanf
000ed0  2802              CMP      r0,#2
000ed2  d104              BNE      |L1.3806|
;;;46      {
;;;47     	printf("0x%x",(raddr[0]));		//  .
000ed4  9801              LDR      r0,[sp,#4]
000ed6  6801              LDR      r1,[r0,#0]
000ed8  a0b1              ADR      r0,|L1.4512|
000eda  f7fffffe          BL       __2printf
                  |L1.3806|
;;;48      }	
;;;49     }//______________________________________________
000ede  bd7c              POP      {r2-r6,pc}
;;;50     void WriteCMD(char *ptr,uint cnt){		//    .	  ""W012345,8765#"
                          ENDP

                  WriteCMD PROC
000ee0  b57c              PUSH     {r2-r6,lr}
000ee2  4604              MOV      r4,r0
000ee4  460d              MOV      r5,r1
;;;51     // ----------------------------------------------
;;;52     uint wdata, *waddr;
;;;53     
;;;54      if	(sscanf(ptr,"%p,%x", &waddr, &wdata)==2)
000ee6  ab01              ADD      r3,sp,#4
000ee8  466a              MOV      r2,sp
000eea  a1ab              ADR      r1,|L1.4504|
000eec  4620              MOV      r0,r4
000eee  f7fffffe          BL       __0sscanf
000ef2  2802              CMP      r0,#2
000ef4  d104              BNE      |L1.3840|
;;;55      {
;;;56     	ASK();					//   .
000ef6  f7fffffe          BL       ASK
;;;57     	waddr[0]=wdata;				//    .
000efa  e9dd1000          LDRD     r1,r0,[sp,#0]
000efe  6008              STR      r0,[r1,#0]
                  |L1.3840|
;;;58      }	
;;;59     }//______________________________________________
000f00  bd7c              POP      {r2-r6,pc}
;;;60     
                          ENDP

                  SendCMD PROC
;;;61     void SendCMD(char *ptr,uint cnt){		//    .	  ""Saaa,ll,xxx...xx"
000f02  b57c              PUSH     {r2-r6,lr}
000f04  4605              MOV      r5,r0
000f06  460e              MOV      r6,r1
;;;62     // ----------------------------------------------
;;;63     uint len,num;
;;;64     char * pbuf;
;;;65     
;;;66      if	(sscanf(ptr,"%d,%d", &num, &len)==2)
000f08  ab01              ADD      r3,sp,#4
000f0a  466a              MOV      r2,sp
000f0c  a1a6              ADR      r1,|L1.4520|
000f0e  4628              MOV      r0,r5
000f10  f7fffffe          BL       __0sscanf
000f14  2802              CMP      r0,#2
000f16  d11e              BNE      |L1.3926|
;;;67      {
;;;68       if	((num<=3)&&(len<=SizeBufLL))
000f18  9800              LDR      r0,[sp,#0]
000f1a  2803              CMP      r0,#3
000f1c  d81b              BHI      |L1.3926|
000f1e  f240218a          MOV      r1,#0x28a
000f22  9801              LDR      r0,[sp,#4]
000f24  4288              CMP      r0,r1
000f26  d816              BHI      |L1.3926|
;;;69       {
;;;70        if	   (num==0) pbuf=lbuf0;
000f28  9800              LDR      r0,[sp,#0]
000f2a  b908              CBNZ     r0,|L1.3888|
000f2c  4c91              LDR      r4,|L1.4468|
000f2e  e00a              B        |L1.3910|
                  |L1.3888|
;;;71        else if (num==1) pbuf=lbuf1;
000f30  9800              LDR      r0,[sp,#0]
000f32  2801              CMP      r0,#1
000f34  d101              BNE      |L1.3898|
000f36  4c96              LDR      r4,|L1.4496|
000f38  e005              B        |L1.3910|
                  |L1.3898|
;;;72        else if (num==2) pbuf=lbuf2;
000f3a  9800              LDR      r0,[sp,#0]
000f3c  2802              CMP      r0,#2
000f3e  d101              BNE      |L1.3908|
000f40  4c9b              LDR      r4,|L1.4528|
000f42  e000              B        |L1.3910|
                  |L1.3908|
;;;73        else		    pbuf=lbuf3;
000f44  4c9b              LDR      r4,|L1.4532|
                  |L1.3910|
;;;74     	ASK();					//   .
000f46  f7fffffe          BL       ASK
;;;75     	READ_FROM_COM(pbuf,len);		// 
000f4a  4620              MOV      r0,r4
000f4c  9901              LDR      r1,[sp,#4]
000f4e  f7fffffe          BL       READ_FROM_COM
;;;76     	ASK();					//   .
000f52  f7fffffe          BL       ASK
                  |L1.3926|
;;;77       }	
;;;78      }	
;;;79     }//______________________________________________
000f56  bd7c              POP      {r2-r6,pc}
;;;80     void ReceCMD(char *ptr,uint cnt){		//    .	  ""saaa,ll"
                          ENDP

                  ReceCMD PROC
000f58  b57c              PUSH     {r2-r6,lr}
000f5a  4604              MOV      r4,r0
000f5c  460d              MOV      r5,r1
;;;81     
;;;82     char *rptr; uint rcnt;
;;;83     
;;;84      if	(sscanf(ptr,"%p,%d", &rptr, &rcnt)==2)
000f5e  466b              MOV      r3,sp
000f60  aa01              ADD      r2,sp,#4
000f62  a195              ADR      r1,|L1.4536|
000f64  4620              MOV      r0,r4
000f66  f7fffffe          BL       __0sscanf
000f6a  2802              CMP      r0,#2
000f6c  d103              BNE      |L1.3958|
;;;85      {
;;;86     	WRITE_TO_COM(rptr,rcnt);
000f6e  e9dd1000          LDRD     r1,r0,[sp,#0]
000f72  f7fffffe          BL       WRITE_TO_COM
                  |L1.3958|
;;;87      }	
;;;88     }//______________________________________________
000f76  bd7c              POP      {r2-r6,pc}
;;;89     void SetSpeed(char *ptr, uint cnt){		//    .	  "vx(y)1234567"
                          ENDP

                  SetSpeed PROC
000f78  b57c              PUSH     {r2-r6,lr}
000f7a  4604              MOV      r4,r0
000f7c  460d              MOV      r5,r1
;;;90     // ----------------------------------------------
;;;91     char chr; uint val;
;;;92      if	(sscanf(ptr,"%c%d",&chr,&val)==2)
000f7e  466b              MOV      r3,sp
000f80  aa01              ADD      r2,sp,#4
000f82  f2af219c          ADR      r1,|L1.3304|
000f86  4620              MOV      r0,r4
000f88  f7fffffe          BL       __0sscanf
000f8c  2802              CMP      r0,#2
000f8e  d110              BNE      |L1.4018|
;;;93      {
;;;94       if	  (chr=='x') SpeedX=val;
000f90  f89d0004          LDRB     r0,[sp,#4]
000f94  2878              CMP      r0,#0x78
000f96  d103              BNE      |L1.4000|
000f98  4989              LDR      r1,|L1.4544|
000f9a  9800              LDR      r0,[sp,#0]
000f9c  6008              STR      r0,[r1,#0]  ; SpeedX
000f9e  e006              B        |L1.4014|
                  |L1.4000|
;;;95       else if (chr=='y') SpeedY=val;
000fa0  f89d0004          LDRB     r0,[sp,#4]
000fa4  2879              CMP      r0,#0x79
000fa6  d102              BNE      |L1.4014|
000fa8  4986              LDR      r1,|L1.4548|
000faa  9800              LDR      r0,[sp,#0]
000fac  6008              STR      r0,[r1,#0]  ; SpeedY
                  |L1.4014|
;;;96     	ASK();					//   .
000fae  f7fffffe          BL       ASK
                  |L1.4018|
;;;97      }
;;;98     }//______________________________________________
000fb2  bd7c              POP      {r2-r6,pc}
;;;99     void DebugCMD (char *ptr,uint cnt){		//  .
                          ENDP

                  DebugCMD PROC
000fb4  b570              PUSH     {r4-r6,lr}
000fb6  4604              MOV      r4,r0
000fb8  460d              MOV      r5,r1
;;;100    // ----------------------------------------------
;;;101    	sscanf(ptr,"%d",&fDebug);		//     .
000fba  4a83              LDR      r2,|L1.4552|
000fbc  f2af21d0          ADR      r1,|L1.3312|
000fc0  4620              MOV      r0,r4
000fc2  f7fffffe          BL       __0sscanf
;;;102    	ASK();					//   .
000fc6  f7fffffe          BL       ASK
;;;103    }// ---------------------------------------------
000fca  bd70              POP      {r4-r6,pc}
;;;104    
                          ENDP

                  CHECK_CMD PROC
;;;105    void CHECK_CMD(char *ptr,uint cnt){		//    .
000fcc  b570              PUSH     {r4-r6,lr}
000fce  4605              MOV      r5,r0
000fd0  460e              MOV      r6,r1
;;;106    // ----------------------------------------------
;;;107    	char chr=ptr[0];
000fd2  782c              LDRB     r4,[r5,#0]
;;;108    //WRITE_TO_COM(ptr,cnt);			//   .
;;;109    	ptr++; cnt--; ptr[cnt]=0;
000fd4  1c6d              ADDS     r5,r5,#1
000fd6  1e76              SUBS     r6,r6,#1
000fd8  2000              MOVS     r0,#0
000fda  55a8              STRB     r0,[r5,r6]
;;;110    	
;;;111         if (chr=='I') ReadState();			//   .
000fdc  2c49              CMP      r4,#0x49
000fde  d102              BNE      |L1.4070|
000fe0  f7fffffe          BL       ReadState
000fe4  e06a              B        |L1.4284|
                  |L1.4070|
;;;112    else if (chr=='m') MoveCMD(ptr,cnt);		//   .
000fe6  2c6d              CMP      r4,#0x6d
000fe8  d104              BNE      |L1.4084|
000fea  4631              MOV      r1,r6
000fec  4628              MOV      r0,r5
000fee  f7fffffe          BL       MoveCMD
000ff2  e063              B        |L1.4284|
                  |L1.4084|
;;;113    else if (chr=='l') LaserCMD(ptr,cnt);		//   .
000ff4  2c6c              CMP      r4,#0x6c
000ff6  d104              BNE      |L1.4098|
000ff8  4631              MOV      r1,r6
000ffa  4628              MOV      r0,r5
000ffc  f7fffffe          BL       LaserCMD
001000  e05c              B        |L1.4284|
                  |L1.4098|
;;;114    else if (chr=='S') SendCMD(ptr,cnt);		//   .
001002  2c53              CMP      r4,#0x53
001004  d104              BNE      |L1.4112|
001006  4631              MOV      r1,r6
001008  4628              MOV      r0,r5
00100a  f7fffffe          BL       SendCMD
00100e  e055              B        |L1.4284|
                  |L1.4112|
;;;115    else if (chr=='s') ReceCMD(ptr,cnt);		//   .
001010  2c73              CMP      r4,#0x73
001012  d104              BNE      |L1.4126|
001014  4631              MOV      r1,r6
001016  4628              MOV      r0,r5
001018  f7fffffe          BL       ReceCMD
00101c  e04e              B        |L1.4284|
                  |L1.4126|
;;;116    else if (chr=='v') SetSpeed(ptr,cnt);		//    .
00101e  2c76              CMP      r4,#0x76
001020  d104              BNE      |L1.4140|
001022  4631              MOV      r1,r6
001024  4628              MOV      r0,r5
001026  f7fffffe          BL       SetSpeed
00102a  e047              B        |L1.4284|
                  |L1.4140|
;;;117    else if (chr=='b') SetBuffer(ptr,cnt);		//    .
00102c  2c62              CMP      r4,#0x62
00102e  d104              BNE      |L1.4154|
001030  4631              MOV      r1,r6
001032  4628              MOV      r0,r5
001034  f7fffffe          BL       SetBuffer
001038  e040              B        |L1.4284|
                  |L1.4154|
;;;118    
;;;119    else if (chr=='w') ReadCMD(ptr,cnt);		//  .
00103a  2c77              CMP      r4,#0x77
00103c  d104              BNE      |L1.4168|
00103e  4631              MOV      r1,r6
001040  4628              MOV      r0,r5
001042  f7fffffe          BL       ReadCMD
001046  e039              B        |L1.4284|
                  |L1.4168|
;;;120    else if (chr=='W') WriteCMD(ptr,cnt);		//  .
001048  2c57              CMP      r4,#0x57
00104a  d104              BNE      |L1.4182|
00104c  4631              MOV      r1,r6
00104e  4628              MOV      r0,r5
001050  f7fffffe          BL       WriteCMD
001054  e032              B        |L1.4284|
                  |L1.4182|
;;;121    else if (chr=='G') ExecCMD(ptr,cnt);		//  .
001056  2c47              CMP      r4,#0x47
001058  d104              BNE      |L1.4196|
00105a  4631              MOV      r1,r6
00105c  4628              MOV      r0,r5
00105e  f7fffffe          BL       ExecCMD
001062  e02b              B        |L1.4284|
                  |L1.4196|
;;;122    else if (chr=='a') SetAXS(ptr,cnt);		//  .
001064  2c61              CMP      r4,#0x61
001066  d104              BNE      |L1.4210|
001068  4631              MOV      r1,r6
00106a  4628              MOV      r0,r5
00106c  f7fffffe          BL       SetAXS
001070  e024              B        |L1.4284|
                  |L1.4210|
;;;123    else if (chr=='c') ASK();			//  .
001072  2c63              CMP      r4,#0x63
001074  d102              BNE      |L1.4220|
001076  f7fffffe          BL       ASK
00107a  e01f              B        |L1.4284|
                  |L1.4220|
;;;124    else if (chr=='i') ReadInfo();			//   .
00107c  2c69              CMP      r4,#0x69
00107e  d102              BNE      |L1.4230|
001080  f7fffffe          BL       ReadInfo
001084  e01a              B        |L1.4284|
                  |L1.4230|
;;;125    else if (chr=='N') InitCMD();			//  .
001086  2c4e              CMP      r4,#0x4e
001088  d102              BNE      |L1.4240|
00108a  f7fffffe          BL       InitCMD
00108e  e015              B        |L1.4284|
                  |L1.4240|
;;;126    else if (chr=='p') SavePID(ptr,cnt);		//    .
001090  2c70              CMP      r4,#0x70
001092  d104              BNE      |L1.4254|
001094  4631              MOV      r1,r6
001096  4628              MOV      r0,r5
001098  f7fffffe          BL       SavePID
00109c  e00e              B        |L1.4284|
                  |L1.4254|
;;;127    else if (chr=='d') DebugCMD(ptr,cnt);		//  .
00109e  2c64              CMP      r4,#0x64
0010a0  d104              BNE      |L1.4268|
0010a2  4631              MOV      r1,r6
0010a4  4628              MOV      r0,r5
0010a6  f7fffffe          BL       DebugCMD
0010aa  e007              B        |L1.4284|
                  |L1.4268|
;;;128    else if (chr=='o') printf ("\r\npos %d %d",CurrLaserPos,CurrStepPos);		//
0010ac  2c6f              CMP      r4,#0x6f
0010ae  d105              BNE      |L1.4284|
0010b0  4834              LDR      r0,|L1.4484|
0010b2  6842              LDR      r2,[r0,#4]  ; lbufinfo
0010b4  6801              LDR      r1,[r0,#0]  ; lbufinfo
0010b6  a045              ADR      r0,|L1.4556|
0010b8  f7fffffe          BL       __2printf
                  |L1.4284|
;;;129    //else if (chr=='x') xTempCMD();		//
;;;130    //else if (chr=='z') TempCMD(ptr,cnt);		//
;;;131    
;;;132    }//______________________________________________
0010bc  bd70              POP      {r4-r6,pc}
;;;36     
                          ENDP

                  CHECK_INPUT PROC
;;;37     uint CHECK_INPUT(char *ptr, uint i){		//      .
0010be  b570              PUSH     {r4-r6,lr}
0010c0  4606              MOV      r6,r0
0010c2  460c              MOV      r4,r1
;;;38     // ----------------------------------------------
;;;39     //	ptr	   .
;;;40     //	i	   .
;;;41     char chr;					//  .
;;;42     
;;;43      while	(SER_CheckCharRx())
0010c4  e015              B        |L1.4338|
                  |L1.4294|
;;;44      {	chr=SER_ReadChar();
0010c6  bf00              NOP      
0010c8  4843              LDR      r0,|L1.4568|
0010ca  8800              LDRH     r0,[r0,#0]
0010cc  b2c5              UXTB     r5,r0
0010ce  bf00              NOP      
;;;45       if	((i<SIZEBUFRX)&&(chr>' '))
0010d0  2c1f              CMP      r4,#0x1f
0010d2  d204              BCS      |L1.4318|
0010d4  2d20              CMP      r5,#0x20
0010d6  dd02              BLE      |L1.4318|
;;;46       {
;;;47     	ptr[i]=chr; i++;
0010d8  5535              STRB     r5,[r6,r4]
0010da  1c64              ADDS     r4,r4,#1
0010dc  e009              B        |L1.4338|
                  |L1.4318|
;;;48       }
;;;49       else if (((chr==13)||(chr==10))&&(i>0))
0010de  2d0d              CMP      r5,#0xd
0010e0  d001              BEQ      |L1.4326|
0010e2  2d0a              CMP      r5,#0xa
0010e4  d105              BNE      |L1.4338|
                  |L1.4326|
0010e6  b124              CBZ      r4,|L1.4338|
;;;50       {
;;;51     	CHECK_CMD(ptr,i); i=0;
0010e8  4621              MOV      r1,r4
0010ea  4630              MOV      r0,r6
0010ec  f7fffffe          BL       CHECK_CMD
0010f0  2400              MOVS     r4,#0
                  |L1.4338|
0010f2  f7fffffe          BL       SER_CheckCharRx
0010f6  2800              CMP      r0,#0                 ;43
0010f8  d1e5              BNE      |L1.4294|
;;;52       }
;;;53      }	 
;;;54      	return i;
0010fa  4620              MOV      r0,r4
;;;55     }//______________________________________________
0010fc  bd70              POP      {r4-r6,pc}
;;;56     int main(){					//
                          ENDP

                  main PROC
0010fe  2400              MOVS     r4,#0
;;;57     uint i=0;
;;;58     	RemapToRAM();				//     RAM.
001100  f7fffffe          BL       RemapToRAM
;;;59     	
;;;60     	RCC->APB2ENR|=	RCC_APB2ENR_AFIOEN|	//   .
001104  4819              LDR      r0,|L1.4460|
001106  6980              LDR      r0,[r0,#0x18]
001108  f040000d          ORR      r0,r0,#0xd
00110c  4917              LDR      r1,|L1.4460|
00110e  6188              STR      r0,[r1,#0x18]
;;;61     			RCC_APB2ENR_IOPAEN|	//   A.
;;;62     			RCC_APB2ENR_IOPBEN;     //   B.
;;;63     	SER_Init1();				//    1
001110  f7fffffe          BL       SER_Init1
;;;64     	TIM_Init_PWM();				//   .
001114  f7fffffe          BL       TIM_Init_PWM
;;;65     	MotorBreak();				// -.
001118  f7fffffe          BL       MotorBreak
;;;66     	TIM_Init_TOT();				//   .
00111c  f7fffffe          BL       TIM_Init_TOT
;;;67     	TIM_Init_ENC();				//  .
001120  f7fffffe          BL       TIM_Init_ENC
;;;68     	InitPinsSteps();			//    .
001124  f7fffffe          BL       InitPinsSteps
;;;69     	InitTimerSteps();			//   .
001128  f7fffffe          BL       InitTimerSteps
;;;70     	InitLaser();				//   .
00112c  f7fffffe          BL       InitLaser
;;;71     	LaserCTRL(0);				//  .
001130  2000              MOVS     r0,#0
001132  f7fffffe          BL       LaserCTRL
;;;72     	LEDS_Init();				//    .
001136  bf00              NOP      
001138  480d              LDR      r0,|L1.4464|
00113a  1d00              ADDS     r0,r0,#4
00113c  6800              LDR      r0,[r0,#0]
00113e  f420407f          BIC      r0,r0,#0xff00
001142  490b              LDR      r1,|L1.4464|
001144  1d09              ADDS     r1,r1,#4
001146  6008              STR      r0,[r1,#0]
001148  4608              MOV      r0,r1
00114a  6800              LDR      r0,[r0,#0]
00114c  f4405008          ORR      r0,r0,#0x2200
001150  6008              STR      r0,[r1,#0]
001152  bf00              NOP      
;;;73     	VoltageMotor=MAX_PWM;			//    .
001154  20ff              MOVS     r0,#0xff
001156  4921              LDR      r1,|L1.4572|
001158  6008              STR      r0,[r1,#0]  ; VoltageMotor
;;;74     	printf ("\r\nHLDI RAM ready\r\n>");
00115a  a021              ADR      r0,|L1.4576|
00115c  f7fffffe          BL       __2printf
;;;75     //	CaretToHome();
;;;76     //	printf("\r\n0x%x", RCC->CFGR);
;;;77     //	printf("\r\n 0x%8x 0x%8x", RCC->CFGR,RCC->CR);
;;;78     //	printf("\r\n set TOT %d",tot);
;;;79     	
;;;80     
;;;81      while(1)
001160  e04d              B        |L1.4606|
001162  0000              DCW      0x0000
                  |L1.4452|
                          DCD      indxmem
                  |L1.4456|
                          DCD      0x40000800
                  |L1.4460|
                          DCD      0x40021000
                  |L1.4464|
                          DCD      0x40010c00
                  |L1.4468|
                          DCD      lbuf0
                  |L1.4472|
                          DCD      ActBuffer
                  |L1.4476|
                          DCD      0xe000ed08
                  |L1.4480|
                          DCD      0x05fa0004
                  |L1.4484|
                          DCD      lbufinfo
                  |L1.4488|
001188  257800            DCB      "%x",0
00118b  00                DCB      0
                  |L1.4492|
                          DCD      State
                  |L1.4496|
                          DCD      lbuf1
                  |L1.4500|
                          DCD      ||.constdata||+0x418
                  |L1.4504|
001198  25702c25          DCB      "%p,%x",0
00119c  7800    
00119e  00                DCB      0
00119f  00                DCB      0
                  |L1.4512|
0011a0  30782578          DCB      "0x%x",0
0011a4  00      
0011a5  00                DCB      0
0011a6  00                DCB      0
0011a7  00                DCB      0
                  |L1.4520|
0011a8  25642c25          DCB      "%d,%d",0
0011ac  6400    
0011ae  00                DCB      0
0011af  00                DCB      0
                  |L1.4528|
                          DCD      lbuf2
                  |L1.4532|
                          DCD      lbuf3
                  |L1.4536|
0011b8  25702c25          DCB      "%p,%d",0
0011bc  6400    
0011be  00                DCB      0
0011bf  00                DCB      0
                  |L1.4544|
                          DCD      SpeedX
                  |L1.4548|
                          DCD      SpeedY
                  |L1.4552|
                          DCD      fDebug
                  |L1.4556|
0011cc  0d0a706f          DCB      "\r\npos %d %d",0
0011d0  73202564
0011d4  20256400
                  |L1.4568|
                          DCD      0x40013804
                  |L1.4572|
                          DCD      VoltageMotor
                  |L1.4576|
0011e0  0d0a484c          DCB      "\r\nHLDI RAM ready\r\n>",0
0011e4  44492052
0011e8  414d2072
0011ec  65616479
0011f0  0d0a3e00
                  |L1.4596|
;;;82      {
;;;83     	i=CHECK_INPUT(RxBuf,i);			//   .
0011f4  4621              MOV      r1,r4
0011f6  4808              LDR      r0,|L1.4632|
0011f8  f7fffffe          BL       CHECK_INPUT
0011fc  4604              MOV      r4,r0
                  |L1.4606|
0011fe  e7f9              B        |L1.4596|
;;;84     //	PrintStateM();
;;;85      }
;;;86     }// ---------------------------------------------
                          ENDP

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

                  |L1.4632|
                          DCD      RxBuf

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

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

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

                  StepTable
                          DCD      0x00000080
                          DCD      0x00000090
                          DCD      0x00000010
                          DCD      0x00000050
                          DCD      0x00000040
                          DCD      0x00000060
                          DCD      0x00000020
                          DCD      0x000000a0
                  AccelTable
                          DCD      0x0003ec75
                          DCD      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
000418  202d6230          DCB      0x20,0x2d,0x62,0x30
00041c  20307825          DCB      0x20,0x30,0x78,0x25
000420  70202d62          DCB      0x70,0x20,0x2d,0x62
000424  31203078          DCB      0x31,0x20,0x30,0x78
000428  2570202d          DCB      0x25,0x70,0x20,0x2d
00042c  737a2025          DCB      0x73,0x7a,0x20,0x25
000430  64202d72          DCB      0x64,0x20,0x2d,0x72
000434  78202564          DCB      0x78,0x20,0x25,0x64
000438  202d7578          DCB      0x20,0x2d,0x75,0x78
00043c  20256420          DCB      0x20,0x25,0x64,0x20
000440  2d727920          DCB      0x2d,0x72,0x79,0x20
000444  2564202d          DCB      0x25,0x64,0x20,0x2d
000448  75792025          DCB      0x75,0x79,0x20,0x25
00044c  64202d70          DCB      0x64,0x20,0x2d,0x70
000450  69203078          DCB      0x69,0x20,0x30,0x78
000454  2570202d          DCB      0x25,0x70,0x20,0x2d
000458  73692025          DCB      0x73,0x69,0x20,0x25
00045c  6400              DCB      0x64,0x00

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

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

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

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

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

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

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

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

;*** Start embedded assembler ***

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

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

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

 
 blx r0
	ENDP

;*** End   embedded assembler ***

                  __ARM_use_no_argv EQU 0
