[WiFi][Shell] Wifi Shell updates to improve shell commands. (project-…

…chip#31684)

* [WiFi][Shell] Wifi Shell updates to improve shell commands.

- "wifi connect" command was improved to work with credentials entered from shell
- "wifi disconnect" command was created to disconnect from connected WiFi network

* [NXP][platform][common] Update RemoveNetwork and Disconnect functions and enable CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION for all NXP WiFi platforms

* Restyled by clang-format

---------

Co-authored-by: Restyled.io <commits@restyled.io>

examples/platform/nxp/common/app_task/source/AppTaskBase.cpp

@@ -62,6 +62,10 @@
 #include <app/clusters/ota-requestor/OTATestEventTriggerDelegate.h>
 #endif
 
+#ifdef ENABLE_CHIP_SHELL
+#include <lib/shell/commands/WiFi.h>
+#endif
+
 using namespace chip;
 using namespace chip::TLV;
 using namespace ::chip::Credentials;
@@ -202,6 +206,9 @@ CHIP_ERROR chip::NXP::App::AppTaskBase::Init()
 
 #if CONFIG_CHIP_WIFI || CHIP_DEVICE_CONFIG_ENABLE_WPA
  sNetworkCommissioningInstance.Init();
+#ifdef ENABLE_CHIP_SHELL
+ Shell::SetWiFiDriver(chip::NXP::App::GetAppTask().GetWifiDriverInstance());
+#endif
 #endif
 #if CONFIG_CHIP_OTA_REQUESTOR
  if (err == CHIP_NO_ERROR)

src/include/platform/ConnectivityManager.h

@@ -182,6 +182,7 @@ class ConnectivityManager
  void MaintainOnDemandWiFiAP();
  System::Clock::Timeout GetWiFiAPIdleTimeout();
  void SetWiFiAPIdleTimeout(System::Clock::Timeout val);
+ CHIP_ERROR DisconnectNetwork();
 
  // Thread Methods
  bool IsThreadEnabled();
@@ -560,5 +561,10 @@ inline void ConnectivityManager::OnWiFiStationProvisionChange()
  static_cast<ImplClass *>(this)->_OnWiFiStationProvisionChange();
 }
 
+inline CHIP_ERROR ConnectivityManager::DisconnectNetwork()
+{
+ return static_cast<ImplClass *>(this)->_DisconnectNetwork();
+}
+
 } // namespace DeviceLayer
 } // namespace chip

src/include/platform/internal/GenericConnectivityManagerImpl.h

@@ -46,6 +46,7 @@ class GenericConnectivityManagerImpl
  void _SetUserSelectedMode(bool val);
  uint16_t _GetUserSelectedModeTimeout();
  void _SetUserSelectedModeTimeout(uint16_t val);
+ CHIP_ERROR _DisconnectNetwork();
 
 private:
  ImplClass * Impl() { return static_cast<ImplClass *>(this); }
@@ -71,6 +72,12 @@ template <class ImplClass>
 inline void GenericConnectivityManagerImpl<ImplClass>::_SetUserSelectedModeTimeout(uint16_t val)
 {}
 
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl<ImplClass>::_DisconnectNetwork()
+{
+ return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+}
+
 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace chip

src/lib/shell/commands/BUILD.gn

