def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setTitle('Cartesian Coordinate System Demo')
# create a plot with a white canvas
self.setCanvasBackground(Qt.white)
# set plot layout
self.plotLayout().setCanvasMargin(0)
self.plotLayout().setAlignCanvasToScales(True)
# attach a grid
grid = QwtPlotGrid()
grid.attach(self)
grid.setPen(QPen(Qt.black, 0, Qt.DotLine))
# attach a x-axis
xaxis = CartesianAxis(QwtPlot.xBottom, QwtPlot.yLeft)
xaxis.attach(self)
self.enableAxis(QwtPlot.xBottom, False)
# attach a y-axis
yaxis = CartesianAxis(QwtPlot.yLeft, QwtPlot.xBottom)
yaxis.attach(self)
self.enableAxis(QwtPlot.yLeft, False)
# calculate 3 NumPy arrays
x = np.arange(-2*np.pi, 2*np.pi, 0.01)
y = np.pi*np.sin(x)
z = 4*np.pi*np.cos(x)*np.cos(x)*np.sin(x)
# attach a curve
curve = QwtPlotCurve('y = pi*sin(x)')
curve.attach(self)
curve.setPen(QPen(Qt.green, 2))
curve.setData(x, y)
# attach another curve
curve = QwtPlotCurve('y = 4*pi*sin(x)*cos(x)**2')
curve.attach(self)
curve.setPen(QPen(Qt.black, 2))
curve.setData(x, z)
self.replot()
def __init__(self, *args):
QFrame.__init__(self, *args)
self.xMap = QwtScaleMap()
self.xMap.setScaleInterval(-0.5, 10.5)
self.yMap = QwtScaleMap()
self.yMap.setScaleInterval(-1.1, 1.1)
# frame style
self.setFrameStyle(QFrame.Box | QFrame.Raised)
self.setLineWidth(2)
self.setMidLineWidth(3)
# calculate values
self.x = np.arange(0, 10.0, 10.0/27)
self.y = np.sin(self.x)*np.cos(2*self.x)
# make curves with different styles
self.curves = []
self.titles = []
# curve 2
self.titles.append('Style: Lines, Symbol: None')
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.darkBlue))
curve.setStyle(QwtPlotCurve.Lines)
self.curves.append(curve)
# attach data, using Numeric
for curve in self.curves:
curve.setData(self.x, self.y)
def __init__(self, *args):
QFrame.__init__(self, *args)
self.xMap = QwtScaleMap()
self.xMap.setScaleInterval(-0.5, 10.5)
self.yMap = QwtScaleMap()
self.yMap.setScaleInterval(-1.1, 1.1)
# frame style
self.setFrameStyle(QFrame.Box | QFrame.Raised)
self.setLineWidth(2)
self.setMidLineWidth(3)
# calculate values
self.x = np.arange(0, 10.0, 10.0 / 27)
self.y = np.sin(self.x) * np.cos(2 * self.x)
# make curves with different styles
self.curves = []
self.titles = []
# curve 1
self.titles.append("Style: Sticks, Symbol: Ellipse")
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.red))
curve.setStyle(QwtPlotCurve.Sticks)
curve.setSymbol(
QwtSymbol(QwtSymbol.Ellipse, QBrush(Qt.yellow), QPen(Qt.blue),
QSize(5, 5)))
self.curves.append(curve)
# curve 2
self.titles.append("Style: Lines, Symbol: None")
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.darkBlue))
curve.setStyle(QwtPlotCurve.Lines)
self.curves.append(curve)
# curve 3
self.titles.append("Style: Lines, Symbol: None, Antialiased")
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.darkBlue))
curve.setStyle(QwtPlotCurve.Lines)
curve.setRenderHint(QwtPlotItem.RenderAntialiased)
self.curves.append(curve)
# curve 4
self.titles.append("Style: Steps, Symbol: None")
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.darkCyan))
curve.setStyle(QwtPlotCurve.Steps)
self.curves.append(curve)
# curve 5
self.titles.append("Style: NoCurve, Symbol: XCross")
curve = QwtPlotCurve()
curve.setStyle(QwtPlotCurve.NoCurve)
curve.setSymbol(
QwtSymbol(QwtSymbol.XCross, QBrush(), QPen(Qt.darkMagenta),
QSize(5, 5)))
self.curves.append(curve)
# attach data, using Numeric
for curve in self.curves:
curve.setData(self.x, self.y)
class Example(QtGui.QWidget):
def __init__(self):
super(Example, self).__init__()
self.initUI()
self.current_y = 0
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.update_plot)
self.timer.setInterval(1000 / FREQ)
self.timer.start()
def initUI(self):
self.setGeometry(300, 300, 1000, 1000)
self.setWindowTitle('Icon')
self.setWindowIcon(QtGui.QIcon('web.png'))
self.plot = QwtPlot("Test", self)
self.plot.resize(900, 900)
self.curve = QwtPlotCurve("Curve 1")
self.curve.attach(self.plot)
self.show()
def update_plot(self):
self.curve.setData(x, ys[self.current_y])
self.current_y = (self.current_y + 1) % YS
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setTitle("Cartesian Coordinate System Demo")
# create a plot with a white canvas
self.setCanvasBackground(Qt.white)
# set plot layout
self.plotLayout().setCanvasMargin(0)
self.plotLayout().setAlignCanvasToScales(True)
# attach a grid
grid = QwtPlotGrid()
grid.attach(self)
grid.setPen(QPen(Qt.black, 0, Qt.DotLine))
# attach a x-axis
xaxis = CartesianAxis(QwtPlot.xBottom, QwtPlot.yLeft)
xaxis.attach(self)
self.enableAxis(QwtPlot.xBottom, False)
# attach a y-axis
yaxis = CartesianAxis(QwtPlot.yLeft, QwtPlot.xBottom)
yaxis.attach(self)
self.enableAxis(QwtPlot.yLeft, False)
# calculate 3 NumPy arrays
x = np.arange(-2 * np.pi, 2 * np.pi, 0.01)
y = np.pi * np.sin(x)
z = 4 * np.pi * np.cos(x) * np.cos(x) * np.sin(x)
# attach a curve
curve = QwtPlotCurve("y = pi*sin(x)")
curve.attach(self)
curve.setPen(QPen(Qt.green, 2))
curve.setData(x, y)
# attach another curve
curve = QwtPlotCurve("y = 4*pi*sin(x)*cos(x)**2")
curve.attach(self)
curve.setPen(QPen(Qt.black, 2))
curve.setData(x, z)
self.replot()
class MyWindow(QtGui.QMainWindow):
"""
This class implements a derivative of
PyQt4.QtGui.QMainWindow, a complete application
window, which can feature menus, submenus,
status bar, etc. In this example, it uses
few of those features.
"""
def __init__(self, parent=None):
"""
Constructor: creates an instance of MyWindow
"""
#########################################
# Necessary actions, which must be done #
# for any project #
#########################################
# first, calling the ancestor's creator
QtGui.QMainWindow.__init__(self, parent)
# get the User Interface from the module UI_p1
self.ui=Ui_MainWindow()
# initialize the user interface
self.ui.setupUi(self)
#########################################
# Custom actions, which can be written #
# in other ways for other projects. #
#########################################
# aliases for some parts of the user interface
self.plotWidget = self.ui.qwtPlot
self.measureButton = self.ui.measureButton
self.closeButton = self.ui.closeButton
# connect methods to buttons' click signals
self.measureButton.clicked.connect(self.measure)
self.closeButton.clicked.connect(self.close)
# initialize an empty curve for the plot widget
self.curve = QwtPlotCurve()
self.curve.attach(self.plotWidget)
return
def measure(self):
"""
This is a custom method to connect to the
button for measurements.
There is no need for another custom method,
since the method "close" is already inherited
from the ancestor class.
"""
# create data for a curve with some fixed
# and some random features
import random
x=np.arange(0,8,1e-2) # abscissa: [0, 0.01, 0.02, ... 7.99]
r=random.random()
y=np.sin(x)+r*np.sin(3*x) # calculated ordinate
# feed new data into the curve
self.curve.setData(x,y,len(x))
# change the title of the plot on the fly
self.plotWidget.setTitle("sin(x) + {} sin(3x)".format(r))
# display the result
self.plotWidget.replot()
return
class Example(QtGui.QWidget):
def __init__(self):
super(Example, self).__init__()
self.initUI()
self.current_y = 0
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.update_plot)
self.timer.setInterval(1000/FREQ)
self.timer.start()
def initUI(self):
self.setGeometry(300, 300, 1000, 1000)
self.setWindowTitle('Icon')
self.setWindowIcon(QtGui.QIcon('web.png'))
self.plot = QwtPlot("Test", self)
self.plot.resize(900, 900)
self.curve = QwtPlotCurve("Curve 1")
self.curve.attach(self.plot)
self.show()
def update_plot(self):
self.curve.setData(x, ys[self.current_y])
self.current_y = (self.current_y + 1) % YS
def pbServerClicked(self):
if self.ServerActive == 0:
self.N = self.sbNsig.value()
self.Hist = int(self.edHist.text().__str__())
self.pbStartServer.setText('Stop Server')
self.ServerActive = 1
self.plot = dataPlot(self.N)
self.plot.resize(800, 500)
self.plot.show()
self.timebase = []
self.x = []
self.c = []
for n in range(0, self.N):
self.x.append([])
cv = QwtPlotCurve()
pen = QPen(QColor(self.colors[n % 8]))
pen.setWidth(WIDTH)
cv.setPen(pen)
cv.setData([], [])
self.c.append(cv)
self.c[n].attach(self.plot)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.pltRefresh)
refTimer = self.sbRefT.value()
self.timer.start(refTimer)
self.th = rcvServer(self)
self.th.start()
else:
self.pbStartServer.setText('Start Server')
self.ServerActive = 0
self.stopServer()
def createCurve(self, x, y, colour):
curve = QwtPlotCurve()
colour = QColor(colour)
curve.setPen(colour)
curve.setData(x, y)
curve.attach(self.plot)
#self.plot.replot()
self.curves.append(curve)
class MyWindow(QtGui.QMainWindow):
"""
This class implements a derivative of
PyQt4.QtGui.QMainWindow, a complete application
window, which can feature menus, submenus,
status bar, etc. In this example, it uses
few of those features.
"""
def __init__(self, parent=None):
"""
Constructor: creates an instance of MyWindow
"""
#########################################
# Necessary actions, which must be done #
# for any project #
#########################################
# first, calling the ancestor's creator
QtGui.QMainWindow.__init__(self, parent)
# get the User Interface from the module UI_p1
self.ui=Ui_MainWindow()
# initialize the user interface
self.ui.setupUi(self)
#########################################
# Custom actions, which can be written #
# in other ways for other projects. #
#########################################
# aliases for some parts of the user interface
self.plotWidget = self.ui.qwtPlot
self.measureButton = self.ui.measureButton
self.closeButton = self.ui.closeButton
# connect methods to buttons' click signals
self.measureButton.clicked.connect(self.measure)
self.closeButton.clicked.connect(self.close)
# initialize an empty curve for the plot widget
self.curve = QwtPlotCurve()
self.curve.attach(self.plotWidget)
# initialize the driver for expEYES Junior
self.p = ej.open()
return
def measure(self):
"""
This is a custom method to connect to the
button for measurements.
There is no need for another custom method,
since the method "close" is already inherited
from the ancestor class.
"""
t,v = self.p.capture(1,1000,200)
self.curve.setData(t,v,len(t))
# display the result
self.plotWidget.replot()
return
def __insertCurve(self, orientation, color, base):
curve = QwtPlotCurve()
curve.attach(self)
curve.setPen(QPen(color))
curve.setSymbol(QwtSymbol(QwtSymbol.Ellipse, QBrush(Qt.gray), QPen(color), QSize(8, 8)))
fixed = base * np.ones(10, np.float)
changing = np.arange(0, 95.0, 10.0, np.float) + 5.0
if orientation == Qt.Horizontal:
curve.setData(changing, fixed)
else:
curve.setData(fixed, changing)
def __insertCurve(self, orientation, color, base):
curve = QwtPlotCurve()
curve.attach(self)
curve.setPen(QPen(color))
curve.setSymbol(
QwtSymbol(QwtSymbol.Ellipse, QBrush(Qt.gray), QPen(color), QSize(8, 8))
)
fixed = base * np.ones(10, np.float)
changing = np.arange(0, 95.0, 10.0, np.float) + 5.0
if orientation == Qt.Horizontal:
curve.setData(changing, fixed)
else:
curve.setData(fixed, changing)
def setData(self, *args):
"""Set x versus y data with error bars in dx and dy.
Horizontal error bars are plotted if dx is not None.
Vertical error bars are plotted if dy is not None.
x and y must be sequences with a shape (N,) and dx and dy must be
sequences (if not None) with a shape (), (N,), or (2, N):
- if dx or dy has a shape () or (N,), the error bars are given by
(x-dx, x+dx) or (y-dy, y+dy),
- if dx or dy has a shape (2, N), the error bars are given by
(x-dx[0], x+dx[1]) or (y-dy[0], y+dy[1]).
"""
if len(args) == 1:
QwtPlotCurve.setData(self, *args)
return
dx = None
dy = None
x, y = args[:2]
if len(args) > 2:
dx = args[2]
if len(args) > 3:
dy = args[3]
self.__x = np.asarray(x, np.float)
if len(self.__x.shape) != 1:
raise RuntimeError('len(asarray(x).shape) != 1')
self.__y = np.asarray(y, np.float)
if len(self.__y.shape) != 1:
raise RuntimeError('len(asarray(y).shape) != 1')
if len(self.__x) != len(self.__y):
raise RuntimeError('len(asarray(x)) != len(asarray(y))')
if dx is None:
self.__dx = None
else:
self.__dx = np.asarray(dx, np.float)
if len(self.__dx.shape) not in [0, 1, 2]:
raise RuntimeError('len(asarray(dx).shape) not in [0, 1, 2]')
if dy is None:
self.__dy = dy
else:
self.__dy = np.asarray(dy, np.float)
if len(self.__dy.shape) not in [0, 1, 2]:
raise RuntimeError('len(asarray(dy).shape) not in [0, 1, 2]')
QwtPlotCurve.setData(self, self.__x, self.__y)
def setData(self, *args):
"""Set x versus y data with error bars in dx and dy.
Horizontal error bars are plotted if dx is not None.
Vertical error bars are plotted if dy is not None.
x and y must be sequences with a shape (N,) and dx and dy must be
sequences (if not None) with a shape (), (N,), or (2, N):
- if dx or dy has a shape () or (N,), the error bars are given by
(x-dx, x+dx) or (y-dy, y+dy),
- if dx or dy has a shape (2, N), the error bars are given by
(x-dx[0], x+dx[1]) or (y-dy[0], y+dy[1]).
"""
if len(args) == 1:
QwtPlotCurve.setData(self, *args)
return
dx = None
dy = None
x, y = args[:2]
if len(args) > 2:
dx = args[2]
if len(args) > 3:
dy = args[3]
self.__x = np.asarray(x, np.float)
if len(self.__x.shape) != 1:
raise RuntimeError('len(asarray(x).shape) != 1')
self.__y = np.asarray(y, np.float)
if len(self.__y.shape) != 1:
raise RuntimeError('len(asarray(y).shape) != 1')
if len(self.__x) != len(self.__y):
raise RuntimeError('len(asarray(x)) != len(asarray(y))')
if dx is None:
self.__dx = None
else:
self.__dx = np.asarray(dx, np.float)
if len(self.__dx.shape) not in [0, 1, 2]:
raise RuntimeError('len(asarray(dx).shape) not in [0, 1, 2]')
if dy is None:
self.__dy = dy
else:
self.__dy = np.asarray(dy, np.float)
if len(self.__dy.shape) not in [0, 1, 2]:
raise RuntimeError('len(asarray(dy).shape) not in [0, 1, 2]')
QwtPlotCurve.setData(self, self.__x, self.__y)
class AlphaEpsilonPlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
self.enableAxis(self.xBottom)
# insert a few curves
self.Alpha = QwtPlotCurve('Alpha')
self.Alpha.setPen(QPen(Qt.red))
self.Alpha.attach(self)
self.Epsilon = QwtPlotCurve('Epsilon')
self.Epsilon.setPen(QPen(Qt.blue))
self.Epsilon.attach(self)
# initialize the data
self.Alpha.setData([0], [0])
self.Epsilon.setData([0], [0])
# replot
self.replot()
def newData(self, Alpha, Epsilon):
self.Alpha.setData(list(range(len(Alpha))), Alpha)
self.Epsilon.setData(list(range(len(Epsilon))), Epsilon)
# replot
self.replot()
def __init__(self, title, xdata, ydata, style, symbol=None, *args):
super(BMPlot, self).__init__(*args)
self.setMinimumSize(200, 200)
self.setTitle(title)
self.setAxisTitle(QwtPlot.xBottom, 'x')
self.setAxisTitle(QwtPlot.yLeft, 'y')
curve = QwtPlotCurve()
curve.setPen(QPen(get_curve_color()))
curve.setStyle(style)
curve.setRenderHint(QwtPlotCurve.RenderAntialiased)
if symbol is not None:
curve.setSymbol(symbol)
curve.attach(self)
curve.setData(xdata, ydata)
self.replot()
def create_log_plot():
plot = QwtPlot('LogCurveDemo.py (or how to handle -inf values)')
plot.enableAxis(QwtPlot.xBottom)
plot.setAxisScaleEngine(QwtPlot.yLeft, QwtLogScaleEngine())
curve = QwtPlotCurve()
curve.setRenderHint(QwtPlotCurve.RenderAntialiased)
pen = QPen(Qt.magenta)
pen.setWidth(1.5)
curve.setPen(pen)
curve.attach(plot)
x = np.arange(0.0, 10.0, 0.1)
y = 10*np.cos(x)**2-.1
print("y<=0:", y<=0)
curve.setData(x, y)
plot.replot()
return plot
def create_log_plot():
plot = QwtPlot('LogCurveDemo.py (or how to handle -inf values)')
plot.enableAxis(QwtPlot.xBottom)
plot.setAxisScaleEngine(QwtPlot.yLeft, QwtLogScaleEngine())
curve = QwtPlotCurve()
curve.setRenderHint(QwtPlotCurve.RenderAntialiased)
pen = QPen(Qt.magenta)
pen.setWidth(1.5)
curve.setPen(pen)
curve.attach(plot)
x = np.arange(0.0, 10.0, 0.1)
y = 10 * np.cos(x)**2 - .1
print("y<=0:", y <= 0)
curve.setData(x, y)
plot.replot()
return plot
def setData(self, *args):
if len(args) == 1:
QwtPlotCurve.setData(self, *args)
return
x, y = args[:2]
if len(args) > 2:
self.symbolSizes = args[2]
self.__x = numpy.asarray(x, numpy.float)
if len(self.__x.shape) != 1:
raise RuntimeError('len(asarray(x).shape) != 1')
self.__y = numpy.asarray(y, numpy.float)
if len(self.__y.shape) != 1:
raise RuntimeError('len(asarray(y).shape) != 1')
if len(self.__x) != len(self.__y):
raise RuntimeError('len(asarray(x)) != len(asarray(y))')
QwtPlotCurve.setData(self, self.__x, self.__y)
class DataPlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setCanvasBackground(Qt.white)
# Initialize data
self.x = [0]
self.y = [0]
self.setTitle("A Moving QwtPlot Demonstration")
self.insertLegend(QwtLegend(), QwtPlot.BottomLegend);
self.curveR = QwtPlotCurve("Data Moving Right")
self.curveR.attach(self)
self.curveR.setPen(QPen(Qt.red))
self.setAxisTitle(QwtPlot.xBottom, "Time (seconds)")
self.setAxisTitle(QwtPlot.yLeft, "Values")
self.startTimer(400)
self.phase = 0.0
#self.setAlignCanvasToScales(0.5,0.2)
def timerEvent(self, e):
if self.phase > np.pi - 0.0001:
self.phase = 0.0
# y moves from left to right:
# shift y array right and assign new value y[0]
self.y.append(self.phase+5*random.random())
self.x.append(self.phase*3+0.4*random.random())
# z moves from right to left:
# Shift z array left and assign new value to z[n-1].
self.curveR.setData(self.x, self.y)
self.replot()
self.phase += np.pi*0.0
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setTitle('ReallySimpleDemo.py')
self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
self.setAxisTitle(QwtPlot.xBottom, 'x -->')
self.setAxisTitle(QwtPlot.yLeft, 'y -->')
self.enableAxis(self.xBottom)
# insert a few curves
cSin = QwtPlotCurve('y = sin(x)')
cSin.setPen(QPen(Qt.red))
cSin.attach(self)
cCos = QwtPlotCurve('y = cos(x)')
cCos.setPen(QPen(Qt.blue))
cCos.attach(self)
# make a Numeric array for the horizontal data
x = np.arange(0.0, 10.0, 0.1)
# initialize the data
cSin.setData(x, np.sin(x))
cCos.setData(x, np.cos(x))
# insert a horizontal marker at y = 0
mY = QwtPlotMarker()
mY.setLabel(QwtText('y = 0'))
mY.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
mY.setLineStyle(QwtPlotMarker.HLine)
mY.setYValue(0.0)
mY.attach(self)
# insert a vertical marker at x = 2 pi
mX = QwtPlotMarker()
mX.setLabel(QwtText('x = 2 pi'))
mX.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
mX.setLineStyle(QwtPlotMarker.VLine)
mX.setXValue(2*np.pi)
mX.attach(self)
# replot
self.replot()
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setTitle('ReallySimpleDemo.py')
self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
self.setAxisTitle(QwtPlot.xBottom, 'x -->')
self.setAxisTitle(QwtPlot.yLeft, 'y -->')
self.enableAxis(self.xBottom)
# insert a few curves
cSin = QwtPlotCurve('y = sin(x)')
cSin.setPen(QPen(Qt.red))
cSin.attach(self)
cCos = QwtPlotCurve('y = cos(x)')
cCos.setPen(QPen(Qt.blue))
cCos.attach(self)
# make a Numeric array for the horizontal data
x = np.arange(0.0, 10.0, 0.1)
# initialize the data
cSin.setData(x, np.sin(x))
cCos.setData(x, np.cos(x))
# insert a horizontal marker at y = 0
mY = QwtPlotMarker()
mY.setLabel(QwtText('y = 0'))
mY.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
mY.setLineStyle(QwtPlotMarker.HLine)
mY.setYValue(0.0)
mY.attach(self)
# insert a vertical marker at x = 2 pi
mX = QwtPlotMarker()
mX.setLabel(QwtText('x = 2 pi'))
mX.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
mX.setLineStyle(QwtPlotMarker.VLine)
mX.setXValue(2 * np.pi)
mX.attach(self)
# replot
self.replot()
class RewardPlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
self.enableAxis(self.xBottom)
# insert a few curves
self.Reward = QwtPlotCurve('Reward')
self.Reward.setPen(QPen(Qt.darkGreen))
self.Reward.attach(self)
# initialize the data
self.Reward.setData([0], [0])
# replot
self.replot()
def newData(self, Reward):
self.Reward.setData(list(range(len(Reward))), Reward)
# replot
self.replot()
def __init__(self, *args):
QWidget.__init__(self, *args)
layout = QGridLayout(self)
# try to create a plot for SciPy arrays
# make a curve and copy the data
numpy_curve = QwtPlotCurve('y = lorentzian(x)')
x = np.arange(0.0, 10.0, 0.01)
y = lorentzian(x)
numpy_curve.setData(x, y)
# here, we know we can plot NumPy arrays
numpy_plot = QwtPlot(self)
numpy_plot.setTitle('numpy array')
numpy_plot.setCanvasBackground(Qt.white)
numpy_plot.plotLayout().setCanvasMargin(0)
numpy_plot.plotLayout().setAlignCanvasToScales(True)
# insert a curve and make it red
numpy_curve.attach(numpy_plot)
numpy_curve.setPen(QPen(Qt.red))
layout.addWidget(numpy_plot, 0, 0)
numpy_plot.replot()
# create a plot widget for lists of Python floats
list_plot = QwtPlot(self)
list_plot.setTitle('Python list')
list_plot.setCanvasBackground(Qt.white)
list_plot.plotLayout().setCanvasMargin(0)
list_plot.plotLayout().setAlignCanvasToScales(True)
x = drange(0.0, 10.0, 0.01)
y = [lorentzian(item) for item in x]
# insert a curve, make it red and copy the lists
list_curve = QwtPlotCurve('y = lorentzian(x)')
list_curve.attach(list_plot)
list_curve.setPen(QPen(Qt.red))
list_curve.setData(x, y)
layout.addWidget(list_plot, 0, 1)
layout.addWidget(DataPlot(self),1,1)
layout.addWidget(3dstl(self), 1, 0)
list_plot.replot()
def pbServerClicked(self):
if self.ServerActive == 0:
self.N = self.sbNsig.value()
self.Hist = int(self.edHist.text().__str__())
self.pbStartServer.setText('Stop Server')
self.ServerActive = 1
self.plot = dataPlot(self.N)
self.plot.resize(800, 800)
self.plot.show()
self.x = []
self.c = []
for n in range(0, self.N):
self.x.append([])
for n in range(0, int(self.N / 2)):
cv = QwtPlotCurve()
pen = QPen(QColor(self.colors[n]))
cv.setPen(pen)
cv.setData([], [])
self.c.append(cv)
self.c[n].attach(self.plot)
if not (self.ckAutoscale.isChecked()):
self.xmin = float(self.edXmin.text().__str__())
self.xmax = float(self.edXmax.text().__str__())
self.ymin = float(self.edYmin.text().__str__())
self.ymax = float(self.edYmax.text().__str__())
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.pltRefresh)
refTimer = self.sbRefT.value()
self.timer.start(refTimer)
self.th = rcvServer(self)
self.th.start()
else:
self.pbStartServer.setText('Start Server')
self.ServerActive = 0
self.stopServer()
def __init__(self, *args):
QWidget.__init__(self, *args)
layout = QGridLayout(self)
# try to create a plot for SciPy arrays
# make a curve and copy the data
numpy_curve = QwtPlotCurve('y = lorentzian(x)')
x = np.arange(0.0, 10.0, 0.01)
y = lorentzian(x)
numpy_curve.setData(x, y)
# here, we know we can plot NumPy arrays
numpy_plot = QwtPlot(self)
numpy_plot.setTitle('numpy array')
numpy_plot.setCanvasBackground(Qt.white)
numpy_plot.plotLayout().setCanvasMargin(0)
numpy_plot.plotLayout().setAlignCanvasToScales(True)
# insert a curve and make it red
numpy_curve.attach(numpy_plot)
numpy_curve.setPen(QPen(Qt.red))
layout.addWidget(numpy_plot, 0, 0)
numpy_plot.replot()
# create a plot widget for lists of Python floats
list_plot = QwtPlot(self)
list_plot.setTitle('Python list')
list_plot.setCanvasBackground(Qt.white)
list_plot.plotLayout().setCanvasMargin(0)
list_plot.plotLayout().setAlignCanvasToScales(True)
x = drange(0.0, 10.0, 0.01)
y = [lorentzian(item) for item in x]
# insert a curve, make it red and copy the lists
list_curve = QwtPlotCurve('y = lorentzian(x)')
list_curve.attach(list_plot)
list_curve.setPen(QPen(Qt.red))
list_curve.setData(x, y)
layout.addWidget(list_plot, 0, 1)
list_plot.replot()
class FermentGraph(QWidget):
_logname = 'FermentGraphGeneric'
_log = logging.getLogger(f'{_logname}')
def __init__(self, database, parent=None):
super().__init__(parent)
self.db = database
self.updateTimer = QTimer(self)
self.updateTimer.start(5000)
self.plot = QwtPlot()
self.curve = QwtPlotCurve()
self.curve.attach(self.plot)
self.plot.resize(1000, 1000)
self.plot.show()
self.plot.setAxisScaleDraw(QwtPlot.xBottom, DateTimeTimeScaleDraw())
axisFont = QFont("Helvetica", 11, QFont.Bold)
titleFont = QFont("Helvetica", 12, QFont.Bold)
xTitle = QwtText()
xTitle.setText("Time")
xTitle.setFont(axisFont)
self.plot.setAxisTitle(self.plot.xBottom, xTitle)
self.yTitle = QwtText()
self.yTitle.setFont(axisFont)
self.plot.setAxisTitle(self.plot.yLeft, self.yTitle)
self.titleText = QwtText()
self.titleText.setFont(titleFont)
self.plot.setTitle(self.titleText)
mainLayout = QHBoxLayout()
mainLayout.addWidget(self.plot)
self.setLayout(mainLayout)
self.plot.show()
self.results = []
self.batchID = None
def updatePlot(self, variable):
if self.batchID is not None:
self.db.flushTables()
sql = f"SELECT TimeStamp, {variable} FROM Ferment WHERE BatchID = '{self.batchID}'"
timestamps = []
self.results = []
for data in self.db.custom(sql)[1:]:
timestamps.append(data[0])
self.results.append(data[1])
startTime = timestamps[0]
for i in range(len(timestamps)):
timestamps[i] = (timestamps[i] - startTime).seconds
# self.plot.setAxisScaleDraw(QwtPlot.xBottom, TimeScaleDraw())
self.curve.setData(timestamps, self.results)
self.plot.replot()
self.plot.show()
def changeTank(self, tankID):
self.titleText.setText(f"Fermentation Tank: {tankID}")
class MyWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui=Ui_MainWindow()
self.ui.setupUi(self)
# connect methods to buttons' click signals
self.ui.wakeUpButton.clicked.connect(self.wakeUp)
self.ui.stopButton.clicked.connect(self.stop)
self.ui.closeButton.clicked.connect(self.close)
self.ui.saveButton.clicked.connect(self.save)
self.ui.immediateButton.clicked.connect(self.immediate)
self.ui.finalButton.clicked.connect(self.final)
self.ui.fitButton.clicked.connect(self.fit)
self.ui.action_Save_Ctrl_S.triggered.connect(self.save)
self.ui.action_Quit_Ctrl_Q.triggered.connect(self.close)
self.ui.actionManual.triggered.connect(self.manual)
self.ui.actionAbout.triggered.connect(self.about)
self.ui.durationEdit.textChanged.connect(self.durationChanged)
# create a timer
self.stopTime=time.time()
self.timer=QtCore.QTimer()
# connect the timer to the "tick" callback method
self.timer.timeout.connect(self.tick)
# 20 times per second
self.timer.start(50)
# initialize an empty curve for the plot widget
self.curve = QwtPlotCurve()
self.curve0 = QwtPlotCurve()
self.fitCurve1 = QwtPlotCurve()
self.fitCurve2 = QwtPlotCurve()
self.fitCurve3 = QwtPlotCurve()
self.curve.attach(self.ui.qwtPlot)
self.curve0.attach(self.ui.qwtPlot)
self.fitCurve1.attach(self.ui.qwtPlot)
self.fitCurve2.attach(self.ui.qwtPlot)
self.fitCurve3.attach(self.ui.qwtPlot)
# adjust the axis scales based on duration = 15 s
self.durationChanged(15, ampl=5)
# set the maxvalue for the threshold rate (in V/s)
self.maxthreshold=150/15 # = 150/duration
# expEYESdetection and initialization
try:
self.p = ej.open()
assert(self.p.fd)
self.setWindowTitle("expEYES Junior found on port {}".format(
self.p.fd.port
))
except:
self.setWindowTitle("ERROR: expEYES Junior NOT FOUND!")
self.ui.wakeUpButton.setEnabled(False)
# custom properties
self.isImmediate=True
return
def durationChanged(self, value, ampl=0):
"""
Callback function for changed in ui.durationEdit
@param value the widget's value in case of an event
@param ampl an amplitudes (defaults to 0)
"""
try:
duration=float(value)
except:
return
# set the axis scales for the plot widget
self.ui.qwtPlot.setAxisScale(QwtPlot.xBottom, 0, duration)
# draw the "zero" line
small=duration/1e6
self.curve0.setData([0, small, 2*small, 3*small, duration],
[0, ampl, -ampl, 0, 0], 5)
# update the threshold rate
self.maxThreshold=150/duration
self.ui.thresholdLabel.setText("{} V/s".format(self.maxThreshold))
# erase fit curves
self.fitCurve1.setData([],[],0)
self.fitCurve2.setData([],[],0)
self.fitCurve3.setData([],[],0)
return
def immediate(self):
self.isImmediate=True
return
def final(self):
self.isImmediate=False
return
def stop(self):
# in "final" mode, this has no effect
# in "immediate" mode, it forces the plot to
# stop at the next tick call.
self.stopTime=time.time()
return
def save(self):
filename=self.ui.fileNameEdit.text()
with open(filename,"w") as outfile:
for i in range(len(self.t)):
outfile.write("{} {}\n".format(
self.t[i], self.v[i]
))
self.ui.statusbar.showMessage(
"Saved data to {}".format(filename), 3000 # 3 seconds
)
return
def waitForThreshold(self, threshold, duration, timeOut=None):
"""
wait for the input to change quickly enough
@param threshold a minimal voltage slew rate (V/s)
@param duration the duration of scheduled measurement series
@param timeOut the longets wait time (defaults to None)
"""
start=time.time()
delay=int(duration/1000*1e6) # thousandth of duration, in µs
if delay < 4:
delay=4
t, v = self.p.capture(1, 2, delay)
slewRate=(v[1]-v[0])/(t[1]-t[0])*1000
while abs(slewRate)<threshold:
if timeOut != None and time.time()>start+timeOut:
return
t, v = self.p.capture(1, 2, delay)
slewRate=(v[1]-v[0])/(t[1]-t[0])*1000
return
def wakeUp(self):
# get the duration of the experiment in s
duration = float(self.ui.durationEdit.text())
self.durationChanged(duration)
if duration < 0.5: # "final" mode is mandatory
self.ui.finalButton.setChecked(True)
self.isImmediate=False
elif duration > 3.5: # "immediate" mode is mandatory
self.ui.immediateButton.setChecked(True)
self.isImmediate=True
# wait until the slew rate is fast enough
threshold = self.ui.thresholdSlider.value()*self.maxThreshold/100
self.waitForThreshold(threshold, duration, timeOut=5)
# start measuring
if self.isImmediate:
now=time.time()
self.t=[]
self.v=[]
self.curve.setData([],[],0)
self.startTime=now
self.stopTime=now+duration
# now the curve will grow until time.time >= self.stopTime
# thanks to self.timer's timeout events
else:
samples = 1800 # maximum sample number with 8 bit precision
# ensure that samples * delay will be slightly bigger than duration
delay=1+int(duration*1e6/1800)
t, self.v = self.p.capture(1,samples, delay)
self.t=[1e-3*date for date in t] # convert ms to s
self.curve.setData(self.t, self.v, len(self.t))
return
def tick(self):
""" Callback for the timeout events """
t=time.time()
if t < self.stopTime:
v = self.p.get_voltage(1)
self.t.append(time.time()-self.startTime)
self.v.append(v)
self.curve.setData(self.t, self.v, len(self.t))
return
def fit(self):
"""
Fitting data in self.t, self.v with a damped oscillation model
"""
# fitting is performed by eyemath (aka em) thanks to
# scipy.optimize, and the error function defined by
# the module eyemath (line 92):
# p[0] * sin(2*pi*p[1]*x+p[2]) * exp(-p[4]*x) - p[3]
# so the vector of parameters is:
# amplitude, frequency, phase, DC average, damping factor.
yfit, plsq = em.fit_dsine(self.t, self.v, mode="Hz")
# display the fitting model
msg="{0:4.2f}*sin(2*pi*{1:4.2f}*t+({2:3.1f}))*exp(-{4:4.2f}*t)+{3:3.1f}".format(
*plsq
)
self.ui.fitEdit.setText(msg)
# display three curves : model and model's envelopes
t=np.array(self.t)
f1=np.array(yfit)
f2=plsq[0]*np.exp(-plsq[4]*t)
f3=-1.0*f2
average=plsq[3]*np.ones(len(t))
red=QtGui.QColor("#ff0000")
self.fitCurve1.setPen(red)
self.fitCurve2.setPen(red)
self.fitCurve3.setPen(red)
self.fitCurve1.setData(t, f1, len(t))
self.fitCurve2.setData(t, f2+average, len(t))
self.fitCurve3.setData(t, f3+average, len(t))
return
def about(self):
"""
show license stuff
"""
with open("license.html","w") as licenseFile:
licenseFile.write("""
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title> About ... </title>
</head>
<body>
""")
licenseFile.write(license)
licenseFile.write("</body></html>")
self.aboutWidget=QtGui.QTextBrowser(self.parent())
self.aboutWidget.resize(600,500)
self.aboutWidget.show()
self.aboutWidget.setOpenExternalLinks(True)
self.aboutWidget.setSource(QtCore.QUrl("file:license.html"))
self.aboutWidget.setWindowTitle("About oscill4.py")
return
def manual(self):
"""
display the manual
"""
self.manualWidget=QtGui.QTextBrowser(self.parent())
self.manualWidget.resize(600,500)
self.manualWidget.show()
self.manualWidget.setOpenExternalLinks(True)
self.manualWidget.setSource(QtCore.QUrl("file:oscill4.html"))
self.manualWidget.setWindowTitle("User Manual of oscill4.py")
return
def notImplemented(self):
msg=QtGui.QMessageBox(QtGui.QMessageBox.Warning,"Sorry",
"not yet implemented", )
msg.exec_()
return
class MyWindow(QtGui.QMainWindow):
"""
This class implements a derivative of
PyQt4.QtGui.QMainWindow, a complete application
window, which can feature menus, submenus,
status bar, etc. In this example, it uses
few of those features.
"""
def __init__(self, parent=None):
"""
Constructor: creates an instance of MyWindow
"""
#########################################
# Necessary actions, which must be done #
# for any project #
#########################################
# first, calling the ancestor's creator
QtGui.QMainWindow.__init__(self, parent)
# get the User Interface from the module UI_p1
self.ui=Ui_MainWindow()
# initialize the user interface
self.ui.setupUi(self)
#########################################
# Custom actions, which can be written #
# in other ways for other projects. #
#########################################
# aliases for some parts of the user interface
self.plotWidget = self.ui.qwtPlot
self.measureButton = self.ui.measureButton
self.closeButton = self.ui.closeButton
# connect methods to buttons' click signals
self.measureButton.clicked.connect(self.measure)
self.closeButton.clicked.connect(self.close)
# initialize an empty curve for the plot widget
self.curve = QwtPlotCurve()
self.curve.attach(self.plotWidget)
# initialize the driver for expEYES Junior
# prevent an error if the box is not detected
try:
self.p = ej.open()
assert(self.p.fd)
self.setWindowTitle("expEYES Junior found on port {}".format(
self.p.fd.port
))
except:
self.setWindowTitle("ERROR: expEYES Junior NOT FOUND!")
self.measureButton.setEnabled(False)
return
def measure(self):
"""
This is a custom method to connect to the
button for measurements.
There is no need for another custom method,
since the method "close" is already inherited
from the ancestor class.
"""
sample=int(self.ui.samplesEdit.text())
delay=int(self.ui.delayEdit.text())
channel=self.inputCode()
duration=int(sample*delay/1000) # in ms
self.ui.statusbar.showMessage(
"Measuring data for {} seconds, please be patient...".format(duration/1000),
duration
)
self.ui.statusbar.repaint() # immediately shows the status
t,v = self.p.capture(channel, sample, delay)
self.curve.setData(t,v,len(t))
# display the result
self.plotWidget.replot()
return
def inputCode(self):
"""
considers the radio buttons
@return the code for the selected input channel
"""
value={
"A1": 1,
"A2": 2,
"IN1": 3,
"IN2": 4,
"SEN": 5,
}
radios=[r for r in self.ui.groupBox.children()
if isinstance(r, QtGui.QRadioButton)]
for r in radios:
if r.isChecked():
return value[r.text().strip()]
return 0
class MapDemo(QMainWindow):
def __init__(self, *args):
QMainWindow.__init__(self, *args)
self.plot = QwtPlot(self)
self.plot.setTitle("A Simple Map Demonstration")
self.plot.setCanvasBackground(Qt.white)
self.plot.setAxisTitle(QwtPlot.xBottom, "x")
self.plot.setAxisTitle(QwtPlot.yLeft, "y")
self.plot.setAxisScale(QwtPlot.xBottom, 0.0, 1.0)
self.plot.setAxisScale(QwtPlot.yLeft, 0.0, 1.0)
self.setCentralWidget(self.plot)
# Initialize map data
self.count = self.i = 1000
self.xs = np.zeros(self.count, np.float)
self.ys = np.zeros(self.count, np.float)
self.kappa = 0.2
self.curve = QwtPlotCurve("Map")
self.curve.attach(self.plot)
self.curve.setSymbol(
QwtSymbol(QwtSymbol.Ellipse, QBrush(Qt.red), QPen(Qt.blue),
QSize(5, 5)))
self.curve.setPen(QPen(Qt.cyan))
toolBar = QToolBar(self)
self.addToolBar(toolBar)
# 1 tick = 1 ms, 10 ticks = 10 ms (Linux clock is 100 Hz)
self.ticks = 10
self.tid = self.startTimer(self.ticks)
self.timer_tic = None
self.user_tic = None
self.system_tic = None
self.plot.replot()
def setTicks(self, ticks):
self.i = self.count
self.ticks = int(ticks)
self.killTimer(self.tid)
self.tid = self.startTimer(ticks)
def resizeEvent(self, event):
self.plot.resize(event.size())
self.plot.move(0, 0)
def moreData(self):
if self.i == self.count:
self.i = 0
self.x = random.random()
self.y = random.random()
self.xs[self.i] = self.x
self.ys[self.i] = self.y
self.i += 1
chunks = []
self.timer_toc = time.time()
if self.timer_tic:
chunks.append("wall: %s s." %
(self.timer_toc - self.timer_tic))
print(' '.join(chunks))
self.timer_tic = self.timer_toc
else:
self.x, self.y = standard_map(self.x, self.y, self.kappa)
self.xs[self.i] = self.x
self.ys[self.i] = self.y
self.i += 1
def timerEvent(self, e):
self.moreData()
self.curve.setData(self.xs[:self.i], self.ys[:self.i])
self.plot.replot()
from qwt.qt.QtGui import QApplication
from qwt import QwtPlot, QwtPlotCurve
import numpy as np
app = QApplication([])
x = np.linspace(-10, 10, 500)
y1, y2 = np.cos(x), np.sin(x)
my_plot = QwtPlot("Two curves")
curve1, curve2 = QwtPlotCurve("Curve 1"), QwtPlotCurve("Curve 2")
curve1.setData(x, y1)
curve2.setData(x, y2)
curve1.attach(my_plot)
curve2.attach(my_plot)
my_plot.resize(600, 300)
my_plot.replot()
my_plot.show()
app.exec_()
class DataPlot(QwtPlot):
# signal define
signal_showinfo = pyqtSignal(object)
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.uut_dev = None
self.timerId = None
#self.interval = 250 # ms
self.interval = config.interval # ms
fileTIME = datetime.datetime.now()
File_timestamp = "%04d-%02d-%02d_%02d%02d%02d" % (
fileTIME.year, fileTIME.month, fileTIME.day, fileTIME.hour,
fileTIME.minute, fileTIME.second)
self.fileNamme = '.\data\data_%s.txt' % File_timestamp
print('Raw data record file name:%s' % self.fileNamme)
# default parameters from config file
self.x_ZERO = config.X_lower
self.x_range = config.X_upper
self.x_interval = config.X_grid_interval
self.y_range_Upper = config.Y_upper
self.y_range_Lower = config.Y_lower
self.y_interval = config.Y_grid_interval
self.unit = 'kPa' # default value, will replaced by actual reading.
#self.getReadingCommand = r"UPPER_VAL?\r\n" # default pass and pac
#self.getResp_rex = r'^[-]?([0-9]{1,}[.]?[0-9]*)'
self.lenth = config.Slope_lenth # 40 = 10s caculate the slowrate
# QwtPlot property
# Initialize 坐标轴
self.setCanvasBackground(Qt.white) #Qt.white
self.alignScales()
grid = QwtPlotGrid()
grid.attach(self)
grid.setMajorPen(QPen(Qt.black, 0, Qt.DotLine))
# x Axis property
#self.setAxisScaleDraw(QwtPlot.xBottom, TimeScaleDraw(self.cpuStat.upTime()))
#timeScale = QwtDateScaleDraw(Qt.LocalTime)
#print(timeScale)
#self.setAxisScaleDraw(QwtPlot.xBottom, timeScale)
self.setAxisScale(QwtPlot.xBottom, 0.0, self.x_range, self.x_interval)
#self.setAxisAutoScale(QwtPlot.yLeft,True)
#self.setAxisScale(QwtPlot.yLeft,99.99,100.0,0.0005)
self.setAxisScale(QwtPlot.yLeft, self.y_range_Lower,
self.y_range_Upper, self.y_interval)
self.setAxisLabelRotation(QwtPlot.xBottom, -45.0)
self.x = np.arange(
0.0, self.x_range + 1, 0.25
) #0.25 for ONE POINT, THIS SHOULD BE Align to the reading rate:250ms
#self.z = np.zeros(len(self.x), np.float)
list = []
for i in range(len(self.x)):
list.append(0.0)
self.z = np.array(list)
rlist = []
for i in range(self.lenth): # 10s
rlist.append(0.0)
self.RateList = np.array(rlist)
self.setTitle("UUT Reading Monitor - OutPort(%s)\r\n" % (self.unit))
#self.insertLegend(QwtLegend(), QwtPlot.RightLegend);
self.curveL = QwtPlotCurve("UUT Reading")
self.curveL.attach(self)
pen = QPen(Qt.red)
pen.setWidth(1.5)
#pen.setWidth(1)
self.curveL.setPen(pen)
font = QFont()
font.setFamily("Calibri") #,Consolas
font.setPointSize(16)
# show the latest reading. line and point value
self.peakMarker = m = QwtPlotMarker()
m.setLineStyle(QwtPlotMarker.HLine)
m.setLabelAlignment(Qt.AlignLeft | Qt.AlignTop)
m.setLinePen(QPen(Qt.blue, 1.5, Qt.DashDotLine))
text = QwtText('Reading: ----')
text.setColor(Qt.red)
text.setBackgroundBrush(QBrush(self.canvasBackground()))
text.setFont(font)
m.setLabel(text)
# MarkPoint symbol
m.setSymbol(
QwtSymbol(QwtSymbol.Diamond, QBrush(Qt.blue), QPen(Qt.green),
QSize(7, 7)))
m.attach(self)
# text marker , display slope rate
self.txtMarker = m = QwtPlotMarker()
m.setValue(self.x_range / 2,
self.y_range_Upper - self.y_interval / 2) # show position
m.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
text = QwtText('Slope Rate: ----')
text.setFont(font)
text.setColor(Qt.white)
text.setBackgroundBrush(QBrush(Qt.black))
text.setBorderPen(QPen(Qt.red, 2))
m.setLabel(text)
m.attach(self)
self.setAxisTitle(QwtPlot.xBottom, "Time (seconds)")
self.setAxisTitle(QwtPlot.yLeft, "UUT - Reading(%s)" % (self.unit))
self.replot()
#self.startTimer(250)#ms# FOR GET READING
#self.starttime = time.clock();#unit: s python2
self.starttime = time.time() # python3
self.idx = 0
self.readfmt = "%f"
self.Saveinfo("Starting...")
def setPara(
self, y_lower, y_upper, y_interval, x_interval, x_upper,
x_lower): # y_lower,y_upper,y_interval,x_interval,X-Upper,x_lower
self.y_range_Upper = y_upper
self.y_range_Lower = y_lower
self.x_interval = x_interval
self.y_interval = y_interval
self.x_range = x_upper
self.x_ZERO = x_lower
self.setAxisScale(QwtPlot.xBottom, self.x_ZERO, self.x_range,
self.x_interval) # self.x_range
#self.setAxisAutoScale(QwtPlot.yLeft,True)
#self.setAxisScale(QwtPlot.yLeft,99.99,100.0,0.0005)
self.setAxisScale(QwtPlot.yLeft, self.y_range_Lower,
self.y_range_Upper, self.y_interval)
self.replot()
def StartTimer(self):
if not self.uut_dev:
print(
"Please connect the device first!\r\n**********************************************"
)
self.signal_showinfo.emit("Please connect the device first!")
QMessageBox.warning(self, 'Warning',
'Please connect the device first!',
QMessageBox.Yes, QMessageBox.Yes)
else:
if not self.timerId:
print(self.interval)
self.timerId = self.startTimer(self.interval)
self.signal_showinfo.emit("Timer Started!")
def StopTimer(self):
if self.timerId:
if (QMessageBox.Yes == QMessageBox.warning(
self, 'Warning',
'Are you want to stop the refresh of the curve?',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)):
self.killTimer(self.timerId)
self.timerId = None
self.signal_showinfo.emit("Timmer stoped!")
def Connect(self, COMPort, baudrate):
if self.uut_dev is None:
try:
self.uut_dev = device_py3.SerialDevice(
False, False, port=COMPort,
baudrate=baudrate) #'''args[0]'''
self.signal_showinfo.emit('Device opened success!')
# Do Configuration settings:
for cmd in config.pre_cmd:
print(self.sendcmd(self.uut_dev, cmd + "\r\n"))
time.sleep(0.5)
#print(self.sendcmd(self.uut_dev,"echo 0\r\n"))
#print(self.sendcmd(self.uut_dev,"prompt off\r\n"))
except Exception as e:
print(e, '\r\nDevice opened failed!')
self.signal_showinfo.emit(
'Device opened failed!\r\n**********************************************'
)
QMessageBox.warning(
self, 'Warning',
'Device opened failed! Please Check the COM port!!',
QMessageBox.Yes, QMessageBox.Yes)
else:
print("Device already opened!")
self.signal_showinfo.emit("Device already opened!")
QMessageBox.warning(self, 'Warning', 'Device has already opened!',
QMessageBox.Yes, QMessageBox.Yes)
def DisConnect(self):
self.StopTimer()
if self.uut_dev:
self.uut_dev.close()
self.uut_dev = None
print("Device disconnected! \r\n")
self.signal_showinfo.emit("Device disconnected!")
QMessageBox.warning(self, 'Warning', 'Device disconnected!',
QMessageBox.Yes, QMessageBox.Yes)
def showPeak(self, x, amplitude):
self.peakMarker.setValue(x, amplitude) # position
label = self.peakMarker.label()
label.setText('Reading: %f %s' % (amplitude, self.unit))
self.peakMarker.setLabel(label)
def showTxtLabel(self, x, y, txt):
self.txtMarker.setValue(x, y)
label = self.txtMarker.label()
label.setText(txt)
self.txtMarker.setLabel(label)
def alignScales(self):
self.canvas().setFrameStyle(QFrame.Box | QFrame.Plain)
self.canvas().setLineWidth(1)
for i in range(QwtPlot.axisCnt):
scaleWidget = self.axisWidget(i)
if scaleWidget:
scaleWidget.setMargin(0)
scaleDraw = self.axisScaleDraw(i)
if scaleDraw:
scaleDraw.enableComponent(QwtAbstractScaleDraw.Backbone, False)
def timerEvent(self, e):
# send cmd and get readings, record times, X is second;
# tfdata = self.uut_get_val(self.uut_dev, "VAL?\r") #Wolf
#tfdata = self.uut_get_val(self.uut_dev, "READ:VOLT:DC?\r") # GW VOLT
#ifdata = self.uut_get_val(self.uut_dev, "READ:CURR:DC?\r") # GW CURRENT
#tfdata = self.uut_get_val(self.uut_dev, "x?\r\n") # 8508
tfdata = self.uut_get_val(self.uut_dev, config.GetReadingCmd +
"\r\n") #"UPPER_VAL?\r\n") # pass/pac
self.showPeak(int(self.x_range), tfdata)
#print(tfdata) #, "\t" , ifdata
self.z = np.concatenate((self.z[1:], self.z[:1]), 0)
if (tfdata < 99999999.0):
self.z[-1] = tfdata
else:
self.z[-1] = 99999999.0
# Rate
self.RateList = np.concatenate((self.RateList[1:], self.RateList[:1]),
0)
self.RateList[-1] = tfdata
self.showTxtLabel(
self.x_ZERO, self.y_range_Upper,
str('Slope Rate:%f %s/min' %
((self.RateList[-1] - self.RateList[0]) /
(self.lenth * 250.0 / 1000.0 / 60.0), self.unit)))
self.curveL.setData(self.x, self.z)
self.setTitle("Max:%f, min:%f, Peak2Peak:%f " %
(np.amax(self.z), np.amin(self.z), np.ptp(self.z)))
self.setAxisTitle(QwtPlot.yLeft, "UUT - Reading(%s)" % (self.unit))
self.replot()
self.idx = self.idx + 1
#Write file to txt log
self.SaveData(tfdata)
#now = time.clock(); # python 2
now = time.time()
# python 3
if ((now - self.starttime) > int(self.x_range)): # points (seconds)
#self.starttime = time.clock(); # reset start time python 2
self.starttime = time.time()
# reset start time python 3
pngTIME = datetime.datetime.now()
FILE_timestamp = "%04d-%02d-%02d_%02d%02d%02d" % (
pngTIME.year, pngTIME.month, pngTIME.day, pngTIME.hour,
pngTIME.minute, pngTIME.second)
PNGFile = ('%s_%s' % (FILE_timestamp, '.png'))
self.exportTo('.\pic\%s' % PNGFile,
size=(1920, 1080),
resolution=100)
print(PNGFile, "The snaped curve picture has been created.")
def uut_get_val(
self,
uut_dev_in,
type="x?\r\n"
): #[0-9]\d*\.\d+$ #r'[ -+]\d+\.\d+[Ee][-+][0-9]{2}' #r'[-]?\d+\.\d+' 匹配正负小数
cmd_encode = type.encode()
m, self.unit = uut_dev_in.trx(
cmd_encode, config.rsp_regular
) #r'^[-]?([0-9]{1,}[.]?[0-9]*)') # ^[-]?([0-9]{1,}[.]?[0-9]*)$ - 匹配正负小数和整数
if m:
return float(m.group(0))
else:
return 7200.0 ##
def sendcmd(self, uut_dev_in, cmd):
cmd_encode = cmd.encode()
uut_dev_in.write(cmd_encode)
return cmd_encode
def SaveData(self, tfdata):
fh = open(self.fileNamme, "a")
now = datetime.datetime.now()
timestamp = "%02d:%02d:%02d.%03d" % (now.hour, now.minute, now.second,
now.microsecond / 1000)
rstr = "%s, %s, %s\n" % (self.idx, timestamp, tfdata)
fh.write(rstr)
fh.flush()
def Saveinfo(self, info):
fh = open(self.fileNamme, "a")
now = datetime.datetime.now()
timestamp = "%04d-%02d-%02d_%02d%02d%02d" % (
now.year, now.month, now.day, now.hour, now.minute, now.second)
title = "%s, %s\n" % (timestamp, info)
fh.write(title)
fh.write("\nSN,TIME,SenseNiose\n")
fh.flush()
def __init__(self, parent=None):
super(Mision, self).__init__(parent)
layout = QGridLayout(self)
layout.lb1 = QLabel(self)
layout.IM1=QLabel(self)
layout.IM2=QLabel(self)
layout.IM3=QLabel(self)
layout.IM4 = QLabel(self)
layout.IM5 = QLabel(self)
layout.IM1.setPixmap(QPixmap("ipn.png"))
layout.IM1.setGeometry(1250, 0, 120, 90)
layout.IM2.setPixmap(QPixmap("mexico.png"))
layout.IM2.setGeometry(1160, 0, 120, 90)
layout.IM3.setPixmap(QPixmap("upiita.png"))
layout.IM3.setGeometry(80, 0, 120, 90)
layout.IM4.setPixmap(QPixmap("CANSATCOMP.png"))
layout.IM4.setGeometry(500, 30, 180, 90)
layout.IM5.setPixmap(QPixmap("IPNUPIITA.png"))
layout.IM5.setGeometry(700, 30, 180, 90)
###############
layout.lb1.setPixmap(QPixmap("CANSAT_BKG.png"))
layout.lb1.setGeometry(0, 0, 1500, 1000)
############################TITLE#############################
titulo1=QLabel()
teamthor = QPixmap("TEAM3.png")
titulo1.setPixmap(teamthor)
layout.addWidget(titulo1,0,1)
#############################################################
x = [1, 2]
y = [1, 2]
layout.addWidget(grap1, 1, 0)
##############################################################
graph2 = QwtPlot()
curva2 = QwtPlotCurve()
curva3 = QwtPlotCurve()
xcurva2 = [-800, 800]
ycurva2 = [0, 0]
xcurva3 = [0, 0]
ycurva3 = [-800, 800]
curva2.setData(xcurva2, ycurva2)
curva2.setPen(QPen(Qt.black))
curva2.attach(graph2)
curva3.setData(xcurva3, ycurva3)
curva3.setPen(QPen(Qt.black))
curva3.attach(graph2)
pal = QPalette();
pal.setColor(QPalette.Text, Qt.white)
pal.setColor(QPalette.Foreground, Qt.white)
layout.addWidget(graph2, 2, 0)
grid = QwtPlotGrid()
grid.attach(graph2)
grid.setPen(QPen(Qt.black, 0, Qt.DotLine))
graph2.replot()
graph2.setAxisScale(QwtPlot.xBottom, -800, 800)
graph2.setAxisScale(QwtPlot.yLeft, -800, 800)
graph2.setPalette(pal)
#############################################################)
layoutv = QGridLayout()
layoutvN = QVBoxLayout()
lb1 = QLabel(self)
pixmap=QPixmap("DIAL4.png")
pixmap = pixmap.scaledToWidth(220)
lb1.setPixmap(pixmap)
layoutv.addWidget(text_pressure,0,0)
layoutv.addWidget(lb1,1,0)
layoutv.addWidget(ql1,1,0,Qt.AlignCenter)
frame5.setLayout(layoutv)
layoutvN.addWidget(frame5)
layout.addLayout(layoutvN, 1, 1)
#############################################################
layoutvp = QGridLayout()
layoutvNp = QVBoxLayout()
lb1p = QLabel(self)
pixmapp = QPixmap("DIAL4.png")
pixmapp = pixmap.scaledToWidth(160)
lb1p.setPixmap(pixmapp)
layoutvp.addWidget(text_pitch, 0, 0)
layoutvp.addWidget(text_roll, 1, 0)
layoutvp.addWidget(text_bladespin, 2, 0)
layoutvp.addWidget(lb1p, 3, 0 ,Qt.AlignCenter)
layoutvp.addWidget(ql1p, 3, 0, Qt.AlignCenter)
frame6.setLayout(layoutvp)
layoutvNp.addWidget(frame6)
layout.addLayout(layoutvNp, 2, 1)
############################################################
layouth1 = QHBoxLayout()
layouth2 = QHBoxLayout()
layouth1.addWidget(volt_bar)
layouth1.addWidget(text_volt)
frame3.setLayout(layouth1)
layouth2.addWidget(frame3)
layout.addLayout(layouth2, 1, 2)
############################################################
layoutG = QVBoxLayout()
layoutG2 = QVBoxLayout()
layoutG3 = QVBoxLayout()
layoutG4 = QVBoxLayout()
layoutG5 = QVBoxLayout()
layoutG.addWidget(text_gps_time)
layoutG.addWidget(text_gps_la)
layoutG.addWidget(text_gps_lo)
layoutG.addWidget(text_gps_al)
layoutG.addWidget(text_gps_sats)
layoutG3.addWidget(text_teamId)
layoutG3.addWidget(text_mission_time)
layoutG3.addWidget(text_Packet_count)
frame2.setLayout(layoutG)
frame7.setLayout(layoutG3)
layoutG2.addWidget(frame2)
layoutG4.addWidget(frame7)
layoutG5.addLayout(layoutG2)
layoutG5.addLayout(layoutG4)
layout.addLayout(layoutG5, 2,2)
############################################################
vboxj3 = QVBoxLayout()
layoutG3 = QVBoxLayout()
vboxj3.addWidget(text_sys)
vboxj3.addWidget(text_elevation)
vboxj3.addWidget(text_azimut)
vboxj3.addWidget(text_gs_to_cansat)
vboxj3.addWidget(text_space)
frame1.setLayout(vboxj3)
layoutG3.addWidget(frame1)
layout.addLayout(layoutG3, 1, 3)
###########################################################
layout.setContentsMargins(0,0,0,0)
layout.setSpacing(30)
############################################################
layouth3 = QHBoxLayout()
layouth4 = QHBoxLayout()
layouth3.addWidget(temp_bar)
layouth3.addWidget(temp_text)
frame4.setLayout(layouth3)
layouth4.addWidget(frame4)
layout.addLayout(layouth4, 2, 3)
temp_bar.setStyleSheet('QProgressBar::chunk {background: rgb(255, 0, 0);}')
temp_bar.setRange(0, 350)
temp_bar.setFixedSize(50, 200)
############################################################
self.setLayout(layout)
class BodePlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setTitle('Frequency Response of a 2<sup>nd</sup>-order System')
self.setCanvasBackground(Qt.darkBlue)
# legend
legend = QwtLegend()
legend.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.insertLegend(legend, QwtPlot.BottomLegend)
# grid
self.grid = QwtPlotGrid()
self.grid.enableXMin(True)
self.grid.attach(self)
# axes
self.enableAxis(QwtPlot.yRight)
self.setAxisTitle(QwtPlot.xBottom, '\u03c9/\u03c9<sub>0</sub>')
self.setAxisTitle(QwtPlot.yLeft, 'Amplitude [dB]')
self.setAxisTitle(QwtPlot.yRight, 'Phase [\u00b0]')
self.setAxisMaxMajor(QwtPlot.xBottom, 6)
self.setAxisMaxMinor(QwtPlot.xBottom, 10)
self.setAxisScaleEngine(QwtPlot.xBottom, QwtLogScaleEngine())
# curves
self.curve1 = QwtPlotCurve('Amplitude')
self.curve1.setRenderHint(QwtPlotItem.RenderAntialiased)
self.curve1.setPen(QPen(Qt.yellow))
self.curve1.setYAxis(QwtPlot.yLeft)
self.curve1.attach(self)
self.curve2 = QwtPlotCurve('Phase')
self.curve2.setRenderHint(QwtPlotItem.RenderAntialiased)
self.curve2.setPen(QPen(Qt.cyan))
self.curve2.setYAxis(QwtPlot.yRight)
self.curve2.attach(self)
# alias
fn = self.fontInfo().family()
# marker
self.dB3Marker = m = QwtPlotMarker()
m.setValue(0.0, 0.0)
m.setLineStyle(QwtPlotMarker.VLine)
m.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
m.setLinePen(QPen(Qt.green, 2, Qt.DashDotLine))
text = QwtText('')
text.setColor(Qt.green)
text.setBackgroundBrush(Qt.red)
text.setFont(QFont(fn, 12, QFont.Bold))
m.setLabel(text)
m.attach(self)
self.peakMarker = m = QwtPlotMarker()
m.setLineStyle(QwtPlotMarker.HLine)
m.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
m.setLinePen(QPen(Qt.red, 2, Qt.DashDotLine))
text = QwtText('')
text.setColor(Qt.red)
text.setBackgroundBrush(QBrush(self.canvasBackground()))
text.setFont(QFont(fn, 12, QFont.Bold))
m.setLabel(text)
m.setSymbol(
QwtSymbol(QwtSymbol.Diamond, QBrush(Qt.yellow), QPen(Qt.green),
QSize(7, 7)))
m.attach(self)
# text marker
m = QwtPlotMarker()
m.setValue(0.1, -20.0)
m.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
text = QwtText('[1-(\u03c9/\u03c9<sub>0</sub>)<sup>2</sup>+2j\u03c9/Q]'
'<sup>-1</sup>')
text.setFont(QFont(fn, 12, QFont.Bold))
text.setColor(Qt.blue)
text.setBackgroundBrush(QBrush(Qt.yellow))
text.setBorderPen(QPen(Qt.red, 2))
m.setLabel(text)
m.attach(self)
self.setDamp(0.01)
def showData(self, frequency, amplitude, phase):
self.curve1.setData(frequency, amplitude)
self.curve2.setData(frequency, phase)
def showPeak(self, frequency, amplitude):
self.peakMarker.setValue(frequency, amplitude)
label = self.peakMarker.label()
label.setText('Peak: %4g dB' % amplitude)
self.peakMarker.setLabel(label)
def show3dB(self, frequency):
self.dB3Marker.setValue(frequency, 0.0)
label = self.dB3Marker.label()
label.setText('-3dB at f = %4g' % frequency)
self.dB3Marker.setLabel(label)
def setDamp(self, d):
self.damping = d
# Numerical Python: f, g, a and p are NumPy arrays!
f = np.exp(np.log(10.0) * np.arange(-2, 2.02, 0.04))
g = 1.0 / (1.0 - f * f + 2j * self.damping * f)
a = 20.0 * np.log10(abs(g))
p = 180 * np.arctan2(g.imag, g.real) / np.pi
# for show3dB
i3 = np.argmax(np.where(np.less(a, -3.0), a, -100.0))
f3 = f[i3] - (a[i3] + 3.0) * (f[i3] - f[i3 - 1]) / (a[i3] - a[i3 - 1])
# for showPeak
imax = np.argmax(a)
self.showPeak(f[imax], a[imax])
self.show3dB(f3)
self.showData(f, a, p)
self.replot()
def __init__(self, *args):
QwtPlot.__init__(self, *args)
# set plot title
self.setTitle('ImagePlot')
# set plot layout
self.plotLayout().setCanvasMargin(0)
self.plotLayout().setAlignCanvasToScales(True)
# set legend
legend = QwtLegend()
legend.setDefaultItemMode(QwtLegendData.Clickable)
self.insertLegend(legend, QwtPlot.RightLegend)
# set axis titles
self.setAxisTitle(QwtPlot.xBottom, 'time (s)')
self.setAxisTitle(QwtPlot.yLeft, 'frequency (Hz)')
colorMap = QwtLinearColorMap(Qt.blue, Qt.red)
interval = QwtInterval(-1, 1)
self.enableAxis(QwtPlot.yRight)
self.setAxisScale(QwtPlot.yRight, -1, 1)
self.axisWidget(QwtPlot.yRight).setColorBarEnabled(True)
self.axisWidget(QwtPlot.yRight).setColorMap(interval, colorMap)
# calculate 3 NumPy arrays
x = np.arange(-2*np.pi, 2*np.pi, 0.01)
y = np.pi*np.sin(x)
z = 4*np.pi*np.cos(x)*np.cos(x)*np.sin(x)
# attach a curve
curve = QwtPlotCurve('y = pi*sin(x)')
curve.attach(self)
curve.setPen(QPen(Qt.green, 2))
curve.setData(x, y)
# attach another curve
curve = QwtPlotCurve('y = 4*pi*sin(x)*cos(x)**2')
curve.attach(self)
curve.setPen(QPen(Qt.black, 2))
curve.setData(x, z)
# attach a grid
grid = QwtPlotGrid()
grid.attach(self)
grid.setPen(QPen(Qt.black, 0, Qt.DotLine))
# attach a horizontal marker at y = 0
marker = QwtPlotMarker()
marker.attach(self)
marker.setValue(0.0, 0.0)
marker.setLineStyle(QwtPlotMarker.HLine)
marker.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
marker.setLabel(QwtText('y = 0'))
# attach a vertical marker at x = pi
marker = QwtPlotMarker()
marker.attach(self)
marker.setValue(np.pi, 0.0)
marker.setLineStyle(QwtPlotMarker.VLine)
marker.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
marker.setLabel(QwtText('x = pi'))
# attach a plot image
plotImage = PlotImage('Image')
plotImage.attach(self)
plotImage.setData(square(512, -2*np.pi, 2*np.pi),
(-2*np.pi, 2*np.pi), (-2*np.pi, 2*np.pi))
legend.SIG_CLICKED.connect(self.toggleVisibility)
# replot
self.replot()
class MyWindow(QtGui.QMainWindow):
"""
This class implements a derivative of
PyQt4.QtGui.QMainWindow, a complete application
window, which can feature menus, submenus,
status bar, etc. In this example, it uses
few of those features.
"""
def __init__(self, parent=None):
"""
Constructor: creates an instance of MyWindow
"""
#########################################
# Necessary actions, which must be done #
# for any project #
#########################################
# first, calling the ancestor's creator
QtGui.QMainWindow.__init__(self, parent)
# get the User Interface from the module UI_p1
self.ui=Ui_MainWindow()
# initialize the user interface
self.ui.setupUi(self)
#########################################
# Custom actions, which can be written #
# in other ways for other projects. #
#########################################
# aliases for some parts of the user interface
self.plotWidget = self.ui.qwtPlot
self.measureButton = self.ui.measureButton
self.closeButton = self.ui.closeButton
self.saveButton = self.ui.saveButton
# connect methods to buttons' click signals
self.measureButton.clicked.connect(self.measure)
self.closeButton.clicked.connect(self.close)
self.saveButton.clicked.connect(self.save)
# initialize an empty curve for the plot widget
self.curve = QwtPlotCurve()
self.curve.attach(self.plotWidget)
# initialize the driver for expEYES Junior
# prevent an error if the box is not detected
try:
self.p = ej.open()
assert(self.p.fd)
self.setWindowTitle("expEYES Junior found on port {}".format(
self.p.fd.port
))
except:
self.setWindowTitle("ERROR: expEYES Junior NOT FOUND!")
self.measureButton.setEnabled(False)
return
def measure(self):
"""
This is a custom method to connect to the
button for measurements.
There is no need for another custom method,
since the method "close" is already inherited
from the ancestor class.
"""
self.t, self.v = self.p.capture(1,1000,200)
self.curve.setData(self.t, self.v, len(self.t))
# display the result
self.plotWidget.replot()
# activate the save widget
self.saveButton.setEnabled(True)
return
def save(self):
"""
save data into a file named "data.csv"
"""
with open("data.csv", "w") as outfile:
for i in range(len(self.t)):
outfile.write("{} {}\n".format(self.t[i], self.v[i]))
delay=2000 # 2000 ms = 2 seconds
self.ui.statusbar.showMessage("saved data to file data.csv",delay)
return
class DataPlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
# Initialize Decice address,
#self.uut_dev = GPIBdevice.GPIBdevice(args[0])
self.rm = visa.ResourceManager()
print(self.rm.list_resources())
self.uut_dev = self.rm.open_resource(args[0])
print('open pass')
# Initialize 坐标轴
self.setCanvasBackground(Qt.white)
self.alignScales()
grid = QwtPlotGrid()
grid.attach(self)
grid.setMajorPen(QPen(Qt.black, 0, Qt.DotLine))
self.setAxisScale(QwtPlot.xBottom, 0.0, 300.1, 10.0)
self.setAxisAutoScale(QwtPlot.yLeft, True)
#self.setAxisScale(QwtPlot.yLeft,4.0,20.0,2.0)
self.x = np.arange(
0.0, 300.1, 0.5
) #0.25 for ONE POINT, THIS SHOULD BE Align to the reading rate:250ms
self.z = np.zeros(len(self.x), np.float)
self.setTitle("UUT Reading Monitor")
self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
self.curveL = QwtPlotCurve("UUT Reading")
self.curveL.attach(self)
self.curveL.setPen(QPen(Qt.red))
self.setAxisTitle(QwtPlot.xBottom, "Time (seconds)")
self.setAxisTitle(QwtPlot.yLeft, "UUT - Reading")
self.replot()
self.startTimer(500) #ms# FOR GET READING
self.starttime = time.clock()
#unit: s
self.idx = 0
self.readfmt = "%.8f"
self.Saveinfo("Starting...")
IDN = self.uut_get_val(self.uut_dev, "*IDN?\r")
print IDN
print "Starting..."
def alignScales(self):
self.canvas().setFrameStyle(QFrame.Box | QFrame.Plain)
self.canvas().setLineWidth(1)
for i in range(QwtPlot.axisCnt):
scaleWidget = self.axisWidget(i)
if scaleWidget:
scaleWidget.setMargin(0)
scaleDraw = self.axisScaleDraw(i)
if scaleDraw:
scaleDraw.enableComponent(QwtAbstractScaleDraw.Backbone, False)
def timerEvent(self, e):
# send cmd and get readings, record times, X is second;
tfdata = self.uut_get_val(self.uut_dev, "x?\r")
print tfdata
self.z = np.concatenate((self.z[1:], self.z[:1]), 1)
self.z[-1] = tfdata
self.curveL.setData(self.x, self.z)
self.replot()
self.idx = self.idx + 1
#Write file to txt log
self.SaveData(tfdata)
now = time.clock()
if ((now - self.starttime) > 250): # 250 point (seconds)
self.starttime = time.clock()
# reset start time
pngTIME = datetime.datetime.now()
FILE_timestamp = "%04d-%02d-%02d_%02d%02d%02d" % (
pngTIME.year, pngTIME.month, pngTIME.day, pngTIME.hour,
pngTIME.minute, pngTIME.second)
PNGFile = ('%s_%s' % (FILE_timestamp, '.png'))
self.exportTo(PNGFile, size=(1920, 1080), resolution=200)
print PNGFile, "The snaped curve picture has been created."
def uut_get_val(self, uut_dev_in, type="x?\r"): #[0-9]\d*\.\d+$
'''
if type == "*IDN?\r":
uut_dev_in.write(type)
line = ''
m = None
while True:
line = line + uut_dev_in.read()
if line.endswith('\r'):
return line
break
else:
m = uut_dev_in.trx(type, r'-?\d+\.\d+[Ee][-+][0-9]{2}')
print m.group(0);
return float(m.group(0))
'''
reading = ''
reading = uut_dev_in.query(type) #u'+000.3272E-06\n'
if type == "*IDN?\r":
return reading
return float(reading)
def SaveData(self, tfdata):
fh = open("data_8508.txt", "a")
now = datetime.datetime.now()
timestamp = "%02d:%02d:%02d.%03d" % (now.hour, now.minute, now.second,
now.microsecond / 1000)
fmtstr = "%s, %%s, %s\n" % (self.idx, self.readfmt)
fh.write(fmtstr % (timestamp, tfdata))
fh.flush()
def Saveinfo(self, info):
fh = open("data_8508.txt", "a")
now = datetime.datetime.now()
timestamp = "%04d-%02d-%02d_%02d%02d%02d" % (
now.year, now.month, now.day, now.hour, now.minute, now.second)
title = "%s, %s\n" % (timestamp, info)
fh.write(title)
fh.flush()
pen.setJoinStyle(Qt.MiterJoin)
symbol = QwtSymbol()
symbol.setPen(pen)
symbol.setBrush(Qt.red)
symbol.setPath(path)
symbol.setPinPoint(QPointF(0.0, 0.0))
symbol.setSize(10, 14)
# --- Test it within a simple plot ---
curve = QwtPlotCurve()
curve_pen = QPen(Qt.blue)
curve_pen.setStyle(Qt.DotLine)
curve.setPen(curve_pen)
curve.setSymbol(symbol)
x = np.linspace(0, 10, 10)
curve.setData(x, np.sin(x))
plot = QwtPlot()
curve.attach(plot)
plot.resize(600, 300)
plot.replot()
plot.show()
plot.grab().save(
osp.join(osp.abspath(osp.dirname(__file__)), "images",
"symbol_path_example.png"))
app.exec_()
class MapDemo(QMainWindow):
def __init__(self, *args):
QMainWindow.__init__(self, *args)
self.plot = QwtPlot(self)
self.plot.setTitle("A Simple Map Demonstration")
self.plot.setCanvasBackground(Qt.white)
self.plot.setAxisTitle(QwtPlot.xBottom, "x")
self.plot.setAxisTitle(QwtPlot.yLeft, "y")
self.plot.setAxisScale(QwtPlot.xBottom, 0.0, 1.0)
self.plot.setAxisScale(QwtPlot.yLeft, 0.0, 1.0)
self.setCentralWidget(self.plot)
# Initialize map data
self.count = self.i = 1000
self.xs = np.zeros(self.count, np.float)
self.ys = np.zeros(self.count, np.float)
self.kappa = 0.2
self.curve = QwtPlotCurve("Map")
self.curve.attach(self.plot)
self.curve.setSymbol(QwtSymbol(QwtSymbol.Ellipse,
QBrush(Qt.red),
QPen(Qt.blue),
QSize(5, 5)))
self.curve.setPen(QPen(Qt.cyan))
toolBar = QToolBar(self)
self.addToolBar(toolBar)
# 1 tick = 1 ms, 10 ticks = 10 ms (Linux clock is 100 Hz)
self.ticks = 10
self.tid = self.startTimer(self.ticks)
self.timer_tic = None
self.user_tic = None
self.system_tic = None
self.plot.replot()
def setTicks(self, ticks):
self.i = self.count
self.ticks = int(ticks)
self.killTimer(self.tid)
self.tid = self.startTimer(ticks)
def resizeEvent(self, event):
self.plot.resize(event.size())
self.plot.move(0, 0)
def moreData(self):
if self.i == self.count:
self.i = 0
self.x = random.random()
self.y = random.random()
self.xs[self.i] = self.x
self.ys[self.i] = self.y
self.i += 1
chunks = []
self.timer_toc = time.time()
if self.timer_tic:
chunks.append("wall: %s s." % (self.timer_toc-self.timer_tic))
print(' '.join(chunks))
self.timer_tic = self.timer_toc
else:
self.x, self.y = standard_map(self.x, self.y, self.kappa)
self.xs[self.i] = self.x
self.ys[self.i] = self.y
self.i += 1
def timerEvent(self, e):
self.moreData()
self.curve.setData(self.xs[:self.i], self.ys[:self.i])
self.plot.replot()
def __init__(self, parent=None):
super(Mision, self).__init__(parent)
layout = QGridLayout(self)
layout.lb1 = QLabel(self)
x=0
layout.lb1.setPixmap(QPixmap("CANSAT_BKG.png"))
layout.lb1.setGeometry(0, 0, 1500, 1000)
############################TITLE#############################
font = QFont("UKNumberPlate", 20, 10, 0) #### FUENTE, TAMAÑO, GROSOR, ITALICA 0-F
titulo1=QLabel()
titulo1.setFont(font)
titulo1.setStyleSheet('color: white')
titulo1.setText('TEAM THOR')
layout.addWidget(titulo1,0,1)
#############################################################
x = [1, 2]
y = [1, 2]
layout.addWidget(grap1, 1, 0)
##############################################################
graph2 = QwtPlot()
curva2 = QwtPlotCurve()
curva3 = QwtPlotCurve()
xcurva2 = [-800, 800]
ycurva2 = [0, 0]
xcurva3 = [0, 0]
ycurva3 = [-800, 800]
curva2.setData(xcurva2, ycurva2)
curva2.setPen(QPen(Qt.black))
curva2.attach(graph2)
curva3.setData(xcurva3, ycurva3)
curva3.setPen(QPen(Qt.black))
curva3.attach(graph2)
pal = QPalette();
pal.setColor(QPalette.Text, Qt.white)
pal.setColor(QPalette.Foreground, Qt.white)
layout.addWidget(graph2, 2, 0)
grid = QwtPlotGrid()
grid.attach(graph2)
grid.setPen(QPen(Qt.black, 0, Qt.DotLine))
graph2.replot()
graph2.setAxisScale(QwtPlot.xBottom, -800, 800)
graph2.setAxisScale(QwtPlot.yLeft, -800, 800)
graph2.setPalette(pal)
#############################################################)
layoutv = QVBoxLayout()
layoutvN = QVBoxLayout()
lb1 = QLabel(self)
pixmap=QPixmap("DIAL4.png")
pixmap2 = QPixmap("pointer.png")
pixmap = pixmap.scaledToWidth(220)
pixmap2 = pixmap2.scaledToWidth(20)
lb1.setPixmap(pixmap)
layoutv.addWidget(text_pressure)
layoutv.addWidget(lb1)
frame5.setLayout(layoutv)
layoutvN.addWidget(frame5)
layout.addLayout(layoutvN, 1, 1)
###
self.lbN = QLabel(self)
#x=50400
press=0
ang=(0.002685)*press-140
if ang>=0:
correctionx = 0
correctiony=round(ang*0.2)
else:
correctiony = - round(ang * 0.2)
if ang<=-105:
correctionx = -round((((-ang-100)*0.07)**(2))-40)
else:
if ang>=-9.4:
correctionx = round(12 * (((-ang-1)/100) ** (1 / 4)))
else:
correctionx = round(12 * (((-ang -9.5)) ** (1 / 4)))
t = QTransform()
t.rotate(ang)
rotated_pixmap = pixmap2.transformed(t, Qt.SmoothTransformation)
#lbN = QLabel(self)
self.lbN.setPixmap(rotated_pixmap)
self.lbN.setGeometry(619 - correctionx, 180 + correctiony, 70, 70)
layout.lbN= self.lbN
#layout.lbN.setPixmap(rotated_pixmap)
#layout.lbN.setGeometry(619-correctionx, 180 + correctiony, 70, 70)
#ang2.correctiony
#############################################################
############################################################
layouth1 = QHBoxLayout()
layouth2 = QHBoxLayout()
layouth1.addWidget(volt_bar)
layouth1.addWidget(text_volt)
frame3.setLayout(layouth1)
layouth2.addWidget(frame3)
layout.addLayout(layouth2, 1, 2)
############################################################
layoutG = QVBoxLayout()
layoutG2 = QVBoxLayout()
layoutG3 = QVBoxLayout()
layoutG4 = QVBoxLayout()
layoutG5 = QVBoxLayout()
layoutG.addWidget(text_gps_time)
layoutG.addWidget(text_gps_la)
layoutG.addWidget(text_gps_lo)
layoutG.addWidget(text_gps_al)
layoutG.addWidget(text_gps_sats)
layoutG3.addWidget(text_teamId)
layoutG3.addWidget(text_mission_time)
layoutG3.addWidget(text_Packet_count)
frame2.setLayout(layoutG)
frame7.setLayout(layoutG3)
layoutG2.addWidget(frame2)
layoutG4.addWidget(frame7)
layoutG5.addLayout(layoutG2)
layoutG5.addLayout(layoutG4)
layout.addLayout(layoutG5, 2,2)
############################################################
vboxj3 = QVBoxLayout()
layoutG3 = QVBoxLayout()
vboxj3.addWidget(text_sys)
vboxj3.addWidget(text_elevation)
vboxj3.addWidget(text_azimut)
vboxj3.addWidget(text_gs_to_cansat)
vboxj3.addWidget(text_space)
frame1.setLayout(vboxj3)
layoutG3.addWidget(frame1)
layout.addLayout(layoutG3, 1, 3)
###########################################################
layout.setContentsMargins(0,0,0,0)
layout.setSpacing(40)
############################################################
layouth3 = QVBoxLayout()
layouth4 = QVBoxLayout()
layouth3.addWidget(temp_text)
layouth3.addWidget(temp_bar)
frame4.setLayout(layouth3)
layouth4.addWidget(frame4)
layout.addLayout(layouth4, 2, 3)
temp_bar.setStyleSheet('QProgressBar::chunk {background: rgb(255, 0, 0);}')
############################################################
self.setLayout(layout)
class DataPlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setCanvasBackground(Qt.white)
self.alignScales()
# Initialize data
self.x = np.arange(0.0, 100.1, 0.5)
self.y = np.zeros(len(self.x), np.float)
self.z = np.zeros(len(self.x), np.float)
self.setTitle("A Moving QwtPlot Demonstration")
self.insertLegend(QwtLegend(), QwtPlot.BottomLegend);
self.curveR = QwtPlotCurve("Data Moving Right")
self.curveR.attach(self)
self.curveL = QwtPlotCurve("Data Moving Left")
self.curveL.attach(self)
self.curveL.setSymbol(QwtSymbol(QwtSymbol.Ellipse,
QBrush(),
QPen(Qt.yellow),
QSize(7, 7)))
self.curveR.setPen(QPen(Qt.red))
self.curveL.setPen(QPen(Qt.blue))
mY = QwtPlotMarker()
mY.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
mY.setLineStyle(QwtPlotMarker.HLine)
mY.setYValue(0.0)
mY.attach(self)
self.setAxisTitle(QwtPlot.xBottom, "Time (seconds)")
self.setAxisTitle(QwtPlot.yLeft, "Values")
self.startTimer(50)
self.phase = 0.0
def alignScales(self):
self.canvas().setFrameStyle(QFrame.Box | QFrame.Plain)
self.canvas().setLineWidth(1)
for i in range(QwtPlot.axisCnt):
scaleWidget = self.axisWidget(i)
if scaleWidget:
scaleWidget.setMargin(0)
scaleDraw = self.axisScaleDraw(i)
if scaleDraw:
scaleDraw.enableComponent(QwtAbstractScaleDraw.Backbone, False)
def timerEvent(self, e):
if self.phase > np.pi - 0.0001:
self.phase = 0.0
# y moves from left to right:
# shift y array right and assign new value y[0]
self.y = np.concatenate((self.y[:1], self.y[:-1]), 1)
self.y[0] = np.sin(self.phase) * (-1.0 + 2.0*random.random())
# z moves from right to left:
# Shift z array left and assign new value to z[n-1].
self.z = np.concatenate((self.z[1:], self.z[:1]), 1)
self.z[-1] = 0.8 - (2.0 * self.phase/np.pi) + 0.4*random.random()
self.curveR.setData(self.x, self.y)
self.curveL.setData(self.x, self.z)
self.replot()
self.phase += np.pi*0.02
def __init__(self, *args):
QFrame.__init__(self, *args)
self.xMap = QwtScaleMap()
self.xMap.setScaleInterval(-0.5, 10.5)
self.yMap = QwtScaleMap()
self.yMap.setScaleInterval(-1.1, 1.1)
# frame style
self.setFrameStyle(QFrame.Box | QFrame.Raised)
self.setLineWidth(2)
self.setMidLineWidth(3)
# calculate values
self.x = np.arange(0, 10.0, 10.0/27)
self.y = np.sin(self.x)*np.cos(2*self.x)
# make curves with different styles
self.curves = []
self.titles = []
# curve 1
self.titles.append('Style: Sticks, Symbol: Ellipse')
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.red))
curve.setStyle(QwtPlotCurve.Sticks)
curve.setSymbol(QwtSymbol(QwtSymbol.Ellipse,
QBrush(Qt.yellow),
QPen(Qt.blue),
QSize(5, 5)))
self.curves.append(curve)
# curve 2
self.titles.append('Style: Lines, Symbol: None')
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.darkBlue))
curve.setStyle(QwtPlotCurve.Lines)
self.curves.append(curve)
# curve 3
self.titles.append('Style: Lines, Symbol: None, Antialiased')
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.darkBlue))
curve.setStyle(QwtPlotCurve.Lines)
curve.setRenderHint(QwtPlotItem.RenderAntialiased)
self.curves.append(curve)
# curve 4
self.titles.append('Style: Steps, Symbol: None')
curve = QwtPlotCurve()
curve.setPen(QPen(Qt.darkCyan))
curve.setStyle(QwtPlotCurve.Steps)
self.curves.append(curve)
# curve 5
self.titles.append('Style: NoCurve, Symbol: XCross')
curve = QwtPlotCurve()
curve.setStyle(QwtPlotCurve.NoCurve)
curve.setSymbol(QwtSymbol(QwtSymbol.XCross,
QBrush(),
QPen(Qt.darkMagenta),
QSize(5, 5)))
self.curves.append(curve)
# attach data, using Numeric
for curve in self.curves:
curve.setData(self.x, self.y)
class MyWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui=Ui_MainWindow()
self.ui.setupUi(self)
# connect methods to buttons' click signals
self.ui.wakeUpButton.clicked.connect(self.wakeUp)
self.ui.stopButton.clicked.connect(self.stop)
self.ui.closeButton.clicked.connect(self.close)
self.ui.saveButton.clicked.connect(self.save)
self.ui.immediateButton.clicked.connect(self.immediate)
self.ui.finalButton.clicked.connect(self.final)
self.ui.fitButton.clicked.connect(self.fit)
self.ui.action_Save_Ctrl_S.triggered.connect(self.save)
self.ui.action_Quit_Ctrl_Q.triggered.connect(self.close)
self.ui.actionManual.triggered.connect(self.manual)
self.ui.actionAbout.triggered.connect(self.about)
# initialize an empty curve for the plot widget
self.curve = QwtPlotCurve()
self.curve.attach(self.ui.qwtPlot)
# expEYESdetection and initialization
try:
self.p = ej.open()
assert(self.p.fd)
self.setWindowTitle("expEYES Junior found on port {}".format(
self.p.fd.port
))
except:
self.setWindowTitle("ERROR: expEYES Junior NOT FOUND!")
self.wakeUpButton.setEnabled(False)
# custom properties
self.isImmediate=True
return
def immediate(self):
self.isImmediate=True
return
def final(self):
self.isImmediate=False
return
def wakeUp(self):
# get the duration of the experiment in µs
duration = 1e6 * float(self.ui.durationEdit.text())
samples = 1800 # maximum sample number with 8 bit precision
# ensure that samples * delay will be slightly bigger than duration
delay=1+int(duration/1800)
t,v = self.p.capture(1,samples, delay)
self.curve.setData(t,v,len(t))
# display the result
self.ui.qwtPlot.replot()
return
def notImplemented(self):
msg=QtGui.QMessageBox(QtGui.QMessageBox.Warning,"Sorry",
"not yet implemented", )
msg.exec_()
return
stop=save=fit=manual=about=notImplemented
# -*- coding: utf-8 -*-
__author__ = 'Valeriy'
from qwt.qt.QtGui import QApplication
from qwt import QwtPlot, QwtPlotCurve
import numpy as np
app = QApplication([])
# x = [1,2,3,4,5,6,7,8,9]
# y1 = [3.2, 5.1 ,7.0, 4.24, 4.41, 8.34, 2.21, 5.657, 6.1]
x = []
y1 = []
my_plot = QwtPlot("Two curves")
curve1 = QwtPlotCurve("Curve 1")
my_plot.resize(600, 300)
curve1.setData(x, y1)
curve1.attach(my_plot)
# my_plot.replot()
my_plot.show()
app.exec_()
# SELECT PrepData FROM= Pdata WHERE ((PNameId=2) AND (SNameId = 14) AND (YearId=2012))
def __init__(self, *args):
QwtPlot.__init__(self, *args)
# set plot title
self.setTitle('ImagePlot')
# set plot layout
self.plotLayout().setCanvasMargin(0)
self.plotLayout().setAlignCanvasToScales(True)
# set legend
legend = QwtLegend()
legend.setDefaultItemMode(QwtLegendData.Clickable)
self.insertLegend(legend, QwtPlot.RightLegend)
# set axis titles
self.setAxisTitle(QwtPlot.xBottom, 'time (s)')
self.setAxisTitle(QwtPlot.yLeft, 'frequency (Hz)')
colorMap = QwtLinearColorMap(Qt.blue, Qt.red)
interval = QwtInterval(-1, 1)
self.enableAxis(QwtPlot.yRight)
self.setAxisScale(QwtPlot.yRight, -1, 1)
self.axisWidget(QwtPlot.yRight).setColorBarEnabled(True)
self.axisWidget(QwtPlot.yRight).setColorMap(interval, colorMap)
# calculate 3 NumPy arrays
x = np.arange(-2 * np.pi, 2 * np.pi, 0.01)
y = np.pi * np.sin(x)
z = 4 * np.pi * np.cos(x) * np.cos(x) * np.sin(x)
# attach a curve
curve = QwtPlotCurve('y = pi*sin(x)')
curve.attach(self)
curve.setPen(QPen(Qt.green, 2))
curve.setData(x, y)
# attach another curve
curve = QwtPlotCurve('y = 4*pi*sin(x)*cos(x)**2')
curve.attach(self)
curve.setPen(QPen(Qt.black, 2))
curve.setData(x, z)
# attach a grid
grid = QwtPlotGrid()
grid.attach(self)
grid.setPen(QPen(Qt.black, 0, Qt.DotLine))
# attach a horizontal marker at y = 0
marker = QwtPlotMarker()
marker.attach(self)
marker.setValue(0.0, 0.0)
marker.setLineStyle(QwtPlotMarker.HLine)
marker.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
marker.setLabel(QwtText('y = 0'))
# attach a vertical marker at x = pi
marker = QwtPlotMarker()
marker.attach(self)
marker.setValue(np.pi, 0.0)
marker.setLineStyle(QwtPlotMarker.VLine)
marker.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
marker.setLabel(QwtText('x = pi'))
# attach a plot image
plotImage = PlotImage('Image')
plotImage.attach(self)
plotImage.setData(square(512, -2 * np.pi, 2 * np.pi),
(-2 * np.pi, 2 * np.pi), (-2 * np.pi, 2 * np.pi))
legend.SIG_CLICKED.connect(self.toggleVisibility)
# replot
self.replot()
class BodePlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setTitle('Frequency Response of a 2<sup>nd</sup>-order System')
self.setCanvasBackground(Qt.darkBlue)
# legend
legend = QwtLegend()
legend.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.insertLegend(legend, QwtPlot.BottomLegend)
# grid
self.grid = QwtPlotGrid()
self.grid.enableXMin(True)
self.grid.attach(self)
# axes
self.enableAxis(QwtPlot.yRight)
self.setAxisTitle(QwtPlot.xBottom, '\u03c9/\u03c9<sub>0</sub>')
self.setAxisTitle(QwtPlot.yLeft, 'Amplitude [dB]')
self.setAxisTitle(QwtPlot.yRight, 'Phase [\u00b0]')
self.setAxisMaxMajor(QwtPlot.xBottom, 6)
self.setAxisMaxMinor(QwtPlot.xBottom, 10)
self.setAxisScaleEngine(QwtPlot.xBottom, QwtLogScaleEngine())
# curves
self.curve1 = QwtPlotCurve('Amplitude')
self.curve1.setRenderHint(QwtPlotItem.RenderAntialiased);
self.curve1.setPen(QPen(Qt.yellow))
self.curve1.setYAxis(QwtPlot.yLeft)
self.curve1.attach(self)
self.curve2 = QwtPlotCurve('Phase')
self.curve2.setRenderHint(QwtPlotItem.RenderAntialiased);
self.curve2.setPen(QPen(Qt.cyan))
self.curve2.setYAxis(QwtPlot.yRight)
self.curve2.attach(self)
# alias
fn = self.fontInfo().family()
# marker
self.dB3Marker = m = QwtPlotMarker()
m.setValue(0.0, 0.0)
m.setLineStyle(QwtPlotMarker.VLine)
m.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
m.setLinePen(QPen(Qt.green, 2, Qt.DashDotLine))
text = QwtText('')
text.setColor(Qt.green)
text.setBackgroundBrush(Qt.red)
text.setFont(QFont(fn, 12, QFont.Bold))
m.setLabel(text)
m.attach(self)
self.peakMarker = m = QwtPlotMarker()
m.setLineStyle(QwtPlotMarker.HLine)
m.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
m.setLinePen(QPen(Qt.red, 2, Qt.DashDotLine))
text = QwtText('')
text.setColor(Qt.red)
text.setBackgroundBrush(QBrush(self.canvasBackground()))
text.setFont(QFont(fn, 12, QFont.Bold))
m.setLabel(text)
m.setSymbol(QwtSymbol(QwtSymbol.Diamond,
QBrush(Qt.yellow),
QPen(Qt.green),
QSize(7,7)))
m.attach(self)
# text marker
m = QwtPlotMarker()
m.setValue(0.1, -20.0)
m.setLabelAlignment(Qt.AlignRight | Qt.AlignBottom)
text = QwtText(
'[1-(\u03c9/\u03c9<sub>0</sub>)<sup>2</sup>+2j\u03c9/Q]'
'<sup>-1</sup>'
)
text.setFont(QFont(fn, 12, QFont.Bold))
text.setColor(Qt.blue)
text.setBackgroundBrush(QBrush(Qt.yellow))
text.setBorderPen(QPen(Qt.red, 2))
m.setLabel(text)
m.attach(self)
self.setDamp(0.01)
def showData(self, frequency, amplitude, phase):
self.curve1.setData(frequency, amplitude)
self.curve2.setData(frequency, phase)
def showPeak(self, frequency, amplitude):
self.peakMarker.setValue(frequency, amplitude)
label = self.peakMarker.label()
label.setText('Peak: %4g dB' % amplitude)
self.peakMarker.setLabel(label)
def show3dB(self, frequency):
self.dB3Marker.setValue(frequency, 0.0)
label = self.dB3Marker.label()
label.setText('-3dB at f = %4g' % frequency)
self.dB3Marker.setLabel(label)
def setDamp(self, d):
self.damping = d
# Numerical Python: f, g, a and p are NumPy arrays!
f = np.exp(np.log(10.0)*np.arange(-2, 2.02, 0.04))
g = 1.0/(1.0-f*f+2j*self.damping*f)
a = 20.0*np.log10(abs(g))
p = 180*np.arctan2(g.imag, g.real)/np.pi
# for show3dB
i3 = np.argmax(np.where(np.less(a, -3.0), a, -100.0))
f3 = f[i3] - (a[i3]+3.0)*(f[i3]-f[i3-1])/(a[i3]-a[i3-1])
# for showPeak
imax = np.argmax(a)
self.showPeak(f[imax], a[imax])
self.show3dB(f3)
self.showData(f, a, p)
self.replot()
class DataPlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.setCanvasBackground(Qt.white)
self.alignScales()
# Initialize data
self.x = np.arange(0.0, 100.1, 0.5)
self.y = np.zeros(len(self.x), np.float)
self.z = np.zeros(len(self.x), np.float)
self.setTitle("A Moving QwtPlot Demonstration")
self.insertLegend(QwtLegend(), QwtPlot.BottomLegend)
self.curveR = QwtPlotCurve("Data Moving Right")
self.curveR.attach(self)
self.curveL = QwtPlotCurve("Data Moving Left")
self.curveL.attach(self)
self.curveL.setSymbol(
QwtSymbol(QwtSymbol.Ellipse, QBrush(), QPen(Qt.yellow),
QSize(7, 7)))
self.curveR.setPen(QPen(Qt.red))
self.curveL.setPen(QPen(Qt.blue))
mY = QwtPlotMarker()
mY.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
mY.setLineStyle(QwtPlotMarker.HLine)
mY.setYValue(0.0)
mY.attach(self)
self.setAxisTitle(QwtPlot.xBottom, "Time (seconds)")
self.setAxisTitle(QwtPlot.yLeft, "Values")
self.startTimer(50)
self.phase = 0.0
def alignScales(self):
self.canvas().setFrameStyle(QFrame.Box | QFrame.Plain)
self.canvas().setLineWidth(1)
for i in range(QwtPlot.axisCnt):
scaleWidget = self.axisWidget(i)
if scaleWidget:
scaleWidget.setMargin(0)
scaleDraw = self.axisScaleDraw(i)
if scaleDraw:
scaleDraw.enableComponent(QwtAbstractScaleDraw.Backbone, False)
def timerEvent(self, e):
if self.phase > np.pi - 0.0001:
self.phase = 0.0
# y moves from left to right:
# shift y array right and assign new value y[0]
self.y = np.concatenate((self.y[:1], self.y[:-1]), 1)
self.y[0] = np.sin(self.phase) * (-1.0 + 2.0 * random.random())
# z moves from right to left:
# Shift z array left and assign new value to z[n-1].
self.z = np.concatenate((self.z[1:], self.z[:1]), 1)
self.z[-1] = 0.8 - (2.0 * self.phase / np.pi) + 0.4 * random.random()
self.curveR.setData(self.x, self.y)
self.curveL.setData(self.x, self.z)
self.replot()
self.phase += np.pi * 0.02
class ZoomPopup(QWidget):
winclosed = pyqtSignal(int)
winpaused = pyqtSignal(int)
save_zoom_display = pyqtSignal(str, int)
image_auto_scale = pyqtSignal(int)
image_scale_values = pyqtSignal(float, float)
def __init__(self,
CurveNumber,
x_values,
y_values,
flags,
pen,
parent=None,
name=None):
""" Initialises all the variables.
creates the main zoom plot
connects the qt signals
"""
QWidget.__init__(self, parent)
self.setWindowTitle('Channel ' + str(CurveNumber))
self._parent = parent
self._d_zoomActive = self._d_zoom = False
self._curve_number = CurveNumber
self.curves = {}
self._do_close = True # enable closing by window manager
self._do_pause = False # pause mode is False at startup
self._compare_max = False
self._do_linear_scale = True # linear Y axis scale by default
self._do_fixed_scale = False # auto scaling by default
self._array_label = "Channel "
#Create the plot for selected curve to zoom
self._plotter = QwtImageDisplay(self)
self._plotter.setZoomDisplay()
self._zoom_plot_label = self._array_label + str(
self._curve_number) + " Sequence (oldest to most recent)"
self._max_crv = -1 # negative value used to indicate that this display
self._min_crv = -1 # is not being used
#####end of parameters set for the plot#######/
# we seem to need a layout for PyQt
box1 = QHBoxLayout(self)
box1.addWidget(self._plotter)
# self.plotPrinter = plot_printer_qt5.plot_printer(self._plotter)
self._plotter.winpaused.connect(self.Pausing)
self._plotter.compare.connect(self.do_compare)
# self._plotter.do_print.connnect(self.plotPrinter.do_print)
self._plotter.save_display.connect(self.handle_save_display)
# insert flags ?
self._plotter.initVellsContextMenu()
self.update_plot(y_values, flags)
self.show()
def handle_save_display(self, title):
self.save_zoom_display.emit(self._zoom_plot_label, self._curve_number)
def do_compare_max(self, x_values):
### instantiate the envelop that will show min/max deviations
self._max_envelop = self._y_values
self._min_envelop = self._y_values
self._max_crv = QwtPlotCurve('Zoomed max curve')
self._max_crv.attach(self._plotter)
self._min_crv = QwtPlotCurve('Zoomed min curve')
self._min_crv.attach(self._plotter)
self._max_crv.setData(x_values, self._max_envelop)
self._min_crv.setData(x_values, self._min_envelop)
self._compare_max = True
def do_compare(self):
print('in zoomwin do_compare')
if self._compare_max:
self.stop_compare_max()
self._compare_max = False
else:
self._max_envelop = self._y_values
self._min_envelop = self._y_values
self._max_crv = QwtPlotCurve('Zoomed max curve')
self._max_crv.attach(self._plotter)
self._min_crv = QwtPlotCurve('Zoomed min curve')
self._min_crv.attach(self._plotter)
self._max_crv.setData(x_values, self._max_envelop)
self._min_crv.setData(x_values, self._min_envelop)
self._compare_max = True
self.reset_max()
def stop_compare_max(self):
if self._compare_max:
self._max_envelop = 0.0
self._min_envelop = 0.0
self._max_crv.detach()
self._min_crv.detach()
self._compare_max = False
self._max_crv = -1
self._min_crv = -1
def get_max(self):
if self._compare_max:
self._max_envelop = self.max(self._max_envelop, self._y_values)
self._min_envelop = self.min(self._min_envelop, self._y_values)
def max(self, array1, array2):
shape = array1.shape
max_envelop = array1
for i in range(shape[0]):
if array2[i] > array1[i]:
max_envelop[i] = array2[i]
return max_envelop
def min(self, array1, array2):
shape = array1.shape
min_envelop = array1
for i in range(shape[0]):
if array2[i] < array1[i]:
min_envelop[i] = array2[i]
return min_envelop
def reset_max(self):
if self._compare_max:
self._max_envelop = self._y_values
self._min_envelop = self._y_values
def test_max(self):
if self._compare_max:
return True
else:
return False
def pause_mode(self):
if self._do_pause:
return True
else:
return False
def exec_close(self):
self.close()
def Pausing(self):
self.winpaused.emit(self._curve_number)
def change_scale_type(self):
# click means change to fixed scale
toggle_id = self.menu_table['Fixed Scale ']
if self._do_fixed_scale:
self._do_fixed_scale = False
self._menu.changeItem(toggle_id, 'Fixed Scale')
self._plotter.setAxisAutoScale(QwtPlot.yLeft)
self.image_auto_scale.emit(0)
else:
self._do_fixed_scale = True
self._menu.changeItem(toggle_id, 'Auto Scale')
# find current data min and max
scale_max = self._y_values.max()
scale_min = self._y_values.min()
def set_scale_values(self, max_value, min_value):
if self._do_fixed_scale:
self.image_scale_values.emit(max_value, min_value)
self._plotter.setAxisScale(QwtPlot.yLeft, min_value, max_value)
self._plotter.replot()
def cancel_scale_request(self):
if self._do_fixed_scale:
toggle_id = self.menu_table['Fixed Scale ']
self._menu.changeItem(toggle_id, 'Fixed Scale')
self._plotter.setAxisAutoScale(QwtPlot.yLeft)
self._do_fixed_scale = False
def update_plot(self, y_values, flags):
if not self._do_pause:
self._plotter.unsetFlagsData()
self._y_values = y_values
abs_flags = numpy.absolute(flags)
if abs_flags.max() > 0:
if len(flags) == len(self._y_values):
self._plotter.setFlagsData(flags, flip_axes=True)
self._plotter.set_flag_toggles_active(True, False)
else:
self._plotter.set_flag_toggles_active(False, False)
self._plotter.array_plot(incoming_plot_array=self._y_values,
flip_axes=True)
# self.get_max()
self._plotter.replot()
def setDataLabel(self, data_label, array_label, is_array=False):
self._data_label = data_label
if array_label is None:
self._array_label = 'Ch ' + str(self._curve_number)
else:
self._array_label = array_label
if is_array:
self._zoom_plot_label = self._data_label + ": " + self._array_label
else:
self._zoom_plot_label = self._data_label + ": " + self._array_label + " Sequence (oldest to most recent)"
self._plotter.setAxisTitle(QwtPlot.xBottom, self._zoom_plot_label)
self._plotter._x_title = self._zoom_plot_label
self.setWindowTitle(self._zoom_plot_label)
def plotMouseMoved(self, e):
""" Gets x and y position of the mouse on the plot according to axis' value
set right text on the button and underneath the plot
"""
# (I) e (QMouseEvent) Mouse event
lbl = QString("Event=")
lbl2 = QString("")
lbl2.setNum(self._plotter.invTransform(QwtPlot.xBottom,
e.pos().x()), 'g', 3)
lbl += lbl2 + ", Signal="
lbl2.setNum(self._plotter.invTransform(QwtPlot.yLeft,
e.pos().y()), 'g', 3)
lbl += lbl2
# self._ControlFrame._lblInfo.setText(lbl)
def closeEvent(self, ce):
if self._do_close:
self.winclosed.emit(self._curve_number)
ce.accept()
else:
ce.ignore()
class MyWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui=Ui_MainWindow()
self.ui.setupUi(self)
# connect methods to buttons' click signals
self.ui.wakeUpButton.clicked.connect(self.wakeUp)
self.ui.stopButton.clicked.connect(self.stop)
self.ui.closeButton.clicked.connect(self.close)
self.ui.saveButton.clicked.connect(self.save)
self.ui.immediateButton.clicked.connect(self.immediate)
self.ui.finalButton.clicked.connect(self.final)
self.ui.fitButton.clicked.connect(self.fit)
self.ui.action_Save_Ctrl_S.triggered.connect(self.save)
self.ui.action_Quit_Ctrl_Q.triggered.connect(self.close)
self.ui.actionManual.triggered.connect(self.manual)
self.ui.actionAbout.triggered.connect(self.about)
# create a timer
self.stopTime=time.time()
self.timer=QtCore.QTimer()
# connect the timer to the "tick" callback method
self.timer.timeout.connect(self.tick)
# 20 times per second
self.timer.start(50)
# initialize an empty curve for the plot widget
self.curve = QwtPlotCurve()
self.curve.attach(self.ui.qwtPlot)
# expEYESdetection and initialization
try:
self.p = ej.open()
assert(self.p.fd)
self.setWindowTitle("expEYES Junior found on port {}".format(
self.p.fd.port
))
except:
self.setWindowTitle("ERROR: expEYES Junior NOT FOUND!")
self.wakeUpButton.setEnabled(False)
# custom properties
self.isImmediate=True
return
def immediate(self):
self.isImmediate=True
return
def final(self):
self.isImmediate=False
return
def wakeUp(self):
# get the duration of the experiment in s
duration = float(self.ui.durationEdit.text())
if duration < 0.5: # "final" mode is mandatory
self.ui.finalButton.setChecked(True)
self.isImmediate=False
elif duration > 3.5: # "immediate" mode is mandatory
self.ui.immediateButton.setChecked(True)
self.isImmediate=True
self.ui.qwtPlot.setAxisScale(QwtPlot.xBottom, 0, duration)
if self.isImmediate:
now=time.time()
self.t=[]
self.v=[]
self.curve.setData([],[],0)
self.startTime=now
self.stopTime=now+duration
# now the curve will grow until time.time >= self.stopTime
# thanks to self.timer's timeout events
else:
samples = 1800 # maximum sample number with 8 bit precision
# ensure that samples * delay will be slightly bigger than duration
delay=1+int(duration*1e6/1800)
t, self.v = self.p.capture(1,samples, delay)
self.t=[1e-3*date for date in t] # convert ms to s
self.curve.setData(self.t, self.v, len(self.t))
return
def tick(self):
""" Callback for the timeout events """
t=time.time()
if t < self.stopTime:
v = self.p.get_voltage(1)
self.t.append(time.time()-self.startTime)
self.v.append(v)
self.curve.setData(self.t, self.v, len(self.t))
return
def notImplemented(self):
msg=QtGui.QMessageBox(QtGui.QMessageBox.Warning,"Sorry",
"not yet implemented", )
msg.exec_()
return
stop=save=fit=manual=about=notImplemented
class DataPlot(QwtPlot):
def __init__(self, *args):
QwtPlot.__init__(self, *args)
self.Dev_COM = None
self.uut_dev = None
print(args)
if args:
self.Dev_COM = args[0]
if self.Dev_COM:
# Initialize Decice COM,
self.uut_dev = device.SerialDevice(False,
False,
port=self.Dev_COM,
baudrate=9600)
else:
# Initial LAN device
#UUT PORT(NOTE: PC need to config the same ip section)
self.uut_Client_ip = '169.254.1.3'
self.uut_lan_port = 3490 #
self.uut_buf_size = 1024
try:
self.uut_dev = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
Addr = (self.uut_Client_ip, self.uut_lan_port)
self.uut_dev.connect(Addr)
print('Connectin created!')
except Exception as e: #
raise Exception(e)
#print(self.sendcmd('SYST:REM\r\n'))
print(self.sendcmd('*CLS\r\n'))
fileTIME = datetime.datetime.now()
File_timestamp = "%04d-%02d-%02d_%02d%02d%02d" % (
fileTIME.year, fileTIME.month, fileTIME.day, fileTIME.hour,
fileTIME.minute, fileTIME.second)
self.fileNamme = r'./data/data_%s.txt' % (File_timestamp)
print(self.fileNamme)
# Initialize 坐标轴
self.setCanvasBackground(Qt.white)
self.alignScales()
grid = QwtPlotGrid()
grid.attach(self)
grid.setMajorPen(QPen(Qt.black, 0, Qt.DotLine))
self.setAxisScale(QwtPlot.xBottom, 0.0, 300.1, 10.0)
self.setAxisAutoScale(QwtPlot.yLeft, True)
#self.setAxisScale(QwtPlot.yLeft,99.99,100.0,0.0005)
self.x = np.arange(
0.0, 300, 0.5
) #0.5 for ONE POINT, THIS SHOULD BE Align to the reading rate:250ms
print(self.x)
#self.z = np.zeros(len(self.x), np.float)
list = []
for i in range(len(self.x)):
list.append(0)
self.z = np.array(list)
self.setTitle("UUT Reading Monitor - (mA)")
self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
self.curveL = QwtPlotCurve("UUT Reading")
self.curveL.attach(self)
self.curveL.setPen(QPen(Qt.red))
self.setAxisTitle(QwtPlot.xBottom, "Time (seconds)")
self.setAxisTitle(QwtPlot.yLeft, "UUT - Reading(mA)")
self.replot()
self.startTimer(500) # ms # FOR GET READING
self.starttime = time.clock()
#unit: s
self.idx = 0
self.readfmt = "%f"
self.Saveinfo("Starting...")
def alignScales(self):
self.canvas().setFrameStyle(QFrame.Box | QFrame.Plain)
self.canvas().setLineWidth(1)
for i in range(QwtPlot.axisCnt):
scaleWidget = self.axisWidget(i)
if scaleWidget:
scaleWidget.setMargin(0)
scaleDraw = self.axisScaleDraw(i)
if scaleDraw:
scaleDraw.enableComponent(QwtAbstractScaleDraw.Backbone, False)
def timerEvent(self, e):
# send cmd and get readings, record times, X is second;
if self.Dev_COM: # SerialDevice
# tfdata = self.uut_get_val(self.uut_dev, "VAL?\r") #Wolf
#tfdata = self.uut_get_val(self.uut_dev, "READ:VOLT:DC?\r") # GW VOLT
#ifdata = self.uut_get_val(self.uut_dev, "READ:CURR:DC?\r") # GW CURRENT
#tfdata = self.uut_get_val(self.uut_dev, "x?\r\n") # 8508
#print('Getting Serial data.........')
tfdata = self.uut_get_val(self.uut_dev,
"UPPER_VAL?\r\n") # pass/pac
#tfdata = 1000*self.uut_get_val(self.uut_dev, "CONF:CURR:DC +1.000000E-01,+1.000000E-07;:MEAS:CURR:DC?\r\n") # 8846
else: # LanDevice
print('Getting Serial data.........')
tfdata = 1000.0 * float(
self.Get_Lan_Response(
"CONF:CURR:DC +1.000000E-01,+1.000000E-07;:MEAS:CURR:DC?\r\n"
)) # 8846
print(tfdata) #, "\t" , ifdata
self.z = np.concatenate((self.z[1:], self.z[:1]), 0)
self.z[-1] = tfdata
self.curveL.setData(self.x, self.z)
self.replot()
self.idx = self.idx + 1
#Write file to txt log
self.SaveData(tfdata)
now = time.clock()
if ((now - self.starttime) > 250): # 250 point (seconds)
self.starttime = time.clock()
# reset start time
pngTIME = datetime.datetime.now()
FILE_timestamp = "%04d-%02d-%02d_%02d%02d%02d" % (
pngTIME.year, pngTIME.month, pngTIME.day, pngTIME.hour,
pngTIME.minute, pngTIME.second)
PNGFile = ('%s_%s' % (FILE_timestamp, '.png'))
self.exportTo('.\pic\%s' % PNGFile,
size=(1920, 1080),
resolution=200)
print PNGFile, "The snaped curve picture has been created."
def sendcmd(self, cmd):
cmd_encode = cmd.encode()
if self.Dev_COM:
self.uut_dev.write(cmd)
else:
self.uut_dev.send(cmd_encode)
return cmd_encode
# LAN Device reaponse
def Get_Lan_Response(self, cmd):
self.sendcmd(cmd)
Rsp = ''
rtn = ''
while (1):
recv_data = self.uut_dev.recv(self.uut_buf_size)
Rsp += recv_data.decode()
#print(Rsp)
if ('\n' or '\r') in Rsp:
Rsp.strip()
break
return Rsp
# Serial devie response
def uut_get_val(self,
uut_dev_in,
type="x?\r\n"
): #[0-9]\d*\.\d+$ #r'[ -+]\d+\.\d+[Ee][-+][0-9]{2}'
cmd_encode = type.encode()
print(cmd_encode)
uut_dev_in.flush()
m = uut_dev_in.trx(type, r'[0-9]\d*\.\d+$')
print m.group(0)
return float(m.group(0))
def SaveData(self, tfdata):
fh = open(self.fileNamme, "a")
now = datetime.datetime.now()
timestamp = "%02d:%02d:%02d.%03d" % (now.hour, now.minute, now.second,
now.microsecond / 1000)
str = "%s, %s, %s\n" % (self.idx, timestamp, tfdata)
fh.write(str)
fh.flush()
def Saveinfo(self, info):
fh = open(self.fileNamme, "a")
now = datetime.datetime.now()
timestamp = "%04d-%02d-%02d_%02d%02d%02d" % (
now.year, now.month, now.day, now.hour, now.minute, now.second)
title = "%s, %s\n" % (timestamp, info)
fh.write(title)
fh.write("\nSN,TIME,SenseNiose\n")
fh.flush()
