## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
##
+import itertools
+import math
import qtcompat
import sigrok.core as sr
+import util
+
+try:
+ from itertools import izip
+except ImportError:
+ izip = zip
QtCore = qtcompat.QtCore
QtGui = qtcompat.QtGui
+class Trace(object):
+ '''Class to hold the measured samples.'''
+
+ def __init__(self):
+ self.samples = []
+ self.new = False
+
+ def append(self, sample):
+ self.samples.append(sample)
+ self.new = True
+
class MeasurementDataModel(QtGui.QStandardItemModel):
'''Model to hold the measured values.'''
'''Role used to identify and find the item.'''
- _idRole = QtCore.Qt.UserRole + 1
+ idRole = QtCore.Qt.UserRole + 1
'''Role used to store the device vendor and model.'''
descRole = QtCore.Qt.UserRole + 2
+ '''Role used to store a dictionary with the traces.'''
+ tracesRole = QtCore.Qt.UserRole + 3
+
+ '''Role used to store the color to draw the graph of the channel.'''
+ colorRole = QtCore.Qt.UserRole + 4
+
def __init__(self, parent):
super(self.__class__, self).__init__(parent)
# Use the description text to sort the items for now, because the
- # _idRole holds tuples, and using them to sort doesn't work.
+ # idRole holds tuples, and using them to sort doesn't work.
self.setSortRole(MeasurementDataModel.descRole)
- # Used in 'format_value()' to check against.
- self.inf = float('inf')
-
- def format_unit(self, u):
- units = {
- sr.Unit.VOLT: 'V',
- sr.Unit.AMPERE: 'A',
- sr.Unit.OHM: u'\u03A9',
- sr.Unit.FARAD: 'F',
- sr.Unit.KELVIN: 'K',
- sr.Unit.CELSIUS: u'\u00B0C',
- sr.Unit.FAHRENHEIT: u'\u00B0F',
- sr.Unit.HERTZ: 'Hz',
- sr.Unit.PERCENTAGE: '%',
- # sr.Unit.BOOLEAN
- sr.Unit.SECOND: 's',
- sr.Unit.SIEMENS: 'S',
- sr.Unit.DECIBEL_MW: 'dBu',
- sr.Unit.DECIBEL_VOLT: 'dBV',
- # sr.Unit.UNITLESS
- sr.Unit.DECIBEL_SPL: 'dB',
- # sr.Unit.CONCENTRATION
- sr.Unit.REVOLUTIONS_PER_MINUTE: 'rpm',
- sr.Unit.VOLT_AMPERE: 'VA',
- sr.Unit.WATT: 'W',
- sr.Unit.WATT_HOUR: 'Wh',
- sr.Unit.METER_SECOND: 'm/s',
- sr.Unit.HECTOPASCAL: 'hPa',
- sr.Unit.HUMIDITY_293K: '%rF',
- sr.Unit.DEGREE: u'\u00B0',
- sr.Unit.HENRY: 'H'
- }
-
- return units.get(u, '')
+ # A generator for the colors of the channels.
+ self._colorgen = self._make_colorgen()
+
+ def _make_colorgen(self):
+ cols = [
+ QtGui.QColor(0x8F, 0x52, 0x02), # brown
+ QtGui.QColor(0x73, 0xD2, 0x16), # green
+ QtGui.QColor(0xCC, 0x00, 0x00), # red
+ QtGui.QColor(0x34, 0x65, 0xA4), # blue
+ QtGui.QColor(0xF5, 0x79, 0x00), # orange
+ QtGui.QColor(0xED, 0xD4, 0x00), # yellow
+ QtGui.QColor(0x75, 0x50, 0x7B) # violet
+ ]
+
+ def myrepeat(g, n):
+ '''Repeats every element from 'g' 'n' times'.'''
+ for e in g:
+ for f in itertools.repeat(e, n):
+ yield f
+
+ colorcycle = itertools.cycle(cols)
+ darkness = myrepeat(itertools.count(100, 10), len(cols))
+
+ for c, d in izip(colorcycle, darkness):
+ yield QtGui.QColor(c).darker(d)
def format_mqflags(self, mqflags):
if sr.QuantityFlag.AC in mqflags:
return ''
def format_value(self, mag):
- if mag == self.inf:
+ if math.isinf(mag):
return u'\u221E'
return '{:f}'.format(mag)
def getItem(self, device, channel):
- '''Returns the item for the device + channel combination from the model,
- or creates a new item if no existing one matches.'''
+ '''Return the item for the device + channel combination from the
+ model, or create a new item if no existing one matches.'''
- # unique identifier for the device + channel
- # TODO: isn't there something better?
+ # Unique identifier for the device + channel.
+ # TODO: Isn't there something better?
uid = (
device.vendor,
device.model,
channel.index
)
- # find the correct item in the model
+ # Find the correct item in the model.
for row in range(self.rowCount()):
item = self.item(row)
- rid = item.data(MeasurementDataModel._idRole)
- rid = tuple(rid) # PySide returns a list
+ rid = item.data(MeasurementDataModel.idRole)
+ rid = tuple(rid) # PySide returns a list.
if uid == rid:
return item
- # nothing found, create a new item
- desc = '{} {}, channel "{}"'.format(
+ # Nothing found, create a new item.
+ desc = '{} {}, {}'.format(
device.vendor, device.model, channel.name)
item = QtGui.QStandardItem()
- item.setData(uid, MeasurementDataModel._idRole)
+ item.setData(uid, MeasurementDataModel.idRole)
item.setData(desc, MeasurementDataModel.descRole)
+ item.setData({}, MeasurementDataModel.tracesRole)
+ item.setData(next(self._colorgen), MeasurementDataModel.colorRole)
self.appendRow(item)
self.sort(0)
return item
- @QtCore.Slot(object, object, object)
- def update(self, device, channel, data):
- '''Updates the data for the device (+channel) with the most recent
+ @QtCore.Slot(float, sr.classes.Device, sr.classes.Channel, tuple)
+ def update(self, timestamp, device, channel, data):
+ '''Update the data for the device (+channel) with the most recent
measurement from the given payload.'''
item = self.getItem(device, channel)
value, unit, mqflags = data
value_str = self.format_value(value)
- unit_str = self.format_unit(unit)
+ unit_str = util.format_unit(unit)
mqflags_str = self.format_mqflags(mqflags)
- disp = ' '.join([value_str, unit_str, mqflags_str])
+ # The display role is a tuple containing the value and the unit/flags.
+ disp = (value_str, ' '.join([unit_str, mqflags_str]))
item.setData(disp, QtCore.Qt.DisplayRole)
+ # The samples role is a dictionary that contains the old samples for each unit.
+ # Should be trimmed periodically, otherwise it grows larger and larger.
+ if not math.isinf(value) and not math.isnan(value):
+ sample = (timestamp, value)
+ traces = item.data(MeasurementDataModel.tracesRole)
+
+ # It's not possible to use 'collections.defaultdict' here, because
+ # PySide doesn't return the original type that was passed in.
+ if not (unit in traces):
+ traces[unit] = Trace()
+ traces[unit].append(sample)
+
+ item.setData(traces, MeasurementDataModel.tracesRole)
+
+ def clear_samples(self):
+ '''Removes all old samples from the model.'''
+ for row in range(self.rowCount()):
+ idx = self.index(row, 0)
+ self.setData(idx, {},
+ MeasurementDataModel.tracesRole)
+
class MultimeterDelegate(QtGui.QStyledItemDelegate):
'''Delegate to show the data items from a MeasurementDataModel.'''
def __init__(self, parent, font):
- '''Initializes the delegate.
+ '''Initialize the delegate.
- :param font: Font used for the description text, the value is drawn
- with a slightly bigger and bold variant of the font.
+ :param font: Font used for the text.
'''
super(self.__class__, self).__init__(parent)
self._nfont = font
- self._bfont = QtGui.QFont(self._nfont)
-
- self._bfont.setBold(True)
- if self._bfont.pixelSize() != -1:
- self._bfont.setPixelSize(self._bfont.pixelSize() * 1.8)
- else:
- self._bfont.setPointSizeF(self._bfont.pointSizeF() * 1.8)
fi = QtGui.QFontInfo(self._nfont)
self._nfontheight = fi.pixelSize()
- fm = QtGui.QFontMetrics(self._bfont)
+ fm = QtGui.QFontMetrics(self._nfont)
r = fm.boundingRect('-XX.XXXXXX X XX')
- self._size = QtCore.QSize(r.width() * 1.2, r.height() * 3.5)
+
+ w = 1.4 * r.width() + 2 * self._nfontheight
+ h = 2.6 * self._nfontheight
+ self._size = QtCore.QSize(w, h)
def sizeHint(self, option=None, index=None):
return self._size
+ def _color_rect(self, outer):
+ '''Returns the dimensions of the clickable rectangle.'''
+ x1 = (outer.height() - self._nfontheight) / 2
+ r = QtCore.QRect(x1, x1, self._nfontheight, self._nfontheight)
+ r.translate(outer.topLeft())
+ return r
+
def paint(self, painter, options, index):
- value = index.data(QtCore.Qt.DisplayRole)
+ value, unit = index.data(QtCore.Qt.DisplayRole)
desc = index.data(MeasurementDataModel.descRole)
+ color = index.data(MeasurementDataModel.colorRole)
- # description in the top left corner
painter.setFont(self._nfont)
+
+ # Draw the clickable rectangle.
+ painter.fillRect(self._color_rect(options.rect), color)
+
+ # Draw the text
+ h = options.rect.height()
p = options.rect.topLeft()
- p += QtCore.QPoint(self._nfontheight, 2 * self._nfontheight)
- painter.drawText(p, desc)
-
- # value in the center
- painter.setFont(self._bfont)
- r = options.rect.adjusted(self._nfontheight, 2.5 * self._nfontheight,
- 0, 0)
- painter.drawText(r, QtCore.Qt.AlignCenter, value)
+ p += QtCore.QPoint(h, (h + self._nfontheight) / 2 - 2)
+ painter.drawText(p, desc + ': ' + value + ' ' + unit)
+
+ def editorEvent(self, event, model, options, index):
+ if type(event) is QtGui.QMouseEvent:
+ if event.type() == QtCore.QEvent.MouseButtonPress:
+ rect = self._color_rect(options.rect)
+ if rect.contains(event.x(), event.y()):
+ c = index.data(MeasurementDataModel.colorRole)
+ c = QtGui.QColorDialog.getColor(c, None,
+ 'Choose new color for channel')
+ if c.isValid():
+ # False if cancel is pressed (resulting in a black
+ # color).
+ item = model.itemFromIndex(index)
+ item.setData(c, MeasurementDataModel.colorRole)
+
+ return True
+
+ return False
projects / sigrok-meter.git / blobdiff