///////////////////////////////////////////////////////////////////////////////
//
// IAR C/C++ Compiler V2.10.4.157 for STM8                10/Aug/2020  13:50:20
// Copyright 2010-2015 IAR Systems AB.
//
//    Source file  =  F:\2-Lora\Code\stm8l151K6T6-WLAN\BSP\stm8l15x_it.c
//    Command line =  
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\BSP\stm8l15x_it.c -e -Ol --no_cse
//        --no_unroll --no_inline --no_code_motion --no_tbaa --no_cross_call
//        --debug --code_model small --data_model medium -o
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\Debug\Obj\ --dlib_config
//        E:\IAR\stm8\LIB\dlstm8smf.h -lB
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\Debug\List\ -I
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\FWLIB\inc\ -I
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\FWLIB\src\ -I
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\USER\ -I
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\BSP\ -I
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\radio\ -I
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\SX1278\ --vregs 16
//    List file    =  F:\2-Lora\Code\stm8l151K6T6-WLAN\Debug\List\stm8l15x_it.s
//
///////////////////////////////////////////////////////////////////////////////

        EXTERN ?pop_l0
        EXTERN ?pop_l1
        EXTERN ?push_l0
        EXTERN ?push_l1
        EXTERN RTC_ClearITPendingBit
        EXTERN TIM2_ClearITPendingBit
        EXTERN TIM4_ClearITPendingBit
        EXTERN Timer4Deal
        EXTERN UartRecDeal
        EXTERN time_count2

        PUBLIC ADC1_COMP_IRQHandler
        PUBLIC DMA1_CHANNEL0_1_IRQHandler
        PUBLIC DMA1_CHANNEL2_3_IRQHandler
        PUBLIC EXTI0_IRQHandler
        PUBLIC EXTI1_IRQHandler
        PUBLIC EXTI2_IRQHandler
        PUBLIC EXTI3_IRQHandler
        PUBLIC EXTI4_IRQHandler
        PUBLIC EXTI5_IRQHandler
        PUBLIC EXTI6_IRQHandler
        PUBLIC EXTI7_IRQHandler
        PUBLIC EXTIB_IRQHandler
        PUBLIC EXTID_IRQHandler
        PUBLIC EXTIE_F_PVD_IRQHandler
        PUBLIC FLASH_IRQHandler
        PUBLIC I2C1_IRQHandler
        PUBLIC LCD_IRQHandler
        PUBLIC NonHandledInterrupt
        PUBLIC RTC_CSSLSE_IRQHandler
        PUBLIC SPI1_IRQHandler
        PUBLIC SWITCH_CSS_BREAK_DAC_IRQHandler
        PUBLIC TIM1_CAP_IRQHandler
        PUBLIC TIM1_UPD_OVF_TRG_COM_IRQHandler
        PUBLIC TIM2_CAP_IRQHandler
        PUBLIC TIM2_UPD_OVF_TRG_BRK_IRQHandler
        PUBLIC TIM3_CAP_IRQHandler
        PUBLIC TIM3_UPD_OVF_TRG_BRK_IRQHandler
        PUBLIC TIM4_UPD_OVF_TRG_IRQHandler
        PUBLIC TRAP_IRQHandler
        PUBLIC USART1_RX_IRQHandler
        PUBLIC USART1_TX_IRQHandler
        PUBLIC _interrupt_1
        PUBLIC _interrupt_10
        PUBLIC _interrupt_11
        PUBLIC _interrupt_12
        PUBLIC _interrupt_13
        PUBLIC _interrupt_14
        PUBLIC _interrupt_15
        PUBLIC _interrupt_16
        PUBLIC _interrupt_17
        PUBLIC _interrupt_18
        PUBLIC _interrupt_19
        PUBLIC _interrupt_2
        PUBLIC _interrupt_20
        PUBLIC _interrupt_21
        PUBLIC _interrupt_22
        PUBLIC _interrupt_23
        PUBLIC _interrupt_24
        PUBLIC _interrupt_25
        PUBLIC _interrupt_26
        PUBLIC _interrupt_27
        PUBLIC _interrupt_28
        PUBLIC _interrupt_29
        PUBLIC _interrupt_3
        PUBLIC _interrupt_30
        PUBLIC _interrupt_31
        PUBLIC _interrupt_4
        PUBLIC _interrupt_5
        PUBLIC _interrupt_6
        PUBLIC _interrupt_7
        PUBLIC _interrupt_8
        PUBLIC _interrupt_9
        PUBLIC recdata
        PUBLIC recnum

