eric: comparison src/eric7/MicroPython/Devices/RP2040Devices.py

-:33e7b9d3f91c
+:ffe7432f716b
 """
 menu.addSeparator()
 menu.addAction(self.tr("Set Country"), self.__setCountry).setEnabled(
 self._deviceData["wifi_type"] == "picow"
 )
+menu.addAction(self.tr("Reset Country"), self.__resetCountry).setEnabled(
+self._deviceData["wifi_type"] == "picow"
+)
 def hasWifi(self):
 """
 Public method to check the availability of WiFi.
 else:
 # pimoroni firmware loaded but no pico wireless present
 return False, ""
 return ast.literal_eval(out.decode("utf-8"))
+def hasWifiCountry(self):
+"""
+Public method to check, if the device has support to set the WiFi country.
+@return flag indicating the support of WiFi country
+@rtype bool
+"""
+return self._deviceData["wifi_type"] == "picow"
 def getWifiData(self):
 """
 Public method to get data related to the current WiFi status.
 @return tuple of three dictionaries containing the WiFi status data
 'status': wifi.status(),
 'ifconfig': wifi.ifconfig(),
 'mac': ubinascii.hexlify(wifi.config('mac'), ':').decode(),
 'channel': wifi.config('channel'),
 'txpower': wifi.config('txpower'),
-'country': rp2.country(),
 }
 print(ujson.dumps(station))
 wifi = network.WLAN(network.AP_IF)
 ap = {
 'ifconfig': wifi.ifconfig(),
 'mac': ubinascii.hexlify(wifi.config('mac'), ':').decode(),
 'channel': wifi.config('channel'),
 'txpower': wifi.config('txpower'),
 'essid': wifi.config('essid'),
-'country': rp2.country(),
 }
 print(ujson.dumps(ap))
 overall = {
 'active': station['active'] or ap['active']
 }
+try:
+overall['country'] = network.country()
+except AttributeError:
+overall['country'] = rp2.country()
+try:
+overall['hostname'] = network.hostname()
+except AttributeError:
+pass
 print(ujson.dumps(overall))
 wifi_status()
 del wifi_status
 """
 station["ap_security"] = self.tr("unknown ({0})").format(
 station["ap_security"]
 )
 return station, ap, overall
-def connectWifi(self, ssid, password):
+def connectWifi(self, ssid, password, hostname):
 """
 Public method to connect a device to a WiFi network.
 @param ssid name (SSID) of the WiFi network
 @type str
 @param password password needed to connect
 @type str
+@param hostname host name of the device
+@type str
 @return tuple containing the connection status and an error string
 @rtype tuple of (bool, str)
 """
 if self._deviceData["wifi_type"] == "picow":
 country = Preferences.getMicroPython("WifiCountry").upper()
 command = """
-def connect_wifi(ssid, password, country):
+def connect_wifi(ssid, password, hostname, country):
 import network
 import rp2
 import ujson
 from time import sleep
 rp2.country(country)
+if hostname:
+try:
+network.hostname(hostname)
+except AttributeError:
+pass
 wifi = network.WLAN(network.STA_IF)
 wifi.active(False)
 wifi.active(True)
 wifi.connect(ssid, password)
 max_wait -= 1
 sleep(0.1)
 status = wifi.status()
 print(ujson.dumps({{'connected': wifi.isconnected(), 'status': status}}))
-connect_wifi({0}, {1}, {2})
+connect_wifi({0}, {1}, {2}, {3})
 del connect_wifi
 """.format(
 repr(ssid),
 repr(password if password else ""),
+repr(hostname),
 repr(country if country else "XX"),
 )
 elif self._deviceData["wifi_type"] == "picowireless":
 command = """
 def connect_wifi(ssid, password):
 """.format(
 repr(ssid),
 repr(password if password else ""),
 )
 else:
-return super().connectWifi(ssid, password)
+return super().connectWifi(ssid, password, hostname)
 with EricOverrideCursor():
 out, err = self.executeCommands(
 command, mode=self._submitMode, timeout=15000
 )
 if err:
 return False
 return out.strip() == b"True"
-def writeCredentials(self, ssid, password):
+def writeCredentials(self, ssid, password, hostname, country):
 """
 Public method to write the given credentials to the connected device and modify
 the start script to connect automatically.
 @param ssid SSID of the network to connect to
 @type str
 @param password password needed to authenticate
+@type str
+@param hostname host name of the device
+@type str
+@param country WiFi country code
 @type str
 @return tuple containing a flag indicating success and an error message
 @rtype tuple of (bool, str)
 """
 command = """
 modify_boot()
 del modify_boot
 """
 if self._deviceData["wifi_type"] == "picow":
