/**************************************************************************
 *
 *       Copyright (c) 2009-2023 by SiFar Technology, Inc.
 *
 *  This software is copyrighted by and is the property of SiFar
 *  Technology, Inc.. All rights are reserved by SiFar Technology, Inc..
 *  This software may only be used in accordance with the corresponding
 *  license agreement. Any unauthorized use, duplication, distribution,
 *  or disclosure of this software is expressly forbidden.
 *
 *  This Copyright notice MUST not be removed or modified without prior
 *  written consent of SiFar Technology, Inc..
 *
 *  SiFar Technology, Inc. reserves the right to modify this software without notice.
 *
 *  Author: Payton
 *  Ver: 1.0.0  2023.01.29
 *  Description: 
 *
**************************************************************************/

#include <stdio.h>
#include <kwrap/util.h>
#include <sf_led.h>
//#include "DxOutput.h"
//#include "DxCfg.h"
#include "IOCfg.h"
#include "DxHunting.h"
#include "kwrap/type.h"
#include <comm/bin_info.h>
#include "modelext_info.h"
#include "DrvExt.h"
#include "PrjInc.h"
#include <kwrap/debug.h>
#include "sf_mcu.h"

void sf_trigger_time_led_cb(UINT32 cnt)
{
	printf("[%s:%d] led\n", __FUNCTION__, __LINE__);
	gpio_direction_output(GPIO_GREEN_LED, 1);
	gpio_set_value(GPIO_GREEN_LED, cnt);
}

#if 1

VK_TASK_HANDLE ledTskId;

//static BOOL isIrLedOn = FALSE;
static BOOL isGoToPir = FALSE;
static unsigned char isLedExit = 1;

static BOOL isUsbIn = FALSE;
#if HW_S530
VK_TASK_HANDLE ledRunningTskId;

static BOOL isRunningLedOn = FALSE;
static UINT8 FormatSdFlag = 0;
#endif

LedInfo_t LedInfo[SF_LED_ALL] = {
    /*  ledId,           ledstate,    times,  gpioNum */
    #if HW_S530
    {SF_LED_STATUS_R, SF_LED_STATE_OFF, 0, DSI_GPIO_8},
    {SF_LED_STATUS_G, SF_LED_STATE_OFF, 0, DSI_GPIO_9},
    {SF_LED_SD_G,     SF_LED_STATE_OFF, 0, DSI_GPIO_7},
    {SF_LED_SD_R,     SF_LED_STATE_OFF, 0, DSI_GPIO_4},
    {SF_LED_WIFI,     SF_LED_STATE_OFF, 0, DSI_GPIO_6},
    {SF_LED_BAT1,     SF_LED_STATE_OFF, 0, DSI_GPIO_5},
    {SF_LED_BAT2,     SF_LED_STATE_OFF, 0, DSI_GPIO_2},
    {SF_LED_BAT3,     SF_LED_STATE_OFF, 0, DSI_GPIO_3},
    {SF_LED_BAT4,     SF_LED_STATE_OFF, 0, DSI_GPIO_0},
    {SF_LED_SIG1_R,   SF_LED_STATE_OFF, 0, DSI_GPIO_10},
    {SF_LED_SIG1_G,   SF_LED_STATE_OFF, 0, DSI_GPIO_1},
    {SF_LED_SIG2,     SF_LED_STATE_OFF, 0, L_GPIO_1},
    {SF_LED_SIG3,     SF_LED_STATE_OFF, 0, L_GPIO_0},
    {SF_LED_SIG4,     SF_LED_STATE_OFF, 0, P_GPIO_8},
    #endif
    {SF_LED_BUSY,     SF_LED_STATE_OFF, 0, P_GPIO_10},
};
    
//ID FLG_ID_SF_LED = 0;

// Flag
//#define FLG_SF_LED_IDLE          FLGPTN_BIT(0)
//#define FLG_SF_LED               FLGPTN_BIT(1)
//#define FLG_SF_LED_ALL           0xFFFFFFFF

