Port esp2866 driver to new WiFiInterface API

Author: bulislaw

ESP8266/ESP8266.cpp

@@ -79,7 +79,7 @@ bool ESP8266::disconnect(void)
 const char *ESP8266::getIPAddress(void)
 {
     if (!(_parser.send("AT+CIFSR")
-        && _parser.recv("+CIFSR:STAIP,\"%[^\"]\"", _ip_buffer)
+        && _parser.recv("+CIFSR:STAIP,\"%15[^\"]\"", _ip_buffer)
         && _parser.recv("OK"))) {
         return 0;
     }
@@ -90,19 +90,62 @@ const char *ESP8266::getIPAddress(void)
 const char *ESP8266::getMACAddress(void)
 {
     if (!(_parser.send("AT+CIFSR")
-        && _parser.recv("+CIFSR:STAMAC,\"%[^\"]\"", _mac_buffer)
+        && _parser.recv("+CIFSR:STAMAC,\"%17[^\"]\"", _mac_buffer)
         && _parser.recv("OK"))) {
         return 0;
     }
 
     return _mac_buffer;
 }
 
+int8_t ESP8266::getRSSI()
+{
+    int8_t rssi;
+    char bssid[18];
+
+   if (!(_parser.send("AT+CWJAP?")
+        && _parser.recv("+CWJAP:\"%*[^\"]\",\"%17[^\"]\"", bssid)
+        && _parser.recv("OK"))) {
+        return 0;
+    }
+
+    if (!(_parser.send("AT+CWLAP=\"\",\"%s\",", bssid)
+        && _parser.recv("+CWLAP:(%*d,\"%*[^\"]\",%hhd,", &rssi)
+        && _parser.recv("OK"))) {
+        return 0;
+    }
+
+    return rssi;
+}
+
 bool ESP8266::isConnected(void)
 {
     return getIPAddress() != 0;
 }
 
+int ESP8266::scan(WiFiAccessPoint *res, unsigned limit)
+{
+    unsigned cnt = 0;
+    nsapi_wifi_ap_t ap;
+
+    if (!_parser.send("AT+CWLAP")) {
+        return NSAPI_ERROR_DEVICE_ERROR;
+    }
+
+    while (recv_ap(&ap)) {
+        if (cnt < limit) {
+            res[cnt] = WiFiAccessPoint(ap);
+        }
+
+        cnt++;
+        if (limit != 0 && cnt >= limit) {
+            break;
+        }
+    }
+
+    return cnt;
+}
+
 bool ESP8266::open(const char *type, int id, const char* addr, int port)
 {
     //IDs only 0-4
@@ -227,3 +270,15 @@ void ESP8266::attach(Callback<void()> func)
 {
     _serial.attach(func);
 }
+
+bool ESP8266::recv_ap(nsapi_wifi_ap_t *ap)
+{
+    int sec;
+    bool ret = _parser.recv("+CWLAP:(%d,\"%32[^\"]\",%hhd,\"%hhx:%hhx:%hhx:%hhx:%hhx:%hhx\",%d", &sec, ap->ssid,
+                            &ap->rssi, &ap->bssid[0], &ap->bssid[1], &ap->bssid[2], &ap->bssid[3], &ap->bssid[4],
+                            &ap->bssid[5], &ap->channel);
+
+    ap->security = sec < 5 ? (nsapi_security_t)sec : NSAPI_SECURITY_UNKNOWN;
+
+    return ret;
+}

ESP8266/ESP8266.h

@@ -81,13 +81,28 @@ class ESP8266
     */
     const char *getMACAddress(void);
 
+    /* Return RSSI for active connection
+     *
+     * @return      Measured RSSI
+     */
+    int8_t getRSSI();
+
     /**
     * Check if ESP8266 is conenected
     *
     * @return true only if the chip has an IP address
     */
     bool isConnected(void);
 
+    /** Scan for available networks
+     *
+     * @param  ap    Pointer to allocated array to store discovered AP
+     * @param  limit Size of allocated @a res array, or 0 to only count available AP
+     * @return       Number of entries in @a res, or if @a count was 0 number of available networks, negative on error
+     *               see @a nsapi_error
+     */
+    int scan(WiFiAccessPoint *res, unsigned limit);
+
     /**
     * Open a socketed connection
     *
@@ -173,6 +188,7 @@ class ESP8266
         // data follows
     } *_packets, **_packets_end;
     void _packet_handler();
+    bool recv_ap(nsapi_wifi_ap_t *ap);
 
     char _ip_buffer[16];
     char _mac_buffer[18];

ESP8266Interface.cpp

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
- 
 
+#include <string.h>
 #include "ESP8266Interface.h"
 
 // Various timeouts for different ESP8266 operations
@@ -23,7 +23,6 @@
 #define ESP8266_RECV_TIMEOUT    0
 #define ESP8266_MISC_TIMEOUT    500
 
-
 // ESP8266Interface implementation
 ESP8266Interface::ESP8266Interface(PinName tx, PinName rx, bool debug)
     : _esp(tx, rx, debug)
@@ -34,10 +33,18 @@ ESP8266Interface::ESP8266Interface(PinName tx, PinName rx, bool debug)
     _esp.attach(this, &ESP8266Interface::event);
 }
 
-int ESP8266Interface::connect(
-    const char *ssid,
-    const char *pass,
-    nsapi_security_t security)
+int ESP8266Interface::connect(const char *ssid, const char *pass, nsapi_security_t security,
+                                        uint8_t channel)
+{
+    if (channel != 0) {
+        return NSAPI_ERROR_UNSUPPORTED;
+    }
+
+    set_credentials(ssid, pass, security);
+    return connect();
+}
+
+int ESP8266Interface::connect()
 {
     _esp.setTimeout(ESP8266_CONNECT_TIMEOUT);
 
@@ -49,17 +56,36 @@ int ESP8266Interface::connect(
         return NSAPI_ERROR_DHCP_FAILURE;
     }
 
-    if (!_esp.connect(ssid, pass)) {
+    if (!_esp.connect(ap_ssid, ap_pass)) {
         return NSAPI_ERROR_NO_CONNECTION;
     }
 
     if (!_esp.getIPAddress()) {
         return NSAPI_ERROR_DHCP_FAILURE;
     }
 
+    return NSAPI_ERROR_OK;
+}
+
+int ESP8266Interface::set_credentials(const char *ssid, const char *pass, nsapi_security_t security)
+{
+    memset(ap_ssid, 0, sizeof(ap_ssid));
+    strncpy(ap_ssid, ssid, sizeof(ap_ssid));
+
+    memset(ap_pass, 0, sizeof(ap_pass));
+    strncpy(ap_pass, pass, sizeof(ap_pass));
+
+    ap_sec = security;
+
     return 0;
 }
 
+int ESP8266Interface::set_channel(uint8_t channel)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+
 int ESP8266Interface::disconnect()
 {
     _esp.setTimeout(ESP8266_MISC_TIMEOUT);
@@ -68,7 +94,7 @@ int ESP8266Interface::disconnect()
         return NSAPI_ERROR_DEVICE_ERROR;
     }
 
-    return 0;
+    return NSAPI_ERROR_OK;
 }
 
 const char* ESP8266Interface::get_ip_address()
@@ -81,6 +107,16 @@ const char* ESP8266Interface::get_mac_address()
     return _esp.getMACAddress();
 }
 
+int8_t ESP8266Interface::get_rssi()
+{
+    return _esp.getRSSI();
+}
+
+int ESP8266Interface::scan(WiFiAccessPoint *res, unsigned count)
+{
+    return _esp.scan(res, count);
+}
+
 struct esp8266_socket {
     int id;
     nsapi_protocol_t proto;

ESP8266Interface.h

@@ -17,8 +17,8 @@
 #ifndef ESP8266_INTERFACE_H
 #define ESP8266_INTERFACE_H
 
-#include "network-socket/NetworkStack.h"
-#include "network-socket/WiFiInterface.h"
+#include "NetworkStack.h"
+#include "WiFiInterface.h"
 #include "ESP8266.h"
 
 
@@ -39,18 +39,44 @@ class ESP8266Interface : public NetworkStack, public WiFiInterface
 
     /** Start the interface
      *
-     *  Attempts to connect to a WiFi network. If passphrase is invalid,
-     *  NSAPI_ERROR_AUTH_ERROR is returned.
+     *  Attempts to connect to a WiFi network. Requires ssid and passphrase to be set.
+     *  If passphrase is invalid, NSAPI_ERROR_AUTH_ERROR is returned.
+     *
+     *  @return         0 on success, negative error code on failure
+     */
+    virtual int connect();
+
+    /** Start the interface
+     *
+     *  Attempts to connect to a WiFi network.
+     *
+     *  @param ssid      Name of the network to connect to
+     *  @param pass      Security passphrase to connect to the network
+     *  @param security  Type of encryption for connection (Default: NSAPI_SECURITY_NONE)
+     *  @param channel   This parameter is not supported, setting it to anything else than 0 will result in NSAPI_ERROR_UNSUPPORTED
+     *  @return          0 on success, or error code on failure
+     */
+    virtual int connect(const char *ssid, const char *pass, nsapi_security_t security = NSAPI_SECURITY_NONE,
+                                  uint8_t channel = 0);
+
+    /** Set the WiFi network credentials
      *
      *  @param ssid      Name of the network to connect to
      *  @param pass      Security passphrase to connect to the network
      *  @param security  Type of encryption for connection
-     *  @return          0 on success, negative error code on failure
+     *                   (defaults to NSAPI_SECURITY_NONE)
+     *  @return          0 on success, or error code on failure
      */
-    virtual int connect(
-        const char *ssid,
-        const char *pass,
-        nsapi_security_t security = NSAPI_SECURITY_NONE);
+    virtual int set_credentials(const char *ssid, const char *pass, nsapi_security_t security = NSAPI_SECURITY_NONE);
+
+    /** Set the WiFi network channel - NOT SUPPORTED
+     *
+     * This function is not supported and will return NSAPI_ERROR_UNSUPPORTED
+     *
+     *  @param channel   Channel on which the connection is to be made, or 0 for any (Default: 0)
+     *  @return          Not supported, returns NSAPI_ERROR_UNSUPPORTED
+     */
+    virtual int set_channel(uint8_t channel);
 
     /** Stop the interface
      *  @return             0 on success, negative on failure
@@ -67,6 +93,24 @@ class ESP8266Interface : public NetworkStack, public WiFiInterface
      */
     virtual const char *get_mac_address();
 
+    /** Gets the current radio signal strength for active connection
+     *
+     * @return          Connection strength in dBm (negative value)
+     */
+    virtual int8_t get_rssi();
+
+    /** Scan for available networks
+     *
+     * This function will block.
+     *
+     * @param  ap       Pointer to allocated array to store discovered AP
+     * @param  count    Size of allocated @a res array, or 0 to only count available AP
+     * @param  timeout  Timeout in milliseconds; 0 for no timeout (Default: 0)
+     * @return          Number of entries in @a, or if @a count was 0 number of available networks, negative on error
+     *                  see @a nsapi_error
+     */
+    virtual int scan(WiFiAccessPoint *res, unsigned count);
+
 protected:
     /** Open a socket
      *  @param handle       Handle in which to store new socket
@@ -78,14 +122,14 @@ class ESP8266Interface : public NetworkStack, public WiFiInterface
     /** Close the socket
      *  @param handle       Socket handle
      *  @return             0 on success, negative on failure
-     *  @note On failure, any memory associated with the socket must still 
+     *  @note On failure, any memory associated with the socket must still
      *        be cleaned up
      */
     virtual int socket_close(void *handle);
 
     /** Bind a server socket to a specific port
      *  @param handle       Socket handle
-     *  @param address      Local address to listen for incoming connections on 
+     *  @param address      Local address to listen for incoming connections on
      *  @return             0 on success, negative on failure.
      */
     virtual int socket_bind(void *handle, const SocketAddress &address);
@@ -174,17 +218,22 @@ class ESP8266Interface : public NetworkStack, public WiFiInterface
     {
         return this;
     }
-    
+
 private:
     ESP8266 _esp;
     bool _ids[ESP8266_SOCKET_COUNT];
 
+    char ap_ssid[33]; /* 32 is what 802.11 defines as longest possible name; +1 for the \0 */
+    nsapi_security_t ap_sec;
+    uint8_t ap_ch;
+    char ap_pass[64]; /* The longest allowed passphrase */
+
     void event();
+
     struct {
         void (*callback)(void *);
         void *data;
     } _cbs[ESP8266_SOCKET_COUNT];
 };
 
-
 #endif