def __init__(self):
super(MyWindow, self).__init__()
self.initGUI("PyQt5 学习 LCDNumber")
mainLayout = QGridLayout()
self.setLayout(mainLayout)
# 要展示的数据
price = 13.568
amount = 213
id = "18726345"
lbl_price = QLabel("价格:")
lbl_amount = QLabel("数量：")
lbl_id = QLabel("商品编号：")
lcd_price = QLCDNumber()
lcd_price.setDecMode()
lcd_price.setSmallDecimalPoint(True)
lcd_price.display(price)
mainLayout.addWidget(lbl_price, 0, 0)
mainLayout.addWidget(lcd_price, 0, 1, 1, 3)
lcd_amount = QLCDNumber()
lcd_amount.display(amount)
mainLayout.addWidget(lbl_amount, 1, 0)
mainLayout.addWidget(lcd_amount, 1, 1, 1, 3)
lcd_id = QLCDNumber()
lcd_id.setDecMode()
# NOTE: 设置能显示的数字的最大个数，如果不设置大一点，有可能显示不完整
lcd_id.setDigitCount(10)
lcd_id.display(id)
mainLayout.addWidget(lbl_id, 2, 0)
mainLayout.addWidget(lcd_id, 2, 1, 1, 3)
def makeLCD(self,s):
lcd = QLCDNumber()
lcd.setSegmentStyle(2)
lcd.setFrameStyle(QFrame.Plain)
lcd.setSmallDecimalPoint(False)
lcd.setStyleSheet("QLCDNumber { color: %s; background-color: %s;}"%(self.aw.lcdpaletteF[s],self.aw.lcdpaletteB[s]))
return lcd
class MainWidget(QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
layout = QHBoxLayout(self) # Main layout of the widget
# Creating a group box with a title for each of the widget's parts. Adding a layout for each of the group boxes.
box_labels = ['Display', 'Sweep control', 'Switch']
self.group_box = {}
self.group_box_layout = {}
for label in box_labels:
self.group_box_layout[label] = QGridLayout(
) # Creating a layout for each group box
self.group_box[label] = QGroupBox(label) # Creating a group box
self.group_box[label].setLayout(
self.group_box_layout[label]
) # Setting layouts to the group boxes
layout.addWidget(self.group_box[label]
) # Setting group boxes to the main layout
# Creating an lcd number to be a value monitor and adding it to the layout of the 'Display' group box
self.value_lcd = QLCDNumber(6)
self.value_lcd.setSmallDecimalPoint(True)
self.value_lcd.display('0.0000')
self.value_lcd.setFixedSize(320, 85)
self.group_box_layout['Display'].addWidget(self.value_lcd,
0,
0,
4,
1,
alignment=Qt.AlignCenter)
# Creating indicators for all the gui
indicator_labels = [
'Clamped', 'Persistent', 'Sweep limit', 'Quench', 'Hold',
'To zero', 'To set', 'Heater'
]
indicator_orders = [
'i-l', 'i-l', 'i-l', 'i-l', 'l-i', 'l-i', 'l-i', 'l-i'
]
indicator_alignments = ['h', 'h', 'h', 'h', 'v', 'v', 'v', 'v']
self.indicator = {}
self.sweep_control_btn = {}
self.heater_btn = Button()
k = 0
for label, order, alignment in zip(indicator_labels, indicator_orders,
indicator_alignments):
self.indicator[label] = Indicator(label, alignment, order, 12)
if k < 4:
# Adding corresponding indicators to the 'Display' layout
self.group_box_layout['Display'].addWidget(
self.indicator[label], k, 1, alignment=Qt.AlignLeft)
elif k < 7:
# Adding corresponding indicators to the 'Sweep control' layout. Also creating buttons and adding
# them as well
self.group_box_layout['Sweep control'].addWidget(
self.indicator[label], 0, k, alignment=Qt.AlignCenter)
self.sweep_control_btn[label] = Button()
self.group_box_layout['Sweep control'].addWidget(
self.sweep_control_btn[label],
1,
k,
alignment=Qt.AlignCenter)
else:
# Adding a 'Heater' indicator to the 'Switch' group box layout. Adding a button to switch the heater
self.group_box_layout['Switch'].addWidget(
self.indicator[label], 0, 0, alignment=Qt.AlignCenter)
self.group_box_layout['Switch'].addWidget(
self.heater_btn, 1, 0, alignment=Qt.AlignCenter)
k += 1
class WavemeterChannelMonitor(WavemeterClient):
"""
Connects to a :class:`WavemeterServer` to monitor a channel wavelength, temperature or pressure. There are three
available GUI elements: a stripchart plot, a scalable number display, and an interferogram plot.
:param host: the address at which the :class:`WavemeterServer` publisher is running
:param channel: wavemeter channel (can be either <n>, '<n>', 'ch<n>', 'T' or 'p')
:param port: port of the publisher
:param rpc_host: host of the wavemeter server (only needed for interferograms, default = same as publisher)
:param rpc_port: port of the wavemeter server rpc target (only needed for interferograms)
:param rpc_target: target name for rpcs (only needed for interferograms)
:param title: the window title (generated from the server details by default)
:param window_width: initial width of the window in pixels
:param window_x: initial x position of the window in pixels
:param window_y: initial y position of the window in pixels
:param enable_stripchart: show the stripchart
:param stripchart_height: initial stripchart height in pixels
:param stripchart_num_points: number of data points displayed in the stripchart
:param plot_freq: True for frequency plot, False for wavelength plot
:param plot_offset: y offset of the plot (unit is MHz for frequencies and nm for wavelengths)
:param plot_pen: pen specification for the plot trace (see pyqtgraph documentation)
:param plot_symbol: symbol specification for the plot points
:param plot_bgr: bgr color of the plot
:param enable_lcd: show the current value (wavelength or frequency) as a scalable number
:param lcd_height: lcd height in pixels
:param lcd_ndigits: number of digits in the lcd
:param lcd_freq: start with the number display showing the frequency (default is wavelength)
:param enable_interferograms: display the interferograms
:param interferogram_update_interval: number of values after which to update the interferograms
:param show_interferogram_update_control: show the spinbox to adjust interferogram update rate
:param if0_pen: pen specification for the 1st interferogram
:param if1_pen: pen specification for the 2nd interferogram
:param interferogram_bgr: bgr color of the interferogram plot
:param interferogram_height: initial height of the interferogram plot in pixels
:param interferogram_exposure_control: enable control of wavemeter exposure times
"""
def __init__(self, host: str = "::1", channel: str = "ch1",
port: int = 3281, rpc_host: str = "", rpc_port: int = 3280, rpc_target="wavemeter_server",
title: str = None, window_width: int = 611, window_x: int = 0, window_y: int = 0,
enable_stripchart: bool = True, stripchart_height: int = 350, stripchart_num_points: int = 100,
plot_freq: bool = True, plot_offset: float = 0., plot_pen: Any = pyqtgraph.mkPen(color="k", width=3),
plot_symbol: Any = None, plot_bgr: str = "w", enable_lcd: bool = True, lcd_height: int = 160,
lcd_ndigits: int = 10, lcd_freq: bool = False, enable_interferograms: bool = False,
interferogram_update_interval: int = 1, show_interferogram_update_control: bool = False,
if0_pen: Any = pyqtgraph.mkPen(color="g", width=1),
if1_pen: Any = pyqtgraph.mkPen(color="b", width=1), interferogram_bgr: str = "w",
interferogram_height: int = 150, interferogram_exposure_control: bool = False):
# user interface components
self._enable_stripchart = enable_stripchart
self._enable_lcd = enable_lcd
self._enable_interferograms = enable_interferograms
self.lcd_ndigits = lcd_ndigits
self.stripchart_pen = plot_pen
self.stripchart_symbol = plot_symbol
self.stripchart_bgr = plot_bgr
self._app = QApplication(sys.argv)
self._loop = QEventLoop(self._app)
asyncio.set_event_loop(self._loop)
self.plot_freq = plot_freq
self.plot_offset = plot_offset
self.lcd_freq = lcd_freq
try: # accept integer (or string lacking the "ch" prefix) as channel argument
self.channel = "ch{}".format(int(channel))
except ValueError:
self.channel = channel
self.not_a_wavelength = (self.channel in ["T", "p"]) # disable frequency conversion options for T and p
if self.not_a_wavelength:
self.plot_freq = False
self.lcd_freq = False
self._enable_interferograms = False
self.title = title if title is not None else "{} monitor ({}:{})".format(channel, host, port)
if self._enable_interferograms and not self.not_a_wavelength:
channel_id = int(self.channel[2:])
self.interferograms = InterferogramWidget(rpc_host=rpc_host, rpc_port=rpc_port, rpc_target=rpc_target,
channel_id=channel_id, if0_pen=if0_pen, if1_pen=if1_pen,
bgr_color=interferogram_bgr,
update_interval=interferogram_update_interval,
show_interval_spinbox=show_interferogram_update_control,
show_exposure_ctrl=interferogram_exposure_control)
self._build_ui(window_width, window_x, window_y, stripchart_height, stripchart_num_points, lcd_height,
interferogram_height)
super().__init__(self.channel, host, port, self._loop)
def _build_ui(self, window_width, window_x, window_y, stripchart_height, stripchart_num_points, lcd_height,
interferogram_height):
self.window = QWidget()
self.window.setWindowTitle(self.title)
window_height = stripchart_height * self._enable_stripchart \
+ lcd_height * self._enable_lcd \
+ interferogram_height * self._enable_interferograms
self.window.resize(window_width, window_height)
self.window.move(window_x, window_y)
# The layout only contains one element (the splitter), but it is needed to rescale widgets as window is rescaled
self.v_layout = QVBoxLayout()
self.v_splitter = QSplitter(Qt.Vertical)
self.v_layout.addWidget(self.v_splitter)
self.window.setLayout(self.v_layout)
self.v_layout.addWidget(self.v_splitter)
splitter_sizes = []
if self._enable_stripchart:
self._build_stripchart(stripchart_num_points)
splitter_sizes.append(stripchart_height)
if self._enable_lcd:
self._build_lcd()
splitter_sizes.append(lcd_height)
if self._enable_interferograms:
self.v_splitter.addWidget(self.interferograms)
splitter_sizes.append(interferogram_height)
self.v_splitter.setSizes(splitter_sizes)
def _build_stripchart(self, num_points):
plot_title = ""
if self.plot_freq:
plot_y_label = "frequency (MHz)"
if self.plot_offset != 0:
plot_title = "offset: {:11} THz".format(self.plot_offset * 1e-6)
else:
if self.channel == "T":
plot_y_label = "temperature (degrees C)"
if self.plot_offset != 0:
plot_title = "offset: {:5} degrees C".format(self.plot_offset)
elif self.channel == "p":
plot_y_label = "pressure (mbar)"
if self.plot_offset != 0:
plot_title = "offset: {:6} mbar".format(self.plot_offset)
else:
plot_y_label = "vac. wavelength (nm)"
if self.plot_offset != 0:
plot_title = "offset: {:10} nm".format(self.plot_offset)
self.stripchart = Stripchart(num_points=num_points, xvalues=True, offset=self.plot_offset,
plot_title=plot_title, plot_pen=self.stripchart_pen,
plot_symbol=self.stripchart_symbol, plot_bgr=self.stripchart_bgr,
x_label="wavemeter time stamp (s)", y_label=plot_y_label, y_grid=True)
clear_button = QPushButton("&Clear")
clear_button.clicked.connect(self.stripchart.clear_data)
layout = QVBoxLayout()
layout.addWidget(self.stripchart)
layout.addWidget(clear_button)
widget = QWidget()
widget.setLayout(layout)
self.v_splitter.addWidget(widget)
def _add_stripchart_point(self):
if self.value < 0: # ignore error codes
return
if self.plot_freq: # plot frequency in MHz
self.stripchart.add_point(self.timestamp * 1e-3, 299792456e3 / self.value)
else: # plot wavelength in nm
self.stripchart.add_point(self.timestamp * 1e-3, self.value)
def _build_lcd(self):
layout = QVBoxLayout()
self.lcd = QLCDNumber()
self.lcd.setSmallDecimalPoint(True)
self.lcd.setDigitCount(self.lcd_ndigits)
freq_checkbox = QCheckBox("Display frequency")
freq_checkbox.setChecked(self.lcd_freq)
def switch_wl_freq():
self.lcd_freq = freq_checkbox.isChecked()
self._update_lcd()
freq_checkbox.clicked.connect(switch_wl_freq)
layout.addWidget(self.lcd)
if not self.not_a_wavelength:
layout.addWidget(freq_checkbox)
widget = QWidget()
widget.setLayout(layout)
self.v_splitter.addWidget(widget)
def _update_lcd(self):
if self.value > 0:
value = 299792456e-3 / self.value if self.lcd_freq else self.value
# next line is to keep number of decimals constant (i.e. display trailing zeros)
self.lcd.display("{{:.0{}f}}".format(self.lcd_ndigits-len(str(int(value)))).format(value))
elif self.value == -2: # bad signal
self.lcd.display("b")
elif self.value == -3: # underexposed
self.lcd.display("u")
elif self.value == -4: # overexposed
self.lcd.display("o")
else:
self.lcd.display(self.value)
def _init_callback(self):
if self._enable_lcd:
self._update_lcd()
if self._enable_interferograms:
self.interferograms.update_data()
def _new_value_callback(self):
if self._enable_stripchart:
self._add_stripchart_point()
if self._enable_lcd:
self._update_lcd()
if self._enable_interferograms:
self.interferograms.update_data()
def run(self):
self.window.show()
self._loop.run_forever()
if self._subscriber is not None:
self._loop.run_until_complete(self._subscriber.close())
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(784, 600)
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.Time = QLCDNumber(self.centralwidget)
self.Time.setGeometry(QRect(260, 80, 271, 121))
self.Time.setFrameShape(QFrame.Box)
self.Time.setFrameShadow(QFrame.Sunken)
self.Time.setLineWidth(1)
self.Time.setMidLineWidth(0)
self.Time.setSmallDecimalPoint(False)
self.Time.setDigitCount(8)
self.Time.setObjectName("lcdNumber")
self.label = QLabel(self.centralwidget)
self.label.setGeometry(QRect(220, 0, 341, 61))
font = QFont()
font.setBold(False)
font.setWeight(50)
self.label.setFont(font)
self.label.setFocusPolicy(Qt.NoFocus)
self.label.setFrameShape(QFrame.NoFrame)
self.label.setTextFormat(Qt.AutoText)
self.label.setScaledContents(False)
self.label.setAlignment(Qt.AlignCenter)
self.label.setIndent(-1)
self.label.setObjectName("label")
self.line = QFrame(self.centralwidget)
self.line.setGeometry(QRect(0, 40, 831, 31))
self.line.setFrameShape(QFrame.HLine)
self.line.setFrameShadow(QFrame.Sunken)
self.line.setObjectName("line")
self.line_2 = QFrame(self.centralwidget)
self.line_2.setGeometry(QRect(0, 220, 801, 31))
self.line_2.setFrameShape(QFrame.HLine)
self.line_2.setFrameShadow(QFrame.Sunken)
self.line_2.setObjectName("line_2")
self.Melody = QPushButton(self.centralwidget)
self.Melody.setGeometry(QRect(-270, 240, 1091, 61))
self.Melody.setObjectName("pushButton")
self.Pause = QPushButton(self.centralwidget)
self.Pause.setGeometry(QRect(520, 370, 81, 81))
self.Pause.setDefault(True)
self.Pause.setFlat(False)
self.Pause.setObjectName("pushButton_2")
self.Stop = QPushButton(self.centralwidget)
self.Stop.setGeometry(QRect(190, 370, 81, 81))
self.Stop.setDefault(True)
self.Stop.setObjectName("pushButton_3")
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menubar.setGeometry(QRect(0, 0, 784, 21))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.label.setText(_translate("MainWindow", "Таймер"))
self.Melody.setText(_translate("MainWindow", "Рингтон"))
self.Pause.setText(_translate("MainWindow", "Пауза"))
self.Stop.setText(_translate("MainWindow", "Отмена"))
