[sigrok-meter.git] / samplingthread.py

##
## This file is part of the sigrok-meter project.
##
## Copyright (C) 2013 Uwe Hermann <uwe@hermann-uwe.de>
## Copyright (C) 2014 Jens Steinhauser <jens.steinhauser@gmail.com>
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
##

import qtcompat
import re
import sigrok.core as sr
import time

QtCore = qtcompat.QtCore
QtGui = qtcompat.QtGui

class SamplingThread(QtCore.QObject):
    '''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(float, sr.classes.Device, sr.classes.Channel, tuple)

        '''Signal emmited in case of an error.'''
        error = QtCore.Signal(str)

        def __init__(self, context, drivers):
            super(self.__class__, self).__init__()

            self.context = context
            self.drivers = drivers

            self.sampling = False

        def parse_configstring(self, cs):
            '''Dissect a config string and return the options as a
            dictionary.'''

            def parse_option(k, v):
                '''Parse the value for a single option.'''
                try:
                    ck = sr.ConfigKey.get_by_identifier(k)
                except:
                    raise ValueError('No option named "{}".'.format(k))

                try:
                    val = ck.parse_string(v)
                except:
                    raise ValueError(
                        'Invalid value "{}" for option "{}".'.format(v, k))

                return (k, val)

            if not re.match('(([^:=]+=[^:=]+)(:[^:=]+=[^:=]+)*)?$', cs):
                raise ValueError(
                    '"{}" is not a valid configuration string.'.format(cs))

            if not cs:
                return {}

            opts = cs.split(':')
            opts = [tuple(kv.split('=')) for kv in opts]
            opts = [parse_option(k, v) for (k, v) in opts]
            return dict(opts)

        def parse_driverstring(self, ds):
            '''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)
            if not m:
                raise ValueError('"{}" is not a valid driver string.'.format(ds))

            opts = m.group('opts')[1:]
            return (m.group('name'), self.parse_configstring(opts))

        @QtCore.Slot()
        def start_sampling(self):
            devices = []
            for (ds, cs) in self.drivers:
                # Process driver string.
                try:
                    (name, opts) = self.parse_driverstring(ds)
                    if not name in self.context.drivers:
                        raise RuntimeError('No driver named "{}".'.format(name))

                    driver = self.context.drivers[name]
                    devs = driver.scan(**opts)
                    if not devs:
                        raise RuntimeError('No devices found.')

                    device = devs[0]
                except Exception as e:
                    self.error.emit(
                        'Error processing driver string:\n{}'.format(e))
                    return

                # Process configuration string.
                try:
                    cfgs = self.parse_configstring(cs)
                    for k, v in cfgs.items():
                        device.config_set(sr.ConfigKey.get_by_identifier(k), v)
                except Exception as e:
                    self.error.emit(
                        'Error processing configuration string:\n{}'.format(e))
                    return

                devices.append(device)

            self.session = self.context.create_session()
            for dev in devices:
                self.session.add_device(dev)
                dev.open()
            self.session.add_datafeed_callback(self.callback)
            self.session.start()
            self.sampling = True
            self.session.run()

            # If sampling is 'True' here, it means that 'stop_sampling()' was
            # not called, therefore 'session.run()' ended too early, indicating
            # an error.
            if self.sampling:
                self.error.emit('An error occured during the acquisition.')

        def stop_sampling(self):
            if self.sampling:
                self.sampling = False
                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
                # is already set to 'None'.
                return

            if packet.type != sr.PacketType.ANALOG:
                return

            if not len(packet.payload.channels):
                return

            # TODO: find a device with multiple channels in one packet
            channel = packet.payload.channels[0]

            # The most recent value.
            value = packet.payload.data[0][-1]

            self.measured.emit(now, device, channel,
                    (value, packet.payload.unit, packet.payload.mq_flags))

    # Signal used to start the worker across threads.
    _start_signal = QtCore.Signal()

    def __init__(self, context, drivers):
        super(self.__class__, self).__init__()

        self.worker = self.Worker(context, drivers)
        self.thread = QtCore.QThread()
        self.worker.moveToThread(self.thread)

        self._start_signal.connect(self.worker.start_sampling)

        # Expose the signals of the worker.
        self.measured = self.worker.measured
        self.error = self.worker.error

        self.thread.start()

    def start(self):
        '''Start sampling.'''
        self._start_signal.emit()

    def stop(self):
        '''Stop sampling and stop the background thread.'''
        self.worker.stop_sampling()
        self.thread.quit()
        self.thread.wait()
