class ScopeShotTimer(QDialog):
def __init__(self):
super(ScopeShotTimer, self).__init__()
self.initUI()
def initUI(self):
self.count = 0
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.Time)
self.timer.start(1000)
self.lcd = QLCDNumber(self)
# get the palette
palette = self.lcd.palette()
# foreground color
palette.setColor(palette.WindowText, QtGui.QColor(85, 85, 255))
# background color
palette.setColor(palette.Background, QtGui.QColor(0, 170, 255))
# "light" border
palette.setColor(palette.Light, QtGui.QColor(255, 0, 0))
# "dark" border
palette.setColor(palette.Dark, QtGui.QColor(0, 255, 0))
# set the palette
self.lcd.setPalette(palette)
self.lcd.setMinimumHeight(100)
self.lcd.setMinimumWidth(148)
self.lcd.display(self.count)
diologGrid = QGridLayout()
diologGrid.addWidget(self.lcd, 0, 0)
self.okButton = QPushButton('Capture Scope Shot', self)
self.okButton.clicked[bool].connect(self.close)
diologGrid.addWidget(self.okButton, 0, 1)
self.setLayout(diologGrid)
self.setGeometry(200, 200, 150, 100)
self.setWindowTitle('Scope Capture')
self.setWindowIcon(QIcon('xbox_icon.ico'))
def Time(self):
# self.lcd.display(strftime("%H"+":"+"%M"+":"+"%S"))
self.count += 1
self.lcd.display(self.count)
if self.count == 120:
print '\a'
class timeWidget(QWidget):
time = pyqtSignal()
def __init__(self, winParent):
super(timeWidget, self).__init__()
self.winParent = winParent
self.seconds = 0
hLayout = QHBoxLayout()
timeLabel = QLabel("Time")
self.lcd = QLCDNumber(self)
self.lcd.setMaximumSize(100, 50)
hLayout.addWidget(timeLabel, 0)
hLayout.addWidget(self.lcd, 1)
hSpacer = QSpacerItem(300, 30, QSizePolicy.Ignored,
QSizePolicy.Ignored)
hLayout.addItem(hSpacer)
self.setLayout(hLayout)
timer = QTimer(self)
timer.start(1000)
timer.timeout.connect(self.printTime)
# get the palette
palette = self.lcd.palette()
# foreground color
palette.setColor(palette.WindowText, QColor(85, 85, 255))
# background color
palette.setColor(palette.Background, QColor(0, 170, 255))
# "light" border
palette.setColor(palette.Light, QColor(255, 0, 0))
# "dark" border
palette.setColor(palette.Dark, QColor(0, 255, 0))
# set the palette
self.lcd.setPalette(palette)
def printTime(self):
self.seconds += 1
self.lcd.display(self.seconds)
class timeWidget(QWidget):
time = pyqtSignal()
def __init__(self,winParent):
super(timeWidget, self).__init__()
self.winParent=winParent
self.seconds = 0
hLayout = QHBoxLayout()
timeLabel = QLabel("Time")
self.lcd = QLCDNumber(self)
self.lcd.setMaximumSize(100,50)
hLayout.addWidget(timeLabel,0)
hLayout.addWidget(self.lcd, 1)
hSpacer = QSpacerItem(300, 30, QSizePolicy.Ignored, QSizePolicy.Ignored)
hLayout.addItem(hSpacer)
self.setLayout(hLayout)
timer = QTimer(self)
timer.start(1000)
timer.timeout.connect(self.printTime)
# get the palette
palette = self.lcd.palette()
# foreground color
palette.setColor(palette.WindowText, QColor(85, 85, 255))
# background color
palette.setColor(palette.Background, QColor(0, 170, 255))
# "light" border
palette.setColor(palette.Light, QColor(255, 0, 0))
# "dark" border
palette.setColor(palette.Dark, QColor(0, 255, 0))
# set the palette
self.lcd.setPalette(palette)
def printTime(self):
self.seconds += 1
self.lcd.display(self.seconds)
class CountDownTimer(QLCDNumber):
"""
time_allocation: positive integer, indicating the allocated time for user
time_value: started as time_allocation, and dynamically changed every second
"""
def __init__(self, time_allocation=15, parent=None):
super(CountDownTimer, self).__init__(parent)
self.time_allocation = time_allocation
self.time_value = self.time_allocation
# timer
self.timer = QTimer(self)
self.timer.timeout.connect(self.advance_time)
# LCD time display
self.lcd = QLCDNumber(self)
self.lcd.setDigitCount(3)
self.lcd.setSegmentStyle(QLCDNumber.Flat)
self.lcd.display(self.time_value)
def restart_timer(self):
self.time_value = self.time_allocation
self.lcd.display(self.time_value)
palette = self.lcd.palette()
palette.setColor(palette.WindowText, QColor(0, 0, 0))
self.lcd.setPalette(palette)
self.timer.start(1000)
def advance_time(self):
self.time_value -= 1
# Yellow - five seconds left
if self.time_value == 5:
palette = self.lcd.palette()
palette.setColor(palette.WindowText, QColor(255, 153, 0))
self.lcd.setPalette(palette)
# Red - no time left
if self.time_value == 0:
palette = self.lcd.palette()
palette.setColor(palette.WindowText, QColor(255, 0, 0))
self.lcd.setPalette(palette)
self.lcd.display(self.time_value)
class MainWindow(QWidget):
def __init__(self, ser, sio):
super().__init__()
# Setup the colour palette
palette = self.palette()
palette.setColor(QPalette.Window, QColor(40, 40, 40))
palette.setColor(QPalette.WindowText, QColor(230, 230, 230))
palette.setColor(QPalette.Base, QColor(252, 252, 252))
palette.setColor(QPalette.AlternateBase, QColor(239, 240, 241))
palette.setColor(QPalette.ToolTipBase, QColor(239, 240, 241))
palette.setColor(QPalette.ToolTipText, QColor(49, 54, 59))
palette.setColor(QPalette.Text, QColor(0, 0, 0))
palette.setColor(QPalette.Button, QColor(85, 90, 95))
palette.setColor(QPalette.ButtonText, QColor(50, 50, 50))
palette.setColor(QPalette.BrightText, QColor(255, 255, 255))
palette.setColor(QPalette.Link, QColor(41, 128, 185))
palette.setColor(QPalette.Highlight, QColor(136, 136, 136))
palette.setColor(QPalette.HighlightedText, QColor(239, 240, 241))
palette.setColor(QPalette.Disabled, QPalette.Light, Qt.white)
palette.setColor(QPalette.Disabled, QPalette.Shadow,
QColor(234, 234, 234))
self.setPalette(palette)
self.ser = ser
self.sio = sio
self.start = 1
self.maxforce = 0000.00
self.oldforce = 0.0
self.force = 0.0
self.initUI()
def initUI(self):
self.grid = QGridLayout()
self.teams = {}
self.currentteam = [QListWidgetItem_Team()]
self.chartView = QChartView()
self.loadNewGraph = True
# LCD Widget to display the force
self.forcelcd = QLCDNumber(7, self)
self.forcelcd.setStyleSheet(
"color: rgb(0, 210, 0); border-image: url(background3.png) stretch; background-repeat: no-repeat;"
)
lcdpalette = self.forcelcd.palette()
lcdpalette.setColor(lcdpalette.Light, QtGui.QColor(0, 255, 0))
lcdpalette.setColor(lcdpalette.Dark, QtGui.QColor(0, 0, 0))
self.forcelcd.setPalette(lcdpalette)
self.forcelcd.setFrameStyle(0)
# Push buttons
zero = QPushButton('Zero Scale', self)
clearmax = QPushButton('Reset', self)
clearmax.clicked.connect(self.reset)
export = QPushButton('Export', self)
togglestart = QPushButton('Start/Stop', self)
# Push Button Functions
zero.clicked.connect(self.zero_scale)
clearmax.clicked.connect(self.reset)
export.clicked.connect(self.exportTeams)
togglestart.clicked.connect(self.toggle)
# Textbox to enter in team name
self.teaminput = QLineEdit()
self.teaminput.setText('Enter team here')
self.teaminput.returnPressed.connect(self.addTeam)
# Current highest force text
self.maxforce = 0000.00
self.maxforcetxt = QLabel()
self.maxforcetxt.setFont(QtGui.QFont("Quartz", 62))
self.maxforcetxt.setText("Maximum Force: %.2f N" % self.maxforce)
self.maxforcetxt.setStyleSheet(
"color: rgb(0, 210, 0); background-image: url(maxbackground.png); background-attachment: fixed"
)
self.maxforcetxt.setAlignment(QtCore.Qt.AlignCenter)
# List of teams and scores
self.teamlist = QListWidget()
self.teamlist.setStyleSheet("background-color: rgb(85, 90, 100);")
self.teamlist.setSortingEnabled(True)
self.teamlist.itemDoubleClicked.connect(self.selectTeam)
# EGBC Logo
self.EGBC = QLabel()
img = QPixmap('EGBC_Logo_Mod2.png')
self.EGBC.setPixmap(img)
# Add widgets to grid and format
self.grid.setColumnStretch(1, 2)
self.grid.setColumnStretch(2, 2)
self.grid.setColumnStretch(3, 2)
self.grid.setColumnStretch(4, 2)
self.grid.setColumnStretch(5, 1)
self.grid.setColumnStretch(6, 2)
self.grid.setRowStretch(1, 6)
self.grid.setRowStretch(0, 1)
self.grid.addWidget(self.maxforcetxt, 0, 1, 1, 4)
self.grid.addWidget(self.EGBC, 0, 5, 1, 2)
self.grid.addWidget(self.forcelcd, 1, 1, 1, 5)
self.grid.addWidget(zero, 2, 1)
self.grid.addWidget(clearmax, 2, 2)
self.grid.addWidget(export, 2, 3)
self.grid.addWidget(togglestart, 2, 4)
self.grid.addWidget(self.teamlist, 1, 6)
self.grid.addWidget(self.teaminput, 2, 6)
self.updateforce()
self.setLayout(self.grid)
print(self.teaminput.width())
self.showFullScreen()
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
reply = QMessageBox.question(self, 'PyQt5 message',
"Do you want to exit the program?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes:
self.close()
else:
e.ignore()
def zero_scale(self):
self.ser.write(b'x\r\n')
self.sio.flush()
trunk = self.sio.readline()
self.ser.write(b'1\r\n')
self.sio.flush()
for line in self.sio.readlines():
if line == '>\r\n':
break
self.ser.write(b'x\r\nx\r\n')
self.sio.flush()
self.reset()
return
def reset(self):
self.maxforce = 0.0
self.force = 0.0
self.maxforcetxt.setText(str("Maximum Force: %.2f N" % self.maxforce))
self.forcelcd.display(self.force)
def toggle(self):
self.start ^= 1
if self.start:
self.chartView.hide()
#self.grid.removeWidget(self.chartView)
self.forcelcd.show()
else:
self.loadNewGraph = True
self.forcelcd.hide()
def addTeam(self):
self.grid.removeWidget(self.chartView)
team = self.teaminput.text()
print(team)
if team and team != "Enter team here":
self.teaminput.setText("")
self.teams[team] = [
0.00,
]
item = QListWidgetItem_Team()
item.setText(team + " - " + str(self.teams[team]))
item.setFont(QtGui.QFont("Times", 32))
self.teamlist.addItem(item)
with open(os.path.join(csv_path, team + '.csv'), 'w',
newline='') as csvfileout:
writer = csv.DictWriter(csvfileout, fieldnames=['Sample', 'Force'])
writer.writeheader()
csvfileout.close()
def selectTeam(self):
self.chartView.hide()
self.currentteam = self.teamlist.selectedItems()
if not self.start:
self.loadNewGraph = True
def exportTeams(self):
for team in self.teams:
sample = 0
with open(os.path.join(csv_path, team + '.csv'), 'w',
newline='') as csvfileout:
writer = csv.DictWriter(csvfileout,
fieldnames=['Sample', 'Force'])
writer.writeheader()
for samples in self.teams[team]:
writer.writerow({'Sample': sample, 'Force': samples})
sample += 1
csvfileout.close()
def get_force(self):
self.ser.flushOutput()
self.ser.flushInput()
output = self.sio.readline()
print(output)
if 'Exiting' not in output and len(output) in range(10, 12):
end = output.rfind(',kg')
value = output[0:end]
else:
value = self.oldforce / 9.81
return value
def updateforce(self):
self.grid.removeWidget(self.chartView)
if self.start:
# Generate some random force values for testing
#self.force = random.randrange(1,5000,1)
#self.force += 0.01
self.force = round(float(self.get_force()) * 9.81, 2)
self.forcelcd.display(self.force)
self.oldforce = self.force
# Update team dictionary and CSV file
if self.currentteam[0].name():
self.teams[self.currentteam[0].name()].append(self.force)
start = time.time()
with open(os.path.join(csv_path,
self.currentteam[0].name() + ".csv"),
"a+",
newline='') as csvfile:
writer = csv.DictWriter(csvfile,
fieldnames=['Sample', 'Force'])
csvfile.seek(0)
writer.writerow({
'Sample': self.currentteam[0].samples,
'Force': self.force
})
self.currentteam[0].samples += 1
csvfile.close()
end = time.time()
print(end - start)
# New max force found, update the force label and list
if self.force > self.maxforce:
self.maxforce = self.force
self.maxforcetxt.setText("Maximum Force: %.2f N" % self.force)
self.currentteam[0].setForce(self.force)
if not self.start and self.loadNewGraph:
data = QSplineSeries()
data.setName(self.currentteam[0].name())
with open(os.path.join(csv_path,
self.currentteam[0].name() + '.csv'),
"r",
newline='') as file:
for line in file:
if "Sample" not in line:
s = line.split(",")
data.append(float(s[0]), float(s[1]))
file.close()
maxForceline = QLineSeries()
maxForceline.setName("Maxiumum Force")
maxForceline.append(0.0, self.currentteam[0].force())
maxForceline.append(self.currentteam[0].samples,
self.currentteam[0].force())
force_chart = QChart()
force_chart.addSeries(data)
force_chart.addSeries(maxForceline)
force_chart.setToolTip("{}".format(self.maxforce))
force_chart.setTitle("Force vs. Time Graph for {}".format(
self.currentteam[0].name()))
force_chart.createDefaultAxes()
force_chart.axisY().setRange(0, self.currentteam[0].force() + 10)
force_chart.setTheme(2)
self.chartView = QChartView(force_chart)
self.chartView.setRenderHint(QPainter.Antialiasing)
# self.grid.removeWidget(self.chartView)
self.grid.addWidget(self.chartView, 1, 1, 1, 5)
print(self.grid.children())
self.chartView.show()
self.loadNewGraph = False
QtCore.QTimer.singleShot(200, lambda: self.updateforce())
class PlayingMediaWidget(QWidget):
def __init__(self, cue, **kwargs):
super().__init__(**kwargs)
self.cue = cue
self.cue_time = CueTime(cue)
self.cue_time.notify.connect(self._time_updated, Connection.QtQueued)
self._dbmeter_element = None
self._accurate_time = False
scroll_size = (self.parent().verticalScrollBar().width() + 5)
self.setGeometry(0, 0, self.parent().width() - scroll_size, 102)
self.setFocusPolicy(Qt.NoFocus)
self.gridLayoutWidget = QWidget(self)
self.gridLayoutWidget.setGeometry(self.geometry())
self.gridLayout = QGridLayout(self.gridLayoutWidget)
self.gridLayout.setContentsMargins(2, 2, 2, 2)
self.nameLabel = QLabel(self.gridLayoutWidget)
self.nameLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.nameLabel.setText(cue.name)
self.nameLabel.setToolTip(cue.name)
self.gridLayout.addWidget(self.nameLabel, 0, 0, 1, 3)
self.playPauseButton = QPushButton(self.gridLayoutWidget)
self.playPauseButton.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.playPauseButton.setIcon(QIcon.fromTheme('media-playback-pause'))
self.playPauseButton.setIconSize(QSize(24, 24))
self.playPauseButton.setFocusPolicy(Qt.NoFocus)
self.playPauseButton.clicked.connect(self._pause)
self.gridLayout.addWidget(self.playPauseButton, 1, 0)
self.stopButton = QPushButton(self.gridLayoutWidget)
self.stopButton.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.stopButton.setIcon(QIcon.fromTheme('media-playback-stop'))
self.stopButton.setIconSize(QSize(24, 24))
self.stopButton.setFocusPolicy(Qt.NoFocus)
self.stopButton.clicked.connect(self._stop)
self.gridLayout.addWidget(self.stopButton, 1, 1)
self.timeDisplay = QLCDNumber(self.gridLayoutWidget)
self.timeDisplay.setStyleSheet('background-color: transparent')
self.timeDisplay.setSegmentStyle(QLCDNumber.Flat)
self.timeDisplay.setDigitCount(8)
self.timeDisplay.display(strtime(cue.media.duration))
self.gridLayout.addWidget(self.timeDisplay, 1, 2)
self.seekSlider = QClickSlider(self.gridLayoutWidget)
self.seekSlider.setOrientation(Qt.Horizontal)
self.seekSlider.setRange(0, cue.media.duration)
self.seekSlider.setFocusPolicy(Qt.NoFocus)
self.seekSlider.sliderMoved.connect(self._seek)
self.seekSlider.sliderJumped.connect(self._seek)
self.seekSlider.setVisible(False)
self.dbmeter = QDbMeter(self.gridLayoutWidget)
self.dbmeter.setVisible(False)
self.gridLayout.setRowStretch(0, 1)
self.gridLayout.setRowStretch(1, 2)
self.gridLayout.setColumnStretch(0, 3)
self.gridLayout.setColumnStretch(1, 3)
self.gridLayout.setColumnStretch(2, 5)
cue.changed('name').connect(self.name_changed)
cue.media.changed('duration').connect(self.update_duration)
cue.media.played.connect(self._pause_to_play)
cue.media.paused.connect(self._play_to_pause)
self.fade = self.cue.media.element('Fade')
if self.fade is not None:
self.fade.enter_fadein.connect(self.enter_fadein)
self.fade.enter_fadeout.connect(self.enter_fadeout)
self.fade.exit_fadein.connect(self.exit_fade)
self.fade.exit_fadeout.connect(self.exit_fade)
def enter_fadeout(self):
p = self.timeDisplay.palette()
p.setColor(p.Text, QColor(255, 50, 50))
self.timeDisplay.setPalette(p)
def enter_fadein(self):
p = self.timeDisplay.palette()
p.setColor(p.Text, QColor(0, 255, 0))
self.timeDisplay.setPalette(p)
def exit_fade(self):
self.timeDisplay.setPalette(self.palette())
def name_changed(self, name):
self.nameLabel.setText(name)
self.nameLabel.setToolTip(name)
def set_accurate_time(self, enable):
self._accurate_time = enable
def set_seek_visible(self, visible):
if visible and not self.seekSlider.isVisible():
self.gridLayout.addWidget(self.seekSlider, 2, 0, 1, 3)
self.gridLayout.setRowStretch(2, 1)
elif not visible and self.seekSlider.isVisible():
self.gridLayout.removeWidget(self.seekSlider)
self.gridLayout.setRowStretch(2, 0)
self.seekSlider.setVisible(visible)
def set_dbmeter_visible(self, visible):
if self._dbmeter_element is not None:
self._dbmeter_element.level_ready.disconnect(self.dbmeter.plot)
self._dbmeter_element = None
if visible:
self._dbmeter_element = self.cue.media.element('DbMeter')
if self._dbmeter_element is not None:
self._dbmeter_element.level_ready.connect(self.dbmeter.plot)
# Add/Remove the QDbMeter in the layout
if visible and not self.dbmeter.isVisible():
self.gridLayout.addWidget(self.dbmeter, 0, 3, 4, 1)
self.gridLayout.setColumnStretch(3, 1)
elif not visible and self.dbmeter.isVisible():
self.gridLayout.removeWidget(self.dbmeter)
self.gridLayout.setColumnStretch(3, 0)
self.dbmeter.setVisible(visible)
def _time_updated(self, time):
if not self.visibleRegion().isEmpty():
# If the given value is the duration or < 0 set the time to 0
if time == self.cue.media.duration or time < 0:
time = 0
# Set the value the seek slider
self.seekSlider.setValue(time)
# Show the time in the widget
self.timeDisplay.display(strtime(self.cue.media.duration - time,
accurate=self._accurate_time))
def update_duration(self, media, duration):
self.seekSlider.setMaximum(duration)
def _stop(self, *args):
self.cue.stop()
def _play(self, *args):
self.cue.start()
def _pause(self, *args):
self.cue.pause()
def _seek(self, position):
self.cue.media.seek(position)
def _play_to_pause(self):
self.playPauseButton.clicked.disconnect()
self.playPauseButton.clicked.connect(self._play)
self.playPauseButton.setIcon(QIcon.fromTheme('media-playback-start'))
def _pause_to_play(self):
self.playPauseButton.clicked.disconnect()
self.playPauseButton.clicked.connect(self._pause)
self.playPauseButton.setIcon(QIcon.fromTheme('media-playback-pause'))
class PlayingMediaWidget(QWidget):
def __init__(self, cue, media_time, parent=None):
super().__init__(parent)
self.cue = cue
self.media_time = media_time
self._dbmeter_element = None
self._accurate_time = False
scroll_size = (self.parent().verticalScrollBar().width() + 5)
self.setGeometry(0, 0, self.parent().width() - scroll_size, 102)
self.setFocusPolicy(Qt.NoFocus)
self.gridLayoutWidget = QWidget(self)
self.gridLayoutWidget.setGeometry(self.geometry())
self.gridLayout = QGridLayout(self.gridLayoutWidget)
self.gridLayout.setContentsMargins(2, 2, 2, 2)
self.nameLabel = QLabel(self.gridLayoutWidget)
self.nameLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.nameLabel.setText(cue['name'])
self.nameLabel.setToolTip(cue['name'])
self.gridLayout.addWidget(self.nameLabel, 0, 0, 1, 3)
self.playPauseButton = QPushButton(self.gridLayoutWidget)
self.playPauseButton.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.playPauseButton.setIcon(QIcon.fromTheme("media-playback-pause"))
self.playPauseButton.setFocusPolicy(Qt.NoFocus)
self.playPauseButton.clicked.connect(lambda: self.cue.media.pause())
self.gridLayout.addWidget(self.playPauseButton, 1, 0)
self.stopButton = QPushButton(self.gridLayoutWidget)
self.stopButton.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.stopButton.setIcon(QIcon.fromTheme("media-playback-stop"))
self.stopButton.setFocusPolicy(Qt.NoFocus)
self.stopButton.clicked.connect(lambda m: cue.media.stop())
self.gridLayout.addWidget(self.stopButton, 1, 1)
self.timeDisplay = QLCDNumber(self.gridLayoutWidget)
self.timeDisplay.setSegmentStyle(QLCDNumber.Flat)
self.timeDisplay.setDigitCount(8)
self.timeDisplay.display(strtime(cue.media['duration']))
self.gridLayout.addWidget(self.timeDisplay, 1, 2)
self.seekSlider = QClickSlider(self.gridLayoutWidget)
self.seekSlider.setOrientation(Qt.Horizontal)
self.seekSlider.setRange(0, cue.media['duration'])
self.seekSlider.setFocusPolicy(Qt.NoFocus)
self.seekSlider.sliderMoved.connect(cue.media.seek)
self.seekSlider.sliderJumped.connect(cue.media.seek)
self.seekSlider.setVisible(False)
self.dbmeter = QDbMeter(self.gridLayoutWidget)
self.dbmeter.setVisible(False)
self.gridLayout.setRowStretch(0, 1)
self.gridLayout.setRowStretch(1, 2)
self.gridLayout.setColumnStretch(0, 3)
self.gridLayout.setColumnStretch(1, 3)
self.gridLayout.setColumnStretch(2, 5)
self.media_time.notify.connect(self.on_time_updated)
cue.updated.connect(self.on_cue_updated)
cue.media.duration.connect(self.update_duration)
cue.media.played.connect(self._pause_to_play)
cue.media.paused.connect(self._play_to_pause)
self.fade = self.cue.media.element("Fade")
if self.fade is not None:
self.fade.enter_fadein.connect(self.enter_fadein)
self.fade.enter_fadeout.connect(self.enter_fadeout)
self.fade.exit_fadein.connect(self.exit_fade)
self.fade.exit_fadeout.connect(self.exit_fade)
def enter_fadeout(self):
p = self.timeDisplay.palette()
p.setColor(p.Text, QColor(255, 50, 50))
self.timeDisplay.setPalette(p)
def enter_fadein(self):
p = self.timeDisplay.palette()
p.setColor(p.Text, QColor(0, 255, 0))
self.timeDisplay.setPalette(p)
def exit_fade(self):
self.timeDisplay.setPalette(self.palette())
def on_cue_updated(self, cue):
self.nameLabel.setText(cue['name'])
self.nameLabel.setToolTip(cue['name'])
def set_accurate_time(self, enable):
self._accurate_time = enable
def set_seek_visible(self, visible):
if visible and not self.seekSlider.isVisible():
self.gridLayout.addWidget(self.seekSlider, 2, 0, 1, 3)
self.gridLayout.setRowStretch(2, 1)
elif not visible and self.seekSlider.isVisible():
self.gridLayout.removeWidget(self.seekSlider)
self.gridLayout.setRowStretch(2, 0)
self.seekSlider.setVisible(visible)
def set_dbmeter_visible(self, visible):
if self._dbmeter_element is not None:
self._dbmeter_element.levelReady.disconnect(self.dbmeter.plot)
self._dbmeter_element = None
if visible:
self._dbmeter_element = self.cue.media.element("DbMeter")
if self._dbmeter_element is not None:
self._dbmeter_element.levelReady.connect(self.dbmeter.plot)
# Add/Remove the QDbMeter in the layout
if visible and not self.dbmeter.isVisible():
self.gridLayout.addWidget(self.dbmeter, 0, 3, 4, 1)
self.gridLayout.setColumnStretch(3, 1)
elif not visible and self.dbmeter.isVisible():
self.gridLayout.removeWidget(self.dbmeter)
self.gridLayout.setColumnStretch(3, 0)
self.dbmeter.setVisible(visible)
def on_time_updated(self, time):
if not self.visibleRegion().isEmpty():
# If the given value is the duration or < 0 set the time to 0
if time == self.cue.media['duration'] or time < 0:
time = 0
# Set the value the seek slider
self.seekSlider.setValue(time)
# If in count-down mode the widget will show the remaining time
time = self.cue.media['duration'] - time
# Show the time in the widget
self.timeDisplay.display(strtime(time,
accurate=self._accurate_time))
def update_duration(self, media, duration):
self.seekSlider.setMaximum(duration)
def _play_to_pause(self):
self.playPauseButton.clicked.disconnect()
self.playPauseButton.clicked.connect(lambda: self.cue.media.play())
self.playPauseButton.setIcon(QIcon.fromTheme("media-playback-start"))
def _pause_to_play(self):
self.playPauseButton.clicked.disconnect()
self.playPauseButton.clicked.connect(lambda: self.cue.media.pause())
self.playPauseButton.setIcon(QIcon.fromTheme("media-playback-pause"))
def destroy_widget(self):
self.hide()
self.set_dbmeter_visible(False)
self.media_time.notify.disconnect(self.on_time_updated)
if self.fade is not None:
self.fade.enter_fadein.disconnect(self.enter_fadein)
self.fade.enter_fadeout.disconnect(self.enter_fadeout)
self.fade.exit_fadein.disconnect(self.exit_fade)
self.fade.exit_fadeout.disconnect(self.exit_fade)
self.cue.media.duration.disconnect(self.update_duration)
self.cue.updated.disconnect(self.on_cue_updated)
class timeDigitalWidget(QWidget):
time = pyqtSignal()
def __init__(self, winParent, Percentage):
super(timeDigitalWidget, self).__init__()
self.winParent = winParent
self.seconds = 900
self.pose3d = pose3d
self.Percentage = Percentage
self.show = False
self.MAX_PERCENT = 30
self.MAX_MARK = 10
self.hLayout = QHBoxLayout()
timeLabel = QLabel("Time")
self.lcd = QLCDNumber(self)
self.lcd.setMaximumSize(100, 50)
self.hLayout.addWidget(timeLabel, 0)
self.hLayout.addWidget(self.lcd, 1)
hSpacer = QSpacerItem(300, 30, QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.hLayout.addItem(hSpacer)
self.setLayout(self.hLayout)
timer = QTimer(self)
timer.start(1000)
timer.timeout.connect(self.printTime)
# get the palette
palette = self.lcd.palette()
# foreground color
palette.setColor(palette.WindowText, QColor(85, 85, 255))
# background color
palette.setColor(palette.Background, QColor(0, 170, 255))
# "light" border
palette.setColor(palette.Light, QColor(255, 0, 0))
# "dark" border
palette.setColor(palette.Dark, QColor(0, 255, 0))
# set the palette
self.lcd.setPalette(palette)
def showMark(self):
self.show = True
mark = self.testPercentage()
markLabel = QLabel('Final mark: ' + str(mark))
self.hLayout.addWidget(markLabel, 0)
self.setLayout(self.hLayout)
def printTime(self):
if self.seconds > 0:
self.seconds -= 1
else:
if not self.show:
self.showMark()
self.lcd.display(self.seconds)
def testPercentage(self):
pHouse = self.Percentage.calculatePercentage()
markPerc = float(pHouse) * float(self.MAX_MARK) / float(
self.MAX_PERCENT)
if pHouse > self.MAX_PERCENT:
markPerc = 10
return markPerc
class Objetives(QWidget):
NumButtons = 3
def __init__(self, parent=None):
super(Objetives, self).__init__(parent)
self.createDisplay()
self.createDisplayAverage()
self.createButtons()
self.numVictory = 0
self.numLosses = 0
mainLayout = QGridLayout()
mainLayout.addWidget(self.displayLCD)
mainLayout.addWidget(self.horizontalGroupBox)
mainLayout.addWidget(self.displayWinPercent)
self.setLayout(mainLayout)
self.setWindowTitle("Objetives")
def createButtons(self):
self.horizontalGroupBox = QGroupBox("")
layout = QGridLayout()
self.victoryButton = self.createButton("Victory", "+",self.addVictoryOrLosses)
self.lossesButton = self.createButton("Losses", "+",self.addVictoryOrLosses)
self.victoryDecreaseButton = self.createButton("DV","-",self.addVictoryOrLosses)
self.losseDecreaseButton = self.createButton("DL","-",self.addVictoryOrLosses)
self.lossesButton.setMinimumWidth(150)
self.victoryButton.setMinimumWidth(150)
self.losseDecreaseButton.setMaximumHeight(20)
self.victoryDecreaseButton.setMaximumHeight(20)
layout.addWidget(self.victoryButton, 0, 0, 1, 1)
layout.addWidget(self.lossesButton, 0, 2, 1, 1)
layout.addWidget(self.victoryDecreaseButton, 1, 0, 1, 1)
layout.addWidget(self.losseDecreaseButton, 1, 2, 1, 1)
self.horizontalGroupBox.setLayout(layout)
def createDisplayAverage(self):
self.displayWinPercent = QGroupBox("Wins")
layout = QHBoxLayout()
self.progressBar = QProgressBar()
self.progressBar.setRange(0, 100)
# self.progressBar.setValue(5000)
layout.addWidget(self.progressBar)
self.displayWinPercent.setLayout(layout)
def createDisplay(self):
self.displayLCD = QGroupBox("")
layout = QHBoxLayout()
paletteLosses = QPalette()
paletteVictory = QPalette()
paletteLosses.setColor(paletteLosses.WindowText, QColor(255, 000, 000))
paletteVictory.setColor(paletteVictory.WindowText, QColor(000, 255, 000))
self.lossesLcd = QLCDNumber(3)
self.lossesLcd.setSegmentStyle(QLCDNumber.Filled)
self.lossesLcd.setPalette(paletteLosses)
self.victoryLcd = QLCDNumber(3)
self.victoryLcd.setSegmentStyle(QLCDNumber.Filled)
self.victoryLcd.setPalette(paletteVictory)
self.lossesLcd.setMinimumHeight(100)
self.victoryLcd.setMinimumHeight(100)
self.lossesLcd.setMinimumWidth(150)
self.victoryLcd.setMinimumWidth(150)
layout.addWidget(self.victoryLcd)
layout.addWidget(self.lossesLcd)
self.displayLCD.setLayout(layout)
def addVictoryOrLosses(self):
clickedButton = self.sender()
clickedOperator = clickedButton.text()
operand = float(1)
if clickedOperator == "Victory":
self.numVictory = self.numVictory + 1
self.victoryLcd.display(str(self.numVictory))
if clickedOperator == "DV":
self.numVictory = self.numVictory - 1
self.victoryLcd.display(str(self.numVictory))
if clickedOperator == "Losses":
self.numLosses = self.numLosses + 1
self.lossesLcd.display(str(self.numLosses))
if clickedOperator == "DL":
self.numLosses = self.numLosses - 1
self.lossesLcd.display(str(self.numLosses))
self.calculateAverage()
def calculateAverage(self):
total = self.numVictory + self.numLosses
# self.progressBar.setValue((int(self.numVictory / total * 100)))
self.progressBar.setValue(100)
# self.victoryLcdAv.display(str(int(self.numVictory / total * 100)))
# self.lossesLcdAv.display(str(int(self.numLosses / total * 100)))
def createButton(self, text, op, member):
button = Button(text,op)
button.clicked.connect(member)
return button
class OverWatch(QWidget):
update_sig = pyqtSignal(str)
def __init__(self):
super().__init__()
self.timer = QTimer()
self.timer.timeout.connect(self.collDat)
self.timer.start(2000)
self.collectData = DataCollect(self.update_sig)
self.update_sig.connect(self.update)
self.inrec = []
self.dsb1 = []
self.dsb2 = []
self.dsb3 = []
self.initUI()
def initUI(self):
hbox = QHBoxLayout()
# tH is the house temperature panel
tH = QFrame(self)
tH.setFrameShape(QFrame.StyledPanel)
tHvbox = QGridLayout()
tHvbox.addWidget(QLabel('Inside'), 1, 1, 1, 2)
tHvbox.addWidget(QLabel('Outside'), 1, 3, 1, 2)
tHvbox.addWidget(QLabel('Temp:'), 2, 0)
tHvbox.addWidget(QLabel('C'), 2, 2)
tHvbox.addWidget(QLabel('C'), 2, 4)
tHvbox.addWidget(QLabel('Humidity:'), 3, 0)
tHvbox.addWidget(QLabel('%'), 3, 2)
tHvbox.addWidget(QLabel('%'), 3, 4)
self.outTemp = QLCDNumber()
self.inTemp = QLCDNumber()
self.outHD = QLCDNumber()
self.inHD = QLCDNumber()
# get the palette
palette = self.inTemp.palette()
# palette.setColor(palette.Window, QtGui.QColor(255, 0, 0))
palette.setColor(palette.Light, QtGui.QColor(0, 0, 0))
palette.setColor(palette.Dark, QtGui.QColor(0, 0, 0))
self.inTemp.setPalette(palette)
self.outTemp.setPalette(palette)
self.inHD.setPalette(palette)
self.outHD.setPalette(palette)
tHvbox.addWidget(self.outTemp, 2, 3, 1, 1)
tHvbox.addWidget(self.inTemp, 2, 1, 1, 1)
tHvbox.addWidget(self.outHD, 3, 3, 1, 1)
tHvbox.addWidget(self.inHD, 3, 1, 1, 1)
self.tPlot = PlotWidget()
tHvbox.addWidget(self.tPlot, 4, 0, 4, 5)
self.weekbt = QPushButton('Week')
self.monthbt = QPushButton('Month')
tHvbox.addWidget(self.weekbt, 8, 0)
tHvbox.addWidget(self.monthbt, 8, 1)
self.pBar = QProgressBar()
self.pBar.setOrientation(Qt.Vertical)
tHvbox.addWidget(self.pBar, 4, 6)
self.pBar.setRange(950, 1050)
tH.setLayout(tHvbox)
tr = QFrame(self)
tr.setFrameShape(QFrame.StyledPanel)
bt = QFrame(self)
bt.setFrameShape(QFrame.StyledPanel)
split1 = QSplitter(Qt.Horizontal)
split1.addWidget(bt)
split1.addWidget(tr)
split2 = QSplitter(Qt.Vertical)
split2.addWidget(tH)
split2.addWidget(split1)
hbox.addWidget(split2)
self.tPlot.plot(self.inrec, pen=None, symbol='x')
self.setLayout(hbox)
self.setGeometry(300, 300, 800, 600)
self.setWindowTitle('OverWatch')
self.show()
self.collDat()
def collDat(self):
""" collect values """
self.collectData.start()
def update(self, dat):
""" Update the plot """
data = dict([[v.split(':')[0], float(v.split(':')[1])]
for v in dat.split(',')])
self.inTemp.display(data['InTemp'])
self.outTemp.display(data['DSB1'])
self.inHD.display(data['InHD'])
self.outHD.display(data['DSB2'])
self.pBar.setValue(int(data['Press']) * 10)
self.inrec.append(data['InTemp'])
self.dsb1.append(data['DSB1'])
self.dsb2.append(data['DSB2'])
self.dsb3.append(data['DSB3'])
self.tPlot.plot(self.inrec, symbol='x')
self.tPlot.plot(self.dsb1, symbol='o')
self.tPlot.plot(self.dsb2, symbol='o')
self.tPlot.plot(self.dsb3, symbol='o')
class RunningCueWidget(QWidget):
def __init__(self, cue, **kwargs):
super().__init__(**kwargs)
self.setGeometry(0, 0, self.parent().viewport().width(), 80)
self.setFocusPolicy(Qt.NoFocus)
self.setLayout(QHBoxLayout(self))
self.layout().setContentsMargins(0, 0, 0, 1)
self._accurate_time = False
self.cue = cue
self.cue_time = CueTime(cue)
self.cue_time.notify.connect(self._time_updated, Connection.QtQueued)
# Use this to avoid transparent background
self.gridLayoutWidget = QWidget(self)
self.gridLayout = QGridLayout(self.gridLayoutWidget)
self.gridLayout.setContentsMargins(3, 3, 3, 3)
self.gridLayout.setSpacing(2)
self.layout().addWidget(self.gridLayoutWidget)
self.nameLabel = QLabel(self.gridLayoutWidget)
self.nameLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.nameLabel.setText(cue.name)
self.nameLabel.setToolTip(cue.name)
self.gridLayout.addWidget(self.nameLabel, 0, 0, 1, 2)
self.controlButtons = CueControlButtons(parent=self.gridLayoutWidget)
self.gridLayout.addWidget(self.controlButtons, 1, 0)
if CueAction.Stop in cue.CueActions:
self.controlButtons.stopButton.clicked.connect(self._stop)
else:
self.controlButtons.stopButton.setEnabled(False)
if CueAction.Pause in cue.CueActions:
self.controlButtons.pauseButton.clicked.connect(self._pause)
self.controlButtons.startButton.clicked.connect(self._resume)
else:
self.controlButtons.pauseButton.setEnabled(False)
self.controlButtons.startButton.setEnabled(False)
if CueAction.FadeIn in cue.CueActions:
self.controlButtons.fadeInButton.clicked.connect(self._fadein)
else:
self.controlButtons.fadeInButton.setEnabled(False)
if CueAction.FadeOut in cue.CueActions:
self.controlButtons.fadeOutButton.clicked.connect(self._fadeout)
else:
self.controlButtons.fadeOutButton.setEnabled(False)
if CueAction.Interrupt in cue.CueActions:
self.controlButtons.interruptButton.clicked.connect(
self._interrupt)
else:
self.controlButtons.interruptButton.setEnabled(False)
self.timeDisplay = QLCDNumber(self.gridLayoutWidget)
self.timeDisplay.setStyleSheet('background-color: transparent')
self.timeDisplay.setSegmentStyle(QLCDNumber.Flat)
self.timeDisplay.setDigitCount(8)
self.timeDisplay.display(strtime(cue.duration))
self.gridLayout.addWidget(self.timeDisplay, 1, 1)
self.gridLayout.setRowStretch(0, 1)
self.gridLayout.setRowStretch(1, 3)
self.gridLayout.setColumnStretch(0, 7)
self.gridLayout.setColumnStretch(1, 5)
cue.changed('name').connect(self.name_changed, Connection.QtQueued)
cue.started.connect(self.controlButtons.pauseMode, Connection.QtQueued)
cue.paused.connect(self.controlButtons.startMode, Connection.QtQueued)
# Fade enter/exit
cue.fadein_start.connect(self.enter_fadein, Connection.QtQueued)
cue.fadein_end.connect(self.exit_fade, Connection.QtQueued)
cue.fadeout_start.connect(self.enter_fadeout, Connection.QtQueued)
cue.fadeout_end.connect(self.exit_fade, Connection.QtQueued)
def enter_fadein(self):
p = self.timeDisplay.palette()
p.setColor(p.Text, QColor(0, 255, 0))
self.timeDisplay.setPalette(p)
def enter_fadeout(self):
p = self.timeDisplay.palette()
p.setColor(p.Text, QColor(255, 50, 50))
self.timeDisplay.setPalette(p)
def exit_fade(self):
self.timeDisplay.setPalette(self.palette())
def name_changed(self, name):
self.nameLabel.setText(name)
self.nameLabel.setToolTip(name)
def set_accurate_time(self, enable):
self._accurate_time = enable
def _time_updated(self, time):
if not self.visibleRegion().isEmpty():
# If the given value is the duration or < 0 set the time to 0
if time == self.cue.duration or time < 0:
time = 0
self._update_timers(time)
def _update_timers(self, time):
self.timeDisplay.display(
strtime(self.cue.duration - time, accurate=self._accurate_time))
def _pause(self):
self.cue.pause(fade=config['ListLayout'].getboolean('PauseCueFade'))
def _resume(self):
self.cue.restart(fade=config['ListLayout'].getboolean('ResumeCueFade'))
def _stop(self):
self.cue.stop(fade=config['ListLayout'].getboolean('StopCueFade'))
def _interrupt(self):
self.cue.interrupt(
fade=config['ListLayout'].getboolean('InterruptCueFade'))
def _fadeout(self):
self.cue.execute(CueAction.FadeOut)
def _fadein(self):
self.cue.execute(CueAction.FadeIn)
class CueWidget(QWidget):
ICON_SIZE = 14
SLIDER_RANGE = 1000
context_menu_request = pyqtSignal(object, QPoint)
edit_request = pyqtSignal(object)
cue_executed = pyqtSignal(object)
def __init__(self, cue, **kwargs):
super().__init__(**kwargs)
self.cue = None
self._selected = False
self._accurate_timing = False
self._show_dbmeter = False
self._show_volume = False
self._countdown_mode = True
self._dbmeter_element = None
self._fade_element = None
self._volume_element = None
self.setAttribute(Qt.WA_TranslucentBackground)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(2)
self.layout().setColumnStretch(0, 6)
self.layout().setRowStretch(0, 4)
self.nameButton = QClickLabel(self)
self.nameButton.setObjectName('ButtonCueWidget')
self.nameButton.setWordWrap(True)
self.nameButton.setAlignment(Qt.AlignCenter)
self.nameButton.setFocusPolicy(Qt.NoFocus)
self.nameButton.clicked.connect(self._clicked)
self.nameButton.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.layout().addWidget(self.nameButton, 0, 0)
self.statusIcon = QLabel(self.nameButton)
self.statusIcon.setStyleSheet('background-color: transparent')
self.statusIcon.setPixmap(
pixmap_from_icon('led-off', CueWidget.ICON_SIZE))
self.seekSlider = QClickSlider(self.nameButton)
self.seekSlider.setOrientation(Qt.Horizontal)
self.seekSlider.setFocusPolicy(Qt.NoFocus)
self.seekSlider.setVisible(False)
self.volumeSlider = QClickSlider(self.nameButton)
self.volumeSlider.setObjectName('VolumeSlider')
self.volumeSlider.setOrientation(Qt.Vertical)
self.volumeSlider.setFocusPolicy(Qt.NoFocus)
self.volumeSlider.setRange(0, CueWidget.SLIDER_RANGE)
self.volumeSlider.setPageStep(10)
self.volumeSlider.valueChanged.connect(
self._change_volume, Qt.DirectConnection)
self.volumeSlider.setVisible(False)
self.dbMeter = QDbMeter(self)
self.dbMeter.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.dbMeter.setVisible(False)
self.timeBar = QProgressBar(self)
self.timeBar.setTextVisible(False)
self.timeBar.setLayout(QHBoxLayout())
self.timeBar.layout().setContentsMargins(0, 0, 0, 0)
self.timeDisplay = QLCDNumber(self.timeBar)
self.timeDisplay.setStyleSheet('background-color: transparent')
self.timeDisplay.setSegmentStyle(QLCDNumber.Flat)
self.timeDisplay.setDigitCount(8)
self.timeDisplay.display('00:00:00')
self.timeBar.layout().addWidget(self.timeDisplay)
self.timeBar.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.timeBar.setVisible(False)
self._set_cue(cue)
@property
def selected(self):
return self._selected
@selected.setter
def selected(self, value):
self._selected = value
self._update_style(self.cue.stylesheet)
def contextMenuEvent(self, event):
self.context_menu_request.emit(self, event.globalPos())
def mouseMoveEvent(self, event):
if (event.buttons() == Qt.LeftButton and
(event.modifiers() == Qt.ControlModifier or
event.modifiers() == Qt.ShiftModifier)):
mime_data = QMimeData()
mime_data.setText(PageWidget.DRAG_MAGIC)
drag = QDrag(self)
drag.setMimeData(mime_data)
drag.setPixmap(self.grab(self.rect()))
if event.modifiers() == Qt.ControlModifier:
drag.exec_(Qt.MoveAction)
else:
drag.exec_(Qt.CopyAction)
event.accept()
else:
event.ignore()
def set_countdown_mode(self, mode):
self._countdown_mode = mode
self._update_time(self.cue.current_time())
def set_accurate_timing(self, enable):
self._accurate_timing = enable
if self.cue.state & CueState.Pause:
self._update_time(self.cue.current_time(), True)
elif not self.cue.state & CueState.Running:
self._update_duration(self.cue.duration)
def show_seek_slider(self, visible):
if isinstance(self.cue, MediaCue):
self.seekSlider.setVisible(visible)
self.update()
def show_dbmeters(self, visible):
if isinstance(self.cue, MediaCue):
self._show_dbmeter = visible
if self._dbmeter_element is not None:
self._dbmeter_element.level_ready.disconnect(self.dbMeter.plot)
self._dbmeter_element = None
if visible:
self._dbmeter_element = self.cue.media.element('DbMeter')
if self._dbmeter_element is not None:
self._dbmeter_element.level_ready.connect(self.dbMeter.plot)
self.layout().addWidget(self.dbMeter, 0, 2)
self.layout().setColumnStretch(2, 1)
self.dbMeter.show()
else:
self.layout().removeWidget(self.dbMeter)
self.layout().setColumnStretch(2, 0)
self.dbMeter.hide()
self.update()
def show_volume_slider(self, visible):
if isinstance(self.cue, MediaCue):
self._show_volume = visible
if self._volume_element is not None:
self._volume_element.changed('volume').disconnect(
self.reset_volume)
self._volume_element = None
if visible:
self.volumeSlider.setEnabled(self.cue.state & CueState.Running)
self._volume_element = self.cue.media.element('Volume')
if self._volume_element is not None:
self.reset_volume()
self._volume_element.changed('volume').connect(
self.reset_volume,
Connection.QtQueued)
self.layout().addWidget(self.volumeSlider, 0, 1)
self.layout().setColumnStretch(1, 1)
self.volumeSlider.show()
else:
self.layout().removeWidget(self.volumeSlider)
self.layout().setColumnStretch(1, 0)
self.volumeSlider.hide()
self.update()
def reset_volume(self):
if self._volume_element is not None:
self.volumeSlider.setValue(round(fader_to_slider(
self._volume_element.volume) * CueWidget.SLIDER_RANGE))
def _set_cue(self, cue):
self.cue = cue
# Cue properties changes
self.cue.changed('name').connect(
self._update_name, Connection.QtQueued)
self.cue.changed('stylesheet').connect(
self._update_style, Connection.QtQueued)
self.cue.changed('duration').connect(
self._update_duration, Connection.QtQueued)
self.cue.changed('description').connect(
self._update_description, Connection.QtQueued)
# Fade enter/exit
self.cue.fadein_start.connect(self._enter_fadein, Connection.QtQueued)
self.cue.fadein_end.connect(self._exit_fade, Connection.QtQueued)
self.cue.fadeout_start.connect(self._enter_fadeout, Connection.QtQueued)
self.cue.fadeout_end.connect(self._exit_fade, Connection.QtQueued)
# Cue status changed
self.cue.interrupted.connect(self._status_stopped, Connection.QtQueued)
self.cue.started.connect(self._status_playing, Connection.QtQueued)
self.cue.stopped.connect(self._status_stopped, Connection.QtQueued)
self.cue.paused.connect(self._status_paused, Connection.QtQueued)
self.cue.error.connect(self._status_error, Connection.QtQueued)
self.cue.end.connect(self._status_stopped, Connection.QtQueued)
# DbMeter connections
if isinstance(cue, MediaCue):
self.cue.media.elements_changed.connect(
self._media_updated, Connection.QtQueued)
self.cue.paused.connect(self.dbMeter.reset, Connection.QtQueued)
self.cue.stopped.connect(self.dbMeter.reset, Connection.QtQueued)
self.cue.end.connect(self.dbMeter.reset, Connection.QtQueued)
self.cue.error.connect(self.dbMeter.reset, Connection.QtQueued)
self.seekSlider.sliderMoved.connect(self.cue.media.seek)
self.seekSlider.sliderJumped.connect(self.cue.media.seek)
self._cue_time = CueTime(self.cue)
self._cue_time.notify.connect(self._update_time, Connection.QtQueued)
self._update_name(cue.name)
self._update_style(cue.stylesheet)
self._update_duration(self.cue.duration)
def _media_updated(self):
self.show_dbmeters(self._show_dbmeter)
self.show_volume_slider(self._show_volume)
def _update_name(self, name):
self.nameButton.setText(name)
def _update_description(self, description):
self.nameButton.setToolTip(description)
def _change_volume(self, new_volume):
self._volume_element.current_volume = slider_to_fader(
new_volume / CueWidget.SLIDER_RANGE)
def _clicked(self, event):
if not (self.seekSlider.geometry().contains(event.pos()) and
self.seekSlider.isVisible()):
if event.button() != Qt.RightButton:
if event.modifiers() == Qt.ShiftModifier:
self.edit_request.emit(self.cue)
elif event.modifiers() == Qt.ControlModifier:
self.selected = not self.selected
else:
self.cue_executed.emit(self.cue)
self.cue.execute()
def _update_style(self, stylesheet):
stylesheet += 'text-decoration: underline;' if self.selected else ''
self.nameButton.setStyleSheet(stylesheet)
def _enter_fadein(self):
p = self.timeDisplay.palette()
p.setColor(p.WindowText, QColor(0, 255, 0))
self.timeDisplay.setPalette(p)
def _enter_fadeout(self):
p = self.timeDisplay.palette()
p.setColor(p.WindowText, QColor(255, 50, 50))
self.timeDisplay.setPalette(p)
def _exit_fade(self):
self.timeDisplay.setPalette(self.timeBar.palette())
def _status_stopped(self):
self.statusIcon.setPixmap(
pixmap_from_icon('led-off', CueWidget.ICON_SIZE))
self.volumeSlider.setEnabled(False)
self._update_time(0, True)
self.reset_volume()
def _status_playing(self):
self.statusIcon.setPixmap(
pixmap_from_icon('led-running', CueWidget.ICON_SIZE))
self.volumeSlider.setEnabled(True)
def _status_paused(self):
self.statusIcon.setPixmap(
pixmap_from_icon('led-pause', CueWidget.ICON_SIZE))
self.volumeSlider.setEnabled(False)
def _status_error(self, cue, error, details):
self.statusIcon.setPixmap(
pixmap_from_icon('led-error', CueWidget.ICON_SIZE))
self.volumeSlider.setEnabled(False)
self.reset_volume()
QDetailedMessageBox.dcritical(self.cue.name, error, details)
def _update_duration(self, duration):
# Update the maximum values of seek-slider and time progress-bar
if duration > 0:
if not self.timeBar.isVisible():
self.layout().addWidget(self.timeBar, 1, 0, 1, 3)
self.layout().setRowStretch(1, 1)
self.timeBar.show()
self.timeBar.setMaximum(duration)
self.seekSlider.setMaximum(duration)
else:
self.timeBar.hide()
self.layout().setRowStretch(1, 0)
if not self.cue.state & CueState.Running:
self._update_time(duration, True)
def _update_time(self, time, ignore_visibility=False):
if ignore_visibility or not self.visibleRegion().isEmpty():
# If the given value is the duration or < 0 set the time to 0
if time == self.cue.duration or time < 0:
time = 0
# Set the value the seek slider
self.seekSlider.setValue(time)
# If in count-down mode the widget will show the remaining time
if self._countdown_mode:
time = self.cue.duration - time
# Set the value of the timer progress-bar
if self.cue.duration > 0:
self.timeBar.setValue(time)
# Show the time in the widget
self.timeDisplay.display(
strtime(time, accurate=self._accurate_timing))
def resizeEvent(self, event):
self.update()
def update(self):
super().update()
self.layout().activate()
s_width = self.nameButton.width() - 8
s_height = self.seekSlider.height()
s_ypos = self.nameButton.height() - s_height
self.seekSlider.setGeometry(4, s_ypos, s_width, s_height)
self.statusIcon.setGeometry(4, 4,
CueWidget.ICON_SIZE,
CueWidget.ICON_SIZE)
class PlayingMediaWidget(QWidget):
def __init__(self, cue, **kwargs):
super().__init__(**kwargs)
self.setFocusPolicy(Qt.NoFocus)
self.setGeometry(0, 0, self.parent().viewport().width(), 110)
self.cue = cue
self.cue_time = CueTime(cue)
self.cue_time.notify.connect(self._time_updated, Connection.QtQueued)
self._dbmeter_element = None
self._accurate_time = False
self.gridLayoutWidget = QWidget(self)
self.gridLayoutWidget.setGeometry(self.geometry())
self.gridLayout = QGridLayout(self.gridLayoutWidget)
self.gridLayout.setContentsMargins(3, 3, 3, 3)
self.gridLayout.setSpacing(2)
self.nameLabel = QLabel(self.gridLayoutWidget)
self.nameLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.nameLabel.setText(cue.name)
self.nameLabel.setToolTip(cue.name)
self.gridLayout.addWidget(self.nameLabel, 0, 0, 1, 2)
self.controlButtons = CueControlButtons(parent=self.gridLayoutWidget)
self.controlButtons.stopButton.clicked.connect(self._stop)
self.controlButtons.pauseButton.clicked.connect(self._pause)
self.controlButtons.startButton.clicked.connect(self._start)
self.controlButtons.fadeInButton.clicked.connect(self._fadein)
self.controlButtons.fadeOutButton.clicked.connect(self._fadeout)
self.controlButtons.interruptButton.clicked.connect(self._interrupt)
self.gridLayout.addWidget(self.controlButtons, 1, 0)
self.timeDisplay = QLCDNumber(self.gridLayoutWidget)
self.timeDisplay.setStyleSheet('background-color: transparent')
self.timeDisplay.setSegmentStyle(QLCDNumber.Flat)
self.timeDisplay.setDigitCount(8)
self.timeDisplay.display(strtime(cue.media.duration))
self.gridLayout.addWidget(self.timeDisplay, 1, 1)
self.seekSlider = QClickSlider(self.gridLayoutWidget)
self.seekSlider.setOrientation(Qt.Horizontal)
self.seekSlider.setRange(0, cue.media.duration)
self.seekSlider.setFocusPolicy(Qt.NoFocus)
self.seekSlider.sliderMoved.connect(self._seek)
self.seekSlider.sliderJumped.connect(self._seek)
self.seekSlider.setVisible(False)
self.dbmeter = QDbMeter(self.gridLayoutWidget)
self.dbmeter.setVisible(False)
self.gridLayout.setRowStretch(0, 1)
self.gridLayout.setRowStretch(1, 3)
self.gridLayout.setColumnStretch(0, 7)
self.gridLayout.setColumnStretch(1, 5)
cue.changed('name').connect(self.name_changed)
cue.changed('duration').connect(self.update_duration)
cue.started.connect(self.controlButtons.pauseMode)
cue.paused.connect(self.controlButtons.startMode)
# Fade enter/exit
cue.fadein_start.connect(self.enter_fadein, Connection.QtQueued)
cue.fadein_end.connect(self.exit_fade, Connection.QtQueued)
cue.fadeout_start.connect(self.enter_fadeout, Connection.QtQueued)
cue.fadeout_end.connect(self.exit_fade, Connection.QtQueued)
def enter_fadein(self):
p = self.timeDisplay.palette()
p.setColor(p.Text, QColor(0, 255, 0))
self.timeDisplay.setPalette(p)
def enter_fadeout(self):
p = self.timeDisplay.palette()
p.setColor(p.Text, QColor(255, 50, 50))
self.timeDisplay.setPalette(p)
def exit_fade(self):
self.timeDisplay.setPalette(self.palette())
def name_changed(self, name):
self.nameLabel.setText(name)
self.nameLabel.setToolTip(name)
def set_accurate_time(self, enable):
self._accurate_time = enable
def set_seek_visible(self, visible):
if visible and not self.seekSlider.isVisible():
self.gridLayout.addWidget(self.seekSlider, 2, 0, 1, 2)
self.gridLayout.setRowStretch(2, 1)
elif not visible and self.seekSlider.isVisible():
self.gridLayout.removeWidget(self.seekSlider)
self.gridLayout.setRowStretch(2, 0)
self.seekSlider.setVisible(visible)
def set_dbmeter_visible(self, visible):
if self._dbmeter_element is not None:
self._dbmeter_element.level_ready.disconnect(self.dbmeter.plot)
self._dbmeter_element = None
if visible:
self._dbmeter_element = self.cue.media.element('DbMeter')
if self._dbmeter_element is not None:
self._dbmeter_element.level_ready.connect(self.dbmeter.plot)
# Add/Remove the QDbMeter in the layout
if visible and not self.dbmeter.isVisible():
self.gridLayout.addWidget(self.dbmeter, 0, 2, 3, 1)
self.gridLayout.setColumnStretch(2, 1)
elif not visible and self.dbmeter.isVisible():
self.gridLayout.removeWidget(self.dbmeter)
self.gridLayout.setColumnStretch(2, 0)
self.dbmeter.setVisible(visible)
def _time_updated(self, time):
if not self.visibleRegion().isEmpty():
# If the given value is the duration or < 0 set the time to 0
if time == self.cue.media.duration or time < 0:
time = 0
# Set the value the seek slider
self.seekSlider.setValue(time)
# Show the time in the widget
self.timeDisplay.display(
strtime(self.cue.media.duration - time,
accurate=self._accurate_time))
def update_duration(self, duration):
self.seekSlider.setMaximum(duration)
def _pause(self):
self.cue.pause(fade=config['ListLayout'].getboolean('PauseCueFade'))
def _start(self):
self.cue.start(fade=config['ListLayout'].getboolean('RestartCueFade'))
def _stop(self):
self.cue.stop(fade=config['ListLayout'].getboolean('StopCueFade'))
def _interrupt(self):
self.cue.interrupt(
fade=config['ListLayout'].getboolean('InterruptCueFade'))
def _fadeout(self):
self.cue.fadeout(config['ListLayout'].getfloat('CueFadeDuration'),
FadeOutType[config['ListLayout'].get('CueFadeType')])
def _fadein(self):
self.cue.fadein(config['ListLayout'].getfloat('CueFadeDuration'),
FadeInType[config['ListLayout'].get('CueFadeType')])
def _seek(self, position):
self.cue.media.seek(position)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.left = 10
self.top = 10
self.title = 'Rodent Vitals Monitoring Software'
self.width = 700
self.height = 500
self.model = []
#Matplotlib graphs
self.lbl = PlotCanvas()
#LCDs for numerical vital monitoring
self.lcd_BR = QLCDNumber(self)
self.lcd_HR = QLCDNumber(self)
self.lcd_TEMP = QLCDNumber(self)
self.control = PID()
self.control.setPoint(set_point=35)
print("Initializing MainWindow")
if not os.path.isdir(
'/home/pi/Documents/MouseVitalMonitoring/Voltage Data'):
os.mkdir('/home/pi/Documents/MouseVitalMonitoring/Voltage Data')
if not os.path.isdir(
'/home/pi/Documents/MouseVitalMonitoring/Vital Data'):
os.mkdir('/home/pi/Documents/MouseVitalMonitoring/Vital Data')
GPIO.output(33, 1)
self.initUI()
def initUI(self):
# Set Main Window Geometry and Title
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowTitle(self.title)
#LCDs for numerical vital monitoring
self.lcd_BR.setSegmentStyle(QLCDNumber.Flat)
paletteBR = self.lcd_BR.palette()
paletteBR.setColor(paletteBR.WindowText, QtGui.QColor(85, 85, 240))
self.lcd_BR.setPalette(paletteBR)
self.lcd_BR.display(58)
self.lcd_HR.setSegmentStyle(QLCDNumber.Flat)
paletteHR = self.lcd_HR.palette()
paletteHR.setColor(paletteHR.WindowText, QtGui.QColor(85, 255, 85))
self.lcd_HR.setPalette(paletteHR)
self.lcd_HR.display(287)
self.lcd_TEMP.setSegmentStyle(QLCDNumber.Flat)
paletteTEMP = self.lcd_TEMP.palette()
paletteTEMP.setColor(paletteTEMP.WindowText, QtGui.QColor(255, 85, 85))
self.lcd_TEMP.setPalette(paletteTEMP)
self.lcd_TEMP.display(17)
#Labels for vitals
BRlabel = QLabel('Breathing Rate (breaths/min)')
HRlabel = QLabel('Heart Rate (beats/min)')
TEMPlabel = QLabel('Subject Temperature (Celsius)')
#Setting up Frame Layout
wid = QWidget(self)
self.setCentralWidget(wid)
box = QHBoxLayout(self)
#Boxes for LCD vitals
box_HRLCD = QHBoxLayout(self)
box_BRLCD = QHBoxLayout(self)
box_TEMPLCD = QHBoxLayout(self)
box_HRLCD.addWidget(self.lcd_HR)
box_BRLCD.addWidget(self.lcd_BR)
box_TEMPLCD.addWidget(self.lcd_TEMP)
box_graph = QHBoxLayout(self)
box_graph.addWidget(self.lbl)
left = QFrame(self)
left.setFrameShape(QFrame.Box)
topright = QFrame(self)
topright.setFrameShape(QFrame.Box)
middleright = QFrame(self)
middleright.setFrameShape(QFrame.Box)
bottomright = QFrame(self)
bottomright.setFrameShape(QFrame.Box)
left.setLayout(box_graph)
topright.setLayout(box_HRLCD)
middleright.setLayout(box_BRLCD)
bottomright.setLayout(box_TEMPLCD)
# Splitting frames and adding layout to window
splitter1 = QSplitter(Qt.Vertical)
splitter1.addWidget(topright)
splitter1.addWidget(middleright)
splitter2 = QSplitter(Qt.Vertical)
splitter2.addWidget(splitter1)
splitter2.addWidget(bottomright)
splitter3 = QSplitter(Qt.Horizontal)
splitter3.addWidget(left)
splitter3.addWidget(splitter2)
box.addWidget(splitter3)
wid.setLayout(box)
menubar = self.menuBar()
fileMenu = menubar.addMenu('File')
recordingMenu = menubar.addMenu('Recording Options')
self.statusbar = self.statusBar()
self.statusbar.showMessage('Ready')
changeWindowSize = QAction('Change Window Size', self)
changeWindowSize.triggered.connect(lambda: self.windowSizeInput())
resetWindow = QAction('Reset Window to Present', self)
resetWindow.triggered.connect(lambda: self.windowReset())
recordingMenu.addAction(changeWindowSize)
recordingMenu.addAction(resetWindow)
fileMenu.addAction(newAct)
fileMenu.addMenu(impMenu)
fileMenu.addMenu(expMenu)
fileMenu.addMenu(recordingMenu)
#Making the status bar
viewStatAct = QAction('View statusbar', self, checkable=True)
viewStatAct.setStatusTip('View statusbar')
viewStatAct.setChecked(True)
viewStatAct.triggered.connect(self.toggleMenu)
viewMenu.addAction(viewStatAct)
#Making the toolbar
exitAct = QAction(QIcon('cancel-512.png'), 'Exit', self)
exitAct.triggered.connect(lambda: self.Close())
exportAct = QAction(QIcon('200px-Love_Heart_SVG.svg.png'),
'Export Vitals', self)
exportAct.triggered.connect(lambda: self.writeRealCsv())
exportRawAct = QAction(QIcon('LVtemp0360812798988.png'),
'Export Raw Data', self)
exportRawAct.triggered.connect(lambda: self.writeVoltageCsv())
startAct = QAction(QIcon('graphs icon.png'), 'Start Graphs', self)
startAct.triggered.connect(
lambda: self.lbl.plot(lcd_HR=self.lcd_HR,
lcd_BR=self.lcd_BR,
lcd_TEMP=self.lcd_TEMP,
control=self.control))
heatAct = QAction(QIcon('temperature icon.png'), 'Start Temperature',
self)
heatAct.triggered.connect(lambda: self.tempControl())
vitalsAct = QAction(QIcon('vitals icon.png'), 'Start Recording', self)
vitalsAct.triggered.connect(lambda: self.startVitals())
self.toolbar = self.addToolBar('Exit')
self.toolbar = self.addToolBar('Save')
self.toolbar = self.addToolBar('Export')
self.toolbar = self.addToolBar('Export')
self.toolbar.addAction(exitAct)
self.toolbar.addAction(startAct)
self.toolbar.addAction(heatAct)
self.toolbar.addAction(vitalsAct)
self.toolbar.addAction(exportRawAct)
self.toolbar.addAction(exportAct)
print("Creating toolbar menus and displaying window")
#Setting window size and showing
self.show()
def Close(self):
today = dt.now()
today = today.strftime("%Y-%m-%d-%H%M%S")
#sub.call(["git", "add", "."])
#sub.call(["git", "commit", "-m", "Data Updates"])
#sub.call(["git", "push"])
sys.exit()
def tempControl(self):
while True:
current_value = ConvertTemp(ReadChannel(2))
print(current_value)
newvalue = self.control.update(current_value=current_value)
print(newvalue)
if newvalue > current_value:
direction = 1
else:
direction = 0
GPIO.output(33, 1)
GPIO.output(29, direction)
time.sleep(2)
def startVitals(self):
#self.tempControl()
self.lbl.plot(lcd_HR=self.lcd_HR,
lcd_BR=self.lcd_BR,
lcd_TEMP=self.lcd_TEMP,
control=self.control)
def windowSizeInput(self):
# open a smaller window with a numerical input option
num, ok = QInputDialog.getInt(self, "Window Dialog", "enter a number")
if ok:
newSize = num
self.lbl.plot(window=newSize * 10000, start=self.lbl.current_time)
def windowReset(self):
self.lbl.plot(window=self.lbl.window, start=self.lbl.current_time)
def toggleMenu(self, state):
if state:
self.statusbar.show()
else:
self.statusbar.hide()
def writeVoltageCsv(self):
today = dt.now()
today = today.strftime("%Y-%m-%d-%H%M%S")
workingdir = os.getcwd() + '/Voltage Data/'
volt_hr = np.array(self.lbl.hr_volt)
volt_br = np.array(self.lbl.br_volt)
volt_temp = np.array(self.lbl.temp_volt)
len_x = len(time)
len_hr = len(volt_hr)
len_br = len(volt_br)
len_temp = len(volt_temp)
lengths = np.array([len_hr, len_br, len_temp])
x = min(int(s) for s in lengths)
time = time[0:(x - 1)]
volt_hr = volt_hr[0:(x - 1)]
volt_br = volt_br[0:(x - 1)]
volt_temp = volt_temp[0:(x - 1)]
fileName_volt = workingdir + 'Voltage_Data' + today + '.csv'
data = pd.DataFrame({
'Heart Rate (V)': volt_hr,
'Breathing Rate (V)': volt_br,
'Temperature (V)': volt_temp
})
data.to_csv(fileName_volt, index=False)
def writeRealCsv(self):
today = dt.now()
today = today.strftime("%Y-%m-%d-%H%M%S")
workingdir = os.getcwd() + '/Vital Data/'
real_hr = np.array(self.lbl.hr_data)
real_br = np.array(self.lbl.br_data)
real_temp = np.array(self.lbl.temp_data)
hr_nan = np.isnan(real_hr)
br_nan = np.isnan(real_br)
temp_nan = np.isnan(real_temp)
real_hr[hr_nan] = 0
real_br[br_nan] = 0
real_temp[temp_nan] = 0
fileName_real = workingdir + 'Vital_Data' + today + '.csv'
data = pd.DataFrame({
'Heart Rate (bpm)': real_hr,
'Breathing Rate (bpm)': real_temp,
'Temperature (F)': real_temp
})
data.to_csv(fileName_real, index=False)
def initUI(self):
#Layout: You need to create a QWidget and set it as the central widget on the QMainWindow and assign the QLayout to th
#wid = QWidget(self)
self.setCentralWidget(self.wid)
QToolTip.setFont(QFont('SansSerif', 10))
#labels
AcName = QLabel('Action Name', self)
AcNameEdit = QLineEdit()
self.ac_name_obj = AcNameEdit
AcType = QLabel('Action Type', self)
AcTypes = ['PUMP', 'VALVE ACTION']
# Create and fill the combo box to choose the tyoe of action
AcTypeBox = QComboBox()
AcTypeBox.addItems(AcTypes)
self.ac_type_obj = AcTypeBox
#minutes
AcDurationMin = QLabel('Action Duration [min]', self)
AcDurationLCDMin = QLCDNumber()
AcDurationLCDMin.setSegmentStyle(QLCDNumber.Flat)
#change color of LCD, not working
palette = QPalette()
palette.setColor(QPalette.Background, QColor(170, 255, 0))
palette.setColor(QPalette.Base, QColor(170, 255, 0))
palette.setColor(QPalette.AlternateBase, QColor(170, 255, 0))
AcDurationLCDMin.setPalette(palette)
sliderAcDurMin = QSlider(Qt.Horizontal, self)
sliderAcDurMin.setMaximum(60)
sliderAcDurMin.valueChanged.connect(AcDurationLCDMin.display)
self.ac_duration_min_obj = sliderAcDurMin
#seconds
AcDurationSec = QLabel('[sec]', self)
AcDurationLCDSec = QLCDNumber()
AcDurationLCDSec.setSegmentStyle(QLCDNumber.Flat)
sliderAcDurSec = QSlider(Qt.Horizontal, self)
sliderAcDurSec.setMaximum(60)
sliderAcDurSec.valueChanged.connect(AcDurationLCDSec.display)
self.ac_duration_sec_obj = sliderAcDurSec
#tStart
TStart = QLabel('Time Start [sec]', self)
TStartEdit = QLineEdit()
self.t_start_obj = TStartEdit
#valve options
"""IfValve = QLabel('If Action type is "Valve" ONLY, select options below. \n' 'Keep the Valve number at 0 if PUMPNG selected',self)
ValveOption = QLabel('Valve Option')
ValveOptions = ['NO VALVE','OPENING', 'CLOSING']
ValveOptionBox = QComboBox()
ValveOptionBox.addItems(ValveOptions)
self.valve_option_action_obj = ValveOptionBox
"""
ValveNumber = QLabel('Valve Number', self)
ValveNumberLCD = QLCDNumber()
ValveNumberLCD.setSegmentStyle(QLCDNumber.Flat)
sliderValveNumber = QSlider(Qt.Horizontal, self)
sliderValveNumber.setMaximum(24)
sliderValveNumber.valueChanged.connect(ValveNumberLCD.display)
self.valve_number_obj = sliderValveNumber
#Valve action list
AcList = QLabel('Action list', self)
AcListEdit = QTextEdit()
AcListEdit.autoFormatting()
self.actionDisplay = AcListEdit
#valve option button
Valvebtn = QPushButton('Add Action', self)
Valvebtn.clicked.connect(self.AddAction)
Valvebtn.resize(Valvebtn.sizeHint())
#chip bonding button
Bondingbtn = QPushButton('Chip Bonding', self)
Bondingbtn.clicked.connect(self.chip_bonding)
Bondingbtn.resize(Bondingbtn.sizeHint())
#bonding duration
BondDuration = QLabel('Bond Duration [h]', self)
BondDurationEdit = QLineEdit()
self.bond_duration_obj = BondDurationEdit
#quit button
qbtn = QPushButton('Quit',
self) #second parameter is the parent widget
qbtn.clicked.connect(self.closeEvent)
#qbtn.clicked.connect(QApplication.instance().quit)
#btn.setToolTip('This is a <b>QPushButton</b> widget') --> text when pointing at the button
qbtn.resize(qbtn.sizeHint()) #recommended size for the button
#qbtn.move(1600, 900) #position in absolute position
#next button
nextbtn = QPushButton('Next',
self) #second parameter is the parent widget
nextbtn.clicked.connect(self.GoToNext)
nextbtn.resize(nextbtn.sizeHint()) #recommended size for the butto
#grid Layout
grid = QGridLayout()
grid.addWidget(AcName, 1, 0)
grid.addWidget(AcNameEdit, 1, 1)
grid.addWidget(AcType, 2, 0)
grid.addWidget(AcTypeBox, 2, 1)
grid.addWidget(AcDurationMin, 3, 0)
grid.addWidget(AcDurationLCDMin, 3, 1)
grid.addWidget(sliderAcDurMin, 3, 2)
grid.addWidget(AcDurationSec, 3, 3)
grid.addWidget(AcDurationLCDSec, 3, 4)
grid.addWidget(sliderAcDurSec, 3, 5)
grid.addWidget(TStart, 4, 0)
grid.addWidget(TStartEdit, 4, 1)
#grid.addWidget(IfValve, 5, 0)
#grid.addWidget(ValveOption,6, 0 )
#grid.addWidget(ValveOptionBox, 6, 1)
grid.addWidget(ValveNumber, 6, 2)
grid.addWidget(ValveNumberLCD, 6, 3)
grid.addWidget(sliderValveNumber, 6, 4)
grid.addWidget(Bondingbtn, 8, 3)
grid.addWidget(BondDuration, 8, 1)
grid.addWidget(BondDurationEdit, 8, 2)
grid.addWidget(AcList, 9, 0)
grid.addWidget(AcListEdit, 9, 1, 1, 4)
grid.addWidget(Valvebtn, 7, 1)
grid.addWidget(qbtn, 11, 7)
grid.addWidget(nextbtn, 10, 1)
#print(sliderAcDur.value())
for i in range(0, 6):
grid.setColumnStretch(i, 1)
grid.setRowStretch(i, 1)
grid.setSpacing(1)
grid.setHorizontalSpacing(1)
grid.setVerticalSpacing(1)
self.wid.setLayout(grid)
#menu bar
exitAct = QAction(QIcon('exit.png'), '&Exit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(qApp.quit)
self.statusBar()
menubar = self.menuBar()
fileMenu = menubar.addMenu('File')
fileMenu.addAction(exitAct)
#submenu
impMenu = QMenu('Import', self)
impAct = QAction('Import mail', self)
impMenu.addAction(impAct)
newAct = QAction('New', self)
fileMenu.addAction(newAct)
fileMenu.addMenu(impMenu)
#window geometry
self.setGeometry(0, 0, 1800,
1000) # x start, y start, x length, y length
self.setWindowTitle('Micropump GUI _ Action')
class tiempoDigitalWidget(QWidget):
time = pyqtSignal()
def __init__(self, winParent, porcentaje):
super(tiempoDigitalWidget, self).__init__()
self.winParent = winParent
self.seconds = 900
self.pose3d = pose3d
self.porcentaje = porcentaje
self.show = False
self.MAX_PERCENT = 30
self.MAX_NOTA = 10
self.hLayout = QHBoxLayout()
tiempoLabel = QLabel("Tiempo")
self.lcd = QLCDNumber(self)
self.lcd.setMaximumSize(100, 50)
self.hLayout.addWidget(tiempoLabel, 0)
self.hLayout.addWidget(self.lcd, 1)
hSpacer = QSpacerItem(300, 30, QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.hLayout.addItem(hSpacer)
self.setLayout(self.hLayout)
timer = QTimer(self)
timer.start(1000)
timer.timeout.connect(self.printTime)
# get the palette
palette = self.lcd.palette()
# foreground color
palette.setColor(palette.WindowText, QColor(85, 85, 255))
# background color
palette.setColor(palette.Background, QColor(0, 170, 255))
# "light" border
palette.setColor(palette.Light, QColor(255, 0, 0))
# "dark" border
palette.setColor(palette.Dark, QColor(0, 255, 0))
# set the palette
self.lcd.setPalette(palette)
def showNota(self):
self.show = True
nota = self.testPorcentaje()
notaLabel = QLabel('Nota final: ' + str(nota))
self.hLayout.addWidget(notaLabel, 0)
self.setLayout(self.hLayout)
def printTime(self):
if self.seconds > 0:
self.seconds -= 1
else:
if not self.show:
self.showNota()
self.lcd.display(self.seconds)
def testPorcentaje(self):
pCasa = self.porcentaje.calculatePercentaje()
notaPorc = pCasa * self.MAX_NOTA / self.MAX_PERCENT
if pCasa > self.MAX_PERCENT:
notaPorc = 10
return notaPorc
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.left = 10
self.top = 10
self.title = 'Rodent Vitals Monitoring Software Demo'
self.width = 1200
self.height = 1200
self.model = []
#Matplotlib graphs
self.lbl = PlotCanvas()
#LCDs for numerical vital monitoring
self.lcd_BR = QLCDNumber(self)
self.lcd_HR = QLCDNumber(self)
self.lcd_TEMP = QLCDNumber(self)
self.initUI()
def initUI(self):
# Set Main Window Geometry and Title
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowTitle(self.title)
#LCDs for numerical vital monitoring
self.lcd_BR.setSegmentStyle(QLCDNumber.Flat)
paletteBR = self.lcd_BR.palette()
paletteBR.setColor(paletteBR.WindowText, QtGui.QColor(85, 85, 240))
self.lcd_BR.setPalette(paletteBR)
self.lcd_BR.display(58)
self.lcd_HR.setSegmentStyle(QLCDNumber.Flat)
paletteHR = self.lcd_HR.palette()
paletteHR.setColor(paletteHR.WindowText, QtGui.QColor(85, 255, 85))
self.lcd_HR.setPalette(paletteHR)
self.lcd_HR.display(287)
self.lcd_TEMP.setSegmentStyle(QLCDNumber.Flat)
paletteTEMP = self.lcd_TEMP.palette()
paletteTEMP.setColor(paletteTEMP.WindowText, QtGui.QColor(255, 85, 85))
self.lcd_TEMP.setPalette(paletteTEMP)
self.lcd_TEMP.display(17)
#Labels for vitals
BRlabel = QLabel('Breathing Rate (breaths/min)')
HRlabel = QLabel('Heart Rate (beats/min)')
TEMPlabel = QLabel('Subject Temperature (Celsius)')
#Setting up Frame Layout
wid = QWidget(self)
self.setCentralWidget(wid)
box = QHBoxLayout(self)
#Boxes for LCD vitals
box_HRLCD = QHBoxLayout(self)
box_BRLCD = QHBoxLayout(self)
box_TEMPLCD = QHBoxLayout(self)
box_HRLCD.addWidget(self.lcd_HR)
box_BRLCD.addWidget(self.lcd_BR)
box_TEMPLCD.addWidget(self.lcd_TEMP)
box_graph = QHBoxLayout(self)
box_graph.addWidget(self.lbl)
# Frames for vitals
left = QFrame(self)
left.setFrameShape(QFrame.Box)
topright = QFrame(self)
topright.setFrameShape(QFrame.Box)
middleright = QFrame(self)
middleright.setFrameShape(QFrame.Box)
bottomright = QFrame(self)
bottomright.setFrameShape(QFrame.Box)
left.setLayout(box_graph)
topright.setLayout(box_HRLCD)
middleright.setLayout(box_BRLCD)
bottomright.setLayout(box_TEMPLCD)
# Splitting frames and adding layout to window
splitter1 = QSplitter(Qt.Vertical)
splitter1.addWidget(topright)
splitter1.addWidget(middleright)
splitter2 = QSplitter(Qt.Vertical)
splitter2.addWidget(splitter1)
splitter2.addWidget(bottomright)
splitter3 = QSplitter(Qt.Horizontal)
splitter3.addWidget(left)
splitter3.addWidget(splitter2)
box.addWidget(splitter3)
wid.setLayout(box)
menubar = self.menuBar()
fileMenu = menubar.addMenu('File')
viewMenu = menubar.addMenu('View')
recordingMenu = menubar.addMenu('Recording Options')
self.statusbar = self.statusBar()
self.statusbar.showMessage('Ready')
impMenu = QMenu('Import', self)
impAct = QAction('Import data', self)
impAct.triggered.connect(lambda: self.loadCsv)
impMenu.addAction(impAct)
expMenu = QMenu('Export', self)
expAct = QAction('Export data', self)
expAct.triggered.connect(lambda: self.writeCsv)
expMenu.addAction(expAct)
newAct = QAction('New', self)
changeWindowSize = QAction('Change Window Size', self)
changeWindowSize.triggered.connect(lambda: self.windowSizeInput())
resetWindow = QAction('Reset Window to Present', self)
resetWindow.triggered.connect(lambda: self.windowReset())
recordingMenu.addAction(changeWindowSize)
recordingMenu.addAction(resetWindow)
fileMenu.addAction(newAct)
fileMenu.addMenu(impMenu)
fileMenu.addMenu(expMenu)
fileMenu.addMenu(recordingMenu)
#Making the status bar
viewStatAct = QAction('View statusbar', self, checkable=True)
viewStatAct.setStatusTip('View statusbar')
viewStatAct.setChecked(True)
viewStatAct.triggered.connect(self.toggleMenu)
viewMenu.addAction(viewStatAct)
#Making the toolbar
exitAct = QAction(QIcon('cancel-512.png'), 'Exit', self)
exitAct.triggered.connect(lambda: sys.exit())
exportAct = QAction(QIcon('512x512.png'), 'Export Vitals', self)
exportAct.triggered.connect(lambda: self.writeRealCsv())
exportRawAct = QAction(QIcon('document.png'), 'Export Raw Data', self)
exportRawAct.triggered.connect(lambda: self.writeVoltageCsv())
startAct = QAction(QIcon('graphs icon.png'), 'Start Graphs', self)
startAct.triggered.connect(lambda: self.lbl.plot(self.lcd_HR, self.lcd_BR, self.lcd_TEMP))
heatAct = QAction(QIcon('temperature icon.png'), 'Start Temperature', self)
heatAct.triggered.connect(lambda: self.tempControl())
vitalsAct = QAction(QIcon('vitals icon.png'), 'Start Vitals', self)
vitalsAct.triggered.connect(lambda: self.startVitals())
self.toolbar = self.addToolBar('Exit')
self.toolbar = self.addToolBar('Save')
self.toolbar = self.addToolBar('Export')
self.toolbar = self.addToolBar('Export')
self.toolbar.addAction(exitAct)
self.toolbar.addAction(startAct)
self.toolbar.addAction(heatAct)
self.toolbar.addAction(vitalsAct)
self.toolbar.addAction(exportAct)
#Setting window size and showing
self.show()
def analyzeHR(self, run=True):
data = genfromtxt('breathdata.csv', dtype=None, delimiter=',')
HR_ADCchan = 1
run = True
all_data = []
all_hr = []
count = 0
while run:
Value = []
HR = []
HR_Wave = WaveletTransform(data[1+count:5000+count])
peakind = signal.find_peaks_cwt(HR_Wave, np.arange(1,1000))
dist = []
for i in range(len(peakind)-2):
dist.append(peakind[i+1] - peakind[i])
heart_rate = np.mean(1./np.sum(dist))
self.lcd_HR.display(heart_rate)
all_hr.append(heart_rate)
count = count + 10
print(heart_rate)
def startVitals(self):
t = []
vital_thread = threading.Thread(target = self.analyzeHR())
t.append(vital_thread)
vital_thread.start()
#temp_thread = threading.Thread(self.tempControl())
plot_thread = threading.Thread(target = self.lbl.plot())
t.append(plot_thread)
#temp_thread.start()
plot_thread.start()
#plot_thread.run()
#vital_thread.run()
def windowSizeInput(self):
# open a smaller window with a numerical input option
num,ok = QInputDialog.getInt(self,"Window Dialog","enter a number")
if ok:
newSize = num
self.lbl.plot(window=newSize, start = self.lbl.current_time)
def windowReset(self):
self.lbl.plot(window = self.lbl.window, start = self.lbl.current_time)
def toggleMenu(self, state):
if state:
self.statusbar.show()
else:
self.statusbar.hide()
# IN PROGRESS - last line of loadCSV needs to be changed and graphs need to be made self variables upon initialization for dynamic changing and one for models for each vital
def writeVoltageCsv(self):
cwd = os.getcwd()
volt_hr = self.lbl.volt_hr
volt_br = self.lbl.volt_br
volt_temp = self.lbl.volt_temp
fileName_volt = cwd + "/Voltage_Data.csv"
data = pd.DataFrame({'Heart Rate (V)':volt_hr, 'Breathing Rate (V)':volt_br, 'Temperature (V)':volt_temp})
data.to_csv(fileName_volt, index=False)
def writeRealCsv(self):
cwd = os.getcwd()
real_hr = self.lbl.real_hr
real_br = self.lbl.real_br
real_temp = self.lbl.real_temp
fileName_real = cwd + "/Vital_Data.csv"
data = pd.DataFrame({'Heart Rate (bpm)':real_hr, 'Breathing Rate (bpm)':real_temp, 'Temperature (F)':real_temp})
data.to_csv(fileName_real, index=False)
class timeDigitalWidget(QWidget):
time = pyqtSignal()
def __init__(self,winParent, percentaje):
super(timeDigitalWidget, self).__init__()
self.winParent=winParent
self.seconds = 900
self.pose3d = pose3d
self.percentaje = percentaje
self.show = False
self.MAX_PERCENT = 30
self.MAX_MARK = 10
self.hLayout = QHBoxLayout()
timeLabel = QLabel("Time")
self.lcd = QLCDNumber(self)
self.lcd.setMaximumSize(100,50)
self.hLayout.addWidget(timeLabel,0)
self.hLayout.addWidget(self.lcd, 1)
hSpacer = QSpacerItem(300, 30, QSizePolicy.Ignored, QSizePolicy.Ignored)
self.hLayout.addItem(hSpacer)
self.setLayout(self.hLayout)
timer = QTimer(self)
timer.start(1000)
timer.timeout.connect(self.printTime)
# get the palette
palette = self.lcd.palette()
# foreground color
palette.setColor(palette.WindowText, QColor(85, 85, 255))
# background color
palette.setColor(palette.Background, QColor(0, 170, 255))
# "light" border
palette.setColor(palette.Light, QColor(255, 0, 0))
# "dark" border
palette.setColor(palette.Dark, QColor(0, 255, 0))
# set the palette
self.lcd.setPalette(palette)
def showMark(self):
self.show = True
mark = self.testPercentaje()
markLabel = QLabel('Final mark: ' + str(mark))
self.hLayout.addWidget(markLabel, 0)
self.setLayout(self.hLayout)
def printTime(self):
if self.seconds > 0:
self.seconds -= 1
else:
if not self.show:
self.showMark()
self.lcd.display(self.seconds)
def testPercentaje(self):
pHouse = self.percentaje.calculatePercentaje()
markPerc = float(pHouse) * float(self.MAX_MARK) / float(self.MAX_PERCENT)
if pHouse > self.MAX_PERCENT:
markPerc = 10
return markPerc
class SigSlot(QWidget):
def __init__(self,parent=None):
QWidget.__init__(self)
self.dev = None
self.model = None
self.cur_range = None
self.mode = None
self.initalizing = True
self.load_enabled = False
self.setWindowTitle('ITECH Electric Load')
self.dev_selector = QComboBox(self)
self.dev_selector.addItems(serial_ports())
# self.dev_selector.addItems(["COM7"])
self.btn_connect = QPushButton('Open', self)
self.btn_connect.clicked.connect(self.on_open_click)
self.btn_connect.setToolTip('This is an example button')
# Device Selector
box_selector = QHBoxLayout()
box_selector.addWidget(self.dev_selector)
box_selector.addWidget(self.btn_connect)
self.dev_id = QLineEdit(self)
# Mode Zone
mode_selector = QVBoxLayout()
mode_group = QGroupBox("Mode", self)
self.mode_cc = QRadioButton("CC")
self.mode_cc.toggled.connect(lambda:self.on_mode_select(self.mode_cc))
self.mode_cv = QRadioButton("CV")
self.mode_cv.toggled.connect(lambda:self.on_mode_select(self.mode_cv))
self.mode_cr = QRadioButton("CR")
self.mode_cr.toggled.connect(lambda:self.on_mode_select(self.mode_cr))
self.mode_cp = QRadioButton("CW")
self.mode_cp.toggled.connect(lambda:self.on_mode_select(self.mode_cp))
mode_selector.addWidget(self.mode_cc)
mode_selector.addWidget(self.mode_cv)
mode_selector.addWidget(self.mode_cr)
mode_selector.addWidget(self.mode_cp)
# Load Control
self.lcd = QLCDNumber(8, self)
spRight = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
spRight.setHorizontalStretch(2)
self.lcd.setSizePolicy(spRight)
self.btn_load = QPushButton('LOAD', self)
self.btn_load.clicked.connect(self.on_btn_load_clicked)
# Power
main_slider_label = QLabel("Power:", self)
self.slider = QSlider(Qt.Horizontal,self)
self.main_slider_value = QLineEdit("0.00A", self)
self.main_slider_value.installEventFilter(self)
# sp_slider_value = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
# sp_slider_value.setHorizontalStretch(0.1)
# self.main_slider_value.setSizePolicy(sp_slider_value)
self.main_slider_value.setFixedSize(80, 20)
self.slider.setMinimum(0)
self.slider.setMaximum(10000 * 132)
self.slider.setSingleStep(132*10000 / 300)
# Meassure Zone Start
mode_meas_vol = QGroupBox("Voltage", self)
mode_meas_cur = QGroupBox("Current", self)
mode_meas_pow = QGroupBox("Power", self)
meas_vol_layout = QHBoxLayout()
self.meas_vol_lcd = QLCDNumber(6, self)
# get the palette
palette = self.meas_vol_lcd.palette()
palette.setColor(palette.Light, QColor(255, 0, 0))
self.meas_vol_lcd.setPalette(palette)
meas_vol_layout.addWidget(self.meas_vol_lcd)
mode_meas_vol.setLayout(meas_vol_layout)
meas_cur_layout = QHBoxLayout()
self.meas_cur_lcd = QLCDNumber(6, self)
palette = self.meas_cur_lcd.palette()
palette.setColor(palette.Light, QColor(0, 255, 0))
self.meas_cur_lcd.setPalette(palette)
meas_cur_layout.addWidget(self.meas_cur_lcd)
mode_meas_cur.setLayout(meas_cur_layout)
meas_pow_layout = QHBoxLayout()
self.meas_pow_lcd = QLCDNumber(6, self)
palette = self.meas_pow_lcd.palette()
palette.setColor(palette.Light, QColor(0, 0, 255))
self.meas_pow_lcd.setPalette(palette)
meas_pow_layout.addWidget(self.meas_pow_lcd)
mode_meas_pow.setLayout(meas_pow_layout)
meas_layout = QHBoxLayout()
meas_layout.addWidget(mode_meas_vol)
meas_layout.addWidget(mode_meas_cur)
meas_layout.addWidget(mode_meas_pow)
# Meassure Zone End
# Pluse Zone
pulse_mainLayout = QVBoxLayout()
pulse_group = QGroupBox("Pluse", self)
pulse_layout = QHBoxLayout()
self.pulse_enabled = QCheckBox("ENABLE", self)
self.pulse_freq = QSlider(Qt.Horizontal, self)
self.pulse_freq.setMinimum(1)
self.pulse_freq.setMaximum(5000)
self.pulse_freq.setSingleStep(10)
self.pulse_freq_text = QLineEdit("0.00Hz", self)
self.pulse_freq_text.installEventFilter(self)
self.pulse_freq_text.setFixedSize(60, 20)
self.pulse_duty = QSlider(Qt.Horizontal, self)
self.pulse_duty.setMinimum(50)
self.pulse_duty.setMaximum(950)
self.pulse_duty_text = QLineEdit("50.0%", self)
self.pulse_duty_text.installEventFilter(self)
self.pulse_duty_text.setFixedSize(40, 20)
pulse_level_label = QLabel("Level:", self)
self.pulse_level_slider = QSlider(Qt.Horizontal,self)
self.pulse_level_text = QLineEdit("0.00A", self)
self.pulse_level_text.installEventFilter(self)
self.pulse_level_text.setFixedSize(40, 20)
self.pulse_level_slider.setMinimum(0)
self.pulse_level_slider.setMaximum(1000)
pulse_layout.addWidget(self.pulse_enabled)
pulse_layout.addWidget(self.pulse_freq)
pulse_layout.addWidget(self.pulse_freq_text)
pulse_layout.addWidget(self.pulse_duty)
pulse_layout.addWidget(self.pulse_duty_text)
pulse_level_layout = QHBoxLayout()
pulse_level_layout.addWidget(pulse_level_label)
pulse_level_layout.addWidget(self.pulse_level_slider)
pulse_level_layout.addWidget(self.pulse_level_text)
pulse_mainLayout.addLayout(pulse_layout)
pulse_mainLayout.addLayout(pulse_level_layout)
pulse_group.setLayout(pulse_mainLayout)
self.pulse_enabled.toggled.connect(self.on_pulse_enabled_toggle)
self.pulse_freq.valueChanged.connect(self.on_pulse_freq_slider_valueChanged)
self.pulse_duty.valueChanged.connect(self.on_pulse_duty_slider_valueChanged)
self.pulse_level_slider.valueChanged.connect(self.on_pulse_level_slider_valueChanged)
# Pluse Zone End
main_layout = QHBoxLayout()
mode_group.setLayout(mode_selector)
# mode_size = mode_group.sizeHint()
# mode_size.setWidth(80)
# mode_group.resize(mode_size)
main_layout.addWidget(mode_group)
main_layout.addWidget(self.lcd)
self.btn_load.setFixedSize(self.btn_load.sizeHint().width(), mode_group.sizeHint().height())
main_layout.addWidget(self.btn_load)
vbox = QVBoxLayout()
vbox.addLayout(box_selector)
vbox.addWidget(self.dev_id)
vbox.addLayout(main_layout)
layer_main_slider = QHBoxLayout()
layer_main_slider.addWidget(main_slider_label)
layer_main_slider.addWidget(self.slider)
layer_main_slider.addWidget(self.main_slider_value)
vbox.addLayout(layer_main_slider)
vbox.addLayout(meas_layout)
vbox.addWidget(pulse_group)
self.setLayout(vbox)
self.slider.valueChanged.connect(self.on_main_slider_valueChanged)
self.resize(350,250)
timer = QTimer(self)
timer.setSingleShot(False)
timer.timeout.connect(self.get_meas_value)
timer.start(100)
def get_main_scale_div(self):
div_val = 10000
return div_val
def get_cmd(self, cmd):
try:
model = self.model.split(",")
for i in range(0,len(COMMAND_SET)):
if model[1] in COMMAND_SET[i]["models"]:
return COMMAND_SET[i][cmd]
return COMMAND_SET[0][cmd]
except Exception as e:
return None
@pyqtSlot()
def get_meas_value(self):
if self.dev is not None and not self.initalizing:
try:
state = self.dev.GetInputValues()
self.meas_curr = state[1]
self.meas_volt = state[0]
self.meas_pow = state[2]
self.load_enabled = (state[3] & 0x8) == 0x8
self.update_load_button()
self.meas_cur_lcd.display(self.meas_curr)
self.meas_vol_lcd.display(self.meas_volt)
self.meas_pow_lcd.display(self.meas_pow)
except Exception as e:
print("Read data failed")
def update_mode(self):
div_val = self.get_main_scale_div()
if self.mode == "CC":
max_var = self.dev.GetMaxCurrent()
self.slider.setMaximum(max_var * div_val)
self.slider.setSingleStep(max_var * div_val / 300)
self.cur_current = self.dev.GetCCCurrent()
self.slider.setValue(float(self.cur_current) * div_val)
self.pulse_enabled.setEnabled(True)
elif self.mode == "CV":
max_var = self.dev.GetMaxVoltage()
self.slider.setMaximum(max_var * div_val)
self.slider.setSingleStep(max_var * div_val / 300)
self.cur_voltage = self.dev.GetCVVoltage()
self.slider.setValue(float(self.cur_voltage) * div_val)
self.pulse_enabled.setEnabled(False)
elif self.mode == "CW":
max_var = self.dev.GetMaxPower()
self.slider.setMaximum(max_var * div_val)
self.slider.setSingleStep(max_var * div_val / 300)
self.cur_power = self.dev.GetCWPower()
self.slider.setValue(float(self.cur_power) * div_val)
self.pulse_enabled.setEnabled(False)
elif self.mode == "CR":
max_var = 7500
self.slider.setMaximum(max_var * div_val)
self.slider.setSingleStep(max_var * div_val / 300)
self.cur_resister = self.dev.GetCRResistance()
self.slider.setValue(float(self.cur_resister) * div_val)
self.pulse_enabled.setEnabled(False)
self.update_slider_value()
@pyqtSlot()
def on_open_click(self):
print("Click", self.dev_selector.currentText())
if self.dev is None:
self.initalizing = True
self.dev = dcload.DCLoad()
self.dev.Initialize(self.dev_selector.currentText(), 115200)
self.btn_connect.setText("Close")
self.model, serial_no, fw = self.dev.GetProductInformation()
self.dev_id.setText(self.model)
mode = self.dev.GetMode()
self.mode = mode
if mode == "CC":
self.mode_cc.setChecked(True)
elif mode == "CV":
self.mode_cv.setChecked(True)
elif mode == "CR":
self.mode_cr.setChecked(True)
elif mode == "CW":
self.mode_cp.setChecked(True)
self.update_mode()
self.dev.SetRemoteControl()
# self.dev.write("PULSe:FREQuency?")
# self.cur_pulse_freq = self.dev.read().strip()
# self.dev.write("PULSe:DCYCle?")
# self.cur_pulse_duty = self.dev.read().strip()
# self.dev.write("PULSe:LEVel:PERCentage:CURRent?")
trans_state = self.dev.GetTransient(self.mode)
self.trans_state = trans_state
if trans_state[1] + trans_state[3] == 0:
self.cur_pulse_freq = 10000
self.cur_pulse_duty = 50
else:
self.cur_pulse_freq = 1 / (trans_state[1] + trans_state[3])
self.cur_pulse_duty = trans_state[1] / (trans_state[1] + trans_state[3]) * 100
self.cur_pulse_level = trans_state[0] / (self.slider.value()/self.get_main_scale_div()) * 100
cur_function = self.dev.GetFunction()
if cur_function == "transient":
self.cur_pulse_enabled = True
else:
self.cur_pulse_enabled = False
print("Pluse Freq : %s DUTY: %s%%" % (self.cur_pulse_freq, self.cur_pulse_duty))
self.update_pulse_info()
self.initalizing = False
else:
del self.dev
self.btn_connect.setText("Open")
self.dev = None
self.initalizing = True
def update_pulse_info(self):
duty_1 = 1 / self.cur_pulse_freq * (self.cur_pulse_duty / 100)
duty_2 = 1 / self.cur_pulse_freq * (1 - self.cur_pulse_duty / 100)
print(self.mode, self.cur_pulse_level / 100 * self.slider.value()/self.get_main_scale_div(), int(duty_1 * 10000), self.slider.value()/self.get_main_scale_div(), int(10000*duty_2))
self.dev.SetTransient(self.mode, self.cur_pulse_level / 100 * self.slider.value()/self.get_main_scale_div(), duty_1, self.slider.value()/self.get_main_scale_div(), duty_2, "continuous")
self.pulse_freq.setValue(float(self.cur_pulse_freq))
self.pulse_duty.setValue(float(self.cur_pulse_duty) * 10)
self.pulse_level_slider.setValue(float(self.cur_pulse_level) * 10)
self.pulse_freq_text.setText("%.0fHz" % (float(self.cur_pulse_freq)))
self.pulse_duty_text.setText("%.01f%%" % (float(self.cur_pulse_duty)))
self.pulse_level_text.setText("%.01f%%" % (float(self.cur_pulse_level)))
if self.cur_pulse_enabled:
self.pulse_enabled.setChecked(True)
self.mode_cv.setEnabled(False)
self.mode_cr.setEnabled(False)
self.mode_cp.setEnabled(False)
else:
self.pulse_enabled.setChecked(False)
self.mode_cv.setEnabled(True)
self.mode_cr.setEnabled(True)
self.mode_cp.setEnabled(True)
@pyqtSlot()
def on_pulse_enabled_toggle(self):
if not self.initalizing:
self.cur_pulse_enabled = not self.cur_pulse_enabled
if self.cur_pulse_enabled:
self.dev.SetFunction("transient")
print(self.dev.GetTriggerSource())
self.dev.TriggerLoad()
else:
self.dev.SetFunction("fixed")
print("Set Pluse To %s" % (self.cur_pulse_enabled))
self.update_pulse_info()
@pyqtSlot()
def on_pulse_freq_slider_valueChanged(self):
if self.initalizing:
return
print("Set Pluse Frequence to %d" % (self.pulse_freq.value()))
self.cur_pulse_freq = self.pulse_freq.value()
self.update_pulse_info()
@pyqtSlot()
def on_pulse_duty_slider_valueChanged(self):
if self.initalizing:
return
print("Set Pluse Duty to %.01f%%" % (self.pulse_duty.value()/10))
self.cur_pulse_duty = self.pulse_duty.value()/10
self.update_pulse_info()
@pyqtSlot()
def on_pulse_level_slider_valueChanged(self):
if self.initalizing:
return
print("Set Pluse Level to %.01f%%" % (self.pulse_level_slider.value()/10))
self.cur_pulse_level = (self.pulse_level_slider.value()/10)
self.update_pulse_info()
@pyqtSlot()
def on_mode_select(self,b):
if b.isChecked() and not self.initalizing:
print("Set MODE = %s %d" % (b.text(), b.isChecked()))
self.dev.SetMode(b.text())
self.mode = b.text()
self.update_mode()
def update_slider_value(self):
div_val = self.get_main_scale_div()
self.lcd.display("%.03f" % (self.slider.value()/div_val))
if self.mode == "CC":
self.main_slider_value.setText("%.03f A" % (self.slider.value()/div_val))
elif self.mode == "CV":
self.main_slider_value.setText("%.04f V" % (self.slider.value()/div_val))
elif self.mode == "CW":
self.main_slider_value.setText("%.04f W" % (self.slider.value()/div_val))
elif self.mode == "CR":
self.main_slider_value.setText("%.04f Ω" % (self.slider.value()/div_val))
@pyqtSlot()
def on_main_slider_valueChanged(self):
div_val = self.get_main_scale_div()
if self.initalizing:
return
print("Set Power to %d" % (self.slider.value()))
self.update_slider_value()
if self.mode == "CC":
self.dev.SetCCCurrent(self.slider.value()/div_val)
elif self.mode == "CV":
self.dev.SetCVVoltage(self.slider.value()/div_val)
elif self.mode == "CW":
self.dev.SetCWPower(self.slider.value()/div_val)
elif self.mode == "CR":
self.dev.SetCRResistance(self.slider.value()/div_val)
def eventFilter(self, obj, event):
if obj == self.main_slider_value and event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter:
try:
div_val = self.get_main_scale_div()
if self.mode == "CR" and float(self.main_slider_value.text()) * div_val > 0:
self.slider.setValue(float(self.main_slider_value.text()) * div_val)
else:
self.slider.setValue(float(self.main_slider_value.text()) * div_val)
self.on_main_slider_valueChanged()
self.main_slider_value.selectAll()
except Exception as e:
print("INPUT INVALID")
self.update_slider_value()
elif event.key() == Qt.Key_Escape:
self.update_slider_value()
elif obj == self.pulse_freq_text and event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter:
try:
self.pulse_freq.setValue(float(self.pulse_freq_text.text()))
self.pulse_freq_text.selectAll()
except Exception as e:
print("INPUT INVALID")
self.update_pulse_info()
elif event.key() == Qt.Key_Escape:
self.update_pulse_info()
elif obj == self.pulse_duty_text and event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter:
try:
self.pulse_duty.setValue(float(self.pulse_duty_text.text()) * 10)
self.pulse_duty_text.selectAll()
except Exception as e:
print("INPUT INVALID")
self.update_pulse_info()
elif event.key() == Qt.Key_Escape:
self.update_pulse_info()
elif obj == self.pulse_level_text and event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter:
try:
self.pulse_level_slider.setValue(float(self.pulse_level_text.text()) * 10)
self.pulse_level_text.selectAll()
except Exception as e:
print("INPUT INVALID")
self.update_pulse_info()
elif event.key() == Qt.Key_Escape:
self.update_pulse_info()
elif event.type() == QEvent.Enter and obj in [self.main_slider_value, self.pulse_freq_text, self.pulse_duty_text, self.pulse_level_text]:
rc = super(SigSlot, self).eventFilter(obj, event)
obj.setFocus()
obj.selectAll()
return rc
# print(obj)
return super(SigSlot, self).eventFilter(obj, event)
def update_load_button(self):
if self.load_enabled == False:
self.btn_load.setStyleSheet("background-color: #00ff77;")
self.mode_cc.setEnabled(True)
self.mode_cv.setEnabled(True)
self.mode_cr.setEnabled(True)
self.mode_cp.setEnabled(True)
else:
self.btn_load.setStyleSheet("background-color: red;")
self.mode_cc.setEnabled(False)
self.mode_cv.setEnabled(False)
self.mode_cr.setEnabled(False)
self.mode_cp.setEnabled(False)
@pyqtSlot()
def on_btn_load_clicked(self):
if self.initalizing:
return
print("Change Load State")
if self.load_enabled == False:
self.dev.TurnLoadOn()
self.load_enabled = True
else:
print("Close LOAD")
self.dev.TurnLoadOff()
self.load_enabled = False
self.update_load_button()
def keyPressEvent(self, e):
if e.key() == Qt.Key_F5:
self.on_btn_load_clicked()
class RmsDriver(QObject):
def __init__(self, driverNum):
super().__init__()
self.CtrlNum = driverNum
self.name = 'Driver ' + str(driverNum)
self.lapcount = 0
self.bestLapTime = None
self.lapTime = None
self.time = None
self.fuellevel = 15
self.pitcount = 0
self.pit = False
self.buildDriver()
def buildDriver(self):
self.nameFont = QFont()
self.nameFont.setPointSize(20)
self.nameFont.setBold(True)
self.nameBtn = QPushButton(self.name + '\n' + 'Ctrl: ' +
str(self.CtrlNum))
self.nameBtn.setToolTip('Click to change driver name')
self.nameBtn.setFont(self.nameFont)
self.nameBtn.setStyleSheet(
"QPushButton { border: 5px solid black; border-radius: 10px; background-color: white}"
)
self.lapCountLCD = QLCDNumber(3)
self.lapCountLCD.setStyleSheet(
"QLCDNumber{ border-radius: 10px; background-color: black}")
lcdPalette = self.lapCountLCD.palette()
lcdPalette.setColor(lcdPalette.WindowText, QColor(255, 255, 0))
self.lapCountLCD.setPalette(lcdPalette)
self.lapCountLCD.display(self.lapcount)
self.bestLapLCD = QLCDNumber()
self.bestLapLCD.setStyleSheet(
"QLCDNumber{ border-radius: 10px; background-color: black}")
lcdPalette = self.bestLapLCD.palette()
lcdPalette.setColor(lcdPalette.WindowText, QColor(255, 255, 0))
self.bestLapLCD.setPalette(lcdPalette)
self.bestLapLCD.display(self.bestLapTime)
self.lapLCD = QLCDNumber()
self.lapLCD.setStyleSheet(
"QLCDNumber{ border-radius: 10px; background-color: black}")
lcdPalette = self.lapLCD.palette()
lcdPalette.setColor(lcdPalette.WindowText, QColor(255, 255, 0))
self.lapLCD.setPalette(lcdPalette)
self.lapLCD.display(self.lapTime)
self.fuelbar = QProgressBar()
self.fuelbar.setOrientation(Qt.Horizontal)
self.fuelbar.setStyleSheet(
"QProgressBar{ color: white; background-color: black; border: 5px solid black; border-radius: 10px; text-align: center}\
QProgressBar::chunk { background: qlineargradient(x1: 1, y1: 0.5, x2: 0, y2: 0.5, stop: 0 #00AA00, stop: "
+ str(0.92 - (1 / (self.fuellevel))) + " #22FF22, stop: " +
str(0.921 - (1 / (self.fuellevel))) + " #22FF22, stop: " +
str(1.001 - (1 / (self.fuellevel))) + " red, stop: 1 #550000); }")
self.fuelbar.setMinimum(0)
self.fuelbar.setMaximum(15)
self.fuelbar.setValue(self.fuellevel)
self.pitCountLCD = QLCDNumber(2)
self.pitCountLCD.setStyleSheet(
"QLCDNumber{ border-radius: 10px; background-color: black}")
lcdPalette = self.pitCountLCD.palette()
lcdPalette.setColor(lcdPalette.WindowText, QColor(255, 0, 0))
self.pitCountLCD.setPalette(lcdPalette)
self.pitCountLCD.display(self.pitcount)
def getName(self):
return self.name
def getNameBtn(self):
return self.nameBtn
def getLapCountLCD(self):
return self.lapCountLCD
def getBestLapLCD(self):
return self.bestLapLCD
def getLapLCD(self):
return self.lapLCD
def getFuelBar(self):
return self.fuelbar
def setCtrlNum(self, num):
self.CtrlNum = num
self.nameBtn.setText(self.name + '\n' + 'Ctrl: ' + str(self.CtrlNum))
def getPits(self):
return self.pitCountLCD
def newlap(self, timer):
if self.time is not None:
self.lapTime = timer.timestamp - self.time
if self.bestLapTime is None or self.lapTime < self.bestLapTime:
self.bestLapTime = self.lapTime
self.lapcount += 1
self.time = timer.timestamp
class WheelBox(QWidget):
valueChanged = pyqtSignal('double', name="valueChanged")
def __init__(self, title, min, max, stepSize, parent):
super().__init__(parent)
self.__d_number = QLCDNumber(self)
self.__d_number.setSegmentStyle(QLCDNumber.Filled)
self.__d_number.setAutoFillBackground(True)
self.__d_number.setFixedHeight(self.__d_number.sizeHint().height() * 2)
self.__d_number.setFocusPolicy(Qt.WheelFocus)
pal = QPalette(Qt.black)
pal.setColor(QPalette.WindowText, Qt.green)
self.__d_number.setPalette(pal)
self.__d_wheel = Wheel(self)
self.__d_wheel.setOrientation(Qt.Vertical)
self.__d_wheel.setInverted(True)
self.__d_wheel.setRange(min, max)
self.__d_wheel.setSingleStep(stepSize)
self.__d_wheel.setPageStepCount(5)
self.__d_wheel.setFixedHeight(self.__d_number.height())
self.__d_number.setFocusProxy(self.__d_wheel)
font = QFont("Helvetica", 10)
font.setBold(True)
self.__d_label = QLabel(title, self)
self.__d_label.setFont(font)
hLayout = QHBoxLayout()
hLayout.setContentsMargins(0, 0, 0, 0)
hLayout.setSpacing(2)
hLayout.addWidget(self.__d_number, 10)
hLayout.addWidget(self.__d_wheel)
vLayout = QVBoxLayout(self)
vLayout.addLayout(hLayout, 10)
vLayout.addWidget(self.__d_label, 0, Qt.AlignTop | Qt.AlignHCenter)
self.__d_wheel.valueChanged.connect(self.display)
self.__d_wheel.valueChanged.connect(self.valueChanged)
def display(self, value):
self.__d_number.display(value)
def theme(self):
return self.__d_wheel.palette().color(QPalette.Window)
def setTheme(self, color):
self.__d_wheel.setPalette(QPalette(color))
def setValue(self, value):
self.__d_wheel.setValue(value)
self.__d_number.display(value)
def value(self):
return self.__d_wheel.value()
theme = pyqtProperty(QColor, theme, setTheme)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.left = 10
self.top = 10
self.title = 'Rodent Vitals Monitoring Software Demo'
self.width = 700
self.height = 500
self.model = []
#Matplotlib graphs
self.lbl = PlotCanvas()
#LCDs for numerical vital monitoring
self.lcd_BR = QLCDNumber(self)
self.lcd_HR = QLCDNumber(self)
self.lcd_TEMP = QLCDNumber(self)
self.control = PID()
self.control.setPoint(set_point=37)
print("Initializing MainWindow")
self.initUI()
def initUI(self):
# Set Main Window Geometry and Title
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowTitle(self.title)
#LCDs for numerical vital monitoring
self.lcd_BR.setSegmentStyle(QLCDNumber.Flat)
paletteBR = self.lcd_BR.palette()
paletteBR.setColor(paletteBR.WindowText, QtGui.QColor(85, 85, 240))
self.lcd_BR.setPalette(paletteBR)
self.lcd_BR.display(58)
self.lcd_HR.setSegmentStyle(QLCDNumber.Flat)
paletteHR = self.lcd_HR.palette()
paletteHR.setColor(paletteHR.WindowText, QtGui.QColor(85, 255, 85))
self.lcd_HR.setPalette(paletteHR)
self.lcd_HR.display(287)
self.lcd_TEMP.setSegmentStyle(QLCDNumber.Flat)
paletteTEMP = self.lcd_TEMP.palette()
paletteTEMP.setColor(paletteTEMP.WindowText, QtGui.QColor(255, 85, 85))
self.lcd_TEMP.setPalette(paletteTEMP)
self.lcd_TEMP.display(17)
#Labels for vitals
BRlabel = QLabel('Breathing Rate (breaths/min)')
HRlabel = QLabel('Heart Rate (beats/min)')
TEMPlabel = QLabel('Subject Temperature (Celsius)')
#Setting up Frame Layout
wid = QWidget(self)
self.setCentralWidget(wid)
box = QHBoxLayout(self)
#Boxes for LCD vitals
box_HRLCD = QHBoxLayout(self)
box_BRLCD = QHBoxLayout(self)
box_TEMPLCD = QHBoxLayout(self)
box_HRLCD.addWidget(self.lcd_HR)
box_BRLCD.addWidget(self.lcd_BR)
box_TEMPLCD.addWidget(self.lcd_TEMP)
box_graph = QHBoxLayout(self)
box_graph.addWidget(self.lbl)
left = QFrame(self)
left.setFrameShape(QFrame.Box)
topright = QFrame(self)
topright.setFrameShape(QFrame.Box)
middleright = QFrame(self)
middleright.setFrameShape(QFrame.Box)
bottomright = QFrame(self)
bottomright.setFrameShape(QFrame.Box)
left.setLayout(box_graph)
topright.setLayout(box_HRLCD)
middleright.setLayout(box_BRLCD)
bottomright.setLayout(box_TEMPLCD)
# Splitting frames and adding layout to window
splitter1 = QSplitter(Qt.Vertical)
splitter1.addWidget(topright)
splitter1.addWidget(middleright)
splitter2 = QSplitter(Qt.Vertical)
splitter2.addWidget(splitter1)
splitter2.addWidget(bottomright)
splitter3 = QSplitter(Qt.Horizontal)
splitter3.addWidget(left)
splitter3.addWidget(splitter2)
box.addWidget(splitter3)
wid.setLayout(box)
menubar = self.menuBar()
fileMenu = menubar.addMenu('File')
viewMenu = menubar.addMenu('View')
recordingMenu = menubar.addMenu('Recording Options')
self.statusbar = self.statusBar()
self.statusbar.showMessage('Ready')
impMenu = QMenu('Import', self)
impAct = QAction('Import data', self)
impAct.triggered.connect(lambda: self.loadCsv)
impMenu.addAction(impAct)
expMenu = QMenu('Export', self)
expAct = QAction('Export data', self)
expAct.triggered.connect(lambda: self.writeCsv)
expMenu.addAction(expAct)
newAct = QAction('New', self)
changeWindowSize = QAction('Change Window Size', self)
changeWindowSize.triggered.connect(lambda: self.windowSizeInput())
resetWindow = QAction('Reset Window to Present', self)
resetWindow.triggered.connect(lambda: self.windowReset())
recordingMenu.addAction(changeWindowSize)
recordingMenu.addAction(resetWindow)
fileMenu.addAction(newAct)
fileMenu.addMenu(impMenu)
fileMenu.addMenu(expMenu)
fileMenu.addMenu(recordingMenu)
#Making the status bar
viewStatAct = QAction('View statusbar', self, checkable=True)
viewStatAct.setStatusTip('View statusbar')
viewStatAct.setChecked(True)
viewStatAct.triggered.connect(self.toggleMenu)
viewMenu.addAction(viewStatAct)
#Making the toolbar
exitAct = QAction(QIcon('cancel-512.png'), 'Exit', self)
exitAct.triggered.connect(lambda: sys.exit())
exportAct = QAction(QIcon('512x512.png'), 'Export Vitals', self)
exportAct.triggered.connect(lambda: self.writeRealCsv())
exportRawAct = QAction(QIcon('document.png'), 'Export Raw Data', self)
exportRawAct.triggered.connect(lambda: self.writeVoltageCsv())
startAct = QAction(QIcon('graphs icon.png'), 'Start Graphs', self)
startAct.triggered.connect(lambda: self.lbl.plot(lcd_HR=self.lcd_HR, lcd_BR=self.lcd_BR, lcd_TEMP=self.lcd_TEMP))
heatAct = QAction(QIcon('temperature icon.png'), 'Start Temperature', self)
heatAct.triggered.connect(lambda: self.tempControl())
vitalsAct = QAction(QIcon('vitals icon.png'), 'Start Vitals', self)
vitalsAct.triggered.connect(lambda: self.displayVitals())
self.toolbar = self.addToolBar('Exit')
self.toolbar = self.addToolBar('Save')
self.toolbar = self.addToolBar('Export')
self.toolbar = self.addToolBar('Export')
self.toolbar.addAction(exitAct)
self.toolbar.addAction(startAct)
self.toolbar.addAction(heatAct)
self.toolbar.addAction(exportRawAct)
self.toolbar.addAction(exportAct)
print("Creating toolbar menus and displaying window")
#Setting window size and showing
self.show()
def Close(self):
self.p.stop()
GPIO.cleanup()
sys.exit()
def tempControl(self):
while True:
current_value = ConvertTemp(ReadChannel(2), 1)
#print(ReadChannel(2))
print(current_value)
newvalue = self.control.update(current_value=current_value)
print(newvalue)
if newvalue > current_value:
direction = 1
else:
direction = 0
GPIO.output(33, 1)
GPIO.output(29, direction)
time.sleep(2)
def startVitals(self):
self.tempControl()
self.lbl.plot()
def windowSizeInput(self):
# open a smaller window with a numerical input option
num,ok = QInputDialog.getInt(self,"Window Dialog","enter a number")
if ok:
newSize = num
self.lbl.plot(window=newSize, start = self.lbl.current_time)
def windowReset(self):
self.lbl.plot(window = self.lbl.window, start = self.lbl.current_time)
def toggleMenu(self, state):
if state:
self.statusbar.show()
else:
self.statusbar.hide()
# IN PROGRESS - last line of loadCSV needs to be changed and graphs need to be made self variables upon initialization for dynamic changing and one for models for each vital
def writeVoltageCsv(self, fileName):
cwd = os.getcwd()
volt_hr = self.lbl.volt_hr
volt_br = self.lbl.volt_br
volt_temp = self.lbl.volt_temp
fileName_volt = cwd + fileName + "Voltage_Data.csv"
data = pd.DataFrame({'Heart Rate (V)':volt_hr, 'Breathing Rate (V)':volt_br, 'Temperature (V)':volt_temp})
data.to_csv(fileName_volt, index=False)
def writeRealCsv(self, fileName):
real_hr = self.lbl.real_hr
real_br = self.lbl.real_br
real_temp = self.lbl.real_temp
fileName_real = cwd + fileName + "Vital_Data.csv"
data = pd.DataFrame({'Heart Rate (bpm)':real_hr, 'Breathing Rate (bpm)':real_temp, 'Temperature (F)':real_temp})
data.to_csv(fileName_real, index=False)
class OmniRigQTControls:
def __init__(self, operatingAsClient, sendCommandFunction=None):
self.operatingAsClient = operatingAsClient
self.omnirigObject = None
self.omniRigInfo = {}
self.sendCommandFunction = sendCommandFunction
self.blackColorPalette = QPalette()
self.blackColorPalette.setColor(QPalette.WindowText, QColor("black"))
self.redColorPalette = QPalette()
self.redColorPalette.setColor(QPalette.WindowText, QColor("red"))
self.boldFont = QFont()
self.boldFont.setBold(True)
self.regularFont = QFont()
self.regularFont.setBold(False)
self.labelRigName = QLabel("Rig is not responding")
self.rigSelectGroupBox = QGroupBox("Rig select:")
self.radioBtnTRX1 = QRadioButton("Rig 1")
self.radioBtnTRX1.setChecked(True)
self.radioBtnTRX1.toggled.connect(self.refreshRigInformation)
self.radioBtnTRX2 = QRadioButton("Rig 2")
self.radioBtnTRX2.toggled.connect(self.refreshRigInformation)
hboxRigSelect = QHBoxLayout()
hboxRigSelect.addWidget(self.radioBtnTRX1)
hboxRigSelect.addWidget(self.radioBtnTRX2)
hboxRigSelect.addWidget(self.labelRigName)
hboxRigSelect.addStretch()
self.rigSelectGroupBox.setLayout(hboxRigSelect)
self.rigSelectGroupBox.setMaximumWidth(360)
self.lcdTrxFrequency = QLCDNumber(10)
self.lcdTrxFrequency.display('00.000.00')
self.lcdTrxFrequency.setPalette(self.blackColorPalette)
self.lcdTrxFrequency.setMinimumHeight(50)
self.lcdTrxFrequency.setMaximumHeight(50)
self.lcdTrxFrequency.setMaximumWidth(275)
self.lcdTrxFrequency.setMinimumWidth(275)
self.labelRigModeLSB = QLabel('LSB')
self.labelRigModeLSB.setFont(self.boldFont)
self.labelRigModeLSB.setEnabled(False)
self.labelRigModeUSB = QLabel('USB')
self.labelRigModeUSB.setFont(self.boldFont)
self.labelRigModeUSB.setEnabled(False)
vboxMiddlePanel = QVBoxLayout()
vboxMiddlePanel.addWidget(self.labelRigModeLSB)
vboxMiddlePanel.addWidget(self.labelRigModeUSB)
hboxMiddlePanel = QHBoxLayout()
hboxMiddlePanel.addLayout(vboxMiddlePanel)
hboxMiddlePanel.addStretch()
self.btnBack500Hz = QPushButton("<--")
self.btnBack500Hz.setFixedWidth(50)
self.btnForward500Hz = QPushButton("-->")
self.btnForward500Hz.setFixedWidth(50)
self.btnForward500Hz.clicked.connect(self.btnOmniRigPlus500HzClick)
self.btnOmniRigUSB = QPushButton("USB")
self.btnOmniRigUSB.clicked.connect(self.btnOmniUSBClick)
self.btnOmniRigUSB.setFixedWidth(50)
self.btnOmniRigLSB = QPushButton("LSB")
self.btnOmniRigLSB.clicked.connect(self.btnOmniLSBClick)
self.btnOmniRigLSB.setFixedWidth(50)
hboxRigCATControl = QHBoxLayout()
hboxRigCATControl.addWidget(self.btnBack500Hz)
hboxRigCATControl.addWidget(self.btnForward500Hz)
hboxRigCATControl.addStretch()
hboxRigCATControl.addWidget(self.btnOmniRigLSB)
hboxRigCATControl.addWidget(self.btnOmniRigUSB)
hboxRigCATControl.addStretch(1)
hboxMainLayout = QHBoxLayout()
hboxMainLayout.addWidget(self.lcdTrxFrequency)
hboxMainLayout.addLayout(hboxMiddlePanel)
self.vboxMainLayout = QVBoxLayout()
self.vboxMainLayout.addWidget(self.rigSelectGroupBox)
self.vboxMainLayout.addLayout(hboxMainLayout)
if self.operatingAsClient is True:
self.vboxMainLayout.addLayout(hboxRigCATControl)
def setOmnirigObject(self, omnirigObject):
self.omnirigObject = omnirigObject
def btnOmniRigPlus500HzClick(self):
try:
self.omnirigObject = win32.Dispatch("OmniRig.OmniRigX")
except:
pass
if self.omnirigObject is not None and self.operatingAsClient is False:
if self.radioBtnTRX1.isChecked():
self.omnirigObject.Rig1.SetSimplexMode(str(self.omnirigObject.Rig1.Freq+500))
else:
self.omnirigObject.Rig2.SetSimplexMode(str(self.omnirigObject.Rig1.Freq+500))
if self.operatingAsClient is True and self.sendCommandFunction is not None:
self.sendCommandFunction('+500=1')
def btnOmniLSBClick(self):
try:
self.omnirigObject = win32.Dispatch("OmniRig.OmniRigX")
except:
pass
if self.omnirigObject is not None and self.operatingAsClient is False:
if self.radioBtnTRX1.isChecked():
self.omnirigObject.Rig1.Mode = '67108864'
else:
self.omnirigObject.Rig2.Mode = '67108864'
if self.operatingAsClient is True and self.sendCommandFunction is not None:
self.sendCommandFunction('setLSB=1')
def btnOmniUSBClick(self):
try:
self.omnirigObject = win32.Dispatch("OmniRig.OmniRigX")
except:
pass
if self.omnirigObject is not None and self.operatingAsClient is False:
if self.radioBtnTRX1.isChecked():
self.omnirigObject.Rig1.Mode = '33554432'
else:
self.omnirigObject.Rig2.Mode = '33554432'
if self.operatingAsClient is True and self.sendCommandFunction is not None:
self.sendCommandFunction('setUSB=1')
def setDisplayFreq(self, txtFreq):
self.lcdTrxFrequency.display(txtFreq)
def setOmniRigErrorText(self, msgText):
self.labelRigName.setText(msgText)
self.labelRigName.setPalette(self.redColorPalette)
def setRigStatus(self, rigType):
self.labelRigName.setText(rigType)
self.labelRigName.setPalette(self.blackColorPalette)
def getRigsInformation(self):
return self.omniRigInfo
def disableControls(self):
self.radioBtnTRX1.setEnabled(False)
self.radioBtnTRX2.setEnabled(False)
def refreshRigInformation(self):
rignum = '2'
if self.radioBtnTRX1.isChecked():
rignum = '1'
if len(self.omniRigInfo) > 1:
self.radioBtnTRX1.setText(self.omniRigInfo['1'].getRigType())
self.radioBtnTRX2.setText(self.omniRigInfo['2'].getRigType())
freqTxt = self.omniRigInfo[rignum].getRigFreq()
self.setDisplayFreq(self.addDotsToFreq(freqTxt))
self.setRigStatus(self.omniRigInfo[rignum].getRigStatus())
if freqTxt == 0:
self.labelRigModeUSB.setEnabled(False)
self.labelRigModeLSB.setEnabled(False)
else:
if self.omniRigInfo[rignum].getRigMode() == 'LSB':
self.labelRigModeUSB.setEnabled(False)
self.labelRigModeLSB.setEnabled(True)
else:
self.labelRigModeUSB.setEnabled(True)
self.labelRigModeLSB.setEnabled(False)
def setRigInformation(self, omniRigInfo):
self.omniRigInfo = omniRigInfo
self.refreshRigInformation()
def addDotsToFreq(self, freqvalue):
freqTxt = str(freqvalue)
if len(freqTxt) < 6:
freqTxt = '00000000'
firstPart = freqTxt[:-6]
if len(freqTxt) == 8:
mainPart = freqTxt[:7]
middlePart = mainPart[2:5]
lastPart = mainPart[5:]
else:
mainPart = freqTxt[:6]
middlePart = mainPart[1:4]
lastPart = mainPart[4:]
return firstPart+"."+middlePart+"."+lastPart
def getGUI(self):
return self.vboxMainLayout
class CueWidget(QWidget):
STOP = QIcon.fromTheme('led-off')
START = QIcon.fromTheme('led-running')
PAUSE = QIcon.fromTheme('led-pause')
ERROR = QIcon.fromTheme('led-error')
ICON_SIZE = 14
context_menu_request = pyqtSignal(object, QPoint)
edit_request = pyqtSignal(object)
cue_executed = pyqtSignal(object)
def __init__(self, cue, **kwargs):
super().__init__(**kwargs)
self.cue = None
self._selected = False
self._accurate_timing = False
self._show_dbmeter = False
self._countdown_mode = True
self._dbmeter_element = None
self._fade_element = None
self.setAttribute(Qt.WA_TranslucentBackground)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(2)
self.layout().setColumnStretch(0, 6)
self.layout().setRowStretch(0, 4)
self.nameButton = QClickLabel(self)
self.nameButton.setObjectName('ButtonCueWidget')
self.nameButton.setWordWrap(True)
self.nameButton.setAlignment(Qt.AlignCenter)
self.nameButton.setFocusPolicy(Qt.NoFocus)
self.nameButton.clicked.connect(self._clicked)
self.nameButton.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.layout().addWidget(self.nameButton, 0, 0)
self.statusIcon = QLabel(self.nameButton)
self.statusIcon.setStyleSheet('background-color: transparent')
self.statusIcon.setPixmap(CueWidget.STOP.pixmap(CueWidget.ICON_SIZE,
CueWidget.ICON_SIZE))
self.seekSlider = QClickSlider(self.nameButton)
self.seekSlider.setOrientation(Qt.Horizontal)
self.seekSlider.setFocusPolicy(Qt.NoFocus)
self.seekSlider.setVisible(False)
self.dbMeter = QDbMeter(self)
self.dbMeter.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.dbMeter.setVisible(False)
self.timeBar = QProgressBar(self)
self.timeBar.setTextVisible(False)
self.timeBar.setLayout(QHBoxLayout())
self.timeBar.layout().setContentsMargins(0, 0, 0, 0)
self.timeDisplay = QLCDNumber(self.timeBar)
self.timeDisplay.setStyleSheet('background-color: transparent')
self.timeDisplay.setSegmentStyle(QLCDNumber.Flat)
self.timeDisplay.setDigitCount(8)
self.timeDisplay.display('00:00:00')
self.timeBar.layout().addWidget(self.timeDisplay)
self.timeBar.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.timeBar.setVisible(False)
self._set_cue(cue)
@property
def selected(self):
return self._selected
@selected.setter
def selected(self, value):
self._selected = value
self._update_style(self.cue.stylesheet)
def contextMenuEvent(self, event):
self.context_menu_request.emit(self, event.globalPos())
def mouseMoveEvent(self, event):
if (event.buttons() == Qt.LeftButton and
(event.modifiers() == Qt.ControlModifier or
event.modifiers() == Qt.ShiftModifier)):
mime_data = QMimeData()
mime_data.setText(PageWidget.DRAG_MAGIC)
drag = QDrag(self)
drag.setMimeData(mime_data)
drag.setPixmap(self.grab(self.rect()))
if event.modifiers() == Qt.ControlModifier:
drag.exec_(Qt.MoveAction)
else:
drag.exec_(Qt.CopyAction)
event.accept()
else:
event.ignore()
def set_countdown_mode(self, mode):
self._countdown_mode = mode
self._update_time(self.cue.current_time())
def set_accurate_timing(self, enable):
self._accurate_timing = enable
if self.cue.state == CueState.Pause:
self._update_time(self.cue.current_time(), True)
elif self.cue.state != CueState.Running:
self._update_duration(self.cue.duration)
def show_seek_slider(self, visible):
self.seekSlider.setVisible(visible)
self.update()
def show_dbmeters(self, visible):
if isinstance(self.cue, MediaCue):
self._show_dbmeter = visible
if self._dbmeter_element is not None:
self._dbmeter_element.level_ready.disconnect(self.dbMeter.plot)
self._dbmeter_element = None
if visible:
self._dbmeter_element = self.cue.media.element('DbMeter')
if self._dbmeter_element is not None:
self._dbmeter_element.level_ready.connect(self.dbMeter.plot)
self.layout().addWidget(self.dbMeter, 0, 1)
self.layout().setColumnStretch(1, 1)
self.dbMeter.show()
else:
self.dbMeter.hide()
self.layout().setColumnStretch(1, 0)
self.update()
def _set_cue(self, cue):
self.cue = cue
self.cue.changed('name').connect(self._update_name, Connection.QtQueued)
self.cue.changed('stylesheet').connect(self._update_style, Connection.QtQueued)
self.cue.changed('duration').connect(self._update_duration, Connection.QtQueued)
self.cue.changed('description').connect(self._update_description, Connection.QtQueued)
if isinstance(cue, MediaCue):
self.cue.media.changed('pipe').connect(self._media_updated)
self.cue.paused.connect(self.dbMeter.reset, Connection.QtQueued)
self.cue.stopped.connect(self.dbMeter.reset, Connection.QtQueued)
self.cue.end.connect(self.dbMeter.reset, Connection.QtQueued)
self.cue.error.connect(self.dbMeter.reset, Connection.QtQueued)
self.seekSlider.sliderMoved.connect(self.cue.media.seek)
self.seekSlider.sliderJumped.connect(self.cue.media.seek)
# Cue status changed
self.cue.started.connect(self._status_playing, Connection.QtQueued)
self.cue.stopped.connect(self._status_stopped, Connection.QtQueued)
self.cue.paused.connect(self._status_paused, Connection.QtQueued)
self.cue.error.connect(self._status_error, Connection.QtQueued)
self.cue.end.connect(self._status_stopped, Connection.QtQueued)
self._cue_time = CueTime(self.cue)
self._cue_time.notify.connect(self._update_time)
self._update_name(cue.name)
self._update_style(cue.stylesheet)
self._update_duration(self.cue.duration)
def _media_updated(self):
self.show_dbmeters(self._show_dbmeter)
new_fade = self.cue.media.element('Fade')
if new_fade is not self._fade_element:
if self._fade_element is not None:
self._fade_element.enter_fadein.disconnect(self._enter_fadein)
self._fade_element.enter_fadeout.disconnect(self._enter_fadeout)
self._fade_element.exit_fadein.disconnect(self._exit_fade)
self._fade_element.exit_fadeout.disconnect(self._exit_fade)
if new_fade is not None:
self._fade_element = new_fade
self._fade_element.enter_fadein.connect(self._enter_fadein)
self._fade_element.enter_fadeout.connect(self._enter_fadeout)
self._fade_element.exit_fadein.connect(self._exit_fade)
self._fade_element.exit_fadeout.connect(self._exit_fade)
def _update_name(self, name):
self.nameButton.setText(name)
def _update_description(self, description):
self.nameButton.setToolTip(description)
def _clicked(self, event):
if not self.seekSlider.geometry().contains(event.pos()):
if event.button() != Qt.RightButton:
if event.modifiers() == Qt.ShiftModifier:
self.edit_request.emit(self.cue)
elif event.modifiers() == Qt.ControlModifier:
self.selected = not self.selected
else:
self.cue_executed.emit(self.cue)
self.cue.execute()
def _update_style(self, stylesheet):
stylesheet += 'text-decoration: underline;' if self.selected else ''
self.nameButton.setStyleSheet(stylesheet)
def _enter_fadein(self):
p = self.timeDisplay.palette()
p.setColor(p.WindowText, QColor(0, 255, 0))
self.timeDisplay.setPalette(p)
def _enter_fadeout(self):
p = self.timeDisplay.palette()
p.setColor(p.WindowText, QColor(255, 50, 50))
self.timeDisplay.setPalette(p)
def _exit_fade(self):
self.timeDisplay.setPalette(self.timeBar.palette())
def _status_stopped(self):
self.statusIcon.setPixmap(CueWidget.STOP.pixmap(CueWidget.ICON_SIZE,
CueWidget.ICON_SIZE))
self._update_time(0, True)
def _status_playing(self):
self.statusIcon.setPixmap(CueWidget.START.pixmap(CueWidget.ICON_SIZE,
CueWidget.ICON_SIZE))
def _status_paused(self):
self.statusIcon.setPixmap(CueWidget.PAUSE.pixmap(CueWidget.ICON_SIZE,
CueWidget.ICON_SIZE))
def _status_error(self, cue, error, details):
self.statusIcon.setPixmap(CueWidget.ERROR.pixmap(CueWidget.ICON_SIZE,
CueWidget.ICON_SIZE))
QDetailedMessageBox.dcritical(self.cue.name, error, details)
def _update_duration(self, duration):
# Update the maximum values of seek-slider and time progress-bar
if duration > 0:
if not self.timeBar.isVisible():
self.layout().addWidget(self.timeBar, 1, 0, 1, 2)
self.layout().setRowStretch(1, 1)
self.timeBar.show()
self.timeBar.setMaximum(duration)
self.seekSlider.setMaximum(duration)
else:
self.timeBar.hide()
self.layout().setRowStretch(1, 0)
# If not in playing or paused update the widget showed time
if self.cue.state != CueState.Running or self.cue.state != CueState.Running:
self._update_time(duration, True)
def _update_time(self, time, ignore_visibility=False):
if ignore_visibility or not self.visibleRegion().isEmpty():
# If the given value is the duration or < 0 set the time to 0
if time == self.cue.duration or time < 0:
time = 0
# Set the value the seek slider
self.seekSlider.setValue(time)
# If in count-down mode the widget will show the remaining time
if self._countdown_mode:
time = self.cue.duration - time
# Set the value of the timer progress-bar
if self.cue.duration > 0:
self.timeBar.setValue(time)
# Show the time in the widget
self.timeDisplay.display(strtime(time, accurate=self._accurate_timing))
def resizeEvent(self, event):
self.update()
def update(self):
super().update()
self.layout().activate()
xdim = self.nameButton.width()
ydim = self.nameButton.height() / 5
ypos = self.nameButton.height() - ydim
self.seekSlider.setGeometry(0, ypos, xdim, ydim)
self.statusIcon.setGeometry(4, 4, CueWidget.ICON_SIZE,
CueWidget.ICON_SIZE)
class GeneralsTab(QWidget):
def __init__(self, bus, bms_com):
super().__init__()
self.com1 = bms_com
self.bus = bus
'''self.warning_label = QLabel()
warning_layout = QHBoxLayout()
warning_layout.addStretch()
warning_layout.addWidget(self.warning_label)
warning_layout.addStretch()'''
#set state of charge layout
self.stateofcharge = QLabel('State of Charge:')
self.percentage = QLabel('%')
self.line = QLineEdit()
#self.fillBlanks('soc', self.line)
self.line.setFixedWidth(40)
self.line.setReadOnly(True)
self.logo = QLabel('')
self.i = QPixmap('C:/Users/iheb/BMS_UI/icons/State of charge.ico')
self.logo.setPixmap(self.i.scaled(30, 30))
h_box0 = QHBoxLayout()
h_box0.addSpacing(30)
h_box0.addWidget(self.logo)
h_box0.addWidget(self.stateofcharge)
h_box0.addWidget(self.line)
h_box0.addWidget(self.percentage)
h_box0.addStretch()
# set GeneralVolatge Layout
self.voltage = QLabel("Battery Voltage")
self.line2 = QLineEdit()
self.line2.setFixedWidth(50)
self.line2.setReadOnly(True)
self.v = QLabel('V')
self.logo1 = QLabel('')
self.i1 = QPixmap('C:/Users/iheb/BMS_UI/icons/voltage.ico')
self.logo1.setPixmap(self.i1.scaled(30, 30))
h_box2 = QHBoxLayout()
h_box2.addSpacing(30)
h_box2.addWidget(self.logo1)
h_box2.addWidget(self.voltage)
h_box2.addWidget(self.line2)
h_box2.addWidget(self.v)
h_box2.addStretch()
# set SC Layout
self.sc = QLabel("Shutdown Circuit")
self.line3 = QLineEdit()
self.line3.setFixedWidth(50)
self.line3.setReadOnly(True)
self.logo2 = QLabel('')
self.i2 = QPixmap('C:/Users/iheb/BMS_UI/icons/sc.png')
self.logo2.setPixmap(self.i2.scaled(30, 30))
h_box3 = QHBoxLayout()
h_box3.addSpacing(30)
h_box3.addWidget(self.logo2)
h_box3.addWidget(self.sc)
h_box3.addWidget(self.line3)
h_box3.addStretch()
#set Current (strom) layout
self.current = QLabel("Battery Current (Strom)")
self.line4 = QLineEdit()
self.line4.setFixedWidth(50)
self.line4.setReadOnly(True)
self.c = QLabel('mA')
self.logo3 = QLabel('')
self.i3 = QPixmap('C:/Users/iheb/BMS_UI/icons/Strom.ico')
self.logo3.setPixmap(self.i3.scaled(30, 30))
h_box4 = QHBoxLayout()
h_box4.addSpacing(30)
h_box4.addWidget(self.logo3)
h_box4.addWidget(self.current)
h_box4.addWidget(self.line4)
h_box4.addWidget(self.c)
h_box4.addStretch()
# first vertical layout that contains 5 horizental ones
v_box1 = QVBoxLayout()
v_box1.addSpacing(30)
v_box1.addLayout(h_box0)
v_box1.addStretch()
v_box1.addLayout(h_box4)
v_box1.addStretch()
v_box1.addLayout(h_box2)
v_box1.addStretch()
v_box1.addLayout(h_box3)
# max voltage layout
self.vm = QLabel('Voltage Max:')
self.line5 = QLineEdit()
self.line5.setFixedWidth(50)
self.line5.setReadOnly(True)
self.logo8 = QLabel('')
self.i8 = QPixmap('C:/Users/iheb/BMS_UI/icons/maxVoltage.png')
self.logo8.setPixmap(self.i8.scaled(30, 30))
self.v1 = QLabel('V')
h_box5 = QHBoxLayout()
h_box5.addSpacing(30)
h_box5.addWidget(self.logo8)
h_box5.addWidget(self.vm)
h_box5.addWidget(self.line5)
h_box5.addWidget(self.v1)
h_box5.addStretch()
# min Voltage Layout
self.prStartTime = QLabel('Voltage Min:')
self.line6 = QLineEdit()
self.line6.setFixedWidth(50)
self.line6.setReadOnly(True)
self.logo4 = QLabel('')
self.i4 = QPixmap('C:/Users/iheb/BMS_UI/icons/minVoltage.png')
self.logo4.setPixmap(self.i4.scaled(30, 30))
self.s = QLabel('mV')
h_box6 = QHBoxLayout()
h_box6.addSpacing(30)
h_box6.addWidget(self.logo4)
h_box6.addWidget(self.prStartTime)
h_box6.addWidget(self.line6)
h_box6.addWidget(self.s)
h_box6.addStretch()
# max temperature Layout
self.failTime = QLabel('Temperature Max:')
self.line7 = QLineEdit()
self.line7.setFixedWidth(50)
self.line7.setReadOnly(True)
self.logo5 = QLabel('')
self.i5 = QPixmap('C:/Users/iheb/BMS_UI/icons/maxTemperature.png')
self.logo5.setPixmap(self.i5.scaled(30, 30))
self.s1 = QLabel('C°')
h_box7 = QHBoxLayout()
h_box7.addSpacing(30)
h_box7.addWidget(self.logo5)
h_box7.addWidget(self.failTime)
h_box7.addWidget(self.line7)
h_box7.addWidget(self.s1)
h_box7.addStretch()
# min Temperature Layout
self.upTime = QLabel('Temperature Min:')
self.line8 = QLineEdit()
self.line8.setFixedWidth(50)
self.line8.setReadOnly(True)
self.logo6 = QLabel('')
self.i6 = QPixmap('C:/Users/iheb/BMS_UI/icons/minTemperature.png')
self.logo6.setPixmap(self.i6.scaled(30, 30))
self.s2 = QLabel('C°')
h_box8 = QHBoxLayout()
h_box8.addSpacing(30)
h_box8.addWidget(self.logo6)
h_box8.addWidget(self.upTime)
h_box8.addWidget(self.line8)
h_box8.addWidget(self.s2)
h_box8.addStretch()
# second vertical layout that contains 5 horizental ones
v_box2 = QVBoxLayout()
v_box2.addSpacing(30)
v_box2.addLayout(h_box5)
v_box2.addStretch()
v_box2.addLayout(h_box6)
v_box2.addStretch()
v_box2.addLayout(h_box7)
v_box2.addStretch()
v_box2.addLayout(h_box8)
#Transmition error Layout
self.txError = QLabel('Transmition Error: ')
self.line10 = QLineEdit()
self.line10.setFixedWidth(50)
self.line10.setReadOnly(True)
h_box10 = QHBoxLayout()
h_box10.addSpacing(30)
h_box10.addWidget(self.txError)
h_box10.addWidget(self.line10)
h_box10.addStretch()
# set current State layout
self.state = QLabel("Current State: ")
self.line1 = QLineEdit()
self.line1.setFixedWidth(120)
self.line1.setReadOnly(True)
h_box1 = QHBoxLayout()
h_box1.addSpacing(30)
h_box1.addWidget(self.state)
h_box1.addWidget(self.line1)
h_box1.addStretch()
# dcLink Voltage Layout
self.HV_state = QLabel('HV Button:')
self.line9 = QLineEdit('off')
self.line9.setFixedWidth(30)
self.line9.setReadOnly(True)
self.v2 = QLabel('V')
h_box9 = QHBoxLayout()
h_box9.addSpacing(30)
h_box9.addWidget(self.HV_state)
h_box9.addWidget(self.line9)
#h_box9.addWidget(self.v2)
h_box9.addStretch()
#start balancing command
self.startBalancing = QPushButton('Start Balancing')
self.logo7 = QLabel('')
self.i7 = QPixmap('C:/Users/iheb/BMS_UI/icons/balancing.png')
self.logo7.setPixmap(self.i7.scaled(30, 30))
self.respond = QLabel(' ')
#HV_Button_simuator
self.HVButton = QPushButton('HV Button')
self.logo9 = QLabel('')
self.i9 = QPixmap('C:/Users/iheb/BMS_UI/icons/HV.png')
self.logo9.setPixmap(self.i9.scaled(30, 30))
self.respond1 = QLabel()
self.i_hv = QPixmap('C:/Users/iheb/BMS_UI/icons/respond.png')
h_box15 = QHBoxLayout()
h_box15.addSpacing(30)
h_box15.addWidget(self.logo7)
h_box15.addSpacing(10)
h_box15.addWidget(self.startBalancing)
h_box15.addStretch()
h_box15.addWidget(self.respond)
h_box15.addStretch()
h_box16 = QHBoxLayout()
h_box16.addSpacing(30)
h_box16.addWidget(self.logo9)
h_box16.addSpacing(10)
h_box16.addWidget(self.HVButton)
h_box16.addStretch()
h_box16.addWidget(self.respond1)
h_box16.addStretch()
v_box4 = QVBoxLayout()
v_box4.addLayout(h_box15)
v_box4.addStretch()
v_box4.addLayout(h_box16)
v_box4.addStretch()
# AirLsAux Layout
'''self.airls = QLabel('AirLSAux: ')
self.line11 = QLineEdit()
self.line11.setFixedWidth(30)
self.line11.setReadOnly(True)
h_box11 = QHBoxLayout()
h_box11.addSpacing(30)
h_box11.addWidget(self.airls)
h_box11.addWidget(self.line11)
h_box11.addStretch()
# AirHsAux Layout
self.airhs = QLabel('AirHSAux: ')
self.line12 = QLineEdit()
self.line12.setFixedWidth(30)
self.line12.setReadOnly(True)
h_box12 = QHBoxLayout()
h_box12.addSpacing(30)
h_box12.addWidget(self.airhs)
h_box12.addWidget(self.line12)
h_box12.addStretch()
# HV Button Layout
self.hvButton = QLabel('HV Button: ')
self.line13 = QLineEdit()
self.line13.setFixedWidth(30)
self.line13.setReadOnly(True)
h_box13 = QHBoxLayout()
h_box13.addSpacing(30)
h_box13.addWidget(self.hvButton)
h_box13.addWidget(self.line13)
h_box13.addStretch()
# Start Load Layout
self.startLoad = QLabel('StartLoad: ')
self.line14 = QLineEdit()
self.line14.setFixedWidth(30)
self.line14.setReadOnly(True)
h_box14 = QHBoxLayout()
h_box14.addSpacing(30)
h_box14.addWidget(self.startLoad)
h_box14.addWidget(self.line14)
h_box14.addStretch()'''
#third vertical layout that contains 5 horizental ones
v_box3 = QVBoxLayout()
v_box3.addSpacing(30)
v_box3.addLayout(h_box10)
v_box3.addStretch()
v_box3.addLayout(h_box1)
v_box3.addStretch()
v_box3.addLayout(h_box9)
v_box3.addStretch()
v_box3.addLayout(v_box4)
#horizental layout containing the fan controlling slider
self.comment = QLabel('Enable')
self.enable = QCheckBox()
self.fan = QLabel('Fan Controller: ')
self.lcd = QLCDNumber(self)
self.sld = QSlider(Qt.Horizontal, self)
self.sld.setMinimum(0)
self.sld.setMaximum(100)
self.sld.setTickInterval(1)
palette = self.lcd.palette()
palette.setColor(palette.Light, QColor(255, 0, 0))
self.lcd.setPalette(palette)
self.lcd.setFixedSize(55, 30)
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.comment)
hbox.addWidget(self.enable)
hbox.addWidget(self.fan)
hbox.addWidget(self.sld)
hbox.addSpacing(30)
hbox.addWidget(self.lcd)
hbox.addStretch()
# set general layout
v_box0 = QVBoxLayout()
h_box = QHBoxLayout()
h_box.addLayout(v_box1)
h_box.addStretch()
h_box.addLayout(v_box2)
h_box.addStretch()
h_box.addLayout(v_box3)
h_box.addSpacing(30)
#v_box0.addLayout(warning_layout)
v_box0.addLayout(h_box)
v_box0.addSpacing(30)
v_box = QVBoxLayout()
v_box.addLayout(v_box0)
v_box.addLayout(hbox)
self.setLayout(v_box)
self.t = QTimer() #timer for the Balancing response
self.t1 = QTimer() #timer for the HV Button response
self.ie = QPixmap('C:/Users/iheb/BMS_UI/icons/error.png')
self.i = QPixmap('C:/Users/iheb/BMS_UI/icons/respond.png')
def fillBlanks(
self
): #methode that times the filling of the labels from the general tab
self.timer1 = QTimer()
self.timer1.timeout.connect(lambda: self.setData())
self.timer1.start(2000)
def setData(self): #methode that enables the data to be set
"""self.d = self.data
threading.Thread(target= self.d.fillData(140, 'soc')).start()
threading.Thread(target=self.d.fillData(140, 'cs')).start()
threading.Thread(target=self.d.fillData(140, 'bc')).start()
threading.Thread(target=self.d.fillData(140, 'bv')).start()
threading.Thread(target=self.d.fillData(140, 'sc')).start()
threading.Thread(target=self.d.fillData(140, 'hvb')).start()
threading.Thread(target=self.d.fillData(140, 'te')).start()
threading.Thread(target=self.d.fillData(140, 'mxV')).start()
threading.Thread(target=self.d.fillData(140, 'mnV')).start()
threading.Thread(target=self.d.fillData(140, 'mxT')).start()
threading.Thread(target=self.d.fillData(140, 'mnT')).start()"""
self.line.setText(str(BMS_Data.getdata(cell=1, type='soc')))
self.line1.setText(str(BMS_Data.getdata(cell=1, type='cs')))
#print(str(BMS_Data.getdata(cell=1, type='cs')))
self.line2.setText(str(BMS_Data.getdata(cell=1, type='bv')))
#print(str(BMS_Data.getdata(cell=1, type='bv')))
self.line3.setText(str(BMS_Data.getdata(cell=1, type='sc')))
#print(str(BMS_Data.getdata(cell=1, type='sc')))
self.line4.setText(str(BMS_Data.getdata(cell=1, type='bc')))
#print(str(BMS_Data.getdata(cell=1, type='bc')))
self.line5.setText(str(BMS_Data.getdata(cell=1, type='mxV')))
#print(str(BMS_Data.getdata(cell=1, type='mxV')))
self.line6.setText(str(BMS_Data.getdata(cell=1, type='mnV')))
#print(str(BMS_Data.getdata(cell=1, type='mnV')))
self.line7.setText(str(BMS_Data.getdata(cell=1, type='mxT')))
#print(str(BMS_Data.getdata(cell=1, type='mxT')))
self.line8.setText(str(BMS_Data.getdata(cell=1, type='mnT')))
#print(str(BMS_Data.getdata(cell=1, type='mnT')))
self.line9.setText(str(BMS_Data.getdata(cell=1, type='hvb')))
#print(str(BMS_Data.getdata(cell=1, type='hvb')))
self.line10.setText(str(BMS_Data.getdata(cell=1, type='te')))
#print(str(BMS_Data.getdata(cell=1, type='te')))
#self.line11.setText(str(self.d.getdata(cell=1, type='airLsAux')))
#self.line12.setText(str(self.d.getdata(cell=1, type='airHsAux')))
#self.line13.setText(str(self.d.getdata(cell=1, type='hvb')))
#self.line14.setText(str(self.d.getdata(cell=1, type='sl')))
def start_Balancing(self):
self.respond.setMinimumSize(30, 30)
if BMS_ControlParameter.getConnectionState():
try:
if self.sender().text() == 'Start Balancing':
self.startBalancing.setText('Stop Balancing')
self.com1.balancing(self.bus)
print('balancing on')
self.respond.setPixmap(self.i.scaled(30, 30))
self.t.timeout.connect(lambda: threading.Thread(
target=self.response(self.t, self.respond)).start())
self.t.start(2000)
else:
self.startBalancing.setText('Start Balancing')
self.com1.stop_balancing(self.bus)
print('balancing off')
self.respond.setPixmap(self.i.scaled(30, 30))
self.t.timeout.connect(lambda: threading.Thread(
target=self.response(self.t, self.respond)).start())
self.t.start(2000)
except Exception as e:
self.respond.setPixmap(self.ie.scaled(30, 30))
logging.error(traceback.format_exc())
else:
print("you need to be connected")
def response(self, timer, label):
label.clear()
timer.stop()
def HV_clicked(self):
self.respond1.setMinimumSize(30, 30)
if BMS_ControlParameter.getConnectionState():
try:
BMS_Data.setHv(1)
self.com1.HV_simulate(self.bus)
self.respond1.setPixmap(self.i_hv.scaled(30, 30))
#self.t1.timeout.connect(lambda: threading.Thread(target=self.response(self.t1,self.respond1)).start())
#self.t1.start(2000)
except Exception as e:
self.respond1.setPixmap(self.ie.scaled(30, 30))
logging.error(traceback.format_exc())
else:
print("you need to be connected")
"""def no_pcan(self):
self.warning_label.setText('NO PCAN ADAPTER IS DETECTED, PLEASE PLUG ADAPTER AND RESTART THE PROGRAM')"""
def controlFan(self, x):
if self.enable.isChecked(
): #the check box needs to be checked in order to execute any command
if BMS_ControlParameter.getConnectionState(
): #there needs to be connection in order to execute any command
try:
print(x)
if (x >= 0) and (x <= 100):
self.com1.sendFanControl(self.bus, x)
except Exception as e:
#self.enable.setChecked(False)
logging.error(traceback.format_exc())
else:
print("you need to be connected")
def sendUserFlag(self):
sender = self.sender()
if BMS_ControlParameter.getConnectionState() and sender.isChecked():
self.com1.setUserFlag(self.bus)
print('set')
elif BMS_ControlParameter.getConnectionState() and not (
sender.isChecked()):
self.com1.resetUserFlag(self.bus)
print('reset')
else:
print('not Connected')
####################################################################################################################
