ISCS_KEY_BASE_CAN/mainboard/components/action/user_sever.c

#include "user_server.h"
#include "user_nfc.h"
#include "user_charge.h"
#include "user_elect.h"
#include "user_led.h"
#include "dip_sw.h"
#include "elect_sw.h"
#include "user_fan.h"
#include "user_adc.h"

tmosTaskID user_server_task_id = INVALID_TASK_ID;
static uint32_t offline_timeout = CAN_OFFLINE_TIMEOUT_DEFAULT / USER_SERVER_INTERVAL;
static bool offline_stat = false;
static uint8_t can_idx = 0xFF;
static uint8_t left_fan_speed = 0;
static uint8_t right_fan_speed = 0;
static key_data_s key_data = {
    .elect_act = {
        .left_elect_act = 0,
        .left_elect_finish = 0,
        .right_elect_act = 0,
        .right_elect_finish = 0,
    },
	.elect_stat = {
		.left_key_elect_stat = 0,
        .left_charge_stat = 0,
        .left_Reserved = 0,
		.right_key_elect_stat = 0,
        .right_charge_stat = 0,
        .right_Reserved = 0,
        .left_elect_fault = 0,
        .left_elect_stat_Reserved = 0,
        .right_elect_fault = 0,
        .right_elect_stat_Reserved = 0,
	},
	.key_stat = {
		.left_key_stat = 0,
		.left_charge_stat = 0,
        .left_Reserved = 0,
		.right_key_stat = 0,
		.right_charge_stat = 0,
        .right_Reserved = 0,
	},
    .charge_temp = {
        .left_temperature = -100,
        .right_temperature = -100,
    },
	.left_key_id = 0,
	.right_key_id = 0,
};

static can_open_data_s can_open_data;

