motor_ctl-1/3.BasicFunction/Source/bikelight.c

/**
 * @file Bikelight.c
 * @author
 * @brief light of ebike
 * @version 0.1
 * @date 2023-06-20
 *
 * @copyright Copyright (c) 2021
 *
 */

#define  BIKELIGHT_
/************************************************************************
 Beginning of File, do not put anything above here except notes
 Compiler Directives:
*************************************************************************/
#include "syspar.h"
#include "typedefine.h"
#include "mathtool.h"
#include "bikelight.h"
#include "hwsetup.h"
#include "power.h"
#include "CodePara.h"
#include "adc.h"
#include "UserGpio_Config.h"

#include "ti_msp_dl_config.h"
//----------------------------

//BIKELED_STR         BikeLedPara;
BIKELEDCHECK_STR   BikeLedCheck_F;//前灯参数
BIKELEDCHECK_STR   BikeLedCheck_B;//尾灯参数
BIKELEDCHECK_STR   BikeLedCheck_L;//左灯参数
BIKELEDCHECK_STR   BikeLedCheck_R;//右灯参数
BIKELIGHT_OUT       bikelight_stBikeLightOut   = BIKELIGHT_OUT_DEFAULT;
LED_PWM_STR   BikePwmChoice;
void LED_EnableDeal(BIKELEDCHECK_STR *p,UWORD switchAction,LED_PWM_STR mode );
/***************************************************************
 Function: bikelight_voGetBikeLightError;
 Description: 前后灯电压故障检测
 Call by: 1ms
 Input Variables:LightPowerVolPu-LED灯的电压值,Ledsta-灯的开关状态，p-内部参数
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
//void bikelight_voGetBikeLightError(UWORD LightPowerVolPu,BOOL Ledsta,BIKELEDCHECK_STR *p)
//{
//    //开灯故障
//if(Ledsta==TRUE)
//{
//if(  (LightPowerVolPu <p->uwLedOnVoltMin  ) || (LightPowerVolPu > p->uwLedOnVoltMax))
//{
//    p->uwBike_LedOnErrCnt++;
//    if(p->uwBike_LedOnErrCnt>LEDRISETIME)
//    {
//       if(p->uwBike_LedOnErrAddNO< LEDERRTIME)
//       {
//        p->uwBike_LedOnErrAddNO++;
//       }
//       else
//       {
//        p->blBike_LedOnErr=   TRUE;
//       }
//
//        p->uwBike_LedOnErrCnt=0;
//    }
//
//}
//else
//{
//    p->uwBike_LedOnErrDCnt++;
// if(p->uwBike_LedOnErrDCnt >LEDRISETIME)
// {
//     if(p->uwBike_LedOnErrAddNO> 0)
//       {
//        p->uwBike_LedOnErrAddNO--;
//       }
//       else
//       {
//        p->blBike_LedOnErr=   FALSE;
//       }
//      p->uwBike_LedOnErrDCnt=0;
// }
//}
//
//p->uwBike_LedOffErrCnt=0;
//p->uwBike_LedOffErrDCnt=0;
//}
////----------关灯故障-----------
//else
//{
//if(  LightPowerVolPu > p->uwLedOffVoltMax)
//{
//    p->uwBike_LedOffErrCnt++;
//    if(p->uwBike_LedOffErrCnt>LEDFALLTIME)
//    {
//       if(p->uwBike_LedOffErrAddNO< LEDERRTIME)
//       {
//        p->uwBike_LedOffErrAddNO++;
//       }
//       else
//       {
//        p->blBike_LedOffErr=   TRUE;
//       }
//
//        p->uwBike_LedOffErrCnt=0;
//    }
//
//}
//else
//{
//    p->uwBike_LedOffErrDCnt++;
// if(p->uwBike_LedOffErrDCnt >LEDFALLTIME)
// {
//     if(p->uwBike_LedOffErrAddNO> 0)
//       {
//        p->uwBike_LedOffErrAddNO--;
//       }
//       else
//       {
//        p->blBike_LedOffErr=   FALSE;
//       }
//      p->uwBike_LedOffErrDCnt=0;
// }
//}
//
//}
//
//p->uwBike_LedOnErrCnt=0;
//p->uwBike_LedOnErrDCnt=0;
//}

/***************************************************************
 Function: bikelight_voBikeLightInit;
 Description: bike light control initialization
 Call by: FSM_voInit
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void bikelight_voBikeLightInit(void)
{

    BikeLedCheck_F.blBike_LedOffErr=FALSE;
    BikeLedCheck_F.uwBike_LedOffErrAddNO=0;
    BikeLedCheck_F.uwBike_LedOffErrCnt=0;
    BikeLedCheck_F.uwBike_LedOffErrDCnt=0;
    BikeLedCheck_F.blBike_LedOnErr=FALSE;
    BikeLedCheck_F.uwBike_LedOnErrAddNO=0;
    BikeLedCheck_F.uwBike_LedOnErrCnt=0;
    BikeLedCheck_F.uwBike_LedOnErrDCnt=0;
    BikeLedCheck_F.uwLedOffVoltMax=  ((ULONG)LIGHT_OFFERR_VOLTAGE << 14) / VBASE; //

    BikeLedCheck_B.blBike_LedOffErr=FALSE;
    BikeLedCheck_B.uwBike_LedOffErrAddNO=0;
    BikeLedCheck_B.uwBike_LedOffErrCnt=0;
    BikeLedCheck_B.uwBike_LedOffErrDCnt=0;
    BikeLedCheck_B.blBike_LedOnErr=FALSE;
    BikeLedCheck_B.uwBike_LedOnErrAddNO=0;
    BikeLedCheck_B.uwBike_LedOnErrCnt=0;
    BikeLedCheck_B.uwBike_LedOnErrDCnt=0;
    BikeLedCheck_B.uwLedOffVoltMax= ((ULONG)LIGHT_OFFERR_VOLTAGE << 14) / VBASE;
}

/***************************************************************
 Function: bikelight_voBikeLightCoef;
 Description:  滤波时间/阈值电压设定参数更新 ,参数输入端
 Call by:初始化，接收数据更新
 Input Variables: N/A
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void bikelight_voBikeLightCoef(UWORD volt)
{

#if(LED_OUTVOLT==LED_OUTVOLT_6V)
//前灯
    BikeLedCheck_F.uwBike_LedVolt =6;

    BikeLedCheck_B.uwBike_LedVolt =6;

#elif(LED_OUTVOLT==LED_OUTVOLT_12V)

     BikeLedCheck_F.uwBike_LedVolt =12;

     BikeLedCheck_B.uwBike_LedVolt =12;

#elif(LED_OUTVOLT==LED_OUTVOLT_6VOR12V)
 //前灯
    BikeLedCheck_F.uwBike_LedVolt =volt & 0x0f;
//尾灯
    BikeLedCheck_B.uwBike_LedMode =  (volt & 0xf000)>>12;
   BikeLedCheck_B.uwBike_LedVolt =(volt & 0x0f00)>>8;


#endif


   if( BikeLedCheck_F.uwBike_LedVolt == 12) //拉低短路
    {

        IO_LED_6or12V_Choise_H(); //12V使能
   }
   else //高阻
   {

       IO_LED_6or12V_Choise_L();//6V输出使能
    }



}
/***************************************************************
 Function: bikelight_voBikeLightInit;
 Description: bike light control initialization
 Call by: 1ms
 Input Variables: switchAction-开灯情况，Brate_Sta-刹车状态， uwBike_LedMode-尾灯模式
 Output/Return Variables: N/A
 Subroutine Call: N/A;
 Reference: N/A
****************************************************************/
void bikelight_voBikeLightControl(UWORD switchAction, BOOL Brate_Sta )
{

if( power_stPowStateOut.blPowerStartupFlg  ==FALSE)
{

  //  IO_FORWARDLED_OFF();
  //  IO_BACKLED_OFF();
  //  DL_TimerG_setCaptureCompareValue(PWM_2_INST, 0, GPIO_PWM_2_C1_IDX);//max=720
    BikeLedGloFun.blBike_BackLedSta=FALSE;
    BikeLedGloFun.blBike_ForwardLedFlag=FALSE;
    BikeLedCheck_F.uwBike_keyLedHighSta=0;


    BikeLedGloFun.uwBike_BackLedDetErrTime=0;
}
else
{
#if((DCDC_12S6V_SEL_EN==0)||(DCDC_12S6V_SEL_EN==3))
      IO_LED_6or12V_EN_H();
#endif
#if(BIKELEDOPEN_R_ENABLE!=0)
    // ---------------尾灯7个状态处理------------
   // BikeLedCheck_B.uwBike_LedMode=two_byte;
    switch( BikeLedCheck_B.uwBike_LedMode)
    {
        case one_byte:  //模式1
        {
            if(Brate_Sta==TRUE)//尾灯低亮，刹车高亮
            {
              BikeLedGloFun.blBike_BackLedSta=TRUE;
            }
            else
            {
                if(switchAction!=0)
                {
                    BikeLedCheck_B.uwLedAddcnt++;
                    if(BikeLedCheck_B.uwLedAddcnt > BikeLedAddCycle)
                    {
                        BikeLedCheck_B.uwLedAddcnt=0;
                    }
                    if(BikeLedCheck_B.uwLedAddcnt<BikeLedAddDuty)
                    {
                        BikeLedGloFun.blBike_BackLedSta=TRUE;
                    }
                    else
                    {
                        BikeLedGloFun.blBike_BackLedSta=FALSE;
                     }
                }
                else
                {
                    BikeLedGloFun.blBike_BackLedSta=FALSE;
                    BikeLedCheck_B.uwLedAddcnt=0;
                }
            }
          break;
        }
        case two_byte:
        {

           if(Brate_Sta==TRUE) //尾灯高亮，刹车闪烁
           {
             BikeLedCheck_B.uwLedAddcnt++;
             if(BikeLedCheck_B.uwLedAddcnt > BikeLedFlickerCycle)
             {
                 BikeLedCheck_B.uwLedAddcnt=0;
             }
             if(BikeLedCheck_B.uwLedAddcnt<BikeLedFlickerDuty)
             {
                 BikeLedGloFun.blBike_BackLedSta=TRUE;
             }
             else
             {
                 BikeLedGloFun.blBike_BackLedSta=FALSE;
             }
           }
           else
           {
               if(switchAction!=0)
               {
                   BikeLedGloFun.blBike_BackLedSta=TRUE;
               }
               else
               {
                   BikeLedGloFun.blBike_BackLedSta=FALSE;
                }
               BikeLedCheck_B.uwLedAddcnt=0;
           }
              break;
        }
        case Three_byte:
        {
            if(Brate_Sta==TRUE) //刹车高亮
             {
                 BikeLedGloFun.blBike_BackLedSta=TRUE;
             }
           else
           {
               BikeLedGloFun.blBike_BackLedSta=FALSE;
           }

              break;
        }
        case four_byte: //刹车闪烁
        {
            if(Brate_Sta==TRUE)
             {
                BikeLedCheck_B.uwLedAddcnt++;
                if(BikeLedCheck_B.uwLedAddcnt > BikeLedFlickerCycle)
                {
                    BikeLedCheck_B.uwLedAddcnt=0;
                }
                if(BikeLedCheck_B.uwLedAddcnt<BikeLedFlickerDuty)
                {
                    BikeLedGloFun.blBike_BackLedSta=TRUE;
                }
                else
                {
                    BikeLedGloFun.blBike_BackLedSta=FALSE;
                }
             }
             else
             {
               BikeLedGloFun.blBike_BackLedSta=FALSE;
             }
              break;
        }
        case five_byte:
        {
            BikeLedGloFun.blBike_BackLedSta=TRUE; //开机常亮
              break;
        }
        case six_byte:
        {
            if(cp_stBikeRunInfoPara.BikeSpeedKmH>=BikeLedOverSpeedMax) //超速报警
              {
                  BikeLedCheck_B.uwLedAddcnt++;
                  if(BikeLedCheck_B.uwLedAddcnt > BikeLedOverSpedCycle)
                  {
                      BikeLedCheck_B.uwLedAddcnt=0;
                  }
                  if(BikeLedCheck_B.uwLedAddcnt<BikeLedOverSpedDuty)
                  {
                      BikeLedGloFun.blBike_BackLedSta=TRUE;
                  }
                  else
                  {
                      BikeLedGloFun.blBike_BackLedSta=FALSE;
                  }
              }
              else if(cp_stBikeRunInfoPara.BikeSpeedKmH<=BikeLedOverSpeedMin)
              {
                  BikeLedGloFun.blBike_BackLedSta=FALSE;
                  BikeLedCheck_B.uwLedAddcnt=0;
              }
              break;
        }
    default:
             break;

    }
//-----------尾灯处理--------
    if( BikeLedGloFun.blBike_BackLedSta==TRUE) //尾灯控制
    {
        if(BikeLedCheck_B.uwBike_keyLedHighSta==0)
          {
              BikeLedCheck_B.uwBike_keyLedHighSta=1;
              BikeLedCheck_B.uwBike_OpenLedEn=0;//开灯瞬间处理标志
              BikeLedCheck_B.uwBike_LedOffErrCnt=0;  //10秒一检测计时
              BikeLedCheck_B.uwBike_OpenPreTime=0; //开灯瞬间5ms内处理计数
              BikeLedCheck_B.uwBike_LedCheckLowTime=0;//检测过流IO出现低电平次数
              BikeLedCheck_B.blBike_ForwardLedStart=TRUE; //前灯允许开灯启动，总开关
              BikeLedCheck_B.blBike_LedCurErr=FALSE;
              DL_TimerG_startCounter(PWM_B_L_INST);
              GPIOB->POLARITY15_0 &= ~(DL_GPIO_PIN_15_EDGE_FALL |DL_GPIO_PIN_15_EDGE_RISE);
              GPIOB->POLARITY15_0  |=DL_GPIO_PIN_15_EDGE_RISE;


  //            BikeLedCheck_B.uwBike_LedOffErrCnt=0;  //10秒一检测计时
  //            BikeLedCheck_B.uwBike_OpenPreTime=0; //开灯瞬间5ms内处理计数
  //            BikeLedGloFun.blBike_BackLedStart=TRUE;//尾灯允许开灯启动
          }
#if(DCDC_12S6V_SEL_EN==2)
      IO_LED_6or12V_EN_H();
#endif
          if((BikeLedCheck_B.uwBike_OpenLedEn==0) &&(BikeLedCheck_B.blBike_ForwardLedStart==TRUE)) //开灯检测，过流后每隔10秒检测1次
          {
           LED_EnableDeal(&BikeLedCheck_B,switchAction,B_PWM_byte);
          }
          else
          {
              GPIOB->POLARITY15_0 &= ~(DL_GPIO_PIN_15_EDGE_FALL |DL_GPIO_PIN_15_EDGE_RISE);
              GPIOB->POLARITY15_0  |=DL_GPIO_PIN_15_EDGE_FALL;
          }

          BikeLedCheck_B.uwBike_keyLedLowSta=1;
    }
    else
    {
        BikeLedCheck_B.uwBike_keyLedHighSta=0;
        if(BikeLedCheck_B.uwBike_keyLedLowSta!=0)
           {
            BikeLedCheck_B.uwBike_keyLedLowSta=0;
               BikeLedCheck_B.uwBikeLight_PWM=0;
               DL_TimerG_setCaptureCompareValue(PWM_B_L_INST, BikeLedCheck_B.uwBikeLight_PWM, GPIO_PWM_B_L_C1_IDX);//max=2304
           }
#if(DCDC_12S6V_SEL_EN==2)
      IO_LED_6or12V_EN_L();
#endif
    }



#endif




    // ---------------前灯处理------------
#if(BIKELEDOPEN_F_ENABLE!=0)
    if (switchAction == 1)
    {
        if(BikeLedCheck_F.uwBike_keyLedHighSta==0)
        {
            BikeLedCheck_F.uwBike_keyLedHighSta=1;
            BikeLedCheck_F.uwBike_OpenLedEn=0;//开灯瞬间处理标志
            BikeLedCheck_F.uwBike_LedOffErrCnt=0;  //10秒一检测计时
            BikeLedCheck_F.uwBike_OpenPreTime=0; //开灯瞬间5ms内处理计数
            BikeLedCheck_F.uwBike_LedCheckLowTime=0;//检测过流IO出现低电平次数
            BikeLedCheck_F.blBike_ForwardLedStart=TRUE; //前灯允许开灯启动，总开关
             DL_COMP_setDACCode0(COMP_FLEDCHECK_INST, 0x0f);
            BikeLedCheck_F.blBike_LedCurErr=FALSE;
            DL_TimerG_startCounter(PWM_F_INST);
//            BikeLedCheck_B.uwBike_LedOffErrCnt=0;  //10秒一检测计时
//            BikeLedCheck_B.uwBike_OpenPreTime=0; //开灯瞬间5ms内处理计数
//            BikeLedGloFun.blBike_BackLedStart=TRUE;//尾灯允许开灯启动
#if(DCDC_12S6V_SEL_EN==1)
            IO_LED_6or12V_EN_H();
#endif
        }

        if((BikeLedCheck_F.uwBike_OpenLedEn==0) &&(BikeLedCheck_F.blBike_ForwardLedStart==TRUE)) //开灯检测，过流后每隔10秒检测1次
        {
         LED_EnableDeal(&BikeLedCheck_F,switchAction,F_PWM_byte);
        }
        else
         {
#if(DCDC_12S6V_SEL_EN!=3)
             DL_COMP_setDACCode0(COMP_FLEDCHECK_INST, 0x4f);
#endif
         }

        BikeLedCheck_F.uwBike_keyLedLowSta=1;
    }
    else
    {
        BikeLedCheck_F.uwBike_keyLedHighSta=0;
     if(BikeLedCheck_F.uwBike_keyLedLowSta!=0)
        {
         BikeLedCheck_F.uwBike_keyLedLowSta=0;
            BikeLedCheck_F.uwBikeLight_PWM=0;
            DL_TimerG_setCaptureCompareValue(PWM_F_INST, BikeLedCheck_F.uwBikeLight_PWM, GPIO_PWM_F_C1_IDX);//max=2304
            BikeLedGloFun.blBike_ForwardLedFlag=FALSE; //开前灯标志
#if(DCDC_12S6V_SEL_EN==1)
            IO_LED_6or12V_EN_L();
#endif
        }
    }
#endif

    //------------右灯处理------

//    if(switchAction==1) //
//       {
//           if(BikeLedCheck_R.uwBike_keyLedHighSta==0)
//             {
//                 BikeLedCheck_R.uwBike_keyLedHighSta=1;
//                 BikeLedCheck_R.uwBike_OpenLedEn=0;//开灯瞬间处理标志
//                 BikeLedCheck_R.uwBike_LedOffErrCnt=0;  //10秒一检测计时
//                 BikeLedCheck_R.uwBike_OpenPreTime=0; //开灯瞬间5ms内处理计数
//                 BikeLedCheck_R.uwBike_LedCheckLowTime=0;//检测过流IO出现低电平次数
//                 BikeLedCheck_R.blBike_ForwardLedStart=TRUE; //前灯允许开灯启动，总开关
//                 BikeLedCheck_R.blBike_LedCurErr=FALSE;
//                 DL_TimerG_startCounter(PWM_R_INST);
//                 GPIOB->POLARITY15_0 &= ~(DL_GPIO_PIN_8_EDGE_RISE |DL_GPIO_PIN_8_EDGE_FALL);
//                 GPIOB->POLARITY15_0  |=DL_GPIO_PIN_8_EDGE_RISE;
//
//             }
//
//             if((BikeLedCheck_R.uwBike_OpenLedEn==0) &&(BikeLedCheck_R.blBike_ForwardLedStart==TRUE)) //开灯检测，过流后每隔10秒检测1次
//             {
//              LED_EnableDeal(&BikeLedCheck_R,switchAction,R_PWM_byte);
//             }
//             else
//             {
//                 GPIOB->POLARITY15_0 &= ~(DL_GPIO_PIN_8_EDGE_RISE |DL_GPIO_PIN_8_EDGE_FALL);
//                 GPIOB->POLARITY15_0  |=DL_GPIO_PIN_8_EDGE_FALL;
//             }
//
//             BikeLedCheck_R.uwBike_keyLedLowSta=1;
//       }
//       else
//       {
//           BikeLedCheck_R.uwBike_keyLedHighSta=0;
//           if(BikeLedCheck_R.uwBike_keyLedLowSta!=0)
//              {
//               BikeLedCheck_R.uwBike_keyLedLowSta=0;
//                  BikeLedCheck_R.uwBikeLight_PWM=0;
//                  DL_TimerG_setCaptureCompareValue(PWM_R_INST, BikeLedCheck_R.uwBikeLight_PWM, GPIO_PWM_R_C1_IDX);//max=2304
//              }
//       }
    //------------左灯处理------

      if(switchAction==1) //
         {
             if(BikeLedCheck_L.uwBike_keyLedHighSta==0)
               {
                   BikeLedCheck_L.uwBike_keyLedHighSta=1;
                   BikeLedCheck_L.uwBike_OpenLedEn=0;//开灯瞬间处理标志
                   BikeLedCheck_L.uwBike_LedOffErrCnt=0;  //10秒一检测计时
                   BikeLedCheck_L.uwBike_OpenPreTime=0; //开灯瞬间5ms内处理计数
                   BikeLedCheck_L.uwBike_LedCheckLowTime=0;//检测过流IO出现低电平次数
                   BikeLedCheck_L.blBike_ForwardLedStart=TRUE; //前灯允许开灯启动，总开关
                   BikeLedCheck_L.blBike_LedCurErr=FALSE;
                   DL_TimerG_startCounter(PWM_B_L_INST);
                   GPIOA->POLARITY15_0 &= ~(DL_GPIO_PIN_3_EDGE_RISE |DL_GPIO_PIN_3_EDGE_FALL);
                   GPIOA->POLARITY15_0  |=DL_GPIO_PIN_3_EDGE_RISE;


               }

               if((BikeLedCheck_L.uwBike_OpenLedEn==0) &&(BikeLedCheck_L.blBike_ForwardLedStart==TRUE)) //开灯检测，过流后每隔10秒检测1次
               {
                LED_EnableDeal(&BikeLedCheck_L,switchAction,L_PWM_byte);
               }
               else
               {
                   GPIOA->POLARITY15_0 &= ~(DL_GPIO_PIN_3_EDGE_RISE |DL_GPIO_PIN_3_EDGE_FALL);
                   GPIOA->POLARITY15_0  |=DL_GPIO_PIN_3_EDGE_FALL;
               }

               BikeLedCheck_L.uwBike_keyLedLowSta=1;
         }
         else
         {
             BikeLedCheck_L.uwBike_keyLedHighSta=0;
             if(BikeLedCheck_L.uwBike_keyLedLowSta!=0)
                {
                 BikeLedCheck_L.uwBike_keyLedLowSta=0;
                    BikeLedCheck_L.uwBikeLight_PWM=0;
                    DL_TimerG_setCaptureCompareValue(PWM_B_L_INST, BikeLedCheck_L.uwBikeLight_PWM, GPIO_PWM_B_L_C0_IDX);//max=2304
                }
         }
//---------------------
#if(BIKE_OXFORD_EN!=0)
    IO_FORWARDLED_ON(); //开前灯
    IO_BACKLED_ON();

#endif
    //--------------LED电路检测----------
//-------F_LED
    if((BikeLedCheck_F.blBike_LedCurErr==TRUE )&&(switchAction == 1))  //过流标志，前灯恢复检测
    {
        BikeLedCheck_F.uwBike_LedOffErrCnt++;
        if(BikeLedCheck_F.uwBike_LedOffErrCnt>2000) //1000ms
        {
            BikeLedCheck_F.uwBike_keyLedHighSta=0;
            BikeLedCheck_F.uwBike_LedOffErrCnt=0;
            BikeLedCheck_F.blBike_LedCurErr=FALSE;
            BikeLedCheck_F.blBike_ForwardLedStart=TRUE;//前灯允许开灯启动，总开关

        }
     }
    else
    {
        BikeLedCheck_F.uwBike_LedOffErrCnt=0;
    }

//------B_LED
    if((BikeLedCheck_B.blBike_LedCurErr==TRUE)&&(BikeLedGloFun.blBike_BackLedSta == 1)) //后灯恢复检测
    {

       BikeLedCheck_B.uwBike_LedOffErrCnt++;
       if(BikeLedCheck_B.uwBike_LedOffErrCnt>2000)
       {
           BikeLedCheck_B.uwBike_keyLedHighSta=0;
           BikeLedCheck_B.uwBike_LedOffErrCnt=0;
           BikeLedCheck_B.blBike_LedCurErr=FALSE;
           BikeLedCheck_B.blBike_ForwardLedStart=TRUE;//前灯允许开灯启动，总开关
       }

     }
    else
    {
        BikeLedCheck_B.uwBike_LedOffErrCnt=0;
    }

    //------R_LED

    if((BikeLedCheck_R.blBike_LedCurErr==TRUE )&&(switchAction == 1))  //过流标志，前灯恢复检测
    {
        BikeLedCheck_R.uwBike_LedOffErrCnt++;
        if(BikeLedCheck_R.uwBike_LedOffErrCnt>2000) //1000ms
        {
            BikeLedCheck_R.uwBike_keyLedHighSta=0;
            BikeLedCheck_R.uwBike_LedOffErrCnt=0;
            BikeLedCheck_R.blBike_LedCurErr=FALSE;
            BikeLedCheck_R.blBike_ForwardLedStart=TRUE;//前灯允许开灯启动，总开关

        }
     }
    else
    {
        BikeLedCheck_R.uwBike_LedOffErrCnt=0;
    }

    //------L_LED
    if((BikeLedCheck_L.blBike_LedCurErr==TRUE )&&(switchAction == 1))  //过流标志，前灯恢复检测
    {
        BikeLedCheck_L.uwBike_LedOffErrCnt++;
        if(BikeLedCheck_L.uwBike_LedOffErrCnt>2000) //1000ms
        {
            BikeLedCheck_L.uwBike_keyLedHighSta=0;
            BikeLedCheck_L.uwBike_LedOffErrCnt=0;
            BikeLedCheck_L.blBike_LedCurErr=FALSE;
            BikeLedCheck_L.blBike_ForwardLedStart=TRUE;//前灯允许开灯启动，总开关

        }
     }
    else
    {
        BikeLedCheck_L.uwBike_LedOffErrCnt=0;
    }
    //------


}

}