static void sf_led_on(LedId_t ledId)
{ 
    //gpio_setPin(LedInfo[ledId].gpioNum);
    //printf("[%s:%d] gpioNum:%d ledId:%d\n", __FUNCTION__, __LINE__,LedInfo[ledId].gpioNum,ledId);
    gpio_set_value(LedInfo[ledId].gpioNum, SF_LED_STATE_ON);
}


static void sf_led_off(LedId_t ledId)
{
    //gpio_clearPin(LedInfo[ledId].gpioNum);
    //printf("[%s:%d] gpioNum:%d ledId:%d\n", __FUNCTION__, __LINE__,LedInfo[ledId].gpioNum,ledId);
    gpio_set_value(LedInfo[ledId].gpioNum, SF_LED_STATE_OFF);
}
#if HW_S530
void sf_set_runningLed(BOOL status)
{
    isRunningLedOn = status;
}

THREAD_RETTYPE sf_runningLed_thread(void *arg)
{
	THREAD_ENTRY();
    UINT8 run = 0;
    UINT8 time = 0;
    
    while(isLedExit)
    {
        if(isRunningLedOn)
        {
            time++;

            if(time == 50)
            {
                time = 0;
                
                switch(run)
                {
                    case 0:
                        sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG2, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
                        run++;
                        break;

                    case 1:
                        sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG2, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
                        run++;
                        break;

                    case 2:
                        sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG2, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
                        run++;
                        break;

                    case 3:
                        sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG2, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG3, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
                        run++;
                        break;

                    case 4:
                        sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
                        sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG2, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG3, SF_LED_STATE_ON);
                        sf_led_set(SF_LED_SIG4, SF_LED_STATE_ON);
                        run = 0;
                        break;
                }
            }
        }
        else
        {
            run = 0;
            time = 0;
        }
        vos_util_delay_ms(10);
    }

    printf("[%s:%d] e \n", __FUNCTION__, __LINE__);
    THREAD_RETURN(0);

}
#endif


THREAD_RETTYPE sf_led_thread(void *arg)
{
    THREAD_ENTRY();
    UINT8 i = 0;

    /*gpio init*/
    for(i = 0; i < SF_LED_ALL; i++)
    {
        
        //gpio_setDir(LedInfo[i].gpioNum, GPIO_DIR_OUTPUT);
        
        //gpio_setPin(LedInfo[i].gpioNum);
        gpio_direction_output(LedInfo[i].gpioNum,GPIO_DIR_OUTPUT);
        //gpio_direction_output(LedInfo[i].gpioNum, GPIO_DIR_OUTPUT);
        gpio_set_value(LedInfo[i].gpioNum, LedInfo[i].ledstate);
    }

    //FLGPTN  FlgPtn;
    printf("[%s:%d] s\n", __FUNCTION__, __LINE__);
    while(isLedExit)
    {
        
        for(i = 0; i < SF_LED_ALL; i++)
        {
            if(isUsbIn)
            {
                if((SF_LED_BUSY == i)/* || (i == SF_LED_STATUS_G)*/)
                {
                    sf_led_on(LedInfo[i].ledId);
                }
                else
                {
                    sf_led_off(LedInfo[i].ledId);
                }
            }
            else if(isGoToPir)
            {
                if(i < SF_LED_BUSY)
                {
                    sf_led_off(LedInfo[i].ledId);
                }
                else
                {
                    if(LedInfo[i].times == 0)
                    {
                        sf_led_off(LedInfo[i].ledId);
                    }
                    else if(LedInfo[i].times == 25)  //50*10ms
                    {
                        sf_led_on(LedInfo[i].ledId);
                    }
                    else if(LedInfo[i].times == 50)  //100*10ms
                    {
                        sf_led_off(LedInfo[i].ledId);
                        LedInfo[i].times = 0;
                    }
                    LedInfo[i].times++;
                }
            }
            else if(LedInfo[i].ledstate == SF_LED_STATE_OFF)
            {
                sf_led_off(LedInfo[i].ledId);
            }
            else if(LedInfo[i].ledstate == SF_LED_STATE_ON)
            {
                sf_led_on(LedInfo[i].ledId);
            }
            #if HW_S530
            else if(LedInfo[i].ledstate == SF_LED_STATE_SLOW_FLASHING)
            {
                if(LedInfo[i].times == 0)
                {
                    sf_led_on(LedInfo[i].ledId);
                }
                else if(LedInfo[i].times == 50)  //50*10ms
                {
                    sf_led_off(LedInfo[i].ledId);
                }
                else if(LedInfo[i].times == 100)  //100*10ms
                {
                    sf_led_on(LedInfo[i].ledId);
                    LedInfo[i].times = 0;
                }
                LedInfo[i].times++;
            }
            else if(LedInfo[i].ledstate == SF_LED_STATE_FLASHING)
            {
                if(LedInfo[i].times == 0)
                {
                    sf_led_on(LedInfo[i].ledId);
                }
                else if(LedInfo[i].times == 25)  //25*10ms
                {
                    sf_led_off(LedInfo[i].ledId);
                }
                else if(LedInfo[i].times == 50)  //50*10ms
                {
                    sf_led_on(LedInfo[i].ledId);
                    LedInfo[i].times = 0;
                }
                LedInfo[i].times++;
            }
            #endif
        }
        vos_util_delay_ms(2);
    }
    
    printf("[%s:%d] e \n", __FUNCTION__, __LINE__);
	THREAD_RETURN(0);

}


