///////////////////////////////////////////////////////////////////////////////
//
// IAR C/C++ Compiler V2.10.4.157 for STM8                10/Aug/2020  13:50:17
// Copyright 2010-2015 IAR Systems AB.
//
//    Source file  =  F:\2-Lora\Code\stm8l151K6T6-WLAN\USER\bsp_photoresistor.c
//    Command line =  
//        F:\2-Lora\Code\stm8l151K6T6-WLAN\USER\bsp_photoresistor.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\bsp_photoresistor.s
//
///////////////////////////////////////////////////////////////////////////////

        EXTERN ?add32_l0_l0_0x
        EXTERN ?b12
        EXTERN ?b13
        EXTERN ?b14
        EXTERN ?b8
        EXTERN ?b9
        EXTERN ?epilogue_l2
        EXTERN ?epilogue_l2_w6
        EXTERN ?fcastf32s16_l0_x
        EXTERN ?fcastf32u32_l0_l0
        EXTERN ?fcmpeq32_c_0x_fzero
        EXTERN ?fcmplt32_c_l0_0x
        EXTERN ?fcmplt32_c_l0_dc32
        EXTERN ?fdiv32_l0_l0_dc32
        EXTERN ?fmul32_l0_l0_0x
        EXTERN ?fmul32_l0_l0_dc32
        EXTERN ?fmul32_l0_l0_l1
        EXTERN ?fsub32_l0_l0_l1
        EXTERN ?load32_0x_l0
        EXTERN ?load32_0x_l2
        EXTERN ?load32_l0_0x
        EXTERN ?mov_l0_l2
        EXTERN ?mov_l1_l0
        EXTERN ?mov_l1_l2
        EXTERN ?mov_l2_l0
        EXTERN ?push_l2
        EXTERN ?push_w6
        EXTERN ?scmp32_c_l0_l1
        EXTERN ?sdiv16_x_x_y
        EXTERN ?sdiv32_l0_l0_l1
        EXTERN ?sext32_l0_x
        EXTERN ?sra16_x_x_8
        EXTERN ?sub32_l0_l0_0x
        EXTERN ?sub32_l0_l0_l1
        EXTERN ?w0
        EXTERN ?w1
        EXTERN ?w2
        EXTERN ?w4
        EXTERN ?w5
        EXTERN ?w6
        EXTERN ADC_ChannelCmd
        EXTERN ADC_ClearFlag
        EXTERN ADC_Cmd
        EXTERN ADC_GetConversionValue
        EXTERN ADC_GetFlagStatus
        EXTERN ADC_SoftwareStartConv
        EXTERN CarRecDataStr
        EXTERN GPIO_ReadInputDataBit
        EXTERN abs

        PUBLIC BatValue
        PUBLIC BatVolDec
        PUBLIC BatVoltage
        PUBLIC DelayTime4s
        PUBLIC GetSysStatus
        PUBLIC MotorRunCount
        PUBLIC Ph_Dec_in_flag
        PUBLIC VAL_PHOTO
        PUBLIC day_or_night
        PUBLIC day_or_night2
        PUBLIC ge_state
        PUBLIC geo_wave_count
        PUBLIC geo_wave_flag
        PUBLIC get_photoresistor_ad
        PUBLIC judge_day_night
        PUBLIC judge_ph_state
        PUBLIC mag_time_count
        PUBLIC no_car_count
        PUBLIC ph_base
        PUBLIC ph_car_in
        PUBLIC ph_car_out
        PUBLIC ph_stable_value
        PUBLIC ph_state
        PUBLIC ph_value
        PUBLIC ph_wave_count
        PUBLIC ph_wave_flag
        PUBLIC pho_fault_count
        PUBLIC thr_day
        PUBLIC thr_night
        PUBLIC thr_pho_resistor_h
        PUBLIC time_state
        PUBLIC tmp_thr_pho
        PUBLIC ttt
        PUBLIC wave_time_check

// F:\2-Lora\Code\stm8l151K6T6-WLAN\USER\bsp_photoresistor.c
//    1 /*
//    2 *********************************************************************************************************
//    3 *
//    4 *	模块名称 : 光敏电阻检测车模块
//    5 *	文件名称 : bsp_photoresistor.c
//    6 *	版    本 : V1.0
//    7 *	说    明 : 光敏电阻检测车
//    8 *
//    9 *	修改记录 :
//   10 *		版本号  日期       作者    说明
//   11 *		v1.0
//   12 *
//   13 *	Copyright (C)
//   14 *
//   15 *********************************************************************************************************
//   16 */
//   17 
//   18 #include "bsp_photoresistor.h"

        SECTION `.near.data`:DATA:REORDER:NOROOT(0)
//   19 int16_t  thr_pho_resistor_h = 0x174;
thr_pho_resistor_h:
        DC16 372

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   20 int16_t  ph_stable_value = 0;
ph_stable_value:
        DS8 2

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   21 uint16_t  ph_value[5];
ph_value:
        DS8 10

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   22 int ph_wave_flag = 0;
ph_wave_flag:
        DS8 2

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   23 int ph_wave_count = 0;
ph_wave_count:
        DS8 2

        SECTION `.near.data`:DATA:REORDER:NOROOT(0)
//   24 enum STATUS ph_state = 1;
ph_state:
        DC8 1

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   25 enum STATUS Ph_Dec_in_flag;
Ph_Dec_in_flag:
        DS8 1

        SECTION `.near.data`:DATA:REORDER:NOROOT(0)
//   26 enum STATUS ge_state = 1;//地磁是否正常标志
ge_state:
        DC8 1

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   27 u8 mag_time_count;
mag_time_count:
        DS8 1

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   28 int16_t VAL_PHOTO = 0;
VAL_PHOTO:
        DS8 2

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   29 int16_t ph_base = 0;
ph_base:
        DS8 2

        SECTION `.near.data`:DATA:REORDER:NOROOT(0)