@@ -36,7 +36,10 @@ source_set("commands") {
  }
 
  if (chip_enable_wifi) {
- sources += [ "WiFi.cpp" ]
+ sources += [
+ "WiFi.cpp",
+ "WiFi.h",
+ ]
  }
 
  if (chip_enable_ble && chip_device_platform != "none") {

src/lib/shell/commands/WiFi.cpp

@@ -18,17 +18,22 @@
 #include <lib/shell/Commands.h>
 #include <lib/shell/Engine.h>
 #include <lib/shell/commands/Help.h>
+#include <lib/shell/commands/WiFi.h>
 #include <lib/shell/streamer.h>
+#include <lib/support/Span.h>
 #include <platform/CHIPDeviceLayer.h>
 #include <platform/ConnectivityManager.h>
+#include <platform/NetworkCommissioning.h>
 
 using chip::DeviceLayer::ConnectivityManager;
 using chip::DeviceLayer::ConnectivityMgr;
+using namespace chip::DeviceLayer::NetworkCommissioning;
 
 namespace chip {
 namespace Shell {
 
-static chip::Shell::Engine sShellWiFiSubCommands;
+static Shell::Engine sShellWiFiSubCommands;
+static DeviceLayer::NetworkCommissioning::WiFiDriver * sDriver;
 
 static CHIP_ERROR WiFiHelpHandler(int argc, char ** argv)
 {
@@ -104,13 +109,38 @@ static CHIP_ERROR WiFiModeHandler(int argc, char ** argv)
 
 static CHIP_ERROR WiFiConnectHandler(int argc, char ** argv)
 {
- if (argc != 2)
- {
- return CHIP_ERROR_INVALID_ARGUMENT;
- }
+ CHIP_ERROR error = CHIP_NO_ERROR;
+ uint8_t networkIndex;
+ char debugBuffer[CHIP_CONFIG_NETWORK_COMMISSIONING_DEBUG_TEXT_BUFFER_SIZE];
+ MutableCharSpan debugText(debugBuffer);
+
+ VerifyOrReturnError(GetWiFiDriver() != nullptr, CHIP_ERROR_NOT_IMPLEMENTED);
+
+ /* Command accepts running with SSID and password as parameters */
+ VerifyOrReturnError((argc == 2), CHIP_ERROR_INVALID_ARGUMENT);
+
+ ByteSpan ssidSpan = ByteSpan(Uint8::from_const_char(argv[0]), strlen(argv[0]));
+ ByteSpan passwordSpan = ByteSpan(Uint8::from_const_char(argv[1]), strlen(argv[1]));
+
+ VerifyOrReturnError(IsSpanUsable(ssidSpan) && IsSpanUsable(passwordSpan), CHIP_ERROR_INVALID_ARGUMENT);
+
+ ChipLogProgress(Shell, "Adding/Updating network %s", argv[0]);
+
+ /* AddOrUpdateNetwork() checks ssid length and password length. The network info is not persistent. */
+ GetWiFiDriver()->AddOrUpdateNetwork(ssidSpan, passwordSpan, debugText, networkIndex);
+
+ ChipLogProgress(Shell, "Connecting to network");
+ /* Connection event will be returned in OnWiFiConnectivityChange from DeviceCallbacks.cpp */
+ GetWiFiDriver()->ConnectNetwork(ssidSpan, nullptr);
 
- // TODO:Provision WiFi using WirelessDriver
- return CHIP_ERROR_NOT_IMPLEMENTED;
+ return error;
+}
+
+static CHIP_ERROR WiFiDisconnectHandler(int argc, char ** argv)
+{
+ VerifyOrReturnError((argc == 0), CHIP_ERROR_INVALID_ARGUMENT);
+
+ return ConnectivityMgr().DisconnectNetwork();
 }
 
 static CHIP_ERROR WiFiDispatch(int argc, char ** argv)
@@ -122,13 +152,24 @@ static CHIP_ERROR WiFiDispatch(int argc, char ** argv)
  return sShellWiFiSubCommands.ExecCommand(argc, argv);
 }
 
+void SetWiFiDriver(WiFiDriver * driver)
+{
+ sDriver = driver;
+}
+
+WiFiDriver * GetWiFiDriver()
+{
+ return sDriver;
+}
+
 void RegisterWiFiCommands()
 {
  /// Subcommands for root command: `device <subcommand>`
  static const shell_command_t sWiFiSubCommands[] = {
  { &WiFiHelpHandler, "help", "" },
- { &WiFiModeHandler, "mode", "Get/Set wifi mode. Usage: wifi mode [disable|ap|sta]." },
- { &WiFiConnectHandler, "connect", "Connect to AP. Usage: wifi connect ssid psk." },
+ { &WiFiModeHandler, "mode", "Get/Set wifi mode. Usage: wifi mode [disable|ap|sta]" },
+ { &WiFiConnectHandler, "connect", "Connect to AP. Usage: wifi connect <ssid> <psk>" },
+ { &WiFiDisconnectHandler, "disconnect", "Disconnect device from AP. Usage: wifi disconnect" },
  };
  static const shell_command_t sWiFiCommand = { &WiFiDispatch, "wifi", "Usage: wifi <subcommand>" };
 

src/lib/shell/commands/WiFi.h

@@ -0,0 +1,35 @@
+/*
+ *
+ * Copyright (c) 2024 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file
+ * Header that defines default shell commands for CHIP examples
+ */
+
+#pragma once
+
+#include <lib/shell/Engine.h>
+#include <platform/NetworkCommissioning.h>
+
+namespace chip {
+namespace Shell {
+
+void SetWiFiDriver(DeviceLayer::NetworkCommissioning::WiFiDriver * driver);
+DeviceLayer::NetworkCommissioning::WiFiDriver * GetWiFiDriver();
+
+} // namespace Shell
+} // namespace chip

src/platform/nxp/common/ConnectivityManagerImpl.cpp

@@ -590,6 +590,34 @@ void ConnectivityManagerImpl::ConnectNetworkTimerHandler(::chip::System::Layer *
  PlatformMgr().UnlockChipStack();
  }
 }
+
+/* Can be used to disconnect from WiFi network.
+ */
+CHIP_ERROR ConnectivityManagerImpl::_DisconnectNetwork(void)
+{
+ int ret = 0;
+ CHIP_ERROR err = CHIP_NO_ERROR;
+
+ if (ConnectivityMgrImpl().IsWiFiStationConnected())
+ {
+ ChipLogProgress(NetworkProvisioning, "Disconnecting from WiFi network.");
+
+ ret = wlan_disconnect();
+
+ if (ret != WM_SUCCESS)
+ {
+ ChipLogError(NetworkProvisioning, "Failed to disconnect from network with error: %u", (uint8_t) ret);
+ err = CHIP_ERROR_UNEXPECTED_EVENT;
+ }
+ }
+ else
+ {
+ ChipLogError(NetworkProvisioning, "Error: WiFi not connected!");
+ err = CHIP_ERROR_INCORRECT_STATE;
+ }
+
+ return err;
+}
 #endif
 
 } // namespace DeviceLayer

src/platform/nxp/common/ConnectivityManagerImpl.h

@@ -115,6 +115,7 @@ class ConnectivityManagerImpl final : public ConnectivityManager,
  bool _IsWiFiStationEnabled();
  bool _IsWiFiStationConnected();
  bool _IsWiFiStationApplicationControlled();
+ CHIP_ERROR _DisconnectNetwork(void);
 #endif /* CHIP_DEVICE_CONFIG_ENABLE_WPA */
 
  // ===== Members for internal use by the following friends.

src/platform/nxp/common/NetworkCommissioningDriver.h

@@ -72,10 +72,6 @@ class NXPWiFiDriver final : public WiFiDriver
  Status ReorderNetwork(ByteSpan networkId, uint8_t index, MutableCharSpan & outDebugText) override;
  void ConnectNetwork(ByteSpan networkId, ConnectCallback * callback) override;
 
- /* Can be used to disconnect from WiFi network.
- */
- int DisconnectNetwork();
-
  /* Returns the network SSID. User needs to allocate a buffer of size >= DeviceLayer::Internal::kMaxWiFiSSIDLength.
  * ssid - pointer to the returned SSID
  */

src/platform/nxp/common/NetworkCommissioningWiFiDriver.cpp

@@ -142,14 +142,39 @@ Status NXPWiFiDriver::AddOrUpdateNetwork(ByteSpan ssid, ByteSpan credentials, Mu
 
 Status NXPWiFiDriver::RemoveNetwork(ByteSpan networkId, MutableCharSpan & outDebugText, uint8_t & outNetworkIndex)
 {
+ int err_code = 0;
+
  outDebugText.reduce_size(0);
  outNetworkIndex = 0;
  VerifyOrReturnError(NetworkMatch(mStagingNetwork, networkId), Status::kNetworkIDNotFound);
 
- // Use empty ssid for representing invalid network
- mStagingNetwork.ssidLen = 0;
- memset(mStagingNetwork.ssid, 0, DeviceLayer::Internal::kMaxWiFiSSIDLength);
- memset(mStagingNetwork.credentials, 0, DeviceLayer::Internal::kMaxWiFiKeyLength);
+ err_code = wlan_remove_network((char *) networkId.data());
+
+ switch (err_code)
+ {
+ case -WM_E_INVAL:
+ ChipLogError(DeviceLayer, "Error: Network not found");
+ break;
+
+ case WM_SUCCESS:
+ /* Use empty ssid for representing invalid network */
+ mStagingNetwork.ssidLen = 0;
+ memset(mStagingNetwork.ssid, 0, DeviceLayer::Internal::kMaxWiFiSSIDLength);
+ memset(mStagingNetwork.credentials, 0, DeviceLayer::Internal::kMaxWiFiKeyLength);
+ /* Save to persistent memory */
+ CommitConfiguration();
+ ChipLogProgress(DeviceLayer, "Successfully removed network");
+ break;
+
+ case WLAN_ERROR_STATE:
+ ChipLogError(DeviceLayer, "Error: Can't remove network in this state");
+ break;
+
+ default:
+ ChipLogError(DeviceLayer, "Error: Unable to remove network");
+ break;
+ }
+
  return Status::kSuccess;
 }
 
@@ -238,29 +263,6 @@ void NXPWiFiDriver::ConnectNetwork(ByteSpan networkId, ConnectCallback * callbac
  }
 }
 
-int NXPWiFiDriver::DisconnectNetwork(void)
-{
- int ret = 0;
-
- if (ConnectivityMgrImpl().IsWiFiStationConnected())
- {
- ChipLogProgress(NetworkProvisioning, "Disconnecting from WiFi network.");
-
- ret = wlan_disconnect();
-
- if (ret != WM_SUCCESS)
- {
- ChipLogError(NetworkProvisioning, "Failed to disconnect from network with error: %u", (uint8_t) ret);
- }
- }
- else
- {
- ChipLogError(NetworkProvisioning, "Error: WiFi not connected!");
- }
-
- return ret;
-}
-
 CHIP_ERROR NXPWiFiDriver::StartScanWiFiNetworks(ByteSpan ssid)
 {
  wlan_scan_params_v2_t wlan_scan_param;

third_party/nxp/rt_sdk/rt_sdk.gni

@@ -562,11 +562,7 @@ template("rt_sdk") {
  }
 
  if (chip_enable_wifi) {
- if (!w8801_transceiver) {
- defines += [ "CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION=1" ]
- } else {
- defines += [ "CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION=0" ]
- }
+ defines += [ "CHIP_DEVICE_CONFIG_ENABLE_WIFI_STATION=1" ]
  }
 
  # Now add our "system-header" include dirs