support network interface for haaseduk1 #1642 (#1667)

* support network interface for haaseduk1 #1642
Co-authored-by: NskylarCai <75605680+skylarCai@users.noreply.github.com>

components/amp_adapter/include/aos_log.h

+/*
+ * Copyright (C) 2015-2020 Alibaba Group Holding Limited
+ */
+
+#ifndef AOS_LOG_H
+#define AOS_LOG_H
+
+#include <stdarg.h>
+#include <string.h>
+
+typedef enum {
+    AOS_LOG_NONE,   /* disable log */
+    AOS_LOG_FATAL,  /* fatal log will output */
+    AOS_LOG_ERROR,  /* fatal + error log will output */
+    AOS_LOG_WARN,   /* fatal + warn + error log will output(default level) */
+    AOS_LOG_INFO,   /* info + warn + error log will output */
+    AOS_LOG_DEBUG,  /* debug + info + warn + error + fatal log will output */
+    AOS_LOG_VERBOSE,
+} haas_log_level_t;
+
+/**
+ * Function prototype for syncronized log text, Recommed using below brief API LOGX instead of this.
+ *
+ * @param[in]  s         Serverity of Log
+ * @param[in]  tag       Usually File name
+ * @param[in]  fmt, ...  Variable Parameter, support format print to log
+ *
+ * @return  0 on success, negative error on failure.
+ */
+int  aos_log(const unsigned char s, const char *tag, const char *fmt, ...);
+
+
+/**
+ * Set the log level.
+ *
+ * @param[in]  log_level  level to be set,must be one of AOS_LL_NONE,AOS_LL_FATAL,
+ * AOS_LL_ERROR,AOS_LL_WARN,AOS_LL_INFO or AOS_LL_DEBUG.
+ *
+ * @return  0 on success, negative error on failure.
+ */
+int  aos_log_set_level(haas_log_level_t log_level);
+
+
+#define AOS_LOGF(tag, ...)  aos_log(AOS_LOG_FATAL, tag, __VA_ARGS__)
+
+#define AOS_LOGE(tag, ...)  aos_log(AOS_LOG_ERROR, tag, __VA_ARGS__)
+
+#define AOS_LOGW(tag, ...)  aos_log(AOS_LOG_WARN, tag, __VA_ARGS__)
+
+#define AOS_LOGI(tag, ...)  aos_log(AOS_LOG_INFO, tag, __VA_ARGS__)
+
+#define AOS_LOGD(tag, ...)  aos_log(AOS_LOG_DEBUG, tag, __VA_ARGS__)
+
+#define AOS_LOGV(tag, ...)  aos_log(AOS_LOG_VERBOSE, tag, __VA_ARGS__)
+
+
+#endif /* AOS_LOG_H */
+

components/amp_adapter/include/aos_network.h

@@ -2,13 +2,57 @@
  * Copyright (C) 2015-2020 Alibaba Group Holding Limited
  */
 
+#ifndef AOS_NETWORK_H
+#define AOS_NETWORK_H
+
+#include <stdbool.h>
 #ifndef _AOS_NETWORK_H_
 #define _AOS_NETWORK_H_
 #define SCANNED_WIFI_COUNT_MAX 32
 #define SCANNED_LOCATOR_COUNT_MAX 32