//   30 int16_t day_or_night = 0x765;//0x765
day_or_night:
        DC16 1893

        SECTION `.near.data`:DATA:REORDER:NOROOT(0)
//   31 int16_t day_or_night2 = 0x200;//0x300
day_or_night2:
        DC16 512

        SECTION `.near.data`:DATA:REORDER:NOROOT(0)
//   32 int16_t thr_night = 0x200;//0x300
thr_night:
        DC16 512

        SECTION `.near.data`:DATA:REORDER:NOROOT(0)
//   33 int16_t thr_day = 0x174;//0x174
thr_day:
        DC16 372

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   34 uint8_t pho_fault_count = 0;
pho_fault_count:
        DS8 1

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   35 int geo_wave_flag = 0;
geo_wave_flag:
        DS8 2

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   36 int geo_wave_count = 0;
geo_wave_count:
        DS8 2

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   37 int no_car_count;
no_car_count:
        DS8 2
//   38 ///////////////////////////////////
//   39 

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//   40 u8 tmp_thr_pho[10];//光敏阈值存储
tmp_thr_pho:
        DS8 10
//   41 
//   42 /***************************test*************************************/
//   43 //////////////////////得到光敏电阻值////////////////////////////////
//   44 /***
//   45 功能：采集光敏电阻AD值
//   46 ***/

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//   47 void get_photoresistor_ad(void)
//   48 {
get_photoresistor_ad:
        CALL      L:?push_l2
//   49         int i=0;
        CLR       S:?b9
        CLR       S:?b8
//   50         ADC_Cmd(ADC1,ENABLE);
        LD        A, #0x1
        LDW       X, #0x5340
        CALL      L:ADC_Cmd
        JRA       L:??get_photoresistor_ad_0
//   51         while(i<5)
//   52         {
//   53                 ADC_ChannelCmd(ADC1,ADC_Channel_22,ENABLE);
??get_photoresistor_ad_1:
        LD        A, #0x1
        LDW       Y, #0x140
        LDW       X, #0x5340
        CALL      L:ADC_ChannelCmd
//   54                 ADC_SoftwareStartConv(ADC1);
        LDW       X, #0x5340
        CALL      L:ADC_SoftwareStartConv
//   55                 while(ADC_GetFlagStatus(ADC1,ADC_FLAG_EOC)==RESET);
??get_photoresistor_ad_2:
        LD        A, #0x1
        LDW       X, #0x5340
        CALL      L:ADC_GetFlagStatus
        CP        A, #0x0
        JREQ      L:??get_photoresistor_ad_2
//   56                 ph_value[i++] = ADC_GetConversionValue(ADC1);
        LDW       X, S:?w4
        SLLW      X
        PUSHW     X
        LDW       X, #0x5340
        CALL      L:ADC_GetConversionValue
        POPW      Y
        LDW       (L:ph_value,Y), X
        LDW       X, S:?w4
        INCW      X
        LDW       S:?w4, X
//   57                 ADC_ClearFlag(ADC1,ADC_FLAG_EOC);
        LD        A, #0x1
        LDW       X, #0x5340
        CALL      L:ADC_ClearFlag
//   58         }
??get_photoresistor_ad_0:
        LDW       X, S:?w4
        CPW       X, #0x5
        JRSLT     L:??get_photoresistor_ad_1
//   59         VAL_PHOTO = (ph_value[1] + ph_value[2] + ph_value[3])/3;
        LDW       X, L:ph_value + 4
        ADDW      X, L:ph_value + 2
        ADDW      X, L:ph_value + 6
        LDW       Y, #0x3
        DIVW      X, Y
        LDW       L:VAL_PHOTO, X
//   60         
//   61         CarRecDataStr.pr[0] = VAL_PHOTO>>8;
        LDW       X, L:VAL_PHOTO
        CALL      L:?sra16_x_x_8
        LD        A, XL
        LD        L:CarRecDataStr + 5, A
//   62         CarRecDataStr.pr[1] = VAL_PHOTO;
        LDW       X, L:VAL_PHOTO
        LD        A, XL
        LD        L:CarRecDataStr + 6, A
//   63         ADC_ChannelCmd(ADC1,ADC_Channel_22,DISABLE);
        CLR       A
        LDW       Y, #0x140
        LDW       X, #0x5340
        CALL      L:ADC_ChannelCmd
//   64         ADC_Cmd(ADC1,DISABLE);
        CLR       A
        LDW       X, #0x5340
        CALL      L:ADC_Cmd
//   65 }
        JP        L:?epilogue_l2
//   66 

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//   67 void judge_ph_state(void)
//   68 {
//   69         static uint8_t count = 0;
//   70         if(ph_state == YES)count = 0;
judge_ph_state:
        LD        A, L:ph_state
        CP        A, #0x1
        JRNE      L:??judge_ph_state_0
        MOV       L:??count, #0x0
        RET
//   71         else
//   72         {
//   73               if(VAL_PHOTO > 0x200)count++;
??judge_ph_state_0:
        LDW       X, L:VAL_PHOTO
        CPW       X, #0x201
        JRSLT     L:??judge_ph_state_1
        LD        A, L:??count
        ADD       A, #0x1
        LD        L:??count, A
//   74               if(count>=5)
??judge_ph_state_1:
        LD        A, L:??count
        CP        A, #0x5
        JRC       L:??judge_ph_state_2
//   75               {
//   76                       count = 0;
        MOV       L:??count, #0x0
//   77                       ph_state = YES;
        MOV       L:ph_state, #0x1
//   78               }
//   79         }
//   80 }
??judge_ph_state_2:
        RET

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
??count:
        DS8 1