-country = Preferences.getMicroPython("WifiCountry").upper()
+secrets = (
-secrets = "WIFI_SSID = {0}\nWIFI_KEY = {1}\nWIFI_COUNTRY={2}".format(
+"WIFI_SSID = {0}\nWIFI_KEY = {1}\nWIFI_COUNTRY={2}\n"
+"WIFI_HOSTNAME = {3}\n"
+).format(
 repr(ssid),
 repr(password) if password else '""',
-repr(country) if country else '""',
+repr(country.upper()) if country else '""',
+repr(hostname) if hostname else '""',
 )
 wifiConnectFile = "picowWiFiConnect.py"
 else:
 secrets = "WIFI_SSID = {0}\nWIFI_KEY = {1}\n".format(
 repr(ssid),
 repr(password) if password else '""',
 )
 if self._deviceData["wifi_type"] == "picowireless":
 wifiConnectFile = "pimoroniWiFiConnect.py"
 else:
+secrets += "WIFI_HOSTNAME = {0}\n".format(
+repr(hostname if hostname else '""')
+)
 wifiConnectFile = "mpyWiFiConnect.py"
 try:
 # write secrets file
 self.putData("/secrets.py", secrets.encode("utf-8"))
 # copy auto-connect file
 if err:
 return False, err
 else:
 return out.decode("utf-8").strip() == "True", ""
-def startAccessPoint(self, ssid, security=None, password=None, ifconfig=None):
+def startAccessPoint(
+self,
+ssid,
+security=None,
+password=None,
+hostname=None,
+ifconfig=None,
+):
 """
 Public method to start the access point interface.
 @param ssid SSID of the access point
 @type str
 @param security security method (defaults to None)
 @type int (optional)
 @param password password (defaults to None)
 @type str (optional)
+@param hostname host name of the device (defaults to None)
+@type str (optional)
 @param ifconfig IPv4 configuration for the access point if not default
 (IPv4 address, netmask, gateway address, DNS server address)
 @type tuple of (str, str, str, str)
 @return tuple containing a flag indicating success and an error message
 @rtype tuple of (bool, str)
 if self._deviceData["wifi_type"] == "picow":
 country = Preferences.getMicroPython("WifiCountry").upper()
 if security:
 security = 4  # Pico W supports just WPA/WPA2
 command = """
-def start_ap(ssid, security, password, ifconfig, country):
+def start_ap(ssid, security, password, hostname, ifconfig, country):
 import network
 import rp2
 from time import sleep
 rp2.country(country)
+if hostname:
+try:
+network.hostname(hostname)
+except AttributeError:
+pass
 ap = network.WLAN(network.AP_IF)
 ap.active(True)
 if ifconfig:
 ap.ifconfig(ifconfig)
 ap.config(ssid=ssid, security=security, password=password)
 sleep(0.1)
 print(ap.isconnected())
-start_ap({0}, {1}, {2}, {3}, {4})
+start_ap({0}, {1}, {2}, {3}, {4}, {5})
 del start_ap
 """.format(
 repr(ssid),
 security,
 repr(password),
+repr(hostname),
 ifconfig,
 repr(country if country else "XX"),
 )
 elif self._deviceData["wifi_type"] == "picowireless":
 if ifconfig:
 """.format(
 repr(ssid),
 repr(password if password else ""),
 )
 else:
-return super().startAccessPoint(ssid, security=security, password=password)
+return super().startAccessPoint(
+ssid,
+security=security,
+password=password,
+hostname=hostname,
+ifconfig=ifconfig,
+)
 out, err = self.executeCommands(command, mode=self._submitMode, timeout=15000)
 if err:
 return False, err
 else:
 out, err = self.executeCommands(command, mode=self._submitMode)
 if err:
 return False, err
 return out.decode("utf-8").strip() == "True", ""
+@pyqtSlot()
+def __setCountry(self):
+"""
+Private slot to configure the country of the connected RP2040 device.
+The country is the two-letter ISO 3166-1 Alpha-2 country code.
+"""
+from ..WifiDialogs.WifiCountryDialog import WifiCountryDialog
+dlg = WifiCountryDialog()
+if dlg.exec() == QDialog.DialogCode.Accepted:
+country, remember = dlg.getCountry()
+if remember:
+Preferences.setMicroPython("WifiCountry", country)
+command = """
+try:
+import network
+network.country({0})
+except AttributeError:
+import rp2
+rp2.country({0})
+""".format(
+repr(country)
+)
+out, err = self.executeCommands(command, mode=self._submitMode)
+if err:
+self.microPython.showError("country()", err)
+@pyqtSlot()
+def __resetCountry(self):
+"""
+Private slot to reset the country of the connected ESP32 device.
+The country is the two-letter ISO 3166-1 Alpha-2 country code. This method
+resets it to the default code 'XX' representing the "worldwide" region.
+"""
+command = """
+try:
+import network
+network.country('XX')
+except AttributeError:
+pass
+"""
+out, err = self.executeCommands(command, mode=self._submitMode)
+if err:
+self.microPython.showError("country()", err)
 ##################################################################
 ## Methods below implement Bluetooth related methods
 ##################################################################
 'active': nic.active(),
 'connected': nic.isconnected(),
 'status': nic.status(),
 'ifconfig': nic.ifconfig(),
 'mac': ubinascii.hexlify(nic.config('mac'), ':').decode(),
-'hostname': network.hostname(),
 }}