void LED_EnableDeal(BIKELEDCHECK_STR *p,UWORD switchAction,LED_PWM_STR mode )
{

if(switchAction!=0)
{


    if(p->uwBike_OpenPreTime<2000)
     p->uwBike_OpenPreTime++;
    if(p->uwBike_OpenPreTime<=2)//2ms
    {
        p->uwBikeLight_PWM=LIGHT_FIRSTPWM;//

    }
    else if(p->uwBike_OpenPreTime<=4) //
    {
       // p->uwBikeLight_PWM =691 ;//720;//
        if((p->uwBike_OpenLedEn ==0)&&(p->blBike_LedCurErr==TRUE))
        {
            p->uwBikeLight_PWM =LIGHT_SECTPWM ;//720;//
        }
        else
        {
            p->uwBikeLight_PWM=0;
        }

    }
//    else if(p->uwBike_OpenPreTime>=1000)
//    {
//        p->uwBikeLight_PWM=0;//
//        p->uwBike_OpenLedEn=1;
//    }
    if((p->uwBike_OpenPreTime>4) && (p->uwBikeLight_PWM!=0))// ||(p->uwBike_LedCheckLowTime>=2)
         {
             BikeLedGloFun.blBike_ForwardLedFlag=TRUE;
             p->blBike_LedCurErr=FALSE;
              p->uwBike_OpenLedEn=1;


         }

    if(p->uwBike_OpenLedEn!=0) //
        {
            p->uwBikeLight_PWM=2304;//

        }

}
else
{
    p->uwBikeLight_PWM=0;//
}
if(mode==F_PWM_byte)
  {
      DL_TimerG_setCaptureCompareValue(PWM_F_INST, p->uwBikeLight_PWM, GPIO_PWM_F_C1_IDX);//max=2304
  }
  else if(mode==B_PWM_byte)
  {
      DL_TimerG_setCaptureCompareValue(PWM_B_L_INST, p->uwBikeLight_PWM, GPIO_PWM_B_L_C1_IDX);//max=2304
  }
  else if(mode==L_PWM_byte)
  {
      DL_TimerG_setCaptureCompareValue(PWM_B_L_INST, p->uwBikeLight_PWM, GPIO_PWM_B_L_C0_IDX);//max=2304
  }
//  else if(mode==R_PWM_byte)
//   {
//       DL_TimerG_setCaptureCompareValue(PWM_R_INST, p->uwBikeLight_PWM, GPIO_PWM_R_C1_IDX);//max=2304
//   }


}
/*************************************************************************
 Local Functions (N/A)
*************************************************************************/

/*************************************************************************
 End of this File (EOF)!
 Do not put anything after this part!
*************************************************************************/