/*******************************************************************************
  * @函数名称   prvUser_server_dev_type_protocol
  * @函数说明   设备类型索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_dev_type_protocol(void)
{
    if(can_open_data.subidx == REG_DEV_TYPE_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_WORD;
            s_data.idx = REG_DEV_TYPE_IDX;
            s_data.subidx = REG_DEV_TYPE_SUBIDX;
            s_data.data[0] = DEV_TYPE;
            s_data.data[1] = DEV_TYPE >> 8;
            s_data.data[2] = 0;
            s_data.data[3] = 0;
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = R_INS_WR_FAIL;
            s_data.idx = REG_DEV_TYPE_IDX;
            s_data.subidx = REG_DEV_TYPE_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_version_protocol
  * @函数说明   版本号索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_version_protocol(void)
{
    if(can_open_data.subidx == REG_VERSION_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_DWORD;
            s_data.idx = REG_VERSION_IDX;
            s_data.subidx = REG_VERSION_SUBIDX;
            s_data.data[0] = HARDWARE_VERSION;
            s_data.data[1] = HARDWARE_VERSION >> 8;
            s_data.data[2] = SOFTWARE_VERSION;
            s_data.data[3] = SOFTWARE_VERSION >> 8;
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = R_INS_WR_FAIL;
            s_data.idx = REG_VERSION_IDX;
            s_data.subidx = REG_VERSION_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_key_stat_protocol
  * @函数说明   钥匙索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_key_stat_protocol(void)
{
    if(can_open_data.subidx == REG_KEY_STAT_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_WORD;
            s_data.idx = REG_KEY_STAT_IDX;
            s_data.subidx = REG_KEY_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            memcpy(s_data.data,(uint8_t *)&(key_data.key_stat), 2);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = R_INS_WR_FAIL;
            s_data.idx = REG_KEY_STAT_IDX;
            s_data.subidx = REG_KEY_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_elect_stat_protocol
  * @函数说明   电磁锁控制索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_elect_stat_protocol(void)
{
    if(can_open_data.subidx == REG_ELECT_STAT_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_WORD;
            s_data.idx = REG_ELECT_STAT_IDX;
            s_data.subidx = REG_ELECT_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            memcpy(s_data.data,(uint8_t *)&(key_data.elect_stat), 2);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else if(can_open_data.ins == S_INS_WR_WORD)
        {
            key_elect_control_s elect;
            memcpy((uint8_t *)&elect, (uint8_t *)&can_open_data.data, 2);

            can_open_data_s s_data;
            s_data.ins = R_INS_WR_SUCC;
            s_data.idx = REG_ELECT_STAT_IDX;
            s_data.subidx = REG_ELECT_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            memcpy(s_data.data,(uint8_t *)&elect, 2);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        
            if(elect.left_elect_enable == 1)
            {
                set_elect_work_stat(LEFT_IDX, (elect.left_elect_control == 1)?true:false);
            }
            
            if(elect.right_elect_enable == 1)
            {
                set_elect_work_stat(RIGHT_IDX, (elect.right_elect_control == 1)?true:false);
            }
            
            if(elect.left_charge_enable == 1)
            {
                set_user_charge_Queue((elect.left_charge_control == 1)?CHARGE_QUEUE_LEFT_OPEN:CHARGE_QUEUE_LEFT_CLOSE);
            }
            
            if(elect.right_charge_enable == 1)
            {
                set_user_charge_Queue((elect.right_charge_control == 1)?CHARGE_QUEUE_RIGHT_OPEN:CHARGE_QUEUE_RIGHT_CLOSE);
            }
        }
        else{
            can_open_data_s s_data;
            s_data.ins = R_INS_WR_FAIL;
            s_data.idx = REG_ELECT_STAT_IDX;
            s_data.subidx = REG_ELECT_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_charge_temp_protocol
  * @函数说明   充电温度值索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_charge_temp_protocol(void)
{
    if(can_open_data.subidx == REG_CHARGE_TEMP_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_DWORD;
            s_data.idx = REG_CHARGE_TEMP_IDX;
            s_data.subidx = REG_CHARGE_TEMP_SUBIDX;
            memcpy(s_data.data,(uint8_t *)&(key_data.charge_temp), 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = R_INS_WR_FAIL;
            s_data.idx = REG_CHARGE_TEMP_IDX;
            s_data.subidx = REG_CHARGE_TEMP_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_left_key_id_protocol
  * @函数说明   左边钥匙NFC号索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_left_key_id_protocol(void)
{
    if(can_open_data.subidx == REG_LEFT_KEY_ID_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_DWORD;
            s_data.idx = REG_LEFT_KEY_ID_IDX;
            s_data.subidx = REG_LEFT_KEY_ID_SUBIDX;
            s_data.data[0] = key_data.left_key_id[3];
            s_data.data[1] = key_data.left_key_id[2];
            s_data.data[2] = key_data.left_key_id[1];
            s_data.data[3] = key_data.left_key_id[0];
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = R_INS_WR_FAIL;
            s_data.idx = REG_LEFT_KEY_ID_IDX;
            s_data.subidx = REG_LEFT_KEY_ID_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_right_key_id_protocol
  * @函数说明   右边钥匙NFC号索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_right_key_id_protocol(void)
{
    if(can_open_data.subidx == REG_RIGHT_KEY_ID_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_DWORD;
            s_data.idx = REG_RIGHT_KEY_ID_IDX;
            s_data.subidx = REG_RIGHT_KEY_ID_SUBIDX;
            memset(s_data.data, 0, 4);
            s_data.data[0] = key_data.right_key_id[3];
            s_data.data[1] = key_data.right_key_id[2];
            s_data.data[2] = key_data.right_key_id[1];
            s_data.data[3] = key_data.right_key_id[0];
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = R_INS_WR_FAIL;
            s_data.idx = REG_RIGHT_KEY_ID_IDX;
            s_data.subidx = REG_RIGHT_KEY_ID_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_can_protocol
  * @函数说明   can总线协议解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_can_protocol(void)
{
    bool stat = false;
    switch(can_open_data.idx)
    {
        case REG_DEV_TYPE_IDX:prvUser_server_dev_type_protocol();stat = true;break;
        case REG_VERSION_IDX:prvUser_server_version_protocol();stat = true;break;
        case REG_KEY_STAT_IDX:prvUser_server_key_stat_protocol();stat = true;break;
        case REG_ELECT_STAT_IDX:prvUser_server_elect_stat_protocol();stat = true;break;
        case REG_CHARGE_TEMP_IDX:prvUser_server_charge_temp_protocol();stat = true;break;
        case REG_LEFT_KEY_ID_IDX:prvUser_server_left_key_id_protocol();stat = true;break;
        case REG_RIGHT_KEY_ID_IDX:prvUser_server_right_key_id_protocol();stat = true;break;
        default:break;
    }

    if(stat == true)
    {
        offline_timeout = CAN_OFFLINE_TIMEOUT_DEFAULT / USER_SERVER_INTERVAL;
        if(offline_stat == true)
        {
            offline_stat = false;
            vUser_led_set_alarm_view(LED_ALL_ALARM_OFFLINE, false);
        }
    }
}

/*******************************************************************************
  * @函数名称   ble_action_rst_pro
  * @函数说明   重启倒计时
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint8_t rst_timeout = 5;
static void ble_action_rst_pro(void)
{
    if(rst_timeout == 0)
    {
        /* Software reset */
        NVIC_SystemReset();
    }
    else{
	    rst_timeout--;
	    PRINT("Restart countdown %d second\n", rst_timeout);
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_can_offline_check
  * @函数说明   CAN总线离线检测
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_can_offline_check(void)
{
    if(offline_timeout > 0)
    {
        if(offline_timeout == 1)
        {
            if(offline_stat == false)
            {
                offline_stat = true;
                vUser_led_set_alarm_view(LED_ALL_ALARM_OFFLINE, true);
            }
        }
        offline_timeout--;
    }
}

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

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

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

    return 0;
}

