class CountDownWidget(QWidget):
def __init__(self, parent=None):
# コンストラクタ
QWidget.__init__(self, parent=parent)
self.interval = 10
self.setup_ui()
def setup_ui(self):
self.setAutoFillBackground(True)
p = self.palette()
p.setColor(self.backgroundRole(), QtCore.Qt.white)
self.setPalette(p)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.timer = QtCore.QTimer(parent=self)
self.timer.setInterval(self.interval)
self.timer.timeout.connect(self.do_countdown)
self.lcd_number = QLCDNumber(parent=self)
self.lcd_number.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.lcd_number.setFrameStyle(QFrame.NoFrame)
self.lcd_number.setSegmentStyle(QLCDNumber.Flat)
self.lcd_number.setDigitCount(6)
layout = QVBoxLayout()
layout.addWidget(self.lcd_number)
self.setLayout(layout)
self.reset_count()
def update_display(self):
self.lcd_number.display("%6.2f" % (self.count / 100))
self.lcd_number.update()
def do_countdown(self):
self.count -= 1
self.update_display()
if self.count <= 0:
self.stop_countdown()
def start_countdown(self):
if self.count > 0:
self.timer.start()
def stop_countdown(self):
self.timer.stop()
def reset_count(self):
self.count = 18000
self.update_display()
class CountDownWidget(QWidget):
'''
classdocs
'''
def __init__(self, parent=None):
'''
Constructor
'''
QWidget.__init__(self, parent=parent)
self.interval = 10
self.setup_ui()
'''
実際の初期化関数
'''
def setup_ui(self):
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.timer = QTimer(parent=self)
self.timer.setInterval(self.interval)
self.timer.timeout.connect(self.do_countdown)
self.lcd_number = QLCDNumber(parent=self)
self.lcd_number.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.lcd_number.setFrameStyle(QFrame.NoFrame)
self.lcd_number.setSegmentStyle(QLCDNumber.Flat)
self.lcd_number.setDigitCount(6)
layout = QVBoxLayout()
layout.addWidget(self.lcd_number)
self.setLayout(layout)
self.reset_count()
def update_display(self):
self.lcd_number.display("%6.2f" % (self.count / 100))
self.lcd_number.update()
def do_countdown(self):
self.count -= 1
self.update_display()
if self.count <= 0:
self.stopcountdown()
def start_countdown(self):
if self.count > 0:
self.timer.start()
def stop_countdown(self):
self.timer.stop()
def reset_count(self):
self.count = 18000
self.update_display()
class Window(QWidget):
def __init__(self):
super().__init__()
self.showMaximized()
self.setWindowTitle('Barbequer')
self.setWindowIcon(QIcon('BBQ.png'))
self.init()
def init(self):
self.size_policy = (QSizePolicy.Expanding, QSizePolicy.Expanding)
self.font = QFont()
self.font.setPointSize(16)
self.temp_display_label = QLabel(self)
self.temp_display_label.setText('Current Temperature:')
self.temp_display_label.setSizePolicy(self.size_policy[0],
self.size_policy[1])
self.temp_display_label.setFont(self.font)
# self.temp_display_label.setAlignment(Qt.AlignRight)
self.temp_display = QLCDNumber(self)
self.temp_display.setSizePolicy(self.size_policy[0],
self.size_policy[1])
self.temp_display.setFont(self.font)
self.temp_set_label = QLabel(self)
self.temp_set_label.setText('Set Temperature:')
self.temp_set_label.setSizePolicy(self.size_policy[0],
self.size_policy[1])
self.temp_set_label.setFont(self.font)
# self.temp_set_label.setAlignment(Qt.AlignRight)
self.temp_set = QLCDNumber(self)
self.temp_set.setSizePolicy(self.size_policy[0], self.size_policy[1])
self.temp_set.setFont(self.font)
self.temp_dial = QDial(self)
self.temp_dial.setSizePolicy(self.size_policy[0], self.size_policy[1])
self.temp_dial.setProperty('value', 0)
self.temp_dial.setSliderPosition(0)
self.temp_dial.setNotchesVisible(True)
self.temp_dial.setMaximum(600)
self.temp_dial.setToolTip('Set Desired Temperature in Fahrenheit')
self.temp_dial.valueChanged.connect(self.update_temperature)
self.exhasut_fan = QRadioButton('&Enable Exhaust Fan')
self.exhasut_fan.setSizePolicy(self.size_policy[0],
self.size_policy[1])
self.exhasut_fan.setFont(self.font)
self.exhasut_fan.setToolTip('Enable exhaust fan')
self.intake_fan = QRadioButton('&Enable Intake Fan')
self.intake_fan.setSizePolicy(self.size_policy[0], self.size_policy[1])
self.intake_fan.setFont(self.font)
self.intake_fan.setToolTip('Enable intake fan')
self.start_button = QPushButton('Start', self)
self.start_button.setSizePolicy(self.size_policy[0],
self.size_policy[1])
self.start_button.setFont(self.font)
self.start_button.setToolTip('Start Maintaining Temperature')
self.start_button.clicked.connect(self.maintain_temperature)
self.timer_button = QPushButton('Timer', self)
self.timer_button.setSizePolicy(self.size_policy[0],
self.size_policy[1])
self.timer_button.setFont(self.font)
self.timer_button.setToolTip('Cook Time')
qp = QPainter()
qp.begin(self)
qp.setPen(QPen(QColor(255, 80, 0), 3))
qp.setBrush(QColor(255, 80, 0))
qp.drawEllipse(QPoint(50, 60), 30, 30)
qp.end()
#add the grid layout to the interface
self.layout = QGridLayout(self)
self.layout.addWidget(self.temp_dial, 0, 0, 2, 2)
self.layout.addWidget(self.temp_set_label, 2, 0)
self.layout.addWidget(self.temp_set, 2, 1, 1, 2)
self.layout.addWidget(self.temp_display_label, 3, 0)
self.layout.addWidget(self.temp_display, 3, 1)
self.layout.addWidget(self.exhasut_fan, 4, 0)
self.layout.addWidget(self.intake_fan, 4, 1)
self.layout.addWidget(self.start_button, 5, 0)
self.layout.addWidget(self.timer_button, 5, 1)
# self.layout.addWidget(qp,6,1)
def update_temperature(self):
self.temp_set.display(str(self.temp_dial.sliderPosition()))
try:
self.start_button.setEnabled(True)
self.Temp.stop()
except:
'''do nothing here'''
def maintain_temperature(self):
self.Temp = temp_operation(self)
self.start_button.setDisabled(True)
self.Temp.isRunning = False
time.sleep(1)
if self.Temp.isRunning == False:
self.Temp.isRunning = True
self.Temp.set_temp = self.temp_dial.sliderPosition()
self.Temp.display_update.connect(self.temp_display.display)
self.Temp.start()
print(self.Temp.isRunning)
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 Display(QWidget):
def __init__(self):
super().__init__()
self.showMaximized()
self.setWindowTitle('D250 Speedometer v1.0')
font = QFont()
font.setPointSize(16)
self.throttle_position = QProgressBar(self)
self.throttle_position.setFont(font)
self.throttle_position.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.throttle_position.setMaximumHeight(30)
self.speed = QLCDNumber(self)
self.speed.setFont(font)
self.speed.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
#use thread to display value
self.cruise_indicator = QLineEdit(self)
self.cruise_indicator.setReadOnly(True)
self.cruise_indicator.setFont(font)
self.cruise_indicator.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.cruise_indicator.setAlignment(q.Qt.AlignRight)
self.cruise_indicator.setMaximumHeight(100)
self.indicator = QLineEdit(self)
self.indicator.setReadOnly(True)
self.indicator.setFont(font)
self.indicator.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.indicator.setAlignment(q.Qt.AlignRight)
self.indicator.setMaximumHeight(100)
self.set_cruise = QPushButton('Set', self)
self.set_cruise.setCheckable(True)
self.set_cruise.setFont(font)
self.set_cruise.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.set_cruise.clicked.connect(self.sets)
self.resume = QPushButton('Resume', self)
self.resume.setFont(font)
self.resume.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.resume.clicked.connect(self.resumes)
self.cancel = QPushButton('Cancel', self)
self.cancel.setFont(font)
self.cancel.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.cancel.clicked.connect(self.cancels)
self.cruise_state = QPushButton('On\Off', self)
self.cruise_state.setCheckable(True)
self.cruise_state.setFont(font)
self.cruise_state.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.cruise_state.clicked.connect(self.on_off)
'Add the layout to the widget'
layout = QGridLayout()
layout.addWidget(self.speed, 0, 1)
layout.addWidget(self.cruise_indicator, 1, 1)
layout.addWidget(self.indicator, 2, 1)
layout.addWidget(self.resume, 0, 2)
layout.addWidget(self.set_cruise, 1, 0, 2, 1)
layout.addWidget(self.cancel, 1, 2, 2, 1)
layout.addWidget(self.cruise_state, 0, 0)
vlayout = QVBoxLayout()
vlayout.addLayout(layout)
vlayout.addWidget(self.throttle_position)
self.setLayout(vlayout)
self.initUI()
def initUI(self):
'''Setting up the GUI'''
self.th = Thread(self)
self.th.changeprogressbar.connect(self.throttle_position.setValue)
self.th.changelcd.connect(self.speed.display)
self.th.change_odometer.connect(self.cruise_indicator.setText)
self.th.start()
def on_off(self):
'''State of the Cruise Control'''
if self.cruise_state.isChecked() == True:
self.cruise_indicator.setText('On')
elif self.cruise_state.isChecked() == False:
self.cruise_indicator.setText('Off')
def resumes(self):
'''Resumes the pickup to set speed'''
self.cruise_indicator.setText('Resuming')
time.sleep(2)
self.th.change_odometer.connect(self.cruise_indicator.setText)
def cancels(self):
'''Cancels and keeps set speed'''
self.cruise_indicator.setText('Cancels')
time.sleep(2)
self.th.change_odometer.connect(self.cruise_indicator.setText)
def sets(self):
'''Sets the speed for the cruise control'''
self.cruise_indicator.setText('Set')
time.sleep(2)
self.th.change_odometer.connect(self.cruise_indicator.setText)
class Display(QWidget):
def __init__(self):
super().__init__()
self.showMaximized()
self.setWindowTitle('D250 Speedometer v1.0')
font = QFont()
font.setPointSize(16)
#displaying the throttle position from the stepper motor controller
self.throttle_position = QProgressBar(self)
self.throttle_position.setFont(font)
self.throttle_position.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.throttle_position.setMaximumHeight(30)
#use thread to display value
self.speed = QLCDNumber(self)
self.speed.setFont(font)
self.speed.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
#Indication of various vehicle parameters
self.cruise_indicator = QLineEdit(self)
self.cruise_indicator.setReadOnly(True)
self.cruise_indicator.setFont(font)
self.cruise_indicator.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.cruise_indicator.setAlignment(q.Qt.AlignRight)
self.cruise_indicator.setMaximumHeight(100)
#values of vehicle parameters
self.indicator = QLineEdit(self)
self.indicator.setReadOnly(True)
self.indicator.setFont(font)
self.indicator.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.indicator.setAlignment(q.Qt.AlignRight)
self.indicator.setMaximumHeight(100)
#incorporation of cruise control feature to maintain and resume the vehicle speed
self.set_cruise = QPushButton('Set', self)
self.set_cruise.setCheckable(True)
self.set_cruise.setFont(font)
self.set_cruise.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.set_cruise.clicked.connect(self.sets)
self.set_cruise.setDisabled(True)
#resume vehicle speed
self.resume = QPushButton('Resume', self)
self.resume.setFont(font)
self.resume.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.resume.clicked.connect(self.resumes)
self.resume.setDisabled(True)
#cancel cruise
self.cancel = QPushButton('Cancel', self)
self.cancel.setFont(font)
self.cancel.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.cancel.clicked.connect(self.cancels)
self.cancel.setDisabled(True)
#turn cruise on and off
self.cruise_state = QPushButton('On\Off', self)
self.cruise_state.setCheckable(True)
self.cruise_state.setFont(font)
self.cruise_state.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.cruise_state.clicked.connect(self.on_off)
'Add the layout to the widget'
layout = QGridLayout()
layout.addWidget(self.speed, 0, 1)
layout.addWidget(self.cruise_indicator, 1, 1)
layout.addWidget(self.indicator, 2, 1)
layout.addWidget(self.resume, 0, 2)
layout.addWidget(self.set_cruise, 1, 0, 2, 1)
layout.addWidget(self.cancel, 1, 2, 2, 1)
layout.addWidget(self.cruise_state, 0, 0)
vlayout = QVBoxLayout()
vlayout.addLayout(layout)
vlayout.addWidget(self.throttle_position)
self.setLayout(vlayout)
self.initUI()
def initUI(self):
'''Setting up the GUI'''
self.th = Mileage(self)
self.th.changelcd.connect(self.speed.display)
self.th.change_odometer.connect(self.cruise_indicator.setText)
self.th.start()
self.gauges = Gauge_Readouts(self)
self.gauges.values.connect(self.indicator.setText)
self.gauges.start()
def on_off(self):
'''State of the Cruise Control'''
if self.cruise_state.isChecked() == True:
self.cruise_indicator.setText('On')
self.set_cruise.setEnabled(True)
elif self.cruise_state.isChecked() == False:
self.cruise_indicator.setText('Off')
self.cancel.setEnabled(False)
self.resume.setEnabled(False)
self.set_cruise.setEnabled(False)
def resumes(self):
'''Resumes the pickup to set speed'''
self.indicator.setText('Resuming to {:.1f}:'.format(self.set_speed))
self.maintain = Throttle_Position(self.set_speed)
self.maintain.throttle_position.connect(
self.throttle_position.setValue)
self.maintain.start()
def cancels(self):
'''Cancels and keeps set speed'''
self.indicator.setText('Cancel')
self.resume.setEnabled(True)
self.maintain.running = False
def sets(self):
'''Sets the speed for the cruise control'''
self.set_speed = sp.Gauges.find_speed(self)[0]
self.indicator.setText('Set at {:.1f}'.format(self.set_speed))
self.cancel.setEnabled(True)
self.resume.setEnabled(False)
self.maintain = Throttle_Position(self.set_speed)
self.maintain.throttle_position.connect(
self.throttle_position.setValue)
self.maintain.start()
