LPT26x-HSF-4MB-Hilink_14.2.0.308_20250411/application/ws63/user_main/spotlight/spotlight_main.c

#include "hsf.h"
#include "hfconfig.h"
#if defined(CONFIG_PWM_SUPPORT_LPM)
#include "pm_veto.h"
#endif
#include "pinctrl.h"
#include "gpio.h"
#include "pinctrl.h"
#include "pwm.h"
#include "timer.h"
#include "soc_osal.h"
#include "systick.h"

// #include "tcxo.h"

#include "spotlight.h"

// 函数前向声明
static void init_timer_system(void);
static void init_fade_ctx(void);
static void init_breath_ctx(void);
static void stop_fade_task(void);
static void stop_breath_task(void);
static void stop_breath_timer(void);
static void stop_spotlight_main_task(void);
static void check_net_cfg_timeout(void);
static void check_net_cfg_power_on_keep_time(void);
static void set_light2breathtimeout(void);
static void set_light2net_cfg_done(void);
static void start_breath_timer(void);
void calculate_pwm_duty(void);
void update_pwm_output(void);

// 定义上报函数类型
typedef void (*report_func_t)(void);
static void start_report_task(report_func_t report_func);
static void report_fade_complete_status(void);
static uint32_t calculate_checksum(const device_data_t* data);
static bool write_device_data_to_addr(uint32_t addr, const device_data_t* data);;
static void report_device_online_status(void);


#define BRIGHTNESS_PIN  GPIO_04  // 冷白LED (CW)
#define CCT_PIN         GPIO_00  // 暖白LED (WW)
#define SWITCH_PIN      GPIO_13

#define CONFIG_PWM_GROUP_ID        2

#define OPEN_LIGHT  GPIO_LEVEL_HIGH
#define CLOSE_LIGHT GPIO_LEVEL_LOW

// 状态上报任务相关变量
#define REPORT_TASK_PRIO          80
#define REPORT_TASK_STACK_SIZE    0x1000
static osal_task *report_task_handle = NULL;
static bool report_task_running = false;  // 添加任务运行状态标志

// 灯渐变任务相关定义
#define FADE_TASK_PRIO          80
#define FADE_TASK_STACK_SIZE    0x1000

// 呼吸灯任务相关定义
#define BREATH_TASK_PRIO        80
#define BREATH_TASK_STACK_SIZE  0x1000

// PWM频率和周期定义
#define PWM_FREQUENCY  2000    // PWM频率 2KHz

static uint32_t pwm_period_cnt = 0; //  PWM周期 40us
static uint8_t channel_id_cw = 0;   // 冷白LED通道ID
static uint8_t channel_id_ww = 0;   // 暖白LED通道ID

void save_device_data(void);
void read_device_data(void);
void req_save_device_data(void);
static void stop_breath_timer(void);
device_control_t g_device_control = DEFAULT_DEVICE_DATA;

// 配网状态定义
typedef enum {
    NET_CFG_IDLE = 0,      // 空闲状态
    NET_CFG_BREATHING,     // 呼吸灯状态，配网中
    NET_CFG_TIMEOUT,       // 超时状态
} net_cfg_state_e;

// 配网状态相关变量
static net_cfg_state_e g_net_breath_state = NET_CFG_IDLE;  // 配网状态
static uint64_t g_net_cfg_start_time = 0;  // 配网开始时间

// 保存任务相关变量
static osal_task *save_task_handle = NULL;
static bool save_task_running = false;
static osal_semaphore save_data_sem;

// 打印频率限制相关定义
#define PRINT_INTERVAL_MS 1000  // 最小打印间隔(ms)

typedef struct {
    uint64_t last_print_time;   // 上次打印时间
    const char *prefix;         // 打印前缀
} print_limiter_t;

// 渐变控制相关变量
static struct {
    // 渐变控制参数
    int32_t target_brightness;
    int32_t target_cct;
    int32_t current_brightness;
    int32_t current_cct;
    int32_t step_brightness;
    int32_t step_cct;
    bool is_fading;
    bool fade_completed;
    uint32_t smooth_time_us;    // 渐变总时长(us)
    uint32_t update_interval;   // 更新间隔(us)
    
    // 任务相关
    osal_task *task_handle;
    bool task_running;
    osal_semaphore sem;
    timer_handle_t timer_handle;
    
    // 打印限制器
    print_limiter_t print_limiter;
} fade_ctx = {0};

// 呼吸灯控制相关变量
static struct {
    // 呼吸灯控制参数
    int32_t duty;
    int32_t step;
    uint32_t update_interval;   // 更新间隔(us)
    bool is_initial_breath;  // 是否是初始3秒呼吸
    
    // 任务相关
    osal_task *task_handle;
    bool task_running;
    osal_semaphore sem;
    timer_handle_t timer_handle;

    uint32_t start_time_ms;
    uint32_t breath_cnt;
    
    // 打印限制器
    print_limiter_t print_limiter;
} breath_ctx = {0};

print_limiter_t pwm_limiter = {
    .last_print_time = 0,
    .prefix = "[pwm]",
};

// 定时器初始化标志
static bool timer_initialized = false;

// 初始化定时器系统
static void init_timer_system(void)
{
    if (!timer_initialized) {
        uapi_timer_init();
        int ret = uapi_timer_adapter(TIMER_INDEX_1, TIMER_1_IRQN, 1);
        if (ret != 0) {
            e_printf("定时器适配器初始化失败\r\n");
            return;
        }
        timer_initialized = true;
    }
}

// 初始化打印限制器
static void init_print_limiter(print_limiter_t *limiter, const char *prefix)
{
    limiter->last_print_time = 0;
    limiter->prefix = prefix;
}

// 带频率限制的打印函数
static bool should_print(print_limiter_t *limiter)
{
    uint64_t current_time = uapi_systick_get_ms();
    if (current_time - limiter->last_print_time >= PRINT_INTERVAL_MS) {
        limiter->last_print_time = current_time;
        return true;
    }
    return false;
}