/*******************************************************************************
  * @函数名称   vUser_server_task_start
  * @函数说明   定时任务开始
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_server_task_start(void)
{
    bStatus_t stat = tmos_start_reload_task(user_server_task_id, (1 << SERVER_QUEUE_TIME), MS1_TO_SYSTEM_TIME(USER_SERVER_INTERVAL));
}

/*******************************************************************************
  * @函数名称   vUser_server_set_led_stat
  * @函数说明   设置LED灯变化
  * @输入参数  	idx：左边或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void vUser_server_set_led_stat(uint8_t idx)
{
    if(idx == LEFT_IDX)
    {
        if(key_data.elect_stat.left_elect_fault == 1)
        {
            vUser_led_set_view_stat(LEFT_IDX, LED_VIEW_ELECT_FAUIL);
        }
        else if(key_data.elect_stat.left_key_elect_stat == 1 && key_data.key_stat.left_key_stat == 1)
        {
            vUser_led_set_view_stat(LEFT_IDX, LED_VIEW_KEY_ELECT);
        }
        else if(key_data.elect_stat.left_key_elect_stat == 0 && key_data.key_stat.left_key_stat == 0)
        {
            vUser_led_set_view_stat(LEFT_IDX, LED_VIEW_NOKEY_NOELECT);
        }
        else if(key_data.elect_stat.left_key_elect_stat == 0 && key_data.key_stat.left_key_stat == 1)
        {
            vUser_led_set_view_stat(LEFT_IDX, LED_VIEW_KEY_NOELECT);
        }
        else if(key_data.elect_stat.left_key_elect_stat == 1 && key_data.key_stat.left_key_stat == 0)
        {
            vUser_led_set_view_stat(LEFT_IDX, LED_VIEW_NOKEY_ELECT);
        }
    }
    else if(idx ==RIGHT_IDX)
    {
        if(key_data.elect_stat.right_elect_fault == 1)
        {
            vUser_led_set_view_stat(RIGHT_IDX, LED_VIEW_ELECT_FAUIL);
        }
        else if(key_data.elect_stat.right_key_elect_stat == 1 && key_data.key_stat.right_key_stat == 1)
        {
            vUser_led_set_view_stat(RIGHT_IDX, LED_VIEW_KEY_ELECT);
        }
        else if(key_data.elect_stat.right_key_elect_stat == 0 && key_data.key_stat.right_key_stat == 0)
        {
            vUser_led_set_view_stat(RIGHT_IDX, LED_VIEW_NOKEY_NOELECT);
        }
        else if(key_data.elect_stat.right_key_elect_stat == 0 && key_data.key_stat.right_key_stat == 1)
        {
            vUser_led_set_view_stat(RIGHT_IDX, LED_VIEW_KEY_NOELECT);
        }
        else if(key_data.elect_stat.right_key_elect_stat == 1 && key_data.key_stat.right_key_stat == 0)
        {
            vUser_led_set_view_stat(RIGHT_IDX, LED_VIEW_NOKEY_ELECT);
        }
    }
}

/*******************************************************************************
  * @函数名称   vUser_server_get_key_data
  * @函数说明   获取钥匙底座数据变量
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   钥匙底座数据变量指针
*******************************************************************************/
key_data_s *vUser_server_get_key_data(void)
{
    return &key_data;
}

