diff --git a/application/samples/wifi/ohos_connect/hilink_adapt/entry/hilink_ble_main.c b/application/samples/wifi/ohos_connect/hilink_adapt/entry/hilink_ble_main.c index cb99e5b..82232c3 100755 --- a/application/samples/wifi/ohos_connect/hilink_adapt/entry/hilink_ble_main.c +++ b/application/samples/wifi/ohos_connect/hilink_adapt/entry/hilink_ble_main.c @@ -271,10 +271,12 @@ static void HILINK_BT_StateChangeHandler(HILINK_BT_SdkStatus event, const void * HILINK_SAL_ERROR("set addr err\n"); } /* 设置蓝牙广播格式，包括靠近发现、碰一碰等，下一次发送广播生效 */ - BLE_SetAdvType(BLE_ADV_LOCAL_NAME); + BLE_SetAdvType(BLE_ADV_NEARBY_V0); /* BLE配网广播控制：参数代表广播时间，0:停止；0xFFFFFFFF:一直广播，其他：广播指定时间后停止，单位秒 */ - (void)BLE_CfgNetAdvCtrl(ble_adv_time); + if(ble_adv_time) { + (void)BLE_CfgNetAdvCtrl(ble_adv_time); + } ble_sdk_running = 1; 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"); 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) { @@ -495,7 +497,7 @@ int hilink_ble_main(void) } /* 设置广播方式为靠近发现 */ - BLE_SetAdvType(BLE_ADV_LOCAL_NAME); + BLE_SetAdvType(BLE_ADV_NEARBY_V0); /* 初始化ble sdk */ ret = BLE_CfgNetInit(&g_bleInitParam, &g_bleCfgNetCb); diff --git a/application/samples/wifi/ohos_connect/hilink_adapt/product/hilink_device.c b/application/samples/wifi/ohos_connect/hilink_adapt/product/hilink_device.c index f62c153..3980e2f 100755 --- a/application/samples/wifi/ohos_connect/hilink_adapt/product/hilink_device.c +++ b/application/samples/wifi/ohos_connect/hilink_adapt/product/hilink_device.c @@ -19,9 +19,6 @@ #ifdef CONFIG_SUPPORT_HILINK_INDIE_UPGRADE #include "hilink_entry.h" #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" @@ -545,11 +542,11 @@ void HILINK_NotifyDevStatus(int status) break; case HILINK_DEVICE_UNREGISTER: /* 设备被解绑，请在此处添加实现 */ - handle_device_unbind(); + // handle_device_unbind(); break; case HILINK_REVOKE_FLAG_SET: /* 设备被复位标记置位，请在此处添加实现 */ - handle_device_unbind(); + // handle_device_unbind(); break; case HILINK_NEGO_REG_INFO_FAIL: /* 设备协商配网信息失败 */ diff --git a/application/ws63/user_main/switch_panel/switch_panel.h b/application/ws63/user_main/switch_panel/switch_panel.h index b312132..729da6b 100644 --- a/application/ws63/user_main/switch_panel/switch_panel.h +++ b/application/ws63/user_main/switch_panel/switch_panel.h @@ -173,6 +173,7 @@ extern osal_task *g_key_scan_task_handle; extern osal_task *g_config_task_handle; extern osal_task *g_save_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 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设备事件处理 void handle_device_online(void); diff --git a/application/ws63/user_main/switch_panel/switch_panel_ble.c b/application/ws63/user_main/switch_panel/switch_panel_ble.c index fcb3a99..77001cb 100755 --- a/application/ws63/user_main/switch_panel/switch_panel_ble.c +++ b/application/ws63/user_main/switch_panel/switch_panel_ble.c @@ -165,7 +165,7 @@ int switch_panel_ble_handle_custom_data(const char *buff, unsigned int len) { return -1; } - e_printf("[BLE] 接收到数据: %s (长度: %u)\r\n", buff, len); + e_printf("[BLE] 接收到数据: %s (len: %u)\r\n", buff, len); // 处理空JSON请求 - 上报全量状态 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"); // 处理特殊服务ID - if (strcmp(svc_id, "allservices") == 0) { + if (strcmp(svc_id, "allservices") == 0 || strcmp(svc_id, "getStateinfo") == 0) { // H5连接时的状态同步请求 e_printf("[BLE] H5连接，同步所有状态\r\n"); ble_report_all_switches(); diff --git a/application/ws63/user_main/switch_panel/switch_panel_config.c b/application/ws63/user_main/switch_panel/switch_panel_config.c index dfb2d41..a46bf67 100644 --- a/application/ws63/user_main/switch_panel/switch_panel_config.c +++ b/application/ws63/user_main/switch_panel/switch_panel_config.c @@ -37,6 +37,7 @@ static bool g_factory_test_running = false; static int g_factory_test_step = 0; static uint32_t g_factory_test_start_time = 0; static uint8_t g_wifi_state = WIFI_STA_SAMPLE_INIT; +static bool g_factory_test_monitor_running = false; //====================== WiFi事件回调函数 ====================== static void wifi_scan_state_changed(int32_t state, int32_t size) { @@ -169,10 +170,7 @@ static int factory_test_wifi_init(void) { } // 创建STA接口 - if (wifi_sta_enable() != 0) { - e_printf("%s WiFi STA启动失败\r\n", WIFI_STA_SAMPLE_LOG); - goto lab_err; - } + wifi_sta_enable(); e_printf("%s WiFi产测环境初始化完成\r\n", WIFI_STA_SAMPLE_LOG); return 0; @@ -184,11 +182,11 @@ lab_err: // 进入配网模式 void enter_config_mode(void) { if (g_runtime_state.mode == MODE_CONFIG) { - e_printf("[CONFIG] 已在配网模式中\r\n"); + e_printf("已在配网模式中\r\n"); return; } - e_printf("[CONFIG] 进入配网模式\r\n"); + e_printf("进入配网模式\r\n"); start_hilink_ble_net_config(CONFIG_TIMEOUT_MS/1000); // 更新设备模式 @@ -204,7 +202,7 @@ void enter_config_mode(void) { "config_task", TASK_STACK_SIZE); if (!g_config_task_handle) { - e_printf("[CONFIG] 创建配网任务失败\r\n"); + e_printf("创建配网任务失败\r\n"); return; } @@ -212,7 +210,7 @@ void enter_config_mode(void) { 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; } - 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) { 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_device_mode(MODE_NORMAL); - // 重置配网相关变量 g_config_key_id = -1; - - e_printf("[CONFIG] 已退出配网模式\r\n"); + e_printf("已退出配网模式\r\n"); } // 配网模式任务 int config_mode_task(void *arg) { (void)arg; - e_printf("[CONFIG] 配网任务开始\r\n"); + e_printf("配网任务开始\r\n"); // 记录配网开始时间 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; bool led_blink_state = false; uint32_t last_blink_time = 0; 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 elapsed_time = current_time - config_start_time; // 检查是否超时 (10分钟) if (elapsed_time >= CONFIG_TIMEOUT_MS) { - e_printf("[CONFIG] 配网超时，退出配网模式\r\n"); + e_printf("配网超时，退出配网模式\r\n"); break; } @@ -307,10 +295,8 @@ int config_mode_task(void *arg) { osal_msleep(100); } - e_printf("[CONFIG] 配网任务结束\r\n"); + e_printf("配网任务结束\r\n"); g_config_task_handle = NULL; - // 退出配网模式 - exit_config_mode(); return 0; } @@ -332,7 +318,7 @@ void panel_led_blink(void) { // 进入产测模式 void enter_factory_test_mode(void) { - e_printf("[FACTORY] 进入产测模式\r\n"); + e_printf("进入产测模式\r\n"); // 更新设备模式 set_device_mode(MODE_FACTORY_TEST); @@ -341,14 +327,11 @@ void enter_factory_test_mode(void) { g_factory_test_running = true; g_factory_test_step = 0; g_factory_test_start_time = hfsys_get_time(); - - // 开始产测序列 - factory_test_sequence(); } // 产测序列 void factory_test_sequence(void) { - e_printf("[FACTORY] 开始产测序列\r\n"); + e_printf("开始产测序列\r\n"); // 步骤1: 开始指示 - 交替闪烁白黄灯500ms for (int i = 0; i < 6; i++) { @@ -360,7 +343,7 @@ void factory_test_sequence(void) { // 步骤2-5: 单个开关测试 (开1->4, 每个1.5秒) 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黄灯 for (int i = 0; i < SWITCH_COUNT; i++) { @@ -377,7 +360,7 @@ void factory_test_sequence(void) { } // 步骤6: 全关 (1.5秒) - e_printf("[FACTORY] 测试全关\r\n"); + e_printf("测试全关\r\n"); for (int i = 0; i < SWITCH_COUNT; i++) { set_switch_output(i, false); set_led_output(i, LED_YELLOW); @@ -385,7 +368,7 @@ void factory_test_sequence(void) { osal_msleep(1500); // 步骤7: 全开 (1.5秒) - e_printf("[FACTORY] 测试全开\r\n"); + e_printf("测试全开\r\n"); for (int i = 0; i < SWITCH_COUNT; i++) { set_switch_output(i, true); set_led_output(i, LED_WHITE); @@ -393,28 +376,31 @@ void factory_test_sequence(void) { osal_msleep(1500); // 步骤8: 再次全关 - e_printf("[FACTORY] 结束测试 - 全关\r\n"); + e_printf("结束测试 - 全关\r\n"); for (int i = 0; i < SWITCH_COUNT; i++) { set_switch_output(i, false); set_led_output(i, LED_YELLOW); } - - // TODO: WiFi信号强度校验 - bool wifi_test_pass = check_factory_test_wifi(); - + + osal_msleep(1500); + // 步骤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) { - e_printf("[FACTORY] 产测全部通过\r\n"); + e_printf("产测全部通过\r\n"); // 所有开关开启表示通过 for (int i = 0; i < SWITCH_COUNT; i++) { - set_switch_output(i, true); - set_led_output(i, LED_WHITE); + set_switch_output(i, false); + set_led_output(i, LED_YELLOW); } } else { - e_printf("[FACTORY] 产测失败\r\n"); + e_printf("产测失败\r\n"); // 所有开关关闭表示失败 for (int i = 0; i < SWITCH_COUNT; i++) { - set_switch_output(i, false); set_led_output(i, LED_YELLOW); } } @@ -425,12 +411,12 @@ void factory_test_sequence(void) { // 恢复设备默认状态 sync_hardware_state(); - - e_printf("[FACTORY] 产测序列完成\r\n"); + wifi_unregister_event_cb(&wifi_event_cb); + e_printf("产测序列完成\r\n"); } // 检查产测热点 -bool check_factory_test_wifi(void) { +bool check_factory_test_wifi(int32_t rssi_threshold) { // 使用WiFi扫描功能检测产测热点 "ShuorongSelfTest" // 并校验信号强度 >= -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", WIFI_STA_SAMPLE_LOG, FACTORY_TEST_SSID); return true; @@ -458,3 +444,104 @@ bool check_factory_test_wifi(void) { 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"); +} + diff --git a/application/ws63/user_main/switch_panel/switch_panel_hilink.c b/application/ws63/user_main/switch_panel/switch_panel_hilink.c index 5245662..d314312 100644 --- a/application/ws63/user_main/switch_panel/switch_panel_hilink.c +++ b/application/ws63/user_main/switch_panel/switch_panel_hilink.c @@ -17,6 +17,9 @@ static int handle_put_switch_common(int switch_id, const char* svc_id, void handle_device_online(void) { e_printf("设备上线\r\n"); + // 检查是否是新绑定的设备 + bool was_unbound = !g_persistent_state.is_bound; + // 更新设备绑定状态 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); switch_panel_ble_disable(); @@ -64,12 +83,14 @@ void handle_device_unbind(void) { // 重置为出厂默认状态 reset_persistent_state(); g_persistent_state.is_bound = false; // 保持未绑定状态 - + g_persistent_state.is_first_boot = false; // 标记为非出厂模式 + // 同步硬件状态 sync_hardware_state(); // 保存状态 save_persistent_state(); + // HILINK_RestoreFactorySettings(); e_printf("设备已重置为出厂默认状态\r\n"); } diff --git a/application/ws63/user_main/switch_panel/switch_panel_keys.c b/application/ws63/user_main/switch_panel/switch_panel_keys.c index 2b87771..03e3d6f 100644 --- a/application/ws63/user_main/switch_panel/switch_panel_keys.c +++ b/application/ws63/user_main/switch_panel/switch_panel_keys.c @@ -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; } + // 如果设备未绑定，记录状态变化以便调试 + if (!g_persistent_state.is_bound) { + e_printf("设备未绑定，允许自由控制开关%d\r\n", switch_id + 1); + } + // 更新开关状态 if (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) { + // 如果设备未绑定，总开关不影响子开关控制 + if (!g_persistent_state.is_bound) { + e_printf("设备未绑定，总开关不影响子开关控制\r\n"); + return; + } + if (!g_persistent_state.master_switch) { - // 总开关关闭时，强制关闭所有子开关 - e_printf("总开关关闭，强制关闭所有子开关\r\n"); + // 设备已绑定且总开关关闭时，强制关闭所有子开关 + e_printf("设备已绑定且总开关关闭，强制关闭所有子开关\r\n"); 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); // } } - // 立即保存状态 - save_persistent_state(); - // 同步所有子开关状态到云端 if (g_persistent_state.is_bound) { fast_report_all_switches_async(); @@ -109,7 +118,7 @@ void apply_master_switch_control(void) { int key_scan_task(void *arg) { (void)arg; - e_printf("[KEY] 按键扫描任务开始\r\n"); + e_printf("按键扫描任务开始\r\n"); // 按键状态记录 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]; } - while (!osal_kthread_should_stop()) { + while (1) { uint32_t current_time = hfsys_get_time(); // 扫描所有按键 for (int i = 0; i < SWITCH_COUNT; i++) { bool new_raw_state = get_key_input(i); // 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]) { @@ -154,7 +163,7 @@ int key_scan_task(void *arg) { // 按键按下 press_start_time[i] = current_time; is_long_press_handled[i] = false; - e_printf("[KEY] 按键%d 按下\r\n", i + 1); + e_printf("按键%d 按下\r\n", i + 1); } else { // 按键松开 uint32_t press_duration = current_time - press_start_time[i]; @@ -168,7 +177,7 @@ int key_scan_task(void *arg) { 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扫描间隔，提高响应性 } - e_printf("[KEY] 按键扫描任务退出\r\n"); + e_printf("按键扫描任务退出\r\n"); return 0; } @@ -201,17 +210,17 @@ void handle_key_press(int key_id) { 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) { - e_printf("[KEY] 配网模式下，忽略短按事件\r\n"); + e_printf("配网模式下，忽略短按事件\r\n"); return; } // 在产测模式下，忽略短按事件 if (g_runtime_state.mode == MODE_FACTORY_TEST) { - e_printf("[KEY] 产测模式下，忽略短按事件\r\n"); + e_printf("产测模式下，忽略短按事件\r\n"); return; } @@ -226,11 +235,11 @@ void handle_key_long_press(int key_id) { return; } - e_printf("[KEY] 处理按键%d 长按事件\r\n", key_id + 1); + e_printf("处理按键%d 长按事件\r\n", key_id + 1); // 只有第一个按键支持长按进入配网模式 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) { @@ -239,13 +248,13 @@ void handle_key_long_press(int key_id) { enter_config_mode(); } else { if (g_persistent_state.is_bound) { - e_printf("[KEY] 设备已绑定，不能进入配网模式\r\n"); + e_printf("设备已绑定，不能进入配网模式\r\n"); } else { - e_printf("[KEY] 非正常模式，不能进入配网模式\r\n"); + e_printf("非正常模式，不能进入配网模式\r\n"); } } } else { - e_printf("[KEY] 非第一个按键的长按，忽略\r\n"); + e_printf("非第一个按键的长按，忽略\r\n"); } } @@ -266,17 +275,17 @@ int key_system_init(void) { "key_scan", TASK_STACK_SIZE); if (!g_key_scan_task_handle) { - e_printf("[KEY] 创建按键扫描任务失败\r\n"); + e_printf("创建按键扫描任务失败\r\n"); return HF_FAIL; } // 设置任务优先级 ret = osal_kthread_set_priority(g_key_scan_task_handle, TASK_PRIORITY_HIGH); 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; } diff --git a/application/ws63/user_main/switch_panel/switch_panel_main.c b/application/ws63/user_main/switch_panel/switch_panel_main.c index 274da83..05029f8 100644 --- a/application/ws63/user_main/switch_panel/switch_panel_main.c +++ b/application/ws63/user_main/switch_panel/switch_panel_main.c @@ -44,6 +44,7 @@ osal_task *g_key_scan_task_handle = NULL; osal_task *g_config_task_handle = NULL; osal_task *g_save_task_handle = NULL; // 异步保存任务句柄 osal_task *g_report_task_handle = NULL; // 异步上报任务句柄 +osal_task *g_factory_test_task_handle = NULL; // 产测任务句柄 static bool g_initialized = false; static uint32_t g_config_start_time = 0; @@ -79,7 +80,7 @@ int async_report_task(void *arg) { // 引用外部的fast_report函数 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 (!g_report_system_running) { @@ -407,7 +408,7 @@ static int save_data_task(void *arg) { 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 (!g_save_system_running) { @@ -590,7 +591,7 @@ void reset_persistent_state(void) { g_persistent_state.magic = DEVICE_DATA_MAGIC; 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; } - e_printf("[STATE] 运行时状态已初始化\r\n"); + e_printf("运行时状态已初始化\r\n"); } //====================== GPIO配置数据结构 ====================== @@ -627,25 +628,25 @@ typedef struct { // GPIO初始化配置表 static const gpio_config_t gpio_configs[] = { // 开关控制 - 输出 - {SWITCH1_GPIO, PIN_MODE_1, 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"}, - {SWITCH3_GPIO, PIN_MODE_1, 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"}, + {SWITCH1_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH1"}, + {SWITCH2_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH2"}, + {SWITCH3_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "SWITCH3"}, + {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"}, - {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"}, {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指示灯 - 输出 - {LED1_GPIO, PIN_MODE_1, 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"}, - {LED3_GPIO, PIN_MODE_1, 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"}, + {LED1_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED1"}, + {LED2_GPIO, PIN_MODE_0, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED2"}, + {LED3_GPIO, PIN_MODE_4, PIN_PULL_TYPE_DOWN, PIN_DS_7, GPIO_DIRECTION_OUTPUT, "LED3"}, + {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模式 ret = uapi_pin_set_mode(config->pin, config->mode); 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; } ret = uapi_pin_set_pull(config->pin, config->pull); 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; } ret = uapi_pin_set_ds(config->pin, config->ds); 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; } // 设置GPIO方向 ret = uapi_gpio_set_dir(config->pin, config->direction); 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; } - e_printf("[GPIO] %s 初始化完成 (方向: %s)\r\n", + e_printf("%s 初始化完成 (方向: %s)\r\n", config->name, 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; } // 设置开关输出状态 void set_switch_output(int switch_id, bool state) { 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; } @@ -717,13 +718,13 @@ void set_switch_output(int switch_id, bool state) { // 设置输出状态 gpio_level_t level = state ? GPIO_LEVEL_HIGH : GPIO_LEVEL_LOW; 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 指示灯状态 void set_led_output(int led_id, led_state_t state) { 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; } @@ -781,7 +782,7 @@ void sync_hardware_state(void) { // 同步面板背光状态 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(); // 配网逻辑： - // 1. 如果设备未绑定 且 是第一次启动 -> 直接进入配网 + // 1. 如果设备未绑定 且 是第一次启动 -> 启动产测监控并进入配网 // 2. 如果设备未绑定 且 不是第一次启动 -> 等待按键触发配网 if (!g_persistent_state.is_bound) { 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(); } else { e_printf("设备未绑定，等待按键触发配网\r\n"); @@ -1002,8 +1008,8 @@ void set_device_mode(system_mode_t mode) { if (g_runtime_state.mode != mode) { system_mode_t old_mode = g_runtime_state.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)); } } \ No newline at end of file