// 渐变灯任务函数
static void *fade_task(const char *arg)
{
    unused(arg);
    e_printf("[fade_task] Task started\r\n");
    
    while (fade_ctx.task_running) {
        // 等待渐变信号
        if (osal_sem_down_timeout(&fade_ctx.sem, 100*1000) != OSAL_SUCCESS) {
            continue;
        }
        
        if (!fade_ctx.is_fading) {
            continue;
        }

        // 使用打印限制器控制打印频率
        if (should_print(&fade_ctx.print_limiter)) {
            e_printf("%s Brightness: curr:%d, target:%d, step:%d, cct:curr:%d, target:%d, step:%d\r\n", 
                     fade_ctx.print_limiter.prefix,
                     fade_ctx.current_brightness, fade_ctx.target_brightness, fade_ctx.step_brightness,
                     fade_ctx.current_cct, fade_ctx.target_cct,fade_ctx.step_cct);
        }

        // 检查是否达到目标值
        bool brightness_reached = (fade_ctx.step_brightness > 0) ? 
            (fade_ctx.current_brightness >= fade_ctx.target_brightness) :
            (fade_ctx.current_brightness <= fade_ctx.target_brightness);
        
        bool cct_reached = (fade_ctx.step_cct > 0) ?
            (fade_ctx.current_cct >= fade_ctx.target_cct) :
            (fade_ctx.current_cct <= fade_ctx.target_cct);
        // 更新当前值
        if (!brightness_reached)
        {
            fade_ctx.current_brightness += fade_ctx.step_brightness;
        }
        if (!cct_reached)
        {
            fade_ctx.current_cct += fade_ctx.step_cct;
        }
        // 如果达到目标值，停止渐变
        if (brightness_reached && cct_reached) {
            e_printf("[fade_task] Fade completed, Final brightness: %d, CCT: %d\r\n", 
                     fade_ctx.target_brightness, 
                     fade_ctx.target_cct);
            fade_ctx.is_fading = false;
            fade_ctx.fade_completed = true;
            fade_ctx.current_brightness = fade_ctx.target_brightness;
            fade_ctx.current_cct = fade_ctx.target_cct;
            uapi_timer_stop(fade_ctx.timer_handle);
        }

        BRIGHTNESS_LITME_RANGE(fade_ctx.current_brightness);
        CCT_LITME_RANGE(fade_ctx.current_cct);
        // 更新PWM输出
        g_device_control.brightness_local = fade_ctx.current_brightness;
        g_device_control.cct_local = fade_ctx.current_cct;
        calculate_pwm_duty();
        update_pwm_output();
        
        if (fade_ctx.fade_completed) {
            fade_ctx.fade_completed = false;
            e_printf("[fade_task] Status report: local brightness=%d, CCT=%d\r\n", 
                     g_device_control.brightness_local, 
                     g_device_control.cct_local);
            // 启动状态上报任务，使用渐变完成状态上报函数
            start_report_task(report_device_online_status);
            req_save_device_data();
        }
    }
    
    e_printf("[fade_task] Task exited\r\n");
    return NULL;
}

// 呼吸灯任务函数
static void *breath_task(const char *arg)
{
    unused(arg);
    e_printf("[breath_task] Task started\r\n");
    
    while (breath_ctx.task_running) {
        // 等待呼吸信号
        if (osal_sem_down_timeout(&breath_ctx.sem, 100*1000) != OSAL_SUCCESS) {
            continue;
        }
        
        if (g_net_breath_state != NET_CFG_BREATHING) {
            continue;
        }

        // 检查是否超过呼吸灯持续时间
        uint32_t current_time = uapi_systick_get_ms();
        uint32_t elapsed_time = current_time - g_net_cfg_start_time;
        
        if (elapsed_time >= NET_CFG_BREATH_DURATION) {
            set_light2breathtimeout();
            stop_breath_timer();
            continue;
        }
        // 检查是否需要改变方向
        if (breath_ctx.duty >= BRIGHTNESS_LOCAL_MAX) {
            breath_ctx.duty = BRIGHTNESS_LOCAL_MAX;
            breath_ctx.step = -1 * breath_ctx.step;
            e_printf("%s breathing %d, down %dms\n", breath_ctx.print_limiter.prefix, breath_ctx.breath_cnt, uapi_systick_get_ms() - breath_ctx.start_time_ms);
        } else if (breath_ctx.duty <= 0) {
            breath_ctx.duty = 0;
            breath_ctx.step = -1 * breath_ctx.step;
            e_printf("%s breathing %d, up %dms\n", breath_ctx.print_limiter.prefix, breath_ctx.breath_cnt, uapi_systick_get_ms() - breath_ctx.start_time_ms);
        }

        // 更新亮度
        breath_ctx.duty += breath_ctx.step;

        int32_t brightness_pwm = breath_ctx.duty;
        // 设置黄白灯交替呼吸
        g_device_control.duty_ww = brightness_pwm;
        g_device_control.duty_cw = PWM_DUTY_RATIO_MAX - brightness_pwm;

        update_pwm_output();
    }
    
    e_printf("[breath_task] Task exited\r\n");
    return NULL;
}

// 渐变定时器回调函数
static void fade_timer_callback(uintptr_t data)
{
    osal_sem_up(&fade_ctx.sem);
    uapi_timer_start(fade_ctx.timer_handle, fade_ctx.update_interval, fade_timer_callback, 0);
}

// 呼吸灯定时器回调函数
static void breath_timer_callback(uintptr_t data)
{
    osal_sem_up(&breath_ctx.sem);
    uapi_timer_start(breath_ctx.timer_handle, breath_ctx.update_interval, breath_timer_callback, 0);
}

