ISCS_CABINET_CONTROL/mainboard/components/ws2812b/user_ws2812b.c

#include "user_ws2812b.h"
#include "user_config.h"

tmosTaskID user_ws2812b_task_id = INVALID_TASK_ID;

static uint16_t user_ws2812b_task_process_event(uint8_t task_id, uint16_t events);

static void vUser_ws2812b_left_wrRGB(uint8_t r, uint8_t g, uint8_t b);
static void vUser_ws2812b_right_wrRGB(uint8_t r, uint8_t g, uint8_t b);

static user_ws2812b_work_s user_ws2812b_work[2] = {
    {
        .idx = LEFT_IDX,
        .txStat = false,
        .alarm_stat = 0,
        .change = false,
        .bright_stat = false,                                   //灯是否亮
        .flicker_type = WS2812B_FLICKER_NULL,
        .flicker_delaytime = 0,                         //闪烁间隔时间
        .breath_bright = 0,                              //呼吸灯亮度
        .delaytime = 0,
        .count = 0,
        .tail_step = 0,
        .tail_idx = 0,
        .tail_dir = false,
        .rgbValue = NULL,
        .rValue = 0,
        .gValue = 0,
        .bValue = 0,
    },
    {
        .idx = RIGHT_IDX,
        .txStat = false,
        .alarm_stat = 0,
        .change = false,
        .bright_stat = false,                                   //灯是否亮
        .flicker_type = WS2812B_FLICKER_NULL,
        .flicker_delaytime = 0,                         //闪烁间隔时间
        .breath_bright = 0,                              //呼吸灯亮度
        .delaytime = 0,
        .count = 0,
        .tail_step = 0,
        .tail_idx = 0,
        .tail_dir = false,
        .rgbValue = NULL,
        .rValue = 0,
        .gValue = 0,
        .bValue = 0,
    },
};