//   81 /////////////////////光敏电阻检测车进入/////////////////////////
//   82 /***
//   83 输入：first_dec：更新参数的值；next_dec：正常检测
//   84 功能：光敏检测车进入
//   85 输出：1：有车；0：无车
//   86 ***/

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//   87 int ph_car_in(int flag)
//   88 {
//   89 	static uint8_t dec_car_in_count = 0;//光敏稳定变化计次
//   90 	static int16_t ph_in_before = 0;
//   91 	if(flag == 1)
ph_car_in:
        CPW       X, #0x1
        JRNE      L:??ph_car_in_0
//   92 	{
//   93 
//   94 		ph_in_before = VAL_PHOTO;//首次更新ad值
        LDW       X, L:VAL_PHOTO
        LDW       L:??ph_in_before, X
//   95 		return 3;
        LDW       X, #0x3
        RET
//   96 	}
//   97 	if((ph_base - VAL_PHOTO)>THR_PHO_RESISTOR_H)
??ph_car_in_0:
        LDW       X, L:ph_base
        SUBW      X, L:VAL_PHOTO
        LDW       Y, L:thr_pho_resistor_h
        LDW       S:?w0, X
        CPW       Y, S:?w0
        JRSGE     L:??ph_car_in_1
//   98 	{
//   99                 if(abs(VAL_PHOTO - ph_in_before) < THR_PHO_RESISTOR_H/5)
        LDW       X, L:VAL_PHOTO
        SUBW      X, L:??ph_in_before
        CALL      L:abs
        LDW       S:?w0, X
        LDW       X, L:thr_pho_resistor_h
        LDW       Y, #0x5
        CALL      L:?sdiv16_x_x_y
        LDW       S:?w1, X
        LDW       X, S:?w0
        CPW       X, S:?w1
        JRSGE     L:??ph_car_in_2
//  100                 {
//  101                         dec_car_in_count++;
        LD        A, L:??dec_car_in_count
        ADD       A, #0x1
        LD        L:??dec_car_in_count, A
//  102                         if(dec_car_in_count>=PR_DEC_COUNT)
        LD        A, L:??dec_car_in_count
        CP        A, #0x4
        JRC       L:??ph_car_in_3
//  103                         {
//  104                                 dec_car_in_count = PR_DEC_COUNT;
        MOV       L:??dec_car_in_count, #0x4
        JRA       L:??ph_car_in_3
//  105                         }
//  106                 }
//  107                 else
//  108                 {
//  109                         dec_car_in_count = 0;
??ph_car_in_2:
        MOV       L:??dec_car_in_count, #0x0
//  110                 }
//  111                 ph_in_before = VAL_PHOTO;
??ph_car_in_3:
        LDW       X, L:VAL_PHOTO
        LDW       L:??ph_in_before, X
        JRA       L:??ph_car_in_4
//  112 	}
//  113 	else
//  114 	{
//  115 				dec_car_in_count = 0;
??ph_car_in_1:
        MOV       L:??dec_car_in_count, #0x0
//  116 	}
//  117 
//  118 	if(dec_car_in_count>=PR_DEC_COUNT)
??ph_car_in_4:
        LD        A, L:??dec_car_in_count
        CP        A, #0x4
        JRC       L:??ph_car_in_5
//  119 	{
//  120                 dec_car_in_count = PR_DEC_COUNT;
        MOV       L:??dec_car_in_count, #0x4
//  121 				ph_stable_value = ph_in_before;//光敏检测车停稳值
        LDW       X, L:??ph_in_before
        LDW       L:ph_stable_value, X
//  122 				return 1;//检测到车进入
        CLRW      X
        INCW      X
        RET
//  123 	}
//  124 	return 0;
??ph_car_in_5:
        CLRW      X
        RET
//  125 }

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
??dec_car_in_count:
        DS8 1

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
??ph_in_before:
        DS8 2
//  126 //////////////////////光敏检测车离开//////////////////////////
//  127 /***
//  128 输入：first_dec：对参数进行清零；next_dec：正常检测
//  129 功能：光敏检测车离开
//  130 输出：1：车离开；0：车未离开
//  131 ***/

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  132 int ph_car_out(int flag)
//  133 {
//  134 	//thr_pho_resistor_A
//  135 	static uint8_t dec_car_out_count=0;
//  136 	static int16_t ph_out_before = 0;
//  137 	if(flag == 1)
ph_car_out:
        CPW       X, #0x1
        JRNE      L:??ph_car_out_0
//  138 	{
//  139                 get_photoresistor_ad();
        CALL      L:get_photoresistor_ad
//  140 		ph_out_before = VAL_PHOTO;//首次更新ad值
        LDW       X, L:VAL_PHOTO
        LDW       L:??ph_out_before, X
//  141 		dec_car_out_count = 0;
        MOV       L:??dec_car_out_count, #0x0
//  142 		ph_wave_flag = 0;
        CLRW      X
        LDW       L:ph_wave_flag, X
//  143 		return 3;
        LDW       X, #0x3
        RET
//  144 	}
//  145 	if((VAL_PHOTO - ph_out_before) > THR_PHO_RESISTOR_H)//阈值减小，增加灵敏度
??ph_car_out_0:
        LDW       X, L:VAL_PHOTO
        SUBW      X, L:??ph_out_before
        LDW       Y, L:thr_pho_resistor_h
        LDW       S:?w0, X
        CPW       Y, S:?w0
        JRSGE     L:??ph_car_out_1
//  146 	{
//  147 		dec_car_out_count++;
        LD        A, L:??dec_car_out_count
        ADD       A, #0x1
        LD        L:??dec_car_out_count, A
//  148 		if(dec_car_out_count>=PR_DEC_COUNT)
        LD        A, L:??dec_car_out_count
        CP        A, #0x4
        JRC       L:??ph_car_out_2