+typedef enum {
+    AOS_ERR_WIFI_BASE = 0x3000,         /*!< WiFi ERR NUM BASE */
+    AOS_ERR_WIFI_NOT_INIT,              /*!< WiFi driver was not installed by esp_wifi_init */
+    AOS_ERR_WIFI_NOT_STARTED,           /*!< WiFi driver was not started by esp_wifi_start */
+    AOS_ERR_WIFI_NOT_STOPPED,           /*!< WiFi driver was not stopped by esp_wifi_stop */
+    AOS_ERR_WIFI_IF,                    /*!< WiFi interface error */
+    AOS_ERR_WIFI_MODE,                  /*!< WiFi mode error */
+    AOS_ERR_WIFI_STATE,                 /*!< WiFi internal state error */
+    AOS_ERR_WIFI_CONN,                  /*!< WiFi internal control block of station or soft-AP error */
+    AOS_ERR_WIFI_NVS,                   /*!< WiFi internal NVS module error */
+    AOS_ERR_WIFI_MAC,                   /*!< MAC address is invalid */
+    AOS_ERR_WIFI_SSID,                  /*!< SSID is invalid */
+    AOS_ERR_WIFI_PASSWORD,              /*!< Password is invalid */
+    AOS_ERR_WIFI_TIMEOUT,               /*!< Timeout error */
+    AOS_ERR_WIFI_WAKE_FAIL,             /*!< WiFi is in sleep state(RF closed) and wakeup fail */
+    AOS_ERR_WIFI_WOULD_BLOCK,           /*!< The caller would block */
+    AOS_ERR_WIFI_NOT_CONNECT,           /*!< Station still in disconnect status */
+    AOS_ERR_WIFI_POST,                  /*!< Failed to post the event to WiFi task */
+    AOS_ERR_WIFI_INIT_STATE,            /*!< Invalod WiFi state when init/deinit is called */
+    AOS_ERR_WIFI_STOP_STATE,            /*!< Returned when WiFi is stopping */
+    AOS_ERR_WIFI_NOT_ASSOC,             /*!< The WiFi connection is not associated */
+    AOS_ERR_WIFI_TX_DISALLOW,           /*!< The WiFi TX is disallowed */
+    AOS_ERR_TCPIP_ADAPTER_INVALID_PARAMS,
+    AOS_ERR_TCPIP_ADAPTER_IF_NOT_READY,
+    AOS_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED,
+    AOS_ERR_TCPIP_ADAPTER_NO_MEM
+} AOS_NETWORK_ERR_E;
+
+typedef enum {
+    AOS_NET_NOINIT = 0,
+    AOS_NET_STA_STARTED,
+    AOS_NET_STA_GOT_IP,
+    AOS_NET_STA_LOST_IP,
+    AOS_NET_STA_DISCONNECTED,
+    AOS_NET_STA_CONNECTED,
+    AOS_NET_STA_STOPED,
+    AOS_NET_STATE_UNKNOWN
+} AOS_NETWORK_STATE_E;
 
 typedef enum {
     AOS_NETWORK_WIFI,
+    AOS_NETWORK_WIFI_STA,
+    AOS_NETWORK_WIFI_AP,
     AOS_NETWORK_CELLULAR,
     AOS_NETWORK_ETHERNET,
     AOS_NETWORK_UNKNOW,
@@ -35,6 +79,14 @@ typedef enum {
     AOS_NETWORK_SHAREMODE_AUTHTYPE_INVALID
 } AOS_NETWORK_SHAREMODE_AUTHTYPE_E;
 
+typedef struct {
+    void (*cb)(int status, void *);
+    int wifi_state;
+    int wifi_mode;
+    bool is_initialized;
+    bool is_started;
+} aos_wifi_manager_t;
+
 typedef struct aos_sim_info {
     char imsi[32];
     char imei[32];
@@ -61,6 +113,19 @@ typedef struct aos_wifi_info {
     int rssi;
 } aos_wifi_info_t;
 
+
+/** @brief  network ifconfig type */
+#define IPADDR_STR_LEN 16
+typedef struct aos_ifconfig_info {
+   bool dhcp_en;                         /**< dhcp is enabled */
+   char ip_addr[IPADDR_STR_LEN];         /**< ip address */
+   char mask[IPADDR_STR_LEN];            /**< ip address mask */
+   char gw[IPADDR_STR_LEN];              /**< gateway ip address */
+   char dns_server[IPADDR_STR_LEN];      /**< dns server address */
+   char mac[IPADDR_STR_LEN + 2];         /**< mac address */
+   int  rssi;                            /**< rssi */
+} aos_ifconfig_info_t;
+
 typedef struct aos_scanned_wifi_info {
     int num;
     aos_wifi_info_t wifi_info[SCANNED_WIFI_COUNT_MAX];
@@ -76,41 +141,25 @@ typedef struct aos_sharemode_info {
     AOS_NETWORK_SHAREMODE_E share_mode;
 } aos_sharemode_info_t;
 
-/**
- * @brief       file close
- *
- * @param[out]  ip: ip pointer
- *
- * @return      0: success, -1: failed
- */
-int aos_wifi_init();
+int aos_wifi_init(aos_wifi_manager_t *wifi_manager);
+
+int aos_wifi_start(aos_wifi_manager_t *wifi_manager);
 
-/**
- * @brief       file close
- *
- * @param[out]  ip: ip pointer
- *
- * @return      0: success, -1: failed
- */
 int aos_wifi_connect(const char *ssid, const char *passwd);
 
-/**
- * @brief       file close
- *
- * @param[out]  ip: ip pointer
- *
- * @return      0: success, -1: failed
- */
+int aos_wifi_stop(aos_wifi_manager_t *wifi_manager);
+
 int aos_wifi_disconnect();
 
-/**
- * @brief       file close
- *
- * @param[out]  ip: ip pointer
- *
- * @return      0: success, -1: failed
- */
-int aos_get_wifi_info(aos_wifi_info_t *wifi_info);
+int aos_wifi_get_info(aos_wifi_info_t *wifi_info);
+
+int aos_wifi_get_state();
+
+int aos_wifi_deinit(aos_wifi_manager_t *wifi_manager);
+
+int aos_net_set_ifconfig(aos_ifconfig_info_t *info);
+
+int aos_net_get_ifconfig(aos_ifconfig_info_t *info);
 
 /**
  * @brief       file close
@@ -198,3 +247,4 @@ int aos_location_scaned_wifi_info(aos_scanned_wifi_info_t *scaned_wifi);
 
 #endif /* _AOS_NETWORK_H_ */
 
+#endif

components/amp_adapter/include/aos_system.h

@@ -76,33 +76,6 @@ const char *aos_get_device_name(void);
  */
 int aos_system_sleep(void);
 
-/**
- * @brief   get RTOS default priority
- *
- * @return  default priority
- */
-int aos_get_wireless_info(struct _amp_wireless_info_t *info);
-
-/**
- * @brief   get RTOS default priority
- *
- * @return  default priority
- */
-int aos_get_network_status(void);
-
-/**
- * @brief   get RTOS default priority
- *
- * @return  default priority
- */
-int aos_get_ip(char *ip);
-
-/**
- * @brief   get RTOS default priority
- *
- * @return  default priority
- */
-int aos_get_mac_addr(unsigned char mac[6]);
 
 /**
  * @brief   get RTOS default priority

components/amp_adapter/package.yaml

@@ -67,7 +67,6 @@ source_file:
   - platform/aos/haas200/amp_ota_port.c ? <BOARD_HAAS200>
   - platform/aos/haaseduk1/amp_ota_port.c ? <BOARD_HAASEDUK1>
   - platform/aos/aos_system.c ? <!ESP_PLATFORM>
-  - platform/aos/app_ota.c ? <!ESP_PLATFORM>
   - platform/aos/network/*.c ? <!ESP_PLATFORM>
   - platform/aos/peripheral/*.c     ? <!ESP_PLATFORM>
   - platform/esp_idf/*.c ? <ESP_PLATFORM>

components/amp_adapter/platform/aos/aos_log.c

+#include "aos_log.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "ulog/ulog.h"
+#include "aos/kernel.h"
+#include "aos/errno.h"
+
+static int local_log_level = AOS_LOG_VERBOSE;
+
+int  aos_log(const unsigned char s, const char *tag, const char *fmt, ...)
+{
+    if (s > local_log_level) {
+        return 0;
+    }
+
+    va_list list;
+    va_start(list, fmt);
+    ulog(s, "AOS", tag, 0, fmt, list);
+    va_end(list);
+
+    return 0;
+}
+
+int  aos_log_set_level(haas_log_level_t log_level)
+{
+    local_log_level = log_level;
+
+    aos_set_log_level(log_level);
+}

components/amp_adapter/platform/aos/aos_system.c

@@ -81,54 +81,12 @@ const char *aos_get_platform_type(void)
     return _SYSINFO_DEVICE_NAME;
 }
 
-int aos_get_ip(char *ip)
-{
-#ifndef AOS_BOARD_HAAS700
-    netmgr_hdl_t hdl;
-    netmgr_ifconfig_info_t info = {0};
-
-    hdl = netmgr_get_dev("/dev/wifi0");
-    if(hdl < 0) {
-        return -1;
-    }
-
-    if(netmgr_get_ifconfig(hdl, &info) < 0) {
-        return -1;
-    }
-
-    if (0 == strcmp(info.ip_addr, "0.0.0.0")) {
-        return -1;
-    }
-    return 0;
-#else
-    return -1;
-#endif
-}
-
-int aos_get_mac_addr(unsigned char mac[8])
-{
-    // TODO: ?
-    return 0;
-}
-
 
 int aos_network_status_registercb(void (*cb)(int status, void *), void *arg)
 {
     return aos_wifi_set_msg_cb(cb);
 }
 
-int aos_get_network_status(void)
-{
-#ifndef AOS_BOARD_HAAS700
-    int ret = 0;
-    ret = aos_wifi_get_state();
-
-    return (ret == CONN_STATE_NETWORK_CONNECTED);
-#else
-    return 0;
-#endif
-}
-
 /**
  * @brief get wifi mac address
  * @param[out] mac: mac address，format: "01:23:45:67:89:ab"

components/amp_adapter/platform/aos/network/aos_wifi.c → components/amp_adapter/platform/aos/network/aos_network.c

@@ -6,30 +6,186 @@
 #include "aos_network.h"
 #include "netmgr.h"
 #include "netmgr_wifi.h"
+#include <uservice/eventid.h>
+#include <uservice/uservice.h>
 
+#ifndef WIFI_DEV_PATH
 #define WIFI_DEV_PATH "/dev/wifi0"
+#endif
+
+#define LOG_TAG       "aos_wifi"
 
-int aos_wifi_init()
+static int _remap_exceptions(int e)
 {
-    return netmgr_service_init(NULL);
+    int32_t err = 0;
+    // switch (e) {
+    //     case ESP_ERR_WIFI_NOT_INIT:
+    //         err = AOS_ERR_WIFI_NOT_INIT;
+    //         break;
+    //     case ESP_ERR_WIFI_NOT_STARTED:
+    //         err = AOS_ERR_WIFI_NOT_STARTED;
+    //         break;
+    //     case ESP_ERR_WIFI_NOT_STOPPED:
+    //         err = AOS_ERR_WIFI_NOT_STOPPED;
+    //         break;
+    //     case ESP_ERR_WIFI_IF:
+    //         err = AOS_ERR_WIFI_IF;
+    //         break;
+    //     case ESP_ERR_WIFI_MODE:
+    //         err = AOS_ERR_WIFI_MODE;
+    //         break;
+    //     case ESP_ERR_WIFI_STATE:
+    //         err = AOS_ERR_WIFI_STATE;
+    //         break;
+    //     case ESP_ERR_WIFI_CONN:
+    //         err = AOS_ERR_WIFI_CONN;
+    //         break;
+    //     case ESP_ERR_WIFI_NVS:
+    //         err = AOS_ERR_WIFI_NVS;
+    //         break;
+    //     case ESP_ERR_WIFI_MAC:
+    //         err = AOS_ERR_WIFI_MAC;
+    //         break;
+    //     case ESP_ERR_WIFI_SSID:
+    //         err = AOS_ERR_WIFI_SSID;
+    //         break;
+    //     case ESP_ERR_WIFI_PASSWORD:
+    //         err = AOS_ERR_WIFI_PASSWORD;
+    //         break;
+    //     case ESP_ERR_WIFI_TIMEOUT:
+    //         err = ETIMEDOUT;
+    //         break;
+    //     case ESP_ERR_WIFI_WAKE_FAIL:
+    //         err = AOS_ERR_WIFI_WAKE_FAIL;
+    //         break;
+    //     case ESP_ERR_WIFI_WOULD_BLOCK:
+    //         err = AOS_ERR_WIFI_WOULD_BLOCK;
+    //         break;
+    //     case ESP_ERR_WIFI_NOT_CONNECT:
+    //         err = AOS_ERR_WIFI_NOT_CONNECT;
+    //         break;
+    //     case ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS:
+    //         err = AOS_ERR_TCPIP_ADAPTER_INVALID_PARAMS;
+    //         break;
+    //     case ESP_ERR_TCPIP_ADAPTER_IF_NOT_READY:
+    //         err = AOS_ERR_TCPIP_ADAPTER_IF_NOT_READY;
+    //         break;
+    //     case ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED:
+    //         err = AOS_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED;
+    //         break;
+    //     case ESP_ERR_TCPIP_ADAPTER_NO_MEM:
+    //         err = ENOMEM;
+    //         break;
+    // }
+    return err;
 }
 
 
-int aos_wifi_set_ifconfig(netmgr_ifconfig_info_t *info)
+static void wifi_event_cb(uint32_t event_id, const void *param, void *ctx)
 {
-    netmgr_hdl_t hdl;
+    int32_t event;
+    int wifi_state = 0;
+    aos_wifi_manager_t *wifi_manager = NULL;
+    if (ctx != NULL) {
+        wifi_manager = (aos_wifi_manager_t *)ctx;
+    }
+
+    switch (event_id) {
+    case EVENT_NETMGR_WIFI_DISCONNECTED:
+        wifi_state = AOS_NET_STA_DISCONNECTED;
+        break;
+
+    case EVENT_NETMGR_WIFI_CONNECTED:
+        wifi_state = AOS_NET_STA_CONNECTED;
+        break;
+
+    case EVENT_NETMGR_GOT_IP:
+        wifi_state = AOS_NET_STA_GOT_IP;
+        break;
+
+    case EVENT_NETMGR_WIFI_CONN_TIMEOUT:
+        wifi_state = AOS_NET_STA_STARTED;
+        break;
+
+    default:
+        event = AOS_NET_STATE_UNKNOWN;
+        break;
+    }
+    if (wifi_manager != NULL) {
+        wifi_manager->wifi_state = wifi_state;
+    }
+
+    if (wifi_manager->cb != NULL) {
+        wifi_manager->cb(wifi_state, ctx);
+    }
+    return;
+}
+
+int aos_wifi_init(aos_wifi_manager_t *wifi_manager)
+{
+    int ret = 0;
+    netmgr_hdl_t hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl >= 0) {
+        LOGE(LOG_TAG, "wifi already init by other task");
+    } else {
+        LOGE(LOG_TAG, "aos_wifi_init start");
+        ret = event_service_init(NULL);
+        if (ret != 0) {
+            LOGE(LOG_TAG, "event_service_init failed");
+            return ret;
+        }
+        ret = netmgr_service_init(NULL);
+        if (ret != 0) {
+            LOGE(LOG_TAG, "netmgr_service_init failed");
+            return ret;
+        }
+
+        netmgr_set_auto_reconnect(NULL, false);
+        ret = netmgr_wifi_set_auto_save_ap(false);
+        if (ret != 0) {
+            LOGE(LOG_TAG, "netmgr_wifi_set_auto_save_ap failed");
+            return ret;
+        }
+    }
+    event_subscribe(EVENT_NETMGR_WIFI_DISCONNECTED, wifi_event_cb, wifi_manager);
+    event_subscribe(EVENT_NETMGR_WIFI_CONNECTED, wifi_event_cb, wifi_manager);
+    event_subscribe(EVENT_NETMGR_WIFI_CONN_TIMEOUT, wifi_event_cb, wifi_manager);
+    event_subscribe(EVENT_NETMGR_GOT_IP, wifi_event_cb, wifi_manager);
+    return ret;
+}
+
+int aos_wifi_deinit(aos_wifi_manager_t *wifi_manager)
+{
+    // return netmgr_service_deinit();
+    return 0;
+}
+
+int aos_wifi_start(aos_wifi_manager_t *wifi_manager)
+{
+    return 0;
+}
 
-    if((hdl = netmgr_get_dev(WIFI_DEV_PATH)) == -1) {
+int aos_wifi_stop(aos_wifi_manager_t *wifi_manager)
+{
+    return 0;
+}
+
+int aos_net_set_ifconfig(aos_ifconfig_info_t *info)
+{
+    netmgr_hdl_t hdl;
+    printf("dev %s open failed\n", __func__);
+    hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl == -1) {
         return -1;
     }
     return netmgr_set_ifconfig(hdl, info);
 }
 
-int aos_wifi_get_ifconfig(netmgr_ifconfig_info_t *info)
+int aos_net_get_ifconfig(aos_ifconfig_info_t *info)
 {
     netmgr_hdl_t hdl;
-
-    if((hdl = netmgr_get_dev(WIFI_DEV_PATH)) == -1) {
+    hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl == -1) {
         return -1;
     }
     return netmgr_get_ifconfig(hdl, info);
@@ -38,8 +194,8 @@ int aos_wifi_get_ifconfig(netmgr_ifconfig_info_t *info)
 int aos_wifi_set_msg_cb(netmgr_msg_cb_t cb)
 {
     netmgr_hdl_t hdl;
-
-    if((hdl = netmgr_get_dev(WIFI_DEV_PATH)) == -1) {
+    hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl == -1) {
         return -1;
     }
     return netmgr_set_msg_cb(hdl, cb);
@@ -48,8 +204,8 @@ int aos_wifi_set_msg_cb(netmgr_msg_cb_t cb)
 int aos_wifi_del_msg_cb(netmgr_msg_cb_t cb)
 {
     netmgr_hdl_t hdl;
-
-    if((hdl = netmgr_get_dev(WIFI_DEV_PATH)) == -1) {
+    hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl == -1) {
         return -1;
     }
     return netmgr_del_msg_cb(hdl, cb);
@@ -65,8 +221,9 @@ int aos_wifi_connect(const char *ssid, const char *passwd)
     int ret = -1;
     netmgr_hdl_t hdl;
     netmgr_connect_params_t params;
-
-    if((hdl = netmgr_get_dev(WIFI_DEV_PATH)) == -1) {
+    hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl < 0) {
+        LOGE(LOG_TAG, "netmgr_get_dev failed");
         return -1;
     }
 
@@ -78,37 +235,38 @@ int aos_wifi_connect(const char *ssid, const char *passwd)
 
     ret = netmgr_connect(hdl, &params);
     if (ret != 0) {
+        LOGE(LOG_TAG, "netmgr_connect failed. %d\n", ret);
         return ret;
     }
 
     return ret;
 }
 
-int aos_get_wifi_info(aos_wifi_info_t *wifi_info)
+int aos_wifi_get_info(aos_wifi_info_t *wifi_info)
 {
     netmgr_hdl_t hdl;
     netmgr_config_t config;
     netmgr_ifconfig_info_t info;
     int ap_num;
     int used_ap;                                         /**< ap that is used in the array */
-
-    if((hdl = netmgr_get_dev(WIFI_DEV_PATH)) == -1) {
+    hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl == -1) {
         return -1;
     }
 
     memset(&info, 0, sizeof(info));
-    if(netmgr_get_ifconfig(hdl, &info) == -1) {
+    if (netmgr_get_ifconfig(hdl, &info) == -1) {
         return -1;
     }
 
     memset(&config, 0, sizeof(config));
-    if(netmgr_get_config(hdl, &config) == -1) {
+    if (netmgr_get_config(hdl, &config) == -1) {
         return -1;
     }
     ap_num = config.config.wifi_config.ap_num;
     used_ap = config.config.wifi_config.used_ap;
 
-    if((ap_num < MAX_AP_CONFIG_NUM) && (used_ap < ap_num)) {
+    if ((ap_num < MAX_AP_CONFIG_NUM) && (used_ap < ap_num)) {
         memset(wifi_info->ssid, 0, sizeof(wifi_info->ssid));
         strncpy(wifi_info->ssid, config.config.wifi_config.config[used_ap].ssid, sizeof(wifi_info->ssid) - 1);
     } else {
@@ -125,8 +283,8 @@ int aos_get_wifi_info(aos_wifi_info_t *wifi_info)
 int aos_wifi_disconnect()
 {
     netmgr_hdl_t hdl;
-
-    if((hdl = netmgr_get_dev(WIFI_DEV_PATH)) == -1) {
+    hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl == -1) {
         return -1;
     }
     return netmgr_disconnect(hdl);
@@ -135,10 +293,17 @@ int aos_wifi_disconnect()
 int aos_wifi_get_state()
 {
     netmgr_hdl_t hdl;
-
-    if((hdl = netmgr_get_dev(WIFI_DEV_PATH)) == -1) {
+    hdl = netmgr_get_dev(WIFI_DEV_PATH);
+    if (hdl == -1) {
         return -1;
     }
     return netmgr_get_state(hdl);
 }
+
+int aos_get_network_status()
+{
+    int net_status = aos_wifi_get_state();
+    return net_status == AOS_NET_STA_GOT_IP ? 1 : 0;
+}
+
 #endif

components/py_engine/adapter/haas/CMakeLists.txt

@@ -117,6 +117,7 @@ set(MICROPY_SOURCE_PORT
     ${PROJECT_SOURCE_DIR}/mpstdinport.c
     ${PROJECT_SOURCE_DIR}/mpthreadport.c
     ${PROJECT_SOURCE_DIR}/utility.c
+    ${PROJECT_SOURCE_DIR}/modnetwork.c
 )
 
 set(MICROPY_SOURCE_QSTR

components/py_engine/adapter/haas/modnetwork.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "aos_network.h"
+#include "py/builtin.h"
+#include "py/mperrno.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/stackctrl.h"
+#include "aos_log.h"
+#include "utility.h"
+
+#define LOG_TAG   "mod_network"
+
+typedef struct _aos_wifi_obj_t {
+    mp_obj_base_t base;
+    int if_mode;
+} aos_wifi_if_obj_t;
+const mp_obj_type_t aos_wifi_if_type;
+STATIC const aos_wifi_if_obj_t aos_wifi_sta_obj = {{&aos_wifi_if_type}, AOS_NETWORK_WIFI_STA};
+STATIC const aos_wifi_if_obj_t aos_wifi_ap_obj = {{&aos_wifi_if_type}, AOS_NETWORK_WIFI_AP};
+STATIC aos_wifi_manager_t *wifi_manager = NULL;
+static mp_obj_t on_wifi_event_cb = mp_const_none;
+
+STATIC void _network_exceptions(AOS_NETWORK_ERR_E e)
+{
+    switch (e) {
+    case AOS_ERR_WIFI_NOT_INIT:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Initialized"));
+    case AOS_ERR_WIFI_NOT_STARTED:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Started"));
+    case AOS_ERR_WIFI_NOT_STOPPED:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Stopped"));
+    case AOS_ERR_WIFI_IF:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Interface"));
+    case AOS_ERR_WIFI_MODE:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Mode"));
+    case AOS_ERR_WIFI_STATE:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal State Error"));
+    case AOS_ERR_WIFI_CONN:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal Error"));
+    case AOS_ERR_WIFI_NVS:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal NVS Error"));
+    case AOS_ERR_WIFI_MAC:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid MAC Address"));
+    case AOS_ERR_WIFI_SSID:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi SSID Invalid"));
+    case AOS_ERR_WIFI_PASSWORD:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Password"));
+    case AOS_ERR_WIFI_TIMEOUT:
+        mp_raise_OSError(MP_ETIMEDOUT);
+    case AOS_ERR_WIFI_WAKE_FAIL:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Wakeup Failure"));
+    case AOS_ERR_WIFI_WOULD_BLOCK:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Would Block"));
+    case AOS_ERR_WIFI_NOT_CONNECT:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Connected"));
+    case AOS_ERR_TCPIP_ADAPTER_INVALID_PARAMS:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP Invalid Parameters"));
+    case AOS_ERR_TCPIP_ADAPTER_IF_NOT_READY:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP IF Not Ready"));
+    case AOS_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED:
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP DHCP Client Start Failed"));
+    case AOS_ERR_TCPIP_ADAPTER_NO_MEM:
+        mp_raise_OSError(MP_ENOMEM);
+    default:
+        mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("Wifi Unknown Error 0x%04x"), e);
+    }
+}
+static inline void network_exceptions(AOS_NETWORK_ERR_E e)
+{
+    if (e != 0) {
+        _network_exceptions(e);
+    }
+}
+
+static void wifi_event_cb(uint32_t event_id, void *context)
+{
+    if (on_wifi_event_cb != mp_const_none && mp_obj_is_callable(on_wifi_event_cb)) {
+        callback_to_python_LoBo(on_wifi_event_cb, MP_OBJ_NEW_SMALL_INT(event_id), NULL);
+    }
+}
+
+STATIC mp_obj_t wifi_init()
+{
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_0(aos_wifi_init_obj, wifi_init);
+
+STATIC mp_obj_t wifi_active(mp_obj_t self_in, mp_obj_t active)
+{
+    if (wifi_manager->is_started) {
+        return mp_const_none;
+    }
+
+    if (mp_obj_is_true(active)) {
+        network_exceptions(aos_wifi_start(wifi_manager));
+    } else {
+        network_exceptions(aos_wifi_stop(wifi_manager));
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(aos_wifi_active_obj, wifi_active);
+
+STATIC mp_obj_t wifi_connect(mp_obj_t self_in, mp_obj_t ssid_in, mp_obj_t pwd_in)
+{
+    const char *_ssid = mp_obj_str_get_str(ssid_in);
+    const char *_pwd = mp_obj_str_get_str(pwd_in);
+
+    if (!wifi_manager) {
+        wifi_init(self_in);
+        network_exceptions(aos_wifi_start(wifi_manager));
+    }
+    if (!wifi_manager->is_started) {
+        network_exceptions(aos_wifi_start(wifi_manager));
+    }
+
+    MP_THREAD_GIL_EXIT();
+    network_exceptions(aos_wifi_connect(_ssid, _pwd));
+    MP_THREAD_GIL_ENTER();
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_3(aos_wifi_connect_obj, wifi_connect);
+
+STATIC mp_obj_t wifi_disconnect(mp_obj_t self_in)
+{
+    network_exceptions(aos_wifi_disconnect());
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(aos_wifi_disconnect_obj, wifi_disconnect);
+
+STATIC mp_obj_t wifi_get_status(size_t n_args, const mp_obj_t *args)
+{
+    if (wifi_manager != NULL)
+        return mp_obj_new_int(wifi_manager->wifi_state);
+    else {
+        return mp_obj_new_int(-1);
+    }
+}
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(aos_wifi_get_status_obj, 1, 2, wifi_get_status);
+
+STATIC mp_obj_t wifi_is_connected(mp_obj_t self_in)
+{
+    if (wifi_manager->wifi_state == AOS_NET_STA_GOT_IP)
+        return mp_obj_new_bool(true);
+    return mp_obj_new_bool(false);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(wifi_is_connected_obj, wifi_is_connected);
+
+
+STATIC mp_obj_t wifi_on(mp_obj_t self_in, mp_obj_t func)
+{
+    on_wifi_event_cb = func;
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(aos_wifi_on_obj, wifi_on);
+
+STATIC mp_obj_t wifi_get_info(mp_obj_t self_in)
+{
+    aos_wifi_info_t wifi_info = { 0 };
+    mp_int_t ret = aos_wifi_get_info(&wifi_info);
+    if (ret < 0) {
+        AOS_LOGI(LOG_TAG, "Failed to get wifi info\n");
+        return mp_const_none;
+    }
+    mp_obj_t dict = mp_obj_new_dict(4);
+    mp_obj_dict_store(dict, MP_OBJ_NEW_QSTR(qstr_from_str("ssid")), mp_obj_new_strn(wifi_info.ssid));
+    mp_obj_dict_store(dict, MP_OBJ_NEW_QSTR(qstr_from_str("mac")), mp_obj_new_strn(wifi_info.mac));
+    mp_obj_dict_store(dict, MP_OBJ_NEW_QSTR(qstr_from_str("ip")), mp_obj_new_strn(wifi_info.ip));
+    mp_obj_dict_store(dict, MP_OBJ_NEW_QSTR(qstr_from_str("rssi")), mp_obj_new_int(wifi_info.rssi));
+    return dict;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(aos_wifi_get_info_obj, wifi_get_info);
+
+static int netutils_format_ipv4_addr(uint8_t *in_ip, char* out_ip)
+{
+    mp_uint_t ip_len;
+    if (sizeof(in_ip) < 4) {
+        AOS_LOGE("network", "invalid ip format.");
+        return -1;
+    }
+    ip_len = snprintf(out_ip, 16, "%u.%u.%u.%u", in_ip[3], in_ip[2], in_ip[1], in_ip[0]);
+    AOS_LOGE("network", out_ip);
+    return ip_len;
+}
+#ifndef NETUTILS_IPV4ADDR_BUFSIZE
+#define NETUTILS_IPV4ADDR_BUFSIZE    4
+#endif
+
+static void netutils_parse_ipv4_addr(mp_obj_t addr_in, uint8_t *out_ip)
+{
+    size_t addr_len;
+    const char *addr_str = mp_obj_str_get_data(addr_in, &addr_len);
+    if (addr_len == 0) {
+        // special case of no address given
+        memset(out_ip, 0, NETUTILS_IPV4ADDR_BUFSIZE);
+        return;
+    }
+    const char *s = addr_str;
+    const char *s_top = addr_str + addr_len;
+    for (mp_uint_t i = 3; ; i--) {
+        mp_uint_t val = 0;
+        for (; s < s_top && *s != '.'; s++) {
+            val = val * 10 + *s - '0';
+        }
+        // out_ip[i] = val;
+        out_ip[NETUTILS_IPV4ADDR_BUFSIZE - 1 - i] = val;
+        if (i == 0 && s == s_top) {
+            return;
+        } else if (i > 0 && s < s_top && *s == '.') {
+            s++;
+        } else {
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid arguments"));
+        }
+    }
+}
+
+STATIC mp_obj_t aos_ifconfig(size_t n_args, const mp_obj_t *args)
+{
+    aos_ifconfig_info_t info = { 0 };
+    if (n_args == 1) {
+        // get
+        mp_int_t ret = aos_net_get_ifconfig(&info);
+        if (ret != 0) {
+            AOS_LOGI(LOG_TAG, "netmgr_get_config failed, ret = %d\n", ret);
+            return mp_const_none;
+        }
+
+        mp_obj_t tuple[4] = {
+            mp_obj_new_strn(info.ip_addr),
+            mp_obj_new_strn(info.mask),
+            mp_obj_new_strn(info.gw),
+            mp_obj_new_strn(info.dns_server),
+            mp_obj_new_strn(info.mac),
+        };
+        return mp_obj_new_tuple(5, tuple);
+    } else {
+        // set
+        if (mp_obj_is_type(args[1], &mp_type_tuple) || mp_obj_is_type(args[1], &mp_type_list)) {
+            mp_obj_t *items;
+            mp_obj_get_array_fixed_n(args[1], 4, &items);
+            netutils_format_ipv4_addr(items[0], (void *)&info.ip_addr);
+            netutils_format_ipv4_addr(items[1], (void *)&info.mask);
+            netutils_format_ipv4_addr(items[2], (void *)&info.gw);
+            netutils_format_ipv4_addr(items[3], (void *)&info.dns_server);
+        }
+        mp_int_t ret = aos_net_set_ifconfig(&info);
+        return mp_obj_new_int(ret);
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(aos_ifconfig_obj, 1, 2, aos_ifconfig);
+
+STATIC const mp_rom_map_elem_t wifi_if_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&aos_wifi_active_obj) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_connect), MP_ROM_PTR(&aos_wifi_connect_obj) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_disconnect), MP_ROM_PTR(&aos_wifi_disconnect_obj) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_status), MP_ROM_PTR(&aos_wifi_get_status_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_scan), MP_ROM_PTR(&aos_wifi_scan_obj) },
+    { MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&wifi_is_connected_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&esp_config_obj) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&aos_ifconfig_obj) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_on), MP_ROM_PTR(&aos_wifi_on_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(wifi_if_locals_dict, wifi_if_locals_dict_table);
+const mp_obj_type_t aos_wifi_if_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_WIFI,
+    .locals_dict = (mp_obj_t)&wifi_if_locals_dict,
+};
+
+STATIC mp_obj_t get_wifi(size_t n_args, const mp_obj_t *args)
+{
+    int idx = (n_args > 0) ? mp_obj_get_int(args[0]) : AOS_NETWORK_WIFI_STA;
+    if (idx == AOS_NETWORK_WIFI_STA) {
+        if (!wifi_manager) {
+            wifi_manager = calloc(sizeof(aos_wifi_manager_t), 1);
+            if (!wifi_manager) {
+                network_exceptions(MP_ENOMEM);
+            }
+            wifi_manager->cb = wifi_event_cb;
+            wifi_manager->wifi_state = AOS_NET_NOINIT;
+            wifi_manager->wifi_mode = AOS_NETWORK_WIFI_STA;
+            wifi_manager->is_initialized = false;
+            wifi_manager->is_started = false;
+        }
+        network_exceptions(aos_wifi_init(wifi_manager));
+        return MP_OBJ_FROM_PTR(&aos_wifi_sta_obj);
+    } else if (idx == AOS_NETWORK_WIFI_AP) {
+        return MP_OBJ_FROM_PTR(&aos_wifi_ap_obj);
+    } else {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid WLAN interface identifier"));
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(aos_get_wifi_obj, 0, 1, get_wifi);
+
+
+
+STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_network) },
+    // { MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&aos_wifi_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_WLAN), MP_ROM_PTR(&aos_get_wifi_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_STA_IF), MP_ROM_INT(AOS_NETWORK_WIFI_STA)},
+    { MP_ROM_QSTR(MP_QSTR_AP_IF), MP_ROM_INT(AOS_NETWORK_WIFI_AP)},
+
+    { MP_ROM_QSTR(MP_QSTR_STA_STARTED), MP_ROM_INT(AOS_NET_STA_STARTED) },
+    { MP_ROM_QSTR(MP_QSTR_STA_CONNECTED), MP_ROM_INT(AOS_NET_STA_CONNECTED) },
+    { MP_ROM_QSTR(MP_QSTR_STA_GOT_IP), MP_ROM_INT(AOS_NET_STA_GOT_IP) },
+    { MP_ROM_QSTR(MP_QSTR_STA_LOST_IP), MP_ROM_INT(AOS_NET_STA_LOST_IP) },
+    { MP_ROM_QSTR(MP_QSTR_STA_DISCONNECTED), MP_ROM_INT(AOS_NET_STA_DISCONNECTED) },
+    { MP_ROM_QSTR(MP_QSTR_STA_STOPED), MP_ROM_INT(AOS_NET_STA_STOPED) },
+    { MP_ROM_QSTR(MP_QSTR_STA_UNKNOWN), MP_ROM_INT(AOS_NET_STATE_UNKNOWN) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(mp_module_network_globals, mp_module_network_globals_table);
+
+const mp_obj_module_t mp_module_network = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&mp_module_network_globals,
+};
+
+MP_REGISTER_MODULE(MP_QSTR_network, mp_module_network, 1);

haas_lib_bundles/python/docs/haas_extended_api/network.md

+# Network - 网络配置模块
+* 模块功能：  
+管理Wi-Fi和以太网
+
+* 参考用法：  
+```python
+import network
+import time
+
+def callback(event_id):
+    print(event_id)
+
+nic = network.WLAN(network.STA_IF)
+nic.on(callback)
+nic.active(True)
+if not nic.isconnected():
+    nic.connect(ssid, password)
+    print("Waiting for connection...")
+    while not nic.isconnected():
+        time.sleep(1)
+print(nic.ifconfig())
+```
+
+## 常量说明
+|常量|值|说明|
+|:-|:-|:-|
+|network.STA_IF|1|WLAN STA模式|
+|network.AP_IF|2|WLAN AP模式|
+|network.STA_STARTED|1|WLAN已启动|
+|network.STA_GOT_IP|2|WLAN获得IP|
+|network.STA_LOST_IP|3|WLAN已丢失IP|
+|network.STA_DISCONNECTED|4|WLAN已断开连接|
+|network.STA_CONNECTED|5|WLAN已链接|
+|network.STA_STOPED|6|WLAN已停用|
+|network.STA_UNKNOWN|7|未知状态|
+
+
+## 错误码
+
+```C
+typedef enum {
+    AOS_ERR_WIFI_BASE = 0x3000,         /*!< WiFi ERR NUM BASE */
+    AOS_ERR_WIFI_NOT_INIT,              /*!< WiFi driver was not installed by esp_wifi_init */
+    AOS_ERR_WIFI_NOT_STARTED,           /*!< WiFi driver was not started by esp_wifi_start */
+    AOS_ERR_WIFI_NOT_STOPPED,           /*!< WiFi driver was not stopped by esp_wifi_stop */
+    AOS_ERR_WIFI_IF,                    /*!< WiFi interface error */
+    AOS_ERR_WIFI_MODE,                  /*!< WiFi mode error */
+    AOS_ERR_WIFI_STATE,                 /*!< WiFi internal state error */
+    AOS_ERR_WIFI_CONN,                  /*!< WiFi internal control block of station or soft-AP error */
+    AOS_ERR_WIFI_NVS,                   /*!< WiFi internal NVS module error */
+    AOS_ERR_WIFI_MAC,                   /*!< MAC address is invalid */
+    AOS_ERR_WIFI_SSID,                  /*!< SSID is invalid */
+    AOS_ERR_WIFI_PASSWORD,              /*!< Password is invalid */
+    AOS_ERR_WIFI_TIMEOUT,               /*!< Timeout error */
+    AOS_ERR_WIFI_WAKE_FAIL,             /*!< WiFi is in sleep state(RF closed) and wakeup fail */
+    AOS_ERR_WIFI_WOULD_BLOCK,           /*!< The caller would block */
+    AOS_ERR_WIFI_NOT_CONNECT,           /*!< Station still in disconnect status */
+    AOS_ERR_WIFI_POST,                  /*!< Failed to post the event to WiFi task */
+    AOS_ERR_WIFI_INIT_STATE,            /*!< Invalod WiFi state when init/deinit is called */
+    AOS_ERR_WIFI_STOP_STATE,            /*!< Returned when WiFi is stopping */
+    AOS_ERR_WIFI_NOT_ASSOC,             /*!< The WiFi connection is not associated */
+    AOS_ERR_WIFI_TX_DISALLOW,           /*!< The WiFi TX is disallowed */
+    AOS_ERR_TCPIP_ADAPTER_INVALID_PARAMS,
+    AOS_ERR_TCPIP_ADAPTER_IF_NOT_READY,
+    AOS_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED,
+    AOS_ERR_TCPIP_ADAPTER_NO_MEM
+} AOS_NETWORK_ERR_E;
+```
+
+## network.WLAN - 创建一个WLAN实例
+
+* 函数原型：
+> class network.WLAN(interface_id)
+
+* 参数说明：
+
+interface_id 可选值为 network.STA_IF 或 network.AP_IF
+
+* 返回值：  
+返回一个wlan实例
+
+* 参考代码：
+```python
+wlan = network.WLAN(network.STA_IF)
+```
+
+## WLAN.active
+
+* 函数原型：
+> WLAN.active(is_active)
+
+* 参数说明：
+
+|参数|类型|必选参数？|说明|
+|-----|----|:---:|----|
+|is_active|bool（True, False）|是|激活/反激活|
+
+## WLAN.connect
+
+* 函数功能：  
+链接Wi-FI
+
+* 函数原型：
+> WLAN.connect(ssid, pwd)
+
+* 参数说明：
+
+|参数|类型|必选参数？|说明|
+|-----|----|:---:|----|
+|ssid|string|是|ssid名称|
+|pwd|string|是|ssid密码|
+
+* 参数说明：
+
+|参数|类型|必选参数？|说明|
+|-----|----|:---:|----|
+|ssid|string|是|ssid名称|
+|pwd|string|是|ssid密码|
+
+## WLAN.disconnect
+
+* 函数功能：  
+断开Wi-Fi链接
+
+* 函数原型：
+> WLAN.disconnect()
+
+* 参数说明：无
+
+* 返回值：
+
+成功返回0，错误返回错误码
+
+## WLAN.status
+
+* 函数功能：  
+获取Wi-Fi状态
+
+* 函数原型：
+> WLAN.status()
+
+* 参数说明：无
+
+* 返回值
+
+|定义| 数值 |说明|
+|:-|:-|:-|
+|network.STA_STARTED|1|WLAN已启动|
+|network.STA_GOT_IP|2|WLAN获得IP|
+|network.STA_LOST_IP|3|WLAN已丢失IP|
+|network.STA_DISCONNECTED|4|WLAN已断开连接|
+|network.STA_CONNECTED|5|WLAN已链接|
+|network.STA_STOPED|6|WLAN已停用|
+|network.STA_UNKNOWN|7|未知状态|
+
+## WLAN.isconnected
+
+* 函数功能：  
+查看Wi-Fi是否已链接
+
+* 函数原型：
+> WLAN.isconnected()
+
+* 参数说明：无
+
+* 返回值
+
+|类型| 数值 |说明|
+|:-|:-|:-|
+|bool|True|Wi-Fi已连接|
+|bool|False|Wi-Fi未连接|
+
+
+## WLAN.ifconfig
+
+* 函数功能：  
+查看Wi-Fi是否已链接
+
+* 函数原型：
+> WLAN.ifconfig([ip, subnet, gateway, dns])
+
+* 参数说明：
+
+如果不传参数，则获取当前IP配置, 如果传入组合参数，则设定IP信息
+
+|参数|类型|必选参数|说明|
+|:----|:----|:---:|----|
+|ip_info|tuple|否|ip信息|
+
+ip_info数据格式说明：
+
+|参数|类型|说明|
+|:----|:----|:----|
+|ip|stringip|地址|
+|subnet|string|子网掩码|
+|gateway|string|网关地址|
+|dns|string|dns地址|
+
+* 返回值
+
+成功返回0，错误返回错误码
+
+
+## WLAN.on
+
+* 函数功能：  
+注册回调函数，网络状态发生变化时候，引擎会调用毁掉函数
+
+* 函数原型：
+> WLAN.on(callback)
+
+* 参数说明：
+
+|参数|类型|必选参数|说明|
+|:----|:----|:---:|----|
+|callback|func|是|设定回调函数|
+
+* callback函数定义
+callback(event_type)
+
+* 返回值
+
+成功返回0，错误返回错误码
+
+## WLAN.scan
+
+* 函数功能：  
+扫描附近AP
+
+* 函数原型：
+> WLAN.scan()
+
+* 参数说明：
+
+无
+
+* 返回值
+
+返回AP列表
\ No newline at end of file