Debian Codegraph @

eyes17/layouts/oscilloscope_widget.py

raw
1 import sys, time
2 import functools
3 from functools import partial
4
5 from PyQt5 import QtGui, QtCore, QtWidgets
6
7 import pyqtgraph as pg
8
9 import math, os.path, struct
10 import numpy as np
11 from collections import OrderedDict
12 from . import ui_advancedLogger,ui_inputSelector, ui_miniScope
13 from . gauge import Gauge
14 from . advancedLoggerTools import fit_sine,sine_eval,LOGGER, inputs, outputs
15
16 colors=['#00ff00','#ff0000','#ffff80',(10,255,255)]+[(50+np.random.randint(200),50+np.random.randint(200),150+np.random.randint(100)) for a in range(10)]
17
18 class miniscope(QtWidgets.QWidget,ui_miniScope.Ui_Form):
19 tbvals = [0.100, 0.200, 0.500, 1.0, 2.0, 5.0, 10.0, 20.0, 50.0,100.,200.] # allowed mS/div values
20 NP = 500 # Number of samples
21 TG = 1 # Number of channels
22 MINDEL = 1
23 MAXDEL = 1000
24 def __init__(self,parent,device):
25 super(miniscope, self).__init__(parent)
26 self.setupUi(self)
27 self.p = device
28 if self.p: self.A1Box.addItems(self.p.allAnalogChannels)
29 self.splitter.setSizes([500,100])
30 self.activeParameter = 0
31
32 self.curve = self.plot.plot(pen=colors[0])
33 self.fitcurve = self.plot.plot(pen=colors[1],width=2)
34 self.curve2 = self.plot.plot(pen=colors[2])
35 self.fitcurve2 = self.plot.plot(pen=colors[3],width=2)
36
37 self.region = pg.LinearRegionItem()
38 self.region.setBrush([255,0,50,50])
39 self.region.setZValue(10)
40 for a in self.region.lines: a.setCursor(QtGui.QCursor(QtCore.Qt.SizeHorCursor));
41 self.plot.addItem(self.region, ignoreBounds=False)
42 self.region.setRegion([.1,.5])
43
44 self.results = []
45 for a in ['amplitude','frequency','phase','offset','','','','','','']:
46 x = QtWidgets.QListWidgetItem(a)
47 self.list.addItem(x)
48 self.results.append(None)
49 def changeParameter(self,p):
50 self.activeParameter = p
51 self.message.setText('Selected Parameter = %s of %s'%(self.list.item(p).text(),self.A1Box.currentText()))
52
53 def timebaseChanged(self,val):
54 msperdiv = self.tbvals[int(val)] #millisecs / division
55 totalusec = msperdiv * 1000 * 10.0 # total 10 divisions
56 self.TG = int(totalusec/self.NP)
57 if self.TG < self.MINDEL:
58 self.TG = self.MINDEL
59 elif self.TG > self.MAXDEL:
60 self.TG = self.MAXDEL
61 xmax = self.TG*self.NP*1e-3
62 self.plot.setRange(xRange=[0,xmax])
63 self.timebaseLabel.setText('%.2f mS'%(totalusec/1e3))
64 self.region.setRegion([.1*xmax,.95*xmax])
65
66 def read(self,**kwargs):
67 chan = str(self.A1Box.currentText())
68 if self.p and chan in self.p.allAnalogChannels:
69 for a in range(10): self.list.item(a).setText('')
70 if self.A2Box.isChecked(): #2 channel capture
71 t,v,t2,v2 = self.p.capture2(self.NP,self.TG,chan)
72 self.curve.setData(t,v)
73 kwargs['fitCurve'] = self.fitcurve
74 res1 = self.sineFit(t,v,**kwargs)
75
76 if res1 is not None:
77 self.list.item(0).setText('Amplitude %.2f'%res1[0]);
78 self.list.item(1).setText('Frequency %.2f'%res1[1])
79 self.list.item(2).setText('Phase %.2f'%res1[2]);
80 self.list.item(3).setText('Offset %.2f'%res1[3]);
81
82
83 self.curve2.setData(t2,v2)
84 kwargs['fitCurve'] = self.fitcurve2
85 res2 = self.sineFit(t2,v2,**kwargs)
86
87 if res2 is not None:
88 self.list.item(4).setText('Amplitude %.2f'%res2[0]);
89 self.list.item(5).setText('Frequency %.2f'%res2[1])
90 self.list.item(6).setText('Phase %.2f'%res2[2]);
91 self.list.item(7).setText('Offset %.2f'%res2[3]);
92
93 if res1 is not None and res2 is not None:
94 try:
95 self.results = list(res1)+list(res2)
96 self.results.append(res2[0]/res1[0]) #Amplitude ratio
97 self.results.append(res2[2]-res1[2]) #Phase diff
98 self.list.item(8).setText('AMP(2/1) %.2f'%(res2[0]/res1[0]))
99 self.list.item(9).setText('Phase(2-1) %.2f'%(res2[2]-res1[2]))
100 return float(self.results[self.activeParameter])
101 except Exception as e:
102 print(e)
103 return False
104 else:
105 if self.activeParameter>3:
106 self.activeParameter = 0
107 self.list.setCurrentRow(0)
108 t,v = self.p.capture1(chan,self.NP,self.TG)
109 self.curve.setData(t,v)
110 kwargs['fitCurve'] = self.fitcurve
111 self.results = self.sineFit(t,v,**kwargs)
112
113 if self.results is not None:
114 self.list.item(0).setText('Amplitude %.2f'%self.results[0]);
115 self.list.item(1).setText('Frequency %.2f'%self.results[1])
116 self.list.item(2).setText('Phase %.2f'%self.results[2]);
117 self.list.item(3).setText('Offset %.2f'%self.results[3]);
118
119 return float(self.results[self.activeParameter])
120 return False
121
122 def changeChannel(self,chan):
123 chan = str(chan)
124 miny = min(self.p.analogInputSources[chan].calPoly10(0),self.p.analogInputSources[chan].calPoly10(1023))
125 maxy = max(self.p.analogInputSources[chan].calPoly10(0),self.p.analogInputSources[chan].calPoly10(1023))
126 self.plot.setRange(yRange=[miny,maxy])
127
128 def sineFit(self,t,v,**kwargs):
129 S,E=self.region.getRegion()
130 start = (np.abs(t - S)).argmin()
131 end = (np.abs(t - E)).argmin()
132 try:
133 fa=fit_sine(t[start:end],v[start:end])
134 if fa is not None:
135 amp=abs(fa[0])
136 freq=fa[1]*1e3
137 if 'freq' in kwargs and self.freqCheckBox.isChecked(): #Input frequency supplied. check for fitting error
138 if ( abs(kwargs.get('freq') - freq)/freq ) > 0.1: #Frequency mismatch >10%
139 return None
140
141 phase = fa[2]*180/np.pi
142 offset = fa[3]
143 #self.message.setText(s)
144 x = np.linspace(t[start],t[end],1000)
145 if 'fitCurve' in kwargs:
146 kwargs['fitCurve'].clear()
147 kwargs['fitCurve'].setData(x,sine_eval(x,fa))
148 return amp,freq,phase,offset
149 except Exception as e:
150 self.message.setText('fit failed')
151 print(e)
152 return None
153
154 class DIOINPUT(QtWidgets.QDialog,ui_inputSelector.Ui_Dialog):
155 SLIDER_SCALING = 1000.
156 def __init__(self,parent,device,confirmValues,**kwargs):
157 super(DIOINPUT, self).__init__(parent)
158 self.setupUi(self)
159 self.titlePrefix = kwargs.get('title','')+ ': '
160 self.confirmValues = confirmValues
161 self.subSelection.setStyleSheet("border: 3px dashed #5353ff;")
162 self.selectedGauge = None
163
164 self.p = device
165 if self.p: self.I2C = self.p.I2C
166 self.inputs = inputs(self.p)
167 self.outputs = outputs(self.p)
168 self.type = None
169 self.autoRefresh = True
170 self.functions = []
171
172
173 self.initialize = None
174 self.read = None
175 self.widgets =[]
176 self.gauges = []
177 self.miniscope = None
178 self.activeSensor = None
179 self.permanentInputs = self.inputs.permanentInputs
180 self.permanentOutputs = self.outputs.permanentOutputs
181 self.init()
182
183 def reconnect(self,device):
184 self.p = device
185 self.I2C = self.p.I2C
186 self.inputs.__init__(self.p)
187 self.outputs.__init__(self.p)
188 #self.outputs.setDevice(self.p)
189 self.permanentInputs = self.inputs.permanentInputs
190 self.permanentOutputs = self.outputs.permanentOutputs
191 self.init()
192
193 def init(self):
194 self.updateOptions(self.permanentInputs+self.refreshSensorList(),self.permanentOutputs)
195
196 def refreshSensorList(self):
197 self.logger = LOGGER(self.I2C)
198 x = self.logger.I2CScan()
199 #print('I2C Found: ',x)
200 self.sensorList = []
201 for a in x:
202 s = self.logger.sensors.get(a,None)
203 if s is not None:
204 self.sensorList.append(s)
205 return self.sensorList
206
207 def updateOptions(self,sensors,outputs):
208 self.sensors = sensors+outputs
209 self.availableInputs.blockSignals(True)
210
211 self.availableInputs.clear()
212 self.availableInputs.addItems([a['name'] for a in self.sensors])
213 if self.activeSensor not in self.sensors:
214 self.loadSensor(self.sensors[0])
215 self.availableInputs.blockSignals(False)
216
217 def selectSensor(self,index):
218 self.loadSensor(self.sensors[index])
219 self.subSelectionChanged(0)
220
221 def subSelectionChanged(self,index):
222 name = str(self.subSelection.currentText())
223 self.subSelectionIndex = index
224 for a in self.gauges:
225 if a.title_text == name:
226 a.gauge_color_inner_radius_factor = 0.5
227 a.set_NeedleColor(255, 0, 0, 255)
228 self.selectedGauge = a
229 else:
230 a.gauge_color_inner_radius_factor = 0.9
231 a.set_NeedleColor(100, 100, 100, 255)
232 self.minValue.setValue(self.activeSensor['min'][index])
233 self.maxValue.setValue(self.activeSensor['max'][index])
234
235 def loadSensor(self,sensor):
236 self.activeSensor = sensor
237 self.name = sensor['name']
238 self.funtions = {}
239 self.initialize = sensor['init']
240 self.initialize()
241
242
243 self.max = sensor.get('max',None)
244 self.min = sensor.get('min',None)
245 self.type = sensor['type']
246 self.autoRefresh = sensor.get('autorefresh',True)
247
248 for a in self.widgets:
249 a.setParent(None)
250 self.widgets =[]
251 for a in sensor.get('config',[]): #Load configuration menus
252 l = QtWidgets.QLabel(a.get('name',''))
253 self.configLayout.addWidget(l) ; self.widgets.append(l)
254 l = QtWidgets.QComboBox(); l.addItems(a.get('options',[]))
255 l.currentIndexChanged['int'].connect(a.get('function',None))
256 self.configLayout.addWidget(l) ; self.widgets.append(l)
257
258 for a in sensor.get('spinboxes',[]): #Load spinbox configuration options
259 label = QtWidgets.QLabel(a.get('name',''))
260 self.configLayout.addWidget(label) ; self.widgets.append(label)
261 l = QtWidgets.QSlider()
262 l.setOrientation(QtCore.Qt.Horizontal)
263 l.setProperty("class", "symmetric volts")
264 l.setMaximumSize(QtCore.QSize(300, 16777215))
265 MIN = a.get('minimum',0); MAX = a.get('maximum',100)
266 l.setMinimum(MIN)
267 l.setMaximum(MAX)
268 l.setValue(a.get('value',(MAX+MIN)/2)) #Move to midpoint if value is not specified
269 l.setObjectName(a.get('name','undef'))
270 l.valueChanged['int'].connect(a.get('function',None))
271 self.configLayout.addWidget(l) ; self.widgets.append(l)
272
273
274 for a in self.gauges:
275 a.setParent(None)
276 self.gauges = []
277 self.subSelection.clear()
278
279 if self.miniscope:
280 self.miniscope.setParent(None);
281 self.read=None;
282 self.miniscope=None
283
284 self.functions = []
285 row = 1; col=1;
286 parameters=0
287
288 if 'scope' in self.name: # It's an oscilloscope. make a plot instead of gauges
289 self.miniscope = miniscope(self,self.p)
290 self.gaugeLayout.addWidget(self.miniscope)
291 self.setWindowTitle(self.titlePrefix + 'Oscilloscope with analysis')
292 self.read = self.miniscope.read
293
294 else:
295 self.fields = sensor.get('fields',None)
296 self.subSelection.addItems(self.fields)
297 self.subSelectionIndex = 0
298 for a,b,c in zip(self.fields,self.min,self.max):
299 gauge = Gauge(self,a)
300 gauge.setObjectName(a)
301 gauge.set_MinValue(b)
302 gauge.set_MaxValue(c)
303 self.gaugeLayout.addWidget(gauge,row,col)
304 self.gauges.append(gauge)
305 col+= 1
306 if col == 4:
307 row += 1
308 col = 1
309
310
311 if sensor['type'] == 'output':
312 l = QtWidgets.QSlider(self); l.setMinimum(b*self.SLIDER_SCALING); l.setMaximum(c*self.SLIDER_SCALING);l.setValue(b*self.SLIDER_SCALING);
313 l.setOrientation(QtCore.Qt.Horizontal)
314 gauge.value_needle_snapzone = 1
315 gauge.valueChanged.connect(functools.partial(self.showval,parameters))
316
317 l.valueChanged['int'].connect(functools.partial(self.write,parameters))
318 self.configLayout.addWidget(l) ; self.widgets.append(l)
319 self.functions.append(sensor['write'])
320 for a in sensor.get('outputconfig',[]): #Load configuration menus
321 l = QtWidgets.QLabel(a.get('name',''))
322 self.configLayout.addWidget(l) ; self.widgets.append(l)
323 l = QtWidgets.QComboBox(); l.addItems(a.get('options',[]))
324 l.currentIndexChanged['int'].connect(a.get('function',None))
325 self.configLayout.addWidget(l) ; self.widgets.append(l)
326
327
328 parameters+=1
329
330 if not self.autoRefresh: #Time consuming , blocking function call. add a button for it.
331 l = QtWidgets.QPushButton("MAKE A MEASUREMENT",self)
332 l.clicked.connect(self.readAndUpdate)
333 self.configLayout.addWidget(l) ; self.widgets.append(l)
334
335 if sensor['type'] == 'input':
336 self.read = sensor['read']
337 self.setWindowTitle(self.titlePrefix + 'Input : %s'%self.name)
338 else:
339 self.read = None
340 self.setWindowTitle(self.titlePrefix + 'Output : %s'%self.name)
341
342 def showval(self,index,v):
343 self.gauges[index].value = v
344 self.gauges[index].update()
345 self.widgets[index].setValue(v*self.SLIDER_SCALING)
346
347 def write(self,index,val):
348 val/=self.SLIDER_SCALING
349 self.gauges[index].update_value(val)
350 self.functions[index](val)
351
352 def readAndUpdate(self):
353 a = self.read()
354 self.message.setText(str(a))
355 if a is not None:
356 self.setValue(a)
357
358 def setValue(self,vals):
359 if vals is None:
360 print('check connections')
361 return
362 p=0
363 for a in self.gauges:
364 a.update_value(vals[p])
365 p+=1
366
367 def confirm(self):
368 if self.confirmValues is None: return
369 if 'scope' in self.name:
370 self.confirmValues('Oscilloscope:%s:%s'%(self.miniscope.A1Box.currentText(),self.miniscope.list.item(self.miniscope.activeParameter).text()))
371 else:
372 self.confirmValues('%s:%s'%(self.activeSensor['name'],self.activeSensor['fields'][self.subSelectionIndex]))
373
374 self.hide()
375
376 def initSweep(self,steps):
377 self.value = self.minValue.value()#self.min[self.subSelectionIndex]
378 self.endValue = self.maxValue.value()#self.max[self.subSelectionIndex]
379 self.stepSize = (self.endValue - self.value)/steps
380 self.message.setText('%.2f -> %.2f in %d steps'%(self.value,self.endValue,steps))
381 if self.type == 'output': #Output
382 self.write(self.subSelectionIndex,self.value*self.SLIDER_SCALING)
383 self.message.setText('%.2f / %.2f'%(self.value,self.endValue))
384
385 def nextValue(self,**kwargs):
386 if 'scope' in self.name:
387 return self.read(**kwargs)
388 elif self.type == 'input':
389 a = self.read()
390 if a is not None:
391 if len(a)>=self.subSelectionIndex:
392 self.setValue(a)
393 try:
394 return a[self.subSelectionIndex]
395 except:
396 return False
397 elif self.type == 'output': #Output
398 self.write(self.subSelectionIndex,self.value*self.SLIDER_SCALING)
399 self.message.setText('%.2f / %.2f'%(self.value,self.endValue))
400 v = self.value
401
402 self.value+=self.stepSize
403 if self.value>self.endValue:
404 return None #None returned will stop the acquisition
405 return v
406
407 return False
408
409 def getValue(self,a):
410 v = a.read()
411 if v is not None:
412 return v[self.subSelectionIndex]
413 return None
414
415 def launch(self,setWindow=None):
416 if self.initialize is not None:
417 self.initialize()
418 if setWindow is not None:
419 self.setWindow(setWindow)
420 self.show()
421
422 def setWindow(self,win):
423 p=0
424 for a in self.sensors:
425 if win.lower() == a['name'].lower():
426 #self.loadSensor(a)
427 self.availableInputs.setCurrentIndex(p)
428 break
429 p+=1
430
431 def reposition(self,pos):
432 ph = self.parent().geometry().height()
433 px = self.parent().geometry().x()
434 py = self.parent().geometry().y()
435 dw = self.width()
436 dh = self.height()
437 if pos == 'bottom-left':
438 self.setGeometry( px, py+ph-dh, dw, dh )
439 elif pos == 'top-left':
440 self.setGeometry( px, py, dw, dh )