Merge pull request #685 from nkolban/master

Issue #589.  Design and implementation of wifi.getStatus()

Author: gfwilliams

libs/network/esp8266/jswrap_esp8266.c

@@ -708,12 +708,50 @@ void jswrap_ESP8266_wifi_createAP(
   os_printf("< jswrap_ESP8266_wifi_createAP\n");
 }
 
+/*JSON{
+  "type"     : "staticmethod",
+  "class"    : "wifi",
+  "name"     : "getStatus",
+  "generate" : "jswrap_ESP8266_wifi_getStatus",
+  "return"   : ["JsVar", "A boolean representing our WiFi status "]
+}
+* Retrieve the status of the current WiFi environment.
+* The object returned by this function will have some or all of the following properties:
+* * `isStation` - True if the ESP8266 is being a Station
+* * `isAP` - True if the ESP8266 is being an Access Point.
+* * `connectedStations` - An array of the stations connected to us if we are being an access point.  This
+* array may be empty.  Each entry in the array will itself be an object describing the station which,
+* at a minimum will contain `ip` being the IP address of the station.
+*/
+JsVar *jswrap_ESP8266_wifi_getStatus() {
+  os_printf("> jswrap_ESP8266_wifi_getStatus\n");
+  JsVar *jsWiFiStatus = jspNewObject(NULL, "WiFiStatus");
+  uint8 opMode = wifi_get_opmode();
+  jsvObjectSetChildAndUnLock(
+      jsWiFiStatus,
+      "isStation",
+      jsvNewFromBool(opMode == STATION_MODE || opMode == STATIONAP_MODE));
+  jsvObjectSetChildAndUnLock(
+      jsWiFiStatus,
+      "isAP",
+      jsvNewFromBool(opMode == SOFTAP_MODE || opMode == STATIONAP_MODE));
+  if (opMode == SOFTAP_MODE || opMode == STATIONAP_MODE) {
+    jsvObjectSetChildAndUnLock(
+      jsWiFiStatus,
+      "connectedStations",
+      jswrap_ESP8266WiFi_getConnectedStations());
+  }
+  os_printf("< jswrap_ESP8266_wifi_getStatus\n");
+  return jsWiFiStatus;
+}
+
+
 /*JSON{
   "type"     : "staticmethod",
   "class"    : "wifi",
   "name"     : "getIP",
   "generate" : "jswrap_ESP8266_wifi_getIP",
-  "return"   : ["JsVar", "A boolean representing our auto connect status"]
+  "return"   : ["JsVar", "A boolean representing our IP information"]
 }
 * Return IP information in an object which contains:
 * * ip - IP address
@@ -725,12 +763,12 @@ JsVar *jswrap_ESP8266_wifi_getIP() {
   struct ip_info info;
   wifi_get_ip_info(0, &info);
 
-  JsVar *ipInfo = jspNewObject(NULL, "Restart");
-  jsvObjectSetChildAndUnLock(ipInfo, "ip", jsvNewFromInteger(info.ip.addr));
-  jsvObjectSetChildAndUnLock(ipInfo, "netmask", jsvNewFromInteger(info.netmask.addr));
-  jsvObjectSetChildAndUnLock(ipInfo, "gw", jsvNewFromInteger(info.gw.addr));
+  JsVar *jsIpInfo = jspNewObject(NULL, "Restart");
+  jsvObjectSetChildAndUnLock(jsIpInfo, "ip", jsvNewFromInteger(info.ip.addr));
+  jsvObjectSetChildAndUnLock(jsIpInfo, "netmask", jsvNewFromInteger(info.netmask.addr));
+  jsvObjectSetChildAndUnLock(jsIpInfo, "gw", jsvNewFromInteger(info.gw.addr));
   os_printf("< jswrap_ESP8266_wifi_getIP\n");
-  return ipInfo;
+  return jsIpInfo;
 }
 
 
@@ -1868,14 +1906,18 @@ static void scanCB(void *arg, STATUS status) {
    */
 
   os_printf(">> scanCB\n");