UINT8 sf_led_set(LedId_t ledId, Ledstate_t ledstate)
{
    UINT8 i = 0;

    if(ledId == SF_LED_ALL)
    {
        /*printf("led id:ALL, state:%d\n", ledstate);*/
        for(i = 0; i < SF_LED_ALL; i++)
        {
            LedInfo[i].ledstate = ledstate;
            LedInfo[i].times = 0;
        }
        return 0;
    }
    else if(ledId < SF_LED_ALL)
    {
        /*printf("led id:%d, state:%d\n", ledId,ledstate);*/
        LedInfo[ledId].ledstate = ledstate;
        LedInfo[ledId].times = 0;
        return 0;
    }
    else
    {
        return 1;
    }
}


Ledstate_t sf_led_get(LedId_t ledId)
{
    return LedInfo[ledId].ledstate;
}


void sf_led_init(void)
{
	UINT8 i = 0;
	static UINT8 dofirst = 1;
	printf("[%s:%d] s\n", __FUNCTION__, __LINE__);
    UINT8 startup = sf_get_power_on_mode();
    if(((PWR_ON_SETUP != startup) && (PWR_ON_USB != startup)))
        return;

    if(!dofirst)
		return;
	dofirst = 0;

	/*gpio init*/
	for(i = 0; i < SF_LED_ALL; i++)
	{
        //gpio_setDir(LedInfo[i].gpioNum, GPIO_DIR_OUTPUT);
		//gpio_setPin(LedInfo[i].gpioNum);
        gpio_direction_output(LedInfo[i].gpioNum, GPIO_DIR_OUTPUT);
        gpio_set_value(LedInfo[i].gpioNum, LedInfo[i].ledstate);
	}

	//vos_flag_create(&FLG_ID_SF_LED, NULL, "FLG_ID_SF_LED");
	/*thread creat*/
   ledTskId = vos_task_create(sf_led_thread, NULL, "sf_led_thread", 25, 2048);
	vos_task_resume(ledTskId);
     #if HW_S530
     /*thread creat*/
    ledRunningTskId = vos_task_create(sf_runningLed_thread, NULL, "sf_runningLed_thread", 25, 2048);
     vos_task_resume(ledRunningTskId);
    #endif
	printf("[%s:%d] e SF_LED_ALL:%d\n", __FUNCTION__, __LINE__,SF_LED_ALL);
}