// F:\2-Lora\Code\stm8l151K6T6-WLAN\BSP\stm8l15x_it.c
//    1 
//    2 
//    3 
//    4 /**
//    5   ******************************************************************************
//    6   * @file    Project/Template/stm8l15x_it.c
//    7   * @author  MCD Tools Team
//    8   * @version V1.2.0
//    9   * @date    09/2010
//   10   * @brief   Main Interrupt Service Routines.
//   11   *          This file provides template for all peripherals interrupt service routine.
//   12   ******************************************************************************
//   13   * @copy
//   14   *
//   15   * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
//   16   * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
//   17   * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
//   18   * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
//   19   * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
//   20   * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
//   21   *
//   22   * <h2><center>&copy; COPYRIGHT 2010 STMicroelectronics</center></h2>
//   23   */
//   24 
//   25 /* Includes ------------------------------------------------------------------*/
//   26 #include "stm8l15x.h"
//   27 //#include "stm8l15x_it.h"
//   28 
//   29 #include "bsp.h"

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   30 u8 recnum = 0;
recnum:
        DS8 1

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   31 u8 recdata[50] = {0};
recdata:
        DS8 50

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//   32 INTERRUPT_HANDLER(NonHandledInterrupt,0)
//   33 {
//   34 /* In order to detect unexpected events during development,
//   35    it is recommended to set a breakpoint on the following instruction.
//   36 */
//   37   while (1);
NonHandledInterrupt:
_interrupt_2:
        JRA       L:_interrupt_2
//   38 
//   39 }
//   40 /**
//   41   * @brief TRAP interrupt routine
//   42   * @par Parameters:
//   43   * None
//   44   * @retval
//   45   * None
//   46 */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//   47 INTERRUPT_HANDLER_TRAP(TRAP_IRQHandler)
//   48 {
//   49 /* In order to detect unexpected events during development,
//   50    it is recommended to set a breakpoint on the following instruction.
//   51 */
//   52   while (1);
TRAP_IRQHandler:
_interrupt_1:
        JRA       L:_interrupt_1
//   53 
//   54 }
//   55 /**
//   56   * @brief FLASH Interrupt routine.
//   57   * @par Parameters:
//   58   * None
//   59   * @retval
//   60   * None
//   61   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//   62 INTERRUPT_HANDLER(FLASH_IRQHandler,1)
//   63 {
//   64 /* In order to detect unexpected events during development,
//   65    it is recommended to set a breakpoint on the following instruction.
//   66 */
//   67   while (1);
FLASH_IRQHandler:
_interrupt_3:
        JRA       L:_interrupt_3
//   68 
//   69 }
//   70 /**
//   71   * @brief DMA1 channel0 and channel1 Interrupt routine.
//   72   * @par Parameters:
//   73   * None
//   74   * @retval
//   75   * None
//   76   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//   77 INTERRUPT_HANDLER(DMA1_CHANNEL0_1_IRQHandler,2)
//   78 {
//   79 /* In order to detect unexpected events during development,
//   80    it is recommended to set a breakpoint on the following instruction.
//   81 */
//   82   while (1);
DMA1_CHANNEL0_1_IRQHandler:
_interrupt_4:
        JRA       L:_interrupt_4
//   83 
//   84 }
//   85 /**
//   86   * @brief DMA1 channel2 and channel3 Interrupt routine.
//   87   * @par Parameters:
//   88   * None
//   89   * @retval
//   90   * None
//   91   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//   92 INTERRUPT_HANDLER(DMA1_CHANNEL2_3_IRQHandler,3)
//   93 {
//   94 /* In order to detect unexpected events during development,
//   95    it is recommended to set a breakpoint on the following instruction.
//   96 */
//   97   while (1);
DMA1_CHANNEL2_3_IRQHandler:
_interrupt_5:
        JRA       L:_interrupt_5
//   98 
//   99 }
//  100 /**
//  101   * @brief RTC Interrupt routine.
//  102   * @par Parameters:
//  103   * None
//  104   * @retval
//  105   * None
//  106   */
//  107 

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  108 INTERRUPT_HANDLER(RTC_CSSLSE_IRQHandler, 4)
//  109 {
RTC_CSSLSE_IRQHandler:
_interrupt_6:
        PUSH      CC
        POP       A
        AND       A, #0xbf
        PUSH      A
        POP       CC
        CALL      L:?push_l0
        CALL      L:?push_l1