// 初始化渐变控制
static void init_fade_ctx(void)
{
    init_timer_system();
    int ret = uapi_timer_create(TIMER_INDEX_1, &fade_ctx.timer_handle);
    if (ret != 0) {
        e_printf("渐变定时器创建失败\r\n");
    }
    
    // 初始化信号量
    if (osal_sem_init(&fade_ctx.sem, 0) != OSAL_SUCCESS) {
        e_printf("[init_fade_ctx] Failed to init semaphore\n");
        return;
    }
    
    // 初始化打印限制器
    init_print_limiter(&fade_ctx.print_limiter, "[fade_task]");
    
    // 创建渐变任务
    osal_kthread_lock();
    fade_ctx.task_handle = osal_kthread_create((osal_kthread_handler)fade_task, NULL, "FadeTask",
                                         FADE_TASK_STACK_SIZE);
    if (fade_ctx.task_handle != NULL) {
        fade_ctx.task_running = true;
        osal_kthread_set_priority(fade_ctx.task_handle, FADE_TASK_PRIO);
        e_printf("[init_fade_ctx] Fade task created successfully\n");
    } else {
        e_printf("[init_fade_ctx] Failed to create fade task\n");
        osal_sem_destroy(&fade_ctx.sem);
    }
    osal_kthread_unlock();
    
    // 设置默认更新间隔
    fade_ctx.update_interval = FADE_INTERVAL_MIN;
}

// 初始化呼吸灯控制
static void init_breath_ctx(void)
{
    init_timer_system();
    int ret = uapi_timer_create(TIMER_INDEX_1, &breath_ctx.timer_handle);
    if (ret != 0) {
        e_printf("呼吸灯定时器创建失败\r\n");
    }
    
    // 初始化信号量
    if (osal_sem_init(&breath_ctx.sem, 0) != OSAL_SUCCESS) {
        e_printf("[init_breath_ctx] Failed to init semaphore\n");
        return;
    }
    
    // 初始化打印限制器
    init_print_limiter(&breath_ctx.print_limiter, "[breath_task]");
    breath_ctx.duty = g_device_control.brightness_local;
    breath_ctx.step = BREARTH_STEP == 0 ? 1 : BREARTH_STEP;
    breath_ctx.update_interval = BREARTH_INTERVAL;
    breath_ctx.is_initial_breath = true;
    breath_ctx.start_time_ms = uapi_systick_get_ms();
    e_printf("Breath task: brightness=%d, step=%d, update_interval=%d, is_initial_breath=%d\n",
             breath_ctx.duty, breath_ctx.step, breath_ctx.update_interval, breath_ctx.is_initial_breath);

    // 创建呼吸灯任务
    osal_kthread_lock();
    breath_ctx.task_handle = osal_kthread_create((osal_kthread_handler)breath_task, NULL, "BreathTask",
                                           BREATH_TASK_STACK_SIZE);
    if (breath_ctx.task_handle != NULL) {
        breath_ctx.task_running = true;
        osal_kthread_set_priority(breath_ctx.task_handle, BREATH_TASK_PRIO);
        e_printf("[init_breath_ctx] Breath task created successfully\n");
    } else {
        e_printf("[init_breath_ctx] Failed to create breath task\n");
        osal_sem_destroy(&breath_ctx.sem);
    }
    osal_kthread_unlock();
}

// 停止渐变任务
static void stop_fade_task(void)
{
    if (fade_ctx.task_handle == NULL) {
        return;
    }
    
    fade_ctx.task_running = false;
    osal_sem_up(&fade_ctx.sem);  // 唤醒任务以使其退出
    
    osal_kthread_lock();
    osal_kthread_destroy(fade_ctx.task_handle, 0);
    fade_ctx.task_handle = NULL;
    osal_kthread_unlock();
    
    osal_sem_destroy(&fade_ctx.sem);
    
    e_printf("[stop_fade_task] Fade task stopped\n");
}

// 停止呼吸灯任务
static void stop_breath_task(void)
{
    if (breath_ctx.task_handle == NULL) {
        return;
    }
    
    breath_ctx.task_running = false;
    osal_sem_up(&breath_ctx.sem);  // 唤醒任务以使其退出
    
    osal_kthread_lock();
    osal_kthread_destroy(breath_ctx.task_handle, 0);
    breath_ctx.task_handle = NULL;
    osal_kthread_unlock();
    
    osal_sem_destroy(&breath_ctx.sem);
    
    e_printf("[stop_breath_task] Breath task stopped\n");
}

// 修改stop_breath_timer函数
static void stop_breath_timer(void)
{
    uapi_timer_stop(breath_ctx.timer_handle);
    uapi_timer_delete(breath_ctx.timer_handle);
    stop_breath_task();
}

// 计算PWM占空比
void calculate_pwm_duty(void)
{   // 如果开关关闭，则占空比为0
    uint32_t total_brightness_pwm = g_device_control.brightness_local;
    // 计算色温比例 (0-10000)
    uint16_t cct_ratio = ((g_device_control.cct_local - CCT_LOCAL_MIN) * 10000) / CCT_RANGE;

    // 根据色温比例计算CW和WW的占空比
    // 总亮度保持不变，只调整CW和WW的比例
    g_device_control.duty_cw = (total_brightness_pwm * cct_ratio) / 10000;
    g_device_control.duty_ww = total_brightness_pwm - g_device_control.duty_cw;
}

