import qtcompat
import re
import sigrok.core as sr
+import time
QtCore = qtcompat.QtCore
QtGui = qtcompat.QtGui
class SamplingThread(QtCore.QObject):
- '''A class that handles the reception of sigrok packets in the background.'''
+ '''Class that handles the reception of sigrok packets in the background.'''
class Worker(QtCore.QObject):
'''Helper class that does the actual work in another thread.'''
'''Signal emitted when new data arrived.'''
- measured = QtCore.Signal(object, object, object)
+ measured = QtCore.Signal(float, sr.classes.Device, sr.classes.Channel, tuple)
'''Signal emmited in case of an error.'''
error = QtCore.Signal(str)
self.sampling = False
def parse_configstring(self, cs):
- '''Dissects a config string and returns the options as a
+ '''Dissect a config string and return the options as a
dictionary.'''
def parse_option(k, v):
return dict(opts)
def parse_driverstring(self, ds):
- '''Dissects the driver string and returns a tuple consiting of
+ '''Dissect the driver string and return a tuple consisting of
the driver name and the options (as a dictionary).'''
m = re.match('(?P<name>[^:]+)(?P<opts>(:[^:=]+=[^:=]+)*)$', ds)
def start_sampling(self):
devices = []
for (ds, cs) in self.drivers:
- # process driver string
+ # Process driver string.
try:
(name, opts) = self.parse_driverstring(ds)
if not name in self.context.drivers:
- raise RuntimeError('No driver called "{}".'.format(name))
+ raise RuntimeError('No driver named "{}".'.format(name))
driver = self.context.drivers[name]
devs = driver.scan(**opts)
'Error processing driver string:\n{}'.format(e))
return
- # process configuration string
+ # Process configuration string.
try:
cfgs = self.parse_configstring(cs)
for k, v in cfgs.items():
self.session.stop()
def callback(self, device, packet):
+ now = time.time()
+
if not sr:
# In rare cases it can happen that the callback fires while
# the interpreter is shutting down. Then the sigrok module
# TODO: find a device with multiple channels in one packet
channel = packet.payload.channels[0]
- # the most recent value
+ # The most recent value.
value = packet.payload.data[0][-1]
- self.measured.emit(device, channel,
+ self.measured.emit(now, device, channel,
(value, packet.payload.unit, packet.payload.mq_flags))
- # signal used to start the worker across threads
+ # Signal used to start the worker across threads.
_start_signal = QtCore.Signal()
def __init__(self, context, drivers):
self._start_signal.connect(self.worker.start_sampling)
- # expose the signals of the worker
+ # Expose the signals of the worker.
self.measured = self.worker.measured
self.error = self.worker.error
self.thread.start()
def start(self):
- '''Starts sampling'''
+ '''Start sampling.'''
self._start_signal.emit()
def stop(self):
- '''Stops sampling and the background thread.'''
+ '''Stop sampling and stop the background thread.'''
self.worker.stop_sampling()
self.thread.quit()
self.thread.wait()