def exp_start(): global stats global detailed_stats global run_stats wlan = WLAN(mode=WLAN.STA) print(ubinascii.hexlify(wlan.mac(), ':').decode()) if not wlan.isconnected(): wlan.connect(ssid='rasp', auth=(WLAN.WPA2, 'lalalala'), timeout=5000) while not wlan.isconnected(): machine.idle() print("I got IP" + wlan.ifconfig()[0]) host = wlan.ifconfig()[0] port = 8000 wlan_s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) print("socket created") wlan_s.bind((host, port)) wlan_s.listen(5) print("Waiting for initialization...") _thread.start_new_thread(receive_stats, ()) while (True): conn, addr = wlan_s.accept() print('Got connection from', addr) data = conn.recv(512) data = str(data)[2:][:-1] if (len(data) > 10): try: (init, ip, pkts) = data.split(":") if (init == "init"): pycom.rgbled(red) msg = ip + ":" + pkts run_stats = 0 time.sleep(1) lora.init(mode=LoRa.LORA, tx_iq=True, region=LoRa.EU868, frequency=freqs[0], power_mode=LoRa.TX_ONLY, bandwidth=LoRa.BW_125KHZ, sf=12) pkg = struct.pack(_LORA_PKG_FORMAT % len(msg), MY_ID, len(msg), msg) # lora_sock.send(pkg) for j in range(3): lora_sock.send(pkg) time.sleep(1) lora.init(mode=LoRa.LORA, rx_iq=True, region=LoRa.EU868, frequency=freqs[7], power_mode=LoRa.ALWAYS_ON, bandwidth=LoRa.BW_125KHZ, sf=12) pycom.rgbled(green) run_stats = 1 stats = [] detailed_stats = [] _thread.start_new_thread(receive_stats, ()) except: print("wrong packet format!")
from network import WLAN import ubinascii wl = WLAN() ubinascii.hexlify(wl.mac())[:6] + 'FFFE' + ubinascii.hexlify(wl.mac())[6:]
wlan = WLAN(mode=WLAN.STA) pycom.rgbled(0xFF8C00) wlan.connect(ssid=SSID, auth=(WIFI_SECURITY, WIFI_PASSWORD)) print('Connecting to Wifi') while not wlan.isconnected(): machine.idle() print('Wifi connection succeded!') pycom.rgbled(0xFF00FF) print('Connecting to MQTT...\n') client_id = 'pytrack_{}'.format(hexlify(wlan.mac()).decode('utf-8')) pycom.rgbled(0x001400) py = Pytrack() li = LIS2HH12(py) # after 240 seconds of waiting without a GPS fix it will # return None, None gnss = L76GNSS(py, timeout=10) while True: pycom.rgbled(0x000014) print('\n\n** 3-Axis Accelerometer (LIS2HH12)') acceleration = li.acceleration()
from network import WLAN import binascii wl = WLAN() gate_id = binascii.hexlify(wl.mac())[:6] + 'FFFE' + binascii.hexlify(wl.mac())[6:] print(gate_id)
from network import WLAN import binascii wl = WLAN() x = binascii.hexlify(wl.mac())[:6] + 'FFFE' + binascii.hexlify(wl.mac())[6:] print(x)
wlan.connect(config.WIFI_SSID, auth=(None, config.WIFI_PASS), timeout=5000) while not wlan.isconnected(): time.sleep(0.5) print('WLAN connection succeeded!') time.sleep(2) gc.enable # setup rtc rtc = machine.RTC() rtc.ntp_sync("pool.ntp.org") utime.sleep_ms(750) print(rtc.now()) # get MAC address as the device ID deviceID = binascii.hexlify(wlan.mac()) #py = Pytrack() #l76 = L76GNSS(py, timeout=30) # user specified callback function def customCallback(client, userdata, message): print("Received a new message: ") print(message.payload) print("from topic: ") print(message.topic) print("--------------\n\n") # configure the MQTT client
from network import WLAN from mqtt import MQTTClient import machine import time import ubinascii import configMQTT def settimeout(duration): pass wlan = WLAN(mode=WLAN.STA) # classical mac writing convention print("mac address = " + ubinascii.hexlify(wlan.mac().sta_mac, ':').decode()) strID = ubinascii.hexlify(wlan.mac().sta_mac, '').decode() # hostname from the 4 last characters hostNameID = ("N" + strID[-5:]).upper() print("hostname = " + hostNameID) wlan.connect(configMQTT.WIFI_SSID, auth=(WLAN.WPA2, configMQTT.WIFI_PASS), timeout=5000) while not wlan.isconnected(): machine.idle() print("Connected to Wifi\n") client = MQTTClient("demo", configMQTT.MQTT_SERVER, port=1883) client.settimeout = settimeout
class WifiManager: def __init__(self, jsonfile): # Load configuration from config JSON file. # wificonfig.json contans the network settings # STATIC_IP is 'None' or empty string -> use dynamic IP self._config = self.readjson(jsonfile) # create network in STAtion mode # pycom: device always starts up in AP-mode self._wlan = WLAN(mode=WLAN.STA) if USE_DEBUG: print('WifiManager::WLAN mode:', self._wlan.mode()) # pycom: 1=STA, 2=AP) def readjson(self, jsonfile): """readjson(file) - returns the contents of file in JSON-format""" with open(jsonfile, 'r') as infile: config = json.load(infile) if USE_DEBUG: print('WifiManager::JSON settings: {}'.format(config)) return config # pycom connect def connect(self): """connect() - connects device according to network parameters in JSON-file.""" self._wlan = WLAN() # get current object, without changing the mode # skip connecting, when a soft-reset is performed if machine.reset_cause() != machine.SOFT_RESET: self._wlan.init(mode=WLAN.STA) # configuration below MUST match your home router settings!! # IP, Subnet, Gateway, DNS if self._config['STATIC_IP'] is None: if USE_DEBUG: print('WifiManager::Static IP configuration for SSID: ', self._config['SSID']) self._wlan.ifconfig(config=(self._config['STATIC_IP'], self._config['MASKER'], self._config['GATEWAY_IP'], self._config['DNS'])) else: if USE_DEBUG: print('WifiManager::Dynamic IP configuration for SSID: ', self._config['SSID']) pass # connect to Wifi if USE_DEBUG: print('WifiManager::isconnected:', self._wlan.isconnected()) if not self._wlan.isconnected(): if USE_DEBUG: print( "WifiManager::start '{0}' to connect to '{1}' with IP '{2}'" .format(self._config['IDENTITY'], self._config['SSID'], self._config['STATIC_IP'])) # change the line below to match your network ssid, security and password self._wlan.connect(self._config['SSID'], auth=(WLAN.WPA2, self._config['PASSWRD']), timeout=5000) while not self._wlan.isconnected(): machine.idle() # save power while waiting # connected, return network config return self._wlan.ifconfig() # wrapper for disconnecting network def disconnect(self): """disconnect() - de-activate network interface, but leaves Wifi radio on""" self._wlan.disconnect( ) # pycom - disconnect from Wifi, but leave Wif radio on. if USE_DEBUG: print('WifiManager::Wifi disconnected') # wrapper for disabling Wifi radio def deinit(self): """deinit() - disable Wifi radio""" self._wlan.deint() # pycom if USE_DEBUG: print('WifiManager::Wifi radio off') # wrapper for network scan def scan(self): """scan() - Performs a network scan and returns a list of named tuples with (ssid, bssid, sec, channel, rssi) """ return self._wlan.scan() # wrapper for wlan.isconnected() @property def isconnected(self): """isconnected() - returns if connected to Wifi (True) or not (False)""" return self._wlan.isconnected() def print_config(self): """print_config() - print config data on screen.""" for key in self._config.keys(): print('[{0}] = {1}'.format(key, self._config[key])) def change_access(self, user=None, passwrd=None): """change_access - change password for telnet and ftp access""" if (user is None) or (passwrd is None): print('WifiManager:: username and password must be specified') return server = Server() # from network # disable the server server.deinit() # enable the server again with new credentials # for example: remote access, ftp and telnet, not USB server.init(login=(user, passwrd), timeout=600) if USE_DEBUG: print('WifiManager::password {} is changed...'.format(user)) @property def __config(self): """returns config tuple""" return self._config @property def mac(self): """returns MAC-address of device""" mac = hexlify(self._wlan.mac(), ':').decode() # pycom # return (mac) # lower case return mac.upper()
from network import WLAN import binascii wl = WLAN() print("Gateway EUI: {}".format( binascii.hexlify(wl.mac())[:6] + 'fffe' + binascii.hexlify(wl.mac())[6:]))
class MicroWifi: # ============================================================================ # ===( Constants )============================================================ # ============================================================================ _ETH_AP = 1 _ETH_STA = 0 _IP_NONE = '0.0.0.0' _DEFAULT_AUTH_TYPE = WLAN.WPA2 _AP_MASK = '255.255.255.0' _DEFAULT_TIMEOUT_SEC = 10 # ============================================================================ # ===( Utils )=============================================================== # ============================================================================ @staticmethod def _mac2Str(binMac): return hexlify(binMac, ':').decode().upper() # ---------------------------------------------------------------------------- def _setAPInfos(self, ssid=None, key=None, ip=None, mask=None, gateway=None, dns=None): self._apInfos = { 'ssid': ssid, 'key': key, 'ip': ip, 'mask': mask, 'gateway': gateway, 'dns': dns } # ---------------------------------------------------------------------------- def _setConnectionInfos(self, bssid=None, ssid=None, key=None, ip=None, mask=None, gateway=None, dns=None): self._connInfos = { 'macBssid': bssid, 'ssid': ssid, 'key': key, 'ip': ip, 'mask': mask, 'gateway': gateway, 'dns': dns } # ---------------------------------------------------------------------------- def _openConf(self): try: with open(self._filePath, 'r') as jsonFile: self._confObj = load(jsonFile) except: self._confObj = {} if self._confObj.get('STA', None) is None: self._confObj['STA'] = {} # ---------------------------------------------------------------------------- def _writeConf(self): try: jsonStr = dumps(self._confObj) try: mkdir(self._confPath) except: pass jsonFile = open(self._filePath, 'wb') jsonFile.write(jsonStr) jsonFile.close() return True except: return False # ============================================================================ # ===( Constructor )========================================================== # ============================================================================ def __init__(self, confName="wifi", confPath="/flash/conf", useExtAntenna=False): self._confPath = confPath self._filePath = '%s/%s.json' % (confPath, confName) self._wlan = WLAN() self._antenna = WLAN.EXT_ANT if useExtAntenna else WLAN.INT_ANT self._openConf() self._setAPInfos() self._setConnectionInfos() self._wlan.init(antenna=self._antenna) self.DisableRadio() # ============================================================================ # ===( Functions )============================================================ # ============================================================================ def DisableRadio(self): self.CloseAccessPoint() self.CloseConnectionToAP() self._wlan.deinit() # ---------------------------------------------------------------------------- def GetMACAddr(self): return self._mac2Str(self._wlan.mac()) # ---------------------------------------------------------------------------- def GetAPInfos(self): if not self.IsAccessPointOpened(): self._setAPInfos() return self._apInfos # ---------------------------------------------------------------------------- def GetConnectionInfos(self): if not self.IsConnectedToAP(): self._setConnectionInfos() return self._connInfos # ---------------------------------------------------------------------------- def ScanAP(self): try: if self._wlan.mode() == WLAN.STA: self._wlan.init(antenna=self._antenna) return self._wlan.scan() except: return () # ---------------------------------------------------------------------------- def OpenAccessPoint(self, ssid, key=None, ip='192.168.0.254', autoSave=True): if ssid and ip: try: self._wlan.ifconfig(id=self._ETH_AP, config=(ip, self._AP_MASK, ip, ip)) auth = (self._DEFAULT_AUTH_TYPE, key) if key else None self._wlan.init(mode=WLAN.STA_AP, ssid=ssid, auth=auth, antenna=self._antenna) print("WIFI ACCESS POINT OPENED :") print(" - MAC address : %s" % self.GetMACAddr()) print(" - Network SSID : %s" % ssid) print(" - IP address : %s" % ip) print(" - Mask : %s" % self._AP_MASK) print(" - Gateway IP : %s" % ip) print(" - DNS server : %s" % ip) if autoSave: self._confObj['AP'] = {'ssid': ssid, 'key': key, 'ip': ip} self._writeConf() self._setAPInfos(ssid, key, ip, self._AP_MASK, ip, ip) return True except: self.CloseAccessPoint() return False # ---------------------------------------------------------------------------- def OpenAccessPointFromConf(self): try: ssid = self._confObj['AP']['ssid'] key = self._confObj['AP']['key'] ip = self._confObj['AP']['ip'] return self.OpenAccessPoint(ssid, key, ip, False) except: return False # ---------------------------------------------------------------------------- def RemoveAccessPointFromConf(self): try: del self._confObj['AP'] return self._writeConf() except: return False # ---------------------------------------------------------------------------- def CloseAccessPoint(self): try: ip = self._IP_NONE self._wlan.mode(WLAN.STA) self._wlan.ifconfig(id=self._ETH_AP, config=(ip, ip, ip, ip)) return True except: return False # ---------------------------------------------------------------------------- def IsAccessPointOpened(self): return self._wlan.ifconfig(self._ETH_AP)[0] != self._IP_NONE # ---------------------------------------------------------------------------- def ConnectToAP(self, ssid, key=None, macBssid=None, timeoutSec=None, autoSave=True): if ssid: if not key: key = '' if not timeoutSec: timeoutSec = self._DEFAULT_TIMEOUT_SEC timeout = timeoutSec * 1000 if self._wlan.mode() == WLAN.STA: self._wlan.init(antenna=self._antenna) print("TRYING TO CONNECT WIFI TO AP %s..." % ssid) for ap in self.ScanAP(): if ap.ssid == ssid and \ ( not macBssid or self._mac2Str(ap.bssid) == macBssid ) : self._wlan.connect(ssid=ap.ssid, bssid=ap.bssid, auth=(self._DEFAULT_AUTH_TYPE, key), timeout=timeout) t = ticks_ms() while ticks_diff(t, ticks_ms()) < timeout: sleep(0.100) if self.IsConnectedToAP(): bssid = self._mac2Str(ap.bssid) staCfg = self._wlan.ifconfig(id=self._ETH_STA) ip = staCfg[0] mask = staCfg[1] gateway = staCfg[2] dns = staCfg[3] print("WIFI CONNECTED TO AP :") print(" - MAC address : %s" % self.GetMACAddr()) print(" - Network BSSID : %s" % bssid) print(" - Network SSID : %s" % ssid) print(" - IP address : %s" % ip) print(" - Mask : %s" % mask) print(" - Gateway IP : %s" % gateway) print(" - DNS server : %s" % dns) if autoSave: sta = { 'ssid': ssid, 'key': key, } self._confObj['STA'][bssid] = sta self._writeConf() self._setConnectionInfos(bssid, ssid, key, ip, mask, gateway, dns) return True self.CloseConnectionToAP() break print("FAILED TO CONNECT WIFI TO AP %s" % ssid) return False # ---------------------------------------------------------------------------- def ConnectToAPFromConf(self, bssidMustBeSame=False, timeoutSec=None): if self._wlan.mode() == WLAN.STA: self._wlan.init(antenna=self._antenna) for ap in self.ScanAP(): for bssid in self._confObj['STA']: macBssid = self._mac2Str(ap.bssid) if bssidMustBeSame else None if self._confObj['STA'][bssid]['ssid'] == ap.ssid and \ ( not macBssid or bssid == macBssid ) : if self.ConnectToAP(ap.ssid, self._confObj['STA'][bssid]['key'], macBssid, timeoutSec, False): return True break return False # ---------------------------------------------------------------------------- def RemoveConnectionToAPFromConf(self, ssid, macBssid=None): try: changed = False for bssid in list(self._confObj['STA']): if self._confObj['STA'][bssid]['ssid'] == ssid and \ ( not macBssid or bssid == macBssid ) : del self._confObj['STA'][bssid] changed = True if changed: return self._writeConf() except: pass return False # ---------------------------------------------------------------------------- def CloseConnectionToAP(self): try: self._wlan.disconnect() self._wlan.ifconfig(id=self._ETH_STA, config='dhcp') return True except: return False # ---------------------------------------------------------------------------- def IsConnectedToAP(self): return self._wlan.ifconfig(self._ETH_STA)[0] != self._IP_NONE # ---------------------------------------------------------------------------- def ResolveIPFromHostname(self, hostname): originalMode = self._wlan.mode() if originalMode == WLAN.STA_AP: self._wlan.mode(WLAN.STA) try: ipResolved = getaddrinfo(hostname, 0)[0][-1][0] except: ipResolved = None if originalMode == WLAN.STA_AP: self._wlan.mode(WLAN.STA_AP) return ipResolved if ipResolved != self._IP_NONE else None # ---------------------------------------------------------------------------- def InternetAccessIsPresent(self): return (self.ResolveIPFromHostname('iana.org') is not None) # ---------------------------------------------------------------------------- def WaitForInternetAccess(self, timeoutSec=None): if not timeoutSec: timeoutSec = self._DEFAULT_TIMEOUT_SEC timeout = timeoutSec * 1000 t = ticks_ms() while ticks_diff(t, ticks_ms()) < timeout: sleep(0.100) if self.InternetAccessIsPresent(): return True return False
import socket import time import pycom import uos import binascii import struct import machine import sys import network from network import LoRa from network import WLAN from machine import Timer from messageLoRa import messageLoRa wlan = WLAN() mySSID="WGW_lopy_"+binascii.hexlify(wlan.mac().decode('utf-8')).decode() print("My AP name is : "+mySSID) # configure the WLAN subsystem in station mode (the default is AP) wlan.init(mode=WLAN.STA_AP, ssid=mySSID,auth=(WLAN.WPA2,'www.python.com'), channel=7, antenna=WLAN.INT_ANT) #STA config #wlan.ifconfig(id=0,config='dhcp') #AP config #wlan.ifconfig(id=1,config="dhcp") print("My ip on the network [AP] is : "+wlan.ifconfig(id=1)[0]) print("My ip on the network [STA] is : "+wlan.ifconfig(id=0)[0]) # Create a TCP/IP socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Bind the socket to the port server_address = ('192.168.4.1', 5000) print('starting up on {} port {}'.format(*server_address))
except: pass try: # v1.20.1.r1 print("wifi_ssid_sta", pycom.wifi_ssid_sta()) print("wifi_pwd_sta", pycom.wifi_pwd_sta()) print("wifi_ssid_ap", pycom.wifi_ssid_ap()) print("wifi_pwd_ap", pycom.wifi_pwd_ap()) except: pass print("===== wlan =======================================") wlan = WLAN() try: print("sta_mac", binascii.hexlify(wlan.mac().sta_mac)) print("ap_mac", binascii.hexlify(wlan.mac().ap_mac)) except: print("mac", binascii.hexlify(wlan.mac())) print("is_connected", wlan.isconnected()) print("ssid", wlan.ssid()) print("bssid", binascii.hexlify(wlan.bssid())) try: print("country", wlan.country()) except: pass print("ifconfig", wlan.ifconfig()) print('IP:', wlan.ifconfig()[0]) print("mode", wlan.mode(), end=' ') print_wifi_mode(wlan.mode()) print()
import math pycom.heartbeat(False) off = 0x000000 red = 0x7f0000 green = 0x007f00 blue = 0x00007f white = 0xFFFAFA wlan = WLAN(mode=WLAN.STA) if not wlan.isconnected(): wlan.connect('ssid', auth=(WLAN.WPA2, 'password'), timeout=5000) while not wlan.isconnected(): machine.idle() print(ubinascii.hexlify(wlan.mac(), ':').decode()) print("I got IP" + wlan.ifconfig()[0]) _LORA_PKG_FORMAT = "!BB%ds" _LORA_INIT_FORMAT = "!BBs" _LORA_RCV_PKG_FORMAT = "!BB%ds" MY_ID = 0x01 my_sf = int(MY_ID) + 6 my_bw_index = 2 (guard, sync_method, sync_rate) = (40, 1, 1) freqs = [865000000, 865600000, 866200000, 866800000, 867400000, 868000000] # my channels airtime = [[0.174336, 0.087168, 0.043584], [0.307712, 0.153856, 0.076928], [0.553984, 0.276992, 0.138496], [1.026048, 0.513024, 0.256512], [2.215936, 0.944128, 0.472064], [3.940352, 1.724416, 0.862208]] if (my_bw_index == 0):
from network import WLAN import binascii wl = WLAN() #chirpstack config FFEE binascii.hexlify(wl.mac())[:6] + 'FFEE' + binascii.hexlify(wl.mac())[6:] #TTN config FFFE #binascii.hexlify(wl.mac())[:6] + 'FFFE' + binascii.hexlify(wl.mac())[6:]
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)
print(wifi.isconnected() == True) wifi.disconnect() print(wifi.isconnected() == False) t0 = time.ticks_ms() wifi.connect(testconfig.wlan_ssid, auth=testconfig.wlan_auth, timeout=0) print(time.ticks_ms() - t0 < 500) wifi.disconnect() print(wifi.isconnected() == False) # test init again wifi.init(WLAN.AP, ssid='www.wipy.io', auth=None, channel=5, antenna=WLAN.INT_ANT) print(len(wifi.mac()) == 6) # next ones MUST raise try: wifi.init(mode=12345) except: print('Exception') try: wifi.init(1, mode=WLAN.AP) except: print('Exception') try: wifi.init(mode=WLAN.AP, ssid=None) except:
class WifiManager: def __init__(self, known_nets): self._known_nets = known_nets # create network in STAtion mode # pycom: device always starts up in AP-mode #self._wl = WLAN() #self._wl.mode(WLAN.STA) '''def print_debug(self, message): """print_debug() - for debugging """ if USE_DEBUG: print(msg) ''' # 2019-1203 new, due to Exception error in legacy WifiManager # pre-condition: self._known_nets is not None # post-condition: self._wl is created # returns: IP # URL: https://docs.pycom.io/tutorials/all/wlan/ def connect(self): """connect() - connects device according to network parameters in JSON-file.""" if machine.reset_cause() != machine.SOFT_RESET: # from network import WLAN self._wl = WLAN() self._wl.mode(WLAN.STA) original_ssid = self._wl.ssid() original_auth = self._wl.auth() print_debug("Wifimanager - scanning for known wifi nets...") available_nets = self._wl.scan() nets = frozenset([e.ssid for e in available_nets]) known_nets_names = frozenset([key for key in self._known_nets]) net_to_use = list(nets & known_nets_names) print_debug("Wifimanager - SSID to use...{}".format(net_to_use)) try: net_to_use = net_to_use[0] print_debug("Wifimanager - net to use...{}".format(net_to_use)) net_properties = self._known_nets[net_to_use] pwd = net_properties['pwd'] sec = [e.sec for e in available_nets if e.ssid == net_to_use][0] print_debug( "Wifimanager - net_properties...{}".format(net_properties)) if 'wlan_config' in net_properties: print_debug("Wifimanager - wlan_config...{}".format( net_properties['wlan_config'])) self._wl.ifconfig(config=net_properties['wlan_config']) self._wl.connect(net_to_use, (sec, pwd), timeout=10000) ip = self.wait_for_networking(1) self._ssid = net_to_use print_debug("Connected to " + net_to_use + " with IP address:" + ip) except Exception as e: print( "Failed to connect to any known network, going into AP mode" ) self._wl.init(mode=WLAN.AP, ssid=original_ssid, auth=original_auth, channel=6, antenna=WLAN.INT_ANT) self._ssid = None else: print_debug("Already connected to " + net_to_use + " with IP address:" + self._wl.ifconfig()[0]) return self._wl.ifconfig()[0] def wait_for_networking(self, dt=1): """ wait unitil network is connected and returns IP""" station = self._wl # network.WLAN(mode=network.WLAN.STA) while not station.isconnected(): time.sleep(dt) machine.idle() ip = station.ifconfig()[0] return ip # wrapper for disconnecting network def disconnect(self): """disconnect() - de-activate network interface, but leaves Wifi radio on""" self._wl.disconnect( ) # pycom - disconnect from Wifi, but leave Wif radio on. print_debug('WifiManager::Wifi disconnected') # wrapper for disabling Wifi radio def deinit(self): """deinit() - disable Wifi radio""" self._wl.deint() # pycom print_debug('WifiManager::Wifi radio off') # wrapper for network scan def scan(self): """scan() - Performs a network scan and returns a list of named tuples with (ssid, bssid, sec, channel, rssi) """ return self._wl.scan() def change_access(self, user=None, passwrd=None): """change_access - change password for telnet and ftp access""" if (user is None) or (passwrd is None): print('WifiManager:: username and password must be specified') return server = Server() # from network # disable the server server.deinit() # enable the server again with new credentials # for ftp and telnet, not USB server.init(login=(user, passwrd), timeout=600) print_debug('WifiManager::password {} is changed...'.format(user)) # wrappers for wlan settings. @property def ssid(self): """ ssid() - returns SSID of connected Wifi network""" return self._ssid @property def isconnected(self): """isconnected() - returns if connected to Wifi (True) or not (False)""" return self._wl.isconnected() @property def ip(self): """ip() - returns IP of device on connected Wifi network""" return self._wl.ifconfig()[0] @property def mac(self): """returns MAC-address of device""" mac = hexlify(self._wl.mac(), ':').decode() # pycom # return (mac) # lower case return mac.upper() # ================================================ # legacy methods # ================================================ import json def __readjson(self, jsonfile): """readjson(file) - returns the contents of file in JSON-format""" with open(jsonfile, 'r') as infile: config = json.load(infile) if USE_DEBUG: print('WifiManager::JSON settings: {}'.format(config)) return config
''' import machine import os from network import WLAN mch = os.uname().machine if not 'LaunchPad' in mch and not 'WiPy' in mch: raise Exception('Board not supported!') wifi = WLAN() print(machine) machine.idle() print(machine.freq() == (80000000, )) print(machine.unique_id() == wifi.mac()) machine.main('main.py') rand_nums = [] for i in range(0, 100): rand = machine.rng() if rand not in rand_nums: rand_nums.append(rand) else: print('RNG number repeated') break for i in range(0, 10): machine.idle()
] index = 0 slot = {} KEY = {} if (my_bw_index == 0): my_bw = LoRa.BW_125KHZ my_bw_plain = 125 elif (my_bw_index == 1): my_bw = LoRa.BW_250KHZ my_bw_plain = 250 elif (my_bw_index == 2): my_bw = LoRa.BW_500KHZ my_bw_plain = 500 wlan = WLAN(mode=WLAN.STA) print("My MAC address is:", ubinascii.hexlify(wlan.mac(), ':').decode()) if not wlan.isconnected(): wlan.connect('rasp', auth=(WLAN.WPA2, 'lalalala'), timeout=5000) while not wlan.isconnected(): machine.idle() print("I got IP" + wlan.ifconfig()[0]) # this is borrowed from LoRaSim (https://www.lancaster.ac.uk/scc/sites/lora/lorasim.html) def airtime_calc(sf, cr, pl, bw): H = 0 # implicit header disabled (H=0) or not (H=1) DE = 0 # low data rate optimization enabled (=1) or not (=0) Npream = 8 if bw == 125 and sf in [11, 12]: # low data rate optimization mandated for BW125 with SF11 and SF12 DE = 1
from network import WLAN import ubinascii wl = WLAN() print(ubinascii.hexlify(wl.mac())[:6] + 'FFFE' + ubinascii.hexlify(wl.mac())[6:])
# test init again wifi.init(WLAN.AP, ssid='www.wipy.io', auth=None, channel=5, antenna=WLAN.INT_ANT) print(wifi.mode() == WLAN.AP) # get the current instance without re-init wifi = WLAN() print(wifi.mode() == WLAN.AP) wifi = WLAN(0) print(wifi.mode() == WLAN.AP) # test the MAC address length print(len(wifi.mac()) == 6) # next ones MUST raise try: wifi.init(mode=12345) except: print('Exception') try: wifi.init(1, mode=WLAN.AP) except: print('Exception') try: wifi.init(mode=WLAN.AP, ssid=None) except:
test_wifi() if not wifi_passed: # try twice time.sleep(1.0) test_wifi() EMPTY_MAC_ADDRESS = b'ffffffffffff' pycom.heartbeat(False) try: f = open('/flash/sys/test.fct', 'r') initial_test_result = f.readall() if wifi_passed and binascii.hexlify( wlan.mac()) != EMPTY_MAC_ADDRESS and os.uname( ).release == "{FW_VERSION}" and 'WiPy' in os.uname( ).machine and initial_test_result == 'Test OK': pycom.rgbled(0x008000) # green green_led(1) print('QA Test OK') else: pycom.rgbled(0x800000) # red red_led(1) print('QA Test failed') f.close() except Exception: pycom.rgbled(0x800000) # red red_led(1) print('QA Test failed')
''' import machine import os from network import WLAN mch = os.uname().machine if not 'LaunchPad' in mch and not'WiPy' in mch: raise Exception('Board not supported!') wifi = WLAN() print(machine) machine.idle() print(machine.freq() == (80000000,)) print(machine.unique_id() == wifi.mac()) machine.main('main.py') rand_nums = [] for i in range(0, 100): rand = machine.rng() if rand not in rand_nums: rand_nums.append(rand) else: print('RNG number repeated') break for i in range(0, 10): machine.idle()