def showTime(self):
time = QTime.currentTime()
text = time.toString('hh:mm')
if (time.second() % 2) == 0:
text = text[:2] + ' ' + text[3:]
self.display(text)
def on_update_progress(self, read, total):
"""This methods is called by self.reply.downloadProgress signal
Args:
read (int): Number of bytes readed
total (int): Total bytes to download
"""
if read <= 0:
return
if self.reply.error() != QNetworkReply.NoError:
return
self._file.write(self.reply.readAll())
# compute speed
duration = self.time.secsTo(QTime.currentTime()) + 1
speed = read / duration
remaining = (total - read) / speed
h_remaining = QTime(0, 0, 0, 0).addSecs(remaining).toString()
h_total = self.human_readable_bytes(total)
h_read = self.human_readable_bytes(read)
h_speed = self.human_readable_bytes(speed) + "/sec"
self.info_label.setText(
f"Time remaining {h_remaining} - {h_read} of {h_total} ({h_speed})"
)
# Set progression
self.progress.setRange(0, total)
self.progress.setValue(read)
def paintEvent(self, event):
side = min(self.width(), self.height())
time = QTime.currentTime()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogClock.hourColor)
painter.save()
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)))
painter.drawConvexPolygon(AnalogClock.hourHand)
painter.restore()
painter.setPen(AnalogClock.hourColor)
for i in range(12):
painter.drawLine(88, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogClock.minuteColor)
painter.save()
painter.rotate(6.0 * (time.minute() + time.second() / 60.0))
painter.drawConvexPolygon(AnalogClock.minuteHand)
painter.restore()
painter.setPen(AnalogClock.minuteColor)
for j in range(60):
if (j % 5) != 0:
painter.drawLine(92, 0, 96, 0)
painter.rotate(6.0)
def showTime(self):
time = QTime.currentTime()
text = time.toString("hh:mm")
# print(text)
if (time.second() % 2 == 0):
text = text[:2] + ' ' + text[3:]
self.display(text)
def update_clock(self):
time = QTime.currentTime()
s_time = time.toString('hh:mm')
if time.second() % 2 == 0:
s_time = s_time.replace(':', '.')
self._window.lcd.display(s_time)
self._analog_clock.time = time
def showTime(self):
time = QTime.currentTime() # Récupère le temps
text = time.toString('hh:mm') # Formate l'affichage du temps
if (
time.second() % 2
) == 0: # Enlève les deux points entre les minutes et heures une seconde sur deux.
text = text[:2] + ' ' + text[3:]
self.display(text) # Affiche le texte
def printReceipt(self):
self.playSound('audio4')
# printer = Usb(idVendor=0x0416, idProduct=0x5011, timeout=0, in_ep=0x81, out_ep=0x03)
os.system('sudo -S python3 printer.py ' + str(self.total_price) +
' --datetime "' +
QDate.currentDate().toString(Qt.DefaultLocaleShortDate) +
'-' +
QTime.currentTime().toString(Qt.DefaultLocaleShortDate) +
'"')
self.stackStart()
def open_game(self):
"""7秒后运行游戏"""
assert self.path is not None, "No current game path"
self.proc_name = utils.get_proc_name_by_path(self.path)
if self.proc_name is None:
LocaleEmulator.instance.excute_game_with_le(self.path)
# XXX wait 7 seconds
import time
from PySide2.QtCore import QTime
from PySide2.QtWidgets import QApplication
delay = QTime.currentTime().addSecs(7)
while QTime.currentTime() < delay:
QApplication.processEvents()
time.sleep(0.01)
self.proc_name = utils.get_proc_name_by_path(self.path)
self.pids = utils.find_all_pids(self.proc_name)
list(map(Hooker.instance.attach, self.pids))
def __init__(self, parent=None):
super(monPainter, self).__init__(parent)
currentTime = QTime.currentTime()
self.sec = currentTime.second()
self.hour = currentTime.hour()
self.min = currentTime.minute()
self.timer = QTimer()
self.timer.setInterval(1000)
self.timer.start()
self.timer.timeout.connect(self.runTimer)
print(currentTime)
def __init__(self, parent=None):
super(monHorloge, self).__init__(parent)
currentTime= QTime.currentTime()
self.heure = currentTime.hour()
self.minute = currentTime.minute()
self.timer = QTimer()
self.timer.setInterval(1000)
self.timer.timeout.connect(self.increaseTime)
self.timer.start()
def initForm(self):
date: QDate = QDate.currentDate()
time: QTime = QTime.currentTime()
self.tumblerDateTime1.year = date.year()
self.tumblerDateTime1.month = date.month()
self.tumblerDateTime1.day = date.day()
self.tumblerDateTime1.hour = time.hour()
self.tumblerDateTime1.min = time.minute()
self.tumblerDateTime1.sec = time.second()
self.tumblerDateTime2.setDateTime(date.year(), date.month(), date.day(),
time.hour(), time.minute(), time.second())
def __init__(self, parent=None):
super(monClock, self).__init__(parent)
self.interval_time = 1000
local_time = QTime.currentTime()
self.valeur_sec = local_time.second()
self.valeur_min = local_time.minute()
self.valeur_h = local_time.hour()
# self.slider.valueChanged.connect(self.compteur.interval_time)
self.timer = QTimer()
self.timer.setInterval(self.interval_time)
self.timer.timeout.connect(self.setValeur_sec_min_h)
self.timer.start()
print("Time refreshing", self.interval_time)
def newLetter(self):
self.textEdit.clear()
cursor = self.textEdit.textCursor()
cursor.movePosition(QTextCursor.Start)
topFrame = cursor.currentFrame()
topFrameFormat = topFrame.frameFormat()
topFrameFormat.setPadding(16)
topFrame.setFrameFormat(topFrameFormat)
# timer = QTimer(self)
# timer.timeout.connect(self.showTime)
# timer.start(1000)
textFormat = QTextCharFormat()
boldFormat = QTextCharFormat()
boldFormat.setFontWeight(QFont.Bold)
italicFormat = QTextCharFormat()
italicFormat.setFontItalic(True)
tableFormat = QTextTableFormat()
tableFormat.setBorder(1)
tableFormat.setCellPadding(16)
tableFormat.setAlignment(Qt.AlignRight)
cursor.insertTable(1, 1, tableFormat)
cursor.insertText("Tomasz Dróżdż", boldFormat)
cursor.insertBlock()
cursor.insertText("Politechnika Wrocławska", textFormat)
cursor.insertBlock()
cursor.insertText("Automatyka i Robotyka")
cursor.insertBlock()
cursor.insertText("SOLAR PANEL Program")
cursor.setPosition(topFrame.lastPosition())
cursor.insertText(
QDate.currentDate().toString("Dziś jest: d MMMM yyyy:"),
textFormat)
cursor.insertText(QTime.currentTime().toString(" hh:mm:ss"),
textFormat)
# cursor.insertText(QTimer.timer(" hh:mm:ss", 1000), textFormat)
cursor.insertBlock()
cursor.insertBlock()
cursor.insertText("Wrocław: ", textFormat)
cursor.insertText("17.03 deg; 51.10 deg", textFormat)
cursor.insertText(",", textFormat)
for i in range(3):
cursor.insertBlock()
cursor.insertText("Text", textFormat)
def testInsert(self):
myHash = {}
qdate = QDate.currentDate()
qdatetime = QDateTime.currentDateTime()
qtime = QTime.currentTime()
qurl = QUrl("http://www.pyside.org")
qpoint = QPoint(12, 42)
myHash[qdate] = "QDate"
myHash[qdatetime] = "QDateTime"
myHash[qtime] = "QTime"
myHash[qurl] = "QUrl"
myHash[qpoint] = "QPoint"
self.assertEqual(myHash[qdate], "QDate")
self.assertEqual(myHash[qdatetime], "QDateTime")
self.assertEqual(myHash[qtime], "QTime")
self.assertEqual(myHash[qurl], "QUrl")
self.assertEqual(myHash[qpoint], "QPoint")
def testInsert(self):
myHash = {}
qdate = QDate.currentDate()
qdatetime = QDateTime.currentDateTime()
qtime = QTime.currentTime()
qurl = QUrl("http://www.pyside.org")
qpoint = QPoint(12, 42)
myHash[qdate] = "QDate"
myHash[qdatetime] = "QDateTime"
myHash[qtime] = "QTime"
myHash[qurl] = "QUrl"
myHash[qpoint] = "QPoint"
self.assertEqual(myHash[qdate], "QDate")
self.assertEqual(myHash[qdatetime], "QDateTime")
self.assertEqual(myHash[qtime], "QTime")
self.assertEqual(myHash[qurl], "QUrl")
self.assertEqual(myHash[qpoint], "QPoint")
def __init__(self, parent=None, size=basic_size):
super(AnalogClock, self).__init__(parent)
self._time = QTime.currentTime()
self.setAttribute(Qt.WA_TranslucentBackground)
if size is None:
size = basic_size
self.resize(size, size)
else:
if size < basic_size:
size = basic_size
self.resize(size, size)
font = QFont()
font.setStyleHint(QFont.SansSerif)
font.setFamily('monospace')
font.setPointSize(12)
self.font = font
def __init__(self, parent, mirror_task):
super(DlgScedule, self).__init__(parent)
# setup UI
self.ui = Ui_DlgSchedule()
self.ui.setupUi(self)
# selected task
self._mirrorTask = mirror_task
# schedule manager
self._manager = ScheduledTasksManager()
# connect slots
self.ui.btnOK.clicked.connect(lambda: self.Btn_Clicked(self.ui.btnOK))
self.ui.btnCancel.clicked.connect(
lambda: self.Btn_Clicked(self.ui.btnCancel))
self.ui.checkBox.clicked.connect(
lambda: self.Btn_Clicked(self.ui.checkBox))
# set checkbox
self.ui.checkBox.setChecked(False)
# make schedule types
self.ui.comboBox.addItems(Settings.SCHEDULE_TYPES)
# get task schedule task
task = self._manager.Get(self._mirrorTask)
try:
if task is not None:
# get next triger time
time = task.LastRunTime
# get time stamp
dt = datetime.datetime.fromtimestamp(
timestamp=time.timestamp(), tz=time.tzinfo)
# set checkbox
self.ui.checkBox.setChecked(task.Enabled)
# set date & time
self.ui.dateEdit.setDate(QDate(dt.year, dt.month, dt.day))
self.ui.timeEdit.setTime(QTime(dt.hour, dt.minute, dt.day))
else:
self.ui.dateEdit.setDate(QDate.currentDate())
self.ui.timeEdit.setTime(QTime.currentTime())
# enable controls
self.EnableControls()
except Exception as e:
print(f'Schedule Dlg Err:{e}')
def starting_printing_process(self):
if self.is_printing:
self.print_text_signal.emit("Already printing!")
return
if self.__motor_controller.is_connected or DEBUG_MODE_ON:
self.printing_date = QDate.currentDate().toString("yyyy.MM.dd")
self.printing_time = QTime.currentTime().toString("hh.mm.ss")
self.is_printing = True
self.block_parameters_signal.emit()
self.current_layer = 0
self.current_burning_layer = 0
self.number_of_layers = len(self.features_file_names) + len(
self.support_file_names)
self.print_text_signal.emit("Starting printing process ...")
self.__print_support_parameters__()
self.__print_features_parameters__()
if DEBUG_MODE_ON:
self.prepare_next_layer()
else:
self.__motor_controller.begin_printing_process()
else:
self.print_text_signal.emit("The printer is NOT connected!")
def start(self):
""" Start downloading the file specify by set_source
"""
filepath = self.destination.absoluteFilePath(self.source.fileName())
if QFile(filepath).exists():
QFile.remove(filepath)
self._file = QFile(filepath)
# open the file to write in
if self._file.open(QIODevice.WriteOnly):
print("open file", filepath)
# Create a Qt Request
request = QNetworkRequest()
request.setUrl(self.source)
self.time = QTime.currentTime()
self.reply = self.net.get(request)
# Connect reply to different slots
self.reply.downloadProgress.connect(self.on_update_progress)
self.reply.finished.connect(self.on_finished)
self.reply.error.connect(self.on_error)
def new_time_input(parent, title_str, time=None):
"""
creates input with title
:param parent:
:param title_str:
:param hint_str:
:param only_numbers:
:return:
"""
widget = QWidget(parent)
widget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
# layout
layout = QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(2)
# label
title = QLabel(widget)
title.setText(title_str)
title.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
# text edit
widget.time_input = QTimeEdit(widget)
if time is None:
widget.time_input.setTime(QTime.currentTime())
else:
widget.time_input.setTime(time)
# add to layout
layout.addWidget(title)
layout.addWidget(widget.time_input)
widget.setLayout(layout)
return widget
def createDateDialog(self):
popup = QDialog(self)
popup.setFixedSize(270, 60)
popup.setWindowTitle("Nouvelle date")
layout = QHBoxLayout()
prefix = QLabel("Heure cible: ")
layout.addWidget(prefix)
qline = QTimeEdit()
qline.setDisplayFormat("hh:mm:ss")
qline.setTime(QTime.currentTime())
layout.addWidget(qline)
button = QPushButton("Ok")
button.clicked.connect(lambda: self.createDate(popup,
qline.time().hour(),
qline.time().minute(),
qline.time().second()))
layout.addWidget(button)
popup.setLayout(layout)
popup.exec_()
** Website/Contact: https://github.com/SBGit-2019/Pyside-QCP **
****************************************************************************
'''
import shiboken2 as Shiboken
from PySide2 import QtGui
import sys
import math
from random import uniform, randint
from PySide2.QtWidgets import QApplication, QDialog, QLineEdit, QPushButton, QVBoxLayout, QWidget, QMainWindow
from PySide2.QtGui import QLinearGradient, QRadialGradient, QColor, QBrush, QPen, QFont, QPixmap, QPainterPath
from PySide2.QtCore import Qt, QMargins, QPointF, QObject, QCoreApplication, QFile, QTimer, QLocale, QDateTime, QDate, QSize, QTime
from PySide2.QtUiTools import QUiLoader
from QCustomPlot_PySide import *
time = QTime.currentTime()
lastPointKey = 0
customPlot = None
lastFpsKey = 0.0
frameCount = 0
def realtimeDataSlot(): # called by timer
# calculate two new data points:
global lastPointKey
global time
global customPlot
global lastFpsKey
global frameCount
key = time.elapsed(
) / 1000.0 # time elapsed since start of demo, in seconds
def update_frame(self):
time = QTime.currentTime()
if time.second() % 10 == 0:
self.update()
property_ = manager_map[PropertyID.DATE].addProperty("date_%d" %
(count + 1, ))
property_.propertyManager().setValue(property_, QDate.currentDate())
tree_browser.setFactoryForManager(manager_map[PropertyID.DATE],
factory_map[PropertyID.DATE])
box_browser.setFactoryForManager(manager_map[PropertyID.DATE],
factory_map[PropertyID.DATE])
button_browser.setFactoryForManager(manager_map[PropertyID.DATE],
factory_map[PropertyID.DATE])
group[count].addSubProperty(property_)
# time
manager_map[PropertyID.TIME].valueChanged.connect(set_value)
property_ = manager_map[PropertyID.TIME].addProperty("time_%d" %
(count + 1, ))
property_.propertyManager().setValue(property_, QTime.currentTime())
tree_browser.setFactoryForManager(manager_map[PropertyID.TIME],
factory_map[PropertyID.TIME])
box_browser.setFactoryForManager(manager_map[PropertyID.TIME],
factory_map[PropertyID.TIME])
button_browser.setFactoryForManager(manager_map[PropertyID.TIME],
factory_map[PropertyID.TIME])
group[count].addSubProperty(property_)
# datetime
manager_map[PropertyID.DATETIME].valueChanged.connect(set_value)
property_ = manager_map[PropertyID.DATETIME].addProperty(
"datetime_%d" % (count + 1, ))
property_.propertyManager().setValue(property_,
QDateTime.currentDateTime())
tree_browser.setFactoryForManager(manager_map[PropertyID.DATETIME],
def _delay(self, secs: int) -> None:
die_time = QTime.currentTime().addSecs(secs)
while QTime.currentTime() < die_time:
QCoreApplication.processEvents(QEventLoop().AllEvents, 100)
import sys
import time
from PySide2.QtWidgets import QApplication
from PySide2.QtWidgets import QLabel
from PySide2.QtCore import QTime, QTimer, QCoreApplication
if __name__ == "__main__":
app = QApplication(sys.argv)
message = "Alert!"
due = QTime.currentTime()
try:
if len(sys.argv)<2:
raise ValueError
hours, minutes = sys.argv[1].split(":")
if not due.isValid():
raise ValueError
due = QTime(int(hours), int(minutes))
while QTime.currentTime() < due :
time.sleep()
label = QLabel("<font color=red size=72>Alarm Clock </font>")
label.show()
quit()
class Data_App(QWidget, Ui_MainWindow):
def __init__(self):
super().__init__()
# 创建串口实例对象
self.serial = serial.Serial()
# 创建 QTimer 实例对象
self.timer1 = QTimer()
self.timer2 = QTimer()
self.time = QTime()
self.now_time = ''
# 创建显示窗口
self.main_window = QMainWindow()
self.setupUi(self.main_window)
self.retranslateUi(self.main_window)
# 正则表达式相关
bit_3_validator = QRegExpValidator()
bit_3_validator.setRegExp(QRegExp('[0-9]{1,3}'))
self.fresh_waste_edit.setValidator(bit_3_validator)
self.fresh_edit.setValidator(bit_3_validator)
self.waste_edit.setValidator(bit_3_validator)
self.blood_edit.setValidator(bit_3_validator)
self.ultrafiltration_edit.setValidator(bit_3_validator)
self.debug_send_edit.setValidator(bit_3_validator)
# 储存所有存在的串口 字典
self.Com_Dict = {}
# 创建新csv文件标志
self.create_file_flag = True
self.write_data_flag = False
# 要保存的当前的文件名
self.now_file_name = None
# 串口接收的字符串
self.received_bit_data = None
self.received_data = None
# 图像对象
self.fresh_pressure_plot = None
self.waste_pressure_plot = None
self.fresh_flow_plot = None
self.waste_flow_plot = None
self.blood_flow_plot = None
self.artery_pressure_plot = None
self.vein_pressure_plot = None
self.weight_1_plot = None
self.weight_2_plot = None
self.weight_3_plot = None
self.tmp_plot = None
# self.ph_plot = None
# self.temperature_plot = None
# 保存收到的数据 list
self.x = 0
self.list_fresh_pressure = [0] * 10
self.list_waste_pressure = [0] * 10
self.list_fresh_flow = [0] * 10
self.list_waste_flow = [0] * 10
self.list_blood_flow = [0] * 10
self.list_artery_pressure = [0] * 10
self.list_vein_pressure = [0] * 10
self.list_weight_1 = [0] * 10
self.list_weight_2 = [0] * 10
self.list_weight_3 = [0] * 10
self.list_tmp = [0] * 10
# self.list_ph = [0]*1000
# 接收到的最新的数据
self.flag = ""
self.fresh_pressure_data = 0
self.waste_pressure_data = 0
self.fresh_flow_data = 0
self.waste_flow_data = 0
self.blood_flow_data = 0
self.artery_pressure_data = 0
self.vein_pressure_data = 0
self.weight_1_data = 0
self.weight_2_data = 0
self.weight_3_data = 0
# 跨膜压
self.tmp_data = 0
self.initial_temperature_data = 0
self.process_temperature_data = 0
# self.ph_data = 0
self.ultra_filtration_data = 0
# 判断是否为首次接收到数据
self.times = 0
# 数据为空次数
self.count_err = 0
self.num = 0
self.start_stop_flag = False
self.init()
self.port_check()
# 按键关联
def init(self):
# 串口开关按钮
self.open_serial_button.clicked.connect(self.port_operation)
# 数据接收按钮
self.receive_button.clicked.connect(self.data_begin)
self.start_stop_button.clicked.connect(
lambda: self.send_data(self.start_stop_button))
# 数据发送按钮
self.fresh_waste_forward_button.clicked.connect(
lambda: self.send_data(self.fresh_waste_forward_button))
self.fresh_waste_reverse_button.clicked.connect(
lambda: self.send_data(self.fresh_waste_reverse_button))
self.fresh_forward_button.clicked.connect(
lambda: self.send_data(self.fresh_forward_button))
self.fresh_reverse_button.clicked.connect(
lambda: self.send_data(self.fresh_reverse_button))
self.waste_forward_button.clicked.connect(
lambda: self.send_data(self.waste_forward_button))
self.waste_reverse_button.clicked.connect(
lambda: self.send_data(self.waste_reverse_button))
self.blood_forward_button.clicked.connect(
lambda: self.send_data(self.blood_forward_button))
self.blood_reverse_button.clicked.connect(
lambda: self.send_data(self.blood_reverse_button))
self.ultrafiltration_forward_button.clicked.connect(
lambda: self.send_data(self.ultrafiltration_forward_button))
self.ultrafiltration_reverse_button.clicked.connect(
lambda: self.send_data(self.ultrafiltration_reverse_button))
self.debug_send_button.clicked.connect(
lambda: self.send_data(self.debug_send_button))
# 全部设置按钮
self.all_send_button.clicked.connect(
lambda: self.send_data(self.all_send_button))
# 停止按钮信号与槽
self.fresh_waste_stop_button.clicked.connect(
lambda: self.send_data(self.fresh_waste_stop_button))
self.fresh_stop_button.clicked.connect(
lambda: self.send_data(self.fresh_stop_button))
self.waste_stop_button.clicked.connect(
lambda: self.send_data(self.waste_stop_button))
self.blood_stop_button.clicked.connect(
lambda: self.send_data(self.blood_stop_button))
self.ultrafiltration_stop_button.clicked.connect(
lambda: self.send_data(self.ultrafiltration_stop_button))
# 退出程序
self.quit_button.clicked.connect(self.app_close)
# 串口检测按钮
self.find_port_button.clicked.connect(self.port_check)
# 定时器接收数据
self.timer1.timeout.connect(self.receive_data)
self.timer2.timeout.connect(self.write_data)
# PlotWidget 实例初始化
self.dialysis_pressure_plot_view_init()
self.flow_plot_view_init()
self.pulse_plot_view_init()
self.weight_plot_view_init()
self.tmp_plot_view_init()
# self.ph_plot_view_init()
# 透析液压力趋势
def dialysis_pressure_plot_view_init(self):
self.dialysis_pressure_plot_view.setTitle("透析液压力（red新鲜液；blue废液）",
color='008080',
size='12pt',
font='黑体')
# 设置上下左右的label
self.dialysis_pressure_plot_view.setLabel("left", "压强")
self.dialysis_pressure_plot_view.setLabel("bottom", "采样点")
# 设置自适应刻度范围
self.dialysis_pressure_plot_view.enableAutoRange()
# 显示表格线
self.dialysis_pressure_plot_view.showGrid(x=True, y=True)
# 背景色改为黑色
self.dialysis_pressure_plot_view.setBackground('000000')
# 实时显示应该获取 plotItem， 调用setData，
# 这样只重新plot该曲线，性能更高
self.fresh_pressure_plot = self.dialysis_pressure_plot_view.getPlotItem(
).plot(pen=pg.mkPen('r', width=2))
self.waste_pressure_plot = self.dialysis_pressure_plot_view.getPlotItem(
).plot(pen=pg.mkPen('b', width=2))
# 透析液流量
def flow_plot_view_init(self):
self.dialysis_flow_plot_view.setTitle("透析液流量(red新鲜；green废液；blue血液)",
color='008080',
size='12pt')
# 设置上下左右的label
self.dialysis_flow_plot_view.setLabel("left", "流量")
self.dialysis_flow_plot_view.setLabel("bottom", "采样点")
# 设置自适应刻度范围
self.dialysis_flow_plot_view.enableAutoRange()
# 显示表格线
self.dialysis_flow_plot_view.showGrid(x=True, y=True)
# 背景色改为白色
self.dialysis_flow_plot_view.setBackground('000000')
# 实时显示应该获取 plotItem， 调用setData，
# 这样只重新plot该曲线，性能更高
self.fresh_flow_plot = self.dialysis_flow_plot_view.getPlotItem().plot(
pen=pg.mkPen('r', width=2))
self.waste_flow_plot = self.dialysis_flow_plot_view.getPlotItem().plot(
pen=pg.mkPen('g', width=2))
self.blood_flow_plot = self.dialysis_flow_plot_view.getPlotItem().plot(
pen=pg.mkPen('b', width=2))
# 动静脉压力
def pulse_plot_view_init(self):
self.pluse_plot_view.setTitle("动静脉压（red动脉；blue静脉）",
color='008080',
size='12pt')
# 设置上下左右的label
self.pluse_plot_view.setLabel("left", "压强")
self.pluse_plot_view.setLabel("bottom", "采样点")
# 设置自适应刻度范围
self.pluse_plot_view.enableAutoRange()
# 显示表格线
self.pluse_plot_view.showGrid(x=True, y=True)
# 背景色改为黑色
self.pluse_plot_view.setBackground('000000')
# 实时显示应该获取 plotItem， 调用setData，
# 这样只重新plot该曲线，性能更高
self.artery_pressure_plot = self.pluse_plot_view.getPlotItem().plot(
pen=pg.mkPen('r', width=2))
self.vein_pressure_plot = self.pluse_plot_view.getPlotItem().plot(
pen=pg.mkPen('b', width=2))
# 重量显示
def weight_plot_view_init(self):
self.weight_plot_view.setTitle("重量（red重量1；green重量2；blue重量3）",
color='008080',
size='12pt')
# 设置上下左右的label
self.weight_plot_view.setLabel("left", "重量")
self.weight_plot_view.setLabel("bottom", "采样点")
# 设置自适应刻度范围
self.weight_plot_view.enableAutoRange()
# 显示表格线
self.weight_plot_view.showGrid(x=True, y=True)
# 背景色改为黑色
self.weight_plot_view.setBackground('000000')
# 实时显示应该获取 plotItem， 调用setData，
# 这样只重新plot该曲线，性能更高
self.weight_1_plot = self.weight_plot_view.getPlotItem().plot(
pen=pg.mkPen('r', width=2))
self.weight_2_plot = self.weight_plot_view.getPlotItem().plot(
pen=pg.mkPen('g', width=2))
self.weight_3_plot = self.weight_plot_view.getPlotItem().plot(
pen=pg.mkPen('b', width=2))
# TMP显示
def tmp_plot_view_init(self):
self.tmp_plot_view.setTitle("跨膜压", color='008080', size='12pt')
# 设置上下左右的label
self.tmp_plot_view.setLabel("left", "压强")
self.tmp_plot_view.setLabel("bottom", "采样点")
# 设置自适应刻度范围
self.tmp_plot_view.enableAutoRange()
# 显示表格线
self.tmp_plot_view.showGrid(x=True, y=True)
# 背景色改为黑色
self.tmp_plot_view.setBackground('000000')
# 实时显示应该获取 plotItem， 调用setData，
# 这样只重新plot该曲线，性能更高
self.tmp_plot = self.tmp_plot_view.getPlotItem().plot(
pen=pg.mkPen('r', width=2))
# ph 值
# def ph_plot_view_init(self):
# self.ph_plot_view.setTitle("PH",
# color='008080',
# size='12pt')
# # 设置上下左右的label
# self.ph_plot_view.setLabel("left", "PH值")
# self.ph_plot_view.setLabel("bottom", "采样点")
#
# # 设置自适应刻度范围
# self.ph_plot_view.enableAutoRange()
#
# # 显示表格线
# self.ph_plot_view.showGrid(x=True, y=True)
#
# # 背景色改为白色
# self.ph_plot_view.setBackground('w')
#
# # 实时显示应该获取 plotItem， 调用setData，
# # 这样只重新plot该曲线，性能更高
# self.ph_plot = self.ph_plot_view.getPlotItem().plot( pen=pg.mkPen('r', width=2))
# 串口检测
def port_check(self):
# 检测所有存在的串口，将信息存储在字典中
port_list = list(serial.tools.list_ports.comports())
self.port_combo_box.clear()
if len(port_list) == 0:
self.port_combo_box.addItem("无串口")
QMessageBox.information(self, "信息", "未检测到串口！")
else:
self.port_combo_box.clear()
for port in port_list:
self.Com_Dict["%s" % port[0]] = "%s" % port[1]
self.port_combo_box.addItem(port[0])
# 串口开关操作
def port_operation(self):
if self.serial.is_open:
self.close_serial_port()
else:
self.open_serial_port()
# 开始接收数据
def data_begin(self):
if self.serial.is_open:
# 打开串口接收定时器，周期为100ms
if not self.timer1.isActive():
self.timer1.start(100)
self.receive_button.setText("接收中")
else:
return None
else:
QMessageBox.information(self, 'Port', '串口未打开！')
# 打开串口
def open_serial_port(self):
# 从QComboBox的当前值获取端口号
self.serial.port = self.port_combo_box.currentText()
# self.serial.port = "COM1"
if not self.serial.port:
QMessageBox.critical(self, '错误', '没有选择串口')
# 设置串口通信参数
self.serial.baudrate = 115200
self.serial.bytesize = 8
self.serial.stopbits = 1
self.serial.parity = "N"
# timeout默认为None，若不设置timeout，当使用read()时，一直会等到读取指定的字节数为止
self.serial.timeout = 2
self.serial.write_timeout = 2
# 设置软件控制流开关
self.serial.rtscts = True
self.serial.dsrdtr = True
try:
self.serial.rts = True
self.serial.dtr = True
self.serial.open()
except:
QMessageBox.critical(self, "Port Error", "此串口不能被打开！")
return None
# 判断是否有串口打开
if self.serial.is_open:
# 打开串口接收定时器，周期为100ms
self.statusbar.showMessage("打开串口成功")
self.open_serial_button.setText("关闭串口")
self.port_status_label.setStyleSheet("background-color:green")
self.port_status_label.style().polish(
self.port_status_label) # 刷新样式
# 关闭串口
def close_serial_port(self):
self.timer1.stop()
self.timer2.stop()
self.serial.close()
if not self.serial.is_open:
self.open_serial_button.setText("打开串口")
self.port_status_label.setStyleSheet("background-color:gray")
self.port_status_label.style().polish(
self.port_status_label) # 刷新样式
self.receive_button.setText("接收")
self.statusbar.showMessage("串口已关闭")
def write_data(self):
self.write_data_flag = True
# 接收数据
def receive_data(self):
try:
num = self.serial.inWaiting()
except:
self.close_serial_port()
QMessageBox.critical(self, "Read Error", "读取输入缓存区数据的字节数失败！")
return None
print(self.serial.rts)
print(num)
self.received_bit_data = self.serial.read(101)
print(self.received_bit_data)
self.received_data = self.received_bit_data.decode('ascii')
# 已经接收到信息说明系统已经开启，将系统状态改为开启
if self.times == 0:
self.system_status_button(self.start_stop_button)
self.times += 1
print(self.received_data)
self.statusbar.showMessage("数据读取成功，准备处理数据")
self.data_operation()
# 处理接收的数据
def data_operation(self):
# 这里的received_data指的是发送端发送的字符串
if len(self.received_data) == 101:
self.count_err = 0
try:
# 使用获得的数据字符串创建一个对象
self.now_time = self.time.currentTime().toString()
data = Data_Deal(self.received_data + self.now_time)
# 对数据进行分析处理，并获得一个元祖类型的返回值，以便后面更新显示
self.flag, self.artery_pressure_data, self.vein_pressure_data, self.fresh_pressure_data,\
self.waste_pressure_data, self.fresh_flow_data, self.waste_flow_data, self.blood_flow_data,\
self.tmp_data, self.weight_1_data, self.weight_2_data, self.weight_3_data,\
self.initial_temperature_data, self.process_temperature_data,\
self.ultra_filtration_data = data.get_num()
except ValueError:
self.statusbar.showMessage('数据解析失败！准备重新接收')
self.serial.reset_input_buffer()
return None
# 判断需要创建一个新的csv还是直接存入当前csv(每次数据接收成功都会为之创建一个csv文件)
if self.create_file_flag:
self.create_file_flag = False
# 每一分钟保存一次数据
self.timer2.start(300000)
# 当前成功接收的数据所存放的文件名
self.now_file_name = self.now_time[0:2] + "_" + self.now_time[
3:5] + "_" + self.now_time[6:8] + ".csv"
data.create_csv(self.now_file_name)
else:
if self.write_data_flag and self.flag == 'tmp':
self.write_data_flag = False
data.store_to_csv(self.now_file_name)
if self.flag == 'tmp':
print('数据格式没问题')
self.show_update()
self.statusbar.showMessage("数据格式正确，更新数据完毕")
# print("更新数据完毕")
else:
self.statusbar.showMessage('数据格式不正确！准备重新接收')
# QMessageBox.information(self, "信息", "数据格式不正确！准备重新接收")
self.serial.reset_input_buffer()
return None
elif len(self.received_data) == 0:
self.count_err += 1
print(self.count_err)
if self.count_err == 5:
self.close_serial_port()
QMessageBox.information(self, "信息", "没有读到数据！")
return None
return None
else:
self.count_err = 0
self.statusbar.showMessage("读取的数据的字节数不对！准备重新接收")
# QMessageBox.information(self, "信息", "读取的数据的字节数不对！准备重新接收")
self.serial.reset_input_buffer()
return None
# pass #self.textBrowser.insertPlainText("Data Receive Error: Wrong Data Length!\r\n")
# QMessageBox.critical(self, "Data Length Error", "从输入缓存区读取数据的字节数不对！")
# 更新所有显示
def show_update(self):
# 更新文本显示区域的数据
self.fresh_pressure_value.setText(str(self.fresh_pressure_data))
self.waste_pressure_vlue.setText(str(self.waste_pressure_data))
self.fresh_flow_value.setText(str(self.fresh_flow_data))
self.waste_flow_value.setText(str(self.waste_flow_data))
self.blood_flow_value.setText(str(self.blood_flow_data))
self.artery_pressure_value.setText(str(self.artery_pressure_data))
self.vein_pressure_value.setText(str(self.vein_pressure_data))
# 电导值已经去掉，目前显示重量，未在右边显示
# self.ph_value.setText(str(self.ph_data))
self.initial_temperature_value.setText(
str(self.initial_temperature_data))
self.process_temperature_value.setText(
str(self.process_temperature_data))
self.ultrafiltration_show_value.setText(str(
self.ultra_filtration_data))
# 更新数据
self.x += 1
# self.list_fresh_pressure[:-1] = self.list_fresh_pressure[1:]
# self.list_fresh_pressure[-1] = self.fresh_pressure_data
# self.list_fresh_pressure.insert(0, 0)
# self.list_waste_pressure[:-1] = self.list_waste_pressure[1:]
# self.list_waste_pressure[-1] = self.waste_pressure_data
# self.list_waste_pressure.insert(0, 0)
# self.list_fresh_flow[:-1] = self.list_fresh_flow[1:]
# self.list_fresh_flow[-1] = self.fresh_flow_data
# self.list_waste_flow[:-1] = self.list_waste_flow[1:]
# self.list_waste_flow[-1] = self.waste_flow_data
# self.list_blood_flow[:-1] = self.list_blood_flow[1:]
# self.list_blood_flow[-1] = self.blood_flow_data
# self.list_artery_pressure[:-1] = self.list_artery_pressure[1:]
# self.list_artery_pressure[-1] = self.artery_pressure_data
# self.list_vein_pressure[:-1] = self.list_vein_pressure[1:]
# self.list_vein_pressure[-1] = self.vein_pressure_data
# self.list_weight_1[:-1] = self.list_weight_1[1:]
# self.list_weight_1[-1] = self.weight_1_data
# self.list_weight_2[:-1] = self.list_weight_2[1:]
# self.list_weight_2[-1] = self.weight_2_data
# self.list_weight_3[:-1] = self.list_weight_3[1:]
# self.list_weight_3[-1] = self.weight_3_data
# self.list_tmp[:-1] = self.list_tmp[1:]
# self.list_tmp[-1] = self.tmp_data
# self.list_ph[:-1] = self.list_ph[1:]
# self.list_ph[-1] = self.ph_data
self.list_fresh_pressure.append(self.fresh_pressure_data)
self.list_waste_pressure.append(self.waste_pressure_data)
self.list_fresh_flow.append(self.fresh_flow_data)
self.list_waste_flow.append(self.waste_flow_data)
self.list_blood_flow.append(self.blood_flow_data)
self.list_artery_pressure.append(self.artery_pressure_data)
self.list_vein_pressure.append(self.vein_pressure_data)
self.list_weight_1.append(self.weight_1_data)
self.list_weight_2.append(self.weight_2_data)
self.list_weight_3.append(self.weight_3_data)
self.list_tmp.append(self.tmp_data)
# 更新图形
self.fresh_pressure_plot.setData(self.list_fresh_pressure)
# 给图形对象设置新坐标值，# 参数1：x 轴起点坐标 参数2：y 轴起点坐标
self.fresh_pressure_plot.setPos(self.x, 0)
self.waste_pressure_plot.setData(self.list_waste_pressure)
self.waste_pressure_plot.setPos(self.x, 0)
self.fresh_flow_plot.setData(self.list_fresh_flow)
self.fresh_flow_plot.setPos(self.x, 0)
self.waste_flow_plot.setData(self.list_waste_flow)
self.waste_flow_plot.setPos(self.x, 0)
self.blood_flow_plot.setData(self.list_blood_flow)
self.blood_flow_plot.setPos(self.x, 0)
self.artery_pressure_plot.setData(self.list_artery_pressure)
self.artery_pressure_plot.setPos(self.x, 0)
self.vein_pressure_plot.setData(self.list_vein_pressure)
self.vein_pressure_plot.setPos(self.x, 0)
self.weight_1_plot.setData(self.list_weight_1)
self.weight_1_plot.setPos(self.x, 0)
self.weight_2_plot.setData(self.list_weight_2)
self.weight_2_plot.setPos(self.x, 0)
self.weight_3_plot.setData(self.list_weight_3)
self.weight_3_plot.setPos(self.x, 0)
self.tmp_plot.setData(self.list_tmp)
self.tmp_plot.setPos(self.x, 0)
# self.ph_plot.setData(self.list_ph)
# self.ph_plot.setPos(self.x, 0)
# 发送数据
def send_data(self, btn):
if self.serial.is_open:
bytes_data = self.button_effort(btn)
if bytes_data != "" and len(bytes_data) > 5:
self.serial.write(bytes_data)
# QMessageBox.information(self, 'Send', '发送数据成功！')
else:
QMessageBox.critical(self, "Send Error", "发送数据不能为空！")
else:
QMessageBox.information(self, 'Port', '串口未打开')
return None
# 判断不同的按钮做出不同的响应
def button_effort(self, btn):
data = ""
# 发送新鲜液废旧液数据
if btn.objectName() == "fresh_waste_forward_button":
data = "ffw" + self.fresh_waste_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "fresh_waste_reverse_button":
data = "rfw" + self.fresh_waste_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "fresh_waste_stop_button":
data = "fwaStop\r\n"
return data.encode('ascii')
elif btn.objectName() == "fresh_forward_button":
data = "ffr" + self.fresh_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "fresh_reverse_button":
data = "rfr" + self.fresh_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "fresh_stop_button":
data = "freStop\r\n"
return data.encode('ascii')
elif btn.objectName() == "waste_forward_button":
data = "fwa" + self.waste_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "waste_reverse_button":
data = "rwa" + self.waste_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "waste_stop_button":
data = "wasStop\r\n"
return data.encode('ascii')
elif btn.objectName() == "blood_forward_button":
data = "fbl" + self.blood_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "blood_reverse_button":
data = "rbl" + self.blood_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "blood_stop_button":
data = "bloStop\r\n"
return data.encode('ascii')
elif btn.objectName() == "ultrafiltration_forward_button":
data = "ful" + self.ultrafiltration_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "ultrafiltration_reverse_button":
data = "rul" + self.ultrafiltration_edit.text() + "\r\n"
return data.encode('ascii')
elif btn.objectName() == "ultrafiltration_stop_button":
data = "ultStop\r\n"
return data.encode('ascii')
elif btn.objectName() == "debug_send_button":
data = "cmd" + self.debug_send_edit.text() + "\r\n"
return data.encode('ascii')
# elif btn.objectName() == "all_send_button":
# data = self.get_all_cmd()
# if data != "":
# reply = QMessageBox.question(None, "检查命令", data, QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
# if reply == QMessageBox.Yes:
# data += "\r\n"
elif btn.objectName() == "start_stop_button":
self.system_status_button(btn)
if self.start_stop_flag:
data = "systemStart\r\n"
return data.encode('ascii')
elif not self.start_stop_flag:
data = "systemStop\r\n"
return data.encode('ascii')
else:
return data
#
# if data != '':
# return data.encode('ascii')
# 发送所有命令的按钮指令(还有用吗？)
# def get_all_cmd(self):
# data = ""
# if self.fresh_waste_edit.text() != "":
# data += "fwl" + self.fresh_waste_edit.text()
# if self.ultrafiltration_edit.text() != "":
# data += "ult" + self.ultrafiltration_edit.text()
# if self.blood_pump_edit.text() != "":
# data += "bpu" + self.blood_pump_edit.text()
# if self.debug_send_edit.text() != "":
# data += self.debug_send_edit.text()
#
# if data == "":
# QMessageBox.critical(self, "警告", "未设置参数", QMessageBox.Yes)
# return data
# 更改系统开启与停止按钮的样式
def system_status_button(self, btn):
if btn.text() == "开启":
self.start_stop_flag = True
btn.setText('停止')
self.system_status_label.setStyleSheet('background-color:green')
self.system_status_label.style().polish(self.system_status_label)
elif btn.text() == "停止":
self.start_stop_flag = False
btn.setText('开启')
self.system_status_label.setStyleSheet('background-color:gray')
self.system_status_label.style().polish(self.system_status_label)
# 关闭系统
def app_close(self):
self.close_serial_port()
quit()
def createDockWindows(self):
# dock = QDockWidget('n', self)
# dock.setFeatures(dock.NoDockWidgetFeatures)
# dock.DockWidgetMovable = False
# dock.setAllowedAreas(Qt.TopDockWidgetArea)
# self.addDockWidget(Qt.TopDockWidgetArea, dock)
dock = QDockWidget("Program", self)
dock.setFeatures(dock.NoDockWidgetFeatures)
dock.DockWidgetMovable = False
dock.setAllowedAreas(Qt.LeftDockWidgetArea)
self.multiWidget = QWidget()
font1 = QFont("Courier New", 10)
self.title = QLabel("SOLAR PANEL Program")
font2 = QFont("Courier New", 10)
font2.setBold(True)
self.author = QLabel("Tomasz Dróżdż")
self.author.setFont(font2)
self.other = QLabel("Politechnika Wrocławska")
self.other2 = QLabel("Automatyka i Robotyka")
self.vLayout = QVBoxLayout()
self.vLayout.addWidget(self.title)
self.vLayout.addWidget(self.author)
self.vLayout.addWidget(self.other)
self.vLayout.addWidget(self.other2)
self.multiWidget.setLayout(self.vLayout)
dock.setWidget(self.multiWidget)
self.addDockWidget(Qt.LeftDockWidgetArea, dock)
dock = QDockWidget("Zegar", self)
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.multiWidget2 = QWidget()
font3 = QFont("Arial", 13)
font4 = QFont("Arial", 20)
self.date = QLabel(QDate.currentDate().toString("d MMMM yyyy: "))
self.clock = QLabel(QTime.currentTime().toString("hh:mm:ss"))
self.date.setFont(font3)
self.clock.setFont(font4)
font4.setBold(True)
self.vLayout2 = QVBoxLayout()
self.vLayout2.addWidget(self.date)
self.vLayout2.addWidget(self.clock)
self.multiWidget2.setLayout(self.vLayout2)
dock.setWidget(self.multiWidget2)
self.addDockWidget(Qt.LeftDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
dock = QDockWidget("Współrzędne Geograficzne Panelu: ", self)
s = ephem.Sun()
s.compute(epoch=ephem.now())
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.multiWidget3 = QWidget()
font5 = QFont("Arial", 12)
font6 = QFont("Arial", 17)
self.vLayout3 = QGridLayout()
self.result = QLabel(self.latlong)
self.name = QLabel('Nazwa')
self.latitude = QLabel('Szerokość')
self.longitude = QLabel('Długość')
self.dateandtime = QLabel('Data i Czas')
# self.result = QLabel('')
# self.result2 = QLabel('')
# self.result3 = QLabel('')
self.solarpanelcor = QLabel('WSPÓŁRZĘDNE PANELU SŁONECZNEGO: ')
self.nameEdit = QLineEdit()
self.nameEdit.setFixedHeight(28)
self.nameEdit.setFixedWidth(386)
self.nameEdit.setStatusTip(
"Wprowadź nazwę dla konfiguracji współrzędnych i czasu")
self.latitudeEdit = QLineEdit()
self.latitudeEdit.setFixedHeight(28)
self.latitudeEdit.setFixedWidth(386)
self.latitudeEdit.setStatusTip(
"Wprowadzona szerokość powinna być w stopniach dziesiętnych (np.: 51.100000)"
)
self.longitudeEdit = QLineEdit()
self.longitudeEdit.setFixedHeight(28)
self.longitudeEdit.setFixedWidth(386)
self.longitudeEdit.setStatusTip(
"Wprowadzona długość powinna być w stopniach dziesiętnych (np.: 17.03333)"
)
self.dateandtimeEdit = QLineEdit()
self.dateandtimeEdit.setFixedHeight(28)
self.dateandtimeEdit.setFixedWidth(386)
self.dateandtimeEdit.setStatusTip(
"Wprowadzona data powinna być w formacie: rok/mies/dzień<spacja>godz:min:sek (np.: 2022/12/4 8:12:7)"
)
self.button = QPushButton('Wylicz współrzędne / Przerwij liczenie',
self)
self.button.clicked.connect(self.handleButton4)
self.name.setFont(font5)
self.latitude.setFont(font5)
self.longitude.setFont(font5)
self.dateandtime.setFont(font5)
self.button.setFont(font6)
self.button.setStatusTip("Rozpoczyna Obliczenia")
# self.button.addAction(self.buttonAct)
# self.solarpanelcor.setFont(font5)
# self.result.setFont(font6)
# self.result2.setFont(font6)
# self.result3.setFont(font6)
self.vLayout3.addWidget(self.name)
self.vLayout3.addWidget(self.nameEdit)
self.vLayout3.addWidget(self.latitude)
self.vLayout3.addWidget(self.latitudeEdit)
self.vLayout3.addWidget(self.longitude)
self.vLayout3.addWidget(self.longitudeEdit)
self.vLayout3.addWidget(self.dateandtime)
self.vLayout3.addWidget(self.dateandtimeEdit)
self.vLayout3.addWidget(self.button)
# self.vLayout3.addWidget(self.solarpanelcor)
# self.vLayout3.addWidget(self.result)
# self.vLayout3.addWidget(self.result2)
# self.vLayout3.addWidget(self.result3)
self.multiWidget3.setLayout(self.vLayout3)
dock.setWidget(self.multiWidget3)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
def update(self):
time = QTime.currentTime()
self.clock.setText(QTime.currentTime().toString("hh:mm:ss"))