+  if (g_jsScanCallback == NULL) {
+    os_printf("<< scanCB\n");
+    return;
+  }
 
   // Set the opmode back to the value it was prior to the request for a scan.
   assert(g_preWiFiScanMode != -1);
   wifi_set_opmode_current(g_preWiFiScanMode);
   g_preWiFiScanMode = -1;
 
   // Create the Empty JS array that will be passed as a parameter to the callback.
-  JsVar *accessPointArray = jsvNewArray(NULL, 0);
+  JsVar *jsAccessPointArray = jsvNewArray(NULL, 0);
   struct bss_info *bssInfo;
 
   bssInfo = (struct bss_info *)arg;
@@ -1897,29 +1939,38 @@ static void scanCB(void *arg, STATUS status) {
     // sint16 freq_offset
     // ---
     // Create, populate and add a child ...
-    JsVar *currentAccessPoint = jspNewObject(NULL, "AccessPoint");
-    jsvObjectSetChildAndUnLock(currentAccessPoint, "rssi", jsvNewFromInteger(bssInfo->rssi));
-    jsvObjectSetChildAndUnLock(currentAccessPoint, "channel", jsvNewFromInteger(bssInfo->channel));
-    jsvObjectSetChildAndUnLock(currentAccessPoint, "authMode", jsvNewFromInteger(bssInfo->authmode));
-    jsvObjectSetChildAndUnLock(currentAccessPoint, "isHidden", jsvNewFromBool(bssInfo->is_hidden));
+    JsVar *jsCurrentAccessPoint = jspNewObject(NULL, "AccessPoint");
+    jsvObjectSetChildAndUnLock(jsCurrentAccessPoint, "rssi", jsvNewFromInteger(bssInfo->rssi));
+    jsvObjectSetChildAndUnLock(jsCurrentAccessPoint, "channel", jsvNewFromInteger(bssInfo->channel));
+    jsvObjectSetChildAndUnLock(jsCurrentAccessPoint, "authMode", jsvNewFromInteger(bssInfo->authmode));
+    jsvObjectSetChildAndUnLock(jsCurrentAccessPoint, "isHidden", jsvNewFromBool(bssInfo->is_hidden));
     // The SSID may **NOT** be NULL terminated ... so handle that.
     char ssid[sizeof(bssInfo->ssid) + 1];
     os_strncpy((char *)ssid, (char *)bssInfo->ssid, sizeof(bssInfo->ssid));
     ssid[sizeof(ssid)-1] = '\0';
-    jsvObjectSetChildAndUnLock(currentAccessPoint, "ssid", jsvNewFromString(ssid));
+    jsvObjectSetChildAndUnLock(jsCurrentAccessPoint, "ssid", jsvNewFromString(ssid));
 
     // Add the new record to the array
-    jsvArrayPush(accessPointArray, currentAccessPoint);
+    jsvArrayPush(jsAccessPointArray, jsCurrentAccessPoint);
+    jsvUnLock(jsCurrentAccessPoint);
 
     os_printf(" - ssid: %s\n", bssInfo->ssid);
     bssInfo = STAILQ_NEXT(bssInfo, next);
   }
 
   // We have now completed the scan callback, so now we can invoke the JS callback.
-  JsVar *params[1];
-  params[0] = accessPointArray;
-  jsiQueueEvents(NULL, g_jsScanCallback, params, 1);
+  // The parameters to the callback are:
+  // * err - An error indication - always null as we can't fail.
+  // * accessPointArray - An array of access point records.
+  JsVar *params[2];
+  params[0] = jsvNewNull();
+  params[1] = jsAccessPointArray;
+  jsiQueueEvents(NULL, g_jsScanCallback, params, 2);
+
+  jsvUnLock(jsAccessPointArray);
   jsvUnLock(g_jsScanCallback);
+  jsvUnLock(params[0]);
+  g_jsScanCallback = NULL;
   os_printf("<< scanCB\n");
 }
 