/*******************************************************************************
  * @函数名称   vUser_can_recv_data_callback
  * @函数说明   can接收数据上报回调
  * @输入参数  	data：数据指针
               size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_can_recv_data_callback(uint8_t *data, uint8_t size)
{
    memcpy(&can_open_data, data, sizeof(can_open_data_s));
    bStatus_t stat = tmos_start_task(user_server_task_id, (1 << SERVER_QUEUE_CAN), MS1_TO_SYSTEM_TIME(1));
}

/*******************************************************************************
  * @函数名称   prvUser_server_check_elect_stat
  * @函数说明   检测电磁锁状态是否正常
  * @输入参数  	idx：左或者右边
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_check_elect_stat(uint8_t idx)
{
    if(idx == LEFT_IDX)
    {
        key_data.elect_stat.left_elect_fault = key_data.elect_act.left_elect_finish;
    }
    else if(idx == RIGHT_IDX)
    {
        key_data.elect_stat.right_elect_fault = key_data.elect_act.right_elect_finish;
    }
    vUser_server_set_led_stat(idx);
}

/*******************************************************************************
  * @函数名称   vUser_nfc_upload_card_callback
  * @函数说明   钥匙nfc标签读取上报回调
  * @输入参数  	idx：左或者右边
               stat：是否有钥匙
               card：钥匙RFID号
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_nfc_upload_card_callback(uint8_t idx, bool stat, unsigned char *card)
{
    if(idx == LEFT_IDX)
    {
        key_data.key_stat.left_key_stat = (stat == true)?1:0;
        memcpy(key_data.left_key_id, &card[4], 4);

    }
    else if(idx == RIGHT_IDX)
    {
        key_data.key_stat.right_key_stat = (stat == true)?1:0;
        memcpy(key_data.right_key_id, &card[4], 4);
    }
    vUser_server_set_led_stat(idx);
}

/*******************************************************************************
  * @函数名称   vUser_elect_upload_stat_callback
  * @函数说明   设置钥匙位电磁锁状态回调
  * @输入参数   idx：左边或者右边
                stat：电磁锁是否锁死
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void vUser_elect_upload_stat_callback(uint8_t idx, bool stat, bool finish)
{
	if(idx == LEFT_IDX)
	{
		key_data.elect_act.left_elect_act = (stat == true)?1:0;
	}
	else if(idx == RIGHT_IDX)
	{
		key_data.elect_act.right_elect_act = (stat == true)?1:0;
	}
    
    if(finish == false)
    {
        if(idx == LEFT_IDX)
        {
            if(key_data.elect_act.left_elect_act != key_data.elect_stat.left_key_elect_stat)
            {
                key_data.elect_act.left_elect_finish = 1;
            }
        }
        else if(idx == RIGHT_IDX)
        {
            if(key_data.elect_act.right_elect_act != key_data.elect_stat.right_key_elect_stat)
            {
                key_data.elect_act.right_elect_finish = 1;
            }
        }
    }
    else{
        prvUser_server_check_elect_stat(idx);
    }
}

/*******************************************************************************
  * @函数名称   vUser_charge_upload_stat_callback
  * @函数说明   设置钥匙位电磁锁状态回调
  * @输入参数   idx：左边或者右边
                stat：充电状态
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void vUser_charge_upload_stat_callback(uint8_t idx, bool stat)
{
    if(idx == LEFT_IDX)
	{
		key_data.key_stat.left_charge_stat = (stat == true)?1:0;
        key_data.elect_stat.left_charge_stat = (stat == true)?1:0;
        if(stat == true)
        {
            set_fan_indication(LEFT_IDX, 50);
        }
	}
	else if(idx == RIGHT_IDX)
	{
		key_data.key_stat.right_charge_stat = (stat == true)?1:0;
        key_data.elect_stat.right_charge_stat = (stat == true)?1:0;
        if(stat == true)
        {
            set_fan_indication(RIGHT_IDX, 50);
        }
	}
    vUser_nfc_set_charge_stat(idx, stat);
}

/*******************************************************************************
  * @函数名称   prvDipsw_upload_callback
  * @函数说明   地址读取回调
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvDipsw_upload_callback(uint8_t addr)
{
    vUser_can_set_addr(addr);
    elect_start(addr);
    if(addr != can_idx)
    {
        can_idx = addr;
        if(addr > 0)
        {
            vUser_led_set_alarm_view(LED_ALL_ALARM_CAN_IDX_ERROR, false);
        }
        else{
            vUser_led_set_alarm_view(LED_ALL_ALARM_CAN_IDX_ERROR, true);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvDipsw_upload_callback
  * @函数说明   地址读取回调
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvElectsw_upload_callback(uint8_t idx, bool stat)
{
    if(idx == LEFT_IDX)
	{
		key_data.elect_stat.left_key_elect_stat = (stat == true)?1:0;
        key_data.elect_act.left_elect_finish = 0;
	}
	else if(idx == RIGHT_IDX)
	{
		key_data.elect_stat.right_key_elect_stat = (stat == true)?1:0;
        key_data.elect_act.right_elect_finish = 0;
	}
    prvUser_server_check_elect_stat(idx);
}

/*******************************************************************************
  * @函数名称   prvUser_server_charge_fan_change
  * @函数说明   f风扇转速调整
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_charge_fan_change(void)
{
    if(key_data.key_stat.left_charge_stat == false)
    {
        if(key_data.charge_temp.left_temperature <= USER_FAN_STOP_DFAULT_VALUE)
        {
            if(left_fan_speed > 0)
            {
                left_fan_speed = 0;
                set_fan_indication(LEFT_IDX, 0);
                PRINT("left fan set 0\n");
            }
        }
    }
    else{
        if(key_data.charge_temp.left_temperature > USER_FAN_STOP_DFAULT_VALUE)
        {
            uint8_t value = (key_data.charge_temp.left_temperature - USER_FAN_STOP_DFAULT_VALUE) / 10;
            if(left_fan_speed != value)
            {
                left_fan_speed = value;
                set_fan_indication(LEFT_IDX, (value > 50)?100:(50 + value));
                PRINT("left fan set %d%%", value);
            }
        }
        else{
            if(left_fan_speed -= 50)
            {
                left_fan_speed = 50;
                set_fan_indication(LEFT_IDX, 50);
                PRINT("left fan set 0\n");
            }
        }
    }

    if(key_data.key_stat.right_charge_stat == false)
    {
        if(key_data.charge_temp.right_temperature <= USER_FAN_STOP_DFAULT_VALUE)
        {
            if(right_fan_speed > 0)
            {
                right_fan_speed = 0;
                set_fan_indication(RIGHT_IDX, 0);
                PRINT("right fan set 0\n");
            }
        }
    }
    else{
        if(key_data.charge_temp.right_temperature > USER_FAN_STOP_DFAULT_VALUE)
        {
            uint8_t value = (key_data.charge_temp.right_temperature - USER_FAN_STOP_DFAULT_VALUE) / 10;
            if(right_fan_speed != value)
            {
                right_fan_speed = value;
                set_fan_indication(RIGHT_IDX, (value > 50)?100:(50 + value));
                PRINT("right fan set %d%%", value);
            }
        }
        else{
            if(right_fan_speed != 50)
            {
                right_fan_speed = 50;
                set_fan_indication(RIGHT_IDX, 50);
                PRINT("right fan set 50\n");
            }
        }
    }
}

/*******************************************************************************
  * @函数名称   prvAdc_upload_callback
  * @函数说明   温度上报回调
  * @输入参数  	data：温度数据
               tmp_stat：温度计状态
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvAdc_upload_callback(adc_data_s data, bool tmp_stat)
{
    if(tmp_stat == true)
    {
        key_data.charge_temp.left_temperature = data.left_ntc / 10;
        key_data.charge_temp.right_temperature = data.right_ntc / 10;

        prvUser_server_charge_fan_change();
    }
}

/*******************************************************************************
  * @函数名称   vUser_server_init
  * @函数说明   初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_server_init(void)
{
    vUser_can_set_recv_data_func(prvUser_can_recv_data_callback);
    vUser_nfc_set_upload_key_stat_func(prvUser_nfc_upload_card_callback);
    vUser_elect_set_upload_stat_func(vUser_elect_upload_stat_callback);
    vUser_charge_set_upload_stat_func(vUser_charge_upload_stat_callback);
    vDipsw_set_upload_func(prvDipsw_upload_callback);
    vElectsw_set_upload_func(prvElectsw_upload_callback);
    set_adc_upload_func(prvAdc_upload_callback);

    user_server_task_id  = TMOS_ProcessEventRegister(user_server_task_process_event);
    PRINT("user_server_task_id=%d\n", user_server_task_id);
}