Commit	Line	Data
	1	##
	2	## This file is part of the sigrok-meter project.
	3	##
	4	## Copyright (C) 2013 Uwe Hermann <uwe@hermann-uwe.de>
	5	## Copyright (C) 2014 Jens Steinhauser <jens.steinhauser@gmail.com>
	6	##
	7	## This program is free software; you can redistribute it and/or modify
	8	## it under the terms of the GNU General Public License as published by
	9	## the Free Software Foundation; either version 2 of the License, or
	10	## (at your option) any later version.
	11	##
	12	## This program is distributed in the hope that it will be useful,
	13	## but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	## GNU General Public License for more details.
	16	##
	17	## You should have received a copy of the GNU General Public License
	18	## along with this program; if not, write to the Free Software
	19	## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	20	##
	21
	22	import qtcompat
	23	import re
	24	import sigrok.core as sr
	25	import time
	26
	27	QtCore = qtcompat.QtCore
	28	QtGui = qtcompat.QtGui
	29
	30	class SamplingThread(QtCore.QObject):
	31	'''Class that handles the reception of sigrok packets in the background.'''
	32
	33	class Worker(QtCore.QObject):
	34	'''Helper class that does the actual work in another thread.'''
	35
	36	'''Signal emitted when new data arrived.'''
	37	measured = QtCore.Signal(float, sr.classes.Device, sr.classes.Channel, tuple)
	38
	39	'''Signal emmited in case of an error.'''
	40	error = QtCore.Signal(str)
	41
	42	def __init__(self, context, drivers):
	43	super(self.__class__, self).__init__()
	44
	45	self.context = context
	46	self.drivers = drivers
	47
	48	self.sampling = False
	49
	50	def parse_configstring(self, cs):
	51	'''Dissect a config string and return the options as a
	52	dictionary.'''
	53
	54	def parse_option(k, v):
	55	'''Parse the value for a single option.'''
	56	try:
	57	ck = sr.ConfigKey.get_by_identifier(k)
	58	except:
	59	raise ValueError('No option named "{}".'.format(k))
	60
	61	try:
	62	val = ck.parse_string(v)
	63	except:
	64	raise ValueError(
	65	'Invalid value "{}" for option "{}".'.format(v, k))
	66
	67	return (k, val)
	68
	69	if not re.match('(([^:=]+=[^:=]+)(:[^:=]+=[^:=]+)*)?$', cs):
	70	raise ValueError(
	71	'"{}" is not a valid configuration string.'.format(cs))
	72
	73	if not cs:
	74	return {}
	75
	76	opts = cs.split(':')
	77	opts = [tuple(kv.split('=')) for kv in opts]
	78	opts = [parse_option(k, v) for (k, v) in opts]
	79	return dict(opts)
	80
	81	def parse_driverstring(self, ds):
	82	'''Dissect the driver string and return a tuple consisting of
	83	the driver name and the options (as a dictionary).'''
	84
	85	m = re.match('(?P<name>[^:]+)(?P<opts>(:[^:=]+=[^:=]+)*)$', ds)
	86	if not m:
	87	raise ValueError('"{}" is not a valid driver string.'.format(ds))
	88
	89	opts = m.group('opts')[1:]
	90	return (m.group('name'), self.parse_configstring(opts))
	91
	92	@QtCore.Slot()
	93	def start_sampling(self):
	94	devices = []
	95	for (ds, cs) in self.drivers:
	96	# Process driver string.
	97	try:
	98	(name, opts) = self.parse_driverstring(ds)
	99	if not name in self.context.drivers:
	100	raise RuntimeError('No driver named "{}".'.format(name))
	101
	102	driver = self.context.drivers[name]
	103	devs = driver.scan(**opts)
	104	if not devs:
	105	raise RuntimeError('No devices found.')
	106
	107	device = devs[0]
	108	except Exception as e:
	109	self.error.emit(
	110	'Error processing driver string:\n{}'.format(e))
	111	return
	112
	113	# Process configuration string.
	114	try:
	115	cfgs = self.parse_configstring(cs)
	116	for k, v in cfgs.items():
	117	device.config_set(sr.ConfigKey.get_by_identifier(k), v)
	118	except Exception as e:
	119	self.error.emit(
	120	'Error processing configuration string:\n{}'.format(e))
	121	return
	122
	123	devices.append(device)
	124
	125	self.session = self.context.create_session()
	126	for dev in devices:
	127	self.session.add_device(dev)
	128	dev.open()
	129	self.session.add_datafeed_callback(self.callback)
	130	self.session.start()
	131	self.sampling = True
	132	self.session.run()
	133
	134	# If sampling is 'True' here, it means that 'stop_sampling()' was
	135	# not called, therefore 'session.run()' ended too early, indicating
	136	# an error.
	137	if self.sampling:
	138	self.error.emit('An error occured during the acquisition.')
	139
	140	def stop_sampling(self):
	141	if self.sampling:
	142	self.sampling = False
	143	self.session.stop()
	144
	145	def callback(self, device, packet):
	146	now = time.time()
	147
	148	if not sr:
	149	# In rare cases it can happen that the callback fires while
	150	# the interpreter is shutting down. Then the sigrok module
	151	# is already set to 'None'.
	152	return
	153
	154	if packet.type != sr.PacketType.ANALOG:
	155	return
	156
	157	if not len(packet.payload.channels):
	158	return
	159
	160	# TODO: find a device with multiple channels in one packet
	161	channel = packet.payload.channels[0]
	162
	163	# The most recent value.
	164	value = packet.payload.data[0][-1]
	165
	166	self.measured.emit(now, device, channel,
	167	(value, packet.payload.unit, packet.payload.mq_flags))
	168
	169	# Signal used to start the worker across threads.
	170	_start_signal = QtCore.Signal()
	171
	172	def __init__(self, context, drivers):
	173	super(self.__class__, self).__init__()
	174
	175	self.worker = self.Worker(context, drivers)
	176	self.thread = QtCore.QThread()
	177	self.worker.moveToThread(self.thread)
	178
	179	self._start_signal.connect(self.worker.start_sampling)
	180
	181	# Expose the signals of the worker.
	182	self.measured = self.worker.measured
	183	self.error = self.worker.error
	184
	185	self.thread.start()
	186
	187	def start(self):
	188	'''Start sampling.'''
	189	self._start_signal.emit()
	190
	191	def stop(self):
	192	'''Stop sampling and stop the background thread.'''
	193	self.worker.stop_sampling()
	194	self.thread.quit()
	195	self.thread.wait()