+try:
+res['hostname'] = network.hostname()
+except AttributeError:
+res['hostname'] = ''
 print(ujson.dumps(res))
 ethernet_status()
 del ethernet_status, w5x00_init
 """.format(
 (
 self.tr("Status"),
 self.__statusTranslations["picowiz"][ethStatus["status"]],
 )
 )
-status.append((self.tr("Hostname"), ethStatus["hostname"]))
+status.append(
+(
+self.tr("Hostname"),
+ethStatus["hostname"] if ethStatus["hostname"] else self.tr("unknown"),
+)
+)
 status.append((self.tr("IPv4 Address"), ethStatus["ifconfig"][0]))
 status.append((self.tr("Netmask"), ethStatus["ifconfig"][1]))
 status.append((self.tr("Gateway"), ethStatus["ifconfig"][2]))
 status.append((self.tr("DNS"), ethStatus["ifconfig"][3]))
 status.append((self.tr("MAC-Address"), ethStatus["mac"]))
 return status
-def connectToLan(self, config):
+def connectToLan(self, config, hostname):
 """
 Public method to connect the connected device to the LAN.
 @param config configuration for the connection (either the string 'dhcp'
 for a dynamic address or a tuple of four strings with the IPv4 parameters.
 @type str or tuple of (str, str, str, str)
+@param hostname host name of the device
+@type str
 @return tuple containing a flag indicating success and an error message
 @rtype tuple of (bool, str)
 """
 command = """{0}
-def connect_lan(config):
+def connect_lan(config, hostname):
+import network
 import time
+if hostname:
+try:
+network.hostname(hostname)
+except AttributeError:
+pass
 w5x00_init()
 nic.active(False)
 nic.active(True)
 break
 max_wait -= 1
 time.sleep(0.1)
 print(nic.isconnected())
-connect_lan({1})
+connect_lan({1}, {2})
 del connect_lan, w5x00_init
 """.format(
-WiznetUtilities.mpyWiznetInit(), "'dhcp'" if config == "dhcp" else config
+WiznetUtilities.mpyWiznetInit(),
+"'dhcp'" if config == "dhcp" else config,
+repr(hostname) if hostname else "''",
 )
 with EricOverrideCursor():
 out, err = self.executeCommands(
 command, mode=self._submitMode, timeout=15000
 # The WIZnet 5x00 interface cannot be switched off explicitly. That means,
 # disconnect from the LAN is all we can do.
 return self.disconnectFromLan()
-def writeLanAutoConnect(self, config):
+def writeLanAutoConnect(self, config, hostname):
 """
 Public method to generate a script and associated configuration to connect the
 device to the LAN during boot time.
 @param config configuration for the connection (either the string 'dhcp'
 for a dynamic address or a tuple of four strings with the IPv4 parameters.
 @type str or tuple of (str, str, str, str)
+@param hostname host name of the device
+@type str
 @return tuple containing a flag indicating success and an error message
 @rtype tuple of (bool, str)
 """
 command = """
 def modify_boot():
 print(True)
 modify_boot()
 del modify_boot
 """
-ifconfig = "ifconfig = {0}\n".format("'dhcp'" if config == "dhcp" else config)
+devconfig = "ifconfig = {0}\nhostname = {1}".format(
+"'dhcp'" if config == "dhcp" else config,
+repr(hostname) if hostname else "''",
+)
 try:
 # write secrets file
-self.putData("/wiznet_config.py", ifconfig.encode("utf-8"))
+self.putData("/wiznet_config.py", devconfig.encode("utf-8"))
 # copy auto-connect file
 self.put(
 os.path.join(
 os.path.dirname(__file__), "MCUScripts", "picoWiznetConnect.py"
 ),
 if err:
 return False, err
 else:
 res = ast.literal_eval(out.decode("utf-8"))
 return res["result"], res["error"]
-############################################################################
-## RP2 only methods below
-############################################################################
-@pyqtSlot()
-def __setCountry(self):
-"""
-Private slot to configure the country of the connected RP2040 device.
-The country is the two letter country code.
-"""
-from ..WifiDialogs.WifiCountryDialog import WifiCountryDialog
-dlg = WifiCountryDialog()
-if dlg.exec() == QDialog.DialogCode.Accepted:
-country, remember = dlg.getCountry()
-if remember:
-Preferences.setMicroPython("WifiCountry", country)
-command = """
-import rp2
-rp2.country({0})
-""".format(
-repr(country)
-)
-out, err = self.executeCommands(command, mode=self._submitMode)
-if err:
-self.microPython.showError("rp2.country()", err)
 def createDevice(
 microPythonWidget, deviceType, vid, pid, boardName, serialNumber  # noqa: U100
 ):

Mercurial Repositories > eric / file comparison

comparison: src/eric7/MicroPython/Devices/RP2040Devices.py

src/eric7/MicroPython/Devices/RP2040Devices.py