//  149 		{
//  150 			dec_car_out_count = PR_DEC_COUNT;
        MOV       L:??dec_car_out_count, #0x4
//  151                         return 1;//检测到车离开
        CLRW      X
        INCW      X
        RET
//  152 		}
//  153 	}
//  154 	else
//  155 	{
//  156 		dec_car_out_count = 0;
??ph_car_out_1:
        MOV       L:??dec_car_out_count, #0x0
//  157                 ph_out_before = VAL_PHOTO;
        LDW       X, L:VAL_PHOTO
        LDW       L:??ph_out_before, X
//  158 	}
//  159 	if((VAL_PHOTO - ph_out_before) > (THR_PHO_RESISTOR_H/2))//光敏在波动
??ph_car_out_2:
        LDW       X, L:VAL_PHOTO
        SUBW      X, L:??ph_out_before
        LDW       S:?w0, X
        LDW       X, L:thr_pho_resistor_h
        LDW       Y, #0x2
        CALL      L:?sdiv16_x_x_y
        CPW       X, S:?w0
        JRSGE     L:??ph_car_out_3
//  160 	{
//  161 		ph_wave_flag = 1;//有波动
        CLRW      X
        INCW      X
        LDW       L:ph_wave_flag, X
//  162 	}
//  163 	return 0;//未检测到车离开
??ph_car_out_3:
        CLRW      X
        RET
//  164 }

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
??dec_car_out_count:
        DS8 1

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
??ph_out_before:
        DS8 2
//  165 
//  166 /**********判断白天和晚上*************/
//  167 /***
//  168 功能：白天晚上自动识别
//  169 ***/

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  170 void judge_day_night(int flag)
//  171 {
//  172 
//  173 
//  174 		static int ph_value_sum_count = 0;
//  175 		static int32_t  ph_value_sum = 0;
//  176                 if(flag == 1)
judge_day_night:
        CPW       X, #0x1
        JRNE      L:??judge_day_night_0
//  177                 {
//  178                         ph_value_sum_count = 0;
        CLRW      X
        LDW       L:??ph_value_sum_count, X
//  179                         ph_value_sum = 0;
        LDW       X, #0x0
        LDW       L:??ph_value_sum, X
        LDW       X, #0x0
        LDW       L:??ph_value_sum + 2, X
//  180                 }
//  181                 get_photoresistor_ad();
??judge_day_night_0:
        CALL      L:get_photoresistor_ad
//  182                 ph_value_sum_count++;
        LDW       X, L:??ph_value_sum_count
        INCW      X
        LDW       L:??ph_value_sum_count, X
//  183                 ph_value_sum = ph_value_sum + VAL_PHOTO;
        LDW       X, L:VAL_PHOTO
        CALL      L:?sext32_l0_x
        LDW       X, #??ph_value_sum
        CALL      L:?add32_l0_l0_0x
        LDW       X, #??ph_value_sum
        CALL      L:?load32_0x_l0
//  184                 if(ph_value_sum_count >= 30)
        LDW       X, L:??ph_value_sum_count
        CPW       X, #0x1e
        JRSGE     ??lb_1
        JP        L:??judge_day_night_1
//  185                 {
//  186                         ph_value_sum = ph_value_sum/ph_value_sum_count;
??lb_1:
        LDW       X, L:??ph_value_sum_count
        CALL      L:?sext32_l0_x
        CALL      L:?mov_l1_l0
        LDW       X, #??ph_value_sum
        CALL      L:?load32_l0_0x
        CALL      L:?sdiv32_l0_l0_l1
        LDW       X, #??ph_value_sum
        CALL      L:?load32_0x_l0
//  187                         if(ph_stable_value - ph_value_sum > DAY_OR_NIGHT2)
        LDW       X, L:ph_stable_value
        CALL      L:?sext32_l0_x
        LDW       X, #??ph_value_sum
        CALL      L:?sub32_l0_l0_0x
        CALL      L:?mov_l1_l0
        LDW       X, L:day_or_night2
        CALL      L:?sext32_l0_x
        CALL      L:?scmp32_c_l0_l1
        JRSGE     L:??judge_day_night_2
//  188                         {
//  189                                 thr_pho_resistor_h = THR_night;
        LDW       X, L:thr_night
        LDW       L:thr_pho_resistor_h, X
//  190                                 ph_stable_value = ph_value_sum;
        LDW       X, #??ph_value_sum
        CALL      L:?load32_l0_0x
        LDW       X, S:?w1
        LDW       L:ph_stable_value, X
        JRA       L:??judge_day_night_3
//  191                         }
//  192                         else if(ph_value_sum - ph_stable_value > DAY_OR_NIGHT2)
??judge_day_night_2:
        LDW       X, L:ph_stable_value
        CALL      L:?sext32_l0_x
        CALL      L:?mov_l1_l0
        LDW       X, #??ph_value_sum
        CALL      L:?load32_l0_0x
        CALL      L:?sub32_l0_l0_l1
        CALL      L:?mov_l1_l0
        LDW       X, L:day_or_night2
        CALL      L:?sext32_l0_x
        CALL      L:?scmp32_c_l0_l1
        JRSGE     L:??judge_day_night_3
//  193                         {
//  194                                 thr_pho_resistor_h = THR_day;
        LDW       X, L:thr_day
        LDW       L:thr_pho_resistor_h, X
//  195                                 ph_stable_value = ph_value_sum;
        LDW       X, #??ph_value_sum
        CALL      L:?load32_l0_0x
        LDW       X, S:?w1
        LDW       L:ph_stable_value, X
//  196                         }
//  197                         ph_value_sum = 0;
??judge_day_night_3:
        LDW       X, #0x0
        LDW       L:??ph_value_sum, X
        LDW       X, #0x0
        LDW       L:??ph_value_sum + 2, X
