def __init__(self):
super(CommSockets, self).__init__()
self.ourSocket = QUdpSocket(self)
self.ourSocket.bind(QHostAddress.LocalHost, self.SOCKET_NR_OUR)
self.theirSocket = QUdpSocket(self)
self.ourSocket.readyRead.connect(self.readPendingDatagrams)
def udp_slave(self, port1, port2):
self.socket1 = QUdpSocket()
self.socket2 = QUdpSocket()
self.socket1.bind(QHostAddress(config.host), port1)
self.socket2.bind(QHostAddress(config.host), port2)
self.socket1.readyRead.connect(self.on_udp_receive1)
self.socket2.readyRead.connect(self.on_udp_receive2)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.password_ui = PasswordVerify(mainwindow=self)
self.face_ui = FaceVerify(mainwindow=self)
self.find_device = QUdpSocket()
self.video_send = QUdpSocket()
self.set_bind()
self.showFullScreen()
self.set_connect()
def __init__(self,port,service_id):
self.multicastgroup = QHostAddress("224.0.1.232")
self.mcast_port = 55421
self.port = port
super().__init__()
self.udpSocket = QUdpSocket(self)
self.udpSocket.bind(QHostAddress.AnyIPv4,int(port))
self.udpSocket_multi = QUdpSocket(self)
self.udpSocket_multi.bind(QHostAddress.AnyIPv4, self.mcast_port, QUdpSocket.ReuseAddressHint)
self.udpSocket_multi.joinMulticastGroup(self.multicastgroup)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
self.udpSocket_multi.readyRead.connect(self.processPendingDatagrams_multi)
def __init__(self):
super().__init__()
self.config = Config("config.ini")
# INIT Controls
self.wheels = Wheels(self.config.steeringMid, self.config.steeringLeft,
self.config.steeringRight)
self.accelerator = Accelerator(self.config, self)
self.__initUI()
self.statusBar().showMessage("Board not connected")
# Init uds listener
self._log("Init udp at {}:{}".format(
get_ip(), self.config.getOption('udp_port')))
self.udpSocket = QUdpSocket()
self.udpSocket.setLocalAddress(QHostAddress(get_ip()))
self.udpSocket.bind(self.config.getOption('udp_port'))
self.udpSocket.readyRead.connect(self.udpHandler)
# Init tcp server
self.tcpServer = QTcpServer(self)
self._log("Starting TCP at {}:{} ".format(
get_ip(), str(self.config.getOption('tcp_port'))))
self.tcpServer.listen(QHostAddress(get_ip()),
self.config.getOption('tcp_port'))
self.tcpServer.newConnection.connect(self.establishBoardConnection)
self.show()
def __init__(self, parent=None):
super(QObject, self).__init__(parent)
self.udpSocket = QUdpSocket(self)
self.udpSocket.readyRead.connect(self.data_received)
self.__currentIndex = 0
def __init__(self):
super(FileWindow, self).__init__()
# 加载ui文件
loadUi('filepage.ui', self)
# 关闭页面 就销毁对象
self.setAttribute(Qt.WA_DeleteOnClose)
# 定义显示在TableWidget中的空对象
self.newItem0 = None
self.newItem1 = None
# 创建定时器对象
self.timer = QTimer()
# 创建udp客户端socket
self.udp_client_socket = QUdpSocket()
# 上传路径+文件名
self.file_path_name = ''
# 下载文件名
self.file_name = ''
# 收到服务器消息链接到 receive_message槽函数
self.udp_client_socket.readyRead.connect(self.receiveMessage)
# 上传文件按钮点击信号，连接到槽函数
self.up_btn.clicked.connect(self.pressUpLoadBtn)
# 下载文件按钮点击信号，连接到槽函数
self.down_btn.clicked.connect(self.pressDownloadBtn)
# 定时器超时信号，连接到槽函数
self.timer.timeout.connect(self.timeout)
# 初始化TableWidget
self.initTableWidget()
# 启动定时器
self.timer.start(2000)
def __init__(self, sock_type='TCP Client', ip='127.0.0.1', port=2007):
'''打开网络设备，建立连接
## sock_type:
- 'TCP Client'
- 'TCP Server'
- 'UDP'
'''
self.sock_type = sock_type
# self.ip = ip
self.port = port
if sock_type == 'TCP Client':
tcp_client = QTcpSocket()
tcp_client.connectToHost(ip, port)
self.sock = tcp_client
elif sock_type == 'TCP Server':
tcp_server = QTcpServer()
tcp_server.listen(QHostAddress(ip), port)
self.sock = tcp_server
elif sock_type == 'UDP':
udp = QUdpSocket()
udp.bind(QHostAddress(ip), port)
self.sock = udp
else:
print('Unkonw sock_type=%r' % sock_type)
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.udpSocket = QUdpSocket()
self.udpSocket.bind(self.port)
self.udpSocket.readyRead.connect(self.handle_incoming)
def __init__(self):
super(AudioWindow, self).__init__()
# 加载ui文件
loadUi('audioPage.ui', self)
self.my_count = ''
self.friend_count = ''
# 创建socket对象
self.audio_socket = QUdpSocket()
# 收到服务器消息链接到 receive_message槽函数
self.audio_socket.readyRead.connect(self.receiveMessage)
# 创建audio_data对象
self.audio_data = AudioStruct()
# 创建两个线程对象
self.audio_client = AudioClient()
self.audio_server = AudioServer()
# 接受语音消息
self.recvBtn.clicked.connect(self.pressAcceptBtn)
# 拒绝语音消息
self.rejectBtn.clicked.connect(self.pressRejectBtn)
# 关闭
self.closeBtn.clicked.connect(self.pressCloseBtn)
self.set_count_server.connect(self.audio_server.setCount)
self.set_count_client.connect(self.audio_client.setCount)
def connectToSensorPublisher(self):
self.sensorpubSocket = QUdpSocket()
self.sensorpubSocket.bind(QHostAddress.AnyIPv4,
self.sensorBroadcastPort,
QUdpSocket.ShareAddress)
self.sensorpubSocket.joinMulticastGroup(self.sensorBroadcastAddress)
self.lastSensorBroadcastAddress = self.sensorBroadcastAddress
def start_trans(self, pipe):
if self.pipe != pipe:
return
print('start_trans %d' % self.pipe)
if self.SocketClient:
self.SocketClient.readyRead.disconnect(self.on_readyRead)
self.SocketClient.connected.disconnect(self.on_connected)
self.SocketClient.disconnected.disconnect(self.on_disconnected)
self.SocketClient.error.disconnect(self.on_error)
self.SocketClient.close()
self.SocketClient.deleteLater()
self.SocketClient = None
if appsetting.trans_protocol(pipe) == 'tcp':
self.SocketClient = QTcpSocket()
else:
self.SocketClient = QUdpSocket()
self.SocketClient.readyRead.connect(self.on_readyRead)
self.SocketClient.connected.connect(self.on_connected)
self.SocketClient.disconnected.connect(self.on_disconnected)
self.SocketClient.error.connect(self.on_error)
self.SocketClient.bind(QHostAddress(appsetting.trans_localip(pipe)))
self.sig_Transing_state.emit(self.pipe, False)
if appsetting.trans_enable(self.pipe) != '0':
self.SocketClient.connectToHost(appsetting.trans_ip(pipe), int(appsetting.trans_port(pipe)))
def network(self):
#若接收数据正常，udpsocket->bytesAvailable()的值将为0，接收不到数据则为非零值，这样就可用个定时器，是不是的检测下，若不为零，将SOCKET重启即可。
self.udpSocket = QUdpSocket(self)
self.port = 12345
self.udpSocket.bind(
self.port, QUdpSocket.ShareAddress | QUdpSocket.ReuseAddressHint)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
def __init__(self):
super(LoginWindow, self).__init__()
# 加载ui文件
loadUi('loginPage.ui', self)
# 关闭页面 就销毁对象
self.setAttribute(Qt.WA_DeleteOnClose)
# 创建udp socket
self.udp_client_socket = QUdpSocket()
# 收发数据对象
self.data = LoginStruct()
# 注册界面空对象
self.register_window = None
# 聊天界面空对象
self.chat_window = None
# 后台界面空对象
self.houtai_window = None
# 设置背景图片
background = QPixmap("img/login_background.jpeg")
# 图片缩放
background = background.scaled(self.background_label.width(),
self.background_label.width())
self.background_label.setPixmap(background)
# 设置输入密码框
self.passwd_lineEdit.setEchoMode(QLineEdit.Password)
# 登录按钮接到press_login_btn槽函数
self.login_Btn.clicked.connect(self.pressLoginBtn)
# 注册按钮接到press_rgs_btn槽函数
self.rgs_Btn.clicked.connect(self.pressRgsBtn)
# 收到服务器消息链接到 receive_message槽函数
self.udp_client_socket.readyRead.connect(self.receiveMessage)
def __init__(self, parent=None):
super(Sender, self).__init__(parent)
self.statusLabel = QLabel("Ready to broadcast datagrams on port 45454")
self.startButton = QPushButton("&Start")
quitButton = QPushButton("&Quit")
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(quitButton, QDialogButtonBox.RejectRole)
self.timer = QTimer(self)
self.udpSocket = QUdpSocket(self)
self.messageNo = 1
self.startButton.clicked.connect(self.startBroadcasting)
quitButton.clicked.connect(self.close)
self.timer.timeout.connect(self.broadcastDatagramm)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Broadcast Sender")
def __init__(self, *sources, **kwargs):
"""Arguments:
sources: paths of QML component sources
kwargs: passed on to PreviewTab
"""
super().__init__()
self._tab_kwargs = kwargs
self.setWindowTitle("pqp")
self.tab_widget = QTabWidget()
self.tab_widget.setTabsClosable(True)
self._populate_tab_widget(*sources)
self.load_button = QPushButton("Load...")
layout = QVBoxLayout()
layout.addWidget(self.tab_widget)
layout.addWidget(self.load_button)
widget = QWidget()
widget.setLayout(layout)
self.setCentralWidget(widget)
self.udp_socket = QUdpSocket()
self.udp_socket.bind(QHostAddress.LocalHost, UDP_PORT)
self.load_button.clicked.connect(self.show_dialog)
self.udp_socket.readyRead.connect(self.read_from_udp_client)
self.tab_widget.tabCloseRequested.connect(self.shutdown_tab)
def __init__(self, host=None, port=None, type=None, parent=None):
super(UDPClient, self).__init__(parent)
mcast_addr = host
mcast_port = port
type = type
self.statusLabel = QLabel("Listening for broadcasted messages")
quitButton = QPushButton("&Quit")
self.udpSocket = QUdpSocket(self)
dstAddress = QHostAddress()
dstAddress.setAddress(mcast_addr)
self.udpSocket.bind(dstAddress, mcast_port)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
quitButton.clicked.connect(self.close)
buttonLayout = QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(quitButton)
buttonLayout.addStretch(1)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle("Broadcast Receiver")
def __init__(self, ip_addr, temp_gcode_file, log_enabled=False):
super().__init__()
self._ip = QHostAddress(ip_addr)
self._localTempGcode = temp_gcode_file
self._port = 3000
self.BUFSIZE = 1280
self._file_encode = 'utf-8'
self._abort = False
self._filename = None
self._log_enabled = log_enabled
self._connected = False
self._socket = QUdpSocket(self)
self._last_reply = None
self._isPrinting = False
self._isIdle = False
self._print_now = 0
self._print_total = 0
self._busy = False
self._printing_filename = ""
self._firmware_ver = ""
self._printing_time = 0
self._update_fail_cnt = 0
self._last_times = []
self._status = {}
self._mutex = Lock()
self._config = {'e_mm_per_step': '0.0',
's_machine_type': '0',
's_x_max': '0.0',
's_y_max': '0.0',
's_z_max': '0.0',
'x_mm_per_step': '0.0',
'y_mm_per_step': '0.0',
'z_mm_per_step': '0.0'}
self.__log("d", "LocalPort: {}", self._socket.localPort())
def __init__(self):
super(UdpCore, self).__init__()
self.initUI()
'''
disconnectFromHost, close, abort好像都可以中断udp bind状态
'''
self.udpSocket = QUdpSocket(self)
self.signalSlot()
def __init__(self, input_ipAdress, input_port):
self.host_ip = QHostAddress(input_ipAdress)
self.port = input_port
self.udp_socket = QUdpSocket()
# udp_socket.bind(QHostAddress('192.168.43.126'),port)
print(self.udp_socket.bind(QHostAddress('localhost'), self.port))
def __init__(self, game_port, login, peer_id, recv):
QObject.__init__(self)
self._logger.info("Allocating local relay for {}, {}".format(login, peer_id))
self._socket = QUdpSocket()
self._socket.stateChanged.connect(self._state_changed)
self._socket.readyRead.connect(self._ready_read)
self.game_port = game_port
self.login, self.peer_id = login, peer_id
self.recv = recv
def __init__(self, my_count):
super(ChatWindow, self).__init__()
# 关闭页面 就销毁对象
self.setAttribute(Qt.WA_DeleteOnClose)
# 加载界面文件
loadUi("chatPage.ui", self)
self.my_count = my_count
self.myname_label.setText(self.my_count)
# 定时器对象
self.timer = QTimer()
# 创建udp客户端socket
self.udp_client_socket = QUdpSocket()
# 收发数据对象
self.data = ChatStruct()
# 用户列表
self.user_list = []
# 聊天记录界面空对象
self.chat_record_page = None
# 文件传输界面空对象
self.file_window = None
# 设置背景图片
background = QPixmap("img/chat_background.jpg")
background = background.scaled(self.back_label.width(),
self.back_label.width())
self.back_label.setPixmap(background)
# 设置只读
self.show_msg_textEdit.setReadOnly(True)
# 定时器初始化
self.timer.start(1000)
# 定时器超时信号，连接到槽函数
self.timer.timeout.connect(self.timeout)
# 双击好友treeWidget
self.friends_treeWidget.doubleClicked.connect(
self.on_treeWidget_doubleClicked)
# 发送消息按钮，连接到槽函数
self.send_Btn.clicked.connect(self.pressSendBtn)
# 查看聊天记录按钮，连接到槽函数
self.msg_log_Btn.clicked.connect(self.pressMsgBtn)
# 文件按钮信号，连接到槽函数
self.file_up_Btn.clicked.connect(self.pressFileBtn)
# 收到服务器消息链接到 receiveMessage槽函数
self.udp_client_socket.readyRead.connect(self.receiveMessage)
# 语音界面
self.audio_window = None
# 语音消息按钮
self.audio_Btn.clicked.connect(self.pressAudioBtn)
# 更新ip 和 端口
self.update_ip_port()
# 获取好友列表
self.updateUserList()
def __init__(self):
super(UdpCommunication, self).__init__()
self.ui = Ui_Form()
self.ui.setupUi(self)
self.udpSocket = QUdpSocket() #socket
self.udpSocket.bind(9999)
self.ui.pushButton_send.clicked.connect(self.handleSend)
self.udpSocket.readyRead.connect(self.handleRecv)
def __init__(self, udpc, logger: Logger, name="Ana", parent=None):
super().__init__(logger=logger, parent=parent)
self.udpc = udpc
self.addr = QHostAddress(udpc.addr)
self.port = udpc.port
self.transport = Transport()
self.socket = QUdpSocket(self)
self.socket.bind(QHostAddress(udpc.local_addr), udpc.local_port)
self.rid = udpc.rid
self.add_rid(udpc.rid)
self.name = name
def __init__(self, parent=None):
super(Control, self).__init__(parent)
self.setupUi(self)
self.function = "manual_driver"
self.ip = ""
self.port = 0
self.forward_or_back = None
self.left_or_right = None
self.holder = None
self.car_socket = QTcpSocket(self)
self.monitoring_socket = QUdpSocket(self)
self.monitoring_socket.bind(QHostAddress("10.42.0.1"), 8889)
self.connect_to_car()
self.set_connect()
def run(self):
Monitor.send_video = QUdpSocket()
while 1:
_, frame = Monitor.cap.read()
Monitor.frame = cv2.resize(frame, (100, 100))
time.sleep(2)
if Monitor.flag:
enfra = cv2.imencode('.jpg', Monitor.frame)[1]
data = zlib.compress(enfra, zlib.Z_BEST_COMPRESSION)
data_encode = np.array(data)
str_encode = data_encode.tostring()
Monitor.send_video.writeDatagram(str_encode, Monitor.ip, Monitor.port)
Monitor.send_video.flush()
else:
pass
def main():
# conn = connection.Connection('localhost', 100)
udp_socket = QUdpSocket()
time.sleep(3)
s = 'test/n'
b = QtCore.QByteArray()
b.append(s.encode())
udp_socket.connectToHost(QHostAddress.LocalHost, 100)
while True:
udp_socket.writeData(b)
time.sleep(1)
def run(self): """ create and init a socket and enter into an event loop """ # udp server socket self.__socket = QUdpSocket() # bind socket to all interfaces and port 4000 self.__socket.bind(QHostAddress.Any, 4000) self.__socket.readyRead.connect(self.read_msg, Qt.DirectConnection) # start another worker to process messages self.__proc_worker = threading.Thread(target=self.process_msgs) self.__proc_worker.setDaemon(True) self.__proc_worker.start() self.exec()
def __init__(self, ip, parent=None):
super().__init__(parent)
self.ip = ip
self.socket_ = QUdpSocket()
self.detail_device = None
self.verticalLayout = QVBoxLayout()
self.label = QLabel(parent)
self.label.setMinimumSize(QSize(300, 200))
self.label.setMaximumSize(QSize(300, 200))
self.label.setScaledContents(True)
self.verticalLayout.addWidget(self.label)
self.monitor = QPushButton(parent)
self.monitor.setMinimumSize(QSize(300, 20))
self.monitor.setMaximumSize(QSize(300, 20))
self.verticalLayout.addWidget(self.monitor)
self.hide_item()
self.set_connect()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.ip = self.get_ip()
self.socket_1 = Monitor(self.ip, self.ui_scroll_area)
self.socket_2 = Monitor(self.ip, self.ui_scroll_area)
self.socket_3 = Monitor(self.ip, self.ui_scroll_area)
self.socket_4 = Monitor(self.ip, self.ui_scroll_area)
self.ports = Queue()
self.find_device = QUdpSocket()
self.set_find_device_bind()
self.add_monitor()
self.add_ports()
self.set_connect()
self.current_device_num = 0
self.sign_in = Sign(mainwindow=self)
self.sign_in.show()
