forked from huangxin/ailai
2692 lines
118 KiB
Python
2692 lines
118 KiB
Python
import configparser
|
||
import copy
|
||
import json
|
||
import logging
|
||
import os
|
||
import queue
|
||
import random
|
||
import sys
|
||
import threading
|
||
from multiprocessing import Process
|
||
import traceback
|
||
|
||
import PySide6
|
||
import cv2
|
||
import numpy as np
|
||
from PyQt5.uic.properties import QtWidgets
|
||
from PySide6 import QtCore
|
||
from PySide6.QtCore import QThread, Signal, Slot, QObject, QEvent, QTimer
|
||
from PySide6.QtGui import (
|
||
QIntValidator,
|
||
QStandardItemModel,
|
||
QStandardItem,
|
||
Qt,
|
||
QMovie,
|
||
QIcon,
|
||
QCursor,
|
||
QColor,
|
||
QTextCursor,
|
||
)
|
||
from PySide6.QtWidgets import (
|
||
QApplication,
|
||
QMainWindow,
|
||
QPushButton,
|
||
QLabel,
|
||
QHeaderView,
|
||
QTableWidget,
|
||
QTableWidgetItem,
|
||
QWidget,
|
||
QHBoxLayout,
|
||
QAbstractItemView,
|
||
QMessageBox,
|
||
QSizePolicy,
|
||
QComboBox,
|
||
QMenu,
|
||
)
|
||
from datetime import datetime
|
||
|
||
from click import clear
|
||
|
||
import Util.util_pic
|
||
from Model.FeedModel import LineModel, PositionModel
|
||
from Util.util_ini import writeFeedLine_to_ini
|
||
import Constant
|
||
from CU.Command import FeedCommand
|
||
from CU.Feeding import (
|
||
FeedLine,
|
||
FeedingConfig,
|
||
Feeding,
|
||
FeedStatus,
|
||
FeedMidStatus,
|
||
ResetStatus,
|
||
)
|
||
from Util.util_log import QTextEditLogger
|
||
from Util.util_time import CRisOrFall
|
||
|
||
# from Vision.camera_coordinate_dete import Detection
|
||
from COM.COM_Robot import RobotClient
|
||
from Expection import Error_Code
|
||
from queue import Queue
|
||
from Model.RobotModel import *
|
||
import time
|
||
from queue import Queue
|
||
from Model.Position import Real_Position, Detection_Position
|
||
from threading import Thread
|
||
from CU.Command import Status
|
||
from Util.util_log import log
|
||
|
||
# from Vision.detect_person import DetectionPerson
|
||
from ui_MainWin import Ui_MainWindow
|
||
from view.ResetView import StopDialog
|
||
from EMV.EMV import RelayController
|
||
|
||
|
||
# from view.ResetView import StopDialog
|
||
|
||
|
||
class MainWindow(QMainWindow, Ui_MainWindow):
|
||
updateUI_seting = Signal()
|
||
|
||
def __init__(self):
|
||
super(MainWindow, self).__init__()
|
||
|
||
self.setupUi(self)
|
||
# 传感器继电器加入变量
|
||
self.relay_controller = RelayController()
|
||
self.sensor_thread = None
|
||
self.sensor2_thread = None
|
||
self.last_status_printed = None
|
||
self.last_pause_printed = None
|
||
# 传感器加入变量结束
|
||
# self.setWindowFlags(Qt.WindowType.FramelessWindowHint)
|
||
self.thread_signal = True
|
||
self.init_qss()
|
||
self.init_UI()
|
||
self.init_Run()
|
||
self.init_robot_info()
|
||
self.init_IOPanel()
|
||
self.start_Runing()
|
||
self.init_log()
|
||
self.init_FeedLine()
|
||
self.init_table_lines()
|
||
self.init_table_position()
|
||
self.table_line_changed = False
|
||
self.table_position_changed = False
|
||
self.selected_line_section = ""
|
||
|
||
def init_IOPanel(self):
|
||
self.dirt_io_points = {}
|
||
self.dirt_io_points.setdefault("y1", self.widget_y1)
|
||
self.dirt_io_points.setdefault("y2", self.widget_y2)
|
||
self.dirt_io_points.setdefault("y3", self.widget_y3)
|
||
self.dirt_io_points.setdefault("y4", self.widget_y4)
|
||
self.dirt_io_points.setdefault("y5", self.widget_y5)
|
||
self.dirt_io_points.setdefault("y6", self.widget_y6)
|
||
self.dirt_io_points.setdefault("y7", self.widget_y7)
|
||
self.dirt_io_points.setdefault("y8", self.widget_y8)
|
||
self.dirt_io_points.setdefault("y9", self.widget_y9)
|
||
self.dirt_io_points.setdefault("y10", self.widget_y10)
|
||
self.dirt_io_points.setdefault("y11", self.widget_y11)
|
||
self.dirt_io_points.setdefault("y12", self.widget_y12)
|
||
self.dirt_io_points.setdefault("y13", self.widget_y13)
|
||
self.dirt_io_points.setdefault("y14", self.widget_y14)
|
||
self.dirt_io_points.setdefault("y15", self.widget_y15)
|
||
self.dirt_io_points.setdefault("y16", self.widget_y16)
|
||
self.dirt_io_points.setdefault("y17", self.widget_y17)
|
||
self.dirt_io_points.setdefault("y18", self.widget_y18)
|
||
self.dirt_io_points.setdefault("y19", self.widget_y19)
|
||
self.dirt_io_points.setdefault("y20", self.widget_y20)
|
||
self.dirt_io_points.setdefault("y21", self.widget_y21)
|
||
self.dirt_io_points.setdefault("y22", self.widget_y22)
|
||
self.dirt_io_points.setdefault("y23", self.widget_y23)
|
||
self.dirt_io_points.setdefault("y24", self.widget_y24)
|
||
self.dirt_io_points.setdefault("y25", self.widget_y25)
|
||
self.dirt_io_points.setdefault("y26", self.widget_y26)
|
||
self.dirt_io_points.setdefault("y27", self.widget_y27)
|
||
self.dirt_io_points.setdefault("y28", self.widget_y28)
|
||
self.dirt_io_points.setdefault("y29", self.widget_y29)
|
||
self.dirt_io_points.setdefault("y30", self.widget_y30)
|
||
self.dirt_io_points.setdefault("y31", self.widget_y31)
|
||
self.dirt_io_points.setdefault("y32", self.widget_y32)
|
||
|
||
self.widget_y1.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y1.index = 1
|
||
self.widget_y2.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y2.index = 2
|
||
self.widget_y3.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y3.index = 3
|
||
self.widget_y4.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y4.index = 4
|
||
self.widget_y5.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y5.index = 5
|
||
self.widget_y6.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y6.index = 6
|
||
self.widget_y7.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y7.index = 7
|
||
self.widget_y8.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y8.index = 8
|
||
self.widget_y9.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y9.index = 9
|
||
self.widget_y10.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y10.index = 10
|
||
self.widget_y11.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y11.index = 11
|
||
self.widget_y12.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y12.index = 12
|
||
self.widget_y13.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y13.index = 13
|
||
self.widget_y14.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y14.index = 14
|
||
self.widget_y15.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y15.index = 15
|
||
self.widget_y16.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y16.index = 16
|
||
self.widget_y17.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y17.index = 17
|
||
self.widget_y18.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y18.index = 18
|
||
self.widget_y19.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y19.index = 19
|
||
self.widget_y20.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y20.index = 20
|
||
self.widget_y21.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y21.index = 21
|
||
self.widget_y22.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y22.index = 22
|
||
self.widget_y23.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y23.index = 23
|
||
self.widget_y24.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y24.index = 24
|
||
self.widget_y25.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y25.index = 25
|
||
self.widget_y26.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y26.index = 26
|
||
self.widget_y27.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y27.index = 27
|
||
self.widget_y28.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y28.index = 28
|
||
self.widget_y29.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y29.index = 29
|
||
self.widget_y30.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y30.index = 30
|
||
self.widget_y31.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y31.index = 31
|
||
self.widget_y32.clicked.connect(self.send_IO_Point_OpenOrClose)
|
||
self.widget_y32.index = 32
|
||
|
||
# region 战线，点位表格初始化
|
||
def init_table_lines(self):
|
||
self.tableWidget_lines.setColumnCount(4)
|
||
|
||
self.tableWidget_lines.horizontalHeader().setStyleSheet(
|
||
f"background-color: {QColor(44,44,44).name()};"
|
||
)
|
||
self.tableWidget_lines.verticalHeader().setStyleSheet(
|
||
f"background-color: {QColor(44,44,44).name()};"
|
||
)
|
||
self.tableWidget_lines.verticalHeader().hide()
|
||
self.tableWidget_lines.setHorizontalHeaderLabels(["节名", "线名", "id", "操作"])
|
||
self.tableWidget_lines.setSelectionBehavior(QTableWidget.SelectRows)
|
||
self.tableWidget_lines.setAutoScroll(True)
|
||
self.tableWidget_lines.setColumnHidden(0, True)
|
||
self.tableWidget_lines.setColumnHidden(2, True)
|
||
|
||
# 自动调整列宽
|
||
header = self.tableWidget_lines.horizontalHeader()
|
||
header.setSectionResizeMode(0, PySide6.QtWidgets.QHeaderView.ResizeMode.Stretch)
|
||
header.setSectionResizeMode(1, PySide6.QtWidgets.QHeaderView.ResizeMode.Stretch)
|
||
header.setSectionResizeMode(2, PySide6.QtWidgets.QHeaderView.ResizeMode.Stretch)
|
||
self.tableWidget_lines.setContextMenuPolicy(
|
||
PySide6.QtCore.Qt.ContextMenuPolicy.CustomContextMenu
|
||
)
|
||
self.tableWidget_lines.customContextMenuRequested.connect(
|
||
self.show_lines_context_menu
|
||
)
|
||
|
||
self.tableWidget_lines.cellChanged.connect(self.send_table_lines_cell_changed)
|
||
self.init_table_lines_data()
|
||
|
||
self.pushButton_savePosition.clicked.connect(self.send_save_lines_data)
|
||
|
||
def send_table_line_position_cell_changed(self):
|
||
self.table_position_changed = True
|
||
|
||
def send_table_lines_cell_changed(self):
|
||
self.table_line_changed = True
|
||
|
||
def send_save_lines_data(self):
|
||
if self.table_position_changed or self.table_line_changed:
|
||
section = self.selected_line_section
|
||
for row_i in range(self.tableWidget_lines.rowCount()):
|
||
if self.tableWidget_lines.item(row_i, 0).text() == section:
|
||
line_model = LineModel()
|
||
if len(
|
||
self.get_table_positions()
|
||
) == 0 and self.feedLine_dict.keys().__contains__(section):
|
||
line_model = self.feedLine_dict[section]
|
||
line_model.name = self.tableWidget_lines.item(row_i, 1).text()
|
||
else:
|
||
line_model.section = section
|
||
line_model.name = self.tableWidget_lines.item(row_i, 1).text()
|
||
line_model.id = int(
|
||
self.tableWidget_lines.item(row_i, 2).text()
|
||
)
|
||
line_model.positions = self.get_table_positions()
|
||
config_reader = configparser.ConfigParser()
|
||
config_reader.read(Constant.feedLine_set_file, encoding="utf-8")
|
||
if (
|
||
len(self.get_table_positions()) != 0
|
||
and line_model.id != self.get_table_positions()[0].lineId
|
||
):
|
||
return
|
||
line_model.save_line_model(config_reader)
|
||
config_reader.write(
|
||
open(Constant.feedLine_set_file, "w", encoding="utf-8")
|
||
)
|
||
self.init_FeedLine()
|
||
break
|
||
self.init_table_lines_data()
|
||
self.table_line_changed = False
|
||
self.table_position_changed = False
|
||
|
||
def get_table_positions(self):
|
||
position_models = []
|
||
for row_i in range(self.tableWidget_line_positions.rowCount()):
|
||
section = self.tableWidget_line_positions.item(row_i, 0).text()
|
||
position_model = PositionModel(index=row_i)
|
||
position_model.section = section
|
||
position_model.X = float(
|
||
self.tableWidget_line_positions.item(row_i, 1).text()
|
||
)
|
||
position_model.Y = float(
|
||
self.tableWidget_line_positions.item(row_i, 2).text()
|
||
)
|
||
position_model.Z = float(
|
||
self.tableWidget_line_positions.item(row_i, 3).text()
|
||
)
|
||
position_model.U = float(
|
||
self.tableWidget_line_positions.item(row_i, 4).text()
|
||
)
|
||
position_model.V = float(
|
||
self.tableWidget_line_positions.item(row_i, 5).text()
|
||
)
|
||
position_model.W = float(
|
||
self.tableWidget_line_positions.item(row_i, 6).text()
|
||
)
|
||
combox_line_type = self.tableWidget_line_positions.cellWidget(row_i, 7)
|
||
position_model.lineType = combox_line_type.currentData()
|
||
combox_status = self.tableWidget_line_positions.cellWidget(row_i, 8)
|
||
position_model.status = combox_status.currentData()
|
||
|
||
position_model.id = int(
|
||
self.tableWidget_line_positions.item(row_i, 9).text()
|
||
)
|
||
position_model.order = row_i
|
||
position_model.lineId = int(
|
||
self.tableWidget_line_positions.item(row_i, 11).text()
|
||
)
|
||
position_models.append(position_model)
|
||
return position_models
|
||
|
||
def init_table_lines_data(self):
|
||
# self.tableWidget_lines.setItem(0, 0, QTableWidgetItem("线1"))
|
||
# self.tableWidget_lines.setItem(1, 0, QTableWidgetItem("线2"))
|
||
# self.tableWidget_lines.setItem()
|
||
self.tableWidget_lines.blockSignals(True)
|
||
self.selected_line_section = ""
|
||
self.table_line_changed = False
|
||
self.table_position_changed = False
|
||
self.tableWidget_lines.setRowCount(0)
|
||
for key, value in self.feedLine_dict.items():
|
||
self.tableWidget_lines.insertRow(self.tableWidget_lines.rowCount())
|
||
self.tableWidget_lines.setItem(
|
||
self.tableWidget_lines.rowCount() - 1, 0, QTableWidgetItem(key)
|
||
)
|
||
self.tableWidget_lines.setItem(
|
||
self.tableWidget_lines.rowCount() - 1, 1, QTableWidgetItem(value.name)
|
||
)
|
||
self.tableWidget_lines.setItem(
|
||
self.tableWidget_lines.rowCount() - 1,
|
||
2,
|
||
QTableWidgetItem(str(value.id)),
|
||
)
|
||
show_pos_btn = QPushButton("显示路径")
|
||
show_pos_btn.clicked.connect(
|
||
lambda _, index=self.tableWidget_lines.rowCount() - 1: self.show_lines_pos_data(
|
||
index
|
||
)
|
||
)
|
||
self.tableWidget_lines.setCellWidget(
|
||
self.tableWidget_lines.rowCount() - 1, 3, show_pos_btn
|
||
)
|
||
|
||
self.selected_line_section = ""
|
||
self.tableWidget_line_positions.setRowCount(0)
|
||
self.tableWidget_lines.blockSignals(False)
|
||
|
||
def show_lines_context_menu(self):
|
||
menu = QMenu(self)
|
||
action_add = menu.addAction("添加投料线")
|
||
action_del = menu.addAction("删除投料线")
|
||
action = menu.exec(QCursor.pos())
|
||
if action == action_add:
|
||
self.add_new_line()
|
||
elif action == action_del:
|
||
self.del_line()
|
||
|
||
def del_line(self):
|
||
if self.tableWidget_lines.rowCount() == 0:
|
||
return
|
||
if self.tableWidget_lines.currentRow() == -1:
|
||
return
|
||
self.tableWidget_lines.removeRow(self.tableWidget_lines.currentRow())
|
||
self.table_line_changed = True
|
||
|
||
def add_new_line(self):
|
||
add_section = f"{Constant.feedLine_set_section}{1}"
|
||
for i in range(1, Constant.MAX_Line_num):
|
||
if not self.feedLine_dict.get(f"{Constant.feedLine_set_section}{i}"):
|
||
add_section = f"{Constant.feedLine_set_section}{i}"
|
||
break
|
||
|
||
self.tableWidget_lines.insertRow(self.tableWidget_lines.rowCount())
|
||
self.tableWidget_lines.setItem(
|
||
self.tableWidget_lines.rowCount() - 1, 0, QTableWidgetItem(add_section)
|
||
)
|
||
self.tableWidget_lines.setItem(
|
||
self.tableWidget_lines.rowCount() - 1,
|
||
1,
|
||
QTableWidgetItem("线" + str(self.tableWidget_lines.rowCount())),
|
||
)
|
||
self.tableWidget_lines.setItem(
|
||
self.tableWidget_lines.rowCount() - 1, 2, QTableWidgetItem(str(i))
|
||
)
|
||
show_pos_btn = QPushButton("显示路径")
|
||
show_pos_btn.clicked.connect(
|
||
lambda _, index=self.tableWidget_lines.rowCount() - 1: self.show_lines_pos_data(
|
||
index
|
||
)
|
||
)
|
||
self.tableWidget_lines.setCellWidget(
|
||
self.tableWidget_lines.rowCount() - 1, 3, show_pos_btn
|
||
)
|
||
|
||
self.table_position_changed = True
|
||
self.feedLine_dict[add_section] = LineModel(i)
|
||
|
||
def show_lines_pos_data(self, line_index):
|
||
if (
|
||
self.selected_line_section != ""
|
||
and self.selected_line_section
|
||
!= self.tableWidget_lines.item(line_index, 0).text()
|
||
):
|
||
if self.table_position_changed or self.table_line_changed:
|
||
msgBox = QMessageBox()
|
||
msgBox.setText("已修改的数据，是否保存？")
|
||
msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
|
||
result = msgBox.exec()
|
||
if result == QMessageBox.StandardButton.Ok:
|
||
self.send_save_lines_data()
|
||
return
|
||
else:
|
||
# 重新初始化·
|
||
self.init_table_lines_data()
|
||
self.table_line_changed = False
|
||
self.table_position_changed = False
|
||
line_name = self.tableWidget_lines.item(line_index, 0).text()
|
||
line_model = self.feedLine_dict.get(line_name)
|
||
self.init_table_positions_data(line_model.positions)
|
||
self.selected_line_section = line_name
|
||
self.label_table_line_position_title.setText(line_model.name)
|
||
|
||
def init_table_position(self):
|
||
# self.tableWidget_line_positions.setRowCount(5)
|
||
self.tableWidget_line_positions.setColumnCount(14)
|
||
|
||
self.tableWidget_line_positions.setHorizontalHeaderLabels(
|
||
[
|
||
"节段",
|
||
"X",
|
||
"Y",
|
||
"Z",
|
||
"U",
|
||
"V",
|
||
"W",
|
||
"运动类型",
|
||
"点位类型",
|
||
"序号",
|
||
"排序",
|
||
"线号",
|
||
"操作1",
|
||
"操作2",
|
||
]
|
||
)
|
||
self.tableWidget_line_positions.setSelectionBehavior(QTableWidget.SelectRows)
|
||
self.tableWidget_line_positions.setColumnHidden(0, True)
|
||
self.tableWidget_line_positions.setColumnHidden(9, True)
|
||
self.tableWidget_line_positions.setColumnHidden(10, True)
|
||
self.tableWidget_line_positions.setColumnHidden(11, True)
|
||
self.tableWidget_line_positions.setAutoScroll(True)
|
||
self.tableWidget_line_positions.verticalHeader().hide()
|
||
# 自动调整列宽
|
||
header = self.tableWidget_line_positions.horizontalHeader()
|
||
header.setSectionResizeMode(
|
||
0, PySide6.QtWidgets.QHeaderView.ResizeMode.Interactive
|
||
)
|
||
self.tableWidget_line_positions.setHorizontalScrollBarPolicy(
|
||
PySide6.QtCore.Qt.ScrollBarPolicy.ScrollBarAsNeeded
|
||
)
|
||
for i in range(14):
|
||
header.setSectionResizeMode(
|
||
i, PySide6.QtWidgets.QHeaderView.ResizeMode.Interactive
|
||
)
|
||
self.tableWidget_line_positions.setContextMenuPolicy(
|
||
PySide6.QtCore.Qt.ContextMenuPolicy.CustomContextMenu
|
||
)
|
||
self.tableWidget_line_positions.customContextMenuRequested.connect(
|
||
self.show_positions_context_menu
|
||
)
|
||
self.tableWidget_line_positions.cellChanged.connect(
|
||
self.send_table_line_position_cell_changed
|
||
)
|
||
|
||
def init_table_positions_data(self, position_list):
|
||
self.tableWidget_line_positions.blockSignals(True)
|
||
self.tableWidget_line_positions.setRowCount(0)
|
||
for index, position_model in enumerate(position_list):
|
||
self.tableWidget_line_positions.insertRow(
|
||
self.tableWidget_line_positions.rowCount()
|
||
)
|
||
self.set_positionModel_to_tabel(index, position_model)
|
||
self.tableWidget_line_positions.blockSignals(False)
|
||
|
||
def show_positions_context_menu(self):
|
||
menu = QMenu(self)
|
||
action_add = menu.addAction("添加位置节点")
|
||
action_del = menu.addAction("删除位置节点")
|
||
action = menu.exec(QCursor.pos())
|
||
if action == action_add:
|
||
self.add_new_position()
|
||
elif action == action_del:
|
||
self.del_position()
|
||
|
||
def del_position(self):
|
||
if self.tableWidget_line_positions.rowCount() == 0:
|
||
return
|
||
if self.tableWidget_line_positions.currentRow() == -1:
|
||
return
|
||
section = self.tableWidget_line_positions.item(
|
||
self.tableWidget_line_positions.currentRow(), 0
|
||
).text()
|
||
|
||
id = int(
|
||
self.tableWidget_line_positions.item(
|
||
self.tableWidget_line_positions.currentRow(), 9
|
||
).text()
|
||
)
|
||
line_model = self.feedLine_dict.get(self.selected_line_section)
|
||
for pos_model in line_model.positions:
|
||
if pos_model.id == id:
|
||
line_model.positions.remove(pos_model)
|
||
break
|
||
self.tableWidget_line_positions.removeRow(
|
||
self.tableWidget_line_positions.currentRow()
|
||
)
|
||
|
||
config_writer = configparser.ConfigParser()
|
||
config_writer.read(Constant.feedLine_set_file, encoding="utf-8")
|
||
config_writer.remove_section(section)
|
||
config_writer.write(open(Constant.feedLine_set_file, "w", encoding="utf-8"))
|
||
|
||
self.table_position_changed = True
|
||
|
||
def add_new_position(self): # 选中添加
|
||
if self.selected_line_section == "":
|
||
return
|
||
config_reader = configparser.ConfigParser()
|
||
config_reader.read(Constant.feedLine_set_file, encoding="utf-8")
|
||
position_model = PositionModel(999)
|
||
ids = []
|
||
for j in range(self.tableWidget_line_positions.rowCount()):
|
||
ids.append(int(self.tableWidget_line_positions.item(j, 9).text()))
|
||
for i in range(1, Constant.MAX_Position_num):
|
||
if not config_reader.has_section(f"{Constant.position_set_section}{i}"):
|
||
if ids.__contains__(i):
|
||
continue
|
||
position_model = PositionModel(i)
|
||
break
|
||
if self.tableWidget_line_positions.currentRow() == -1:
|
||
row_i = self.tableWidget_line_positions.rowCount()
|
||
else:
|
||
row_i = self.tableWidget_line_positions.currentRow()
|
||
|
||
# self.tableWidget_line_positions.setRowCount(self.tableWidget_line_positions.rowCount()+1)
|
||
self.tableWidget_line_positions.insertRow(row_i + 1)
|
||
|
||
position_model.order = 0
|
||
position_model.status = 1
|
||
line_model = self.feedLine_dict.get(self.selected_line_section)
|
||
line_id = line_model.id
|
||
position_model.lineId = line_id
|
||
self.set_positionModel_to_tabel(row_i + 1, position_model)
|
||
self.table_line_changed = True
|
||
|
||
def tabel_move_position(self, row_i):
|
||
if self.tableWidget_line_positions.currentRow() == -1:
|
||
QMessageBox.information(self, "提示", Constant.str_sys_set_position_error)
|
||
return
|
||
|
||
row_i = self.tableWidget_line_positions.currentRow()
|
||
combox_line_type = self.tableWidget_line_positions.cellWidget(row_i, 7)
|
||
lineType = combox_line_type.currentData()
|
||
p1 = Real_Position().init_position(
|
||
float(self.tableWidget_line_positions.item(row_i, 1).text()),
|
||
float(self.tableWidget_line_positions.item(row_i, 2).text()),
|
||
float(self.tableWidget_line_positions.item(row_i, 3).text()),
|
||
float(self.tableWidget_line_positions.item(row_i, 4).text()),
|
||
float(self.tableWidget_line_positions.item(row_i, 5).text()),
|
||
float(self.tableWidget_line_positions.item(row_i, 6).text()),
|
||
)
|
||
if lineType == 0: # 直线
|
||
if row_i != 0:
|
||
combox_line_type_inner = self.tableWidget_line_positions.cellWidget(
|
||
row_i - 1, 7
|
||
)
|
||
lineType_inner = combox_line_type_inner.currentData()
|
||
if lineType_inner == 2:
|
||
p2 = Real_Position().init_position(
|
||
float(
|
||
self.tableWidget_line_positions.item(row_i - 1, 1).text()
|
||
),
|
||
float(
|
||
self.tableWidget_line_positions.item(row_i - 1, 2).text()
|
||
),
|
||
float(
|
||
self.tableWidget_line_positions.item(row_i - 1, 3).text()
|
||
),
|
||
float(
|
||
self.tableWidget_line_positions.item(row_i - 1, 4).text()
|
||
),
|
||
float(
|
||
self.tableWidget_line_positions.item(row_i - 1, 5).text()
|
||
),
|
||
float(
|
||
self.tableWidget_line_positions.item(row_i - 1, 6).text()
|
||
),
|
||
)
|
||
self.send_position_command(
|
||
x1=p1.X,
|
||
x2=p1.Y,
|
||
x3=p1.Z,
|
||
x4=p1.U,
|
||
x5=p1.V,
|
||
x6=p1.W,
|
||
move_type=MoveType.Cure,
|
||
speed=self.robotClient.debug_speed,
|
||
p2=p2,
|
||
)
|
||
return
|
||
self.send_position_command(
|
||
x1=p1.X,
|
||
x2=p1.Y,
|
||
x3=p1.Z,
|
||
x4=p1.U,
|
||
x5=p1.V,
|
||
x6=p1.W,
|
||
move_type=MoveType.WORLD,
|
||
speed=self.robotClient.debug_speed,
|
||
)
|
||
return
|
||
if lineType == 4: # 自由路径
|
||
self.send_position_command(
|
||
x1=p1.X,
|
||
x2=p1.Y,
|
||
x3=p1.Z,
|
||
x4=p1.U,
|
||
x5=p1.V,
|
||
x6=p1.W,
|
||
move_type=MoveType.AXIS,
|
||
speed=self.robotClient.debug_speed,
|
||
)
|
||
return
|
||
|
||
def tabel_get_position(self, row_i):
|
||
if self.tableWidget_line_positions.currentRow() == -1:
|
||
QMessageBox.information(self, "提示", Constant.str_sys_set_position_error)
|
||
return
|
||
|
||
row_i = self.tableWidget_line_positions.currentRow()
|
||
combox_line_type = self.tableWidget_line_positions.cellWidget(row_i, 7)
|
||
lineType = combox_line_type.currentData()
|
||
if lineType == 4:
|
||
self.set_position_tabel(row_i, self.status_address.getAnglePosition())
|
||
else:
|
||
self.set_position_tabel(row_i, self.status_address.getRealPosition())
|
||
self.table_line_changed = True
|
||
|
||
def tabel_delete_position(self, row_i):
|
||
self.tableWidget_line_positions.removeRow(row_i)
|
||
self.table_line_changed = True
|
||
|
||
def set_positionModel_to_tabel(self, row_i, position_model: PositionModel):
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 0, QTableWidgetItem(str(position_model.section))
|
||
)
|
||
self.set_position_tabel(row_i, position_model.get_position())
|
||
combox_lineType = QComboBox()
|
||
combox_lineType.addItem("直线", 0)
|
||
combox_lineType.addItem("曲线中间点", 2)
|
||
combox_lineType.addItem("曲线终点", 3)
|
||
combox_lineType.addItem("自由路径", 4)
|
||
combox_lineType.setCurrentIndex(
|
||
combox_lineType.findData(position_model.lineType)
|
||
)
|
||
combox_lineType.currentIndexChanged.connect(
|
||
self.send_table_position_status_changed
|
||
)
|
||
self.tableWidget_line_positions.setCellWidget(row_i, 7, combox_lineType)
|
||
|
||
combox = QComboBox()
|
||
combox.addItem("初始化点", 2)
|
||
combox.addItem("中间点", 3)
|
||
combox.addItem("相机/待抓点", 4)
|
||
combox.addItem("抓取前点", 3)
|
||
combox.addItem("抓取", 5)
|
||
combox.addItem("抓取后点", 3)
|
||
combox.addItem("破带点1", 6)
|
||
combox.addItem("破带点2", 7)
|
||
combox.addItem("震动点", 8)
|
||
combox.addItem("扔带点", 9)
|
||
combox.setCurrentIndex(combox.findData(position_model.status))
|
||
combox.currentIndexChanged.connect(self.send_table_position_status_changed)
|
||
self.tableWidget_line_positions.setCellWidget(row_i, 8, combox)
|
||
# self.tableWidget_line_positions.setItem(row_i, 7, QTableWidgetItem(str(position_model.status)))
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 9, QTableWidgetItem(str(position_model.id))
|
||
)
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 10, QTableWidgetItem(str(position_model.order))
|
||
)
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 11, QTableWidgetItem(str(position_model.lineId))
|
||
)
|
||
|
||
get_pos_btn = QPushButton("获取点位")
|
||
get_pos_btn.clicked.connect(
|
||
lambda _, index=row_i: self.tabel_get_position(index)
|
||
)
|
||
self.tableWidget_line_positions.setCellWidget(row_i, 12, get_pos_btn)
|
||
|
||
move_pos_btn = QPushButton("移至点位")
|
||
move_pos_btn.clicked.connect(
|
||
lambda _, index=row_i: self.tabel_move_position(index)
|
||
)
|
||
self.tableWidget_line_positions.setCellWidget(row_i, 13, move_pos_btn)
|
||
|
||
def send_table_position_status_changed(self):
|
||
self.table_position_changed = True
|
||
|
||
def set_position_tabel(self, row_i, position):
|
||
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 1, QTableWidgetItem(str(position.X))
|
||
)
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 2, QTableWidgetItem(str(position.Y))
|
||
)
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 3, QTableWidgetItem(str(position.Z))
|
||
)
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 4, QTableWidgetItem(str(position.U))
|
||
)
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 5, QTableWidgetItem(str(position.V))
|
||
)
|
||
self.tableWidget_line_positions.setItem(
|
||
row_i, 6, QTableWidgetItem(str(position.W))
|
||
)
|
||
|
||
# endregion
|
||
def init_qss(self):
|
||
pass
|
||
|
||
def init_log(self):
|
||
log.log_info_signal.connect(self.log_info_message)
|
||
log.log_error_signal.connect(self.log_error_message)
|
||
log.log_warning_signal.connect(self.log_warning_message)
|
||
log.init_log(
|
||
self.textEdit_log_info, self.textEdit_log_error, Constant.log_file_path
|
||
)
|
||
log.log_message(logging.INFO, Constant.str_sys_start)
|
||
|
||
def log_info_message(self, message):
|
||
now = datetime.now()
|
||
formatted_time = now.strftime("%Y-%m-%d %H:%M:%S")
|
||
self.textEdit_log_info.append(f"{formatted_time}-提示： {message}")
|
||
|
||
def log_warning_message(self, message):
|
||
now = datetime.now()
|
||
formatted_time = now.strftime("%Y-%m-%d %H:%M:%S")
|
||
self.textEdit_log_info.append(f"{formatted_time}-注意： {message}")
|
||
self.textEdit_log_error.append(f"{formatted_time}-注意： {message}")
|
||
|
||
def log_error_message(self, message):
|
||
now = datetime.now()
|
||
formatted_time = now.strftime("%Y-%m-%d %H:%M:%S")
|
||
self.textEdit_log_info.append(f"{formatted_time}-报警： {message}")
|
||
self.textEdit_log_error.append(f"{formatted_time}-报警： {message}")
|
||
if self.tabWidget.currentIndex() != 1:
|
||
self.tabWidget.setCurrentIndex(1)
|
||
|
||
def init_UI(self):
|
||
self.pushButton_num1.clicked.connect(self.send_num_button_click)
|
||
self.pushButton_num2.clicked.connect(self.send_num_button_click)
|
||
self.pushButton_num3.clicked.connect(self.send_num_button_click)
|
||
self.pushButton_num4.clicked.connect(self.send_num_button_click)
|
||
self.pushButton_num5.clicked.connect(self.send_num_button_click)
|
||
self.pushButton_num6.clicked.connect(self.send_num_button_click)
|
||
self.pushButton_AddNum.clicked.connect(self.send_addNum_button_click)
|
||
self.pushButton_SubNum.clicked.connect(self.send_subNum_button_click)
|
||
|
||
self.lineEdit_j1.returnPressed.connect(self.send_position_returnPressed)
|
||
self.lineEdit_j2.returnPressed.connect(self.send_position_returnPressed)
|
||
self.lineEdit_j3.returnPressed.connect(self.send_position_returnPressed)
|
||
self.lineEdit_j4.returnPressed.connect(self.send_position_returnPressed)
|
||
self.lineEdit_j5.returnPressed.connect(self.send_position_returnPressed)
|
||
self.lineEdit_j6.returnPressed.connect(self.send_position_returnPressed)
|
||
self.pushButton_sendMove.clicked.connect(self.send_position_returnPressed)
|
||
|
||
self.pushButton_j1_sub.clicked.connect(self.send_subOneAsix_button_click)
|
||
self.pushButton_j2_sub.clicked.connect(self.send_subOneAsix_button_click)
|
||
self.pushButton_j3_sub.clicked.connect(self.send_subOneAsix_button_click)
|
||
self.pushButton_j4_sub.clicked.connect(self.send_subOneAsix_button_click)
|
||
self.pushButton_j5_sub.clicked.connect(self.send_subOneAsix_button_click)
|
||
self.pushButton_j6_sub.clicked.connect(self.send_subOneAsix_button_click)
|
||
|
||
self.pushButton_j1_add.clicked.connect(self.send_addOneAsix_button_click)
|
||
self.pushButton_j2_add.clicked.connect(self.send_addOneAsix_button_click)
|
||
self.pushButton_j3_add.clicked.connect(self.send_addOneAsix_button_click)
|
||
self.pushButton_j4_add.clicked.connect(self.send_addOneAsix_button_click)
|
||
self.pushButton_j5_add.clicked.connect(self.send_addOneAsix_button_click)
|
||
self.pushButton_j6_add.clicked.connect(self.send_addOneAsix_button_click)
|
||
|
||
self.pushButton_stopFeed.clicked.connect(self.send_stopFeed_button_click)
|
||
self.pushButton_pauseFeed.clicked.connect(self.send_pauseFeed_button_click)
|
||
|
||
self.pushButton_get_p1.clicked.connect(self.get_p1_button_click)
|
||
self.pushButton_get_p2.clicked.connect(self.get_p2_button_click)
|
||
self.pushButton_get_p3.clicked.connect(self.get_p3_button_click)
|
||
self.pushButton_get_p4.clicked.connect(self.get_p4_button_click)
|
||
self.pushButton_get_p5.clicked.connect(self.get_p5_button_click)
|
||
self.pushButton_get_origin.clicked.connect(self.get_origin_button_click)
|
||
|
||
self.pushButton_set_p1.clicked.connect(self.set_p1_button_click)
|
||
self.pushButton_set_p2.clicked.connect(self.set_p2_button_click)
|
||
self.pushButton_set_p3.clicked.connect(self.set_p3_button_click)
|
||
self.pushButton_set_p4.clicked.connect(self.set_p4_button_click)
|
||
self.pushButton_set_p5.clicked.connect(self.set_p5_button_click)
|
||
self.pushButton_set_origin.clicked.connect(self.set_origin_button_click)
|
||
|
||
self.pushButton_clearAlarm.clicked.connect(self.send_clear_alarm_command)
|
||
self.pushButton_emergency.clicked.connect(self.send_emergency_alarm_command)
|
||
self.pushButton_reset.clicked.connect(self.send_reset_button_click)
|
||
|
||
self.pushButton_saveSeting.clicked.connect(self.send_setSpeed_clicked)
|
||
|
||
self.pushButton_num_confirm.clicked.connect(self.send_custom_num_returnPressed)
|
||
|
||
# self.tabWidget_control.currentChanged.connect(self.send_tabWidget_control_change)
|
||
|
||
self.frame_sys_seting.setVisible(False)
|
||
self.pushButton_sysseting.clicked.connect(self.send_click_sysmeuExpand)
|
||
|
||
self.pushButton_leftmenu_produce.clicked.connect(
|
||
lambda _, index=0: self.send_click_change_stackView(index)
|
||
)
|
||
self.pushButton_leftmenu_robot_seting.clicked.connect(
|
||
lambda _, index=2: self.send_click_change_stackView(index)
|
||
)
|
||
self.pushButton_leftmenu_IO.clicked.connect(
|
||
lambda _, index=1: self.send_click_change_stackView(index)
|
||
)
|
||
self.pushButton_leftmenu_position.clicked.connect(
|
||
lambda _, index=5: self.send_click_change_stackView(index)
|
||
)
|
||
self.pushButton_leftmenu_baseSeting.clicked.connect(
|
||
lambda _, index=3: self.send_click_change_stackView(index)
|
||
)
|
||
self.pushButton_leftmenu_posDebug.clicked.connect(
|
||
lambda _, index=4: self.send_click_change_stackView(index)
|
||
)
|
||
self.pushButton_exit.clicked.connect(self.send_exit_button_click)
|
||
self.pushButton_onekeyfeed.clicked.connect(self.send_onekeyfeed_button_click)
|
||
|
||
int_validator = QIntValidator(0, 100, self.lineEdit_num)
|
||
self.lineEdit_num.setValidator(int_validator)
|
||
|
||
# self.horizontalSlider_J1.sliderReleased
|
||
|
||
self.pushButton_startFeed.clicked.connect(self.send_startFeed_button_click)
|
||
|
||
self.horizontalSlider_feedingNum.blockSignals(True)
|
||
self.horizontalSlider_feedingNum.setMinimum(0)
|
||
|
||
def init_Run(self):
|
||
self.robotClient = None
|
||
self.configReader = configparser.ConfigParser()
|
||
# TODO 关闭图像
|
||
self.command_position_quene = Queue()
|
||
self.status_address = DataAddress()
|
||
self.feedLine_dict = {}
|
||
self.command_quene = Queue()
|
||
self.main_threading = None
|
||
self.detection_person = None # DetectionPerson()
|
||
self.index = 1
|
||
|
||
self.configReader.read(Constant.set_ini)
|
||
ip = self.configReader.get("Robot_Feed", "IPAddress")
|
||
port = int(self.configReader.get("Robot_Feed", "Port"))
|
||
photo_locs = [
|
||
(
|
||
float(self.configReader.get("Robot_Feed", "photo_x1")),
|
||
float(self.configReader.get("Robot_Feed", "photo_y1")),
|
||
float(self.configReader.get("Robot_Feed", "photo_z1")),
|
||
float(self.configReader.get("Robot_Feed", "photo_u1")),
|
||
float(self.configReader.get("Robot_Feed", "photo_v1")),
|
||
float(self.configReader.get("Robot_Feed", "photo_w1")),
|
||
),
|
||
(
|
||
float(self.configReader.get("Robot_Feed", "photo_x2")),
|
||
float(self.configReader.get("Robot_Feed", "photo_y2")),
|
||
float(self.configReader.get("Robot_Feed", "photo_z2")),
|
||
float(self.configReader.get("Robot_Feed", "photo_u2")),
|
||
float(self.configReader.get("Robot_Feed", "photo_v2")),
|
||
float(self.configReader.get("Robot_Feed", "photo_w2")),
|
||
),
|
||
(
|
||
float(self.configReader.get("Robot_Feed", "photo_x3")),
|
||
float(self.configReader.get("Robot_Feed", "photo_y3")),
|
||
float(self.configReader.get("Robot_Feed", "photo_z3")),
|
||
float(self.configReader.get("Robot_Feed", "photo_u3")),
|
||
float(self.configReader.get("Robot_Feed", "photo_v3")),
|
||
float(self.configReader.get("Robot_Feed", "photo_w3")),
|
||
),
|
||
(
|
||
float(self.configReader.get("Robot_Feed", "photo_x4")),
|
||
float(self.configReader.get("Robot_Feed", "photo_y4")),
|
||
float(self.configReader.get("Robot_Feed", "photo_z4")),
|
||
float(self.configReader.get("Robot_Feed", "photo_u4")),
|
||
float(self.configReader.get("Robot_Feed", "photo_v4")),
|
||
float(self.configReader.get("Robot_Feed", "photo_w4")),
|
||
),
|
||
(
|
||
float(self.configReader.get("Robot_Feed", "photo_x5")),
|
||
float(self.configReader.get("Robot_Feed", "photo_y5")),
|
||
float(self.configReader.get("Robot_Feed", "photo_z5")),
|
||
float(self.configReader.get("Robot_Feed", "photo_u5")),
|
||
float(self.configReader.get("Robot_Feed", "photo_v5")),
|
||
float(self.configReader.get("Robot_Feed", "photo_w5")),
|
||
),
|
||
]
|
||
origin_position = Real_Position().init_position(
|
||
float(self.configReader.get("Origin", "X")),
|
||
float(self.configReader.get("Origin", "Y")),
|
||
float(self.configReader.get("Origin", "Z")),
|
||
float(self.configReader.get("Origin", "U")),
|
||
float(self.configReader.get("Origin", "V")),
|
||
float(self.configReader.get("Origin", "W")),
|
||
)
|
||
debug_speed = int(self.configReader.get("Speed", "debug_speed"))
|
||
feed_speed = int(self.configReader.get("Speed", "feed_speed"))
|
||
reset_speed = int(self.configReader.get("Speed", "reset_speed"))
|
||
io_take_addr = int(self.configReader.get("Robot_Feed", "io_take_addr"))
|
||
io_zip_addr = int(self.configReader.get("Robot_Feed", "io_zip_addr"))
|
||
io_shake_addr = int(self.configReader.get("Robot_Feed", "io_shake_addr"))
|
||
time_delay_take = float(self.configReader.get("Robot_Feed", "takeDelay"))
|
||
time_delay_put = float(self.configReader.get("Robot_Feed", "putDelay"))
|
||
time_delay_shake = float(self.configReader.get("Robot_Feed", "shakeDelay"))
|
||
max_angle_interval = float(
|
||
self.configReader.get("Robot_Feed", "max_angle_interval")
|
||
)
|
||
smooth = int(self.configReader.get("Robot_Feed", "smooth"))
|
||
dynamic_height = float(self.configReader.get("Robot_Feed", "dynamic_height"))
|
||
# TODO
|
||
# dropDelay_time = int(self.configReader.get('Robot_Feed', 'dropDelay_time'))
|
||
self.robotClient = RobotClient(
|
||
ip,
|
||
port,
|
||
photo_locs,
|
||
self.command_position_quene,
|
||
self.status_address,
|
||
[io_take_addr, io_zip_addr, io_shake_addr],
|
||
time_delay_take,
|
||
time_delay_put,
|
||
time_delay_shake,
|
||
origin_position,
|
||
)
|
||
self.robotClient.debug_speed = debug_speed
|
||
self.robotClient.feed_speed = feed_speed
|
||
self.robotClient.reset_speed = reset_speed
|
||
self.robotClient.max_angle_interval = max_angle_interval
|
||
self.robotClient.smooth = smooth
|
||
self.robotClient.dynamic_height = dynamic_height
|
||
self.feeding = Feeding(self.robotClient) # 临时
|
||
self.feeding.need_origin_signal.connect(self.show_infomessage_box)
|
||
self.feeding.take_no_photo_sigal.connect(self.show_no_photo_message_box)
|
||
self.feeding.update_detect_image.connect(self.updateUI_label_detection)
|
||
self.feeding.log_signal.connect(self.log_message)
|
||
self.last_time = time.time()
|
||
self.remain_lineName = self.configReader.get("Robot_Feed", "remain_lineName")
|
||
self.remain_Count = int(self.configReader.get("Robot_Feed", "remain_Count"))
|
||
self.updateUI_seting.connect(self.update_seting_frame)
|
||
try:
|
||
self.robotClient.CreatConnect()
|
||
except:
|
||
self.set_label_status_style(False)
|
||
return Error_Code.SYS_NETERROR
|
||
if self.robotClient.connected:
|
||
return 0
|
||
else:
|
||
return Error_Code.SYS_NETERROR
|
||
|
||
def init_seting_frame(self):
|
||
|
||
rows = len(self.feedLine_dict.keys()) + 1
|
||
self.tableWidget_feedSeting.setRowCount(rows)
|
||
self.tableWidget_feedSeting.setColumnCount(20 + 2 * 6)
|
||
# 设置第一重表头的合并 (三列一组)
|
||
self.tableWidget_feedSeting_addtional_col_num = 2
|
||
|
||
self.tableWidget_feedSeting.setSpan(
|
||
0, 0 + self.tableWidget_feedSeting_addtional_col_num, 1, 6
|
||
) # 合并前3列
|
||
self.tableWidget_feedSeting.setSpan(
|
||
0, 6 + self.tableWidget_feedSeting_addtional_col_num, 1, 6
|
||
) # 合并后3列
|
||
self.tableWidget_feedSeting.setSpan(
|
||
0, 12 + self.tableWidget_feedSeting_addtional_col_num, 1, 6
|
||
) # 合并后3列
|
||
self.tableWidget_feedSeting.setSpan(
|
||
0, 18 + self.tableWidget_feedSeting_addtional_col_num, 1, 6
|
||
) # 合并后3列
|
||
self.tableWidget_feedSeting.setSpan(
|
||
0, 24 + self.tableWidget_feedSeting_addtional_col_num, 1, 6
|
||
) # 合并后3列
|
||
|
||
self.tableWidget_feedSeting.itemChanged.connect(
|
||
self.send_tabelFeedSet_itemChanged
|
||
)
|
||
|
||
btn_safe = QPushButton("获取安全位置")
|
||
widget_safe = QWidget()
|
||
layout_safe = QHBoxLayout()
|
||
layout_safe.addWidget(btn_safe)
|
||
# 调整布局的间距，使之更紧凑
|
||
layout_safe.setContentsMargins(0, 0, 0, 0)
|
||
# 将布局设置到 QWidget 容器中
|
||
widget_safe.setLayout(layout_safe)
|
||
|
||
btn_bk1 = QPushButton("获取破袋位置1")
|
||
widget_bk1 = QWidget()
|
||
layout_bk1 = QHBoxLayout()
|
||
layout_bk1.addWidget(btn_bk1)
|
||
# 调整布局的间距，使之更紧凑
|
||
layout_bk1.setContentsMargins(0, 0, 0, 0)
|
||
# 将布局设置到 QWidget 容器中
|
||
widget_bk1.setLayout(layout_bk1)
|
||
|
||
btn_bk2 = QPushButton("获取破袋位置2")
|
||
widget_bk2 = QWidget()
|
||
layout_bk2 = QHBoxLayout()
|
||
layout_bk2.addWidget(btn_bk2)
|
||
# 调整布局的间距，使之更紧凑
|
||
layout_bk2.setContentsMargins(0, 0, 0, 0)
|
||
# 将布局设置到 QWidget 容器中
|
||
widget_bk2.setLayout(layout_bk2)
|
||
|
||
btn_shake = QPushButton("获取摇晃位置")
|
||
widget_shake = QWidget()
|
||
layout_shake = QHBoxLayout()
|
||
layout_shake.addWidget(btn_shake)
|
||
layout_shake.setContentsMargins(0, 0, 0, 0)
|
||
widget_shake.setLayout(layout_shake)
|
||
|
||
btn_dropbag = QPushButton("获取丢袋位置")
|
||
widget_dropbag = QWidget()
|
||
layout_dropbag = QHBoxLayout()
|
||
layout_dropbag.addWidget(btn_dropbag)
|
||
# 调整布局的间距，使之更紧凑
|
||
layout_dropbag.setContentsMargins(0, 0, 0, 0)
|
||
# 将布局设置到 QWidget 容器中
|
||
widget_dropbag.setLayout(layout_dropbag)
|
||
|
||
btn_safe.clicked.connect(self.send_get_safe_position_button_click)
|
||
btn_bk1.clicked.connect(self.send_get_broken1_position_button_click)
|
||
btn_bk2.clicked.connect(self.send_get_broken2_position_button_click)
|
||
btn_shake.clicked.connect(self.send_get_shake_position_button_click)
|
||
btn_dropbag.clicked.connect(self.send_get_dropbag_position_button_click)
|
||
|
||
# 添加第一重表头项
|
||
|
||
self.tableWidget_feedSeting.setCellWidget(
|
||
0, 0 + self.tableWidget_feedSeting_addtional_col_num, widget_safe
|
||
)
|
||
self.tableWidget_feedSeting.setCellWidget(
|
||
0, 6 + self.tableWidget_feedSeting_addtional_col_num, widget_bk1
|
||
)
|
||
self.tableWidget_feedSeting.setCellWidget(
|
||
0, 12 + self.tableWidget_feedSeting_addtional_col_num, widget_bk2
|
||
)
|
||
self.tableWidget_feedSeting.setCellWidget(
|
||
0, 18 + self.tableWidget_feedSeting_addtional_col_num, widget_shake
|
||
)
|
||
self.tableWidget_feedSeting.setCellWidget(
|
||
0, 24 + self.tableWidget_feedSeting_addtional_col_num, widget_dropbag
|
||
)
|
||
|
||
self.tableWidget_feedSeting.setSelectionBehavior(QTableWidget.SelectRows)
|
||
self.tableWidget_feedSeting.setAutoScroll(True)
|
||
# 添加第二重表头
|
||
self.tableWidget_feedSeting.setHorizontalHeaderLabels(
|
||
[
|
||
"header",
|
||
"线名",
|
||
"X1",
|
||
"Y1",
|
||
"Z1",
|
||
"U1",
|
||
"V1",
|
||
"W1",
|
||
"X2",
|
||
"Y2",
|
||
"Z2",
|
||
"U2",
|
||
"V2",
|
||
"W2",
|
||
"X3",
|
||
"Y3",
|
||
"Z3",
|
||
"U3",
|
||
"V3",
|
||
"W3",
|
||
"X4",
|
||
"Y4",
|
||
"Z4",
|
||
"U4",
|
||
"V4",
|
||
"W4",
|
||
"X5",
|
||
"Y5",
|
||
"Z5",
|
||
"U5",
|
||
"V5",
|
||
"W5",
|
||
]
|
||
)
|
||
|
||
self.tableWidget_feedSeting.hideColumn(0)
|
||
# 填充数据行
|
||
for row, (feed_line_key, feed_line) in enumerate(self.feedLine_dict.items()):
|
||
self.tableWidget_feedSeting.setItem(
|
||
row + 1, 0, QTableWidgetItem(feed_line_key)
|
||
)
|
||
self.tableWidget_feedSeting.setItem(
|
||
row + 1, 1, QTableWidgetItem(feed_line.name)
|
||
)
|
||
self.set_position_to_tabel(row + 1, 0, feed_line.safe_position)
|
||
self.set_position_to_tabel(row + 1, 1, feed_line.broken1_position)
|
||
self.set_position_to_tabel(row + 1, 2, feed_line.broken2_position)
|
||
self.set_position_to_tabel(row + 1, 3, feed_line.broken2_position)
|
||
self.set_position_to_tabel(row + 1, 4, feed_line.drop_bag_position)
|
||
|
||
# 禁用自动表头
|
||
self.tableWidget_feedSeting.verticalHeader().setVisible(True)
|
||
self.pushButton_tableFeedSet_addRow.clicked.connect(
|
||
self.send_tabelFeedSet_addRow
|
||
)
|
||
self.pushButton_tableFeedSet_deleRow.clicked.connect(
|
||
self.send_tabelFeedSet_delRow
|
||
)
|
||
self.pushButton_tableFeedSet_save.clicked.connect(self.send_tabelFeedSet_save)
|
||
|
||
def init_FeedLine(self):
|
||
# line_count = self.configReader.get('Robot_Feed', 'LineCount', fallback=0)
|
||
configReader = configparser.ConfigParser()
|
||
configReader.read(Constant.feedLine_set_file, encoding="utf-8")
|
||
for i in range(1, Constant.MAX_Line_num):
|
||
line_str = f"{Constant.feedLine_set_section}{i}"
|
||
if configReader.has_section(line_str):
|
||
feed_line = LineModel()
|
||
feed_line.read_line_model(config_reader=configReader, index=i)
|
||
self.feedLine_dict[f"{Constant.feedLine_set_section}{i}"] = feed_line
|
||
self.updateUI_Select_Line()
|
||
pass
|
||
|
||
def init_robot_info(self):
|
||
j1_min = int(self.configReader.get("Robot_Feed", "j1_min"))
|
||
j1_max = int(self.configReader.get("Robot_Feed", "j1_max"))
|
||
j2_min = int(self.configReader.get("Robot_Feed", "j2_min"))
|
||
j2_max = int(self.configReader.get("Robot_Feed", "j2_max"))
|
||
j3_min = int(self.configReader.get("Robot_Feed", "j3_min"))
|
||
j3_max = int(self.configReader.get("Robot_Feed", "j3_max"))
|
||
j4_min = int(self.configReader.get("Robot_Feed", "j4_min"))
|
||
j4_max = int(self.configReader.get("Robot_Feed", "j4_max"))
|
||
j5_min = int(self.configReader.get("Robot_Feed", "j5_min"))
|
||
j5_max = int(self.configReader.get("Robot_Feed", "j5_max"))
|
||
j6_min = int(self.configReader.get("Robot_Feed", "j6_min"))
|
||
j6_max = int(self.configReader.get("Robot_Feed", "j6_max"))
|
||
self.horizontalSlider_J1.setMinimum(j1_min)
|
||
self.horizontalSlider_J1.setMaximum(j1_max)
|
||
self.horizontalSlider_J2.setMinimum(j2_min)
|
||
self.horizontalSlider_J2.setMaximum(j2_max)
|
||
self.horizontalSlider_J3.setMinimum(j3_min)
|
||
self.horizontalSlider_J3.setMaximum(j3_max)
|
||
self.horizontalSlider_J4.setMinimum(j4_min)
|
||
self.horizontalSlider_J4.setMaximum(j4_max)
|
||
self.horizontalSlider_J5.setMinimum(j5_min)
|
||
self.horizontalSlider_J5.setMaximum(j5_max)
|
||
self.horizontalSlider_J6.setMinimum(j6_min)
|
||
self.horizontalSlider_J6.setMaximum(j6_max)
|
||
self.label_j1_min.setText(j1_min.__str__())
|
||
self.label_j1_max.setText(j1_max.__str__())
|
||
self.label_j2_min.setText(j2_min.__str__())
|
||
self.label_j2_max.setText(j2_max.__str__())
|
||
self.label_j3_min.setText(j3_min.__str__())
|
||
self.label_j3_max.setText(j3_max.__str__())
|
||
self.label_j4_min.setText(j4_min.__str__())
|
||
self.label_j4_max.setText(j4_max.__str__())
|
||
self.label_j5_min.setText(j5_min.__str__())
|
||
self.label_j5_max.setText(j5_max.__str__())
|
||
self.label_j6_min.setText(j6_min.__str__())
|
||
self.label_j6_max.setText(str(j6_max))
|
||
|
||
def start_Runing(self):
|
||
# 多线程启动
|
||
self.main_threading = Thread(target=self.run) # 主循环
|
||
self.robot_connect_threading = Thread(target=self.robotClient.run)
|
||
self.main_UI_threading = Thread(target=self.updateUI)
|
||
self.detect_person_thread = Thread(target=self.run_detect_persion)
|
||
self.main_threading.start()
|
||
self.robot_connect_threading.start()
|
||
self.main_UI_threading.start()
|
||
self.detect_person_thread.start()
|
||
pass
|
||
|
||
def check_continue(self):
|
||
if self.remain_Count != 0:
|
||
for key in self.feedLine_dict.keys():
|
||
feed_line = self.feedLine_dict[key]
|
||
if f"FeedLine{self.remain_lineName}" == key:
|
||
# 提示
|
||
remain_messageBox = QMessageBox()
|
||
remain_messageBox.setIcon(QMessageBox.Icon.Warning)
|
||
remain_messageBox.setText(
|
||
f"还有{self.remain_Count}袋未投料，是否继续？"
|
||
) # 这里返回多少袋没有投料
|
||
# remain_messageBox.setStandardButtons(QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel)
|
||
ok_button = remain_messageBox.addButton(
|
||
"确定", PySide6.QtWidgets.QMessageBox.ButtonRole.AcceptRole
|
||
)
|
||
cancel_button = remain_messageBox.addButton(
|
||
"取消", PySide6.QtWidgets.QMessageBox.ButtonRole.RejectRole
|
||
)
|
||
result = remain_messageBox.exec()
|
||
if remain_messageBox.clickedButton() == cancel_button:
|
||
self.remain_Count = 0
|
||
return
|
||
self.configReader.read(Constant.feedLine_set_file, encoding="utf-8")
|
||
line_name = self.configReader.get(key, "name")
|
||
current_index = self.comboBox_lineIndex.findText(line_name)
|
||
self.comboBox_lineIndex.setCurrentIndex(current_index)
|
||
|
||
self.horizontalSlider_feedingNum.setMaximum(self.remain_Count)
|
||
self.label_maxNum.setText(
|
||
str(self.remain_Count)
|
||
) # 目标投料袋数设置为setini文件中保存的remain_count
|
||
self.horizontalSlider_feedingNum.setValue(0)
|
||
|
||
self.send_startFeed_button_click()
|
||
else:
|
||
return
|
||
|
||
def send_startFeed_button_click(self):
|
||
if self.feeding.feedStatus != FeedStatus.FNone:
|
||
self.show_infomessage_box("正在执行")
|
||
return
|
||
# 触发自动运行
|
||
if self.robotClient.status_model.curMode != 7:
|
||
self.send_switch_tool_command()
|
||
log.log_message(logging.INFO, Constant.str_sys_switch_tool)
|
||
self.send_start_tool_command()
|
||
log.log_message(logging.INFO, Constant.str_sys_start_tool)
|
||
|
||
msg_box_person = QMessageBox()
|
||
msg_box_person.setIcon(QMessageBox.Icon.Information)
|
||
msg_box_person.setText("是否确认生产区域安全继续生产？")
|
||
msg_box_person.setWindowTitle("提示")
|
||
|
||
ok_button = msg_box_person.addButton(
|
||
"确定", PySide6.QtWidgets.QMessageBox.ButtonRole.AcceptRole
|
||
)
|
||
cancel_button = msg_box_person.addButton(
|
||
"取消", PySide6.QtWidgets.QMessageBox.ButtonRole.RejectRole
|
||
)
|
||
|
||
result = msg_box_person.exec()
|
||
|
||
if msg_box_person.clickedButton() == cancel_button:
|
||
return
|
||
log.log_message(logging.INFO, "第一层确认生产")
|
||
|
||
has_person = False
|
||
# has_person, _ = self.detection_person.get_person() # TODO
|
||
if has_person: # TODO
|
||
# self.feeding.pause = True
|
||
# self.send_pause_command(True)
|
||
#
|
||
# self.show_messagebox_of_person()
|
||
msg_box_person.setText("检测到安全区域后人是否继续生产？")
|
||
result = msg_box_person.exec()
|
||
if result == QMessageBox.StandardButton.Cancel:
|
||
return
|
||
log.log_message(logging.ERROR, "人员进入安全区")
|
||
|
||
num = self.horizontalSlider_feedingNum.maximum()
|
||
line_head = self.comboBox_lineIndex.currentData()
|
||
self.command_quene.put(
|
||
FeedCommand(
|
||
FeedingConfig(
|
||
num,
|
||
FeedLine(
|
||
self.feedLine_dict[line_head].id,
|
||
self.feedLine_dict[line_head].name,
|
||
self.feedLine_dict[line_head].positions,
|
||
),
|
||
self.feeding.robotClient.photo_locs[:],
|
||
)
|
||
)
|
||
)
|
||
# self.stackedWidget_num.setCurrentIndex(1)
|
||
self.set_run_status_button(True)
|
||
self.feeding.pause = False
|
||
self.feeding.onekey = False
|
||
log.log_message(
|
||
logging.INFO,
|
||
f"{self.feedLine_dict[line_head].name}:{Constant.str_feed_start}",
|
||
)
|
||
|
||
def send_num_button_click(self):
|
||
button = self.sender()
|
||
if button.text() != "自定义":
|
||
num = int(button.text())
|
||
self.horizontalSlider_feedingNum.setMaximum(num)
|
||
self.label_maxNum.setText(str(num))
|
||
self.horizontalSlider_feedingNum.setValue(0)
|
||
else:
|
||
self.lineEdit_num.show()
|
||
|
||
def send_subOneAsix_button_click(self):
|
||
btn_str = self.sender().objectName()
|
||
Constant.manual_adjust_accuracy = float(
|
||
self.lineEdit_manual_adjust_accuracy.text()
|
||
)
|
||
x1 = float(self.label_j1.text())
|
||
x2 = float(self.label_j2.text())
|
||
x3 = float(self.label_j3.text())
|
||
x4 = float(self.label_j4.text())
|
||
x5 = float(self.label_j5.text())
|
||
x6 = float(self.label_j6.text())
|
||
if "j1" in btn_str:
|
||
x1 = x1 - Constant.manual_adjust_accuracy
|
||
elif "j2" in btn_str:
|
||
x2 = x2 - Constant.manual_adjust_accuracy
|
||
pass
|
||
elif "j3" in btn_str:
|
||
x3 = x3 - Constant.manual_adjust_accuracy
|
||
pass
|
||
elif "j4" in btn_str:
|
||
x4 = x4 - Constant.manual_adjust_accuracy
|
||
pass
|
||
elif "j5" in btn_str:
|
||
x5 = x5 - Constant.manual_adjust_accuracy
|
||
pass
|
||
elif "j6" in btn_str:
|
||
x6 = x6 - Constant.manual_adjust_accuracy
|
||
self.send_position_command(x1, x2, x3, x4, x5, x6, MoveType.AXIS)
|
||
|
||
def send_addOneAsix_button_click(self, btn):
|
||
btn_str = self.sender().objectName()
|
||
Constant.manual_adjust_accuracy = float(
|
||
self.lineEdit_manual_adjust_accuracy.text()
|
||
)
|
||
x1 = float(self.label_j1.text())
|
||
x2 = float(self.label_j2.text())
|
||
x3 = float(self.label_j3.text())
|
||
x4 = float(self.label_j4.text())
|
||
x5 = float(self.label_j5.text())
|
||
x6 = float(self.label_j6.text())
|
||
if "j1" in btn_str:
|
||
x1 = x1 + Constant.manual_adjust_accuracy
|
||
elif "j2" in btn_str:
|
||
x2 = x2 + Constant.manual_adjust_accuracy
|
||
pass
|
||
elif "j3" in btn_str:
|
||
x3 = x3 + Constant.manual_adjust_accuracy
|
||
pass
|
||
elif "j4" in btn_str:
|
||
x4 = x4 + Constant.manual_adjust_accuracy
|
||
pass
|
||
elif "j5" in btn_str:
|
||
x5 = x5 + Constant.manual_adjust_accuracy
|
||
pass
|
||
elif "j6" in btn_str:
|
||
x6 = x6 + Constant.manual_adjust_accuracy
|
||
self.send_position_command(x1, x2, x3, x4, x5, x6, move_type=MoveType.AXIS)
|
||
|
||
def send_addNum_button_click(self):
|
||
self.feeding.feedConfig.num += 1
|
||
log.log_message(logging.INFO, Constant.str_sys_feedNum_add)
|
||
max_num = int(self.label_maxNum.text()) + 1
|
||
self.horizontalSlider_feedingNum.setMaximum(max_num)
|
||
self.label_maxNum.setText(str(max_num))
|
||
|
||
def send_subNum_button_click(self):
|
||
if self.feeding.feedConfig.num <= 1:
|
||
# self.send_stopFeed_button_click()
|
||
self.feeding.feedStatus = FeedStatus.FNone
|
||
# 清空运行命令
|
||
self.send_clear_auto_command()
|
||
log.log_message(logging.INFO, Constant.str_feed_stop)
|
||
return
|
||
self.feeding.feedConfig.num -= 1
|
||
log.log_message(logging.INFO, Constant.str_sys_feedNum_sub)
|
||
max_num = int(self.label_maxNum.text()) - 1
|
||
self.horizontalSlider_feedingNum.setMaximum(max_num)
|
||
self.label_maxNum.setText(str(max_num))
|
||
|
||
def send_custom_num_returnPressed(self):
|
||
if self.lineEdit_num.text() == "" or not self.lineEdit_num.text().isdigit():
|
||
return
|
||
self.horizontalSlider_feedingNum.setMaximum(int(self.lineEdit_num.text()))
|
||
self.horizontalSlider_feedingNum.setValue(0)
|
||
self.label_maxNum.setText(self.lineEdit_num.text())
|
||
log.log_message(
|
||
logging.INFO, f"{Constant.str_sys_setFeedNum}:{self.label_maxNum.text()} "
|
||
)
|
||
|
||
def send_position_button_click(self):
|
||
# if True:
|
||
# cmd_command = CMDRequest()
|
||
# cmd_command.cmdData = ['rewriteData', '800', f'{position_instruction.m0}', 0]
|
||
# request_command = vars(cmd_command)
|
||
# self.robotClient.add_sendQuene(request_command)
|
||
return
|
||
|
||
def send_position_returnPressed(self):
|
||
log.log_message(logging.INFO, Constant.str_sys_manualPosition)
|
||
try:
|
||
self.send_position_command(
|
||
float(self.lineEdit_j1.text()),
|
||
float(self.lineEdit_j2.text()),
|
||
float(self.lineEdit_j3.text()),
|
||
float(self.lineEdit_j4.text()),
|
||
float(self.lineEdit_j5.text()),
|
||
float(self.lineEdit_j6.text()),
|
||
)
|
||
except Exception as e:
|
||
self.show_infomessage_box(Constant.str_sys_log_move_error)
|
||
|
||
def send_setSpeed_label_doubelClick(self):
|
||
pass
|
||
|
||
def send_setSpeed_clicked(self):
|
||
self.robotClient.feed_speed = int(self.lineEdit_speed_run.text())
|
||
self.robotClient.debug_speed = int(self.lineEdit_speed_debug.text())
|
||
self.robotClient.reset_speed = int(self.lineEdit_speed_reset.text())
|
||
self.robotClient.smooth = int(self.lineEdit_setting_smooth.text())
|
||
self.robotClient.dynamic_height = float(self.lineEdit_setting_height.text())
|
||
try:
|
||
take_addr = int(self.lineEdit_take_addr.text())
|
||
press_addr = int(self.lineEdit_press_addr.text())
|
||
shake_addr = int(self.lineEdit_shake_addr.text())
|
||
time_delay_take = float(self.lineEdit_timedelay_take.text())
|
||
time_delay_put = float(self.lineEdit_timedelay_put.text())
|
||
time_delay_shake = float(self.lineEdit_timedelay_shake.text())
|
||
self.robotClient.con_ios[0] = take_addr
|
||
self.robotClient.con_ios[1] = press_addr
|
||
self.robotClient.con_ios[2] = shake_addr
|
||
self.robotClient.time_delay_take = time_delay_take
|
||
self.robotClient.time_delay_put = time_delay_put
|
||
self.robotClient.time_delay_shake = time_delay_shake
|
||
self.configReader = configparser.ConfigParser()
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set("Robot_Feed", "io_take_addr", str(take_addr))
|
||
self.configReader.set("Robot_Feed", "io_zip_addr", str(press_addr))
|
||
self.configReader.set("Robot_Feed", "io_shake_addr", str(shake_addr))
|
||
self.configReader.set("Robot_Feed", "takeDelay", str(time_delay_take))
|
||
self.configReader.set("Robot_Feed", "putDelay", str(time_delay_put))
|
||
self.configReader.set("Robot_Feed", "shakeDelay", str(time_delay_shake))
|
||
self.configReader.set(
|
||
"Speed", "feed_speed", str(self.robotClient.feed_speed)
|
||
)
|
||
self.configReader.set(
|
||
"Speed", "debug_speed", str(self.robotClient.debug_speed)
|
||
)
|
||
self.configReader.set(
|
||
"Speed", "reset_speed", str(self.robotClient.reset_speed)
|
||
)
|
||
self.configReader.set("Robot_Feed", "smooth", str(self.robotClient.smooth))
|
||
self.configReader.set(
|
||
"Robot_Feed", "dynamic_height", str(self.robotClient.dynamic_height)
|
||
)
|
||
self.configReader.write(open(Constant.set_ini, "w", encoding="utf-8"))
|
||
except Exception as e:
|
||
log.log_message(logging.ERROR, Constant.str_sys_set_error + e)
|
||
pass
|
||
# self.pushButton_speed.setText(str(Constant.speed))
|
||
log.log_message(
|
||
logging.INFO,
|
||
Constant.str_sys_setSpeed
|
||
+ str(self.robotClient.debug_speed)
|
||
+ "|"
|
||
+ str(self.robotClient.feed_speed),
|
||
)
|
||
pass
|
||
|
||
def send_get_safe_position_button_click(self):
|
||
real_position = self.robotClient.status_model.getRealPosition()
|
||
row_i = self.tableWidget_feedSeting.currentRow()
|
||
head = self.tableWidget_feedSeting.item(row_i, 0).text()
|
||
self.feedLine_dict[head].safe_position.init_position(
|
||
real_position.X,
|
||
real_position.Y,
|
||
real_position.Z,
|
||
real_position.U,
|
||
real_position.V,
|
||
real_position.W,
|
||
)
|
||
self.set_position_to_tabel(row_i, 0, real_position)
|
||
|
||
def send_get_broken1_position_button_click(self):
|
||
real_position = self.robotClient.status_model.getRealPosition()
|
||
row_i = self.tableWidget_feedSeting.currentRow()
|
||
head = self.tableWidget_feedSeting.item(row_i, 0).text()
|
||
self.feedLine_dict[head].broken1_position.init_position(
|
||
real_position.X,
|
||
real_position.Y,
|
||
real_position.Z,
|
||
real_position.U,
|
||
real_position.V,
|
||
real_position.W,
|
||
)
|
||
self.set_position_to_tabel(row_i, 1, real_position)
|
||
|
||
def send_get_broken2_position_button_click(self):
|
||
real_position = self.robotClient.status_model.getRealPosition()
|
||
row_i = self.tableWidget_feedSeting.currentRow()
|
||
head = self.tableWidget_feedSeting.item(row_i, 0).text()
|
||
self.feedLine_dict[head].broken2_position.init_position(
|
||
real_position.X,
|
||
real_position.Y,
|
||
real_position.Z,
|
||
real_position.U,
|
||
real_position.V,
|
||
real_position.W,
|
||
)
|
||
self.set_position_to_tabel(row_i, 2, real_position)
|
||
|
||
def send_get_shake_position_button_click(self):
|
||
real_position = self.robotClient.status_model.getRealPosition()
|
||
row_i = self.tableWidget_feedSeting.currentRow()
|
||
head = self.tableWidget_feedSeting.item(row_i, 0).text()
|
||
self.feedLine_dict[head].shake_position.init_position(
|
||
real_position.X,
|
||
real_position.Y,
|
||
real_position.Z,
|
||
real_position.U,
|
||
real_position.V,
|
||
real_position.W,
|
||
)
|
||
self.set_position_to_tabel(row_i, 3, real_position)
|
||
|
||
def send_get_dropbag_position_button_click(self):
|
||
real_position = self.robotClient.status_model.getRealPosition()
|
||
row_i = self.tableWidget_feedSeting.currentRow()
|
||
head = self.tableWidget_feedSeting.item(row_i, 0).text()
|
||
self.feedLine_dict[head].drop_bag_position.init_position(
|
||
real_position.X,
|
||
real_position.Y,
|
||
real_position.Z,
|
||
real_position.U,
|
||
real_position.V,
|
||
real_position.W,
|
||
)
|
||
self.set_position_to_tabel(row_i, 4, real_position)
|
||
|
||
def send_get_zipbag_position_button_click(self):
|
||
real_position = self.robotClient.status_model.getRealPosition()
|
||
row_i = self.tableWidget_feedSeting.currentRow()
|
||
head = self.tableWidget_feedSeting.item(row_i, 0).text()
|
||
self.feedLine_dict[head].zip_bag_position.init_position(
|
||
real_position.X,
|
||
real_position.Y,
|
||
real_position.Z,
|
||
real_position.U,
|
||
real_position.V,
|
||
real_position.W,
|
||
)
|
||
self.set_position_to_tabel(row_i, 6, real_position)
|
||
|
||
def send_tabelFeedSet_addRow(self):
|
||
for i in range(1, 20):
|
||
head = f"{Constant.feedLine_set_section}{i}"
|
||
if head not in self.feedLine_dict:
|
||
row_position = self.tableWidget_feedSeting.rowCount() # 当前行数
|
||
self.tableWidget_feedSeting.insertRow(row_position)
|
||
safe_position = Real_Position()
|
||
break_1_position = Real_Position()
|
||
break_2_position = Real_Position()
|
||
shake_position = Real_Position()
|
||
drop_bag_position = Real_Position()
|
||
|
||
self.feedLine_dict[head] = FeedLine(
|
||
"新建",
|
||
safe_position,
|
||
break_1_position,
|
||
break_2_position,
|
||
shake_position,
|
||
drop_bag_position,
|
||
)
|
||
self.tableWidget_feedSeting.setItem(
|
||
self.tableWidget_feedSeting.rowCount() - 1,
|
||
0,
|
||
QTableWidgetItem(head),
|
||
)
|
||
self.tableWidget_feedSeting.setItem(
|
||
self.tableWidget_feedSeting.rowCount() - 1,
|
||
1,
|
||
QTableWidgetItem("新建"),
|
||
)
|
||
self.set_position_to_tabel(
|
||
self.tableWidget_feedSeting.rowCount() - 1, 0, safe_position
|
||
)
|
||
self.set_position_to_tabel(
|
||
self.tableWidget_feedSeting.rowCount() - 1, 1, break_1_position
|
||
)
|
||
self.set_position_to_tabel(
|
||
self.tableWidget_feedSeting.rowCount() - 1, 2, break_2_position
|
||
)
|
||
self.set_position_to_tabel(
|
||
self.tableWidget_feedSeting.rowCount() - 1, 3, shake_position
|
||
)
|
||
self.set_position_to_tabel(
|
||
self.tableWidget_feedSeting.rowCount() - 1, 4, drop_bag_position
|
||
)
|
||
break
|
||
|
||
def send_tabelFeedSet_delRow(self):
|
||
selectRow = self.tableWidget_feedSeting.currentRow()
|
||
if selectRow >= 0:
|
||
for feed_line_key, feed_line in self.feedLine_dict.items():
|
||
if (
|
||
feed_line_key
|
||
== self.tableWidget_feedSeting.item(selectRow, 0).text()
|
||
):
|
||
self.feedLine_dict.pop(feed_line_key)
|
||
self.tableWidget_feedSeting.removeRow(selectRow)
|
||
break
|
||
else:
|
||
QMessageBox.information(self, "提示", "请选择要删除的行")
|
||
|
||
def send_tabelFeedSet_save(self):
|
||
count = len(self.feedLine_dict.keys())
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set("Robot_Feed", "LineCount", str(count))
|
||
writeFeedLine_to_ini(self.feedLine_dict, Constant.feedLine_set_file)
|
||
pass
|
||
|
||
def send_stopFeed_button_click(self):
|
||
# 清空状态
|
||
self.feeding.feedStatus = FeedStatus.FNone
|
||
self.feeding.reset_status = ResetStatus.RNone
|
||
# 清空运行命令
|
||
self.send_clear_auto_command()
|
||
# self.feeding.feedConfig.num = 0
|
||
log.log_message(logging.INFO, Constant.str_feed_stop)
|
||
|
||
def send_pauseFeed_button_click(self):
|
||
if self.pushButton_pauseFeed.text() == "暂停":
|
||
|
||
icon9 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.SystemReboot))
|
||
self.pushButton_pauseFeed.setIcon(icon9)
|
||
self.pushButton_pauseFeed.setText("继续")
|
||
log.log_message(logging.INFO, Constant.str_feed_pause)
|
||
self.send_pause_command(True)
|
||
self.feeding.pause = True
|
||
else:
|
||
icon9 = QIcon(QIcon.fromTheme(QIcon.ThemeIcon.MediaPlaybackPause))
|
||
self.pushButton_pauseFeed.setIcon(icon9)
|
||
self.pushButton_pauseFeed.setText("暂停")
|
||
self.send_pause_command(False)
|
||
log.log_message(logging.INFO, Constant.str_feed_continue)
|
||
self.send_start_tool_command()
|
||
log.log_message(logging.INFO, Constant.str_sys_start_tool)
|
||
self.feeding.pause = False
|
||
|
||
pass
|
||
|
||
def send_tabWidget_control_change(self):
|
||
if self.robotClient.status_model.curMode != 7:
|
||
self.send_switch_tool_command()
|
||
log.log_message(logging.INFO, Constant.str_sys_switch_tool)
|
||
self.send_start_tool_command()
|
||
|
||
def send_reset_button_click(self):
|
||
# 触发自动运行
|
||
if self.robotClient.status_model.curMode != 7:
|
||
self.send_switch_tool_command()
|
||
log.log_message(logging.INFO, Constant.str_sys_switch_tool)
|
||
self.send_start_tool_command()
|
||
log.log_message(logging.INFO, Constant.str_sys_start_tool)
|
||
|
||
line_head = self.comboBox_lineIndex.currentData()
|
||
self.send_clear_auto_command()
|
||
log.log_message(logging.INFO, Constant.str_feed_reset_start)
|
||
# safe_position = self.feedLine_dict[line_head].safe_position
|
||
# self.send_position_command(safe_position.X, safe_position.Y, safe_position.Z, safe_position.U, safe_position.V, safe_position.W,move_type=MoveType.WORLD)
|
||
if self.remain_lineName != "":
|
||
line_head = f"{Constant.feedLine_set_section}{self.remain_lineName}"
|
||
return_positions = copy.deepcopy(self.feedLine_dict[line_head].positions)
|
||
position_origin = PositionModel()
|
||
position_origin.init_position(self.robotClient.origin_position)
|
||
position_origin.status = 1
|
||
return_positions.insert(0, position_origin)
|
||
if self.feedLine_dict.keys().__contains__(line_head):
|
||
self.feeding.feedConfig = FeedingConfig(
|
||
0,
|
||
FeedLine(
|
||
self.feedLine_dict[line_head].id,
|
||
self.feedLine_dict[line_head].name,
|
||
return_positions,
|
||
),
|
||
self.feeding.robotClient.photo_locs[:],
|
||
)
|
||
else:
|
||
log.log_message(logging.ERROR, Constant.str_feed_reset_no_line_error)
|
||
return
|
||
self.feeding.reset_status = ResetStatus.RStart
|
||
# dialog_reset = StopDialog()
|
||
# dialog_reset.stop_thread_signal.connect(self.stop_reset_thread)
|
||
else:
|
||
log.log_message(logging.ERROR, Constant.str_feed_reset_no_line_error)
|
||
return
|
||
# thread = threading.Thread(target=self.feeding.return_original_position())
|
||
# thread.start()
|
||
|
||
def stop_reset_thread(self):
|
||
self.feeding.reset_status = ResetStatus.ROk
|
||
self.send_clear_auto_command()
|
||
self.send_emergency_alarm_command()
|
||
|
||
def send_tabelFeedSet_itemChanged(self, item):
|
||
row = item.row()
|
||
column = item.column()
|
||
value = item.text()
|
||
head = self.tableWidget_feedSeting.item(row, 0).text()
|
||
if column == 1:
|
||
self.feedLine_dict[head].name = value
|
||
elif column == (0 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].safe_position.X = float(value)
|
||
elif column == (1 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].safe_position.Y = float(value)
|
||
elif column == (2 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].safe_position.Z = float(value)
|
||
elif column == (3 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].safe_position.U = float(value)
|
||
elif column == (4 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].safe_position.V = float(value)
|
||
elif column == (5 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].safe_position.W = float(value)
|
||
# elif column == 7:
|
||
elif column == (6 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken1_position.X = float(value)
|
||
elif column == (7 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken1_position.Y = float(value)
|
||
elif column == (8 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken1_position.Z = float(value)
|
||
elif column == (9 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken1_position.U = float(value)
|
||
elif column == (10 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken1_position.V = float(value)
|
||
elif column == (11 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken1_position.W = float(value)
|
||
|
||
elif column == (12 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken2_position.X = float(value)
|
||
elif column == (13 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken2_position.Y = float(value)
|
||
elif column == (14 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken2_position.Z = float(value)
|
||
elif column == (15 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken2_position.U = float(value)
|
||
elif column == (16 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken2_position.V = float(value)
|
||
elif column == (17 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].broken2_position.W = float(value)
|
||
|
||
elif column == (18 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].shake_position.X = float(value)
|
||
elif column == (19 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].shake_position.Y = float(value)
|
||
elif column == (20 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].shake_position.Z = float(value)
|
||
elif column == (21 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].shake_position.U = float(value)
|
||
elif column == (22 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].shake_position.V = float(value)
|
||
elif column == (23 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].shake_position.W = float(value)
|
||
|
||
elif column == (24 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].drop_bag_position.X = float(value)
|
||
elif column == (25 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].drop_bag_position.Y = float(value)
|
||
elif column == (26 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].drop_bag_position.Z = float(value)
|
||
elif column == (27 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].drop_bag_position.U = float(value)
|
||
elif column == (28 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].drop_bag_position.V = float(value)
|
||
elif column == (29 + self.tableWidget_feedSeting_addtional_col_num):
|
||
self.feedLine_dict[head].drop_bag_position.W = float(value)
|
||
|
||
def run(self):
|
||
# 主线程的逻辑就是 feeding.run() 接口和错误状态处理
|
||
while self.thread_signal:
|
||
time.sleep(0.1)
|
||
if Constant.feedStatus: # feedStatus的状态打印
|
||
current_status = self.feeding.feedStatus
|
||
is_paused = self.feeding.pause
|
||
|
||
# 只有当状态或暂停标志发生变化时才打印
|
||
if (
|
||
current_status != self.last_status_printed
|
||
or is_paused != self.last_pause_printed
|
||
):
|
||
print(
|
||
f"[调试] 当前 feedStatus: {current_status}, 是否暂停: {is_paused}"
|
||
)
|
||
self.last_status_printed = current_status
|
||
self.last_pause_printed = is_paused
|
||
|
||
# print("进入了主线程的 run")
|
||
|
||
# 获取状态和控制标志
|
||
current_feed_status = self.feeding.feedStatus
|
||
is_running = (current_feed_status == FeedStatus.FStart) and (
|
||
not self.feeding.pause
|
||
) # 加上未暂停
|
||
is_stopped = ( # 以下情况应关闭传感器
|
||
current_feed_status
|
||
in [
|
||
FeedStatus.FFinished,
|
||
FeedStatus.FNone,
|
||
FeedStatus.FReverse,
|
||
FeedStatus.FStartReverse,
|
||
]
|
||
or self.feeding.pause # 暂停时也视为“停止”
|
||
)
|
||
# 启动条件：处于 FStart 且未暂停，且线程未运行
|
||
if is_running and self.sensor_thread is None:
|
||
print("启动传感器线程..........!!!!!!!!!!!!!!!!!!!!!!")
|
||
try:
|
||
self.relay_controller._running = True
|
||
self.sensor_thread = threading.Thread(
|
||
target=self.relay_controller.handle_sensor1,
|
||
name="Sensor1MonitorThread",
|
||
daemon=True,
|
||
)
|
||
self.sensor_thread.start()
|
||
self.sensor2_thread = threading.Thread(
|
||
target=self.relay_controller.handle_sensor2, daemon=True
|
||
)
|
||
self.sensor2_thread.start()
|
||
print("🟢 传感器1监控线程已启动（开始投料）")
|
||
print("🟢 传感器2监控线程已启动（关闭滚筒）")
|
||
except Exception as e:
|
||
log.log_message(logging.ERROR, f"启动传感器线程失败: {e}")
|
||
|
||
# 关闭条件：暂停、完成、回退等状态
|
||
if is_stopped and self.sensor_thread is not None:
|
||
print("进入了传感器线程关闭流程")
|
||
try:
|
||
self.relay_controller._running = False
|
||
if self.sensor_thread.is_alive():
|
||
self.sensor_thread.join(timeout=1)
|
||
print("🛑 传感器监控线程已关闭（暂停/完成/回退）")
|
||
self.relay_controller.close(conveyor2=True)
|
||
except Exception as e:
|
||
print("传感器线程关闭流程发生了异常")
|
||
log.log_message(logging.ERROR, f"关闭传感器线程异常: {e}")
|
||
finally:
|
||
self.sensor_thread = None
|
||
|
||
# 如果你也有 handle_sensor2 线程，也可以在这里关闭
|
||
|
||
# 处理命令队列
|
||
if not self.command_quene.empty():
|
||
command = self.command_quene.get()
|
||
if (
|
||
isinstance(command, FeedCommand)
|
||
and command.status == Status.Prepareing
|
||
):
|
||
if self.feeding.feedStatus == FeedStatus.FNone:
|
||
position_origin = PositionModel()
|
||
position_origin.init_position(self.robotClient.origin_position)
|
||
position_origin.status = 1
|
||
command.feed_config.feedLine.feed_positions.insert(
|
||
0, position_origin
|
||
)
|
||
|
||
self.robotClient.send_emergency_sound()
|
||
time.sleep(5)
|
||
self.robotClient.send_emergency_stop()
|
||
self.feeding.feedConfig = command.feed_config
|
||
self.feeding.feedStatus = (
|
||
FeedStatus.FStart
|
||
) # ✅ 投料开始，会触发传感器线程启动
|
||
command.status = Status.Runing
|
||
self.record_remain_num()
|
||
|
||
# 执行 feeding 主逻辑
|
||
try:
|
||
self.feeding.run()
|
||
self.feeding.run_reset()
|
||
except Exception as e:
|
||
log.log_message(logging.ERROR, f"Feeding运行异常: {e}")
|
||
|
||
# while 循环结束，程序退出，确保线程关闭
|
||
try:
|
||
if self.sensor_thread is not None:
|
||
self.relay_controller._running = False
|
||
print(
|
||
"self.relay_controller._running: ", self.relay_controller._running
|
||
)
|
||
if self.sensor_thread.is_alive():
|
||
print("进入 传感器线程等待")
|
||
self.sensor_thread.join(timeout=1)
|
||
print("⏹ 主程序退出，传感器线程已关闭")
|
||
self.sensor_thread = None
|
||
print("self.sensor_thread: ", self.sensor_thread)
|
||
except Exception as e:
|
||
print(f"主循环退出时关闭线程异常: {e}")
|
||
log.log_message(logging.ERROR, f"主循环退出时关闭线程异常: {e}")
|
||
|
||
def run_detect_persion(self):
|
||
while self.thread_signal:
|
||
has_person = False
|
||
# has_person, _ = self.detection_person.get_person() # TODO
|
||
if has_person: # TODO
|
||
# self.feeding.pause = True
|
||
# self.send_pause_command(True)
|
||
#
|
||
# self.show_messagebox_of_person()
|
||
# msg_box_person.setText("检测到安全区域后人是否继续生产？")
|
||
# result = msg_box_person.exec()
|
||
# if result == QMessageBox.StandardButton.Cancel:
|
||
# return
|
||
log.log_message(logging.ERROR, "人员进入安全区")
|
||
|
||
time.sleep(1)
|
||
pass
|
||
|
||
def updateUI(self):
|
||
while self.thread_signal:
|
||
time.sleep(0.2)
|
||
if self.robotClient.connected:
|
||
self.set_label_status_style(True)
|
||
else:
|
||
self.set_label_status_style(False)
|
||
if self.feeding.feedStatus != FeedStatus.FNone:
|
||
self.horizontalSlider_feedingNum.setValue(
|
||
self.horizontalSlider_feedingNum.maximum()
|
||
- self.feeding.feedConfig.num
|
||
)
|
||
# self.label_remain_num.setText(str(self.feeding.feedConfig.num))
|
||
else:
|
||
self.set_run_status_button(False)
|
||
if self.feeding.feedConfig != None:
|
||
# 修改点1：这里修改显示剩余袋数的逻辑
|
||
# 原来的逻辑是显示剩余袋数：self.label_remain_num.setText(self.feeding.feedConfig.num))
|
||
# 我改成了目标袋数减剩余袋数就是已经投料的袋数self.label_remain_num.setText(str(self.horizontalSlider_feedingNum.maximum()-self.feeding.feedConfig.num))
|
||
self.label_remain_num.setText(
|
||
str(
|
||
self.horizontalSlider_feedingNum.maximum()
|
||
- self.feeding.feedConfig.num
|
||
)
|
||
)
|
||
if self.feeding.feedStatus == FeedStatus.FNone:
|
||
self.stackedWidget_num.setCurrentIndex(0)
|
||
else:
|
||
self.stackedWidget_num.setCurrentIndex(1)
|
||
|
||
self.label_date.setText(datetime.now().strftime("%Y-%m-%d"))
|
||
self.label_time.setText(datetime.now().strftime("%H:%M:%S"))
|
||
|
||
self.updateUI_seting.emit()
|
||
|
||
def update_seting_frame(self):
|
||
self.updateUI_Position()
|
||
self.updateUI_label_status()
|
||
self.updateUI_frame_sign(self.feeding.feedStatus)
|
||
self.updateUI_IOPanel()
|
||
|
||
def updateRobotSeting(self):
|
||
self.lineEdit_origin_x.setText(str(self.robotClient.origin_position.X))
|
||
self.lineEdit_origin_y.setText(str(self.robotClient.origin_position.Y))
|
||
self.lineEdit_origin_z.setText(str(self.robotClient.origin_position.Z))
|
||
self.lineEdit_origin_u.setText(str(self.robotClient.origin_position.U))
|
||
self.lineEdit_origin_v.setText(str(self.robotClient.origin_position.V))
|
||
self.lineEdit_origin_w.setText(str(self.robotClient.origin_position.W))
|
||
|
||
@Slot()
|
||
def show_no_photo_message_box(self):
|
||
print("显示弹窗图片")
|
||
self.feeding.pause = True
|
||
self.send_pause_command(pause=1)
|
||
msg_box_person = QMessageBox()
|
||
msg_box_person.setIcon(QMessageBox.Icon.Warning)
|
||
msg_box_person.setText("未识别到料袋报警，请重新放料后，点击继续")
|
||
msg_box_person.setWindowTitle("提示")
|
||
ok_button = msg_box_person.addButton("确定", QMessageBox.AcceptRole)
|
||
cancel_button = msg_box_person.addButton("取消", QMessageBox.RejectRole)
|
||
result = msg_box_person.exec()
|
||
if msg_box_person.clickedButton() == cancel_button:
|
||
return
|
||
# self.show_infomessage_box("")
|
||
|
||
def updateUI_IOPanel(self):
|
||
try:
|
||
io_bits = self.robotClient.status_model.get_IO_bits()
|
||
for index, bit in enumerate(io_bits):
|
||
toggle = self.dirt_io_points[f"y{index+1}"]
|
||
if toggle.is_on == bit:
|
||
continue
|
||
else:
|
||
toggle.change_status()
|
||
except Exception as e:
|
||
log.log_message(logging.ERROR, Constant.str_sys_log_IO_error)
|
||
pass
|
||
|
||
@Slot()
|
||
def updateUI_label_detection(self, img: np.ndarray):
|
||
img_copy = np.copy(img)
|
||
backgroud_img = Util.util_pic.cv2_to_qpixmap(img_copy)
|
||
if backgroud_img == None:
|
||
return
|
||
backgroud_img = backgroud_img.scaled(
|
||
self.label_showDetection.size().width(),
|
||
self.label_showDetection.size().height(),
|
||
Qt.AspectRatioMode.IgnoreAspectRatio,
|
||
Qt.TransformationMode.SmoothTransformation,
|
||
)
|
||
self.label_showDetection.setPixmap(backgroud_img)
|
||
|
||
@Slot()
|
||
def log_message(self, level, message):
|
||
log.log_message(level, message)
|
||
|
||
def updateUI_Select_Line(self):
|
||
self.comboBox_lineIndex.clear()
|
||
for key, value in self.feedLine_dict.items():
|
||
self.comboBox_lineIndex.addItem(value.name, key)
|
||
|
||
def updateUI_label_status(self):
|
||
if self.robotClient.status_model.isMoving == 1:
|
||
self.label_move_sign.show()
|
||
if self.label_move_sign.text() == "正在移动.":
|
||
self.label_move_sign.setText("正在移动..")
|
||
else:
|
||
self.label_move_sign.setText("正在移动.")
|
||
else:
|
||
self.label_move_sign.hide()
|
||
if self.robotClient.status_model.curMode >= 0:
|
||
try:
|
||
self.label_status_model.setText(
|
||
Constant.mode_array[self.robotClient.status_model.curMode]
|
||
)
|
||
except:
|
||
self.label_status_model.setText("未知模式")
|
||
self.label_status_remoteCmdLen.setText(
|
||
str(self.robotClient.status_model.RemoteCmdLen)
|
||
)
|
||
if self.robotClient.status_model.curAlarm != 0:
|
||
log.log_message(
|
||
logging.ERROR,
|
||
Constant.str_sys_log_alarm_error
|
||
+ str(self.robotClient.status_model.curAlarm),
|
||
)
|
||
self.feeding.pause = True
|
||
self.label_status_alarmcode.setText(str(self.robotClient.status_model.curAlarm))
|
||
self.label_status_toolIndex.setText(
|
||
str(self.robotClient.status_model.toolCoord)
|
||
)
|
||
self.label_status_speed.setText(str(self.robotClient.status_model.curSpeed_n))
|
||
|
||
def updateUI_Position(self):
|
||
self.horizontalSlider_J1.setValue(self.status_address.axis_0)
|
||
self.horizontalSlider_J2.setValue(self.status_address.axis_1)
|
||
self.horizontalSlider_J3.setValue(self.status_address.axis_2)
|
||
self.horizontalSlider_J4.setValue(self.status_address.axis_3)
|
||
self.horizontalSlider_J5.setValue(self.status_address.axis_4)
|
||
self.horizontalSlider_J6.setValue(self.status_address.axis_5)
|
||
|
||
self.label_j1.setText(str(self.status_address.axis_0))
|
||
self.label_j2.setText(str(self.status_address.axis_1))
|
||
self.label_j3.setText(str(self.status_address.axis_2))
|
||
self.label_j4.setText(str(self.status_address.axis_3))
|
||
self.label_j5.setText(str(self.status_address.axis_4))
|
||
self.label_j6.setText(str(self.status_address.axis_5))
|
||
self.horizontalSlider_J1.setValue(self.status_address.axis_0)
|
||
self.horizontalSlider_J2.setValue(self.status_address.axis_1)
|
||
self.horizontalSlider_J3.setValue(self.status_address.axis_2)
|
||
self.horizontalSlider_J4.setValue(self.status_address.axis_3)
|
||
self.horizontalSlider_J5.setValue(self.status_address.axis_4)
|
||
self.horizontalSlider_J6.setValue(self.status_address.axis_5)
|
||
|
||
def set_position_to_tabel(self, row_i, position_j, real_Position: Real_Position):
|
||
self.tableWidget_feedSeting.setItem(
|
||
row_i,
|
||
position_j * 6 + self.tableWidget_feedSeting_addtional_col_num,
|
||
QTableWidgetItem(str(real_Position.X)),
|
||
)
|
||
self.tableWidget_feedSeting.setItem(
|
||
row_i,
|
||
position_j * 6 + 1 + self.tableWidget_feedSeting_addtional_col_num,
|
||
QTableWidgetItem(str(real_Position.Y)),
|
||
)
|
||
self.tableWidget_feedSeting.setItem(
|
||
row_i,
|
||
position_j * 6 + 2 + self.tableWidget_feedSeting_addtional_col_num,
|
||
QTableWidgetItem(str(real_Position.Z)),
|
||
)
|
||
self.tableWidget_feedSeting.setItem(
|
||
row_i,
|
||
position_j * 6 + 3 + self.tableWidget_feedSeting_addtional_col_num,
|
||
QTableWidgetItem(str(real_Position.U)),
|
||
)
|
||
self.tableWidget_feedSeting.setItem(
|
||
row_i,
|
||
position_j * 6 + 4 + self.tableWidget_feedSeting_addtional_col_num,
|
||
QTableWidgetItem(str(real_Position.V)),
|
||
)
|
||
self.tableWidget_feedSeting.setItem(
|
||
row_i,
|
||
position_j * 6 + 5 + self.tableWidget_feedSeting_addtional_col_num,
|
||
QTableWidgetItem(str(real_Position.W)),
|
||
)
|
||
|
||
def updateUI_frame_sign(self, sign: FeedStatus):
|
||
# print("start")
|
||
if sign == FeedStatus.FNone:
|
||
self.set_sign_status(self.label_sign_go, self.pushButton_sign_go, False)
|
||
self.set_sign_status(
|
||
self.label_sign_photo, self.pushButton_sign_photo, False
|
||
)
|
||
self.set_sign_status(self.label_sign_take, self.pushButton_sign_take, False)
|
||
self.set_sign_status(self.label_sign_feed, self.pushButton_sign_feed, False)
|
||
return
|
||
if sign < FeedStatus.FPhoto:
|
||
self.set_sign_status(self.label_sign_go, self.pushButton_sign_go, True)
|
||
self.set_sign_status(
|
||
self.label_sign_photo, self.pushButton_sign_photo, False
|
||
)
|
||
self.set_sign_status(self.label_sign_take, self.pushButton_sign_take, False)
|
||
self.set_sign_status(self.label_sign_feed, self.pushButton_sign_feed, False)
|
||
return
|
||
if sign <= FeedStatus.FPhoto:
|
||
self.set_sign_status(self.label_sign_go, self.pushButton_sign_go, False)
|
||
self.set_sign_status(
|
||
self.label_sign_photo, self.pushButton_sign_photo, True
|
||
)
|
||
self.set_sign_status(self.label_sign_take, self.pushButton_sign_take, False)
|
||
self.set_sign_status(self.label_sign_feed, self.pushButton_sign_feed, False)
|
||
return
|
||
if sign <= FeedStatus.FTake:
|
||
self.set_sign_status(self.label_sign_go, self.pushButton_sign_go, False)
|
||
self.set_sign_status(
|
||
self.label_sign_photo, self.pushButton_sign_photo, False
|
||
)
|
||
self.set_sign_status(self.label_sign_take, self.pushButton_sign_take, True)
|
||
self.set_sign_status(self.label_sign_feed, self.pushButton_sign_feed, False)
|
||
return
|
||
if sign <= FeedStatus.FBroken1:
|
||
self.set_sign_status(self.label_sign_go, self.pushButton_sign_go, False)
|
||
self.set_sign_status(
|
||
self.label_sign_photo, self.pushButton_sign_photo, False
|
||
)
|
||
self.set_sign_status(self.label_sign_take, self.pushButton_sign_take, False)
|
||
self.set_sign_status(self.label_sign_feed, self.pushButton_sign_feed, True)
|
||
return
|
||
pass
|
||
|
||
def set_label_status_style(self, connected: bool):
|
||
# return
|
||
if connected and not self.label_connect_status.isEnabled():
|
||
self.label_connect_status.setEnabled(True)
|
||
if not connected and self.label_connect_status.isEnabled():
|
||
self.label_connect_status.setDisabled(True)
|
||
|
||
def set_sign_status(self, label, btn, signed: bool):
|
||
# return
|
||
try:
|
||
if signed and label.isEnabled():
|
||
label.setDisabled(True)
|
||
btn.setDisabled(True)
|
||
# if label.styleSheet().strip() != self.active_label_sign_Qss:
|
||
# label.setStyleSheet(self.active_label_sign_Qss)
|
||
# self.active_label_sign_Qss = label.styleSheet().strip()
|
||
#
|
||
# if btn.styleSheet().strip() != self.active_btn_sign_Qss:
|
||
# btn.setStyleSheet(self.active_btn_sign_Qss)
|
||
# self.active_btn_sign_Qss = btn.styleSheet().strip()
|
||
if not signed and not label.isEnabled():
|
||
label.setEnabled(True)
|
||
btn.setEnabled(True)
|
||
# if label.styleSheet().strip() != self.noactive_label_sign_Qss:
|
||
# label.setStyleSheet(self.noactive_label_sign_Qss)
|
||
# self.noactive_label_sign_Qss = label.styleSheet().strip()
|
||
# if btn.styleSheet().strip() != self.noactive_btn_sign_Qss:
|
||
# btn.setStyleSheet(self.noactive_btn_sign_Qss)
|
||
# self.noactive_btn_sign_Qss = btn.styleSheet().strip()
|
||
except Exception as e:
|
||
print(e)
|
||
|
||
def set_run_status_button(self, isRuning: bool):
|
||
self.pushButton_pauseFeed.setText("暂停")
|
||
##self.pushButton_startFeed.setEnabled(False)
|
||
|
||
# if isRuning:
|
||
# self.pushButton_pauseFeed.show()
|
||
# self.pushButton_stopFeed.show()
|
||
# self.pushButton_startFeed.hide()
|
||
# else:
|
||
# self.pushButton_pauseFeed.hide()
|
||
# self.pushButton_stopFeed.hide()
|
||
# self.pushButton_startFeed.show()
|
||
|
||
def send_clear_auto_command(self):
|
||
clear_command = CMDInstructRequest()
|
||
clear_command.emptyList = "1"
|
||
request_command = clear_command.toString()
|
||
log.log_message(logging.INFO, Constant.str_sys_clearAlarm)
|
||
self.robotClient.add_sendQuene(request_command)
|
||
# self.command_quene.put(request_command)
|
||
|
||
def send_position_command(
|
||
self,
|
||
x1,
|
||
x2,
|
||
x3,
|
||
x4,
|
||
x5,
|
||
x6,
|
||
move_type: MoveType = MoveType.WORLD,
|
||
speed=5,
|
||
p2=None,
|
||
):
|
||
# ailaimi
|
||
position_instruction = Instruction()
|
||
position_instruction.m0 = float(x1)
|
||
position_instruction.m1 = float(x2)
|
||
position_instruction.m2 = float(x3)
|
||
position_instruction.m3 = float(x4)
|
||
position_instruction.action = move_type.value
|
||
position_instruction.speed = self.robotClient.debug_speed
|
||
position_instruction.tool = 0
|
||
if position_instruction.action == 17:
|
||
position_instruction.m0_p = p2.X
|
||
position_instruction.m1_p = p2.Y
|
||
position_instruction.m2_p = p2.Z
|
||
position_instruction.m3_p = p2.U
|
||
# position_instruction.m4_p = p2.V
|
||
# position_instruction.m5_p = p2.W
|
||
|
||
instruction_command = CMDInstructRequest()
|
||
instruction_command.instructions.append(position_instruction)
|
||
request_command = instruction_command.toString()
|
||
log_str = (
|
||
f'移动到位置:{"自由路径" if move_type == MoveType.AXIS else "姿势直线"}：'
|
||
f"m0:{position_instruction.m0}-"
|
||
f"m2:{position_instruction.m1}-"
|
||
f"m3:{position_instruction.m2}-"
|
||
f"m4:{position_instruction.m3}-"
|
||
)
|
||
log.log_message(logging.INFO, log_str)
|
||
print("request_command", request_command)
|
||
self.robotClient.add_sendQuene(request_command)
|
||
|
||
def send_pause_command(self, pause: bool):
|
||
pause_command = CMDRequest()
|
||
pause_command.cmdData.append("actionPause")
|
||
if pause:
|
||
pause_command.cmdData.append("1")
|
||
else:
|
||
pause_command.cmdData.append("0")
|
||
request_command = pause_command.toString()
|
||
self.robotClient.add_sendQuene(request_command)
|
||
|
||
def send_emergency_alarm_command(self):
|
||
self.feeding.feedStatus = FeedStatus.FNone
|
||
|
||
stop_command = CMDRequest()
|
||
stop_command.cmdData.append("actionStop")
|
||
stop_command.cmdData.append("1")
|
||
request_command = stop_command.toString()
|
||
self.send_clear_auto_command()
|
||
self.robotClient.add_sendQuene(request_command)
|
||
self.feeding.send_emergency_sound()
|
||
self.feeding.feedConfig.num = 0
|
||
log.log_message(logging.INFO, Constant.str_sys_emergencyStop)
|
||
# TODO
|
||
|
||
def send_clear_alarm_command(self, pause: bool):
|
||
self.send_clear_auto_command()
|
||
pause_command = CMDRequest()
|
||
pause_command.cmdData.append("StopButton")
|
||
pause_command.cmdData.append("1")
|
||
request_command = pause_command.toString()
|
||
self.robotClient.add_sendQuene(request_command)
|
||
|
||
def send_switch_tool_command(self):
|
||
switch_command = CMDRequest()
|
||
switch_command.cmdData.append("switchTool")
|
||
switch_command.cmdData.append("2")
|
||
request_command = switch_command.toString()
|
||
self.robotClient.add_sendQuene(request_command)
|
||
|
||
def send_start_tool_command(self):
|
||
switch_command = CMDRequest()
|
||
switch_command.cmdData.append("startButton")
|
||
switch_command.cmdData.append("1")
|
||
request_command = switch_command.toString()
|
||
self.robotClient.add_sendQuene(request_command)
|
||
|
||
def show_messagebox_of_person(self):
|
||
|
||
msg_box = QMessageBox(self)
|
||
msg_box.setWindowTitle("提示")
|
||
msg_box.setText("当前有人是否继续")
|
||
msg_box.setIcon(QMessageBox.Question)
|
||
msg_box.setStandardButtons(QMessageBox.Yes)
|
||
msg_box.setDefaultButton(QMessageBox.Yes)
|
||
|
||
result = msg_box.exec()
|
||
|
||
if result == QMessageBox.Yes:
|
||
self.feeding.pause = False
|
||
self.send_pause_command(False)
|
||
|
||
### 设置界面
|
||
def get_p1_button_click(self):
|
||
realPosition = self.robotClient.status_model.getRealPosition()
|
||
self.lineEdit_x1.setText(str(realPosition.X))
|
||
self.lineEdit_y1.setText(str(realPosition.Y))
|
||
self.lineEdit_z1.setText(str(realPosition.Z))
|
||
self.lineEdit_u1.setText(str(realPosition.U))
|
||
self.lineEdit_v1.setText(str(realPosition.V))
|
||
self.lineEdit_w1.setText(str(realPosition.W))
|
||
|
||
def get_p2_button_click(self):
|
||
realPosition = self.robotClient.status_model.getRealPosition()
|
||
self.lineEdit_x2.setText(str(realPosition.X))
|
||
self.lineEdit_y2.setText(str(realPosition.Y))
|
||
self.lineEdit_z2.setText(str(realPosition.Z))
|
||
self.lineEdit_u2.setText(str(realPosition.U))
|
||
self.lineEdit_v2.setText(str(realPosition.V))
|
||
self.lineEdit_w2.setText(str(realPosition.W))
|
||
|
||
def get_p3_button_click(self):
|
||
realPosition = self.robotClient.status_model.getRealPosition()
|
||
self.lineEdit_x3.setText(str(realPosition.X))
|
||
self.lineEdit_y3.setText(str(realPosition.Y))
|
||
self.lineEdit_z3.setText(str(realPosition.Z))
|
||
self.lineEdit_u3.setText(str(realPosition.U))
|
||
self.lineEdit_v3.setText(str(realPosition.V))
|
||
self.lineEdit_w3.setText(str(realPosition.W))
|
||
|
||
def get_p4_button_click(self):
|
||
realPosition = self.robotClient.status_model.getRealPosition()
|
||
self.lineEdit_x4.setText(str(realPosition.X))
|
||
self.lineEdit_y4.setText(str(realPosition.Y))
|
||
self.lineEdit_z4.setText(str(realPosition.Z))
|
||
self.lineEdit_u4.setText(str(realPosition.U))
|
||
self.lineEdit_v4.setText(str(realPosition.V))
|
||
self.lineEdit_w4.setText(str(realPosition.W))
|
||
|
||
def get_p5_button_click(self):
|
||
realPosition = self.robotClient.status_model.getRealPosition()
|
||
self.lineEdit_x5.setText(str(realPosition.X))
|
||
self.lineEdit_y5.setText(str(realPosition.Y))
|
||
self.lineEdit_z5.setText(str(realPosition.Z))
|
||
self.lineEdit_u5.setText(str(realPosition.U))
|
||
self.lineEdit_v5.setText(str(realPosition.V))
|
||
self.lineEdit_w5.setText(str(realPosition.W))
|
||
|
||
def get_origin_button_click(self):
|
||
realPosition = self.robotClient.status_model.getRealPosition()
|
||
self.lineEdit_origin_x.setText(str(realPosition.X))
|
||
self.lineEdit_origin_y.setText(str(realPosition.Y))
|
||
self.lineEdit_origin_z.setText(str(realPosition.Z))
|
||
self.lineEdit_origin_u.setText(str(realPosition.U))
|
||
self.lineEdit_origin_v.setText(str(realPosition.V))
|
||
self.lineEdit_origin_w.setText(str(realPosition.W))
|
||
|
||
def set_p1_button_click(self):
|
||
try:
|
||
x1 = float(self.lineEdit_x1.text())
|
||
y1 = float(self.lineEdit_y1.text())
|
||
z1 = float(self.lineEdit_z1.text())
|
||
u1 = float(self.lineEdit_u1.text())
|
||
v1 = float(self.lineEdit_v1.text())
|
||
w1 = float(self.lineEdit_w1.text())
|
||
|
||
self.robotClient.photo_locs[0] = (x1, y1, z1, u1, v1, w1)
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set("Robot_Feed", "photo_x1", str(x1))
|
||
self.configReader.set("Robot_Feed", "photo_y1", str(y1))
|
||
self.configReader.set("Robot_Feed", "photo_z1", str(z1))
|
||
self.configReader.set("Robot_Feed", "photo_u1", str(u1))
|
||
self.configReader.set("Robot_Feed", "photo_v1", str(v1))
|
||
self.configReader.set("Robot_Feed", "photo_w1", str(w1))
|
||
self.configReader.write(open(Constant.set_ini, "w", encoding="utf-8"))
|
||
log.log_message(logging.INFO, f"设置拍照点1:{x1},{y1},{z1}")
|
||
except:
|
||
self.show_infomessage_box("设置拍照点1失败")
|
||
|
||
def set_p2_button_click(self):
|
||
try:
|
||
x2 = float(self.lineEdit_x2.text())
|
||
y2 = float(self.lineEdit_y2.text())
|
||
z2 = float(self.lineEdit_z2.text())
|
||
u2 = float(self.lineEdit_u2.text())
|
||
v2 = float(self.lineEdit_v2.text())
|
||
w2 = float(self.lineEdit_w2.text())
|
||
self.robotClient.photo_locs[1] = (x2, y2, z2, u2, v2, w2)
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set("Robot_Feed", "photo_x2", str(x2))
|
||
self.configReader.set("Robot_Feed", "photo_y2", str(y2))
|
||
self.configReader.set("Robot_Feed", "photo_z2", str(z2))
|
||
self.configReader.set("Robot_Feed", "photo_u2", str(u2))
|
||
self.configReader.set("Robot_Feed", "photo_v2", str(v2))
|
||
self.configReader.set("Robot_Feed", "photo_w2", str(w2))
|
||
self.configReader.write(open(Constant.set_ini, "w", encoding="utf-8"))
|
||
log.log_message(logging.INFO, f"设置拍照点2:{x2},{y2},{z2}")
|
||
except:
|
||
self.show_infomessage_box("设置拍照点2失败")
|
||
|
||
def set_p3_button_click(self):
|
||
try:
|
||
x3 = float(self.lineEdit_x3.text())
|
||
y3 = float(self.lineEdit_y3.text())
|
||
z3 = float(self.lineEdit_z3.text())
|
||
u3 = float(self.lineEdit_u3.text())
|
||
v3 = float(self.lineEdit_v3.text())
|
||
w3 = float(self.lineEdit_w3.text())
|
||
self.robotClient.photo_locs[2] = (x3, y3, z3, u3, v3, w3)
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set("Robot_Feed", "photo_x3", str(x3))
|
||
self.configReader.set("Robot_Feed", "photo_y3", str(y3))
|
||
self.configReader.set("Robot_Feed", "photo_z3", str(z3))
|
||
self.configReader.set("Robot_Feed", "photo_u3", str(u3))
|
||
self.configReader.set("Robot_Feed", "photo_v3", str(v3))
|
||
self.configReader.set("Robot_Feed", "photo_w3", str(w3))
|
||
self.configReader.write(open(Constant.set_ini, "w", encoding="utf-8"))
|
||
log.log_message(logging.INFO, f"设置拍照点3:{x3},{y3},{z3}")
|
||
except:
|
||
self.show_infomessage_box("设置拍照点3失败")
|
||
|
||
def set_p4_button_click(self):
|
||
try:
|
||
x4 = float(self.lineEdit_x4.text())
|
||
y4 = float(self.lineEdit_y4.text())
|
||
z4 = float(self.lineEdit_z4.text())
|
||
u4 = float(self.lineEdit_u4.text())
|
||
v4 = float(self.lineEdit_v4.text())
|
||
w4 = float(self.lineEdit_w4.text())
|
||
self.robotClient.photo_locs[3] = (x4, y4, z4, u4, v4, w4)
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set("Robot_Feed", "photo_x4", str(x4))
|
||
self.configReader.set("Robot_Feed", "photo_y4", str(y4))
|
||
self.configReader.set("Robot_Feed", "photo_z4", str(z4))
|
||
self.configReader.set("Robot_Feed", "photo_u4", str(u4))
|
||
self.configReader.set("Robot_Feed", "photo_v4", str(v4))
|
||
self.configReader.set("Robot_Feed", "photo_w4", str(w4))
|
||
self.configReader.write(open(Constant.set_ini, "w", encoding="utf-8"))
|
||
log.log_message(logging.INFO, f"设置拍照点4:{x4},{y4},{z4}")
|
||
except:
|
||
self.show_infomessage_box("设置拍照点4失败")
|
||
|
||
def set_p5_button_click(self):
|
||
try:
|
||
x5 = float(self.lineEdit_x5.text())
|
||
y5 = float(self.lineEdit_y5.text())
|
||
z5 = float(self.lineEdit_z5.text())
|
||
u5 = float(self.lineEdit_u5.text())
|
||
v5 = float(self.lineEdit_v5.text())
|
||
w5 = float(self.lineEdit_w5.text())
|
||
self.robotClient.photo_locs[4] = (x5, y5, z5, u5, v5, w5)
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set("Robot_Feed", "photo_x5", str(x5))
|
||
self.configReader.set("Robot_Feed", "photo_y5", str(y5))
|
||
self.configReader.set("Robot_Feed", "photo_z5", str(z5))
|
||
self.configReader.set("Robot_Feed", "photo_u5", str(u5))
|
||
self.configReader.set("Robot_Feed", "photo_v5", str(v5))
|
||
self.configReader.set("Robot_Feed", "photo_w5", str(w5))
|
||
self.configReader.write(open(Constant.set_ini, "w", encoding="utf-8"))
|
||
log.log_message(logging.INFO, f"设置拍照点5:{x5},{y5},{z5}")
|
||
except:
|
||
self.show_infomessage_box("设置拍照点5失败")
|
||
|
||
def set_origin_button_click(self):
|
||
try:
|
||
x = float(self.lineEdit_origin_x.text())
|
||
y = float(self.lineEdit_origin_y.text())
|
||
z = float(self.lineEdit_origin_z.text())
|
||
u = float(self.lineEdit_origin_u.text())
|
||
v = float(self.lineEdit_origin_v.text())
|
||
w = float(self.lineEdit_origin_w.text())
|
||
origin_position = Real_Position()
|
||
origin_position.init_position(x, y, z, u, v, w)
|
||
self.robotClient.origin_position = origin_position
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set("Origin", "X", str(x))
|
||
self.configReader.set("Origin", "Y", str(y))
|
||
self.configReader.set("Origin", "Z", str(z))
|
||
self.configReader.set("Origin", "U", str(u))
|
||
self.configReader.set("Origin", "V", str(v))
|
||
self.configReader.set("Origin", "W", str(w))
|
||
self.configReader.write(open(Constant.set_ini, "w", encoding="utf-8"))
|
||
log.log_message(logging.INFO, f"设置原点:{x},{y},{z}")
|
||
except:
|
||
log.log_message(logging.ERROR, f"设置原点失败")
|
||
self.show_infomessage_box("设置原点失败")
|
||
|
||
def updateUI_Photo_Set(self):
|
||
self.lineEdit_x1.setText(str(self.robotClient.photo_locs[0][0]))
|
||
self.lineEdit_y1.setText(str(self.robotClient.photo_locs[0][1]))
|
||
self.lineEdit_z1.setText(str(self.robotClient.photo_locs[0][2]))
|
||
self.lineEdit_u1.setText(str(self.robotClient.photo_locs[0][3]))
|
||
self.lineEdit_v1.setText(str(self.robotClient.photo_locs[0][4]))
|
||
self.lineEdit_w1.setText(str(self.robotClient.photo_locs[0][5]))
|
||
self.lineEdit_x2.setText(str(self.robotClient.photo_locs[1][0]))
|
||
self.lineEdit_y2.setText(str(self.robotClient.photo_locs[1][1]))
|
||
self.lineEdit_z2.setText(str(self.robotClient.photo_locs[1][2]))
|
||
self.lineEdit_u2.setText(str(self.robotClient.photo_locs[1][3]))
|
||
self.lineEdit_v2.setText(str(self.robotClient.photo_locs[1][4]))
|
||
self.lineEdit_w2.setText(str(self.robotClient.photo_locs[1][5]))
|
||
self.lineEdit_x3.setText(str(self.robotClient.photo_locs[2][0]))
|
||
self.lineEdit_y3.setText(str(self.robotClient.photo_locs[2][1]))
|
||
self.lineEdit_z3.setText(str(self.robotClient.photo_locs[2][2]))
|
||
self.lineEdit_u3.setText(str(self.robotClient.photo_locs[2][3]))
|
||
self.lineEdit_v3.setText(str(self.robotClient.photo_locs[2][4]))
|
||
self.lineEdit_w3.setText(str(self.robotClient.photo_locs[2][5]))
|
||
self.lineEdit_x4.setText(str(self.robotClient.photo_locs[3][0]))
|
||
self.lineEdit_y4.setText(str(self.robotClient.photo_locs[3][1]))
|
||
self.lineEdit_z4.setText(str(self.robotClient.photo_locs[3][2]))
|
||
self.lineEdit_u4.setText(str(self.robotClient.photo_locs[3][3]))
|
||
self.lineEdit_v4.setText(str(self.robotClient.photo_locs[3][4]))
|
||
self.lineEdit_w4.setText(str(self.robotClient.photo_locs[3][5]))
|
||
self.lineEdit_x5.setText(str(self.robotClient.photo_locs[4][0]))
|
||
self.lineEdit_y5.setText(str(self.robotClient.photo_locs[4][1]))
|
||
self.lineEdit_z5.setText(str(self.robotClient.photo_locs[4][2]))
|
||
self.lineEdit_u5.setText(str(self.robotClient.photo_locs[4][3]))
|
||
self.lineEdit_v5.setText(str(self.robotClient.photo_locs[4][4]))
|
||
self.lineEdit_w5.setText(str(self.robotClient.photo_locs[4][5]))
|
||
pass
|
||
|
||
def updateUI_Base_Set(self):
|
||
self.lineEdit_speed_run.setText(str(self.robotClient.feed_speed))
|
||
self.lineEdit_speed_debug.setText(str(self.robotClient.debug_speed))
|
||
self.lineEdit_speed_reset.setText(str(self.robotClient.reset_speed))
|
||
self.lineEdit_take_addr.setText(str(self.robotClient.con_ios[0]))
|
||
self.lineEdit_press_addr.setText(str(self.robotClient.con_ios[1]))
|
||
self.lineEdit_shake_addr.setText(str(self.robotClient.con_ios[2]))
|
||
self.lineEdit_setting_smooth.setText(str(self.robotClient.smooth))
|
||
self.lineEdit_timedelay_take.setText(str(self.robotClient.time_delay_take))
|
||
self.lineEdit_timedelay_put.setText(str(self.robotClient.time_delay_put))
|
||
self.lineEdit_timedelay_shake.setText(str(self.robotClient.time_delay_shake))
|
||
self.lineEdit_setting_height.setText(str(self.robotClient.dynamic_height))
|
||
|
||
def show_infomessage_box(self, message):
|
||
# print("显示弹窗")
|
||
msg_box = QMessageBox(self)
|
||
msg_box.setWindowTitle("提示")
|
||
msg_box.setText(message)
|
||
msg_box.setIcon(QMessageBox.Icon.Information)
|
||
msg_box.setStandardButtons(QMessageBox.StandardButton.Ok)
|
||
msg_box.show()
|
||
|
||
def send_click_change_stackView(self, index):
|
||
self.stackedWidget_view.setCurrentIndex(index)
|
||
if index == 0:
|
||
self.updateUI_Select_Line()
|
||
if index == 2:
|
||
self.updateRobotSeting()
|
||
self.updateUI_Photo_Set()
|
||
if index == 3:
|
||
self.updateUI_Base_Set()
|
||
|
||
# 修改点2：设置一键投料的目标袋数从999设置到40袋
|
||
def send_onekeyfeed_button_click(self):
|
||
# if self.feeding.feedStatus != FeedStatus.FNone:
|
||
# self.show_infomessage_box("正在执行")
|
||
# return
|
||
|
||
self.horizontalSlider_feedingNum.setMaximum(40)
|
||
self.label_maxNum.setText(str(40))
|
||
self.horizontalSlider_feedingNum.setValue(0)
|
||
|
||
self.send_startFeed_button_click()
|
||
self.feeding.onekey = True
|
||
|
||
def send_exit_button_click(self):
|
||
self.closeEvent(None)
|
||
QApplication.quit()
|
||
sys.exit(app.exec())
|
||
|
||
def send_click_sysmeuExpand(self):
|
||
self.frame_sys_seting.setVisible(not self.frame_sys_seting.isVisible())
|
||
if self.frame_2.sizePolicy().verticalPolicy() == QSizePolicy.Policy.Fixed:
|
||
self.frame_2.setSizePolicy(
|
||
QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding
|
||
)
|
||
else:
|
||
self.frame_2.setSizePolicy(
|
||
QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed
|
||
)
|
||
|
||
def send_IO_Point_OpenOrClose(self, index, togger):
|
||
if togger:
|
||
self.feeding.sendIOControl(index - 1, 1)
|
||
log.log_message(logging.INFO, f"打开IO{index}")
|
||
else:
|
||
self.feeding.sendIOControl(index - 1, 0)
|
||
log.log_message(logging.INFO, f"关闭IO{index}")
|
||
|
||
def showEvent(self, event):
|
||
super().showEvent(event)
|
||
QTimer.singleShot(2000, self.check_continue)
|
||
|
||
def closeEvent(self, event):
|
||
self.hide() # 用户体验，先将窗口隐藏掉
|
||
print("self.record_remain_num")
|
||
self.record_remain_num()
|
||
print("self.feeding.close_feed()")
|
||
self.feeding.close_feed()
|
||
self.thread_signal = False
|
||
print("self.detect_person_thread.join()")
|
||
self.detect_person_thread.join()
|
||
print("self.main_UI_threading.join()")
|
||
self.main_UI_threading.join()
|
||
print("self.main_threading.join()")
|
||
self.main_threading.join()
|
||
print("after self.main_threading.join()")
|
||
self.robotClient.close()
|
||
print("self.robot_connect_threading.join()")
|
||
self.robot_connect_threading.join()
|
||
log.log_message(logging.INFO, Constant.str_sys_exit)
|
||
print(" closeEvent over")
|
||
# os._exit(0)
|
||
|
||
# 记录投料袋数
|
||
def record_remain_num(self):
|
||
try:
|
||
self.configReader = configparser.ConfigParser()
|
||
self.configReader.read(Constant.set_ini)
|
||
self.configReader.set(
|
||
"Robot_Feed",
|
||
"remain_linename",
|
||
str(self.feeding.feedConfig.feedLine.id),
|
||
)
|
||
self.configReader.set(
|
||
"Robot_Feed", "remain_count", str(self.feeding.feedConfig.num)
|
||
)
|
||
self.configReader.write(open(Constant.set_ini, "w", encoding="utf-8"))
|
||
except:
|
||
log.log_message(logging.ERROR, Constant.str_sys_log_feedNum)
|
||
|
||
|
||
class MyApplication(QApplication):
|
||
def __init__(self, argv):
|
||
super().__init__(argv)
|
||
|
||
def notify(self, receiver, event):
|
||
try:
|
||
return super().notify(receiver, event)
|
||
except Exception as e:
|
||
log.log_message(logging.ERROR, e)
|
||
# 可以在这里记录日志或者执行其他操作
|
||
return False
|
||
|
||
|
||
def handle_exception(exc_type, exc_value, exc_tb):
|
||
if issubclass(exc_type, KeyboardInterrupt):
|
||
log.log_message(logging.INFO, "用户主动退出程序")
|
||
return
|
||
log.log_message(logging.ERROR, exc_value)
|
||
traceback.print_exception(exc_type, exc_value, exc_tb)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
app = MyApplication(sys.argv)
|
||
window = MainWindow()
|
||
window.show()
|
||
sys.excepthook = handle_exception
|
||
try:
|
||
sys.exit(app.exec())
|
||
print("after sys.exit(app.exec())")
|
||
except Exception as e:
|
||
log.log_message(logging.ERROR, e)
|