//  198                         ph_value_sum_count = 0;
        CLRW      X
        LDW       L:??ph_value_sum_count, X
//  199                 }
//  200 }
??judge_day_night_1:
        RET

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
??ph_value_sum_count:
        DS8 2

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
??ph_value_sum:
        DS8 4
//  201 /******电压采集******/
//  202 #define DecreaseValue1 (0.04/1000.0)
//  203 #define DecreaseValue2 (0.3/1000.0)
//  204 
//  205 

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//  206 double BatVoltage[2] = {0};
BatVoltage:
        DS8 8

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//  207 uint32_t MotorRunCount = 0;
MotorRunCount:
        DS8 4

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//  208 int BatValue=0;
BatValue:
        DS8 2

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//  209 u8 ttt;
ttt:
        DS8 1

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  210 void BatVolDec(u8 state)
//  211 {
BatVolDec:
        CALL      L:?push_l2
        CALL      L:?push_w6
        PUSH      S:?b14
        LD        S:?b14, A
//  212      int i=0;
        CLR       S:?b13
        CLR       S:?b12
//  213      double temp=0;
        CLRW      X
        LDW       S:?w5, X
        LDW       S:?w4, X
//  214      ADC_ChannelCmd(ADC1, ADC_Channel_0, ENABLE);
        LD        A, #0x1
        LDW       Y, #0x301
        LDW       X, #0x5340
        CALL      L:ADC_ChannelCmd
//  215      for(i=0;i<5;i++)
        CLRW      X
        LDW       S:?w6, X
        JRA       L:??BatVolDec_0
//  216      {
//  217          ADC_SoftwareStartConv(ADC1);
??BatVolDec_1:
        LDW       X, #0x5340
        CALL      L:ADC_SoftwareStartConv
//  218          while(ADC_GetFlagStatus(ADC1,ADC_FLAG_EOC) == RESET);
??BatVolDec_2:
        LD        A, #0x1
        LDW       X, #0x5340
        CALL      L:ADC_GetFlagStatus
        CP        A, #0x0
        JREQ      L:??BatVolDec_2
//  219          BatValue += ADC_GetConversionValue(ADC1);
        LDW       X, #0x5340
        CALL      L:ADC_GetConversionValue
        ADDW      X, L:BatValue
        LDW       L:BatValue, X
//  220      }
        LDW       X, S:?w6
        INCW      X
        LDW       S:?w6, X
??BatVolDec_0:
        LDW       X, S:?w6
        CPW       X, #0x5
        JRSLT     L:??BatVolDec_1
//  221      ADC_ChannelCmd(ADC1, ADC_Channel_0, DISABLE);
        CLR       A
        LDW       Y, #0x301
        LDW       X, #0x5340
        CALL      L:ADC_ChannelCmd
//  222      BatValue = BatValue/5;
        LDW       X, L:BatValue
        LDW       Y, #0x5
        CALL      L:?sdiv16_x_x_y
        LDW       L:BatValue, X
//  223 
//  224      if(state==1)
        LD        A, S:?b14
        CP        A, #0x1
        JRNE      L:??BatVolDec_3
//  225      {
//  226           BatVoltage[0] = BatValue*10.0/308.0;
        LDW       X, L:BatValue
        CALL      L:?fcastf32s16_l0_x
        CALL      L:?fmul32_l0_l0_dc32
        DATA
        DC32      0x41200000
        CODE
        CALL      L:?fdiv32_l0_l0_dc32
        DATA
        DC32      0x439a0000
        CODE
        LDW       X, #BatVoltage
        CALL      L:?load32_0x_l0
        JP        L:??BatVolDec_4
//  227      }
//  228      else if(state==2)
??BatVolDec_3:
        LD        A, S:?b14
        CP        A, #0x2
        JREQ      ??lb_0
        JP        L:??BatVolDec_5
//  229      {
//  230           if((BatVoltage[0]*308.0/10)<((5.8-0.65)/2.0/3.3*4096))
??lb_0:
        CLRW      X
        LDW       S:?w1, X
        LDW       X, #0x439a
        LDW       S:?w0, X
        LDW       X, #BatVoltage
        CALL      L:?fmul32_l0_l0_0x
        CALL      L:?fdiv32_l0_l0_dc32
        DATA
        DC32      0x41200000
        CODE
        CALL      L:?fcmplt32_c_l0_dc32
        DATA
        DC32      0x4547c1f1
        CODE
        JRNC      L:??BatVolDec_6
//  231           {
//  232               temp = DecreaseValue2;
        LDW       X, #0x4952
        LDW       S:?w5, X
        LDW       X, #0x399d
        LDW       S:?w4, X
        JRA       L:??BatVolDec_7
//  233           }
//  234           else
//  235           {
//  236               temp = DecreaseValue1;
??BatVolDec_6:
        LDW       X, #0xc5ac
        LDW       S:?w5, X
        LDW       X, #0x3827
        LDW       S:?w4, X
//  237           }
//  238           temp = MotorRunCount*(temp/3.3*4096)*10.0/308.0;
??BatVolDec_7:
        CALL      L:?mov_l0_l2
        CALL      L:?fdiv32_l0_l0_dc32
        DATA
        DC32      0x40533333
        CODE
        CALL      L:?fmul32_l0_l0_dc32
        DATA
        DC32      0x45800000
        CODE
        CALL      L:?mov_l1_l0
        LDW       X, #MotorRunCount
        CALL      L:?load32_l0_0x
        CALL      L:?fcastf32u32_l0_l0
        CALL      L:?fmul32_l0_l0_l1
        CALL      L:?fmul32_l0_l0_dc32
        DATA
        DC32      0x41200000
        CODE
        CALL      L:?fdiv32_l0_l0_dc32
        DATA
        DC32      0x439a0000
        CODE
        CALL      L:?mov_l2_l0