// 更新PWM输出
void update_pwm_output(void)
{
    pwm_config_t cfg_repeat = {0};
    cfg_repeat.repeat = true;
    if (g_device_control.duty_cw > PWM_DUTY_RATIO_MAX) {
        g_device_control.duty_cw = PWM_DUTY_RATIO_MAX;
    }
    if (g_device_control.duty_ww > PWM_DUTY_RATIO_MAX) {
        g_device_control.duty_ww = PWM_DUTY_RATIO_MAX;
    }
    uint32_t high_cnt_cw = (pwm_period_cnt * g_device_control.duty_cw) / PWM_DUTY_RATIO_MAX;
    uint32_t low_cnt_cw = pwm_period_cnt - high_cnt_cw;

    uint32_t high_cnt_ww = (pwm_period_cnt * g_device_control.duty_ww) / PWM_DUTY_RATIO_MAX;
    uint32_t low_cnt_ww = pwm_period_cnt - high_cnt_ww;

    // uapi_pwm_stop_group(CONFIG_PWM_GROUP_ID);
    // uapi_pwm_clear_group(CONFIG_PWM_GROUP_ID);
    if (!g_device_control.on) { // 如果开关关闭，则占空比为0
        e_printf("spotlight off\r\n");
        high_cnt_cw = 0;
        low_cnt_cw = 0;
        high_cnt_ww = 0;
        low_cnt_ww = 0;
    }
    cfg_repeat.high_time = high_cnt_cw;
    cfg_repeat.low_time = low_cnt_cw;
    uapi_pwm_open(channel_id_cw, &cfg_repeat);
    // 配置第二个通道
    cfg_repeat.high_time = high_cnt_ww;
    cfg_repeat.low_time = low_cnt_ww;
    cfg_repeat.offset_time = high_cnt_cw;//配置互补形成相位

    uapi_pwm_open(channel_id_ww, &cfg_repeat);
    // 设置PWM组
    uint8_t channel_ids[2] = {channel_id_cw, channel_id_ww};
    // uapi_pwm_set_group(CONFIG_PWM_GROUP_ID, channel_ids, 2);

    // // 更新PWM占空比
    // uapi_pwm_update_duty_ratio(channel_id_cw, low_cnt_cw, high_cnt_cw);
    // uapi_pwm_update_duty_ratio(channel_id_ww, low_cnt_ww, high_cnt_ww);
    
    // 启动PWM组
    uapi_pwm_start_group(CONFIG_PWM_GROUP_ID);
    if (should_print(&pwm_limiter)) {
        e_printf("cw:high:%u, low:%u, duty:%u/1000, ww:high:%u, low:%u, duty:%u/1000, offset_time:%u\r\n",
             high_cnt_cw, low_cnt_cw, g_device_control.duty_cw, high_cnt_ww, low_cnt_ww, g_device_control.duty_ww, cfg_repeat.offset_time);
    }
}

#define ABS(x) ((x) < 0 ? -(x) : (x))

// 计算渐变步长
static void calculate_fade_steps(void)
{
    // 从g_device_control获取渐变时间
    fade_ctx.smooth_time_us = g_device_control.fade_time * 1000 * 1000;//s->us
    e_printf("fade brightness: curr:%d, target:%d, cct: curr:%d, target:%d\r\n", 
        fade_ctx.current_brightness, fade_ctx.target_brightness, fade_ctx.current_cct, fade_ctx.target_cct);
    // 计算亮度渐变步长
    int32_t brightness_diff = fade_ctx.target_brightness - fade_ctx.current_brightness;
    int32_t cct_diff = fade_ctx.target_cct - fade_ctx.current_cct;
    
    // 计算需要的总步数（取亮度和色温中变化较大的那个）
    uint32_t max_diff = (ABS(brightness_diff) > ABS(cct_diff)) ? ABS(brightness_diff) : ABS(cct_diff);
    uint32_t min_steps = 0;
    uint32_t available_interval = 0;
    
    // 如果变化太小，直接设置目标值 EKKO:这里需要确认是直接设置目标值还是强制等待渐变时长
    if (max_diff == 0) {
        fade_ctx.step_brightness = 0;
        fade_ctx.step_cct = 0;
        fade_ctx.update_interval = fade_ctx.smooth_time_us;
        goto lab_exit;
    }

    min_steps = max_diff;
    
    // 计算实际可用的时间间隔
    available_interval = fade_ctx.smooth_time_us / min_steps;
    
    // 如果时间间隔太小（小于允许的最小更新间隔），则增加步长
    if (available_interval < FADE_INTERVAL_MIN) {
        // 重新计算步长，确保在指定时间内完成
        fade_ctx.update_interval = FADE_INTERVAL_MIN;
        int32_t actual_steps = fade_ctx.smooth_time_us / fade_ctx.update_interval;
        
        // 计算新的步长
        fade_ctx.step_brightness = brightness_diff / actual_steps;
        fade_ctx.step_cct = cct_diff / actual_steps;
        
        // 确保至少有一个最小步长
        if (fade_ctx.step_brightness == 0 && brightness_diff != 0) {
            fade_ctx.step_brightness = (brightness_diff > 0) ? 1 : -1;
        }
        if (fade_ctx.step_cct == 0 && cct_diff != 0) {
            fade_ctx.step_cct = (cct_diff > 0) ? 1 : -1;
        }
    } else {
        // 使用计算出的时间间隔
        fade_ctx.update_interval = available_interval;
        fade_ctx.step_brightness = (brightness_diff > 0) ? 1 : -1;
        fade_ctx.step_cct = (cct_diff > 0) ? 1 : -1;
    }
    // 如果亮度或色温没有变化，则步长为0
    if (brightness_diff == 0) {
        fade_ctx.step_brightness = 0;
    }
    if (cct_diff == 0) {
        fade_ctx.step_cct = 0;
    }
lab_exit:
    if (should_print(&fade_ctx.print_limiter)) {
        e_printf("max_diff:%d, fade time:%uus, Brightness: diff:%d, step:%d, CCT: diff:%d, step:%d, update_interval:%uus\r\n",
                 max_diff, fade_ctx.smooth_time_us, brightness_diff, fade_ctx.step_brightness, cct_diff, fade_ctx.step_cct, fade_ctx.update_interval);
    }
}

static void cancel_current_light_fade(void)
{
    uapi_timer_stop(fade_ctx.timer_handle);
}

// 计算校验和
static uint32_t calculate_checksum(const device_data_t* data)
{
    uint32_t sum = 0;
    const uint32_t* ptr = (const uint32_t*)(((char*)data) + sizeof(data->checksum));
    size_t len = sizeof(device_data_t) - sizeof(data->checksum); // 减去checksum字段的大小
    
    for (size_t i = 0; i < len / 4; i++) {
        sum ^= ptr[i];
    }
    return sum;
}

// 验证数据有效性
static bool verify_device_data(const device_data_t* data)
{
    if (data->magic != DEVICE_DATA_MAGIC) {
        e_printf("magic error:%x\n", data->magic);
        return false;
    }
    
    if (data->version > DEVICE_DATA_VERSION) {
        e_printf("versoin missmatch:%x\n", data->version);
        return false;
    }
    
    uint32_t checksum = calculate_checksum(data);
    if (checksum != data->checksum) {
        e_printf("check sum error:%x\n", data->version);
        return false;
    }
    
    return true;
}