//  110     Timer4Deal();
        CALL      L:Timer4Deal
//  111     //RTC_WakeUpCmd(DISABLE);
//  112     RTC_ClearITPendingBit(RTC_IT_WUT);
        LDW       X, #0x40
        CALL      L:RTC_ClearITPendingBit
//  113 }
        CALL      L:?pop_l1
        CALL      L:?pop_l0
        IRET
//  114 /**
//  115   * @brief External IT PORTE/F and PVD Interrupt routine.
//  116   * @par Parameters:
//  117   * None
//  118   * @retval
//  119   * None
//  120   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  121 INTERRUPT_HANDLER(EXTIE_F_PVD_IRQHandler,5)
//  122 {
//  123 /* In order to detect unexpected events during development,
//  124    it is recommended to set a breakpoint on the following instruction.
//  125 */
//  126   while (1);
EXTIE_F_PVD_IRQHandler:
_interrupt_7:
        JRA       L:_interrupt_7
//  127 
//  128 }
//  129 
//  130 /**
//  131   * @brief External IT PORTB Interrupt routine.
//  132   * @par Parameters:
//  133   * None
//  134   * @retval
//  135   * None
//  136   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  137 INTERRUPT_HANDLER(EXTIB_IRQHandler,6)
//  138 {
//  139 /* In order to detect unexpected events during development,
//  140    it is recommended to set a breakpoint on the following instruction.
//  141 */
//  142   while (1);
EXTIB_IRQHandler:
_interrupt_8:
        JRA       L:_interrupt_8
//  143 
//  144 }
//  145 
//  146 /**
//  147   * @brief External IT PORTD Interrupt routine.
//  148   * @par Parameters:
//  149   * None
//  150   * @retval
//  151   * None
//  152   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  153 INTERRUPT_HANDLER(EXTID_IRQHandler,7)
//  154 {
//  155 /* In order to detect unexpected events during development,
//  156    it is recommended to set a breakpoint on the following instruction.
//  157 */
//  158   while (1);
EXTID_IRQHandler:
_interrupt_9:
        JRA       L:_interrupt_9
//  159 
//  160 }
//  161 
//  162 /**
//  163   * @brief External IT PIN0 Interrupt routine.
//  164   * @par Parameters:
//  165   * None
//  166   * @retval
//  167   * None
//  168   */
//  169 

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  170 INTERRUPT_HANDLER(EXTI0_IRQHandler,8)//yuryu
//  171 {
//  172 /* In order to detect unexpected events during development,
//  173    it is recommended to set a breakpoint on the following instruction.
//  174 */
//  175   while (1);
EXTI0_IRQHandler:
_interrupt_10:
        JRA       L:_interrupt_10
//  176 }
//  177 /**
//  178   * @brief External IT PIN1 Interrupt routine.
//  179   *   On User button pressed:
//  180   *   Check if button presse a long time (4-5 sec.) if yes --> Set Autotest
//  181   *   Else update status_machine to pass to next measuremetn.
//  182   *   Update the LCD bar graph
//  183   * @par Parameters:
//  184   * None
//  185   * @retval
//  186   * None
//  187   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  188 INTERRUPT_HANDLER(EXTI1_IRQHandler,9)
//  189 {
//  190 
//  191     while (1);
EXTI1_IRQHandler:
_interrupt_11:
        JRA       L:_interrupt_11
//  192 
//  193 }
//  194 
//  195 /**
//  196   * @brief External IT PIN2 Interrupt routine.
//  197   * @par Parameters:
//  198   * None
//  199   * @retval
//  200   * None
//  201   */
//  202 
//  203 /**
//  204   * 无线AUX中断
//  205   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  206 INTERRUPT_HANDLER(EXTI2_IRQHandler, 10)
//  207 {
//  208 	while (1);
EXTI2_IRQHandler:
_interrupt_12:
        JRA       L:_interrupt_12
