ekko/SR_Switch_Hilink_14.2.0.308_20250411
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. 修复删除设备后无法正常配网的问题，原因是因为wifi在ble设置广播时间为0后不进行扫描了，修改为ble advtime为0的时候就不设置就好了

Browse Source 
2. 添加产测 wifi 信号测试的步骤。测试中灯全亮，测试成功灯灭了
3. 修复GPIO 模式配置的问题导致控制led和开关失效的问题。
This commit is contained in:
Ekko.bao
2025-07-22 09:20:01 +08:00
parent feef3bf1f7
commit 6cd2908eaf
8 changed files with 245 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
application/samples/wifi/ohos_connect/hilink_adapt/entry/hilink_ble_main.c
View File

@ -271,10 +271,12 @@ static void HILINK_BT_StateChangeHandler(HILINK_BT_SdkStatus event, const void *
HILINK_SAL_ERROR("set addr err\n"); HILINK_SAL_ERROR("set addr err\n");
} }
/* 设置蓝牙广播格式，包括靠近发现、碰一碰等，下一次发送广播生效 */ /* 设置蓝牙广播格式，包括靠近发现、碰一碰等，下一次发送广播生效 */
BLE_SetAdvType(BLE_ADV_LOCAL_NAME); BLE_SetAdvType(BLE_ADV_NEARBY_V0);
/* BLE配网广播控制：参数代表广播时间，0:停止；0xFFFFFFFF:一直广播，其他：广播指定时间后停止，单位秒 */ /* BLE配网广播控制：参数代表广播时间，0:停止；0xFFFFFFFF:一直广播，其他：广播指定时间后停止，单位秒 */
(void)BLE_CfgNetAdvCtrl(ble_adv_time); if(ble_adv_time) {
(void)BLE_CfgNetAdvCtrl(ble_adv_time);
}
ble_sdk_running = 1; ble_sdk_running = 1;
e_printf("callback set ble adv time: %ds\n", ble_adv_time); e_printf("callback set ble adv time: %ds\n", ble_adv_time);
} }
@ -403,7 +405,7 @@ static int BleRcvCustomData(unsigned char *buff, unsigned int len)
HILINK_SAL_NOTICE("buff is NULL\r\n"); HILINK_SAL_NOTICE("buff is NULL\r\n");
return -1; return -1;
} }
HILINK_SAL_NOTICE("custom data, len: %u, data: %s", len, buff); HILINK_SAL_NOTICE("custom data, len: %u, data: %s\n", len, buff);
/* 处理自定义数据 */ /* 处理自定义数据 */
if (BleHandleCustomData((const char *)buff, len) != 0) { if (BleHandleCustomData((const char *)buff, len) != 0) {
@ -495,7 +497,7 @@ int hilink_ble_main(void)
} }
/* 设置广播方式为靠近发现 */ /* 设置广播方式为靠近发现 */
BLE_SetAdvType(BLE_ADV_LOCAL_NAME); BLE_SetAdvType(BLE_ADV_NEARBY_V0);
/* 初始化ble sdk */ /* 初始化ble sdk */
ret = BLE_CfgNetInit(&g_bleInitParam, &g_bleCfgNetCb); ret = BLE_CfgNetInit(&g_bleInitParam, &g_bleCfgNetCb);

7
application/samples/wifi/ohos_connect/hilink_adapt/product/hilink_device.c
View File

@ -19,9 +19,6 @@
#ifdef CONFIG_SUPPORT_HILINK_INDIE_UPGRADE #ifdef CONFIG_SUPPORT_HILINK_INDIE_UPGRADE
#include "hilink_entry.h" #include "hilink_entry.h"
#endif #endif
extern void handle_device_online(void);
extern void handle_device_unbind(void);
extern void handle_device_offline(void);
// 声明外部函数 // 声明外部函数
#include "switch_panel/switch_panel.h" #include "switch_panel/switch_panel.h"
@ -545,11 +542,11 @@ void HILINK_NotifyDevStatus(int status)
break; break;
case HILINK_DEVICE_UNREGISTER: case HILINK_DEVICE_UNREGISTER:
/* 设备被解绑，请在此处添加实现 */ /* 设备被解绑，请在此处添加实现 */
handle_device_unbind(); // handle_device_unbind();
break; break;
case HILINK_REVOKE_FLAG_SET: case HILINK_REVOKE_FLAG_SET:
/* 设备被复位标记置位，请在此处添加实现 */ /* 设备被复位标记置位，请在此处添加实现 */
handle_device_unbind(); // handle_device_unbind();
break; break;
case HILINK_NEGO_REG_INFO_FAIL: case HILINK_NEGO_REG_INFO_FAIL:
/* 设备协商配网信息失败 */ /* 设备协商配网信息失败 */

6
application/ws63/user_main/switch_panel/switch_panel.h
View File

@ -173,6 +173,7 @@ extern osal_task *g_key_scan_task_handle;
extern osal_task *g_config_task_handle; extern osal_task *g_config_task_handle;
extern osal_task *g_save_task_handle; // 异步保存任务句柄 extern osal_task *g_save_task_handle; // 异步保存任务句柄
extern osal_task *g_report_task_handle; // 异步上报任务句柄 extern osal_task *g_report_task_handle; // 异步上报任务句柄
extern osal_task *g_factory_test_task_handle; // 产测任务句柄
//====================== 函数声明 ====================== //====================== 函数声明 ======================
@ -243,7 +244,10 @@ void panel_led_blink(void);
// 产测相关函数 // 产测相关函数
void enter_factory_test_mode(void); void enter_factory_test_mode(void);
void factory_test_sequence(void); void factory_test_sequence(void);
bool check_factory_test_wifi(void); bool check_factory_test_wifi(int32_t rssi_threshold);
int factory_test_monitor_task(void *arg);
void start_factory_test_monitor(void);
void stop_factory_test_monitor(void);
// HiLink设备事件处理 // HiLink设备事件处理
void handle_device_online(void); void handle_device_online(void);