// 从指定地址读取设备数据
static bool read_device_data_from_addr(uint32_t addr, device_data_t* data)
{
    int ret = hfuflash_read(addr, (char*)data, sizeof(device_data_t));
    if (ret != sizeof(device_data_t)) {
        e_printf("从地址0x%x读取设备数据失败，实际读取长度：%d\r\n", addr, ret);
        return false;
    }
    
    if (!verify_device_data(data)) {
        e_printf("地址0x%x的数据无效\r\n", addr);
        return false;
    }
    
    return true;
}

// 写入数据到指定地址
static bool write_device_data_to_addr(uint32_t addr, const device_data_t* data)
{
    int ret = hfuflash_erase_page(addr, 1);
    if (ret != HF_SUCCESS) {
        e_printf("擦除地址0x%x的Flash页失败，错误码：%d\r\n", addr, ret);
        return false;
    }
    
    ret = hfuflash_write(addr, (char*)data, sizeof(device_data_t));
    if (ret != sizeof(device_data_t)) {
        e_printf("写入数据到地址0x%x失败，实际写入长度：%d\r\n", addr, ret);
        return false;
    }
    
    return true;
}

void read_device_data(void)
{
#if SUPPORT_SAVE_TO_FLASH
    device_data_t data;
    bool main_valid = false;
    bool backup_valid = false;
    
    // 尝试读取主数据区
    main_valid = read_device_data_from_addr(DEVICE_DATA_FLASH_ADDR, &data);
    
    // 如果主数据区无效，尝试读取备份区
    if (!main_valid) {
        backup_valid = read_device_data_from_addr(DEVICE_DATA_BACKUP_ADDR, &data);
    }
    
    if (!main_valid && backup_valid) { // 如果主数据区无效但备份区有效，从备份区恢复
        e_printf("从备份区恢复数据\r\n");
        write_device_data_to_addr(DEVICE_DATA_FLASH_ADDR, &data);
    } else if (!main_valid && !backup_valid) {    // 如果两个区域都无效，使用默认值
        e_printf("主数据和备份数据都无效，使用默认值\r\n");
        // 只打印g_device_control的当前值，不打印data.control
        // e_printf("读取完成状态: %d\r\n", g_device_control.read_done);
        e_printf("上电次数: %d\r\n", g_device_control.power_on_cnt);
        e_printf("配网状态: %d\r\n", g_device_control.is_networked);
        e_printf("开关状态: %d\r\n", g_device_control.on);
        e_printf("灯光模式: %d\r\n", g_device_control.elightMode);
        e_printf("亮度:    %d\r\n", g_device_control.brightness_local);
        e_printf("色温:    %d\r\n", g_device_control.cct_local);
        e_printf("冷白LED: %d\r\n", g_device_control.duty_cw);
        e_printf("暖白LED: %d\r\n", g_device_control.duty_ww);
        e_printf("渐变时间: %d\r\n", g_device_control.fade_time);
        goto lab_exit;
    }
    // 更新设备控制状态
    e_printf("设备状态恢复:\r\n");
    // e_printf("读取完成状态: %d => %d\r\n", g_device_control.read_done, data.control.read_done);
    e_printf("上电次数: %d => %d\r\n", g_device_control.power_on_cnt, data.control.power_on_cnt);
    e_printf("配网状态: %d => %d\r\n", g_device_control.is_networked, data.control.is_networked);
    e_printf("开关状态: %d => %d\r\n", g_device_control.on, data.control.on);
    e_printf("灯光模式: %d => %d\r\n", g_device_control.elightMode, data.control.elightMode);
    e_printf("亮度:    %d => %d\r\n", g_device_control.brightness_local, data.control.brightness_local);
    e_printf("色温:    %d => %d\r\n", g_device_control.cct_local, data.control.cct_local);
    e_printf("冷白LED: %d => %d\r\n", g_device_control.duty_cw, data.control.duty_cw);
    e_printf("暖白LED: %d => %d\r\n", g_device_control.duty_ww, data.control.duty_ww);
    e_printf("渐变时间: %d => %d\r\n", g_device_control.fade_time, data.control.fade_time);
    
    g_device_control = data.control;
lab_exit:
#endif
    g_device_control.read_done = true;
    e_printf("读取设备数据成功\r\n");
}
void save_device_data(void)
{
    e_printf("Starting to save device data\n");
#if SUPPORT_SAVE_TO_FLASH
    // 使用静态变量保存上一次的数据状态
    static device_control_t last_control = {0};
    static bool is_first_save = true;
    
    // 需要比较的字段（根据注释标记的持久化维持部分）
    bool need_save = is_first_save || 
                    last_control.on != g_device_control.on ||
                    last_control.elightMode != g_device_control.elightMode ||
                    last_control.brightness_local != g_device_control.brightness_local ||
                    last_control.fade_time != g_device_control.fade_time ||
                    last_control.cct_local != g_device_control.cct_local ||
                    last_control.power_on_cnt != g_device_control.power_on_cnt ||
                    last_control.is_networked != g_device_control.is_networked;
    
    if (!need_save) {
        e_printf("No changes detected, skip saving\n");
        return;
    }
    
    device_data_t data;
    
    // 准备要保存的数据
    data.magic = DEVICE_DATA_MAGIC;
    data.version = DEVICE_DATA_VERSION;
    data.control = g_device_control;
    data.checksum = calculate_checksum(&data);
    
    // 先写入备份区
    if (!write_device_data_to_addr(DEVICE_DATA_BACKUP_ADDR, &data)) {
        e_printf("Failed to write backup data\n");
        return;
    }
    
    // 再写入主数据区
    if (!write_device_data_to_addr(DEVICE_DATA_FLASH_ADDR, &data)) {
        e_printf("Failed to write main data, but backup data saved\n");
    }
    
    // 更新上一次的数据状态
    last_control = g_device_control;
    is_first_save = false;
    
    e_printf("Device data saved successfully\n");
#endif
    e_printf("Save device data done\n");
}

