def start_server(self):
if not self.is_server_started:
self.is_server_started = True
port = 12017
server_backlog = 10
send_hz = 10
ip_list = self.model.teams_list.keys()
self.server = TCPServer(port,
server_backlog,
whitelist=ip_list,
hz=send_hz)
self.server.new_connection.connect(
self.model.new_connection_handler)
self.server.lost_connection.connect(
self.model.lost_connection_handler)
self.server.new_response.connect(self.model.new_response_handler)
self.server.server_ready.connect(self.server_ready_handler)
self.model.team_state_change_signal.connect(
self.server.on_race_state_change)
self.server_thread = QThread()
self.server.moveToThread(self.server_thread)
self.server_thread.started.connect(self.server.run_server)
self.server_thread.start()
def run(self):
log.info('Running server on port %d' % self.port)
rpcprotocol = RPCProtocol()
self.tcpserver = TCPServer(self.handler,rpcprotocol)
self.tcpserver.bind(self.port, self.host)
self.tcpserver.start(0)
ioloop.IOLoop.instance().start()
def on_tcp_server_start_stop_button_clicked(self):
if self.ui.button_TcpServer.text() == 'Start':
self.ui.button_TcpServer.setEnabled(False)
self.ui.lineEdit_TcpServerListenPort.setEnabled(False)
self.tcp_server_thread = QThread()
self.tcp_server = TCPServer(
self.ui.label_LocalIP.text(),
int(self.ui.lineEdit_TcpServerListenPort.text()))
self.tcp_server_thread.started.connect(self.tcp_server.start)
self.tcp_server.status.connect(self.on_tcp_server_status_update)
self.tcp_server.message.connect(self.on_tcp_server_message_ready)
self.tcp_server.moveToThread(self.tcp_server_thread)
self.tcp_server_thread.start()
self.config['TCP_Server_Port'] = self.ui.lineEdit_TcpServerListenPort.text()
self.save_config()
elif self.ui.button_TcpServer.text() == 'Stop':
self.ui.button_TcpServer.setEnabled(False)
self.tcp_server.close()
elif self.ui.button_TcpServer.text() == 'Disconnect':
self.ui.button_TcpServer.setEnabled(False)
self.tcp_server.disconnect()
def __init__(self, host="0.0.0.0", port=21000):
TCPServer.__init__(self)
self.host = host
self.port = port
self.loop = None
self.www = WebServer(self)
class RPCServer(object):
def __init__(self,port,host=''):
self.handler = RPCHandler(self)
self.port = port
self.host = host
self.tcpserver = None
self.serviceMap = {}
def registerService(self, service):
'''Register an RPC service.'''
self.serviceMap[service.GetDescriptor().full_name] = service
def run(self):
log.info('Running server on port %d' % self.port)
rpcprotocol = RPCProtocol()
self.tcpserver = TCPServer(self.handler,rpcprotocol)
self.tcpserver.bind(self.port, self.host)
self.tcpserver.start(0)
ioloop.IOLoop.instance().start()
def stop(self):
self.tcpserver.stop()
ioloop.IOLoop.instance().stop()
# mohoque
from tcpserver import TCPServer
if __name__ == "__main__":
serverAddr = '127.0.0.1'
port = 8080
d = TCPServer(serverAddr, port)
d.start_server()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.showMaximized()
self.setWindowTitle("EVGP Race Control System")
self.is_server_started = False
teams_list_file_path = "racers_list.yaml"
if not os.path.exists(teams_list_file_path):
logging.warning("No racers_list.yaml found!")
msgBox = QMessageBox()
msgBox.setIcon(QMessageBox.Warning)
msgBox.setText(
"No racers_list.yaml found.\nPress Open and use the file explorer to select the racer list YAML file"
)
msgBox.setWindowTitle("No racers_list.yaml found!")
msgBox.setStandardButtons(QMessageBox.Open)
returnValue = msgBox.exec()
if returnValue == QMessageBox.Open:
teams_list_file_path = QFileDialog.getOpenFileName(
self, 'Open Racer List File', os.getcwd(),
"Yaml files (*.yaml)")[0]
self.model = RCSModel(teams_list_file_path)
layout = QGridLayout()
layout.setColumnStretch(0, 10)
layout.setColumnStretch(1, 10)
#FILTERED ACTIVE RACE TABLE
self.activeRaceProxyModel = RCSSortFilterProxyModel(True)
self.activeRaceProxyModel.setDynamicSortFilter(True)
self.activeRaceProxyModel.setSourceModel(self.model)
self.activeRaceTable = QtWidgets.QTableView()
self.activeRaceTable.setModel(self.activeRaceProxyModel)
self.activeRaceTable.setSizeAdjustPolicy(
QtWidgets.QAbstractScrollArea.AdjustToContents)
self.activeRaceTable.horizontalHeader().setStretchLastSection(True)
self.activeRaceTable.horizontalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.ResizeToContents)
self.activeRaceTable.setSelectionBehavior(
QtWidgets.QTableView.SelectRows)
self.activeRaceTable.setSelectionMode(
QtWidgets.QTableView.SingleSelection)
layout.addWidget(self.activeRaceTable, 1, 0)
self.standbyRaceProxyModel = RCSSortFilterProxyModel(False)
self.standbyRaceProxyModel.setDynamicSortFilter(True)
self.standbyRaceProxyModel.setSourceModel(self.model)
self.standbyRaceTable = QtWidgets.QTableView()
self.standbyRaceTable.setModel(self.standbyRaceProxyModel)
self.standbyRaceTable.setSizeAdjustPolicy(
QtWidgets.QAbstractScrollArea.AdjustToContents)
self.standbyRaceTable.horizontalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.ResizeToContents)
self.standbyRaceTable.horizontalHeader().setStretchLastSection(True)
self.standbyRaceTable.setSelectionBehavior(
QtWidgets.QTableView.SelectRows)
self.standbyRaceTable.setSelectionMode(
QtWidgets.QTableView.SingleSelection)
layout.addWidget(self.standbyRaceTable, 1, 1)
self.activeRaceTableLabel = QLabel("Active Race Table")
self.activeRaceTableLabel.setAlignment(Qt.AlignCenter)
self.standbyRaceTableLabel = QLabel("Other Teams Table")
self.standbyRaceTableLabel.setAlignment(Qt.AlignCenter)
layout.addWidget(self.activeRaceTableLabel, 0, 0)
layout.addWidget(self.standbyRaceTableLabel, 0, 1)
self.standbyRaceTable.setSortingEnabled(True)
self.standbyRaceTable.sortByColumn(1, Qt.AscendingOrder)
self.activeRaceTable.setSortingEnabled(True)
self.activeRaceTable.sortByColumn(1, Qt.AscendingOrder)
self.selectedIndex = None
self.standbyRaceTable.selectionModel().selectionChanged.connect(
self.standby_race_table_selection_handler)
self.activeRaceTable.selectionModel().selectionChanged.connect(
self.active_race_table_selection_handler)
self.horizontalGroupBox = QGroupBox("")
self.horizontalGroupBox.setLayout(layout)
# All relevant buttons in sidebar
self.button_sidebar_vBox = QVBoxLayout()
layout.addLayout(self.button_sidebar_vBox, 1, 3)
self.button_sidebar_vBox.setAlignment(Qt.AlignTop)
# Move Racers Buttons
self.button_container_stylesheet = "QWidget#ButtonContainer{background-color: rgb(200, 200, 200);\n border-radius: 5;\n}"
move_racers_button_container = QWidget()
move_racers_button_container.setObjectName("ButtonContainer")
move_racers_button_container.setStyleSheet(
self.button_container_stylesheet)
move_racers_button_container.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
move_racers_layout = QVBoxLayout(move_racers_button_container)
move_racers_layout.addWidget(QLabel("ADMIN CONTROLS"))
move_to_active_race_button = QPushButton("Move to Active Race")
move_to_active_race_button.clicked.connect(self.move_to_active_race)
move_racers_layout.addWidget(move_to_active_race_button)
remove_from_active_race_button = QPushButton("Remove from Active Race")
remove_from_active_race_button.clicked.connect(
self.remove_from_active_race)
move_racers_layout.addWidget(remove_from_active_race_button)
self.button_sidebar_vBox.addWidget(move_racers_button_container)
# Team State Control Buttons
team_state_button_container = QWidget()
team_state_button_container.setObjectName("ButtonContainer")
team_state_button_container.setStyleSheet(
self.button_container_stylesheet)
team_state_button_container.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
team_state_btns = self.create_team_state_buttons()
team_state_layout = QVBoxLayout(team_state_button_container)
team_state_layout.addWidget(QLabel("TEAM CONTROLS"))
for btn in team_state_btns:
team_state_layout.addWidget(btn)
self.button_sidebar_vBox.addWidget(team_state_button_container)
# Race State Control Buttons
race_state_button_container = QWidget()
race_state_button_container.setObjectName("ButtonContainer")
race_state_button_container.setStyleSheet(
self.button_container_stylesheet)
race_state_button_container.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
race_state_btns = self.create_race_state_buttons()
race_state_layout = QVBoxLayout(race_state_button_container)
race_state_layout.addWidget(QLabel("RACE CONTROLS"))
for btn in race_state_btns:
race_state_layout.addWidget(btn)
self.button_sidebar_vBox.addWidget(race_state_button_container)
self.info_group_box = QGroupBox("Race Status Information")
self.race_state_label = QLabel("Race State: IN_GARAGE")
self.info_label = QLabel("Race Status: No Race running.")
info_layout = QVBoxLayout()
info_layout.addWidget(self.race_state_label)
info_layout.addWidget(self.info_label)
self.info_group_box.setLayout(info_layout)
layout.addWidget(self.info_group_box, 3, 0)
self.buttonController = ButtonStateController(
race_state_btns[0], race_state_btns[1], race_state_btns[2],
race_state_btns[3], race_state_btns[4], team_state_btns[0],
move_to_active_race_button, remove_from_active_race_button,
self.race_state_label, self.info_label)
self.model.race_state_change_signal.connect(
self.buttonController.race_state_updated)
verticalSpacer = QtWidgets.QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
layout.addItem(verticalSpacer, 4, 0, rowSpan=1, columnSpan=3)
self.create_menu_bar()
# wait for start of server
self.server_wait_label = QLabel(
"Waiting for TCP Server to start. Please hold on.")
self.server_wait_label.setAlignment(Qt.AlignCenter)
self.setCentralWidget(self.server_wait_label)
self.start_server()
# Make sure we stop the server on window close
def closeEvent(self, event):
self.stop_server()
event.accept()
def create_menu_bar(self):
menuBar = QtWidgets.QMenuBar(self)
self.setMenuBar(menuBar)
helpMenu = menuBar.addMenu("&Help")
self.reset_gui_buttons_actions = QtWidgets.QAction("Reset GUI buttons")
self.reset_gui_buttons_actions.triggered.connect(
self.buttonController.enable_all_buttons)
helpMenu.addAction(self.reset_gui_buttons_actions)
self.about_action = QtWidgets.QAction("About")
self.about_action.triggered.connect(self.show_about_message)
helpMenu.addAction(self.about_action)
def show_about_message(self):
text = "The Electric Vehicle GrandPrix Autonomous Race Control System " \
"is brought to you by the RoboJackets at Georgia Tech.<br>" \
"Contribute to the RCS at <a href='https://github.com/RoboJackets/evgp-rcs'>https://github.com/RoboJackets/evgp-rcs</a>"
QMessageBox.question(self, 'About the EVGP Race Control System', text,
QMessageBox.Ok)
def create_race_state_buttons(self):
grid_active_race_button = QPushButton("GRID ACTIVE RACE")
grid_active_race_button.clicked.connect(
lambda: self.race_state_change_callback(RaceState.GRID_ACTIVE))
start_race_button = QPushButton("START RACE")
start_race_button.setEnabled(False)
start_race_button.clicked.connect(
lambda: self.race_state_change_callback(RaceState.GREEN_GREEN))
red_flag_race_button = QPushButton("RED FLAG RACE")
red_flag_race_button.clicked.connect(
lambda: self.race_state_change_callback(RaceState.RED_FLAG))
e_stop_race_button = QPushButton("E-STOP RACE")
e_stop_race_button.clicked.connect(
lambda: self.race_state_change_callback(RaceState.RED_RED))
finish_race_button = QPushButton("FINISH RACE")
finish_race_button.clicked.connect(
lambda: self.race_state_change_callback(RaceState.IN_GARAGE))
return [
grid_active_race_button, start_race_button, red_flag_race_button,
e_stop_race_button, finish_race_button
]
def create_team_state_buttons(self):
in_garage_team_button = QPushButton("IN GARAGE TEAM")
in_garage_team_button.clicked.connect(
lambda: self.team_state_change_callback(RaceState.IN_GARAGE))
red_flag_team_button = QPushButton("RED FLAG TEAM")
red_flag_team_button.clicked.connect(
lambda: self.team_state_change_callback(RaceState.RED_FLAG))
e_stop_team_button = QPushButton("E-STOP TEAM")
e_stop_team_button.clicked.connect(
lambda: self.team_state_change_callback(RaceState.RED_RED))
return [
in_garage_team_button, red_flag_team_button, e_stop_team_button
]
def team_state_change_callback(self, state):
if self.selectedIndex is not None:
self.model.team_state_change(self.selectedIndex, state)
def race_state_change_callback(self, state):
self.model.race_state_change(state)
def move_to_active_race(self):
if self.selectedIndex is not None:
changed = self.model.move_to_active_race(self.selectedIndex)
if changed:
self.clearAllSelections()
def remove_from_active_race(self):
if self.selectedIndex is not None:
changed = self.model.move_to_standby_race(self.selectedIndex)
if changed:
self.clearAllSelections()
def start_server(self):
if not self.is_server_started:
self.is_server_started = True
port = 12017
server_backlog = 10
send_hz = 10
ip_list = self.model.teams_list.keys()
self.server = TCPServer(port,
server_backlog,
whitelist=ip_list,
hz=send_hz)
self.server.new_connection.connect(
self.model.new_connection_handler)
self.server.lost_connection.connect(
self.model.lost_connection_handler)
self.server.new_response.connect(self.model.new_response_handler)
self.server.server_ready.connect(self.server_ready_handler)
self.model.team_state_change_signal.connect(
self.server.on_race_state_change)
self.server_thread = QThread()
self.server.moveToThread(self.server_thread)
self.server_thread.started.connect(self.server.run_server)
self.server_thread.start()
def stop_server(self):
if self.is_server_started:
self.server.stop()
self.is_server_started = False
self.server_thread.quit()
@QtCore.pyqtSlot(bool)
def server_ready_handler(self, isReady):
if isReady:
self.setCentralWidget(self.horizontalGroupBox)
if not isReady:
self.server_wait_label.setText(
"Server Error: Please restart program.")
QMessageBox.question(
self, 'Server Error',
"Server failed to start.\nPress \"Close\" to quit program, then fix your network issues and restart this program.",
QMessageBox.Close)
self.close()
@QtCore.pyqtSlot(QItemSelection, QItemSelection)
def standby_race_table_selection_handler(self, filterTableSelection,
filterTableDeselected):
if filterTableSelection.indexes():
self.activeRaceTable.selectionModel().clearSelection()
self.selectedIndex = self.standbyRaceProxyModel.mapToSource(
filterTableSelection.indexes()[0]).row()
@QtCore.pyqtSlot(QItemSelection, QItemSelection)
def active_race_table_selection_handler(self, tableSelection,
tableDeselected):
if tableSelection.indexes():
self.standbyRaceTable.selectionModel().clearSelection()
self.selectedIndex = self.activeRaceProxyModel.mapToSource(
tableSelection.indexes()[0]).row()
def clearAllSelections(self):
self.activeRaceTable.selectionModel().clearSelection()
self.standbyRaceTable.selectionModel().clearSelection()
self.selectedIndex = None
# An example showing the use of httpserver.TCPServer
# Reverses the data received from the client and send it back
import sys
# Import httpserver in the python import path
sys.path.insert(0, "./httpserver")
from tcpserver import TCPServer
def reverse_data(queue, data):
queue.put(data[::-1])
print(data)
if __name__ == '__main__':
server = TCPServer('127.0.0.1', 8000, callback=reverse_data)
server.start()
server.run()
class MyApp(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
super(QtWidgets.QMainWindow, self).__init__()
self.status_message = ['● Idle', '● Idle', '● Idle', '']
config_file = Path('config.json')
# config_file = open('config.json', 'w+')
if config_file.exists():
self.config = json.load(open('config.json', 'r'))
else:
self.config = dict()
json.dump(self.config, open('config.json', 'w+'))
"""Load UI"""
self.ui = uic.loadUi('mainwindow.ui', self)
self.init_ui()
self.ui.comboBox_Interface.currentIndexChanged.connect(
self.on_interface_selection_change)
self.ui.button_Refresh.clicked.connect(self.on_refresh_button_clicked)
self.ui.button_TcpClient.clicked.connect(
self.on_tcp_client_connect_button_clicked
)
self.ui.button_TcpClientSend.clicked.connect(
self.on_tcp_client_message_send
)
self.ui.lineEdit_TcpClientSend.returnPressed.connect(
self.on_tcp_client_message_send
)
self.ui.button_TcpServer.clicked.connect(
self.on_tcp_server_start_stop_button_clicked)
self.ui.button_TcpServerSend.clicked.connect(
self.on_tcp_server_message_send
)
self.ui.lineEdit_TcpServerSend.returnPressed.connect(
self.on_tcp_server_message_send
)
self.ui.button_Udp.clicked.connect(
self.on_udp_server_start_stop_button_clicked
)
self.ui.button_UdpSend.clicked.connect(
self.on_udp_message_send
)
self.ui.lineEdit_UdpSend.returnPressed.connect(
self.on_udp_message_send
)
self.udp_send = UDPServer(
'0.0.0.0',
1234)
self.ui.tabWidget.currentChanged.connect(
self.on_tab_changed
)
def save_config(self):
try:
json.dump(self.config, open('config.json', 'w+'))
except PermissionError as err:
pass
def init_ui(self):
# Interface
self.update_network_interfaces()
self.ui.tabWidget.setCurrentIndex(self.config.get('Tab_Index', 0))
self.on_tab_changed(self.config.get('Tab_Index', 0))
# TCP Client
self.ui.textBrowser_TcpClientMessage.setEnabled(False)
self.ui.lineEdit_TcpClientSend.setEnabled(False)
self.ui.button_TcpClientSend.setEnabled(False)
tcp_client_ip = self.config.get('TCP_Client_IP', '127.0.0.1')
tcp_client_port = self.config.get('TCP_Client_Port', '1234')
self.ui.lineEdit_TcpClientTargetIP.setText(tcp_client_ip)
self.ui.lineEdit_TcpClientTargetPort.setText(tcp_client_port)
# TCP Server
self.ui.textBrowser_TcpServerMessage.setEnabled(False)
self.ui.lineEdit_TcpServerSend.setEnabled(False)
self.ui.button_TcpServerSend.setEnabled(False)
tcp_server_port = self.config.get('TCP_Server_Port', '1234')
self.ui.lineEdit_TcpServerListenPort.setText(tcp_server_port)
# UDP
udp_listen_port = self.config.get('UDP_Listen_Port', '1234')
udp_target_ip = self.config.get('UDP_Target_IP', '127.0.0.1')
udp_target_port = self.config.get('UDP_Target_Port', '1234')
self.ui.lineEdit_UdpListenPort.setText(udp_listen_port)
self.ui.lineEdit_UdpTargetIP.setText(udp_target_ip)
self.ui.lineEdit_UdpTargetPort.setText(udp_target_port)
def update_network_interfaces(self):
self.ui.comboBox_Interface.clear()
self.net_if = psutil.net_if_addrs()
net_if_stats = psutil.net_if_stats()
net_names = list(self.net_if.keys())
for if_name in net_names:
if not net_if_stats[if_name].isup:
self.net_if.pop(if_name, None)
else:
self.ui.comboBox_Interface.addItem(if_name)
interface_idx = self.config.get('Interface', 0)
if interface_idx >= self.ui.comboBox_Interface.count():
self.ui.comboBox_Interface.setCurrentIndex(0)
else:
self.ui.comboBox_Interface.setCurrentIndex(interface_idx)
current_interface = self.ui.comboBox_Interface.currentText()
self.config['Interface'] = self.ui.comboBox_Interface.currentIndex()
for snicaddr in self.net_if[current_interface]:
if snicaddr.family == socket.AF_INET:
ipv4_add = snicaddr.address
break
else:
ipv4_add = '0.0.0.0'
self.ui.label_LocalIP.setText(ipv4_add)
self.save_config()
def on_interface_selection_change(self):
current_interface = self.ui.comboBox_Interface.currentText()
if current_interface in self.net_if:
for snicaddr in self.net_if[current_interface]:
if snicaddr.family == socket.AF_INET:
ipv4_add = snicaddr.address
break
else:
ipv4_add = '0.0.0.0'
else:
return
self.ui.label_LocalIP.setText(ipv4_add)
self.config['Interface'] = self.ui.comboBox_Interface.currentIndex()
self.save_config()
def on_refresh_button_clicked(self):
self.update_network_interfaces()
# TCP Client
def on_tcp_client_connect_button_clicked(self):
if self.ui.button_TcpClient.text() == 'Connect':
self.ui.button_TcpClient.setEnabled(False)
self.ui.lineEdit_TcpClientTargetIP.setEnabled(False)
self.ui.lineEdit_TcpClientTargetPort.setEnabled(False)
self.tcp_client_thread = QThread()
self.tcp_client = TCPClient(
self.ui.label_LocalIP.text(),
int(self.ui.lineEdit_TcpClientTargetPort.text()))
self.tcp_client_thread.started.connect(self.tcp_client.start)
self.tcp_client.status.connect(self.on_tcp_client_status_update)
self.tcp_client.message.connect(self.on_tcp_client_message_ready)
self.tcp_client.moveToThread(self.tcp_client_thread)
self.tcp_client_thread.start()
self.config['TCP_Client_IP'] = self.ui.label_LocalIP.text()
self.config['TCP_Client_Port'] = self.ui.lineEdit_TcpClientTargetPort.text()
self.save_config()
elif self.ui.button_TcpClient.text() == 'Disconnect':
self.ui.button_TcpClient.setEnabled(False)
self.tcp_client.close()
def on_tcp_client_status_update(self, status, addr):
if status == TCPClient.STOP:
self.tcp_client.status.disconnect()
self.tcp_client.message.disconnect()
self.ui.button_TcpClient.setText('Connect')
self.tcp_client_thread.quit()
self.ui.lineEdit_TcpClientTargetIP.setEnabled(True)
self.ui.lineEdit_TcpClientTargetPort.setEnabled(True)
self.ui.textBrowser_TcpClientMessage.setEnabled(False)
self.ui.lineEdit_TcpClientSend.setEnabled(False)
self.ui.button_TcpClientSend.setEnabled(False)
self.status_message[0] = '● Idle'
if self.ui.tabWidget.currentIndex() == 0:
self.on_tab_changed(0)
elif status == TCPClient.CONNECTED:
self.ui.button_TcpClient.setText('Disconnect')
self.ui.textBrowser_TcpClientMessage.setEnabled(True)
self.ui.lineEdit_TcpClientSend.setEnabled(True)
self.ui.button_TcpClientSend.setEnabled(True)
self.status_message[0] = '● Connected to ' +\
self.ui.label_LocalIP.text() +\
':'+self.ui.lineEdit_TcpClientTargetPort.text()
if self.ui.tabWidget.currentIndex() == 0:
self.on_tab_changed(0)
self.ui.button_TcpClient.setEnabled(True)
def on_tcp_client_message_ready(self, source, msg):
self.ui.textBrowser_TcpClientMessage.append(
'<p style="text-align: center;"><span style="color: #2196F3;"><strong>----- ' +
source +
' -----</strong></span></p>')
self.ui.textBrowser_TcpClientMessage.append(
'<p style="text-align: center;"><span style="color: #2196F3;">' +
msg +
'</span></p>')
def on_tcp_client_message_send(self):
self.tcp_client.send(self.ui.lineEdit_TcpClientSend.text())
self.ui.textBrowser_TcpClientMessage.append(
'<p style="text-align: center;"><strong>----- ' +
'this' +
' -----</strong></p>')
self.ui.textBrowser_TcpClientMessage.append(
'<p style="text-align: center;">' +
self.ui.lineEdit_TcpClientSend.text() +
'</p>')
self.ui.lineEdit_TcpClientSend.clear()
# TCP Server
def on_tcp_server_start_stop_button_clicked(self):
if self.ui.button_TcpServer.text() == 'Start':
self.ui.button_TcpServer.setEnabled(False)
self.ui.lineEdit_TcpServerListenPort.setEnabled(False)
self.tcp_server_thread = QThread()
self.tcp_server = TCPServer(
self.ui.label_LocalIP.text(),
int(self.ui.lineEdit_TcpServerListenPort.text()))
self.tcp_server_thread.started.connect(self.tcp_server.start)
self.tcp_server.status.connect(self.on_tcp_server_status_update)
self.tcp_server.message.connect(self.on_tcp_server_message_ready)
self.tcp_server.moveToThread(self.tcp_server_thread)
self.tcp_server_thread.start()
self.config['TCP_Server_Port'] = self.ui.lineEdit_TcpServerListenPort.text()
self.save_config()
elif self.ui.button_TcpServer.text() == 'Stop':
self.ui.button_TcpServer.setEnabled(False)
self.tcp_server.close()
elif self.ui.button_TcpServer.text() == 'Disconnect':
self.ui.button_TcpServer.setEnabled(False)
self.tcp_server.disconnect()
def on_tcp_server_status_update(self, status, addr):
if status == TCPServer.STOP:
self.tcp_server.status.disconnect()
self.tcp_server.message.disconnect()
self.ui.button_TcpServer.setText('Start')
self.tcp_server_thread.quit()
self.ui.textBrowser_TcpServerMessage.setEnabled(False)
self.ui.lineEdit_TcpServerSend.setEnabled(False)
self.ui.button_TcpServerSend.setEnabled(False)
self.ui.lineEdit_TcpServerListenPort.setEnabled(True)
self.status_message[1] = '● Idle'
if self.ui.tabWidget.currentIndex() == 1:
self.on_tab_changed(1)
elif status == TCPServer.LISTEN:
self.ui.button_TcpServer.setText('Stop')
self.ui.textBrowser_TcpServerMessage.setEnabled(False)
self.ui.lineEdit_TcpServerSend.setEnabled(False)
self.ui.button_TcpServerSend.setEnabled(False)
self.status_message[1] = '● Listen on ' +\
self.ui.label_LocalIP.text()+':' +\
self.ui.lineEdit_TcpServerListenPort.text()
if self.ui.tabWidget.currentIndex() == 1:
self.on_tab_changed(1)
elif status == TCPServer.CONNECTED:
self.ui.button_TcpServer.setText('Disconnect')
self.ui.textBrowser_TcpServerMessage.setEnabled(True)
self.ui.lineEdit_TcpServerSend.setEnabled(True)
self.ui.button_TcpServerSend.setEnabled(True)
self.status_message[1] = '● Connected to '+addr
if self.ui.tabWidget.currentIndex() == 1:
self.on_tab_changed(1)
# self.tcp_server.send('Hello World')
self.ui.button_TcpServer.setEnabled(True)
def on_tcp_server_message_ready(self, source, msg):
self.ui.textBrowser_TcpServerMessage.append(
'<p style="text-align: center;"><span style="color: #2196F3;"><strong>----- ' +
source +
' -----</strong></span></p>')
self.ui.textBrowser_TcpServerMessage.append(
'<p style="text-align: center;"><span style="color: #2196F3;">' +
msg +
'</span></p>')
def on_tcp_server_message_send(self):
self.tcp_server.send(self.ui.lineEdit_TcpServerSend.text())
self.ui.textBrowser_TcpServerMessage.append(
'<p style="text-align: center;"><strong>----- ' +
'this' +
' -----</strong></p>')
self.ui.textBrowser_TcpServerMessage.append(
'<p style="text-align: center;">' +
self.ui.lineEdit_TcpServerSend.text() +
'</p>')
self.ui.lineEdit_TcpServerSend.clear()
# UDP
def on_udp_server_start_stop_button_clicked(self):
if self.ui.button_Udp.text() == 'Start':
self.ui.button_Udp.setEnabled(False)
self.ui.lineEdit_UdpListenPort.setEnabled(False)
self.udp_thread = QThread()
self.udp_server = UDPServer(
self.ui.label_LocalIP.text(),
int(self.ui.lineEdit_UdpListenPort.text()))
self.udp_thread.started.connect(self.udp_server.start)
self.udp_server.status.connect(self.on_udp_server_status_update)
self.udp_server.message.connect(self.on_udp_server_message_ready)
self.udp_server.moveToThread(self.udp_thread)
self.udp_thread.start()
self.config['UDP_Listen_Port'] = self.ui.lineEdit_UdpListenPort.text()
self.save_config()
elif self.ui.button_Udp.text() == 'Stop':
self.ui.button_Udp.setEnabled(False)
self.udp_server.close()
def on_udp_server_status_update(self, status, addr):
if status == UDPServer.STOP:
self.udp_server.status.disconnect()
self.udp_server.message.disconnect()
self.ui.button_Udp.setText('Start')
# self.tcp_server_thread.terminate()
self.udp_thread.quit()
self.ui.lineEdit_UdpListenPort.setEnabled(True)
self.status_message[2] = '● Idle'
if self.ui.tabWidget.currentIndex() == 2:
self.on_tab_changed(2)
elif status == UDPServer.LISTEN:
self.ui.button_Udp.setText('Stop')
self.status_message[2] = '● Listen on ' +\
self.ui.label_LocalIP.text()+':' +\
self.ui.lineEdit_TcpServerListenPort.text()
if self.ui.tabWidget.currentIndex() == 2:
self.on_tab_changed(2)
self.ui.button_Udp.setEnabled(True)
def on_udp_server_message_ready(self, source, msg):
self.ui.textBrowser_UdpMessage.append(
'<p style="text-align: center;"><span style="color: #2196F3;"><strong>----- ' +
source +
' -----</strong></span></p>')
self.ui.textBrowser_UdpMessage.append(
'<p style="text-align: center;"><span style="color: #2196F3;">' +
msg +
'</span></p>')
def on_udp_message_send(self):
self.udp_send.send(
self.ui.lineEdit_UdpSend.text(),
self.ui.lineEdit_UdpTargetIP.text(),
int(self.ui.lineEdit_UdpTargetPort.text())
)
self.ui.textBrowser_UdpMessage.append(
'<p style="text-align: center;"><strong>----- ' +
'this' +
' -----</strong></p>')
self.ui.textBrowser_UdpMessage.append(
'<p style="text-align: center;">' +
self.ui.lineEdit_UdpSend.text() +
'</p>')
self.ui.lineEdit_UdpSend.clear()
self.config['UDP_Target_IP'] = self.ui.lineEdit_UdpTargetIP.text()
self.config['UDP_Target_Port'] = self.ui.lineEdit_UdpTargetPort.text()
self.save_config()
def on_tab_changed(self, index):
self.ui.statusBar.clearMessage()
self.ui.statusBar.setStyleSheet('color: green')
self.ui.statusBar.showMessage(self.status_message[index])
self.config['Tab_Index'] = self.ui.tabWidget.currentIndex()
self.save_config()