libs/network/esp8266/jswrap_esp8266.h

@@ -50,6 +50,7 @@ void   jswrap_ESP8266_wifi_connect(JsVar *jsSsid, JsVar *jsPassword, JsVar *jsOp
 void   jswrap_ESP8266_wifi_createAP(JsVar *jsSsid, JsVar *jsPassword, JsVar *jsOptions, JsVar *jsCallback);
 void   jswrap_ESP8266_wifi_disconnect(JsVar *jsOptions, JsVar *jsCallback);
 JsVar *jswrap_ESP8266_wifi_getIP();
+JsVar *jswrap_ESP8266_wifi_getStatus();
 void   jswrap_ESP8266_wifi_scan(JsVar *jsCallback);
 void   jswrap_ESP8266_wifi_stopAP(JsVar *jsOptions, JsVar *jsCallback);
 

targets/esp8266/docs/05-User_Guide.md

@@ -247,6 +247,10 @@ Scan for a list of the access points and pass them as an array into a callback f
 
 `wifi.scan(callback)`
 
+The signature for the callback function is:
+
+    callback(err, arrayOfAccessPoints)
+
 The callback function is passed an array of records where each record describes a potential access point.
 Each record contains:
 
@@ -259,14 +263,31 @@ Each record contains:
 For example:
 
     var wifi = require("wifi");
-    wifi.scan(function(arrayOfAcessPoints) {
+    wifi.scan(function(err, arrayOfAcessPoints) {
       for (var i=0; i<arrayOfAcessPoints.length; i++) {
         print("Access point: " + i + " = " + JSON.stringify(arrayOfAcessPoints[i]));
       }
     });
 
 ----
 
+##wifi.getSatus
+
+Retrieve the status of the WiFi environment.
+
+`wifi.getStatus()`
+
+This function returns a JavaScript object that contains the current status of the WiFi environment.  Depending
+on the board being used, the results may include the following:
+
+* `isStation` - True if the device is being a Station
+* `isAP` - True if the device is being an Access Point.
+* `connectedStations` - An array of the stations connected to us if we are being an access point.  This
+array may be empty.  Each entry in the array will itself be an object describing the station which,
+at a minimum will contain `ip` being the IP address of the station.
+
+----
+
 ##wifi.stopAP
 
 Don't be an access point any longer.

targets/esp8266/jshardware.c

@@ -653,20 +653,21 @@ void jshSPISetReceive(IOEventFlags device, bool isReceive) {
 /** Set-up I2C master for ESP8266, default pins are SCL:14, SDA:2. Only device I2C1 is supported
  *  and only master mode. */
 void jshI2CSetup(IOEventFlags device, JshI2CInfo *info) {
-  os_printf("ESP8266: jshI2CSetup SCL=%d SDA=%d bitrate=%d\n",
+  os_printf("> jshI2CSetup: SCL=%d SDA=%d bitrate=%d\n",
       info->pinSCL, info->pinSDA, info->bitrate);
   if (device != EV_I2C1) {
     jsError("Only I2C1 supported");
     return;
   }
 
-  Pin scl = info->pinSCL >= 0 ? info->pinSCL : 14;
-  Pin sda = info->pinSDA >= 0 ? info->pinSDA : 2;
+  Pin scl = info->pinSCL !=PIN_UNDEFINED ? info->pinSCL : 14;
+  Pin sda = info->pinSDA !=PIN_UNDEFINED ? info->pinSDA : 2;
 
-  jshPinSetState(info->pinSCL, JSHPINSTATE_I2C);
-  jshPinSetState(info->pinSDA, JSHPINSTATE_I2C);
+  jshPinSetState(scl, JSHPINSTATE_I2C);
+  jshPinSetState(sda, JSHPINSTATE_I2C);
 
   i2c_master_gpio_init(scl, sda, info->bitrate);
+  os_printf("< jshI2CSetup\n");
 }
 
 void jshI2CWrite(IOEventFlags device, unsigned char address, int nBytes,