void req_save_device_data(void)
{
    osal_sem_up(&save_data_sem);
}

// 保存任务函数
static void *save_data_task(const char *arg)
{
    e_printf("[save_data_task] Save task started\n");
    
    while (save_task_running) {
        // 等待保存信号
        if (osal_sem_down_timeout(&save_data_sem, 100*1000) != OSAL_SUCCESS) {
            continue;
        }
        while(OSAL_SUCCESS == osal_sem_trydown(&save_data_sem));//消耗所有的信号一次性刷入
        save_device_data();
    }
    
    e_printf("[save_data_task] Save task exited\n");
    return NULL;
}

// 初始化保存任务
static void init_save_task(void)
{
    if (save_task_handle != NULL) {
        return;
    }
    
    // 初始化信号量
    if (osal_sem_init(&save_data_sem, 0) != OSAL_SUCCESS) {
        e_printf("[init_save_task] Failed to init semaphore\n");
        return;
    }
    
    // 创建保存任务
    osal_kthread_lock();
    save_task_handle = osal_kthread_create((osal_kthread_handler)save_data_task, NULL, "SaveDataTask",
                                         SAVE_TASK_STACK_SIZE);
    if (save_task_handle != NULL) {
        save_task_running = true;
        osal_kthread_set_priority(save_task_handle, SAVE_TASK_PRIO);
        e_printf("[init_save_task] Save task created successfully\n");
    } else {
        e_printf("[init_save_task] Failed to create save task\n");
        osal_sem_destroy(&save_data_sem);
    }
    osal_kthread_unlock();
}

// 停止保存任务
static void stop_save_task(void)
{
    if (save_task_handle == NULL) {
        return;
    }
    
    save_task_running = false;
    osal_sem_up(&save_data_sem);  // 唤醒任务以使其退出
    
    osal_kthread_lock();
    osal_kthread_destroy(save_task_handle, 0);
    save_task_handle = NULL;
    osal_kthread_unlock();
    
    osal_sem_destroy(&save_data_sem);
    
    e_printf("[stop_save_task] Save task stopped\n");
}

// 设置灯光状态（统一控制函数）
int set_light(int32_t brightness_local, int32_t cct_local)
{
    // 如果任一参数大于等于0，则更新对应值
    e_printf("ligMode:%d, local brightness: curr:%d, target:%d,  local cct: curr:%d, target:%d\r\n", 
            g_device_control.elightMode, g_device_control.brightness_local, brightness_local, g_device_control.cct_local, cct_local);

    fade_ctx.current_brightness = g_device_control.brightness_local;
    fade_ctx.current_cct = g_device_control.cct_local;
    fade_ctx.target_brightness = fade_ctx.current_brightness ;
    fade_ctx.target_cct = fade_ctx.current_cct;

    if (brightness_local >= 0) {
        BRIGHTNESS_LITME_RANGE(brightness_local);

        if (g_device_control.elightMode == LIGHT_MODE_CUSTOMER) {
            fade_ctx.target_brightness = brightness_local;
        } else {
            g_device_control.brightness_local = brightness_local;
        }
    } 
    
    if (cct_local >= 0) {
        CCT_LITME_RANGE(cct_local);

        if (g_device_control.elightMode == LIGHT_MODE_CUSTOMER) {
            fade_ctx.target_cct = cct_local;
        } else {
            g_device_control.cct_local = cct_local;
        }
    }

    switch (g_device_control.elightMode)
    {
        case LIGHT_MODE_CUSTOMER:
            if (g_device_control.fade_time) {
                fade_ctx.is_fading = true;
                fade_ctx.fade_completed = false;
                // 计算渐变步长
                calculate_fade_steps();
                e_printf("start fade\r\n");
                // 启动渐变定时器
                set_switch(true);
                uapi_timer_start(fade_ctx.timer_handle, fade_ctx.update_interval, fade_timer_callback, 0);
                #if 0
                等待渐变完成
                while (!fade_ctx.fade_completed) {
                    msleep(10);
                }
                return 0; // 同步上报
                #else
                return -111; // 异步上报
                #endif
            }
            // no break; // 如果渐变时间是0则直接一步完成
        default: //情景模式直接切换到对应的色温和亮度
            set_switch(true);
    }
    start_report_task(report_device_online_status);//直接全量上报
    return -111; // 异步上报
}

// 设置开关状态
int set_switch(bool open)
{
    g_device_control.on = open;
    if (fade_ctx.is_fading) //打断当前的渐变计划
    {
        cancel_current_light_fade();
    }
    calculate_pwm_duty();
    update_pwm_output();
    uapi_gpio_set_val(SWITCH_PIN, open ? OPEN_LIGHT : CLOSE_LIGHT);
    
    // 保存设备状态
    req_save_device_data();
    return 0;
}

static void gpio_init(pin_t pin)
{
    /* PINCTRL init. */
    uapi_pin_init();
    uapi_pin_set_mode(pin, HAL_PIO_FUNC_GPIO);
    uapi_gpio_set_dir(pin, GPIO_DIRECTION_OUTPUT);
    uapi_pin_set_ds(pin, PIN_DS_3);
    uapi_pin_set_pull(pin, PIN_PULL_TYPE_DOWN);
    uapi_gpio_set_val(pin, CLOSE_LIGHT);
}

static void pwm_sys_init(void) {
    uapi_pwm_deinit();
}

