API tools faq
paste
Advertisement
tranthudo

drv_led.c

tranthudo
Jun 6th, 2019
105
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 21.97 KB | None | 0 0
raw download clone embed print report
  1. /*****************************************************************************
  2.  *
  3.  * MODULE:             JN-AN-1217
  4.  *
  5.  * COMPONENT:          drv_leds.c
  6.  *
  7.  * DESCRIPTION:        API for control led
  8.  *
  9.  ***************************************************************************/
  10.  
  11. /****************************************************************************/
  12. /***        Include files                                                 ***/
  13. /****************************************************************************/
  14. #include "drv_leds.h"
  15. #include "AppHardwareApi_JN516x.h"
  16. #include "dbg.h"
  17. #include "ZTimer.h"
  18. /****************************************************************************/
  19. /***        Macro Definitions                                             ***/
  20. /****************************************************************************/
  21. #ifdef DEBUG_DRV_LEDS
  22.     #define TRACE_DRV_LEDS              (TRUE)
  23. #else   /* DEBUG_DRV_LEDS */
  24.     #define TRACE_DRV_LEDS              (FALSE)
  25. #endif  /* DEBUG_DRV_LEDS */
  26.  
  27. #define PWM_CYCLE                       (20)        //ms T=20ms => f = 50Hz
  28. /****************************************************************************/
  29. /***        Type Definitions                                              ***/
  30. /****************************************************************************/
  31. // define counter
  32. typedef enum
  33. {
  34.     E_COUNTER_DIM_PWM_ON = 0,
  35.     E_COUNTER_DIM_PWM_OFF,
  36.     E_ALL_DIM_COUNTER,
  37. }DRV_LEDS_eResetCounter;
  38.  
  39. enum
  40. {
  41.     ORIGIN = 0,
  42.     CURRENT,
  43.     NUMBER_COUNTER,
  44. };
  45.  
  46. typedef enum
  47. {
  48.     E_BLINK_TIMER_NONE = 0,
  49.     E_BLINK_TIMER_ON,
  50.     E_BLINK_TIMER_OFF
  51. }DRV_LEDS_teBlinkTimerRuning;
  52.  
  53. typedef enum
  54. {
  55.     E_MAIN_BLINK_LED = 0,
  56.     E_ALTERNATE_BLINK_LED,
  57.     SIZE_OF_BLINK_LED_MASK
  58. }DRV_LEDS_teLedMaskIndex;
  59.  
  60. typedef struct
  61. {
  62.     uint8_t     u8PWMOn;            //ms
  63.     uint8_t     u8PWMOff;           //ms
  64. }DRV_LEDS_tsCounterDim;
  65.  
  66. typedef struct
  67. {
  68.     uint32_t                u32PinMask[SIZE_OF_BLINK_LED_MASK];     //[1] main led blink, [2] alternate led blink
  69.     int16_t                 i16NumberBlink;
  70.     uint16_t                u16TimeOn;          //ms
  71.     uint16_t                u16TimeOff;         //ms
  72.     fnCbAfterBlink          fnCallback;
  73.     void                    *pParams;
  74.  
  75.     DRV_LEDS_teBlinkTimerRuning eTimerRun;
  76.     uint8_t                 u8TimerIndex;
  77.     uint8_t                 u8TimerBlink;
  78. }DRV_LEDS_tsBlinkGroupLeds;
  79.  
  80. typedef struct
  81. {
  82.     DRV_LEDS_teLedLevel_t       eLedLevel;
  83.     uint32_t                    u32DimLedPinMask;
  84.  
  85.     DRV_LEDS_tsBlinkGroupLeds   sBlinkGroupLeds[MAX_NUMBER_GROUP_LED_BLINK];
  86. }DRV_LEDS_tsParams;
  87.  
  88. /****************************************************************************/
  89. /***        Local Function Prototypes                                     ***/
  90. /****************************************************************************/
  91. /* Dim led functions */
  92. PRIVATE void vStartDimTimer(void);
  93. PRIVATE void vStopDimTimer(void);
  94. PRIVATE void vDimLedsProcess(void);
  95. PRIVATE void vUpdateDimCounter(void);
  96. PRIVATE void vResetDimCounter(void);
  97. PRIVATE void vTurnOnAllDimLeds(void);
  98. PRIVATE void vTurnOffAllDimLeds(void);
  99. PRIVATE void vAddLedTo_ArrayLedDim(uint8_t u8LedPin);
  100. PRIVATE void vRemoveLedOutOf_ArrayLedDim(uint8_t u8LedPin);
  101. /* Blink led functions */
  102. PRIVATE void vcbTimerBlinkLed(void *pvParam);
  103. PRIVATE void vStartBlinkTimer(uint8_t u8TimerIndex, DRV_LEDS_teBlinkTimerRuning eTimerRun);
  104. PRIVATE void vStopBlinkTimer(uint8_t u8TimerIndex);
  105. PRIVATE bool_t bIsBlinkTimerRunning(uint8_t u8TimerIndex);
  106. PRIVATE void vRemoveLedInOtherGroupThatHaveInThisGroup(uint8_t u8GroupLedsIndex);
  107. PRIVATE void vAddBlinkLedTo_ArrayLedDim(uint8_t u8GroupLedsIndex, DRV_LEDS_teLedMaskIndex eLedMaskIndex);
  108. PRIVATE void vRemoveBlinkLedTo_ArrayLedDim(uint8_t u8GroupLedsIndex, DRV_LEDS_teLedMaskIndex eLedMaskIndex);
  109. PRIVATE void vTurnOnAllBlinkLeds(uint8_t u8GroupLedsIndex, DRV_LEDS_teLedMaskIndex eLedMaskIndex);
  110. PRIVATE void vTurnOffAllBlinkLeds(uint8_t u8GroupLedsIndex, DRV_LEDS_teLedMaskIndex eLedMaskIndex);
  111. /* Common functions */
  112. PRIVATE void vTurnLed_On(uint8_t u8LedPin);
  113. PRIVATE void vTurnLed_Off(uint8_t u8LedPin);
  114. PRIVATE bool_t bIsPinLedAlreadyInitialized(uint8_t u8LedPin);
  115. PRIVATE void vRemoveThisLedInBlinkLedGroupThatContainsIt(uint8_t u8LedPin);
  116. /****************************************************************************/
  117. /***        Exported Variables                                            ***/
  118. /****************************************************************************/
  119.  
  120. /****************************************************************************/
  121. /***        Local Variables                                               ***/
  122. /****************************************************************************/
  123. PRIVATE uint8_t             u8TimeBase = 0;
  124. PRIVATE uint16_t            u16TimerCycle = 0;
  125.  
  126. PRIVATE DRV_LEDS_tsParams   sLedParams;
  127. PRIVATE uint32_t            u32LedInitializedMask;
  128.  
  129. DRV_LEDS_tsCounterDim       sDimCounter[NUMBER_COUNTER];
  130. bool_t                      bDimTimerStopped = TRUE;
  131. /****************************************************************************/
  132. /***        Exported Functions                                            ***/
  133. /****************************************************************************/
  134. PUBLIC bool_t DRV_LEDS_bInitialize(
  135.         uint8_t                     *u8ArrLedPin,
  136.         uint8_t                     u8NumberLed,
  137.         DRV_LEDS_teLedLevel_t       eLedLevel
  138. ){
  139.     uint8_t i,j;
  140.  
  141.     u8TimeBase = PWM_CYCLE/(NUMBER_OF_LED_LEVEL - 1);
  142.     u16TimerCycle = 1000*u8TimeBase;
  143.  
  144.     if(u8NumberLed > MAX_NUMBER_LEDS_SUPPORT)
  145.     {
  146.         return FALSE;
  147.     }
  148.  
  149.     // initialize dim led
  150.     sLedParams.eLedLevel = eLedLevel;
  151.     sLedParams.u32DimLedPinMask = 0;
  152.  
  153.     // initialize blink led
  154.     for(i = 0; i < MAX_NUMBER_GROUP_LED_BLINK; i++)
  155.     {
  156.         for(j = 0; j < SIZE_OF_BLINK_LED_MASK; j++)
  157.         {
  158.             sLedParams.sBlinkGroupLeds[i].u32PinMask[j] = 0;
  159.         }
  160.         sLedParams.sBlinkGroupLeds[i].i16NumberBlink    = 0;
  161.         sLedParams.sBlinkGroupLeds[i].fnCallback        = NULL;
  162.         sLedParams.sBlinkGroupLeds[i].pParams           = NULL;
  163.         sLedParams.sBlinkGroupLeds[i].u16TimeOff        = 0;
  164.         sLedParams.sBlinkGroupLeds[i].u16TimeOn         = 0;
  165.     }
  166.  
  167.     /* Initialize led information */
  168.     u32LedInitializedMask = 0;
  169.     for(i = 0; i < u8NumberLed; i++)
  170.     {
  171.         u32LedInitializedMask |= 1UL << u8ArrLedPin[i];
  172.     }
  173.     //Set led pin as output
  174.     vAHI_DioSetDirection(0, u32LedInitializedMask);
  175.     //Turn off all the LEDs
  176.     vAHI_DioSetOutput(0, u32LedInitializedMask);
  177.     // Check special DO_0,DO_1 was required to initialize or not
  178.     if(bIsPinLedAlreadyInitialized(DO_0_PIN) || bIsPinLedAlreadyInitialized(DO_1_PIN))
  179.     {
  180.         bAHI_DoEnableOutputs(TRUE);
  181.         // Turn off led DO_0,DO_1
  182.         vAHI_DoSetDataOut(0, u32LedInitializedMask >> DO_0_PIN);
  183.     }
  184.     // Initialize blink timer
  185.     for(i = 0; i < MAX_NUMBER_GROUP_LED_BLINK; i ++)
  186.     {
  187.         sLedParams.sBlinkGroupLeds[i].u8TimerIndex = i;
  188.         sLedParams.sBlinkGroupLeds[i].eTimerRun = E_BLINK_TIMER_NONE;
  189.         (void) ZTIMER_eOpen(&sLedParams.sBlinkGroupLeds[i].u8TimerBlink,
  190.                     vcbTimerBlinkLed,
  191.                     &sLedParams.sBlinkGroupLeds[i].u8TimerIndex,
  192.                     ZTIMER_FLAG_PREVENT_SLEEP);
  193.     }
  194.     // Initialize counter
  195.     vUpdateDimCounter();
  196.     vResetDimCounter();
  197.  
  198.     /* Dim timer */
  199.     if((sLedParams.eLedLevel != LED_LEVEL_0) && (sLedParams.eLedLevel != LED_LEVEL_100) )
  200.     {
  201.         vStartDimTimer();
  202.     }
  203.  
  204.     DBG_vPrintf(TRACE_DRV_LEDS,
  205.             "DRV-LED: Led Initialize finished Time base = %d, Timer cycle = %d Timer = %d \n",
  206.             u8TimeBase, u16TimerCycle, DIM_LED_TIMER);
  207.  
  208.     return TRUE;
  209. }
  210.  
  211. PUBLIC void DRV_LEDS_vBlinkLedsAlternately(
  212.         uint8_t                 *u8ArrLedPin,
  213.         uint8_t                 u8NumberLed,
  214.         uint8_t                 *u8ArrLedPin2,
  215.         uint8_t                 u8NumberLed2,
  216.         int16_t                 i16NumberBlink,
  217.         int16_t                 i16BlinkDuration,       //ms
  218.         uint16_t                u16TimeOn,              //ms
  219.         uint16_t                u16TimeOff,             //ms
  220.         fnCbAfterBlink          fnCallback,
  221.         void                    *pParams
  222. )
  223. {
  224.     uint8_t i,j;
  225.  
  226.     if((u8ArrLedPin == NULL) || (u8NumberLed > MAX_NUMBER_LEDS_SUPPORT))
  227.         return;
  228.  
  229.     bool_t  bBlinkLedAlternately = FALSE;
  230.     if((u8ArrLedPin2 != NULL) && (u8NumberLed2 > 0) && (u8NumberLed2 < MAX_NUMBER_LEDS_SUPPORT))
  231.     {
  232.         bBlinkLedAlternately = TRUE;
  233.         //make sure all led in 2 arrays is different
  234.         bool b2ArrDiff = TRUE;
  235.         for(i = 0; i < u8NumberLed; i++)
  236.             for(j = 0; j < u8NumberLed2; j++)
  237.             {
  238.                 if( u8ArrLedPin[i] == u8ArrLedPin2[j])
  239.                 {
  240.                     b2ArrDiff = FALSE;
  241.                     DBG_vPrintf(TRACE_DRV_LEDS,
  242.                             "DRV-LED: Error Pin[%] off u8ArrLedPin =  Pin[%] off u8ArrLedPin2 \n",
  243.                             u8ArrLedPin[i], u8ArrLedPin2[j]);
  244.                 }
  245.             }
  246.         if(!b2ArrDiff)
  247.             return;
  248.     }
  249.     //Check whether all led in u8ArrLedPin,u8ArrLedPin2 already initialized or not
  250.     bool_t  bAllLedAlreadyInit = TRUE;
  251.     for(i = 0; i < u8NumberLed; i ++)
  252.     {
  253.         if(!bIsPinLedAlreadyInitialized(u8ArrLedPin[i]))
  254.         {
  255.             bAllLedAlreadyInit = FALSE;
  256.             DBG_vPrintf(TRACE_DRV_LEDS, "DRV-LED: Please initialize pin[%] in u8ArrLedPin  as led pin first \n", u8ArrLedPin[i]);
  257.         }
  258.     }
  259.     for(i = 0; i < u8NumberLed2; i ++)
  260.     {
  261.         if(!bIsPinLedAlreadyInitialized(u8ArrLedPin2[i]))
  262.         {
  263.             bAllLedAlreadyInit = FALSE;
  264.             DBG_vPrintf(TRACE_DRV_LEDS, "DRV-LED: Please initialize pin[%] in u8ArrLedPin2 as led pin first \n", u8ArrLedPin2[i]);
  265.         }
  266.     }
  267.     if(!bAllLedAlreadyInit)
  268.         return;
  269.  
  270.     /* Initialize Group led */
  271.     uint8_t u8GroupLedsIndex = MAX_NUMBER_GROUP_LED_BLINK;
  272.     for(i = 0; i < MAX_NUMBER_GROUP_LED_BLINK; i++)
  273.     {
  274.         if(sLedParams.sBlinkGroupLeds[i].eTimerRun == E_BLINK_TIMER_NONE)
  275.         {
  276.             u8GroupLedsIndex = i;
  277.             break;
  278.         }
  279.     }
  280.     if(u8GroupLedsIndex == MAX_NUMBER_GROUP_LED_BLINK)
  281.     {
  282.         u8GroupLedsIndex = 0;
  283.         if(bIsBlinkTimerRunning(u8GroupLedsIndex))
  284.         {
  285.             vStopBlinkTimer(u8GroupLedsIndex);
  286.         }
  287.         vRemoveBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  288.         vRemoveBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  289.     }
  290.     for(i = 0; i < SIZE_OF_BLINK_LED_MASK; i++)
  291.     {
  292.         sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[i] = 0;
  293.     }
  294.     for(i = 0; i < u8NumberLed; i ++)
  295.     {
  296.         sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[0] |= 1UL << u8ArrLedPin[i];
  297.     }
  298.     if(bBlinkLedAlternately)
  299.     {
  300.         for(i = 0; i < u8NumberLed2; i ++)
  301.         {
  302.             sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[1] |= 1UL << u8ArrLedPin2[i];
  303.         }
  304.     }
  305.  
  306.     if(i16NumberBlink > 0)
  307.     {
  308.         sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].i16NumberBlink = i16NumberBlink;
  309.     }
  310.     else
  311.     {
  312.         if(i16BlinkDuration > 0)
  313.         {
  314.             sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].i16NumberBlink = i16BlinkDuration/(u16TimeOn + u16TimeOff);
  315.             if(sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].i16NumberBlink == 0)
  316.             {
  317.                 DBG_vPrintf(TRACE_DRV_LEDS,
  318.                         "DRV-LED:No need to blink: Cycle = u16TimeOn + u16TimeOff >  i16BlinkDuration (%d > %d) \n",
  319.                         (u16TimeOn + u16TimeOff), i16BlinkDuration);
  320.                 return;
  321.             }
  322.         }
  323.         else
  324.         {
  325.             sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].i16NumberBlink = LED_BLINK_FOREVER;
  326.         }
  327.     }
  328.     sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u16TimeOn      = u16TimeOn;
  329.     sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u16TimeOff     = u16TimeOff;
  330.  
  331.     sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].fnCallback     = fnCallback;
  332.     sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].pParams        = pParams;
  333.  
  334.     //Remove all led in other group that has in this group
  335.     vRemoveLedInOtherGroupThatHaveInThisGroup(u8GroupLedsIndex);
  336.  
  337.     //Start timer to blink led
  338.     vAddBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  339.     vRemoveBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  340.     if(bDimTimerStopped)
  341.     {
  342.         if(sLedParams.eLedLevel != LED_LEVEL_0)
  343.         {
  344.             vTurnOnAllBlinkLeds(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  345.         }
  346.         vTurnOffAllBlinkLeds(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  347.     }
  348.  
  349.     if((bDimTimerStopped) && (sLedParams.eLedLevel != LED_LEVEL_0) && (sLedParams.eLedLevel != LED_LEVEL_100))
  350.     {
  351.         vStartDimTimer();
  352.     }
  353.     vStartBlinkTimer(u8GroupLedsIndex, E_BLINK_TIMER_ON);
  354.  
  355.     DBG_vPrintf(TRACE_DRV_LEDS, "DRV-LED: start led[%d] Alternately = %d, Time on = %d, Time off = %d \n",
  356.             u8GroupLedsIndex, bBlinkLedAlternately,
  357.             sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u16TimeOn,
  358.             sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u16TimeOff);
  359. }
  360.  
  361. PUBLIC void DRV_LEDS_vStopBlinkLeds(
  362.         bool_t                  bStopBlinkAllLeds,
  363.         uint8_t                 *u8ArrLedPin,
  364.         uint8_t                 u8NumberLed
  365. )
  366. {
  367.     uint8 i,j;
  368.     if(bStopBlinkAllLeds)
  369.     {
  370.         for(i = 0; i < MAX_NUMBER_GROUP_LED_BLINK; i++)
  371.         {
  372.             vStopBlinkTimer(i);
  373.             sLedParams.sBlinkGroupLeds[i].eTimerRun = E_BLINK_TIMER_NONE;
  374.             for(j = 0; j < SIZE_OF_BLINK_LED_MASK; j++)
  375.             {
  376.                 sLedParams.sBlinkGroupLeds[i].u32PinMask[j] = 0;
  377.             }
  378.             sLedParams.sBlinkGroupLeds[i].i16NumberBlink    = 0;
  379.             sLedParams.sBlinkGroupLeds[i].fnCallback        = NULL;
  380.             sLedParams.sBlinkGroupLeds[i].pParams           = NULL;
  381.             sLedParams.sBlinkGroupLeds[i].u16TimeOff        = 0;
  382.             sLedParams.sBlinkGroupLeds[i].u16TimeOn         = 0;
  383.         }
  384.     }
  385.     else
  386.     {
  387.         if((u8ArrLedPin == NULL) || (u8NumberLed > MAX_NUMBER_LEDS_SUPPORT))
  388.                 return;
  389.  
  390.         for(i = 0; i < u8NumberLed; i++)
  391.         {
  392.             vRemoveThisLedInBlinkLedGroupThatContainsIt(u8ArrLedPin[i]);
  393.             vTurnLed_Off(u8ArrLedPin[i]);
  394.         }
  395.     }
  396. }
  397. PUBLIC void DRV_LEDS_vSetLevel(
  398.         DRV_LEDS_teLedLevel_t   eLedLevel
  399. )
  400. {
  401.     sLedParams.eLedLevel = eLedLevel;
  402.  
  403.     if(sLedParams.eLedLevel == LED_LEVEL_0)
  404.     {
  405.         vTurnOffAllDimLeds();
  406.         vStopDimTimer();
  407.     }
  408.     else if(sLedParams.eLedLevel == LED_LEVEL_100)
  409.     {
  410.         vTurnOnAllDimLeds();
  411.         vStopDimTimer();
  412.     }
  413.     else
  414.     {
  415.         if(bDimTimerStopped)
  416.         {
  417.             vStartDimTimer();
  418.         }
  419.     }
  420.  
  421.     vUpdateDimCounter();
  422.     vResetDimCounter();
  423. }
  424.  
  425. PUBLIC void DRV_LEDS_vOn(
  426.         uint8_t                 u8LedPin
  427. )
  428. {
  429.     if(!bIsPinLedAlreadyInitialized(u8LedPin))
  430.     {
  431.         DBG_vPrintf(TRACE_DRV_LEDS, "DRV-LED: Please initialize pin[%] as led pin first \n", u8LedPin);
  432.         return;
  433.     }
  434.  
  435.     vAddLedTo_ArrayLedDim(u8LedPin);
  436.  
  437.     vRemoveThisLedInBlinkLedGroupThatContainsIt(u8LedPin);
  438.  
  439.     if(sLedParams.eLedLevel == LED_LEVEL_0)
  440.     {
  441.         vTurnLed_Off(u8LedPin);
  442.     }
  443.     else
  444.     {
  445.         vTurnLed_On(u8LedPin);
  446.     }
  447.  
  448.     vUpdateDimCounter();
  449.     vResetDimCounter();
  450.  
  451.     if(bDimTimerStopped)
  452.     {
  453.         vStartDimTimer();
  454.     }
  455.  
  456.     DBG_vPrintf(TRACE_DRV_LEDS, "DRV-LED: start led[%d], PWMon = %d, off = %d \n",
  457.             u8LedPin, sDimCounter[CURRENT].u8PWMOn, sDimCounter[CURRENT].u8PWMOff);
  458. }
  459.  
  460. PUBLIC void DRV_LEDS_vOff(
  461.         uint8_t                 u8LedPin
  462. )
  463. {
  464.     if(!bIsPinLedAlreadyInitialized(u8LedPin))
  465.     {
  466.         DBG_vPrintf(TRACE_DRV_LEDS, "DRV-LED: Please initialize pin[%] as led pin first \n", u8LedPin);
  467.         return;
  468.     }
  469.  
  470.     vRemoveLedOutOf_ArrayLedDim(u8LedPin);
  471.  
  472.     vRemoveThisLedInBlinkLedGroupThatContainsIt(u8LedPin);
  473.  
  474.     vTurnLed_Off(u8LedPin);
  475. }
  476. /****************************************************************************/
  477. /***        Local Functions                                               ***/
  478. /****************************************************************************/
  479. PUBLIC void DRV_LEDS_vISR_DimTimer(uint32 u32Device, uint32 u32ItemBitmap)
  480. {
  481.     vDimLedsProcess();
  482.     /*Start timer again*/
  483.     if(!bDimTimerStopped)
  484.     {
  485.         vStartDimTimer();
  486.     }
  487. }
  488. PRIVATE void vDimLedsProcess(void)
  489. {
  490.     static bool_t bAlreadyTurnOff = FALSE;
  491.     if(sDimCounter[CURRENT].u8PWMOn > 0)
  492.     {
  493.         sDimCounter[CURRENT].u8PWMOn --;
  494.     }
  495.     else
  496.     {
  497.         if(!bAlreadyTurnOff)
  498.         {
  499.             vTurnOffAllDimLeds();
  500.             bAlreadyTurnOff = TRUE;
  501.         }
  502.         if(sDimCounter[CURRENT].u8PWMOff  > 0)
  503.         {
  504.             sDimCounter[CURRENT].u8PWMOff --;
  505.         }
  506.         else
  507.         {
  508.             bAlreadyTurnOff = FALSE;
  509.             vTurnOnAllDimLeds();
  510.             vResetDimCounter();
  511.         }
  512.     }
  513. }
  514.  
  515. PRIVATE void vStartDimTimer(void)
  516. {
  517.     // Start Hardware Timer0 as Base time to Blink led and PWM led
  518.     vAHI_TimerEnable(DIM_LED_TIMER, 4, FALSE, TRUE, FALSE);     // clock for timer = 16/2^4 = 1Mhz
  519.     vAHI_TimerClockSelect(DIM_LED_TIMER, FALSE, FALSE);
  520.     vAHI_TimerStartSingleShot(DIM_LED_TIMER, 0, u16TimerCycle); // 1000 cycles * 1MHz = 1ms
  521.     bDimTimerStopped = FALSE;
  522. }
  523.  
  524. PRIVATE void vStopDimTimer(void)
  525. {
  526.     vAHI_TimerStop(DIM_LED_TIMER);
  527.     bDimTimerStopped = TRUE;
  528. }
  529.  
  530. PRIVATE void vcbTimerBlinkLed(void *pvParam)
  531. {
  532.     if (NULL == pvParam) return;
  533.     uint8_t u8GroupLedsIndex = *((uint8_t*)pvParam);
  534.     vStopBlinkTimer(u8GroupLedsIndex);
  535.  
  536.     if(sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].i16NumberBlink == 0)
  537.     {
  538.         vRemoveBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  539.         vRemoveBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  540.  
  541.         vTurnOffAllBlinkLeds(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  542.         vTurnOffAllBlinkLeds(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  543.  
  544.         sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].eTimerRun = E_BLINK_TIMER_NONE;
  545.         if(NULL != sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].fnCallback)
  546.         {
  547.             // Callback function
  548.             sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].fnCallback(sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].pParams);
  549.         }
  550.         return;
  551.     }
  552.  
  553.     /* Start timer again */
  554.     if(E_BLINK_TIMER_ON == sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].eTimerRun)
  555.     {
  556.         if(sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].i16NumberBlink != LED_BLINK_FOREVER)
  557.         {
  558.             sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].i16NumberBlink --;
  559.         }
  560.  
  561.         vRemoveBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  562.         vAddBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  563.  
  564.         vTurnOffAllBlinkLeds(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  565.         if(sLedParams.eLedLevel != LED_LEVEL_0)
  566.         {
  567.             vTurnOnAllBlinkLeds(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  568.         }
  569.  
  570.         vStartBlinkTimer(u8GroupLedsIndex, E_BLINK_TIMER_OFF);
  571.     }
  572.     else if(E_BLINK_TIMER_OFF == sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].eTimerRun)
  573.     {
  574.         vAddBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  575.         vRemoveBlinkLedTo_ArrayLedDim(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  576.  
  577.         vTurnOffAllBlinkLeds(u8GroupLedsIndex, E_ALTERNATE_BLINK_LED);
  578.         if(sLedParams.eLedLevel != LED_LEVEL_0)
  579.         {
  580.             vTurnOnAllBlinkLeds(u8GroupLedsIndex, E_MAIN_BLINK_LED);
  581.         }
  582.  
  583.         vStartBlinkTimer(u8GroupLedsIndex, E_BLINK_TIMER_ON);
  584.     }
  585.  
  586. }
  587.  
  588. PRIVATE void vStartBlinkTimer(uint8_t u8TimerIndex, DRV_LEDS_teBlinkTimerRuning eTimerRun)
  589. {
  590.     switch(eTimerRun)
  591.     {
  592.     case E_BLINK_TIMER_ON:
  593.         ZTIMER_eStart(sLedParams.sBlinkGroupLeds[u8TimerIndex].u8TimerBlink, sLedParams.sBlinkGroupLeds[u8TimerIndex].u16TimeOn);
  594.         sLedParams.sBlinkGroupLeds[u8TimerIndex].eTimerRun = E_BLINK_TIMER_ON;
  595.         break;
  596.  
  597.     case E_BLINK_TIMER_OFF:
  598.         ZTIMER_eStart(sLedParams.sBlinkGroupLeds[u8TimerIndex].u8TimerBlink, sLedParams.sBlinkGroupLeds[u8TimerIndex].u16TimeOff);
  599.         sLedParams.sBlinkGroupLeds[u8TimerIndex].eTimerRun = E_BLINK_TIMER_OFF;
  600.             break;
  601.     default:
  602.         break;
  603.     }
  604. }
  605.  
  606. PRIVATE void vStopBlinkTimer(uint8_t u8TimerIndex)
  607. {
  608.     ZTIMER_eStop(sLedParams.sBlinkGroupLeds[u8TimerIndex].u8TimerBlink);
  609. }
  610.  
  611. PRIVATE bool_t  bIsBlinkTimerRunning(uint8_t u8TimerIndex)
  612. {
  613.     return (ZTIMER_eGetState(sLedParams.sBlinkGroupLeds[u8TimerIndex].u8TimerBlink) == E_ZTIMER_STATE_RUNNING);
  614. }
  615.  
  616. PRIVATE void vRemoveLedInOtherGroupThatHaveInThisGroup(uint8_t u8GroupLedsIndex)
  617. {
  618.     uint8 i,j,k;
  619.     for(i = 0; i < MAX_NUMBER_GROUP_LED_BLINK; i++)
  620.     {
  621.         if(i != u8GroupLedsIndex)
  622.         {
  623.             for(j = 0; j < SIZE_OF_BLINK_LED_MASK; j++)
  624.                 for(k = 0; k < SIZE_OF_BLINK_LED_MASK; k++)
  625.                     sLedParams.sBlinkGroupLeds[i].u32PinMask[j] &= ~sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[k];
  626.         }
  627.     }
  628. }
  629.  
  630. PRIVATE void vAddBlinkLedTo_ArrayLedDim(uint8_t u8GroupLedsIndex, DRV_LEDS_teLedMaskIndex eLedMaskIndex)
  631. {
  632.     sLedParams.u32DimLedPinMask |= sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[eLedMaskIndex];
  633. }
  634.  
  635. PRIVATE void vRemoveBlinkLedTo_ArrayLedDim(uint8_t u8GroupLedsIndex, DRV_LEDS_teLedMaskIndex eLedMaskIndex)
  636. {
  637.     sLedParams.u32DimLedPinMask &= ~sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[eLedMaskIndex];
  638. }
  639.  
  640. PRIVATE void vUpdateDimCounter(void)
  641. {
  642.     sDimCounter[ORIGIN].u8PWMOn     = sLedParams.eLedLevel;                                     //number of time base
  643.     sDimCounter[ORIGIN].u8PWMOff    = (NUMBER_OF_LED_LEVEL - 1) - sDimCounter[ORIGIN].u8PWMOn;  //number of time base
  644. }
  645.  
  646. PRIVATE void vResetDimCounter(void)
  647. {
  648.     sDimCounter[CURRENT].u8PWMOn    = sDimCounter[ORIGIN].u8PWMOn;
  649.     sDimCounter[CURRENT].u8PWMOff   = sDimCounter[ORIGIN].u8PWMOff;
  650. }
  651.  
  652. PRIVATE void vTurnLed_On(uint8_t u8LedPin)
  653. {
  654.     vAHI_DioSetOutput(1UL << u8LedPin, 0);
  655.     // Turn on led DO_0,DO_1
  656.     if(u8LedPin == DO_0_PIN)
  657.     {
  658.         vAHI_DoSetDataOut(0x01, 0);
  659.     }
  660.     else if(u8LedPin == DO_1_PIN)
  661.     {
  662.         vAHI_DoSetDataOut(0x02, 0);
  663.     }
  664. }
  665.  
  666. PRIVATE void vTurnLed_Off(uint8_t u8LedPin)
  667. {
  668.     vAHI_DioSetOutput(0, 1UL << u8LedPin);
  669.     // Turn off led DO_0,DO_1
  670.     if(u8LedPin == DO_0_PIN)
  671.     {
  672.         vAHI_DoSetDataOut(0, 0x01);
  673.     }
  674.     else if(u8LedPin == DO_1_PIN)
  675.     {
  676.         vAHI_DoSetDataOut(0, 0x02);
  677.     }
  678. }
  679.  
  680. PRIVATE void vTurnOnAllDimLeds(void)
  681. {
  682.     vAHI_DioSetOutput(sLedParams.u32DimLedPinMask, 0);
  683.     // Turn on led DO_0,DO_1
  684.     vAHI_DoSetDataOut(sLedParams.u32DimLedPinMask >> DO_0_PIN, 0);
  685. }
  686.  
  687. PRIVATE void vTurnOffAllDimLeds(void)
  688. {
  689.     vAHI_DioSetOutput(0, sLedParams.u32DimLedPinMask);
  690.     // Turn off led DO_0,DO_1
  691.     vAHI_DoSetDataOut(0, sLedParams.u32DimLedPinMask >> DO_0_PIN);
  692. }
  693.  
  694. PRIVATE void vTurnOnAllBlinkLeds(uint8_t u8GroupLedsIndex, DRV_LEDS_teLedMaskIndex eLedMaskIndex)
  695. {
  696.     vAHI_DioSetOutput(sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[eLedMaskIndex], 0);
  697.     // Turn on led DO_0,DO_1
  698.     vAHI_DoSetDataOut(sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[eLedMaskIndex] >> DO_0_PIN, 0);
  699. }
  700.  
  701. PRIVATE void vTurnOffAllBlinkLeds(uint8_t u8GroupLedsIndex, DRV_LEDS_teLedMaskIndex eLedMaskIndex)
  702. {
  703.     vAHI_DioSetOutput(0, sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[eLedMaskIndex]);
  704.     // Turn off led DO_0,DO_1
  705.     vAHI_DoSetDataOut(0, sLedParams.sBlinkGroupLeds[u8GroupLedsIndex].u32PinMask[eLedMaskIndex] >> DO_0_PIN);
  706. }
  707.  
  708. PRIVATE bool_t bIsPinLedAlreadyInitialized(uint8_t u8LedPin)
  709. {
  710.     return ((u32LedInitializedMask >> u8LedPin) & 1U);
  711. }
  712.  
  713. PRIVATE void vAddLedTo_ArrayLedDim(uint8_t u8LedPin)
  714. {
  715.     sLedParams.u32DimLedPinMask |= 1UL << u8LedPin;
  716. }
  717.  
  718. PRIVATE void vRemoveLedOutOf_ArrayLedDim(uint8_t u8LedPin)
  719. {
  720.     sLedParams.u32DimLedPinMask &= ~(1UL << u8LedPin);
  721. }
  722.  
  723. PRIVATE void vRemoveThisLedInBlinkLedGroupThatContainsIt(uint8_t u8LedPin)
  724. {
  725.     uint8 i,j;
  726.     for(i = 0; i < MAX_NUMBER_GROUP_LED_BLINK; i++)
  727.         for(j = 0; j < SIZE_OF_BLINK_LED_MASK; j++)
  728.         {
  729.             sLedParams.sBlinkGroupLeds[i].u32PinMask[j] &= ~(1UL << u8LedPin);
  730.         }
  731. }
  732. /****************************************************************************/
  733. /***        END OF FILE                                                   ***/
  734. /****************************************************************************/
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!