//  209 }
//  210 /**
//  211   * @brief External IT PIN3 Interrupt routine.
//  212   * @par Parameters:
//  213   * None
//  214   * @retval
//  215   * None
//  216   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  217 INTERRUPT_HANDLER(EXTI3_IRQHandler,11)
//  218 {
//  219 /* In order to detect unexpected events during development,
//  220    it is recommended to set a breakpoint on the following instruction.
//  221 */
//  222   while (1);
EXTI3_IRQHandler:
_interrupt_13:
        JRA       L:_interrupt_13
//  223 
//  224 }
//  225 
//  226 /**
//  227   * @brief External IT PIN4 Interrupt routine.
//  228   * @par Parameters:
//  229   * None
//  230   * @retval
//  231   * None
//  232   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  233 INTERRUPT_HANDLER(EXTI4_IRQHandler,12)
//  234 {
//  235 /* In order to detect unexpected events during development,
//  236    it is recommended to set a breakpoint on the following instruction.
//  237 */
//  238   while (1);
EXTI4_IRQHandler:
_interrupt_14:
        JRA       L:_interrupt_14
//  239 
//  240 }
//  241 
//  242 /**
//  243   * @brief External IT PIN5 Interrupt routine.
//  244   * @par Parameters:
//  245   * None
//  246   * @retval
//  247   * None
//  248   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  249 INTERRUPT_HANDLER(EXTI5_IRQHandler,13)
//  250 {
//  251 /* In order to detect unexpected events during development,
//  252    it is recommended to set a breakpoint on the following instruction.
//  253 */
//  254   while (1);
EXTI5_IRQHandler:
_interrupt_15:
        JRA       L:_interrupt_15
//  255 
//  256 }
//  257 
//  258 /**
//  259   * @brief External IT PIN6 Interrupt routine.
//  260   * @par Parameters:
//  261   * None
//  262   * @retval
//  263   * None
//  264   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  265 INTERRUPT_HANDLER(EXTI6_IRQHandler,14)
//  266 {
//  267   while (1);
EXTI6_IRQHandler:
_interrupt_16:
        JRA       L:_interrupt_16
//  268 }
//  269 
//  270 /**
//  271   * @brief External IT PIN7 Interrupt routine.
//  272   * @par Parameters:
//  273   * None
//  274   * @retval
//  275   * None
//  276   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  277 INTERRUPT_HANDLER(EXTI7_IRQHandler,15)
//  278 {
//  279 /* In order to detect unexpected events during development,
//  280    it is recommended to set a breakpoint on the following instruction.
//  281 */
//  282 
//  283   while (1);
EXTI7_IRQHandler:
_interrupt_17:
        JRA       L:_interrupt_17
//  284 
//  285 }
//  286 /**
//  287   * @brief LCD start of new frame Interrupt routine.
//  288   * @par Parameters:
//  289   * None
//  290   * @retval
//  291   * None
//  292   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  293 INTERRUPT_HANDLER(LCD_IRQHandler,16)
//  294 {
//  295 /* In order to detect unexpected events during development,
//  296    it is recommended to set a breakpoint on the following instruction.
//  297 */
//  298   while (1);
LCD_IRQHandler:
_interrupt_18:
        JRA       L:_interrupt_18
//  299 
//  300 }
//  301 /**
//  302   * @brief CLK switch/CSS/TIM1 break Interrupt routine.
//  303   * @par Parameters:
//  304   * None
//  305   * @retval
//  306   * None
//  307   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  308 INTERRUPT_HANDLER(SWITCH_CSS_BREAK_DAC_IRQHandler,17)
//  309 {
//  310 /* In order to detect unexpected events during development,
//  311    it is recommended to set a breakpoint on the following instruction.
//  312 */
//  313   while (1);
SWITCH_CSS_BREAK_DAC_IRQHandler:
_interrupt_19:
        JRA       L:_interrupt_19
//  314 
//  315 }
//  316 
//  317 /**
//  318   * @brief ADC1/Comparator Interrupt routine.
//  319   * @par Parameters:
//  320   * None
//  321   * @retval
//  322   * None
//  323   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  324 INTERRUPT_HANDLER(ADC1_COMP_IRQHandler,18)
//  325 {
//  326 /* In order to detect unexpected events during development,
//  327    it is recommended to set a breakpoint on the following instruction.
//  328 */
//  329   while (1);
ADC1_COMP_IRQHandler:
_interrupt_20:
        JRA       L:_interrupt_20