static void pwm_init(pin_t pin, pin_t pin1)
{
    pwm_config_t cfg_repeat = {0};
    cfg_repeat.repeat = true;
    uapi_pin_set_mode(pin, PIN_MODE_1);
    uapi_pin_set_mode(pin1, PIN_MODE_1);
    uapi_pwm_init();
    uint32_t frequency = uapi_pwm_get_frequency(pin%8);
    // uint32_t pwm_base_period_ns = 1000 * 1000 * 1000 / frequency;
    // uint32_t pwm_base_period_ns = 1000 * 1000 * 1000 / (80 * 1000 * 1000);// 80MHZ
    // uint32_t pwm_target_period_ns = 1000 * 1000 * 1000 / PWM_FREQUENCY;
    pwm_period_cnt =  ((80 * 1000 * 1000) / PWM_FREQUENCY);
    // 设置PWM组
    channel_id_cw = pin%8;
    channel_id_ww = pin1%8;
    uint8_t channel_ids[2] = {channel_id_cw, channel_id_ww};
    uapi_pwm_open(channel_id_cw, &cfg_repeat);
    uapi_pwm_open(channel_id_ww, &cfg_repeat);
    uapi_pwm_set_group(CONFIG_PWM_GROUP_ID, channel_ids, sizeof(channel_ids));
    uapi_pwm_start_group(CONFIG_PWM_GROUP_ID);
    e_printf("PWM基础时钟频率: %dHz, 目标时钟频率: %dHz, 周期计数: %d\r\n", frequency, PWM_FREQUENCY, pwm_period_cnt);
}

// 配网状态管理相关函数
static void handle_network_status(void)
{
    // 如果已经配网，直接返回
    if (g_device_control.is_networked) {
        return;
    }

    // 增加上电计数
    g_device_control.power_on_cnt++;
    e_printf("现在是第 %d 次上电\r\n", g_device_control.power_on_cnt);
    // 检查是否需要进入配网状态
    if (g_device_control.power_on_cnt >= NET_CFG_ENTRY_CNT) {
        e_printf("进入配网状态，上电次数：%d\r\n", g_device_control.power_on_cnt);
        g_device_control.power_on_cnt = 0;//
        extern int start_hilink_ble_net_config(int32_t net_cfg_time_s);
        int ret = start_hilink_ble_net_config(NET_CFG_TOTAL_TIMEOUT/1000);
        if (ret) {
            // FIXME: 这里简单恢复之前等待配网的灯效即可
            e_printf("start net_cfg fail:%n\r\n", ret);
            req_save_device_data();
            // extern int HILINK_RestoreFactorySettings(void);
            // HILINK_RestoreFactorySettings();
            return;
        }
        // 初始化呼吸灯控制
        init_breath_ctx();
        start_breath_timer();
    }
    
    // 保存设备状态
    req_save_device_data();
}


// 设备上线时的状态上报
static void report_device_online_status(void)
{
    e_printf("[report_task] Starting to report all service status\r\n");
    fast_report(SVC_ID_SWITCH);
    fast_report(SVC_ID_BRIGHTNESS);
    fast_report(SVC_ID_CCT);
    fast_report(SVC_ID_LIGHT_MODE);
    fast_report(SVC_ID_FADE_TIME);
    e_printf("[report_task] Status report completed\r\n");
}

// 渐变结束时的状态上报
static void report_fade_complete_status(void)
{
    req_save_device_data();
    e_printf("[report_task] Reporting fade complete status\r\n");
    fast_report(SVC_ID_LIGHT_MODE);
    fast_report(SVC_ID_BRIGHTNESS);
    fast_report(SVC_ID_CCT);
    e_printf("[report_task] Fade status report completed\r\n");
}

// 状态上报任务函数
static void *report_task(const char *arg)
{
    report_func_t report_func = (report_func_t)arg;
    e_printf("report_task running...\r\n");
    while (!(g_device_control.read_done && hf_hilink_main_is_runing())) {
        // 数据已经正确load并且hilink已经运行才开始上报
        e_printf("read_done%d, hilink:%d\r\n", g_device_control.read_done, hf_hilink_main_is_runing());
        osal_msleep(50);
    }
    if (report_func)
    {
        report_func();
    }
    report_task_running = false;
    e_printf("[report_task] exited\r\n");
    return NULL;
}

// 启动状态上报任务
static void start_report_task(report_func_t report_func)
{
    if (report_task_running) {
        e_printf("[report_task] Previous task is still running, skip this report\r\n");
        return;
    }
    if (report_task_handle) {
        osal_kthread_destroy(report_task_handle, 0);
        report_task_handle = NULL;
    }

    e_printf("start report_task\r\n");
    osal_kthread_lock();
    report_task_handle = osal_kthread_create((osal_kthread_handler)report_task, (void*)report_func, "ReportStaTask",
                                      REPORT_TASK_STACK_SIZE);
    if (report_task_handle != NULL) {
        report_task_running = true;  // 设置任务运行标志
        osal_kthread_set_priority(report_task_handle, REPORT_TASK_PRIO);
    }
    osal_kthread_unlock();
}

static int device_online = 0;
// 修改handle_device_online函数
void handle_device_online(void)
{
    if(device_online)
    {
        return;
    }
    e_printf("device online!\r\n");
    if (!g_device_control.is_networked) {
        e_printf("设备首次上线，记录配网状态\r\n");
        g_device_control.is_networked = true;
        g_device_control.power_on_cnt = 0;  // 重置上电计数
        stop_breath_timer();  // 停止呼吸灯
        set_light2net_cfg_done();
        req_save_device_data();
    }
    // 重置配网状态
    g_net_breath_state = NET_CFG_IDLE;
    g_net_cfg_start_time = 0;
    // 启动状态上报任务，使用设备上线状态上报函数
    start_report_task(report_device_online_status);
    device_online = 1;
}

void handle_device_offline(void)
{
    if (!device_online) {
        return;
    }
    device_online = 0;
    e_printf("device offline!\r\n");
}
// 处理设备解绑
void handle_device_unbind(void)
{
    e_printf("设备被解绑，重置配网状态\r\n");
    if (g_device_control.is_networked) {
        g_device_control.is_networked = false;
        g_device_control.power_on_cnt = 0;  // 重置上电计数
        stop_spotlight_main_task();
        device_control_t tmp = DEFAULT_DEVICE_DATA;//恢复默认
        g_device_control = tmp;
        save_device_data();
    }
}

static void check_net_cfg_power_on_keep_time(void)
{
    if (g_device_control.power_on_cnt <= 0) {
        return;
    }
    if (g_device_control.is_networked) {
        return;
    }
    if (uapi_systick_get_ms() > INIT_NET_CFG_PWOER_ON_KEEP_TIME) {
        e_printf("power_on keep time is %llums must < %ds, we will reset cnt\r\n", uapi_systick_get_ms(), INIT_NET_CFG_PWOER_ON_KEEP_TIME/1000);
        g_device_control.power_on_cnt = 0;
        req_save_device_data();
    }
}