void sf_led_stop(void)
{
    printf("[%s:%d] e\n", __FUNCTION__, __LINE__);
}


void sf_sys_status_led_set(LedSysState_t ledSysStateId)
{
    UINT8 startup = sf_get_power_on_mode();
    if(((PWR_ON_SETUP != startup) && (PWR_ON_AUTO != startup) && (PWR_ON_USB != startup)))
        return;
    if((ledSysStateId != SF_LED_SYS_STATE_PIR_DETECT) && (ledSysStateId != SF_LED_SYS_STATE_PIR_NOT_DETECT))
        printf("SYS LED SET %d\n", ledSysStateId);
    switch(ledSysStateId)
    {
        #if HW_S530
        case SF_LED_SYS_STATE_ERROR:
            sf_led_set(SF_LED_STATUS_G, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_STATUS_R, SF_LED_STATE_FLASHING);
            break;

        case SF_LED_SYS_STATE_NORMAL:
            sf_led_set(SF_LED_STATUS_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_STATUS_R, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_UPDATE:
            sf_led_set(SF_LED_STATUS_G, SF_LED_STATE_FLASHING);
            sf_led_set(SF_LED_STATUS_R, SF_LED_STATE_OFF);
            break;
            
        case SF_LED_SYS_STATE_SENDING:
            sf_led_set(SF_LED_STATUS_G, SF_LED_STATE_SLOW_FLASHING);
            sf_led_set(SF_LED_STATUS_R, SF_LED_STATE_OFF);
            break;  
        case SF_LED_SYS_STATE_SEND_FAIL:
            sf_led_set(SF_LED_STATUS_G, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_STATUS_R, SF_LED_STATE_ON);
            break;

        case SF_LED_SYS_STATE_SEND_SUCCESS:
            sf_led_set(SF_LED_STATUS_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_STATUS_R, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_SD_NORMAL:
            sf_led_set(SF_LED_SD_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SD_R, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_SD_ERROR:
            sf_led_set(SF_LED_SD_G, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SD_R, SF_LED_STATE_ON);
            break;

        case SF_LED_SYS_STATE_SD_FULL:
            sf_led_set(SF_LED_SD_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SD_R, SF_LED_STATE_ON);
            break;

        case SF_LED_SYS_STATE_SD_FORMAT_START:
            FormatSdFlag = 1;
            sf_led_set(SF_LED_BUSY, SF_LED_STATE_OFF);
            sf_set_runningLed(0);
            break;

        case SF_LED_SYS_STATE_SD_FORMAT_SUCCESS:
            FormatSdFlag = 2;
            break;

        case SF_LED_SYS_STATE_SD_FORMAT_FAIL:
            FormatSdFlag = 3;
            break;

        case SF_LED_SYS_STATE_SD_FORMAT_EXIT:
            FormatSdFlag = 0;
            sf_led_set(SF_LED_BUSY, SF_LED_STATE_ON);
            //sf_set_runningLed(0);
            break;
#if (defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_))
        case SF_LED_SYS_STATE_WIFI_DISCONNECT:
            sf_led_set(SF_LED_WIFI, SF_LED_STATE_SLOW_FLASHING);
            break;

        case SF_LED_SYS_STATE_WIFI_CONNECTED:
            sf_led_set(SF_LED_WIFI, SF_LED_STATE_ON);
            break;

        case SF_LED_SYS_STATE_BAT_0:
            sf_led_set(SF_LED_BAT1, SF_LED_STATE_FLASHING);
            sf_led_set(SF_LED_BAT2, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_BAT3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_BAT4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_BAT_1:
            sf_led_set(SF_LED_BAT1, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT2, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_BAT3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_BAT4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_BAT_2:
            sf_led_set(SF_LED_BAT1, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT2, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_BAT4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_BAT_3:
            sf_led_set(SF_LED_BAT1, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT2, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT3, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_BAT_4:
            sf_led_set(SF_LED_BAT1, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT2, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT3, SF_LED_STATE_ON);
            sf_led_set(SF_LED_BAT4, SF_LED_STATE_ON);
            break;

        case SF_LED_SYS_STATE_GPRS_NO_SIGNAL:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG2, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
            break;
            
        case SF_LED_SYS_STATE_GPRS_SIGNAL_0:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG2, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_GPRS_SIGNAL_1:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG2, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_GPRS_SIGNAL_2:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG2, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_GPRS_SIGNAL_3:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG2, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG3, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_GPRS_SIGNAL_4:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG2, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG3, SF_LED_STATE_ON);
            sf_led_set(SF_LED_SIG4, SF_LED_STATE_ON);
            break;

        case SF_LED_SYS_STATE_GPRS_SEARCH:
            sf_set_runningLed(1);
            break;

        case SF_LED_SYS_STATE_SIM_ERROR:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_FLASHING);
            sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG2, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_SERVER_FAIL:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_SIG1_R, SF_LED_STATE_SLOW_FLASHING);
            sf_led_set(SF_LED_SIG1_G, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG2, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_SIG4, SF_LED_STATE_OFF);
            break;
        
        case SF_LED_SYS_STATE_DEBUG_ON:
            sf_led_set(SF_LED_SD_G, SF_LED_STATE_FLASHING);
            sf_led_set(SF_LED_SD_R, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_DEBUG_OFF:
            sf_led_set(SF_LED_STATUS_G, SF_LED_STATE_ON);
            sf_led_set(SF_LED_STATUS_R, SF_LED_STATE_ON);
            break;

#endif
        case SF_LED_SYS_STATE_RESET:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_ALL, SF_LED_STATE_ON);
            break;

        case SF_LED_SYS_STATE_USB_IN:
            sf_set_runningLed(0);
            sf_led_set(SF_LED_ALL, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_BUSY, SF_LED_STATE_ON);
            #if (defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_))
            sf_led_set(SF_LED_STATUS_G, SF_LED_STATE_ON);
            #endif
            isUsbIn = TRUE;
            break;
        #endif  
        //#if HW_S510
         //   case SF_LED_SYS_STATE_UPDATE:
        //        sf_led_set(SF_LED_BUSY, SF_LED_STATE_SLOW_FLASHING);
        //        break;
        //#endif

        case SF_LED_SYS_STATE_GOING_TO_PIR:
            isGoToPir = TRUE;
            sf_led_set(SF_LED_BUSY, SF_LED_STATE_OFF);
            break;
        
        case SF_LED_SYS_STATE_EXIT_GO_TO_PIR:
            isGoToPir = FALSE;
            sf_led_set(SF_LED_BUSY, SF_LED_STATE_ON);
            break;
    
        case SF_LED_SYS_STATE_POWER_OFF:
            #if HW_S530 
            sf_set_runningLed(0);
            #endif
            sf_led_set(SF_LED_ALL, SF_LED_STATE_OFF);
            isGoToPir = FALSE;
            break;
            
        case SF_LED_SYS_STATE_PIR_DETECT:
            sf_led_set(SF_LED_BUSY, SF_LED_STATE_OFF);
            break;

        case SF_LED_SYS_STATE_PIR_NOT_DETECT:
            sf_led_set(SF_LED_BUSY, SF_LED_STATE_ON);
            break;
        #if (defined(_MODEL_565_HUNTING_EVB_LINUX_4G_S530_))
        case SF_LED_SYS_STATE_BAT_0_SLOW:
            sf_led_set(SF_LED_BAT1, SF_LED_STATE_SLOW_FLASHING);
            sf_led_set(SF_LED_BAT2, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_BAT3, SF_LED_STATE_OFF);
            sf_led_set(SF_LED_BAT4, SF_LED_STATE_OFF);
            break;
        #endif
        default:
            break;
    }

}


#endif