ISCS_KEY_BASE_CAN/OnlyUpdateApp_IAP/APP/led.c

#include "led.h"
#include "define.h"
#include "stdarg.h"

static tmosTaskID led_task_id = INVALID_TASK_ID;

static void stat_led_work_stat(bool stat);

static led_work_s led_work[LED_TYPE_MAX] = {
  {
      .stat = LED_STAT_OFF,
      .work_stat = LED_WORK_OFF,
      .single_flicker_period = 0,
      .flicker_period = 0,
      .flicker_onperiod = 0,
      .flicker_count = 0,
      .set_work_stat = stat_led_work_stat,
  }
};

/**
 * gpio初始化函数
 */
static void led_gpio_init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure={0};

    LED_GPIO_RCC_ENABLE;

    GPIO_InitStructure.GPIO_Pin = DEV_LED_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_Init(DEV_LED_GPIO, &GPIO_InitStructure);
    DEV_LED_OFF;
}

static void stat_led_work_stat(bool stat)
{
	SET_DEV_LED(stat);
}

static void led_invert(led_work_s *led_work)
{
    if(led_work->flicker_count > 0)
    {
        if(led_work->single_flicker_period == 0)
        {
            led_work->single_flicker_period = led_work->flicker_period;
            led_work->stat = LED_STAT_ON;
            led_work->set_work_stat(true);
        }
        else if(led_work->single_flicker_period == (led_work->flicker_period - led_work->flicker_onperiod))
        {
            led_work->single_flicker_period--;
            led_work->stat = LED_STAT_OFF;
            led_work->set_work_stat(false);
            led_work->flicker_count--;
        }
        else{
            led_work->single_flicker_period--;
        }
    }
    else{
        led_work->work_stat = LED_WORK_OFF;
        led_work->set_work_stat(false);
    }
}

static void led_indication(led_work_s *led_work)
{
    switch(led_work->work_stat)
    {
	case LED_WORK_OFF:
	{
	    break;
	}
	case LED_WORK_ON:
	{
	    break;
	}
	case LED_WORK_INVERT:
	{
	    led_invert(led_work);
	    break;
	}
	default:break;
    }
}

static void led_task(void)
{
    for(int i = 0; i < LED_TYPE_MAX; i++)
    {
	led_indication(&led_work[i]);
    }
}

//task的event处理回调函数,需要在注册task时候,传进去
static uint16_t led_task_process_event(uint8_t task_id, uint16_t events)
{
    //event 处理
    if(events & (1 << LED_QUEUE_PLAY))
    {
	return (events ^ (1 << LED_QUEUE_PLAY));
    }
    //event 处理
    if(events & (1 << LED_QUEUE_TIME))
    {
	led_task();
	return (events ^ (1 << LED_QUEUE_TIME)); //异或的方式清除该事件运行标志，并返回未运行的事件标志
    }

    return 0;
}



bool set_led_indication(LED_TYPE type, LED_WORK_STAT work_stat, ...)
{
    bool stat = false;

    if(type >= LED_TYPE_MAX)
    {
	goto exit;
    }

    if(work_stat == LED_WORK_OFF || work_stat == LED_WORK_ON)
    {
        led_work[type].work_stat = work_stat;
        led_work[type].set_work_stat((work_stat == LED_WORK_ON)?true:false);
        stat = true;
    }
    else if(work_stat == LED_WORK_INVERT)
    {
        led_work[type].work_stat = work_stat;

        va_list ap;    						//保存所有参数
        va_start(ap, work_stat);	//第一个参数的位置
        led_work[type].flicker_period = va_arg(ap, uint32_t)/LED_INTERVAL;
        led_work[type].flicker_onperiod = va_arg(ap, uint32_t)/LED_INTERVAL;
        led_work[type].flicker_count = va_arg(ap, uint32_t);
        if(led_work[type].flicker_count == 0)
        {
            led_work[type].flicker_count = 0x7FFFFFFF;
        }
        va_end(ap);

        stat = true;
    }
exit:
    return stat;
}

void led_task_init(void)
{
    led_gpio_init();
    led_task_id  = TMOS_ProcessEventRegister(led_task_process_event);
}

void led_task_start(void)
{
    bStatus_t stat = tmos_start_reload_task(led_task_id, (1 << LED_QUEUE_TIME), MS1_TO_SYSTEM_TIME(LED_INTERVAL));
}

void led_enter_ota(void)
{
  set_led_indication(STAT_LED, LED_WORK_INVERT, 2000, 1000, 0);
}

void led_data_ota(void)
{
  set_led_indication(STAT_LED, LED_WORK_INVERT, 20, 10, 5);
}