//  239           temp = BatVoltage[0]-temp;
        LDW       X, #BatVoltage
        CALL      L:?load32_l0_0x
        CALL      L:?mov_l1_l2
        CALL      L:?fsub32_l0_l0_l1
        CALL      L:?mov_l2_l0
//  240           BatVoltage[1] = temp;
        LDW       X, #BatVoltage + 4
        CALL      L:?load32_0x_l2
//  241           BatVoltage[0] = BatVoltage[1];
        LDW       X, #BatVoltage + 4
        CALL      L:?load32_l0_0x
        LDW       X, #BatVoltage
        CALL      L:?load32_0x_l0
        JRA       L:??BatVolDec_4
//  242      }
//  243      else if(state==3)
??BatVolDec_5:
        LD        A, S:?b14
        CP        A, #0x3
        JRNE      L:??BatVolDec_4
//  244      {
//  245           BatVoltage[0] = (BatValue*10.0/308.0);
        LDW       X, L:BatValue
        CALL      L:?fcastf32s16_l0_x
        CALL      L:?fmul32_l0_l0_dc32
        DATA
        DC32      0x41200000
        CODE
        CALL      L:?fdiv32_l0_l0_dc32
        DATA
        DC32      0x439a0000
        CODE
        LDW       X, #BatVoltage
        CALL      L:?load32_0x_l0
//  246           if((BatVoltage[1]<BatVoltage[0])&&(BatVoltage[1]!=0))
        LDW       X, #BatVoltage
        LDW       S:?w2, X
        LDW       X, #BatVoltage + 4
        CALL      L:?load32_l0_0x
        LDW       X, S:?w2
        CALL      L:?fcmplt32_c_l0_0x
        JRNC      L:??BatVolDec_4
        LDW       X, #BatVoltage + 4
        CALL      L:?fcmpeq32_c_0x_fzero
        JREQ      L:??BatVolDec_4
//  247           {
//  248               BatVoltage[0] = BatVoltage[1];
        LDW       X, #BatVoltage + 4
        CALL      L:?load32_l0_0x
        LDW       X, #BatVoltage
        CALL      L:?load32_0x_l0
//  249           }
//  250      }
//  251      else
//  252      {
//  253           ;
//  254      }
//  255      BatValue = 0;
??BatVolDec_4:
        CLRW      X
        LDW       L:BatValue, X
//  256      MotorRunCount = 0;
        LDW       X, #0x0
        LDW       L:MotorRunCount, X
        LDW       X, #0x0
        LDW       L:MotorRunCount + 2, X
//  257 }
        POP       S:?b14
        JP        L:?epilogue_l2_w6
//  258 
//  259 
//  260 
//  261 /*
//  262 enum //TIME_STATE//时刻表
//  263 {
//  264     T_10s            = 2,//10s
//  265     T_20s         = 5,//20s
//  266     T_40s          = 10,//40s
//  267     T_60s            = 15,//1minute
//  268     T_200s    = 50,//200s
//  269     T_5m          = 75,//5mintutes
//  270 	NO_CAR                = 76//5mintutes+
//  271 };
//  272 */
//  273 /***
//  274 输入：计数值
//  275 功能：时刻判断
//  276 输出：具体时刻
//  277 
//  278 ***/
//  279 static int judge_time_state(int time)
//  280 {
//  281 	if(time<T_30s)
//  282 	{
//  283 		time = T_30s;
//  284 	}
//  285 	else if(time<T_40s)//40s
//  286 	{
//  287 		time = T_40s;
//  288 	}
//  289 	else if(time==T_40s*2||time==(T_40s*3)||time==(T_40s*4))//200s
//  290 	{
//  291 		time=SELF_ADAPTION_TIMR;
//  292 	}
//  293 	else if(time<T_200s)//小于200s
//  294 	{
//  295 		time=T_200s;
//  296 	}
//  297 	else if(time<=T_5m)//<5分钟
//  298 	{
//  299 		time=T_5m;
//  300 	}
//  301 	else if(time>=NO_CAR)//>5minutes
//  302 	{
//  303 		time=NO_CAR;
//  304 	}
//  305 	return time;
//  306 }
//  307 /****
//  308 输入：无
//  309 功能：检测车进入
//  310 
//  311 输出：0：未检测到车进入；1：光敏检测到车进入；2：地磁检测到车进入；3：光敏和地磁都检测到车进入
//  312 ****/
//  313 static int common_dec_car_in(void)
//  314 {
//  315 	int i = 0,j = 0;
//  316 	i = ph_car_in(next_dec);
//  317 	j = geomag_car_in();
//  318 	if(i==0&&j==0)
//  319 	{
//  320 		return 0;//未检测到车进入
//  321 	}
//  322 	else if(i==1&&j==0)
//  323 	{
//  324 
//  325                 asm("NOP");
//  326 		return 1;//光敏检测到车进入
//  327 	}
//  328 	else if(i==0&&j==1)
//  329 	{
//  330                 asm("NOP");
//  331 		return 2;//地磁检测到车进入
//  332 	}
//  333 	else if(i==1&&j==1)
//  334 	{
//  335                 asm("NOP");
//  336 		return 3;//地磁光敏都检测到车进入
//  337 	}
//  338 	return 0;
//  339 }
//  340 /***
//  341 输入：光敏状态，地磁状态
//  342 功能：光敏，地磁状态判断
//  343 输出：0：都坏，1：只光敏好，2：只地磁好，3：都好
//  344 ***/
//  345 static int ge_ph_state(int ph_state_i,int ge_state_j)
//  346 {
//  347 	if(ph_state_i==0&&ge_state_j==0)
//  348 	{
//  349 		return 0;
//  350 	}
//  351 	else if(ph_state_i==1&&ge_state_j==0)
//  352 	{
//  353 		return 1;
//  354 	}
//  355 	else if(ph_state_i==0&&ge_state_j==1)
//  356 	{
//  357 		return 2;
//  358 	}
//  359 	else if(ph_state_i==1&&ge_state_j==1)
//  360 	{
//  361 		return 3;
//  362 	}
//  363 	return 0;
//  364 }
//  365 
//  366 /***
//  367 功能：
//  368 ***/

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  369 void wave_time_check(void)
//  370 {
//  371         if(geo_wave_flag == 1)//有波动
wave_time_check:
        LDW       X, L:geo_wave_flag
        CPW       X, #0x1
        JRNE      L:??wave_time_check_0