// spotlight主任务相关变量
#define SPOTLIGHT_MAIN_TASK_PRIO      23
#define SPOTLIGHT_MAIN_TASK_STACK_SIZE 0x1000
static osal_task *spotlight_main_task_handle = NULL;
static bool spotlight_main_task_running = false;
// spotlight主任务函数
static void *spotlight_main_task(const char *arg)
{
    unused(arg);
    e_printf("[spotlight_main_task] Task started\r\n");
    uint32_t current_time = 0; //uapi_systick_get_ms();
    while (spotlight_main_task_running) {
        // 检查配网超时
        check_net_cfg_timeout();
        check_net_cfg_power_on_keep_time();
        osal_msleep(20);
    }
    
    // 停止保存任务
    stop_save_task();
    e_printf("[spotlight_main_task] Task exited\r\n");
    return NULL;
}

// 启动spotlight主任务
static void start_spotlight_main_task(void)
{
    if (spotlight_main_task_handle != NULL) {
        e_printf("[start spotlight task] Task already running\r\n");
        return;
    }

    e_printf("[start spotlight task] Starting task\r\n");
    osal_kthread_lock();
    spotlight_main_task_handle = osal_kthread_create((osal_kthread_handler)spotlight_main_task, NULL, "SpotlightMain",
                                      SPOTLIGHT_MAIN_TASK_STACK_SIZE);
    if (spotlight_main_task_handle != NULL) {
        spotlight_main_task_running = true;
        osal_kthread_set_priority(spotlight_main_task_handle, SPOTLIGHT_MAIN_TASK_PRIO);
        e_printf("[start spotlight task] Task created successfully\r\n");
    } else {
        e_printf("[start spotlight task] Failed to create task\r\n");
    }
    osal_kthread_unlock();
}

// 停止spotlight主任务
static void stop_spotlight_main_task(void)
{
    if (spotlight_main_task_handle == NULL) {
        return;
    }
    
    spotlight_main_task_running = false;
    
    osal_kthread_lock();
    osal_kthread_destroy(spotlight_main_task_handle, 0);
    spotlight_main_task_handle = NULL;
    osal_kthread_unlock();
    
    e_printf("[stop_spotlight_main_task] Task stopped\r\n");
}

// 检查配网超时
static void check_net_cfg_timeout(void)
{
    if (g_net_breath_state != NET_CFG_BREATHING) {
        return;
    }
    uint64_t current_time = uapi_systick_get_ms();
    uint64_t elapsed_time = current_time - g_net_cfg_start_time;
    
    if (elapsed_time >= NET_CFG_TOTAL_TIMEOUT) {
        e_printf("[Net Cfg] 配网超过10分钟，退出配网模式\r\n");
        g_net_breath_state = NET_CFG_TIMEOUT;
    }
}
// 修改spotlight_main函数
int spotlight_main(void) {
    uapi_systick_init();
    read_device_data();
    e_printf("uapi_timer_get_max_us:%uus\r\n", uapi_timer_get_max_us());
    
    // 初始化GPIO并将灯关闭
    gpio_init(SWITCH_PIN);
    // 初始化PWM系统
    pwm_sys_init();
    pwm_init(BRIGHTNESS_PIN, CCT_PIN);
    
    // 初始化渐变控制
    init_fade_ctx();
    
    // 初始化保存任务
    init_save_task();

    // 检查配网状态,确定是否需要进入配网状态
    handle_network_status();

    set_switch(g_device_control.on);//按照当前值更新light

    start_spotlight_main_task();
    return 0;
}

// 设置渐变时长
int set_smooth_time(uint32_t smooth_time)
{
    e_printf("[set_smooth_time] Setting smooth time: %d s\r\n", smooth_time);
    if (smooth_time < SMOOTH_TIME_MIN) {
        e_printf("[set_smooth_time] Smooth time below minimum, adjusted to: %d s\r\n", SMOOTH_TIME_MIN);
        smooth_time = SMOOTH_TIME_MIN;
    }
    if (smooth_time > SMOOTH_TIME_MAX) {
        e_printf("[set_smooth_time] Smooth time above maximum, adjusted to: %d s\r\n", SMOOTH_TIME_MAX);
        smooth_time = SMOOTH_TIME_MAX;
    }
    
    g_device_control.fade_time = smooth_time;
    req_save_device_data();
    e_printf("[set_smooth_time] Smooth time setting completed\r\n");
    return 0;
}

// 设置灯光到配网超时状态
static void set_light2breathtimeout(void)
{
    e_printf("[Net cfg] 配网超过1分钟，退出呼吸灯状态\r\n");
    // 恢复到自定义模式
    g_device_control.brightness_local = BRIGHTNESS_REMOTE2LOCAL(NET_CFG_TIMEOUT_BRIGHTNESS);
    g_device_control.cct_local = CCT_REMOTE2LOCAL(NET_CFG_TIMEOUT_CCT);
    calculate_pwm_duty();
    update_pwm_output();
}

// 设置灯光到配网完成状态
static void set_light2net_cfg_done(void)
{
    g_device_control.elightMode = NET_CFG_DEFAULT_LIGHTMODE;
    g_device_control.brightness_local = BRIGHTNESS_REMOTE2LOCAL(NET_CFG_DEFAULT_BRIGHTNESS);
    g_device_control.cct_local        = CCT_REMOTE2LOCAL(NET_CFG_DEFAULT_CCT);
    g_device_control.fade_time  = NET_CFG_DEFAULT_FADE_TIME;
    calculate_pwm_duty();
    update_pwm_output();
}

// 启动呼吸灯
static void start_breath_timer(void)
{
    g_net_breath_state = NET_CFG_BREATHING;
    g_net_cfg_start_time = uapi_systick_get_ms();
    breath_ctx.is_initial_breath = true;
    uapi_timer_start(breath_ctx.timer_handle, breath_ctx.update_interval, breath_timer_callback, 0);
}