eric: comparison eric6/MicroPython/MicroPythonReplWidget.py

-:ac12da95958b
+:e3d04faced34
 try:
 from PyQt5.QtSerialPort import QSerialPort
 HAS_QTSERIALPORT = True
 except ImportError:
 HAS_QTSERIALPORT = False
+from E5Gui.E5ZoomWidget import E5ZoomWidget
+from E5Gui import E5MessageBox, E5FileDialog
+from E5Gui.E5Application import e5App
+from .Ui_MicroPythonReplWidget import Ui_MicroPythonReplWidget
+from . import MicroPythonDevices
 try:
-from PyQt5.QtChart import QChart    # __IGNORE_WARNING__
+from .MicroPythonGraphWidget import MicroPythonGraphWidget
 HAS_QTCHART = True
 except ImportError:
 HAS_QTCHART = False
-from E5Gui.E5ZoomWidget import E5ZoomWidget
-from E5Gui import E5MessageBox, E5FileDialog
-from E5Gui.E5Application import e5App
-from .Ui_MicroPythonReplWidget import Ui_MicroPythonReplWidget
-from . import MicroPythonDevices
 import Globals
 import UI.PixmapCache
 self.__zoomWidget.setMinimum(self.ZoomMin)
 self.__zoomWidget.setMaximum(self.ZoomMax)
 self.__zoomWidget.valueChanged.connect(self.__doZoom)
 self.__currentZoom = 0
+self.__ui = None
 self.__serial = None
 self.__device = None
 self.setConnected(False)
 self.__replRunning = False
 def setActionButtons(self, **kwargs):
 """
 Public method to set the enabled state of the various action buttons.
-@param kwargs keyword arguments containg the enabled states (keys are
+@keyparam kwargs keyword arguments containg the enabled states (keys
-'run', 'repl', 'files', 'chart', 'open', 'save'
+are 'run', 'repl', 'files', 'chart', 'open', 'save'
 @type dict
 """
 if "open" in kwargs:
 self.openButton.setEnabled(kwargs["open"])
 if "save" in kwargs:
 self.chartButton.setEnabled(kwargs["chart"])
 @pyqtSlot(QPoint)
 def __showContextMenu(self, pos):
 """
-Privat slot to show the REPL context menu.
+Private slot to show the REPL context menu.
 @param pos position to show the menu at
 @type QPoint
 """
 if Globals.isMacPlatform():
 self.__showNoDeviceMessage()
 return
 if self.__replRunning:
 self.dataReceived.disconnect(self.__processData)
-self.__disconnect()
+if not self.__plotterRunning:
+self.__disconnectSerial()
 self.__replRunning = False
 self.__device.setRepl(False)
 else:
 ok, reason = self.__device.canStartRepl()
 if not ok:
 self,
 self.tr("Start REPL"),
 self.tr("""<p>The REPL cannot be started.</p><p>Reason:"""
 """ {0}</p>""").format(reason))
 return
+self.replEdit.clear()
+self.dataReceived.connect(self.__processData)
 if not self.__serial:
-self.replEdit.clear()
-self.dataReceived.connect(self.__processData)
 self.__openSerialLink()
 if self.__serial:
 if self.__device.forceInterrupt():
 # send a Ctrl-B (exit raw mode)
 self.__serial.write(b'\x02')
 Private slot to disconnect from the currently connected device.
 """
 if self.__replRunning:
 self.on_replButton_clicked()
+if self.__plotterRunning:
+self.on_chartButton_clicked()
 # TODO: add more
-def __disconnect(self):
+def __disconnectSerial(self):
 """
 Private slot to disconnect the serial connection.
 """
 self.__closeSerialLink()
 self.setConnected(False)
 def __doZoom(self, value):
 """
 Private slot to zoom the REPL pane.
 @param value zoom value
-@param int
+@type int
 """
 if value < self.__currentZoom:
 self.replEdit.zoomOut(self.__currentZoom - value)
 elif value > self.__currentZoom:
 self.replEdit.zoomIn(value - self.__currentZoom)
 portName = self.deviceTypeComboBox.itemData(
 self.deviceTypeComboBox.currentIndex(),
 self.DevicePortRole)
 if Globals.isWindowsPlatform():
-# return unchanged
+# return it unchanged
 return portName
 else:
 # return with device path prepended
 return "/dev/{0}".format(portName)
 Public method to execute a series of commands over a period of time.
 @param commandsList list of commands to be execute on the device
 @type list of bytes
 """
+def remainingTask(commands):
+self.execute(commands)
 if commandsList:
 command = commandsList[0]
 self.__serial.write(command)
 remainder = commandsList[1:]
-remainingTask = lambda commands=remainder: self.execute(commands)
+QTimer.singleShot(2, lambda: remainingTask(remainder))
-QTimer.singleShot(2, remainingTask)
 @pyqtSlot()
 def on_runButton_clicked(self):
 """
 Private slot to execute the script of the active editor on the
 return
 workspace = self.__device.getWorkspace()
 aw = e5App().getObject("ViewManager").activeWindow()
 aw.saveFileAs(workspace)
+@pyqtSlot()
+def on_chartButton_clicked(self):
+"""
+Private slot to open a chart view to plot data received from the
+connected device.
+"""
+if not HAS_QTCHART:
+# QtChart not available => fail silently
+return
+if not self.__device:
+self.__showNoDeviceMessage()
+return
+if self.__ui is None:
+self.__ui = e5App().getObject("UserInterface")
+if self.__plotterRunning:
+if self.__chartWidget.hasData():
+res = E5MessageBox.okToClearData(
+self,
+self.tr("Unsaved Chart Data"),
+self.tr("""The chart contains unsaved data."""),
+self.__chartWidget.saveData)
+if not res:
+# abort
+return
+self.dataReceived.disconnect(self.__chartWidget.processData)
+self.__chartWidget.dataFlood.disconnect(self.handleDataFlood)
+if not self.__replRunning:
+self.__disconnectSerial()
+self.__plotterRunning = False
+self.__device.setPlotter(False)
+self.__ui.removeSideWidget(self.__chartWidget)
+else:
+ok, reason = self.__device.canStartPlotter()
+if not ok:
+E5MessageBox.warning(
+self,
+self.tr("Start Chart"),
+self.tr("""<p>The Chart cannot be started.</p><p>Reason:"""
+""" {0}</p>""").format(reason))
+return
+self.__chartWidget = MicroPythonGraphWidget(self)
+self.dataReceived.connect(self.__chartWidget.processData)
+self.__chartWidget.dataFlood.connect(self.handleDataFlood)
+self.__ui.addSideWidget(self.__ui.BottomSide, self.__chartWidget,
+UI.PixmapCache.getIcon("chart"),
+self.tr("Chart"))
+self.__ui.showSideWidget(self.__chartWidget)
+if not self.__serial:
+self.__openSerialLink()
+if self.__serial:
+if self.__device.forceInterrupt():
+# send a Ctrl-B (exit raw mode)
+self.__serial.write(b'\x02')
+# send Ctrl-C (keyboard interrupt)
+self.__serial.write(b'\x03')
+self.__plotterRunning = True
+self.__device.setPlotter(True)
+@pyqtSlot()
+def handleDataFlood(self):
+"""
+Public slot handling a data flood from the device.
+"""
+self.on_disconnectButton_clicked()
+self.__device.handleDataFlood()

Mercurial Repositories > eric / file comparison

comparison: eric6/MicroPython/MicroPythonReplWidget.py

eric6/MicroPython/MicroPythonReplWidget.py