//  372         {
//  373                 geo_wave_count ++;
        LDW       X, L:geo_wave_count
        INCW      X
        LDW       L:geo_wave_count, X
//  374                 if(geo_wave_count>=4)
        LDW       X, L:geo_wave_count
        CPW       X, #0x4
        JRSLT     L:??wave_time_check_1
//  375                 {
//  376                        geo_wave_count = 4;
        LDW       X, #0x4
        LDW       L:geo_wave_count, X
        JRA       L:??wave_time_check_1
//  377                 }
//  378         }
//  379         else
//  380         {
//  381                 geo_wave_count = 0;
??wave_time_check_0:
        CLRW      X
        LDW       L:geo_wave_count, X
//  382         }
//  383 
//  384         if(ph_wave_flag == 1)
??wave_time_check_1:
        LDW       X, L:ph_wave_flag
        CPW       X, #0x1
        JRNE      L:??wave_time_check_2
//  385         {
//  386                 ph_wave_count ++;
        LDW       X, L:ph_wave_count
        INCW      X
        LDW       L:ph_wave_count, X
//  387                 if(ph_wave_count>=4)
        LDW       X, L:ph_wave_count
        CPW       X, #0x4
        JRSLT     L:??wave_time_check_3
//  388                 {
//  389                        ph_wave_count = 4;
        LDW       X, #0x4
        LDW       L:ph_wave_count, X
        RET
//  390                 }
//  391         }
//  392         else
//  393         {
//  394                 ph_wave_count = 0;
??wave_time_check_2:
        CLRW      X
        LDW       L:ph_wave_count, X
//  395         }
//  396 }
??wave_time_check_3:
        RET
//  397 /***
//  398 输入：无
//  399 功能:检测车离开
//  400 输出：1：检测到车离开；0：未检测到车离开
//  401 ***/
//  402 static int common_dec_car_out()
//  403 {
//  404         //protect_count
//  405 	int i = 0,j = 0;
//  406 	i = ph_car_out(next_dec);
//  407 	j = geomag_car_out(next_dec);
//  408         if(i==0)geo_wave_flag = 0;
//  409         wave_time_check();
//  410 	if((i==1&&j==1)||(i==1&&geo_wave_flag==1)||(j==1&&ph_wave_flag==1))
//  411 	{
//  412                 if((i==1&&geo_wave_flag==1)&&geo_wave_count<4)
//  413                 {
//  414                         return 0;//bsp_DelayMS(15000);
//  415                 }
//  416                 else if((j==1&&ph_wave_flag==1)&&ph_wave_count<4)
//  417                 {
//  418                         return 0;//bsp_DelayMS(15000);
//  419                 }
//  420                 ph_wave_count = 0;
//  421                 geo_wave_count = 0;
//  422                 return 1;//检测到车离开
//  423 	}
//  424 	return 0;
//  425 }
//  426 /*行程开关*/
//  427 #define GPIOP_TRAVELSWITCH_K1   GPIOB
//  428 #define GPIOB_TRAVELSWITCH_K1   GPIO_Pin_0
//  429 /**
//  430 *获取行程开关状态，锁关闭时，立起来，返回1；锁打开时，返回0
//  431 */

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  432 u8 GetSysStatus(void)
//  433 {
//  434 
//  435 	if(GPIO_ReadInputDataBit( GPIOP_TRAVELSWITCH_K1, GPIOB_TRAVELSWITCH_K1 ) == RESET)
GetSysStatus:
        LD        A, #0x1
        LDW       X, #0x5005
        CALL      L:GPIO_ReadInputDataBit
        CP        A, #0x0
        JRNE      L:??GetSysStatus_0
//  436 	{
//  437 		if(GPIO_ReadInputDataBit( GPIOP_TRAVELSWITCH_K1, GPIOB_TRAVELSWITCH_K1 ) == RESET)
        LD        A, #0x1
        LDW       X, #0x5005
        CALL      L:GPIO_ReadInputDataBit
        CP        A, #0x0
        JRNE      L:??GetSysStatus_0
//  438 		return 0;
        CLR       A
        RET
//  439 	}
//  440 	if(GPIO_ReadInputDataBit( GPIOP_TRAVELSWITCH_K1, GPIOB_TRAVELSWITCH_K1 ) != RESET)
??GetSysStatus_0:
        LD        A, #0x1
        LDW       X, #0x5005
        CALL      L:GPIO_ReadInputDataBit
        CP        A, #0x0
        JREQ      L:??GetSysStatus_1
//  441 	{
//  442 		if(GPIO_ReadInputDataBit( GPIOP_TRAVELSWITCH_K1, GPIOB_TRAVELSWITCH_K1 ) != RESET)
        LD        A, #0x1
        LDW       X, #0x5005
        CALL      L:GPIO_ReadInputDataBit
        CP        A, #0x0
        JREQ      L:??GetSysStatus_1
//  443 		return 1;
        LD        A, #0x1
        RET
//  444 	}
//  445 
//  446 	return 2;
??GetSysStatus_1:
        LD        A, #0x2
        RET
//  447 
//  448 }
//  449 
//  450 /***
//  451 输入：无
//  452 功能：各时间段，地磁和光敏配合检测车进入及离开
//  453 输出：无
//  454 ***/
//  455 

        SECTION `.near.bss`:DATA:REORDER:NOROOT(0)