//  330 
//  331 }
//  332 
//  333 /**
//  334   * @brief TIM2 Update/Overflow/Trigger/Break Interrupt routine.
//  335   * @par Parameters:
//  336   * None
//  337   * @retval
//  338   * None
//  339   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  340 INTERRUPT_HANDLER(TIM2_UPD_OVF_TRG_BRK_IRQHandler,19)
//  341 {
TIM2_UPD_OVF_TRG_BRK_IRQHandler:
_interrupt_21:
        PUSH      CC
        POP       A
        AND       A, #0xbf
        PUSH      A
        POP       CC
        CALL      L:?push_l0
        CALL      L:?push_l1
//  342 /* In order to detect unexpected events during development,
//  343    it is recommended to set a breakpoint on the following instruction.
//  344 */
//  345       TIM2_ClearITPendingBit(TIM2_IT_Update);
        LD        A, #0x1
        CALL      L:TIM2_ClearITPendingBit
//  346       if(time_count2>0)
        LDW       X, L:time_count2
        TNZW      X
        JREQ      L:??TIM2_UPD_OVF_TRG_BRK_IRQHandler_0
//  347       {
//  348             time_count2--;
        LDW       X, L:time_count2
        DECW      X
        LDW       L:time_count2, X
//  349       }
//  350 
//  351 }
??TIM2_UPD_OVF_TRG_BRK_IRQHandler_0:
        CALL      L:?pop_l1
        CALL      L:?pop_l0
        IRET
//  352 
//  353 /**
//  354   * @brief Timer2 Capture/Compare Interrupt routine.
//  355   * @par Parameters:
//  356   * None
//  357   * @retval
//  358   * None
//  359   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  360 INTERRUPT_HANDLER(TIM2_CAP_IRQHandler,20)
//  361 {
//  362 /* In order to detect unexpected events during development,
//  363    it is recommended to set a breakpoint on the following instruction.
//  364 */
//  365   while (1);
TIM2_CAP_IRQHandler:
_interrupt_22:
        JRA       L:_interrupt_22
//  366 
//  367 }
//  368 
//  369 
//  370 /**
//  371   * @brief Timer3 Update/Overflow/Trigger/Break Interrupt routine.
//  372   * @par Parameters:
//  373   * None
//  374   * @retval
//  375   * None
//  376   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  377 INTERRUPT_HANDLER(TIM3_UPD_OVF_TRG_BRK_IRQHandler,21)
//  378 {
//  379 /* In order to detect unexpected events during development,
//  380    it is recommended to set a breakpoint on the following instruction.
//  381 */
//  382   while (1);
TIM3_UPD_OVF_TRG_BRK_IRQHandler:
_interrupt_23:
        JRA       L:_interrupt_23
//  383 
//  384 }
//  385 /**
//  386   * @brief Timer3 Capture/Compare Interrupt routine.
//  387   * @par Parameters:
//  388   * None
//  389   * @retval
//  390   * None
//  391   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  392 INTERRUPT_HANDLER(TIM3_CAP_IRQHandler,22)
//  393 {
//  394 /* In order to detect unexpected events during development,
//  395    it is recommended to set a breakpoint on the following instruction.
//  396 */
//  397   while (1);
TIM3_CAP_IRQHandler:
_interrupt_24:
        JRA       L:_interrupt_24
//  398 
//  399 }
//  400 /**
//  401   * @brief TIM1 Update/Overflow/Trigger/Commutation Interrupt routine.
//  402   * @par Parameters:
//  403   * None
//  404   * @retval
//  405   * None
//  406   */
//  407 /*
//  408 ** 定时器1中断，定时多少？
//  409 */
//  410 

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  411 INTERRUPT_HANDLER(TIM1_UPD_OVF_TRG_COM_IRQHandler,23)
//  412 {
//  413 /* In order to detect unexpected events during development,
//  414    it is recommended to set a breakpoint on the following instruction.
//  415 */
//  416   while (1);
TIM1_UPD_OVF_TRG_COM_IRQHandler:
_interrupt_25:
        JRA       L:_interrupt_25
