1267 lines
42 KiB
C
1267 lines
42 KiB
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);
|
||
}
|
||
|