//  456 uint8_t DelayTime4s = 0;
DelayTime4s:
        DS8 1

        SECTION `.near_func.text`:CODE:REORDER:NOROOT(0)
        CODE
//  457 void time_state(void)
//  458 {
//  459         char printf_buff[100];
//  460 	int time = 0;
time_state:
        CLRW      Y
//  461 	int dec_flag = 0;
        CLRW      X
//  462         if(DelayTime4s)return;
        LD        A, L:DelayTime4s
        CP        A, #0x0
        JRNE      L:??time_state_0
//  463         DelayTime4s = 4;
        MOV       L:DelayTime4s, #0x4
//  464         if(LOW_POWER_TEST)return;
??time_state_0:
        RET
//  465 	if((LIMIT_READ)||(QMC5883LStr.DataOkFlag == 0)||(LockCarState.MotorActResults == FALL_ERROR)||(LockCarState.MotorActResults == RISE_OK)||((LockCarState.MotorCmd!=CmdIdle)))return;	
//  466 	mag_time_count++;       
//  467         //BeepStart(1,0);
//  468         //UsartPrint(QMC5883LStr.QMC_CUR_ROPORT,6);
//  469         QMC5883LStr.DataOkFlag = FALSE;
//  470 	get_photoresistor_ad();
//  471         judge_ph_state();
//  472         if(HC_DEBUG){
//  473             sprintf(printf_buff,"Tim:%d;P_BASE:%d,P_CUR:%d;QMC_BASE:X=%d,Z=%d;QMC_CUR:X=%d,Z=%d;car_state = %d\r\n",mag_time_count,ph_base,VAL_PHOTO,QMC5883LStr.QMC_BASE[0],QMC5883LStr.QMC_BASE[2],QMC5883LStr.QMC_CUR[0],QMC5883LStr.QMC_CUR[2],CarRecDataStr.CarState);
//  474             int i = 0;
//  475             while(printf_buff[i]!='\n')
//  476               UsartPrint(&printf_buff[i++],1);
//  477         }
//  478         //UsartPrint(&mag_time_count,1);
//  479 	if(CarRecDataStr.CarState==0)
//  480 	{
//  481 		time = judge_time_state(mag_time_count);
//  482                 if(mag_time_count<=T_4s)
//  483                 {
//  484                     no_car_count = 0;
//  485                     memcpy(QMC5883LStr.QMC_BASE,QMC5883LStr.QMC_CUR,3*sizeof(int16_t));
//  486                     ph_base = VAL_PHOTO;
//  487                     if(ph_base<0x200)ph_state = NO;
//  488                     BeepStart(1,0);
//  489                     
//  490                 }
//  491                 if(time>T_30s)
//  492                 {
//  493                         dec_flag = common_dec_car_in();
//  494                 }
//  495 		switch(time)
//  496 		{
//  497                         case T_30s:
//  498                         {
//  499 
//  500                                 return;
//  501                         }
//  502                         case T_40s:
//  503                         {
//  504                                 if(dec_flag == 2||dec_flag == 3)
//  505                                 {
//  506                                   have_car_send();
//  507                                 }
//  508                                 break;
//  509                         }
//  510                         case SELF_ADAPTION_TIMR:
//  511                         {
//  512                                 geomag_self_adaption();
//  513                                 break;
//  514                         }
//  515                         case T_200s:
//  516                         {
//  517                                 if(dec_flag == 2||dec_flag == 3)
//  518                                 {
//  519                                       have_car_send();
//  520                                 }
//  521                                 break;
//  522                         }
//  523                         case T_5m:
//  524                         {
//  525                                 if(dec_flag == 1||dec_flag == 2||dec_flag == 3)have_car_send();
//  526                                 break;
//  527                         }
//  528                         case NO_CAR:
//  529                         {
//  530                                 NO_car_deal();
//  531                                 
//  532                                 break;
//  533                         }
//  534                         default:
//  535                                 break;
//  536 		}
//  537 
//  538 	}
//  539 	else//检测车离开
//  540 	{
//  541 
//  542                 if(mag_time_count < T_3M)//前三分钟不检测车离开
//  543                 {
//  544                         return;
//  545                 }
//  546                 else
//  547                 {
//  548                         mag_time_count = T_3M;
//  549                 }
//  550 
//  551 		switch(ge_ph_state(ph_state,ge_state))
//  552 		{
//  553 		case 0://光敏地磁都故障
//  554 			break;
//  555 		case 1://单光敏检测
//  556 		{
//  557 			judge_day_night(next_dec);//白天晚上自动识别
//  558 			if(ph_car_out(next_dec))
//  559 			{
//  560 				NO_car_deal();
//  561 			}
//  562 			break;
//  563 		}
//  564 		case 2://单地磁检测
//  565 		{
//  566 			if(geomag_car_out(next_dec))
//  567                         {
//  568                               NO_car_deal();
//  569                         }
//  570 			break;
//  571 		}
//  572 		case 3://地磁光敏配合检测
//  573 		{
//  574 			judge_day_night(next_dec);
//  575 			if(common_dec_car_out())
//  576                         {
//  577                                 NO_car_deal();
//  578                                 asm("NOP");
//  579 
//  580                         }
//  581 			break;
//  582 		}
//  583 		default:
//  584 			break;
//  585 		}
//  586 	}
//  587 }

        SECTION VREGS:DATA:REORDER:NOROOT(0)

        END
//  588 
// 
//    68 bytes in section .near.bss
//    12 bytes in section .near.data
// 1 124 bytes in section .near_func.text
// 
// 1 124 bytes of CODE memory
//    80 bytes of DATA memory
//
//Errors: none
//Warnings: 17
