eric: comparison src/eric7/MicroPython/MicrobitDevices.py

-:4958dd72c937
+:606ac0e26533
 """
 Module implementing the device interface class for BBC micro:bit and
 Calliope mini boards.
 """
+import contextlib
 import os
 import shutil
 from PyQt6.QtCore import QStandardPaths, QUrl, pyqtSlot
 from PyQt6.QtNetwork import QNetworkRequest
 class MicrobitDevice(MicroPythonDevice):
 """
 Class implementing the device for BBC micro:bit and Calliope mini boards.
 """
-def __init__(self, microPythonWidget, deviceType, parent=None):
+def __init__(self, microPythonWidget, deviceType, serialNumber, parent=None):
 """
 Constructor
 @param microPythonWidget reference to the main MicroPython widget
 @type MicroPythonWidget
 @param deviceType type of the device
 @type str
+@param serialNumber serial number of the board
+@type str
 @param parent reference to the parent object
 @type QObject
 """
 super().__init__(microPythonWidget, deviceType, parent)
+self.__boardId = 0  # illegal ID
+if serialNumber:
+with contextlib.suppress(ValueError):
+self.__boardId = int(serialNumber[:4], 16)
 def setButtons(self):
 """
 Public method to enable the supported action buttons.
 """
 The default returns True.
 @return flag indicating support for time commands
 @rtype bool
 """
+if (
+self.microPython.isConnected()
+and self.checkDeviceData()
+and self._deviceData["mpy_name"] == "circuitpython"
+):
+return True
 return False
+def __isMicroBitV1(self):
+"""
+Private method to check, if the device is a BBC micro:bit v1.
+@return falg indicating a BBC micro:bit v1
+@rtype bool
+"""
+return self.__boardId in (0x9900, 0x9901)
+def __isMicroBitV2(self):
+"""
+Private method to check, if the device is a BBC micro:bit v2.
+@return falg indicating a BBC micro:bit v2
+@rtype bool
+"""
+return self.__boardId in (0x9903, 0x9904, 0x9905, 0x9906)
+def __isCalliope(self):
+"""
+Private method to check, if the device is a Calliope mini.
+@return flag indicating a Calliope mini
+@rtype bool
+"""
+return self.__boardId in (0x12A0,)
 def addDeviceMenuEntries(self, menu):
 """
 Public method to add device specific entries to the given menu.
 def __showFirmwareVersions(self):
 """
 Private slot to show the firmware version of the connected device and the
 available firmware version.
 """
-if self.microPython.isConnected():
+if self.microPython.isConnected() and self.checkDeviceData():
-interface = self.microPython.commandsInterface()
+if self._deviceData["mpy_name"] not in ("micropython", "circuitpython"):
-if interface is not None:
+EricMessageBox.critical(
-impInfo = interface.getImplementation()
+None,
-versionInfo = interface.version()
+self.tr("Show MicroPython Versions"),
-if impInfo["name"] != "micropython":
+self.tr(
-EricMessageBox.critical(
+"""The firmware of the connected device cannot be"""
-None,
+""" determined or the board does not run MicroPython"""
-self.tr("Show MicroPython Versions"),
+""" or CircuitPython. Aborting..."""
-self.tr(
+),
-"""The firmware of the connected device cannot be"""
+)
-""" determined or the board does not run MicroPython."""
+else:
-""" Aborting..."""
+if self.getDeviceType() == "bbc_microbit":
-),
+if self._deviceData["mpy_name"] == "micropython":
-)
+if self.__isMicroBitV1():
-else:
-impInfo["version"] = versionInfo["release"]
-if self.getDeviceType() == "bbc_microbit":
-if "nRF51" in versionInfo["machine"]:
 url = QUrl(FirmwareGithubUrls["microbit_v1"])
-elif "nRF52" in versionInfo["machine"]:
+elif self.__isMicroBitV2():
 url = QUrl(FirmwareGithubUrls["microbit_v2"])
 else:
 EricMessageBox.critical(
 None,
 self.tr("Show MicroPython Versions"),
 """<p>The BBC micro:bit generation cannot be"""
 """ determined. Aborting...</p>"""
 ),
 )
 return