//  417 
//  418 
//  419 }
//  420 
//  421 /**
//  422   * @brief TIM1 Capture/Compare Interrupt routine.
//  423   * @par Parameters:
//  424   * None
//  425   * @retval
//  426   * None
//  427   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  428 INTERRUPT_HANDLER(TIM1_CAP_IRQHandler,24)
//  429 {
//  430 /* In order to detect unexpected events during development,
//  431    it is recommended to set a breakpoint on the following instruction.
//  432 */
//  433   while (1);
TIM1_CAP_IRQHandler:
_interrupt_26:
        JRA       L:_interrupt_26
//  434 
//  435 }
//  436 
//  437 /**
//  438   * @brief TIM4 Update/Overflow/Trigger Interrupt routine.
//  439   * @par Parameters:
//  440   * None
//  441   * @retval
//  442   * None
//  443   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  444 INTERRUPT_HANDLER(TIM4_UPD_OVF_TRG_IRQHandler,25)
//  445 {
TIM4_UPD_OVF_TRG_IRQHandler:
_interrupt_27:
        PUSH      CC
        POP       A
        AND       A, #0xbf
        PUSH      A
        POP       CC
        CALL      L:?push_l0
        CALL      L:?push_l1
//  446 /* In order to detect unexpected events during development,
//  447    it is recommended to set a breakpoint on the following instruction.
//  448 */
//  449     TIM4_ClearITPendingBit(TIM4_IT_Update);
        LD        A, #0x1
        CALL      L:TIM4_ClearITPendingBit
//  450     Timer4Deal();
        CALL      L:Timer4Deal
//  451 
//  452 }
        CALL      L:?pop_l1
        CALL      L:?pop_l0
        IRET
//  453 /*
//  454   * @brief SPI1 Interrupt routine.
//  455   * @par Parameters:
//  456   * None
//  457   * @retval
//  458   * None
//  459   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  460 INTERRUPT_HANDLER(SPI1_IRQHandler,26)
//  461 {
//  462 /* In order to detect unexpected events during development,
//  463    it is recommended to set a breakpoint on the following instruction.
//  464 */
//  465   while (1);
SPI1_IRQHandler:
_interrupt_28:
        JRA       L:_interrupt_28
//  466 
//  467 }
//  468 
//  469 /**
//  470   * @brief USART1 TX Interrupt routine.
//  471   * @par Parameters:
//  472   * None
//  473   * @retval
//  474   * None
//  475   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  476 INTERRUPT_HANDLER(USART1_TX_IRQHandler,27)
//  477 {
//  478 /* In order to detect unexpected events during development,
//  479    it is recommended to set a breakpoint on the following instruction.
//  480 */
//  481   while (1);
USART1_TX_IRQHandler:
_interrupt_29:
        JRA       L:_interrupt_29
//  482 
//  483 }
//  484 
//  485 /**
//  486   * @brief USART1 RX Interrupt routine.
//  487   * @par Parameters:
//  488   * None
//  489   * @retval
//  490   * None
//  491   */
//  492 

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  493 INTERRUPT_HANDLER(USART1_RX_IRQHandler,28)
//  494 {
USART1_RX_IRQHandler:
_interrupt_30:
        PUSH      CC
        POP       A
        AND       A, #0xbf
        PUSH      A
        POP       CC
        CALL      L:?push_l0
        CALL      L:?push_l1
//  495 /* In order to detect unexpected events during development,
//  496    it is recommended to set a breakpoint on the following instruction.
//  497 */
//  498 	UartRecDeal();
        CALL      L:UartRecDeal
//  499 
//  500 }
        CALL      L:?pop_l1
        CALL      L:?pop_l0
        IRET
//  501 
//  502 /**
//  503   * @brief I2C1 Interrupt routine.
//  504   * @par Parameters:
//  505   * None
//  506   * @retval
//  507   * None
//  508   */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  509 INTERRUPT_HANDLER(I2C1_IRQHandler,29)
//  510 {
//  511 /* In order to detect unexpected events during development,
//  512    it is recommended to set a breakpoint on the following instruction.
//  513 */
//  514   while (1);
I2C1_IRQHandler:
_interrupt_31:
        JRA       L:_interrupt_31
//  515 }

        SECTION VREGS:DATA:REORDER:NOROOT(0)

        END
//  516 
//  517 /**
//  518   * @}
//  519   */
//  520 /******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE****/
//  521 
//  522 
// 
//  51 bytes in section .near.bss
// 168 bytes in section .near_func.text
// 
// 168 bytes of CODE memory
//  51 bytes of DATA memory
//
//Errors: none
//Warnings: none
