Mbed OS Reference | EMW3080BInterface.h Source File

 /* EMW3080B implementation of NetworkInterfaceAPI
  * Copyright (c) STMicroelectronics 2021
  * SPDX-License-Identifier: Apache-2.0
  *
  * 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.
  */
 
 #ifndef EMW3080B_INTERFACE_H
 #define EMW3080B_INTERFACE_H
 
 #if defined(MBED_CONF_NSAPI_PRESENT)
 
 #include <inttypes.h>
 
 #include "mbed.h"
 #include "mbed_debug.h"
 #include "mx_wifi.h"
 #include "netsocket/WiFiInterface.h"
 #include "netsocket/EMACInterface.h"
 #include "netsocket/OnboardNetworkStack.h"
 #include "EMW3080B_EMAC.h"
 
 
 /** EMW3080BInterface class
  *  Implementation of the NetworkStack for the EMW3080B
  */
 class EMW3080BInterface : public WiFiInterface, public EMACInterface  {
 public:
     EMW3080BInterface(bool debug = MBED_CONF_EMW3080B_WIFI_DEBUG,
                       PinName mosi   = MBED_CONF_EMW3080B_WIFI_MOSI,
                       PinName miso   = MBED_CONF_EMW3080B_WIFI_MISO,
                       PinName sclk   = MBED_CONF_EMW3080B_WIFI_SCLK,
                       PinName nss    = MBED_CONF_EMW3080B_WIFI_NSS,
                       PinName notify = MBED_CONF_EMW3080B_WIFI_NOTIFY,
                       PinName flow   = MBED_CONF_EMW3080B_WIFI_FLOW,
                       PinName reset  = MBED_CONF_EMW3080B_WIFI_RESET,
                       PinName tx     = MBED_CONF_EMW3080B_WIFI_TX,
                       PinName rx     = MBED_CONF_EMW3080B_WIFI_RX,
                       EMAC &emac      = EMW3080B_EMAC::get_instance(),
                       OnboardNetworkStack &stack = OnboardNetworkStack::get_default_instance()
                      );
 
     /** Start the interface
      *
      *  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
      */
     nsapi_error_t 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
      */
     nsapi_error_t connect(const char *ssid, const char *pass, nsapi_security_t security = NSAPI_SECURITY_NONE, uint8_t channel = 0);
 
     /** Stop the interface
      *  @return             0 on success, negative on failure
      */
     nsapi_error_t disconnect();
 
     /** 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
      *                   (defaults to NSAPI_SECURITY_NONE)
      *  @return          0 on success, or error code on failure
      */
     nsapi_error_t 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
      */
     nsapi_error_t set_channel(uint8_t channel)
     {
         if (channel != 0) {
             return NSAPI_ERROR_UNSUPPORTED;
         }
 
         return 0;
     }
 
     /** Gets the current radio signal strength for active connection
      *
      * @return          Connection strength in dBm (negative value)
      */
     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
      */
     int scan(WiFiAccessPoint *res, unsigned count);
 
     MX_WIFIObject_t MxWifiObj;
 
 private:
 
     nsapi_security_t emw_sec2nsapi_sec(mwifi_security_t sec)
     {
         nsapi_security_t sec_out;
 
         switch (sec) {
             case MX_WIFI_SEC_NONE:
                 sec_out = NSAPI_SECURITY_NONE;
                 break;
             case MX_WIFI_SEC_WEP:
                 sec_out = NSAPI_SECURITY_WEP;
                 break;
             case MX_WIFI_SEC_WPA_AES:
             case MX_WIFI_SEC_WPA_TKIP:
                 sec_out = NSAPI_SECURITY_WPA;
                 break;
             case MX_WIFI_SEC_WPA2_AES:
             case MX_WIFI_SEC_WPA2_TKIP:
             case MX_WIFI_SEC_WPA2_MIXED:
                 sec_out = NSAPI_SECURITY_WPA2;
                 break;
             case MX_WIFI_SEC_AUTO:
                 sec_out = NSAPI_SECURITY_WPA_WPA2;
                 break;
             default:
                 sec_out = NSAPI_SECURITY_WPA_WPA2;
                 break;
 
         }
         return sec_out;
     }
 
     MX_WIFI_SecurityType_t nsapi_sec2emw_sec(nsapi_security_t sec)
     {
         MX_WIFI_SecurityType_t mx_sec;
 
         switch (sec) {
             case NSAPI_SECURITY_NONE:
                 mx_sec = MX_WIFI_SEC_NONE;
                 break;
             case NSAPI_SECURITY_WEP:
                 mx_sec =  MX_WIFI_SEC_WEP;
                 break;
             case NSAPI_SECURITY_WPA:
                 mx_sec =  MX_WIFI_SEC_WPA_AES;
                 break;
             case NSAPI_SECURITY_WPA2:
                 mx_sec =  MX_WIFI_SEC_WPA2_AES;
                 break;
             default:
                 mx_sec =  MX_WIFI_SEC_AUTO;
                 break;
         }
 
         return mx_sec;
     }
 
     /* MXCHIP array size for SCAN is 2KB , so limits number of AP to 20 */
 #define      MAX_AP_COUNT    20
 
 
     int8_t   IO_Init(uint16_t mode);
     int8_t   IO_DeInit(void);
     void     IO_Delay(uint32_t delayms);
     uint16_t IO_Send(uint8_t *data, uint16_t len);
     uint16_t IO_Receive(uint8_t *buffer, uint16_t buff_size);
 
     void probe(void);
     void release(void);
     char                     _ssid[33]; /* The longest possible name (defined in 802.11) +1 for the \0 */
     char                     _pass[64]; /* The longest allowed passphrase + 1 */
     mwifi_ap_info_t          _ap_info[MAX_AP_COUNT];
     MX_WIFI_SecurityType_t   _sec;
     volatile  bool          _isConnected;
     Mutex                   _mutex;
 
     uint8_t _debug_level;
 };
 
 #endif /* MBED_CONF_NSAPI_PRESENT */
 
 #endif /* EMW3080B_INTERFACE_H */
Important Information for this Arm website