-else:
+elif self._deviceData["mpy_name"] == "circuitpython":
-EricMessageBox.critical(
+url = QUrl(FirmwareGithubUrls["circuitpython"])
-None,
+else:
-self.tr("Show MicroPython Versions"),
+EricMessageBox.critical(
-self.tr(
+None,
-"""<p>The firmware URL for the device type <b>{0}</b>"""
+self.tr("Show MicroPython Versions"),
-""" is not known. Aborting...</p>"""
+self.tr(
-).format(self.getDeviceType()),
+"""<p>The firmware URL for the device type <b>{0}</b>"""
-)
+""" is not known. Aborting...</p>"""
-return
+).format(self.getDeviceType()),
-ui = ericApp().getObject("UserInterface")
-request = QNetworkRequest(url)
-reply = ui.networkAccessManager().head(request)
-reply.finished.connect(
-lambda: self.__firmwareVersionResponse(reply, impInfo)
 )
+return
-def __firmwareVersionResponse(self, reply, implementation):
+ui = ericApp().getObject("UserInterface")
+request = QNetworkRequest(url)
+reply = ui.networkAccessManager().head(request)
+reply.finished.connect(lambda: self.__firmwareVersionResponse(reply))
+def __firmwareVersionResponse(self, reply):
 """
 Private method handling the response of the latest version request.
 @param reply reference to the reply object
 @type QNetworkReply
-@param implementation dictionary containing the implementation data of the
-connected device
-@type dict
 """
 latestUrl = reply.url().toString()
 tag = latestUrl.rsplit("/", 1)[-1]
 while tag and not tag[0].isdecimal():
 # get rid of leading non-decimal characters
 tag = tag[1:]
 latestVersion = Globals.versionToTuple(tag)
-if implementation["version"] == "unknown":
+if self._deviceData["release"] == "unknown":
 currentVersionStr = self.tr("unknown")
 currentVersion = (0, 0, 0)
 else:
-currentVersionStr = implementation["version"]
+currentVersionStr = self._deviceData["release"]
 currentVersion = Globals.versionToTuple(currentVersionStr)
+if self._deviceData["mpy_name"] == "circuitpython":
+kind = "CircuitPython"
+microbitVersion = "2"  # only v2 device can run CircuitPython
+elif self._deviceData["mpy_name"] == "micropython":
+kind = "MicroPython"
+if self.__isMicroBitV1():
+microbitVersion = "1"
+elif self.__isMicroBitV2():
+microbitVersion = "2"
+else:
+kind = self.tr("Firmware")
+microbitVersion = "?"
 msg = self.tr(
-"<h4>MicroPython Version Information<br/>"
+"<h4>{0} Version Information<br/>"
-"(BBC micro:bit v{2})</h4>"
+"(BBC micro:bit v{1})</h4>"
 "<table>"
-"<tr><td>Installed:</td><td>{0}</td></tr>"
+"<tr><td>Installed:</td><td>{2}</td></tr>"
-"<tr><td>Available:</td><td>{1}</td></tr>"
+"<tr><td>Available:</td><td>{3}</td></tr>"
 "</table>"
-).format(currentVersionStr, tag, currentVersionStr[0])
+).format(kind, microbitVersion, currentVersionStr, tag)
 if currentVersion < latestVersion:
 msg += self.tr("<p><b>Update available!</b></p>")
 EricMessageBox.information(
 None,
-self.tr("MicroPython Version"),
+self.tr("{0} Version").format(kind),
 msg,
 )
 @pyqtSlot()
 def __saveMain(self):
 @return documentation URL of the device
 @rtype str
 """
 if self.getDeviceType() == "bbc_microbit":
 # BBC micro:bit
-return Preferences.getMicroPython("MicrobitDocuUrl")
+if self._deviceData and self._deviceData["mpy_name"] == "circuitpython":
+return Preferences.getMicroPython("CircuitPythonDocuUrl")
+else:
+return Preferences.getMicroPython("MicrobitDocuUrl")
 else:
 # Calliope mini
 return Preferences.getMicroPython("CalliopeDocuUrl")
 def getDownloadMenuEntries(self):
 @return list of tuples with menu text and URL to be opened for each
 entry
 @rtype list of tuple of (str, str)
 """
 if self.getDeviceType() == "bbc_microbit":
-return [
+if self.__isMicroBitV1():
-(
+return [
-self.tr("MicroPython Firmware for BBC micro:bit V1"),
+(
-Preferences.getMicroPython("MicrobitMicroPythonUrl"),
+self.tr("MicroPython Firmware for BBC micro:bit V1"),
-),
+Preferences.getMicroPython("MicrobitMicroPythonUrl"),
-(
+),
-self.tr("MicroPython Firmware for BBC micro:bit V2"),
+(
-Preferences.getMicroPython("MicrobitV2MicroPythonUrl"),
+self.tr("DAPLink Firmware"),
-),
+Preferences.getMicroPython("MicrobitFirmwareUrl"),
-(
+),
-self.tr("DAPLink Firmware"),
+]
-Preferences.getMicroPython("MicrobitFirmwareUrl"),
+elif self.__isMicroBitV2():
-),
+return [
-]
+(
+self.tr("MicroPython Firmware for BBC micro:bit V2"),
+Preferences.getMicroPython("MicrobitV2MicroPythonUrl"),
+),
+(
+self.tr("CircuitPython Firmware for BBC micro:bit V2"),
+"https://circuitpython.org/board/microbit_v2/",
+),
+(
+self.tr("DAPLink Firmware"),
+Preferences.getMicroPython("MicrobitFirmwareUrl"),
+),
+]
+else:
+return []
 else:
 return [
 (
 self.tr("MicroPython Firmware"),
 Preferences.getMicroPython("CalliopeMicroPythonUrl"),
 Preferences.getMicroPython("CalliopeDAPLinkUrl"),
 ),
 ]
-def createDevice(microPythonWidget, deviceType, vid, pid, boardName):
+def createDevice(microPythonWidget, deviceType, vid, pid, boardName, serialNumber):
 """
 Function to instantiate a MicroPython device object.
 @param microPythonWidget reference to the main MicroPython widget
 @type MicroPythonWidget
 @type int
 @param pid product ID
 @type int
 @param boardName name of the board
 @type str
+@param serialNumber serial number of the board
+@type str
 @return reference to the instantiated device object
 @rtype MicrobitDevice
 """
-return MicrobitDevice(microPythonWidget, deviceType)
+return MicrobitDevice(microPythonWidget, deviceType, serialNumber)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/MicroPython/MicrobitDevices.py

src/eric7/MicroPython/MicrobitDevices.py