def wifiAsAp(): global wifi ap_if = WLAN(AP_IF) ap_if.active(True) ap_if.config(essid='hywcoinpo', channel=7, password='******') log.info('wifi as AP') wifi = ap_if
def create_wifi(): # type: () -> str ssid = "QRGames Player" ap = WLAN(AP_IF) ap.active(True) ap.config(essid=ssid) return ap.ifconfig()[0]
def setup_wifi(CLIENT_ID): AP = WLAN(AP_IF) AP.active(False) log("AP Down") STA = WLAN(STA_IF) STA.active(True) log("STA Up") STA.config(dhcp_hostname=CLIENT_ID) log("Config UP") connect_wifi(STA) return STA
def wlan_connect(wlan_essid, wlan_password, hostname: str = ""): from network import WLAN, STA_IF from utime import sleep nic = WLAN(STA_IF) if not nic.isconnected(): print("Connecting to network: ...") nic.active(True) if len(hostname) > 0: nic.config(dhcp_hostname=hostname) nic.connect(wlan_essid, wlan_password) while not nic.isconnected(): sleep(1) print("Network connected, the configuration: {}".format(nic.ifconfig()))
async def EnableAP(self, aMode: bool, aPassw=None): Log.Print(1, 'i', 'EnableAP() %s, %s ' % (aMode, aPassw)) R = WLAN(AP_IF) R.active(False) await sleep(1) R.active(aMode) if (aMode): R.config(essid='vRelay-' + GetMac(R)[-4:], authmode=AUTH_WPA_WPA2_PSK, password=aPassw) await self._WaitForReady(R.active) return R
def set_wifi(essid, pwd, timeout=60): console_write('[NW: STA] SET WIFI STA NW {}'.format(essid)) # Disable AP mode ap_if = WLAN(AP_IF) if ap_if.active(): ap_if.active(False) del ap_if # Set STA and Connect sta_if = WLAN(STA_IF) sta_if.active(True) # Set custom DHCP hostname sta_if.config(dhcp_hostname=cfgget('devfid')) # Check are we already connected if not sta_if.isconnected(): # Multiple essid and pwd handling with retry mechanism essid, pwd = __select_available_wifi_nw(sta_if, essid, pwd) # Connect to the located wifi network if essid is not None: console_write('\t| [NW: STA] CONNECT TO NETWORK {}'.format(essid)) # connect to network sta_if.connect(essid, pwd) # wait for connection, with timeout set while not sta_if.isconnected() and timeout > 0: console_write( "\t| [NW: STA] Waiting for connection... {} sec".format( timeout)) timeout -= 1 sleep_ms(500) # Set static IP - here because some data comes from connection. (subnet, etc.) if sta_if.isconnected() and __set_wifi_dev_static_ip(sta_if): sta_if.disconnect() del sta_if return set_wifi(essid, pwd) else: console_write( "\t| [NW: STA] Wifi network was NOT found: {}".format(essid)) return False console_write("\t|\t| [NW: STA] network config: " + str(sta_if.ifconfig())) console_write("\t|\t| [NW: STA] CONNECTED: " + str(sta_if.isconnected())) else: console_write("\t| [NW: STA] ALREADY CONNECTED TO {}".format(essid)) cfgput("devip", str(sta_if.ifconfig()[0])) set_dev_uid() return sta_if.isconnected()
def enable_ap_mode(essid=None, password=None): from network import AP_IF, AUTH_WPA_WPA2_PSK, WLAN from ubinascii import hexlify wifi_interface = WLAN(AP_IF) if not essid: essid = b"micropython-esp8266-%s" % hexlify( wifi_interface.config("mac")[-3:]) if not password: password = b'micropybootconfig' wifi_interface.config(essid=essid, authmode=AUTH_WPA_WPA2_PSK, password=password) del hexlify
def sys_config(): from network import WLAN global MyName,debug,debugDNS,runREPL,runDNS,runWeb,threaded from config import * from config import MyName,debug,debugDNS,runREPL,runDNS,runWeb,threaded wlan=WLAN() ip = wlan.ifconfig()[0] if(ip == "0.0.0.0"): ip = "192.168.4.1" apMode = wlan.config('essid') try: x = open("/client.cfg") x.close() apMode += " - Wifi Client Mode" except: apMode += " - AP Enabled" if(wlan.isconnected()): apMode += ' - Connected' content = "MyName:\t\t" + str(MyName) + "\n" content += "Network:\t" + apMode + "\n" content += "IP Address:\t" + ip + "\n" content += "debug\t\t" + str(debug) + "\n" content += "debugDNS\t" + str(debugDNS) + "\n" content += "runREPL\t\t" + str(runREPL) + "\n" content += "runDNS\t\t" + str(runDNS) + "\n" content += "runWeb\t\t" + str(runWeb) + "\n" content += "threaded\t" + str(threaded) + "\n" return(content)
class AccessPoint: def __init__(self): self.ap_if = WLAN(AP_IF) def get_ip(self): return self.ap_if.ifconfig()[0] def stop(self): self.ap_if.active(False) def start(self, essid, password): self.ap_if.active(True) if password: self.ap_if.config(essid=essid, password=password, authmode=4) else: self.ap_if.config(essid=essid, authmode=0)
class WifiAp: def __init__(self): self.ap = WLAN(AP_IF) def start_ap(self): if self.ap.active(): return self.ap.active(True) self.ap.config(essid=DEVICE_NAME, password=HW_PIN) while not self.ap.active(): sleep(1) def stop_ap(self): if self.ap.active(): self.ap.active(False) def get_info(self): if self.ap.active(): (ip, _, gw, _) = self.ap.ifconfig() return {'ip': ip, 'gw': gw} return None
def wlan_connect(): global oled wlan = WLAN(STA_IF) # create station interface wlan.active(True) # bring interface up if not wlan.isconnected(): oled.text('Connecting to network...', 0, 0) wlan.connect('SCOTTCAMPUS', 'mavericks') oled.text(wlan.config('essid'), 20, 35) oled.show() while not wlan.isconnected(): pass print('Network config:', wlan.ifconfig())
def set_access_point(_essid, _pwd, _authmode=3): console_write("[NW: AP] SET AP MODE: {} - {} - auth mode: {}".format( _essid, _pwd, _authmode)) sta_if = WLAN(STA_IF) if sta_if.isconnected(): sta_if.active(False) ap_if = WLAN(AP_IF) ap_if.active(True) # Set WiFi access point name (formally known as ESSID) and WiFi authmode (2): WPA2 try: console_write("[NW: AP] Configure") ap_if.config(essid=_essid, password=_pwd, authmode=_authmode) except Exception as e: console_write("[NW: AP] Config Error: {}".format(e)) if ap_if.active() and str(ap_if.config('essid')) == str( _essid) and ap_if.config('authmode') == _authmode: cfgput("devip", ap_if.ifconfig()[0]) console_write("\t|\t| [NW: AP] network config: " + str(ap_if.ifconfig())) set_uid_macaddr_hex(ap_if) return ap_if.active()
def sys_config_html(): from network import WLAN global MyName,debug,debugDNS,runREPL,runDNS,runWeb,threaded from config import * from config import MyName,debug,debugDNS,runREPL,runDNS,runWeb,threaded wlan=WLAN() ip = wlan.ifconfig()[0] if(ip == "0.0.0.0"): ip = "192.168.4.1" apMode = wlan.config('essid') try: x = open("/client.cfg") x.close() apMode += " - Wifi Client Mode" except: apMode += " - AP Enabled" if(wlan.isconnected()): apMode += ' - Connected' apMode += ' <a href="/config/toggleAP">(switch)</a>' content = "Network:\t" + apMode + "\n" content += "IP Address:\t" + ip + "\n" for n in ["MyName","debug","debugDNS","runREPL","runDNS","runWeb","threaded"]: pad = " " * (15 - len(n)) content += '<a href="/config/'+n+'">'+n+'</a>'+pad+ str(eval(n)) + "\n" return(content)
class Network(): def __init__(self): self.wlan = WLAN(STA_IF) self.ap = WLAN(AP_IF) def is_active(self): """Checking Active Module :return: boolean """ print("Check WLAN...") if self.wlan.active() is False: print("WLAN Non Active...") self.wlan.active(True) else: print("WLAN Active...") return True return False def connect(self, essid, password): """Connect To Network Keyword Arguments :param essid: the name essid :param password: the password :return: boolean """ if self.is_active(): print("Connecting....") self.wlan.connect(essid, password) if self.wlan.isconnected(): print("Connected...") return True else: print("Failed Connect...") else: self.is_active() def is_connected(self): """ Checking Connection :return: boolean """ res = self.wlan.isconnected() if res: print("Network Connected") else: print("Network Disconnected") return res def status(self): """ Checking status connection :return: boolean """ self.is_connected() print("Status : ", self.wlan.ifconfig()) def activate_ap(self, essid): if self.ap.active(): print('Access Point Active') self.ap.config(essid=essid, password='******') else: print('Access Point Non Active') self.ap.active(True) def deactivate_ap(self): self.ap.active(False) print('Deactivate Access Point')
from network import mDNS, ftp, telnet, AP_IF, STA_IF, WLAN from machine import idle mdns = mDNS() ap = WLAN(AP_IF) ap.active(True) ap.config(essid='Sparthan') ap.config(authmode=3, password='******') print('WLAN connection succeeded!') mdns.start('sparthan', 'MicroPython Sparthan ESP32') ftp.start(user='******', password='******') #telnet.start(user='******', password='******')
class WiFiManager: def __init__(self, manager, settings): self.manager = manager self.settings = settings # WIFI settings. self.stations = self.settings.get('networking.wifi.stations') self.station = None def start(self): """ https://docs.pycom.io/tutorials/all/wlan.html https://github.com/pycom/pydocs/blob/master/firmwareapi/pycom/network/wlan.md """ # Todo: Propagate more parameters here, e.g. for using an external antenna. self.station = WLAN() #if machine.reset_cause() == machine.SOFT_RESET: # print("WiFi STA: Network connection after SOFT_RESET.") # self.print_short_status() # # Inform about networking status. # self.print_address_status() # return True # Save the default ssid and auth for restoring AP mode later original_ssid = self.station.ssid() original_auth = self.station.auth() # Inform about networking status. self.print_address_status() # Setup network interface. self.station.init() # Check WiFi connectivity. if self.station.isconnected(): log.info( "WiFi STA: Network connection already established, will skip scanning and resume connectivity." ) self.print_short_status() # Give system some breath. time.sleep(0.25) # Inform about networking status. self.print_address_status() return True # Prepare information about known WiFi networks. networks_known = frozenset( [station['ssid'] for station in self.stations]) log.info("WiFi STA: Starting interface") self.station.mode(WLAN.STA) # Attempt to connect to known/configured networks. log.info("WiFi STA: Directly connecting to configured networks: %s", list(networks_known)) try: self.connect_stations(networks_known) except: log.warning('WiFi: Switching to AP mode not implemented yet') # Todo: Reenable WiFi AP mode in the context of an "initial configuration" mode. """ log.info('WiFi: Switching to AP mode') # WLAN.AP, original_ssid, original_auth, WLAN.INT_ANT # TOOD: Make default channel configurable self.station.init(mode=WLAN.AP, ssid=original_ssid, auth=original_auth, channel=6, antenna=WLAN.INT_ANT) """ def power_off(self): """ Power off all radio peripherals. - https://forum.pycom.io/topic/563/disabling-wifi-on-lopy - https://github.com/Hiverize/FiPy/commit/b6b15677 """ # WiFi if self.station: try: log.info('Turning off WiFi') self.station.deinit() except: log.exception('Turning off WiFi failed') def connect_stations(self, network_names): # Prepare information about known WiFi networks. network_map = {station['ssid']: station for station in self.stations} for network_name in network_names: try: # All the configuration details for this network. # { # 'ssid': 'FooBar', # 'password': '******', # 'ifconfig': ('192.168.42.42', '255.255.255.0', '192.168.42.1', '192.168.42.1'), # } network_selected = network_map[network_name] if self.connect_station(network_selected): break except Exception: log.exception( 'WiFi STA: Connecting to "{}" failed'.format(network_name)) if not self.station.isconnected(): self.forget_network(network_name) message = 'WiFi STA: Connecting to any network candidate failed' description = 'Please check your WiFi configuration for one of the ' \ 'station candidates {}.'.format(len(network_names)) log.error('{}. {}'.format(message, description)) log.warning( 'Todo: We might want to switch to AP mode here or alternatively ' 'buffer telemetry data to flash to be scheduled for transmission later.' ) raise WiFiException(message) def connect_station(self, network): network_name = network['ssid'] log.info('WiFi STA: Prepare connecting to network "{}"'.format( network_name)) auth_mode = self.get_auth_mode(network_name) log.info( 'WiFi STA: Attempt connecting to network "{}" with auth mode "{}"'. format(network_name, auth_mode)) password = network['password'] # TODO: Optionally, configure hostname. # https://docs.micropython.org/en/latest/library/network.WLAN.html # https://github.com/pycom/pycom-micropython-sigfox/pull/165 # https://forum.pycom.io/topic/3326/new-firmware-release-v1-18-0 if 'dhcp_hostname' in network: if hasattr(self.station, 'config'): log.ingo('WiFi STA: Using dhcp_hostname "{}"'.format( network['dhcp_hostname'])) self.station.config(dhcp_hostname=network['dhcp_hostname']) else: log.error('Could not set hostname on older MicroPython') # Optionally, configure static IP address. if 'ifconfig' in network: log.info( 'WiFi STA: Using static network configuration "{}"'.format( network_name)) self.station.ifconfig(config=network['ifconfig']) # Obtain timeout value. network_timeout = network.get('timeout', 15.0) # Set interval how often to poll for WiFi connectivity. network_poll_interval = 800 # Connect to WiFi station. log.info( 'WiFi STA: Starting connection to "{}" with timeout of {} seconds'. format(network_name, network_timeout)) self.station.connect(network_name, (auth_mode, password), timeout=int(network_timeout * 1000)) # Wait for station network to arrive. # ``isconnected()`` returns True when connected to a WiFi access point *and* having a valid IP address. retries = int(network_timeout * network_poll_interval) while not self.station.isconnected() and retries > 0: log.info( 'WiFi STA: Waiting for network "{}".'.format(network_name)) retries -= 1 # Save power while waiting. machine.idle() # Feed watchdog. self.manager.device.feed_watchdog() # Don't busy-wait. time.sleep_ms(network_poll_interval) if not self.station.isconnected(): raise WiFiException( 'WiFi STA: Unable to connect to "{}"'.format(network_name)) # Inform about networking status. self.print_short_status() self.print_address_status() return True def scan_stations(self): self.manager.device.feed_watchdog() # Inquire visible networks. log.info("WiFi STA: Scanning for networks") stations_available = self.station.scan() networks_found = frozenset([e.ssid for e in stations_available]) # Print names/SSIDs of networks found. log.info("WiFi STA: Networks available: %s", list(networks_found)) return stations_available # Compute set of effective networks by intersecting known with found ones. #network_candidates = list(networks_found & networks_known) #log.info("WiFi STA: Network candidates: %s", network_candidates) def get_ssid(self): return self.station.ssid() def get_ip_address(self): try: return self.station.ifconfig()[0] except: pass def get_auth_mode(self, network_name): # NVRAM key for storing auth mode per network. Maximum of 15 characters. auth_mode_nvs_key = self.auth_mode_nvs_key(network_name) # Get WiFi STA auth mode from NVRAM. try: import pycom auth_mode = pycom.nvs_get(auth_mode_nvs_key) log.info('WiFi STA: Auth mode from NVRAM with key=%s, value=%s', auth_mode_nvs_key, auth_mode) except: auth_mode = None # Fall back to find out WiFi STA auth mode by network scan. if auth_mode is None: log.info( 'WiFi STA: Unknown auth mode for network "%s", invoking WiFi scan', network_name) wifi_neighbourhood = self.scan_stations() #log.info('WiFi STA: Neighbourhood is %s', wifi_neighbourhood) for e in wifi_neighbourhood: if e.ssid == network_name: auth_mode = e.sec break if not auth_mode: message = 'WiFi STA: Unable to inquire auth mode for network "{}"'.format( network_name) log.warning(message) raise WiFiException(message) log.info( 'WiFi STA: Storing auth mode into NVRAM with key=%s, value=%s', auth_mode_nvs_key, auth_mode) try: import pycom pycom.nvs_set(auth_mode_nvs_key, auth_mode) except: log.exception('WiFi STA: Storing auth mode into NVRAM failed') return auth_mode def auth_mode_nvs_key(self, ssid): """ Hack to get a short representation of a WiFi SSID in order to squeeze it into a NVRAM key with a maximum length of 15 characters. Fixme: Review this. """ import hashlib import ubinascii digest = ubinascii.hexlify(hashlib.sha512(ssid).digest()).decode() identifier = 'wa.{}'.format(digest[15:27]) return identifier def forget_network(self, network_name): log.info('WiFi STA: Forgetting NVRAM data for network "{}"'.format( network_name)) auth_mode_nvs_key = self.auth_mode_nvs_key(network_name) try: import pycom pycom.nvs_erase(auth_mode_nvs_key) except: pass def print_short_status(self): log.info('WiFi STA: Connected to "{}" with IP address "{}"'.format( self.get_ssid(), self.get_ip_address())) def print_address_status(self): mac_address = self.humanize_mac_addresses(self.station.mac()) ifconfig = self.station.ifconfig() log.info('WiFi STA: Networking address (MAC): %s', mac_address) log.info('WiFi STA: Networking address (IP): %s', ifconfig) def humanize_mac_addresses(self, mac): info = {} if hasattr(mac, 'sta_mac'): info['sta_mac'] = format_mac_address( binascii.hexlify(mac.sta_mac).decode()) if hasattr(mac, 'ap_mac'): info['ap_mac'] = format_mac_address( binascii.hexlify(mac.ap_mac).decode()) return info def print_metrics(self): metrics = SystemWiFiMetrics(self.station).read() log.info('WiFi STA: Metrics: %s', metrics)
def mac(): from network import WLAN nw = WLAN() return nw.config('mac') # 5 bytes
class Wifi(ConfigOp): def __init__(self, hostname, pin=2): self.__wlan = None self.__timeout = DEFAULT_TMOUT self.__led = Relay(pin) self.is_ok = False self.gw = None self.ip = None self.dns = None ConfigOp.__init__(self, 'wifi', CONFIG_NAME) self.add_command(self.__get_info, GET) self.add_command(self.__reconnect, SET, 'reconnect') self.__hostname = hostname def is_connected(self): return self.__wlan != None and self.__wlan.isconnected() async def __get_info(self, _): v = self.get_info() await sleep(0) return result(200, None, v) async def __reconnect(self, _): delayed_task(5000, self.async_connect, (True), True) return result(200, None, RECONNECT_WIFI) async def __reload_config(self): # NOSONAR return await self.__reconnect(None) def get_info(self): return { "mac": MAC, "connected": self.is_connected(), "connection tested": self.is_ok, "hostname": self.__hostname, "ip": self.ip, "gw": self.gw, "dns": self.dns } def check_wifi_config(self): self.load() return not (self.__config is None or is_str_empty(self.__config[SSID]) or is_str_empty(self.__config[PASSWORD])) def disconnect(self): if self.__wlan is not None and self.__wlan.isconnected(): self.__wlan.disconnect() self.__wlan.active(False) async def async_connect(self, force_rec=False): if self.__wlan is not None and self.__wlan.isconnected(): if force_rec: self.disconnect() return await self.__async_connect() return True return await self.__async_connect() async def __async_connect(self): self.__connect_init() return await self.__async_connect_finish() async def __async_connect_finish(self): start_time = time() # Check time while not self.__wlan.isconnected(): await sleep_ms(DEFAULT_300) self.__led.on() await sleep_ms(DEFAULT_300) self.__led.off() if time() - start_time > self.__timeout: log.error("Wifi connection timeout: %d", self.__timeout) break return self.__set_properties() def __connect_init(self): self.check_wifi_config() if self.__config is None: log.error("Wifi config is None") return log.info("Connect to wifi: %s", self.__config[SSID]) self.__wlan = WLAN(STA_IF) # 创建 station 接口 if self.__wlan.isconnected(): self.__wlan.disconnect() self.__wlan.active(True) # Activate the interface self.__wlan.scan() # Scan self.__led.off() self.__wlan.config(dhcp_hostname=self.__hostname) self.__wlan.connect(self.__config[SSID], self.__config[PASSWORD]) # 连接到指定ESSID网络 if TIMEOUT in self.__config: self.__timeout = self.__config[TIMEOUT] def __set_properties(self): if self.__wlan.isconnected(): log.info('network information: %r', self.__wlan.ifconfig()) (self.ip, _, self.gw, self.dns) = self.__wlan.ifconfig() self.is_ok = True self.__led.on() else: self.ip = None self.gw = None self.dns = None self.is_ok = False self.__wlan = None self.__led.off() return self.is_ok def check_connection(self): if hw.WIFI_CHECK_TYPE == 0: return True if not self.is_connected(): return False if hw.WIFI_CHECK_TYPE == 1: return True dest = self.gw if hw.WIFI_CHECK_TYPE == 3: if WIFI_CHECK_HOST in self.__config != None: dest = self.__config[WIFI_CHECK_HOST] else: dest = hw.WIFI_CHECK_HOST return ping_check(dest) async def monitor(self): log.debug("Setup wifi monitor") while hw.WIFI: try: await sleep(hw.WIFI_CHECK_INTVAL) if not self.check_connection(): log.info("Wifi is not ready, reconnecting...") await self.async_connect(True) except: #NOSONAR # pylint: disable=W0702 pass
wlan.connect(net.ssid, auth=(net.sec, networks[net.ssid]), timeout=5000) while not wlan.isconnected(): machine.idle() # save power while waiting print("WLAN: connected to " + net.ssid + " with IP address:" + wlan.ifconfig()[0]) break else: print("WLAN: auto-connected") elif HARDWARE == 'esp32': print("ESP32") import network wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.config(dhcp_hostname='hpwc') if not wlan.isconnected(): print("WLAN: scanning for known network") nets = wlan.scan() for net in nets: print('Found network: ', net) ssid = net[0].decode() if ssid in networks: print('WLAN: attempting to connect to "%s"' % ssid) wlan.connect(ssid, networks[ssid]) while not wlan.isconnected(): machine.idle() # save power while waiting print("WLAN: connected to " + ssid + " with IP address:" + wlan.ifconfig()[0]) break else:
class WifiManager: def __init__(self, essid=None): self.local_ip = AP_IP self.sta_if = WLAN(STA_IF) self.ap_if = WLAN(AP_IF) if essid is None: essid = b"ESP8266-%s" % binascii.hexlify(self.ap_if.config("mac")[-3:]) self.essid = essid self.creds = Creds() # Turn off station and AP interface to force a reconnect self.sta_if.active(True) self.ap_if.active(False) self.loop = asyncio.get_event_loop() self.loop.create_task(self.check_wifi()) async def start_access_point(self): while not self.ap_if.active(): self.ap_if.active(True) await asyncio.sleep(1) # IP address, netmask, gateway, DNS self.ap_if.ifconfig( (self.local_ip, "255.255.255.0", self.local_ip, self.local_ip) ) self.ap_if.config(essid=self.essid, authmode=AUTH_OPEN) print("> AP mode configured: {} ".format(self.essid.decode("utf-8")), self.ap_if.ifconfig()) async def check_wifi(self): while True: self.loop.create_task(self.connect(True)) if self.creds.load().is_valid(): await asyncio.sleep(WAIT_FOR_CONNECT) if not self.sta_if.isconnected(): self.loop.create_task(self.start_access_point()) while not self.sta_if.isconnected(): await asyncio.sleep(1) self.ap_if.active(False) while self.sta_if.isconnected(): await asyncio.sleep(1) async def connect(self, autoLoop=False): if not self.sta_if.isconnected(): if self.creds.load().is_valid(): print("> Connecting to {:s}/{:s}".format(self.creds.essid, self.creds.password)) self.sta_if.connect(self.creds.essid, self.creds.password) await asyncio.sleep(WAIT_FOR_CONNECT) if not self.sta_if.isconnected(): print("> Connection failed. WLAN status={:d}".format(self.sta_if.status())) if autoLoop: self.loop.create_task(self.connect(True)) else: print("> No valid credentials file: {}".format(Creds.CRED_FILE))
class Connection: def __init__(self): # Scan networks in surrounding self._ifc = WLAN(STA_IF) if not self._ifc.active(True): raise RuntimeError("WiFi activation failed") sc = self._ifc.scan() self.nets = [] for n in sc: self.nets.append(Wifi(n[0].decode(), n[1])) self._ifc.active(False) # Start requested variant of connection if jumpers.hotspot: self._hotspot() else: self._attach() def _attach(self): # Activate WiFi interface self._ifc = WLAN(STA_IF) if not self._ifc.active(True): raise RuntimeError("WiFi activation failed") # Search first based on BSSID network = None for n in self.nets: for c in connection: if n.bssid == c.bssid: network = c break else: continue break # Repeat the same for SSID if BSSID was not found if network is None: for n in self.nets: for c in connection: if n.ssid == c.ssid: network = c break else: continue break # Checks if we have something and connect to WiFi if network is None: raise RuntimeError("No know WiFi found!") self.config = network self._ifc.connect(network.ssid, network.passwd, bssid=network.bssid) for i in range(8): if self._ifc.isconnected(): log("Connected: " + str(self.ifconfig)) self.is_hotspot = False return sleep(1) raise RuntimeError("Wifi connection refused") def _hotspot(self): # Create hotspot to be able to attach by FTP and configure meteostation self._ifc = WLAN(AP_IF) self._ifc.active(True) self._ifc.config(essid=hotspot.ssid, password=hotspot.passwd, authmode=3) while self._ifc.active() == False: sleep(1) self.is_hotspot = True log("Running hotspot: " + str(self.ifconfig)) @property def ifconfig(self): return self._ifc.ifconfig() def http_get_json(self, url): log("HTTP GET: " + url) for retry in range(CONN_RETRY_CNT): try: return urequests.get(url).json() collect() return except OSError as e: log('ECONNRESET -> retry') if e.errno == ECONNRESET: continue raise e def disconnect(self): WLAN(STA_IF).active(False) WLAN(AP_IF).active(False) self._ifc = None
from network import WLAN, AP_IF, AUTH_WPA_WPA2_PSK from webrepl import start start() ap_if = WLAN(AP_IF) ap_if.active(True) ap_if.config(essid='ESP32', authmode=AUTH_WPA_WPA2_PSK, password='******')
class WifiManager: ip = "0.0.0.0" ssids = [] ssids_timestamp = 0 def __init__(self, ap_essid=None): self.sta_if = WLAN(STA_IF) self.ap_if = WLAN(AP_IF) self.sta_if.active(False) self.sta_if.active(True) if ap_essid is None: ap_essid = b"ESP8266-%s" % hexlify(self.ap_if.config("mac")[-3:]) self.ap_essid = ap_essid self.credentials = Credentials() # Turn off station and AP interface to force a reconnect self.sta_if.active(True) self.ap_if.active(False) self.loop = get_event_loop() self.loop.create_task(self.check_wifi()) async def check_wifi(self): while True: self.loop.create_task(self.connect(True)) if self.credentials.load().is_valid(): await sleep_ms(WAIT_FOR_CONNECT) if not self.sta_if.isconnected(): self.loop.create_task(self.start_access_point()) while not self.sta_if.isconnected(): await sleep_ms(CHECK_CONNECTED) self.ip = self.sta_if.ifconfig()[0] Blink().flash3TimesFast() print("> Connected to {} with IP: {}".format( self.credentials.essid.decode("ascii"), self.ip)) if self.ap_if.active(): # Leave a bit of time so the client can retrieve the Wifi IP address await sleep_ms(WAIT_BEFORE_AP_SHUTDOWN) print("> Shuting down AP") self.ap_if.active(False) while self.sta_if.isconnected(): await sleep_ms(CHECK_CONNECTED) async def start_access_point(self): self.ap_if.active(True) while not self.ap_if.active(): await sleep_ms(CHECK_CONNECTED) self.ip = AP_IP # IP address, netmask, gateway, DNS self.ap_if.ifconfig((self.ip, "255.255.255.0", self.ip, self.ip)) self.ap_if.config(essid=self.ap_essid, authmode=AUTH_OPEN) print( "> AP mode configured: {} ".format(self.ap_essid.decode("utf-8")), self.ap_if.ifconfig(), ) async def connect(self, autoLoop=False): if not self.sta_if.isconnected() or not autoLoop: if self.credentials.load().is_valid(): print("> Connecting to {:s}/{:s}".format( self.credentials.essid, self.credentials.password)) self.sta_if.active(False) self.sta_if.active(True) self.sta_if.connect(self.credentials.essid, self.credentials.password) await sleep_ms(WAIT_FOR_CONNECT) if not self.sta_if.isconnected(): if autoLoop: await sleep_ms(WAIT_BEFORE_RECONNECT) self.loop.create_task(self.connect(True)) else: print("> No valid credentials file: {}".format(FILE)) def set_ap_essid(self, ap_essid): self.ap_essid = ap_essid def get_ssids(self): now = ticks_ms() if len(self.ssids) == 0 or now > self.ssids_timestamp + 1000 * 30: ssids = self.sta_if.scan() self.ssids_timestamp = now self.ssids = [] for ssid in ssids: self.ssids.append('"%s"' % ssid[0].decode("ascii")) self.ssids.sort() return b'{"ssids": [%s]}' % (",".join(self.ssids))
def connect_to_network(): """ connect to a network and disable the access point """ from network import WLAN, STA_IF, AP_IF from miscellaneous import read_json sta_if = WLAN(STA_IF) # wifi station (connect to router) ap_if = WLAN(AP_IF) # wifi access point (like a router) if read_json( "data/config")["network"]["networkStation"]["enabled"] is True: warning("Network station will be enabled") if sta_if.isconnected(): # check if you're already connected message('Already connected to network') while not sta_if.isconnected(): message('Connecting to network...') sta_if.active(True) # enable the station if read_json("data/config")["network"]["networkStation"][ "homeNetwork"] is True: # check if you want to # connect to home wifi warning("Using home network") sta_if.connect('Hackercollective', 'w6HSB2S3bb042') # let station connect to wifi else: # connect to custom wifi warning("Using custom network config") ssid = read_json("data/config")["network"]["networkStation"][ "customSSID"] # read custom wifi ssid # from json password = read_json("data/config")["network"][ "networkStation"]["customNetworkPassword"] # read # custom password from json sta_if.connect(ssid, password) # let station connect to wifi from time import time # import time to make a timer start_time = time( ) + 120 # make timer (last value is how long the timer in ms) while not sta_if.isconnected(): # wait to be connected if time() == start_time: # check if timer is over break message('Network config:' + str(sta_if.ifconfig())) message('The ip is ' + str(sta_if.ifconfig()[0])) else: warning("Network station will be disabled") sta_if.active(False) # enable network station if read_json("data/config")["network"]["accessPoint"][ "enabled"] is True: # check if you want an access point in # config warning("Access point will be enabled") ap_if.active(True) # disable access point ap_if.config( essid=read_json("data/config")["network"]["accessPoint"] ["SSID"], # set password and ssid of password=read_json("data/config")["network"]["accessPoint"] ["password"]) # the access point else: warning("Access point will be disabled") ap_if.active(False) # enable access point
def wifiAPpassword(pw=None): from network import WLAN, AP_IF, AUTH_WPA_WPA2_PSK AP = WLAN(AP_IF) AP.config(essid=STSSID, authmode=AUTH_WPA_WPA2_PSK, password=pw if pw else STSSIDPW)
active = wifi.active(True) log.info('WIFI_SSID={}'.format(config.WIFI_SSID)) log.info('WIFI_PASS={}'.format(config.WIFI_PASS)) connect = wifi.connect(config.WIFI_SSID,config.WIFI_PASS) # wait until the device is connected to the WiFi network MAX_ATTEMPTS = 20 attempt_count = 0 while not wifi.isconnected() and attempt_count < MAX_ATTEMPTS: attempt_count += 1 log.info('z.') sleep(1) if attempt_count == MAX_ATTEMPTS: log.error('The flag pole is broken.') log.info('connect={}'.format(connect)) # Get mac address mac = hexlify(wifi.config('mac'),':').decode() log.info('mac={}'.format(mac)) # clean up this mess del hexlify del WLAN del AP_IF del STA_IF del ap_if del active del connect del MAX_ATTEMPTS del attempt_count del wifi collect() ##############################################################################
class WiFi: RECONNECT_TIMEOUT = 10 def __init__(self, config, verbose=0): self.verbose = verbose self.config = config self.__connecting = False self.connect_start = None self.station = WLAN(STA_IF) def __repr__(self): return '<WiFi: {}, {} at {:x}>'.format(self.station.config('essid'), self.station.ifconfig(), id(self)) def device_id(self): import ubinascii return ubinascii.hexlify(self.station.config('mac'), ':').decode().upper() def connecting(self): return self.__connecting def connected(self): return self.station.isconnected() def connect(self): if self.__connecting: if self.station.isconnected(): self.__connecting = False self.connect_start = None elif (time() - self.connect_start) > self.RECONNECT_TIMEOUT: # self.station.active(False) self.__connecting = False self.connect_start = time() if self.verbose: print('-> ' 'Connect ' 'timeout') elif self.station.isconnected() is False: if self.connect_start is None or ( time() - self.connect_start) > self.RECONNECT_TIMEOUT: if self.verbose: if self.connect_start is None: print('-> ' 'Reconnect ' 'timer started') else: print('-> ' 'Reconnect ' 'timeout') self.connect_start = time() else: return False self.station.active(True) ssid, password = self.scan() if self.verbose: print('[{}] [{}]'.format(ssid, password)) if ssid: self.station.connect(ssid, password) sleep(1) self.__connecting = True return True return False def disconnect(self): self.station.disconnect() def scan(self): ssid, password = None, None ap_scan = self.station.scan() ap_list = [] for ap in ap_scan: for ssid_mask, password in self.config['wifi']: mask = '^{}$'.format(ssid_mask) if search(mask, ap[0]): ap_list.append((ap[3], ap[0], password)) ap_list.sort(reverse=True) if self.verbose: for ap in ap_list: print(ap) if len(ap_list): ssid, password = ap_list[0][1], ap_list[0][2] return ssid, password
from machine import Pin from machine import UART import network from network import WLAN from utime import sleep_ms SERVANT_IP = "192.168.169.1" SERVANT_PORT = 18788 REMOTE_IP = "192.168.169.2" REMOTE_PORT = 11686 # setup access point ACCESS_POINT = WLAN(network.AP_IF) ACCESS_POINT.active(False) ACCESS_POINT.config(essid="Headrush Servant", authmode=4, password="******", hidden=True) ACCESS_POINT.ifconfig( (SERVANT_IP, "255.255.255.0", "192.168.178.1", "8.8.8.8")) ACCESS_POINT.active(True) _STATUS_LED = Pin(23, Pin.OUT, Pin.PULL_UP) _STATUS_LED.value(1) # some general setup _MIDI_TX_PIN = 18 _COMMAND_MAP = { b"button_rig_up": (49).to_bytes(1, "big"), b"button_rig_down": (55).to_bytes(1, "big"), b"button_scene1": (56).to_bytes(1, "big"),
import utils, usocket as socket, os from network import WLAN, AP_IF ap = WLAN(AP_IF) ap.config(essid=utils.get_machine_id(), channel=11) ap.active(True) print('Wifi connected:', ap.ifconfig()) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(('', 80)) s.listen(5) def process_file(conn, addr): path = conn.recv(4096).decode('ascii') utils.mkdir(path) file = conn.recv(4096) with open(path, 'wb') as f: f.write(file) conn.close() while 1: conn, addr = s.accept() process_file(conn, addr) print('got a connection from {}'.format(str(addr)))
def enable_ap_mode(essid=None, password=None): from network import AP_IF, AUTH_WPA_WPA2_PSK, WLAN from ubinascii import hexlify wifi_interface = WLAN(AP_IF) if not essid: essid = b"micropython-esp8266-%s" % hexlify(wifi_interface.config("mac")[-3:]) if not password: password = b'micropybootconfig' wifi_interface.config(essid=essid, authmode=AUTH_WPA_WPA2_PSK, password=password) del hexlify