/*******************************************************************************
  * @函数名称	vUser_ws2812b_set_wrByte
  * @函数说明   转换ws2812b颜色数据
  * @输入参数  	byte：字节
               color：spi发送数据属猪
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void vUser_ws2812b_set_wrByte(uint8_t byte, uint8_t *color)
{
    for(uint8_t i = 0; i < 8; i++)
	{
        if((byte & 0x80) == 0x80)
        {
            *color++ = WS2812B_HIGH;
        }
        else
        {
            *color++ = WS2812B_LOW;
        }
        byte <<= 1;
	}   
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_set_led_bright
  * @函数说明   设置ws2812b点亮状态
  * @输入参数  	ws2812b：变量指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_led_bright(user_ws2812b_work_s *ws2812b)
{
	for(uint8_t i = 0; i < ws2812b->count; i++)
	{
        vUser_ws2812b_set_wrByte(ws2812b->gValue, &ws2812b->rgbValue[i * 24]);
        vUser_ws2812b_set_wrByte(ws2812b->rValue, &ws2812b->rgbValue[i * 24 + 8]);
        vUser_ws2812b_set_wrByte(ws2812b->bValue, &ws2812b->rgbValue[i * 24 + 16]);
	}
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_set_led_dark
  * @函数说明   设置ws2812b暗状态
  * @输入参数  	ws2812b：变量指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_led_dark(user_ws2812b_work_s *ws2812b)
{
	for(uint8_t i = 0; i < ws2812b->count; i++)
	{
		vUser_ws2812b_set_wrByte(0, &ws2812b->rgbValue[i * 24]);
        vUser_ws2812b_set_wrByte(0, &ws2812b->rgbValue[i * 24 + 8]);
        vUser_ws2812b_set_wrByte(0, &ws2812b->rgbValue[i * 24 + 16]);
	}
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_set_normal_stat
  * @函数说明   设置ws2812b普通状态
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_set_normal_stat(uint8_t idx)
{
    user_ws2812b_work[idx].rValue = (WS2812B_NORMAL_RGB >> 16) & 0xFF;
    user_ws2812b_work[idx].gValue = (WS2812B_NORMAL_RGB >> 8) & 0xFF;
    user_ws2812b_work[idx].bValue = WS2812B_NORMAL_RGB & 0xFF;

    user_ws2812b_work[idx].tail_idx = 0;
    user_ws2812b_work[idx].tail_step = user_ws2812b_work[idx].count / 3;
    user_ws2812b_work[idx].tail_dir = false,
    user_ws2812b_work[idx].delaytime = FLICKER_DELAYTIME_DEFAULT;

    user_ws2812b_work[idx].flicker_type = WS2812B_FLICKER_NULL;
    user_ws2812b_work[idx].change = true;
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_set_ble_connect_stat
  * @函数说明   设置蓝牙连接状态
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_set_ble_connect_stat(uint8_t idx)
{
    user_ws2812b_work[idx].rValue = (WS2812B_BLE_RGB >> 16) & 0xFF;
    user_ws2812b_work[idx].gValue = (WS2812B_BLE_RGB >> 8) & 0xFF;
    user_ws2812b_work[idx].bValue = WS2812B_BLE_RGB & 0xFF;

    user_ws2812b_work[idx].tail_idx = 0;
    user_ws2812b_work[idx].tail_step = user_ws2812b_work[idx].count / 3;
    user_ws2812b_work[idx].delaytime = FLICKER_DELAYTIME_DEFAULT;

    user_ws2812b_work[idx].flicker_delaytime = BREATH_SPEED_DEFAULT;
    user_ws2812b_work[idx].breath_bright = 0;
    user_ws2812b_work[idx].bright_stat = true;
    user_ws2812b_work[idx].flicker_type = WS2812B_FLICKER_NULL;
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_set_can_id_alarm_stat
  * @函数说明   设置ws2812b CAN id错误状态
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_set_can_id_alarm_stat(uint8_t idx)
{
    user_ws2812b_work[idx].rValue = (WS2812B_CANID_ERROR_RGB >> 16) & 0xFF;
    user_ws2812b_work[idx].gValue = (WS2812B_CANID_ERROR_RGB >> 8) & 0xFF;
    user_ws2812b_work[idx].bValue = WS2812B_CANID_ERROR_RGB & 0xFF;

    user_ws2812b_work[idx].tail_idx = 0;
    user_ws2812b_work[idx].tail_step = user_ws2812b_work[idx].count / 3;
    user_ws2812b_work[idx].delaytime = FLICKER_DELAYTIME_DEFAULT;

    user_ws2812b_work[idx].flicker_delaytime = ID_ERROR_FLICKER_DEFAULT;
    user_ws2812b_work[idx].flicker_type = WS2812B_FLICKER_NULL;
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_set_offline_alarm_stat
  * @函数说明   设置ws2812b CAN 离线错误状态
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_set_offline_alarm_stat(uint8_t idx)
{
    user_ws2812b_work[idx].rValue = (WS2812B_OFFLINE_RGB >> 16) & 0xFF;
    user_ws2812b_work[idx].gValue = (WS2812B_OFFLINE_RGB >> 8) & 0xFF;
    user_ws2812b_work[idx].bValue = WS2812B_OFFLINE_RGB & 0xFF;

    user_ws2812b_work[idx].tail_idx = 0;
    user_ws2812b_work[idx].tail_step = user_ws2812b_work[idx].count / 3;
    user_ws2812b_work[idx].delaytime = FLICKER_DELAYTIME_DEFAULT;

    user_ws2812b_work[idx].flicker_delaytime = OFFLINE_FLICKER_DEFAULT;
    user_ws2812b_work[idx].flicker_type = WS2812B_FLICKER_NULL;
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_set_alarm_view
  * @函数说明   设置ws2812b故障显示状态
  * @输入参数  	alarmStat：故障类型
                stat：故障状态
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_set_alarm_view(uint8_t idx, ws2812b_all_alarm_stat_e alarmStat, bool stat)
{
    if(stat == true)
    {
        user_ws2812b_work[idx].alarm_stat |= (1 << alarmStat);
    }
    else{
        user_ws2812b_work[idx].alarm_stat &= ~(1 << alarmStat);
    }

    if((user_ws2812b_work[idx].alarm_stat & (1 << WS2812B_ALL_ALARM_LOCK)) != 0)
    {

    }
    else if((user_ws2812b_work[idx].alarm_stat & (1 << WS2812B_ALL_ALARM_RST)) != 0)
    {
        
    }
    else if((user_ws2812b_work[idx].alarm_stat & (1 << WS2812B_ALL_ALARM_BLE)) != 0)
    {
        vUser_ws2812b_set_ble_connect_stat(idx);
    }
    else if((user_ws2812b_work[idx].alarm_stat & (1 << WS2812B_ALL_ALARM_CAN_IDX_ERROR)) != 0)
    {
        vUser_ws2812b_set_can_id_alarm_stat(idx);
    }
    else if((user_ws2812b_work[idx].alarm_stat & (1 <<  WS2812B_ALL_ALARM_OFFLINE)) != 0)
    {
        vUser_ws2812b_set_offline_alarm_stat(idx);
    }
    else if(user_ws2812b_work[idx].alarm_stat == 0)
    {
        vUser_ws2812b_set_normal_stat(idx);
    }
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_set_tail
  * @函数说明   设置ws2812b 拖尾效果
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_tail(uint8_t idx)
{
    prvUser_ws2812b_set_led_dark(&user_ws2812b_work[idx]);

    for(uint8_t i = 0; i < user_ws2812b_work[idx].tail_step; i++)
    {
        // 计算当前拖尾段的相对位置，越靠前越亮
        uint32_t rev = user_ws2812b_work[idx].tail_step - 1 - i;

        // 线性亮度值（0~255），头部最亮，尾部最暗
        uint8_t lin = 0xFF - (rev * 0xFF / user_ws2812b_work[idx].tail_step);

        // 应用二次衰减算法（非线性），亮度更柔和自然
        uint8_t bri = (lin * lin) >> 8;

        // 设置第 i 颗灯的颜色，按亮度比例缩放
        if(user_ws2812b_work[idx].tail_dir == false)                //正向
        {
            if((user_ws2812b_work[idx].tail_idx + i) >= user_ws2812b_work[idx].tail_step)
            {
                uint16_t wrIdx = user_ws2812b_work[idx].tail_idx - user_ws2812b_work[idx].tail_step + i;

                vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].gValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24]);
                vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].rValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24 + 8]);
                vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].bValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24 + 16]);
            }
        }
        else{

            if(user_ws2812b_work[idx].tail_idx >= user_ws2812b_work[idx].tail_step - 1)
            {
                if((user_ws2812b_work[idx].tail_idx - i) < user_ws2812b_work[idx].count)
                {
                    uint16_t wrIdx = user_ws2812b_work[idx].tail_idx - i;

                    vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].gValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24]);
                    vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].rValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24 + 8]);
                    vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].bValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24 + 16]);
                }
            }
            else{
                if((user_ws2812b_work[idx].tail_idx - i) >= 0)
                {
                    uint16_t wrIdx = user_ws2812b_work[idx].tail_idx - i;

                    vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].gValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24]);
                    vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].rValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24 + 8]);
                    vUser_ws2812b_set_wrByte((user_ws2812b_work[idx].bValue * bri) >> 8, &user_ws2812b_work[idx].rgbValue[wrIdx * 24 + 16]);
                }
            }
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_set_flowing_water
  * @函数说明   设置ws2812b 流水灯效果
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_flowing_water(uint8_t idx)
{
    if(user_ws2812b_work[idx].delaytime > 0)
    {
        user_ws2812b_work[idx].delaytime--;
    }
    else{
        user_ws2812b_work[idx].delaytime = FLICKER_DELAYTIME_DEFAULT;

        prvUser_ws2812b_set_tail(idx);
        
        if(user_ws2812b_work[idx].tail_dir == false)
        {
            if(user_ws2812b_work[idx].tail_idx >= (user_ws2812b_work[idx].count + user_ws2812b_work[idx].tail_step) - 1)
            {
                user_ws2812b_work[idx].tail_dir = true;
            }
            else{
                user_ws2812b_work[idx].tail_idx += 1;
            }
        }
        else{
            if(user_ws2812b_work[idx].tail_idx <= 0)
            {
                user_ws2812b_work[idx].tail_dir = false;
            }
            else{
                user_ws2812b_work[idx].tail_idx -= 1;
            }
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_set_flick
  * @函数说明   设置ws2812b 闪烁效果
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_flick(uint8_t idx)
{
    if(user_ws2812b_work[idx].delaytime > 0)
    {
        user_ws2812b_work[idx].delaytime--;
    }
    else{
        user_ws2812b_work[idx].delaytime = user_ws2812b_work[idx].flicker_delaytime;

        if(user_ws2812b_work[idx].bright_stat == false)
        {
            user_ws2812b_work[idx].bright_stat = true;
            prvUser_ws2812b_set_led_bright(&user_ws2812b_work[idx]);
        }
        else{
            user_ws2812b_work[idx].bright_stat = false;
            prvUser_ws2812b_set_led_dark(&user_ws2812b_work[idx]);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_set_breath
  * @函数说明   设置ws2812b 呼吸灯效果
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_breath(uint8_t idx)
{
    if(user_ws2812b_work[idx].delaytime > 0)
    {
        user_ws2812b_work[idx].delaytime--;
    }
    else{
        user_ws2812b_work[idx].delaytime = user_ws2812b_work[idx].flicker_delaytime / 100;

        if(user_ws2812b_work[idx].bright_stat == false)
        {
            if(user_ws2812b_work[idx].breath_bright > 10)
            {
                user_ws2812b_work[idx].breath_bright -= 2;
            }
            else{
                user_ws2812b_work[idx].bright_stat = true;
            }
        }
        else{
            if(user_ws2812b_work[idx].breath_bright < 250)
            {
                user_ws2812b_work[idx].breath_bright += 2;
            }
            else{
                user_ws2812b_work[idx].bright_stat = false;
            }
        }

        // 应用二次衰减算法（非线性），亮度更柔和自然
        uint8_t bri = (user_ws2812b_work[idx].breath_bright * user_ws2812b_work[idx].breath_bright) >> 8;

        // 应用亮度到颜色
        uint8_t out_r = ((uint16_t)user_ws2812b_work[idx].rValue * (uint16_t)bri) >> 8;
        uint8_t out_g = ((uint16_t)user_ws2812b_work[idx].gValue * (uint16_t)bri) >> 8;
        uint8_t out_b = ((uint16_t)user_ws2812b_work[idx].bValue * (uint16_t)bri) >> 8;

        for(uint8_t i = 0; i < user_ws2812b_work[idx].count; i++)
        {
            vUser_ws2812b_set_wrByte(out_g, &user_ws2812b_work[idx].rgbValue[i * 24]);
            vUser_ws2812b_set_wrByte(out_r, &user_ws2812b_work[idx].rgbValue[i * 24 + 8]);
            vUser_ws2812b_set_wrByte(out_b, &user_ws2812b_work[idx].rgbValue[i * 24 + 16]);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_txData
  * @函数说明   发送ws2812b数据
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_txData(uint8_t idx)
{
    bUser_spi_WriteByte(idx, user_ws2812b_work[idx].rgbValue, user_ws2812b_work[idx].count * 3 * 8);
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_set_ble_connect_check
  * @函数说明   设置ws2812b 蓝牙连接状态
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_ble_connect_check(uint8_t idx)
{
    prvUser_ws2812b_set_breath(idx);
    prvUser_ws2812b_txData(idx);
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_set_can_id_alarm_check
  * @函数说明   设置ws2812b CAN id错误状态
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_can_id_alarm_check(uint8_t idx)
{
    prvUser_ws2812b_set_flick(idx);
    prvUser_ws2812b_txData(idx);
}

/*******************************************************************************
  * @函数名称   prvUser_ws2812b_set_offline_alarm_check
  * @函数说明   设置ws2812b CAN 离线错误状态
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_set_offline_alarm_check(uint8_t idx)
{
    prvUser_ws2812b_set_flick(idx);
    prvUser_ws2812b_txData(idx);
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_normal_check
  * @函数说明   ws2812b闪正常状态处理
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_normal_check(uint8_t idx)
{
    // prvUser_ws2812b_set_flowing_water(idx);
    // prvUser_ws2812b_txData(idx);
    if(user_ws2812b_work[idx].change == true)
    {
        user_ws2812b_work[idx].change = false;
        prvUser_ws2812b_set_led_bright(&user_ws2812b_work[idx]);
        prvUser_ws2812b_txData(idx);
    }
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_normal_check
  * @函数说明   ws2812b闪正常状态处理
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_ws2812b_lock_check(uint8_t idx)
{
    switch(user_ws2812b_work[idx].flicker_type)
    {
        case WS2812B_DARK:{
            if(user_ws2812b_work[idx].change == true)
            {
                user_ws2812b_work[idx].change = false;
                prvUser_ws2812b_set_led_dark(&user_ws2812b_work[idx]);
                prvUser_ws2812b_txData(idx);
            }
        }break;
        case WS2812B_BRIGHT:{
            if(user_ws2812b_work[idx].change == true)
            {
                user_ws2812b_work[idx].change = false;
                prvUser_ws2812b_set_led_bright(&user_ws2812b_work[idx]);
                prvUser_ws2812b_txData(idx);
            }
        }break;
        case WS2812B_FLICKER_ON:{
            prvUser_ws2812b_set_flick(idx);
            prvUser_ws2812b_txData(idx);
        }break;
        case WS2812B_BREATH_ON:{
            prvUser_ws2812b_set_breath(idx);
            prvUser_ws2812b_txData(idx);
        }break;
        case WS2812B_TAIL_ON:{
            prvUser_ws2812b_set_flowing_water(idx);
            prvUser_ws2812b_txData(idx);
        }break;
        default:break;
    }
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_left_time_task
  * @函数说明   ws2812b时间循环任务
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void vUser_ws2812b_check(uint8_t idx)
{
    if(user_ws2812b_work[idx].txStat == false)
    {
        if((user_ws2812b_work[idx].alarm_stat & (1 << WS2812B_ALL_ALARM_LOCK)) != 0)
        {
            prvUser_ws2812b_lock_check(idx);
        }
        else if((user_ws2812b_work[idx].alarm_stat & (1 << WS2812B_ALL_ALARM_RST)) != 0)
        {
            
        }
        else if((user_ws2812b_work[idx].alarm_stat & (1 << WS2812B_ALL_ALARM_BLE)) != 0)
        {
            prvUser_ws2812b_set_ble_connect_check(idx);
        }
        else if((user_ws2812b_work[idx].alarm_stat & (1 << WS2812B_ALL_ALARM_CAN_IDX_ERROR)) != 0)
        {
            prvUser_ws2812b_set_can_id_alarm_check(idx);
        }
        else if((user_ws2812b_work[idx].alarm_stat & (1 <<  WS2812B_ALL_ALARM_OFFLINE)) != 0)
        {
            prvUser_ws2812b_set_offline_alarm_check(idx);
        }
        else if(user_ws2812b_work[idx].alarm_stat == 0)
        {
            prvUser_ws2812b_normal_check(idx);
        }
    }
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_time_task
  * @函数说明   ws2812b时间循环任务
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void vUser_ws2812b_time_task(void)
{
    vUser_ws2812b_check(LEFT_IDX);
    vUser_ws2812b_check(RIGHT_IDX);
}

/*******************************************************************************
  * @函数名称   user_charge_task_process_event
  * @函数说明   task的event处理回调函数,需要在注册task时候,传进去
  * @输入参数  	task_id：任务ID
               events：事件
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint16_t user_ws2812b_task_process_event(uint8_t task_id, uint16_t events)
{
    //event 处理
    if(events & (1 << WS2812B_QUEUE_TIME))
    {
        vUser_ws2812b_time_task();
        return (events ^ (1 << WS2812B_QUEUE_TIME)); //异或的方式清除该事件运行标志，并返回未运行的事件标志
    }

    if(events & (1 << WS2812B_QUEUE_INT))
    {
        
        return (events ^ (1 << WS2812B_QUEUE_INT)); //异或的方式清除该事件运行标志，并返回未运行的事件标志
    }

    return 0;
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_task_start
  * @函数说明   任务开始
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_task_start(void)
{
    bStatus_t stat = tmos_start_reload_task(user_ws2812b_task_id, (1 << WS2812B_QUEUE_TIME), MS1_TO_SYSTEM_TIME(USER_WS2812B_INTERVAL));
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_init
  * @函数说明   初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_init(void)
{
    user_ws2812b_work[LEFT_IDX].count = (user_config_param.left_ws2812b_count > WS2812B_MAX_COUNT)?WS2812B_MAX_COUNT:user_config_param.left_ws2812b_count;
    user_ws2812b_work[RIGHT_IDX].count = (user_config_param.right_ws2812b_count > WS2812B_MAX_COUNT)?WS2812B_MAX_COUNT:user_config_param.right_ws2812b_count;
    user_ws2812b_work[LEFT_IDX].rgbValue = (uint8_t *)malloc(user_ws2812b_work[LEFT_IDX].count * 3 * 8);
    user_ws2812b_work[RIGHT_IDX].rgbValue = (uint8_t *)malloc(user_ws2812b_work[RIGHT_IDX].count * 3 * 8);

    prvUser_ws2812b_set_led_dark(&user_ws2812b_work[LEFT_IDX]);
    prvUser_ws2812b_set_led_dark(&user_ws2812b_work[RIGHT_IDX]);

    user_spi_Init();
    user_spi_01_dma_init(user_ws2812b_work[LEFT_IDX].rgbValue, user_ws2812b_work[LEFT_IDX].count * 3 * 8);
    user_spi_02_dma_init(user_ws2812b_work[RIGHT_IDX].rgbValue, user_ws2812b_work[LEFT_IDX].count * 3 * 8);

    user_ws2812b_task_id  = TMOS_ProcessEventRegister(user_ws2812b_task_process_event);
    PRINT("user_ws2812b_task_id=%d\n", user_ws2812b_task_id);
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_set_tx_stat
  * @函数说明   设置数据发射状态
  * @输入参数  	idx：左边或者右边
               stat：状态
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_set_tx_stat(uint8_t idx, bool stat)
{
    user_ws2812b_work[idx].txStat = stat;
}

/*******************************************************************************
  * @函数名称   vUser_ws2812b_set_tx_stat
  * @函数说明   设置数据发射状态
  * @输入参数  	idx：左边或者右边
               stat：锁定状态
               type：灯状态
               timeValue：时间
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_ws2812b_set_lock_stat(uint8_t idx, bool lock, ws2812b_flicker_type_e type, uint8_t r, uint8_t g, uint8_t b, uint32_t timeValue)
{
    PRINT("idx=%d,lock=%s,type=%d,r=%02X,g=%02X,b=%02X,time=%dms\n",idx, (lock == true)?"true":"false",type - 1,r,g,b,timeValue);
    
    if(lock == true)
    {
        vUser_ws2812b_set_alarm_view(idx, WS2812B_ALL_ALARM_LOCK, true);
        user_ws2812b_work[idx].rValue = r;
        user_ws2812b_work[idx].gValue = g;
        user_ws2812b_work[idx].bValue = b;
        user_ws2812b_work[idx].flicker_type = type;
        switch(user_ws2812b_work[idx].flicker_type)
        {
            case WS2812B_DARK:{
                user_ws2812b_work[idx].change = true;
            }break;
            case WS2812B_BRIGHT:{
                user_ws2812b_work[idx].change = true;
            }break;
            case WS2812B_FLICKER_ON:{
                user_ws2812b_work[idx].delaytime = FLICKER_DELAYTIME_DEFAULT;
                user_ws2812b_work[idx].flicker_delaytime = timeValue / USER_WS2812B_INTERVAL;
            }break;
            case WS2812B_BREATH_ON:{
                user_ws2812b_work[idx].delaytime = FLICKER_DELAYTIME_DEFAULT;
                user_ws2812b_work[idx].flicker_delaytime = timeValue / USER_WS2812B_INTERVAL;
            }break;
            case WS2812B_TAIL_ON:{
                user_ws2812b_work[idx].tail_step = user_ws2812b_work[idx].count / 3;
                user_ws2812b_work[idx].delaytime = FLICKER_DELAYTIME_DEFAULT;
                user_ws2812b_work[idx].flicker_delaytime = timeValue / USER_WS2812B_INTERVAL;
            }break;
            default:break;
        }
    }
    else{
        vUser_ws2812b_set_alarm_view(idx, WS2812B_ALL_ALARM_LOCK, false);
    }
}