4
application/ws63/user_main/switch_panel/switch_panel_ble.c
View File

@ -165,7 +165,7 @@ int switch_panel_ble_handle_custom_data(const char *buff, unsigned int len) {
return -1; return -1;
} }
e_printf("[BLE] 接收到数据: %s (长度: %u)\r\n", buff, len); e_printf("[BLE] 接收到数据: %s (len: %u)\r\n", buff, len);
// 处理空JSON请求 - 上报全量状态 // 处理空JSON请求 - 上报全量状态
if (strcmp(buff, "{}") == 0) { if (strcmp(buff, "{}") == 0) {
@ -195,7 +195,7 @@ int switch_panel_ble_handle_custom_data(const char *buff, unsigned int len) {
cJSON *dataItem = cJSON_GetObjectItem(json, "data"); cJSON *dataItem = cJSON_GetObjectItem(json, "data");
// 处理特殊服务ID // 处理特殊服务ID
if (strcmp(svc_id, "allservices") == 0) { if (strcmp(svc_id, "allservices") == 0 || strcmp(svc_id, "getStateinfo") == 0) {
// H5连接时的状态同步请求 // H5连接时的状态同步请求
e_printf("[BLE] H5连接，同步所有状态\r\n"); e_printf("[BLE] H5连接，同步所有状态\r\n");
ble_report_all_switches(); ble_report_all_switches();

189
application/ws63/user_main/switch_panel/switch_panel_config.c
View File

@ -37,6 +37,7 @@ static bool g_factory_test_running = false;
static int g_factory_test_step = 0; static int g_factory_test_step = 0;
static uint32_t g_factory_test_start_time = 0; static uint32_t g_factory_test_start_time = 0;
static uint8_t g_wifi_state = WIFI_STA_SAMPLE_INIT; static uint8_t g_wifi_state = WIFI_STA_SAMPLE_INIT;
static bool g_factory_test_monitor_running = false;
//====================== WiFi事件回调函数 ====================== //====================== WiFi事件回调函数 ======================
static void wifi_scan_state_changed(int32_t state, int32_t size) { static void wifi_scan_state_changed(int32_t state, int32_t size) {
@ -169,10 +170,7 @@ static int factory_test_wifi_init(void) {
} }
// 创建STA接口 // 创建STA接口
if (wifi_sta_enable() != 0) { wifi_sta_enable();
e_printf("%s WiFi STA启动失败\r\n", WIFI_STA_SAMPLE_LOG);
goto lab_err;
}
e_printf("%s WiFi产测环境初始化完成\r\n", WIFI_STA_SAMPLE_LOG); e_printf("%s WiFi产测环境初始化完成\r\n", WIFI_STA_SAMPLE_LOG);
return 0; return 0;
@ -184,11 +182,11 @@ lab_err:
// 进入配网模式 // 进入配网模式
void enter_config_mode(void) { void enter_config_mode(void) {
if (g_runtime_state.mode == MODE_CONFIG) { if (g_runtime_state.mode == MODE_CONFIG) {
e_printf("[CONFIG] 已在配网模式中\r\n"); e_printf("已在配网模式中\r\n");
return; return;
} }
e_printf("[CONFIG] 进入配网模式\r\n"); e_printf("进入配网模式\r\n");
start_hilink_ble_net_config(CONFIG_TIMEOUT_MS/1000); start_hilink_ble_net_config(CONFIG_TIMEOUT_MS/1000);
// 更新设备模式 // 更新设备模式
@ -204,7 +202,7 @@ void enter_config_mode(void) {
"config_task", "config_task",
TASK_STACK_SIZE); TASK_STACK_SIZE);
if (!g_config_task_handle) { if (!g_config_task_handle) {
e_printf("[CONFIG] 创建配网任务失败\r\n"); e_printf("创建配网任务失败\r\n");
return; return;
} }
@ -212,7 +210,7 @@ void enter_config_mode(void) {
osal_kthread_set_priority(g_config_task_handle, TASK_PRIORITY_NORM); osal_kthread_set_priority(g_config_task_handle, TASK_PRIORITY_NORM);
} }
e_printf("[CONFIG] 配网模式已开启，超时时间: %d分钟\r\n", CONFIG_TIMEOUT_MS / 60000); e_printf("配网模式已开启，超时时间: %d分钟\r\n", CONFIG_TIMEOUT_MS / 60000);
} }
// 退出配网模式 // 退出配网模式
@ -221,8 +219,10 @@ void exit_config_mode(void) {
return; return;
} }
e_printf("[CONFIG] 退出配网模式\r\n"); e_printf("退出配网模式\r\n");
start_hilink_ble_net_config(0);
// 更新设备模式
set_device_mode(MODE_NORMAL);
// 终止配网任务 // 终止配网任务
if (g_config_task_handle) { if (g_config_task_handle) {
osal_kthread_destroy(g_config_task_handle, 1); osal_kthread_destroy(g_config_task_handle, 1);
@ -237,44 +237,32 @@ void exit_config_mode(void) {
// 恢复面板背光状态 // 恢复面板背光状态
set_panel_led(g_persistent_state.panel_led ? PANEL_LED_ON : PANEL_LED_OFF); set_panel_led(g_persistent_state.panel_led ? PANEL_LED_ON : PANEL_LED_OFF);
// 更新设备模式
set_device_mode(MODE_NORMAL);
// 重置配网相关变量 // 重置配网相关变量
g_config_key_id = -1; g_config_key_id = -1;
e_printf("已退出配网模式\r\n");
e_printf("[CONFIG] 已退出配网模式\r\n");
} }
// 配网模式任务 // 配网模式任务
int config_mode_task(void *arg) { int config_mode_task(void *arg) {
(void)arg; (void)arg;
e_printf("[CONFIG] 配网任务开始\r\n"); e_printf("配网任务开始\r\n");
// 记录配网开始时间 // 记录配网开始时间
g_runtime_state.config_start_time = hfsys_get_time(); g_runtime_state.config_start_time = hfsys_get_time();
// 只有在首次启动时才检查产测热点
if (g_persistent_state.is_first_boot && check_factory_test_wifi()) {
e_printf("[CONFIG] 检测到产测热点且为首次启动，进入产测模式\r\n");
exit_config_mode();
enter_factory_test_mode();
return 0;
}
uint32_t config_start_time = g_runtime_state.config_start_time; uint32_t config_start_time = g_runtime_state.config_start_time;
bool led_blink_state = false; bool led_blink_state = false;
uint32_t last_blink_time = 0; uint32_t last_blink_time = 0;
const uint32_t blink_interval = 500; // 500ms闪烁间隔 (1Hz) const uint32_t blink_interval = 500; // 500ms闪烁间隔 (1Hz)
while (g_runtime_state.mode == MODE_CONFIG && !osal_kthread_should_stop()) { while (g_runtime_state.mode == MODE_CONFIG) {
uint32_t current_time = hfsys_get_time(); uint32_t current_time = hfsys_get_time();
uint32_t elapsed_time = current_time - config_start_time; uint32_t elapsed_time = current_time - config_start_time;
// 检查是否超时 (10分钟) // 检查是否超时 (10分钟)
if (elapsed_time >= CONFIG_TIMEOUT_MS) { if (elapsed_time >= CONFIG_TIMEOUT_MS) {
e_printf("[CONFIG] 配网超时，退出配网模式\r\n"); e_printf("配网超时，退出配网模式\r\n");
break; break;
} }
@ -307,10 +295,8 @@ int config_mode_task(void *arg) {
osal_msleep(100); osal_msleep(100);
} }
e_printf("[CONFIG] 配网任务结束\r\n"); e_printf("配网任务结束\r\n");
g_config_task_handle = NULL; g_config_task_handle = NULL;
// 退出配网模式
exit_config_mode();
return 0; return 0;
} }
@ -332,7 +318,7 @@ void panel_led_blink(void) {
// 进入产测模式 // 进入产测模式
void enter_factory_test_mode(void) { void enter_factory_test_mode(void) {
e_printf("[FACTORY] 进入产测模式\r\n"); e_printf("进入产测模式\r\n");
// 更新设备模式 // 更新设备模式
set_device_mode(MODE_FACTORY_TEST); set_device_mode(MODE_FACTORY_TEST);
@ -341,14 +327,11 @@ void enter_factory_test_mode(void) {
g_factory_test_running = true; g_factory_test_running = true;
g_factory_test_step = 0; g_factory_test_step = 0;
g_factory_test_start_time = hfsys_get_time(); g_factory_test_start_time = hfsys_get_time();
// 开始产测序列
factory_test_sequence();
} }
// 产测序列 // 产测序列
void factory_test_sequence(void) { void factory_test_sequence(void) {
e_printf("[FACTORY] 开始产测序列\r\n"); e_printf("开始产测序列\r\n");
// 步骤1: 开始指示 - 交替闪烁白黄灯500ms // 步骤1: 开始指示 - 交替闪烁白黄灯500ms
for (int i = 0; i < 6; i++) { for (int i = 0; i < 6; i++) {
@ -360,7 +343,7 @@ void factory_test_sequence(void) {
// 步骤2-5: 单个开关测试 (开1->4, 每个1.5秒) // 步骤2-5: 单个开关测试 (开1->4, 每个1.5秒)
for (int switch_id = 0; switch_id < SWITCH_COUNT; switch_id++) { for (int switch_id = 0; switch_id < SWITCH_COUNT; switch_id++) {
e_printf("[FACTORY] 测试开关%d\r\n", switch_id + 1); e_printf("测试开关%d\r\n", switch_id + 1);
// 所有开关关闭，所有LED黄灯 // 所有开关关闭，所有LED黄灯
for (int i = 0; i < SWITCH_COUNT; i++) { for (int i = 0; i < SWITCH_COUNT; i++) {
@ -377,7 +360,7 @@ void factory_test_sequence(void) {
} }
// 步骤6: 全关 (1.5秒) // 步骤6: 全关 (1.5秒)
e_printf("[FACTORY] 测试全关\r\n"); e_printf("测试全关\r\n");
for (int i = 0; i < SWITCH_COUNT; i++) { for (int i = 0; i < SWITCH_COUNT; i++) {
set_switch_output(i, false); set_switch_output(i, false);
set_led_output(i, LED_YELLOW); set_led_output(i, LED_YELLOW);
@ -385,7 +368,7 @@ void factory_test_sequence(void) {
osal_msleep(1500); osal_msleep(1500);
// 步骤7: 全开 (1.5秒) // 步骤7: 全开 (1.5秒)
e_printf("[FACTORY] 测试全开\r\n"); e_printf("测试全开\r\n");
for (int i = 0; i < SWITCH_COUNT; i++) { for (int i = 0; i < SWITCH_COUNT; i++) {
set_switch_output(i, true); set_switch_output(i, true);
set_led_output(i, LED_WHITE); set_led_output(i, LED_WHITE);
@ -393,28 +376,31 @@ void factory_test_sequence(void) {
osal_msleep(1500); osal_msleep(1500);
// 步骤8: 再次全关 // 步骤8: 再次全关
e_printf("[FACTORY] 结束测试 - 全关\r\n"); e_printf("结束测试 - 全关\r\n");
for (int i = 0; i < SWITCH_COUNT; i++) { for (int i = 0; i < SWITCH_COUNT; i++) {
set_switch_output(i, false); set_switch_output(i, false);
set_led_output(i, LED_YELLOW); set_led_output(i, LED_YELLOW);
} }
// TODO: WiFi信号强度校验 osal_msleep(1500);
bool wifi_test_pass = check_factory_test_wifi(); // 步骤9: 检查WiFi信号强度
for (int i = 0; i < SWITCH_COUNT; i++) {
set_led_output(i, LED_WHITE);
}
bool wifi_test_pass = check_factory_test_wifi(FACTORY_TEST_RSSI_THRESHOLD);
// 显示最终结果 // 显示最终结果
if (wifi_test_pass) { if (wifi_test_pass) {
e_printf("[FACTORY] 产测全部通过\r\n"); e_printf("产测全部通过\r\n");
// 所有开关开启表示通过 // 所有开关开启表示通过
for (int i = 0; i < SWITCH_COUNT; i++) { for (int i = 0; i < SWITCH_COUNT; i++) {
set_switch_output(i, true); set_switch_output(i, false);
set_led_output(i, LED_WHITE); set_led_output(i, LED_YELLOW);
} }
} else { } else {
e_printf("[FACTORY] 产测失败\r\n"); e_printf("产测失败\r\n");
// 所有开关关闭表示失败 // 所有开关关闭表示失败
for (int i = 0; i < SWITCH_COUNT; i++) { for (int i = 0; i < SWITCH_COUNT; i++) {
set_switch_output(i, false);
set_led_output(i, LED_YELLOW); set_led_output(i, LED_YELLOW);
} }
} }
@ -425,12 +411,12 @@ void factory_test_sequence(void) {
// 恢复设备默认状态 // 恢复设备默认状态
sync_hardware_state(); sync_hardware_state();
wifi_unregister_event_cb(&wifi_event_cb);
e_printf("[FACTORY] 产测序列完成\r\n"); e_printf("产测序列完成\r\n");
} }
// 检查产测热点 // 检查产测热点
bool check_factory_test_wifi(void) { bool check_factory_test_wifi(int32_t rssi_threshold) {
// 使用WiFi扫描功能检测产测热点 "ShuorongSelfTest" // 使用WiFi扫描功能检测产测热点 "ShuorongSelfTest"
// 并校验信号强度 >= -70dBm // 并校验信号强度 >= -70dBm
@ -449,7 +435,7 @@ bool check_factory_test_wifi(void) {
} }
// 扫描并检查目标热点 // 扫描并检查目标热点
if (wifi_scan_and_check(FACTORY_TEST_SSID, FACTORY_TEST_RSSI_THRESHOLD) == 0) { if (wifi_scan_and_check(FACTORY_TEST_SSID, rssi_threshold) == 0) {
e_printf("%s 产测热点检测通过: %s, 信号强度满足要求\r\n", e_printf("%s 产测热点检测通过: %s, 信号强度满足要求\r\n",
WIFI_STA_SAMPLE_LOG, FACTORY_TEST_SSID); WIFI_STA_SAMPLE_LOG, FACTORY_TEST_SSID);
return true; return true;
@ -458,3 +444,104 @@ bool check_factory_test_wifi(void) {
return false; // 未找到合格的产测热点 return false; // 未找到合格的产测热点
} }
//====================== 产测监控线程 ======================
// 产测监控任务
int factory_test_monitor_task(void *arg) {
(void)arg;
e_printf("[FACTORY] 产测监控线程启动\r\n");
uint32_t monitor_start_time = hfsys_get_time();
uint32_t last_scan_time = 0;
const uint32_t scan_timeout = 5000; // 5秒总超时时间
const uint32_t scan_interval = 500; // 500ms扫描间隔
while (g_factory_test_monitor_running) {
uint32_t current_time = hfsys_get_time();
// 检查总超时时间
if ((current_time - monitor_start_time) >= scan_timeout) {
e_printf("[FACTORY] 产测热点扫描超时（5秒），停止监控\r\n");
break;
}
// 每500ms检查一次WiFi
if ((current_time - last_scan_time) >= scan_interval) {
last_scan_time = current_time;
e_printf("[FACTORY] 正在扫描产测热点: %s\r\n", FACTORY_TEST_SSID);
// 检查是否找到产测热点
if (check_factory_test_wifi(0)) { // 不检查信号强度，只检查是否存在
e_printf("[FACTORY] 发现产测热点，退出配网模式并进入产测\r\n");
// 退出配网模式
if (g_runtime_state.mode == MODE_CONFIG) {
exit_config_mode();
}
// 进入产测模式
enter_factory_test_mode();
// 开始产测序列
factory_test_sequence();
// 结束监控任务
break;
}
}
// 休眠100ms
osal_msleep(100);
}
e_printf("[FACTORY] 产测监控线程退出\r\n");
g_factory_test_task_handle = NULL;
wifi_unregister_event_cb(&wifi_event_cb);
return 0;
}
// 启动产测监控线程
void start_factory_test_monitor(void) {
if (g_factory_test_task_handle != NULL) {
e_printf("[FACTORY] 产测监控线程已经在运行\r\n");
return;
}
e_printf("[FACTORY] 启动产测监控线程\r\n");
g_factory_test_monitor_running = true;
g_factory_test_task_handle = osal_kthread_create((osal_kthread_handler)factory_test_monitor_task,
NULL,
"factory_test_monitor",
TASK_STACK_SIZE);
if (g_factory_test_task_handle == NULL) {
e_printf("[FACTORY] 创建产测监控任务失败\r\n");
g_factory_test_monitor_running = false;
return;
}
// 设置任务优先级为低优先级
osal_kthread_set_priority(g_factory_test_task_handle, TASK_PRIORITY_LOW);
e_printf("[FACTORY] 产测监控线程启动成功\r\n");
}
// 停止产测监控线程
void stop_factory_test_monitor(void) {
if (g_factory_test_task_handle == NULL) {
return;
}
e_printf("[FACTORY] 停止产测监控线程\r\n");
g_factory_test_monitor_running = false;
// 等待任务退出
if (g_factory_test_task_handle) {
osal_kthread_destroy(g_factory_test_task_handle, 1);
g_factory_test_task_handle = NULL;
}
e_printf("[FACTORY] 产测监控线程已停止\r\n");
}

29
application/ws63/user_main/switch_panel/switch_panel_hilink.c
View File

@ -17,6 +17,9 @@ static int handle_put_switch_common(int switch_id, const char* svc_id,
void handle_device_online(void) { void handle_device_online(void) {
e_printf("设备上线\r\n"); e_printf("设备上线\r\n");
// 检查是否是新绑定的设备
bool was_unbound = !g_persistent_state.is_bound;
// 更新设备绑定状态 // 更新设备绑定状态
g_persistent_state.is_bound = true; g_persistent_state.is_bound = true;
@ -27,10 +30,26 @@ void handle_device_online(void) {
} }
// 退出配网模式 // 退出配网模式
if (g_runtime_state.mode == MODE_CONFIG) { exit_config_mode();
exit_config_mode();
// 如果设备之前是未绑定状态，现在绑定成功，恢复默认状态
if (was_unbound) {
e_printf("设备绑定成功，恢复默认状态\r\n");
// 恢复默认状态：总开关关闭，所有子开关关闭，面板背光开启，所有LED黄灯
g_persistent_state.master_switch = false;
g_persistent_state.panel_led = true;
for (int i = 0; i < SWITCH_COUNT; i++) {
g_persistent_state.switches[i].switch_on = false;
g_persistent_state.switches[i].led_state = false; // false表示黄灯
}
// 同步硬件状态
sync_hardware_state();
e_printf("已恢复默认状态：总开关关闭，所有子开关关闭，LED黄灯，面板背光开启\r\n");
} }
// 设备上线时禁用蓝牙模式，启用云端模式 // 设备上线时禁用蓝牙模式，启用云端模式
extern void switch_panel_ble_disable(void); extern void switch_panel_ble_disable(void);
switch_panel_ble_disable(); switch_panel_ble_disable();
@ -64,12 +83,14 @@ void handle_device_unbind(void) {
// 重置为出厂默认状态 // 重置为出厂默认状态
reset_persistent_state(); reset_persistent_state();
g_persistent_state.is_bound = false; // 保持未绑定状态 g_persistent_state.is_bound = false; // 保持未绑定状态
g_persistent_state.is_first_boot = false; // 标记为非出厂模式
// 同步硬件状态 // 同步硬件状态
sync_hardware_state(); sync_hardware_state();
// 保存状态 // 保存状态
save_persistent_state(); save_persistent_state();
// HILINK_RestoreFactorySettings();
e_printf("设备已重置为出厂默认状态\r\n"); e_printf("设备已重置为出厂默认状态\r\n");
} }

57
application/ws63/user_main/switch_panel/switch_panel_keys.c
View File

@ -14,11 +14,17 @@ void update_switch_state(int switch_id, bool state) {
} }
// 检查总开关是否允许操作 // 检查总开关是否允许操作
if (!g_persistent_state.master_switch && state) { // 注意：如果设备未绑定，则不受总开关限制，可以自由控制
e_printf("总开关关闭，不允许开启开关%d\r\n", switch_id + 1); if (g_persistent_state.is_bound && !g_persistent_state.master_switch && state) {
e_printf("设备已绑定且总开关关闭，不允许开启开关%d\r\n", switch_id + 1);
return; return;
} }
// 如果设备未绑定，记录状态变化以便调试
if (!g_persistent_state.is_bound) {
e_printf("设备未绑定，允许自由控制开关%d\r\n", switch_id + 1);
}
// 更新开关状态 // 更新开关状态
if (g_persistent_state.switches[switch_id].switch_on != state) { if (g_persistent_state.switches[switch_id].switch_on != state) {
g_persistent_state.switches[switch_id].switch_on = state; g_persistent_state.switches[switch_id].switch_on = state;
@ -66,9 +72,15 @@ void update_master_switch(bool state) {
// 应用总开关控制逻辑 // 应用总开关控制逻辑
void apply_master_switch_control(void) { void apply_master_switch_control(void) {
// 如果设备未绑定，总开关不影响子开关控制
if (!g_persistent_state.is_bound) {
e_printf("设备未绑定，总开关不影响子开关控制\r\n");
return;
}
if (!g_persistent_state.master_switch) { if (!g_persistent_state.master_switch) {
// 总开关关闭时，强制关闭所有子开关 // 设备已绑定且总开关关闭时，强制关闭所有子开关
e_printf("总开关关闭，强制关闭所有子开关\r\n"); e_printf("设备已绑定且总开关关闭，强制关闭所有子开关\r\n");
for (int i = 0; i < SWITCH_COUNT; i++) { for (int i = 0; i < SWITCH_COUNT; i++) {
// 如果子开关之前是开着的，需要同步状态 // 如果子开关之前是开着的，需要同步状态
@ -92,9 +104,6 @@ void apply_master_switch_control(void) {
// set_led_output(i, g_persistent_state.switches[i].led_state ? LED_WHITE : LED_YELLOW); // set_led_output(i, g_persistent_state.switches[i].led_state ? LED_WHITE : LED_YELLOW);
// } // }
} }
// 立即保存状态
save_persistent_state();
// 同步所有子开关状态到云端 // 同步所有子开关状态到云端
if (g_persistent_state.is_bound) { if (g_persistent_state.is_bound) {
fast_report_all_switches_async(); fast_report_all_switches_async();
@ -109,7 +118,7 @@ void apply_master_switch_control(void) {
int key_scan_task(void *arg) { int key_scan_task(void *arg) {
(void)arg; (void)arg;
e_printf("[KEY] 按键扫描任务开始\r\n"); e_printf("按键扫描任务开始\r\n");
// 按键状态记录 // 按键状态记录
bool stable_states[SWITCH_COUNT] = {true, true, true, true}; // 稳定状态 bool stable_states[SWITCH_COUNT] = {true, true, true, true}; // 稳定状态
@ -126,14 +135,14 @@ int key_scan_task(void *arg) {
g_runtime_state.switches[i].physical_key = stable_states[i]; g_runtime_state.switches[i].physical_key = stable_states[i];
} }
while (!osal_kthread_should_stop()) { while (1) {
uint32_t current_time = hfsys_get_time(); uint32_t current_time = hfsys_get_time();
// 扫描所有按键 // 扫描所有按键
for (int i = 0; i < SWITCH_COUNT; i++) { for (int i = 0; i < SWITCH_COUNT; i++) {
bool new_raw_state = get_key_input(i); bool new_raw_state = get_key_input(i);
// if (i == 1) { // if (i == 1) {
// e_printf("[KEY] 按键%d 状态: %d\r\n", i + 1, new_raw_state); // e_printf("按键%d 状态: %d\r\n", i + 1, new_raw_state);
// } // }
// 如果原始状态发生变化，重置防抖计时 // 如果原始状态发生变化，重置防抖计时
if (new_raw_state != raw_states[i]) { if (new_raw_state != raw_states[i]) {
@ -154,7 +163,7 @@ int key_scan_task(void *arg) {
// 按键按下 // 按键按下
press_start_time[i] = current_time; press_start_time[i] = current_time;
is_long_press_handled[i] = false; is_long_press_handled[i] = false;
e_printf("[KEY] 按键%d 按下\r\n", i + 1); e_printf("按键%d 按下\r\n", i + 1);
} else { } else {
// 按键松开 // 按键松开
uint32_t press_duration = current_time - press_start_time[i]; uint32_t press_duration = current_time - press_start_time[i];
@ -168,7 +177,7 @@ int key_scan_task(void *arg) {
handle_key_press(i); handle_key_press(i);
} }
e_printf("[KEY] 按键%d 松开 (持续时间: %ums)\r\n", i + 1, press_duration); e_printf("按键%d 松开 (持续时间: %ums)\r\n", i + 1, press_duration);
} }
// 更新全局状态 // 更新全局状态
@ -191,7 +200,7 @@ int key_scan_task(void *arg) {
osal_msleep(10); // 10ms扫描间隔，提高响应性 osal_msleep(10); // 10ms扫描间隔，提高响应性
} }
e_printf("[KEY] 按键扫描任务退出\r\n"); e_printf("按键扫描任务退出\r\n");
return 0; return 0;
} }
@ -201,17 +210,17 @@ void handle_key_press(int key_id) {
return; return;
} }
e_printf("[KEY] 处理按键%d 短按事件\r\n", key_id + 1); e_printf("处理按键%d 短按事件\r\n", key_id + 1);
// 在配网模式下，忽略短按事件 // 在配网模式下，忽略短按事件
if (g_runtime_state.mode == MODE_CONFIG) { if (g_runtime_state.mode == MODE_CONFIG) {
e_printf("[KEY] 配网模式下，忽略短按事件\r\n"); e_printf("配网模式下，忽略短按事件\r\n");
return; return;
} }
// 在产测模式下，忽略短按事件 // 在产测模式下，忽略短按事件
if (g_runtime_state.mode == MODE_FACTORY_TEST) { if (g_runtime_state.mode == MODE_FACTORY_TEST) {
e_printf("[KEY] 产测模式下，忽略短按事件\r\n"); e_printf("产测模式下，忽略短按事件\r\n");
return; return;
} }
@ -226,11 +235,11 @@ void handle_key_long_press(int key_id) {
return; return;
} }
e_printf("[KEY] 处理按键%d 长按事件\r\n", key_id + 1); e_printf("处理按键%d 长按事件\r\n", key_id + 1);
// 只有第一个按键支持长按进入配网模式 // 只有第一个按键支持长按进入配网模式
if (key_id == 0) { if (key_id == 0) {
e_printf("[KEY] 长按第一个按键，检查配网条件\r\n"); e_printf("长按第一个按键，检查配网条件\r\n");
// 只有在正常模式下且设备未绑定时才能进入配网模式 // 只有在正常模式下且设备未绑定时才能进入配网模式
if (g_runtime_state.mode == MODE_NORMAL && !g_persistent_state.is_bound) { if (g_runtime_state.mode == MODE_NORMAL && !g_persistent_state.is_bound) {
@ -239,13 +248,13 @@ void handle_key_long_press(int key_id) {
enter_config_mode(); enter_config_mode();
} else { } else {
if (g_persistent_state.is_bound) { if (g_persistent_state.is_bound) {
e_printf("[KEY] 设备已绑定，不能进入配网模式\r\n"); e_printf("设备已绑定，不能进入配网模式\r\n");
} else { } else {
e_printf("[KEY] 非正常模式，不能进入配网模式\r\n"); e_printf("非正常模式，不能进入配网模式\r\n");
} }
} }
} else { } else {
e_printf("[KEY] 非第一个按键的长按，忽略\r\n"); e_printf("非第一个按键的长按，忽略\r\n");
} }
} }
@ -266,17 +275,17 @@ int key_system_init(void) {
"key_scan", "key_scan",
TASK_STACK_SIZE); TASK_STACK_SIZE);
if (!g_key_scan_task_handle) { if (!g_key_scan_task_handle) {
e_printf("[KEY] 创建按键扫描任务失败\r\n"); e_printf("创建按键扫描任务失败\r\n");
return HF_FAIL; return HF_FAIL;
} }
// 设置任务优先级 // 设置任务优先级
ret = osal_kthread_set_priority(g_key_scan_task_handle, TASK_PRIORITY_HIGH); ret = osal_kthread_set_priority(g_key_scan_task_handle, TASK_PRIORITY_HIGH);
if (ret != 0) { if (ret != 0) {
e_printf("[KEY] 设置按键扫描任务优先级失败: %d\r\n", ret); e_printf("设置按键扫描任务优先级失败: %d\r\n", ret);
} }
e_printf("[KEY] 按键系统初始化完成\r\n"); e_printf("按键系统初始化完成\r\n");
return HF_SUCCESS; return HF_SUCCESS;
} }

62
application/ws63/user_main/switch_panel/switch_panel_main.c
View File

@ -44,6 +44,7 @@ osal_task *g_key_scan_task_handle = NULL;
osal_task *g_config_task_handle = NULL; osal_task *g_config_task_handle = NULL;
osal_task *g_save_task_handle = NULL; // 异步保存任务句柄 osal_task *g_save_task_handle = NULL; // 异步保存任务句柄
osal_task *g_report_task_handle = NULL; // 异步上报任务句柄 osal_task *g_report_task_handle = NULL; // 异步上报任务句柄
osal_task *g_factory_test_task_handle = NULL; // 产测任务句柄
static bool g_initialized = false; static bool g_initialized = false;
static uint32_t g_config_start_time = 0; static uint32_t g_config_start_time = 0;
@ -79,7 +80,7 @@ int async_report_task(void *arg) {
// 引用外部的fast_report函数 // 引用外部的fast_report函数
extern int fast_report(const char* svc_id); extern int fast_report(const char* svc_id);
while (g_report_system_running && !osal_kthread_should_stop()) { while (g_report_system_running) {
// 等待上报信号量 // 等待上报信号量
if (osal_sem_down(&g_report_semaphore) == OSAL_SUCCESS) { if (osal_sem_down(&g_report_semaphore) == OSAL_SUCCESS) {
if (!g_report_system_running) { if (!g_report_system_running) {
@ -407,7 +408,7 @@ static int save_data_task(void *arg) {
e_printf("异步保存任务启动\r\n"); e_printf("异步保存任务启动\r\n");
while (g_save_system_running && !osal_kthread_should_stop()) { while (g_save_system_running) {
// 等待保存信号量 // 等待保存信号量
if (osal_sem_down(&g_save_semaphore) == OSAL_SUCCESS) { if (osal_sem_down(&g_save_semaphore) == OSAL_SUCCESS) {
if (!g_save_system_running) { if (!g_save_system_running) {
@ -590,7 +591,7 @@ void reset_persistent_state(void) {
g_persistent_state.magic = DEVICE_DATA_MAGIC; g_persistent_state.magic = DEVICE_DATA_MAGIC;
g_persistent_state.version = DEVICE_DATA_VERSION; g_persistent_state.version = DEVICE_DATA_VERSION;
e_printf("[STATE] 持久化状态已重置为默认值\r\n"); e_printf("持久化状态已重置为默认值\r\n");
} }
// 初始化运行时状态 // 初始化运行时状态
@ -611,7 +612,7 @@ void init_runtime_state(void) {
g_runtime_state.switches[i].long_press_handled = false; g_runtime_state.switches[i].long_press_handled = false;
} }
e_printf("[STATE] 运行时状态已初始化\r\n"); e_printf("运行时状态已初始化\r\n");
} }
//====================== GPIO配置数据结构 ====================== //====================== GPIO配置数据结构 ======================
@ -627,25 +628,25 @@ typedef struct {
// GPIO初始化配置表 // GPIO初始化配置表
static const gpio_config_t gpio_configs[] = { static const gpio_config_t gpio_configs[] = {
// 开关控制 - 输出 // 开关控制 - 输出
{SWITCH1_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH1"}, {SWITCH1_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH1"},
{SWITCH2_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH2"}, {SWITCH2_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH2"},
{SWITCH3_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH3"}, {SWITCH3_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH3"},
{SWITCH4_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH4"}, {SWITCH4_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH4"},
// 物理按键 - 输入 // 物理按键 - 输入
{KEY1_GPIO, PIN_MODE_0, PIN_PULL_TYPE_UP, PIN_DS_7, GPIO_DIRECTION_INPUT, "KEY1"}, {KEY1_GPIO, PIN_MODE_0, PIN_PULL_TYPE_UP, PIN_DS_7, GPIO_DIRECTION_INPUT, "KEY1"},
{KEY2_GPIO, PIN_MODE_0, PIN_PULL_TYPE_UP, PIN_DS_7, GPIO_DIRECTION_INPUT, "KEY2"}, {KEY2_GPIO, PIN_MODE_2, PIN_PULL_TYPE_UP, PIN_DS_7, GPIO_DIRECTION_INPUT, "KEY2"},
{KEY3_GPIO, PIN_MODE_0, PIN_PULL_TYPE_UP, PIN_DS_7, GPIO_DIRECTION_INPUT, "KEY3"}, {KEY3_GPIO, PIN_MODE_0, PIN_PULL_TYPE_UP, PIN_DS_7, GPIO_DIRECTION_INPUT, "KEY3"},
{KEY4_GPIO, PIN_MODE_0, PIN_PULL_TYPE_UP, PIN_DS_7, GPIO_DIRECTION_INPUT, "KEY4"}, {KEY4_GPIO, PIN_MODE_0, PIN_PULL_TYPE_UP, PIN_DS_7, GPIO_DIRECTION_INPUT, "KEY4"},
// 面板背光 - 输出 // 面板背光 - 输出
{PANEL_LED_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "PANEL_LED"}, {PANEL_LED_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "PANEL_LED"},
// LED指示灯 - 输出 // LED指示灯 - 输出
{LED1_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED1"}, {LED1_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED1"},
{LED2_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED2"}, {LED2_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED2"},
{LED3_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED3"}, {LED3_GPIO, PIN_MODE_4, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED3"},
{LED4_GPIO, PIN_MODE_1, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED4"}, {LED4_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED4"},
}; };
@ -668,40 +669,40 @@ int switch_panel_gpio_init(void) {
// 设置为GPIO模式 // 设置为GPIO模式
ret = uapi_pin_set_mode(config->pin, config->mode); ret = uapi_pin_set_mode(config->pin, config->mode);
if (ret != 0) { if (ret != 0) {
e_printf("[GPIO] %s pinctrl初始化失败: %d\r\n", config->name, ret); e_printf("%s pinctrl初始化失败: %d\r\n", config->name, ret);
return HF_FAIL; return HF_FAIL;
} }
ret = uapi_pin_set_pull(config->pin, config->pull); ret = uapi_pin_set_pull(config->pin, config->pull);
if (ret != 0) { if (ret != 0) {
e_printf("[GPIO] %s pinctrl初始化失败: %d\r\n", config->name, ret); e_printf("%s pinctrl初始化失败: %d\r\n", config->name, ret);
return HF_FAIL; return HF_FAIL;
} }
ret = uapi_pin_set_ds(config->pin, config->ds); ret = uapi_pin_set_ds(config->pin, config->ds);
if (ret != 0) { if (ret != 0) {
e_printf("[GPIO] %s pinctrl初始化失败: %d\r\n", config->name, ret); e_printf("%s pinctrl初始化失败: %d\r\n", config->name, ret);
return HF_FAIL; return HF_FAIL;
} }
// 设置GPIO方向 // 设置GPIO方向
ret = uapi_gpio_set_dir(config->pin, config->direction); ret = uapi_gpio_set_dir(config->pin, config->direction);
if (ret != 0) { if (ret != 0) {
e_printf("[GPIO] %s 设置方向失败: %d\r\n", config->name, ret); e_printf("%s 设置方向失败: %d\r\n", config->name, ret);
return HF_FAIL; return HF_FAIL;
} }
e_printf("[GPIO] %s 初始化完成 (方向: %s)\r\n", e_printf("%s 初始化完成 (方向: %s)\r\n",
config->name, config->name,
config->direction == GPIO_DIRECTION_OUTPUT ? "输出" : "输入"); config->direction == GPIO_DIRECTION_OUTPUT ? "输出" : "输入");
} }
e_printf("[GPIO] 所有GPIO初始化完成 (共%d个)\r\n", GPIO_CONFIG_COUNT); e_printf("所有GPIO初始化完成 (共%d个)\r\n", GPIO_CONFIG_COUNT);
return HF_SUCCESS; return HF_SUCCESS;
} }
// 设置开关输出状态 // 设置开关输出状态
void set_switch_output(int switch_id, bool state) { void set_switch_output(int switch_id, bool state) {
if (switch_id < 0 || switch_id >= SWITCH_COUNT) { if (switch_id < 0 || switch_id >= SWITCH_COUNT) {
e_printf("[HW] 无效的开关ID: %d\r\n", switch_id); e_printf("无效的开关ID: %d\r\n", switch_id);
return; return;
} }
@ -717,13 +718,13 @@ void set_switch_output(int switch_id, bool state) {
// 设置输出状态 // 设置输出状态
gpio_level_t level = state ? GPIO_LEVEL_HIGH : GPIO_LEVEL_LOW; gpio_level_t level = state ? GPIO_LEVEL_HIGH : GPIO_LEVEL_LOW;
uapi_gpio_set_val(gpio_pin, level); uapi_gpio_set_val(gpio_pin, level);
e_printf("[HW] 开关%d 状态: %s\r\n", switch_id + 1, state ? "开" : "关"); e_printf("开关%d 状态: %s\r\n", switch_id + 1, state ? "开" : "关");
} }
// 设置 LED 指示灯状态 // 设置 LED 指示灯状态
void set_led_output(int led_id, led_state_t state) { void set_led_output(int led_id, led_state_t state) {
if (led_id < 0 || led_id >= SWITCH_COUNT) { if (led_id < 0 || led_id >= SWITCH_COUNT) {
e_printf("[HW] 无效的LED ID: %d\r\n", led_id); e_printf("无效的LED ID: %d\r\n", led_id);
return; return;
} }
@ -781,7 +782,7 @@ void sync_hardware_state(void) {
// 同步面板背光状态 // 同步面板背光状态
set_panel_led(g_persistent_state.panel_led ? PANEL_LED_ON : PANEL_LED_OFF); set_panel_led(g_persistent_state.panel_led ? PANEL_LED_ON : PANEL_LED_OFF);
e_printf("[STATE] 硬件状态已同步\r\n"); e_printf("硬件状态已同步\r\n");
} }
//====================== 主程序函数 ====================== //====================== 主程序函数 ======================
@ -844,11 +845,16 @@ int switch_panel_main(void) {
save_persistent_state(); save_persistent_state();
// 配网逻辑： // 配网逻辑：
// 1. 如果设备未绑定 且 是第一次启动 -> 直接进入配网 // 1. 如果设备未绑定 且 是第一次启动 -> 启动产测监控并进入配网
// 2. 如果设备未绑定 且 不是第一次启动 -> 等待按键触发配网 // 2. 如果设备未绑定 且 不是第一次启动 -> 等待按键触发配网
if (!g_persistent_state.is_bound) { if (!g_persistent_state.is_bound) {
if (first_boot) { if (first_boot) {
e_printf("首次启动且未绑定，直接进入配网模式\r\n"); e_printf("首次启动且未绑定，启动产测监控并进入配网模式\r\n");
// 启动产测监控线程
start_factory_test_monitor();
// 同时进入配网模式
extern int g_config_key_id;
g_config_key_id = 0;
enter_config_mode(); enter_config_mode();
} else { } else {
e_printf("设备未绑定，等待按键触发配网\r\n"); e_printf("设备未绑定，等待按键触发配网\r\n");
@ -1002,8 +1008,8 @@ void set_device_mode(system_mode_t mode) {
if (g_runtime_state.mode != mode) { if (g_runtime_state.mode != mode) {
system_mode_t old_mode = g_runtime_state.mode; system_mode_t old_mode = g_runtime_state.mode;
g_runtime_state.mode = mode; g_runtime_state.mode = mode;
e_printf("[MODE] 设备模式切换: %s -> %s\r\n", e_printf("设备模式切换: %s -> %s\r\n",
get_mode_string(old_mode), get_mode_string(mode)); get_mode_string(old_mode), get_mode_string(mode));
} }
} }